From 181e7f1869a4d6a5a0333f00414f2847db811e6f Mon Sep 17 00:00:00 2001 From: MarcusLongmuir Date: Mon, 27 Jan 2025 17:23:36 +0000 Subject: [PATCH] deploy: e27d50267d8b493d1e9479ec6e755ec982c825b6 --- pull/212/index.html | 1 + .../212/v1/PlayCanvasModeInternal-6JRQ32LR.js | 57531 ++++++++++++++++ .../v1/PlayCanvasModeInternal-6JRQ32LR.js.map | 7 + pull/212/v1/ThreeJSModeInternal-OES4PZ5X.js | 34003 +++++++++ .../v1/ThreeJSModeInternal-OES4PZ5X.js.map | 7 + pull/212/v1/chunk-CPWJBFSW.js | 78 + pull/212/v1/chunk-CPWJBFSW.js.map | 7 + pull/212/v1/chunk-OGDCF6KN.js | 9500 +++ pull/212/v1/chunk-OGDCF6KN.js.map | 7 + pull/212/v1/cloudysky_2k-WS2HEI54.jpg | Bin 0 -> 201967 bytes pull/212/v1/favicon.svg | 5 + pull/212/v1/github-mark-white-DC6LPEI2.svg | 1 + pull/212/v1/index.css | 302 + pull/212/v1/index.css.map | 7 + pull/212/v1/index.html | 10 + pull/212/v1/index.js | 781 + pull/212/v1/index.js.map | 7 + pull/212/v1/mml-logotype-white-YIZ3ZTFD.svg | 8 + 18 files changed, 102262 insertions(+) create mode 100644 pull/212/index.html create mode 100644 pull/212/v1/PlayCanvasModeInternal-6JRQ32LR.js create mode 100644 pull/212/v1/PlayCanvasModeInternal-6JRQ32LR.js.map create mode 100644 pull/212/v1/ThreeJSModeInternal-OES4PZ5X.js create mode 100644 pull/212/v1/ThreeJSModeInternal-OES4PZ5X.js.map create mode 100644 pull/212/v1/chunk-CPWJBFSW.js create mode 100644 pull/212/v1/chunk-CPWJBFSW.js.map create mode 100644 pull/212/v1/chunk-OGDCF6KN.js create mode 100644 pull/212/v1/chunk-OGDCF6KN.js.map create mode 100644 pull/212/v1/cloudysky_2k-WS2HEI54.jpg create mode 100644 pull/212/v1/favicon.svg create mode 100644 pull/212/v1/github-mark-white-DC6LPEI2.svg create mode 100644 pull/212/v1/index.css create mode 100644 pull/212/v1/index.css.map create mode 100644 pull/212/v1/index.html create mode 100644 pull/212/v1/index.js create mode 100644 pull/212/v1/index.js.map create mode 100644 pull/212/v1/mml-logotype-white-YIZ3ZTFD.svg diff --git a/pull/212/index.html b/pull/212/index.html new file mode 100644 index 00000000..e56e1ef7 --- /dev/null +++ b/pull/212/index.html @@ -0,0 +1 @@ + diff --git a/pull/212/v1/PlayCanvasModeInternal-6JRQ32LR.js b/pull/212/v1/PlayCanvasModeInternal-6JRQ32LR.js new file mode 100644 index 00000000..d1b49697 --- /dev/null +++ b/pull/212/v1/PlayCanvasModeInternal-6JRQ32LR.js @@ -0,0 +1,57531 @@ +import { + calculateContentBounds, + envMaps, + parseXYZ +} from "./chunk-CPWJBFSW.js"; +import { + Audio as Audio2, + AudioGraphics, + CanvasText, + ChatProbeGraphics, + CubeGraphics, + CylinderGraphics, + DebugHelperGraphics, + EventHandlerCollection, + FrameGraphics, + FullScreenMMLScene, + Image as Image2, + ImageGraphics, + InteractionGraphics, + LabelGraphics, + LightGraphics, + LinkGraphics, + LoadingInstanceManager, + MELEMENT_PROPERTY_NAME, + MElement, + MElementGraphics, + MMLNetworkSource, + Matr4, + Model, + ModelGraphics, + NetworkedDOMWebsocketStatus, + NetworkedDOMWebsocketStatusToString, + PlaneGraphics, + PositionProbeGraphics, + PromptGraphics, + Quat, + RemoteDocumentGraphics, + SphereGraphics, + StaticFileVideoSource, + StatusUI, + TransformableElement, + TransformableGraphics, + Vect3, + VideoGraphics, + WHEPVideoSource, + ambientLightColorField, + ambientLightField, + backgroundColorField, + calculateContentSize, + cameraFitContents, + cameraFovField, + cameraLookAtField, + cameraModeField, + cameraOrbitDistanceField, + cameraOrbitPitchField, + cameraOrbitSpeedField, + cameraPositionField, + environmentMapField, + getRelativePositionAndRotationRelativeToObject, + parseColorAttribute, + setDebugGlobals +} from "./chunk-OGDCF6KN.js"; + +// ../../node_modules/playcanvas/build/playcanvas/src/core/constants.js +var TRACEID_GPU_TIMINGS = "GpuTimings"; + +// ../../node_modules/playcanvas/build/playcanvas/src/core/core.js +var version = "1.73.5"; +var revision = "26a4396"; +var typeofs = ["undefined", "number", "string", "boolean"]; +var objectTypes = { + "[object Array]": "array", + "[object Object]": "object", + "[object Function]": "function", + "[object Date]": "date", + "[object RegExp]": "regexp", + "[object Float32Array]": "float32array" +}; +function type(obj) { + if (obj === null) { + return "null"; + } + const typeString = typeof obj; + if (typeofs.includes(typeString)) { + return typeString; + } + return objectTypes[Object.prototype.toString.call(obj)]; +} +function extend(target2, ex) { + for (const prop in ex) { + const copy = ex[prop]; + if (type(copy) === "object") { + target2[prop] = extend({}, copy); + } else if (type(copy) === "array") { + target2[prop] = extend([], copy); + } else { + target2[prop] = copy; + } + } + return target2; +} + +// ../../node_modules/playcanvas/build/playcanvas/src/core/event-handle.js +var EventHandle = class { + constructor(handler, name, callback, scope, once = false) { + this.handler = void 0; + this.name = void 0; + this.callback = void 0; + this.scope = void 0; + this._once = void 0; + this._removed = false; + this.handler = handler; + this.name = name; + this.callback = callback; + this.scope = scope; + this._once = once; + } + off() { + if (this._removed) return; + this.handler.off(this.name, this.callback, this.scope); + } + on(name, callback, scope = this) { + return this.handler._addCallback(name, callback, scope, false); + } + once(name, callback, scope = this) { + return this.handler._addCallback(name, callback, scope, true); + } + set removed(value) { + if (!value) return; + this._removed = true; + } + get removed() { + return this._removed; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/core/event-handler.js +var EventHandler = class { + constructor() { + this._callbacks = /* @__PURE__ */ new Map(); + this._callbackActive = /* @__PURE__ */ new Map(); + } + initEventHandler() { + this._callbacks = /* @__PURE__ */ new Map(); + this._callbackActive = /* @__PURE__ */ new Map(); + } + _addCallback(name, callback, scope, once) { + if (!this._callbacks.has(name)) this._callbacks.set(name, []); + if (this._callbackActive.has(name)) { + const callbackActive = this._callbackActive.get(name); + if (callbackActive && callbackActive === this._callbacks.get(name)) { + this._callbackActive.set(name, callbackActive.slice()); + } + } + const evt = new EventHandle(this, name, callback, scope, once); + this._callbacks.get(name).push(evt); + return evt; + } + on(name, callback, scope = this) { + return this._addCallback(name, callback, scope, false); + } + once(name, callback, scope = this) { + return this._addCallback(name, callback, scope, true); + } + off(name, callback, scope) { + if (name) { + if (this._callbackActive.has(name) && this._callbackActive.get(name) === this._callbacks.get(name)) this._callbackActive.set(name, this._callbackActive.get(name).slice()); + } else { + for (const [key, callbacks] of this._callbackActive) { + if (!this._callbacks.has(key)) continue; + if (this._callbacks.get(key) !== callbacks) continue; + this._callbackActive.set(key, callbacks.slice()); + } + } + if (!name) { + for (const callbacks of this._callbacks.values()) { + for (let i = 0; i < callbacks.length; i++) { + callbacks[i].removed = true; + } + } + this._callbacks.clear(); + } else if (!callback) { + const callbacks = this._callbacks.get(name); + if (callbacks) { + for (let i = 0; i < callbacks.length; i++) { + callbacks[i].removed = true; + } + this._callbacks.delete(name); + } + } else { + const callbacks = this._callbacks.get(name); + if (!callbacks) return this; + for (let i = 0; i < callbacks.length; i++) { + if (callbacks[i].callback !== callback) continue; + if (scope && callbacks[i].scope !== scope) continue; + callbacks[i].removed = true; + callbacks.splice(i, 1); + i--; + } + if (callbacks.length === 0) this._callbacks.delete(name); + } + return this; + } + fire(name, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) { + if (!name) return this; + const callbacksInitial = this._callbacks.get(name); + if (!callbacksInitial) return this; + let callbacks; + if (!this._callbackActive.has(name)) { + this._callbackActive.set(name, callbacksInitial); + } else if (this._callbackActive.get(name) !== callbacksInitial) { + callbacks = callbacksInitial.slice(); + } + for (let i = 0; (callbacks || this._callbackActive.get(name)) && i < (callbacks || this._callbackActive.get(name)).length; i++) { + const evt = (callbacks || this._callbackActive.get(name))[i]; + if (!evt.callback) continue; + evt.callback.call(evt.scope, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); + if (evt._once) { + const existingCallback = this._callbacks.get(name); + const ind = existingCallback ? existingCallback.indexOf(evt) : -1; + if (ind !== -1) { + if (this._callbackActive.get(name) === existingCallback) this._callbackActive.set(name, this._callbackActive.get(name).slice()); + const _callbacks = this._callbacks.get(name); + if (!_callbacks) continue; + _callbacks[ind].removed = true; + _callbacks.splice(ind, 1); + if (_callbacks.length === 0) this._callbacks.delete(name); + } + } + } + if (!callbacks) this._callbackActive.delete(name); + return this; + } + hasEvent(name) { + var _this$_callbacks$get; + return !!((_this$_callbacks$get = this._callbacks.get(name)) != null && _this$_callbacks$get.length); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/core/events.js +var events = { + attach(target2) { + const ev = events; + target2._addCallback = ev._addCallback; + target2.on = ev.on; + target2.off = ev.off; + target2.fire = ev.fire; + target2.once = ev.once; + target2.hasEvent = ev.hasEvent; + EventHandler.prototype.initEventHandler.call(target2); + return target2; + }, + _addCallback: EventHandler.prototype._addCallback, + on: EventHandler.prototype.on, + off: EventHandler.prototype.off, + fire: EventHandler.prototype.fire, + once: EventHandler.prototype.once, + hasEvent: EventHandler.prototype.hasEvent +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/core/guid.js +var guid = { + create() { + return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c2) { + const r = Math.random() * 16 | 0; + const v = c2 === "x" ? r : r & 3 | 8; + return v.toString(16); + }); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/core/path.js +var path = { + delimiter: "/", + join(...sections) { + let result = sections[0]; + for (let i = 0; i < sections.length - 1; i++) { + const one = sections[i]; + const two = sections[i + 1]; + if (two[0] === path.delimiter) { + result = two; + continue; + } + if (one && two && one[one.length - 1] !== path.delimiter && two[0] !== path.delimiter) { + result += path.delimiter + two; + } else { + result += two; + } + } + return result; + }, + normalize(pathname) { + const lead = pathname.startsWith(path.delimiter); + const trail = pathname.endsWith(path.delimiter); + const parts = pathname.split("/"); + let result = ""; + let cleaned = []; + for (let i = 0; i < parts.length; i++) { + if (parts[i] === "") continue; + if (parts[i] === ".") continue; + if (parts[i] === ".." && cleaned.length > 0) { + cleaned = cleaned.slice(0, cleaned.length - 2); + continue; + } + if (i > 0) cleaned.push(path.delimiter); + cleaned.push(parts[i]); + } + result = cleaned.join(""); + if (!lead && result[0] === path.delimiter) { + result = result.slice(1); + } + if (trail && result[result.length - 1] !== path.delimiter) { + result += path.delimiter; + } + return result; + }, + split(pathname) { + const lastDelimiterIndex = pathname.lastIndexOf(path.delimiter); + if (lastDelimiterIndex !== -1) { + return [pathname.substring(0, lastDelimiterIndex), pathname.substring(lastDelimiterIndex + 1)]; + } + return ["", pathname]; + }, + getBasename(pathname) { + return path.split(pathname)[1]; + }, + getDirectory(pathname) { + return path.split(pathname)[0]; + }, + getExtension(pathname) { + const ext = pathname.split("?")[0].split(".").pop(); + if (ext !== pathname) { + return "." + ext; + } + return ""; + }, + isRelativePath(pathname) { + return pathname.charAt(0) !== "/" && pathname.match(/:\/\//) === null; + }, + extractPath(pathname) { + let result = ""; + const parts = pathname.split("/"); + let i = 0; + if (parts.length > 1) { + if (path.isRelativePath(pathname)) { + if (parts[0] === ".") { + for (i = 0; i < parts.length - 1; ++i) { + result += i === 0 ? parts[i] : "/" + parts[i]; + } + } else if (parts[0] === "..") { + for (i = 0; i < parts.length - 1; ++i) { + result += i === 0 ? parts[i] : "/" + parts[i]; + } + } else { + result = "."; + for (i = 0; i < parts.length - 1; ++i) { + result += "/" + parts[i]; + } + } + } else { + for (i = 0; i < parts.length - 1; ++i) { + result += i === 0 ? parts[i] : "/" + parts[i]; + } + } + } + return result; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/core/platform.js +var _ref; +var _ref2; +var _ref3; +var detectPassiveEvents = () => { + let result = false; + try { + const opts = Object.defineProperty({}, "passive", { + get: function() { + result = true; + return false; + } + }); + window.addEventListener("testpassive", null, opts); + window.removeEventListener("testpassive", null, opts); + } catch (e) { + } + return result; +}; +var ua = typeof navigator !== "undefined" ? navigator.userAgent : ""; +var environment = typeof window !== "undefined" ? "browser" : typeof global !== "undefined" ? "node" : "worker"; +var platformName = /android/i.test(ua) ? "android" : /ip([ao]d|hone)/i.test(ua) ? "ios" : /windows/i.test(ua) ? "windows" : /mac os/i.test(ua) ? "osx" : /linux/i.test(ua) ? "linux" : /cros/i.test(ua) ? "cros" : null; +var browserName = environment !== "browser" ? null : /(Chrome\/|Chromium\/|Edg.*\/)/.test(ua) ? "chrome" : /Safari\//.test(ua) ? "safari" : /Firefox\//.test(ua) ? "firefox" : "other"; +var xbox = /xbox/i.test(ua); +var touch = environment === "browser" && ("ontouchstart" in window || "maxTouchPoints" in navigator && navigator.maxTouchPoints > 0); +var gamepads = environment === "browser" && (!!navigator.getGamepads || !!navigator.webkitGetGamepads); +var workers = typeof Worker !== "undefined"; +var passiveEvents = detectPassiveEvents(); +var platform = { + name: platformName, + environment, + global: (_ref = (_ref2 = (_ref3 = typeof globalThis !== "undefined" && globalThis) != null ? _ref3 : environment === "browser" && window) != null ? _ref2 : environment === "node" && global) != null ? _ref : environment === "worker" && self, + browser: environment === "browser", + worker: environment === "worker", + desktop: ["windows", "osx", "linux", "cros"].includes(platformName), + mobile: ["android", "ios"].includes(platformName), + ios: platformName === "ios", + android: platformName === "android", + xbox, + gamepads, + touch, + workers, + passiveEvents, + browserName +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/core/string.js +var ASCII_LOWERCASE = "abcdefghijklmnopqrstuvwxyz"; +var ASCII_UPPERCASE = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; +var ASCII_LETTERS = ASCII_LOWERCASE + ASCII_UPPERCASE; +var HIGH_SURROGATE_BEGIN = 55296; +var HIGH_SURROGATE_END = 56319; +var LOW_SURROGATE_BEGIN = 56320; +var LOW_SURROGATE_END = 57343; +var ZERO_WIDTH_JOINER = 8205; +var REGIONAL_INDICATOR_BEGIN = 127462; +var REGIONAL_INDICATOR_END = 127487; +var FITZPATRICK_MODIFIER_BEGIN = 127995; +var FITZPATRICK_MODIFIER_END = 127999; +var DIACRITICAL_MARKS_BEGIN = 8400; +var DIACRITICAL_MARKS_END = 8447; +var VARIATION_MODIFIER_BEGIN = 65024; +var VARIATION_MODIFIER_END = 65039; +function getCodePointData(string2, i = 0) { + const size = string2.length; + if (i < 0 || i >= size) { + return null; + } + const first = string2.charCodeAt(i); + if (size > 1 && first >= HIGH_SURROGATE_BEGIN && first <= HIGH_SURROGATE_END) { + const second = string2.charCodeAt(i + 1); + if (second >= LOW_SURROGATE_BEGIN && second <= LOW_SURROGATE_END) { + return { + code: (first - HIGH_SURROGATE_BEGIN) * 1024 + second - LOW_SURROGATE_BEGIN + 65536, + long: true + }; + } + } + return { + code: first, + long: false + }; +} +function isCodeBetween(string2, begin, end) { + if (!string2) return false; + const codeData = getCodePointData(string2); + if (codeData) { + const code = codeData.code; + return code >= begin && code <= end; + } + return false; +} +function numCharsToTakeForNextSymbol(string2, index) { + if (index === string2.length - 1) { + return 1; + } + if (isCodeBetween(string2[index], HIGH_SURROGATE_BEGIN, HIGH_SURROGATE_END)) { + const first = string2.substring(index, index + 2); + const second = string2.substring(index + 2, index + 4); + if (isCodeBetween(second, FITZPATRICK_MODIFIER_BEGIN, FITZPATRICK_MODIFIER_END) || isCodeBetween(first, REGIONAL_INDICATOR_BEGIN, REGIONAL_INDICATOR_END) && isCodeBetween(second, REGIONAL_INDICATOR_BEGIN, REGIONAL_INDICATOR_END)) { + return 4; + } + if (isCodeBetween(second, VARIATION_MODIFIER_BEGIN, VARIATION_MODIFIER_END)) { + return 3; + } + return 2; + } + if (isCodeBetween(string2[index + 1], VARIATION_MODIFIER_BEGIN, VARIATION_MODIFIER_END)) { + return 2; + } + return 1; +} +var string = { + ASCII_LOWERCASE, + ASCII_UPPERCASE, + ASCII_LETTERS, + format(s, ...args) { + for (let i = 0; i < args.length; i++) { + s = s.replace(`{${i}}`, args[i]); + } + return s; + }, + getCodePoint(string2, i) { + const codePointData = getCodePointData(string2, i); + return codePointData && codePointData.code; + }, + getCodePoints(string2) { + if (typeof string2 !== "string") { + throw new TypeError("Not a string"); + } + let i = 0; + const arr = []; + let codePoint; + while (!!(codePoint = getCodePointData(string2, i))) { + arr.push(codePoint.code); + i += codePoint.long ? 2 : 1; + } + return arr; + }, + getSymbols(string2) { + if (typeof string2 !== "string") { + throw new TypeError("Not a string"); + } + let index = 0; + const length = string2.length; + const output = []; + let take = 0; + let ch; + while (index < length) { + take += numCharsToTakeForNextSymbol(string2, index + take); + ch = string2[index + take]; + if (isCodeBetween(ch, DIACRITICAL_MARKS_BEGIN, DIACRITICAL_MARKS_END)) { + ch = string2[index + take++]; + } + if (isCodeBetween(ch, VARIATION_MODIFIER_BEGIN, VARIATION_MODIFIER_END)) { + ch = string2[index + take++]; + } + if (ch && ch.charCodeAt(0) === ZERO_WIDTH_JOINER) { + ch = string2[index + take++]; + continue; + } + const char = string2.substring(index, index + take); + output.push(char); + index += take; + take = 0; + } + return output; + }, + fromCodePoint() { + const chars = []; + let current; + let codePoint; + let units; + for (let i = 0; i < arguments.length; ++i) { + current = Number(arguments[i]); + codePoint = current - 65536; + units = current > 65535 ? [(codePoint >> 10) + 55296, codePoint % 1024 + 56320] : [current]; + chars.push(String.fromCharCode.apply(null, units)); + } + return chars.join(""); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/core/wasm-module.js +var cachedResult = (func) => { + const uninitToken = {}; + let result = uninitToken; + return () => { + if (result === uninitToken) { + result = func(); + } + return result; + }; +}; +var Impl = class _Impl { + static loadScript(url, callback) { + const s = document.createElement("script"); + s.setAttribute("src", url); + s.onload = () => { + callback(null); + }; + s.onerror = () => { + callback(`Failed to load script='${url}'`); + }; + document.body.appendChild(s); + } + static loadWasm(moduleName, config, callback) { + const loadUrl = _Impl.wasmSupported() && config.glueUrl && config.wasmUrl ? config.glueUrl : config.fallbackUrl; + if (loadUrl) { + _Impl.loadScript(loadUrl, (err) => { + if (err) { + callback(err, null); + } else { + const module = window[moduleName]; + window[moduleName] = void 0; + module({ + locateFile: () => config.wasmUrl, + onAbort: () => { + callback("wasm module aborted."); + } + }).then((instance) => { + callback(null, instance); + }); + } + }); + } else { + callback("No supported wasm modules found.", null); + } + } + static getModule(name) { + if (!_Impl.modules.hasOwnProperty(name)) { + _Impl.modules[name] = { + config: null, + initializing: false, + instance: null, + callbacks: [] + }; + } + return _Impl.modules[name]; + } + static initialize(moduleName, module) { + if (module.initializing) { + return; + } + const config = module.config; + if (config.glueUrl || config.wasmUrl || config.fallbackUrl) { + module.initializing = true; + _Impl.loadWasm(moduleName, config, (err, instance) => { + if (err) { + if (config.errorHandler) { + config.errorHandler(err); + } else { + console.error(`failed to initialize module=${moduleName} error=${err}`); + } + } else { + module.instance = instance; + module.callbacks.forEach((callback) => { + callback(instance); + }); + } + }); + } + } +}; +Impl.modules = {}; +Impl.wasmSupported = cachedResult(() => { + try { + if (typeof WebAssembly === "object" && typeof WebAssembly.instantiate === "function") { + const module = new WebAssembly.Module(Uint8Array.of(0, 97, 115, 109, 1, 0, 0, 0)); + if (module instanceof WebAssembly.Module) return new WebAssembly.Instance(module) instanceof WebAssembly.Instance; + } + } catch (e) { + } + return false; +}); +var WasmModule = class { + static setConfig(moduleName, config) { + const module = Impl.getModule(moduleName); + module.config = config; + if (module.callbacks.length > 0) { + Impl.initialize(moduleName, module); + } + } + static getConfig(moduleName) { + var _Impl$modules; + return (_Impl$modules = Impl.modules) == null || (_Impl$modules = _Impl$modules[moduleName]) == null ? void 0 : _Impl$modules.config; + } + static getInstance(moduleName, callback) { + const module = Impl.getModule(moduleName); + if (module.instance) { + callback(module.instance); + } else { + module.callbacks.push(callback); + if (module.config) { + Impl.initialize(moduleName, module); + } + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/core/read-stream.js +var ReadStream = class { + constructor(arraybuffer) { + this.arraybuffer = void 0; + this.dataView = void 0; + this.offset = 0; + this.arraybuffer = arraybuffer; + this.dataView = new DataView(arraybuffer); + } + get remainingBytes() { + return this.dataView.byteLength - this.offset; + } + reset(offset = 0) { + this.offset = offset; + } + skip(bytes) { + this.offset += bytes; + } + align(bytes) { + this.offset = this.offset + bytes - 1 & ~(bytes - 1); + } + _inc(amount) { + this.offset += amount; + return this.offset - amount; + } + readChar() { + return String.fromCharCode(this.dataView.getUint8(this.offset++)); + } + readChars(numChars) { + let result = ""; + for (let i = 0; i < numChars; ++i) { + result += this.readChar(); + } + return result; + } + readU8() { + return this.dataView.getUint8(this.offset++); + } + readU16() { + return this.dataView.getUint16(this._inc(2), true); + } + readU32() { + return this.dataView.getUint32(this._inc(4), true); + } + readU64() { + return this.readU32() + 2 ** 32 * this.readU32(); + } + readU32be() { + return this.dataView.getUint32(this._inc(4), false); + } + readArray(result) { + for (let i = 0; i < result.length; ++i) { + result[i] = this.readU8(); + } + } + readLine() { + const view = this.dataView; + let result = ""; + while (true) { + if (this.offset >= view.byteLength) { + break; + } + const c2 = String.fromCharCode(this.readU8()); + if (c2 === "\n") { + break; + } + result += c2; + } + return result; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/core/tags.js +var Tags = class extends EventHandler { + constructor(parent) { + super(); + this._index = {}; + this._list = []; + this._parent = parent; + } + add(...args) { + let changed = false; + const tags = this._processArguments(args, true); + if (!tags.length) return changed; + for (let i = 0; i < tags.length; i++) { + if (this._index[tags[i]]) continue; + changed = true; + this._index[tags[i]] = true; + this._list.push(tags[i]); + this.fire("add", tags[i], this._parent); + } + if (changed) this.fire("change", this._parent); + return changed; + } + remove(...args) { + let changed = false; + if (!this._list.length) return changed; + const tags = this._processArguments(args, true); + if (!tags.length) return changed; + for (let i = 0; i < tags.length; i++) { + if (!this._index[tags[i]]) continue; + changed = true; + delete this._index[tags[i]]; + this._list.splice(this._list.indexOf(tags[i]), 1); + this.fire("remove", tags[i], this._parent); + } + if (changed) this.fire("change", this._parent); + return changed; + } + clear() { + if (!this._list.length) return; + const tags = this._list.slice(0); + this._list = []; + this._index = {}; + for (let i = 0; i < tags.length; i++) this.fire("remove", tags[i], this._parent); + this.fire("change", this._parent); + } + has(...query) { + if (!this._list.length) return false; + return this._has(this._processArguments(query)); + } + _has(tags) { + if (!this._list.length || !tags.length) return false; + for (let i = 0; i < tags.length; i++) { + if (tags[i].length === 1) { + if (this._index[tags[i][0]]) return true; + } else { + let multiple = true; + for (let t = 0; t < tags[i].length; t++) { + if (this._index[tags[i][t]]) continue; + multiple = false; + break; + } + if (multiple) return true; + } + } + return false; + } + list() { + return this._list.slice(0); + } + _processArguments(args, flat) { + const tags = []; + let tmp = []; + if (!args || !args.length) return tags; + for (let i = 0; i < args.length; i++) { + if (args[i] instanceof Array) { + if (!flat) tmp = []; + for (let t = 0; t < args[i].length; t++) { + if (typeof args[i][t] !== "string") continue; + if (flat) { + tags.push(args[i][t]); + } else { + tmp.push(args[i][t]); + } + } + if (!flat && tmp.length) tags.push(tmp); + } else if (typeof args[i] === "string") { + if (flat) { + tags.push(args[i]); + } else { + tags.push([args[i]]); + } + } + } + return tags; + } + get size() { + return this._list.length; + } +}; +Tags.EVENT_ADD = "add"; +Tags.EVENT_REMOVE = "remove"; +Tags.EVENT_CHANGE = "change"; + +// ../../node_modules/playcanvas/build/playcanvas/src/core/time.js +var now = typeof window !== "undefined" && window.performance && window.performance.now ? performance.now.bind(performance) : Date.now; + +// ../../node_modules/playcanvas/build/playcanvas/src/core/uri.js +var re = /^(([^:\/?#]+):)?(\/\/([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/; +var URI = class { + constructor(uri) { + this.scheme = void 0; + this.authority = void 0; + this.path = void 0; + this.query = void 0; + this.fragment = void 0; + const result = uri.match(re); + this.scheme = result[2]; + this.authority = result[4]; + this.path = result[5]; + this.query = result[7]; + this.fragment = result[9]; + } + toString() { + let s = ""; + if (this.scheme) { + s += this.scheme + ":"; + } + if (this.authority) { + s += "//" + this.authority; + } + s += this.path; + if (this.query) { + s += "?" + this.query; + } + if (this.fragment) { + s += "#" + this.fragment; + } + return s; + } + getQuery() { + const result = {}; + if (this.query) { + const queryParams = decodeURIComponent(this.query).split("&"); + for (const queryParam of queryParams) { + const pair = queryParam.split("="); + result[pair[0]] = pair[1]; + } + } + return result; + } + setQuery(params) { + let q2 = ""; + for (const key in params) { + if (params.hasOwnProperty(key)) { + if (q2 !== "") { + q2 += "&"; + } + q2 += encodeURIComponent(key) + "=" + encodeURIComponent(params[key]); + } + } + this.query = q2; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/core/tracing.js +var Tracing = class _Tracing { + static set(channel, enabled = true) { + } + static get(channel) { + return _Tracing._traceChannels.has(channel); + } +}; +Tracing._traceChannels = /* @__PURE__ */ new Set(); +Tracing.stack = false; + +// ../../node_modules/playcanvas/build/playcanvas/src/core/math/math.js +var math = { + DEG_TO_RAD: Math.PI / 180, + RAD_TO_DEG: 180 / Math.PI, + clamp(value, min, max) { + if (value >= max) return max; + if (value <= min) return min; + return value; + }, + intToBytes24(i) { + const r = i >> 16 & 255; + const g = i >> 8 & 255; + const b = i & 255; + return [r, g, b]; + }, + intToBytes32(i) { + const r = i >> 24 & 255; + const g = i >> 16 & 255; + const b = i >> 8 & 255; + const a = i & 255; + return [r, g, b, a]; + }, + bytesToInt24(r, g, b) { + if (r.length) { + b = r[2]; + g = r[1]; + r = r[0]; + } + return r << 16 | g << 8 | b; + }, + bytesToInt32(r, g, b, a) { + if (r.length) { + a = r[3]; + b = r[2]; + g = r[1]; + r = r[0]; + } + return (r << 24 | g << 16 | b << 8 | a) >>> 0; + }, + lerp(a, b, alpha) { + return a + (b - a) * math.clamp(alpha, 0, 1); + }, + lerpAngle(a, b, alpha) { + if (b - a > 180) { + b -= 360; + } + if (b - a < -180) { + b += 360; + } + return math.lerp(a, b, math.clamp(alpha, 0, 1)); + }, + powerOfTwo(x2) { + return x2 !== 0 && !(x2 & x2 - 1); + }, + nextPowerOfTwo(val) { + val--; + val |= val >> 1; + val |= val >> 2; + val |= val >> 4; + val |= val >> 8; + val |= val >> 16; + val++; + return val; + }, + nearestPowerOfTwo(val) { + return Math.pow(2, Math.round(Math.log(val) / Math.log(2))); + }, + random(min, max) { + const diff = max - min; + return Math.random() * diff + min; + }, + smoothstep(min, max, x2) { + if (x2 <= min) return 0; + if (x2 >= max) return 1; + x2 = (x2 - min) / (max - min); + return x2 * x2 * (3 - 2 * x2); + }, + smootherstep(min, max, x2) { + if (x2 <= min) return 0; + if (x2 >= max) return 1; + x2 = (x2 - min) / (max - min); + return x2 * x2 * x2 * (x2 * (x2 * 6 - 15) + 10); + }, + roundUp(numToRound, multiple) { + if (multiple === 0) return numToRound; + return Math.ceil(numToRound / multiple) * multiple; + }, + between(num, a, b, inclusive) { + const min = Math.min(a, b); + const max = Math.max(a, b); + return inclusive ? num >= min && num <= max : num > min && num < max; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/core/math/color.js +var _Color; +var Color = class { + constructor(r = 0, g = 0, b = 0, a = 1) { + this.r = void 0; + this.g = void 0; + this.b = void 0; + this.a = void 0; + const length = r.length; + if (length === 3 || length === 4) { + this.r = r[0]; + this.g = r[1]; + this.b = r[2]; + this.a = r[3] !== void 0 ? r[3] : 1; + } else { + this.r = r; + this.g = g; + this.b = b; + this.a = a; + } + } + clone() { + const cstr = this.constructor; + return new cstr(this.r, this.g, this.b, this.a); + } + copy(rhs) { + this.r = rhs.r; + this.g = rhs.g; + this.b = rhs.b; + this.a = rhs.a; + return this; + } + equals(rhs) { + return this.r === rhs.r && this.g === rhs.g && this.b === rhs.b && this.a === rhs.a; + } + set(r, g, b, a = 1) { + this.r = r; + this.g = g; + this.b = b; + this.a = a; + return this; + } + lerp(lhs, rhs, alpha) { + this.r = lhs.r + alpha * (rhs.r - lhs.r); + this.g = lhs.g + alpha * (rhs.g - lhs.g); + this.b = lhs.b + alpha * (rhs.b - lhs.b); + this.a = lhs.a + alpha * (rhs.a - lhs.a); + return this; + } + fromString(hex) { + const i = parseInt(hex.replace("#", "0x"), 16); + let bytes; + if (hex.length > 7) { + bytes = math.intToBytes32(i); + } else { + bytes = math.intToBytes24(i); + bytes[3] = 255; + } + this.set(bytes[0] / 255, bytes[1] / 255, bytes[2] / 255, bytes[3] / 255); + return this; + } + toString(alpha) { + let s = "#" + ((1 << 24) + (Math.round(this.r * 255) << 16) + (Math.round(this.g * 255) << 8) + Math.round(this.b * 255)).toString(16).slice(1); + if (alpha === true) { + const a = Math.round(this.a * 255).toString(16); + if (this.a < 16 / 255) { + s += "0" + a; + } else { + s += a; + } + } + return s; + } +}; +_Color = Color; +Color.BLACK = Object.freeze(new _Color(0, 0, 0, 1)); +Color.BLUE = Object.freeze(new _Color(0, 0, 1, 1)); +Color.CYAN = Object.freeze(new _Color(0, 1, 1, 1)); +Color.GRAY = Object.freeze(new _Color(0.5, 0.5, 0.5, 1)); +Color.GREEN = Object.freeze(new _Color(0, 1, 0, 1)); +Color.MAGENTA = Object.freeze(new _Color(1, 0, 1, 1)); +Color.RED = Object.freeze(new _Color(1, 0, 0, 1)); +Color.WHITE = Object.freeze(new _Color(1, 1, 1, 1)); +Color.YELLOW = Object.freeze(new _Color(1, 1, 0, 1)); + +// ../../node_modules/playcanvas/build/playcanvas/src/core/math/float-packing.js +var oneDiv255 = 1 / 255; +var floatView = new Float32Array(1); +var int32View = new Int32Array(floatView.buffer); +var FloatPacking = class _FloatPacking { + static float2Half(value) { + floatView[0] = value; + const x2 = int32View[0]; + let bits = x2 >> 16 & 32768; + let m = x2 >> 12 & 2047; + const e = x2 >> 23 & 255; + if (e < 103) { + return bits; + } + if (e > 142) { + bits |= 31744; + bits |= (e === 255 ? 0 : 1) && x2 & 8388607; + return bits; + } + if (e < 113) { + m |= 2048; + bits |= (m >> 114 - e) + (m >> 113 - e & 1); + return bits; + } + bits |= e - 112 << 10 | m >> 1; + bits += m & 1; + return bits; + } + static float2Bytes(value, array2, offset, numBytes) { + const enc1 = 255 * value % 1; + array2[offset + 0] = Math.round((value % 1 - oneDiv255 * enc1) * 255); + if (numBytes > 1) { + const enc2 = 65025 * value % 1; + array2[offset + 1] = Math.round((enc1 - oneDiv255 * enc2) * 255); + if (numBytes > 2) { + const enc3 = 16581375 * value % 1; + array2[offset + 2] = Math.round((enc2 - oneDiv255 * enc3) * 255); + if (numBytes > 3) { + array2[offset + 3] = Math.round(enc3 * 255); + } + } + } + } + static float2BytesRange(value, array2, offset, min, max, numBytes) { + value = math.clamp((value - min) / (max - min), 0, 1); + _FloatPacking.float2Bytes(value, array2, offset, numBytes); + } + static float2MantissaExponent(value, array2, offset, numBytes) { + const exponent = Math.floor(Math.log2(Math.abs(value))) + 1; + value /= Math.pow(2, exponent); + _FloatPacking.float2BytesRange(value, array2, offset, -1, 1, numBytes - 1); + array2[offset + numBytes - 1] = Math.round(exponent + 127); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/core/math/vec3.js +var _Vec; +var Vec3 = class { + constructor(x2 = 0, y2 = 0, z2 = 0) { + this.x = void 0; + this.y = void 0; + this.z = void 0; + if (x2.length === 3) { + this.x = x2[0]; + this.y = x2[1]; + this.z = x2[2]; + } else { + this.x = x2; + this.y = y2; + this.z = z2; + } + } + add(rhs) { + this.x += rhs.x; + this.y += rhs.y; + this.z += rhs.z; + return this; + } + add2(lhs, rhs) { + this.x = lhs.x + rhs.x; + this.y = lhs.y + rhs.y; + this.z = lhs.z + rhs.z; + return this; + } + addScalar(scalar) { + this.x += scalar; + this.y += scalar; + this.z += scalar; + return this; + } + addScaled(rhs, scalar) { + this.x += rhs.x * scalar; + this.y += rhs.y * scalar; + this.z += rhs.z * scalar; + return this; + } + clone() { + const cstr = this.constructor; + return new cstr(this.x, this.y, this.z); + } + copy(rhs) { + this.x = rhs.x; + this.y = rhs.y; + this.z = rhs.z; + return this; + } + cross(lhs, rhs) { + const lx = lhs.x; + const ly = lhs.y; + const lz = lhs.z; + const rx = rhs.x; + const ry = rhs.y; + const rz = rhs.z; + this.x = ly * rz - ry * lz; + this.y = lz * rx - rz * lx; + this.z = lx * ry - rx * ly; + return this; + } + distance(rhs) { + const x2 = this.x - rhs.x; + const y2 = this.y - rhs.y; + const z2 = this.z - rhs.z; + return Math.sqrt(x2 * x2 + y2 * y2 + z2 * z2); + } + div(rhs) { + this.x /= rhs.x; + this.y /= rhs.y; + this.z /= rhs.z; + return this; + } + div2(lhs, rhs) { + this.x = lhs.x / rhs.x; + this.y = lhs.y / rhs.y; + this.z = lhs.z / rhs.z; + return this; + } + divScalar(scalar) { + this.x /= scalar; + this.y /= scalar; + this.z /= scalar; + return this; + } + dot(rhs) { + return this.x * rhs.x + this.y * rhs.y + this.z * rhs.z; + } + equals(rhs) { + return this.x === rhs.x && this.y === rhs.y && this.z === rhs.z; + } + equalsApprox(rhs, epsilon3 = 1e-6) { + return Math.abs(this.x - rhs.x) < epsilon3 && Math.abs(this.y - rhs.y) < epsilon3 && Math.abs(this.z - rhs.z) < epsilon3; + } + length() { + return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z); + } + lengthSq() { + return this.x * this.x + this.y * this.y + this.z * this.z; + } + lerp(lhs, rhs, alpha) { + this.x = lhs.x + alpha * (rhs.x - lhs.x); + this.y = lhs.y + alpha * (rhs.y - lhs.y); + this.z = lhs.z + alpha * (rhs.z - lhs.z); + return this; + } + mul(rhs) { + this.x *= rhs.x; + this.y *= rhs.y; + this.z *= rhs.z; + return this; + } + mul2(lhs, rhs) { + this.x = lhs.x * rhs.x; + this.y = lhs.y * rhs.y; + this.z = lhs.z * rhs.z; + return this; + } + mulScalar(scalar) { + this.x *= scalar; + this.y *= scalar; + this.z *= scalar; + return this; + } + normalize(src = this) { + const lengthSq = src.x * src.x + src.y * src.y + src.z * src.z; + if (lengthSq > 0) { + const invLength = 1 / Math.sqrt(lengthSq); + this.x = src.x * invLength; + this.y = src.y * invLength; + this.z = src.z * invLength; + } + return this; + } + floor(src = this) { + this.x = Math.floor(src.x); + this.y = Math.floor(src.y); + this.z = Math.floor(src.z); + return this; + } + ceil(src = this) { + this.x = Math.ceil(src.x); + this.y = Math.ceil(src.y); + this.z = Math.ceil(src.z); + return this; + } + round(src = this) { + this.x = Math.round(src.x); + this.y = Math.round(src.y); + this.z = Math.round(src.z); + return this; + } + min(rhs) { + if (rhs.x < this.x) this.x = rhs.x; + if (rhs.y < this.y) this.y = rhs.y; + if (rhs.z < this.z) this.z = rhs.z; + return this; + } + max(rhs) { + if (rhs.x > this.x) this.x = rhs.x; + if (rhs.y > this.y) this.y = rhs.y; + if (rhs.z > this.z) this.z = rhs.z; + return this; + } + project(rhs) { + const a_dot_b = this.x * rhs.x + this.y * rhs.y + this.z * rhs.z; + const b_dot_b = rhs.x * rhs.x + rhs.y * rhs.y + rhs.z * rhs.z; + const s = a_dot_b / b_dot_b; + this.x = rhs.x * s; + this.y = rhs.y * s; + this.z = rhs.z * s; + return this; + } + set(x2, y2, z2) { + this.x = x2; + this.y = y2; + this.z = z2; + return this; + } + sub(rhs) { + this.x -= rhs.x; + this.y -= rhs.y; + this.z -= rhs.z; + return this; + } + sub2(lhs, rhs) { + this.x = lhs.x - rhs.x; + this.y = lhs.y - rhs.y; + this.z = lhs.z - rhs.z; + return this; + } + subScalar(scalar) { + this.x -= scalar; + this.y -= scalar; + this.z -= scalar; + return this; + } + toString() { + return `[${this.x}, ${this.y}, ${this.z}]`; + } +}; +_Vec = Vec3; +Vec3.ZERO = Object.freeze(new _Vec(0, 0, 0)); +Vec3.ONE = Object.freeze(new _Vec(1, 1, 1)); +Vec3.UP = Object.freeze(new _Vec(0, 1, 0)); +Vec3.DOWN = Object.freeze(new _Vec(0, -1, 0)); +Vec3.RIGHT = Object.freeze(new _Vec(1, 0, 0)); +Vec3.LEFT = Object.freeze(new _Vec(-1, 0, 0)); +Vec3.FORWARD = Object.freeze(new _Vec(0, 0, -1)); +Vec3.BACK = Object.freeze(new _Vec(0, 0, 1)); + +// ../../node_modules/playcanvas/build/playcanvas/src/core/math/mat3.js +var _Mat; +var Mat3 = class { + constructor() { + this.data = new Float32Array(9); + this.data[0] = this.data[4] = this.data[8] = 1; + } + clone() { + const cstr = this.constructor; + return new cstr().copy(this); + } + copy(rhs) { + const src = rhs.data; + const dst = this.data; + dst[0] = src[0]; + dst[1] = src[1]; + dst[2] = src[2]; + dst[3] = src[3]; + dst[4] = src[4]; + dst[5] = src[5]; + dst[6] = src[6]; + dst[7] = src[7]; + dst[8] = src[8]; + return this; + } + set(src) { + const dst = this.data; + dst[0] = src[0]; + dst[1] = src[1]; + dst[2] = src[2]; + dst[3] = src[3]; + dst[4] = src[4]; + dst[5] = src[5]; + dst[6] = src[6]; + dst[7] = src[7]; + dst[8] = src[8]; + return this; + } + getX(x2 = new Vec3()) { + return x2.set(this.data[0], this.data[1], this.data[2]); + } + getY(y2 = new Vec3()) { + return y2.set(this.data[3], this.data[4], this.data[5]); + } + getZ(z2 = new Vec3()) { + return z2.set(this.data[6], this.data[7], this.data[8]); + } + equals(rhs) { + const l = this.data; + const r = rhs.data; + return l[0] === r[0] && l[1] === r[1] && l[2] === r[2] && l[3] === r[3] && l[4] === r[4] && l[5] === r[5] && l[6] === r[6] && l[7] === r[7] && l[8] === r[8]; + } + isIdentity() { + const m = this.data; + return m[0] === 1 && m[1] === 0 && m[2] === 0 && m[3] === 0 && m[4] === 1 && m[5] === 0 && m[6] === 0 && m[7] === 0 && m[8] === 1; + } + setIdentity() { + const m = this.data; + m[0] = 1; + m[1] = 0; + m[2] = 0; + m[3] = 0; + m[4] = 1; + m[5] = 0; + m[6] = 0; + m[7] = 0; + m[8] = 1; + return this; + } + toString() { + return "[" + this.data.join(", ") + "]"; + } + transpose(src = this) { + const s = src.data; + const t = this.data; + if (s === t) { + let tmp; + tmp = s[1]; + t[1] = s[3]; + t[3] = tmp; + tmp = s[2]; + t[2] = s[6]; + t[6] = tmp; + tmp = s[5]; + t[5] = s[7]; + t[7] = tmp; + } else { + t[0] = s[0]; + t[1] = s[3]; + t[2] = s[6]; + t[3] = s[1]; + t[4] = s[4]; + t[5] = s[7]; + t[6] = s[2]; + t[7] = s[5]; + t[8] = s[8]; + } + return this; + } + setFromMat4(m) { + const src = m.data; + const dst = this.data; + dst[0] = src[0]; + dst[1] = src[1]; + dst[2] = src[2]; + dst[3] = src[4]; + dst[4] = src[5]; + dst[5] = src[6]; + dst[6] = src[8]; + dst[7] = src[9]; + dst[8] = src[10]; + return this; + } + setFromQuat(r) { + const qx = r.x; + const qy = r.y; + const qz = r.z; + const qw = r.w; + const x2 = qx + qx; + const y2 = qy + qy; + const z2 = qz + qz; + const xx = qx * x2; + const xy = qx * y2; + const xz = qx * z2; + const yy = qy * y2; + const yz = qy * z2; + const zz = qz * z2; + const wx = qw * x2; + const wy = qw * y2; + const wz = qw * z2; + const m = this.data; + m[0] = 1 - (yy + zz); + m[1] = xy + wz; + m[2] = xz - wy; + m[3] = xy - wz; + m[4] = 1 - (xx + zz); + m[5] = yz + wx; + m[6] = xz + wy; + m[7] = yz - wx; + m[8] = 1 - (xx + yy); + return this; + } + invertMat4(src) { + const s = src.data; + const a0 = s[0]; + const a1 = s[1]; + const a2 = s[2]; + const a4 = s[4]; + const a5 = s[5]; + const a6 = s[6]; + const a8 = s[8]; + const a9 = s[9]; + const a10 = s[10]; + const b11 = a10 * a5 - a6 * a9; + const b21 = -a10 * a1 + a2 * a9; + const b31 = a6 * a1 - a2 * a5; + const b12 = -a10 * a4 + a6 * a8; + const b22 = a10 * a0 - a2 * a8; + const b32 = -a6 * a0 + a2 * a4; + const b13 = a9 * a4 - a5 * a8; + const b23 = -a9 * a0 + a1 * a8; + const b33 = a5 * a0 - a1 * a4; + const det = a0 * b11 + a1 * b12 + a2 * b13; + if (det === 0) { + this.setIdentity(); + } else { + const invDet = 1 / det; + const t = this.data; + t[0] = b11 * invDet; + t[1] = b21 * invDet; + t[2] = b31 * invDet; + t[3] = b12 * invDet; + t[4] = b22 * invDet; + t[5] = b32 * invDet; + t[6] = b13 * invDet; + t[7] = b23 * invDet; + t[8] = b33 * invDet; + } + return this; + } + transformVector(vec2, res = new Vec3()) { + const m = this.data; + const { + x: x2, + y: y2, + z: z2 + } = vec2; + res.x = x2 * m[0] + y2 * m[3] + z2 * m[6]; + res.y = x2 * m[1] + y2 * m[4] + z2 * m[7]; + res.z = x2 * m[2] + y2 * m[5] + z2 * m[8]; + return res; + } +}; +_Mat = Mat3; +Mat3.IDENTITY = Object.freeze(new _Mat()); +Mat3.ZERO = Object.freeze(new _Mat().set([0, 0, 0, 0, 0, 0, 0, 0, 0])); + +// ../../node_modules/playcanvas/build/playcanvas/src/core/math/vec2.js +var _Vec2; +var Vec2 = class { + constructor(x2 = 0, y2 = 0) { + this.x = void 0; + this.y = void 0; + if (x2.length === 2) { + this.x = x2[0]; + this.y = x2[1]; + } else { + this.x = x2; + this.y = y2; + } + } + add(rhs) { + this.x += rhs.x; + this.y += rhs.y; + return this; + } + add2(lhs, rhs) { + this.x = lhs.x + rhs.x; + this.y = lhs.y + rhs.y; + return this; + } + addScalar(scalar) { + this.x += scalar; + this.y += scalar; + return this; + } + addScaled(rhs, scalar) { + this.x += rhs.x * scalar; + this.y += rhs.y * scalar; + return this; + } + clone() { + const cstr = this.constructor; + return new cstr(this.x, this.y); + } + copy(rhs) { + this.x = rhs.x; + this.y = rhs.y; + return this; + } + cross(rhs) { + return this.x * rhs.y - this.y * rhs.x; + } + distance(rhs) { + const x2 = this.x - rhs.x; + const y2 = this.y - rhs.y; + return Math.sqrt(x2 * x2 + y2 * y2); + } + div(rhs) { + this.x /= rhs.x; + this.y /= rhs.y; + return this; + } + div2(lhs, rhs) { + this.x = lhs.x / rhs.x; + this.y = lhs.y / rhs.y; + return this; + } + divScalar(scalar) { + this.x /= scalar; + this.y /= scalar; + return this; + } + dot(rhs) { + return this.x * rhs.x + this.y * rhs.y; + } + equals(rhs) { + return this.x === rhs.x && this.y === rhs.y; + } + equalsApprox(rhs, epsilon3 = 1e-6) { + return Math.abs(this.x - rhs.x) < epsilon3 && Math.abs(this.y - rhs.y) < epsilon3; + } + length() { + return Math.sqrt(this.x * this.x + this.y * this.y); + } + lengthSq() { + return this.x * this.x + this.y * this.y; + } + lerp(lhs, rhs, alpha) { + this.x = lhs.x + alpha * (rhs.x - lhs.x); + this.y = lhs.y + alpha * (rhs.y - lhs.y); + return this; + } + mul(rhs) { + this.x *= rhs.x; + this.y *= rhs.y; + return this; + } + mul2(lhs, rhs) { + this.x = lhs.x * rhs.x; + this.y = lhs.y * rhs.y; + return this; + } + mulScalar(scalar) { + this.x *= scalar; + this.y *= scalar; + return this; + } + normalize(src = this) { + const lengthSq = src.x * src.x + src.y * src.y; + if (lengthSq > 0) { + const invLength = 1 / Math.sqrt(lengthSq); + this.x = src.x * invLength; + this.y = src.y * invLength; + } + return this; + } + rotate(degrees) { + const angle = Math.atan2(this.x, this.y) + degrees * math.DEG_TO_RAD; + const len = Math.sqrt(this.x * this.x + this.y * this.y); + this.x = Math.sin(angle) * len; + this.y = Math.cos(angle) * len; + return this; + } + angle() { + return Math.atan2(this.x, this.y) * math.RAD_TO_DEG; + } + angleTo(rhs) { + return Math.atan2(this.x * rhs.y + this.y * rhs.x, this.x * rhs.x + this.y * rhs.y) * math.RAD_TO_DEG; + } + floor(src = this) { + this.x = Math.floor(src.x); + this.y = Math.floor(src.y); + return this; + } + ceil(src = this) { + this.x = Math.ceil(src.x); + this.y = Math.ceil(src.y); + return this; + } + round(src = this) { + this.x = Math.round(src.x); + this.y = Math.round(src.y); + return this; + } + min(rhs) { + if (rhs.x < this.x) this.x = rhs.x; + if (rhs.y < this.y) this.y = rhs.y; + return this; + } + max(rhs) { + if (rhs.x > this.x) this.x = rhs.x; + if (rhs.y > this.y) this.y = rhs.y; + return this; + } + set(x2, y2) { + this.x = x2; + this.y = y2; + return this; + } + sub(rhs) { + this.x -= rhs.x; + this.y -= rhs.y; + return this; + } + sub2(lhs, rhs) { + this.x = lhs.x - rhs.x; + this.y = lhs.y - rhs.y; + return this; + } + subScalar(scalar) { + this.x -= scalar; + this.y -= scalar; + return this; + } + toString() { + return `[${this.x}, ${this.y}]`; + } + static angleRad(lhs, rhs) { + return Math.atan2(lhs.x * rhs.y - lhs.y * rhs.x, lhs.x * rhs.x + lhs.y * rhs.y); + } +}; +_Vec2 = Vec2; +Vec2.ZERO = Object.freeze(new _Vec2(0, 0)); +Vec2.ONE = Object.freeze(new _Vec2(1, 1)); +Vec2.UP = Object.freeze(new _Vec2(0, 1)); +Vec2.DOWN = Object.freeze(new _Vec2(0, -1)); +Vec2.RIGHT = Object.freeze(new _Vec2(1, 0)); +Vec2.LEFT = Object.freeze(new _Vec2(-1, 0)); + +// ../../node_modules/playcanvas/build/playcanvas/src/core/math/vec4.js +var _Vec3; +var Vec4 = class { + constructor(x2 = 0, y2 = 0, z2 = 0, w = 0) { + this.x = void 0; + this.y = void 0; + this.z = void 0; + this.w = void 0; + if (x2.length === 4) { + this.x = x2[0]; + this.y = x2[1]; + this.z = x2[2]; + this.w = x2[3]; + } else { + this.x = x2; + this.y = y2; + this.z = z2; + this.w = w; + } + } + add(rhs) { + this.x += rhs.x; + this.y += rhs.y; + this.z += rhs.z; + this.w += rhs.w; + return this; + } + add2(lhs, rhs) { + this.x = lhs.x + rhs.x; + this.y = lhs.y + rhs.y; + this.z = lhs.z + rhs.z; + this.w = lhs.w + rhs.w; + return this; + } + addScalar(scalar) { + this.x += scalar; + this.y += scalar; + this.z += scalar; + this.w += scalar; + return this; + } + addScaled(rhs, scalar) { + this.x += rhs.x * scalar; + this.y += rhs.y * scalar; + this.z += rhs.z * scalar; + this.w += rhs.w * scalar; + return this; + } + clone() { + const cstr = this.constructor; + return new cstr(this.x, this.y, this.z, this.w); + } + copy(rhs) { + this.x = rhs.x; + this.y = rhs.y; + this.z = rhs.z; + this.w = rhs.w; + return this; + } + div(rhs) { + this.x /= rhs.x; + this.y /= rhs.y; + this.z /= rhs.z; + this.w /= rhs.w; + return this; + } + div2(lhs, rhs) { + this.x = lhs.x / rhs.x; + this.y = lhs.y / rhs.y; + this.z = lhs.z / rhs.z; + this.w = lhs.w / rhs.w; + return this; + } + divScalar(scalar) { + this.x /= scalar; + this.y /= scalar; + this.z /= scalar; + this.w /= scalar; + return this; + } + dot(rhs) { + return this.x * rhs.x + this.y * rhs.y + this.z * rhs.z + this.w * rhs.w; + } + equals(rhs) { + return this.x === rhs.x && this.y === rhs.y && this.z === rhs.z && this.w === rhs.w; + } + equalsApprox(rhs, epsilon3 = 1e-6) { + return Math.abs(this.x - rhs.x) < epsilon3 && Math.abs(this.y - rhs.y) < epsilon3 && Math.abs(this.z - rhs.z) < epsilon3 && Math.abs(this.w - rhs.w) < epsilon3; + } + length() { + return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w); + } + lengthSq() { + return this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w; + } + lerp(lhs, rhs, alpha) { + this.x = lhs.x + alpha * (rhs.x - lhs.x); + this.y = lhs.y + alpha * (rhs.y - lhs.y); + this.z = lhs.z + alpha * (rhs.z - lhs.z); + this.w = lhs.w + alpha * (rhs.w - lhs.w); + return this; + } + mul(rhs) { + this.x *= rhs.x; + this.y *= rhs.y; + this.z *= rhs.z; + this.w *= rhs.w; + return this; + } + mul2(lhs, rhs) { + this.x = lhs.x * rhs.x; + this.y = lhs.y * rhs.y; + this.z = lhs.z * rhs.z; + this.w = lhs.w * rhs.w; + return this; + } + mulScalar(scalar) { + this.x *= scalar; + this.y *= scalar; + this.z *= scalar; + this.w *= scalar; + return this; + } + normalize(src = this) { + const lengthSq = src.x * src.x + src.y * src.y + src.z * src.z + src.w * src.w; + if (lengthSq > 0) { + const invLength = 1 / Math.sqrt(lengthSq); + this.x = src.x * invLength; + this.y = src.y * invLength; + this.z = src.z * invLength; + this.w = src.w * invLength; + } + return this; + } + floor(src = this) { + this.x = Math.floor(src.x); + this.y = Math.floor(src.y); + this.z = Math.floor(src.z); + this.w = Math.floor(src.w); + return this; + } + ceil(src = this) { + this.x = Math.ceil(src.x); + this.y = Math.ceil(src.y); + this.z = Math.ceil(src.z); + this.w = Math.ceil(src.w); + return this; + } + round(src = this) { + this.x = Math.round(src.x); + this.y = Math.round(src.y); + this.z = Math.round(src.z); + this.w = Math.round(src.w); + return this; + } + min(rhs) { + if (rhs.x < this.x) this.x = rhs.x; + if (rhs.y < this.y) this.y = rhs.y; + if (rhs.z < this.z) this.z = rhs.z; + if (rhs.w < this.w) this.w = rhs.w; + return this; + } + max(rhs) { + if (rhs.x > this.x) this.x = rhs.x; + if (rhs.y > this.y) this.y = rhs.y; + if (rhs.z > this.z) this.z = rhs.z; + if (rhs.w > this.w) this.w = rhs.w; + return this; + } + set(x2, y2, z2, w) { + this.x = x2; + this.y = y2; + this.z = z2; + this.w = w; + return this; + } + sub(rhs) { + this.x -= rhs.x; + this.y -= rhs.y; + this.z -= rhs.z; + this.w -= rhs.w; + return this; + } + sub2(lhs, rhs) { + this.x = lhs.x - rhs.x; + this.y = lhs.y - rhs.y; + this.z = lhs.z - rhs.z; + this.w = lhs.w - rhs.w; + return this; + } + subScalar(scalar) { + this.x -= scalar; + this.y -= scalar; + this.z -= scalar; + this.w -= scalar; + return this; + } + toString() { + return `[${this.x}, ${this.y}, ${this.z}, ${this.w}]`; + } +}; +_Vec3 = Vec4; +Vec4.ZERO = Object.freeze(new _Vec3(0, 0, 0, 0)); +Vec4.ONE = Object.freeze(new _Vec3(1, 1, 1, 1)); + +// ../../node_modules/playcanvas/build/playcanvas/src/core/math/mat4.js +var _Mat2; +var _halfSize = new Vec2(); +var x = new Vec3(); +var y = new Vec3(); +var z = new Vec3(); +var scale = new Vec3(); +var Mat4 = class _Mat4 { + constructor() { + this.data = new Float32Array(16); + this.data[0] = this.data[5] = this.data[10] = this.data[15] = 1; + } + static _getPerspectiveHalfSize(halfSize, fov, aspect, znear, fovIsHorizontal) { + if (fovIsHorizontal) { + halfSize.x = znear * Math.tan(fov * Math.PI / 360); + halfSize.y = halfSize.x / aspect; + } else { + halfSize.y = znear * Math.tan(fov * Math.PI / 360); + halfSize.x = halfSize.y * aspect; + } + } + add2(lhs, rhs) { + const a = lhs.data, b = rhs.data, r = this.data; + r[0] = a[0] + b[0]; + r[1] = a[1] + b[1]; + r[2] = a[2] + b[2]; + r[3] = a[3] + b[3]; + r[4] = a[4] + b[4]; + r[5] = a[5] + b[5]; + r[6] = a[6] + b[6]; + r[7] = a[7] + b[7]; + r[8] = a[8] + b[8]; + r[9] = a[9] + b[9]; + r[10] = a[10] + b[10]; + r[11] = a[11] + b[11]; + r[12] = a[12] + b[12]; + r[13] = a[13] + b[13]; + r[14] = a[14] + b[14]; + r[15] = a[15] + b[15]; + return this; + } + add(rhs) { + return this.add2(this, rhs); + } + clone() { + const cstr = this.constructor; + return new cstr().copy(this); + } + copy(rhs) { + const src = rhs.data, dst = this.data; + dst[0] = src[0]; + dst[1] = src[1]; + dst[2] = src[2]; + dst[3] = src[3]; + dst[4] = src[4]; + dst[5] = src[5]; + dst[6] = src[6]; + dst[7] = src[7]; + dst[8] = src[8]; + dst[9] = src[9]; + dst[10] = src[10]; + dst[11] = src[11]; + dst[12] = src[12]; + dst[13] = src[13]; + dst[14] = src[14]; + dst[15] = src[15]; + return this; + } + equals(rhs) { + const l = this.data, r = rhs.data; + return l[0] === r[0] && l[1] === r[1] && l[2] === r[2] && l[3] === r[3] && l[4] === r[4] && l[5] === r[5] && l[6] === r[6] && l[7] === r[7] && l[8] === r[8] && l[9] === r[9] && l[10] === r[10] && l[11] === r[11] && l[12] === r[12] && l[13] === r[13] && l[14] === r[14] && l[15] === r[15]; + } + isIdentity() { + const m = this.data; + return m[0] === 1 && m[1] === 0 && m[2] === 0 && m[3] === 0 && m[4] === 0 && m[5] === 1 && m[6] === 0 && m[7] === 0 && m[8] === 0 && m[9] === 0 && m[10] === 1 && m[11] === 0 && m[12] === 0 && m[13] === 0 && m[14] === 0 && m[15] === 1; + } + mul2(lhs, rhs) { + const a = lhs.data; + const b = rhs.data; + const r = this.data; + const a00 = a[0]; + const a01 = a[1]; + const a02 = a[2]; + const a03 = a[3]; + const a10 = a[4]; + const a11 = a[5]; + const a12 = a[6]; + const a13 = a[7]; + const a20 = a[8]; + const a21 = a[9]; + const a22 = a[10]; + const a23 = a[11]; + const a30 = a[12]; + const a31 = a[13]; + const a32 = a[14]; + const a33 = a[15]; + let b0, b1, b2, b3; + b0 = b[0]; + b1 = b[1]; + b2 = b[2]; + b3 = b[3]; + r[0] = a00 * b0 + a10 * b1 + a20 * b2 + a30 * b3; + r[1] = a01 * b0 + a11 * b1 + a21 * b2 + a31 * b3; + r[2] = a02 * b0 + a12 * b1 + a22 * b2 + a32 * b3; + r[3] = a03 * b0 + a13 * b1 + a23 * b2 + a33 * b3; + b0 = b[4]; + b1 = b[5]; + b2 = b[6]; + b3 = b[7]; + r[4] = a00 * b0 + a10 * b1 + a20 * b2 + a30 * b3; + r[5] = a01 * b0 + a11 * b1 + a21 * b2 + a31 * b3; + r[6] = a02 * b0 + a12 * b1 + a22 * b2 + a32 * b3; + r[7] = a03 * b0 + a13 * b1 + a23 * b2 + a33 * b3; + b0 = b[8]; + b1 = b[9]; + b2 = b[10]; + b3 = b[11]; + r[8] = a00 * b0 + a10 * b1 + a20 * b2 + a30 * b3; + r[9] = a01 * b0 + a11 * b1 + a21 * b2 + a31 * b3; + r[10] = a02 * b0 + a12 * b1 + a22 * b2 + a32 * b3; + r[11] = a03 * b0 + a13 * b1 + a23 * b2 + a33 * b3; + b0 = b[12]; + b1 = b[13]; + b2 = b[14]; + b3 = b[15]; + r[12] = a00 * b0 + a10 * b1 + a20 * b2 + a30 * b3; + r[13] = a01 * b0 + a11 * b1 + a21 * b2 + a31 * b3; + r[14] = a02 * b0 + a12 * b1 + a22 * b2 + a32 * b3; + r[15] = a03 * b0 + a13 * b1 + a23 * b2 + a33 * b3; + return this; + } + mulAffine2(lhs, rhs) { + const a = lhs.data; + const b = rhs.data; + const r = this.data; + const a00 = a[0]; + const a01 = a[1]; + const a02 = a[2]; + const a10 = a[4]; + const a11 = a[5]; + const a12 = a[6]; + const a20 = a[8]; + const a21 = a[9]; + const a22 = a[10]; + const a30 = a[12]; + const a31 = a[13]; + const a32 = a[14]; + let b0, b1, b2; + b0 = b[0]; + b1 = b[1]; + b2 = b[2]; + r[0] = a00 * b0 + a10 * b1 + a20 * b2; + r[1] = a01 * b0 + a11 * b1 + a21 * b2; + r[2] = a02 * b0 + a12 * b1 + a22 * b2; + r[3] = 0; + b0 = b[4]; + b1 = b[5]; + b2 = b[6]; + r[4] = a00 * b0 + a10 * b1 + a20 * b2; + r[5] = a01 * b0 + a11 * b1 + a21 * b2; + r[6] = a02 * b0 + a12 * b1 + a22 * b2; + r[7] = 0; + b0 = b[8]; + b1 = b[9]; + b2 = b[10]; + r[8] = a00 * b0 + a10 * b1 + a20 * b2; + r[9] = a01 * b0 + a11 * b1 + a21 * b2; + r[10] = a02 * b0 + a12 * b1 + a22 * b2; + r[11] = 0; + b0 = b[12]; + b1 = b[13]; + b2 = b[14]; + r[12] = a00 * b0 + a10 * b1 + a20 * b2 + a30; + r[13] = a01 * b0 + a11 * b1 + a21 * b2 + a31; + r[14] = a02 * b0 + a12 * b1 + a22 * b2 + a32; + r[15] = 1; + return this; + } + mul(rhs) { + return this.mul2(this, rhs); + } + transformPoint(vec2, res = new Vec3()) { + const m = this.data; + const { + x: x2, + y: y2, + z: z2 + } = vec2; + res.x = x2 * m[0] + y2 * m[4] + z2 * m[8] + m[12]; + res.y = x2 * m[1] + y2 * m[5] + z2 * m[9] + m[13]; + res.z = x2 * m[2] + y2 * m[6] + z2 * m[10] + m[14]; + return res; + } + transformVector(vec2, res = new Vec3()) { + const m = this.data; + const { + x: x2, + y: y2, + z: z2 + } = vec2; + res.x = x2 * m[0] + y2 * m[4] + z2 * m[8]; + res.y = x2 * m[1] + y2 * m[5] + z2 * m[9]; + res.z = x2 * m[2] + y2 * m[6] + z2 * m[10]; + return res; + } + transformVec4(vec2, res = new Vec4()) { + const m = this.data; + const { + x: x2, + y: y2, + z: z2, + w + } = vec2; + res.x = x2 * m[0] + y2 * m[4] + z2 * m[8] + w * m[12]; + res.y = x2 * m[1] + y2 * m[5] + z2 * m[9] + w * m[13]; + res.z = x2 * m[2] + y2 * m[6] + z2 * m[10] + w * m[14]; + res.w = x2 * m[3] + y2 * m[7] + z2 * m[11] + w * m[15]; + return res; + } + setLookAt(position2, target2, up3) { + z.sub2(position2, target2).normalize(); + y.copy(up3).normalize(); + x.cross(y, z).normalize(); + y.cross(z, x); + const r = this.data; + r[0] = x.x; + r[1] = x.y; + r[2] = x.z; + r[3] = 0; + r[4] = y.x; + r[5] = y.y; + r[6] = y.z; + r[7] = 0; + r[8] = z.x; + r[9] = z.y; + r[10] = z.z; + r[11] = 0; + r[12] = position2.x; + r[13] = position2.y; + r[14] = position2.z; + r[15] = 1; + return this; + } + setFrustum(left, right2, bottom, top, znear, zfar) { + const temp1 = 2 * znear; + const temp2 = right2 - left; + const temp3 = top - bottom; + const temp4 = zfar - znear; + const r = this.data; + r[0] = temp1 / temp2; + r[1] = 0; + r[2] = 0; + r[3] = 0; + r[4] = 0; + r[5] = temp1 / temp3; + r[6] = 0; + r[7] = 0; + r[8] = (right2 + left) / temp2; + r[9] = (top + bottom) / temp3; + r[10] = (-zfar - znear) / temp4; + r[11] = -1; + r[12] = 0; + r[13] = 0; + r[14] = -temp1 * zfar / temp4; + r[15] = 0; + return this; + } + setPerspective(fov, aspect, znear, zfar, fovIsHorizontal) { + _Mat4._getPerspectiveHalfSize(_halfSize, fov, aspect, znear, fovIsHorizontal); + return this.setFrustum(-_halfSize.x, _halfSize.x, -_halfSize.y, _halfSize.y, znear, zfar); + } + setOrtho(left, right2, bottom, top, near, far) { + const r = this.data; + r[0] = 2 / (right2 - left); + r[1] = 0; + r[2] = 0; + r[3] = 0; + r[4] = 0; + r[5] = 2 / (top - bottom); + r[6] = 0; + r[7] = 0; + r[8] = 0; + r[9] = 0; + r[10] = -2 / (far - near); + r[11] = 0; + r[12] = -(right2 + left) / (right2 - left); + r[13] = -(top + bottom) / (top - bottom); + r[14] = -(far + near) / (far - near); + r[15] = 1; + return this; + } + setFromAxisAngle(axis, angle) { + angle *= math.DEG_TO_RAD; + const { + x: x2, + y: y2, + z: z2 + } = axis; + const c2 = Math.cos(angle); + const s = Math.sin(angle); + const t = 1 - c2; + const tx = t * x2; + const ty = t * y2; + const m = this.data; + m[0] = tx * x2 + c2; + m[1] = tx * y2 + s * z2; + m[2] = tx * z2 - s * y2; + m[3] = 0; + m[4] = tx * y2 - s * z2; + m[5] = ty * y2 + c2; + m[6] = ty * z2 + s * x2; + m[7] = 0; + m[8] = tx * z2 + s * y2; + m[9] = ty * z2 - x2 * s; + m[10] = t * z2 * z2 + c2; + m[11] = 0; + m[12] = 0; + m[13] = 0; + m[14] = 0; + m[15] = 1; + return this; + } + setTranslate(x2, y2, z2) { + const m = this.data; + m[0] = 1; + m[1] = 0; + m[2] = 0; + m[3] = 0; + m[4] = 0; + m[5] = 1; + m[6] = 0; + m[7] = 0; + m[8] = 0; + m[9] = 0; + m[10] = 1; + m[11] = 0; + m[12] = x2; + m[13] = y2; + m[14] = z2; + m[15] = 1; + return this; + } + setScale(x2, y2, z2) { + const m = this.data; + m[0] = x2; + m[1] = 0; + m[2] = 0; + m[3] = 0; + m[4] = 0; + m[5] = y2; + m[6] = 0; + m[7] = 0; + m[8] = 0; + m[9] = 0; + m[10] = z2; + m[11] = 0; + m[12] = 0; + m[13] = 0; + m[14] = 0; + m[15] = 1; + return this; + } + setViewport(x2, y2, width, height) { + const m = this.data; + m[0] = width * 0.5; + m[1] = 0; + m[2] = 0; + m[3] = 0; + m[4] = 0; + m[5] = height * 0.5; + m[6] = 0; + m[7] = 0; + m[8] = 0; + m[9] = 0; + m[10] = 0.5; + m[11] = 0; + m[12] = x2 + width * 0.5; + m[13] = y2 + height * 0.5; + m[14] = 0.5; + m[15] = 1; + return this; + } + setReflection(normal, distance) { + const a = normal.x; + const b = normal.y; + const c2 = normal.z; + const data2 = this.data; + data2[0] = 1 - 2 * a * a; + data2[1] = -2 * a * b; + data2[2] = -2 * a * c2; + data2[3] = 0; + data2[4] = -2 * a * b; + data2[5] = 1 - 2 * b * b; + data2[6] = -2 * b * c2; + data2[7] = 0; + data2[8] = -2 * a * c2; + data2[9] = -2 * b * c2; + data2[10] = 1 - 2 * c2 * c2; + data2[11] = 0; + data2[12] = -2 * a * distance; + data2[13] = -2 * b * distance; + data2[14] = -2 * c2 * distance; + data2[15] = 1; + return this; + } + invert(src = this) { + const s = src.data; + const a00 = s[0]; + const a01 = s[1]; + const a02 = s[2]; + const a03 = s[3]; + const a10 = s[4]; + const a11 = s[5]; + const a12 = s[6]; + const a13 = s[7]; + const a20 = s[8]; + const a21 = s[9]; + const a22 = s[10]; + const a23 = s[11]; + const a30 = s[12]; + const a31 = s[13]; + const a32 = s[14]; + const a33 = s[15]; + const b00 = a00 * a11 - a01 * a10; + const b01 = a00 * a12 - a02 * a10; + const b02 = a00 * a13 - a03 * a10; + const b03 = a01 * a12 - a02 * a11; + const b04 = a01 * a13 - a03 * a11; + const b05 = a02 * a13 - a03 * a12; + const b06 = a20 * a31 - a21 * a30; + const b07 = a20 * a32 - a22 * a30; + const b08 = a20 * a33 - a23 * a30; + const b09 = a21 * a32 - a22 * a31; + const b10 = a21 * a33 - a23 * a31; + const b11 = a22 * a33 - a23 * a32; + const det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06; + if (det === 0) { + this.setIdentity(); + } else { + const invDet = 1 / det; + const t = this.data; + t[0] = (a11 * b11 - a12 * b10 + a13 * b09) * invDet; + t[1] = (-a01 * b11 + a02 * b10 - a03 * b09) * invDet; + t[2] = (a31 * b05 - a32 * b04 + a33 * b03) * invDet; + t[3] = (-a21 * b05 + a22 * b04 - a23 * b03) * invDet; + t[4] = (-a10 * b11 + a12 * b08 - a13 * b07) * invDet; + t[5] = (a00 * b11 - a02 * b08 + a03 * b07) * invDet; + t[6] = (-a30 * b05 + a32 * b02 - a33 * b01) * invDet; + t[7] = (a20 * b05 - a22 * b02 + a23 * b01) * invDet; + t[8] = (a10 * b10 - a11 * b08 + a13 * b06) * invDet; + t[9] = (-a00 * b10 + a01 * b08 - a03 * b06) * invDet; + t[10] = (a30 * b04 - a31 * b02 + a33 * b00) * invDet; + t[11] = (-a20 * b04 + a21 * b02 - a23 * b00) * invDet; + t[12] = (-a10 * b09 + a11 * b07 - a12 * b06) * invDet; + t[13] = (a00 * b09 - a01 * b07 + a02 * b06) * invDet; + t[14] = (-a30 * b03 + a31 * b01 - a32 * b00) * invDet; + t[15] = (a20 * b03 - a21 * b01 + a22 * b00) * invDet; + } + return this; + } + set(src) { + const dst = this.data; + dst[0] = src[0]; + dst[1] = src[1]; + dst[2] = src[2]; + dst[3] = src[3]; + dst[4] = src[4]; + dst[5] = src[5]; + dst[6] = src[6]; + dst[7] = src[7]; + dst[8] = src[8]; + dst[9] = src[9]; + dst[10] = src[10]; + dst[11] = src[11]; + dst[12] = src[12]; + dst[13] = src[13]; + dst[14] = src[14]; + dst[15] = src[15]; + return this; + } + setIdentity() { + const m = this.data; + m[0] = 1; + m[1] = 0; + m[2] = 0; + m[3] = 0; + m[4] = 0; + m[5] = 1; + m[6] = 0; + m[7] = 0; + m[8] = 0; + m[9] = 0; + m[10] = 1; + m[11] = 0; + m[12] = 0; + m[13] = 0; + m[14] = 0; + m[15] = 1; + return this; + } + setTRS(t, r, s) { + const qx = r.x; + const qy = r.y; + const qz = r.z; + const qw = r.w; + const sx = s.x; + const sy = s.y; + const sz = s.z; + const x2 = qx + qx; + const y2 = qy + qy; + const z2 = qz + qz; + const xx = qx * x2; + const xy = qx * y2; + const xz = qx * z2; + const yy = qy * y2; + const yz = qy * z2; + const zz = qz * z2; + const wx = qw * x2; + const wy = qw * y2; + const wz = qw * z2; + const m = this.data; + m[0] = (1 - (yy + zz)) * sx; + m[1] = (xy + wz) * sx; + m[2] = (xz - wy) * sx; + m[3] = 0; + m[4] = (xy - wz) * sy; + m[5] = (1 - (xx + zz)) * sy; + m[6] = (yz + wx) * sy; + m[7] = 0; + m[8] = (xz + wy) * sz; + m[9] = (yz - wx) * sz; + m[10] = (1 - (xx + yy)) * sz; + m[11] = 0; + m[12] = t.x; + m[13] = t.y; + m[14] = t.z; + m[15] = 1; + return this; + } + transpose(src = this) { + const s = src.data; + const t = this.data; + if (s === t) { + let tmp; + tmp = s[1]; + t[1] = s[4]; + t[4] = tmp; + tmp = s[2]; + t[2] = s[8]; + t[8] = tmp; + tmp = s[3]; + t[3] = s[12]; + t[12] = tmp; + tmp = s[6]; + t[6] = s[9]; + t[9] = tmp; + tmp = s[7]; + t[7] = s[13]; + t[13] = tmp; + tmp = s[11]; + t[11] = s[14]; + t[14] = tmp; + } else { + t[0] = s[0]; + t[1] = s[4]; + t[2] = s[8]; + t[3] = s[12]; + t[4] = s[1]; + t[5] = s[5]; + t[6] = s[9]; + t[7] = s[13]; + t[8] = s[2]; + t[9] = s[6]; + t[10] = s[10]; + t[11] = s[14]; + t[12] = s[3]; + t[13] = s[7]; + t[14] = s[11]; + t[15] = s[15]; + } + return this; + } + getTranslation(t = new Vec3()) { + return t.set(this.data[12], this.data[13], this.data[14]); + } + getX(x2 = new Vec3()) { + return x2.set(this.data[0], this.data[1], this.data[2]); + } + getY(y2 = new Vec3()) { + return y2.set(this.data[4], this.data[5], this.data[6]); + } + getZ(z2 = new Vec3()) { + return z2.set(this.data[8], this.data[9], this.data[10]); + } + getScale(scale2 = new Vec3()) { + this.getX(x); + this.getY(y); + this.getZ(z); + scale2.set(x.length(), y.length(), z.length()); + return scale2; + } + get scaleSign() { + this.getX(x); + this.getY(y); + this.getZ(z); + x.cross(x, y); + return x.dot(z) < 0 ? -1 : 1; + } + setFromEulerAngles(ex, ey, ez) { + ex *= math.DEG_TO_RAD; + ey *= math.DEG_TO_RAD; + ez *= math.DEG_TO_RAD; + const s1 = Math.sin(-ex); + const c1 = Math.cos(-ex); + const s2 = Math.sin(-ey); + const c2 = Math.cos(-ey); + const s3 = Math.sin(-ez); + const c3 = Math.cos(-ez); + const m = this.data; + m[0] = c2 * c3; + m[1] = -c2 * s3; + m[2] = s2; + m[3] = 0; + m[4] = c1 * s3 + c3 * s1 * s2; + m[5] = c1 * c3 - s1 * s2 * s3; + m[6] = -c2 * s1; + m[7] = 0; + m[8] = s1 * s3 - c1 * c3 * s2; + m[9] = c3 * s1 + c1 * s2 * s3; + m[10] = c1 * c2; + m[11] = 0; + m[12] = 0; + m[13] = 0; + m[14] = 0; + m[15] = 1; + return this; + } + getEulerAngles(eulers = new Vec3()) { + this.getScale(scale); + const sx = scale.x; + const sy = scale.y; + const sz = scale.z; + if (sx === 0 || sy === 0 || sz === 0) return eulers.set(0, 0, 0); + const m = this.data; + const y2 = Math.asin(-m[2] / sx); + const halfPi = Math.PI * 0.5; + let x2, z2; + if (y2 < halfPi) { + if (y2 > -halfPi) { + x2 = Math.atan2(m[6] / sy, m[10] / sz); + z2 = Math.atan2(m[1] / sx, m[0] / sx); + } else { + z2 = 0; + x2 = -Math.atan2(m[4] / sy, m[5] / sy); + } + } else { + z2 = 0; + x2 = Math.atan2(m[4] / sy, m[5] / sy); + } + return eulers.set(x2, y2, z2).mulScalar(math.RAD_TO_DEG); + } + toString() { + return "[" + this.data.join(", ") + "]"; + } +}; +_Mat2 = Mat4; +Mat4.IDENTITY = Object.freeze(new _Mat2()); +Mat4.ZERO = Object.freeze(new _Mat2().set([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])); + +// ../../node_modules/playcanvas/build/playcanvas/src/core/math/quat.js +var _Quat; +var Quat2 = class { + constructor(x2 = 0, y2 = 0, z2 = 0, w = 1) { + this.x = void 0; + this.y = void 0; + this.z = void 0; + this.w = void 0; + if (x2.length === 4) { + this.x = x2[0]; + this.y = x2[1]; + this.z = x2[2]; + this.w = x2[3]; + } else { + this.x = x2; + this.y = y2; + this.z = z2; + this.w = w; + } + } + clone() { + const cstr = this.constructor; + return new cstr(this.x, this.y, this.z, this.w); + } + conjugate(src = this) { + this.x = src.x * -1; + this.y = src.y * -1; + this.z = src.z * -1; + this.w = src.w; + return this; + } + copy(rhs) { + this.x = rhs.x; + this.y = rhs.y; + this.z = rhs.z; + this.w = rhs.w; + return this; + } + equals(rhs) { + return this.x === rhs.x && this.y === rhs.y && this.z === rhs.z && this.w === rhs.w; + } + equalsApprox(rhs, epsilon3 = 1e-6) { + return Math.abs(this.x - rhs.x) < epsilon3 && Math.abs(this.y - rhs.y) < epsilon3 && Math.abs(this.z - rhs.z) < epsilon3 && Math.abs(this.w - rhs.w) < epsilon3; + } + getAxisAngle(axis) { + let rad = Math.acos(this.w) * 2; + const s = Math.sin(rad / 2); + if (s !== 0) { + axis.x = this.x / s; + axis.y = this.y / s; + axis.z = this.z / s; + if (axis.x < 0 || axis.y < 0 || axis.z < 0) { + axis.x *= -1; + axis.y *= -1; + axis.z *= -1; + rad *= -1; + } + } else { + axis.x = 1; + axis.y = 0; + axis.z = 0; + } + return rad * math.RAD_TO_DEG; + } + getEulerAngles(eulers = new Vec3()) { + let x2, y2, z2; + const qx = this.x; + const qy = this.y; + const qz = this.z; + const qw = this.w; + const a2 = 2 * (qw * qy - qx * qz); + if (a2 <= -0.99999) { + x2 = 2 * Math.atan2(qx, qw); + y2 = -Math.PI / 2; + z2 = 0; + } else if (a2 >= 0.99999) { + x2 = 2 * Math.atan2(qx, qw); + y2 = Math.PI / 2; + z2 = 0; + } else { + x2 = Math.atan2(2 * (qw * qx + qy * qz), 1 - 2 * (qx * qx + qy * qy)); + y2 = Math.asin(a2); + z2 = Math.atan2(2 * (qw * qz + qx * qy), 1 - 2 * (qy * qy + qz * qz)); + } + return eulers.set(x2, y2, z2).mulScalar(math.RAD_TO_DEG); + } + invert(src = this) { + return this.conjugate(src).normalize(); + } + length() { + return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w); + } + lengthSq() { + return this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w; + } + mul(rhs) { + const q1x = this.x; + const q1y = this.y; + const q1z = this.z; + const q1w = this.w; + const q2x = rhs.x; + const q2y = rhs.y; + const q2z = rhs.z; + const q2w = rhs.w; + this.x = q1w * q2x + q1x * q2w + q1y * q2z - q1z * q2y; + this.y = q1w * q2y + q1y * q2w + q1z * q2x - q1x * q2z; + this.z = q1w * q2z + q1z * q2w + q1x * q2y - q1y * q2x; + this.w = q1w * q2w - q1x * q2x - q1y * q2y - q1z * q2z; + return this; + } + mulScalar(scalar, src = this) { + this.x = src.x * scalar; + this.y = src.y * scalar; + this.z = src.z * scalar; + this.w = src.w * scalar; + return this; + } + mul2(lhs, rhs) { + const q1x = lhs.x; + const q1y = lhs.y; + const q1z = lhs.z; + const q1w = lhs.w; + const q2x = rhs.x; + const q2y = rhs.y; + const q2z = rhs.z; + const q2w = rhs.w; + this.x = q1w * q2x + q1x * q2w + q1y * q2z - q1z * q2y; + this.y = q1w * q2y + q1y * q2w + q1z * q2x - q1x * q2z; + this.z = q1w * q2z + q1z * q2w + q1x * q2y - q1y * q2x; + this.w = q1w * q2w - q1x * q2x - q1y * q2y - q1z * q2z; + return this; + } + normalize(src = this) { + let len = src.length(); + if (len === 0) { + this.x = this.y = this.z = 0; + this.w = 1; + } else { + len = 1 / len; + this.x = src.x * len; + this.y = src.y * len; + this.z = src.z * len; + this.w = src.w * len; + } + return this; + } + set(x2, y2, z2, w) { + this.x = x2; + this.y = y2; + this.z = z2; + this.w = w; + return this; + } + setFromAxisAngle(axis, angle) { + angle *= 0.5 * math.DEG_TO_RAD; + const sa = Math.sin(angle); + const ca = Math.cos(angle); + this.x = sa * axis.x; + this.y = sa * axis.y; + this.z = sa * axis.z; + this.w = ca; + return this; + } + setFromEulerAngles(ex, ey, ez) { + if (ex instanceof Vec3) { + const vec2 = ex; + ex = vec2.x; + ey = vec2.y; + ez = vec2.z; + } + const halfToRad2 = 0.5 * math.DEG_TO_RAD; + ex *= halfToRad2; + ey *= halfToRad2; + ez *= halfToRad2; + const sx = Math.sin(ex); + const cx = Math.cos(ex); + const sy = Math.sin(ey); + const cy = Math.cos(ey); + const sz = Math.sin(ez); + const cz = Math.cos(ez); + this.x = sx * cy * cz - cx * sy * sz; + this.y = cx * sy * cz + sx * cy * sz; + this.z = cx * cy * sz - sx * sy * cz; + this.w = cx * cy * cz + sx * sy * sz; + return this; + } + setFromMat4(m) { + const d = m.data; + let m00 = d[0]; + let m01 = d[1]; + let m02 = d[2]; + let m10 = d[4]; + let m11 = d[5]; + let m12 = d[6]; + let m20 = d[8]; + let m21 = d[9]; + let m22 = d[10]; + let l; + l = m00 * m00 + m01 * m01 + m02 * m02; + if (l === 0) return this.set(0, 0, 0, 1); + l = 1 / Math.sqrt(l); + m00 *= l; + m01 *= l; + m02 *= l; + l = m10 * m10 + m11 * m11 + m12 * m12; + if (l === 0) return this.set(0, 0, 0, 1); + l = 1 / Math.sqrt(l); + m10 *= l; + m11 *= l; + m12 *= l; + l = m20 * m20 + m21 * m21 + m22 * m22; + if (l === 0) return this.set(0, 0, 0, 1); + l = 1 / Math.sqrt(l); + m20 *= l; + m21 *= l; + m22 *= l; + if (m22 < 0) { + if (m00 > m11) { + this.set(1 + m00 - m11 - m22, m01 + m10, m20 + m02, m12 - m21); + } else { + this.set(m01 + m10, 1 - m00 + m11 - m22, m12 + m21, m20 - m02); + } + } else { + if (m00 < -m11) { + this.set(m20 + m02, m12 + m21, 1 - m00 - m11 + m22, m01 - m10); + } else { + this.set(m12 - m21, m20 - m02, m01 - m10, 1 + m00 + m11 + m22); + } + } + return this.mulScalar(1 / this.length()); + } + setFromDirections(from, to) { + const dotProduct = 1 + from.dot(to); + if (dotProduct < Number.EPSILON) { + if (Math.abs(from.x) > Math.abs(from.y)) { + this.x = -from.z; + this.y = 0; + this.z = from.x; + this.w = 0; + } else { + this.x = 0; + this.y = -from.z; + this.z = from.y; + this.w = 0; + } + } else { + this.x = from.y * to.z - from.z * to.y; + this.y = from.z * to.x - from.x * to.z; + this.z = from.x * to.y - from.y * to.x; + this.w = dotProduct; + } + return this.normalize(); + } + slerp(lhs, rhs, alpha) { + const lx = lhs.x; + const ly = lhs.y; + const lz = lhs.z; + const lw = lhs.w; + let rx = rhs.x; + let ry = rhs.y; + let rz = rhs.z; + let rw = rhs.w; + let cosHalfTheta = lw * rw + lx * rx + ly * ry + lz * rz; + if (cosHalfTheta < 0) { + rw = -rw; + rx = -rx; + ry = -ry; + rz = -rz; + cosHalfTheta = -cosHalfTheta; + } + if (Math.abs(cosHalfTheta) >= 1) { + this.w = lw; + this.x = lx; + this.y = ly; + this.z = lz; + return this; + } + const halfTheta = Math.acos(cosHalfTheta); + const sinHalfTheta = Math.sqrt(1 - cosHalfTheta * cosHalfTheta); + if (Math.abs(sinHalfTheta) < 1e-3) { + this.w = lw * 0.5 + rw * 0.5; + this.x = lx * 0.5 + rx * 0.5; + this.y = ly * 0.5 + ry * 0.5; + this.z = lz * 0.5 + rz * 0.5; + return this; + } + const ratioA = Math.sin((1 - alpha) * halfTheta) / sinHalfTheta; + const ratioB = Math.sin(alpha * halfTheta) / sinHalfTheta; + this.w = lw * ratioA + rw * ratioB; + this.x = lx * ratioA + rx * ratioB; + this.y = ly * ratioA + ry * ratioB; + this.z = lz * ratioA + rz * ratioB; + return this; + } + transformVector(vec2, res = new Vec3()) { + const x2 = vec2.x, y2 = vec2.y, z2 = vec2.z; + const qx = this.x, qy = this.y, qz = this.z, qw = this.w; + const ix = qw * x2 + qy * z2 - qz * y2; + const iy = qw * y2 + qz * x2 - qx * z2; + const iz = qw * z2 + qx * y2 - qy * x2; + const iw = -qx * x2 - qy * y2 - qz * z2; + res.x = ix * qw + iw * -qx + iy * -qz - iz * -qy; + res.y = iy * qw + iw * -qy + iz * -qx - ix * -qz; + res.z = iz * qw + iw * -qz + ix * -qy - iy * -qx; + return res; + } + toString() { + return `[${this.x}, ${this.y}, ${this.z}, ${this.w}]`; + } +}; +_Quat = Quat2; +Quat2.IDENTITY = Object.freeze(new _Quat(0, 0, 0, 1)); +Quat2.ZERO = Object.freeze(new _Quat(0, 0, 0, 0)); + +// ../../node_modules/playcanvas/build/playcanvas/src/core/shape/bounding-box.js +var tmpVecA = new Vec3(); +var tmpVecB = new Vec3(); +var tmpVecC = new Vec3(); +var tmpVecD = new Vec3(); +var tmpVecE = new Vec3(); +var BoundingBox = class _BoundingBox { + constructor(center2 = new Vec3(), halfExtents = new Vec3(0.5, 0.5, 0.5)) { + this.center = void 0; + this.halfExtents = void 0; + this._min = new Vec3(); + this._max = new Vec3(); + this.center = center2; + this.halfExtents = halfExtents; + } + add(other) { + const tc = this.center; + const tcx = tc.x; + const tcy = tc.y; + const tcz = tc.z; + const th = this.halfExtents; + const thx = th.x; + const thy = th.y; + const thz = th.z; + let tminx = tcx - thx; + let tmaxx = tcx + thx; + let tminy = tcy - thy; + let tmaxy = tcy + thy; + let tminz = tcz - thz; + let tmaxz = tcz + thz; + const oc = other.center; + const ocx = oc.x; + const ocy = oc.y; + const ocz = oc.z; + const oh = other.halfExtents; + const ohx = oh.x; + const ohy = oh.y; + const ohz = oh.z; + const ominx = ocx - ohx; + const omaxx = ocx + ohx; + const ominy = ocy - ohy; + const omaxy = ocy + ohy; + const ominz = ocz - ohz; + const omaxz = ocz + ohz; + if (ominx < tminx) tminx = ominx; + if (omaxx > tmaxx) tmaxx = omaxx; + if (ominy < tminy) tminy = ominy; + if (omaxy > tmaxy) tmaxy = omaxy; + if (ominz < tminz) tminz = ominz; + if (omaxz > tmaxz) tmaxz = omaxz; + tc.x = (tminx + tmaxx) * 0.5; + tc.y = (tminy + tmaxy) * 0.5; + tc.z = (tminz + tmaxz) * 0.5; + th.x = (tmaxx - tminx) * 0.5; + th.y = (tmaxy - tminy) * 0.5; + th.z = (tmaxz - tminz) * 0.5; + } + copy(src) { + this.center.copy(src.center); + this.halfExtents.copy(src.halfExtents); + } + clone() { + return new _BoundingBox(this.center.clone(), this.halfExtents.clone()); + } + intersects(other) { + const aMax = this.getMax(); + const aMin = this.getMin(); + const bMax = other.getMax(); + const bMin = other.getMin(); + return aMin.x <= bMax.x && aMax.x >= bMin.x && aMin.y <= bMax.y && aMax.y >= bMin.y && aMin.z <= bMax.z && aMax.z >= bMin.z; + } + _intersectsRay(ray, point) { + const tMin = tmpVecA.copy(this.getMin()).sub(ray.origin); + const tMax = tmpVecB.copy(this.getMax()).sub(ray.origin); + const dir = ray.direction; + if (dir.x === 0) { + tMin.x = tMin.x < 0 ? -Number.MAX_VALUE : Number.MAX_VALUE; + tMax.x = tMax.x < 0 ? -Number.MAX_VALUE : Number.MAX_VALUE; + } else { + tMin.x /= dir.x; + tMax.x /= dir.x; + } + if (dir.y === 0) { + tMin.y = tMin.y < 0 ? -Number.MAX_VALUE : Number.MAX_VALUE; + tMax.y = tMax.y < 0 ? -Number.MAX_VALUE : Number.MAX_VALUE; + } else { + tMin.y /= dir.y; + tMax.y /= dir.y; + } + if (dir.z === 0) { + tMin.z = tMin.z < 0 ? -Number.MAX_VALUE : Number.MAX_VALUE; + tMax.z = tMax.z < 0 ? -Number.MAX_VALUE : Number.MAX_VALUE; + } else { + tMin.z /= dir.z; + tMax.z /= dir.z; + } + const realMin = tmpVecC.set(Math.min(tMin.x, tMax.x), Math.min(tMin.y, tMax.y), Math.min(tMin.z, tMax.z)); + const realMax = tmpVecD.set(Math.max(tMin.x, tMax.x), Math.max(tMin.y, tMax.y), Math.max(tMin.z, tMax.z)); + const minMax = Math.min(Math.min(realMax.x, realMax.y), realMax.z); + const maxMin = Math.max(Math.max(realMin.x, realMin.y), realMin.z); + const intersects = minMax >= maxMin && maxMin >= 0; + if (intersects) point.copy(ray.direction).mulScalar(maxMin).add(ray.origin); + return intersects; + } + _fastIntersectsRay(ray) { + const diff = tmpVecA; + const cross = tmpVecB; + const prod = tmpVecC; + const absDiff = tmpVecD; + const absDir = tmpVecE; + const rayDir = ray.direction; + diff.sub2(ray.origin, this.center); + absDiff.set(Math.abs(diff.x), Math.abs(diff.y), Math.abs(diff.z)); + prod.mul2(diff, rayDir); + if (absDiff.x > this.halfExtents.x && prod.x >= 0) return false; + if (absDiff.y > this.halfExtents.y && prod.y >= 0) return false; + if (absDiff.z > this.halfExtents.z && prod.z >= 0) return false; + absDir.set(Math.abs(rayDir.x), Math.abs(rayDir.y), Math.abs(rayDir.z)); + cross.cross(rayDir, diff); + cross.set(Math.abs(cross.x), Math.abs(cross.y), Math.abs(cross.z)); + if (cross.x > this.halfExtents.y * absDir.z + this.halfExtents.z * absDir.y) return false; + if (cross.y > this.halfExtents.x * absDir.z + this.halfExtents.z * absDir.x) return false; + if (cross.z > this.halfExtents.x * absDir.y + this.halfExtents.y * absDir.x) return false; + return true; + } + intersectsRay(ray, point) { + if (point) { + return this._intersectsRay(ray, point); + } + return this._fastIntersectsRay(ray); + } + setMinMax(min, max) { + this.center.add2(max, min).mulScalar(0.5); + this.halfExtents.sub2(max, min).mulScalar(0.5); + } + getMin() { + return this._min.copy(this.center).sub(this.halfExtents); + } + getMax() { + return this._max.copy(this.center).add(this.halfExtents); + } + containsPoint(point) { + const min = this.getMin(); + const max = this.getMax(); + if (point.x < min.x || point.x > max.x || point.y < min.y || point.y > max.y || point.z < min.z || point.z > max.z) { + return false; + } + return true; + } + setFromTransformedAabb(aabb, m, ignoreScale = false) { + const ac = aabb.center; + const ar = aabb.halfExtents; + const d = m.data; + let mx0 = d[0]; + let mx1 = d[4]; + let mx2 = d[8]; + let my0 = d[1]; + let my1 = d[5]; + let my2 = d[9]; + let mz0 = d[2]; + let mz1 = d[6]; + let mz2 = d[10]; + if (ignoreScale) { + let lengthSq = mx0 * mx0 + mx1 * mx1 + mx2 * mx2; + if (lengthSq > 0) { + const invLength = 1 / Math.sqrt(lengthSq); + mx0 *= invLength; + mx1 *= invLength; + mx2 *= invLength; + } + lengthSq = my0 * my0 + my1 * my1 + my2 * my2; + if (lengthSq > 0) { + const invLength = 1 / Math.sqrt(lengthSq); + my0 *= invLength; + my1 *= invLength; + my2 *= invLength; + } + lengthSq = mz0 * mz0 + mz1 * mz1 + mz2 * mz2; + if (lengthSq > 0) { + const invLength = 1 / Math.sqrt(lengthSq); + mz0 *= invLength; + mz1 *= invLength; + mz2 *= invLength; + } + } + this.center.set(d[12] + mx0 * ac.x + mx1 * ac.y + mx2 * ac.z, d[13] + my0 * ac.x + my1 * ac.y + my2 * ac.z, d[14] + mz0 * ac.x + mz1 * ac.y + mz2 * ac.z); + this.halfExtents.set(Math.abs(mx0) * ar.x + Math.abs(mx1) * ar.y + Math.abs(mx2) * ar.z, Math.abs(my0) * ar.x + Math.abs(my1) * ar.y + Math.abs(my2) * ar.z, Math.abs(mz0) * ar.x + Math.abs(mz1) * ar.y + Math.abs(mz2) * ar.z); + } + static computeMinMax(vertices, min, max, numVerts = vertices.length / 3) { + if (numVerts > 0) { + let minx = vertices[0]; + let miny = vertices[1]; + let minz = vertices[2]; + let maxx = minx; + let maxy = miny; + let maxz = minz; + const n = numVerts * 3; + for (let i = 3; i < n; i += 3) { + const x2 = vertices[i]; + const y2 = vertices[i + 1]; + const z2 = vertices[i + 2]; + if (x2 < minx) minx = x2; + if (y2 < miny) miny = y2; + if (z2 < minz) minz = z2; + if (x2 > maxx) maxx = x2; + if (y2 > maxy) maxy = y2; + if (z2 > maxz) maxz = z2; + } + min.set(minx, miny, minz); + max.set(maxx, maxy, maxz); + } + } + compute(vertices, numVerts) { + _BoundingBox.computeMinMax(vertices, tmpVecA, tmpVecB, numVerts); + this.setMinMax(tmpVecA, tmpVecB); + } + intersectsBoundingSphere(sphere) { + const sq = this._distanceToBoundingSphereSq(sphere); + if (sq <= sphere.radius * sphere.radius) { + return true; + } + return false; + } + _distanceToBoundingSphereSq(sphere) { + const boxMin = this.getMin(); + const boxMax = this.getMax(); + let sq = 0; + const axis = ["x", "y", "z"]; + for (let i = 0; i < 3; ++i) { + let out = 0; + const pn = sphere.center[axis[i]]; + const bMin = boxMin[axis[i]]; + const bMax = boxMax[axis[i]]; + let val = 0; + if (pn < bMin) { + val = bMin - pn; + out += val * val; + } + if (pn > bMax) { + val = pn - bMax; + out += val * val; + } + sq += out; + } + return sq; + } + _expand(expandMin, expandMax) { + tmpVecA.add2(this.getMin(), expandMin); + tmpVecB.add2(this.getMax(), expandMax); + this.setMinMax(tmpVecA, tmpVecB); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/core/shape/bounding-sphere.js +var tmpVecA2 = new Vec3(); +var tmpVecB2 = new Vec3(); +var BoundingSphere = class { + constructor(center2 = new Vec3(), radius = 0.5) { + this.center = void 0; + this.radius = void 0; + this.center = center2; + this.radius = radius; + } + containsPoint(point) { + const lenSq = tmpVecA2.sub2(point, this.center).lengthSq(); + const r = this.radius; + return lenSq < r * r; + } + intersectsRay(ray, point) { + const m = tmpVecA2.copy(ray.origin).sub(this.center); + const b = m.dot(tmpVecB2.copy(ray.direction).normalize()); + const c2 = m.dot(m) - this.radius * this.radius; + if (c2 > 0 && b > 0) return false; + const discr = b * b - c2; + if (discr < 0) return false; + const t = Math.abs(-b - Math.sqrt(discr)); + if (point) point.copy(ray.direction).mulScalar(t).add(ray.origin); + return true; + } + intersectsBoundingSphere(sphere) { + tmpVecA2.sub2(sphere.center, this.center); + const totalRadius = sphere.radius + this.radius; + if (tmpVecA2.lengthSq() <= totalRadius * totalRadius) { + return true; + } + return false; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/core/shape/frustum.js +var Frustum = class { + constructor() { + this.planes = []; + for (let i = 0; i < 6; i++) this.planes[i] = []; + } + setFromMat4(matrix2) { + const vpm = matrix2.data; + let plane; + const planes = this.planes; + plane = planes[0]; + plane[0] = vpm[3] - vpm[0]; + plane[1] = vpm[7] - vpm[4]; + plane[2] = vpm[11] - vpm[8]; + plane[3] = vpm[15] - vpm[12]; + let t = Math.sqrt(plane[0] * plane[0] + plane[1] * plane[1] + plane[2] * plane[2]); + plane[0] /= t; + plane[1] /= t; + plane[2] /= t; + plane[3] /= t; + plane = planes[1]; + plane[0] = vpm[3] + vpm[0]; + plane[1] = vpm[7] + vpm[4]; + plane[2] = vpm[11] + vpm[8]; + plane[3] = vpm[15] + vpm[12]; + t = Math.sqrt(plane[0] * plane[0] + plane[1] * plane[1] + plane[2] * plane[2]); + plane[0] /= t; + plane[1] /= t; + plane[2] /= t; + plane[3] /= t; + plane = planes[2]; + plane[0] = vpm[3] + vpm[1]; + plane[1] = vpm[7] + vpm[5]; + plane[2] = vpm[11] + vpm[9]; + plane[3] = vpm[15] + vpm[13]; + t = Math.sqrt(plane[0] * plane[0] + plane[1] * plane[1] + plane[2] * plane[2]); + plane[0] /= t; + plane[1] /= t; + plane[2] /= t; + plane[3] /= t; + plane = planes[3]; + plane[0] = vpm[3] - vpm[1]; + plane[1] = vpm[7] - vpm[5]; + plane[2] = vpm[11] - vpm[9]; + plane[3] = vpm[15] - vpm[13]; + t = Math.sqrt(plane[0] * plane[0] + plane[1] * plane[1] + plane[2] * plane[2]); + plane[0] /= t; + plane[1] /= t; + plane[2] /= t; + plane[3] /= t; + plane = planes[4]; + plane[0] = vpm[3] - vpm[2]; + plane[1] = vpm[7] - vpm[6]; + plane[2] = vpm[11] - vpm[10]; + plane[3] = vpm[15] - vpm[14]; + t = Math.sqrt(plane[0] * plane[0] + plane[1] * plane[1] + plane[2] * plane[2]); + plane[0] /= t; + plane[1] /= t; + plane[2] /= t; + plane[3] /= t; + plane = planes[5]; + plane[0] = vpm[3] + vpm[2]; + plane[1] = vpm[7] + vpm[6]; + plane[2] = vpm[11] + vpm[10]; + plane[3] = vpm[15] + vpm[14]; + t = Math.sqrt(plane[0] * plane[0] + plane[1] * plane[1] + plane[2] * plane[2]); + plane[0] /= t; + plane[1] /= t; + plane[2] /= t; + plane[3] /= t; + } + containsPoint(point) { + let p, plane; + for (p = 0; p < 6; p++) { + plane = this.planes[p]; + if (plane[0] * point.x + plane[1] * point.y + plane[2] * point.z + plane[3] <= 0) { + return false; + } + } + return true; + } + containsSphere(sphere) { + let c2 = 0; + let d; + let p; + const sr = sphere.radius; + const sc = sphere.center; + const scx = sc.x; + const scy = sc.y; + const scz = sc.z; + const planes = this.planes; + let plane; + for (p = 0; p < 6; p++) { + plane = planes[p]; + d = plane[0] * scx + plane[1] * scy + plane[2] * scz + plane[3]; + if (d <= -sr) return 0; + if (d > sr) c2++; + } + return c2 === 6 ? 2 : 1; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/core/shape/ray.js +var Ray = class { + constructor(origin, direction) { + this.origin = new Vec3(); + this.direction = Vec3.FORWARD.clone(); + if (origin) { + this.origin.copy(origin); + } + if (direction) { + this.direction.copy(direction); + } + } + set(origin, direction) { + this.origin.copy(origin); + this.direction.copy(direction); + return this; + } + copy(src) { + return this.set(src.origin, src.direction); + } + clone() { + return new this.constructor(this.origin, this.direction); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/audio/constants.js +var DISTANCE_LINEAR = "linear"; +var DISTANCE_INVERSE = "inverse"; +var DISTANCE_EXPONENTIAL = "exponential"; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/constants.js +var ADDRESS_REPEAT = 0; +var ADDRESS_CLAMP_TO_EDGE = 1; +var ADDRESS_MIRRORED_REPEAT = 2; +var BLENDMODE_ZERO = 0; +var BLENDMODE_ONE = 1; +var BLENDMODE_SRC_COLOR = 2; +var BLENDMODE_DST_COLOR = 4; +var BLENDMODE_ONE_MINUS_DST_COLOR = 5; +var BLENDMODE_SRC_ALPHA = 6; +var BLENDMODE_ONE_MINUS_SRC_ALPHA = 8; +var BLENDEQUATION_ADD = 0; +var BLENDEQUATION_REVERSE_SUBTRACT = 2; +var BLENDEQUATION_MIN = 3; +var BLENDEQUATION_MAX = 4; +var BUFFERUSAGE_READ = 1; +var BUFFERUSAGE_COPY_DST = 8; +var BUFFERUSAGE_INDEX = 16; +var BUFFERUSAGE_VERTEX = 32; +var BUFFERUSAGE_UNIFORM = 64; +var BUFFERUSAGE_STORAGE = 128; +var BUFFER_STATIC = 0; +var BUFFER_DYNAMIC = 1; +var BUFFER_STREAM = 2; +var BUFFER_GPUDYNAMIC = 3; +var CLEARFLAG_COLOR = 1; +var CLEARFLAG_DEPTH = 2; +var CLEARFLAG_STENCIL = 4; +var CULLFACE_NONE = 0; +var CULLFACE_BACK = 1; +var CULLFACE_FRONT = 2; +var FILTER_NEAREST = 0; +var FILTER_LINEAR = 1; +var FILTER_NEAREST_MIPMAP_NEAREST = 2; +var FILTER_NEAREST_MIPMAP_LINEAR = 3; +var FILTER_LINEAR_MIPMAP_NEAREST = 4; +var FILTER_LINEAR_MIPMAP_LINEAR = 5; +var FUNC_LESS = 1; +var FUNC_LESSEQUAL = 3; +var FUNC_ALWAYS = 7; +var INDEXFORMAT_UINT8 = 0; +var INDEXFORMAT_UINT16 = 1; +var INDEXFORMAT_UINT32 = 2; +var PIXELFORMAT_A8 = 0; +var PIXELFORMAT_L8 = 1; +var PIXELFORMAT_LA8 = 2; +var PIXELFORMAT_RGB565 = 3; +var PIXELFORMAT_RGBA5551 = 4; +var PIXELFORMAT_RGBA4 = 5; +var PIXELFORMAT_RGB8 = 6; +var PIXELFORMAT_RGBA8 = 7; +var PIXELFORMAT_DXT1 = 8; +var PIXELFORMAT_DXT3 = 9; +var PIXELFORMAT_DXT5 = 10; +var PIXELFORMAT_RGB16F = 11; +var PIXELFORMAT_RGBA16F = 12; +var PIXELFORMAT_RGB32F = 13; +var PIXELFORMAT_RGBA32F = 14; +var PIXELFORMAT_R32F = 15; +var PIXELFORMAT_DEPTH = 16; +var PIXELFORMAT_DEPTHSTENCIL = 17; +var PIXELFORMAT_111110F = 18; +var PIXELFORMAT_SRGB = 19; +var PIXELFORMAT_SRGBA = 20; +var PIXELFORMAT_ETC1 = 21; +var PIXELFORMAT_ETC2_RGB = 22; +var PIXELFORMAT_ETC2_RGBA = 23; +var PIXELFORMAT_PVRTC_2BPP_RGB_1 = 24; +var PIXELFORMAT_PVRTC_2BPP_RGBA_1 = 25; +var PIXELFORMAT_PVRTC_4BPP_RGB_1 = 26; +var PIXELFORMAT_PVRTC_4BPP_RGBA_1 = 27; +var PIXELFORMAT_ASTC_4x4 = 28; +var PIXELFORMAT_ATC_RGB = 29; +var PIXELFORMAT_ATC_RGBA = 30; +var PIXELFORMAT_BGRA8 = 31; +var PIXELFORMAT_R8I = 32; +var PIXELFORMAT_R8U = 33; +var PIXELFORMAT_R16I = 34; +var PIXELFORMAT_R16U = 35; +var PIXELFORMAT_R32I = 36; +var PIXELFORMAT_R32U = 37; +var PIXELFORMAT_RG8I = 38; +var PIXELFORMAT_RG8U = 39; +var PIXELFORMAT_RG16I = 40; +var PIXELFORMAT_RG16U = 41; +var PIXELFORMAT_RG32I = 42; +var PIXELFORMAT_RG32U = 43; +var PIXELFORMAT_RGBA8I = 44; +var PIXELFORMAT_RGBA8U = 45; +var PIXELFORMAT_RGBA16I = 46; +var PIXELFORMAT_RGBA16U = 47; +var PIXELFORMAT_RGBA32I = 48; +var PIXELFORMAT_RGBA32U = 49; +var PIXELFORMAT_R16F = 50; +var PIXELFORMAT_RG16F = 51; +var pixelFormatInfo = /* @__PURE__ */ new Map([[PIXELFORMAT_A8, { + name: "A8", + size: 1 +}], [PIXELFORMAT_L8, { + name: "L8", + size: 1 +}], [PIXELFORMAT_LA8, { + name: "LA8", + size: 2 +}], [PIXELFORMAT_RGB565, { + name: "RGB565", + size: 2 +}], [PIXELFORMAT_RGBA5551, { + name: "RGBA5551", + size: 2 +}], [PIXELFORMAT_RGBA4, { + name: "RGBA4", + size: 2 +}], [PIXELFORMAT_RGB8, { + name: "RGB8", + size: 4 +}], [PIXELFORMAT_RGBA8, { + name: "RGBA8", + size: 4 +}], [PIXELFORMAT_R16F, { + name: "R16F", + size: 2 +}], [PIXELFORMAT_RG16F, { + name: "RG16F", + size: 4 +}], [PIXELFORMAT_RGB16F, { + name: "RGB16F", + size: 8 +}], [PIXELFORMAT_RGBA16F, { + name: "RGBA16F", + size: 8 +}], [PIXELFORMAT_RGB32F, { + name: "RGB32F", + size: 16 +}], [PIXELFORMAT_RGBA32F, { + name: "RGBA32F", + size: 16 +}], [PIXELFORMAT_R32F, { + name: "R32F", + size: 4 +}], [PIXELFORMAT_DEPTH, { + name: "DEPTH", + size: 4 +}], [PIXELFORMAT_DEPTHSTENCIL, { + name: "DEPTHSTENCIL", + size: 4 +}], [PIXELFORMAT_111110F, { + name: "111110F", + size: 4 +}], [PIXELFORMAT_SRGB, { + name: "SRGB", + size: 4 +}], [PIXELFORMAT_SRGBA, { + name: "SRGBA", + size: 4 +}], [PIXELFORMAT_BGRA8, { + name: "BGRA8", + size: 4 +}], [PIXELFORMAT_DXT1, { + name: "DXT1", + blockSize: 8 +}], [PIXELFORMAT_DXT3, { + name: "DXT3", + blockSize: 16 +}], [PIXELFORMAT_DXT5, { + name: "DXT5", + blockSize: 16 +}], [PIXELFORMAT_ETC1, { + name: "ETC1", + blockSize: 8 +}], [PIXELFORMAT_ETC2_RGB, { + name: "ETC2_RGB", + blockSize: 8 +}], [PIXELFORMAT_ETC2_RGBA, { + name: "ETC2_RGBA", + blockSize: 16 +}], [PIXELFORMAT_PVRTC_2BPP_RGB_1, { + name: "PVRTC_2BPP_RGB_1", + blockSize: 8 +}], [PIXELFORMAT_PVRTC_2BPP_RGBA_1, { + name: "PVRTC_2BPP_RGBA_1", + blockSize: 8 +}], [PIXELFORMAT_PVRTC_4BPP_RGB_1, { + name: "PVRTC_4BPP_RGB_1", + blockSize: 8 +}], [PIXELFORMAT_PVRTC_4BPP_RGBA_1, { + name: "PVRTC_4BPP_RGBA_1", + blockSize: 8 +}], [PIXELFORMAT_ASTC_4x4, { + name: "ASTC_4x4", + blockSize: 16 +}], [PIXELFORMAT_ATC_RGB, { + name: "ATC_RGB", + blockSize: 8 +}], [PIXELFORMAT_ATC_RGBA, { + name: "ATC_RGBA", + blockSize: 16 +}], [PIXELFORMAT_R8I, { + name: "R8I", + size: 1, + isInt: true +}], [PIXELFORMAT_R8U, { + name: "R8U", + size: 1, + isInt: true +}], [PIXELFORMAT_R16I, { + name: "R16I", + size: 2, + isInt: true +}], [PIXELFORMAT_R16U, { + name: "R16U", + size: 2, + isInt: true +}], [PIXELFORMAT_R32I, { + name: "R32I", + size: 4, + isInt: true +}], [PIXELFORMAT_R32U, { + name: "R32U", + size: 4, + isInt: true +}], [PIXELFORMAT_RG8I, { + name: "RG8I", + size: 2, + isInt: true +}], [PIXELFORMAT_RG8U, { + name: "RG8U", + size: 2, + isInt: true +}], [PIXELFORMAT_RG16I, { + name: "RG16I", + size: 4, + isInt: true +}], [PIXELFORMAT_RG16U, { + name: "RG16U", + size: 4, + isInt: true +}], [PIXELFORMAT_RG32I, { + name: "RG32I", + size: 8, + isInt: true +}], [PIXELFORMAT_RG32U, { + name: "RG32U", + size: 8, + isInt: true +}], [PIXELFORMAT_RGBA8I, { + name: "RGBA8I", + size: 4, + isInt: true +}], [PIXELFORMAT_RGBA8U, { + name: "RGBA8U", + size: 4, + isInt: true +}], [PIXELFORMAT_RGBA16I, { + name: "RGBA16I", + size: 8, + isInt: true +}], [PIXELFORMAT_RGBA16U, { + name: "RGBA16U", + size: 8, + isInt: true +}], [PIXELFORMAT_RGBA32I, { + name: "RGBA32I", + size: 16, + isInt: true +}], [PIXELFORMAT_RGBA32U, { + name: "RGBA32U", + size: 16, + isInt: true +}]]); +var isCompressedPixelFormat = (format) => { + var _pixelFormatInfo$get; + return ((_pixelFormatInfo$get = pixelFormatInfo.get(format)) == null ? void 0 : _pixelFormatInfo$get.blockSize) !== void 0; +}; +var isIntegerPixelFormat = (format) => { + var _pixelFormatInfo$get2; + return ((_pixelFormatInfo$get2 = pixelFormatInfo.get(format)) == null ? void 0 : _pixelFormatInfo$get2.isInt) === true; +}; +var getPixelFormatArrayType = (format) => { + switch (format) { + case PIXELFORMAT_R32F: + case PIXELFORMAT_RGB32F: + case PIXELFORMAT_RGBA32F: + return Float32Array; + case PIXELFORMAT_R32I: + case PIXELFORMAT_RG32I: + case PIXELFORMAT_RGBA32I: + return Int32Array; + case PIXELFORMAT_R32U: + case PIXELFORMAT_RG32U: + case PIXELFORMAT_RGBA32U: + return Uint32Array; + case PIXELFORMAT_R16I: + case PIXELFORMAT_RG16I: + case PIXELFORMAT_RGBA16I: + return Int16Array; + case PIXELFORMAT_R16U: + case PIXELFORMAT_RG16U: + case PIXELFORMAT_RGBA16U: + case PIXELFORMAT_RGB565: + case PIXELFORMAT_RGBA5551: + case PIXELFORMAT_RGBA4: + case PIXELFORMAT_R16F: + case PIXELFORMAT_RG16F: + case PIXELFORMAT_RGB16F: + case PIXELFORMAT_RGBA16F: + return Uint16Array; + case PIXELFORMAT_R8I: + case PIXELFORMAT_RG8I: + case PIXELFORMAT_RGBA8I: + return Int8Array; + default: + return Uint8Array; + } +}; +var PRIMITIVE_POINTS = 0; +var PRIMITIVE_LINES = 1; +var PRIMITIVE_LINELOOP = 2; +var PRIMITIVE_LINESTRIP = 3; +var PRIMITIVE_TRIANGLES = 4; +var PRIMITIVE_TRISTRIP = 5; +var PRIMITIVE_TRIFAN = 6; +var SEMANTIC_POSITION = "POSITION"; +var SEMANTIC_NORMAL = "NORMAL"; +var SEMANTIC_TANGENT = "TANGENT"; +var SEMANTIC_BLENDWEIGHT = "BLENDWEIGHT"; +var SEMANTIC_BLENDINDICES = "BLENDINDICES"; +var SEMANTIC_COLOR = "COLOR"; +var SEMANTIC_TEXCOORD = "TEXCOORD"; +var SEMANTIC_TEXCOORD0 = "TEXCOORD0"; +var SEMANTIC_TEXCOORD1 = "TEXCOORD1"; +var SEMANTIC_TEXCOORD2 = "TEXCOORD2"; +var SEMANTIC_TEXCOORD3 = "TEXCOORD3"; +var SEMANTIC_TEXCOORD4 = "TEXCOORD4"; +var SEMANTIC_TEXCOORD5 = "TEXCOORD5"; +var SEMANTIC_TEXCOORD6 = "TEXCOORD6"; +var SEMANTIC_TEXCOORD7 = "TEXCOORD7"; +var SEMANTIC_ATTR = "ATTR"; +var SEMANTIC_ATTR0 = "ATTR0"; +var SEMANTIC_ATTR1 = "ATTR1"; +var SEMANTIC_ATTR2 = "ATTR2"; +var SEMANTIC_ATTR3 = "ATTR3"; +var SEMANTIC_ATTR4 = "ATTR4"; +var SEMANTIC_ATTR5 = "ATTR5"; +var SEMANTIC_ATTR6 = "ATTR6"; +var SEMANTIC_ATTR7 = "ATTR7"; +var SEMANTIC_ATTR8 = "ATTR8"; +var SEMANTIC_ATTR9 = "ATTR9"; +var SEMANTIC_ATTR10 = "ATTR10"; +var SEMANTIC_ATTR11 = "ATTR11"; +var SEMANTIC_ATTR12 = "ATTR12"; +var SEMANTIC_ATTR13 = "ATTR13"; +var SEMANTIC_ATTR14 = "ATTR14"; +var SEMANTIC_ATTR15 = "ATTR15"; +var SHADERTAG_MATERIAL = 1; +var STENCILOP_KEEP = 0; +var TEXTURELOCK_NONE = 0; +var TEXTURELOCK_READ = 1; +var TEXTURELOCK_WRITE = 2; +var TEXTURETYPE_DEFAULT = "default"; +var TEXTURETYPE_RGBM = "rgbm"; +var TEXTURETYPE_RGBE = "rgbe"; +var TEXTURETYPE_RGBP = "rgbp"; +var TEXTURETYPE_SWIZZLEGGGR = "swizzleGGGR"; +var TEXTUREDIMENSION_2D = "2d"; +var TEXTUREDIMENSION_2D_ARRAY = "2d-array"; +var TEXTUREDIMENSION_CUBE = "cube"; +var TEXTUREDIMENSION_3D = "3d"; +var SAMPLETYPE_FLOAT = 0; +var SAMPLETYPE_UNFILTERABLE_FLOAT = 1; +var SAMPLETYPE_DEPTH = 2; +var SAMPLETYPE_INT = 3; +var SAMPLETYPE_UINT = 4; +var TEXTUREPROJECTION_NONE = "none"; +var TEXTUREPROJECTION_CUBE = "cube"; +var TEXTUREPROJECTION_EQUIRECT = "equirect"; +var TEXTUREPROJECTION_OCTAHEDRAL = "octahedral"; +var SHADERLANGUAGE_WGSL = "wgsl"; +var TYPE_INT8 = 0; +var TYPE_UINT8 = 1; +var TYPE_INT16 = 2; +var TYPE_UINT16 = 3; +var TYPE_INT32 = 4; +var TYPE_UINT32 = 5; +var TYPE_FLOAT32 = 6; +var TYPE_FLOAT16 = 7; +var UNIFORMTYPE_BOOL = 0; +var UNIFORMTYPE_INT = 1; +var UNIFORMTYPE_FLOAT = 2; +var UNIFORMTYPE_VEC2 = 3; +var UNIFORMTYPE_VEC3 = 4; +var UNIFORMTYPE_VEC4 = 5; +var UNIFORMTYPE_IVEC2 = 6; +var UNIFORMTYPE_IVEC3 = 7; +var UNIFORMTYPE_IVEC4 = 8; +var UNIFORMTYPE_BVEC2 = 9; +var UNIFORMTYPE_BVEC3 = 10; +var UNIFORMTYPE_BVEC4 = 11; +var UNIFORMTYPE_MAT2 = 12; +var UNIFORMTYPE_MAT3 = 13; +var UNIFORMTYPE_MAT4 = 14; +var UNIFORMTYPE_TEXTURE2D = 15; +var UNIFORMTYPE_TEXTURECUBE = 16; +var UNIFORMTYPE_FLOATARRAY = 17; +var UNIFORMTYPE_TEXTURE2D_SHADOW = 18; +var UNIFORMTYPE_TEXTURECUBE_SHADOW = 19; +var UNIFORMTYPE_TEXTURE3D = 20; +var UNIFORMTYPE_VEC2ARRAY = 21; +var UNIFORMTYPE_VEC3ARRAY = 22; +var UNIFORMTYPE_VEC4ARRAY = 23; +var UNIFORMTYPE_MAT4ARRAY = 24; +var UNIFORMTYPE_TEXTURE2D_ARRAY = 25; +var UNIFORMTYPE_UINT = 26; +var UNIFORMTYPE_UVEC2 = 27; +var UNIFORMTYPE_UVEC3 = 28; +var UNIFORMTYPE_UVEC4 = 29; +var UNIFORMTYPE_INTARRAY = 30; +var UNIFORMTYPE_UINTARRAY = 31; +var UNIFORMTYPE_BOOLARRAY = 32; +var UNIFORMTYPE_IVEC2ARRAY = 33; +var UNIFORMTYPE_UVEC2ARRAY = 34; +var UNIFORMTYPE_BVEC2ARRAY = 35; +var UNIFORMTYPE_IVEC3ARRAY = 36; +var UNIFORMTYPE_UVEC3ARRAY = 37; +var UNIFORMTYPE_BVEC3ARRAY = 38; +var UNIFORMTYPE_IVEC4ARRAY = 39; +var UNIFORMTYPE_UVEC4ARRAY = 40; +var UNIFORMTYPE_BVEC4ARRAY = 41; +var UNIFORMTYPE_ITEXTURE2D = 42; +var UNIFORMTYPE_UTEXTURE2D = 43; +var UNIFORMTYPE_ITEXTURECUBE = 44; +var UNIFORMTYPE_UTEXTURECUBE = 45; +var UNIFORMTYPE_ITEXTURE3D = 46; +var UNIFORMTYPE_UTEXTURE3D = 47; +var UNIFORMTYPE_ITEXTURE2D_ARRAY = 48; +var UNIFORMTYPE_UTEXTURE2D_ARRAY = 49; +var uniformTypeToName = ["bool", "int", "float", "vec2", "vec3", "vec4", "ivec2", "ivec3", "ivec4", "bvec2", "bvec3", "bvec4", "mat2", "mat3", "mat4", "sampler2D", "samplerCube", "", "sampler2DShadow", "samplerCubeShadow", "sampler3D", "", "", "", "", "sampler2DArray", "uint", "uvec2", "uvec3", "uvec4", "", "", "", "", "", "", "", "", "", "", "", "", "isampler2D", "usampler2D", "isamplerCube", "usamplerCube", "isampler3D", "usampler3D", "isampler2DArray", "usampler2DArray"]; +var uniformTypeToStorage = new Uint8Array([TYPE_INT32, TYPE_INT32, TYPE_FLOAT32, TYPE_FLOAT32, TYPE_FLOAT32, TYPE_FLOAT32, TYPE_INT32, TYPE_INT32, TYPE_INT32, TYPE_INT32, TYPE_INT32, TYPE_INT32, TYPE_FLOAT32, TYPE_FLOAT32, TYPE_FLOAT32, TYPE_INT32, TYPE_INT32, TYPE_FLOAT32, TYPE_INT32, TYPE_INT32, TYPE_INT32, TYPE_FLOAT32, TYPE_FLOAT32, TYPE_FLOAT32, TYPE_FLOAT32, TYPE_INT32, TYPE_UINT32, TYPE_UINT32, TYPE_UINT32, TYPE_UINT32, TYPE_INT32, TYPE_UINT32, TYPE_INT32, TYPE_INT32, TYPE_UINT32, TYPE_INT32, TYPE_INT32, TYPE_UINT32, TYPE_INT32, TYPE_INT32, TYPE_UINT32, TYPE_INT32, TYPE_INT32, TYPE_UINT32, TYPE_INT32, TYPE_UINT32, TYPE_INT32, TYPE_UINT32, TYPE_INT32, TYPE_UINT32]); +var DEVICETYPE_WEBGL1 = "webgl1"; +var DEVICETYPE_WEBGL2 = "webgl2"; +var DEVICETYPE_WEBGPU = "webgpu"; +var DEVICETYPE_NULL = "null"; +var SHADERSTAGE_VERTEX = 1; +var SHADERSTAGE_FRAGMENT = 2; +var SHADERSTAGE_COMPUTE = 4; +var BINDGROUP_MESH = 0; +var BINDGROUP_VIEW = 1; +var bindGroupNames = ["mesh", "view"]; +var UNIFORM_BUFFER_DEFAULT_SLOT_NAME = "default"; +var typedArrayTypes = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Uint16Array]; +var typedArrayTypesByteSize = [1, 1, 2, 2, 4, 4, 4, 2]; +var typedArrayIndexFormats = [Uint8Array, Uint16Array, Uint32Array]; +var typedArrayIndexFormatsByteSize = [1, 2, 4]; +var semanticToLocation = {}; +semanticToLocation[SEMANTIC_POSITION] = 0; +semanticToLocation[SEMANTIC_NORMAL] = 1; +semanticToLocation[SEMANTIC_BLENDWEIGHT] = 2; +semanticToLocation[SEMANTIC_BLENDINDICES] = 3; +semanticToLocation[SEMANTIC_COLOR] = 4; +semanticToLocation[SEMANTIC_TEXCOORD0] = 5; +semanticToLocation[SEMANTIC_TEXCOORD1] = 6; +semanticToLocation[SEMANTIC_TEXCOORD2] = 7; +semanticToLocation[SEMANTIC_TEXCOORD3] = 8; +semanticToLocation[SEMANTIC_TEXCOORD4] = 9; +semanticToLocation[SEMANTIC_TEXCOORD5] = 10; +semanticToLocation[SEMANTIC_TEXCOORD6] = 11; +semanticToLocation[SEMANTIC_TEXCOORD7] = 12; +semanticToLocation[SEMANTIC_TANGENT] = 13; +semanticToLocation[SEMANTIC_ATTR0] = 0; +semanticToLocation[SEMANTIC_ATTR1] = 1; +semanticToLocation[SEMANTIC_ATTR2] = 2; +semanticToLocation[SEMANTIC_ATTR3] = 3; +semanticToLocation[SEMANTIC_ATTR4] = 4; +semanticToLocation[SEMANTIC_ATTR5] = 5; +semanticToLocation[SEMANTIC_ATTR6] = 6; +semanticToLocation[SEMANTIC_ATTR7] = 7; +semanticToLocation[SEMANTIC_ATTR8] = 8; +semanticToLocation[SEMANTIC_ATTR9] = 9; +semanticToLocation[SEMANTIC_ATTR10] = 10; +semanticToLocation[SEMANTIC_ATTR11] = 11; +semanticToLocation[SEMANTIC_ATTR12] = 12; +semanticToLocation[SEMANTIC_ATTR13] = 13; +semanticToLocation[SEMANTIC_ATTR14] = 14; +semanticToLocation[SEMANTIC_ATTR15] = 15; + +// ../../node_modules/playcanvas/build/playcanvas/_virtual/_rollupPluginBabelHelpers.js +function _extends() { + _extends = Object.assign ? Object.assign.bind() : function(target2) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + for (var key in source) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + target2[key] = source[key]; + } + } + } + return target2; + }; + return _extends.apply(this, arguments); +} + +// ../../node_modules/playcanvas/build/playcanvas/src/core/math/bit-packing.js +var BitPacking = { + set(storage, value, shift, mask = 1) { + const data2 = storage & ~(mask << shift); + return data2 | value << shift; + }, + get(storage, shift, mask = 1) { + return storage >> shift & mask; + }, + all(storage, shift, mask = 1) { + const shifted = mask << shift; + return (storage & shifted) === shifted; + }, + any(storage, shift, mask = 1) { + return (storage & mask << shift) !== 0; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/blend-state.js +var _BlendState; +var opMask = 7; +var factorMask = 15; +var colorOpShift = 0; +var colorSrcFactorShift = 3; +var colorDstFactorShift = 7; +var alphaOpShift = 11; +var alphaSrcFactorShift = 14; +var alphaDstFactorShift = 18; +var redWriteShift = 22; +var greenWriteShift = 23; +var blueWriteShift = 24; +var alphaWriteShift = 25; +var blendShift = 26; +var allWriteMasks = 15; +var allWriteShift = redWriteShift; +var BlendState = class { + constructor(blend = false, colorOp = BLENDEQUATION_ADD, colorSrcFactor = BLENDMODE_ONE, colorDstFactor = BLENDMODE_ZERO, alphaOp, alphaSrcFactor, alphaDstFactor, redWrite = true, greenWrite = true, blueWrite = true, alphaWrite = true) { + this.target0 = 0; + this.setColorBlend(colorOp, colorSrcFactor, colorDstFactor); + this.setAlphaBlend(alphaOp != null ? alphaOp : colorOp, alphaSrcFactor != null ? alphaSrcFactor : colorSrcFactor, alphaDstFactor != null ? alphaDstFactor : colorDstFactor); + this.setColorWrite(redWrite, greenWrite, blueWrite, alphaWrite); + this.blend = blend; + } + set blend(value) { + this.target0 = BitPacking.set(this.target0, value ? 1 : 0, blendShift); + } + get blend() { + return BitPacking.all(this.target0, blendShift); + } + setColorBlend(op, srcFactor, dstFactor) { + this.target0 = BitPacking.set(this.target0, op, colorOpShift, opMask); + this.target0 = BitPacking.set(this.target0, srcFactor, colorSrcFactorShift, factorMask); + this.target0 = BitPacking.set(this.target0, dstFactor, colorDstFactorShift, factorMask); + } + setAlphaBlend(op, srcFactor, dstFactor) { + this.target0 = BitPacking.set(this.target0, op, alphaOpShift, opMask); + this.target0 = BitPacking.set(this.target0, srcFactor, alphaSrcFactorShift, factorMask); + this.target0 = BitPacking.set(this.target0, dstFactor, alphaDstFactorShift, factorMask); + } + setColorWrite(redWrite, greenWrite, blueWrite, alphaWrite) { + this.redWrite = redWrite; + this.greenWrite = greenWrite; + this.blueWrite = blueWrite; + this.alphaWrite = alphaWrite; + } + get colorOp() { + return BitPacking.get(this.target0, colorOpShift, opMask); + } + get colorSrcFactor() { + return BitPacking.get(this.target0, colorSrcFactorShift, factorMask); + } + get colorDstFactor() { + return BitPacking.get(this.target0, colorDstFactorShift, factorMask); + } + get alphaOp() { + return BitPacking.get(this.target0, alphaOpShift, opMask); + } + get alphaSrcFactor() { + return BitPacking.get(this.target0, alphaSrcFactorShift, factorMask); + } + get alphaDstFactor() { + return BitPacking.get(this.target0, alphaDstFactorShift, factorMask); + } + set redWrite(value) { + this.target0 = BitPacking.set(this.target0, value ? 1 : 0, redWriteShift); + } + get redWrite() { + return BitPacking.all(this.target0, redWriteShift); + } + set greenWrite(value) { + this.target0 = BitPacking.set(this.target0, value ? 1 : 0, greenWriteShift); + } + get greenWrite() { + return BitPacking.all(this.target0, greenWriteShift); + } + set blueWrite(value) { + this.target0 = BitPacking.set(this.target0, value ? 1 : 0, blueWriteShift); + } + get blueWrite() { + return BitPacking.all(this.target0, blueWriteShift); + } + set alphaWrite(value) { + this.target0 = BitPacking.set(this.target0, value ? 1 : 0, alphaWriteShift); + } + get alphaWrite() { + return BitPacking.all(this.target0, alphaWriteShift); + } + get allWrite() { + return BitPacking.get(this.target0, allWriteShift, allWriteMasks); + } + copy(rhs) { + this.target0 = rhs.target0; + return this; + } + clone() { + const clone = new this.constructor(); + return clone.copy(this); + } + get key() { + return this.target0; + } + equals(rhs) { + return this.target0 === rhs.target0; + } +}; +_BlendState = BlendState; +BlendState.NOBLEND = Object.freeze(new _BlendState()); +BlendState.NOWRITE = Object.freeze(new _BlendState(void 0, void 0, void 0, void 0, void 0, void 0, void 0, false, false, false, false)); +BlendState.ALPHABLEND = Object.freeze(new _BlendState(true, BLENDEQUATION_ADD, BLENDMODE_SRC_ALPHA, BLENDMODE_ONE_MINUS_SRC_ALPHA)); +BlendState.ADDBLEND = Object.freeze(new _BlendState(true, BLENDEQUATION_ADD, BLENDMODE_ONE, BLENDMODE_ONE)); + +// ../../node_modules/playcanvas/build/playcanvas/src/core/string-ids.js +var StringIds = class { + constructor() { + this.map = /* @__PURE__ */ new Map(); + this.id = 0; + } + get(name) { + let value = this.map.get(name); + if (value === void 0) { + value = this.id++; + this.map.set(name, value); + } + return value; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/depth-state.js +var _DepthState; +var stringIds = new StringIds(); +var funcMask = 7; +var funcShift = 0; +var writeShift = 3; +var DepthState = class { + constructor(func = FUNC_LESSEQUAL, write = true) { + this.data = 0; + this._depthBias = 0; + this._depthBiasSlope = 0; + this.key = 0; + this.func = func; + this.write = write; + } + set test(value) { + this.func = value ? FUNC_LESSEQUAL : FUNC_ALWAYS; + this.updateKey(); + } + get test() { + return this.func !== FUNC_ALWAYS; + } + set write(value) { + this.data = BitPacking.set(this.data, value ? 1 : 0, writeShift); + this.updateKey(); + } + get write() { + return BitPacking.all(this.data, writeShift); + } + set func(value) { + this.data = BitPacking.set(this.data, value, funcShift, funcMask); + this.updateKey(); + } + get func() { + return BitPacking.get(this.data, funcShift, funcMask); + } + set depthBias(value) { + this._depthBias = value; + this.updateKey(); + } + get depthBias() { + return this._depthBias; + } + set depthBiasSlope(value) { + this._depthBiasSlope = value; + this.updateKey(); + } + get depthBiasSlope() { + return this._depthBiasSlope; + } + copy(rhs) { + this.data = rhs.data; + this._depthBias = rhs._depthBias; + this._depthBiasSlope = rhs._depthBiasSlope; + this.key = rhs.key; + return this; + } + clone() { + const clone = new this.constructor(); + return clone.copy(this); + } + updateKey() { + const { + data: data2, + _depthBias, + _depthBiasSlope + } = this; + const key = `${data2}-${_depthBias}-${_depthBiasSlope}`; + this.key = stringIds.get(key); + } + equals(rhs) { + return this.key === rhs.key; + } +}; +_DepthState = DepthState; +DepthState.DEFAULT = Object.freeze(new _DepthState()); +DepthState.NODEPTH = Object.freeze(new _DepthState(FUNC_ALWAYS, false)); +DepthState.WRITEDEPTH = Object.freeze(new _DepthState(FUNC_ALWAYS, true)); + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/version.js +var Version = class { + constructor() { + this.globalId = 0; + this.revision = 0; + } + equals(other) { + return this.globalId === other.globalId && this.revision === other.revision; + } + copy(other) { + this.globalId = other.globalId; + this.revision = other.revision; + } + reset() { + this.globalId = 0; + this.revision = 0; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/versioned-object.js +var idCounter = 0; +var VersionedObject = class { + constructor() { + idCounter++; + this.version = new Version(); + this.version.globalId = idCounter; + } + increment() { + this.version.revision++; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/scope-id.js +var ScopeId = class { + constructor(name) { + this.name = name; + this.value = null; + this.versionObject = new VersionedObject(); + } + toJSON(key) { + return void 0; + } + setValue(value) { + this.value = value; + this.versionObject.increment(); + } + getValue() { + return this.value; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/scope-space.js +var ScopeSpace = class { + constructor(name) { + this.name = name; + this.variables = /* @__PURE__ */ new Map(); + } + resolve(name) { + if (!this.variables.has(name)) { + this.variables.set(name, new ScopeId(name)); + } + return this.variables.get(name); + } + removeValue(value) { + for (const uniformName in this.variables) { + const uniform = this.variables[uniformName]; + if (uniform.value === value) { + uniform.value = null; + } + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/vertex-buffer.js +var id = 0; +var VertexBuffer = class { + constructor(graphicsDevice, format, numVertices, options) { + this.usage = BUFFER_STATIC; + let initialData; + if (typeof options === "object") { + var _options$usage; + this.usage = (_options$usage = options.usage) != null ? _options$usage : BUFFER_STATIC; + initialData = options.data; + } else if (arguments.length > 3) { + var _arguments$; + this.usage = (_arguments$ = arguments[3]) != null ? _arguments$ : BUFFER_STATIC; + initialData = arguments[4]; + } + this.device = graphicsDevice; + this.format = format; + this.numVertices = numVertices; + this.id = id++; + this.impl = graphicsDevice.createVertexBufferImpl(this, format, options); + this.numBytes = format.verticesByteSize ? format.verticesByteSize : format.size * numVertices; + this.adjustVramSizeTracking(graphicsDevice._vram, this.numBytes); + if (initialData) { + this.setData(initialData); + } else { + this.storage = new ArrayBuffer(this.numBytes); + } + this.device.buffers.push(this); + } + destroy() { + const device = this.device; + const idx = device.buffers.indexOf(this); + if (idx !== -1) { + device.buffers.splice(idx, 1); + } + if (this.impl.initialized) { + this.impl.destroy(device); + this.adjustVramSizeTracking(device._vram, -this.storage.byteLength); + } + } + adjustVramSizeTracking(vram, size) { + vram.vb += size; + } + loseContext() { + this.impl.loseContext(); + } + getFormat() { + return this.format; + } + getUsage() { + return this.usage; + } + getNumVertices() { + return this.numVertices; + } + lock() { + return this.storage; + } + unlock() { + this.impl.unlock(this); + } + setData(data2) { + if (data2.byteLength !== this.numBytes) { + return false; + } + this.storage = data2; + this.unlock(); + return true; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/core/hash.js +function hashCode(str) { + let hash = 0; + for (let i = 0, len = str.length; i < len; i++) { + hash = (hash << 5) - hash + str.charCodeAt(i); + hash |= 0; + } + return hash; +} +function hash32Fnv1a(array2) { + const prime = 16777619; + let hash = 2166136261; + for (let i = 0; i < array2.length; i++) { + hash ^= array2[i]; + hash *= prime; + } + return hash >>> 0; +} + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/device-cache.js +var DeviceCache = class { + constructor() { + this._cache = /* @__PURE__ */ new Map(); + } + get(device, onCreate) { + if (!this._cache.has(device)) { + this._cache.set(device, onCreate()); + device.on("destroy", () => { + this.remove(device); + }); + device.on("devicelost", () => { + var _this$_cache$get; + (_this$_cache$get = this._cache.get(device)) == null || _this$_cache$get.loseContext == null || _this$_cache$get.loseContext(device); + }); + } + return this._cache.get(device); + } + remove(device) { + var _this$_cache$get2; + (_this$_cache$get2 = this._cache.get(device)) == null || _this$_cache$get2.destroy == null || _this$_cache$get2.destroy(device); + this._cache.delete(device); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/vertex-format.js +var stringIds2 = new StringIds(); +var webgpuValidElementSizes = [2, 4, 8, 12, 16]; +var deviceCache = new DeviceCache(); +var VertexFormat = class _VertexFormat { + constructor(graphicsDevice, description, vertexCount) { + this.device = graphicsDevice; + this._elements = []; + this.hasUv0 = false; + this.hasUv1 = false; + this.hasColor = false; + this.hasTangents = false; + this.verticesByteSize = 0; + this.vertexCount = vertexCount; + this.interleaved = vertexCount === void 0; + this.instancing = false; + this.size = description.reduce((total, desc) => { + return total + Math.ceil(desc.components * typedArrayTypesByteSize[desc.type] / 4) * 4; + }, 0); + let offset = 0, elementSize; + for (let i = 0, len = description.length; i < len; i++) { + var _elementDesc$asInt, _elementDesc$normaliz; + const elementDesc = description[i]; + elementSize = elementDesc.components * typedArrayTypesByteSize[elementDesc.type]; + if (vertexCount) { + offset = math.roundUp(offset, elementSize); + } + const asInt = (_elementDesc$asInt = elementDesc.asInt) != null ? _elementDesc$asInt : false; + const normalize = asInt ? false : (_elementDesc$normaliz = elementDesc.normalize) != null ? _elementDesc$normaliz : false; + const element = { + name: elementDesc.semantic, + offset: vertexCount ? offset : elementDesc.hasOwnProperty("offset") ? elementDesc.offset : offset, + stride: vertexCount ? elementSize : elementDesc.hasOwnProperty("stride") ? elementDesc.stride : this.size, + dataType: elementDesc.type, + numComponents: elementDesc.components, + normalize, + size: elementSize, + asInt + }; + this._elements.push(element); + if (vertexCount) { + offset += elementSize * vertexCount; + } else { + offset += Math.ceil(elementSize / 4) * 4; + } + if (elementDesc.semantic === SEMANTIC_TEXCOORD0) { + this.hasUv0 = true; + } else if (elementDesc.semantic === SEMANTIC_TEXCOORD1) { + this.hasUv1 = true; + } else if (elementDesc.semantic === SEMANTIC_COLOR) { + this.hasColor = true; + } else if (elementDesc.semantic === SEMANTIC_TANGENT) { + this.hasTangents = true; + } + } + if (vertexCount) { + this.verticesByteSize = offset; + } + this._evaluateHash(); + } + get elements() { + return this._elements; + } + static getDefaultInstancingFormat(graphicsDevice) { + return deviceCache.get(graphicsDevice, () => { + return new _VertexFormat(graphicsDevice, [{ + semantic: SEMANTIC_ATTR12, + components: 4, + type: TYPE_FLOAT32 + }, { + semantic: SEMANTIC_ATTR13, + components: 4, + type: TYPE_FLOAT32 + }, { + semantic: SEMANTIC_ATTR14, + components: 4, + type: TYPE_FLOAT32 + }, { + semantic: SEMANTIC_ATTR15, + components: 4, + type: TYPE_FLOAT32 + }]); + }); + } + static isElementValid(graphicsDevice, elementDesc) { + const elementSize = elementDesc.components * typedArrayTypesByteSize[elementDesc.type]; + if (graphicsDevice.isWebGPU && !webgpuValidElementSizes.includes(elementSize)) return false; + return true; + } + update() { + this._evaluateHash(); + } + _evaluateHash() { + const stringElementsBatch = []; + const stringElementsRender = []; + const len = this._elements.length; + for (let i = 0; i < len; i++) { + const { + name, + dataType, + numComponents, + normalize, + offset, + stride, + size, + asInt + } = this._elements[i]; + const stringElementBatch = name + dataType + numComponents + normalize + asInt; + stringElementsBatch.push(stringElementBatch); + const stringElementRender = stringElementBatch + offset + stride + size; + stringElementsRender.push(stringElementRender); + } + stringElementsBatch.sort(); + const batchingString = stringElementsBatch.join(); + this.batchingHash = hashCode(batchingString); + this.shaderProcessingHashString = batchingString; + this.renderingHashString = stringElementsRender.join("_"); + this.renderingHash = stringIds2.get(this.renderingHashString); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/stencil-parameters.js +var _StencilParameters; +var stringIds3 = new StringIds(); +var StencilParameters = class { + set func(value) { + this._func = value; + this._dirty = true; + } + get func() { + return this._func; + } + set ref(value) { + this._ref = value; + this._dirty = true; + } + get ref() { + return this._ref; + } + set fail(value) { + this._fail = value; + this._dirty = true; + } + get fail() { + return this._fail; + } + set zfail(value) { + this._zfail = value; + this._dirty = true; + } + get zfail() { + return this._zfail; + } + set zpass(value) { + this._zpass = value; + this._dirty = true; + } + get zpass() { + return this._zpass; + } + set readMask(value) { + this._readMask = value; + this._dirty = true; + } + get readMask() { + return this._readMask; + } + set writeMask(value) { + this._writeMask = value; + this._dirty = true; + } + get writeMask() { + return this._writeMask; + } + constructor(options = {}) { + var _options$func, _options$ref, _options$readMask, _options$writeMask, _options$fail, _options$zfail, _options$zpass; + this._func = void 0; + this._ref = void 0; + this._fail = void 0; + this._zfail = void 0; + this._zpass = void 0; + this._readMask = void 0; + this._writeMask = void 0; + this._dirty = true; + this._key = void 0; + this._func = (_options$func = options.func) != null ? _options$func : FUNC_ALWAYS; + this._ref = (_options$ref = options.ref) != null ? _options$ref : 0; + this._readMask = (_options$readMask = options.readMask) != null ? _options$readMask : 255; + this._writeMask = (_options$writeMask = options.writeMask) != null ? _options$writeMask : 255; + this._fail = (_options$fail = options.fail) != null ? _options$fail : STENCILOP_KEEP; + this._zfail = (_options$zfail = options.zfail) != null ? _options$zfail : STENCILOP_KEEP; + this._zpass = (_options$zpass = options.zpass) != null ? _options$zpass : STENCILOP_KEEP; + this._evalKey(); + } + _evalKey() { + const { + _func, + _ref: _ref4, + _fail, + _zfail, + _zpass, + _readMask, + _writeMask + } = this; + const key = `${_func},${_ref4},${_fail},${_zfail},${_zpass},${_readMask},${_writeMask}`; + this._key = stringIds3.get(key); + this._dirty = false; + } + get key() { + if (this._dirty) { + this._evalKey(); + } + return this._key; + } + copy(rhs) { + this._func = rhs._func; + this._ref = rhs._ref; + this._readMask = rhs._readMask; + this._writeMask = rhs._writeMask; + this._fail = rhs._fail; + this._zfail = rhs._zfail; + this._zpass = rhs._zpass; + this._dirty = rhs._dirty; + this._key = rhs._key; + return this; + } + clone() { + const clone = new this.constructor(); + return clone.copy(this); + } +}; +_StencilParameters = StencilParameters; +StencilParameters.DEFAULT = Object.freeze(new _StencilParameters()); + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/graphics-device.js +var GraphicsDevice = class _GraphicsDevice extends EventHandler { + constructor(canvas, options) { + var _this$initOptions, _this$initOptions$dep, _this$initOptions2, _this$initOptions2$st, _this$initOptions3, _this$initOptions3$an, _this$initOptions4, _this$initOptions4$po; + super(); + this.canvas = void 0; + this.backBuffer = null; + this.backBufferSize = new Vec2(); + this.backBufferFormat = void 0; + this.backBufferAntialias = false; + this.isWebGPU = false; + this.isWebGL1 = false; + this.isWebGL2 = false; + this.scope = void 0; + this.boneLimit = void 0; + this.maxAnisotropy = void 0; + this.maxCubeMapSize = void 0; + this.maxTextureSize = void 0; + this.maxVolumeSize = void 0; + this.maxColorAttachments = 1; + this.precision = void 0; + this.samples = void 0; + this.supportsStencil = void 0; + this.supportsMrt = false; + this.supportsVolumeTextures = false; + this.supportsCompute = false; + this.supportsStorageTextureRead = false; + this.renderTarget = null; + this.shaders = []; + this.textures = []; + this.targets = /* @__PURE__ */ new Set(); + this.renderVersion = 0; + this.renderPassIndex = void 0; + this.insideRenderPass = false; + this.supportsInstancing = void 0; + this.supportsUniformBuffers = false; + this.textureFloatRenderable = void 0; + this.textureHalfFloatRenderable = void 0; + this.textureFloatFilterable = false; + this.textureHalfFloatFilterable = false; + this.quadVertexBuffer = void 0; + this.blendState = new BlendState(); + this.depthState = new DepthState(); + this.stencilEnabled = false; + this.stencilFront = new StencilParameters(); + this.stencilBack = new StencilParameters(); + this.dynamicBuffers = void 0; + this.gpuProfiler = void 0; + this.defaultClearOptions = { + color: [0, 0, 0, 1], + depth: 1, + stencil: 0, + flags: CLEARFLAG_COLOR | CLEARFLAG_DEPTH + }; + this.clientRect = { + width: 0, + height: 0 + }; + this.canvas = canvas; + this.initOptions = _extends({}, options); + (_this$initOptions$dep = (_this$initOptions = this.initOptions).depth) != null ? _this$initOptions$dep : _this$initOptions.depth = true; + (_this$initOptions2$st = (_this$initOptions2 = this.initOptions).stencil) != null ? _this$initOptions2$st : _this$initOptions2.stencil = true; + (_this$initOptions3$an = (_this$initOptions3 = this.initOptions).antialias) != null ? _this$initOptions3$an : _this$initOptions3.antialias = true; + (_this$initOptions4$po = (_this$initOptions4 = this.initOptions).powerPreference) != null ? _this$initOptions4$po : _this$initOptions4.powerPreference = "high-performance"; + this._maxPixelRatio = platform.browser ? Math.min(1, window.devicePixelRatio) : 1; + this.buffers = []; + this._vram = { + tex: 0, + vb: 0, + ib: 0, + ub: 0, + sb: 0 + }; + this._shaderStats = { + vsCompiled: 0, + fsCompiled: 0, + linked: 0, + materialShaders: 0, + compileTime: 0 + }; + this.initializeContextCaches(); + this._drawCallsPerFrame = 0; + this._shaderSwitchesPerFrame = 0; + this._primsPerFrame = []; + for (let i = PRIMITIVE_POINTS; i <= PRIMITIVE_TRIFAN; i++) { + this._primsPerFrame[i] = 0; + } + this._renderTargetCreationTime = 0; + this.scope = new ScopeSpace("Device"); + this.textureBias = this.scope.resolve("textureBias"); + this.textureBias.setValue(0); + } + postInit() { + const vertexFormat = new VertexFormat(this, [{ + semantic: SEMANTIC_POSITION, + components: 2, + type: TYPE_FLOAT32 + }]); + const positions = new Float32Array([-1, -1, 1, -1, -1, 1, 1, 1]); + this.quadVertexBuffer = new VertexBuffer(this, vertexFormat, 4, { + data: positions + }); + } + destroy() { + var _this$quadVertexBuffe, _this$dynamicBuffers, _this$gpuProfiler; + this.fire("destroy"); + (_this$quadVertexBuffe = this.quadVertexBuffer) == null || _this$quadVertexBuffe.destroy(); + this.quadVertexBuffer = null; + (_this$dynamicBuffers = this.dynamicBuffers) == null || _this$dynamicBuffers.destroy(); + this.dynamicBuffers = null; + (_this$gpuProfiler = this.gpuProfiler) == null || _this$gpuProfiler.destroy(); + this.gpuProfiler = null; + } + onDestroyShader(shader) { + this.fire("destroy:shader", shader); + const idx = this.shaders.indexOf(shader); + if (idx !== -1) { + this.shaders.splice(idx, 1); + } + } + postDestroy() { + this.scope = null; + this.canvas = null; + } + loseContext() { + var _this$gpuProfiler2; + this.contextLost = true; + this.backBufferSize.set(-1, -1); + for (const texture of this.textures) { + texture.loseContext(); + } + for (const buffer of this.buffers) { + buffer.loseContext(); + } + for (const target2 of this.targets) { + target2.loseContext(); + } + (_this$gpuProfiler2 = this.gpuProfiler) == null || _this$gpuProfiler2.loseContext(); + } + restoreContext() { + var _this$gpuProfiler3; + this.contextLost = false; + this.initializeRenderState(); + this.initializeContextCaches(); + for (const buffer of this.buffers) { + buffer.unlock(); + } + (_this$gpuProfiler3 = this.gpuProfiler) == null || _this$gpuProfiler3.restoreContext == null || _this$gpuProfiler3.restoreContext(); + } + toJSON(key) { + return void 0; + } + initializeContextCaches() { + this.indexBuffer = null; + this.vertexBuffers = []; + this.shader = null; + this.shaderValid = void 0; + this.shaderAsyncCompile = false; + this.renderTarget = null; + } + initializeRenderState() { + this.blendState = new BlendState(); + this.depthState = new DepthState(); + this.cullMode = CULLFACE_BACK; + this.vx = this.vy = this.vw = this.vh = 0; + this.sx = this.sy = this.sw = this.sh = 0; + this.blendColor = new Color(0, 0, 0, 0); + } + setStencilState(stencilFront, stencilBack) { + } + setBlendState(blendState) { + } + setBlendColor(r, g, b, a) { + } + setDepthState(depthState) { + } + setCullMode(cullMode) { + } + setRenderTarget(renderTarget) { + this.renderTarget = renderTarget; + } + setIndexBuffer(indexBuffer) { + this.indexBuffer = indexBuffer; + } + setVertexBuffer(vertexBuffer) { + if (vertexBuffer) { + this.vertexBuffers.push(vertexBuffer); + } + } + clearVertexBuffer() { + this.vertexBuffers.length = 0; + } + getRenderTarget() { + return this.renderTarget; + } + initRenderTarget(target2) { + if (target2.initialized) return; + target2.init(); + this.targets.add(target2); + } + _isBrowserInterface(texture) { + return this._isImageBrowserInterface(texture) || this._isImageCanvasInterface(texture) || this._isImageVideoInterface(texture); + } + _isImageBrowserInterface(texture) { + return typeof ImageBitmap !== "undefined" && texture instanceof ImageBitmap || typeof HTMLImageElement !== "undefined" && texture instanceof HTMLImageElement; + } + _isImageCanvasInterface(texture) { + return typeof HTMLCanvasElement !== "undefined" && texture instanceof HTMLCanvasElement; + } + _isImageVideoInterface(texture) { + return typeof HTMLVideoElement !== "undefined" && texture instanceof HTMLVideoElement; + } + resizeCanvas(width, height) { + const pixelRatio = Math.min(this._maxPixelRatio, platform.browser ? window.devicePixelRatio : 1); + const w = Math.floor(width * pixelRatio); + const h = Math.floor(height * pixelRatio); + if (w !== this.canvas.width || h !== this.canvas.height) { + this.setResolution(w, h); + } + } + setResolution(width, height) { + this.canvas.width = width; + this.canvas.height = height; + this.fire(_GraphicsDevice.EVENT_RESIZE, width, height); + } + updateClientRect() { + if (platform.worker) { + this.clientRect.width = this.canvas.width; + this.clientRect.height = this.canvas.height; + } else { + const rect = this.canvas.getBoundingClientRect(); + this.clientRect.width = rect.width; + this.clientRect.height = rect.height; + } + } + get width() { + return this.canvas.width; + } + get height() { + return this.canvas.height; + } + set fullscreen(fullscreen) { + } + get fullscreen() { + return false; + } + set maxPixelRatio(ratio) { + this._maxPixelRatio = ratio; + } + get maxPixelRatio() { + return this._maxPixelRatio; + } + get deviceType() { + return this._deviceType; + } + getBoneLimit() { + return this.boneLimit; + } + setBoneLimit(maxBones) { + this.boneLimit = maxBones; + } + startRenderPass(renderPass) { + } + endRenderPass(renderPass) { + } + startComputePass() { + } + endComputePass() { + } + frameStart() { + this.renderPassIndex = 0; + this.renderVersion++; + } + frameEnd() { + } + computeDispatch(computes) { + } + getRenderableHdrFormat(formats = [PIXELFORMAT_111110F, PIXELFORMAT_RGBA16F, PIXELFORMAT_RGBA32F], filterable = true) { + for (let i = 0; i < formats.length; i++) { + const format = formats[i]; + switch (format) { + case PIXELFORMAT_111110F: { + if (this.textureRG11B10Renderable) return format; + break; + } + case PIXELFORMAT_RGBA16F: + if (this.textureHalfFloatRenderable && (!filterable || this.textureHalfFloatFilterable)) { + return format; + } + break; + case PIXELFORMAT_RGBA32F: + if (this.textureFloatRenderable && (!filterable || this.textureFloatFilterable)) { + return format; + } + break; + } + } + return void 0; + } +}; +GraphicsDevice.EVENT_RESIZE = "resizecanvas"; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/render-target.js +var id2 = 0; +var RenderTarget = class { + constructor(options = {}) { + var _options$face, _this$_colorBuffer, _this$_depthBuffer, _options$samples, _options$autoResolve, _options$flipY; + this.name = void 0; + this._device = void 0; + this._colorBuffer = void 0; + this._colorBuffers = void 0; + this._depthBuffer = void 0; + this._depth = void 0; + this._stencil = void 0; + this._samples = void 0; + this.autoResolve = void 0; + this._face = void 0; + this.flipY = void 0; + this.id = id2++; + const _arg2 = arguments[1]; + const _arg3 = arguments[2]; + if (options instanceof GraphicsDevice) { + this._colorBuffer = _arg2; + options = _arg3; + } else { + this._colorBuffer = options.colorBuffer; + } + if (this._colorBuffer) { + this._colorBuffers = [this._colorBuffer]; + } + this._depthBuffer = options.depthBuffer; + this._face = (_options$face = options.face) != null ? _options$face : 0; + if (this._depthBuffer) { + const format = this._depthBuffer._format; + if (format === PIXELFORMAT_DEPTH) { + this._depth = true; + this._stencil = false; + } else if (format === PIXELFORMAT_DEPTHSTENCIL) { + this._depth = true; + this._stencil = true; + } else { + this._depth = false; + this._stencil = false; + } + } else { + var _options$depth, _options$stencil; + this._depth = (_options$depth = options.depth) != null ? _options$depth : true; + this._stencil = (_options$stencil = options.stencil) != null ? _options$stencil : false; + } + if (options.colorBuffers) { + if (!this._colorBuffers) { + this._colorBuffers = [...options.colorBuffers]; + this._colorBuffer = options.colorBuffers[0]; + } + } + const device = ((_this$_colorBuffer = this._colorBuffer) == null ? void 0 : _this$_colorBuffer.device) || ((_this$_depthBuffer = this._depthBuffer) == null ? void 0 : _this$_depthBuffer.device) || options.graphicsDevice; + this._device = device; + const { + maxSamples + } = this._device; + this._samples = Math.min((_options$samples = options.samples) != null ? _options$samples : 1, maxSamples); + if (device.isWebGPU) { + this._samples = this._samples > 1 ? maxSamples : 1; + } + this.autoResolve = (_options$autoResolve = options.autoResolve) != null ? _options$autoResolve : true; + this.name = options.name; + if (!this.name) { + var _this$_colorBuffer2; + this.name = (_this$_colorBuffer2 = this._colorBuffer) == null ? void 0 : _this$_colorBuffer2.name; + } + if (!this.name) { + var _this$_depthBuffer2; + this.name = (_this$_depthBuffer2 = this._depthBuffer) == null ? void 0 : _this$_depthBuffer2.name; + } + if (!this.name) { + this.name = "Untitled"; + } + this.flipY = (_options$flipY = options.flipY) != null ? _options$flipY : false; + this.validateMrt(); + this.impl = device.createRenderTargetImpl(this); + } + destroy() { + const device = this._device; + if (device) { + device.targets.delete(this); + if (device.renderTarget === this) { + device.setRenderTarget(null); + } + this.destroyFrameBuffers(); + } + } + destroyFrameBuffers() { + const device = this._device; + if (device) { + this.impl.destroy(device); + } + } + destroyTextureBuffers() { + var _this$_depthBuffer3, _this$_colorBuffers; + (_this$_depthBuffer3 = this._depthBuffer) == null || _this$_depthBuffer3.destroy(); + this._depthBuffer = null; + (_this$_colorBuffers = this._colorBuffers) == null || _this$_colorBuffers.forEach((colorBuffer) => { + colorBuffer.destroy(); + }); + this._colorBuffers = null; + this._colorBuffer = null; + } + resize(width, height) { + if (this.width !== width || this.height !== height) { + var _this$_depthBuffer4, _this$_colorBuffers2; + const device = this._device; + this.destroyFrameBuffers(); + if (device.renderTarget === this) { + device.setRenderTarget(null); + } + (_this$_depthBuffer4 = this._depthBuffer) == null || _this$_depthBuffer4.resize(width, height); + (_this$_colorBuffers2 = this._colorBuffers) == null || _this$_colorBuffers2.forEach((colorBuffer) => { + colorBuffer.resize(width, height); + }); + this.validateMrt(); + this.impl = device.createRenderTargetImpl(this); + } + } + validateMrt() { + } + init() { + this.impl.init(this._device, this); + } + get initialized() { + return this.impl.initialized; + } + get device() { + return this._device; + } + loseContext() { + this.impl.loseContext(); + } + resolve(color = true, depth = !!this._depthBuffer) { + if (this._device && this._samples > 1) { + this.impl.resolve(this._device, this, color, depth); + } + } + copy(source, color, depth) { + if (!this._device) { + if (source._device) { + this._device = source._device; + } else { + return false; + } + } + const success = this._device.copyRenderTarget(source, this, color, depth); + return success; + } + get samples() { + return this._samples; + } + get depth() { + return this._depth; + } + get stencil() { + return this._stencil; + } + get colorBuffer() { + return this._colorBuffer; + } + getColorBuffer(index) { + var _this$_colorBuffers3; + return (_this$_colorBuffers3 = this._colorBuffers) == null ? void 0 : _this$_colorBuffers3[index]; + } + get depthBuffer() { + return this._depthBuffer; + } + get face() { + return this._face; + } + get width() { + var _this$_colorBuffer3, _this$_depthBuffer5; + return ((_this$_colorBuffer3 = this._colorBuffer) == null ? void 0 : _this$_colorBuffer3.width) || ((_this$_depthBuffer5 = this._depthBuffer) == null ? void 0 : _this$_depthBuffer5.width) || this._device.width; + } + get height() { + var _this$_colorBuffer4, _this$_depthBuffer6; + return ((_this$_colorBuffer4 = this._colorBuffer) == null ? void 0 : _this$_colorBuffer4.height) || ((_this$_depthBuffer6 = this._depthBuffer) == null ? void 0 : _this$_depthBuffer6.height) || this._device.height; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-bind-group.js +var WebgpuBindGroup = class { + constructor() { + this.bindGroup = void 0; + } + update(bindGroup) { + this.destroy(); + const device = bindGroup.device; + const descr = this.createDescriptor(device, bindGroup); + this.bindGroup = device.wgpu.createBindGroup(descr); + } + destroy() { + this.bindGroup = null; + } + createDescriptor(device, bindGroup) { + const entries = []; + const format = bindGroup.format; + const uniformBufferFormats = bindGroup.format.uniformBufferFormats; + bindGroup.uniformBuffers.forEach((ub, i) => { + const slot = uniformBufferFormats[i].slot; + const buffer = ub.persistent ? ub.impl.buffer : ub.allocation.gpuBuffer.buffer; + entries.push({ + binding: slot, + resource: { + buffer, + offset: 0, + size: ub.format.byteSize + } + }); + }); + const textureFormats = bindGroup.format.textureFormats; + bindGroup.textures.forEach((tex, textureIndex) => { + const wgpuTexture = tex.impl; + const textureFormat = format.textureFormats[textureIndex]; + const slot = textureFormats[textureIndex].slot; + const view = wgpuTexture.getView(device); + entries.push({ + binding: slot, + resource: view + }); + if (textureFormat.hasSampler) { + const sampler = wgpuTexture.getSampler(device, textureFormat.sampleType); + entries.push({ + binding: slot + 1, + resource: sampler + }); + } + }); + const storageTextureFormats = bindGroup.format.storageTextureFormats; + bindGroup.storageTextures.forEach((tex, textureIndex) => { + const wgpuTexture = tex.impl; + const slot = storageTextureFormats[textureIndex].slot; + const view = wgpuTexture.getView(device); + entries.push({ + binding: slot, + resource: view + }); + }); + const storageBufferFormats = bindGroup.format.storageBufferFormats; + bindGroup.storageBuffers.forEach((buffer, bufferIndex) => { + const wgpuBuffer = buffer.impl.buffer; + const slot = storageBufferFormats[bufferIndex].slot; + entries.push({ + binding: slot, + resource: { + buffer: wgpuBuffer + } + }); + }); + const descr = { + layout: bindGroup.format.impl.bindGroupLayout, + entries + }; + return descr; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-utils.js +var WebgpuUtils = class { + static shaderStage(stage) { + let ret = 0; + if (stage & SHADERSTAGE_VERTEX) ret |= GPUShaderStage.VERTEX; + if (stage & SHADERSTAGE_FRAGMENT) ret |= GPUShaderStage.FRAGMENT; + if (stage & SHADERSTAGE_COMPUTE) ret |= GPUShaderStage.COMPUTE; + return ret; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/constants.js +var gpuTextureFormats = []; +gpuTextureFormats[PIXELFORMAT_A8] = ""; +gpuTextureFormats[PIXELFORMAT_L8] = "r8unorm"; +gpuTextureFormats[PIXELFORMAT_LA8] = "rg8unorm"; +gpuTextureFormats[PIXELFORMAT_RGB565] = ""; +gpuTextureFormats[PIXELFORMAT_RGBA5551] = ""; +gpuTextureFormats[PIXELFORMAT_RGBA4] = ""; +gpuTextureFormats[PIXELFORMAT_RGB8] = "rgba8unorm"; +gpuTextureFormats[PIXELFORMAT_RGBA8] = "rgba8unorm"; +gpuTextureFormats[PIXELFORMAT_DXT1] = "bc1-rgba-unorm"; +gpuTextureFormats[PIXELFORMAT_DXT3] = "bc2-rgba-unorm"; +gpuTextureFormats[PIXELFORMAT_DXT5] = "bc3-rgba-unorm"; +gpuTextureFormats[PIXELFORMAT_RGB16F] = ""; +gpuTextureFormats[PIXELFORMAT_RGBA16F] = "rgba16float"; +gpuTextureFormats[PIXELFORMAT_R16F] = "r16float"; +gpuTextureFormats[PIXELFORMAT_RG16F] = "rg16float"; +gpuTextureFormats[PIXELFORMAT_RGB32F] = ""; +gpuTextureFormats[PIXELFORMAT_RGBA32F] = "rgba32float"; +gpuTextureFormats[PIXELFORMAT_R32F] = "r32float"; +gpuTextureFormats[PIXELFORMAT_DEPTH] = "depth32float"; +gpuTextureFormats[PIXELFORMAT_DEPTHSTENCIL] = "depth24plus-stencil8"; +gpuTextureFormats[PIXELFORMAT_111110F] = "rg11b10ufloat"; +gpuTextureFormats[PIXELFORMAT_SRGB] = ""; +gpuTextureFormats[PIXELFORMAT_SRGBA] = ""; +gpuTextureFormats[PIXELFORMAT_ETC1] = ""; +gpuTextureFormats[PIXELFORMAT_ETC2_RGB] = "etc2-rgb8unorm"; +gpuTextureFormats[PIXELFORMAT_ETC2_RGBA] = "etc2-rgba8unorm"; +gpuTextureFormats[PIXELFORMAT_PVRTC_2BPP_RGB_1] = ""; +gpuTextureFormats[PIXELFORMAT_PVRTC_2BPP_RGBA_1] = ""; +gpuTextureFormats[PIXELFORMAT_PVRTC_4BPP_RGB_1] = ""; +gpuTextureFormats[PIXELFORMAT_PVRTC_4BPP_RGBA_1] = ""; +gpuTextureFormats[PIXELFORMAT_ASTC_4x4] = "astc-4x4-unorm"; +gpuTextureFormats[PIXELFORMAT_ATC_RGB] = ""; +gpuTextureFormats[PIXELFORMAT_ATC_RGBA] = ""; +gpuTextureFormats[PIXELFORMAT_BGRA8] = "bgra8unorm"; +gpuTextureFormats[PIXELFORMAT_R8I] = "r8sint"; +gpuTextureFormats[PIXELFORMAT_R8U] = "r8uint"; +gpuTextureFormats[PIXELFORMAT_R16I] = "r16sint"; +gpuTextureFormats[PIXELFORMAT_R16U] = "r16uint"; +gpuTextureFormats[PIXELFORMAT_R32I] = "r32sint"; +gpuTextureFormats[PIXELFORMAT_R32U] = "r32uint"; +gpuTextureFormats[PIXELFORMAT_RG8I] = "rg8sint"; +gpuTextureFormats[PIXELFORMAT_RG8U] = "rg8uint"; +gpuTextureFormats[PIXELFORMAT_RG16I] = "rg16sint"; +gpuTextureFormats[PIXELFORMAT_RG16U] = "rg16uint"; +gpuTextureFormats[PIXELFORMAT_RG32I] = "rg32sint"; +gpuTextureFormats[PIXELFORMAT_RG32U] = "rg32uint"; +gpuTextureFormats[PIXELFORMAT_RGBA8I] = "rgba8sint"; +gpuTextureFormats[PIXELFORMAT_RGBA8U] = "rgba8uint"; +gpuTextureFormats[PIXELFORMAT_RGBA16I] = "rgba16sint"; +gpuTextureFormats[PIXELFORMAT_RGBA16U] = "rgba16uint"; +gpuTextureFormats[PIXELFORMAT_RGBA32I] = "rgba32sint"; +gpuTextureFormats[PIXELFORMAT_RGBA32U] = "rgba32uint"; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-bind-group-format.js +var samplerTypes = []; +samplerTypes[SAMPLETYPE_FLOAT] = "filtering"; +samplerTypes[SAMPLETYPE_UNFILTERABLE_FLOAT] = "non-filtering"; +samplerTypes[SAMPLETYPE_DEPTH] = "comparison"; +samplerTypes[SAMPLETYPE_INT] = "comparison"; +samplerTypes[SAMPLETYPE_UINT] = "comparison"; +var sampleTypes = []; +sampleTypes[SAMPLETYPE_FLOAT] = "float"; +sampleTypes[SAMPLETYPE_UNFILTERABLE_FLOAT] = "unfilterable-float"; +sampleTypes[SAMPLETYPE_DEPTH] = "depth"; +sampleTypes[SAMPLETYPE_INT] = "sint"; +sampleTypes[SAMPLETYPE_UINT] = "uint"; +var stringIds4 = new StringIds(); +var WebgpuBindGroupFormat = class { + constructor(bindGroupFormat) { + const device = bindGroupFormat.device; + const { + key, + descr + } = this.createDescriptor(bindGroupFormat); + this.key = stringIds4.get(key); + this.bindGroupLayout = device.wgpu.createBindGroupLayout(descr); + } + destroy() { + this.bindGroupLayout = null; + } + loseContext() { + } + createDescriptor(bindGroupFormat) { + const entries = []; + let key = ""; + bindGroupFormat.uniformBufferFormats.forEach((bufferFormat) => { + const visibility = WebgpuUtils.shaderStage(bufferFormat.visibility); + key += `#${bufferFormat.slot}U:${visibility}`; + entries.push({ + binding: bufferFormat.slot, + visibility, + buffer: { + type: "uniform", + hasDynamicOffset: true + } + }); + }); + bindGroupFormat.textureFormats.forEach((textureFormat) => { + const visibility = WebgpuUtils.shaderStage(textureFormat.visibility); + const sampleType = textureFormat.sampleType; + const viewDimension = textureFormat.textureDimension; + const multisampled = false; + const gpuSampleType = sampleTypes[sampleType]; + key += `#${textureFormat.slot}T:${visibility}-${gpuSampleType}-${viewDimension}-${multisampled}`; + entries.push({ + binding: textureFormat.slot, + visibility, + texture: { + sampleType: gpuSampleType, + viewDimension, + multisampled + } + }); + if (textureFormat.hasSampler) { + const gpuSamplerType = samplerTypes[sampleType]; + key += `#${textureFormat.slot + 1}S:${visibility}-${gpuSamplerType}`; + entries.push({ + binding: textureFormat.slot + 1, + visibility, + sampler: { + type: gpuSamplerType + } + }); + } + }); + bindGroupFormat.storageTextureFormats.forEach((textureFormat) => { + const { + format, + textureDimension + } = textureFormat; + const { + read, + write + } = textureFormat; + key += `#${textureFormat.slot}ST:${format}-${textureDimension}-${read ? "r1" : "r0"}-${write ? "w1" : "w0"}`; + entries.push({ + binding: textureFormat.slot, + visibility: GPUShaderStage.COMPUTE, + storageTexture: { + access: read ? write ? "read-write" : "read-only" : "write-only", + format: gpuTextureFormats[format], + viewDimension: textureDimension + } + }); + }); + bindGroupFormat.storageBufferFormats.forEach((bufferFormat) => { + const readOnly = bufferFormat.readOnly; + const visibility = WebgpuUtils.shaderStage(bufferFormat.visibility); + key += `#${bufferFormat.slot}SB:${visibility}-${readOnly ? "ro" : "rw"}`; + entries.push({ + binding: bufferFormat.slot, + visibility, + buffer: { + type: readOnly ? "read-only-storage" : "storage" + } + }); + }); + const descr = { + entries + }; + return { + key, + descr + }; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-buffer.js +var WebgpuBuffer = class { + constructor(usageFlags = 0) { + this.buffer = null; + this.usageFlags = 0; + this.usageFlags = usageFlags; + } + destroy(device) { + if (this.buffer) { + this.buffer.destroy(); + this.buffer = null; + } + } + get initialized() { + return !!this.buffer; + } + loseContext() { + } + allocate(device, size) { + this.buffer = device.wgpu.createBuffer({ + size, + usage: this.usageFlags + }); + } + unlock(device, storage) { + var _storage$byteOffset, _storage$buffer; + const wgpu = device.wgpu; + if (!this.buffer) { + const size = storage.byteLength + 3 & ~3; + this.usageFlags |= GPUBufferUsage.COPY_DST; + this.allocate(device, size); + } + const srcOffset = (_storage$byteOffset = storage.byteOffset) != null ? _storage$byteOffset : 0; + const srcData = new Uint8Array((_storage$buffer = storage.buffer) != null ? _storage$buffer : storage, srcOffset, storage.byteLength); + const data2 = new Uint8Array(this.buffer.size); + data2.set(srcData); + wgpu.queue.writeBuffer(this.buffer, 0, data2, 0, data2.length); + } + read(device, offset, size, data2) { + return device.readStorageBuffer(this, offset, size, data2); + } + write(device, bufferOffset, data2, dataOffset, size) { + device.writeStorageBuffer(this, bufferOffset, data2, dataOffset, size); + } + clear(device, offset, size) { + device.clearStorageBuffer(this, offset, size); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-index-buffer.js +var WebgpuIndexBuffer = class extends WebgpuBuffer { + constructor(indexBuffer, options) { + super(BUFFERUSAGE_INDEX | (options != null && options.storage ? BUFFERUSAGE_STORAGE : 0)); + this.format = null; + this.format = indexBuffer.format === INDEXFORMAT_UINT16 ? "uint16" : "uint32"; + } + unlock(indexBuffer) { + const device = indexBuffer.device; + super.unlock(device, indexBuffer.storage); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/core/array-utils.js +var array = { + equals(arr1, arr2) { + if (arr1.length !== arr2.length) { + return false; + } + for (let i = 0; i < arr1.length; i++) { + if (arr1[i] !== arr2[i]) { + return false; + } + } + return true; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-vertex-buffer-layout.js +var gpuVertexFormats = []; +gpuVertexFormats[TYPE_INT8] = "sint8"; +gpuVertexFormats[TYPE_UINT8] = "uint8"; +gpuVertexFormats[TYPE_INT16] = "sint16"; +gpuVertexFormats[TYPE_UINT16] = "uint16"; +gpuVertexFormats[TYPE_INT32] = "sint32"; +gpuVertexFormats[TYPE_UINT32] = "uint32"; +gpuVertexFormats[TYPE_FLOAT32] = "float32"; +gpuVertexFormats[TYPE_FLOAT16] = "float16"; +var gpuVertexFormatsNormalized = []; +gpuVertexFormatsNormalized[TYPE_INT8] = "snorm8"; +gpuVertexFormatsNormalized[TYPE_UINT8] = "unorm8"; +gpuVertexFormatsNormalized[TYPE_INT16] = "snorm16"; +gpuVertexFormatsNormalized[TYPE_UINT16] = "unorm16"; +gpuVertexFormatsNormalized[TYPE_INT32] = "sint32"; +gpuVertexFormatsNormalized[TYPE_UINT32] = "uint32"; +gpuVertexFormatsNormalized[TYPE_FLOAT32] = "float32"; +gpuVertexFormatsNormalized[TYPE_FLOAT16] = "float16"; +var WebgpuVertexBufferLayout = class { + constructor() { + this.cache = /* @__PURE__ */ new Map(); + } + get(vertexFormat0, vertexFormat1 = null) { + const key = this.getKey(vertexFormat0, vertexFormat1); + let layout = this.cache.get(key); + if (!layout) { + layout = this.create(vertexFormat0, vertexFormat1); + this.cache.set(key, layout); + } + return layout; + } + getKey(vertexFormat0, vertexFormat1 = null) { + return `${vertexFormat0 == null ? void 0 : vertexFormat0.renderingHashString}-${vertexFormat1 == null ? void 0 : vertexFormat1.renderingHashString}`; + } + create(vertexFormat0, vertexFormat1) { + const layout = []; + const addFormat = (format) => { + const interleaved = format.interleaved; + const stepMode = format.instancing ? "instance" : "vertex"; + let attributes = []; + const elementCount = format.elements.length; + for (let i = 0; i < elementCount; i++) { + const element = format.elements[i]; + const location = semanticToLocation[element.name]; + const formatTable = element.normalize ? gpuVertexFormatsNormalized : gpuVertexFormats; + attributes.push({ + shaderLocation: location, + offset: interleaved ? element.offset : 0, + format: `${formatTable[element.dataType]}${element.numComponents > 1 ? "x" + element.numComponents : ""}` + }); + if (!interleaved || i === elementCount - 1) { + layout.push({ + attributes, + arrayStride: element.stride, + stepMode + }); + attributes = []; + } + } + }; + if (vertexFormat0) addFormat(vertexFormat0); + if (vertexFormat1) addFormat(vertexFormat1); + return layout; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-pipeline.js +var WebgpuPipeline = class { + constructor(device) { + this.device = device; + } + getPipelineLayout(bindGroupFormats) { + const bindGroupLayouts = []; + bindGroupFormats.forEach((format) => { + bindGroupLayouts.push(format.bindGroupLayout); + }); + const descr = { + bindGroupLayouts + }; + const pipelineLayout = this.device.wgpu.createPipelineLayout(descr); + return pipelineLayout; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-render-pipeline.js +var _primitiveTopology = ["point-list", "line-list", void 0, "line-strip", "triangle-list", "triangle-strip", void 0]; +var _blendOperation = ["add", "subtract", "reverse-subtract", "min", "max"]; +var _blendFactor = ["zero", "one", "src", "one-minus-src", "dst", "one-minus-dst", "src-alpha", "src-alpha-saturated", "one-minus-src-alpha", "dst-alpha", "one-minus-dst-alpha", "constant", "one-minus-constant"]; +var _compareFunction = ["never", "less", "equal", "less-equal", "greater", "not-equal", "greater-equal", "always"]; +var _cullModes = ["none", "back", "front"]; +var _stencilOps = ["keep", "zero", "replace", "increment-clamp", "increment-wrap", "decrement-clamp", "decrement-wrap", "invert"]; +var CacheEntry = class { + constructor() { + this.pipeline = void 0; + this.hashes = void 0; + } +}; +var WebgpuRenderPipeline = class extends WebgpuPipeline { + constructor(device) { + super(device); + this.lookupHashes = new Uint32Array(13); + this.vertexBufferLayout = new WebgpuVertexBufferLayout(); + this.cache = /* @__PURE__ */ new Map(); + } + get(primitive2, vertexFormat0, vertexFormat1, shader, renderTarget, bindGroupFormats, blendState, depthState, cullMode, stencilEnabled, stencilFront, stencilBack) { + var _vertexFormat0$render, _vertexFormat1$render, _bindGroupFormats$0$k, _bindGroupFormats$, _bindGroupFormats$1$k, _bindGroupFormats$2, _bindGroupFormats$2$k, _bindGroupFormats$3; + const lookupHashes = this.lookupHashes; + lookupHashes[0] = primitive2.type; + lookupHashes[1] = shader.id; + lookupHashes[2] = cullMode; + lookupHashes[3] = depthState.key; + lookupHashes[4] = blendState.key; + lookupHashes[5] = (_vertexFormat0$render = vertexFormat0 == null ? void 0 : vertexFormat0.renderingHash) != null ? _vertexFormat0$render : 0; + lookupHashes[6] = (_vertexFormat1$render = vertexFormat1 == null ? void 0 : vertexFormat1.renderingHash) != null ? _vertexFormat1$render : 0; + lookupHashes[7] = renderTarget.impl.key; + lookupHashes[8] = (_bindGroupFormats$0$k = (_bindGroupFormats$ = bindGroupFormats[0]) == null ? void 0 : _bindGroupFormats$.key) != null ? _bindGroupFormats$0$k : 0; + lookupHashes[9] = (_bindGroupFormats$1$k = (_bindGroupFormats$2 = bindGroupFormats[1]) == null ? void 0 : _bindGroupFormats$2.key) != null ? _bindGroupFormats$1$k : 0; + lookupHashes[10] = (_bindGroupFormats$2$k = (_bindGroupFormats$3 = bindGroupFormats[2]) == null ? void 0 : _bindGroupFormats$3.key) != null ? _bindGroupFormats$2$k : 0; + lookupHashes[11] = stencilEnabled ? stencilFront.key : 0; + lookupHashes[12] = stencilEnabled ? stencilBack.key : 0; + const hash = hash32Fnv1a(lookupHashes); + let cacheEntries = this.cache.get(hash); + if (cacheEntries) { + for (let i = 0; i < cacheEntries.length; i++) { + const entry = cacheEntries[i]; + if (array.equals(entry.hashes, lookupHashes)) { + return entry.pipeline; + } + } + } + const primitiveTopology = _primitiveTopology[primitive2.type]; + const pipelineLayout = this.getPipelineLayout(bindGroupFormats); + const vertexBufferLayout = this.vertexBufferLayout.get(vertexFormat0, vertexFormat1); + const cacheEntry = new CacheEntry(); + cacheEntry.hashes = new Uint32Array(lookupHashes); + cacheEntry.pipeline = this.create(primitiveTopology, shader, renderTarget, pipelineLayout, blendState, depthState, vertexBufferLayout, cullMode, stencilEnabled, stencilFront, stencilBack); + if (cacheEntries) { + cacheEntries.push(cacheEntry); + } else { + cacheEntries = [cacheEntry]; + } + this.cache.set(hash, cacheEntries); + return cacheEntry.pipeline; + } + getBlend(blendState) { + let blend; + if (blendState.blend) { + blend = { + color: { + operation: _blendOperation[blendState.colorOp], + srcFactor: _blendFactor[blendState.colorSrcFactor], + dstFactor: _blendFactor[blendState.colorDstFactor] + }, + alpha: { + operation: _blendOperation[blendState.alphaOp], + srcFactor: _blendFactor[blendState.alphaSrcFactor], + dstFactor: _blendFactor[blendState.alphaDstFactor] + } + }; + } + return blend; + } + getDepthStencil(depthState, renderTarget, stencilEnabled, stencilFront, stencilBack) { + let depthStencil; + const { + depth, + stencil + } = renderTarget; + if (depth || stencil) { + depthStencil = { + format: renderTarget.impl.depthFormat + }; + if (depth) { + depthStencil.depthWriteEnabled = depthState.write; + depthStencil.depthCompare = _compareFunction[depthState.func]; + depthStencil.depthBias = depthState.depthBias; + depthStencil.depthBiasSlopeScale = depthState.depthBiasSlope; + } else { + depthStencil.depthWriteEnabled = false; + depthStencil.depthCompare = "always"; + } + if (stencil && stencilEnabled) { + depthStencil.stencilReadMas = stencilFront.readMask; + depthStencil.stencilWriteMask = stencilFront.writeMask; + depthStencil.stencilFront = { + compare: _compareFunction[stencilFront.func], + failOp: _stencilOps[stencilFront.fail], + passOp: _stencilOps[stencilFront.zpass], + depthFailOp: _stencilOps[stencilFront.zfail] + }; + depthStencil.stencilBack = { + compare: _compareFunction[stencilBack.func], + failOp: _stencilOps[stencilBack.fail], + passOp: _stencilOps[stencilBack.zpass], + depthFailOp: _stencilOps[stencilBack.zfail] + }; + } + } + return depthStencil; + } + create(primitiveTopology, shader, renderTarget, pipelineLayout, blendState, depthState, vertexBufferLayout, cullMode, stencilEnabled, stencilFront, stencilBack) { + const wgpu = this.device.wgpu; + const webgpuShader = shader.impl; + const descr = { + vertex: { + module: webgpuShader.getVertexShaderModule(), + entryPoint: webgpuShader.vertexEntryPoint, + buffers: vertexBufferLayout + }, + primitive: { + topology: primitiveTopology, + frontFace: "ccw", + cullMode: _cullModes[cullMode] + }, + depthStencil: this.getDepthStencil(depthState, renderTarget, stencilEnabled, stencilFront, stencilBack), + multisample: { + count: renderTarget.samples + }, + layout: pipelineLayout + }; + descr.fragment = { + module: webgpuShader.getFragmentShaderModule(), + entryPoint: webgpuShader.fragmentEntryPoint, + targets: [] + }; + const colorAttachments = renderTarget.impl.colorAttachments; + if (colorAttachments.length > 0) { + let writeMask = 0; + if (blendState.redWrite) writeMask |= GPUColorWrite.RED; + if (blendState.greenWrite) writeMask |= GPUColorWrite.GREEN; + if (blendState.blueWrite) writeMask |= GPUColorWrite.BLUE; + if (blendState.alphaWrite) writeMask |= GPUColorWrite.ALPHA; + const blend = this.getBlend(blendState); + colorAttachments.forEach((attachment) => { + descr.fragment.targets.push({ + format: attachment.format, + writeMask, + blend + }); + }); + } + const pipeline = wgpu.createRenderPipeline(descr); + return pipeline; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-compute-pipeline.js +var WebgpuComputePipeline = class extends WebgpuPipeline { + get(shader, bindGroupFormat) { + const pipelineLayout = this.getPipelineLayout([bindGroupFormat.impl]); + const pipeline = this.create(shader, pipelineLayout); + return pipeline; + } + create(shader, pipelineLayout) { + const wgpu = this.device.wgpu; + const webgpuShader = shader.impl; + const descr = { + compute: { + module: webgpuShader.getComputeShaderModule(), + entryPoint: webgpuShader.computeEntryPoint + }, + layout: pipelineLayout + }; + const pipeline = wgpu.createComputePipeline(descr); + return pipeline; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-render-target.js +var stringIds5 = new StringIds(); +var ColorAttachment = class { + constructor() { + this.format = void 0; + this.multisampledBuffer = void 0; + } + destroy() { + var _this$multisampledBuf; + (_this$multisampledBuf = this.multisampledBuffer) == null || _this$multisampledBuf.destroy(); + this.multisampledBuffer = null; + } +}; +var WebgpuRenderTarget = class { + constructor(renderTarget) { + this.initialized = false; + this.key = void 0; + this.colorAttachments = []; + this.depthFormat = void 0; + this.hasStencil = void 0; + this.depthTexture = null; + this.depthTextureInternal = false; + this.assignedColorTexture = null; + this.renderPassDescriptor = {}; + this.renderTarget = renderTarget; + if (renderTarget._colorBuffers) { + renderTarget._colorBuffers.forEach((colorBuffer, index) => { + this.setColorAttachment(index, void 0, colorBuffer.impl.format); + }); + } + this.updateKey(); + } + destroy(device) { + this.initialized = false; + if (this.depthTextureInternal) { + var _this$depthTexture; + (_this$depthTexture = this.depthTexture) == null || _this$depthTexture.destroy(); + this.depthTexture = null; + } + this.assignedColorTexture = null; + this.colorAttachments.forEach((colorAttachment) => { + colorAttachment.destroy(); + }); + this.colorAttachments.length = 0; + } + updateKey() { + const rt = this.renderTarget; + let key = `${rt.samples}:${rt.depth ? this.depthFormat : "nodepth"}`; + this.colorAttachments.forEach((colorAttachment) => { + key += `:${colorAttachment.format}`; + }); + this.key = stringIds5.get(key); + } + setDepthFormat(depthFormat) { + this.depthFormat = depthFormat; + this.hasStencil = depthFormat === "depth24plus-stencil8"; + } + assignColorTexture(gpuTexture) { + this.assignedColorTexture = gpuTexture; + const view = gpuTexture.createView(); + const colorAttachment = this.renderPassDescriptor.colorAttachments[0]; + const samples = this.renderTarget.samples; + if (samples > 1) { + colorAttachment.resolveTarget = view; + } else { + colorAttachment.view = view; + } + this.setColorAttachment(0, void 0, gpuTexture.format); + this.updateKey(); + } + setColorAttachment(index, multisampledBuffer, format) { + if (!this.colorAttachments[index]) { + this.colorAttachments[index] = new ColorAttachment(); + } + if (multisampledBuffer) { + this.colorAttachments[index].multisampledBuffer = multisampledBuffer; + } + if (format) { + this.colorAttachments[index].format = format; + } + } + init(device, renderTarget) { + var _renderTarget$_colorB, _renderTarget$_colorB2; + const wgpu = device.wgpu; + this.initDepthStencil(wgpu, renderTarget); + this.renderPassDescriptor.colorAttachments = []; + const count = (_renderTarget$_colorB = (_renderTarget$_colorB2 = renderTarget._colorBuffers) == null ? void 0 : _renderTarget$_colorB2.length) != null ? _renderTarget$_colorB : 1; + for (let i = 0; i < count; ++i) { + var _this$colorAttachment; + const colorAttachment = this.initColor(wgpu, renderTarget, i); + const isDefaultFramebuffer = i === 0 && ((_this$colorAttachment = this.colorAttachments[0]) == null ? void 0 : _this$colorAttachment.format); + if (colorAttachment.view || isDefaultFramebuffer) { + this.renderPassDescriptor.colorAttachments.push(colorAttachment); + } + } + this.initialized = true; + } + initDepthStencil(wgpu, renderTarget) { + const { + samples, + width, + height, + depth, + depthBuffer + } = renderTarget; + if (depth || depthBuffer) { + if (!depthBuffer) { + this.setDepthFormat("depth24plus-stencil8"); + const depthTextureDesc = { + size: [width, height, 1], + dimension: "2d", + sampleCount: samples, + format: this.depthFormat, + usage: GPUTextureUsage.RENDER_ATTACHMENT + }; + if (samples > 1) { + depthTextureDesc.usage |= GPUTextureUsage.TEXTURE_BINDING; + } else { + depthTextureDesc.usage |= GPUTextureUsage.COPY_SRC; + } + this.depthTexture = wgpu.createTexture(depthTextureDesc); + this.depthTextureInternal = true; + } else { + this.depthTexture = depthBuffer.impl.gpuTexture; + this.setDepthFormat(depthBuffer.impl.format); + } + this.renderPassDescriptor.depthStencilAttachment = { + view: this.depthTexture.createView() + }; + } + } + initColor(wgpu, renderTarget, index) { + const colorAttachment = {}; + const { + samples, + width, + height + } = renderTarget; + const colorBuffer = renderTarget.getColorBuffer(index); + let colorView = null; + if (colorBuffer) { + const mipLevelCount = 1; + if (colorBuffer.cubemap) { + colorView = colorBuffer.impl.createView({ + dimension: "2d", + baseArrayLayer: renderTarget.face, + arrayLayerCount: 1, + mipLevelCount + }); + } else { + colorView = colorBuffer.impl.createView({ + mipLevelCount + }); + } + } + if (samples > 1) { + var _this$colorAttachment2, _this$colorAttachment3; + const multisampledTextureDesc = { + size: [width, height, 1], + dimension: "2d", + sampleCount: samples, + format: (_this$colorAttachment2 = (_this$colorAttachment3 = this.colorAttachments[index]) == null ? void 0 : _this$colorAttachment3.format) != null ? _this$colorAttachment2 : colorBuffer.impl.format, + usage: GPUTextureUsage.RENDER_ATTACHMENT + }; + const multisampledColorBuffer = wgpu.createTexture(multisampledTextureDesc); + this.setColorAttachment(index, multisampledColorBuffer, multisampledTextureDesc.format); + colorAttachment.view = multisampledColorBuffer.createView(); + colorAttachment.resolveTarget = colorView; + } else { + colorAttachment.view = colorView; + } + return colorAttachment; + } + setupForRenderPass(renderPass) { + var _this$renderPassDescr, _this$renderPassDescr2; + const count = (_this$renderPassDescr = (_this$renderPassDescr2 = this.renderPassDescriptor.colorAttachments) == null ? void 0 : _this$renderPassDescr2.length) != null ? _this$renderPassDescr : 0; + for (let i = 0; i < count; ++i) { + const colorAttachment = this.renderPassDescriptor.colorAttachments[i]; + const colorOps = renderPass.colorArrayOps[i]; + colorAttachment.clearValue = colorOps.clearValue; + colorAttachment.loadOp = colorOps.clear ? "clear" : "load"; + colorAttachment.storeOp = colorOps.store ? "store" : "discard"; + } + const depthAttachment = this.renderPassDescriptor.depthStencilAttachment; + if (depthAttachment) { + depthAttachment.depthClearValue = renderPass.depthStencilOps.clearDepthValue; + depthAttachment.depthLoadOp = renderPass.depthStencilOps.clearDepth ? "clear" : "load"; + depthAttachment.depthStoreOp = renderPass.depthStencilOps.storeDepth ? "store" : "discard"; + depthAttachment.depthReadOnly = false; + if (this.hasStencil) { + depthAttachment.stencilClearValue = renderPass.depthStencilOps.clearStencilValue; + depthAttachment.stencilLoadOp = renderPass.depthStencilOps.clearStencil ? "clear" : "load"; + depthAttachment.stencilStoreOp = renderPass.depthStencilOps.storeStencil ? "store" : "discard"; + depthAttachment.stencilReadOnly = false; + } + } + } + loseContext() { + this.initialized = false; + } + resolve(device, target2, color, depth) { + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/uniform-buffer-format.js +var uniformTypeToNumComponents = []; +uniformTypeToNumComponents[UNIFORMTYPE_FLOAT] = 1; +uniformTypeToNumComponents[UNIFORMTYPE_VEC2] = 2; +uniformTypeToNumComponents[UNIFORMTYPE_VEC3] = 3; +uniformTypeToNumComponents[UNIFORMTYPE_VEC4] = 4; +uniformTypeToNumComponents[UNIFORMTYPE_INT] = 1; +uniformTypeToNumComponents[UNIFORMTYPE_IVEC2] = 2; +uniformTypeToNumComponents[UNIFORMTYPE_IVEC3] = 3; +uniformTypeToNumComponents[UNIFORMTYPE_IVEC4] = 4; +uniformTypeToNumComponents[UNIFORMTYPE_BOOL] = 1; +uniformTypeToNumComponents[UNIFORMTYPE_BVEC2] = 2; +uniformTypeToNumComponents[UNIFORMTYPE_BVEC3] = 3; +uniformTypeToNumComponents[UNIFORMTYPE_BVEC4] = 4; +uniformTypeToNumComponents[UNIFORMTYPE_MAT2] = 8; +uniformTypeToNumComponents[UNIFORMTYPE_MAT3] = 12; +uniformTypeToNumComponents[UNIFORMTYPE_MAT4] = 16; +uniformTypeToNumComponents[UNIFORMTYPE_UINT] = 1; +uniformTypeToNumComponents[UNIFORMTYPE_UVEC2] = 2; +uniformTypeToNumComponents[UNIFORMTYPE_UVEC3] = 3; +uniformTypeToNumComponents[UNIFORMTYPE_UVEC4] = 4; +var UniformFormat = class { + get isArrayType() { + return this.count > 0; + } + constructor(name, type2, count = 0) { + this.name = void 0; + this.type = void 0; + this.byteSize = void 0; + this.offset = void 0; + this.scopeId = void 0; + this.count = void 0; + this.numComponents = void 0; + this.shortName = name; + this.name = count ? `${name}[0]` : name; + this.type = type2; + this.numComponents = uniformTypeToNumComponents[type2]; + this.updateType = type2; + if (count > 0) { + switch (type2) { + case UNIFORMTYPE_FLOAT: + this.updateType = UNIFORMTYPE_FLOATARRAY; + break; + case UNIFORMTYPE_INT: + this.updateType = UNIFORMTYPE_INTARRAY; + break; + case UNIFORMTYPE_UINT: + this.updateType = UNIFORMTYPE_UINTARRAY; + break; + case UNIFORMTYPE_BOOL: + this.updateType = UNIFORMTYPE_BOOLARRAY; + break; + case UNIFORMTYPE_VEC2: + this.updateType = UNIFORMTYPE_VEC2ARRAY; + break; + case UNIFORMTYPE_IVEC2: + this.updateType = UNIFORMTYPE_IVEC2ARRAY; + break; + case UNIFORMTYPE_UVEC2: + this.updateType = UNIFORMTYPE_UVEC2ARRAY; + break; + case UNIFORMTYPE_BVEC2: + this.updateType = UNIFORMTYPE_BVEC2ARRAY; + break; + case UNIFORMTYPE_VEC3: + this.updateType = UNIFORMTYPE_VEC3ARRAY; + break; + case UNIFORMTYPE_IVEC3: + this.updateType = UNIFORMTYPE_IVEC3ARRAY; + break; + case UNIFORMTYPE_UVEC3: + this.updateType = UNIFORMTYPE_UVEC3ARRAY; + break; + case UNIFORMTYPE_BVEC3: + this.updateType = UNIFORMTYPE_BVEC3ARRAY; + break; + case UNIFORMTYPE_VEC4: + this.updateType = UNIFORMTYPE_VEC4ARRAY; + break; + case UNIFORMTYPE_IVEC4: + this.updateType = UNIFORMTYPE_IVEC4ARRAY; + break; + case UNIFORMTYPE_UVEC4: + this.updateType = UNIFORMTYPE_UVEC4ARRAY; + break; + case UNIFORMTYPE_BVEC4: + this.updateType = UNIFORMTYPE_BVEC4ARRAY; + break; + case UNIFORMTYPE_MAT4: + this.updateType = UNIFORMTYPE_MAT4ARRAY; + break; + } + } + this.count = count; + let componentSize = this.numComponents; + if (count) { + componentSize = math.roundUp(componentSize, 4); + } + this.byteSize = componentSize * 4; + if (count) this.byteSize *= count; + } + calculateOffset(offset) { + let alignment = this.byteSize <= 8 ? this.byteSize : 16; + if (this.count) alignment = 16; + offset = math.roundUp(offset, alignment); + this.offset = offset / 4; + } +}; +var UniformBufferFormat = class { + constructor(graphicsDevice, uniforms) { + this.byteSize = 0; + this.map = /* @__PURE__ */ new Map(); + this.scope = graphicsDevice.scope; + this.uniforms = uniforms; + let offset = 0; + for (let i = 0; i < uniforms.length; i++) { + const uniform = uniforms[i]; + uniform.calculateOffset(offset); + offset = uniform.offset * 4 + uniform.byteSize; + uniform.scopeId = this.scope.resolve(uniform.name); + this.map.set(uniform.name, uniform); + } + this.byteSize = math.roundUp(offset, 16); + } + get(name) { + return this.map.get(name); + } + getShaderDeclaration(bindGroup, bindIndex) { + const name = bindGroupNames[bindGroup]; + let code = `layout(set = ${bindGroup}, binding = ${bindIndex}, std140) uniform ub_${name} { +`; + this.uniforms.forEach((uniform) => { + const typeString = uniformTypeToName[uniform.type]; + code += ` ${typeString} ${uniform.shortName}${uniform.count ? `[${uniform.count}]` : ""}; +`; + }); + return code + "};\n"; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/bind-group-format.js +var id3 = 0; +var textureDimensionInfo = { + [TEXTUREDIMENSION_2D]: "texture2D", + [TEXTUREDIMENSION_CUBE]: "textureCube", + [TEXTUREDIMENSION_3D]: "texture3D", + [TEXTUREDIMENSION_2D_ARRAY]: "texture2DArray" +}; +var BindBaseFormat = class { + constructor(name, visibility) { + this.slot = -1; + this.scopeId = null; + this.name = name; + this.visibility = visibility; + } +}; +var BindUniformBufferFormat = class extends BindBaseFormat { +}; +var BindStorageBufferFormat = class extends BindBaseFormat { + constructor(name, visibility, readOnly = false) { + super(name, visibility); + this.readOnly = readOnly; + } +}; +var BindTextureFormat = class extends BindBaseFormat { + constructor(name, visibility, textureDimension = TEXTUREDIMENSION_2D, sampleType = SAMPLETYPE_FLOAT, hasSampler = true) { + super(name, visibility); + this.textureDimension = textureDimension; + this.sampleType = sampleType; + this.hasSampler = hasSampler; + } +}; +var BindStorageTextureFormat = class extends BindBaseFormat { + constructor(name, format = PIXELFORMAT_RGBA8, textureDimension = TEXTUREDIMENSION_2D, write = true, read = false) { + super(name, SHADERSTAGE_COMPUTE); + this.format = format; + this.textureDimension = textureDimension; + this.write = write; + this.read = read; + } +}; +var BindGroupFormat = class { + constructor(graphicsDevice, formats) { + this.uniformBufferFormats = []; + this.textureFormats = []; + this.storageTextureFormats = []; + this.storageBufferFormats = []; + this.id = id3++; + let slot = 0; + formats.forEach((format) => { + format.slot = slot++; + if (format instanceof BindTextureFormat && format.hasSampler) { + slot++; + } + if (format instanceof BindUniformBufferFormat) { + this.uniformBufferFormats.push(format); + } else if (format instanceof BindTextureFormat) { + this.textureFormats.push(format); + } else if (format instanceof BindStorageTextureFormat) { + this.storageTextureFormats.push(format); + } else if (format instanceof BindStorageBufferFormat) { + this.storageBufferFormats.push(format); + } else ; + }); + this.device = graphicsDevice; + const scope = graphicsDevice.scope; + this.bufferFormatsMap = /* @__PURE__ */ new Map(); + this.uniformBufferFormats.forEach((bf, i) => this.bufferFormatsMap.set(bf.name, i)); + this.textureFormatsMap = /* @__PURE__ */ new Map(); + this.textureFormats.forEach((tf, i) => { + this.textureFormatsMap.set(tf.name, i); + tf.scopeId = scope.resolve(tf.name); + }); + this.storageTextureFormatsMap = /* @__PURE__ */ new Map(); + this.storageTextureFormats.forEach((tf, i) => { + this.storageTextureFormatsMap.set(tf.name, i); + tf.scopeId = scope.resolve(tf.name); + }); + this.storageBufferFormatsMap = /* @__PURE__ */ new Map(); + this.storageBufferFormats.forEach((bf, i) => { + this.storageBufferFormatsMap.set(bf.name, i); + bf.scopeId = scope.resolve(bf.name); + }); + this.impl = graphicsDevice.createBindGroupFormatImpl(this); + } + destroy() { + this.impl.destroy(); + } + getTexture(name) { + const index = this.textureFormatsMap.get(name); + if (index !== void 0) { + return this.textureFormats[index]; + } + return null; + } + getStorageTexture(name) { + const index = this.storageTextureFormatsMap.get(name); + if (index !== void 0) { + return this.storageTextureFormats[index]; + } + return null; + } + getShaderDeclarationTextures(bindGroup) { + let code = ""; + this.textureFormats.forEach((format) => { + let textureType = textureDimensionInfo[format.textureDimension]; + let namePostfix = ""; + let extraCode = ""; + if (textureType === "texture2DArray") { + namePostfix = "_texture"; + extraCode = `#define ${format.name} sampler2DArray(${format.name}${namePostfix}, ${format.name}_sampler) +`; + } + if (format.sampleType === SAMPLETYPE_INT) { + textureType = `i${textureType}`; + } else if (format.sampleType === SAMPLETYPE_UINT) { + textureType = `u${textureType}`; + } + code += `layout(set = ${bindGroup}, binding = ${format.slot}) uniform ${textureType} ${format.name}${namePostfix}; +`; + if (format.hasSampler) { + code += `layout(set = ${bindGroup}, binding = ${format.slot + 1}) uniform sampler ${format.name}_sampler; +`; + } + code += extraCode; + }); + return code; + } + loseContext() { + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/shader-processor.js +var KEYWORD = /[ \t]*(\battribute\b|\bvarying\b|\buniform\b)/g; +var KEYWORD_LINE = /(\battribute\b|\bvarying\b|\bout\b|\buniform\b)[ \t]*([^;]+)([;]+)/g; +var MARKER = "@@@"; +var ARRAY_IDENTIFIER = /([\w-]+)\[(.*?)\]/; +var precisionQualifiers = /* @__PURE__ */ new Set(["highp", "mediump", "lowp"]); +var shadowSamplers = /* @__PURE__ */ new Set(["sampler2DShadow", "samplerCubeShadow", "sampler2DArrayShadow"]); +var textureDimensions = { + sampler2D: TEXTUREDIMENSION_2D, + sampler3D: TEXTUREDIMENSION_3D, + samplerCube: TEXTUREDIMENSION_CUBE, + samplerCubeShadow: TEXTUREDIMENSION_CUBE, + sampler2DShadow: TEXTUREDIMENSION_2D, + sampler2DArray: TEXTUREDIMENSION_2D_ARRAY, + sampler2DArrayShadow: TEXTUREDIMENSION_2D_ARRAY, + isampler2D: TEXTUREDIMENSION_2D, + usampler2D: TEXTUREDIMENSION_2D, + isampler3D: TEXTUREDIMENSION_3D, + usampler3D: TEXTUREDIMENSION_3D, + isamplerCube: TEXTUREDIMENSION_CUBE, + usamplerCube: TEXTUREDIMENSION_CUBE, + isampler2DArray: TEXTUREDIMENSION_2D_ARRAY, + usampler2DArray: TEXTUREDIMENSION_2D_ARRAY +}; +var UniformLine = class { + constructor(line, shader) { + this.line = line; + const words = line.trim().split(/\s+/); + if (precisionQualifiers.has(words[0])) { + this.precision = words.shift(); + } + this.type = words.shift(); + if (line.includes(",")) ; + if (line.includes("[")) { + const rest = words.join(" "); + const match = ARRAY_IDENTIFIER.exec(rest); + this.name = match[1]; + this.arraySize = Number(match[2]); + if (isNaN(this.arraySize)) { + shader.failed = true; + } + } else { + this.name = words.shift(); + this.arraySize = 0; + } + this.isSampler = this.type.indexOf("sampler") !== -1; + this.isSignedInt = this.type.indexOf("isampler") !== -1; + this.isUnsignedInt = this.type.indexOf("usampler") !== -1; + } +}; +var ShaderProcessor = class _ShaderProcessor { + static run(device, shaderDefinition, shader) { + const varyingMap = /* @__PURE__ */ new Map(); + const vertexExtracted = _ShaderProcessor.extract(shaderDefinition.vshader); + const fragmentExtracted = _ShaderProcessor.extract(shaderDefinition.fshader); + const attributesBlock = _ShaderProcessor.processAttributes(vertexExtracted.attributes, shaderDefinition.attributes, shaderDefinition.processingOptions); + const vertexVaryingsBlock = _ShaderProcessor.processVaryings(vertexExtracted.varyings, varyingMap, true); + const fragmentVaryingsBlock = _ShaderProcessor.processVaryings(fragmentExtracted.varyings, varyingMap, false); + const outBlock = _ShaderProcessor.processOuts(fragmentExtracted.outs); + const concatUniforms = vertexExtracted.uniforms.concat(fragmentExtracted.uniforms); + const uniforms = Array.from(new Set(concatUniforms)); + const parsedUniforms = uniforms.map((line) => new UniformLine(line, shader)); + const uniformsData = _ShaderProcessor.processUniforms(device, parsedUniforms, shaderDefinition.processingOptions, shader); + const vBlock = attributesBlock + "\n" + vertexVaryingsBlock + "\n" + uniformsData.code; + const vshader = vertexExtracted.src.replace(MARKER, vBlock); + const fBlock = fragmentVaryingsBlock + "\n" + outBlock + "\n" + uniformsData.code; + const fshader = fragmentExtracted.src.replace(MARKER, fBlock); + return { + vshader, + fshader, + meshUniformBufferFormat: uniformsData.meshUniformBufferFormat, + meshBindGroupFormat: uniformsData.meshBindGroupFormat + }; + } + static extract(src) { + const attributes = []; + const varyings = []; + const outs = []; + const uniforms = []; + let replacement = `${MARKER} +`; + let match; + while ((match = KEYWORD.exec(src)) !== null) { + const keyword = match[1]; + switch (keyword) { + case "attribute": + case "varying": + case "uniform": + case "out": { + KEYWORD_LINE.lastIndex = match.index; + const lineMatch = KEYWORD_LINE.exec(src); + if (keyword === "attribute") { + attributes.push(lineMatch[2]); + } else if (keyword === "varying") { + varyings.push(lineMatch[2]); + } else if (keyword === "out") { + outs.push(lineMatch[2]); + } else if (keyword === "uniform") { + uniforms.push(lineMatch[2]); + } + src = _ShaderProcessor.cutOut(src, match.index, KEYWORD_LINE.lastIndex, replacement); + KEYWORD.lastIndex = match.index + replacement.length; + replacement = ""; + break; + } + } + } + return { + src, + attributes, + varyings, + outs, + uniforms + }; + } + static processUniforms(device, uniforms, processingOptions, shader) { + const uniformLinesSamplers = []; + const uniformLinesNonSamplers = []; + uniforms.forEach((uniform) => { + if (uniform.isSampler) { + uniformLinesSamplers.push(uniform); + } else { + uniformLinesNonSamplers.push(uniform); + } + }); + const meshUniforms = []; + uniformLinesNonSamplers.forEach((uniform) => { + if (!processingOptions.hasUniform(uniform.name)) { + const uniformType = uniformTypeToName.indexOf(uniform.type); + const uniformFormat = new UniformFormat(uniform.name, uniformType, uniform.arraySize); + meshUniforms.push(uniformFormat); + } + }); + const meshUniformBufferFormat = meshUniforms.length ? new UniformBufferFormat(device, meshUniforms) : null; + const uniformBufferFormats = []; + if (meshUniformBufferFormat) { + uniformBufferFormats.push(new BindUniformBufferFormat(UNIFORM_BUFFER_DEFAULT_SLOT_NAME, SHADERSTAGE_VERTEX | SHADERSTAGE_FRAGMENT)); + } + const textureFormats = []; + uniformLinesSamplers.forEach((uniform) => { + if (!processingOptions.hasTexture(uniform.name)) { + let sampleType = SAMPLETYPE_FLOAT; + if (uniform.isSignedInt) { + sampleType = SAMPLETYPE_INT; + } else if (uniform.isUnsignedInt) { + sampleType = SAMPLETYPE_UINT; + } else { + if (uniform.precision === "highp") sampleType = SAMPLETYPE_UNFILTERABLE_FLOAT; + if (shadowSamplers.has(uniform.type)) sampleType = SAMPLETYPE_DEPTH; + } + const dimension = textureDimensions[uniform.type]; + textureFormats.push(new BindTextureFormat(uniform.name, SHADERSTAGE_VERTEX | SHADERSTAGE_FRAGMENT, dimension, sampleType)); + } + }); + const meshBindGroupFormat = new BindGroupFormat(device, [...uniformBufferFormats, ...textureFormats]); + let code = ""; + processingOptions.uniformFormats.forEach((format, bindGroupIndex) => { + if (format) { + code += format.getShaderDeclaration(bindGroupIndex, 0); + } + }); + if (meshUniformBufferFormat) { + code += meshUniformBufferFormat.getShaderDeclaration(BINDGROUP_MESH, 0); + } + processingOptions.bindGroupFormats.forEach((format, bindGroupIndex) => { + if (format) { + code += format.getShaderDeclarationTextures(bindGroupIndex); + } + }); + code += meshBindGroupFormat.getShaderDeclarationTextures(BINDGROUP_MESH); + return { + code, + meshUniformBufferFormat, + meshBindGroupFormat + }; + } + static processVaryings(varyingLines, varyingMap, isVertex) { + let block = ""; + const op = isVertex ? "out" : "in"; + varyingLines.forEach((line, index) => { + const words = _ShaderProcessor.splitToWords(line); + const type2 = words[0]; + const name = words[1]; + if (isVertex) { + varyingMap.set(name, index); + } else { + index = varyingMap.get(name); + } + block += `layout(location = ${index}) ${op} ${type2} ${name}; +`; + }); + return block; + } + static processOuts(outsLines) { + let block = ""; + outsLines.forEach((line, index) => { + block += `layout(location = ${index}) out ${line}; +`; + }); + return block; + } + static getTypeCount(type2) { + const lastChar = type2.substring(type2.length - 1); + const num = parseInt(lastChar, 10); + return isNaN(num) ? 1 : num; + } + static processAttributes(attributeLines, shaderDefinitionAttributes, processingOptions) { + let block = ""; + attributeLines.forEach((line) => { + const words = _ShaderProcessor.splitToWords(line); + let type2 = words[0]; + let name = words[1]; + if (shaderDefinitionAttributes.hasOwnProperty(name)) { + const semantic = shaderDefinitionAttributes[name]; + const location = semanticToLocation[semantic]; + let copyCode; + const element = processingOptions.getVertexElement(semantic); + if (element) { + const dataType = element.dataType; + if (dataType !== TYPE_FLOAT32 && dataType !== TYPE_FLOAT16 && !element.normalize && !element.asInt) { + const attribNumElements = _ShaderProcessor.getTypeCount(type2); + const newName = `_private_${name}`; + copyCode = `vec${attribNumElements} ${name} = vec${attribNumElements}(${newName}); +`; + name = newName; + const isSignedType = dataType === TYPE_INT8 || dataType === TYPE_INT16 || dataType === TYPE_INT32; + if (attribNumElements === 1) { + type2 = isSignedType ? "int" : "uint"; + } else { + type2 = isSignedType ? `ivec${attribNumElements}` : `uvec${attribNumElements}`; + } + } + } + block += `layout(location = ${location}) in ${type2} ${name}; +`; + if (copyCode) { + block += copyCode; + } + } + }); + return block; + } + static splitToWords(line) { + line = line.replace(/\s+/g, " ").trim(); + return line.split(" "); + } + static cutOut(src, start, end, replacement) { + return src.substring(0, start) + replacement + src.substring(end); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-shader.js +var WebgpuShader = class { + constructor(shader) { + this._vertexCode = null; + this._fragmentCode = null; + this._computeCode = null; + this.vertexEntryPoint = "main"; + this.fragmentEntryPoint = "main"; + this.computeEntryPoint = "main"; + this.shader = shader; + const definition = shader.definition; + if (definition.shaderLanguage === SHADERLANGUAGE_WGSL) { + var _definition$vshader, _definition$fshader, _definition$cshader; + this._vertexCode = (_definition$vshader = definition.vshader) != null ? _definition$vshader : null; + this._fragmentCode = (_definition$fshader = definition.fshader) != null ? _definition$fshader : null; + this._computeCode = (_definition$cshader = definition.cshader) != null ? _definition$cshader : null; + this.meshUniformBufferFormat = definition.meshUniformBufferFormat; + this.meshBindGroupFormat = definition.meshBindGroupFormat; + this.computeUniformBufferFormats = definition.computeUniformBufferFormats; + this.computeBindGroupFormat = definition.computeBindGroupFormat; + this.vertexEntryPoint = "vertexMain"; + this.fragmentEntryPoint = "fragmentMain"; + shader.ready = true; + } else { + if (definition.processingOptions) { + this.process(); + } + } + } + destroy(shader) { + this._vertexCode = null; + this._fragmentCode = null; + } + createShaderModule(code, shaderType) { + const device = this.shader.device; + const wgpu = device.wgpu; + const shaderModule = wgpu.createShaderModule({ + code + }); + return shaderModule; + } + getVertexShaderModule() { + return this.createShaderModule(this._vertexCode, "Vertex"); + } + getFragmentShaderModule() { + return this.createShaderModule(this._fragmentCode, "Fragment"); + } + getComputeShaderModule() { + return this.createShaderModule(this._computeCode, "Compute"); + } + process() { + const shader = this.shader; + const processed = ShaderProcessor.run(shader.device, shader.definition, shader); + this._vertexCode = this.transpile(processed.vshader, "vertex", shader.definition.vshader); + this._fragmentCode = this.transpile(processed.fshader, "fragment", shader.definition.fshader); + if (!(this._vertexCode && this._fragmentCode)) { + shader.failed = true; + } else { + shader.ready = true; + } + shader.meshUniformBufferFormat = processed.meshUniformBufferFormat; + shader.meshBindGroupFormat = processed.meshBindGroupFormat; + } + transpile(src, shaderType, originalSrc) { + try { + const spirv = this.shader.device.glslang.compileGLSL(src, shaderType); + return this.shader.device.twgsl.convertSpirV2WGSL(spirv); + } catch (err) { + console.error(`Failed to transpile webgl ${shaderType} shader [${this.shader.label}] to WebGPU: [${err.message}] while rendering ${void 0}`, { + processed: src, + original: originalSrc, + shader: this.shader + }); + } + } + get vertexCode() { + return this._vertexCode; + } + get fragmentCode() { + return this._fragmentCode; + } + loseContext() { + } + restoreContext(device, shader) { + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/texture-utils.js +var TextureUtils = class _TextureUtils { + static calcLevelDimension(dimension, mipLevel) { + return Math.max(dimension >> mipLevel, 1); + } + static calcMipLevelsCount(width, height, depth = 1) { + return 1 + Math.floor(Math.log2(Math.max(width, height, depth))); + } + static calcLevelGpuSize(width, height, depth, format) { + var _pixelFormatInfo$get$, _pixelFormatInfo$get, _formatInfo$blockSize; + const formatInfo = pixelFormatInfo.get(format); + const pixelSize = (_pixelFormatInfo$get$ = (_pixelFormatInfo$get = pixelFormatInfo.get(format)) == null ? void 0 : _pixelFormatInfo$get.size) != null ? _pixelFormatInfo$get$ : 0; + if (pixelSize > 0) { + return width * height * depth * pixelSize; + } + const blockSize = (_formatInfo$blockSize = formatInfo.blockSize) != null ? _formatInfo$blockSize : 0; + let blockWidth = Math.floor((width + 3) / 4); + const blockHeight = Math.floor((height + 3) / 4); + const blockDepth = Math.floor((depth + 3) / 4); + if (format === PIXELFORMAT_PVRTC_2BPP_RGB_1 || format === PIXELFORMAT_PVRTC_2BPP_RGBA_1) { + blockWidth = Math.max(Math.floor(blockWidth / 2), 1); + } + return blockWidth * blockHeight * blockDepth * blockSize; + } + static calcGpuSize(width, height, depth, format, mipmaps, cubemap) { + let result = 0; + while (1) { + result += _TextureUtils.calcLevelGpuSize(width, height, depth, format); + if (!mipmaps || width === 1 && height === 1 && depth === 1) { + break; + } + width = Math.max(width >> 1, 1); + height = Math.max(height >> 1, 1); + depth = Math.max(depth >> 1, 1); + } + return result * (cubemap ? 6 : 1); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-texture.js +var gpuAddressModes = []; +gpuAddressModes[ADDRESS_REPEAT] = "repeat"; +gpuAddressModes[ADDRESS_CLAMP_TO_EDGE] = "clamp-to-edge"; +gpuAddressModes[ADDRESS_MIRRORED_REPEAT] = "mirror-repeat"; +var gpuFilterModes = []; +gpuFilterModes[FILTER_NEAREST] = { + level: "nearest", + mip: "nearest" +}; +gpuFilterModes[FILTER_LINEAR] = { + level: "linear", + mip: "nearest" +}; +gpuFilterModes[FILTER_NEAREST_MIPMAP_NEAREST] = { + level: "nearest", + mip: "nearest" +}; +gpuFilterModes[FILTER_NEAREST_MIPMAP_LINEAR] = { + level: "nearest", + mip: "linear" +}; +gpuFilterModes[FILTER_LINEAR_MIPMAP_NEAREST] = { + level: "linear", + mip: "nearest" +}; +gpuFilterModes[FILTER_LINEAR_MIPMAP_LINEAR] = { + level: "linear", + mip: "linear" +}; +var dummyUse = (thingOne) => { +}; +var WebgpuTexture = class { + constructor(texture) { + this.gpuTexture = void 0; + this.view = void 0; + this.samplers = []; + this.descr = void 0; + this.format = void 0; + this.texture = texture; + this.format = gpuTextureFormats[texture.format]; + this.create(texture.device); + } + create(device) { + const texture = this.texture; + const wgpu = device.wgpu; + const mipLevelCount = texture.requiredMipLevels; + this.descr = { + size: { + width: texture.width, + height: texture.height, + depthOrArrayLayers: texture.cubemap ? 6 : texture.array ? texture.arrayLength : 1 + }, + format: this.format, + mipLevelCount, + sampleCount: 1, + dimension: texture.volume ? "3d" : "2d", + usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | (isCompressedPixelFormat(texture.format) ? 0 : GPUTextureUsage.RENDER_ATTACHMENT) | (texture.storage ? GPUTextureUsage.STORAGE_BINDING : 0) + }; + this.gpuTexture = wgpu.createTexture(this.descr); + let viewDescr; + if (this.texture.format === PIXELFORMAT_DEPTHSTENCIL) { + viewDescr = { + format: "depth24plus", + aspect: "depth-only" + }; + } + this.view = this.createView(viewDescr); + } + destroy(device) { + } + propertyChanged(flag) { + this.samplers.length = 0; + } + getView(device) { + this.uploadImmediate(device, this.texture); + return this.view; + } + createView(viewDescr) { + var _options$format, _options$dimension, _options$aspect, _options$baseMipLevel, _options$mipLevelCoun, _options$baseArrayLay, _options$arrayLayerCo; + const options = viewDescr != null ? viewDescr : {}; + const textureDescr = this.descr; + const texture = this.texture; + const defaultViewDimension = () => { + if (texture.cubemap) return "cube"; + if (texture.volume) return "3d"; + if (texture.array) return "2d-array"; + return "2d"; + }; + const descr = { + format: (_options$format = options.format) != null ? _options$format : textureDescr.format, + dimension: (_options$dimension = options.dimension) != null ? _options$dimension : defaultViewDimension(), + aspect: (_options$aspect = options.aspect) != null ? _options$aspect : "all", + baseMipLevel: (_options$baseMipLevel = options.baseMipLevel) != null ? _options$baseMipLevel : 0, + mipLevelCount: (_options$mipLevelCoun = options.mipLevelCount) != null ? _options$mipLevelCoun : textureDescr.mipLevelCount, + baseArrayLayer: (_options$baseArrayLay = options.baseArrayLayer) != null ? _options$baseArrayLay : 0, + arrayLayerCount: (_options$arrayLayerCo = options.arrayLayerCount) != null ? _options$arrayLayerCo : textureDescr.depthOrArrayLayers + }; + const view = this.gpuTexture.createView(descr); + return view; + } + getSampler(device, sampleType) { + let sampler = this.samplers[sampleType]; + if (!sampler) { + const texture = this.texture; + const descr = { + addressModeU: gpuAddressModes[texture.addressU], + addressModeV: gpuAddressModes[texture.addressV], + addressModeW: gpuAddressModes[texture.addressW] + }; + if (!sampleType && texture.compareOnRead) { + sampleType = SAMPLETYPE_DEPTH; + } + if (sampleType === SAMPLETYPE_DEPTH || sampleType === SAMPLETYPE_INT || sampleType === SAMPLETYPE_UINT) { + descr.compare = "less"; + descr.magFilter = "linear"; + descr.minFilter = "linear"; + } else if (sampleType === SAMPLETYPE_UNFILTERABLE_FLOAT) { + descr.magFilter = "nearest"; + descr.minFilter = "nearest"; + descr.mipmapFilter = "nearest"; + } else { + const forceNearest = !device.textureFloatFilterable && (texture.format === PIXELFORMAT_RGBA32F || texture.format === PIXELFORMAT_RGBA16F); + if (forceNearest || this.texture.format === PIXELFORMAT_DEPTHSTENCIL || isIntegerPixelFormat(this.texture.format)) { + descr.magFilter = "nearest"; + descr.minFilter = "nearest"; + descr.mipmapFilter = "nearest"; + } else { + descr.magFilter = gpuFilterModes[texture.magFilter].level; + descr.minFilter = gpuFilterModes[texture.minFilter].level; + descr.mipmapFilter = gpuFilterModes[texture.minFilter].mip; + } + } + const allLinear = descr.minFilter === "linear" && descr.magFilter === "linear" && descr.mipmapFilter === "linear"; + descr.maxAnisotropy = allLinear ? math.clamp(Math.round(texture._anisotropy), 1, device.maxTextureAnisotropy) : 1; + sampler = device.wgpu.createSampler(descr); + this.samplers[sampleType] = sampler; + } + return sampler; + } + loseContext() { + } + uploadImmediate(device, texture) { + if (texture._needsUpload || texture._needsMipmapsUpload) { + this.uploadData(device); + texture._needsUpload = false; + texture._needsMipmapsUpload = false; + } + } + uploadData(device) { + const texture = this.texture; + if (texture._levels) { + let anyUploads = false; + let anyLevelMissing = false; + const requiredMipLevels = texture.requiredMipLevels; + for (let mipLevel = 0; mipLevel < requiredMipLevels; mipLevel++) { + const mipObject = texture._levels[mipLevel]; + if (mipObject) { + if (texture.cubemap) { + for (let face = 0; face < 6; face++) { + const faceSource = mipObject[face]; + if (faceSource) { + if (this.isExternalImage(faceSource)) { + this.uploadExternalImage(device, faceSource, mipLevel, face); + anyUploads = true; + } else if (ArrayBuffer.isView(faceSource)) { + this.uploadTypedArrayData(device, faceSource, mipLevel, face); + anyUploads = true; + } else ; + } else { + anyLevelMissing = true; + } + } + } else if (texture._volume) ; + else if (texture.array) { + if (texture.arrayLength === mipObject.length) { + for (let index = 0; index < texture._arrayLength; index++) { + const arraySource = mipObject[index]; + if (this.isExternalImage(arraySource)) { + this.uploadExternalImage(device, arraySource, mipLevel, index); + anyUploads = true; + } else if (ArrayBuffer.isView(arraySource)) { + this.uploadTypedArrayData(device, arraySource, mipLevel, index); + anyUploads = true; + } else ; + } + } else { + anyLevelMissing = true; + } + } else { + if (this.isExternalImage(mipObject)) { + this.uploadExternalImage(device, mipObject, mipLevel, 0); + anyUploads = true; + } else if (ArrayBuffer.isView(mipObject)) { + this.uploadTypedArrayData(device, mipObject, mipLevel, 0); + anyUploads = true; + } else ; + } + } else { + anyLevelMissing = true; + } + } + if (anyUploads && anyLevelMissing && texture.mipmaps && !isCompressedPixelFormat(texture.format)) { + device.mipmapRenderer.generate(this); + } + if (texture._gpuSize) { + texture.adjustVramSizeTracking(device._vram, -texture._gpuSize); + } + texture._gpuSize = texture.gpuSize; + texture.adjustVramSizeTracking(device._vram, texture._gpuSize); + } + } + isExternalImage(image) { + return image instanceof ImageBitmap || image instanceof HTMLVideoElement || image instanceof HTMLCanvasElement || image instanceof OffscreenCanvas; + } + uploadExternalImage(device, image, mipLevel, index) { + const src = { + source: image, + origin: [0, 0], + flipY: false + }; + const dst = { + texture: this.gpuTexture, + mipLevel, + origin: [0, 0, index], + aspect: "all" + }; + const copySize = { + width: this.descr.size.width, + height: this.descr.size.height, + depthOrArrayLayers: 1 + }; + device.submit(); + dummyUse(image instanceof HTMLCanvasElement && image.getContext("2d")); + device.wgpu.queue.copyExternalImageToTexture(src, dst, copySize); + } + uploadTypedArrayData(device, data2, mipLevel, index) { + const texture = this.texture; + const wgpu = device.wgpu; + const dest = { + texture: this.gpuTexture, + origin: [0, 0, index], + mipLevel + }; + const width = TextureUtils.calcLevelDimension(texture.width, mipLevel); + const height = TextureUtils.calcLevelDimension(texture.height, mipLevel); + TextureUtils.calcLevelGpuSize(width, height, 1, texture.format); + const formatInfo = pixelFormatInfo.get(texture.format); + let dataLayout; + let size; + if (formatInfo.size) { + dataLayout = { + offset: 0, + bytesPerRow: formatInfo.size * width, + rowsPerImage: height + }; + size = { + width, + height + }; + } else if (formatInfo.blockSize) { + const blockDim = (size2) => { + return Math.floor((size2 + 3) / 4); + }; + dataLayout = { + offset: 0, + bytesPerRow: formatInfo.blockSize * blockDim(width), + rowsPerImage: blockDim(height) + }; + size = { + width: Math.max(4, width), + height: Math.max(4, height) + }; + } else ; + device.submit(); + wgpu.queue.writeTexture(dest, data2, dataLayout, size); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-uniform-buffer.js +var WebgpuUniformBuffer = class extends WebgpuBuffer { + constructor(uniformBuffer) { + super(BUFFERUSAGE_UNIFORM); + } + unlock(uniformBuffer) { + const device = uniformBuffer.device; + super.unlock(device, uniformBuffer.storageInt32.buffer); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-vertex-buffer.js +var WebgpuVertexBuffer = class extends WebgpuBuffer { + constructor(vertexBuffer, format, options) { + super(BUFFERUSAGE_VERTEX | (options != null && options.storage ? BUFFERUSAGE_STORAGE : 0)); + } + unlock(vertexBuffer) { + const device = vertexBuffer.device; + super.unlock(device, vertexBuffer.storage); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/core/preprocessor.js +var KEYWORD2 = /[ \t]*#(ifn?def|if|endif|else|elif|define|undef|extension|include)/g; +var DEFINE = /define[ \t]+([^\n]+)\r?(?:\n|$)/g; +var EXTENSION = /extension[ \t]+([\w-]+)[ \t]*:[ \t]*(enable|require)/g; +var UNDEF = /undef[ \t]+([^\n]+)\r?(?:\n|$)/g; +var IF = /(ifdef|ifndef|if)[ \t]*([^\r\n]+)\r?\n/g; +var ENDIF = /(endif|else|elif)([ \t]+[^\r\n]+)?\r?(?:\n|$)/g; +var IDENTIFIER = /([\w-]+)/; +var DEFINED = /(!|\s)?defined\(([\w-]+)\)/; +var INVALID = /[><=|&+-]/g; +var INCLUDE = /include[ \t]+"([\w-]+)"\r?(?:\n|$)/g; +var Preprocessor = class _Preprocessor { + static run(source, includes = /* @__PURE__ */ new Map(), stripUnusedColorAttachments = false) { + source = source.replace(/\/\*[\s\S]*?\*\/|([^\\:]|^)\/\/.*$/gm, "$1"); + source = source.split(/\r?\n/).map((line) => line.trimEnd()).join("\n"); + const defines = /* @__PURE__ */ new Map(); + if (stripUnusedColorAttachments) { + const counts = /* @__PURE__ */ new Map(); + const regex = /(pcFragColor[1-8])\b/g; + const matches = source.match(regex); + matches == null || matches.forEach((match) => { + var _counts$get; + const index = parseInt(match.charAt(match.length - 1), 10); + counts.set(index, ((_counts$get = counts.get(index)) != null ? _counts$get : 0) + 1); + }); + counts.forEach((count, index) => { + if (count === 1) { + defines.set(`REMOVE_COLOR_ATTACHMENT_${index}`, ""); + } + }); + } + source = this._preprocess(source, defines, includes); + const intDefines = /* @__PURE__ */ new Map(); + defines.forEach((value, key) => { + if (Number.isInteger(parseFloat(value)) && !value.includes(".")) { + intDefines.set(key, value); + } + }); + source = this.RemoveEmptyLines(source); + source = this.processArraySize(source, intDefines); + return source; + } + static processArraySize(source, intDefines) { + if (source !== null) { + intDefines.forEach((value, key) => { + source = source.replace(new RegExp(`\\[${key}\\]`, "g"), `[${value}]`); + }); + } + return source; + } + static RemoveEmptyLines(source) { + if (source !== null) { + source = source.split(/\r?\n/).map((line) => line.trim() === "" ? "" : line).join("\n"); + source = source.replace(/(\n\n){3,}/gm, "\n\n"); + } + return source; + } + static _preprocess(source, defines = /* @__PURE__ */ new Map(), includes) { + const originalSource = source; + const stack = []; + let error = false; + let match; + while ((match = KEYWORD2.exec(source)) !== null) { + const keyword = match[1]; + switch (keyword) { + case "define": { + DEFINE.lastIndex = match.index; + const define = DEFINE.exec(source); + error || (error = define === null); + const expression = define[1]; + IDENTIFIER.lastIndex = define.index; + const identifierValue = IDENTIFIER.exec(expression); + const identifier = identifierValue[1]; + let value = expression.substring(identifier.length).trim(); + if (value === "") value = "true"; + const keep = _Preprocessor._keep(stack); + if (keep) { + defines.set(identifier, value); + } + KEYWORD2.lastIndex = define.index + define[0].length; + break; + } + case "undef": { + UNDEF.lastIndex = match.index; + const undef = UNDEF.exec(source); + const identifier = undef[1].trim(); + const keep = _Preprocessor._keep(stack); + if (keep) { + defines.delete(identifier); + } + KEYWORD2.lastIndex = undef.index + undef[0].length; + break; + } + case "extension": { + EXTENSION.lastIndex = match.index; + const extension = EXTENSION.exec(source); + error || (error = extension === null); + if (extension) { + const identifier = extension[1]; + const keep = _Preprocessor._keep(stack); + if (keep) { + defines.set(identifier, "true"); + } + } + KEYWORD2.lastIndex = extension.index + extension[0].length; + break; + } + case "ifdef": + case "ifndef": + case "if": { + IF.lastIndex = match.index; + const iff = IF.exec(source); + const expression = iff[2]; + const evaluated = _Preprocessor.evaluate(expression, defines); + error || (error = evaluated.error); + let result = evaluated.result; + if (keyword === "ifndef") { + result = !result; + } + stack.push({ + anyKeep: result, + keep: result, + start: match.index, + end: IF.lastIndex + }); + KEYWORD2.lastIndex = iff.index + iff[0].length; + break; + } + case "endif": + case "else": + case "elif": { + ENDIF.lastIndex = match.index; + const endif = ENDIF.exec(source); + const blockInfo = stack.pop(); + const blockCode = blockInfo.keep ? source.substring(blockInfo.end, match.index) : ""; + source = source.substring(0, blockInfo.start) + blockCode + source.substring(ENDIF.lastIndex); + KEYWORD2.lastIndex = blockInfo.start + blockCode.length; + const endifCommand = endif[1]; + if (endifCommand === "else" || endifCommand === "elif") { + let result = false; + if (!blockInfo.anyKeep) { + if (endifCommand === "else") { + result = !blockInfo.keep; + } else { + const evaluated = _Preprocessor.evaluate(endif[2], defines); + result = evaluated.result; + error || (error = evaluated.error); + } + } + stack.push({ + anyKeep: blockInfo.anyKeep || result, + keep: result, + start: KEYWORD2.lastIndex, + end: KEYWORD2.lastIndex + }); + } + break; + } + case "include": { + INCLUDE.lastIndex = match.index; + const include = INCLUDE.exec(source); + error || (error = include === null); + const identifier = include[1].trim(); + const keep = _Preprocessor._keep(stack); + if (keep) { + const includeSource = includes == null ? void 0 : includes.get(identifier); + if (includeSource) { + source = source.substring(0, include.index - 1) + includeSource + source.substring(INCLUDE.lastIndex); + KEYWORD2.lastIndex = include.index; + } else { + console.error(`Include not found: ${identifier}`); + error = true; + } + } + break; + } + } + } + if (error) { + console.warn("Failed to preprocess shader: ", { + source: originalSource + }); + return originalSource; + } + return source; + } + static _keep(stack) { + for (let i = 0; i < stack.length; i++) { + if (!stack[i].keep) return false; + } + return true; + } + static evaluate(expression, defines) { + const correct = INVALID.exec(expression) === null; + let invert = false; + const defined = DEFINED.exec(expression); + if (defined) { + invert = defined[1] === "!"; + expression = defined[2]; + } + expression = expression.trim(); + let exists = defines.has(expression); + if (invert) { + exists = !exists; + } + return { + result: exists, + error: !correct + }; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/shader.js +var id4 = 0; +var Shader = class { + constructor(graphicsDevice, definition) { + this.meshUniformBufferFormat = void 0; + this.meshBindGroupFormat = void 0; + this.id = id4++; + this.device = graphicsDevice; + this.definition = definition; + this.name = definition.name || "Untitled"; + this.init(); + if (definition.cshader) ; + else { + definition.vshader = Preprocessor.run(definition.vshader, definition.vincludes); + const stripUnusedColorAttachments = graphicsDevice.isWebGL2 && (platform.name === "osx" || platform.name === "ios"); + definition.fshader = Preprocessor.run(definition.fshader, definition.fincludes, stripUnusedColorAttachments); + } + this.impl = graphicsDevice.createShaderImpl(this); + } + init() { + this.ready = false; + this.failed = false; + } + get label() { + return `Shader Id ${this.id} ${this.name}`; + } + destroy() { + this.device.onDestroyShader(this); + this.impl.destroy(this); + } + loseContext() { + this.init(); + this.impl.loseContext(); + } + restoreContext() { + this.impl.restoreContext(this.device, this); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/bind-group.js +var id5 = 0; +var BindGroup = class { + constructor(graphicsDevice, format, defaultUniformBuffer) { + this.renderVersionUpdated = -1; + this.uniformBuffers = void 0; + this.uniformBufferOffsets = []; + this.id = id5++; + this.device = graphicsDevice; + this.format = format; + this.dirty = true; + this.impl = graphicsDevice.createBindGroupImpl(this); + this.textures = []; + this.storageTextures = []; + this.storageBuffers = []; + this.uniformBuffers = []; + this.defaultUniformBuffer = defaultUniformBuffer; + if (defaultUniformBuffer) { + this.setUniformBuffer(UNIFORM_BUFFER_DEFAULT_SLOT_NAME, defaultUniformBuffer); + } + } + destroy() { + this.impl.destroy(); + this.impl = null; + this.format = null; + this.defaultUniformBuffer = null; + } + setUniformBuffer(name, uniformBuffer) { + const index = this.format.bufferFormatsMap.get(name); + if (this.uniformBuffers[index] !== uniformBuffer) { + this.uniformBuffers[index] = uniformBuffer; + this.dirty = true; + } + } + setStorageBuffer(name, storageBuffer) { + const index = this.format.storageBufferFormatsMap.get(name); + if (this.storageBuffers[index] !== storageBuffer) { + this.storageBuffers[index] = storageBuffer; + this.dirty = true; + } + } + setTexture(name, texture) { + const index = this.format.textureFormatsMap.get(name); + if (this.textures[index] !== texture) { + this.textures[index] = texture; + this.dirty = true; + } else if (this.renderVersionUpdated < texture.renderVersionDirty) { + this.dirty = true; + } + } + setStorageTexture(name, texture) { + const index = this.format.storageTextureFormatsMap.get(name); + if (this.storageTextures[index] !== texture) { + this.storageTextures[index] = texture; + this.dirty = true; + } else if (this.renderVersionUpdated < texture.renderVersionDirty) { + this.dirty = true; + } + } + updateUniformBuffers() { + for (let i = 0; i < this.uniformBuffers.length; i++) { + this.uniformBuffers[i].update(); + } + } + update() { + const { + textureFormats, + storageTextureFormats, + storageBufferFormats + } = this.format; + for (let i = 0; i < textureFormats.length; i++) { + const textureFormat = textureFormats[i]; + const value = textureFormat.scopeId.value; + this.setTexture(textureFormat.name, value); + } + for (let i = 0; i < storageTextureFormats.length; i++) { + const storageTextureFormat = storageTextureFormats[i]; + const value = storageTextureFormat.scopeId.value; + this.setStorageTexture(storageTextureFormat.name, value); + } + for (let i = 0; i < storageBufferFormats.length; i++) { + const storageBufferFormat = storageBufferFormats[i]; + const value = storageBufferFormat.scopeId.value; + this.setStorageBuffer(storageBufferFormat.name, value); + } + this.uniformBufferOffsets.length = this.uniformBuffers.length; + for (let i = 0; i < this.uniformBuffers.length; i++) { + const uniformBuffer = this.uniformBuffers[i]; + this.uniformBufferOffsets[i] = uniformBuffer.offset; + if (this.renderVersionUpdated < uniformBuffer.renderVersionDirty) { + this.dirty = true; + } + } + if (this.dirty) { + this.dirty = false; + this.renderVersionUpdated = this.device.renderVersion; + this.impl.update(this); + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/dynamic-buffers.js +var DynamicBuffer = class { + constructor(device) { + this.device = void 0; + this.device = device; + } +}; +var UsedBuffer = class { + constructor() { + this.gpuBuffer = void 0; + this.stagingBuffer = void 0; + this.offset = void 0; + this.size = void 0; + } +}; +var DynamicBufferAllocation = class { + constructor() { + this.storage = void 0; + this.gpuBuffer = void 0; + this.offset = void 0; + } +}; +var DynamicBuffers = class { + constructor(device, bufferSize, bufferAlignment) { + this.bufferSize = void 0; + this.gpuBuffers = []; + this.stagingBuffers = []; + this.usedBuffers = []; + this.activeBuffer = null; + this.device = device; + this.bufferSize = bufferSize; + this.bufferAlignment = bufferAlignment; + } + destroy() { + this.gpuBuffers.forEach((gpuBuffer) => { + gpuBuffer.destroy(this.device); + }); + this.gpuBuffers = null; + this.stagingBuffers.forEach((stagingBuffer) => { + stagingBuffer.destroy(this.device); + }); + this.stagingBuffers = null; + this.usedBuffers = null; + this.activeBuffer = null; + } + alloc(allocation, size) { + if (this.activeBuffer) { + const _alignedStart = math.roundUp(this.activeBuffer.size, this.bufferAlignment); + const space = this.bufferSize - _alignedStart; + if (space < size) { + this.scheduleSubmit(); + } + } + if (!this.activeBuffer) { + let gpuBuffer = this.gpuBuffers.pop(); + if (!gpuBuffer) { + gpuBuffer = this.createBuffer(this.device, this.bufferSize, false); + } + let stagingBuffer = this.stagingBuffers.pop(); + if (!stagingBuffer) { + stagingBuffer = this.createBuffer(this.device, this.bufferSize, true); + } + this.activeBuffer = new UsedBuffer(); + this.activeBuffer.stagingBuffer = stagingBuffer; + this.activeBuffer.gpuBuffer = gpuBuffer; + this.activeBuffer.offset = 0; + this.activeBuffer.size = 0; + } + const activeBuffer = this.activeBuffer; + const alignedStart = math.roundUp(activeBuffer.size, this.bufferAlignment); + allocation.gpuBuffer = activeBuffer.gpuBuffer; + allocation.offset = alignedStart; + allocation.storage = activeBuffer.stagingBuffer.alloc(alignedStart, size); + activeBuffer.size = alignedStart + size; + } + scheduleSubmit() { + if (this.activeBuffer) { + this.usedBuffers.push(this.activeBuffer); + this.activeBuffer = null; + } + } + submit() { + this.scheduleSubmit(); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/uniform-buffer.js +var _updateFunctions = []; +_updateFunctions[UNIFORMTYPE_FLOAT] = function(uniformBuffer, value, offset) { + const dst = uniformBuffer.storageFloat32; + dst[offset] = value; +}; +_updateFunctions[UNIFORMTYPE_VEC2] = (uniformBuffer, value, offset) => { + const dst = uniformBuffer.storageFloat32; + dst[offset] = value[0]; + dst[offset + 1] = value[1]; +}; +_updateFunctions[UNIFORMTYPE_VEC3] = (uniformBuffer, value, offset) => { + const dst = uniformBuffer.storageFloat32; + dst[offset] = value[0]; + dst[offset + 1] = value[1]; + dst[offset + 2] = value[2]; +}; +_updateFunctions[UNIFORMTYPE_VEC4] = (uniformBuffer, value, offset) => { + const dst = uniformBuffer.storageFloat32; + dst[offset] = value[0]; + dst[offset + 1] = value[1]; + dst[offset + 2] = value[2]; + dst[offset + 3] = value[3]; +}; +_updateFunctions[UNIFORMTYPE_INT] = function(uniformBuffer, value, offset) { + const dst = uniformBuffer.storageInt32; + dst[offset] = value; +}; +_updateFunctions[UNIFORMTYPE_IVEC2] = function(uniformBuffer, value, offset) { + const dst = uniformBuffer.storageInt32; + dst[offset] = value[0]; + dst[offset + 1] = value[1]; +}; +_updateFunctions[UNIFORMTYPE_IVEC3] = function(uniformBuffer, value, offset) { + const dst = uniformBuffer.storageInt32; + dst[offset] = value[0]; + dst[offset + 1] = value[1]; + dst[offset + 2] = value[2]; +}; +_updateFunctions[UNIFORMTYPE_IVEC4] = function(uniformBuffer, value, offset) { + const dst = uniformBuffer.storageInt32; + dst[offset] = value[0]; + dst[offset + 1] = value[1]; + dst[offset + 2] = value[2]; + dst[offset + 3] = value[3]; +}; +_updateFunctions[UNIFORMTYPE_MAT2] = (uniformBuffer, value, offset) => { + const dst = uniformBuffer.storageFloat32; + dst[offset] = value[0]; + dst[offset + 1] = value[1]; + dst[offset + 4] = value[2]; + dst[offset + 5] = value[3]; + dst[offset + 8] = value[4]; + dst[offset + 9] = value[5]; +}; +_updateFunctions[UNIFORMTYPE_MAT3] = (uniformBuffer, value, offset) => { + const dst = uniformBuffer.storageFloat32; + dst[offset] = value[0]; + dst[offset + 1] = value[1]; + dst[offset + 2] = value[2]; + dst[offset + 4] = value[3]; + dst[offset + 5] = value[4]; + dst[offset + 6] = value[5]; + dst[offset + 8] = value[6]; + dst[offset + 9] = value[7]; + dst[offset + 10] = value[8]; +}; +_updateFunctions[UNIFORMTYPE_FLOATARRAY] = function(uniformBuffer, value, offset, count) { + const dst = uniformBuffer.storageFloat32; + for (let i = 0; i < count; i++) { + dst[offset + i * 4] = value[i]; + } +}; +_updateFunctions[UNIFORMTYPE_VEC2ARRAY] = (uniformBuffer, value, offset, count) => { + const dst = uniformBuffer.storageFloat32; + for (let i = 0; i < count; i++) { + dst[offset + i * 4] = value[i * 2]; + dst[offset + i * 4 + 1] = value[i * 2 + 1]; + } +}; +_updateFunctions[UNIFORMTYPE_VEC3ARRAY] = (uniformBuffer, value, offset, count) => { + const dst = uniformBuffer.storageFloat32; + for (let i = 0; i < count; i++) { + dst[offset + i * 4] = value[i * 3]; + dst[offset + i * 4 + 1] = value[i * 3 + 1]; + dst[offset + i * 4 + 2] = value[i * 3 + 2]; + } +}; +_updateFunctions[UNIFORMTYPE_UINT] = (uniformBuffer, value, offset, count) => { + const dst = uniformBuffer.storageUint32; + dst[offset] = value; +}; +_updateFunctions[UNIFORMTYPE_UVEC2] = (uniformBuffer, value, offset, count) => { + const dst = uniformBuffer.storageUint32; + dst[offset] = value[0]; + dst[offset + 1] = value[1]; +}; +_updateFunctions[UNIFORMTYPE_UVEC3] = (uniformBuffer, value, offset, count) => { + const dst = uniformBuffer.storageUint32; + dst[offset] = value[0]; + dst[offset + 1] = value[1]; + dst[offset + 2] = value[2]; +}; +_updateFunctions[UNIFORMTYPE_UVEC4] = (uniformBuffer, value, offset, count) => { + const dst = uniformBuffer.storageUint32; + dst[offset] = value[0]; + dst[offset + 1] = value[1]; + dst[offset + 2] = value[2]; + dst[offset + 3] = value[3]; +}; +_updateFunctions[UNIFORMTYPE_INTARRAY] = function(uniformBuffer, value, offset, count) { + const dst = uniformBuffer.storageInt32; + for (let i = 0; i < count; i++) { + dst[offset + i * 4] = value[i]; + } +}; +_updateFunctions[UNIFORMTYPE_BOOLARRAY] = _updateFunctions[UNIFORMTYPE_INTARRAY]; +_updateFunctions[UNIFORMTYPE_UINTARRAY] = function(uniformBuffer, value, offset, count) { + const dst = uniformBuffer.storageUint32; + for (let i = 0; i < count; i++) { + dst[offset + i * 4] = value[i]; + } +}; +_updateFunctions[UNIFORMTYPE_IVEC2ARRAY] = (uniformBuffer, value, offset, count) => { + const dst = uniformBuffer.storageInt32; + for (let i = 0; i < count; i++) { + dst[offset + i * 4] = value[i * 2]; + dst[offset + i * 4 + 1] = value[i * 2 + 1]; + } +}; +_updateFunctions[UNIFORMTYPE_BVEC2ARRAY] = _updateFunctions[UNIFORMTYPE_IVEC2ARRAY]; +_updateFunctions[UNIFORMTYPE_UVEC2ARRAY] = (uniformBuffer, value, offset, count) => { + const dst = uniformBuffer.storageUint32; + for (let i = 0; i < count; i++) { + dst[offset + i * 4] = value[i * 2]; + dst[offset + i * 4 + 1] = value[i * 2 + 1]; + } +}; +_updateFunctions[UNIFORMTYPE_IVEC3ARRAY] = (uniformBuffer, value, offset, count) => { + const dst = uniformBuffer.storageInt32; + for (let i = 0; i < count; i++) { + dst[offset + i * 4] = value[i * 3]; + dst[offset + i * 4 + 1] = value[i * 3 + 1]; + dst[offset + i * 4 + 2] = value[i * 3 + 2]; + } +}; +_updateFunctions[UNIFORMTYPE_BVEC3ARRAY] = _updateFunctions[UNIFORMTYPE_IVEC3ARRAY]; +_updateFunctions[UNIFORMTYPE_UVEC3ARRAY] = (uniformBuffer, value, offset, count) => { + const dst = uniformBuffer.storageUint32; + for (let i = 0; i < count; i++) { + dst[offset + i * 4] = value[i * 3]; + dst[offset + i * 4 + 1] = value[i * 3 + 1]; + dst[offset + i * 4 + 2] = value[i * 3 + 2]; + } +}; +var UniformBuffer = class { + constructor(graphicsDevice, format, persistent = true) { + this.device = void 0; + this.persistent = void 0; + this.allocation = void 0; + this.storageFloat32 = void 0; + this.storageInt32 = void 0; + this.storageUint32 = void 0; + this.renderVersionDirty = 0; + this.device = graphicsDevice; + this.format = format; + this.persistent = persistent; + if (persistent) { + this.impl = graphicsDevice.createUniformBufferImpl(this); + const storage = new ArrayBuffer(format.byteSize); + this.assignStorage(new Int32Array(storage)); + graphicsDevice._vram.ub += this.format.byteSize; + } else { + this.allocation = new DynamicBufferAllocation(); + } + } + destroy() { + if (this.persistent) { + const device = this.device; + this.impl.destroy(device); + device._vram.ub -= this.format.byteSize; + } + } + get offset() { + return this.persistent ? 0 : this.allocation.offset; + } + assignStorage(storage) { + this.storageInt32 = storage; + this.storageUint32 = new Uint32Array(storage.buffer, storage.byteOffset, storage.byteLength / 4); + this.storageFloat32 = new Float32Array(storage.buffer, storage.byteOffset, storage.byteLength / 4); + } + loseContext() { + var _this$impl; + (_this$impl = this.impl) == null || _this$impl.loseContext(); + } + setUniform(uniformFormat) { + const offset = uniformFormat.offset; + const value = uniformFormat.scopeId.value; + if (value !== null && value !== void 0) { + const updateFunction = _updateFunctions[uniformFormat.updateType]; + if (updateFunction) { + updateFunction(this, value, offset, uniformFormat.count); + } else { + this.storageFloat32.set(value, offset); + } + } + } + set(name) { + const uniformFormat = this.format.map.get(name); + if (uniformFormat) { + this.setUniform(uniformFormat); + } + } + update() { + const persistent = this.persistent; + if (!persistent) { + const allocation = this.allocation; + const oldGpuBuffer = allocation.gpuBuffer; + this.device.dynamicBuffers.alloc(allocation, this.format.byteSize); + this.assignStorage(allocation.storage); + if (oldGpuBuffer !== allocation.gpuBuffer) { + this.renderVersionDirty = this.device.renderVersion; + } + } + const uniforms = this.format.uniforms; + for (let i = 0; i < uniforms.length; i++) { + this.setUniform(uniforms[i]); + } + if (persistent) { + this.impl.unlock(this); + } else { + this.storageFloat32 = null; + this.storageInt32 = null; + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-clear-renderer.js +var primitive = { + type: PRIMITIVE_TRISTRIP, + base: 0, + count: 4, + indexed: false +}; +var WebgpuClearRenderer = class { + constructor(device) { + const code = ` + + struct ub_mesh { + color : vec4f, + depth: f32 + } + + @group(0) @binding(0) var ubMesh : ub_mesh; + + var pos : array = array( + vec2(-1.0, 1.0), vec2(1.0, 1.0), + vec2(-1.0, -1.0), vec2(1.0, -1.0) + ); + + struct VertexOutput { + @builtin(position) position : vec4f + } + + @vertex + fn vertexMain(@builtin(vertex_index) vertexIndex : u32) -> VertexOutput { + var output : VertexOutput; + output.position = vec4(pos[vertexIndex], ubMesh.depth, 1.0); + return output; + } + + @fragment + fn fragmentMain() -> @location(0) vec4f { + return ubMesh.color; + } + `; + this.shader = new Shader(device, { + name: "WebGPUClearRendererShader", + shaderLanguage: SHADERLANGUAGE_WGSL, + vshader: code, + fshader: code + }); + this.uniformBuffer = new UniformBuffer(device, new UniformBufferFormat(device, [new UniformFormat("color", UNIFORMTYPE_VEC4), new UniformFormat("depth", UNIFORMTYPE_FLOAT)]), false); + const bindGroupFormat = new BindGroupFormat(device, [new BindUniformBufferFormat(UNIFORM_BUFFER_DEFAULT_SLOT_NAME, SHADERSTAGE_VERTEX | SHADERSTAGE_FRAGMENT)]); + this.bindGroup = new BindGroup(device, bindGroupFormat, this.uniformBuffer); + this.colorData = new Float32Array(4); + this.colorId = device.scope.resolve("color"); + this.depthId = device.scope.resolve("depth"); + } + destroy() { + this.shader.destroy(); + this.shader = null; + this.uniformBuffer.destroy(); + this.uniformBuffer = null; + this.bindGroup.destroy(); + this.bindGroup = null; + } + clear(device, renderTarget, options, defaultOptions) { + var _options$flags; + options = options || defaultOptions; + const flags = (_options$flags = options.flags) != null ? _options$flags : defaultOptions.flags; + if (flags !== 0) { + if (flags & CLEARFLAG_COLOR && (renderTarget.colorBuffer || renderTarget.impl.assignedColorTexture)) { + var _options$color; + const color = (_options$color = options.color) != null ? _options$color : defaultOptions.color; + this.colorData.set(color); + device.setBlendState(BlendState.NOBLEND); + } else { + device.setBlendState(BlendState.NOWRITE); + } + this.colorId.setValue(this.colorData); + if (flags & CLEARFLAG_DEPTH && renderTarget.depth) { + var _options$depth; + const depth = (_options$depth = options.depth) != null ? _options$depth : defaultOptions.depth; + this.depthId.setValue(depth); + device.setDepthState(DepthState.WRITEDEPTH); + } else { + this.depthId.setValue(1); + device.setDepthState(DepthState.NODEPTH); + } + if (flags & CLEARFLAG_STENCIL && renderTarget.stencil) ; + device.setCullMode(CULLFACE_NONE); + device.setShader(this.shader); + const bindGroup = this.bindGroup; + bindGroup.defaultUniformBuffer.update(); + bindGroup.update(); + device.setBindGroup(BINDGROUP_MESH, bindGroup); + device.draw(primitive); + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-mipmap-renderer.js +var WebgpuMipmapRenderer = class { + constructor(device) { + this.device = void 0; + this.device = device; + const code = ` + + var pos : array = array( + vec2(-1.0, 1.0), vec2(1.0, 1.0), + vec2(-1.0, -1.0), vec2(1.0, -1.0) + ); + + struct VertexOutput { + @builtin(position) position : vec4f, + @location(0) texCoord : vec2f + }; + + @vertex + fn vertexMain(@builtin(vertex_index) vertexIndex : u32) -> VertexOutput { + var output : VertexOutput; + output.texCoord = pos[vertexIndex] * vec2f(0.5, -0.5) + vec2f(0.5); + output.position = vec4f(pos[vertexIndex], 0, 1); + return output; + } + + @group(0) @binding(0) var imgSampler : sampler; + @group(0) @binding(1) var img : texture_2d; + + @fragment + fn fragmentMain(@location(0) texCoord : vec2f) -> @location(0) vec4f { + return textureSample(img, imgSampler, texCoord); + } + `; + this.shader = new Shader(device, { + name: "WebGPUMipmapRendererShader", + shaderLanguage: SHADERLANGUAGE_WGSL, + vshader: code, + fshader: code + }); + this.minSampler = device.wgpu.createSampler({ + minFilter: "linear" + }); + } + destroy() { + this.shader.destroy(); + this.shader = null; + } + generate(webgpuTexture) { + var _device$commandEncode; + const textureDescr = webgpuTexture.descr; + if (textureDescr.mipLevelCount <= 1) { + return; + } + if (webgpuTexture.texture.volume) { + return; + } + const device = this.device; + const wgpu = device.wgpu; + const webgpuShader = this.shader.impl; + const pipeline = wgpu.createRenderPipeline({ + layout: "auto", + vertex: { + module: webgpuShader.getVertexShaderModule(), + entryPoint: webgpuShader.vertexEntryPoint + }, + fragment: { + module: webgpuShader.getFragmentShaderModule(), + entryPoint: webgpuShader.fragmentEntryPoint, + targets: [{ + format: textureDescr.format + }] + }, + primitive: { + topology: "triangle-strip" + } + }); + const texture = webgpuTexture.texture; + const numFaces = texture.cubemap ? 6 : texture.array ? texture.arrayLength : 1; + const srcViews = []; + for (let face = 0; face < numFaces; face++) { + srcViews.push(webgpuTexture.createView({ + dimension: "2d", + baseMipLevel: 0, + mipLevelCount: 1, + baseArrayLayer: face + })); + } + const commandEncoder = (_device$commandEncode = device.commandEncoder) != null ? _device$commandEncode : wgpu.createCommandEncoder(); + for (let i = 1; i < textureDescr.mipLevelCount; i++) { + for (let face = 0; face < numFaces; face++) { + const dstView = webgpuTexture.createView({ + dimension: "2d", + baseMipLevel: i, + mipLevelCount: 1, + baseArrayLayer: face + }); + const passEncoder = commandEncoder.beginRenderPass({ + colorAttachments: [{ + view: dstView, + loadOp: "clear", + storeOp: "store" + }] + }); + const bindGroup = wgpu.createBindGroup({ + layout: pipeline.getBindGroupLayout(0), + entries: [{ + binding: 0, + resource: this.minSampler + }, { + binding: 1, + resource: srcViews[face] + }] + }); + passEncoder.setPipeline(pipeline); + passEncoder.setBindGroup(0, bindGroup); + passEncoder.draw(4); + passEncoder.end(); + srcViews[face] = dstView; + } + } + if (!device.commandEncoder) { + const cb = commandEncoder.finish(); + device.addCommandBuffer(cb); + } + device.pipeline = null; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-dynamic-buffer.js +var WebgpuDynamicBuffer = class extends DynamicBuffer { + constructor(device, size, isStaging) { + super(device); + this.buffer = null; + this.mappedRange = null; + this.buffer = device.wgpu.createBuffer({ + size, + usage: isStaging ? GPUBufferUsage.MAP_WRITE | GPUBufferUsage.COPY_SRC : GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST, + mappedAtCreation: isStaging + }); + if (isStaging) { + this.onAvailable(); + } + device._vram.ub += size; + } + destroy(device) { + device._vram.ub -= this.buffer.size; + this.buffer.destroy(); + this.buffer = null; + } + onAvailable() { + this.mappedRange = this.buffer.getMappedRange(); + } + alloc(offset, size) { + return new Int32Array(this.mappedRange, offset, size / 4); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-dynamic-buffers.js +var WebgpuDynamicBuffers = class extends DynamicBuffers { + constructor(...args) { + super(...args); + this.pendingStagingBuffers = []; + } + createBuffer(device, size, isStaging) { + return new WebgpuDynamicBuffer(device, size, isStaging); + } + submit() { + super.submit(); + const count = this.usedBuffers.length; + if (count) { + const device = this.device; + const gpuBuffers = this.gpuBuffers; + const commandEncoder = device.wgpu.createCommandEncoder(); + for (let i = count - 1; i >= 0; i--) { + const usedBuffer = this.usedBuffers[i]; + const { + stagingBuffer, + gpuBuffer, + offset, + size + } = usedBuffer; + const src = stagingBuffer.buffer; + src.unmap(); + commandEncoder.copyBufferToBuffer(src, offset, gpuBuffer.buffer, offset, size); + gpuBuffers.push(gpuBuffer); + } + const cb = commandEncoder.finish(); + device.addCommandBuffer(cb, true); + for (let i = 0; i < count; i++) { + const stagingBuffer = this.usedBuffers[i].stagingBuffer; + this.pendingStagingBuffers.push(stagingBuffer); + } + this.usedBuffers.length = 0; + } + } + onCommandBuffersSubmitted() { + const count = this.pendingStagingBuffers.length; + if (count) { + for (let i = 0; i < count; i++) { + const stagingBuffer = this.pendingStagingBuffers[i]; + stagingBuffer.buffer.mapAsync(GPUMapMode.WRITE).then(() => { + if (this.stagingBuffers) { + stagingBuffer.onAvailable(); + this.stagingBuffers.push(stagingBuffer); + } + }); + } + this.pendingStagingBuffers.length = 0; + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/gpu-profiler.js +var GpuProfiler = class { + constructor() { + this.frameAllocations = []; + this.pastFrameAllocations = /* @__PURE__ */ new Map(); + this._enabled = false; + this._enableRequest = false; + this._frameTime = 0; + } + loseContext() { + this.pastFrameAllocations.clear(); + } + set enabled(value) { + this._enableRequest = value; + } + get enabled() { + return this._enableRequest; + } + processEnableRequest() { + if (this._enableRequest !== this._enabled) { + this._enabled = this._enableRequest; + if (!this._enabled) { + this._frameTime = 0; + } + } + } + request(renderVersion) { + this.pastFrameAllocations.set(renderVersion, this.frameAllocations); + this.frameAllocations = []; + } + report(renderVersion, timings) { + if (timings) { + const allocations = this.pastFrameAllocations.get(renderVersion); + if (timings.length > 0) { + this._frameTime = timings[0]; + } + if (Tracing.get(TRACEID_GPU_TIMINGS)) { + for (let i = 0; i < allocations.length; ++i) { + allocations[i]; + } + } + } + this.pastFrameAllocations.delete(renderVersion); + } + getSlot(name) { + const slot = this.frameAllocations.length; + this.frameAllocations.push(name); + return slot; + } + get slotCount() { + return this.frameAllocations.length; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-query-set.js +var WebgpuQuerySet = class { + constructor(device, isTimestamp, capacity) { + this.querySet = void 0; + this.stagingBuffers = []; + this.activeStagingBuffer = null; + this.bytesPerSlot = void 0; + this.device = device; + this.capacity = capacity; + this.bytesPerSlot = isTimestamp ? 8 : 4; + const wgpu = device.wgpu; + this.querySet = wgpu.createQuerySet({ + type: isTimestamp ? "timestamp" : "occlusion", + count: capacity + }); + this.queryBuffer = wgpu.createBuffer({ + size: this.bytesPerSlot * capacity, + usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST + }); + } + destroy() { + var _this$querySet, _this$queryBuffer; + (_this$querySet = this.querySet) == null || _this$querySet.destroy(); + this.querySet = null; + (_this$queryBuffer = this.queryBuffer) == null || _this$queryBuffer.destroy(); + this.queryBuffer = null; + this.activeStagingBuffer = null; + this.stagingBuffers.forEach((stagingBuffer) => { + stagingBuffer.destroy(); + }); + this.stagingBuffers = null; + } + getStagingBuffer() { + let stagingBuffer = this.stagingBuffers.pop(); + if (!stagingBuffer) { + stagingBuffer = this.device.wgpu.createBuffer({ + size: this.queryBuffer.size, + usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ + }); + } + return stagingBuffer; + } + resolve(count) { + const device = this.device; + const commandEncoder = device.wgpu.createCommandEncoder(); + commandEncoder.resolveQuerySet(this.querySet, 0, count, this.queryBuffer, 0); + const activeStagingBuffer = this.getStagingBuffer(); + this.activeStagingBuffer = activeStagingBuffer; + commandEncoder.copyBufferToBuffer(this.queryBuffer, 0, activeStagingBuffer, 0, this.bytesPerSlot * count); + const cb = commandEncoder.finish(); + device.addCommandBuffer(cb); + } + request(count, renderVersion) { + const stagingBuffer = this.activeStagingBuffer; + this.activeStagingBuffer = null; + return stagingBuffer.mapAsync(GPUMapMode.READ).then(() => { + var _this$stagingBuffers; + const srcTimings = new BigInt64Array(stagingBuffer.getMappedRange()); + const timings = []; + for (let i = 0; i < count; i++) { + timings.push(Number(srcTimings[i * 2 + 1] - srcTimings[i * 2]) * 1e-6); + } + stagingBuffer.unmap(); + (_this$stagingBuffers = this.stagingBuffers) == null || _this$stagingBuffers.push(stagingBuffer); + return { + renderVersion, + timings + }; + }); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-gpu-profiler.js +var WebgpuGpuProfiler = class extends GpuProfiler { + constructor(device) { + super(); + this.device = void 0; + this.frameGPUMarkerSlot = void 0; + this.device = device; + this.timestampQueriesSet = device.supportsTimestampQuery ? new WebgpuQuerySet(device, true, 512) : null; + } + destroy() { + var _this$timestampQuerie; + (_this$timestampQuerie = this.timestampQueriesSet) == null || _this$timestampQuerie.destroy(); + this.timestampQueriesSet = null; + } + frameStart() { + this.processEnableRequest(); + } + frameEnd() { + if (this._enabled) { + var _this$timestampQuerie2; + (_this$timestampQuerie2 = this.timestampQueriesSet) == null || _this$timestampQuerie2.resolve(this.slotCount * 2); + } + } + request() { + if (this._enabled) { + var _this$timestampQuerie3; + const renderVersion = this.device.renderVersion; + (_this$timestampQuerie3 = this.timestampQueriesSet) == null || _this$timestampQuerie3.request(this.slotCount, renderVersion).then((results) => { + this.report(results.renderVersion, results.timings); + }); + super.request(renderVersion); + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-resolver.js +var WebgpuResolver = class { + constructor(device) { + this.device = void 0; + this.pipelineCache = /* @__PURE__ */ new Map(); + this.device = device; + const code = ` + + var pos : array = array( + vec2(-1.0, 1.0), vec2(1.0, 1.0), vec2(-1.0, -1.0), vec2(1.0, -1.0) + ); + + struct VertexOutput { + @builtin(position) position : vec4f, + }; + + @vertex + fn vertexMain(@builtin(vertex_index) vertexIndex : u32) -> VertexOutput { + var output : VertexOutput; + output.position = vec4f(pos[vertexIndex], 0, 1); + return output; + } + + @group(0) @binding(0) var img : texture_depth_multisampled_2d; + + @fragment + fn fragmentMain(@builtin(position) fragColor: vec4f) -> @location(0) vec4f { + // load th depth value from sample index 0 + var depth = textureLoad(img, vec2i(fragColor.xy), 0u); + return vec4(depth, 0.0, 0.0, 0.0); + } + `; + this.shader = new Shader(device, { + name: "WebGPUResolverDepthShader", + shaderLanguage: SHADERLANGUAGE_WGSL, + vshader: code, + fshader: code + }); + } + destroy() { + this.shader.destroy(); + this.shader = null; + this.pipelineCache = null; + } + getPipeline(format) { + let pipeline = this.pipelineCache.get(format); + if (!pipeline) { + pipeline = this.createPipeline(format); + this.pipelineCache.set(format, pipeline); + } + return pipeline; + } + createPipeline(format) { + const webgpuShader = this.shader.impl; + const pipeline = this.device.wgpu.createRenderPipeline({ + layout: "auto", + vertex: { + module: webgpuShader.getVertexShaderModule(), + entryPoint: webgpuShader.vertexEntryPoint + }, + fragment: { + module: webgpuShader.getFragmentShaderModule(), + entryPoint: webgpuShader.fragmentEntryPoint, + targets: [{ + format + }] + }, + primitive: { + topology: "triangle-strip" + } + }); + return pipeline; + } + resolveDepth(commandEncoder, sourceTexture, destinationTexture) { + const device = this.device; + const wgpu = device.wgpu; + const pipeline = this.getPipeline(destinationTexture.format); + const numFaces = sourceTexture.depthOrArrayLayers; + for (let face = 0; face < numFaces; face++) { + const srcView = sourceTexture.createView({ + dimension: "2d", + aspect: "depth-only", + baseMipLevel: 0, + mipLevelCount: 1, + baseArrayLayer: face + }); + const dstView = destinationTexture.createView({ + dimension: "2d", + baseMipLevel: 0, + mipLevelCount: 1, + baseArrayLayer: face + }); + const passEncoder = commandEncoder.beginRenderPass({ + colorAttachments: [{ + view: dstView, + loadOp: "clear", + storeOp: "store" + }] + }); + const bindGroup = wgpu.createBindGroup({ + layout: pipeline.getBindGroupLayout(0), + entries: [{ + binding: 0, + resource: srcView + }] + }); + passEncoder.setPipeline(pipeline); + passEncoder.setBindGroup(0, bindGroup); + passEncoder.draw(4); + passEncoder.end(); + } + device.pipeline = null; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-compute.js +var WebgpuCompute = class { + constructor(compute) { + this.uniformBuffers = []; + this.bindGroup = null; + this.compute = compute; + const { + device, + shader + } = compute; + const { + computeBindGroupFormat, + computeUniformBufferFormats + } = shader.impl; + this.bindGroup = new BindGroup(device, computeBindGroupFormat); + if (computeUniformBufferFormats) { + for (const name in computeUniformBufferFormats) { + if (computeUniformBufferFormats.hasOwnProperty(name)) { + const ub = new UniformBuffer(device, computeUniformBufferFormats[name], true); + this.uniformBuffers.push(ub); + this.bindGroup.setUniformBuffer(name, ub); + } + } + } + this.pipeline = device.computePipeline.get(shader, computeBindGroupFormat); + } + destroy() { + this.uniformBuffers.forEach((ub) => ub.destroy()); + this.uniformBuffers.length = 0; + this.bindGroup.destroy(); + this.bindGroup = null; + } + updateBindGroup() { + const { + bindGroup + } = this; + bindGroup.updateUniformBuffers(); + bindGroup.update(); + } + dispatch(x2, y2, z2) { + const device = this.compute.device; + device.setBindGroup(0, this.bindGroup); + const passEncoder = device.passEncoder; + passEncoder.setPipeline(this.pipeline); + passEncoder.dispatchWorkgroups(x2, y2, z2); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-graphics-device.js +var _uniqueLocations = /* @__PURE__ */ new Map(); +var WebgpuGraphicsDevice = class extends GraphicsDevice { + constructor(canvas, options = {}) { + var _options$alpha, _options$antialias; + super(canvas, options); + this.renderPipeline = new WebgpuRenderPipeline(this); + this.computePipeline = new WebgpuComputePipeline(this); + this.clearRenderer = void 0; + this.mipmapRenderer = void 0; + this.pipeline = void 0; + this.bindGroupFormats = []; + this.commandEncoder = null; + this.commandBuffers = []; + this.limits = void 0; + options = this.initOptions; + options.alpha = (_options$alpha = options.alpha) != null ? _options$alpha : true; + this.backBufferAntialias = (_options$antialias = options.antialias) != null ? _options$antialias : false; + this.isWebGPU = true; + this._deviceType = DEVICETYPE_WEBGPU; + } + destroy() { + this.clearRenderer.destroy(); + this.clearRenderer = null; + this.mipmapRenderer.destroy(); + this.mipmapRenderer = null; + this.resolver.destroy(); + this.resolver = null; + super.destroy(); + } + initDeviceCaps() { + var _this$wgpu; + const limits = (_this$wgpu = this.wgpu) == null ? void 0 : _this$wgpu.limits; + this.limits = limits; + this.precision = "highp"; + this.maxPrecision = "highp"; + this.maxSamples = 4; + this.maxTextures = 16; + this.maxTextureSize = limits.maxTextureDimension2D; + this.maxCubeMapSize = limits.maxTextureDimension2D; + this.maxVolumeSize = limits.maxTextureDimension3D; + this.maxColorAttachments = limits.maxColorAttachments; + this.maxPixelRatio = 1; + this.maxAnisotropy = 16; + this.fragmentUniformsCount = limits.maxUniformBufferBindingSize / 16; + this.vertexUniformsCount = limits.maxUniformBufferBindingSize / 16; + this.supportsInstancing = true; + this.supportsUniformBuffers = true; + this.supportsVolumeTextures = true; + this.supportsBoneTextures = true; + this.supportsMorphTargetTexturesCore = true; + this.supportsAreaLights = true; + this.supportsDepthShadow = true; + this.supportsGpuParticles = true; + this.supportsMrt = true; + this.supportsCompute = true; + this.extUintElement = true; + this.extTextureFloat = true; + this.textureFloatRenderable = true; + this.textureHalfFloatFilterable = true; + this.extTextureHalfFloat = true; + this.textureHalfFloatRenderable = true; + this.textureHalfFloatUpdatable = true; + this.boneLimit = 1024; + this.supportsImageBitmap = true; + this.extStandardDerivatives = true; + this.extBlendMinmax = true; + this.areaLightLutFormat = this.textureFloatFilterable ? PIXELFORMAT_RGBA32F : PIXELFORMAT_RGBA8; + this.supportsTextureFetch = true; + this.samples = this.backBufferAntialias ? 4 : 1; + const wgslFeatures = navigator.gpu.wgslLanguageFeatures; + this.supportsStorageTextureRead = wgslFeatures == null ? void 0 : wgslFeatures.has("readonly_and_readwrite_storage_textures"); + } + async initWebGpu(glslangUrl, twgslUrl) { + var _this$gpuAdapter, _this$wgpu$lost; + if (!window.navigator.gpu) { + throw new Error("Unable to retrieve GPU. Ensure you are using a browser that supports WebGPU rendering."); + } + const buildUrl = (srcPath) => { + return new URL(srcPath, window.location.href).toString(); + }; + const results = await Promise.all([import( + /* @vite-ignore */ + /* webpackIgnore: true */ + `${buildUrl(twgslUrl)}` + ).then((module) => twgsl(twgslUrl.replace(".js", ".wasm"))), import( + /* @vite-ignore */ + /* webpackIgnore: true */ + `${buildUrl(glslangUrl)}` + ).then((module) => module.default())]); + this.twgsl = results[0]; + this.glslang = results[1]; + const adapterOptions = { + powerPreference: this.initOptions.powerPreference !== "default" ? this.initOptions.powerPreference : void 0 + }; + this.gpuAdapter = await window.navigator.gpu.requestAdapter(adapterOptions); + const requiredFeatures = []; + const requireFeature = (feature) => { + const supported = this.gpuAdapter.features.has(feature); + if (supported) { + requiredFeatures.push(feature); + } + return supported; + }; + this.textureFloatFilterable = requireFeature("float32-filterable"); + this.extCompressedTextureS3TC = requireFeature("texture-compression-bc"); + this.extCompressedTextureETC = requireFeature("texture-compression-etc2"); + this.extCompressedTextureASTC = requireFeature("texture-compression-astc"); + this.supportsTimestampQuery = requireFeature("timestamp-query"); + this.supportsDepthClip = requireFeature("depth-clip-control"); + this.supportsDepth32Stencil = requireFeature("depth32float-stencil8"); + this.supportsIndirectFirstInstance = requireFeature("indirect-first-instance"); + this.supportsShaderF16 = requireFeature("shader-f16"); + this.supportsStorageRGBA8 = requireFeature("bgra8unorm-storage"); + this.textureRG11B10Renderable = requireFeature("rg11b10ufloat-renderable"); + const adapterLimits = (_this$gpuAdapter = this.gpuAdapter) == null ? void 0 : _this$gpuAdapter.limits; + const requiredLimits = {}; + if (adapterLimits) { + for (const limitName in adapterLimits) { + if (limitName === "minSubgroupSize" || limitName === "maxSubgroupSize") { + continue; + } + requiredLimits[limitName] = adapterLimits[limitName]; + } + } + const deviceDescr = { + requiredFeatures, + requiredLimits, + defaultQueue: { + label: "Default Queue" + } + }; + this.wgpu = await this.gpuAdapter.requestDevice(deviceDescr); + (_this$wgpu$lost = this.wgpu.lost) == null || _this$wgpu$lost.then((info) => { + if (info.reason !== "destroyed") ; + }); + this.initDeviceCaps(); + this.gpuContext = this.canvas.getContext("webgpu"); + const preferredCanvasFormat = navigator.gpu.getPreferredCanvasFormat(); + this.backBufferFormat = preferredCanvasFormat === "rgba8unorm" ? PIXELFORMAT_RGBA8 : PIXELFORMAT_BGRA8; + this.canvasConfig = { + device: this.wgpu, + colorSpace: "srgb", + alphaMode: this.initOptions.alpha ? "premultiplied" : "opaque", + format: preferredCanvasFormat, + usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC | GPUTextureUsage.COPY_DST, + viewFormats: [] + }; + this.gpuContext.configure(this.canvasConfig); + this.createBackbuffer(); + this.clearRenderer = new WebgpuClearRenderer(this); + this.mipmapRenderer = new WebgpuMipmapRenderer(this); + this.resolver = new WebgpuResolver(this); + this.postInit(); + return this; + } + postInit() { + super.postInit(); + this.initializeRenderState(); + this.setupPassEncoderDefaults(); + this.gpuProfiler = new WebgpuGpuProfiler(this); + this.dynamicBuffers = new WebgpuDynamicBuffers(this, 1024 * 1024, this.limits.minUniformBufferOffsetAlignment); + } + createBackbuffer() { + this.supportsStencil = this.initOptions.stencil; + this.backBuffer = new RenderTarget({ + name: "WebgpuFramebuffer", + graphicsDevice: this, + depth: this.initOptions.depth, + stencil: this.supportsStencil, + samples: this.samples + }); + } + frameStart() { + super.frameStart(); + this.gpuProfiler.frameStart(); + this.submit(); + const outColorBuffer = this.gpuContext.getCurrentTexture(); + if (this.backBufferSize.x !== outColorBuffer.width || this.backBufferSize.y !== outColorBuffer.height) { + this.backBufferSize.set(outColorBuffer.width, outColorBuffer.height); + this.backBuffer.destroy(); + this.backBuffer = null; + this.createBackbuffer(); + } + const rt = this.backBuffer; + const wrt = rt.impl; + wrt.setColorAttachment(0, void 0, outColorBuffer.format); + this.initRenderTarget(rt); + wrt.assignColorTexture(outColorBuffer); + } + frameEnd() { + super.frameEnd(); + this.gpuProfiler.frameEnd(); + this.submit(); + if (!this.contextLost) { + this.gpuProfiler.request(); + } + } + createBufferImpl(usageFlags) { + return new WebgpuBuffer(usageFlags); + } + createUniformBufferImpl(uniformBuffer) { + return new WebgpuUniformBuffer(uniformBuffer); + } + createVertexBufferImpl(vertexBuffer, format, options) { + return new WebgpuVertexBuffer(vertexBuffer, format, options); + } + createIndexBufferImpl(indexBuffer, options) { + return new WebgpuIndexBuffer(indexBuffer, options); + } + createShaderImpl(shader) { + return new WebgpuShader(shader); + } + createTextureImpl(texture) { + return new WebgpuTexture(texture); + } + createRenderTargetImpl(renderTarget) { + return new WebgpuRenderTarget(renderTarget); + } + createBindGroupFormatImpl(bindGroupFormat) { + return new WebgpuBindGroupFormat(bindGroupFormat); + } + createBindGroupImpl(bindGroup) { + return new WebgpuBindGroup(); + } + createComputeImpl(compute) { + return new WebgpuCompute(compute); + } + setBindGroup(index, bindGroup) { + if (this.passEncoder) { + this.passEncoder.setBindGroup(index, bindGroup.impl.bindGroup, bindGroup.uniformBufferOffsets); + this.bindGroupFormats[index] = bindGroup.format.impl; + } + } + submitVertexBuffer(vertexBuffer, slot) { + const format = vertexBuffer.format; + const { + interleaved, + elements + } = format; + const elementCount = elements.length; + const vbBuffer = vertexBuffer.impl.buffer; + if (interleaved) { + this.passEncoder.setVertexBuffer(slot, vbBuffer); + return 1; + } + for (let i = 0; i < elementCount; i++) { + this.passEncoder.setVertexBuffer(slot + i, vbBuffer, elements[i].offset); + } + return elementCount; + } + validateVBLocations(vb0, vb1) { + const validateVB = (vb) => { + const { + elements + } = vb.format; + for (let i = 0; i < elements.length; i++) { + const name = elements[i].name; + const location = semanticToLocation[name]; + if (_uniqueLocations.has(location)) ; + _uniqueLocations.set(location, name); + } + }; + validateVB(vb0); + validateVB(vb1); + _uniqueLocations.clear(); + } + draw(primitive2, numInstances = 1, keepBuffers) { + if (this.shader.ready && !this.shader.failed) { + const passEncoder = this.passEncoder; + const vb0 = this.vertexBuffers[0]; + const vb1 = this.vertexBuffers[1]; + this.vertexBuffers.length = 0; + if (vb0) { + const vbSlot = this.submitVertexBuffer(vb0, 0); + if (vb1) { + this.submitVertexBuffer(vb1, vbSlot); + } + } + const pipeline = this.renderPipeline.get(primitive2, vb0 == null ? void 0 : vb0.format, vb1 == null ? void 0 : vb1.format, this.shader, this.renderTarget, this.bindGroupFormats, this.blendState, this.depthState, this.cullMode, this.stencilEnabled, this.stencilFront, this.stencilBack); + if (this.pipeline !== pipeline) { + this.pipeline = pipeline; + passEncoder.setPipeline(pipeline); + } + const ib = this.indexBuffer; + if (ib) { + this.indexBuffer = null; + passEncoder.setIndexBuffer(ib.impl.buffer, ib.impl.format); + passEncoder.drawIndexed(primitive2.count, numInstances, primitive2.base, 0, 0); + } else { + passEncoder.draw(primitive2.count, numInstances, primitive2.base, 0); + } + } + } + setShader(shader, asyncCompile = false) { + if (shader !== this.shader) { + this.shader = shader; + } + } + setBlendState(blendState) { + this.blendState.copy(blendState); + } + setDepthState(depthState) { + this.depthState.copy(depthState); + } + setStencilState(stencilFront, stencilBack) { + if (stencilFront || stencilBack) { + this.stencilEnabled = true; + this.stencilFront.copy(stencilFront != null ? stencilFront : StencilParameters.DEFAULT); + this.stencilBack.copy(stencilBack != null ? stencilBack : StencilParameters.DEFAULT); + const ref = this.stencilFront.ref; + if (this.stencilRef !== ref) { + this.stencilRef = ref; + this.passEncoder.setStencilReference(ref); + } + } else { + this.stencilEnabled = false; + } + } + setBlendColor(r, g, b, a) { + const c2 = this.blendColor; + if (r !== c2.r || g !== c2.g || b !== c2.b || a !== c2.a) { + c2.set(r, g, b, a); + this.passEncoder.setBlendConstant(c2); + } + } + setCullMode(cullMode) { + this.cullMode = cullMode; + } + setAlphaToCoverage(state) { + } + initializeContextCaches() { + super.initializeContextCaches(); + } + setupPassEncoderDefaults() { + this.pipeline = null; + this.stencilRef = 0; + this.blendColor.set(0, 0, 0, 0); + } + _uploadDirtyTextures() { + this.textures.forEach((texture) => { + if (texture._needsUpload || texture._needsMipmaps) { + texture.upload(); + } + }); + } + startRenderPass(renderPass) { + this._uploadDirtyTextures(); + const rt = renderPass.renderTarget || this.backBuffer; + this.renderTarget = rt; + const wrt = rt.impl; + this.commandEncoder = this.wgpu.createCommandEncoder(); + if (rt !== this.backBuffer) { + this.initRenderTarget(rt); + } + wrt.setupForRenderPass(renderPass); + const renderPassDesc = wrt.renderPassDescriptor; + if (this.gpuProfiler._enabled) { + if (this.gpuProfiler.timestampQueriesSet) { + const slot = this.gpuProfiler.getSlot(renderPass.name); + renderPassDesc.timestampWrites = { + querySet: this.gpuProfiler.timestampQueriesSet.querySet, + beginningOfPassWriteIndex: slot * 2, + endOfPassWriteIndex: slot * 2 + 1 + }; + } + } + this.passEncoder = this.commandEncoder.beginRenderPass(renderPassDesc); + this.setupPassEncoderDefaults(); + const { + width, + height + } = rt; + this.setViewport(0, 0, width, height); + this.setScissor(0, 0, width, height); + this.insideRenderPass = true; + } + endRenderPass(renderPass) { + this.passEncoder.end(); + this.passEncoder = null; + this.insideRenderPass = false; + this.bindGroupFormats.length = 0; + for (let i = 0; i < renderPass.colorArrayOps.length; i++) { + const colorOps = renderPass.colorArrayOps[i]; + if (colorOps.mipmaps) { + this.mipmapRenderer.generate(renderPass.renderTarget._colorBuffers[i].impl); + } + } + const cb = this.commandEncoder.finish(); + this.addCommandBuffer(cb); + this.commandEncoder = null; + } + startComputePass() { + this.commandEncoder = this.wgpu.createCommandEncoder(); + this.pipeline = null; + this.passEncoder = this.commandEncoder.beginComputePass(); + this.insideRenderPass = true; + } + endComputePass() { + this.passEncoder.end(); + this.passEncoder = null; + this.insideRenderPass = false; + this.bindGroupFormats.length = 0; + const cb = this.commandEncoder.finish(); + this.addCommandBuffer(cb); + this.commandEncoder = null; + } + computeDispatch(computes) { + this.startComputePass(); + for (let i = 0; i < computes.length; i++) { + const compute = computes[i]; + compute.applyParameters(); + compute.impl.updateBindGroup(); + } + for (let i = 0; i < computes.length; i++) { + const compute = computes[i]; + compute.impl.dispatch(compute.countX, compute.countY, compute.countZ); + } + this.endComputePass(); + } + addCommandBuffer(commandBuffer, front = false) { + if (front) { + this.commandBuffers.unshift(commandBuffer); + } else { + this.commandBuffers.push(commandBuffer); + } + } + submit() { + if (this.commandBuffers.length > 0) { + this.dynamicBuffers.submit(); + this.wgpu.queue.submit(this.commandBuffers); + this.commandBuffers.length = 0; + this.dynamicBuffers.onCommandBuffersSubmitted(); + } + } + clear(options) { + if (options.flags) { + this.clearRenderer.clear(this, this.renderTarget, options, this.defaultClearOptions); + } + } + setViewport(x2, y2, w, h) { + if (this.passEncoder) { + if (!this.renderTarget.flipY) { + y2 = this.renderTarget.height - y2 - h; + } + this.vx = x2; + this.vy = y2; + this.vw = w; + this.vh = h; + this.passEncoder.setViewport(x2, y2, w, h, 0, 1); + } + } + setScissor(x2, y2, w, h) { + if (this.passEncoder) { + if (!this.renderTarget.flipY) { + y2 = this.renderTarget.height - y2 - h; + } + this.sx = x2; + this.sy = y2; + this.sw = w; + this.sh = h; + this.passEncoder.setScissorRect(x2, y2, w, h); + } + } + clearStorageBuffer(storageBuffer, offset = 0, size = storageBuffer.byteSize) { + var _this$commandEncoder; + const commandEncoder = (_this$commandEncoder = this.commandEncoder) != null ? _this$commandEncoder : this.wgpu.createCommandEncoder(); + commandEncoder.clearBuffer(storageBuffer.buffer, offset, size); + if (!this.commandEncoder) { + const cb = commandEncoder.finish(); + this.addCommandBuffer(cb); + } + } + readStorageBuffer(storageBuffer, offset = 0, size = storageBuffer.byteSize - offset, data2 = null, immediate = false) { + var _this$commandEncoder2; + const stagingBuffer = this.createBufferImpl(BUFFERUSAGE_READ | BUFFERUSAGE_COPY_DST); + stagingBuffer.allocate(this, size); + const destBuffer = stagingBuffer.buffer; + const commandEncoder = (_this$commandEncoder2 = this.commandEncoder) != null ? _this$commandEncoder2 : this.wgpu.createCommandEncoder(); + commandEncoder.copyBufferToBuffer(storageBuffer.buffer, offset, destBuffer, 0, size); + if (!this.commandEncoder) { + const cb = commandEncoder.finish(); + this.addCommandBuffer(cb); + } + return new Promise((resolve, reject) => { + const read = () => { + destBuffer == null || destBuffer.mapAsync(GPUMapMode.READ).then(() => { + var _data; + (_data = data2) != null ? _data : data2 = new Uint8Array(size); + const copySrc = destBuffer.getMappedRange(0, size); + const srcType = data2.constructor; + data2.set(new srcType(copySrc)); + destBuffer.unmap(); + stagingBuffer.destroy(this); + resolve(data2); + }); + }; + if (immediate) { + this.submit(); + read(); + } else { + setTimeout(() => { + read(); + }); + } + }); + } + writeStorageBuffer(storageBuffer, bufferOffset = 0, data2, dataOffset = 0, size) { + this.wgpu.queue.writeBuffer(storageBuffer.buffer, bufferOffset, data2, dataOffset, size); + } + copyRenderTarget(source, dest, color, depth) { + var _this$commandEncoder3; + const copySize = { + width: source ? source.width : dest.width, + height: source ? source.height : dest.height, + depthOrArrayLayers: 1 + }; + const commandEncoder = (_this$commandEncoder3 = this.commandEncoder) != null ? _this$commandEncoder3 : this.wgpu.createCommandEncoder(); + if (color) { + const copySrc = { + texture: source ? source.colorBuffer.impl.gpuTexture : this.renderTarget.impl.assignedColorTexture, + mipLevel: 0 + }; + const copyDst = { + texture: dest ? dest.colorBuffer.impl.gpuTexture : this.renderTarget.impl.assignedColorTexture, + mipLevel: 0 + }; + commandEncoder.copyTextureToTexture(copySrc, copyDst, copySize); + } + if (depth) { + const sourceRT = source ? source : this.renderTarget; + const sourceTexture = sourceRT.impl.depthTexture; + if (source.samples > 1) { + const destTexture = dest.colorBuffer.impl.gpuTexture; + this.resolver.resolveDepth(commandEncoder, sourceTexture, destTexture); + } else { + const destTexture = dest ? dest.depthBuffer.impl.gpuTexture : this.renderTarget.impl.depthTexture; + const copySrc = { + texture: sourceTexture, + mipLevel: 0 + }; + const copyDst = { + texture: destTexture, + mipLevel: 0 + }; + commandEncoder.copyTextureToTexture(copySrc, copyDst, copySize); + } + } + if (!this.commandEncoder) { + const cb = commandEncoder.finish(); + this.addCommandBuffer(cb); + } + return true; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/texture.js +var id6 = 0; +var Texture = class { + constructor(graphicsDevice, options = {}) { + var _options$name, _options$width, _options$height, _options$format, _options$storage, _options$cubemap, _options$fixCubemapSe, _options$flipY, _options$premultiplyA, _ref4, _options$mipmaps, _options$minFilter, _options$magFilter, _options$anisotropy, _options$addressU, _options$addressV, _options$addressW, _options$compareOnRea, _options$compareFunc; + this.name = void 0; + this._gpuSize = 0; + this.id = id6++; + this._invalid = false; + this._lockedLevel = -1; + this._lockedMode = TEXTURELOCK_NONE; + this.renderVersionDirty = 0; + this._storage = false; + this.device = graphicsDevice; + this.name = (_options$name = options.name) != null ? _options$name : ""; + this._width = Math.floor((_options$width = options.width) != null ? _options$width : 4); + this._height = Math.floor((_options$height = options.height) != null ? _options$height : 4); + this._format = (_options$format = options.format) != null ? _options$format : PIXELFORMAT_RGBA8; + this._compressed = isCompressedPixelFormat(this._format); + this._integerFormat = isIntegerPixelFormat(this._format); + if (this._integerFormat) { + options.mipmaps = false; + options.minFilter = FILTER_NEAREST; + options.magFilter = FILTER_NEAREST; + } + if (graphicsDevice.supportsVolumeTextures) { + var _options$volume, _options$depth, _options$arrayLength; + this._volume = (_options$volume = options.volume) != null ? _options$volume : false; + this._depth = Math.floor((_options$depth = options.depth) != null ? _options$depth : 1); + this._arrayLength = Math.floor((_options$arrayLength = options.arrayLength) != null ? _options$arrayLength : 0); + } else { + this._volume = false; + this._depth = 1; + this._arrayLength = 0; + } + this._storage = (_options$storage = options.storage) != null ? _options$storage : false; + this._cubemap = (_options$cubemap = options.cubemap) != null ? _options$cubemap : false; + this.fixCubemapSeams = (_options$fixCubemapSe = options.fixCubemapSeams) != null ? _options$fixCubemapSe : false; + this._flipY = (_options$flipY = options.flipY) != null ? _options$flipY : false; + this._premultiplyAlpha = (_options$premultiplyA = options.premultiplyAlpha) != null ? _options$premultiplyA : false; + this._mipmaps = (_ref4 = (_options$mipmaps = options.mipmaps) != null ? _options$mipmaps : options.autoMipmap) != null ? _ref4 : true; + this._minFilter = (_options$minFilter = options.minFilter) != null ? _options$minFilter : FILTER_LINEAR_MIPMAP_LINEAR; + this._magFilter = (_options$magFilter = options.magFilter) != null ? _options$magFilter : FILTER_LINEAR; + this._anisotropy = (_options$anisotropy = options.anisotropy) != null ? _options$anisotropy : 1; + this._addressU = (_options$addressU = options.addressU) != null ? _options$addressU : ADDRESS_REPEAT; + this._addressV = (_options$addressV = options.addressV) != null ? _options$addressV : ADDRESS_REPEAT; + this._addressW = (_options$addressW = options.addressW) != null ? _options$addressW : ADDRESS_REPEAT; + this._compareOnRead = (_options$compareOnRea = options.compareOnRead) != null ? _options$compareOnRea : false; + this._compareFunc = (_options$compareFunc = options.compareFunc) != null ? _options$compareFunc : FUNC_LESS; + this.type = TEXTURETYPE_DEFAULT; + if (options.hasOwnProperty("type")) { + this.type = options.type; + } else if (options.hasOwnProperty("rgbm")) { + this.type = options.rgbm ? TEXTURETYPE_RGBM : TEXTURETYPE_DEFAULT; + } else if (options.hasOwnProperty("swizzleGGGR")) { + this.type = options.swizzleGGGR ? TEXTURETYPE_SWIZZLEGGGR : TEXTURETYPE_DEFAULT; + } + this.projection = TEXTUREPROJECTION_NONE; + if (this._cubemap) { + this.projection = TEXTUREPROJECTION_CUBE; + } else if (options.projection && options.projection !== TEXTUREPROJECTION_CUBE) { + this.projection = options.projection; + } + this.impl = graphicsDevice.createTextureImpl(this); + this.dirtyAll(); + this._levels = options.levels; + if (this._levels) { + this.upload(); + } else { + this._levels = this._cubemap ? [[null, null, null, null, null, null]] : [null]; + } + graphicsDevice.textures.push(this); + } + destroy() { + const device = this.device; + if (device) { + const idx = device.textures.indexOf(this); + if (idx !== -1) { + device.textures.splice(idx, 1); + } + device.scope.removeValue(this); + this.impl.destroy(device); + this.adjustVramSizeTracking(device._vram, -this._gpuSize); + this._levels = null; + this.device = null; + } + } + resize(width, height, depth = 1) { + const device = this.device; + this.adjustVramSizeTracking(device._vram, -this._gpuSize); + this.impl.destroy(device); + this._width = Math.floor(width); + this._height = Math.floor(height); + this._depth = Math.floor(depth); + this.impl = device.createTextureImpl(this); + this.dirtyAll(); + } + loseContext() { + this.impl.loseContext(); + this.dirtyAll(); + } + adjustVramSizeTracking(vram, size) { + vram.tex += size; + } + propertyChanged(flag) { + this.impl.propertyChanged(flag); + this.renderVersionDirty = this.device.renderVersion; + } + get requiredMipLevels() { + return this.mipmaps ? TextureUtils.calcMipLevelsCount(this.width, this.height) : 1; + } + get lockedMode() { + return this._lockedMode; + } + set minFilter(v) { + if (this._minFilter !== v) { + if (isIntegerPixelFormat(this._format)) ; + else { + this._minFilter = v; + this.propertyChanged(1); + } + } + } + get minFilter() { + return this._minFilter; + } + set magFilter(v) { + if (this._magFilter !== v) { + if (isIntegerPixelFormat(this._format)) ; + else { + this._magFilter = v; + this.propertyChanged(2); + } + } + } + get magFilter() { + return this._magFilter; + } + set addressU(v) { + if (this._addressU !== v) { + this._addressU = v; + this.propertyChanged(4); + } + } + get addressU() { + return this._addressU; + } + set addressV(v) { + if (this._addressV !== v) { + this._addressV = v; + this.propertyChanged(8); + } + } + get addressV() { + return this._addressV; + } + set addressW(addressW) { + if (!this.device.supportsVolumeTextures) return; + if (!this._volume) { + return; + } + if (addressW !== this._addressW) { + this._addressW = addressW; + this.propertyChanged(16); + } + } + get addressW() { + return this._addressW; + } + set compareOnRead(v) { + if (this._compareOnRead !== v) { + this._compareOnRead = v; + this.propertyChanged(32); + } + } + get compareOnRead() { + return this._compareOnRead; + } + set compareFunc(v) { + if (this._compareFunc !== v) { + this._compareFunc = v; + this.propertyChanged(64); + } + } + get compareFunc() { + return this._compareFunc; + } + set anisotropy(v) { + if (this._anisotropy !== v) { + this._anisotropy = v; + this.propertyChanged(128); + } + } + get anisotropy() { + return this._anisotropy; + } + set mipmaps(v) { + if (this._mipmaps !== v) { + if (this.device.isWebGPU) ; + else if (isIntegerPixelFormat(this._format)) ; + else { + this._mipmaps = v; + } + if (v) this._needsMipmapsUpload = true; + } + } + get mipmaps() { + return this._mipmaps; + } + get storage() { + return this._storage; + } + get width() { + return this._width; + } + get height() { + return this._height; + } + get depth() { + return this._depth; + } + get format() { + return this._format; + } + get cubemap() { + return this._cubemap; + } + get gpuSize() { + const mips = this.pot && this._mipmaps && !(this._compressed && this._levels.length === 1); + return TextureUtils.calcGpuSize(this._width, this._height, this._depth, this._format, mips, this._cubemap); + } + get array() { + return this._arrayLength > 0; + } + get arrayLength() { + return this._arrayLength; + } + get volume() { + return this._volume; + } + set flipY(flipY) { + if (this._flipY !== flipY) { + this._flipY = flipY; + this._needsUpload = true; + } + } + get flipY() { + return this._flipY; + } + set premultiplyAlpha(premultiplyAlpha) { + if (this._premultiplyAlpha !== premultiplyAlpha) { + this._premultiplyAlpha = premultiplyAlpha; + this._needsUpload = true; + } + } + get premultiplyAlpha() { + return this._premultiplyAlpha; + } + get pot() { + return math.powerOfTwo(this._width) && math.powerOfTwo(this._height); + } + get encoding() { + switch (this.type) { + case TEXTURETYPE_RGBM: + return "rgbm"; + case TEXTURETYPE_RGBE: + return "rgbe"; + case TEXTURETYPE_RGBP: + return "rgbp"; + default: + return this.format === PIXELFORMAT_RGB16F || this.format === PIXELFORMAT_RGB32F || this.format === PIXELFORMAT_RGBA16F || this.format === PIXELFORMAT_RGBA32F || isIntegerPixelFormat(this.format) ? "linear" : "srgb"; + } + } + dirtyAll() { + this._levelsUpdated = this._cubemap ? [[true, true, true, true, true, true]] : [true]; + this._needsUpload = true; + this._needsMipmapsUpload = this._mipmaps; + this._mipmapsUploaded = false; + this.propertyChanged(255); + } + lock(options = {}) { + var _options$level, _options$face, _options$mode; + (_options$level = options.level) != null ? _options$level : options.level = 0; + (_options$face = options.face) != null ? _options$face : options.face = 0; + (_options$mode = options.mode) != null ? _options$mode : options.mode = TEXTURELOCK_WRITE; + this._lockedMode = options.mode; + this._lockedLevel = options.level; + const levels = this.cubemap ? this._levels[options.face] : this._levels; + if (levels[options.level] === null) { + const width = Math.max(1, this._width >> options.level); + const height = Math.max(1, this._height >> options.level); + const depth = Math.max(1, this._depth >> options.level); + const data2 = new ArrayBuffer(TextureUtils.calcLevelGpuSize(width, height, depth, this._format)); + levels[options.level] = new (getPixelFormatArrayType(this._format))(data2); + } + return levels[options.level]; + } + setSource(source, mipLevel = 0) { + let invalid = false; + let width, height; + if (this._cubemap) { + if (source[0]) { + width = source[0].width || 0; + height = source[0].height || 0; + for (let i = 0; i < 6; i++) { + const face = source[i]; + if (!face || face.width !== width || face.height !== height || !this.device._isBrowserInterface(face)) { + invalid = true; + break; + } + } + } else { + invalid = true; + } + if (!invalid) { + for (let i = 0; i < 6; i++) { + if (this._levels[mipLevel][i] !== source[i]) this._levelsUpdated[mipLevel][i] = true; + } + } + } else { + if (!this.device._isBrowserInterface(source)) invalid = true; + if (!invalid) { + if (source !== this._levels[mipLevel]) this._levelsUpdated[mipLevel] = true; + width = source.width; + height = source.height; + } + } + if (invalid) { + this._width = 4; + this._height = 4; + if (this._cubemap) { + for (let i = 0; i < 6; i++) { + this._levels[mipLevel][i] = null; + this._levelsUpdated[mipLevel][i] = true; + } + } else { + this._levels[mipLevel] = null; + this._levelsUpdated[mipLevel] = true; + } + } else { + if (mipLevel === 0) { + this._width = width; + this._height = height; + } + this._levels[mipLevel] = source; + } + if (this._invalid !== invalid || !invalid) { + this._invalid = invalid; + this.upload(); + } + } + getSource(mipLevel = 0) { + return this._levels[mipLevel]; + } + unlock() { + if (this._lockedMode === TEXTURELOCK_NONE) ; + if (this._lockedMode === TEXTURELOCK_WRITE) { + this.upload(); + } + this._lockedLevel = -1; + this._lockedMode = TEXTURELOCK_NONE; + } + upload() { + var _this$impl$uploadImme, _this$impl; + this._needsUpload = true; + this._needsMipmapsUpload = this._mipmaps; + (_this$impl$uploadImme = (_this$impl = this.impl).uploadImmediate) == null || _this$impl$uploadImme.call(_this$impl, this.device, this); + } + async downloadAsync() { + const promises = []; + for (let i = 0; i < (this.cubemap ? 6 : 1); i++) { + var _this$device$readPixe, _this$device; + const renderTarget = new RenderTarget({ + colorBuffer: this, + depth: false, + face: i + }); + this.device.setRenderTarget(renderTarget); + this.device.initRenderTarget(renderTarget); + const levels = this.cubemap ? this._levels[i] : this._levels; + let level = levels[0]; + if (levels[0] && this.device._isBrowserInterface(levels[0])) { + levels[0] = null; + } + level = this.lock({ + face: i + }); + const promise = (_this$device$readPixe = (_this$device = this.device).readPixelsAsync) == null ? void 0 : _this$device$readPixe.call(_this$device, 0, 0, this.width, this.height, level).then(() => renderTarget.destroy()); + promises.push(promise); + } + await Promise.all(promises); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgl/webgl-buffer.js +var WebglBuffer = class { + constructor() { + this.bufferId = null; + } + destroy(device) { + if (this.bufferId) { + device.gl.deleteBuffer(this.bufferId); + this.bufferId = null; + } + } + get initialized() { + return !!this.bufferId; + } + loseContext() { + this.bufferId = null; + } + unlock(device, usage, target2, storage) { + const gl = device.gl; + if (!this.bufferId) { + let glUsage; + switch (usage) { + case BUFFER_STATIC: + glUsage = gl.STATIC_DRAW; + break; + case BUFFER_DYNAMIC: + glUsage = gl.DYNAMIC_DRAW; + break; + case BUFFER_STREAM: + glUsage = gl.STREAM_DRAW; + break; + case BUFFER_GPUDYNAMIC: + glUsage = device.isWebGL2 ? gl.DYNAMIC_COPY : gl.STATIC_DRAW; + break; + } + this.bufferId = gl.createBuffer(); + gl.bindBuffer(target2, this.bufferId); + gl.bufferData(target2, storage, glUsage); + } else { + gl.bindBuffer(target2, this.bufferId); + gl.bufferSubData(target2, 0, storage); + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgl/webgl-vertex-buffer.js +var WebglVertexBuffer = class extends WebglBuffer { + constructor(...args) { + super(...args); + this.vao = null; + } + destroy(device) { + super.destroy(device); + device.unbindVertexArray(); + } + loseContext() { + super.loseContext(); + this.vao = null; + } + unlock(vertexBuffer) { + const device = vertexBuffer.device; + super.unlock(device, vertexBuffer.usage, device.gl.ARRAY_BUFFER, vertexBuffer.storage); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgl/webgl-index-buffer.js +var WebglIndexBuffer = class extends WebglBuffer { + constructor(indexBuffer) { + super(); + const gl = indexBuffer.device.gl; + const format = indexBuffer.format; + if (format === INDEXFORMAT_UINT8) { + this.glFormat = gl.UNSIGNED_BYTE; + } else if (format === INDEXFORMAT_UINT16) { + this.glFormat = gl.UNSIGNED_SHORT; + } else if (format === INDEXFORMAT_UINT32) { + this.glFormat = gl.UNSIGNED_INT; + } + } + unlock(indexBuffer) { + const device = indexBuffer.device; + super.unlock(device, indexBuffer.usage, device.gl.ELEMENT_ARRAY_BUFFER, indexBuffer.storage); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgl/webgl-shader-input.js +var WebglShaderInput = class { + constructor(graphicsDevice, name, type2, locationId) { + this.locationId = locationId; + this.scopeId = graphicsDevice.scope.resolve(name); + this.version = new Version(); + if (name.substring(name.length - 3) === "[0]") { + switch (type2) { + case UNIFORMTYPE_FLOAT: + type2 = UNIFORMTYPE_FLOATARRAY; + break; + case UNIFORMTYPE_INT: + type2 = UNIFORMTYPE_INTARRAY; + break; + case UNIFORMTYPE_UINT: + type2 = UNIFORMTYPE_UINTARRAY; + break; + case UNIFORMTYPE_BOOL: + type2 = UNIFORMTYPE_BOOLARRAY; + break; + case UNIFORMTYPE_VEC2: + type2 = UNIFORMTYPE_VEC2ARRAY; + break; + case UNIFORMTYPE_IVEC2: + type2 = UNIFORMTYPE_IVEC2ARRAY; + break; + case UNIFORMTYPE_UVEC2: + type2 = UNIFORMTYPE_UVEC2ARRAY; + break; + case UNIFORMTYPE_BVEC2: + type2 = UNIFORMTYPE_BVEC2ARRAY; + break; + case UNIFORMTYPE_VEC3: + type2 = UNIFORMTYPE_VEC3ARRAY; + break; + case UNIFORMTYPE_IVEC3: + type2 = UNIFORMTYPE_IVEC3ARRAY; + break; + case UNIFORMTYPE_UVEC3: + type2 = UNIFORMTYPE_UVEC3ARRAY; + break; + case UNIFORMTYPE_BVEC3: + type2 = UNIFORMTYPE_BVEC3ARRAY; + break; + case UNIFORMTYPE_VEC4: + type2 = UNIFORMTYPE_VEC4ARRAY; + break; + case UNIFORMTYPE_IVEC4: + type2 = UNIFORMTYPE_IVEC4ARRAY; + break; + case UNIFORMTYPE_UVEC4: + type2 = UNIFORMTYPE_UVEC4ARRAY; + break; + case UNIFORMTYPE_BVEC4: + type2 = UNIFORMTYPE_BVEC4ARRAY; + break; + } + } + this.dataType = type2; + this.value = [null, null, null, null]; + this.array = []; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgl/webgl-shader.js +var _vertexShaderBuiltins = /* @__PURE__ */ new Set(["gl_VertexID", "gl_InstanceID", "gl_DrawID", "gl_BaseVertex", "gl_BaseInstance"]); +var CompiledShaderCache = class { + constructor() { + this.map = /* @__PURE__ */ new Map(); + } + destroy(device) { + this.map.forEach((shader) => { + device.gl.deleteShader(shader); + }); + } + loseContext(device) { + this.map.clear(); + } +}; +var _vertexShaderCache = new DeviceCache(); +var _fragmentShaderCache = new DeviceCache(); +var WebglShader = class { + constructor(shader) { + this.compileDuration = 0; + this.init(); + this.compile(shader.device, shader); + this.link(shader.device, shader); + shader.device.shaders.push(shader); + } + destroy(shader) { + if (this.glProgram) { + shader.device.gl.deleteProgram(this.glProgram); + this.glProgram = null; + } + } + init() { + this.uniforms = []; + this.samplers = []; + this.attributes = []; + this.glProgram = null; + this.glVertexShader = null; + this.glFragmentShader = null; + } + loseContext() { + this.init(); + } + restoreContext(device, shader) { + this.compile(device, shader); + this.link(device, shader); + } + compile(device, shader) { + const definition = shader.definition; + this.glVertexShader = this._compileShaderSource(device, definition.vshader, true); + this.glFragmentShader = this._compileShaderSource(device, definition.fshader, false); + } + link(device, shader) { + if (this.glProgram) return; + const gl = device.gl; + if (gl.isContextLost()) { + return; + } + const glProgram = gl.createProgram(); + this.glProgram = glProgram; + gl.attachShader(glProgram, this.glVertexShader); + gl.attachShader(glProgram, this.glFragmentShader); + const definition = shader.definition; + const attrs = definition.attributes; + if (device.isWebGL2 && definition.useTransformFeedback) { + const outNames = []; + for (const attr in attrs) { + if (attrs.hasOwnProperty(attr)) { + outNames.push("out_" + attr); + } + } + gl.transformFeedbackVaryings(glProgram, outNames, gl.INTERLEAVED_ATTRIBS); + } + for (const attr in attrs) { + if (attrs.hasOwnProperty(attr)) { + const semantic = attrs[attr]; + const loc = semanticToLocation[semantic]; + gl.bindAttribLocation(glProgram, loc, attr); + } + } + gl.linkProgram(glProgram); + } + _compileShaderSource(device, src, isVertexShader) { + const gl = device.gl; + const shaderDeviceCache = isVertexShader ? _vertexShaderCache : _fragmentShaderCache; + const shaderCache = shaderDeviceCache.get(device, () => { + return new CompiledShaderCache(); + }); + let glShader = shaderCache.map.get(src); + if (!glShader) { + glShader = gl.createShader(isVertexShader ? gl.VERTEX_SHADER : gl.FRAGMENT_SHADER); + if (!glShader && gl.isContextLost()) { + return glShader; + } + gl.shaderSource(glShader, src); + gl.compileShader(glShader); + shaderCache.map.set(src, glShader); + } + return glShader; + } + finalize(device, shader) { + const gl = device.gl; + if (gl.isContextLost()) { + return true; + } + const glProgram = this.glProgram; + const definition = shader.definition; + const linkStatus = gl.getProgramParameter(glProgram, gl.LINK_STATUS); + if (!linkStatus) { + if (!this._isCompiled(device, shader, this.glVertexShader, definition.vshader, "vertex")) return false; + if (!this._isCompiled(device, shader, this.glFragmentShader, definition.fshader, "fragment")) return false; + const message = "Failed to link shader program. Error: " + gl.getProgramInfoLog(glProgram); + console.error(message); + return false; + } + const numAttributes = gl.getProgramParameter(glProgram, gl.ACTIVE_ATTRIBUTES); + for (let i = 0; i < numAttributes; i++) { + const info = gl.getActiveAttrib(glProgram, i); + const location = gl.getAttribLocation(glProgram, info.name); + if (_vertexShaderBuiltins.has(info.name)) continue; + if (definition.attributes[info.name] === void 0) { + console.error(`Vertex shader attribute "${info.name}" is not mapped to a semantic in shader definition, shader [${shader.label}]`, shader); + shader.failed = true; + } else { + const shaderInput = new WebglShaderInput(device, definition.attributes[info.name], device.pcUniformType[info.type], location); + this.attributes.push(shaderInput); + } + } + const samplerTypes2 = device._samplerTypes; + const numUniforms = gl.getProgramParameter(glProgram, gl.ACTIVE_UNIFORMS); + for (let i = 0; i < numUniforms; i++) { + const info = gl.getActiveUniform(glProgram, i); + const location = gl.getUniformLocation(glProgram, info.name); + const shaderInput = new WebglShaderInput(device, info.name, device.pcUniformType[info.type], location); + if (samplerTypes2.has(info.type)) { + this.samplers.push(shaderInput); + } else { + this.uniforms.push(shaderInput); + } + } + shader.ready = true; + return true; + } + _isCompiled(device, shader, glShader, source, shaderType) { + const gl = device.gl; + if (!gl.getShaderParameter(glShader, gl.COMPILE_STATUS)) { + const infoLog = gl.getShaderInfoLog(glShader); + const [code, error] = this._processError(source, infoLog); + const message = `Failed to compile ${shaderType} shader: + +${infoLog} +${code} while rendering ${void 0}`; + console.error(message); + return false; + } + return true; + } + isLinked(device) { + const { + extParallelShaderCompile + } = device; + if (extParallelShaderCompile) { + return device.gl.getProgramParameter(this.glProgram, extParallelShaderCompile.COMPLETION_STATUS_KHR); + } + return true; + } + _processError(src, infoLog) { + const error = {}; + let code = ""; + if (src) { + const lines = src.split("\n"); + let from = 0; + let to = lines.length; + if (infoLog && infoLog.startsWith("ERROR:")) { + const match = infoLog.match(/^ERROR:\s([0-9]+):([0-9]+):\s*(.+)/); + if (match) { + error.message = match[3]; + error.line = parseInt(match[2], 10); + from = Math.max(0, error.line - 6); + to = Math.min(lines.length, error.line + 5); + } + } + for (let i = from; i < to; i++) { + code += i + 1 + ": " + lines[i] + "\n"; + } + error.source = src; + } + return [code, error]; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgl/webgl-texture.js +function downsampleImage(image, size) { + const srcW = image.width; + const srcH = image.height; + if (srcW > size || srcH > size) { + const scale2 = size / Math.max(srcW, srcH); + const dstW = Math.floor(srcW * scale2); + const dstH = Math.floor(srcH * scale2); + const canvas = document.createElement("canvas"); + canvas.width = dstW; + canvas.height = dstH; + const context = canvas.getContext("2d"); + context.drawImage(image, 0, 0, srcW, srcH, 0, 0, dstW, dstH); + return canvas; + } + return image; +} +var WebglTexture = class { + constructor() { + this._glTexture = null; + this._glTarget = void 0; + this._glFormat = void 0; + this._glInternalFormat = void 0; + this._glPixelType = void 0; + this._glCreated = void 0; + this.dirtyParameterFlags = 0; + } + destroy(device) { + if (this._glTexture) { + for (let i = 0; i < device.textureUnits.length; i++) { + const textureUnit = device.textureUnits[i]; + for (let j = 0; j < textureUnit.length; j++) { + if (textureUnit[j] === this._glTexture) { + textureUnit[j] = null; + } + } + } + device.gl.deleteTexture(this._glTexture); + this._glTexture = null; + } + } + loseContext() { + this._glTexture = null; + } + propertyChanged(flag) { + this.dirtyParameterFlags |= flag; + } + initialize(device, texture) { + const gl = device.gl; + this._glTexture = gl.createTexture(); + this._glTarget = texture._cubemap ? gl.TEXTURE_CUBE_MAP : texture._volume ? gl.TEXTURE_3D : texture.array ? gl.TEXTURE_2D_ARRAY : gl.TEXTURE_2D; + switch (texture._format) { + case PIXELFORMAT_A8: + this._glFormat = gl.ALPHA; + this._glInternalFormat = gl.ALPHA; + this._glPixelType = gl.UNSIGNED_BYTE; + break; + case PIXELFORMAT_L8: + this._glFormat = gl.LUMINANCE; + this._glInternalFormat = gl.LUMINANCE; + this._glPixelType = gl.UNSIGNED_BYTE; + break; + case PIXELFORMAT_LA8: + this._glFormat = gl.LUMINANCE_ALPHA; + this._glInternalFormat = gl.LUMINANCE_ALPHA; + this._glPixelType = gl.UNSIGNED_BYTE; + break; + case PIXELFORMAT_RGB565: + this._glFormat = gl.RGB; + this._glInternalFormat = gl.RGB; + this._glPixelType = gl.UNSIGNED_SHORT_5_6_5; + break; + case PIXELFORMAT_RGBA5551: + this._glFormat = gl.RGBA; + this._glInternalFormat = gl.RGBA; + this._glPixelType = gl.UNSIGNED_SHORT_5_5_5_1; + break; + case PIXELFORMAT_RGBA4: + this._glFormat = gl.RGBA; + this._glInternalFormat = gl.RGBA; + this._glPixelType = gl.UNSIGNED_SHORT_4_4_4_4; + break; + case PIXELFORMAT_RGB8: + this._glFormat = gl.RGB; + this._glInternalFormat = device.isWebGL2 ? gl.RGB8 : gl.RGB; + this._glPixelType = gl.UNSIGNED_BYTE; + break; + case PIXELFORMAT_RGBA8: + this._glFormat = gl.RGBA; + this._glInternalFormat = device.isWebGL2 ? gl.RGBA8 : gl.RGBA; + this._glPixelType = gl.UNSIGNED_BYTE; + break; + case PIXELFORMAT_DXT1: + this._glFormat = gl.RGB; + this._glInternalFormat = device.extCompressedTextureS3TC.COMPRESSED_RGB_S3TC_DXT1_EXT; + break; + case PIXELFORMAT_DXT3: + this._glFormat = gl.RGBA; + this._glInternalFormat = device.extCompressedTextureS3TC.COMPRESSED_RGBA_S3TC_DXT3_EXT; + break; + case PIXELFORMAT_DXT5: + this._glFormat = gl.RGBA; + this._glInternalFormat = device.extCompressedTextureS3TC.COMPRESSED_RGBA_S3TC_DXT5_EXT; + break; + case PIXELFORMAT_ETC1: + this._glFormat = gl.RGB; + this._glInternalFormat = device.extCompressedTextureETC1.COMPRESSED_RGB_ETC1_WEBGL; + break; + case PIXELFORMAT_PVRTC_2BPP_RGB_1: + this._glFormat = gl.RGB; + this._glInternalFormat = device.extCompressedTexturePVRTC.COMPRESSED_RGB_PVRTC_2BPPV1_IMG; + break; + case PIXELFORMAT_PVRTC_2BPP_RGBA_1: + this._glFormat = gl.RGBA; + this._glInternalFormat = device.extCompressedTexturePVRTC.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG; + break; + case PIXELFORMAT_PVRTC_4BPP_RGB_1: + this._glFormat = gl.RGB; + this._glInternalFormat = device.extCompressedTexturePVRTC.COMPRESSED_RGB_PVRTC_4BPPV1_IMG; + break; + case PIXELFORMAT_PVRTC_4BPP_RGBA_1: + this._glFormat = gl.RGBA; + this._glInternalFormat = device.extCompressedTexturePVRTC.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG; + break; + case PIXELFORMAT_ETC2_RGB: + this._glFormat = gl.RGB; + this._glInternalFormat = device.extCompressedTextureETC.COMPRESSED_RGB8_ETC2; + break; + case PIXELFORMAT_ETC2_RGBA: + this._glFormat = gl.RGBA; + this._glInternalFormat = device.extCompressedTextureETC.COMPRESSED_RGBA8_ETC2_EAC; + break; + case PIXELFORMAT_ASTC_4x4: + this._glFormat = gl.RGBA; + this._glInternalFormat = device.extCompressedTextureASTC.COMPRESSED_RGBA_ASTC_4x4_KHR; + break; + case PIXELFORMAT_ATC_RGB: + this._glFormat = gl.RGB; + this._glInternalFormat = device.extCompressedTextureATC.COMPRESSED_RGB_ATC_WEBGL; + break; + case PIXELFORMAT_ATC_RGBA: + this._glFormat = gl.RGBA; + this._glInternalFormat = device.extCompressedTextureATC.COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL; + break; + case PIXELFORMAT_R16F: + if (device.isWebGL2) { + this._glFormat = gl.RED; + this._glInternalFormat = gl.R16F; + this._glPixelType = gl.HALF_FLOAT; + } else { + this._glFormat = gl.LUMINANCE; + this._glInternalFormat = gl.LUMINANCE; + this._glPixelType = device.extTextureHalfFloat.HALF_FLOAT_OES; + } + break; + case PIXELFORMAT_RG16F: + if (device.isWebGL2) { + this._glFormat = gl.RG; + this._glInternalFormat = gl.RG16F; + this._glPixelType = gl.HALF_FLOAT; + } else { + this._glFormat = gl.RG; + this._glInternalFormat = gl.RG; + this._glPixelType = device.extTextureHalfFloat.HALF_FLOAT_OES; + } + break; + case PIXELFORMAT_RGB16F: + this._glFormat = gl.RGB; + if (device.isWebGL2) { + this._glInternalFormat = gl.RGB16F; + this._glPixelType = gl.HALF_FLOAT; + } else { + this._glInternalFormat = gl.RGB; + this._glPixelType = device.extTextureHalfFloat.HALF_FLOAT_OES; + } + break; + case PIXELFORMAT_RGBA16F: + this._glFormat = gl.RGBA; + if (device.isWebGL2) { + this._glInternalFormat = gl.RGBA16F; + this._glPixelType = gl.HALF_FLOAT; + } else { + this._glInternalFormat = gl.RGBA; + this._glPixelType = device.extTextureHalfFloat.HALF_FLOAT_OES; + } + break; + case PIXELFORMAT_RGB32F: + this._glFormat = gl.RGB; + if (device.isWebGL2) { + this._glInternalFormat = gl.RGB32F; + } else { + this._glInternalFormat = gl.RGB; + } + this._glPixelType = gl.FLOAT; + break; + case PIXELFORMAT_RGBA32F: + this._glFormat = gl.RGBA; + if (device.isWebGL2) { + this._glInternalFormat = gl.RGBA32F; + } else { + this._glInternalFormat = gl.RGBA; + } + this._glPixelType = gl.FLOAT; + break; + case PIXELFORMAT_R32F: + this._glFormat = gl.RED; + this._glInternalFormat = gl.R32F; + this._glPixelType = gl.FLOAT; + break; + case PIXELFORMAT_DEPTH: + if (device.isWebGL2) { + this._glFormat = gl.DEPTH_COMPONENT; + this._glInternalFormat = gl.DEPTH_COMPONENT32F; + this._glPixelType = gl.FLOAT; + } else { + this._glFormat = gl.DEPTH_COMPONENT; + this._glInternalFormat = gl.DEPTH_COMPONENT; + this._glPixelType = gl.UNSIGNED_SHORT; + } + break; + case PIXELFORMAT_DEPTHSTENCIL: + this._glFormat = gl.DEPTH_STENCIL; + if (device.isWebGL2) { + this._glInternalFormat = gl.DEPTH24_STENCIL8; + this._glPixelType = gl.UNSIGNED_INT_24_8; + } else { + this._glInternalFormat = gl.DEPTH_STENCIL; + this._glPixelType = device.extDepthTexture.UNSIGNED_INT_24_8_WEBGL; + } + break; + case PIXELFORMAT_111110F: + this._glFormat = gl.RGB; + this._glInternalFormat = gl.R11F_G11F_B10F; + this._glPixelType = gl.UNSIGNED_INT_10F_11F_11F_REV; + break; + case PIXELFORMAT_SRGB: + this._glFormat = gl.RGB; + this._glInternalFormat = gl.SRGB8; + this._glPixelType = gl.UNSIGNED_BYTE; + break; + case PIXELFORMAT_SRGBA: + this._glFormat = gl.RGBA; + this._glInternalFormat = gl.SRGB8_ALPHA8; + this._glPixelType = gl.UNSIGNED_BYTE; + break; + case PIXELFORMAT_R8I: + this._glFormat = gl.RED_INTEGER; + this._glInternalFormat = gl.R8I; + this._glPixelType = gl.BYTE; + break; + case PIXELFORMAT_R8U: + this._glFormat = gl.RED_INTEGER; + this._glInternalFormat = gl.R8UI; + this._glPixelType = gl.UNSIGNED_BYTE; + break; + case PIXELFORMAT_R16I: + this._glFormat = gl.RED_INTEGER; + this._glInternalFormat = gl.R16I; + this._glPixelType = gl.SHORT; + break; + case PIXELFORMAT_R16U: + this._glFormat = gl.RED_INTEGER; + this._glInternalFormat = gl.R16UI; + this._glPixelType = gl.UNSIGNED_SHORT; + break; + case PIXELFORMAT_R32I: + this._glFormat = gl.RED_INTEGER; + this._glInternalFormat = gl.R32I; + this._glPixelType = gl.INT; + break; + case PIXELFORMAT_R32U: + this._glFormat = gl.RED_INTEGER; + this._glInternalFormat = gl.R32UI; + this._glPixelType = gl.UNSIGNED_INT; + break; + case PIXELFORMAT_RG8I: + this._glFormat = gl.RG_INTEGER; + this._glInternalFormat = gl.RG8I; + this._glPixelType = gl.BYTE; + break; + case PIXELFORMAT_RG8U: + this._glFormat = gl.RG_INTEGER; + this._glInternalFormat = gl.RG8UI; + this._glPixelType = gl.UNSIGNED_BYTE; + break; + case PIXELFORMAT_RG16I: + this._glFormat = gl.RG_INTEGER; + this._glInternalFormat = gl.RG16I; + this._glPixelType = gl.SHORT; + break; + case PIXELFORMAT_RG16U: + this._glFormat = gl.RG_INTEGER; + this._glInternalFormat = gl.RG16UI; + this._glPixelType = gl.UNSIGNED_SHORT; + break; + case PIXELFORMAT_RG32I: + this._glFormat = gl.RG_INTEGER; + this._glInternalFormat = gl.RG32I; + this._glPixelType = gl.INT; + break; + case PIXELFORMAT_RG32U: + this._glFormat = gl.RG_INTEGER; + this._glInternalFormat = gl.RG32UI; + this._glPixelType = gl.UNSIGNED_INT; + break; + case PIXELFORMAT_RGBA8I: + this._glFormat = gl.RGBA_INTEGER; + this._glInternalFormat = gl.RGBA8I; + this._glPixelType = gl.BYTE; + break; + case PIXELFORMAT_RGBA8U: + this._glFormat = gl.RGBA_INTEGER; + this._glInternalFormat = gl.RGBA8UI; + this._glPixelType = gl.UNSIGNED_BYTE; + break; + case PIXELFORMAT_RGBA16I: + this._glFormat = gl.RGBA_INTEGER; + this._glInternalFormat = gl.RGBA16I; + this._glPixelType = gl.SHORT; + break; + case PIXELFORMAT_RGBA16U: + this._glFormat = gl.RGBA_INTEGER; + this._glInternalFormat = gl.RGBA16UI; + this._glPixelType = gl.UNSIGNED_SHORT; + break; + case PIXELFORMAT_RGBA32I: + this._glFormat = gl.RGBA_INTEGER; + this._glInternalFormat = gl.RGBA32I; + this._glPixelType = gl.INT; + break; + case PIXELFORMAT_RGBA32U: + this._glFormat = gl.RGBA_INTEGER; + this._glInternalFormat = gl.RGBA32UI; + this._glPixelType = gl.UNSIGNED_INT; + break; + } + this._glCreated = false; + } + upload(device, texture) { + const gl = device.gl; + if (!texture._needsUpload && (texture._needsMipmapsUpload && texture._mipmapsUploaded || !texture.pot)) return; + let mipLevel = 0; + let mipObject; + let resMult; + const requiredMipLevels = texture.requiredMipLevels; + if (texture.array) { + gl.texStorage3D(gl.TEXTURE_2D_ARRAY, requiredMipLevels, this._glInternalFormat, texture._width, texture._height, texture._arrayLength); + } + while (texture._levels[mipLevel] || mipLevel === 0) { + if (!texture._needsUpload && mipLevel === 0) { + mipLevel++; + continue; + } else if (mipLevel && (!texture._needsMipmapsUpload || !texture._mipmaps)) { + break; + } + mipObject = texture._levels[mipLevel]; + resMult = 1 / Math.pow(2, mipLevel); + if (mipLevel === 1 && !texture._compressed && !texture._integerFormat && texture._levels.length < requiredMipLevels) { + gl.generateMipmap(this._glTarget); + texture._mipmapsUploaded = true; + } + if (texture._cubemap) { + let face; + if (device._isBrowserInterface(mipObject[0])) { + for (face = 0; face < 6; face++) { + if (!texture._levelsUpdated[0][face]) continue; + let src = mipObject[face]; + if (device._isImageBrowserInterface(src)) { + if (src.width > device.maxCubeMapSize || src.height > device.maxCubeMapSize) { + src = downsampleImage(src, device.maxCubeMapSize); + if (mipLevel === 0) { + texture._width = src.width; + texture._height = src.height; + } + } + } + device.setUnpackFlipY(false); + device.setUnpackPremultiplyAlpha(texture._premultiplyAlpha); + if (this._glCreated) { + gl.texSubImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + face, mipLevel, 0, 0, this._glFormat, this._glPixelType, src); + } else { + gl.texImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + face, mipLevel, this._glInternalFormat, this._glFormat, this._glPixelType, src); + } + } + } else { + resMult = 1 / Math.pow(2, mipLevel); + for (face = 0; face < 6; face++) { + if (!texture._levelsUpdated[0][face]) continue; + const texData = mipObject[face]; + if (texture._compressed) { + if (this._glCreated && texData) { + gl.compressedTexSubImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + face, mipLevel, 0, 0, Math.max(texture._width * resMult, 1), Math.max(texture._height * resMult, 1), this._glInternalFormat, texData); + } else { + gl.compressedTexImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + face, mipLevel, this._glInternalFormat, Math.max(texture._width * resMult, 1), Math.max(texture._height * resMult, 1), 0, texData); + } + } else { + device.setUnpackFlipY(false); + device.setUnpackPremultiplyAlpha(texture._premultiplyAlpha); + if (this._glCreated && texData) { + gl.texSubImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + face, mipLevel, 0, 0, Math.max(texture._width * resMult, 1), Math.max(texture._height * resMult, 1), this._glFormat, this._glPixelType, texData); + } else { + gl.texImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + face, mipLevel, this._glInternalFormat, Math.max(texture._width * resMult, 1), Math.max(texture._height * resMult, 1), 0, this._glFormat, this._glPixelType, texData); + } + } + } + } + } else if (texture._volume) { + if (texture._compressed) { + gl.compressedTexImage3D(gl.TEXTURE_3D, mipLevel, this._glInternalFormat, Math.max(texture._width * resMult, 1), Math.max(texture._height * resMult, 1), Math.max(texture._depth * resMult, 1), 0, mipObject); + } else { + device.setUnpackFlipY(false); + device.setUnpackPremultiplyAlpha(texture._premultiplyAlpha); + gl.texImage3D(gl.TEXTURE_3D, mipLevel, this._glInternalFormat, Math.max(texture._width * resMult, 1), Math.max(texture._height * resMult, 1), Math.max(texture._depth * resMult, 1), 0, this._glFormat, this._glPixelType, mipObject); + } + } else if (texture.array && typeof mipObject === "object") { + if (texture._arrayLength === mipObject.length) { + if (texture._compressed) { + for (let index = 0; index < texture._arrayLength; index++) { + gl.compressedTexSubImage3D(gl.TEXTURE_2D_ARRAY, mipLevel, 0, 0, index, Math.max(Math.floor(texture._width * resMult), 1), Math.max(Math.floor(texture._height * resMult), 1), 1, this._glFormat, mipObject[index]); + } + } else { + for (let index = 0; index < texture._arrayLength; index++) { + gl.texSubImage3D(gl.TEXTURE_2D_ARRAY, mipLevel, 0, 0, index, Math.max(Math.floor(texture._width * resMult), 1), Math.max(Math.floor(texture._height * resMult), 1), 1, this._glFormat, this._glPixelType, mipObject[index]); + } + } + } + } else { + if (device._isBrowserInterface(mipObject)) { + if (device._isImageBrowserInterface(mipObject)) { + if (mipObject.width > device.maxTextureSize || mipObject.height > device.maxTextureSize) { + mipObject = downsampleImage(mipObject, device.maxTextureSize); + if (mipLevel === 0) { + texture._width = mipObject.width; + texture._height = mipObject.height; + } + } + } + const w = mipObject.width || mipObject.videoWidth; + const h = mipObject.height || mipObject.videoHeight; + device.setUnpackFlipY(texture._flipY); + device.setUnpackPremultiplyAlpha(texture._premultiplyAlpha); + if (this._glCreated && texture._width === w && texture._height === h && !device._isImageVideoInterface(mipObject)) { + gl.texSubImage2D(gl.TEXTURE_2D, mipLevel, 0, 0, this._glFormat, this._glPixelType, mipObject); + } else { + gl.texImage2D(gl.TEXTURE_2D, mipLevel, this._glInternalFormat, this._glFormat, this._glPixelType, mipObject); + if (mipLevel === 0) { + texture._width = w; + texture._height = h; + } + } + } else { + resMult = 1 / Math.pow(2, mipLevel); + if (texture._compressed) { + if (this._glCreated && mipObject) { + gl.compressedTexSubImage2D(gl.TEXTURE_2D, mipLevel, 0, 0, Math.max(Math.floor(texture._width * resMult), 1), Math.max(Math.floor(texture._height * resMult), 1), this._glInternalFormat, mipObject); + } else { + gl.compressedTexImage2D(gl.TEXTURE_2D, mipLevel, this._glInternalFormat, Math.max(Math.floor(texture._width * resMult), 1), Math.max(Math.floor(texture._height * resMult), 1), 0, mipObject); + } + } else { + device.setUnpackFlipY(false); + device.setUnpackPremultiplyAlpha(texture._premultiplyAlpha); + if (this._glCreated && mipObject) { + gl.texSubImage2D(gl.TEXTURE_2D, mipLevel, 0, 0, Math.max(texture._width * resMult, 1), Math.max(texture._height * resMult, 1), this._glFormat, this._glPixelType, mipObject); + } else { + gl.texImage2D(gl.TEXTURE_2D, mipLevel, this._glInternalFormat, Math.max(texture._width * resMult, 1), Math.max(texture._height * resMult, 1), 0, this._glFormat, this._glPixelType, mipObject); + } + } + } + if (mipLevel === 0) { + texture._mipmapsUploaded = false; + } else { + texture._mipmapsUploaded = true; + } + } + mipLevel++; + } + if (texture._needsUpload) { + if (texture._cubemap) { + for (let i = 0; i < 6; i++) texture._levelsUpdated[0][i] = false; + } else { + texture._levelsUpdated[0] = false; + } + } + if (!texture._compressed && !texture._integerFormat && texture._mipmaps && texture._needsMipmapsUpload && (texture.pot || device.isWebGL2) && texture._levels.length === 1) { + gl.generateMipmap(this._glTarget); + texture._mipmapsUploaded = true; + } + if (texture._gpuSize) { + texture.adjustVramSizeTracking(device._vram, -texture._gpuSize); + } + texture._gpuSize = texture.gpuSize; + texture.adjustVramSizeTracking(device._vram, texture._gpuSize); + this._glCreated = true; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgl/webgl-render-target.js +var FramebufferPair = class { + constructor(msaaFB, resolveFB) { + this.msaaFB = void 0; + this.resolveFB = void 0; + this.msaaFB = msaaFB; + this.resolveFB = resolveFB; + } + destroy(gl) { + if (this.msaaFB) { + gl.deleteRenderbuffer(this.msaaFB); + this.msaaFB = null; + } + if (this.resolveFB) { + gl.deleteRenderbuffer(this.resolveFB); + this.resolveFB = null; + } + } +}; +var WebglRenderTarget = class { + constructor() { + this._glFrameBuffer = null; + this._glDepthBuffer = null; + this._glResolveFrameBuffer = null; + this.colorMrtFramebuffers = null; + this._glMsaaColorBuffers = []; + this._glMsaaDepthBuffer = null; + this.suppliedColorFramebuffer = void 0; + this._isInitialized = false; + } + destroy(device) { + var _this$colorMrtFramebu; + const gl = device.gl; + this._isInitialized = false; + if (this._glFrameBuffer) { + if (this._glFrameBuffer !== this.suppliedColorFramebuffer) gl.deleteFramebuffer(this._glFrameBuffer); + this._glFrameBuffer = null; + } + if (this._glDepthBuffer) { + gl.deleteRenderbuffer(this._glDepthBuffer); + this._glDepthBuffer = null; + } + if (this._glResolveFrameBuffer) { + if (this._glResolveFrameBuffer !== this.suppliedColorFramebuffer) gl.deleteFramebuffer(this._glResolveFrameBuffer); + this._glResolveFrameBuffer = null; + } + this._glMsaaColorBuffers.forEach((buffer) => { + gl.deleteRenderbuffer(buffer); + }); + this._glMsaaColorBuffers.length = 0; + (_this$colorMrtFramebu = this.colorMrtFramebuffers) == null || _this$colorMrtFramebu.forEach((framebuffer) => { + framebuffer.destroy(gl); + }); + this.colorMrtFramebuffers = null; + if (this._glMsaaDepthBuffer) { + gl.deleteRenderbuffer(this._glMsaaDepthBuffer); + this._glMsaaDepthBuffer = null; + } + this.suppliedColorFramebuffer = void 0; + } + get initialized() { + return this._isInitialized; + } + init(device, target2) { + const gl = device.gl; + this._isInitialized = true; + const buffers = []; + if (this.suppliedColorFramebuffer !== void 0) { + this._glFrameBuffer = this.suppliedColorFramebuffer; + } else { + var _target$_colorBuffers, _target$_colorBuffers2, _device$extDrawBuffer, _device$extDrawBuffer2; + this._glFrameBuffer = gl.createFramebuffer(); + device.setFramebuffer(this._glFrameBuffer); + const colorBufferCount = (_target$_colorBuffers = (_target$_colorBuffers2 = target2._colorBuffers) == null ? void 0 : _target$_colorBuffers2.length) != null ? _target$_colorBuffers : 0; + const attachmentBaseConstant = device.isWebGL2 ? gl.COLOR_ATTACHMENT0 : (_device$extDrawBuffer = (_device$extDrawBuffer2 = device.extDrawBuffers) == null ? void 0 : _device$extDrawBuffer2.COLOR_ATTACHMENT0_WEBGL) != null ? _device$extDrawBuffer : gl.COLOR_ATTACHMENT0; + for (let i = 0; i < colorBufferCount; ++i) { + const colorBuffer = target2.getColorBuffer(i); + if (colorBuffer) { + if (!colorBuffer.impl._glTexture) { + colorBuffer._width = Math.min(colorBuffer.width, device.maxRenderBufferSize); + colorBuffer._height = Math.min(colorBuffer.height, device.maxRenderBufferSize); + device.setTexture(colorBuffer, 0); + } + gl.framebufferTexture2D(gl.FRAMEBUFFER, attachmentBaseConstant + i, colorBuffer._cubemap ? gl.TEXTURE_CUBE_MAP_POSITIVE_X + target2._face : gl.TEXTURE_2D, colorBuffer.impl._glTexture, 0); + buffers.push(attachmentBaseConstant + i); + } + } + if (device.drawBuffers) { + device.drawBuffers(buffers); + } + const depthBuffer = target2._depthBuffer; + if (depthBuffer) { + if (!depthBuffer.impl._glTexture) { + depthBuffer._width = Math.min(depthBuffer.width, device.maxRenderBufferSize); + depthBuffer._height = Math.min(depthBuffer.height, device.maxRenderBufferSize); + device.setTexture(depthBuffer, 0); + } + if (target2._stencil) { + gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, depthBuffer._cubemap ? gl.TEXTURE_CUBE_MAP_POSITIVE_X + target2._face : gl.TEXTURE_2D, target2._depthBuffer.impl._glTexture, 0); + } else { + gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, depthBuffer._cubemap ? gl.TEXTURE_CUBE_MAP_POSITIVE_X + target2._face : gl.TEXTURE_2D, target2._depthBuffer.impl._glTexture, 0); + } + } else if (target2._depth) { + const willRenderMsaa = target2._samples > 1 && device.isWebGL2; + if (!willRenderMsaa) { + if (!this._glDepthBuffer) { + this._glDepthBuffer = gl.createRenderbuffer(); + } + gl.bindRenderbuffer(gl.RENDERBUFFER, this._glDepthBuffer); + if (target2._stencil) { + gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_STENCIL, target2.width, target2.height); + gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, gl.RENDERBUFFER, this._glDepthBuffer); + } else { + const depthFormat = device.isWebGL2 ? gl.DEPTH_COMPONENT32F : gl.DEPTH_COMPONENT16; + gl.renderbufferStorage(gl.RENDERBUFFER, depthFormat, target2.width, target2.height); + gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, this._glDepthBuffer); + } + gl.bindRenderbuffer(gl.RENDERBUFFER, null); + } + } + } + if (device.isWebGL2 && target2._samples > 1) { + var _target$_colorBuffers3, _target$_colorBuffers4; + this._glResolveFrameBuffer = this._glFrameBuffer; + this._glFrameBuffer = gl.createFramebuffer(); + device.setFramebuffer(this._glFrameBuffer); + const colorBufferCount = (_target$_colorBuffers3 = (_target$_colorBuffers4 = target2._colorBuffers) == null ? void 0 : _target$_colorBuffers4.length) != null ? _target$_colorBuffers3 : 0; + if (this.suppliedColorFramebuffer !== void 0) { + const buffer = gl.createRenderbuffer(); + this._glMsaaColorBuffers.push(buffer); + const internalFormat = device.backBufferFormat === PIXELFORMAT_RGBA8 ? gl.RGBA8 : gl.RGB8; + gl.bindRenderbuffer(gl.RENDERBUFFER, buffer); + gl.renderbufferStorageMultisample(gl.RENDERBUFFER, target2._samples, internalFormat, target2.width, target2.height); + gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, buffer); + } else { + for (let i = 0; i < colorBufferCount; ++i) { + const colorBuffer = target2.getColorBuffer(i); + if (colorBuffer) { + const buffer = gl.createRenderbuffer(); + this._glMsaaColorBuffers.push(buffer); + gl.bindRenderbuffer(gl.RENDERBUFFER, buffer); + gl.renderbufferStorageMultisample(gl.RENDERBUFFER, target2._samples, colorBuffer.impl._glInternalFormat, target2.width, target2.height); + gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + i, gl.RENDERBUFFER, buffer); + } + } + } + if (target2._depth) { + if (!this._glMsaaDepthBuffer) { + this._glMsaaDepthBuffer = gl.createRenderbuffer(); + } + gl.bindRenderbuffer(gl.RENDERBUFFER, this._glMsaaDepthBuffer); + if (target2._stencil) { + gl.renderbufferStorageMultisample(gl.RENDERBUFFER, target2._samples, gl.DEPTH24_STENCIL8, target2.width, target2.height); + gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, gl.RENDERBUFFER, this._glMsaaDepthBuffer); + } else { + gl.renderbufferStorageMultisample(gl.RENDERBUFFER, target2._samples, gl.DEPTH_COMPONENT32F, target2.width, target2.height); + gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, this._glMsaaDepthBuffer); + } + } + if (colorBufferCount > 1) { + this._createMsaaMrtFramebuffers(device, target2, colorBufferCount); + device.setFramebuffer(this._glFrameBuffer); + device.drawBuffers(buffers); + } + } + } + _createMsaaMrtFramebuffers(device, target2, colorBufferCount) { + const gl = device.gl; + this.colorMrtFramebuffers = []; + for (let i = 0; i < colorBufferCount; ++i) { + const colorBuffer = target2.getColorBuffer(i); + const srcFramebuffer = gl.createFramebuffer(); + device.setFramebuffer(srcFramebuffer); + const buffer = this._glMsaaColorBuffers[i]; + gl.bindRenderbuffer(gl.RENDERBUFFER, buffer); + gl.renderbufferStorageMultisample(gl.RENDERBUFFER, target2._samples, colorBuffer.impl._glInternalFormat, target2.width, target2.height); + gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, buffer); + device.drawBuffers([gl.COLOR_ATTACHMENT0]); + const dstFramebuffer = gl.createFramebuffer(); + device.setFramebuffer(dstFramebuffer); + gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, colorBuffer._cubemap ? gl.TEXTURE_CUBE_MAP_POSITIVE_X + target2._face : gl.TEXTURE_2D, colorBuffer.impl._glTexture, 0); + this.colorMrtFramebuffers[i] = new FramebufferPair(srcFramebuffer, dstFramebuffer); + } + } + _checkFbo(device, target2, type2 = "") { + const gl = device.gl; + const status = gl.checkFramebufferStatus(gl.FRAMEBUFFER); + switch (status) { + case gl.FRAMEBUFFER_INCOMPLETE_ATTACHMENT: + break; + case gl.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: + break; + case gl.FRAMEBUFFER_INCOMPLETE_DIMENSIONS: + break; + case gl.FRAMEBUFFER_UNSUPPORTED: + break; + } + } + loseContext() { + this._glFrameBuffer = null; + this._glDepthBuffer = null; + this._glResolveFrameBuffer = null; + this._glMsaaColorBuffers.length = 0; + this._glMsaaDepthBuffer = null; + this.colorMrtFramebuffers = null; + this.suppliedColorFramebuffer = void 0; + this._isInitialized = false; + } + internalResolve(device, src, dst, target2, mask) { + device.setScissor(0, 0, target2.width, target2.height); + const gl = device.gl; + gl.bindFramebuffer(gl.READ_FRAMEBUFFER, src); + gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, dst); + gl.blitFramebuffer(0, 0, target2.width, target2.height, 0, 0, target2.width, target2.height, mask, gl.NEAREST); + } + resolve(device, target2, color, depth) { + if (device.isWebGL2) { + const gl = device.gl; + if (this.colorMrtFramebuffers) { + if (color) { + for (let i = 0; i < this.colorMrtFramebuffers.length; i++) { + const fbPair = this.colorMrtFramebuffers[i]; + this.internalResolve(device, fbPair.msaaFB, fbPair.resolveFB, target2, gl.COLOR_BUFFER_BIT); + } + } + if (depth) { + this.internalResolve(device, this._glFrameBuffer, this._glResolveFrameBuffer, target2, gl.DEPTH_BUFFER_BIT); + } + } else { + this.internalResolve(device, this._glFrameBuffer, this._glResolveFrameBuffer, target2, (color ? gl.COLOR_BUFFER_BIT : 0) | (depth ? gl.DEPTH_BUFFER_BIT : 0)); + } + gl.bindFramebuffer(gl.FRAMEBUFFER, this._glFrameBuffer); + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/shader-chunks/frag/gles2.js +var gles2PS = ` +#define pcFragColor0 gl_FragData[0] +#if COLOR_ATTACHMENT_1 +#define pcFragColor1 gl_FragData[1] +#endif +#if COLOR_ATTACHMENT_2 +#define pcFragColor2 gl_FragData[2] +#endif +#if COLOR_ATTACHMENT_3 +#define pcFragColor3 gl_FragData[3] +#endif +#if COLOR_ATTACHMENT_4 +#define pcFragColor4 gl_FragData[4] +#endif +#if COLOR_ATTACHMENT_5 +#define pcFragColor5 gl_FragData[5] +#endif +#if COLOR_ATTACHMENT_6 +#define pcFragColor6 gl_FragData[6] +#endif +#if COLOR_ATTACHMENT_7 +#define pcFragColor7 gl_FragData[7] +#endif +#define texture2DBias texture2D +#define itexture2D texture2D +#define utexture2D texture2D +#define SHADOWMAP_PASS(name) name +#define SHADOWMAP_ACCEPT(name) sampler2D name +#define TEXTURE_PASS(name) name +#define TEXTURE_ACCEPT(name) sampler2D name +#define TEXTURE_ACCEPT_HIGHP(name) highp sampler2D name +#ifndef SUPPORTS_TEXLOD + #define texture2DLodEXT texture2D + #define texture2DProjLodEXT textureProj + #define textureCubeLodEXT textureCube + #define textureShadow texture2D +#else + #define textureShadow(res, uv) texture2DGradEXT(res, uv, vec2(1, 1), vec2(1, 1)) +#endif +#ifdef SUPPORTS_MRT + #define gl_FragColor pcFragColor0 +#endif +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/shader-chunks/vert/gles2.js +var gles2VS = ` +#define TEXTURE_PASS(name) name +#define TEXTURE_ACCEPT(name) sampler2D name +#define TEXTURE_ACCEPT_HIGHP(name) highp sampler2D name +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/shader-chunks/frag/gles3.js +var gles3PS = ` +#ifndef outType_0 +#define outType_0 vec4 +#endif +layout(location = 0) out highp outType_0 pc_fragColor; +#ifndef REMOVE_COLOR_ATTACHMENT_1 +#if COLOR_ATTACHMENT_1 +layout(location = 1) out highp outType_1 pc_fragColor1; +#endif +#endif +#ifndef REMOVE_COLOR_ATTACHMENT_2 +#if COLOR_ATTACHMENT_2 +layout(location = 2) out highp outType_2 pc_fragColor2; +#endif +#endif +#ifndef REMOVE_COLOR_ATTACHMENT_3 +#if COLOR_ATTACHMENT_3 +layout(location = 3) out highp outType_3 pc_fragColor3; +#endif +#endif +#ifndef REMOVE_COLOR_ATTACHMENT_4 +#if COLOR_ATTACHMENT_4 +layout(location = 4) out highp outType_4 pc_fragColor4; +#endif +#endif +#ifndef REMOVE_COLOR_ATTACHMENT_5 +#if COLOR_ATTACHMENT_5 +layout(location = 5) out highp outType_5 pc_fragColor5; +#endif +#endif +#ifndef REMOVE_COLOR_ATTACHMENT_6 +#if COLOR_ATTACHMENT_6 +layout(location = 6) out highp outType_6 pc_fragColor6; +#endif +#endif +#ifndef REMOVE_COLOR_ATTACHMENT_7 +#if COLOR_ATTACHMENT_7 +layout(location = 7) out highp outType_7 pc_fragColor7; +#endif +#endif +#define gl_FragColor pc_fragColor +#define pcFragColor0 pc_fragColor +#define pcFragColor1 pc_fragColor1 +#define pcFragColor2 pc_fragColor2 +#define pcFragColor3 pc_fragColor3 +#define pcFragColor4 pc_fragColor4 +#define pcFragColor5 pc_fragColor5 +#define pcFragColor6 pc_fragColor6 +#define pcFragColor7 pc_fragColor7 +#define varying in +#define texture2D texture +#define texture2DBias texture +#define textureCube texture +#define texture2DProj textureProj +#define texture2DLodEXT textureLod +#define texture2DProjLodEXT textureProjLod +#define textureCubeLodEXT textureLod +#define texture2DGradEXT textureGrad +#define texture2DProjGradEXT textureProjGrad +#define textureCubeGradEXT textureGrad +#define utexture2D texture +#define itexture2D texture +#define textureShadow(res, uv) textureGrad(res, uv, vec2(1, 1), vec2(1, 1)) +#define SHADOWMAP_PASS(name) name +#define SHADOWMAP_ACCEPT(name) sampler2DShadow name +#define TEXTURE_PASS(name) name +#define TEXTURE_ACCEPT(name) sampler2D name +#define TEXTURE_ACCEPT_HIGHP(name) highp sampler2D name +#define GL2 +#define SUPPORTS_TEXLOD +#define SUPPORTS_MRT +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/shader-chunks/vert/gles3.js +var gles3VS = ` +#define attribute in +#define varying out +#define texture2D texture +#define utexture2D texture +#define itexture2D texture +#define GL2 +#define VERTEXSHADER +#define TEXTURE_PASS(name) name +#define TEXTURE_ACCEPT(name) sampler2D name +#define TEXTURE_ACCEPT_HIGHP(name) highp sampler2D name +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/shader-chunks/frag/webgpu.js +var webgpuPS = ` +#extension GL_EXT_samplerless_texture_functions : require +#ifndef outType_0 +#define outType_0 vec4 +#endif +#ifndef outType_1 +#define outType_1 vec4 +#endif +#ifndef outType_2 +#define outType_2 vec4 +#endif +#ifndef outType_3 +#define outType_3 vec4 +#endif +#ifndef outType_4 +#define outType_4 vec4 +#endif +#ifndef outType_5 +#define outType_5 vec4 +#endif +#ifndef outType_6 +#define outType_6 vec4 +#endif +#ifndef outType_7 +#define outType_7 vec4 +#endif +layout(location = 0) out highp outType_0 pc_fragColor; +layout(location = 1) out highp outType_1 pc_fragColor1; +layout(location = 2) out highp outType_2 pc_fragColor2; +layout(location = 3) out highp outType_3 pc_fragColor3; +layout(location = 4) out highp outType_4 pc_fragColor4; +layout(location = 5) out highp outType_5 pc_fragColor5; +layout(location = 6) out highp outType_6 pc_fragColor6; +layout(location = 7) out highp outType_7 pc_fragColor7; +#define gl_FragColor pc_fragColor +#define pcFragColor0 pc_fragColor +#define pcFragColor1 pc_fragColor1 +#define pcFragColor2 pc_fragColor2 +#define pcFragColor3 pc_fragColor3 +#define pcFragColor4 pc_fragColor4 +#define pcFragColor5 pc_fragColor5 +#define pcFragColor6 pc_fragColor6 +#define pcFragColor7 pc_fragColor7 +#define texture2D(res, uv) texture(sampler2D(res, res ## _sampler), uv) +#define texture2DBias(res, uv, bias) texture(sampler2D(res, res ## _sampler), uv, bias) +#define texture2DLodEXT(res, uv, lod) textureLod(sampler2D(res, res ## _sampler), uv, lod) +#define textureCube(res, uv) texture(samplerCube(res, res ## _sampler), uv) +#define textureCubeLodEXT(res, uv, lod) textureLod(samplerCube(res, res ## _sampler), uv, lod) +#define textureShadow(res, uv) textureLod(sampler2DShadow(res, res ## _sampler), uv, 0.0) +#define itexture2D(res, uv) texture(isampler2D(res, res ## _sampler), uv) +#define utexture2D(res, uv) texture(usampler2D(res, res ## _sampler), uv) +#define SHADOWMAP_PASS(name) name, name ## _sampler +#define SHADOWMAP_ACCEPT(name) texture2D name, sampler name ## _sampler +#define TEXTURE_PASS(name) name, name ## _sampler +#define TEXTURE_ACCEPT(name) texture2D name, sampler name ## _sampler +#define TEXTURE_ACCEPT_HIGHP TEXTURE_ACCEPT +#define GL2 +#define WEBGPU +#define SUPPORTS_TEXLOD +#define SUPPORTS_MRT +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/shader-chunks/vert/webgpu.js +var webgpuVS = ` +#extension GL_EXT_samplerless_texture_functions : require +#define texture2D(res, uv) texture(sampler2D(res, res ## _sampler), uv) +#define itexture2D(res, uv) texture(isampler2D(res, res ## _sampler), uv) +#define utexture2D(res, uv) texture(usampler2D(res, res ## _sampler), uv) +#define TEXTURE_PASS(name) name, name ## _sampler +#define TEXTURE_ACCEPT(name) texture2D name, sampler name ## _sampler +#define TEXTURE_ACCEPT_HIGHP TEXTURE_ACCEPT +#define GL2 +#define WEBGPU +#define VERTEXSHADER +#define gl_VertexID gl_VertexIndex +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/shader-chunks/frag/shared.js +var sharedFS = ` +vec2 getGrabScreenPos(vec4 clipPos) { + vec2 uv = (clipPos.xy / clipPos.w) * 0.5 + 0.5; + #ifdef WEBGPU + uv.y = 1.0 - uv.y; + #endif + return uv; +} +vec2 getImageEffectUV(vec2 uv) { + #ifdef WEBGPU + uv.y = 1.0 - uv.y; + #endif + return uv; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/shader-utils.js +var _attrib2Semantic = { + vertex_position: SEMANTIC_POSITION, + vertex_normal: SEMANTIC_NORMAL, + vertex_tangent: SEMANTIC_TANGENT, + vertex_texCoord0: SEMANTIC_TEXCOORD0, + vertex_texCoord1: SEMANTIC_TEXCOORD1, + vertex_texCoord2: SEMANTIC_TEXCOORD2, + vertex_texCoord3: SEMANTIC_TEXCOORD3, + vertex_texCoord4: SEMANTIC_TEXCOORD4, + vertex_texCoord5: SEMANTIC_TEXCOORD5, + vertex_texCoord6: SEMANTIC_TEXCOORD6, + vertex_texCoord7: SEMANTIC_TEXCOORD7, + vertex_color: SEMANTIC_COLOR, + vertex_boneIndices: SEMANTIC_BLENDINDICES, + vertex_boneWeights: SEMANTIC_BLENDWEIGHT +}; +var ShaderUtils = class _ShaderUtils { + static createDefinition(device, options) { + var _options$name, _options$attributes; + const getDefines = (gpu, gl2, gl1, isVertex, options2) => { + const deviceIntro = device.isWebGPU ? gpu : device.isWebGL2 ? gl2 : _ShaderUtils.gl1Extensions(device, options2) + gl1; + let attachmentsDefine = ""; + if (!isVertex) { + var _options$fragmentOutp; + let fragmentOutputTypes = (_options$fragmentOutp = options2.fragmentOutputTypes) != null ? _options$fragmentOutp : "vec4"; + if (!Array.isArray(fragmentOutputTypes)) { + fragmentOutputTypes = [fragmentOutputTypes]; + } + for (let i = 0; i < device.maxColorAttachments; i++) { + var _fragmentOutputTypes$; + attachmentsDefine += `#define COLOR_ATTACHMENT_${i} +`; + const outType = (_fragmentOutputTypes$ = fragmentOutputTypes[i]) != null ? _fragmentOutputTypes$ : "vec4"; + attachmentsDefine += `#define outType_${i} ${outType} +`; + } + } + return attachmentsDefine + deviceIntro; + }; + const name = (_options$name = options.name) != null ? _options$name : "Untitled"; + const vertCode = _ShaderUtils.versionCode(device) + getDefines(webgpuVS, gles3VS, gles2VS, true, options) + _ShaderUtils.getDefinesCode(options.vertexDefines) + sharedFS + _ShaderUtils.getShaderNameCode(name) + options.vertexCode; + const fragCode = (options.fragmentPreamble || "") + _ShaderUtils.versionCode(device) + getDefines(webgpuPS, gles3PS, gles2PS, false, options) + _ShaderUtils.getDefinesCode(options.fragmentDefines) + _ShaderUtils.precisionCode(device) + "\n" + sharedFS + _ShaderUtils.getShaderNameCode(name) + (options.fragmentCode || _ShaderUtils.dummyFragmentCode()); + const attribs = (_options$attributes = options.attributes) != null ? _options$attributes : _ShaderUtils.collectAttributes(options.vertexCode); + return { + name, + attributes: attribs, + vshader: vertCode, + vincludes: options.vertexIncludes, + fincludes: options.fragmentIncludes, + fshader: fragCode, + useTransformFeedback: options.useTransformFeedback + }; + } + static getDefinesCode(defines) { + let code = ""; + defines == null || defines.forEach((value, key) => { + code += `#define ${key} ${value} +`; + }); + return code; + } + static getShaderNameCode(name) { + return `#define SHADER_NAME ${name} +`; + } + static gl1Extensions(device, options, isVertex) { + let code; + if (isVertex) { + code = options.vertexExtensions ? `${options.vertexExtensions} +` : ""; + } else { + code = options.fragmentExtensions ? `${options.fragmentExtensions} +` : ""; + if (device.extStandardDerivatives) { + code += "#extension GL_OES_standard_derivatives : enable\n"; + } + if (device.extTextureLod) { + code += "#extension GL_EXT_shader_texture_lod : enable\n"; + code += "#define SUPPORTS_TEXLOD\n"; + } + if (device.extDrawBuffers) { + code += "#extension GL_EXT_draw_buffers : require\n"; + code += "#define SUPPORTS_MRT\n"; + } + } + return code; + } + static dummyFragmentCode() { + return "void main(void) {gl_FragColor = vec4(0.0);}"; + } + static versionCode(device) { + if (device.isWebGPU) { + return "#version 450\n"; + } + return device.isWebGL2 ? "#version 300 es\n" : ""; + } + static precisionCode(device, forcePrecision) { + let code = ""; + if (forcePrecision && forcePrecision !== "highp" && forcePrecision !== "mediump" && forcePrecision !== "lowp") { + forcePrecision = null; + } + if (forcePrecision) { + if (forcePrecision === "highp" && device.maxPrecision !== "highp") { + forcePrecision = "mediump"; + } + if (forcePrecision === "mediump" && device.maxPrecision === "lowp") { + forcePrecision = "lowp"; + } + } + const precision = forcePrecision ? forcePrecision : device.precision; + if (!device.isWebGPU) { + code = `precision ${precision} float; +precision ${precision} int;`; + if (device.isWebGL2) { + code += `precision ${precision} sampler2DShadow; +`; + } + } else { + code = `precision ${precision} float; +precision ${precision} int; +`; + } + return code; + } + static collectAttributes(vsCode2) { + const attribs = {}; + let attrs = 0; + let found = vsCode2.indexOf("attribute"); + while (found >= 0) { + if (found > 0 && vsCode2[found - 1] === "/") break; + const endOfLine = vsCode2.indexOf(";", found); + const startOfAttribName = vsCode2.lastIndexOf(" ", endOfLine); + const attribName = vsCode2.substring(startOfAttribName + 1, endOfLine); + if (attribs[attribName]) ; + else { + const semantic = _attrib2Semantic[attribName]; + if (semantic !== void 0) { + attribs[attribName] = semantic; + } else { + attribs[attribName] = "ATTR" + attrs; + attrs++; + } + } + found = vsCode2.indexOf("attribute", found + 1); + } + return attribs; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgl/webgl-gpu-profiler.js +var FrameQueriesInfo = class { + constructor() { + this.renderVersion = void 0; + this.queries = []; + } + destroy(gl) { + this.queries.forEach((query) => gl.deleteQuery(query)); + this.queries = null; + } +}; +var WebglGpuProfiler = class extends GpuProfiler { + constructor(device) { + super(); + this.device = void 0; + this.freeQueries = []; + this.frameQueries = []; + this.previousFrameQueries = []; + this.timings = []; + this.device = device; + this.ext = device.extDisjointTimerQuery; + } + destroy() { + this.freeQueries.forEach((query) => this.device.gl.deleteQuery(query)); + this.frameQueries.forEach((query) => this.device.gl.deleteQuery(query)); + this.previousFrameQueries.forEach((frameQueriesInfo) => frameQueriesInfo.destroy(this.device.gl)); + this.freeQueries = null; + this.frameQueries = null; + this.previousFrameQueries = null; + } + loseContext() { + super.loseContext(); + this.freeQueries = []; + this.frameQueries = []; + this.previousFrameQueries = []; + } + restoreContext() { + this.ext = this.device.extDisjointTimerQuery; + } + getQuery() { + var _this$freeQueries$pop; + return (_this$freeQueries$pop = this.freeQueries.pop()) != null ? _this$freeQueries$pop : this.device.gl.createQuery(); + } + start(name) { + if (this.ext) { + const slot = this.getSlot(name); + const query = this.getQuery(); + this.frameQueries[slot] = query; + this.device.gl.beginQuery(this.ext.TIME_ELAPSED_EXT, query); + return slot; + } + return void 0; + } + end(slot) { + if (slot !== void 0) { + this.device.gl.endQuery(this.ext.TIME_ELAPSED_EXT); + } + } + frameStart() { + this.processEnableRequest(); + if (this._enabled) { + this.frameGPUMarkerSlot = this.start("GpuFrame"); + } + } + frameEnd() { + if (this._enabled) { + this.end(this.frameGPUMarkerSlot); + } + } + request() { + if (this._enabled) { + const ext = this.ext; + const gl = this.device.gl; + const renderVersion = this.device.renderVersion; + const frameQueries = this.frameQueries; + if (frameQueries.length > 0) { + this.frameQueries = []; + const frameQueriesInfo = new FrameQueriesInfo(); + frameQueriesInfo.queries = frameQueries; + frameQueriesInfo.renderVersion = renderVersion; + this.previousFrameQueries.push(frameQueriesInfo); + } + if (this.previousFrameQueries.length > 0) { + const previousQueriesInfo = this.previousFrameQueries[0]; + const previousQueries = previousQueriesInfo.queries; + const lastQuery = previousQueries[previousQueries.length - 1]; + const available = gl.getQueryParameter(lastQuery, gl.QUERY_RESULT_AVAILABLE); + const disjoint = gl.getParameter(ext.GPU_DISJOINT_EXT); + if (available && !disjoint) { + this.previousFrameQueries.shift(); + const timings = this.timings; + timings.length = 0; + for (let i = 0; i < previousQueries.length; i++) { + const query = previousQueries[i]; + const duration = gl.getQueryParameter(query, gl.QUERY_RESULT); + timings[i] = duration * 1e-6; + this.freeQueries.push(query); + } + this.report(previousQueriesInfo.renderVersion, timings); + } + if (disjoint) { + this.previousFrameQueries.forEach((frameQueriesInfo) => { + this.report(frameQueriesInfo.renderVersion, null); + frameQueriesInfo.destroy(gl); + }); + this.previousFrameQueries.length = 0; + } + } + super.request(renderVersion); + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgl/webgl-graphics-device.js +var invalidateAttachments = []; +var _fullScreenQuadVS = ` +attribute vec2 vertex_position; +varying vec2 vUv0; +void main(void) +{ + gl_Position = vec4(vertex_position, 0.5, 1.0); + vUv0 = vertex_position.xy*0.5+0.5; +} +`; +var _precisionTest1PS = ` +void main(void) { + gl_FragColor = vec4(2147483648.0); +} +`; +var _precisionTest2PS = ` +uniform sampler2D source; +vec4 packFloat(float depth) { + const vec4 bit_shift = vec4(256.0 * 256.0 * 256.0, 256.0 * 256.0, 256.0, 1.0); + const vec4 bit_mask = vec4(0.0, 1.0 / 256.0, 1.0 / 256.0, 1.0 / 256.0); + vec4 res = mod(depth * bit_shift * vec4(255), vec4(256) ) / vec4(255); + res -= res.xxyz * bit_mask; + return res; +} +void main(void) { + float c = texture2D(source, vec2(0.0)).r; + float diff = abs(c - 2147483648.0) / 2147483648.0; + gl_FragColor = packFloat(diff); +} +`; +var _outputTexture2D = ` +varying vec2 vUv0; +uniform sampler2D source; +void main(void) { + gl_FragColor = texture2D(source, vUv0); +} +`; +function quadWithShader(device, target2, shader) { + const oldRt = device.renderTarget; + device.setRenderTarget(target2); + device.updateBegin(); + device.setCullMode(CULLFACE_NONE); + device.setBlendState(BlendState.NOBLEND); + device.setDepthState(DepthState.NODEPTH); + device.setStencilState(null, null); + device.setVertexBuffer(device.quadVertexBuffer, 0); + device.setShader(shader); + device.draw({ + type: PRIMITIVE_TRISTRIP, + base: 0, + count: 4, + indexed: false + }); + device.updateEnd(); + device.setRenderTarget(oldRt); + device.updateBegin(); +} +function testRenderable(gl, pixelFormat) { + let result = true; + const texture = gl.createTexture(); + gl.bindTexture(gl.TEXTURE_2D, texture); + gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST); + gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST); + gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE); + gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE); + gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 2, 2, 0, gl.RGBA, pixelFormat, null); + const framebuffer = gl.createFramebuffer(); + gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer); + gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0); + if (gl.checkFramebufferStatus(gl.FRAMEBUFFER) !== gl.FRAMEBUFFER_COMPLETE) { + result = false; + } + gl.bindTexture(gl.TEXTURE_2D, null); + gl.deleteTexture(texture); + gl.bindFramebuffer(gl.FRAMEBUFFER, null); + gl.deleteFramebuffer(framebuffer); + return result; +} +function testTextureHalfFloatUpdatable(gl, pixelFormat) { + let result = true; + const texture = gl.createTexture(); + gl.bindTexture(gl.TEXTURE_2D, texture); + gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST); + gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST); + gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE); + gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE); + const data2 = new Uint16Array(4 * 2 * 2); + gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 2, 2, 0, gl.RGBA, pixelFormat, data2); + if (gl.getError() !== gl.NO_ERROR) { + result = false; + console.log("Above error related to HALF_FLOAT_OES can be ignored, it was triggered by testing half float texture support"); + } + gl.bindTexture(gl.TEXTURE_2D, null); + gl.deleteTexture(texture); + return result; +} +function testTextureFloatHighPrecision(device) { + if (!device.textureFloatRenderable) return false; + const shader1 = new Shader(device, ShaderUtils.createDefinition(device, { + name: "ptest1", + vertexCode: _fullScreenQuadVS, + fragmentCode: _precisionTest1PS + })); + const shader2 = new Shader(device, ShaderUtils.createDefinition(device, { + name: "ptest2", + vertexCode: _fullScreenQuadVS, + fragmentCode: _precisionTest2PS + })); + const textureOptions = { + format: PIXELFORMAT_RGBA32F, + width: 1, + height: 1, + mipmaps: false, + minFilter: FILTER_NEAREST, + magFilter: FILTER_NEAREST, + name: "testFHP" + }; + const tex1 = new Texture(device, textureOptions); + const targ1 = new RenderTarget({ + colorBuffer: tex1, + depth: false + }); + quadWithShader(device, targ1, shader1); + textureOptions.format = PIXELFORMAT_RGBA8; + const tex2 = new Texture(device, textureOptions); + const targ2 = new RenderTarget({ + colorBuffer: tex2, + depth: false + }); + device.constantTexSource.setValue(tex1); + quadWithShader(device, targ2, shader2); + const prevFramebuffer = device.activeFramebuffer; + device.setFramebuffer(targ2.impl._glFrameBuffer); + const pixels = new Uint8Array(4); + device.readPixels(0, 0, 1, 1, pixels); + device.setFramebuffer(prevFramebuffer); + const x2 = pixels[0] / 255; + const y2 = pixels[1] / 255; + const z2 = pixels[2] / 255; + const w = pixels[3] / 255; + const f = x2 / (256 * 256 * 256) + y2 / (256 * 256) + z2 / 256 + w; + tex1.destroy(); + targ1.destroy(); + tex2.destroy(); + targ2.destroy(); + shader1.destroy(); + shader2.destroy(); + return f === 0; +} +var WebglGraphicsDevice = class extends GraphicsDevice { + constructor(canvas, options = {}) { + var _options$antialias; + super(canvas, options); + this.gl = void 0; + this._defaultFramebuffer = null; + this._defaultFramebufferChanged = false; + options = this.initOptions; + this.updateClientRect(); + this.initTextureUnits(); + this.contextLost = false; + this._contextLostHandler = (event) => { + event.preventDefault(); + this.loseContext(); + this.fire("devicelost"); + }; + this._contextRestoredHandler = () => { + this.restoreContext(); + this.fire("devicerestored"); + }; + const ua2 = typeof navigator !== "undefined" && navigator.userAgent; + this.forceDisableMultisampling = ua2 && ua2.includes("AppleWebKit") && (ua2.includes("15.4") || ua2.includes("15_4")); + if (this.forceDisableMultisampling) { + options.antialias = false; + } + if (platform.browserName === "firefox" && platform.name === "windows") { + const _ua = typeof navigator !== "undefined" ? navigator.userAgent : ""; + const match = _ua.match(/Firefox\/(\d+(\.\d+)*)/); + const firefoxVersion = match ? match[1] : null; + if (firefoxVersion) { + const version2 = parseFloat(firefoxVersion); + if (version2 >= 120 || version2 === 115) { + options.antialias = false; + } + } + } + let gl = null; + this.backBufferAntialias = (_options$antialias = options.antialias) != null ? _options$antialias : false; + options.antialias = false; + if (options.gl) { + gl = options.gl; + } else { + const preferWebGl2 = options.preferWebGl2 !== void 0 ? options.preferWebGl2 : true; + const names = preferWebGl2 ? ["webgl2", "webgl", "experimental-webgl"] : ["webgl", "experimental-webgl"]; + for (let i = 0; i < names.length; i++) { + gl = canvas.getContext(names[i], options); + if (gl) { + break; + } + } + } + if (!gl) { + throw new Error("WebGL not supported"); + } + this.gl = gl; + this.isWebGL2 = typeof WebGL2RenderingContext !== "undefined" && gl instanceof WebGL2RenderingContext; + this.isWebGL1 = !this.isWebGL2; + this._deviceType = this.isWebGL2 ? DEVICETYPE_WEBGL2 : DEVICETYPE_WEBGL1; + this.updateBackbufferFormat(null); + const isChrome = platform.browserName === "chrome"; + const isSafari = platform.browserName === "safari"; + const isMac = platform.browser && navigator.appVersion.indexOf("Mac") !== -1; + this._tempEnableSafariTextureUnitWorkaround = isSafari; + this._tempMacChromeBlitFramebufferWorkaround = isMac && isChrome && !options.alpha; + canvas.addEventListener("webglcontextlost", this._contextLostHandler, false); + canvas.addEventListener("webglcontextrestored", this._contextRestoredHandler, false); + this.initializeExtensions(); + this.initializeCapabilities(); + this.initializeRenderState(); + this.initializeContextCaches(); + this.createBackbuffer(null); + this.supportsImageBitmap = !isSafari && typeof ImageBitmap !== "undefined"; + this._samplerTypes = /* @__PURE__ */ new Set([...[gl.SAMPLER_2D, gl.SAMPLER_CUBE], ...this.isWebGL2 ? [gl.UNSIGNED_INT_SAMPLER_2D, gl.INT_SAMPLER_2D, gl.SAMPLER_2D_SHADOW, gl.SAMPLER_CUBE_SHADOW, gl.SAMPLER_3D, gl.INT_SAMPLER_3D, gl.UNSIGNED_INT_SAMPLER_3D, gl.SAMPLER_2D_ARRAY, gl.INT_SAMPLER_2D_ARRAY, gl.UNSIGNED_INT_SAMPLER_2D_ARRAY] : []]); + this.glAddress = [gl.REPEAT, gl.CLAMP_TO_EDGE, gl.MIRRORED_REPEAT]; + this.glBlendEquation = [gl.FUNC_ADD, gl.FUNC_SUBTRACT, gl.FUNC_REVERSE_SUBTRACT, this.isWebGL2 ? gl.MIN : this.extBlendMinmax ? this.extBlendMinmax.MIN_EXT : gl.FUNC_ADD, this.isWebGL2 ? gl.MAX : this.extBlendMinmax ? this.extBlendMinmax.MAX_EXT : gl.FUNC_ADD]; + this.glBlendFunctionColor = [gl.ZERO, gl.ONE, gl.SRC_COLOR, gl.ONE_MINUS_SRC_COLOR, gl.DST_COLOR, gl.ONE_MINUS_DST_COLOR, gl.SRC_ALPHA, gl.SRC_ALPHA_SATURATE, gl.ONE_MINUS_SRC_ALPHA, gl.DST_ALPHA, gl.ONE_MINUS_DST_ALPHA, gl.CONSTANT_COLOR, gl.ONE_MINUS_CONSTANT_COLOR]; + this.glBlendFunctionAlpha = [gl.ZERO, gl.ONE, gl.SRC_COLOR, gl.ONE_MINUS_SRC_COLOR, gl.DST_COLOR, gl.ONE_MINUS_DST_COLOR, gl.SRC_ALPHA, gl.SRC_ALPHA_SATURATE, gl.ONE_MINUS_SRC_ALPHA, gl.DST_ALPHA, gl.ONE_MINUS_DST_ALPHA, gl.CONSTANT_ALPHA, gl.ONE_MINUS_CONSTANT_ALPHA]; + this.glComparison = [gl.NEVER, gl.LESS, gl.EQUAL, gl.LEQUAL, gl.GREATER, gl.NOTEQUAL, gl.GEQUAL, gl.ALWAYS]; + this.glStencilOp = [gl.KEEP, gl.ZERO, gl.REPLACE, gl.INCR, gl.INCR_WRAP, gl.DECR, gl.DECR_WRAP, gl.INVERT]; + this.glClearFlag = [0, gl.COLOR_BUFFER_BIT, gl.DEPTH_BUFFER_BIT, gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT, gl.STENCIL_BUFFER_BIT, gl.STENCIL_BUFFER_BIT | gl.COLOR_BUFFER_BIT, gl.STENCIL_BUFFER_BIT | gl.DEPTH_BUFFER_BIT, gl.STENCIL_BUFFER_BIT | gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT]; + this.glCull = [0, gl.BACK, gl.FRONT, gl.FRONT_AND_BACK]; + this.glFilter = [gl.NEAREST, gl.LINEAR, gl.NEAREST_MIPMAP_NEAREST, gl.NEAREST_MIPMAP_LINEAR, gl.LINEAR_MIPMAP_NEAREST, gl.LINEAR_MIPMAP_LINEAR]; + this.glPrimitive = [gl.POINTS, gl.LINES, gl.LINE_LOOP, gl.LINE_STRIP, gl.TRIANGLES, gl.TRIANGLE_STRIP, gl.TRIANGLE_FAN]; + this.glType = [gl.BYTE, gl.UNSIGNED_BYTE, gl.SHORT, gl.UNSIGNED_SHORT, gl.INT, gl.UNSIGNED_INT, gl.FLOAT, gl.HALF_FLOAT]; + this.pcUniformType = {}; + this.pcUniformType[gl.BOOL] = UNIFORMTYPE_BOOL; + this.pcUniformType[gl.INT] = UNIFORMTYPE_INT; + this.pcUniformType[gl.FLOAT] = UNIFORMTYPE_FLOAT; + this.pcUniformType[gl.FLOAT_VEC2] = UNIFORMTYPE_VEC2; + this.pcUniformType[gl.FLOAT_VEC3] = UNIFORMTYPE_VEC3; + this.pcUniformType[gl.FLOAT_VEC4] = UNIFORMTYPE_VEC4; + this.pcUniformType[gl.INT_VEC2] = UNIFORMTYPE_IVEC2; + this.pcUniformType[gl.INT_VEC3] = UNIFORMTYPE_IVEC3; + this.pcUniformType[gl.INT_VEC4] = UNIFORMTYPE_IVEC4; + this.pcUniformType[gl.BOOL_VEC2] = UNIFORMTYPE_BVEC2; + this.pcUniformType[gl.BOOL_VEC3] = UNIFORMTYPE_BVEC3; + this.pcUniformType[gl.BOOL_VEC4] = UNIFORMTYPE_BVEC4; + this.pcUniformType[gl.FLOAT_MAT2] = UNIFORMTYPE_MAT2; + this.pcUniformType[gl.FLOAT_MAT3] = UNIFORMTYPE_MAT3; + this.pcUniformType[gl.FLOAT_MAT4] = UNIFORMTYPE_MAT4; + this.pcUniformType[gl.SAMPLER_2D] = UNIFORMTYPE_TEXTURE2D; + this.pcUniformType[gl.SAMPLER_CUBE] = UNIFORMTYPE_TEXTURECUBE; + this.pcUniformType[gl.UNSIGNED_INT] = UNIFORMTYPE_UINT; + this.pcUniformType[gl.UNSIGNED_INT_VEC2] = UNIFORMTYPE_UVEC2; + this.pcUniformType[gl.UNSIGNED_INT_VEC3] = UNIFORMTYPE_UVEC3; + this.pcUniformType[gl.UNSIGNED_INT_VEC4] = UNIFORMTYPE_UVEC4; + if (this.isWebGL2) { + this.pcUniformType[gl.SAMPLER_2D_SHADOW] = UNIFORMTYPE_TEXTURE2D_SHADOW; + this.pcUniformType[gl.SAMPLER_CUBE_SHADOW] = UNIFORMTYPE_TEXTURECUBE_SHADOW; + this.pcUniformType[gl.SAMPLER_2D_ARRAY] = UNIFORMTYPE_TEXTURE2D_ARRAY; + this.pcUniformType[gl.SAMPLER_3D] = UNIFORMTYPE_TEXTURE3D; + this.pcUniformType[gl.INT_SAMPLER_2D] = UNIFORMTYPE_ITEXTURE2D; + this.pcUniformType[gl.UNSIGNED_INT_SAMPLER_2D] = UNIFORMTYPE_UTEXTURE2D; + this.pcUniformType[gl.INT_SAMPLER_CUBE] = UNIFORMTYPE_ITEXTURECUBE; + this.pcUniformType[gl.UNSIGNED_INT_SAMPLER_2D] = UNIFORMTYPE_UTEXTURECUBE; + this.pcUniformType[gl.INT_SAMPLER_3D] = UNIFORMTYPE_ITEXTURE3D; + this.pcUniformType[gl.UNSIGNED_INT_SAMPLER_3D] = UNIFORMTYPE_UTEXTURE3D; + this.pcUniformType[gl.INT_SAMPLER_2D_ARRAY] = UNIFORMTYPE_ITEXTURE2D_ARRAY; + this.pcUniformType[gl.UNSIGNED_INT_SAMPLER_2D_ARRAY] = UNIFORMTYPE_UTEXTURE2D_ARRAY; + } + this.targetToSlot = {}; + this.targetToSlot[gl.TEXTURE_2D] = 0; + this.targetToSlot[gl.TEXTURE_CUBE_MAP] = 1; + this.targetToSlot[gl.TEXTURE_3D] = 2; + let scopeX, scopeY, scopeZ, scopeW; + let uniformValue; + this.commitFunction = []; + this.commitFunction[UNIFORMTYPE_BOOL] = function(uniform, value) { + if (uniform.value !== value) { + gl.uniform1i(uniform.locationId, value); + uniform.value = value; + } + }; + this.commitFunction[UNIFORMTYPE_INT] = this.commitFunction[UNIFORMTYPE_BOOL]; + this.commitFunction[UNIFORMTYPE_FLOAT] = function(uniform, value) { + if (uniform.value !== value) { + gl.uniform1f(uniform.locationId, value); + uniform.value = value; + } + }; + this.commitFunction[UNIFORMTYPE_VEC2] = function(uniform, value) { + uniformValue = uniform.value; + scopeX = value[0]; + scopeY = value[1]; + if (uniformValue[0] !== scopeX || uniformValue[1] !== scopeY) { + gl.uniform2fv(uniform.locationId, value); + uniformValue[0] = scopeX; + uniformValue[1] = scopeY; + } + }; + this.commitFunction[UNIFORMTYPE_VEC3] = function(uniform, value) { + uniformValue = uniform.value; + scopeX = value[0]; + scopeY = value[1]; + scopeZ = value[2]; + if (uniformValue[0] !== scopeX || uniformValue[1] !== scopeY || uniformValue[2] !== scopeZ) { + gl.uniform3fv(uniform.locationId, value); + uniformValue[0] = scopeX; + uniformValue[1] = scopeY; + uniformValue[2] = scopeZ; + } + }; + this.commitFunction[UNIFORMTYPE_VEC4] = function(uniform, value) { + uniformValue = uniform.value; + scopeX = value[0]; + scopeY = value[1]; + scopeZ = value[2]; + scopeW = value[3]; + if (uniformValue[0] !== scopeX || uniformValue[1] !== scopeY || uniformValue[2] !== scopeZ || uniformValue[3] !== scopeW) { + gl.uniform4fv(uniform.locationId, value); + uniformValue[0] = scopeX; + uniformValue[1] = scopeY; + uniformValue[2] = scopeZ; + uniformValue[3] = scopeW; + } + }; + this.commitFunction[UNIFORMTYPE_IVEC2] = function(uniform, value) { + uniformValue = uniform.value; + scopeX = value[0]; + scopeY = value[1]; + if (uniformValue[0] !== scopeX || uniformValue[1] !== scopeY) { + gl.uniform2iv(uniform.locationId, value); + uniformValue[0] = scopeX; + uniformValue[1] = scopeY; + } + }; + this.commitFunction[UNIFORMTYPE_BVEC2] = this.commitFunction[UNIFORMTYPE_IVEC2]; + this.commitFunction[UNIFORMTYPE_IVEC3] = function(uniform, value) { + uniformValue = uniform.value; + scopeX = value[0]; + scopeY = value[1]; + scopeZ = value[2]; + if (uniformValue[0] !== scopeX || uniformValue[1] !== scopeY || uniformValue[2] !== scopeZ) { + gl.uniform3iv(uniform.locationId, value); + uniformValue[0] = scopeX; + uniformValue[1] = scopeY; + uniformValue[2] = scopeZ; + } + }; + this.commitFunction[UNIFORMTYPE_BVEC3] = this.commitFunction[UNIFORMTYPE_IVEC3]; + this.commitFunction[UNIFORMTYPE_IVEC4] = function(uniform, value) { + uniformValue = uniform.value; + scopeX = value[0]; + scopeY = value[1]; + scopeZ = value[2]; + scopeW = value[3]; + if (uniformValue[0] !== scopeX || uniformValue[1] !== scopeY || uniformValue[2] !== scopeZ || uniformValue[3] !== scopeW) { + gl.uniform4iv(uniform.locationId, value); + uniformValue[0] = scopeX; + uniformValue[1] = scopeY; + uniformValue[2] = scopeZ; + uniformValue[3] = scopeW; + } + }; + this.commitFunction[UNIFORMTYPE_BVEC4] = this.commitFunction[UNIFORMTYPE_IVEC4]; + this.commitFunction[UNIFORMTYPE_MAT2] = function(uniform, value) { + gl.uniformMatrix2fv(uniform.locationId, false, value); + }; + this.commitFunction[UNIFORMTYPE_MAT3] = function(uniform, value) { + gl.uniformMatrix3fv(uniform.locationId, false, value); + }; + this.commitFunction[UNIFORMTYPE_MAT4] = function(uniform, value) { + gl.uniformMatrix4fv(uniform.locationId, false, value); + }; + this.commitFunction[UNIFORMTYPE_FLOATARRAY] = function(uniform, value) { + gl.uniform1fv(uniform.locationId, value); + }; + this.commitFunction[UNIFORMTYPE_VEC2ARRAY] = function(uniform, value) { + gl.uniform2fv(uniform.locationId, value); + }; + this.commitFunction[UNIFORMTYPE_VEC3ARRAY] = function(uniform, value) { + gl.uniform3fv(uniform.locationId, value); + }; + this.commitFunction[UNIFORMTYPE_VEC4ARRAY] = function(uniform, value) { + gl.uniform4fv(uniform.locationId, value); + }; + this.commitFunction[UNIFORMTYPE_UINT] = function(uniform, value) { + if (uniform.value !== value) { + gl.uniform1ui(uniform.locationId, value); + uniform.value = value; + } + }; + this.commitFunction[UNIFORMTYPE_UVEC2] = function(uniform, value) { + uniformValue = uniform.value; + scopeX = value[0]; + scopeY = value[1]; + if (uniformValue[0] !== scopeX || uniformValue[1] !== scopeY) { + gl.uniform2uiv(uniform.locationId, value); + uniformValue[0] = scopeX; + uniformValue[1] = scopeY; + } + }; + this.commitFunction[UNIFORMTYPE_UVEC3] = function(uniform, value) { + uniformValue = uniform.value; + scopeX = value[0]; + scopeY = value[1]; + scopeZ = value[2]; + if (uniformValue[0] !== scopeX || uniformValue[1] !== scopeY || uniformValue[2] !== scopeZ) { + gl.uniform3uiv(uniform.locationId, value); + uniformValue[0] = scopeX; + uniformValue[1] = scopeY; + uniformValue[2] = scopeZ; + } + }; + this.commitFunction[UNIFORMTYPE_UVEC4] = function(uniform, value) { + uniformValue = uniform.value; + scopeX = value[0]; + scopeY = value[1]; + scopeZ = value[2]; + scopeW = value[3]; + if (uniformValue[0] !== scopeX || uniformValue[1] !== scopeY || uniformValue[2] !== scopeZ || uniformValue[3] !== scopeW) { + gl.uniform4uiv(uniform.locationId, value); + uniformValue[0] = scopeX; + uniformValue[1] = scopeY; + uniformValue[2] = scopeZ; + uniformValue[3] = scopeW; + } + }; + this.commitFunction[UNIFORMTYPE_INTARRAY] = function(uniform, value) { + gl.uniform1iv(uniform.locationId, value); + }; + this.commitFunction[UNIFORMTYPE_UINTARRAY] = function(uniform, value) { + gl.uniform1uiv(uniform.locationId, value); + }; + this.commitFunction[UNIFORMTYPE_BOOLARRAY] = this.commitFunction[UNIFORMTYPE_INTARRAY]; + this.commitFunction[UNIFORMTYPE_IVEC2ARRAY] = function(uniform, value) { + gl.uniform2iv(uniform.locationId, value); + }; + this.commitFunction[UNIFORMTYPE_UVEC2ARRAY] = function(uniform, value) { + gl.uniform2uiv(uniform.locationId, value); + }; + this.commitFunction[UNIFORMTYPE_BVEC2ARRAY] = this.commitFunction[UNIFORMTYPE_IVEC2ARRAY]; + this.commitFunction[UNIFORMTYPE_IVEC3ARRAY] = function(uniform, value) { + gl.uniform3iv(uniform.locationId, value); + }; + this.commitFunction[UNIFORMTYPE_UVEC3ARRAY] = function(uniform, value) { + gl.uniform3uiv(uniform.locationId, value); + }; + this.commitFunction[UNIFORMTYPE_BVEC3ARRAY] = this.commitFunction[UNIFORMTYPE_IVEC3ARRAY]; + this.commitFunction[UNIFORMTYPE_IVEC4ARRAY] = function(uniform, value) { + gl.uniform4iv(uniform.locationId, value); + }; + this.commitFunction[UNIFORMTYPE_UVEC4ARRAY] = function(uniform, value) { + gl.uniform4uiv(uniform.locationId, value); + }; + this.commitFunction[UNIFORMTYPE_BVEC4ARRAY] = this.commitFunction[UNIFORMTYPE_IVEC4ARRAY]; + this.commitFunction[UNIFORMTYPE_MAT4ARRAY] = function(uniform, value) { + gl.uniformMatrix4fv(uniform.locationId, false, value); + }; + this.supportsBoneTextures = this.extTextureFloat && this.maxVertexTextures > 0; + let numUniforms = this.vertexUniformsCount; + numUniforms -= 4 * 4; + numUniforms -= 8; + numUniforms -= 1; + numUniforms -= 4 * 4; + this.boneLimit = Math.floor(numUniforms / 3); + this.boneLimit = Math.min(this.boneLimit, 128); + this.constantTexSource = this.scope.resolve("source"); + if (this.extTextureFloat) { + if (this.isWebGL2) { + this.textureFloatRenderable = !!this.extColorBufferFloat; + } else { + this.textureFloatRenderable = testRenderable(gl, gl.FLOAT); + } + } else { + this.textureFloatRenderable = false; + } + if (this.extColorBufferHalfFloat) { + this.textureHalfFloatRenderable = !!this.extColorBufferHalfFloat; + } else if (this.extTextureHalfFloat) { + if (this.isWebGL2) { + this.textureHalfFloatRenderable = !!this.extColorBufferFloat; + } else { + this.textureHalfFloatRenderable = testRenderable(gl, this.extTextureHalfFloat.HALF_FLOAT_OES); + } + } else { + this.textureHalfFloatRenderable = false; + } + this.supportsMorphTargetTexturesCore = this.maxPrecision === "highp" && this.maxVertexTextures >= 2; + this.supportsDepthShadow = this.isWebGL2; + this._textureFloatHighPrecision = void 0; + this._textureHalfFloatUpdatable = void 0; + this.areaLightLutFormat = PIXELFORMAT_RGBA8; + if (this.extTextureHalfFloat && this.textureHalfFloatUpdatable && this.extTextureHalfFloatLinear) { + this.areaLightLutFormat = PIXELFORMAT_RGBA16F; + } else if (this.extTextureFloat && this.extTextureFloatLinear) { + this.areaLightLutFormat = PIXELFORMAT_RGBA32F; + } + this.postInit(); + } + postInit() { + super.postInit(); + this.gpuProfiler = new WebglGpuProfiler(this); + } + destroy() { + super.destroy(); + const gl = this.gl; + if (this.isWebGL2 && this.feedback) { + gl.deleteTransformFeedback(this.feedback); + } + this.clearVertexArrayObjectCache(); + this.canvas.removeEventListener("webglcontextlost", this._contextLostHandler, false); + this.canvas.removeEventListener("webglcontextrestored", this._contextRestoredHandler, false); + this._contextLostHandler = null; + this._contextRestoredHandler = null; + this.gl = null; + super.postDestroy(); + } + createBackbuffer(frameBuffer) { + this.supportsStencil = this.initOptions.stencil; + this.backBuffer = new RenderTarget({ + name: "WebglFramebuffer", + graphicsDevice: this, + depth: this.initOptions.depth, + stencil: this.supportsStencil, + samples: this.samples + }); + this.backBuffer.impl.suppliedColorFramebuffer = frameBuffer; + } + updateBackbufferFormat(framebuffer) { + const gl = this.gl; + gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer); + const alphaBits = this.gl.getParameter(this.gl.ALPHA_BITS); + this.backBufferFormat = alphaBits ? PIXELFORMAT_RGBA8 : PIXELFORMAT_RGB8; + } + updateBackbuffer() { + const resolutionChanged = this.canvas.width !== this.backBufferSize.x || this.canvas.height !== this.backBufferSize.y; + if (this._defaultFramebufferChanged || resolutionChanged) { + if (this._defaultFramebufferChanged) { + this.updateBackbufferFormat(this._defaultFramebuffer); + } + this._defaultFramebufferChanged = false; + this.backBufferSize.set(this.canvas.width, this.canvas.height); + this.backBuffer.destroy(); + this.createBackbuffer(this._defaultFramebuffer); + } + } + createVertexBufferImpl(vertexBuffer, format) { + return new WebglVertexBuffer(); + } + createIndexBufferImpl(indexBuffer) { + return new WebglIndexBuffer(indexBuffer); + } + createShaderImpl(shader) { + return new WebglShader(shader); + } + createTextureImpl(texture) { + return new WebglTexture(); + } + createRenderTargetImpl(renderTarget) { + return new WebglRenderTarget(); + } + getPrecision() { + const gl = this.gl; + let precision = "highp"; + if (gl.getShaderPrecisionFormat) { + const vertexShaderPrecisionHighpFloat = gl.getShaderPrecisionFormat(gl.VERTEX_SHADER, gl.HIGH_FLOAT); + const vertexShaderPrecisionMediumpFloat = gl.getShaderPrecisionFormat(gl.VERTEX_SHADER, gl.MEDIUM_FLOAT); + const fragmentShaderPrecisionHighpFloat = gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER, gl.HIGH_FLOAT); + const fragmentShaderPrecisionMediumpFloat = gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER, gl.MEDIUM_FLOAT); + if (vertexShaderPrecisionHighpFloat && vertexShaderPrecisionMediumpFloat && fragmentShaderPrecisionHighpFloat && fragmentShaderPrecisionMediumpFloat) { + const highpAvailable = vertexShaderPrecisionHighpFloat.precision > 0 && fragmentShaderPrecisionHighpFloat.precision > 0; + const mediumpAvailable = vertexShaderPrecisionMediumpFloat.precision > 0 && fragmentShaderPrecisionMediumpFloat.precision > 0; + if (!highpAvailable) { + if (mediumpAvailable) { + precision = "mediump"; + } else { + precision = "lowp"; + } + } + } + } + return precision; + } + getExtension() { + for (let i = 0; i < arguments.length; i++) { + if (this.supportedExtensions.indexOf(arguments[i]) !== -1) { + return this.gl.getExtension(arguments[i]); + } + } + return null; + } + get extDisjointTimerQuery() { + if (!this._extDisjointTimerQuery) { + if (this.isWebGL2) { + this._extDisjointTimerQuery = this.getExtension("EXT_disjoint_timer_query_webgl2", "EXT_disjoint_timer_query"); + } + } + return this._extDisjointTimerQuery; + } + initializeExtensions() { + var _gl$getSupportedExten; + const gl = this.gl; + this.supportedExtensions = (_gl$getSupportedExten = gl.getSupportedExtensions()) != null ? _gl$getSupportedExten : []; + this._extDisjointTimerQuery = null; + if (this.isWebGL2) { + this.extBlendMinmax = true; + this.extDrawBuffers = true; + this.drawBuffers = gl.drawBuffers.bind(gl); + this.extInstancing = true; + this.extStandardDerivatives = true; + this.extTextureFloat = true; + this.extTextureHalfFloat = true; + this.textureHalfFloatFilterable = true; + this.extTextureLod = true; + this.extUintElement = true; + this.extVertexArrayObject = true; + this.extColorBufferFloat = this.getExtension("EXT_color_buffer_float"); + this.extDepthTexture = true; + this.textureRG11B10Renderable = true; + } else { + var _this$extDrawBuffers; + this.extBlendMinmax = this.getExtension("EXT_blend_minmax"); + this.extDrawBuffers = this.getExtension("WEBGL_draw_buffers"); + this.extInstancing = this.getExtension("ANGLE_instanced_arrays"); + this.drawBuffers = (_this$extDrawBuffers = this.extDrawBuffers) == null ? void 0 : _this$extDrawBuffers.drawBuffersWEBGL.bind(this.extDrawBuffers); + if (this.extInstancing) { + const ext = this.extInstancing; + gl.drawArraysInstanced = ext.drawArraysInstancedANGLE.bind(ext); + gl.drawElementsInstanced = ext.drawElementsInstancedANGLE.bind(ext); + gl.vertexAttribDivisor = ext.vertexAttribDivisorANGLE.bind(ext); + } + this.extStandardDerivatives = this.getExtension("OES_standard_derivatives"); + this.extTextureFloat = this.getExtension("OES_texture_float"); + this.extTextureLod = this.getExtension("EXT_shader_texture_lod"); + this.extUintElement = this.getExtension("OES_element_index_uint"); + this.extVertexArrayObject = this.getExtension("OES_vertex_array_object"); + if (this.extVertexArrayObject) { + const ext = this.extVertexArrayObject; + gl.createVertexArray = ext.createVertexArrayOES.bind(ext); + gl.deleteVertexArray = ext.deleteVertexArrayOES.bind(ext); + gl.isVertexArray = ext.isVertexArrayOES.bind(ext); + gl.bindVertexArray = ext.bindVertexArrayOES.bind(ext); + } + this.extColorBufferFloat = null; + this.extDepthTexture = gl.getExtension("WEBGL_depth_texture"); + this.extTextureHalfFloat = this.getExtension("OES_texture_half_float"); + this.extTextureHalfFloatLinear = this.getExtension("OES_texture_half_float_linear"); + this.textureHalfFloatFilterable = !!this.extTextureHalfFloatLinear; + } + this.extDebugRendererInfo = this.getExtension("WEBGL_debug_renderer_info"); + this.extTextureFloatLinear = this.getExtension("OES_texture_float_linear"); + this.textureFloatFilterable = !!this.extTextureFloatLinear; + this.extFloatBlend = this.getExtension("EXT_float_blend"); + this.extTextureFilterAnisotropic = this.getExtension("EXT_texture_filter_anisotropic", "WEBKIT_EXT_texture_filter_anisotropic"); + this.extCompressedTextureETC1 = this.getExtension("WEBGL_compressed_texture_etc1"); + this.extCompressedTextureETC = this.getExtension("WEBGL_compressed_texture_etc"); + this.extCompressedTexturePVRTC = this.getExtension("WEBGL_compressed_texture_pvrtc", "WEBKIT_WEBGL_compressed_texture_pvrtc"); + this.extCompressedTextureS3TC = this.getExtension("WEBGL_compressed_texture_s3tc", "WEBKIT_WEBGL_compressed_texture_s3tc"); + this.extCompressedTextureATC = this.getExtension("WEBGL_compressed_texture_atc"); + this.extCompressedTextureASTC = this.getExtension("WEBGL_compressed_texture_astc"); + this.extParallelShaderCompile = this.getExtension("KHR_parallel_shader_compile"); + this.extColorBufferHalfFloat = this.getExtension("EXT_color_buffer_half_float"); + } + initializeCapabilities() { + var _contextAttribs$antia, _contextAttribs$stenc; + const gl = this.gl; + let ext; + const userAgent = typeof navigator !== "undefined" ? navigator.userAgent : ""; + this.maxPrecision = this.precision = this.getPrecision(); + const contextAttribs = gl.getContextAttributes(); + this.supportsMsaa = (_contextAttribs$antia = contextAttribs == null ? void 0 : contextAttribs.antialias) != null ? _contextAttribs$antia : false; + this.supportsStencil = (_contextAttribs$stenc = contextAttribs == null ? void 0 : contextAttribs.stencil) != null ? _contextAttribs$stenc : false; + this.supportsInstancing = !!this.extInstancing; + this.maxTextureSize = gl.getParameter(gl.MAX_TEXTURE_SIZE); + this.maxCubeMapSize = gl.getParameter(gl.MAX_CUBE_MAP_TEXTURE_SIZE); + this.maxRenderBufferSize = gl.getParameter(gl.MAX_RENDERBUFFER_SIZE); + this.maxTextures = gl.getParameter(gl.MAX_TEXTURE_IMAGE_UNITS); + this.maxCombinedTextures = gl.getParameter(gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS); + this.maxVertexTextures = gl.getParameter(gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS); + this.vertexUniformsCount = gl.getParameter(gl.MAX_VERTEX_UNIFORM_VECTORS); + this.fragmentUniformsCount = gl.getParameter(gl.MAX_FRAGMENT_UNIFORM_VECTORS); + if (this.isWebGL2) { + this.maxDrawBuffers = gl.getParameter(gl.MAX_DRAW_BUFFERS); + this.maxColorAttachments = gl.getParameter(gl.MAX_COLOR_ATTACHMENTS); + this.maxVolumeSize = gl.getParameter(gl.MAX_3D_TEXTURE_SIZE); + this.supportsMrt = true; + this.supportsVolumeTextures = true; + } else { + ext = this.extDrawBuffers; + this.supportsMrt = !!ext; + this.maxDrawBuffers = ext ? gl.getParameter(ext.MAX_DRAW_BUFFERS_WEBGL) : 1; + this.maxColorAttachments = ext ? gl.getParameter(ext.MAX_COLOR_ATTACHMENTS_WEBGL) : 1; + this.maxVolumeSize = 1; + } + ext = this.extDebugRendererInfo; + this.unmaskedRenderer = ext ? gl.getParameter(ext.UNMASKED_RENDERER_WEBGL) : ""; + this.unmaskedVendor = ext ? gl.getParameter(ext.UNMASKED_VENDOR_WEBGL) : ""; + const maliRendererRegex = /\bMali-G52+/; + const samsungModelRegex = /SM-[a-zA-Z0-9]+/; + this.supportsGpuParticles = !(this.unmaskedVendor === "ARM" && userAgent.match(samsungModelRegex)) && !this.unmaskedRenderer.match(maliRendererRegex); + ext = this.extTextureFilterAnisotropic; + this.maxAnisotropy = ext ? gl.getParameter(ext.MAX_TEXTURE_MAX_ANISOTROPY_EXT) : 1; + const antialiasSupported = this.isWebGL2 && !this.forceDisableMultisampling; + this.maxSamples = antialiasSupported ? gl.getParameter(gl.MAX_SAMPLES) : 1; + this.maxSamples = Math.min(this.maxSamples, 4); + this.samples = antialiasSupported && this.backBufferAntialias ? this.maxSamples : 1; + this.supportsAreaLights = this.isWebGL2 || !platform.android; + this.supportsTextureFetch = this.isWebGL2; + if (this.maxTextures <= 8) { + this.supportsAreaLights = false; + } + } + initializeRenderState() { + super.initializeRenderState(); + const gl = this.gl; + gl.disable(gl.BLEND); + gl.blendFunc(gl.ONE, gl.ZERO); + gl.blendEquation(gl.FUNC_ADD); + gl.colorMask(true, true, true, true); + gl.blendColor(0, 0, 0, 0); + gl.enable(gl.CULL_FACE); + this.cullFace = gl.BACK; + gl.cullFace(gl.BACK); + gl.enable(gl.DEPTH_TEST); + gl.depthFunc(gl.LEQUAL); + gl.depthMask(true); + this.stencil = false; + gl.disable(gl.STENCIL_TEST); + this.stencilFuncFront = this.stencilFuncBack = FUNC_ALWAYS; + this.stencilRefFront = this.stencilRefBack = 0; + this.stencilMaskFront = this.stencilMaskBack = 255; + gl.stencilFunc(gl.ALWAYS, 0, 255); + this.stencilFailFront = this.stencilFailBack = STENCILOP_KEEP; + this.stencilZfailFront = this.stencilZfailBack = STENCILOP_KEEP; + this.stencilZpassFront = this.stencilZpassBack = STENCILOP_KEEP; + this.stencilWriteMaskFront = 255; + this.stencilWriteMaskBack = 255; + gl.stencilOp(gl.KEEP, gl.KEEP, gl.KEEP); + gl.stencilMask(255); + this.alphaToCoverage = false; + this.raster = true; + if (this.isWebGL2) { + gl.disable(gl.SAMPLE_ALPHA_TO_COVERAGE); + gl.disable(gl.RASTERIZER_DISCARD); + } + this.depthBiasEnabled = false; + gl.disable(gl.POLYGON_OFFSET_FILL); + this.clearDepth = 1; + gl.clearDepth(1); + this.clearColor = new Color(0, 0, 0, 0); + gl.clearColor(0, 0, 0, 0); + this.clearStencil = 0; + gl.clearStencil(0); + if (this.isWebGL2) { + gl.hint(gl.FRAGMENT_SHADER_DERIVATIVE_HINT, gl.NICEST); + } else { + if (this.extStandardDerivatives) { + gl.hint(this.extStandardDerivatives.FRAGMENT_SHADER_DERIVATIVE_HINT_OES, gl.NICEST); + } + } + gl.enable(gl.SCISSOR_TEST); + gl.pixelStorei(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, gl.NONE); + this.unpackFlipY = false; + gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false); + this.unpackPremultiplyAlpha = false; + gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false); + gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1); + } + initTextureUnits(count = 16) { + this.textureUnits = []; + for (let i = 0; i < count; i++) { + this.textureUnits.push([null, null, null]); + } + } + initializeContextCaches() { + super.initializeContextCaches(); + this._vaoMap = /* @__PURE__ */ new Map(); + this.boundVao = null; + this.activeFramebuffer = null; + this.feedback = null; + this.transformFeedbackBuffer = null; + this.textureUnit = 0; + this.initTextureUnits(this.maxCombinedTextures); + } + loseContext() { + super.loseContext(); + for (const shader of this.shaders) { + shader.loseContext(); + } + } + restoreContext() { + this.initializeExtensions(); + this.initializeCapabilities(); + super.restoreContext(); + for (const shader of this.shaders) { + shader.restoreContext(); + } + } + setViewport(x2, y2, w, h) { + if (this.vx !== x2 || this.vy !== y2 || this.vw !== w || this.vh !== h) { + this.gl.viewport(x2, y2, w, h); + this.vx = x2; + this.vy = y2; + this.vw = w; + this.vh = h; + } + } + setScissor(x2, y2, w, h) { + if (this.sx !== x2 || this.sy !== y2 || this.sw !== w || this.sh !== h) { + this.gl.scissor(x2, y2, w, h); + this.sx = x2; + this.sy = y2; + this.sw = w; + this.sh = h; + } + } + setFramebuffer(fb) { + if (this.activeFramebuffer !== fb) { + const gl = this.gl; + gl.bindFramebuffer(gl.FRAMEBUFFER, fb); + this.activeFramebuffer = fb; + } + } + copyRenderTarget(source, dest, color, depth) { + const gl = this.gl; + if (source === this.backBuffer) { + source = null; + } + if (!this.isWebGL2 && depth) { + return false; + } + if (color) { + if (!dest) { + if (!source._colorBuffer) { + return false; + } + } else if (source) { + if (!source._colorBuffer || !dest._colorBuffer) { + return false; + } + if (source._colorBuffer._format !== dest._colorBuffer._format) { + return false; + } + } + } + if (depth && source) { + if (!source._depth) { + if (!source._depthBuffer || !dest._depthBuffer) { + return false; + } + if (source._depthBuffer._format !== dest._depthBuffer._format) { + return false; + } + } + } + if (this.isWebGL2) { + var _this$backBuffer, _this$backBuffer2; + const prevRt = this.renderTarget; + this.renderTarget = dest; + this.updateBegin(); + const src = source ? source.impl._glFrameBuffer : (_this$backBuffer = this.backBuffer) == null ? void 0 : _this$backBuffer.impl._glFrameBuffer; + const dst = dest ? dest.impl._glFrameBuffer : (_this$backBuffer2 = this.backBuffer) == null ? void 0 : _this$backBuffer2.impl._glFrameBuffer; + gl.bindFramebuffer(gl.READ_FRAMEBUFFER, src); + gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, dst); + const w = source ? source.width : dest ? dest.width : this.width; + const h = source ? source.height : dest ? dest.height : this.height; + gl.blitFramebuffer(0, 0, w, h, 0, 0, w, h, (color ? gl.COLOR_BUFFER_BIT : 0) | (depth ? gl.DEPTH_BUFFER_BIT : 0), gl.NEAREST); + this.renderTarget = prevRt; + gl.bindFramebuffer(gl.FRAMEBUFFER, prevRt ? prevRt.impl._glFrameBuffer : null); + } else { + const shader = this.getCopyShader(); + this.constantTexSource.setValue(source._colorBuffer); + quadWithShader(this, dest, shader); + } + return true; + } + getCopyShader() { + if (!this._copyShader) { + this._copyShader = new Shader(this, ShaderUtils.createDefinition(this, { + name: "outputTex2D", + vertexCode: _fullScreenQuadVS, + fragmentCode: _outputTexture2D + })); + } + return this._copyShader; + } + frameStart() { + super.frameStart(); + this.updateBackbuffer(); + this.gpuProfiler.frameStart(); + } + frameEnd() { + super.frameEnd(); + this.gpuProfiler.frameEnd(); + this.gpuProfiler.request(); + } + startRenderPass(renderPass) { + var _renderPass$renderTar; + const rt = (_renderPass$renderTar = renderPass.renderTarget) != null ? _renderPass$renderTar : this.backBuffer; + this.renderTarget = rt; + this.updateBegin(); + const { + width, + height + } = rt; + this.setViewport(0, 0, width, height); + this.setScissor(0, 0, width, height); + const colorOps = renderPass.colorOps; + const depthStencilOps = renderPass.depthStencilOps; + if (colorOps != null && colorOps.clear || depthStencilOps.clearDepth || depthStencilOps.clearStencil) { + let clearFlags = 0; + const clearOptions = {}; + if (colorOps != null && colorOps.clear) { + clearFlags |= CLEARFLAG_COLOR; + clearOptions.color = [colorOps.clearValue.r, colorOps.clearValue.g, colorOps.clearValue.b, colorOps.clearValue.a]; + } + if (depthStencilOps.clearDepth) { + clearFlags |= CLEARFLAG_DEPTH; + clearOptions.depth = depthStencilOps.clearDepthValue; + } + if (depthStencilOps.clearStencil) { + clearFlags |= CLEARFLAG_STENCIL; + clearOptions.stencil = depthStencilOps.clearStencilValue; + } + clearOptions.flags = clearFlags; + this.clear(clearOptions); + } + this.insideRenderPass = true; + } + endRenderPass(renderPass) { + this.unbindVertexArray(); + const target2 = this.renderTarget; + const colorBufferCount = renderPass.colorArrayOps.length; + if (target2) { + var _renderPass$colorOps; + if (this.isWebGL2) { + invalidateAttachments.length = 0; + const gl = this.gl; + for (let i = 0; i < colorBufferCount; i++) { + const colorOps = renderPass.colorArrayOps[i]; + if (!(colorOps.store || colorOps.resolve)) { + invalidateAttachments.push(gl.COLOR_ATTACHMENT0 + i); + } + } + if (target2 !== this.backBuffer) { + if (!renderPass.depthStencilOps.storeDepth) { + invalidateAttachments.push(gl.DEPTH_ATTACHMENT); + } + if (!renderPass.depthStencilOps.storeStencil) { + invalidateAttachments.push(gl.STENCIL_ATTACHMENT); + } + } + if (invalidateAttachments.length > 0) { + if (renderPass.fullSizeClearRect) { + gl.invalidateFramebuffer(gl.DRAW_FRAMEBUFFER, invalidateAttachments); + } + } + } + if ((_renderPass$colorOps = renderPass.colorOps) != null && _renderPass$colorOps.resolve) { + if (this.isWebGL2 && renderPass.samples > 1 && target2.autoResolve) { + target2.resolve(true, false); + } + } + for (let i = 0; i < colorBufferCount; i++) { + const colorOps = renderPass.colorArrayOps[i]; + if (colorOps.mipmaps) { + const colorBuffer = target2._colorBuffers[i]; + if (colorBuffer && colorBuffer.impl._glTexture && colorBuffer.mipmaps && (colorBuffer.pot || this.isWebGL2)) { + this.activeTexture(this.maxCombinedTextures - 1); + this.bindTexture(colorBuffer); + this.gl.generateMipmap(colorBuffer.impl._glTarget); + } + } + } + } + this.insideRenderPass = false; + } + set defaultFramebuffer(value) { + if (this._defaultFramebuffer !== value) { + this._defaultFramebuffer = value; + this._defaultFramebufferChanged = true; + } + } + get defaultFramebuffer() { + return this._defaultFramebuffer; + } + updateBegin() { + var _this$renderTarget; + this.boundVao = null; + if (this._tempEnableSafariTextureUnitWorkaround) { + for (let unit = 0; unit < this.textureUnits.length; ++unit) { + for (let slot = 0; slot < 3; ++slot) { + this.textureUnits[unit][slot] = null; + } + } + } + const target2 = (_this$renderTarget = this.renderTarget) != null ? _this$renderTarget : this.backBuffer; + const targetImpl = target2.impl; + if (!targetImpl.initialized) { + this.initRenderTarget(target2); + } + this.setFramebuffer(targetImpl._glFrameBuffer); + } + updateEnd() { + this.unbindVertexArray(); + const target2 = this.renderTarget; + if (target2 && target2 !== this.backBuffer) { + if (this.isWebGL2 && target2._samples > 1 && target2.autoResolve) { + target2.resolve(); + } + const colorBuffer = target2._colorBuffer; + if (colorBuffer && colorBuffer.impl._glTexture && colorBuffer.mipmaps && (colorBuffer.pot || this.isWebGL2)) { + this.activeTexture(this.maxCombinedTextures - 1); + this.bindTexture(colorBuffer); + this.gl.generateMipmap(colorBuffer.impl._glTarget); + } + } + } + setUnpackFlipY(flipY) { + if (this.unpackFlipY !== flipY) { + this.unpackFlipY = flipY; + const gl = this.gl; + gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, flipY); + } + } + setUnpackPremultiplyAlpha(premultiplyAlpha) { + if (this.unpackPremultiplyAlpha !== premultiplyAlpha) { + this.unpackPremultiplyAlpha = premultiplyAlpha; + const gl = this.gl; + gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, premultiplyAlpha); + } + } + activeTexture(textureUnit) { + if (this.textureUnit !== textureUnit) { + this.gl.activeTexture(this.gl.TEXTURE0 + textureUnit); + this.textureUnit = textureUnit; + } + } + bindTexture(texture) { + const impl = texture.impl; + const textureTarget = impl._glTarget; + const textureObject = impl._glTexture; + const textureUnit = this.textureUnit; + const slot = this.targetToSlot[textureTarget]; + if (this.textureUnits[textureUnit][slot] !== textureObject) { + this.gl.bindTexture(textureTarget, textureObject); + this.textureUnits[textureUnit][slot] = textureObject; + } + } + bindTextureOnUnit(texture, textureUnit) { + const impl = texture.impl; + const textureTarget = impl._glTarget; + const textureObject = impl._glTexture; + const slot = this.targetToSlot[textureTarget]; + if (this.textureUnits[textureUnit][slot] !== textureObject) { + this.activeTexture(textureUnit); + this.gl.bindTexture(textureTarget, textureObject); + this.textureUnits[textureUnit][slot] = textureObject; + } + } + setTextureParameters(texture) { + const gl = this.gl; + const flags = texture.impl.dirtyParameterFlags; + const target2 = texture.impl._glTarget; + if (flags & 1) { + let filter = texture._minFilter; + if (!texture.pot && !this.isWebGL2 || !texture._mipmaps || texture._compressed && texture._levels.length === 1) { + if (filter === FILTER_NEAREST_MIPMAP_NEAREST || filter === FILTER_NEAREST_MIPMAP_LINEAR) { + filter = FILTER_NEAREST; + } else if (filter === FILTER_LINEAR_MIPMAP_NEAREST || filter === FILTER_LINEAR_MIPMAP_LINEAR) { + filter = FILTER_LINEAR; + } + } + gl.texParameteri(target2, gl.TEXTURE_MIN_FILTER, this.glFilter[filter]); + } + if (flags & 2) { + gl.texParameteri(target2, gl.TEXTURE_MAG_FILTER, this.glFilter[texture._magFilter]); + } + if (flags & 4) { + if (this.isWebGL2) { + gl.texParameteri(target2, gl.TEXTURE_WRAP_S, this.glAddress[texture._addressU]); + } else { + gl.texParameteri(target2, gl.TEXTURE_WRAP_S, this.glAddress[texture.pot ? texture._addressU : ADDRESS_CLAMP_TO_EDGE]); + } + } + if (flags & 8) { + if (this.isWebGL2) { + gl.texParameteri(target2, gl.TEXTURE_WRAP_T, this.glAddress[texture._addressV]); + } else { + gl.texParameteri(target2, gl.TEXTURE_WRAP_T, this.glAddress[texture.pot ? texture._addressV : ADDRESS_CLAMP_TO_EDGE]); + } + } + if (flags & 16) { + if (this.isWebGL2) { + gl.texParameteri(target2, gl.TEXTURE_WRAP_R, this.glAddress[texture._addressW]); + } + } + if (flags & 32) { + if (this.isWebGL2) { + gl.texParameteri(target2, gl.TEXTURE_COMPARE_MODE, texture._compareOnRead ? gl.COMPARE_REF_TO_TEXTURE : gl.NONE); + } + } + if (flags & 64) { + if (this.isWebGL2) { + gl.texParameteri(target2, gl.TEXTURE_COMPARE_FUNC, this.glComparison[texture._compareFunc]); + } + } + if (flags & 128) { + const ext = this.extTextureFilterAnisotropic; + if (ext) { + gl.texParameterf(target2, ext.TEXTURE_MAX_ANISOTROPY_EXT, math.clamp(Math.round(texture._anisotropy), 1, this.maxAnisotropy)); + } + } + } + setTexture(texture, textureUnit) { + const impl = texture.impl; + if (!impl._glTexture) impl.initialize(this, texture); + if (impl.dirtyParameterFlags > 0 || texture._needsUpload || texture._needsMipmapsUpload) { + this.activeTexture(textureUnit); + this.bindTexture(texture); + if (impl.dirtyParameterFlags) { + this.setTextureParameters(texture); + impl.dirtyParameterFlags = 0; + } + if (texture._needsUpload || texture._needsMipmapsUpload) { + impl.upload(this, texture); + texture._needsUpload = false; + texture._needsMipmapsUpload = false; + } + } else { + this.bindTextureOnUnit(texture, textureUnit); + } + } + createVertexArray(vertexBuffers) { + let key, vao; + const useCache = vertexBuffers.length > 1; + if (useCache) { + key = ""; + for (let i = 0; i < vertexBuffers.length; i++) { + const vertexBuffer = vertexBuffers[i]; + key += vertexBuffer.id + vertexBuffer.format.renderingHash; + } + vao = this._vaoMap.get(key); + } + if (!vao) { + const gl = this.gl; + vao = gl.createVertexArray(); + gl.bindVertexArray(vao); + gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null); + for (let i = 0; i < vertexBuffers.length; i++) { + const vertexBuffer = vertexBuffers[i]; + gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer.impl.bufferId); + const elements = vertexBuffer.format.elements; + for (let j = 0; j < elements.length; j++) { + const e = elements[j]; + const loc = semanticToLocation[e.name]; + if (e.asInt) { + gl.vertexAttribIPointer(loc, e.numComponents, this.glType[e.dataType], e.stride, e.offset); + } else { + gl.vertexAttribPointer(loc, e.numComponents, this.glType[e.dataType], e.normalize, e.stride, e.offset); + } + gl.enableVertexAttribArray(loc); + if (vertexBuffer.format.instancing) { + gl.vertexAttribDivisor(loc, 1); + } + } + } + gl.bindVertexArray(null); + gl.bindBuffer(gl.ARRAY_BUFFER, null); + if (useCache) { + this._vaoMap.set(key, vao); + } + } + return vao; + } + unbindVertexArray() { + if (this.boundVao) { + this.boundVao = null; + this.gl.bindVertexArray(null); + } + } + setBuffers() { + const gl = this.gl; + let vao; + if (this.vertexBuffers.length === 1) { + const vertexBuffer = this.vertexBuffers[0]; + if (!vertexBuffer.impl.vao) { + vertexBuffer.impl.vao = this.createVertexArray(this.vertexBuffers); + } + vao = vertexBuffer.impl.vao; + } else { + vao = this.createVertexArray(this.vertexBuffers); + } + if (this.boundVao !== vao) { + this.boundVao = vao; + gl.bindVertexArray(vao); + } + this.clearVertexBuffer(); + const bufferId = this.indexBuffer ? this.indexBuffer.impl.bufferId : null; + gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, bufferId); + } + draw(primitive2, numInstances, keepBuffers) { + const gl = this.gl; + this.activateShader(this); + if (!this.shaderValid) return; + let sampler, samplerValue, texture, numTextures; + let uniform, scopeId, uniformVersion, programVersion; + const shader = this.shader; + if (!shader) return; + const samplers = shader.impl.samplers; + const uniforms = shader.impl.uniforms; + if (!keepBuffers) { + this.setBuffers(); + } + let textureUnit = 0; + for (let i = 0, len = samplers.length; i < len; i++) { + sampler = samplers[i]; + samplerValue = sampler.scopeId.value; + if (!samplerValue) { + return; + } + if (samplerValue instanceof Texture) { + texture = samplerValue; + this.setTexture(texture, textureUnit); + if (sampler.slot !== textureUnit) { + gl.uniform1i(sampler.locationId, textureUnit); + sampler.slot = textureUnit; + } + textureUnit++; + } else { + sampler.array.length = 0; + numTextures = samplerValue.length; + for (let j = 0; j < numTextures; j++) { + texture = samplerValue[j]; + this.setTexture(texture, textureUnit); + sampler.array[j] = textureUnit; + textureUnit++; + } + gl.uniform1iv(sampler.locationId, sampler.array); + } + } + for (let i = 0, len = uniforms.length; i < len; i++) { + uniform = uniforms[i]; + scopeId = uniform.scopeId; + uniformVersion = uniform.version; + programVersion = scopeId.versionObject.version; + if (uniformVersion.globalId !== programVersion.globalId || uniformVersion.revision !== programVersion.revision) { + uniformVersion.globalId = programVersion.globalId; + uniformVersion.revision = programVersion.revision; + if (scopeId.value !== null) { + this.commitFunction[uniform.dataType](uniform, scopeId.value); + } + } + } + if (this.isWebGL2 && this.transformFeedbackBuffer) { + gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, this.transformFeedbackBuffer.impl.bufferId); + gl.beginTransformFeedback(gl.POINTS); + } + const mode = this.glPrimitive[primitive2.type]; + const count = primitive2.count; + if (primitive2.indexed) { + const indexBuffer = this.indexBuffer; + const format = indexBuffer.impl.glFormat; + const offset = primitive2.base * indexBuffer.bytesPerIndex; + if (numInstances > 0) { + gl.drawElementsInstanced(mode, count, format, offset, numInstances); + } else { + gl.drawElements(mode, count, format, offset); + } + } else { + const first = primitive2.base; + if (numInstances > 0) { + gl.drawArraysInstanced(mode, first, count, numInstances); + } else { + gl.drawArrays(mode, first, count); + } + } + if (this.isWebGL2 && this.transformFeedbackBuffer) { + gl.endTransformFeedback(); + gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, null); + } + this._drawCallsPerFrame++; + } + clear(options) { + var _options$flags; + const defaultOptions = this.defaultClearOptions; + options = options || defaultOptions; + const flags = (_options$flags = options.flags) != null ? _options$flags : defaultOptions.flags; + if (flags !== 0) { + const gl = this.gl; + if (flags & CLEARFLAG_COLOR) { + var _options$color; + const color = (_options$color = options.color) != null ? _options$color : defaultOptions.color; + const r = color[0]; + const g = color[1]; + const b = color[2]; + const a = color[3]; + const c2 = this.clearColor; + if (r !== c2.r || g !== c2.g || b !== c2.b || a !== c2.a) { + this.gl.clearColor(r, g, b, a); + this.clearColor.set(r, g, b, a); + } + this.setBlendState(BlendState.NOBLEND); + } + if (flags & CLEARFLAG_DEPTH) { + var _options$depth; + const depth = (_options$depth = options.depth) != null ? _options$depth : defaultOptions.depth; + if (depth !== this.clearDepth) { + this.gl.clearDepth(depth); + this.clearDepth = depth; + } + this.setDepthState(DepthState.WRITEDEPTH); + } + if (flags & CLEARFLAG_STENCIL) { + var _options$stencil; + const stencil = (_options$stencil = options.stencil) != null ? _options$stencil : defaultOptions.stencil; + if (stencil !== this.clearStencil) { + this.gl.clearStencil(stencil); + this.clearStencil = stencil; + } + gl.stencilMask(255); + this.stencilWriteMaskFront = 255; + this.stencilWriteMaskBack = 255; + } + gl.clear(this.glClearFlag[flags]); + } + } + submit() { + this.gl.flush(); + } + readPixels(x2, y2, w, h, pixels) { + const gl = this.gl; + gl.readPixels(x2, y2, w, h, gl.RGBA, gl.UNSIGNED_BYTE, pixels); + } + async readPixelsAsync(x2, y2, w, h, pixels) { + var _this$renderTarget$co, _impl$_glFormat, _impl$_glPixelType; + const gl = this.gl; + if (!this.isWebGL2) { + this.readPixels(x2, y2, w, h, pixels); + return; + } + const clientWaitAsync = (flags, interval_ms) => { + const sync = gl.fenceSync(gl.SYNC_GPU_COMMANDS_COMPLETE, 0); + this.submit(); + return new Promise((resolve, reject) => { + function test() { + const res = gl.clientWaitSync(sync, flags, 0); + if (res === gl.WAIT_FAILED) { + gl.deleteSync(sync); + reject(new Error("webgl clientWaitSync sync failed")); + } else if (res === gl.TIMEOUT_EXPIRED) { + setTimeout(test, interval_ms); + } else { + gl.deleteSync(sync); + resolve(); + } + } + test(); + }); + }; + const impl = (_this$renderTarget$co = this.renderTarget.colorBuffer) == null ? void 0 : _this$renderTarget$co.impl; + const format = (_impl$_glFormat = impl == null ? void 0 : impl._glFormat) != null ? _impl$_glFormat : gl.RGBA; + const pixelType = (_impl$_glPixelType = impl == null ? void 0 : impl._glPixelType) != null ? _impl$_glPixelType : gl.UNSIGNED_BYTE; + const buf = gl.createBuffer(); + gl.bindBuffer(gl.PIXEL_PACK_BUFFER, buf); + gl.bufferData(gl.PIXEL_PACK_BUFFER, pixels.byteLength, gl.STREAM_READ); + gl.readPixels(x2, y2, w, h, format, pixelType, 0); + gl.bindBuffer(gl.PIXEL_PACK_BUFFER, null); + await clientWaitAsync(0, 20); + gl.bindBuffer(gl.PIXEL_PACK_BUFFER, buf); + gl.getBufferSubData(gl.PIXEL_PACK_BUFFER, 0, pixels); + gl.bindBuffer(gl.PIXEL_PACK_BUFFER, null); + gl.deleteBuffer(buf); + } + setAlphaToCoverage(state) { + if (this.isWebGL1) return; + if (this.alphaToCoverage === state) return; + this.alphaToCoverage = state; + if (state) { + this.gl.enable(this.gl.SAMPLE_ALPHA_TO_COVERAGE); + } else { + this.gl.disable(this.gl.SAMPLE_ALPHA_TO_COVERAGE); + } + } + setTransformFeedbackBuffer(tf) { + if (this.transformFeedbackBuffer === tf) return; + this.transformFeedbackBuffer = tf; + if (this.isWebGL2) { + const gl = this.gl; + if (tf) { + if (!this.feedback) { + this.feedback = gl.createTransformFeedback(); + } + gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, this.feedback); + } else { + gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, null); + } + } + } + setRaster(on) { + if (this.raster === on) return; + this.raster = on; + if (this.isWebGL2) { + if (on) { + this.gl.disable(this.gl.RASTERIZER_DISCARD); + } else { + this.gl.enable(this.gl.RASTERIZER_DISCARD); + } + } + } + setStencilTest(enable) { + if (this.stencil !== enable) { + const gl = this.gl; + if (enable) { + gl.enable(gl.STENCIL_TEST); + } else { + gl.disable(gl.STENCIL_TEST); + } + this.stencil = enable; + } + } + setStencilFunc(func, ref, mask) { + if (this.stencilFuncFront !== func || this.stencilRefFront !== ref || this.stencilMaskFront !== mask || this.stencilFuncBack !== func || this.stencilRefBack !== ref || this.stencilMaskBack !== mask) { + this.gl.stencilFunc(this.glComparison[func], ref, mask); + this.stencilFuncFront = this.stencilFuncBack = func; + this.stencilRefFront = this.stencilRefBack = ref; + this.stencilMaskFront = this.stencilMaskBack = mask; + } + } + setStencilFuncFront(func, ref, mask) { + if (this.stencilFuncFront !== func || this.stencilRefFront !== ref || this.stencilMaskFront !== mask) { + const gl = this.gl; + gl.stencilFuncSeparate(gl.FRONT, this.glComparison[func], ref, mask); + this.stencilFuncFront = func; + this.stencilRefFront = ref; + this.stencilMaskFront = mask; + } + } + setStencilFuncBack(func, ref, mask) { + if (this.stencilFuncBack !== func || this.stencilRefBack !== ref || this.stencilMaskBack !== mask) { + const gl = this.gl; + gl.stencilFuncSeparate(gl.BACK, this.glComparison[func], ref, mask); + this.stencilFuncBack = func; + this.stencilRefBack = ref; + this.stencilMaskBack = mask; + } + } + setStencilOperation(fail, zfail, zpass, writeMask) { + if (this.stencilFailFront !== fail || this.stencilZfailFront !== zfail || this.stencilZpassFront !== zpass || this.stencilFailBack !== fail || this.stencilZfailBack !== zfail || this.stencilZpassBack !== zpass) { + this.gl.stencilOp(this.glStencilOp[fail], this.glStencilOp[zfail], this.glStencilOp[zpass]); + this.stencilFailFront = this.stencilFailBack = fail; + this.stencilZfailFront = this.stencilZfailBack = zfail; + this.stencilZpassFront = this.stencilZpassBack = zpass; + } + if (this.stencilWriteMaskFront !== writeMask || this.stencilWriteMaskBack !== writeMask) { + this.gl.stencilMask(writeMask); + this.stencilWriteMaskFront = writeMask; + this.stencilWriteMaskBack = writeMask; + } + } + setStencilOperationFront(fail, zfail, zpass, writeMask) { + if (this.stencilFailFront !== fail || this.stencilZfailFront !== zfail || this.stencilZpassFront !== zpass) { + this.gl.stencilOpSeparate(this.gl.FRONT, this.glStencilOp[fail], this.glStencilOp[zfail], this.glStencilOp[zpass]); + this.stencilFailFront = fail; + this.stencilZfailFront = zfail; + this.stencilZpassFront = zpass; + } + if (this.stencilWriteMaskFront !== writeMask) { + this.gl.stencilMaskSeparate(this.gl.FRONT, writeMask); + this.stencilWriteMaskFront = writeMask; + } + } + setStencilOperationBack(fail, zfail, zpass, writeMask) { + if (this.stencilFailBack !== fail || this.stencilZfailBack !== zfail || this.stencilZpassBack !== zpass) { + this.gl.stencilOpSeparate(this.gl.BACK, this.glStencilOp[fail], this.glStencilOp[zfail], this.glStencilOp[zpass]); + this.stencilFailBack = fail; + this.stencilZfailBack = zfail; + this.stencilZpassBack = zpass; + } + if (this.stencilWriteMaskBack !== writeMask) { + this.gl.stencilMaskSeparate(this.gl.BACK, writeMask); + this.stencilWriteMaskBack = writeMask; + } + } + setBlendState(blendState) { + const currentBlendState = this.blendState; + if (!currentBlendState.equals(blendState)) { + const gl = this.gl; + const { + blend, + colorOp, + alphaOp, + colorSrcFactor, + colorDstFactor, + alphaSrcFactor, + alphaDstFactor + } = blendState; + if (currentBlendState.blend !== blend) { + if (blend) { + gl.enable(gl.BLEND); + } else { + gl.disable(gl.BLEND); + } + } + if (currentBlendState.colorOp !== colorOp || currentBlendState.alphaOp !== alphaOp) { + const glBlendEquation = this.glBlendEquation; + gl.blendEquationSeparate(glBlendEquation[colorOp], glBlendEquation[alphaOp]); + } + if (currentBlendState.colorSrcFactor !== colorSrcFactor || currentBlendState.colorDstFactor !== colorDstFactor || currentBlendState.alphaSrcFactor !== alphaSrcFactor || currentBlendState.alphaDstFactor !== alphaDstFactor) { + gl.blendFuncSeparate(this.glBlendFunctionColor[colorSrcFactor], this.glBlendFunctionColor[colorDstFactor], this.glBlendFunctionAlpha[alphaSrcFactor], this.glBlendFunctionAlpha[alphaDstFactor]); + } + if (currentBlendState.allWrite !== blendState.allWrite) { + this.gl.colorMask(blendState.redWrite, blendState.greenWrite, blendState.blueWrite, blendState.alphaWrite); + } + currentBlendState.copy(blendState); + } + } + setBlendColor(r, g, b, a) { + const c2 = this.blendColor; + if (r !== c2.r || g !== c2.g || b !== c2.b || a !== c2.a) { + this.gl.blendColor(r, g, b, a); + c2.set(r, g, b, a); + } + } + setStencilState(stencilFront, stencilBack) { + if (stencilFront || stencilBack) { + this.setStencilTest(true); + if (stencilFront === stencilBack) { + this.setStencilFunc(stencilFront.func, stencilFront.ref, stencilFront.readMask); + this.setStencilOperation(stencilFront.fail, stencilFront.zfail, stencilFront.zpass, stencilFront.writeMask); + } else { + var _stencilFront, _stencilBack; + (_stencilFront = stencilFront) != null ? _stencilFront : stencilFront = StencilParameters.DEFAULT; + this.setStencilFuncFront(stencilFront.func, stencilFront.ref, stencilFront.readMask); + this.setStencilOperationFront(stencilFront.fail, stencilFront.zfail, stencilFront.zpass, stencilFront.writeMask); + (_stencilBack = stencilBack) != null ? _stencilBack : stencilBack = StencilParameters.DEFAULT; + this.setStencilFuncBack(stencilBack.func, stencilBack.ref, stencilBack.readMask); + this.setStencilOperationBack(stencilBack.fail, stencilBack.zfail, stencilBack.zpass, stencilBack.writeMask); + } + } else { + this.setStencilTest(false); + } + } + setDepthState(depthState) { + const currentDepthState = this.depthState; + if (!currentDepthState.equals(depthState)) { + const gl = this.gl; + const write = depthState.write; + if (currentDepthState.write !== write) { + gl.depthMask(write); + } + let { + func, + test + } = depthState; + if (!test && write) { + test = true; + func = FUNC_ALWAYS; + } + if (currentDepthState.func !== func) { + gl.depthFunc(this.glComparison[func]); + } + if (currentDepthState.test !== test) { + if (test) { + gl.enable(gl.DEPTH_TEST); + } else { + gl.disable(gl.DEPTH_TEST); + } + } + const { + depthBias, + depthBiasSlope + } = depthState; + if (depthBias || depthBiasSlope) { + if (!this.depthBiasEnabled) { + this.depthBiasEnabled = true; + this.gl.enable(this.gl.POLYGON_OFFSET_FILL); + } + gl.polygonOffset(depthBiasSlope, depthBias); + } else { + if (this.depthBiasEnabled) { + this.depthBiasEnabled = false; + this.gl.disable(this.gl.POLYGON_OFFSET_FILL); + } + } + currentDepthState.copy(depthState); + } + } + setCullMode(cullMode) { + if (this.cullMode !== cullMode) { + if (cullMode === CULLFACE_NONE) { + this.gl.disable(this.gl.CULL_FACE); + } else { + if (this.cullMode === CULLFACE_NONE) { + this.gl.enable(this.gl.CULL_FACE); + } + const mode = this.glCull[cullMode]; + if (this.cullFace !== mode) { + this.gl.cullFace(mode); + this.cullFace = mode; + } + } + this.cullMode = cullMode; + } + } + setShader(shader, asyncCompile = false) { + if (shader !== this.shader) { + this.shader = shader; + this.shaderAsyncCompile = asyncCompile; + this.shaderValid = void 0; + } + } + activateShader(device) { + const { + shader + } = this; + const { + impl + } = shader; + if (this.shaderValid === void 0) { + if (shader.failed) { + this.shaderValid = false; + } else if (!shader.ready) { + if (this.shaderAsyncCompile) { + if (impl.isLinked(device)) { + if (!impl.finalize(this, shader)) { + shader.failed = true; + this.shaderValid = false; + } + } else { + this.shaderValid = false; + } + } else { + if (!impl.finalize(this, shader)) { + shader.failed = true; + this.shaderValid = false; + } + } + } + } + if (this.shaderValid === void 0) { + this.gl.useProgram(impl.glProgram); + this.shaderValid = true; + } + } + clearVertexArrayObjectCache() { + const gl = this.gl; + this._vaoMap.forEach((item, key, mapObj) => { + gl.deleteVertexArray(item); + }); + this._vaoMap.clear(); + } + set fullscreen(fullscreen) { + if (fullscreen) { + const canvas = this.gl.canvas; + canvas.requestFullscreen(); + } else { + document.exitFullscreen(); + } + } + get fullscreen() { + return !!document.fullscreenElement; + } + get textureFloatHighPrecision() { + if (this._textureFloatHighPrecision === void 0) { + this._textureFloatHighPrecision = testTextureFloatHighPrecision(this); + } + return this._textureFloatHighPrecision; + } + get textureHalfFloatUpdatable() { + if (this._textureHalfFloatUpdatable === void 0) { + if (this.isWebGL2) { + this._textureHalfFloatUpdatable = true; + } else { + this._textureHalfFloatUpdatable = testTextureHalfFloatUpdatable(this.gl, this.extTextureHalfFloat.HALF_FLOAT_OES); + } + } + return this._textureHalfFloatUpdatable; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/null/null-index-buffer.js +var NullIndexBuffer = class { + unlock(indexBuffer) { + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/null/null-render-target.js +var NullRenderTarget = class { + destroy(device) { + } + init(device, renderTarget) { + } + loseContext() { + } + resolve(device, target2, color, depth) { + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/null/null-shader.js +var NullShader = class { + destroy(shader) { + } + loseContext() { + } + restoreContext(device, shader) { + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/null/null-texture.js +var NullTexture = class { + destroy(device) { + } + propertyChanged(flag) { + } + loseContext() { + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/null/null-vertex-buffer.js +var NullVertexBuffer = class { + destroy(device) { + } + unlock(vertexBuffer) { + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/null/null-graphics-device.js +var NullGraphicsDevice = class extends GraphicsDevice { + constructor(canvas, options = {}) { + super(canvas, options); + options = this.initOptions; + this.isNull = true; + this._deviceType = DEVICETYPE_NULL; + this.samples = 1; + } + destroy() { + super.destroy(); + } + initDeviceCaps() { + this.disableParticleSystem = true; + this.precision = "highp"; + this.maxPrecision = "highp"; + this.maxSamples = 4; + this.maxTextures = 16; + this.maxTextureSize = 4096; + this.maxCubeMapSize = 4096; + this.maxVolumeSize = 4096; + this.maxColorAttachments = 8; + this.maxPixelRatio = 1; + this.maxAnisotropy = 16; + this.supportsInstancing = true; + this.supportsUniformBuffers = false; + this.supportsVolumeTextures = true; + this.supportsBoneTextures = true; + this.supportsMorphTargetTexturesCore = true; + this.supportsAreaLights = true; + this.supportsDepthShadow = true; + this.supportsGpuParticles = false; + this.supportsMrt = true; + this.extUintElement = true; + this.extTextureFloat = true; + this.textureFloatRenderable = true; + this.extTextureHalfFloat = true; + this.textureHalfFloatRenderable = true; + this.textureHalfFloatUpdatable = true; + this.boneLimit = 1024; + this.supportsImageBitmap = true; + this.extStandardDerivatives = true; + this.extBlendMinmax = true; + this.areaLightLutFormat = PIXELFORMAT_RGBA8; + this.supportsTextureFetch = true; + } + postInit() { + super.postInit(); + } + frameStart() { + super.frameStart(); + } + frameEnd() { + super.frameEnd(); + } + updateBegin() { + } + updateEnd() { + } + readPixels(x2, y2, w, h, pixels) { + } + createVertexBufferImpl(vertexBuffer, format) { + return new NullVertexBuffer(vertexBuffer, format); + } + createIndexBufferImpl(indexBuffer) { + return new NullIndexBuffer(indexBuffer); + } + createShaderImpl(shader) { + return new NullShader(shader); + } + createTextureImpl(texture) { + return new NullTexture(texture); + } + createRenderTargetImpl(renderTarget) { + return new NullRenderTarget(renderTarget); + } + draw(primitive2, numInstances = 1, keepBuffers) { + } + setShader(shader, asyncCompile = false) { + } + setBlendState(blendState) { + } + setDepthState(depthState) { + } + setStencilState(stencilFront, stencilBack) { + } + setBlendColor(r, g, b, a) { + } + setCullMode(cullMode) { + } + setAlphaToCoverage(state) { + } + initializeContextCaches() { + super.initializeContextCaches(); + } + clear(options) { + } + setViewport(x2, y2, w, h) { + } + setScissor(x2, y2, w, h) { + } + copyRenderTarget(source, dest, color, depth) { + return true; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/graphics-device-create.js +function createGraphicsDevice(canvas, options = {}) { + var _options$deviceTypes; + const deviceTypes = (_options$deviceTypes = options.deviceTypes) != null ? _options$deviceTypes : []; + if (!deviceTypes.includes(DEVICETYPE_WEBGL2)) { + deviceTypes.push(DEVICETYPE_WEBGL2); + } + if (!deviceTypes.includes(DEVICETYPE_WEBGL1)) { + deviceTypes.push(DEVICETYPE_WEBGL1); + } + if (!deviceTypes.includes(DEVICETYPE_NULL)) { + deviceTypes.push(DEVICETYPE_NULL); + } + if (platform.browser && !!navigator.xr) { + var _options$xrCompatible; + (_options$xrCompatible = options.xrCompatible) != null ? _options$xrCompatible : options.xrCompatible = true; + } + const deviceCreateFuncs = []; + for (let i = 0; i < deviceTypes.length; i++) { + var _window; + const deviceType = deviceTypes[i]; + if (deviceType === DEVICETYPE_WEBGPU && (_window = window) != null && (_window = _window.navigator) != null && _window.gpu) { + deviceCreateFuncs.push(() => { + const device = new WebgpuGraphicsDevice(canvas, options); + return device.initWebGpu(options.glslangUrl, options.twgslUrl); + }); + } + if (deviceType === DEVICETYPE_WEBGL1 || deviceType === DEVICETYPE_WEBGL2) { + deviceCreateFuncs.push(() => { + options.preferWebGl2 = deviceType === DEVICETYPE_WEBGL2; + return new WebglGraphicsDevice(canvas, options); + }); + } + if (deviceType === DEVICETYPE_NULL) { + deviceCreateFuncs.push(() => { + return new NullGraphicsDevice(canvas, options); + }); + } + } + return new Promise((resolve, reject) => { + let attempt = 0; + const next = () => { + if (attempt >= deviceCreateFuncs.length) { + reject(new Error("Failed to create a graphics device")); + } else { + Promise.resolve(deviceCreateFuncs[attempt++]()).then((device) => { + if (device) { + resolve(device); + } else { + next(); + } + }).catch((err) => { + console.log(err); + next(); + }); + } + }; + next(); + }); +} + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/index-buffer.js +var id7 = 0; +var IndexBuffer = class { + constructor(graphicsDevice, format, numIndices, usage = BUFFER_STATIC, initialData, options) { + this.device = graphicsDevice; + this.format = format; + this.numIndices = numIndices; + this.usage = usage; + this.id = id7++; + this.impl = graphicsDevice.createIndexBufferImpl(this, options); + const bytesPerIndex = typedArrayIndexFormatsByteSize[format]; + this.bytesPerIndex = bytesPerIndex; + this.numBytes = this.numIndices * bytesPerIndex; + if (initialData) { + this.setData(initialData); + } else { + this.storage = new ArrayBuffer(this.numBytes); + } + this.adjustVramSizeTracking(graphicsDevice._vram, this.numBytes); + this.device.buffers.push(this); + } + destroy() { + const device = this.device; + const idx = device.buffers.indexOf(this); + if (idx !== -1) { + device.buffers.splice(idx, 1); + } + if (this.device.indexBuffer === this) { + this.device.indexBuffer = null; + } + if (this.impl.initialized) { + this.impl.destroy(device); + this.adjustVramSizeTracking(device._vram, -this.storage.byteLength); + } + } + adjustVramSizeTracking(vram, size) { + vram.ib += size; + } + loseContext() { + this.impl.loseContext(); + } + getFormat() { + return this.format; + } + getNumIndices() { + return this.numIndices; + } + lock() { + return this.storage; + } + unlock() { + this.impl.unlock(this); + } + setData(data2) { + if (data2.byteLength !== this.numBytes) { + return false; + } + this.storage = data2; + this.unlock(); + return true; + } + _lockTypedArray() { + const lock = this.lock(); + const indices = this.format === INDEXFORMAT_UINT32 ? new Uint32Array(lock) : this.format === INDEXFORMAT_UINT16 ? new Uint16Array(lock) : new Uint8Array(lock); + return indices; + } + writeData(data2, count) { + const indices = this._lockTypedArray(); + if (data2.length > count) { + if (ArrayBuffer.isView(data2)) { + data2 = data2.subarray(0, count); + indices.set(data2); + } else { + for (let i = 0; i < count; i++) indices[i] = data2[i]; + } + } else { + indices.set(data2); + } + this.unlock(); + } + readData(data2) { + const indices = this._lockTypedArray(); + const count = this.numIndices; + if (ArrayBuffer.isView(data2)) { + data2.set(indices); + } else { + data2.length = 0; + for (let i = 0; i < count; i++) data2[i] = indices[i]; + } + return count; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/render-pass.js +var ColorAttachmentOps = class { + constructor() { + this.clearValue = new Color(0, 0, 0, 1); + this.clear = false; + this.store = false; + this.resolve = true; + this.mipmaps = false; + } +}; +var DepthStencilAttachmentOps = class { + constructor() { + this.clearDepthValue = 1; + this.clearStencilValue = 0; + this.clearDepth = false; + this.clearStencil = false; + this.storeDepth = false; + this.storeStencil = false; + } +}; +var RenderPass = class { + get colorOps() { + return this.colorArrayOps[0]; + } + constructor(graphicsDevice) { + this._name = void 0; + this.device = void 0; + this._enabled = true; + this.executeEnabled = true; + this.renderTarget = void 0; + this._options = void 0; + this.samples = 0; + this.colorArrayOps = []; + this.depthStencilOps = void 0; + this.requiresCubemaps = true; + this.fullSizeClearRect = true; + this.beforePasses = []; + this.afterPasses = []; + this.device = graphicsDevice; + } + set name(value) { + this._name = value; + } + get name() { + if (!this._name) this._name = this.constructor.name; + return this._name; + } + set options(value) { + this._options = value; + if (value) { + var _this$_options$scaleX, _this$_options$scaleY; + this._options.scaleX = (_this$_options$scaleX = this._options.scaleX) != null ? _this$_options$scaleX : 1; + this._options.scaleY = (_this$_options$scaleY = this._options.scaleY) != null ? _this$_options$scaleY : 1; + } + } + get options() { + return this._options; + } + init(renderTarget = null, options = null) { + var _renderTarget$_colorB; + this.options = options; + this.renderTarget = renderTarget; + this.samples = Math.max(this.renderTarget ? this.renderTarget.samples : this.device.samples, 1); + this.depthStencilOps = new DepthStencilAttachmentOps(); + const numColorOps = renderTarget ? (_renderTarget$_colorB = renderTarget._colorBuffers) == null ? void 0 : _renderTarget$_colorB.length : 1; + this.colorArrayOps.length = 0; + for (let i = 0; i < numColorOps; i++) { + var _this$renderTarget; + const colorOps = new ColorAttachmentOps(); + this.colorArrayOps[i] = colorOps; + if (this.samples === 1) { + colorOps.store = true; + colorOps.resolve = false; + } + if ((_this$renderTarget = this.renderTarget) != null && (_this$renderTarget = _this$renderTarget._colorBuffers) != null && _this$renderTarget[i].mipmaps) { + colorOps.mipmaps = true; + } + } + this.postInit(); + } + destroy() { + } + postInit() { + } + frameUpdate() { + if (this._options && this.renderTarget) { + var _this$_options$resize; + const resizeSource = (_this$_options$resize = this._options.resizeSource) != null ? _this$_options$resize : this.device.backBuffer; + const width = Math.floor(resizeSource.width * this._options.scaleX); + const height = Math.floor(resizeSource.height * this._options.scaleY); + this.renderTarget.resize(width, height); + } + } + before() { + } + execute() { + } + after() { + } + onEnable() { + } + onDisable() { + } + set enabled(value) { + if (this._enabled !== value) { + this._enabled = value; + if (value) { + this.onEnable(); + } else { + this.onDisable(); + } + } + } + get enabled() { + return this._enabled; + } + setClearColor(color) { + const count = this.colorArrayOps.length; + for (let i = 0; i < count; i++) { + const colorOps = this.colorArrayOps[i]; + if (color) colorOps.clearValue.copy(color); + colorOps.clear = !!color; + } + } + setClearDepth(depthValue) { + if (depthValue) this.depthStencilOps.clearDepthValue = depthValue; + this.depthStencilOps.clearDepth = depthValue !== void 0; + } + setClearStencil(stencilValue) { + if (stencilValue) this.depthStencilOps.clearStencilValue = stencilValue; + this.depthStencilOps.clearStencil = stencilValue !== void 0; + } + render() { + if (this.enabled) { + const device = this.device; + const realPass = this.renderTarget !== void 0; + this.before(); + if (this.executeEnabled) { + if (realPass) { + device.startRenderPass(this); + } + this.execute(); + if (realPass) { + device.endRenderPass(this); + } + } + this.after(); + device.renderPassIndex++; + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/shader-processor-options.js +var ShaderProcessorOptions = class { + constructor(viewUniformFormat, viewBindGroupFormat, vertexFormat) { + this.uniformFormats = []; + this.bindGroupFormats = []; + this.vertexFormat = void 0; + this.uniformFormats[BINDGROUP_VIEW] = viewUniformFormat; + this.bindGroupFormats[BINDGROUP_VIEW] = viewBindGroupFormat; + this.vertexFormat = vertexFormat; + } + hasUniform(name) { + for (let i = 0; i < this.uniformFormats.length; i++) { + const uniformFormat = this.uniformFormats[i]; + if (uniformFormat != null && uniformFormat.get(name)) { + return true; + } + } + return false; + } + hasTexture(name) { + for (let i = 0; i < this.bindGroupFormats.length; i++) { + const groupFormat = this.bindGroupFormats[i]; + if (groupFormat != null && groupFormat.getTexture(name)) { + return true; + } + } + return false; + } + getVertexElement(semantic) { + var _this$vertexFormat; + return (_this$vertexFormat = this.vertexFormat) == null ? void 0 : _this$vertexFormat.elements.find((element) => element.name === semantic); + } + generateKey(device) { + let key = JSON.stringify(this.uniformFormats) + JSON.stringify(this.bindGroupFormats); + if (device.isWebGPU) { + var _this$vertexFormat2; + key += (_this$vertexFormat2 = this.vertexFormat) == null ? void 0 : _this$vertexFormat2.shaderProcessingHashString; + } + return key; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/vertex-iterator.js +function set1(a) { + this.array[this.index] = a; +} +function set2(a, b) { + this.array[this.index] = a; + this.array[this.index + 1] = b; +} +function set3(a, b, c2) { + this.array[this.index] = a; + this.array[this.index + 1] = b; + this.array[this.index + 2] = c2; +} +function set4(a, b, c2, d) { + this.array[this.index] = a; + this.array[this.index + 1] = b; + this.array[this.index + 2] = c2; + this.array[this.index + 3] = d; +} +function arraySet1(index, inputArray, inputIndex) { + this.array[index] = inputArray[inputIndex]; +} +function arraySet2(index, inputArray, inputIndex) { + this.array[index] = inputArray[inputIndex]; + this.array[index + 1] = inputArray[inputIndex + 1]; +} +function arraySet3(index, inputArray, inputIndex) { + this.array[index] = inputArray[inputIndex]; + this.array[index + 1] = inputArray[inputIndex + 1]; + this.array[index + 2] = inputArray[inputIndex + 2]; +} +function arraySet4(index, inputArray, inputIndex) { + this.array[index] = inputArray[inputIndex]; + this.array[index + 1] = inputArray[inputIndex + 1]; + this.array[index + 2] = inputArray[inputIndex + 2]; + this.array[index + 3] = inputArray[inputIndex + 3]; +} +function arrayGet1(offset, outputArray, outputIndex) { + outputArray[outputIndex] = this.array[offset]; +} +function arrayGet2(offset, outputArray, outputIndex) { + outputArray[outputIndex] = this.array[offset]; + outputArray[outputIndex + 1] = this.array[offset + 1]; +} +function arrayGet3(offset, outputArray, outputIndex) { + outputArray[outputIndex] = this.array[offset]; + outputArray[outputIndex + 1] = this.array[offset + 1]; + outputArray[outputIndex + 2] = this.array[offset + 2]; +} +function arrayGet4(offset, outputArray, outputIndex) { + outputArray[outputIndex] = this.array[offset]; + outputArray[outputIndex + 1] = this.array[offset + 1]; + outputArray[outputIndex + 2] = this.array[offset + 2]; + outputArray[outputIndex + 3] = this.array[offset + 3]; +} +var VertexIteratorAccessor = class { + constructor(buffer, vertexElement, vertexFormat) { + this.index = 0; + this.numComponents = vertexElement.numComponents; + if (vertexFormat.interleaved) { + this.array = new typedArrayTypes[vertexElement.dataType](buffer, vertexElement.offset); + } else { + this.array = new typedArrayTypes[vertexElement.dataType](buffer, vertexElement.offset, vertexFormat.vertexCount * vertexElement.numComponents); + } + this.stride = vertexElement.stride / this.array.constructor.BYTES_PER_ELEMENT; + switch (vertexElement.numComponents) { + case 1: + this.set = set1; + this.getToArray = arrayGet1; + this.setFromArray = arraySet1; + break; + case 2: + this.set = set2; + this.getToArray = arrayGet2; + this.setFromArray = arraySet2; + break; + case 3: + this.set = set3; + this.getToArray = arrayGet3; + this.setFromArray = arraySet3; + break; + case 4: + this.set = set4; + this.getToArray = arrayGet4; + this.setFromArray = arraySet4; + break; + } + } + get(offset) { + return this.array[this.index + offset]; + } + set(a, b, c2, d) { + } + getToArray(offset, outputArray, outputIndex) { + } + setFromArray(index, inputArray, inputIndex) { + } +}; +var VertexIterator = class { + constructor(vertexBuffer) { + this.vertexBuffer = vertexBuffer; + this.vertexFormatSize = vertexBuffer.getFormat().size; + this.buffer = this.vertexBuffer.lock(); + this.accessors = []; + this.element = {}; + const vertexFormat = this.vertexBuffer.getFormat(); + for (let i = 0; i < vertexFormat.elements.length; i++) { + const vertexElement = vertexFormat.elements[i]; + this.accessors[i] = new VertexIteratorAccessor(this.buffer, vertexElement, vertexFormat); + this.element[vertexElement.name] = this.accessors[i]; + } + } + next(count = 1) { + let i = 0; + const accessors = this.accessors; + const numAccessors = this.accessors.length; + while (i < numAccessors) { + const accessor = accessors[i++]; + accessor.index += count * accessor.stride; + } + } + end() { + this.vertexBuffer.unlock(); + } + writeData(semantic, data2, numVertices) { + const element = this.element[semantic]; + if (element) { + if (numVertices > this.vertexBuffer.numVertices) { + numVertices = this.vertexBuffer.numVertices; + } + const numComponents = element.numComponents; + if (this.vertexBuffer.getFormat().interleaved) { + let index = 0; + for (let i = 0; i < numVertices; i++) { + element.setFromArray(index, data2, i * numComponents); + index += element.stride; + } + } else { + if (data2.length > numVertices * numComponents) { + const copyCount = numVertices * numComponents; + if (ArrayBuffer.isView(data2)) { + data2 = data2.subarray(0, copyCount); + element.array.set(data2); + } else { + for (let i = 0; i < copyCount; i++) element.array[i] = data2[i]; + } + } else { + element.array.set(data2); + } + } + } + } + readData(semantic, data2) { + const element = this.element[semantic]; + let count = 0; + if (element) { + count = this.vertexBuffer.numVertices; + let i; + const numComponents = element.numComponents; + if (this.vertexBuffer.getFormat().interleaved) { + if (Array.isArray(data2)) data2.length = 0; + element.index = 0; + let offset = 0; + for (i = 0; i < count; i++) { + element.getToArray(offset, data2, i * numComponents); + offset += element.stride; + } + } else { + if (ArrayBuffer.isView(data2)) { + data2.set(element.array); + } else { + data2.length = 0; + const copyCount = count * numComponents; + for (i = 0; i < copyCount; i++) data2[i] = element.array[i]; + } + } + } + return count; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/input/constants.js +var EVENT_MOUSEDOWN = "mousedown"; +var EVENT_MOUSEMOVE = "mousemove"; +var EVENT_MOUSEUP = "mouseup"; +var EVENT_MOUSEWHEEL = "mousewheel"; +var MOUSEBUTTON_NONE = -1; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/input/mouse-event.js +function isMousePointerLocked() { + return !!(document.pointerLockElement || document.mozPointerLockElement || document.webkitPointerLockElement); +} +var MouseEvent = class _MouseEvent { + constructor(mouse, event) { + var _event$ctrlKey, _event$altKey, _event$shiftKey, _event$metaKey; + this.x = 0; + this.y = 0; + this.dx = 0; + this.dy = 0; + this.button = MOUSEBUTTON_NONE; + this.wheelDelta = 0; + this.element = void 0; + this.ctrlKey = false; + this.altKey = false; + this.shiftKey = false; + this.metaKey = false; + this.event = void 0; + let coords = { + x: 0, + y: 0 + }; + if (event) { + if (event instanceof _MouseEvent) { + throw Error("Expected MouseEvent"); + } + coords = mouse._getTargetCoords(event); + } else { + event = {}; + } + if (coords) { + this.x = coords.x; + this.y = coords.y; + } else if (isMousePointerLocked()) { + this.x = 0; + this.y = 0; + } else { + return; + } + if (event.type === "wheel") { + if (event.deltaY > 0) { + this.wheelDelta = 1; + } else if (event.deltaY < 0) { + this.wheelDelta = -1; + } + } + if (isMousePointerLocked()) { + this.dx = event.movementX || event.webkitMovementX || event.mozMovementX || 0; + this.dy = event.movementY || event.webkitMovementY || event.mozMovementY || 0; + } else { + this.dx = this.x - mouse._lastX; + this.dy = this.y - mouse._lastY; + } + if (event.type === "mousedown" || event.type === "mouseup") { + this.button = event.button; + } + this.buttons = mouse._buttons.slice(0); + this.element = event.target; + this.ctrlKey = (_event$ctrlKey = event.ctrlKey) != null ? _event$ctrlKey : false; + this.altKey = (_event$altKey = event.altKey) != null ? _event$altKey : false; + this.shiftKey = (_event$shiftKey = event.shiftKey) != null ? _event$shiftKey : false; + this.metaKey = (_event$metaKey = event.metaKey) != null ? _event$metaKey : false; + this.event = event; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/input/mouse.js +var Mouse = class extends EventHandler { + constructor(element) { + super(); + this._lastX = 0; + this._lastY = 0; + this._buttons = [false, false, false]; + this._lastbuttons = [false, false, false]; + this._target = null; + this._attached = false; + this._upHandler = this._handleUp.bind(this); + this._downHandler = this._handleDown.bind(this); + this._moveHandler = this._handleMove.bind(this); + this._wheelHandler = this._handleWheel.bind(this); + this._contextMenuHandler = (event) => { + event.preventDefault(); + }; + this.attach(element); + } + static isPointerLocked() { + return isMousePointerLocked(); + } + attach(element) { + this._target = element; + if (this._attached) return; + this._attached = true; + const passiveOptions = { + passive: false + }; + const options = platform.passiveEvents ? passiveOptions : false; + window.addEventListener("mouseup", this._upHandler, options); + window.addEventListener("mousedown", this._downHandler, options); + window.addEventListener("mousemove", this._moveHandler, options); + window.addEventListener("wheel", this._wheelHandler, options); + } + detach() { + if (!this._attached) return; + this._attached = false; + this._target = null; + const passiveOptions = { + passive: false + }; + const options = platform.passiveEvents ? passiveOptions : false; + window.removeEventListener("mouseup", this._upHandler, options); + window.removeEventListener("mousedown", this._downHandler, options); + window.removeEventListener("mousemove", this._moveHandler, options); + window.removeEventListener("wheel", this._wheelHandler, options); + } + disableContextMenu() { + if (!this._target) return; + this._target.addEventListener("contextmenu", this._contextMenuHandler); + } + enableContextMenu() { + if (!this._target) return; + this._target.removeEventListener("contextmenu", this._contextMenuHandler); + } + enablePointerLock(success, error) { + if (!document.body.requestPointerLock) { + if (error) error(); + return; + } + const s = () => { + success(); + document.removeEventListener("pointerlockchange", s); + }; + const e = () => { + error(); + document.removeEventListener("pointerlockerror", e); + }; + if (success) { + document.addEventListener("pointerlockchange", s, false); + } + if (error) { + document.addEventListener("pointerlockerror", e, false); + } + document.body.requestPointerLock(); + } + disablePointerLock(success) { + if (!document.exitPointerLock) { + return; + } + const s = () => { + success(); + document.removeEventListener("pointerlockchange", s); + }; + if (success) { + document.addEventListener("pointerlockchange", s, false); + } + document.exitPointerLock(); + } + update() { + this._lastbuttons[0] = this._buttons[0]; + this._lastbuttons[1] = this._buttons[1]; + this._lastbuttons[2] = this._buttons[2]; + } + isPressed(button) { + return this._buttons[button]; + } + wasPressed(button) { + return this._buttons[button] && !this._lastbuttons[button]; + } + wasReleased(button) { + return !this._buttons[button] && this._lastbuttons[button]; + } + _handleUp(event) { + this._buttons[event.button] = false; + const e = new MouseEvent(this, event); + if (!e.event) return; + this.fire(EVENT_MOUSEUP, e); + } + _handleDown(event) { + this._buttons[event.button] = true; + const e = new MouseEvent(this, event); + if (!e.event) return; + this.fire(EVENT_MOUSEDOWN, e); + } + _handleMove(event) { + const e = new MouseEvent(this, event); + if (!e.event) return; + this.fire(EVENT_MOUSEMOVE, e); + this._lastX = e.x; + this._lastY = e.y; + } + _handleWheel(event) { + const e = new MouseEvent(this, event); + if (!e.event) return; + this.fire(EVENT_MOUSEWHEEL, e); + } + _getTargetCoords(event) { + const rect = this._target.getBoundingClientRect(); + const left = Math.floor(rect.left); + const top = Math.floor(rect.top); + if (event.clientX < left || event.clientX >= left + this._target.clientWidth || event.clientY < top || event.clientY >= top + this._target.clientHeight) { + return null; + } + return { + x: event.clientX - left, + y: event.clientY - top + }; + } +}; +Mouse.EVENT_MOUSEMOVE = EVENT_MOUSEMOVE; +Mouse.EVENT_MOUSEDOWN = EVENT_MOUSEDOWN; +Mouse.EVENT_MOUSEUP = EVENT_MOUSEUP; +Mouse.EVENT_MOUSEWHEEL = EVENT_MOUSEWHEEL; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/net/http.js +var Http = class _Http { + get(url, options, callback) { + if (typeof options === "function") { + callback = options; + options = {}; + } + return this.request("GET", url, options, callback); + } + post(url, data2, options, callback) { + if (typeof options === "function") { + callback = options; + options = {}; + } + options.postdata = data2; + return this.request("POST", url, options, callback); + } + put(url, data2, options, callback) { + if (typeof options === "function") { + callback = options; + options = {}; + } + options.postdata = data2; + return this.request("PUT", url, options, callback); + } + del(url, options, callback) { + if (typeof options === "function") { + callback = options; + options = {}; + } + return this.request("DELETE", url, options, callback); + } + request(method, url, options, callback) { + let uri, query, postdata; + let errored = false; + if (typeof options === "function") { + callback = options; + options = {}; + } + if (options.retry) { + options = Object.assign({ + retries: 0, + maxRetries: 5 + }, options); + } + options.callback = callback; + if (options.async == null) { + options.async = true; + } + if (options.headers == null) { + options.headers = {}; + } + if (options.postdata != null) { + if (options.postdata instanceof Document) { + postdata = options.postdata; + } else if (options.postdata instanceof FormData) { + postdata = options.postdata; + } else if (options.postdata instanceof Object) { + let contentType = options.headers["Content-Type"]; + if (contentType === void 0) { + options.headers["Content-Type"] = _Http.ContentType.FORM_URLENCODED; + contentType = options.headers["Content-Type"]; + } + switch (contentType) { + case _Http.ContentType.FORM_URLENCODED: { + postdata = ""; + let bFirstItem = true; + for (const key in options.postdata) { + if (options.postdata.hasOwnProperty(key)) { + if (bFirstItem) { + bFirstItem = false; + } else { + postdata += "&"; + } + const encodedKey = encodeURIComponent(key); + const encodedValue = encodeURIComponent(options.postdata[key]); + postdata += `${encodedKey}=${encodedValue}`; + } + } + break; + } + default: + case _Http.ContentType.JSON: + if (contentType == null) { + options.headers["Content-Type"] = _Http.ContentType.JSON; + } + postdata = JSON.stringify(options.postdata); + break; + } + } else { + postdata = options.postdata; + } + } + if (options.cache === false) { + const timestamp = now(); + uri = new URI(url); + if (!uri.query) { + uri.query = "ts=" + timestamp; + } else { + uri.query = uri.query + "&ts=" + timestamp; + } + url = uri.toString(); + } + if (options.query) { + uri = new URI(url); + query = extend(uri.getQuery(), options.query); + uri.setQuery(query); + url = uri.toString(); + } + const xhr = new XMLHttpRequest(); + xhr.open(method, url, options.async); + xhr.withCredentials = options.withCredentials !== void 0 ? options.withCredentials : false; + xhr.responseType = options.responseType || this._guessResponseType(url); + for (const header in options.headers) { + if (options.headers.hasOwnProperty(header)) { + xhr.setRequestHeader(header, options.headers[header]); + } + } + xhr.onreadystatechange = () => { + this._onReadyStateChange(method, url, options, xhr); + }; + xhr.onerror = () => { + this._onError(method, url, options, xhr); + errored = true; + }; + try { + xhr.send(postdata); + } catch (e) { + if (!errored) { + options.error(xhr.status, xhr, e); + } + } + return xhr; + } + _guessResponseType(url) { + const uri = new URI(url); + const ext = path.getExtension(uri.path).toLowerCase(); + if (_Http.binaryExtensions.indexOf(ext) >= 0) { + return _Http.ResponseType.ARRAY_BUFFER; + } else if (ext === ".json") { + return _Http.ResponseType.JSON; + } else if (ext === ".xml") { + return _Http.ResponseType.DOCUMENT; + } + return _Http.ResponseType.TEXT; + } + _isBinaryContentType(contentType) { + const binTypes = [_Http.ContentType.BASIS, _Http.ContentType.BIN, _Http.ContentType.DDS, _Http.ContentType.GLB, _Http.ContentType.MP3, _Http.ContentType.MP4, _Http.ContentType.OGG, _Http.ContentType.OPUS, _Http.ContentType.WAV]; + if (binTypes.indexOf(contentType) >= 0) { + return true; + } + return false; + } + _isBinaryResponseType(responseType) { + return responseType === _Http.ResponseType.ARRAY_BUFFER || responseType === _Http.ResponseType.BLOB || responseType === _Http.ResponseType.JSON; + } + _onReadyStateChange(method, url, options, xhr) { + if (xhr.readyState === 4) { + switch (xhr.status) { + case 0: { + if (xhr.responseURL && xhr.responseURL.startsWith("file:///")) { + this._onSuccess(method, url, options, xhr); + } else { + this._onError(method, url, options, xhr); + } + break; + } + case 200: + case 201: + case 206: + case 304: { + this._onSuccess(method, url, options, xhr); + break; + } + default: { + this._onError(method, url, options, xhr); + break; + } + } + } + } + _onSuccess(method, url, options, xhr) { + let response; + let contentType; + const header = xhr.getResponseHeader("Content-Type"); + if (header) { + const parts = header.split(";"); + contentType = parts[0].trim(); + } + try { + if (this._isBinaryContentType(contentType) || this._isBinaryResponseType(xhr.responseType)) { + response = xhr.response; + } else if (contentType === _Http.ContentType.JSON || url.split("?")[0].endsWith(".json")) { + response = JSON.parse(xhr.responseText); + } else if (xhr.responseType === _Http.ResponseType.DOCUMENT || contentType === _Http.ContentType.XML) { + response = xhr.responseXML; + } else { + response = xhr.responseText; + } + options.callback(null, response); + } catch (err) { + options.callback(err); + } + } + _onError(method, url, options, xhr) { + if (options.retrying) { + return; + } + if (options.retry && options.retries < options.maxRetries) { + options.retries++; + options.retrying = true; + const retryDelay = math.clamp(Math.pow(2, options.retries) * _Http.retryDelay, 0, options.maxRetryDelay || 5e3); + console.log(`${method}: ${url} - Error ${xhr.status}. Retrying in ${retryDelay} ms`); + setTimeout(() => { + options.retrying = false; + this.request(method, url, options, options.callback); + }, retryDelay); + } else { + options.callback(xhr.status === 0 ? "Network error" : xhr.status, null); + } + } +}; +Http.ContentType = { + AAC: "audio/aac", + BASIS: "image/basis", + BIN: "application/octet-stream", + DDS: "image/dds", + FORM_URLENCODED: "application/x-www-form-urlencoded", + GIF: "image/gif", + GLB: "model/gltf-binary", + JPEG: "image/jpeg", + JSON: "application/json", + MP3: "audio/mpeg", + MP4: "audio/mp4", + OGG: "audio/ogg", + OPUS: 'audio/ogg; codecs="opus"', + PNG: "image/png", + TEXT: "text/plain", + WAV: "audio/x-wav", + XML: "application/xml" +}; +Http.ResponseType = { + TEXT: "text", + ARRAY_BUFFER: "arraybuffer", + BLOB: "blob", + DOCUMENT: "document", + JSON: "json" +}; +Http.binaryExtensions = [".model", ".wav", ".ogg", ".mp3", ".mp4", ".m4a", ".aac", ".dds", ".basis", ".glb", ".opus"]; +Http.retryDelay = 100; +var http = new Http(); + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/audio/capabilities.js +function hasAudioContext() { + return !!(typeof AudioContext !== "undefined" || typeof webkitAudioContext !== "undefined"); +} + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/audio/channel.js +var Channel = class { + constructor(manager, sound, options = {}) { + var _options$volume, _options$loop, _options$pitch; + this.volume = (_options$volume = options.volume) != null ? _options$volume : 1; + this.loop = (_options$loop = options.loop) != null ? _options$loop : false; + this.pitch = (_options$pitch = options.pitch) != null ? _options$pitch : 1; + this.sound = sound; + this.paused = false; + this.suspended = false; + this.manager = manager; + this.source = null; + if (hasAudioContext()) { + this.startTime = 0; + this.startOffset = 0; + const context = manager.context; + this.gain = context.createGain(); + } else if (sound.audio) { + this.source = sound.audio.cloneNode(false); + this.source.pause(); + } + } + getVolume() { + return this.volume; + } + getLoop() { + return this.loop; + } + setLoop(loop) { + this.loop = loop; + if (this.source) { + this.source.loop = loop; + } + } + getPitch() { + return this.pitch; + } + onManagerVolumeChange() { + this.setVolume(this.getVolume()); + } + onManagerSuspend() { + if (this.isPlaying() && !this.suspended) { + this.suspended = true; + this.pause(); + } + } + onManagerResume() { + if (this.suspended) { + this.suspended = false; + this.unpause(); + } + } + play() { + if (this.source) { + throw new Error("Call stop() before calling play()"); + } + this._createSource(); + if (!this.source) { + return; + } + this.startTime = this.manager.context.currentTime; + this.source.start(0, this.startOffset % this.source.buffer.duration); + this.setVolume(this.volume); + this.setLoop(this.loop); + this.setPitch(this.pitch); + this.manager.on("volumechange", this.onManagerVolumeChange, this); + this.manager.on("suspend", this.onManagerSuspend, this); + this.manager.on("resume", this.onManagerResume, this); + if (this.manager.suspended) this.onManagerSuspend(); + } + pause() { + if (this.source) { + this.paused = true; + this.startOffset += this.manager.context.currentTime - this.startTime; + this.source.stop(0); + this.source = null; + } + } + unpause() { + if (this.source || !this.paused) { + console.warn("Call pause() before unpausing."); + return; + } + this._createSource(); + if (!this.source) { + return; + } + this.startTime = this.manager.context.currentTime; + this.source.start(0, this.startOffset % this.source.buffer.duration); + this.setVolume(this.volume); + this.setLoop(this.loop); + this.setPitch(this.pitch); + this.paused = false; + } + stop() { + if (this.source) { + this.source.stop(0); + this.source = null; + } + this.manager.off("volumechange", this.onManagerVolumeChange, this); + this.manager.off("suspend", this.onManagerSuspend, this); + this.manager.off("resume", this.onManagerResume, this); + } + setVolume(volume) { + volume = math.clamp(volume, 0, 1); + this.volume = volume; + if (this.gain) { + this.gain.gain.value = volume * this.manager.volume; + } + } + setPitch(pitch) { + this.pitch = pitch; + if (this.source) { + this.source.playbackRate.value = pitch; + } + } + isPlaying() { + return !this.paused && this.source.playbackState === this.source.PLAYING_STATE; + } + getDuration() { + return this.source ? this.source.buffer.duration : 0; + } + _createSource() { + const context = this.manager.context; + if (this.sound.buffer) { + this.source = context.createBufferSource(); + this.source.buffer = this.sound.buffer; + this.source.connect(this.gain); + this.gain.connect(context.destination); + if (!this.loop) { + this.source.onended = this.pause.bind(this); + } + } + } +}; +if (!hasAudioContext()) { + Object.assign(Channel.prototype, { + play: function() { + if (this.source) { + this.paused = false; + this.setVolume(this.volume); + this.setLoop(this.loop); + this.setPitch(this.pitch); + this.source.play(); + } + this.manager.on("volumechange", this.onManagerVolumeChange, this); + this.manager.on("suspend", this.onManagerSuspend, this); + this.manager.on("resume", this.onManagerResume, this); + if (this.manager.suspended) this.onManagerSuspend(); + }, + pause: function() { + if (this.source) { + this.paused = true; + this.source.pause(); + } + }, + unpause: function() { + if (this.source) { + this.paused = false; + this.source.play(); + } + }, + stop: function() { + if (this.source) { + this.source.pause(); + } + this.manager.off("volumechange", this.onManagerVolumeChange, this); + this.manager.off("suspend", this.onManagerSuspend, this); + this.manager.off("resume", this.onManagerResume, this); + }, + setVolume: function(volume) { + volume = math.clamp(volume, 0, 1); + this.volume = volume; + if (this.source) { + this.source.volume = volume * this.manager.volume; + } + }, + setPitch: function(pitch) { + this.pitch = pitch; + if (this.source) { + this.source.playbackRate = pitch; + } + }, + getDuration: function() { + return this.source && !isNaN(this.source.duration) ? this.source.duration : 0; + }, + isPlaying: function() { + return !this.source.paused; + } + }); +} + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/audio/channel3d.js +var MAX_DISTANCE = 1e4; +var Channel3d = class extends Channel { + constructor(manager, sound, options) { + super(manager, sound, options); + this.position = new Vec3(); + this.velocity = new Vec3(); + if (hasAudioContext()) { + this.panner = manager.context.createPanner(); + } else { + this.maxDistance = MAX_DISTANCE; + this.minDistance = 1; + this.rollOffFactor = 1; + this.distanceModel = DISTANCE_INVERSE; + } + } + getPosition() { + return this.position; + } + setPosition(position2) { + this.position.copy(position2); + const panner = this.panner; + if ("positionX" in panner) { + panner.positionX.value = position2.x; + panner.positionY.value = position2.y; + panner.positionZ.value = position2.z; + } else if (panner.setPosition) { + panner.setPosition(position2.x, position2.y, position2.z); + } + } + getVelocity() { + return this.velocity; + } + setVelocity(velocity) { + this.velocity.copy(velocity); + } + getMaxDistance() { + return this.panner.maxDistance; + } + setMaxDistance(max) { + this.panner.maxDistance = max; + } + getMinDistance() { + return this.panner.refDistance; + } + setMinDistance(min) { + this.panner.refDistance = min; + } + getRollOffFactor() { + return this.panner.rolloffFactor; + } + setRollOffFactor(factor) { + this.panner.rolloffFactor = factor; + } + getDistanceModel() { + return this.panner.distanceModel; + } + setDistanceModel(distanceModel) { + this.panner.distanceModel = distanceModel; + } + _createSource() { + const context = this.manager.context; + this.source = context.createBufferSource(); + this.source.buffer = this.sound.buffer; + this.source.connect(this.panner); + this.panner.connect(this.gain); + this.gain.connect(context.destination); + if (!this.loop) { + this.source.onended = this.pause.bind(this); + } + } +}; +if (!hasAudioContext()) { + let offset = new Vec3(); + const fallOff = function fallOff2(posOne, posTwo, refDistance, maxDistance, rolloffFactor, distanceModel) { + offset = offset.sub2(posOne, posTwo); + const distance = offset.length(); + if (distance < refDistance) { + return 1; + } else if (distance > maxDistance) { + return 0; + } + let result = 0; + if (distanceModel === DISTANCE_LINEAR) { + result = 1 - rolloffFactor * (distance - refDistance) / (maxDistance - refDistance); + } else if (distanceModel === DISTANCE_INVERSE) { + result = refDistance / (refDistance + rolloffFactor * (distance - refDistance)); + } else if (distanceModel === DISTANCE_EXPONENTIAL) { + result = Math.pow(distance / refDistance, -rolloffFactor); + } + return math.clamp(result, 0, 1); + }; + Object.assign(Channel3d.prototype, { + setPosition: function(position2) { + this.position.copy(position2); + if (this.source) { + const listener = this.manager.listener; + const lpos = listener.getPosition(); + const factor = fallOff(lpos, this.position, this.minDistance, this.maxDistance, this.rollOffFactor, this.distanceModel); + const v = this.getVolume(); + this.source.volume = v * factor; + } + }, + getMaxDistance: function() { + return this.maxDistance; + }, + setMaxDistance: function(max) { + this.maxDistance = max; + }, + getMinDistance: function() { + return this.minDistance; + }, + setMinDistance: function(min) { + this.minDistance = min; + }, + getRollOffFactor: function() { + return this.rollOffFactor; + }, + setRollOffFactor: function(factor) { + this.rollOffFactor = factor; + }, + getDistanceModel: function() { + return this.distanceModel; + }, + setDistanceModel: function(distanceModel) { + this.distanceModel = distanceModel; + } + }); +} + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/sound/listener.js +var Listener = class { + constructor(manager) { + this._manager = void 0; + this.position = new Vec3(); + this.velocity = new Vec3(); + this.orientation = new Mat4(); + this._manager = manager; + } + getPosition() { + return this.position; + } + setPosition(position2) { + this.position.copy(position2); + const listener = this.listener; + if (listener) { + if ("positionX" in listener) { + listener.positionX.value = position2.x; + listener.positionY.value = position2.y; + listener.positionZ.value = position2.z; + } else if (listener.setPosition) { + listener.setPosition(position2.x, position2.y, position2.z); + } + } + } + getVelocity() { + return this.velocity; + } + setVelocity(velocity) { + } + setOrientation(orientation) { + this.orientation.copy(orientation); + const listener = this.listener; + if (listener) { + const m = orientation.data; + if ("forwardX" in listener) { + listener.forwardX.value = -m[8]; + listener.forwardY.value = -m[9]; + listener.forwardZ.value = -m[10]; + listener.upX.value = m[4]; + listener.upY.value = m[5]; + listener.upZ.value = m[6]; + } else if (listener.setOrientation) { + listener.setOrientation(-m[8], -m[9], -m[10], m[4], m[5], m[6]); + } + } + } + getOrientation() { + return this.orientation; + } + get listener() { + const context = this._manager.context; + return context ? context.listener : null; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/sound/manager.js +var CONTEXT_STATE_RUNNING = "running"; +var USER_INPUT_EVENTS = ["click", "touchstart", "mousedown"]; +var SoundManager = class extends EventHandler { + constructor() { + super(); + this._context = null; + this.AudioContext = typeof AudioContext !== "undefined" && AudioContext || typeof webkitAudioContext !== "undefined" && webkitAudioContext; + if (!this.AudioContext) ; + this._unlockHandlerFunc = this._unlockHandler.bind(this); + this._userSuspended = false; + this.listener = new Listener(this); + this._volume = 1; + } + set volume(volume) { + volume = math.clamp(volume, 0, 1); + this._volume = volume; + this.fire("volumechange", volume); + } + get volume() { + return this._volume; + } + get suspended() { + return this._userSuspended; + } + get context() { + if (!this._context && this.AudioContext) { + this._context = new this.AudioContext(); + if (this._context.state !== CONTEXT_STATE_RUNNING) { + this._registerUnlockListeners(); + } + } + return this._context; + } + suspend() { + if (!this._userSuspended) { + this._userSuspended = true; + if (this._context && this._context.state === CONTEXT_STATE_RUNNING) { + this._suspend(); + } + } + } + resume() { + if (this._userSuspended) { + this._userSuspended = false; + if (this._context && this._context.state !== CONTEXT_STATE_RUNNING) { + this._resume(); + } + } + } + destroy() { + this.fire("destroy"); + if (this._context) { + var _this$_context; + this._removeUnlockListeners(); + (_this$_context = this._context) == null || _this$_context.close(); + this._context = null; + } + } + playSound(sound, options = {}) { + let channel = null; + if (Channel) { + channel = new Channel(this, sound, options); + channel.play(); + } + return channel; + } + playSound3d(sound, position2, options = {}) { + let channel = null; + if (Channel3d) { + channel = new Channel3d(this, sound, options); + channel.setPosition(position2); + if (options.volume) { + channel.setVolume(options.volume); + } + if (options.loop) { + channel.setLoop(options.loop); + } + if (options.maxDistance) { + channel.setMaxDistance(options.maxDistance); + } + if (options.minDistance) { + channel.setMinDistance(options.minDistance); + } + if (options.rollOffFactor) { + channel.setRollOffFactor(options.rollOffFactor); + } + if (options.distanceModel) { + channel.setDistanceModel(options.distanceModel); + } + channel.play(); + } + return channel; + } + _resume() { + this._context.resume().then(() => { + const source = this._context.createBufferSource(); + source.buffer = this._context.createBuffer(1, 1, this._context.sampleRate); + source.connect(this._context.destination); + source.start(0); + source.onended = (event) => { + source.disconnect(0); + this.fire("resume"); + }; + }, (e) => { + }).catch((e) => { + }); + } + _suspend() { + this._context.suspend().then(() => { + this.fire("suspend"); + }, (e) => { + }).catch((e) => { + }); + } + _unlockHandler() { + this._removeUnlockListeners(); + if (!this._userSuspended && this._context.state !== CONTEXT_STATE_RUNNING) { + this._resume(); + } + } + _registerUnlockListeners() { + USER_INPUT_EVENTS.forEach((eventName) => { + window.addEventListener(eventName, this._unlockHandlerFunc, false); + }); + } + _removeUnlockListeners() { + USER_INPUT_EVENTS.forEach((eventName) => { + window.removeEventListener(eventName, this._unlockHandlerFunc, false); + }); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/sound/sound.js +var Sound = class { + constructor(resource) { + this.audio = void 0; + this.buffer = void 0; + if (resource instanceof Audio) { + this.audio = resource; + } else { + this.buffer = resource; + } + } + get duration() { + let duration = 0; + if (this.buffer) { + duration = this.buffer.duration; + } else if (this.audio) { + duration = this.audio.duration; + } + return duration || 0; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/sound/instance.js +var STATE_PLAYING = 0; +var STATE_PAUSED = 1; +var STATE_STOPPED = 2; +function capTime(time2, duration) { + return time2 % duration || 0; +} +var SoundInstance = class extends EventHandler { + constructor(manager, sound, options) { + super(); + this.source = null; + this._manager = manager; + this._volume = options.volume !== void 0 ? math.clamp(Number(options.volume) || 0, 0, 1) : 1; + this._pitch = options.pitch !== void 0 ? Math.max(0.01, Number(options.pitch) || 0) : 1; + this._loop = !!(options.loop !== void 0 ? options.loop : false); + this._sound = sound; + this._state = STATE_STOPPED; + this._suspended = false; + this._suspendEndEvent = 0; + this._suspendInstanceEvents = false; + this._playWhenLoaded = true; + this._startTime = Math.max(0, Number(options.startTime) || 0); + this._duration = Math.max(0, Number(options.duration) || 0); + this._startOffset = null; + this._onPlayCallback = options.onPlay; + this._onPauseCallback = options.onPause; + this._onResumeCallback = options.onResume; + this._onStopCallback = options.onStop; + this._onEndCallback = options.onEnd; + if (hasAudioContext()) { + this._startedAt = 0; + this._currentTime = 0; + this._currentOffset = 0; + this._inputNode = null; + this._connectorNode = null; + this._firstNode = null; + this._lastNode = null; + this._waitingContextSuspension = false; + this._initializeNodes(); + this._endedHandler = this._onEnded.bind(this); + } else { + this._isReady = false; + this._loadedMetadataHandler = this._onLoadedMetadata.bind(this); + this._timeUpdateHandler = this._onTimeUpdate.bind(this); + this._endedHandler = this._onEnded.bind(this); + this._createSource(); + } + } + set currentTime(value) { + if (value < 0) return; + if (this._state === STATE_PLAYING) { + const suspend = this._suspendInstanceEvents; + this._suspendInstanceEvents = true; + this.stop(); + this._startOffset = value; + this.play(); + this._suspendInstanceEvents = suspend; + } else { + this._startOffset = value; + this._currentTime = value; + } + } + get currentTime() { + if (this._startOffset !== null) { + return this._startOffset; + } + if (this._state === STATE_PAUSED) { + return this._currentTime; + } + if (this._state === STATE_STOPPED || !this.source) { + return 0; + } + this._updateCurrentTime(); + return this._currentTime; + } + set duration(value) { + this._duration = Math.max(0, Number(value) || 0); + const isPlaying = this._state === STATE_PLAYING; + this.stop(); + if (isPlaying) { + this.play(); + } + } + get duration() { + if (!this._sound) { + return 0; + } + if (this._duration) { + return capTime(this._duration, this._sound.duration); + } + return this._sound.duration; + } + get isPaused() { + return this._state === STATE_PAUSED; + } + get isPlaying() { + return this._state === STATE_PLAYING; + } + get isStopped() { + return this._state === STATE_STOPPED; + } + get isSuspended() { + return this._suspended; + } + set loop(value) { + this._loop = !!value; + if (this.source) { + this.source.loop = this._loop; + } + } + get loop() { + return this._loop; + } + set pitch(pitch) { + this._currentOffset = this.currentTime; + this._startedAt = this._manager.context.currentTime; + this._pitch = Math.max(Number(pitch) || 0, 0.01); + if (this.source) { + this.source.playbackRate.value = this._pitch; + } + } + get pitch() { + return this._pitch; + } + set sound(value) { + this._sound = value; + if (this._state !== STATE_STOPPED) { + this.stop(); + } else { + this._createSource(); + } + } + get sound() { + return this._sound; + } + set startTime(value) { + this._startTime = Math.max(0, Number(value) || 0); + const isPlaying = this._state === STATE_PLAYING; + this.stop(); + if (isPlaying) { + this.play(); + } + } + get startTime() { + return this._startTime; + } + set volume(volume) { + volume = math.clamp(volume, 0, 1); + this._volume = volume; + if (this.gain) { + this.gain.gain.value = volume * this._manager.volume; + } + } + get volume() { + return this._volume; + } + _onPlay() { + this.fire("play"); + if (this._onPlayCallback) this._onPlayCallback(this); + } + _onPause() { + this.fire("pause"); + if (this._onPauseCallback) this._onPauseCallback(this); + } + _onResume() { + this.fire("resume"); + if (this._onResumeCallback) this._onResumeCallback(this); + } + _onStop() { + this.fire("stop"); + if (this._onStopCallback) this._onStopCallback(this); + } + _onEnded() { + if (this._suspendEndEvent > 0) { + this._suspendEndEvent--; + return; + } + this.fire("end"); + if (this._onEndCallback) this._onEndCallback(this); + this.stop(); + } + _onManagerVolumeChange() { + this.volume = this._volume; + } + _onManagerSuspend() { + if (this._state === STATE_PLAYING && !this._suspended) { + this._suspended = true; + this.pause(); + } + } + _onManagerResume() { + if (this._suspended) { + this._suspended = false; + this.resume(); + } + } + _initializeNodes() { + this.gain = this._manager.context.createGain(); + this._inputNode = this.gain; + this._connectorNode = this.gain; + this._connectorNode.connect(this._manager.context.destination); + } + play() { + if (this._state !== STATE_STOPPED) { + this.stop(); + } + this._state = STATE_PLAYING; + this._playWhenLoaded = false; + if (this._waitingContextSuspension) { + return false; + } + if (this._manager.suspended) { + this._manager.once("resume", this._playAudioImmediate, this); + this._waitingContextSuspension = true; + return false; + } + this._playAudioImmediate(); + return true; + } + _playAudioImmediate() { + this._waitingContextSuspension = false; + if (this._state !== STATE_PLAYING) { + return; + } + if (!this.source) { + this._createSource(); + } + let offset = capTime(this._startOffset, this.duration); + offset = capTime(this._startTime + offset, this._sound.duration); + this._startOffset = null; + if (this._duration) { + this.source.start(0, offset, this._duration); + } else { + this.source.start(0, offset); + } + this._startedAt = this._manager.context.currentTime; + this._currentTime = 0; + this._currentOffset = offset; + this.volume = this._volume; + this.loop = this._loop; + this.pitch = this._pitch; + this._manager.on("volumechange", this._onManagerVolumeChange, this); + this._manager.on("suspend", this._onManagerSuspend, this); + this._manager.on("resume", this._onManagerResume, this); + this._manager.on("destroy", this._onManagerDestroy, this); + if (!this._suspendInstanceEvents) { + this._onPlay(); + } + } + pause() { + this._playWhenLoaded = false; + if (this._state !== STATE_PLAYING) return false; + this._state = STATE_PAUSED; + if (this._waitingContextSuspension) { + return true; + } + this._updateCurrentTime(); + this._suspendEndEvent++; + this.source.stop(0); + this.source = null; + this._startOffset = null; + if (!this._suspendInstanceEvents) this._onPause(); + return true; + } + resume() { + if (this._state !== STATE_PAUSED) { + return false; + } + let offset = this.currentTime; + this._state = STATE_PLAYING; + if (this._waitingContextSuspension) { + return true; + } + if (!this.source) { + this._createSource(); + } + if (this._startOffset !== null) { + offset = capTime(this._startOffset, this.duration); + offset = capTime(this._startTime + offset, this._sound.duration); + this._startOffset = null; + } + if (this._duration) { + this.source.start(0, offset, this._duration); + } else { + this.source.start(0, offset); + } + this._startedAt = this._manager.context.currentTime; + this._currentOffset = offset; + this.volume = this._volume; + this.loop = this._loop; + this.pitch = this._pitch; + this._playWhenLoaded = false; + if (!this._suspendInstanceEvents) this._onResume(); + return true; + } + stop() { + this._playWhenLoaded = false; + if (this._state === STATE_STOPPED) return false; + const wasPlaying = this._state === STATE_PLAYING; + this._state = STATE_STOPPED; + if (this._waitingContextSuspension) { + return true; + } + this._manager.off("volumechange", this._onManagerVolumeChange, this); + this._manager.off("suspend", this._onManagerSuspend, this); + this._manager.off("resume", this._onManagerResume, this); + this._manager.off("destroy", this._onManagerDestroy, this); + this._startedAt = 0; + this._currentTime = 0; + this._currentOffset = 0; + this._startOffset = null; + this._suspendEndEvent++; + if (wasPlaying && this.source) { + this.source.stop(0); + } + this.source = null; + if (!this._suspendInstanceEvents) this._onStop(); + return true; + } + setExternalNodes(firstNode, lastNode) { + if (!firstNode) { + console.error("The firstNode must be a valid Audio Node"); + return; + } + if (!lastNode) { + lastNode = firstNode; + } + const speakers = this._manager.context.destination; + if (this._firstNode !== firstNode) { + if (this._firstNode) { + this._connectorNode.disconnect(this._firstNode); + } else { + this._connectorNode.disconnect(speakers); + } + this._firstNode = firstNode; + this._connectorNode.connect(firstNode); + } + if (this._lastNode !== lastNode) { + if (this._lastNode) { + this._lastNode.disconnect(speakers); + } + this._lastNode = lastNode; + this._lastNode.connect(speakers); + } + } + clearExternalNodes() { + const speakers = this._manager.context.destination; + if (this._firstNode) { + this._connectorNode.disconnect(this._firstNode); + this._firstNode = null; + } + if (this._lastNode) { + this._lastNode.disconnect(speakers); + this._lastNode = null; + } + this._connectorNode.connect(speakers); + } + getExternalNodes() { + return [this._firstNode, this._lastNode]; + } + _createSource() { + if (!this._sound) { + return null; + } + const context = this._manager.context; + if (this._sound.buffer) { + this.source = context.createBufferSource(); + this.source.buffer = this._sound.buffer; + this.source.connect(this._inputNode); + this.source.onended = this._endedHandler; + this.source.loopStart = capTime(this._startTime, this.source.buffer.duration); + if (this._duration) { + this.source.loopEnd = Math.max(this.source.loopStart, capTime(this._startTime + this._duration, this.source.buffer.duration)); + } + } + return this.source; + } + _updateCurrentTime() { + this._currentTime = capTime((this._manager.context.currentTime - this._startedAt) * this._pitch + this._currentOffset, this.duration); + } + _onManagerDestroy() { + if (this.source && this._state === STATE_PLAYING) { + this.source.stop(0); + this.source = null; + } + } +}; +SoundInstance.EVENT_PLAY = "play"; +SoundInstance.EVENT_PAUSE = "pause"; +SoundInstance.EVENT_RESUME = "resume"; +SoundInstance.EVENT_STOP = "stop"; +SoundInstance.EVENT_END = "end"; +if (!hasAudioContext()) { + Object.assign(SoundInstance.prototype, { + play: function() { + if (this._state !== STATE_STOPPED) { + this.stop(); + } + if (!this.source) { + if (!this._createSource()) { + return false; + } + } + this.volume = this._volume; + this.pitch = this._pitch; + this.loop = this._loop; + this.source.play(); + this._state = STATE_PLAYING; + this._playWhenLoaded = false; + this._manager.on("volumechange", this._onManagerVolumeChange, this); + this._manager.on("suspend", this._onManagerSuspend, this); + this._manager.on("resume", this._onManagerResume, this); + this._manager.on("destroy", this._onManagerDestroy, this); + if (this._manager.suspended) this._onManagerSuspend(); + if (!this._suspendInstanceEvents) this._onPlay(); + return true; + }, + pause: function() { + if (!this.source || this._state !== STATE_PLAYING) return false; + this._suspendEndEvent++; + this.source.pause(); + this._playWhenLoaded = false; + this._state = STATE_PAUSED; + this._startOffset = null; + if (!this._suspendInstanceEvents) this._onPause(); + return true; + }, + resume: function() { + if (!this.source || this._state !== STATE_PAUSED) return false; + this._state = STATE_PLAYING; + this._playWhenLoaded = false; + if (this.source.paused) { + this.source.play(); + if (!this._suspendInstanceEvents) this._onResume(); + } + return true; + }, + stop: function() { + if (!this.source || this._state === STATE_STOPPED) return false; + this._manager.off("volumechange", this._onManagerVolumeChange, this); + this._manager.off("suspend", this._onManagerSuspend, this); + this._manager.off("resume", this._onManagerResume, this); + this._manager.off("destroy", this._onManagerDestroy, this); + this._suspendEndEvent++; + this.source.pause(); + this._playWhenLoaded = false; + this._state = STATE_STOPPED; + this._startOffset = null; + if (!this._suspendInstanceEvents) this._onStop(); + return true; + }, + setExternalNodes: function() { + }, + clearExternalNodes: function() { + }, + getExternalNodes: function() { + return [null, null]; + }, + _onLoadedMetadata: function() { + this.source.removeEventListener("loadedmetadata", this._loadedMetadataHandler); + this._isReady = true; + let offset = capTime(this._startOffset, this.duration); + offset = capTime(this._startTime + offset, this._sound.duration); + this._startOffset = null; + this.source.currentTime = offset; + }, + _createSource: function() { + if (this._sound && this._sound.audio) { + this._isReady = false; + this.source = this._sound.audio.cloneNode(true); + this.source.addEventListener("loadedmetadata", this._loadedMetadataHandler); + this.source.addEventListener("timeupdate", this._timeUpdateHandler); + this.source.onended = this._endedHandler; + } + return this.source; + }, + _onTimeUpdate: function() { + if (!this._duration) return; + if (this.source.currentTime > capTime(this._startTime + this._duration, this.source.duration)) { + if (this.loop) { + this.source.currentTime = capTime(this._startTime, this.source.duration); + } else { + this.source.removeEventListener("timeupdate", this._timeUpdateHandler); + this.source.pause(); + this._onEnded(); + } + } + }, + _onManagerDestroy: function() { + if (this.source) { + this.source.pause(); + } + } + }); + Object.defineProperty(SoundInstance.prototype, "volume", { + get: function() { + return this._volume; + }, + set: function(volume) { + volume = math.clamp(volume, 0, 1); + this._volume = volume; + if (this.source) { + this.source.volume = volume * this._manager.volume; + } + } + }); + Object.defineProperty(SoundInstance.prototype, "pitch", { + get: function() { + return this._pitch; + }, + set: function(pitch) { + this._pitch = Math.max(Number(pitch) || 0, 0.01); + if (this.source) { + this.source.playbackRate = this._pitch; + } + } + }); + Object.defineProperty(SoundInstance.prototype, "sound", { + get: function() { + return this._sound; + }, + set: function(value) { + this.stop(); + this._sound = value; + } + }); + Object.defineProperty(SoundInstance.prototype, "currentTime", { + get: function() { + if (this._startOffset !== null) { + return this._startOffset; + } + if (this._state === STATE_STOPPED || !this.source) { + return 0; + } + return this.source.currentTime - this._startTime; + }, + set: function(value) { + if (value < 0) return; + this._startOffset = value; + if (this.source && this._isReady) { + this.source.currentTime = capTime(this._startTime + capTime(value, this.duration), this._sound.duration); + this._startOffset = null; + } + } + }); +} + +// ../../node_modules/playcanvas/build/playcanvas/src/platform/sound/instance3d.js +var MAX_DISTANCE2 = 1e4; +var SoundInstance3d = class extends SoundInstance { + constructor(manager, sound, options = {}) { + super(manager, sound, options); + this._position = new Vec3(); + this._velocity = new Vec3(); + if (options.position) this.position = options.position; + this.maxDistance = options.maxDistance !== void 0 ? Number(options.maxDistance) : MAX_DISTANCE2; + this.refDistance = options.refDistance !== void 0 ? Number(options.refDistance) : 1; + this.rollOffFactor = options.rollOffFactor !== void 0 ? Number(options.rollOffFactor) : 1; + this.distanceModel = options.distanceModel !== void 0 ? options.distanceModel : DISTANCE_LINEAR; + } + _initializeNodes() { + this.gain = this._manager.context.createGain(); + this.panner = this._manager.context.createPanner(); + this.panner.connect(this.gain); + this._inputNode = this.panner; + this._connectorNode = this.gain; + this._connectorNode.connect(this._manager.context.destination); + } + set position(value) { + this._position.copy(value); + const panner = this.panner; + if ("positionX" in panner) { + panner.positionX.value = value.x; + panner.positionY.value = value.y; + panner.positionZ.value = value.z; + } else if (panner.setPosition) { + panner.setPosition(value.x, value.y, value.z); + } + } + get position() { + return this._position; + } + set velocity(velocity) { + this._velocity.copy(velocity); + } + get velocity() { + return this._velocity; + } + set maxDistance(value) { + this.panner.maxDistance = value; + } + get maxDistance() { + return this.panner.maxDistance; + } + set refDistance(value) { + this.panner.refDistance = value; + } + get refDistance() { + return this.panner.refDistance; + } + set rollOffFactor(value) { + this.panner.rolloffFactor = value; + } + get rollOffFactor() { + return this.panner.rolloffFactor; + } + set distanceModel(value) { + this.panner.distanceModel = value; + } + get distanceModel() { + return this.panner.distanceModel; + } +}; +if (!hasAudioContext()) { + let offset = new Vec3(); + const fallOff = function fallOff2(posOne, posTwo, refDistance, maxDistance, rollOffFactor, distanceModel) { + offset = offset.sub2(posOne, posTwo); + const distance = offset.length(); + if (distance < refDistance) { + return 1; + } else if (distance > maxDistance) { + return 0; + } + let result = 0; + if (distanceModel === DISTANCE_LINEAR) { + result = 1 - rollOffFactor * (distance - refDistance) / (maxDistance - refDistance); + } else if (distanceModel === DISTANCE_INVERSE) { + result = refDistance / (refDistance + rollOffFactor * (distance - refDistance)); + } else if (distanceModel === DISTANCE_EXPONENTIAL) { + result = Math.pow(distance / refDistance, -rollOffFactor); + } + return math.clamp(result, 0, 1); + }; + Object.defineProperty(SoundInstance3d.prototype, "position", { + get: function() { + return this._position; + }, + set: function(position2) { + this._position.copy(position2); + if (this.source) { + const listener = this._manager.listener; + const lpos = listener.getPosition(); + const factor = fallOff(lpos, this._position, this.refDistance, this.maxDistance, this.rollOffFactor, this.distanceModel); + const v = this.volume; + this.source.volume = v * factor * this._manager.volume; + } + } + }); + Object.defineProperty(SoundInstance3d.prototype, "maxDistance", { + get: function() { + return this._maxDistance; + }, + set: function(value) { + this._maxDistance = value; + } + }); + Object.defineProperty(SoundInstance3d.prototype, "refDistance", { + get: function() { + return this._refDistance; + }, + set: function(value) { + this._refDistance = value; + } + }); + Object.defineProperty(SoundInstance3d.prototype, "rollOffFactor", { + get: function() { + return this._rollOffFactor; + }, + set: function(value) { + this._rollOffFactor = value; + } + }); + Object.defineProperty(SoundInstance3d.prototype, "distanceModel", { + get: function() { + return this._distanceModel; + }, + set: function(value) { + this._distanceModel = value; + } + }); +} + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/constants.js +var BLEND_SUBTRACTIVE = 0; +var BLEND_ADDITIVE = 1; +var BLEND_NORMAL = 2; +var BLEND_NONE = 3; +var BLEND_PREMULTIPLIED = 4; +var BLEND_MULTIPLICATIVE = 5; +var BLEND_ADDITIVEALPHA = 6; +var BLEND_MULTIPLICATIVE2X = 7; +var BLEND_SCREEN = 8; +var BLEND_MIN = 9; +var BLEND_MAX = 10; +var FOG_NONE = "none"; +var FOG_LINEAR = "linear"; +var FRESNEL_SCHLICK = 2; +var LAYER_FX = 2; +var LAYER_WORLD = 15; +var LAYERID_WORLD = 0; +var LAYERID_DEPTH = 1; +var LAYERID_SKYBOX = 2; +var LAYERID_IMMEDIATE = 3; +var LAYERID_UI = 4; +var LIGHTTYPE_DIRECTIONAL = 0; +var LIGHTTYPE_OMNI = 1; +var LIGHTTYPE_SPOT = 2; +var LIGHTSHAPE_PUNCTUAL = 0; +var LIGHTSHAPE_RECT = 1; +var LIGHTSHAPE_DISK = 2; +var LIGHTSHAPE_SPHERE = 3; +var LIGHTFALLOFF_LINEAR = 0; +var LIGHTFALLOFF_INVERSESQUARED = 1; +var SHADOW_PCF3 = 0; +var SHADOW_VSM8 = 1; +var SHADOW_VSM16 = 2; +var SHADOW_VSM32 = 3; +var SHADOW_PCF5 = 4; +var SHADOW_PCF1 = 5; +var SHADOW_PCSS = 6; +var shadowTypeToString = {}; +shadowTypeToString[SHADOW_PCF3] = "PCF3"; +shadowTypeToString[SHADOW_VSM8] = "VSM8"; +shadowTypeToString[SHADOW_VSM16] = "VSM16"; +shadowTypeToString[SHADOW_VSM32] = "VSM32"; +shadowTypeToString[SHADOW_PCF5] = "PCF5"; +shadowTypeToString[SHADOW_PCF1] = "PCF1"; +shadowTypeToString[SHADOW_PCSS] = "PCSS"; +var BLUR_GAUSSIAN = 1; +var PROJECTION_PERSPECTIVE = 0; +var PROJECTION_ORTHOGRAPHIC = 1; +var RENDERSTYLE_SOLID = 0; +var RENDERSTYLE_WIREFRAME = 1; +var RENDERSTYLE_POINTS = 2; +var CUBEPROJ_NONE = 0; +var CUBEPROJ_BOX = 1; +var SPECULAR_PHONG = 0; +var SPECULAR_BLINN = 1; +var DETAILMODE_MUL = "mul"; +var GAMMA_NONE = 0; +var GAMMA_SRGB = 1; +var GAMMA_SRGBFAST = 2; +var GAMMA_SRGBHDR = 3; +var TONEMAP_LINEAR = 0; +var TONEMAP_FILMIC = 1; +var TONEMAP_HEJL = 2; +var TONEMAP_ACES = 3; +var TONEMAP_ACES2 = 4; +var TONEMAP_NEUTRAL = 5; +var SPECOCC_AO = 1; +var SPECOCC_GLOSSDEPENDENT = 2; +var SHADERDEF_NOSHADOW = 1; +var SHADERDEF_SKIN = 2; +var SHADERDEF_UV0 = 4; +var SHADERDEF_UV1 = 8; +var SHADERDEF_VCOLOR = 16; +var SHADERDEF_INSTANCING = 32; +var SHADERDEF_LM = 64; +var SHADERDEF_DIRLM = 128; +var SHADERDEF_SCREENSPACE = 256; +var SHADERDEF_TANGENTS = 512; +var SHADERDEF_MORPH_POSITION = 1024; +var SHADERDEF_MORPH_NORMAL = 2048; +var SHADERDEF_MORPH_TEXTURE_BASED = 4096; +var SHADERDEF_LMAMBIENT = 8192; +var SHADOWUPDATE_NONE = 0; +var SHADOWUPDATE_THISFRAME = 1; +var SHADOWUPDATE_REALTIME = 2; +var SORTKEY_FORWARD = 0; +var SORTKEY_DEPTH = 1; +var MASK_AFFECT_DYNAMIC = 1; +var MASK_AFFECT_LIGHTMAPPED = 2; +var MASK_BAKE = 4; +var SHADER_FORWARD = 0; +var SHADER_FORWARDHDR = 1; +var SHADER_DEPTH = 2; +var SHADER_PICK = 3; +var SHADER_SHADOW = 4; +var SHADER_PREPASS_VELOCITY = 5; +var SPRITE_RENDERMODE_SIMPLE = 0; +var SPRITE_RENDERMODE_SLICED = 1; +var SPRITE_RENDERMODE_TILED = 2; +var BAKE_COLORDIR = 1; +var VIEW_CENTER = 0; +var SORTMODE_NONE = 0; +var SORTMODE_MANUAL = 1; +var SORTMODE_MATERIALMESH = 2; +var SORTMODE_BACK2FRONT = 3; +var SORTMODE_FRONT2BACK = 4; +var SORTMODE_CUSTOM = 5; +var ASPECT_AUTO = 0; +var ASPECT_MANUAL = 1; +var SKYTYPE_INFINITE = "infinite"; +var SKYTYPE_BOX = "box"; +var SKYTYPE_DOME = "dome"; +var DITHER_NONE = "none"; +var DITHER_BAYER8 = "bayer8"; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/alphaTest.js +var alphaTestPS = ` +uniform float alpha_ref; +void alphaTest(float a) { + if (a < alpha_ref) discard; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/ambientConstant.js +var ambientConstantPS = ` +void addAmbient(vec3 worldNormal) { + dDiffuseLight += light_globalAmbient; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/ambientEnv.js +var ambientEnvPS = ` +#ifndef ENV_ATLAS +#define ENV_ATLAS +uniform sampler2D texture_envAtlas; +#endif +void addAmbient(vec3 worldNormal) { + vec3 dir = normalize(cubeMapRotate(worldNormal) * vec3(-1.0, 1.0, 1.0)); + vec2 uv = mapUv(toSphericalUv(dir), vec4(128.0, 256.0 + 128.0, 64.0, 32.0) / atlasSize); + vec4 raw = texture2D(texture_envAtlas, uv); + vec3 linear = $DECODE(raw); + dDiffuseLight += processEnvironment(linear); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/ambientSH.js +var ambientSHPS = ` +uniform vec3 ambientSH[9]; +void addAmbient(vec3 worldNormal) { + vec3 n = cubeMapRotate(worldNormal); + vec3 color = + ambientSH[0] + + ambientSH[1] * n.x + + ambientSH[2] * n.y + + ambientSH[3] * n.z + + ambientSH[4] * n.x * n.z + + ambientSH[5] * n.z * n.y + + ambientSH[6] * n.y * n.x + + ambientSH[7] * (3.0 * n.z * n.z - 1.0) + + ambientSH[8] * (n.x * n.x - n.y * n.y); + dDiffuseLight += processEnvironment(max(color, vec3(0.0))); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/ao.js +var aoPS = ` +void getAO() { + dAo = 1.0; + #ifdef MAPTEXTURE + float aoBase = texture2DBias($SAMPLER, $UV, textureBias).$CH; + dAo *= addAoDetail(aoBase); + #endif + #ifdef MAPVERTEX + dAo *= saturate(vVertexColor.$VC); + #endif +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/aoDetailMap.js +var aoDetailMapPS = ` +float addAoDetail(float ao) { +#ifdef MAPTEXTURE + float aoDetail = texture2DBias($SAMPLER, $UV, textureBias).$CH; + return detailMode_$DETAILMODE(vec3(ao), vec3(aoDetail)).r; +#else + return ao; +#endif +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/aoDiffuseOcc.js +var aoDiffuseOccPS = ` +void occludeDiffuse(float ao) { + dDiffuseLight *= ao; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/aoSpecOcc.js +var aoSpecOccPS = ` +uniform float material_occludeSpecularIntensity; +void occludeSpecular(float gloss, float ao, vec3 worldNormal, vec3 viewDir) { + float specPow = exp2(gloss * 11.0); + float specOcc = saturate(pow(dot(worldNormal, viewDir) + ao, 0.01*specPow) - 1.0 + ao); + specOcc = mix(1.0, specOcc, material_occludeSpecularIntensity); + dSpecularLight *= specOcc; + dReflection *= specOcc; + +#ifdef LIT_SHEEN + sSpecularLight *= specOcc; + sReflection *= specOcc; +#endif +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/aoSpecOccConst.js +var aoSpecOccConstPS = ` +void occludeSpecular(float gloss, float ao, vec3 worldNormal, vec3 viewDir) { + float specPow = exp2(gloss * 11.0); + float specOcc = saturate(pow(dot(worldNormal, viewDir) + ao, 0.01*specPow) - 1.0 + ao); + dSpecularLight *= specOcc; + dReflection *= specOcc; + +#ifdef LIT_SHEEN + sSpecularLight *= specOcc; + sReflection *= specOcc; +#endif +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/aoSpecOccConstSimple.js +var aoSpecOccConstSimplePS = ` +void occludeSpecular(float gloss, float ao, vec3 worldNormal, vec3 viewDir) { + dSpecularLight *= ao; + dReflection *= ao; +#ifdef LIT_SHEEN + sSpecularLight *= ao; + sReflection *= ao; +#endif +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/aoSpecOccSimple.js +var aoSpecOccSimplePS = ` +uniform float material_occludeSpecularIntensity; +void occludeSpecular(float gloss, float ao, vec3 worldNormal, vec3 viewDir) { + float specOcc = mix(1.0, ao, material_occludeSpecularIntensity); + dSpecularLight *= specOcc; + dReflection *= specOcc; +#ifdef LIT_SHEEN + sSpecularLight *= specOcc; + sReflection *= specOcc; +#endif +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/base.js +var basePS = ` +uniform vec3 view_position; +uniform vec3 light_globalAmbient; +float square(float x) { + return x*x; +} +float saturate(float x) { + return clamp(x, 0.0, 1.0); +} +vec3 saturate(vec3 x) { + return clamp(x, vec3(0.0), vec3(1.0)); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/vert/base.js +var baseVS = ` +attribute vec3 vertex_position; +attribute vec3 vertex_normal; +attribute vec4 vertex_tangent; +attribute vec2 vertex_texCoord0; +attribute vec2 vertex_texCoord1; +attribute vec4 vertex_color; +uniform mat4 matrix_viewProjection; +uniform mat4 matrix_model; +uniform mat3 matrix_normal; +vec3 dPositionW; +mat4 dModelMatrix; +mat3 dNormalMatrix; +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/baseNineSliced.js +var baseNineSlicedPS = ` +#define NINESLICED +varying vec2 vMask; +varying vec2 vTiledUv; +uniform mediump vec4 innerOffset; +uniform mediump vec2 outerScale; +uniform mediump vec4 atlasRect; +vec2 nineSlicedUv; +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/vert/baseNineSliced.js +var baseNineSlicedVS = ` +#define NINESLICED +varying vec2 vMask; +varying vec2 vTiledUv; +uniform mediump vec4 innerOffset; +uniform mediump vec2 outerScale; +uniform mediump vec4 atlasRect; +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/baseNineSlicedTiled.js +var baseNineSlicedTiledPS = ` +#define NINESLICED +#define NINESLICETILED +varying vec2 vMask; +varying vec2 vTiledUv; +uniform mediump vec4 innerOffset; +uniform mediump vec2 outerScale; +uniform mediump vec4 atlasRect; +vec2 nineSlicedUv; +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/bayer.js +var bayerPS = ` +float bayer2(vec2 p) { + return mod(2.0 * p.y + p.x + 1.0, 4.0); +} +float bayer4(vec2 p) { + vec2 p1 = mod(p, 2.0); + vec2 p2 = floor(0.5 * mod(p, 4.0)); + return 4.0 * bayer2(p1) + bayer2(p2); +} +float bayer8(vec2 p) { + vec2 p1 = mod(p, 2.0); + vec2 p2 = floor(0.5 * mod(p, 4.0)); + vec2 p4 = floor(0.25 * mod(p, 8.0)); + return 4.0 * (4.0 * bayer2(p1) + bayer2(p2)) + bayer2(p4); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/biasConst.js +var biasConstPS = ` +#define SHADOWBIAS +#define SHADOW_SAMPLE_Z_BIAS +float getShadowBias(float resolution, float maxBias) { + return maxBias; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/blurVSM.js +var blurVSMPS = ` +varying vec2 vUv0; +uniform sampler2D source; +uniform vec2 pixelOffset; +#ifdef GAUSS +uniform float weight[SAMPLES]; +#endif +#ifdef PACKED +float decodeFloatRG(vec2 rg) { + return rg.y*(1.0/255.0) + rg.x; +} +vec2 encodeFloatRG( float v ) { + vec2 enc = vec2(1.0, 255.0) * v; + enc = fract(enc); + enc -= enc.yy * vec2(1.0/255.0, 1.0/255.0); + return enc; +} +#endif +void main(void) { + vec3 moments = vec3(0.0); + vec2 uv = vUv0 - pixelOffset * (float(SAMPLES) * 0.5); + for (int i=0; i= vAbs.x && vAbs.z >= vAbs.y) { + faceIndex = dir.z < 0.0 ? 5.0 : 4.0; + ma = 0.5 / vAbs.z; + uv = vec2(dir.z < 0.0 ? -dir.x : dir.x, -dir.y); + tileOffset.x = 2.0; + tileOffset.y = dir.z < 0.0 ? 1.0 : 0.0; + } else if(vAbs.y >= vAbs.x) { + faceIndex = dir.y < 0.0 ? 3.0 : 2.0; + ma = 0.5 / vAbs.y; + uv = vec2(dir.x, dir.y < 0.0 ? -dir.z : dir.z); + tileOffset.x = 1.0; + tileOffset.y = dir.y < 0.0 ? 1.0 : 0.0; + } else { + faceIndex = dir.x < 0.0 ? 1.0 : 0.0; + ma = 0.5 / vAbs.x; + uv = vec2(dir.x < 0.0 ? dir.z : -dir.z, -dir.y); + tileOffset.x = 0.0; + tileOffset.y = dir.x < 0.0 ? 1.0 : 0.0; + } + return uv * ma + 0.5; +} +vec2 getCubemapAtlasCoordinates(const vec3 omniAtlasViewport, float shadowEdgePixels, float shadowTextureResolution, const vec3 dir) { + float faceIndex; + vec2 tileOffset; + vec2 uv = getCubemapFaceCoordinates(dir, faceIndex, tileOffset); + float atlasFaceSize = omniAtlasViewport.z; + float tileSize = shadowTextureResolution * atlasFaceSize; + float offset = shadowEdgePixels / tileSize; + uv = uv * vec2(1.0 - offset * 2.0) + vec2(offset * 1.0); + uv *= atlasFaceSize; + uv += tileOffset * atlasFaceSize; + uv += omniAtlasViewport.xy; + return uv; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/clusteredLightCookies.js +var clusteredLightCookiesPS = ` +vec3 _getCookieClustered(TEXTURE_ACCEPT(tex), vec2 uv, float intensity, bool isRgb, vec4 cookieChannel) { + vec4 pixel = mix(vec4(1.0), texture2DLodEXT(tex, uv, 0.0), intensity); + return isRgb == true ? pixel.rgb : vec3(dot(pixel, cookieChannel)); +} +vec3 getCookie2DClustered(TEXTURE_ACCEPT(tex), mat4 transform, vec3 worldPosition, float intensity, bool isRgb, vec4 cookieChannel) { + vec4 projPos = transform * vec4(worldPosition, 1.0); + return _getCookieClustered(TEXTURE_PASS(tex), projPos.xy / projPos.w, intensity, isRgb, cookieChannel); +} +vec3 getCookieCubeClustered(TEXTURE_ACCEPT(tex), vec3 dir, float intensity, bool isRgb, vec4 cookieChannel, float shadowTextureResolution, float shadowEdgePixels, vec3 omniAtlasViewport) { + vec2 uv = getCubemapAtlasCoordinates(omniAtlasViewport, shadowEdgePixels, shadowTextureResolution, dir); + return _getCookieClustered(TEXTURE_PASS(tex), uv, intensity, isRgb, cookieChannel); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/clusteredLightShadows.js +var clusteredLightShadowsPS = ` +void _getShadowCoordPerspZbuffer(mat4 shadowMatrix, vec4 shadowParams, vec3 wPos) { + vec4 projPos = shadowMatrix * vec4(wPos, 1.0); + projPos.xyz /= projPos.w; + dShadowCoord = projPos.xyz; +} +void getShadowCoordPerspZbufferNormalOffset(mat4 shadowMatrix, vec4 shadowParams, vec3 normal) { + vec3 wPos = vPositionW + normal * shadowParams.y; + _getShadowCoordPerspZbuffer(shadowMatrix, shadowParams, wPos); +} +vec3 normalOffsetPointShadow(vec4 shadowParams, vec3 lightPos, inout vec3 lightDir, vec3 lightDirNorm, vec3 normal) { + float distScale = length(lightDir); + vec3 wPos = vPositionW + normal * shadowParams.y * clamp(1.0 - dot(normal, -lightDirNorm), 0.0, 1.0) * distScale; + vec3 dir = wPos - lightPos; + return dir; +} +#ifdef GL2 + #if defined(CLUSTER_SHADOW_TYPE_PCF1) + float getShadowOmniClusteredPCF1(SHADOWMAP_ACCEPT(shadowMap), vec4 shadowParams, vec3 omniAtlasViewport, float shadowEdgePixels, vec3 lightDir) { + float shadowTextureResolution = shadowParams.x; + vec2 uv = getCubemapAtlasCoordinates(omniAtlasViewport, shadowEdgePixels, shadowTextureResolution, lightDir); + float shadowZ = length(lightDir) * shadowParams.w + shadowParams.z; + return textureShadow(shadowMap, vec3(uv, shadowZ)); + } + #endif + #if defined(CLUSTER_SHADOW_TYPE_PCF3) + float getShadowOmniClusteredPCF3(SHADOWMAP_ACCEPT(shadowMap), vec4 shadowParams, vec3 omniAtlasViewport, float shadowEdgePixels, vec3 lightDir) { + float shadowTextureResolution = shadowParams.x; + vec2 uv = getCubemapAtlasCoordinates(omniAtlasViewport, shadowEdgePixels, shadowTextureResolution, lightDir); + float shadowZ = length(lightDir) * shadowParams.w + shadowParams.z; + vec3 shadowCoord = vec3(uv, shadowZ); + return getShadowPCF3x3(SHADOWMAP_PASS(shadowMap), shadowCoord, shadowParams); + } + #endif + #if defined(CLUSTER_SHADOW_TYPE_PCF5) + float getShadowOmniClusteredPCF5(SHADOWMAP_ACCEPT(shadowMap), vec4 shadowParams, vec3 omniAtlasViewport, float shadowEdgePixels, vec3 lightDir) { + float shadowTextureResolution = shadowParams.x; + vec2 uv = getCubemapAtlasCoordinates(omniAtlasViewport, shadowEdgePixels, shadowTextureResolution, lightDir); + float shadowZ = length(lightDir) * shadowParams.w + shadowParams.z; + vec3 shadowCoord = vec3(uv, shadowZ); + return getShadowPCF5x5(SHADOWMAP_PASS(shadowMap), shadowCoord, shadowParams); + } + #endif +#else + #if defined(CLUSTER_SHADOW_TYPE_PCF1) + float getShadowOmniClusteredPCF1(sampler2D shadowMap, vec4 shadowParams, vec3 omniAtlasViewport, float shadowEdgePixels, vec3 lightDir) { + float shadowTextureResolution = shadowParams.x; + vec2 uv = getCubemapAtlasCoordinates(omniAtlasViewport, shadowEdgePixels, shadowTextureResolution, lightDir); + float depth = unpackFloat(textureShadow(shadowMap, uv)); + float shadowZ = length(lightDir) * shadowParams.w + shadowParams.z; + return depth > shadowZ ? 1.0 : 0.0; + } + #endif + #if defined(CLUSTER_SHADOW_TYPE_PCF3) + float getShadowOmniClusteredPCF3(sampler2D shadowMap, vec4 shadowParams, vec3 omniAtlasViewport, float shadowEdgePixels, vec3 lightDir) { + float shadowTextureResolution = shadowParams.x; + vec2 uv = getCubemapAtlasCoordinates(omniAtlasViewport, shadowEdgePixels, shadowTextureResolution, lightDir); + float shadowZ = length(lightDir) * shadowParams.w + shadowParams.z; + vec3 shadowCoord = vec3(uv, shadowZ); + return getShadowPCF3x3(shadowMap, shadowCoord, shadowParams); + } + #endif + #if defined(CLUSTER_SHADOW_TYPE_PCF5) + float getShadowOmniClusteredPCF5(sampler2D shadowMap, vec4 shadowParams, vec3 omniAtlasViewport, float shadowEdgePixels, vec3 lightDir) { + float shadowTextureResolution = shadowParams.x; + vec2 uv = getCubemapAtlasCoordinates(omniAtlasViewport, shadowEdgePixels, shadowTextureResolution, lightDir); + float shadowZ = length(lightDir) * shadowParams.w + shadowParams.z; + vec3 shadowCoord = vec3(uv, shadowZ); + return getShadowPCF3x3(shadowMap, shadowCoord, shadowParams); + } + #endif +#endif +#ifdef GL2 + #if defined(CLUSTER_SHADOW_TYPE_PCF1) + float getShadowSpotClusteredPCF1(SHADOWMAP_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams) { + return textureShadow(shadowMap, shadowCoord); + } + #endif + #if defined(CLUSTER_SHADOW_TYPE_PCF3) + float getShadowSpotClusteredPCF3(SHADOWMAP_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams) { + return getShadowSpotPCF3x3(SHADOWMAP_PASS(shadowMap), shadowCoord, shadowParams); + } + #endif + #if defined(CLUSTER_SHADOW_TYPE_PCF5) + float getShadowSpotClusteredPCF5(SHADOWMAP_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams) { + return getShadowPCF5x5(SHADOWMAP_PASS(shadowMap), shadowCoord, shadowParams); + } + #endif +#else + #if defined(CLUSTER_SHADOW_TYPE_PCF1) + float getShadowSpotClusteredPCF1(sampler2D shadowMap, vec3 shadowCoord, vec4 shadowParams) { + float depth = unpackFloat(textureShadow(shadowMap, shadowCoord.xy)); + return depth > shadowCoord.z ? 1.0 : 0.0; + } + #endif + #if defined(CLUSTER_SHADOW_TYPE_PCF3) + float getShadowSpotClusteredPCF3(sampler2D shadowMap, vec3 shadowCoord, vec4 shadowParams) { + return getShadowSpotPCF3x3(shadowMap, shadowCoord, shadowParams); + } + #endif + #if defined(CLUSTER_SHADOW_TYPE_PCF5) + float getShadowSpotClusteredPCF5(sampler2D shadowMap, vec3 shadowCoord, vec4 shadowParams) { + return getShadowSpotPCF3x3(shadowMap, shadowCoord, shadowParams); + } + #endif +#endif +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/clusteredLight.js +var clusteredLightPS = ` +uniform highp sampler2D clusterWorldTexture; +uniform highp sampler2D lightsTexture8; +uniform highp sampler2D lightsTextureFloat; +#if defined(CLUSTER_COOKIES) + #define CLUSTER_COOKIES_OR_SHADOWS +#endif +#if defined(CLUSTER_SHADOWS) + #define CLUSTER_COOKIES_OR_SHADOWS +#endif +#ifdef CLUSTER_SHADOWS + #ifdef GL2 + uniform sampler2DShadow shadowAtlasTexture; + #else + uniform sampler2D shadowAtlasTexture; + #endif +#endif +#ifdef CLUSTER_COOKIES + uniform sampler2D cookieAtlasTexture; +#endif +#ifdef GL2 + uniform int clusterMaxCells; +#else + uniform float clusterMaxCells; + uniform vec4 lightsTextureInvSize; +#endif +uniform float clusterSkip; +uniform vec3 clusterCellsCountByBoundsSize; +uniform vec3 clusterTextureSize; +uniform vec3 clusterBoundsMin; +uniform vec3 clusterBoundsDelta; +uniform vec3 clusterCellsDot; +uniform vec3 clusterCellsMax; +uniform vec2 clusterCompressionLimit0; +uniform vec2 shadowAtlasParams; +struct ClusterLightData { + vec3 halfWidth; + float lightType; + vec3 halfHeight; + #ifdef GL2 + int lightIndex; + #else + float lightV; + #endif + vec3 position; + float shape; + vec3 direction; + float falloffMode; + vec3 color; + float shadowIntensity; + vec3 omniAtlasViewport; + float range; + vec4 cookieChannelMask; + float shadowBias; + float shadowNormalBias; + float innerConeAngleCos; + float outerConeAngleCos; + float cookie; + float cookieRgb; + float cookieIntensity; + float mask; +}; +mat4 lightProjectionMatrix; +#define isClusteredLightCastShadow(light) ( light.shadowIntensity > 0.0 ) +#define isClusteredLightCookie(light) (light.cookie > 0.5 ) +#define isClusteredLightCookieRgb(light) (light.cookieRgb > 0.5 ) +#define isClusteredLightSpot(light) ( light.lightType > 0.5 ) +#define isClusteredLightFalloffLinear(light) ( light.falloffMode < 0.5 ) +#define isClusteredLightArea(light) ( light.shape > 0.1 ) +#define isClusteredLightRect(light) ( light.shape < 0.3 ) +#define isClusteredLightDisk(light) ( light.shape < 0.6 ) +#ifdef CLUSTER_MESH_DYNAMIC_LIGHTS + #define acceptLightMask(light) ( light.mask < 0.75) +#else + #define acceptLightMask(light) ( light.mask > 0.25) +#endif +vec4 decodeClusterLowRange4Vec4(vec4 d0, vec4 d1, vec4 d2, vec4 d3) { + return vec4( + bytes2floatRange4(d0, -2.0, 2.0), + bytes2floatRange4(d1, -2.0, 2.0), + bytes2floatRange4(d2, -2.0, 2.0), + bytes2floatRange4(d3, -2.0, 2.0) + ); +} +#ifdef GL2 + vec4 sampleLightsTexture8(const ClusterLightData clusterLightData, int index) { + return texelFetch(lightsTexture8, ivec2(index, clusterLightData.lightIndex), 0); + } + vec4 sampleLightTextureF(const ClusterLightData clusterLightData, int index) { + return texelFetch(lightsTextureFloat, ivec2(index, clusterLightData.lightIndex), 0); + } +#else + vec4 sampleLightsTexture8(const ClusterLightData clusterLightData, float index) { + return texture2DLodEXT(lightsTexture8, vec2(index * lightsTextureInvSize.z, clusterLightData.lightV), 0.0); + } + vec4 sampleLightTextureF(const ClusterLightData clusterLightData, float index) { + return texture2DLodEXT(lightsTextureFloat, vec2(index * lightsTextureInvSize.x, clusterLightData.lightV), 0.0); + } +#endif +void decodeClusterLightCore(inout ClusterLightData clusterLightData, float lightIndex) { + #ifdef GL2 + clusterLightData.lightIndex = int(lightIndex); + #else + clusterLightData.lightV = (lightIndex + 0.5) * lightsTextureInvSize.w; + #endif + vec4 lightInfo = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_FLAGS); + clusterLightData.lightType = lightInfo.x; + clusterLightData.shape = lightInfo.y; + clusterLightData.falloffMode = lightInfo.z; + clusterLightData.shadowIntensity = lightInfo.w; + vec4 colorA = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_COLOR_A); + vec4 colorB = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_COLOR_B); + clusterLightData.color = vec3(bytes2float2(colorA.xy), bytes2float2(colorA.zw), bytes2float2(colorB.xy)) * clusterCompressionLimit0.y; + clusterLightData.cookie = colorB.z; + clusterLightData.mask = colorB.w; + #ifdef CLUSTER_TEXTURE_FLOAT + vec4 lightPosRange = sampleLightTextureF(clusterLightData, CLUSTER_TEXTURE_F_POSITION_RANGE); + clusterLightData.position = lightPosRange.xyz; + clusterLightData.range = lightPosRange.w; + vec4 lightDir_Unused = sampleLightTextureF(clusterLightData, CLUSTER_TEXTURE_F_SPOT_DIRECTION); + clusterLightData.direction = lightDir_Unused.xyz; + #else + vec4 encPosX = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_POSITION_X); + vec4 encPosY = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_POSITION_Y); + vec4 encPosZ = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_POSITION_Z); + clusterLightData.position = vec3(bytes2float4(encPosX), bytes2float4(encPosY), bytes2float4(encPosZ)) * clusterBoundsDelta + clusterBoundsMin; + vec4 encRange = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_RANGE); + clusterLightData.range = bytes2float4(encRange) * clusterCompressionLimit0.x; + vec4 encDirX = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_SPOT_DIRECTION_X); + vec4 encDirY = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_SPOT_DIRECTION_Y); + vec4 encDirZ = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_SPOT_DIRECTION_Z); + clusterLightData.direction = vec3(bytes2float4(encDirX), bytes2float4(encDirY), bytes2float4(encDirZ)) * 2.0 - 1.0; + #endif +} +void decodeClusterLightSpot(inout ClusterLightData clusterLightData) { + vec4 coneAngle = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_SPOT_ANGLES); + clusterLightData.innerConeAngleCos = bytes2float2(coneAngle.xy) * 2.0 - 1.0; + clusterLightData.outerConeAngleCos = bytes2float2(coneAngle.zw) * 2.0 - 1.0; +} +void decodeClusterLightOmniAtlasViewport(inout ClusterLightData clusterLightData) { + #ifdef CLUSTER_TEXTURE_FLOAT + clusterLightData.omniAtlasViewport = sampleLightTextureF(clusterLightData, CLUSTER_TEXTURE_F_PROJ_MAT_0).xyz; + #else + vec4 viewportA = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_ATLAS_VIEWPORT_A); + vec4 viewportB = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_ATLAS_VIEWPORT_B); + clusterLightData.omniAtlasViewport = vec3(bytes2float2(viewportA.xy), bytes2float2(viewportA.zw), bytes2float2(viewportB.xy)); + #endif +} +void decodeClusterLightAreaData(inout ClusterLightData clusterLightData) { + #ifdef CLUSTER_TEXTURE_FLOAT + clusterLightData.halfWidth = sampleLightTextureF(clusterLightData, CLUSTER_TEXTURE_F_AREA_DATA_WIDTH).xyz; + clusterLightData.halfHeight = sampleLightTextureF(clusterLightData, CLUSTER_TEXTURE_F_AREA_DATA_HEIGHT).xyz; + #else + vec4 areaWidthX = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_AREA_DATA_WIDTH_X); + vec4 areaWidthY = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_AREA_DATA_WIDTH_Y); + vec4 areaWidthZ = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_AREA_DATA_WIDTH_Z); + clusterLightData.halfWidth = vec3(mantissaExponent2Float(areaWidthX), mantissaExponent2Float(areaWidthY), mantissaExponent2Float(areaWidthZ)); + vec4 areaHeightX = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_AREA_DATA_HEIGHT_X); + vec4 areaHeightY = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_AREA_DATA_HEIGHT_Y); + vec4 areaHeightZ = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_AREA_DATA_HEIGHT_Z); + clusterLightData.halfHeight = vec3(mantissaExponent2Float(areaHeightX), mantissaExponent2Float(areaHeightY), mantissaExponent2Float(areaHeightZ)); + #endif +} +void decodeClusterLightProjectionMatrixData(inout ClusterLightData clusterLightData) { + + #ifdef CLUSTER_TEXTURE_FLOAT + vec4 m0 = sampleLightTextureF(clusterLightData, CLUSTER_TEXTURE_F_PROJ_MAT_0); + vec4 m1 = sampleLightTextureF(clusterLightData, CLUSTER_TEXTURE_F_PROJ_MAT_1); + vec4 m2 = sampleLightTextureF(clusterLightData, CLUSTER_TEXTURE_F_PROJ_MAT_2); + vec4 m3 = sampleLightTextureF(clusterLightData, CLUSTER_TEXTURE_F_PROJ_MAT_3); + #else + vec4 m00 = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_PROJ_MAT_00); + vec4 m01 = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_PROJ_MAT_01); + vec4 m02 = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_PROJ_MAT_02); + vec4 m03 = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_PROJ_MAT_03); + vec4 m0 = decodeClusterLowRange4Vec4(m00, m01, m02, m03); + vec4 m10 = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_PROJ_MAT_10); + vec4 m11 = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_PROJ_MAT_11); + vec4 m12 = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_PROJ_MAT_12); + vec4 m13 = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_PROJ_MAT_13); + vec4 m1 = decodeClusterLowRange4Vec4(m10, m11, m12, m13); + vec4 m20 = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_PROJ_MAT_20); + vec4 m21 = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_PROJ_MAT_21); + vec4 m22 = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_PROJ_MAT_22); + vec4 m23 = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_PROJ_MAT_23); + vec4 m2 = decodeClusterLowRange4Vec4(m20, m21, m22, m23); + vec4 m30 = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_PROJ_MAT_30); + vec4 m31 = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_PROJ_MAT_31); + vec4 m32 = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_PROJ_MAT_32); + vec4 m33 = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_PROJ_MAT_33); + vec4 m3 = vec4(mantissaExponent2Float(m30), mantissaExponent2Float(m31), mantissaExponent2Float(m32), mantissaExponent2Float(m33)); + #endif + + lightProjectionMatrix = mat4(m0, m1, m2, m3); +} +void decodeClusterLightShadowData(inout ClusterLightData clusterLightData) { + + vec4 biases = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_SHADOW_BIAS); + clusterLightData.shadowBias = bytes2floatRange2(biases.xy, -1.0, 20.0), + clusterLightData.shadowNormalBias = bytes2float2(biases.zw); +} +void decodeClusterLightCookieData(inout ClusterLightData clusterLightData) { + vec4 cookieA = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_COOKIE_A); + clusterLightData.cookieIntensity = cookieA.x; + clusterLightData.cookieRgb = cookieA.y; + clusterLightData.cookieChannelMask = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_COOKIE_B); +} +void evaluateLight( + ClusterLightData light, + vec3 worldNormal, + vec3 viewDir, + vec3 reflectionDir, +#if defined(LIT_CLEARCOAT) + vec3 clearcoatReflectionDir, +#endif + float gloss, + vec3 specularity, + vec3 geometricNormal, + mat3 tbn, +#if defined(LIT_IRIDESCENCE) + vec3 iridescenceFresnel, +#endif + vec3 clearcoat_worldNormal, + float clearcoat_gloss, + float sheen_gloss, + float iridescence_intensity +) { + vec3 cookieAttenuation = vec3(1.0); + float diffuseAttenuation = 1.0; + float falloffAttenuation = 1.0; + getLightDirPoint(light.position); + #ifdef CLUSTER_AREALIGHTS + if (isClusteredLightArea(light)) { + decodeClusterLightAreaData(light); + if (isClusteredLightRect(light)) { + calcRectLightValues(light.position, light.halfWidth, light.halfHeight); + } else if (isClusteredLightDisk(light)) { + calcDiskLightValues(light.position, light.halfWidth, light.halfHeight); + } else { + calcSphereLightValues(light.position, light.halfWidth, light.halfHeight); + } + falloffAttenuation = getFalloffWindow(light.range, dLightDirW); + } else + #endif + { + if (isClusteredLightFalloffLinear(light)) + falloffAttenuation = getFalloffLinear(light.range, dLightDirW); + else + falloffAttenuation = getFalloffInvSquared(light.range, dLightDirW); + } + if (falloffAttenuation > 0.00001) { + #ifdef CLUSTER_AREALIGHTS + if (isClusteredLightArea(light)) { + if (isClusteredLightRect(light)) { + diffuseAttenuation = getRectLightDiffuse(worldNormal, viewDir, dLightDirW, dLightDirNormW) * 16.0; + } else if (isClusteredLightDisk(light)) { + diffuseAttenuation = getDiskLightDiffuse(worldNormal, viewDir, dLightDirW, dLightDirNormW) * 16.0; + } else { + diffuseAttenuation = getSphereLightDiffuse(worldNormal, viewDir, dLightDirW, dLightDirNormW) * 16.0; + } + } else + #endif + { + falloffAttenuation *= getLightDiffuse(worldNormal, viewDir, dLightDirW, dLightDirNormW); + } + if (isClusteredLightSpot(light)) { + decodeClusterLightSpot(light); + falloffAttenuation *= getSpotEffect(light.direction, light.innerConeAngleCos, light.outerConeAngleCos, dLightDirNormW); + } + #if defined(CLUSTER_COOKIES_OR_SHADOWS) + if (falloffAttenuation > 0.00001) { + if (isClusteredLightCastShadow(light) || isClusteredLightCookie(light)) { + if (isClusteredLightSpot(light)) { + decodeClusterLightProjectionMatrixData(light); + } else { + decodeClusterLightOmniAtlasViewport(light); + } + float shadowTextureResolution = shadowAtlasParams.x; + float shadowEdgePixels = shadowAtlasParams.y; + #ifdef CLUSTER_COOKIES + if (isClusteredLightCookie(light)) { + decodeClusterLightCookieData(light); + if (isClusteredLightSpot(light)) { + cookieAttenuation = getCookie2DClustered(TEXTURE_PASS(cookieAtlasTexture), lightProjectionMatrix, vPositionW, light.cookieIntensity, isClusteredLightCookieRgb(light), light.cookieChannelMask); + } else { + cookieAttenuation = getCookieCubeClustered(TEXTURE_PASS(cookieAtlasTexture), dLightDirW, light.cookieIntensity, isClusteredLightCookieRgb(light), light.cookieChannelMask, shadowTextureResolution, shadowEdgePixels, light.omniAtlasViewport); + } + } + #endif + #ifdef CLUSTER_SHADOWS + if (isClusteredLightCastShadow(light)) { + decodeClusterLightShadowData(light); + vec4 shadowParams = vec4(shadowTextureResolution, light.shadowNormalBias, light.shadowBias, 1.0 / light.range); + if (isClusteredLightSpot(light)) { + getShadowCoordPerspZbufferNormalOffset(lightProjectionMatrix, shadowParams, geometricNormal); + + #if defined(CLUSTER_SHADOW_TYPE_PCF1) + float shadow = getShadowSpotClusteredPCF1(SHADOWMAP_PASS(shadowAtlasTexture), dShadowCoord, shadowParams); + #elif defined(CLUSTER_SHADOW_TYPE_PCF3) + float shadow = getShadowSpotClusteredPCF3(SHADOWMAP_PASS(shadowAtlasTexture), dShadowCoord, shadowParams); + #elif defined(CLUSTER_SHADOW_TYPE_PCF5) + float shadow = getShadowSpotClusteredPCF5(SHADOWMAP_PASS(shadowAtlasTexture), dShadowCoord, shadowParams); + #elif defined(CLUSTER_SHADOW_TYPE_PCSS) + float shadow = getShadowSpotClusteredPCSS(SHADOWMAP_PASS(shadowAtlasTexture), dShadowCoord, shadowParams); + #endif + falloffAttenuation *= mix(1.0, shadow, light.shadowIntensity); + } else { + vec3 dir = normalOffsetPointShadow(shadowParams, dLightPosW, dLightDirW, dLightDirNormW, geometricNormal); + #if defined(CLUSTER_SHADOW_TYPE_PCF1) + float shadow = getShadowOmniClusteredPCF1(SHADOWMAP_PASS(shadowAtlasTexture), shadowParams, light.omniAtlasViewport, shadowEdgePixels, dir); + #elif defined(CLUSTER_SHADOW_TYPE_PCF3) + float shadow = getShadowOmniClusteredPCF3(SHADOWMAP_PASS(shadowAtlasTexture), shadowParams, light.omniAtlasViewport, shadowEdgePixels, dir); + #elif defined(CLUSTER_SHADOW_TYPE_PCF5) + float shadow = getShadowOmniClusteredPCF5(SHADOWMAP_PASS(shadowAtlasTexture), shadowParams, light.omniAtlasViewport, shadowEdgePixels, dir); + #endif + falloffAttenuation *= mix(1.0, shadow, light.shadowIntensity); + } + } + #endif + } + } + #endif + #ifdef CLUSTER_AREALIGHTS + if (isClusteredLightArea(light)) { + { + vec3 areaDiffuse = (diffuseAttenuation * falloffAttenuation) * light.color * cookieAttenuation; + #if defined(LIT_SPECULAR) + #if defined(LIT_CONSERVE_ENERGY) + areaDiffuse = mix(areaDiffuse, vec3(0), dLTCSpecFres); + #endif + #endif + dDiffuseLight += areaDiffuse; + } + #ifdef LIT_SPECULAR + float areaLightSpecular; + if (isClusteredLightRect(light)) { + areaLightSpecular = getRectLightSpecular(worldNormal, viewDir); + } else if (isClusteredLightDisk(light)) { + areaLightSpecular = getDiskLightSpecular(worldNormal, viewDir); + } else { + areaLightSpecular = getSphereLightSpecular(worldNormal, viewDir); + } + dSpecularLight += dLTCSpecFres * areaLightSpecular * falloffAttenuation * light.color * cookieAttenuation; + #ifdef LIT_CLEARCOAT + float areaLightSpecularCC; + if (isClusteredLightRect(light)) { + areaLightSpecularCC = getRectLightSpecular(clearcoat_worldNormal, viewDir); + } else if (isClusteredLightDisk(light)) { + areaLightSpecularCC = getDiskLightSpecular(clearcoat_worldNormal, viewDir); + } else { + areaLightSpecularCC = getSphereLightSpecular(clearcoat_worldNormal, viewDir); + } + ccSpecularLight += ccLTCSpecFres * areaLightSpecularCC * falloffAttenuation * light.color * cookieAttenuation; + #endif + #endif + } else + #endif + { + { + vec3 punctualDiffuse = falloffAttenuation * light.color * cookieAttenuation; + #if defined(CLUSTER_AREALIGHTS) + #if defined(LIT_SPECULAR) + #if defined(LIT_CONSERVE_ENERGY) + punctualDiffuse = mix(punctualDiffuse, vec3(0), specularity); + #endif + #endif + #endif + dDiffuseLight += punctualDiffuse; + } + + #ifdef LIT_SPECULAR + vec3 halfDir = normalize(-dLightDirNormW + viewDir); + + #ifdef LIT_SPECULAR_FRESNEL + dSpecularLight += + getLightSpecular(halfDir, reflectionDir, worldNormal, viewDir, dLightDirNormW, gloss, tbn) * falloffAttenuation * light.color * cookieAttenuation * + getFresnel( + dot(viewDir, halfDir), + gloss, + specularity + #if defined(LIT_IRIDESCENCE) + , iridescenceFresnel, + iridescence_intensity + #endif + ); + #else + dSpecularLight += getLightSpecular(halfDir, reflectionDir, worldNormal, viewDir, dLightDirNormW, gloss, tbn) * falloffAttenuation * light.color * cookieAttenuation * specularity; + #endif + #ifdef LIT_CLEARCOAT + #ifdef LIT_SPECULAR_FRESNEL + ccSpecularLight += getLightSpecular(halfDir, clearcoatReflectionDir, clearcoat_worldNormal, viewDir, dLightDirNormW, clearcoat_gloss, tbn) * falloffAttenuation * light.color * cookieAttenuation * getFresnelCC(dot(viewDir, halfDir)); + #else + ccSpecularLight += getLightSpecular(halfDir, clearcoatReflectionDir, clearcoat_worldNormal, viewDir, dLightDirNormW, clearcoat_gloss, tbn) * falloffAttenuation * light.color * cookieAttenuation; + #endif + #endif + #ifdef LIT_SHEEN + sSpecularLight += getLightSpecularSheen(halfDir, worldNormal, viewDir, dLightDirNormW, sheen_gloss) * falloffAttenuation * light.color * cookieAttenuation; + #endif + #endif + } + } + dAtten = falloffAttenuation; + dAttenD = diffuseAttenuation; + dAtten3 = cookieAttenuation; +} +void evaluateClusterLight( + float lightIndex, + vec3 worldNormal, + vec3 viewDir, + vec3 reflectionDir, +#if defined(LIT_CLEARCOAT) + vec3 clearcoatReflectionDir, +#endif + float gloss, + vec3 specularity, + vec3 geometricNormal, + mat3 tbn, +#if defined(LIT_IRIDESCENCE) + vec3 iridescenceFresnel, +#endif + vec3 clearcoat_worldNormal, + float clearcoat_gloss, + float sheen_gloss, + float iridescence_intensity +) { + ClusterLightData clusterLightData; + decodeClusterLightCore(clusterLightData, lightIndex); + if (acceptLightMask(clusterLightData)) + evaluateLight( + clusterLightData, + worldNormal, + viewDir, + reflectionDir, +#if defined(LIT_CLEARCOAT) + clearcoatReflectionDir, +#endif + gloss, + specularity, + geometricNormal, + tbn, +#if defined(LIT_IRIDESCENCE) + iridescenceFresnel, +#endif + clearcoat_worldNormal, + clearcoat_gloss, + sheen_gloss, + iridescence_intensity + ); +} +void addClusteredLights( + vec3 worldNormal, + vec3 viewDir, + vec3 reflectionDir, +#if defined(LIT_CLEARCOAT) + vec3 clearcoatReflectionDir, +#endif + float gloss, + vec3 specularity, + vec3 geometricNormal, + mat3 tbn, +#if defined(LIT_IRIDESCENCE) + vec3 iridescenceFresnel, +#endif + vec3 clearcoat_worldNormal, + float clearcoat_gloss, + float sheen_gloss, + float iridescence_intensity +) { + if (clusterSkip > 0.5) + return; + vec3 cellCoords = floor((vPositionW - clusterBoundsMin) * clusterCellsCountByBoundsSize); + if (!(any(lessThan(cellCoords, vec3(0.0))) || any(greaterThanEqual(cellCoords, clusterCellsMax)))) { + float cellIndex = dot(clusterCellsDot, cellCoords); + float clusterV = floor(cellIndex * clusterTextureSize.y); + float clusterU = cellIndex - (clusterV * clusterTextureSize.x); + #ifdef GL2 + for (int lightCellIndex = 0; lightCellIndex < clusterMaxCells; lightCellIndex++) { + float lightIndex = texelFetch(clusterWorldTexture, ivec2(int(clusterU) + lightCellIndex, clusterV), 0).x; + if (lightIndex <= 0.0) + return; + evaluateClusterLight( + lightIndex * 255.0, + worldNormal, + viewDir, + reflectionDir, +#if defined(LIT_CLEARCOAT) + clearcoatReflectionDir, +#endif + gloss, + specularity, + geometricNormal, + tbn, +#if defined(LIT_IRIDESCENCE) + iridescenceFresnel, +#endif + clearcoat_worldNormal, + clearcoat_gloss, + sheen_gloss, + iridescence_intensity + ); + } + #else + clusterV = (clusterV + 0.5) * clusterTextureSize.z; + const float maxLightCells = 256.0; + for (float lightCellIndex = 0.5; lightCellIndex < maxLightCells; lightCellIndex++) { + float lightIndex = texture2DLodEXT(clusterWorldTexture, vec2(clusterTextureSize.y * (clusterU + lightCellIndex), clusterV), 0.0).x; + if (lightIndex <= 0.0) + return; + + evaluateClusterLight( + lightIndex * 255.0, + worldNormal, + viewDir, + reflectionDir, +#if defined(LIT_CLEARCOAT) + clearcoatReflectionDir, +#endif + gloss, + specularity, + geometricNormal, + tbn, +#if defined(LIT_IRIDESCENCE) + iridescenceFresnel, +#endif + clearcoat_worldNormal, + clearcoat_gloss, + sheen_gloss, + iridescence_intensity + ); + if (lightCellIndex >= clusterMaxCells) { + break; + } + } + #endif + } +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/combine.js +var combinePS = ` +vec3 combineColor(vec3 albedo, vec3 sheenSpecularity, float clearcoatSpecularity) { + vec3 ret = vec3(0); +#ifdef LIT_OLD_AMBIENT + ret += (dDiffuseLight - light_globalAmbient) * albedo + material_ambient * light_globalAmbient; +#else + ret += albedo * dDiffuseLight; +#endif +#ifdef LIT_SPECULAR + ret += dSpecularLight; +#endif +#ifdef LIT_REFLECTIONS + ret += dReflection.rgb * dReflection.a; +#endif +#ifdef LIT_SHEEN + float sheenScaling = 1.0 - max(max(sheenSpecularity.r, sheenSpecularity.g), sheenSpecularity.b) * 0.157; + ret = ret * sheenScaling + (sSpecularLight + sReflection.rgb) * sheenSpecularity; +#endif +#ifdef LIT_CLEARCOAT + float clearCoatScaling = 1.0 - ccFresnel * clearcoatSpecularity; + ret = ret * clearCoatScaling + (ccSpecularLight + ccReflection.rgb) * clearcoatSpecularity; +#endif + return ret; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/cookie.js +var cookiePS = ` +vec4 getCookie2D(sampler2D tex, mat4 transform, float intensity) { + vec4 projPos = transform * vec4(vPositionW, 1.0); + projPos.xy /= projPos.w; + return mix(vec4(1.0), texture2D(tex, projPos.xy), intensity); +} +vec4 getCookie2DClip(sampler2D tex, mat4 transform, float intensity) { + vec4 projPos = transform * vec4(vPositionW, 1.0); + projPos.xy /= projPos.w; + if (projPos.x < 0.0 || projPos.x > 1.0 || projPos.y < 0.0 || projPos.y > 1.0 || projPos.z < 0.0) return vec4(0.0); + return mix(vec4(1.0), texture2D(tex, projPos.xy), intensity); +} +vec4 getCookie2DXform(sampler2D tex, mat4 transform, float intensity, vec4 cookieMatrix, vec2 cookieOffset) { + vec4 projPos = transform * vec4(vPositionW, 1.0); + projPos.xy /= projPos.w; + projPos.xy += cookieOffset; + vec2 uv = mat2(cookieMatrix) * (projPos.xy-vec2(0.5)) + vec2(0.5); + return mix(vec4(1.0), texture2D(tex, uv), intensity); +} +vec4 getCookie2DClipXform(sampler2D tex, mat4 transform, float intensity, vec4 cookieMatrix, vec2 cookieOffset) { + vec4 projPos = transform * vec4(vPositionW, 1.0); + projPos.xy /= projPos.w; + projPos.xy += cookieOffset; + if (projPos.x < 0.0 || projPos.x > 1.0 || projPos.y < 0.0 || projPos.y > 1.0 || projPos.z < 0.0) return vec4(0.0); + vec2 uv = mat2(cookieMatrix) * (projPos.xy-vec2(0.5)) + vec2(0.5); + return mix(vec4(1.0), texture2D(tex, uv), intensity); +} +vec4 getCookieCube(samplerCube tex, mat4 transform, float intensity) { + return mix(vec4(1.0), textureCube(tex, dLightDirNormW * mat3(transform)), intensity); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/cubeMapProjectBox.js +var cubeMapProjectBoxPS = ` +uniform vec3 envBoxMin; +uniform vec3 envBoxMax; +vec3 cubeMapProject(vec3 nrdir) { + nrdir = cubeMapRotate(nrdir); + vec3 rbmax = (envBoxMax - vPositionW) / nrdir; + vec3 rbmin = (envBoxMin - vPositionW) / nrdir; + vec3 rbminmax; + rbminmax.x = nrdir.x>0.0? rbmax.x : rbmin.x; + rbminmax.y = nrdir.y>0.0? rbmax.y : rbmin.y; + rbminmax.z = nrdir.z>0.0? rbmax.z : rbmin.z; + float fa = min(min(rbminmax.x, rbminmax.y), rbminmax.z); + vec3 posonbox = vPositionW + nrdir * fa; + vec3 envBoxPos = (envBoxMin + envBoxMax) * 0.5; + return normalize(posonbox - envBoxPos); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/cubeMapProjectNone.js +var cubeMapProjectNonePS = ` +vec3 cubeMapProject(vec3 dir) { + return cubeMapRotate(dir); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/cubeMapRotate.js +var cubeMapRotatePS = ` +#ifdef CUBEMAP_ROTATION +uniform mat3 cubeMapRotationMatrix; +#endif +vec3 cubeMapRotate(vec3 refDir) { +#ifdef CUBEMAP_ROTATION + return refDir * cubeMapRotationMatrix; +#else + return refDir; +#endif +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/debug-output.js +var debugOutputPS = ` +#ifdef DEBUG_ALBEDO_PASS +gl_FragColor = vec4(gammaCorrectOutput(dAlbedo), 1.0); +#endif +#ifdef DEBUG_UV0_PASS +gl_FragColor = vec4(litArgs_albedo , 1.0); +#endif +#ifdef DEBUG_WORLD_NORMAL_PASS +gl_FragColor = vec4(litArgs_worldNormal * 0.5 + 0.5, 1.0); +#endif +#ifdef DEBUG_OPACITY_PASS +gl_FragColor = vec4(vec3(litArgs_opacity) , 1.0); +#endif +#ifdef DEBUG_SPECULARITY_PASS +gl_FragColor = vec4(litArgs_specularity, 1.0); +#endif +#ifdef DEBUG_GLOSS_PASS +gl_FragColor = vec4(vec3(litArgs_gloss) , 1.0); +#endif +#ifdef DEBUG_METALNESS_PASS +gl_FragColor = vec4(vec3(litArgs_metalness) , 1.0); +#endif +#ifdef DEBUG_AO_PASS +gl_FragColor = vec4(vec3(litArgs_ao) , 1.0); +#endif +#ifdef DEBUG_EMISSION_PASS +gl_FragColor = vec4(gammaCorrectOutput(litArgs_emission), 1.0); +#endif +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/debug-process-frontend.js +var debugProcessFrontendPS = ` +#ifdef DEBUG_LIGHTING_PASS +litArgs_albedo = vec3(0.5); +#endif +#ifdef DEBUG_UV0_PASS +#ifdef VARYING_VUV0 +litArgs_albedo = vec3(vUv0, 0); +#else +litArgs_albedo = vec3(0); +#endif +#endif +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/decode.js +var decodePS = ` +vec3 decodeLinear(vec4 raw) { + return raw.rgb; +} +float decodeGamma(float raw) { + return pow(raw, 2.2); +} +vec3 decodeGamma(vec3 raw) { + return pow(raw, vec3(2.2)); +} +vec3 decodeGamma(vec4 raw) { + return pow(raw.xyz, vec3(2.2)); +} +vec3 decodeRGBM(vec4 raw) { + vec3 color = (8.0 * raw.a) * raw.rgb; + return color * color; +} +vec3 decodeRGBP(vec4 raw) { + vec3 color = raw.rgb * (-raw.a * 7.0 + 8.0); + return color * color; +} +vec3 decodeRGBE(vec4 raw) { + if (raw.a == 0.0) { + return vec3(0.0, 0.0, 0.0); + } else { + return raw.xyz * pow(2.0, raw.w * 255.0 - 128.0); + } +} +vec4 passThrough(vec4 raw) { + return raw; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/detailModes.js +var detailModesPS = ` +vec3 detailMode_mul(vec3 c1, vec3 c2) { + return c1 * c2; +} +vec3 detailMode_add(vec3 c1, vec3 c2) { + return c1 + c2; +} +vec3 detailMode_screen(vec3 c1, vec3 c2) { + return 1.0 - (1.0 - c1)*(1.0 - c2); +} +vec3 detailMode_overlay(vec3 c1, vec3 c2) { + return mix(1.0 - 2.0*(1.0 - c1)*(1.0 - c2), 2.0*c1*c2, step(c1, vec3(0.5))); +} +vec3 detailMode_min(vec3 c1, vec3 c2) { + return min(c1, c2); +} +vec3 detailMode_max(vec3 c1, vec3 c2) { + return max(c1, c2); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/diffuse.js +var diffusePS = ` +#ifdef MAPCOLOR +uniform vec3 material_diffuse; +#endif +void getAlbedo() { + dAlbedo = vec3(1.0); +#ifdef MAPCOLOR + dAlbedo *= material_diffuse.rgb; +#endif +#ifdef MAPTEXTURE + vec3 albedoBase = $DECODE(texture2DBias($SAMPLER, $UV, textureBias)).$CH; + dAlbedo *= addAlbedoDetail(albedoBase); +#endif +#ifdef MAPVERTEX + dAlbedo *= gammaCorrectInput(saturate(vVertexColor.$VC)); +#endif +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/diffuseDetailMap.js +var diffuseDetailMapPS = ` +vec3 addAlbedoDetail(vec3 albedo) { +#ifdef MAPTEXTURE + vec3 albedoDetail = $DECODE(texture2DBias($SAMPLER, $UV, textureBias)).$CH; + return detailMode_$DETAILMODE(albedo, albedoDetail); +#else + return albedo; +#endif +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/emissive.js +var emissivePS = ` +#ifdef MAPCOLOR +uniform vec3 material_emissive; +#endif +#ifdef MAPFLOAT +uniform float material_emissiveIntensity; +#endif +void getEmission() { + dEmission = vec3(1.0); + #ifdef MAPFLOAT + dEmission *= material_emissiveIntensity; + #endif + #ifdef MAPCOLOR + dEmission *= material_emissive; + #endif + #ifdef MAPTEXTURE + dEmission *= $DECODE(texture2DBias($SAMPLER, $UV, textureBias)).$CH; + #endif + #ifdef MAPVERTEX + dEmission *= gammaCorrectInput(saturate(vVertexColor.$VC)); + #endif +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/encode.js +var encodePS = ` +vec4 encodeLinear(vec3 source) { + return vec4(source, 1.0); +} +vec4 encodeGamma(vec3 source) { + return vec4(pow(source + 0.0000001, vec3(1.0 / 2.2)), 1.0); +} +vec4 encodeRGBM(vec3 source) { + vec4 result; + result.rgb = pow(source.rgb, vec3(0.5)); + result.rgb *= 1.0 / 8.0; + result.a = saturate( max( max( result.r, result.g ), max( result.b, 1.0 / 255.0 ) ) ); + result.a = ceil(result.a * 255.0) / 255.0; + result.rgb /= result.a; + return result; +} +vec4 encodeRGBP(vec3 source) { + vec3 gamma = pow(source, vec3(0.5)); + float maxVal = min(8.0, max(1.0, max(gamma.x, max(gamma.y, gamma.z)))); + float v = 1.0 - ((maxVal - 1.0) / 7.0); + v = ceil(v * 255.0) / 255.0; + return vec4(gamma / (-v * 7.0 + 8.0), v); +} +vec4 encodeRGBE(vec3 source) { + float maxVal = max(source.x, max(source.y, source.z)); + if (maxVal < 1e-32) { + return vec4(0, 0, 0, 0); + } else { + float e = ceil(log2(maxVal)); + return vec4(source / pow(2.0, e), (e + 128.0) / 255.0); + } +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/end.js +var endPS = ` + gl_FragColor.rgb = combineColor(litArgs_albedo, litArgs_sheen_specularity, litArgs_clearcoat_specularity); + gl_FragColor.rgb += litArgs_emission; + gl_FragColor.rgb = addFog(gl_FragColor.rgb); + #ifndef HDR + gl_FragColor.rgb = toneMap(gl_FragColor.rgb); + gl_FragColor.rgb = gammaCorrectOutput(gl_FragColor.rgb); + #endif +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/vert/end.js +var endVS = ` +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/envAtlas.js +var envAtlasPS = ` +const float atlasSize = 512.0; +const float seamSize = 1.0 / atlasSize; +vec2 mapUv(vec2 uv, vec4 rect) { + return vec2(mix(rect.x + seamSize, rect.x + rect.z - seamSize, uv.x), + mix(rect.y + seamSize, rect.y + rect.w - seamSize, uv.y)); +} +vec2 mapRoughnessUv(vec2 uv, float level) { + float t = 1.0 / exp2(level); + return mapUv(uv, vec4(0, 1.0 - t, t, t * 0.5)); +} +vec2 mapShinyUv(vec2 uv, float level) { + float t = 1.0 / exp2(level); + return mapUv(uv, vec4(1.0 - t, 1.0 - t, t, t * 0.5)); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/envConst.js +var envConstPS = ` +vec3 processEnvironment(vec3 color) { + return color; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/envMultiply.js +var envMultiplyPS = ` +uniform float skyboxIntensity; +vec3 processEnvironment(vec3 color) { + return color * skyboxIntensity; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/extension.js +var extensionPS = ` +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/vert/extension.js +var extensionVS = ` +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/falloffInvSquared.js +var falloffInvSquaredPS = ` +float getFalloffWindow(float lightRadius, vec3 lightDir) { + float sqrDist = dot(lightDir, lightDir); + float invRadius = 1.0 / lightRadius; + return square( saturate( 1.0 - square( sqrDist * square(invRadius) ) ) ); +} +float getFalloffInvSquared(float lightRadius, vec3 lightDir) { + float sqrDist = dot(lightDir, lightDir); + float falloff = 1.0 / (sqrDist + 1.0); + float invRadius = 1.0 / lightRadius; + falloff *= 16.0; + falloff *= square( saturate( 1.0 - square( sqrDist * square(invRadius) ) ) ); + return falloff; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/falloffLinear.js +var falloffLinearPS = ` +float getFalloffLinear(float lightRadius, vec3 lightDir) { + float d = length(lightDir); + return max(((lightRadius - d) / lightRadius), 0.0); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/fixCubemapSeamsNone.js +var fixCubemapSeamsNonePS = ` +vec3 fixSeams(vec3 vec, float mipmapIndex) { + return vec; +} +vec3 fixSeams(vec3 vec) { + return vec; +} +vec3 fixSeamsStatic(vec3 vec, float invRecMipSize) { + return vec; +} +vec3 calcSeam(vec3 vec) { + return vec3(0); +} +vec3 applySeam(vec3 vec, vec3 seam, float scale) { + return vec; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/fixCubemapSeamsStretch.js +var fixCubemapSeamsStretchPS = ` +vec3 fixSeams(vec3 vec, float mipmapIndex) { + vec3 avec = abs(vec); + float scale = 1.0 - exp2(mipmapIndex) / 128.0; + float M = max(max(avec.x, avec.y), avec.z); + if (avec.x != M) vec.x *= scale; + if (avec.y != M) vec.y *= scale; + if (avec.z != M) vec.z *= scale; + return vec; +} +vec3 fixSeams(vec3 vec) { + vec3 avec = abs(vec); + float scale = 1.0 - 1.0 / 128.0; + float M = max(max(avec.x, avec.y), avec.z); + if (avec.x != M) vec.x *= scale; + if (avec.y != M) vec.y *= scale; + if (avec.z != M) vec.z *= scale; + return vec; +} +vec3 fixSeamsStatic(vec3 vec, float invRecMipSize) { + vec3 avec = abs(vec); + float scale = invRecMipSize; + float M = max(max(avec.x, avec.y), avec.z); + if (avec.x != M) vec.x *= scale; + if (avec.y != M) vec.y *= scale; + if (avec.z != M) vec.z *= scale; + return vec; +} +vec3 calcSeam(vec3 vec) { + vec3 avec = abs(vec); + float M = max(avec.x, max(avec.y, avec.z)); + return vec3(avec.x != M ? 1.0 : 0.0, + avec.y != M ? 1.0 : 0.0, + avec.z != M ? 1.0 : 0.0); +} +vec3 applySeam(vec3 vec, vec3 seam, float scale) { + return vec * (seam * -scale + vec3(1.0)); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/float-unpacking.js +var floatUnpackingPS = ` +float bytes2float2(vec2 data) { + return dot(data, vec2(1.0, 1.0 / 255.0)); +} +float bytes2float3(vec3 data) { + return dot(data, vec3(1.0, 1.0 / 255.0, 1.0 / 65025.0)); +} +float bytes2float4(vec4 data) { + return dot(data, vec4(1.0, 1.0 / 255.0, 1.0 / 65025.0, 1.0 / 16581375.0)); +} +float bytes2floatRange2(vec2 data, float min, float max) { + return mix(min, max, bytes2float2(data)); +} +float bytes2floatRange3(vec3 data, float min, float max) { + return mix(min, max, bytes2float3(data)); +} +float bytes2floatRange4(vec4 data, float min, float max) { + return mix(min, max, bytes2float4(data)); +} +float mantissaExponent2Float(vec4 pack) +{ + float value = bytes2floatRange3(pack.xyz, -1.0, 1.0); + float exponent = floor(pack.w * 255.0 - 127.0); + return value * exp2(exponent); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/fogExp.js +var fogExpPS = ` +uniform vec3 fog_color; +uniform float fog_density; +float dBlendModeFogFactor = 1.0; +vec3 addFog(vec3 color) { + float depth = gl_FragCoord.z / gl_FragCoord.w; + float fogFactor = exp(-depth * fog_density); + fogFactor = clamp(fogFactor, 0.0, 1.0); + return mix(fog_color * dBlendModeFogFactor, color, fogFactor); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/fogExp2.js +var fogExp2PS = ` +uniform vec3 fog_color; +uniform float fog_density; +float dBlendModeFogFactor = 1.0; +vec3 addFog(vec3 color) { + float depth = gl_FragCoord.z / gl_FragCoord.w; + float fogFactor = exp(-depth * depth * fog_density * fog_density); + fogFactor = clamp(fogFactor, 0.0, 1.0); + return mix(fog_color * dBlendModeFogFactor, color, fogFactor); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/fogLinear.js +var fogLinearPS = ` +uniform vec3 fog_color; +uniform float fog_start; +uniform float fog_end; +float dBlendModeFogFactor = 1.0; +vec3 addFog(vec3 color) { + float depth = gl_FragCoord.z / gl_FragCoord.w; + float fogFactor = (fog_end - depth) / (fog_end - fog_start); + fogFactor = clamp(fogFactor, 0.0, 1.0); + return mix(fog_color * dBlendModeFogFactor, color, fogFactor); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/fogNone.js +var fogNonePS = ` +float dBlendModeFogFactor = 1.0; +vec3 addFog(vec3 color) { + return color; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/fresnelSchlick.js +var fresnelSchlickPS = ` +vec3 getFresnel( + float cosTheta, + float gloss, + vec3 specularity +#if defined(LIT_IRIDESCENCE) + , vec3 iridescenceFresnel, + float iridescenceIntensity +#endif + ) { + float fresnel = pow(1.0 - max(cosTheta, 0.0), 5.0); + float glossSq = gloss * gloss; + vec3 ret = specularity + (max(vec3(glossSq), specularity) - specularity) * fresnel; +#if defined(LIT_IRIDESCENCE) + return mix(ret, iridescenceFresnel, iridescenceIntensity); +#else + return ret; +#endif +} +float getFresnelCC(float cosTheta) { + float fresnel = pow(1.0 - max(cosTheta, 0.0), 5.0); + return 0.04 + (1.0 - 0.04) * fresnel; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/fullscreenQuad.js +var fullscreenQuadPS = ` +varying vec2 vUv0; +uniform sampler2D source; +void main(void) { + gl_FragColor = texture2D(source, vUv0); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/vert/fullscreenQuad.js +var fullscreenQuadVS = ` +attribute vec2 vertex_position; +varying vec2 vUv0; +void main(void) +{ + gl_Position = vec4(vertex_position, 0.5, 1.0); + vUv0 = vertex_position.xy*0.5+0.5; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/gamma1_0.js +var gamma1_0PS = ` +float gammaCorrectInput(float color) { + return color; +} +vec3 gammaCorrectInput(vec3 color) { + return color; +} +vec4 gammaCorrectInput(vec4 color) { + return color; +} +vec3 gammaCorrectOutput(vec3 color) { + return color; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/gamma2_2.js +var gamma2_2PS = ` +float gammaCorrectInput(float color) { + return decodeGamma(color); +} +vec3 gammaCorrectInput(vec3 color) { + return decodeGamma(color); +} +vec4 gammaCorrectInput(vec4 color) { + return vec4(decodeGamma(color.xyz), color.w); +} +vec3 gammaCorrectOutput(vec3 color) { +#ifdef HDR + return color; +#else + return pow(color + 0.0000001, vec3(1.0 / 2.2)); +#endif +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/gloss.js +var glossPS = ` +#ifdef MAPFLOAT +uniform float material_gloss; +#endif +void getGlossiness() { + dGlossiness = 1.0; + #ifdef MAPFLOAT + dGlossiness *= material_gloss; + #endif + #ifdef MAPTEXTURE + dGlossiness *= texture2DBias($SAMPLER, $UV, textureBias).$CH; + #endif + #ifdef MAPVERTEX + dGlossiness *= saturate(vVertexColor.$VC); + #endif + #ifdef MAPINVERT + dGlossiness = 1.0 - dGlossiness; + #endif + dGlossiness += 0.0000001; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/iridescenceDiffraction.js +var iridescenceDiffractionPS = ` +uniform float material_iridescenceRefractionIndex; +#ifndef PI +#define PI 3.14159265 +#endif +float iridescence_iorToFresnel(float transmittedIor, float incidentIor) { + return pow((transmittedIor - incidentIor) / (transmittedIor + incidentIor), 2.0); +} +vec3 iridescence_iorToFresnel(vec3 transmittedIor, float incidentIor) { + return pow((transmittedIor - vec3(incidentIor)) / (transmittedIor + vec3(incidentIor)), vec3(2.0)); +} +vec3 iridescence_fresnelToIor(vec3 f0) { + vec3 sqrtF0 = sqrt(f0); + return (vec3(1.0) + sqrtF0) / (vec3(1.0) - sqrtF0); +} +vec3 iridescence_sensitivity(float opd, vec3 shift) { + float phase = 2.0 * PI * opd * 1.0e-9; + const vec3 val = vec3(5.4856e-13, 4.4201e-13, 5.2481e-13); + const vec3 pos = vec3(1.6810e+06, 1.7953e+06, 2.2084e+06); + const vec3 var = vec3(4.3278e+09, 9.3046e+09, 6.6121e+09); + vec3 xyz = val * sqrt(2.0 * PI * var) * cos(pos * phase + shift) * exp(-pow(phase, 2.0) * var); + xyz.x += 9.7470e-14 * sqrt(2.0 * PI * 4.5282e+09) * cos(2.2399e+06 * phase + shift[0]) * exp(-4.5282e+09 * pow(phase, 2.0)); + xyz /= vec3(1.0685e-07); + const mat3 XYZ_TO_REC709 = mat3( + 3.2404542, -0.9692660, 0.0556434, + -1.5371385, 1.8760108, -0.2040259, + -0.4985314, 0.0415560, 1.0572252 + ); + return XYZ_TO_REC709 * xyz; +} +float iridescence_fresnel(float cosTheta, float f0) { + float x = clamp(1.0 - cosTheta, 0.0, 1.0); + float x2 = x * x; + float x5 = x * x2 * x2; + return f0 + (1.0 - f0) * x5; +} +vec3 iridescence_fresnel(float cosTheta, vec3 f0) { + float x = clamp(1.0 - cosTheta, 0.0, 1.0); + float x2 = x * x; + float x5 = x * x2 * x2; + return f0 + (vec3(1.0) - f0) * x5; +} +vec3 calcIridescence(float outsideIor, float cosTheta, vec3 base_f0, float iridescenceThickness) { + float iridescenceIor = mix(outsideIor, material_iridescenceRefractionIndex, smoothstep(0.0, 0.03, iridescenceThickness)); + float sinTheta2Sq = pow(outsideIor / iridescenceIor, 2.0) * (1.0 - pow(cosTheta, 2.0)); + float cosTheta2Sq = 1.0 - sinTheta2Sq; + if (cosTheta2Sq < 0.0) { + return vec3(1.0); + } + float cosTheta2 = sqrt(cosTheta2Sq); + float r0 = iridescence_iorToFresnel(iridescenceIor, outsideIor); + float r12 = iridescence_fresnel(cosTheta, r0); + float r21 = r12; + float t121 = 1.0 - r12; + float phi12 = iridescenceIor < outsideIor ? PI : 0.0; + float phi21 = PI - phi12; + vec3 baseIor = iridescence_fresnelToIor(base_f0 + vec3(0.0001)); + vec3 r1 = iridescence_iorToFresnel(baseIor, iridescenceIor); + vec3 r23 = iridescence_fresnel(cosTheta2, r1); + vec3 phi23 = vec3(0.0); + if (baseIor[0] < iridescenceIor) phi23[0] = PI; + if (baseIor[1] < iridescenceIor) phi23[1] = PI; + if (baseIor[2] < iridescenceIor) phi23[2] = PI; + float opd = 2.0 * iridescenceIor * iridescenceThickness * cosTheta2; + vec3 phi = vec3(phi21) + phi23; + vec3 r123Sq = clamp(r12 * r23, 1e-5, 0.9999); + vec3 r123 = sqrt(r123Sq); + vec3 rs = pow(t121, 2.0) * r23 / (1.0 - r123Sq); + vec3 c0 = r12 + rs; + vec3 i = c0; + vec3 cm = rs - t121; + for (int m = 1; m <= 2; m++) { + cm *= r123; + vec3 sm = 2.0 * iridescence_sensitivity(float(m) * opd, float(m) * phi); + i += cm * sm; + } + return max(i, vec3(0.0)); +} +vec3 getIridescence(float cosTheta, vec3 specularity, float iridescenceThickness) { + return calcIridescence(1.0, cosTheta, specularity, iridescenceThickness); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/iridescence.js +var iridescencePS = ` +#ifdef MAPFLOAT +uniform float material_iridescence; +#endif +void getIridescence() { + float iridescence = 1.0; + #ifdef MAPFLOAT + iridescence *= material_iridescence; + #endif + #ifdef MAPTEXTURE + iridescence *= texture2DBias($SAMPLER, $UV, textureBias).$CH; + #endif + dIridescence = iridescence; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/iridescenceThickness.js +var iridescenceThicknessPS = ` +uniform float material_iridescenceThicknessMax; +#ifdef MAPTEXTURE +uniform float material_iridescenceThicknessMin; +#endif +void getIridescenceThickness() { + #ifdef MAPTEXTURE + float blend = texture2DBias($SAMPLER, $UV, textureBias).$CH; + float iridescenceThickness = mix(material_iridescenceThicknessMin, material_iridescenceThicknessMax, blend); + #else + float iridescenceThickness = material_iridescenceThicknessMax; + #endif + dIridescenceThickness = iridescenceThickness; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/vert/instancing.js +var instancingVS = ` +attribute vec4 instance_line1; +attribute vec4 instance_line2; +attribute vec4 instance_line3; +attribute vec4 instance_line4; +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/ior.js +var iorPS = ` +#ifdef MAPFLOAT +uniform float material_refractionIndex; +#endif +void getIor() { +#ifdef MAPFLOAT + dIor = material_refractionIndex; +#else + dIor = 1.0 / 1.5; +#endif +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/lightDiffuseLambert.js +var lightDiffuseLambertPS = ` +float getLightDiffuse(vec3 worldNormal, vec3 viewDir, vec3 lightDir, vec3 lightDirNorm) { + return max(dot(worldNormal, -lightDirNorm), 0.0); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/lightDirPoint.js +var lightDirPointPS = ` +void getLightDirPoint(vec3 lightPosW) { + dLightDirW = vPositionW - lightPosW; + dLightDirNormW = normalize(dLightDirW); + dLightPosW = lightPosW; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/lightmapAdd.js +var lightmapAddPS = ` +void addLightMap( + vec3 lightmap, + vec3 dir, + vec3 worldNormal, + vec3 viewDir, + vec3 reflectionDir, + float gloss, + vec3 specularity, + vec3 vertexNormal, + mat3 tbn +#if defined(LIT_IRIDESCENCE) + vec3 iridescenceFresnel, + float iridescenceIntensity +#endif +) { + dDiffuseLight += lightmap; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/lightmapDirAdd.js +var lightmapDirAddPS = ` +void addLightMap( + vec3 lightmap, + vec3 dir, + vec3 worldNormal, + vec3 viewDir, + vec3 reflectionDir, + float gloss, + vec3 specularity, + vec3 vertexNormal, + mat3 tbn +#if defined(LIT_IRIDESCENCE) + vec3 iridescenceFresnel, + float iridescenceIntensity +#endif +) { + if (dot(dir, dir) < 0.0001) { + dDiffuseLight += lightmap; + } else { + float vlight = saturate(dot(dir, -vertexNormal)); + float flight = saturate(dot(dir, -worldNormal)); + float nlight = (flight / max(vlight, 0.01)) * 0.5; + dDiffuseLight += lightmap * nlight * 2.0; + vec3 halfDir = normalize(-dir + viewDir); + vec3 specularLight = lightmap * getLightSpecular(halfDir, reflectionDir, worldNormal, viewDir, dir, gloss, tbn); +#ifdef LIT_SPECULAR_FRESNEL + specularLight *= + getFresnel(dot(viewDir, halfDir), + gloss, + specularity + #if defined(LIT_IRIDESCENCE) + , iridescenceFresnel, + iridescenceIntensity + #endif + ); +#endif + dSpecularLight += specularLight; + } +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/lightmapDir.js +var lightmapDirPS = ` +uniform sampler2D texture_lightMap; +uniform sampler2D texture_dirLightMap; +void getLightMap() { + dLightmap = $DECODE(texture2DBias(texture_lightMap, $UV, textureBias)).$CH; + vec3 dir = texture2DBias(texture_dirLightMap, $UV, textureBias).xyz * 2.0 - 1.0; + float dirDot = dot(dir, dir); + dLightmapDir = (dirDot > 0.001) ? dir / sqrt(dirDot) : vec3(0.0); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/lightmapSingle.js +var lightmapSinglePS = ` +void getLightMap() { + dLightmap = vec3(1.0); + #ifdef MAPTEXTURE + dLightmap *= $DECODE(texture2DBias($SAMPLER, $UV, textureBias)).$CH; + #endif + #ifdef MAPVERTEX + dLightmap *= saturate(vVertexColor.$VC); + #endif +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/lightSpecularAnisoGGX.js +var lightSpecularAnisoGGXPS = ` +float calcLightSpecular(float gloss, vec3 worldNormal, vec3 viewDir, vec3 h, vec3 lightDirNorm, mat3 tbn) { + float PI = 3.141592653589793; + float roughness = max((1.0 - gloss) * (1.0 - gloss), 0.001); + float anisotropy = material_anisotropy * roughness; + + float at = max((roughness + anisotropy), roughness / 4.0); + float ab = max((roughness - anisotropy), roughness / 4.0); + float NoH = dot(worldNormal, h); + float ToH = dot(tbn[0], h); + float BoH = dot(tbn[1], h); + float a2 = at * ab; + vec3 v = vec3(ab * ToH, at * BoH, a2 * NoH); + float v2 = dot(v, v); + float w2 = a2 / v2; + float D = a2 * w2 * w2 * (1.0 / PI); + float ToV = dot(tbn[0], viewDir); + float BoV = dot(tbn[1], viewDir); + float ToL = dot(tbn[0], -lightDirNorm); + float BoL = dot(tbn[1], -lightDirNorm); + float NoV = dot(worldNormal, viewDir); + float NoL = dot(worldNormal, -lightDirNorm); + float lambdaV = NoL * length(vec3(at * ToV, ab * BoV, NoV)); + float lambdaL = NoV * length(vec3(at * ToL, ab * BoL, NoL)); + float G = 0.5 / (lambdaV + lambdaL); + return D * G; +} +float getLightSpecular(vec3 h, vec3 reflDir, vec3 worldNormal, vec3 viewDir, vec3 lightDirNorm, float gloss, mat3 tbn) { + return calcLightSpecular(gloss, worldNormal, viewDir, h, lightDirNorm, tbn); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/lightSpecularBlinn.js +var lightSpecularBlinnPS = ` +float calcLightSpecular(float gloss, vec3 worldNormal, vec3 h) { + float nh = max( dot( h, worldNormal ), 0.0 ); + float specPow = exp2(gloss * 11.0); + specPow = max(specPow, 0.0001); + return pow(nh, specPow) * (specPow + 2.0) / 8.0; +} +float getLightSpecular(vec3 h, vec3 reflDir, vec3 worldNormal, vec3 viewDir, vec3 lightDirNorm, float gloss, mat3 tbn) { + return calcLightSpecular(gloss, worldNormal, h); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/lightSpecularPhong.js +var lightSpecularPhongPS = ` +float calcLightSpecular(float gloss, vec3 reflDir, vec3 lightDirNorm) { + float specPow = gloss; + return pow(max(dot(reflDir, -lightDirNorm), 0.0), specPow + 0.0001); +} +float getLightSpecular(vec3 h, vec3 reflDir, vec3 worldNormal, vec3 viewDir, vec3 lightDirNorm, float gloss, mat3 tbn) { + return calcLightSpecular(gloss, reflDir, lightDirNorm); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/lightSheen.js +var lightSheenPS = ` +float sheenD(vec3 normal, vec3 h, float roughness) { + float invR = 1.0 / (roughness * roughness); + float cos2h = max(dot(normal, h), 0.0); + cos2h *= cos2h; + float sin2h = max(1.0 - cos2h, 0.0078125); + return (2.0 + invR) * pow(sin2h, invR * 0.5) / (2.0 * PI); +} +float sheenV(vec3 normal, vec3 viewDir, vec3 light) { + float NoV = max(dot(normal, viewDir), 0.000001); + float NoL = max(dot(normal, light), 0.000001); + return 1.0 / (4.0 * (NoL + NoV - NoL * NoV)); +} +float getLightSpecularSheen(vec3 h, vec3 worldNormal, vec3 viewDir, vec3 lightDirNorm, float sheenGloss) { + float D = sheenD(worldNormal, h, sheenGloss); + float V = sheenV(worldNormal, viewDir, -lightDirNorm); + return D * V; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/linearizeDepth.js +var linearizeDepthPS = ` +#ifndef LINEARIZE_DEPTH +#define LINEARIZE_DEPTH +float linearizeDepth(float z, vec4 cameraParams) { + if (cameraParams.w == 0.0) + return (cameraParams.z * cameraParams.y) / (cameraParams.y + z * (cameraParams.z - cameraParams.y)); + else + return cameraParams.z + z * (cameraParams.y - cameraParams.z); +} +#ifndef CAMERAPLANES +#define CAMERAPLANES +uniform vec4 camera_params; +#endif +#ifdef GL2 +float linearizeDepth(float z) { + return linearizeDepth(z, camera_params); +} +#else +#ifndef UNPACKFLOAT +#define UNPACKFLOAT +float unpackFloat(vec4 rgbaDepth) { + const vec4 bitShift = vec4(1.0 / (256.0 * 256.0 * 256.0), 1.0 / (256.0 * 256.0), 1.0 / 256.0, 1.0); + return dot(rgbaDepth, bitShift); +} +#endif +#endif +#endif +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/litShaderArgs.js +var litShaderArgsPS = ` +vec3 litArgs_albedo; +float litArgs_opacity; +vec3 litArgs_emission; +vec3 litArgs_worldNormal; +float litArgs_ao; +vec3 litArgs_lightmap; +vec3 litArgs_lightmapDir; +float litArgs_metalness; +vec3 litArgs_specularity; +float litArgs_specularityFactor; +float litArgs_gloss; +float litArgs_sheen_gloss; +vec3 litArgs_sheen_specularity; +float litArgs_transmission; +float litArgs_thickness; +float litArgs_ior; +float litArgs_dispersion; +float litArgs_iridescence_intensity; +float litArgs_iridescence_thickness; +vec3 litArgs_clearcoat_worldNormal; +float litArgs_clearcoat_specularity; +float litArgs_clearcoat_gloss; +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/ltc.js +var ltcPS = ` +mat3 transposeMat3( const in mat3 m ) { + mat3 tmp; + tmp[ 0 ] = vec3( m[ 0 ].x, m[ 1 ].x, m[ 2 ].x ); + tmp[ 1 ] = vec3( m[ 0 ].y, m[ 1 ].y, m[ 2 ].y ); + tmp[ 2 ] = vec3( m[ 0 ].z, m[ 1 ].z, m[ 2 ].z ); + return tmp; +} +vec2 LTC_Uv( const in vec3 N, const in vec3 V, const in float roughness ) { + const float LUT_SIZE = 64.0; + const float LUT_SCALE = ( LUT_SIZE - 1.0 ) / LUT_SIZE; + const float LUT_BIAS = 0.5 / LUT_SIZE; + float dotNV = saturate( dot( N, V ) ); + vec2 uv = vec2( roughness, sqrt( 1.0 - dotNV ) ); + uv = uv * LUT_SCALE + LUT_BIAS; + return uv; +} +float LTC_ClippedSphereFormFactor( const in vec3 f ) { + float l = length( f ); + return max( ( l * l + f.z ) / ( l + 1.0 ), 0.0 ); +} +vec3 LTC_EdgeVectorFormFactor( const in vec3 v1, const in vec3 v2 ) { + float x = dot( v1, v2 ); + float y = abs( x ); + float a = 0.8543985 + ( 0.4965155 + 0.0145206 * y ) * y; + float b = 3.4175940 + ( 4.1616724 + y ) * y; + float v = a / b; + float theta_sintheta = ( x > 0.0 ) ? v : 0.5 * inversesqrt( max( 1.0 - x * x, 1e-7 ) ) - v; + return cross( v1, v2 ) * theta_sintheta; +} +struct Coords { + vec3 coord0; + vec3 coord1; + vec3 coord2; + vec3 coord3; +}; +float LTC_EvaluateRect( const in vec3 N, const in vec3 V, const in vec3 P, const in mat3 mInv, const in Coords rectCoords) { + vec3 v1 = rectCoords.coord1 - rectCoords.coord0; + vec3 v2 = rectCoords.coord3 - rectCoords.coord0; + + vec3 lightNormal = cross( v1, v2 ); + float factor = sign(-dot( lightNormal, P - rectCoords.coord0 )); + vec3 T1, T2; + T1 = normalize( V - N * dot( V, N ) ); + T2 = factor * cross( N, T1 ); + mat3 mat = mInv * transposeMat3( mat3( T1, T2, N ) ); + vec3 coords[ 4 ]; + coords[ 0 ] = mat * ( rectCoords.coord0 - P ); + coords[ 1 ] = mat * ( rectCoords.coord1 - P ); + coords[ 2 ] = mat * ( rectCoords.coord2 - P ); + coords[ 3 ] = mat * ( rectCoords.coord3 - P ); + coords[ 0 ] = normalize( coords[ 0 ] ); + coords[ 1 ] = normalize( coords[ 1 ] ); + coords[ 2 ] = normalize( coords[ 2 ] ); + coords[ 3 ] = normalize( coords[ 3 ] ); + vec3 vectorFormFactor = vec3( 0.0 ); + vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 0 ], coords[ 1 ] ); + vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 1 ], coords[ 2 ] ); + vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 2 ], coords[ 3 ] ); + vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 3 ], coords[ 0 ] ); + float result = LTC_ClippedSphereFormFactor( vectorFormFactor ); + return result; +} +Coords dLTCCoords; +Coords getLTCLightCoords(vec3 lightPos, vec3 halfWidth, vec3 halfHeight){ + Coords coords; + coords.coord0 = lightPos + halfWidth - halfHeight; + coords.coord1 = lightPos - halfWidth - halfHeight; + coords.coord2 = lightPos - halfWidth + halfHeight; + coords.coord3 = lightPos + halfWidth + halfHeight; + return coords; +} +float dSphereRadius; +Coords getSphereLightCoords(vec3 lightPos, vec3 halfWidth, vec3 halfHeight){ + dSphereRadius = max(length(halfWidth), length(halfHeight)); + vec3 f = reflect(normalize(lightPos - view_position), vNormalW); + vec3 w = normalize(cross(f, halfHeight)); + vec3 h = normalize(cross(f, w)); + return getLTCLightCoords(lightPos, w * dSphereRadius, h * dSphereRadius); +} +vec2 dLTCUV; +#ifdef LIT_CLEARCOAT +vec2 ccLTCUV; +#endif +vec2 getLTCLightUV(float gloss, vec3 worldNormal, vec3 viewDir) +{ + float roughness = max((1.0 - gloss) * (1.0 - gloss), 0.001); + return LTC_Uv( worldNormal, viewDir, roughness ); +} +vec3 dLTCSpecFres; +#ifdef LIT_CLEARCOAT +vec3 ccLTCSpecFres; +#endif +vec3 getLTCLightSpecFres(vec2 uv, vec3 specularity) +{ + vec4 t2 = texture2DLodEXT(areaLightsLutTex2, uv, 0.0); + #ifdef AREA_R8_G8_B8_A8_LUTS + t2 *= vec4(0.693103,1,1,1); + t2 += vec4(0.306897,0,0,0); + #endif + return specularity * t2.x + ( vec3( 1.0 ) - specularity) * t2.y; +} +void calcLTCLightValues(float gloss, vec3 worldNormal, vec3 viewDir, vec3 specularity, float clearcoatGloss, vec3 clearcoatWorldNormal, float clearcoatSpecularity) +{ + dLTCUV = getLTCLightUV(gloss, worldNormal, viewDir); + dLTCSpecFres = getLTCLightSpecFres(dLTCUV, specularity); +#ifdef LIT_CLEARCOAT + ccLTCUV = getLTCLightUV(clearcoatGloss, clearcoatWorldNormal, viewDir); + ccLTCSpecFres = getLTCLightSpecFres(ccLTCUV, vec3(clearcoatSpecularity)); +#endif +} +void calcRectLightValues(vec3 lightPos, vec3 halfWidth, vec3 halfHeight) +{ + dLTCCoords = getLTCLightCoords(lightPos, halfWidth, halfHeight); +} +void calcDiskLightValues(vec3 lightPos, vec3 halfWidth, vec3 halfHeight) +{ + calcRectLightValues(lightPos, halfWidth, halfHeight); +} +void calcSphereLightValues(vec3 lightPos, vec3 halfWidth, vec3 halfHeight) +{ + dLTCCoords = getSphereLightCoords(lightPos, halfWidth, halfHeight); +} +vec3 SolveCubic(vec4 Coefficient) +{ + float pi = 3.14159; + Coefficient.xyz /= Coefficient.w; + Coefficient.yz /= 3.0; + float A = Coefficient.w; + float B = Coefficient.z; + float C = Coefficient.y; + float D = Coefficient.x; + vec3 Delta = vec3( + -Coefficient.z * Coefficient.z + Coefficient.y, + -Coefficient.y * Coefficient.z + Coefficient.x, + dot(vec2(Coefficient.z, -Coefficient.y), Coefficient.xy) + ); + float Discriminant = dot(vec2(4.0 * Delta.x, -Delta.y), Delta.zy); + vec3 RootsA, RootsD; + vec2 xlc, xsc; + { + float A_a = 1.0; + float C_a = Delta.x; + float D_a = -2.0 * B * Delta.x + Delta.y; + float Theta = atan(sqrt(Discriminant), -D_a) / 3.0; + float x_1a = 2.0 * sqrt(-C_a) * cos(Theta); + float x_3a = 2.0 * sqrt(-C_a) * cos(Theta + (2.0 / 3.0) * pi); + float xl; + if ((x_1a + x_3a) > 2.0 * B) + xl = x_1a; + else + xl = x_3a; + xlc = vec2(xl - B, A); + } + { + float A_d = D; + float C_d = Delta.z; + float D_d = -D * Delta.y + 2.0 * C * Delta.z; + float Theta = atan(D * sqrt(Discriminant), -D_d) / 3.0; + float x_1d = 2.0 * sqrt(-C_d) * cos(Theta); + float x_3d = 2.0 * sqrt(-C_d) * cos(Theta + (2.0 / 3.0) * pi); + float xs; + if (x_1d + x_3d < 2.0 * C) + xs = x_1d; + else + xs = x_3d; + xsc = vec2(-D, xs + C); + } + float E = xlc.y * xsc.y; + float F = -xlc.x * xsc.y - xlc.y * xsc.x; + float G = xlc.x * xsc.x; + vec2 xmc = vec2(C * F - B * G, -B * F + C * E); + vec3 Root = vec3(xsc.x / xsc.y, xmc.x / xmc.y, xlc.x / xlc.y); + if (Root.x < Root.y && Root.x < Root.z) + Root.xyz = Root.yxz; + else if (Root.z < Root.x && Root.z < Root.y) + Root.xyz = Root.xzy; + return Root; +} +float LTC_EvaluateDisk(vec3 N, vec3 V, vec3 P, mat3 Minv, Coords points) +{ + vec3 T1, T2; + T1 = normalize(V - N * dot(V, N)); + T2 = cross(N, T1); + mat3 R = transposeMat3( mat3( T1, T2, N ) ); + vec3 L_[ 3 ]; + L_[ 0 ] = R * ( points.coord0 - P ); + L_[ 1 ] = R * ( points.coord1 - P ); + L_[ 2 ] = R * ( points.coord2 - P ); + vec3 Lo_i = vec3(0); + vec3 C = 0.5 * (L_[0] + L_[2]); + vec3 V1 = 0.5 * (L_[1] - L_[2]); + vec3 V2 = 0.5 * (L_[1] - L_[0]); + C = Minv * C; + V1 = Minv * V1; + V2 = Minv * V2; + float a, b; + float d11 = dot(V1, V1); + float d22 = dot(V2, V2); + float d12 = dot(V1, V2); + if (abs(d12) / sqrt(d11 * d22) > 0.0001) + { + float tr = d11 + d22; + float det = -d12 * d12 + d11 * d22; + det = sqrt(det); + float u = 0.5 * sqrt(tr - 2.0 * det); + float v = 0.5 * sqrt(tr + 2.0 * det); + float e_max = (u + v) * (u + v); + float e_min = (u - v) * (u - v); + vec3 V1_, V2_; + if (d11 > d22) + { + V1_ = d12 * V1 + (e_max - d11) * V2; + V2_ = d12 * V1 + (e_min - d11) * V2; + } + else + { + V1_ = d12*V2 + (e_max - d22)*V1; + V2_ = d12*V2 + (e_min - d22)*V1; + } + a = 1.0 / e_max; + b = 1.0 / e_min; + V1 = normalize(V1_); + V2 = normalize(V2_); + } + else + { + a = 1.0 / dot(V1, V1); + b = 1.0 / dot(V2, V2); + V1 *= sqrt(a); + V2 *= sqrt(b); + } + vec3 V3 = cross(V1, V2); + if (dot(C, V3) < 0.0) + V3 *= -1.0; + float L = dot(V3, C); + float x0 = dot(V1, C) / L; + float y0 = dot(V2, C) / L; + float E1 = inversesqrt(a); + float E2 = inversesqrt(b); + a *= L * L; + b *= L * L; + float c0 = a * b; + float c1 = a * b * (1.0 + x0 * x0 + y0 * y0) - a - b; + float c2 = 1.0 - a * (1.0 + x0 * x0) - b * (1.0 + y0 * y0); + float c3 = 1.0; + vec3 roots = SolveCubic(vec4(c0, c1, c2, c3)); + float e1 = roots.x; + float e2 = roots.y; + float e3 = roots.z; + vec3 avgDir = vec3(a * x0 / (a - e2), b * y0 / (b - e2), 1.0); + mat3 rotate = mat3(V1, V2, V3); + avgDir = rotate * avgDir; + avgDir = normalize(avgDir); + float L1 = sqrt(-e2 / e3); + float L2 = sqrt(-e2 / e1); + float formFactor = L1 * L2 * inversesqrt((1.0 + L1 * L1) * (1.0 + L2 * L2)); + + const float LUT_SIZE = 64.0; + const float LUT_SCALE = ( LUT_SIZE - 1.0 ) / LUT_SIZE; + const float LUT_BIAS = 0.5 / LUT_SIZE; + vec2 uv = vec2(avgDir.z * 0.5 + 0.5, formFactor); + uv = uv*LUT_SCALE + LUT_BIAS; + float scale = texture2DLodEXT(areaLightsLutTex2, uv, 0.0).w; + return formFactor*scale; +} +float getRectLightDiffuse(vec3 worldNormal, vec3 viewDir, vec3 lightDir, vec3 lightDirNorm) { + return LTC_EvaluateRect( worldNormal, viewDir, vPositionW, mat3( 1.0 ), dLTCCoords ); +} +float getDiskLightDiffuse(vec3 worldNormal, vec3 viewDir, vec3 lightDir, vec3 lightDirNorm) { + return LTC_EvaluateDisk( worldNormal, viewDir, vPositionW, mat3( 1.0 ), dLTCCoords ); +} +float getSphereLightDiffuse(vec3 worldNormal, vec3 viewDir, vec3 lightDir, vec3 lightDirNorm) { + float falloff = dSphereRadius / (dot(lightDir, lightDir) + dSphereRadius); + return getLightDiffuse(worldNormal, viewDir, lightDir, lightDirNorm) * falloff; +} +mat3 getLTCLightInvMat(vec2 uv) +{ + vec4 t1 = texture2DLodEXT(areaLightsLutTex1, uv, 0.0); + #ifdef AREA_R8_G8_B8_A8_LUTS + t1 *= vec4(1.001, 0.3239, 0.60437568, 1.0); + t1 += vec4(0.0, -0.2976, -0.01381, 0.0); + #endif + return mat3( + vec3( t1.x, 0, t1.y ), + vec3( 0, 1, 0 ), + vec3( t1.z, 0, t1.w ) + ); +} +float calcRectLightSpecular(vec3 worldNormal, vec3 viewDir, vec2 uv) { + mat3 mInv = getLTCLightInvMat(uv); + return LTC_EvaluateRect( worldNormal, viewDir, vPositionW, mInv, dLTCCoords ); +} +float getRectLightSpecular(vec3 worldNormal, vec3 viewDir) { + return calcRectLightSpecular(worldNormal, viewDir, dLTCUV); +} +float calcDiskLightSpecular(vec3 worldNormal, vec3 viewDir, vec2 uv) { + mat3 mInv = getLTCLightInvMat(uv); + return LTC_EvaluateDisk( worldNormal, viewDir, vPositionW, mInv, dLTCCoords ); +} +float getDiskLightSpecular(vec3 worldNormal, vec3 viewDir) { + return calcDiskLightSpecular(worldNormal, viewDir, dLTCUV); +} +float getSphereLightSpecular(vec3 worldNormal, vec3 viewDir) { + return calcDiskLightSpecular(worldNormal, viewDir, dLTCUV); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/metalness.js +var metalnessPS = ` +#ifdef MAPFLOAT +uniform float material_metalness; +#endif +void getMetalness() { + float metalness = 1.0; + #ifdef MAPFLOAT + metalness *= material_metalness; + #endif + #ifdef MAPTEXTURE + metalness *= texture2DBias($SAMPLER, $UV, textureBias).$CH; + #endif + #ifdef MAPVERTEX + metalness *= saturate(vVertexColor.$VC); + #endif + dMetalness = metalness; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/msdf.js +var msdfPS = ` +uniform sampler2D texture_msdfMap; +#ifdef GL_OES_standard_derivatives +#define USE_FWIDTH +#endif +#ifdef GL2 +#define USE_FWIDTH +#endif +float median(float r, float g, float b) { + return max(min(r, g), min(max(r, g), b)); +} +float map (float min, float max, float v) { + return (v - min) / (max - min); +} +uniform float font_sdfIntensity; +uniform float font_pxrange; +uniform float font_textureWidth; +#ifdef UNIFORM_TEXT_PARAMETERS +uniform vec4 outline_color; +uniform float outline_thickness; +uniform vec4 shadow_color; +uniform vec2 shadow_offset; +#else +varying vec4 outline_color; +varying float outline_thickness; +varying vec4 shadow_color; +varying vec2 shadow_offset; +#endif +vec4 applyMsdf(vec4 color) { + vec3 tsample = texture2D(texture_msdfMap, vUv0).rgb; + vec2 uvShdw = vUv0 - shadow_offset; + vec3 ssample = texture2D(texture_msdfMap, uvShdw).rgb; + float sigDist = median(tsample.r, tsample.g, tsample.b); + float sigDistShdw = median(ssample.r, ssample.g, ssample.b); + float smoothingMax = 0.2; + #ifdef USE_FWIDTH + vec2 w = fwidth(vUv0); + float smoothing = clamp(w.x * font_textureWidth / font_pxrange, 0.0, smoothingMax); + #else + float font_size = 16.0; + float smoothing = clamp(font_pxrange / font_size, 0.0, smoothingMax); + #endif + float mapMin = 0.05; + float mapMax = clamp(1.0 - font_sdfIntensity, mapMin, 1.0); + float sigDistInner = map(mapMin, mapMax, sigDist); + float sigDistOutline = map(mapMin, mapMax, sigDist + outline_thickness); + sigDistShdw = map(mapMin, mapMax, sigDistShdw + outline_thickness); + float center = 0.5; + float inside = smoothstep(center-smoothing, center+smoothing, sigDistInner); + float outline = smoothstep(center-smoothing, center+smoothing, sigDistOutline); + float shadow = smoothstep(center-smoothing, center+smoothing, sigDistShdw); + vec4 tcolor = (outline > inside) ? outline * vec4(outline_color.a * outline_color.rgb, outline_color.a) : vec4(0.0); + tcolor = mix(tcolor, color, inside); + vec4 scolor = (shadow > outline) ? shadow * vec4(shadow_color.a * shadow_color.rgb, shadow_color.a) : tcolor; + tcolor = mix(scolor, tcolor, outline); + + return tcolor; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/metalnessModulate.js +var metalnessModulatePS = ` +vec3 getSpecularModulate(in vec3 specularity, in vec3 albedo, in float metalness, in float f0) { + vec3 dielectricF0 = f0 * specularity; + return mix(dielectricF0, albedo, metalness); +} +vec3 getAlbedoModulate(in vec3 albedo, in float metalness) { + return albedo * (1.0 - metalness); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/vert/msdf.js +var msdfVS = ` +attribute vec3 vertex_outlineParameters; +attribute vec3 vertex_shadowParameters; +varying vec4 outline_color; +varying float outline_thickness; +varying vec4 shadow_color; +varying vec2 shadow_offset; +void unpackMsdfParams() { + vec3 little = mod(vertex_outlineParameters, 256.); + vec3 big = (vertex_outlineParameters - little) / 256.; + outline_color.rb = little.xy / 255.; + outline_color.ga = big.xy / 255.; + outline_thickness = little.z / 255. * 0.2; + little = mod(vertex_shadowParameters, 256.); + big = (vertex_shadowParameters - little) / 256.; + shadow_color.rb = little.xy / 255.; + shadow_color.ga = big.xy / 255.; + shadow_offset = (vec2(little.z, big.z) / 127. - 1.) * 0.005; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/vert/normal.js +var normalVS = ` +#ifdef MORPHING_TEXTURE_BASED_NORMAL +uniform highp sampler2D morphNormalTex; +#endif +vec3 getNormal() { + #ifdef SKIN + dNormalMatrix = mat3(dModelMatrix[0].xyz, dModelMatrix[1].xyz, dModelMatrix[2].xyz); + #elif defined(INSTANCING) + dNormalMatrix = mat3(instance_line1.xyz, instance_line2.xyz, instance_line3.xyz); + #else + dNormalMatrix = matrix_normal; + #endif + vec3 tempNormal = vertex_normal; + #ifdef MORPHING + #ifdef MORPHING_NRM03 + tempNormal += morph_weights_a[0] * morph_nrm0; + tempNormal += morph_weights_a[1] * morph_nrm1; + tempNormal += morph_weights_a[2] * morph_nrm2; + tempNormal += morph_weights_a[3] * morph_nrm3; + #endif + #ifdef MORPHING_NRM47 + tempNormal += morph_weights_b[0] * morph_nrm4; + tempNormal += morph_weights_b[1] * morph_nrm5; + tempNormal += morph_weights_b[2] * morph_nrm6; + tempNormal += morph_weights_b[3] * morph_nrm7; + #endif + #endif + #ifdef MORPHING_TEXTURE_BASED_NORMAL + #ifdef WEBGPU + ivec2 morphUV = getTextureMorphCoords(); + vec3 morphNormal = texelFetch(morphNormalTex, ivec2(morphUV), 0).xyz; + #else + vec2 morphUV = getTextureMorphCoords(); + vec3 morphNormal = texture2D(morphNormalTex, morphUV).xyz; + #endif + tempNormal += morphNormal; + #endif + return normalize(dNormalMatrix * tempNormal); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/normalDetailMap.js +var normalDetailMapPS = ` +#ifdef MAPTEXTURE +uniform float material_normalDetailMapBumpiness; +vec3 blendNormals(vec3 n1, vec3 n2) { + n1 += vec3(0, 0, 1); + n2 *= vec3(-1, -1, 1); + return n1 * dot(n1, n2) / n1.z - n2; +} +#endif +vec3 addNormalDetail(vec3 normalMap) { +#ifdef MAPTEXTURE + vec3 normalDetailMap = unpackNormal(texture2DBias($SAMPLER, $UV, textureBias)); + normalDetailMap = mix(vec3(0.0, 0.0, 1.0), normalDetailMap, material_normalDetailMapBumpiness); + return blendNormals(normalMap, normalDetailMap); +#else + return normalMap; +#endif +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/vert/normalInstanced.js +var normalInstancedVS = ` +vec3 getNormal() { + dNormalMatrix = mat3(instance_line1.xyz, instance_line2.xyz, instance_line3.xyz); + return normalize(dNormalMatrix * vertex_normal); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/normalMap.js +var normalMapPS = ` +#ifdef MAPTEXTURE +uniform float material_bumpiness; +#endif +void getNormal() { +#ifdef MAPTEXTURE + vec3 normalMap = unpackNormal(texture2DBias($SAMPLER, $UV, textureBias)); + normalMap = mix(vec3(0.0, 0.0, 1.0), normalMap, material_bumpiness); + dNormalW = normalize(dTBN * addNormalDetail(normalMap)); +#else + dNormalW = dVertexNormalW; +#endif +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/vert/normalSkinned.js +var normalSkinnedVS = ` +vec3 getNormal() { + dNormalMatrix = mat3(dModelMatrix[0].xyz, dModelMatrix[1].xyz, dModelMatrix[2].xyz); + return normalize(dNormalMatrix * vertex_normal); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/normalXY.js +var normalXYPS = ` +vec3 unpackNormal(vec4 nmap) { + vec3 normal; + normal.xy = nmap.wy * 2.0 - 1.0; + normal.z = sqrt(1.0 - saturate(dot(normal.xy, normal.xy))); + return normal; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/normalXYZ.js +var normalXYZPS = ` +vec3 unpackNormal(vec4 nmap) { + return nmap.xyz * 2.0 - 1.0; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/opacity.js +var opacityPS = ` +#ifdef MAPFLOAT +uniform float material_opacity; +#endif +void getOpacity() { + dAlpha = 1.0; + #ifdef MAPFLOAT + dAlpha *= material_opacity; + #endif + #ifdef MAPTEXTURE + dAlpha *= texture2DBias($SAMPLER, $UV, textureBias).$CH; + #endif + #ifdef MAPVERTEX + dAlpha *= clamp(vVertexColor.$VC, 0.0, 1.0); + #endif +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/opacity-dither.js +var opacityDitherPS = ` +uniform vec4 blueNoiseJitter; +#ifdef DITHER_BLUENOISE + uniform sampler2D blueNoiseTex32; +#endif +void opacityDither(float alpha, float id) { + #ifdef DITHER_BAYER8 + float noise = bayer8(floor(mod(gl_FragCoord.xy + blueNoiseJitter.xy + id, 8.0))) / 64.0; + #else + #ifdef DITHER_BLUENOISE + vec2 uv = fract(gl_FragCoord.xy / 32.0 + blueNoiseJitter.xy + id); + float noise = texture2DLodEXT(blueNoiseTex32, uv, 0.0).y; + #endif + #ifdef DITHER_IGNNOISE + vec3 magic = vec3(0.06711056, 0.00583715, 52.9829189); + float noise = fract(magic.z * fract(dot(gl_FragCoord.xy + blueNoiseJitter.xy + id, magic.xy))); + #endif + #endif + if (alpha < noise) + discard; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/output.js +var outputPS = ` +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/outputAlpha.js +var outputAlphaPS = ` +gl_FragColor.a = litArgs_opacity; +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/outputAlphaOpaque.js +var outputAlphaOpaquePS = ` + gl_FragColor.a = 1.0; +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/outputAlphaPremul.js +var outputAlphaPremulPS = ` +gl_FragColor.rgb *= litArgs_opacity; +gl_FragColor.a = litArgs_opacity; +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/outputTex2D.js +var outputTex2DPS = ` +varying vec2 vUv0; +uniform sampler2D source; +void main(void) { + gl_FragColor = texture2D(source, vUv0); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/packDepth.js +var packDepthPS = ` +vec4 packFloat(float depth) { + const vec4 bit_shift = vec4(256.0 * 256.0 * 256.0, 256.0 * 256.0, 256.0, 1.0); + const vec4 bit_mask = vec4(0.0, 1.0 / 256.0, 1.0 / 256.0, 1.0 / 256.0); + vec4 res = mod(depth * bit_shift * vec4(255), vec4(256) ) / vec4(255); + res -= res.xxyz * bit_mask; + return res; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/sheen.js +var sheenPS = ` +#ifdef MAPCOLOR +uniform vec3 material_sheen; +#endif +void getSheen() { + vec3 sheenColor = vec3(1, 1, 1); + #ifdef MAPCOLOR + sheenColor *= material_sheen; + #endif + #ifdef MAPTEXTURE + sheenColor *= $DECODE(texture2DBias($SAMPLER, $UV, textureBias)).$CH; + #endif + #ifdef MAPVERTEX + sheenColor *= saturate(vVertexColor.$VC); + #endif + sSpecularity = sheenColor; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/sheenGloss.js +var sheenGlossPS = ` +#ifdef MAPFLOAT +uniform float material_sheenGloss; +#endif +void getSheenGlossiness() { + float sheenGlossiness = 1.0; + #ifdef MAPFLOAT + sheenGlossiness *= material_sheenGloss; + #endif + #ifdef MAPTEXTURE + sheenGlossiness *= texture2DBias($SAMPLER, $UV, textureBias).$CH; + #endif + #ifdef MAPVERTEX + sheenGlossiness *= saturate(vVertexColor.$VC); + #endif + #ifdef MAPINVERT + sheenGlossiness = 1.0 - sheenGlossiness; + #endif + sheenGlossiness += 0.0000001; + sGlossiness = sheenGlossiness; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/parallax.js +var parallaxPS = ` +uniform float material_heightMapFactor; +void getParallax() { + float parallaxScale = material_heightMapFactor; + float height = texture2DBias($SAMPLER, $UV, textureBias).$CH; + height = height * parallaxScale - parallaxScale*0.5; + vec3 viewDirT = dViewDirW * dTBN; + viewDirT.z += 0.42; + dUvOffset = height * (viewDirT.xy / viewDirT.z); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particle.js +var particlePS = ` +varying vec4 texCoordsAlphaLife; +uniform sampler2D colorMap; +uniform sampler2D colorParam; +uniform float graphSampleSize; +uniform float graphNumSamples; +#ifndef CAMERAPLANES +#define CAMERAPLANES +uniform vec4 camera_params; +#endif +uniform float softening; +uniform float colorMult; +float saturate(float x) { + return clamp(x, 0.0, 1.0); +} +#ifndef UNPACKFLOAT +#define UNPACKFLOAT +float unpackFloat(vec4 rgbaDepth) { + const vec4 bitShift = vec4(1.0 / (256.0 * 256.0 * 256.0), 1.0 / (256.0 * 256.0), 1.0 / 256.0, 1.0); + float depth = dot(rgbaDepth, bitShift); + return depth; +} +#endif +void main(void) { + vec4 tex = gammaCorrectInput(texture2D(colorMap, vec2(texCoordsAlphaLife.x, 1.0 - texCoordsAlphaLife.y))); + vec4 ramp = gammaCorrectInput(texture2D(colorParam, vec2(texCoordsAlphaLife.w, 0.0))); + ramp.rgb *= colorMult; + ramp.a += texCoordsAlphaLife.z; + vec3 rgb = tex.rgb * ramp.rgb; + float a = tex.a * ramp.a; +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/vert/particle.js +var particleVS = ` +vec3 unpack3NFloats(float src) { + float r = fract(src); + float g = fract(src * 256.0); + float b = fract(src * 65536.0); + return vec3(r, g, b); +} +float saturate(float x) { + return clamp(x, 0.0, 1.0); +} +vec4 tex1Dlod_lerp(TEXTURE_ACCEPT_HIGHP(tex), vec2 tc) { + return mix( texture2D(tex,tc), texture2D(tex,tc + graphSampleSize), fract(tc.x*graphNumSamples) ); +} +vec4 tex1Dlod_lerp(TEXTURE_ACCEPT_HIGHP(tex), vec2 tc, out vec3 w) { + vec4 a = texture2D(tex,tc); + vec4 b = texture2D(tex,tc + graphSampleSize); + float c = fract(tc.x*graphNumSamples); + vec3 unpackedA = unpack3NFloats(a.w); + vec3 unpackedB = unpack3NFloats(b.w); + w = mix(unpackedA, unpackedB, c); + return mix(a, b, c); +} +vec2 rotate(vec2 quadXY, float pRotation, out mat2 rotMatrix) { + float c = cos(pRotation); + float s = sin(pRotation); + mat2 m = mat2(c, -s, s, c); + rotMatrix = m; + return m * quadXY; +} +vec3 billboard(vec3 InstanceCoords, vec2 quadXY) { + #ifdef SCREEN_SPACE + vec3 pos = vec3(-1, 0, 0) * quadXY.x + vec3(0, -1, 0) * quadXY.y; + #else + vec3 pos = -matrix_viewInverse[0].xyz * quadXY.x + -matrix_viewInverse[1].xyz * quadXY.y; + #endif + return pos; +} +vec3 customFace(vec3 InstanceCoords, vec2 quadXY) { + vec3 pos = faceTangent * quadXY.x + faceBinorm * quadXY.y; + return pos; +} +vec2 safeNormalize(vec2 v) { + float l = length(v); + return (l > 1e-06) ? v / l : v; +} +void main(void) { + vec3 meshLocalPos = particle_vertexData.xyz; + float id = floor(particle_vertexData.w); + float rndFactor = fract(sin(id + 1.0 + seed)); + vec3 rndFactor3 = vec3(rndFactor, fract(rndFactor*10.0), fract(rndFactor*100.0)); + float uv = id / numParticlesPot; + readInput(uv); +#ifdef LOCAL_SPACE + inVel = mat3(matrix_model) * inVel; +#endif + vec2 velocityV = safeNormalize((mat3(matrix_view) * inVel).xy); + float particleLifetime = lifetime; + if (inLife <= 0.0 || inLife > particleLifetime || !inShow) meshLocalPos = vec3(0.0); + vec2 quadXY = meshLocalPos.xy; + float nlife = clamp(inLife / particleLifetime, 0.0, 1.0); + vec3 paramDiv; + vec4 params = tex1Dlod_lerp(TEXTURE_PASS(internalTex2), vec2(nlife, 0), paramDiv); + float scale = params.y; + float scaleDiv = paramDiv.x; + float alphaDiv = paramDiv.z; + scale += (scaleDiv * 2.0 - 1.0) * scaleDivMult * fract(rndFactor*10000.0); +#ifndef USE_MESH + texCoordsAlphaLife = vec4(quadXY * -0.5 + 0.5, (alphaDiv * 2.0 - 1.0) * alphaDivMult * fract(rndFactor*1000.0), nlife); +#else + texCoordsAlphaLife = vec4(particle_uv, (alphaDiv * 2.0 - 1.0) * alphaDivMult * fract(rndFactor*1000.0), nlife); +#endif + vec3 particlePos = inPos; + vec3 particlePosMoved = vec3(0.0); + mat2 rotMatrix; +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/vert/particleAnimFrameClamp.js +var particleAnimFrameClampVS = ` + float animFrame = min(floor(texCoordsAlphaLife.w * animTexParams.y) + animTexParams.x, animTexParams.z); +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/vert/particleAnimFrameLoop.js +var particleAnimFrameLoopVS = ` + float animFrame = floor(mod(texCoordsAlphaLife.w * animTexParams.y + animTexParams.x, animTexParams.z + 1.0)); +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/vert/particleAnimTex.js +var particleAnimTexVS = ` + float animationIndex; + if (animTexIndexParams.y == 1.0) { + animationIndex = floor((animTexParams.w + 1.0) * rndFactor3.z) * (animTexParams.z + 1.0); + } else { + animationIndex = animTexIndexParams.x * (animTexParams.z + 1.0); + } + float atlasX = (animationIndex + animFrame) * animTexTilesParams.x; + float atlasY = 1.0 - floor(atlasX + 1.0) * animTexTilesParams.y; + atlasX = fract(atlasX); + texCoordsAlphaLife.xy *= animTexTilesParams.xy; + texCoordsAlphaLife.xy += vec2(atlasX, atlasY); +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particleInputFloat.js +var particleInputFloatPS = ` +void readInput(float uv) { + vec4 tex = texture2D(particleTexIN, vec2(uv, 0.25)); + vec4 tex2 = texture2D(particleTexIN, vec2(uv, 0.75)); + inPos = tex.xyz; + inVel = tex2.xyz; + inAngle = (tex.w < 0.0? -tex.w : tex.w) - 1000.0; + inShow = tex.w >= 0.0; + inLife = tex2.w; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particleInputRgba8.js +var particleInputRgba8PS = ` +#define PI2 6.283185307179586 +uniform vec3 inBoundsSize; +uniform vec3 inBoundsCenter; +uniform float maxVel; +float decodeFloatRG(vec2 rg) { + return rg.y*(1.0/255.0) + rg.x; +} +float decodeFloatRGBA( vec4 rgba ) { + return dot( rgba, vec4(1.0, 1.0/255.0, 1.0/65025.0, 1.0/160581375.0) ); +} +void readInput(float uv) { + vec4 tex0 = texture2D(particleTexIN, vec2(uv, 0.125)); + vec4 tex1 = texture2D(particleTexIN, vec2(uv, 0.375)); + vec4 tex2 = texture2D(particleTexIN, vec2(uv, 0.625)); + vec4 tex3 = texture2D(particleTexIN, vec2(uv, 0.875)); + inPos = vec3(decodeFloatRG(tex0.rg), decodeFloatRG(tex0.ba), decodeFloatRG(tex1.rg)); + inPos = (inPos - vec3(0.5)) * inBoundsSize + inBoundsCenter; + inVel = tex2.xyz; + inVel = (inVel - vec3(0.5)) * maxVel; + inAngle = decodeFloatRG(tex1.ba) * PI2; + inShow = tex2.a > 0.5; + inLife = decodeFloatRGBA(tex3); + float maxNegLife = max(lifetime, (numParticles - 1.0) * (rate+rateDiv)); + float maxPosLife = lifetime+1.0; + inLife = inLife * (maxNegLife + maxPosLife) - maxNegLife; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particleOutputFloat.js +var particleOutputFloatPS = ` +void writeOutput() { + if (gl_FragCoord.y<1.0) { + gl_FragColor = vec4(outPos, (outAngle + 1000.0) * visMode); + } else { + gl_FragColor = vec4(outVel, outLife); + } +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particleOutputRgba8.js +var particleOutputRgba8PS = ` +uniform vec3 outBoundsMul; +uniform vec3 outBoundsAdd; +vec2 encodeFloatRG( float v ) { + vec2 enc = vec2(1.0, 255.0) * v; + enc = fract(enc); + enc -= enc.yy * vec2(1.0/255.0, 1.0/255.0); + return enc; +} +vec4 encodeFloatRGBA( float v ) { + vec4 enc = vec4(1.0, 255.0, 65025.0, 160581375.0) * v; + enc = fract(enc); + enc -= enc.yzww * vec4(1.0/255.0,1.0/255.0,1.0/255.0,0.0); + return enc; +} +void writeOutput() { + outPos = outPos * outBoundsMul + outBoundsAdd; + outAngle = fract(outAngle / PI2); + outVel = (outVel / maxVel) + vec3(0.5); + float maxNegLife = max(lifetime, (numParticles - 1.0) * (rate+rateDiv)); + float maxPosLife = lifetime+1.0; + outLife = (outLife + maxNegLife) / (maxNegLife + maxPosLife); + if (gl_FragCoord.y < 1.0) { + gl_FragColor = vec4(encodeFloatRG(outPos.x), encodeFloatRG(outPos.y)); + } else if (gl_FragCoord.y < 2.0) { + gl_FragColor = vec4(encodeFloatRG(outPos.z), encodeFloatRG(outAngle)); + } else if (gl_FragCoord.y < 3.0) { + gl_FragColor = vec4(outVel, visMode*0.5+0.5); + } else { + gl_FragColor = encodeFloatRGBA(outLife); + } +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particleUpdaterAABB.js +var particleUpdaterAABBPS = ` +uniform mat3 spawnBounds; +uniform vec3 spawnPosInnerRatio; +vec3 calcSpawnPosition(vec3 inBounds, float rndFactor) { + vec3 pos = inBounds - vec3(0.5); + vec3 posAbs = abs(pos); + vec3 maxPos = vec3(max(posAbs.x, max(posAbs.y, posAbs.z))); + vec3 edge = maxPos + (vec3(0.5) - maxPos) * spawnPosInnerRatio; + pos.x = edge.x * (maxPos.x == posAbs.x ? sign(pos.x) : 2.0 * pos.x); + pos.y = edge.y * (maxPos.y == posAbs.y ? sign(pos.y) : 2.0 * pos.y); + pos.z = edge.z * (maxPos.z == posAbs.z ? sign(pos.z) : 2.0 * pos.z); +#ifndef LOCAL_SPACE + return emitterPos + spawnBounds * pos; +#else + return spawnBounds * pos; +#endif +} +void addInitialVelocity(inout vec3 localVelocity, vec3 inBounds) { + localVelocity -= vec3(0, 0, initialVelocity); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particleUpdaterEnd.js +var particleUpdaterEndPS = ` + writeOutput(); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particleUpdaterInit.js +var particleUpdaterInitPS = ` +varying vec2 vUv0; +uniform highp sampler2D particleTexIN; +uniform highp sampler2D internalTex0; +uniform highp sampler2D internalTex1; +uniform highp sampler2D internalTex2; +uniform highp sampler2D internalTex3; +uniform mat3 emitterMatrix; +uniform mat3 emitterMatrixInv; +uniform vec3 emitterScale; +uniform vec3 emitterPos; +uniform vec3 frameRandom; +uniform vec3 localVelocityDivMult; +uniform vec3 velocityDivMult; +uniform float delta; +uniform float rate; +uniform float rateDiv; +uniform float lifetime; +uniform float numParticles; +uniform float rotSpeedDivMult; +uniform float radialSpeedDivMult; +uniform float seed; +uniform float startAngle; +uniform float startAngle2; +uniform float initialVelocity; +uniform float graphSampleSize; +uniform float graphNumSamples; +vec3 inPos; +vec3 inVel; +float inAngle; +bool inShow; +float inLife; +float visMode; +vec3 outPos; +vec3 outVel; +float outAngle; +bool outShow; +float outLife; +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particleUpdaterNoRespawn.js +var particleUpdaterNoRespawnPS = ` + if (outLife >= lifetime) { + outLife -= max(lifetime, (numParticles - 1.0) * particleRate); + visMode = -1.0; + } +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particleUpdaterOnStop.js +var particleUpdaterOnStopPS = ` + visMode = outLife < 0.0? -1.0: visMode; +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particleUpdaterRespawn.js +var particleUpdaterRespawnPS = ` + if (outLife >= lifetime) { + outLife -= max(lifetime, (numParticles - 1.0) * particleRate); + visMode = 1.0; + } + visMode = outLife < 0.0? 1.0: visMode; +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particleUpdaterSphere.js +var particleUpdaterSpherePS = ` +uniform float spawnBoundsSphere; +uniform float spawnBoundsSphereInnerRatio; +vec3 calcSpawnPosition(vec3 inBounds, float rndFactor) { + float rnd4 = fract(rndFactor * 1000.0); + vec3 norm = normalize(inBounds.xyz - vec3(0.5)); + float r = rnd4 * (1.0 - spawnBoundsSphereInnerRatio) + spawnBoundsSphereInnerRatio; +#ifndef LOCAL_SPACE + return emitterPos + norm * r * spawnBoundsSphere; +#else + return norm * r * spawnBoundsSphere; +#endif +} +void addInitialVelocity(inout vec3 localVelocity, vec3 inBounds) { + localVelocity += normalize(inBounds - vec3(0.5)) * initialVelocity; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particleUpdaterStart.js +var particleUpdaterStartPS = ` +float saturate(float x) { + return clamp(x, 0.0, 1.0); +} +vec3 unpack3NFloats(float src) { + float r = fract(src); + float g = fract(src * 256.0); + float b = fract(src * 65536.0); + return vec3(r, g, b); +} +vec3 tex1Dlod_lerp(TEXTURE_ACCEPT_HIGHP(tex), vec2 tc, out vec3 w) { + vec4 a = texture2D(tex, tc); + vec4 b = texture2D(tex, tc + graphSampleSize); + float c = fract(tc.x * graphNumSamples); + vec3 unpackedA = unpack3NFloats(a.w); + vec3 unpackedB = unpack3NFloats(b.w); + w = mix(unpackedA, unpackedB, c); + return mix(a.xyz, b.xyz, c); +} +#define HASHSCALE4 vec4(1031, .1030, .0973, .1099) +vec4 hash41(float p) { + vec4 p4 = fract(vec4(p) * HASHSCALE4); + p4 += dot(p4, p4.wzxy+19.19); + return fract(vec4((p4.x + p4.y)*p4.z, (p4.x + p4.z)*p4.y, (p4.y + p4.z)*p4.w, (p4.z + p4.w)*p4.x)); +} +void main(void) { + if (gl_FragCoord.x > numParticles) discard; + readInput(vUv0.x); + visMode = inShow? 1.0 : -1.0; + vec4 rndFactor = hash41(gl_FragCoord.x + seed); + float particleRate = rate + rateDiv * rndFactor.x; + outLife = inLife + delta; + float nlife = clamp(outLife / lifetime, 0.0, 1.0); + vec3 localVelocityDiv; + vec3 velocityDiv; + vec3 paramDiv; + vec3 localVelocity = tex1Dlod_lerp(TEXTURE_PASS(internalTex0), vec2(nlife, 0), localVelocityDiv); + vec3 velocity = tex1Dlod_lerp(TEXTURE_PASS(internalTex1), vec2(nlife, 0), velocityDiv); + vec3 params = tex1Dlod_lerp(TEXTURE_PASS(internalTex2), vec2(nlife, 0), paramDiv); + float rotSpeed = params.x; + float rotSpeedDiv = paramDiv.y; + vec3 radialParams = tex1Dlod_lerp(TEXTURE_PASS(internalTex3), vec2(nlife, 0), paramDiv); + float radialSpeed = radialParams.x; + float radialSpeedDiv = radialParams.y; + bool respawn = inLife <= 0.0 || outLife >= lifetime; + inPos = respawn ? calcSpawnPosition(rndFactor.xyz, rndFactor.x) : inPos; + inAngle = respawn ? mix(startAngle, startAngle2, rndFactor.x) : inAngle; +#ifndef LOCAL_SPACE + vec3 radialVel = inPos - emitterPos; +#else + vec3 radialVel = inPos; +#endif + radialVel = (dot(radialVel, radialVel) > 1.0E-8) ? radialSpeed * normalize(radialVel) : vec3(0.0); + radialVel += (radialSpeedDiv * vec3(2.0) - vec3(1.0)) * radialSpeedDivMult * rndFactor.xyz; + localVelocity += (localVelocityDiv * vec3(2.0) - vec3(1.0)) * localVelocityDivMult * rndFactor.xyz; + velocity += (velocityDiv * vec3(2.0) - vec3(1.0)) * velocityDivMult * rndFactor.xyz; + rotSpeed += (rotSpeedDiv * 2.0 - 1.0) * rotSpeedDivMult * rndFactor.y; + addInitialVelocity(localVelocity, rndFactor.xyz); +#ifndef LOCAL_SPACE + outVel = emitterMatrix * localVelocity + (radialVel + velocity) * emitterScale; +#else + outVel = (localVelocity + radialVel) / emitterScale + emitterMatrixInv * velocity; +#endif + outPos = inPos + outVel * delta; + outAngle = inAngle + rotSpeed * delta; +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/vert/particle_billboard.js +var particle_billboardVS = ` + quadXY = rotate(quadXY, inAngle, rotMatrix); + vec3 localPos = billboard(particlePos, quadXY); +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particle_blendAdd.js +var particle_blendAddPS = ` + dBlendModeFogFactor = 0.0; + rgb *= saturate(gammaCorrectInput(max(a, 0.0))); + if ((rgb.r + rgb.g + rgb.b) < 0.000001) discard; +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particle_blendMultiply.js +var particle_blendMultiplyPS = ` + rgb = mix(vec3(1.0), rgb, vec3(a)); + if (rgb.r + rgb.g + rgb.b > 2.99) discard; +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particle_blendNormal.js +var particle_blendNormalPS = ` + if (a < 0.01) discard; +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/vert/particle_cpu.js +var particle_cpuVS = ` +attribute vec4 particle_vertexData; +attribute vec4 particle_vertexData2; +attribute vec4 particle_vertexData3; +attribute float particle_vertexData4; +#ifndef USE_MESH +attribute vec2 particle_vertexData5; +#else +attribute vec4 particle_vertexData5; +#endif +uniform mat4 matrix_viewProjection; +uniform mat4 matrix_model; +#ifndef VIEWMATRIX +#define VIEWMATRIX +uniform mat4 matrix_view; +#endif +uniform mat3 matrix_normal; +uniform mat4 matrix_viewInverse; +uniform float numParticles; +uniform float lifetime; +uniform float stretch; +uniform float seed; +uniform vec3 wrapBounds; +uniform vec3 emitterScale; +uniform vec3 faceTangent; +uniform vec3 faceBinorm; +#ifdef PARTICLE_GPU + uniform highp sampler2D internalTex0; + uniform highp sampler2D internalTex1; + uniform highp sampler2D internalTex2; +#endif +uniform vec3 emitterPos; +varying vec4 texCoordsAlphaLife; +vec2 rotate(vec2 quadXY, float pRotation, out mat2 rotMatrix) +{ + float c = cos(pRotation); + float s = sin(pRotation); + mat2 m = mat2(c, -s, s, c); + rotMatrix = m; + return m * quadXY; +} +vec3 billboard(vec3 InstanceCoords, vec2 quadXY) +{ + vec3 pos = -matrix_viewInverse[0].xyz * quadXY.x + -matrix_viewInverse[1].xyz * quadXY.y; + return pos; +} +vec3 customFace(vec3 InstanceCoords, vec2 quadXY) +{ + vec3 pos = faceTangent * quadXY.x + faceBinorm * quadXY.y; + return pos; +} +void main(void) +{ + vec3 particlePos = particle_vertexData.xyz; + vec3 inPos = particlePos; + vec3 vertPos = particle_vertexData3.xyz; + vec3 inVel = vec3(particle_vertexData2.w, particle_vertexData3.w, particle_vertexData5.x); + float id = floor(particle_vertexData4); + float rndFactor = fract(sin(id + 1.0 + seed)); + vec3 rndFactor3 = vec3(rndFactor, fract(rndFactor*10.0), fract(rndFactor*100.0)); +#ifdef LOCAL_SPACE + inVel = mat3(matrix_model) * inVel; +#endif + vec2 velocityV = normalize((mat3(matrix_view) * inVel).xy); + vec2 quadXY = vertPos.xy; +#ifdef USE_MESH + texCoordsAlphaLife = vec4(particle_vertexData5.zw, particle_vertexData2.z, particle_vertexData.w); +#else + texCoordsAlphaLife = vec4(quadXY * -0.5 + 0.5, particle_vertexData2.z, particle_vertexData.w); +#endif + mat2 rotMatrix; + float inAngle = particle_vertexData2.x; + vec3 particlePosMoved = vec3(0.0); + vec3 meshLocalPos = particle_vertexData3.xyz; +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/vert/particle_cpu_end.js +var particle_cpu_endVS = ` + localPos *= particle_vertexData2.y * emitterScale; + localPos += particlePos; + gl_Position = matrix_viewProjection * vec4(localPos, 1.0); +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/vert/particle_customFace.js +var particle_customFaceVS = ` + quadXY = rotate(quadXY, inAngle, rotMatrix); + vec3 localPos = customFace(particlePos, quadXY); +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particle_end.js +var particle_endPS = ` + rgb = addFog(rgb); + rgb = toneMap(rgb); + rgb = gammaCorrectOutput(rgb); + gl_FragColor = vec4(rgb, a); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/vert/particle_end.js +var particle_endVS = ` + localPos *= scale * emitterScale; + localPos += particlePos; + #ifdef SCREEN_SPACE + gl_Position = vec4(localPos.x, localPos.y, 0.0, 1.0); + #else + gl_Position = matrix_viewProjection * vec4(localPos.xyz, 1.0); + #endif +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particle_halflambert.js +var particle_halflambertPS = ` + vec3 negNormal = normal*0.5+0.5; + vec3 posNormal = -normal*0.5+0.5; + negNormal *= negNormal; + posNormal *= posNormal; +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/vert/particle_init.js +var particle_initVS = ` +attribute vec4 particle_vertexData; +#ifdef USE_MESH +attribute vec2 particle_uv; +#endif +uniform mat4 matrix_viewProjection; +uniform mat4 matrix_model; +uniform mat3 matrix_normal; +uniform mat4 matrix_viewInverse; +#ifndef VIEWMATRIX +#define VIEWMATRIX +uniform mat4 matrix_view; +#endif +uniform float numParticles; +uniform float numParticlesPot; +uniform float graphSampleSize; +uniform float graphNumSamples; +uniform float stretch; +uniform vec3 wrapBounds; +uniform vec3 emitterScale; +uniform vec3 emitterPos; +uniform vec3 faceTangent; +uniform vec3 faceBinorm; +uniform float rate; +uniform float rateDiv; +uniform float lifetime; +uniform float deltaRandomnessStatic; +uniform float scaleDivMult; +uniform float alphaDivMult; +uniform float seed; +uniform float delta; +uniform sampler2D particleTexOUT; +uniform sampler2D particleTexIN; +#ifdef PARTICLE_GPU + uniform highp sampler2D internalTex0; + uniform highp sampler2D internalTex1; + uniform highp sampler2D internalTex2; +#endif +#ifndef CAMERAPLANES +#define CAMERAPLANES +uniform vec4 camera_params; +#endif +varying vec4 texCoordsAlphaLife; +vec3 inPos; +vec3 inVel; +float inAngle; +bool inShow; +float inLife; +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particle_lambert.js +var particle_lambertPS = ` + vec3 negNormal = max(normal, vec3(0.0)); + vec3 posNormal = max(-normal, vec3(0.0)); +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particle_lighting.js +var particle_lightingPS = ` + vec3 light = negNormal.x*lightCube[0] + posNormal.x*lightCube[1] + + negNormal.y*lightCube[2] + posNormal.y*lightCube[3] + + negNormal.z*lightCube[4] + posNormal.z*lightCube[5]; + rgb *= light; +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/vert/particle_localShift.js +var particle_localShiftVS = ` + particlePos = (matrix_model * vec4(particlePos, 1.0)).xyz; +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/vert/particle_mesh.js +var particle_meshVS = ` + vec3 localPos = meshLocalPos; + localPos.xy = rotate(localPos.xy, inAngle, rotMatrix); + localPos.yz = rotate(localPos.yz, inAngle, rotMatrix); + billboard(particlePos, quadXY); +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/vert/particle_normal.js +var particle_normalVS = ` + Normal = normalize(localPos + matrix_viewInverse[2].xyz); +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particle_normalMap.js +var particle_normalMapPS = ` + vec3 normalMap = normalize(texture2D(normalMap, vec2(texCoordsAlphaLife.x, 1.0 - texCoordsAlphaLife.y)).xyz * 2.0 - 1.0); + vec3 normal = ParticleMat * normalMap; +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/vert/particle_pointAlong.js +var particle_pointAlongVS = ` + inAngle = atan(velocityV.x, velocityV.y); +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particle_soft.js +var particle_softPS = ` + float depth = getLinearScreenDepth(); + float particleDepth = vDepth; + float depthDiff = saturate(abs(particleDepth - depth) * softening); + a *= depthDiff; +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/vert/particle_soft.js +var particle_softVS = ` + vDepth = getLinearDepth(localPos); +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/vert/particle_stretch.js +var particle_stretchVS = ` + vec3 moveDir = inVel * stretch; + vec3 posPrev = particlePos - moveDir; + posPrev += particlePosMoved; + vec2 centerToVertexV = normalize((mat3(matrix_view) * localPos).xy); + float interpolation = dot(-velocityV, centerToVertexV) * 0.5 + 0.5; + particlePos = mix(particlePos, posPrev, interpolation); +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/vert/particle_TBN.js +var particle_TBNVS = ` + mat3 rot3 = mat3(rotMatrix[0][0], rotMatrix[0][1], 0.0, rotMatrix[1][0], rotMatrix[1][1], 0.0, 0.0, 0.0, 1.0); + ParticleMat = mat3(-matrix_viewInverse[0].xyz, -matrix_viewInverse[1].xyz, matrix_viewInverse[2].xyz) * rot3; +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/vert/particle_wrap.js +var particle_wrapVS = ` + vec3 origParticlePos = particlePos; + particlePos -= matrix_model[3].xyz; + particlePos = mod(particlePos, wrapBounds) - wrapBounds * 0.5; + particlePos += matrix_model[3].xyz; + particlePosMoved = particlePos - origParticlePos; +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/reflDir.js +var reflDirPS = ` +void getReflDir(vec3 worldNormal, vec3 viewDir, float gloss, mat3 tbn) { + dReflDirW = normalize(-reflect(viewDir, worldNormal)); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/reflDirAniso.js +var reflDirAnisoPS = ` +void getReflDir(vec3 worldNormal, vec3 viewDir, float gloss, mat3 tbn) { + float roughness = sqrt(1.0 - min(gloss, 1.0)); + float anisotropy = material_anisotropy * roughness; + vec3 anisotropicDirection = anisotropy >= 0.0 ? tbn[1] : tbn[0]; + vec3 anisotropicTangent = cross(anisotropicDirection, viewDir); + vec3 anisotropicNormal = cross(anisotropicTangent, anisotropicDirection); + vec3 bentNormal = normalize(mix(normalize(worldNormal), normalize(anisotropicNormal), anisotropy)); + dReflDirW = reflect(-viewDir, bentNormal); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/reflectionCC.js +var reflectionCCPS = ` +#ifdef LIT_CLEARCOAT +void addReflectionCC(vec3 reflDir, float gloss) { + ccReflection += calcReflection(reflDir, gloss); +} +#endif +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/reflectionCube.js +var reflectionCubePS = ` +uniform samplerCube texture_cubeMap; +uniform float material_reflectivity; +vec3 calcReflection(vec3 reflDir, float gloss) { + vec3 lookupVec = fixSeams(cubeMapProject(reflDir)); + lookupVec.x *= -1.0; + return $DECODE(textureCube(texture_cubeMap, lookupVec)); +} +void addReflection(vec3 reflDir, float gloss) { + dReflection += vec4(calcReflection(reflDir, gloss), material_reflectivity); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/reflectionEnvHQ.js +var reflectionEnvHQPS = ` +#ifndef ENV_ATLAS +#define ENV_ATLAS +uniform sampler2D texture_envAtlas; +#endif +uniform samplerCube texture_cubeMap; +uniform float material_reflectivity; +vec3 calcReflection(vec3 reflDir, float gloss) { + vec3 dir = cubeMapProject(reflDir) * vec3(-1.0, 1.0, 1.0); + vec2 uv = toSphericalUv(dir); + float level = saturate(1.0 - gloss) * 5.0; + float ilevel = floor(level); + float flevel = level - ilevel; + vec3 sharp = $DECODE_CUBEMAP(textureCube(texture_cubeMap, fixSeams(dir))); + vec3 roughA = $DECODE(texture2D(texture_envAtlas, mapRoughnessUv(uv, ilevel))); + vec3 roughB = $DECODE(texture2D(texture_envAtlas, mapRoughnessUv(uv, ilevel + 1.0))); + return processEnvironment(mix(sharp, mix(roughA, roughB, flevel), min(level, 1.0))); +} +void addReflection(vec3 reflDir, float gloss) { + dReflection += vec4(calcReflection(reflDir, gloss), material_reflectivity); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/reflectionEnv.js +var reflectionEnvPS = ` +#ifndef ENV_ATLAS +#define ENV_ATLAS +uniform sampler2D texture_envAtlas; +#endif +uniform float material_reflectivity; +float shinyMipLevel(vec2 uv) { + vec2 dx = dFdx(uv); + vec2 dy = dFdy(uv); + vec2 uv2 = vec2(fract(uv.x + 0.5), uv.y); + vec2 dx2 = dFdx(uv2); + vec2 dy2 = dFdy(uv2); + float maxd = min(max(dot(dx, dx), dot(dy, dy)), max(dot(dx2, dx2), dot(dy2, dy2))); + return clamp(0.5 * log2(maxd) - 1.0 + textureBias, 0.0, 5.0); +} +vec3 calcReflection(vec3 reflDir, float gloss) { + vec3 dir = cubeMapProject(reflDir) * vec3(-1.0, 1.0, 1.0); + vec2 uv = toSphericalUv(dir); + float level = saturate(1.0 - gloss) * 5.0; + float ilevel = floor(level); + float level2 = shinyMipLevel(uv * atlasSize); + float ilevel2 = floor(level2); + vec2 uv0, uv1; + float weight; + if (ilevel == 0.0) { + uv0 = mapShinyUv(uv, ilevel2); + uv1 = mapShinyUv(uv, ilevel2 + 1.0); + weight = level2 - ilevel2; + } else { + uv0 = uv1 = mapRoughnessUv(uv, ilevel); + weight = 0.0; + } + vec3 linearA = $DECODE(texture2D(texture_envAtlas, uv0)); + vec3 linearB = $DECODE(texture2D(texture_envAtlas, uv1)); + vec3 linear0 = mix(linearA, linearB, weight); + vec3 linear1 = $DECODE(texture2D(texture_envAtlas, mapRoughnessUv(uv, ilevel + 1.0))); + return processEnvironment(mix(linear0, linear1, level - ilevel)); +} +void addReflection(vec3 reflDir, float gloss) { + dReflection += vec4(calcReflection(reflDir, gloss), material_reflectivity); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/reflectionSphere.js +var reflectionSpherePS = ` +#ifndef VIEWMATRIX +#define VIEWMATRIX +uniform mat4 matrix_view; +#endif +uniform sampler2D texture_sphereMap; +uniform float material_reflectivity; +vec3 calcReflection(vec3 reflDir, float gloss) { + vec3 reflDirV = (mat3(matrix_view) * reflDir).xyz; + float m = 2.0 * sqrt( dot(reflDirV.xy, reflDirV.xy) + (reflDirV.z+1.0)*(reflDirV.z+1.0) ); + vec2 sphereMapUv = reflDirV.xy / m + 0.5; + return $DECODE(texture2D(texture_sphereMap, sphereMapUv)); +} +void addReflection(vec3 reflDir, float gloss) { + dReflection += vec4(calcReflection(reflDir, gloss), material_reflectivity); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/reflectionSheen.js +var reflectionSheenPS = ` +void addReflectionSheen(vec3 worldNormal, vec3 viewDir, float gloss) { + float NoV = dot(worldNormal, viewDir); + float alphaG = gloss * gloss; + float a = gloss < 0.25 ? -339.2 * alphaG + 161.4 * gloss - 25.9 : -8.48 * alphaG + 14.3 * gloss - 9.95; + float b = gloss < 0.25 ? 44.0 * alphaG - 23.7 * gloss + 3.26 : 1.97 * alphaG - 3.27 * gloss + 0.72; + float DG = exp( a * NoV + b ) + ( gloss < 0.25 ? 0.0 : 0.1 * ( gloss - 0.25 ) ); + sReflection += calcReflection(worldNormal, 0.0) * saturate(DG); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/refractionCube.js +var refractionCubePS = ` +vec3 refract2(vec3 viewVec, vec3 normal, float IOR) { + float vn = dot(viewVec, normal); + float k = 1.0 - IOR * IOR * (1.0 - vn * vn); + vec3 refrVec = IOR * viewVec - (IOR * vn + sqrt(k)) * normal; + return refrVec; +} +void addRefraction( + vec3 worldNormal, + vec3 viewDir, + float thickness, + float gloss, + vec3 specularity, + vec3 albedo, + float transmission, + float refractionIndex, + float dispersion +#if defined(LIT_IRIDESCENCE) + , vec3 iridescenceFresnel, + float iridescenceIntensity +#endif +) { + vec4 tmpRefl = dReflection; + vec3 reflectionDir = refract2(-viewDir, worldNormal, refractionIndex); + dReflection = vec4(0); + addReflection(reflectionDir, gloss); + dDiffuseLight = mix(dDiffuseLight, dReflection.rgb * albedo, transmission); + dReflection = tmpRefl; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/refractionDynamic.js +var refractionDynamicPS = ` +uniform float material_invAttenuationDistance; +uniform vec3 material_attenuation; +vec3 evalRefractionColor(vec3 refractionVector, float gloss, float refractionIndex) { + vec4 pointOfRefraction = vec4(vPositionW + refractionVector, 1.0); + vec4 projectionPoint = matrix_viewProjection * pointOfRefraction; + vec2 uv = getGrabScreenPos(projectionPoint); + #ifdef SUPPORTS_TEXLOD + float iorToRoughness = (1.0 - gloss) * clamp((1.0 / refractionIndex) * 2.0 - 2.0, 0.0, 1.0); + float refractionLod = log2(uScreenSize.x) * iorToRoughness; + vec3 refraction = texture2DLodEXT(uSceneColorMap, uv, refractionLod).rgb; + #else + vec3 refraction = texture2D(uSceneColorMap, uv).rgb; + #endif + return refraction; +} +void addRefraction( + vec3 worldNormal, + vec3 viewDir, + float thickness, + float gloss, + vec3 specularity, + vec3 albedo, + float transmission, + float refractionIndex, + float dispersion +#if defined(LIT_IRIDESCENCE) + , vec3 iridescenceFresnel, + float iridescenceIntensity +#endif +) { + vec3 modelScale; + modelScale.x = length(vec3(matrix_model[0].xyz)); + modelScale.y = length(vec3(matrix_model[1].xyz)); + modelScale.z = length(vec3(matrix_model[2].xyz)); + vec3 scale = thickness * modelScale; + vec3 refractionVector = normalize(refract(-viewDir, worldNormal, refractionIndex)) * scale; + vec3 refraction = evalRefractionColor(refractionVector, gloss, refractionIndex); + #ifdef DISPERSION + float halfSpread = (1.0 / refractionIndex - 1.0) * 0.025 * dispersion; + float refractionIndexR = refractionIndex - halfSpread; + refractionVector = normalize(refract(-viewDir, worldNormal, refractionIndexR)) * scale; + refraction.r = evalRefractionColor(refractionVector, gloss, refractionIndexR).r; + float refractionIndexB = refractionIndex + halfSpread; + refractionVector = normalize(refract(-viewDir, worldNormal, refractionIndexB)) * scale; + refraction.b = evalRefractionColor(refractionVector, gloss, refractionIndexB).b; + #endif + vec3 transmittance; + if (material_invAttenuationDistance != 0.0) + { + vec3 attenuation = -log(material_attenuation) * material_invAttenuationDistance; + transmittance = exp(-attenuation * length(refractionVector)); + } + else + { + transmittance = refraction; + } + vec3 fresnel = vec3(1.0) - + getFresnel( + dot(viewDir, worldNormal), + gloss, + specularity + #if defined(LIT_IRIDESCENCE) + , iridescenceFresnel, + iridescenceIntensity + #endif + ); + dDiffuseLight = mix(dDiffuseLight, refraction * transmittance * fresnel, transmission); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/reproject.js +var reprojectPS = ` +varying vec2 vUv0; +#ifdef CUBEMAP_SOURCE + uniform samplerCube sourceCube; +#else + uniform sampler2D sourceTex; +#endif +#ifdef USE_SAMPLES_TEX + uniform sampler2D samplesTex; + uniform vec2 samplesTexInverseSize; +#endif +uniform vec3 params; +float targetFace() { return params.x; } +float sourceCubeSeamScale() { return params.y; } +float targetCubeSeamScale() { return params.z; } +float PI = 3.141592653589793; +float saturate(float x) { + return clamp(x, 0.0, 1.0); +} +${decodePS} +${encodePS} +vec3 modifySeams(vec3 dir, float scale) { + vec3 adir = abs(dir); + float M = max(max(adir.x, adir.y), adir.z); + return dir / M * vec3( + adir.x == M ? 1.0 : scale, + adir.y == M ? 1.0 : scale, + adir.z == M ? 1.0 : scale + ); +} +vec2 toSpherical(vec3 dir) { + return vec2(dir.xz == vec2(0.0) ? 0.0 : atan(dir.x, dir.z), asin(dir.y)); +} +vec3 fromSpherical(vec2 uv) { + return vec3(cos(uv.y) * sin(uv.x), + sin(uv.y), + cos(uv.y) * cos(uv.x)); +} +vec3 getDirectionEquirect() { + return fromSpherical((vec2(vUv0.x, 1.0 - vUv0.y) * 2.0 - 1.0) * vec2(PI, PI * 0.5)); +} +float signNotZero(float k){ + return(k >= 0.0) ? 1.0 : -1.0; +} +vec2 signNotZero(vec2 v) { + return vec2(signNotZero(v.x), signNotZero(v.y)); +} +vec3 octDecode(vec2 o) { + vec3 v = vec3(o.x, 1.0 - abs(o.x) - abs(o.y), o.y); + if (v.y < 0.0) { + v.xz = (1.0 - abs(v.zx)) * signNotZero(v.xz); + } + return normalize(v); +} +vec3 getDirectionOctahedral() { + return octDecode(vec2(vUv0.x, 1.0 - vUv0.y) * 2.0 - 1.0); +} +vec2 octEncode(in vec3 v) { + float l1norm = abs(v.x) + abs(v.y) + abs(v.z); + vec2 result = v.xz * (1.0 / l1norm); + if (v.y < 0.0) { + result = (1.0 - abs(result.yx)) * signNotZero(result.xy); + } + return result; +} +#ifdef CUBEMAP_SOURCE + vec4 sampleCubemap(vec3 dir) { + return textureCube(sourceCube, modifySeams(dir, 1.0 - sourceCubeSeamScale())); + } + vec4 sampleCubemap(vec2 sph) { + return sampleCubemap(fromSpherical(sph)); +} + vec4 sampleCubemap(vec3 dir, float mipLevel) { + return textureCubeLodEXT(sourceCube, modifySeams(dir, 1.0 - exp2(mipLevel) * sourceCubeSeamScale()), mipLevel); + } + vec4 sampleCubemap(vec2 sph, float mipLevel) { + return sampleCubemap(fromSpherical(sph), mipLevel); + } +#else + vec4 sampleEquirect(vec2 sph) { + vec2 uv = sph / vec2(PI * 2.0, PI) + 0.5; + return texture2D(sourceTex, vec2(uv.x, 1.0 - uv.y)); + } + vec4 sampleEquirect(vec3 dir) { + return sampleEquirect(toSpherical(dir)); + } + vec4 sampleEquirect(vec2 sph, float mipLevel) { + vec2 uv = sph / vec2(PI * 2.0, PI) + 0.5; + return texture2DLodEXT(sourceTex, vec2(uv.x, 1.0 - uv.y), mipLevel); + } + vec4 sampleEquirect(vec3 dir, float mipLevel) { + return sampleEquirect(toSpherical(dir), mipLevel); + } + vec4 sampleOctahedral(vec3 dir) { + vec2 uv = octEncode(dir) * 0.5 + 0.5; + return texture2D(sourceTex, vec2(uv.x, 1.0 - uv.y)); + } + vec4 sampleOctahedral(vec2 sph) { + return sampleOctahedral(fromSpherical(sph)); + } + vec4 sampleOctahedral(vec3 dir, float mipLevel) { + vec2 uv = octEncode(dir) * 0.5 + 0.5; + return texture2DLodEXT(sourceTex, vec2(uv.x, 1.0 - uv.y), mipLevel); + } + vec4 sampleOctahedral(vec2 sph, float mipLevel) { + return sampleOctahedral(fromSpherical(sph), mipLevel); + } +#endif +vec3 getDirectionCubemap() { + vec2 st = vUv0 * 2.0 - 1.0; + float face = targetFace(); + vec3 vec; + if (face == 0.0) { + vec = vec3(1, -st.y, -st.x); + } else if (face == 1.0) { + vec = vec3(-1, -st.y, st.x); + } else if (face == 2.0) { + vec = vec3(st.x, 1, st.y); + } else if (face == 3.0) { + vec = vec3(st.x, -1, -st.y); + } else if (face == 4.0) { + vec = vec3(st.x, -st.y, 1); + } else { + vec = vec3(-st.x, -st.y, -1); + } + return normalize(modifySeams(vec, 1.0 / (1.0 - targetCubeSeamScale()))); +} +mat3 matrixFromVector(vec3 n) { + float a = 1.0 / (1.0 + n.z); + float b = -n.x * n.y * a; + vec3 b1 = vec3(1.0 - n.x * n.x * a, b, -n.x); + vec3 b2 = vec3(b, 1.0 - n.y * n.y * a, -n.y); + return mat3(b1, b2, n); +} +mat3 matrixFromVectorSlow(vec3 n) { + vec3 up = (1.0 - abs(n.y) <= 0.0000001) ? vec3(0.0, 0.0, n.y > 0.0 ? 1.0 : -1.0) : vec3(0.0, 1.0, 0.0); + vec3 x = normalize(cross(up, n)); + vec3 y = cross(n, x); + return mat3(x, y, n); +} +vec4 reproject() { + if (NUM_SAMPLES <= 1) { + return ENCODE_FUNC(DECODE_FUNC(SOURCE_FUNC(TARGET_FUNC()))); + } else { + vec3 t = TARGET_FUNC(); + vec3 tu = dFdx(t); + vec3 tv = dFdy(t); + vec3 result = vec3(0.0); + for (float u = 0.0; u < NUM_SAMPLES_SQRT; ++u) { + for (float v = 0.0; v < NUM_SAMPLES_SQRT; ++v) { + result += DECODE_FUNC(SOURCE_FUNC(normalize(t + + tu * (u / NUM_SAMPLES_SQRT - 0.5) + + tv * (v / NUM_SAMPLES_SQRT - 0.5)))); + } + } + return ENCODE_FUNC(result / (NUM_SAMPLES_SQRT * NUM_SAMPLES_SQRT)); + } +} +vec4 unpackFloat = vec4(1.0, 1.0 / 255.0, 1.0 / 65025.0, 1.0 / 16581375.0); +#ifdef USE_SAMPLES_TEX + void unpackSample(int i, out vec3 L, out float mipLevel) { + float u = (float(i * 4) + 0.5) * samplesTexInverseSize.x; + float v = (floor(u) + 0.5) * samplesTexInverseSize.y; + vec4 raw; + raw.x = dot(texture2D(samplesTex, vec2(u, v)), unpackFloat); u += samplesTexInverseSize.x; + raw.y = dot(texture2D(samplesTex, vec2(u, v)), unpackFloat); u += samplesTexInverseSize.x; + raw.z = dot(texture2D(samplesTex, vec2(u, v)), unpackFloat); u += samplesTexInverseSize.x; + raw.w = dot(texture2D(samplesTex, vec2(u, v)), unpackFloat); + L.xyz = raw.xyz * 2.0 - 1.0; + mipLevel = raw.w * 8.0; + } + vec4 prefilterSamples() { + mat3 vecSpace = matrixFromVectorSlow(TARGET_FUNC()); + vec3 L; + float mipLevel; + vec3 result = vec3(0.0); + float totalWeight = 0.0; + for (int i = 0; i < NUM_SAMPLES; ++i) { + unpackSample(i, L, mipLevel); + result += DECODE_FUNC(SOURCE_FUNC(vecSpace * L, mipLevel)) * L.z; + totalWeight += L.z; + } + return ENCODE_FUNC(result / totalWeight); + } + vec4 prefilterSamplesUnweighted() { + mat3 vecSpace = matrixFromVectorSlow(TARGET_FUNC()); + vec3 L; + float mipLevel; + vec3 result = vec3(0.0); + float totalWeight = 0.0; + for (int i = 0; i < NUM_SAMPLES; ++i) { + unpackSample(i, L, mipLevel); + result += DECODE_FUNC(SOURCE_FUNC(vecSpace * L, mipLevel)); + } + return ENCODE_FUNC(result / float(NUM_SAMPLES)); + } +#endif +void main(void) { + gl_FragColor = PROCESS_FUNC(); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/sampleCatmullRom.js +var sampleCatmullRomPS = ` +vec4 SampleTextureCatmullRom(TEXTURE_ACCEPT(tex), vec2 uv, vec2 texSize) { + vec2 samplePos = uv * texSize; + vec2 texPos1 = floor(samplePos - 0.5) + 0.5; + vec2 f = samplePos - texPos1; + vec2 w0 = f * (-0.5 + f * (1.0 - 0.5 * f)); + vec2 w1 = 1.0 + f * f * (-2.5 + 1.5 * f); + vec2 w2 = f * (0.5 + f * (2.0 - 1.5 * f)); + vec2 w3 = f * f * (-0.5 + 0.5 * f); + vec2 w12 = w1 + w2; + vec2 offset12 = w2 / (w1 + w2); + vec2 texPos0 = (texPos1 - 1.0) / texSize; + vec2 texPos3 = (texPos1 + 2.0) / texSize; + vec2 texPos12 = (texPos1 + offset12) / texSize; + vec4 result = vec4(0.0); + result += texture2DLodEXT(tex, vec2(texPos0.x, texPos0.y), 0.0) * w0.x * w0.y; + result += texture2DLodEXT(tex, vec2(texPos12.x, texPos0.y), 0.0) * w12.x * w0.y; + result += texture2DLodEXT(tex, vec2(texPos3.x, texPos0.y), 0.0) * w3.x * w0.y; + result += texture2DLodEXT(tex, vec2(texPos0.x, texPos12.y), 0.0) * w0.x * w12.y; + result += texture2DLodEXT(tex, vec2(texPos12.x, texPos12.y), 0.0) * w12.x * w12.y; + result += texture2DLodEXT(tex, vec2(texPos3.x, texPos12.y), 0.0) * w3.x * w12.y; + result += texture2DLodEXT(tex, vec2(texPos0.x, texPos3.y), 0.0) * w0.x * w3.y; + result += texture2DLodEXT(tex, vec2(texPos12.x, texPos3.y), 0.0) * w12.x * w3.y; + result += texture2DLodEXT(tex, vec2(texPos3.x, texPos3.y), 0.0) * w3.x * w3.y; + return result; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/screenDepth.js +var screenDepthPS = ` +uniform highp sampler2D uSceneDepthMap; +#ifndef SCREENSIZE +#define SCREENSIZE +uniform vec4 uScreenSize; +#endif +#ifndef VIEWMATRIX +#define VIEWMATRIX +uniform mat4 matrix_view; +#endif +#ifndef LINEARIZE_DEPTH +#ifndef CAMERAPLANES +#define CAMERAPLANES +uniform vec4 camera_params; +#endif +#define LINEARIZE_DEPTH +#ifdef GL2 +float linearizeDepth(float z) { + if (camera_params.w == 0.0) + return (camera_params.z * camera_params.y) / (camera_params.y + z * (camera_params.z - camera_params.y)); + else + return camera_params.z + z * (camera_params.y - camera_params.z); +} +#else +#ifndef UNPACKFLOAT +#define UNPACKFLOAT +float unpackFloat(vec4 rgbaDepth) { + const vec4 bitShift = vec4(1.0 / (256.0 * 256.0 * 256.0), 1.0 / (256.0 * 256.0), 1.0 / 256.0, 1.0); + return dot(rgbaDepth, bitShift); +} +#endif +#endif +#endif +float getLinearScreenDepth(vec2 uv) { + #ifdef GL2 + return linearizeDepth(texture2D(uSceneDepthMap, uv).r); + #else + return unpackFloat(texture2D(uSceneDepthMap, uv)) * camera_params.y; + #endif +} +#ifndef VERTEXSHADER +float getLinearScreenDepth() { + vec2 uv = gl_FragCoord.xy * uScreenSize.zw; + return getLinearScreenDepth(uv); +} +#endif +float getLinearDepth(vec3 pos) { + return -(matrix_view * vec4(pos, 1.0)).z; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/shadowCascades.js +var shadowCascadesPS = ` +const float maxCascades = 4.0; +mat4 cascadeShadowMat; +void getShadowCascadeMatrix(mat4 shadowMatrixPalette[4], float shadowCascadeDistances[4], float shadowCascadeCount) { + float depth = 1.0 / gl_FragCoord.w; + float cascadeIndex = 0.0; + for (float i = 0.0; i < maxCascades; i++) { + if (depth < shadowCascadeDistances[int(i)]) { + cascadeIndex = i; + break; + } + } + cascadeIndex = min(cascadeIndex, shadowCascadeCount - 1.0); + #ifdef GL2 + cascadeShadowMat = shadowMatrixPalette[int(cascadeIndex)]; + #else + if (cascadeIndex == 0.0) { + cascadeShadowMat = shadowMatrixPalette[0]; + } + else if (cascadeIndex == 1.0) { + cascadeShadowMat = shadowMatrixPalette[1]; + } + else if (cascadeIndex == 2.0) { + cascadeShadowMat = shadowMatrixPalette[2]; + } + else { + cascadeShadowMat = shadowMatrixPalette[3]; + } + #endif +} +void fadeShadow(float shadowCascadeDistances[4]) { + float depth = 1.0 / gl_FragCoord.w; + if (depth > shadowCascadeDistances[int(maxCascades - 1.0)]) { + dShadowCoord.z = -9999999.0; + } +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/shadowEVSM.js +var shadowEVSMPS = ` +float VSM$(TEXTURE_ACCEPT(tex), vec2 texCoords, float resolution, float Z, float vsmBias, float exponent) { + vec3 moments = texture2D(tex, texCoords).xyz; + return calculateEVSM(moments, Z, vsmBias, exponent); +} +float getShadowVSM$(TEXTURE_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams, float exponent, vec3 lightDir) { + return VSM$(TEXTURE_PASS(shadowMap), shadowCoord.xy, shadowParams.x, shadowCoord.z, shadowParams.y, exponent); +} +float getShadowSpotVSM$(TEXTURE_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams, float exponent, vec3 lightDir) { + return VSM$(TEXTURE_PASS(shadowMap), shadowCoord.xy, shadowParams.x, length(lightDir) * shadowParams.w + shadowParams.z, shadowParams.y, exponent); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/shadowEVSMn.js +var shadowEVSMnPS = ` +float VSM$(TEXTURE_ACCEPT(tex), vec2 texCoords, float resolution, float Z, float vsmBias, float exponent) { + float pixelSize = 1.0 / resolution; + texCoords -= vec2(pixelSize); + vec3 s00 = texture2D(tex, texCoords).xyz; + vec3 s10 = texture2D(tex, texCoords + vec2(pixelSize, 0)).xyz; + vec3 s01 = texture2D(tex, texCoords + vec2(0, pixelSize)).xyz; + vec3 s11 = texture2D(tex, texCoords + vec2(pixelSize)).xyz; + vec2 fr = fract(texCoords * resolution); + vec3 h0 = mix(s00, s10, fr.x); + vec3 h1 = mix(s01, s11, fr.x); + vec3 moments = mix(h0, h1, fr.y); + return calculateEVSM(moments, Z, vsmBias, exponent); +} +float getShadowVSM$(TEXTURE_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams, float exponent, vec3 lightDir) { + return VSM$(TEXTURE_PASS(shadowMap), shadowCoord.xy, shadowParams.x, shadowCoord.z, shadowParams.y, exponent); +} +float getShadowSpotVSM$(TEXTURE_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams, float exponent, vec3 lightDir) { + return VSM$(TEXTURE_PASS(shadowMap), shadowCoord.xy, shadowParams.x, length(lightDir) * shadowParams.w + shadowParams.z, shadowParams.y, exponent); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/shadowPCSS.js +var shadowPCSSPS = ` +#define PCSS_SAMPLE_COUNT 16 +uniform float pcssDiskSamples[PCSS_SAMPLE_COUNT]; +uniform float pcssSphereSamples[PCSS_SAMPLE_COUNT]; +vec2 vogelDisk(int sampleIndex, float count, float phi, float r) { + const float GoldenAngle = 2.4; + float theta = float(sampleIndex) * GoldenAngle + phi; + float sine = sin(theta); + float cosine = cos(theta); + return vec2(r * cosine, r * sine); +} +vec3 vogelSphere(int sampleIndex, float count, float phi, float r) { + const float GoldenAngle = 2.4; + float theta = float(sampleIndex) * GoldenAngle + phi; + float weight = float(sampleIndex) / count; + return vec3(cos(theta) * r, weight, sin(theta) * r); +} +float noise(vec2 screenPos) { + const float PHI = 1.61803398874989484820459; + return fract(sin(dot(screenPos * PHI, screenPos)) * screenPos.x); +} +#ifndef UNPACKFLOAT +#define UNPACKFLOAT +float unpackFloat(vec4 rgbaDepth) { + const vec4 bitShift = vec4(1.0 / (256.0 * 256.0 * 256.0), 1.0 / (256.0 * 256.0), 1.0 / 256.0, 1.0); + return dot(rgbaDepth, bitShift); +} +#endif +float viewSpaceDepth(float depth, mat4 invProjection) { + float z = depth * 2.0 - 1.0; + vec4 clipSpace = vec4(0.0, 0.0, z, 1.0); + vec4 viewSpace = invProjection * clipSpace; + return viewSpace.z; +} +float PCSSBlockerDistance(TEXTURE_ACCEPT(shadowMap), vec2 sampleCoords[PCSS_SAMPLE_COUNT], vec2 shadowCoords, vec2 searchSize, float z) { + float blockers = 0.0; + float averageBlocker = 0.0; + for (int i = 0; i < PCSS_SAMPLE_COUNT; i++) { + vec2 offset = sampleCoords[i] * searchSize; + vec2 sampleUV = shadowCoords + offset; + #ifdef GL2 + float blocker = textureLod(shadowMap, sampleUV, 0.0).r; + #else + float blocker = unpackFloat(texture2D(shadowMap, sampleUV)); + #endif + float isBlocking = step(blocker, z); + blockers += isBlocking; + averageBlocker += blocker * isBlocking; + } + if (blockers > 0.0) + return averageBlocker /= blockers; + return -1.0; +} +float PCSS(TEXTURE_ACCEPT(shadowMap), vec3 shadowCoords, vec4 cameraParams, vec2 shadowSearchArea) { + float receiverDepth = shadowCoords.z; +#ifndef GL2 + receiverDepth *= 1.0 / (cameraParams.y - cameraParams.z); +#endif + vec2 samplePoints[PCSS_SAMPLE_COUNT]; + float noise = noise( gl_FragCoord.xy ) * 2.0 * PI; + for (int i = 0; i < PCSS_SAMPLE_COUNT; i++) { + float pcssPresample = pcssDiskSamples[i]; + samplePoints[i] = vogelDisk(i, float(PCSS_SAMPLE_COUNT), noise, pcssPresample); + } + float averageBlocker = PCSSBlockerDistance(TEXTURE_PASS(shadowMap), samplePoints, shadowCoords.xy, shadowSearchArea, receiverDepth); + if (averageBlocker == -1.0) { + return 1.0; + } else { + vec2 filterRadius = ((receiverDepth - averageBlocker) / averageBlocker) * shadowSearchArea * cameraParams.x; + float shadow = 0.0; + for (int i = 0; i < PCSS_SAMPLE_COUNT; i ++) + { + vec2 sampleUV = samplePoints[i] * filterRadius; + sampleUV = shadowCoords.xy + sampleUV; + #ifdef GL2 + float depth = textureLod(shadowMap, sampleUV, 0.0).r; + #else + float depth = unpackFloat(texture2D(shadowMap, sampleUV)); + #endif + shadow += step(receiverDepth, depth); + } + return shadow / float(PCSS_SAMPLE_COUNT); + } +} +float PCSSCubeBlockerDistance(samplerCube shadowMap, vec3 lightDirNorm, vec3 samplePoints[PCSS_SAMPLE_COUNT], float z, float shadowSearchArea) { + float blockers = 0.0; + float averageBlocker = 0.0; + for (int i = 0; i < PCSS_SAMPLE_COUNT; i++) { + vec3 sampleDir = lightDirNorm + samplePoints[i] * shadowSearchArea; + sampleDir = normalize(sampleDir); + #ifdef GL2 + float blocker = textureCubeLodEXT(shadowMap, sampleDir, 0.0).r; + #else + float blocker = unpackFloat(textureCube(shadowMap, sampleDir)); + #endif + float isBlocking = step(blocker, z); + blockers += isBlocking; + averageBlocker += blocker * isBlocking; + } + if (blockers > 0.0) + return averageBlocker /= float(blockers); + return -1.0; +} +float PCSSCube(samplerCube shadowMap, vec4 shadowParams, vec3 shadowCoords, vec4 cameraParams, float shadowSearchArea, vec3 lightDir) { + + vec3 samplePoints[PCSS_SAMPLE_COUNT]; + float noise = noise( gl_FragCoord.xy ) * 2.0 * PI; + for (int i = 0; i < PCSS_SAMPLE_COUNT; i++) { + float r = pcssSphereSamples[i]; + samplePoints[i] = vogelSphere(i, float(PCSS_SAMPLE_COUNT), noise, r); + } + float receiverDepth = length(lightDir) * shadowParams.w + shadowParams.z; + vec3 lightDirNorm = normalize(lightDir); + + float averageBlocker = PCSSCubeBlockerDistance(shadowMap, lightDirNorm, samplePoints, receiverDepth, shadowSearchArea); + if (averageBlocker == -1.0) { + return 1.0; + } else { + float filterRadius = ((receiverDepth - averageBlocker) / averageBlocker) * shadowSearchArea; + float shadow = 0.0; + for (int i = 0; i < PCSS_SAMPLE_COUNT; i++) + { + vec3 offset = samplePoints[i] * filterRadius; + vec3 sampleDir = lightDirNorm + offset; + sampleDir = normalize(sampleDir); + #ifdef GL2 + float depth = textureCubeLodEXT(shadowMap, sampleDir, 0.0).r; + #else + float depth = unpackFloat(textureCube(shadowMap, sampleDir)); + #endif + shadow += step(receiverDepth, depth); + } + return shadow / float(PCSS_SAMPLE_COUNT); + } +} +float getShadowPointPCSS(samplerCube shadowMap, vec3 shadowCoord, vec4 shadowParams, vec4 cameraParams, vec2 shadowSearchArea, vec3 lightDir) { + return PCSSCube(shadowMap, shadowParams, shadowCoord, cameraParams, shadowSearchArea.x, lightDir); +} +float getShadowSpotPCSS(TEXTURE_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams, vec4 cameraParams, vec2 shadowSearchArea, vec3 lightDir) { + return PCSS(TEXTURE_PASS(shadowMap), shadowCoord, cameraParams, shadowSearchArea); +} +float getShadowPCSS(TEXTURE_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams, vec4 cameraParams, vec2 shadowSearchArea, vec3 lightDir) { + return PCSS(TEXTURE_PASS(shadowMap), shadowCoord, cameraParams, shadowSearchArea); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/shadowSampleCoord.js +var shadowSampleCoordPS = ` +vec3 getShadowSampleCoord$LIGHT(mat4 shadowTransform, vec4 shadowParams, vec3 worldPosition, vec3 lightPos, inout vec3 lightDir, vec3 lightDirNorm, vec3 normal) { + vec3 surfacePosition = worldPosition; +#ifdef SHADOW_SAMPLE_POINT + #ifdef SHADOW_SAMPLE_NORMAL_OFFSET + float distScale = length(lightDir); + surfacePosition = worldPosition + normal * shadowParams.y * clamp(1.0 - dot(normal, -lightDirNorm), 0.0, 1.0) * distScale; + lightDir = surfacePosition - lightPos; + return lightDir; + #endif +#else + #ifdef SHADOW_SAMPLE_SOURCE_ZBUFFER + #ifdef SHADOW_SAMPLE_NORMAL_OFFSET + surfacePosition = worldPosition + normal * shadowParams.y; + #endif + #else + #ifdef SHADOW_SAMPLE_NORMAL_OFFSET + #ifdef SHADOW_SAMPLE_ORTHO + float distScale = 1.0; + #else + float distScale = abs(dot(vPositionW - lightPos, lightDirNorm)); + #endif + surfacePosition = worldPosition + normal * shadowParams.y * clamp(1.0 - dot(normal, -lightDirNorm), 0.0, 1.0) * distScale; + #endif + #endif + vec4 positionInShadowSpace = shadowTransform * vec4(surfacePosition, 1.0); + #ifdef SHADOW_SAMPLE_ORTHO + positionInShadowSpace.z = saturate(positionInShadowSpace.z) - 0.0001; + #else + #ifdef SHADOW_SAMPLE_SOURCE_ZBUFFER + positionInShadowSpace.xyz /= positionInShadowSpace.w; + #else + positionInShadowSpace.xy /= positionInShadowSpace.w; + positionInShadowSpace.z = length(lightDir) * shadowParams.w; + #endif + #endif + #ifdef SHADOW_SAMPLE_Z_BIAS + positionInShadowSpace.z += getShadowBias(shadowParams.x, shadowParams.z); + #endif + surfacePosition = positionInShadowSpace.xyz; +#endif + return surfacePosition; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/shadowStandard.js +var shadowStandardPS = ` +vec3 lessThan2(vec3 a, vec3 b) { + return clamp((b - a)*1000.0, 0.0, 1.0); +} +#ifndef UNPACKFLOAT +#define UNPACKFLOAT + float unpackFloat(vec4 rgbaDepth) { + const vec4 bitShift = vec4(1.0 / (256.0 * 256.0 * 256.0), 1.0 / (256.0 * 256.0), 1.0 / 256.0, 1.0); + return dot(rgbaDepth, bitShift); + } +#endif +#ifdef GL2 +float _getShadowPCF3x3(SHADOWMAP_ACCEPT(shadowMap), vec3 shadowCoord, vec3 shadowParams) { + float z = shadowCoord.z; + vec2 uv = shadowCoord.xy * shadowParams.x; + float shadowMapSizeInv = 1.0 / shadowParams.x; + vec2 base_uv = floor(uv + 0.5); + float s = (uv.x + 0.5 - base_uv.x); + float t = (uv.y + 0.5 - base_uv.y); + base_uv -= vec2(0.5); + base_uv *= shadowMapSizeInv; + float sum = 0.0; + float uw0 = (3.0 - 2.0 * s); + float uw1 = (1.0 + 2.0 * s); + float u0 = (2.0 - s) / uw0 - 1.0; + float u1 = s / uw1 + 1.0; + float vw0 = (3.0 - 2.0 * t); + float vw1 = (1.0 + 2.0 * t); + float v0 = (2.0 - t) / vw0 - 1.0; + float v1 = t / vw1 + 1.0; + u0 = u0 * shadowMapSizeInv + base_uv.x; + v0 = v0 * shadowMapSizeInv + base_uv.y; + u1 = u1 * shadowMapSizeInv + base_uv.x; + v1 = v1 * shadowMapSizeInv + base_uv.y; + sum += uw0 * vw0 * textureShadow(shadowMap, vec3(u0, v0, z)); + sum += uw1 * vw0 * textureShadow(shadowMap, vec3(u1, v0, z)); + sum += uw0 * vw1 * textureShadow(shadowMap, vec3(u0, v1, z)); + sum += uw1 * vw1 * textureShadow(shadowMap, vec3(u1, v1, z)); + sum *= 1.0f / 16.0; + return sum; +} +float getShadowPCF3x3(SHADOWMAP_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams) { + return _getShadowPCF3x3(SHADOWMAP_PASS(shadowMap), shadowCoord, shadowParams.xyz); +} +float getShadowSpotPCF3x3(SHADOWMAP_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams) { + return _getShadowPCF3x3(SHADOWMAP_PASS(shadowMap), shadowCoord, shadowParams.xyz); +} +float getShadowPCF1x1(SHADOWMAP_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams) { + return textureShadow(shadowMap, shadowCoord); +} +float getShadowSpotPCF1x1(SHADOWMAP_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams) { + return textureShadow(shadowMap, shadowCoord); +} +#else +float _xgetShadowPCF3x3(mat3 depthKernel, vec3 shadowCoord, sampler2D shadowMap, vec3 shadowParams) { + mat3 shadowKernel; + vec3 shadowZ = vec3(shadowCoord.z); + shadowKernel[0] = vec3(greaterThan(depthKernel[0], shadowZ)); + shadowKernel[1] = vec3(greaterThan(depthKernel[1], shadowZ)); + shadowKernel[2] = vec3(greaterThan(depthKernel[2], shadowZ)); + vec2 fractionalCoord = fract( shadowCoord.xy * shadowParams.x ); + shadowKernel[0] = mix(shadowKernel[0], shadowKernel[1], fractionalCoord.x); + shadowKernel[1] = mix(shadowKernel[1], shadowKernel[2], fractionalCoord.x); + vec4 shadowValues; + shadowValues.x = mix(shadowKernel[0][0], shadowKernel[0][1], fractionalCoord.y); + shadowValues.y = mix(shadowKernel[0][1], shadowKernel[0][2], fractionalCoord.y); + shadowValues.z = mix(shadowKernel[1][0], shadowKernel[1][1], fractionalCoord.y); + shadowValues.w = mix(shadowKernel[1][1], shadowKernel[1][2], fractionalCoord.y); + return dot( shadowValues, vec4( 1.0 ) ) * 0.25; +} +float _getShadowPCF3x3(sampler2D shadowMap, vec3 shadowCoord, vec3 shadowParams) { + float xoffset = 1.0 / shadowParams.x; + float dx0 = -xoffset; + float dx1 = xoffset; + mat3 depthKernel; + depthKernel[0][0] = unpackFloat(textureShadow(shadowMap, shadowCoord.xy + vec2(dx0, dx0))); + depthKernel[0][1] = unpackFloat(textureShadow(shadowMap, shadowCoord.xy + vec2(dx0, 0.0))); + depthKernel[0][2] = unpackFloat(textureShadow(shadowMap, shadowCoord.xy + vec2(dx0, dx1))); + depthKernel[1][0] = unpackFloat(textureShadow(shadowMap, shadowCoord.xy + vec2(0.0, dx0))); + depthKernel[1][1] = unpackFloat(textureShadow(shadowMap, shadowCoord.xy)); + depthKernel[1][2] = unpackFloat(textureShadow(shadowMap, shadowCoord.xy + vec2(0.0, dx1))); + depthKernel[2][0] = unpackFloat(textureShadow(shadowMap, shadowCoord.xy + vec2(dx1, dx0))); + depthKernel[2][1] = unpackFloat(textureShadow(shadowMap, shadowCoord.xy + vec2(dx1, 0.0))); + depthKernel[2][2] = unpackFloat(textureShadow(shadowMap, shadowCoord.xy + vec2(dx1, dx1))); + return _xgetShadowPCF3x3(depthKernel, shadowCoord, shadowMap, shadowParams); +} +float getShadowPCF3x3(sampler2D shadowMap, vec3 shadowCoord, vec4 shadowParams) { + return _getShadowPCF3x3(shadowMap, shadowCoord, shadowParams.xyz); +} +float getShadowSpotPCF3x3(sampler2D shadowMap, vec3 shadowCoord, vec4 shadowParams) { + return _getShadowPCF3x3(shadowMap, shadowCoord, shadowParams.xyz); +} +float _getShadowPCF1x1(sampler2D shadowMap, vec3 shadowCoord) { + float shadowSample = unpackFloat(textureShadow(shadowMap, shadowCoord.xy)); + return shadowSample > shadowCoord.z ? 1.0 : 0.0; +} +float getShadowPCF1x1(sampler2D shadowMap, vec3 shadowCoord, vec4 shadowParams) { + return _getShadowPCF1x1(shadowMap, shadowCoord); +} +float getShadowSpotPCF1x1(sampler2D shadowMap, vec3 shadowCoord, vec4 shadowParams) { + return _getShadowPCF1x1(shadowMap, shadowCoord); +} +#endif +#ifndef WEBGPU +float _getShadowPoint(samplerCube shadowMap, vec4 shadowParams, vec3 dir) { + vec3 tc = normalize(dir); + vec3 tcAbs = abs(tc); + vec4 dirX = vec4(1,0,0, tc.x); + vec4 dirY = vec4(0,1,0, tc.y); + float majorAxisLength = tc.z; + if ((tcAbs.x > tcAbs.y) && (tcAbs.x > tcAbs.z)) { + dirX = vec4(0,0,1, tc.z); + dirY = vec4(0,1,0, tc.y); + majorAxisLength = tc.x; + } else if ((tcAbs.y > tcAbs.x) && (tcAbs.y > tcAbs.z)) { + dirX = vec4(1,0,0, tc.x); + dirY = vec4(0,0,1, tc.z); + majorAxisLength = tc.y; + } + float shadowParamsInFaceSpace = ((1.0/shadowParams.x) * 2.0) * abs(majorAxisLength); + vec3 xoffset = (dirX.xyz * shadowParamsInFaceSpace); + vec3 yoffset = (dirY.xyz * shadowParamsInFaceSpace); + vec3 dx0 = -xoffset; + vec3 dy0 = -yoffset; + vec3 dx1 = xoffset; + vec3 dy1 = yoffset; + mat3 shadowKernel; + mat3 depthKernel; + depthKernel[0][0] = unpackFloat(textureCube(shadowMap, tc + dx0 + dy0)); + depthKernel[0][1] = unpackFloat(textureCube(shadowMap, tc + dx0)); + depthKernel[0][2] = unpackFloat(textureCube(shadowMap, tc + dx0 + dy1)); + depthKernel[1][0] = unpackFloat(textureCube(shadowMap, tc + dy0)); + depthKernel[1][1] = unpackFloat(textureCube(shadowMap, tc)); + depthKernel[1][2] = unpackFloat(textureCube(shadowMap, tc + dy1)); + depthKernel[2][0] = unpackFloat(textureCube(shadowMap, tc + dx1 + dy0)); + depthKernel[2][1] = unpackFloat(textureCube(shadowMap, tc + dx1)); + depthKernel[2][2] = unpackFloat(textureCube(shadowMap, tc + dx1 + dy1)); + vec3 shadowZ = vec3(length(dir) * shadowParams.w + shadowParams.z); + shadowKernel[0] = vec3(lessThan2(depthKernel[0], shadowZ)); + shadowKernel[1] = vec3(lessThan2(depthKernel[1], shadowZ)); + shadowKernel[2] = vec3(lessThan2(depthKernel[2], shadowZ)); + vec2 uv = (vec2(dirX.w, dirY.w) / abs(majorAxisLength)) * 0.5; + vec2 fractionalCoord = fract( uv * shadowParams.x ); + shadowKernel[0] = mix(shadowKernel[0], shadowKernel[1], fractionalCoord.x); + shadowKernel[1] = mix(shadowKernel[1], shadowKernel[2], fractionalCoord.x); + vec4 shadowValues; + shadowValues.x = mix(shadowKernel[0][0], shadowKernel[0][1], fractionalCoord.y); + shadowValues.y = mix(shadowKernel[0][1], shadowKernel[0][2], fractionalCoord.y); + shadowValues.z = mix(shadowKernel[1][0], shadowKernel[1][1], fractionalCoord.y); + shadowValues.w = mix(shadowKernel[1][1], shadowKernel[1][2], fractionalCoord.y); + return 1.0 - dot( shadowValues, vec4( 1.0 ) ) * 0.25; +} +float getShadowPointPCF3x3(samplerCube shadowMap, vec3 shadowCoord, vec4 shadowParams, vec3 lightDir) { + return _getShadowPoint(shadowMap, shadowParams, lightDir); +} +#endif +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/shadowStandardGL2.js +var shadowStandardGL2PS = ` +float _getShadowPCF5x5(SHADOWMAP_ACCEPT(shadowMap), vec3 shadowCoord, vec3 shadowParams) { + float z = shadowCoord.z; + vec2 uv = shadowCoord.xy * shadowParams.x; + float shadowMapSizeInv = 1.0 / shadowParams.x; + vec2 base_uv = floor(uv + 0.5); + float s = (uv.x + 0.5 - base_uv.x); + float t = (uv.y + 0.5 - base_uv.y); + base_uv -= vec2(0.5); + base_uv *= shadowMapSizeInv; + float uw0 = (4.0 - 3.0 * s); + float uw1 = 7.0; + float uw2 = (1.0 + 3.0 * s); + float u0 = (3.0 - 2.0 * s) / uw0 - 2.0; + float u1 = (3.0 + s) / uw1; + float u2 = s / uw2 + 2.0; + float vw0 = (4.0 - 3.0 * t); + float vw1 = 7.0; + float vw2 = (1.0 + 3.0 * t); + float v0 = (3.0 - 2.0 * t) / vw0 - 2.0; + float v1 = (3.0 + t) / vw1; + float v2 = t / vw2 + 2.0; + float sum = 0.0; + u0 = u0 * shadowMapSizeInv + base_uv.x; + v0 = v0 * shadowMapSizeInv + base_uv.y; + u1 = u1 * shadowMapSizeInv + base_uv.x; + v1 = v1 * shadowMapSizeInv + base_uv.y; + u2 = u2 * shadowMapSizeInv + base_uv.x; + v2 = v2 * shadowMapSizeInv + base_uv.y; + sum += uw0 * vw0 * textureShadow(shadowMap, vec3(u0, v0, z)); + sum += uw1 * vw0 * textureShadow(shadowMap, vec3(u1, v0, z)); + sum += uw2 * vw0 * textureShadow(shadowMap, vec3(u2, v0, z)); + sum += uw0 * vw1 * textureShadow(shadowMap, vec3(u0, v1, z)); + sum += uw1 * vw1 * textureShadow(shadowMap, vec3(u1, v1, z)); + sum += uw2 * vw1 * textureShadow(shadowMap, vec3(u2, v1, z)); + sum += uw0 * vw2 * textureShadow(shadowMap, vec3(u0, v2, z)); + sum += uw1 * vw2 * textureShadow(shadowMap, vec3(u1, v2, z)); + sum += uw2 * vw2 * textureShadow(shadowMap, vec3(u2, v2, z)); + sum *= 1.0f / 144.0; + sum = saturate(sum); + return sum; +} +float getShadowPCF5x5(SHADOWMAP_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams) { + return _getShadowPCF5x5(SHADOWMAP_PASS(shadowMap), shadowCoord, shadowParams.xyz); +} +float getShadowSpotPCF5x5(SHADOWMAP_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams) { + return _getShadowPCF5x5(SHADOWMAP_PASS(shadowMap), shadowCoord, shadowParams.xyz); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/shadowVSM8.js +var shadowVSM8PS = ` +float calculateVSM8(vec3 moments, float Z, float vsmBias) { + float VSMBias = vsmBias; + float depthScale = VSMBias * Z; + float minVariance1 = depthScale * depthScale; + return chebyshevUpperBound(moments.xy, Z, minVariance1, 0.1); +} +float decodeFloatRG(vec2 rg) { + return rg.y*(1.0/255.0) + rg.x; +} +float VSM8(TEXTURE_ACCEPT(tex), vec2 texCoords, float resolution, float Z, float vsmBias, float exponent) { + vec4 c = texture2D(tex, texCoords); + vec3 moments = vec3(decodeFloatRG(c.xy), decodeFloatRG(c.zw), 0.0); + return calculateVSM8(moments, Z, vsmBias); +} +float getShadowVSM8(TEXTURE_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams, float exponent, vec3 lightDir) { + return VSM8(TEXTURE_PASS(shadowMap), shadowCoord.xy, shadowParams.x, shadowCoord.z, shadowParams.y, 0.0); +} +float getShadowSpotVSM8(TEXTURE_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams, float exponent, vec3 lightDir) { + return VSM8(TEXTURE_PASS(shadowMap), shadowCoord.xy, shadowParams.x, length(lightDir) * shadowParams.w + shadowParams.z, shadowParams.y, 0.0); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/shadowVSM_common.js +var shadowVSM_commonPS = ` +float linstep(float a, float b, float v) { + return saturate((v - a) / (b - a)); +} +float reduceLightBleeding(float pMax, float amount) { + return linstep(amount, 1.0, pMax); +} +float chebyshevUpperBound(vec2 moments, float mean, float minVariance, float lightBleedingReduction) { + float variance = moments.y - (moments.x * moments.x); + variance = max(variance, minVariance); + float d = mean - moments.x; + float pMax = variance / (variance + (d * d)); + pMax = reduceLightBleeding(pMax, lightBleedingReduction); + return (mean <= moments.x ? 1.0 : pMax); +} +float calculateEVSM(vec3 moments, float Z, float vsmBias, float exponent) { + Z = 2.0 * Z - 1.0; + float warpedDepth = exp(exponent * Z); + moments.xy += vec2(warpedDepth, warpedDepth*warpedDepth) * (1.0 - moments.z); + float VSMBias = vsmBias; + float depthScale = VSMBias * exponent * warpedDepth; + float minVariance1 = depthScale * depthScale; + return chebyshevUpperBound(moments.xy, warpedDepth, minVariance1, 0.1); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/vert/skinBatchConst.js +var skinBatchConstVS = ` +attribute float vertex_boneIndices; +uniform vec4 matrix_pose[BONE_LIMIT * 3]; +mat4 getBoneMatrix(const in float i) { + vec4 v1 = matrix_pose[int(3.0 * i)]; + vec4 v2 = matrix_pose[int(3.0 * i + 1.0)]; + vec4 v3 = matrix_pose[int(3.0 * i + 2.0)]; + return mat4( + v1.x, v2.x, v3.x, 0, + v1.y, v2.y, v3.y, 0, + v1.z, v2.z, v3.z, 0, + v1.w, v2.w, v3.w, 1 + ); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/vert/skinBatchTex.js +var skinBatchTexVS = ` +attribute float vertex_boneIndices; +uniform highp sampler2D texture_poseMap; +uniform vec4 texture_poseMapSize; +mat4 getBoneMatrix(const in float i) { + float j = i * 3.0; + float dx = texture_poseMapSize.z; + float dy = texture_poseMapSize.w; + float y = floor(j * dx); + float x = j - (y * texture_poseMapSize.x); + y = dy * (y + 0.5); + vec4 v1 = texture2D(texture_poseMap, vec2(dx * (x + 0.5), y)); + vec4 v2 = texture2D(texture_poseMap, vec2(dx * (x + 1.5), y)); + vec4 v3 = texture2D(texture_poseMap, vec2(dx * (x + 2.5), y)); + return mat4( + v1.x, v2.x, v3.x, 0, + v1.y, v2.y, v3.y, 0, + v1.z, v2.z, v3.z, 0, + v1.w, v2.w, v3.w, 1 + ); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/vert/skinConst.js +var skinConstVS = ` +attribute vec4 vertex_boneWeights; +attribute vec4 vertex_boneIndices; +uniform vec4 matrix_pose[BONE_LIMIT * 3]; +void getBoneMatrix(const in float i, out vec4 v1, out vec4 v2, out vec4 v3) { + v1 = matrix_pose[int(3.0 * i)]; + v2 = matrix_pose[int(3.0 * i + 1.0)]; + v3 = matrix_pose[int(3.0 * i + 2.0)]; +} +mat4 getSkinMatrix(const in vec4 indices, const in vec4 weights) { + vec4 a1, a2, a3; + getBoneMatrix(indices.x, a1, a2, a3); + vec4 b1, b2, b3; + getBoneMatrix(indices.y, b1, b2, b3); + vec4 c1, c2, c3; + getBoneMatrix(indices.z, c1, c2, c3); + vec4 d1, d2, d3; + getBoneMatrix(indices.w, d1, d2, d3); + vec4 v1 = a1 * weights.x + b1 * weights.y + c1 * weights.z + d1 * weights.w; + vec4 v2 = a2 * weights.x + b2 * weights.y + c2 * weights.z + d2 * weights.w; + vec4 v3 = a3 * weights.x + b3 * weights.y + c3 * weights.z + d3 * weights.w; + float one = dot(weights, vec4(1.0)); + return mat4( + v1.x, v2.x, v3.x, 0, + v1.y, v2.y, v3.y, 0, + v1.z, v2.z, v3.z, 0, + v1.w, v2.w, v3.w, one + ); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/vert/skinTex.js +var skinTexVS = ` +attribute vec4 vertex_boneWeights; +attribute vec4 vertex_boneIndices; +uniform highp sampler2D texture_poseMap; +uniform vec4 texture_poseMapSize; +void getBoneMatrix(const in float index, out vec4 v1, out vec4 v2, out vec4 v3) { + float i = float(index); + float j = i * 3.0; + float dx = texture_poseMapSize.z; + float dy = texture_poseMapSize.w; + + float y = floor(j * dx); + float x = j - (y * texture_poseMapSize.x); + y = dy * (y + 0.5); + v1 = texture2D(texture_poseMap, vec2(dx * (x + 0.5), y)); + v2 = texture2D(texture_poseMap, vec2(dx * (x + 1.5), y)); + v3 = texture2D(texture_poseMap, vec2(dx * (x + 2.5), y)); +} +mat4 getSkinMatrix(const in vec4 indices, const in vec4 weights) { + vec4 a1, a2, a3; + getBoneMatrix(indices.x, a1, a2, a3); + vec4 b1, b2, b3; + getBoneMatrix(indices.y, b1, b2, b3); + vec4 c1, c2, c3; + getBoneMatrix(indices.z, c1, c2, c3); + vec4 d1, d2, d3; + getBoneMatrix(indices.w, d1, d2, d3); + vec4 v1 = a1 * weights.x + b1 * weights.y + c1 * weights.z + d1 * weights.w; + vec4 v2 = a2 * weights.x + b2 * weights.y + c2 * weights.z + d2 * weights.w; + vec4 v3 = a3 * weights.x + b3 * weights.y + c3 * weights.z + d3 * weights.w; + float one = dot(weights, vec4(1.0)); + return mat4( + v1.x, v2.x, v3.x, 0, + v1.y, v2.y, v3.y, 0, + v1.z, v2.z, v3.z, 0, + v1.w, v2.w, v3.w, one + ); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/skybox/frag/skyboxEnv.js +var skyboxEnvPS = ` +varying vec3 vViewDir; +uniform sampler2D texture_envAtlas; +uniform float mipLevel; +void main(void) { + vec3 dir = vViewDir * vec3(-1.0, 1.0, 1.0); + vec2 uv = toSphericalUv(normalize(dir)); + vec3 linear = SKYBOX_DECODE_FNC(texture2D(texture_envAtlas, mapRoughnessUv(uv, mipLevel))); + gl_FragColor = vec4(gammaCorrectOutput(toneMap(processEnvironment(linear))), 1.0); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/skybox/frag/skyboxHDR.js +var skyboxHDRPS = ` +varying vec3 vViewDir; +uniform samplerCube texture_cubeMap; +#ifdef SKYMESH + varying vec3 vWorldPos; + uniform mat3 cubeMapRotationMatrix; + uniform vec3 projectedSkydomeCenter; +#endif +void main(void) { + #ifdef SKYMESH + vec3 envDir = normalize(vWorldPos - projectedSkydomeCenter); + vec3 dir = envDir * cubeMapRotationMatrix; + #else + vec3 dir = vViewDir; + #endif + dir.x *= -1.0; + vec3 linear = SKYBOX_DECODE_FNC(textureCube(texture_cubeMap, fixSeamsStatic(dir, SKYBOX_MIP))); + gl_FragColor = vec4(gammaCorrectOutput(toneMap(processEnvironment(linear))), 1.0); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/skybox/vert/skybox.js +var skyboxVS = ` +attribute vec3 aPosition; +#ifndef VIEWMATRIX +#define VIEWMATRIX +uniform mat4 matrix_view; +#endif +uniform mat4 matrix_projectionSkybox; +uniform mat3 cubeMapRotationMatrix; +varying vec3 vViewDir; +#ifdef SKYMESH + uniform mat4 matrix_model; + varying vec3 vWorldPos; +#endif +void main(void) { + mat4 view = matrix_view; + #ifdef SKYMESH + vec4 worldPos = matrix_model * vec4(aPosition, 1.0); + vWorldPos = worldPos.xyz; + gl_Position = matrix_projectionSkybox * view * worldPos; + #else + view[3][0] = view[3][1] = view[3][2] = 0.0; + gl_Position = matrix_projectionSkybox * view * vec4(aPosition, 1.0); + vViewDir = aPosition * cubeMapRotationMatrix; + #endif + gl_Position.z = gl_Position.w - 1.0e-7; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/specular.js +var specularPS = ` +#ifdef MAPCOLOR +uniform vec3 material_specular; +#endif +void getSpecularity() { + vec3 specularColor = vec3(1,1,1); + #ifdef MAPCOLOR + specularColor *= material_specular; + #endif + #ifdef MAPTEXTURE + specularColor *= $DECODE(texture2DBias($SAMPLER, $UV, textureBias)).$CH; + #endif + #ifdef MAPVERTEX + specularColor *= saturate(vVertexColor.$VC); + #endif + dSpecularity = specularColor; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/spherical.js +var sphericalPS = ` +const float PI = 3.141592653589793; +vec2 toSpherical(vec3 dir) { + return vec2(dir.xz == vec2(0.0) ? 0.0 : atan(dir.x, dir.z), asin(dir.y)); +} +vec2 toSphericalUv(vec3 dir) { + vec2 uv = toSpherical(dir) / vec2(PI * 2.0, PI) + 0.5; + return vec2(uv.x, 1.0 - uv.y); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/specularityFactor.js +var specularityFactorPS = ` +#ifdef MAPFLOAT +uniform float material_specularityFactor; +#endif +void getSpecularityFactor() { + float specularityFactor = 1.0; + #ifdef MAPFLOAT + specularityFactor *= material_specularityFactor; + #endif + #ifdef MAPTEXTURE + specularityFactor *= texture2DBias($SAMPLER, $UV, textureBias).$CH; + #endif + #ifdef MAPVERTEX + specularityFactor *= saturate(vVertexColor.$VC); + #endif + dSpecularityFactor = specularityFactor; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/spot.js +var spotPS = ` +float getSpotEffect(vec3 lightSpotDir, float lightInnerConeAngle, float lightOuterConeAngle, vec3 lightDirNorm) { + float cosAngle = dot(lightDirNorm, lightSpotDir); + return smoothstep(lightOuterConeAngle, lightInnerConeAngle, cosAngle); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/start.js +var startPS = ` +void main(void) { + dReflection = vec4(0); + #ifdef LIT_CLEARCOAT + ccSpecularLight = vec3(0); + ccReflection = vec3(0); + #endif +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/vert/start.js +var startVS = ` +void main(void) { + gl_Position = getPosition(); +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/startNineSliced.js +var startNineSlicedPS = ` + nineSlicedUv = vUv0; + nineSlicedUv.y = 1.0 - nineSlicedUv.y; +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/startNineSlicedTiled.js +var startNineSlicedTiledPS = ` + vec2 tileMask = step(vMask, vec2(0.99999)); + vec2 tileSize = 0.5 * (innerOffset.xy + innerOffset.zw); + vec2 tileScale = vec2(1.0) / (vec2(1.0) - tileSize); + vec2 clampedUv = mix(innerOffset.xy * 0.5, vec2(1.0) - innerOffset.zw * 0.5, fract((vTiledUv - tileSize) * tileScale)); + clampedUv = clampedUv * atlasRect.zw + atlasRect.xy; + nineSlicedUv = vUv0 * tileMask + clampedUv * (vec2(1.0) - tileMask); + nineSlicedUv.y = 1.0 - nineSlicedUv.y; + +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/storeEVSM.js +var storeEVSMPS = ` +float exponent = VSM_EXPONENT; +depth = 2.0 * depth - 1.0; +depth = exp(exponent * depth); +gl_FragColor = vec4(depth, depth*depth, 1.0, 1.0); +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/vert/tangentBinormal.js +var tangentBinormalVS = ` +vec3 getTangent() { + return normalize(dNormalMatrix * vertex_tangent.xyz); +} +vec3 getBinormal() { + return cross(vNormalW, vTangentW) * vertex_tangent.w; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/TBN.js +var TBNPS = ` +void getTBN(vec3 tangent, vec3 binormal, vec3 normal) { + dTBN = mat3(normalize(tangent), normalize(binormal), normalize(normal)); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/TBNderivative.js +var TBNderivativePS = ` +uniform float tbnBasis; +void getTBN(vec3 tangent, vec3 binormal, vec3 normal) { + vec2 uv = $UV; + vec3 dp1 = dFdx( vPositionW ); + vec3 dp2 = dFdy( vPositionW ); + vec2 duv1 = dFdx( uv ); + vec2 duv2 = dFdy( uv ); + vec3 dp2perp = cross( dp2, normal ); + vec3 dp1perp = cross( normal, dp1 ); + vec3 T = dp2perp * duv1.x + dp1perp * duv2.x; + vec3 B = dp2perp * duv1.y + dp1perp * duv2.y; + float denom = max( dot(T,T), dot(B,B) ); + float invmax = (denom == 0.0) ? 0.0 : tbnBasis / sqrt( denom ); + dTBN = mat3(T * invmax, -B * invmax, normal ); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/TBNfast.js +var TBNfastPS = ` +void getTBN(vec3 tangent, vec3 binormal, vec3 normal) { + dTBN = mat3(tangent, binormal, normal); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/TBNObjectSpace.js +var TBNObjectSpacePS = ` +void getTBN(vec3 tangent, vec3 binormal, vec3 normal) { + vec3 B = cross(normal, vObjectSpaceUpW); + vec3 T = cross(normal, B); + if (dot(B,B)==0.0) + { + float major=max(max(normal.x, normal.y), normal.z); + if (normal.x == major) + { + B=cross(normal, vec3(0,1,0)); + T=cross(normal, B); + } + else if (normal.y == major) + { + B=cross(normal, vec3(0,0,1)); + T=cross(normal, B); + } + else if (normal.z == major) + { + B=cross(normal, vec3(1,0,0)); + T=cross(normal, B); + } + } + dTBN = mat3(normalize(T), normalize(B), normalize(normal)); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/textureSample.js +var textureSamplePS = ` +vec4 texture2DSRGB(sampler2D tex, vec2 uv) { + return gammaCorrectInput(texture2D(tex, uv)); +} +vec4 texture2DSRGB(sampler2D tex, vec2 uv, float bias) { + return gammaCorrectInput(texture2D(tex, uv, bias)); +} +vec3 texture2DRGBM(sampler2D tex, vec2 uv) { + return decodeRGBM(texture2D(tex, uv)); +} +vec3 texture2DRGBM(sampler2D tex, vec2 uv, float bias) { + return decodeRGBM(texture2D(tex, uv, bias)); +} +vec3 texture2DRGBE(sampler2D tex, vec2 uv) { + return decodeRGBM(texture2D(tex, uv)); +} +vec3 texture2DRGBE(sampler2D tex, vec2 uv, float bias) { + return decodeRGBM(texture2D(tex, uv, bias)); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/thickness.js +var thicknessPS = ` +#ifdef MAPFLOAT +uniform float material_thickness; +#endif +void getThickness() { + dThickness = 1.0; + #ifdef MAPFLOAT + dThickness *= material_thickness; + #endif + #ifdef MAPTEXTURE + dThickness *= texture2DBias($SAMPLER, $UV, textureBias).$CH; + #endif + #ifdef MAPVERTEX + dThickness *= saturate(vVertexColor.$VC); + #endif +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/tonemappingAces.js +var tonemappingAcesPS = ` +uniform float exposure; +vec3 toneMap(vec3 color) { + float tA = 2.51; + float tB = 0.03; + float tC = 2.43; + float tD = 0.59; + float tE = 0.14; + vec3 x = color * exposure; + return (x*(tA*x+tB))/(x*(tC*x+tD)+tE); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/tonemappingAces2.js +var tonemappingAces2PS = ` +uniform float exposure; +const mat3 ACESInputMat = mat3( + 0.59719, 0.35458, 0.04823, + 0.07600, 0.90834, 0.01566, + 0.02840, 0.13383, 0.83777 +); +const mat3 ACESOutputMat = mat3( + 1.60475, -0.53108, -0.07367, + -0.10208, 1.10813, -0.00605, + -0.00327, -0.07276, 1.07602 +); +vec3 RRTAndODTFit(vec3 v) { + vec3 a = v * (v + 0.0245786) - 0.000090537; + vec3 b = v * (0.983729 * v + 0.4329510) + 0.238081; + return a / b; +} +vec3 toneMap(vec3 color) { + color *= exposure / 0.6; + color = color * ACESInputMat; + color = RRTAndODTFit(color); + color = color * ACESOutputMat; + color = clamp(color, 0.0, 1.0); + return color; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/tonemappingFilmic.js +var tonemappingFilmicPS = ` +const float A = 0.15; +const float B = 0.50; +const float C = 0.10; +const float D = 0.20; +const float E = 0.02; +const float F = 0.30; +const float W = 11.2; +uniform float exposure; +vec3 uncharted2Tonemap(vec3 x) { + return ((x*(A*x+C*B)+D*E)/(x*(A*x+B)+D*F))-E/F; +} +vec3 toneMap(vec3 color) { + color = uncharted2Tonemap(color * exposure); + vec3 whiteScale = 1.0 / uncharted2Tonemap(vec3(W,W,W)); + color = color * whiteScale; + return color; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/tonemappingHejl.js +var tonemappingHejlPS = ` +uniform float exposure; +vec3 toneMap(vec3 color) { + color *= exposure; + const float A = 0.22, B = 0.3, C = .1, D = 0.2, E = .01, F = 0.3; + const float Scl = 1.25; + vec3 h = max( vec3(0.0), color - vec3(0.004) ); + return (h*((Scl*A)*h+Scl*vec3(C*B,C*B,C*B))+Scl*vec3(D*E,D*E,D*E)) / (h*(A*h+vec3(B,B,B))+vec3(D*F,D*F,D*F)) - Scl*vec3(E/F,E/F,E/F); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/tonemappingLinear.js +var tonemappingLinearPS = ` +uniform float exposure; +vec3 toneMap(vec3 color) { + return color * exposure; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/tonemappingNeutral.js +var tonemappingNeutralPS = ` +uniform float exposure; +vec3 toneMap(vec3 color) { + color *= exposure; + float startCompression = 0.8 - 0.04; + float desaturation = 0.15; + float x = min(color.r, min(color.g, color.b)); + float offset = x < 0.08 ? x - 6.25 * x * x : 0.04; + color -= offset; + float peak = max(color.r, max(color.g, color.b)); + if (peak < startCompression) return color; + float d = 1. - startCompression; + float newPeak = 1. - d * d / (peak + d - startCompression); + color *= newPeak / peak; + float g = 1. - 1. / (desaturation * (peak - newPeak) + 1.); + return mix(color, newPeak * vec3(1, 1, 1), g); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/tonemappingNone.js +var tonemappingNonePS = ` +vec3 toneMap(vec3 color) { + return color; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/vert/transform.js +var transformVS = ` +#ifdef PIXELSNAP +uniform vec4 uScreenSize; +#endif +#ifdef SCREENSPACE +uniform float projectionFlipY; +#endif +#ifdef MORPHING +uniform vec4 morph_weights_a; +uniform vec4 morph_weights_b; +#endif +#ifdef MORPHING_TEXTURE_BASED + uniform vec4 morph_tex_params; + #ifdef WEBGPU + ivec2 getTextureMorphCoords() { + ivec2 textureSize = ivec2(morph_tex_params.xy); + int morphGridV = int(morph_vertex_id / textureSize.x); + int morphGridU = int(morph_vertex_id - (morphGridV * textureSize.x)); + morphGridV = textureSize.y - morphGridV - 1; + return ivec2(morphGridU, morphGridV); + } + #else + vec2 getTextureMorphCoords() { + vec2 textureSize = morph_tex_params.xy; + vec2 invTextureSize = morph_tex_params.zw; + float morphGridV = floor(morph_vertex_id * invTextureSize.x); + float morphGridU = morph_vertex_id - (morphGridV * textureSize.x); + return vec2(morphGridU, morphGridV) * invTextureSize + (0.5 * invTextureSize); + } + #endif +#endif +#ifdef MORPHING_TEXTURE_BASED_POSITION +uniform highp sampler2D morphPositionTex; +#endif +mat4 getModelMatrix() { + #ifdef DYNAMICBATCH + return getBoneMatrix(vertex_boneIndices); + #elif defined(SKIN) + return matrix_model * getSkinMatrix(vertex_boneIndices, vertex_boneWeights); + #elif defined(INSTANCING) + return mat4(instance_line1, instance_line2, instance_line3, instance_line4); + #else + return matrix_model; + #endif +} +vec4 getPosition() { + dModelMatrix = getModelMatrix(); + vec3 localPos = vertex_position; + #ifdef NINESLICED + localPos.xz *= outerScale; + vec2 positiveUnitOffset = clamp(vertex_position.xz, vec2(0.0), vec2(1.0)); + vec2 negativeUnitOffset = clamp(-vertex_position.xz, vec2(0.0), vec2(1.0)); + localPos.xz += (-positiveUnitOffset * innerOffset.xy + negativeUnitOffset * innerOffset.zw) * vertex_texCoord0.xy; + vTiledUv = (localPos.xz - outerScale + innerOffset.xy) * -0.5 + 1.0; + localPos.xz *= -0.5; + localPos = localPos.xzy; + #endif + #ifdef MORPHING + #ifdef MORPHING_POS03 + localPos.xyz += morph_weights_a[0] * morph_pos0; + localPos.xyz += morph_weights_a[1] * morph_pos1; + localPos.xyz += morph_weights_a[2] * morph_pos2; + localPos.xyz += morph_weights_a[3] * morph_pos3; + #endif + #ifdef MORPHING_POS47 + localPos.xyz += morph_weights_b[0] * morph_pos4; + localPos.xyz += morph_weights_b[1] * morph_pos5; + localPos.xyz += morph_weights_b[2] * morph_pos6; + localPos.xyz += morph_weights_b[3] * morph_pos7; + #endif + #endif + #ifdef MORPHING_TEXTURE_BASED_POSITION + #ifdef WEBGPU + ivec2 morphUV = getTextureMorphCoords(); + vec3 morphPos = texelFetch(morphPositionTex, ivec2(morphUV), 0).xyz; + #else + vec2 morphUV = getTextureMorphCoords(); + vec3 morphPos = texture2D(morphPositionTex, morphUV).xyz; + #endif + localPos += morphPos; + #endif + vec4 posW = dModelMatrix * vec4(localPos, 1.0); + #ifdef SCREENSPACE + posW.zw = vec2(0.0, 1.0); + #endif + dPositionW = posW.xyz; + vec4 screenPos; + #ifdef UV1LAYOUT + screenPos = vec4(vertex_texCoord1.xy * 2.0 - 1.0, 0.5, 1); + #ifdef WEBGPU + screenPos.y *= -1.0; + #endif + #else + #ifdef SCREENSPACE + screenPos = posW; + screenPos.y *= projectionFlipY; + #else + screenPos = matrix_viewProjection * posW; + #endif + #ifdef PIXELSNAP + screenPos.xy = (screenPos.xy * 0.5) + 0.5; + screenPos.xy *= uScreenSize.xy; + screenPos.xy = floor(screenPos.xy); + screenPos.xy *= uScreenSize.zw; + screenPos.xy = (screenPos.xy * 2.0) - 1.0; + #endif + #endif + return screenPos; +} +vec3 getWorldPosition() { + return dPositionW; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/vert/transformDecl.js +var transformDeclVS = ` +attribute vec3 vertex_position; +uniform mat4 matrix_model; +uniform mat4 matrix_viewProjection; +vec3 dPositionW; +mat4 dModelMatrix; +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/transmission.js +var transmissionPS = ` +#ifdef MAPFLOAT +uniform float material_refraction; +#endif +void getRefraction() { + float refraction = 1.0; + #ifdef MAPFLOAT + refraction = material_refraction; + #endif + #ifdef MAPTEXTURE + refraction *= texture2DBias($SAMPLER, $UV, textureBias).$CH; + #endif + #ifdef MAPVERTEX + refraction *= saturate(vVertexColor.$VC); + #endif + dTransmission = refraction; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/twoSidedLighting.js +var twoSidedLightingPS = ` +uniform float twoSidedLightingNegScaleFactor; +void handleTwoSidedLighting() { + dTBN[2] *= gl_FrontFacing ? twoSidedLightingNegScaleFactor : -twoSidedLightingNegScaleFactor; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/vert/uv0.js +var uv0VS = ` +#ifdef NINESLICED +vec2 getUv0() { + vec2 uv = vertex_position.xz; + vec2 positiveUnitOffset = clamp(vertex_position.xz, vec2(0.0), vec2(1.0)); + vec2 negativeUnitOffset = clamp(-vertex_position.xz, vec2(0.0), vec2(1.0)); + uv += (-positiveUnitOffset * innerOffset.xy + negativeUnitOffset * innerOffset.zw) * vertex_texCoord0.xy; + uv = uv * -0.5 + 0.5; + uv = uv * atlasRect.zw + atlasRect.xy; + vMask = vertex_texCoord0.xy; + return uv; +} +#else +vec2 getUv0() { + return vertex_texCoord0; +} +#endif +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/vert/uv1.js +var uv1VS = ` +vec2 getUv1() { + return vertex_texCoord1; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/viewDir.js +var viewDirPS = ` +void getViewDir() { + dViewDirW = normalize(view_position - vPositionW); +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/vert/viewNormal.js +var viewNormalVS = ` +#ifndef VIEWMATRIX +#define VIEWMATRIX +uniform mat4 matrix_view; +#endif +vec3 getViewNormal() { + return mat3(matrix_view) * vNormalW; +} +`; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/chunks.js +var shaderChunks = { + alphaTestPS, + ambientConstantPS, + ambientEnvPS, + ambientSHPS, + aoPS, + aoDetailMapPS, + aoDiffuseOccPS, + aoSpecOccPS, + aoSpecOccConstPS, + aoSpecOccConstSimplePS, + aoSpecOccSimplePS, + basePS, + baseVS, + baseNineSlicedPS, + baseNineSlicedVS, + baseNineSlicedTiledPS, + bayerPS, + biasConstPS, + blurVSMPS, + clearCoatPS, + clearCoatGlossPS, + clearCoatNormalPS, + clusteredLightCookiesPS, + clusteredLightShadowsPS, + clusteredLightUtilsPS, + clusteredLightPS, + combinePS, + cookiePS, + cubeMapProjectBoxPS, + cubeMapProjectNonePS, + cubeMapRotatePS, + debugOutputPS, + debugProcessFrontendPS, + detailModesPS, + diffusePS, + diffuseDetailMapPS, + decodePS, + emissivePS, + encodePS, + endPS, + endVS, + envAtlasPS, + envConstPS, + envMultiplyPS, + extensionPS, + extensionVS, + falloffInvSquaredPS, + falloffLinearPS, + fixCubemapSeamsNonePS, + fixCubemapSeamsStretchPS, + floatUnpackingPS, + fogExpPS, + fogExp2PS, + fogLinearPS, + fogNonePS, + fresnelSchlickPS, + fullscreenQuadPS, + fullscreenQuadVS, + gamma1_0PS, + gamma2_2PS, + gles2PS, + gles2VS, + gles3PS, + gles3VS, + glossPS, + iridescenceDiffractionPS, + iridescencePS, + iridescenceThicknessPS, + instancingVS, + iorPS, + lightDiffuseLambertPS, + lightDirPointPS, + lightmapAddPS, + lightmapDirAddPS, + lightmapDirPS, + lightmapSinglePS, + lightSpecularAnisoGGXPS, + lightSpecularBlinnPS, + lightSpecularPhongPS, + lightSheenPS, + linearizeDepthPS, + litShaderArgsPS, + ltcPS, + metalnessPS, + metalnessModulatePS, + msdfPS, + msdfVS, + normalVS, + normalDetailMapPS, + normalInstancedVS, + normalMapPS, + normalSkinnedVS, + normalXYPS, + normalXYZPS, + opacityPS, + opacityDitherPS, + outputPS, + outputAlphaPS, + outputAlphaOpaquePS, + outputAlphaPremulPS, + outputTex2DPS, + packDepthPS, + sheenPS, + sheenGlossPS, + parallaxPS, + particlePS, + particleVS, + particleAnimFrameClampVS, + particleAnimFrameLoopVS, + particleAnimTexVS, + particleInputFloatPS, + particleInputRgba8PS, + particleOutputFloatPS, + particleOutputRgba8PS, + particleUpdaterAABBPS, + particleUpdaterEndPS, + particleUpdaterInitPS, + particleUpdaterNoRespawnPS, + particleUpdaterOnStopPS, + particleUpdaterRespawnPS, + particleUpdaterSpherePS, + particleUpdaterStartPS, + particle_billboardVS, + particle_blendAddPS, + particle_blendMultiplyPS, + particle_blendNormalPS, + particle_cpuVS, + particle_cpu_endVS, + particle_customFaceVS, + particle_endPS, + particle_endVS, + particle_halflambertPS, + particle_initVS, + particle_lambertPS, + particle_lightingPS, + particle_localShiftVS, + particle_meshVS, + particle_normalVS, + particle_normalMapPS, + particle_pointAlongVS, + particle_softPS, + particle_softVS, + particle_stretchVS, + particle_TBNVS, + particle_wrapVS, + reflDirPS, + reflDirAnisoPS, + reflectionCCPS, + reflectionCubePS, + reflectionEnvHQPS, + reflectionEnvPS, + reflectionSpherePS, + reflectionSheenPS, + refractionCubePS, + refractionDynamicPS, + reprojectPS, + sampleCatmullRomPS, + screenDepthPS, + shadowCascadesPS, + shadowEVSMPS, + shadowEVSMnPS, + shadowPCSSPS, + shadowSampleCoordPS, + shadowStandardPS, + shadowStandardGL2PS, + shadowVSM8PS, + shadowVSM_commonPS, + skinBatchConstVS, + skinBatchTexVS, + skinConstVS, + skinTexVS, + skyboxEnvPS, + skyboxHDRPS, + skyboxVS, + specularPS, + sphericalPS, + specularityFactorPS, + spotPS, + startPS, + startVS, + startNineSlicedPS, + startNineSlicedTiledPS, + storeEVSMPS, + tangentBinormalVS, + TBNPS, + TBNderivativePS, + TBNfastPS, + TBNObjectSpacePS, + textureSamplePS, + thicknessPS, + tonemappingAcesPS, + tonemappingAces2PS, + tonemappingFilmicPS, + tonemappingHejlPS, + tonemappingLinearPS, + tonemappingNeutralPS, + tonemappingNonePS, + transformVS, + transformDeclVS, + transmissionPS, + twoSidedLightingPS, + uv0VS, + uv1VS, + viewDirPS, + viewNormalVS, + webgpuPS, + webgpuVS +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/get-program-library.js +var programLibraryDeviceCache = new DeviceCache(); +function getProgramLibrary(device) { + const library = programLibraryDeviceCache.get(device); + return library; +} +function setProgramLibrary(device, library) { + programLibraryDeviceCache.get(device, () => { + return library; + }); +} + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/programs/shader-generator.js +var ShaderGenerator = class { + static begin() { + return "void main(void)\n{\n"; + } + static end() { + return "}\n"; + } + static skinCode(device, chunks = shaderChunks) { + if (device.supportsBoneTextures) { + return chunks.skinTexVS; + } + return "#define BONE_LIMIT " + device.getBoneLimit() + "\n" + chunks.skinConstVS; + } + static fogCode(value, chunks = shaderChunks) { + if (value === "linear") { + return chunks.fogLinearPS ? chunks.fogLinearPS : shaderChunks.fogLinearPS; + } else if (value === "exp") { + return chunks.fogExpPS ? chunks.fogExpPS : shaderChunks.fogExpPS; + } else if (value === "exp2") { + return chunks.fogExp2PS ? chunks.fogExp2PS : shaderChunks.fogExp2PS; + } + return chunks.fogNonePS ? chunks.fogNonePS : shaderChunks.fogNonePS; + } + static gammaCode(value, chunks = shaderChunks) { + if (value === GAMMA_SRGB || value === GAMMA_SRGBFAST) { + return chunks.gamma2_2PS ? chunks.gamma2_2PS : shaderChunks.gamma2_2PS; + } else if (value === GAMMA_SRGBHDR) { + return "#define HDR\n" + (chunks.gamma2_2PS ? chunks.gamma2_2PS : shaderChunks.gamma2_2PS); + } + return chunks.gamma1_0PS ? chunks.gamma1_0PS : shaderChunks.gamma1_0PS; + } + static tonemapCode(value, chunks = shaderChunks) { + var _chunks$tonemappingFi, _chunks$tonemappingLi, _chunks$tonemappingHe, _chunks$tonemappingAc, _chunks$tonemappingAc2, _chunks$tonemappingNe, _chunks$tonemapingNon; + switch (value) { + case TONEMAP_FILMIC: + return (_chunks$tonemappingFi = chunks.tonemappingFilmicPS) != null ? _chunks$tonemappingFi : shaderChunks.tonemappingFilmicPS; + case TONEMAP_LINEAR: + return (_chunks$tonemappingLi = chunks.tonemappingLinearPS) != null ? _chunks$tonemappingLi : shaderChunks.tonemappingLinearPS; + case TONEMAP_HEJL: + return (_chunks$tonemappingHe = chunks.tonemappingHejlPS) != null ? _chunks$tonemappingHe : shaderChunks.tonemappingHejlPS; + case TONEMAP_ACES: + return (_chunks$tonemappingAc = chunks.tonemappingAcesPS) != null ? _chunks$tonemappingAc : shaderChunks.tonemappingAcesPS; + case TONEMAP_ACES2: + return (_chunks$tonemappingAc2 = chunks.tonemappingAces2PS) != null ? _chunks$tonemappingAc2 : shaderChunks.tonemappingAces2PS; + case TONEMAP_NEUTRAL: + return (_chunks$tonemappingNe = chunks.tonemappingNeutralPS) != null ? _chunks$tonemappingNe : shaderChunks.tonemappingNeutralPS; + } + return (_chunks$tonemapingNon = chunks.tonemapingNonePS) != null ? _chunks$tonemapingNon : shaderChunks.tonemappingNonePS; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/utils.js +function createShader(device, vsName, fsName, useTransformFeedback = false, shaderDefinitionOptions = {}) { + if (typeof useTransformFeedback === "boolean") { + shaderDefinitionOptions.useTransformFeedback = useTransformFeedback; + } else if (typeof useTransformFeedback === "object") { + shaderDefinitionOptions = _extends({}, shaderDefinitionOptions, useTransformFeedback); + } + return new Shader(device, ShaderUtils.createDefinition(device, _extends({}, shaderDefinitionOptions, { + name: `${vsName}_${fsName}`, + vertexCode: shaderChunks[vsName], + fragmentCode: shaderChunks[fsName] + }))); +} +function createShaderFromCode(device, vsCode2, fsCode, uniqueName, attributes, useTransformFeedback = false, shaderDefinitionOptions = {}) { + if (typeof useTransformFeedback === "boolean") { + shaderDefinitionOptions.useTransformFeedback = useTransformFeedback; + } else if (typeof useTransformFeedback === "object") { + shaderDefinitionOptions = _extends({}, shaderDefinitionOptions, useTransformFeedback); + } + const programLibrary = getProgramLibrary(device); + let shader = programLibrary.getCachedShader(uniqueName); + if (!shader) { + shader = new Shader(device, ShaderUtils.createDefinition(device, _extends({}, shaderDefinitionOptions, { + name: uniqueName, + vertexCode: vsCode2, + fragmentCode: fsCode, + attributes + }))); + programLibrary.setCachedShader(uniqueName, shader); + } + return shader; +} +var ShaderGeneratorPassThrough = class extends ShaderGenerator { + constructor(key, shaderDefinition) { + super(); + this.key = key; + this.shaderDefinition = shaderDefinition; + } + generateKey(options) { + return this.key; + } + createShaderDefinition(device, options) { + return this.shaderDefinition; + } +}; +function processShader(shader, processingOptions) { + var _shaderDefinition$nam; + const shaderDefinition = shader.definition; + const name = (_shaderDefinition$nam = shaderDefinition.name) != null ? _shaderDefinition$nam : "shader"; + const key = `${name}-id-${shader.id}`; + const materialGenerator = new ShaderGeneratorPassThrough(key, shaderDefinition); + const libraryModuleName = "shader"; + const library = getProgramLibrary(shader.device); + library.register(libraryModuleName, materialGenerator); + const variant = library.getProgram(libraryModuleName, {}, processingOptions); + if (shader.definition.shaderLanguage === SHADERLANGUAGE_WGSL) { + variant.meshUniformBufferFormat = shaderDefinition.meshUniformBufferFormat; + variant.meshBindGroupFormat = shaderDefinition.meshBindGroupFormat; + } + library.unregister(libraryModuleName); + return variant; +} +shaderChunks.createShader = createShader; +shaderChunks.createShaderFromCode = createShaderFromCode; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/graphics/quad-render.js +var _quadPrimitive = { + type: PRIMITIVE_TRISTRIP, + base: 0, + count: 4, + indexed: false +}; +var _tempViewport = new Vec4(); +var _tempScissor = new Vec4(); +var QuadRender = class { + constructor(shader) { + this.uniformBuffer = void 0; + this.bindGroup = void 0; + const device = shader.device; + this.shader = shader; + if (device.supportsUniformBuffers) { + const processingOptions = new ShaderProcessorOptions(); + this.shader = processShader(shader, processingOptions); + const ubFormat = this.shader.meshUniformBufferFormat; + if (ubFormat) { + this.uniformBuffer = new UniformBuffer(device, ubFormat, false); + } + const bindGroupFormat = this.shader.meshBindGroupFormat; + this.bindGroup = new BindGroup(device, bindGroupFormat, this.uniformBuffer); + } + } + destroy() { + var _this$uniformBuffer, _this$bindGroup; + (_this$uniformBuffer = this.uniformBuffer) == null || _this$uniformBuffer.destroy(); + this.uniformBuffer = null; + (_this$bindGroup = this.bindGroup) == null || _this$bindGroup.destroy(); + this.bindGroup = null; + } + render(viewport, scissor) { + const device = this.shader.device; + if (viewport) { + var _scissor2; + _tempViewport.set(device.vx, device.vy, device.vw, device.vh); + _tempScissor.set(device.sx, device.sy, device.sw, device.sh); + scissor = (_scissor2 = scissor) != null ? _scissor2 : viewport; + device.setViewport(viewport.x, viewport.y, viewport.z, viewport.w); + device.setScissor(scissor.x, scissor.y, scissor.z, scissor.w); + } + device.setVertexBuffer(device.quadVertexBuffer, 0); + const shader = this.shader; + device.setShader(shader); + if (device.supportsUniformBuffers) { + var _bindGroup$defaultUni; + const bindGroup = this.bindGroup; + (_bindGroup$defaultUni = bindGroup.defaultUniformBuffer) == null || _bindGroup$defaultUni.update(); + bindGroup.update(); + device.setBindGroup(BINDGROUP_MESH, bindGroup); + } + device.draw(_quadPrimitive); + if (viewport) { + device.setViewport(_tempViewport.x, _tempViewport.y, _tempViewport.z, _tempViewport.w); + device.setScissor(_tempScissor.x, _tempScissor.y, _tempScissor.z, _tempScissor.w); + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/graphics/render-pass-quad.js +var RenderPassQuad = class extends RenderPass { + constructor(device, quad, rect, scissorRect) { + super(device); + this.quad = quad; + this.rect = rect; + this.scissorRect = scissorRect; + } + execute() { + const { + device + } = this; + device.setCullMode(CULLFACE_NONE); + device.setDepthState(DepthState.NODEPTH); + device.setStencilState(null, null); + this.quad.render(this.rect, this.scissorRect); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/graphics/quad-render-utils.js +var _tempRect = new Vec4(); +function drawQuadWithShader(device, target2, shader, rect, scissorRect) { + const quad = new QuadRender(shader); + if (!rect) { + rect = _tempRect; + rect.x = 0; + rect.y = 0; + rect.z = target2 ? target2.width : device.width; + rect.w = target2 ? target2.height : device.height; + } + const renderPass = new RenderPassQuad(device, quad, rect, scissorRect); + renderPass.init(target2); + renderPass.colorOps.clear = false; + renderPass.depthStencilOps.clearDepth = false; + if (device.isWebGPU && target2 === null && device.samples > 1) { + renderPass.colorOps.store = true; + } + renderPass.render(); + quad.destroy(); +} + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-pass.js +var shaderPassDeviceCache = new DeviceCache(); +var ShaderPassInfo = class { + constructor(name, index, options = {}) { + this.index = void 0; + this.name = void 0; + this.shaderDefines = void 0; + this.name = name; + this.index = index; + Object.assign(this, options); + this.shaderDefines = this.buildShaderDefines(); + } + buildShaderDefines() { + let keyword; + if (this.isShadow) { + keyword = "SHADOW"; + } else if (this.isForward) { + keyword = "FORWARD"; + } else if (this.index === SHADER_DEPTH) { + keyword = "DEPTH"; + } else if (this.index === SHADER_PICK) { + keyword = "PICK"; + } + const define1 = keyword ? `#define ${keyword}_PASS +` : ""; + const define2 = `#define ${this.name.toUpperCase()}_PASS +`; + return define1 + define2; + } +}; +var ShaderPass = class _ShaderPass { + constructor() { + this.passesNamed = /* @__PURE__ */ new Map(); + this.passesIndexed = []; + this.nextIndex = 0; + const add = (name, index, options) => { + this.allocate(name, options); + }; + add("forward", SHADER_FORWARD, { + isForward: true + }); + add("forward_hdr", SHADER_FORWARDHDR, { + isForward: true + }); + add("depth"); + add("pick"); + add("shadow"); + add("prepass"); + } + static get(device) { + return shaderPassDeviceCache.get(device, () => { + return new _ShaderPass(); + }); + } + allocate(name, options) { + let info = this.passesNamed.get(name); + if (info === void 0) { + info = new ShaderPassInfo(name, this.nextIndex, options); + this.passesNamed.set(info.name, info); + this.passesIndexed[info.index] = info; + this.nextIndex++; + } + return info; + } + getByIndex(index) { + const info = this.passesIndexed[index]; + return info; + } + getByName(name) { + return this.passesNamed.get(name); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/programs/basic.js +var vShader = ` + + #include "shaderPassDefines" + #include "transformDeclVS" + + #ifdef SKIN + #include "skinCode" + #endif + + #include "transformVS" + + #ifdef VERTEX_COLORS + attribute vec4 vertex_color; + varying vec4 vColor; + #endif + + #ifdef DIFFUSE_MAP + attribute vec2 vertex_texCoord0; + varying vec2 vUv0; + #endif + + #ifdef DEPTH_PASS + varying float vDepth; + + #ifndef VIEWMATRIX + #define VIEWMATRIX + uniform mat4 matrix_view; + #endif + + #ifndef CAMERAPLANES + #define CAMERAPLANES + uniform vec4 camera_params; + #endif + #endif + + void main(void) { + gl_Position = getPosition(); + + #ifdef DEPTH_PASS + vDepth = -(matrix_view * vec4(getWorldPosition(),1.0)).z * camera_params.x; + #endif + + #ifdef VERTEX_COLORS + vColor = vertex_color; + #endif + + #ifdef DIFFUSE_MAP + vUv0 = vertex_texCoord0; + #endif + } +`; +var fShader = ` + + #include "shaderPassDefines" + + #ifdef VERTEX_COLORS + varying vec4 vColor; + #else + uniform vec4 uColor; + #endif + + #ifdef DIFFUSE_MAP + varying vec2 vUv0; + uniform sampler2D texture_diffuseMap; + #endif + + #ifdef FOG + #include "fogCode" + #endif + + #ifdef ALPHA_TEST + #include "alphaTestPS" + #endif + + #ifdef DEPTH_PASS + varying float vDepth; + #include "packDepthPS" + #endif + + void main(void) { + + #ifdef VERTEX_COLORS + gl_FragColor = vColor; + #else + gl_FragColor = uColor; + #endif + + #ifdef DIFFUSE_MAP + gl_FragColor *= texture2D(texture_diffuseMap, vUv0); + #endif + + #ifdef ALPHA_TEST + alphaTest(gl_FragColor.a); + #endif + + #ifndef PICK_PASS + + #ifdef DEPTH_PASS + gl_FragColor = packFloat(vDepth); + #else + #ifdef FOG + glFragColor.rgb = addFog(gl_FragColor.rgb); + #endif + #endif + #endif + } +`; +var ShaderGeneratorBasic = class extends ShaderGenerator { + generateKey(options) { + let key = "basic"; + if (options.fog) key += "_fog"; + if (options.alphaTest) key += "_atst"; + if (options.vertexColors) key += "_vcol"; + if (options.diffuseMap) key += "_diff"; + if (options.skin) key += "_skin"; + if (options.screenSpace) key += "_ss"; + if (options.useInstancing) key += "_inst"; + if (options.useMorphPosition) key += "_morphp"; + if (options.useMorphNormal) key += "_morphn"; + if (options.useMorphTextureBased) key += "_morpht"; + key += "_" + options.pass; + return key; + } + createAttributesDefinition(definitionOptions, options) { + const attributes = { + vertex_position: SEMANTIC_POSITION + }; + if (options.skin) { + attributes.vertex_boneWeights = SEMANTIC_BLENDWEIGHT; + attributes.vertex_boneIndices = SEMANTIC_BLENDINDICES; + } + if (options.vertexColors) { + attributes.vertex_color = SEMANTIC_COLOR; + } + if (options.diffuseMap) { + attributes.vertex_texCoord0 = SEMANTIC_TEXCOORD0; + } + definitionOptions.attributes = attributes; + } + createVertexDefinition(device, definitionOptions, options, shaderPassInfo) { + const includes = /* @__PURE__ */ new Map(); + const defines = /* @__PURE__ */ new Map(); + includes.set("shaderPassDefines", shaderPassInfo.shaderDefines); + includes.set("transformDeclVS", shaderChunks.transformDeclVS); + includes.set("transformVS", shaderChunks.transformVS); + includes.set("skinCode", ShaderGenerator.skinCode(device)); + if (options.skin) defines.set("SKIN", true); + if (options.vertexColors) defines.set("VERTEX_COLORS", true); + if (options.diffuseMap) defines.set("DIFFUSE_MAP", true); + definitionOptions.vertexCode = vShader; + definitionOptions.vertexIncludes = includes; + definitionOptions.vertexDefines = defines; + } + createFragmentDefinition(definitionOptions, options, shaderPassInfo) { + const includes = /* @__PURE__ */ new Map(); + const defines = /* @__PURE__ */ new Map(); + includes.set("shaderPassDefines", shaderPassInfo.shaderDefines); + includes.set("fogCode", ShaderGenerator.fogCode(options.fog)); + includes.set("alphaTestPS", shaderChunks.alphaTestPS); + includes.set("packDepthPS", shaderChunks.packDepthPS); + if (options.vertexColors) defines.set("VERTEX_COLORS", true); + if (options.diffuseMap) defines.set("DIFFUSE_MAP", true); + if (options.fog) defines.set("FOG", true); + if (options.alphaTest) defines.set("ALPHA_TEST", true); + definitionOptions.fragmentCode = fShader; + definitionOptions.fragmentIncludes = includes; + definitionOptions.fragmentDefines = defines; + } + createShaderDefinition(device, options) { + const definitionOptions = { + name: "BasicShader" + }; + const shaderPassInfo = ShaderPass.get(device).getByIndex(options.pass); + this.createAttributesDefinition(definitionOptions, options); + this.createVertexDefinition(device, definitionOptions, options, shaderPassInfo); + this.createFragmentDefinition(definitionOptions, options, shaderPassInfo); + return ShaderUtils.createDefinition(device, definitionOptions); + } +}; +var basic = new ShaderGeneratorBasic(); + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/materials/default-material.js +var defaultMaterialDeviceCache = new DeviceCache(); +function getDefaultMaterial(device) { + const material = defaultMaterialDeviceCache.get(device); + return material; +} +function setDefaultMaterial(device, material) { + defaultMaterialDeviceCache.get(device, () => { + return material; + }); +} + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/materials/material.js +var blendModes = []; +blendModes[BLEND_SUBTRACTIVE] = { + src: BLENDMODE_ONE, + dst: BLENDMODE_ONE, + op: BLENDEQUATION_REVERSE_SUBTRACT +}; +blendModes[BLEND_NONE] = { + src: BLENDMODE_ONE, + dst: BLENDMODE_ZERO, + op: BLENDEQUATION_ADD +}; +blendModes[BLEND_NORMAL] = { + src: BLENDMODE_SRC_ALPHA, + dst: BLENDMODE_ONE_MINUS_SRC_ALPHA, + op: BLENDEQUATION_ADD +}; +blendModes[BLEND_PREMULTIPLIED] = { + src: BLENDMODE_ONE, + dst: BLENDMODE_ONE_MINUS_SRC_ALPHA, + op: BLENDEQUATION_ADD +}; +blendModes[BLEND_ADDITIVE] = { + src: BLENDMODE_ONE, + dst: BLENDMODE_ONE, + op: BLENDEQUATION_ADD +}; +blendModes[BLEND_ADDITIVEALPHA] = { + src: BLENDMODE_SRC_ALPHA, + dst: BLENDMODE_ONE, + op: BLENDEQUATION_ADD +}; +blendModes[BLEND_MULTIPLICATIVE2X] = { + src: BLENDMODE_DST_COLOR, + dst: BLENDMODE_SRC_COLOR, + op: BLENDEQUATION_ADD +}; +blendModes[BLEND_SCREEN] = { + src: BLENDMODE_ONE_MINUS_DST_COLOR, + dst: BLENDMODE_ONE, + op: BLENDEQUATION_ADD +}; +blendModes[BLEND_MULTIPLICATIVE] = { + src: BLENDMODE_DST_COLOR, + dst: BLENDMODE_ZERO, + op: BLENDEQUATION_ADD +}; +blendModes[BLEND_MIN] = { + src: BLENDMODE_ONE, + dst: BLENDMODE_ONE, + op: BLENDEQUATION_MIN +}; +blendModes[BLEND_MAX] = { + src: BLENDMODE_ONE, + dst: BLENDMODE_ONE, + op: BLENDEQUATION_MAX +}; +var id8 = 0; +var Material = class { + constructor() { + this._shader = null; + this.meshInstances = []; + this.name = "Untitled"; + this.userId = ""; + this.id = id8++; + this.variants = /* @__PURE__ */ new Map(); + this.parameters = {}; + this.alphaTest = 0; + this.alphaToCoverage = false; + this._blendState = new BlendState(); + this._depthState = new DepthState(); + this.cull = CULLFACE_BACK; + this.stencilFront = null; + this.stencilBack = null; + this._shaderVersion = 0; + this._scene = null; + this.dirty = true; + } + set depthBias(value) { + this._depthState.depthBias = value; + } + get depthBias() { + return this._depthState.depthBias; + } + set slopeDepthBias(value) { + this._depthState.depthBiasSlope = value; + } + get slopeDepthBias() { + return this._depthState.depthBiasSlope; + } + set redWrite(value) { + this._blendState.redWrite = value; + } + get redWrite() { + return this._blendState.redWrite; + } + set greenWrite(value) { + this._blendState.greenWrite = value; + } + get greenWrite() { + return this._blendState.greenWrite; + } + set blueWrite(value) { + this._blendState.blueWrite = value; + } + get blueWrite() { + return this._blendState.blueWrite; + } + set alphaWrite(value) { + this._blendState.alphaWrite = value; + } + get alphaWrite() { + return this._blendState.alphaWrite; + } + set shader(shader) { + this._shader = shader; + } + get shader() { + return this._shader; + } + get transparent() { + return this._blendState.blend; + } + _updateTransparency() { + const transparent = this.transparent; + const meshInstances = this.meshInstances; + for (let i = 0; i < meshInstances.length; i++) { + meshInstances[i].transparent = transparent; + } + } + set blendState(value) { + this._blendState.copy(value); + this._updateTransparency(); + } + get blendState() { + return this._blendState; + } + set blendType(type2) { + const blendMode = blendModes[type2]; + this._blendState.setColorBlend(blendMode.op, blendMode.src, blendMode.dst); + this._blendState.setAlphaBlend(blendMode.op, blendMode.src, blendMode.dst); + const blend = type2 !== BLEND_NONE; + if (this._blendState.blend !== blend) { + this._blendState.blend = blend; + this._updateTransparency(); + } + this._updateMeshInstanceKeys(); + } + get blendType() { + if (!this.transparent) { + return BLEND_NONE; + } + const { + colorOp, + colorSrcFactor, + colorDstFactor, + alphaOp, + alphaSrcFactor, + alphaDstFactor + } = this._blendState; + for (let i = 0; i < blendModes.length; i++) { + const blendMode = blendModes[i]; + if (blendMode.src === colorSrcFactor && blendMode.dst === colorDstFactor && blendMode.op === colorOp && blendMode.src === alphaSrcFactor && blendMode.dst === alphaDstFactor && blendMode.op === alphaOp) { + return i; + } + } + return BLEND_NORMAL; + } + set depthState(value) { + this._depthState.copy(value); + } + get depthState() { + return this._depthState; + } + set depthTest(value) { + this._depthState.test = value; + } + get depthTest() { + return this._depthState.test; + } + set depthFunc(value) { + this._depthState.func = value; + } + get depthFunc() { + return this._depthState.func; + } + set depthWrite(value) { + this._depthState.write = value; + } + get depthWrite() { + return this._depthState.write; + } + copy(source) { + var _source$stencilFront; + this.name = source.name; + this._shader = source._shader; + this.alphaTest = source.alphaTest; + this.alphaToCoverage = source.alphaToCoverage; + this._blendState.copy(source._blendState); + this._depthState.copy(source._depthState); + this.cull = source.cull; + this.stencilFront = (_source$stencilFront = source.stencilFront) == null ? void 0 : _source$stencilFront.clone(); + if (source.stencilBack) { + this.stencilBack = source.stencilFront === source.stencilBack ? this.stencilFront : source.stencilBack.clone(); + } + return this; + } + clone() { + const clone = new this.constructor(); + return clone.copy(this); + } + _updateMeshInstanceKeys() { + const meshInstances = this.meshInstances; + for (let i = 0; i < meshInstances.length; i++) { + meshInstances[i].updateKey(); + } + } + updateUniforms(device, scene2) { + } + getShaderVariant(device, scene2, objDefs, unused, pass, sortedLights, viewUniformFormat, viewBindGroupFormat, vertexFormat) { + const processingOptions = new ShaderProcessorOptions(viewUniformFormat, viewBindGroupFormat, vertexFormat); + return processShader(this._shader, processingOptions); + } + update() { + this.dirty = true; + if (this._shader) this._shader.failed = false; + } + clearParameters() { + this.parameters = {}; + } + getParameters() { + return this.parameters; + } + clearVariants() { + this.variants.clear(); + const meshInstances = this.meshInstances; + const count = meshInstances.length; + for (let i = 0; i < count; i++) { + meshInstances[i].clearShaders(); + } + } + getParameter(name) { + return this.parameters[name]; + } + setParameter(name, data2) { + if (data2 === void 0 && typeof name === "object") { + const uniformObject = name; + if (uniformObject.length) { + for (let i = 0; i < uniformObject.length; i++) { + this.setParameter(uniformObject[i]); + } + return; + } + name = uniformObject.name; + data2 = uniformObject.value; + } + const param = this.parameters[name]; + if (param) { + param.data = data2; + } else { + this.parameters[name] = { + scopeId: null, + data: data2 + }; + } + } + deleteParameter(name) { + if (this.parameters[name]) { + delete this.parameters[name]; + } + } + setParameters(device, names) { + const parameters = this.parameters; + if (names === void 0) names = parameters; + for (const paramName in names) { + const parameter = parameters[paramName]; + if (parameter) { + if (!parameter.scopeId) { + parameter.scopeId = device.scope.resolve(paramName); + } + parameter.scopeId.setValue(parameter.data); + } + } + } + destroy() { + this.variants.clear(); + this._shader = null; + for (let i = 0; i < this.meshInstances.length; i++) { + const meshInstance = this.meshInstances[i]; + meshInstance.clearShaders(); + meshInstance._material = null; + if (meshInstance.mesh) { + const defaultMaterial = getDefaultMaterial(meshInstance.mesh.device); + if (this !== defaultMaterial) { + meshInstance.material = defaultMaterial; + } + } + } + this.meshInstances.length = 0; + } + addMeshInstanceRef(meshInstance) { + this.meshInstances.push(meshInstance); + } + removeMeshInstanceRef(meshInstance) { + const meshInstances = this.meshInstances; + const i = meshInstances.indexOf(meshInstance); + if (i !== -1) { + meshInstances.splice(i, 1); + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/materials/basic-material.js +var BasicMaterial = class extends Material { + constructor(...args) { + super(...args); + this.color = new Color(1, 1, 1, 1); + this.colorUniform = new Float32Array(4); + this.colorMap = null; + this.vertexColors = false; + } + copy(source) { + super.copy(source); + this.color.copy(source.color); + this.colorMap = source.colorMap; + this.vertexColors = source.vertexColors; + return this; + } + updateUniforms(device, scene2) { + this.clearParameters(); + this.colorUniform[0] = this.color.r; + this.colorUniform[1] = this.color.g; + this.colorUniform[2] = this.color.b; + this.colorUniform[3] = this.color.a; + this.setParameter("uColor", this.colorUniform); + if (this.colorMap) { + this.setParameter("texture_diffuseMap", this.colorMap); + } + } + getShaderVariant(device, scene2, objDefs, unused, pass, sortedLights, viewUniformFormat, viewBindGroupFormat, vertexFormat) { + const options = { + skin: objDefs && (objDefs & SHADERDEF_SKIN) !== 0, + screenSpace: objDefs && (objDefs & SHADERDEF_SCREENSPACE) !== 0, + useInstancing: objDefs && (objDefs & SHADERDEF_INSTANCING) !== 0, + useMorphPosition: objDefs && (objDefs & SHADERDEF_MORPH_POSITION) !== 0, + useMorphNormal: objDefs && (objDefs & SHADERDEF_MORPH_NORMAL) !== 0, + useMorphTextureBased: objDefs && (objDefs & SHADERDEF_MORPH_TEXTURE_BASED) !== 0, + alphaTest: this.alphaTest > 0, + vertexColors: this.vertexColors, + diffuseMap: !!this.colorMap, + pass + }; + const processingOptions = new ShaderProcessorOptions(viewUniformFormat, viewBindGroupFormat, vertexFormat); + const library = getProgramLibrary(device); + library.register("basic", basic); + return library.getProgram("basic", options, processingOptions, this.userId); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/batching/batch.js +var Batch = class { + constructor(meshInstances, dynamic, batchGroupId) { + this._aabb = new BoundingBox(); + this.origMeshInstances = void 0; + this.meshInstance = null; + this.dynamic = void 0; + this.batchGroupId = void 0; + this.origMeshInstances = meshInstances; + this.dynamic = dynamic; + this.batchGroupId = batchGroupId; + } + destroy(scene2, layers) { + if (this.meshInstance) { + this.removeFromLayers(scene2, layers); + this.meshInstance.destroy(); + this.meshInstance = null; + } + } + addToLayers(scene2, layers) { + for (let i = 0; i < layers.length; i++) { + const layer = scene2.layers.getLayerById(layers[i]); + if (layer) { + layer.addMeshInstances([this.meshInstance]); + } + } + } + removeFromLayers(scene2, layers) { + for (let i = 0; i < layers.length; i++) { + const layer = scene2.layers.getLayerById(layers[i]); + if (layer) { + layer.removeMeshInstances([this.meshInstance]); + } + } + } + updateBoundingBox() { + this._aabb.copy(this.origMeshInstances[0].aabb); + for (let i = 1; i < this.origMeshInstances.length; i++) { + this._aabb.add(this.origMeshInstances[i].aabb); + } + this.meshInstance.aabb = this._aabb; + this.meshInstance._aabbVer = 0; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/batching/batch-group.js +var BatchGroup = class { + constructor(id12, name, dynamic, maxAabbSize, layers = [LAYERID_WORLD]) { + this._ui = false; + this._sprite = false; + this._obj = { + model: [], + element: [], + sprite: [], + render: [] + }; + this.id = void 0; + this.name = void 0; + this.dynamic = void 0; + this.maxAabbSize = void 0; + this.layers = void 0; + this.id = id12; + this.name = name; + this.dynamic = dynamic; + this.maxAabbSize = maxAabbSize; + this.layers = layers; + } +}; +BatchGroup.MODEL = "model"; +BatchGroup.ELEMENT = "element"; +BatchGroup.SPRITE = "sprite"; +BatchGroup.RENDER = "render"; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/skin-instance.js +var _invMatrix = new Mat4(); +var SkinInstance = class { + constructor(skin) { + this.bones = void 0; + this.boneTextureSize = void 0; + this._dirty = true; + this._rootBone = null; + this._skinUpdateIndex = -1; + this._updateBeforeCull = true; + if (skin) { + this.initSkin(skin); + } + } + set rootBone(rootBone) { + this._rootBone = rootBone; + } + get rootBone() { + return this._rootBone; + } + init(device, numBones) { + if (device.supportsBoneTextures) { + const numPixels = numBones * 3; + let width = Math.ceil(Math.sqrt(numPixels)); + width = math.roundUp(width, 3); + const height = Math.ceil(numPixels / width); + this.boneTexture = new Texture(device, { + width, + height, + format: PIXELFORMAT_RGBA32F, + mipmaps: false, + minFilter: FILTER_NEAREST, + magFilter: FILTER_NEAREST, + name: "skin" + }); + this.boneTextureSize = [width, height, 1 / width, 1 / height]; + this.matrixPalette = this.boneTexture.lock({ + mode: TEXTURELOCK_READ + }); + this.boneTexture.unlock(); + } else { + this.matrixPalette = new Float32Array(numBones * 12); + } + } + destroy() { + if (this.boneTexture) { + this.boneTexture.destroy(); + this.boneTexture = null; + } + } + resolve(rootBone, entity) { + this.rootBone = rootBone; + const skin = this.skin; + const bones = []; + for (let j = 0; j < skin.boneNames.length; j++) { + const boneName = skin.boneNames[j]; + let bone = rootBone.findByName(boneName); + if (!bone) { + bone = entity; + } + bones.push(bone); + } + this.bones = bones; + } + initSkin(skin) { + this.skin = skin; + this.bones = []; + const numBones = skin.inverseBindPose.length; + this.init(skin.device, numBones); + this.matrices = []; + for (let i = 0; i < numBones; i++) { + this.matrices[i] = new Mat4(); + } + } + uploadBones(device) { + if (device.supportsBoneTextures) { + this.boneTexture.lock(); + this.boneTexture.unlock(); + } + } + _updateMatrices(rootNode, skinUpdateIndex) { + if (this._skinUpdateIndex !== skinUpdateIndex) { + this._skinUpdateIndex = skinUpdateIndex; + _invMatrix.copy(rootNode.getWorldTransform()).invert(); + for (let i = this.bones.length - 1; i >= 0; i--) { + this.matrices[i].mulAffine2(_invMatrix, this.bones[i].getWorldTransform()); + this.matrices[i].mulAffine2(this.matrices[i], this.skin.inverseBindPose[i]); + } + } + } + updateMatrices(rootNode, skinUpdateIndex) { + if (this._updateBeforeCull) { + this._updateMatrices(rootNode, skinUpdateIndex); + } + } + updateMatrixPalette(rootNode, skinUpdateIndex) { + this._updateMatrices(rootNode, skinUpdateIndex); + const mp = this.matrixPalette; + const count = this.bones.length; + for (let i = 0; i < count; i++) { + const pe = this.matrices[i].data; + const base = i * 12; + mp[base] = pe[0]; + mp[base + 1] = pe[4]; + mp[base + 2] = pe[8]; + mp[base + 3] = pe[12]; + mp[base + 4] = pe[1]; + mp[base + 5] = pe[5]; + mp[base + 6] = pe[9]; + mp[base + 7] = pe[13]; + mp[base + 8] = pe[2]; + mp[base + 9] = pe[6]; + mp[base + 10] = pe[10]; + mp[base + 11] = pe[14]; + } + this.uploadBones(this.skin.device); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/core/ref-counted-object.js +var RefCountedObject = class { + constructor() { + this._refCount = 0; + } + incRefCount() { + this._refCount++; + } + decRefCount() { + this._refCount--; + } + get refCount() { + return this._refCount; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/mesh.js +var id9 = 0; +var GeometryData = class { + constructor() { + this.initDefaults(); + } + initDefaults() { + this.recreate = false; + this.verticesUsage = BUFFER_STATIC; + this.indicesUsage = BUFFER_STATIC; + this.maxVertices = 0; + this.maxIndices = 0; + this.vertexCount = 0; + this.indexCount = 0; + this.vertexStreamsUpdated = false; + this.indexStreamUpdated = false; + this.vertexStreamDictionary = {}; + this.indices = null; + } + _changeVertexCount(count, semantic) { + if (!this.vertexCount) { + this.vertexCount = count; + } + } +}; +GeometryData.DEFAULT_COMPONENTS_POSITION = 3; +GeometryData.DEFAULT_COMPONENTS_NORMAL = 3; +GeometryData.DEFAULT_COMPONENTS_UV = 2; +GeometryData.DEFAULT_COMPONENTS_COLORS = 4; +var GeometryVertexStream = class { + constructor(data2, componentCount, dataType, dataTypeNormalize, asInt) { + this.data = data2; + this.componentCount = componentCount; + this.dataType = dataType; + this.dataTypeNormalize = dataTypeNormalize; + this.asInt = asInt; + } +}; +var Mesh = class _Mesh extends RefCountedObject { + constructor(graphicsDevice, options) { + super(); + this._aabbVer = 0; + this._aabb = new BoundingBox(); + this._storageVertex = false; + this._storageIndex = false; + this.id = id9++; + this.device = graphicsDevice; + this._storageIndex = (options == null ? void 0 : options.storageIndex) || false; + this._storageVertex = (options == null ? void 0 : options.storageVertex) || false; + this.vertexBuffer = null; + this.indexBuffer = [null]; + this.primitive = [{ + type: 0, + base: 0, + count: 0 + }]; + this.skin = null; + this._morph = null; + this._geometryData = null; + this.boneAabb = null; + } + static fromGeometry(graphicsDevice, geometry, options = {}) { + const mesh = new _Mesh(graphicsDevice, options); + const { + positions, + normals, + tangents, + colors, + uvs, + uvs1, + blendIndices, + blendWeights, + indices + } = geometry; + if (positions) { + mesh.setPositions(positions); + } + if (normals) { + mesh.setNormals(normals); + } + if (tangents) { + mesh.setVertexStream(SEMANTIC_TANGENT, tangents, 4); + } + if (colors) { + mesh.setColors32(colors); + } + if (uvs) { + mesh.setUvs(0, uvs); + } + if (uvs1) { + mesh.setUvs(1, uvs1); + } + if (blendIndices) { + mesh.setVertexStream(SEMANTIC_BLENDINDICES, blendIndices, 4, blendIndices.length / 4, TYPE_UINT8); + } + if (blendWeights) { + mesh.setVertexStream(SEMANTIC_BLENDWEIGHT, blendWeights, 4); + } + if (indices) { + mesh.setIndices(indices); + } + mesh.update(); + return mesh; + } + set morph(morph) { + if (morph !== this._morph) { + if (this._morph) { + this._morph.decRefCount(); + } + this._morph = morph; + if (morph) { + morph.incRefCount(); + } + } + } + get morph() { + return this._morph; + } + set aabb(aabb) { + this._aabb = aabb; + this._aabbVer++; + } + get aabb() { + return this._aabb; + } + destroy() { + const morph = this.morph; + if (morph) { + this.morph = null; + if (morph.refCount < 1) { + morph.destroy(); + } + } + if (this.vertexBuffer) { + this.vertexBuffer.destroy(); + this.vertexBuffer = null; + } + for (let j = 0; j < this.indexBuffer.length; j++) { + this._destroyIndexBuffer(j); + } + this.indexBuffer.length = 0; + this._geometryData = null; + } + _destroyIndexBuffer(index) { + if (this.indexBuffer[index]) { + this.indexBuffer[index].destroy(); + this.indexBuffer[index] = null; + } + } + _initBoneAabbs(morphTargets) { + this.boneAabb = []; + this.boneUsed = []; + let x2, y2, z2; + let bMax, bMin; + const boneMin = []; + const boneMax = []; + const boneUsed = this.boneUsed; + const numBones = this.skin.boneNames.length; + let maxMorphX, maxMorphY, maxMorphZ; + for (let i = 0; i < numBones; i++) { + boneMin[i] = new Vec3(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE); + boneMax[i] = new Vec3(-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE); + } + const iterator = new VertexIterator(this.vertexBuffer); + const posElement = iterator.element[SEMANTIC_POSITION]; + const weightsElement = iterator.element[SEMANTIC_BLENDWEIGHT]; + const indicesElement = iterator.element[SEMANTIC_BLENDINDICES]; + const numVerts = this.vertexBuffer.numVertices; + for (let j = 0; j < numVerts; j++) { + for (let k = 0; k < 4; k++) { + const boneWeight = weightsElement.array[weightsElement.index + k]; + if (boneWeight > 0) { + const boneIndex = indicesElement.array[indicesElement.index + k]; + boneUsed[boneIndex] = true; + x2 = posElement.array[posElement.index]; + y2 = posElement.array[posElement.index + 1]; + z2 = posElement.array[posElement.index + 2]; + bMax = boneMax[boneIndex]; + bMin = boneMin[boneIndex]; + if (bMin.x > x2) bMin.x = x2; + if (bMin.y > y2) bMin.y = y2; + if (bMin.z > z2) bMin.z = z2; + if (bMax.x < x2) bMax.x = x2; + if (bMax.y < y2) bMax.y = y2; + if (bMax.z < z2) bMax.z = z2; + if (morphTargets) { + let minMorphX = maxMorphX = x2; + let minMorphY = maxMorphY = y2; + let minMorphZ = maxMorphZ = z2; + for (let l = 0; l < morphTargets.length; l++) { + const target2 = morphTargets[l]; + const dx = target2.deltaPositions[j * 3]; + const dy = target2.deltaPositions[j * 3 + 1]; + const dz = target2.deltaPositions[j * 3 + 2]; + if (dx < 0) { + minMorphX += dx; + } else { + maxMorphX += dx; + } + if (dy < 0) { + minMorphY += dy; + } else { + maxMorphY += dy; + } + if (dz < 0) { + minMorphZ += dz; + } else { + maxMorphZ += dz; + } + } + if (bMin.x > minMorphX) bMin.x = minMorphX; + if (bMin.y > minMorphY) bMin.y = minMorphY; + if (bMin.z > minMorphZ) bMin.z = minMorphZ; + if (bMax.x < maxMorphX) bMax.x = maxMorphX; + if (bMax.y < maxMorphY) bMax.y = maxMorphY; + if (bMax.z < maxMorphZ) bMax.z = maxMorphZ; + } + } + } + iterator.next(); + } + const positionElement = this.vertexBuffer.getFormat().elements.find((e) => e.name === SEMANTIC_POSITION); + if (positionElement && positionElement.normalize) { + const func = (() => { + switch (positionElement.dataType) { + case TYPE_INT8: + return (x3) => Math.max(x3 / 127, -1); + case TYPE_UINT8: + return (x3) => x3 / 255; + case TYPE_INT16: + return (x3) => Math.max(x3 / 32767, -1); + case TYPE_UINT16: + return (x3) => x3 / 65535; + default: + return (x3) => x3; + } + })(); + for (let i = 0; i < numBones; i++) { + if (boneUsed[i]) { + const min = boneMin[i]; + const max = boneMax[i]; + min.set(func(min.x), func(min.y), func(min.z)); + max.set(func(max.x), func(max.y), func(max.z)); + } + } + } + for (let i = 0; i < numBones; i++) { + const aabb = new BoundingBox(); + aabb.setMinMax(boneMin[i], boneMax[i]); + this.boneAabb.push(aabb); + } + } + _initGeometryData() { + if (!this._geometryData) { + this._geometryData = new GeometryData(); + if (this.vertexBuffer) { + this._geometryData.vertexCount = this.vertexBuffer.numVertices; + this._geometryData.maxVertices = this.vertexBuffer.numVertices; + } + if (this.indexBuffer.length > 0 && this.indexBuffer[0]) { + this._geometryData.indexCount = this.indexBuffer[0].numIndices; + this._geometryData.maxIndices = this.indexBuffer[0].numIndices; + } + } + } + clear(verticesDynamic, indicesDynamic, maxVertices = 0, maxIndices = 0) { + this._initGeometryData(); + this._geometryData.initDefaults(); + this._geometryData.recreate = true; + this._geometryData.maxVertices = maxVertices; + this._geometryData.maxIndices = maxIndices; + this._geometryData.verticesUsage = verticesDynamic ? BUFFER_STATIC : BUFFER_DYNAMIC; + this._geometryData.indicesUsage = indicesDynamic ? BUFFER_STATIC : BUFFER_DYNAMIC; + } + setVertexStream(semantic, data2, componentCount, numVertices, dataType = TYPE_FLOAT32, dataTypeNormalize = false, asInt = false) { + this._initGeometryData(); + const vertexCount = numVertices || data2.length / componentCount; + this._geometryData._changeVertexCount(vertexCount, semantic); + this._geometryData.vertexStreamsUpdated = true; + this._geometryData.vertexStreamDictionary[semantic] = new GeometryVertexStream(data2, componentCount, dataType, dataTypeNormalize, asInt); + } + getVertexStream(semantic, data2) { + let count = 0; + let done = false; + if (this._geometryData) { + const stream = this._geometryData.vertexStreamDictionary[semantic]; + if (stream) { + done = true; + count = this._geometryData.vertexCount; + if (ArrayBuffer.isView(data2)) { + data2.set(stream.data); + } else { + data2.length = 0; + data2.push(stream.data); + } + } + } + if (!done) { + if (this.vertexBuffer) { + const iterator = new VertexIterator(this.vertexBuffer); + count = iterator.readData(semantic, data2); + } + } + return count; + } + setPositions(positions, componentCount = GeometryData.DEFAULT_COMPONENTS_POSITION, numVertices) { + this.setVertexStream(SEMANTIC_POSITION, positions, componentCount, numVertices, TYPE_FLOAT32, false); + } + setNormals(normals, componentCount = GeometryData.DEFAULT_COMPONENTS_NORMAL, numVertices) { + this.setVertexStream(SEMANTIC_NORMAL, normals, componentCount, numVertices, TYPE_FLOAT32, false); + } + setUvs(channel, uvs, componentCount = GeometryData.DEFAULT_COMPONENTS_UV, numVertices) { + this.setVertexStream(SEMANTIC_TEXCOORD + channel, uvs, componentCount, numVertices, TYPE_FLOAT32, false); + } + setColors(colors, componentCount = GeometryData.DEFAULT_COMPONENTS_COLORS, numVertices) { + this.setVertexStream(SEMANTIC_COLOR, colors, componentCount, numVertices, TYPE_FLOAT32, false); + } + setColors32(colors, numVertices) { + this.setVertexStream(SEMANTIC_COLOR, colors, GeometryData.DEFAULT_COMPONENTS_COLORS, numVertices, TYPE_UINT8, true); + } + setIndices(indices, numIndices) { + this._initGeometryData(); + this._geometryData.indexStreamUpdated = true; + this._geometryData.indices = indices; + this._geometryData.indexCount = numIndices || indices.length; + } + getPositions(positions) { + return this.getVertexStream(SEMANTIC_POSITION, positions); + } + getNormals(normals) { + return this.getVertexStream(SEMANTIC_NORMAL, normals); + } + getUvs(channel, uvs) { + return this.getVertexStream(SEMANTIC_TEXCOORD + channel, uvs); + } + getColors(colors) { + return this.getVertexStream(SEMANTIC_COLOR, colors); + } + getIndices(indices) { + let count = 0; + if (this._geometryData && this._geometryData.indices) { + const streamIndices = this._geometryData.indices; + count = this._geometryData.indexCount; + if (ArrayBuffer.isView(indices)) { + indices.set(streamIndices); + } else { + indices.length = 0; + for (let i = 0, il = streamIndices.length; i < il; i++) { + indices.push(streamIndices[i]); + } + } + } else { + if (this.indexBuffer.length > 0 && this.indexBuffer[0]) { + const indexBuffer = this.indexBuffer[0]; + count = indexBuffer.readData(indices); + } + } + return count; + } + update(primitiveType = PRIMITIVE_TRIANGLES, updateBoundingBox = true) { + if (this._geometryData) { + if (updateBoundingBox) { + const stream = this._geometryData.vertexStreamDictionary[SEMANTIC_POSITION]; + if (stream) { + if (stream.componentCount === 3) { + this._aabb.compute(stream.data, this._geometryData.vertexCount); + this._aabbVer++; + } + } + } + let destroyVB = this._geometryData.recreate; + if (this._geometryData.vertexCount > this._geometryData.maxVertices) { + destroyVB = true; + this._geometryData.maxVertices = this._geometryData.vertexCount; + } + if (destroyVB) { + if (this.vertexBuffer) { + this.vertexBuffer.destroy(); + this.vertexBuffer = null; + } + } + let destroyIB = this._geometryData.recreate; + if (this._geometryData.indexCount > this._geometryData.maxIndices) { + destroyIB = true; + this._geometryData.maxIndices = this._geometryData.indexCount; + } + if (destroyIB) { + if (this.indexBuffer.length > 0 && this.indexBuffer[0]) { + this.indexBuffer[0].destroy(); + this.indexBuffer[0] = null; + } + } + if (this._geometryData.vertexStreamsUpdated) { + this._updateVertexBuffer(); + } + if (this._geometryData.indexStreamUpdated) { + this._updateIndexBuffer(); + } + this.primitive[0].type = primitiveType; + if (this.indexBuffer.length > 0 && this.indexBuffer[0]) { + if (this._geometryData.indexStreamUpdated) { + this.primitive[0].count = this._geometryData.indexCount; + this.primitive[0].indexed = true; + } + } else { + if (this._geometryData.vertexStreamsUpdated) { + this.primitive[0].count = this._geometryData.vertexCount; + this.primitive[0].indexed = false; + } + } + this._geometryData.vertexCount = 0; + this._geometryData.indexCount = 0; + this._geometryData.vertexStreamsUpdated = false; + this._geometryData.indexStreamUpdated = false; + this._geometryData.recreate = false; + this.updateRenderStates(); + } + } + _buildVertexFormat(vertexCount) { + const vertexDesc = []; + for (const semantic in this._geometryData.vertexStreamDictionary) { + const stream = this._geometryData.vertexStreamDictionary[semantic]; + vertexDesc.push({ + semantic, + components: stream.componentCount, + type: stream.dataType, + normalize: stream.dataTypeNormalize, + asInt: stream.asInt + }); + } + return new VertexFormat(this.device, vertexDesc, vertexCount); + } + _updateVertexBuffer() { + if (!this.vertexBuffer) { + const allocateVertexCount = this._geometryData.maxVertices; + const format = this._buildVertexFormat(allocateVertexCount); + this.vertexBuffer = new VertexBuffer(this.device, format, allocateVertexCount, { + usage: this._geometryData.verticesUsage, + storage: this._storageVertex + }); + } + const iterator = new VertexIterator(this.vertexBuffer); + const numVertices = this._geometryData.vertexCount; + for (const semantic in this._geometryData.vertexStreamDictionary) { + const stream = this._geometryData.vertexStreamDictionary[semantic]; + iterator.writeData(semantic, stream.data, numVertices); + delete this._geometryData.vertexStreamDictionary[semantic]; + } + iterator.end(); + } + _updateIndexBuffer() { + if (this.indexBuffer.length <= 0 || !this.indexBuffer[0]) { + const maxVertices = this._geometryData.maxVertices; + const createFormat = maxVertices > 65535 || maxVertices === 0 ? INDEXFORMAT_UINT32 : INDEXFORMAT_UINT16; + const options = this._storageIndex ? { + storage: true + } : void 0; + this.indexBuffer[0] = new IndexBuffer(this.device, createFormat, this._geometryData.maxIndices, this._geometryData.indicesUsage, void 0, options); + } + const srcIndices = this._geometryData.indices; + if (srcIndices) { + const indexBuffer = this.indexBuffer[0]; + indexBuffer.writeData(srcIndices, this._geometryData.indexCount); + this._geometryData.indices = null; + } + } + prepareRenderState(renderStyle) { + if (renderStyle === RENDERSTYLE_WIREFRAME) { + this.generateWireframe(); + } else if (renderStyle === RENDERSTYLE_POINTS) { + this.primitive[RENDERSTYLE_POINTS] = { + type: PRIMITIVE_POINTS, + base: 0, + count: this.vertexBuffer ? this.vertexBuffer.numVertices : 0, + indexed: false + }; + } + } + updateRenderStates() { + if (this.primitive[RENDERSTYLE_POINTS]) { + this.prepareRenderState(RENDERSTYLE_POINTS); + } + if (this.primitive[RENDERSTYLE_WIREFRAME]) { + this.prepareRenderState(RENDERSTYLE_WIREFRAME); + } + } + generateWireframe() { + this._destroyIndexBuffer(RENDERSTYLE_WIREFRAME); + const numVertices = this.vertexBuffer.numVertices; + const lines = []; + let format; + if (this.indexBuffer.length > 0 && this.indexBuffer[0]) { + const offsets = [[0, 1], [1, 2], [2, 0]]; + const base = this.primitive[RENDERSTYLE_SOLID].base; + const count = this.primitive[RENDERSTYLE_SOLID].count; + const indexBuffer = this.indexBuffer[RENDERSTYLE_SOLID]; + const srcIndices = new typedArrayIndexFormats[indexBuffer.format](indexBuffer.storage); + const seen = /* @__PURE__ */ new Set(); + for (let j = base; j < base + count; j += 3) { + for (let k = 0; k < 3; k++) { + const i1 = srcIndices[j + offsets[k][0]]; + const i2 = srcIndices[j + offsets[k][1]]; + const hash = i1 > i2 ? i2 * numVertices + i1 : i1 * numVertices + i2; + if (!seen.has(hash)) { + seen.add(hash); + lines.push(i1, i2); + } + } + } + format = indexBuffer.format; + } else { + for (let i = 0; i < numVertices; i += 3) { + lines.push(i, i + 1, i + 1, i + 2, i + 2, i); + } + format = lines.length > 65535 ? INDEXFORMAT_UINT32 : INDEXFORMAT_UINT16; + } + const wireBuffer = new IndexBuffer(this.vertexBuffer.device, format, lines.length); + const dstIndices = new typedArrayIndexFormats[wireBuffer.format](wireBuffer.storage); + dstIndices.set(lines); + wireBuffer.unlock(); + this.primitive[RENDERSTYLE_WIREFRAME] = { + type: PRIMITIVE_LINES, + base: 0, + count: lines.length, + indexed: true + }; + this.indexBuffer[RENDERSTYLE_WIREFRAME] = wireBuffer; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/graph-node.js +var scaleCompensatePosTransform = new Mat4(); +var scaleCompensatePos = new Vec3(); +var scaleCompensateRot = new Quat2(); +var scaleCompensateRot2 = new Quat2(); +var scaleCompensateScale = new Vec3(); +var scaleCompensateScaleForParent = new Vec3(); +var tmpMat4 = new Mat4(); +var tmpQuat = new Quat2(); +var position = new Vec3(); +var invParentWtm = new Mat4(); +var rotation = new Quat2(); +var invParentRot = new Quat2(); +var matrix = new Mat4(); +var target = new Vec3(); +var up = new Vec3(); +function createTest(attr, value) { + if (attr instanceof Function) { + return attr; + } + return (node) => { + let x2 = node[attr]; + if (x2 instanceof Function) { + x2 = x2(); + } + return x2 === value; + }; +} +function findNode(node, test) { + if (test(node)) return node; + const children = node._children; + const len = children.length; + for (let i = 0; i < len; ++i) { + const result = findNode(children[i], test); + if (result) return result; + } + return null; +} +var GraphNode = class extends EventHandler { + constructor(name = "Untitled") { + super(); + this.name = void 0; + this.tags = new Tags(this); + this._labels = {}; + this.localPosition = new Vec3(); + this.localRotation = new Quat2(); + this.localScale = new Vec3(1, 1, 1); + this.localEulerAngles = new Vec3(); + this.position = new Vec3(); + this.rotation = new Quat2(); + this.eulerAngles = new Vec3(); + this._scale = null; + this.localTransform = new Mat4(); + this._dirtyLocal = false; + this._aabbVer = 0; + this._frozen = false; + this.worldTransform = new Mat4(); + this._dirtyWorld = false; + this._worldScaleSign = 0; + this._normalMatrix = new Mat3(); + this._dirtyNormal = true; + this._right = null; + this._up = null; + this._forward = null; + this._parent = null; + this._children = []; + this._graphDepth = 0; + this._enabled = true; + this._enabledInHierarchy = false; + this.scaleCompensation = false; + this.name = name; + } + get right() { + if (!this._right) { + this._right = new Vec3(); + } + return this.getWorldTransform().getX(this._right).normalize(); + } + get up() { + if (!this._up) { + this._up = new Vec3(); + } + return this.getWorldTransform().getY(this._up).normalize(); + } + get forward() { + if (!this._forward) { + this._forward = new Vec3(); + } + return this.getWorldTransform().getZ(this._forward).normalize().mulScalar(-1); + } + get normalMatrix() { + const normalMat = this._normalMatrix; + if (this._dirtyNormal) { + normalMat.invertMat4(this.getWorldTransform()).transpose(); + this._dirtyNormal = false; + } + return normalMat; + } + set enabled(enabled) { + if (this._enabled !== enabled) { + var _this$_parent; + this._enabled = enabled; + if (enabled && (_this$_parent = this._parent) != null && _this$_parent.enabled || !enabled) { + this._notifyHierarchyStateChanged(this, enabled); + } + } + } + get enabled() { + return this._enabled && this._enabledInHierarchy; + } + get parent() { + return this._parent; + } + get path() { + let node = this._parent; + if (!node) { + return ""; + } + let result = this.name; + while (node && node._parent) { + result = `${node.name}/${result}`; + node = node._parent; + } + return result; + } + get root() { + let result = this; + while (result._parent) { + result = result._parent; + } + return result; + } + get children() { + return this._children; + } + get graphDepth() { + return this._graphDepth; + } + _notifyHierarchyStateChanged(node, enabled) { + node._onHierarchyStateChanged(enabled); + const c2 = node._children; + for (let i = 0, len = c2.length; i < len; i++) { + if (c2[i]._enabled) this._notifyHierarchyStateChanged(c2[i], enabled); + } + } + _onHierarchyStateChanged(enabled) { + this._enabledInHierarchy = enabled; + if (enabled && !this._frozen) this._unfreezeParentToRoot(); + } + _cloneInternal(clone) { + clone.name = this.name; + const tags = this.tags._list; + clone.tags.clear(); + for (let i = 0; i < tags.length; i++) clone.tags.add(tags[i]); + clone._labels = Object.assign({}, this._labels); + clone.localPosition.copy(this.localPosition); + clone.localRotation.copy(this.localRotation); + clone.localScale.copy(this.localScale); + clone.localEulerAngles.copy(this.localEulerAngles); + clone.position.copy(this.position); + clone.rotation.copy(this.rotation); + clone.eulerAngles.copy(this.eulerAngles); + clone.localTransform.copy(this.localTransform); + clone._dirtyLocal = this._dirtyLocal; + clone.worldTransform.copy(this.worldTransform); + clone._dirtyWorld = this._dirtyWorld; + clone._dirtyNormal = this._dirtyNormal; + clone._aabbVer = this._aabbVer + 1; + clone._enabled = this._enabled; + clone.scaleCompensation = this.scaleCompensation; + clone._enabledInHierarchy = false; + } + clone() { + const clone = new this.constructor(); + this._cloneInternal(clone); + return clone; + } + copy(source) { + source._cloneInternal(this); + return this; + } + destroy() { + this.remove(); + const children = this._children; + while (children.length) { + const child = children.pop(); + child._parent = null; + child.destroy(); + } + this.fire("destroy", this); + this.off(); + } + find(attr, value) { + const results = []; + const test = createTest(attr, value); + this.forEach((node) => { + if (test(node)) results.push(node); + }); + return results; + } + findOne(attr, value) { + const test = createTest(attr, value); + return findNode(this, test); + } + findByTag() { + const query = arguments; + const results = []; + const queryNode = (node, checkNode) => { + if (checkNode && node.tags.has(...query)) { + results.push(node); + } + for (let i = 0; i < node._children.length; i++) { + queryNode(node._children[i], true); + } + }; + queryNode(this, false); + return results; + } + findByName(name) { + return this.findOne("name", name); + } + findByPath(path2) { + const parts = Array.isArray(path2) ? path2 : path2.split("/"); + let result = this; + for (let i = 0, imax = parts.length; i < imax; ++i) { + result = result.children.find((c2) => c2.name === parts[i]); + if (!result) { + return null; + } + } + return result; + } + forEach(callback, thisArg) { + callback.call(thisArg, this); + const children = this._children; + const len = children.length; + for (let i = 0; i < len; ++i) { + children[i].forEach(callback, thisArg); + } + } + isDescendantOf(node) { + let parent = this._parent; + while (parent) { + if (parent === node) return true; + parent = parent._parent; + } + return false; + } + isAncestorOf(node) { + return node.isDescendantOf(this); + } + getEulerAngles() { + this.getWorldTransform().getEulerAngles(this.eulerAngles); + return this.eulerAngles; + } + getLocalEulerAngles() { + this.localRotation.getEulerAngles(this.localEulerAngles); + return this.localEulerAngles; + } + getLocalPosition() { + return this.localPosition; + } + getLocalRotation() { + return this.localRotation; + } + getLocalScale() { + return this.localScale; + } + getLocalTransform() { + if (this._dirtyLocal) { + this.localTransform.setTRS(this.localPosition, this.localRotation, this.localScale); + this._dirtyLocal = false; + } + return this.localTransform; + } + getPosition() { + this.getWorldTransform().getTranslation(this.position); + return this.position; + } + getRotation() { + this.rotation.setFromMat4(this.getWorldTransform()); + return this.rotation; + } + getScale() { + if (!this._scale) { + this._scale = new Vec3(); + } + return this.getWorldTransform().getScale(this._scale); + } + getWorldTransform() { + if (!this._dirtyLocal && !this._dirtyWorld) return this.worldTransform; + if (this._parent) this._parent.getWorldTransform(); + this._sync(); + return this.worldTransform; + } + get worldScaleSign() { + if (this._worldScaleSign === 0) { + this._worldScaleSign = this.getWorldTransform().scaleSign; + } + return this._worldScaleSign; + } + remove() { + var _this$_parent2; + (_this$_parent2 = this._parent) == null || _this$_parent2.removeChild(this); + } + reparent(parent, index) { + this.remove(); + if (parent) { + if (index >= 0) { + parent.insertChild(this, index); + } else { + parent.addChild(this); + } + } + } + setLocalEulerAngles(x2, y2, z2) { + this.localRotation.setFromEulerAngles(x2, y2, z2); + if (!this._dirtyLocal) this._dirtifyLocal(); + } + setLocalPosition(x2, y2, z2) { + if (x2 instanceof Vec3) { + this.localPosition.copy(x2); + } else { + this.localPosition.set(x2, y2, z2); + } + if (!this._dirtyLocal) this._dirtifyLocal(); + } + setLocalRotation(x2, y2, z2, w) { + if (x2 instanceof Quat2) { + this.localRotation.copy(x2); + } else { + this.localRotation.set(x2, y2, z2, w); + } + if (!this._dirtyLocal) this._dirtifyLocal(); + } + setLocalScale(x2, y2, z2) { + if (x2 instanceof Vec3) { + this.localScale.copy(x2); + } else { + this.localScale.set(x2, y2, z2); + } + if (!this._dirtyLocal) this._dirtifyLocal(); + } + _dirtifyLocal() { + if (!this._dirtyLocal) { + this._dirtyLocal = true; + if (!this._dirtyWorld) this._dirtifyWorld(); + } + } + _unfreezeParentToRoot() { + let p = this._parent; + while (p) { + p._frozen = false; + p = p._parent; + } + } + _dirtifyWorld() { + if (!this._dirtyWorld) this._unfreezeParentToRoot(); + this._dirtifyWorldInternal(); + } + _dirtifyWorldInternal() { + if (!this._dirtyWorld) { + this._frozen = false; + this._dirtyWorld = true; + for (let i = 0; i < this._children.length; i++) { + if (!this._children[i]._dirtyWorld) this._children[i]._dirtifyWorldInternal(); + } + } + this._dirtyNormal = true; + this._worldScaleSign = 0; + this._aabbVer++; + } + setPosition(x2, y2, z2) { + if (x2 instanceof Vec3) { + position.copy(x2); + } else { + position.set(x2, y2, z2); + } + if (this._parent === null) { + this.localPosition.copy(position); + } else { + invParentWtm.copy(this._parent.getWorldTransform()).invert(); + invParentWtm.transformPoint(position, this.localPosition); + } + if (!this._dirtyLocal) this._dirtifyLocal(); + } + setRotation(x2, y2, z2, w) { + if (x2 instanceof Quat2) { + rotation.copy(x2); + } else { + rotation.set(x2, y2, z2, w); + } + if (this._parent === null) { + this.localRotation.copy(rotation); + } else { + const parentRot = this._parent.getRotation(); + invParentRot.copy(parentRot).invert(); + this.localRotation.copy(invParentRot).mul(rotation); + } + if (!this._dirtyLocal) this._dirtifyLocal(); + } + setEulerAngles(x2, y2, z2) { + this.localRotation.setFromEulerAngles(x2, y2, z2); + if (this._parent !== null) { + const parentRot = this._parent.getRotation(); + invParentRot.copy(parentRot).invert(); + this.localRotation.mul2(invParentRot, this.localRotation); + } + if (!this._dirtyLocal) this._dirtifyLocal(); + } + addChild(node) { + this._prepareInsertChild(node); + this._children.push(node); + this._onInsertChild(node); + } + addChildAndSaveTransform(node) { + const wPos = node.getPosition(); + const wRot = node.getRotation(); + this._prepareInsertChild(node); + node.setPosition(tmpMat4.copy(this.worldTransform).invert().transformPoint(wPos)); + node.setRotation(tmpQuat.copy(this.getRotation()).invert().mul(wRot)); + this._children.push(node); + this._onInsertChild(node); + } + insertChild(node, index) { + this._prepareInsertChild(node); + this._children.splice(index, 0, node); + this._onInsertChild(node); + } + _prepareInsertChild(node) { + node.remove(); + } + _fireOnHierarchy(name, nameHierarchy, parent) { + this.fire(name, parent); + for (let i = 0; i < this._children.length; i++) { + this._children[i]._fireOnHierarchy(nameHierarchy, nameHierarchy, parent); + } + } + _onInsertChild(node) { + node._parent = this; + const enabledInHierarchy = node._enabled && this.enabled; + if (node._enabledInHierarchy !== enabledInHierarchy) { + node._enabledInHierarchy = enabledInHierarchy; + node._notifyHierarchyStateChanged(node, enabledInHierarchy); + } + node._updateGraphDepth(); + node._dirtifyWorld(); + if (this._frozen) node._unfreezeParentToRoot(); + node._fireOnHierarchy("insert", "inserthierarchy", this); + if (this.fire) this.fire("childinsert", node); + } + _updateGraphDepth() { + this._graphDepth = this._parent ? this._parent._graphDepth + 1 : 0; + for (let i = 0, len = this._children.length; i < len; i++) { + this._children[i]._updateGraphDepth(); + } + } + removeChild(child) { + const index = this._children.indexOf(child); + if (index === -1) { + return; + } + this._children.splice(index, 1); + child._parent = null; + child._fireOnHierarchy("remove", "removehierarchy", this); + this.fire("childremove", child); + } + _sync() { + if (this._dirtyLocal) { + this.localTransform.setTRS(this.localPosition, this.localRotation, this.localScale); + this._dirtyLocal = false; + } + if (this._dirtyWorld) { + if (this._parent === null) { + this.worldTransform.copy(this.localTransform); + } else { + if (this.scaleCompensation) { + let parentWorldScale; + const parent = this._parent; + let scale2 = this.localScale; + let parentToUseScaleFrom = parent; + if (parentToUseScaleFrom) { + while (parentToUseScaleFrom && parentToUseScaleFrom.scaleCompensation) { + parentToUseScaleFrom = parentToUseScaleFrom._parent; + } + if (parentToUseScaleFrom) { + parentToUseScaleFrom = parentToUseScaleFrom._parent; + if (parentToUseScaleFrom) { + parentWorldScale = parentToUseScaleFrom.worldTransform.getScale(); + scaleCompensateScale.mul2(parentWorldScale, this.localScale); + scale2 = scaleCompensateScale; + } + } + } + scaleCompensateRot2.setFromMat4(parent.worldTransform); + scaleCompensateRot.mul2(scaleCompensateRot2, this.localRotation); + let tmatrix = parent.worldTransform; + if (parent.scaleCompensation) { + scaleCompensateScaleForParent.mul2(parentWorldScale, parent.getLocalScale()); + scaleCompensatePosTransform.setTRS(parent.worldTransform.getTranslation(scaleCompensatePos), scaleCompensateRot2, scaleCompensateScaleForParent); + tmatrix = scaleCompensatePosTransform; + } + tmatrix.transformPoint(this.localPosition, scaleCompensatePos); + this.worldTransform.setTRS(scaleCompensatePos, scaleCompensateRot, scale2); + } else { + this.worldTransform.mulAffine2(this._parent.worldTransform, this.localTransform); + } + } + this._dirtyWorld = false; + } + } + syncHierarchy() { + if (!this._enabled) return; + if (this._frozen) return; + this._frozen = true; + if (this._dirtyLocal || this._dirtyWorld) { + this._sync(); + } + const children = this._children; + for (let i = 0, len = children.length; i < len; i++) { + children[i].syncHierarchy(); + } + } + lookAt(x2, y2, z2, ux = 0, uy = 1, uz = 0) { + if (x2 instanceof Vec3) { + target.copy(x2); + if (y2 instanceof Vec3) { + up.copy(y2); + } else { + up.copy(Vec3.UP); + } + } else if (z2 === void 0) { + return; + } else { + target.set(x2, y2, z2); + up.set(ux, uy, uz); + } + matrix.setLookAt(this.getPosition(), target, up); + rotation.setFromMat4(matrix); + this.setRotation(rotation); + } + translate(x2, y2, z2) { + if (x2 instanceof Vec3) { + position.copy(x2); + } else { + position.set(x2, y2, z2); + } + position.add(this.getPosition()); + this.setPosition(position); + } + translateLocal(x2, y2, z2) { + if (x2 instanceof Vec3) { + position.copy(x2); + } else { + position.set(x2, y2, z2); + } + this.localRotation.transformVector(position, position); + this.localPosition.add(position); + if (!this._dirtyLocal) this._dirtifyLocal(); + } + rotate(x2, y2, z2) { + rotation.setFromEulerAngles(x2, y2, z2); + if (this._parent === null) { + this.localRotation.mul2(rotation, this.localRotation); + } else { + const rot = this.getRotation(); + const parentRot = this._parent.getRotation(); + invParentRot.copy(parentRot).invert(); + rotation.mul2(invParentRot, rotation); + this.localRotation.mul2(rotation, rot); + } + if (!this._dirtyLocal) this._dirtifyLocal(); + } + rotateLocal(x2, y2, z2) { + rotation.setFromEulerAngles(x2, y2, z2); + this.localRotation.mul(rotation); + if (!this._dirtyLocal) this._dirtifyLocal(); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/core/ref-counted-cache.js +var RefCountedCache = class { + constructor() { + this.cache = /* @__PURE__ */ new Map(); + } + destroy() { + this.cache.forEach((refCount, object) => { + object.destroy(); + }); + this.cache.clear(); + } + incRef(object) { + const refCount = (this.cache.get(object) || 0) + 1; + this.cache.set(object, refCount); + } + decRef(object) { + if (object) { + let refCount = this.cache.get(object); + if (refCount) { + refCount--; + if (refCount === 0) { + this.cache.delete(object); + object.destroy(); + } else { + this.cache.set(object, refCount); + } + } + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/graphics/lightmap-cache.js +var LightmapCache = class { + static incRef(texture) { + this.cache.incRef(texture); + } + static decRef(texture) { + this.cache.decRef(texture); + } + static destroy() { + this.cache.destroy(); + } +}; +LightmapCache.cache = new RefCountedCache(); + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/mesh-instance.js +var id10 = 0; +var _tmpAabb = new BoundingBox(); +var _tempBoneAabb = new BoundingBox(); +var _tempSphere = new BoundingSphere(); +var _meshSet = /* @__PURE__ */ new Set(); +var InstancingData = class { + constructor(numObjects) { + this.vertexBuffer = null; + this.count = numObjects; + } +}; +var ShaderInstance = class { + constructor() { + this.shader = void 0; + this.bindGroup = null; + } + getBindGroup(device) { + if (!this.bindGroup) { + const shader = this.shader; + const ubFormat = shader.meshUniformBufferFormat; + const uniformBuffer = new UniformBuffer(device, ubFormat, false); + const bindGroupFormat = shader.meshBindGroupFormat; + this.bindGroup = new BindGroup(device, bindGroupFormat, uniformBuffer); + } + return this.bindGroup; + } + destroy() { + const group = this.bindGroup; + if (group) { + var _group$defaultUniform; + (_group$defaultUniform = group.defaultUniformBuffer) == null || _group$defaultUniform.destroy(); + group.destroy(); + this.bindGroup = null; + } + } +}; +var ShaderCacheEntry = class { + constructor() { + this.shaderInstances = /* @__PURE__ */ new Map(); + } + destroy() { + this.shaderInstances.forEach((instance) => instance.destroy()); + this.shaderInstances.clear(); + } +}; +var MeshInstance = class _MeshInstance { + constructor(mesh, material, node = null) { + this.visible = true; + this.castShadow = false; + this.transparent = false; + this._material = null; + this._shaderCache = []; + this.id = id10++; + this.pick = true; + if (mesh instanceof GraphNode) { + const temp = mesh; + mesh = material; + material = node; + node = temp; + } + this._key = [0, 0]; + this.node = node; + this._mesh = mesh; + mesh.incRefCount(); + this.material = material; + this._shaderDefs = MASK_AFFECT_DYNAMIC << 16; + if (mesh.vertexBuffer) { + const format = mesh.vertexBuffer.format; + this._shaderDefs |= format.hasUv0 ? SHADERDEF_UV0 : 0; + this._shaderDefs |= format.hasUv1 ? SHADERDEF_UV1 : 0; + this._shaderDefs |= format.hasColor ? SHADERDEF_VCOLOR : 0; + this._shaderDefs |= format.hasTangents ? SHADERDEF_TANGENTS : 0; + } + this.layer = LAYER_WORLD; + this._renderStyle = RENDERSTYLE_SOLID; + this._receiveShadow = true; + this._screenSpace = false; + this.cull = true; + this._updateAabb = true; + this._updateAabbFunc = null; + this._calculateSortDistance = null; + this.updateKey(); + this._skinInstance = null; + this._morphInstance = null; + this.gsplatInstance = null; + this.instancingData = null; + this._customAabb = null; + this.aabb = new BoundingBox(); + this._aabbVer = -1; + this._aabbMeshVer = -1; + this.drawOrder = 0; + this.visibleThisFrame = false; + this.isVisibleFunc = null; + this.parameters = {}; + this.stencilFront = null; + this.stencilBack = null; + this.flipFacesFactor = 1; + } + set renderStyle(renderStyle) { + this._renderStyle = renderStyle; + this.mesh.prepareRenderState(renderStyle); + } + get renderStyle() { + return this._renderStyle; + } + set mesh(mesh) { + if (mesh === this._mesh) return; + if (this._mesh) { + this._mesh.decRefCount(); + } + this._mesh = mesh; + if (mesh) { + mesh.incRefCount(); + } + } + get mesh() { + return this._mesh; + } + set aabb(aabb) { + this._aabb = aabb; + } + get aabb() { + if (!this._updateAabb) { + return this._aabb; + } + if (this._updateAabbFunc) { + return this._updateAabbFunc(this._aabb); + } + let localAabb = this._customAabb; + let toWorldSpace = !!localAabb; + if (!localAabb) { + localAabb = _tmpAabb; + if (this.skinInstance) { + if (!this.mesh.boneAabb) { + const morphTargets = this._morphInstance ? this._morphInstance.morph._targets : null; + this.mesh._initBoneAabbs(morphTargets); + } + const boneUsed = this.mesh.boneUsed; + let first = true; + for (let i = 0; i < this.mesh.boneAabb.length; i++) { + if (boneUsed[i]) { + _tempBoneAabb.setFromTransformedAabb(this.mesh.boneAabb[i], this.skinInstance.matrices[i]); + if (first) { + first = false; + localAabb.center.copy(_tempBoneAabb.center); + localAabb.halfExtents.copy(_tempBoneAabb.halfExtents); + } else { + localAabb.add(_tempBoneAabb); + } + } + } + toWorldSpace = true; + } else if (this.node._aabbVer !== this._aabbVer || this.mesh._aabbVer !== this._aabbMeshVer) { + if (this.mesh) { + localAabb.center.copy(this.mesh.aabb.center); + localAabb.halfExtents.copy(this.mesh.aabb.halfExtents); + } else { + localAabb.center.set(0, 0, 0); + localAabb.halfExtents.set(0, 0, 0); + } + if (this.mesh && this.mesh.morph) { + const morphAabb = this.mesh.morph.aabb; + localAabb._expand(morphAabb.getMin(), morphAabb.getMax()); + } + toWorldSpace = true; + this._aabbVer = this.node._aabbVer; + this._aabbMeshVer = this.mesh._aabbVer; + } + } + if (toWorldSpace) { + this._aabb.setFromTransformedAabb(localAabb, this.node.getWorldTransform()); + } + return this._aabb; + } + clearShaders() { + const shaderCache = this._shaderCache; + for (let i = 0; i < shaderCache.length; i++) { + var _shaderCache$i; + (_shaderCache$i = shaderCache[i]) == null || _shaderCache$i.destroy(); + shaderCache[i] = null; + } + } + getShaderInstance(shaderPass, lightHash, scene2, viewUniformFormat, viewBindGroupFormat, sortedLights) { + let shaderInstance; + let passEntry = this._shaderCache[shaderPass]; + if (passEntry) { + shaderInstance = passEntry.shaderInstances.get(lightHash); + } else { + passEntry = new ShaderCacheEntry(); + this._shaderCache[shaderPass] = passEntry; + } + if (!shaderInstance) { + const mat = this._material; + const shaderDefs = this._shaderDefs; + const variantKey = shaderPass + "_" + shaderDefs + "_" + lightHash; + shaderInstance = new ShaderInstance(); + shaderInstance.shader = mat.variants.get(variantKey); + if (!shaderInstance.shader) { + var _this$_mesh$vertexBuf; + const shader = mat.getShaderVariant(this.mesh.device, scene2, shaderDefs, null, shaderPass, sortedLights, viewUniformFormat, viewBindGroupFormat, (_this$_mesh$vertexBuf = this._mesh.vertexBuffer) == null ? void 0 : _this$_mesh$vertexBuf.format); + mat.variants.set(variantKey, shader); + shaderInstance.shader = shader; + } + passEntry.shaderInstances.set(lightHash, shaderInstance); + } + return shaderInstance; + } + set material(material) { + this.clearShaders(); + const prevMat = this._material; + if (prevMat) { + prevMat.removeMeshInstanceRef(this); + } + this._material = material; + if (material) { + material.addMeshInstanceRef(this); + this.transparent = material.transparent; + this.updateKey(); + } + } + get material() { + return this._material; + } + set layer(layer) { + this._layer = layer; + this.updateKey(); + } + get layer() { + return this._layer; + } + _updateShaderDefs(shaderDefs) { + if (shaderDefs !== this._shaderDefs) { + this._shaderDefs = shaderDefs; + this.clearShaders(); + } + } + set calculateSortDistance(calculateSortDistance) { + this._calculateSortDistance = calculateSortDistance; + } + get calculateSortDistance() { + return this._calculateSortDistance; + } + set receiveShadow(val) { + if (this._receiveShadow !== val) { + this._receiveShadow = val; + this._updateShaderDefs(val ? this._shaderDefs & ~SHADERDEF_NOSHADOW : this._shaderDefs | SHADERDEF_NOSHADOW); + } + } + get receiveShadow() { + return this._receiveShadow; + } + set skinInstance(val) { + this._skinInstance = val; + this._updateShaderDefs(val ? this._shaderDefs | SHADERDEF_SKIN : this._shaderDefs & ~SHADERDEF_SKIN); + this._setupSkinUpdate(); + } + get skinInstance() { + return this._skinInstance; + } + set morphInstance(val) { + var _this$_morphInstance; + (_this$_morphInstance = this._morphInstance) == null || _this$_morphInstance.destroy(); + this._morphInstance = val; + let shaderDefs = this._shaderDefs; + shaderDefs = val && val.morph.useTextureMorph ? shaderDefs | SHADERDEF_MORPH_TEXTURE_BASED : shaderDefs & ~SHADERDEF_MORPH_TEXTURE_BASED; + shaderDefs = val && val.morph.morphPositions ? shaderDefs | SHADERDEF_MORPH_POSITION : shaderDefs & ~SHADERDEF_MORPH_POSITION; + shaderDefs = val && val.morph.morphNormals ? shaderDefs | SHADERDEF_MORPH_NORMAL : shaderDefs & ~SHADERDEF_MORPH_NORMAL; + this._updateShaderDefs(shaderDefs); + } + get morphInstance() { + return this._morphInstance; + } + set screenSpace(val) { + if (this._screenSpace !== val) { + this._screenSpace = val; + this._updateShaderDefs(val ? this._shaderDefs | SHADERDEF_SCREENSPACE : this._shaderDefs & ~SHADERDEF_SCREENSPACE); + } + } + get screenSpace() { + return this._screenSpace; + } + set key(val) { + this._key[SORTKEY_FORWARD] = val; + } + get key() { + return this._key[SORTKEY_FORWARD]; + } + set mask(val) { + const toggles = this._shaderDefs & 65535; + this._updateShaderDefs(toggles | val << 16); + } + get mask() { + return this._shaderDefs >> 16; + } + set instancingCount(value) { + if (this.instancingData) this.instancingData.count = value; + } + get instancingCount() { + return this.instancingData ? this.instancingData.count : 0; + } + destroy() { + var _this$_skinInstance, _this$morphInstance; + const mesh = this.mesh; + if (mesh) { + this.mesh = null; + if (mesh.refCount < 1) { + mesh.destroy(); + } + } + this.setRealtimeLightmap(_MeshInstance.lightmapParamNames[0], null); + this.setRealtimeLightmap(_MeshInstance.lightmapParamNames[1], null); + (_this$_skinInstance = this._skinInstance) == null || _this$_skinInstance.destroy(); + this._skinInstance = null; + (_this$morphInstance = this.morphInstance) == null || _this$morphInstance.destroy(); + this.morphInstance = null; + this.clearShaders(); + this.material = null; + } + static _prepareRenderStyleForArray(meshInstances, renderStyle) { + if (meshInstances) { + for (let i = 0; i < meshInstances.length; i++) { + meshInstances[i]._renderStyle = renderStyle; + const mesh = meshInstances[i].mesh; + if (!_meshSet.has(mesh)) { + _meshSet.add(mesh); + mesh.prepareRenderState(renderStyle); + } + } + _meshSet.clear(); + } + } + _isVisible(camera) { + if (this.visible) { + if (this.isVisibleFunc) { + return this.isVisibleFunc(camera); + } + _tempSphere.center = this.aabb.center; + _tempSphere.radius = this._aabb.halfExtents.length(); + return camera.frustum.containsSphere(_tempSphere); + } + return false; + } + updateKey() { + const material = this.material; + const blendType = material.alphaToCoverage || material.alphaTest ? BLEND_NORMAL : material.blendType; + this._key[SORTKEY_FORWARD] = (this.layer & 15) << 27 | (blendType === BLEND_NONE ? 1 : 0) << 26 | (material.id & 33554431) << 0; + } + setInstancing(vertexBuffer, cull = false) { + if (vertexBuffer) { + this.instancingData = new InstancingData(vertexBuffer.numVertices); + this.instancingData.vertexBuffer = vertexBuffer; + vertexBuffer.format.instancing = true; + this.cull = cull; + } else { + this.instancingData = null; + this.cull = true; + } + this._updateShaderDefs(vertexBuffer ? this._shaderDefs | SHADERDEF_INSTANCING : this._shaderDefs & ~SHADERDEF_INSTANCING); + } + ensureMaterial(device) { + if (!this.material) { + this.material = getDefaultMaterial(device); + } + } + clearParameters() { + this.parameters = {}; + } + getParameters() { + return this.parameters; + } + getParameter(name) { + return this.parameters[name]; + } + setParameter(name, data2, passFlags = -262141) { + if (data2 === void 0 && typeof name === "object") { + const uniformObject = name; + if (uniformObject.length) { + for (let i = 0; i < uniformObject.length; i++) { + this.setParameter(uniformObject[i]); + } + return; + } + name = uniformObject.name; + data2 = uniformObject.value; + } + const param = this.parameters[name]; + if (param) { + param.data = data2; + param.passFlags = passFlags; + } else { + this.parameters[name] = { + scopeId: null, + data: data2, + passFlags + }; + } + } + setRealtimeLightmap(name, texture) { + const old = this.getParameter(name); + if (old === texture) return; + if (old) { + LightmapCache.decRef(old.data); + } + if (texture) { + LightmapCache.incRef(texture); + this.setParameter(name, texture); + } else { + this.deleteParameter(name); + } + } + deleteParameter(name) { + if (this.parameters[name]) { + delete this.parameters[name]; + } + } + setParameters(device, passFlag) { + const parameters = this.parameters; + for (const paramName in parameters) { + const parameter = parameters[paramName]; + if (parameter.passFlags & passFlag) { + if (!parameter.scopeId) { + parameter.scopeId = device.scope.resolve(paramName); + } + parameter.scopeId.setValue(parameter.data); + } + } + } + setLightmapped(value) { + if (value) { + this.mask = (this.mask | MASK_AFFECT_LIGHTMAPPED) & ~(MASK_AFFECT_DYNAMIC | MASK_BAKE); + } else { + this.setRealtimeLightmap(_MeshInstance.lightmapParamNames[0], null); + this.setRealtimeLightmap(_MeshInstance.lightmapParamNames[1], null); + this._shaderDefs &= ~(SHADERDEF_LM | SHADERDEF_DIRLM | SHADERDEF_LMAMBIENT); + this.mask = (this.mask | MASK_AFFECT_DYNAMIC) & ~(MASK_AFFECT_LIGHTMAPPED | MASK_BAKE); + } + } + setCustomAabb(aabb) { + if (aabb) { + if (this._customAabb) { + this._customAabb.copy(aabb); + } else { + this._customAabb = aabb.clone(); + } + } else { + this._customAabb = null; + this._aabbVer = -1; + } + this._setupSkinUpdate(); + } + _setupSkinUpdate() { + if (this._skinInstance) { + this._skinInstance._updateBeforeCull = !this._customAabb; + } + } +}; +MeshInstance.lightmapParamNames = ["texture_lightMap", "texture_dirLightMap"]; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/graphics/render-pass-color-grab.js +var _colorUniformNames = ["uSceneColorMap", "texture_grabPass"]; +var RenderPassColorGrab = class extends RenderPass { + constructor(...args) { + super(...args); + this.colorRenderTarget = null; + this.source = null; + } + destroy() { + super.destroy(); + this.releaseRenderTarget(this.colorRenderTarget); + } + shouldReallocate(targetRT, sourceTexture, sourceFormat) { + const targetFormat = targetRT == null ? void 0 : targetRT.colorBuffer.format; + if (targetFormat !== sourceFormat) return true; + const width = (sourceTexture == null ? void 0 : sourceTexture.width) || this.device.width; + const height = (sourceTexture == null ? void 0 : sourceTexture.height) || this.device.height; + return !targetRT || width !== targetRT.width || height !== targetRT.height; + } + allocateRenderTarget(renderTarget, sourceRenderTarget, device, format) { + const mipmaps = device.isWebGL2; + const texture = new Texture(device, { + name: _colorUniformNames[0], + format, + width: sourceRenderTarget ? sourceRenderTarget.colorBuffer.width : device.width, + height: sourceRenderTarget ? sourceRenderTarget.colorBuffer.height : device.height, + mipmaps, + minFilter: mipmaps ? FILTER_LINEAR_MIPMAP_LINEAR : FILTER_LINEAR, + magFilter: FILTER_LINEAR, + addressU: ADDRESS_CLAMP_TO_EDGE, + addressV: ADDRESS_CLAMP_TO_EDGE + }); + if (renderTarget) { + renderTarget.destroyFrameBuffers(); + renderTarget._colorBuffer = texture; + renderTarget._colorBuffers = [texture]; + } else { + renderTarget = new RenderTarget({ + name: "ColorGrabRT", + colorBuffer: texture, + depth: false, + stencil: false, + autoResolve: false + }); + } + return renderTarget; + } + releaseRenderTarget(rt) { + if (rt) { + rt.destroyTextureBuffers(); + rt.destroy(); + } + } + frameUpdate() { + var _sourceRt$colorBuffer; + const device = this.device; + const sourceRt = this.source; + const sourceFormat = (_sourceRt$colorBuffer = sourceRt == null ? void 0 : sourceRt.colorBuffer.format) != null ? _sourceRt$colorBuffer : this.device.backBufferFormat; + if (this.shouldReallocate(this.colorRenderTarget, sourceRt == null ? void 0 : sourceRt.colorBuffer, sourceFormat)) { + this.releaseRenderTarget(this.colorRenderTarget); + this.colorRenderTarget = this.allocateRenderTarget(this.colorRenderTarget, sourceRt, device, sourceFormat); + } + const colorBuffer = this.colorRenderTarget.colorBuffer; + _colorUniformNames.forEach((name) => device.scope.resolve(name).setValue(colorBuffer)); + } + execute() { + const device = this.device; + const sourceRt = this.source; + const colorBuffer = this.colorRenderTarget.colorBuffer; + if (device.isWebGPU) { + device.copyRenderTarget(sourceRt, this.colorRenderTarget, true, false); + device.mipmapRenderer.generate(this.colorRenderTarget.colorBuffer.impl); + } else if (device.isWebGL2) { + device.copyRenderTarget(sourceRt, this.colorRenderTarget, true, false); + device.activeTexture(device.maxCombinedTextures - 1); + device.bindTexture(colorBuffer); + device.gl.generateMipmap(colorBuffer.impl._glTarget); + } else { + if (!colorBuffer.impl._glTexture) { + colorBuffer.impl.initialize(device, colorBuffer); + } + device.bindTexture(colorBuffer); + const gl = device.gl; + gl.copyTexImage2D(gl.TEXTURE_2D, 0, colorBuffer.impl._glFormat, 0, 0, colorBuffer.width, colorBuffer.height, 0); + colorBuffer._needsUpload = false; + colorBuffer._needsMipmapsUpload = false; + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/graphics/render-pass-depth-grab.js +var _depthUniformNames = ["uSceneDepthMap", "uDepthMap"]; +var RenderPassDepthGrab = class extends RenderPass { + constructor(device, camera) { + super(device); + this.depthRenderTarget = null; + this.camera = null; + this.camera = camera; + } + destroy() { + super.destroy(); + this.releaseRenderTarget(this.depthRenderTarget); + } + shouldReallocate(targetRT, sourceTexture) { + const width = (sourceTexture == null ? void 0 : sourceTexture.width) || this.device.width; + const height = (sourceTexture == null ? void 0 : sourceTexture.height) || this.device.height; + return !targetRT || width !== targetRT.width || height !== targetRT.height; + } + allocateRenderTarget(renderTarget, sourceRenderTarget, device, format, isDepth) { + const texture = new Texture(device, { + name: _depthUniformNames[0], + format, + width: sourceRenderTarget ? sourceRenderTarget.colorBuffer.width : device.width, + height: sourceRenderTarget ? sourceRenderTarget.colorBuffer.height : device.height, + mipmaps: false, + minFilter: FILTER_NEAREST, + magFilter: FILTER_NEAREST, + addressU: ADDRESS_CLAMP_TO_EDGE, + addressV: ADDRESS_CLAMP_TO_EDGE + }); + if (renderTarget) { + renderTarget.destroyFrameBuffers(); + if (isDepth) { + renderTarget._depthBuffer = texture; + } else { + renderTarget._colorBuffer = texture; + renderTarget._colorBuffers = [texture]; + } + } else { + renderTarget = new RenderTarget({ + name: "DepthGrabRT", + colorBuffer: isDepth ? null : texture, + depthBuffer: isDepth ? texture : null, + depth: !isDepth, + stencil: device.supportsStencil, + autoResolve: false + }); + } + return renderTarget; + } + releaseRenderTarget(rt) { + if (rt) { + rt.destroyTextureBuffers(); + rt.destroy(); + } + } + before() { + var _camera$renderTarget, _camera$renderTarget$, _camera$renderTarget2, _camera$renderTarget3; + const camera = this.camera; + const device = this.device; + const destinationRt = (_camera$renderTarget = camera == null ? void 0 : camera.renderTarget) != null ? _camera$renderTarget : device.backBuffer; + let useDepthBuffer = true; + let format = destinationRt.stencil ? PIXELFORMAT_DEPTHSTENCIL : PIXELFORMAT_DEPTH; + if (device.isWebGPU) { + const numSamples = destinationRt.samples; + if (numSamples > 1) { + format = PIXELFORMAT_R32F; + useDepthBuffer = false; + } + } + const sourceTexture = (_camera$renderTarget$ = (_camera$renderTarget2 = camera.renderTarget) == null ? void 0 : _camera$renderTarget2.depthBuffer) != null ? _camera$renderTarget$ : (_camera$renderTarget3 = camera.renderTarget) == null ? void 0 : _camera$renderTarget3.colorBuffer; + if (this.shouldReallocate(this.depthRenderTarget, sourceTexture)) { + this.releaseRenderTarget(this.depthRenderTarget); + this.depthRenderTarget = this.allocateRenderTarget(this.depthRenderTarget, camera.renderTarget, device, format, useDepthBuffer); + } + const colorBuffer = useDepthBuffer ? this.depthRenderTarget.depthBuffer : this.depthRenderTarget.colorBuffer; + _depthUniformNames.forEach((name) => device.scope.resolve(name).setValue(colorBuffer)); + } + execute() { + const device = this.device; + if (device.isWebGL2 && device.renderTarget.samples > 1) { + const src = device.renderTarget.impl._glFrameBuffer; + const dest = this.depthRenderTarget; + device.renderTarget = dest; + device.updateBegin(); + this.depthRenderTarget.impl.internalResolve(device, src, dest.impl._glFrameBuffer, this.depthRenderTarget, device.gl.DEPTH_BUFFER_BIT); + } else { + device.copyRenderTarget(device.renderTarget, this.depthRenderTarget, false, true); + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/graphics/render-pass-depth.js +var webgl1DepthClearColor = new Color(254 / 255, 254 / 255, 254 / 255, 254 / 255); +var tempMeshInstances = []; +var lights = [[], [], []]; +var _depthUniformNames2 = ["uSceneDepthMap", "uDepthMap"]; +var RenderPassDepth = class extends RenderPass { + constructor(device, renderer, camera) { + super(device); + this.renderer = renderer; + this.camera = camera; + this.setupRenderTarget(); + } + destroy() { + super.destroy(); + if (this.renderTarget) { + this.renderTarget.destroyTextureBuffers(); + this.renderTarget.destroy(); + this.renderTarget = null; + } + } + update(scene2) { + this.scene = scene2; + } + setupRenderTarget() { + const texture = new Texture(this.device, { + name: _depthUniformNames2[0], + format: PIXELFORMAT_RGBA8, + width: 4, + height: 4, + mipmaps: false, + minFilter: FILTER_NEAREST, + magFilter: FILTER_NEAREST, + addressU: ADDRESS_CLAMP_TO_EDGE, + addressV: ADDRESS_CLAMP_TO_EDGE + }); + const renderTarget = new RenderTarget({ + name: `${_depthUniformNames2[0]}RT}`, + colorBuffer: texture, + depth: true, + stencil: false + }); + this.init(renderTarget, {}); + this.setClearColor(webgl1DepthClearColor); + this.setClearDepth(1); + } + before() { + const device = this.device; + const colorBuffer = this.renderTarget.colorBuffer; + _depthUniformNames2.forEach((name) => device.scope.resolve(name).setValue(colorBuffer)); + } + execute() { + const { + device, + renderer, + camera, + scene: scene2, + renderTarget + } = this; + const layers = scene2.layers.layerList; + const subLayerEnabled = scene2.layers.subLayerEnabled; + const isTransparent = scene2.layers.subLayerList; + for (let i = 0; i < layers.length; i++) { + const layer = layers[i]; + if (layer.enabled && subLayerEnabled[i]) { + if (layer.camerasSet.has(camera)) { + if (layer.id === LAYERID_DEPTH) break; + const culledInstances = layer.getCulledInstances(camera); + const meshInstances = isTransparent[i] ? culledInstances.transparent : culledInstances.opaque; + for (let j = 0; j < meshInstances.length; j++) { + var _meshInstance$materia; + const meshInstance = meshInstances[j]; + if ((_meshInstance$materia = meshInstance.material) != null && _meshInstance$materia.depthWrite) { + tempMeshInstances.push(meshInstance); + } + } + renderer.setCameraUniforms(camera, renderTarget); + renderer.renderForward(camera, tempMeshInstances, lights, SHADER_DEPTH, (meshInstance) => { + device.setBlendState(BlendState.NOBLEND); + }, layer); + tempMeshInstances.length = 0; + } + } + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/camera.js +var _deviceCoord = new Vec3(); +var _halfSize2 = new Vec3(); +var _point = new Vec3(); +var _invViewProjMat = new Mat4(); +var _frustumPoints = [new Vec3(), new Vec3(), new Vec3(), new Vec3(), new Vec3(), new Vec3(), new Vec3(), new Vec3()]; +var Camera = class _Camera { + constructor() { + this.shaderPassInfo = null; + this.renderPassColorGrab = null; + this.renderPassDepthGrab = null; + this.renderPasses = []; + this.jitter = 0; + this._aspectRatio = 16 / 9; + this._aspectRatioMode = ASPECT_AUTO; + this._calculateProjection = null; + this._calculateTransform = null; + this._clearColor = new Color(0.75, 0.75, 0.75, 1); + this._clearColorBuffer = true; + this._clearDepth = 1; + this._clearDepthBuffer = true; + this._clearStencil = 0; + this._clearStencilBuffer = true; + this._cullFaces = true; + this._farClip = 1e3; + this._flipFaces = false; + this._fov = 45; + this._frustumCulling = true; + this._horizontalFov = false; + this._layers = [LAYERID_WORLD, LAYERID_DEPTH, LAYERID_SKYBOX, LAYERID_UI, LAYERID_IMMEDIATE]; + this._layersSet = new Set(this._layers); + this._nearClip = 0.1; + this._node = null; + this._orthoHeight = 10; + this._projection = PROJECTION_PERSPECTIVE; + this._rect = new Vec4(0, 0, 1, 1); + this._renderTarget = null; + this._scissorRect = new Vec4(0, 0, 1, 1); + this._scissorRectClear = false; + this._aperture = 16; + this._shutter = 1 / 1e3; + this._sensitivity = 1e3; + this._projMat = new Mat4(); + this._projMatDirty = true; + this._projMatSkybox = new Mat4(); + this._viewMat = new Mat4(); + this._viewMatDirty = true; + this._viewProjMat = new Mat4(); + this._viewProjMatDirty = true; + this._shaderMatricesVersion = 0; + this._viewProjInverse = new Mat4(); + this._viewProjCurrent = null; + this._viewProjPrevious = new Mat4(); + this._jitters = [0, 0, 0, 0]; + this.frustum = new Frustum(); + this._xr = null; + this._xrProperties = { + horizontalFov: this._horizontalFov, + fov: this._fov, + aspectRatio: this._aspectRatio, + farClip: this._farClip, + nearClip: this._nearClip + }; + } + destroy() { + var _this$renderPassColor, _this$renderPassDepth; + (_this$renderPassColor = this.renderPassColorGrab) == null || _this$renderPassColor.destroy(); + this.renderPassColorGrab = null; + (_this$renderPassDepth = this.renderPassDepthGrab) == null || _this$renderPassDepth.destroy(); + this.renderPassDepthGrab = null; + this.renderPasses.length = 0; + } + _storeShaderMatrices(viewProjMat2, jitterX, jitterY, renderVersion) { + if (this._shaderMatricesVersion !== renderVersion) { + var _this$_viewProjCurren, _this$_viewProjCurren2; + this._shaderMatricesVersion = renderVersion; + this._viewProjPrevious.copy((_this$_viewProjCurren = this._viewProjCurrent) != null ? _this$_viewProjCurren : viewProjMat2); + (_this$_viewProjCurren2 = this._viewProjCurrent) != null ? _this$_viewProjCurren2 : this._viewProjCurrent = new Mat4(); + this._viewProjCurrent.copy(viewProjMat2); + this._viewProjInverse.invert(viewProjMat2); + this._jitters[2] = this._jitters[0]; + this._jitters[3] = this._jitters[1]; + this._jitters[0] = jitterX; + this._jitters[1] = jitterY; + } + } + get fullSizeClearRect() { + const rect = this._scissorRectClear ? this.scissorRect : this._rect; + return rect.x === 0 && rect.y === 0 && rect.z === 1 && rect.w === 1; + } + set aspectRatio(newValue) { + if (this._aspectRatio !== newValue) { + this._aspectRatio = newValue; + this._projMatDirty = true; + } + } + get aspectRatio() { + var _this$xr; + return (_this$xr = this.xr) != null && _this$xr.active ? this._xrProperties.aspectRatio : this._aspectRatio; + } + set aspectRatioMode(newValue) { + if (this._aspectRatioMode !== newValue) { + this._aspectRatioMode = newValue; + this._projMatDirty = true; + } + } + get aspectRatioMode() { + return this._aspectRatioMode; + } + set calculateProjection(newValue) { + this._calculateProjection = newValue; + this._projMatDirty = true; + } + get calculateProjection() { + return this._calculateProjection; + } + set calculateTransform(newValue) { + this._calculateTransform = newValue; + } + get calculateTransform() { + return this._calculateTransform; + } + set clearColor(newValue) { + this._clearColor.copy(newValue); + } + get clearColor() { + return this._clearColor; + } + set clearColorBuffer(newValue) { + this._clearColorBuffer = newValue; + } + get clearColorBuffer() { + return this._clearColorBuffer; + } + set clearDepth(newValue) { + this._clearDepth = newValue; + } + get clearDepth() { + return this._clearDepth; + } + set clearDepthBuffer(newValue) { + this._clearDepthBuffer = newValue; + } + get clearDepthBuffer() { + return this._clearDepthBuffer; + } + set clearStencil(newValue) { + this._clearStencil = newValue; + } + get clearStencil() { + return this._clearStencil; + } + set clearStencilBuffer(newValue) { + this._clearStencilBuffer = newValue; + } + get clearStencilBuffer() { + return this._clearStencilBuffer; + } + set cullFaces(newValue) { + this._cullFaces = newValue; + } + get cullFaces() { + return this._cullFaces; + } + set farClip(newValue) { + if (this._farClip !== newValue) { + this._farClip = newValue; + this._projMatDirty = true; + } + } + get farClip() { + var _this$xr2; + return (_this$xr2 = this.xr) != null && _this$xr2.active ? this._xrProperties.farClip : this._farClip; + } + set flipFaces(newValue) { + this._flipFaces = newValue; + } + get flipFaces() { + return this._flipFaces; + } + set fov(newValue) { + if (this._fov !== newValue) { + this._fov = newValue; + this._projMatDirty = true; + } + } + get fov() { + var _this$xr3; + return (_this$xr3 = this.xr) != null && _this$xr3.active ? this._xrProperties.fov : this._fov; + } + set frustumCulling(newValue) { + this._frustumCulling = newValue; + } + get frustumCulling() { + return this._frustumCulling; + } + set horizontalFov(newValue) { + if (this._horizontalFov !== newValue) { + this._horizontalFov = newValue; + this._projMatDirty = true; + } + } + get horizontalFov() { + var _this$xr4; + return (_this$xr4 = this.xr) != null && _this$xr4.active ? this._xrProperties.horizontalFov : this._horizontalFov; + } + set layers(newValue) { + this._layers = newValue.slice(0); + this._layersSet = new Set(this._layers); + } + get layers() { + return this._layers; + } + get layersSet() { + return this._layersSet; + } + set nearClip(newValue) { + if (this._nearClip !== newValue) { + this._nearClip = newValue; + this._projMatDirty = true; + } + } + get nearClip() { + var _this$xr5; + return (_this$xr5 = this.xr) != null && _this$xr5.active ? this._xrProperties.nearClip : this._nearClip; + } + set node(newValue) { + this._node = newValue; + } + get node() { + return this._node; + } + set orthoHeight(newValue) { + if (this._orthoHeight !== newValue) { + this._orthoHeight = newValue; + this._projMatDirty = true; + } + } + get orthoHeight() { + return this._orthoHeight; + } + set projection(newValue) { + if (this._projection !== newValue) { + this._projection = newValue; + this._projMatDirty = true; + } + } + get projection() { + return this._projection; + } + get projectionMatrix() { + this._evaluateProjectionMatrix(); + return this._projMat; + } + set rect(newValue) { + this._rect.copy(newValue); + } + get rect() { + return this._rect; + } + set renderTarget(newValue) { + this._renderTarget = newValue; + } + get renderTarget() { + return this._renderTarget; + } + set scissorRect(newValue) { + this._scissorRect.copy(newValue); + } + get scissorRect() { + return this._scissorRect; + } + get viewMatrix() { + if (this._viewMatDirty) { + const wtm = this._node.getWorldTransform(); + this._viewMat.copy(wtm).invert(); + this._viewMatDirty = false; + } + return this._viewMat; + } + set aperture(newValue) { + this._aperture = newValue; + } + get aperture() { + return this._aperture; + } + set sensitivity(newValue) { + this._sensitivity = newValue; + } + get sensitivity() { + return this._sensitivity; + } + set shutter(newValue) { + this._shutter = newValue; + } + get shutter() { + return this._shutter; + } + set xr(newValue) { + if (this._xr !== newValue) { + this._xr = newValue; + this._projMatDirty = true; + } + } + get xr() { + return this._xr; + } + clone() { + return new _Camera().copy(this); + } + copy(other) { + this._aspectRatio = other._aspectRatio; + this._farClip = other._farClip; + this._fov = other._fov; + this._horizontalFov = other._horizontalFov; + this._nearClip = other._nearClip; + this._xrProperties.aspectRatio = other._xrProperties.aspectRatio; + this._xrProperties.farClip = other._xrProperties.farClip; + this._xrProperties.fov = other._xrProperties.fov; + this._xrProperties.horizontalFov = other._xrProperties.horizontalFov; + this._xrProperties.nearClip = other._xrProperties.nearClip; + this.aspectRatioMode = other.aspectRatioMode; + this.calculateProjection = other.calculateProjection; + this.calculateTransform = other.calculateTransform; + this.clearColor = other.clearColor; + this.clearColorBuffer = other.clearColorBuffer; + this.clearDepth = other.clearDepth; + this.clearDepthBuffer = other.clearDepthBuffer; + this.clearStencil = other.clearStencil; + this.clearStencilBuffer = other.clearStencilBuffer; + this.cullFaces = other.cullFaces; + this.flipFaces = other.flipFaces; + this.frustumCulling = other.frustumCulling; + this.layers = other.layers; + this.orthoHeight = other.orthoHeight; + this.projection = other.projection; + this.rect = other.rect; + this.renderTarget = other.renderTarget; + this.scissorRect = other.scissorRect; + this.aperture = other.aperture; + this.shutter = other.shutter; + this.sensitivity = other.sensitivity; + this.shaderPassInfo = other.shaderPassInfo; + this.jitter = other.jitter; + this._projMatDirty = true; + return this; + } + _enableRenderPassColorGrab(device, enable) { + if (enable) { + if (!this.renderPassColorGrab) { + this.renderPassColorGrab = new RenderPassColorGrab(device); + } + } else { + var _this$renderPassColor2; + (_this$renderPassColor2 = this.renderPassColorGrab) == null || _this$renderPassColor2.destroy(); + this.renderPassColorGrab = null; + } + } + _enableRenderPassDepthGrab(device, renderer, enable) { + if (enable) { + if (!this.renderPassDepthGrab) { + this.renderPassDepthGrab = device.isWebGL1 ? new RenderPassDepth(device, renderer, this) : new RenderPassDepthGrab(device, this); + } + } else { + var _this$renderPassDepth2; + (_this$renderPassDepth2 = this.renderPassDepthGrab) == null || _this$renderPassDepth2.destroy(); + this.renderPassDepthGrab = null; + } + } + _updateViewProjMat() { + if (this._projMatDirty || this._viewMatDirty || this._viewProjMatDirty) { + this._viewProjMat.mul2(this.projectionMatrix, this.viewMatrix); + this._viewProjMatDirty = false; + } + } + worldToScreen(worldCoord, cw, ch, screenCoord = new Vec3()) { + this._updateViewProjMat(); + this._viewProjMat.transformPoint(worldCoord, screenCoord); + const vpm = this._viewProjMat.data; + const w = worldCoord.x * vpm[3] + worldCoord.y * vpm[7] + worldCoord.z * vpm[11] + 1 * vpm[15]; + screenCoord.x = (screenCoord.x / w + 1) * 0.5 * cw; + screenCoord.y = (1 - screenCoord.y / w) * 0.5 * ch; + return screenCoord; + } + screenToWorld(x2, y2, z2, cw, ch, worldCoord = new Vec3()) { + const range = this.farClip - this.nearClip; + _deviceCoord.set(x2 / cw, (ch - y2) / ch, z2 / range); + _deviceCoord.mulScalar(2); + _deviceCoord.sub(Vec3.ONE); + if (this._projection === PROJECTION_PERSPECTIVE) { + Mat4._getPerspectiveHalfSize(_halfSize2, this.fov, this.aspectRatio, this.nearClip, this.horizontalFov); + _halfSize2.x *= _deviceCoord.x; + _halfSize2.y *= _deviceCoord.y; + const invView = this._node.getWorldTransform(); + _halfSize2.z = -this.nearClip; + invView.transformPoint(_halfSize2, _point); + const cameraPos = this._node.getPosition(); + worldCoord.sub2(_point, cameraPos); + worldCoord.normalize(); + worldCoord.mulScalar(z2); + worldCoord.add(cameraPos); + } else { + this._updateViewProjMat(); + _invViewProjMat.copy(this._viewProjMat).invert(); + _invViewProjMat.transformPoint(_deviceCoord, worldCoord); + } + return worldCoord; + } + _evaluateProjectionMatrix() { + if (this._projMatDirty) { + if (this._projection === PROJECTION_PERSPECTIVE) { + this._projMat.setPerspective(this.fov, this.aspectRatio, this.nearClip, this.farClip, this.horizontalFov); + this._projMatSkybox.copy(this._projMat); + } else { + const y2 = this._orthoHeight; + const x2 = y2 * this.aspectRatio; + this._projMat.setOrtho(-x2, x2, -y2, y2, this.nearClip, this.farClip); + this._projMatSkybox.setPerspective(this.fov, this.aspectRatio, this.nearClip, this.farClip); + } + this._projMatDirty = false; + } + } + getProjectionMatrixSkybox() { + this._evaluateProjectionMatrix(); + return this._projMatSkybox; + } + getExposure() { + const ev100 = Math.log2(this._aperture * this._aperture / this._shutter * 100 / this._sensitivity); + return 1 / (Math.pow(2, ev100) * 1.2); + } + getScreenSize(sphere) { + if (this._projection === PROJECTION_PERSPECTIVE) { + const distance = this._node.getPosition().distance(sphere.center); + if (distance < sphere.radius) { + return 1; + } + const viewAngle = Math.asin(sphere.radius / distance); + const sphereViewHeight = Math.tan(viewAngle); + const screenViewHeight = Math.tan(this.fov / 2 * math.DEG_TO_RAD); + return Math.min(sphereViewHeight / screenViewHeight, 1); + } + return math.clamp(sphere.radius / this._orthoHeight, 0, 1); + } + getFrustumCorners(near = this.nearClip, far = this.farClip) { + const fov = this.fov * Math.PI / 180; + let y2 = this._projection === PROJECTION_PERSPECTIVE ? Math.tan(fov / 2) * near : this._orthoHeight; + let x2 = y2 * this.aspectRatio; + const points = _frustumPoints; + points[0].x = x2; + points[0].y = -y2; + points[0].z = -near; + points[1].x = x2; + points[1].y = y2; + points[1].z = -near; + points[2].x = -x2; + points[2].y = y2; + points[2].z = -near; + points[3].x = -x2; + points[3].y = -y2; + points[3].z = -near; + if (this._projection === PROJECTION_PERSPECTIVE) { + y2 = Math.tan(fov / 2) * far; + x2 = y2 * this.aspectRatio; + } + points[4].x = x2; + points[4].y = -y2; + points[4].z = -far; + points[5].x = x2; + points[5].y = y2; + points[5].z = -far; + points[6].x = -x2; + points[6].y = y2; + points[6].z = -far; + points[7].x = -x2; + points[7].y = -y2; + points[7].z = -far; + return points; + } + setXrProperties(properties2) { + Object.assign(this._xrProperties, properties2); + this._projMatDirty = true; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/programs/lit-shader-options.js +var LitShaderOptions = class { + constructor() { + this.hasTangents = false; + this.chunks = {}; + this.pass = 0; + this.alphaTest = false; + this.blendType = BLEND_NONE; + this.separateAmbient = false; + this.screenSpace = false; + this.skin = false; + this.useInstancing = false; + this.useMorphPosition = false; + this.useMorphNormal = false; + this.useMorphTextureBased = false; + this.nineSlicedMode = 0; + this.clusteredLightingEnabled = true; + this.clusteredLightingCookiesEnabled = false; + this.clusteredLightingShadowsEnabled = false; + this.clusteredLightingShadowType = 0; + this.clusteredLightingAreaLightsEnabled = false; + this.vertexColors = false; + this.lightMapEnabled = false; + this.dirLightMapEnabled = false; + this.useHeights = false; + this.useNormals = false; + this.useClearCoatNormals = false; + this.useAo = false; + this.diffuseMapEnabled = false; + this.useAmbientTint = false; + this.customFragmentShader = null; + this.pixelSnap = false; + this.shadingModel = 0; + this.ambientSH = false; + this.fastTbn = false; + this.twoSidedLighting = false; + this.occludeDirect = false; + this.occludeSpecular = 0; + this.occludeSpecularFloat = false; + this.useMsdf = false; + this.msdfTextAttribute = false; + this.alphaToCoverage = false; + this.opacityFadesSpecular = false; + this.opacityDither = DITHER_NONE; + this.opacityShadowDither = DITHER_NONE; + this.cubeMapProjection = 0; + this.conserveEnergy = false; + this.useSpecular = false; + this.useSpecularityFactor = false; + this.enableGGXSpecular = false; + this.fresnelModel = 0; + this.useRefraction = false; + this.useClearCoat = false; + this.useSheen = false; + this.useIridescence = false; + this.useMetalness = false; + this.useDynamicRefraction = false; + this.dispersion = false; + this.fog = FOG_NONE; + this.gamma = GAMMA_NONE; + this.toneMap = -1; + this.fixSeams = false; + this.reflectionSource = null; + this.reflectionEncoding = null; + this.reflectionCubemapEncoding = null; + this.ambientSource = "constant"; + this.ambientEncoding = null; + this.skyboxIntensity = 1; + this.useCubeMapRotation = false; + this.lightMapWithoutAmbient = false; + this.lights = []; + this.noShadow = false; + this.lightMaskDynamic = 0; + this.userAttributes = {}; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/materials/lit-material-options-builder.js +var LitMaterialOptionsBuilder = class _LitMaterialOptionsBuilder { + static update(litOptions, material, scene2, objDefs, pass, sortedLights) { + _LitMaterialOptionsBuilder.updateSharedOptions(litOptions, material, scene2, objDefs, pass); + _LitMaterialOptionsBuilder.updateMaterialOptions(litOptions, material); + _LitMaterialOptionsBuilder.updateEnvOptions(litOptions, material, scene2); + _LitMaterialOptionsBuilder.updateLightingOptions(litOptions, material, objDefs, sortedLights); + if (pass === SHADER_FORWARDHDR) { + litOptions.gamma = GAMMA_SRGBHDR; + litOptions.toneMap = TONEMAP_LINEAR; + } + } + static updateSharedOptions(litOptions, material, scene2, objDefs, pass) { + litOptions.chunks = material.chunks; + litOptions.pass = pass; + litOptions.alphaTest = material.alphaTest > 0; + litOptions.blendType = material.blendType; + litOptions.screenSpace = objDefs && (objDefs & SHADERDEF_SCREENSPACE) !== 0; + litOptions.skin = objDefs && (objDefs & SHADERDEF_SKIN) !== 0; + litOptions.useInstancing = objDefs && (objDefs & SHADERDEF_INSTANCING) !== 0; + litOptions.useMorphPosition = objDefs && (objDefs & SHADERDEF_MORPH_POSITION) !== 0; + litOptions.useMorphNormal = objDefs && (objDefs & SHADERDEF_MORPH_NORMAL) !== 0; + litOptions.useMorphTextureBased = objDefs && (objDefs & SHADERDEF_MORPH_TEXTURE_BASED) !== 0; + litOptions.hasTangents = objDefs && (objDefs & SHADERDEF_TANGENTS) !== 0; + litOptions.nineSlicedMode = material.nineSlicedMode || SPRITE_RENDERMODE_SIMPLE; + if (material.useLighting && scene2.clusteredLightingEnabled) { + litOptions.clusteredLightingEnabled = true; + litOptions.clusteredLightingCookiesEnabled = scene2.lighting.cookiesEnabled; + litOptions.clusteredLightingShadowsEnabled = scene2.lighting.shadowsEnabled; + litOptions.clusteredLightingShadowType = scene2.lighting.shadowType; + litOptions.clusteredLightingAreaLightsEnabled = scene2.lighting.areaLightsEnabled; + } else { + litOptions.clusteredLightingEnabled = false; + litOptions.clusteredLightingCookiesEnabled = false; + litOptions.clusteredLightingShadowsEnabled = false; + litOptions.clusteredLightingAreaLightsEnabled = false; + } + } + static updateMaterialOptions(litOptions, material) { + litOptions.useAmbientTint = false; + litOptions.separateAmbient = false; + litOptions.customFragmentShader = null; + litOptions.pixelSnap = material.pixelSnap; + litOptions.shadingModel = material.shadingModel; + litOptions.ambientSH = material.ambientSH; + litOptions.fastTbn = material.fastTbn; + litOptions.twoSidedLighting = material.twoSidedLighting; + litOptions.occludeDirect = material.occludeDirect; + litOptions.occludeSpecular = material.occludeSpecular; + litOptions.occludeSpecularFloat = material.occludeSpecularIntensity !== 1; + litOptions.useMsdf = false; + litOptions.msdfTextAttribute = false; + litOptions.alphaToCoverage = material.alphaToCoverage; + litOptions.opacityFadesSpecular = material.opacityFadesSpecular; + litOptions.opacityDither = material.opacityDither; + litOptions.cubeMapProjection = CUBEPROJ_NONE; + litOptions.conserveEnergy = material.conserveEnergy && material.shadingModel === SPECULAR_BLINN; + litOptions.useSpecular = material.hasSpecular; + litOptions.useSpecularityFactor = material.hasSpecularityFactor; + litOptions.enableGGXSpecular = material.ggxSpecular; + litOptions.fresnelModel = material.fresnelModel; + litOptions.useRefraction = material.hasRefraction; + litOptions.useClearCoat = material.hasClearCoat; + litOptions.useSheen = material.hasSheen; + litOptions.useIridescence = material.hasIrridescence; + litOptions.useMetalness = material.hasMetalness; + litOptions.useDynamicRefraction = material.dynamicRefraction; + litOptions.dispersion = material.dispersion > 0; + litOptions.vertexColors = false; + litOptions.lightMapEnabled = material.hasLighting; + litOptions.dirLightMapEnabled = material.dirLightMap; + litOptions.useHeights = material.hasHeights; + litOptions.useNormals = material.hasNormals; + litOptions.useClearCoatNormals = material.hasClearCoatNormals; + litOptions.useAo = material.hasAo; + litOptions.diffuseMapEnabled = material.hasDiffuseMap; + } + static updateEnvOptions(litOptions, material, scene2) { + litOptions.fog = material.useFog ? scene2.fog : "none"; + litOptions.gamma = material.useGammaTonemap ? scene2.gammaCorrection : GAMMA_NONE; + litOptions.toneMap = material.useGammaTonemap ? scene2.toneMapping : -1; + litOptions.fixSeams = false; + if (material.useSkybox && scene2.envAtlas && scene2.skybox) { + litOptions.reflectionSource = "envAtlasHQ"; + litOptions.reflectionEncoding = scene2.envAtlas.encoding; + litOptions.reflectionCubemapEncoding = scene2.skybox.encoding; + } else if (material.useSkybox && scene2.envAtlas) { + litOptions.reflectionSource = "envAtlas"; + litOptions.reflectionEncoding = scene2.envAtlas.encoding; + } else if (material.useSkybox && scene2.skybox) { + litOptions.reflectionSource = "cubeMap"; + litOptions.reflectionEncoding = scene2.skybox.encoding; + } else { + litOptions.reflectionSource = null; + litOptions.reflectionEncoding = null; + } + if (material.ambientSH) { + litOptions.ambientSource = "ambientSH"; + litOptions.ambientEncoding = null; + } else if (litOptions.reflectionSource && scene2.envAtlas) { + litOptions.ambientSource = "envAtlas"; + litOptions.ambientEncoding = scene2.envAtlas.encoding; + } else { + litOptions.ambientSource = "constant"; + litOptions.ambientEncoding = null; + } + const hasSkybox = !!litOptions.reflectionSource; + litOptions.skyboxIntensity = hasSkybox; + litOptions.useCubeMapRotation = hasSkybox && scene2._skyboxRotationShaderInclude; + } + static updateLightingOptions(litOptions, material, objDefs, sortedLights) { + litOptions.lightMapWithoutAmbient = false; + if (material.useLighting) { + const lightsFiltered = []; + const mask = objDefs ? objDefs >> 16 : MASK_AFFECT_DYNAMIC; + litOptions.lightMaskDynamic = !!(mask & MASK_AFFECT_DYNAMIC); + litOptions.lightMapWithoutAmbient = false; + if (sortedLights) { + _LitMaterialOptionsBuilder.collectLights(LIGHTTYPE_DIRECTIONAL, sortedLights[LIGHTTYPE_DIRECTIONAL], lightsFiltered, mask); + _LitMaterialOptionsBuilder.collectLights(LIGHTTYPE_OMNI, sortedLights[LIGHTTYPE_OMNI], lightsFiltered, mask); + _LitMaterialOptionsBuilder.collectLights(LIGHTTYPE_SPOT, sortedLights[LIGHTTYPE_SPOT], lightsFiltered, mask); + } + litOptions.lights = lightsFiltered; + } else { + litOptions.lights = []; + } + if (litOptions.lights.length === 0 || (objDefs & SHADERDEF_NOSHADOW) !== 0) { + litOptions.noShadow = true; + } + } + static collectLights(lType, lights2, lightsFiltered, mask) { + for (let i = 0; i < lights2.length; i++) { + const light = lights2[i]; + if (light.enabled) { + if (light.mask & mask) { + lightsFiltered.push(light); + } + } + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunk-builder.js +var ChunkBuilder = class { + constructor() { + this.code = ""; + } + append(...chunks) { + chunks.forEach((chunk) => { + if (chunk.endsWith("\n")) { + this.code += chunk; + } else { + this.code += chunk + "\n"; + } + }); + } + prepend(...chunks) { + chunks.forEach((chunk) => { + if (chunk.endsWith("\n")) { + this.code = chunk + this.code; + } else { + this.code = chunk + "\n" + this.code; + } + }); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunk-utils.js +var decodeTable = { + "linear": "decodeLinear", + "srgb": "decodeGamma", + "rgbm": "decodeRGBM", + "rgbe": "decodeRGBE", + "rgbp": "decodeRGBP" +}; +var encodeTable = { + "linear": "encodeLinear", + "srgb": "encodeGamma", + "rgbm": "encodeRGBM", + "rgbe": "encodeRGBE", + "rgbp": "encodeRGBP" +}; +var ChunkUtils = class { + static decodeFunc(encoding) { + return decodeTable[encoding] || "decodeGamma"; + } + static encodeFunc(encoding) { + return encodeTable[encoding] || "encodeGamma"; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/renderer/light-camera.js +var _viewMat = new Mat4(); +var _viewProjMat = new Mat4(); +var _viewportMatrix = new Mat4(); +var LightCamera = class _LightCamera { + static create(name, lightType, face) { + const camera = new Camera(); + camera.node = new GraphNode(name); + camera.aspectRatio = 1; + camera.aspectRatioMode = ASPECT_MANUAL; + camera._scissorRectClear = true; + switch (lightType) { + case LIGHTTYPE_OMNI: + camera.node.setRotation(_LightCamera.pointLightRotations[face]); + camera.fov = 90; + camera.projection = PROJECTION_PERSPECTIVE; + break; + case LIGHTTYPE_SPOT: + camera.projection = PROJECTION_PERSPECTIVE; + break; + case LIGHTTYPE_DIRECTIONAL: + camera.projection = PROJECTION_ORTHOGRAPHIC; + break; + } + return camera; + } + static evalSpotCookieMatrix(light) { + let cookieCamera = _LightCamera._spotCookieCamera; + if (!cookieCamera) { + cookieCamera = _LightCamera.create("SpotCookieCamera", LIGHTTYPE_SPOT); + _LightCamera._spotCookieCamera = cookieCamera; + } + cookieCamera.fov = light._outerConeAngle * 2; + const cookieNode = cookieCamera._node; + cookieNode.setPosition(light._node.getPosition()); + cookieNode.setRotation(light._node.getRotation()); + cookieNode.rotateLocal(-90, 0, 0); + _viewMat.setTRS(cookieNode.getPosition(), cookieNode.getRotation(), Vec3.ONE).invert(); + _viewProjMat.mul2(cookieCamera.projectionMatrix, _viewMat); + const cookieMatrix = light.cookieMatrix; + const rectViewport = light.atlasViewport; + _viewportMatrix.setViewport(rectViewport.x, rectViewport.y, rectViewport.z, rectViewport.w); + cookieMatrix.mul2(_viewportMatrix, _viewProjMat); + return cookieMatrix; + } +}; +LightCamera.pointLightRotations = [new Quat2().setFromEulerAngles(0, 90, 180), new Quat2().setFromEulerAngles(0, -90, 180), new Quat2().setFromEulerAngles(90, 0, 0), new Quat2().setFromEulerAngles(-90, 0, 0), new Quat2().setFromEulerAngles(0, 180, 180), new Quat2().setFromEulerAngles(0, 0, 180)]; +LightCamera._spotCookieCamera = null; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/lighting/lights-buffer.js +var epsilon = 1e-6; +var tempVec3 = new Vec3(); +var tempAreaLightSizes = new Float32Array(6); +var areaHalfAxisWidth = new Vec3(-0.5, 0, 0); +var areaHalfAxisHeight = new Vec3(0, 0, 0.5); +var TextureIndex8 = { + FLAGS: 0, + COLOR_A: 1, + COLOR_B: 2, + SPOT_ANGLES: 3, + SHADOW_BIAS: 4, + COOKIE_A: 5, + COOKIE_B: 6, + COUNT_ALWAYS: 7, + POSITION_X: 7, + POSITION_Y: 8, + POSITION_Z: 9, + RANGE: 10, + SPOT_DIRECTION_X: 11, + SPOT_DIRECTION_Y: 12, + SPOT_DIRECTION_Z: 13, + PROJ_MAT_00: 14, + ATLAS_VIEWPORT_A: 14, + PROJ_MAT_01: 15, + ATLAS_VIEWPORT_B: 15, + PROJ_MAT_02: 16, + PROJ_MAT_03: 17, + PROJ_MAT_10: 18, + PROJ_MAT_11: 19, + PROJ_MAT_12: 20, + PROJ_MAT_13: 21, + PROJ_MAT_20: 22, + PROJ_MAT_21: 23, + PROJ_MAT_22: 24, + PROJ_MAT_23: 25, + PROJ_MAT_30: 26, + PROJ_MAT_31: 27, + PROJ_MAT_32: 28, + PROJ_MAT_33: 29, + AREA_DATA_WIDTH_X: 30, + AREA_DATA_WIDTH_Y: 31, + AREA_DATA_WIDTH_Z: 32, + AREA_DATA_HEIGHT_X: 33, + AREA_DATA_HEIGHT_Y: 34, + AREA_DATA_HEIGHT_Z: 35, + COUNT: 36 +}; +var TextureIndexFloat = { + POSITION_RANGE: 0, + SPOT_DIRECTION: 1, + PROJ_MAT_0: 2, + ATLAS_VIEWPORT: 2, + PROJ_MAT_1: 3, + PROJ_MAT_2: 4, + PROJ_MAT_3: 5, + AREA_DATA_WIDTH: 6, + AREA_DATA_HEIGHT: 7, + COUNT: 8 +}; +var FORMAT_FLOAT = 0; +var FORMAT_8BIT = 1; +var shaderDefinesDeviceCache = new DeviceCache(); +var LightsBuffer = class _LightsBuffer { + static getLightTextureFormat(device) { + return device.extTextureFloat && device.maxTextures > 8 ? FORMAT_FLOAT : FORMAT_8BIT; + } + static getShaderDefines(device) { + return shaderDefinesDeviceCache.get(device, () => { + const buildShaderDefines = (device2, object, prefix, floatOffset2) => { + return Object.keys(object).map((key) => `#define ${prefix}${key} ${object[key]}${floatOffset2}`).join("\n"); + }; + const lightTextureFormat = _LightsBuffer.getLightTextureFormat(device); + const clusterTextureFormat = lightTextureFormat === FORMAT_FLOAT ? "FLOAT" : "8BIT"; + const floatOffset = device.supportsTextureFetch ? "" : ".5"; + return ` + +#define CLUSTER_TEXTURE_${clusterTextureFormat} + ${buildShaderDefines(device, TextureIndex8, "CLUSTER_TEXTURE_8_", floatOffset)} + ${buildShaderDefines(device, TextureIndexFloat, "CLUSTER_TEXTURE_F_", floatOffset)} + `; + }); + } + constructor(device) { + this.device = device; + this.cookiesEnabled = false; + this.shadowsEnabled = false; + this.areaLightsEnabled = false; + this.maxLights = 255; + let pixelsPerLight8 = TextureIndex8.COUNT_ALWAYS; + let pixelsPerLightFloat = 0; + this.lightTextureFormat = _LightsBuffer.getLightTextureFormat(device); + if (this.lightTextureFormat === FORMAT_FLOAT) { + pixelsPerLightFloat = TextureIndexFloat.COUNT; + } else { + pixelsPerLight8 = TextureIndex8.COUNT; + } + this.lights8 = new Uint8ClampedArray(4 * pixelsPerLight8 * this.maxLights); + this.lightsTexture8 = this.createTexture(this.device, pixelsPerLight8, this.maxLights, PIXELFORMAT_RGBA8, "LightsTexture8"); + this._lightsTexture8Id = this.device.scope.resolve("lightsTexture8"); + if (pixelsPerLightFloat) { + this.lightsFloat = new Float32Array(4 * pixelsPerLightFloat * this.maxLights); + this.lightsTextureFloat = this.createTexture(this.device, pixelsPerLightFloat, this.maxLights, PIXELFORMAT_RGBA32F, "LightsTextureFloat"); + this._lightsTextureFloatId = this.device.scope.resolve("lightsTextureFloat"); + } else { + this.lightsFloat = null; + this.lightsTextureFloat = null; + this._lightsTextureFloatId = void 0; + } + this._lightsTextureInvSizeId = this.device.scope.resolve("lightsTextureInvSize"); + this._lightsTextureInvSizeData = new Float32Array(4); + this._lightsTextureInvSizeData[0] = pixelsPerLightFloat ? 1 / this.lightsTextureFloat.width : 0; + this._lightsTextureInvSizeData[1] = pixelsPerLightFloat ? 1 / this.lightsTextureFloat.height : 0; + this._lightsTextureInvSizeData[2] = 1 / this.lightsTexture8.width; + this._lightsTextureInvSizeData[3] = 1 / this.lightsTexture8.height; + this.invMaxColorValue = 0; + this.invMaxAttenuation = 0; + this.boundsMin = new Vec3(); + this.boundsDelta = new Vec3(); + } + destroy() { + if (this.lightsTexture8) { + this.lightsTexture8.destroy(); + this.lightsTexture8 = null; + } + if (this.lightsTextureFloat) { + this.lightsTextureFloat.destroy(); + this.lightsTextureFloat = null; + } + } + createTexture(device, width, height, format, name) { + const tex = new Texture(device, { + name, + width, + height, + mipmaps: false, + format, + addressU: ADDRESS_CLAMP_TO_EDGE, + addressV: ADDRESS_CLAMP_TO_EDGE, + type: TEXTURETYPE_DEFAULT, + magFilter: FILTER_NEAREST, + minFilter: FILTER_NEAREST, + anisotropy: 1 + }); + return tex; + } + setCompressionRanges(maxAttenuation, maxColorValue) { + this.invMaxColorValue = 1 / maxColorValue; + this.invMaxAttenuation = 1 / maxAttenuation; + } + setBounds(min, delta) { + this.boundsMin.copy(min); + this.boundsDelta.copy(delta); + } + uploadTextures() { + if (this.lightsTextureFloat) { + this.lightsTextureFloat.lock().set(this.lightsFloat); + this.lightsTextureFloat.unlock(); + } + this.lightsTexture8.lock().set(this.lights8); + this.lightsTexture8.unlock(); + } + updateUniforms() { + this._lightsTexture8Id.setValue(this.lightsTexture8); + if (this.lightTextureFormat === FORMAT_FLOAT) { + this._lightsTextureFloatId.setValue(this.lightsTextureFloat); + } + this._lightsTextureInvSizeId.setValue(this._lightsTextureInvSizeData); + } + getSpotDirection(direction, spot) { + const mat = spot._node.getWorldTransform(); + mat.getY(direction).mulScalar(-1); + direction.normalize(); + } + getLightAreaSizes(light) { + const mat = light._node.getWorldTransform(); + mat.transformVector(areaHalfAxisWidth, tempVec3); + tempAreaLightSizes[0] = tempVec3.x; + tempAreaLightSizes[1] = tempVec3.y; + tempAreaLightSizes[2] = tempVec3.z; + mat.transformVector(areaHalfAxisHeight, tempVec3); + tempAreaLightSizes[3] = tempVec3.x; + tempAreaLightSizes[4] = tempVec3.y; + tempAreaLightSizes[5] = tempVec3.z; + return tempAreaLightSizes; + } + addLightDataFlags(data8, index, light, isSpot, castShadows, shadowIntensity) { + data8[index + 0] = isSpot ? 255 : 0; + data8[index + 1] = light._shape * 64; + data8[index + 2] = light._falloffMode * 255; + data8[index + 3] = castShadows ? shadowIntensity * 255 : 0; + } + addLightDataColor(data8, index, light, gammaCorrection, isCookie) { + const invMaxColorValue = this.invMaxColorValue; + const color = gammaCorrection ? light._linearFinalColor : light._finalColor; + FloatPacking.float2Bytes(color[0] * invMaxColorValue, data8, index + 0, 2); + FloatPacking.float2Bytes(color[1] * invMaxColorValue, data8, index + 2, 2); + FloatPacking.float2Bytes(color[2] * invMaxColorValue, data8, index + 4, 2); + data8[index + 6] = isCookie ? 255 : 0; + const isDynamic = !!(light.mask & MASK_AFFECT_DYNAMIC); + const isLightmapped = !!(light.mask & MASK_AFFECT_LIGHTMAPPED); + data8[index + 7] = isDynamic && isLightmapped ? 127 : isLightmapped ? 255 : 0; + } + addLightDataSpotAngles(data8, index, light) { + FloatPacking.float2Bytes(light._innerConeAngleCos * (0.5 - epsilon) + 0.5, data8, index + 0, 2); + FloatPacking.float2Bytes(light._outerConeAngleCos * (0.5 - epsilon) + 0.5, data8, index + 2, 2); + } + addLightDataShadowBias(data8, index, light) { + const lightRenderData = light.getRenderData(null, 0); + const biases = light._getUniformBiasValues(lightRenderData); + FloatPacking.float2BytesRange(biases.bias, data8, index, -1, 20, 2); + FloatPacking.float2Bytes(biases.normalBias, data8, index + 2, 2); + } + addLightDataPositionRange(data8, index, light, pos) { + const normPos = tempVec3.sub2(pos, this.boundsMin).div(this.boundsDelta); + FloatPacking.float2Bytes(normPos.x, data8, index + 0, 4); + FloatPacking.float2Bytes(normPos.y, data8, index + 4, 4); + FloatPacking.float2Bytes(normPos.z, data8, index + 8, 4); + FloatPacking.float2Bytes(light.attenuationEnd * this.invMaxAttenuation, data8, index + 12, 4); + } + addLightDataSpotDirection(data8, index, light) { + this.getSpotDirection(tempVec3, light); + FloatPacking.float2Bytes(tempVec3.x * (0.5 - epsilon) + 0.5, data8, index + 0, 4); + FloatPacking.float2Bytes(tempVec3.y * (0.5 - epsilon) + 0.5, data8, index + 4, 4); + FloatPacking.float2Bytes(tempVec3.z * (0.5 - epsilon) + 0.5, data8, index + 8, 4); + } + addLightDataLightProjMatrix(data8, index, lightProjectionMatrix) { + const matData = lightProjectionMatrix.data; + for (let m = 0; m < 12; m++) FloatPacking.float2BytesRange(matData[m], data8, index + 4 * m, -2, 2, 4); + for (let m = 12; m < 16; m++) { + FloatPacking.float2MantissaExponent(matData[m], data8, index + 4 * m, 4); + } + } + addLightDataCookies(data8, index, light) { + const isRgb = light._cookieChannel === "rgb"; + data8[index + 0] = Math.floor(light.cookieIntensity * 255); + data8[index + 1] = isRgb ? 255 : 0; + if (!isRgb) { + const channel = light._cookieChannel; + data8[index + 4] = channel === "rrr" ? 255 : 0; + data8[index + 5] = channel === "ggg" ? 255 : 0; + data8[index + 6] = channel === "bbb" ? 255 : 0; + data8[index + 7] = channel === "aaa" ? 255 : 0; + } + } + addLightAtlasViewport(data8, index, atlasViewport) { + FloatPacking.float2Bytes(atlasViewport.x, data8, index + 0, 2); + FloatPacking.float2Bytes(atlasViewport.y, data8, index + 2, 2); + FloatPacking.float2Bytes(atlasViewport.z / 3, data8, index + 4, 2); + } + addLightAreaSizes(data8, index, light) { + const areaSizes = this.getLightAreaSizes(light); + for (let i = 0; i < 6; i++) { + FloatPacking.float2MantissaExponent(areaSizes[i], data8, index + 4 * i, 4); + } + } + addLightData(light, lightIndex, gammaCorrection) { + const isSpot = light._type === LIGHTTYPE_SPOT; + const hasAtlasViewport = light.atlasViewportAllocated; + const isCookie = this.cookiesEnabled && !!light._cookie && hasAtlasViewport; + const isArea = this.areaLightsEnabled && light.shape !== LIGHTSHAPE_PUNCTUAL; + const castShadows = this.shadowsEnabled && light.castShadows && hasAtlasViewport; + const pos = light._node.getPosition(); + let lightProjectionMatrix = null; + let atlasViewport = null; + if (isSpot) { + if (castShadows) { + const lightRenderData = light.getRenderData(null, 0); + lightProjectionMatrix = lightRenderData.shadowMatrix; + } else if (isCookie) { + lightProjectionMatrix = LightCamera.evalSpotCookieMatrix(light); + } + } else { + if (castShadows || isCookie) { + atlasViewport = light.atlasViewport; + } + } + const data8 = this.lights8; + const data8Start = lightIndex * this.lightsTexture8.width * 4; + this.addLightDataFlags(data8, data8Start + 4 * TextureIndex8.FLAGS, light, isSpot, castShadows, light.shadowIntensity); + this.addLightDataColor(data8, data8Start + 4 * TextureIndex8.COLOR_A, light, gammaCorrection, isCookie); + if (isSpot) { + this.addLightDataSpotAngles(data8, data8Start + 4 * TextureIndex8.SPOT_ANGLES, light); + } + if (light.castShadows) { + this.addLightDataShadowBias(data8, data8Start + 4 * TextureIndex8.SHADOW_BIAS, light); + } + if (isCookie) { + this.addLightDataCookies(data8, data8Start + 4 * TextureIndex8.COOKIE_A, light); + } + if (this.lightTextureFormat === FORMAT_FLOAT) { + const dataFloat = this.lightsFloat; + const dataFloatStart = lightIndex * this.lightsTextureFloat.width * 4; + dataFloat[dataFloatStart + 4 * TextureIndexFloat.POSITION_RANGE + 0] = pos.x; + dataFloat[dataFloatStart + 4 * TextureIndexFloat.POSITION_RANGE + 1] = pos.y; + dataFloat[dataFloatStart + 4 * TextureIndexFloat.POSITION_RANGE + 2] = pos.z; + dataFloat[dataFloatStart + 4 * TextureIndexFloat.POSITION_RANGE + 3] = light.attenuationEnd; + if (isSpot) { + this.getSpotDirection(tempVec3, light); + dataFloat[dataFloatStart + 4 * TextureIndexFloat.SPOT_DIRECTION + 0] = tempVec3.x; + dataFloat[dataFloatStart + 4 * TextureIndexFloat.SPOT_DIRECTION + 1] = tempVec3.y; + dataFloat[dataFloatStart + 4 * TextureIndexFloat.SPOT_DIRECTION + 2] = tempVec3.z; + } + if (lightProjectionMatrix) { + const matData = lightProjectionMatrix.data; + for (let m = 0; m < 16; m++) dataFloat[dataFloatStart + 4 * TextureIndexFloat.PROJ_MAT_0 + m] = matData[m]; + } + if (atlasViewport) { + dataFloat[dataFloatStart + 4 * TextureIndexFloat.ATLAS_VIEWPORT + 0] = atlasViewport.x; + dataFloat[dataFloatStart + 4 * TextureIndexFloat.ATLAS_VIEWPORT + 1] = atlasViewport.y; + dataFloat[dataFloatStart + 4 * TextureIndexFloat.ATLAS_VIEWPORT + 2] = atlasViewport.z / 3; + } + if (isArea) { + const areaSizes = this.getLightAreaSizes(light); + dataFloat[dataFloatStart + 4 * TextureIndexFloat.AREA_DATA_WIDTH + 0] = areaSizes[0]; + dataFloat[dataFloatStart + 4 * TextureIndexFloat.AREA_DATA_WIDTH + 1] = areaSizes[1]; + dataFloat[dataFloatStart + 4 * TextureIndexFloat.AREA_DATA_WIDTH + 2] = areaSizes[2]; + dataFloat[dataFloatStart + 4 * TextureIndexFloat.AREA_DATA_HEIGHT + 0] = areaSizes[3]; + dataFloat[dataFloatStart + 4 * TextureIndexFloat.AREA_DATA_HEIGHT + 1] = areaSizes[4]; + dataFloat[dataFloatStart + 4 * TextureIndexFloat.AREA_DATA_HEIGHT + 2] = areaSizes[5]; + } + } else { + this.addLightDataPositionRange(data8, data8Start + 4 * TextureIndex8.POSITION_X, light, pos); + if (isSpot) { + this.addLightDataSpotDirection(data8, data8Start + 4 * TextureIndex8.SPOT_DIRECTION_X, light); + } + if (lightProjectionMatrix) { + this.addLightDataLightProjMatrix(data8, data8Start + 4 * TextureIndex8.PROJ_MAT_00, lightProjectionMatrix); + } + if (atlasViewport) { + this.addLightAtlasViewport(data8, data8Start + 4 * TextureIndex8.ATLAS_VIEWPORT_A, atlasViewport); + } + if (isArea) { + this.addLightAreaSizes(data8, data8Start + 4 * TextureIndex8.AREA_DATA_WIDTH_X, light); + } + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/programs/lit-shader.js +var builtinAttributes = { + vertex_normal: SEMANTIC_NORMAL, + vertex_tangent: SEMANTIC_TANGENT, + vertex_texCoord0: SEMANTIC_TEXCOORD0, + vertex_texCoord1: SEMANTIC_TEXCOORD1, + vertex_color: SEMANTIC_COLOR, + vertex_boneWeights: SEMANTIC_BLENDWEIGHT, + vertex_boneIndices: SEMANTIC_BLENDINDICES +}; +var builtinVaryings = { + vVertexColor: "vec4", + vPositionW: "vec3", + vNormalV: "vec3", + vNormalW: "vec3", + vTangentW: "vec3", + vBinormalW: "vec3", + vObjectSpaceUpW: "vec3", + vUv0: "vec2", + vUv1: "vec2" +}; +var LitShader = class { + constructor(device, options) { + this.device = device; + this.options = options; + this.attributes = { + vertex_position: SEMANTIC_POSITION + }; + if (options.userAttributes) { + for (const [semantic, name] of Object.entries(options.userAttributes)) { + this.attributes[name] = semantic; + } + } + if (options.chunks) { + const userChunks = options.chunks; + this.chunks = Object.create(shaderChunks); + for (const chunkName in shaderChunks) { + if (userChunks.hasOwnProperty(chunkName)) { + const chunk = userChunks[chunkName]; + for (const a in builtinAttributes) { + if (builtinAttributes.hasOwnProperty(a) && chunk.indexOf(a) >= 0) { + this.attributes[a] = builtinAttributes[a]; + } + } + this.chunks[chunkName] = chunk; + } + } + } else { + this.chunks = shaderChunks; + } + this.shaderPassInfo = ShaderPass.get(this.device).getByIndex(options.pass); + this.shadowPass = this.shaderPassInfo.isShadow; + this.lighting = options.lights.length > 0 || options.dirLightMapEnabled || options.clusteredLightingEnabled; + this.reflections = !!options.reflectionSource; + this.needsNormal = this.lighting || this.reflections || options.useSpecular || options.ambientSH || options.useHeights || options.enableGGXSpecular || options.clusteredLightingEnabled && !this.shadowPass || options.useClearCoatNormals; + this.needsNormal = this.needsNormal && !this.shadowPass; + this.needsSceneColor = options.useDynamicRefraction; + this.needsScreenSize = options.useDynamicRefraction; + this.needsTransforms = options.useDynamicRefraction; + this.varyings = ""; + this.varyingDefines = ""; + this.vshader = null; + this.frontendDecl = null; + this.frontendCode = null; + this.frontendFunc = null; + this.lightingUv = null; + this.defines = []; + this.fshader = null; + } + _vsAddBaseCode(code, chunks, options) { + code += chunks.baseVS; + if (options.nineSlicedMode === SPRITE_RENDERMODE_SLICED || options.nineSlicedMode === SPRITE_RENDERMODE_TILED) { + code += chunks.baseNineSlicedVS; + } + return code; + } + _vsAddTransformCode(code, device, chunks, options) { + code += this.chunks.transformVS; + return code; + } + _setMapTransform(codes, name, id12, uv) { + const checkId = id12 + uv * 100; + if (!codes[3][checkId]) { + const varName = `texture_${name}MapTransform`; + codes[0] += `uniform vec3 ${varName}0; +`; + codes[0] += `uniform vec3 ${varName}1; +`; + codes[1] += `varying vec2 vUV${uv}_${id12}; +`; + codes[2] += ` vUV${uv}_${id12} = vec2(dot(vec3(uv${uv}, 1), ${varName}0), dot(vec3(uv${uv}, 1), ${varName}1)); +`; + codes[3][checkId] = true; + } + return codes; + } + _fsGetBaseCode() { + const options = this.options; + const chunks = this.chunks; + let result = this.chunks.basePS; + if (options.nineSlicedMode === SPRITE_RENDERMODE_SLICED) { + result += chunks.baseNineSlicedPS; + } else if (options.nineSlicedMode === SPRITE_RENDERMODE_TILED) { + result += chunks.baseNineSlicedTiledPS; + } + return result; + } + _fsGetStartCode(code, device, chunks, options) { + let result = chunks.startPS; + if (options.nineSlicedMode === SPRITE_RENDERMODE_SLICED) { + result += chunks.startNineSlicedPS; + } else if (options.nineSlicedMode === SPRITE_RENDERMODE_TILED) { + result += chunks.startNineSlicedTiledPS; + } + return result; + } + _getLightSourceShapeString(shape2) { + switch (shape2) { + case LIGHTSHAPE_RECT: + return "Rect"; + case LIGHTSHAPE_DISK: + return "Disk"; + case LIGHTSHAPE_SPHERE: + return "Sphere"; + default: + return ""; + } + } + generateVertexShader(useUv, useUnmodifiedUv, mapTransforms) { + const device = this.device; + const options = this.options; + const chunks = this.chunks; + let code = ""; + let codeBody = ""; + code = this._vsAddBaseCode(code, chunks, options); + codeBody += " vPositionW = getWorldPosition();\n"; + if (this.options.pass === SHADER_DEPTH || this.options.pass === SHADER_PREPASS_VELOCITY) { + code += "varying float vDepth;\n"; + code += "#ifndef VIEWMATRIX\n"; + code += "#define VIEWMATRIX\n"; + code += "uniform mat4 matrix_view;\n"; + code += "#endif\n"; + code += "#ifndef CAMERAPLANES\n"; + code += "#define CAMERAPLANES\n"; + code += "uniform vec4 camera_params;\n\n"; + code += "#endif\n"; + codeBody += " vDepth = -(matrix_view * vec4(vPositionW,1.0)).z * camera_params.x;\n"; + } + if (this.options.pass === SHADER_PREPASS_VELOCITY) ; + if (this.options.useInstancing) { + this.attributes.instance_line1 = SEMANTIC_ATTR12; + this.attributes.instance_line2 = SEMANTIC_ATTR13; + this.attributes.instance_line3 = SEMANTIC_ATTR14; + this.attributes.instance_line4 = SEMANTIC_ATTR15; + code += chunks.instancingVS; + } + if (this.needsNormal) { + this.attributes.vertex_normal = SEMANTIC_NORMAL; + codeBody += " vNormalW = getNormal();\n"; + if (options.reflectionSource === "sphereMap" && device.fragmentUniformsCount <= 16) { + code += chunks.viewNormalVS; + codeBody += " vNormalV = getViewNormal();\n"; + } + if (options.hasTangents && (options.useHeights || options.useNormals || options.enableGGXSpecular)) { + this.attributes.vertex_tangent = SEMANTIC_TANGENT; + code += chunks.tangentBinormalVS; + codeBody += " vTangentW = getTangent();\n"; + codeBody += " vBinormalW = getBinormal();\n"; + } else if (options.enableGGXSpecular || !device.extStandardDerivatives) { + codeBody += " vObjectSpaceUpW = normalize(dNormalMatrix * vec3(0, 1, 0));\n"; + } + } + const maxUvSets = 2; + for (let i = 0; i < maxUvSets; i++) { + if (useUv[i]) { + this.attributes["vertex_texCoord" + i] = "TEXCOORD" + i; + code += chunks["uv" + i + "VS"]; + codeBody += " vec2 uv" + i + " = getUv" + i + "();\n"; + } + if (useUnmodifiedUv[i]) { + codeBody += " vUv" + i + " = uv" + i + ";\n"; + } + } + const codes = [code, this.varyings, codeBody, []]; + mapTransforms.forEach((mapTransform) => { + this._setMapTransform(codes, mapTransform.name, mapTransform.id, mapTransform.uv); + }); + code = codes[0]; + this.varyings = codes[1]; + codeBody = codes[2]; + if (options.vertexColors) { + this.attributes.vertex_color = SEMANTIC_COLOR; + codeBody += " vVertexColor = vertex_color;\n"; + } + if (options.useMsdf && options.msdfTextAttribute) { + this.attributes.vertex_outlineParameters = SEMANTIC_ATTR8; + this.attributes.vertex_shadowParameters = SEMANTIC_ATTR9; + codeBody += " unpackMsdfParams();\n"; + code += chunks.msdfVS; + } + if (options.useMorphPosition || options.useMorphNormal) { + if (options.useMorphTextureBased) { + code += "#define MORPHING_TEXTURE_BASED\n"; + if (options.useMorphPosition) { + code += "#define MORPHING_TEXTURE_BASED_POSITION\n"; + } + if (options.useMorphNormal) { + code += "#define MORPHING_TEXTURE_BASED_NORMAL\n"; + } + this.attributes.morph_vertex_id = SEMANTIC_ATTR15; + const morphIdType = device.isWebGPU ? "uint" : "float"; + code += `attribute ${morphIdType} morph_vertex_id; +`; + } else { + code += "#define MORPHING\n"; + if (options.useMorphPosition) { + this.attributes.morph_pos0 = SEMANTIC_ATTR8; + this.attributes.morph_pos1 = SEMANTIC_ATTR9; + this.attributes.morph_pos2 = SEMANTIC_ATTR10; + this.attributes.morph_pos3 = SEMANTIC_ATTR11; + code += "#define MORPHING_POS03\n"; + code += "attribute vec3 morph_pos0;\n"; + code += "attribute vec3 morph_pos1;\n"; + code += "attribute vec3 morph_pos2;\n"; + code += "attribute vec3 morph_pos3;\n"; + } else if (options.useMorphNormal) { + this.attributes.morph_nrm0 = SEMANTIC_ATTR8; + this.attributes.morph_nrm1 = SEMANTIC_ATTR9; + this.attributes.morph_nrm2 = SEMANTIC_ATTR10; + this.attributes.morph_nrm3 = SEMANTIC_ATTR11; + code += "#define MORPHING_NRM03\n"; + code += "attribute vec3 morph_nrm0;\n"; + code += "attribute vec3 morph_nrm1;\n"; + code += "attribute vec3 morph_nrm2;\n"; + code += "attribute vec3 morph_nrm3;\n"; + } + if (!options.useMorphNormal) { + this.attributes.morph_pos4 = SEMANTIC_ATTR12; + this.attributes.morph_pos5 = SEMANTIC_ATTR13; + this.attributes.morph_pos6 = SEMANTIC_ATTR14; + this.attributes.morph_pos7 = SEMANTIC_ATTR15; + code += "#define MORPHING_POS47\n"; + code += "attribute vec3 morph_pos4;\n"; + code += "attribute vec3 morph_pos5;\n"; + code += "attribute vec3 morph_pos6;\n"; + code += "attribute vec3 morph_pos7;\n"; + } else { + this.attributes.morph_nrm4 = SEMANTIC_ATTR12; + this.attributes.morph_nrm5 = SEMANTIC_ATTR13; + this.attributes.morph_nrm6 = SEMANTIC_ATTR14; + this.attributes.morph_nrm7 = SEMANTIC_ATTR15; + code += "#define MORPHING_NRM47\n"; + code += "attribute vec3 morph_nrm4;\n"; + code += "attribute vec3 morph_nrm5;\n"; + code += "attribute vec3 morph_nrm6;\n"; + code += "attribute vec3 morph_nrm7;\n"; + } + } + } + if (options.skin) { + this.attributes.vertex_boneWeights = SEMANTIC_BLENDWEIGHT; + this.attributes.vertex_boneIndices = SEMANTIC_BLENDINDICES; + code += ShaderGenerator.skinCode(device, chunks); + code += "#define SKIN\n"; + } else if (options.useInstancing) { + code += "#define INSTANCING\n"; + } + if (options.screenSpace) { + code += "#define SCREENSPACE\n"; + } + if (options.pixelSnap) { + code += "#define PIXELSNAP\n"; + } + code = this._vsAddTransformCode(code, device, chunks, options); + if (this.needsNormal) { + code += chunks.normalVS; + } + code += "\n"; + code += chunks.startVS; + code += codeBody; + code += chunks.endVS; + code += "}"; + Object.keys(builtinVaryings).forEach((v) => { + if (code.indexOf(v) >= 0) { + this.varyings += `varying ${builtinVaryings[v]} ${v}; +`; + this.varyingDefines += `#define VARYING_${v.toUpperCase()} +`; + } + }); + const shaderPassDefines = this.shaderPassInfo.shaderDefines; + this.vshader = shaderPassDefines + this.varyings + code; + } + _fsGetBeginCode() { + let code = this.shaderPassInfo.shaderDefines; + for (let i = 0; i < this.defines.length; i++) { + code += `#define ${this.defines[i]} +`; + } + return code; + } + _fsGetPickPassCode() { + let code = this._fsGetBeginCode(); + code += "uniform vec4 uColor;\n"; + code += this.varyings; + code += this.varyingDefines; + code += this.frontendDecl; + code += this.frontendCode; + code += ShaderGenerator.begin(); + code += this.frontendFunc; + code += " gl_FragColor = uColor;\n"; + code += ShaderGenerator.end(); + return code; + } + _fsGetDepthPassCode() { + const chunks = this.chunks; + let code = this._fsGetBeginCode(); + code += "varying float vDepth;\n"; + code += this.varyings; + code += this.varyingDefines; + code += chunks.packDepthPS; + code += this.frontendDecl; + code += this.frontendCode; + code += ShaderGenerator.begin(); + code += this.frontendFunc; + code += " gl_FragColor = packFloat(vDepth);\n"; + code += ShaderGenerator.end(); + return code; + } + _fsGetPrePassVelocityCode() { + return this._fsGetDepthPassCode(); + } + _fsGetShadowPassCode() { + const device = this.device; + const options = this.options; + const chunks = this.chunks; + const varyings = this.varyings; + const lightType = this.shaderPassInfo.lightType; + let shadowType = this.shaderPassInfo.shadowType; + if (lightType !== LIGHTTYPE_DIRECTIONAL && options.clusteredLightingEnabled) { + if (shadowType === SHADOW_VSM8 || shadowType === SHADOW_VSM16 || shadowType === SHADOW_VSM32 || shadowType === SHADOW_PCSS) { + shadowType = SHADOW_PCF3; + } + } + let code = this._fsGetBeginCode(); + if (device.extStandardDerivatives && device.isWebGL1) { + code += "uniform vec2 polygonOffset;\n"; + } + if (shadowType === SHADOW_VSM32) { + if (device.textureFloatHighPrecision) { + code += "#define VSM_EXPONENT 15.0\n\n"; + } else { + code += "#define VSM_EXPONENT 5.54\n\n"; + } + } else if (shadowType === SHADOW_VSM16) { + code += "#define VSM_EXPONENT 5.54\n\n"; + } + if (lightType !== LIGHTTYPE_DIRECTIONAL) { + code += "uniform vec3 view_position;\n"; + code += "uniform float light_radius;\n"; + } + code += varyings; + code += this.varyingDefines; + code += this.frontendDecl; + code += this.frontendCode; + const mayPackDepth = shadowType === SHADOW_PCF1 || shadowType === SHADOW_PCF3 || shadowType === SHADOW_PCF5 || shadowType === SHADOW_PCSS; + const mustPackDepth = lightType === LIGHTTYPE_OMNI && shadowType !== SHADOW_PCSS && !options.clusteredLightingEnabled; + const usePackedDepth = mayPackDepth && !device.supportsDepthShadow || mustPackDepth; + if (usePackedDepth) { + code += chunks.packDepthPS; + } else if (shadowType === SHADOW_VSM8) { + code += "vec2 encodeFloatRG( float v ) {\n"; + code += " vec2 enc = vec2(1.0, 255.0) * v;\n"; + code += " enc = fract(enc);\n"; + code += " enc -= enc.yy * vec2(1.0/255.0, 1.0/255.0);\n"; + code += " return enc;\n"; + code += "}\n\n"; + } + if (shadowType === SHADOW_PCSS) { + code += shaderChunks.linearizeDepthPS; + } + code += ShaderGenerator.begin(); + code += this.frontendFunc; + const isVsm = shadowType === SHADOW_VSM8 || shadowType === SHADOW_VSM16 || shadowType === SHADOW_VSM32; + const applySlopeScaleBias = device.isWebGL1 && device.extStandardDerivatives; + const usePerspectiveDepth = lightType === LIGHTTYPE_DIRECTIONAL || !isVsm && lightType === LIGHTTYPE_SPOT; + let hasModifiedDepth = false; + if (usePerspectiveDepth) { + code += " float depth = gl_FragCoord.z;\n"; + } else { + code += " float depth = min(distance(view_position, vPositionW) / light_radius, 0.99999);\n"; + hasModifiedDepth = true; + } + if (applySlopeScaleBias) { + code += " float minValue = 2.3374370500153186e-10; //(1.0 / 255.0) / (256.0 * 256.0 * 256.0);\n"; + code += " depth += polygonOffset.x * max(abs(dFdx(depth)), abs(dFdy(depth))) + minValue * polygonOffset.y;\n"; + hasModifiedDepth = true; + } + if (usePackedDepth) { + code += " gl_FragColor = packFloat(depth);\n"; + } else if (!isVsm) { + const exportR32 = shadowType === SHADOW_PCSS; + if (exportR32) { + code += " gl_FragColor.r = depth;\n"; + } else { + if (hasModifiedDepth) { + code += " gl_FragDepth = depth;\n"; + } + code += " gl_FragColor = vec4(1.0);\n"; + } + } else if (shadowType === SHADOW_VSM8) { + code += " gl_FragColor = vec4(encodeFloatRG(depth), encodeFloatRG(depth*depth));\n"; + } else { + code += chunks.storeEVSMPS; + } + code += ShaderGenerator.end(); + return code; + } + _fsGetLitPassCode() { + const device = this.device; + const options = this.options; + const chunks = this.chunks; + const decl = new ChunkBuilder(); + const func = new ChunkBuilder(); + const backend = new ChunkBuilder(); + const code = new ChunkBuilder(); + if (options.opacityFadesSpecular === false) { + decl.append("uniform float material_alphaFade;"); + } + if (options.useSpecular) { + this.defines.push("LIT_SPECULAR"); + if (this.reflections) { + this.defines.push("LIT_REFLECTIONS"); + } + if (options.useClearCoat) { + this.defines.push("LIT_CLEARCOAT"); + } + if (options.fresnelModel > 0) { + this.defines.push("LIT_SPECULAR_FRESNEL"); + } + if (options.conserveEnergy) { + this.defines.push("LIT_CONSERVE_ENERGY"); + } + if (options.useSheen) { + this.defines.push("LIT_SHEEN"); + } + if (options.useIridescence) { + this.defines.push("LIT_IRIDESCENCE"); + } + } + const shadowTypeUsed = []; + let numShadowLights = 0; + let shadowedDirectionalLightUsed = false; + let useVsm = false; + let usePcss = false; + let hasAreaLights = options.lights.some(function(light) { + return light._shape && light._shape !== LIGHTSHAPE_PUNCTUAL; + }); + if (options.clusteredLightingEnabled && options.clusteredLightingAreaLightsEnabled) { + hasAreaLights = true; + } + if (hasAreaLights || options.clusteredLightingEnabled) { + let areaLutsPrecision = "highp"; + if (device.areaLightLutFormat === PIXELFORMAT_RGBA8) { + decl.append("#define AREA_R8_G8_B8_A8_LUTS"); + areaLutsPrecision = "lowp"; + } + decl.append("#define AREA_LIGHTS"); + decl.append(`uniform ${areaLutsPrecision} sampler2D areaLightsLutTex1;`); + decl.append(`uniform ${areaLutsPrecision} sampler2D areaLightsLutTex2;`); + } + for (let i = 0; i < options.lights.length; i++) { + const light = options.lights[i]; + const lightType = light._type; + if (options.clusteredLightingEnabled && lightType !== LIGHTTYPE_DIRECTIONAL) continue; + const lightShape = hasAreaLights && light._shape ? light._shape : LIGHTSHAPE_PUNCTUAL; + decl.append("uniform vec3 light" + i + "_color;"); + if (light._shadowType === SHADOW_PCSS && light.castShadows && !options.noShadow) { + decl.append(`uniform float light${i}_shadowSearchArea;`); + decl.append(`uniform vec4 light${i}_cameraParams;`); + } + if (lightType === LIGHTTYPE_DIRECTIONAL) { + decl.append("uniform vec3 light" + i + "_direction;"); + } else { + decl.append("uniform vec3 light" + i + "_position;"); + decl.append("uniform float light" + i + "_radius;"); + if (lightType === LIGHTTYPE_SPOT) { + decl.append("uniform vec3 light" + i + "_direction;"); + decl.append("uniform float light" + i + "_innerConeAngle;"); + decl.append("uniform float light" + i + "_outerConeAngle;"); + } + } + if (lightShape !== LIGHTSHAPE_PUNCTUAL) { + if (lightType === LIGHTTYPE_DIRECTIONAL) { + decl.append("uniform vec3 light" + i + "_position;"); + } + decl.append("uniform vec3 light" + i + "_halfWidth;"); + decl.append("uniform vec3 light" + i + "_halfHeight;"); + } + if (light.castShadows && !options.noShadow) { + decl.append("uniform mat4 light" + i + "_shadowMatrix;"); + decl.append("uniform float light" + i + "_shadowIntensity;"); + if (lightType === LIGHTTYPE_DIRECTIONAL) { + decl.append("uniform mat4 light" + i + "_shadowMatrixPalette[4];"); + decl.append("uniform float light" + i + "_shadowCascadeDistances[4];"); + decl.append("uniform float light" + i + "_shadowCascadeCount;"); + } + decl.append("uniform vec4 light" + i + "_shadowParams;"); + if (lightType === LIGHTTYPE_DIRECTIONAL) { + shadowedDirectionalLightUsed = true; + } + if (lightType === LIGHTTYPE_OMNI) { + decl.append("uniform samplerCube light" + i + "_shadowMap;"); + } else { + if (light._isPcf && device.supportsDepthShadow) { + decl.append("uniform sampler2DShadow light" + i + "_shadowMap;"); + } else { + decl.append("uniform sampler2D light" + i + "_shadowMap;"); + } + } + numShadowLights++; + shadowTypeUsed[light._shadowType] = true; + if (light._isVsm) useVsm = true; + if (light._shadowType === SHADOW_PCSS) usePcss = true; + } + if (light._cookie) { + if (light._cookie._cubemap) { + if (lightType === LIGHTTYPE_OMNI) { + decl.append("uniform samplerCube light" + i + "_cookie;"); + decl.append("uniform float light" + i + "_cookieIntensity;"); + if (!light.castShadows || options.noShadow) { + decl.append("uniform mat4 light" + i + "_shadowMatrix;"); + } + } + } else { + if (lightType === LIGHTTYPE_SPOT) { + decl.append("uniform sampler2D light" + i + "_cookie;"); + decl.append("uniform float light" + i + "_cookieIntensity;"); + if (!light.castShadows || options.noShadow) { + decl.append("uniform mat4 light" + i + "_shadowMatrix;"); + } + if (light._cookieTransform) { + decl.append("uniform vec4 light" + i + "_cookieMatrix;"); + decl.append("uniform vec2 light" + i + "_cookieOffset;"); + } + } + } + } + } + const hasTBN = this.needsNormal && (options.useNormals || options.useClearCoatNormals || options.enableGGXSpecular && !options.useHeights); + if (hasTBN) { + if (options.hasTangents) { + func.append(options.fastTbn ? chunks.TBNfastPS : chunks.TBNPS); + } else { + if (device.extStandardDerivatives && (options.useNormals || options.useClearCoatNormals)) { + func.append(chunks.TBNderivativePS.replace(/\$UV/g, this.lightingUv)); + } else { + func.append(chunks.TBNObjectSpacePS); + } + } + if (options.twoSidedLighting) { + func.append(chunks.twoSidedLightingPS); + } + } + func.append(chunks.sphericalPS); + func.append(chunks.decodePS); + func.append(ShaderGenerator.gammaCode(options.gamma, chunks)); + func.append(ShaderGenerator.tonemapCode(options.toneMap, chunks)); + func.append(ShaderGenerator.fogCode(options.fog, chunks)); + func.append(this.frontendCode); + if (options.useCubeMapRotation) { + decl.append("#define CUBEMAP_ROTATION"); + } + if (this.needsNormal) { + func.append(chunks.cubeMapRotatePS); + func.append(options.cubeMapProjection > 0 ? chunks.cubeMapProjectBoxPS : chunks.cubeMapProjectNonePS); + func.append(options.skyboxIntensity ? chunks.envMultiplyPS : chunks.envConstPS); + } + if (this.lighting && options.useSpecular || this.reflections) { + if (options.useMetalness) { + func.append(chunks.metalnessModulatePS); + } + if (options.fresnelModel === FRESNEL_SCHLICK) { + func.append(chunks.fresnelSchlickPS); + } + if (options.useIridescence) { + func.append(chunks.iridescenceDiffractionPS); + } + } + if (options.useAo) { + func.append(chunks.aoDiffuseOccPS); + switch (options.occludeSpecular) { + case SPECOCC_AO: + func.append(options.occludeSpecularFloat ? chunks.aoSpecOccSimplePS : chunks.aoSpecOccConstSimplePS); + break; + case SPECOCC_GLOSSDEPENDENT: + func.append(options.occludeSpecularFloat ? chunks.aoSpecOccPS : chunks.aoSpecOccConstPS); + break; + } + } + if (options.reflectionSource === "envAtlasHQ") { + func.append(options.fixSeams ? chunks.fixCubemapSeamsStretchPS : chunks.fixCubemapSeamsNonePS); + func.append(chunks.envAtlasPS); + func.append(chunks.reflectionEnvHQPS.replace(/\$DECODE_CUBEMAP/g, ChunkUtils.decodeFunc(options.reflectionCubemapEncoding)).replace(/\$DECODE/g, ChunkUtils.decodeFunc(options.reflectionEncoding))); + } else if (options.reflectionSource === "envAtlas") { + func.append(chunks.envAtlasPS); + func.append(chunks.reflectionEnvPS.replace(/\$DECODE/g, ChunkUtils.decodeFunc(options.reflectionEncoding))); + } else if (options.reflectionSource === "cubeMap") { + func.append(options.fixSeams ? chunks.fixCubemapSeamsStretchPS : chunks.fixCubemapSeamsNonePS); + func.append(chunks.reflectionCubePS.replace(/\$DECODE/g, ChunkUtils.decodeFunc(options.reflectionEncoding))); + } else if (options.reflectionSource === "sphereMap") { + func.append(chunks.reflectionSpherePS.replace(/\$DECODE/g, ChunkUtils.decodeFunc(options.reflectionEncoding))); + } + if (this.reflections) { + if (options.useClearCoat) { + func.append(chunks.reflectionCCPS); + } + if (options.useSheen) { + func.append(chunks.reflectionSheenPS); + } + } + if (options.useRefraction) { + if (options.useDynamicRefraction) { + if (options.dispersion) { + decl.append("uniform float material_dispersion;"); + decl.append("#define DISPERSION\n"); + } + func.append(chunks.refractionDynamicPS); + } else if (this.reflections) { + func.append(chunks.refractionCubePS); + } + } + if (options.useSheen) { + func.append(chunks.lightSheenPS); + } + if (options.clusteredLightingEnabled) { + func.append(chunks.clusteredLightUtilsPS); + if (options.clusteredLightingCookiesEnabled) func.append(chunks.clusteredLightCookiesPS); + if (options.clusteredLightingShadowsEnabled && !options.noShadow) { + shadowTypeUsed[SHADOW_PCF3] = true; + shadowTypeUsed[SHADOW_PCF5] = true; + shadowTypeUsed[SHADOW_PCSS] = true; + } + } + if (numShadowLights > 0 || options.clusteredLightingEnabled) { + if (shadowedDirectionalLightUsed) { + func.append(chunks.shadowCascadesPS); + } + if (shadowTypeUsed[SHADOW_PCF1] || shadowTypeUsed[SHADOW_PCF3]) { + func.append(chunks.shadowStandardPS); + } + if (shadowTypeUsed[SHADOW_PCF5] && !device.isWebGL1) { + func.append(chunks.shadowStandardGL2PS); + } + if (useVsm) { + func.append(chunks.shadowVSM_commonPS); + if (shadowTypeUsed[SHADOW_VSM8]) { + func.append(chunks.shadowVSM8PS); + } + if (shadowTypeUsed[SHADOW_VSM16]) { + func.append(device.extTextureHalfFloatLinear ? chunks.shadowEVSMPS.replace(/\$/g, "16") : chunks.shadowEVSMnPS.replace(/\$/g, "16")); + } + if (shadowTypeUsed[SHADOW_VSM32]) { + func.append(device.extTextureFloatLinear ? chunks.shadowEVSMPS.replace(/\$/g, "32") : chunks.shadowEVSMnPS.replace(/\$/g, "32")); + } + } + if (usePcss) { + func.append(chunks.linearizeDepthPS); + func.append(chunks.shadowPCSSPS); + } + if (!(device.isWebGL2 || device.isWebGPU || device.extStandardDerivatives)) { + func.append(chunks.biasConstPS); + } + } + if (options.enableGGXSpecular) func.append("uniform float material_anisotropy;"); + if (this.lighting) { + func.append(chunks.lightDiffuseLambertPS); + if (hasAreaLights || options.clusteredLightingAreaLightsEnabled) { + func.append(chunks.ltcPS); + } + } + let useOldAmbient = false; + if (options.useSpecular) { + if (this.lighting) { + func.append(options.shadingModel === SPECULAR_PHONG ? chunks.lightSpecularPhongPS : options.enableGGXSpecular ? chunks.lightSpecularAnisoGGXPS : chunks.lightSpecularBlinnPS); + } + if (!options.fresnelModel && !this.reflections && !options.diffuseMapEnabled) { + decl.append("uniform vec3 material_ambient;"); + decl.append("#define LIT_OLD_AMBIENT"); + useOldAmbient = true; + } + } + func.append(chunks.combinePS); + if (options.lightMapEnabled) { + func.append(options.useSpecular && options.dirLightMapEnabled ? chunks.lightmapDirAddPS : chunks.lightmapAddPS); + } + const addAmbient = !options.lightMapEnabled || options.lightMapWithoutAmbient; + if (addAmbient) { + if (options.ambientSource === "ambientSH") { + func.append(chunks.ambientSHPS); + } else if (options.ambientSource === "envAtlas") { + if (options.reflectionSource !== "envAtlas" && options.reflectionSource !== "envAtlasHQ") { + func.append(chunks.envAtlasPS); + } + func.append(chunks.ambientEnvPS.replace(/\$DECODE/g, ChunkUtils.decodeFunc(options.ambientEncoding))); + } else { + func.append(chunks.ambientConstantPS); + } + } + if (options.useAmbientTint && !useOldAmbient) { + decl.append("uniform vec3 material_ambient;"); + } + if (options.useMsdf) { + if (!options.msdfTextAttribute) { + decl.append("#define UNIFORM_TEXT_PARAMETERS"); + } + func.append(chunks.msdfPS); + } + if (this.needsNormal) { + func.append(chunks.viewDirPS); + if (options.useSpecular) { + func.append(options.enableGGXSpecular ? chunks.reflDirAnisoPS : chunks.reflDirPS); + } + } + let hasPointLights = false; + let usesLinearFalloff = false; + let usesInvSquaredFalloff = false; + let usesSpot = false; + let usesCookie = false; + let usesCookieNow; + if (options.clusteredLightingEnabled && this.lighting) { + usesSpot = true; + hasPointLights = true; + usesLinearFalloff = true; + usesCookie = true; + func.append(chunks.floatUnpackingPS); + if (options.lightMaskDynamic) decl.append("#define CLUSTER_MESH_DYNAMIC_LIGHTS"); + if (options.clusteredLightingCookiesEnabled) decl.append("#define CLUSTER_COOKIES"); + if (options.clusteredLightingShadowsEnabled && !options.noShadow) { + decl.append("#define CLUSTER_SHADOWS"); + decl.append("#define CLUSTER_SHADOW_TYPE_" + shadowTypeToString[options.clusteredLightingShadowType]); + } + if (options.clusteredLightingAreaLightsEnabled) decl.append("#define CLUSTER_AREALIGHTS"); + decl.append(LightsBuffer.getShaderDefines(device)); + if (options.clusteredLightingShadowsEnabled && !options.noShadow) { + func.append(chunks.clusteredLightShadowsPS); + } + func.append(chunks.clusteredLightPS); + } + code.append(this._fsGetStartCode(code, device, chunks, options)); + if (this.needsNormal) { + code.append(" dVertexNormalW = normalize(vNormalW);"); + if ((options.useHeights || options.useNormals) && options.hasTangents) { + code.append(" dTangentW = vTangentW;"); + code.append(" dBinormalW = vBinormalW;"); + } + code.append(" getViewDir();"); + if (hasTBN) { + code.append(" getTBN(dTangentW, dBinormalW, dVertexNormalW);"); + if (options.twoSidedLighting) { + code.append(" handleTwoSidedLighting();"); + } + } + } + code.append(this.frontendFunc); + if (this.needsNormal) { + if (options.useSpecular) { + backend.append(" getReflDir(litArgs_worldNormal, dViewDirW, litArgs_gloss, dTBN);"); + } + if (options.useClearCoat) { + backend.append(" ccReflDirW = normalize(-reflect(dViewDirW, litArgs_clearcoat_worldNormal));"); + } + } + if (this.lighting && options.useSpecular || this.reflections) { + if (options.useMetalness) { + backend.append(" float f0 = 1.0 / litArgs_ior; f0 = (f0 - 1.0) / (f0 + 1.0); f0 *= f0;"); + backend.append(" litArgs_specularity = getSpecularModulate(litArgs_specularity, litArgs_albedo, litArgs_metalness, f0);"); + backend.append(" litArgs_albedo = getAlbedoModulate(litArgs_albedo, litArgs_metalness);"); + } + if (options.useIridescence) { + backend.append(" vec3 iridescenceFresnel = getIridescence(saturate(dot(dViewDirW, litArgs_worldNormal)), litArgs_specularity, litArgs_iridescence_thickness);"); + } + } + if (addAmbient) { + backend.append(" addAmbient(litArgs_worldNormal);"); + if (options.conserveEnergy && options.useSpecular) { + backend.append(` dDiffuseLight = dDiffuseLight * (1.0 - litArgs_specularity);`); + } + if (options.separateAmbient) { + backend.append(` + vec3 dAmbientLight = dDiffuseLight; + dDiffuseLight = vec3(0); + `); + } + } + if (options.useAmbientTint && !useOldAmbient) { + backend.append(" dDiffuseLight *= material_ambient;"); + } + if (options.useAo && !options.occludeDirect) { + backend.append(" occludeDiffuse(litArgs_ao);"); + } + if (options.lightMapEnabled) { + backend.append(` addLightMap( + litArgs_lightmap, + litArgs_lightmapDir, + litArgs_worldNormal, + dViewDirW, + dReflDirW, + litArgs_gloss, + litArgs_specularity, + dVertexNormalW, + dTBN + #if defined(LIT_IRIDESCENCE) + , iridescenceFresnel, + litArgs_iridescence_intensity + #endif + );`); + } + if (this.lighting || this.reflections) { + if (this.reflections) { + if (options.useClearCoat) { + backend.append(" addReflectionCC(ccReflDirW, litArgs_clearcoat_gloss);"); + if (options.fresnelModel > 0) { + backend.append(" ccFresnel = getFresnelCC(dot(dViewDirW, litArgs_clearcoat_worldNormal));"); + backend.append(" ccReflection.rgb *= ccFresnel;"); + } else { + backend.append(" ccFresnel = 0.0;"); + } + } + if (options.useSpecularityFactor) { + backend.append(" ccReflection.rgb *= litArgs_specularityFactor;"); + } + if (options.useSheen) { + backend.append(" addReflectionSheen(litArgs_worldNormal, dViewDirW, litArgs_sheen_gloss);"); + } + backend.append(" addReflection(dReflDirW, litArgs_gloss);"); + if (options.fresnelModel > 0) { + backend.append(` dReflection.rgb *= + getFresnel( + dot(dViewDirW, litArgs_worldNormal), + litArgs_gloss, + litArgs_specularity + #if defined(LIT_IRIDESCENCE) + , iridescenceFresnel, + litArgs_iridescence_intensity + #endif + );`); + } else { + backend.append(" dReflection.rgb *= litArgs_specularity;"); + } + if (options.useSpecularityFactor) { + backend.append(" dReflection.rgb *= litArgs_specularityFactor;"); + } + } + if (hasAreaLights) { + backend.append(" dSpecularLight *= litArgs_specularity;"); + if (options.useSpecular) { + backend.append(" calcLTCLightValues(litArgs_gloss, litArgs_worldNormal, dViewDirW, litArgs_specularity, litArgs_clearcoat_gloss, litArgs_clearcoat_worldNormal, litArgs_clearcoat_specularity);"); + } + } + for (let i = 0; i < options.lights.length; i++) { + const light = options.lights[i]; + const lightType = light._type; + if (options.clusteredLightingEnabled && lightType !== LIGHTTYPE_DIRECTIONAL) { + continue; + } + usesCookieNow = false; + const lightShape = hasAreaLights && light._shape ? light.shape : LIGHTSHAPE_PUNCTUAL; + const shapeString = hasAreaLights && light._shape ? this._getLightSourceShapeString(lightShape) : ""; + if (lightShape !== LIGHTSHAPE_PUNCTUAL) { + backend.append(" calc" + shapeString + "LightValues(light" + i + "_position, light" + i + "_halfWidth, light" + i + "_halfHeight);"); + } + if (lightType === LIGHTTYPE_DIRECTIONAL) { + backend.append(" dLightDirNormW = light" + i + "_direction;"); + backend.append(" dAtten = 1.0;"); + } else { + if (light._cookie) { + if (lightType === LIGHTTYPE_SPOT && !light._cookie._cubemap) { + usesCookie = true; + usesCookieNow = true; + } else if (lightType === LIGHTTYPE_OMNI && light._cookie._cubemap) { + usesCookie = true; + usesCookieNow = true; + } + } + backend.append(" getLightDirPoint(light" + i + "_position);"); + hasPointLights = true; + if (usesCookieNow) { + if (lightType === LIGHTTYPE_SPOT) { + backend.append(" dAtten3 = getCookie2D" + (light._cookieFalloff ? "" : "Clip") + (light._cookieTransform ? "Xform" : "") + "(light" + i + "_cookie, light" + i + "_shadowMatrix, light" + i + "_cookieIntensity" + (light._cookieTransform ? ", light" + i + "_cookieMatrix, light" + i + "_cookieOffset" : "") + ")." + light._cookieChannel + ";"); + } else { + backend.append(" dAtten3 = getCookieCube(light" + i + "_cookie, light" + i + "_shadowMatrix, light" + i + "_cookieIntensity)." + light._cookieChannel + ";"); + } + } + if (lightShape === LIGHTSHAPE_PUNCTUAL) { + if (light._falloffMode === LIGHTFALLOFF_LINEAR) { + backend.append(" dAtten = getFalloffLinear(light" + i + "_radius, dLightDirW);"); + usesLinearFalloff = true; + } else { + backend.append(" dAtten = getFalloffInvSquared(light" + i + "_radius, dLightDirW);"); + usesInvSquaredFalloff = true; + } + } else { + backend.append(" dAtten = getFalloffWindow(light" + i + "_radius, dLightDirW);"); + usesInvSquaredFalloff = true; + } + backend.append(" if (dAtten > 0.00001) {"); + if (lightType === LIGHTTYPE_SPOT) { + if (!(usesCookieNow && !light._cookieFalloff)) { + backend.append(" dAtten *= getSpotEffect(light" + i + "_direction, light" + i + "_innerConeAngle, light" + i + "_outerConeAngle, dLightDirNormW);"); + usesSpot = true; + } + } + } + if (lightShape !== LIGHTSHAPE_PUNCTUAL) { + if (lightType === LIGHTTYPE_DIRECTIONAL) { + backend.append(" dAttenD = getLightDiffuse(litArgs_worldNormal, dViewDirW, dLightDirW, dLightDirNormW);"); + } else { + backend.append(" dAttenD = get" + shapeString + "LightDiffuse(litArgs_worldNormal, dViewDirW, dLightDirW, dLightDirNormW) * 16.0;"); + } + } else { + backend.append(" dAtten *= getLightDiffuse(litArgs_worldNormal, dViewDirW, dLightDirW, dLightDirNormW);"); + } + if (light.castShadows && !options.noShadow) { + const pcssShadows = light._shadowType === SHADOW_PCSS; + const vsmShadows = light._shadowType === SHADOW_VSM8 || light._shadowType === SHADOW_VSM16 || light._shadowType === SHADOW_VSM32; + const pcfShadows = light._shadowType === SHADOW_PCF1 || light._shadowType === SHADOW_PCF3 || light._shadowType === SHADOW_PCF5; + let shadowReadMode = null; + let evsmExp; + switch (light._shadowType) { + case SHADOW_VSM8: + shadowReadMode = "VSM8"; + evsmExp = "0.0"; + break; + case SHADOW_VSM16: + shadowReadMode = "VSM16"; + evsmExp = "5.54"; + break; + case SHADOW_VSM32: + shadowReadMode = "VSM32"; + if (device.textureFloatHighPrecision) { + evsmExp = "15.0"; + } else { + evsmExp = "5.54"; + } + break; + case SHADOW_PCF1: + shadowReadMode = "PCF1x1"; + break; + case SHADOW_PCF5: + shadowReadMode = "PCF5x5"; + break; + case SHADOW_PCSS: + shadowReadMode = "PCSS"; + break; + case SHADOW_PCF3: + default: + shadowReadMode = "PCF3x3"; + break; + } + if (shadowReadMode !== null) { + if (light._normalOffsetBias && !light._isVsm) { + func.append("#define SHADOW_SAMPLE_NORMAL_OFFSET"); + } + if (lightType === LIGHTTYPE_DIRECTIONAL) { + func.append("#define SHADOW_SAMPLE_ORTHO"); + } + if ((pcfShadows || pcssShadows) && device.isWebGL2 || device.isWebGPU || device.extStandardDerivatives) { + func.append("#define SHADOW_SAMPLE_SOURCE_ZBUFFER"); + } + if (lightType === LIGHTTYPE_OMNI) { + func.append("#define SHADOW_SAMPLE_POINT"); + } + const coordCode = chunks.shadowSampleCoordPS; + func.append(coordCode.replace("$LIGHT", i)); + func.append("#undef SHADOW_SAMPLE_NORMAL_OFFSET"); + func.append("#undef SHADOW_SAMPLE_ORTHO"); + func.append("#undef SHADOW_SAMPLE_SOURCE_ZBUFFER"); + func.append("#undef SHADOW_SAMPLE_POINT"); + let shadowMatrix = `light${i}_shadowMatrix`; + if (lightType === LIGHTTYPE_DIRECTIONAL && light.numCascades > 1) { + backend.append(` getShadowCascadeMatrix(light${i}_shadowMatrixPalette, light${i}_shadowCascadeDistances, light${i}_shadowCascadeCount);`); + shadowMatrix = `cascadeShadowMat`; + } + backend.append(` dShadowCoord = getShadowSampleCoord${i}(${shadowMatrix}, light${i}_shadowParams, vPositionW, dLightPosW, dLightDirW, dLightDirNormW, dVertexNormalW);`); + if (lightType === LIGHTTYPE_DIRECTIONAL) { + backend.append(` fadeShadow(light${i}_shadowCascadeDistances);`); + } + var shadowCoordArgs = `SHADOWMAP_PASS(light${i}_shadowMap), dShadowCoord, light${i}_shadowParams`; + if (vsmShadows) { + shadowCoordArgs = `${shadowCoordArgs}, ${evsmExp}, dLightDirW`; + } else if (pcssShadows) { + let penumbraSizeArg = `vec2(light${i}_shadowSearchArea)`; + if (lightShape !== LIGHTSHAPE_PUNCTUAL) { + penumbraSizeArg = `vec2(length(light${i}_halfWidth), length(light${i}_halfHeight)) * light${i}_shadowSearchArea`; + } + shadowCoordArgs = `${shadowCoordArgs}, light${i}_cameraParams, ${penumbraSizeArg}, dLightDirW`; + } + if (lightType === LIGHTTYPE_OMNI) { + shadowReadMode = `Point${shadowReadMode}`; + if (!pcssShadows) { + shadowCoordArgs = `${shadowCoordArgs}, dLightDirW`; + } + } else if (lightType === LIGHTTYPE_SPOT) { + shadowReadMode = `Spot${shadowReadMode}`; + } + backend.append(` float shadow${i} = getShadow${shadowReadMode}(${shadowCoordArgs});`); + backend.append(` dAtten *= mix(1.0, shadow${i}, light${i}_shadowIntensity);`); + } + } + if (lightShape !== LIGHTSHAPE_PUNCTUAL) { + if (options.conserveEnergy && options.useSpecular) { + backend.append(" dDiffuseLight += ((dAttenD * dAtten) * light" + i + "_color" + (usesCookieNow ? " * dAtten3" : "") + ") * (1.0 - dLTCSpecFres);"); + } else { + backend.append(" dDiffuseLight += (dAttenD * dAtten) * light" + i + "_color" + (usesCookieNow ? " * dAtten3" : "") + ";"); + } + } else { + if (hasAreaLights && options.conserveEnergy && options.useSpecular) { + backend.append(" dDiffuseLight += (dAtten * light" + i + "_color" + (usesCookieNow ? " * dAtten3" : "") + ") * (1.0 - litArgs_specularity);"); + } else { + backend.append(" dDiffuseLight += dAtten * light" + i + "_color" + (usesCookieNow ? " * dAtten3" : "") + ";"); + } + } + if (options.useSpecular) { + backend.append(" dHalfDirW = normalize(-dLightDirNormW + dViewDirW);"); + } + if (light.affectSpecularity) { + if (lightShape !== LIGHTSHAPE_PUNCTUAL) { + if (options.useClearCoat) { + backend.append(` ccSpecularLight += ccLTCSpecFres * get${shapeString}LightSpecular(litArgs_clearcoat_worldNormal, dViewDirW) * dAtten * light${i}_color` + (usesCookieNow ? " * dAtten3" : "") + ";"); + } + if (options.useSpecular) { + backend.append(` dSpecularLight += dLTCSpecFres * get${shapeString}LightSpecular(litArgs_worldNormal, dViewDirW) * dAtten * light${i}_color` + (usesCookieNow ? " * dAtten3" : "") + ";"); + } + } else { + var calcFresnel = false; + if (lightType === LIGHTTYPE_DIRECTIONAL && options.fresnelModel > 0) { + calcFresnel = true; + } + if (options.useClearCoat) { + backend.append(` ccSpecularLight += getLightSpecular(dHalfDirW, ccReflDirW, litArgs_clearcoat_worldNormal, dViewDirW, dLightDirNormW, litArgs_clearcoat_gloss, dTBN) * dAtten * light${i}_color` + (usesCookieNow ? " * dAtten3" : "") + (calcFresnel ? " * getFresnelCC(dot(dViewDirW, dHalfDirW));" : ";")); + } + if (options.useSheen) { + backend.append(` sSpecularLight += getLightSpecularSheen(dHalfDirW, litArgs_worldNormal, dViewDirW, dLightDirNormW, litArgs_sheen_gloss) * dAtten * light${i}_color` + (usesCookieNow ? " * dAtten3;" : ";")); + } + if (options.useSpecular) { + backend.append(` dSpecularLight += getLightSpecular(dHalfDirW, dReflDirW, litArgs_worldNormal, dViewDirW, dLightDirNormW, litArgs_gloss, dTBN) * dAtten * light${i}_color` + (usesCookieNow ? " * dAtten3" : "") + (calcFresnel ? ` + * getFresnel( + dot(dViewDirW, dHalfDirW), + litArgs_gloss, + litArgs_specularity + #if defined(LIT_IRIDESCENCE) + , iridescenceFresnel, + litArgs_iridescence_intensity + #endif + );` : `* litArgs_specularity;`)); + } + } + } + if (lightType !== LIGHTTYPE_DIRECTIONAL) { + backend.append(" }"); + } + } + if (options.clusteredLightingEnabled && this.lighting) { + usesLinearFalloff = true; + usesInvSquaredFalloff = true; + hasPointLights = true; + backend.append(` addClusteredLights( + litArgs_worldNormal, + dViewDirW, + dReflDirW, + #if defined(LIT_CLEARCOAT) + ccReflDirW, + #endif + litArgs_gloss, + litArgs_specularity, + dVertexNormalW, + dTBN, + #if defined(LIT_IRIDESCENCE) + iridescenceFresnel, + #endif + litArgs_clearcoat_worldNormal, + litArgs_clearcoat_gloss, + litArgs_sheen_gloss, + litArgs_iridescence_intensity + );`); + } + if (hasAreaLights) { + if (options.useClearCoat) { + backend.append(" litArgs_clearcoat_specularity = 1.0;"); + } + if (options.useSpecular) { + backend.append(" litArgs_specularity = vec3(1);"); + } + } + if (options.useRefraction) { + backend.append(` addRefraction( + litArgs_worldNormal, + dViewDirW, + litArgs_thickness, + litArgs_gloss, + litArgs_specularity, + litArgs_albedo, + litArgs_transmission, + litArgs_ior, + litArgs_dispersion + #if defined(LIT_IRIDESCENCE) + , iridescenceFresnel, + litArgs_iridescence_intensity + #endif + );`); + } + } + if (options.useAo) { + if (options.occludeDirect) { + backend.append(" occludeDiffuse(litArgs_ao);"); + } + if (options.occludeSpecular === SPECOCC_AO || options.occludeSpecular === SPECOCC_GLOSSDEPENDENT) { + backend.append(" occludeSpecular(litArgs_gloss, litArgs_ao, litArgs_worldNormal, dViewDirW);"); + } + } + if (options.useSpecularityFactor) { + backend.append(" dSpecularLight *= litArgs_specularityFactor;"); + } + if (options.opacityFadesSpecular === false) { + if (options.blendType === BLEND_NORMAL || options.blendType === BLEND_PREMULTIPLIED) { + backend.append("float specLum = dot((dSpecularLight + dReflection.rgb * dReflection.a), vec3( 0.2126, 0.7152, 0.0722 ));"); + backend.append("#ifdef LIT_CLEARCOAT\n specLum += dot(ccSpecularLight * litArgs_clearcoat_specularity + ccReflection.rgb * litArgs_clearcoat_specularity, vec3( 0.2126, 0.7152, 0.0722 ));\n#endif"); + backend.append("litArgs_opacity = clamp(litArgs_opacity + gammaCorrectInput(specLum), 0.0, 1.0);"); + } + backend.append("litArgs_opacity *= material_alphaFade;"); + } + backend.append(chunks.endPS); + if (options.blendType === BLEND_NORMAL || options.blendType === BLEND_ADDITIVEALPHA || options.alphaToCoverage) { + backend.append(chunks.outputAlphaPS); + } else if (options.blendType === BLEND_PREMULTIPLIED) { + backend.append(chunks.outputAlphaPremulPS); + } else { + backend.append(chunks.outputAlphaOpaquePS); + } + if (options.useMsdf) { + backend.append(" gl_FragColor = applyMsdf(gl_FragColor);"); + } + backend.append(chunks.outputPS); + backend.append(chunks.debugOutputPS); + if (hasPointLights) { + func.prepend(chunks.lightDirPointPS); + } + if (usesLinearFalloff) { + func.prepend(chunks.falloffLinearPS); + } + if (usesInvSquaredFalloff) { + func.prepend(chunks.falloffInvSquaredPS); + } + if (usesSpot) { + func.prepend(chunks.spotPS); + } + if (usesCookie && !options.clusteredLightingEnabled) { + func.prepend(chunks.cookiePS); + } + let structCode = ""; + const backendCode = `void evaluateBackend() { +${backend.code} +}`; + func.append(backendCode); + code.append(chunks.debugProcessFrontendPS); + code.append(" evaluateBackend();"); + code.append(ShaderGenerator.end()); + const mergedCode = decl.code + func.code + code.code; + if (mergedCode.includes("dTBN")) structCode += "mat3 dTBN;\n"; + if (mergedCode.includes("dVertexNormalW")) structCode += "vec3 dVertexNormalW;\n"; + if (mergedCode.includes("dTangentW")) structCode += "vec3 dTangentW;\n"; + if (mergedCode.includes("dBinormalW")) structCode += "vec3 dBinormalW;\n"; + if (mergedCode.includes("dViewDirW")) structCode += "vec3 dViewDirW;\n"; + if (mergedCode.includes("dReflDirW")) structCode += "vec3 dReflDirW;\n"; + if (mergedCode.includes("dHalfDirW")) structCode += "vec3 dHalfDirW;\n"; + if (mergedCode.includes("ccReflDirW")) structCode += "vec3 ccReflDirW;\n"; + if (mergedCode.includes("dLightDirNormW")) structCode += "vec3 dLightDirNormW;\n"; + if (mergedCode.includes("dLightDirW")) structCode += "vec3 dLightDirW;\n"; + if (mergedCode.includes("dLightPosW")) structCode += "vec3 dLightPosW;\n"; + if (mergedCode.includes("dShadowCoord")) structCode += "vec3 dShadowCoord;\n"; + if (mergedCode.includes("dReflection")) structCode += "vec4 dReflection;\n"; + if (mergedCode.includes("dDiffuseLight")) structCode += "vec3 dDiffuseLight;\n"; + if (mergedCode.includes("dSpecularLight")) structCode += "vec3 dSpecularLight;\n"; + if (mergedCode.includes("dAtten")) structCode += "float dAtten;\n"; + if (mergedCode.includes("dAttenD")) structCode += "float dAttenD;\n"; + if (mergedCode.includes("dAtten3")) structCode += "vec3 dAtten3;\n"; + if (mergedCode.includes("dMsdf")) structCode += "vec4 dMsdf;\n"; + if (mergedCode.includes("ccFresnel")) structCode += "float ccFresnel;\n"; + if (mergedCode.includes("ccReflection")) structCode += "vec3 ccReflection;\n"; + if (mergedCode.includes("ccSpecularLight")) structCode += "vec3 ccSpecularLight;\n"; + if (mergedCode.includes("ccSpecularityNoFres")) structCode += "float ccSpecularityNoFres;\n"; + if (mergedCode.includes("sSpecularLight")) structCode += "vec3 sSpecularLight;\n"; + if (mergedCode.includes("sReflection")) structCode += "vec3 sReflection;\n"; + const result = this._fsGetBeginCode() + this.varyings + this.varyingDefines + this._fsGetBaseCode() + structCode + this.frontendDecl + mergedCode; + return result; + } + generateFragmentShader(frontendDecl, frontendCode, frontendFunc, lightingUv) { + var _this$handleCompatibi; + const options = this.options; + this.frontendDecl = frontendDecl; + this.frontendCode = frontendCode; + this.frontendFunc = frontendFunc; + this.lightingUv = lightingUv; + if (options.pass === SHADER_PICK) { + this.fshader = this._fsGetPickPassCode(); + } else if (options.pass === SHADER_DEPTH) { + this.fshader = this._fsGetDepthPassCode(); + } else if (options.pass === SHADER_PREPASS_VELOCITY) { + this.fshader = this._fsGetPrePassVelocityCode(); + } else if (this.shadowPass) { + this.fshader = this._fsGetShadowPassCode(); + } else if (options.customFragmentShader) { + this.fshader = this._fsGetBeginCode() + options.customFragmentShader; + } else { + this.fshader = this._fsGetLitPassCode(); + } + (_this$handleCompatibi = this.handleCompatibility) == null || _this$handleCompatibi.call(this); + } + getDefinition() { + const definition = ShaderUtils.createDefinition(this.device, { + name: "LitShader", + attributes: this.attributes, + vertexCode: this.vshader, + fragmentCode: this.fshader + }); + if (this.shaderPassInfo.isForward) { + definition.tag = SHADERTAG_MATERIAL; + } + return definition; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/programs/lit-options-utils.js +var LitOptionsUtils = { + generateKey(options) { + return "lit" + Object.keys(options).sort().map((key) => { + if (key === "chunks") { + return LitOptionsUtils.generateChunksKey(options); + } else if (key === "lights") { + return LitOptionsUtils.generateLightsKey(options); + } + return key + options[key]; + }).join("\n"); + }, + generateLightsKey(options) { + return "lights:" + options.lights.map((light) => { + return !options.clusteredLightingEnabled || light._type === LIGHTTYPE_DIRECTIONAL ? `${light.key},` : ""; + }).join(""); + }, + generateChunksKey(options) { + var _options$chunks; + return "chunks:\n" + Object.keys((_options$chunks = options.chunks) != null ? _options$chunks : {}).sort().map((key) => key + options.chunks[key]).join(""); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/lighting/world-clusters.js +var tempVec32 = new Vec3(); +var tempMin3 = new Vec3(); +var tempMax3 = new Vec3(); +var tempBox = new BoundingBox(); +var epsilon2 = 1e-6; +var ClusterLight = class { + constructor() { + this.light = null; + this.min = new Vec3(); + this.max = new Vec3(); + } +}; +var WorldClusters = class { + constructor(device) { + this.clusterTexture = void 0; + this.device = device; + this.name = "Untitled"; + this.reportCount = 0; + this.boundsMin = new Vec3(); + this.boundsMax = new Vec3(); + this.boundsDelta = new Vec3(); + this._cells = new Vec3(1, 1, 1); + this._cellsLimit = new Vec3(); + this.cells = this._cells; + this.maxCellLightCount = 4; + this._maxAttenuation = 0; + this._maxColorValue = 0; + this._usedLights = []; + this._usedLights.push(new ClusterLight()); + this.lightsBuffer = new LightsBuffer(device); + this.registerUniforms(device); + } + set maxCellLightCount(count) { + if (count !== this._maxCellLightCount) { + this._maxCellLightCount = count; + this._cellsDirty = true; + } + } + get maxCellLightCount() { + return this._maxCellLightCount; + } + set cells(value) { + tempVec32.copy(value).floor(); + if (!this._cells.equals(tempVec32)) { + this._cells.copy(tempVec32); + this._cellsLimit.copy(tempVec32).sub(Vec3.ONE); + this._cellsDirty = true; + } + } + get cells() { + return this._cells; + } + destroy() { + this.lightsBuffer.destroy(); + this.releaseClusterTexture(); + } + releaseClusterTexture() { + if (this.clusterTexture) { + this.clusterTexture.destroy(); + this.clusterTexture = null; + } + } + registerUniforms(device) { + this._clusterSkipId = device.scope.resolve("clusterSkip"); + this._clusterMaxCellsId = device.scope.resolve("clusterMaxCells"); + this._clusterWorldTextureId = device.scope.resolve("clusterWorldTexture"); + this._clusterTextureSizeId = device.scope.resolve("clusterTextureSize"); + this._clusterTextureSizeData = new Float32Array(3); + this._clusterBoundsMinId = device.scope.resolve("clusterBoundsMin"); + this._clusterBoundsMinData = new Float32Array(3); + this._clusterBoundsDeltaId = device.scope.resolve("clusterBoundsDelta"); + this._clusterBoundsDeltaData = new Float32Array(3); + this._clusterCellsCountByBoundsSizeId = device.scope.resolve("clusterCellsCountByBoundsSize"); + this._clusterCellsCountByBoundsSizeData = new Float32Array(3); + this._clusterCellsDotId = device.scope.resolve("clusterCellsDot"); + this._clusterCellsDotData = new Float32Array(3); + this._clusterCellsMaxId = device.scope.resolve("clusterCellsMax"); + this._clusterCellsMaxData = new Float32Array(3); + this._clusterCompressionLimit0Id = device.scope.resolve("clusterCompressionLimit0"); + this._clusterCompressionLimit0Data = new Float32Array(2); + } + updateParams(lightingParams) { + if (lightingParams) { + this.cells = lightingParams.cells; + this.maxCellLightCount = lightingParams.maxLightsPerCell; + this.lightsBuffer.cookiesEnabled = lightingParams.cookiesEnabled; + this.lightsBuffer.shadowsEnabled = lightingParams.shadowsEnabled; + this.lightsBuffer.areaLightsEnabled = lightingParams.areaLightsEnabled; + } + } + updateCells() { + if (this._cellsDirty) { + this._cellsDirty = false; + const cx = this._cells.x; + const cy = this._cells.y; + const cz = this._cells.z; + const numCells = cx * cy * cz; + const totalPixels = this.maxCellLightCount * numCells; + let width = Math.ceil(Math.sqrt(totalPixels)); + width = math.roundUp(width, this.maxCellLightCount); + const height = Math.ceil(totalPixels / width); + this._clusterCellsMaxData[0] = cx; + this._clusterCellsMaxData[1] = cy; + this._clusterCellsMaxData[2] = cz; + this._clusterCellsDotData[0] = this.maxCellLightCount; + this._clusterCellsDotData[1] = cx * cz * this.maxCellLightCount; + this._clusterCellsDotData[2] = cx * this.maxCellLightCount; + this.clusters = new Uint8ClampedArray(totalPixels); + this.counts = new Int32Array(numCells); + this._clusterTextureSizeData[0] = width; + this._clusterTextureSizeData[1] = 1 / width; + this._clusterTextureSizeData[2] = 1 / height; + this.releaseClusterTexture(); + this.clusterTexture = this.lightsBuffer.createTexture(this.device, width, height, PIXELFORMAT_L8, "ClusterTexture"); + } + } + uploadTextures() { + this.clusterTexture.lock().set(this.clusters); + this.clusterTexture.unlock(); + this.lightsBuffer.uploadTextures(); + } + updateUniforms() { + this._clusterSkipId.setValue(this._usedLights.length > 1 ? 0 : 1); + this.lightsBuffer.updateUniforms(); + this._clusterWorldTextureId.setValue(this.clusterTexture); + this._clusterMaxCellsId.setValue(this.maxCellLightCount); + const boundsDelta = this.boundsDelta; + this._clusterCellsCountByBoundsSizeData[0] = this._cells.x / boundsDelta.x; + this._clusterCellsCountByBoundsSizeData[1] = this._cells.y / boundsDelta.y; + this._clusterCellsCountByBoundsSizeData[2] = this._cells.z / boundsDelta.z; + this._clusterCellsCountByBoundsSizeId.setValue(this._clusterCellsCountByBoundsSizeData); + this._clusterBoundsMinData[0] = this.boundsMin.x; + this._clusterBoundsMinData[1] = this.boundsMin.y; + this._clusterBoundsMinData[2] = this.boundsMin.z; + this._clusterBoundsDeltaData[0] = boundsDelta.x; + this._clusterBoundsDeltaData[1] = boundsDelta.y; + this._clusterBoundsDeltaData[2] = boundsDelta.z; + this._clusterCompressionLimit0Data[0] = this._maxAttenuation; + this._clusterCompressionLimit0Data[1] = this._maxColorValue; + this._clusterTextureSizeId.setValue(this._clusterTextureSizeData); + this._clusterBoundsMinId.setValue(this._clusterBoundsMinData); + this._clusterBoundsDeltaId.setValue(this._clusterBoundsDeltaData); + this._clusterCellsDotId.setValue(this._clusterCellsDotData); + this._clusterCellsMaxId.setValue(this._clusterCellsMaxData); + this._clusterCompressionLimit0Id.setValue(this._clusterCompressionLimit0Data); + } + evalLightCellMinMax(clusteredLight, min, max) { + min.copy(clusteredLight.min); + min.sub(this.boundsMin); + min.div(this.boundsDelta); + min.mul2(min, this.cells); + min.floor(); + max.copy(clusteredLight.max); + max.sub(this.boundsMin); + max.div(this.boundsDelta); + max.mul2(max, this.cells); + max.ceil(); + min.max(Vec3.ZERO); + max.min(this._cellsLimit); + } + collectLights(lights2) { + const maxLights = this.lightsBuffer.maxLights; + const usedLights = this._usedLights; + let lightIndex = 1; + lights2.forEach((light) => { + const runtimeLight = !!(light.mask & (MASK_AFFECT_DYNAMIC | MASK_AFFECT_LIGHTMAPPED)); + const zeroAngleSpotlight = light.type === LIGHTTYPE_SPOT && light._outerConeAngle === 0; + if (light.enabled && light.type !== LIGHTTYPE_DIRECTIONAL && light.visibleThisFrame && light.intensity > 0 && runtimeLight && !zeroAngleSpotlight) { + if (lightIndex < maxLights) { + let clusteredLight; + if (lightIndex < usedLights.length) { + clusteredLight = usedLights[lightIndex]; + } else { + clusteredLight = new ClusterLight(); + usedLights.push(clusteredLight); + } + clusteredLight.light = light; + light.getBoundingBox(tempBox); + clusteredLight.min.copy(tempBox.getMin()); + clusteredLight.max.copy(tempBox.getMax()); + lightIndex++; + } + } + }); + usedLights.length = lightIndex; + } + evaluateBounds() { + const usedLights = this._usedLights; + const min = this.boundsMin; + const max = this.boundsMax; + if (usedLights.length > 1) { + min.copy(usedLights[1].min); + max.copy(usedLights[1].max); + for (let i = 2; i < usedLights.length; i++) { + min.min(usedLights[i].min); + max.max(usedLights[i].max); + } + } else { + min.set(0, 0, 0); + max.set(1, 1, 1); + } + this.boundsDelta.sub2(max, min); + this.lightsBuffer.setBounds(min, this.boundsDelta); + } + evaluateCompressionLimits(gammaCorrection) { + let maxAttenuation = 0; + let maxColorValue = 0; + const usedLights = this._usedLights; + for (let i = 1; i < usedLights.length; i++) { + const light = usedLights[i].light; + maxAttenuation = Math.max(light.attenuationEnd, maxAttenuation); + const color = gammaCorrection ? light._linearFinalColor : light._finalColor; + maxColorValue = Math.max(color[0], maxColorValue); + maxColorValue = Math.max(color[1], maxColorValue); + maxColorValue = Math.max(color[2], maxColorValue); + } + this._maxAttenuation = maxAttenuation + epsilon2; + this._maxColorValue = maxColorValue + epsilon2; + this.lightsBuffer.setCompressionRanges(this._maxAttenuation, this._maxColorValue); + } + updateClusters(gammaCorrection) { + this.counts.fill(0); + this.clusters.fill(0); + const divX = this._cells.x; + const divZ = this._cells.z; + const counts = this.counts; + const limit = this._maxCellLightCount; + const clusters = this.clusters; + const pixelsPerCellCount = this.maxCellLightCount; + const usedLights = this._usedLights; + for (let i = 1; i < usedLights.length; i++) { + const clusteredLight = usedLights[i]; + const light = clusteredLight.light; + this.lightsBuffer.addLightData(light, i, gammaCorrection); + this.evalLightCellMinMax(clusteredLight, tempMin3, tempMax3); + const xStart = tempMin3.x; + const xEnd = tempMax3.x; + const yStart = tempMin3.y; + const yEnd = tempMax3.y; + const zStart = tempMin3.z; + const zEnd = tempMax3.z; + for (let x2 = xStart; x2 <= xEnd; x2++) { + for (let z2 = zStart; z2 <= zEnd; z2++) { + for (let y2 = yStart; y2 <= yEnd; y2++) { + const clusterIndex = x2 + divX * (z2 + y2 * divZ); + const count = counts[clusterIndex]; + if (count < limit) { + clusters[pixelsPerCellCount * clusterIndex + count] = i; + counts[clusterIndex] = count + 1; + } + } + } + } + } + } + update(lights2, gammaCorrection, lightingParams) { + this.updateParams(lightingParams); + this.updateCells(); + this.collectLights(lights2); + this.evaluateBounds(); + this.evaluateCompressionLimits(gammaCorrection); + this.updateClusters(gammaCorrection); + this.uploadTextures(); + } + activate() { + this.updateUniforms(); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/renderer/shadow-map.js +var ShadowMap = class _ShadowMap { + constructor(texture, targets) { + this.texture = texture; + this.cached = false; + this.renderTargets = targets; + } + destroy() { + if (this.texture) { + this.texture.destroy(); + this.texture = null; + } + const targets = this.renderTargets; + for (let i = 0; i < targets.length; i++) { + targets[i].destroy(); + } + this.renderTargets.length = 0; + } + static getShadowFormat(device, shadowType) { + if (shadowType === SHADOW_VSM32) { + return PIXELFORMAT_RGBA32F; + } else if (shadowType === SHADOW_VSM16) { + return PIXELFORMAT_RGBA16F; + } else if (shadowType === SHADOW_PCF5) { + return PIXELFORMAT_DEPTH; + } else if ((shadowType === SHADOW_PCF1 || shadowType === SHADOW_PCF3) && device.supportsDepthShadow) { + return PIXELFORMAT_DEPTH; + } else if (shadowType === SHADOW_PCSS && !device.isWebGL1) { + return PIXELFORMAT_R32F; + } + return PIXELFORMAT_RGBA8; + } + static getShadowFiltering(device, shadowType) { + if ((shadowType === SHADOW_PCF1 || shadowType === SHADOW_PCF3 || shadowType === SHADOW_PCSS) && !device.supportsDepthShadow) { + return FILTER_NEAREST; + } else if (shadowType === SHADOW_VSM32) { + return device.extTextureFloatLinear ? FILTER_LINEAR : FILTER_NEAREST; + } else if (shadowType === SHADOW_VSM16) { + return device.extTextureHalfFloatLinear ? FILTER_LINEAR : FILTER_NEAREST; + } + return FILTER_LINEAR; + } + static create(device, light) { + let shadowMap = null; + if (light._type === LIGHTTYPE_OMNI) { + shadowMap = this.createCubemap(device, light._shadowResolution, light._shadowType); + } else { + shadowMap = this.create2dMap(device, light._shadowResolution, light._shadowType); + } + return shadowMap; + } + static createAtlas(device, resolution, shadowType) { + const shadowMap = this.create2dMap(device, resolution, shadowType); + const targets = shadowMap.renderTargets; + const rt = targets[0]; + for (let i = 0; i < 5; i++) { + targets.push(rt); + } + return shadowMap; + } + static create2dMap(device, size, shadowType) { + const format = this.getShadowFormat(device, shadowType); + const filter = this.getShadowFiltering(device, shadowType); + const texture = new Texture(device, { + format, + width: size, + height: size, + mipmaps: false, + minFilter: filter, + magFilter: filter, + addressU: ADDRESS_CLAMP_TO_EDGE, + addressV: ADDRESS_CLAMP_TO_EDGE, + name: "ShadowMap2D" + }); + let target2 = null; + if (shadowType === SHADOW_PCF5 || (shadowType === SHADOW_PCF1 || shadowType === SHADOW_PCF3) && device.supportsDepthShadow) { + texture.compareOnRead = true; + texture.compareFunc = FUNC_LESS; + target2 = new RenderTarget({ + depthBuffer: texture + }); + } else { + target2 = new RenderTarget({ + colorBuffer: texture, + depth: true + }); + } + if (device.isWebGPU) { + target2.flipY = true; + } + return new _ShadowMap(texture, [target2]); + } + static createCubemap(device, size, shadowType) { + const format = shadowType === SHADOW_PCSS && !device.isWebGL1 ? PIXELFORMAT_R32F : PIXELFORMAT_RGBA8; + const cubemap = new Texture(device, { + format, + width: size, + height: size, + cubemap: true, + mipmaps: false, + minFilter: FILTER_NEAREST, + magFilter: FILTER_NEAREST, + addressU: ADDRESS_CLAMP_TO_EDGE, + addressV: ADDRESS_CLAMP_TO_EDGE, + name: "ShadowMapCube" + }); + const targets = []; + for (let i = 0; i < 6; i++) { + const target2 = new RenderTarget({ + colorBuffer: cubemap, + face: i, + depth: true + }); + targets.push(target2); + } + return new _ShadowMap(cubemap, targets); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/lighting/light-texture-atlas.js +var _tempArray = []; +var _tempArray2 = []; +var _viewport = new Vec4(); +var _scissor = new Vec4(); +var Slot = class { + constructor(rect) { + this.size = Math.floor(rect.w * 1024); + this.used = false; + this.lightId = -1; + this.rect = rect; + } +}; +var LightTextureAtlas = class { + constructor(device) { + this.device = device; + this.version = 1; + this.shadowAtlasResolution = 2048; + this.shadowAtlas = null; + this.shadowEdgePixels = 3; + this.cookieAtlasResolution = 4; + this.cookieAtlas = new Texture(this.device, { + name: "CookieAtlas", + width: this.cookieAtlasResolution, + height: this.cookieAtlasResolution, + format: PIXELFORMAT_RGBA8, + cubemap: false, + mipmaps: false, + minFilter: FILTER_NEAREST, + magFilter: FILTER_NEAREST, + addressU: ADDRESS_CLAMP_TO_EDGE, + addressV: ADDRESS_CLAMP_TO_EDGE + }); + this.cookieRenderTarget = new RenderTarget({ + colorBuffer: this.cookieAtlas, + depth: false, + flipY: true + }); + this.slots = []; + this.atlasSplit = []; + this.cubeSlotsOffsets = [new Vec2(0, 0), new Vec2(0, 1), new Vec2(1, 0), new Vec2(1, 1), new Vec2(2, 0), new Vec2(2, 1)]; + this.scissorVec = new Vec4(); + this.allocateShadowAtlas(1); + this.allocateCookieAtlas(1); + this.allocateUniforms(); + } + destroy() { + this.destroyShadowAtlas(); + this.destroyCookieAtlas(); + } + destroyShadowAtlas() { + var _this$shadowAtlas; + (_this$shadowAtlas = this.shadowAtlas) == null || _this$shadowAtlas.destroy(); + this.shadowAtlas = null; + } + destroyCookieAtlas() { + var _this$cookieAtlas, _this$cookieRenderTar; + (_this$cookieAtlas = this.cookieAtlas) == null || _this$cookieAtlas.destroy(); + this.cookieAtlas = null; + (_this$cookieRenderTar = this.cookieRenderTarget) == null || _this$cookieRenderTar.destroy(); + this.cookieRenderTarget = null; + } + allocateShadowAtlas(resolution) { + if (!this.shadowAtlas || this.shadowAtlas.texture.width !== resolution) { + this.version++; + this.destroyShadowAtlas(); + this.shadowAtlas = ShadowMap.createAtlas(this.device, resolution, SHADOW_PCF3); + this.shadowAtlas.cached = true; + const scissorOffset = 4 / this.shadowAtlasResolution; + this.scissorVec.set(scissorOffset, scissorOffset, -2 * scissorOffset, -2 * scissorOffset); + } + } + allocateCookieAtlas(resolution) { + if (this.cookieAtlas.width !== resolution) { + this.cookieRenderTarget.resize(resolution, resolution); + this.version++; + } + } + allocateUniforms() { + this._shadowAtlasTextureId = this.device.scope.resolve("shadowAtlasTexture"); + this._shadowAtlasParamsId = this.device.scope.resolve("shadowAtlasParams"); + this._shadowAtlasParams = new Float32Array(2); + this._cookieAtlasTextureId = this.device.scope.resolve("cookieAtlasTexture"); + } + updateUniforms() { + const isShadowFilterPcf = true; + const rt = this.shadowAtlas.renderTargets[0]; + const isDepthShadow = !this.device.isWebGL1 && isShadowFilterPcf; + const shadowBuffer = isDepthShadow ? rt.depthBuffer : rt.colorBuffer; + this._shadowAtlasTextureId.setValue(shadowBuffer); + this._shadowAtlasParams[0] = this.shadowAtlasResolution; + this._shadowAtlasParams[1] = this.shadowEdgePixels; + this._shadowAtlasParamsId.setValue(this._shadowAtlasParams); + this._cookieAtlasTextureId.setValue(this.cookieAtlas); + } + subdivide(numLights, lightingParams) { + let atlasSplit = lightingParams.atlasSplit; + if (!atlasSplit) { + const gridSize = Math.ceil(Math.sqrt(numLights)); + atlasSplit = _tempArray2; + atlasSplit[0] = gridSize; + atlasSplit.length = 1; + } + const arraysEqual2 = (a, b) => a.length === b.length && a.every((v, i) => v === b[i]); + if (!arraysEqual2(atlasSplit, this.atlasSplit)) { + this.version++; + this.slots.length = 0; + this.atlasSplit.length = 0; + this.atlasSplit.push(...atlasSplit); + const splitCount = this.atlasSplit[0]; + if (splitCount > 1) { + const invSize = 1 / splitCount; + for (let i = 0; i < splitCount; i++) { + for (let j = 0; j < splitCount; j++) { + const rect = new Vec4(i * invSize, j * invSize, invSize, invSize); + const nextLevelSplit = this.atlasSplit[1 + i * splitCount + j]; + if (nextLevelSplit > 1) { + for (let x2 = 0; x2 < nextLevelSplit; x2++) { + for (let y2 = 0; y2 < nextLevelSplit; y2++) { + const invSizeNext = invSize / nextLevelSplit; + const rectNext = new Vec4(rect.x + x2 * invSizeNext, rect.y + y2 * invSizeNext, invSizeNext, invSizeNext); + this.slots.push(new Slot(rectNext)); + } + } + } else { + this.slots.push(new Slot(rect)); + } + } + } + } else { + this.slots.push(new Slot(new Vec4(0, 0, 1, 1))); + } + this.slots.sort((a, b) => { + return b.size - a.size; + }); + } + } + collectLights(localLights, lightingParams) { + const cookiesEnabled = lightingParams.cookiesEnabled; + const shadowsEnabled = lightingParams.shadowsEnabled; + let needsShadowAtlas = false; + let needsCookieAtlas = false; + const lights2 = _tempArray; + lights2.length = 0; + const processLights = (list) => { + for (let i = 0; i < list.length; i++) { + const light = list[i]; + if (light.visibleThisFrame) { + const lightShadow = shadowsEnabled && light.castShadows; + const lightCookie = cookiesEnabled && !!light.cookie; + needsShadowAtlas || (needsShadowAtlas = lightShadow); + needsCookieAtlas || (needsCookieAtlas = lightCookie); + if (lightShadow || lightCookie) { + lights2.push(light); + } + } + } + }; + if (cookiesEnabled || shadowsEnabled) { + processLights(localLights); + } + lights2.sort((a, b) => { + return b.maxScreenSize - a.maxScreenSize; + }); + if (needsShadowAtlas) { + this.allocateShadowAtlas(this.shadowAtlasResolution); + } + if (needsCookieAtlas) { + this.allocateCookieAtlas(this.cookieAtlasResolution); + } + if (needsShadowAtlas || needsCookieAtlas) { + this.subdivide(lights2.length, lightingParams); + } + return lights2; + } + setupSlot(light, rect) { + light.atlasViewport.copy(rect); + const faceCount = light.numShadowFaces; + for (let face = 0; face < faceCount; face++) { + if (light.castShadows || light._cookie) { + _viewport.copy(rect); + _scissor.copy(rect); + if (light._type === LIGHTTYPE_SPOT) { + _viewport.add(this.scissorVec); + } + if (light._type === LIGHTTYPE_OMNI) { + const smallSize = _viewport.z / 3; + const offset = this.cubeSlotsOffsets[face]; + _viewport.x += smallSize * offset.x; + _viewport.y += smallSize * offset.y; + _viewport.z = smallSize; + _viewport.w = smallSize; + _scissor.copy(_viewport); + } + if (light.castShadows) { + const lightRenderData = light.getRenderData(null, face); + lightRenderData.shadowViewport.copy(_viewport); + lightRenderData.shadowScissor.copy(_scissor); + } + } + } + } + assignSlot(light, slotIndex, slotReassigned) { + light.atlasViewportAllocated = true; + const slot = this.slots[slotIndex]; + slot.lightId = light.id; + slot.used = true; + if (slotReassigned) { + light.atlasSlotUpdated = true; + light.atlasVersion = this.version; + light.atlasSlotIndex = slotIndex; + } + } + update(localLights, lightingParams) { + this.shadowAtlasResolution = lightingParams.shadowAtlasResolution; + this.cookieAtlasResolution = lightingParams.cookieAtlasResolution; + const lights2 = this.collectLights(localLights, lightingParams); + if (lights2.length > 0) { + const slots = this.slots; + for (let i = 0; i < slots.length; i++) { + slots[i].used = false; + } + const assignCount = Math.min(lights2.length, slots.length); + for (let i = 0; i < assignCount; i++) { + const light = lights2[i]; + if (light.castShadows) light._shadowMap = this.shadowAtlas; + const previousSlot = slots[light.atlasSlotIndex]; + if (light.atlasVersion === this.version && light.id === (previousSlot == null ? void 0 : previousSlot.lightId)) { + const _previousSlot = slots[light.atlasSlotIndex]; + if (_previousSlot.size === slots[i].size && !_previousSlot.used) { + this.assignSlot(light, light.atlasSlotIndex, false); + } + } + } + let usedCount = 0; + for (let i = 0; i < assignCount; i++) { + while (usedCount < slots.length && slots[usedCount].used) usedCount++; + const light = lights2[i]; + if (!light.atlasViewportAllocated) { + this.assignSlot(light, usedCount, true); + } + const slot = slots[light.atlasSlotIndex]; + this.setupSlot(light, slot.rect); + } + } + this.updateUniforms(); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/graphics/light-cube.js +var lightCubeDir = [new Vec3(-1, 0, 0), new Vec3(1, 0, 0), new Vec3(0, -1, 0), new Vec3(0, 1, 0), new Vec3(0, 0, -1), new Vec3(0, 0, 1)]; +var LightCube = class { + constructor() { + this.colors = new Float32Array(6 * 3); + } + update(ambientLight, lights2) { + const colors = this.colors; + const { + r, + g, + b + } = ambientLight; + for (let j = 0; j < 6; j++) { + colors[j * 3] = r; + colors[j * 3 + 1] = g; + colors[j * 3 + 2] = b; + } + for (let j = 0; j < lights2.length; j++) { + const light = lights2[j]; + if (light._type === LIGHTTYPE_DIRECTIONAL) { + for (let c2 = 0; c2 < 6; c2++) { + const weight = Math.max(lightCubeDir[c2].dot(light._direction), 0) * light._intensity; + const lightColor = light._color; + colors[c2 * 3] += lightColor.r * weight; + colors[c2 * 3 + 1] += lightColor.g * weight; + colors[c2 * 3 + 2] += lightColor.b * weight; + } + } + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/renderer/shadow-map-cache.js +var ShadowMapCache = class { + constructor() { + this.cache = /* @__PURE__ */ new Map(); + } + destroy() { + this.clear(); + this.cache = null; + } + clear() { + this.cache.forEach((shadowMaps) => { + shadowMaps.forEach((shadowMap) => { + shadowMap.destroy(); + }); + }); + this.cache.clear(); + } + getKey(light) { + const isCubeMap = light._type === LIGHTTYPE_OMNI; + const shadowType = light._shadowType; + const resolution = light._shadowResolution; + return `${isCubeMap}-${shadowType}-${resolution}`; + } + get(device, light) { + const key = this.getKey(light); + const shadowMaps = this.cache.get(key); + if (shadowMaps && shadowMaps.length) { + return shadowMaps.pop(); + } + const shadowMap = ShadowMap.create(device, light); + shadowMap.cached = true; + return shadowMap; + } + add(light, shadowMap) { + const key = this.getKey(light); + const shadowMaps = this.cache.get(key); + if (shadowMaps) { + shadowMaps.push(shadowMap); + } else { + this.cache.set(key, [shadowMap]); + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/renderer/render-pass-shadow-local-non-clustered.js +var RenderPassShadowLocalNonClustered = class extends RenderPass { + constructor(device, shadowRenderer, light, face, applyVsm) { + super(device); + this.requiresCubemaps = false; + this.shadowRenderer = shadowRenderer; + this.light = light; + this.face = face; + this.applyVsm = applyVsm; + this.shadowCamera = shadowRenderer.prepareFace(light, null, face); + shadowRenderer.setupRenderPass(this, this.shadowCamera, true); + } + execute() { + this.shadowRenderer.renderFace(this.light, null, this.face, false); + } + after() { + if (this.applyVsm) { + this.shadowRenderer.renderVsm(this.light, this.shadowCamera); + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/renderer/shadow-renderer-local.js +var ShadowRendererLocal = class { + constructor(renderer, shadowRenderer) { + this.shadowLights = []; + this.renderer = void 0; + this.shadowRenderer = void 0; + this.device = void 0; + this.renderer = renderer; + this.shadowRenderer = shadowRenderer; + this.device = renderer.device; + } + cull(light, comp, casters = null) { + const isClustered = this.renderer.scene.clusteredLightingEnabled; + light.visibleThisFrame = true; + if (!isClustered) { + if (!light._shadowMap) { + light._shadowMap = ShadowMap.create(this.device, light); + } + } + const type2 = light._type; + const faceCount = type2 === LIGHTTYPE_SPOT ? 1 : 6; + for (let face = 0; face < faceCount; face++) { + const lightRenderData = light.getRenderData(null, face); + const shadowCam = lightRenderData.shadowCamera; + shadowCam.nearClip = light.attenuationEnd / 1e3; + shadowCam.farClip = light.attenuationEnd; + lightRenderData.depthRangeCompensation = shadowCam.farClip - shadowCam.nearClip; + const shadowCamNode = shadowCam._node; + const lightNode = light._node; + shadowCamNode.setPosition(lightNode.getPosition()); + if (type2 === LIGHTTYPE_SPOT) { + shadowCam.fov = light._outerConeAngle * 2; + shadowCamNode.setRotation(lightNode.getRotation()); + shadowCamNode.rotateLocal(-90, 0, 0); + } else if (type2 === LIGHTTYPE_OMNI) { + if (isClustered) { + const tileSize = this.shadowRenderer.lightTextureAtlas.shadowAtlasResolution * light.atlasViewport.z / 3; + const texelSize = 2 / tileSize; + const filterSize = texelSize * this.shadowRenderer.lightTextureAtlas.shadowEdgePixels; + shadowCam.fov = Math.atan(1 + filterSize) * math.RAD_TO_DEG * 2; + } else { + shadowCam.fov = 90; + } + } + this.renderer.updateCameraFrustum(shadowCam); + this.shadowRenderer.cullShadowCasters(comp, light, lightRenderData.visibleCasters, shadowCam, casters); + } + } + prepareLights(shadowLights, lights2) { + let shadowCamera; + for (let i = 0; i < lights2.length; i++) { + const light = lights2[i]; + if (this.shadowRenderer.needsShadowRendering(light) && light.atlasViewportAllocated) { + shadowLights.push(light); + for (let face = 0; face < light.numShadowFaces; face++) { + shadowCamera = this.shadowRenderer.prepareFace(light, null, face); + } + } + } + return shadowCamera; + } + buildNonClusteredRenderPasses(frameGraph, localLights) { + for (let i = 0; i < localLights.length; i++) { + const light = localLights[i]; + if (this.shadowRenderer.needsShadowRendering(light)) { + const applyVsm = light._type === LIGHTTYPE_SPOT; + const faceCount = light.numShadowFaces; + for (let face = 0; face < faceCount; face++) { + const renderPass = new RenderPassShadowLocalNonClustered(this.device, this.shadowRenderer, light, face, applyVsm); + frameGraph.addRenderPass(renderPass); + } + } + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/renderer/render-pass-shadow-directional.js +var RenderPassShadowDirectional = class extends RenderPass { + constructor(device, shadowRenderer, light, camera, allCascadesRendering) { + super(device); + this.shadowRenderer = shadowRenderer; + this.light = light; + this.camera = camera; + this.allCascadesRendering = allCascadesRendering; + } + execute() { + const { + light, + camera, + shadowRenderer, + allCascadesRendering + } = this; + const faceCount = light.numShadowFaces; + const shadowUpdateOverrides = light.shadowUpdateOverrides; + for (let face = 0; face < faceCount; face++) { + if ((shadowUpdateOverrides == null ? void 0 : shadowUpdateOverrides[face]) !== SHADOWUPDATE_NONE) { + shadowRenderer.renderFace(light, camera, face, !allCascadesRendering); + } + if ((shadowUpdateOverrides == null ? void 0 : shadowUpdateOverrides[face]) === SHADOWUPDATE_THISFRAME) { + shadowUpdateOverrides[face] = SHADOWUPDATE_NONE; + } + } + } + after() { + this.shadowRenderer.renderVsm(this.light, this.camera); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/renderer/shadow-renderer-directional.js +var visibleSceneAabb = new BoundingBox(); +var center = new Vec3(); +var shadowCamView = new Mat4(); +var aabbPoints = [new Vec3(), new Vec3(), new Vec3(), new Vec3(), new Vec3(), new Vec3(), new Vec3(), new Vec3()]; +var _depthRange = { + min: 0, + max: 0 +}; +function getDepthRange(cameraViewMatrix, aabbMin, aabbMax) { + aabbPoints[0].x = aabbPoints[1].x = aabbPoints[2].x = aabbPoints[3].x = aabbMin.x; + aabbPoints[1].y = aabbPoints[3].y = aabbPoints[7].y = aabbPoints[5].y = aabbMin.y; + aabbPoints[2].z = aabbPoints[3].z = aabbPoints[6].z = aabbPoints[7].z = aabbMin.z; + aabbPoints[4].x = aabbPoints[5].x = aabbPoints[6].x = aabbPoints[7].x = aabbMax.x; + aabbPoints[0].y = aabbPoints[2].y = aabbPoints[4].y = aabbPoints[6].y = aabbMax.y; + aabbPoints[0].z = aabbPoints[1].z = aabbPoints[4].z = aabbPoints[5].z = aabbMax.z; + let minz = 9999999999; + let maxz = -9999999999; + for (let i = 0; i < 8; ++i) { + cameraViewMatrix.transformPoint(aabbPoints[i], aabbPoints[i]); + const z2 = aabbPoints[i].z; + if (z2 < minz) minz = z2; + if (z2 > maxz) maxz = z2; + } + _depthRange.min = minz; + _depthRange.max = maxz; + return _depthRange; +} +var ShadowRendererDirectional = class { + constructor(renderer, shadowRenderer) { + this.renderer = void 0; + this.shadowRenderer = void 0; + this.device = void 0; + this.renderer = renderer; + this.shadowRenderer = shadowRenderer; + this.device = renderer.device; + } + cull(light, comp, camera, casters = null) { + light.visibleThisFrame = true; + if (!light._shadowMap) { + light._shadowMap = ShadowMap.create(this.device, light); + } + const nearDist = camera._nearClip; + this.generateSplitDistances(light, nearDist, Math.min(camera._farClip, light.shadowDistance)); + const shadowUpdateOverrides = light.shadowUpdateOverrides; + for (let cascade = 0; cascade < light.numCascades; cascade++) { + if ((shadowUpdateOverrides == null ? void 0 : shadowUpdateOverrides[cascade]) === SHADOWUPDATE_NONE) { + break; + } + const lightRenderData = light.getRenderData(camera, cascade); + const shadowCam = lightRenderData.shadowCamera; + shadowCam.renderTarget = light._shadowMap.renderTargets[0]; + lightRenderData.shadowViewport.copy(light.cascades[cascade]); + lightRenderData.shadowScissor.copy(light.cascades[cascade]); + const shadowCamNode = shadowCam._node; + const lightNode = light._node; + shadowCamNode.setPosition(lightNode.getPosition()); + shadowCamNode.setRotation(lightNode.getRotation()); + shadowCamNode.rotateLocal(-90, 0, 0); + const frustumNearDist = cascade === 0 ? nearDist : light._shadowCascadeDistances[cascade - 1]; + const frustumFarDist = light._shadowCascadeDistances[cascade]; + const frustumPoints = camera.getFrustumCorners(frustumNearDist, frustumFarDist); + center.set(0, 0, 0); + const cameraWorldMat = camera.node.getWorldTransform(); + for (let i = 0; i < 8; i++) { + cameraWorldMat.transformPoint(frustumPoints[i], frustumPoints[i]); + center.add(frustumPoints[i]); + } + center.mulScalar(1 / 8); + let radius = 0; + for (let i = 0; i < 8; i++) { + const dist = frustumPoints[i].sub(center).length(); + if (dist > radius) radius = dist; + } + const right2 = shadowCamNode.right; + const up3 = shadowCamNode.up; + const lightDir = shadowCamNode.forward; + const sizeRatio = 0.25 * light._shadowResolution / radius; + const x2 = Math.ceil(center.dot(up3) * sizeRatio) / sizeRatio; + const y2 = Math.ceil(center.dot(right2) * sizeRatio) / sizeRatio; + const scaledUp = up3.mulScalar(x2); + const scaledRight = right2.mulScalar(y2); + const dot = center.dot(lightDir); + const scaledDir = lightDir.mulScalar(dot); + center.add2(scaledUp, scaledRight).add(scaledDir); + shadowCamNode.setPosition(center); + shadowCamNode.translateLocal(0, 0, 1e6); + shadowCam.nearClip = 0.01; + shadowCam.farClip = 2e6; + shadowCam.orthoHeight = radius; + this.renderer.updateCameraFrustum(shadowCam); + this.shadowRenderer.cullShadowCasters(comp, light, lightRenderData.visibleCasters, shadowCam, casters); + let emptyAabb = true; + const visibleCasters = lightRenderData.visibleCasters; + for (let i = 0; i < visibleCasters.length; i++) { + const meshInstance = visibleCasters[i]; + if (emptyAabb) { + emptyAabb = false; + visibleSceneAabb.copy(meshInstance.aabb); + } else { + visibleSceneAabb.add(meshInstance.aabb); + } + } + shadowCamView.copy(shadowCamNode.getWorldTransform()).invert(); + const depthRange = getDepthRange(shadowCamView, visibleSceneAabb.getMin(), visibleSceneAabb.getMax()); + shadowCamNode.translateLocal(0, 0, depthRange.max + 0.1); + shadowCam.farClip = depthRange.max - depthRange.min + 0.2; + lightRenderData.depthRangeCompensation = shadowCam.farClip; + lightRenderData.projectionCompensation = radius; + } + } + generateSplitDistances(light, nearDist, farDist) { + light._shadowCascadeDistances.fill(farDist); + for (let i = 1; i < light.numCascades; i++) { + const fraction = i / light.numCascades; + const linearDist = nearDist + (farDist - nearDist) * fraction; + const logDist = nearDist * (farDist / nearDist) ** fraction; + const dist = math.lerp(linearDist, logDist, light.cascadeDistribution); + light._shadowCascadeDistances[i - 1] = dist; + } + } + getLightRenderPass(light, camera) { + let renderPass = null; + if (this.shadowRenderer.needsShadowRendering(light)) { + const faceCount = light.numShadowFaces; + const shadowUpdateOverrides = light.shadowUpdateOverrides; + let allCascadesRendering = true; + let shadowCamera; + for (let face = 0; face < faceCount; face++) { + if ((shadowUpdateOverrides == null ? void 0 : shadowUpdateOverrides[face]) === SHADOWUPDATE_NONE) allCascadesRendering = false; + shadowCamera = this.shadowRenderer.prepareFace(light, camera, face); + } + renderPass = new RenderPassShadowDirectional(this.device, this.shadowRenderer, light, camera, allCascadesRendering); + this.shadowRenderer.setupRenderPass(renderPass, shadowCamera, allCascadesRendering); + } + return renderPass; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/renderer/shadow-renderer.js +function gauss(x2, sigma) { + return Math.exp(-(x2 * x2) / (2 * sigma * sigma)); +} +function gaussWeights(kernelSize) { + const sigma = (kernelSize - 1) / (2 * 3); + const halfWidth = (kernelSize - 1) * 0.5; + const values = new Array(kernelSize); + let sum = 0; + for (let i = 0; i < kernelSize; ++i) { + values[i] = gauss(i - halfWidth, sigma); + sum += values[i]; + } + for (let i = 0; i < kernelSize; ++i) { + values[i] /= sum; + } + return values; +} +var tempSet = /* @__PURE__ */ new Set(); +var shadowCamView2 = new Mat4(); +var shadowCamViewProj = new Mat4(); +var pixelOffset = new Float32Array(2); +var blurScissorRect = new Vec4(1, 1, 0, 0); +var viewportMatrix = new Mat4(); +var ShadowRenderer = class _ShadowRenderer { + constructor(renderer, lightTextureAtlas) { + this.shadowPassCache = []; + this.device = renderer.device; + this.renderer = renderer; + this.lightTextureAtlas = lightTextureAtlas; + const scope = this.device.scope; + this.polygonOffsetId = scope.resolve("polygonOffset"); + this.polygonOffset = new Float32Array(2); + this.sourceId = scope.resolve("source"); + this.pixelOffsetId = scope.resolve("pixelOffset"); + this.weightId = scope.resolve("weight[0]"); + this.blurVsmShaderCode = [shaderChunks.blurVSMPS, "#define GAUSS\n" + shaderChunks.blurVSMPS]; + const packed = "#define PACKED\n"; + this.blurPackedVsmShaderCode = [packed + this.blurVsmShaderCode[0], packed + this.blurVsmShaderCode[1]]; + this.blurVsmShader = [{}, {}]; + this.blurPackedVsmShader = [{}, {}]; + this.blurVsmWeights = {}; + this.shadowMapLightRadiusId = scope.resolve("light_radius"); + this.viewUniformFormat = null; + this.viewBindGroupFormat = null; + this.blendStateWrite = new BlendState(); + this.blendStateNoWrite = new BlendState(); + this.blendStateNoWrite.setColorWrite(false, false, false, false); + } + static createShadowCamera(device, shadowType, type2, face) { + const shadowCam = LightCamera.create("ShadowCamera", type2, face); + if (shadowType >= SHADOW_VSM8 && shadowType <= SHADOW_VSM32) { + shadowCam.clearColor = new Color(0, 0, 0, 0); + } else { + shadowCam.clearColor = new Color(1, 1, 1, 1); + } + shadowCam.clearDepthBuffer = true; + shadowCam.clearStencilBuffer = false; + return shadowCam; + } + static setShadowCameraSettings(shadowCam, device, shadowType, type2, isClustered) { + let hwPcf = shadowType === SHADOW_PCF5 || (shadowType === SHADOW_PCF1 || shadowType === SHADOW_PCF3) && device.supportsDepthShadow; + if (type2 === LIGHTTYPE_OMNI && !isClustered) { + hwPcf = false; + } + shadowCam.clearColorBuffer = !hwPcf; + } + _cullShadowCastersInternal(meshInstances, visible, camera) { + const numInstances = meshInstances.length; + for (let i = 0; i < numInstances; i++) { + const meshInstance = meshInstances[i]; + if (meshInstance.castShadow) { + if (!meshInstance.cull || meshInstance._isVisible(camera)) { + meshInstance.visibleThisFrame = true; + visible.push(meshInstance); + } + } + } + } + cullShadowCasters(comp, light, visible, camera, casters) { + visible.length = 0; + if (casters) { + this._cullShadowCastersInternal(casters, visible, camera); + } else { + const layers = comp.layerList; + const len = layers.length; + for (let i = 0; i < len; i++) { + const layer = layers[i]; + if (layer._lightsSet.has(light)) { + if (!tempSet.has(layer)) { + tempSet.add(layer); + this._cullShadowCastersInternal(layer.shadowCasters, visible, camera); + } + } + } + tempSet.clear(); + } + visible.sort(this.renderer.sortCompareDepth); + } + setupRenderState(device, light) { + if (device.isWebGL1 && device.extStandardDerivatives) { + if (light._type === LIGHTTYPE_OMNI) { + this.polygonOffset[0] = 0; + this.polygonOffset[1] = 0; + this.polygonOffsetId.setValue(this.polygonOffset); + } else { + this.polygonOffset[0] = light.shadowBias * -1e3; + this.polygonOffset[1] = light.shadowBias * -1e3; + this.polygonOffsetId.setValue(this.polygonOffset); + } + } + const isClustered = this.renderer.scene.clusteredLightingEnabled; + const gpuOrGl2 = device.isWebGL2 || device.isWebGPU; + const useShadowSampler = isClustered ? light._isPcf && gpuOrGl2 : light._isPcf && gpuOrGl2 && light._type !== LIGHTTYPE_OMNI; + device.setBlendState(useShadowSampler ? this.blendStateNoWrite : this.blendStateWrite); + device.setDepthState(light.shadowDepthState); + device.setStencilState(null, null); + } + dispatchUniforms(light, shadowCam, lightRenderData, face) { + const shadowCamNode = shadowCam._node; + if (light._type !== LIGHTTYPE_DIRECTIONAL) { + this.renderer.dispatchViewPos(shadowCamNode.getPosition()); + this.shadowMapLightRadiusId.setValue(light.attenuationEnd); + } + shadowCamView2.setTRS(shadowCamNode.getPosition(), shadowCamNode.getRotation(), Vec3.ONE).invert(); + shadowCamViewProj.mul2(shadowCam.projectionMatrix, shadowCamView2); + const rectViewport = lightRenderData.shadowViewport; + shadowCam.rect = rectViewport; + shadowCam.scissorRect = lightRenderData.shadowScissor; + viewportMatrix.setViewport(rectViewport.x, rectViewport.y, rectViewport.z, rectViewport.w); + lightRenderData.shadowMatrix.mul2(viewportMatrix, shadowCamViewProj); + if (light._type === LIGHTTYPE_DIRECTIONAL) { + light._shadowMatrixPalette.set(lightRenderData.shadowMatrix.data, face * 16); + } + } + getShadowPass(light) { + var _this$shadowPassCache; + const lightType = light._type; + const shadowType = light._shadowType; + let shadowPassInfo = (_this$shadowPassCache = this.shadowPassCache[lightType]) == null ? void 0 : _this$shadowPassCache[shadowType]; + if (!shadowPassInfo) { + const shadowPassName = `ShadowPass_${lightType}_${shadowType}`; + shadowPassInfo = ShaderPass.get(this.device).allocate(shadowPassName, { + isShadow: true, + lightType, + shadowType + }); + if (!this.shadowPassCache[lightType]) this.shadowPassCache[lightType] = []; + this.shadowPassCache[lightType][shadowType] = shadowPassInfo; + } + return shadowPassInfo.index; + } + submitCasters(visibleCasters, light) { + const device = this.device; + const renderer = this.renderer; + const scene2 = renderer.scene; + const passFlags = 1 << SHADER_SHADOW; + const shadowPass = this.getShadowPass(light); + const count = visibleCasters.length; + for (let i = 0; i < count; i++) { + const meshInstance = visibleCasters[i]; + const mesh = meshInstance.mesh; + meshInstance.ensureMaterial(device); + const material = meshInstance.material; + renderer.setBaseConstants(device, material); + renderer.setSkinning(device, meshInstance); + if (material.dirty) { + material.updateUniforms(device, scene2); + material.dirty = false; + } + if (material.chunks) { + renderer.setupCullMode(true, 1, meshInstance); + material.setParameters(device); + meshInstance.setParameters(device, passFlags); + } + const shaderInstance = meshInstance.getShaderInstance(shadowPass, 0, scene2, this.viewUniformFormat, this.viewBindGroupFormat); + const shadowShader = shaderInstance.shader; + meshInstance._key[SORTKEY_DEPTH] = shadowShader.id; + device.setShader(shadowShader); + renderer.setVertexBuffers(device, mesh); + renderer.setMorphing(device, meshInstance.morphInstance); + this.renderer.setupMeshUniformBuffers(shaderInstance, meshInstance); + const style = meshInstance.renderStyle; + device.setIndexBuffer(mesh.indexBuffer[style]); + renderer.drawInstance(device, meshInstance, mesh, style); + renderer._shadowDrawCalls++; + } + } + needsShadowRendering(light) { + const needs = light.enabled && light.castShadows && light.shadowUpdateMode !== SHADOWUPDATE_NONE && light.visibleThisFrame; + if (light.shadowUpdateMode === SHADOWUPDATE_THISFRAME) { + light.shadowUpdateMode = SHADOWUPDATE_NONE; + } + if (needs) { + this.renderer._shadowMapUpdates += light.numShadowFaces; + } + return needs; + } + getLightRenderData(light, camera, face) { + return light.getRenderData(light._type === LIGHTTYPE_DIRECTIONAL ? camera : null, face); + } + setupRenderPass(renderPass, shadowCamera, clearRenderTarget) { + const rt = shadowCamera.renderTarget; + renderPass.init(rt); + renderPass.depthStencilOps.clearDepthValue = 1; + renderPass.depthStencilOps.clearDepth = clearRenderTarget; + if (rt.depthBuffer) { + renderPass.depthStencilOps.storeDepth = true; + } else { + renderPass.colorOps.clearValue.copy(shadowCamera.clearColor); + renderPass.colorOps.clear = clearRenderTarget; + renderPass.depthStencilOps.storeDepth = false; + } + renderPass.requiresCubemaps = false; + } + prepareFace(light, camera, face) { + const type2 = light._type; + const shadowType = light._shadowType; + const isClustered = this.renderer.scene.clusteredLightingEnabled; + const lightRenderData = this.getLightRenderData(light, camera, face); + const shadowCam = lightRenderData.shadowCamera; + _ShadowRenderer.setShadowCameraSettings(shadowCam, this.device, shadowType, type2, isClustered); + const renderTargetIndex = type2 === LIGHTTYPE_DIRECTIONAL ? 0 : face; + shadowCam.renderTarget = light._shadowMap.renderTargets[renderTargetIndex]; + return shadowCam; + } + renderFace(light, camera, face, clear, insideRenderPass = true) { + const device = this.device; + const lightRenderData = this.getLightRenderData(light, camera, face); + const shadowCam = lightRenderData.shadowCamera; + this.dispatchUniforms(light, shadowCam, lightRenderData, face); + const rt = shadowCam.renderTarget; + const renderer = this.renderer; + renderer.setCameraUniforms(shadowCam, rt); + if (device.supportsUniformBuffers) { + renderer.setupViewUniformBuffers(lightRenderData.viewBindGroups, this.viewUniformFormat, this.viewBindGroupFormat, 1); + } + if (insideRenderPass) { + renderer.setupViewport(shadowCam, rt); + if (clear) { + renderer.clear(shadowCam); + } + } else { + renderer.clearView(shadowCam, rt, true, false); + } + this.setupRenderState(device, light); + this.submitCasters(lightRenderData.visibleCasters, light); + } + render(light, camera, insideRenderPass = true) { + if (this.needsShadowRendering(light)) { + const faceCount = light.numShadowFaces; + for (let face = 0; face < faceCount; face++) { + this.prepareFace(light, camera, face); + this.renderFace(light, camera, face, true, insideRenderPass); + } + this.renderVsm(light, camera); + } + } + renderVsm(light, camera) { + if (light._isVsm && light._vsmBlurSize > 1) { + const isClustered = this.renderer.scene.clusteredLightingEnabled; + if (!isClustered || light._type === LIGHTTYPE_DIRECTIONAL) { + this.applyVsmBlur(light, camera); + } + } + } + getVsmBlurShader(isVsm8, blurMode, filterSize) { + let blurShader = (isVsm8 ? this.blurPackedVsmShader : this.blurVsmShader)[blurMode][filterSize]; + if (!blurShader) { + this.blurVsmWeights[filterSize] = gaussWeights(filterSize); + const blurVS = shaderChunks.fullscreenQuadVS; + let blurFS = "#define SAMPLES " + filterSize + "\n"; + if (isVsm8) { + blurFS += this.blurPackedVsmShaderCode[blurMode]; + } else { + blurFS += this.blurVsmShaderCode[blurMode]; + } + const blurShaderName = "blurVsm" + blurMode + filterSize + isVsm8; + blurShader = createShaderFromCode(this.device, blurVS, blurFS, blurShaderName); + if (isVsm8) { + this.blurPackedVsmShader[blurMode][filterSize] = blurShader; + } else { + this.blurVsmShader[blurMode][filterSize] = blurShader; + } + } + return blurShader; + } + applyVsmBlur(light, camera) { + const device = this.device; + device.setBlendState(BlendState.NOBLEND); + const lightRenderData = light.getRenderData(light._type === LIGHTTYPE_DIRECTIONAL ? camera : null, 0); + const shadowCam = lightRenderData.shadowCamera; + const origShadowMap = shadowCam.renderTarget; + const tempShadowMap = this.renderer.shadowMapCache.get(device, light); + const tempRt = tempShadowMap.renderTargets[0]; + const isVsm8 = light._shadowType === SHADOW_VSM8; + const blurMode = light.vsmBlurMode; + const filterSize = light._vsmBlurSize; + const blurShader = this.getVsmBlurShader(isVsm8, blurMode, filterSize); + blurScissorRect.z = light._shadowResolution - 2; + blurScissorRect.w = blurScissorRect.z; + this.sourceId.setValue(origShadowMap.colorBuffer); + pixelOffset[0] = 1 / light._shadowResolution; + pixelOffset[1] = 0; + this.pixelOffsetId.setValue(pixelOffset); + if (blurMode === BLUR_GAUSSIAN) this.weightId.setValue(this.blurVsmWeights[filterSize]); + drawQuadWithShader(device, tempRt, blurShader, null, blurScissorRect); + this.sourceId.setValue(tempRt.colorBuffer); + pixelOffset[1] = pixelOffset[0]; + pixelOffset[0] = 0; + this.pixelOffsetId.setValue(pixelOffset); + drawQuadWithShader(device, origShadowMap, blurShader, null, blurScissorRect); + this.renderer.shadowMapCache.add(light, tempShadowMap); + } + initViewBindGroupFormat() { + if (this.device.supportsUniformBuffers && !this.viewUniformFormat) { + this.viewUniformFormat = new UniformBufferFormat(this.device, [new UniformFormat("matrix_viewProjection", UNIFORMTYPE_MAT4)]); + this.viewBindGroupFormat = new BindGroupFormat(this.device, [new BindUniformBufferFormat(UNIFORM_BUFFER_DEFAULT_SLOT_NAME, SHADERSTAGE_VERTEX | SHADERSTAGE_FRAGMENT)]); + } + } + frameUpdate() { + this.initViewBindGroupFormat(); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/renderer/world-clusters-allocator.js +var tempClusterArray = []; +var WorldClustersAllocator = class { + constructor(graphicsDevice) { + this._empty = null; + this._allocated = []; + this._clusters = /* @__PURE__ */ new Map(); + this.device = graphicsDevice; + } + destroy() { + if (this._empty) { + this._empty.destroy(); + this._empty = null; + } + this._allocated.forEach((cluster) => { + cluster.destroy(); + }); + this._allocated.length = 0; + } + get count() { + return this._allocated.length; + } + get empty() { + if (!this._empty) { + const empty = new WorldClusters(this.device); + empty.name = "ClusterEmpty"; + empty.update([], false, null); + this._empty = empty; + } + return this._empty; + } + assign(renderPasses) { + const empty = this.empty; + tempClusterArray.push(...this._allocated); + this._allocated.length = 0; + this._clusters.clear(); + const passCount = renderPasses.length; + for (let p = 0; p < passCount; p++) { + const renderPass = renderPasses[p]; + const renderActions = renderPass.renderActions; + if (renderActions) { + const count = renderActions.length; + for (let i = 0; i < count; i++) { + const ra = renderActions[i]; + ra.lightClusters = null; + const layer = ra.layer; + if (layer.hasClusteredLights && layer.meshInstances.length) { + const hash = layer.getLightIdHash(); + const existingRenderAction = this._clusters.get(hash); + let clusters = existingRenderAction == null ? void 0 : existingRenderAction.lightClusters; + if (!clusters) { + var _tempClusterArray$pop; + clusters = (_tempClusterArray$pop = tempClusterArray.pop()) != null ? _tempClusterArray$pop : new WorldClusters(this.device); + this._allocated.push(clusters); + this._clusters.set(hash, ra); + } + ra.lightClusters = clusters; + } + if (!ra.lightClusters) { + ra.lightClusters = empty; + } + } + } + } + tempClusterArray.forEach((item) => item.destroy()); + tempClusterArray.length = 0; + } + update(renderPasses, gammaCorrection, lighting) { + this.assign(renderPasses); + this._clusters.forEach((renderAction) => { + const layer = renderAction.layer; + const cluster = renderAction.lightClusters; + cluster.update(layer.clusteredLightsSet, gammaCorrection, lighting); + }); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/renderer/render-pass-cookie-renderer.js +var textureBlitVertexShader = ` + attribute vec2 vertex_position; + varying vec2 uv0; + void main(void) { + gl_Position = vec4(vertex_position, 0.5, 1.0); + uv0 = vertex_position.xy * 0.5 + 0.5; + #ifndef WEBGPU + uv0.y = 1.0 - uv0.y; + #endif + }`; +var textureBlitFragmentShader = ` + varying vec2 uv0; + uniform sampler2D blitTexture; + void main(void) { + gl_FragColor = texture2D(blitTexture, uv0); + }`; +var textureCubeBlitFragmentShader = ` + varying vec2 uv0; + uniform samplerCube blitTexture; + uniform mat4 invViewProj; + void main(void) { + vec4 projPos = vec4(uv0 * 2.0 - 1.0, 0.5, 1.0); + vec4 worldPos = invViewProj * projPos; + gl_FragColor = textureCube(blitTexture, worldPos.xyz); + }`; +var _viewport2 = new Vec4(); +var _invViewProjMatrices = []; +var RenderPassCookieRenderer = class _RenderPassCookieRenderer extends RenderPass { + constructor(device, cubeSlotsOffsets) { + super(device); + this._quadRenderer2D = null; + this._quadRendererCube = null; + this._filteredLights = []; + this._cubeSlotsOffsets = cubeSlotsOffsets; + this.requiresCubemaps = false; + this.blitTextureId = device.scope.resolve("blitTexture"); + this.invViewProjId = device.scope.resolve("invViewProj"); + } + destroy() { + var _this$_quadRenderer2D, _this$_quadRendererCu; + (_this$_quadRenderer2D = this._quadRenderer2D) == null || _this$_quadRenderer2D.destroy(); + this._quadRenderer2D = null; + (_this$_quadRendererCu = this._quadRendererCube) == null || _this$_quadRendererCu.destroy(); + this._quadRendererCube = null; + } + static create(renderTarget, cubeSlotsOffsets) { + const renderPass = new _RenderPassCookieRenderer(renderTarget.device, cubeSlotsOffsets); + renderPass.init(renderTarget); + renderPass.colorOps.clear = false; + renderPass.depthStencilOps.clearDepth = false; + return renderPass; + } + update(lights2) { + const filteredLights = this._filteredLights; + this.filter(lights2, filteredLights); + this.executeEnabled = filteredLights.length > 0; + } + filter(lights2, filteredLights) { + for (let i = 0; i < lights2.length; i++) { + const light = lights2[i]; + if (light._type === LIGHTTYPE_DIRECTIONAL) continue; + if (!light.atlasViewportAllocated) continue; + if (!light.atlasSlotUpdated) continue; + if (light.enabled && light.cookie && light.visibleThisFrame) { + filteredLights.push(light); + } + } + } + initInvViewProjMatrices() { + if (!_invViewProjMatrices.length) { + for (let face = 0; face < 6; face++) { + const camera = LightCamera.create(null, LIGHTTYPE_OMNI, face); + const projMat = camera.projectionMatrix; + const viewMat2 = camera.node.getLocalTransform().clone().invert(); + _invViewProjMatrices[face] = new Mat4().mul2(projMat, viewMat2).invert(); + } + } + } + get quadRenderer2D() { + if (!this._quadRenderer2D) { + const shader = createShaderFromCode(this.device, textureBlitVertexShader, textureBlitFragmentShader, `cookieRenderer2d`); + this._quadRenderer2D = new QuadRender(shader); + } + return this._quadRenderer2D; + } + get quadRendererCube() { + if (!this._quadRendererCube) { + const shader = createShaderFromCode(this.device, textureBlitVertexShader, textureCubeBlitFragmentShader, `cookieRendererCube`); + this._quadRendererCube = new QuadRender(shader); + } + return this._quadRendererCube; + } + execute() { + const device = this.device; + device.setBlendState(BlendState.NOBLEND); + device.setCullMode(CULLFACE_NONE); + device.setDepthState(DepthState.NODEPTH); + device.setStencilState(); + const renderTargetWidth = this.renderTarget.colorBuffer.width; + const cubeSlotsOffsets = this._cubeSlotsOffsets; + const filteredLights = this._filteredLights; + for (let i = 0; i < filteredLights.length; i++) { + const light = filteredLights[i]; + const faceCount = light.numShadowFaces; + const quad = faceCount > 1 ? this.quadRendererCube : this.quadRenderer2D; + if (faceCount > 1) { + this.initInvViewProjMatrices(); + } + this.blitTextureId.setValue(light.cookie); + for (let face = 0; face < faceCount; face++) { + _viewport2.copy(light.atlasViewport); + if (faceCount > 1) { + const smallSize = _viewport2.z / 3; + const offset = cubeSlotsOffsets[face]; + _viewport2.x += smallSize * offset.x; + _viewport2.y += smallSize * offset.y; + _viewport2.z = smallSize; + _viewport2.w = smallSize; + this.invViewProjId.setValue(_invViewProjMatrices[face].data); + } + _viewport2.mulScalar(renderTargetWidth); + quad.render(_viewport2); + } + } + filteredLights.length = 0; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/renderer/render-pass-shadow-local-clustered.js +var RenderPassShadowLocalClustered = class extends RenderPass { + constructor(device, shadowRenderer, shadowRendererLocal) { + super(device); + this.requiresCubemaps = false; + this.shadowRenderer = shadowRenderer; + this.shadowRendererLocal = shadowRendererLocal; + } + update(localLights) { + const shadowLights = this.shadowRendererLocal.shadowLights; + const shadowCamera = this.shadowRendererLocal.prepareLights(shadowLights, localLights); + const count = shadowLights.length; + this.enabled = count > 0; + if (count) { + this.shadowRenderer.setupRenderPass(this, shadowCamera, false); + } + } + execute() { + const shadowLights = this.shadowRendererLocal.shadowLights; + const count = shadowLights.length; + for (let i = 0; i < count; i++) { + const light = shadowLights[i]; + for (let face = 0; face < light.numShadowFaces; face++) { + this.shadowRenderer.renderFace(light, null, face, true); + } + } + shadowLights.length = 0; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/renderer/render-pass-update-clustered.js +var RenderPassUpdateClustered = class extends RenderPass { + constructor(device, renderer, shadowRenderer, shadowRendererLocal, lightTextureAtlas) { + super(device); + this.renderer = renderer; + this.frameGraph = null; + this.cookiesRenderPass = RenderPassCookieRenderer.create(lightTextureAtlas.cookieRenderTarget, lightTextureAtlas.cubeSlotsOffsets); + this.beforePasses.push(this.cookiesRenderPass); + this.shadowRenderPass = new RenderPassShadowLocalClustered(device, shadowRenderer, shadowRendererLocal); + this.beforePasses.push(this.shadowRenderPass); + } + update(frameGraph, shadowsEnabled, cookiesEnabled, lights2, localLights) { + this.frameGraph = frameGraph; + this.cookiesRenderPass.enabled = cookiesEnabled; + if (cookiesEnabled) { + this.cookiesRenderPass.update(lights2); + } + this.shadowRenderPass.enabled = shadowsEnabled; + if (shadowsEnabled) { + this.shadowRenderPass.update(localLights); + } + } + destroy() { + this.cookiesRenderPass.destroy(); + this.cookiesRenderPass = null; + } + execute() { + const { + renderer + } = this; + const { + scene: scene2 + } = renderer; + renderer.worldClustersAllocator.update(this.frameGraph.renderPasses, scene2.gammaCorrection, scene2.lighting); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/core/math/blue-noise.js +var base64String = "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"; +var data = null; +var initData = () => { + if (!data) { + const binaryString = atob(base64String); + data = Uint8Array.from(binaryString, (char) => char.charCodeAt(0)); + } +}; +var blueNoiseData = () => { + initData(); + return data; +}; +var BlueNoise = class { + constructor(seed = 0) { + this.seed = 0; + this.seed = seed * 4; + initData(); + } + _next() { + this.seed = (this.seed + 4) % data.length; + } + value() { + this._next(); + return data[this.seed] / 255; + } + vec4(dest = new Vec4()) { + this._next(); + return dest.set(data[this.seed], data[this.seed + 1], data[this.seed + 2], data[this.seed + 3]).mulScalar(1 / 255); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/graphics/noise-textures.js +var createTexture = (device, namePrefix, size, data2) => { + const texture = new Texture(device, { + name: `${namePrefix}${size}`, + width: size, + height: size, + format: PIXELFORMAT_RGBA8, + addressU: ADDRESS_REPEAT, + addressV: ADDRESS_REPEAT, + type: TEXTURETYPE_DEFAULT, + magFilter: FILTER_NEAREST, + minFilter: FILTER_NEAREST, + anisotropy: 1, + mipmaps: false + }); + texture.lock().set(data2); + texture.unlock(); + return texture; +}; +var deviceCacheBlueNoise = new DeviceCache(); +var getBlueNoiseTexture = (device) => { + return deviceCacheBlueNoise.get(device, () => { + const data2 = blueNoiseData(); + const size = Math.sqrt(data2.length / 4); + return createTexture(device, "BlueNoise", size, data2); + }); +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/renderer/renderer.js +var _skinUpdateIndex = 0; +var viewProjMat = new Mat4(); +var viewInvMat = new Mat4(); +var viewMat = new Mat4(); +var viewMat3 = new Mat3(); +var tempSphere = new BoundingSphere(); +var _flipYMat = new Mat4().setScale(1, -1, 1); +var _tempLightSet = /* @__PURE__ */ new Set(); +var _tempLayerSet = /* @__PURE__ */ new Set(); +var _fixProjRangeMat = new Mat4().set([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0.5, 0, 0, 0, 0.5, 1]); +var _haltonSequence = [new Vec2(0.5, 0.333333), new Vec2(0.25, 0.666667), new Vec2(0.75, 0.111111), new Vec2(0.125, 0.444444), new Vec2(0.625, 0.777778), new Vec2(0.375, 0.222222), new Vec2(0.875, 0.555556), new Vec2(0.0625, 0.888889), new Vec2(0.5625, 0.037037), new Vec2(0.3125, 0.37037), new Vec2(0.8125, 0.703704), new Vec2(0.1875, 0.148148), new Vec2(0.6875, 0.481481), new Vec2(0.4375, 0.814815), new Vec2(0.9375, 0.259259), new Vec2(0.03125, 0.592593)]; +var _tempProjMat0 = new Mat4(); +var _tempProjMat1 = new Mat4(); +var _tempProjMat2 = new Mat4(); +var _tempProjMat3 = new Mat4(); +var _tempProjMat4 = new Mat4(); +var _tempProjMat5 = new Mat4(); +var _tempSet = /* @__PURE__ */ new Set(); +var _tempMeshInstances = []; +var _tempMeshInstancesSkinned = []; +var Renderer = class { + constructor(graphicsDevice) { + this.clustersDebugRendered = false; + this.processingMeshInstances = /* @__PURE__ */ new Set(); + this.worldClustersAllocator = void 0; + this.lights = []; + this.localLights = []; + this.cameraDirShadowLights = /* @__PURE__ */ new Map(); + this.dirLightShadows = /* @__PURE__ */ new Map(); + this.blueNoise = new BlueNoise(123); + this.device = graphicsDevice; + this.scene = null; + this.worldClustersAllocator = new WorldClustersAllocator(graphicsDevice); + this.lightTextureAtlas = new LightTextureAtlas(graphicsDevice); + this.shadowMapCache = new ShadowMapCache(); + this.shadowRenderer = new ShadowRenderer(this, this.lightTextureAtlas); + this._shadowRendererLocal = new ShadowRendererLocal(this, this.shadowRenderer); + this._shadowRendererDirectional = new ShadowRendererDirectional(this, this.shadowRenderer); + this._renderPassUpdateClustered = new RenderPassUpdateClustered(this.device, this, this.shadowRenderer, this._shadowRendererLocal, this.lightTextureAtlas); + this.viewUniformFormat = null; + this.viewBindGroupFormat = null; + this._skinTime = 0; + this._morphTime = 0; + this._cullTime = 0; + this._shadowMapTime = 0; + this._lightClustersTime = 0; + this._layerCompositionUpdateTime = 0; + this._shadowDrawCalls = 0; + this._skinDrawCalls = 0; + this._instancedDrawCalls = 0; + this._shadowMapUpdates = 0; + this._numDrawCallsCulled = 0; + this._camerasRendered = 0; + this._lightClusters = 0; + const scope = graphicsDevice.scope; + this.boneTextureId = scope.resolve("texture_poseMap"); + this.boneTextureSizeId = scope.resolve("texture_poseMapSize"); + this.poseMatrixId = scope.resolve("matrix_pose[0]"); + this.modelMatrixId = scope.resolve("matrix_model"); + this.normalMatrixId = scope.resolve("matrix_normal"); + this.viewInvId = scope.resolve("matrix_viewInverse"); + this.viewPos = new Float32Array(3); + this.viewPosId = scope.resolve("view_position"); + this.projId = scope.resolve("matrix_projection"); + this.projSkyboxId = scope.resolve("matrix_projectionSkybox"); + this.viewId = scope.resolve("matrix_view"); + this.viewId3 = scope.resolve("matrix_view3"); + this.viewProjId = scope.resolve("matrix_viewProjection"); + this.flipYId = scope.resolve("projectionFlipY"); + this.tbnBasis = scope.resolve("tbnBasis"); + this.nearClipId = scope.resolve("camera_near"); + this.farClipId = scope.resolve("camera_far"); + this.cameraParams = new Float32Array(4); + this.cameraParamsId = scope.resolve("camera_params"); + this.viewIndexId = scope.resolve("view_index"); + this.blueNoiseJitterVersion = 0; + this.blueNoiseJitterVec = new Vec4(); + this.blueNoiseJitterData = new Float32Array(4); + this.blueNoiseJitterId = scope.resolve("blueNoiseJitter"); + this.blueNoiseTextureId = scope.resolve("blueNoiseTex32"); + this.alphaTestId = scope.resolve("alpha_ref"); + this.opacityMapId = scope.resolve("texture_opacityMap"); + this.exposureId = scope.resolve("exposure"); + this.twoSidedLightingNegScaleFactorId = scope.resolve("twoSidedLightingNegScaleFactor"); + this.twoSidedLightingNegScaleFactorId.setValue(0); + this.morphWeightsA = scope.resolve("morph_weights_a"); + this.morphWeightsB = scope.resolve("morph_weights_b"); + this.morphPositionTex = scope.resolve("morphPositionTex"); + this.morphNormalTex = scope.resolve("morphNormalTex"); + this.morphTexParams = scope.resolve("morph_tex_params"); + this.lightCube = new LightCube(); + this.constantLightCube = scope.resolve("lightCube[0]"); + } + destroy() { + this.shadowRenderer = null; + this._shadowRendererLocal = null; + this._shadowRendererDirectional = null; + this.shadowMapCache.destroy(); + this.shadowMapCache = null; + this._renderPassUpdateClustered.destroy(); + this._renderPassUpdateClustered = null; + this.lightTextureAtlas.destroy(); + this.lightTextureAtlas = null; + } + sortCompare(drawCallA, drawCallB) { + if (drawCallA.layer === drawCallB.layer) { + if (drawCallA.drawOrder && drawCallB.drawOrder) { + return drawCallA.drawOrder - drawCallB.drawOrder; + } else if (drawCallA.zdist && drawCallB.zdist) { + return drawCallB.zdist - drawCallA.zdist; + } else if (drawCallA.zdist2 && drawCallB.zdist2) { + return drawCallA.zdist2 - drawCallB.zdist2; + } + } + return drawCallB._key[SORTKEY_FORWARD] - drawCallA._key[SORTKEY_FORWARD]; + } + sortCompareMesh(drawCallA, drawCallB) { + if (drawCallA.layer === drawCallB.layer) { + if (drawCallA.drawOrder && drawCallB.drawOrder) { + return drawCallA.drawOrder - drawCallB.drawOrder; + } else if (drawCallA.zdist && drawCallB.zdist) { + return drawCallB.zdist - drawCallA.zdist; + } + } + const keyA = drawCallA._key[SORTKEY_FORWARD]; + const keyB = drawCallB._key[SORTKEY_FORWARD]; + if (keyA === keyB && drawCallA.mesh && drawCallB.mesh) { + return drawCallB.mesh.id - drawCallA.mesh.id; + } + return keyB - keyA; + } + sortCompareDepth(drawCallA, drawCallB) { + const keyA = drawCallA._key[SORTKEY_DEPTH]; + const keyB = drawCallB._key[SORTKEY_DEPTH]; + if (keyA === keyB && drawCallA.mesh && drawCallB.mesh) { + return drawCallB.mesh.id - drawCallA.mesh.id; + } + return keyB - keyA; + } + setupViewport(camera, renderTarget) { + const device = this.device; + const pixelWidth = renderTarget ? renderTarget.width : device.width; + const pixelHeight = renderTarget ? renderTarget.height : device.height; + const rect = camera.rect; + let x2 = Math.floor(rect.x * pixelWidth); + let y2 = Math.floor(rect.y * pixelHeight); + let w = Math.floor(rect.z * pixelWidth); + let h = Math.floor(rect.w * pixelHeight); + device.setViewport(x2, y2, w, h); + if (camera._scissorRectClear) { + const scissorRect = camera.scissorRect; + x2 = Math.floor(scissorRect.x * pixelWidth); + y2 = Math.floor(scissorRect.y * pixelHeight); + w = Math.floor(scissorRect.z * pixelWidth); + h = Math.floor(scissorRect.w * pixelHeight); + } + device.setScissor(x2, y2, w, h); + } + setCameraUniforms(camera, target2) { + const flipY = target2 == null ? void 0 : target2.flipY; + let viewCount = 1; + if (camera.xr && camera.xr.session) { + var _camera$_node; + const transform = ((_camera$_node = camera._node) == null || (_camera$_node = _camera$_node.parent) == null ? void 0 : _camera$_node.getWorldTransform()) || null; + const views = camera.xr.views; + viewCount = views.list.length; + for (let v = 0; v < viewCount; v++) { + const view = views.list[v]; + view.updateTransforms(transform); + camera.frustum.setFromMat4(view.projViewOffMat); + } + } else { + let projMat = camera.projectionMatrix; + if (camera.calculateProjection) { + camera.calculateProjection(projMat, VIEW_CENTER); + } + let projMatSkybox = camera.getProjectionMatrixSkybox(); + if (flipY) { + projMat = _tempProjMat0.mul2(_flipYMat, projMat); + projMatSkybox = _tempProjMat1.mul2(_flipYMat, projMatSkybox); + } + if (this.device.isWebGPU) { + projMat = _tempProjMat2.mul2(_fixProjRangeMat, projMat); + projMatSkybox = _tempProjMat3.mul2(_fixProjRangeMat, projMatSkybox); + } + const { + jitter + } = camera; + let jitterX = 0; + let jitterY = 0; + if (jitter > 0) { + const targetWidth = target2 ? target2.width : this.device.width; + const targetHeight = target2 ? target2.height : this.device.height; + const offset = _haltonSequence[this.device.renderVersion % _haltonSequence.length]; + jitterX = jitter * (offset.x * 2 - 1) / targetWidth; + jitterY = jitter * (offset.y * 2 - 1) / targetHeight; + projMat = _tempProjMat4.copy(projMat); + projMat.data[8] = jitterX; + projMat.data[9] = jitterY; + projMatSkybox = _tempProjMat5.copy(projMatSkybox); + projMatSkybox.data[8] = jitterX; + projMatSkybox.data[9] = jitterY; + if (this.blueNoiseJitterVersion !== this.device.renderVersion) { + this.blueNoiseJitterVersion = this.device.renderVersion; + this.blueNoise.vec4(this.blueNoiseJitterVec); + } + } + const jitterVec = jitter > 0 ? this.blueNoiseJitterVec : Vec4.ZERO; + this.blueNoiseJitterData[0] = jitterVec.x; + this.blueNoiseJitterData[1] = jitterVec.y; + this.blueNoiseJitterData[2] = jitterVec.z; + this.blueNoiseJitterData[3] = jitterVec.w; + this.blueNoiseJitterId.setValue(this.blueNoiseJitterData); + this.projId.setValue(projMat.data); + this.projSkyboxId.setValue(projMatSkybox.data); + if (camera.calculateTransform) { + camera.calculateTransform(viewInvMat, VIEW_CENTER); + } else { + const pos = camera._node.getPosition(); + const rot = camera._node.getRotation(); + viewInvMat.setTRS(pos, rot, Vec3.ONE); + } + this.viewInvId.setValue(viewInvMat.data); + viewMat.copy(viewInvMat).invert(); + this.viewId.setValue(viewMat.data); + viewMat3.setFromMat4(viewMat); + this.viewId3.setValue(viewMat3.data); + viewProjMat.mul2(projMat, viewMat); + this.viewProjId.setValue(viewProjMat.data); + camera._storeShaderMatrices(viewProjMat, jitterX, jitterY, this.device.renderVersion); + this.flipYId.setValue(flipY ? -1 : 1); + this.dispatchViewPos(camera._node.getPosition()); + camera.frustum.setFromMat4(viewProjMat); + } + this.tbnBasis.setValue(flipY ? -1 : 1); + const n = camera._nearClip; + const f = camera._farClip; + this.nearClipId.setValue(n); + this.farClipId.setValue(f); + this.cameraParams[0] = 1 / f; + this.cameraParams[1] = f; + this.cameraParams[2] = n; + this.cameraParams[3] = camera.projection === PROJECTION_ORTHOGRAPHIC ? 1 : 0; + this.cameraParamsId.setValue(this.cameraParams); + this.exposureId.setValue(this.scene.physicalUnits ? camera.getExposure() : this.scene.exposure); + return viewCount; + } + clear(camera, clearColor, clearDepth, clearStencil) { + const flags = ((clearColor != null ? clearColor : camera._clearColorBuffer) ? CLEARFLAG_COLOR : 0) | ((clearDepth != null ? clearDepth : camera._clearDepthBuffer) ? CLEARFLAG_DEPTH : 0) | ((clearStencil != null ? clearStencil : camera._clearStencilBuffer) ? CLEARFLAG_STENCIL : 0); + if (flags) { + const device = this.device; + device.clear({ + color: [camera._clearColor.r, camera._clearColor.g, camera._clearColor.b, camera._clearColor.a], + depth: camera._clearDepth, + stencil: camera._clearStencil, + flags + }); + } + } + setCamera(camera, target2, clear, renderAction = null) { + this.setCameraUniforms(camera, target2); + this.clearView(camera, target2, clear, false); + } + clearView(camera, target2, clear, forceWrite) { + const device = this.device; + device.setRenderTarget(target2); + device.updateBegin(); + if (forceWrite) { + device.setColorWrite(true, true, true, true); + device.setDepthWrite(true); + } + this.setupViewport(camera, target2); + if (clear) { + const options = camera._clearOptions; + device.clear(options ? options : { + color: [camera._clearColor.r, camera._clearColor.g, camera._clearColor.b, camera._clearColor.a], + depth: camera._clearDepth, + flags: (camera._clearColorBuffer ? CLEARFLAG_COLOR : 0) | (camera._clearDepthBuffer ? CLEARFLAG_DEPTH : 0) | (camera._clearStencilBuffer ? CLEARFLAG_STENCIL : 0), + stencil: camera._clearStencil + }); + } + } + setupCullMode(cullFaces, flipFactor, drawCall) { + const material = drawCall.material; + let mode = CULLFACE_NONE; + if (cullFaces) { + let flipFaces = 1; + if (material.cull === CULLFACE_FRONT || material.cull === CULLFACE_BACK) { + flipFaces = flipFactor * drawCall.flipFacesFactor * drawCall.node.worldScaleSign; + } + if (flipFaces < 0) { + mode = material.cull === CULLFACE_FRONT ? CULLFACE_BACK : CULLFACE_FRONT; + } else { + mode = material.cull; + } + } + this.device.setCullMode(mode); + if (mode === CULLFACE_NONE && material.cull === CULLFACE_NONE) { + this.twoSidedLightingNegScaleFactorId.setValue(drawCall.node.worldScaleSign); + } + } + updateCameraFrustum(camera) { + if (camera.xr && camera.xr.views.list.length) { + const view = camera.xr.views.list[0]; + viewProjMat.mul2(view.projMat, view.viewOffMat); + camera.frustum.setFromMat4(viewProjMat); + return; + } + const projMat = camera.projectionMatrix; + if (camera.calculateProjection) { + camera.calculateProjection(projMat, VIEW_CENTER); + } + if (camera.calculateTransform) { + camera.calculateTransform(viewInvMat, VIEW_CENTER); + } else { + const pos = camera._node.getPosition(); + const rot = camera._node.getRotation(); + viewInvMat.setTRS(pos, rot, Vec3.ONE); + this.viewInvId.setValue(viewInvMat.data); + } + viewMat.copy(viewInvMat).invert(); + viewProjMat.mul2(projMat, viewMat); + camera.frustum.setFromMat4(viewProjMat); + } + setBaseConstants(device, material) { + device.setCullMode(material.cull); + if (material.opacityMap) { + this.opacityMapId.setValue(material.opacityMap); + } + if (material.opacityMap || material.alphaTest > 0) { + this.alphaTestId.setValue(material.alphaTest); + } + } + updateCpuSkinMatrices(drawCalls) { + _skinUpdateIndex++; + const drawCallsCount = drawCalls.length; + if (drawCallsCount === 0) return; + for (let i = 0; i < drawCallsCount; i++) { + const si = drawCalls[i].skinInstance; + if (si) { + si.updateMatrices(drawCalls[i].node, _skinUpdateIndex); + si._dirty = true; + } + } + } + updateGpuSkinMatrices(drawCalls) { + for (const drawCall of drawCalls) { + const skin = drawCall.skinInstance; + if (skin && skin._dirty) { + skin.updateMatrixPalette(drawCall.node, _skinUpdateIndex); + skin._dirty = false; + } + } + } + updateMorphing(drawCalls) { + for (const drawCall of drawCalls) { + const morphInst = drawCall.morphInstance; + if (morphInst && morphInst._dirty) { + morphInst.update(); + } + } + } + updateGSplats(drawCalls) { + for (const drawCall of drawCalls) { + var _drawCall$gsplatInsta; + (_drawCall$gsplatInsta = drawCall.gsplatInstance) == null || _drawCall$gsplatInsta.update(); + } + } + gpuUpdate(drawCalls) { + this.updateGpuSkinMatrices(drawCalls); + this.updateMorphing(drawCalls); + this.updateGSplats(drawCalls); + } + setVertexBuffers(device, mesh) { + device.setVertexBuffer(mesh.vertexBuffer); + } + setMorphing(device, morphInstance) { + if (morphInstance) { + if (morphInstance.morph.useTextureMorph) { + device.setVertexBuffer(morphInstance.morph.vertexBufferIds); + this.morphPositionTex.setValue(morphInstance.texturePositions); + this.morphNormalTex.setValue(morphInstance.textureNormals); + this.morphTexParams.setValue(morphInstance._textureParams); + } else { + for (let t = 0; t < morphInstance._activeVertexBuffers.length; t++) { + const vb = morphInstance._activeVertexBuffers[t]; + if (vb) { + const semantic = SEMANTIC_ATTR + (t + 8); + vb.format.elements[0].name = semantic; + vb.format.elements[0].scopeId = device.scope.resolve(semantic); + vb.format.update(); + device.setVertexBuffer(vb); + } + } + this.morphWeightsA.setValue(morphInstance._shaderMorphWeightsA); + this.morphWeightsB.setValue(morphInstance._shaderMorphWeightsB); + } + } + } + setSkinning(device, meshInstance) { + const skinInstance = meshInstance.skinInstance; + if (skinInstance) { + this._skinDrawCalls++; + if (device.supportsBoneTextures) { + const boneTexture = skinInstance.boneTexture; + this.boneTextureId.setValue(boneTexture); + this.boneTextureSizeId.setValue(skinInstance.boneTextureSize); + } else { + this.poseMatrixId.setValue(skinInstance.matrixPalette); + } + } + } + dispatchViewPos(position2) { + const vp = this.viewPos; + vp[0] = position2.x; + vp[1] = position2.y; + vp[2] = position2.z; + this.viewPosId.setValue(vp); + } + initViewBindGroupFormat(isClustered) { + if (this.device.supportsUniformBuffers && !this.viewUniformFormat) { + const uniforms = [new UniformFormat("matrix_viewProjection", UNIFORMTYPE_MAT4), new UniformFormat("cubeMapRotationMatrix", UNIFORMTYPE_MAT3), new UniformFormat("view_position", UNIFORMTYPE_VEC3), new UniformFormat("skyboxIntensity", UNIFORMTYPE_FLOAT), new UniformFormat("exposure", UNIFORMTYPE_FLOAT), new UniformFormat("textureBias", UNIFORMTYPE_FLOAT)]; + if (isClustered) { + uniforms.push(...[new UniformFormat("clusterCellsCountByBoundsSize", UNIFORMTYPE_VEC3), new UniformFormat("clusterTextureSize", UNIFORMTYPE_VEC3), new UniformFormat("clusterBoundsMin", UNIFORMTYPE_VEC3), new UniformFormat("clusterBoundsDelta", UNIFORMTYPE_VEC3), new UniformFormat("clusterCellsDot", UNIFORMTYPE_VEC3), new UniformFormat("clusterCellsMax", UNIFORMTYPE_VEC3), new UniformFormat("clusterCompressionLimit0", UNIFORMTYPE_VEC2), new UniformFormat("shadowAtlasParams", UNIFORMTYPE_VEC2), new UniformFormat("clusterMaxCells", UNIFORMTYPE_INT), new UniformFormat("clusterSkip", UNIFORMTYPE_FLOAT)]); + } + this.viewUniformFormat = new UniformBufferFormat(this.device, uniforms); + const formats = [new BindUniformBufferFormat(UNIFORM_BUFFER_DEFAULT_SLOT_NAME, SHADERSTAGE_VERTEX | SHADERSTAGE_FRAGMENT), new BindTextureFormat("lightsTextureFloat", SHADERSTAGE_FRAGMENT, TEXTUREDIMENSION_2D, SAMPLETYPE_UNFILTERABLE_FLOAT), new BindTextureFormat("lightsTexture8", SHADERSTAGE_FRAGMENT, TEXTUREDIMENSION_2D, SAMPLETYPE_UNFILTERABLE_FLOAT), new BindTextureFormat("shadowAtlasTexture", SHADERSTAGE_FRAGMENT, TEXTUREDIMENSION_2D, SAMPLETYPE_DEPTH), new BindTextureFormat("cookieAtlasTexture", SHADERSTAGE_FRAGMENT, TEXTUREDIMENSION_2D, SAMPLETYPE_FLOAT), new BindTextureFormat("areaLightsLutTex1", SHADERSTAGE_FRAGMENT, TEXTUREDIMENSION_2D, SAMPLETYPE_FLOAT), new BindTextureFormat("areaLightsLutTex2", SHADERSTAGE_FRAGMENT, TEXTUREDIMENSION_2D, SAMPLETYPE_FLOAT)]; + if (isClustered) { + formats.push(...[new BindTextureFormat("clusterWorldTexture", SHADERSTAGE_FRAGMENT, TEXTUREDIMENSION_2D, SAMPLETYPE_UNFILTERABLE_FLOAT)]); + } + this.viewBindGroupFormat = new BindGroupFormat(this.device, formats); + } + } + setupViewUniformBuffers(viewBindGroups, viewUniformFormat, viewBindGroupFormat, viewCount) { + const device = this.device; + while (viewBindGroups.length < viewCount) { + const ub = new UniformBuffer(device, viewUniformFormat, false); + const bg = new BindGroup(device, viewBindGroupFormat, ub); + viewBindGroups.push(bg); + } + const viewBindGroup = viewBindGroups[0]; + viewBindGroup.defaultUniformBuffer.update(); + viewBindGroup.update(); + device.setBindGroup(BINDGROUP_VIEW, viewBindGroup); + } + setupMeshUniformBuffers(shaderInstance, meshInstance) { + const device = this.device; + if (device.supportsUniformBuffers) { + this.modelMatrixId.setValue(meshInstance.node.worldTransform.data); + this.normalMatrixId.setValue(meshInstance.node.normalMatrix.data); + const meshBindGroup = shaderInstance.getBindGroup(device); + meshBindGroup.defaultUniformBuffer.update(); + meshBindGroup.update(); + device.setBindGroup(BINDGROUP_MESH, meshBindGroup); + } + } + drawInstance(device, meshInstance, mesh, style, normal) { + const modelMatrix = meshInstance.node.worldTransform; + this.modelMatrixId.setValue(modelMatrix.data); + if (normal) { + this.normalMatrixId.setValue(meshInstance.node.normalMatrix.data); + } + const instancingData = meshInstance.instancingData; + if (instancingData) { + if (instancingData.count > 0) { + this._instancedDrawCalls++; + device.setVertexBuffer(instancingData.vertexBuffer); + device.draw(mesh.primitive[style], instancingData.count); + } else { + device.clearVertexBuffer(); + } + } else { + device.draw(mesh.primitive[style]); + } + } + drawInstance2(device, meshInstance, mesh, style) { + const instancingData = meshInstance.instancingData; + if (instancingData) { + if (instancingData.count > 0) { + this._instancedDrawCalls++; + device.draw(mesh.primitive[style], instancingData.count, true); + } else { + device.clearVertexBuffer(); + } + } else { + device.draw(mesh.primitive[style], void 0, true); + } + } + cull(camera, drawCalls, culledInstances) { + const opaque = culledInstances.opaque; + opaque.length = 0; + const transparent = culledInstances.transparent; + transparent.length = 0; + const doCull = camera.frustumCulling; + const count = drawCalls.length; + for (let i = 0; i < count; i++) { + const drawCall = drawCalls[i]; + if (drawCall.visible) { + const visible = !doCull || !drawCall.cull || drawCall._isVisible(camera); + if (visible) { + drawCall.visibleThisFrame = true; + const bucket = drawCall.transparent ? transparent : opaque; + bucket.push(drawCall); + if (drawCall.skinInstance || drawCall.morphInstance || drawCall.gsplatInstance) { + this.processingMeshInstances.add(drawCall); + if (drawCall.gsplatInstance) { + drawCall.gsplatInstance.cameras.push(camera); + } + } + } + } + } + } + collectLights(comp) { + this.lights.length = 0; + this.localLights.length = 0; + const stats = this.scene._stats; + const count = comp.layerList.length; + for (let i = 0; i < count; i++) { + const layer = comp.layerList[i]; + if (!_tempLayerSet.has(layer)) { + _tempLayerSet.add(layer); + const lights2 = layer._lights; + for (let j = 0; j < lights2.length; j++) { + const light = lights2[j]; + if (!_tempLightSet.has(light)) { + _tempLightSet.add(light); + this.lights.push(light); + if (light._type !== LIGHTTYPE_DIRECTIONAL) { + this.localLights.push(light); + } + } + } + } + } + stats.lights = this.lights.length; + _tempLightSet.clear(); + _tempLayerSet.clear(); + } + cullLights(camera, lights2) { + const clusteredLightingEnabled = this.scene.clusteredLightingEnabled; + const physicalUnits = this.scene.physicalUnits; + for (let i = 0; i < lights2.length; i++) { + const light = lights2[i]; + if (light.enabled) { + if (light._type !== LIGHTTYPE_DIRECTIONAL) { + light.getBoundingSphere(tempSphere); + if (camera.frustum.containsSphere(tempSphere)) { + light.visibleThisFrame = true; + light.usePhysicalUnits = physicalUnits; + const screenSize = camera.getScreenSize(tempSphere); + light.maxScreenSize = Math.max(light.maxScreenSize, screenSize); + } else { + if (!clusteredLightingEnabled) { + if (light.castShadows && !light.shadowMap) { + light.visibleThisFrame = true; + } + } + } + } else { + light.usePhysicalUnits = this.scene.physicalUnits; + } + } + } + } + cullShadowmaps(comp) { + const isClustered = this.scene.clusteredLightingEnabled; + for (let i = 0; i < this.localLights.length; i++) { + const light = this.localLights[i]; + if (light._type !== LIGHTTYPE_DIRECTIONAL) { + if (isClustered) { + if (light.atlasSlotUpdated && light.shadowUpdateMode === SHADOWUPDATE_NONE) { + light.shadowUpdateMode = SHADOWUPDATE_THISFRAME; + } + } else { + if (light.shadowUpdateMode === SHADOWUPDATE_NONE && light.castShadows) { + if (!light.getRenderData(null, 0).shadowCamera.renderTarget) { + light.shadowUpdateMode = SHADOWUPDATE_THISFRAME; + } + } + } + if (light.visibleThisFrame && light.castShadows && light.shadowUpdateMode !== SHADOWUPDATE_NONE) { + this._shadowRendererLocal.cull(light, comp); + } + } + } + this.cameraDirShadowLights.clear(); + const cameras = comp.cameras; + for (let i = 0; i < cameras.length; i++) { + const cameraComponent = cameras[i]; + if (cameraComponent.enabled) { + const camera = cameraComponent.camera; + let lightList; + const cameraLayers = camera.layers; + for (let l = 0; l < cameraLayers.length; l++) { + const cameraLayer = comp.getLayerById(cameraLayers[l]); + if (cameraLayer) { + const layerDirLights = cameraLayer.splitLights[LIGHTTYPE_DIRECTIONAL]; + for (let j = 0; j < layerDirLights.length; j++) { + const light = layerDirLights[j]; + if (light.castShadows && !_tempSet.has(light)) { + var _lightList; + _tempSet.add(light); + lightList = (_lightList = lightList) != null ? _lightList : []; + lightList.push(light); + this._shadowRendererDirectional.cull(light, comp, camera); + } + } + } + } + if (lightList) { + this.cameraDirShadowLights.set(camera, lightList); + } + _tempSet.clear(); + } + } + } + cullComposition(comp) { + this.processingMeshInstances.clear(); + const numCameras = comp.cameras.length; + for (let i = 0; i < numCameras; i++) { + const camera = comp.cameras[i]; + let currentRenderTarget; + let cameraChanged = true; + this._camerasRendered++; + const layerIds = camera.layers; + for (let j = 0; j < layerIds.length; j++) { + const layer = comp.getLayerById(layerIds[j]); + if (layer && layer.enabled) { + var _camera$renderTarget; + const renderTarget = (_camera$renderTarget = camera.renderTarget) != null ? _camera$renderTarget : layer.renderTarget; + if (cameraChanged || renderTarget !== currentRenderTarget) { + cameraChanged = false; + currentRenderTarget = renderTarget; + camera.frameUpdate(renderTarget); + this.updateCameraFrustum(camera.camera); + } + this.cullLights(camera.camera, layer._lights); + layer.onPreCull == null || layer.onPreCull(comp.camerasMap.get(camera)); + const culledInstances = layer.getCulledInstances(camera.camera); + this.cull(camera.camera, layer.meshInstances, culledInstances); + layer.onPostCull == null || layer.onPostCull(comp.camerasMap.get(camera)); + } + } + } + if (this.scene.clusteredLightingEnabled) { + this.updateLightTextureAtlas(); + } + this.cullShadowmaps(comp); + } + updateShaders(drawCalls, onlyLitShaders) { + const count = drawCalls.length; + for (let i = 0; i < count; i++) { + const mat = drawCalls[i].material; + if (mat) { + if (!_tempSet.has(mat)) { + _tempSet.add(mat); + if (mat.getShaderVariant !== Material.prototype.getShaderVariant) { + if (onlyLitShaders) { + if (!mat.useLighting || mat.emitter && !mat.emitter.lighting) continue; + } + mat.clearVariants(); + } + } + } + } + _tempSet.clear(); + } + updateFrameUniforms() { + this.blueNoiseTextureId.setValue(getBlueNoiseTexture(this.device)); + } + beginFrame(comp) { + const scene2 = this.scene; + const updateShaders = scene2.updateShaders; + const layers = comp.layerList; + const layerCount = layers.length; + for (let i = 0; i < layerCount; i++) { + const layer = layers[i]; + const meshInstances = layer.meshInstances; + const count = meshInstances.length; + for (let j = 0; j < count; j++) { + const meshInst = meshInstances[j]; + meshInst.visibleThisFrame = false; + if (updateShaders) { + _tempMeshInstances.push(meshInst); + } + if (meshInst.skinInstance) { + _tempMeshInstancesSkinned.push(meshInst); + } + } + } + if (updateShaders) { + const onlyLitShaders = !scene2.updateShaders; + this.updateShaders(_tempMeshInstances, onlyLitShaders); + scene2.updateShaders = false; + scene2._shaderVersion++; + } + this.updateFrameUniforms(); + this.updateCpuSkinMatrices(_tempMeshInstancesSkinned); + _tempMeshInstances.length = 0; + _tempMeshInstancesSkinned.length = 0; + const lights2 = this.lights; + const lightCount = lights2.length; + for (let i = 0; i < lightCount; i++) { + lights2[i].beginFrame(); + } + } + updateLightTextureAtlas() { + this.lightTextureAtlas.update(this.localLights, this.scene.lighting); + } + updateLayerComposition(comp) { + const len = comp.layerList.length; + for (let i = 0; i < len; i++) { + comp.layerList[i]._postRenderCounter = 0; + } + const scene2 = this.scene; + const shaderVersion = scene2._shaderVersion; + for (let i = 0; i < len; i++) { + const layer = comp.layerList[i]; + layer._shaderVersion = shaderVersion; + layer._preRenderCalledForCameras = 0; + layer._postRenderCalledForCameras = 0; + const transparent = comp.subLayerList[i]; + if (transparent) { + layer._postRenderCounter |= 2; + } else { + layer._postRenderCounter |= 1; + } + layer._postRenderCounterMax = layer._postRenderCounter; + } + comp._update(); + } + frameUpdate() { + this.clustersDebugRendered = false; + this.initViewBindGroupFormat(this.scene.clusteredLightingEnabled); + this.dirLightShadows.clear(); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/composition/render-action.js +var RenderAction = class { + constructor() { + this.layer = null; + this.transparent = false; + this.camera = null; + this.renderTarget = null; + this.lightClusters = null; + this.clearColor = false; + this.clearDepth = false; + this.clearStencil = false; + this.triggerPostprocess = false; + this.firstCameraUse = false; + this.lastCameraUse = false; + this.viewBindGroups = []; + this.useCameraPasses = false; + } + destroy() { + this.viewBindGroups.forEach((bg) => { + bg.defaultUniformBuffer.destroy(); + bg.destroy(); + }); + this.viewBindGroups.length = 0; + } + setupClears(camera, layer) { + this.clearColor = (camera == null ? void 0 : camera.clearColorBuffer) || layer.clearColorBuffer; + this.clearDepth = (camera == null ? void 0 : camera.clearDepthBuffer) || layer.clearDepthBuffer; + this.clearStencil = (camera == null ? void 0 : camera.clearStencilBuffer) || layer.clearStencilBuffer; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/renderer/render-pass-forward.js +var RenderPassForward = class extends RenderPass { + constructor(device, layerComposition, scene2, renderer) { + super(device); + this.layerComposition = void 0; + this.scene = void 0; + this.renderer = void 0; + this.renderActions = []; + this.noDepthClear = false; + this.layerComposition = layerComposition; + this.scene = scene2; + this.renderer = renderer; + } + addRenderAction(renderAction) { + this.renderActions.push(renderAction); + } + addLayer(cameraComponent, layer, transparent, autoClears = true) { + const ra = new RenderAction(); + ra.renderTarget = this.renderTarget; + ra.camera = cameraComponent; + ra.layer = layer; + ra.transparent = transparent; + if (autoClears) { + const firstRa = this.renderActions.length === 0; + ra.setupClears(firstRa ? cameraComponent : void 0, layer); + } + this.addRenderAction(ra); + } + addLayers(composition, cameraComponent, startIndex, firstLayerClears, lastLayerId, lastLayerIsTransparent = true) { + const { + layerList, + subLayerEnabled, + subLayerList + } = composition; + let clearRenderTarget = firstLayerClears; + let index = startIndex; + while (index < layerList.length) { + const layer = layerList[index]; + const isTransparent = subLayerList[index]; + const enabled = layer.enabled && subLayerEnabled[index]; + const renderedbyCamera = cameraComponent.camera.layersSet.has(layer.id); + if (enabled && renderedbyCamera) { + this.addLayer(cameraComponent, layer, isTransparent, clearRenderTarget); + clearRenderTarget = false; + } + index++; + if (layer.id === lastLayerId && isTransparent === lastLayerIsTransparent) { + break; + } + } + return index; + } + updateDirectionalShadows() { + const { + renderer, + renderActions + } = this; + for (let i = 0; i < renderActions.length; i++) { + const renderAction = renderActions[i]; + const cameraComp = renderAction.camera; + const camera = cameraComp.camera; + const shadowDirLights = this.renderer.cameraDirShadowLights.get(camera); + if (shadowDirLights) { + for (let l = 0; l < shadowDirLights.length; l++) { + const light = shadowDirLights[l]; + if (renderer.dirLightShadows.get(light) !== camera) { + renderer.dirLightShadows.set(light, camera); + const shadowPass = renderer._shadowRendererDirectional.getLightRenderPass(light, camera); + if (shadowPass) { + this.beforePasses.push(shadowPass); + } + } + } + } + } + } + updateClears() { + const renderAction = this.renderActions[0]; + if (renderAction) { + const cameraComponent = renderAction.camera; + const camera = cameraComponent.camera; + const fullSizeClearRect = camera.fullSizeClearRect; + this.setClearColor(fullSizeClearRect && renderAction.clearColor ? camera.clearColor : void 0); + this.setClearDepth(fullSizeClearRect && renderAction.clearDepth && !this.noDepthClear ? camera.clearDepth : void 0); + this.setClearStencil(fullSizeClearRect && renderAction.clearStencil ? camera.clearStencil : void 0); + } + } + frameUpdate() { + super.frameUpdate(); + this.updateDirectionalShadows(); + this.updateClears(); + } + before() { + const { + renderActions + } = this; + if (renderActions.length) { + const ra = renderActions[0]; + if (ra.camera.onPreRender && ra.firstCameraUse) { + ra.camera.onPreRender(); + } + } + } + execute() { + const { + layerComposition, + renderActions + } = this; + for (let i = 0; i < renderActions.length; i++) { + const ra = renderActions[i]; + if (layerComposition.isEnabled(ra.layer, ra.transparent)) { + this.renderRenderAction(ra, i === 0); + } + } + } + after() { + const { + renderActions + } = this; + if (renderActions.length) { + const ra = renderActions[renderActions.length - 1]; + if (ra.camera.onPostRender && ra.lastCameraUse) { + ra.camera.onPostRender(); + } + } + this.beforePasses.length = 0; + } + renderRenderAction(renderAction, firstRenderAction) { + const { + renderer, + layerComposition + } = this; + const device = renderer.device; + const { + layer, + transparent, + camera + } = renderAction; + const cameraPass = layerComposition.camerasMap.get(camera); + if (!transparent && layer.onPreRenderOpaque) { + layer.onPreRenderOpaque(cameraPass); + } else if (transparent && layer.onPreRenderTransparent) { + layer.onPreRenderTransparent(cameraPass); + } + if (!(layer._preRenderCalledForCameras & 1 << cameraPass)) { + if (layer.onPreRender) { + layer.onPreRender(cameraPass); + } + layer._preRenderCalledForCameras |= 1 << cameraPass; + } + if (camera) { + var _camera$camera$shader, _camera$camera$shader2; + const options = { + lightClusters: renderAction.lightClusters + }; + const shaderPass = (_camera$camera$shader = (_camera$camera$shader2 = camera.camera.shaderPassInfo) == null ? void 0 : _camera$camera$shader2.index) != null ? _camera$camera$shader : layer.shaderPass; + if (!firstRenderAction || !camera.camera.fullSizeClearRect) { + options.clearColor = renderAction.clearColor; + options.clearDepth = renderAction.clearDepth; + options.clearStencil = renderAction.clearStencil; + } + renderer.renderForwardLayer(camera.camera, renderAction.renderTarget, layer, transparent, shaderPass, renderAction.viewBindGroups, options); + device.setBlendState(BlendState.NOBLEND); + device.setStencilState(null, null); + device.setAlphaToCoverage(false); + } + if (!transparent && layer.onPostRenderOpaque) { + layer.onPostRenderOpaque(cameraPass); + } else if (transparent && layer.onPostRenderTransparent) { + layer.onPostRenderTransparent(cameraPass); + } + if (layer.onPostRender && !(layer._postRenderCalledForCameras & 1 << cameraPass)) { + layer._postRenderCounter &= ~(transparent ? 2 : 1); + if (layer._postRenderCounter === 0) { + layer.onPostRender(cameraPass); + layer._postRenderCalledForCameras |= 1 << cameraPass; + layer._postRenderCounter = layer._postRenderCounterMax; + } + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/renderer/render-pass-postprocessing.js +var RenderPassPostprocessing = class extends RenderPass { + constructor(device, renderer, renderAction) { + super(device); + this.renderer = renderer; + this.renderAction = renderAction; + this.requiresCubemaps = false; + } + execute() { + const renderAction = this.renderAction; + const camera = renderAction.camera; + camera.onPostprocessing(); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/renderer/forward-renderer.js +var _noLights = [[], [], []]; +var _drawCallList = { + drawCalls: [], + shaderInstances: [], + isNewMaterial: [], + lightMaskChanged: [], + clear: function() { + this.drawCalls.length = 0; + this.shaderInstances.length = 0; + this.isNewMaterial.length = 0; + this.lightMaskChanged.length = 0; + } +}; +function vogelDiskPrecalculationSamples(numSamples) { + const samples = []; + for (let i = 0; i < numSamples; ++i) { + const r = Math.sqrt(i + 0.5) / Math.sqrt(numSamples); + samples.push(r); + } + return samples; +} +function vogelSpherePrecalculationSamples(numSamples) { + const samples = []; + for (let i = 0; i < numSamples; i++) { + const weight = i / numSamples; + const radius = Math.sqrt(1 - weight * weight); + samples.push(radius); + } + return samples; +} +var ForwardRenderer = class extends Renderer { + constructor(graphicsDevice) { + super(graphicsDevice); + const device = this.device; + this._forwardDrawCalls = 0; + this._materialSwitches = 0; + this._depthMapTime = 0; + this._forwardTime = 0; + this._sortTime = 0; + const scope = device.scope; + this.fogColorId = scope.resolve("fog_color"); + this.fogStartId = scope.resolve("fog_start"); + this.fogEndId = scope.resolve("fog_end"); + this.fogDensityId = scope.resolve("fog_density"); + this.ambientId = scope.resolve("light_globalAmbient"); + this.skyboxIntensityId = scope.resolve("skyboxIntensity"); + this.cubeMapRotationMatrixId = scope.resolve("cubeMapRotationMatrix"); + this.pcssDiskSamplesId = scope.resolve("pcssDiskSamples[0]"); + this.pcssSphereSamplesId = scope.resolve("pcssSphereSamples[0]"); + this.lightColorId = []; + this.lightDir = []; + this.lightDirId = []; + this.lightShadowMapId = []; + this.lightShadowMatrixId = []; + this.lightShadowParamsId = []; + this.lightShadowIntensity = []; + this.lightRadiusId = []; + this.lightPos = []; + this.lightPosId = []; + this.lightWidth = []; + this.lightWidthId = []; + this.lightHeight = []; + this.lightHeightId = []; + this.lightInAngleId = []; + this.lightOutAngleId = []; + this.lightCookieId = []; + this.lightCookieIntId = []; + this.lightCookieMatrixId = []; + this.lightCookieOffsetId = []; + this.lightShadowSearchAreaId = []; + this.lightCameraParamsId = []; + this.shadowMatrixPaletteId = []; + this.shadowCascadeDistancesId = []; + this.shadowCascadeCountId = []; + this.screenSizeId = scope.resolve("uScreenSize"); + this._screenSize = new Float32Array(4); + this.fogColor = new Float32Array(3); + this.ambientColor = new Float32Array(3); + this.pcssDiskSamples = vogelDiskPrecalculationSamples(16); + this.pcssSphereSamples = vogelSpherePrecalculationSamples(16); + } + destroy() { + super.destroy(); + } + dispatchGlobalLights(scene2) { + this.ambientColor[0] = scene2.ambientLight.r; + this.ambientColor[1] = scene2.ambientLight.g; + this.ambientColor[2] = scene2.ambientLight.b; + if (scene2.gammaCorrection) { + for (let i = 0; i < 3; i++) { + this.ambientColor[i] = Math.pow(this.ambientColor[i], 2.2); + } + } + if (scene2.physicalUnits) { + for (let i = 0; i < 3; i++) { + this.ambientColor[i] *= scene2.ambientLuminance; + } + } + this.ambientId.setValue(this.ambientColor); + this.skyboxIntensityId.setValue(scene2.physicalUnits ? scene2.skyboxLuminance : scene2.skyboxIntensity); + this.cubeMapRotationMatrixId.setValue(scene2._skyboxRotationMat3.data); + } + _resolveLight(scope, i) { + const light = "light" + i; + this.lightColorId[i] = scope.resolve(light + "_color"); + this.lightDir[i] = new Float32Array(3); + this.lightDirId[i] = scope.resolve(light + "_direction"); + this.lightShadowMapId[i] = scope.resolve(light + "_shadowMap"); + this.lightShadowMatrixId[i] = scope.resolve(light + "_shadowMatrix"); + this.lightShadowParamsId[i] = scope.resolve(light + "_shadowParams"); + this.lightShadowIntensity[i] = scope.resolve(light + "_shadowIntensity"); + this.lightShadowSearchAreaId[i] = scope.resolve(light + "_shadowSearchArea"); + this.lightRadiusId[i] = scope.resolve(light + "_radius"); + this.lightPos[i] = new Float32Array(3); + this.lightPosId[i] = scope.resolve(light + "_position"); + this.lightWidth[i] = new Float32Array(3); + this.lightWidthId[i] = scope.resolve(light + "_halfWidth"); + this.lightHeight[i] = new Float32Array(3); + this.lightHeightId[i] = scope.resolve(light + "_halfHeight"); + this.lightInAngleId[i] = scope.resolve(light + "_innerConeAngle"); + this.lightOutAngleId[i] = scope.resolve(light + "_outerConeAngle"); + this.lightCookieId[i] = scope.resolve(light + "_cookie"); + this.lightCookieIntId[i] = scope.resolve(light + "_cookieIntensity"); + this.lightCookieMatrixId[i] = scope.resolve(light + "_cookieMatrix"); + this.lightCookieOffsetId[i] = scope.resolve(light + "_cookieOffset"); + this.lightCameraParamsId[i] = scope.resolve(light + "_cameraParams"); + this.shadowMatrixPaletteId[i] = scope.resolve(light + "_shadowMatrixPalette[0]"); + this.shadowCascadeDistancesId[i] = scope.resolve(light + "_shadowCascadeDistances[0]"); + this.shadowCascadeCountId[i] = scope.resolve(light + "_shadowCascadeCount"); + } + setLTCDirectionalLight(wtm, cnt, dir, campos, far) { + this.lightPos[cnt][0] = campos.x - dir.x * far; + this.lightPos[cnt][1] = campos.y - dir.y * far; + this.lightPos[cnt][2] = campos.z - dir.z * far; + this.lightPosId[cnt].setValue(this.lightPos[cnt]); + const hWidth = wtm.transformVector(new Vec3(-0.5, 0, 0)); + this.lightWidth[cnt][0] = hWidth.x * far; + this.lightWidth[cnt][1] = hWidth.y * far; + this.lightWidth[cnt][2] = hWidth.z * far; + this.lightWidthId[cnt].setValue(this.lightWidth[cnt]); + const hHeight = wtm.transformVector(new Vec3(0, 0, 0.5)); + this.lightHeight[cnt][0] = hHeight.x * far; + this.lightHeight[cnt][1] = hHeight.y * far; + this.lightHeight[cnt][2] = hHeight.z * far; + this.lightHeightId[cnt].setValue(this.lightHeight[cnt]); + } + dispatchDirectLights(dirs, scene2, mask, camera) { + let cnt = 0; + const scope = this.device.scope; + for (let i = 0; i < dirs.length; i++) { + if (!(dirs[i].mask & mask)) continue; + const directional = dirs[i]; + const wtm = directional._node.getWorldTransform(); + if (!this.lightColorId[cnt]) { + this._resolveLight(scope, cnt); + } + this.lightColorId[cnt].setValue(scene2.gammaCorrection ? directional._linearFinalColor : directional._finalColor); + wtm.getY(directional._direction).mulScalar(-1); + directional._direction.normalize(); + this.lightDir[cnt][0] = directional._direction.x; + this.lightDir[cnt][1] = directional._direction.y; + this.lightDir[cnt][2] = directional._direction.z; + this.lightDirId[cnt].setValue(this.lightDir[cnt]); + if (directional.shape !== LIGHTSHAPE_PUNCTUAL) { + this.setLTCDirectionalLight(wtm, cnt, directional._direction, camera._node.getPosition(), camera.farClip); + } + if (directional.castShadows) { + const lightRenderData = directional.getRenderData(camera, 0); + const biases = directional._getUniformBiasValues(lightRenderData); + this.lightShadowMapId[cnt].setValue(lightRenderData.shadowBuffer); + this.lightShadowMatrixId[cnt].setValue(lightRenderData.shadowMatrix.data); + this.shadowMatrixPaletteId[cnt].setValue(directional._shadowMatrixPalette); + this.shadowCascadeDistancesId[cnt].setValue(directional._shadowCascadeDistances); + this.shadowCascadeCountId[cnt].setValue(directional.numCascades); + this.lightShadowIntensity[cnt].setValue(directional.shadowIntensity); + const projectionCompensation = 50 / lightRenderData.projectionCompensation; + const pixelsPerMeter = directional.penumbraSize / lightRenderData.shadowCamera.renderTarget.width; + this.lightShadowSearchAreaId[cnt].setValue(pixelsPerMeter * projectionCompensation); + const cameraParams = directional._shadowCameraParams; + cameraParams.length = 4; + cameraParams[0] = lightRenderData.depthRangeCompensation; + cameraParams[1] = lightRenderData.shadowCamera._farClip; + cameraParams[2] = lightRenderData.shadowCamera._nearClip; + cameraParams[3] = 1; + this.lightCameraParamsId[cnt].setValue(cameraParams); + const params = directional._shadowRenderParams; + params.length = 4; + params[0] = directional._shadowResolution; + params[1] = biases.normalBias; + params[2] = biases.bias; + params[3] = 0; + this.lightShadowParamsId[cnt].setValue(params); + } + cnt++; + } + return cnt; + } + setLTCPositionalLight(wtm, cnt) { + const hWidth = wtm.transformVector(new Vec3(-0.5, 0, 0)); + this.lightWidth[cnt][0] = hWidth.x; + this.lightWidth[cnt][1] = hWidth.y; + this.lightWidth[cnt][2] = hWidth.z; + this.lightWidthId[cnt].setValue(this.lightWidth[cnt]); + const hHeight = wtm.transformVector(new Vec3(0, 0, 0.5)); + this.lightHeight[cnt][0] = hHeight.x; + this.lightHeight[cnt][1] = hHeight.y; + this.lightHeight[cnt][2] = hHeight.z; + this.lightHeightId[cnt].setValue(this.lightHeight[cnt]); + } + dispatchOmniLight(scene2, scope, omni, cnt) { + const wtm = omni._node.getWorldTransform(); + if (!this.lightColorId[cnt]) { + this._resolveLight(scope, cnt); + } + this.lightRadiusId[cnt].setValue(omni.attenuationEnd); + this.lightColorId[cnt].setValue(scene2.gammaCorrection ? omni._linearFinalColor : omni._finalColor); + wtm.getTranslation(omni._position); + this.lightPos[cnt][0] = omni._position.x; + this.lightPos[cnt][1] = omni._position.y; + this.lightPos[cnt][2] = omni._position.z; + this.lightPosId[cnt].setValue(this.lightPos[cnt]); + if (omni.shape !== LIGHTSHAPE_PUNCTUAL) { + this.setLTCPositionalLight(wtm, cnt); + } + if (omni.castShadows) { + const lightRenderData = omni.getRenderData(null, 0); + this.lightShadowMapId[cnt].setValue(lightRenderData.shadowBuffer); + const biases = omni._getUniformBiasValues(lightRenderData); + const params = omni._shadowRenderParams; + params.length = 4; + params[0] = omni._shadowResolution; + params[1] = biases.normalBias; + params[2] = biases.bias; + params[3] = 1 / omni.attenuationEnd; + this.lightShadowParamsId[cnt].setValue(params); + this.lightShadowIntensity[cnt].setValue(omni.shadowIntensity); + const pixelsPerMeter = omni.penumbraSize / lightRenderData.shadowCamera.renderTarget.width; + this.lightShadowSearchAreaId[cnt].setValue(pixelsPerMeter); + const cameraParams = omni._shadowCameraParams; + cameraParams.length = 4; + cameraParams[0] = lightRenderData.depthRangeCompensation; + cameraParams[1] = lightRenderData.shadowCamera._farClip; + cameraParams[2] = lightRenderData.shadowCamera._nearClip; + cameraParams[3] = 0; + this.lightCameraParamsId[cnt].setValue(cameraParams); + } + if (omni._cookie) { + this.lightCookieId[cnt].setValue(omni._cookie); + this.lightShadowMatrixId[cnt].setValue(wtm.data); + this.lightCookieIntId[cnt].setValue(omni.cookieIntensity); + } + } + dispatchSpotLight(scene2, scope, spot, cnt) { + const wtm = spot._node.getWorldTransform(); + if (!this.lightColorId[cnt]) { + this._resolveLight(scope, cnt); + } + this.lightInAngleId[cnt].setValue(spot._innerConeAngleCos); + this.lightOutAngleId[cnt].setValue(spot._outerConeAngleCos); + this.lightRadiusId[cnt].setValue(spot.attenuationEnd); + this.lightColorId[cnt].setValue(scene2.gammaCorrection ? spot._linearFinalColor : spot._finalColor); + wtm.getTranslation(spot._position); + this.lightPos[cnt][0] = spot._position.x; + this.lightPos[cnt][1] = spot._position.y; + this.lightPos[cnt][2] = spot._position.z; + this.lightPosId[cnt].setValue(this.lightPos[cnt]); + if (spot.shape !== LIGHTSHAPE_PUNCTUAL) { + this.setLTCPositionalLight(wtm, cnt); + } + wtm.getY(spot._direction).mulScalar(-1); + spot._direction.normalize(); + this.lightDir[cnt][0] = spot._direction.x; + this.lightDir[cnt][1] = spot._direction.y; + this.lightDir[cnt][2] = spot._direction.z; + this.lightDirId[cnt].setValue(this.lightDir[cnt]); + if (spot.castShadows) { + const lightRenderData = spot.getRenderData(null, 0); + this.lightShadowMapId[cnt].setValue(lightRenderData.shadowBuffer); + this.lightShadowMatrixId[cnt].setValue(lightRenderData.shadowMatrix.data); + const biases = spot._getUniformBiasValues(lightRenderData); + const params = spot._shadowRenderParams; + params.length = 4; + params[0] = spot._shadowResolution; + params[1] = biases.normalBias; + params[2] = biases.bias; + params[3] = 1 / spot.attenuationEnd; + this.lightShadowParamsId[cnt].setValue(params); + this.lightShadowIntensity[cnt].setValue(spot.shadowIntensity); + const pixelsPerMeter = spot.penumbraSize / lightRenderData.shadowCamera.renderTarget.width; + const fov = lightRenderData.shadowCamera._fov * Math.PI / 180; + const fovRatio = 1 / Math.tan(fov / 2); + this.lightShadowSearchAreaId[cnt].setValue(pixelsPerMeter * fovRatio); + const cameraParams = spot._shadowCameraParams; + cameraParams.length = 4; + cameraParams[0] = lightRenderData.depthRangeCompensation; + cameraParams[1] = lightRenderData.shadowCamera._farClip; + cameraParams[2] = lightRenderData.shadowCamera._nearClip; + cameraParams[3] = 0; + this.lightCameraParamsId[cnt].setValue(cameraParams); + } + if (spot._cookie) { + if (!spot.castShadows) { + const cookieMatrix = LightCamera.evalSpotCookieMatrix(spot); + this.lightShadowMatrixId[cnt].setValue(cookieMatrix.data); + } + this.lightCookieId[cnt].setValue(spot._cookie); + this.lightCookieIntId[cnt].setValue(spot.cookieIntensity); + if (spot._cookieTransform) { + spot._cookieTransformUniform[0] = spot._cookieTransform.x; + spot._cookieTransformUniform[1] = spot._cookieTransform.y; + spot._cookieTransformUniform[2] = spot._cookieTransform.z; + spot._cookieTransformUniform[3] = spot._cookieTransform.w; + this.lightCookieMatrixId[cnt].setValue(spot._cookieTransformUniform); + spot._cookieOffsetUniform[0] = spot._cookieOffset.x; + spot._cookieOffsetUniform[1] = spot._cookieOffset.y; + this.lightCookieOffsetId[cnt].setValue(spot._cookieOffsetUniform); + } + } + } + dispatchLocalLights(sortedLights, scene2, mask, usedDirLights) { + let cnt = usedDirLights; + const scope = this.device.scope; + const omnis = sortedLights[LIGHTTYPE_OMNI]; + const numOmnis = omnis.length; + for (let i = 0; i < numOmnis; i++) { + const omni = omnis[i]; + if (!(omni.mask & mask)) continue; + this.dispatchOmniLight(scene2, scope, omni, cnt); + cnt++; + } + const spts = sortedLights[LIGHTTYPE_SPOT]; + const numSpts = spts.length; + for (let i = 0; i < numSpts; i++) { + const spot = spts[i]; + if (!(spot.mask & mask)) continue; + this.dispatchSpotLight(scene2, scope, spot, cnt); + cnt++; + } + } + renderForwardPrepareMaterials(camera, drawCalls, sortedLights, layer, pass) { + var _layer$getLightHash; + const addCall = (drawCall, shaderInstance, isNewMaterial, lightMaskChanged) => { + _drawCallList.drawCalls.push(drawCall); + _drawCallList.shaderInstances.push(shaderInstance); + _drawCallList.isNewMaterial.push(isNewMaterial); + _drawCallList.lightMaskChanged.push(lightMaskChanged); + }; + _drawCallList.clear(); + const device = this.device; + const scene2 = this.scene; + const clusteredLightingEnabled = scene2.clusteredLightingEnabled; + const lightHash = (_layer$getLightHash = layer == null ? void 0 : layer.getLightHash(clusteredLightingEnabled)) != null ? _layer$getLightHash : 0; + let prevMaterial = null, prevObjDefs, prevLightMask; + const drawCallsCount = drawCalls.length; + for (let i = 0; i < drawCallsCount; i++) { + const drawCall = drawCalls[i]; + drawCall.ensureMaterial(device); + const material = drawCall.material; + const objDefs = drawCall._shaderDefs; + const lightMask = drawCall.mask; + if (material && material === prevMaterial && objDefs !== prevObjDefs) { + prevMaterial = null; + } + if (material !== prevMaterial) { + this._materialSwitches++; + material._scene = scene2; + if (material.dirty) { + material.updateUniforms(device, scene2); + material.dirty = false; + } + } + const shaderInstance = drawCall.getShaderInstance(pass, lightHash, scene2, this.viewUniformFormat, this.viewBindGroupFormat, sortedLights); + addCall(drawCall, shaderInstance, material !== prevMaterial, !prevMaterial || lightMask !== prevLightMask); + prevMaterial = material; + prevObjDefs = objDefs; + prevLightMask = lightMask; + } + return _drawCallList; + } + renderForwardInternal(camera, preparedCalls, sortedLights, pass, drawCallback, flipFaces) { + const device = this.device; + const scene2 = this.scene; + const passFlag = 1 << pass; + const flipFactor = flipFaces ? -1 : 1; + const clusteredLightingEnabled = this.scene.clusteredLightingEnabled; + const preparedCallsCount = preparedCalls.drawCalls.length; + for (let i = 0; i < preparedCallsCount; i++) { + var _drawCall$stencilFron, _drawCall$stencilBack; + const drawCall = preparedCalls.drawCalls[i]; + const newMaterial = preparedCalls.isNewMaterial[i]; + const lightMaskChanged = preparedCalls.lightMaskChanged[i]; + const shaderInstance = preparedCalls.shaderInstances[i]; + const material = drawCall.material; + const lightMask = drawCall.mask; + if (newMaterial) { + const asyncCompile = false; + device.setShader(shaderInstance.shader, asyncCompile); + material.setParameters(device); + if (lightMaskChanged) { + const usedDirLights = this.dispatchDirectLights(sortedLights[LIGHTTYPE_DIRECTIONAL], scene2, lightMask, camera); + if (!clusteredLightingEnabled) { + this.dispatchLocalLights(sortedLights, scene2, lightMask, usedDirLights); + } + } + this.alphaTestId.setValue(material.alphaTest); + device.setBlendState(material.blendState); + device.setDepthState(material.depthState); + device.setAlphaToCoverage(material.alphaToCoverage); + } + this.setupCullMode(camera._cullFaces, flipFactor, drawCall); + const stencilFront = (_drawCall$stencilFron = drawCall.stencilFront) != null ? _drawCall$stencilFron : material.stencilFront; + const stencilBack = (_drawCall$stencilBack = drawCall.stencilBack) != null ? _drawCall$stencilBack : material.stencilBack; + device.setStencilState(stencilFront, stencilBack); + const mesh = drawCall.mesh; + drawCall.setParameters(device, passFlag); + this.setVertexBuffers(device, mesh); + this.setMorphing(device, drawCall.morphInstance); + this.setSkinning(device, drawCall); + this.setupMeshUniformBuffers(shaderInstance, drawCall); + const style = drawCall.renderStyle; + device.setIndexBuffer(mesh.indexBuffer[style]); + drawCallback == null || drawCallback(drawCall, i); + if (camera.xr && camera.xr.session && camera.xr.views.list.length) { + const views = camera.xr.views; + for (let v = 0; v < views.list.length; v++) { + const view = views.list[v]; + device.setViewport(view.viewport.x, view.viewport.y, view.viewport.z, view.viewport.w); + this.projId.setValue(view.projMat.data); + this.projSkyboxId.setValue(view.projMat.data); + this.viewId.setValue(view.viewOffMat.data); + this.viewInvId.setValue(view.viewInvOffMat.data); + this.viewId3.setValue(view.viewMat3.data); + this.viewProjId.setValue(view.projViewOffMat.data); + this.viewPosId.setValue(view.positionData); + this.viewIndexId.setValue(v); + if (v === 0) { + this.drawInstance(device, drawCall, mesh, style, true); + } else { + this.drawInstance2(device, drawCall, mesh, style); + } + this._forwardDrawCalls++; + } + } else { + this.drawInstance(device, drawCall, mesh, style, true); + this._forwardDrawCalls++; + } + if (i < preparedCallsCount - 1 && !preparedCalls.isNewMaterial[i + 1]) { + material.setParameters(device, drawCall.parameters); + } + } + } + renderForward(camera, allDrawCalls, sortedLights, pass, drawCallback, layer, flipFaces) { + const preparedCalls = this.renderForwardPrepareMaterials(camera, allDrawCalls, sortedLights, layer, pass); + this.renderForwardInternal(camera, preparedCalls, sortedLights, pass, drawCallback, flipFaces); + _drawCallList.clear(); + } + renderForwardLayer(camera, renderTarget, layer, transparent, shaderPass, viewBindGroups, options = {}) { + var _options$clearColor, _options$clearDepth, _options$clearStencil; + const { + scene: scene2, + device + } = this; + const clusteredLightingEnabled = scene2.clusteredLightingEnabled; + this.setupViewport(camera, renderTarget); + const clearColor = (_options$clearColor = options.clearColor) != null ? _options$clearColor : false; + const clearDepth = (_options$clearDepth = options.clearDepth) != null ? _options$clearDepth : false; + const clearStencil = (_options$clearStencil = options.clearStencil) != null ? _options$clearStencil : false; + if (clearColor || clearDepth || clearStencil) { + this.clear(camera, clearColor, clearDepth, clearStencil); + } + let visible, splitLights; + if (layer) { + layer.sortVisible(camera, transparent); + const culledInstances = layer.getCulledInstances(camera); + visible = transparent ? culledInstances.transparent : culledInstances.opaque; + scene2.immediate.onPreRenderLayer(layer, visible, transparent); + if (layer.requiresLightCube) { + this.lightCube.update(scene2.ambientLight, layer._lights); + this.constantLightCube.setValue(this.lightCube.colors); + } + splitLights = layer.splitLights; + } else { + var _options$splitLights; + visible = options.meshInstances; + splitLights = (_options$splitLights = options.splitLights) != null ? _options$splitLights : _noLights; + } + if (clusteredLightingEnabled) { + var _options$lightCluster; + const lightClusters = (_options$lightCluster = options.lightClusters) != null ? _options$lightCluster : this.worldClustersAllocator.empty; + lightClusters.activate(); + if (layer) { + if (!this.clustersDebugRendered && scene2.lighting.debugLayer === layer.id) { + this.clustersDebugRendered = true; + } + } + } + scene2._activeCamera = camera; + const viewCount = this.setCameraUniforms(camera, renderTarget); + if (device.supportsUniformBuffers) { + this.setupViewUniformBuffers(viewBindGroups, this.viewUniformFormat, this.viewBindGroupFormat, viewCount); + } + const flipFaces = !!(camera._flipFaces ^ (renderTarget == null ? void 0 : renderTarget.flipY)); + const forwardDrawCalls = this._forwardDrawCalls; + this.renderForward(camera, visible, splitLights, shaderPass, layer == null ? void 0 : layer.onDrawCall, layer, flipFaces); + if (layer) layer._forwardDrawCalls += this._forwardDrawCalls - forwardDrawCalls; + } + setSceneConstants() { + const scene2 = this.scene; + this.dispatchGlobalLights(scene2); + if (scene2.fog !== FOG_NONE) { + this.fogColor[0] = scene2.fogColor.r; + this.fogColor[1] = scene2.fogColor.g; + this.fogColor[2] = scene2.fogColor.b; + if (scene2.gammaCorrection) { + for (let i = 0; i < 3; i++) { + this.fogColor[i] = Math.pow(this.fogColor[i], 2.2); + } + } + this.fogColorId.setValue(this.fogColor); + if (scene2.fog === FOG_LINEAR) { + this.fogStartId.setValue(scene2.fogStart); + this.fogEndId.setValue(scene2.fogEnd); + } else { + this.fogDensityId.setValue(scene2.fogDensity); + } + } + const device = this.device; + this._screenSize[0] = device.width; + this._screenSize[1] = device.height; + this._screenSize[2] = 1 / device.width; + this._screenSize[3] = 1 / device.height; + this.screenSizeId.setValue(this._screenSize); + this.pcssDiskSamplesId.setValue(this.pcssDiskSamples); + this.pcssSphereSamplesId.setValue(this.pcssSphereSamples); + } + buildFrameGraph(frameGraph, layerComposition) { + const scene2 = this.scene; + const webgl1 = this.device.isWebGL1; + frameGraph.reset(); + this.update(layerComposition); + if (scene2.clusteredLightingEnabled) { + const { + shadowsEnabled, + cookiesEnabled + } = scene2.lighting; + this._renderPassUpdateClustered.update(frameGraph, shadowsEnabled, cookiesEnabled, this.lights, this.localLights); + frameGraph.addRenderPass(this._renderPassUpdateClustered); + } else { + this._shadowRendererLocal.buildNonClusteredRenderPasses(frameGraph, this.localLights); + } + let startIndex = 0; + let newStart = true; + let renderTarget = null; + const renderActions = layerComposition._renderActions; + for (let i = startIndex; i < renderActions.length; i++) { + const renderAction = renderActions[i]; + const { + layer, + camera + } = renderAction; + if (renderAction.useCameraPasses) { + camera.camera.renderPasses.forEach((renderPass) => { + frameGraph.addRenderPass(renderPass); + }); + } else { + const depthPass = camera.camera.renderPassDepthGrab; + if (depthPass && webgl1 && renderAction.firstCameraUse) { + depthPass.options.resizeSource = camera.camera.renderTarget; + depthPass.update(this.scene); + frameGraph.addRenderPass(depthPass); + } + const isDepthLayer = layer.id === LAYERID_DEPTH; + if (webgl1 && isDepthLayer && !camera.renderSceneColorMap) continue; + const isGrabPass = isDepthLayer && (camera.renderSceneColorMap || camera.renderSceneDepthMap); + if (newStart) { + newStart = false; + startIndex = i; + renderTarget = renderAction.renderTarget; + } + const nextRenderAction = renderActions[i + 1]; + const isNextLayerDepth = nextRenderAction ? nextRenderAction.layer.id === LAYERID_DEPTH : false; + const isNextLayerGrabPass = isNextLayerDepth && (camera.renderSceneColorMap || camera.renderSceneDepthMap) && !webgl1; + const nextNeedDirShadows = nextRenderAction ? nextRenderAction.firstCameraUse && this.cameraDirShadowLights.has(nextRenderAction.camera.camera) : false; + if (!nextRenderAction || nextRenderAction.renderTarget !== renderTarget || nextNeedDirShadows || isNextLayerGrabPass || isGrabPass) { + const isDepthOnly = isDepthLayer && startIndex === i; + if (!isDepthOnly) { + this.addMainRenderPass(frameGraph, layerComposition, renderTarget, startIndex, i); + } + if (isDepthLayer) { + if (camera.renderSceneColorMap) { + const colorGrabPass = camera.camera.renderPassColorGrab; + colorGrabPass.source = camera.renderTarget; + frameGraph.addRenderPass(colorGrabPass); + } + if (camera.renderSceneDepthMap && !webgl1) { + frameGraph.addRenderPass(camera.camera.renderPassDepthGrab); + } + } + if (renderAction.triggerPostprocess && camera != null && camera.onPostprocessing) { + const renderPass = new RenderPassPostprocessing(this.device, this, renderAction); + frameGraph.addRenderPass(renderPass); + } + newStart = true; + } + } + } + } + addMainRenderPass(frameGraph, layerComposition, renderTarget, startIndex, endIndex) { + const renderPass = new RenderPassForward(this.device, layerComposition, this.scene, this); + renderPass.init(renderTarget); + const renderActions = layerComposition._renderActions; + for (let i = startIndex; i <= endIndex; i++) { + renderPass.addRenderAction(renderActions[i]); + } + frameGraph.addRenderPass(renderPass); + } + update(comp) { + this.frameUpdate(); + this.shadowRenderer.frameUpdate(); + this.scene._updateSkyMesh(); + this.updateLayerComposition(comp); + this.collectLights(comp); + this.beginFrame(comp); + this.setSceneConstants(); + this.cullComposition(comp); + this.gpuUpdate(this.processingMeshInstances); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/layer.js +function sortManual(drawCallA, drawCallB) { + return drawCallA.drawOrder - drawCallB.drawOrder; +} +function sortMaterialMesh(drawCallA, drawCallB) { + const keyA = drawCallA._key[SORTKEY_FORWARD]; + const keyB = drawCallB._key[SORTKEY_FORWARD]; + if (keyA === keyB && drawCallA.mesh && drawCallB.mesh) { + return drawCallB.mesh.id - drawCallA.mesh.id; + } + return keyB - keyA; +} +function sortBackToFront(drawCallA, drawCallB) { + return drawCallB.zdist - drawCallA.zdist; +} +function sortFrontToBack(drawCallA, drawCallB) { + return drawCallA.zdist - drawCallB.zdist; +} +var sortCallbacks = [null, sortManual, sortMaterialMesh, sortBackToFront, sortFrontToBack]; +var layerCounter = 0; +var lightKeys = []; +var _tempMaterials = /* @__PURE__ */ new Set(); +var CulledInstances = class { + constructor() { + this.opaque = []; + this.transparent = []; + } +}; +var Layer = class { + constructor(options = {}) { + var _options$enabled, _options$opaqueSortMo, _options$transparentS, _options$shaderPass; + this.meshInstances = []; + this.meshInstancesSet = /* @__PURE__ */ new Set(); + this.shadowCasters = []; + this.shadowCastersSet = /* @__PURE__ */ new Set(); + this._visibleInstances = /* @__PURE__ */ new WeakMap(); + this._lights = []; + this._lightsSet = /* @__PURE__ */ new Set(); + this._clusteredLightsSet = /* @__PURE__ */ new Set(); + this._splitLights = [[], [], []]; + this._splitLightsDirty = true; + this.requiresLightCube = false; + this.cameras = []; + this.camerasSet = /* @__PURE__ */ new Set(); + this._dirtyComposition = false; + if (options.id !== void 0) { + this.id = options.id; + layerCounter = Math.max(this.id + 1, layerCounter); + } else { + this.id = layerCounter++; + } + this.name = options.name; + this._enabled = (_options$enabled = options.enabled) != null ? _options$enabled : true; + this._refCounter = this._enabled ? 1 : 0; + this.opaqueSortMode = (_options$opaqueSortMo = options.opaqueSortMode) != null ? _options$opaqueSortMo : SORTMODE_MATERIALMESH; + this.transparentSortMode = (_options$transparentS = options.transparentSortMode) != null ? _options$transparentS : SORTMODE_BACK2FRONT; + if (options.renderTarget) { + this.renderTarget = options.renderTarget; + } + this.shaderPass = (_options$shaderPass = options.shaderPass) != null ? _options$shaderPass : SHADER_FORWARD; + this._clearColorBuffer = !!options.clearColorBuffer; + this._clearDepthBuffer = !!options.clearDepthBuffer; + this._clearStencilBuffer = !!options.clearStencilBuffer; + this.onPreCull = options.onPreCull; + this.onPreRender = options.onPreRender; + this.onPreRenderOpaque = options.onPreRenderOpaque; + this.onPreRenderTransparent = options.onPreRenderTransparent; + this.onPostCull = options.onPostCull; + this.onPostRender = options.onPostRender; + this.onPostRenderOpaque = options.onPostRenderOpaque; + this.onPostRenderTransparent = options.onPostRenderTransparent; + this.onDrawCall = options.onDrawCall; + this.onEnable = options.onEnable; + this.onDisable = options.onDisable; + if (this._enabled && this.onEnable) { + this.onEnable(); + } + this.layerReference = options.layerReference; + this.customSortCallback = null; + this.customCalculateSortValues = null; + this._lightHash = 0; + this._lightHashDirty = false; + this._lightIdHash = 0; + this._lightIdHashDirty = false; + this._shaderVersion = -1; + } + set enabled(val) { + if (val !== this._enabled) { + this._dirtyComposition = true; + this._enabled = val; + if (val) { + this.incrementCounter(); + if (this.onEnable) this.onEnable(); + } else { + this.decrementCounter(); + if (this.onDisable) this.onDisable(); + } + } + } + get enabled() { + return this._enabled; + } + set clearColorBuffer(val) { + this._clearColorBuffer = val; + this._dirtyComposition = true; + } + get clearColorBuffer() { + return this._clearColorBuffer; + } + set clearDepthBuffer(val) { + this._clearDepthBuffer = val; + this._dirtyComposition = true; + } + get clearDepthBuffer() { + return this._clearDepthBuffer; + } + set clearStencilBuffer(val) { + this._clearStencilBuffer = val; + this._dirtyComposition = true; + } + get clearStencilBuffer() { + return this._clearStencilBuffer; + } + get hasClusteredLights() { + return this._clusteredLightsSet.size > 0; + } + get clusteredLightsSet() { + return this._clusteredLightsSet; + } + incrementCounter() { + if (this._refCounter === 0) { + this._enabled = true; + if (this.onEnable) this.onEnable(); + } + this._refCounter++; + } + decrementCounter() { + if (this._refCounter === 1) { + this._enabled = false; + if (this.onDisable) this.onDisable(); + } else if (this._refCounter === 0) { + return; + } + this._refCounter--; + } + addMeshInstances(meshInstances, skipShadowCasters) { + const destMeshInstances = this.meshInstances; + const destMeshInstancesSet = this.meshInstancesSet; + for (let i = 0; i < meshInstances.length; i++) { + const mi = meshInstances[i]; + if (!destMeshInstancesSet.has(mi)) { + destMeshInstances.push(mi); + destMeshInstancesSet.add(mi); + _tempMaterials.add(mi.material); + } + } + if (!skipShadowCasters) { + this.addShadowCasters(meshInstances); + } + if (_tempMaterials.size > 0) { + const sceneShaderVer = this._shaderVersion; + _tempMaterials.forEach((mat) => { + if (sceneShaderVer >= 0 && mat._shaderVersion !== sceneShaderVer) { + if (mat.getShaderVariant !== Material.prototype.getShaderVariant) { + mat.clearVariants(); + } + mat._shaderVersion = sceneShaderVer; + } + }); + _tempMaterials.clear(); + } + } + removeMeshInstances(meshInstances, skipShadowCasters) { + const destMeshInstances = this.meshInstances; + const destMeshInstancesSet = this.meshInstancesSet; + for (let i = 0; i < meshInstances.length; i++) { + const mi = meshInstances[i]; + if (destMeshInstancesSet.has(mi)) { + destMeshInstancesSet.delete(mi); + const j = destMeshInstances.indexOf(mi); + if (j >= 0) { + destMeshInstances.splice(j, 1); + } + } + } + if (!skipShadowCasters) { + this.removeShadowCasters(meshInstances); + } + } + addShadowCasters(meshInstances) { + const shadowCasters = this.shadowCasters; + const shadowCastersSet = this.shadowCastersSet; + for (let i = 0; i < meshInstances.length; i++) { + const mi = meshInstances[i]; + if (mi.castShadow && !shadowCastersSet.has(mi)) { + shadowCastersSet.add(mi); + shadowCasters.push(mi); + } + } + } + removeShadowCasters(meshInstances) { + const shadowCasters = this.shadowCasters; + const shadowCastersSet = this.shadowCastersSet; + for (let i = 0; i < meshInstances.length; i++) { + const mi = meshInstances[i]; + if (shadowCastersSet.has(mi)) { + shadowCastersSet.delete(mi); + const j = shadowCasters.indexOf(mi); + if (j >= 0) { + shadowCasters.splice(j, 1); + } + } + } + } + clearMeshInstances(skipShadowCasters = false) { + this.meshInstances.length = 0; + this.meshInstancesSet.clear(); + if (!skipShadowCasters) { + this.shadowCasters.length = 0; + this.shadowCastersSet.clear(); + } + } + markLightsDirty() { + this._lightHashDirty = true; + this._lightIdHashDirty = true; + this._splitLightsDirty = true; + } + addLight(light) { + const l = light.light; + if (!this._lightsSet.has(l)) { + this._lightsSet.add(l); + this._lights.push(l); + this.markLightsDirty(); + } + if (l.type !== LIGHTTYPE_DIRECTIONAL) { + this._clusteredLightsSet.add(l); + } + } + removeLight(light) { + const l = light.light; + if (this._lightsSet.has(l)) { + this._lightsSet.delete(l); + this._lights.splice(this._lights.indexOf(l), 1); + this.markLightsDirty(); + } + if (l.type !== LIGHTTYPE_DIRECTIONAL) { + this._clusteredLightsSet.delete(l); + } + } + clearLights() { + this._lightsSet.forEach((light) => light.removeLayer(this)); + this._lightsSet.clear(); + this._clusteredLightsSet.clear(); + this._lights.length = 0; + this.markLightsDirty(); + } + get splitLights() { + if (this._splitLightsDirty) { + this._splitLightsDirty = false; + const splitLights = this._splitLights; + for (let i = 0; i < splitLights.length; i++) splitLights[i].length = 0; + const lights2 = this._lights; + for (let i = 0; i < lights2.length; i++) { + const light = lights2[i]; + if (light.enabled) { + splitLights[light._type].push(light); + } + } + for (let i = 0; i < splitLights.length; i++) splitLights[i].sort((a, b) => a.key - b.key); + } + return this._splitLights; + } + evaluateLightHash(localLights, directionalLights, useIds) { + let hash = 0; + const lights2 = this._lights; + for (let i = 0; i < lights2.length; i++) { + const isLocalLight = lights2[i].type !== LIGHTTYPE_DIRECTIONAL; + if (localLights && isLocalLight || directionalLights && !isLocalLight) { + lightKeys.push(useIds ? lights2[i].id : lights2[i].key); + } + } + if (lightKeys.length > 0) { + lightKeys.sort(); + hash = hash32Fnv1a(lightKeys); + lightKeys.length = 0; + } + return hash; + } + getLightHash(isClustered) { + if (this._lightHashDirty) { + this._lightHashDirty = false; + this._lightHash = this.evaluateLightHash(!isClustered, true, false); + } + return this._lightHash; + } + getLightIdHash() { + if (this._lightIdHashDirty) { + this._lightIdHashDirty = false; + this._lightIdHash = this.evaluateLightHash(true, false, true); + } + return this._lightIdHash; + } + addCamera(camera) { + if (!this.camerasSet.has(camera.camera)) { + this.camerasSet.add(camera.camera); + this.cameras.push(camera); + this._dirtyComposition = true; + } + } + removeCamera(camera) { + if (this.camerasSet.has(camera.camera)) { + this.camerasSet.delete(camera.camera); + const index = this.cameras.indexOf(camera); + this.cameras.splice(index, 1); + this._dirtyComposition = true; + } + } + clearCameras() { + this.cameras.length = 0; + this.camerasSet.clear(); + this._dirtyComposition = true; + } + _calculateSortDistances(drawCalls, drawCallsCount, camPos, camFwd) { + for (let i = 0; i < drawCallsCount; i++) { + const drawCall = drawCalls[i]; + if (drawCall.layer <= LAYER_FX) continue; + if (drawCall.calculateSortDistance) { + drawCall.zdist = drawCall.calculateSortDistance(drawCall, camPos, camFwd); + continue; + } + const meshPos = drawCall.aabb.center; + const tempx = meshPos.x - camPos.x; + const tempy = meshPos.y - camPos.y; + const tempz = meshPos.z - camPos.z; + drawCall.zdist = tempx * camFwd.x + tempy * camFwd.y + tempz * camFwd.z; + } + } + getCulledInstances(camera) { + let instances = this._visibleInstances.get(camera); + if (!instances) { + instances = new CulledInstances(); + this._visibleInstances.set(camera, instances); + } + return instances; + } + sortVisible(camera, transparent) { + const sortMode = transparent ? this.transparentSortMode : this.opaqueSortMode; + if (sortMode === SORTMODE_NONE) return; + const culledInstances = this.getCulledInstances(camera); + const instances = transparent ? culledInstances.transparent : culledInstances.opaque; + const cameraNode = camera.node; + if (sortMode === SORTMODE_CUSTOM) { + const sortPos = cameraNode.getPosition(); + const sortDir = cameraNode.forward; + if (this.customCalculateSortValues) { + this.customCalculateSortValues(instances, instances.length, sortPos, sortDir); + } + if (this.customSortCallback) { + instances.sort(this.customSortCallback); + } + } else { + if (sortMode === SORTMODE_BACK2FRONT || sortMode === SORTMODE_FRONT2BACK) { + const sortPos = cameraNode.getPosition(); + const sortDir = cameraNode.forward; + this._calculateSortDistances(instances, instances.length, sortPos, sortDir); + } + instances.sort(sortCallbacks[sortMode]); + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/core/sort.js +var cmpPriority = (a, b) => a.priority - b.priority; +var sortPriority = (arr) => arr.sort(cmpPriority); + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/composition/layer-composition.js +var LayerComposition = class extends EventHandler { + constructor(name = "Untitled") { + super(); + this.layerList = []; + this.layerIdMap = /* @__PURE__ */ new Map(); + this.layerNameMap = /* @__PURE__ */ new Map(); + this.layerOpaqueIndexMap = /* @__PURE__ */ new Map(); + this.layerTransparentIndexMap = /* @__PURE__ */ new Map(); + this.subLayerList = []; + this.subLayerEnabled = []; + this.cameras = []; + this.camerasMap = /* @__PURE__ */ new Map(); + this._renderActions = []; + this._dirty = false; + this.name = name; + this._opaqueOrder = {}; + this._transparentOrder = {}; + } + destroy() { + this.destroyRenderActions(); + } + destroyRenderActions() { + this._renderActions.forEach((ra) => ra.destroy()); + this._renderActions.length = 0; + } + _update() { + const len = this.layerList.length; + if (!this._dirty) { + for (let i = 0; i < len; i++) { + if (this.layerList[i]._dirtyComposition) { + this._dirty = true; + break; + } + } + } + if (this._dirty) { + this._dirty = false; + this.cameras.length = 0; + for (let i = 0; i < len; i++) { + const layer = this.layerList[i]; + layer._dirtyComposition = false; + for (let j = 0; j < layer.cameras.length; j++) { + const camera = layer.cameras[j]; + const index = this.cameras.indexOf(camera); + if (index < 0) { + this.cameras.push(camera); + } + } + } + if (this.cameras.length > 1) { + sortPriority(this.cameras); + } + this.camerasMap.clear(); + for (let i = 0; i < this.cameras.length; i++) { + this.camerasMap.set(this.cameras[i], i); + } + let renderActionCount = 0; + this.destroyRenderActions(); + for (let i = 0; i < this.cameras.length; i++) { + const camera = this.cameras[i]; + if (camera.camera.renderPasses.length > 0) { + this.addDummyRenderAction(renderActionCount, camera); + renderActionCount++; + continue; + } + let cameraFirstRenderAction = true; + const cameraFirstRenderActionIndex = renderActionCount; + let lastRenderAction = null; + let postProcessMarked = false; + for (let j = 0; j < len; j++) { + const layer = this.layerList[j]; + const isLayerEnabled = layer.enabled && this.subLayerEnabled[j]; + if (isLayerEnabled) { + if (layer.cameras.length > 0) { + if (camera.layers.indexOf(layer.id) >= 0) { + if (!postProcessMarked && layer.id === camera.disablePostEffectsLayer) { + postProcessMarked = true; + if (lastRenderAction) { + lastRenderAction.triggerPostprocess = true; + } + } + const isTransparent = this.subLayerList[j]; + lastRenderAction = this.addRenderAction(renderActionCount, layer, isTransparent, camera, cameraFirstRenderAction, postProcessMarked); + renderActionCount++; + cameraFirstRenderAction = false; + } + } + } + } + if (cameraFirstRenderActionIndex < renderActionCount) { + lastRenderAction.lastCameraUse = true; + } + if (!postProcessMarked && lastRenderAction) { + lastRenderAction.triggerPostprocess = true; + } + if (camera.renderTarget && camera.postEffectsEnabled) { + this.propagateRenderTarget(cameraFirstRenderActionIndex - 1, camera); + } + } + this._logRenderActions(); + } + } + getNextRenderAction(renderActionIndex) { + const renderAction = new RenderAction(); + this._renderActions.push(renderAction); + return renderAction; + } + addDummyRenderAction(renderActionIndex, camera) { + const renderAction = this.getNextRenderAction(renderActionIndex); + renderAction.camera = camera; + renderAction.useCameraPasses = true; + } + addRenderAction(renderActionIndex, layer, isTransparent, camera, cameraFirstRenderAction, postProcessMarked) { + let rt = layer.renderTarget; + if (camera && camera.renderTarget) { + if (layer.id !== LAYERID_DEPTH) { + rt = camera.renderTarget; + } + } + let used = false; + const renderActions = this._renderActions; + for (let i = renderActionIndex - 1; i >= 0; i--) { + if (renderActions[i].camera === camera && renderActions[i].renderTarget === rt) { + used = true; + break; + } + } + if (postProcessMarked && camera.postEffectsEnabled) { + rt = null; + } + const renderAction = this.getNextRenderAction(renderActionIndex); + renderAction.triggerPostprocess = false; + renderAction.layer = layer; + renderAction.transparent = isTransparent; + renderAction.camera = camera; + renderAction.renderTarget = rt; + renderAction.firstCameraUse = cameraFirstRenderAction; + renderAction.lastCameraUse = false; + const needsCameraClear = cameraFirstRenderAction || !used; + const needsLayerClear = layer.clearColorBuffer || layer.clearDepthBuffer || layer.clearStencilBuffer; + if (needsCameraClear || needsLayerClear) { + renderAction.setupClears(needsCameraClear ? camera : void 0, layer); + } + return renderAction; + } + propagateRenderTarget(startIndex, fromCamera) { + for (let a = startIndex; a >= 0; a--) { + const ra = this._renderActions[a]; + const layer = ra.layer; + if (ra.renderTarget && layer.id !== LAYERID_DEPTH) { + break; + } + if (layer.id === LAYERID_DEPTH) { + continue; + } + if (ra.useCameraPasses) { + break; + } + const thisCamera = ra == null ? void 0 : ra.camera.camera; + if (thisCamera) { + if (!fromCamera.camera.rect.equals(thisCamera.rect) || !fromCamera.camera.scissorRect.equals(thisCamera.scissorRect)) { + break; + } + } + ra.renderTarget = fromCamera.renderTarget; + } + } + _logRenderActions() { + } + _isLayerAdded(layer) { + const found = this.layerIdMap.get(layer.id) === layer; + return found; + } + _isSublayerAdded(layer, transparent) { + const map = transparent ? this.layerTransparentIndexMap : this.layerOpaqueIndexMap; + if (map.get(layer) !== void 0) { + return true; + } + return false; + } + push(layer) { + if (this._isLayerAdded(layer)) return; + this.layerList.push(layer); + this.layerList.push(layer); + this._opaqueOrder[layer.id] = this.subLayerList.push(false) - 1; + this._transparentOrder[layer.id] = this.subLayerList.push(true) - 1; + this.subLayerEnabled.push(true); + this.subLayerEnabled.push(true); + this._updateLayerMaps(); + this._dirty = true; + this.fire("add", layer); + } + insert(layer, index) { + if (this._isLayerAdded(layer)) return; + this.layerList.splice(index, 0, layer, layer); + this.subLayerList.splice(index, 0, false, true); + const count = this.layerList.length; + this._updateOpaqueOrder(index, count - 1); + this._updateTransparentOrder(index, count - 1); + this.subLayerEnabled.splice(index, 0, true, true); + this._updateLayerMaps(); + this._dirty = true; + this.fire("add", layer); + } + remove(layer) { + let id12 = this.layerList.indexOf(layer); + delete this._opaqueOrder[id12]; + delete this._transparentOrder[id12]; + while (id12 >= 0) { + this.layerList.splice(id12, 1); + this.subLayerList.splice(id12, 1); + this.subLayerEnabled.splice(id12, 1); + id12 = this.layerList.indexOf(layer); + this._dirty = true; + this.fire("remove", layer); + } + const count = this.layerList.length; + this._updateOpaqueOrder(0, count - 1); + this._updateTransparentOrder(0, count - 1); + this._updateLayerMaps(); + } + pushOpaque(layer) { + if (this._isSublayerAdded(layer, false)) return; + this.layerList.push(layer); + this._opaqueOrder[layer.id] = this.subLayerList.push(false) - 1; + this.subLayerEnabled.push(true); + this._updateLayerMaps(); + this._dirty = true; + this.fire("add", layer); + } + insertOpaque(layer, index) { + if (this._isSublayerAdded(layer, false)) return; + this.layerList.splice(index, 0, layer); + this.subLayerList.splice(index, 0, false); + const count = this.subLayerList.length; + this._updateOpaqueOrder(index, count - 1); + this.subLayerEnabled.splice(index, 0, true); + this._updateLayerMaps(); + this._dirty = true; + this.fire("add", layer); + } + removeOpaque(layer) { + for (let i = 0, len = this.layerList.length; i < len; i++) { + if (this.layerList[i] === layer && !this.subLayerList[i]) { + this.layerList.splice(i, 1); + this.subLayerList.splice(i, 1); + len--; + this._updateOpaqueOrder(i, len - 1); + this.subLayerEnabled.splice(i, 1); + this._dirty = true; + if (this.layerList.indexOf(layer) < 0) { + this.fire("remove", layer); + } + break; + } + } + this._updateLayerMaps(); + } + pushTransparent(layer) { + if (this._isSublayerAdded(layer, true)) return; + this.layerList.push(layer); + this._transparentOrder[layer.id] = this.subLayerList.push(true) - 1; + this.subLayerEnabled.push(true); + this._updateLayerMaps(); + this._dirty = true; + this.fire("add", layer); + } + insertTransparent(layer, index) { + if (this._isSublayerAdded(layer, true)) return; + this.layerList.splice(index, 0, layer); + this.subLayerList.splice(index, 0, true); + const count = this.subLayerList.length; + this._updateTransparentOrder(index, count - 1); + this.subLayerEnabled.splice(index, 0, true); + this._updateLayerMaps(); + this._dirty = true; + this.fire("add", layer); + } + removeTransparent(layer) { + for (let i = 0, len = this.layerList.length; i < len; i++) { + if (this.layerList[i] === layer && this.subLayerList[i]) { + this.layerList.splice(i, 1); + this.subLayerList.splice(i, 1); + len--; + this._updateTransparentOrder(i, len - 1); + this.subLayerEnabled.splice(i, 1); + this._dirty = true; + if (this.layerList.indexOf(layer) < 0) { + this.fire("remove", layer); + } + break; + } + } + this._updateLayerMaps(); + } + getOpaqueIndex(layer) { + var _this$layerOpaqueInde; + return (_this$layerOpaqueInde = this.layerOpaqueIndexMap.get(layer)) != null ? _this$layerOpaqueInde : -1; + } + getTransparentIndex(layer) { + var _this$layerTransparen; + return (_this$layerTransparen = this.layerTransparentIndexMap.get(layer)) != null ? _this$layerTransparen : -1; + } + isEnabled(layer, transparent) { + const index = transparent ? this.getTransparentIndex(layer) : this.getOpaqueIndex(layer); + return this.subLayerEnabled[index]; + } + _updateLayerMaps() { + this.layerIdMap.clear(); + this.layerNameMap.clear(); + this.layerOpaqueIndexMap.clear(); + this.layerTransparentIndexMap.clear(); + for (let i = 0; i < this.layerList.length; i++) { + const layer = this.layerList[i]; + this.layerIdMap.set(layer.id, layer); + this.layerNameMap.set(layer.name, layer); + const subLayerIndexMap = this.subLayerList[i] ? this.layerTransparentIndexMap : this.layerOpaqueIndexMap; + subLayerIndexMap.set(layer, i); + } + } + getLayerById(id12) { + var _this$layerIdMap$get; + return (_this$layerIdMap$get = this.layerIdMap.get(id12)) != null ? _this$layerIdMap$get : null; + } + getLayerByName(name) { + var _this$layerNameMap$ge; + return (_this$layerNameMap$ge = this.layerNameMap.get(name)) != null ? _this$layerNameMap$ge : null; + } + _updateOpaqueOrder(startIndex, endIndex) { + for (let i = startIndex; i <= endIndex; i++) { + if (this.subLayerList[i] === false) { + this._opaqueOrder[this.layerList[i].id] = i; + } + } + } + _updateTransparentOrder(startIndex, endIndex) { + for (let i = startIndex; i <= endIndex; i++) { + if (this.subLayerList[i] === true) { + this._transparentOrder[this.layerList[i].id] = i; + } + } + } + _sortLayersDescending(layersA, layersB, order) { + let topLayerA = -1; + let topLayerB = -1; + for (let i = 0, len = layersA.length; i < len; i++) { + const id12 = layersA[i]; + if (order.hasOwnProperty(id12)) { + topLayerA = Math.max(topLayerA, order[id12]); + } + } + for (let i = 0, len = layersB.length; i < len; i++) { + const id12 = layersB[i]; + if (order.hasOwnProperty(id12)) { + topLayerB = Math.max(topLayerB, order[id12]); + } + } + if (topLayerA === -1 && topLayerB !== -1) { + return 1; + } else if (topLayerB === -1 && topLayerA !== -1) { + return -1; + } + return topLayerB - topLayerA; + } + sortTransparentLayers(layersA, layersB) { + return this._sortLayersDescending(layersA, layersB, this._transparentOrder); + } + sortOpaqueLayers(layersA, layersB) { + return this._sortLayersDescending(layersA, layersB, this._opaqueOrder); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/light.js +var tmpVec = new Vec3(); +var tmpBiases = { + bias: 0, + normalBias: 0 +}; +var chanId = { + r: 0, + g: 1, + b: 2, + a: 3 +}; +var lightTypes = { + "directional": LIGHTTYPE_DIRECTIONAL, + "omni": LIGHTTYPE_OMNI, + "point": LIGHTTYPE_OMNI, + "spot": LIGHTTYPE_SPOT +}; +var directionalCascades = [[new Vec4(0, 0, 1, 1)], [new Vec4(0, 0, 0.5, 0.5), new Vec4(0, 0.5, 0.5, 0.5)], [new Vec4(0, 0, 0.5, 0.5), new Vec4(0, 0.5, 0.5, 0.5), new Vec4(0.5, 0, 0.5, 0.5)], [new Vec4(0, 0, 0.5, 0.5), new Vec4(0, 0.5, 0.5, 0.5), new Vec4(0.5, 0, 0.5, 0.5), new Vec4(0.5, 0.5, 0.5, 0.5)]]; +var id11 = 0; +var LightRenderData = class { + constructor(device, camera, face, light) { + this.light = light; + this.camera = camera; + this.shadowCamera = ShadowRenderer.createShadowCamera(device, light._shadowType, light._type, face); + this.shadowMatrix = new Mat4(); + this.shadowViewport = new Vec4(0, 0, 1, 1); + this.shadowScissor = new Vec4(0, 0, 1, 1); + this.depthRangeCompensation = 0; + this.projectionCompensation = 0; + this.face = face; + this.visibleCasters = []; + this.viewBindGroups = []; + } + destroy() { + this.viewBindGroups.forEach((bg) => { + bg.defaultUniformBuffer.destroy(); + bg.destroy(); + }); + this.viewBindGroups.length = 0; + } + get shadowBuffer() { + const rt = this.shadowCamera.renderTarget; + if (rt) { + const light = this.light; + if (light._type === LIGHTTYPE_OMNI) { + return rt.colorBuffer; + } + return light._isPcf && light.device.supportsDepthShadow ? rt.depthBuffer : rt.colorBuffer; + } + return null; + } +}; +var Light = class _Light { + constructor(graphicsDevice, clusteredLighting) { + this.layers = /* @__PURE__ */ new Set(); + this.clusteredLighting = void 0; + this.shadowDepthState = DepthState.DEFAULT.clone(); + this.device = graphicsDevice; + this.clusteredLighting = clusteredLighting; + this.id = id11++; + this._type = LIGHTTYPE_DIRECTIONAL; + this._color = new Color(0.8, 0.8, 0.8); + this._intensity = 1; + this._affectSpecularity = true; + this._luminance = 0; + this._castShadows = false; + this._enabled = false; + this._mask = MASK_AFFECT_DYNAMIC; + this.isStatic = false; + this.key = 0; + this.bakeDir = true; + this.bakeNumSamples = 1; + this.bakeArea = 0; + this.attenuationStart = 10; + this.attenuationEnd = 10; + this._falloffMode = LIGHTFALLOFF_LINEAR; + this._shadowType = SHADOW_PCF3; + this._vsmBlurSize = 11; + this.vsmBlurMode = BLUR_GAUSSIAN; + this.vsmBias = 0.01 * 0.25; + this._cookie = null; + this.cookieIntensity = 1; + this._cookieFalloff = true; + this._cookieChannel = "rgb"; + this._cookieTransform = null; + this._cookieTransformUniform = new Float32Array(4); + this._cookieOffset = null; + this._cookieOffsetUniform = new Float32Array(2); + this._cookieTransformSet = false; + this._cookieOffsetSet = false; + this._innerConeAngle = 40; + this._outerConeAngle = 45; + this.cascades = null; + this._shadowMatrixPalette = null; + this._shadowCascadeDistances = null; + this.numCascades = 1; + this.cascadeDistribution = 0.5; + this._shape = LIGHTSHAPE_PUNCTUAL; + this._finalColor = new Float32Array([0.8, 0.8, 0.8]); + const c2 = Math.pow(this._finalColor[0], 2.2); + this._linearFinalColor = new Float32Array([c2, c2, c2]); + this._position = new Vec3(0, 0, 0); + this._direction = new Vec3(0, 0, 0); + this._innerConeAngleCos = Math.cos(this._innerConeAngle * Math.PI / 180); + this._updateOuterAngle(this._outerConeAngle); + this._usePhysicalUnits = void 0; + this._shadowMap = null; + this._shadowRenderParams = []; + this._shadowCameraParams = []; + this.shadowDistance = 40; + this._shadowResolution = 1024; + this._shadowBias = -5e-4; + this.shadowIntensity = 1; + this._normalOffsetBias = 0; + this.shadowUpdateMode = SHADOWUPDATE_REALTIME; + this.shadowUpdateOverrides = null; + this._penumbraSize = 1; + this._isVsm = false; + this._isPcf = true; + this._cookieMatrix = null; + this._atlasViewport = null; + this.atlasViewportAllocated = false; + this.atlasVersion = 0; + this.atlasSlotIndex = 0; + this.atlasSlotUpdated = false; + this._node = null; + this._renderData = []; + this.visibleThisFrame = false; + this.maxScreenSize = 0; + this._updateShadowBias(); + } + destroy() { + this._destroyShadowMap(); + this.releaseRenderData(); + this._renderData = null; + } + releaseRenderData() { + if (this._renderData) { + for (let i = 0; i < this._renderData.length; i++) { + this._renderData[i].destroy(); + } + this._renderData.length = 0; + } + } + addLayer(layer) { + this.layers.add(layer); + } + removeLayer(layer) { + this.layers.delete(layer); + } + set shadowBias(value) { + if (this._shadowBias !== value) { + this._shadowBias = value; + this._updateShadowBias(); + } + } + get shadowBias() { + return this._shadowBias; + } + set numCascades(value) { + if (!this.cascades || this.numCascades !== value) { + this.cascades = directionalCascades[value - 1]; + this._shadowMatrixPalette = new Float32Array(4 * 16); + this._shadowCascadeDistances = new Float32Array(4); + this._destroyShadowMap(); + this.updateKey(); + } + } + get numCascades() { + return this.cascades.length; + } + set shadowMap(shadowMap) { + if (this._shadowMap !== shadowMap) { + this._destroyShadowMap(); + this._shadowMap = shadowMap; + } + } + get shadowMap() { + return this._shadowMap; + } + set mask(value) { + if (this._mask !== value) { + this._mask = value; + this.updateKey(); + } + } + get mask() { + return this._mask; + } + get numShadowFaces() { + const type2 = this._type; + if (type2 === LIGHTTYPE_DIRECTIONAL) { + return this.numCascades; + } else if (type2 === LIGHTTYPE_OMNI) { + return 6; + } + return 1; + } + set type(value) { + if (this._type === value) return; + this._type = value; + this._destroyShadowMap(); + this._updateShadowBias(); + this.updateKey(); + const stype = this._shadowType; + this._shadowType = null; + this.shadowUpdateOverrides = null; + this.shadowType = stype; + } + get type() { + return this._type; + } + set shape(value) { + if (this._shape === value) return; + this._shape = value; + this._destroyShadowMap(); + this.updateKey(); + const stype = this._shadowType; + this._shadowType = null; + this.shadowType = stype; + } + get shape() { + return this._shape; + } + set usePhysicalUnits(value) { + if (this._usePhysicalUnits !== value) { + this._usePhysicalUnits = value; + this._updateFinalColor(); + } + } + get usePhysicalUnits() { + return this._usePhysicalUnits; + } + set shadowType(value) { + if (this._shadowType === value) return; + const device = this.device; + if (this._type === LIGHTTYPE_OMNI && value !== SHADOW_PCF3 && value !== SHADOW_PCSS) value = SHADOW_PCF3; + const supportsDepthShadow = device.supportsDepthShadow; + if (value === SHADOW_PCF5 && !supportsDepthShadow) { + value = SHADOW_PCF3; + } + if (value === SHADOW_VSM32 && (!device.textureFloatRenderable || !device.textureFloatFilterable)) value = SHADOW_VSM16; + if (value === SHADOW_VSM16 && !device.textureHalfFloatRenderable) value = SHADOW_VSM8; + this._isVsm = value >= SHADOW_VSM8 && value <= SHADOW_VSM32; + this._isPcf = value === SHADOW_PCF1 || value === SHADOW_PCF3 || value === SHADOW_PCF5; + this._shadowType = value; + this._destroyShadowMap(); + this.updateKey(); + } + get shadowType() { + return this._shadowType; + } + set enabled(value) { + if (this._enabled !== value) { + this._enabled = value; + this.layersDirty(); + } + } + get enabled() { + return this._enabled; + } + set castShadows(value) { + if (this._castShadows !== value) { + this._castShadows = value; + this._destroyShadowMap(); + this.layersDirty(); + this.updateKey(); + } + } + get castShadows() { + return this._castShadows && this._mask !== MASK_BAKE && this._mask !== 0; + } + set shadowResolution(value) { + if (this._shadowResolution !== value) { + if (this._type === LIGHTTYPE_OMNI) { + value = Math.min(value, this.device.maxCubeMapSize); + } else { + value = Math.min(value, this.device.maxTextureSize); + } + this._shadowResolution = value; + this._destroyShadowMap(); + } + } + get shadowResolution() { + return this._shadowResolution; + } + set vsmBlurSize(value) { + if (this._vsmBlurSize === value) return; + if (value % 2 === 0) value++; + this._vsmBlurSize = value; + } + get vsmBlurSize() { + return this._vsmBlurSize; + } + set normalOffsetBias(value) { + if (this._normalOffsetBias === value) return; + if (!this._normalOffsetBias && value || this._normalOffsetBias && !value) { + this.updateKey(); + } + this._normalOffsetBias = value; + } + get normalOffsetBias() { + return this._normalOffsetBias; + } + set falloffMode(value) { + if (this._falloffMode === value) return; + this._falloffMode = value; + this.updateKey(); + } + get falloffMode() { + return this._falloffMode; + } + set innerConeAngle(value) { + if (this._innerConeAngle === value) return; + this._innerConeAngle = value; + this._innerConeAngleCos = Math.cos(value * Math.PI / 180); + if (this._usePhysicalUnits) { + this._updateFinalColor(); + } + } + get innerConeAngle() { + return this._innerConeAngle; + } + set outerConeAngle(value) { + if (this._outerConeAngle === value) return; + this._outerConeAngle = value; + this._updateOuterAngle(value); + if (this._usePhysicalUnits) { + this._updateFinalColor(); + } + } + get outerConeAngle() { + return this._outerConeAngle; + } + set penumbraSize(value) { + this._penumbraSize = value; + } + get penumbraSize() { + return this._penumbraSize; + } + _updateOuterAngle(angle) { + const radAngle = angle * Math.PI / 180; + this._outerConeAngleCos = Math.cos(radAngle); + this._outerConeAngleSin = Math.sin(radAngle); + } + set intensity(value) { + if (this._intensity !== value) { + this._intensity = value; + this._updateFinalColor(); + } + } + get intensity() { + return this._intensity; + } + set affectSpecularity(value) { + if (this._type === LIGHTTYPE_DIRECTIONAL) { + this._affectSpecularity = value; + this.updateKey(); + } + } + get affectSpecularity() { + return this._affectSpecularity; + } + set luminance(value) { + if (this._luminance !== value) { + this._luminance = value; + this._updateFinalColor(); + } + } + get luminance() { + return this._luminance; + } + get cookieMatrix() { + if (!this._cookieMatrix) { + this._cookieMatrix = new Mat4(); + } + return this._cookieMatrix; + } + get atlasViewport() { + if (!this._atlasViewport) { + this._atlasViewport = new Vec4(0, 0, 1, 1); + } + return this._atlasViewport; + } + set cookie(value) { + if (this._cookie === value) return; + this._cookie = value; + this.updateKey(); + } + get cookie() { + return this._cookie; + } + set cookieFalloff(value) { + if (this._cookieFalloff === value) return; + this._cookieFalloff = value; + this.updateKey(); + } + get cookieFalloff() { + return this._cookieFalloff; + } + set cookieChannel(value) { + if (this._cookieChannel === value) return; + if (value.length < 3) { + const chr = value.charAt(value.length - 1); + const addLen = 3 - value.length; + for (let i = 0; i < addLen; i++) value += chr; + } + this._cookieChannel = value; + this.updateKey(); + } + get cookieChannel() { + return this._cookieChannel; + } + set cookieTransform(value) { + if (this._cookieTransform === value) return; + this._cookieTransform = value; + this._cookieTransformSet = !!value; + if (value && !this._cookieOffset) { + this.cookieOffset = new Vec2(); + this._cookieOffsetSet = false; + } + this.updateKey(); + } + get cookieTransform() { + return this._cookieTransform; + } + set cookieOffset(value) { + if (this._cookieOffset === value) return; + const xformNew = !!(this._cookieTransformSet || value); + if (xformNew && !value && this._cookieOffset) { + this._cookieOffset.set(0, 0); + } else { + this._cookieOffset = value; + } + this._cookieOffsetSet = !!value; + if (value && !this._cookieTransform) { + this.cookieTransform = new Vec4(1, 1, 0, 0); + this._cookieTransformSet = false; + } + this.updateKey(); + } + get cookieOffset() { + return this._cookieOffset; + } + beginFrame() { + this.visibleThisFrame = this._type === LIGHTTYPE_DIRECTIONAL && this._enabled; + this.maxScreenSize = 0; + this.atlasViewportAllocated = false; + this.atlasSlotUpdated = false; + } + _destroyShadowMap() { + this.releaseRenderData(); + if (this._shadowMap) { + if (!this._shadowMap.cached) { + this._shadowMap.destroy(); + } + this._shadowMap = null; + } + if (this.shadowUpdateMode === SHADOWUPDATE_NONE) { + this.shadowUpdateMode = SHADOWUPDATE_THISFRAME; + } + if (this.shadowUpdateOverrides) { + for (let i = 0; i < this.shadowUpdateOverrides.length; i++) { + if (this.shadowUpdateOverrides[i] === SHADOWUPDATE_NONE) { + this.shadowUpdateOverrides[i] = SHADOWUPDATE_THISFRAME; + } + } + } + } + getRenderData(camera, face) { + for (let i = 0; i < this._renderData.length; i++) { + const current = this._renderData[i]; + if (current.camera === camera && current.face === face) { + return current; + } + } + const rd = new LightRenderData(this.device, camera, face, this); + this._renderData.push(rd); + return rd; + } + clone() { + const clone = new _Light(this.device, this.clusteredLighting); + clone.type = this._type; + clone.setColor(this._color); + clone.intensity = this._intensity; + clone.affectSpecularity = this._affectSpecularity; + clone.luminance = this._luminance; + clone.castShadows = this.castShadows; + clone._enabled = this._enabled; + clone.attenuationStart = this.attenuationStart; + clone.attenuationEnd = this.attenuationEnd; + clone.falloffMode = this._falloffMode; + clone.shadowType = this._shadowType; + clone.vsmBlurSize = this._vsmBlurSize; + clone.vsmBlurMode = this.vsmBlurMode; + clone.vsmBias = this.vsmBias; + clone.penumbraSize = this.penumbraSize; + clone.shadowUpdateMode = this.shadowUpdateMode; + clone.mask = this.mask; + if (this.shadowUpdateOverrides) { + clone.shadowUpdateOverrides = this.shadowUpdateOverrides.slice(); + } + clone.innerConeAngle = this._innerConeAngle; + clone.outerConeAngle = this._outerConeAngle; + clone.numCascades = this.numCascades; + clone.cascadeDistribution = this.cascadeDistribution; + clone.shape = this._shape; + clone.shadowDepthState.copy(this.shadowDepthState); + clone.shadowBias = this.shadowBias; + clone.normalOffsetBias = this._normalOffsetBias; + clone.shadowResolution = this._shadowResolution; + clone.shadowDistance = this.shadowDistance; + clone.shadowIntensity = this.shadowIntensity; + return clone; + } + static getLightUnitConversion(type2, outerAngle = Math.PI / 4, innerAngle = 0) { + switch (type2) { + case LIGHTTYPE_SPOT: { + const falloffEnd = Math.cos(outerAngle); + const falloffStart = Math.cos(innerAngle); + return 2 * Math.PI * (1 - falloffStart + (falloffStart - falloffEnd) / 2); + } + case LIGHTTYPE_OMNI: + return 4 * Math.PI; + case LIGHTTYPE_DIRECTIONAL: + return 1; + } + } + _getUniformBiasValues(lightRenderData) { + const farClip = lightRenderData.shadowCamera._farClip; + switch (this._type) { + case LIGHTTYPE_OMNI: + tmpBiases.bias = this.shadowBias; + tmpBiases.normalBias = this._normalOffsetBias; + break; + case LIGHTTYPE_SPOT: + if (this._isVsm) { + tmpBiases.bias = -1e-5 * 20; + } else { + tmpBiases.bias = this.shadowBias * 20; + if (this.device.isWebGL1 && this.device.extStandardDerivatives) tmpBiases.bias *= -100; + } + tmpBiases.normalBias = this._isVsm ? this.vsmBias / (this.attenuationEnd / 7) : this._normalOffsetBias; + break; + case LIGHTTYPE_DIRECTIONAL: + if (this._isVsm) { + tmpBiases.bias = -1e-5 * 20; + } else { + tmpBiases.bias = this.shadowBias / farClip * 100; + if (this.device.isWebGL1 && this.device.extStandardDerivatives) tmpBiases.bias *= -100; + } + tmpBiases.normalBias = this._isVsm ? this.vsmBias / (farClip / 7) : this._normalOffsetBias; + break; + } + return tmpBiases; + } + getColor() { + return this._color; + } + getBoundingSphere(sphere) { + if (this._type === LIGHTTYPE_SPOT) { + const size = this.attenuationEnd; + const angle = this._outerConeAngle; + const cosAngle = this._outerConeAngleCos; + const node = this._node; + tmpVec.copy(node.up); + if (angle > 45) { + sphere.radius = size * this._outerConeAngleSin; + tmpVec.mulScalar(-size * cosAngle); + } else { + sphere.radius = size / (2 * cosAngle); + tmpVec.mulScalar(-sphere.radius); + } + sphere.center.add2(node.getPosition(), tmpVec); + } else if (this._type === LIGHTTYPE_OMNI) { + sphere.center = this._node.getPosition(); + sphere.radius = this.attenuationEnd; + } + } + getBoundingBox(box) { + if (this._type === LIGHTTYPE_SPOT) { + const range = this.attenuationEnd; + const angle = this._outerConeAngle; + const node = this._node; + const scl = Math.abs(Math.sin(angle * math.DEG_TO_RAD) * range); + box.center.set(0, -range * 0.5, 0); + box.halfExtents.set(scl, range * 0.5, scl); + box.setFromTransformedAabb(box, node.getWorldTransform(), true); + } else if (this._type === LIGHTTYPE_OMNI) { + box.center.copy(this._node.getPosition()); + box.halfExtents.set(this.attenuationEnd, this.attenuationEnd, this.attenuationEnd); + } + } + _updateShadowBias() { + const device = this.device; + if (device.isWebGL2 || device.isWebGPU) { + if (this._type === LIGHTTYPE_OMNI && !this.clusteredLighting) { + this.shadowDepthState.depthBias = 0; + this.shadowDepthState.depthBiasSlope = 0; + } else { + const bias = this.shadowBias * -1e3; + this.shadowDepthState.depthBias = bias; + this.shadowDepthState.depthBiasSlope = bias; + } + } + } + _updateFinalColor() { + const color = this._color; + const r = color.r; + const g = color.g; + const b = color.b; + let i = this._intensity; + if (this._usePhysicalUnits) { + i = this._luminance / _Light.getLightUnitConversion(this._type, this._outerConeAngle * math.DEG_TO_RAD, this._innerConeAngle * math.DEG_TO_RAD); + } + const finalColor = this._finalColor; + const linearFinalColor = this._linearFinalColor; + finalColor[0] = r * i; + finalColor[1] = g * i; + finalColor[2] = b * i; + if (i >= 1) { + linearFinalColor[0] = Math.pow(r, 2.2) * i; + linearFinalColor[1] = Math.pow(g, 2.2) * i; + linearFinalColor[2] = Math.pow(b, 2.2) * i; + } else { + linearFinalColor[0] = Math.pow(finalColor[0], 2.2); + linearFinalColor[1] = Math.pow(finalColor[1], 2.2); + linearFinalColor[2] = Math.pow(finalColor[2], 2.2); + } + } + setColor() { + if (arguments.length === 1) { + this._color.set(arguments[0].r, arguments[0].g, arguments[0].b); + } else if (arguments.length === 3) { + this._color.set(arguments[0], arguments[1], arguments[2]); + } + this._updateFinalColor(); + } + layersDirty() { + this.layers.forEach((layer) => { + layer.markLightsDirty(); + }); + } + updateKey() { + let key = this._type << 29 | (this._castShadows ? 1 : 0) << 28 | this._shadowType << 25 | this._falloffMode << 23 | (this._normalOffsetBias !== 0 ? 1 : 0) << 22 | (this._cookie ? 1 : 0) << 21 | (this._cookieFalloff ? 1 : 0) << 20 | chanId[this._cookieChannel.charAt(0)] << 18 | (this._cookieTransform ? 1 : 0) << 12 | this._shape << 10 | this.numCascades - 1 << 8 | (this.affectSpecularity ? 1 : 0) << 7 | this.mask << 6; + if (this._cookieChannel.length === 3) { + key |= chanId[this._cookieChannel.charAt(1)] << 16; + key |= chanId[this._cookieChannel.charAt(2)] << 14; + } + if (key !== this.key) { + this.layersDirty(); + } + this.key = key; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/lighting/lighting-params.js +var LightingParams = class { + constructor(supportsAreaLights, maxTextureSize, dirtyLightsFnc) { + this._areaLightsEnabled = false; + this._cells = new Vec3(10, 3, 10); + this._maxLightsPerCell = 255; + this._shadowsEnabled = true; + this._shadowType = SHADOW_PCF3; + this._shadowAtlasResolution = 2048; + this._cookiesEnabled = false; + this._cookieAtlasResolution = 2048; + this.debugLayer = void 0; + this.atlasSplit = null; + this._supportsAreaLights = supportsAreaLights; + this._maxTextureSize = maxTextureSize; + this._dirtyLightsFnc = dirtyLightsFnc; + } + applySettings(render) { + var _render$lightingShado, _render$lightingCooki, _render$lightingAreaL, _render$lightingShado2, _render$lightingCooki2, _render$lightingMaxLi, _render$lightingShado3; + this.shadowsEnabled = (_render$lightingShado = render.lightingShadowsEnabled) != null ? _render$lightingShado : this.shadowsEnabled; + this.cookiesEnabled = (_render$lightingCooki = render.lightingCookiesEnabled) != null ? _render$lightingCooki : this.cookiesEnabled; + this.areaLightsEnabled = (_render$lightingAreaL = render.lightingAreaLightsEnabled) != null ? _render$lightingAreaL : this.areaLightsEnabled; + this.shadowAtlasResolution = (_render$lightingShado2 = render.lightingShadowAtlasResolution) != null ? _render$lightingShado2 : this.shadowAtlasResolution; + this.cookieAtlasResolution = (_render$lightingCooki2 = render.lightingCookieAtlasResolution) != null ? _render$lightingCooki2 : this.cookieAtlasResolution; + this.maxLightsPerCell = (_render$lightingMaxLi = render.lightingMaxLightsPerCell) != null ? _render$lightingMaxLi : this.maxLightsPerCell; + this.shadowType = (_render$lightingShado3 = render.lightingShadowType) != null ? _render$lightingShado3 : this.shadowType; + if (render.lightingCells) this.cell = new Vec3(render.lightingCells); + } + set cells(value) { + this._cells.copy(value); + } + get cells() { + return this._cells; + } + set maxLightsPerCell(value) { + this._maxLightsPerCell = math.clamp(value, 1, 255); + } + get maxLightsPerCell() { + return this._maxLightsPerCell; + } + set cookieAtlasResolution(value) { + this._cookieAtlasResolution = math.clamp(value, 32, this._maxTextureSize); + } + get cookieAtlasResolution() { + return this._cookieAtlasResolution; + } + set shadowAtlasResolution(value) { + this._shadowAtlasResolution = math.clamp(value, 32, this._maxTextureSize); + } + get shadowAtlasResolution() { + return this._shadowAtlasResolution; + } + set shadowType(value) { + if (this._shadowType !== value) { + this._shadowType = value; + this._dirtyLightsFnc(); + } + } + get shadowType() { + return this._shadowType; + } + set cookiesEnabled(value) { + if (this._cookiesEnabled !== value) { + this._cookiesEnabled = value; + this._dirtyLightsFnc(); + } + } + get cookiesEnabled() { + return this._cookiesEnabled; + } + set areaLightsEnabled(value) { + if (this._supportsAreaLights) { + if (this._areaLightsEnabled !== value) { + this._areaLightsEnabled = value; + this._dirtyLightsFnc(); + } + } + } + get areaLightsEnabled() { + return this._areaLightsEnabled; + } + set shadowsEnabled(value) { + if (this._shadowsEnabled !== value) { + this._shadowsEnabled = value; + this._dirtyLightsFnc(); + } + } + get shadowsEnabled() { + return this._shadowsEnabled; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/morph-instance.js +var textureMorphVertexShader = ` + attribute vec2 vertex_position; + varying vec2 uv0; + void main(void) { + gl_Position = vec4(vertex_position, 0.5, 1.0); + uv0 = vertex_position.xy * 0.5 + 0.5; + } + `; +var blendStateAdditive = new BlendState(true, BLENDEQUATION_ADD, BLENDMODE_ONE, BLENDMODE_ONE); +var MorphInstance = class _MorphInstance { + constructor(morph) { + this.morph = morph; + morph.incRefCount(); + this.device = morph.device; + this._weights = []; + this._weightMap = /* @__PURE__ */ new Map(); + for (let v = 0; v < morph._targets.length; v++) { + const target2 = morph._targets[v]; + if (target2.name) { + this._weightMap.set(target2.name, v); + } + this.setWeight(v, target2.defaultWeight); + } + this._activeTargets = []; + if (morph.useTextureMorph) { + this.shaderCache = {}; + this.maxSubmitCount = this.device.maxTextures; + this._shaderMorphWeights = new Float32Array(this.maxSubmitCount); + const createRT = (name, textureVar) => { + this[textureVar] = morph._createTexture(name, morph._renderTextureFormat); + return new RenderTarget({ + colorBuffer: this[textureVar], + depth: false + }); + }; + if (morph.morphPositions) { + this.rtPositions = createRT("MorphRTPos", "texturePositions"); + } + if (morph.morphNormals) { + this.rtNormals = createRT("MorphRTNrm", "textureNormals"); + } + this._textureParams = new Float32Array([morph.morphTextureWidth, morph.morphTextureHeight, 1 / morph.morphTextureWidth, 1 / morph.morphTextureHeight]); + for (let i = 0; i < this.maxSubmitCount; i++) { + this["morphBlendTex" + i] = this.device.scope.resolve("morphBlendTex" + i); + } + this.morphFactor = this.device.scope.resolve("morphFactor[0]"); + this.zeroTextures = false; + } else { + this.maxSubmitCount = 8; + this._shaderMorphWeights = new Float32Array(this.maxSubmitCount); + this._shaderMorphWeightsA = new Float32Array(this._shaderMorphWeights.buffer, 0, 4); + this._shaderMorphWeightsB = new Float32Array(this._shaderMorphWeights.buffer, 4 * 4, 4); + this._activeVertexBuffers = new Array(this.maxSubmitCount); + } + } + destroy() { + this.shader = null; + const morph = this.morph; + if (morph) { + this.morph = null; + morph.decRefCount(); + if (morph.refCount < 1) { + morph.destroy(); + } + } + if (this.rtPositions) { + this.rtPositions.destroy(); + this.rtPositions = null; + } + if (this.texturePositions) { + this.texturePositions.destroy(); + this.texturePositions = null; + } + if (this.rtNormals) { + this.rtNormals.destroy(); + this.rtNormals = null; + } + if (this.textureNormals) { + this.textureNormals.destroy(); + this.textureNormals = null; + } + } + clone() { + return new _MorphInstance(this.morph); + } + _getWeightIndex(key) { + if (typeof key === "string") { + const index = this._weightMap.get(key); + return index; + } + return key; + } + getWeight(key) { + const index = this._getWeightIndex(key); + return this._weights[index]; + } + setWeight(key, weight) { + const index = this._getWeightIndex(key); + this._weights[index] = weight; + this._dirty = true; + } + _getFragmentShader(numTextures) { + let fragmentShader = ""; + if (numTextures > 0) { + fragmentShader += "varying vec2 uv0;\nuniform highp float morphFactor[" + numTextures + "];\n"; + } + for (let i = 0; i < numTextures; i++) { + fragmentShader += "uniform highp sampler2D morphBlendTex" + i + ";\n"; + } + fragmentShader += "void main (void) {\n highp vec4 color = vec4(0, 0, 0, 1);\n"; + for (let i = 0; i < numTextures; i++) { + fragmentShader += " color.xyz += morphFactor[" + i + "] * texture2D(morphBlendTex" + i + ", uv0).xyz;\n"; + } + fragmentShader += " gl_FragColor = color;\n}\n"; + return fragmentShader; + } + _getShader(count) { + let shader = this.shaderCache[count]; + if (!shader) { + const fs = this._getFragmentShader(count); + shader = createShaderFromCode(this.device, textureMorphVertexShader, fs, "textureMorph" + count); + this.shaderCache[count] = shader; + } + return shader; + } + _updateTextureRenderTarget(renderTarget, srcTextureName) { + const device = this.device; + const submitBatch = (usedCount2, blending2) => { + this.morphFactor.setValue(this._shaderMorphWeights); + device.setBlendState(blending2 ? blendStateAdditive : BlendState.NOBLEND); + const shader = this._getShader(usedCount2); + drawQuadWithShader(device, renderTarget, shader); + }; + let usedCount = 0; + let blending = false; + const count = this._activeTargets.length; + for (let i = 0; i < count; i++) { + const activeTarget = this._activeTargets[i]; + const tex = activeTarget.target[srcTextureName]; + if (tex) { + this["morphBlendTex" + usedCount].setValue(tex); + this._shaderMorphWeights[usedCount] = activeTarget.weight; + usedCount++; + if (usedCount >= this.maxSubmitCount) { + submitBatch(usedCount, blending); + usedCount = 0; + blending = true; + } + } + } + if (usedCount > 0 || count === 0 && !this.zeroTextures) { + submitBatch(usedCount, blending); + } + } + _updateTextureMorph() { + this.device; + if (this._activeTargets.length > 0 || !this.zeroTextures) { + if (this.rtPositions) this._updateTextureRenderTarget(this.rtPositions, "texturePositions"); + if (this.rtNormals) this._updateTextureRenderTarget(this.rtNormals, "textureNormals"); + this.zeroTextures = this._activeTargets.length === 0; + } + } + _updateVertexMorph() { + const count = this.maxSubmitCount; + for (let i = 0; i < count; i++) { + this._shaderMorphWeights[i] = 0; + this._activeVertexBuffers[i] = null; + } + let posIndex = 0; + let nrmIndex = this.morph.morphPositions ? 4 : 0; + for (let i = 0; i < this._activeTargets.length; i++) { + const target2 = this._activeTargets[i].target; + if (target2._vertexBufferPositions) { + this._activeVertexBuffers[posIndex] = target2._vertexBufferPositions; + this._shaderMorphWeights[posIndex] = this._activeTargets[i].weight; + posIndex++; + } + if (target2._vertexBufferNormals) { + this._activeVertexBuffers[nrmIndex] = target2._vertexBufferNormals; + this._shaderMorphWeights[nrmIndex] = this._activeTargets[i].weight; + nrmIndex++; + } + } + } + update() { + this._dirty = false; + const targets = this.morph._targets; + let activeCount = 0; + const epsilon3 = 1e-5; + for (let i = 0; i < targets.length; i++) { + const absWeight = Math.abs(this.getWeight(i)); + if (absWeight > epsilon3) { + if (this._activeTargets.length <= activeCount) { + this._activeTargets[activeCount] = {}; + } + const activeTarget = this._activeTargets[activeCount++]; + activeTarget.absWeight = absWeight; + activeTarget.weight = this.getWeight(i); + activeTarget.target = targets[i]; + } + } + this._activeTargets.length = activeCount; + const maxActiveTargets = this.morph.maxActiveTargets; + if (this._activeTargets.length > maxActiveTargets) { + this._activeTargets.sort(function(l, r) { + return l.absWeight < r.absWeight ? 1 : r.absWeight < l.absWeight ? -1 : 0; + }); + this._activeTargets.length = maxActiveTargets; + } + if (this.morph.useTextureMorph) { + this._updateTextureMorph(); + } else { + this._updateVertexMorph(); + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/model.js +var Model2 = class _Model { + constructor() { + this.graph = null; + this.meshInstances = []; + this.skinInstances = []; + this.morphInstances = []; + this.cameras = []; + this.lights = []; + this._shadersVersion = 0; + this._immutable = false; + } + getGraph() { + return this.graph; + } + setGraph(graph) { + this.graph = graph; + } + getCameras() { + return this.cameras; + } + setCameras(cameras) { + this.cameras = cameras; + } + getLights() { + return this.lights; + } + setLights(lights2) { + this.lights = lights2; + } + getMaterials() { + const materials = []; + for (let i = 0; i < this.meshInstances.length; i++) { + const meshInstance = this.meshInstances[i]; + if (materials.indexOf(meshInstance.material) === -1) { + materials.push(meshInstance.material); + } + } + return materials; + } + clone() { + const srcNodes = []; + const cloneNodes = []; + const _duplicate = function _duplicate2(node) { + const newNode = node.clone(); + srcNodes.push(node); + cloneNodes.push(newNode); + for (let idx = 0; idx < node._children.length; idx++) { + newNode.addChild(_duplicate2(node._children[idx])); + } + return newNode; + }; + const cloneGraph = _duplicate(this.graph); + const cloneMeshInstances = []; + const cloneSkinInstances = []; + const cloneMorphInstances = []; + for (let i = 0; i < this.skinInstances.length; i++) { + const skin = this.skinInstances[i].skin; + const cloneSkinInstance = new SkinInstance(skin); + const bones = []; + for (let j = 0; j < skin.boneNames.length; j++) { + const boneName = skin.boneNames[j]; + const bone = cloneGraph.findByName(boneName); + bones.push(bone); + } + cloneSkinInstance.bones = bones; + cloneSkinInstances.push(cloneSkinInstance); + } + for (let i = 0; i < this.morphInstances.length; i++) { + const morph = this.morphInstances[i].morph; + const cloneMorphInstance = new MorphInstance(morph); + cloneMorphInstances.push(cloneMorphInstance); + } + for (let i = 0; i < this.meshInstances.length; i++) { + const meshInstance = this.meshInstances[i]; + const nodeIndex = srcNodes.indexOf(meshInstance.node); + const cloneMeshInstance = new MeshInstance(meshInstance.mesh, meshInstance.material, cloneNodes[nodeIndex]); + if (meshInstance.skinInstance) { + const skinInstanceIndex = this.skinInstances.indexOf(meshInstance.skinInstance); + cloneMeshInstance.skinInstance = cloneSkinInstances[skinInstanceIndex]; + } + if (meshInstance.morphInstance) { + const morphInstanceIndex = this.morphInstances.indexOf(meshInstance.morphInstance); + cloneMeshInstance.morphInstance = cloneMorphInstances[morphInstanceIndex]; + } + cloneMeshInstances.push(cloneMeshInstance); + } + const clone = new _Model(); + clone.graph = cloneGraph; + clone.meshInstances = cloneMeshInstances; + clone.skinInstances = cloneSkinInstances; + clone.morphInstances = cloneMorphInstances; + clone.getGraph().syncHierarchy(); + return clone; + } + destroy() { + const meshInstances = this.meshInstances; + for (let i = 0; i < meshInstances.length; i++) { + meshInstances[i].destroy(); + } + this.meshInstances.length = 0; + } + generateWireframe() { + MeshInstance._prepareRenderStyleForArray(this.meshInstances, RENDERSTYLE_WIREFRAME); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/morph.js +var Morph = class extends RefCountedObject { + constructor(targets, graphicsDevice, { + preferHighPrecision = false + } = {}) { + super(); + this._aabb = void 0; + this.preferHighPrecision = void 0; + this.device = graphicsDevice; + this.preferHighPrecision = preferHighPrecision; + this._targets = targets.slice(); + const device = this.device; + if (device.supportsMorphTargetTexturesCore) { + const renderableHalf = device.extTextureHalfFloat && device.textureHalfFloatRenderable ? PIXELFORMAT_RGBA16F : void 0; + const renderableFloat = device.extTextureFloat && device.textureFloatRenderable ? PIXELFORMAT_RGBA32F : void 0; + this._renderTextureFormat = this.preferHighPrecision ? renderableFloat != null ? renderableFloat : renderableHalf : renderableHalf != null ? renderableHalf : renderableFloat; + const textureHalf = device.extTextureHalfFloat && device.textureHalfFloatUpdatable ? PIXELFORMAT_RGBA16F : void 0; + const textureFloat = device.extTextureFloat ? PIXELFORMAT_RGB32F : void 0; + this._textureFormat = this.preferHighPrecision ? textureFloat != null ? textureFloat : textureHalf : textureHalf != null ? textureHalf : textureFloat; + if (this._renderTextureFormat !== void 0 && this._textureFormat !== void 0) { + this._useTextureMorph = true; + } + } + this._init(); + this._updateMorphFlags(); + } + get aabb() { + if (!this._aabb) { + const min = new Vec3(); + const max = new Vec3(); + for (let i = 0; i < this._targets.length; i++) { + const targetAabb = this._targets[i].aabb; + min.min(targetAabb.getMin()); + max.max(targetAabb.getMax()); + } + this._aabb = new BoundingBox(); + this._aabb.setMinMax(min, max); + } + return this._aabb; + } + get morphPositions() { + return this._morphPositions; + } + get morphNormals() { + return this._morphNormals; + } + get maxActiveTargets() { + if (this._useTextureMorph) return this._targets.length; + return this._morphPositions && this._morphNormals ? 4 : 8; + } + get useTextureMorph() { + return this._useTextureMorph; + } + _init() { + if (this._useTextureMorph) { + this._useTextureMorph = this._initTextureBased(); + } + if (!this._useTextureMorph) { + for (let i = 0; i < this._targets.length; i++) { + this._targets[i]._initVertexBuffers(this.device); + } + } + for (let i = 0; i < this._targets.length; i++) { + this._targets[i]._postInit(); + } + } + _findSparseSet(deltaArrays, ids2, usedDataIndices, floatRounding) { + let freeIndex = 1; + const dataCount = deltaArrays[0].length; + for (let v = 0; v < dataCount; v += 3) { + let vertexUsed = false; + for (let i = 0; i < deltaArrays.length; i++) { + const data2 = deltaArrays[i]; + if (data2[v] !== 0 || data2[v + 1] !== 0 || data2[v + 2] !== 0) { + vertexUsed = true; + break; + } + } + if (vertexUsed) { + ids2.push(freeIndex + floatRounding); + usedDataIndices.push(v / 3); + freeIndex++; + } else { + ids2.push(0 + floatRounding); + } + } + return freeIndex; + } + _initTextureBased() { + const useUintIds = this.device.isWebGPU; + const floatRounding = useUintIds ? 0 : 0.2; + const deltaArrays = [], deltaInfos = []; + for (let i = 0; i < this._targets.length; i++) { + const target2 = this._targets[i]; + if (target2.options.deltaPositions) { + deltaArrays.push(target2.options.deltaPositions); + deltaInfos.push({ + target: target2, + name: "texturePositions" + }); + } + if (target2.options.deltaNormals) { + deltaArrays.push(target2.options.deltaNormals); + deltaInfos.push({ + target: target2, + name: "textureNormals" + }); + } + } + const ids2 = [], usedDataIndices = []; + const freeIndex = this._findSparseSet(deltaArrays, ids2, usedDataIndices, floatRounding); + const maxTextureSize = Math.min(this.device.maxTextureSize, 4096); + let morphTextureWidth = Math.ceil(Math.sqrt(freeIndex)); + morphTextureWidth = Math.min(morphTextureWidth, maxTextureSize); + const morphTextureHeight = Math.ceil(freeIndex / morphTextureWidth); + if (morphTextureHeight > maxTextureSize) { + return false; + } + this.morphTextureWidth = morphTextureWidth; + this.morphTextureHeight = morphTextureHeight; + let halfFloat = false; + let numComponents = 3; + const float2Half = FloatPacking.float2Half; + if (this._textureFormat === PIXELFORMAT_RGBA16F) { + halfFloat = true; + numComponents = 4; + } + const textures = []; + for (let i = 0; i < deltaArrays.length; i++) { + textures.push(this._createTexture("MorphTarget", this._textureFormat)); + } + for (let i = 0; i < deltaArrays.length; i++) { + const data2 = deltaArrays[i]; + const texture = textures[i]; + const textureData = texture.lock(); + if (halfFloat) { + for (let v = 0; v < usedDataIndices.length; v++) { + const index = usedDataIndices[v] * 3; + const dstIndex = v * numComponents + numComponents; + textureData[dstIndex] = float2Half(data2[index]); + textureData[dstIndex + 1] = float2Half(data2[index + 1]); + textureData[dstIndex + 2] = float2Half(data2[index + 2]); + } + } else { + for (let v = 0; v < usedDataIndices.length; v++) { + const index = usedDataIndices[v] * 3; + const dstIndex = v * numComponents + numComponents; + textureData[dstIndex] = data2[index]; + textureData[dstIndex + 1] = data2[index + 1]; + textureData[dstIndex + 2] = data2[index + 2]; + } + } + texture.unlock(); + const target2 = deltaInfos[i].target; + target2._setTexture(deltaInfos[i].name, texture); + } + const formatDesc = [{ + semantic: SEMANTIC_ATTR15, + components: 1, + type: useUintIds ? TYPE_UINT32 : TYPE_FLOAT32 + }]; + this.vertexBufferIds = new VertexBuffer(this.device, new VertexFormat(this.device, formatDesc, ids2.length), ids2.length, { + data: useUintIds ? new Uint32Array(ids2) : new Float32Array(ids2) + }); + return true; + } + destroy() { + var _this$vertexBufferIds; + (_this$vertexBufferIds = this.vertexBufferIds) == null || _this$vertexBufferIds.destroy(); + this.vertexBufferIds = null; + for (let i = 0; i < this._targets.length; i++) { + this._targets[i].destroy(); + } + this._targets.length = 0; + } + get targets() { + return this._targets; + } + _updateMorphFlags() { + this._morphPositions = false; + this._morphNormals = false; + for (let i = 0; i < this._targets.length; i++) { + const target2 = this._targets[i]; + if (target2.morphPositions) { + this._morphPositions = true; + } + if (target2.morphNormals) { + this._morphNormals = true; + } + } + } + _createTexture(name, format) { + return new Texture(this.device, { + width: this.morphTextureWidth, + height: this.morphTextureHeight, + format, + cubemap: false, + mipmaps: false, + minFilter: FILTER_NEAREST, + magFilter: FILTER_NEAREST, + addressU: ADDRESS_CLAMP_TO_EDGE, + addressV: ADDRESS_CLAMP_TO_EDGE, + name + }); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/morph-target.js +var MorphTarget = class _MorphTarget { + constructor(options) { + this.used = false; + if (arguments.length === 2) { + options = arguments[1]; + } + this.options = options; + this._name = options.name; + this._defaultWeight = options.defaultWeight || 0; + this._aabb = options.aabb; + this.deltaPositions = options.deltaPositions; + } + destroy() { + var _this$_vertexBufferPo, _this$_vertexBufferNo, _this$texturePosition, _this$textureNormals; + (_this$_vertexBufferPo = this._vertexBufferPositions) == null || _this$_vertexBufferPo.destroy(); + this._vertexBufferPositions = null; + (_this$_vertexBufferNo = this._vertexBufferNormals) == null || _this$_vertexBufferNo.destroy(); + this._vertexBufferNormals = null; + (_this$texturePosition = this.texturePositions) == null || _this$texturePosition.destroy(); + this.texturePositions = null; + (_this$textureNormals = this.textureNormals) == null || _this$textureNormals.destroy(); + this.textureNormals = null; + } + get name() { + return this._name; + } + get defaultWeight() { + return this._defaultWeight; + } + get aabb() { + if (!this._aabb) { + this._aabb = new BoundingBox(); + if (this.deltaPositions) this._aabb.compute(this.deltaPositions); + } + return this._aabb; + } + get morphPositions() { + return !!this._vertexBufferPositions || !!this.texturePositions; + } + get morphNormals() { + return !!this._vertexBufferNormals || !!this.textureNormals; + } + clone() { + return new _MorphTarget(this.options); + } + _postInit() { + if (!this.options.preserveData) { + this.options = null; + } + this.used = true; + } + _initVertexBuffers(graphicsDevice) { + const options = this.options; + this._vertexBufferPositions = this._createVertexBuffer(graphicsDevice, options.deltaPositions, options.deltaPositionsType); + this._vertexBufferNormals = this._createVertexBuffer(graphicsDevice, options.deltaNormals, options.deltaNormalsType); + if (this._vertexBufferPositions) { + this.deltaPositions = this._vertexBufferPositions.lock(); + } + } + _createVertexBuffer(device, data2, dataType = TYPE_FLOAT32) { + if (data2) { + const formatDesc = [{ + semantic: SEMANTIC_ATTR0, + components: 3, + type: dataType + }]; + return new VertexBuffer(device, new VertexFormat(device, formatDesc), data2.length / 3, { + data: data2 + }); + } + return null; + } + _setTexture(name, texture) { + this[name] = texture; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/programs/skybox.js +var mip2size = [128, 64, 16, 8, 4, 2]; +var fShader2 = ` + #include "decodePS" + #include "gamma" + #include "tonemapping" + #include "envMultiplyPS" + + #ifdef SKY_CUBEMAP + #include "cubemapSeams" + #include "skyboxHDRPS" + #else + #include "sphericalPS" + #include "envAtlasPS" + #include "skyboxEnvPS" + #endif +`; +var ShaderGeneratorSkybox = class extends ShaderGenerator { + generateKey(options) { + const sharedKey = `skybox-${options.type}-${options.encoding}-${options.gamma}-${options.toneMapping}-${options.skymesh}`; + return sharedKey + (options.type === "cubemap" ? `-${options.mip}` : ""); + } + createShaderDefinition(device, options) { + const defines = /* @__PURE__ */ new Map(); + defines.set("SKYBOX_DECODE_FNC", ChunkUtils.decodeFunc(options.encoding)); + if (options.skymesh !== SKYTYPE_INFINITE) defines.set("SKYMESH", ""); + if (options.type === "cubemap") { + defines.set("SKY_CUBEMAP", ""); + defines.set("SKYBOX_MIP", (1 - 1 / mip2size[options.mip]).toString()); + } + const includes = /* @__PURE__ */ new Map(); + includes.set("decodePS", shaderChunks.decodePS); + includes.set("gamma", ShaderGenerator.gammaCode(options.gamma)); + includes.set("tonemapping", ShaderGenerator.tonemapCode(options.toneMapping)); + includes.set("envMultiplyPS", shaderChunks.envMultiplyPS); + if (options.type === "cubemap") { + includes.set("cubemapSeams", options.mip ? shaderChunks.fixCubemapSeamsStretchPS : shaderChunks.fixCubemapSeamsNonePS); + includes.set("skyboxHDRPS", shaderChunks.skyboxHDRPS); + } else { + includes.set("sphericalPS", shaderChunks.sphericalPS); + includes.set("envAtlasPS", shaderChunks.envAtlasPS); + includes.set("skyboxEnvPS", shaderChunks.skyboxEnvPS); + } + return ShaderUtils.createDefinition(device, { + name: "SkyboxShader", + attributes: { + aPosition: SEMANTIC_POSITION + }, + vertexCode: shaderChunks.skyboxVS, + vertexDefines: defines, + fragmentCode: fShader2, + fragmentDefines: defines, + fragmentIncludes: includes + }); + } +}; +var skybox = new ShaderGeneratorSkybox(); + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/geometry/geometry-utils.js +var calculateNormals = (positions, indices) => { + const triangleCount = indices.length / 3; + const vertexCount = positions.length / 3; + const p12 = new Vec3(); + const p22 = new Vec3(); + const p3 = new Vec3(); + const p1p2 = new Vec3(); + const p1p3 = new Vec3(); + const faceNormal = new Vec3(); + const normals = []; + for (let i = 0; i < positions.length; i++) { + normals[i] = 0; + } + for (let i = 0; i < triangleCount; i++) { + const i1 = indices[i * 3]; + const i2 = indices[i * 3 + 1]; + const i3 = indices[i * 3 + 2]; + p12.set(positions[i1 * 3], positions[i1 * 3 + 1], positions[i1 * 3 + 2]); + p22.set(positions[i2 * 3], positions[i2 * 3 + 1], positions[i2 * 3 + 2]); + p3.set(positions[i3 * 3], positions[i3 * 3 + 1], positions[i3 * 3 + 2]); + p1p2.sub2(p22, p12); + p1p3.sub2(p3, p12); + faceNormal.cross(p1p2, p1p3).normalize(); + normals[i1 * 3] += faceNormal.x; + normals[i1 * 3 + 1] += faceNormal.y; + normals[i1 * 3 + 2] += faceNormal.z; + normals[i2 * 3] += faceNormal.x; + normals[i2 * 3 + 1] += faceNormal.y; + normals[i2 * 3 + 2] += faceNormal.z; + normals[i3 * 3] += faceNormal.x; + normals[i3 * 3 + 1] += faceNormal.y; + normals[i3 * 3 + 2] += faceNormal.z; + } + for (let i = 0; i < vertexCount; i++) { + const nx = normals[i * 3]; + const ny = normals[i * 3 + 1]; + const nz = normals[i * 3 + 2]; + const invLen = 1 / Math.sqrt(nx * nx + ny * ny + nz * nz); + normals[i * 3] *= invLen; + normals[i * 3 + 1] *= invLen; + normals[i * 3 + 2] *= invLen; + } + return normals; +}; +var calculateTangents = (positions, normals, uvs, indices) => { + const triangleCount = indices.length / 3; + const vertexCount = positions.length / 3; + const v1 = new Vec3(); + const v22 = new Vec3(); + const v32 = new Vec3(); + const w1 = new Vec2(); + const w2 = new Vec2(); + const w3 = new Vec2(); + const sdir = new Vec3(); + const tdir = new Vec3(); + const tan1 = new Float32Array(vertexCount * 3); + const tan2 = new Float32Array(vertexCount * 3); + const tangents = []; + for (let i = 0; i < triangleCount; i++) { + const i1 = indices[i * 3]; + const i2 = indices[i * 3 + 1]; + const i3 = indices[i * 3 + 2]; + v1.set(positions[i1 * 3], positions[i1 * 3 + 1], positions[i1 * 3 + 2]); + v22.set(positions[i2 * 3], positions[i2 * 3 + 1], positions[i2 * 3 + 2]); + v32.set(positions[i3 * 3], positions[i3 * 3 + 1], positions[i3 * 3 + 2]); + w1.set(uvs[i1 * 2], uvs[i1 * 2 + 1]); + w2.set(uvs[i2 * 2], uvs[i2 * 2 + 1]); + w3.set(uvs[i3 * 2], uvs[i3 * 2 + 1]); + const x1 = v22.x - v1.x; + const x2 = v32.x - v1.x; + const y1 = v22.y - v1.y; + const y2 = v32.y - v1.y; + const z1 = v22.z - v1.z; + const z2 = v32.z - v1.z; + const s1 = w2.x - w1.x; + const s2 = w3.x - w1.x; + const _t = w2.y - w1.y; + const _t2 = w3.y - w1.y; + const area = s1 * _t2 - s2 * _t; + if (area === 0) { + sdir.set(0, 1, 0); + tdir.set(1, 0, 0); + } else { + const r = 1 / area; + sdir.set((_t2 * x1 - _t * x2) * r, (_t2 * y1 - _t * y2) * r, (_t2 * z1 - _t * z2) * r); + tdir.set((s1 * x2 - s2 * x1) * r, (s1 * y2 - s2 * y1) * r, (s1 * z2 - s2 * z1) * r); + } + tan1[i1 * 3 + 0] += sdir.x; + tan1[i1 * 3 + 1] += sdir.y; + tan1[i1 * 3 + 2] += sdir.z; + tan1[i2 * 3 + 0] += sdir.x; + tan1[i2 * 3 + 1] += sdir.y; + tan1[i2 * 3 + 2] += sdir.z; + tan1[i3 * 3 + 0] += sdir.x; + tan1[i3 * 3 + 1] += sdir.y; + tan1[i3 * 3 + 2] += sdir.z; + tan2[i1 * 3 + 0] += tdir.x; + tan2[i1 * 3 + 1] += tdir.y; + tan2[i1 * 3 + 2] += tdir.z; + tan2[i2 * 3 + 0] += tdir.x; + tan2[i2 * 3 + 1] += tdir.y; + tan2[i2 * 3 + 2] += tdir.z; + tan2[i3 * 3 + 0] += tdir.x; + tan2[i3 * 3 + 1] += tdir.y; + tan2[i3 * 3 + 2] += tdir.z; + } + const t1 = new Vec3(); + const t2 = new Vec3(); + const n = new Vec3(); + const temp = new Vec3(); + for (let i = 0; i < vertexCount; i++) { + n.set(normals[i * 3], normals[i * 3 + 1], normals[i * 3 + 2]); + t1.set(tan1[i * 3], tan1[i * 3 + 1], tan1[i * 3 + 2]); + t2.set(tan2[i * 3], tan2[i * 3 + 1], tan2[i * 3 + 2]); + const ndott = n.dot(t1); + temp.copy(n).mulScalar(ndott); + temp.sub2(t1, temp).normalize(); + tangents[i * 4] = temp.x; + tangents[i * 4 + 1] = temp.y; + tangents[i * 4 + 2] = temp.z; + temp.cross(n, t1); + tangents[i * 4 + 3] = temp.dot(t2) < 0 ? -1 : 1; + } + return tangents; +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/geometry/geometry.js +var Geometry = class { + constructor() { + this.positions = void 0; + this.normals = void 0; + this.colors = void 0; + this.uvs = void 0; + this.uvs1 = void 0; + this.blendIndices = void 0; + this.blendWeights = void 0; + this.tangents = void 0; + this.indices = void 0; + } + calculateNormals() { + this.normals = calculateNormals(this.positions, this.indices); + } + calculateTangents() { + this.tangents = calculateTangents(this.positions, this.normals, this.uvs, this.indices); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/geometry/box-geometry.js +var primitiveUv1Padding = 4 / 64; +var primitiveUv1PaddingScale = 1 - primitiveUv1Padding * 2; +var BoxGeometry = class extends Geometry { + constructor(opts = {}) { + var _opts$halfExtents, _opts$widthSegments, _opts$lengthSegments, _opts$heightSegments, _opts$yOffset; + super(); + const he = (_opts$halfExtents = opts.halfExtents) != null ? _opts$halfExtents : new Vec3(0.5, 0.5, 0.5); + const ws = (_opts$widthSegments = opts.widthSegments) != null ? _opts$widthSegments : 1; + const ls = (_opts$lengthSegments = opts.lengthSegments) != null ? _opts$lengthSegments : 1; + const hs = (_opts$heightSegments = opts.heightSegments) != null ? _opts$heightSegments : 1; + const yOffset = (_opts$yOffset = opts.yOffset) != null ? _opts$yOffset : 0; + const minY = -he.y + yOffset; + const maxY = he.y + yOffset; + const corners = [new Vec3(-he.x, minY, he.z), new Vec3(he.x, minY, he.z), new Vec3(he.x, maxY, he.z), new Vec3(-he.x, maxY, he.z), new Vec3(he.x, minY, -he.z), new Vec3(-he.x, minY, -he.z), new Vec3(-he.x, maxY, -he.z), new Vec3(he.x, maxY, -he.z)]; + const faceAxes = [[0, 1, 3], [4, 5, 7], [3, 2, 6], [1, 0, 4], [1, 4, 2], [5, 0, 6]]; + const faceNormals = [[0, 0, 1], [0, 0, -1], [0, 1, 0], [0, -1, 0], [1, 0, 0], [-1, 0, 0]]; + const sides = { + FRONT: 0, + BACK: 1, + TOP: 2, + BOTTOM: 3, + RIGHT: 4, + LEFT: 5 + }; + const positions = []; + const normals = []; + const uvs = []; + const indices = []; + let vcounter = 0; + const generateFace = (side, uSegments, vSegments) => { + const temp1 = new Vec3(); + const temp2 = new Vec3(); + const temp3 = new Vec3(); + const r = new Vec3(); + for (let i = 0; i <= uSegments; i++) { + for (let j = 0; j <= vSegments; j++) { + temp1.lerp(corners[faceAxes[side][0]], corners[faceAxes[side][1]], i / uSegments); + temp2.lerp(corners[faceAxes[side][0]], corners[faceAxes[side][2]], j / vSegments); + temp3.sub2(temp2, corners[faceAxes[side][0]]); + r.add2(temp1, temp3); + let u = i / uSegments; + let v = j / vSegments; + positions.push(r.x, r.y, r.z); + normals.push(faceNormals[side][0], faceNormals[side][1], faceNormals[side][2]); + uvs.push(u, 1 - v); + u = u * primitiveUv1PaddingScale + primitiveUv1Padding; + v = v * primitiveUv1PaddingScale + primitiveUv1Padding; + u /= 3; + v /= 3; + u += side % 3 / 3; + v += Math.floor(side / 3) / 3; + if (i < uSegments && j < vSegments) { + indices.push(vcounter + vSegments + 1, vcounter + 1, vcounter); + indices.push(vcounter + vSegments + 1, vcounter + vSegments + 2, vcounter + 1); + } + vcounter++; + } + } + }; + generateFace(sides.FRONT, ws, hs); + generateFace(sides.BACK, ws, hs); + generateFace(sides.TOP, ws, ls); + generateFace(sides.BOTTOM, ws, ls); + generateFace(sides.RIGHT, ls, hs); + generateFace(sides.LEFT, ls, hs); + this.positions = positions; + this.normals = normals; + this.uvs = uvs; + this.uvs1 = uvs; + this.indices = indices; + if (opts.calculateTangents) { + this.tangents = calculateTangents(positions, normals, uvs, indices); + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/geometry/sphere-geometry.js +var SphereGeometry = class extends Geometry { + constructor(opts = {}) { + var _opts$radius, _opts$latitudeBands, _opts$longitudeBands; + super(); + const radius = (_opts$radius = opts.radius) != null ? _opts$radius : 0.5; + const latitudeBands = (_opts$latitudeBands = opts.latitudeBands) != null ? _opts$latitudeBands : 16; + const longitudeBands = (_opts$longitudeBands = opts.longitudeBands) != null ? _opts$longitudeBands : 16; + const positions = []; + const normals = []; + const uvs = []; + const indices = []; + for (let lat = 0; lat <= latitudeBands; lat++) { + const theta = lat * Math.PI / latitudeBands; + const sinTheta = Math.sin(theta); + const cosTheta = Math.cos(theta); + for (let lon = 0; lon <= longitudeBands; lon++) { + const phi = lon * 2 * Math.PI / longitudeBands - Math.PI / 2; + const sinPhi = Math.sin(phi); + const cosPhi = Math.cos(phi); + const x2 = cosPhi * sinTheta; + const y2 = cosTheta; + const z2 = sinPhi * sinTheta; + const u = 1 - lon / longitudeBands; + const v = 1 - lat / latitudeBands; + positions.push(x2 * radius, y2 * radius, z2 * radius); + normals.push(x2, y2, z2); + uvs.push(u, 1 - v); + } + } + for (let lat = 0; lat < latitudeBands; ++lat) { + for (let lon = 0; lon < longitudeBands; ++lon) { + const first = lat * (longitudeBands + 1) + lon; + const second = first + longitudeBands + 1; + indices.push(first + 1, second, first); + indices.push(first + 1, second + 1, second); + } + } + this.positions = positions; + this.normals = normals; + this.uvs = uvs; + this.uvs1 = uvs; + this.indices = indices; + if (opts.calculateTangents) { + this.tangents = calculateTangents(positions, normals, uvs, indices); + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/geometry/dome-geometry.js +var DomeGeometry = class extends SphereGeometry { + constructor(opts = {}) { + var _opts$latitudeBands, _opts$longitudeBands; + const radius = 0.5; + const latitudeBands = (_opts$latitudeBands = opts.latitudeBands) != null ? _opts$latitudeBands : 16; + const longitudeBands = (_opts$longitudeBands = opts.longitudeBands) != null ? _opts$longitudeBands : 16; + super({ + radius, + latitudeBands, + longitudeBands + }); + const bottomLimit = 0.1; + const curvatureRadius = 0.95; + const curvatureRadiusSq = curvatureRadius * curvatureRadius; + const positions = this.positions; + for (let i = 0; i < positions.length; i += 3) { + const x2 = positions[i] / radius; + let y2 = positions[i + 1] / radius; + const z2 = positions[i + 2] / radius; + if (y2 < 0) { + y2 *= 0.3; + if (x2 * x2 + z2 * z2 < curvatureRadiusSq) { + y2 = -bottomLimit; + } + } + y2 += bottomLimit; + y2 *= radius; + positions[i + 1] = y2; + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/skybox/sky-geometry.js +var SkyGeometry = class _SkyGeometry { + static create(device, type2) { + switch (type2) { + case SKYTYPE_BOX: + return _SkyGeometry.box(device); + case SKYTYPE_DOME: + return _SkyGeometry.dome(device); + } + return _SkyGeometry.infinite(device); + } + static infinite(device) { + return Mesh.fromGeometry(device, new BoxGeometry(device)); + } + static box(device) { + return Mesh.fromGeometry(device, new BoxGeometry({ + yOffset: 0.5 + })); + } + static dome(device) { + const geom = new DomeGeometry({ + latitudeBands: 50, + longitudeBands: 50 + }); + geom.normals = void 0; + geom.uvs = void 0; + return Mesh.fromGeometry(device, geom); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/skybox/sky-mesh.js +var SkyMesh = class { + constructor(device, scene2, node, texture, type2) { + this.meshInstance = null; + const material = new Material(); + material.name = "SkyMaterial"; + material.getShaderVariant = function(dev, sc, defs, unused, pass, sortedLights, viewUniformFormat, viewBindGroupFormat) { + const options = { + pass, + encoding: texture.encoding, + gamma: pass === SHADER_FORWARDHDR ? scene2.gammaCorrection ? GAMMA_SRGBHDR : GAMMA_NONE : scene2.gammaCorrection, + toneMapping: pass === SHADER_FORWARDHDR ? TONEMAP_LINEAR : scene2.toneMapping, + skymesh: type2 + }; + if (texture.cubemap) { + options.type = "cubemap"; + options.mip = texture.fixCubemapSeams ? scene2.skyboxMip : 0; + options.fixSeams = texture.fixCubemapSeams; + } else { + options.type = "envAtlas"; + } + const processingOptions = new ShaderProcessorOptions(viewUniformFormat, viewBindGroupFormat); + const library = getProgramLibrary(device); + library.register("skybox", skybox); + return library.getProgram("skybox", options, processingOptions); + }; + if (texture.cubemap) { + material.setParameter("texture_cubeMap", texture); + } else { + material.setParameter("texture_envAtlas", texture); + material.setParameter("mipLevel", scene2._skyboxMip); + } + material.cull = CULLFACE_FRONT; + material.depthWrite = false; + const skyLayer = scene2.layers.getLayerById(LAYERID_SKYBOX); + if (skyLayer) { + const mesh = SkyGeometry.create(device, type2); + const meshInstance = new MeshInstance(mesh, material, node); + this.meshInstance = meshInstance; + meshInstance.cull = false; + meshInstance.pick = false; + skyLayer.addMeshInstances([meshInstance]); + this.skyLayer = skyLayer; + } + } + destroy() { + if (this.meshInstance) { + if (this.skyLayer) { + this.skyLayer.removeMeshInstances([this.meshInstance]); + } + this.meshInstance.destroy(); + this.meshInstance = null; + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/skybox/sky.js +var Sky = class { + constructor(scene2) { + this._type = SKYTYPE_INFINITE; + this._center = new Vec3(0, 1, 0); + this.skyMesh = null; + this.node = new GraphNode("SkyMeshNode"); + this.device = scene2.device; + this.scene = scene2; + this.center = new Vec3(0, 1, 0); + this.centerArray = new Float32Array(3); + this.projectedSkydomeCenterId = this.device.scope.resolve("projectedSkydomeCenter"); + } + applySettings(render) { + var _render$skyType, _render$skyMeshPositi, _render$skyMeshRotati, _render$skyMeshScale; + this.type = (_render$skyType = render.skyType) != null ? _render$skyType : SKYTYPE_INFINITE; + this.node.setLocalPosition(new Vec3((_render$skyMeshPositi = render.skyMeshPosition) != null ? _render$skyMeshPositi : [0, 0, 0])); + this.node.setLocalEulerAngles(new Vec3((_render$skyMeshRotati = render.skyMeshRotation) != null ? _render$skyMeshRotati : [0, 0, 0])); + this.node.setLocalScale(new Vec3((_render$skyMeshScale = render.skyMeshScale) != null ? _render$skyMeshScale : [1, 1, 1])); + if (render.skyCenter) { + this._center = new Vec3(render.skyCenter); + } + } + set type(value) { + if (this._type !== value) { + this._type = value; + this.scene.updateShaders = true; + this.updateSkyMesh(); + } + } + get type() { + return this._type; + } + set center(value) { + this._center.copy(value); + } + get center() { + return this._center; + } + updateSkyMesh() { + const texture = this.scene._getSkyboxTex(); + if (texture) { + this.resetSkyMesh(); + this.skyMesh = new SkyMesh(this.device, this.scene, this.node, texture, this.type); + this.scene.fire("set:skybox", texture); + } + } + resetSkyMesh() { + var _this$skyMesh; + (_this$skyMesh = this.skyMesh) == null || _this$skyMesh.destroy(); + this.skyMesh = null; + } + update() { + if (this.type !== SKYTYPE_INFINITE) { + const { + center: center2, + centerArray + } = this; + const temp = new Vec3(); + this.node.getWorldTransform().transformPoint(center2, temp); + centerArray[0] = temp.x; + centerArray[1] = temp.y; + centerArray[2] = temp.z; + this.projectedSkydomeCenterId.setValue(centerArray); + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/immediate/immediate-batch.js +var identityGraphNode = new GraphNode(); +identityGraphNode.worldTransform = Mat4.IDENTITY; +identityGraphNode._dirtyWorld = identityGraphNode._dirtyNormal = false; +var ImmediateBatch = class { + constructor(device, material, layer) { + this.material = material; + this.layer = layer; + this.positions = []; + this.colors = []; + this.mesh = new Mesh(device); + this.meshInstance = null; + } + addLines(positions, color) { + const destPos = this.positions; + const count = positions.length; + for (let i = 0; i < count; i++) { + const pos = positions[i]; + destPos.push(pos.x, pos.y, pos.z); + } + const destCol = this.colors; + if (color.length) { + for (let i = 0; i < count; i++) { + const col = color[i]; + destCol.push(col.r, col.g, col.b, col.a); + } + } else { + for (let i = 0; i < count; i++) { + destCol.push(color.r, color.g, color.b, color.a); + } + } + } + addLinesArrays(positions, color) { + const destPos = this.positions; + for (let i = 0; i < positions.length; i += 3) { + destPos.push(positions[i], positions[i + 1], positions[i + 2]); + } + const destCol = this.colors; + if (color.length) { + for (let i = 0; i < color.length; i += 4) { + destCol.push(color[i], color[i + 1], color[i + 2], color[i + 3]); + } + } else { + const count = positions.length / 3; + for (let i = 0; i < count; i++) { + destCol.push(color.r, color.g, color.b, color.a); + } + } + } + onPreRender(visibleList, transparent) { + if (this.positions.length > 0 && this.material.transparent === transparent) { + this.mesh.setPositions(this.positions); + this.mesh.setColors(this.colors); + this.mesh.update(PRIMITIVE_LINES, false); + if (!this.meshInstance) { + this.meshInstance = new MeshInstance(this.mesh, this.material, identityGraphNode); + } + visibleList.push(this.meshInstance); + } + } + clear() { + this.positions.length = 0; + this.colors.length = 0; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/immediate/immediate-batches.js +var ImmediateBatches = class { + constructor(device) { + this.device = device; + this.map = /* @__PURE__ */ new Map(); + } + getBatch(material, layer) { + let batch = this.map.get(material); + if (!batch) { + batch = new ImmediateBatch(this.device, material, layer); + this.map.set(material, batch); + } + return batch; + } + onPreRender(visibleList, transparent) { + this.map.forEach((batch) => { + batch.onPreRender(visibleList, transparent); + }); + } + clear() { + this.map.forEach((batch) => batch.clear()); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/immediate/immediate.js +var tempPoints = []; +var vec = new Vec3(); +var Immediate = class { + constructor(device) { + this.device = device; + this.quadMesh = null; + this.textureShader = null; + this.depthTextureShader = null; + this.cubeLocalPos = null; + this.cubeWorldPos = null; + this.batchesMap = /* @__PURE__ */ new Map(); + this.allBatches = /* @__PURE__ */ new Set(); + this.updatedLayers = /* @__PURE__ */ new Set(); + this._materialDepth = null; + this._materialNoDepth = null; + this.layerMeshInstances = /* @__PURE__ */ new Map(); + } + createMaterial(depthTest) { + const material = new BasicMaterial(); + material.vertexColors = true; + material.blendType = BLEND_NORMAL; + material.depthTest = depthTest; + material.update(); + return material; + } + get materialDepth() { + if (!this._materialDepth) { + this._materialDepth = this.createMaterial(true); + } + return this._materialDepth; + } + get materialNoDepth() { + if (!this._materialNoDepth) { + this._materialNoDepth = this.createMaterial(false); + } + return this._materialNoDepth; + } + getBatch(layer, depthTest) { + let batches = this.batchesMap.get(layer); + if (!batches) { + batches = new ImmediateBatches(this.device); + this.batchesMap.set(layer, batches); + } + this.allBatches.add(batches); + const material = depthTest ? this.materialDepth : this.materialNoDepth; + return batches.getBatch(material, layer); + } + getShader(id12, fragment) { + if (!this[id12]) { + const vertex = ` + attribute vec2 vertex_position; + uniform mat4 matrix_model; + varying vec2 uv0; + void main(void) { + gl_Position = matrix_model * vec4(vertex_position, 0, 1); + uv0 = vertex_position.xy + 0.5; + } + `; + this[id12] = createShaderFromCode(this.device, vertex, fragment, `DebugShader:${id12}`); + } + return this[id12]; + } + getTextureShader() { + return this.getShader("textureShader", ` + varying vec2 uv0; + uniform sampler2D colorMap; + void main (void) { + gl_FragColor = vec4(texture2D(colorMap, uv0).xyz, 1); + } + `); + } + getUnfilterableTextureShader() { + return this.getShader("textureShaderUnfilterable", ` + varying vec2 uv0; + uniform highp sampler2D colorMap; + void main (void) { + ivec2 uv = ivec2(uv0 * textureSize(colorMap, 0)); + gl_FragColor = vec4(texelFetch(colorMap, uv, 0).xyz, 1); + } + `); + } + getDepthTextureShader() { + return this.getShader("depthTextureShader", ` + ${shaderChunks.screenDepthPS} + varying vec2 uv0; + void main() { + float depth = getLinearScreenDepth(getImageEffectUV(uv0)) * camera_params.x; + gl_FragColor = vec4(vec3(depth), 1.0); + } + `); + } + getQuadMesh() { + if (!this.quadMesh) { + this.quadMesh = new Mesh(this.device); + this.quadMesh.setPositions([-0.5, -0.5, 0, 0.5, -0.5, 0, -0.5, 0.5, 0, 0.5, 0.5, 0]); + this.quadMesh.update(PRIMITIVE_TRISTRIP); + } + return this.quadMesh; + } + drawMesh(material, matrix2, mesh, meshInstance, layer) { + if (!meshInstance) { + const graphNode = this.getGraphNode(matrix2); + meshInstance = new MeshInstance(mesh, material, graphNode); + } + let layerMeshInstances = this.layerMeshInstances.get(layer); + if (!layerMeshInstances) { + layerMeshInstances = []; + this.layerMeshInstances.set(layer, layerMeshInstances); + } + layerMeshInstances.push(meshInstance); + } + drawWireAlignedBox(min, max, color, depthTest, layer, mat) { + if (mat) { + const mulPoint = (x2, y2, z2) => { + vec.set(x2, y2, z2); + mat.transformPoint(vec, vec); + tempPoints.push(vec.x, vec.y, vec.z); + }; + mulPoint(min.x, min.y, min.z); + mulPoint(min.x, max.y, min.z); + mulPoint(min.x, max.y, min.z); + mulPoint(max.x, max.y, min.z); + mulPoint(max.x, max.y, min.z); + mulPoint(max.x, min.y, min.z); + mulPoint(max.x, min.y, min.z); + mulPoint(min.x, min.y, min.z); + mulPoint(min.x, min.y, max.z); + mulPoint(min.x, max.y, max.z); + mulPoint(min.x, max.y, max.z); + mulPoint(max.x, max.y, max.z); + mulPoint(max.x, max.y, max.z); + mulPoint(max.x, min.y, max.z); + mulPoint(max.x, min.y, max.z); + mulPoint(min.x, min.y, max.z); + mulPoint(min.x, min.y, min.z); + mulPoint(min.x, min.y, max.z); + mulPoint(min.x, max.y, min.z); + mulPoint(min.x, max.y, max.z); + mulPoint(max.x, max.y, min.z); + mulPoint(max.x, max.y, max.z); + mulPoint(max.x, min.y, min.z); + mulPoint(max.x, min.y, max.z); + } else { + tempPoints.push(min.x, min.y, min.z, min.x, max.y, min.z, min.x, max.y, min.z, max.x, max.y, min.z, max.x, max.y, min.z, max.x, min.y, min.z, max.x, min.y, min.z, min.x, min.y, min.z, min.x, min.y, max.z, min.x, max.y, max.z, min.x, max.y, max.z, max.x, max.y, max.z, max.x, max.y, max.z, max.x, min.y, max.z, max.x, min.y, max.z, min.x, min.y, max.z, min.x, min.y, min.z, min.x, min.y, max.z, min.x, max.y, min.z, min.x, max.y, max.z, max.x, max.y, min.z, max.x, max.y, max.z, max.x, min.y, min.z, max.x, min.y, max.z); + } + const batch = this.getBatch(layer, depthTest); + batch.addLinesArrays(tempPoints, color); + tempPoints.length = 0; + } + drawWireSphere(center2, radius, color, numSegments, depthTest, layer) { + const step = 2 * Math.PI / numSegments; + let angle = 0; + for (let i = 0; i < numSegments; i++) { + const sin0 = Math.sin(angle); + const cos0 = Math.cos(angle); + angle += step; + const sin1 = Math.sin(angle); + const cos1 = Math.cos(angle); + tempPoints.push(center2.x + radius * sin0, center2.y, center2.z + radius * cos0); + tempPoints.push(center2.x + radius * sin1, center2.y, center2.z + radius * cos1); + tempPoints.push(center2.x + radius * sin0, center2.y + radius * cos0, center2.z); + tempPoints.push(center2.x + radius * sin1, center2.y + radius * cos1, center2.z); + tempPoints.push(center2.x, center2.y + radius * sin0, center2.z + radius * cos0); + tempPoints.push(center2.x, center2.y + radius * sin1, center2.z + radius * cos1); + } + const batch = this.getBatch(layer, depthTest); + batch.addLinesArrays(tempPoints, color); + tempPoints.length = 0; + } + getGraphNode(matrix2) { + const graphNode = new GraphNode("ImmediateDebug"); + graphNode.worldTransform = matrix2; + graphNode._dirtyWorld = graphNode._dirtyNormal = false; + return graphNode; + } + onPreRenderLayer(layer, visibleList, transparent) { + this.batchesMap.forEach((batches, batchLayer) => { + if (batchLayer === layer) { + batches.onPreRender(visibleList, transparent); + } + }); + if (!this.updatedLayers.has(layer)) { + this.updatedLayers.add(layer); + const meshInstances = this.layerMeshInstances.get(layer); + if (meshInstances) { + for (let i = 0; i < meshInstances.length; i++) { + visibleList.push(meshInstances[i]); + } + meshInstances.length = 0; + } + } + } + onPostRender() { + this.allBatches.forEach((batch) => batch.clear()); + this.allBatches.clear(); + this.updatedLayers.clear(); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/core/math/random.js +var _goldenAngle = 2.399963229728653; +var random = { + circlePoint(point) { + const r = Math.sqrt(Math.random()); + const theta = Math.random() * 2 * Math.PI; + point.x = r * Math.cos(theta); + point.y = r * Math.sin(theta); + }, + circlePointDeterministic(point, index, numPoints) { + const theta = index * _goldenAngle; + const r = Math.sqrt(index) / Math.sqrt(numPoints); + point.x = r * Math.cos(theta); + point.y = r * Math.sin(theta); + }, + spherePointDeterministic(point, index, numPoints, start = 0, end = 1) { + start = 1 - 2 * start; + end = 1 - 2 * end; + const y2 = math.lerp(start, end, index / numPoints); + const radius = Math.sqrt(1 - y2 * y2); + const theta = _goldenAngle * index; + point.x = Math.cos(theta) * radius; + point.y = y2; + point.z = Math.sin(theta) * radius; + }, + radicalInverse(i) { + let bits = (i << 16 | i >>> 16) >>> 0; + bits = ((bits & 1431655765) << 1 | (bits & 2863311530) >>> 1) >>> 0; + bits = ((bits & 858993459) << 2 | (bits & 3435973836) >>> 2) >>> 0; + bits = ((bits & 252645135) << 4 | (bits & 4042322160) >>> 4) >>> 0; + bits = ((bits & 16711935) << 8 | (bits & 4278255360) >>> 8) >>> 0; + return bits * 23283064365386963e-26; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/graphics/reproject-texture.js +var getProjectionName = (projection) => { + switch (projection) { + case TEXTUREPROJECTION_CUBE: + return "Cubemap"; + case TEXTUREPROJECTION_OCTAHEDRAL: + return "Octahedral"; + default: + return "Equirect"; + } +}; +var packFloat32ToRGBA8 = (value, array2, offset) => { + if (value <= 0) { + array2[offset + 0] = 0; + array2[offset + 1] = 0; + array2[offset + 2] = 0; + array2[offset + 3] = 0; + } else if (value >= 1) { + array2[offset + 0] = 255; + array2[offset + 1] = 0; + array2[offset + 2] = 0; + array2[offset + 3] = 0; + } else { + let encX = 1 * value % 1; + let encY = 255 * value % 1; + let encZ = 65025 * value % 1; + const encW = 16581375 * value % 1; + encX -= encY / 255; + encY -= encZ / 255; + encZ -= encW / 255; + array2[offset + 0] = Math.min(255, Math.floor(encX * 256)); + array2[offset + 1] = Math.min(255, Math.floor(encY * 256)); + array2[offset + 2] = Math.min(255, Math.floor(encZ * 256)); + array2[offset + 3] = Math.min(255, Math.floor(encW * 256)); + } +}; +var packSamples = (samples) => { + const numSamples = samples.length; + const w = Math.min(numSamples, 512); + const h = Math.ceil(numSamples / w); + const data2 = new Uint8Array(w * h * 4); + let off = 0; + for (let i = 0; i < numSamples; i += 4) { + packFloat32ToRGBA8(samples[i + 0] * 0.5 + 0.5, data2, off + 0); + packFloat32ToRGBA8(samples[i + 1] * 0.5 + 0.5, data2, off + 4); + packFloat32ToRGBA8(samples[i + 2] * 0.5 + 0.5, data2, off + 8); + packFloat32ToRGBA8(samples[i + 3] / 8, data2, off + 12); + off += 16; + } + return { + width: w, + height: h, + data: data2 + }; +}; +var hemisphereSamplePhong = (dstVec, x2, y2, specularPower) => { + const phi = y2 * 2 * Math.PI; + const cosTheta = Math.pow(1 - x2, 1 / (specularPower + 1)); + const sinTheta = Math.sqrt(1 - cosTheta * cosTheta); + dstVec.set(Math.cos(phi) * sinTheta, Math.sin(phi) * sinTheta, cosTheta).normalize(); +}; +var hemisphereSampleLambert = (dstVec, x2, y2) => { + const phi = y2 * 2 * Math.PI; + const cosTheta = Math.sqrt(1 - x2); + const sinTheta = Math.sqrt(x2); + dstVec.set(Math.cos(phi) * sinTheta, Math.sin(phi) * sinTheta, cosTheta).normalize(); +}; +var hemisphereSampleGGX = (dstVec, x2, y2, a) => { + const phi = y2 * 2 * Math.PI; + const cosTheta = Math.sqrt((1 - x2) / (1 + (a * a - 1) * x2)); + const sinTheta = Math.sqrt(1 - cosTheta * cosTheta); + dstVec.set(Math.cos(phi) * sinTheta, Math.sin(phi) * sinTheta, cosTheta).normalize(); +}; +var D_GGX = (NoH, linearRoughness) => { + const a = NoH * linearRoughness; + const k = linearRoughness / (1 - NoH * NoH + a * a); + return k * k * (1 / Math.PI); +}; +var generatePhongSamples = (numSamples, specularPower) => { + const H = new Vec3(); + const result = []; + for (let i = 0; i < numSamples; ++i) { + hemisphereSamplePhong(H, i / numSamples, random.radicalInverse(i), specularPower); + result.push(H.x, H.y, H.z, 0); + } + return result; +}; +var generateLambertSamples = (numSamples, sourceTotalPixels) => { + const pixelsPerSample = sourceTotalPixels / numSamples; + const H = new Vec3(); + const result = []; + for (let i = 0; i < numSamples; ++i) { + hemisphereSampleLambert(H, i / numSamples, random.radicalInverse(i)); + const pdf = H.z / Math.PI; + const mipLevel = 0.5 * Math.log2(pixelsPerSample / pdf); + result.push(H.x, H.y, H.z, mipLevel); + } + return result; +}; +var requiredSamplesGGX = { + "16": { + "2": 26, + "8": 20, + "32": 17, + "128": 16, + "512": 16 + }, + "32": { + "2": 53, + "8": 40, + "32": 34, + "128": 32, + "512": 32 + }, + "128": { + "2": 214, + "8": 163, + "32": 139, + "128": 130, + "512": 128 + }, + "1024": { + "2": 1722, + "8": 1310, + "32": 1114, + "128": 1041, + "512": 1025 + } +}; +var getRequiredSamplesGGX = (numSamples, specularPower) => { + const table = requiredSamplesGGX[numSamples]; + return table && table[specularPower] || numSamples; +}; +var generateGGXSamples = (numSamples, specularPower, sourceTotalPixels) => { + const pixelsPerSample = sourceTotalPixels / numSamples; + const roughness = 1 - Math.log2(specularPower) / 11; + const a = roughness * roughness; + const H = new Vec3(); + const L = new Vec3(); + const N = new Vec3(0, 0, 1); + const result = []; + const requiredSamples = getRequiredSamplesGGX(numSamples, specularPower); + for (let i = 0; i < requiredSamples; ++i) { + hemisphereSampleGGX(H, i / requiredSamples, random.radicalInverse(i), a); + const NoH = H.z; + L.set(H.x, H.y, H.z).mulScalar(2 * NoH).sub(N); + if (L.z > 0) { + const pdf = D_GGX(Math.min(1, NoH), a) / 4 + 1e-3; + const mipLevel = 0.5 * Math.log2(pixelsPerSample / pdf); + result.push(L.x, L.y, L.z, mipLevel); + } + } + while (result.length < numSamples * 4) { + result.push(0, 0, 0, 0); + } + return result; +}; +var createSamplesTex = (device, name, samples) => { + const packedSamples = packSamples(samples); + return new Texture(device, { + name, + width: packedSamples.width, + height: packedSamples.height, + mipmaps: false, + minFilter: FILTER_NEAREST, + magFilter: FILTER_NEAREST, + levels: [packedSamples.data] + }); +}; +var SimpleCache = class { + constructor(destroyContent = true) { + this.map = /* @__PURE__ */ new Map(); + this.destroyContent = destroyContent; + } + destroy() { + if (this.destroyContent) { + this.map.forEach((value, key) => { + value.destroy(); + }); + } + } + get(key, missFunc) { + if (!this.map.has(key)) { + const result = missFunc(); + this.map.set(key, result); + return result; + } + return this.map.get(key); + } +}; +var samplesCache = new SimpleCache(false); +var deviceCache2 = new DeviceCache(); +var getCachedTexture = (device, key, getSamplesFnc) => { + const cache = deviceCache2.get(device, () => { + return new SimpleCache(); + }); + return cache.get(key, () => { + return createSamplesTex(device, key, samplesCache.get(key, getSamplesFnc)); + }); +}; +var generateLambertSamplesTex = (device, numSamples, sourceTotalPixels) => { + const key = `lambert-samples-${numSamples}-${sourceTotalPixels}`; + return getCachedTexture(device, key, () => { + return generateLambertSamples(numSamples, sourceTotalPixels); + }); +}; +var generatePhongSamplesTex = (device, numSamples, specularPower) => { + const key = `phong-samples-${numSamples}-${specularPower}`; + return getCachedTexture(device, key, () => { + return generatePhongSamples(numSamples, specularPower); + }); +}; +var generateGGXSamplesTex = (device, numSamples, specularPower, sourceTotalPixels) => { + const key = `ggx-samples-${numSamples}-${specularPower}-${sourceTotalPixels}`; + return getCachedTexture(device, key, () => { + return generateGGXSamples(numSamples, specularPower, sourceTotalPixels); + }); +}; +var vsCode = ` +attribute vec2 vertex_position; + +uniform vec4 uvMod; + +varying vec2 vUv0; + +void main(void) { + gl_Position = vec4(vertex_position, 0.5, 1.0); + vUv0 = getImageEffectUV((vertex_position.xy * 0.5 + 0.5) * uvMod.xy + uvMod.zw); +} +`; +function reprojectTexture(source, target2, options = {}) { + var _options$seamPixels, _options$rect$z, _options$rect, _options$rect$w, _options$rect2; + if (source instanceof GraphicsDevice) { + source = arguments[1]; + target2 = arguments[2]; + options = {}; + if (arguments[3] !== void 0) { + options.specularPower = arguments[3]; + } + if (arguments[4] !== void 0) { + options.numSamples = arguments[4]; + } + } + const seamPixels = (_options$seamPixels = options.seamPixels) != null ? _options$seamPixels : 0; + const innerWidth = ((_options$rect$z = (_options$rect = options.rect) == null ? void 0 : _options$rect.z) != null ? _options$rect$z : target2.width) - seamPixels * 2; + const innerHeight = ((_options$rect$w = (_options$rect2 = options.rect) == null ? void 0 : _options$rect2.w) != null ? _options$rect$w : target2.height) - seamPixels * 2; + if (innerWidth < 1 || innerHeight < 1) { + return false; + } + const funcNames = { + "none": "reproject", + "lambert": "prefilterSamplesUnweighted", + "phong": "prefilterSamplesUnweighted", + "ggx": "prefilterSamples" + }; + const specularPower = options.hasOwnProperty("specularPower") ? options.specularPower : 1; + const face = options.hasOwnProperty("face") ? options.face : null; + const distribution = options.hasOwnProperty("distribution") ? options.distribution : specularPower === 1 ? "none" : "phong"; + const processFunc = funcNames[distribution] || "reproject"; + const prefilterSamples = processFunc.startsWith("prefilterSamples"); + const decodeFunc = ChunkUtils.decodeFunc(source.encoding); + const encodeFunc = ChunkUtils.encodeFunc(target2.encoding); + const sourceFunc = `sample${getProjectionName(source.projection)}`; + const targetFunc = `getDirection${getProjectionName(target2.projection)}`; + const numSamples = options.hasOwnProperty("numSamples") ? options.numSamples : 1024; + const shaderKey = `${processFunc}_${decodeFunc}_${encodeFunc}_${sourceFunc}_${targetFunc}_${numSamples}`; + const device = source.device; + let shader = getProgramLibrary(device).getCachedShader(shaderKey); + if (!shader) { + const defines = `#define PROCESS_FUNC ${processFunc} +` + (prefilterSamples ? `#define USE_SAMPLES_TEX +` : "") + (source.cubemap ? `#define CUBEMAP_SOURCE +` : "") + `#define DECODE_FUNC ${decodeFunc} +#define ENCODE_FUNC ${encodeFunc} +#define SOURCE_FUNC ${sourceFunc} +#define TARGET_FUNC ${targetFunc} +#define NUM_SAMPLES ${numSamples} +#define NUM_SAMPLES_SQRT ${Math.round(Math.sqrt(numSamples)).toFixed(1)} +`; + shader = createShaderFromCode(device, vsCode, `${defines} +${shaderChunks.reprojectPS}`, shaderKey); + } + device.setBlendState(BlendState.NOBLEND); + const constantSource = device.scope.resolve(source.cubemap ? "sourceCube" : "sourceTex"); + constantSource.setValue(source); + const constantParams = device.scope.resolve("params"); + device.scope.resolve("params2"); + const uvModParam = device.scope.resolve("uvMod"); + if (seamPixels > 0) { + uvModParam.setValue([(innerWidth + seamPixels * 2) / innerWidth, (innerHeight + seamPixels * 2) / innerHeight, -seamPixels / innerWidth, -seamPixels / innerHeight]); + } else { + uvModParam.setValue([1, 1, 0, 0]); + } + const params = [0, source.fixCubemapSeams ? 1 / source.width : 0, target2.fixCubemapSeams ? 1 / target2.width : 0]; + if (prefilterSamples) { + const sourceTotalPixels = source.width * source.height * (source.cubemap ? 6 : 1); + const samplesTex = distribution === "ggx" ? generateGGXSamplesTex(device, numSamples, specularPower, sourceTotalPixels) : distribution === "lambert" ? generateLambertSamplesTex(device, numSamples, sourceTotalPixels) : generatePhongSamplesTex(device, numSamples, specularPower); + device.scope.resolve("samplesTex").setValue(samplesTex); + device.scope.resolve("samplesTexInverseSize").setValue([1 / samplesTex.width, 1 / samplesTex.height]); + } + for (let f = 0; f < (target2.cubemap ? 6 : 1); f++) { + if (face === null || f === face) { + var _options; + const renderTarget = new RenderTarget({ + colorBuffer: target2, + face: f, + depth: false, + flipY: device.isWebGPU + }); + params[0] = f; + constantParams.setValue(params); + drawQuadWithShader(device, renderTarget, shader, (_options = options) == null ? void 0 : _options.rect); + renderTarget.destroy(); + } + } + return true; +} + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/graphics/env-lighting.js +var fixCubemapSeams = true; +var calcLevels = (width, height = 0) => { + return 1 + Math.floor(Math.log2(Math.max(width, height))); +}; +var supportsFloat16 = (device) => { + return device.extTextureHalfFloat && device.textureHalfFloatRenderable; +}; +var supportsFloat32 = (device) => { + return device.extTextureFloat && device.textureFloatRenderable; +}; +var lightingSourcePixelFormat = (device) => { + return supportsFloat16(device) ? PIXELFORMAT_RGBA16F : supportsFloat32(device) ? PIXELFORMAT_RGBA32F : PIXELFORMAT_RGBA8; +}; +var lightingPixelFormat = (device) => { + return PIXELFORMAT_RGBA8; +}; +var createCubemap = (device, size, format, mipmaps) => { + return new Texture(device, { + name: `lighting-${size}`, + cubemap: true, + width: size, + height: size, + format, + type: format === PIXELFORMAT_RGBA8 ? TEXTURETYPE_RGBP : TEXTURETYPE_DEFAULT, + addressU: ADDRESS_CLAMP_TO_EDGE, + addressV: ADDRESS_CLAMP_TO_EDGE, + fixCubemapSeams, + mipmaps: !!mipmaps + }); +}; +var EnvLighting = class { + static generateSkyboxCubemap(source, size) { + const device = source.device; + const result = createCubemap(device, size || (source.cubemap ? source.width : source.width / 4), PIXELFORMAT_RGBA8, false); + reprojectTexture(source, result, { + numSamples: 1024 + }); + return result; + } + static generateLightingSource(source, options) { + const device = source.device; + const format = lightingSourcePixelFormat(device); + const result = (options == null ? void 0 : options.target) || new Texture(device, { + name: `lighting-source`, + cubemap: true, + width: (options == null ? void 0 : options.size) || 128, + height: (options == null ? void 0 : options.size) || 128, + format, + type: format === PIXELFORMAT_RGBA8 ? TEXTURETYPE_RGBP : TEXTURETYPE_DEFAULT, + addressU: ADDRESS_CLAMP_TO_EDGE, + addressV: ADDRESS_CLAMP_TO_EDGE, + fixCubemapSeams: false, + mipmaps: true + }); + reprojectTexture(source, result, { + numSamples: source.mipmaps ? 1 : 1024 + }); + return result; + } + static generateAtlas(source, options) { + const device = source.device; + const format = lightingPixelFormat(); + const result = (options == null ? void 0 : options.target) || new Texture(device, { + name: "envAtlas", + width: (options == null ? void 0 : options.size) || 512, + height: (options == null ? void 0 : options.size) || 512, + format, + type: TEXTURETYPE_RGBP, + projection: TEXTUREPROJECTION_EQUIRECT, + addressU: ADDRESS_CLAMP_TO_EDGE, + addressV: ADDRESS_CLAMP_TO_EDGE, + mipmaps: false + }); + const s = result.width / 512; + const rect = new Vec4(0, 0, 512 * s, 256 * s); + const levels = calcLevels(256) - calcLevels(4); + for (let i = 0; i < levels; ++i) { + reprojectTexture(source, result, { + numSamples: 1, + rect, + seamPixels: s + }); + rect.x += rect.w; + rect.y += rect.w; + rect.z = Math.max(1, Math.floor(rect.z * 0.5)); + rect.w = Math.max(1, Math.floor(rect.w * 0.5)); + } + rect.set(0, 256 * s, 256 * s, 128 * s); + for (let i = 1; i < 7; ++i) { + reprojectTexture(source, result, { + numSamples: (options == null ? void 0 : options.numReflectionSamples) || 1024, + distribution: (options == null ? void 0 : options.distribution) || "ggx", + specularPower: Math.max(1, 2048 >> i * 2), + rect, + seamPixels: s + }); + rect.y += rect.w; + rect.z = Math.max(1, Math.floor(rect.z * 0.5)); + rect.w = Math.max(1, Math.floor(rect.w * 0.5)); + } + rect.set(128 * s, (256 + 128) * s, 64 * s, 32 * s); + reprojectTexture(source, result, { + numSamples: (options == null ? void 0 : options.numAmbientSamples) || 2048, + distribution: "lambert", + rect, + seamPixels: s + }); + return result; + } + static generatePrefilteredAtlas(sources, options) { + const device = sources[0].device; + const format = sources[0].format; + const type2 = sources[0].type; + const result = (options == null ? void 0 : options.target) || new Texture(device, { + name: "envPrefilteredAtlas", + width: (options == null ? void 0 : options.size) || 512, + height: (options == null ? void 0 : options.size) || 512, + format, + type: type2, + projection: TEXTUREPROJECTION_EQUIRECT, + addressU: ADDRESS_CLAMP_TO_EDGE, + addressV: ADDRESS_CLAMP_TO_EDGE, + mipmaps: false + }); + const s = result.width / 512; + const rect = new Vec4(0, 0, 512 * s, 256 * s); + const levels = calcLevels(512); + for (let i = 0; i < levels; ++i) { + reprojectTexture(sources[0], result, { + numSamples: 1, + rect, + seamPixels: s + }); + rect.x += rect.w; + rect.y += rect.w; + rect.z = Math.max(1, Math.floor(rect.z * 0.5)); + rect.w = Math.max(1, Math.floor(rect.w * 0.5)); + } + rect.set(0, 256 * s, 256 * s, 128 * s); + for (let i = 1; i < sources.length; ++i) { + reprojectTexture(sources[i], result, { + numSamples: 1, + rect, + seamPixels: s + }); + rect.y += rect.w; + rect.z = Math.max(1, Math.floor(rect.z * 0.5)); + rect.w = Math.max(1, Math.floor(rect.w * 0.5)); + } + rect.set(128 * s, (256 + 128) * s, 64 * s, 32 * s); + if (options != null && options.legacyAmbient) { + reprojectTexture(sources[5], result, { + numSamples: 1, + rect, + seamPixels: s + }); + } else { + reprojectTexture(sources[0], result, { + numSamples: (options == null ? void 0 : options.numSamples) || 2048, + distribution: "lambert", + rect, + seamPixels: s + }); + } + return result; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/scene.js +var Scene = class extends EventHandler { + constructor(graphicsDevice) { + super(); + this.ambientBake = false; + this.ambientBakeOcclusionBrightness = 0; + this.ambientBakeOcclusionContrast = 0; + this.ambientLight = new Color(0, 0, 0); + this.ambientLuminance = 0; + this.exposure = 1; + this.fogColor = new Color(0, 0, 0); + this.fogDensity = 0; + this.fogEnd = 1e3; + this.fogStart = 1; + this.lightmapSizeMultiplier = 1; + this.lightmapMaxResolution = 2048; + this.lightmapMode = BAKE_COLORDIR; + this.lightmapFilterEnabled = false; + this.lightmapHDR = false; + this.root = null; + this.physicalUnits = false; + this._envAtlas = null; + this._skyboxCubeMap = null; + this.device = graphicsDevice; + this._gravity = new Vec3(0, -9.8, 0); + this._layers = null; + this._fog = FOG_NONE; + this._gammaCorrection = GAMMA_SRGB; + this._toneMapping = 0; + this._prefilteredCubemaps = []; + this._internalEnvAtlas = null; + this._skyboxIntensity = 1; + this._skyboxLuminance = 0; + this._skyboxMip = 0; + this._skyboxRotationShaderInclude = false; + this._skyboxRotation = new Quat2(); + this._skyboxRotationMat3 = new Mat3(); + this._skyboxRotationMat4 = new Mat4(); + this._ambientBakeNumSamples = 1; + this._ambientBakeSpherePart = 0.4; + this._lightmapFilterRange = 10; + this._lightmapFilterSmoothness = 0.2; + this._clusteredLightingEnabled = true; + this._lightingParams = new LightingParams(this.device.supportsAreaLights, this.device.maxTextureSize, () => { + this.updateShaders = true; + }); + this._sky = new Sky(this); + this._stats = { + meshInstances: 0, + lights: 0, + dynamicLights: 0, + bakedLights: 0, + updateShadersTime: 0 + }; + this.updateShaders = true; + this._shaderVersion = 0; + this.immediate = new Immediate(this.device); + } + get defaultDrawLayer() { + return this.layers.getLayerById(LAYERID_IMMEDIATE); + } + set ambientBakeNumSamples(value) { + this._ambientBakeNumSamples = math.clamp(Math.floor(value), 1, 255); + } + get ambientBakeNumSamples() { + return this._ambientBakeNumSamples; + } + set ambientBakeSpherePart(value) { + this._ambientBakeSpherePart = math.clamp(value, 1e-3, 1); + } + get ambientBakeSpherePart() { + return this._ambientBakeSpherePart; + } + set clusteredLightingEnabled(value) { + if (this.device.isWebGPU && !value) { + return; + } + if (!this._clusteredLightingEnabled && value) { + console.error("Turning on disabled clustered lighting is not currently supported"); + return; + } + this._clusteredLightingEnabled = value; + } + get clusteredLightingEnabled() { + return this._clusteredLightingEnabled; + } + set envAtlas(value) { + if (value !== this._envAtlas) { + this._envAtlas = value; + if (value) { + value.addressU = ADDRESS_CLAMP_TO_EDGE; + value.addressV = ADDRESS_CLAMP_TO_EDGE; + value.minFilter = FILTER_LINEAR; + value.magFilter = FILTER_LINEAR; + value.mipmaps = false; + } + this._prefilteredCubemaps = []; + if (this._internalEnvAtlas) { + this._internalEnvAtlas.destroy(); + this._internalEnvAtlas = null; + } + this._resetSkyMesh(); + } + } + get envAtlas() { + return this._envAtlas; + } + set fog(type2) { + if (type2 !== this._fog) { + this._fog = type2; + this.updateShaders = true; + } + } + get fog() { + return this._fog; + } + set gammaCorrection(value) { + if (value !== this._gammaCorrection) { + this._gammaCorrection = value; + this.updateShaders = true; + } + } + get gammaCorrection() { + return this._gammaCorrection; + } + set layers(layers) { + const prev = this._layers; + this._layers = layers; + this.fire("set:layers", prev, layers); + } + get layers() { + return this._layers; + } + get sky() { + return this._sky; + } + get lighting() { + return this._lightingParams; + } + set lightmapFilterRange(value) { + this._lightmapFilterRange = Math.max(value, 1e-3); + } + get lightmapFilterRange() { + return this._lightmapFilterRange; + } + set lightmapFilterSmoothness(value) { + this._lightmapFilterSmoothness = Math.max(value, 1e-3); + } + get lightmapFilterSmoothness() { + return this._lightmapFilterSmoothness; + } + set prefilteredCubemaps(value) { + value = value || []; + const cubemaps = this._prefilteredCubemaps; + const changed = cubemaps.length !== value.length || cubemaps.some((c2, i) => c2 !== value[i]); + if (changed) { + const complete = value.length === 6 && value.every((c2) => !!c2); + if (complete) { + this._internalEnvAtlas = EnvLighting.generatePrefilteredAtlas(value, { + target: this._internalEnvAtlas + }); + this._envAtlas = this._internalEnvAtlas; + } else { + if (this._internalEnvAtlas) { + this._internalEnvAtlas.destroy(); + this._internalEnvAtlas = null; + } + this._envAtlas = null; + } + this._prefilteredCubemaps = value.slice(); + this._resetSkyMesh(); + } + } + get prefilteredCubemaps() { + return this._prefilteredCubemaps; + } + set skybox(value) { + if (value !== this._skyboxCubeMap) { + this._skyboxCubeMap = value; + this._resetSkyMesh(); + } + } + get skybox() { + return this._skyboxCubeMap; + } + set skyboxIntensity(value) { + if (value !== this._skyboxIntensity) { + this._skyboxIntensity = value; + this._resetSkyMesh(); + } + } + get skyboxIntensity() { + return this._skyboxIntensity; + } + set skyboxLuminance(value) { + if (value !== this._skyboxLuminance) { + this._skyboxLuminance = value; + this._resetSkyMesh(); + } + } + get skyboxLuminance() { + return this._skyboxLuminance; + } + set skyboxMip(value) { + if (value !== this._skyboxMip) { + this._skyboxMip = value; + this._resetSkyMesh(); + } + } + get skyboxMip() { + return this._skyboxMip; + } + set skyboxRotation(value) { + if (!this._skyboxRotation.equals(value)) { + const isIdentity = value.equals(Quat2.IDENTITY); + this._skyboxRotation.copy(value); + if (isIdentity) { + this._skyboxRotationMat3.setIdentity(); + } else { + this._skyboxRotationMat4.setTRS(Vec3.ZERO, value, Vec3.ONE); + this._skyboxRotationMat3.invertMat4(this._skyboxRotationMat4); + } + if (!this._skyboxRotationShaderInclude && !isIdentity) { + this._skyboxRotationShaderInclude = true; + this._resetSkyMesh(); + } + } + } + get skyboxRotation() { + return this._skyboxRotation; + } + set toneMapping(value) { + if (value !== this._toneMapping) { + this._toneMapping = value; + this.updateShaders = true; + } + } + get toneMapping() { + return this._toneMapping; + } + destroy() { + this._resetSkyMesh(); + this.root = null; + this.off(); + } + drawLine(start, end, color = Color.WHITE, depthTest = true, layer = this.defaultDrawLayer) { + const batch = this.immediate.getBatch(layer, depthTest); + batch.addLines([start, end], [color, color]); + } + drawLines(positions, colors, depthTest = true, layer = this.defaultDrawLayer) { + const batch = this.immediate.getBatch(layer, depthTest); + batch.addLines(positions, colors); + } + drawLineArrays(positions, colors, depthTest = true, layer = this.defaultDrawLayer) { + const batch = this.immediate.getBatch(layer, depthTest); + batch.addLinesArrays(positions, colors); + } + applySettings(settings) { + var _render$skyboxIntensi, _render$skyboxLuminan, _render$skyboxMip, _render$clusteredLigh; + const physics = settings.physics; + const render = settings.render; + this._gravity.set(physics.gravity[0], physics.gravity[1], physics.gravity[2]); + this.ambientLight.set(render.global_ambient[0], render.global_ambient[1], render.global_ambient[2]); + this.ambientLuminance = render.ambientLuminance; + this._fog = render.fog; + this.fogColor.set(render.fog_color[0], render.fog_color[1], render.fog_color[2]); + this.fogStart = render.fog_start; + this.fogEnd = render.fog_end; + this.fogDensity = render.fog_density; + this._gammaCorrection = render.gamma_correction; + this._toneMapping = render.tonemapping; + this.lightmapSizeMultiplier = render.lightmapSizeMultiplier; + this.lightmapMaxResolution = render.lightmapMaxResolution; + this.lightmapMode = render.lightmapMode; + this.exposure = render.exposure; + this._skyboxIntensity = (_render$skyboxIntensi = render.skyboxIntensity) != null ? _render$skyboxIntensi : 1; + this._skyboxLuminance = (_render$skyboxLuminan = render.skyboxLuminance) != null ? _render$skyboxLuminan : 2e4; + this._skyboxMip = (_render$skyboxMip = render.skyboxMip) != null ? _render$skyboxMip : 0; + if (render.skyboxRotation) { + this.skyboxRotation = new Quat2().setFromEulerAngles(render.skyboxRotation[0], render.skyboxRotation[1], render.skyboxRotation[2]); + } + this.sky.applySettings(render); + this.clusteredLightingEnabled = (_render$clusteredLigh = render.clusteredLightingEnabled) != null ? _render$clusteredLigh : false; + this.lighting.applySettings(render); + ["lightmapFilterEnabled", "lightmapFilterRange", "lightmapFilterSmoothness", "ambientBake", "ambientBakeNumSamples", "ambientBakeSpherePart", "ambientBakeOcclusionBrightness", "ambientBakeOcclusionContrast"].forEach((setting) => { + if (render.hasOwnProperty(setting)) { + this[setting] = render[setting]; + } + }); + this._resetSkyMesh(); + } + _getSkyboxTex() { + const cubemaps = this._prefilteredCubemaps; + if (this._skyboxMip) { + const skyboxMapping = [0, 1, 3, 4, 5, 6]; + return cubemaps[skyboxMapping[this._skyboxMip]] || this._envAtlas || cubemaps[0] || this._skyboxCubeMap; + } + return this._skyboxCubeMap || cubemaps[0] || this._envAtlas; + } + _updateSkyMesh() { + if (!this.sky.skyMesh) { + this.sky.updateSkyMesh(); + } + this.sky.update(); + } + _resetSkyMesh() { + this.sky.resetSkyMesh(); + this.updateShaders = true; + } + setSkybox(cubemaps) { + if (!cubemaps) { + this.skybox = null; + this.envAtlas = null; + } else { + this.skybox = cubemaps[0] || null; + if (cubemaps[1] && !cubemaps[1].cubemap) { + this.envAtlas = cubemaps[1]; + } else { + this.prefilteredCubemaps = cubemaps.slice(1); + } + } + } + get lightmapPixelFormat() { + return this.lightmapHDR && this.device.getRenderableHdrFormat() || PIXELFORMAT_RGBA8; + } +}; +Scene.EVENT_SETLAYERS = "set:layers"; +Scene.EVENT_SETSKYBOX = "set:skybox"; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/skin.js +var Skin = class { + constructor(graphicsDevice, ibp, boneNames) { + this.device = graphicsDevice; + this.inverseBindPose = ibp; + this.boneNames = boneNames; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/materials/standard-material-options.js +var StandardMaterialOptions = class { + constructor() { + this.forceUv1 = false; + this.ambientTint = false; + this.diffuseTint = false; + this.specularTint = false; + this.metalnessTint = false; + this.glossTint = false; + this.emissiveTint = false; + this.opacityTint = false; + this.emissiveEncoding = "linear"; + this.lightMapEncoding = "linear"; + this.packedNormal = false; + this.glossInvert = false; + this.sheenGlossInvert = false; + this.clearCoatGlossInvert = false; + this.litOptions = new LitShaderOptions(); + } + get pass() { + return this.litOptions.pass; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/programs/standard.js +var _matTex2D = []; +var buildPropertiesList = (options) => { + return Object.keys(options).filter((key) => key !== "litOptions").sort(); +}; +var ShaderGeneratorStandard = class extends ShaderGenerator { + constructor(...args) { + super(...args); + this.optionsContext = new StandardMaterialOptions(); + this.optionsContextMin = new StandardMaterialOptions(); + } + generateKey(options) { + let props; + if (options === this.optionsContextMin) { + if (!this.propsMin) this.propsMin = buildPropertiesList(options); + props = this.propsMin; + } else if (options === this.optionsContext) { + if (!this.props) this.props = buildPropertiesList(options); + props = this.props; + } else { + props = buildPropertiesList(options); + } + const key = "standard:\n" + props.map((prop) => prop + options[prop]).join("\n") + LitOptionsUtils.generateKey(options.litOptions); + return key; + } + _getUvSourceExpression(transformPropName, uVPropName, options) { + const transformId = options[transformPropName]; + const uvChannel = options[uVPropName]; + const isMainPass = options.litOptions.pass === SHADER_FORWARD || options.litOptions.pass === SHADER_FORWARDHDR; + let expression; + if (isMainPass && options.litOptions.nineSlicedMode === SPRITE_RENDERMODE_SLICED) { + expression = "nineSlicedUv"; + } else if (isMainPass && options.litOptions.nineSlicedMode === SPRITE_RENDERMODE_TILED) { + expression = "nineSlicedUv"; + } else { + if (transformId === 0) { + expression = "vUv" + uvChannel; + } else { + expression = "vUV" + uvChannel + "_" + transformId; + } + if (options.heightMap && transformPropName !== "heightMapTransform") { + expression += " + dUvOffset"; + } + } + return expression; + } + _addMapDef(name, enabled) { + return enabled ? `#define ${name} +` : `#undef ${name} +`; + } + _addMapDefs(float, color, vertex, map, invert) { + return this._addMapDef("MAPFLOAT", float) + this._addMapDef("MAPCOLOR", color) + this._addMapDef("MAPVERTEX", vertex) + this._addMapDef("MAPTEXTURE", map) + this._addMapDef("MAPINVERT", invert); + } + _addMap(propName, chunkName, options, chunks, mapping, encoding = null) { + const mapPropName = propName + "Map"; + const uVPropName = mapPropName + "Uv"; + const identifierPropName = mapPropName + "Identifier"; + const transformPropName = mapPropName + "Transform"; + const channelPropName = mapPropName + "Channel"; + const vertexColorChannelPropName = propName + "VertexColorChannel"; + const tintPropName = propName + "Tint"; + const vertexColorPropName = propName + "VertexColor"; + const detailModePropName = propName + "Mode"; + const invertName = propName + "Invert"; + const tintOption = options[tintPropName]; + const vertexColorOption = options[vertexColorPropName]; + const textureOption = options[mapPropName]; + const textureIdentifier = options[identifierPropName]; + const detailModeOption = options[detailModePropName]; + let subCode = chunks[chunkName]; + if (textureOption) { + const uv = this._getUvSourceExpression(transformPropName, uVPropName, options); + subCode = subCode.replace(/\$UV/g, uv).replace(/\$CH/g, options[channelPropName]); + if (mapping && subCode.search(/\$SAMPLER/g) !== -1) { + let samplerName = "texture_" + mapPropName; + const alias = mapping[textureIdentifier]; + if (alias) { + samplerName = alias; + } else { + mapping[textureIdentifier] = samplerName; + } + subCode = subCode.replace(/\$SAMPLER/g, samplerName); + } + if (encoding) { + if (options[channelPropName] === "aaa") { + subCode = subCode.replace(/\$DECODE/g, "passThrough"); + } else { + subCode = subCode.replace(/\$DECODE/g, ChunkUtils.decodeFunc(!options.litOptions.gamma && encoding === "srgb" ? "linear" : encoding)); + } + if (subCode.indexOf("$texture2DSAMPLE")) { + const decodeTable2 = { + linear: "texture2D", + srgb: "texture2DSRGB", + rgbm: "texture2DRGBM", + rgbe: "texture2DRGBE" + }; + subCode = subCode.replace(/\$texture2DSAMPLE/g, decodeTable2[encoding] || "texture2D"); + } + } + } + if (vertexColorOption) { + subCode = subCode.replace(/\$VC/g, options[vertexColorChannelPropName]); + } + if (detailModeOption) { + subCode = subCode.replace(/\$DETAILMODE/g, detailModeOption); + } + const isFloatTint = !!(tintOption & 1); + const isVecTint = !!(tintOption & 2); + const invertOption = !!options[invertName]; + subCode = this._addMapDefs(isFloatTint, isVecTint, vertexColorOption, textureOption, invertOption) + subCode; + return subCode.replace(/\$/g, ""); + } + _correctChannel(p, chan, _matTex2D2) { + if (_matTex2D2[p] > 0) { + if (_matTex2D2[p] < chan.length) { + return chan.substring(0, _matTex2D2[p]); + } else if (_matTex2D2[p] > chan.length) { + let str = chan; + const chr = str.charAt(str.length - 1); + const addLen = _matTex2D2[p] - str.length; + for (let i = 0; i < addLen; i++) str += chr; + return str; + } + return chan; + } + } + createShaderDefinition(device, options) { + const shaderPassInfo = ShaderPass.get(device).getByIndex(options.litOptions.pass); + const isForwardPass = shaderPassInfo.isForward; + const litShader = new LitShader(device, options.litOptions); + const useUv = []; + const useUnmodifiedUv = []; + const mapTransforms = []; + const maxUvSets = 2; + const textureMapping = {}; + for (const p in _matTex2D) { + const mname = p + "Map"; + if (options[p + "VertexColor"]) { + const cname = p + "VertexColorChannel"; + options[cname] = this._correctChannel(p, options[cname], _matTex2D); + } + if (options[mname]) { + const cname = mname + "Channel"; + const tname = mname + "Transform"; + const uname = mname + "Uv"; + options[uname] = Math.min(options[uname], maxUvSets - 1); + options[cname] = this._correctChannel(p, options[cname], _matTex2D); + const uvSet = options[uname]; + useUv[uvSet] = true; + useUnmodifiedUv[uvSet] = useUnmodifiedUv[uvSet] || options[mname] && !options[tname]; + if (options[tname]) { + mapTransforms.push({ + name: p, + id: options[tname], + uv: options[uname] + }); + } + } + } + if (options.forceUv1) { + useUv[1] = true; + useUnmodifiedUv[1] = useUnmodifiedUv[1] !== void 0 ? useUnmodifiedUv[1] : true; + } + litShader.generateVertexShader(useUv, useUnmodifiedUv, mapTransforms); + if (options.litOptions.shadingModel === SPECULAR_PHONG) { + options.litOptions.fresnelModel = 0; + options.litOptions.ambientSH = false; + } else { + options.litOptions.fresnelModel = options.litOptions.fresnelModel === 0 ? FRESNEL_SCHLICK : options.litOptions.fresnelModel; + } + const decl = new ChunkBuilder(); + const code = new ChunkBuilder(); + const func = new ChunkBuilder(); + const args = new ChunkBuilder(); + let lightingUv = ""; + if (options.litOptions.nineSlicedMode === SPRITE_RENDERMODE_TILED) { + decl.append(`const float textureBias = -1000.0;`); + } else { + decl.append(`uniform float textureBias;`); + } + if (isForwardPass) { + if (options.heightMap) { + decl.append("vec2 dUvOffset;"); + code.append(this._addMap("height", "parallaxPS", options, litShader.chunks, textureMapping)); + func.append("getParallax();"); + } + if (options.litOptions.blendType !== BLEND_NONE || options.litOptions.alphaTest || options.litOptions.alphaToCoverage || options.litOptions.opacityDither !== DITHER_NONE) { + decl.append("float dAlpha;"); + code.append(this._addMap("opacity", "opacityPS", options, litShader.chunks, textureMapping)); + func.append("getOpacity();"); + args.append("litArgs_opacity = dAlpha;"); + if (options.litOptions.alphaTest) { + code.append(litShader.chunks.alphaTestPS); + func.append("alphaTest(dAlpha);"); + } + const opacityDither = options.litOptions.opacityDither; + if (opacityDither !== DITHER_NONE) { + if (opacityDither === DITHER_BAYER8) decl.append(litShader.chunks.bayerPS); + decl.append(`#define DITHER_${opacityDither.toUpperCase()} +`); + decl.append(litShader.chunks.opacityDitherPS); + func.append("opacityDither(dAlpha, 0.0);"); + } + } else { + decl.append("float dAlpha = 1.0;"); + } + if (litShader.needsNormal) { + if (options.normalMap || options.clearCoatNormalMap) { + code.append(options.packedNormal ? litShader.chunks.normalXYPS : litShader.chunks.normalXYZPS); + if (!options.litOptions.hasTangents) { + const baseName = options.normalMap ? "normalMap" : "clearCoatNormalMap"; + lightingUv = this._getUvSourceExpression(`${baseName}Transform`, `${baseName}Uv`, options); + } + } + decl.append("vec3 dNormalW;"); + code.append(this._addMap("normalDetail", "normalDetailMapPS", options, litShader.chunks, textureMapping)); + code.append(this._addMap("normal", "normalMapPS", options, litShader.chunks, textureMapping)); + func.append("getNormal();"); + args.append("litArgs_worldNormal = dNormalW;"); + } + if (litShader.needsSceneColor) { + decl.append("uniform sampler2D uSceneColorMap;"); + } + if (litShader.needsScreenSize) { + decl.append("uniform vec4 uScreenSize;"); + } + if (litShader.needsTransforms) { + decl.append("uniform mat4 matrix_viewProjection;"); + decl.append("uniform mat4 matrix_model;"); + } + if (options.diffuseDetail || options.aoDetail) { + code.append(litShader.chunks.detailModesPS); + } + decl.append("vec3 dAlbedo;"); + if (options.diffuseDetail) { + code.append(this._addMap("diffuseDetail", "diffuseDetailMapPS", options, litShader.chunks, textureMapping, options.diffuseDetailEncoding)); + } + code.append(this._addMap("diffuse", "diffusePS", options, litShader.chunks, textureMapping, options.diffuseEncoding)); + func.append("getAlbedo();"); + args.append("litArgs_albedo = dAlbedo;"); + if (options.litOptions.useRefraction) { + decl.append("float dTransmission;"); + code.append(this._addMap("refraction", "transmissionPS", options, litShader.chunks, textureMapping)); + func.append("getRefraction();"); + args.append("litArgs_transmission = dTransmission;"); + decl.append("float dThickness;"); + code.append(this._addMap("thickness", "thicknessPS", options, litShader.chunks, textureMapping)); + func.append("getThickness();"); + args.append("litArgs_thickness = dThickness;"); + if (options.litOptions.dispersion) { + args.append("litArgs_dispersion = material_dispersion;"); + } + } + if (options.litOptions.useIridescence) { + decl.append("float dIridescence;"); + code.append(this._addMap("iridescence", "iridescencePS", options, litShader.chunks, textureMapping)); + func.append("getIridescence();"); + args.append("litArgs_iridescence_intensity = dIridescence;"); + decl.append("float dIridescenceThickness;"); + code.append(this._addMap("iridescenceThickness", "iridescenceThicknessPS", options, litShader.chunks, textureMapping)); + func.append("getIridescenceThickness();"); + args.append("litArgs_iridescence_thickness = dIridescenceThickness;"); + } + if (litShader.lighting && options.litOptions.useSpecular || litShader.reflections) { + decl.append("vec3 dSpecularity;"); + decl.append("float dGlossiness;"); + if (options.litOptions.useSheen) { + decl.append("vec3 sSpecularity;"); + code.append(this._addMap("sheen", "sheenPS", options, litShader.chunks, textureMapping, options.sheenEncoding)); + func.append("getSheen();"); + args.append("litArgs_sheen_specularity = sSpecularity;"); + decl.append("float sGlossiness;"); + code.append(this._addMap("sheenGloss", "sheenGlossPS", options, litShader.chunks, textureMapping)); + func.append("getSheenGlossiness();"); + args.append("litArgs_sheen_gloss = sGlossiness;"); + } + if (options.litOptions.useMetalness) { + decl.append("float dMetalness;"); + code.append(this._addMap("metalness", "metalnessPS", options, litShader.chunks, textureMapping)); + func.append("getMetalness();"); + args.append("litArgs_metalness = dMetalness;"); + decl.append("float dIor;"); + code.append(this._addMap("ior", "iorPS", options, litShader.chunks, textureMapping)); + func.append("getIor();"); + args.append("litArgs_ior = dIor;"); + } + if (options.litOptions.useSpecularityFactor) { + decl.append("float dSpecularityFactor;"); + code.append(this._addMap("specularityFactor", "specularityFactorPS", options, litShader.chunks, textureMapping)); + func.append("getSpecularityFactor();"); + args.append("litArgs_specularityFactor = dSpecularityFactor;"); + } + if (options.useSpecularColor) { + code.append(this._addMap("specular", "specularPS", options, litShader.chunks, textureMapping, options.specularEncoding)); + } else { + code.append("void getSpecularity() { dSpecularity = vec3(1); }"); + } + code.append(this._addMap("gloss", "glossPS", options, litShader.chunks, textureMapping)); + func.append("getGlossiness();"); + func.append("getSpecularity();"); + args.append("litArgs_specularity = dSpecularity;"); + args.append("litArgs_gloss = dGlossiness;"); + } else { + decl.append("vec3 dSpecularity = vec3(0.0);"); + decl.append("float dGlossiness = 0.0;"); + } + if (options.aoDetail) { + code.append(this._addMap("aoDetail", "aoDetailMapPS", options, litShader.chunks, textureMapping)); + } + if (options.aoMap || options.aoVertexColor) { + decl.append("float dAo;"); + code.append(this._addMap("ao", "aoPS", options, litShader.chunks, textureMapping)); + func.append("getAO();"); + args.append("litArgs_ao = dAo;"); + } + decl.append("vec3 dEmission;"); + code.append(this._addMap("emissive", "emissivePS", options, litShader.chunks, textureMapping, options.emissiveEncoding)); + func.append("getEmission();"); + args.append("litArgs_emission = dEmission;"); + if (options.litOptions.useClearCoat) { + decl.append("float ccSpecularity;"); + decl.append("float ccGlossiness;"); + decl.append("vec3 ccNormalW;"); + code.append(this._addMap("clearCoat", "clearCoatPS", options, litShader.chunks, textureMapping)); + code.append(this._addMap("clearCoatGloss", "clearCoatGlossPS", options, litShader.chunks, textureMapping)); + code.append(this._addMap("clearCoatNormal", "clearCoatNormalPS", options, litShader.chunks, textureMapping)); + func.append("getClearCoat();"); + func.append("getClearCoatGlossiness();"); + func.append("getClearCoatNormal();"); + args.append("litArgs_clearcoat_specularity = ccSpecularity;"); + args.append("litArgs_clearcoat_gloss = ccGlossiness;"); + args.append("litArgs_clearcoat_worldNormal = ccNormalW;"); + } + if (options.lightMap || options.lightVertexColor) { + const lightmapDir = options.dirLightMap && options.litOptions.useSpecular; + const lightmapChunkPropName = lightmapDir ? "lightmapDirPS" : "lightmapSinglePS"; + decl.append("vec3 dLightmap;"); + if (lightmapDir) { + decl.append("vec3 dLightmapDir;"); + } + code.append(this._addMap("light", lightmapChunkPropName, options, litShader.chunks, textureMapping, options.lightMapEncoding)); + func.append("getLightMap();"); + args.append("litArgs_lightmap = dLightmap;"); + if (lightmapDir) { + args.append("litArgs_lightmapDir = dLightmapDir;"); + } + } + if (code.code.indexOf("texture2DSRGB") !== -1 || code.code.indexOf("texture2DRGBM") !== -1 || code.code.indexOf("texture2DRGBE") !== -1) { + code.prepend(litShader.chunks.textureSamplePS); + } + } else { + const opacityShadowDither = options.litOptions.opacityShadowDither; + if (options.litOptions.alphaTest || opacityShadowDither) { + decl.append("float dAlpha;"); + code.append(this._addMap("opacity", "opacityPS", options, litShader.chunks, textureMapping)); + func.append("getOpacity();"); + args.append("litArgs_opacity = dAlpha;"); + if (options.litOptions.alphaTest) { + code.append(litShader.chunks.alphaTestPS); + func.append("alphaTest(dAlpha);"); + } + if (opacityShadowDither !== DITHER_NONE) { + if (opacityShadowDither === DITHER_BAYER8) decl.append(litShader.chunks.bayerPS); + decl.append(`#define DITHER_${opacityShadowDither.toUpperCase()} +`); + decl.append(litShader.chunks.opacityDitherPS); + func.append("opacityDither(dAlpha, 0.0);"); + } + } + } + decl.append(litShader.chunks.litShaderArgsPS); + code.append(`void evaluateFrontend() { +${func.code} +${args.code} + } +`); + func.code = `evaluateFrontend();`; + for (const texture in textureMapping) { + decl.append(`uniform sampler2D ${textureMapping[texture]};`); + } + func.code = ` +${func.code.split("\n").map((l) => ` ${l}`).join("\n")} + +`; + litShader.generateFragmentShader(decl.code, code.code, func.code, lightingUv); + return litShader.getDefinition(); + } +}; +var standard = new ShaderGeneratorStandard(); + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/materials/standard-material-options-builder.js +var arraysEqual = (a, b) => { + if (a.length !== b.length) { + return false; + } + for (let i = 0; i < a.length; ++i) { + if (a[i] !== b[i]) { + return false; + } + } + return true; +}; +var notWhite = (color) => { + return color.r !== 1 || color.g !== 1 || color.b !== 1; +}; +var notBlack = (color) => { + return color.r !== 0 || color.g !== 0 || color.b !== 0; +}; +var StandardMaterialOptionsBuilder = class { + constructor() { + this._mapXForms = null; + } + updateMinRef(options, scene2, stdMat, objDefs, pass, sortedLights) { + this._updateSharedOptions(options, scene2, stdMat, objDefs, pass); + this._updateMinOptions(options, stdMat, pass); + this._updateUVOptions(options, stdMat, objDefs, true); + } + updateRef(options, scene2, stdMat, objDefs, pass, sortedLights) { + this._updateSharedOptions(options, scene2, stdMat, objDefs, pass); + this._updateEnvOptions(options, stdMat, scene2); + this._updateMaterialOptions(options, stdMat); + if (pass === SHADER_FORWARDHDR) { + if (options.litOptions.gamma) options.litOptions.gamma = GAMMA_SRGBHDR; + options.litOptions.toneMap = TONEMAP_LINEAR; + } + options.litOptions.hasTangents = objDefs && (objDefs & SHADERDEF_TANGENTS) !== 0; + this._updateLightOptions(options, scene2, stdMat, objDefs, sortedLights); + this._updateUVOptions(options, stdMat, objDefs, false); + } + _updateSharedOptions(options, scene2, stdMat, objDefs, pass) { + options.forceUv1 = stdMat.forceUv1; + if (stdMat.userAttributes) { + options.litOptions.userAttributes = Object.fromEntries(stdMat.userAttributes.entries()); + } + options.litOptions.chunks = stdMat.chunks || {}; + options.litOptions.pass = pass; + options.litOptions.alphaTest = stdMat.alphaTest > 0; + options.litOptions.blendType = stdMat.blendType; + options.litOptions.screenSpace = objDefs && (objDefs & SHADERDEF_SCREENSPACE) !== 0; + options.litOptions.skin = objDefs && (objDefs & SHADERDEF_SKIN) !== 0; + options.litOptions.useInstancing = objDefs && (objDefs & SHADERDEF_INSTANCING) !== 0; + options.litOptions.useMorphPosition = objDefs && (objDefs & SHADERDEF_MORPH_POSITION) !== 0; + options.litOptions.useMorphNormal = objDefs && (objDefs & SHADERDEF_MORPH_NORMAL) !== 0; + options.litOptions.useMorphTextureBased = objDefs && (objDefs & SHADERDEF_MORPH_TEXTURE_BASED) !== 0; + options.litOptions.nineSlicedMode = stdMat.nineSlicedMode || 0; + if (scene2.clusteredLightingEnabled && stdMat.useLighting) { + options.litOptions.clusteredLightingEnabled = true; + options.litOptions.clusteredLightingCookiesEnabled = scene2.lighting.cookiesEnabled; + options.litOptions.clusteredLightingShadowsEnabled = scene2.lighting.shadowsEnabled; + options.litOptions.clusteredLightingShadowType = scene2.lighting.shadowType; + options.litOptions.clusteredLightingAreaLightsEnabled = scene2.lighting.areaLightsEnabled; + } else { + options.litOptions.clusteredLightingEnabled = false; + options.litOptions.clusteredLightingCookiesEnabled = false; + options.litOptions.clusteredLightingShadowsEnabled = false; + options.litOptions.clusteredLightingAreaLightsEnabled = false; + } + } + _updateUVOptions(options, stdMat, objDefs, minimalOptions) { + let hasUv0 = false; + let hasUv1 = false; + let hasVcolor = false; + if (objDefs) { + hasUv0 = (objDefs & SHADERDEF_UV0) !== 0; + hasUv1 = (objDefs & SHADERDEF_UV1) !== 0; + hasVcolor = (objDefs & SHADERDEF_VCOLOR) !== 0; + } + options.litOptions.vertexColors = false; + this._mapXForms = []; + const uniqueTextureMap = {}; + for (const p in _matTex2D) { + this._updateTexOptions(options, stdMat, p, hasUv0, hasUv1, hasVcolor, minimalOptions, uniqueTextureMap); + } + this._mapXForms = null; + options.litOptions.lightMapEnabled = options.lightMap; + options.litOptions.dirLightMapEnabled = options.dirLightMap; + options.litOptions.useHeights = options.heightMap; + options.litOptions.useNormals = options.normalMap; + options.litOptions.useClearCoatNormals = options.clearCoatNormalMap; + options.litOptions.useAo = options.aoMap || options.aoVertexColor; + options.litOptions.diffuseMapEnabled = options.diffuseMap; + } + _updateTexOptions(options, stdMat, p, hasUv0, hasUv1, hasVcolor, minimalOptions, uniqueTextureMap) { + const isOpacity = p === "opacity"; + if (!minimalOptions || isOpacity) { + const mname = p + "Map"; + const vname = p + "VertexColor"; + const vcname = p + "VertexColorChannel"; + const cname = mname + "Channel"; + const tname = mname + "Transform"; + const uname = mname + "Uv"; + const iname = mname + "Identifier"; + if (p !== "light") { + options[mname] = false; + options[iname] = void 0; + options[cname] = ""; + options[tname] = 0; + options[uname] = 0; + } + options[vname] = false; + options[vcname] = ""; + if (isOpacity && stdMat.blendType === BLEND_NONE && stdMat.alphaTest === 0 && !stdMat.alphaToCoverage && stdMat.opacityDither === DITHER_NONE) { + return; + } + if (p !== "height" && stdMat[vname]) { + if (hasVcolor) { + options[vname] = stdMat[vname]; + options[vcname] = stdMat[vcname]; + options.litOptions.vertexColors = true; + } + } + if (stdMat[mname]) { + let allow = true; + if (stdMat[uname] === 0 && !hasUv0) allow = false; + if (stdMat[uname] === 1 && !hasUv1) allow = false; + if (allow) { + const mapId = stdMat[mname].id; + let identifier = uniqueTextureMap[mapId]; + if (identifier === void 0) { + uniqueTextureMap[mapId] = p; + identifier = p; + } + options[mname] = !!stdMat[mname]; + options[iname] = identifier; + options[tname] = this._getMapTransformID(stdMat.getUniform(tname), stdMat[uname]); + options[cname] = stdMat[cname]; + options[uname] = stdMat[uname]; + } + } + } + } + _updateMinOptions(options, stdMat, pass) { + options.opacityTint = stdMat.blendType !== BLEND_NONE || stdMat.opacityShadowDither !== DITHER_NONE; + const isPrepass = pass === SHADER_PREPASS_VELOCITY; + options.litOptions.opacityShadowDither = isPrepass ? stdMat.opacityDither : stdMat.opacityShadowDither; + options.litOptions.lights = []; + } + _updateMaterialOptions(options, stdMat) { + var _stdMat$diffuseMap, _stdMat$diffuseDetail, _stdMat$emissiveMap, _stdMat$lightMap; + const diffuseTint = stdMat.diffuseTint || !stdMat.diffuseMap && !stdMat.diffuseVertexColor; + const useSpecular = !!(stdMat.useMetalness || stdMat.specularMap || stdMat.sphereMap || stdMat.cubeMap || notBlack(stdMat.specular) || stdMat.specularityFactor > 0 && stdMat.useMetalness || stdMat.enableGGXSpecular || stdMat.clearCoat > 0); + const useSpecularColor = !stdMat.useMetalness || stdMat.useMetalnessSpecularColor; + const specularTint = useSpecular && (stdMat.specularTint || !stdMat.specularMap && !stdMat.specularVertexColor) && notWhite(stdMat.specular); + const specularityFactorTint = useSpecular && stdMat.useMetalnessSpecularColor && (stdMat.specularityFactorTint || stdMat.specularityFactor < 1 && !stdMat.specularityFactorMap); + const emissiveTintColor = !stdMat.emissiveMap || notWhite(stdMat.emissive) && stdMat.emissiveTint; + const emissiveTintIntensity = stdMat.emissiveIntensity !== 1; + const isPackedNormalMap = stdMat.normalMap ? stdMat.normalMap.format === PIXELFORMAT_DXT5 || stdMat.normalMap.type === TEXTURETYPE_SWIZZLEGGGR : false; + options.opacityTint = stdMat.blendType !== BLEND_NONE || stdMat.alphaTest > 0 || stdMat.opacityDither !== DITHER_NONE ? 1 : 0; + options.ambientTint = stdMat.ambientTint; + options.diffuseTint = diffuseTint ? 2 : 0; + options.specularTint = specularTint ? 2 : 0; + options.specularityFactorTint = specularityFactorTint ? 1 : 0; + options.metalnessTint = stdMat.useMetalness && stdMat.metalness < 1 ? 1 : 0; + options.glossTint = 1; + options.emissiveTint = (emissiveTintColor ? 2 : 0) + (emissiveTintIntensity ? 1 : 0); + options.diffuseEncoding = (_stdMat$diffuseMap = stdMat.diffuseMap) == null ? void 0 : _stdMat$diffuseMap.encoding; + options.diffuseDetailEncoding = (_stdMat$diffuseDetail = stdMat.diffuseDetailMap) == null ? void 0 : _stdMat$diffuseDetail.encoding; + options.emissiveEncoding = (_stdMat$emissiveMap = stdMat.emissiveMap) == null ? void 0 : _stdMat$emissiveMap.encoding; + options.lightMapEncoding = (_stdMat$lightMap = stdMat.lightMap) == null ? void 0 : _stdMat$lightMap.encoding; + options.packedNormal = isPackedNormalMap; + options.refractionTint = stdMat.refraction !== 1 ? 1 : 0; + options.refractionIndexTint = stdMat.refractionIndex !== 1 / 1.5 ? 1 : 0; + options.thicknessTint = stdMat.useDynamicRefraction && stdMat.thickness !== 1 ? 1 : 0; + options.specularEncoding = stdMat.specularEncoding || "linear"; + options.sheenEncoding = stdMat.sheenEncoding || "linear"; + options.aoMapUv = stdMat.aoUvSet; + options.aoDetail = !!stdMat.aoMap; + options.diffuseDetail = !!stdMat.diffuseMap; + options.normalDetail = !!stdMat.normalMap; + options.diffuseDetailMode = stdMat.diffuseDetailMode; + options.aoDetailMode = stdMat.aoDetailMode; + options.clearCoatTint = stdMat.clearCoat !== 1 ? 1 : 0; + options.clearCoatGloss = !!stdMat.clearCoatGloss; + options.clearCoatGlossTint = stdMat.clearCoatGloss !== 1 ? 1 : 0; + options.iorTint = stdMat.refractionIndex !== 1 / 1.5 ? 1 : 0; + options.iridescenceTint = stdMat.iridescence !== 1 ? 1 : 0; + options.sheenTint = stdMat.useSheen && notWhite(stdMat.sheen) ? 2 : 0; + options.sheenGlossTint = 1; + options.glossInvert = stdMat.glossInvert; + options.sheenGlossInvert = stdMat.sheenGlossInvert; + options.clearCoatGlossInvert = stdMat.clearCoatGlossInvert; + options.useSpecularColor = useSpecularColor; + options.litOptions.separateAmbient = false; + options.litOptions.useAmbientTint = stdMat.ambientTint; + options.litOptions.customFragmentShader = stdMat.customFragmentShader; + options.litOptions.pixelSnap = stdMat.pixelSnap; + options.litOptions.shadingModel = stdMat.shadingModel; + options.litOptions.ambientSH = !!stdMat.ambientSH; + options.litOptions.fastTbn = stdMat.fastTbn; + options.litOptions.twoSidedLighting = stdMat.twoSidedLighting; + options.litOptions.occludeSpecular = stdMat.occludeSpecular; + options.litOptions.occludeSpecularFloat = stdMat.occludeSpecularIntensity !== 1; + options.litOptions.useMsdf = !!stdMat.msdfMap; + options.litOptions.msdfTextAttribute = !!stdMat.msdfTextAttribute; + options.litOptions.alphaToCoverage = stdMat.alphaToCoverage; + options.litOptions.opacityFadesSpecular = stdMat.opacityFadesSpecular; + options.litOptions.opacityDither = stdMat.opacityDither; + options.litOptions.cubeMapProjection = stdMat.cubeMapProjection; + options.litOptions.occludeDirect = stdMat.occludeDirect; + options.litOptions.conserveEnergy = stdMat.conserveEnergy && stdMat.shadingModel !== SPECULAR_PHONG; + options.litOptions.useSpecular = useSpecular; + options.litOptions.useSpecularityFactor = (specularityFactorTint || !!stdMat.specularityFactorMap) && stdMat.useMetalnessSpecularColor; + options.litOptions.enableGGXSpecular = stdMat.enableGGXSpecular; + options.litOptions.fresnelModel = stdMat.fresnelModel; + options.litOptions.useRefraction = (stdMat.refraction || !!stdMat.refractionMap) && (stdMat.useDynamicRefraction || !!options.litOptions.reflectionSource); + options.litOptions.useClearCoat = !!stdMat.clearCoat; + options.litOptions.useSheen = stdMat.useSheen; + options.litOptions.useIridescence = stdMat.useIridescence && stdMat.iridescence !== 0; + options.litOptions.useMetalness = stdMat.useMetalness; + options.litOptions.useDynamicRefraction = stdMat.useDynamicRefraction; + options.litOptions.dispersion = stdMat.dispersion > 0; + } + _updateEnvOptions(options, stdMat, scene2) { + options.litOptions.fog = stdMat.useFog ? scene2.fog : "none"; + options.litOptions.gamma = stdMat.useGammaTonemap ? scene2.gammaCorrection : GAMMA_NONE; + options.litOptions.toneMap = stdMat.useGammaTonemap ? scene2.toneMapping : -1; + options.litOptions.fixSeams = stdMat.cubeMap ? stdMat.cubeMap.fixCubemapSeams : false; + const isPhong = stdMat.shadingModel === SPECULAR_PHONG; + let usingSceneEnv = false; + if (stdMat.envAtlas && stdMat.cubeMap && !isPhong) { + options.litOptions.reflectionSource = "envAtlasHQ"; + options.litOptions.reflectionEncoding = stdMat.envAtlas.encoding; + options.litOptions.reflectionCubemapEncoding = stdMat.cubeMap.encoding; + } else if (stdMat.envAtlas && !isPhong) { + options.litOptions.reflectionSource = "envAtlas"; + options.litOptions.reflectionEncoding = stdMat.envAtlas.encoding; + } else if (stdMat.cubeMap) { + options.litOptions.reflectionSource = "cubeMap"; + options.litOptions.reflectionEncoding = stdMat.cubeMap.encoding; + } else if (stdMat.sphereMap) { + options.litOptions.reflectionSource = "sphereMap"; + options.litOptions.reflectionEncoding = stdMat.sphereMap.encoding; + } else if (stdMat.useSkybox && scene2.envAtlas && scene2.skybox && !isPhong) { + options.litOptions.reflectionSource = "envAtlasHQ"; + options.litOptions.reflectionEncoding = scene2.envAtlas.encoding; + options.litOptions.reflectionCubemapEncoding = scene2.skybox.encoding; + usingSceneEnv = true; + } else if (stdMat.useSkybox && scene2.envAtlas && !isPhong) { + options.litOptions.reflectionSource = "envAtlas"; + options.litOptions.reflectionEncoding = scene2.envAtlas.encoding; + usingSceneEnv = true; + } else if (stdMat.useSkybox && scene2.skybox) { + options.litOptions.reflectionSource = "cubeMap"; + options.litOptions.reflectionEncoding = scene2.skybox.encoding; + usingSceneEnv = true; + } else { + options.litOptions.reflectionSource = null; + options.litOptions.reflectionEncoding = null; + } + if (stdMat.ambientSH && !isPhong) { + options.litOptions.ambientSource = "ambientSH"; + options.litOptions.ambientEncoding = null; + } else { + const envAtlas = stdMat.envAtlas || (stdMat.useSkybox && scene2.envAtlas ? scene2.envAtlas : null); + if (envAtlas && !isPhong) { + options.litOptions.ambientSource = "envAtlas"; + options.litOptions.ambientEncoding = envAtlas.encoding; + } else { + options.litOptions.ambientSource = "constant"; + options.litOptions.ambientEncoding = null; + } + } + options.litOptions.skyboxIntensity = usingSceneEnv; + options.litOptions.useCubeMapRotation = usingSceneEnv && scene2._skyboxRotationShaderInclude; + } + _updateLightOptions(options, scene2, stdMat, objDefs, sortedLights) { + options.lightMap = false; + options.lightMapChannel = ""; + options.lightMapUv = 0; + options.lightMapTransform = 0; + options.litOptions.lightMapWithoutAmbient = false; + options.dirLightMap = false; + if (objDefs) { + options.litOptions.noShadow = (objDefs & SHADERDEF_NOSHADOW) !== 0; + if ((objDefs & SHADERDEF_LM) !== 0) { + options.lightMapEncoding = scene2.lightmapPixelFormat === PIXELFORMAT_RGBA8 ? "rgbm" : "linear"; + options.lightMap = true; + options.lightMapChannel = "rgb"; + options.lightMapUv = 1; + options.lightMapTransform = 0; + options.litOptions.lightMapWithoutAmbient = !stdMat.lightMap; + if ((objDefs & SHADERDEF_DIRLM) !== 0) { + options.dirLightMap = true; + } + if ((objDefs & SHADERDEF_LMAMBIENT) !== 0) { + options.litOptions.lightMapWithoutAmbient = false; + } + } + } + if (stdMat.useLighting) { + const lightsFiltered = []; + const mask = objDefs ? objDefs >> 16 : MASK_AFFECT_DYNAMIC; + options.litOptions.lightMaskDynamic = !!(mask & MASK_AFFECT_DYNAMIC); + if (sortedLights) { + LitMaterialOptionsBuilder.collectLights(LIGHTTYPE_DIRECTIONAL, sortedLights[LIGHTTYPE_DIRECTIONAL], lightsFiltered, mask); + LitMaterialOptionsBuilder.collectLights(LIGHTTYPE_OMNI, sortedLights[LIGHTTYPE_OMNI], lightsFiltered, mask); + LitMaterialOptionsBuilder.collectLights(LIGHTTYPE_SPOT, sortedLights[LIGHTTYPE_SPOT], lightsFiltered, mask); + } + options.litOptions.lights = lightsFiltered; + } else { + options.litOptions.lights = []; + } + if (options.litOptions.lights.length === 0) { + options.litOptions.noShadow = true; + } + } + _getMapTransformID(xform, uv) { + if (!xform) return 0; + let xforms = this._mapXForms[uv]; + if (!xforms) { + xforms = []; + this._mapXForms[uv] = xforms; + } + for (let i = 0; i < xforms.length; i++) { + if (arraysEqual(xforms[i][0].value, xform[0].value) && arraysEqual(xforms[i][1].value, xform[1].value)) { + return i + 1; + } + } + return xforms.push(xform); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/materials/standard-material-parameters.js +function _textureParameter(name, channel = true, vertexColor = true) { + const result = {}; + result[`${name}Map`] = "texture"; + result[`${name}MapTiling`] = "vec2"; + result[`${name}MapOffset`] = "vec2"; + result[`${name}MapRotation`] = "number"; + result[`${name}MapUv`] = "number"; + if (channel) { + result[`${name}MapChannel`] = "string"; + if (vertexColor) { + result[`${name}VertexColor`] = "boolean"; + result[`${name}VertexColorChannel`] = "string"; + } + } + return result; +} +var standardMaterialParameterTypes = _extends({ + name: "string", + chunks: "chunks", + mappingFormat: "string", + _engine: "boolean", + ambient: "rgb", + ambientTint: "boolean" +}, _textureParameter("ao"), _textureParameter("aoDetail", true, false), { + aoDetailMode: "string", + diffuse: "rgb", + diffuseTint: "boolean" +}, _textureParameter("diffuse"), _textureParameter("diffuseDetail", true, false), { + diffuseDetailMode: "string", + specular: "rgb", + specularTint: "boolean" +}, _textureParameter("specular"), { + occludeSpecular: "enum:occludeSpecular", + specularityFactor: "number", + specularityFactorTint: "boolean" +}, _textureParameter("specularityFactor"), { + useMetalness: "boolean", + metalness: "number", + enableGGXSpecular: "boolean", + anisotropy: "number", + metalnessTint: "boolean" +}, _textureParameter("metalness"), { + useMetalnessSpecularColor: "boolean", + conserveEnergy: "boolean", + shininess: "number", + gloss: "number", + glossInvert: "boolean" +}, _textureParameter("gloss"), { + clearCoat: "number" +}, _textureParameter("clearCoat"), { + clearCoatGloss: "number", + clearCoatGlossInvert: "boolean" +}, _textureParameter("clearCoatGloss"), { + clearCoatBumpiness: "number" +}, _textureParameter("clearCoatNormal", false), { + useSheen: "boolean", + sheen: "rgb", + sheenTint: "boolean" +}, _textureParameter("sheen"), { + sheenGloss: "number", + sheenGlossTint: "boolean", + sheenGlossInvert: "boolean" +}, _textureParameter("sheenGloss"), { + fresnelModel: "number", + emissive: "rgb", + emissiveTint: "boolean" +}, _textureParameter("emissive"), { + emissiveIntensity: "number" +}, _textureParameter("normal", false), { + bumpiness: "number" +}, _textureParameter("normalDetail", false), { + normalDetailMapBumpiness: "number" +}, _textureParameter("height", true, false), { + heightMapFactor: "number", + alphaToCoverage: "boolean", + alphaTest: "number", + alphaFade: "number", + opacity: "number" +}, _textureParameter("opacity"), { + opacityFadesSpecular: "boolean", + opacityDither: "string", + opacityShadowDither: "string", + reflectivity: "number", + refraction: "number", + refractionTint: "boolean" +}, _textureParameter("refraction"), { + refractionIndex: "number", + dispersion: "number", + thickness: "number", + thicknessTint: "boolean" +}, _textureParameter("thickness"), { + attenuation: "rgb", + attenuationDistance: "number", + useDynamicRefraction: "boolean", + sphereMap: "texture", + cubeMap: "cubemap", + cubeMapProjection: "number", + cubeMapProjectionBox: "boundingbox", + useIridescence: "boolean", + iridescence: "number", + iridescenceTint: "boolean" +}, _textureParameter("iridescence"), { + iridescenceThicknessTint: "boolean", + iridescenceThicknessMin: "number", + iridescenceThicknessMax: "number", + iridescenceRefractionIndex: "number" +}, _textureParameter("iridescenceThickness"), _textureParameter("light"), { + depthTest: "boolean", + depthFunc: "enum:depthFunc", + depthWrite: "boolean", + depthBias: "number", + slopeDepthBias: "number", + cull: "enum:cull", + blendType: "enum:blendType", + shadingModel: "enum:shadingModel", + useFog: "boolean", + useLighting: "boolean", + useSkybox: "boolean", + useGammaTonemap: "boolean", + envAtlas: "texture", + twoSidedLighting: "boolean" +}); +var standardMaterialTextureParameters = []; +for (const key in standardMaterialParameterTypes) { + const type2 = standardMaterialParameterTypes[key]; + if (type2 === "texture") { + standardMaterialTextureParameters.push(key); + } +} +var standardMaterialCubemapParameters = []; +for (const key in standardMaterialParameterTypes) { + const type2 = standardMaterialParameterTypes[key]; + if (type2 === "cubemap") { + standardMaterialCubemapParameters.push(key); + } +} + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/materials/standard-material.js +var _props = {}; +var _uniforms = {}; +var _params = /* @__PURE__ */ new Set(); +var StandardMaterial = class extends Material { + constructor() { + super(); + this.userAttributes = /* @__PURE__ */ new Map(); + this._dirtyShader = true; + this._assetReferences = {}; + this._activeParams = /* @__PURE__ */ new Set(); + this._activeLightingParams = /* @__PURE__ */ new Set(); + this.shaderOptBuilder = new StandardMaterialOptionsBuilder(); + this.reset(); + } + reset() { + Object.keys(_props).forEach((name) => { + this[`_${name}`] = _props[name].value(); + }); + this._chunks = {}; + this._uniformCache = {}; + } + set shader(shader) { + } + get shader() { + return null; + } + set chunks(value) { + this._dirtyShader = true; + this._chunks = value; + } + get chunks() { + this._dirtyShader = true; + return this._chunks; + } + copy(source) { + super.copy(source); + Object.keys(_props).forEach((k) => { + this[k] = source[k]; + }); + for (const p in source._chunks) { + if (source._chunks.hasOwnProperty(p)) this._chunks[p] = source._chunks[p]; + } + return this; + } + setAttribute(name, semantic) { + this.userAttributes.set(semantic, name); + } + _setParameter(name, value) { + _params.add(name); + this.setParameter(name, value); + } + _setParameters(parameters) { + parameters.forEach((v) => { + this._setParameter(v.name, v.value); + }); + } + _processParameters(paramsName) { + const prevParams = this[paramsName]; + prevParams.forEach((param) => { + if (!_params.has(param)) { + delete this.parameters[param]; + } + }); + this[paramsName] = _params; + _params = prevParams; + _params.clear(); + } + _updateMap(p) { + const mname = p + "Map"; + const map = this[mname]; + if (map) { + this._setParameter("texture_" + mname, map); + const tname = mname + "Transform"; + const uniform = this.getUniform(tname); + if (uniform) { + this._setParameters(uniform); + } + } + } + _allocUniform(name, allocFunc) { + let uniform = this._uniformCache[name]; + if (!uniform) { + uniform = allocFunc(); + this._uniformCache[name] = uniform; + } + return uniform; + } + getUniform(name, device, scene2) { + return _uniforms[name](this, device, scene2); + } + updateUniforms(device, scene2) { + const getUniform = (name) => { + return this.getUniform(name, device, scene2); + }; + this._setParameter("material_ambient", getUniform("ambient")); + if (!this.diffuseMap || this.diffuseTint) { + this._setParameter("material_diffuse", getUniform("diffuse")); + } + if (this.useMetalness) { + if (!this.metalnessMap || this.metalness < 1) { + this._setParameter("material_metalness", this.metalness); + } + if (!this.specularMap || this.specularTint) { + this._setParameter("material_specular", getUniform("specular")); + } + if (!this.specularityFactorMap || this.specularityFactorTint) { + this._setParameter("material_specularityFactor", this.specularityFactor); + } + if (!this.sheenMap || this.sheenTint) { + this._setParameter("material_sheen", getUniform("sheen")); + } + if (!this.sheenGlossMap || this.sheenGlossTint) { + this._setParameter("material_sheenGloss", this.sheenGloss); + } + this._setParameter("material_refractionIndex", this.refractionIndex); + } else { + if (!this.specularMap || this.specularTint) { + this._setParameter("material_specular", getUniform("specular")); + } + } + if (this.enableGGXSpecular) { + this._setParameter("material_anisotropy", this.anisotropy); + } + if (this.clearCoat > 0) { + this._setParameter("material_clearCoat", this.clearCoat); + this._setParameter("material_clearCoatGloss", this.clearCoatGloss); + this._setParameter("material_clearCoatBumpiness", this.clearCoatBumpiness); + } + this._setParameter("material_gloss", getUniform("gloss")); + if (!this.emissiveMap || this.emissiveTint) { + this._setParameter("material_emissive", getUniform("emissive")); + } + if (this.emissiveIntensity !== 1) { + this._setParameter("material_emissiveIntensity", this.emissiveIntensity); + } + if (this.refraction > 0) { + this._setParameter("material_refraction", this.refraction); + } + if (this.dispersion > 0) { + this._setParameter("material_dispersion", this.dispersion); + } + if (this.useDynamicRefraction) { + this._setParameter("material_thickness", this.thickness); + this._setParameter("material_attenuation", getUniform("attenuation")); + this._setParameter("material_invAttenuationDistance", this.attenuationDistance === 0 ? 0 : 1 / this.attenuationDistance); + } + if (this.useIridescence) { + this._setParameter("material_iridescence", this.iridescence); + this._setParameter("material_iridescenceRefractionIndex", this.iridescenceRefractionIndex); + this._setParameter("material_iridescenceThicknessMin", this.iridescenceThicknessMin); + this._setParameter("material_iridescenceThicknessMax", this.iridescenceThicknessMax); + } + this._setParameter("material_opacity", this.opacity); + if (this.opacityFadesSpecular === false) { + this._setParameter("material_alphaFade", this.alphaFade); + } + if (this.occludeSpecular) { + this._setParameter("material_occludeSpecularIntensity", this.occludeSpecularIntensity); + } + if (this.cubeMapProjection === CUBEPROJ_BOX) { + this._setParameter(getUniform("cubeMapProjectionBox")); + } + for (const p in _matTex2D) { + this._updateMap(p); + } + if (this.ambientSH) { + this._setParameter("ambientSH[0]", this.ambientSH); + } + if (this.normalMap) { + this._setParameter("material_bumpiness", this.bumpiness); + } + if (this.normalMap && this.normalDetailMap) { + this._setParameter("material_normalDetailMapBumpiness", this.normalDetailMapBumpiness); + } + if (this.heightMap) { + this._setParameter("material_heightMapFactor", getUniform("heightMapFactor")); + } + const isPhong = this.shadingModel === SPECULAR_PHONG; + if (this.envAtlas && this.cubeMap && !isPhong) { + this._setParameter("texture_envAtlas", this.envAtlas); + this._setParameter("texture_cubeMap", this.cubeMap); + } else if (this.envAtlas && !isPhong) { + this._setParameter("texture_envAtlas", this.envAtlas); + } else if (this.cubeMap) { + this._setParameter("texture_cubeMap", this.cubeMap); + } else if (this.sphereMap) { + this._setParameter("texture_sphereMap", this.sphereMap); + } + this._setParameter("material_reflectivity", this.reflectivity); + this._processParameters("_activeParams"); + if (this._dirtyShader) { + this.clearVariants(); + } + } + updateEnvUniforms(device, scene2) { + const isPhong = this.shadingModel === SPECULAR_PHONG; + const hasLocalEnvOverride = this.envAtlas && !isPhong || this.cubeMap || this.sphereMap; + if (!hasLocalEnvOverride && this.useSkybox) { + if (scene2.envAtlas && scene2.skybox && !isPhong) { + this._setParameter("texture_envAtlas", scene2.envAtlas); + this._setParameter("texture_cubeMap", scene2.skybox); + } else if (scene2.envAtlas && !isPhong) { + this._setParameter("texture_envAtlas", scene2.envAtlas); + } else if (scene2.skybox) { + this._setParameter("texture_cubeMap", scene2.skybox); + } + } + this._processParameters("_activeLightingParams"); + } + getShaderVariant(device, scene2, objDefs, unused, pass, sortedLights, viewUniformFormat, viewBindGroupFormat, vertexFormat) { + this.updateEnvUniforms(device, scene2); + const shaderPassInfo = ShaderPass.get(device).getByIndex(pass); + const minimalOptions = pass === SHADER_DEPTH || pass === SHADER_PICK || pass === SHADER_PREPASS_VELOCITY || shaderPassInfo.isShadow; + let options = minimalOptions ? standard.optionsContextMin : standard.optionsContext; + if (minimalOptions) this.shaderOptBuilder.updateMinRef(options, scene2, this, objDefs, pass, sortedLights); + else this.shaderOptBuilder.updateRef(options, scene2, this, objDefs, pass, sortedLights); + if (this.onUpdateShader) { + options = this.onUpdateShader(options); + } + const processingOptions = new ShaderProcessorOptions(viewUniformFormat, viewBindGroupFormat, vertexFormat); + const library = getProgramLibrary(device); + library.register("standard", standard); + const shader = library.getProgram("standard", options, processingOptions, this.userId); + this._dirtyShader = false; + return shader; + } + destroy() { + for (const asset2 in this._assetReferences) { + this._assetReferences[asset2]._unbind(); + } + this._assetReferences = null; + super.destroy(); + } +}; +StandardMaterial.TEXTURE_PARAMETERS = standardMaterialTextureParameters; +StandardMaterial.CUBEMAP_PARAMETERS = standardMaterialCubemapParameters; +var defineUniform = (name, getUniformFunc) => { + _uniforms[name] = getUniformFunc; +}; +var definePropInternal = (name, constructorFunc, setterFunc, getterFunc) => { + Object.defineProperty(StandardMaterial.prototype, name, { + get: getterFunc || function() { + return this[`_${name}`]; + }, + set: setterFunc + }); + _props[name] = { + value: constructorFunc + }; +}; +var defineValueProp = (prop) => { + const internalName = `_${prop.name}`; + const dirtyShaderFunc = prop.dirtyShaderFunc || (() => true); + const setterFunc = function setterFunc2(value) { + const oldValue = this[internalName]; + if (oldValue !== value) { + this._dirtyShader = this._dirtyShader || dirtyShaderFunc(oldValue, value); + this[internalName] = value; + } + }; + definePropInternal(prop.name, () => prop.defaultValue, setterFunc, prop.getterFunc); +}; +var defineAggProp = (prop) => { + const internalName = `_${prop.name}`; + const dirtyShaderFunc = prop.dirtyShaderFunc || (() => true); + const setterFunc = function setterFunc2(value) { + const oldValue = this[internalName]; + if (!oldValue.equals(value)) { + this._dirtyShader = this._dirtyShader || dirtyShaderFunc(oldValue, value); + this[internalName] = oldValue.copy(value); + } + }; + definePropInternal(prop.name, () => prop.defaultValue.clone(), setterFunc, prop.getterFunc); +}; +var defineProp = (prop) => { + return prop.defaultValue && prop.defaultValue.clone ? defineAggProp(prop) : defineValueProp(prop); +}; +function _defineTex2D(name, channel = "rgb", vertexColor = true, uv = 0) { + _matTex2D[name] = channel.length || -1; + defineProp({ + name: `${name}Map`, + defaultValue: null, + dirtyShaderFunc: (oldValue, newValue) => { + return !!oldValue !== !!newValue || oldValue && (oldValue.type !== newValue.type || oldValue.fixCubemapSeams !== newValue.fixCubemapSeams || oldValue.format !== newValue.format); + } + }); + defineProp({ + name: `${name}MapTiling`, + defaultValue: new Vec2(1, 1) + }); + defineProp({ + name: `${name}MapOffset`, + defaultValue: new Vec2(0, 0) + }); + defineProp({ + name: `${name}MapRotation`, + defaultValue: 0 + }); + defineProp({ + name: `${name}MapUv`, + defaultValue: uv + }); + if (channel) { + defineProp({ + name: `${name}MapChannel`, + defaultValue: channel + }); + if (vertexColor) { + defineProp({ + name: `${name}VertexColor`, + defaultValue: false + }); + defineProp({ + name: `${name}VertexColorChannel`, + defaultValue: channel + }); + } + } + const mapTiling = `${name}MapTiling`; + const mapOffset = `${name}MapOffset`; + const mapRotation = `${name}MapRotation`; + const mapTransform = `${name}MapTransform`; + defineUniform(mapTransform, (material, device, scene2) => { + const tiling = material[mapTiling]; + const offset = material[mapOffset]; + const rotation2 = material[mapRotation]; + if (tiling.x === 1 && tiling.y === 1 && offset.x === 0 && offset.y === 0 && rotation2 === 0) { + return null; + } + const uniform = material._allocUniform(mapTransform, () => { + return [{ + name: `texture_${mapTransform}0`, + value: new Float32Array(3) + }, { + name: `texture_${mapTransform}1`, + value: new Float32Array(3) + }]; + }); + const cr = Math.cos(rotation2 * math.DEG_TO_RAD); + const sr = Math.sin(rotation2 * math.DEG_TO_RAD); + const uniform0 = uniform[0].value; + uniform0[0] = cr * tiling.x; + uniform0[1] = -sr * tiling.y; + uniform0[2] = offset.x; + const uniform1 = uniform[1].value; + uniform1[0] = sr * tiling.x; + uniform1[1] = cr * tiling.y; + uniform1[2] = 1 - tiling.y - offset.y; + return uniform; + }); +} +function _defineColor(name, defaultValue) { + defineProp({ + name, + defaultValue, + getterFunc: function() { + this._dirtyShader = true; + return this[`_${name}`]; + } + }); + defineUniform(name, (material, device, scene2) => { + const uniform = material._allocUniform(name, () => new Float32Array(3)); + const color = material[name]; + const gamma = material.useGammaTonemap && scene2.gammaCorrection; + if (gamma) { + uniform[0] = Math.pow(color.r, 2.2); + uniform[1] = Math.pow(color.g, 2.2); + uniform[2] = Math.pow(color.b, 2.2); + } else { + uniform[0] = color.r; + uniform[1] = color.g; + uniform[2] = color.b; + } + return uniform; + }); +} +function _defineFloat(name, defaultValue, getUniformFunc) { + defineProp({ + name, + defaultValue, + dirtyShaderFunc: (oldValue, newValue) => { + return (oldValue === 0 || oldValue === 1) !== (newValue === 0 || newValue === 1); + } + }); + defineUniform(name, getUniformFunc); +} +function _defineObject(name, getUniformFunc) { + defineProp({ + name, + defaultValue: null, + dirtyShaderFunc: (oldValue, newValue) => { + return !!oldValue === !!newValue; + } + }); + defineUniform(name, getUniformFunc); +} +function _defineFlag(name, defaultValue) { + defineProp({ + name, + defaultValue + }); +} +function _defineMaterialProps() { + _defineColor("ambient", new Color(0.7, 0.7, 0.7)); + _defineColor("diffuse", new Color(1, 1, 1)); + _defineColor("specular", new Color(0, 0, 0)); + _defineColor("emissive", new Color(0, 0, 0)); + _defineColor("sheen", new Color(1, 1, 1)); + _defineColor("attenuation", new Color(1, 1, 1)); + _defineFloat("emissiveIntensity", 1); + _defineFloat("specularityFactor", 1); + _defineFloat("sheenGloss", 0); + _defineFloat("gloss", 0.25, (material, device, scene2) => { + return material.shadingModel === SPECULAR_PHONG ? Math.pow(2, material.gloss * 11) : material.gloss; + }); + _defineFloat("heightMapFactor", 1, (material, device, scene2) => { + return material.heightMapFactor * 0.025; + }); + _defineFloat("opacity", 1); + _defineFloat("alphaFade", 1); + _defineFloat("alphaTest", 0); + _defineFloat("bumpiness", 1); + _defineFloat("normalDetailMapBumpiness", 1); + _defineFloat("reflectivity", 1); + _defineFloat("occludeSpecularIntensity", 1); + _defineFloat("refraction", 0); + _defineFloat("refractionIndex", 1 / 1.5); + _defineFloat("dispersion", 0); + _defineFloat("thickness", 0); + _defineFloat("attenuationDistance", 0); + _defineFloat("metalness", 1); + _defineFloat("anisotropy", 0); + _defineFloat("clearCoat", 0); + _defineFloat("clearCoatGloss", 1); + _defineFloat("clearCoatBumpiness", 1); + _defineFloat("aoUvSet", 0, null); + _defineFloat("iridescence", 0); + _defineFloat("iridescenceRefractionIndex", 1 / 1.5); + _defineFloat("iridescenceThicknessMin", 0); + _defineFloat("iridescenceThicknessMax", 0); + _defineObject("ambientSH"); + _defineObject("cubeMapProjectionBox", (material, device, scene2) => { + const uniform = material._allocUniform("cubeMapProjectionBox", () => { + return [{ + name: "envBoxMin", + value: new Float32Array(3) + }, { + name: "envBoxMax", + value: new Float32Array(3) + }]; + }); + const bboxMin = material.cubeMapProjectionBox.getMin(); + const minUniform = uniform[0].value; + minUniform[0] = bboxMin.x; + minUniform[1] = bboxMin.y; + minUniform[2] = bboxMin.z; + const bboxMax = material.cubeMapProjectionBox.getMax(); + const maxUniform = uniform[1].value; + maxUniform[0] = bboxMax.x; + maxUniform[1] = bboxMax.y; + maxUniform[2] = bboxMax.z; + return uniform; + }); + _defineFlag("ambientTint", false); + _defineFlag("diffuseTint", false); + _defineFlag("sheenTint", false); + _defineFlag("specularTint", false); + _defineFlag("specularityFactorTint", false); + _defineFlag("emissiveTint", false); + _defineFlag("fastTbn", false); + _defineFlag("useMetalness", false); + _defineFlag("useMetalnessSpecularColor", false); + _defineFlag("useSheen", false); + _defineFlag("enableGGXSpecular", false); + _defineFlag("occludeDirect", false); + _defineFlag("normalizeNormalMap", true); + _defineFlag("conserveEnergy", true); + _defineFlag("opacityFadesSpecular", true); + _defineFlag("occludeSpecular", SPECOCC_AO); + _defineFlag("shadingModel", SPECULAR_BLINN); + _defineFlag("fresnelModel", FRESNEL_SCHLICK); + _defineFlag("useDynamicRefraction", false); + _defineFlag("cubeMapProjection", CUBEPROJ_NONE); + _defineFlag("customFragmentShader", null); + _defineFlag("useFog", true); + _defineFlag("useLighting", true); + _defineFlag("useGammaTonemap", true); + _defineFlag("useSkybox", true); + _defineFlag("forceUv1", false); + _defineFlag("pixelSnap", false); + _defineFlag("twoSidedLighting", false); + _defineFlag("nineSlicedMode", void 0); + _defineFlag("msdfTextAttribute", false); + _defineFlag("useIridescence", false); + _defineFlag("glossInvert", false); + _defineFlag("sheenGlossInvert", false); + _defineFlag("clearCoatGlossInvert", false); + _defineFlag("opacityDither", DITHER_NONE); + _defineFlag("opacityShadowDither", DITHER_NONE); + _defineTex2D("diffuse"); + _defineTex2D("specular"); + _defineTex2D("emissive"); + _defineTex2D("thickness", "g"); + _defineTex2D("specularityFactor", "g"); + _defineTex2D("normal", ""); + _defineTex2D("metalness", "g"); + _defineTex2D("gloss", "g"); + _defineTex2D("opacity", "a"); + _defineTex2D("refraction", "g"); + _defineTex2D("height", "g", false); + _defineTex2D("ao", "g"); + _defineTex2D("light", "rgb", true, 1); + _defineTex2D("msdf", ""); + _defineTex2D("diffuseDetail", "rgb", false); + _defineTex2D("normalDetail", ""); + _defineTex2D("aoDetail", "g", false); + _defineTex2D("clearCoat", "g"); + _defineTex2D("clearCoatGloss", "g"); + _defineTex2D("clearCoatNormal", ""); + _defineTex2D("sheen", "rgb"); + _defineTex2D("sheenGloss", "g"); + _defineTex2D("iridescence", "g"); + _defineTex2D("iridescenceThickness", "g"); + _defineFlag("diffuseDetailMode", DETAILMODE_MUL); + _defineFlag("aoDetailMode", DETAILMODE_MUL); + _defineObject("cubeMap"); + _defineObject("sphereMap"); + _defineObject("envAtlas"); + const getterFunc = function getterFunc2() { + return this._prefilteredCubemaps; + }; + const setterFunc = function setterFunc2(value) { + const cubemaps = this._prefilteredCubemaps; + value = value || []; + let changed = false; + let complete = true; + for (let i = 0; i < 6; ++i) { + const v = value[i] || null; + if (cubemaps[i] !== v) { + cubemaps[i] = v; + changed = true; + } + complete = complete && !!cubemaps[i]; + } + if (changed) { + if (complete) { + this.envAtlas = EnvLighting.generatePrefilteredAtlas(cubemaps, { + target: this.envAtlas + }); + } else { + if (this.envAtlas) { + this.envAtlas.destroy(); + this.envAtlas = null; + } + } + this._dirtyShader = true; + } + }; + const empty = [null, null, null, null, null, null]; + definePropInternal("prefilteredCubemaps", () => empty.slice(), setterFunc, getterFunc); +} +_defineMaterialProps(); + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/animation/animation.js +var Key = class { + constructor(time2, position2, rotation2, scale2) { + this.time = time2; + this.position = position2; + this.rotation = rotation2; + this.scale = scale2; + } +}; +var Node = class { + constructor() { + this._name = ""; + this._keys = []; + } +}; +var Animation = class { + constructor() { + this.name = ""; + this.duration = 0; + this._nodes = []; + this._nodeDict = {}; + } + getNode(name) { + return this._nodeDict[name]; + } + addNode(node) { + this._nodes.push(node); + this._nodeDict[node._name] = node; + } + get nodes() { + return this._nodes; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/animation/skeleton.js +var InterpolatedKey = class { + constructor() { + this._written = false; + this._name = ""; + this._keyFrames = []; + this._quat = new Quat2(); + this._pos = new Vec3(); + this._scale = new Vec3(); + this._targetNode = null; + } + getTarget() { + return this._targetNode; + } + setTarget(node) { + this._targetNode = node; + } +}; +var Skeleton = class { + constructor(graph) { + this.looping = true; + this._animation = null; + this._time = 0; + this._interpolatedKeys = []; + this._interpolatedKeyDict = {}; + this._currKeyIndices = {}; + this.graph = null; + const addInterpolatedKeys = (node) => { + const interpKey = new InterpolatedKey(); + interpKey._name = node.name; + this._interpolatedKeys.push(interpKey); + this._interpolatedKeyDict[node.name] = interpKey; + this._currKeyIndices[node.name] = 0; + for (let i = 0; i < node._children.length; i++) addInterpolatedKeys(node._children[i]); + }; + addInterpolatedKeys(graph); + } + set animation(value) { + this._animation = value; + this.currentTime = 0; + } + get animation() { + return this._animation; + } + set currentTime(value) { + this._time = value; + const numNodes = this._interpolatedKeys.length; + for (let i = 0; i < numNodes; i++) { + const node = this._interpolatedKeys[i]; + const nodeName = node._name; + this._currKeyIndices[nodeName] = 0; + } + this.addTime(0); + this.updateGraph(); + } + get currentTime() { + return this._time; + } + get numNodes() { + return this._interpolatedKeys.length; + } + addTime(delta) { + if (this._animation !== null) { + const nodes = this._animation._nodes; + const duration = this._animation.duration; + if (this._time === duration && !this.looping) { + return; + } + this._time += delta; + if (this._time > duration) { + this._time = this.looping ? 0 : duration; + for (let i = 0; i < nodes.length; i++) { + const node = nodes[i]; + const nodeName = node._name; + this._currKeyIndices[nodeName] = 0; + } + } else if (this._time < 0) { + this._time = this.looping ? duration : 0; + for (let i = 0; i < nodes.length; i++) { + const node = nodes[i]; + const nodeName = node._name; + this._currKeyIndices[nodeName] = node._keys.length - 2; + } + } + const offset = delta >= 0 ? 1 : -1; + for (let i = 0; i < nodes.length; i++) { + const node = nodes[i]; + const nodeName = node._name; + const keys = node._keys; + const interpKey = this._interpolatedKeyDict[nodeName]; + if (interpKey === void 0) { + continue; + } + let foundKey = false; + if (keys.length !== 1) { + for (let currKeyIndex = this._currKeyIndices[nodeName]; currKeyIndex < keys.length - 1 && currKeyIndex >= 0; currKeyIndex += offset) { + const k1 = keys[currKeyIndex]; + const k2 = keys[currKeyIndex + 1]; + if (k1.time <= this._time && k2.time >= this._time) { + const alpha = (this._time - k1.time) / (k2.time - k1.time); + interpKey._pos.lerp(k1.position, k2.position, alpha); + interpKey._quat.slerp(k1.rotation, k2.rotation, alpha); + interpKey._scale.lerp(k1.scale, k2.scale, alpha); + interpKey._written = true; + this._currKeyIndices[nodeName] = currKeyIndex; + foundKey = true; + break; + } + } + } + if (keys.length === 1 || !foundKey && this._time === 0 && this.looping) { + interpKey._pos.copy(keys[0].position); + interpKey._quat.copy(keys[0].rotation); + interpKey._scale.copy(keys[0].scale); + interpKey._written = true; + } + } + } + } + blend(skel1, skel2, alpha) { + const numNodes = this._interpolatedKeys.length; + for (let i = 0; i < numNodes; i++) { + const key1 = skel1._interpolatedKeys[i]; + const key2 = skel2._interpolatedKeys[i]; + const dstKey = this._interpolatedKeys[i]; + if (key1._written && key2._written) { + dstKey._quat.slerp(key1._quat, skel2._interpolatedKeys[i]._quat, alpha); + dstKey._pos.lerp(key1._pos, skel2._interpolatedKeys[i]._pos, alpha); + dstKey._scale.lerp(key1._scale, key2._scale, alpha); + dstKey._written = true; + } else if (key1._written) { + dstKey._quat.copy(key1._quat); + dstKey._pos.copy(key1._pos); + dstKey._scale.copy(key1._scale); + dstKey._written = true; + } else if (key2._written) { + dstKey._quat.copy(key2._quat); + dstKey._pos.copy(key2._pos); + dstKey._scale.copy(key2._scale); + dstKey._written = true; + } + } + } + setGraph(graph) { + this.graph = graph; + if (graph) { + for (let i = 0; i < this._interpolatedKeys.length; i++) { + const interpKey = this._interpolatedKeys[i]; + const graphNode = graph.findByName(interpKey._name); + this._interpolatedKeys[i].setTarget(graphNode); + } + } else { + for (let i = 0; i < this._interpolatedKeys.length; i++) { + this._interpolatedKeys[i].setTarget(null); + } + } + } + updateGraph() { + if (this.graph) { + for (let i = 0; i < this._interpolatedKeys.length; i++) { + const interpKey = this._interpolatedKeys[i]; + if (interpKey._written) { + const transform = interpKey.getTarget(); + transform.localPosition.copy(interpKey._pos); + transform.localRotation.copy(interpKey._quat); + transform.localScale.copy(interpKey._scale); + if (!transform._dirtyLocal) transform._dirtifyLocal(); + interpKey._written = false; + } + } + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/geometry/cone-base-geometry.js +var primitiveUv1Padding2 = 4 / 64; +var primitiveUv1PaddingScale2 = 1 - primitiveUv1Padding2 * 2; +var ConeBaseGeometry = class extends Geometry { + constructor(baseRadius, peakRadius, height, heightSegments, capSegments, roundedCaps) { + super(); + const pos = new Vec3(); + const bottomToTop = new Vec3(); + const norm = new Vec3(); + const top = new Vec3(); + const bottom = new Vec3(); + const tangent = new Vec3(); + const positions = []; + const normals = []; + const uvs = []; + const uvs1 = []; + const indices = []; + let offset; + if (height > 0) { + for (let i = 0; i <= heightSegments; i++) { + for (let j = 0; j <= capSegments; j++) { + const theta = j / capSegments * 2 * Math.PI - Math.PI; + const sinTheta = Math.sin(theta); + const cosTheta = Math.cos(theta); + bottom.set(sinTheta * baseRadius, -height / 2, cosTheta * baseRadius); + top.set(sinTheta * peakRadius, height / 2, cosTheta * peakRadius); + pos.lerp(bottom, top, i / heightSegments); + bottomToTop.sub2(top, bottom).normalize(); + tangent.set(cosTheta, 0, -sinTheta); + norm.cross(tangent, bottomToTop).normalize(); + positions.push(pos.x, pos.y, pos.z); + normals.push(norm.x, norm.y, norm.z); + let u = j / capSegments; + let v = i / heightSegments; + uvs.push(u, 1 - v); + const _v = v; + v = u; + u = _v; + u = u * primitiveUv1PaddingScale2 + primitiveUv1Padding2; + v = v * primitiveUv1PaddingScale2 + primitiveUv1Padding2; + u /= 3; + uvs1.push(u, 1 - v); + if (i < heightSegments && j < capSegments) { + const first = i * (capSegments + 1) + j; + const second = i * (capSegments + 1) + (j + 1); + const third = (i + 1) * (capSegments + 1) + j; + const fourth = (i + 1) * (capSegments + 1) + (j + 1); + indices.push(first, second, third); + indices.push(second, fourth, third); + } + } + } + } + if (roundedCaps) { + const latitudeBands = Math.floor(capSegments / 2); + const longitudeBands = capSegments; + const capOffset = height / 2; + for (let lat = 0; lat <= latitudeBands; lat++) { + const theta = lat * Math.PI * 0.5 / latitudeBands; + const sinTheta = Math.sin(theta); + const cosTheta = Math.cos(theta); + for (let lon = 0; lon <= longitudeBands; lon++) { + const phi = lon * 2 * Math.PI / longitudeBands - Math.PI / 2; + const sinPhi = Math.sin(phi); + const cosPhi = Math.cos(phi); + const x2 = cosPhi * sinTheta; + const y2 = cosTheta; + const z2 = sinPhi * sinTheta; + let u = 1 - lon / longitudeBands; + let v = 1 - lat / latitudeBands; + positions.push(x2 * peakRadius, y2 * peakRadius + capOffset, z2 * peakRadius); + normals.push(x2, y2, z2); + uvs.push(u, 1 - v); + u = u * primitiveUv1PaddingScale2 + primitiveUv1Padding2; + v = v * primitiveUv1PaddingScale2 + primitiveUv1Padding2; + u /= 3; + v /= 3; + u += 1 / 3; + uvs1.push(u, 1 - v); + } + } + offset = (heightSegments + 1) * (capSegments + 1); + for (let lat = 0; lat < latitudeBands; ++lat) { + for (let lon = 0; lon < longitudeBands; ++lon) { + const first = lat * (longitudeBands + 1) + lon; + const second = first + longitudeBands + 1; + indices.push(offset + first + 1, offset + second, offset + first); + indices.push(offset + first + 1, offset + second + 1, offset + second); + } + } + for (let lat = 0; lat <= latitudeBands; lat++) { + const theta = Math.PI * 0.5 + lat * Math.PI * 0.5 / latitudeBands; + const sinTheta = Math.sin(theta); + const cosTheta = Math.cos(theta); + for (let lon = 0; lon <= longitudeBands; lon++) { + const phi = lon * 2 * Math.PI / longitudeBands - Math.PI / 2; + const sinPhi = Math.sin(phi); + const cosPhi = Math.cos(phi); + const x2 = cosPhi * sinTheta; + const y2 = cosTheta; + const z2 = sinPhi * sinTheta; + let u = 1 - lon / longitudeBands; + let v = 1 - lat / latitudeBands; + positions.push(x2 * peakRadius, y2 * peakRadius - capOffset, z2 * peakRadius); + normals.push(x2, y2, z2); + uvs.push(u, 1 - v); + u = u * primitiveUv1PaddingScale2 + primitiveUv1Padding2; + v = v * primitiveUv1PaddingScale2 + primitiveUv1Padding2; + u /= 3; + v /= 3; + u += 2 / 3; + uvs1.push(u, 1 - v); + } + } + offset = (heightSegments + 1) * (capSegments + 1) + (longitudeBands + 1) * (latitudeBands + 1); + for (let lat = 0; lat < latitudeBands; ++lat) { + for (let lon = 0; lon < longitudeBands; ++lon) { + const first = lat * (longitudeBands + 1) + lon; + const second = first + longitudeBands + 1; + indices.push(offset + first + 1, offset + second, offset + first); + indices.push(offset + first + 1, offset + second + 1, offset + second); + } + } + } else { + offset = (heightSegments + 1) * (capSegments + 1); + if (baseRadius > 0) { + for (let i = 0; i < capSegments; i++) { + const theta = i / capSegments * 2 * Math.PI; + const x2 = Math.sin(theta); + const y2 = -height / 2; + const z2 = Math.cos(theta); + let u = 1 - (x2 + 1) / 2; + let v = (z2 + 1) / 2; + positions.push(x2 * baseRadius, y2, z2 * baseRadius); + normals.push(0, -1, 0); + uvs.push(u, 1 - v); + u = u * primitiveUv1PaddingScale2 + primitiveUv1Padding2; + v = v * primitiveUv1PaddingScale2 + primitiveUv1Padding2; + u /= 3; + v /= 3; + u += 1 / 3; + uvs1.push(u, 1 - v); + if (i > 1) { + indices.push(offset, offset + i, offset + i - 1); + } + } + } + offset += capSegments; + if (peakRadius > 0) { + for (let i = 0; i < capSegments; i++) { + const theta = i / capSegments * 2 * Math.PI; + const x2 = Math.sin(theta); + const y2 = height / 2; + const z2 = Math.cos(theta); + let u = 1 - (x2 + 1) / 2; + let v = (z2 + 1) / 2; + positions.push(x2 * peakRadius, y2, z2 * peakRadius); + normals.push(0, 1, 0); + uvs.push(u, 1 - v); + u = u * primitiveUv1PaddingScale2 + primitiveUv1Padding2; + v = v * primitiveUv1PaddingScale2 + primitiveUv1Padding2; + u /= 3; + v /= 3; + u += 2 / 3; + uvs1.push(u, 1 - v); + if (i > 1) { + indices.push(offset, offset + i - 1, offset + i); + } + } + } + } + this.positions = positions; + this.normals = normals; + this.uvs = uvs; + this.uvs1 = uvs1; + this.indices = indices; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/geometry/capsule-geometry.js +var CapsuleGeometry = class extends ConeBaseGeometry { + constructor(opts = {}) { + var _opts$radius, _opts$height, _opts$heightSegments, _opts$sides; + const radius = (_opts$radius = opts.radius) != null ? _opts$radius : 0.3; + const height = (_opts$height = opts.height) != null ? _opts$height : 1; + const heightSegments = (_opts$heightSegments = opts.heightSegments) != null ? _opts$heightSegments : 1; + const sides = (_opts$sides = opts.sides) != null ? _opts$sides : 20; + super(radius, radius, height - 2 * radius, heightSegments, sides, true); + if (opts.calculateTangents) { + this.tangents = calculateTangents(this.positions, this.normals, this.uvs, this.indices); + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/geometry/cone-geometry.js +var ConeGeometry = class extends ConeBaseGeometry { + constructor(opts = {}) { + var _opts$baseRadius, _opts$peakRadius, _opts$height, _opts$heightSegments, _opts$capSegments; + const baseRadius = (_opts$baseRadius = opts.baseRadius) != null ? _opts$baseRadius : 0.5; + const peakRadius = (_opts$peakRadius = opts.peakRadius) != null ? _opts$peakRadius : 0; + const height = (_opts$height = opts.height) != null ? _opts$height : 1; + const heightSegments = (_opts$heightSegments = opts.heightSegments) != null ? _opts$heightSegments : 5; + const capSegments = (_opts$capSegments = opts.capSegments) != null ? _opts$capSegments : 18; + super(baseRadius, peakRadius, height, heightSegments, capSegments, false); + if (opts.calculateTangents) { + this.tangents = calculateTangents(this.positions, this.normals, this.uvs, this.indices); + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/geometry/cylinder-geometry.js +var CylinderGeometry = class extends ConeBaseGeometry { + constructor(opts = {}) { + var _opts$radius, _opts$height, _opts$heightSegments, _opts$capSegments; + const radius = (_opts$radius = opts.radius) != null ? _opts$radius : 0.5; + const height = (_opts$height = opts.height) != null ? _opts$height : 1; + const heightSegments = (_opts$heightSegments = opts.heightSegments) != null ? _opts$heightSegments : 5; + const capSegments = (_opts$capSegments = opts.capSegments) != null ? _opts$capSegments : 20; + super(radius, radius, height, heightSegments, capSegments, false); + if (opts.calculateTangents) { + this.tangents = calculateTangents(this.positions, this.normals, this.uvs, this.indices); + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/geometry/plane-geometry.js +var PlaneGeometry = class extends Geometry { + constructor(opts = {}) { + var _opts$halfExtents, _opts$widthSegments, _opts$lengthSegments; + super(); + const he = (_opts$halfExtents = opts.halfExtents) != null ? _opts$halfExtents : new Vec2(0.5, 0.5); + const ws = (_opts$widthSegments = opts.widthSegments) != null ? _opts$widthSegments : 5; + const ls = (_opts$lengthSegments = opts.lengthSegments) != null ? _opts$lengthSegments : 5; + const positions = []; + const normals = []; + const uvs = []; + const indices = []; + let vcounter = 0; + for (let i = 0; i <= ws; i++) { + for (let j = 0; j <= ls; j++) { + const x2 = -he.x + 2 * he.x * i / ws; + const y2 = 0; + const z2 = -(-he.y + 2 * he.y * j / ls); + const u = i / ws; + const v = j / ls; + positions.push(x2, y2, z2); + normals.push(0, 1, 0); + uvs.push(u, 1 - v); + if (i < ws && j < ls) { + indices.push(vcounter + ls + 1, vcounter + 1, vcounter); + indices.push(vcounter + ls + 1, vcounter + ls + 2, vcounter + 1); + } + vcounter++; + } + } + this.positions = positions; + this.normals = normals; + this.uvs = uvs; + this.uvs1 = uvs; + this.indices = indices; + if (opts.calculateTangents) { + this.tangents = calculateTangents(positions, normals, uvs, indices); + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/geometry/torus-geometry.js +var TorusGeometry = class extends Geometry { + constructor(opts = {}) { + var _opts$tubeRadius, _opts$ringRadius, _opts$sectorAngle, _opts$segments, _opts$sides; + super(); + const rc = (_opts$tubeRadius = opts.tubeRadius) != null ? _opts$tubeRadius : 0.2; + const rt = (_opts$ringRadius = opts.ringRadius) != null ? _opts$ringRadius : 0.3; + const sectorAngle = ((_opts$sectorAngle = opts.sectorAngle) != null ? _opts$sectorAngle : 360) * math.DEG_TO_RAD; + const segments = (_opts$segments = opts.segments) != null ? _opts$segments : 30; + const sides = (_opts$sides = opts.sides) != null ? _opts$sides : 20; + const positions = []; + const normals = []; + const uvs = []; + const indices = []; + for (let i = 0; i <= sides; i++) { + for (let j = 0; j <= segments; j++) { + const x2 = Math.cos(sectorAngle * j / segments) * (rt + rc * Math.cos(2 * Math.PI * i / sides)); + const y2 = Math.sin(2 * Math.PI * i / sides) * rc; + const z2 = Math.sin(sectorAngle * j / segments) * (rt + rc * Math.cos(2 * Math.PI * i / sides)); + const nx = Math.cos(sectorAngle * j / segments) * Math.cos(2 * Math.PI * i / sides); + const ny = Math.sin(2 * Math.PI * i / sides); + const nz = Math.sin(sectorAngle * j / segments) * Math.cos(2 * Math.PI * i / sides); + const u = i / sides; + const v = 1 - j / segments; + positions.push(x2, y2, z2); + normals.push(nx, ny, nz); + uvs.push(u, 1 - v); + if (i < sides && j < segments) { + const first = i * (segments + 1) + j; + const second = (i + 1) * (segments + 1) + j; + const third = i * (segments + 1) + (j + 1); + const fourth = (i + 1) * (segments + 1) + (j + 1); + indices.push(first, second, third); + indices.push(second, fourth, third); + } + } + } + this.positions = positions; + this.normals = normals; + this.uvs = uvs; + this.uvs1 = uvs; + this.indices = indices; + if (opts.calculateTangents) { + this.tangents = calculateTangents(positions, normals, uvs, indices); + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/program-library.js +var ProgramLibrary = class { + constructor(device, standardMaterial) { + this.processedCache = /* @__PURE__ */ new Map(); + this.definitionsCache = /* @__PURE__ */ new Map(); + this._generators = /* @__PURE__ */ new Map(); + this._device = device; + this._isClearingCache = false; + this._precached = false; + this._programsCollection = []; + this._defaultStdMatOption = new StandardMaterialOptions(); + this._defaultStdMatOptionMin = new StandardMaterialOptions(); + standardMaterial.shaderOptBuilder.updateRef(this._defaultStdMatOption, {}, standardMaterial, null, [], SHADER_FORWARD, null); + standardMaterial.shaderOptBuilder.updateMinRef(this._defaultStdMatOptionMin, {}, standardMaterial, null, SHADER_SHADOW, null); + device.on("destroy:shader", (shader) => { + this.removeFromCache(shader); + }); + } + destroy() { + this.clearCache(); + } + register(name, generator) { + if (!this._generators.has(name)) { + this._generators.set(name, generator); + } + } + unregister(name) { + if (this._generators.has(name)) { + this._generators.delete(name); + } + } + isRegistered(name) { + return this._generators.has(name); + } + generateShaderDefinition(generator, name, key, options) { + let def = this.definitionsCache.get(key); + if (!def) { + var _options$litOptions, _options$litOptions2, _def$name; + let lights2; + if ((_options$litOptions = options.litOptions) != null && _options$litOptions.lights) { + lights2 = options.litOptions.lights; + options.litOptions.lights = lights2.map(function(l) { + const lcopy = l.clone ? l.clone() : l; + lcopy.key = l.key; + return lcopy; + }); + } + this.storeNewProgram(name, options); + if ((_options$litOptions2 = options.litOptions) != null && _options$litOptions2.lights) options.litOptions.lights = lights2; + if (this._precached) ; + const device = this._device; + def = generator.createShaderDefinition(device, options); + def.name = (_def$name = def.name) != null ? _def$name : options.pass ? `${name}-pass:${options.pass}` : name; + this.definitionsCache.set(key, def); + } + return def; + } + getCachedShader(key) { + return this.processedCache.get(key); + } + setCachedShader(key, shader) { + this.processedCache.set(key, shader); + } + getProgram(name, options, processingOptions, userMaterialId) { + const generator = this._generators.get(name); + if (!generator) { + return null; + } + const generationKeyString = generator.generateKey(options); + const generationKey = hashCode(generationKeyString); + const processingKeyString = processingOptions.generateKey(this._device); + const processingKey = hashCode(processingKeyString); + const totalKey = `${generationKey}#${processingKey}`; + let processedShader = this.getCachedShader(totalKey); + if (!processedShader) { + const generatedShaderDef = this.generateShaderDefinition(generator, name, generationKey, options); + let passName = ""; + let shaderPassInfo; + if (options.pass !== void 0) { + shaderPassInfo = ShaderPass.get(this._device).getByIndex(options.pass); + passName = `-${shaderPassInfo.name}`; + } + this._device.fire("shader:generate", { + userMaterialId, + shaderPassInfo, + definition: generatedShaderDef + }); + const shaderDefinition = { + name: `${generatedShaderDef.name}${passName}-proc`, + attributes: generatedShaderDef.attributes, + vshader: generatedShaderDef.vshader, + vincludes: generatedShaderDef.vincludes, + fincludes: generatedShaderDef.fincludes, + fshader: generatedShaderDef.fshader, + processingOptions, + shaderLanguage: generatedShaderDef.shaderLanguage + }; + processedShader = new Shader(this._device, shaderDefinition); + this.setCachedShader(totalKey, processedShader); + } + return processedShader; + } + storeNewProgram(name, options) { + let opt = {}; + if (name === "standard") { + const defaultMat = this._getDefaultStdMatOptions(options.pass); + for (const p in options) { + if (options.hasOwnProperty(p) && defaultMat[p] !== options[p] || p === "pass") opt[p] = options[p]; + } + for (const p in options.litOptions) { + opt[p] = options.litOptions[p]; + } + } else { + opt = options; + } + this._programsCollection.push(JSON.stringify({ + name, + options: opt + })); + } + dumpPrograms() { + let text = "let device = pc.app ? pc.app.graphicsDevice : pc.Application.getApplication().graphicsDevice;\n"; + text += "let shaders = ["; + if (this._programsCollection[0]) text += "\n " + this._programsCollection[0]; + for (let i = 1; i < this._programsCollection.length; ++i) { + text += ",\n " + this._programsCollection[i]; + } + text += "\n];\n"; + text += "device.getProgramLibrary().precompile(shaders);\n"; + text += 'if (pc.version != "' + version + '" || pc.revision != "' + revision + '")\n'; + text += ' console.warn("precompile-shaders.js: engine version mismatch, rebuild shaders lib with current engine");'; + const element = document.createElement("a"); + element.setAttribute("href", "data:text/plain;charset=utf-8," + encodeURIComponent(text)); + element.setAttribute("download", "precompile-shaders.js"); + element.style.display = "none"; + document.body.appendChild(element); + element.click(); + document.body.removeChild(element); + } + clearCache() { + this._isClearingCache = true; + this.processedCache.forEach((shader) => { + shader.destroy(); + }); + this.processedCache.clear(); + this._isClearingCache = false; + } + removeFromCache(shader) { + if (this._isClearingCache) return; + this.processedCache.forEach((cachedShader, key) => { + if (shader === cachedShader) { + this.processedCache.delete(key); + } + }); + } + _getDefaultStdMatOptions(pass) { + const shaderPassInfo = ShaderPass.get(this._device).getByIndex(pass); + return pass === SHADER_DEPTH || pass === SHADER_PICK || pass === SHADER_PREPASS_VELOCITY || shaderPassInfo.isShadow ? this._defaultStdMatOptionMin : this._defaultStdMatOption; + } + precompile(cache) { + if (cache) { + const shaders = new Array(cache.length); + for (let i = 0; i < cache.length; i++) { + if (cache[i].name === "standard") { + const opt = cache[i].options; + const defaultMat = this._getDefaultStdMatOptions(opt.pass); + for (const p in defaultMat) { + if (defaultMat.hasOwnProperty(p) && opt[p] === void 0) opt[p] = defaultMat[p]; + } + } + shaders[i] = this.getProgram(cache[i].name, cache[i].options); + } + } + this._precached = true; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/constants.js +var FILLMODE_NONE = "NONE"; +var FILLMODE_FILL_WINDOW = "FILL_WINDOW"; +var FILLMODE_KEEP_ASPECT = "KEEP_ASPECT"; +var RESOLUTION_AUTO = "AUTO"; +var RESOLUTION_FIXED = "FIXED"; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/globals.js +var currentApplication; +function getApplication() { + return currentApplication; +} +function setApplication(app2) { + currentApplication = app2; +} + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/script/script-types.js +var ScriptTypes = class _ScriptTypes { + static push(Type, isLegacy) { + if (isLegacy && _ScriptTypes._types.length > 0) { + console.assert("Script Ordering Error. Contact support@playcanvas.com"); + } else { + _ScriptTypes._types.push(Type); + } + } +}; +ScriptTypes._types = []; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/script.js +var _legacy = false; +var _createdLoadingScreen = false; +var script = { + app: null, + create(name, callback) { + if (!_legacy) return; + const ScriptType = callback(script.app); + ScriptType._pcScriptName = name; + ScriptTypes.push(ScriptType, _legacy); + this.fire("created", name, callback); + }, + attribute(name, type2, defaultValue, options) { + }, + createLoadingScreen(callback) { + if (_createdLoadingScreen) return; + _createdLoadingScreen = true; + const app2 = getApplication(); + callback(app2); + } +}; +Object.defineProperty(script, "legacy", { + get: function() { + return _legacy; + }, + set: function(value) { + _legacy = value; + } +}); +events.attach(script); + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/frame-graph.js +var FrameGraph = class { + constructor() { + this.renderPasses = []; + this.renderTargetMap = /* @__PURE__ */ new Map(); + } + addRenderPass(renderPass) { + renderPass.frameUpdate(); + const beforePasses = renderPass.beforePasses; + for (let i = 0; i < beforePasses.length; i++) { + const pass = beforePasses[i]; + if (pass.enabled) { + this.addRenderPass(pass); + } + } + if (renderPass.enabled) { + this.renderPasses.push(renderPass); + } + const afterPasses = renderPass.afterPasses; + for (let i = 0; i < afterPasses.length; i++) { + const pass = afterPasses[i]; + if (pass.enabled) { + this.addRenderPass(pass); + } + } + } + reset() { + this.renderPasses.length = 0; + } + compile() { + const renderTargetMap = this.renderTargetMap; + const renderPasses = this.renderPasses; + for (let i = 0; i < renderPasses.length; i++) { + const renderPass = renderPasses[i]; + const renderTarget = renderPass.renderTarget; + if (renderTarget !== void 0) { + const prevPass = renderTargetMap.get(renderTarget); + if (prevPass) { + const count = renderPass.colorArrayOps.length; + for (let j = 0; j < count; j++) { + const colorOps = renderPass.colorArrayOps[j]; + if (!colorOps.clear) { + prevPass.colorArrayOps[j].store = true; + } + } + if (!renderPass.depthStencilOps.clearDepth) { + prevPass.depthStencilOps.storeDepth = true; + } + if (!renderPass.depthStencilOps.clearStencil) { + prevPass.depthStencilOps.storeStencil = true; + } + } + renderTargetMap.set(renderTarget, renderPass); + } + } + let lastCubeTexture = null; + let lastCubeRenderPass = null; + for (let i = 0; i < renderPasses.length; i++) { + const renderPass = renderPasses[i]; + const renderTarget = renderPass.renderTarget; + const thisTexture = renderTarget == null ? void 0 : renderTarget.colorBuffer; + if (thisTexture != null && thisTexture.cubemap) { + if (lastCubeTexture === thisTexture) { + const count = lastCubeRenderPass.colorArrayOps.length; + for (let j = 0; j < count; j++) { + lastCubeRenderPass.colorArrayOps[j].mipmaps = false; + } + } + lastCubeTexture = renderTarget.colorBuffer; + lastCubeRenderPass = renderPass; + } else if (renderPass.requiresCubemaps) { + lastCubeTexture = null; + lastCubeRenderPass = null; + } + } + renderTargetMap.clear(); + } + render(device) { + this.compile(); + const renderPasses = this.renderPasses; + for (let i = 0; i < renderPasses.length; i++) { + renderPasses[i].render(); + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/area-light-luts.js +var AreaLightCacheEntry = class { + constructor(texture0, texture1) { + this.texture0 = texture0; + this.texture1 = texture1; + } + destroy() { + var _this$texture, _this$texture2; + (_this$texture = this.texture0) == null || _this$texture.destroy(); + (_this$texture2 = this.texture1) == null || _this$texture2.destroy(); + } +}; +var deviceCache3 = new DeviceCache(); +var AreaLightLuts = class _AreaLightLuts { + static createTexture(device, format, size, postfix = "") { + const tex = new Texture(device, { + name: `AreaLightLUT${postfix}`, + width: size, + height: size, + format, + addressU: ADDRESS_CLAMP_TO_EDGE, + addressV: ADDRESS_CLAMP_TO_EDGE, + type: TEXTURETYPE_DEFAULT, + magFilter: FILTER_LINEAR, + minFilter: FILTER_NEAREST, + anisotropy: 1, + mipmaps: false + }); + return tex; + } + static applyTextures(device, texture1, texture2) { + deviceCache3.remove(device); + deviceCache3.get(device, () => { + return new AreaLightCacheEntry(texture1, texture1 === texture2 ? null : texture2); + }); + device.scope.resolve("areaLightsLutTex1").setValue(texture1); + device.scope.resolve("areaLightsLutTex2").setValue(texture2); + } + static createPlaceholder(device) { + const texture = _AreaLightLuts.createTexture(device, device.areaLightLutFormat, 2, "placeholder"); + const pixels = texture.lock(); + pixels.fill(0); + texture.unlock(); + _AreaLightLuts.applyTextures(device, texture, texture); + } + static set(device, ltcMat1, ltcMat2) { + function buildTexture(device2, data3, format2) { + const texture = _AreaLightLuts.createTexture(device2, format2, 64); + texture.lock().set(data3); + texture.unlock(); + return texture; + } + function offsetScale(data3, offset, scale2) { + const count = data3.length; + const ret = new Float32Array(count); + for (let i = 0; i < count; i++) { + const n = i % 4; + ret[i] = (data3[i] + offset[n]) * scale2[n]; + } + return ret; + } + function convertToHalfFloat(data3) { + const count = data3.length; + const ret = new Uint16Array(count); + const float2Half = FloatPacking.float2Half; + for (let i = 0; i < count; i++) { + ret[i] = float2Half(data3[i]); + } + return ret; + } + function convertToUint(data3) { + const count = data3.length; + const ret = new Uint8ClampedArray(count); + for (let i = 0; i < count; i++) { + ret[i] = data3[i] * 255; + } + return ret; + } + const srcData1 = ltcMat1; + const srcData2 = ltcMat2; + let data1, data2; + const format = device.areaLightLutFormat; + if (format === PIXELFORMAT_RGBA32F) { + data1 = srcData1; + data2 = srcData2; + } else if (format === PIXELFORMAT_RGBA16F) { + data1 = convertToHalfFloat(srcData1); + data2 = convertToHalfFloat(srcData2); + } else { + const o1 = [0, 0.2976, 0.01381, 0]; + const s1 = [0.999, 3.08737, 1.6546, 0.603249]; + const o2 = [-0.306897, 0, 0, 0]; + const s2 = [1.442787, 1, 1, 1]; + data1 = convertToUint(offsetScale(srcData1, o1, s1)); + data2 = convertToUint(offsetScale(srcData2, o2, s2)); + } + const tex1 = buildTexture(device, data1, format); + const tex2 = buildTexture(device, data2, format); + _AreaLightLuts.applyTextures(device, tex1, tex2); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/i18n/constants.js +var DEFAULT_LOCALE = "en-US"; +var DEFAULT_LOCALE_FALLBACKS = { + "en": "en-US", + "es": "en-ES", + "zh": "zh-CN", + "zh-HK": "zh-TW", + "zh-TW": "zh-HK", + "zh-MO": "zh-HK", + "fr": "fr-FR", + "de": "de-DE", + "it": "it-IT", + "ru": "ru-RU", + "ja": "ja-JP" +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/i18n/utils.js +var PLURALS = {}; +function definePluralFn(locales, fn) { + for (let i = 0, len = locales.length; i < len; i++) { + PLURALS[locales[i]] = fn; + } +} +function getLang(locale) { + const idx = locale.indexOf("-"); + if (idx !== -1) { + return locale.substring(0, idx); + } + return locale; +} +function replaceLang(locale, desiredLang) { + const idx = locale.indexOf("-"); + if (idx !== -1) { + return desiredLang + locale.substring(idx); + } + return desiredLang; +} +function findAvailableLocale(desiredLocale, availableLocales) { + if (availableLocales[desiredLocale]) { + return desiredLocale; + } + let fallback = DEFAULT_LOCALE_FALLBACKS[desiredLocale]; + if (fallback && availableLocales[fallback]) { + return fallback; + } + const lang = getLang(desiredLocale); + fallback = DEFAULT_LOCALE_FALLBACKS[lang]; + if (availableLocales[fallback]) { + return fallback; + } + if (availableLocales[lang]) { + return lang; + } + return DEFAULT_LOCALE; +} +definePluralFn(["ja", "ko", "th", "vi", "zh", "id"], function(n) { + return 0; +}); +definePluralFn(["fa", "hi"], function(n) { + if (n >= 0 && n <= 1) { + return 0; + } + return 1; +}); +definePluralFn(["fr", "pt"], function(n) { + if (n >= 0 && n < 2) { + return 0; + } + return 1; +}); +definePluralFn(["da"], function(n) { + if (n === 1 || !Number.isInteger(n) && n >= 0 && n <= 1) { + return 0; + } + return 1; +}); +definePluralFn(["de", "en", "it", "el", "es", "tr", "fi", "sv", "nb", "no", "ur"], function(n) { + if (n === 1) { + return 0; + } + return 1; +}); +definePluralFn(["ru", "uk"], function(n) { + if (Number.isInteger(n)) { + const mod10 = n % 10; + const mod100 = n % 100; + if (mod10 === 1 && mod100 !== 11) { + return 0; + } else if (mod10 >= 2 && mod10 <= 4 && (mod100 < 12 || mod100 > 14)) { + return 1; + } else if (mod10 === 0 || mod10 >= 5 && mod10 <= 9 || mod100 >= 11 && mod100 <= 14) { + return 2; + } + } + return 3; +}); +definePluralFn(["pl"], function(n) { + if (Number.isInteger(n)) { + if (n === 1) { + return 0; + } + const mod10 = n % 10; + const mod100 = n % 100; + if (mod10 >= 2 && mod10 <= 4 && (mod100 < 12 || mod100 > 14)) { + return 1; + } else if (mod10 >= 0 && mod10 <= 1 || mod10 >= 5 && mod10 <= 9 || mod100 >= 12 && mod100 <= 14) { + return 2; + } + } + return 3; +}); +definePluralFn(["ar"], function(n) { + if (n === 0) { + return 0; + } else if (n === 1) { + return 1; + } else if (n === 2) { + return 2; + } + if (Number.isInteger(n)) { + const mod100 = n % 100; + if (mod100 >= 3 && mod100 <= 10) { + return 3; + } else if (mod100 >= 11 && mod100 <= 99) { + return 4; + } + } + return 5; +}); +var DEFAULT_PLURAL_FN = PLURALS[getLang(DEFAULT_LOCALE)]; +function getPluralFn(lang) { + return PLURALS[lang] || DEFAULT_PLURAL_FN; +} + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/asset/constants.js +var ABSOLUTE_URL = new RegExp("^\\s*(?:(?:[a-z]+[a-z0-9\\-\\+\\.]*:)?//|data:|blob:)", "i"); + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/asset/asset-file.js +var AssetFile = class { + constructor(url = "", filename = "", hash = null, size = null, opt = null, contents = null) { + this.url = url; + this.filename = filename; + this.hash = hash; + this.size = size; + this.opt = opt; + this.contents = contents; + } + equals(other) { + return this.url === other.url && this.filename === other.filename && this.hash === other.hash && this.size === other.size && this.opt === other.opt && this.contents === other.contents; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/asset/asset.js +var assetIdCounter = -1; +var VARIANT_SUPPORT = { + pvr: "extCompressedTexturePVRTC", + dxt: "extCompressedTextureS3TC", + etc2: "extCompressedTextureETC", + etc1: "extCompressedTextureETC1", + basis: "canvas" +}; +var VARIANT_DEFAULT_PRIORITY = ["pvr", "dxt", "etc2", "etc1", "basis"]; +var Asset = class extends EventHandler { + constructor(name, type2, file, data2, options) { + super(); + this._id = assetIdCounter--; + this._name = name || ""; + this.type = type2; + this.tags = new Tags(this); + this._preload = false; + this._file = null; + this._data = data2 || {}; + this.options = options || {}; + this._resources = []; + this.urlObject = null; + this._i18n = {}; + this.loaded = false; + this.loading = false; + this.registry = null; + if (file) this.file = file; + } + set id(value) { + this._id = value; + } + get id() { + return this._id; + } + set name(value) { + if (this._name === value) return; + const old = this._name; + this._name = value; + this.fire("name", this, this._name, old); + } + get name() { + return this._name; + } + set file(value) { + if (value && value.variants && ["texture", "textureatlas", "bundle"].indexOf(this.type) !== -1) { + var _this$registry; + const app2 = ((_this$registry = this.registry) == null || (_this$registry = _this$registry._loader) == null ? void 0 : _this$registry._app) || getApplication(); + const device = app2 == null ? void 0 : app2.graphicsDevice; + if (device) { + for (let i = 0, len = VARIANT_DEFAULT_PRIORITY.length; i < len; i++) { + const variant = VARIANT_DEFAULT_PRIORITY[i]; + if (value.variants[variant] && device[VARIANT_SUPPORT[variant]]) { + value = value.variants[variant]; + break; + } + if (app2.enableBundles) { + const bundles = app2.bundles.listBundlesForAsset(this); + if (bundles && bundles.find((b) => { + var _b$file; + return b == null || (_b$file = b.file) == null ? void 0 : _b$file.variants[variant]; + })) { + break; + } + } + } + } + } + const oldFile = this._file; + const newFile = value ? new AssetFile(value.url, value.filename, value.hash, value.size, value.opt, value.contents) : null; + if (!!newFile !== !!oldFile || newFile && !newFile.equals(oldFile)) { + this._file = newFile; + this.fire("change", this, "file", newFile, oldFile); + this.reload(); + } + } + get file() { + return this._file; + } + set data(value) { + const old = this._data; + this._data = value; + if (value !== old) { + this.fire("change", this, "data", value, old); + if (this.loaded) this.registry._loader.patch(this, this.registry); + } + } + get data() { + return this._data; + } + set resource(value) { + const _old = this._resources[0]; + this._resources[0] = value; + this.fire("change", this, "resource", value, _old); + } + get resource() { + return this._resources[0]; + } + set resources(value) { + const _old = this._resources; + this._resources = value; + this.fire("change", this, "resources", value, _old); + } + get resources() { + return this._resources; + } + set preload(value) { + value = !!value; + if (this._preload === value) return; + this._preload = value; + if (this._preload && !this.loaded && !this.loading && this.registry) this.registry.load(this); + } + get preload() { + return this._preload; + } + set loadFaces(value) { + value = !!value; + if (!this.hasOwnProperty("_loadFaces") || value !== this._loadFaces) { + this._loadFaces = value; + if (this.loaded) this.registry._loader.patch(this, this.registry); + } + } + get loadFaces() { + return this._loadFaces; + } + getFileUrl() { + const file = this.file; + if (!file || !file.url) return null; + let url = file.url; + if (this.registry && this.registry.prefix && !ABSOLUTE_URL.test(url)) url = this.registry.prefix + url; + if (this.type !== "script" && file.hash) { + const separator = url.indexOf("?") !== -1 ? "&" : "?"; + url += separator + "t=" + file.hash; + } + return url; + } + getAbsoluteUrl(relativePath) { + if (relativePath.startsWith("blob:") || relativePath.startsWith("data:")) { + return relativePath; + } + const base = path.getDirectory(this.file.url); + return path.join(base, relativePath); + } + getLocalizedAssetId(locale) { + locale = findAvailableLocale(locale, this._i18n); + return this._i18n[locale] || null; + } + addLocalizedAssetId(locale, assetId) { + this._i18n[locale] = assetId; + this.fire("add:localized", locale, assetId); + } + removeLocalizedAssetId(locale) { + const assetId = this._i18n[locale]; + if (assetId) { + delete this._i18n[locale]; + this.fire("remove:localized", locale, assetId); + } + } + ready(callback, scope) { + scope = scope || this; + if (this.loaded) { + callback.call(scope, this); + } else { + this.once("load", function(asset2) { + callback.call(scope, asset2); + }); + } + } + reload() { + if (this.loaded) { + this.loaded = false; + this.registry.load(this); + } + } + unload() { + if (!this.loaded && this._resources.length === 0) return; + this.fire("unload", this); + this.registry.fire("unload:" + this.id, this); + const old = this._resources; + if (this.urlObject) { + URL.revokeObjectURL(this.urlObject); + this.urlObject = null; + } + this.resources = []; + this.loaded = false; + if (this.file) { + this.registry._loader.clearCache(this.getFileUrl(), this.type); + } + for (let i = 0; i < old.length; ++i) { + const resource = old[i]; + if (resource && resource.destroy) { + resource.destroy(); + } + } + } + static fetchArrayBuffer(loadUrl, callback, asset2, maxRetries = 0) { + var _asset$file; + if (asset2 != null && (_asset$file = asset2.file) != null && _asset$file.contents) { + setTimeout(() => { + callback(null, asset2.file.contents); + }); + } else { + http.get(loadUrl, { + cache: true, + responseType: "arraybuffer", + retry: maxRetries > 0, + maxRetries + }, callback); + } + } +}; +Asset.EVENT_LOAD = "load"; +Asset.EVENT_UNLOAD = "unload"; +Asset.EVENT_REMOVE = "remove"; +Asset.EVENT_ERROR = "error"; +Asset.EVENT_CHANGE = "change"; +Asset.EVENT_ADDLOCALIZED = "add:localized"; +Asset.EVENT_REMOVELOCALIZED = "remove:localized"; + +// ../../node_modules/playcanvas/build/playcanvas/src/core/tags-cache.js +var TagsCache = class { + constructor(key = null) { + this._index = {}; + this._key = void 0; + this._key = key; + } + addItem(item) { + const tags = item.tags._list; + for (const tag of tags) this.add(tag, item); + } + removeItem(item) { + const tags = item.tags._list; + for (const tag of tags) this.remove(tag, item); + } + add(tag, item) { + if (this._index[tag] && this._index[tag].list.indexOf(item) !== -1) return; + if (!this._index[tag]) { + this._index[tag] = { + list: [] + }; + if (this._key) this._index[tag].keys = {}; + } + this._index[tag].list.push(item); + if (this._key) this._index[tag].keys[item[this._key]] = item; + } + remove(tag, item) { + if (!this._index[tag]) return; + if (this._key) { + if (!this._index[tag].keys[item[this._key]]) return; + } + const ind = this._index[tag].list.indexOf(item); + if (ind === -1) return; + this._index[tag].list.splice(ind, 1); + if (this._key) delete this._index[tag].keys[item[this._key]]; + if (this._index[tag].list.length === 0) delete this._index[tag]; + } + find(args) { + const index = {}; + const items = []; + let item, tag, tags, tagsRest, missingIndex; + const sort = (a, b) => { + return this._index[a].list.length - this._index[b].list.length; + }; + for (let i = 0; i < args.length; i++) { + tag = args[i]; + if (tag instanceof Array) { + if (tag.length === 0) continue; + if (tag.length === 1) { + tag = tag[0]; + } else { + missingIndex = false; + for (let t = 0; t < tag.length; t++) { + if (!this._index[tag[t]]) { + missingIndex = true; + break; + } + } + if (missingIndex) continue; + tags = tag.slice(0).sort(sort); + tagsRest = tags.slice(1); + if (tagsRest.length === 1) tagsRest = tagsRest[0]; + for (let n = 0; n < this._index[tags[0]].list.length; n++) { + item = this._index[tags[0]].list[n]; + if ((this._key ? !index[item[this._key]] : items.indexOf(item) === -1) && item.tags.has(tagsRest)) { + if (this._key) index[item[this._key]] = true; + items.push(item); + } + } + continue; + } + } + if (tag && typeof tag === "string" && this._index[tag]) { + for (let n = 0; n < this._index[tag].list.length; n++) { + item = this._index[tag].list[n]; + if (this._key) { + if (!index[item[this._key]]) { + index[item[this._key]] = true; + items.push(item); + } + } else if (items.indexOf(item) === -1) { + items.push(item); + } + } + } + } + return items; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/asset/asset-registry.js +var AssetRegistry = class extends EventHandler { + constructor(loader) { + super(); + this._assets = /* @__PURE__ */ new Set(); + this._idToAsset = /* @__PURE__ */ new Map(); + this._urlToAsset = /* @__PURE__ */ new Map(); + this._nameToAsset = /* @__PURE__ */ new Map(); + this._tags = new TagsCache("_id"); + this.prefix = null; + this.bundles = null; + this._loader = loader; + } + list(filters = {}) { + const assets = Array.from(this._assets); + if (filters.preload !== void 0) { + return assets.filter((asset2) => asset2.preload === filters.preload); + } + return assets; + } + add(asset2) { + var _asset$file, _asset$file2; + if (this._assets.has(asset2)) return; + this._assets.add(asset2); + this._idToAsset.set(asset2.id, asset2); + if ((_asset$file = asset2.file) != null && _asset$file.url) { + this._urlToAsset.set(asset2.file.url, asset2); + } + if (!this._nameToAsset.has(asset2.name)) this._nameToAsset.set(asset2.name, /* @__PURE__ */ new Set()); + this._nameToAsset.get(asset2.name).add(asset2); + asset2.on("name", this._onNameChange, this); + asset2.registry = this; + this._tags.addItem(asset2); + asset2.tags.on("add", this._onTagAdd, this); + asset2.tags.on("remove", this._onTagRemove, this); + this.fire("add", asset2); + this.fire("add:" + asset2.id, asset2); + if ((_asset$file2 = asset2.file) != null && _asset$file2.url) { + this.fire("add:url:" + asset2.file.url, asset2); + } + if (asset2.preload) this.load(asset2); + } + remove(asset2) { + var _asset$file3, _asset$file4; + if (!this._assets.has(asset2)) return false; + this._assets.delete(asset2); + this._idToAsset.delete(asset2.id); + if ((_asset$file3 = asset2.file) != null && _asset$file3.url) { + this._urlToAsset.delete(asset2.file.url); + } + asset2.off("name", this._onNameChange, this); + if (this._nameToAsset.has(asset2.name)) { + const items = this._nameToAsset.get(asset2.name); + items.delete(asset2); + if (items.size === 0) { + this._nameToAsset.delete(asset2.name); + } + } + this._tags.removeItem(asset2); + asset2.tags.off("add", this._onTagAdd, this); + asset2.tags.off("remove", this._onTagRemove, this); + asset2.fire("remove", asset2); + this.fire("remove", asset2); + this.fire("remove:" + asset2.id, asset2); + if ((_asset$file4 = asset2.file) != null && _asset$file4.url) { + this.fire("remove:url:" + asset2.file.url, asset2); + } + return true; + } + get(id12) { + return this._idToAsset.get(Number(id12)); + } + getByUrl(url) { + return this._urlToAsset.get(url); + } + load(asset2, options) { + if ((asset2.loading || asset2.loaded) && !(options != null && options.force)) { + return; + } + const file = asset2.file; + const _fireLoad = () => { + this.fire("load", asset2); + this.fire("load:" + asset2.id, asset2); + if (file && file.url) this.fire("load:url:" + file.url, asset2); + asset2.fire("load", asset2); + }; + const _opened = (resource) => { + if (resource instanceof Array) { + asset2.resources = resource; + } else { + asset2.resource = resource; + } + this._loader.patch(asset2, this); + if (asset2.type === "bundle") { + const assetIds = asset2.data.assets; + for (let i = 0; i < assetIds.length; i++) { + const assetInBundle = this._idToAsset.get(assetIds[i]); + if (assetInBundle && !assetInBundle.loaded) { + this.load(assetInBundle, { + force: true + }); + } + } + if (asset2.resource.loaded) { + _fireLoad(); + } else { + this.fire("load:start", asset2); + this.fire("load:start:" + asset2.id, asset2); + if (file && file.url) this.fire("load:start:url:" + file.url, asset2); + asset2.fire("load:start", asset2); + asset2.resource.on("load", _fireLoad); + } + } else { + _fireLoad(); + } + }; + const _loaded = (err, resource, extra) => { + asset2.loaded = true; + asset2.loading = false; + if (err) { + this.fire("error", err, asset2); + this.fire("error:" + asset2.id, err, asset2); + asset2.fire("error", err, asset2); + } else { + if (!script.legacy && asset2.type === "script") { + const handler = this._loader.getHandler("script"); + if (handler._cache[asset2.id] && handler._cache[asset2.id].parentNode === document.head) { + document.head.removeChild(handler._cache[asset2.id]); + } + handler._cache[asset2.id] = extra; + } + _opened(resource); + } + }; + if (file || asset2.type === "cubemap") { + this.fire("load:start", asset2); + this.fire("load:" + asset2.id + ":start", asset2); + asset2.loading = true; + const fileUrl = asset2.getFileUrl(); + if (asset2.type === "bundle") { + const assetIds = asset2.data.assets; + for (let i = 0; i < assetIds.length; i++) { + const assetInBundle = this._idToAsset.get(assetIds[i]); + if (!assetInBundle) continue; + if (assetInBundle.loaded || assetInBundle.resource || assetInBundle.loading) continue; + assetInBundle.loading = true; + } + } + this._loader.load(fileUrl, asset2.type, _loaded, asset2, options); + } else { + const resource = this._loader.open(asset2.type, asset2.data); + asset2.loaded = true; + _opened(resource); + } + } + loadFromUrl(url, type2, callback) { + this.loadFromUrlAndFilename(url, null, type2, callback); + } + loadFromUrlAndFilename(url, filename, type2, callback) { + const name = path.getBasename(filename || url); + const file = { + filename: filename || name, + url + }; + let asset2 = this.getByUrl(url); + if (!asset2) { + asset2 = new Asset(name, type2, file); + this.add(asset2); + } else if (asset2.loaded) { + callback(asset2.loadFromUrlError || null, asset2); + return; + } + const startLoad = (asset3) => { + asset3.once("load", (loadedAsset) => { + if (type2 === "material") { + this._loadTextures(loadedAsset, (err, textures) => { + callback(err, loadedAsset); + }); + } else { + callback(null, loadedAsset); + } + }); + asset3.once("error", (err) => { + if (err) { + this.loadFromUrlError = err; + } + callback(err, asset3); + }); + this.load(asset3); + }; + if (asset2.resource) { + callback(null, asset2); + } else if (type2 === "model") { + this._loadModel(asset2, startLoad); + } else { + startLoad(asset2); + } + } + _loadModel(modelAsset, continuation) { + const url = modelAsset.getFileUrl(); + const ext = path.getExtension(url); + if (ext === ".json" || ext === ".glb") { + const dir = path.getDirectory(url); + const basename = path.getBasename(url); + const mappingUrl = path.join(dir, basename.replace(ext, ".mapping.json")); + this._loader.load(mappingUrl, "json", (err, data2) => { + if (err) { + modelAsset.data = { + mapping: [] + }; + continuation(modelAsset); + } else { + this._loadMaterials(modelAsset, data2, (e, materials) => { + modelAsset.data = data2; + continuation(modelAsset); + }); + } + }); + } else { + continuation(modelAsset); + } + } + _loadMaterials(modelAsset, mapping, callback) { + const materials = []; + let count = 0; + const onMaterialLoaded = (err, materialAsset) => { + this._loadTextures(materialAsset, (err2, textures) => { + materials.push(materialAsset); + if (materials.length === count) { + callback(null, materials); + } + }); + }; + for (let i = 0; i < mapping.mapping.length; i++) { + const path2 = mapping.mapping[i].path; + if (path2) { + count++; + const url = modelAsset.getAbsoluteUrl(path2); + this.loadFromUrl(url, "material", onMaterialLoaded); + } + } + if (count === 0) { + callback(null, materials); + } + } + _loadTextures(materialAsset, callback) { + const textures = []; + let count = 0; + const data2 = materialAsset.data; + if (data2.mappingFormat !== "path") { + callback(null, textures); + return; + } + const onTextureLoaded = (err, texture) => { + if (err) console.error(err); + textures.push(texture); + if (textures.length === count) { + callback(null, textures); + } + }; + const texParams = standardMaterialTextureParameters; + for (let i = 0; i < texParams.length; i++) { + const path2 = data2[texParams[i]]; + if (path2 && typeof path2 === "string") { + count++; + const url = materialAsset.getAbsoluteUrl(path2); + this.loadFromUrl(url, "texture", onTextureLoaded); + } + } + if (count === 0) { + callback(null, textures); + } + } + _onTagAdd(tag, asset2) { + this._tags.add(tag, asset2); + } + _onTagRemove(tag, asset2) { + this._tags.remove(tag, asset2); + } + _onNameChange(asset2, name, nameOld) { + if (this._nameToAsset.has(nameOld)) { + const items = this._nameToAsset.get(nameOld); + items.delete(asset2); + if (items.size === 0) { + this._nameToAsset.delete(nameOld); + } + } + if (!this._nameToAsset.has(asset2.name)) this._nameToAsset.set(asset2.name, /* @__PURE__ */ new Set()); + this._nameToAsset.get(asset2.name).add(asset2); + } + findByTag() { + return this._tags.find(arguments); + } + filter(callback) { + return Array.from(this._assets).filter((asset2) => callback(asset2)); + } + find(name, type2) { + const items = this._nameToAsset.get(name); + if (!items) return null; + for (const asset2 of items) { + if (!type2 || asset2.type === type2) { + return asset2; + } + } + return null; + } + findAll(name, type2) { + const items = this._nameToAsset.get(name); + if (!items) return []; + const results = Array.from(items); + if (!type2) return results; + return results.filter((asset2) => asset2.type === type2); + } +}; +AssetRegistry.EVENT_LOAD = "load"; +AssetRegistry.EVENT_ADD = "add"; +AssetRegistry.EVENT_REMOVE = "remove"; +AssetRegistry.EVENT_ERROR = "error"; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/bundle/bundle-registry.js +var BundleRegistry = class { + constructor(assets) { + this._idToBundle = /* @__PURE__ */ new Map(); + this._assetToBundles = /* @__PURE__ */ new Map(); + this._urlsToBundles = /* @__PURE__ */ new Map(); + this._fileRequests = /* @__PURE__ */ new Map(); + this._assets = assets; + this._assets.bundles = this; + this._assets.on("add", this._onAssetAdd, this); + this._assets.on("remove", this._onAssetRemove, this); + } + _onAssetAdd(asset2) { + if (asset2.type === "bundle") { + this._idToBundle.set(asset2.id, asset2); + this._assets.on(`load:start:${asset2.id}`, this._onBundleLoadStart, this); + this._assets.on(`load:${asset2.id}`, this._onBundleLoad, this); + this._assets.on(`error:${asset2.id}`, this._onBundleError, this); + const assetIds = asset2.data.assets; + for (let i = 0; i < assetIds.length; i++) { + this._indexAssetInBundle(assetIds[i], asset2); + } + } else { + if (this._assetToBundles.has(asset2.id)) { + this._indexAssetFileUrls(asset2); + } + } + } + _unbindAssetEvents(id12) { + this._assets.off("load:start:" + id12, this._onBundleLoadStart, this); + this._assets.off("load:" + id12, this._onBundleLoad, this); + this._assets.off("error:" + id12, this._onBundleError, this); + } + _indexAssetInBundle(id12, bundle) { + let bundles = this._assetToBundles.get(id12); + if (!bundles) { + bundles = /* @__PURE__ */ new Set(); + this._assetToBundles.set(id12, bundles); + } + bundles.add(bundle); + const asset2 = this._assets.get(id12); + if (asset2) this._indexAssetFileUrls(asset2); + } + _indexAssetFileUrls(asset2) { + const urls = this._getAssetFileUrls(asset2); + if (!urls) return; + for (let i = 0; i < urls.length; i++) { + const bundles = this._assetToBundles.get(asset2.id); + if (!bundles) continue; + this._urlsToBundles.set(urls[i], bundles); + } + } + _getAssetFileUrls(asset2) { + let url = asset2.getFileUrl(); + if (!url) return null; + url = url.split("?")[0]; + const urls = [url]; + if (asset2.type === "font") { + const numFiles = asset2.data.info.maps.length; + for (let i = 1; i < numFiles; i++) { + urls.push(url.replace(".png", i + ".png")); + } + } + return urls; + } + _onAssetRemove(asset2) { + if (asset2.type === "bundle") { + this._idToBundle.delete(asset2.id); + this._unbindAssetEvents(asset2.id); + const assetIds = asset2.data.assets; + for (let i = 0; i < assetIds.length; i++) { + const bundles = this._assetToBundles.get(assetIds[i]); + if (!bundles) continue; + bundles.delete(asset2); + if (bundles.size === 0) { + this._assetToBundles.delete(assetIds[i]); + for (const [url, otherBundles] of this._urlsToBundles) { + if (otherBundles !== bundles) continue; + this._urlsToBundles.delete(url); + } + } + } + this._onBundleError(`Bundle ${asset2.id} was removed`); + } else { + const bundles = this._assetToBundles.get(asset2.id); + if (!bundles) return; + this._assetToBundles.delete(asset2.id); + const urls = this._getAssetFileUrls(asset2); + if (!urls) return; + for (let i = 0; i < urls.length; i++) { + this._urlsToBundles.delete(urls[i]); + } + } + } + _onBundleLoadStart(asset2) { + asset2.resource.on("add", (url, data2) => { + const callbacks = this._fileRequests.get(url); + if (!callbacks) return; + for (let i = 0; i < callbacks.length; i++) { + callbacks[i](null, data2); + } + this._fileRequests.delete(url); + }); + } + _onBundleLoad(asset2) { + if (!asset2.resource) { + this._onBundleError(`Bundle ${asset2.id} failed to load`); + return; + } + if (!this._fileRequests) return; + for (const [url, requests] of this._fileRequests) { + const bundles = this._urlsToBundles.get(url); + if (!bundles || !bundles.has(asset2)) continue; + const decodedUrl = decodeURIComponent(url); + let err, data2; + if (asset2.resource.has(decodedUrl)) { + data2 = asset2.resource.get(decodedUrl); + } else if (asset2.resource.loaded) { + err = `Bundle ${asset2.id} does not contain URL ${url}`; + } else { + continue; + } + for (let i = 0; i < requests.length; i++) { + requests[i](err, err || data2); + } + this._fileRequests.delete(url); + } + } + _onBundleError(err) { + for (const [url, requests] of this._fileRequests) { + const bundle = this._findLoadedOrLoadingBundleForUrl(url); + if (!bundle) { + for (let i = 0; i < requests.length; i++) requests[i](err); + this._fileRequests.delete(url); + } + } + } + _findLoadedOrLoadingBundleForUrl(url) { + const bundles = this._urlsToBundles.get(url); + if (!bundles) return null; + let candidate = null; + for (const bundle of bundles) { + if (bundle.loaded && bundle.resource) { + return bundle; + } else if (bundle.loading) { + candidate = bundle; + } + } + return candidate; + } + listBundlesForAsset(asset2) { + const bundles = this._assetToBundles.get(asset2.id); + if (bundles) return Array.from(bundles); + return null; + } + list() { + return Array.from(this._idToBundle.values()); + } + hasUrl(url) { + return this._urlsToBundles.has(url); + } + urlIsLoadedOrLoading(url) { + return !!this._findLoadedOrLoadingBundleForUrl(url); + } + loadUrl(url, callback) { + const bundle = this._findLoadedOrLoadingBundleForUrl(url); + if (!bundle) { + callback(`URL ${url} not found in any bundles`); + return; + } + if (bundle.loaded) { + const decodedUrl = decodeURIComponent(url); + if (bundle.resource.has(decodedUrl)) { + callback(null, bundle.resource.get(decodedUrl)); + return; + } else if (bundle.resource.loaded) { + callback(`Bundle ${bundle.id} does not contain URL ${url}`); + return; + } + } + let callbacks = this._fileRequests.get(url); + if (!callbacks) { + callbacks = []; + this._fileRequests.set(url, callbacks); + } + callbacks.push(callback); + } + destroy() { + this._assets.off("add", this._onAssetAdd, this); + this._assets.off("remove", this._onAssetRemove, this); + for (const id12 of this._idToBundle.keys()) { + this._unbindAssetEvents(id12); + } + this._assets = null; + this._idToBundle.clear(); + this._idToBundle = null; + this._assetToBundles.clear(); + this._assetToBundles = null; + this._urlsToBundles.clear(); + this._urlsToBundles = null; + this._fileRequests.clear(); + this._fileRequests = null; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/components/registry.js +var ComponentSystemRegistry = class extends EventHandler { + constructor() { + super(); + this.anim = void 0; + this.animation = void 0; + this.audiolistener = void 0; + this.audiosource = void 0; + this.button = void 0; + this.camera = void 0; + this.collision = void 0; + this.element = void 0; + this.joint = void 0; + this.layoutchild = void 0; + this.layoutgroup = void 0; + this.light = void 0; + this.model = void 0; + this.particlesystem = void 0; + this.render = void 0; + this.rigidbody = void 0; + this.screen = void 0; + this.script = void 0; + this.scrollbar = void 0; + this.scrollview = void 0; + this.sound = void 0; + this.sprite = void 0; + this.zone = void 0; + this.list = []; + } + add(system) { + const id12 = system.id; + if (this[id12]) { + throw new Error(`ComponentSystem name '${id12}' already registered or not allowed`); + } + this[id12] = system; + this.list.push(system); + } + remove(system) { + const id12 = system.id; + if (!this[id12]) { + throw new Error(`No ComponentSystem named '${id12}' registered`); + } + delete this[id12]; + const index = this.list.indexOf(this[id12]); + if (index !== -1) { + this.list.splice(index, 1); + } + } + destroy() { + this.off(); + for (let i = 0; i < this.list.length; i++) { + this.list[i].destroy(); + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/bundle/bundle.js +var Bundle = class extends EventHandler { + constructor(...args) { + super(...args); + this._index = /* @__PURE__ */ new Map(); + this._loaded = false; + } + addFile(url, data2) { + if (this._index.has(url)) return; + this._index.set(url, data2); + this.fire("add", url, data2); + } + has(url) { + return this._index.has(url); + } + get(url) { + return this._index.get(url) || null; + } + destroy() { + this._index.clear(); + } + set loaded(value) { + if (!value || this._loaded) return; + this._loaded = true; + this.fire("load"); + } + get loaded() { + return this._loaded; + } +}; +Bundle.EVENT_ADD = "add"; +Bundle.EVENT_LOAD = "load"; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/handlers/untar.js +var Untar = class extends EventHandler { + constructor(fetchPromise, assetsPrefix = "") { + super(); + this.headerSize = 512; + this.paddingSize = 512; + this.bytesRead = 0; + this.bytesReceived = 0; + this.headerRead = false; + this.reader = null; + this.data = new Uint8Array(0); + this.decoder = null; + this.prefix = ""; + this.fileName = ""; + this.fileSize = 0; + this.fileType = ""; + this.ustarFormat = ""; + this.prefix = assetsPrefix || ""; + this.reader = fetchPromise.body.getReader(); + this.reader.read().then((res) => { + this.pump(res.done, res.value); + }).catch((err) => { + this.fire("error", err); + }); + } + pump(done, value) { + if (done) { + this.fire("done"); + return null; + } + this.bytesReceived += value.byteLength; + const data2 = new Uint8Array(this.data.length + value.length); + data2.set(this.data); + data2.set(value, this.data.length); + this.data = data2; + while (this.readFile()) ; + return this.reader.read().then((res) => { + this.pump(res.done, res.value); + }).catch((err) => { + this.fire("error", err); + }); + } + readFile() { + if (!this.headerRead && this.bytesReceived > this.bytesRead + this.headerSize) { + var _this$decoder; + this.headerRead = true; + const view = new DataView(this.data.buffer, this.bytesRead, this.headerSize); + (_this$decoder = this.decoder) != null ? _this$decoder : this.decoder = new TextDecoder("windows-1252"); + const headers = this.decoder.decode(view); + this.fileName = headers.substring(0, 100).replace(/\0/g, ""); + this.fileSize = parseInt(headers.substring(124, 136), 8); + this.fileType = headers.substring(156, 157); + this.ustarFormat = headers.substring(257, 263); + if (this.ustarFormat.indexOf("ustar") !== -1) { + const prefix = headers.substring(345, 500).replace(/\0/g, ""); + if (prefix.length > 0) { + this.fileName = prefix.trim() + this.fileName.trim(); + } + } + this.bytesRead += 512; + } + if (this.headerRead) { + if (this.bytesReceived < this.bytesRead + this.fileSize) { + return false; + } + if (this.fileType === "" || this.fileType === "0") { + const dataView = new DataView(this.data.buffer, this.bytesRead, this.fileSize); + const file = { + name: this.prefix + this.fileName, + size: this.fileSize, + data: dataView + }; + this.fire("file", file); + } + this.bytesRead += this.fileSize; + this.headerRead = false; + const bytesRemained = this.bytesRead % this.paddingSize; + if (bytesRemained !== 0) this.bytesRead += this.paddingSize - bytesRemained; + return true; + } + return false; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/handlers/handler.js +var ResourceHandler = class { + constructor(app2, handlerType) { + this.handlerType = ""; + this._app = void 0; + this._maxRetries = 0; + this._app = app2; + this.handlerType = handlerType; + } + set maxRetries(value) { + this._maxRetries = value; + } + get maxRetries() { + return this._maxRetries; + } + load(url, callback, asset2) { + } + open(url, data2, asset2) { + return data2; + } + patch(asset2, assets) { + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/handlers/bundle.js +var BundleHandler = class extends ResourceHandler { + constructor(app2) { + super(app2, "bundle"); + this._assets = app2.assets; + } + _fetchRetries(url, options, retries = 0) { + return new Promise((resolve, reject) => { + const tryFetch = () => { + fetch(url, options).then(resolve).catch((err) => { + retries++; + if (retries < this.maxRetries) { + tryFetch(); + } else { + reject(err); + } + }); + }; + tryFetch(); + }); + } + load(url, callback) { + if (typeof url === "string") { + url = { + load: url, + original: url + }; + } + this._fetchRetries(url.load, { + mode: "cors", + credentials: "include" + }, this.maxRetries).then((res) => { + const bundle = new Bundle(); + callback(null, bundle); + const untar = new Untar(res, this._assets.prefix); + untar.on("file", (file) => { + bundle.addFile(file.name, file.data); + }); + untar.on("done", () => { + bundle.loaded = true; + }); + untar.on("error", (err) => { + callback(err); + }); + }).catch((err) => { + callback(err); + }); + } + open(url, bundle) { + return bundle; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/handlers/loader.js +var ResourceLoader = class _ResourceLoader { + constructor(app2) { + this._handlers = {}; + this._requests = {}; + this._cache = {}; + this._app = app2; + } + addHandler(type2, handler) { + this._handlers[type2] = handler; + handler._loader = this; + } + removeHandler(type2) { + delete this._handlers[type2]; + } + getHandler(type2) { + return this._handlers[type2]; + } + static makeKey(url, type2) { + return `${url}-${type2}`; + } + load(url, type2, callback, asset2, options) { + const handler = this._handlers[type2]; + if (!handler) { + const err = `No resource handler for asset type: '${type2}' when loading [${url}]`; + callback(err); + return; + } + if (!url) { + this._loadNull(handler, callback, asset2); + return; + } + const key = _ResourceLoader.makeKey(url, type2); + if (this._cache[key] !== void 0) { + callback(null, this._cache[key]); + } else if (this._requests[key]) { + this._requests[key].push(callback); + } else { + this._requests[key] = [callback]; + const self2 = this; + const handleLoad = function handleLoad2(err, urlObj) { + if (err) { + self2._onFailure(key, err); + return; + } + if (urlObj.load instanceof DataView) { + if (handler.openBinary) { + if (!self2._requests[key]) return; + try { + const data2 = handler.openBinary(urlObj.load); + self2._onSuccess(key, data2); + } catch (err2) { + self2._onFailure(key, err2); + } + return; + } + urlObj.load = URL.createObjectURL(new Blob([urlObj.load])); + if (asset2) { + if (asset2.urlObject) URL.revokeObjectURL(asset2.urlObject); + asset2.urlObject = urlObj.load; + } + } + handler.load(urlObj, function(err2, data2, extra) { + if (!self2._requests[key]) { + return; + } + if (err2) { + self2._onFailure(key, err2); + return; + } + try { + self2._onSuccess(key, handler.open(urlObj.original, data2, asset2), extra); + } catch (e) { + self2._onFailure(key, e); + } + }, asset2); + }; + const normalizedUrl = url.split("?")[0]; + if (this._app.enableBundles && this._app.bundles.hasUrl(normalizedUrl) && !(options && options.bundlesIgnore)) { + if (!this._app.bundles.urlIsLoadedOrLoading(normalizedUrl)) { + var _this$_app$assets; + const bundles = this._app.bundles.listBundlesForAsset(asset2); + let bundle; + if (options && options.bundlesFilter) { + bundle = options.bundlesFilter(bundles); + } + if (!bundle) { + bundles == null || bundles.sort((a, b) => { + return a.file.size - b.file.size; + }); + bundle = bundles == null ? void 0 : bundles[0]; + } + if (bundle) (_this$_app$assets = this._app.assets) == null || _this$_app$assets.load(bundle); + } + this._app.bundles.loadUrl(normalizedUrl, function(err, fileUrlFromBundle) { + handleLoad(err, { + load: fileUrlFromBundle, + original: normalizedUrl + }); + }); + } else { + handleLoad(null, { + load: url, + original: asset2 && asset2.file.filename || url + }); + } + } + } + _loadNull(handler, callback, asset2) { + const onLoad = function onLoad2(err, data2, extra) { + if (err) { + callback(err); + } else { + try { + callback(null, handler.open(null, data2, asset2), extra); + } catch (e) { + callback(e); + } + } + }; + handler.load(null, onLoad, asset2); + } + _onSuccess(key, result, extra) { + if (result !== null) { + this._cache[key] = result; + } else { + delete this._cache[key]; + } + for (let i = 0; i < this._requests[key].length; i++) { + this._requests[key][i](null, result, extra); + } + delete this._requests[key]; + } + _onFailure(key, err) { + console.error(err); + if (this._requests[key]) { + for (let i = 0; i < this._requests[key].length; i++) { + this._requests[key][i](err); + } + delete this._requests[key]; + } + } + open(type2, data2) { + const handler = this._handlers[type2]; + if (!handler) { + console.warn("No resource handler found for: " + type2); + return data2; + } + return handler.open(null, data2); + } + patch(asset2, assets) { + const handler = this._handlers[asset2.type]; + if (!handler) { + console.warn("No resource handler found for: " + asset2.type); + return; + } + if (handler.patch) { + handler.patch(asset2, assets); + } + } + clearCache(url, type2) { + const key = _ResourceLoader.makeKey(url, type2); + delete this._cache[key]; + } + getFromCache(url, type2) { + const key = _ResourceLoader.makeKey(url, type2); + if (this._cache[key]) { + return this._cache[key]; + } + return void 0; + } + enableRetry(maxRetries = 5) { + maxRetries = Math.max(0, maxRetries) || 0; + for (const key in this._handlers) { + this._handlers[key].maxRetries = maxRetries; + } + } + disableRetry() { + for (const key in this._handlers) { + this._handlers[key].maxRetries = 0; + } + } + destroy() { + this._handlers = {}; + this._requests = {}; + this._cache = {}; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/i18n/i18n-parser.js +var I18nParser = class { + _validate(data2) { + if (!data2.header) { + throw new Error('pc.I18n#addData: Missing "header" field'); + } + if (!data2.header.version) { + throw new Error('pc.I18n#addData: Missing "header.version" field'); + } + if (data2.header.version !== 1) { + throw new Error('pc.I18n#addData: Invalid "header.version" field'); + } + if (!data2.data) { + throw new Error('pc.I18n#addData: Missing "data" field'); + } else if (!Array.isArray(data2.data)) { + throw new Error('pc.I18n#addData: "data" field must be an array'); + } + for (let i = 0, len = data2.data.length; i < len; i++) { + const entry = data2.data[i]; + if (!entry.info) { + throw new Error(`pc.I18n#addData: missing "data[${i}].info" field`); + } + if (!entry.info.locale) { + throw new Error(`pc.I18n#addData: missing "data[${i}].info.locale" field`); + } + if (typeof entry.info.locale !== "string") { + throw new Error(`pc.I18n#addData: "data[${i}].info.locale" must be a string`); + } + if (!entry.messages) { + throw new Error(`pc.I18n#addData: missing "data[${i}].messages" field`); + } + } + } + parse(data2) { + return data2.data; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/i18n/i18n.js +var I18n = class extends EventHandler { + constructor(app2) { + super(); + this.locale = DEFAULT_LOCALE; + this._translations = {}; + this._availableLangs = {}; + this._app = app2; + this._assets = []; + this._parser = new I18nParser(); + } + set assets(value) { + const index = {}; + for (let _i = 0, len = value.length; _i < len; _i++) { + const id12 = value[_i] instanceof Asset ? value[_i].id : value[_i]; + index[id12] = true; + } + let i = this._assets.length; + while (i--) { + const id12 = this._assets[i]; + if (!index[id12]) { + this._app.assets.off("add:" + id12, this._onAssetAdd, this); + const asset2 = this._app.assets.get(id12); + if (asset2) { + this._onAssetRemove(asset2); + } + this._assets.splice(i, 1); + } + } + for (const id12 in index) { + const idNum = parseInt(id12, 10); + if (this._assets.indexOf(idNum) !== -1) continue; + this._assets.push(idNum); + const asset2 = this._app.assets.get(idNum); + if (!asset2) { + this._app.assets.once("add:" + idNum, this._onAssetAdd, this); + } else { + this._onAssetAdd(asset2); + } + } + } + get assets() { + return this._assets; + } + set locale(value) { + if (this._locale === value) { + return; + } + let lang = getLang(value); + if (lang === "in") { + lang = "id"; + value = replaceLang(value, lang); + if (this._locale === value) { + return; + } + } + const old = this._locale; + this._locale = value; + this._lang = lang; + this._pluralFn = getPluralFn(this._lang); + this.fire("set:locale", value, old); + } + get locale() { + return this._locale; + } + static findAvailableLocale(desiredLocale, availableLocales) { + return findAvailableLocale(desiredLocale, availableLocales); + } + findAvailableLocale(desiredLocale) { + if (this._translations[desiredLocale]) { + return desiredLocale; + } + const lang = getLang(desiredLocale); + return this._findFallbackLocale(desiredLocale, lang); + } + getText(key, locale) { + let result = key; + let lang; + if (!locale) { + locale = this._locale; + lang = this._lang; + } + let translations = this._translations[locale]; + if (!translations) { + if (!lang) { + lang = getLang(locale); + } + locale = this._findFallbackLocale(locale, lang); + translations = this._translations[locale]; + } + if (translations && translations.hasOwnProperty(key)) { + result = translations[key]; + if (Array.isArray(result)) { + result = result[0]; + } + if (result === null || result === void 0) { + result = key; + } + } + return result; + } + getPluralText(key, n, locale) { + let result = key; + let lang; + let pluralFn; + if (!locale) { + locale = this._locale; + lang = this._lang; + pluralFn = this._pluralFn; + } else { + lang = getLang(locale); + pluralFn = getPluralFn(lang); + } + let translations = this._translations[locale]; + if (!translations) { + locale = this._findFallbackLocale(locale, lang); + lang = getLang(locale); + pluralFn = getPluralFn(lang); + translations = this._translations[locale]; + } + if (translations && translations[key] && pluralFn) { + const index = pluralFn(n); + result = translations[key][index]; + if (result === null || result === void 0) { + result = key; + } + } + return result; + } + addData(data2) { + let parsed; + try { + parsed = this._parser.parse(data2); + } catch (err) { + console.error(err); + return; + } + for (let i = 0, len = parsed.length; i < len; i++) { + const entry = parsed[i]; + const locale = entry.info.locale; + const messages = entry.messages; + if (!this._translations[locale]) { + this._translations[locale] = {}; + const lang = getLang(locale); + if (!this._availableLangs[lang]) { + this._availableLangs[lang] = locale; + } + } + Object.assign(this._translations[locale], messages); + this.fire("data:add", locale, messages); + } + } + removeData(data2) { + let parsed; + try { + parsed = this._parser.parse(data2); + } catch (err) { + console.error(err); + return; + } + for (let i = 0, len = parsed.length; i < len; i++) { + const entry = parsed[i]; + const locale = entry.info.locale; + const translations = this._translations[locale]; + if (!translations) continue; + const messages = entry.messages; + for (const key in messages) { + delete translations[key]; + } + if (Object.keys(translations).length === 0) { + delete this._translations[locale]; + delete this._availableLangs[getLang(locale)]; + } + this.fire("data:remove", locale, messages); + } + } + destroy() { + this._translations = null; + this._availableLangs = null; + this._assets = null; + this._parser = null; + this.off(); + } + _findFallbackLocale(locale, lang) { + let result = DEFAULT_LOCALE_FALLBACKS[locale]; + if (result && this._translations[result]) { + return result; + } + result = DEFAULT_LOCALE_FALLBACKS[lang]; + if (result && this._translations[result]) { + return result; + } + result = this._availableLangs[lang]; + if (result && this._translations[result]) { + return result; + } + return DEFAULT_LOCALE; + } + _onAssetAdd(asset2) { + asset2.on("load", this._onAssetLoad, this); + asset2.on("change", this._onAssetChange, this); + asset2.on("remove", this._onAssetRemove, this); + asset2.on("unload", this._onAssetUnload, this); + if (asset2.resource) { + this._onAssetLoad(asset2); + } + } + _onAssetLoad(asset2) { + this.addData(asset2.resource); + } + _onAssetChange(asset2) { + if (asset2.resource) { + this.addData(asset2.resource); + } + } + _onAssetRemove(asset2) { + asset2.off("load", this._onAssetLoad, this); + asset2.off("change", this._onAssetChange, this); + asset2.off("remove", this._onAssetRemove, this); + asset2.off("unload", this._onAssetUnload, this); + if (asset2.resource) { + this.removeData(asset2.resource); + } + this._app.assets.once("add:" + asset2.id, this._onAssetAdd, this); + } + _onAssetUnload(asset2) { + if (asset2.resource) { + this.removeData(asset2.resource); + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/script/script-registry.js +var ScriptRegistry = class extends EventHandler { + constructor(app2) { + super(); + this._scripts = {}; + this._list = []; + this.app = app2; + } + destroy() { + this.app = null; + this.off(); + } + add(script2) { + const scriptName = script2.__name; + if (this._scripts.hasOwnProperty(scriptName)) { + setTimeout(() => { + if (script2.prototype.swap) { + const old = this._scripts[scriptName]; + const ind = this._list.indexOf(old); + this._list[ind] = script2; + this._scripts[scriptName] = script2; + this.fire("swap", scriptName, script2); + this.fire("swap:" + scriptName, script2); + } else { + console.warn(`script registry already has '${scriptName}' script, define 'swap' method for new script type to enable code hot swapping`); + } + }); + return false; + } + this._scripts[scriptName] = script2; + this._list.push(script2); + this.fire("add", scriptName, script2); + this.fire("add:" + scriptName, script2); + setTimeout(() => { + if (!this._scripts.hasOwnProperty(scriptName)) return; + if (!this.app || !this.app.systems || !this.app.systems.script) { + return; + } + const components = this.app.systems.script._components; + let attributes; + const scriptInstances = []; + const scriptInstancesInitialized = []; + for (components.loopIndex = 0; components.loopIndex < components.length; components.loopIndex++) { + const component = components.items[components.loopIndex]; + if (component._scriptsIndex[scriptName] && component._scriptsIndex[scriptName].awaiting) { + if (component._scriptsData && component._scriptsData[scriptName]) attributes = component._scriptsData[scriptName].attributes; + const scriptInstance = component.create(scriptName, { + preloading: true, + ind: component._scriptsIndex[scriptName].ind, + attributes + }); + if (scriptInstance) scriptInstances.push(scriptInstance); + } + } + for (let i = 0; i < scriptInstances.length; i++) scriptInstances[i].__initializeAttributes(); + for (let i = 0; i < scriptInstances.length; i++) { + if (scriptInstances[i].enabled) { + scriptInstances[i]._initialized = true; + scriptInstancesInitialized.push(scriptInstances[i]); + if (scriptInstances[i].initialize) scriptInstances[i].initialize(); + } + } + for (let i = 0; i < scriptInstancesInitialized.length; i++) { + if (!scriptInstancesInitialized[i].enabled || scriptInstancesInitialized[i]._postInitialized) { + continue; + } + scriptInstancesInitialized[i]._postInitialized = true; + if (scriptInstancesInitialized[i].postInitialize) scriptInstancesInitialized[i].postInitialize(); + } + }); + return true; + } + remove(nameOrType) { + let scriptType = nameOrType; + let scriptName = nameOrType; + if (typeof scriptName !== "string") { + scriptName = scriptType.__name; + } else { + scriptType = this.get(scriptName); + } + if (this.get(scriptName) !== scriptType) return false; + delete this._scripts[scriptName]; + const ind = this._list.indexOf(scriptType); + this._list.splice(ind, 1); + this.fire("remove", scriptName, scriptType); + this.fire("remove:" + scriptName, scriptType); + return true; + } + get(name) { + return this._scripts[name] || null; + } + has(nameOrType) { + if (typeof nameOrType === "string") { + return this._scripts.hasOwnProperty(nameOrType); + } + if (!nameOrType) return false; + const scriptName = nameOrType.__name; + return this._scripts[scriptName] === nameOrType; + } + list() { + return this._list; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/entity.js +var _enableList = []; +var Entity = class _Entity extends GraphNode { + constructor(name, app2 = getApplication()) { + super(name); + this.anim = void 0; + this.animation = void 0; + this.audiolistener = void 0; + this.button = void 0; + this.camera = void 0; + this.collision = void 0; + this.element = void 0; + this.gsplat = void 0; + this.layoutchild = void 0; + this.layoutgroup = void 0; + this.light = void 0; + this.model = void 0; + this.particlesystem = void 0; + this.render = void 0; + this.rigidbody = void 0; + this.screen = void 0; + this.script = void 0; + this.scrollbar = void 0; + this.scrollview = void 0; + this.sound = void 0; + this.sprite = void 0; + this.c = {}; + this._app = void 0; + this._destroying = false; + this._guid = null; + this._template = false; + this._app = app2; + } + addComponent(type2, data2) { + const system = this._app.systems[type2]; + if (!system) { + return null; + } + if (this.c[type2]) { + return null; + } + return system.addComponent(this, data2); + } + removeComponent(type2) { + const system = this._app.systems[type2]; + if (!system) { + return; + } + if (!this.c[type2]) { + return; + } + system.removeComponent(this); + } + findComponent(type2) { + const entity = this.findOne(function(node) { + return node.c && node.c[type2]; + }); + return entity && entity.c[type2]; + } + findComponents(type2) { + const entities = this.find(function(node) { + return node.c && node.c[type2]; + }); + return entities.map(function(entity) { + return entity.c[type2]; + }); + } + findScript(nameOrType) { + const entity = this.findOne((node) => { + var _node$c; + return (_node$c = node.c) == null || (_node$c = _node$c.script) == null ? void 0 : _node$c.has(nameOrType); + }); + return entity == null ? void 0 : entity.c.script.get(nameOrType); + } + findScripts(nameOrType) { + const entities = this.find((node) => { + var _node$c2; + return (_node$c2 = node.c) == null || (_node$c2 = _node$c2.script) == null ? void 0 : _node$c2.has(nameOrType); + }); + return entities.map((entity) => entity.c.script.get(nameOrType)); + } + getGuid() { + if (!this._guid) { + this.setGuid(guid.create()); + } + return this._guid; + } + setGuid(guid2) { + const index = this._app._entityIndex; + if (this._guid) { + delete index[this._guid]; + } + this._guid = guid2; + index[this._guid] = this; + } + _notifyHierarchyStateChanged(node, enabled) { + let enableFirst = false; + if (node === this && _enableList.length === 0) enableFirst = true; + node._beingEnabled = true; + node._onHierarchyStateChanged(enabled); + if (node._onHierarchyStatePostChanged) _enableList.push(node); + const c2 = node._children; + for (let i = 0, len = c2.length; i < len; i++) { + if (c2[i]._enabled) this._notifyHierarchyStateChanged(c2[i], enabled); + } + node._beingEnabled = false; + if (enableFirst) { + for (let i = 0; i < _enableList.length; i++) { + _enableList[i]._onHierarchyStatePostChanged(); + } + _enableList.length = 0; + } + } + _onHierarchyStateChanged(enabled) { + super._onHierarchyStateChanged(enabled); + const components = this.c; + for (const type2 in components) { + if (components.hasOwnProperty(type2)) { + const component = components[type2]; + if (component.enabled) { + if (enabled) { + component.onEnable(); + } else { + component.onDisable(); + } + } + } + } + } + _onHierarchyStatePostChanged() { + const components = this.c; + for (const type2 in components) { + if (components.hasOwnProperty(type2)) components[type2].onPostStateChange(); + } + } + findByGuid(guid2) { + if (this._guid === guid2) return this; + const e = this._app._entityIndex[guid2]; + if (e && (e === this || e.isDescendantOf(this))) { + return e; + } + return null; + } + destroy() { + this._destroying = true; + for (const name in this.c) { + this.c[name].enabled = false; + } + for (const name in this.c) { + this.c[name].system.removeComponent(this); + } + super.destroy(); + if (this._guid) { + delete this._app._entityIndex[this._guid]; + } + this._destroying = false; + } + clone() { + const duplicatedIdsMap = {}; + const clone = this._cloneRecursively(duplicatedIdsMap); + duplicatedIdsMap[this.getGuid()] = clone; + resolveDuplicatedEntityReferenceProperties(this, this, clone, duplicatedIdsMap); + return clone; + } + _cloneRecursively(duplicatedIdsMap) { + const clone = new this.constructor(void 0, this._app); + super._cloneInternal(clone); + for (const type2 in this.c) { + const component = this.c[type2]; + component.system.cloneComponent(this, clone); + } + for (let i = 0; i < this._children.length; i++) { + const oldChild = this._children[i]; + if (oldChild instanceof _Entity) { + const newChild = oldChild._cloneRecursively(duplicatedIdsMap); + clone.addChild(newChild); + duplicatedIdsMap[oldChild.getGuid()] = newChild; + } + } + return clone; + } +}; +Entity.EVENT_DESTROY = "destroy"; +function resolveDuplicatedEntityReferenceProperties(oldSubtreeRoot, oldEntity, newEntity, duplicatedIdsMap) { + if (oldEntity instanceof Entity) { + const components = oldEntity.c; + for (const componentName in components) { + const component = components[componentName]; + const entityProperties = component.system.getPropertiesOfType("entity"); + for (let i = 0, len = entityProperties.length; i < len; i++) { + const propertyDescriptor = entityProperties[i]; + const propertyName = propertyDescriptor.name; + const oldEntityReferenceId = component[propertyName]; + const entityIsWithinOldSubtree = !!oldSubtreeRoot.findByGuid(oldEntityReferenceId); + if (entityIsWithinOldSubtree) { + const newEntityReferenceId = duplicatedIdsMap[oldEntityReferenceId].getGuid(); + if (newEntityReferenceId) { + newEntity.c[componentName][propertyName] = newEntityReferenceId; + } + } + } + } + if (components.script && !newEntity._app.useLegacyScriptAttributeCloning) { + newEntity.script.resolveDuplicatedEntityReferenceProperties(components.script, duplicatedIdsMap); + } + if (components.render) { + newEntity.render.resolveDuplicatedEntityReferenceProperties(components.render, duplicatedIdsMap); + } + if (components.anim) { + newEntity.anim.resolveDuplicatedEntityReferenceProperties(components.anim, duplicatedIdsMap); + } + const _old = oldEntity.children.filter(function(e) { + return e instanceof Entity; + }); + const _new = newEntity.children.filter(function(e) { + return e instanceof Entity; + }); + for (let i = 0, len = _old.length; i < len; i++) { + resolveDuplicatedEntityReferenceProperties(oldSubtreeRoot, _old[i], _new[i], duplicatedIdsMap); + } + } +} + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/scene-registry-item.js +var SceneRegistryItem = class { + constructor(name, url) { + this.name = void 0; + this.url = void 0; + this.data = null; + this._loading = false; + this._onLoadedCallbacks = []; + this.name = name; + this.url = url; + } + get loaded() { + return !!this.data; + } + get loading() { + return this._loading; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/scene-registry.js +var SceneRegistry = class { + constructor(app2) { + this._app = void 0; + this._list = []; + this._index = {}; + this._urlIndex = {}; + this._app = app2; + } + destroy() { + this._app = null; + } + list() { + return this._list; + } + add(name, url) { + if (this._index.hasOwnProperty(name)) { + return false; + } + const item = new SceneRegistryItem(name, url); + const i = this._list.push(item); + this._index[item.name] = i - 1; + this._urlIndex[item.url] = i - 1; + return true; + } + find(name) { + if (this._index.hasOwnProperty(name)) { + return this._list[this._index[name]]; + } + return null; + } + findByUrl(url) { + if (this._urlIndex.hasOwnProperty(url)) { + return this._list[this._urlIndex[url]]; + } + return null; + } + remove(name) { + if (this._index.hasOwnProperty(name)) { + const idx = this._index[name]; + let item = this._list[idx]; + delete this._urlIndex[item.url]; + delete this._index[name]; + this._list.splice(idx, 1); + for (let i = 0; i < this._list.length; i++) { + item = this._list[i]; + this._index[item.name] = i; + this._urlIndex[item.url] = i; + } + } + } + _loadSceneData(sceneItem, storeInCache, callback) { + const app2 = this._app; + let url = sceneItem; + if (typeof sceneItem === "string") { + sceneItem = this.findByUrl(url) || this.find(url) || new SceneRegistryItem("Untitled", url); + } + url = sceneItem.url; + if (!url) { + callback("Cannot find scene to load"); + return; + } + if (sceneItem.loaded) { + callback(null, sceneItem); + return; + } + if (app2.assets && app2.assets.prefix && !ABSOLUTE_URL.test(url)) { + url = path.join(app2.assets.prefix, url); + } + sceneItem._onLoadedCallbacks.push(callback); + if (!sceneItem._loading) { + const handler = app2.loader.getHandler("hierarchy"); + handler.load(url, (err, data2) => { + sceneItem.data = data2; + sceneItem._loading = false; + for (let i = 0; i < sceneItem._onLoadedCallbacks.length; i++) { + sceneItem._onLoadedCallbacks[i](err, sceneItem); + } + if (!storeInCache) { + sceneItem.data = null; + } + sceneItem._onLoadedCallbacks.length = 0; + }); + } + sceneItem._loading = true; + } + loadSceneData(sceneItem, callback) { + this._loadSceneData(sceneItem, true, callback); + } + unloadSceneData(sceneItem) { + if (typeof sceneItem === "string") { + sceneItem = this.findByUrl(sceneItem); + } + if (sceneItem) { + sceneItem.data = null; + } + } + _loadSceneHierarchy(sceneItem, onBeforeAddHierarchy, callback) { + this._loadSceneData(sceneItem, false, (err, sceneItem2) => { + if (err) { + if (callback) { + callback(err); + } + return; + } + if (onBeforeAddHierarchy) { + onBeforeAddHierarchy(sceneItem2); + } + const app2 = this._app; + const _loaded = () => { + const handler = app2.loader.getHandler("hierarchy"); + app2.systems.script.preloading = true; + const entity = handler.open(sceneItem2.url, sceneItem2.data); + app2.systems.script.preloading = false; + app2.loader.clearCache(sceneItem2.url, "hierarchy"); + app2.root.addChild(entity); + app2.systems.fire("initialize", entity); + app2.systems.fire("postInitialize", entity); + app2.systems.fire("postPostInitialize", entity); + if (callback) callback(null, entity); + }; + app2._preloadScripts(sceneItem2.data, _loaded); + }); + } + loadSceneHierarchy(sceneItem, callback) { + this._loadSceneHierarchy(sceneItem, null, callback); + } + loadSceneSettings(sceneItem, callback) { + this._loadSceneData(sceneItem, false, (err, sceneItem2) => { + if (!err) { + this._app.applySceneSettings(sceneItem2.data.settings); + if (callback) { + callback(null); + } + } else { + if (callback) { + callback(err); + } + } + }); + } + changeScene(sceneItem, callback) { + const app2 = this._app; + const onBeforeAddHierarchy = (sceneItem2) => { + const { + children + } = app2.root; + while (children.length) { + children[0].destroy(); + } + app2.applySceneSettings(sceneItem2.data.settings); + }; + this._loadSceneHierarchy(sceneItem, onBeforeAddHierarchy, callback); + } + loadScene(url, callback) { + const app2 = this._app; + const handler = app2.loader.getHandler("scene"); + if (app2.assets && app2.assets.prefix && !ABSOLUTE_URL.test(url)) { + url = path.join(app2.assets.prefix, url); + } + handler.load(url, (err, data2) => { + if (!err) { + const _loaded = () => { + app2.systems.script.preloading = true; + const scene2 = handler.open(url, data2); + const sceneItem = this.findByUrl(url); + if (sceneItem && !sceneItem.loaded) { + sceneItem.data = data2; + } + app2.systems.script.preloading = false; + app2.loader.clearCache(url, "scene"); + app2.loader.patch({ + resource: scene2, + type: "scene" + }, app2.assets); + app2.root.addChild(scene2.root); + if (app2.systems.rigidbody && typeof Ammo !== "undefined") { + app2.systems.rigidbody.gravity.set(scene2._gravity.x, scene2._gravity.y, scene2._gravity.z); + } + if (callback) { + callback(null, scene2); + } + }; + app2._preloadScripts(data2, _loaded); + } else { + if (callback) { + callback(err); + } + } + }); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/stats.js +var ApplicationStats = class { + constructor(device) { + this.frame = { + fps: 0, + ms: 0, + dt: 0, + updateStart: 0, + updateTime: 0, + renderStart: 0, + renderTime: 0, + physicsStart: 0, + physicsTime: 0, + cullTime: 0, + sortTime: 0, + skinTime: 0, + morphTime: 0, + instancingTime: 0, + triangles: 0, + otherPrimitives: 0, + shaders: 0, + materials: 0, + cameras: 0, + shadowMapUpdates: 0, + shadowMapTime: 0, + depthMapTime: 0, + forwardTime: 0, + lightClustersTime: 0, + lightClusters: 0, + _timeToCountFrames: 0, + _fpsAccum: 0 + }; + this.drawCalls = { + forward: 0, + depth: 0, + shadow: 0, + immediate: 0, + misc: 0, + total: 0, + skinned: 0, + instanced: 0, + removedByInstancing: 0 + }; + this.misc = { + renderTargetCreationTime: 0 + }; + this.particles = { + updatesPerFrame: 0, + _updatesPerFrame: 0, + frameTime: 0, + _frameTime: 0 + }; + this.shaders = device._shaderStats; + this.vram = device._vram; + Object.defineProperty(this.vram, "totalUsed", { + get: function() { + return this.tex + this.vb + this.ib; + } + }); + Object.defineProperty(this.vram, "geom", { + get: function() { + return this.vb + this.ib; + } + }); + } + get scene() { + return getApplication().scene._stats; + } + get lightmapper() { + var _getApplication$light; + return (_getApplication$light = getApplication().lightmapper) == null ? void 0 : _getApplication$light.stats; + } + get batcher() { + const batcher = getApplication()._batcher; + return batcher ? batcher._stats : null; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/app-base.js +var Progress = class { + constructor(length) { + this.length = length; + this.count = 0; + } + inc() { + this.count++; + } + done() { + return this.count === this.length; + } +}; +var app = null; +var AppBase = class _AppBase extends EventHandler { + constructor(canvas) { + super(); + this.frameRequestId = void 0; + _AppBase._applications[canvas.id] = this; + setApplication(this); + app = this; + this._destroyRequested = false; + this._inFrameUpdate = false; + this._time = 0; + this.timeScale = 1; + this.maxDeltaTime = 0.1; + this.frame = 0; + this.autoRender = true; + this.renderNextFrame = false; + this.useLegacyScriptAttributeCloning = script.legacy; + this._librariesLoaded = false; + this._fillMode = FILLMODE_KEEP_ASPECT; + this._resolutionMode = RESOLUTION_FIXED; + this._allowResize = true; + this.context = this; + } + init(appOptions) { + const device = appOptions.graphicsDevice; + this.graphicsDevice = device; + this._initDefaultMaterial(); + this._initProgramLibrary(); + this.stats = new ApplicationStats(device); + this._soundManager = appOptions.soundManager; + this.loader = new ResourceLoader(this); + this._entityIndex = {}; + this.scene = new Scene(device); + this._registerSceneImmediate(this.scene); + this.root = new Entity(); + this.root._enabledInHierarchy = true; + this.assets = new AssetRegistry(this.loader); + if (appOptions.assetPrefix) this.assets.prefix = appOptions.assetPrefix; + this.bundles = new BundleRegistry(this.assets); + this.enableBundles = typeof TextDecoder !== "undefined"; + this.scriptsOrder = appOptions.scriptsOrder || []; + this.scripts = new ScriptRegistry(this); + this.i18n = new I18n(this); + this.scenes = new SceneRegistry(this); + this.defaultLayerWorld = new Layer({ + name: "World", + id: LAYERID_WORLD + }); + this.defaultLayerDepth = new Layer({ + name: "Depth", + id: LAYERID_DEPTH, + enabled: false, + opaqueSortMode: SORTMODE_NONE + }); + this.defaultLayerSkybox = new Layer({ + name: "Skybox", + id: LAYERID_SKYBOX, + opaqueSortMode: SORTMODE_NONE + }); + this.defaultLayerUi = new Layer({ + name: "UI", + id: LAYERID_UI, + transparentSortMode: SORTMODE_MANUAL + }); + this.defaultLayerImmediate = new Layer({ + name: "Immediate", + id: LAYERID_IMMEDIATE, + opaqueSortMode: SORTMODE_NONE + }); + const defaultLayerComposition = new LayerComposition("default"); + defaultLayerComposition.pushOpaque(this.defaultLayerWorld); + defaultLayerComposition.pushOpaque(this.defaultLayerDepth); + defaultLayerComposition.pushOpaque(this.defaultLayerSkybox); + defaultLayerComposition.pushTransparent(this.defaultLayerWorld); + defaultLayerComposition.pushOpaque(this.defaultLayerImmediate); + defaultLayerComposition.pushTransparent(this.defaultLayerImmediate); + defaultLayerComposition.pushTransparent(this.defaultLayerUi); + this.scene.layers = defaultLayerComposition; + AreaLightLuts.createPlaceholder(device); + this.renderer = new ForwardRenderer(device); + this.renderer.scene = this.scene; + this.frameGraph = new FrameGraph(); + this.lightmapper = null; + if (appOptions.lightmapper) { + this.lightmapper = new appOptions.lightmapper(device, this.root, this.scene, this.renderer, this.assets); + this.once("prerender", this._firstBake, this); + } + this._batcher = null; + if (appOptions.batchManager) { + this._batcher = new appOptions.batchManager(device, this.root, this.scene); + this.once("prerender", this._firstBatch, this); + } + this.keyboard = appOptions.keyboard || null; + this.mouse = appOptions.mouse || null; + this.touch = appOptions.touch || null; + this.gamepads = appOptions.gamepads || null; + this.elementInput = appOptions.elementInput || null; + if (this.elementInput) this.elementInput.app = this; + this.xr = appOptions.xr ? new appOptions.xr(this) : null; + if (this.elementInput) this.elementInput.attachSelectEvents(); + this._inTools = false; + this._skyboxAsset = null; + this._scriptPrefix = appOptions.scriptPrefix || ""; + if (this.enableBundles) { + this.loader.addHandler("bundle", new BundleHandler(this)); + } + appOptions.resourceHandlers.forEach((resourceHandler) => { + const handler = new resourceHandler(this); + this.loader.addHandler(handler.handlerType, handler); + }); + this.systems = new ComponentSystemRegistry(); + appOptions.componentSystems.forEach((componentSystem) => { + this.systems.add(new componentSystem(this)); + }); + this._visibilityChangeHandler = this.onVisibilityChange.bind(this); + if (typeof document !== "undefined") { + if (document.hidden !== void 0) { + this._hiddenAttr = "hidden"; + document.addEventListener("visibilitychange", this._visibilityChangeHandler, false); + } else if (document.mozHidden !== void 0) { + this._hiddenAttr = "mozHidden"; + document.addEventListener("mozvisibilitychange", this._visibilityChangeHandler, false); + } else if (document.msHidden !== void 0) { + this._hiddenAttr = "msHidden"; + document.addEventListener("msvisibilitychange", this._visibilityChangeHandler, false); + } else if (document.webkitHidden !== void 0) { + this._hiddenAttr = "webkitHidden"; + document.addEventListener("webkitvisibilitychange", this._visibilityChangeHandler, false); + } + } + this.tick = makeTick(this); + } + static getApplication(id12) { + return id12 ? _AppBase._applications[id12] : getApplication(); + } + _initDefaultMaterial() { + const material = new StandardMaterial(); + material.name = "Default Material"; + material.shadingModel = SPECULAR_BLINN; + setDefaultMaterial(this.graphicsDevice, material); + } + _initProgramLibrary() { + const library = new ProgramLibrary(this.graphicsDevice, new StandardMaterial()); + setProgramLibrary(this.graphicsDevice, library); + } + get soundManager() { + return this._soundManager; + } + get batcher() { + return this._batcher; + } + get fillMode() { + return this._fillMode; + } + get resolutionMode() { + return this._resolutionMode; + } + configure(url, callback) { + http.get(url, (err, response) => { + if (err) { + callback(err); + return; + } + const props = response.application_properties; + const scenes = response.scenes; + const assets = response.assets; + this._parseApplicationProperties(props, (err2) => { + this._parseScenes(scenes); + this._parseAssets(assets); + if (!err2) { + callback(null); + } else { + callback(err2); + } + }); + }); + } + preload(callback) { + this.fire("preload:start"); + const assets = this.assets.list({ + preload: true + }); + const progress = new Progress(assets.length); + let _done = false; + const done = () => { + if (!this.graphicsDevice) { + return; + } + if (!_done && progress.done()) { + _done = true; + this.fire("preload:end"); + callback(); + } + }; + const total = assets.length; + if (progress.length) { + const onAssetLoad = (asset2) => { + progress.inc(); + this.fire("preload:progress", progress.count / total); + if (progress.done()) done(); + }; + const onAssetError = (err, asset2) => { + progress.inc(); + this.fire("preload:progress", progress.count / total); + if (progress.done()) done(); + }; + for (let i = 0; i < assets.length; i++) { + if (!assets[i].loaded) { + assets[i].once("load", onAssetLoad); + assets[i].once("error", onAssetError); + this.assets.load(assets[i]); + } else { + progress.inc(); + this.fire("preload:progress", progress.count / total); + if (progress.done()) done(); + } + } + } else { + done(); + } + } + _preloadScripts(sceneData, callback) { + if (!script.legacy) { + callback(); + return; + } + this.systems.script.preloading = true; + const scripts = this._getScriptReferences(sceneData); + const l = scripts.length; + const progress = new Progress(l); + const regex = /^http(s)?:\/\//; + if (l) { + const onLoad = (err, ScriptType) => { + if (err) console.error(err); + progress.inc(); + if (progress.done()) { + this.systems.script.preloading = false; + callback(); + } + }; + for (let i = 0; i < l; i++) { + let scriptUrl = scripts[i]; + if (!regex.test(scriptUrl.toLowerCase()) && this._scriptPrefix) scriptUrl = path.join(this._scriptPrefix, scripts[i]); + this.loader.load(scriptUrl, "script", onLoad); + } + } else { + this.systems.script.preloading = false; + callback(); + } + } + _parseApplicationProperties(props, callback) { + if (typeof props.maxAssetRetries === "number" && props.maxAssetRetries > 0) { + this.loader.enableRetry(props.maxAssetRetries); + } + if (!props.useDevicePixelRatio) props.useDevicePixelRatio = props.use_device_pixel_ratio; + if (!props.resolutionMode) props.resolutionMode = props.resolution_mode; + if (!props.fillMode) props.fillMode = props.fill_mode; + this._width = props.width; + this._height = props.height; + if (props.useDevicePixelRatio) { + this.graphicsDevice.maxPixelRatio = window.devicePixelRatio; + } + this.setCanvasResolution(props.resolutionMode, this._width, this._height); + this.setCanvasFillMode(props.fillMode, this._width, this._height); + if (props.layers && props.layerOrder) { + const composition = new LayerComposition("application"); + const layers = {}; + for (const key in props.layers) { + const data2 = props.layers[key]; + data2.id = parseInt(key, 10); + data2.enabled = data2.id !== LAYERID_DEPTH; + layers[key] = new Layer(data2); + } + for (let i = 0, len = props.layerOrder.length; i < len; i++) { + const sublayer = props.layerOrder[i]; + const layer = layers[sublayer.layer]; + if (!layer) continue; + if (sublayer.transparent) { + composition.pushTransparent(layer); + } else { + composition.pushOpaque(layer); + } + composition.subLayerEnabled[i] = sublayer.enabled; + } + this.scene.layers = composition; + } + if (props.batchGroups) { + const batcher = this.batcher; + if (batcher) { + for (let i = 0, len = props.batchGroups.length; i < len; i++) { + const grp = props.batchGroups[i]; + batcher.addGroup(grp.name, grp.dynamic, grp.maxAabbSize, grp.id, grp.layers); + } + } + } + if (props.i18nAssets) { + this.i18n.assets = props.i18nAssets; + } + this._loadLibraries(props.libraries, callback); + } + _loadLibraries(urls, callback) { + const len = urls.length; + let count = len; + const regex = /^http(s)?:\/\//; + if (len) { + const onLoad = (err, script2) => { + count--; + if (err) { + callback(err); + } else if (count === 0) { + this.onLibrariesLoaded(); + callback(null); + } + }; + for (let i = 0; i < len; ++i) { + let url = urls[i]; + if (!regex.test(url.toLowerCase()) && this._scriptPrefix) url = path.join(this._scriptPrefix, url); + this.loader.load(url, "script", onLoad); + } + } else { + this.onLibrariesLoaded(); + callback(null); + } + } + _parseScenes(scenes) { + if (!scenes) return; + for (let i = 0; i < scenes.length; i++) { + this.scenes.add(scenes[i].name, scenes[i].url); + } + } + _parseAssets(assets) { + const list = []; + const scriptsIndex = {}; + const bundlesIndex = {}; + if (!script.legacy) { + for (let i = 0; i < this.scriptsOrder.length; i++) { + const id12 = this.scriptsOrder[i]; + if (!assets[id12]) continue; + scriptsIndex[id12] = true; + list.push(assets[id12]); + } + if (this.enableBundles) { + for (const id12 in assets) { + if (assets[id12].type === "bundle") { + bundlesIndex[id12] = true; + list.push(assets[id12]); + } + } + } + for (const id12 in assets) { + if (scriptsIndex[id12] || bundlesIndex[id12]) continue; + list.push(assets[id12]); + } + } else { + if (this.enableBundles) { + for (const id12 in assets) { + if (assets[id12].type === "bundle") { + bundlesIndex[id12] = true; + list.push(assets[id12]); + } + } + } + for (const id12 in assets) { + if (bundlesIndex[id12]) continue; + list.push(assets[id12]); + } + } + for (let i = 0; i < list.length; i++) { + const data2 = list[i]; + const asset2 = new Asset(data2.name, data2.type, data2.file, data2.data); + asset2.id = parseInt(data2.id, 10); + asset2.preload = data2.preload ? data2.preload : false; + asset2.loaded = data2.type === "script" && data2.data && data2.data.loadingType > 0; + asset2.tags.add(data2.tags); + if (data2.i18n) { + for (const locale in data2.i18n) { + asset2.addLocalizedAssetId(locale, data2.i18n[locale]); + } + } + this.assets.add(asset2); + } + } + _getScriptReferences(scene2) { + let priorityScripts = []; + if (scene2.settings.priority_scripts) { + priorityScripts = scene2.settings.priority_scripts; + } + const _scripts = []; + const _index = {}; + for (let i = 0; i < priorityScripts.length; i++) { + _scripts.push(priorityScripts[i]); + _index[priorityScripts[i]] = true; + } + const entities = scene2.entities; + for (const key in entities) { + if (!entities[key].components.script) { + continue; + } + const scripts = entities[key].components.script.scripts; + for (let i = 0; i < scripts.length; i++) { + if (_index[scripts[i].url]) continue; + _scripts.push(scripts[i].url); + _index[scripts[i].url] = true; + } + } + return _scripts; + } + start() { + this.frame = 0; + this.fire("start", { + timestamp: now(), + target: this + }); + if (!this._librariesLoaded) { + this.onLibrariesLoaded(); + } + this.systems.fire("initialize", this.root); + this.fire("initialize"); + this.systems.fire("postInitialize", this.root); + this.systems.fire("postPostInitialize", this.root); + this.fire("postinitialize"); + this.tick(); + } + inputUpdate(dt) { + if (this.controller) { + this.controller.update(dt); + } + if (this.mouse) { + this.mouse.update(); + } + if (this.keyboard) { + this.keyboard.update(); + } + if (this.gamepads) { + this.gamepads.update(); + } + } + update(dt) { + this.frame++; + this.graphicsDevice.updateClientRect(); + if (script.legacy) this.systems.fire("fixedUpdate", 1 / 60); + this.systems.fire(this._inTools ? "toolsUpdate" : "update", dt); + this.systems.fire("animationUpdate", dt); + this.systems.fire("postUpdate", dt); + this.fire("update", dt); + this.inputUpdate(dt); + } + frameStart() { + this.graphicsDevice.frameStart(); + } + frameEnd() { + this.graphicsDevice.frameEnd(); + } + render() { + this.fire("prerender"); + this.root.syncHierarchy(); + if (this._batcher) { + this._batcher.updateAll(); + } + this.renderComposition(this.scene.layers); + this.fire("postrender"); + } + renderComposition(layerComposition) { + this.renderer.buildFrameGraph(this.frameGraph, layerComposition); + this.frameGraph.render(this.graphicsDevice); + } + _fillFrameStatsBasic(now2, dt, ms) { + const stats = this.stats.frame; + stats.dt = dt; + stats.ms = ms; + if (now2 > stats._timeToCountFrames) { + stats.fps = stats._fpsAccum; + stats._fpsAccum = 0; + stats._timeToCountFrames = now2 + 1e3; + } else { + stats._fpsAccum++; + } + this.stats.drawCalls.total = this.graphicsDevice._drawCallsPerFrame; + this.graphicsDevice._drawCallsPerFrame = 0; + } + _fillFrameStats() { + let stats = this.stats.frame; + stats.cameras = this.renderer._camerasRendered; + stats.materials = this.renderer._materialSwitches; + stats.shaders = this.graphicsDevice._shaderSwitchesPerFrame; + stats.shadowMapUpdates = this.renderer._shadowMapUpdates; + stats.shadowMapTime = this.renderer._shadowMapTime; + stats.depthMapTime = this.renderer._depthMapTime; + stats.forwardTime = this.renderer._forwardTime; + const prims = this.graphicsDevice._primsPerFrame; + stats.triangles = prims[PRIMITIVE_TRIANGLES] / 3 + Math.max(prims[PRIMITIVE_TRISTRIP] - 2, 0) + Math.max(prims[PRIMITIVE_TRIFAN] - 2, 0); + stats.cullTime = this.renderer._cullTime; + stats.sortTime = this.renderer._sortTime; + stats.skinTime = this.renderer._skinTime; + stats.morphTime = this.renderer._morphTime; + stats.lightClusters = this.renderer._lightClusters; + stats.lightClustersTime = this.renderer._lightClustersTime; + stats.otherPrimitives = 0; + for (let i = 0; i < prims.length; i++) { + if (i < PRIMITIVE_TRIANGLES) { + stats.otherPrimitives += prims[i]; + } + prims[i] = 0; + } + this.renderer._camerasRendered = 0; + this.renderer._materialSwitches = 0; + this.renderer._shadowMapUpdates = 0; + this.graphicsDevice._shaderSwitchesPerFrame = 0; + this.renderer._cullTime = 0; + this.renderer._layerCompositionUpdateTime = 0; + this.renderer._lightClustersTime = 0; + this.renderer._sortTime = 0; + this.renderer._skinTime = 0; + this.renderer._morphTime = 0; + this.renderer._shadowMapTime = 0; + this.renderer._depthMapTime = 0; + this.renderer._forwardTime = 0; + stats = this.stats.drawCalls; + stats.forward = this.renderer._forwardDrawCalls; + stats.culled = this.renderer._numDrawCallsCulled; + stats.depth = 0; + stats.shadow = this.renderer._shadowDrawCalls; + stats.skinned = this.renderer._skinDrawCalls; + stats.immediate = 0; + stats.instanced = 0; + stats.removedByInstancing = 0; + stats.misc = stats.total - (stats.forward + stats.shadow); + this.renderer._depthDrawCalls = 0; + this.renderer._shadowDrawCalls = 0; + this.renderer._forwardDrawCalls = 0; + this.renderer._numDrawCallsCulled = 0; + this.renderer._skinDrawCalls = 0; + this.renderer._immediateRendered = 0; + this.renderer._instancedDrawCalls = 0; + this.stats.misc.renderTargetCreationTime = this.graphicsDevice.renderTargetCreationTime; + stats = this.stats.particles; + stats.updatesPerFrame = stats._updatesPerFrame; + stats.frameTime = stats._frameTime; + stats._updatesPerFrame = 0; + stats._frameTime = 0; + } + setCanvasFillMode(mode, width, height) { + this._fillMode = mode; + this.resizeCanvas(width, height); + } + setCanvasResolution(mode, width, height) { + this._resolutionMode = mode; + if (mode === RESOLUTION_AUTO && width === void 0) { + width = this.graphicsDevice.canvas.clientWidth; + height = this.graphicsDevice.canvas.clientHeight; + } + this.graphicsDevice.resizeCanvas(width, height); + } + isHidden() { + return document[this._hiddenAttr]; + } + onVisibilityChange() { + if (this.isHidden()) { + if (this._soundManager) { + this._soundManager.suspend(); + } + } else { + if (this._soundManager) { + this._soundManager.resume(); + } + } + } + resizeCanvas(width, height) { + if (!this._allowResize) return void 0; + if (this.xr && this.xr.session) return void 0; + const windowWidth = window.innerWidth; + const windowHeight = window.innerHeight; + if (this._fillMode === FILLMODE_KEEP_ASPECT) { + const r = this.graphicsDevice.canvas.width / this.graphicsDevice.canvas.height; + const winR = windowWidth / windowHeight; + if (r > winR) { + width = windowWidth; + height = width / r; + } else { + height = windowHeight; + width = height * r; + } + } else if (this._fillMode === FILLMODE_FILL_WINDOW) { + width = windowWidth; + height = windowHeight; + } + this.graphicsDevice.canvas.style.width = width + "px"; + this.graphicsDevice.canvas.style.height = height + "px"; + this.updateCanvasSize(); + return { + width, + height + }; + } + updateCanvasSize() { + var _this$xr; + if (!this._allowResize || (_this$xr = this.xr) != null && _this$xr.active) { + return; + } + if (this._resolutionMode === RESOLUTION_AUTO) { + const canvas = this.graphicsDevice.canvas; + this.graphicsDevice.resizeCanvas(canvas.clientWidth, canvas.clientHeight); + } + } + onLibrariesLoaded() { + this._librariesLoaded = true; + if (this.systems.rigidbody) { + this.systems.rigidbody.onLibraryLoaded(); + } + } + applySceneSettings(settings) { + let asset2; + if (this.systems.rigidbody && typeof Ammo !== "undefined") { + const gravity = settings.physics.gravity; + this.systems.rigidbody.gravity.set(gravity[0], gravity[1], gravity[2]); + } + this.scene.applySettings(settings); + if (settings.render.hasOwnProperty("skybox")) { + if (settings.render.skybox) { + asset2 = this.assets.get(settings.render.skybox); + if (asset2) { + this.setSkybox(asset2); + } else { + this.assets.once("add:" + settings.render.skybox, this.setSkybox, this); + } + } else { + this.setSkybox(null); + } + } + } + setAreaLightLuts(ltcMat1, ltcMat2) { + if (ltcMat1 && ltcMat2) { + AreaLightLuts.set(this.graphicsDevice, ltcMat1, ltcMat2); + } + } + setSkybox(asset2) { + if (asset2 !== this._skyboxAsset) { + const onSkyboxRemoved = () => { + this.setSkybox(null); + }; + const onSkyboxChanged = () => { + this.scene.setSkybox(this._skyboxAsset ? this._skyboxAsset.resources : null); + }; + if (this._skyboxAsset) { + this.assets.off("load:" + this._skyboxAsset.id, onSkyboxChanged, this); + this.assets.off("remove:" + this._skyboxAsset.id, onSkyboxRemoved, this); + this._skyboxAsset.off("change", onSkyboxChanged, this); + } + this._skyboxAsset = asset2; + if (this._skyboxAsset) { + this.assets.on("load:" + this._skyboxAsset.id, onSkyboxChanged, this); + this.assets.once("remove:" + this._skyboxAsset.id, onSkyboxRemoved, this); + this._skyboxAsset.on("change", onSkyboxChanged, this); + if (this.scene.skyboxMip === 0 && !this._skyboxAsset.loadFaces) { + this._skyboxAsset.loadFaces = true; + } + this.assets.load(this._skyboxAsset); + } + onSkyboxChanged(); + } + } + _firstBake() { + var _this$lightmapper; + (_this$lightmapper = this.lightmapper) == null || _this$lightmapper.bake(null, this.scene.lightmapMode); + } + _firstBatch() { + var _this$batcher; + (_this$batcher = this.batcher) == null || _this$batcher.generate(); + } + _processTimestamp(timestamp) { + return timestamp; + } + drawLine(start, end, color, depthTest, layer) { + this.scene.drawLine(start, end, color, depthTest, layer); + } + drawLines(positions, colors, depthTest = true, layer = this.scene.defaultDrawLayer) { + this.scene.drawLines(positions, colors, depthTest, layer); + } + drawLineArrays(positions, colors, depthTest = true, layer = this.scene.defaultDrawLayer) { + this.scene.drawLineArrays(positions, colors, depthTest, layer); + } + drawWireSphere(center2, radius, color = Color.WHITE, segments = 20, depthTest = true, layer = this.scene.defaultDrawLayer) { + this.scene.immediate.drawWireSphere(center2, radius, color, segments, depthTest, layer); + } + drawWireAlignedBox(minPoint, maxPoint, color = Color.WHITE, depthTest = true, layer = this.scene.defaultDrawLayer, mat) { + this.scene.immediate.drawWireAlignedBox(minPoint, maxPoint, color, depthTest, layer, mat); + } + drawMeshInstance(meshInstance, layer = this.scene.defaultDrawLayer) { + this.scene.immediate.drawMesh(null, null, null, meshInstance, layer); + } + drawMesh(mesh, material, matrix2, layer = this.scene.defaultDrawLayer) { + this.scene.immediate.drawMesh(material, matrix2, mesh, null, layer); + } + drawQuad(matrix2, material, layer = this.scene.defaultDrawLayer) { + this.scene.immediate.drawMesh(material, matrix2, this.scene.immediate.getQuadMesh(), null, layer); + } + drawTexture(x2, y2, width, height, texture, material, layer = this.scene.defaultDrawLayer, filterable = true) { + if (filterable === false && !this.graphicsDevice.isWebGPU) return; + const matrix2 = new Mat4(); + matrix2.setTRS(new Vec3(x2, y2, 0), Quat2.IDENTITY, new Vec3(width, -height, 0)); + if (!material) { + material = new Material(); + material.cull = CULLFACE_NONE; + material.setParameter("colorMap", texture); + material.shader = filterable ? this.scene.immediate.getTextureShader() : this.scene.immediate.getUnfilterableTextureShader(); + material.update(); + } + this.drawQuad(matrix2, material, layer); + } + drawDepthTexture(x2, y2, width, height, layer = this.scene.defaultDrawLayer) { + const material = new Material(); + material.cull = CULLFACE_NONE; + material.shader = this.scene.immediate.getDepthTextureShader(); + material.update(); + this.drawTexture(x2, y2, width, height, null, material, layer); + } + destroy() { + var _this$lightmapper2, _this$xr2, _this$xr3, _this$_soundManager; + if (this._inFrameUpdate) { + this._destroyRequested = true; + return; + } + const canvasId = this.graphicsDevice.canvas.id; + this.fire("destroy", this); + this.off("librariesloaded"); + if (typeof document !== "undefined") { + document.removeEventListener("visibilitychange", this._visibilityChangeHandler, false); + document.removeEventListener("mozvisibilitychange", this._visibilityChangeHandler, false); + document.removeEventListener("msvisibilitychange", this._visibilityChangeHandler, false); + document.removeEventListener("webkitvisibilitychange", this._visibilityChangeHandler, false); + } + this._visibilityChangeHandler = null; + this.root.destroy(); + this.root = null; + if (this.mouse) { + this.mouse.off(); + this.mouse.detach(); + this.mouse = null; + } + if (this.keyboard) { + this.keyboard.off(); + this.keyboard.detach(); + this.keyboard = null; + } + if (this.touch) { + this.touch.off(); + this.touch.detach(); + this.touch = null; + } + if (this.elementInput) { + this.elementInput.detach(); + this.elementInput = null; + } + if (this.gamepads) { + this.gamepads.destroy(); + this.gamepads = null; + } + if (this.controller) { + this.controller = null; + } + this.systems.destroy(); + if (this.scene.layers) { + this.scene.layers.destroy(); + } + const assets = this.assets.list(); + for (let i = 0; i < assets.length; i++) { + assets[i].unload(); + assets[i].off(); + } + this.assets.off(); + this.bundles.destroy(); + this.bundles = null; + this.i18n.destroy(); + this.i18n = null; + const scriptHandler = this.loader.getHandler("script"); + scriptHandler == null || scriptHandler.clearCache(); + this.loader.destroy(); + this.loader = null; + this.scene.destroy(); + this.scene = null; + this.systems = null; + this.context = null; + this.scripts.destroy(); + this.scripts = null; + this.scenes.destroy(); + this.scenes = null; + (_this$lightmapper2 = this.lightmapper) == null || _this$lightmapper2.destroy(); + this.lightmapper = null; + if (this._batcher) { + this._batcher.destroy(); + this._batcher = null; + } + this._entityIndex = {}; + this.defaultLayerDepth.onPreRenderOpaque = null; + this.defaultLayerDepth.onPostRenderOpaque = null; + this.defaultLayerDepth.onDisable = null; + this.defaultLayerDepth.onEnable = null; + this.defaultLayerDepth = null; + this.defaultLayerWorld = null; + (_this$xr2 = this.xr) == null || _this$xr2.end(); + (_this$xr3 = this.xr) == null || _this$xr3.destroy(); + this.renderer.destroy(); + this.renderer = null; + this.graphicsDevice.destroy(); + this.graphicsDevice = null; + this.tick = null; + this.off(); + (_this$_soundManager = this._soundManager) == null || _this$_soundManager.destroy(); + this._soundManager = null; + script.app = null; + _AppBase._applications[canvasId] = null; + if (getApplication() === this) { + setApplication(null); + } + _AppBase.cancelTick(this); + } + static cancelTick(app2) { + if (app2.frameRequestId) { + window.cancelAnimationFrame(app2.frameRequestId); + app2.frameRequestId = void 0; + } + } + getEntityFromIndex(guid2) { + return this._entityIndex[guid2]; + } + _registerSceneImmediate(scene2) { + this.on("postrender", scene2.immediate.onPostRender, scene2.immediate); + } +}; +AppBase._applications = {}; +var _frameEndData = {}; +var makeTick = function makeTick2(_app) { + const application = _app; + return function(timestamp, frame) { + var _application$xr2; + if (!application.graphicsDevice) return; + if (application.frameRequestId) { + var _application$xr; + (_application$xr = application.xr) == null || (_application$xr = _application$xr.session) == null || _application$xr.cancelAnimationFrame(application.frameRequestId); + cancelAnimationFrame(application.frameRequestId); + application.frameRequestId = null; + } + application._inFrameUpdate = true; + setApplication(application); + app = application; + const currentTime = application._processTimestamp(timestamp) || now(); + const ms = currentTime - (application._time || currentTime); + let dt = ms / 1e3; + dt = math.clamp(dt, 0, application.maxDeltaTime); + dt *= application.timeScale; + application._time = currentTime; + if ((_application$xr2 = application.xr) != null && _application$xr2.session) { + application.frameRequestId = application.xr.session.requestAnimationFrame(application.tick); + } else { + application.frameRequestId = platform.browser || platform.worker ? requestAnimationFrame(application.tick) : null; + } + if (application.graphicsDevice.contextLost) return; + application._fillFrameStatsBasic(currentTime, dt, ms); + application.fire("frameupdate", ms); + let shouldRenderFrame = true; + if (frame) { + var _application$xr3; + shouldRenderFrame = (_application$xr3 = application.xr) == null ? void 0 : _application$xr3.update(frame); + application.graphicsDevice.defaultFramebuffer = frame.session.renderState.baseLayer.framebuffer; + } else { + application.graphicsDevice.defaultFramebuffer = null; + } + if (shouldRenderFrame) { + application.update(dt); + application.fire("framerender"); + if (application.autoRender || application.renderNextFrame) { + application.updateCanvasSize(); + application.frameStart(); + application.render(); + application.frameEnd(); + application.renderNextFrame = false; + } + _frameEndData.timestamp = now(); + _frameEndData.target = application; + application.fire("frameend", _frameEndData); + } + application._inFrameUpdate = false; + if (application._destroyRequested) { + application.destroy(); + } + }; +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/app-options.js +var AppOptions = class { + constructor() { + this.elementInput = void 0; + this.keyboard = void 0; + this.mouse = void 0; + this.touch = void 0; + this.gamepads = void 0; + this.scriptPrefix = void 0; + this.assetPrefix = void 0; + this.scriptsOrder = void 0; + this.soundManager = void 0; + this.graphicsDevice = void 0; + this.lightmapper = void 0; + this.batchManager = void 0; + this.xr = void 0; + this.componentSystems = []; + this.resourceHandlers = []; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/components/component.js +var Component = class _Component extends EventHandler { + constructor(system, entity) { + super(); + this.system = void 0; + this.entity = void 0; + this.system = system; + this.entity = entity; + if (this.system.schema && !this._accessorsBuilt) { + this.buildAccessors(this.system.schema); + } + this.on("set", function(name, oldValue, newValue) { + this.fire("set_" + name, name, oldValue, newValue); + }); + this.on("set_enabled", this.onSetEnabled, this); + } + static _buildAccessors(obj, schema) { + schema.forEach(function(descriptor) { + const name = typeof descriptor === "object" ? descriptor.name : descriptor; + Object.defineProperty(obj, name, { + get: function() { + return this.data[name]; + }, + set: function(value) { + const data2 = this.data; + const oldValue = data2[name]; + data2[name] = value; + this.fire("set", name, oldValue, value); + }, + configurable: true + }); + }); + obj._accessorsBuilt = true; + } + buildAccessors(schema) { + _Component._buildAccessors(this, schema); + } + onSetEnabled(name, oldValue, newValue) { + if (oldValue !== newValue) { + if (this.entity.enabled) { + if (newValue) { + this.onEnable(); + } else { + this.onDisable(); + } + } + } + } + onEnable() { + } + onDisable() { + } + onPostStateChange() { + } + get data() { + const record = this.system.store[this.entity.getGuid()]; + return record ? record.data : null; + } + set enabled(arg) { + } + get enabled() { + return true; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/components/system.js +var ComponentSystem = class extends EventHandler { + constructor(app2) { + super(); + this.app = app2; + this.store = {}; + this.schema = []; + } + addComponent(entity, data2 = {}) { + const component = new this.ComponentType(this, entity); + const componentData = new this.DataType(); + this.store[entity.getGuid()] = { + entity, + data: componentData + }; + entity[this.id] = component; + entity.c[this.id] = component; + this.initializeComponentData(component, data2, []); + this.fire("add", entity, component); + return component; + } + removeComponent(entity) { + const record = this.store[entity.getGuid()]; + const component = entity.c[this.id]; + this.fire("beforeremove", entity, component); + delete this.store[entity.getGuid()]; + entity[this.id] = void 0; + delete entity.c[this.id]; + this.fire("remove", entity, record.data); + } + cloneComponent(entity, clone) { + const src = this.store[entity.getGuid()]; + return this.addComponent(clone, src.data); + } + initializeComponentData(component, data2 = {}, properties2) { + for (let i = 0, len = properties2.length; i < len; i++) { + const descriptor = properties2[i]; + let name, type2; + if (typeof descriptor === "object") { + name = descriptor.name; + type2 = descriptor.type; + } else { + name = descriptor; + type2 = void 0; + } + let value = data2[name]; + if (value !== void 0) { + if (type2 !== void 0) { + value = convertValue(value, type2); + } + component[name] = value; + } else { + component[name] = component.data[name]; + } + } + if (component.enabled && component.entity.enabled) { + component.onEnable(); + } + } + getPropertiesOfType(type2) { + const matchingProperties = []; + const schema = this.schema || []; + schema.forEach(function(descriptor) { + if (descriptor && typeof descriptor === "object" && descriptor.type === type2) { + matchingProperties.push(descriptor); + } + }); + return matchingProperties; + } + destroy() { + this.off(); + } +}; +function convertValue(value, type2) { + if (!value) { + return value; + } + switch (type2) { + case "rgb": + if (value instanceof Color) { + return value.clone(); + } + return new Color(value[0], value[1], value[2]); + case "rgba": + if (value instanceof Color) { + return value.clone(); + } + return new Color(value[0], value[1], value[2], value[3]); + case "vec2": + if (value instanceof Vec2) { + return value.clone(); + } + return new Vec2(value[0], value[1]); + case "vec3": + if (value instanceof Vec3) { + return value.clone(); + } + return new Vec3(value[0], value[1], value[2]); + case "vec4": + if (value instanceof Vec4) { + return value.clone(); + } + return new Vec4(value[0], value[1], value[2], value[3]); + case "boolean": + case "number": + case "string": + return value; + case "entity": + return value; + default: + throw new Error("Could not convert unhandled type: " + type2); + } +} + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/anim/constants.js +var INTERPOLATION_STEP = 0; +var INTERPOLATION_LINEAR = 1; +var INTERPOLATION_CUBIC = 2; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/anim/evaluator/anim-cache.js +var AnimCache = class { + constructor() { + this._left = Infinity; + this._right = -Infinity; + this._len = 0; + this._recip = 0; + this._p0 = 0; + this._p1 = 0; + this._t = 0; + this._hermite = { + valid: false, + p0: 0, + m0: 0, + p1: 0, + m1: 0 + }; + } + update(time2, input2) { + if (time2 < this._left || time2 >= this._right) { + const len = input2.length; + if (!len) { + this._left = -Infinity; + this._right = Infinity; + this._len = 0; + this._recip = 0; + this._p0 = this._p1 = 0; + } else { + if (time2 < input2[0]) { + this._left = -Infinity; + this._right = input2[0]; + this._len = 0; + this._recip = 0; + this._p0 = this._p1 = 0; + } else if (time2 >= input2[len - 1]) { + this._left = input2[len - 1]; + this._right = Infinity; + this._len = 0; + this._recip = 0; + this._p0 = this._p1 = len - 1; + } else { + const index = this._findKey(time2, input2); + this._left = input2[index]; + this._right = input2[index + 1]; + this._len = this._right - this._left; + const diff = 1 / this._len; + this._recip = isFinite(diff) ? diff : 0; + this._p0 = index; + this._p1 = index + 1; + } + } + } + this._t = this._recip === 0 ? 0 : (time2 - this._left) * this._recip; + this._hermite.valid = false; + } + _findKey(time2, input2) { + let index = 0; + while (time2 >= input2[index + 1]) { + index++; + } + return index; + } + eval(result, interpolation, output) { + const data2 = output._data; + const comp = output._components; + const idx0 = this._p0 * comp; + if (interpolation === INTERPOLATION_STEP) { + for (let i = 0; i < comp; ++i) { + result[i] = data2[idx0 + i]; + } + } else { + const t = this._t; + const idx1 = this._p1 * comp; + switch (interpolation) { + case INTERPOLATION_LINEAR: + for (let i = 0; i < comp; ++i) { + result[i] = math.lerp(data2[idx0 + i], data2[idx1 + i], t); + } + break; + case INTERPOLATION_CUBIC: { + const hermite = this._hermite; + if (!hermite.valid) { + const t2 = t * t; + const twot = t + t; + const omt = 1 - t; + const omt2 = omt * omt; + hermite.valid = true; + hermite.p0 = (1 + twot) * omt2; + hermite.m0 = t * omt2; + hermite.p1 = t2 * (3 - twot); + hermite.m1 = t2 * (t - 1); + } + const p0 = (this._p0 * 3 + 1) * comp; + const m0 = (this._p0 * 3 + 2) * comp; + const p12 = (this._p1 * 3 + 1) * comp; + const m1 = (this._p1 * 3 + 0) * comp; + for (let i = 0; i < comp; ++i) { + result[i] = hermite.p0 * data2[p0 + i] + hermite.m0 * data2[m0 + i] * this._len + hermite.p1 * data2[p12 + i] + hermite.m1 * data2[m1 + i] * this._len; + } + break; + } + } + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/anim/evaluator/anim-snapshot.js +var AnimSnapshot = class { + constructor(animTrack) { + this._name = animTrack.name + "Snapshot"; + this._time = -1; + this._cache = []; + this._results = []; + for (let i = 0; i < animTrack._inputs.length; ++i) { + this._cache[i] = new AnimCache(); + } + const curves = animTrack._curves; + const outputs = animTrack._outputs; + for (let i = 0; i < curves.length; ++i) { + const curve = curves[i]; + const output = outputs[curve._output]; + const storage = []; + for (let j = 0; j < output._components; ++j) { + storage[j] = 0; + } + this._results[i] = storage; + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/anim/evaluator/anim-clip.js +var AnimClip = class _AnimClip { + constructor(track, time2, speed, playing, loop, eventHandler) { + this._name = track.name; + this._track = track; + this._snapshot = new AnimSnapshot(track); + this._playing = playing; + this._time = time2; + this._speed = speed; + this._loop = loop; + this._blendWeight = 1; + this._blendOrder = 0; + this._eventHandler = eventHandler; + this.alignCursorToCurrentTime(); + } + set name(name) { + this._name = name; + } + get name() { + return this._name; + } + set track(track) { + this._track = track; + this._snapshot = new AnimSnapshot(track); + } + get track() { + return this._track; + } + get snapshot() { + return this._snapshot; + } + set time(time2) { + this._time = time2; + this.alignCursorToCurrentTime(); + } + get time() { + return this._time; + } + set speed(speed) { + const signChanged = Math.sign(speed) !== Math.sign(this._speed); + this._speed = speed; + if (signChanged) { + this.alignCursorToCurrentTime(); + } + } + get speed() { + return this._speed; + } + set loop(loop) { + this._loop = loop; + } + get loop() { + return this._loop; + } + set blendWeight(blendWeight) { + this._blendWeight = blendWeight; + } + get blendWeight() { + return this._blendWeight; + } + set blendOrder(blendOrder) { + this._blendOrder = blendOrder; + } + get blendOrder() { + return this._blendOrder; + } + set eventCursor(value) { + this._eventCursor = value; + } + get eventCursor() { + return this._eventCursor; + } + get eventCursorEnd() { + return this.isReverse ? 0 : this._track.events.length - 1; + } + get nextEvent() { + return this._track.events[this._eventCursor]; + } + get isReverse() { + return this._speed < 0; + } + nextEventAheadOfTime(time2) { + if (!this.nextEvent) return false; + return this.isReverse ? this.nextEvent.time <= time2 : this.nextEvent.time >= time2; + } + nextEventBehindTime(time2) { + if (!this.nextEvent) return false; + if (time2 === this.track.duration) { + return this.isReverse ? this.nextEvent.time >= time2 : this.nextEvent.time <= time2; + } + return this.isReverse ? this.nextEvent.time > time2 : this.nextEvent.time < time2; + } + resetEventCursor() { + this._eventCursor = this.isReverse ? this._track.events.length - 1 : 0; + } + moveEventCursor() { + this._eventCursor += this.isReverse ? -1 : 1; + if (this._eventCursor >= this.track.events.length) { + this._eventCursor = 0; + } else if (this._eventCursor < 0) { + this._eventCursor = this.track.events.length - 1; + } + } + clipFrameTime(frameEndTime) { + const eventFrame = _AnimClip.eventFrame; + eventFrame.start = 0; + eventFrame.end = frameEndTime; + eventFrame.residual = 0; + if (this.isReverse) { + if (frameEndTime < 0) { + eventFrame.start = this.track.duration; + eventFrame.end = 0; + eventFrame.residual = frameEndTime + this.track.duration; + } + } else { + if (frameEndTime > this.track.duration) { + eventFrame.start = 0; + eventFrame.end = this.track.duration; + eventFrame.residual = frameEndTime - this.track.duration; + } + } + } + alignCursorToCurrentTime() { + this.resetEventCursor(); + while (this.nextEventBehindTime(this._time) && this._eventCursor !== this.eventCursorEnd) { + this.moveEventCursor(); + } + } + fireNextEvent() { + this._eventHandler.fire(this.nextEvent.name, _extends({ + track: this.track + }, this.nextEvent)); + this.moveEventCursor(); + } + fireNextEventInFrame(frameStartTime, frameEndTime) { + if (this.nextEventAheadOfTime(frameStartTime) && this.nextEventBehindTime(frameEndTime)) { + this.fireNextEvent(); + return true; + } + return false; + } + activeEventsForFrame(frameStartTime, frameEndTime) { + const eventFrame = _AnimClip.eventFrame; + this.clipFrameTime(frameEndTime); + const initialCursor = this.eventCursor; + while (this.fireNextEventInFrame(frameStartTime, eventFrame.end)) { + if (initialCursor === this.eventCursor) { + break; + } + } + if (this.loop && Math.abs(eventFrame.residual) > 0) { + this.activeEventsForFrame(eventFrame.start, eventFrame.residual); + } + } + progressForTime(time2) { + return time2 * this._speed / this._track.duration; + } + _update(deltaTime) { + if (this._playing) { + let time2 = this._time; + const duration = this._track.duration; + const speed = this._speed; + const loop = this._loop; + if (this._track.events.length > 0 && duration > 0) { + this.activeEventsForFrame(time2, time2 + speed * deltaTime); + } + time2 += speed * deltaTime; + if (speed >= 0) { + if (time2 > duration) { + if (loop) { + time2 = time2 % duration || 0; + } else { + time2 = this._track.duration; + this.pause(); + } + } + } else { + if (time2 < 0) { + if (loop) { + time2 = duration + (time2 % duration || 0); + } else { + time2 = 0; + this.pause(); + } + } + } + this._time = time2; + } + if (this._time !== this._snapshot._time) { + this._track.eval(this._time, this._snapshot); + } + } + play() { + this._playing = true; + this._time = 0; + } + stop() { + this._playing = false; + this._time = 0; + } + pause() { + this._playing = false; + } + resume() { + this._playing = true; + } + reset() { + this._time = 0; + } +}; +AnimClip.eventFrame = { + start: 0, + end: 0, + residual: 0 +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/anim/controller/constants.js +var ANIM_INTERRUPTION_NONE = "NONE"; +var ANIM_INTERRUPTION_PREV = "PREV_STATE"; +var ANIM_INTERRUPTION_NEXT = "NEXT_STATE"; +var ANIM_INTERRUPTION_PREV_NEXT = "PREV_STATE_NEXT_STATE"; +var ANIM_INTERRUPTION_NEXT_PREV = "NEXT_STATE_PREV_STATE"; +var ANIM_GREATER_THAN = "GREATER_THAN"; +var ANIM_LESS_THAN = "LESS_THAN"; +var ANIM_GREATER_THAN_EQUAL_TO = "GREATER_THAN_EQUAL_TO"; +var ANIM_LESS_THAN_EQUAL_TO = "LESS_THAN_EQUAL_TO"; +var ANIM_EQUAL_TO = "EQUAL_TO"; +var ANIM_NOT_EQUAL_TO = "NOT_EQUAL_TO"; +var ANIM_PARAMETER_INTEGER = "INTEGER"; +var ANIM_PARAMETER_FLOAT = "FLOAT"; +var ANIM_PARAMETER_BOOLEAN = "BOOLEAN"; +var ANIM_PARAMETER_TRIGGER = "TRIGGER"; +var ANIM_BLEND_1D = "1D"; +var ANIM_BLEND_2D_DIRECTIONAL = "2D_DIRECTIONAL"; +var ANIM_BLEND_2D_CARTESIAN = "2D_CARTESIAN"; +var ANIM_BLEND_DIRECT = "DIRECT"; +var ANIM_STATE_START = "START"; +var ANIM_STATE_END = "END"; +var ANIM_STATE_ANY = "ANY"; +var ANIM_CONTROL_STATES = [ANIM_STATE_START, ANIM_STATE_END, ANIM_STATE_ANY]; +var ANIM_LAYER_OVERWRITE = "OVERWRITE"; +var ANIM_LAYER_ADDITIVE = "ADDITIVE"; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/anim/evaluator/anim-blend.js +var AnimBlend = class _AnimBlend { + static dot(a, b) { + const len = a.length; + let result = 0; + for (let i = 0; i < len; ++i) { + result += a[i] * b[i]; + } + return result; + } + static normalize(a) { + let l = _AnimBlend.dot(a, a); + if (l > 0) { + l = 1 / Math.sqrt(l); + const len = a.length; + for (let i = 0; i < len; ++i) { + a[i] *= l; + } + } + } + static set(a, b, type2) { + const len = a.length; + if (type2 === "quaternion") { + let l = _AnimBlend.dot(b, b); + if (l > 0) { + l = 1 / Math.sqrt(l); + } + for (let i = 0; i < len; ++i) { + a[i] = b[i] * l; + } + } else { + for (let i = 0; i < len; ++i) { + a[i] = b[i]; + } + } + } + static blendVec(a, b, t, additive) { + const it = additive ? 1 : 1 - t; + const len = a.length; + for (let i = 0; i < len; ++i) { + a[i] = a[i] * it + b[i] * t; + } + } + static blendQuat(a, b, t, additive) { + const len = a.length; + const it = additive ? 1 : 1 - t; + if (_AnimBlend.dot(a, b) < 0) { + t = -t; + } + for (let i = 0; i < len; ++i) { + a[i] = a[i] * it + b[i] * t; + } + if (!additive) { + _AnimBlend.normalize(a); + } + } + static blend(a, b, t, type2, additive) { + if (type2 === "quaternion") { + _AnimBlend.blendQuat(a, b, t, additive); + } else { + _AnimBlend.blendVec(a, b, t, additive); + } + } + static stableSort(a, lessFunc) { + const len = a.length; + for (let i = 0; i < len - 1; ++i) { + for (let j = i + 1; j < len; ++j) { + if (lessFunc(a[j], a[i])) { + const tmp = a[i]; + a[i] = a[j]; + a[j] = tmp; + } + } + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/anim/evaluator/anim-target-value.js +var AnimTargetValue = class _AnimTargetValue { + constructor(component, type2) { + this._component = component; + this.mask = new Int8Array(component.layers.length); + this.weights = new Float32Array(component.layers.length); + this.totalWeight = 0; + this.counter = 0; + this.layerCounter = 0; + this.valueType = type2; + this.dirty = true; + this.value = type2 === _AnimTargetValue.TYPE_QUAT ? [0, 0, 0, 1] : [0, 0, 0]; + this.baseValue = null; + this.setter = null; + } + get _normalizeWeights() { + return this._component.normalizeWeights; + } + getWeight(index) { + if (this.dirty) this.updateWeights(); + if (this._normalizeWeights && this.totalWeight === 0 || !this.mask[index]) { + return 0; + } else if (this._normalizeWeights) { + return this.weights[index] / this.totalWeight; + } + return math.clamp(this.weights[index], 0, 1); + } + _layerBlendType(index) { + return this._component.layers[index].blendType; + } + setMask(index, value) { + this.mask[index] = value; + if (this._normalizeWeights) { + if (this._component.layers[index].blendType === ANIM_LAYER_OVERWRITE) { + this.mask = this.mask.fill(0, 0, index); + } + this.dirty = true; + } + } + updateWeights() { + this.totalWeight = 0; + for (let i = 0; i < this.weights.length; i++) { + this.weights[i] = this._component.layers[i].weight; + this.totalWeight += this.mask[i] * this.weights[i]; + } + this.dirty = false; + } + updateValue(index, value) { + if (this.counter === 0) { + AnimBlend.set(this.value, _AnimTargetValue.IDENTITY_QUAT_ARR, this.valueType); + if (!this._normalizeWeights) { + AnimBlend.blend(this.value, this.baseValue, 1, this.valueType); + } + } + if (!this.mask[index] || this.getWeight(index) === 0) return; + if (this._layerBlendType(index) === ANIM_LAYER_ADDITIVE && !this._normalizeWeights) { + if (this.valueType === _AnimTargetValue.TYPE_QUAT) { + const v = _AnimTargetValue.q1.set(this.value[0], this.value[1], this.value[2], this.value[3]); + const aV1 = _AnimTargetValue.q2.set(this.baseValue[0], this.baseValue[1], this.baseValue[2], this.baseValue[3]); + const aV2 = _AnimTargetValue.q3.set(value[0], value[1], value[2], value[3]); + const aV = aV1.invert().mul(aV2); + aV.slerp(Quat2.IDENTITY, aV, this.getWeight(index)); + v.mul(aV); + _AnimTargetValue.quatArr[0] = v.x; + _AnimTargetValue.quatArr[1] = v.y; + _AnimTargetValue.quatArr[2] = v.z; + _AnimTargetValue.quatArr[3] = v.w; + AnimBlend.set(this.value, _AnimTargetValue.quatArr, this.valueType); + } else { + _AnimTargetValue.vecArr[0] = value[0] - this.baseValue[0]; + _AnimTargetValue.vecArr[1] = value[1] - this.baseValue[1]; + _AnimTargetValue.vecArr[2] = value[2] - this.baseValue[2]; + AnimBlend.blend(this.value, _AnimTargetValue.vecArr, this.getWeight(index), this.valueType, true); + } + } else { + AnimBlend.blend(this.value, value, this.getWeight(index), this.valueType); + } + if (this.setter) this.setter(this.value); + } + unbind() { + if (this.setter) { + this.setter(this.baseValue); + } + } +}; +AnimTargetValue.TYPE_QUAT = "quaternion"; +AnimTargetValue.TYPE_VEC3 = "vector3"; +AnimTargetValue.q1 = new Quat2(); +AnimTargetValue.q2 = new Quat2(); +AnimTargetValue.q3 = new Quat2(); +AnimTargetValue.quatArr = [0, 0, 0, 1]; +AnimTargetValue.vecArr = [0, 0, 0]; +AnimTargetValue.IDENTITY_QUAT_ARR = [0, 0, 0, 1]; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/anim/evaluator/anim-evaluator.js +var AnimEvaluator = class { + constructor(binder) { + this._binder = binder; + this._clips = []; + this._inputs = []; + this._outputs = []; + this._targets = {}; + } + get clips() { + return this._clips; + } + addClip(clip) { + const targets = this._targets; + const binder = this._binder; + const curves = clip.track.curves; + const snapshot = clip.snapshot; + const inputs = []; + const outputs = []; + for (let i = 0; i < curves.length; ++i) { + const curve = curves[i]; + const paths = curve.paths; + for (let j = 0; j < paths.length; ++j) { + const path2 = paths[j]; + const resolved = binder.resolve(path2); + let target2 = targets[resolved && resolved.targetPath || null]; + if (!target2 && resolved) { + target2 = { + target: resolved, + value: [], + curves: 0, + blendCounter: 0 + }; + for (let k = 0; k < target2.target.components; ++k) { + target2.value.push(0); + } + targets[resolved.targetPath] = target2; + if (binder.animComponent) { + if (!binder.animComponent.targets[resolved.targetPath]) { + let type2; + if (resolved.targetPath.substring(resolved.targetPath.length - 13) === "localRotation") { + type2 = AnimTargetValue.TYPE_QUAT; + } else { + type2 = AnimTargetValue.TYPE_VEC3; + } + binder.animComponent.targets[resolved.targetPath] = new AnimTargetValue(binder.animComponent, type2); + } + binder.animComponent.targets[resolved.targetPath].layerCounter++; + binder.animComponent.targets[resolved.targetPath].setMask(binder.layerIndex, 1); + } + } + if (target2) { + target2.curves++; + inputs.push(snapshot._results[i]); + outputs.push(target2); + } + } + } + this._clips.push(clip); + this._inputs.push(inputs); + this._outputs.push(outputs); + } + removeClip(index) { + const targets = this._targets; + const binder = this._binder; + const clips = this._clips; + const clip = clips[index]; + const curves = clip.track.curves; + for (let i = 0; i < curves.length; ++i) { + const curve = curves[i]; + const paths = curve.paths; + for (let j = 0; j < paths.length; ++j) { + const path2 = paths[j]; + const target2 = this._binder.resolve(path2); + if (target2) { + target2.curves--; + if (target2.curves === 0) { + binder.unresolve(path2); + delete targets[target2.targetPath]; + if (binder.animComponent) { + binder.animComponent.targets[target2.targetPath].layerCounter--; + } + } + } + } + } + clips.splice(index, 1); + this._inputs.splice(index, 1); + this._outputs.splice(index, 1); + } + removeClips() { + while (this._clips.length > 0) { + this.removeClip(0); + } + } + updateClipTrack(name, animTrack) { + this._clips.forEach((clip) => { + if (clip.name.includes(name)) { + clip.track = animTrack; + } + }); + this.rebind(); + } + findClip(name) { + const clips = this._clips; + for (let i = 0; i < clips.length; ++i) { + const clip = clips[i]; + if (clip.name === name) { + return clip; + } + } + return null; + } + rebind() { + this._binder.rebind(); + this._targets = {}; + const clips = [...this.clips]; + this.removeClips(); + clips.forEach((clip) => { + this.addClip(clip); + }); + } + assignMask(mask) { + return this._binder.assignMask(mask); + } + update(deltaTime, outputAnimation = true) { + const clips = this._clips; + const order = clips.map(function(c2, i) { + return i; + }); + AnimBlend.stableSort(order, function(a, b) { + return clips[a].blendOrder < clips[b].blendOrder; + }); + for (let i = 0; i < order.length; ++i) { + const index = order[i]; + const clip = clips[index]; + const inputs = this._inputs[index]; + const outputs = this._outputs[index]; + const blendWeight = clip.blendWeight; + if (blendWeight > 0) { + clip._update(deltaTime); + } + if (!outputAnimation) break; + let input2; + let output; + let value; + if (blendWeight >= 1) { + for (let j = 0; j < inputs.length; ++j) { + input2 = inputs[j]; + output = outputs[j]; + value = output.value; + AnimBlend.set(value, input2, output.target.type); + output.blendCounter++; + } + } else if (blendWeight > 0) { + for (let j = 0; j < inputs.length; ++j) { + input2 = inputs[j]; + output = outputs[j]; + value = output.value; + if (output.blendCounter === 0) { + AnimBlend.set(value, input2, output.target.type); + } else { + AnimBlend.blend(value, input2, blendWeight, output.target.type); + } + output.blendCounter++; + } + } + } + const targets = this._targets; + const binder = this._binder; + for (const path2 in targets) { + if (targets.hasOwnProperty(path2)) { + const target2 = targets[path2]; + if (binder.animComponent && target2.target.isTransform) { + const animTarget = binder.animComponent.targets[path2]; + if (animTarget.counter === animTarget.layerCounter) { + animTarget.counter = 0; + } + if (!animTarget.path) { + animTarget.path = path2; + animTarget.baseValue = target2.target.get(); + animTarget.setter = target2.target.set; + } + animTarget.updateValue(binder.layerIndex, target2.value); + animTarget.counter++; + } else { + target2.target.set(target2.value); + } + target2.blendCounter = 0; + } + } + this._binder.update(deltaTime); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/anim/evaluator/anim-events.js +var AnimEvents = class { + constructor(events2) { + this._events = [...events2]; + this._events.sort((a, b) => a.time - b.time); + } + get events() { + return this._events; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/anim/evaluator/anim-track.js +var _AnimTrack; +var AnimTrack = class { + constructor(name, duration, inputs, outputs, curves, animEvents = new AnimEvents([])) { + this._name = name; + this._duration = duration; + this._inputs = inputs; + this._outputs = outputs; + this._curves = curves; + this._animEvents = animEvents; + } + get name() { + return this._name; + } + get duration() { + return this._duration; + } + get inputs() { + return this._inputs; + } + get outputs() { + return this._outputs; + } + get curves() { + return this._curves; + } + set events(animEvents) { + this._animEvents = animEvents; + } + get events() { + return this._animEvents.events; + } + eval(time2, snapshot) { + snapshot._time = time2; + const inputs = this._inputs; + const outputs = this._outputs; + const curves = this._curves; + const cache = snapshot._cache; + const results = snapshot._results; + for (let i = 0; i < inputs.length; ++i) { + cache[i].update(time2, inputs[i]._data); + } + for (let i = 0; i < curves.length; ++i) { + const curve = curves[i]; + const output = outputs[curve._output]; + const result = results[i]; + cache[curve._input].eval(result, curve._interpolation, output); + } + } +}; +_AnimTrack = AnimTrack; +AnimTrack.EMPTY = Object.freeze(new _AnimTrack("empty", Number.MAX_VALUE, [], [], [])); + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/anim/binder/anim-binder.js +var AnimBinder = class { + static joinPath(pathSegments, character) { + character = character || "."; + const escape2 = function escape3(string2) { + return string2.replace(/\\/g, "\\\\").replace(new RegExp("\\" + character, "g"), "\\" + character); + }; + return pathSegments.map(escape2).join(character); + } + static splitPath(path2, character) { + character = character || "."; + const result = []; + let curr = ""; + let i = 0; + while (i < path2.length) { + let c2 = path2[i++]; + if (c2 === "\\" && i < path2.length) { + c2 = path2[i++]; + if (c2 === "\\" || c2 === character) { + curr += c2; + } else { + curr += "\\" + c2; + } + } else if (c2 === character) { + result.push(curr); + curr = ""; + } else { + curr += c2; + } + } + if (curr.length > 0) { + result.push(curr); + } + return result; + } + static encode(entityPath, component, propertyPath) { + return `${Array.isArray(entityPath) ? entityPath.join("/") : entityPath}/${component}/${Array.isArray(propertyPath) ? propertyPath.join("/") : propertyPath}`; + } + resolve(path2) { + return null; + } + unresolve(path2) { + } + update(deltaTime) { + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/anim/evaluator/anim-target.js +var AnimTarget = class { + constructor(func, type2, components, targetPath) { + if (func.set) { + this._set = func.set; + this._get = func.get; + } else { + this._set = func; + } + this._type = type2; + this._components = components; + this._targetPath = targetPath; + this._isTransform = this._targetPath.substring(this._targetPath.length - 13) === "localRotation" || this._targetPath.substring(this._targetPath.length - 13) === "localPosition" || this._targetPath.substring(this._targetPath.length - 10) === "localScale"; + } + get set() { + return this._set; + } + get get() { + return this._get; + } + get type() { + return this._type; + } + get components() { + return this._components; + } + get targetPath() { + return this._targetPath; + } + get isTransform() { + return this._isTransform; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/anim/binder/default-anim-binder.js +var DefaultAnimBinder = class _DefaultAnimBinder { + constructor(graph) { + this._isPathInMask = (path2, checkMaskValue) => { + const maskItem = this._mask[path2]; + if (!maskItem) return false; + else if (maskItem.children || checkMaskValue && maskItem.value !== false) return true; + return false; + }; + this.graph = graph; + if (!graph) return; + this._mask = null; + const nodes = {}; + const flatten = function flatten2(node) { + nodes[node.name] = node; + for (let i = 0; i < node.children.length; ++i) { + flatten2(node.children[i]); + } + }; + flatten(graph); + this.nodes = nodes; + this.targetCache = {}; + const findMeshInstances = function findMeshInstances2(node) { + let object = node; + while (object && !(object instanceof Entity)) { + object = object.parent; + } + let meshInstances; + if (object) { + if (object.render) { + meshInstances = object.render.meshInstances; + } else if (object.model) { + meshInstances = object.model.meshInstances; + } + } + return meshInstances; + }; + this.nodeCounts = {}; + this.activeNodes = []; + this.handlers = { + "localPosition": function(node) { + const object = node.localPosition; + const func = function func2(value) { + object.set(...value); + }; + return _DefaultAnimBinder.createAnimTarget(func, "vector", 3, node, "localPosition"); + }, + "localRotation": function(node) { + const object = node.localRotation; + const func = function func2(value) { + object.set(...value); + }; + return _DefaultAnimBinder.createAnimTarget(func, "quaternion", 4, node, "localRotation"); + }, + "localScale": function(node) { + const object = node.localScale; + const func = function func2(value) { + object.set(...value); + }; + return _DefaultAnimBinder.createAnimTarget(func, "vector", 3, node, "localScale"); + }, + "weight": function(node, weightName) { + if (weightName.indexOf("name.") === 0) { + weightName = weightName.replace("name.", ""); + } else { + weightName = Number(weightName); + } + const meshInstances = findMeshInstances(node); + let setters; + if (meshInstances) { + for (let i = 0; i < meshInstances.length; ++i) { + if (meshInstances[i].node.name === node.name && meshInstances[i].morphInstance) { + const morphInstance = meshInstances[i].morphInstance; + const func = (value) => { + morphInstance.setWeight(weightName, value[0]); + }; + if (!setters) setters = []; + setters.push(func); + } + } + } + if (setters) { + const callSetters = (value) => { + for (let i = 0; i < setters.length; ++i) { + setters[i](value); + } + }; + return _DefaultAnimBinder.createAnimTarget(callSetters, "number", 1, node, `weight.${weightName}`); + } + return null; + }, + "materialTexture": (node, textureName) => { + const meshInstances = findMeshInstances(node); + if (meshInstances) { + let meshInstance; + for (let i = 0; i < meshInstances.length; ++i) { + if (meshInstances[i].node.name === node.name) { + meshInstance = meshInstances[i]; + break; + } + } + if (meshInstance) { + const func = (value) => { + const textureAsset = this.animComponent.system.app.assets.get(value[0]); + if (textureAsset && textureAsset.resource && textureAsset.type === "texture") { + meshInstance.material[textureName] = textureAsset.resource; + meshInstance.material.update(); + } + }; + return _DefaultAnimBinder.createAnimTarget(func, "vector", 1, node, "materialTexture", "material"); + } + } + return null; + } + }; + } + _isPathActive(path2) { + if (!this._mask) return true; + const rootNodeNames = [path2.entityPath[0], this.graph.name]; + for (let j = 0; j < rootNodeNames.length; ++j) { + let currEntityPath = rootNodeNames[j]; + if (this._isPathInMask(currEntityPath, path2.entityPath.length === 1)) return true; + for (let i = 1; i < path2.entityPath.length; i++) { + currEntityPath += "/" + path2.entityPath[i]; + if (this._isPathInMask(currEntityPath, i === path2.entityPath.length - 1)) return true; + } + } + return false; + } + findNode(path2) { + if (!this._isPathActive(path2)) { + return null; + } + let node; + if (this.graph) { + node = this.graph.findByPath(path2.entityPath); + if (!node) { + node = this.graph.findByPath(path2.entityPath.slice(1)); + } + } + if (!node) { + node = this.nodes[path2.entityPath[path2.entityPath.length - 1] || ""]; + } + return node; + } + static createAnimTarget(func, type2, valueCount, node, propertyPath, componentType) { + const targetPath = AnimBinder.encode(node.path, componentType ? componentType : "entity", propertyPath); + return new AnimTarget(func, type2, valueCount, targetPath); + } + resolve(path2) { + const encodedPath = AnimBinder.encode(path2.entityPath, path2.component, path2.propertyPath); + let target2 = this.targetCache[encodedPath]; + if (target2) return target2; + const node = this.findNode(path2); + if (!node) { + return null; + } + const handler = this.handlers[path2.propertyPath]; + if (!handler) { + return null; + } + target2 = handler(node); + if (!target2) { + return null; + } + this.targetCache[encodedPath] = target2; + if (!this.nodeCounts[node.path]) { + this.activeNodes.push(node); + this.nodeCounts[node.path] = 1; + } else { + this.nodeCounts[node.path]++; + } + return target2; + } + unresolve(path2) { + if (path2.component !== "graph") return; + const node = this.nodes[path2.entityPath[path2.entityPath.length - 1] || ""]; + this.nodeCounts[node.path]--; + if (this.nodeCounts[node.path] === 0) { + const activeNodes = this.activeNodes; + const i = activeNodes.indexOf(node.node); + const len = activeNodes.length; + if (i < len - 1) { + activeNodes[i] = activeNodes[len - 1]; + } + activeNodes.pop(); + } + } + update(deltaTime) { + const activeNodes = this.activeNodes; + for (let i = 0; i < activeNodes.length; ++i) { + activeNodes[i]._dirtifyLocal(); + } + } + assignMask(mask) { + if (mask !== this._mask) { + this._mask = mask; + return true; + } + return false; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/anim/controller/anim-node.js +var AnimNode = class { + constructor(state, parent, name, point, speed = 1) { + this._state = state; + this._parent = parent; + this._name = name; + if (Array.isArray(point)) { + this._point = new Vec2(point[0], point[1]); + this._pointLength = this._point.length(); + } else { + this._point = point; + this._pointLength = point; + } + this._speed = speed; + this._weightedSpeed = 1; + this._weight = 1; + this._animTrack = null; + } + get parent() { + return this._parent; + } + get name() { + return this._name; + } + get path() { + return this._parent ? this._parent.path + "." + this._name : this._name; + } + get point() { + return this._point; + } + get pointLength() { + return this._pointLength; + } + set weight(value) { + this._weight = value; + } + get weight() { + return this._parent ? this._parent.weight * this._weight : this._weight; + } + get normalizedWeight() { + const totalWeight = this._state.totalWeight; + if (totalWeight === 0) return 0; + return this.weight / totalWeight; + } + get speed() { + return this._weightedSpeed * this._speed; + } + get absoluteSpeed() { + return Math.abs(this._speed); + } + set weightedSpeed(weightedSpeed) { + this._weightedSpeed = weightedSpeed; + } + get weightedSpeed() { + return this._weightedSpeed; + } + set animTrack(value) { + this._animTrack = value; + } + get animTrack() { + return this._animTrack; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/anim/controller/anim-blend-tree.js +var AnimBlendTree = class _AnimBlendTree extends AnimNode { + constructor(state, parent, name, point, parameters, children, syncAnimations, createTree, findParameter) { + super(state, parent, name, point); + this._parameters = parameters; + this._parameterValues = new Array(parameters.length); + this._children = []; + this._findParameter = findParameter; + this._syncAnimations = syncAnimations !== false; + this._pointCache = {}; + for (let i = 0; i < children.length; i++) { + const child = children[i]; + if (child.children) { + this._children.push(createTree(child.type, state, this, child.name, 1, child.parameter ? [child.parameter] : child.parameters, child.children, child.syncAnimations, createTree, findParameter)); + } else { + this._children.push(new AnimNode(state, this, child.name, child.point, child.speed)); + } + } + } + get weight() { + this.calculateWeights(); + return this._parent ? this._parent.weight * this._weight : this._weight; + } + get syncAnimations() { + return this._syncAnimations; + } + getChild(name) { + for (let i = 0; i < this._children.length; i++) { + if (this._children[i].name === name) return this._children[i]; + } + return null; + } + updateParameterValues() { + let paramsEqual = true; + for (let i = 0; i < this._parameterValues.length; i++) { + const updatedParameter = this._findParameter(this._parameters[i]).value; + if (this._parameterValues[i] !== updatedParameter) { + this._parameterValues[i] = updatedParameter; + paramsEqual = false; + } + } + return paramsEqual; + } + getNodeWeightedDuration(i) { + return this._children[i].animTrack.duration / this._children[i].speedMultiplier * this._children[i].weight; + } + getNodeCount() { + let count = 0; + for (let i = 0; i < this._children.length; i++) { + const child = this._children[i]; + if (child.constructor === _AnimBlendTree) { + count += this._children[i].getNodeCount(); + } else { + count++; + } + } + return count; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/anim/controller/anim-blend-tree-1d.js +var AnimBlendTree1D = class extends AnimBlendTree { + constructor(state, parent, name, point, parameters, children, syncAnimations, createTree, findParameter) { + children.sort((a, b) => a.point - b.point); + super(state, parent, name, point, parameters, children, syncAnimations, createTree, findParameter); + } + calculateWeights() { + if (this.updateParameterValues()) return; + let weightedDurationSum = 0; + this._children[0].weight = 0; + for (let i = 0; i < this._children.length; i++) { + const c1 = this._children[i]; + if (i !== this._children.length - 1) { + const c2 = this._children[i + 1]; + if (c1.point === c2.point) { + c1.weight = 0.5; + c2.weight = 0.5; + } else if (math.between(this._parameterValues[0], c1.point, c2.point, true)) { + const child2Distance = Math.abs(c1.point - c2.point); + const parameterDistance = Math.abs(c1.point - this._parameterValues[0]); + const weight = (child2Distance - parameterDistance) / child2Distance; + c1.weight = weight; + c2.weight = 1 - weight; + } else { + c2.weight = 0; + } + } + if (this._syncAnimations) { + weightedDurationSum += c1.animTrack.duration / c1.absoluteSpeed * c1.weight; + } + } + if (this._syncAnimations) { + for (let i = 0; i < this._children.length; i++) { + const child = this._children[i]; + child.weightedSpeed = child.animTrack.duration / child.absoluteSpeed / weightedDurationSum; + } + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/anim/controller/anim-blend-tree-2d-cartesian.js +var AnimBlendTreeCartesian2D = class _AnimBlendTreeCartesian2D extends AnimBlendTree { + pointDistanceCache(i, j) { + const pointKey = `${i}${j}`; + if (!this._pointCache[pointKey]) { + this._pointCache[pointKey] = this._children[j].point.clone().sub(this._children[i].point); + } + return this._pointCache[pointKey]; + } + calculateWeights() { + if (this.updateParameterValues()) return; + let weightSum, weightedDurationSum; + _AnimBlendTreeCartesian2D._p.set(...this._parameterValues); + weightSum = 0; + weightedDurationSum = 0; + for (let i = 0; i < this._children.length; i++) { + const child = this._children[i]; + const pi = child.point; + _AnimBlendTreeCartesian2D._pip.set(_AnimBlendTreeCartesian2D._p.x, _AnimBlendTreeCartesian2D._p.y).sub(pi); + let minj = Number.MAX_VALUE; + for (let j = 0; j < this._children.length; j++) { + if (i === j) continue; + const pipj = this.pointDistanceCache(i, j); + const result = math.clamp(1 - _AnimBlendTreeCartesian2D._pip.dot(pipj) / pipj.lengthSq(), 0, 1); + if (result < minj) minj = result; + } + child.weight = minj; + weightSum += minj; + if (this._syncAnimations) { + weightedDurationSum += child.animTrack.duration / child.absoluteSpeed * child.weight; + } + } + for (let i = 0; i < this._children.length; i++) { + const child = this._children[i]; + child.weight = child._weight / weightSum; + if (this._syncAnimations) { + child.weightedSpeed = child.animTrack.duration / child.absoluteSpeed / weightedDurationSum; + } + } + } +}; +AnimBlendTreeCartesian2D._p = new Vec2(); +AnimBlendTreeCartesian2D._pip = new Vec2(); + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/anim/controller/anim-blend-tree-2d-directional.js +var AnimBlendTreeDirectional2D = class _AnimBlendTreeDirectional2D extends AnimBlendTree { + pointCache(i, j) { + const pointKey = `${i}${j}`; + if (!this._pointCache[pointKey]) { + this._pointCache[pointKey] = new Vec2((this._children[j].pointLength - this._children[i].pointLength) / ((this._children[j].pointLength + this._children[i].pointLength) / 2), Vec2.angleRad(this._children[i].point, this._children[j].point) * 2); + } + return this._pointCache[pointKey]; + } + calculateWeights() { + if (this.updateParameterValues()) return; + let weightSum, weightedDurationSum; + _AnimBlendTreeDirectional2D._p.set(...this._parameterValues); + const pLength = _AnimBlendTreeDirectional2D._p.length(); + weightSum = 0; + weightedDurationSum = 0; + for (let i = 0; i < this._children.length; i++) { + const child = this._children[i]; + const pi = child.point; + const piLength = child.pointLength; + let minj = Number.MAX_VALUE; + for (let j = 0; j < this._children.length; j++) { + if (i === j) continue; + const pipj = this.pointCache(i, j); + const pjLength = this._children[j].pointLength; + _AnimBlendTreeDirectional2D._pip.set((pLength - piLength) / ((pjLength + piLength) / 2), Vec2.angleRad(pi, _AnimBlendTreeDirectional2D._p) * 2); + const result = math.clamp(1 - Math.abs(_AnimBlendTreeDirectional2D._pip.dot(pipj) / pipj.lengthSq()), 0, 1); + if (result < minj) minj = result; + } + child.weight = minj; + weightSum += minj; + if (this._syncAnimations) { + weightedDurationSum += child.animTrack.duration / child.absoluteSpeed * child.weight; + } + } + for (let i = 0; i < this._children.length; i++) { + const child = this._children[i]; + child.weight = child._weight / weightSum; + if (this._syncAnimations) { + const weightedChildDuration = child.animTrack.duration / weightedDurationSum * weightSum; + child.weightedSpeed = child.absoluteSpeed * weightedChildDuration; + } + } + } +}; +AnimBlendTreeDirectional2D._p = new Vec2(); +AnimBlendTreeDirectional2D._pip = new Vec2(); + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/anim/controller/anim-blend-tree-direct.js +var AnimBlendTreeDirect = class extends AnimBlendTree { + calculateWeights() { + if (this.updateParameterValues()) return; + let weightSum = 0; + let weightedDurationSum = 0; + for (let i = 0; i < this._children.length; i++) { + weightSum += Math.max(this._parameterValues[i], 0); + if (this._syncAnimations) { + const child = this._children[i]; + weightedDurationSum += child.animTrack.duration / child.absoluteSpeed * child.weight; + } + } + for (let i = 0; i < this._children.length; i++) { + const child = this._children[i]; + const weight = Math.max(this._parameterValues[i], 0); + if (weightSum) { + child.weight = weight / weightSum; + if (this._syncAnimations) { + child.weightedSpeed = child.animTrack.duration / child.absoluteSpeed / weightedDurationSum; + } + } else { + child.weight = 0; + if (this._syncAnimations) { + child.weightedSpeed = 0; + } + } + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/anim/controller/anim-state.js +var AnimState = class { + constructor(controller, name, speed = 1, loop = true, blendTree) { + this._animations = {}; + this._animationList = []; + this._controller = controller; + this._name = name; + this._speed = speed; + this._loop = loop; + this._hasAnimations = false; + if (blendTree) { + this._blendTree = this._createTree(blendTree.type, this, null, name, 1, blendTree.parameter ? [blendTree.parameter] : blendTree.parameters, blendTree.children, blendTree.syncAnimations, this._createTree, this._controller.findParameter); + } else { + this._blendTree = new AnimNode(this, null, name, 1, speed); + } + } + _createTree(type2, state, parent, name, point, parameters, children, syncAnimations, createTree, findParameter) { + switch (type2) { + case ANIM_BLEND_1D: + return new AnimBlendTree1D(state, parent, name, point, parameters, children, syncAnimations, createTree, findParameter); + case ANIM_BLEND_2D_CARTESIAN: + return new AnimBlendTreeCartesian2D(state, parent, name, point, parameters, children, syncAnimations, createTree, findParameter); + case ANIM_BLEND_2D_DIRECTIONAL: + return new AnimBlendTreeDirectional2D(state, parent, name, point, parameters, children, syncAnimations, createTree, findParameter); + case ANIM_BLEND_DIRECT: + return new AnimBlendTreeDirect(state, parent, name, point, parameters, children, syncAnimations, createTree, findParameter); + } + return void 0; + } + _getNodeFromPath(path2) { + let currNode = this._blendTree; + for (let i = 1; i < path2.length; i++) { + currNode = currNode.getChild(path2[i]); + } + return currNode; + } + addAnimation(path2, animTrack) { + const pathString = path2.join("."); + const indexOfAnimation = this._animationList.findIndex(function(animation) { + return animation.path === pathString; + }); + if (indexOfAnimation >= 0) { + this._animationList[indexOfAnimation].animTrack = animTrack; + } else { + const node = this._getNodeFromPath(path2); + node.animTrack = animTrack; + this._animationList.push(node); + } + this._updateHasAnimations(); + } + _updateHasAnimations() { + this._hasAnimations = this._animationList.length > 0 && this._animationList.every((animation) => animation.animTrack && animation.animTrack !== AnimTrack.EMPTY); + } + get name() { + return this._name; + } + set animations(value) { + this._animationList = value; + this._updateHasAnimations(); + } + get animations() { + return this._animationList; + } + get hasAnimations() { + return this._hasAnimations; + } + set speed(value) { + this._speed = value; + } + get speed() { + return this._speed; + } + set loop(value) { + this._loop = value; + } + get loop() { + return this._loop; + } + get nodeCount() { + if (!this._blendTree || this._blendTree.constructor === AnimNode) return 1; + return this._blendTree.getNodeCount(); + } + get playable() { + return ANIM_CONTROL_STATES.indexOf(this.name) !== -1 || this.animations.length === this.nodeCount; + } + get looping() { + if (this.animations.length > 0) { + const trackClipName = this.name + "." + this.animations[0].animTrack.name; + const trackClip = this._controller.animEvaluator.findClip(trackClipName); + if (trackClip) { + return trackClip.loop; + } + } + return false; + } + get totalWeight() { + let sum = 0; + for (let i = 0; i < this.animations.length; i++) { + sum += this.animations[i].weight; + } + return sum; + } + get timelineDuration() { + let duration = 0; + for (let i = 0; i < this.animations.length; i++) { + const animation = this.animations[i]; + if (animation.animTrack.duration > duration) { + duration = animation.animTrack.duration; + } + } + return duration; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/anim/controller/anim-transition.js +var AnimTransition = class { + constructor({ + from, + to, + time: time2 = 0, + priority = 0, + conditions = [], + exitTime = null, + transitionOffset = null, + interruptionSource = ANIM_INTERRUPTION_NONE + }) { + this._from = from; + this._to = to; + this._time = time2; + this._priority = priority; + this._conditions = conditions; + this._exitTime = exitTime; + this._transitionOffset = transitionOffset; + this._interruptionSource = interruptionSource; + } + get from() { + return this._from; + } + set to(value) { + this._to = value; + } + get to() { + return this._to; + } + get time() { + return this._time; + } + get priority() { + return this._priority; + } + get conditions() { + return this._conditions; + } + get exitTime() { + return this._exitTime; + } + get transitionOffset() { + return this._transitionOffset; + } + get interruptionSource() { + return this._interruptionSource; + } + get hasExitTime() { + return !!this.exitTime; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/anim/controller/anim-controller.js +var AnimController = class { + constructor(animEvaluator, states, transitions, activate, eventHandler, findParameter, consumeTrigger) { + this._states = {}; + this._stateNames = []; + this._findTransitionsFromStateCache = {}; + this._findTransitionsBetweenStatesCache = {}; + this._previousStateName = null; + this._activeStateName = ANIM_STATE_START; + this._activeStateDuration = 0; + this._activeStateDurationDirty = true; + this._playing = false; + this._activate = void 0; + this._transitions = void 0; + this._currTransitionTime = 1; + this._totalTransitionTime = 1; + this._isTransitioning = false; + this._transitionInterruptionSource = ANIM_INTERRUPTION_NONE; + this._transitionPreviousStates = []; + this._timeInState = 0; + this._timeInStateBefore = 0; + this.findParameter = (name) => { + return this._findParameter(name); + }; + this._animEvaluator = animEvaluator; + this._eventHandler = eventHandler; + this._findParameter = findParameter; + this._consumeTrigger = consumeTrigger; + for (let i = 0; i < states.length; i++) { + this._states[states[i].name] = new AnimState(this, states[i].name, states[i].speed, states[i].loop, states[i].blendTree); + this._stateNames.push(states[i].name); + } + this._transitions = transitions.map((transition) => { + return new AnimTransition(_extends({}, transition)); + }); + this._activate = activate; + } + get animEvaluator() { + return this._animEvaluator; + } + set activeState(stateName) { + this._activeStateName = stateName; + } + get activeState() { + return this._findState(this._activeStateName); + } + get activeStateName() { + return this._activeStateName; + } + get activeStateAnimations() { + return this.activeState.animations; + } + set previousState(stateName) { + this._previousStateName = stateName; + } + get previousState() { + return this._findState(this._previousStateName); + } + get previousStateName() { + return this._previousStateName; + } + get playable() { + let playable = true; + for (let i = 0; i < this._stateNames.length; i++) { + if (!this._states[this._stateNames[i]].playable) { + playable = false; + } + } + return playable; + } + set playing(value) { + this._playing = value; + } + get playing() { + return this._playing; + } + get activeStateProgress() { + return this._getActiveStateProgressForTime(this._timeInState); + } + get activeStateDuration() { + if (this._activeStateDurationDirty) { + let maxDuration = 0; + for (let i = 0; i < this.activeStateAnimations.length; i++) { + const activeClip = this._animEvaluator.findClip(this.activeStateAnimations[i].name); + if (activeClip) { + maxDuration = Math.max(maxDuration, activeClip.track.duration); + } + } + this._activeStateDuration = maxDuration; + this._activeStateDurationDirty = false; + } + return this._activeStateDuration; + } + set activeStateCurrentTime(time2) { + this._timeInStateBefore = time2; + this._timeInState = time2; + for (let i = 0; i < this.activeStateAnimations.length; i++) { + const clip = this.animEvaluator.findClip(this.activeStateAnimations[i].name); + if (clip) { + clip.time = time2; + } + } + } + get activeStateCurrentTime() { + return this._timeInState; + } + get transitioning() { + return this._isTransitioning; + } + get transitionProgress() { + return this._currTransitionTime / this._totalTransitionTime; + } + get states() { + return this._stateNames; + } + assignMask(mask) { + return this._animEvaluator.assignMask(mask); + } + _findState(stateName) { + return this._states[stateName]; + } + _getActiveStateProgressForTime(time2) { + if (this.activeStateName === ANIM_STATE_START || this.activeStateName === ANIM_STATE_END || this.activeStateName === ANIM_STATE_ANY) return 1; + const activeClip = this._animEvaluator.findClip(this.activeStateAnimations[0].name); + if (activeClip) { + return activeClip.progressForTime(time2); + } + return null; + } + _findTransitionsFromState(stateName) { + let transitions = this._findTransitionsFromStateCache[stateName]; + if (!transitions) { + transitions = this._transitions.filter(function(transition) { + return transition.from === stateName; + }); + sortPriority(transitions); + this._findTransitionsFromStateCache[stateName] = transitions; + } + return transitions; + } + _findTransitionsBetweenStates(sourceStateName, destinationStateName) { + let transitions = this._findTransitionsBetweenStatesCache[sourceStateName + "->" + destinationStateName]; + if (!transitions) { + transitions = this._transitions.filter(function(transition) { + return transition.from === sourceStateName && transition.to === destinationStateName; + }); + sortPriority(transitions); + this._findTransitionsBetweenStatesCache[sourceStateName + "->" + destinationStateName] = transitions; + } + return transitions; + } + _transitionHasConditionsMet(transition) { + const conditions = transition.conditions; + for (let i = 0; i < conditions.length; i++) { + const condition = conditions[i]; + const parameter = this._findParameter(condition.parameterName); + switch (condition.predicate) { + case ANIM_GREATER_THAN: + if (!(parameter.value > condition.value)) return false; + break; + case ANIM_LESS_THAN: + if (!(parameter.value < condition.value)) return false; + break; + case ANIM_GREATER_THAN_EQUAL_TO: + if (!(parameter.value >= condition.value)) return false; + break; + case ANIM_LESS_THAN_EQUAL_TO: + if (!(parameter.value <= condition.value)) return false; + break; + case ANIM_EQUAL_TO: + if (!(parameter.value === condition.value)) return false; + break; + case ANIM_NOT_EQUAL_TO: + if (!(parameter.value !== condition.value)) return false; + break; + } + } + return true; + } + _findTransition(from, to) { + let transitions = []; + if (from && to) { + transitions = transitions.concat(this._findTransitionsBetweenStates(from, to)); + } else { + if (!this._isTransitioning) { + transitions = transitions.concat(this._findTransitionsFromState(this._activeStateName)); + transitions = transitions.concat(this._findTransitionsFromState(ANIM_STATE_ANY)); + } else { + switch (this._transitionInterruptionSource) { + case ANIM_INTERRUPTION_PREV: + transitions = transitions.concat(this._findTransitionsFromState(this._previousStateName)); + transitions = transitions.concat(this._findTransitionsFromState(ANIM_STATE_ANY)); + break; + case ANIM_INTERRUPTION_NEXT: + transitions = transitions.concat(this._findTransitionsFromState(this._activeStateName)); + transitions = transitions.concat(this._findTransitionsFromState(ANIM_STATE_ANY)); + break; + case ANIM_INTERRUPTION_PREV_NEXT: + transitions = transitions.concat(this._findTransitionsFromState(this._previousStateName)); + transitions = transitions.concat(this._findTransitionsFromState(this._activeStateName)); + transitions = transitions.concat(this._findTransitionsFromState(ANIM_STATE_ANY)); + break; + case ANIM_INTERRUPTION_NEXT_PREV: + transitions = transitions.concat(this._findTransitionsFromState(this._activeStateName)); + transitions = transitions.concat(this._findTransitionsFromState(this._previousStateName)); + transitions = transitions.concat(this._findTransitionsFromState(ANIM_STATE_ANY)); + break; + } + } + } + transitions = transitions.filter((transition) => { + if (transition.to === this.activeStateName) { + return false; + } + if (transition.hasExitTime) { + let progressBefore = this._getActiveStateProgressForTime(this._timeInStateBefore); + let progress = this._getActiveStateProgressForTime(this._timeInState); + if (transition.exitTime < 1 && this.activeState.loop) { + progressBefore -= Math.floor(progressBefore); + progress -= Math.floor(progress); + } + if (progress === progressBefore) { + if (progress !== transition.exitTime) { + return null; + } + } else if (!(transition.exitTime > progressBefore && transition.exitTime <= progress)) { + return null; + } + } + return this._transitionHasConditionsMet(transition); + }); + if (transitions.length > 0) { + const transition = transitions[0]; + if (transition.to === ANIM_STATE_END) { + const startTransition = this._findTransitionsFromState(ANIM_STATE_START)[0]; + transition.to = startTransition.to; + } + return transition; + } + return null; + } + updateStateFromTransition(transition) { + let state; + let animation; + let clip; + this.previousState = transition.from ? this.activeStateName : null; + this.activeState = transition.to; + this._activeStateDurationDirty = true; + for (let i = 0; i < transition.conditions.length; i++) { + const condition = transition.conditions[i]; + const parameter = this._findParameter(condition.parameterName); + if (parameter.type === ANIM_PARAMETER_TRIGGER) { + this._consumeTrigger(condition.parameterName); + } + } + if (this.previousState) { + if (!this._isTransitioning) { + this._transitionPreviousStates = []; + } + this._transitionPreviousStates.push({ + name: this._previousStateName, + weight: 1 + }); + const interpolatedTime = Math.min(this._totalTransitionTime !== 0 ? this._currTransitionTime / this._totalTransitionTime : 1, 1); + for (let i = 0; i < this._transitionPreviousStates.length; i++) { + if (!this._isTransitioning) { + this._transitionPreviousStates[i].weight = 1; + } else if (i !== this._transitionPreviousStates.length - 1) { + this._transitionPreviousStates[i].weight *= 1 - interpolatedTime; + } else { + this._transitionPreviousStates[i].weight = interpolatedTime; + } + state = this._findState(this._transitionPreviousStates[i].name); + for (let j = 0; j < state.animations.length; j++) { + animation = state.animations[j]; + clip = this._animEvaluator.findClip(animation.name + ".previous." + i); + if (!clip) { + clip = this._animEvaluator.findClip(animation.name); + clip.name = animation.name + ".previous." + i; + } + if (i !== this._transitionPreviousStates.length - 1) { + clip.pause(); + } + } + } + } + this._isTransitioning = true; + this._totalTransitionTime = transition.time; + this._currTransitionTime = 0; + this._transitionInterruptionSource = transition.interruptionSource; + const activeState = this.activeState; + const hasTransitionOffset = transition.transitionOffset && transition.transitionOffset > 0 && transition.transitionOffset < 1; + let timeInState = 0; + let timeInStateBefore = 0; + if (hasTransitionOffset) { + const offsetTime = activeState.timelineDuration * transition.transitionOffset; + timeInState = offsetTime; + timeInStateBefore = offsetTime; + } + this._timeInState = timeInState; + this._timeInStateBefore = timeInStateBefore; + for (let i = 0; i < activeState.animations.length; i++) { + clip = this._animEvaluator.findClip(activeState.animations[i].name); + if (!clip) { + const speed = Number.isFinite(activeState.animations[i].speed) ? activeState.animations[i].speed : activeState.speed; + clip = new AnimClip(activeState.animations[i].animTrack, this._timeInState, speed, true, activeState.loop, this._eventHandler); + clip.name = activeState.animations[i].name; + this._animEvaluator.addClip(clip); + } else { + clip.reset(); + } + if (transition.time > 0) { + clip.blendWeight = 0; + } else { + clip.blendWeight = activeState.animations[i].normalizedWeight; + } + clip.play(); + if (hasTransitionOffset) { + clip.time = activeState.timelineDuration * transition.transitionOffset; + } else { + const startTime = activeState.speed >= 0 ? 0 : this.activeStateDuration; + clip.time = startTime; + } + } + } + _transitionToState(newStateName) { + if (!this._findState(newStateName)) { + return; + } + let transition = this._findTransition(this._activeStateName, newStateName); + if (!transition) { + this._animEvaluator.removeClips(); + transition = new AnimTransition({ + from: null, + to: newStateName + }); + } + this.updateStateFromTransition(transition); + } + assignAnimation(pathString, animTrack, speed, loop) { + const path2 = pathString.split("."); + let state = this._findState(path2[0]); + if (!state) { + state = new AnimState(this, path2[0], speed); + this._states[path2[0]] = state; + this._stateNames.push(path2[0]); + } + state.addAnimation(path2, animTrack); + this._animEvaluator.updateClipTrack(state.name, animTrack); + if (speed !== void 0) { + state.speed = speed; + } + if (loop !== void 0) { + state.loop = loop; + } + if (!this._playing && this._activate && this.playable) { + this.play(); + } + this._activeStateDurationDirty = true; + } + removeNodeAnimations(nodeName) { + if (ANIM_CONTROL_STATES.indexOf(nodeName) !== -1) { + return false; + } + const state = this._findState(nodeName); + if (!state) { + return false; + } + state.animations = []; + return true; + } + play(stateName) { + if (stateName) { + this._transitionToState(stateName); + } + this._playing = true; + } + pause() { + this._playing = false; + } + reset() { + this._previousStateName = null; + this._activeStateName = ANIM_STATE_START; + this._playing = false; + this._currTransitionTime = 1; + this._totalTransitionTime = 1; + this._isTransitioning = false; + this._timeInState = 0; + this._timeInStateBefore = 0; + this._animEvaluator.removeClips(); + } + rebind() { + this._animEvaluator.rebind(); + } + update(dt) { + if (!this._playing) { + return; + } + let state; + let animation; + let clip; + if (this.activeState.loop || this._timeInState < this.activeStateDuration) { + this._timeInStateBefore = this._timeInState; + this._timeInState += dt * this.activeState.speed; + if (!this.activeState.loop && this._timeInState > this.activeStateDuration) { + this._timeInState = this.activeStateDuration; + dt = this.activeStateDuration - this._timeInStateBefore; + } + } + const transition = this._findTransition(this._activeStateName); + if (transition) this.updateStateFromTransition(transition); + if (this._isTransitioning) { + this._currTransitionTime += dt; + if (this._currTransitionTime <= this._totalTransitionTime) { + const interpolatedTime = this._totalTransitionTime !== 0 ? this._currTransitionTime / this._totalTransitionTime : 1; + for (let i = 0; i < this._transitionPreviousStates.length; i++) { + state = this._findState(this._transitionPreviousStates[i].name); + const stateWeight = this._transitionPreviousStates[i].weight; + for (let j = 0; j < state.animations.length; j++) { + animation = state.animations[j]; + clip = this._animEvaluator.findClip(animation.name + ".previous." + i); + if (clip) { + clip.blendWeight = (1 - interpolatedTime) * animation.normalizedWeight * stateWeight; + } + } + } + state = this.activeState; + for (let i = 0; i < state.animations.length; i++) { + animation = state.animations[i]; + this._animEvaluator.findClip(animation.name).blendWeight = interpolatedTime * animation.normalizedWeight; + } + } else { + this._isTransitioning = false; + const activeClips = this.activeStateAnimations.length; + const totalClips = this._animEvaluator.clips.length; + for (let i = 0; i < totalClips - activeClips; i++) { + this._animEvaluator.removeClip(0); + } + this._transitionPreviousStates = []; + state = this.activeState; + for (let i = 0; i < state.animations.length; i++) { + animation = state.animations[i]; + clip = this._animEvaluator.findClip(animation.name); + if (clip) { + clip.blendWeight = animation.normalizedWeight; + } + } + } + } else { + if (this.activeState._blendTree.constructor !== AnimNode) { + state = this.activeState; + for (let i = 0; i < state.animations.length; i++) { + animation = state.animations[i]; + clip = this._animEvaluator.findClip(animation.name); + if (clip) { + clip.blendWeight = animation.normalizedWeight; + if (animation.parent.syncAnimations) { + clip.speed = animation.speed; + } + } + } + } + } + this._animEvaluator.update(dt, this.activeState.hasAnimations); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/components/anim/component-binder.js +var v2 = new Vec2(); +var v3 = new Vec3(); +var v4 = new Vec4(); +var c = new Color(); +var q = new Quat2(); +var AnimComponentBinder = class _AnimComponentBinder extends DefaultAnimBinder { + constructor(animComponent, graph, layerName, mask, layerIndex) { + super(graph); + this.animComponent = animComponent; + this._mask = mask; + this.layerName = layerName; + this.layerIndex = layerIndex; + } + static _packFloat(values) { + return values[0]; + } + static _packBoolean(values) { + return !!values[0]; + } + static _packVec2(values) { + v2.x = values[0]; + v2.y = values[1]; + return v2; + } + static _packVec3(values) { + v3.x = values[0]; + v3.y = values[1]; + v3.z = values[2]; + return v3; + } + static _packVec4(values) { + v4.x = values[0]; + v4.y = values[1]; + v4.z = values[2]; + v4.w = values[3]; + return v4; + } + static _packColor(values) { + c.r = values[0]; + c.g = values[1]; + c.b = values[2]; + c.a = values[3]; + return c; + } + static _packQuat(values) { + q.x = values[0]; + q.y = values[1]; + q.z = values[2]; + q.w = values[3]; + return q; + } + resolve(path2) { + const encodedPath = AnimBinder.encode(path2.entityPath, path2.component, path2.propertyPath); + let target2 = this.targetCache[encodedPath]; + if (target2) return target2; + let entity; + let propertyComponent; + let targetPath; + switch (path2.component) { + case "entity": + entity = this._getEntityFromHierarchy(path2.entityPath); + targetPath = AnimBinder.encode(entity.path, "entity", path2.propertyPath); + propertyComponent = entity; + break; + case "graph": + propertyComponent = this.findNode(path2); + if (!propertyComponent) return null; + targetPath = AnimBinder.encode(propertyComponent.path, "graph", path2.propertyPath); + break; + default: + entity = this._getEntityFromHierarchy(path2.entityPath); + propertyComponent = entity.findComponent(path2.component); + if (!propertyComponent) return null; + targetPath = AnimBinder.encode(entity.path, path2.component, path2.propertyPath); + break; + } + target2 = this._createAnimTargetForProperty(propertyComponent, path2.propertyPath, targetPath); + this.targetCache[encodedPath] = target2; + return target2; + } + update(deltaTime) { + const activeNodes = this.activeNodes; + if (activeNodes) { + for (let i = 0; i < activeNodes.length; i++) { + activeNodes[i]._dirtifyLocal(); + } + } + } + _getEntityFromHierarchy(entityHierarchy) { + if (!this.animComponent.entity.name === entityHierarchy[0]) { + return null; + } + const currEntity = this.animComponent.entity; + if (entityHierarchy.length === 1) { + return currEntity; + } + return currEntity._parent.findByPath(entityHierarchy); + } + _resolvePath(object, path2, resolveLeaf) { + const steps = path2.length - (resolveLeaf ? 0 : 1); + for (let i = 0; i < steps; i++) { + object = object[path2[i]]; + } + return object; + } + _setter(object, path2, packFunc) { + const obj = this._resolvePath(object, path2); + const key = path2[path2.length - 1]; + const setterFuncName = "set" + key.substring(0, 1).toUpperCase() + key.substring(1); + if (obj[setterFuncName]) { + const getterFunc = obj["get" + key.substring(0, 1).toUpperCase() + key.substring(1)].bind(obj); + let baseValues = getterFunc(); + baseValues = [baseValues.x, baseValues.y, baseValues.z, baseValues.w]; + const setterFunc = obj[setterFuncName].bind(obj); + return { + set: (values) => { + setterFunc(packFunc(values)); + }, + get: () => baseValues + }; + } + const prop = obj[key]; + if (typeof prop === "object" && prop.hasOwnProperty("copy")) { + return function(values) { + prop.copy(packFunc(values)); + }; + } + if ([Vec2, Vec3, Vec4, Color, Quat2].indexOf(obj.constructor) !== -1 && path2.length > 1) { + const parent = path2.length > 2 ? this._resolvePath(object, path2.slice(0, -1)) : object; + const objKey = path2[path2.length - 2]; + return function(values) { + obj[key] = packFunc(values); + parent[objKey] = obj; + }; + } + return function(values) { + obj[key] = packFunc(values); + }; + } + _createAnimTargetForProperty(propertyComponent, propertyHierarchy, targetPath) { + if (this.handlers && propertyHierarchy[0].startsWith("weight.")) { + return this.handlers.weight(propertyComponent, propertyHierarchy[0].replace("weight.", "")); + } else if (this.handlers && propertyHierarchy[0] === "material" && propertyHierarchy.length === 2) { + const materialPropertyName = propertyHierarchy[1]; + if (materialPropertyName.endsWith("Map")) { + return this.handlers.materialTexture(propertyComponent, materialPropertyName); + } + } + const property = this._resolvePath(propertyComponent, propertyHierarchy, true); + if (typeof property === "undefined") return null; + let setter; + let animDataType; + let animDataComponents; + if (typeof property === "number") { + setter = this._setter(propertyComponent, propertyHierarchy, _AnimComponentBinder._packFloat); + animDataType = "vector"; + animDataComponents = 1; + } else if (typeof property === "boolean") { + setter = this._setter(propertyComponent, propertyHierarchy, _AnimComponentBinder._packBoolean); + animDataType = "vector"; + animDataComponents = 1; + } else if (typeof property === "object") { + switch (property.constructor) { + case Vec2: + setter = this._setter(propertyComponent, propertyHierarchy, _AnimComponentBinder._packVec2); + animDataType = "vector"; + animDataComponents = 2; + break; + case Vec3: + setter = this._setter(propertyComponent, propertyHierarchy, _AnimComponentBinder._packVec3); + animDataType = "vector"; + animDataComponents = 3; + break; + case Vec4: + setter = this._setter(propertyComponent, propertyHierarchy, _AnimComponentBinder._packVec4); + animDataType = "vector"; + animDataComponents = 4; + break; + case Color: + setter = this._setter(propertyComponent, propertyHierarchy, _AnimComponentBinder._packColor); + animDataType = "vector"; + animDataComponents = 4; + break; + case Quat2: + setter = this._setter(propertyComponent, propertyHierarchy, _AnimComponentBinder._packQuat); + animDataType = "quaternion"; + animDataComponents = 4; + break; + default: + return null; + } + } + if (propertyHierarchy.indexOf("material") !== -1) { + return new AnimTarget(function(values) { + setter(values); + propertyComponent.material.update(); + }, animDataType, animDataComponents, targetPath); + } + return new AnimTarget(setter, animDataType, animDataComponents, targetPath); + } + rebind() { + this.targetCache = {}; + if (this.animComponent.rootBone) { + this.graph = this.animComponent.rootBone; + } else { + this.graph = this.animComponent.entity; + } + const nodes = {}; + const flatten = function flatten2(node) { + nodes[node.name] = node; + for (let i = 0; i < node.children.length; ++i) { + flatten2(node.children[i]); + } + }; + flatten(this.graph); + this.nodes = nodes; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/components/anim/component-layer.js +var AnimComponentLayer = class { + constructor(name, controller, component, weight = 1, blendType = ANIM_LAYER_OVERWRITE) { + this._name = void 0; + this._controller = void 0; + this._component = void 0; + this._weight = void 0; + this._blendType = void 0; + this._mask = null; + this._blendTime = 0; + this._blendTimeElapsed = 0; + this._startingWeight = 0; + this._targetWeight = 0; + this._name = name; + this._controller = controller; + this._component = component; + this._weight = weight; + this._blendType = blendType; + } + get name() { + return this._name; + } + set playing(value) { + this._controller.playing = value; + } + get playing() { + return this._controller.playing; + } + get playable() { + return this._controller.playable; + } + get activeState() { + return this._controller.activeStateName; + } + get previousState() { + return this._controller.previousStateName; + } + get activeStateProgress() { + return this._controller.activeStateProgress; + } + get activeStateDuration() { + return this._controller.activeStateDuration; + } + set activeStateCurrentTime(time2) { + const controller = this._controller; + const layerPlaying = controller.playing; + controller.playing = true; + controller.activeStateCurrentTime = time2; + if (!layerPlaying) { + controller.update(0); + } + controller.playing = layerPlaying; + } + get activeStateCurrentTime() { + return this._controller.activeStateCurrentTime; + } + get transitioning() { + return this._controller.transitioning; + } + get transitionProgress() { + if (this.transitioning) { + return this._controller.transitionProgress; + } + return null; + } + get states() { + return this._controller.states; + } + set weight(value) { + this._weight = value; + this._component.dirtifyTargets(); + } + get weight() { + return this._weight; + } + set blendType(value) { + if (value !== this._blendType) { + this._blendType = value; + if (this._controller.normalizeWeights) { + this._component.rebind(); + } + } + } + get blendType() { + return this._blendType; + } + set mask(value) { + if (this._controller.assignMask(value)) { + this._component.rebind(); + } + this._mask = value; + } + get mask() { + return this._mask; + } + play(name) { + this._controller.play(name); + } + pause() { + this._controller.pause(); + } + reset() { + this._controller.reset(); + } + rebind() { + this._controller.rebind(); + } + update(dt) { + if (this._blendTime) { + if (this._blendTimeElapsed < this._blendTime) { + this.weight = math.lerp(this._startingWeight, this._targetWeight, this._blendTimeElapsed / this._blendTime); + this._blendTimeElapsed += dt; + } else { + this.weight = this._targetWeight; + this._blendTime = 0; + this._blendTimeElapsed = 0; + this._startingWeight = 0; + this._targetWeight = 0; + } + } + this._controller.update(dt); + } + blendToWeight(weight, time2) { + this._startingWeight = this.weight; + this._targetWeight = weight; + this._blendTime = Math.max(0, time2); + this._blendTimeElapsed = 0; + } + assignMask(mask) { + if (this._controller.assignMask(mask)) { + this._component.rebind(); + } + this._mask = mask; + } + assignAnimation(nodePath, animTrack, speed, loop) { + if (!(animTrack instanceof AnimTrack)) { + return; + } + this._controller.assignAnimation(nodePath, animTrack, speed, loop); + if (this._controller._transitions.length === 0) { + this._controller._transitions.push(new AnimTransition({ + from: "START", + to: nodePath + })); + } + if (this._component.activate && this._component.playable) { + this._component.playing = true; + } + } + removeNodeAnimations(nodeName) { + if (this._controller.removeNodeAnimations(nodeName)) { + this._component.playing = false; + } + } + getAnimationAsset(stateName) { + return this._component.animationAssets[`${this.name}:${stateName}`]; + } + transition(to, time2 = 0, transitionOffset = null) { + this._controller.updateStateFromTransition(new AnimTransition({ + from: this._controller.activeStateName, + to, + time: time2, + transitionOffset + })); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/anim/state-graph/anim-state-graph.js +var AnimStateGraph = class { + constructor(data2) { + this._layers = []; + this._parameters = {}; + if (!Array.isArray(data2.layers)) { + for (const layerId in data2.layers) { + const dataLayer = data2.layers[layerId]; + const layer = { + name: dataLayer.name, + blendType: dataLayer.blendType, + weight: dataLayer.weight, + states: [], + transitions: [] + }; + for (let i = 0; i < dataLayer.states.length; i++) { + layer.states.push(data2.states[dataLayer.states[i]]); + } + for (let i = 0; i < dataLayer.transitions.length; i++) { + const dataLayerTransition = data2.transitions[dataLayer.transitions[i]]; + if (dataLayerTransition.conditions && !Array.isArray(dataLayerTransition.conditions)) { + const conditionKeys = Object.keys(dataLayerTransition.conditions); + const conditions = []; + for (let j = 0; j < conditionKeys.length; j++) { + const condition = dataLayerTransition.conditions[conditionKeys[j]]; + if (condition.parameterName) { + conditions.push(condition); + } + } + dataLayerTransition.conditions = conditions; + } + if (Number.isInteger(dataLayerTransition.from)) { + dataLayerTransition.from = data2.states[dataLayerTransition.from].name; + } + if (Number.isInteger(dataLayerTransition.to)) { + dataLayerTransition.to = data2.states[dataLayerTransition.to].name; + } + layer.transitions.push(dataLayerTransition); + } + this._layers.push(layer); + } + } else { + this._layers = data2.layers; + } + for (const paramId in data2.parameters) { + const param = data2.parameters[paramId]; + this._parameters[param.name] = { + type: param.type, + value: param.value + }; + } + } + get parameters() { + return Object.assign({}, this._parameters); + } + get layers() { + return this._layers; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/components/anim/component.js +var AnimComponent = class extends Component { + constructor(system, entity) { + super(system, entity); + this.findParameter = (name) => { + return this._parameters[name]; + }; + this.consumeTrigger = (name) => { + this._consumedTriggers.add(name); + }; + this._stateGraphAsset = null; + this._animationAssets = {}; + this._speed = 1; + this._activate = true; + this._playing = false; + this._rootBone = null; + this._stateGraph = null; + this._layers = []; + this._layerIndices = {}; + this._parameters = {}; + this._targets = {}; + this._consumedTriggers = /* @__PURE__ */ new Set(); + this._normalizeWeights = false; + } + set stateGraphAsset(value) { + if (value === null) { + this.removeStateGraph(); + return; + } + if (this._stateGraphAsset) { + const stateGraphAsset = this.system.app.assets.get(this._stateGraphAsset); + stateGraphAsset.off("change", this._onStateGraphAssetChangeEvent, this); + } + let _id; + let _asset; + if (value instanceof Asset) { + _id = value.id; + _asset = this.system.app.assets.get(_id); + if (!_asset) { + this.system.app.assets.add(value); + _asset = this.system.app.assets.get(_id); + } + } else { + _id = value; + _asset = this.system.app.assets.get(_id); + } + if (!_asset || this._stateGraphAsset === _id) { + return; + } + if (_asset.resource) { + this._stateGraph = _asset.resource; + this.loadStateGraph(this._stateGraph); + _asset.on("change", this._onStateGraphAssetChangeEvent, this); + } else { + _asset.once("load", (asset2) => { + this._stateGraph = asset2.resource; + this.loadStateGraph(this._stateGraph); + }); + _asset.on("change", this._onStateGraphAssetChangeEvent, this); + this.system.app.assets.load(_asset); + } + this._stateGraphAsset = _id; + } + get stateGraphAsset() { + return this._stateGraphAsset; + } + set normalizeWeights(value) { + this._normalizeWeights = value; + this.unbind(); + } + get normalizeWeights() { + return this._normalizeWeights; + } + set animationAssets(value) { + this._animationAssets = value; + this.loadAnimationAssets(); + } + get animationAssets() { + return this._animationAssets; + } + set speed(value) { + this._speed = value; + } + get speed() { + return this._speed; + } + set activate(value) { + this._activate = value; + } + get activate() { + return this._activate; + } + set playing(value) { + this._playing = value; + } + get playing() { + return this._playing; + } + set rootBone(value) { + if (typeof value === "string") { + const entity = this.entity.root.findByGuid(value); + this._rootBone = entity; + } else if (value instanceof Entity) { + this._rootBone = value; + } else { + this._rootBone = null; + } + this.rebind(); + } + get rootBone() { + return this._rootBone; + } + set stateGraph(value) { + this._stateGraph = value; + } + get stateGraph() { + return this._stateGraph; + } + get layers() { + return this._layers; + } + set layerIndices(value) { + this._layerIndices = value; + } + get layerIndices() { + return this._layerIndices; + } + set parameters(value) { + this._parameters = value; + } + get parameters() { + return this._parameters; + } + set targets(value) { + this._targets = value; + } + get targets() { + return this._targets; + } + get playable() { + for (let i = 0; i < this._layers.length; i++) { + if (!this._layers[i].playable) { + return false; + } + } + return true; + } + get baseLayer() { + if (this._layers.length > 0) { + return this._layers[0]; + } + return null; + } + _onStateGraphAssetChangeEvent(asset2) { + const prevAnimationAssets = this.animationAssets; + const prevMasks = this.layers.map((layer) => layer.mask); + this.removeStateGraph(); + this._stateGraph = new AnimStateGraph(asset2._data); + this.loadStateGraph(this._stateGraph); + this.animationAssets = prevAnimationAssets; + this.loadAnimationAssets(); + this.layers.forEach((layer, i) => { + layer.mask = prevMasks[i]; + }); + this.rebind(); + } + dirtifyTargets() { + const targets = Object.values(this._targets); + for (let i = 0; i < targets.length; i++) { + targets[i].dirty = true; + } + } + _addLayer({ + name, + states, + transitions, + weight, + mask, + blendType + }) { + let graph; + if (this.rootBone) { + graph = this.rootBone; + } else { + graph = this.entity; + } + const layerIndex = this._layers.length; + const animBinder = new AnimComponentBinder(this, graph, name, mask, layerIndex); + const animEvaluator = new AnimEvaluator(animBinder); + const controller = new AnimController(animEvaluator, states, transitions, this._activate, this, this.findParameter, this.consumeTrigger); + this._layers.push(new AnimComponentLayer(name, controller, this, weight, blendType)); + this._layerIndices[name] = layerIndex; + return this._layers[layerIndex]; + } + addLayer(name, weight, mask, blendType) { + const layer = this.findAnimationLayer(name); + if (layer) return layer; + const states = [{ + "name": "START", + "speed": 1 + }]; + const transitions = []; + return this._addLayer({ + name, + states, + transitions, + weight, + mask, + blendType + }); + } + _assignParameters(stateGraph) { + this._parameters = {}; + const paramKeys = Object.keys(stateGraph.parameters); + for (let i = 0; i < paramKeys.length; i++) { + const paramKey = paramKeys[i]; + this._parameters[paramKey] = { + type: stateGraph.parameters[paramKey].type, + value: stateGraph.parameters[paramKey].value + }; + } + } + loadStateGraph(stateGraph) { + this._stateGraph = stateGraph; + this._assignParameters(stateGraph); + this._layers = []; + let containsBlendTree = false; + for (let i = 0; i < stateGraph.layers.length; i++) { + const layer = stateGraph.layers[i]; + this._addLayer(_extends({}, layer)); + if (layer.states.some((state) => state.blendTree)) { + containsBlendTree = true; + } + } + if (!containsBlendTree) { + this.setupAnimationAssets(); + } + } + setupAnimationAssets() { + for (let i = 0; i < this._layers.length; i++) { + const layer = this._layers[i]; + const layerName = layer.name; + for (let j = 0; j < layer.states.length; j++) { + const stateName = layer.states[j]; + if (ANIM_CONTROL_STATES.indexOf(stateName) === -1) { + const stateKey = layerName + ":" + stateName; + if (!this._animationAssets[stateKey]) { + this._animationAssets[stateKey] = { + asset: null + }; + } + } + } + } + this.loadAnimationAssets(); + } + loadAnimationAssets() { + for (let i = 0; i < this._layers.length; i++) { + const layer = this._layers[i]; + for (let j = 0; j < layer.states.length; j++) { + const stateName = layer.states[j]; + if (ANIM_CONTROL_STATES.indexOf(stateName) !== -1) continue; + const animationAsset = this._animationAssets[layer.name + ":" + stateName]; + if (!animationAsset || !animationAsset.asset) { + this.findAnimationLayer(layer.name).assignAnimation(stateName, AnimTrack.EMPTY); + continue; + } + const assetId = animationAsset.asset; + const asset2 = this.system.app.assets.get(assetId); + if (asset2) { + if (asset2.resource) { + this.onAnimationAssetLoaded(layer.name, stateName, asset2); + } else { + asset2.once("load", function(layerName, stateName2) { + return function(asset3) { + this.onAnimationAssetLoaded(layerName, stateName2, asset3); + }.bind(this); + }.bind(this)(layer.name, stateName)); + this.system.app.assets.load(asset2); + } + } + } + } + } + onAnimationAssetLoaded(layerName, stateName, asset2) { + this.findAnimationLayer(layerName).assignAnimation(stateName, asset2.resource); + } + removeStateGraph() { + this._stateGraph = null; + this._stateGraphAsset = null; + this._animationAssets = {}; + this._layers = []; + this._layerIndices = {}; + this._parameters = {}; + this._playing = false; + this.unbind(); + this._targets = {}; + } + reset() { + this._assignParameters(this._stateGraph); + for (let i = 0; i < this._layers.length; i++) { + const layerPlaying = this._layers[i].playing; + this._layers[i].reset(); + this._layers[i].playing = layerPlaying; + } + } + unbind() { + if (!this._normalizeWeights) { + Object.keys(this._targets).forEach((targetKey) => { + this._targets[targetKey].unbind(); + }); + } + } + rebind() { + this._targets = {}; + for (let i = 0; i < this._layers.length; i++) { + this._layers[i].rebind(); + } + } + findAnimationLayer(name) { + const layerIndex = this._layerIndices[name]; + return this._layers[layerIndex] || null; + } + addAnimationState(nodeName, animTrack, speed = 1, loop = true, layerName = "Base") { + if (!this._stateGraph) { + this.loadStateGraph(new AnimStateGraph({ + "layers": [{ + "name": layerName, + "states": [{ + "name": "START", + "speed": 1 + }, { + "name": nodeName, + "speed": speed, + "loop": loop, + "defaultState": true + }], + "transitions": [{ + "from": "START", + "to": nodeName + }] + }], + "parameters": {} + })); + } + const layer = this.findAnimationLayer(layerName); + if (layer) { + layer.assignAnimation(nodeName, animTrack, speed, loop); + } else { + var _this$addLayer; + (_this$addLayer = this.addLayer(layerName)) == null || _this$addLayer.assignAnimation(nodeName, animTrack, speed, loop); + } + } + assignAnimation(nodePath, animTrack, layerName, speed = 1, loop = true) { + if (!this._stateGraph && nodePath.indexOf(".") === -1) { + this.loadStateGraph(new AnimStateGraph({ + "layers": [{ + "name": "Base", + "states": [{ + "name": "START", + "speed": 1 + }, { + "name": nodePath, + "speed": speed, + "loop": loop, + "defaultState": true + }], + "transitions": [{ + "from": "START", + "to": nodePath + }] + }], + "parameters": {} + })); + this.baseLayer.assignAnimation(nodePath, animTrack); + return; + } + const layer = layerName ? this.findAnimationLayer(layerName) : this.baseLayer; + if (!layer) { + return; + } + layer.assignAnimation(nodePath, animTrack, speed, loop); + } + removeNodeAnimations(nodeName, layerName) { + const layer = layerName ? this.findAnimationLayer(layerName) : this.baseLayer; + if (!layer) { + return; + } + layer.removeNodeAnimations(nodeName); + } + getParameterValue(name, type2) { + const param = this._parameters[name]; + if (param && param.type === type2) { + return param.value; + } + return void 0; + } + setParameterValue(name, type2, value) { + const param = this._parameters[name]; + if (param && param.type === type2) { + param.value = value; + return; + } + } + getFloat(name) { + return this.getParameterValue(name, ANIM_PARAMETER_FLOAT); + } + setFloat(name, value) { + this.setParameterValue(name, ANIM_PARAMETER_FLOAT, value); + } + getInteger(name) { + return this.getParameterValue(name, ANIM_PARAMETER_INTEGER); + } + setInteger(name, value) { + if (typeof value === "number" && value % 1 === 0) { + this.setParameterValue(name, ANIM_PARAMETER_INTEGER, value); + } + } + getBoolean(name) { + return this.getParameterValue(name, ANIM_PARAMETER_BOOLEAN); + } + setBoolean(name, value) { + this.setParameterValue(name, ANIM_PARAMETER_BOOLEAN, !!value); + } + getTrigger(name) { + return this.getParameterValue(name, ANIM_PARAMETER_TRIGGER); + } + setTrigger(name, singleFrame = false) { + this.setParameterValue(name, ANIM_PARAMETER_TRIGGER, true); + if (singleFrame) { + this._consumedTriggers.add(name); + } + } + resetTrigger(name) { + this.setParameterValue(name, ANIM_PARAMETER_TRIGGER, false); + } + onBeforeRemove() { + if (Number.isFinite(this._stateGraphAsset)) { + const stateGraphAsset = this.system.app.assets.get(this._stateGraphAsset); + stateGraphAsset.off("change", this._onStateGraphAssetChangeEvent, this); + } + } + update(dt) { + for (let i = 0; i < this.layers.length; i++) { + this.layers[i].update(dt * this.speed); + } + this._consumedTriggers.forEach((trigger) => { + this.parameters[trigger].value = false; + }); + this._consumedTriggers.clear(); + } + resolveDuplicatedEntityReferenceProperties(oldAnim, duplicatedIdsMap) { + if (oldAnim.rootBone && duplicatedIdsMap[oldAnim.rootBone.getGuid()]) { + this.rootBone = duplicatedIdsMap[oldAnim.rootBone.getGuid()]; + } else { + this.rebind(); + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/components/anim/data.js +var AnimComponentData = class { + constructor() { + this.enabled = true; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/components/anim/system.js +var _schema = ["enabled"]; +var AnimComponentSystem = class extends ComponentSystem { + constructor(app2) { + super(app2); + this.id = "anim"; + this.ComponentType = AnimComponent; + this.DataType = AnimComponentData; + this.schema = _schema; + this.on("beforeremove", this.onBeforeRemove, this); + this.app.systems.on("animationUpdate", this.onAnimationUpdate, this); + } + initializeComponentData(component, data2, properties2) { + super.initializeComponentData(component, data2, _schema); + const complexProperties = ["animationAssets", "stateGraph", "layers", "masks"]; + Object.keys(data2).forEach((key) => { + if (complexProperties.includes(key)) return; + component[key] = data2[key]; + }); + if (data2.stateGraph) { + component.stateGraph = data2.stateGraph; + component.loadStateGraph(component.stateGraph); + } + if (data2.layers) { + data2.layers.forEach((layer, i) => { + layer._controller.states.forEach((stateKey) => { + layer._controller._states[stateKey]._animationList.forEach((node) => { + if (!node.animTrack || node.animTrack === AnimTrack.EMPTY) { + const animationAsset = this.app.assets.get(layer._component._animationAssets[layer.name + ":" + node.name].asset); + if (animationAsset && !animationAsset.loaded) { + animationAsset.once("load", () => { + component.layers[i].assignAnimation(node.name, animationAsset.resource); + }); + } + } else { + component.layers[i].assignAnimation(node.name, node.animTrack); + } + }); + }); + }); + } + if (data2.animationAssets) { + component.animationAssets = Object.assign(component.animationAssets, data2.animationAssets); + } + if (data2.masks) { + Object.keys(data2.masks).forEach((key) => { + if (component.layers[key]) { + const maskData = data2.masks[key].mask; + const mask = {}; + Object.keys(maskData).forEach((maskKey) => { + mask[decodeURI(maskKey)] = maskData[maskKey]; + }); + component.layers[key].mask = mask; + } + }); + } + } + onAnimationUpdate(dt) { + const components = this.store; + for (const id12 in components) { + if (components.hasOwnProperty(id12)) { + const component = components[id12].entity.anim; + const componentData = component.data; + if (componentData.enabled && component.entity.enabled && component.playing) { + component.update(dt); + } + } + } + } + cloneComponent(entity, clone) { + let masks; + if (!entity.anim.rootBone || entity.anim.rootBone === entity) { + masks = {}; + entity.anim.layers.forEach((layer, i) => { + if (layer.mask) { + const mask = {}; + Object.keys(layer.mask).forEach((path2) => { + const pathArr = path2.split("/"); + pathArr.shift(); + const clonePath = [clone.name, ...pathArr].join("/"); + mask[clonePath] = layer.mask[path2]; + }); + masks[i] = { + mask + }; + } + }); + } + const data2 = { + stateGraphAsset: entity.anim.stateGraphAsset, + animationAssets: entity.anim.animationAssets, + speed: entity.anim.speed, + activate: entity.anim.activate, + playing: entity.anim.playing, + rootBone: entity.anim.rootBone, + stateGraph: entity.anim.stateGraph, + layers: entity.anim.layers, + layerIndices: entity.anim.layerIndices, + parameters: entity.anim.parameters, + normalizeWeights: entity.anim.normalizeWeights, + masks + }; + return this.addComponent(clone, data2); + } + onBeforeRemove(entity, component) { + component.onBeforeRemove(); + } + destroy() { + super.destroy(); + this.app.systems.off("animationUpdate", this.onAnimationUpdate, this); + } +}; +Component._buildAccessors(AnimComponent.prototype, _schema); + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/components/audio-listener/component.js +var AudioListenerComponent = class extends Component { + constructor(system, entity) { + super(system, entity); + } + setCurrentListener() { + if (this.enabled && this.entity.audiolistener && this.entity.enabled) { + this.system.current = this.entity; + const position2 = this.system.current.getPosition(); + this.system.manager.listener.setPosition(position2); + } + } + onEnable() { + this.setCurrentListener(); + } + onDisable() { + if (this.system.current === this.entity) { + this.system.current = null; + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/components/audio-listener/data.js +var AudioListenerComponentData = class { + constructor() { + this.enabled = true; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/components/audio-listener/system.js +var _schema2 = ["enabled"]; +var AudioListenerComponentSystem = class extends ComponentSystem { + constructor(app2) { + super(app2); + this.id = "audiolistener"; + this.ComponentType = AudioListenerComponent; + this.DataType = AudioListenerComponentData; + this.schema = _schema2; + this.manager = app2.soundManager; + this.current = null; + this.app.systems.on("update", this.onUpdate, this); + } + initializeComponentData(component, data2, properties2) { + properties2 = ["enabled"]; + super.initializeComponentData(component, data2, properties2); + } + onUpdate(dt) { + if (this.current) { + const position2 = this.current.getPosition(); + this.manager.listener.setPosition(position2); + const wtm = this.current.getWorldTransform(); + this.manager.listener.setOrientation(wtm); + } + } + destroy() { + super.destroy(); + this.app.systems.off("update", this.onUpdate, this); + } +}; +Component._buildAccessors(AudioListenerComponent.prototype, _schema2); + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/utils/entity-reference.js +var EntityReference = class extends EventHandler { + constructor(parentComponent, entityPropertyName, eventConfig) { + super(); + if (!parentComponent || !(parentComponent instanceof Component)) { + throw new Error("The parentComponent argument is required and must be a Component"); + } else if (!entityPropertyName || typeof entityPropertyName !== "string") { + throw new Error("The propertyName argument is required and must be a string"); + } else if (eventConfig && typeof eventConfig !== "object") { + throw new Error("If provided, the eventConfig argument must be an object"); + } + this._parentComponent = parentComponent; + this._entityPropertyName = entityPropertyName; + this._entity = null; + this._app = parentComponent.system.app; + this._configureEventListeners(eventConfig || {}, { + "entity#destroy": this._onEntityDestroy + }); + this._toggleLifecycleListeners("on"); + } + _configureEventListeners(externalEventConfig, internalEventConfig) { + const externalEventListenerConfigs = this._parseEventListenerConfig(externalEventConfig, "external", this._parentComponent); + const internalEventListenerConfigs = this._parseEventListenerConfig(internalEventConfig, "internal", this); + this._eventListenerConfigs = externalEventListenerConfigs.concat(internalEventListenerConfigs); + this._listenerStatusFlags = {}; + this._gainListeners = {}; + this._loseListeners = {}; + } + _parseEventListenerConfig(eventConfig, prefix, scope) { + return Object.keys(eventConfig).map(function(listenerDescription, index) { + const listenerDescriptionParts = listenerDescription.split("#"); + const sourceName = listenerDescriptionParts[0]; + const eventName = listenerDescriptionParts[1]; + const callback = eventConfig[listenerDescription]; + if (listenerDescriptionParts.length !== 2 || typeof sourceName !== "string" || sourceName.length === 0 || typeof eventName !== "string" || eventName.length === 0) { + throw new Error("Invalid event listener description: `" + listenerDescription + "`"); + } + if (typeof callback !== "function") { + throw new Error("Invalid or missing callback for event listener `" + listenerDescription + "`"); + } + return { + id: prefix + "_" + index + "_" + listenerDescription, + sourceName, + eventName, + callback, + scope + }; + }, this); + } + _toggleLifecycleListeners(onOrOff) { + this._parentComponent[onOrOff]("set_" + this._entityPropertyName, this._onSetEntity, this); + this._parentComponent.system[onOrOff]("beforeremove", this._onParentComponentRemove, this); + this._app.systems[onOrOff]("postPostInitialize", this._updateEntityReference, this); + this._app[onOrOff]("tools:sceneloaded", this._onSceneLoaded, this); + const allComponentSystems = []; + for (let i = 0; i < this._eventListenerConfigs.length; ++i) { + const config = this._eventListenerConfigs[i]; + const componentSystem = this._app.systems[config.sourceName]; + if (componentSystem) { + if (allComponentSystems.indexOf(componentSystem) === -1) { + allComponentSystems.push(componentSystem); + } + if (componentSystem && config.eventName === "gain") { + this._gainListeners[config.sourceName] = config; + } + if (componentSystem && config.eventName === "lose") { + this._loseListeners[config.sourceName] = config; + } + } + } + for (let i = 0; i < allComponentSystems.length; ++i) { + allComponentSystems[i][onOrOff]("add", this._onComponentAdd, this); + allComponentSystems[i][onOrOff]("beforeremove", this._onComponentRemove, this); + } + } + _onSetEntity(name, oldValue, newValue) { + if (newValue instanceof Entity) { + this._updateEntityReference(); + } else { + if (newValue !== null && newValue !== void 0 && typeof newValue !== "string") { + console.warn("Entity field `" + this._entityPropertyName + "` was set to unexpected type '" + typeof newValue + "'"); + return; + } + if (oldValue !== newValue) { + this._updateEntityReference(); + } + } + } + onParentComponentEnable() { + if (!this._entity) { + this._updateEntityReference(); + } + } + _onSceneLoaded() { + this._updateEntityReference(); + } + _updateEntityReference() { + let nextEntityGuid = this._parentComponent.data[this._entityPropertyName]; + let nextEntity; + if (nextEntityGuid instanceof Entity) { + nextEntity = nextEntityGuid; + nextEntityGuid = nextEntity.getGuid(); + this._parentComponent.data[this._entityPropertyName] = nextEntityGuid; + } else { + const root = this._parentComponent.system.app.root; + const isOnSceneGraph = this._parentComponent.entity.isDescendantOf(root); + nextEntity = isOnSceneGraph && nextEntityGuid ? root.findByGuid(nextEntityGuid) : null; + } + const hasChanged = this._entity !== nextEntity; + if (hasChanged) { + if (this._entity) { + this._onBeforeEntityChange(); + } + this._entity = nextEntity; + if (this._entity) { + this._onAfterEntityChange(); + } + this.fire("set:entity", this._entity); + } + } + _onBeforeEntityChange() { + this._toggleEntityListeners("off"); + this._callAllGainOrLoseListeners(this._loseListeners); + } + _onAfterEntityChange() { + this._toggleEntityListeners("on"); + this._callAllGainOrLoseListeners(this._gainListeners); + } + _onComponentAdd(entity, component) { + const componentName = component.system.id; + if (entity === this._entity) { + this._callGainOrLoseListener(componentName, this._gainListeners); + this._toggleComponentListeners("on", componentName); + } + } + _onComponentRemove(entity, component) { + const componentName = component.system.id; + if (entity === this._entity) { + this._callGainOrLoseListener(componentName, this._loseListeners); + this._toggleComponentListeners("off", componentName, true); + } + } + _callAllGainOrLoseListeners(listenerMap) { + for (const componentName in this._entity.c) { + this._callGainOrLoseListener(componentName, listenerMap); + } + } + _callGainOrLoseListener(componentName, listenerMap) { + if (this._entity.c.hasOwnProperty(componentName) && listenerMap[componentName]) { + const config = listenerMap[componentName]; + config.callback.call(config.scope); + } + } + _toggleEntityListeners(onOrOff, isDestroying) { + if (this._entity) { + for (let i = 0; i < this._eventListenerConfigs.length; ++i) { + this._safeToggleListener(onOrOff, this._eventListenerConfigs[i], isDestroying); + } + } + } + _toggleComponentListeners(onOrOff, componentName, isDestroying) { + for (let i = 0; i < this._eventListenerConfigs.length; ++i) { + const config = this._eventListenerConfigs[i]; + if (config.sourceName === componentName) { + this._safeToggleListener(onOrOff, config, isDestroying); + } + } + } + _safeToggleListener(onOrOff, config, isDestroying) { + const isAdding = onOrOff === "on"; + if (isAdding && this._listenerStatusFlags[config.id]) { + return; + } + const source = this._getEventSource(config.sourceName, isDestroying); + if (source) { + source[onOrOff](config.eventName, config.callback, config.scope); + this._listenerStatusFlags[config.id] = isAdding; + } + } + _getEventSource(sourceName, isDestroying) { + if (sourceName === "entity") { + return this._entity; + } + const component = this._entity[sourceName]; + if (component) { + return component; + } + if (!isDestroying) { + console.warn("Entity has no component with name " + sourceName); + } + return null; + } + _onEntityDestroy(entity) { + if (this._entity === entity) { + this._toggleEntityListeners("off", true); + this._entity = null; + } + } + _onParentComponentRemove(entity, component) { + if (component === this._parentComponent) { + this._toggleLifecycleListeners("off"); + this._toggleEntityListeners("off", true); + } + } + hasComponent(componentName) { + return this._entity && this._entity.c ? !!this._entity.c[componentName] : false; + } + get entity() { + return this._entity; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/components/collision/component.js +var _vec3 = new Vec3(); +var _quat = new Quat2(); +var CollisionComponent = class extends Component { + constructor(system, entity) { + super(system, entity); + this._compoundParent = null; + this._hasOffset = false; + this.entity.on("insert", this._onInsert, this); + this.on("set_type", this.onSetType, this); + this.on("set_convexHull", this.onSetModel, this); + this.on("set_halfExtents", this.onSetHalfExtents, this); + this.on("set_linearOffset", this.onSetOffset, this); + this.on("set_angularOffset", this.onSetOffset, this); + this.on("set_radius", this.onSetRadius, this); + this.on("set_height", this.onSetHeight, this); + this.on("set_axis", this.onSetAxis, this); + this.on("set_asset", this.onSetAsset, this); + this.on("set_renderAsset", this.onSetRenderAsset, this); + this.on("set_model", this.onSetModel, this); + this.on("set_render", this.onSetRender, this); + } + get data() { + const record = this.system.store[this.entity.getGuid()]; + return record ? record.data : null; + } + set enabled(arg) { + this._setValue("enabled", arg); + } + get enabled() { + return this.data.enabled; + } + set type(arg) { + this._setValue("type", arg); + } + get type() { + return this.data.type; + } + set halfExtents(arg) { + this._setValue("halfExtents", arg); + } + get halfExtents() { + return this.data.halfExtents; + } + set linearOffset(arg) { + this._setValue("linearOffset", arg); + } + get linearOffset() { + return this.data.linearOffset; + } + set angularOffset(arg) { + this._setValue("angularOffset", arg); + } + get angularOffset() { + return this.data.angularOffset; + } + set radius(arg) { + this._setValue("radius", arg); + } + get radius() { + return this.data.radius; + } + set axis(arg) { + this._setValue("axis", arg); + } + get axis() { + return this.data.axis; + } + set height(arg) { + this._setValue("height", arg); + } + get height() { + return this.data.height; + } + set asset(arg) { + this._setValue("asset", arg); + } + get asset() { + return this.data.asset; + } + set renderAsset(arg) { + this._setValue("renderAsset", arg); + } + get renderAsset() { + return this.data.renderAsset; + } + set convexHull(arg) { + this._setValue("convexHull", arg); + } + get convexHull() { + return this.data.convexHull; + } + set shape(arg) { + this._setValue("shape", arg); + } + get shape() { + return this.data.shape; + } + set model(arg) { + this._setValue("model", arg); + } + get model() { + return this.data.model; + } + set render(arg) { + this._setValue("render", arg); + } + get render() { + return this.data.render; + } + set checkVertexDuplicates(arg) { + this._setValue("checkVertexDuplicates", arg); + } + get checkVertexDuplicates() { + return this.data.checkVertexDuplicates; + } + _setValue(name, value) { + const data2 = this.data; + const oldValue = data2[name]; + data2[name] = value; + this.fire("set", name, oldValue, value); + } + onSetType(name, oldValue, newValue) { + if (oldValue !== newValue) { + this.system.changeType(this, oldValue, newValue); + } + } + onSetHalfExtents(name, oldValue, newValue) { + const t = this.data.type; + if (this.data.initialized && t === "box") { + this.system.recreatePhysicalShapes(this); + } + } + onSetOffset(name, oldValue, newValue) { + this._hasOffset = !this.data.linearOffset.equals(Vec3.ZERO) || !this.data.angularOffset.equals(Quat2.IDENTITY); + if (this.data.initialized) { + this.system.recreatePhysicalShapes(this); + } + } + onSetRadius(name, oldValue, newValue) { + const t = this.data.type; + if (this.data.initialized && (t === "sphere" || t === "capsule" || t === "cylinder" || t === "cone")) { + this.system.recreatePhysicalShapes(this); + } + } + onSetHeight(name, oldValue, newValue) { + const t = this.data.type; + if (this.data.initialized && (t === "capsule" || t === "cylinder" || t === "cone")) { + this.system.recreatePhysicalShapes(this); + } + } + onSetAxis(name, oldValue, newValue) { + const t = this.data.type; + if (this.data.initialized && (t === "capsule" || t === "cylinder" || t === "cone")) { + this.system.recreatePhysicalShapes(this); + } + } + onSetAsset(name, oldValue, newValue) { + const assets = this.system.app.assets; + if (oldValue) { + const asset2 = assets.get(oldValue); + if (asset2) { + asset2.off("remove", this.onAssetRemoved, this); + } + } + if (newValue) { + if (newValue instanceof Asset) { + this.data.asset = newValue.id; + } + const asset2 = assets.get(this.data.asset); + if (asset2) { + asset2.off("remove", this.onAssetRemoved, this); + asset2.on("remove", this.onAssetRemoved, this); + } + } + if (this.data.initialized && this.data.type === "mesh") { + if (!newValue) { + this.data.model = null; + } + this.system.recreatePhysicalShapes(this); + } + } + onSetRenderAsset(name, oldValue, newValue) { + const assets = this.system.app.assets; + if (oldValue) { + const asset2 = assets.get(oldValue); + if (asset2) { + asset2.off("remove", this.onRenderAssetRemoved, this); + } + } + if (newValue) { + if (newValue instanceof Asset) { + this.data.renderAsset = newValue.id; + } + const asset2 = assets.get(this.data.renderAsset); + if (asset2) { + asset2.off("remove", this.onRenderAssetRemoved, this); + asset2.on("remove", this.onRenderAssetRemoved, this); + } + } + if (this.data.initialized && this.data.type === "mesh") { + if (!newValue) { + this.data.render = null; + } + this.system.recreatePhysicalShapes(this); + } + } + onSetModel(name, oldValue, newValue) { + if (this.data.initialized && this.data.type === "mesh") { + this.system.implementations.mesh.doRecreatePhysicalShape(this); + } + } + onSetRender(name, oldValue, newValue) { + this.onSetModel(name, oldValue, newValue); + } + onAssetRemoved(asset2) { + asset2.off("remove", this.onAssetRemoved, this); + if (this.data.asset === asset2.id) { + this.asset = null; + } + } + onRenderAssetRemoved(asset2) { + asset2.off("remove", this.onRenderAssetRemoved, this); + if (this.data.renderAsset === asset2.id) { + this.renderAsset = null; + } + } + _getCompoundChildShapeIndex(shape2) { + const compound = this.data.shape; + const shapes = compound.getNumChildShapes(); + for (let i = 0; i < shapes; i++) { + const childShape = compound.getChildShape(i); + if (childShape.ptr === shape2.ptr) { + return i; + } + } + return null; + } + _onInsert(parent) { + if (typeof Ammo === "undefined") { + return; + } + if (this._compoundParent) { + this.system.recreatePhysicalShapes(this); + } else if (!this.entity.rigidbody) { + let ancestor = this.entity.parent; + while (ancestor) { + if (ancestor.collision && ancestor.collision.type === "compound") { + if (ancestor.collision.shape.getNumChildShapes() === 0) { + this.system.recreatePhysicalShapes(ancestor.collision); + } else { + this.system.recreatePhysicalShapes(this); + } + break; + } + ancestor = ancestor.parent; + } + } + } + _updateCompound() { + const entity = this.entity; + if (entity._dirtyWorld) { + let dirty = entity._dirtyLocal; + let parent = entity; + while (parent && !dirty) { + if (parent.collision && parent.collision === this._compoundParent) { + break; + } + if (parent._dirtyLocal) { + dirty = true; + } + parent = parent.parent; + } + if (dirty) { + entity.forEach(this.system.implementations.compound._updateEachDescendantTransform, entity); + const bodyComponent = this._compoundParent.entity.rigidbody; + if (bodyComponent) { + bodyComponent.activate(); + } + } + } + } + getShapePosition() { + const pos = this.entity.getPosition(); + if (this._hasOffset) { + const rot = this.entity.getRotation(); + const lo = this.data.linearOffset; + _quat.copy(rot).transformVector(lo, _vec3); + return _vec3.add(pos); + } + return pos; + } + getShapeRotation() { + const rot = this.entity.getRotation(); + if (this._hasOffset) { + return _quat.copy(rot).mul(this.data.angularOffset); + } + return rot; + } + onEnable() { + if (this.data.type === "mesh" && (this.data.asset || this.data.renderAsset) && this.data.initialized) { + const asset2 = this.system.app.assets.get(this.data.asset || this.data.renderAsset); + if (asset2 && (!asset2.resource || !this.data.shape)) { + this.system.recreatePhysicalShapes(this); + return; + } + } + if (this.entity.rigidbody) { + if (this.entity.rigidbody.enabled) { + this.entity.rigidbody.enableSimulation(); + } + } else if (this._compoundParent && this !== this._compoundParent) { + if (this._compoundParent.shape.getNumChildShapes() === 0) { + this.system.recreatePhysicalShapes(this._compoundParent); + } else { + const transform = this.system._getNodeTransform(this.entity, this._compoundParent.entity); + this._compoundParent.shape.addChildShape(transform, this.data.shape); + Ammo.destroy(transform); + if (this._compoundParent.entity.rigidbody) { + this._compoundParent.entity.rigidbody.activate(); + } + } + } else if (this.entity.trigger) { + this.entity.trigger.enable(); + } + } + onDisable() { + if (this.entity.rigidbody) { + this.entity.rigidbody.disableSimulation(); + } else if (this._compoundParent && this !== this._compoundParent) { + if (!this._compoundParent.entity._destroying) { + this.system._removeCompoundChild(this._compoundParent, this.data.shape); + if (this._compoundParent.entity.rigidbody) { + this._compoundParent.entity.rigidbody.activate(); + } + } + } else if (this.entity.trigger) { + this.entity.trigger.disable(); + } + } + onBeforeRemove() { + if (this.asset) { + this.asset = null; + } + if (this.renderAsset) { + this.renderAsset = null; + } + this.entity.off("insert", this._onInsert, this); + this.off(); + } +}; +CollisionComponent.EVENT_CONTACT = "contact"; +CollisionComponent.EVENT_COLLISIONSTART = "collisionstart"; +CollisionComponent.EVENT_COLLISIONEND = "collisionend"; +CollisionComponent.EVENT_TRIGGERENTER = "triggerenter"; +CollisionComponent.EVENT_TRIGGERLEAVE = "triggerleave"; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/components/collision/data.js +var CollisionComponentData = class { + constructor() { + this.enabled = true; + this.type = "box"; + this.halfExtents = new Vec3(0.5, 0.5, 0.5); + this.linearOffset = new Vec3(); + this.angularOffset = new Quat2(); + this.radius = 0.5; + this.axis = 1; + this.height = 2; + this.convexHull = false; + this.asset = null; + this.renderAsset = null; + this.checkVertexDuplicates = true; + this.shape = null; + this.model = null; + this.render = null; + this.initialized = false; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/components/rigid-body/constants.js +var BODYTYPE_STATIC = "static"; +var BODYTYPE_DYNAMIC = "dynamic"; +var BODYTYPE_KINEMATIC = "kinematic"; +var BODYFLAG_KINEMATIC_OBJECT = 2; +var BODYFLAG_NORESPONSE_OBJECT = 4; +var BODYSTATE_ACTIVE_TAG = 1; +var BODYSTATE_DISABLE_DEACTIVATION = 4; +var BODYSTATE_DISABLE_SIMULATION = 5; +var BODYGROUP_DYNAMIC = 1; +var BODYGROUP_STATIC = 2; +var BODYGROUP_KINEMATIC = 4; +var BODYGROUP_TRIGGER = 16; +var BODYMASK_ALL = 65535; +var BODYMASK_NOT_STATIC = 65535 ^ 2; +var BODYMASK_NOT_STATIC_KINEMATIC = 65535 ^ (2 | 4); + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/components/collision/trigger.js +var _ammoVec1; +var _ammoQuat; +var _ammoTransform; +var Trigger = class { + constructor(app2, component, data2) { + this.entity = component.entity; + this.component = component; + this.app = app2; + if (typeof Ammo !== "undefined" && !_ammoVec1) { + _ammoVec1 = new Ammo.btVector3(); + _ammoQuat = new Ammo.btQuaternion(); + _ammoTransform = new Ammo.btTransform(); + } + this.initialize(data2); + } + initialize(data2) { + const entity = this.entity; + const shape2 = data2.shape; + if (shape2 && typeof Ammo !== "undefined") { + if (entity.trigger) { + entity.trigger.destroy(); + } + const mass = 1; + const component = this.component; + if (component) { + const bodyPos = component.getShapePosition(); + const bodyRot = component.getShapeRotation(); + _ammoVec1.setValue(bodyPos.x, bodyPos.y, bodyPos.z); + _ammoQuat.setValue(bodyRot.x, bodyRot.y, bodyRot.z, bodyRot.w); + } else { + const pos = entity.getPosition(); + const rot = entity.getRotation(); + _ammoVec1.setValue(pos.x, pos.y, pos.z); + _ammoQuat.setValue(rot.x, rot.y, rot.z, rot.w); + } + _ammoTransform.setOrigin(_ammoVec1); + _ammoTransform.setRotation(_ammoQuat); + const body = this.app.systems.rigidbody.createBody(mass, shape2, _ammoTransform); + body.setRestitution(0); + body.setFriction(0); + body.setDamping(0, 0); + _ammoVec1.setValue(0, 0, 0); + body.setLinearFactor(_ammoVec1); + body.setAngularFactor(_ammoVec1); + body.setCollisionFlags(body.getCollisionFlags() | BODYFLAG_NORESPONSE_OBJECT); + body.entity = entity; + this.body = body; + if (this.component.enabled && entity.enabled) { + this.enable(); + } + } + } + destroy() { + const body = this.body; + if (!body) return; + this.disable(); + this.app.systems.rigidbody.destroyBody(body); + } + _getEntityTransform(transform) { + const component = this.component; + if (component) { + const bodyPos = component.getShapePosition(); + const bodyRot = component.getShapeRotation(); + _ammoVec1.setValue(bodyPos.x, bodyPos.y, bodyPos.z); + _ammoQuat.setValue(bodyRot.x, bodyRot.y, bodyRot.z, bodyRot.w); + } else { + const pos = this.entity.getPosition(); + const rot = this.entity.getRotation(); + _ammoVec1.setValue(pos.x, pos.y, pos.z); + _ammoQuat.setValue(rot.x, rot.y, rot.z, rot.w); + } + transform.setOrigin(_ammoVec1); + transform.setRotation(_ammoQuat); + } + updateTransform() { + this._getEntityTransform(_ammoTransform); + const body = this.body; + body.setWorldTransform(_ammoTransform); + body.activate(); + } + enable() { + const body = this.body; + if (!body) return; + const systems = this.app.systems; + systems.rigidbody.addBody(body, BODYGROUP_TRIGGER, BODYMASK_NOT_STATIC ^ BODYGROUP_TRIGGER); + systems.rigidbody._triggers.push(this); + body.forceActivationState(BODYSTATE_ACTIVE_TAG); + this.updateTransform(); + } + disable() { + const body = this.body; + if (!body) return; + const systems = this.app.systems; + const idx = systems.rigidbody._triggers.indexOf(this); + if (idx > -1) { + systems.rigidbody._triggers.splice(idx, 1); + } + systems.rigidbody.removeBody(body); + body.forceActivationState(BODYSTATE_DISABLE_SIMULATION); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/components/collision/system.js +var mat4 = new Mat4(); +var p1 = new Vec3(); +var p2 = new Vec3(); +var quat = new Quat2(); +var tempGraphNode = new GraphNode(); +var _schema3 = ["enabled", "type", "halfExtents", "linearOffset", "angularOffset", "radius", "axis", "height", "convexHull", "asset", "renderAsset", "shape", "model", "render", "checkVertexDuplicates"]; +var CollisionSystemImpl = class { + constructor(system) { + this.system = system; + } + beforeInitialize(component, data2) { + data2.shape = null; + data2.model = new Model2(); + data2.model.graph = new GraphNode(); + } + afterInitialize(component, data2) { + this.recreatePhysicalShapes(component); + component.data.initialized = true; + } + reset(component, data2) { + this.beforeInitialize(component, data2); + this.afterInitialize(component, data2); + } + recreatePhysicalShapes(component) { + const entity = component.entity; + const data2 = component.data; + if (typeof Ammo !== "undefined") { + if (entity.trigger) { + entity.trigger.destroy(); + delete entity.trigger; + } + if (data2.shape) { + if (component._compoundParent) { + this.system._removeCompoundChild(component._compoundParent, data2.shape); + if (component._compoundParent.entity.rigidbody) component._compoundParent.entity.rigidbody.activate(); + } + this.destroyShape(data2); + } + data2.shape = this.createPhysicalShape(component.entity, data2); + const firstCompoundChild = !component._compoundParent; + if (data2.type === "compound" && (!component._compoundParent || component === component._compoundParent)) { + component._compoundParent = component; + entity.forEach(this._addEachDescendant, component); + } else if (data2.type !== "compound") { + if (component._compoundParent && component === component._compoundParent) { + entity.forEach(this.system.implementations.compound._updateEachDescendant, component); + } + if (!component.rigidbody) { + component._compoundParent = null; + let parent = entity.parent; + while (parent) { + if (parent.collision && parent.collision.type === "compound") { + component._compoundParent = parent.collision; + break; + } + parent = parent.parent; + } + } + } + if (component._compoundParent) { + if (component !== component._compoundParent) { + if (firstCompoundChild && component._compoundParent.shape.getNumChildShapes() === 0) { + this.system.recreatePhysicalShapes(component._compoundParent); + } else { + this.system.updateCompoundChildTransform(entity); + if (component._compoundParent.entity.rigidbody) component._compoundParent.entity.rigidbody.activate(); + } + } + } + if (entity.rigidbody) { + entity.rigidbody.disableSimulation(); + entity.rigidbody.createBody(); + if (entity.enabled && entity.rigidbody.enabled) { + entity.rigidbody.enableSimulation(); + } + } else if (!component._compoundParent) { + if (!entity.trigger) { + entity.trigger = new Trigger(this.system.app, component, data2); + } else { + entity.trigger.initialize(data2); + } + } + } + } + createPhysicalShape(entity, data2) { + return void 0; + } + updateTransform(component, position2, rotation2, scale2) { + if (component.entity.trigger) { + component.entity.trigger.updateTransform(); + } + } + destroyShape(data2) { + if (data2.shape) { + Ammo.destroy(data2.shape); + data2.shape = null; + } + } + beforeRemove(entity, component) { + if (component.data.shape) { + if (component._compoundParent && !component._compoundParent.entity._destroying) { + this.system._removeCompoundChild(component._compoundParent, component.data.shape); + if (component._compoundParent.entity.rigidbody) component._compoundParent.entity.rigidbody.activate(); + } + component._compoundParent = null; + this.destroyShape(component.data); + } + } + remove(entity, data2) { + if (entity.rigidbody && entity.rigidbody.body) { + entity.rigidbody.disableSimulation(); + } + if (entity.trigger) { + entity.trigger.destroy(); + delete entity.trigger; + } + } + clone(entity, clone) { + const src = this.system.store[entity.getGuid()]; + const data2 = { + enabled: src.data.enabled, + type: src.data.type, + halfExtents: [src.data.halfExtents.x, src.data.halfExtents.y, src.data.halfExtents.z], + linearOffset: [src.data.linearOffset.x, src.data.linearOffset.y, src.data.linearOffset.z], + angularOffset: [src.data.angularOffset.x, src.data.angularOffset.y, src.data.angularOffset.z, src.data.angularOffset.w], + radius: src.data.radius, + axis: src.data.axis, + height: src.data.height, + convexHull: src.data.convexHull, + asset: src.data.asset, + renderAsset: src.data.renderAsset, + model: src.data.model, + render: src.data.render, + checkVertexDuplicates: src.data.checkVertexDuplicates + }; + return this.system.addComponent(clone, data2); + } +}; +var CollisionBoxSystemImpl = class extends CollisionSystemImpl { + createPhysicalShape(entity, data2) { + if (typeof Ammo !== "undefined") { + const he = data2.halfExtents; + const ammoHe = new Ammo.btVector3(he ? he.x : 0.5, he ? he.y : 0.5, he ? he.z : 0.5); + const shape2 = new Ammo.btBoxShape(ammoHe); + Ammo.destroy(ammoHe); + return shape2; + } + return void 0; + } +}; +var CollisionSphereSystemImpl = class extends CollisionSystemImpl { + createPhysicalShape(entity, data2) { + if (typeof Ammo !== "undefined") { + return new Ammo.btSphereShape(data2.radius); + } + return void 0; + } +}; +var CollisionCapsuleSystemImpl = class extends CollisionSystemImpl { + createPhysicalShape(entity, data2) { + var _data$axis, _data$radius, _data$height; + const axis = (_data$axis = data2.axis) != null ? _data$axis : 1; + const radius = (_data$radius = data2.radius) != null ? _data$radius : 0.5; + const height = Math.max(((_data$height = data2.height) != null ? _data$height : 2) - 2 * radius, 0); + let shape2 = null; + if (typeof Ammo !== "undefined") { + switch (axis) { + case 0: + shape2 = new Ammo.btCapsuleShapeX(radius, height); + break; + case 1: + shape2 = new Ammo.btCapsuleShape(radius, height); + break; + case 2: + shape2 = new Ammo.btCapsuleShapeZ(radius, height); + break; + } + } + return shape2; + } +}; +var CollisionCylinderSystemImpl = class extends CollisionSystemImpl { + createPhysicalShape(entity, data2) { + var _data$axis2, _data$radius2, _data$height2; + const axis = (_data$axis2 = data2.axis) != null ? _data$axis2 : 1; + const radius = (_data$radius2 = data2.radius) != null ? _data$radius2 : 0.5; + const height = (_data$height2 = data2.height) != null ? _data$height2 : 1; + let halfExtents = null; + let shape2 = null; + if (typeof Ammo !== "undefined") { + switch (axis) { + case 0: + halfExtents = new Ammo.btVector3(height * 0.5, radius, radius); + shape2 = new Ammo.btCylinderShapeX(halfExtents); + break; + case 1: + halfExtents = new Ammo.btVector3(radius, height * 0.5, radius); + shape2 = new Ammo.btCylinderShape(halfExtents); + break; + case 2: + halfExtents = new Ammo.btVector3(radius, radius, height * 0.5); + shape2 = new Ammo.btCylinderShapeZ(halfExtents); + break; + } + } + if (halfExtents) Ammo.destroy(halfExtents); + return shape2; + } +}; +var CollisionConeSystemImpl = class extends CollisionSystemImpl { + createPhysicalShape(entity, data2) { + var _data$axis3, _data$radius3, _data$height3; + const axis = (_data$axis3 = data2.axis) != null ? _data$axis3 : 1; + const radius = (_data$radius3 = data2.radius) != null ? _data$radius3 : 0.5; + const height = (_data$height3 = data2.height) != null ? _data$height3 : 1; + let shape2 = null; + if (typeof Ammo !== "undefined") { + switch (axis) { + case 0: + shape2 = new Ammo.btConeShapeX(radius, height); + break; + case 1: + shape2 = new Ammo.btConeShape(radius, height); + break; + case 2: + shape2 = new Ammo.btConeShapeZ(radius, height); + break; + } + } + return shape2; + } +}; +var CollisionMeshSystemImpl = class extends CollisionSystemImpl { + beforeInitialize(component, data2) { + } + createAmmoHull(mesh, node, shape2, scale2) { + const hull = new Ammo.btConvexHullShape(); + const point = new Ammo.btVector3(); + const positions = []; + mesh.getPositions(positions); + for (let i = 0; i < positions.length; i += 3) { + point.setValue(positions[i] * scale2.x, positions[i + 1] * scale2.y, positions[i + 2] * scale2.z); + hull.addPoint(point, false); + } + Ammo.destroy(point); + hull.recalcLocalAabb(); + hull.setMargin(0.01); + shape2.addChildShape(this.system._getNodeTransform(node), hull); + } + createAmmoMesh(mesh, node, shape2, scale2, checkDupes = true) { + const system = this.system; + let triMesh; + if (system._triMeshCache[mesh.id]) { + triMesh = system._triMeshCache[mesh.id]; + } else { + const vb = mesh.vertexBuffer; + const format = vb.getFormat(); + let stride, positions; + for (let _i = 0; _i < format.elements.length; _i++) { + const element = format.elements[_i]; + if (element.name === SEMANTIC_POSITION) { + positions = new Float32Array(vb.lock(), element.offset); + stride = element.stride / 4; + break; + } + } + const indices = []; + mesh.getIndices(indices); + const numTriangles = mesh.primitive[0].count / 3; + const v1 = new Ammo.btVector3(); + let i1, i2, i3; + const base = mesh.primitive[0].base; + triMesh = new Ammo.btTriangleMesh(); + system._triMeshCache[mesh.id] = triMesh; + const vertexCache = /* @__PURE__ */ new Map(); + const indexedArray = triMesh.getIndexedMeshArray(); + indexedArray.at(0).m_numTriangles = numTriangles; + const sx = scale2 ? scale2.x : 1; + const sy = scale2 ? scale2.y : 1; + const sz = scale2 ? scale2.z : 1; + const addVertex = (index) => { + const x2 = positions[index * stride] * sx; + const y2 = positions[index * stride + 1] * sy; + const z2 = positions[index * stride + 2] * sz; + let idx; + if (checkDupes) { + const str = `${x2}:${y2}:${z2}`; + idx = vertexCache.get(str); + if (idx !== void 0) { + return idx; + } + v1.setValue(x2, y2, z2); + idx = triMesh.findOrAddVertex(v1, false); + vertexCache.set(str, idx); + } else { + v1.setValue(x2, y2, z2); + idx = triMesh.findOrAddVertex(v1, false); + } + return idx; + }; + for (var i = 0; i < numTriangles; i++) { + i1 = addVertex(indices[base + i * 3]); + i2 = addVertex(indices[base + i * 3 + 1]); + i3 = addVertex(indices[base + i * 3 + 2]); + triMesh.addIndex(i1); + triMesh.addIndex(i2); + triMesh.addIndex(i3); + } + Ammo.destroy(v1); + } + const triMeshShape = new Ammo.btBvhTriangleMeshShape(triMesh, true); + if (!scale2) { + const scaling = system._getNodeScaling(node); + triMeshShape.setLocalScaling(scaling); + Ammo.destroy(scaling); + } + const transform = system._getNodeTransform(node); + shape2.addChildShape(transform, triMeshShape); + Ammo.destroy(transform); + } + createPhysicalShape(entity, data2) { + if (typeof Ammo === "undefined") return void 0; + if (data2.model || data2.render) { + const shape2 = new Ammo.btCompoundShape(); + const entityTransform = entity.getWorldTransform(); + const scale2 = entityTransform.getScale(); + if (data2.model) { + const meshInstances = data2.model.meshInstances; + for (let i = 0; i < meshInstances.length; i++) { + this.createAmmoMesh(meshInstances[i].mesh, meshInstances[i].node, shape2, null, data2.checkVertexDuplicates); + } + const vec2 = new Ammo.btVector3(scale2.x, scale2.y, scale2.z); + shape2.setLocalScaling(vec2); + Ammo.destroy(vec2); + } else if (data2.render) { + const meshes = data2.render.meshes; + for (let i = 0; i < meshes.length; i++) { + if (data2.convexHull) { + this.createAmmoHull(meshes[i], tempGraphNode, shape2, scale2); + } else { + this.createAmmoMesh(meshes[i], tempGraphNode, shape2, scale2, data2.checkVertexDuplicates); + } + } + } + return shape2; + } + return void 0; + } + recreatePhysicalShapes(component) { + const data2 = component.data; + if (data2.renderAsset || data2.asset) { + if (component.enabled && component.entity.enabled) { + this.loadAsset(component, data2.renderAsset || data2.asset, data2.renderAsset ? "render" : "model"); + return; + } + } + this.doRecreatePhysicalShape(component); + } + loadAsset(component, id12, property) { + const data2 = component.data; + const assets = this.system.app.assets; + const previousPropertyValue = data2[property]; + const onAssetFullyReady = (asset3) => { + if (data2[property] !== previousPropertyValue) { + return; + } + data2[property] = asset3.resource; + this.doRecreatePhysicalShape(component); + }; + const loadAndHandleAsset = (asset3) => { + asset3.ready((asset4) => { + if (asset4.data.containerAsset) { + const containerAsset = assets.get(asset4.data.containerAsset); + if (containerAsset.loaded) { + onAssetFullyReady(asset4); + } else { + containerAsset.ready(() => { + onAssetFullyReady(asset4); + }); + assets.load(containerAsset); + } + } else { + onAssetFullyReady(asset4); + } + }); + assets.load(asset3); + }; + const asset2 = assets.get(id12); + if (asset2) { + loadAndHandleAsset(asset2); + } else { + assets.once("add:" + id12, loadAndHandleAsset); + } + } + doRecreatePhysicalShape(component) { + const entity = component.entity; + const data2 = component.data; + if (data2.model || data2.render) { + this.destroyShape(data2); + data2.shape = this.createPhysicalShape(entity, data2); + if (entity.rigidbody) { + entity.rigidbody.disableSimulation(); + entity.rigidbody.createBody(); + if (entity.enabled && entity.rigidbody.enabled) { + entity.rigidbody.enableSimulation(); + } + } else { + if (!entity.trigger) { + entity.trigger = new Trigger(this.system.app, component, data2); + } else { + entity.trigger.initialize(data2); + } + } + } else { + this.beforeRemove(entity, component); + this.remove(entity, data2); + } + } + updateTransform(component, position2, rotation2, scale2) { + if (component.shape) { + const entityTransform = component.entity.getWorldTransform(); + const worldScale = entityTransform.getScale(); + const previousScale = component.shape.getLocalScaling(); + if (worldScale.x !== previousScale.x() || worldScale.y !== previousScale.y() || worldScale.z !== previousScale.z()) { + this.doRecreatePhysicalShape(component); + } + } + super.updateTransform(component, position2, rotation2, scale2); + } + destroyShape(data2) { + if (!data2.shape) return; + const numShapes = data2.shape.getNumChildShapes(); + for (let i = 0; i < numShapes; i++) { + const shape2 = data2.shape.getChildShape(i); + Ammo.destroy(shape2); + } + Ammo.destroy(data2.shape); + data2.shape = null; + } +}; +var CollisionCompoundSystemImpl = class extends CollisionSystemImpl { + createPhysicalShape(entity, data2) { + if (typeof Ammo !== "undefined") { + return new Ammo.btCompoundShape(); + } + return void 0; + } + _addEachDescendant(entity) { + if (!entity.collision || entity.rigidbody) return; + entity.collision._compoundParent = this; + if (entity !== this.entity) { + entity.collision.system.recreatePhysicalShapes(entity.collision); + } + } + _updateEachDescendant(entity) { + if (!entity.collision) return; + if (entity.collision._compoundParent !== this) return; + entity.collision._compoundParent = null; + if (entity !== this.entity && !entity.rigidbody) { + entity.collision.system.recreatePhysicalShapes(entity.collision); + } + } + _updateEachDescendantTransform(entity) { + if (!entity.collision || entity.collision._compoundParent !== this.collision._compoundParent) return; + this.collision.system.updateCompoundChildTransform(entity); + } +}; +var CollisionComponentSystem = class extends ComponentSystem { + constructor(app2) { + super(app2); + this.id = "collision"; + this.ComponentType = CollisionComponent; + this.DataType = CollisionComponentData; + this.schema = _schema3; + this.implementations = {}; + this._triMeshCache = {}; + this.on("beforeremove", this.onBeforeRemove, this); + this.on("remove", this.onRemove, this); + } + initializeComponentData(component, _data, properties2) { + properties2 = ["type", "halfExtents", "radius", "axis", "height", "convexHull", "shape", "model", "asset", "render", "renderAsset", "enabled", "linearOffset", "angularOffset", "checkVertexDuplicates"]; + const data2 = {}; + for (let i = 0, len = properties2.length; i < len; i++) { + const property = properties2[i]; + data2[property] = _data[property]; + } + let idx; + if (_data.hasOwnProperty("asset")) { + idx = properties2.indexOf("model"); + if (idx !== -1) { + properties2.splice(idx, 1); + } + idx = properties2.indexOf("render"); + if (idx !== -1) { + properties2.splice(idx, 1); + } + } else if (_data.hasOwnProperty("model")) { + idx = properties2.indexOf("asset"); + if (idx !== -1) { + properties2.splice(idx, 1); + } + } + if (!data2.type) { + data2.type = component.data.type; + } + component.data.type = data2.type; + if (Array.isArray(data2.halfExtents)) { + data2.halfExtents = new Vec3(data2.halfExtents); + } + if (Array.isArray(data2.linearOffset)) { + data2.linearOffset = new Vec3(data2.linearOffset); + } + if (Array.isArray(data2.angularOffset)) { + const values = data2.angularOffset; + if (values.length === 3) { + data2.angularOffset = new Quat2().setFromEulerAngles(values[0], values[1], values[2]); + } else { + data2.angularOffset = new Quat2(data2.angularOffset); + } + } + const impl = this._createImplementation(data2.type); + impl.beforeInitialize(component, data2); + super.initializeComponentData(component, data2, properties2); + impl.afterInitialize(component, data2); + } + _createImplementation(type2) { + if (this.implementations[type2] === void 0) { + let impl; + switch (type2) { + case "box": + impl = new CollisionBoxSystemImpl(this); + break; + case "sphere": + impl = new CollisionSphereSystemImpl(this); + break; + case "capsule": + impl = new CollisionCapsuleSystemImpl(this); + break; + case "cylinder": + impl = new CollisionCylinderSystemImpl(this); + break; + case "cone": + impl = new CollisionConeSystemImpl(this); + break; + case "mesh": + impl = new CollisionMeshSystemImpl(this); + break; + case "compound": + impl = new CollisionCompoundSystemImpl(this); + break; + } + this.implementations[type2] = impl; + } + return this.implementations[type2]; + } + _getImplementation(entity) { + return this.implementations[entity.collision.data.type]; + } + cloneComponent(entity, clone) { + return this._getImplementation(entity).clone(entity, clone); + } + onBeforeRemove(entity, component) { + this.implementations[component.data.type].beforeRemove(entity, component); + component.onBeforeRemove(); + } + onRemove(entity, data2) { + this.implementations[data2.type].remove(entity, data2); + } + updateCompoundChildTransform(entity) { + this._removeCompoundChild(entity.collision._compoundParent, entity.collision.data.shape); + if (entity.enabled && entity.collision.enabled) { + const transform = this._getNodeTransform(entity, entity.collision._compoundParent.entity); + entity.collision._compoundParent.shape.addChildShape(transform, entity.collision.data.shape); + Ammo.destroy(transform); + } + } + _removeCompoundChild(collision, shape2) { + if (collision.shape.removeChildShape) { + collision.shape.removeChildShape(shape2); + } else { + const ind = collision._getCompoundChildShapeIndex(shape2); + if (ind !== null) { + collision.shape.removeChildShapeByIndex(ind); + } + } + } + onTransformChanged(component, position2, rotation2, scale2) { + this.implementations[component.data.type].updateTransform(component, position2, rotation2, scale2); + } + changeType(component, previousType, newType) { + this.implementations[previousType].beforeRemove(component.entity, component); + this.implementations[previousType].remove(component.entity, component.data); + this._createImplementation(newType).reset(component, component.data); + } + recreatePhysicalShapes(component) { + this.implementations[component.data.type].recreatePhysicalShapes(component); + } + _calculateNodeRelativeTransform(node, relative) { + if (node === relative) { + const scale2 = node.getWorldTransform().getScale(); + mat4.setScale(scale2.x, scale2.y, scale2.z); + } else { + this._calculateNodeRelativeTransform(node.parent, relative); + mat4.mul(node.getLocalTransform()); + } + } + _getNodeScaling(node) { + const wtm = node.getWorldTransform(); + const scl = wtm.getScale(); + return new Ammo.btVector3(scl.x, scl.y, scl.z); + } + _getNodeTransform(node, relative) { + let pos, rot; + if (relative) { + this._calculateNodeRelativeTransform(node, relative); + pos = p1; + rot = quat; + mat4.getTranslation(pos); + rot.setFromMat4(mat4); + } else { + pos = node.getPosition(); + rot = node.getRotation(); + } + const ammoQuat = new Ammo.btQuaternion(); + const transform = new Ammo.btTransform(); + transform.setIdentity(); + const origin = transform.getOrigin(); + const component = node.collision; + if (component && component._hasOffset) { + const lo = component.data.linearOffset; + const ao = component.data.angularOffset; + const newOrigin = p2; + quat.copy(rot).transformVector(lo, newOrigin); + newOrigin.add(pos); + quat.copy(rot).mul(ao); + origin.setValue(newOrigin.x, newOrigin.y, newOrigin.z); + ammoQuat.setValue(quat.x, quat.y, quat.z, quat.w); + } else { + origin.setValue(pos.x, pos.y, pos.z); + ammoQuat.setValue(rot.x, rot.y, rot.z, rot.w); + } + transform.setRotation(ammoQuat); + Ammo.destroy(ammoQuat); + Ammo.destroy(origin); + return transform; + } + destroy() { + for (const key in this._triMeshCache) { + Ammo.destroy(this._triMeshCache[key]); + } + this._triMeshCache = null; + super.destroy(); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/graphics/primitive-cache.js +var shapePrimitives = []; +function getShapePrimitive(device, type2) { + let primData = null; + for (let i = 0; i < shapePrimitives.length; i++) { + if (shapePrimitives[i].type === type2 && shapePrimitives[i].device === device) { + primData = shapePrimitives[i].primData; + } + } + if (!primData) { + let mesh, area; + switch (type2) { + case "box": + mesh = Mesh.fromGeometry(device, new BoxGeometry()); + area = { + x: 2, + y: 2, + z: 2, + uv: 2 / 3 + }; + break; + case "capsule": + mesh = Mesh.fromGeometry(device, new CapsuleGeometry({ + radius: 0.5, + height: 2 + })); + area = { + x: Math.PI * 2, + y: Math.PI, + z: Math.PI * 2, + uv: 1 / 3 + 1 / 3 / 3 * 2 + }; + break; + case "cone": + mesh = Mesh.fromGeometry(device, new ConeGeometry({ + baseRadius: 0.5, + peakRadius: 0, + height: 1 + })); + area = { + x: 2.54, + y: 2.54, + z: 2.54, + uv: 1 / 3 + 1 / 3 / 3 + }; + break; + case "cylinder": + mesh = Mesh.fromGeometry(device, new CylinderGeometry({ + radius: 0.5, + height: 1 + })); + area = { + x: Math.PI, + y: 0.79 * 2, + z: Math.PI, + uv: 1 / 3 + 1 / 3 / 3 * 2 + }; + break; + case "plane": + mesh = Mesh.fromGeometry(device, new PlaneGeometry({ + halfExtents: new Vec2(0.5, 0.5), + widthSegments: 1, + lengthSegments: 1 + })); + area = { + x: 0, + y: 1, + z: 0, + uv: 1 + }; + break; + case "sphere": + mesh = Mesh.fromGeometry(device, new SphereGeometry({ + radius: 0.5 + })); + area = { + x: Math.PI, + y: Math.PI, + z: Math.PI, + uv: 1 + }; + break; + case "torus": + mesh = Mesh.fromGeometry(device, new TorusGeometry({ + tubeRadius: 0.2, + ringRadius: 0.3 + })); + area = { + x: Math.PI * 0.5 * 0.5 - Math.PI * 0.1 * 0.1, + y: 0.4, + z: 0.4, + uv: 1 + }; + break; + default: + throw new Error("Invalid primitive type: " + type2); + } + mesh.incRefCount(); + primData = { + mesh, + area + }; + shapePrimitives.push({ + type: type2, + device, + primData + }); + } + return primData; +} + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/components/model/component.js +var ModelComponent = class extends Component { + constructor(system, entity) { + super(system, entity); + this._type = "asset"; + this._asset = null; + this._model = null; + this._mapping = {}; + this._castShadows = true; + this._receiveShadows = true; + this._materialAsset = null; + this._material = void 0; + this._castShadowsLightmap = true; + this._lightmapped = false; + this._lightmapSizeMultiplier = 1; + this.isStatic = false; + this._layers = [LAYERID_WORLD]; + this._batchGroupId = -1; + this._customAabb = null; + this._area = null; + this._materialEvents = null; + this._clonedModel = false; + this._material = system.defaultMaterial; + entity.on("remove", this.onRemoveChild, this); + entity.on("removehierarchy", this.onRemoveChild, this); + entity.on("insert", this.onInsertChild, this); + entity.on("inserthierarchy", this.onInsertChild, this); + } + set meshInstances(value) { + if (!this._model) return; + this._model.meshInstances = value; + } + get meshInstances() { + if (!this._model) return null; + return this._model.meshInstances; + } + set customAabb(value) { + this._customAabb = value; + if (this._model) { + const mi = this._model.meshInstances; + if (mi) { + for (let i = 0; i < mi.length; i++) { + mi[i].setCustomAabb(this._customAabb); + } + } + } + } + get customAabb() { + return this._customAabb; + } + set type(value) { + if (this._type === value) return; + this._area = null; + this._type = value; + if (value === "asset") { + if (this._asset !== null) { + this._bindModelAsset(this._asset); + } else { + this.model = null; + } + } else { + const primData = getShapePrimitive(this.system.app.graphicsDevice, value); + this._area = primData.area; + const mesh = primData.mesh; + const node = new GraphNode(); + const model = new Model2(); + model.graph = node; + model.meshInstances = [new MeshInstance(mesh, this._material, node)]; + this.model = model; + this._asset = null; + } + } + get type() { + return this._type; + } + set asset(value) { + const assets = this.system.app.assets; + let _id = value; + if (value instanceof Asset) { + _id = value.id; + } + if (this._asset !== _id) { + if (this._asset) { + assets.off("add:" + this._asset, this._onModelAssetAdded, this); + const _prev = assets.get(this._asset); + if (_prev) { + this._unbindModelAsset(_prev); + } + } + this._asset = _id; + if (this._asset) { + const asset2 = assets.get(this._asset); + if (!asset2) { + this.model = null; + assets.on("add:" + this._asset, this._onModelAssetAdded, this); + } else { + this._bindModelAsset(asset2); + } + } else { + this.model = null; + } + } + } + get asset() { + return this._asset; + } + set model(value) { + if (this._model === value) return; + if (value && value._immutable) { + return; + } + if (this._model) { + this._model._immutable = false; + this.removeModelFromLayers(); + this._model.getGraph().destroy(); + delete this._model._entity; + if (this._clonedModel) { + this._model.destroy(); + this._clonedModel = false; + } + } + this._model = value; + if (this._model) { + this._model._immutable = true; + const meshInstances = this._model.meshInstances; + for (let i = 0; i < meshInstances.length; i++) { + meshInstances[i].castShadow = this._castShadows; + meshInstances[i].receiveShadow = this._receiveShadows; + meshInstances[i].setCustomAabb(this._customAabb); + } + this.lightmapped = this._lightmapped; + this.entity.addChild(this._model.graph); + if (this.enabled && this.entity.enabled) { + this.addModelToLayers(); + } + this._model._entity = this.entity; + if (this.entity.animation) this.entity.animation.setModel(this._model); + if (this.entity.anim) { + this.entity.anim.rebind(); + } + if (this.type === "asset") { + this.mapping = this._mapping; + } else { + this._unsetMaterialEvents(); + } + } + } + get model() { + return this._model; + } + set lightmapped(value) { + if (value !== this._lightmapped) { + this._lightmapped = value; + if (this._model) { + const mi = this._model.meshInstances; + for (let i = 0; i < mi.length; i++) { + mi[i].setLightmapped(value); + } + } + } + } + get lightmapped() { + return this._lightmapped; + } + set castShadows(value) { + if (this._castShadows === value) return; + const model = this._model; + if (model) { + const layers = this.layers; + const scene2 = this.system.app.scene; + if (this._castShadows && !value) { + for (let i = 0; i < layers.length; i++) { + const layer = this.system.app.scene.layers.getLayerById(this.layers[i]); + if (!layer) continue; + layer.removeShadowCasters(model.meshInstances); + } + } + const meshInstances = model.meshInstances; + for (let i = 0; i < meshInstances.length; i++) { + meshInstances[i].castShadow = value; + } + if (!this._castShadows && value) { + for (let i = 0; i < layers.length; i++) { + const layer = scene2.layers.getLayerById(layers[i]); + if (!layer) continue; + layer.addShadowCasters(model.meshInstances); + } + } + } + this._castShadows = value; + } + get castShadows() { + return this._castShadows; + } + set receiveShadows(value) { + if (this._receiveShadows === value) return; + this._receiveShadows = value; + if (this._model) { + const meshInstances = this._model.meshInstances; + for (let i = 0, len = meshInstances.length; i < len; i++) { + meshInstances[i].receiveShadow = value; + } + } + } + get receiveShadows() { + return this._receiveShadows; + } + set castShadowsLightmap(value) { + this._castShadowsLightmap = value; + } + get castShadowsLightmap() { + return this._castShadowsLightmap; + } + set lightmapSizeMultiplier(value) { + this._lightmapSizeMultiplier = value; + } + get lightmapSizeMultiplier() { + return this._lightmapSizeMultiplier; + } + set layers(value) { + const layers = this.system.app.scene.layers; + if (this.meshInstances) { + for (let i = 0; i < this._layers.length; i++) { + const layer = layers.getLayerById(this._layers[i]); + if (!layer) continue; + layer.removeMeshInstances(this.meshInstances); + } + } + this._layers.length = 0; + for (let i = 0; i < value.length; i++) { + this._layers[i] = value[i]; + } + if (!this.enabled || !this.entity.enabled || !this.meshInstances) return; + for (let i = 0; i < this._layers.length; i++) { + const layer = layers.getLayerById(this._layers[i]); + if (!layer) continue; + layer.addMeshInstances(this.meshInstances); + } + } + get layers() { + return this._layers; + } + set batchGroupId(value) { + if (this._batchGroupId === value) return; + if (this.entity.enabled && this._batchGroupId >= 0) { + var _this$system$app$batc; + (_this$system$app$batc = this.system.app.batcher) == null || _this$system$app$batc.remove(BatchGroup.MODEL, this.batchGroupId, this.entity); + } + if (this.entity.enabled && value >= 0) { + var _this$system$app$batc2; + (_this$system$app$batc2 = this.system.app.batcher) == null || _this$system$app$batc2.insert(BatchGroup.MODEL, value, this.entity); + } + if (value < 0 && this._batchGroupId >= 0 && this.enabled && this.entity.enabled) { + this.addModelToLayers(); + } + this._batchGroupId = value; + } + get batchGroupId() { + return this._batchGroupId; + } + set materialAsset(value) { + let _id = value; + if (value instanceof Asset) { + _id = value.id; + } + const assets = this.system.app.assets; + if (_id !== this._materialAsset) { + if (this._materialAsset) { + assets.off("add:" + this._materialAsset, this._onMaterialAssetAdd, this); + const _prev = assets.get(this._materialAsset); + if (_prev) { + this._unbindMaterialAsset(_prev); + } + } + this._materialAsset = _id; + if (this._materialAsset) { + const asset2 = assets.get(this._materialAsset); + if (!asset2) { + this._setMaterial(this.system.defaultMaterial); + assets.on("add:" + this._materialAsset, this._onMaterialAssetAdd, this); + } else { + this._bindMaterialAsset(asset2); + } + } else { + this._setMaterial(this.system.defaultMaterial); + } + } + } + get materialAsset() { + return this._materialAsset; + } + set material(value) { + if (this._material === value) return; + this.materialAsset = null; + this._setMaterial(value); + } + get material() { + return this._material; + } + set mapping(value) { + if (this._type !== "asset") return; + this._unsetMaterialEvents(); + if (!value) value = {}; + this._mapping = value; + if (!this._model) return; + const meshInstances = this._model.meshInstances; + const modelAsset = this.asset ? this.system.app.assets.get(this.asset) : null; + const assetMapping = modelAsset ? modelAsset.data.mapping : null; + let asset2 = null; + for (let i = 0, len = meshInstances.length; i < len; i++) { + if (value[i] !== void 0) { + if (value[i]) { + asset2 = this.system.app.assets.get(value[i]); + this._loadAndSetMeshInstanceMaterial(asset2, meshInstances[i], i); + } else { + meshInstances[i].material = this.system.defaultMaterial; + } + } else if (assetMapping) { + if (assetMapping[i] && (assetMapping[i].material || assetMapping[i].path)) { + if (assetMapping[i].material !== void 0) { + asset2 = this.system.app.assets.get(assetMapping[i].material); + } else if (assetMapping[i].path !== void 0) { + const url = this._getMaterialAssetUrl(assetMapping[i].path); + if (url) { + asset2 = this.system.app.assets.getByUrl(url); + } + } + this._loadAndSetMeshInstanceMaterial(asset2, meshInstances[i], i); + } else { + meshInstances[i].material = this.system.defaultMaterial; + } + } + } + } + get mapping() { + return this._mapping; + } + addModelToLayers() { + const layers = this.system.app.scene.layers; + for (let i = 0; i < this._layers.length; i++) { + const layer = layers.getLayerById(this._layers[i]); + if (layer) { + layer.addMeshInstances(this.meshInstances); + } + } + } + removeModelFromLayers() { + const layers = this.system.app.scene.layers; + for (let i = 0; i < this._layers.length; i++) { + const layer = layers.getLayerById(this._layers[i]); + if (!layer) continue; + layer.removeMeshInstances(this.meshInstances); + } + } + onRemoveChild() { + if (this._model) this.removeModelFromLayers(); + } + onInsertChild() { + if (this._model && this.enabled && this.entity.enabled) this.addModelToLayers(); + } + onRemove() { + this.asset = null; + this.model = null; + this.materialAsset = null; + this._unsetMaterialEvents(); + this.entity.off("remove", this.onRemoveChild, this); + this.entity.off("insert", this.onInsertChild, this); + } + onLayersChanged(oldComp, newComp) { + this.addModelToLayers(); + oldComp.off("add", this.onLayerAdded, this); + oldComp.off("remove", this.onLayerRemoved, this); + newComp.on("add", this.onLayerAdded, this); + newComp.on("remove", this.onLayerRemoved, this); + } + onLayerAdded(layer) { + const index = this.layers.indexOf(layer.id); + if (index < 0) return; + layer.addMeshInstances(this.meshInstances); + } + onLayerRemoved(layer) { + const index = this.layers.indexOf(layer.id); + if (index < 0) return; + layer.removeMeshInstances(this.meshInstances); + } + _setMaterialEvent(index, event, id12, handler) { + const evt = event + ":" + id12; + this.system.app.assets.on(evt, handler, this); + if (!this._materialEvents) this._materialEvents = []; + if (!this._materialEvents[index]) this._materialEvents[index] = {}; + this._materialEvents[index][evt] = { + id: id12, + handler + }; + } + _unsetMaterialEvents() { + const assets = this.system.app.assets; + const events2 = this._materialEvents; + if (!events2) return; + for (let i = 0, len = events2.length; i < len; i++) { + if (!events2[i]) continue; + const evt = events2[i]; + for (const key in evt) { + assets.off(key, evt[key].handler, this); + } + } + this._materialEvents = null; + } + _getAssetByIdOrPath(idOrPath) { + let asset2 = null; + const isPath = isNaN(parseInt(idOrPath, 10)); + if (!isPath) { + asset2 = this.system.app.assets.get(idOrPath); + } else if (this.asset) { + const url = this._getMaterialAssetUrl(idOrPath); + if (url) asset2 = this.system.app.assets.getByUrl(url); + } + return asset2; + } + _getMaterialAssetUrl(path2) { + if (!this.asset) return null; + const modelAsset = this.system.app.assets.get(this.asset); + return modelAsset ? modelAsset.getAbsoluteUrl(path2) : null; + } + _loadAndSetMeshInstanceMaterial(materialAsset, meshInstance, index) { + const assets = this.system.app.assets; + if (!materialAsset) return; + if (materialAsset.resource) { + meshInstance.material = materialAsset.resource; + this._setMaterialEvent(index, "remove", materialAsset.id, function() { + meshInstance.material = this.system.defaultMaterial; + }); + } else { + this._setMaterialEvent(index, "load", materialAsset.id, function(asset2) { + meshInstance.material = asset2.resource; + this._setMaterialEvent(index, "remove", materialAsset.id, function() { + meshInstance.material = this.system.defaultMaterial; + }); + }); + if (this.enabled && this.entity.enabled) assets.load(materialAsset); + } + } + onEnable() { + const app2 = this.system.app; + const scene2 = app2.scene; + scene2.on("set:layers", this.onLayersChanged, this); + if (scene2.layers) { + scene2.layers.on("add", this.onLayerAdded, this); + scene2.layers.on("remove", this.onLayerRemoved, this); + } + const isAsset = this._type === "asset"; + let asset2; + if (this._model) { + this.addModelToLayers(); + } else if (isAsset && this._asset) { + asset2 = app2.assets.get(this._asset); + if (asset2 && asset2.resource !== this._model) { + this._bindModelAsset(asset2); + } + } + if (this._materialAsset) { + asset2 = app2.assets.get(this._materialAsset); + if (asset2 && asset2.resource !== this._material) { + this._bindMaterialAsset(asset2); + } + } + if (isAsset) { + if (this._mapping) { + for (const index in this._mapping) { + if (this._mapping[index]) { + asset2 = this._getAssetByIdOrPath(this._mapping[index]); + if (asset2 && !asset2.resource) { + app2.assets.load(asset2); + } + } + } + } + } + if (this._batchGroupId >= 0) { + var _app$batcher; + (_app$batcher = app2.batcher) == null || _app$batcher.insert(BatchGroup.MODEL, this.batchGroupId, this.entity); + } + } + onDisable() { + const app2 = this.system.app; + const scene2 = app2.scene; + scene2.off("set:layers", this.onLayersChanged, this); + if (scene2.layers) { + scene2.layers.off("add", this.onLayerAdded, this); + scene2.layers.off("remove", this.onLayerRemoved, this); + } + if (this._batchGroupId >= 0) { + var _app$batcher2; + (_app$batcher2 = app2.batcher) == null || _app$batcher2.remove(BatchGroup.MODEL, this.batchGroupId, this.entity); + } + if (this._model) { + this.removeModelFromLayers(); + } + } + hide() { + if (this._model) { + const instances = this._model.meshInstances; + for (let i = 0, l = instances.length; i < l; i++) { + instances[i].visible = false; + } + } + } + show() { + if (this._model) { + const instances = this._model.meshInstances; + for (let i = 0, l = instances.length; i < l; i++) { + instances[i].visible = true; + } + } + } + _bindMaterialAsset(asset2) { + asset2.on("load", this._onMaterialAssetLoad, this); + asset2.on("unload", this._onMaterialAssetUnload, this); + asset2.on("remove", this._onMaterialAssetRemove, this); + asset2.on("change", this._onMaterialAssetChange, this); + if (asset2.resource) { + this._onMaterialAssetLoad(asset2); + } else { + if (!this.enabled || !this.entity.enabled) return; + this.system.app.assets.load(asset2); + } + } + _unbindMaterialAsset(asset2) { + asset2.off("load", this._onMaterialAssetLoad, this); + asset2.off("unload", this._onMaterialAssetUnload, this); + asset2.off("remove", this._onMaterialAssetRemove, this); + asset2.off("change", this._onMaterialAssetChange, this); + } + _onMaterialAssetAdd(asset2) { + this.system.app.assets.off("add:" + asset2.id, this._onMaterialAssetAdd, this); + if (this._materialAsset === asset2.id) { + this._bindMaterialAsset(asset2); + } + } + _onMaterialAssetLoad(asset2) { + this._setMaterial(asset2.resource); + } + _onMaterialAssetUnload(asset2) { + this._setMaterial(this.system.defaultMaterial); + } + _onMaterialAssetRemove(asset2) { + this._onMaterialAssetUnload(asset2); + } + _onMaterialAssetChange(asset2) { + } + _bindModelAsset(asset2) { + this._unbindModelAsset(asset2); + asset2.on("load", this._onModelAssetLoad, this); + asset2.on("unload", this._onModelAssetUnload, this); + asset2.on("change", this._onModelAssetChange, this); + asset2.on("remove", this._onModelAssetRemove, this); + if (asset2.resource) { + this._onModelAssetLoad(asset2); + } else { + if (!this.enabled || !this.entity.enabled) return; + this.system.app.assets.load(asset2); + } + } + _unbindModelAsset(asset2) { + asset2.off("load", this._onModelAssetLoad, this); + asset2.off("unload", this._onModelAssetUnload, this); + asset2.off("change", this._onModelAssetChange, this); + asset2.off("remove", this._onModelAssetRemove, this); + } + _onModelAssetAdded(asset2) { + this.system.app.assets.off("add:" + asset2.id, this._onModelAssetAdded, this); + if (asset2.id === this._asset) { + this._bindModelAsset(asset2); + } + } + _onModelAssetLoad(asset2) { + this.model = asset2.resource.clone(); + this._clonedModel = true; + } + _onModelAssetUnload(asset2) { + this.model = null; + } + _onModelAssetChange(asset2, attr, _new, _old) { + if (attr === "data") { + this.mapping = this._mapping; + } + } + _onModelAssetRemove(asset2) { + this.model = null; + } + _setMaterial(material) { + if (this._material === material) return; + this._material = material; + const model = this._model; + if (model && this._type !== "asset") { + const meshInstances = model.meshInstances; + for (let i = 0, len = meshInstances.length; i < len; i++) { + meshInstances[i].material = material; + } + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/components/model/data.js +var ModelComponentData = class { + constructor() { + this.enabled = true; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/components/model/system.js +var _schema4 = ["enabled"]; +var ModelComponentSystem = class extends ComponentSystem { + constructor(app2) { + super(app2); + this.id = "model"; + this.ComponentType = ModelComponent; + this.DataType = ModelComponentData; + this.schema = _schema4; + this.defaultMaterial = getDefaultMaterial(app2.graphicsDevice); + this.on("beforeremove", this.onRemove, this); + } + initializeComponentData(component, _data, properties2) { + properties2 = ["material", "materialAsset", "asset", "castShadows", "receiveShadows", "castShadowsLightmap", "lightmapped", "lightmapSizeMultiplier", "type", "mapping", "layers", "isStatic", "batchGroupId"]; + if (_data.batchGroupId === null || _data.batchGroupId === void 0) { + _data.batchGroupId = -1; + } + if (_data.layers && _data.layers.length) { + _data.layers = _data.layers.slice(0); + } + for (let i = 0; i < properties2.length; i++) { + if (_data.hasOwnProperty(properties2[i])) { + component[properties2[i]] = _data[properties2[i]]; + } + } + if (_data.aabbCenter && _data.aabbHalfExtents) { + component.customAabb = new BoundingBox(new Vec3(_data.aabbCenter), new Vec3(_data.aabbHalfExtents)); + } + super.initializeComponentData(component, _data, ["enabled"]); + } + cloneComponent(entity, clone) { + const data2 = { + type: entity.model.type, + asset: entity.model.asset, + castShadows: entity.model.castShadows, + receiveShadows: entity.model.receiveShadows, + castShadowsLightmap: entity.model.castShadowsLightmap, + lightmapped: entity.model.lightmapped, + lightmapSizeMultiplier: entity.model.lightmapSizeMultiplier, + isStatic: entity.model.isStatic, + enabled: entity.model.enabled, + layers: entity.model.layers, + batchGroupId: entity.model.batchGroupId, + mapping: extend({}, entity.model.mapping) + }; + let materialAsset = entity.model.materialAsset; + if (!(materialAsset instanceof Asset) && materialAsset != null) { + materialAsset = this.app.assets.get(materialAsset); + } + const material = entity.model.material; + if (!material || material === this.defaultMaterial || !materialAsset || material === materialAsset.resource) { + data2.materialAsset = materialAsset; + } + const component = this.addComponent(clone, data2); + if (entity.model.model && entity.model.type === "asset" && !entity.model.asset) { + component.model = entity.model.model.clone(); + component._clonedModel = true; + } + if (!data2.materialAsset) component.material = material; + if (entity.model.model) { + const meshInstances = entity.model.model.meshInstances; + const meshInstancesClone = component.model.meshInstances; + for (let i = 0; i < meshInstances.length; i++) { + meshInstancesClone[i].mask = meshInstances[i].mask; + meshInstancesClone[i].material = meshInstances[i].material; + meshInstancesClone[i].layer = meshInstances[i].layer; + meshInstancesClone[i].receiveShadow = meshInstances[i].receiveShadow; + } + } + if (entity.model.customAabb) { + component.customAabb = entity.model.customAabb.clone(); + } + return component; + } + onRemove(entity, component) { + component.onRemove(); + } +}; +Component._buildAccessors(ModelComponent.prototype, _schema4); + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/skin-instance-cache.js +var SkinInstanceCachedObject = class extends RefCountedObject { + constructor(skin, skinInstance) { + super(); + this.skin = skin; + this.skinInstance = skinInstance; + } +}; +var SkinInstanceCache = class _SkinInstanceCache { + static createCachedSkinInstance(skin, rootBone, entity) { + let skinInst = _SkinInstanceCache.getCachedSkinInstance(skin, rootBone); + if (!skinInst) { + skinInst = new SkinInstance(skin); + skinInst.resolve(rootBone, entity); + _SkinInstanceCache.addCachedSkinInstance(skin, rootBone, skinInst); + } + return skinInst; + } + static getCachedSkinInstance(skin, rootBone) { + let skinInstance = null; + const cachedObjArray = _SkinInstanceCache._skinInstanceCache.get(rootBone); + if (cachedObjArray) { + const cachedObj = cachedObjArray.find((element) => element.skin === skin); + if (cachedObj) { + cachedObj.incRefCount(); + skinInstance = cachedObj.skinInstance; + } + } + return skinInstance; + } + static addCachedSkinInstance(skin, rootBone, skinInstance) { + let cachedObjArray = _SkinInstanceCache._skinInstanceCache.get(rootBone); + if (!cachedObjArray) { + cachedObjArray = []; + _SkinInstanceCache._skinInstanceCache.set(rootBone, cachedObjArray); + } + let cachedObj = cachedObjArray.find((element) => element.skin === skin); + if (!cachedObj) { + cachedObj = new SkinInstanceCachedObject(skin, skinInstance); + cachedObjArray.push(cachedObj); + } + cachedObj.incRefCount(); + } + static removeCachedSkinInstance(skinInstance) { + if (skinInstance) { + const rootBone = skinInstance.rootBone; + if (rootBone) { + const cachedObjArray = _SkinInstanceCache._skinInstanceCache.get(rootBone); + if (cachedObjArray) { + const cachedObjIndex = cachedObjArray.findIndex((element) => element.skinInstance === skinInstance); + if (cachedObjIndex >= 0) { + const cachedObj = cachedObjArray[cachedObjIndex]; + cachedObj.decRefCount(); + if (cachedObj.refCount === 0) { + cachedObjArray.splice(cachedObjIndex, 1); + if (!cachedObjArray.length) { + _SkinInstanceCache._skinInstanceCache.delete(rootBone); + } + if (skinInstance) { + skinInstance.destroy(); + cachedObj.skinInstance = null; + } + } + } + } + } + } + } +}; +SkinInstanceCache._skinInstanceCache = /* @__PURE__ */ new Map(); + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/asset/asset-reference.js +var AssetReference = class { + constructor(propertyName, parent, registry, callbacks, scope) { + this.propertyName = propertyName; + this.parent = parent; + this._scope = scope; + this._registry = registry; + this.id = null; + this.url = null; + this.asset = null; + this._onAssetLoad = callbacks.load; + this._onAssetAdd = callbacks.add; + this._onAssetRemove = callbacks.remove; + this._onAssetUnload = callbacks.unload; + } + set id(value) { + if (this.url) throw Error("Can't set id and url"); + this._unbind(); + this._id = value; + this.asset = this._registry.get(this._id); + this._bind(); + } + get id() { + return this._id; + } + set url(value) { + if (this.id) throw Error("Can't set id and url"); + this._unbind(); + this._url = value; + this.asset = this._registry.getByUrl(this._url); + this._bind(); + } + get url() { + return this._url; + } + _bind() { + if (this.id) { + if (this._onAssetLoad) this._registry.on("load:" + this.id, this._onLoad, this); + if (this._onAssetAdd) this._registry.once("add:" + this.id, this._onAdd, this); + if (this._onAssetRemove) this._registry.on("remove:" + this.id, this._onRemove, this); + if (this._onAssetUnload) this._registry.on("unload:" + this.id, this._onUnload, this); + } + if (this.url) { + if (this._onAssetLoad) this._registry.on("load:url:" + this.url, this._onLoad, this); + if (this._onAssetAdd) this._registry.once("add:url:" + this.url, this._onAdd, this); + if (this._onAssetRemove) this._registry.on("remove:url:" + this.url, this._onRemove, this); + } + } + _unbind() { + if (this.id) { + if (this._onAssetLoad) this._registry.off("load:" + this.id, this._onLoad, this); + if (this._onAssetAdd) this._registry.off("add:" + this.id, this._onAdd, this); + if (this._onAssetRemove) this._registry.off("remove:" + this.id, this._onRemove, this); + if (this._onAssetUnload) this._registry.off("unload:" + this.id, this._onUnload, this); + } + if (this.url) { + if (this._onAssetLoad) this._registry.off("load:" + this.url, this._onLoad, this); + if (this._onAssetAdd) this._registry.off("add:" + this.url, this._onAdd, this); + if (this._onAssetRemove) this._registry.off("remove:" + this.url, this._onRemove, this); + } + } + _onLoad(asset2) { + this._onAssetLoad.call(this._scope, this.propertyName, this.parent, asset2); + } + _onAdd(asset2) { + this.asset = asset2; + this._onAssetAdd.call(this._scope, this.propertyName, this.parent, asset2); + } + _onRemove(asset2) { + this._onAssetRemove.call(this._scope, this.propertyName, this.parent, asset2); + this.asset = null; + } + _onUnload(asset2) { + this._onAssetUnload.call(this._scope, this.propertyName, this.parent, asset2); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/components/render/component.js +var RenderComponent = class extends Component { + constructor(system, entity) { + super(system, entity); + this._type = "asset"; + this._castShadows = true; + this._receiveShadows = true; + this._castShadowsLightmap = true; + this._lightmapped = false; + this._lightmapSizeMultiplier = 1; + this.isStatic = false; + this._batchGroupId = -1; + this._layers = [LAYERID_WORLD]; + this._renderStyle = RENDERSTYLE_SOLID; + this._meshInstances = []; + this._customAabb = null; + this._area = null; + this._assetReference = void 0; + this._materialReferences = []; + this._material = void 0; + this._rootBone = void 0; + this._rootBone = new EntityReference(this, "rootBone"); + this._rootBone.on("set:entity", this._onSetRootBone, this); + this._assetReference = new AssetReference("asset", this, system.app.assets, { + add: this._onRenderAssetAdded, + load: this._onRenderAssetLoad, + remove: this._onRenderAssetRemove, + unload: this._onRenderAssetUnload + }, this); + this._material = system.defaultMaterial; + entity.on("remove", this.onRemoveChild, this); + entity.on("removehierarchy", this.onRemoveChild, this); + entity.on("insert", this.onInsertChild, this); + entity.on("inserthierarchy", this.onInsertChild, this); + } + set renderStyle(renderStyle) { + if (this._renderStyle !== renderStyle) { + this._renderStyle = renderStyle; + MeshInstance._prepareRenderStyleForArray(this._meshInstances, renderStyle); + } + } + get renderStyle() { + return this._renderStyle; + } + set customAabb(value) { + this._customAabb = value; + const mi = this._meshInstances; + if (mi) { + for (let i = 0; i < mi.length; i++) { + mi[i].setCustomAabb(this._customAabb); + } + } + } + get customAabb() { + return this._customAabb; + } + set type(value) { + if (this._type !== value) { + this._area = null; + this._type = value; + this.destroyMeshInstances(); + if (value !== "asset") { + let material = this._material; + if (!material || material === this.system.defaultMaterial) { + material = this._materialReferences[0] && this._materialReferences[0].asset && this._materialReferences[0].asset.resource; + } + const primData = getShapePrimitive(this.system.app.graphicsDevice, value); + this._area = primData.area; + this.meshInstances = [new MeshInstance(primData.mesh, material || this.system.defaultMaterial, this.entity)]; + } + } + } + get type() { + return this._type; + } + set meshInstances(value) { + this.destroyMeshInstances(); + this._meshInstances = value; + if (this._meshInstances) { + const mi = this._meshInstances; + for (let i = 0; i < mi.length; i++) { + if (!mi[i].node) { + mi[i].node = this.entity; + } + mi[i].castShadow = this._castShadows; + mi[i].receiveShadow = this._receiveShadows; + mi[i].renderStyle = this._renderStyle; + mi[i].setLightmapped(this._lightmapped); + mi[i].setCustomAabb(this._customAabb); + } + if (this.enabled && this.entity.enabled) { + this.addToLayers(); + } + } + } + get meshInstances() { + return this._meshInstances; + } + set lightmapped(value) { + if (value !== this._lightmapped) { + this._lightmapped = value; + const mi = this._meshInstances; + if (mi) { + for (let i = 0; i < mi.length; i++) { + mi[i].setLightmapped(value); + } + } + } + } + get lightmapped() { + return this._lightmapped; + } + set castShadows(value) { + if (this._castShadows !== value) { + const mi = this._meshInstances; + if (mi) { + const layers = this.layers; + const scene2 = this.system.app.scene; + if (this._castShadows && !value) { + for (let i = 0; i < layers.length; i++) { + const layer = scene2.layers.getLayerById(this.layers[i]); + if (layer) { + layer.removeShadowCasters(mi); + } + } + } + for (let i = 0; i < mi.length; i++) { + mi[i].castShadow = value; + } + if (!this._castShadows && value) { + for (let i = 0; i < layers.length; i++) { + const layer = scene2.layers.getLayerById(layers[i]); + if (layer) { + layer.addShadowCasters(mi); + } + } + } + } + this._castShadows = value; + } + } + get castShadows() { + return this._castShadows; + } + set receiveShadows(value) { + if (this._receiveShadows !== value) { + this._receiveShadows = value; + const mi = this._meshInstances; + if (mi) { + for (let i = 0; i < mi.length; i++) { + mi[i].receiveShadow = value; + } + } + } + } + get receiveShadows() { + return this._receiveShadows; + } + set castShadowsLightmap(value) { + this._castShadowsLightmap = value; + } + get castShadowsLightmap() { + return this._castShadowsLightmap; + } + set lightmapSizeMultiplier(value) { + this._lightmapSizeMultiplier = value; + } + get lightmapSizeMultiplier() { + return this._lightmapSizeMultiplier; + } + set layers(value) { + const layers = this.system.app.scene.layers; + let layer; + if (this._meshInstances) { + for (let i = 0; i < this._layers.length; i++) { + layer = layers.getLayerById(this._layers[i]); + if (layer) { + layer.removeMeshInstances(this._meshInstances); + } + } + } + this._layers.length = 0; + for (let i = 0; i < value.length; i++) { + this._layers[i] = value[i]; + } + if (!this.enabled || !this.entity.enabled || !this._meshInstances) return; + for (let i = 0; i < this._layers.length; i++) { + layer = layers.getLayerById(this._layers[i]); + if (layer) { + layer.addMeshInstances(this._meshInstances); + } + } + } + get layers() { + return this._layers; + } + set batchGroupId(value) { + if (this._batchGroupId !== value) { + if (this.entity.enabled && this._batchGroupId >= 0) { + var _this$system$app$batc; + (_this$system$app$batc = this.system.app.batcher) == null || _this$system$app$batc.remove(BatchGroup.RENDER, this.batchGroupId, this.entity); + } + if (this.entity.enabled && value >= 0) { + var _this$system$app$batc2; + (_this$system$app$batc2 = this.system.app.batcher) == null || _this$system$app$batc2.insert(BatchGroup.RENDER, value, this.entity); + } + if (value < 0 && this._batchGroupId >= 0 && this.enabled && this.entity.enabled) { + this.addToLayers(); + } + this._batchGroupId = value; + } + } + get batchGroupId() { + return this._batchGroupId; + } + set material(value) { + if (this._material !== value) { + this._material = value; + if (this._meshInstances && this._type !== "asset") { + for (let i = 0; i < this._meshInstances.length; i++) { + this._meshInstances[i].material = value; + } + } + } + } + get material() { + return this._material; + } + set materialAssets(value = []) { + if (this._materialReferences.length > value.length) { + for (let i = value.length; i < this._materialReferences.length; i++) { + this._materialReferences[i].id = null; + } + this._materialReferences.length = value.length; + } + for (let i = 0; i < value.length; i++) { + if (!this._materialReferences[i]) { + this._materialReferences.push(new AssetReference(i, this, this.system.app.assets, { + add: this._onMaterialAdded, + load: this._onMaterialLoad, + remove: this._onMaterialRemove, + unload: this._onMaterialUnload + }, this)); + } + if (value[i]) { + const id12 = value[i] instanceof Asset ? value[i].id : value[i]; + if (this._materialReferences[i].id !== id12) { + this._materialReferences[i].id = id12; + } + if (this._materialReferences[i].asset) { + this._onMaterialAdded(i, this, this._materialReferences[i].asset); + } + } else { + this._materialReferences[i].id = null; + if (this._meshInstances[i]) { + this._meshInstances[i].material = this.system.defaultMaterial; + } + } + } + } + get materialAssets() { + return this._materialReferences.map(function(ref) { + return ref.id; + }); + } + set asset(value) { + const id12 = value instanceof Asset ? value.id : value; + if (this._assetReference.id === id12) return; + if (this._assetReference.asset && this._assetReference.asset.resource) { + this._onRenderAssetRemove(); + } + this._assetReference.id = id12; + if (this._assetReference.asset) { + this._onRenderAssetAdded(); + } + } + get asset() { + return this._assetReference.id; + } + assignAsset(asset2) { + const id12 = asset2 instanceof Asset ? asset2.id : asset2; + this._assetReference.id = id12; + } + _onSetRootBone(entity) { + if (entity) { + this._onRootBoneChanged(); + } + } + _onRootBoneChanged() { + this._clearSkinInstances(); + if (this.enabled && this.entity.enabled) { + this._cloneSkinInstances(); + } + } + destroyMeshInstances() { + const meshInstances = this._meshInstances; + if (meshInstances) { + this.removeFromLayers(); + this._clearSkinInstances(); + for (let i = 0; i < meshInstances.length; i++) { + meshInstances[i].destroy(); + } + this._meshInstances.length = 0; + } + } + addToLayers() { + const layers = this.system.app.scene.layers; + for (let i = 0; i < this._layers.length; i++) { + const layer = layers.getLayerById(this._layers[i]); + if (layer) { + layer.addMeshInstances(this._meshInstances); + } + } + } + removeFromLayers() { + if (this._meshInstances && this._meshInstances.length) { + const layers = this.system.app.scene.layers; + for (let i = 0; i < this._layers.length; i++) { + const layer = layers.getLayerById(this._layers[i]); + if (layer) { + layer.removeMeshInstances(this._meshInstances); + } + } + } + } + onRemoveChild() { + this.removeFromLayers(); + } + onInsertChild() { + if (this._meshInstances && this.enabled && this.entity.enabled) { + this.addToLayers(); + } + } + onRemove() { + this.destroyMeshInstances(); + this.asset = null; + this.materialAsset = null; + this._assetReference.id = null; + for (let i = 0; i < this._materialReferences.length; i++) { + this._materialReferences[i].id = null; + } + this.entity.off("remove", this.onRemoveChild, this); + this.entity.off("insert", this.onInsertChild, this); + } + onLayersChanged(oldComp, newComp) { + this.addToLayers(); + oldComp.off("add", this.onLayerAdded, this); + oldComp.off("remove", this.onLayerRemoved, this); + newComp.on("add", this.onLayerAdded, this); + newComp.on("remove", this.onLayerRemoved, this); + } + onLayerAdded(layer) { + const index = this.layers.indexOf(layer.id); + if (index < 0) return; + layer.addMeshInstances(this._meshInstances); + } + onLayerRemoved(layer) { + const index = this.layers.indexOf(layer.id); + if (index < 0) return; + layer.removeMeshInstances(this._meshInstances); + } + onEnable() { + const app2 = this.system.app; + const scene2 = app2.scene; + this._rootBone.onParentComponentEnable(); + this._cloneSkinInstances(); + scene2.on("set:layers", this.onLayersChanged, this); + if (scene2.layers) { + scene2.layers.on("add", this.onLayerAdded, this); + scene2.layers.on("remove", this.onLayerRemoved, this); + } + const isAsset = this._type === "asset"; + if (this._meshInstances && this._meshInstances.length) { + this.addToLayers(); + } else if (isAsset && this.asset) { + this._onRenderAssetAdded(); + } + for (let i = 0; i < this._materialReferences.length; i++) { + if (this._materialReferences[i].asset) { + this.system.app.assets.load(this._materialReferences[i].asset); + } + } + if (this._batchGroupId >= 0) { + var _app$batcher; + (_app$batcher = app2.batcher) == null || _app$batcher.insert(BatchGroup.RENDER, this.batchGroupId, this.entity); + } + } + onDisable() { + const app2 = this.system.app; + const scene2 = app2.scene; + scene2.off("set:layers", this.onLayersChanged, this); + if (scene2.layers) { + scene2.layers.off("add", this.onLayerAdded, this); + scene2.layers.off("remove", this.onLayerRemoved, this); + } + if (this._batchGroupId >= 0) { + var _app$batcher2; + (_app$batcher2 = app2.batcher) == null || _app$batcher2.remove(BatchGroup.RENDER, this.batchGroupId, this.entity); + } + this.removeFromLayers(); + } + hide() { + if (this._meshInstances) { + for (let i = 0; i < this._meshInstances.length; i++) { + this._meshInstances[i].visible = false; + } + } + } + show() { + if (this._meshInstances) { + for (let i = 0; i < this._meshInstances.length; i++) { + this._meshInstances[i].visible = true; + } + } + } + _onRenderAssetAdded() { + if (!this._assetReference.asset) return; + if (this._assetReference.asset.resource) { + this._onRenderAssetLoad(); + } else if (this.enabled && this.entity.enabled) { + this.system.app.assets.load(this._assetReference.asset); + } + } + _onRenderAssetLoad() { + this.destroyMeshInstances(); + if (this._assetReference.asset) { + const render = this._assetReference.asset.resource; + render.off("set:meshes", this._onSetMeshes, this); + render.on("set:meshes", this._onSetMeshes, this); + if (render.meshes) { + this._onSetMeshes(render.meshes); + } + } + } + _onSetMeshes(meshes) { + this._cloneMeshes(meshes); + } + _clearSkinInstances() { + for (let i = 0; i < this._meshInstances.length; i++) { + const meshInstance = this._meshInstances[i]; + SkinInstanceCache.removeCachedSkinInstance(meshInstance.skinInstance); + meshInstance.skinInstance = null; + } + } + _cloneSkinInstances() { + if (this._meshInstances.length && this._rootBone.entity instanceof GraphNode) { + for (let i = 0; i < this._meshInstances.length; i++) { + const meshInstance = this._meshInstances[i]; + const mesh = meshInstance.mesh; + if (mesh.skin && !meshInstance.skinInstance) { + meshInstance.skinInstance = SkinInstanceCache.createCachedSkinInstance(mesh.skin, this._rootBone.entity, this.entity); + } + } + } + } + _cloneMeshes(meshes) { + if (meshes && meshes.length) { + const meshInstances = []; + for (let i = 0; i < meshes.length; i++) { + const mesh = meshes[i]; + const material = this._materialReferences[i] && this._materialReferences[i].asset && this._materialReferences[i].asset.resource; + const meshInst = new MeshInstance(mesh, material || this.system.defaultMaterial, this.entity); + meshInstances.push(meshInst); + if (mesh.morph) { + meshInst.morphInstance = new MorphInstance(mesh.morph); + } + } + this.meshInstances = meshInstances; + this._cloneSkinInstances(); + } + } + _onRenderAssetUnload() { + if (this._type === "asset") { + this.destroyMeshInstances(); + } + } + _onRenderAssetRemove() { + if (this._assetReference.asset && this._assetReference.asset.resource) { + this._assetReference.asset.resource.off("set:meshes", this._onSetMeshes, this); + } + this._onRenderAssetUnload(); + } + _onMaterialAdded(index, component, asset2) { + if (asset2.resource) { + this._onMaterialLoad(index, component, asset2); + } else { + if (this.enabled && this.entity.enabled) { + this.system.app.assets.load(asset2); + } + } + } + _updateMainMaterial(index, material) { + if (index === 0) { + this.material = material; + } + } + _onMaterialLoad(index, component, asset2) { + if (this._meshInstances[index]) { + this._meshInstances[index].material = asset2.resource; + } + this._updateMainMaterial(index, asset2.resource); + } + _onMaterialRemove(index, component, asset2) { + if (this._meshInstances[index]) { + this._meshInstances[index].material = this.system.defaultMaterial; + } + this._updateMainMaterial(index, this.system.defaultMaterial); + } + _onMaterialUnload(index, component, asset2) { + if (this._meshInstances[index]) { + this._meshInstances[index].material = this.system.defaultMaterial; + } + this._updateMainMaterial(index, this.system.defaultMaterial); + } + resolveDuplicatedEntityReferenceProperties(oldRender, duplicatedIdsMap) { + if (oldRender.rootBone && duplicatedIdsMap[oldRender.rootBone]) { + this.rootBone = duplicatedIdsMap[oldRender.rootBone]; + } + this._clearSkinInstances(); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/components/render/data.js +var RenderComponentData = class { + constructor() { + this.enabled = true; + this.rootBone = null; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/components/render/system.js +var _schema5 = [{ + name: "rootBone", + type: "entity" +}, "enabled"]; +var _properties = ["material", "meshInstances", "asset", "materialAssets", "castShadows", "receiveShadows", "castShadowsLightmap", "lightmapped", "lightmapSizeMultiplier", "renderStyle", "type", "layers", "isStatic", "batchGroupId"]; +var RenderComponentSystem = class extends ComponentSystem { + constructor(app2) { + super(app2); + this.id = "render"; + this.ComponentType = RenderComponent; + this.DataType = RenderComponentData; + this.schema = _schema5; + this.defaultMaterial = getDefaultMaterial(app2.graphicsDevice); + this.on("beforeremove", this.onRemove, this); + } + initializeComponentData(component, _data, properties2) { + if (_data.batchGroupId === null || _data.batchGroupId === void 0) { + _data.batchGroupId = -1; + } + if (_data.layers && _data.layers.length) { + _data.layers = _data.layers.slice(0); + } + for (let i = 0; i < _properties.length; i++) { + if (_data.hasOwnProperty(_properties[i])) { + component[_properties[i]] = _data[_properties[i]]; + } + } + if (_data.aabbCenter && _data.aabbHalfExtents) { + component.customAabb = new BoundingBox(new Vec3(_data.aabbCenter), new Vec3(_data.aabbHalfExtents)); + } + super.initializeComponentData(component, _data, _schema5); + } + cloneComponent(entity, clone) { + const data2 = {}; + for (let i = 0; i < _properties.length; i++) { + data2[_properties[i]] = entity.render[_properties[i]]; + } + data2.enabled = entity.render.enabled; + delete data2.meshInstances; + const component = this.addComponent(clone, data2); + const srcMeshInstances = entity.render.meshInstances; + const meshes = srcMeshInstances.map((mi) => mi.mesh); + component._onSetMeshes(meshes); + for (let m = 0; m < srcMeshInstances.length; m++) { + component.meshInstances[m].material = srcMeshInstances[m].material; + } + if (entity.render.customAabb) { + component.customAabb = entity.render.customAabb.clone(); + } + return component; + } + onRemove(entity, component) { + component.onRemove(); + } +}; +Component._buildAccessors(RenderComponent.prototype, _schema5); + +// ../../node_modules/playcanvas/build/playcanvas/src/core/object-pool.js +var ObjectPool = class { + constructor(constructorFunc, size) { + this._constructor = void 0; + this._pool = []; + this._count = 0; + this._constructor = constructorFunc; + this._resize(size); + } + _resize(size) { + if (size > this._pool.length) { + for (let i = this._pool.length; i < size; i++) { + this._pool[i] = new this._constructor(); + } + } + } + allocate() { + if (this._count >= this._pool.length) { + this._resize(this._pool.length * 2); + } + return this._pool[this._count++]; + } + freeAll() { + this._count = 0; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/components/rigid-body/component.js +var _ammoTransform2; +var _ammoVec12; +var _ammoVec2; +var _ammoQuat2; +var _quat1 = new Quat2(); +var _quat2 = new Quat2(); +var _vec32 = new Vec3(); +var RigidBodyComponent = class extends Component { + constructor(system, entity) { + super(system, entity); + this._angularDamping = 0; + this._angularFactor = new Vec3(1, 1, 1); + this._angularVelocity = new Vec3(); + this._body = null; + this._friction = 0.5; + this._group = BODYGROUP_STATIC; + this._linearDamping = 0; + this._linearFactor = new Vec3(1, 1, 1); + this._linearVelocity = new Vec3(); + this._mask = BODYMASK_NOT_STATIC; + this._mass = 1; + this._restitution = 0; + this._rollingFriction = 0; + this._simulationEnabled = false; + this._type = BODYTYPE_STATIC; + } + static onLibraryLoaded() { + if (typeof Ammo !== "undefined") { + _ammoTransform2 = new Ammo.btTransform(); + _ammoVec12 = new Ammo.btVector3(); + _ammoVec2 = new Ammo.btVector3(); + _ammoQuat2 = new Ammo.btQuaternion(); + } + } + set angularDamping(damping) { + if (this._angularDamping !== damping) { + this._angularDamping = damping; + if (this._body) { + this._body.setDamping(this._linearDamping, damping); + } + } + } + get angularDamping() { + return this._angularDamping; + } + set angularFactor(factor) { + if (!this._angularFactor.equals(factor)) { + this._angularFactor.copy(factor); + if (this._body && this._type === BODYTYPE_DYNAMIC) { + _ammoVec12.setValue(factor.x, factor.y, factor.z); + this._body.setAngularFactor(_ammoVec12); + } + } + } + get angularFactor() { + return this._angularFactor; + } + set angularVelocity(velocity) { + if (this._body && this._type === BODYTYPE_DYNAMIC) { + this._body.activate(); + _ammoVec12.setValue(velocity.x, velocity.y, velocity.z); + this._body.setAngularVelocity(_ammoVec12); + this._angularVelocity.copy(velocity); + } + } + get angularVelocity() { + if (this._body && this._type === BODYTYPE_DYNAMIC) { + const velocity = this._body.getAngularVelocity(); + this._angularVelocity.set(velocity.x(), velocity.y(), velocity.z()); + } + return this._angularVelocity; + } + set body(body) { + if (this._body !== body) { + this._body = body; + if (body && this._simulationEnabled) { + body.activate(); + } + } + } + get body() { + return this._body; + } + set friction(friction) { + if (this._friction !== friction) { + this._friction = friction; + if (this._body) { + this._body.setFriction(friction); + } + } + } + get friction() { + return this._friction; + } + set group(group) { + if (this._group !== group) { + this._group = group; + if (this.enabled && this.entity.enabled) { + this.disableSimulation(); + this.enableSimulation(); + } + } + } + get group() { + return this._group; + } + set linearDamping(damping) { + if (this._linearDamping !== damping) { + this._linearDamping = damping; + if (this._body) { + this._body.setDamping(damping, this._angularDamping); + } + } + } + get linearDamping() { + return this._linearDamping; + } + set linearFactor(factor) { + if (!this._linearFactor.equals(factor)) { + this._linearFactor.copy(factor); + if (this._body && this._type === BODYTYPE_DYNAMIC) { + _ammoVec12.setValue(factor.x, factor.y, factor.z); + this._body.setLinearFactor(_ammoVec12); + } + } + } + get linearFactor() { + return this._linearFactor; + } + set linearVelocity(velocity) { + if (this._body && this._type === BODYTYPE_DYNAMIC) { + this._body.activate(); + _ammoVec12.setValue(velocity.x, velocity.y, velocity.z); + this._body.setLinearVelocity(_ammoVec12); + this._linearVelocity.copy(velocity); + } + } + get linearVelocity() { + if (this._body && this._type === BODYTYPE_DYNAMIC) { + const velocity = this._body.getLinearVelocity(); + this._linearVelocity.set(velocity.x(), velocity.y(), velocity.z()); + } + return this._linearVelocity; + } + set mask(mask) { + if (this._mask !== mask) { + this._mask = mask; + if (this.enabled && this.entity.enabled) { + this.disableSimulation(); + this.enableSimulation(); + } + } + } + get mask() { + return this._mask; + } + set mass(mass) { + if (this._mass !== mass) { + this._mass = mass; + if (this._body && this._type === BODYTYPE_DYNAMIC) { + const enabled = this.enabled && this.entity.enabled; + if (enabled) { + this.disableSimulation(); + } + this._body.getCollisionShape().calculateLocalInertia(mass, _ammoVec12); + this._body.setMassProps(mass, _ammoVec12); + this._body.updateInertiaTensor(); + if (enabled) { + this.enableSimulation(); + } + } + } + } + get mass() { + return this._mass; + } + set restitution(restitution) { + if (this._restitution !== restitution) { + this._restitution = restitution; + if (this._body) { + this._body.setRestitution(restitution); + } + } + } + get restitution() { + return this._restitution; + } + set rollingFriction(friction) { + if (this._rollingFriction !== friction) { + this._rollingFriction = friction; + if (this._body) { + this._body.setRollingFriction(friction); + } + } + } + get rollingFriction() { + return this._rollingFriction; + } + set type(type2) { + if (this._type !== type2) { + this._type = type2; + this.disableSimulation(); + switch (type2) { + case BODYTYPE_DYNAMIC: + this._group = BODYGROUP_DYNAMIC; + this._mask = BODYMASK_ALL; + break; + case BODYTYPE_KINEMATIC: + this._group = BODYGROUP_KINEMATIC; + this._mask = BODYMASK_ALL; + break; + case BODYTYPE_STATIC: + default: + this._group = BODYGROUP_STATIC; + this._mask = BODYMASK_NOT_STATIC; + break; + } + this.createBody(); + } + } + get type() { + return this._type; + } + createBody() { + const entity = this.entity; + let shape2; + if (entity.collision) { + shape2 = entity.collision.shape; + if (entity.trigger) { + entity.trigger.destroy(); + delete entity.trigger; + } + } + if (shape2) { + if (this._body) { + this.system.removeBody(this._body); + this.system.destroyBody(this._body); + this._body = null; + } + const mass = this._type === BODYTYPE_DYNAMIC ? this._mass : 0; + this._getEntityTransform(_ammoTransform2); + const body = this.system.createBody(mass, shape2, _ammoTransform2); + body.setRestitution(this._restitution); + body.setFriction(this._friction); + body.setRollingFriction(this._rollingFriction); + body.setDamping(this._linearDamping, this._angularDamping); + if (this._type === BODYTYPE_DYNAMIC) { + const linearFactor = this._linearFactor; + _ammoVec12.setValue(linearFactor.x, linearFactor.y, linearFactor.z); + body.setLinearFactor(_ammoVec12); + const angularFactor = this._angularFactor; + _ammoVec12.setValue(angularFactor.x, angularFactor.y, angularFactor.z); + body.setAngularFactor(_ammoVec12); + } else if (this._type === BODYTYPE_KINEMATIC) { + body.setCollisionFlags(body.getCollisionFlags() | BODYFLAG_KINEMATIC_OBJECT); + body.setActivationState(BODYSTATE_DISABLE_DEACTIVATION); + } + body.entity = entity; + this.body = body; + if (this.enabled && entity.enabled) { + this.enableSimulation(); + } + } + } + isActive() { + return this._body ? this._body.isActive() : false; + } + activate() { + if (this._body) { + this._body.activate(); + } + } + enableSimulation() { + const entity = this.entity; + if (entity.collision && entity.collision.enabled && !this._simulationEnabled) { + const body = this._body; + if (body) { + this.system.addBody(body, this._group, this._mask); + switch (this._type) { + case BODYTYPE_DYNAMIC: + this.system._dynamic.push(this); + body.forceActivationState(BODYSTATE_ACTIVE_TAG); + this.syncEntityToBody(); + break; + case BODYTYPE_KINEMATIC: + this.system._kinematic.push(this); + body.forceActivationState(BODYSTATE_DISABLE_DEACTIVATION); + break; + case BODYTYPE_STATIC: + body.forceActivationState(BODYSTATE_ACTIVE_TAG); + this.syncEntityToBody(); + break; + } + if (entity.collision.type === "compound") { + this.system._compounds.push(entity.collision); + } + body.activate(); + this._simulationEnabled = true; + } + } + } + disableSimulation() { + const body = this._body; + if (body && this._simulationEnabled) { + const system = this.system; + let idx = system._compounds.indexOf(this.entity.collision); + if (idx > -1) { + system._compounds.splice(idx, 1); + } + idx = system._dynamic.indexOf(this); + if (idx > -1) { + system._dynamic.splice(idx, 1); + } + idx = system._kinematic.indexOf(this); + if (idx > -1) { + system._kinematic.splice(idx, 1); + } + system.removeBody(body); + body.forceActivationState(BODYSTATE_DISABLE_SIMULATION); + this._simulationEnabled = false; + } + } + applyForce(x2, y2, z2, px, py, pz) { + const body = this._body; + if (body) { + body.activate(); + if (x2 instanceof Vec3) { + _ammoVec12.setValue(x2.x, x2.y, x2.z); + } else { + _ammoVec12.setValue(x2, y2, z2); + } + if (y2 instanceof Vec3) { + _ammoVec2.setValue(y2.x, y2.y, y2.z); + } else if (px !== void 0) { + _ammoVec2.setValue(px, py, pz); + } else { + _ammoVec2.setValue(0, 0, 0); + } + body.applyForce(_ammoVec12, _ammoVec2); + } + } + applyTorque(x2, y2, z2) { + const body = this._body; + if (body) { + body.activate(); + if (x2 instanceof Vec3) { + _ammoVec12.setValue(x2.x, x2.y, x2.z); + } else { + _ammoVec12.setValue(x2, y2, z2); + } + body.applyTorque(_ammoVec12); + } + } + applyImpulse(x2, y2, z2, px, py, pz) { + const body = this._body; + if (body) { + body.activate(); + if (x2 instanceof Vec3) { + _ammoVec12.setValue(x2.x, x2.y, x2.z); + } else { + _ammoVec12.setValue(x2, y2, z2); + } + if (y2 instanceof Vec3) { + _ammoVec2.setValue(y2.x, y2.y, y2.z); + } else if (px !== void 0) { + _ammoVec2.setValue(px, py, pz); + } else { + _ammoVec2.setValue(0, 0, 0); + } + body.applyImpulse(_ammoVec12, _ammoVec2); + } + } + applyTorqueImpulse(x2, y2, z2) { + const body = this._body; + if (body) { + body.activate(); + if (x2 instanceof Vec3) { + _ammoVec12.setValue(x2.x, x2.y, x2.z); + } else { + _ammoVec12.setValue(x2, y2, z2); + } + body.applyTorqueImpulse(_ammoVec12); + } + } + isStatic() { + return this._type === BODYTYPE_STATIC; + } + isStaticOrKinematic() { + return this._type === BODYTYPE_STATIC || this._type === BODYTYPE_KINEMATIC; + } + isKinematic() { + return this._type === BODYTYPE_KINEMATIC; + } + _getEntityTransform(transform) { + const entity = this.entity; + const component = entity.collision; + if (component) { + const bodyPos = component.getShapePosition(); + const bodyRot = component.getShapeRotation(); + _ammoVec12.setValue(bodyPos.x, bodyPos.y, bodyPos.z); + _ammoQuat2.setValue(bodyRot.x, bodyRot.y, bodyRot.z, bodyRot.w); + } else { + const pos = entity.getPosition(); + const rot = entity.getRotation(); + _ammoVec12.setValue(pos.x, pos.y, pos.z); + _ammoQuat2.setValue(rot.x, rot.y, rot.z, rot.w); + } + transform.setOrigin(_ammoVec12); + transform.setRotation(_ammoQuat2); + } + syncEntityToBody() { + const body = this._body; + if (body) { + this._getEntityTransform(_ammoTransform2); + body.setWorldTransform(_ammoTransform2); + if (this._type === BODYTYPE_KINEMATIC) { + const motionState = body.getMotionState(); + if (motionState) { + motionState.setWorldTransform(_ammoTransform2); + } + } + body.activate(); + } + } + _updateDynamic() { + const body = this._body; + if (body.isActive()) { + const motionState = body.getMotionState(); + if (motionState) { + const entity = this.entity; + motionState.getWorldTransform(_ammoTransform2); + const p = _ammoTransform2.getOrigin(); + const q2 = _ammoTransform2.getRotation(); + const component = entity.collision; + if (component && component._hasOffset) { + const lo = component.data.linearOffset; + const ao = component.data.angularOffset; + const invertedAo = _quat2.copy(ao).invert(); + const entityRot = _quat1.set(q2.x(), q2.y(), q2.z(), q2.w()).mul(invertedAo); + entityRot.transformVector(lo, _vec32); + entity.setPosition(p.x() - _vec32.x, p.y() - _vec32.y, p.z() - _vec32.z); + entity.setRotation(entityRot); + } else { + entity.setPosition(p.x(), p.y(), p.z()); + entity.setRotation(q2.x(), q2.y(), q2.z(), q2.w()); + } + } + } + } + _updateKinematic() { + const motionState = this._body.getMotionState(); + if (motionState) { + this._getEntityTransform(_ammoTransform2); + motionState.setWorldTransform(_ammoTransform2); + } + } + teleport(x2, y2, z2, rx, ry, rz) { + if (x2 instanceof Vec3) { + this.entity.setPosition(x2); + } else { + this.entity.setPosition(x2, y2, z2); + } + if (y2 instanceof Quat2) { + this.entity.setRotation(y2); + } else if (y2 instanceof Vec3) { + this.entity.setEulerAngles(y2); + } else if (rx !== void 0) { + this.entity.setEulerAngles(rx, ry, rz); + } + this.syncEntityToBody(); + } + onEnable() { + if (!this._body) { + this.createBody(); + } + this.enableSimulation(); + } + onDisable() { + this.disableSimulation(); + } +}; +RigidBodyComponent.EVENT_CONTACT = "contact"; +RigidBodyComponent.EVENT_COLLISIONSTART = "collisionstart"; +RigidBodyComponent.EVENT_COLLISIONEND = "collisionend"; +RigidBodyComponent.EVENT_TRIGGERENTER = "triggerenter"; +RigidBodyComponent.EVENT_TRIGGERLEAVE = "triggerleave"; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/components/rigid-body/data.js +var RigidBodyComponentData = class { + constructor() { + this.enabled = true; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/components/rigid-body/system.js +var ammoRayStart; +var ammoRayEnd; +var RaycastResult = class { + constructor(entity, point, normal, hitFraction) { + this.entity = void 0; + this.point = void 0; + this.normal = void 0; + this.hitFraction = void 0; + this.entity = entity; + this.point = point; + this.normal = normal; + this.hitFraction = hitFraction; + } +}; +var SingleContactResult = class { + constructor(a, b, contactPoint) { + this.a = void 0; + this.b = void 0; + this.impulse = void 0; + this.localPointA = void 0; + this.localPointB = void 0; + this.pointA = void 0; + this.pointB = void 0; + this.normal = void 0; + if (arguments.length !== 0) { + this.a = a; + this.b = b; + this.impulse = contactPoint.impulse; + this.localPointA = contactPoint.localPoint; + this.localPointB = contactPoint.localPointOther; + this.pointA = contactPoint.point; + this.pointB = contactPoint.pointOther; + this.normal = contactPoint.normal; + } else { + this.a = null; + this.b = null; + this.impulse = 0; + this.localPointA = new Vec3(); + this.localPointB = new Vec3(); + this.pointA = new Vec3(); + this.pointB = new Vec3(); + this.normal = new Vec3(); + } + } +}; +var ContactPoint = class { + constructor(localPoint = new Vec3(), localPointOther = new Vec3(), point = new Vec3(), pointOther = new Vec3(), normal = new Vec3(), impulse = 0) { + this.localPoint = void 0; + this.localPointOther = void 0; + this.point = void 0; + this.pointOther = void 0; + this.normal = void 0; + this.impulse = void 0; + this.localPoint = localPoint; + this.localPointOther = localPointOther; + this.point = point; + this.pointOther = pointOther; + this.normal = normal; + this.impulse = impulse; + } +}; +var ContactResult = class { + constructor(other, contacts) { + this.other = void 0; + this.contacts = void 0; + this.other = other; + this.contacts = contacts; + } +}; +var _schema6 = ["enabled"]; +var RigidBodyComponentSystem = class extends ComponentSystem { + constructor(app2) { + super(app2); + this.maxSubSteps = 10; + this.fixedTimeStep = 1 / 60; + this.gravity = new Vec3(0, -9.81, 0); + this._gravityFloat32 = new Float32Array(3); + this._dynamic = []; + this._kinematic = []; + this._triggers = []; + this._compounds = []; + this.id = "rigidbody"; + this._stats = app2.stats.frame; + this.ComponentType = RigidBodyComponent; + this.DataType = RigidBodyComponentData; + this.contactPointPool = null; + this.contactResultPool = null; + this.singleContactResultPool = null; + this.schema = _schema6; + this.collisions = {}; + this.frameCollisions = {}; + this.on("beforeremove", this.onBeforeRemove, this); + } + onLibraryLoaded() { + if (typeof Ammo !== "undefined") { + this.collisionConfiguration = new Ammo.btDefaultCollisionConfiguration(); + this.dispatcher = new Ammo.btCollisionDispatcher(this.collisionConfiguration); + this.overlappingPairCache = new Ammo.btDbvtBroadphase(); + this.solver = new Ammo.btSequentialImpulseConstraintSolver(); + this.dynamicsWorld = new Ammo.btDiscreteDynamicsWorld(this.dispatcher, this.overlappingPairCache, this.solver, this.collisionConfiguration); + if (this.dynamicsWorld.setInternalTickCallback) { + const checkForCollisionsPointer = Ammo.addFunction(this._checkForCollisions.bind(this), "vif"); + this.dynamicsWorld.setInternalTickCallback(checkForCollisionsPointer); + } + ammoRayStart = new Ammo.btVector3(); + ammoRayEnd = new Ammo.btVector3(); + RigidBodyComponent.onLibraryLoaded(); + this.contactPointPool = new ObjectPool(ContactPoint, 1); + this.contactResultPool = new ObjectPool(ContactResult, 1); + this.singleContactResultPool = new ObjectPool(SingleContactResult, 1); + this.app.systems.on("update", this.onUpdate, this); + } else { + this.app.systems.off("update", this.onUpdate, this); + } + } + initializeComponentData(component, data2, properties2) { + const props = ["mass", "linearDamping", "angularDamping", "linearFactor", "angularFactor", "friction", "rollingFriction", "restitution", "type", "group", "mask"]; + for (const property of props) { + if (data2.hasOwnProperty(property)) { + const value = data2[property]; + if (Array.isArray(value)) { + component[property] = new Vec3(value[0], value[1], value[2]); + } else { + component[property] = value; + } + } + } + super.initializeComponentData(component, data2, ["enabled"]); + } + cloneComponent(entity, clone) { + const rigidbody = entity.rigidbody; + const data2 = { + enabled: rigidbody.enabled, + mass: rigidbody.mass, + linearDamping: rigidbody.linearDamping, + angularDamping: rigidbody.angularDamping, + linearFactor: [rigidbody.linearFactor.x, rigidbody.linearFactor.y, rigidbody.linearFactor.z], + angularFactor: [rigidbody.angularFactor.x, rigidbody.angularFactor.y, rigidbody.angularFactor.z], + friction: rigidbody.friction, + rollingFriction: rigidbody.rollingFriction, + restitution: rigidbody.restitution, + type: rigidbody.type, + group: rigidbody.group, + mask: rigidbody.mask + }; + return this.addComponent(clone, data2); + } + onBeforeRemove(entity, component) { + if (component.enabled) { + component.enabled = false; + } + if (component.body) { + this.destroyBody(component.body); + component.body = null; + } + } + addBody(body, group, mask) { + if (group !== void 0 && mask !== void 0) { + this.dynamicsWorld.addRigidBody(body, group, mask); + } else { + this.dynamicsWorld.addRigidBody(body); + } + } + removeBody(body) { + this.dynamicsWorld.removeRigidBody(body); + } + createBody(mass, shape2, transform) { + const localInertia = new Ammo.btVector3(0, 0, 0); + if (mass !== 0) { + shape2.calculateLocalInertia(mass, localInertia); + } + const motionState = new Ammo.btDefaultMotionState(transform); + const bodyInfo = new Ammo.btRigidBodyConstructionInfo(mass, motionState, shape2, localInertia); + const body = new Ammo.btRigidBody(bodyInfo); + Ammo.destroy(bodyInfo); + Ammo.destroy(localInertia); + return body; + } + destroyBody(body) { + const motionState = body.getMotionState(); + if (motionState) { + Ammo.destroy(motionState); + } + Ammo.destroy(body); + } + raycastFirst(start, end, options = {}) { + if (options.filterTags || options.filterCallback) { + options.sort = true; + return this.raycastAll(start, end, options)[0] || null; + } + let result = null; + ammoRayStart.setValue(start.x, start.y, start.z); + ammoRayEnd.setValue(end.x, end.y, end.z); + const rayCallback = new Ammo.ClosestRayResultCallback(ammoRayStart, ammoRayEnd); + if (typeof options.filterCollisionGroup === "number") { + rayCallback.set_m_collisionFilterGroup(options.filterCollisionGroup); + } + if (typeof options.filterCollisionMask === "number") { + rayCallback.set_m_collisionFilterMask(options.filterCollisionMask); + } + this.dynamicsWorld.rayTest(ammoRayStart, ammoRayEnd, rayCallback); + if (rayCallback.hasHit()) { + const collisionObj = rayCallback.get_m_collisionObject(); + const body = Ammo.castObject(collisionObj, Ammo.btRigidBody); + if (body) { + const point = rayCallback.get_m_hitPointWorld(); + const normal = rayCallback.get_m_hitNormalWorld(); + result = new RaycastResult(body.entity, new Vec3(point.x(), point.y(), point.z()), new Vec3(normal.x(), normal.y(), normal.z()), rayCallback.get_m_closestHitFraction()); + } + } + Ammo.destroy(rayCallback); + return result; + } + raycastAll(start, end, options = {}) { + const results = []; + ammoRayStart.setValue(start.x, start.y, start.z); + ammoRayEnd.setValue(end.x, end.y, end.z); + const rayCallback = new Ammo.AllHitsRayResultCallback(ammoRayStart, ammoRayEnd); + if (typeof options.filterCollisionGroup === "number") { + rayCallback.set_m_collisionFilterGroup(options.filterCollisionGroup); + } + if (typeof options.filterCollisionMask === "number") { + rayCallback.set_m_collisionFilterMask(options.filterCollisionMask); + } + this.dynamicsWorld.rayTest(ammoRayStart, ammoRayEnd, rayCallback); + if (rayCallback.hasHit()) { + const collisionObjs = rayCallback.get_m_collisionObjects(); + const points = rayCallback.get_m_hitPointWorld(); + const normals = rayCallback.get_m_hitNormalWorld(); + const hitFractions = rayCallback.get_m_hitFractions(); + const numHits = collisionObjs.size(); + for (let i = 0; i < numHits; i++) { + const body = Ammo.castObject(collisionObjs.at(i), Ammo.btRigidBody); + if (body && body.entity) { + if (options.filterTags && !body.entity.tags.has(...options.filterTags) || options.filterCallback && !options.filterCallback(body.entity)) { + continue; + } + const point = points.at(i); + const normal = normals.at(i); + const result = new RaycastResult(body.entity, new Vec3(point.x(), point.y(), point.z()), new Vec3(normal.x(), normal.y(), normal.z()), hitFractions.at(i)); + results.push(result); + } + } + if (options.sort) { + results.sort((a, b) => a.hitFraction - b.hitFraction); + } + } + Ammo.destroy(rayCallback); + return results; + } + _storeCollision(entity, other) { + let isNewCollision = false; + const guid2 = entity.getGuid(); + this.collisions[guid2] = this.collisions[guid2] || { + others: [], + entity + }; + if (this.collisions[guid2].others.indexOf(other) < 0) { + this.collisions[guid2].others.push(other); + isNewCollision = true; + } + this.frameCollisions[guid2] = this.frameCollisions[guid2] || { + others: [], + entity + }; + this.frameCollisions[guid2].others.push(other); + return isNewCollision; + } + _createContactPointFromAmmo(contactPoint) { + const localPointA = contactPoint.get_m_localPointA(); + const localPointB = contactPoint.get_m_localPointB(); + const positionWorldOnA = contactPoint.getPositionWorldOnA(); + const positionWorldOnB = contactPoint.getPositionWorldOnB(); + const normalWorldOnB = contactPoint.get_m_normalWorldOnB(); + const contact = this.contactPointPool.allocate(); + contact.localPoint.set(localPointA.x(), localPointA.y(), localPointA.z()); + contact.localPointOther.set(localPointB.x(), localPointB.y(), localPointB.z()); + contact.point.set(positionWorldOnA.x(), positionWorldOnA.y(), positionWorldOnA.z()); + contact.pointOther.set(positionWorldOnB.x(), positionWorldOnB.y(), positionWorldOnB.z()); + contact.normal.set(normalWorldOnB.x(), normalWorldOnB.y(), normalWorldOnB.z()); + contact.impulse = contactPoint.getAppliedImpulse(); + return contact; + } + _createReverseContactPointFromAmmo(contactPoint) { + const localPointA = contactPoint.get_m_localPointA(); + const localPointB = contactPoint.get_m_localPointB(); + const positionWorldOnA = contactPoint.getPositionWorldOnA(); + const positionWorldOnB = contactPoint.getPositionWorldOnB(); + const normalWorldOnB = contactPoint.get_m_normalWorldOnB(); + const contact = this.contactPointPool.allocate(); + contact.localPointOther.set(localPointA.x(), localPointA.y(), localPointA.z()); + contact.localPoint.set(localPointB.x(), localPointB.y(), localPointB.z()); + contact.pointOther.set(positionWorldOnA.x(), positionWorldOnA.y(), positionWorldOnA.z()); + contact.point.set(positionWorldOnB.x(), positionWorldOnB.y(), positionWorldOnB.z()); + contact.normal.set(normalWorldOnB.x(), normalWorldOnB.y(), normalWorldOnB.z()); + contact.impulse = contactPoint.getAppliedImpulse(); + return contact; + } + _createSingleContactResult(a, b, contactPoint) { + const result = this.singleContactResultPool.allocate(); + result.a = a; + result.b = b; + result.localPointA = contactPoint.localPoint; + result.localPointB = contactPoint.localPointOther; + result.pointA = contactPoint.point; + result.pointB = contactPoint.pointOther; + result.normal = contactPoint.normal; + result.impulse = contactPoint.impulse; + return result; + } + _createContactResult(other, contacts) { + const result = this.contactResultPool.allocate(); + result.other = other; + result.contacts = contacts; + return result; + } + _cleanOldCollisions() { + for (const guid2 in this.collisions) { + if (this.collisions.hasOwnProperty(guid2)) { + const frameCollision = this.frameCollisions[guid2]; + const collision = this.collisions[guid2]; + const entity = collision.entity; + const entityCollision = entity.collision; + const entityRigidbody = entity.rigidbody; + const others = collision.others; + const length = others.length; + let i = length; + while (i--) { + const other = others[i]; + if (!frameCollision || frameCollision.others.indexOf(other) < 0) { + others.splice(i, 1); + if (entity.trigger) { + if (entityCollision) { + entityCollision.fire("triggerleave", other); + } + if (other.rigidbody) { + other.rigidbody.fire("triggerleave", entity); + } + } else if (!other.trigger) { + if (entityRigidbody) { + entityRigidbody.fire("collisionend", other); + } + if (entityCollision) { + entityCollision.fire("collisionend", other); + } + } + } + } + if (others.length === 0) { + delete this.collisions[guid2]; + } + } + } + } + _hasContactEvent(entity) { + const c2 = entity.collision; + if (c2 && (c2.hasEvent("collisionstart") || c2.hasEvent("collisionend") || c2.hasEvent("contact"))) { + return true; + } + const r = entity.rigidbody; + return r && (r.hasEvent("collisionstart") || r.hasEvent("collisionend") || r.hasEvent("contact")); + } + _checkForCollisions(world, timeStep) { + const dynamicsWorld = Ammo.wrapPointer(world, Ammo.btDynamicsWorld); + const dispatcher = dynamicsWorld.getDispatcher(); + const numManifolds = dispatcher.getNumManifolds(); + this.frameCollisions = {}; + for (let i = 0; i < numManifolds; i++) { + const manifold = dispatcher.getManifoldByIndexInternal(i); + const body0 = manifold.getBody0(); + const body1 = manifold.getBody1(); + const wb0 = Ammo.castObject(body0, Ammo.btRigidBody); + const wb1 = Ammo.castObject(body1, Ammo.btRigidBody); + const e0 = wb0.entity; + const e1 = wb1.entity; + if (!e0 || !e1) { + continue; + } + const flags0 = wb0.getCollisionFlags(); + const flags1 = wb1.getCollisionFlags(); + const numContacts = manifold.getNumContacts(); + const forwardContacts = []; + const reverseContacts = []; + let newCollision; + if (numContacts > 0) { + if (flags0 & BODYFLAG_NORESPONSE_OBJECT || flags1 & BODYFLAG_NORESPONSE_OBJECT) { + const e0Events = e0.collision && (e0.collision.hasEvent("triggerenter") || e0.collision.hasEvent("triggerleave")); + const e1Events = e1.collision && (e1.collision.hasEvent("triggerenter") || e1.collision.hasEvent("triggerleave")); + const e0BodyEvents = e0.rigidbody && (e0.rigidbody.hasEvent("triggerenter") || e0.rigidbody.hasEvent("triggerleave")); + const e1BodyEvents = e1.rigidbody && (e1.rigidbody.hasEvent("triggerenter") || e1.rigidbody.hasEvent("triggerleave")); + if (e0Events) { + newCollision = this._storeCollision(e0, e1); + if (newCollision && !(flags1 & BODYFLAG_NORESPONSE_OBJECT)) { + e0.collision.fire("triggerenter", e1); + } + } + if (e1Events) { + newCollision = this._storeCollision(e1, e0); + if (newCollision && !(flags0 & BODYFLAG_NORESPONSE_OBJECT)) { + e1.collision.fire("triggerenter", e0); + } + } + if (e0BodyEvents) { + if (!newCollision) { + newCollision = this._storeCollision(e1, e0); + } + if (newCollision) { + e0.rigidbody.fire("triggerenter", e1); + } + } + if (e1BodyEvents) { + if (!newCollision) { + newCollision = this._storeCollision(e0, e1); + } + if (newCollision) { + e1.rigidbody.fire("triggerenter", e0); + } + } + } else { + const e0Events = this._hasContactEvent(e0); + const e1Events = this._hasContactEvent(e1); + const globalEvents = this.hasEvent("contact"); + if (globalEvents || e0Events || e1Events) { + for (let j = 0; j < numContacts; j++) { + const btContactPoint = manifold.getContactPoint(j); + const contactPoint = this._createContactPointFromAmmo(btContactPoint); + if (e0Events || e1Events) { + forwardContacts.push(contactPoint); + const reverseContactPoint = this._createReverseContactPointFromAmmo(btContactPoint); + reverseContacts.push(reverseContactPoint); + } + if (globalEvents) { + const result = this._createSingleContactResult(e0, e1, contactPoint); + this.fire("contact", result); + } + } + if (e0Events) { + const forwardResult = this._createContactResult(e1, forwardContacts); + newCollision = this._storeCollision(e0, e1); + if (e0.collision) { + e0.collision.fire("contact", forwardResult); + if (newCollision) { + e0.collision.fire("collisionstart", forwardResult); + } + } + if (e0.rigidbody) { + e0.rigidbody.fire("contact", forwardResult); + if (newCollision) { + e0.rigidbody.fire("collisionstart", forwardResult); + } + } + } + if (e1Events) { + const reverseResult = this._createContactResult(e0, reverseContacts); + newCollision = this._storeCollision(e1, e0); + if (e1.collision) { + e1.collision.fire("contact", reverseResult); + if (newCollision) { + e1.collision.fire("collisionstart", reverseResult); + } + } + if (e1.rigidbody) { + e1.rigidbody.fire("contact", reverseResult); + if (newCollision) { + e1.rigidbody.fire("collisionstart", reverseResult); + } + } + } + } + } + } + } + this._cleanOldCollisions(); + this.contactPointPool.freeAll(); + this.contactResultPool.freeAll(); + this.singleContactResultPool.freeAll(); + } + onUpdate(dt) { + let i, len; + this._gravityFloat32[0] = this.gravity.x; + this._gravityFloat32[1] = this.gravity.y; + this._gravityFloat32[2] = this.gravity.z; + const gravity = this.dynamicsWorld.getGravity(); + if (gravity.x() !== this._gravityFloat32[0] || gravity.y() !== this._gravityFloat32[1] || gravity.z() !== this._gravityFloat32[2]) { + gravity.setValue(this.gravity.x, this.gravity.y, this.gravity.z); + this.dynamicsWorld.setGravity(gravity); + } + const triggers = this._triggers; + for (i = 0, len = triggers.length; i < len; i++) { + triggers[i].updateTransform(); + } + const compounds = this._compounds; + for (i = 0, len = compounds.length; i < len; i++) { + compounds[i]._updateCompound(); + } + const kinematic = this._kinematic; + for (i = 0, len = kinematic.length; i < len; i++) { + kinematic[i]._updateKinematic(); + } + this.dynamicsWorld.stepSimulation(dt, this.maxSubSteps, this.fixedTimeStep); + const dynamic = this._dynamic; + for (i = 0, len = dynamic.length; i < len; i++) { + dynamic[i]._updateDynamic(); + } + if (!this.dynamicsWorld.setInternalTickCallback) this._checkForCollisions(Ammo.getPointer(this.dynamicsWorld), dt); + } + destroy() { + super.destroy(); + this.app.systems.off("update", this.onUpdate, this); + if (typeof Ammo !== "undefined") { + Ammo.destroy(this.dynamicsWorld); + Ammo.destroy(this.solver); + Ammo.destroy(this.overlappingPairCache); + Ammo.destroy(this.dispatcher); + Ammo.destroy(this.collisionConfiguration); + this.dynamicsWorld = null; + this.solver = null; + this.overlappingPairCache = null; + this.dispatcher = null; + this.collisionConfiguration = null; + } + } +}; +RigidBodyComponentSystem.EVENT_CONTACT = "contact"; +Component._buildAccessors(RigidBodyComponent.prototype, _schema6); + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/components/sound/slot.js +var instanceOptions = { + volume: 0, + pitch: 0, + loop: false, + startTime: 0, + duration: 0, + position: new Vec3(), + maxDistance: 0, + refDistance: 0, + rollOffFactor: 0, + distanceModel: 0, + onPlay: null, + onPause: null, + onResume: null, + onStop: null, + onEnd: null +}; +var SoundSlot = class extends EventHandler { + constructor(component, name = "Untitled", options = {}) { + super(); + this.name = void 0; + this.instances = []; + this._component = component; + this._assets = component.system.app.assets; + this._manager = component.system.manager; + this.name = name; + this._volume = options.volume !== void 0 ? math.clamp(Number(options.volume) || 0, 0, 1) : 1; + this._pitch = options.pitch !== void 0 ? Math.max(0.01, Number(options.pitch) || 0) : 1; + this._loop = !!(options.loop !== void 0 ? options.loop : false); + this._duration = options.duration > 0 ? options.duration : null; + this._startTime = Math.max(0, Number(options.startTime) || 0); + this._overlap = !!options.overlap; + this._autoPlay = !!options.autoPlay; + this._firstNode = null; + this._lastNode = null; + this._asset = options.asset; + if (this._asset instanceof Asset) { + this._asset = this._asset.id; + } + this._onInstancePlayHandler = this._onInstancePlay.bind(this); + this._onInstancePauseHandler = this._onInstancePause.bind(this); + this._onInstanceResumeHandler = this._onInstanceResume.bind(this); + this._onInstanceStopHandler = this._onInstanceStop.bind(this); + this._onInstanceEndHandler = this._onInstanceEnd.bind(this); + } + play() { + if (!this.overlap) { + this.stop(); + } + if (!this.isLoaded && !this._hasAsset()) { + return void 0; + } + const instance = this._createInstance(); + this.instances.push(instance); + if (!this.isLoaded) { + const onLoad = function onLoad2(sound) { + const playWhenLoaded = instance._playWhenLoaded; + instance.sound = sound; + if (playWhenLoaded) { + instance.play(); + } + }; + this.off("load", onLoad); + this.once("load", onLoad); + this.load(); + } else { + instance.play(); + } + return instance; + } + pause() { + let paused = false; + const instances = this.instances; + for (let i = 0, len = instances.length; i < len; i++) { + if (instances[i].pause()) { + paused = true; + } + } + return paused; + } + resume() { + let resumed = false; + const instances = this.instances; + for (let i = 0, len = instances.length; i < len; i++) { + if (instances[i].resume()) resumed = true; + } + return resumed; + } + stop() { + let stopped = false; + const instances = this.instances; + let i = instances.length; + while (i--) { + instances[i].stop(); + stopped = true; + } + instances.length = 0; + return stopped; + } + load() { + if (!this._hasAsset()) return; + const asset2 = this._assets.get(this._asset); + if (!asset2) { + this._assets.off("add:" + this._asset, this._onAssetAdd, this); + this._assets.once("add:" + this._asset, this._onAssetAdd, this); + return; + } + asset2.off("remove", this._onAssetRemoved, this); + asset2.on("remove", this._onAssetRemoved, this); + if (!asset2.resource) { + asset2.off("load", this._onAssetLoad, this); + asset2.once("load", this._onAssetLoad, this); + this._assets.load(asset2); + return; + } + this.fire("load", asset2.resource); + } + setExternalNodes(firstNode, lastNode) { + if (!firstNode) { + console.error("The firstNode must have a valid AudioNode"); + return; + } + if (!lastNode) { + lastNode = firstNode; + } + this._firstNode = firstNode; + this._lastNode = lastNode; + if (!this._overlap) { + const instances = this.instances; + for (let i = 0, len = instances.length; i < len; i++) { + instances[i].setExternalNodes(firstNode, lastNode); + } + } + } + clearExternalNodes() { + this._firstNode = null; + this._lastNode = null; + if (!this._overlap) { + const instances = this.instances; + for (let i = 0, len = instances.length; i < len; i++) { + instances[i].clearExternalNodes(); + } + } + } + getExternalNodes() { + return [this._firstNode, this._lastNode]; + } + _hasAsset() { + return this._asset != null; + } + _createInstance() { + let instance = null; + const component = this._component; + let sound = null; + if (this._hasAsset()) { + const asset2 = this._assets.get(this._asset); + if (asset2) { + sound = asset2.resource; + } + } + const data2 = instanceOptions; + data2.volume = this._volume * component.volume; + data2.pitch = this._pitch * component.pitch; + data2.loop = this._loop; + data2.startTime = this._startTime; + data2.duration = this._duration; + data2.onPlay = this._onInstancePlayHandler; + data2.onPause = this._onInstancePauseHandler; + data2.onResume = this._onInstanceResumeHandler; + data2.onStop = this._onInstanceStopHandler; + data2.onEnd = this._onInstanceEndHandler; + if (component.positional) { + data2.position.copy(component.entity.getPosition()); + data2.maxDistance = component.maxDistance; + data2.refDistance = component.refDistance; + data2.rollOffFactor = component.rollOffFactor; + data2.distanceModel = component.distanceModel; + instance = new SoundInstance3d(this._manager, sound, data2); + } else { + instance = new SoundInstance(this._manager, sound, data2); + } + if (this._firstNode) { + instance.setExternalNodes(this._firstNode, this._lastNode); + } + return instance; + } + _onInstancePlay(instance) { + this.fire("play", instance); + this._component.fire("play", this, instance); + } + _onInstancePause(instance) { + this.fire("pause", instance); + this._component.fire("pause", this, instance); + } + _onInstanceResume(instance) { + this.fire("resume", instance); + this._component.fire("resume", this, instance); + } + _onInstanceStop(instance) { + const idx = this.instances.indexOf(instance); + if (idx !== -1) { + this.instances.splice(idx, 1); + } + this.fire("stop", instance); + this._component.fire("stop", this, instance); + } + _onInstanceEnd(instance) { + const idx = this.instances.indexOf(instance); + if (idx !== -1) { + this.instances.splice(idx, 1); + } + this.fire("end", instance); + this._component.fire("end", this, instance); + } + _onAssetAdd(asset2) { + this.load(); + } + _onAssetLoad(asset2) { + this.load(); + } + _onAssetRemoved(asset2) { + asset2.off("remove", this._onAssetRemoved, this); + this._assets.off("add:" + asset2.id, this._onAssetAdd, this); + this.stop(); + } + updatePosition(position2) { + const instances = this.instances; + for (let i = 0, len = instances.length; i < len; i++) { + instances[i].position = position2; + } + } + set asset(value) { + const old = this._asset; + if (old) { + this._assets.off("add:" + old, this._onAssetAdd, this); + const oldAsset = this._assets.get(old); + if (oldAsset) { + oldAsset.off("remove", this._onAssetRemoved, this); + } + } + this._asset = value; + if (this._asset instanceof Asset) { + this._asset = this._asset.id; + } + if (this._hasAsset() && this._component.enabled && this._component.entity.enabled) { + this.load(); + } + } + get asset() { + return this._asset; + } + set autoPlay(value) { + this._autoPlay = !!value; + } + get autoPlay() { + return this._autoPlay; + } + set duration(value) { + this._duration = Math.max(0, Number(value) || 0) || null; + if (!this._overlap) { + const instances = this.instances; + for (let i = 0, len = instances.length; i < len; i++) { + instances[i].duration = this._duration; + } + } + } + get duration() { + let assetDuration = 0; + if (this._hasAsset()) { + const asset2 = this._assets.get(this._asset); + assetDuration = asset2 != null && asset2.resource ? asset2.resource.duration : 0; + } + if (this._duration != null) { + return this._duration % (assetDuration || 1); + } + return assetDuration; + } + get isLoaded() { + if (this._hasAsset()) { + const asset2 = this._assets.get(this._asset); + if (asset2) { + return !!asset2.resource; + } + } + return false; + } + get isPaused() { + const instances = this.instances; + const len = instances.length; + if (len === 0) return false; + for (let i = 0; i < len; i++) { + if (!instances[i].isPaused) return false; + } + return true; + } + get isPlaying() { + const instances = this.instances; + for (let i = 0, len = instances.length; i < len; i++) { + if (instances[i].isPlaying) return true; + } + return false; + } + get isStopped() { + const instances = this.instances; + for (let i = 0, len = instances.length; i < len; i++) { + if (!instances[i].isStopped) return false; + } + return true; + } + set loop(value) { + this._loop = !!value; + const instances = this.instances; + for (let i = 0, len = instances.length; i < len; i++) { + instances[i].loop = this._loop; + } + } + get loop() { + return this._loop; + } + set overlap(value) { + this._overlap = !!value; + } + get overlap() { + return this._overlap; + } + set pitch(value) { + this._pitch = Math.max(Number(value) || 0, 0.01); + if (!this._overlap) { + const instances = this.instances; + for (let i = 0, len = instances.length; i < len; i++) { + instances[i].pitch = this.pitch * this._component.pitch; + } + } + } + get pitch() { + return this._pitch; + } + set startTime(value) { + this._startTime = Math.max(0, Number(value) || 0); + if (!this._overlap) { + const instances = this.instances; + for (let i = 0, len = instances.length; i < len; i++) { + instances[i].startTime = this._startTime; + } + } + } + get startTime() { + return this._startTime; + } + set volume(value) { + this._volume = math.clamp(Number(value) || 0, 0, 1); + if (!this._overlap) { + const instances = this.instances; + for (let i = 0, len = instances.length; i < len; i++) { + instances[i].volume = this._volume * this._component.volume; + } + } + } + get volume() { + return this._volume; + } +}; +SoundSlot.EVENT_PLAY = "play"; +SoundSlot.EVENT_PAUSE = "pause"; +SoundSlot.EVENT_RESUME = "resume"; +SoundSlot.EVENT_STOP = "stop"; +SoundSlot.EVENT_LOAD = "load"; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/components/sound/component.js +var SoundComponent = class extends Component { + constructor(system, entity) { + super(system, entity); + this._volume = 1; + this._pitch = 1; + this._positional = true; + this._refDistance = 1; + this._maxDistance = 1e4; + this._rollOffFactor = 1; + this._distanceModel = DISTANCE_LINEAR; + this._slots = {}; + this._playingBeforeDisable = {}; + } + _updateSoundInstances(property, value, isFactor) { + const slots = this._slots; + for (const key in slots) { + const slot = slots[key]; + if (!slot.overlap) { + const instances = slot.instances; + for (let i = 0, len = instances.length; i < len; i++) { + instances[i][property] = isFactor ? slot[property] * value : value; + } + } + } + } + set distanceModel(value) { + this._distanceModel = value; + this._updateSoundInstances("distanceModel", value, false); + } + get distanceModel() { + return this._distanceModel; + } + set maxDistance(value) { + this._maxDistance = value; + this._updateSoundInstances("maxDistance", value, false); + } + get maxDistance() { + return this._maxDistance; + } + set refDistance(value) { + this._refDistance = value; + this._updateSoundInstances("refDistance", value, false); + } + get refDistance() { + return this._refDistance; + } + set rollOffFactor(value) { + this._rollOffFactor = value; + this._updateSoundInstances("rollOffFactor", value, false); + } + get rollOffFactor() { + return this._rollOffFactor; + } + set pitch(value) { + this._pitch = value; + this._updateSoundInstances("pitch", value, true); + } + get pitch() { + return this._pitch; + } + set volume(value) { + this._volume = value; + this._updateSoundInstances("volume", value, true); + } + get volume() { + return this._volume; + } + set positional(newValue) { + this._positional = newValue; + const slots = this._slots; + for (const key in slots) { + const slot = slots[key]; + if (!slot.overlap) { + const instances = slot.instances; + const oldLength = instances.length; + for (let i = oldLength - 1; i >= 0; i--) { + const isPlaying = instances[i].isPlaying || instances[i].isSuspended; + const currentTime = instances[i].currentTime; + if (isPlaying) instances[i].stop(); + const instance = slot._createInstance(); + if (isPlaying) { + instance.play(); + instance.currentTime = currentTime; + } + instances.push(instance); + } + } + } + } + get positional() { + return this._positional; + } + set slots(newValue) { + const oldValue = this._slots; + if (oldValue) { + for (const key in oldValue) { + oldValue[key].stop(); + } + } + const slots = {}; + for (const key in newValue) { + if (!(newValue[key] instanceof SoundSlot)) { + if (newValue[key].name) { + slots[newValue[key].name] = new SoundSlot(this, newValue[key].name, newValue[key]); + } + } else { + slots[newValue[key].name] = newValue[key]; + } + } + this._slots = slots; + if (this.enabled && this.entity.enabled) this.onEnable(); + } + get slots() { + return this._slots; + } + onEnable() { + if (this.system._inTools) { + return; + } + const slots = this._slots; + const playingBeforeDisable = this._playingBeforeDisable; + for (const key in slots) { + const slot = slots[key]; + if (slot.autoPlay && slot.isStopped) { + slot.play(); + } else if (playingBeforeDisable[key]) { + slot.resume(); + } else if (!slot.isLoaded) { + slot.load(); + } + } + } + onDisable() { + const slots = this._slots; + const playingBeforeDisable = {}; + for (const key in slots) { + if (!slots[key].overlap) { + if (slots[key].isPlaying) { + slots[key].pause(); + playingBeforeDisable[key] = true; + } + } + } + this._playingBeforeDisable = playingBeforeDisable; + } + onRemove() { + this.off(); + } + addSlot(name, options) { + const slots = this._slots; + if (slots[name]) { + return null; + } + const slot = new SoundSlot(this, name, options); + slots[name] = slot; + if (slot.autoPlay && this.enabled && this.entity.enabled) { + slot.play(); + } + return slot; + } + removeSlot(name) { + const slots = this._slots; + if (slots[name]) { + slots[name].stop(); + delete slots[name]; + } + } + slot(name) { + return this._slots[name]; + } + _getSlotProperty(name, property) { + if (!this.enabled || !this.entity.enabled) { + return void 0; + } + const slot = this._slots[name]; + if (!slot) { + return void 0; + } + return slot[property]; + } + isPlaying(name) { + return this._getSlotProperty(name, "isPlaying") || false; + } + isLoaded(name) { + return this._getSlotProperty(name, "isLoaded") || false; + } + isPaused(name) { + return this._getSlotProperty(name, "isPaused") || false; + } + isStopped(name) { + return this._getSlotProperty(name, "isStopped") || false; + } + play(name) { + if (!this.enabled || !this.entity.enabled) { + return null; + } + const slot = this._slots[name]; + if (!slot) { + return null; + } + return slot.play(); + } + pause(name) { + const slots = this._slots; + if (name) { + const slot = slots[name]; + if (!slot) { + return; + } + slot.pause(); + } else { + for (const key in slots) { + slots[key].pause(); + } + } + } + resume(name) { + const slots = this._slots; + if (name) { + const slot = slots[name]; + if (!slot) { + return; + } + if (slot.isPaused) { + slot.resume(); + } + } else { + for (const key in slots) { + slots[key].resume(); + } + } + } + stop(name) { + const slots = this._slots; + if (name) { + const slot = slots[name]; + if (!slot) { + return; + } + slot.stop(); + } else { + for (const key in slots) { + slots[key].stop(); + } + } + } +}; +SoundComponent.EVENT_PLAY = "play"; +SoundComponent.EVENT_PAUSE = "pause"; +SoundComponent.EVENT_RESUME = "resume"; +SoundComponent.EVENT_STOP = "stop"; +SoundComponent.EVENT_END = "end"; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/components/sound/data.js +var SoundComponentData = class { + constructor() { + this.enabled = true; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/components/sound/system.js +var _schema7 = ["enabled"]; +var SoundComponentSystem = class extends ComponentSystem { + constructor(app2) { + super(app2); + this.id = "sound"; + this.ComponentType = SoundComponent; + this.DataType = SoundComponentData; + this.schema = _schema7; + this.manager = app2.soundManager; + this.app.systems.on("update", this.onUpdate, this); + this.on("beforeremove", this.onBeforeRemove, this); + } + set volume(volume) { + this.manager.volume = volume; + } + get volume() { + return this.manager.volume; + } + get context() { + if (!hasAudioContext()) { + return null; + } + return this.manager.context; + } + initializeComponentData(component, data2, properties2) { + properties2 = ["volume", "pitch", "positional", "refDistance", "maxDistance", "rollOffFactor", "distanceModel", "slots"]; + for (let i = 0; i < properties2.length; i++) { + if (data2.hasOwnProperty(properties2[i])) { + component[properties2[i]] = data2[properties2[i]]; + } + } + super.initializeComponentData(component, data2, ["enabled"]); + } + cloneComponent(entity, clone) { + const srcComponent = entity.sound; + const srcSlots = srcComponent.slots; + const slots = {}; + for (const key in srcSlots) { + const srcSlot = srcSlots[key]; + slots[key] = { + name: srcSlot.name, + volume: srcSlot.volume, + pitch: srcSlot.pitch, + loop: srcSlot.loop, + duration: srcSlot.duration, + startTime: srcSlot.startTime, + overlap: srcSlot.overlap, + autoPlay: srcSlot.autoPlay, + asset: srcSlot.asset + }; + } + const cloneData = { + distanceModel: srcComponent.distanceModel, + enabled: srcComponent.enabled, + maxDistance: srcComponent.maxDistance, + pitch: srcComponent.pitch, + positional: srcComponent.positional, + refDistance: srcComponent.refDistance, + rollOffFactor: srcComponent.rollOffFactor, + slots, + volume: srcComponent.volume + }; + return this.addComponent(clone, cloneData); + } + onUpdate(dt) { + const store = this.store; + for (const id12 in store) { + if (store.hasOwnProperty(id12)) { + const item = store[id12]; + const entity = item.entity; + if (entity.enabled) { + const component = entity.sound; + if (component.enabled && component.positional) { + const position2 = entity.getPosition(); + const slots = component.slots; + for (const key in slots) { + slots[key].updatePosition(position2); + } + } + } + } + } + } + onBeforeRemove(entity, component) { + const slots = component.slots; + for (const key in slots) { + if (!slots[key].overlap) { + slots[key].stop(); + } + } + component.onRemove(); + } + destroy() { + super.destroy(); + this.app.systems.off("update", this.onUpdate, this); + } +}; +Component._buildAccessors(SoundComponent.prototype, _schema7); + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/components/camera/post-effect-queue.js +var PostEffectEntry = class { + constructor(effect, inputTarget) { + this.effect = effect; + this.inputTarget = inputTarget; + this.outputTarget = null; + this.name = effect.constructor.name; + } +}; +var PostEffectQueue = class { + constructor(app2, camera) { + this.app = app2; + this.camera = camera; + this.destinationRenderTarget = null; + this.effects = []; + this.enabled = false; + this.depthTarget = null; + camera.on("set:rect", this.onCameraRectChanged, this); + } + _allocateColorBuffer(format, name) { + var _renderTarget$width, _renderTarget$height; + const rect = this.camera.rect; + const renderTarget = this.destinationRenderTarget; + const device = this.app.graphicsDevice; + const width = Math.floor(rect.z * ((_renderTarget$width = renderTarget == null ? void 0 : renderTarget.width) != null ? _renderTarget$width : device.width)); + const height = Math.floor(rect.w * ((_renderTarget$height = renderTarget == null ? void 0 : renderTarget.height) != null ? _renderTarget$height : device.height)); + const colorBuffer = new Texture(device, { + name, + format, + width, + height, + mipmaps: false, + minFilter: FILTER_NEAREST, + magFilter: FILTER_NEAREST, + addressU: ADDRESS_CLAMP_TO_EDGE, + addressV: ADDRESS_CLAMP_TO_EDGE + }); + return colorBuffer; + } + _createOffscreenTarget(useDepth, hdr) { + const device = this.app.graphicsDevice; + const format = hdr && device.getRenderableHdrFormat([PIXELFORMAT_RGBA16F, PIXELFORMAT_RGBA32F], true) || PIXELFORMAT_RGBA8; + const name = this.camera.entity.name + "-posteffect-" + this.effects.length; + const colorBuffer = this._allocateColorBuffer(format, name); + return new RenderTarget({ + colorBuffer, + depth: useDepth, + stencil: useDepth && this.app.graphicsDevice.supportsStencil, + samples: useDepth ? device.samples : 1 + }); + } + _resizeOffscreenTarget(rt) { + const format = rt.colorBuffer.format; + const name = rt.colorBuffer.name; + rt.destroyFrameBuffers(); + rt.destroyTextureBuffers(); + rt._colorBuffer = this._allocateColorBuffer(format, name); + rt._colorBuffers = [rt._colorBuffer]; + } + _destroyOffscreenTarget(rt) { + rt.destroyTextureBuffers(); + rt.destroy(); + } + addEffect(effect) { + const effects = this.effects; + const isFirstEffect = effects.length === 0; + const inputTarget = this._createOffscreenTarget(isFirstEffect, effect.hdr); + const newEntry = new PostEffectEntry(effect, inputTarget); + effects.push(newEntry); + this._sourceTarget = newEntry.inputTarget; + if (effects.length > 1) { + effects[effects.length - 2].outputTarget = newEntry.inputTarget; + } + this._newPostEffect = effect; + if (effect.needsDepthBuffer) { + this._requestDepthMap(); + } + this.enable(); + this._newPostEffect = void 0; + } + removeEffect(effect) { + let index = -1; + for (let i = 0, len = this.effects.length; i < len; i++) { + if (this.effects[i].effect === effect) { + index = i; + break; + } + } + if (index >= 0) { + if (index > 0) { + this.effects[index - 1].outputTarget = index + 1 < this.effects.length ? this.effects[index + 1].inputTarget : null; + } else { + if (this.effects.length > 1) { + if (!this.effects[1].inputTarget._depth) { + this._destroyOffscreenTarget(this.effects[1].inputTarget); + this.effects[1].inputTarget = this._createOffscreenTarget(true, this.effects[1].hdr); + this._sourceTarget = this.effects[1].inputTarget; + } + this.camera.renderTarget = this.effects[1].inputTarget; + } + } + this._destroyOffscreenTarget(this.effects[index].inputTarget); + this.effects.splice(index, 1); + } + if (this.enabled) { + if (effect.needsDepthBuffer) { + this._releaseDepthMap(); + } + } + if (this.effects.length === 0) { + this.disable(); + } + } + _requestDepthMaps() { + for (let i = 0, len = this.effects.length; i < len; i++) { + const effect = this.effects[i].effect; + if (this._newPostEffect === effect) continue; + if (effect.needsDepthBuffer) { + this._requestDepthMap(); + } + } + } + _releaseDepthMaps() { + for (let i = 0, len = this.effects.length; i < len; i++) { + const effect = this.effects[i].effect; + if (effect.needsDepthBuffer) { + this._releaseDepthMap(); + } + } + } + _requestDepthMap() { + const depthLayer = this.app.scene.layers.getLayerById(LAYERID_DEPTH); + if (depthLayer) { + depthLayer.incrementCounter(); + this.camera.requestSceneDepthMap(true); + } + } + _releaseDepthMap() { + const depthLayer = this.app.scene.layers.getLayerById(LAYERID_DEPTH); + if (depthLayer) { + depthLayer.decrementCounter(); + this.camera.requestSceneDepthMap(false); + } + } + destroy() { + for (let i = 0, len = this.effects.length; i < len; i++) { + this.effects[i].inputTarget.destroy(); + } + this.effects.length = 0; + this.disable(); + } + enable() { + if (!this.enabled && this.effects.length) { + this.enabled = true; + this._requestDepthMaps(); + this.app.graphicsDevice.on("resizecanvas", this._onCanvasResized, this); + this.destinationRenderTarget = this.camera.renderTarget; + this.camera.renderTarget = this.effects[0].inputTarget; + this.camera.onPostprocessing = () => { + if (this.enabled) { + let rect = null; + const len = this.effects.length; + if (len) { + for (let i = 0; i < len; i++) { + const fx = this.effects[i]; + let destTarget = fx.outputTarget; + if (i === len - 1) { + rect = this.camera.rect; + if (this.destinationRenderTarget) { + destTarget = this.destinationRenderTarget; + } + } + fx.effect.render(fx.inputTarget, destTarget, rect); + } + } + } + }; + } + } + disable() { + if (this.enabled) { + this.enabled = false; + this.app.graphicsDevice.off("resizecanvas", this._onCanvasResized, this); + this._releaseDepthMaps(); + this._destroyOffscreenTarget(this._sourceTarget); + this.camera.renderTarget = null; + this.camera.onPostprocessing = null; + } + } + _onCanvasResized(width, height) { + var _renderTarget$width2, _renderTarget$height2; + const rect = this.camera.rect; + const renderTarget = this.destinationRenderTarget; + width = (_renderTarget$width2 = renderTarget == null ? void 0 : renderTarget.width) != null ? _renderTarget$width2 : width; + height = (_renderTarget$height2 = renderTarget == null ? void 0 : renderTarget.height) != null ? _renderTarget$height2 : height; + this.camera.camera.aspectRatio = width * rect.z / (height * rect.w); + this.resizeRenderTargets(); + } + resizeRenderTargets() { + var _renderTarget$width3, _renderTarget$height3; + const device = this.app.graphicsDevice; + const renderTarget = this.destinationRenderTarget; + const width = (_renderTarget$width3 = renderTarget == null ? void 0 : renderTarget.width) != null ? _renderTarget$width3 : device.width; + const height = (_renderTarget$height3 = renderTarget == null ? void 0 : renderTarget.height) != null ? _renderTarget$height3 : device.height; + const rect = this.camera.rect; + const desiredWidth = Math.floor(rect.z * width); + const desiredHeight = Math.floor(rect.w * height); + const effects = this.effects; + for (let i = 0, len = effects.length; i < len; i++) { + const fx = effects[i]; + if (fx.inputTarget.width !== desiredWidth || fx.inputTarget.height !== desiredHeight) { + this._resizeOffscreenTarget(fx.inputTarget); + } + } + } + onCameraRectChanged(name, oldValue, newValue) { + if (this.enabled) { + this.resizeRenderTargets(); + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/components/camera/component.js +var CameraComponent = class extends Component { + constructor(system, entity) { + super(system, entity); + this.onPostprocessing = null; + this.onPreRender = null; + this.onPostRender = null; + this._renderSceneDepthMap = 0; + this._renderSceneColorMap = 0; + this._sceneDepthMapRequested = false; + this._sceneColorMapRequested = false; + this._priority = 0; + this._disablePostEffectsLayer = LAYERID_UI; + this._camera = new Camera(); + this._camera.node = entity; + this._postEffects = new PostEffectQueue(system.app, this); + } + setShaderPass(name) { + const shaderPass = ShaderPass.get(this.system.app.graphicsDevice); + const shaderPassInfo = name ? shaderPass.allocate(name, { + isForward: true + }) : null; + this._camera.shaderPassInfo = shaderPassInfo; + return shaderPassInfo.index; + } + getShaderPass() { + var _this$_camera$shaderP; + return (_this$_camera$shaderP = this._camera.shaderPassInfo) == null ? void 0 : _this$_camera$shaderP.name; + } + set renderPasses(passes) { + this._camera.renderPasses = passes; + } + get renderPasses() { + return this._camera.renderPasses; + } + set aperture(value) { + this._camera.aperture = value; + } + get aperture() { + return this._camera.aperture; + } + set aspectRatio(value) { + this._camera.aspectRatio = value; + } + get aspectRatio() { + return this._camera.aspectRatio; + } + set aspectRatioMode(value) { + this._camera.aspectRatioMode = value; + } + get aspectRatioMode() { + return this._camera.aspectRatioMode; + } + set calculateProjection(value) { + this._camera.calculateProjection = value; + } + get calculateProjection() { + return this._camera.calculateProjection; + } + set calculateTransform(value) { + this._camera.calculateTransform = value; + } + get calculateTransform() { + return this._camera.calculateTransform; + } + get camera() { + return this._camera; + } + set clearColor(value) { + this._camera.clearColor = value; + } + get clearColor() { + return this._camera.clearColor; + } + set clearColorBuffer(value) { + this._camera.clearColorBuffer = value; + this.dirtyLayerCompositionCameras(); + } + get clearColorBuffer() { + return this._camera.clearColorBuffer; + } + set clearDepthBuffer(value) { + this._camera.clearDepthBuffer = value; + this.dirtyLayerCompositionCameras(); + } + get clearDepthBuffer() { + return this._camera.clearDepthBuffer; + } + set clearStencilBuffer(value) { + this._camera.clearStencilBuffer = value; + this.dirtyLayerCompositionCameras(); + } + get clearStencilBuffer() { + return this._camera.clearStencilBuffer; + } + set cullFaces(value) { + this._camera.cullFaces = value; + } + get cullFaces() { + return this._camera.cullFaces; + } + set disablePostEffectsLayer(layer) { + this._disablePostEffectsLayer = layer; + this.dirtyLayerCompositionCameras(); + } + get disablePostEffectsLayer() { + return this._disablePostEffectsLayer; + } + set farClip(value) { + this._camera.farClip = value; + } + get farClip() { + return this._camera.farClip; + } + set flipFaces(value) { + this._camera.flipFaces = value; + } + get flipFaces() { + return this._camera.flipFaces; + } + set fov(value) { + this._camera.fov = value; + } + get fov() { + return this._camera.fov; + } + get frustum() { + return this._camera.frustum; + } + set frustumCulling(value) { + this._camera.frustumCulling = value; + } + get frustumCulling() { + return this._camera.frustumCulling; + } + set horizontalFov(value) { + this._camera.horizontalFov = value; + } + get horizontalFov() { + return this._camera.horizontalFov; + } + set layers(newValue) { + const layers = this._camera.layers; + for (let i = 0; i < layers.length; i++) { + const layer = this.system.app.scene.layers.getLayerById(layers[i]); + if (!layer) continue; + layer.removeCamera(this); + } + this._camera.layers = newValue; + if (!this.enabled || !this.entity.enabled) return; + for (let i = 0; i < newValue.length; i++) { + const layer = this.system.app.scene.layers.getLayerById(newValue[i]); + if (!layer) continue; + layer.addCamera(this); + } + } + get layers() { + return this._camera.layers; + } + get layersSet() { + return this._camera.layersSet; + } + set jitter(value) { + this._camera.jitter = value; + } + get jitter() { + return this._camera.jitter; + } + set nearClip(value) { + this._camera.nearClip = value; + } + get nearClip() { + return this._camera.nearClip; + } + set orthoHeight(value) { + this._camera.orthoHeight = value; + } + get orthoHeight() { + return this._camera.orthoHeight; + } + get postEffects() { + return this._postEffects; + } + get postEffectsEnabled() { + return this._postEffects.enabled; + } + set priority(newValue) { + this._priority = newValue; + this.dirtyLayerCompositionCameras(); + } + get priority() { + return this._priority; + } + set projection(value) { + this._camera.projection = value; + } + get projection() { + return this._camera.projection; + } + get projectionMatrix() { + return this._camera.projectionMatrix; + } + set rect(value) { + this._camera.rect = value; + this.fire("set:rect", this._camera.rect); + } + get rect() { + return this._camera.rect; + } + set renderSceneColorMap(value) { + if (value && !this._sceneColorMapRequested) { + this.requestSceneColorMap(true); + this._sceneColorMapRequested = true; + } else if (this._sceneColorMapRequested) { + this.requestSceneColorMap(false); + this._sceneColorMapRequested = false; + } + } + get renderSceneColorMap() { + return this._renderSceneColorMap > 0; + } + set renderSceneDepthMap(value) { + if (value && !this._sceneDepthMapRequested) { + this.requestSceneDepthMap(true); + this._sceneDepthMapRequested = true; + } else if (this._sceneDepthMapRequested) { + this.requestSceneDepthMap(false); + this._sceneDepthMapRequested = false; + } + } + get renderSceneDepthMap() { + return this._renderSceneDepthMap > 0; + } + set renderTarget(value) { + this._camera.renderTarget = value; + this.dirtyLayerCompositionCameras(); + } + get renderTarget() { + return this._camera.renderTarget; + } + set scissorRect(value) { + this._camera.scissorRect = value; + } + get scissorRect() { + return this._camera.scissorRect; + } + set sensitivity(value) { + this._camera.sensitivity = value; + } + get sensitivity() { + return this._camera.sensitivity; + } + set shutter(value) { + this._camera.shutter = value; + } + get shutter() { + return this._camera.shutter; + } + get viewMatrix() { + return this._camera.viewMatrix; + } + _enableDepthLayer(value) { + const hasDepthLayer = this.layers.find((layerId) => layerId === LAYERID_DEPTH); + if (hasDepthLayer) { + const depthLayer = this.system.app.scene.layers.getLayerById(LAYERID_DEPTH); + if (value) { + depthLayer == null || depthLayer.incrementCounter(); + } else { + depthLayer == null || depthLayer.decrementCounter(); + } + } else if (value) { + return false; + } + return true; + } + requestSceneColorMap(enabled) { + this._renderSceneColorMap += enabled ? 1 : -1; + this._enableDepthLayer(enabled); + this.camera._enableRenderPassColorGrab(this.system.app.graphicsDevice, this.renderSceneColorMap); + } + requestSceneDepthMap(enabled) { + this._renderSceneDepthMap += enabled ? 1 : -1; + this._enableDepthLayer(enabled); + this.camera._enableRenderPassDepthGrab(this.system.app.graphicsDevice, this.system.app.renderer, this.renderSceneDepthMap); + } + dirtyLayerCompositionCameras() { + const layerComp = this.system.app.scene.layers; + layerComp._dirty = true; + } + screenToWorld(screenx, screeny, cameraz, worldCoord) { + const device = this.system.app.graphicsDevice; + const w = device.clientRect.width; + const h = device.clientRect.height; + return this._camera.screenToWorld(screenx, screeny, cameraz, w, h, worldCoord); + } + worldToScreen(worldCoord, screenCoord) { + const device = this.system.app.graphicsDevice; + const w = device.clientRect.width; + const h = device.clientRect.height; + return this._camera.worldToScreen(worldCoord, w, h, screenCoord); + } + onAppPrerender() { + this._camera._viewMatDirty = true; + this._camera._viewProjMatDirty = true; + } + addCameraToLayers() { + const layers = this.layers; + for (let i = 0; i < layers.length; i++) { + const layer = this.system.app.scene.layers.getLayerById(layers[i]); + if (layer) { + layer.addCamera(this); + } + } + } + removeCameraFromLayers() { + const layers = this.layers; + for (let i = 0; i < layers.length; i++) { + const layer = this.system.app.scene.layers.getLayerById(layers[i]); + if (layer) { + layer.removeCamera(this); + } + } + } + onLayersChanged(oldComp, newComp) { + this.addCameraToLayers(); + oldComp.off("add", this.onLayerAdded, this); + oldComp.off("remove", this.onLayerRemoved, this); + newComp.on("add", this.onLayerAdded, this); + newComp.on("remove", this.onLayerRemoved, this); + } + onLayerAdded(layer) { + const index = this.layers.indexOf(layer.id); + if (index < 0) return; + layer.addCamera(this); + } + onLayerRemoved(layer) { + const index = this.layers.indexOf(layer.id); + if (index < 0) return; + layer.removeCamera(this); + } + onEnable() { + const system = this.system; + const scene2 = system.app.scene; + const layers = scene2.layers; + system.addCamera(this); + scene2.on("set:layers", this.onLayersChanged, this); + if (layers) { + layers.on("add", this.onLayerAdded, this); + layers.on("remove", this.onLayerRemoved, this); + } + if (this.enabled && this.entity.enabled) { + this.addCameraToLayers(); + } + this.postEffects.enable(); + } + onDisable() { + const system = this.system; + const scene2 = system.app.scene; + const layers = scene2.layers; + this.postEffects.disable(); + this.removeCameraFromLayers(); + scene2.off("set:layers", this.onLayersChanged, this); + if (layers) { + layers.off("add", this.onLayerAdded, this); + layers.off("remove", this.onLayerRemoved, this); + } + system.removeCamera(this); + } + onRemove() { + this.onDisable(); + this.off(); + this.camera.destroy(); + } + calculateAspectRatio(rt) { + const device = this.system.app.graphicsDevice; + const width = rt ? rt.width : device.width; + const height = rt ? rt.height : device.height; + return width * this.rect.z / (height * this.rect.w); + } + frameUpdate(rt) { + if (this.aspectRatioMode === ASPECT_AUTO) { + this.aspectRatio = this.calculateAspectRatio(rt); + } + } + startXr(type2, spaceType, options) { + this.system.app.xr.start(this, type2, spaceType, options); + } + endXr(callback) { + if (!this._camera.xr) { + if (callback) callback(new Error("Camera is not in XR")); + return; + } + this._camera.xr.end(callback); + } + copy(source) { + this.aperture = source.aperture; + this.aspectRatio = source.aspectRatio; + this.aspectRatioMode = source.aspectRatioMode; + this.calculateProjection = source.calculateProjection; + this.calculateTransform = source.calculateTransform; + this.clearColor = source.clearColor; + this.clearColorBuffer = source.clearColorBuffer; + this.clearDepthBuffer = source.clearDepthBuffer; + this.clearStencilBuffer = source.clearStencilBuffer; + this.cullFaces = source.cullFaces; + this.disablePostEffectsLayer = source.disablePostEffectsLayer; + this.farClip = source.farClip; + this.flipFaces = source.flipFaces; + this.fov = source.fov; + this.frustumCulling = source.frustumCulling; + this.horizontalFov = source.horizontalFov; + this.layers = source.layers; + this.nearClip = source.nearClip; + this.orthoHeight = source.orthoHeight; + this.priority = source.priority; + this.projection = source.projection; + this.rect = source.rect; + this.renderTarget = source.renderTarget; + this.scissorRect = source.scissorRect; + this.sensitivity = source.sensitivity; + this.shutter = source.shutter; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/components/camera/data.js +var CameraComponentData = class { + constructor() { + this.enabled = true; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/components/camera/system.js +var _schema8 = ["enabled"]; +var CameraComponentSystem = class extends ComponentSystem { + constructor(app2) { + super(app2); + this.cameras = []; + this.id = "camera"; + this.ComponentType = CameraComponent; + this.DataType = CameraComponentData; + this.schema = _schema8; + this.on("beforeremove", this.onBeforeRemove, this); + this.app.on("prerender", this.onAppPrerender, this); + this.app.systems.on("update", this.onUpdate, this); + } + initializeComponentData(component, data2, properties2) { + properties2 = ["aspectRatio", "aspectRatioMode", "calculateProjection", "calculateTransform", "clearColor", "clearColorBuffer", "clearDepthBuffer", "clearStencilBuffer", "renderSceneColorMap", "renderSceneDepthMap", "cullFaces", "farClip", "flipFaces", "fov", "frustumCulling", "horizontalFov", "layers", "renderTarget", "nearClip", "orthoHeight", "projection", "priority", "rect", "scissorRect", "aperture", "shutter", "sensitivity"]; + for (let i = 0; i < properties2.length; i++) { + const property = properties2[i]; + if (data2.hasOwnProperty(property)) { + const value = data2[property]; + switch (property) { + case "rect": + case "scissorRect": + if (Array.isArray(value)) { + component[property] = new Vec4(value[0], value[1], value[2], value[3]); + } else { + component[property] = value; + } + break; + case "clearColor": + if (Array.isArray(value)) { + component[property] = new Color(value[0], value[1], value[2], value[3]); + } else { + component[property] = value; + } + break; + default: + component[property] = value; + break; + } + } + } + super.initializeComponentData(component, data2, ["enabled"]); + } + cloneComponent(entity, clone) { + const c2 = entity.camera; + return this.addComponent(clone, { + aspectRatio: c2.aspectRatio, + aspectRatioMode: c2.aspectRatioMode, + calculateProjection: c2.calculateProjection, + calculateTransform: c2.calculateTransform, + clearColor: c2.clearColor, + clearColorBuffer: c2.clearColorBuffer, + clearDepthBuffer: c2.clearDepthBuffer, + clearStencilBuffer: c2.clearStencilBuffer, + renderSceneDepthMap: c2.renderSceneDepthMap, + renderSceneColorMap: c2.renderSceneColorMap, + cullFaces: c2.cullFaces, + enabled: c2.enabled, + farClip: c2.farClip, + flipFaces: c2.flipFaces, + fov: c2.fov, + frustumCulling: c2.frustumCulling, + horizontalFov: c2.horizontalFov, + layers: c2.layers, + renderTarget: c2.renderTarget, + nearClip: c2.nearClip, + orthoHeight: c2.orthoHeight, + projection: c2.projection, + priority: c2.priority, + rect: c2.rect, + scissorRect: c2.scissorRect, + aperture: c2.aperture, + sensitivity: c2.sensitivity, + shutter: c2.shutter + }); + } + onBeforeRemove(entity, component) { + this.removeCamera(component); + component.onRemove(); + } + onUpdate(dt) { + } + onAppPrerender() { + for (let i = 0, len = this.cameras.length; i < len; i++) { + this.cameras[i].onAppPrerender(); + } + } + addCamera(camera) { + this.cameras.push(camera); + sortPriority(this.cameras); + } + removeCamera(camera) { + const index = this.cameras.indexOf(camera); + if (index >= 0) { + this.cameras.splice(index, 1); + sortPriority(this.cameras); + } + } + destroy() { + super.destroy(); + this.app.systems.off("update", this.onUpdate, this); + } +}; +Component._buildAccessors(CameraComponent.prototype, _schema8); + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/components/light/data.js +var LightComponentData = class { + constructor() { + this.enabled = true; + this.light = void 0; + this.type = "directional"; + this.color = new Color(1, 1, 1); + this.intensity = 1; + this.luminance = 0; + this.shape = LIGHTSHAPE_PUNCTUAL; + this.affectSpecularity = true; + this.castShadows = false; + this.shadowDistance = 40; + this.shadowIntensity = 1; + this.shadowResolution = 1024; + this.shadowBias = 0.05; + this.numCascades = 1; + this.bakeNumSamples = 1; + this.bakeArea = 0; + this.cascadeDistribution = 0.5; + this.normalOffsetBias = 0; + this.range = 10; + this.innerConeAngle = 40; + this.outerConeAngle = 45; + this.falloffMode = LIGHTFALLOFF_LINEAR; + this.shadowType = SHADOW_PCF3; + this.vsmBlurSize = 11; + this.vsmBlurMode = BLUR_GAUSSIAN; + this.vsmBias = 0.01 * 0.25; + this.cookieAsset = null; + this.cookie = null; + this.cookieIntensity = 1; + this.cookieFalloff = true; + this.cookieChannel = "rgb"; + this.cookieAngle = 0; + this.cookieScale = null; + this.cookieOffset = null; + this.shadowUpdateMode = SHADOWUPDATE_REALTIME; + this.mask = 1; + this.affectDynamic = true; + this.affectLightmapped = false; + this.bake = false; + this.bakeDir = true; + this.isStatic = false; + this.layers = [LAYERID_WORLD]; + this.penumbraSize = 1; + } +}; +var properties = Object.keys(new LightComponentData()); + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/components/light/component.js +var LightComponent = class extends Component { + constructor(system, entity) { + super(system, entity); + this._cookieAsset = null; + this._cookieAssetId = null; + this._cookieAssetAdd = false; + this._cookieMatrix = null; + } + get data() { + const record = this.system.store[this.entity.getGuid()]; + return record ? record.data : null; + } + set enabled(arg) { + this._setValue("enabled", arg, function(newValue, oldValue) { + this.onSetEnabled(null, oldValue, newValue); + }); + } + get enabled() { + return this.data.enabled; + } + set light(arg) { + this._setValue("light", arg); + } + get light() { + return this.data.light; + } + set type(arg) { + this._setValue("type", arg, function(newValue, oldValue) { + this.system.changeType(this, oldValue, newValue); + this.refreshProperties(); + }); + } + get type() { + return this.data.type; + } + set color(arg) { + this._setValue("color", arg, function(newValue, oldValue) { + this.light.setColor(newValue); + }, true); + } + get color() { + return this.data.color; + } + set intensity(arg) { + this._setValue("intensity", arg, function(newValue, oldValue) { + this.light.intensity = newValue; + }); + } + get intensity() { + return this.data.intensity; + } + set luminance(arg) { + this._setValue("luminance", arg, function(newValue, oldValue) { + this.light.luminance = newValue; + }); + } + get luminance() { + return this.data.luminance; + } + set shape(arg) { + this._setValue("shape", arg, function(newValue, oldValue) { + this.light.shape = newValue; + }); + } + get shape() { + return this.data.shape; + } + set affectSpecularity(arg) { + this._setValue("affectSpecularity", arg, function(newValue, oldValue) { + this.light.affectSpecularity = newValue; + }); + } + get affectSpecularity() { + return this.data.affectSpecularity; + } + set castShadows(arg) { + this._setValue("castShadows", arg, function(newValue, oldValue) { + this.light.castShadows = newValue; + }); + } + get castShadows() { + return this.data.castShadows; + } + set shadowDistance(arg) { + this._setValue("shadowDistance", arg, function(newValue, oldValue) { + this.light.shadowDistance = newValue; + }); + } + get shadowDistance() { + return this.data.shadowDistance; + } + set shadowIntensity(arg) { + this._setValue("shadowIntensity", arg, function(newValue, oldValue) { + this.light.shadowIntensity = newValue; + }); + } + get shadowIntensity() { + return this.data.shadowIntensity; + } + set shadowResolution(arg) { + this._setValue("shadowResolution", arg, function(newValue, oldValue) { + this.light.shadowResolution = newValue; + }); + } + get shadowResolution() { + return this.data.shadowResolution; + } + set shadowBias(arg) { + this._setValue("shadowBias", arg, function(newValue, oldValue) { + this.light.shadowBias = -0.01 * math.clamp(newValue, 0, 1); + }); + } + get shadowBias() { + return this.data.shadowBias; + } + set numCascades(arg) { + this._setValue("numCascades", arg, function(newValue, oldValue) { + this.light.numCascades = math.clamp(Math.floor(newValue), 1, 4); + }); + } + get numCascades() { + return this.data.numCascades; + } + set bakeNumSamples(arg) { + this._setValue("bakeNumSamples", arg, function(newValue, oldValue) { + this.light.bakeNumSamples = math.clamp(Math.floor(newValue), 1, 255); + }); + } + get bakeNumSamples() { + return this.data.bakeNumSamples; + } + set bakeArea(arg) { + this._setValue("bakeArea", arg, function(newValue, oldValue) { + this.light.bakeArea = math.clamp(newValue, 0, 180); + }); + } + get bakeArea() { + return this.data.bakeArea; + } + set cascadeDistribution(arg) { + this._setValue("cascadeDistribution", arg, function(newValue, oldValue) { + this.light.cascadeDistribution = math.clamp(newValue, 0, 1); + }); + } + get cascadeDistribution() { + return this.data.cascadeDistribution; + } + set normalOffsetBias(arg) { + this._setValue("normalOffsetBias", arg, function(newValue, oldValue) { + this.light.normalOffsetBias = math.clamp(newValue, 0, 1); + }); + } + get normalOffsetBias() { + return this.data.normalOffsetBias; + } + set range(arg) { + this._setValue("range", arg, function(newValue, oldValue) { + this.light.attenuationEnd = newValue; + }); + } + get range() { + return this.data.range; + } + set innerConeAngle(arg) { + this._setValue("innerConeAngle", arg, function(newValue, oldValue) { + this.light.innerConeAngle = newValue; + }); + } + get innerConeAngle() { + return this.data.innerConeAngle; + } + set outerConeAngle(arg) { + this._setValue("outerConeAngle", arg, function(newValue, oldValue) { + this.light.outerConeAngle = newValue; + }); + } + get outerConeAngle() { + return this.data.outerConeAngle; + } + set falloffMode(arg) { + this._setValue("falloffMode", arg, function(newValue, oldValue) { + this.light.falloffMode = newValue; + }); + } + get falloffMode() { + return this.data.falloffMode; + } + set shadowType(arg) { + this._setValue("shadowType", arg, function(newValue, oldValue) { + this.light.shadowType = newValue; + }); + } + get shadowType() { + return this.data.shadowType; + } + set vsmBlurSize(arg) { + this._setValue("vsmBlurSize", arg, function(newValue, oldValue) { + this.light.vsmBlurSize = newValue; + }); + } + get vsmBlurSize() { + return this.data.vsmBlurSize; + } + set vsmBlurMode(arg) { + this._setValue("vsmBlurMode", arg, function(newValue, oldValue) { + this.light.vsmBlurMode = newValue; + }); + } + get vsmBlurMode() { + return this.data.vsmBlurMode; + } + set vsmBias(arg) { + this._setValue("vsmBias", arg, function(newValue, oldValue) { + this.light.vsmBias = math.clamp(newValue, 0, 1); + }); + } + get vsmBias() { + return this.data.vsmBias; + } + set cookieAsset(arg) { + this._setValue("cookieAsset", arg, function(newValue, oldValue) { + if (this._cookieAssetId && (newValue instanceof Asset && newValue.id === this._cookieAssetId || newValue === this._cookieAssetId)) return; + this.onCookieAssetRemove(); + this._cookieAssetId = null; + if (newValue instanceof Asset) { + this.data.cookieAsset = newValue.id; + this._cookieAssetId = newValue.id; + this.onCookieAssetAdd(newValue); + } else if (typeof newValue === "number") { + this._cookieAssetId = newValue; + const asset2 = this.system.app.assets.get(newValue); + if (asset2) { + this.onCookieAssetAdd(asset2); + } else { + this._cookieAssetAdd = true; + this.system.app.assets.on("add:" + this._cookieAssetId, this.onCookieAssetAdd, this); + } + } + }); + } + get cookieAsset() { + return this.data.cookieAsset; + } + set cookie(arg) { + this._setValue("cookie", arg, function(newValue, oldValue) { + this.light.cookie = newValue; + }); + } + get cookie() { + return this.data.cookie; + } + set cookieIntensity(arg) { + this._setValue("cookieIntensity", arg, function(newValue, oldValue) { + this.light.cookieIntensity = math.clamp(newValue, 0, 1); + }); + } + get cookieIntensity() { + return this.data.cookieIntensity; + } + set cookieFalloff(arg) { + this._setValue("cookieFalloff", arg, function(newValue, oldValue) { + this.light.cookieFalloff = newValue; + }); + } + get cookieFalloff() { + return this.data.cookieFalloff; + } + set cookieChannel(arg) { + this._setValue("cookieChannel", arg, function(newValue, oldValue) { + this.light.cookieChannel = newValue; + }); + } + get cookieChannel() { + return this.data.cookieChannel; + } + set cookieAngle(arg) { + this._setValue("cookieAngle", arg, function(newValue, oldValue) { + if (newValue !== 0 || this.cookieScale !== null) { + if (!this._cookieMatrix) this._cookieMatrix = new Vec4(); + let scx = 1; + let scy = 1; + if (this.cookieScale) { + scx = this.cookieScale.x; + scy = this.cookieScale.y; + } + const c2 = Math.cos(newValue * math.DEG_TO_RAD); + const s = Math.sin(newValue * math.DEG_TO_RAD); + this._cookieMatrix.set(c2 / scx, -s / scx, s / scy, c2 / scy); + this.light.cookieTransform = this._cookieMatrix; + } else { + this.light.cookieTransform = null; + } + }); + } + get cookieAngle() { + return this.data.cookieAngle; + } + set cookieScale(arg) { + this._setValue("cookieScale", arg, function(newValue, oldValue) { + if (newValue !== null || this.cookieAngle !== 0) { + if (!this._cookieMatrix) this._cookieMatrix = new Vec4(); + const scx = newValue.x; + const scy = newValue.y; + const c2 = Math.cos(this.cookieAngle * math.DEG_TO_RAD); + const s = Math.sin(this.cookieAngle * math.DEG_TO_RAD); + this._cookieMatrix.set(c2 / scx, -s / scx, s / scy, c2 / scy); + this.light.cookieTransform = this._cookieMatrix; + } else { + this.light.cookieTransform = null; + } + }, true); + } + get cookieScale() { + return this.data.cookieScale; + } + set cookieOffset(arg) { + this._setValue("cookieOffset", arg, function(newValue, oldValue) { + this.light.cookieOffset = newValue; + }, true); + } + get cookieOffset() { + return this.data.cookieOffset; + } + set shadowUpdateMode(arg) { + this._setValue("shadowUpdateMode", arg, function(newValue, oldValue) { + this.light.shadowUpdateMode = newValue; + }, true); + } + get shadowUpdateMode() { + return this.data.shadowUpdateMode; + } + set mask(arg) { + this._setValue("mask", arg, function(newValue, oldValue) { + this.light.mask = newValue; + }); + } + get mask() { + return this.data.mask; + } + set affectDynamic(arg) { + this._setValue("affectDynamic", arg, function(newValue, oldValue) { + if (newValue) { + this.light.mask |= MASK_AFFECT_DYNAMIC; + } else { + this.light.mask &= ~MASK_AFFECT_DYNAMIC; + } + this.light.layersDirty(); + }); + } + get affectDynamic() { + return this.data.affectDynamic; + } + set affectLightmapped(arg) { + this._setValue("affectLightmapped", arg, function(newValue, oldValue) { + if (newValue) { + this.light.mask |= MASK_AFFECT_LIGHTMAPPED; + if (this.bake) this.light.mask &= ~MASK_BAKE; + } else { + this.light.mask &= ~MASK_AFFECT_LIGHTMAPPED; + if (this.bake) this.light.mask |= MASK_BAKE; + } + }); + } + get affectLightmapped() { + return this.data.affectLightmapped; + } + set bake(arg) { + this._setValue("bake", arg, function(newValue, oldValue) { + if (newValue) { + this.light.mask |= MASK_BAKE; + if (this.affectLightmapped) this.light.mask &= ~MASK_AFFECT_LIGHTMAPPED; + } else { + this.light.mask &= ~MASK_BAKE; + if (this.affectLightmapped) this.light.mask |= MASK_AFFECT_LIGHTMAPPED; + } + this.light.layersDirty(); + }); + } + get bake() { + return this.data.bake; + } + set bakeDir(arg) { + this._setValue("bakeDir", arg, function(newValue, oldValue) { + this.light.bakeDir = newValue; + }); + } + get bakeDir() { + return this.data.bakeDir; + } + set isStatic(arg) { + this._setValue("isStatic", arg, function(newValue, oldValue) { + this.light.isStatic = newValue; + }); + } + get isStatic() { + return this.data.isStatic; + } + set layers(arg) { + this._setValue("layers", arg, function(newValue, oldValue) { + for (let i = 0; i < oldValue.length; i++) { + const layer = this.system.app.scene.layers.getLayerById(oldValue[i]); + if (!layer) continue; + layer.removeLight(this); + this.light.removeLayer(layer); + } + for (let i = 0; i < newValue.length; i++) { + const layer = this.system.app.scene.layers.getLayerById(newValue[i]); + if (!layer) continue; + if (this.enabled && this.entity.enabled) { + layer.addLight(this); + this.light.addLayer(layer); + } + } + }); + } + get layers() { + return this.data.layers; + } + set shadowUpdateOverrides(values) { + this.light.shadowUpdateOverrides = values; + } + get shadowUpdateOverrides() { + return this.light.shadowUpdateOverrides; + } + set penumbraSize(value) { + this.light.penumbraSize = value; + } + get penumbraSize() { + return this.light.penumbraSize; + } + _setValue(name, value, setFunc, skipEqualsCheck) { + const data2 = this.data; + const oldValue = data2[name]; + if (!skipEqualsCheck && oldValue === value) return; + data2[name] = value; + if (setFunc) setFunc.call(this, value, oldValue); + } + addLightToLayers() { + for (let i = 0; i < this.layers.length; i++) { + const layer = this.system.app.scene.layers.getLayerById(this.layers[i]); + if (layer) { + layer.addLight(this); + this.light.addLayer(layer); + } + } + } + removeLightFromLayers() { + for (let i = 0; i < this.layers.length; i++) { + const layer = this.system.app.scene.layers.getLayerById(this.layers[i]); + if (layer) { + layer.removeLight(this); + this.light.removeLayer(layer); + } + } + } + onLayersChanged(oldComp, newComp) { + if (this.enabled && this.entity.enabled) { + this.addLightToLayers(); + } + oldComp.off("add", this.onLayerAdded, this); + oldComp.off("remove", this.onLayerRemoved, this); + newComp.on("add", this.onLayerAdded, this); + newComp.on("remove", this.onLayerRemoved, this); + } + onLayerAdded(layer) { + const index = this.layers.indexOf(layer.id); + if (index >= 0 && this.enabled && this.entity.enabled) { + layer.addLight(this); + this.light.addLayer(layer); + } + } + onLayerRemoved(layer) { + const index = this.layers.indexOf(layer.id); + if (index >= 0) { + layer.removeLight(this); + this.light.removeLayer(layer); + } + } + refreshProperties() { + for (let i = 0; i < properties.length; i++) { + const name = properties[i]; + this[name] = this[name]; + } + if (this.enabled && this.entity.enabled) { + this.onEnable(); + } + } + onCookieAssetSet() { + let forceLoad = false; + if (this._cookieAsset.type === "cubemap" && !this._cookieAsset.loadFaces) { + this._cookieAsset.loadFaces = true; + forceLoad = true; + } + if (!this._cookieAsset.resource || forceLoad) this.system.app.assets.load(this._cookieAsset); + if (this._cookieAsset.resource) { + this.onCookieAssetLoad(); + } + } + onCookieAssetAdd(asset2) { + if (this._cookieAssetId !== asset2.id) return; + this._cookieAsset = asset2; + if (this.light.enabled) { + this.onCookieAssetSet(); + } + this._cookieAsset.on("load", this.onCookieAssetLoad, this); + this._cookieAsset.on("remove", this.onCookieAssetRemove, this); + } + onCookieAssetLoad() { + if (!this._cookieAsset || !this._cookieAsset.resource) { + return; + } + this.cookie = this._cookieAsset.resource; + } + onCookieAssetRemove() { + if (!this._cookieAssetId) { + return; + } + if (this._cookieAssetAdd) { + this.system.app.assets.off("add:" + this._cookieAssetId, this.onCookieAssetAdd, this); + this._cookieAssetAdd = false; + } + if (this._cookieAsset) { + this._cookieAsset.off("load", this.onCookieAssetLoad, this); + this._cookieAsset.off("remove", this.onCookieAssetRemove, this); + this._cookieAsset = null; + } + this.cookie = null; + } + onEnable() { + this.light.enabled = true; + this.system.app.scene.on("set:layers", this.onLayersChanged, this); + if (this.system.app.scene.layers) { + this.system.app.scene.layers.on("add", this.onLayerAdded, this); + this.system.app.scene.layers.on("remove", this.onLayerRemoved, this); + } + if (this.enabled && this.entity.enabled) { + this.addLightToLayers(); + } + if (this._cookieAsset && !this.cookie) { + this.onCookieAssetSet(); + } + } + onDisable() { + this.light.enabled = false; + this.system.app.scene.off("set:layers", this.onLayersChanged, this); + if (this.system.app.scene.layers) { + this.system.app.scene.layers.off("add", this.onLayerAdded, this); + this.system.app.scene.layers.off("remove", this.onLayerRemoved, this); + } + this.removeLightFromLayers(); + } + onRemove() { + this.onDisable(); + this.light.destroy(); + this.cookieAsset = null; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/components/light/system.js +var LightComponentSystem = class extends ComponentSystem { + constructor(app2) { + super(app2); + this.id = "light"; + this.ComponentType = LightComponent; + this.DataType = LightComponentData; + this.on("beforeremove", this._onRemoveComponent, this); + } + initializeComponentData(component, _data) { + const data2 = _extends({}, _data); + if (!data2.type) data2.type = component.data.type; + component.data.type = data2.type; + if (data2.layers && Array.isArray(data2.layers)) { + data2.layers = data2.layers.slice(0); + } + if (data2.color && Array.isArray(data2.color)) data2.color = new Color(data2.color[0], data2.color[1], data2.color[2]); + if (data2.cookieOffset && data2.cookieOffset instanceof Array) data2.cookieOffset = new Vec2(data2.cookieOffset[0], data2.cookieOffset[1]); + if (data2.cookieScale && data2.cookieScale instanceof Array) data2.cookieScale = new Vec2(data2.cookieScale[0], data2.cookieScale[1]); + if (data2.enable) { + console.warn("WARNING: enable: Property is deprecated. Set enabled property instead."); + data2.enabled = data2.enable; + } + if (!data2.shape) { + data2.shape = LIGHTSHAPE_PUNCTUAL; + } + const light = new Light(this.app.graphicsDevice, this.app.scene.clusteredLightingEnabled); + light.type = lightTypes[data2.type]; + light._node = component.entity; + component.data.light = light; + super.initializeComponentData(component, data2, properties); + } + _onRemoveComponent(entity, component) { + component.onRemove(); + } + cloneComponent(entity, clone) { + const light = entity.light; + const data2 = []; + let name; + for (let i = 0; i < properties.length; i++) { + name = properties[i]; + if (name === "light") { + continue; + } + if (light[name] && light[name].clone) { + data2[name] = light[name].clone(); + } else { + data2[name] = light[name]; + } + } + return this.addComponent(clone, data2); + } + changeType(component, oldValue, newValue) { + if (oldValue !== newValue) { + component.light.type = lightTypes[newValue]; + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/scene/render.js +var Render = class extends EventHandler { + constructor() { + super(); + this._meshes = null; + } + set meshes(value) { + this.decRefMeshes(); + this._meshes = value; + this.incRefMeshes(); + this.fire("set:meshes", value); + } + get meshes() { + return this._meshes; + } + destroy() { + this.meshes = null; + } + decRefMeshes() { + if (this._meshes) { + const count = this._meshes.length; + for (let i = 0; i < count; i++) { + const mesh = this._meshes[i]; + if (mesh) { + mesh.decRefCount(); + if (mesh.refCount < 1) { + mesh.destroy(); + this._meshes[i] = null; + } + } + } + } + } + incRefMeshes() { + if (this._meshes) { + const count = this._meshes.length; + for (let i = 0; i < count; i++) { + if (this._meshes[i]) { + this._meshes[i].incRefCount(); + } + } + } + } +}; +Render.EVENT_SETMESHES = "set:meshes"; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/anim/evaluator/anim-curve.js +var AnimCurve = class { + constructor(paths, input2, output, interpolation) { + this._paths = paths; + this._input = input2; + this._output = output; + this._interpolation = interpolation; + } + get paths() { + return this._paths; + } + get input() { + return this._input; + } + get output() { + return this._output; + } + get interpolation() { + return this._interpolation; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/anim/evaluator/anim-data.js +var AnimData = class { + constructor(components, data2) { + this._components = components; + this._data = data2; + } + get components() { + return this._components; + } + get data() { + return this._data; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/parsers/draco-worker.js +function DracoWorker(jsUrl, wasmUrl) { + let draco; + const POSITION_ATTRIBUTE = 0; + const NORMAL_ATTRIBUTE = 1; + const wrap = (typedArray, dataType) => { + switch (dataType) { + case draco.DT_INT8: + return new Int8Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength); + case draco.DT_INT16: + return new Int16Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength / 2); + case draco.DT_INT32: + return new Int32Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength / 4); + case draco.DT_UINT8: + return new Uint8Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength); + case draco.DT_UINT16: + return new Uint16Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength / 2); + case draco.DT_UINT32: + return new Uint32Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength / 4); + case draco.DT_FLOAT32: + return new Float32Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength / 4); + } + return null; + }; + const componentSizeInBytes = (dataType) => { + switch (dataType) { + case draco.DT_INT8: + return 1; + case draco.DT_INT16: + return 2; + case draco.DT_INT32: + return 4; + case draco.DT_UINT8: + return 1; + case draco.DT_UINT16: + return 2; + case draco.DT_UINT32: + return 4; + case draco.DT_FLOAT32: + return 4; + } + return 1; + }; + const attributeSizeInBytes = (attribute) => { + return attribute.num_components() * componentSizeInBytes(attribute.data_type()); + }; + const attributeOrder2 = { + 0: 0, + 1: 1, + 5: 2, + 2: 3, + 7: 4, + 8: 5, + 4: 6, + 3: 7 + }; + const generateNormals2 = (vertices, indices) => { + const subtract = (dst, a2, b2) => { + dst[0] = a2[0] - b2[0]; + dst[1] = a2[1] - b2[1]; + dst[2] = a2[2] - b2[2]; + }; + const cross = (dst, a2, b2) => { + dst[0] = a2[1] * b2[2] - b2[1] * a2[2]; + dst[1] = a2[2] * b2[0] - b2[2] * a2[0]; + dst[2] = a2[0] * b2[1] - b2[0] * a2[1]; + }; + const normalize = (dst, offset) => { + const a2 = dst[offset + 0]; + const b2 = dst[offset + 1]; + const c3 = dst[offset + 2]; + const l = 1 / Math.sqrt(a2 * a2 + b2 * b2 + c3 * c3); + dst[offset + 0] *= l; + dst[offset + 1] *= l; + dst[offset + 2] *= l; + }; + const copy = (dst, src, srcOffset) => { + for (let i = 0; i < 3; ++i) { + dst[i] = src[srcOffset + i]; + } + }; + const numTriangles = indices.length / 3; + const numVertices = vertices.length / 3; + const result = new Float32Array(vertices.length); + const a = [0, 0, 0], b = [0, 0, 0], c2 = [0, 0, 0], t1 = [0, 0, 0], t2 = [0, 0, 0], n = [0, 0, 0]; + for (let i = 0; i < numTriangles; ++i) { + const v0 = indices[i * 3 + 0] * 3; + const v1 = indices[i * 3 + 1] * 3; + const v22 = indices[i * 3 + 2] * 3; + copy(a, vertices, v0); + copy(b, vertices, v1); + copy(c2, vertices, v22); + subtract(t1, b, a); + subtract(t2, c2, a); + cross(n, t1, t2); + normalize(n, 0); + for (let j = 0; j < 3; ++j) { + result[v0 + j] += n[j]; + result[v1 + j] += n[j]; + result[v22 + j] += n[j]; + } + } + for (let i = 0; i < numVertices; ++i) { + normalize(result, i * 3); + } + return new Uint8Array(result.buffer); + }; + const decodeMesh = (inputBuffer) => { + const result = {}; + const buffer = new draco.DecoderBuffer(); + buffer.Init(inputBuffer, inputBuffer.length); + const decoder = new draco.Decoder(); + if (decoder.GetEncodedGeometryType(buffer) !== draco.TRIANGULAR_MESH) { + result.error = "Failed to decode draco mesh: not a mesh"; + return result; + } + const mesh = new draco.Mesh(); + const status = decoder.DecodeBufferToMesh(buffer, mesh); + if (!status || !status.ok() || mesh.ptr === 0) { + result.error = "Failed to decode draco asset"; + return result; + } + const numIndices = mesh.num_faces() * 3; + const shortIndices = mesh.num_points() <= 65535; + const indicesSize = numIndices * (shortIndices ? 2 : 4); + const indicesPtr = draco._malloc(indicesSize); + if (shortIndices) { + decoder.GetTrianglesUInt16Array(mesh, indicesSize, indicesPtr); + result.indices = new Uint16Array(draco.HEAPU16.buffer, indicesPtr, numIndices).slice().buffer; + } else { + decoder.GetTrianglesUInt32Array(mesh, indicesSize, indicesPtr); + result.indices = new Uint32Array(draco.HEAPU32.buffer, indicesPtr, numIndices).slice().buffer; + } + draco._free(indicesPtr); + const attributes = []; + for (let i = 0; i < mesh.num_attributes(); ++i) { + attributes.push(decoder.GetAttribute(mesh, i)); + } + attributes.sort((a, b) => { + var _attributeOrder$a$att, _attributeOrder$b$att; + return ((_attributeOrder$a$att = attributeOrder2[a.attribute_type()]) != null ? _attributeOrder$a$att : attributeOrder2.length) - ((_attributeOrder$b$att = attributeOrder2[b.attribute_type()]) != null ? _attributeOrder$b$att : attributeOrder2.length); + }); + result.attributes = attributes.map((a) => a.unique_id()); + let totalVertexSize = 0; + const offsets = attributes.map((a) => { + const offset = totalVertexSize; + totalVertexSize += Math.ceil(attributeSizeInBytes(a) / 4) * 4; + return offset; + }); + const hasNormals = attributes.some((a) => a.attribute_type() === NORMAL_ATTRIBUTE); + const normalOffset = offsets[1]; + if (!hasNormals) { + for (let i = 1; i < offsets.length; ++i) { + offsets[i] += 12; + } + totalVertexSize += 12; + } + result.vertices = new ArrayBuffer(mesh.num_points() * totalVertexSize); + const dst = new Uint8Array(result.vertices); + for (let i = 0; i < mesh.num_attributes(); ++i) { + const attribute = attributes[i]; + const sizeInBytes = attributeSizeInBytes(attribute); + const ptrSize = mesh.num_points() * sizeInBytes; + const ptr = draco._malloc(ptrSize); + decoder.GetAttributeDataArrayForAllPoints(mesh, attribute, attribute.data_type(), ptrSize, ptr); + const src = new Uint8Array(draco.HEAPU8.buffer, ptr, ptrSize); + for (let j = 0; j < mesh.num_points(); ++j) { + for (let c2 = 0; c2 < sizeInBytes; ++c2) { + dst[j * totalVertexSize + offsets[i] + c2] = src[j * sizeInBytes + c2]; + } + } + if (!hasNormals && attribute.attribute_type() === POSITION_ATTRIBUTE) { + const normals = generateNormals2(wrap(src, attribute.data_type()), shortIndices ? new Uint16Array(result.indices) : new Uint32Array(result.indices)); + for (let j = 0; j < mesh.num_points(); ++j) { + for (let c2 = 0; c2 < 12; ++c2) { + dst[j * totalVertexSize + normalOffset + c2] = normals[j * 12 + c2]; + } + } + } + draco._free(ptr); + } + draco.destroy(mesh); + draco.destroy(decoder); + draco.destroy(buffer); + return result; + }; + const decode = (data2) => { + const result = decodeMesh(new Uint8Array(data2.buffer)); + self.postMessage({ + jobId: data2.jobId, + error: result.error, + indices: result.indices, + vertices: result.vertices, + attributes: result.attributes + }, [result.indices, result.vertices].filter((t) => t != null)); + }; + const workQueue = []; + self.onmessage = (message) => { + const data2 = message.data; + switch (data2.type) { + case "init": + self.DracoDecoderModule({ + instantiateWasm: (imports, successCallback) => { + WebAssembly.instantiate(data2.module, imports).then((result) => successCallback(result)).catch((reason) => console.error("instantiate failed + " + reason)); + return {}; + } + }).then((instance) => { + draco = instance; + workQueue.forEach((data3) => decode(data3)); + }); + break; + case "decodeMesh": + if (draco) { + decode(data2); + } else { + workQueue.push(data2); + } + break; + } + }; +} + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/parsers/draco-decoder.js +var downloadMaxRetries = 3; +var JobQueue = class { + constructor() { + this.workers = [[], [], []]; + this.jobId = 0; + this.jobQueue = []; + this.jobCallbacks = /* @__PURE__ */ new Map(); + this.run = (worker, job) => { + worker.postMessage({ + type: "decodeMesh", + jobId: job.jobId, + buffer: job.buffer + }, [job.buffer]); + }; + } + init(workers2) { + workers2.forEach((worker) => { + worker.addEventListener("message", (message) => { + const data2 = message.data; + const callback = this.jobCallbacks.get(data2.jobId); + if (callback) { + callback(data2.error, { + indices: data2.indices, + vertices: data2.vertices, + attributes: data2.attributes + }); + } + this.jobCallbacks.delete(data2.jobId); + if (this.jobQueue.length > 0) { + const job = this.jobQueue.shift(); + this.run(worker, job); + } else { + const index2 = this.workers[2].indexOf(worker); + if (index2 !== -1) { + this.workers[2].splice(index2, 1); + this.workers[1].push(worker); + } else { + const index1 = this.workers[1].indexOf(worker); + if (index1 !== -1) { + this.workers[1].splice(index1, 1); + this.workers[0].push(worker); + } + } + } + }); + }); + this.workers[0] = workers2; + while (this.jobQueue.length && (this.workers[0].length || this.workers[1].length)) { + const job = this.jobQueue.shift(); + if (this.workers[0].length > 0) { + const worker = this.workers[0].shift(); + this.workers[1].push(worker); + this.run(worker, job); + } else { + const worker = this.workers[1].shift(); + this.workers[2].push(worker); + this.run(worker, job); + } + } + } + enqueueJob(buffer, callback) { + const job = { + jobId: this.jobId++, + buffer + }; + this.jobCallbacks.set(job.jobId, callback); + if (this.workers[0].length > 0) { + const worker = this.workers[0].shift(); + this.workers[1].push(worker); + this.run(worker, job); + } else if (this.workers[1].length > 0) { + const worker = this.workers[1].shift(); + this.workers[2].push(worker); + this.run(worker, job); + } else { + this.jobQueue.push(job); + } + } +}; +var downloadScript = (url) => { + return new Promise((resolve, reject) => { + const options = { + cache: true, + responseType: "text", + retry: downloadMaxRetries > 0, + maxRetries: downloadMaxRetries + }; + http.get(url, options, (err, response) => { + if (err) { + reject(err); + } else { + resolve(response); + } + }); + }); +}; +var compileModule = (url) => { + const compileManual = () => { + return fetch(url).then((result) => result.arrayBuffer()).then((buffer) => WebAssembly.compile(buffer)); + }; + const compileStreaming = () => { + return WebAssembly.compileStreaming(fetch(url)).catch((err) => { + return compileManual(); + }); + }; + return WebAssembly.compileStreaming ? compileStreaming() : compileManual(); +}; +var defaultNumWorkers = 1; +var jobQueue; +var lazyConfig; +var initializeWorkers = (config) => { + if (jobQueue) { + return true; + } + if (!config) { + if (lazyConfig) { + config = lazyConfig; + } else { + const moduleConfig = WasmModule.getConfig("DracoDecoderModule"); + if (moduleConfig) { + config = { + jsUrl: moduleConfig.glueUrl, + wasmUrl: moduleConfig.wasmUrl, + numWorkers: moduleConfig.numWorkers + }; + } else { + config = { + jsUrl: "draco.wasm.js", + wasmUrl: "draco.wasm.wasm", + numWorkers: defaultNumWorkers + }; + } + } + } + if (!config.jsUrl || !config.wasmUrl) { + return false; + } + jobQueue = new JobQueue(); + Promise.all([downloadScript(config.jsUrl), compileModule(config.wasmUrl)]).then(([dracoSource, dracoModule]) => { + const code = ["/* draco */", dracoSource, "/* worker */", `( +${DracoWorker.toString()} +)() + +`].join("\n"); + const blob = new Blob([code], { + type: "application/javascript" + }); + const workerUrl = URL.createObjectURL(blob); + const numWorkers = Math.max(1, Math.min(16, config.numWorkers || defaultNumWorkers)); + const workers2 = []; + for (let i = 0; i < numWorkers; ++i) { + const worker = new Worker(workerUrl); + worker.postMessage({ + type: "init", + module: dracoModule + }); + workers2.push(worker); + } + jobQueue.init(workers2); + }); + return true; +}; +var dracoDecode = (buffer, callback) => { + if (!initializeWorkers()) { + return false; + } + jobQueue.enqueueJob(buffer, callback); + return true; +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/parsers/glb-parser.js +var GlbResources = class { + constructor() { + this.gltf = void 0; + this.nodes = void 0; + this.scenes = void 0; + this.animations = void 0; + this.textures = void 0; + this.materials = void 0; + this.variants = void 0; + this.meshVariants = void 0; + this.meshDefaultMaterials = void 0; + this.renders = void 0; + this.skins = void 0; + this.lights = void 0; + this.cameras = void 0; + } + destroy() { + if (this.renders) { + this.renders.forEach((render) => { + render.meshes = null; + }); + } + } +}; +var isDataURI = (uri) => { + return /^data:.*,.*$/i.test(uri); +}; +var getDataURIMimeType = (uri) => { + return uri.substring(uri.indexOf(":") + 1, uri.indexOf(";")); +}; +var getNumComponents = (accessorType) => { + switch (accessorType) { + case "SCALAR": + return 1; + case "VEC2": + return 2; + case "VEC3": + return 3; + case "VEC4": + return 4; + case "MAT2": + return 4; + case "MAT3": + return 9; + case "MAT4": + return 16; + default: + return 3; + } +}; +var getComponentType = (componentType) => { + switch (componentType) { + case 5120: + return TYPE_INT8; + case 5121: + return TYPE_UINT8; + case 5122: + return TYPE_INT16; + case 5123: + return TYPE_UINT16; + case 5124: + return TYPE_INT32; + case 5125: + return TYPE_UINT32; + case 5126: + return TYPE_FLOAT32; + default: + return 0; + } +}; +var getComponentSizeInBytes = (componentType) => { + switch (componentType) { + case 5120: + return 1; + case 5121: + return 1; + case 5122: + return 2; + case 5123: + return 2; + case 5124: + return 4; + case 5125: + return 4; + case 5126: + return 4; + default: + return 0; + } +}; +var getComponentDataType = (componentType) => { + switch (componentType) { + case 5120: + return Int8Array; + case 5121: + return Uint8Array; + case 5122: + return Int16Array; + case 5123: + return Uint16Array; + case 5124: + return Int32Array; + case 5125: + return Uint32Array; + case 5126: + return Float32Array; + default: + return null; + } +}; +var gltfToEngineSemanticMap = { + "POSITION": SEMANTIC_POSITION, + "NORMAL": SEMANTIC_NORMAL, + "TANGENT": SEMANTIC_TANGENT, + "COLOR_0": SEMANTIC_COLOR, + "JOINTS_0": SEMANTIC_BLENDINDICES, + "WEIGHTS_0": SEMANTIC_BLENDWEIGHT, + "TEXCOORD_0": SEMANTIC_TEXCOORD0, + "TEXCOORD_1": SEMANTIC_TEXCOORD1, + "TEXCOORD_2": SEMANTIC_TEXCOORD2, + "TEXCOORD_3": SEMANTIC_TEXCOORD3, + "TEXCOORD_4": SEMANTIC_TEXCOORD4, + "TEXCOORD_5": SEMANTIC_TEXCOORD5, + "TEXCOORD_6": SEMANTIC_TEXCOORD6, + "TEXCOORD_7": SEMANTIC_TEXCOORD7 +}; +var attributeOrder = { + [SEMANTIC_POSITION]: 0, + [SEMANTIC_NORMAL]: 1, + [SEMANTIC_TANGENT]: 2, + [SEMANTIC_COLOR]: 3, + [SEMANTIC_BLENDINDICES]: 4, + [SEMANTIC_BLENDWEIGHT]: 5, + [SEMANTIC_TEXCOORD0]: 6, + [SEMANTIC_TEXCOORD1]: 7, + [SEMANTIC_TEXCOORD2]: 8, + [SEMANTIC_TEXCOORD3]: 9, + [SEMANTIC_TEXCOORD4]: 10, + [SEMANTIC_TEXCOORD5]: 11, + [SEMANTIC_TEXCOORD6]: 12, + [SEMANTIC_TEXCOORD7]: 13 +}; +var getDequantizeFunc = (srcType) => { + switch (srcType) { + case TYPE_INT8: + return (x2) => Math.max(x2 / 127, -1); + case TYPE_UINT8: + return (x2) => x2 / 255; + case TYPE_INT16: + return (x2) => Math.max(x2 / 32767, -1); + case TYPE_UINT16: + return (x2) => x2 / 65535; + default: + return (x2) => x2; + } +}; +var dequantizeArray = (dstArray, srcArray, srcType) => { + const convFunc = getDequantizeFunc(srcType); + const len = srcArray.length; + for (let i = 0; i < len; ++i) { + dstArray[i] = convFunc(srcArray[i]); + } + return dstArray; +}; +var getAccessorData = (gltfAccessor, bufferViews, flatten = false) => { + const numComponents = getNumComponents(gltfAccessor.type); + const dataType = getComponentDataType(gltfAccessor.componentType); + if (!dataType) { + return null; + } + let result; + if (gltfAccessor.sparse) { + const sparse = gltfAccessor.sparse; + const indicesAccessor = { + count: sparse.count, + type: "SCALAR" + }; + const indices = getAccessorData(Object.assign(indicesAccessor, sparse.indices), bufferViews, true); + const valuesAccessor = { + count: sparse.count, + type: gltfAccessor.type, + componentType: gltfAccessor.componentType + }; + const values = getAccessorData(Object.assign(valuesAccessor, sparse.values), bufferViews, true); + if (gltfAccessor.hasOwnProperty("bufferView")) { + const baseAccessor = { + bufferView: gltfAccessor.bufferView, + byteOffset: gltfAccessor.byteOffset, + componentType: gltfAccessor.componentType, + count: gltfAccessor.count, + type: gltfAccessor.type + }; + result = getAccessorData(baseAccessor, bufferViews, true).slice(); + } else { + result = new dataType(gltfAccessor.count * numComponents); + } + for (let i = 0; i < sparse.count; ++i) { + const targetIndex = indices[i]; + for (let j = 0; j < numComponents; ++j) { + result[targetIndex * numComponents + j] = values[i * numComponents + j]; + } + } + } else { + if (gltfAccessor.hasOwnProperty("bufferView")) { + const bufferView = bufferViews[gltfAccessor.bufferView]; + if (flatten && bufferView.hasOwnProperty("byteStride")) { + const bytesPerElement = numComponents * dataType.BYTES_PER_ELEMENT; + const storage = new ArrayBuffer(gltfAccessor.count * bytesPerElement); + const tmpArray = new Uint8Array(storage); + let dstOffset = 0; + for (let i = 0; i < gltfAccessor.count; ++i) { + let srcOffset = (gltfAccessor.byteOffset || 0) + i * bufferView.byteStride; + for (let b = 0; b < bytesPerElement; ++b) { + tmpArray[dstOffset++] = bufferView[srcOffset++]; + } + } + result = new dataType(storage); + } else { + result = new dataType(bufferView.buffer, bufferView.byteOffset + (gltfAccessor.byteOffset || 0), gltfAccessor.count * numComponents); + } + } else { + result = new dataType(gltfAccessor.count * numComponents); + } + } + return result; +}; +var getAccessorDataFloat32 = (gltfAccessor, bufferViews) => { + const data2 = getAccessorData(gltfAccessor, bufferViews, true); + if (data2 instanceof Float32Array || !gltfAccessor.normalized) { + return data2; + } + const float32Data = new Float32Array(data2.length); + dequantizeArray(float32Data, data2, getComponentType(gltfAccessor.componentType)); + return float32Data; +}; +var getAccessorBoundingBox = (gltfAccessor) => { + let min = gltfAccessor.min; + let max = gltfAccessor.max; + if (!min || !max) { + return null; + } + if (gltfAccessor.normalized) { + const ctype = getComponentType(gltfAccessor.componentType); + min = dequantizeArray([], min, ctype); + max = dequantizeArray([], max, ctype); + } + return new BoundingBox(new Vec3((max[0] + min[0]) * 0.5, (max[1] + min[1]) * 0.5, (max[2] + min[2]) * 0.5), new Vec3((max[0] - min[0]) * 0.5, (max[1] - min[1]) * 0.5, (max[2] - min[2]) * 0.5)); +}; +var getPrimitiveType = (primitive2) => { + if (!primitive2.hasOwnProperty("mode")) { + return PRIMITIVE_TRIANGLES; + } + switch (primitive2.mode) { + case 0: + return PRIMITIVE_POINTS; + case 1: + return PRIMITIVE_LINES; + case 2: + return PRIMITIVE_LINELOOP; + case 3: + return PRIMITIVE_LINESTRIP; + case 4: + return PRIMITIVE_TRIANGLES; + case 5: + return PRIMITIVE_TRISTRIP; + case 6: + return PRIMITIVE_TRIFAN; + default: + return PRIMITIVE_TRIANGLES; + } +}; +var generateIndices = (numVertices) => { + const dummyIndices = new Uint16Array(numVertices); + for (let i = 0; i < numVertices; i++) { + dummyIndices[i] = i; + } + return dummyIndices; +}; +var generateNormals = (sourceDesc, indices) => { + const p = sourceDesc[SEMANTIC_POSITION]; + if (!p || p.components !== 3) { + return; + } + let positions; + if (p.size !== p.stride) { + const srcStride = p.stride / typedArrayTypesByteSize[p.type]; + const src = new typedArrayTypes[p.type](p.buffer, p.offset, p.count * srcStride); + positions = new typedArrayTypes[p.type](p.count * 3); + for (let i = 0; i < p.count; ++i) { + positions[i * 3 + 0] = src[i * srcStride + 0]; + positions[i * 3 + 1] = src[i * srcStride + 1]; + positions[i * 3 + 2] = src[i * srcStride + 2]; + } + } else { + positions = new typedArrayTypes[p.type](p.buffer, p.offset, p.count * 3); + } + const numVertices = p.count; + if (!indices) { + indices = generateIndices(numVertices); + } + const normalsTemp = calculateNormals(positions, indices); + const normals = new Float32Array(normalsTemp.length); + normals.set(normalsTemp); + sourceDesc[SEMANTIC_NORMAL] = { + buffer: normals.buffer, + size: 12, + offset: 0, + stride: 12, + count: numVertices, + components: 3, + type: TYPE_FLOAT32 + }; +}; +var flipTexCoordVs = (vertexBuffer) => { + let i, j; + const floatOffsets = []; + const shortOffsets = []; + const byteOffsets = []; + for (i = 0; i < vertexBuffer.format.elements.length; ++i) { + const element = vertexBuffer.format.elements[i]; + if (element.name === SEMANTIC_TEXCOORD0 || element.name === SEMANTIC_TEXCOORD1) { + switch (element.dataType) { + case TYPE_FLOAT32: + floatOffsets.push({ + offset: element.offset / 4 + 1, + stride: element.stride / 4 + }); + break; + case TYPE_UINT16: + shortOffsets.push({ + offset: element.offset / 2 + 1, + stride: element.stride / 2 + }); + break; + case TYPE_UINT8: + byteOffsets.push({ + offset: element.offset + 1, + stride: element.stride + }); + break; + } + } + } + const flip = (offsets, type2, one) => { + const typedArray = new type2(vertexBuffer.storage); + for (i = 0; i < offsets.length; ++i) { + let index = offsets[i].offset; + const stride = offsets[i].stride; + for (j = 0; j < vertexBuffer.numVertices; ++j) { + typedArray[index] = one - typedArray[index]; + index += stride; + } + } + }; + if (floatOffsets.length > 0) { + flip(floatOffsets, Float32Array, 1); + } + if (shortOffsets.length > 0) { + flip(shortOffsets, Uint16Array, 65535); + } + if (byteOffsets.length > 0) { + flip(byteOffsets, Uint8Array, 255); + } +}; +var cloneTexture = (texture) => { + const shallowCopyLevels = (texture2) => { + const result2 = []; + for (let mip = 0; mip < texture2._levels.length; ++mip) { + let level = []; + if (texture2.cubemap) { + for (let face = 0; face < 6; ++face) { + level.push(texture2._levels[mip][face]); + } + } else { + level = texture2._levels[mip]; + } + result2.push(level); + } + return result2; + }; + const result = new Texture(texture.device, texture); + result._levels = shallowCopyLevels(texture); + return result; +}; +var cloneTextureAsset = (src) => { + const result = new Asset(src.name + "_clone", src.type, src.file, src.data, src.options); + result.loaded = true; + result.resource = cloneTexture(src.resource); + src.registry.add(result); + return result; +}; +var createVertexBufferInternal = (device, sourceDesc, flipV) => { + const positionDesc = sourceDesc[SEMANTIC_POSITION]; + if (!positionDesc) { + return null; + } + const numVertices = positionDesc.count; + const vertexDesc = []; + for (const semantic in sourceDesc) { + if (sourceDesc.hasOwnProperty(semantic)) { + const element = { + semantic, + components: sourceDesc[semantic].components, + type: sourceDesc[semantic].type, + normalize: !!sourceDesc[semantic].normalize + }; + if (!VertexFormat.isElementValid(device, element)) { + element.components++; + } + vertexDesc.push(element); + } + } + vertexDesc.sort((lhs, rhs) => { + return attributeOrder[lhs.semantic] - attributeOrder[rhs.semantic]; + }); + let i, j, k; + let source, target2, sourceOffset; + const vertexFormat = new VertexFormat(device, vertexDesc); + let isCorrectlyInterleaved = true; + for (i = 0; i < vertexFormat.elements.length; ++i) { + target2 = vertexFormat.elements[i]; + source = sourceDesc[target2.name]; + sourceOffset = source.offset - positionDesc.offset; + if (source.buffer !== positionDesc.buffer || source.stride !== target2.stride || source.size !== target2.size || sourceOffset !== target2.offset) { + isCorrectlyInterleaved = false; + break; + } + } + const vertexBuffer = new VertexBuffer(device, vertexFormat, numVertices); + const vertexData = vertexBuffer.lock(); + const targetArray = new Uint32Array(vertexData); + let sourceArray; + if (isCorrectlyInterleaved) { + sourceArray = new Uint32Array(positionDesc.buffer, positionDesc.offset, numVertices * vertexBuffer.format.size / 4); + targetArray.set(sourceArray); + } else { + let targetStride, sourceStride; + for (i = 0; i < vertexBuffer.format.elements.length; ++i) { + target2 = vertexBuffer.format.elements[i]; + targetStride = target2.stride / 4; + source = sourceDesc[target2.name]; + sourceStride = source.stride / 4; + sourceArray = new Uint32Array(source.buffer, source.offset, (source.count - 1) * sourceStride + (source.size + 3) / 4); + let src = 0; + let dst = target2.offset / 4; + const kend = Math.floor((source.size + 3) / 4); + for (j = 0; j < numVertices; ++j) { + for (k = 0; k < kend; ++k) { + targetArray[dst + k] = sourceArray[src + k]; + } + src += sourceStride; + dst += targetStride; + } + } + } + if (flipV) { + flipTexCoordVs(vertexBuffer); + } + vertexBuffer.unlock(); + return vertexBuffer; +}; +var createVertexBuffer = (device, attributes, indices, accessors, bufferViews, flipV, vertexBufferDict) => { + const useAttributes = {}; + const attribIds = []; + for (const attrib in attributes) { + if (attributes.hasOwnProperty(attrib) && gltfToEngineSemanticMap.hasOwnProperty(attrib)) { + useAttributes[attrib] = attributes[attrib]; + attribIds.push(attrib + ":" + attributes[attrib]); + } + } + attribIds.sort(); + const vbKey = attribIds.join(); + let vb = vertexBufferDict[vbKey]; + if (!vb) { + const sourceDesc = {}; + for (const attrib in useAttributes) { + const accessor = accessors[attributes[attrib]]; + const accessorData = getAccessorData(accessor, bufferViews); + const bufferView = bufferViews[accessor.bufferView]; + const semantic = gltfToEngineSemanticMap[attrib]; + const size = getNumComponents(accessor.type) * getComponentSizeInBytes(accessor.componentType); + const stride = bufferView && bufferView.hasOwnProperty("byteStride") ? bufferView.byteStride : size; + sourceDesc[semantic] = { + buffer: accessorData.buffer, + size, + offset: accessorData.byteOffset, + stride, + count: accessor.count, + components: getNumComponents(accessor.type), + type: getComponentType(accessor.componentType), + normalize: accessor.normalized + }; + } + if (!sourceDesc.hasOwnProperty(SEMANTIC_NORMAL)) { + generateNormals(sourceDesc, indices); + } + vb = createVertexBufferInternal(device, sourceDesc, flipV); + vertexBufferDict[vbKey] = vb; + } + return vb; +}; +var createSkin = (device, gltfSkin, accessors, bufferViews, nodes, glbSkins) => { + let i, j, bindMatrix; + const joints = gltfSkin.joints; + const numJoints = joints.length; + const ibp = []; + if (gltfSkin.hasOwnProperty("inverseBindMatrices")) { + const inverseBindMatrices = gltfSkin.inverseBindMatrices; + const ibmData = getAccessorData(accessors[inverseBindMatrices], bufferViews, true); + const ibmValues = []; + for (i = 0; i < numJoints; i++) { + for (j = 0; j < 16; j++) { + ibmValues[j] = ibmData[i * 16 + j]; + } + bindMatrix = new Mat4(); + bindMatrix.set(ibmValues); + ibp.push(bindMatrix); + } + } else { + for (i = 0; i < numJoints; i++) { + bindMatrix = new Mat4(); + ibp.push(bindMatrix); + } + } + const boneNames = []; + for (i = 0; i < numJoints; i++) { + boneNames[i] = nodes[joints[i]].name; + } + const key = boneNames.join("#"); + let skin = glbSkins.get(key); + if (!skin) { + skin = new Skin(device, ibp, boneNames); + glbSkins.set(key, skin); + } + return skin; +}; +var createDracoMesh = (device, primitive2, accessors, bufferViews, meshVariants, meshDefaultMaterials, promises) => { + var _primitive$extensions; + const result = new Mesh(device); + result.aabb = getAccessorBoundingBox(accessors[primitive2.attributes.POSITION]); + const vertexDesc = []; + for (const [name, index] of Object.entries(primitive2.attributes)) { + var _accessor$normalized; + const accessor = accessors[index]; + const semantic = gltfToEngineSemanticMap[name]; + const componentType = getComponentType(accessor.componentType); + vertexDesc.push({ + semantic, + components: getNumComponents(accessor.type), + type: componentType, + normalize: (_accessor$normalized = accessor.normalized) != null ? _accessor$normalized : semantic === SEMANTIC_COLOR && (componentType === TYPE_UINT8 || componentType === TYPE_UINT16) + }); + } + promises.push(new Promise((resolve, reject) => { + const dracoExt = primitive2.extensions.KHR_draco_mesh_compression; + dracoDecode(bufferViews[dracoExt.bufferView].slice().buffer, (err, decompressedData) => { + if (err) { + console.log(err); + reject(err); + } else { + var _primitive$attributes; + const order = {}; + for (const [name, index] of Object.entries(dracoExt.attributes)) { + order[gltfToEngineSemanticMap[name]] = decompressedData.attributes.indexOf(index); + } + vertexDesc.sort((a, b) => { + return order[a.semantic] - order[b.semantic]; + }); + if (!((_primitive$attributes = primitive2.attributes) != null && _primitive$attributes.NORMAL)) { + vertexDesc.splice(1, 0, { + semantic: "NORMAL", + components: 3, + type: TYPE_FLOAT32 + }); + } + const vertexFormat = new VertexFormat(device, vertexDesc); + const numVertices = decompressedData.vertices.byteLength / vertexFormat.size; + const indexFormat = numVertices <= 65535 ? INDEXFORMAT_UINT16 : INDEXFORMAT_UINT32; + const numIndices = decompressedData.indices.byteLength / (numVertices <= 65535 ? 2 : 4); + const vertexBuffer = new VertexBuffer(device, vertexFormat, numVertices, { + data: decompressedData.vertices + }); + const indexBuffer = new IndexBuffer(device, indexFormat, numIndices, BUFFER_STATIC, decompressedData.indices); + result.vertexBuffer = vertexBuffer; + result.indexBuffer[0] = indexBuffer; + result.primitive[0].type = getPrimitiveType(primitive2); + result.primitive[0].base = 0; + result.primitive[0].count = indexBuffer ? numIndices : numVertices; + result.primitive[0].indexed = !!indexBuffer; + resolve(); + } + }); + })); + if (primitive2 != null && (_primitive$extensions = primitive2.extensions) != null && _primitive$extensions.KHR_materials_variants) { + const variants = primitive2.extensions.KHR_materials_variants; + const tempMapping = {}; + variants.mappings.forEach((mapping) => { + mapping.variants.forEach((variant) => { + tempMapping[variant] = mapping.material; + }); + }); + meshVariants[result.id] = tempMapping; + } + meshDefaultMaterials[result.id] = primitive2.material; + return result; +}; +var createMesh = (device, gltfMesh, accessors, bufferViews, flipV, vertexBufferDict, meshVariants, meshDefaultMaterials, assetOptions, promises) => { + const meshes = []; + gltfMesh.primitives.forEach((primitive2) => { + var _primitive$extensions2; + if ((_primitive$extensions2 = primitive2.extensions) != null && _primitive$extensions2.KHR_draco_mesh_compression) { + meshes.push(createDracoMesh(device, primitive2, accessors, bufferViews, meshVariants, meshDefaultMaterials, promises)); + } else { + let indices = primitive2.hasOwnProperty("indices") ? getAccessorData(accessors[primitive2.indices], bufferViews, true) : null; + const vertexBuffer = createVertexBuffer(device, primitive2.attributes, indices, accessors, bufferViews, flipV, vertexBufferDict); + const primitiveType = getPrimitiveType(primitive2); + const mesh = new Mesh(device); + mesh.vertexBuffer = vertexBuffer; + mesh.primitive[0].type = primitiveType; + mesh.primitive[0].base = 0; + mesh.primitive[0].indexed = indices !== null; + if (indices !== null) { + let indexFormat; + if (indices instanceof Uint8Array) { + indexFormat = INDEXFORMAT_UINT8; + } else if (indices instanceof Uint16Array) { + indexFormat = INDEXFORMAT_UINT16; + } else { + indexFormat = INDEXFORMAT_UINT32; + } + if (indexFormat === INDEXFORMAT_UINT32 && !device.extUintElement) { + indexFormat = INDEXFORMAT_UINT16; + indices = new Uint16Array(indices); + } + if (indexFormat === INDEXFORMAT_UINT8 && device.isWebGPU) { + indexFormat = INDEXFORMAT_UINT16; + indices = new Uint16Array(indices); + } + const indexBuffer = new IndexBuffer(device, indexFormat, indices.length, BUFFER_STATIC, indices); + mesh.indexBuffer[0] = indexBuffer; + mesh.primitive[0].count = indices.length; + } else { + mesh.primitive[0].count = vertexBuffer.numVertices; + } + if (primitive2.hasOwnProperty("extensions") && primitive2.extensions.hasOwnProperty("KHR_materials_variants")) { + const variants = primitive2.extensions.KHR_materials_variants; + const tempMapping = {}; + variants.mappings.forEach((mapping) => { + mapping.variants.forEach((variant) => { + tempMapping[variant] = mapping.material; + }); + }); + meshVariants[mesh.id] = tempMapping; + } + meshDefaultMaterials[mesh.id] = primitive2.material; + let accessor = accessors[primitive2.attributes.POSITION]; + mesh.aabb = getAccessorBoundingBox(accessor); + if (primitive2.hasOwnProperty("targets")) { + const targets = []; + primitive2.targets.forEach((target2, index) => { + const options = {}; + if (target2.hasOwnProperty("POSITION")) { + accessor = accessors[target2.POSITION]; + options.deltaPositions = getAccessorDataFloat32(accessor, bufferViews); + options.deltaPositionsType = TYPE_FLOAT32; + options.aabb = getAccessorBoundingBox(accessor); + } + if (target2.hasOwnProperty("NORMAL")) { + accessor = accessors[target2.NORMAL]; + options.deltaNormals = getAccessorDataFloat32(accessor, bufferViews); + options.deltaNormalsType = TYPE_FLOAT32; + } + if (gltfMesh.hasOwnProperty("extras") && gltfMesh.extras.hasOwnProperty("targetNames")) { + options.name = gltfMesh.extras.targetNames[index]; + } else { + options.name = index.toString(10); + } + if (gltfMesh.hasOwnProperty("weights")) { + options.defaultWeight = gltfMesh.weights[index]; + } + options.preserveData = assetOptions.morphPreserveData; + targets.push(new MorphTarget(options)); + }); + mesh.morph = new Morph(targets, device, { + preferHighPrecision: assetOptions.morphPreferHighPrecision + }); + } + meshes.push(mesh); + } + }); + return meshes; +}; +var extractTextureTransform = (source, material, maps) => { + var _source$extensions; + let map; + const texCoord = source.texCoord; + if (texCoord) { + for (map = 0; map < maps.length; ++map) { + material[maps[map] + "MapUv"] = texCoord; + } + } + const zeros = [0, 0]; + const ones = [1, 1]; + const textureTransform = (_source$extensions = source.extensions) == null ? void 0 : _source$extensions.KHR_texture_transform; + if (textureTransform) { + const offset = textureTransform.offset || zeros; + const scale2 = textureTransform.scale || ones; + const rotation2 = textureTransform.rotation ? -textureTransform.rotation * math.RAD_TO_DEG : 0; + const tilingVec = new Vec2(scale2[0], scale2[1]); + const offsetVec = new Vec2(offset[0], 1 - scale2[1] - offset[1]); + for (map = 0; map < maps.length; ++map) { + material[`${maps[map]}MapTiling`] = tilingVec; + material[`${maps[map]}MapOffset`] = offsetVec; + material[`${maps[map]}MapRotation`] = rotation2; + } + } +}; +var extensionPbrSpecGlossiness = (data2, material, textures) => { + let color, texture; + if (data2.hasOwnProperty("diffuseFactor")) { + color = data2.diffuseFactor; + material.diffuse.set(Math.pow(color[0], 1 / 2.2), Math.pow(color[1], 1 / 2.2), Math.pow(color[2], 1 / 2.2)); + material.opacity = color[3]; + } else { + material.diffuse.set(1, 1, 1); + material.opacity = 1; + } + if (data2.hasOwnProperty("diffuseTexture")) { + const diffuseTexture = data2.diffuseTexture; + texture = textures[diffuseTexture.index]; + material.diffuseMap = texture; + material.diffuseMapChannel = "rgb"; + material.opacityMap = texture; + material.opacityMapChannel = "a"; + extractTextureTransform(diffuseTexture, material, ["diffuse", "opacity"]); + } + material.useMetalness = false; + if (data2.hasOwnProperty("specularFactor")) { + color = data2.specularFactor; + material.specular.set(Math.pow(color[0], 1 / 2.2), Math.pow(color[1], 1 / 2.2), Math.pow(color[2], 1 / 2.2)); + } else { + material.specular.set(1, 1, 1); + } + if (data2.hasOwnProperty("glossinessFactor")) { + material.gloss = data2.glossinessFactor; + } else { + material.gloss = 1; + } + if (data2.hasOwnProperty("specularGlossinessTexture")) { + const specularGlossinessTexture = data2.specularGlossinessTexture; + material.specularEncoding = "srgb"; + material.specularMap = material.glossMap = textures[specularGlossinessTexture.index]; + material.specularMapChannel = "rgb"; + material.glossMapChannel = "a"; + extractTextureTransform(specularGlossinessTexture, material, ["gloss", "metalness"]); + } +}; +var extensionClearCoat = (data2, material, textures) => { + if (data2.hasOwnProperty("clearcoatFactor")) { + material.clearCoat = data2.clearcoatFactor * 0.25; + } else { + material.clearCoat = 0; + } + if (data2.hasOwnProperty("clearcoatTexture")) { + const clearcoatTexture = data2.clearcoatTexture; + material.clearCoatMap = textures[clearcoatTexture.index]; + material.clearCoatMapChannel = "r"; + extractTextureTransform(clearcoatTexture, material, ["clearCoat"]); + } + if (data2.hasOwnProperty("clearcoatRoughnessFactor")) { + material.clearCoatGloss = data2.clearcoatRoughnessFactor; + } else { + material.clearCoatGloss = 0; + } + if (data2.hasOwnProperty("clearcoatRoughnessTexture")) { + const clearcoatRoughnessTexture = data2.clearcoatRoughnessTexture; + material.clearCoatGlossMap = textures[clearcoatRoughnessTexture.index]; + material.clearCoatGlossMapChannel = "g"; + extractTextureTransform(clearcoatRoughnessTexture, material, ["clearCoatGloss"]); + } + if (data2.hasOwnProperty("clearcoatNormalTexture")) { + const clearcoatNormalTexture = data2.clearcoatNormalTexture; + material.clearCoatNormalMap = textures[clearcoatNormalTexture.index]; + extractTextureTransform(clearcoatNormalTexture, material, ["clearCoatNormal"]); + if (clearcoatNormalTexture.hasOwnProperty("scale")) { + material.clearCoatBumpiness = clearcoatNormalTexture.scale; + } + } + material.clearCoatGlossInvert = true; +}; +var extensionUnlit = (data2, material, textures) => { + material.useLighting = false; + material.emissive.copy(material.diffuse); + material.emissiveTint = material.diffuseTint; + material.emissiveMap = material.diffuseMap; + material.emissiveMapUv = material.diffuseMapUv; + material.emissiveMapTiling.copy(material.diffuseMapTiling); + material.emissiveMapOffset.copy(material.diffuseMapOffset); + material.emissiveMapRotation = material.diffuseMapRotation; + material.emissiveMapChannel = material.diffuseMapChannel; + material.emissiveVertexColor = material.diffuseVertexColor; + material.emissiveVertexColorChannel = material.diffuseVertexColorChannel; + material.useLighting = false; + material.useSkybox = false; + material.diffuse.set(0, 0, 0); + material.diffuseTint = false; + material.diffuseMap = null; + material.diffuseVertexColor = false; +}; +var extensionSpecular = (data2, material, textures) => { + material.useMetalnessSpecularColor = true; + if (data2.hasOwnProperty("specularColorTexture")) { + material.specularEncoding = "srgb"; + material.specularMap = textures[data2.specularColorTexture.index]; + material.specularMapChannel = "rgb"; + extractTextureTransform(data2.specularColorTexture, material, ["specular"]); + } + if (data2.hasOwnProperty("specularColorFactor")) { + const color = data2.specularColorFactor; + material.specular.set(Math.pow(color[0], 1 / 2.2), Math.pow(color[1], 1 / 2.2), Math.pow(color[2], 1 / 2.2)); + } else { + material.specular.set(1, 1, 1); + } + if (data2.hasOwnProperty("specularFactor")) { + material.specularityFactor = data2.specularFactor; + } else { + material.specularityFactor = 1; + } + if (data2.hasOwnProperty("specularTexture")) { + material.specularityFactorMapChannel = "a"; + material.specularityFactorMap = textures[data2.specularTexture.index]; + extractTextureTransform(data2.specularTexture, material, ["specularityFactor"]); + } +}; +var extensionIor = (data2, material, textures) => { + if (data2.hasOwnProperty("ior")) { + material.refractionIndex = 1 / data2.ior; + } +}; +var extensionDispersion = (data2, material, textures) => { + if (data2.hasOwnProperty("dispersion")) { + material.dispersion = data2.dispersion; + } +}; +var extensionTransmission = (data2, material, textures) => { + material.blendType = BLEND_NORMAL; + material.useDynamicRefraction = true; + if (data2.hasOwnProperty("transmissionFactor")) { + material.refraction = data2.transmissionFactor; + } + if (data2.hasOwnProperty("transmissionTexture")) { + material.refractionMapChannel = "r"; + material.refractionMap = textures[data2.transmissionTexture.index]; + extractTextureTransform(data2.transmissionTexture, material, ["refraction"]); + } +}; +var extensionSheen = (data2, material, textures) => { + material.useSheen = true; + if (data2.hasOwnProperty("sheenColorFactor")) { + const color = data2.sheenColorFactor; + material.sheen.set(Math.pow(color[0], 1 / 2.2), Math.pow(color[1], 1 / 2.2), Math.pow(color[2], 1 / 2.2)); + } else { + material.sheen.set(1, 1, 1); + } + if (data2.hasOwnProperty("sheenColorTexture")) { + material.sheenMap = textures[data2.sheenColorTexture.index]; + material.sheenEncoding = "srgb"; + extractTextureTransform(data2.sheenColorTexture, material, ["sheen"]); + } + if (data2.hasOwnProperty("sheenRoughnessFactor")) { + material.sheenGloss = data2.sheenRoughnessFactor; + } else { + material.sheenGloss = 0; + } + if (data2.hasOwnProperty("sheenRoughnessTexture")) { + material.sheenGlossMap = textures[data2.sheenRoughnessTexture.index]; + material.sheenGlossMapChannel = "a"; + extractTextureTransform(data2.sheenRoughnessTexture, material, ["sheenGloss"]); + } + material.sheenGlossInvert = true; +}; +var extensionVolume = (data2, material, textures) => { + material.blendType = BLEND_NORMAL; + material.useDynamicRefraction = true; + if (data2.hasOwnProperty("thicknessFactor")) { + material.thickness = data2.thicknessFactor; + } + if (data2.hasOwnProperty("thicknessTexture")) { + material.thicknessMap = textures[data2.thicknessTexture.index]; + material.thicknessMapChannel = "g"; + extractTextureTransform(data2.thicknessTexture, material, ["thickness"]); + } + if (data2.hasOwnProperty("attenuationDistance")) { + material.attenuationDistance = data2.attenuationDistance; + } + if (data2.hasOwnProperty("attenuationColor")) { + const color = data2.attenuationColor; + material.attenuation.set(Math.pow(color[0], 1 / 2.2), Math.pow(color[1], 1 / 2.2), Math.pow(color[2], 1 / 2.2)); + } +}; +var extensionEmissiveStrength = (data2, material, textures) => { + if (data2.hasOwnProperty("emissiveStrength")) { + material.emissiveIntensity = data2.emissiveStrength; + } +}; +var extensionIridescence = (data2, material, textures) => { + material.useIridescence = true; + if (data2.hasOwnProperty("iridescenceFactor")) { + material.iridescence = data2.iridescenceFactor; + } + if (data2.hasOwnProperty("iridescenceTexture")) { + material.iridescenceMapChannel = "r"; + material.iridescenceMap = textures[data2.iridescenceTexture.index]; + extractTextureTransform(data2.iridescenceTexture, material, ["iridescence"]); + } + if (data2.hasOwnProperty("iridescenceIor")) { + material.iridescenceRefractionIndex = data2.iridescenceIor; + } + if (data2.hasOwnProperty("iridescenceThicknessMinimum")) { + material.iridescenceThicknessMin = data2.iridescenceThicknessMinimum; + } + if (data2.hasOwnProperty("iridescenceThicknessMaximum")) { + material.iridescenceThicknessMax = data2.iridescenceThicknessMaximum; + } + if (data2.hasOwnProperty("iridescenceThicknessTexture")) { + material.iridescenceThicknessMapChannel = "g"; + material.iridescenceThicknessMap = textures[data2.iridescenceThicknessTexture.index]; + extractTextureTransform(data2.iridescenceThicknessTexture, material, ["iridescenceThickness"]); + } +}; +var createMaterial = (gltfMaterial, textures, flipV) => { + const material = new StandardMaterial(); + material.occludeSpecular = SPECOCC_AO; + material.diffuseTint = true; + material.diffuseVertexColor = true; + material.specularTint = true; + material.specularVertexColor = true; + if (gltfMaterial.hasOwnProperty("name")) { + material.name = gltfMaterial.name; + } + let color, texture; + if (gltfMaterial.hasOwnProperty("pbrMetallicRoughness")) { + const pbrData = gltfMaterial.pbrMetallicRoughness; + if (pbrData.hasOwnProperty("baseColorFactor")) { + color = pbrData.baseColorFactor; + material.diffuse.set(Math.pow(color[0], 1 / 2.2), Math.pow(color[1], 1 / 2.2), Math.pow(color[2], 1 / 2.2)); + material.opacity = color[3]; + } else { + material.diffuse.set(1, 1, 1); + material.opacity = 1; + } + if (pbrData.hasOwnProperty("baseColorTexture")) { + const baseColorTexture = pbrData.baseColorTexture; + texture = textures[baseColorTexture.index]; + material.diffuseMap = texture; + material.diffuseMapChannel = "rgb"; + material.opacityMap = texture; + material.opacityMapChannel = "a"; + extractTextureTransform(baseColorTexture, material, ["diffuse", "opacity"]); + } + material.useMetalness = true; + material.specular.set(1, 1, 1); + if (pbrData.hasOwnProperty("metallicFactor")) { + material.metalness = pbrData.metallicFactor; + } else { + material.metalness = 1; + } + if (pbrData.hasOwnProperty("roughnessFactor")) { + material.gloss = pbrData.roughnessFactor; + } else { + material.gloss = 1; + } + material.glossInvert = true; + if (pbrData.hasOwnProperty("metallicRoughnessTexture")) { + const metallicRoughnessTexture = pbrData.metallicRoughnessTexture; + material.metalnessMap = material.glossMap = textures[metallicRoughnessTexture.index]; + material.metalnessMapChannel = "b"; + material.glossMapChannel = "g"; + extractTextureTransform(metallicRoughnessTexture, material, ["gloss", "metalness"]); + } + } + if (gltfMaterial.hasOwnProperty("normalTexture")) { + const normalTexture = gltfMaterial.normalTexture; + material.normalMap = textures[normalTexture.index]; + extractTextureTransform(normalTexture, material, ["normal"]); + if (normalTexture.hasOwnProperty("scale")) { + material.bumpiness = normalTexture.scale; + } + } + if (gltfMaterial.hasOwnProperty("occlusionTexture")) { + const occlusionTexture = gltfMaterial.occlusionTexture; + material.aoMap = textures[occlusionTexture.index]; + material.aoMapChannel = "r"; + extractTextureTransform(occlusionTexture, material, ["ao"]); + } + if (gltfMaterial.hasOwnProperty("emissiveFactor")) { + color = gltfMaterial.emissiveFactor; + material.emissive.set(Math.pow(color[0], 1 / 2.2), Math.pow(color[1], 1 / 2.2), Math.pow(color[2], 1 / 2.2)); + material.emissiveTint = true; + } else { + material.emissive.set(0, 0, 0); + material.emissiveTint = false; + } + if (gltfMaterial.hasOwnProperty("emissiveTexture")) { + const emissiveTexture = gltfMaterial.emissiveTexture; + material.emissiveMap = textures[emissiveTexture.index]; + extractTextureTransform(emissiveTexture, material, ["emissive"]); + } + if (gltfMaterial.hasOwnProperty("alphaMode")) { + switch (gltfMaterial.alphaMode) { + case "MASK": + material.blendType = BLEND_NONE; + if (gltfMaterial.hasOwnProperty("alphaCutoff")) { + material.alphaTest = gltfMaterial.alphaCutoff; + } else { + material.alphaTest = 0.5; + } + break; + case "BLEND": + material.blendType = BLEND_NORMAL; + material.depthWrite = false; + break; + default: + case "OPAQUE": + material.blendType = BLEND_NONE; + break; + } + } else { + material.blendType = BLEND_NONE; + } + if (gltfMaterial.hasOwnProperty("doubleSided")) { + material.twoSidedLighting = gltfMaterial.doubleSided; + material.cull = gltfMaterial.doubleSided ? CULLFACE_NONE : CULLFACE_BACK; + } else { + material.twoSidedLighting = false; + material.cull = CULLFACE_BACK; + } + const extensions = { + "KHR_materials_clearcoat": extensionClearCoat, + "KHR_materials_emissive_strength": extensionEmissiveStrength, + "KHR_materials_ior": extensionIor, + "KHR_materials_dispersion": extensionDispersion, + "KHR_materials_iridescence": extensionIridescence, + "KHR_materials_pbrSpecularGlossiness": extensionPbrSpecGlossiness, + "KHR_materials_sheen": extensionSheen, + "KHR_materials_specular": extensionSpecular, + "KHR_materials_transmission": extensionTransmission, + "KHR_materials_unlit": extensionUnlit, + "KHR_materials_volume": extensionVolume + }; + if (gltfMaterial.hasOwnProperty("extensions")) { + for (const key in gltfMaterial.extensions) { + const extensionFunc = extensions[key]; + if (extensionFunc !== void 0) { + extensionFunc(gltfMaterial.extensions[key], material, textures); + } + } + } + material.update(); + return material; +}; +var createAnimation = (gltfAnimation, animationIndex, gltfAccessors, bufferViews, nodes, meshes, gltfNodes) => { + const createAnimData = (gltfAccessor) => { + return new AnimData(getNumComponents(gltfAccessor.type), getAccessorDataFloat32(gltfAccessor, bufferViews)); + }; + const interpMap = { + "STEP": INTERPOLATION_STEP, + "LINEAR": INTERPOLATION_LINEAR, + "CUBICSPLINE": INTERPOLATION_CUBIC + }; + const inputMap = {}; + const outputMap = {}; + const curveMap = {}; + let outputCounter = 1; + let i; + for (i = 0; i < gltfAnimation.samplers.length; ++i) { + const sampler = gltfAnimation.samplers[i]; + if (!inputMap.hasOwnProperty(sampler.input)) { + inputMap[sampler.input] = createAnimData(gltfAccessors[sampler.input]); + } + if (!outputMap.hasOwnProperty(sampler.output)) { + outputMap[sampler.output] = createAnimData(gltfAccessors[sampler.output]); + } + const interpolation = sampler.hasOwnProperty("interpolation") && interpMap.hasOwnProperty(sampler.interpolation) ? interpMap[sampler.interpolation] : INTERPOLATION_LINEAR; + const curve = { + paths: [], + input: sampler.input, + output: sampler.output, + interpolation + }; + curveMap[i] = curve; + } + const quatArrays = []; + const transformSchema = { + "translation": "localPosition", + "rotation": "localRotation", + "scale": "localScale" + }; + const constructNodePath = (node) => { + const path2 = []; + while (node) { + path2.unshift(node.name); + node = node.parent; + } + return path2; + }; + const createMorphTargetCurves = (curve, gltfNode, entityPath) => { + const out = outputMap[curve.output]; + if (!out) { + return; + } + let targetNames; + if (meshes && meshes[gltfNode.mesh]) { + const mesh = meshes[gltfNode.mesh]; + if (mesh.hasOwnProperty("extras") && mesh.extras.hasOwnProperty("targetNames")) { + targetNames = mesh.extras.targetNames; + } + } + const outData = out.data; + const morphTargetCount = outData.length / inputMap[curve.input].data.length; + const keyframeCount = outData.length / morphTargetCount; + const singleBufferSize = keyframeCount * 4; + const buffer = new ArrayBuffer(singleBufferSize * morphTargetCount); + for (let j = 0; j < morphTargetCount; j++) { + var _targetNames; + const morphTargetOutput = new Float32Array(buffer, singleBufferSize * j, keyframeCount); + for (let k = 0; k < keyframeCount; k++) { + morphTargetOutput[k] = outData[k * morphTargetCount + j]; + } + const output = new AnimData(1, morphTargetOutput); + const weightName = (_targetNames = targetNames) != null && _targetNames[j] ? `name.${targetNames[j]}` : j; + outputMap[-outputCounter] = output; + const morphCurve = { + paths: [{ + entityPath, + component: "graph", + propertyPath: [`weight.${weightName}`] + }], + input: curve.input, + output: -outputCounter, + interpolation: curve.interpolation + }; + outputCounter++; + curveMap[`morphCurve-${i}-${j}`] = morphCurve; + } + }; + for (i = 0; i < gltfAnimation.channels.length; ++i) { + const channel = gltfAnimation.channels[i]; + const target2 = channel.target; + const curve = curveMap[channel.sampler]; + const node = nodes[target2.node]; + const gltfNode = gltfNodes[target2.node]; + const entityPath = constructNodePath(node); + if (target2.path.startsWith("weights")) { + createMorphTargetCurves(curve, gltfNode, entityPath); + curveMap[channel.sampler].morphCurve = true; + } else { + curve.paths.push({ + entityPath, + component: "graph", + propertyPath: [transformSchema[target2.path]] + }); + } + } + const inputs = []; + const outputs = []; + const curves = []; + for (const inputKey in inputMap) { + inputs.push(inputMap[inputKey]); + inputMap[inputKey] = inputs.length - 1; + } + for (const outputKey in outputMap) { + outputs.push(outputMap[outputKey]); + outputMap[outputKey] = outputs.length - 1; + } + for (const curveKey in curveMap) { + const curveData = curveMap[curveKey]; + if (curveData.morphCurve) { + continue; + } + curves.push(new AnimCurve(curveData.paths, inputMap[curveData.input], outputMap[curveData.output], curveData.interpolation)); + if (curveData.paths.length > 0 && curveData.paths[0].propertyPath[0] === "localRotation" && curveData.interpolation !== INTERPOLATION_CUBIC) { + quatArrays.push(curves[curves.length - 1].output); + } + } + quatArrays.sort(); + let prevIndex = null; + let data2; + for (i = 0; i < quatArrays.length; ++i) { + const index = quatArrays[i]; + if (i === 0 || index !== prevIndex) { + data2 = outputs[index]; + if (data2.components === 4) { + const d = data2.data; + const len = d.length - 4; + for (let j = 0; j < len; j += 4) { + const dp = d[j + 0] * d[j + 4] + d[j + 1] * d[j + 5] + d[j + 2] * d[j + 6] + d[j + 3] * d[j + 7]; + if (dp < 0) { + d[j + 4] *= -1; + d[j + 5] *= -1; + d[j + 6] *= -1; + d[j + 7] *= -1; + } + } + } + prevIndex = index; + } + } + let duration = 0; + for (i = 0; i < inputs.length; i++) { + data2 = inputs[i]._data; + duration = Math.max(duration, data2.length === 0 ? 0 : data2[data2.length - 1]); + } + return new AnimTrack(gltfAnimation.hasOwnProperty("name") ? gltfAnimation.name : "animation_" + animationIndex, duration, inputs, outputs, curves); +}; +var tempMat = new Mat4(); +var tempVec = new Vec3(); +var createNode = (gltfNode, nodeIndex) => { + const entity = new GraphNode(); + if (gltfNode.hasOwnProperty("name") && gltfNode.name.length > 0) { + entity.name = gltfNode.name; + } else { + entity.name = "node_" + nodeIndex; + } + if (gltfNode.hasOwnProperty("matrix")) { + tempMat.data.set(gltfNode.matrix); + tempMat.getTranslation(tempVec); + entity.setLocalPosition(tempVec); + tempMat.getEulerAngles(tempVec); + entity.setLocalEulerAngles(tempVec); + tempMat.getScale(tempVec); + entity.setLocalScale(tempVec); + } + if (gltfNode.hasOwnProperty("rotation")) { + const r = gltfNode.rotation; + entity.setLocalRotation(r[0], r[1], r[2], r[3]); + } + if (gltfNode.hasOwnProperty("translation")) { + const t = gltfNode.translation; + entity.setLocalPosition(t[0], t[1], t[2]); + } + if (gltfNode.hasOwnProperty("scale")) { + const s = gltfNode.scale; + entity.setLocalScale(s[0], s[1], s[2]); + } + return entity; +}; +var createCamera = (gltfCamera, node) => { + const projection = gltfCamera.type === "orthographic" ? PROJECTION_ORTHOGRAPHIC : PROJECTION_PERSPECTIVE; + const gltfProperties = projection === PROJECTION_ORTHOGRAPHIC ? gltfCamera.orthographic : gltfCamera.perspective; + const componentData = { + enabled: false, + projection, + nearClip: gltfProperties.znear, + aspectRatioMode: ASPECT_AUTO + }; + if (gltfProperties.zfar) { + componentData.farClip = gltfProperties.zfar; + } + if (projection === PROJECTION_ORTHOGRAPHIC) { + componentData.orthoHeight = 0.5 * gltfProperties.ymag; + if (gltfProperties.ymag) { + componentData.aspectRatioMode = ASPECT_MANUAL; + componentData.aspectRatio = gltfProperties.xmag / gltfProperties.ymag; + } + } else { + componentData.fov = gltfProperties.yfov * math.RAD_TO_DEG; + if (gltfProperties.aspectRatio) { + componentData.aspectRatioMode = ASPECT_MANUAL; + componentData.aspectRatio = gltfProperties.aspectRatio; + } + } + const cameraEntity = new Entity(gltfCamera.name); + cameraEntity.addComponent("camera", componentData); + return cameraEntity; +}; +var createLight = (gltfLight, node) => { + const lightProps = { + enabled: false, + type: gltfLight.type === "point" ? "omni" : gltfLight.type, + color: gltfLight.hasOwnProperty("color") ? new Color(gltfLight.color) : Color.WHITE, + range: gltfLight.hasOwnProperty("range") ? gltfLight.range : 9999, + falloffMode: LIGHTFALLOFF_INVERSESQUARED, + intensity: gltfLight.hasOwnProperty("intensity") ? math.clamp(gltfLight.intensity, 0, 2) : 1 + }; + if (gltfLight.hasOwnProperty("spot")) { + lightProps.innerConeAngle = gltfLight.spot.hasOwnProperty("innerConeAngle") ? gltfLight.spot.innerConeAngle * math.RAD_TO_DEG : 0; + lightProps.outerConeAngle = gltfLight.spot.hasOwnProperty("outerConeAngle") ? gltfLight.spot.outerConeAngle * math.RAD_TO_DEG : Math.PI / 4; + } + if (gltfLight.hasOwnProperty("intensity")) { + lightProps.luminance = gltfLight.intensity * Light.getLightUnitConversion(lightTypes[lightProps.type], lightProps.outerConeAngle, lightProps.innerConeAngle); + } + const lightEntity = new Entity(node.name); + lightEntity.rotateLocal(90, 0, 0); + lightEntity.addComponent("light", lightProps); + return lightEntity; +}; +var createSkins = (device, gltf, nodes, bufferViews) => { + if (!gltf.hasOwnProperty("skins") || gltf.skins.length === 0) { + return []; + } + const glbSkins = /* @__PURE__ */ new Map(); + return gltf.skins.map((gltfSkin) => { + return createSkin(device, gltfSkin, gltf.accessors, bufferViews, nodes, glbSkins); + }); +}; +var createMeshes = (device, gltf, bufferViews, flipV, options) => { + var _gltf$meshes, _gltf$accessors, _gltf$bufferViews; + const vertexBufferDict = {}; + const meshVariants = {}; + const meshDefaultMaterials = {}; + const promises = []; + const valid = !options.skipMeshes && (gltf == null || (_gltf$meshes = gltf.meshes) == null ? void 0 : _gltf$meshes.length) && (gltf == null || (_gltf$accessors = gltf.accessors) == null ? void 0 : _gltf$accessors.length) && (gltf == null || (_gltf$bufferViews = gltf.bufferViews) == null ? void 0 : _gltf$bufferViews.length); + const meshes = valid ? gltf.meshes.map((gltfMesh) => { + return createMesh(device, gltfMesh, gltf.accessors, bufferViews, flipV, vertexBufferDict, meshVariants, meshDefaultMaterials, options, promises); + }) : []; + return { + meshes, + meshVariants, + meshDefaultMaterials, + promises + }; +}; +var createMaterials = (gltf, textures, options, flipV) => { + var _options$material, _options$material$pro, _options$material2, _options$material3; + if (!gltf.hasOwnProperty("materials") || gltf.materials.length === 0) { + return []; + } + const preprocess = options == null || (_options$material = options.material) == null ? void 0 : _options$material.preprocess; + const process = (_options$material$pro = options == null || (_options$material2 = options.material) == null ? void 0 : _options$material2.process) != null ? _options$material$pro : createMaterial; + const postprocess = options == null || (_options$material3 = options.material) == null ? void 0 : _options$material3.postprocess; + return gltf.materials.map((gltfMaterial) => { + if (preprocess) { + preprocess(gltfMaterial); + } + const material = process(gltfMaterial, textures, flipV); + if (postprocess) { + postprocess(gltfMaterial, material); + } + return material; + }); +}; +var createVariants = (gltf) => { + if (!gltf.hasOwnProperty("extensions") || !gltf.extensions.hasOwnProperty("KHR_materials_variants")) return null; + const data2 = gltf.extensions.KHR_materials_variants.variants; + const variants = {}; + for (let i = 0; i < data2.length; i++) { + variants[data2[i].name] = i; + } + return variants; +}; +var createAnimations = (gltf, nodes, bufferViews, options) => { + var _options$animation, _options$animation2; + if (!gltf.hasOwnProperty("animations") || gltf.animations.length === 0) { + return []; + } + const preprocess = options == null || (_options$animation = options.animation) == null ? void 0 : _options$animation.preprocess; + const postprocess = options == null || (_options$animation2 = options.animation) == null ? void 0 : _options$animation2.postprocess; + return gltf.animations.map((gltfAnimation, index) => { + if (preprocess) { + preprocess(gltfAnimation); + } + const animation = createAnimation(gltfAnimation, index, gltf.accessors, bufferViews, nodes, gltf.meshes, gltf.nodes); + if (postprocess) { + postprocess(gltfAnimation, animation); + } + return animation; + }); +}; +var createNodes = (gltf, options) => { + var _options$node, _options$node$process, _options$node2, _options$node3; + if (!gltf.hasOwnProperty("nodes") || gltf.nodes.length === 0) { + return []; + } + const preprocess = options == null || (_options$node = options.node) == null ? void 0 : _options$node.preprocess; + const process = (_options$node$process = options == null || (_options$node2 = options.node) == null ? void 0 : _options$node2.process) != null ? _options$node$process : createNode; + const postprocess = options == null || (_options$node3 = options.node) == null ? void 0 : _options$node3.postprocess; + const nodes = gltf.nodes.map((gltfNode, index) => { + if (preprocess) { + preprocess(gltfNode); + } + const node = process(gltfNode, index); + if (postprocess) { + postprocess(gltfNode, node); + } + return node; + }); + for (let i = 0; i < gltf.nodes.length; ++i) { + const gltfNode = gltf.nodes[i]; + if (gltfNode.hasOwnProperty("children")) { + const parent = nodes[i]; + const uniqueNames = {}; + for (let j = 0; j < gltfNode.children.length; ++j) { + const child = nodes[gltfNode.children[j]]; + if (!child.parent) { + if (uniqueNames.hasOwnProperty(child.name)) { + child.name += uniqueNames[child.name]++; + } else { + uniqueNames[child.name] = 1; + } + parent.addChild(child); + } + } + } + } + return nodes; +}; +var createScenes = (gltf, nodes) => { + var _gltf$scenes$0$nodes; + const scenes = []; + const count = gltf.scenes.length; + if (count === 1 && ((_gltf$scenes$0$nodes = gltf.scenes[0].nodes) == null ? void 0 : _gltf$scenes$0$nodes.length) === 1) { + const nodeIndex = gltf.scenes[0].nodes[0]; + scenes.push(nodes[nodeIndex]); + } else { + for (let i = 0; i < count; i++) { + const scene2 = gltf.scenes[i]; + if (scene2.nodes) { + const sceneRoot = new GraphNode(scene2.name); + for (let n = 0; n < scene2.nodes.length; n++) { + const childNode = nodes[scene2.nodes[n]]; + sceneRoot.addChild(childNode); + } + scenes.push(sceneRoot); + } + } + } + return scenes; +}; +var createCameras = (gltf, nodes, options) => { + let cameras = null; + if (gltf.hasOwnProperty("nodes") && gltf.hasOwnProperty("cameras") && gltf.cameras.length > 0) { + var _options$camera, _options$camera$proce, _options$camera2, _options$camera3; + const preprocess = options == null || (_options$camera = options.camera) == null ? void 0 : _options$camera.preprocess; + const process = (_options$camera$proce = options == null || (_options$camera2 = options.camera) == null ? void 0 : _options$camera2.process) != null ? _options$camera$proce : createCamera; + const postprocess = options == null || (_options$camera3 = options.camera) == null ? void 0 : _options$camera3.postprocess; + gltf.nodes.forEach((gltfNode, nodeIndex) => { + if (gltfNode.hasOwnProperty("camera")) { + const gltfCamera = gltf.cameras[gltfNode.camera]; + if (gltfCamera) { + if (preprocess) { + preprocess(gltfCamera); + } + const camera = process(gltfCamera, nodes[nodeIndex]); + if (postprocess) { + postprocess(gltfCamera, camera); + } + if (camera) { + if (!cameras) cameras = /* @__PURE__ */ new Map(); + cameras.set(gltfNode, camera); + } + } + } + }); + } + return cameras; +}; +var createLights = (gltf, nodes, options) => { + let lights2 = null; + if (gltf.hasOwnProperty("nodes") && gltf.hasOwnProperty("extensions") && gltf.extensions.hasOwnProperty("KHR_lights_punctual") && gltf.extensions.KHR_lights_punctual.hasOwnProperty("lights")) { + const gltfLights = gltf.extensions.KHR_lights_punctual.lights; + if (gltfLights.length) { + var _options$light, _options$light$proces, _options$light2, _options$light3; + const preprocess = options == null || (_options$light = options.light) == null ? void 0 : _options$light.preprocess; + const process = (_options$light$proces = options == null || (_options$light2 = options.light) == null ? void 0 : _options$light2.process) != null ? _options$light$proces : createLight; + const postprocess = options == null || (_options$light3 = options.light) == null ? void 0 : _options$light3.postprocess; + gltf.nodes.forEach((gltfNode, nodeIndex) => { + if (gltfNode.hasOwnProperty("extensions") && gltfNode.extensions.hasOwnProperty("KHR_lights_punctual") && gltfNode.extensions.KHR_lights_punctual.hasOwnProperty("light")) { + const lightIndex = gltfNode.extensions.KHR_lights_punctual.light; + const gltfLight = gltfLights[lightIndex]; + if (gltfLight) { + if (preprocess) { + preprocess(gltfLight); + } + const light = process(gltfLight, nodes[nodeIndex]); + if (postprocess) { + postprocess(gltfLight, light); + } + if (light) { + if (!lights2) lights2 = /* @__PURE__ */ new Map(); + lights2.set(gltfNode, light); + } + } + } + }); + } + } + return lights2; +}; +var linkSkins = (gltf, renders, skins) => { + gltf.nodes.forEach((gltfNode) => { + if (gltfNode.hasOwnProperty("mesh") && gltfNode.hasOwnProperty("skin")) { + const meshGroup = renders[gltfNode.mesh].meshes; + meshGroup.forEach((mesh) => { + mesh.skin = skins[gltfNode.skin]; + }); + } + }); +}; +var createResources = async (device, gltf, bufferViews, textures, options) => { + var _options$global, _options$global2; + const preprocess = options == null || (_options$global = options.global) == null ? void 0 : _options$global.preprocess; + const postprocess = options == null || (_options$global2 = options.global) == null ? void 0 : _options$global2.postprocess; + if (preprocess) { + preprocess(gltf); + } + const flipV = gltf.asset && gltf.asset.generator === "PlayCanvas"; + const nodes = createNodes(gltf, options); + const scenes = createScenes(gltf, nodes); + const lights2 = createLights(gltf, nodes, options); + const cameras = createCameras(gltf, nodes, options); + const variants = createVariants(gltf); + const bufferViewData = await Promise.all(bufferViews); + const { + meshes, + meshVariants, + meshDefaultMaterials, + promises + } = createMeshes(device, gltf, bufferViewData, flipV, options); + const animations = createAnimations(gltf, nodes, bufferViewData, options); + const textureAssets = await Promise.all(textures); + const textureInstances = textureAssets.map((t) => t.resource); + const materials = createMaterials(gltf, textureInstances, options, flipV); + const skins = createSkins(device, gltf, nodes, bufferViewData); + const renders = []; + for (let i = 0; i < meshes.length; i++) { + renders[i] = new Render(); + renders[i].meshes = meshes[i]; + } + linkSkins(gltf, renders, skins); + const result = new GlbResources(); + result.gltf = gltf; + result.nodes = nodes; + result.scenes = scenes; + result.animations = animations; + result.textures = textureAssets; + result.materials = materials; + result.variants = variants; + result.meshVariants = meshVariants; + result.meshDefaultMaterials = meshDefaultMaterials; + result.renders = renders; + result.skins = skins; + result.lights = lights2; + result.cameras = cameras; + if (postprocess) { + postprocess(gltf, result); + } + await Promise.all(promises); + return result; +}; +var applySampler = (texture, gltfSampler) => { + const getFilter = (filter, defaultValue) => { + switch (filter) { + case 9728: + return FILTER_NEAREST; + case 9729: + return FILTER_LINEAR; + case 9984: + return FILTER_NEAREST_MIPMAP_NEAREST; + case 9985: + return FILTER_LINEAR_MIPMAP_NEAREST; + case 9986: + return FILTER_NEAREST_MIPMAP_LINEAR; + case 9987: + return FILTER_LINEAR_MIPMAP_LINEAR; + default: + return defaultValue; + } + }; + const getWrap = (wrap, defaultValue) => { + switch (wrap) { + case 33071: + return ADDRESS_CLAMP_TO_EDGE; + case 33648: + return ADDRESS_MIRRORED_REPEAT; + case 10497: + return ADDRESS_REPEAT; + default: + return defaultValue; + } + }; + if (texture) { + var _gltfSampler; + gltfSampler = (_gltfSampler = gltfSampler) != null ? _gltfSampler : {}; + texture.minFilter = getFilter(gltfSampler.minFilter, FILTER_LINEAR_MIPMAP_LINEAR); + texture.magFilter = getFilter(gltfSampler.magFilter, FILTER_LINEAR); + texture.addressU = getWrap(gltfSampler.wrapS, ADDRESS_REPEAT); + texture.addressV = getWrap(gltfSampler.wrapT, ADDRESS_REPEAT); + } +}; +var gltfTextureUniqueId = 0; +var createImages = (gltf, bufferViews, urlBase, registry, options) => { + var _options$image, _options$image2, _options$image3; + if (!gltf.images || gltf.images.length === 0) { + return []; + } + const preprocess = options == null || (_options$image = options.image) == null ? void 0 : _options$image.preprocess; + const processAsync = options == null || (_options$image2 = options.image) == null ? void 0 : _options$image2.processAsync; + const postprocess = options == null || (_options$image3 = options.image) == null ? void 0 : _options$image3.postprocess; + const mimeTypeFileExtensions = { + "image/png": "png", + "image/jpeg": "jpg", + "image/basis": "basis", + "image/ktx": "ktx", + "image/ktx2": "ktx2", + "image/vnd-ms.dds": "dds" + }; + const loadTexture = (gltfImage, url, bufferView, mimeType, options2) => { + return new Promise((resolve, reject) => { + const continuation = (bufferViewData) => { + const name = (gltfImage.name || "gltf-texture") + "-" + gltfTextureUniqueId++; + const file = { + url: url || name + }; + if (bufferViewData) { + file.contents = bufferViewData.slice(0).buffer; + } + if (mimeType) { + const extension = mimeTypeFileExtensions[mimeType]; + if (extension) { + file.filename = file.url + "." + extension; + } + } + const asset2 = new Asset(name, "texture", file, null, options2); + asset2.on("load", (asset3) => resolve(asset3)); + asset2.on("error", (err) => reject(err)); + registry.add(asset2); + registry.load(asset2); + }; + if (bufferView) { + bufferView.then((bufferViewData) => continuation(bufferViewData)); + } else { + continuation(null); + } + }); + }; + return gltf.images.map((gltfImage, i) => { + if (preprocess) { + preprocess(gltfImage); + } + let promise; + if (processAsync) { + promise = new Promise((resolve, reject) => { + processAsync(gltfImage, (err, textureAsset) => { + if (err) reject(err); + else resolve(textureAsset); + }); + }); + } else { + promise = new Promise((resolve) => { + resolve(null); + }); + } + promise = promise.then((textureAsset) => { + if (textureAsset) { + return textureAsset; + } else if (gltfImage.hasOwnProperty("uri")) { + if (isDataURI(gltfImage.uri)) { + return loadTexture(gltfImage, gltfImage.uri, null, getDataURIMimeType(gltfImage.uri), null); + } + return loadTexture(gltfImage, ABSOLUTE_URL.test(gltfImage.uri) ? gltfImage.uri : path.join(urlBase, gltfImage.uri), null, null, { + crossOrigin: "anonymous" + }); + } else if (gltfImage.hasOwnProperty("bufferView") && gltfImage.hasOwnProperty("mimeType")) { + return loadTexture(gltfImage, null, bufferViews[gltfImage.bufferView], gltfImage.mimeType, null); + } + return Promise.reject(new Error(`Invalid image found in gltf (neither uri or bufferView found). index=${i}`)); + }); + if (postprocess) { + promise = promise.then((textureAsset) => { + postprocess(gltfImage, textureAsset); + return textureAsset; + }); + } + return promise; + }); +}; +var createTextures = (gltf, images, options) => { + var _gltf$images, _gltf$textures, _options$texture, _options$texture2, _options$texture3; + if (!(gltf != null && (_gltf$images = gltf.images) != null && _gltf$images.length) || !(gltf != null && (_gltf$textures = gltf.textures) != null && _gltf$textures.length)) { + return []; + } + const preprocess = options == null || (_options$texture = options.texture) == null ? void 0 : _options$texture.preprocess; + const processAsync = options == null || (_options$texture2 = options.texture) == null ? void 0 : _options$texture2.processAsync; + const postprocess = options == null || (_options$texture3 = options.texture) == null ? void 0 : _options$texture3.postprocess; + const seenImages = /* @__PURE__ */ new Set(); + return gltf.textures.map((gltfTexture) => { + if (preprocess) { + preprocess(gltfTexture); + } + let promise; + if (processAsync) { + promise = new Promise((resolve, reject) => { + processAsync(gltfTexture, gltf.images, (err, gltfImageIndex) => { + if (err) reject(err); + else resolve(gltfImageIndex); + }); + }); + } else { + promise = new Promise((resolve) => { + resolve(null); + }); + } + promise = promise.then((gltfImageIndex) => { + var _ref4, _ref22, _gltfImageIndex, _gltfTexture$extensio, _gltfTexture$extensio2; + gltfImageIndex = (_ref4 = (_ref22 = (_gltfImageIndex = gltfImageIndex) != null ? _gltfImageIndex : gltfTexture == null || (_gltfTexture$extensio = gltfTexture.extensions) == null || (_gltfTexture$extensio = _gltfTexture$extensio.KHR_texture_basisu) == null ? void 0 : _gltfTexture$extensio.source) != null ? _ref22 : gltfTexture == null || (_gltfTexture$extensio2 = gltfTexture.extensions) == null || (_gltfTexture$extensio2 = _gltfTexture$extensio2.EXT_texture_webp) == null ? void 0 : _gltfTexture$extensio2.source) != null ? _ref4 : gltfTexture.source; + const cloneAsset = seenImages.has(gltfImageIndex); + seenImages.add(gltfImageIndex); + return images[gltfImageIndex].then((imageAsset) => { + var _gltf$samplers; + const asset2 = cloneAsset ? cloneTextureAsset(imageAsset) : imageAsset; + applySampler(asset2.resource, ((_gltf$samplers = gltf.samplers) != null ? _gltf$samplers : [])[gltfTexture.sampler]); + return asset2; + }); + }); + if (postprocess) { + promise = promise.then((textureAsset) => { + postprocess(gltfTexture, textureAsset); + return textureAsset; + }); + } + return promise; + }); +}; +var loadBuffers = (gltf, binaryChunk, urlBase, options) => { + var _options$buffer, _options$buffer2, _options$buffer3; + if (!gltf.buffers || gltf.buffers.length === 0) { + return []; + } + const preprocess = options == null || (_options$buffer = options.buffer) == null ? void 0 : _options$buffer.preprocess; + const processAsync = options == null || (_options$buffer2 = options.buffer) == null ? void 0 : _options$buffer2.processAsync; + const postprocess = options == null || (_options$buffer3 = options.buffer) == null ? void 0 : _options$buffer3.postprocess; + return gltf.buffers.map((gltfBuffer, i) => { + if (preprocess) { + preprocess(gltfBuffer); + } + let promise; + if (processAsync) { + promise = new Promise((resolve, reject) => { + processAsync(gltfBuffer, (err, arrayBuffer) => { + if (err) reject(err); + else resolve(arrayBuffer); + }); + }); + } else { + promise = new Promise((resolve) => { + resolve(null); + }); + } + promise = promise.then((arrayBuffer) => { + if (arrayBuffer) { + return arrayBuffer; + } else if (gltfBuffer.hasOwnProperty("uri")) { + if (isDataURI(gltfBuffer.uri)) { + const byteString = atob(gltfBuffer.uri.split(",")[1]); + const binaryArray = new Uint8Array(byteString.length); + for (let j = 0; j < byteString.length; j++) { + binaryArray[j] = byteString.charCodeAt(j); + } + return binaryArray; + } + return new Promise((resolve, reject) => { + http.get(ABSOLUTE_URL.test(gltfBuffer.uri) ? gltfBuffer.uri : path.join(urlBase, gltfBuffer.uri), { + cache: true, + responseType: "arraybuffer", + retry: false + }, (err, result) => { + if (err) reject(err); + else resolve(new Uint8Array(result)); + }); + }); + } + return binaryChunk; + }); + if (postprocess) { + promise = promise.then((buffer) => { + postprocess(gltf.buffers[i], buffer); + return buffer; + }); + } + return promise; + }); +}; +var parseGltf = (gltfChunk, callback) => { + const decodeBinaryUtf8 = (array2) => { + if (typeof TextDecoder !== "undefined") { + return new TextDecoder().decode(array2); + } + let str = ""; + for (let i = 0; i < array2.length; i++) { + str += String.fromCharCode(array2[i]); + } + return decodeURIComponent(escape(str)); + }; + const gltf = JSON.parse(decodeBinaryUtf8(gltfChunk)); + if (gltf.asset && gltf.asset.version && parseFloat(gltf.asset.version) < 2) { + callback(`Invalid gltf version. Expected version 2.0 or above but found version '${gltf.asset.version}'.`); + return; + } + callback(null, gltf); +}; +var parseGlb = (glbData, callback) => { + const data2 = glbData instanceof ArrayBuffer ? new DataView(glbData) : new DataView(glbData.buffer, glbData.byteOffset, glbData.byteLength); + const magic = data2.getUint32(0, true); + const version2 = data2.getUint32(4, true); + const length = data2.getUint32(8, true); + if (magic !== 1179937895) { + callback("Invalid magic number found in glb header. Expected 0x46546C67, found 0x" + magic.toString(16)); + return; + } + if (version2 !== 2) { + callback("Invalid version number found in glb header. Expected 2, found " + version2); + return; + } + if (length <= 0 || length > data2.byteLength) { + callback("Invalid length found in glb header. Found " + length); + return; + } + const chunks = []; + let offset = 12; + while (offset < length) { + const chunkLength = data2.getUint32(offset, true); + if (offset + chunkLength + 8 > data2.byteLength) { + callback(`Invalid chunk length found in glb. Found ${chunkLength}`); + } + const chunkType = data2.getUint32(offset + 4, true); + const chunkData = new Uint8Array(data2.buffer, data2.byteOffset + offset + 8, chunkLength); + chunks.push({ + length: chunkLength, + type: chunkType, + data: chunkData + }); + offset += chunkLength + 8; + } + if (chunks.length !== 1 && chunks.length !== 2) { + callback("Invalid number of chunks found in glb file."); + return; + } + if (chunks[0].type !== 1313821514) { + callback(`Invalid chunk type found in glb file. Expected 0x4E4F534A, found 0x${chunks[0].type.toString(16)}`); + return; + } + if (chunks.length > 1 && chunks[1].type !== 5130562) { + callback(`Invalid chunk type found in glb file. Expected 0x004E4942, found 0x${chunks[1].type.toString(16)}`); + return; + } + callback(null, { + gltfChunk: chunks[0].data, + binaryChunk: chunks.length === 2 ? chunks[1].data : null + }); +}; +var parseChunk = (filename, data2, callback) => { + const hasGlbHeader = () => { + const u8 = new Uint8Array(data2); + return u8[0] === 103 && u8[1] === 108 && u8[2] === 84 && u8[3] === 70; + }; + if (filename && filename.toLowerCase().endsWith(".glb") || hasGlbHeader()) { + parseGlb(data2, callback); + } else { + callback(null, { + gltfChunk: data2, + binaryChunk: null + }); + } +}; +var createBufferViews = (gltf, buffers, options) => { + var _options$bufferView, _options$bufferView2, _options$bufferView3, _gltf$bufferViews2; + const result = []; + const preprocess = options == null || (_options$bufferView = options.bufferView) == null ? void 0 : _options$bufferView.preprocess; + const processAsync = options == null || (_options$bufferView2 = options.bufferView) == null ? void 0 : _options$bufferView2.processAsync; + const postprocess = options == null || (_options$bufferView3 = options.bufferView) == null ? void 0 : _options$bufferView3.postprocess; + if (!((_gltf$bufferViews2 = gltf.bufferViews) != null && _gltf$bufferViews2.length)) { + return result; + } + for (let i = 0; i < gltf.bufferViews.length; ++i) { + const gltfBufferView = gltf.bufferViews[i]; + if (preprocess) { + preprocess(gltfBufferView); + } + let promise; + if (processAsync) { + promise = new Promise((resolve, reject) => { + processAsync(gltfBufferView, buffers, (err, result2) => { + if (err) reject(err); + else resolve(result2); + }); + }); + } else { + promise = new Promise((resolve) => { + resolve(null); + }); + } + promise = promise.then((buffer) => { + if (buffer) { + return buffer; + } + return buffers[gltfBufferView.buffer].then((buffer2) => { + return new Uint8Array(buffer2.buffer, buffer2.byteOffset + (gltfBufferView.byteOffset || 0), gltfBufferView.byteLength); + }); + }); + if (gltfBufferView.hasOwnProperty("byteStride")) { + promise = promise.then((typedArray) => { + typedArray.byteStride = gltfBufferView.byteStride; + return typedArray; + }); + } + if (postprocess) { + promise = promise.then((typedArray) => { + postprocess(gltfBufferView, typedArray); + return typedArray; + }); + } + result.push(promise); + } + return result; +}; +var GlbParser = class { + static parse(filename, urlBase, data2, device, registry, options, callback) { + parseChunk(filename, data2, (err, chunks) => { + if (err) { + callback(err); + return; + } + parseGltf(chunks.gltfChunk, (err2, gltf) => { + if (err2) { + callback(err2); + return; + } + const buffers = loadBuffers(gltf, chunks.binaryChunk, urlBase, options); + const bufferViews = createBufferViews(gltf, buffers, options); + const images = createImages(gltf, bufferViews, urlBase, registry, options); + const textures = createTextures(gltf, images, options); + createResources(device, gltf, bufferViews, textures, options).then((result) => callback(null, result)).catch((err3) => callback(err3)); + }); + }); + } + static createDefaultMaterial() { + return createMaterial({ + name: "defaultGlbMaterial" + }, []); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/handlers/animation.js +var AnimationHandler = class extends ResourceHandler { + constructor(app2) { + super(app2, "animation"); + this.device = app2.graphicsDevice; + this.assets = app2.assets; + } + load(url, callback, asset2) { + if (typeof url === "string") { + url = { + load: url, + original: url + }; + } + const options = { + retry: this.maxRetries > 0, + maxRetries: this.maxRetries + }; + if (url.load.startsWith("blob:") || url.load.startsWith("data:")) { + if (path.getExtension(url.original).toLowerCase() === ".glb") { + options.responseType = Http.ResponseType.ARRAY_BUFFER; + } else { + options.responseType = Http.ResponseType.JSON; + } + } + http.get(url.load, options, (err, response) => { + if (err) { + callback(`Error loading animation resource: ${url.original} [${err}]`); + } else { + if (path.getExtension(url.original).toLowerCase() === ".glb") { + var _asset$options; + GlbParser.parse("filename.glb", "", response, this.device, this.assets, (_asset$options = asset2 == null ? void 0 : asset2.options) != null ? _asset$options : {}, (err2, parseResult) => { + if (err2) { + callback(err2); + } else { + var _asset$data; + const animations = parseResult.animations; + if (asset2 != null && (_asset$data = asset2.data) != null && _asset$data.events) { + for (let i = 0; i < animations.length; i++) { + animations[i].events = new AnimEvents(Object.values(asset2.data.events)); + } + } + parseResult.destroy(); + callback(null, animations); + } + }); + } else { + callback(null, this["_parseAnimationV" + response.animation.version](response)); + } + } + }); + } + open(url, data2, asset2) { + return data2; + } + _parseAnimationV3(data2) { + const animData = data2.animation; + const anim2 = new Animation(); + anim2.name = animData.name; + anim2.duration = animData.duration; + for (let i = 0; i < animData.nodes.length; i++) { + const node = new Node(); + const n = animData.nodes[i]; + node._name = n.name; + for (let j = 0; j < n.keys.length; j++) { + const k = n.keys[j]; + const t = k.time; + const p = k.pos; + const r = k.rot; + const s = k.scale; + const pos = new Vec3(p[0], p[1], p[2]); + const rot = new Quat2().setFromEulerAngles(r[0], r[1], r[2]); + const scl = new Vec3(s[0], s[1], s[2]); + const key = new Key(t, pos, rot, scl); + node._keys.push(key); + } + anim2.addNode(node); + } + return anim2; + } + _parseAnimationV4(data2) { + const animData = data2.animation; + const anim2 = new Animation(); + anim2.name = animData.name; + anim2.duration = animData.duration; + for (let i = 0; i < animData.nodes.length; i++) { + const node = new Node(); + const n = animData.nodes[i]; + node._name = n.name; + const defPos = n.defaults.p; + const defRot = n.defaults.r; + const defScl = n.defaults.s; + for (let j = 0; j < n.keys.length; j++) { + const k = n.keys[j]; + const t = k.t; + const p = defPos ? defPos : k.p; + const r = defRot ? defRot : k.r; + const s = defScl ? defScl : k.s; + const pos = new Vec3(p[0], p[1], p[2]); + const rot = new Quat2().setFromEulerAngles(r[0], r[1], r[2]); + const scl = new Vec3(s[0], s[1], s[2]); + const key = new Key(t, pos, rot, scl); + node._keys.push(key); + } + anim2.addNode(node); + } + return anim2; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/handlers/audio.js +var ie = function() { + if (typeof window === "undefined") { + return false; + } + const ua2 = window.navigator.userAgent; + const msie = ua2.indexOf("MSIE "); + if (msie > 0) { + return parseInt(ua2.substring(msie + 5, ua2.indexOf(".", msie)), 10); + } + const trident = ua2.indexOf("Trident/"); + if (trident > 0) { + const rv = ua2.indexOf("rv:"); + return parseInt(ua2.substring(rv + 3, ua2.indexOf(".", rv)), 10); + } + return false; +}(); +var supportedExtensions = [".ogg", ".mp3", ".wav", ".mp4a", ".m4a", ".mp4", ".aac", ".opus"]; +var AudioHandler = class extends ResourceHandler { + constructor(app2) { + super(app2, "audio"); + this.manager = app2.soundManager; + } + _isSupported(url) { + const ext = path.getExtension(url); + return supportedExtensions.indexOf(ext) > -1; + } + load(url, callback) { + if (typeof url === "string") { + url = { + load: url, + original: url + }; + } + const success = function success2(resource) { + callback(null, new Sound(resource)); + }; + const error = function error2(err) { + let msg = "Error loading audio url: " + url.original; + if (err) { + msg += ": " + (err.message || err); + } + console.warn(msg); + callback(msg); + }; + if (this._createSound) { + if (!this._isSupported(url.original)) { + error(`Audio format for ${url.original} not supported`); + return; + } + this._createSound(url.load, success, error); + } else { + error(null); + } + } + _createSound(url, success, error) { + if (hasAudioContext()) { + const manager = this.manager; + if (!manager.context) { + error("Audio manager has no audio context"); + return; + } + const options = { + retry: this.maxRetries > 0, + maxRetries: this.maxRetries + }; + if (url.startsWith("blob:") || url.startsWith("data:")) { + options.responseType = Http.ResponseType.ARRAY_BUFFER; + } + http.get(url, options, function(err, response) { + if (err) { + error(err); + return; + } + manager.context.decodeAudioData(response, success, error); + }); + } else { + let audio2 = null; + try { + audio2 = new Audio(); + } catch (e) { + error("No support for Audio element"); + return; + } + if (ie) { + document.body.appendChild(audio2); + } + const onReady = function onReady2() { + audio2.removeEventListener("canplaythrough", onReady2); + if (ie) { + document.body.removeChild(audio2); + } + success(audio2); + }; + audio2.onerror = function() { + audio2.onerror = null; + if (ie) { + document.body.removeChild(audio2); + } + error(); + }; + audio2.addEventListener("canplaythrough", onReady); + audio2.src = url; + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/parsers/glb-container-resource.js +var GlbContainerResource = class _GlbContainerResource { + constructor(data2, asset2, assets, defaultMaterial) { + const createAsset = function createAsset2(type2, resource, index) { + const subAsset = _GlbContainerResource.createAsset(asset2.name, type2, resource, index); + assets.add(subAsset); + return subAsset; + }; + const renders = []; + for (let i = 0; i < data2.renders.length; ++i) { + renders.push(createAsset("render", data2.renders[i], i)); + } + const materials = []; + for (let i = 0; i < data2.materials.length; ++i) { + materials.push(createAsset("material", data2.materials[i], i)); + } + const animations = []; + for (let i = 0; i < data2.animations.length; ++i) { + animations.push(createAsset("animation", data2.animations[i], i)); + } + this.data = data2; + this._model = null; + this._assetName = asset2.name; + this._assets = assets; + this._defaultMaterial = defaultMaterial; + this.renders = renders; + this.materials = materials; + this.textures = data2.textures; + this.animations = animations; + } + get model() { + if (!this._model) { + const model = _GlbContainerResource.createModel(this.data, this._defaultMaterial); + const modelAsset = _GlbContainerResource.createAsset(this._assetName, "model", model, 0); + this._assets.add(modelAsset); + this._model = modelAsset; + } + return this._model; + } + static createAsset(assetName, type2, resource, index) { + const subAsset = new Asset(assetName + "/" + type2 + "/" + index, type2, { + url: "" + }); + subAsset.resource = resource; + subAsset.loaded = true; + return subAsset; + } + instantiateModelEntity(options) { + const entity = new Entity(); + entity.addComponent("model", Object.assign({ + type: "asset", + asset: this.model + }, options)); + return entity; + } + instantiateRenderEntity(options) { + const defaultMaterial = this._defaultMaterial; + const skinnedMeshInstances = []; + const createMeshInstance = function createMeshInstance2(root, entity, mesh, materials, meshDefaultMaterials, skins, gltfNode) { + const materialIndex = meshDefaultMaterials[mesh.id]; + const material = materialIndex === void 0 ? defaultMaterial : materials[materialIndex]; + const meshInstance = new MeshInstance(mesh, material); + if (mesh.morph) { + meshInstance.morphInstance = new MorphInstance(mesh.morph); + } + if (gltfNode.hasOwnProperty("skin")) { + skinnedMeshInstances.push({ + meshInstance, + rootBone: root, + entity + }); + } + return meshInstance; + }; + const cloneHierarchy = (root, node, glb) => { + const entity = new Entity(); + node._cloneInternal(entity); + if (!root) root = entity; + let attachedMi = null; + let renderAsset = null; + for (let i = 0; i < glb.nodes.length; i++) { + const glbNode = glb.nodes[i]; + if (glbNode === node) { + const gltfNode = glb.gltf.nodes[i]; + if (gltfNode.hasOwnProperty("mesh")) { + const meshGroup = glb.renders[gltfNode.mesh].meshes; + renderAsset = this.renders[gltfNode.mesh]; + for (let mi = 0; mi < meshGroup.length; mi++) { + const mesh = meshGroup[mi]; + if (mesh) { + const cloneMi = createMeshInstance(root, entity, mesh, glb.materials, glb.meshDefaultMaterials, glb.skins, gltfNode); + if (!attachedMi) { + attachedMi = []; + } + attachedMi.push(cloneMi); + } + } + } + if (glb.lights) { + const lightEntity = glb.lights.get(gltfNode); + if (lightEntity) { + entity.addChild(lightEntity.clone()); + } + } + if (glb.cameras) { + const cameraEntity = glb.cameras.get(gltfNode); + if (cameraEntity) { + cameraEntity.camera.system.cloneComponent(cameraEntity, entity); + } + } + } + } + if (attachedMi) { + entity.addComponent("render", Object.assign({ + type: "asset", + meshInstances: attachedMi, + rootBone: root + }, options)); + entity.render.assignAsset(renderAsset); + } + const children = node.children; + for (let i = 0; i < children.length; i++) { + const childClone = cloneHierarchy(root, children[i], glb); + entity.addChild(childClone); + } + return entity; + }; + const sceneClones = []; + for (const scene2 of this.data.scenes) { + sceneClones.push(cloneHierarchy(null, scene2, this.data)); + } + skinnedMeshInstances.forEach((data2) => { + data2.meshInstance.skinInstance = SkinInstanceCache.createCachedSkinInstance(data2.meshInstance.mesh.skin, data2.rootBone, data2.entity); + }); + return _GlbContainerResource.createSceneHierarchy(sceneClones, Entity); + } + getMaterialVariants() { + return this.data.variants ? Object.keys(this.data.variants) : []; + } + applyMaterialVariant(entity, name) { + const variant = name ? this.data.variants[name] : null; + if (variant === void 0) { + return; + } + const renders = entity.findComponents("render"); + for (let i = 0; i < renders.length; i++) { + const renderComponent = renders[i]; + this._applyMaterialVariant(variant, renderComponent.meshInstances); + } + } + applyMaterialVariantInstances(instances, name) { + const variant = name ? this.data.variants[name] : null; + if (variant === void 0) { + return; + } + this._applyMaterialVariant(variant, instances); + } + _applyMaterialVariant(variant, instances) { + instances.forEach((instance) => { + if (variant === null) { + instance.material = this._defaultMaterial; + } else { + const meshVariants = this.data.meshVariants[instance.mesh.id]; + if (meshVariants) { + instance.material = this.data.materials[meshVariants[variant]]; + } + } + }); + } + static createSceneHierarchy(sceneNodes, nodeType) { + let root = null; + if (sceneNodes.length === 1) { + root = sceneNodes[0]; + } else { + root = new nodeType("SceneGroup"); + for (const scene2 of sceneNodes) { + root.addChild(scene2); + } + } + return root; + } + static createModel(glb, defaultMaterial) { + const createMeshInstance = function createMeshInstance2(model2, mesh, skins, skinInstances2, materials, node, gltfNode) { + const materialIndex = glb.meshDefaultMaterials[mesh.id]; + const material = materialIndex === void 0 ? defaultMaterial : materials[materialIndex]; + const meshInstance = new MeshInstance(mesh, material, node); + if (mesh.morph) { + const morphInstance = new MorphInstance(mesh.morph); + meshInstance.morphInstance = morphInstance; + model2.morphInstances.push(morphInstance); + } + if (gltfNode.hasOwnProperty("skin")) { + const skinIndex = gltfNode.skin; + const skin = skins[skinIndex]; + mesh.skin = skin; + const skinInstance = skinInstances2[skinIndex]; + meshInstance.skinInstance = skinInstance; + model2.skinInstances.push(skinInstance); + } + model2.meshInstances.push(meshInstance); + }; + const model = new Model2(); + const skinInstances = []; + for (const skin of glb.skins) { + const skinInstance = new SkinInstance(skin); + skinInstance.bones = skin.bones; + skinInstances.push(skinInstance); + } + model.graph = _GlbContainerResource.createSceneHierarchy(glb.scenes, GraphNode); + for (let i = 0; i < glb.nodes.length; i++) { + const node = glb.nodes[i]; + if (node.root === model.graph) { + const gltfNode = glb.gltf.nodes[i]; + if (gltfNode.hasOwnProperty("mesh")) { + const meshGroup = glb.renders[gltfNode.mesh].meshes; + for (let mi = 0; mi < meshGroup.length; mi++) { + const mesh = meshGroup[mi]; + if (mesh) { + createMeshInstance(model, mesh, glb.skins, skinInstances, glb.materials, node, gltfNode); + } + } + } + } + } + return model; + } + destroy() { + const registry = this._assets; + const destroyAsset = function destroyAsset2(asset2) { + registry.remove(asset2); + asset2.unload(); + }; + const destroyAssets = function destroyAssets2(assets) { + assets.forEach(function(asset2) { + destroyAsset(asset2); + }); + }; + if (this.animations) { + destroyAssets(this.animations); + this.animations = null; + } + if (this.textures) { + destroyAssets(this.textures); + this.textures = null; + } + if (this.materials) { + destroyAssets(this.materials); + this.materials = null; + } + if (this.renders) { + destroyAssets(this.renders); + this.renders = null; + } + if (this._model) { + destroyAsset(this._model); + this._model = null; + } + this.data = null; + this.assets = null; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/parsers/glb-container-parser.js +var GlbContainerParser = class { + constructor(device, assets, maxRetries) { + this._device = device; + this._assets = assets; + this._defaultMaterial = GlbParser.createDefaultMaterial(); + this.maxRetries = maxRetries; + } + _getUrlWithoutParams(url) { + return url.indexOf("?") >= 0 ? url.split("?")[0] : url; + } + load(url, callback, asset2) { + Asset.fetchArrayBuffer(url.load, (err, result) => { + if (err) { + callback(err); + } else { + GlbParser.parse(this._getUrlWithoutParams(url.original), path.extractPath(url.load), result, this._device, asset2.registry, asset2.options, (err2, result2) => { + if (err2) { + callback(err2); + } else { + callback(null, new GlbContainerResource(result2, asset2, this._assets, this._defaultMaterial)); + } + }); + } + }, asset2, this.maxRetries); + } + open(url, data2, asset2) { + return data2; + } + patch(asset2, assets) { + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/handlers/container.js +var ContainerHandler = class extends ResourceHandler { + constructor(app2) { + super(app2, "container"); + this.glbContainerParser = new GlbContainerParser(app2.graphicsDevice, app2.assets, 0); + this.parsers = {}; + } + set maxRetries(value) { + this.glbContainerParser.maxRetries = value; + for (const parser in this.parsers) { + if (this.parsers.hasOwnProperty(parser)) { + this.parsers[parser].maxRetries = value; + } + } + } + get maxRetries() { + return this.glbContainerParser.maxRetries; + } + _getUrlWithoutParams(url) { + return url.indexOf("?") >= 0 ? url.split("?")[0] : url; + } + _getParser(url) { + const ext = url ? path.getExtension(this._getUrlWithoutParams(url)).toLowerCase().replace(".", "") : null; + return this.parsers[ext] || this.glbContainerParser; + } + load(url, callback, asset2) { + if (typeof url === "string") { + url = { + load: url, + original: url + }; + } + this._getParser(url.original).load(url, callback, asset2); + } + open(url, data2, asset2) { + return this._getParser(url).open(url, data2, asset2); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/parsers/glb-model.js +var GlbModelParser = class { + constructor(modelHandler) { + this._device = modelHandler.device; + this._defaultMaterial = modelHandler.defaultMaterial; + this._assets = modelHandler.assets; + } + parse(data2, callback, asset2) { + var _asset$options; + GlbParser.parse("filename.glb", "", data2, this._device, this._assets, (_asset$options = asset2 == null ? void 0 : asset2.options) != null ? _asset$options : {}, (err, result) => { + if (err) { + callback(err); + } else { + const model = GlbContainerResource.createModel(result, this._defaultMaterial); + result.destroy(); + callback(null, model); + } + }); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/parsers/json-model.js +var JSON_PRIMITIVE_TYPE = { + "points": PRIMITIVE_POINTS, + "lines": PRIMITIVE_LINES, + "lineloop": PRIMITIVE_LINELOOP, + "linestrip": PRIMITIVE_LINESTRIP, + "triangles": PRIMITIVE_TRIANGLES, + "trianglestrip": PRIMITIVE_TRISTRIP, + "trianglefan": PRIMITIVE_TRIFAN +}; +var JSON_VERTEX_ELEMENT_TYPE = { + "int8": TYPE_INT8, + "uint8": TYPE_UINT8, + "int16": TYPE_INT16, + "uint16": TYPE_UINT16, + "int32": TYPE_INT32, + "uint32": TYPE_UINT32, + "float32": TYPE_FLOAT32 +}; +var JsonModelParser = class { + constructor(modelHandler) { + this._device = modelHandler.device; + this._defaultMaterial = modelHandler.defaultMaterial; + } + parse(data2, callback) { + const modelData = data2.model; + if (!modelData) { + callback(null, null); + return; + } + if (modelData.version <= 1) { + callback("JsonModelParser#parse: Trying to parse unsupported model format."); + return; + } + const nodes = this._parseNodes(data2); + const skins = this._parseSkins(data2, nodes); + const vertexBuffers = this._parseVertexBuffers(data2); + const indices = this._parseIndexBuffers(data2, vertexBuffers); + const morphs = this._parseMorphs(data2, nodes, vertexBuffers); + const meshes = this._parseMeshes(data2, skins.skins, morphs.morphs, vertexBuffers, indices.buffer, indices.data); + const meshInstances = this._parseMeshInstances(data2, nodes, meshes, skins.skins, skins.instances, morphs.morphs, morphs.instances); + const model = new Model2(); + model.graph = nodes[0]; + model.meshInstances = meshInstances; + model.skinInstances = skins.instances; + model.morphInstances = morphs.instances; + model.getGraph().syncHierarchy(); + callback(null, model); + } + _parseNodes(data2) { + const modelData = data2.model; + const nodes = []; + let i; + for (i = 0; i < modelData.nodes.length; i++) { + const nodeData = modelData.nodes[i]; + const node = new GraphNode(nodeData.name); + node.setLocalPosition(nodeData.position[0], nodeData.position[1], nodeData.position[2]); + node.setLocalEulerAngles(nodeData.rotation[0], nodeData.rotation[1], nodeData.rotation[2]); + node.setLocalScale(nodeData.scale[0], nodeData.scale[1], nodeData.scale[2]); + node.scaleCompensation = !!nodeData.scaleCompensation; + nodes.push(node); + } + for (i = 1; i < modelData.parents.length; i++) { + nodes[modelData.parents[i]].addChild(nodes[i]); + } + return nodes; + } + _parseSkins(data2, nodes) { + const modelData = data2.model; + const skins = []; + const skinInstances = []; + let i, j; + for (i = 0; i < modelData.skins.length; i++) { + const skinData = modelData.skins[i]; + const inverseBindMatrices = []; + for (j = 0; j < skinData.inverseBindMatrices.length; j++) { + const ibm = skinData.inverseBindMatrices[j]; + inverseBindMatrices[j] = new Mat4().set(ibm); + } + const skin = new Skin(this._device, inverseBindMatrices, skinData.boneNames); + skins.push(skin); + const skinInstance = new SkinInstance(skin); + const bones = []; + for (j = 0; j < skin.boneNames.length; j++) { + const boneName = skin.boneNames[j]; + const bone = nodes[0].findByName(boneName); + bones.push(bone); + } + skinInstance.bones = bones; + skinInstances.push(skinInstance); + } + return { + skins, + instances: skinInstances + }; + } + _getMorphVertexCount(modelData, morphIndex, vertexBuffers) { + for (let i = 0; i < modelData.meshes.length; i++) { + const meshData = modelData.meshes[i]; + if (meshData.morph === morphIndex) { + const vertexBuffer = vertexBuffers[meshData.vertices]; + return vertexBuffer.numVertices; + } + } + return void 0; + } + _parseMorphs(data2, nodes, vertexBuffers) { + const modelData = data2.model; + const morphs = []; + const morphInstances = []; + let i, j, vertexCount; + let targets, morphTarget, morphTargetArray; + if (modelData.morphs) { + const sparseToFull = function sparseToFull2(data3, indices, totalCount) { + const full = new Float32Array(totalCount * 3); + for (let s = 0; s < indices.length; s++) { + const dstIndex = indices[s] * 3; + full[dstIndex] = data3[s * 3]; + full[dstIndex + 1] = data3[s * 3 + 1]; + full[dstIndex + 2] = data3[s * 3 + 2]; + } + return full; + }; + for (i = 0; i < modelData.morphs.length; i++) { + targets = modelData.morphs[i].targets; + morphTargetArray = []; + vertexCount = this._getMorphVertexCount(modelData, i, vertexBuffers); + for (j = 0; j < targets.length; j++) { + const targetAabb = targets[j].aabb; + const min = targetAabb.min; + const max = targetAabb.max; + const aabb = new BoundingBox(new Vec3((max[0] + min[0]) * 0.5, (max[1] + min[1]) * 0.5, (max[2] + min[2]) * 0.5), new Vec3((max[0] - min[0]) * 0.5, (max[1] - min[1]) * 0.5, (max[2] - min[2]) * 0.5)); + const indices = targets[j].indices; + let deltaPositions = targets[j].deltaPositions; + let deltaNormals = targets[j].deltaNormals; + if (indices) { + deltaPositions = sparseToFull(deltaPositions, indices, vertexCount); + deltaNormals = sparseToFull(deltaNormals, indices, vertexCount); + } + morphTarget = new MorphTarget({ + deltaPositions, + deltaNormals, + name: targets[j].name, + aabb + }); + morphTargetArray.push(morphTarget); + } + const morph = new Morph(morphTargetArray, this._device); + morphs.push(morph); + const morphInstance = new MorphInstance(morph); + morphInstances.push(morphInstance); + } + } + return { + morphs, + instances: morphInstances + }; + } + _parseVertexBuffers(data2) { + const modelData = data2.model; + const vertexBuffers = []; + const attributeMap = { + position: SEMANTIC_POSITION, + normal: SEMANTIC_NORMAL, + tangent: SEMANTIC_TANGENT, + blendWeight: SEMANTIC_BLENDWEIGHT, + blendIndices: SEMANTIC_BLENDINDICES, + color: SEMANTIC_COLOR, + texCoord0: SEMANTIC_TEXCOORD0, + texCoord1: SEMANTIC_TEXCOORD1, + texCoord2: SEMANTIC_TEXCOORD2, + texCoord3: SEMANTIC_TEXCOORD3, + texCoord4: SEMANTIC_TEXCOORD4, + texCoord5: SEMANTIC_TEXCOORD5, + texCoord6: SEMANTIC_TEXCOORD6, + texCoord7: SEMANTIC_TEXCOORD7 + }; + for (let i = 0; i < modelData.vertices.length; i++) { + const vertexData = modelData.vertices[i]; + const formatDesc = []; + for (const attributeName in vertexData) { + const attribute = vertexData[attributeName]; + formatDesc.push({ + semantic: attributeMap[attributeName], + components: attribute.components, + type: JSON_VERTEX_ELEMENT_TYPE[attribute.type], + normalize: attributeMap[attributeName] === SEMANTIC_COLOR + }); + } + const vertexFormat = new VertexFormat(this._device, formatDesc); + const numVertices = vertexData.position.data.length / vertexData.position.components; + const vertexBuffer = new VertexBuffer(this._device, vertexFormat, numVertices); + const iterator = new VertexIterator(vertexBuffer); + for (let j = 0; j < numVertices; j++) { + for (const attributeName in vertexData) { + const attribute = vertexData[attributeName]; + switch (attribute.components) { + case 1: + iterator.element[attributeMap[attributeName]].set(attribute.data[j]); + break; + case 2: + iterator.element[attributeMap[attributeName]].set(attribute.data[j * 2], 1 - attribute.data[j * 2 + 1]); + break; + case 3: + iterator.element[attributeMap[attributeName]].set(attribute.data[j * 3], attribute.data[j * 3 + 1], attribute.data[j * 3 + 2]); + break; + case 4: + iterator.element[attributeMap[attributeName]].set(attribute.data[j * 4], attribute.data[j * 4 + 1], attribute.data[j * 4 + 2], attribute.data[j * 4 + 3]); + break; + } + } + iterator.next(); + } + iterator.end(); + vertexBuffers.push(vertexBuffer); + } + return vertexBuffers; + } + _parseIndexBuffers(data2, vertexBuffers) { + const modelData = data2.model; + let indexBuffer = null; + let indexData = null; + let i; + let numIndices = 0; + for (i = 0; i < modelData.meshes.length; i++) { + const meshData = modelData.meshes[i]; + if (meshData.indices !== void 0) { + numIndices += meshData.indices.length; + } + } + let maxVerts = 0; + for (i = 0; i < vertexBuffers.length; i++) { + maxVerts = Math.max(maxVerts, vertexBuffers[i].numVertices); + } + if (numIndices > 0) { + if (maxVerts > 65535 && this._device.extUintElement) { + indexBuffer = new IndexBuffer(this._device, INDEXFORMAT_UINT32, numIndices); + indexData = new Uint32Array(indexBuffer.lock()); + } else { + indexBuffer = new IndexBuffer(this._device, INDEXFORMAT_UINT16, numIndices); + indexData = new Uint16Array(indexBuffer.lock()); + } + } + return { + buffer: indexBuffer, + data: indexData + }; + } + _parseMeshes(data2, skins, morphs, vertexBuffers, indexBuffer, indexData) { + const modelData = data2.model; + const meshes = []; + let indexBase = 0; + for (let i = 0; i < modelData.meshes.length; i++) { + const meshData = modelData.meshes[i]; + const meshAabb = meshData.aabb; + const min = meshAabb.min; + const max = meshAabb.max; + const aabb = new BoundingBox(new Vec3((max[0] + min[0]) * 0.5, (max[1] + min[1]) * 0.5, (max[2] + min[2]) * 0.5), new Vec3((max[0] - min[0]) * 0.5, (max[1] - min[1]) * 0.5, (max[2] - min[2]) * 0.5)); + const indexed = meshData.indices !== void 0; + const mesh = new Mesh(this._device); + mesh.vertexBuffer = vertexBuffers[meshData.vertices]; + mesh.indexBuffer[0] = indexed ? indexBuffer : null; + mesh.primitive[0].type = JSON_PRIMITIVE_TYPE[meshData.type]; + mesh.primitive[0].base = indexed ? meshData.base + indexBase : meshData.base; + mesh.primitive[0].count = meshData.count; + mesh.primitive[0].indexed = indexed; + mesh.skin = meshData.skin !== void 0 ? skins[meshData.skin] : null; + mesh.morph = meshData.morph !== void 0 ? morphs[meshData.morph] : null; + mesh.aabb = aabb; + if (indexed) { + indexData.set(meshData.indices, indexBase); + indexBase += meshData.indices.length; + } + meshes.push(mesh); + } + if (indexBuffer !== null) { + indexBuffer.unlock(); + } + return meshes; + } + _parseMeshInstances(data2, nodes, meshes, skins, skinInstances, morphs, morphInstances) { + const modelData = data2.model; + const meshInstances = []; + let i; + for (i = 0; i < modelData.meshInstances.length; i++) { + const meshInstanceData = modelData.meshInstances[i]; + const node = nodes[meshInstanceData.node]; + const mesh = meshes[meshInstanceData.mesh]; + const meshInstance = new MeshInstance(mesh, this._defaultMaterial, node); + if (mesh.skin) { + const skinIndex = skins.indexOf(mesh.skin); + meshInstance.skinInstance = skinInstances[skinIndex]; + } + if (mesh.morph) { + const morphIndex = morphs.indexOf(mesh.morph); + meshInstance.morphInstance = morphInstances[morphIndex]; + } + meshInstances.push(meshInstance); + } + return meshInstances; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/handlers/model.js +var ModelHandler = class extends ResourceHandler { + constructor(app2) { + super(app2, "model"); + this._parsers = []; + this.device = app2.graphicsDevice; + this.assets = app2.assets; + this.defaultMaterial = getDefaultMaterial(this.device); + this.addParser(new JsonModelParser(this), function(url, data2) { + return path.getExtension(url) === ".json"; + }); + this.addParser(new GlbModelParser(this), function(url, data2) { + return path.getExtension(url) === ".glb"; + }); + } + load(url, callback, asset2) { + if (typeof url === "string") { + url = { + load: url, + original: url + }; + } + const options = { + retry: this.maxRetries > 0, + maxRetries: this.maxRetries + }; + if (url.load.startsWith("blob:") || url.load.startsWith("data:")) { + if (path.getExtension(url.original).toLowerCase() === ".glb") { + options.responseType = Http.ResponseType.ARRAY_BUFFER; + } else { + options.responseType = Http.ResponseType.JSON; + } + } + http.get(url.load, options, (err, response) => { + if (!callback) return; + if (!err) { + for (let i = 0; i < this._parsers.length; i++) { + const p = this._parsers[i]; + if (p.decider(url.original, response)) { + p.parser.parse(response, (err2, parseResult) => { + if (err2) { + callback(err2); + } else { + callback(null, parseResult); + } + }, asset2); + return; + } + } + callback("No parsers found"); + } else { + callback(`Error loading model: ${url.original} [${err}]`); + } + }); + } + open(url, data2) { + return data2; + } + patch(asset2, assets) { + if (!asset2.resource) return; + const data2 = asset2.data; + const self2 = this; + asset2.resource.meshInstances.forEach(function(meshInstance, i) { + if (data2.mapping) { + const handleMaterial = function handleMaterial2(asset3) { + if (asset3.resource) { + meshInstance.material = asset3.resource; + } else { + asset3.once("load", handleMaterial2); + assets.load(asset3); + } + asset3.once("remove", function(asset4) { + if (meshInstance.material === asset4.resource) { + meshInstance.material = self2.defaultMaterial; + } + }); + }; + if (!data2.mapping[i]) { + meshInstance.material = self2.defaultMaterial; + return; + } + const id12 = data2.mapping[i].material; + const url = data2.mapping[i].path; + let material; + if (id12 !== void 0) { + if (!id12) { + meshInstance.material = self2.defaultMaterial; + } else { + material = assets.get(id12); + if (material) { + handleMaterial(material); + } else { + assets.once("add:" + id12, handleMaterial); + } + } + } else if (url) { + const path2 = asset2.getAbsoluteUrl(data2.mapping[i].path); + material = assets.getByUrl(path2); + if (material) { + handleMaterial(material); + } else { + assets.once("add:url:" + path2, handleMaterial); + } + } + } + }); + } + addParser(parser, decider) { + this._parsers.push({ + parser, + decider + }); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/handlers/basis-worker.js +function BasisWorker() { + const BASIS_FORMAT = { + cTFETC1: 0, + cTFETC2: 1, + cTFBC1: 2, + cTFBC3: 3, + cTFPVRTC1_4_RGB: 8, + cTFPVRTC1_4_RGBA: 9, + cTFASTC_4x4: 10, + cTFATC_RGB: 11, + cTFATC_RGBA_INTERPOLATED_ALPHA: 12, + cTFRGBA32: 13, + cTFRGB565: 14, + cTFRGBA4444: 16 + }; + const opaqueMapping = { + astc: BASIS_FORMAT.cTFASTC_4x4, + dxt: BASIS_FORMAT.cTFBC1, + etc1: BASIS_FORMAT.cTFETC1, + etc2: BASIS_FORMAT.cTFETC1, + pvr: BASIS_FORMAT.cTFPVRTC1_4_RGB, + atc: BASIS_FORMAT.cTFATC_RGB, + none: BASIS_FORMAT.cTFRGB565 + }; + const alphaMapping = { + astc: BASIS_FORMAT.cTFASTC_4x4, + dxt: BASIS_FORMAT.cTFBC3, + etc1: BASIS_FORMAT.cTFRGBA4444, + etc2: BASIS_FORMAT.cTFETC2, + pvr: BASIS_FORMAT.cTFPVRTC1_4_RGBA, + atc: BASIS_FORMAT.cTFATC_RGBA_INTERPOLATED_ALPHA, + none: BASIS_FORMAT.cTFRGBA4444 + }; + const PIXEL_FORMAT = { + ETC1: 21, + ETC2_RGB: 22, + ETC2_RGBA: 23, + DXT1: 8, + DXT5: 10, + PVRTC_4BPP_RGB_1: 26, + PVRTC_4BPP_RGBA_1: 27, + ASTC_4x4: 28, + ATC_RGB: 29, + ATC_RGBA: 30, + R8_G8_B8_A8: 7, + R5_G6_B5: 3, + R4_G4_B4_A4: 5 + }; + const basisToEngineMapping = (basisFormat, deviceDetails2) => { + switch (basisFormat) { + case BASIS_FORMAT.cTFETC1: + return deviceDetails2.formats.etc1 ? PIXEL_FORMAT.ETC1 : PIXEL_FORMAT.ETC2_RGB; + case BASIS_FORMAT.cTFETC2: + return PIXEL_FORMAT.ETC2_RGBA; + case BASIS_FORMAT.cTFBC1: + return PIXEL_FORMAT.DXT1; + case BASIS_FORMAT.cTFBC3: + return PIXEL_FORMAT.DXT5; + case BASIS_FORMAT.cTFPVRTC1_4_RGB: + return PIXEL_FORMAT.PVRTC_4BPP_RGB_1; + case BASIS_FORMAT.cTFPVRTC1_4_RGBA: + return PIXEL_FORMAT.PVRTC_4BPP_RGBA_1; + case BASIS_FORMAT.cTFASTC_4x4: + return PIXEL_FORMAT.ASTC_4x4; + case BASIS_FORMAT.cTFATC_RGB: + return PIXEL_FORMAT.ATC_RGB; + case BASIS_FORMAT.cTFATC_RGBA_INTERPOLATED_ALPHA: + return PIXEL_FORMAT.ATC_RGBA; + case BASIS_FORMAT.cTFRGBA32: + return PIXEL_FORMAT.R8_G8_B8_A8; + case BASIS_FORMAT.cTFRGB565: + return PIXEL_FORMAT.R5_G6_B5; + case BASIS_FORMAT.cTFRGBA4444: + return PIXEL_FORMAT.R4_G4_B4_A4; + } + }; + const unswizzleGGGR = (data2) => { + const genB = function genB2(R, G) { + const r = R * (2 / 255) - 1; + const g = G * (2 / 255) - 1; + const b = Math.sqrt(1 - Math.min(1, r * r + g * g)); + return Math.max(0, Math.min(255, Math.floor((b + 1) * 0.5 * 255))); + }; + for (let offset = 0; offset < data2.length; offset += 4) { + const R = data2[offset + 3]; + const G = data2[offset + 1]; + data2[offset + 0] = R; + data2[offset + 2] = genB(R, G); + data2[offset + 3] = 255; + } + return data2; + }; + const pack565 = (data2) => { + const result = new Uint16Array(data2.length / 4); + for (let offset = 0; offset < data2.length; offset += 4) { + const R = data2[offset + 0]; + const G = data2[offset + 1]; + const B = data2[offset + 2]; + result[offset / 4] = (R & 248) << 8 | (G & 252) << 3 | B >> 3; + } + return result; + }; + const isPOT = (width, height) => { + return (width & width - 1) === 0 && (height & height - 1) === 0; + }; + const performanceNow = () => { + return typeof performance !== "undefined" ? performance.now() : 0; + }; + let basis; + let rgbPriority; + let rgbaPriority; + const chooseTargetFormat = (deviceDetails2, hasAlpha, isUASTC) => { + if (isUASTC) { + if (deviceDetails2.formats.astc) { + return "astc"; + } + } else { + if (hasAlpha) { + if (deviceDetails2.formats.etc2) { + return "etc2"; + } + } else { + if (deviceDetails2.formats.etc1 || deviceDetails2.formats.etc2) { + return "etc1"; + } + } + } + const testInOrder = (priority) => { + for (let i = 0; i < priority.length; ++i) { + const format = priority[i]; + if (deviceDetails2.formats[format]) { + return format; + } + } + return "none"; + }; + return testInOrder(hasAlpha ? rgbaPriority : rgbPriority); + }; + const dimensionsValid = (width, height, format, webgl2) => { + switch (format) { + case BASIS_FORMAT.cTFETC1: + case BASIS_FORMAT.cTFETC2: + return true; + case BASIS_FORMAT.cTFBC1: + case BASIS_FORMAT.cTFBC3: + return (width & 3) === 0 && (height & 3) === 0; + case BASIS_FORMAT.cTFPVRTC1_4_RGB: + case BASIS_FORMAT.cTFPVRTC1_4_RGBA: + return isPOT(width, height) && (width === height || webgl2); + case BASIS_FORMAT.cTFASTC_4x4: + return true; + case BASIS_FORMAT.cTFATC_RGB: + case BASIS_FORMAT.cTFATC_RGBA_INTERPOLATED_ALPHA: + return true; + } + return false; + }; + const transcodeKTX2 = (url, data2, options) => { + if (!basis.KTX2File) { + throw new Error("Basis transcoder module does not include support for KTX2."); + } + const funcStart = performanceNow(); + const basisFile = new basis.KTX2File(new Uint8Array(data2)); + const width = basisFile.getWidth(); + const height = basisFile.getHeight(); + const levels = basisFile.getLevels(); + const hasAlpha = !!basisFile.getHasAlpha(); + const isUASTC = basisFile.isUASTC && basisFile.isUASTC(); + if (!width || !height || !levels) { + basisFile.close(); + basisFile.delete(); + throw new Error(`Invalid image dimensions url=${url} width=${width} height=${height} levels=${levels}`); + } + const format = chooseTargetFormat(options.deviceDetails, hasAlpha, isUASTC); + const unswizzle = !!options.isGGGR && format === "pvr"; + let basisFormat; + if (unswizzle) { + basisFormat = BASIS_FORMAT.cTFRGBA32; + } else { + basisFormat = hasAlpha ? alphaMapping[format] : opaqueMapping[format]; + if (!dimensionsValid(width, height, basisFormat, options.deviceDetails.webgl2)) { + basisFormat = hasAlpha ? BASIS_FORMAT.cTFRGBA32 : BASIS_FORMAT.cTFRGB565; + } + } + if (!basisFile.startTranscoding()) { + basisFile.close(); + basisFile.delete(); + throw new Error("Failed to start transcoding url=" + url); + } + let i; + const levelData = []; + for (let mip = 0; mip < levels; ++mip) { + const dstSize = basisFile.getImageTranscodedSizeInBytes(mip, 0, 0, basisFormat); + const dst = new Uint8Array(dstSize); + if (!basisFile.transcodeImage(dst, mip, 0, 0, basisFormat, 0, -1, -1)) { + basisFile.close(); + basisFile.delete(); + throw new Error("Failed to transcode image url=" + url); + } + const is16BitFormat = basisFormat === BASIS_FORMAT.cTFRGB565 || basisFormat === BASIS_FORMAT.cTFRGBA4444; + levelData.push(is16BitFormat ? new Uint16Array(dst.buffer) : dst); + } + basisFile.close(); + basisFile.delete(); + if (unswizzle) { + basisFormat = BASIS_FORMAT.cTFRGB565; + for (i = 0; i < levelData.length; ++i) { + levelData[i] = pack565(unswizzleGGGR(levelData[i])); + } + } + return { + format: basisToEngineMapping(basisFormat, options.deviceDetails), + width, + height, + levels: levelData, + cubemap: false, + transcodeTime: performanceNow() - funcStart, + url, + unswizzledGGGR: unswizzle + }; + }; + const transcodeBasis = (url, data2, options) => { + const funcStart = performanceNow(); + const basisFile = new basis.BasisFile(new Uint8Array(data2)); + const width = basisFile.getImageWidth(0, 0); + const height = basisFile.getImageHeight(0, 0); + const images = basisFile.getNumImages(); + const levels = basisFile.getNumLevels(0); + const hasAlpha = !!basisFile.getHasAlpha(); + const isUASTC = basisFile.isUASTC && basisFile.isUASTC(); + if (!width || !height || !images || !levels) { + basisFile.close(); + basisFile.delete(); + throw new Error(`Invalid image dimensions url=${url} width=${width} height=${height} images=${images} levels=${levels}`); + } + const format = chooseTargetFormat(options.deviceDetails, hasAlpha, isUASTC); + const unswizzle = !!options.isGGGR && format === "pvr"; + let basisFormat; + if (unswizzle) { + basisFormat = BASIS_FORMAT.cTFRGBA32; + } else { + basisFormat = hasAlpha ? alphaMapping[format] : opaqueMapping[format]; + if (!dimensionsValid(width, height, basisFormat, options.deviceDetails.webgl2)) { + basisFormat = hasAlpha ? BASIS_FORMAT.cTFRGBA32 : BASIS_FORMAT.cTFRGB565; + } + } + if (!basisFile.startTranscoding()) { + basisFile.close(); + basisFile.delete(); + throw new Error("Failed to start transcoding url=" + url); + } + let i; + const levelData = []; + for (let mip = 0; mip < levels; ++mip) { + const dstSize = basisFile.getImageTranscodedSizeInBytes(0, mip, basisFormat); + const dst = new Uint8Array(dstSize); + if (!basisFile.transcodeImage(dst, 0, mip, basisFormat, 0, 0)) { + if (mip === levels - 1 && dstSize === levelData[mip - 1].buffer.byteLength) { + dst.set(new Uint8Array(levelData[mip - 1].buffer)); + console.warn("Failed to transcode last mipmap level, using previous level instead url=" + url); + } else { + basisFile.close(); + basisFile.delete(); + throw new Error("Failed to transcode image url=" + url); + } + } + const is16BitFormat = basisFormat === BASIS_FORMAT.cTFRGB565 || basisFormat === BASIS_FORMAT.cTFRGBA4444; + levelData.push(is16BitFormat ? new Uint16Array(dst.buffer) : dst); + } + basisFile.close(); + basisFile.delete(); + if (unswizzle) { + basisFormat = BASIS_FORMAT.cTFRGB565; + for (i = 0; i < levelData.length; ++i) { + levelData[i] = pack565(unswizzleGGGR(levelData[i])); + } + } + return { + format: basisToEngineMapping(basisFormat, options.deviceDetails), + width, + height, + levels: levelData, + cubemap: false, + transcodeTime: performanceNow() - funcStart, + url, + unswizzledGGGR: unswizzle + }; + }; + const transcode = (url, data2, options) => { + return options.isKTX2 ? transcodeKTX2(url, data2, options) : transcodeBasis(url, data2, options); + }; + const workerTranscode = (url, data2, options) => { + try { + const result = transcode(url, data2, options); + result.levels = result.levels.map((v) => v.buffer); + self.postMessage({ + url, + data: result + }, result.levels); + } catch (err) { + self.postMessage({ + url, + err + }, null); + } + }; + const workerInit = (config, callback) => { + const instantiateWasmFunc = (imports, successCallback) => { + WebAssembly.instantiate(config.module, imports).then((result) => { + successCallback(result); + }).catch((reason) => { + console.error("instantiate failed + " + reason); + }); + return {}; + }; + self.BASIS(config.module ? { + instantiateWasm: instantiateWasmFunc + } : null).then((instance) => { + instance.initializeBasis(); + basis = instance; + rgbPriority = config.rgbPriority; + rgbaPriority = config.rgbaPriority; + callback(null); + }); + }; + const queue2 = []; + self.onmessage = (message) => { + const data2 = message.data; + switch (data2.type) { + case "init": + workerInit(data2.config, () => { + for (let i = 0; i < queue2.length; ++i) { + workerTranscode(queue2[i].url, queue2[i].data, queue2[i].options); + } + queue2.length = 0; + }); + break; + case "transcode": + if (basis) { + workerTranscode(data2.url, data2.data, data2.options); + } else { + queue2.push(data2); + } + break; + } + }; +} + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/handlers/basis.js +var getCompressionFormats = (device) => { + return { + astc: !!device.extCompressedTextureASTC, + atc: !!device.extCompressedTextureATC, + dxt: !!device.extCompressedTextureS3TC, + etc1: !!device.extCompressedTextureETC1, + etc2: !!device.extCompressedTextureETC, + pvr: !!device.extCompressedTexturePVRTC + }; +}; +var prepareWorkerModules = (config, callback) => { + const getWorkerBlob = (basisCode) => { + const code = ["/* basis */", basisCode, "", "(" + BasisWorker.toString() + ")()\n\n"].join("\n"); + return new Blob([code], { + type: "application/javascript" + }); + }; + const wasmSupported = () => { + try { + if (typeof WebAssembly === "object" && typeof WebAssembly.instantiate === "function") { + const module = new WebAssembly.Module(Uint8Array.of(0, 97, 115, 109, 1, 0, 0, 0)); + if (module instanceof WebAssembly.Module) return new WebAssembly.Instance(module) instanceof WebAssembly.Instance; + } + } catch (e) { + } + return false; + }; + const sendResponse = (basisCode, module) => { + callback(null, { + workerUrl: URL.createObjectURL(getWorkerBlob(basisCode)), + module, + rgbPriority: config.rgbPriority, + rgbaPriority: config.rgbaPriority + }); + }; + const options = { + cache: true, + responseType: "text", + retry: config.maxRetries > 0, + maxRetries: config.maxRetries + }; + if (config.glueUrl && config.wasmUrl && wasmSupported()) { + let basisCode = null; + let module = null; + http.get(config.glueUrl, options, (err, response) => { + if (err) { + callback(err); + } else { + if (module) { + sendResponse(response, module); + } else { + basisCode = response; + } + } + }); + const fetchPromise = fetch(config.wasmUrl); + const compileManual = () => { + fetchPromise.then((result) => result.arrayBuffer()).then((buffer) => WebAssembly.compile(buffer)).then((module_) => { + if (basisCode) { + sendResponse(basisCode, module_); + } else { + module = module_; + } + }).catch((err) => { + callback(err, null); + }); + }; + if (WebAssembly.compileStreaming) { + WebAssembly.compileStreaming(fetchPromise).then((module_) => { + if (basisCode) { + sendResponse(basisCode, module_); + } else { + module = module_; + } + }).catch((err) => { + compileManual(); + }); + } else { + compileManual(); + } + } else { + http.get(config.fallbackUrl, options, (err, response) => { + if (err) { + callback(err, null); + } else { + sendResponse(response, null); + } + }); + } +}; +var BasisQueue = class { + constructor() { + this.callbacks = {}; + this.queue = []; + this.clients = []; + } + enqueueJob(url, data2, callback, options) { + if (this.callbacks.hasOwnProperty(url)) { + this.callbacks[url].push(callback); + } else { + this.callbacks[url] = [callback]; + const job = { + url, + data: data2, + options + }; + if (this.clients.length > 0) { + this.clients.shift().run(job); + } else { + this.queue.push(job); + } + } + } + enqueueClient(client) { + if (this.queue.length > 0) { + client.run(this.queue.shift()); + } else { + this.clients.push(client); + } + } + handleResponse(url, err, data2) { + const callback = this.callbacks[url]; + if (err) { + for (let i = 0; i < callback.length; ++i) { + callback[i](err); + } + } else { + if (data2.format === PIXELFORMAT_RGB565 || data2.format === PIXELFORMAT_RGBA4) { + data2.levels = data2.levels.map(function(v) { + return new Uint16Array(v); + }); + } else { + data2.levels = data2.levels.map(function(v) { + return new Uint8Array(v); + }); + } + for (let i = 0; i < callback.length; ++i) { + callback[i](null, data2); + } + } + delete this.callbacks[url]; + } +}; +var BasisClient = class { + constructor(queue2, config, eager) { + this.queue = queue2; + this.worker = new Worker(config.workerUrl); + this.worker.addEventListener("message", (message) => { + const data2 = message.data; + this.queue.handleResponse(data2.url, data2.err, data2.data); + if (!this.eager) { + this.queue.enqueueClient(this); + } + }); + this.worker.postMessage({ + type: "init", + config + }); + this.eager = eager; + } + run(job) { + const transfer = []; + if (job.data instanceof ArrayBuffer) { + transfer.push(job.data); + } + this.worker.postMessage({ + type: "transcode", + url: job.url, + format: job.format, + data: job.data, + options: job.options + }, transfer); + if (this.eager) { + this.queue.enqueueClient(this); + } + } +}; +var defaultNumWorkers2 = 1; +var defaultRgbPriority = ["etc1", "etc2", "astc", "dxt", "pvr", "atc"]; +var defaultRgbaPriority = ["astc", "dxt", "etc2", "pvr", "atc"]; +var defaultMaxRetries = 5; +var queue = new BasisQueue(); +var lazyConfig2 = null; +var initializing = false; +function basisInitialize(config) { + if (initializing) { + return; + } + if (!config) { + config = lazyConfig2 || {}; + } else if (config.lazyInit) { + lazyConfig2 = config; + return; + } + if (!config.glueUrl || !config.wasmUrl || !config.fallbackUrl) { + const moduleConfig = WasmModule.getConfig("BASIS"); + if (moduleConfig) { + config = { + glueUrl: moduleConfig.glueUrl, + wasmUrl: moduleConfig.wasmUrl, + fallbackUrl: moduleConfig.fallbackUrl, + numWorkers: moduleConfig.numWorkers + }; + } + } + if (config.glueUrl || config.wasmUrl || config.fallbackUrl) { + initializing = true; + const numWorkers = Math.max(1, Math.min(16, config.numWorkers || defaultNumWorkers2)); + const eagerWorkers = config.numWorkers === 1 || (config.hasOwnProperty("eagerWorkers") ? config.eagerWorkers : true); + config.rgbPriority = config.rgbPriority || defaultRgbPriority; + config.rgbaPriority = config.rgbaPriority || defaultRgbaPriority; + config.maxRetries = config.hasOwnProperty("maxRetries") ? config.maxRetries : defaultMaxRetries; + prepareWorkerModules(config, (err, clientConfig) => { + if (err) { + console.error(`failed to initialize basis worker: ${err}`); + } else { + for (let i = 0; i < numWorkers; ++i) { + queue.enqueueClient(new BasisClient(queue, clientConfig, eagerWorkers)); + } + } + }); + } +} +var deviceDetails = null; +function basisTranscode(device, url, data2, callback, options) { + basisInitialize(); + if (!deviceDetails) { + deviceDetails = { + webgl2: device.isWebGL2, + formats: getCompressionFormats(device) + }; + } + queue.enqueueJob(url, data2, callback, { + deviceDetails, + isGGGR: !!(options != null && options.isGGGR), + isKTX2: !!(options != null && options.isKTX2) + }); + return initializing; +} + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/parsers/texture/texture.js +var TextureParser = class { + load(url, callback, asset2) { + throw new Error("not implemented"); + } + open(url, data2, device) { + throw new Error("not implemented"); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/parsers/texture/basis.js +var BasisParser = class extends TextureParser { + constructor(registry, device) { + super(); + this.device = device; + this.maxRetries = 0; + } + load(url, callback, asset2) { + const device = this.device; + const transcode = (data2) => { + var _asset$file; + const basisModuleFound = basisTranscode(device, url.load, data2, callback, { + isGGGR: ((asset2 == null || (_asset$file = asset2.file) == null || (_asset$file = _asset$file.variants) == null || (_asset$file = _asset$file.basis) == null ? void 0 : _asset$file.opt) & 8) !== 0 + }); + if (!basisModuleFound) { + callback(`Basis module not found. Asset '${asset2.name}' basis texture variant will not be loaded.`); + } + }; + Asset.fetchArrayBuffer(url.load, (err, result) => { + if (err) { + callback(err); + } else { + transcode(result); + } + }, asset2, this.maxRetries); + } + open(url, data2, device, textureOptions = {}) { + const texture = new Texture(device, _extends({ + name: url, + addressU: data2.cubemap ? ADDRESS_CLAMP_TO_EDGE : ADDRESS_REPEAT, + addressV: data2.cubemap ? ADDRESS_CLAMP_TO_EDGE : ADDRESS_REPEAT, + width: data2.width, + height: data2.height, + format: data2.format, + cubemap: data2.cubemap, + levels: data2.levels + }, textureOptions)); + texture.upload(); + return texture; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/parsers/texture/img.js +var ImgParser = class extends TextureParser { + constructor(registry, device) { + super(); + this.crossOrigin = registry.prefix ? "anonymous" : null; + this.maxRetries = 0; + this.device = device; + } + load(url, callback, asset2) { + var _asset$file; + const hasContents = !!(asset2 != null && (_asset$file = asset2.file) != null && _asset$file.contents); + if (hasContents) { + if (this.device.supportsImageBitmap) { + this._loadImageBitmapFromBlob(new Blob([asset2.file.contents]), callback); + return; + } + url = { + load: URL.createObjectURL(new Blob([asset2.file.contents])), + original: url.original + }; + } + const handler = (err, result) => { + if (hasContents) { + URL.revokeObjectURL(url.load); + } + callback(err, result); + }; + let crossOrigin; + if (asset2 && asset2.options && asset2.options.hasOwnProperty("crossOrigin")) { + crossOrigin = asset2.options.crossOrigin; + } else if (ABSOLUTE_URL.test(url.load)) { + crossOrigin = this.crossOrigin; + } + if (this.device.supportsImageBitmap) { + this._loadImageBitmap(url.load, url.original, crossOrigin, handler); + } else { + this._loadImage(url.load, url.original, crossOrigin, handler); + } + } + open(url, data2, device, textureOptions = {}) { + const texture = new Texture(device, _extends({ + name: url, + width: data2.width, + height: data2.height, + format: PIXELFORMAT_RGBA8 + }, textureOptions)); + texture.setSource(data2); + return texture; + } + _loadImage(url, originalUrl, crossOrigin, callback) { + const image = new Image(); + if (crossOrigin) { + image.crossOrigin = crossOrigin; + } + let retries = 0; + const maxRetries = this.maxRetries; + let retryTimeout; + image.onload = function() { + callback(null, image); + }; + image.onerror = function() { + if (retryTimeout) return; + if (maxRetries > 0 && ++retries <= maxRetries) { + const retryDelay = Math.pow(2, retries) * 100; + console.log(`Error loading Texture from: '${originalUrl}' - Retrying in ${retryDelay}ms...`); + const idx = url.indexOf("?"); + const separator = idx >= 0 ? "&" : "?"; + retryTimeout = setTimeout(function() { + image.src = url + separator + "retry=" + Date.now(); + retryTimeout = null; + }, retryDelay); + } else { + callback(`Error loading Texture from: '${originalUrl}'`); + } + }; + image.src = url; + } + _loadImageBitmap(url, originalUrl, crossOrigin, callback) { + const options = { + cache: true, + responseType: "blob", + retry: this.maxRetries > 0, + maxRetries: this.maxRetries + }; + http.get(url, options, (err, blob) => { + if (err) { + callback(err); + } else { + this._loadImageBitmapFromBlob(blob, callback); + } + }); + } + _loadImageBitmapFromBlob(blob, callback) { + createImageBitmap(blob, { + premultiplyAlpha: "none", + colorSpaceConversion: "none" + }).then((imageBitmap) => callback(null, imageBitmap)).catch((e) => callback(e)); + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/parsers/texture/ktx.js +var IDENTIFIER2 = [1481919403, 3140563232, 169478669]; +var KNOWN_FORMATS = { + 33776: PIXELFORMAT_DXT1, + 33778: PIXELFORMAT_DXT3, + 33779: PIXELFORMAT_DXT5, + 36196: PIXELFORMAT_ETC1, + 37492: PIXELFORMAT_ETC2_RGB, + 37496: PIXELFORMAT_ETC2_RGBA, + 35840: PIXELFORMAT_PVRTC_4BPP_RGB_1, + 35841: PIXELFORMAT_PVRTC_2BPP_RGB_1, + 35842: PIXELFORMAT_PVRTC_4BPP_RGBA_1, + 35843: PIXELFORMAT_PVRTC_2BPP_RGBA_1, + 32849: PIXELFORMAT_RGB8, + 32856: PIXELFORMAT_RGBA8, + 35905: PIXELFORMAT_SRGB, + 35907: PIXELFORMAT_SRGBA, + 35898: PIXELFORMAT_111110F, + 34843: PIXELFORMAT_RGB16F, + 34842: PIXELFORMAT_RGBA16F +}; +function createContainer(pixelFormat, buffer, byteOffset, byteSize) { + return pixelFormat === PIXELFORMAT_111110F ? new Uint32Array(buffer, byteOffset, byteSize / 4) : new Uint8Array(buffer, byteOffset, byteSize); +} +var KtxParser = class extends TextureParser { + constructor(registry) { + super(); + this.maxRetries = 0; + } + load(url, callback, asset2) { + Asset.fetchArrayBuffer(url.load, callback, asset2, this.maxRetries); + } + open(url, data2, device, textureOptions = {}) { + const textureData = this.parse(data2); + if (!textureData) { + return null; + } + const texture = new Texture(device, _extends({ + name: url, + addressU: textureData.cubemap ? ADDRESS_CLAMP_TO_EDGE : ADDRESS_REPEAT, + addressV: textureData.cubemap ? ADDRESS_CLAMP_TO_EDGE : ADDRESS_REPEAT, + width: textureData.width, + height: textureData.height, + format: textureData.format, + cubemap: textureData.cubemap, + levels: textureData.levels + }, textureOptions)); + texture.upload(); + return texture; + } + parse(data2) { + const dataU32 = new Uint32Array(data2); + if (IDENTIFIER2[0] !== dataU32[0] || IDENTIFIER2[1] !== dataU32[1] || IDENTIFIER2[2] !== dataU32[2]) { + return null; + } + const header = { + endianness: dataU32[3], + glType: dataU32[4], + glTypeSize: dataU32[5], + glFormat: dataU32[6], + glInternalFormat: dataU32[7], + glBaseInternalFormat: dataU32[8], + pixelWidth: dataU32[9], + pixelHeight: dataU32[10], + pixelDepth: dataU32[11], + numberOfArrayElements: dataU32[12], + numberOfFaces: dataU32[13], + numberOfMipmapLevels: dataU32[14], + bytesOfKeyValueData: dataU32[15] + }; + if (header.pixelDepth > 1) { + return null; + } + if (header.numberOfArrayElements !== 0) { + return null; + } + const format = KNOWN_FORMATS[header.glInternalFormat]; + if (format === void 0) { + return null; + } + let offset = 16 + header.bytesOfKeyValueData / 4; + const isCubemap = header.numberOfFaces > 1; + const levels = []; + for (let mipmapLevel = 0; mipmapLevel < (header.numberOfMipmapLevels || 1); mipmapLevel++) { + const imageSizeInBytes = dataU32[offset++]; + if (isCubemap) { + levels.push([]); + } + const target2 = isCubemap ? levels[mipmapLevel] : levels; + for (let face = 0; face < (isCubemap ? 6 : 1); ++face) { + target2.push(createContainer(format, data2, offset * 4, imageSizeInBytes)); + offset += imageSizeInBytes + 3 >> 2; + } + } + return { + format, + width: header.pixelWidth, + height: header.pixelHeight, + levels, + cubemap: isCubemap + }; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/parsers/texture/ktx2.js +var KHRConstants = { + KHR_DF_MODEL_ETC1S: 163, + KHR_DF_MODEL_UASTC: 166 +}; +var Ktx2Parser = class extends TextureParser { + constructor(registry, device) { + super(); + this.maxRetries = 0; + this.device = device; + } + load(url, callback, asset2) { + Asset.fetchArrayBuffer(url.load, (err, result) => { + if (err) { + callback(err, result); + } else { + this.parse(result, url, callback, asset2); + } + }, asset2, this.maxRetries); + } + open(url, data2, device, textureOptions = {}) { + const texture = new Texture(device, _extends({ + name: url, + addressU: data2.cubemap ? ADDRESS_CLAMP_TO_EDGE : ADDRESS_REPEAT, + addressV: data2.cubemap ? ADDRESS_CLAMP_TO_EDGE : ADDRESS_REPEAT, + width: data2.width, + height: data2.height, + format: data2.format, + cubemap: data2.cubemap, + levels: data2.levels + }, textureOptions)); + texture.upload(); + return texture; + } + parse(arraybuffer, url, callback, asset2) { + const rs = new ReadStream(arraybuffer); + const magic = [rs.readU32be(), rs.readU32be(), rs.readU32be()]; + if (magic[0] !== 2873840728 || magic[1] !== 540160187 || magic[2] !== 218765834) { + return null; + } + const header = { + vkFormat: rs.readU32(), + typeSize: rs.readU32(), + pixelWidth: rs.readU32(), + pixelHeight: rs.readU32(), + pixelDepth: rs.readU32(), + layerCount: rs.readU32(), + faceCount: rs.readU32(), + levelCount: rs.readU32(), + supercompressionScheme: rs.readU32() + }; + const index = { + dfdByteOffset: rs.readU32(), + dfdByteLength: rs.readU32(), + kvdByteOffset: rs.readU32(), + kvdByteLength: rs.readU32(), + sgdByteOffset: rs.readU64(), + sgdByteLength: rs.readU64() + }; + const levels = []; + for (let i = 0; i < Math.max(1, header.levelCount); ++i) { + levels.push({ + byteOffset: rs.readU64(), + byteLength: rs.readU64(), + uncompressedByteLength: rs.readU64() + }); + } + const dfdTotalSize = rs.readU32(); + if (dfdTotalSize !== index.kvdByteOffset - index.dfdByteOffset) { + return null; + } + rs.skip(8); + const colorModel = rs.readU8(); + rs.skip(index.dfdByteLength - 9); + rs.skip(index.kvdByteLength); + if (header.supercompressionScheme === 1 || colorModel === KHRConstants.KHR_DF_MODEL_UASTC) { + var _asset$file; + const basisModuleFound = basisTranscode(this.device, url.load, arraybuffer, callback, { + isGGGR: ((asset2 == null || (_asset$file = asset2.file) == null || (_asset$file = _asset$file.variants) == null || (_asset$file = _asset$file.basis) == null ? void 0 : _asset$file.opt) & 8) !== 0, + isKTX2: true + }); + if (!basisModuleFound) { + callback('Basis module not found. Asset "' + asset2.name + '" basis texture variant will not be loaded.'); + } + } else { + callback("unsupported KTX2 pixel format"); + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/parsers/texture/dds.js +var DdsParser = class extends TextureParser { + constructor(registry) { + super(); + this.maxRetries = 0; + } + load(url, callback, asset2) { + Asset.fetchArrayBuffer(url.load, callback, asset2, this.maxRetries); + } + open(url, data2, device, textureOptions = {}) { + const header = new Uint32Array(data2, 0, 128 / 4); + const width = header[4]; + const height = header[3]; + const mips = Math.max(header[7], 1); + const isFourCc = header[20] === 4; + const fcc = header[21]; + const bpp = header[22]; + const isCubemap = header[28] === 65024; + const FCC_DXT1 = 827611204; + const FCC_DXT5 = 894720068; + const FCC_FP16 = 113; + const FCC_FP32 = 116; + const FCC_ETC1 = 826496069; + const FCC_PVRTC_2BPP_RGB_1 = 825438800; + const FCC_PVRTC_2BPP_RGBA_1 = 825504336; + const FCC_PVRTC_4BPP_RGB_1 = 825439312; + const FCC_PVRTC_4BPP_RGBA_1 = 825504848; + let compressed = false; + let etc1 = false; + let pvrtc2 = false; + let pvrtc4 = false; + let format = null; + let componentSize = 1; + let texture; + if (isFourCc) { + if (fcc === FCC_DXT1) { + format = PIXELFORMAT_DXT1; + compressed = true; + } else if (fcc === FCC_DXT5) { + format = PIXELFORMAT_DXT5; + compressed = true; + } else if (fcc === FCC_FP16) { + format = PIXELFORMAT_RGBA16F; + componentSize = 2; + } else if (fcc === FCC_FP32) { + format = PIXELFORMAT_RGBA32F; + componentSize = 4; + } else if (fcc === FCC_ETC1) { + format = PIXELFORMAT_ETC1; + compressed = true; + etc1 = true; + } else if (fcc === FCC_PVRTC_2BPP_RGB_1 || fcc === FCC_PVRTC_2BPP_RGBA_1) { + format = fcc === FCC_PVRTC_2BPP_RGB_1 ? PIXELFORMAT_PVRTC_2BPP_RGB_1 : PIXELFORMAT_PVRTC_2BPP_RGBA_1; + compressed = true; + pvrtc2 = true; + } else if (fcc === FCC_PVRTC_4BPP_RGB_1 || fcc === FCC_PVRTC_4BPP_RGBA_1) { + format = fcc === FCC_PVRTC_4BPP_RGB_1 ? PIXELFORMAT_PVRTC_4BPP_RGB_1 : PIXELFORMAT_PVRTC_4BPP_RGBA_1; + compressed = true; + pvrtc4 = true; + } + } else { + if (bpp === 32) { + format = PIXELFORMAT_RGBA8; + } + } + if (!format) { + texture = new Texture(device, { + width: 4, + height: 4, + format: PIXELFORMAT_RGB8, + name: "dds-legacy-empty" + }); + return texture; + } + texture = new Texture(device, _extends({ + name: url, + addressU: isCubemap ? ADDRESS_CLAMP_TO_EDGE : ADDRESS_REPEAT, + addressV: isCubemap ? ADDRESS_CLAMP_TO_EDGE : ADDRESS_REPEAT, + width, + height, + format, + cubemap: isCubemap, + mipmaps: mips > 1 + }, textureOptions)); + let offset = 128; + const faces = isCubemap ? 6 : 1; + let mipSize; + const DXT_BLOCK_WIDTH = 4; + const DXT_BLOCK_HEIGHT = 4; + const blockSize = fcc === FCC_DXT1 ? 8 : 16; + let numBlocksAcross, numBlocksDown, numBlocks; + for (let face = 0; face < faces; face++) { + let mipWidth = width; + let mipHeight = height; + for (let i = 0; i < mips; i++) { + if (compressed) { + if (etc1) { + mipSize = Math.floor((mipWidth + 3) / 4) * Math.floor((mipHeight + 3) / 4) * 8; + } else if (pvrtc2) { + mipSize = Math.max(mipWidth, 16) * Math.max(mipHeight, 8) / 4; + } else if (pvrtc4) { + mipSize = Math.max(mipWidth, 8) * Math.max(mipHeight, 8) / 2; + } else { + numBlocksAcross = Math.floor((mipWidth + DXT_BLOCK_WIDTH - 1) / DXT_BLOCK_WIDTH); + numBlocksDown = Math.floor((mipHeight + DXT_BLOCK_HEIGHT - 1) / DXT_BLOCK_HEIGHT); + numBlocks = numBlocksAcross * numBlocksDown; + mipSize = numBlocks * blockSize; + } + } else { + mipSize = mipWidth * mipHeight * 4; + } + const mipBuff = format === PIXELFORMAT_RGBA32F ? new Float32Array(data2, offset, mipSize) : format === PIXELFORMAT_RGBA16F ? new Uint16Array(data2, offset, mipSize) : new Uint8Array(data2, offset, mipSize); + if (!isCubemap) { + texture._levels[i] = mipBuff; + } else { + if (!texture._levels[i]) texture._levels[i] = []; + texture._levels[i][face] = mipBuff; + } + offset += mipSize * componentSize; + mipWidth = Math.max(mipWidth * 0.5, 1); + mipHeight = Math.max(mipHeight * 0.5, 1); + } + } + texture.upload(); + return texture; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/parsers/texture/hdr.js +var HdrParser = class extends TextureParser { + constructor(registry) { + super(); + this.maxRetries = 0; + } + load(url, callback, asset2) { + Asset.fetchArrayBuffer(url.load, callback, asset2, this.maxRetries); + } + open(url, data2, device, textureOptions = {}) { + const textureData = this.parse(data2); + if (!textureData) { + return null; + } + const texture = new Texture(device, _extends({ + name: url, + addressU: ADDRESS_REPEAT, + addressV: ADDRESS_CLAMP_TO_EDGE, + minFilter: FILTER_NEAREST, + magFilter: FILTER_NEAREST, + width: textureData.width, + height: textureData.height, + levels: textureData.levels, + format: PIXELFORMAT_RGBA8, + type: TEXTURETYPE_RGBE, + mipmaps: false + }, textureOptions)); + texture.upload(); + return texture; + } + parse(data2) { + const readStream = new ReadStream(data2); + const magic = readStream.readLine(); + if (!magic.startsWith("#?RADIANCE")) { + return null; + } + const variables = {}; + while (true) { + const line = readStream.readLine(); + if (line.length === 0) { + break; + } else { + const parts = line.split("="); + if (parts.length === 2) { + variables[parts[0]] = parts[1]; + } + } + } + if (!variables.hasOwnProperty("FORMAT")) { + return null; + } + const resolution = readStream.readLine().split(" "); + if (resolution.length !== 4) { + return null; + } + const height = parseInt(resolution[1], 10); + const width = parseInt(resolution[3], 10); + const pixels = this._readPixels(readStream, width, height, resolution[0] === "-Y"); + if (!pixels) { + return null; + } + return { + width, + height, + levels: [pixels] + }; + } + _readPixels(readStream, width, height, flipY) { + if (width < 8 || width > 32767) { + return this._readPixelsFlat(readStream, width, height); + } + const rgbe = [0, 0, 0, 0]; + readStream.readArray(rgbe); + if (rgbe[0] !== 2 || rgbe[1] !== 2 || (rgbe[2] & 128) !== 0) { + readStream.skip(-4); + return this._readPixelsFlat(readStream, width, height); + } + const buffer = new ArrayBuffer(width * height * 4); + const view = new Uint8Array(buffer); + let scanstart = flipY ? 0 : width * 4 * (height - 1); + let x2, y2, i, channel, count, value; + for (y2 = 0; y2 < height; ++y2) { + if (y2) { + readStream.readArray(rgbe); + } + if ((rgbe[2] << 8) + rgbe[3] !== width) { + return null; + } + for (channel = 0; channel < 4; ++channel) { + x2 = 0; + while (x2 < width) { + count = readStream.readU8(); + if (count > 128) { + count -= 128; + if (x2 + count > width) { + return null; + } + value = readStream.readU8(); + for (i = 0; i < count; ++i) { + view[scanstart + channel + 4 * x2++] = value; + } + } else { + if (count === 0 || x2 + count > width) { + return null; + } + for (i = 0; i < count; ++i) { + view[scanstart + channel + 4 * x2++] = readStream.readU8(); + } + } + } + } + scanstart += width * 4 * (flipY ? 1 : -1); + } + return view; + } + _readPixelsFlat(readStream, width, height) { + return readStream.remainingBytes === width * height * 4 ? new Uint8Array(readStream.arraybuffer, readStream.offset) : null; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/handlers/texture.js +var JSON_ADDRESS_MODE = { + "repeat": ADDRESS_REPEAT, + "clamp": ADDRESS_CLAMP_TO_EDGE, + "mirror": ADDRESS_MIRRORED_REPEAT +}; +var JSON_FILTER_MODE = { + "nearest": FILTER_NEAREST, + "linear": FILTER_LINEAR, + "nearest_mip_nearest": FILTER_NEAREST_MIPMAP_NEAREST, + "linear_mip_nearest": FILTER_LINEAR_MIPMAP_NEAREST, + "nearest_mip_linear": FILTER_NEAREST_MIPMAP_LINEAR, + "linear_mip_linear": FILTER_LINEAR_MIPMAP_LINEAR +}; +var JSON_TEXTURE_TYPE = { + "default": TEXTURETYPE_DEFAULT, + "rgbm": TEXTURETYPE_RGBM, + "rgbe": TEXTURETYPE_RGBE, + "rgbp": TEXTURETYPE_RGBP, + "swizzleGGGR": TEXTURETYPE_SWIZZLEGGGR +}; +var _completePartialMipmapChain = function _completePartialMipmapChain2(texture) { + const requiredMipLevels = TextureUtils.calcMipLevelsCount(texture._width, texture._height); + const isHtmlElement = function isHtmlElement2(object) { + return object instanceof HTMLCanvasElement || object instanceof HTMLImageElement || object instanceof HTMLVideoElement; + }; + if (!(texture._format === PIXELFORMAT_RGBA8 || texture._format === PIXELFORMAT_RGBA32F) || texture._volume || texture._compressed || texture._levels.length === 1 || texture._levels.length === requiredMipLevels || isHtmlElement(texture._cubemap ? texture._levels[0][0] : texture._levels[0])) { + return; + } + const downsample = function downsample2(width, height, data2) { + const sampledWidth = Math.max(1, width >> 1); + const sampledHeight = Math.max(1, height >> 1); + const sampledData = new data2.constructor(sampledWidth * sampledHeight * 4); + const xs = Math.floor(width / sampledWidth); + const ys = Math.floor(height / sampledHeight); + const xsys = xs * ys; + for (let y2 = 0; y2 < sampledHeight; ++y2) { + for (let x2 = 0; x2 < sampledWidth; ++x2) { + for (let e = 0; e < 4; ++e) { + let sum = 0; + for (let sy = 0; sy < ys; ++sy) { + for (let sx = 0; sx < xs; ++sx) { + sum += data2[(x2 * xs + sx + (y2 * ys + sy) * width) * 4 + e]; + } + } + sampledData[(x2 + y2 * sampledWidth) * 4 + e] = sum / xsys; + } + } + } + return sampledData; + }; + for (let level = texture._levels.length; level < requiredMipLevels; ++level) { + const width = Math.max(1, texture._width >> level - 1); + const height = Math.max(1, texture._height >> level - 1); + if (texture._cubemap) { + const mips = []; + for (let face = 0; face < 6; ++face) { + mips.push(downsample(width, height, texture._levels[level - 1][face])); + } + texture._levels.push(mips); + } else { + texture._levels.push(downsample(width, height, texture._levels[level - 1])); + } + } + texture._levelsUpdated = texture._cubemap ? [[true, true, true, true, true, true]] : [true]; +}; +var TextureHandler = class extends ResourceHandler { + constructor(app2) { + super(app2, "texture"); + const assets = app2.assets; + const device = app2.graphicsDevice; + this._device = device; + this._assets = assets; + this.imgParser = new ImgParser(assets, device); + this.parsers = { + dds: new DdsParser(assets), + ktx: new KtxParser(assets), + ktx2: new Ktx2Parser(assets, device), + basis: new BasisParser(assets, device), + hdr: new HdrParser(assets) + }; + } + set crossOrigin(value) { + this.imgParser.crossOrigin = value; + } + get crossOrigin() { + return this.imgParser.crossOrigin; + } + set maxRetries(value) { + this.imgParser.maxRetries = value; + for (const parser in this.parsers) { + if (this.parsers.hasOwnProperty(parser)) { + this.parsers[parser].maxRetries = value; + } + } + } + get maxRetries() { + return this.imgParser.maxRetries; + } + _getUrlWithoutParams(url) { + return url.indexOf("?") >= 0 ? url.split("?")[0] : url; + } + _getParser(url) { + const ext = path.getExtension(this._getUrlWithoutParams(url)).toLowerCase().replace(".", ""); + return this.parsers[ext] || this.imgParser; + } + _getTextureOptions(asset2) { + const options = {}; + if (asset2) { + var _asset$name; + if (((_asset$name = asset2.name) == null ? void 0 : _asset$name.length) > 0) { + options.name = asset2.name; + } + const assetData = asset2.data; + if (assetData.hasOwnProperty("minfilter")) { + options.minFilter = JSON_FILTER_MODE[assetData.minfilter]; + } + if (assetData.hasOwnProperty("magfilter")) { + options.magFilter = JSON_FILTER_MODE[assetData.magfilter]; + } + if (assetData.hasOwnProperty("addressu")) { + options.addressU = JSON_ADDRESS_MODE[assetData.addressu]; + } + if (assetData.hasOwnProperty("addressv")) { + options.addressV = JSON_ADDRESS_MODE[assetData.addressv]; + } + if (assetData.hasOwnProperty("mipmaps")) { + options.mipmaps = assetData.mipmaps; + } + if (assetData.hasOwnProperty("anisotropy")) { + options.anisotropy = assetData.anisotropy; + } + if (assetData.hasOwnProperty("flipY")) { + options.flipY = !!assetData.flipY; + } + if (assetData.hasOwnProperty("type")) { + options.type = JSON_TEXTURE_TYPE[assetData.type]; + } else if (assetData.hasOwnProperty("rgbm") && assetData.rgbm) { + options.type = TEXTURETYPE_RGBM; + } else if (asset2.file && (asset2.file.opt & 8) !== 0) { + options.type = TEXTURETYPE_SWIZZLEGGGR; + } + } + return options; + } + load(url, callback, asset2) { + if (typeof url === "string") { + url = { + load: url, + original: url + }; + } + this._getParser(url.original).load(url, callback, asset2); + } + open(url, data2, asset2) { + if (!url) return void 0; + const textureOptions = this._getTextureOptions(asset2); + let texture = this._getParser(url).open(url, data2, this._device, textureOptions); + if (texture === null) { + texture = new Texture(this._device, { + width: 4, + height: 4, + format: PIXELFORMAT_RGB8 + }); + } else { + _completePartialMipmapChain(texture); + if (data2.unswizzledGGGR) { + asset2.file.variants.basis.opt &= ~8; + } + } + return texture; + } + patch(asset2, assets) { + const texture = asset2.resource; + if (!texture) { + return; + } + const options = this._getTextureOptions(asset2); + for (const key of Object.keys(options)) { + texture[key] = options[key]; + } + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/xr/constants.js +var XRHAND_LEFT = "left"; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/xr/xr-finger.js +var XrFinger = class { + constructor(index, hand) { + this._index = void 0; + this._hand = void 0; + this._joints = []; + this._tip = null; + this._index = index; + this._hand = hand; + this._hand._fingers.push(this); + } + get index() { + return this._index; + } + get hand() { + return this._hand; + } + get joints() { + return this._joints; + } + get tip() { + return this._tip; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/xr/xr-joint.js +var tipJointIds = platform.browser && window.XRHand ? ["thumb-tip", "index-finger-tip", "middle-finger-tip", "ring-finger-tip", "pinky-finger-tip"] : []; +var tipJointIdsIndex = {}; +for (let i = 0; i < tipJointIds.length; i++) { + tipJointIdsIndex[tipJointIds[i]] = true; +} +var XrJoint = class { + constructor(index, id12, hand, finger = null) { + this._index = void 0; + this._id = void 0; + this._hand = void 0; + this._finger = void 0; + this._wrist = void 0; + this._tip = void 0; + this._radius = null; + this._localTransform = new Mat4(); + this._worldTransform = new Mat4(); + this._localPosition = new Vec3(); + this._localRotation = new Quat2(); + this._position = new Vec3(); + this._rotation = new Quat2(); + this._dirtyLocal = true; + this._index = index; + this._id = id12; + this._hand = hand; + this._finger = finger; + this._wrist = id12 === "wrist"; + this._tip = this._finger && !!tipJointIdsIndex[id12]; + } + update(pose) { + this._dirtyLocal = true; + this._radius = pose.radius; + this._localPosition.copy(pose.transform.position); + this._localRotation.copy(pose.transform.orientation); + } + _updateTransforms() { + if (this._dirtyLocal) { + this._dirtyLocal = false; + this._localTransform.setTRS(this._localPosition, this._localRotation, Vec3.ONE); + } + const manager = this._hand._manager; + const parent = manager.camera.parent; + if (parent) { + this._worldTransform.mul2(parent.getWorldTransform(), this._localTransform); + } else { + this._worldTransform.copy(this._localTransform); + } + } + getPosition() { + this._updateTransforms(); + this._worldTransform.getTranslation(this._position); + return this._position; + } + getRotation() { + this._updateTransforms(); + this._rotation.setFromMat4(this._worldTransform); + return this._rotation; + } + get index() { + return this._index; + } + get hand() { + return this._hand; + } + get finger() { + return this._finger; + } + get wrist() { + return this._wrist; + } + get tip() { + return this._tip; + } + get radius() { + return this._radius || 5e-3; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/xr/xr-hand.js +var fingerJointIds = []; +var vecA = new Vec3(); +var vecB = new Vec3(); +var vecC = new Vec3(); +if (platform.browser && window.XRHand) { + fingerJointIds = [["thumb-metacarpal", "thumb-phalanx-proximal", "thumb-phalanx-distal", "thumb-tip"], ["index-finger-metacarpal", "index-finger-phalanx-proximal", "index-finger-phalanx-intermediate", "index-finger-phalanx-distal", "index-finger-tip"], ["middle-finger-metacarpal", "middle-finger-phalanx-proximal", "middle-finger-phalanx-intermediate", "middle-finger-phalanx-distal", "middle-finger-tip"], ["ring-finger-metacarpal", "ring-finger-phalanx-proximal", "ring-finger-phalanx-intermediate", "ring-finger-phalanx-distal", "ring-finger-tip"], ["pinky-finger-metacarpal", "pinky-finger-phalanx-proximal", "pinky-finger-phalanx-intermediate", "pinky-finger-phalanx-distal", "pinky-finger-tip"]]; +} +var XrHand = class extends EventHandler { + constructor(inputSource) { + super(); + this._manager = void 0; + this._inputSource = void 0; + this._tracking = false; + this._fingers = []; + this._joints = []; + this._jointsById = {}; + this._tips = []; + this._wrist = null; + const xrHand = inputSource._xrInputSource.hand; + this._manager = inputSource._manager; + this._inputSource = inputSource; + if (xrHand.get("wrist")) { + const joint = new XrJoint(0, "wrist", this, null); + this._wrist = joint; + this._joints.push(joint); + this._jointsById.wrist = joint; + } + for (let f = 0; f < fingerJointIds.length; f++) { + const finger = new XrFinger(f, this); + for (let j = 0; j < fingerJointIds[f].length; j++) { + const jointId = fingerJointIds[f][j]; + if (!xrHand.get(jointId)) continue; + const joint = new XrJoint(j, jointId, this, finger); + this._joints.push(joint); + this._jointsById[jointId] = joint; + if (joint.tip) { + this._tips.push(joint); + finger._tip = joint; + } + finger._joints.push(joint); + } + } + } + update(frame) { + const xrInputSource = this._inputSource._xrInputSource; + for (let j = 0; j < this._joints.length; j++) { + const joint = this._joints[j]; + const jointSpace = xrInputSource.hand.get(joint._id); + if (jointSpace) { + let pose; + if (frame.session.visibilityState !== "hidden") pose = frame.getJointPose(jointSpace, this._manager._referenceSpace); + if (pose) { + joint.update(pose); + if (joint.wrist && !this._tracking) { + this._tracking = true; + this.fire("tracking"); + } + } else if (joint.wrist) { + if (this._tracking) { + this._tracking = false; + this.fire("trackinglost"); + } + break; + } + } + } + const j1 = this._jointsById["thumb-metacarpal"]; + const j4 = this._jointsById["thumb-tip"]; + const j6 = this._jointsById["index-finger-phalanx-proximal"]; + const j9 = this._jointsById["index-finger-tip"]; + const j16 = this._jointsById["ring-finger-phalanx-proximal"]; + const j21 = this._jointsById["pinky-finger-phalanx-proximal"]; + if (j1 && j4 && j6 && j9 && j16 && j21) { + this._inputSource._dirtyRay = true; + this._inputSource._rayLocal.origin.lerp(j4._localPosition, j9._localPosition, 0.5); + let jointL = j1; + let jointR = j21; + if (this._inputSource.handedness === XRHAND_LEFT) { + const t = jointL; + jointL = jointR; + jointR = t; + } + vecA.sub2(jointL._localPosition, this._wrist._localPosition); + vecB.sub2(jointR._localPosition, this._wrist._localPosition); + vecC.cross(vecA, vecB).normalize(); + vecA.lerp(j6._localPosition, j16._localPosition, 0.5); + vecA.sub(this._wrist._localPosition).normalize(); + this._inputSource._rayLocal.direction.lerp(vecC, vecA, 0.5).normalize(); + } + const squeezing = this._fingerIsClosed(1) && this._fingerIsClosed(2) && this._fingerIsClosed(3) && this._fingerIsClosed(4); + if (squeezing) { + if (!this._inputSource._squeezing) { + this._inputSource._squeezing = true; + this._inputSource.fire("squeezestart"); + this._manager.input.fire("squeezestart", this._inputSource); + } + } else { + if (this._inputSource._squeezing) { + this._inputSource._squeezing = false; + this._inputSource.fire("squeeze"); + this._manager.input.fire("squeeze", this._inputSource); + this._inputSource.fire("squeezeend"); + this._manager.input.fire("squeezeend", this._inputSource); + } + } + } + _fingerIsClosed(index) { + const finger = this._fingers[index]; + vecA.sub2(finger.joints[0]._localPosition, finger.joints[1]._localPosition).normalize(); + vecB.sub2(finger.joints[2]._localPosition, finger.joints[3]._localPosition).normalize(); + return vecA.dot(vecB) < -0.8; + } + getJointById(id12) { + return this._jointsById[id12] || null; + } + get fingers() { + return this._fingers; + } + get joints() { + return this._joints; + } + get tips() { + return this._tips; + } + get wrist() { + return this._wrist; + } + get tracking() { + return this._tracking; + } +}; +XrHand.EVENT_TRACKING = "tracking"; +XrHand.EVENT_TRACKINGLOST = "trackinglost"; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/xr/xr-input-source.js +var vec3A = new Vec3(); +var quat2 = new Quat2(); +var ids = 0; +var XrInputSource = class extends EventHandler { + constructor(manager, xrInputSource) { + super(); + this._id = void 0; + this._manager = void 0; + this._xrInputSource = void 0; + this._ray = new Ray(); + this._rayLocal = new Ray(); + this._grip = false; + this._hand = null; + this._velocitiesAvailable = false; + this._velocitiesTimestamp = now(); + this._localTransform = null; + this._worldTransform = null; + this._position = new Vec3(); + this._rotation = new Quat2(); + this._localPosition = null; + this._localPositionLast = null; + this._localRotation = null; + this._linearVelocity = null; + this._dirtyLocal = true; + this._dirtyRay = false; + this._selecting = false; + this._squeezing = false; + this._elementInput = true; + this._elementEntity = null; + this._hitTestSources = []; + this._id = ++ids; + this._manager = manager; + this._xrInputSource = xrInputSource; + if (xrInputSource.hand) this._hand = new XrHand(this); + } + get id() { + return this._id; + } + get inputSource() { + return this._xrInputSource; + } + get targetRayMode() { + return this._xrInputSource.targetRayMode; + } + get handedness() { + return this._xrInputSource.handedness; + } + get profiles() { + return this._xrInputSource.profiles; + } + get grip() { + return this._grip; + } + get hand() { + return this._hand; + } + get gamepad() { + return this._xrInputSource.gamepad || null; + } + get selecting() { + return this._selecting; + } + get squeezing() { + return this._squeezing; + } + set elementInput(value) { + if (this._elementInput === value) return; + this._elementInput = value; + if (!this._elementInput) this._elementEntity = null; + } + get elementInput() { + return this._elementInput; + } + get elementEntity() { + return this._elementEntity; + } + get hitTestSources() { + return this._hitTestSources; + } + update(frame) { + if (this._hand) { + this._hand.update(frame); + } else { + const gripSpace = this._xrInputSource.gripSpace; + if (gripSpace) { + const gripPose = frame.getPose(gripSpace, this._manager._referenceSpace); + if (gripPose) { + if (!this._grip) { + this._grip = true; + this._localTransform = new Mat4(); + this._worldTransform = new Mat4(); + this._localPositionLast = new Vec3(); + this._localPosition = new Vec3(); + this._localRotation = new Quat2(); + this._linearVelocity = new Vec3(); + } + const timestamp = now(); + const dt = (timestamp - this._velocitiesTimestamp) / 1e3; + this._velocitiesTimestamp = timestamp; + this._dirtyLocal = true; + this._localPositionLast.copy(this._localPosition); + this._localPosition.copy(gripPose.transform.position); + this._localRotation.copy(gripPose.transform.orientation); + this._velocitiesAvailable = true; + if (this._manager.input.velocitiesSupported && gripPose.linearVelocity) { + this._linearVelocity.copy(gripPose.linearVelocity); + } else if (dt > 0) { + vec3A.sub2(this._localPosition, this._localPositionLast).divScalar(dt); + this._linearVelocity.lerp(this._linearVelocity, vec3A, 0.15); + } + } else { + this._velocitiesAvailable = false; + } + } + const targetRayPose = frame.getPose(this._xrInputSource.targetRaySpace, this._manager._referenceSpace); + if (targetRayPose) { + this._dirtyRay = true; + this._rayLocal.origin.copy(targetRayPose.transform.position); + this._rayLocal.direction.set(0, 0, -1); + quat2.copy(targetRayPose.transform.orientation); + quat2.transformVector(this._rayLocal.direction, this._rayLocal.direction); + } + } + } + _updateTransforms() { + if (this._dirtyLocal) { + this._dirtyLocal = false; + this._localTransform.setTRS(this._localPosition, this._localRotation, Vec3.ONE); + } + const parent = this._manager.camera.parent; + if (parent) { + this._worldTransform.mul2(parent.getWorldTransform(), this._localTransform); + } else { + this._worldTransform.copy(this._localTransform); + } + } + _updateRayTransforms() { + const dirty = this._dirtyRay; + this._dirtyRay = false; + const parent = this._manager.camera.parent; + if (parent) { + const parentTransform = this._manager.camera.parent.getWorldTransform(); + parentTransform.getTranslation(this._position); + this._rotation.setFromMat4(parentTransform); + this._rotation.transformVector(this._rayLocal.origin, this._ray.origin); + this._ray.origin.add(this._position); + this._rotation.transformVector(this._rayLocal.direction, this._ray.direction); + } else if (dirty) { + this._ray.origin.copy(this._rayLocal.origin); + this._ray.direction.copy(this._rayLocal.direction); + } + } + getPosition() { + if (!this._position) return null; + this._updateTransforms(); + this._worldTransform.getTranslation(this._position); + return this._position; + } + getLocalPosition() { + return this._localPosition; + } + getRotation() { + if (!this._rotation) return null; + this._updateTransforms(); + this._rotation.setFromMat4(this._worldTransform); + return this._rotation; + } + getLocalRotation() { + return this._localRotation; + } + getLinearVelocity() { + if (!this._velocitiesAvailable) return null; + return this._linearVelocity; + } + getOrigin() { + this._updateRayTransforms(); + return this._ray.origin; + } + getDirection() { + this._updateRayTransforms(); + return this._ray.direction; + } + hitTestStart(options = {}) { + options.inputSource = this; + options.profile = this._xrInputSource.profiles[0]; + const callback = options.callback; + options.callback = (err, hitTestSource) => { + if (hitTestSource) this.onHitTestSourceAdd(hitTestSource); + if (callback) callback(err, hitTestSource); + }; + this._manager.hitTest.start(options); + } + onHitTestSourceAdd(hitTestSource) { + this._hitTestSources.push(hitTestSource); + this.fire("hittest:add", hitTestSource); + hitTestSource.on("result", (position2, rotation2, inputSource, hitTestResult) => { + if (inputSource !== this) return; + this.fire("hittest:result", hitTestSource, position2, rotation2, hitTestResult); + }); + hitTestSource.once("remove", () => { + this.onHitTestSourceRemove(hitTestSource); + this.fire("hittest:remove", hitTestSource); + }); + } + onHitTestSourceRemove(hitTestSource) { + const ind = this._hitTestSources.indexOf(hitTestSource); + if (ind !== -1) this._hitTestSources.splice(ind, 1); + } +}; +XrInputSource.EVENT_REMOVE = "remove"; +XrInputSource.EVENT_SELECT = "select"; +XrInputSource.EVENT_SELECTSTART = "selectstart"; +XrInputSource.EVENT_SELECTEND = "selectend"; +XrInputSource.EVENT_SQUEEZE = "squeeze"; +XrInputSource.EVENT_SQUEEZESTART = "squeezestart"; +XrInputSource.EVENT_SQUEEZEEND = "squeezeend"; +XrInputSource.EVENT_HITTESTADD = "hittest:add"; +XrInputSource.EVENT_HITTESTREMOVE = "hittest:remove"; +XrInputSource.EVENT_HITTESTRESULT = "hittest:result"; + +// ../../node_modules/playcanvas/build/playcanvas/src/framework/input/element-input.js +var targetX; +var targetY; +var vecA2 = new Vec3(); +var vecB2 = new Vec3(); +var rayA = new Ray(); +var rayB = new Ray(); +var rayC = new Ray(); +rayA.end = new Vec3(); +rayB.end = new Vec3(); +rayC.end = new Vec3(); +var _pq = new Vec3(); +var _pa = new Vec3(); +var _pb = new Vec3(); +var _pc = new Vec3(); +var _pd = new Vec3(); +var _m = new Vec3(); +var _au = new Vec3(); +var _bv = new Vec3(); +var _cw = new Vec3(); +var _ir = new Vec3(); +var _sct = new Vec3(); +var _accumulatedScale = new Vec3(); +var _paddingTop = new Vec3(); +var _paddingBottom = new Vec3(); +var _paddingLeft = new Vec3(); +var _paddingRight = new Vec3(); +var _cornerBottomLeft = new Vec3(); +var _cornerBottomRight = new Vec3(); +var _cornerTopRight = new Vec3(); +var _cornerTopLeft = new Vec3(); +var ZERO_VEC4 = new Vec4(); +function scalarTriple(p12, p22, p3) { + return _sct.cross(p12, p22).dot(p3); +} +function intersectLineQuad(p, q2, corners) { + _pq.sub2(q2, p); + _pa.sub2(corners[0], p); + _pb.sub2(corners[1], p); + _pc.sub2(corners[2], p); + _m.cross(_pc, _pq); + let v = _pa.dot(_m); + let u; + let w; + if (v >= 0) { + u = -_pb.dot(_m); + if (u < 0) return -1; + w = scalarTriple(_pq, _pb, _pa); + if (w < 0) return -1; + const denom = 1 / (u + v + w); + _au.copy(corners[0]).mulScalar(u * denom); + _bv.copy(corners[1]).mulScalar(v * denom); + _cw.copy(corners[2]).mulScalar(w * denom); + _ir.copy(_au).add(_bv).add(_cw); + } else { + _pd.sub2(corners[3], p); + u = _pd.dot(_m); + if (u < 0) return -1; + w = scalarTriple(_pq, _pa, _pd); + if (w < 0) return -1; + v = -v; + const denom = 1 / (u + v + w); + _au.copy(corners[0]).mulScalar(u * denom); + _bv.copy(corners[3]).mulScalar(v * denom); + _cw.copy(corners[2]).mulScalar(w * denom); + _ir.copy(_au).add(_bv).add(_cw); + } + if (_pq.sub2(corners[0], corners[2]).lengthSq() < 1e-4 * 1e-4) return -1; + if (_pq.sub2(corners[1], corners[3]).lengthSq() < 1e-4 * 1e-4) return -1; + return _ir.sub(p).lengthSq(); +} +var ElementInputEvent = class { + constructor(event, element, camera) { + this.event = event; + this.element = element; + this.camera = camera; + this._stopPropagation = false; + } + stopPropagation() { + this._stopPropagation = true; + if (this.event) { + this.event.stopImmediatePropagation(); + this.event.stopPropagation(); + } + } +}; +var ElementMouseEvent = class extends ElementInputEvent { + constructor(event, element, camera, x2, y2, lastX, lastY) { + super(event, element, camera); + this.x = x2; + this.y = y2; + this.ctrlKey = event.ctrlKey || false; + this.altKey = event.altKey || false; + this.shiftKey = event.shiftKey || false; + this.metaKey = event.metaKey || false; + this.button = event.button; + if (Mouse.isPointerLocked()) { + this.dx = event.movementX || event.webkitMovementX || event.mozMovementX || 0; + this.dy = event.movementY || event.webkitMovementY || event.mozMovementY || 0; + } else { + this.dx = x2 - lastX; + this.dy = y2 - lastY; + } + this.wheelDelta = 0; + if (event.type === "wheel") { + if (event.deltaY > 0) { + this.wheelDelta = 1; + } else if (event.deltaY < 0) { + this.wheelDelta = -1; + } + } + } +}; +var ElementTouchEvent = class extends ElementInputEvent { + constructor(event, element, camera, x2, y2, touch2) { + super(event, element, camera); + this.touches = event.touches; + this.changedTouches = event.changedTouches; + this.x = x2; + this.y = y2; + this.touch = touch2; + } +}; +var ElementSelectEvent = class extends ElementInputEvent { + constructor(event, element, camera, inputSource) { + super(event, element, camera); + this.inputSource = inputSource; + } +}; +var ElementInput = class _ElementInput { + constructor(domElement, options) { + this._app = null; + this._attached = false; + this._target = null; + this._enabled = true; + this._lastX = 0; + this._lastY = 0; + this._upHandler = this._handleUp.bind(this); + this._downHandler = this._handleDown.bind(this); + this._moveHandler = this._handleMove.bind(this); + this._wheelHandler = this._handleWheel.bind(this); + this._touchstartHandler = this._handleTouchStart.bind(this); + this._touchendHandler = this._handleTouchEnd.bind(this); + this._touchcancelHandler = this._touchendHandler; + this._touchmoveHandler = this._handleTouchMove.bind(this); + this._sortHandler = this._sortElements.bind(this); + this._elements = []; + this._hoveredElement = null; + this._pressedElement = null; + this._touchedElements = {}; + this._touchesForWhichTouchLeaveHasFired = {}; + this._selectedElements = {}; + this._selectedPressedElements = {}; + this._useMouse = !options || options.useMouse !== false; + this._useTouch = !options || options.useTouch !== false; + this._useXr = !options || options.useXr !== false; + this._selectEventsAttached = false; + if (platform.touch) this._clickedEntities = {}; + this.attach(domElement); + } + set enabled(value) { + this._enabled = value; + } + get enabled() { + return this._enabled; + } + set app(value) { + this._app = value; + } + get app() { + return this._app || getApplication(); + } + attach(domElement) { + if (this._attached) { + this._attached = false; + this.detach(); + } + this._target = domElement; + this._attached = true; + const opts = platform.passiveEvents ? { + passive: true + } : false; + if (this._useMouse) { + window.addEventListener("mouseup", this._upHandler, opts); + window.addEventListener("mousedown", this._downHandler, opts); + window.addEventListener("mousemove", this._moveHandler, opts); + window.addEventListener("wheel", this._wheelHandler, opts); + } + if (this._useTouch && platform.touch) { + this._target.addEventListener("touchstart", this._touchstartHandler, opts); + this._target.addEventListener("touchend", this._touchendHandler, false); + this._target.addEventListener("touchmove", this._touchmoveHandler, false); + this._target.addEventListener("touchcancel", this._touchcancelHandler, false); + } + this.attachSelectEvents(); + } + attachSelectEvents() { + if (!this._selectEventsAttached && this._useXr && this.app && this.app.xr && this.app.xr.supported) { + if (!this._clickedEntities) this._clickedEntities = {}; + this._selectEventsAttached = true; + this.app.xr.on("start", this._onXrStart, this); + } + } + detach() { + if (!this._attached) return; + this._attached = false; + const opts = platform.passiveEvents ? { + passive: true + } : false; + if (this._useMouse) { + window.removeEventListener("mouseup", this._upHandler, opts); + window.removeEventListener("mousedown", this._downHandler, opts); + window.removeEventListener("mousemove", this._moveHandler, opts); + window.removeEventListener("wheel", this._wheelHandler, opts); + } + if (this._useTouch) { + this._target.removeEventListener("touchstart", this._touchstartHandler, opts); + this._target.removeEventListener("touchend", this._touchendHandler, false); + this._target.removeEventListener("touchmove", this._touchmoveHandler, false); + this._target.removeEventListener("touchcancel", this._touchcancelHandler, false); + } + if (this._selectEventsAttached) { + this._selectEventsAttached = false; + this.app.xr.off("start", this._onXrStart, this); + this.app.xr.off("end", this._onXrEnd, this); + this.app.xr.off("update", this._onXrUpdate, this); + this.app.xr.input.off("selectstart", this._onSelectStart, this); + this.app.xr.input.off("selectend", this._onSelectEnd, this); + this.app.xr.input.off("remove", this._onXrInputRemove, this); + } + this._target = null; + } + addElement(element) { + if (this._elements.indexOf(element) === -1) this._elements.push(element); + } + removeElement(element) { + const idx = this._elements.indexOf(element); + if (idx !== -1) this._elements.splice(idx, 1); + } + _handleUp(event) { + if (!this._enabled) return; + if (Mouse.isPointerLocked()) return; + this._calcMouseCoords(event); + this._onElementMouseEvent("mouseup", event); + } + _handleDown(event) { + if (!this._enabled) return; + if (Mouse.isPointerLocked()) return; + this._calcMouseCoords(event); + this._onElementMouseEvent("mousedown", event); + } + _handleMove(event) { + if (!this._enabled) return; + this._calcMouseCoords(event); + this._onElementMouseEvent("mousemove", event); + this._lastX = targetX; + this._lastY = targetY; + } + _handleWheel(event) { + if (!this._enabled) return; + this._calcMouseCoords(event); + this._onElementMouseEvent("mousewheel", event); + } + _determineTouchedElements(event) { + const touchedElements = {}; + const cameras = this.app.systems.camera.cameras; + for (let i = cameras.length - 1; i >= 0; i--) { + const camera = cameras[i]; + let done = 0; + const len = event.changedTouches.length; + for (let j = 0; j < len; j++) { + if (touchedElements[event.changedTouches[j].identifier]) { + done++; + continue; + } + const coords = this._calcTouchCoords(event.changedTouches[j]); + const element = this._getTargetElementByCoords(camera, coords.x, coords.y); + if (element) { + done++; + touchedElements[event.changedTouches[j].identifier] = { + element, + camera, + x: coords.x, + y: coords.y + }; + } + } + if (done === len) { + break; + } + } + return touchedElements; + } + _handleTouchStart(event) { + if (!this._enabled) return; + const newTouchedElements = this._determineTouchedElements(event); + for (let i = 0, len = event.changedTouches.length; i < len; i++) { + const touch2 = event.changedTouches[i]; + const newTouchInfo = newTouchedElements[touch2.identifier]; + const oldTouchInfo = this._touchedElements[touch2.identifier]; + if (newTouchInfo && (!oldTouchInfo || newTouchInfo.element !== oldTouchInfo.element)) { + this._fireEvent(event.type, new ElementTouchEvent(event, newTouchInfo.element, newTouchInfo.camera, newTouchInfo.x, newTouchInfo.y, touch2)); + this._touchesForWhichTouchLeaveHasFired[touch2.identifier] = false; + } + } + for (const touchId in newTouchedElements) { + this._touchedElements[touchId] = newTouchedElements[touchId]; + } + } + _handleTouchEnd(event) { + if (!this._enabled) return; + const cameras = this.app.systems.camera.cameras; + for (const key in this._clickedEntities) { + delete this._clickedEntities[key]; + } + for (let i = 0, len = event.changedTouches.length; i < len; i++) { + const touch2 = event.changedTouches[i]; + const touchInfo = this._touchedElements[touch2.identifier]; + if (!touchInfo) continue; + const element = touchInfo.element; + const camera = touchInfo.camera; + const x2 = touchInfo.x; + const y2 = touchInfo.y; + delete this._touchedElements[touch2.identifier]; + delete this._touchesForWhichTouchLeaveHasFired[touch2.identifier]; + const coords = this._calcTouchCoords(touch2); + for (let c2 = cameras.length - 1; c2 >= 0; c2--) { + const hovered = this._getTargetElementByCoords(cameras[c2], coords.x, coords.y); + if (hovered === element) { + if (!this._clickedEntities[element.entity.getGuid()]) { + this._fireEvent("click", new ElementTouchEvent(event, element, camera, x2, y2, touch2)); + this._clickedEntities[element.entity.getGuid()] = Date.now(); + } + } + } + this._fireEvent(event.type, new ElementTouchEvent(event, element, camera, x2, y2, touch2)); + } + } + _handleTouchMove(event) { + event.preventDefault(); + if (!this._enabled) return; + const newTouchedElements = this._determineTouchedElements(event); + for (let i = 0, len = event.changedTouches.length; i < len; i++) { + const touch2 = event.changedTouches[i]; + const newTouchInfo = newTouchedElements[touch2.identifier]; + const oldTouchInfo = this._touchedElements[touch2.identifier]; + if (oldTouchInfo) { + const coords = this._calcTouchCoords(touch2); + if ((!newTouchInfo || newTouchInfo.element !== oldTouchInfo.element) && !this._touchesForWhichTouchLeaveHasFired[touch2.identifier]) { + this._fireEvent("touchleave", new ElementTouchEvent(event, oldTouchInfo.element, oldTouchInfo.camera, coords.x, coords.y, touch2)); + this._touchesForWhichTouchLeaveHasFired[touch2.identifier] = true; + } + this._fireEvent("touchmove", new ElementTouchEvent(event, oldTouchInfo.element, oldTouchInfo.camera, coords.x, coords.y, touch2)); + } + } + } + _onElementMouseEvent(eventType, event) { + let element = null; + const lastHovered = this._hoveredElement; + this._hoveredElement = null; + const cameras = this.app.systems.camera.cameras; + let camera; + for (let i = cameras.length - 1; i >= 0; i--) { + camera = cameras[i]; + element = this._getTargetElementByCoords(camera, targetX, targetY); + if (element) break; + } + this._hoveredElement = element; + if ((eventType === "mousemove" || eventType === "mouseup") && this._pressedElement) { + this._fireEvent(eventType, new ElementMouseEvent(event, this._pressedElement, camera, targetX, targetY, this._lastX, this._lastY)); + } else if (element) { + this._fireEvent(eventType, new ElementMouseEvent(event, element, camera, targetX, targetY, this._lastX, this._lastY)); + if (eventType === "mousedown") { + this._pressedElement = element; + } + } + if (lastHovered !== this._hoveredElement) { + if (lastHovered) { + this._fireEvent("mouseleave", new ElementMouseEvent(event, lastHovered, camera, targetX, targetY, this._lastX, this._lastY)); + } + if (this._hoveredElement) { + this._fireEvent("mouseenter", new ElementMouseEvent(event, this._hoveredElement, camera, targetX, targetY, this._lastX, this._lastY)); + } + } + if (eventType === "mouseup" && this._pressedElement) { + if (this._pressedElement === this._hoveredElement) { + const guid2 = this._hoveredElement.entity.getGuid(); + let fireClick = !this._clickedEntities; + if (this._clickedEntities) { + const lastTouchUp = this._clickedEntities[guid2] || 0; + const dt = Date.now() - lastTouchUp; + fireClick = dt > 300; + delete this._clickedEntities[guid2]; + } + if (fireClick) { + this._fireEvent("click", new ElementMouseEvent(event, this._hoveredElement, camera, targetX, targetY, this._lastX, this._lastY)); + } + } + this._pressedElement = null; + } + } + _onXrStart() { + this.app.xr.on("end", this._onXrEnd, this); + this.app.xr.on("update", this._onXrUpdate, this); + this.app.xr.input.on("selectstart", this._onSelectStart, this); + this.app.xr.input.on("selectend", this._onSelectEnd, this); + this.app.xr.input.on("remove", this._onXrInputRemove, this); + } + _onXrEnd() { + this.app.xr.off("update", this._onXrUpdate, this); + this.app.xr.input.off("selectstart", this._onSelectStart, this); + this.app.xr.input.off("selectend", this._onSelectEnd, this); + this.app.xr.input.off("remove", this._onXrInputRemove, this); + } + _onXrUpdate() { + if (!this._enabled) return; + const inputSources = this.app.xr.input.inputSources; + for (let i = 0; i < inputSources.length; i++) { + this._onElementSelectEvent("selectmove", inputSources[i], null); + } + } + _onXrInputRemove(inputSource) { + const hovered = this._selectedElements[inputSource.id]; + if (hovered) { + inputSource._elementEntity = null; + this._fireEvent("selectleave", new ElementSelectEvent(null, hovered, null, inputSource)); + } + delete this._selectedElements[inputSource.id]; + delete this._selectedPressedElements[inputSource.id]; + } + _onSelectStart(inputSource, event) { + if (!this._enabled) return; + this._onElementSelectEvent("selectstart", inputSource, event); + } + _onSelectEnd(inputSource, event) { + if (!this._enabled) return; + this._onElementSelectEvent("selectend", inputSource, event); + } + _onElementSelectEvent(eventType, inputSource, event) { + let element; + const hoveredBefore = this._selectedElements[inputSource.id]; + let hoveredNow; + const cameras = this.app.systems.camera.cameras; + let camera; + if (inputSource.elementInput) { + rayC.set(inputSource.getOrigin(), inputSource.getDirection()); + for (let i = cameras.length - 1; i >= 0; i--) { + camera = cameras[i]; + element = this._getTargetElementByRay(rayC, camera); + if (element) break; + } + } + inputSource._elementEntity = element || null; + if (element) { + this._selectedElements[inputSource.id] = element; + hoveredNow = element; + } else { + delete this._selectedElements[inputSource.id]; + } + if (hoveredBefore !== hoveredNow) { + if (hoveredBefore) this._fireEvent("selectleave", new ElementSelectEvent(event, hoveredBefore, camera, inputSource)); + if (hoveredNow) this._fireEvent("selectenter", new ElementSelectEvent(event, hoveredNow, camera, inputSource)); + } + const pressed = this._selectedPressedElements[inputSource.id]; + if (eventType === "selectmove" && pressed) { + this._fireEvent("selectmove", new ElementSelectEvent(event, pressed, camera, inputSource)); + } + if (eventType === "selectstart") { + this._selectedPressedElements[inputSource.id] = hoveredNow; + if (hoveredNow) this._fireEvent("selectstart", new ElementSelectEvent(event, hoveredNow, camera, inputSource)); + } + if (!inputSource.elementInput && pressed) { + delete this._selectedPressedElements[inputSource.id]; + if (hoveredBefore) { + this._fireEvent("selectend", new ElementSelectEvent(event, pressed, camera, inputSource)); + } + } + if (eventType === "selectend" && inputSource.elementInput) { + delete this._selectedPressedElements[inputSource.id]; + if (pressed) { + this._fireEvent("selectend", new ElementSelectEvent(event, pressed, camera, inputSource)); + } + if (pressed && pressed === hoveredBefore) { + this._fireEvent("click", new ElementSelectEvent(event, pressed, camera, inputSource)); + } + } + } + _fireEvent(name, evt) { + let element = evt.element; + while (true) { + element.fire(name, evt); + if (evt._stopPropagation) break; + if (!element.entity.parent) break; + element = element.entity.parent.element; + if (!element) break; + } + } + _calcMouseCoords(event) { + const rect = this._target.getBoundingClientRect(); + const left = Math.floor(rect.left); + const top = Math.floor(rect.top); + targetX = event.clientX - left; + targetY = event.clientY - top; + } + _calcTouchCoords(touch2) { + let totalOffsetX = 0; + let totalOffsetY = 0; + let target2 = touch2.target; + while (!(target2 instanceof HTMLElement)) { + target2 = target2.parentNode; + } + let currentElement = target2; + do { + totalOffsetX += currentElement.offsetLeft - currentElement.scrollLeft; + totalOffsetY += currentElement.offsetTop - currentElement.scrollTop; + currentElement = currentElement.offsetParent; + } while (currentElement); + return { + x: touch2.pageX - totalOffsetX, + y: touch2.pageY - totalOffsetY + }; + } + _sortElements(a, b) { + const layerOrder = this.app.scene.layers.sortTransparentLayers(a.layers, b.layers); + if (layerOrder !== 0) return layerOrder; + if (a.screen && !b.screen) return -1; + if (!a.screen && b.screen) return 1; + if (!a.screen && !b.screen) return 0; + if (a.screen.screen.screenSpace && !b.screen.screen.screenSpace) return -1; + if (b.screen.screen.screenSpace && !a.screen.screen.screenSpace) return 1; + return b.drawOrder - a.drawOrder; + } + _getTargetElementByCoords(camera, x2, y2) { + const rayScreen = this._calculateRayScreen(x2, y2, camera, rayA) ? rayA : null; + const ray3d = this._calculateRay3d(x2, y2, camera, rayB) ? rayB : null; + return this._getTargetElement(camera, rayScreen, ray3d); + } + _getTargetElementByRay(ray, camera) { + rayA.origin.copy(ray.origin); + rayA.direction.copy(ray.direction); + rayA.end.copy(rayA.direction).mulScalar(camera.farClip * 2).add(rayA.origin); + const ray3d = rayA; + const screenPos = camera.worldToScreen(ray3d.origin, vecA2); + const rayScreen = this._calculateRayScreen(screenPos.x, screenPos.y, camera, rayB) ? rayB : null; + return this._getTargetElement(camera, rayScreen, ray3d); + } + _getTargetElement(camera, rayScreen, ray3d) { + let result = null; + let closestDistance3d = Infinity; + this._elements.sort(this._sortHandler); + for (let i = 0, len = this._elements.length; i < len; i++) { + const element = this._elements[i]; + if (!element.layers.some((v) => camera.layersSet.has(v))) { + continue; + } + if (element.screen && element.screen.screen.screenSpace) { + if (!rayScreen) { + continue; + } + const currentDistance = this._checkElement(rayScreen, element, true); + if (currentDistance >= 0) { + result = element; + break; + } + } else { + if (!ray3d) { + continue; + } + const currentDistance = this._checkElement(ray3d, element, false); + if (currentDistance >= 0) { + if (currentDistance < closestDistance3d) { + result = element; + closestDistance3d = currentDistance; + } + if (element.screen) { + result = element; + break; + } + } + } + } + return result; + } + _calculateRayScreen(x2, y2, camera, ray) { + const sw = this.app.graphicsDevice.width; + const sh = this.app.graphicsDevice.height; + const cameraWidth = camera.rect.z * sw; + const cameraHeight = camera.rect.w * sh; + const cameraLeft = camera.rect.x * sw; + const cameraRight = cameraLeft + cameraWidth; + const cameraBottom = (1 - camera.rect.y) * sh; + const cameraTop = cameraBottom - cameraHeight; + let _x = x2 * sw / this._target.clientWidth; + let _y = y2 * sh / this._target.clientHeight; + if (_x >= cameraLeft && _x <= cameraRight && _y <= cameraBottom && _y >= cameraTop) { + _x = sw * (_x - cameraLeft) / cameraWidth; + _y = sh * (_y - cameraTop) / cameraHeight; + _y = sh - _y; + ray.origin.set(_x, _y, 1); + ray.direction.set(0, 0, -1); + ray.end.copy(ray.direction).mulScalar(2).add(ray.origin); + return true; + } + return false; + } + _calculateRay3d(x2, y2, camera, ray) { + const sw = this._target.clientWidth; + const sh = this._target.clientHeight; + const cameraWidth = camera.rect.z * sw; + const cameraHeight = camera.rect.w * sh; + const cameraLeft = camera.rect.x * sw; + const cameraRight = cameraLeft + cameraWidth; + const cameraBottom = (1 - camera.rect.y) * sh; + const cameraTop = cameraBottom - cameraHeight; + let _x = x2; + let _y = y2; + if (x2 >= cameraLeft && x2 <= cameraRight && y2 <= cameraBottom && _y >= cameraTop) { + _x = sw * (_x - cameraLeft) / cameraWidth; + _y = sh * (_y - cameraTop) / cameraHeight; + camera.screenToWorld(_x, _y, camera.nearClip, vecA2); + camera.screenToWorld(_x, _y, camera.farClip, vecB2); + ray.origin.copy(vecA2); + ray.direction.set(0, 0, -1); + ray.end.copy(vecB2); + return true; + } + return false; + } + _checkElement(ray, element, screen) { + if (element.maskedBy) { + if (this._checkElement(ray, element.maskedBy.element, screen) < 0) { + return -1; + } + } + let scale2; + if (screen) { + scale2 = _ElementInput.calculateScaleToScreen(element); + } else { + scale2 = _ElementInput.calculateScaleToWorld(element); + } + const corners = _ElementInput.buildHitCorners(element, screen ? element.screenCorners : element.worldCorners, scale2); + return intersectLineQuad(ray.origin, ray.end, corners); + } + static buildHitCorners(element, screenOrWorldCorners, scale2) { + let hitCorners = screenOrWorldCorners; + const button = element.entity && element.entity.button; + if (button) { + const hitPadding = element.entity.button.hitPadding || ZERO_VEC4; + _paddingTop.copy(element.entity.up); + _paddingBottom.copy(_paddingTop).mulScalar(-1); + _paddingRight.copy(element.entity.right); + _paddingLeft.copy(_paddingRight).mulScalar(-1); + _paddingTop.mulScalar(hitPadding.w * scale2.y); + _paddingBottom.mulScalar(hitPadding.y * scale2.y); + _paddingRight.mulScalar(hitPadding.z * scale2.x); + _paddingLeft.mulScalar(hitPadding.x * scale2.x); + _cornerBottomLeft.copy(hitCorners[0]).add(_paddingBottom).add(_paddingLeft); + _cornerBottomRight.copy(hitCorners[1]).add(_paddingBottom).add(_paddingRight); + _cornerTopRight.copy(hitCorners[2]).add(_paddingTop).add(_paddingRight); + _cornerTopLeft.copy(hitCorners[3]).add(_paddingTop).add(_paddingLeft); + hitCorners = [_cornerBottomLeft, _cornerBottomRight, _cornerTopRight, _cornerTopLeft]; + } + if (scale2.x < 0) { + const left = hitCorners[2].x; + const right2 = hitCorners[0].x; + hitCorners[0].x = left; + hitCorners[1].x = right2; + hitCorners[2].x = right2; + hitCorners[3].x = left; + } + if (scale2.y < 0) { + const bottom = hitCorners[2].y; + const top = hitCorners[0].y; + hitCorners[0].y = bottom; + hitCorners[1].y = bottom; + hitCorners[2].y = top; + hitCorners[3].y = top; + } + if (scale2.z < 0) { + const x2 = hitCorners[2].x; + const y2 = hitCorners[2].y; + const z2 = hitCorners[2].z; + hitCorners[2].x = hitCorners[0].x; + hitCorners[2].y = hitCorners[0].y; + hitCorners[2].z = hitCorners[0].z; + hitCorners[0].x = x2; + hitCorners[0].y = y2; + hitCorners[0].z = z2; + } + return hitCorners; + } + static calculateScaleToScreen(element) { + let current = element.entity; + const screenScale = element.screen.screen.scale; + _accumulatedScale.set(screenScale, screenScale, screenScale); + while (current && !current.screen) { + _accumulatedScale.mul(current.getLocalScale()); + current = current.parent; + } + return _accumulatedScale; + } + static calculateScaleToWorld(element) { + let current = element.entity; + _accumulatedScale.set(1, 1, 1); + while (current) { + _accumulatedScale.mul(current.getLocalScale()); + current = current.parent; + } + return _accumulatedScale; + } +}; + +// ../../node_modules/playcanvas/build/playcanvas/src/deprecated/deprecated.js +var LINEBATCH_OVERLAY = 1; +string.endsWith = function(s, subs) { + return s.endsWith(subs); +}; +string.startsWith = function(s, subs) { + return s.startsWith(subs); +}; +Object.defineProperty(Color.prototype, "data", { + get: function() { + if (!this._data) { + this._data = new Float32Array(4); + } + this._data[0] = this.r; + this._data[1] = this.g; + this._data[2] = this.b; + this._data[3] = this.a; + return this._data; + } +}); +Object.defineProperty(Color.prototype, "data3", { + get: function() { + if (!this._data3) { + this._data3 = new Float32Array(3); + } + this._data3[0] = this.r; + this._data3[1] = this.g; + this._data3[2] = this.b; + return this._data3; + } +}); +math.INV_LOG2 = Math.LOG2E; +math.intToBytes = math.intToBytes32; +math.bytesToInt = math.bytesToInt32; +Object.defineProperty(Vec2.prototype, "data", { + get: function() { + if (!this._data) { + this._data = new Float32Array(2); + } + this._data[0] = this.x; + this._data[1] = this.y; + return this._data; + } +}); +Vec2.prototype.scale = Vec2.prototype.mulScalar; +Object.defineProperty(Vec3.prototype, "data", { + get: function() { + if (!this._data) { + this._data = new Float32Array(3); + } + this._data[0] = this.x; + this._data[1] = this.y; + this._data[2] = this.z; + return this._data; + } +}); +Vec3.prototype.scale = Vec3.prototype.mulScalar; +Object.defineProperty(Vec4.prototype, "data", { + get: function() { + if (!this._data) { + this._data = new Float32Array(4); + } + this._data[0] = this.x; + this._data[1] = this.y; + this._data[2] = this.z; + this._data[3] = this.w; + return this._data; + } +}); +Vec4.prototype.scale = Vec4.prototype.mulScalar; +BoundingSphere.prototype.intersectRay = BoundingSphere.prototype.intersectsRay; +Frustum.prototype.update = function(projectionMatrix, viewMatrix) { + const viewProj = new Mat4(); + viewProj.mul2(projectionMatrix, viewMatrix); + this.setFromMat4(viewProj); +}; +var PIXELFORMAT_R8_G8_B8 = PIXELFORMAT_RGB8; +function UnsupportedBrowserError(message) { + this.name = "UnsupportedBrowserError"; + this.message = message || ""; +} +UnsupportedBrowserError.prototype = Error.prototype; +function ContextCreationError(message) { + this.name = "ContextCreationError"; + this.message = message || ""; +} +ContextCreationError.prototype = Error.prototype; +var programlib = { + begin: ShaderGenerator.begin, + dummyFragmentCode: ShaderUtils.dummyFragmentCode, + end: ShaderGenerator.end, + fogCode: ShaderGenerator.fogCode, + gammaCode: ShaderGenerator.gammaCode, + precisionCode: ShaderUtils.precisionCode, + skinCode: ShaderGenerator.skinCode, + tonemapCode: ShaderGenerator.tonemapCode, + versionCode: ShaderUtils.versionCode +}; +var _viewport3 = new Vec4(); +Object.defineProperty(shaderChunks, "transformSkinnedVS", { + get: function() { + return "#define SKIN\n" + shaderChunks.transformVS; + } +}); +var deprecatedChunks = { + "ambientPrefilteredCube.frag": "ambientEnv.frag", + "ambientPrefilteredCubeLod.frag": "ambientEnv.frag", + "dpAtlasQuad.frag": null, + "genParaboloid.frag": null, + "prefilterCubemap.frag": null, + "reflectionDpAtlas.frag": "reflectionEnv.frag", + "reflectionPrefilteredCube.frag": "reflectionEnv.frag", + "reflectionPrefilteredCubeLod.frag": "reflectionEnv.frag" +}; +Object.keys(deprecatedChunks).forEach((chunkName) => { + Object.defineProperty(shaderChunks, chunkName, { + get: function() { + return null; + }, + set: function() { + } + }); +}); +Object.defineProperties(RenderTarget.prototype, { + _glFrameBuffer: { + get: function() { + return this.impl._glFrameBuffer; + }, + set: function(rgbm) { + } + } +}); +Object.defineProperty(VertexFormat, "defaultInstancingFormat", { + get: function() { + return null; + } +}); +Object.defineProperties(Texture.prototype, { + rgbm: { + get: function() { + return this.type === TEXTURETYPE_RGBM; + }, + set: function(rgbm) { + this.type = rgbm ? TEXTURETYPE_RGBM : TEXTURETYPE_DEFAULT; + } + }, + swizzleGGGR: { + get: function() { + return this.type === TEXTURETYPE_SWIZZLEGGGR; + }, + set: function(swizzleGGGR) { + this.type = swizzleGGGR ? TEXTURETYPE_SWIZZLEGGGR : TEXTURETYPE_DEFAULT; + } + }, + _glTexture: { + get: function() { + return this.impl._glTexture; + } + }, + autoMipmap: { + get: function() { + return this._mipmaps; + }, + set: function(value) { + this._mipmaps = value; + } + } +}); +Object.defineProperty(GraphicsDevice.prototype, "webgl2", { + get: function() { + return this.isWebGL2; + } +}); +GraphicsDevice.prototype.getProgramLibrary = function() { + return getProgramLibrary(this); +}; +GraphicsDevice.prototype.setProgramLibrary = function(lib) { + setProgramLibrary(this, lib); +}; +GraphicsDevice.prototype.removeShaderFromCache = function(shader) { + getProgramLibrary(this).removeFromCache(shader); +}; +BlendState.DEFAULT = Object.freeze(new BlendState()); +var _tempBlendState = new BlendState(); +var _tempDepthState = new DepthState(); +GraphicsDevice.prototype.setBlendFunction = function(blendSrc, blendDst) { + const currentBlendState = this.blendState; + _tempBlendState.copy(currentBlendState); + _tempBlendState.setColorBlend(currentBlendState.colorOp, blendSrc, blendDst); + _tempBlendState.setAlphaBlend(currentBlendState.alphaOp, blendSrc, blendDst); + this.setBlendState(_tempBlendState); +}; +GraphicsDevice.prototype.setBlendFunctionSeparate = function(blendSrc, blendDst, blendSrcAlpha, blendDstAlpha) { + const currentBlendState = this.blendState; + _tempBlendState.copy(currentBlendState); + _tempBlendState.setColorBlend(currentBlendState.colorOp, blendSrc, blendDst); + _tempBlendState.setAlphaBlend(currentBlendState.alphaOp, blendSrcAlpha, blendDstAlpha); + this.setBlendState(_tempBlendState); +}; +GraphicsDevice.prototype.setBlendEquation = function(blendEquation) { + const currentBlendState = this.blendState; + _tempBlendState.copy(currentBlendState); + _tempBlendState.setColorBlend(blendEquation, currentBlendState.colorSrcFactor, currentBlendState.colorDstFactor); + _tempBlendState.setAlphaBlend(blendEquation, currentBlendState.alphaSrcFactor, currentBlendState.alphaDstFactor); + this.setBlendState(_tempBlendState); +}; +GraphicsDevice.prototype.setBlendEquationSeparate = function(blendEquation, blendAlphaEquation) { + const currentBlendState = this.blendState; + _tempBlendState.copy(currentBlendState); + _tempBlendState.setColorBlend(blendEquation, currentBlendState.colorSrcFactor, currentBlendState.colorDstFactor); + _tempBlendState.setAlphaBlend(blendAlphaEquation, currentBlendState.alphaSrcFactor, currentBlendState.alphaDstFactor); + this.setBlendState(_tempBlendState); +}; +GraphicsDevice.prototype.setColorWrite = function(redWrite, greenWrite, blueWrite, alphaWrite) { + const currentBlendState = this.blendState; + _tempBlendState.copy(currentBlendState); + _tempBlendState.setColorWrite(redWrite, greenWrite, blueWrite, alphaWrite); + this.setBlendState(_tempBlendState); +}; +GraphicsDevice.prototype.getBlending = function() { + return this.blendState.blend; +}; +GraphicsDevice.prototype.setBlending = function(blending) { + _tempBlendState.copy(this.blendState); + _tempBlendState.blend = blending; + this.setBlendState(_tempBlendState); +}; +GraphicsDevice.prototype.setDepthWrite = function(write) { + _tempDepthState.copy(this.depthState); + _tempDepthState.write = write; + this.setDepthState(_tempDepthState); +}; +GraphicsDevice.prototype.setDepthFunc = function(func) { + _tempDepthState.copy(this.depthState); + _tempDepthState.func = func; + this.setDepthState(_tempDepthState); +}; +GraphicsDevice.prototype.setDepthTest = function(test) { + _tempDepthState.copy(this.depthState); + _tempDepthState.test = test; + this.setDepthState(_tempDepthState); +}; +GraphicsDevice.prototype.getCullMode = function() { + return this.cullMode; +}; +Object.defineProperty(Scene.prototype, "defaultMaterial", { + get: function() { + return getDefaultMaterial(getApplication().graphicsDevice); + } +}); +Object.defineProperty(LayerComposition.prototype, "_meshInstances", { + get: function() { + return null; + } +}); +Object.defineProperty(Scene.prototype, "drawCalls", { + get: function() { + return null; + } +}); +["128", "64", "32", "16", "8", "4"].forEach((size, index) => { + Object.defineProperty(Scene.prototype, `skyboxPrefiltered${size}`, { + get: function() { + return this._prefilteredCubemaps[index]; + }, + set: function(value) { + this._prefilteredCubemaps[index] = value; + this.updateShaders = true; + } + }); +}); +Object.defineProperty(Scene.prototype, "models", { + get: function() { + if (!this._models) { + this._models = []; + } + return this._models; + } +}); +Object.defineProperty(Layer.prototype, "renderTarget", { + set: function(rt) { + this._renderTarget = rt; + this._dirtyComposition = true; + }, + get: function() { + return this._renderTarget; + } +}); +Scene.prototype.addModel = function(model) { + if (this.containsModel(model)) return; + const layer = this.layers.getLayerById(LAYERID_WORLD); + if (!layer) return; + layer.addMeshInstances(model.meshInstances); + this.models.push(model); +}; +Scene.prototype.addShadowCaster = function(model) { + const layer = this.layers.getLayerById(LAYERID_WORLD); + if (!layer) return; + layer.addShadowCasters(model.meshInstances); +}; +Scene.prototype.removeModel = function(model) { + const index = this.models.indexOf(model); + if (index !== -1) { + const layer = this.layers.getLayerById(LAYERID_WORLD); + if (!layer) return; + layer.removeMeshInstances(model.meshInstances); + this.models.splice(index, 1); + } +}; +Scene.prototype.removeShadowCasters = function(model) { + const layer = this.layers.getLayerById(LAYERID_WORLD); + if (!layer) return; + layer.removeShadowCasters(model.meshInstances); +}; +Scene.prototype.containsModel = function(model) { + return this.models.indexOf(model) >= 0; +}; +Scene.prototype.getModels = function(model) { + return this.models; +}; +Object.defineProperty(Batch.prototype, "model", { + get: function() { + return null; + } +}); +ForwardRenderer.prototype.renderComposition = function(comp) { + getApplication().renderComposition(comp); +}; +MeshInstance.prototype.syncAabb = function() { +}; +Morph.prototype.getTarget = function(index) { + return this.targets[index]; +}; +GraphNode.prototype._dirtify = function(local) { + if (local) this._dirtifyLocal(); + else this._dirtifyWorld(); +}; +GraphNode.prototype.addLabel = function(label) { + this._labels[label] = true; +}; +GraphNode.prototype.getLabels = function() { + return Object.keys(this._labels); +}; +GraphNode.prototype.hasLabel = function(label) { + return !!this._labels[label]; +}; +GraphNode.prototype.removeLabel = function(label) { + delete this._labels[label]; +}; +GraphNode.prototype.findByLabel = function(label, results = []) { + if (this.hasLabel(label)) { + results.push(this); + } + for (let i = 0; i < this._children.length; ++i) { + results = this._children[i].findByLabel(label, results); + } + return results; +}; +GraphNode.prototype.getChildren = function() { + return this.children; +}; +GraphNode.prototype.getName = function() { + return this.name; +}; +GraphNode.prototype.getPath = function() { + return this.path; +}; +GraphNode.prototype.getRoot = function() { + return this.root; +}; +GraphNode.prototype.getParent = function() { + return this.parent; +}; +GraphNode.prototype.setName = function(name) { + this.name = name; +}; +Material.prototype.getName = function() { + return this.name; +}; +Material.prototype.setName = function(name) { + this.name = name; +}; +Material.prototype.getShader = function() { + return this.shader; +}; +Material.prototype.setShader = function(shader) { + this.shader = shader; +}; +Object.defineProperty(Material.prototype, "blend", { + set: function(value) { + this.blendState.blend = value; + }, + get: function() { + return this.blendState.blend; + } +}); +Object.defineProperty(Material.prototype, "blendSrc", { + set: function(value) { + const currentBlendState = this.blendState; + _tempBlendState.copy(currentBlendState); + _tempBlendState.setColorBlend(currentBlendState.colorOp, value, currentBlendState.colorDstFactor); + _tempBlendState.setAlphaBlend(currentBlendState.alphaOp, value, currentBlendState.alphaDstFactor); + this.blendState = _tempBlendState; + }, + get: function() { + return this.blendState.colorSrcFactor; + } +}); +Object.defineProperty(Material.prototype, "blendDst", { + set: function(value) { + const currentBlendState = this.blendState; + _tempBlendState.copy(currentBlendState); + _tempBlendState.setColorBlend(currentBlendState.colorOp, currentBlendState.colorSrcFactor, value); + _tempBlendState.setAlphaBlend(currentBlendState.alphaOp, currentBlendState.alphaSrcFactor, value); + this.blendState = _tempBlendState; + }, + get: function() { + return this.blendState.colorDstFactor; + } +}); +Object.defineProperty(StandardMaterial.prototype, "shininess", { + get: function() { + return this.gloss * 100; + }, + set: function(value) { + this.gloss = value * 0.01; + } +}); +function _defineAlias(newName, oldName) { + Object.defineProperty(StandardMaterial.prototype, oldName, { + get: function() { + return this[newName]; + }, + set: function(value) { + this[newName] = value; + } + }); +} +_defineAlias("diffuseTint", "diffuseMapTint"); +_defineAlias("specularTint", "specularMapTint"); +_defineAlias("emissiveTint", "emissiveMapTint"); +_defineAlias("aoVertexColor", "aoMapVertexColor"); +_defineAlias("diffuseVertexColor", "diffuseMapVertexColor"); +_defineAlias("specularVertexColor", "specularMapVertexColor"); +_defineAlias("emissiveVertexColor", "emissiveMapVertexColor"); +_defineAlias("metalnessVertexColor", "metalnessMapVertexColor"); +_defineAlias("glossVertexColor", "glossMapVertexColor"); +_defineAlias("opacityVertexColor", "opacityMapVertexColor"); +_defineAlias("lightVertexColor", "lightMapVertexColor"); +_defineAlias("sheenGloss", "sheenGlossiess"); +_defineAlias("clearCoatGloss", "clearCostGlossiness"); +function _defineOption(name, newName) { + if (name !== "pass") { + Object.defineProperty(StandardMaterialOptions.prototype, name, { + get: function() { + return this.litOptions[newName || name]; + }, + set: function(value) { + this.litOptions[newName || name] = value; + } + }); + } +} +_defineOption("refraction", "useRefraction"); +var tempOptions = new LitShaderOptions(); +var litOptionProperties = Object.getOwnPropertyNames(tempOptions); +for (const litOption in litOptionProperties) { + _defineOption(litOptionProperties[litOption]); +} +Animation.prototype.getDuration = function() { + return this.duration; +}; +Animation.prototype.getName = function() { + return this.name; +}; +Animation.prototype.getNodes = function() { + return this.nodes; +}; +Animation.prototype.setDuration = function(duration) { + this.duration = duration; +}; +Animation.prototype.setName = function(name) { + this.name = name; +}; +Skeleton.prototype.getAnimation = function() { + return this.animation; +}; +Skeleton.prototype.getCurrentTime = function() { + return this.currentTime; +}; +Skeleton.prototype.getLooping = function() { + return this.looping; +}; +Skeleton.prototype.getNumNodes = function() { + return this.numNodes; +}; +Skeleton.prototype.setAnimation = function(animation) { + this.animation = animation; +}; +Skeleton.prototype.setCurrentTime = function(time2) { + this.currentTime = time2; +}; +Skeleton.prototype.setLooping = function(looping) { + this.looping = looping; +}; +SoundManager.prototype.getListener = function() { + return this.listener; +}; +SoundManager.prototype.getVolume = function() { + return this.volume; +}; +SoundManager.prototype.setVolume = function(volume) { + this.volume = volume; +}; +AssetRegistry.prototype.getAssetById = function(id12) { + return this.get(id12); +}; +Object.defineProperty(XrInputSource.prototype, "ray", { + get: function() { + return this._rayLocal; + } +}); +Object.defineProperty(XrInputSource.prototype, "position", { + get: function() { + return this._localPosition; + } +}); +Object.defineProperty(XrInputSource.prototype, "rotation", { + get: function() { + return this._localRotation; + } +}); +Object.defineProperty(ElementInput.prototype, "wheel", { + get: function() { + return this.wheelDelta * -2; + } +}); +Object.defineProperty(MouseEvent.prototype, "wheel", { + get: function() { + return this.wheelDelta * -2; + } +}); +AppBase.prototype.isFullscreen = function() { + return !!document.fullscreenElement; +}; +AppBase.prototype.enableFullscreen = function(element, success, error) { + element = element || this.graphicsDevice.canvas; + const s = function s2() { + success(); + document.removeEventListener("fullscreenchange", s2); + }; + const e = function e2() { + error(); + document.removeEventListener("fullscreenerror", e2); + }; + if (success) { + document.addEventListener("fullscreenchange", s, false); + } + if (error) { + document.addEventListener("fullscreenerror", e, false); + } + if (element.requestFullscreen) { + element.requestFullscreen(Element.ALLOW_KEYBOARD_INPUT); + } else { + error(); + } +}; +AppBase.prototype.disableFullscreen = function(success) { + const s = function s2() { + success(); + document.removeEventListener("fullscreenchange", s2); + }; + if (success) { + document.addEventListener("fullscreenchange", s, false); + } + document.exitFullscreen(); +}; +AppBase.prototype.getSceneUrl = function(name) { + const entry = this.scenes.find(name); + if (entry) { + return entry.url; + } + return null; +}; +AppBase.prototype.loadScene = function(url, callback) { + this.scenes.loadScene(url, callback); +}; +AppBase.prototype.loadSceneHierarchy = function(url, callback) { + this.scenes.loadSceneHierarchy(url, callback); +}; +AppBase.prototype.loadSceneSettings = function(url, callback) { + this.scenes.loadSceneSettings(url, callback); +}; +AppBase.prototype.renderMeshInstance = function(meshInstance, options) { + const layer = options != null && options.layer ? options.layer : this.scene.defaultDrawLayer; + this.scene.immediate.drawMesh(null, null, null, meshInstance, layer); +}; +AppBase.prototype.renderMesh = function(mesh, material, matrix2, options) { + const layer = options != null && options.layer ? options.layer : this.scene.defaultDrawLayer; + this.scene.immediate.drawMesh(material, matrix2, mesh, null, layer); +}; +AppBase.prototype._addLines = function(positions, colors, options) { + const layer = options && options.layer ? options.layer : this.scene.layers.getLayerById(LAYERID_IMMEDIATE); + const depthTest = options && options.depthTest !== void 0 ? options.depthTest : true; + const batch = this.scene.immediate.getBatch(layer, depthTest); + batch.addLines(positions, colors); +}; +AppBase.prototype.renderLine = function(start, end, color) { + let endColor = color; + let options; + const arg3 = arguments[3]; + const arg4 = arguments[4]; + if (arg3 instanceof Color) { + endColor = arg3; + if (typeof arg4 === "number") { + if (arg4 === LINEBATCH_OVERLAY) { + options = { + layer: this.scene.layers.getLayerById(LAYERID_IMMEDIATE), + depthTest: false + }; + } else { + options = { + layer: this.scene.layers.getLayerById(LAYERID_IMMEDIATE), + depthTest: true + }; + } + } else { + options = arg4; + } + } else if (typeof arg3 === "number") { + endColor = color; + if (arg3 === LINEBATCH_OVERLAY) { + options = { + layer: this.scene.layers.getLayerById(LAYERID_IMMEDIATE), + depthTest: false + }; + } else { + options = { + layer: this.scene.layers.getLayerById(LAYERID_IMMEDIATE), + depthTest: true + }; + } + } else if (arg3) { + options = arg3; + } + this._addLines([start, end], [color, endColor], options); +}; +AppBase.prototype.renderLines = function(position2, color, options) { + if (!options) { + options = { + layer: this.scene.layers.getLayerById(LAYERID_IMMEDIATE), + depthTest: true + }; + } else if (typeof options === "number") { + if (options === LINEBATCH_OVERLAY) { + options = { + layer: this.scene.layers.getLayerById(LAYERID_IMMEDIATE), + depthTest: false + }; + } else { + options = { + layer: this.scene.layers.getLayerById(LAYERID_IMMEDIATE), + depthTest: true + }; + } + } + const multiColor = !!color.length; + if (multiColor) { + if (position2.length !== color.length) { + console.error("renderLines: position/color arrays have different lengths"); + return; + } + } + if (position2.length % 2 !== 0) { + console.error("renderLines: array length is not divisible by 2"); + return; + } + this._addLines(position2, color, options); +}; +AppBase.prototype.enableVr = function() { +}; +Object.defineProperty(CameraComponent.prototype, "node", { + get: function() { + return this.entity; + } +}); +Object.defineProperty(LightComponent.prototype, "enable", { + get: function() { + return this.enabled; + }, + set: function(value) { + this.enabled = value; + } +}); +ModelComponent.prototype.setVisible = function(visible) { + this.enabled = visible; +}; +Object.defineProperty(ModelComponent.prototype, "aabb", { + get: function() { + return null; + }, + set: function(type2) { + } +}); +Object.defineProperty(RenderComponent.prototype, "aabb", { + get: function() { + return null; + }, + set: function(type2) { + } +}); +Object.defineProperty(RigidBodyComponent.prototype, "bodyType", { + get: function() { + return this.type; + }, + set: function(type2) { + this.type = type2; + } +}); +RigidBodyComponent.prototype.syncBodyToEntity = function() { + this._updateDynamic(); +}; +RigidBodyComponentSystem.prototype.setGravity = function() { + if (arguments.length === 1) { + this.gravity.copy(arguments[0]); + } else { + this.gravity.set(arguments[0], arguments[1], arguments[2]); + } +}; + +// ../../node_modules/@mml-io/mml-web-playcanvas/build/index.js +var mouseMovePixelsThreshold = 10; +var mouseMoveTimeThresholdMilliseconds = 500; +var PlayCanvasClickTrigger = class _PlayCanvasClickTrigger { + constructor(playcanvasApp, clickTarget, camera) { + this.playcanvasApp = playcanvasApp; + this.clickTarget = clickTarget; + this.camera = camera; + this.eventHandlerCollection = new EventHandlerCollection(); + this.mouseDownTime = null; + this.mouseMoveDelta = 0; + this.eventHandlerCollection.add(clickTarget, "mousedown", this.handleMouseDown.bind(this)); + this.eventHandlerCollection.add(clickTarget, "mouseup", this.handleMouseUp.bind(this)); + this.eventHandlerCollection.add(clickTarget, "mousemove", this.handleMouseMove.bind(this)); + } + static init(playcanvasApp, clickTarget, camera) { + return new _PlayCanvasClickTrigger(playcanvasApp, clickTarget, camera); + } + handleMouseDown() { + this.mouseDownTime = Date.now(); + this.mouseMoveDelta = 0; + } + handleMouseUp(event) { + if (!this.mouseDownTime) { + return; + } + const duration = Date.now() - this.mouseDownTime; + this.mouseDownTime = null; + if (this.mouseMoveDelta < mouseMovePixelsThreshold && duration < mouseMoveTimeThresholdMilliseconds) { + this.handleClick(event); + } + } + handleMouseMove(event) { + if (this.mouseDownTime) { + this.mouseMoveDelta += Math.abs(event.movementX) + Math.abs(event.movementY); + } + } + handleClick(event) { + if (event.detail.element) { + return; + } + let x2 = 0; + let y2 = 0; + if (!document.pointerLockElement) { + x2 = event.offsetX; + y2 = event.offsetY; + } + const cameraEntity = this.camera; + const from = cameraEntity.getPosition(); + const cameraComponent = cameraEntity.camera; + if (!cameraComponent) { + console.warn("No camera component found on the camera entity. Cannot raycast."); + return; + } + const to = cameraComponent.screenToWorld(x2, y2, cameraComponent.farClip); + const rigidbodySystem = this.playcanvasApp.systems.rigidbody; + if (!rigidbodySystem) { + console.warn("No rigidbody system found in the PlayCanvas app. Cannot raycast."); + return; + } + const result = rigidbodySystem.raycastFirst(from, to); + if (result) { + const hitEntity = result.entity; + let mElement; + for (let entity = hitEntity; entity; entity = entity.parent) { + mElement = MElement.getMElementFromObject(entity); + if (mElement) { + break; + } + } + if (mElement && mElement instanceof TransformableElement && mElement.isClickable()) { + const elementRelative = getRelativePositionAndRotationRelativeToObject( + { + position: result.point, + rotation: { + x: 0, + y: 0, + z: 0 + } + }, + mElement + ); + mElement.dispatchEvent( + new CustomEvent("click", { + bubbles: true, + detail: { + position: { + ...elementRelative.position + } + } + }) + ); + return; + } + } + } + dispose() { + this.eventHandlerCollection.clear(); + } +}; +var _PlayCanvasAudio = class _PlayCanvasAudio2 extends AudioGraphics { + constructor(audio2) { + super(audio2); + this.audio = audio2; + this.srcLoadingInstanceManager = new LoadingInstanceManager(`${Audio2.tagName}.src`); + this.latestSrcAudioPromise = null; + this.loadedState = null; + this.delayedStartTimer = null; + this.delayedPauseTimer = null; + const audioEntity = this.audio.getContainer(); + this.soundComponent = audioEntity.addComponent("sound", { + positional: true, + distanceModel: "inverse", + volume: audio2.props.volume + }); + } + getPlayCanvasApp() { + return this.audio.getScene().getGraphicsAdapter().getPlayCanvasApp(); + } + setSrc(src) { + if (this.loadedState !== null) { + this.soundComponent.removeSlot("slot"); + this.loadedState.asset.unload(); + this.loadedState = null; + } + if (!src) { + this.srcLoadingInstanceManager.abortIfLoading(); + return; + } + const contentSrc = this.audio.contentSrcToContentAddress(src); + const srcAudioPromise = this.asyncLoadSourceAsset( + contentSrc, + this.getAudioContext(), + (loaded, total) => { + this.srcLoadingInstanceManager.setProgress(loaded / total); + } + ); + this.srcLoadingInstanceManager.start(this.audio.getLoadingProgressManager(), contentSrc); + this.latestSrcAudioPromise = srcAudioPromise; + srcAudioPromise.then((asset2) => { + if (this.latestSrcAudioPromise !== srcAudioPromise || !this.audio.isConnected) { + return; + } + this.latestSrcAudioPromise = null; + this.loadedState = { + asset: asset2 + }; + const sound = asset2; + this.soundComponent.addSlot("slot", { + volume: 1, + pitch: 1, + asset: sound.id, + loop: true, + overlap: false, + autoPlay: false + }); + const slot = this.soundComponent.slot("slot"); + if (slot) { + slot.stop(); + slot.overlap = false; + this.syncAudioTime(); + } + this.srcLoadingInstanceManager.finish(); + }).catch((err) => { + console.error("Error loading m-audio.src", err); + this.srcLoadingInstanceManager.error(err); + }); + } + setStartTime() { + this.syncAudioTime(); + } + setPauseTime() { + this.syncAudioTime(); + } + setLoopDuration() { + this.syncAudioTime(); + } + syncAudioTime() { + if (this.delayedStartTimer) { + clearTimeout(this.delayedStartTimer); + this.delayedStartTimer = null; + } + if (this.delayedPauseTimer !== null) { + clearTimeout(this.delayedPauseTimer); + this.delayedPauseTimer = null; + } + if (!this.audio.props.src) { + return; + } + const slot = this.soundComponent.slot("slot"); + if (slot) { + if (!this.audio.props.enabled || this.audio.isDisabled()) { + slot.stop(); + return; + } + if (slot.loop !== this.audio.props.loop) { + slot.loop = this.audio.props.loop; + } + const documentTime = this.audio.getDocumentTime(); + if (this.audio.props.pauseTime !== null) { + if (documentTime !== null && this.audio.props.pauseTime > documentTime) { + const delayedPauseTimer = setTimeout(() => { + if (this.delayedPauseTimer === delayedPauseTimer) { + this.delayedPauseTimer = null; + } + this.syncAudioTime(); + }, this.audio.props.pauseTime - documentTime); + this.delayedPauseTimer = delayedPauseTimer; + } else { + slot.pause(); + return; + } + } + let currentTime; + if (documentTime) { + currentTime = (documentTime - this.audio.props.startTime) / 1e3; + } else { + currentTime = (this.audio.props.startTime ? this.audio.props.startTime : 0) / 1e3; + } + const asset2 = slot._assets.get(slot.asset); + const assetDuration = (asset2 == null ? void 0 : asset2.resource.duration) || null; + let targetDuration = assetDuration; + if (this.audio.props.loopDuration !== null && this.audio.props.loop) { + const loopDuration = this.audio.props.loopDuration / 1e3; + if (assetDuration !== null && loopDuration > assetDuration) { + asset2.resource.buffer = extendAudioToDuration( + this.getAudioContext(), + asset2.resource.buffer, + loopDuration + ); + slot.pause(); + slot.duration = loopDuration; + } + targetDuration = loopDuration; + } + if (targetDuration !== null && slot.duration !== targetDuration) { + slot.pause(); + slot.duration = targetDuration; + } + let desiredAudioTime; + if (currentTime < 0) { + slot.pause(); + const delayedStartTimer = setTimeout(() => { + if (this.delayedStartTimer === delayedStartTimer) { + this.delayedStartTimer = null; + } + this.syncAudioTime(); + }, -currentTime * 1e3); + this.delayedStartTimer = delayedStartTimer; + return; + } else if (this.audio.props.loop) { + const slotDuration = slot.duration; + desiredAudioTime = currentTime % slotDuration; + } else { + desiredAudioTime = currentTime; + } + if (desiredAudioTime >= slot.duration) { + slot.pause(); + return; + } else { + } + if (slot.isLoaded && (slot.isPaused || slot.isStopped)) { + slot.play(); + } + const soundInstance = slot.instances[0]; + let delta = desiredAudioTime - soundInstance.currentTime; + if (this.audio.props.loop) { + const loopedDelta = delta - slot.duration; + if (Math.abs(delta) > Math.abs(loopedDelta)) { + delta = loopedDelta; + } + } + if (Math.abs(delta) < 0.1) { + slot.pitch = 1; + } else if (Math.abs(delta) > 0.5) { + slot.pitch = 1; + slot.pause(); + soundInstance.currentTime = desiredAudioTime; + slot.resume(); + return; + } else { + if (delta > 0) { + slot.pitch = 1.02; + } else { + slot.pitch = 0.98; + } + } + } + } + getAudioContext() { + const playcanvasApp = this.getPlayCanvasApp(); + const soundSystem = playcanvasApp.systems.sound; + if (!soundSystem) { + throw new Error("Playcanvas sound system not enabled"); + } + return soundSystem.context; + } + enable() { + } + disable() { + } + setLoop() { + this.syncAudioTime(); + } + setEnabled() { + } + setVolume() { + this.soundComponent.volume = this.audio.props.volume; + } + setConeAngle() { + } + setConeFalloffAngle() { + } + setDebug() { + } + async asyncLoadSourceAsset(url, audioContext, onProgress) { + return new Promise((resolve, reject) => { + if (url.startsWith("data:")) { + const base64 = url.split(",", 2)[1]; + if (!base64) { + reject(new Error("Invalid data URL")); + return; + } + let arrayBuffer; + try { + const binary = atob(base64); + const uint8Array = new Uint8Array(binary.length); + for (let i = 0; i < binary.length; i++) { + uint8Array[i] = binary.charCodeAt(i); + } + arrayBuffer = uint8Array.buffer; + } catch (e) { + console.error("Failed to decode base64 data URL", e); + return; + } + audioContext.decodeAudioData(arrayBuffer).then((audioBuffer) => { + const soundComp = new Sound(audioBuffer); + const asset22 = new Asset( + "dataAudioFile-" + _PlayCanvasAudio2.dataAudioFileCount++, + "audio", + { url }, + base64 + ); + asset22.resource = soundComp; + asset22.loaded = true; + this.getPlayCanvasApp().assets.add(asset22); + resolve(asset22); + }).catch((e) => { + console.error("Failed to decode data URI audio data", e); + }); + return; + } + const asset2 = new Asset(url, "audio", { url }); + this.getPlayCanvasApp().assets.add(asset2); + this.getPlayCanvasApp().assets.load(asset2); + asset2.ready((asset22) => { + resolve(asset22); + }); + asset2.on("error", (err) => { + console.error("Error loading audio asset", err); + reject(err); + }); + }); + } + dispose() { + if (this.delayedPauseTimer) { + clearTimeout(this.delayedPauseTimer); + this.delayedPauseTimer = null; + } + if (this.delayedStartTimer) { + clearTimeout(this.delayedStartTimer); + this.delayedStartTimer = null; + } + const audioEntity = this.audio.getContainer(); + audioEntity.removeComponent("sound"); + } +}; +_PlayCanvasAudio.dataAudioFileCount = 0; +var PlayCanvasAudio = _PlayCanvasAudio; +function extendAudioToDuration(context, buffer, seconds) { + const updatedBuffer = context.createBuffer( + buffer.numberOfChannels, + Math.ceil(seconds * buffer.sampleRate), + buffer.sampleRate + ); + for (let channelNumber = 0; channelNumber < buffer.numberOfChannels; channelNumber++) { + const channelData = buffer.getChannelData(channelNumber); + const updatedChannelData = updatedBuffer.getChannelData(channelNumber); + updatedChannelData.set(channelData, 0); + } + return updatedBuffer; +} +var PlayCanvasChatProbe = class extends ChatProbeGraphics { + constructor(chatProbe) { + super(chatProbe); + this.chatProbe = chatProbe; + this.entity = null; + this.debugMaterial = null; + this.updateDebugVisualisation(); + } + disable() { + } + enable() { + } + setRange() { + this.updateDebugVisualisation(); + } + setDebug() { + this.updateDebugVisualisation(); + } + clearDebugVisualisation() { + if (this.entity) { + this.entity.destroy(); + this.entity = null; + } + if (this.debugMaterial) { + this.debugMaterial.destroy(); + this.debugMaterial = null; + } + } + updateDebugVisualisation() { + var _a; + if (!this.chatProbe.props.debug) { + this.clearDebugVisualisation(); + } else { + if (this.chatProbe.isConnected && !this.entity) { + this.entity = new Entity( + "chat-probe-internal", + this.chatProbe.getScene().getGraphicsAdapter().getPlayCanvasApp() + ); + if (!this.debugMaterial) { + this.debugMaterial = new BasicMaterial(); + this.debugMaterial.color = new Color(1, 1, 0); + } + this.entity.addComponent("model", { + type: "sphere", + material: this.debugMaterial + }); + (_a = this.entity.model) == null ? void 0 : _a.model.meshInstances.forEach((mi) => { + mi.renderStyle = RENDERSTYLE_WIREFRAME; + mi.castShadow = false; + }); + this.chatProbe.getContainer().addChild(this.entity); + } + if (this.entity) { + this.entity.setLocalScale( + this.chatProbe.props.range * 2, + this.chatProbe.props.range * 2, + this.chatProbe.props.range * 2 + ); + } + } + } + dispose() { + this.clearDebugVisualisation(); + } +}; +var PlayCanvasCube = class extends CubeGraphics { + constructor(cube) { + super(cube); + this.cube = cube; + this.material = new StandardMaterial(); + this.entity = new Entity( + "cube-internal", + cube.getScene().getGraphicsAdapter().getPlayCanvasApp() + ); + this.entity[MELEMENT_PROPERTY_NAME] = cube; + this.renderComponent = this.entity.addComponent("render", { + type: "box", + material: this.material + }); + this.entity.addComponent("collision", { + type: "box", + halfExtents: new Vec3(0.5, 0.5, 0.5) + }); + cube.getContainer().addChild(this.entity); + } + disable() { + } + enable() { + } + getCollisionElement() { + return this.entity; + } + setColor(color) { + this.material.diffuse.set(color.r, color.g, color.b); + this.material.metalness = 0; + this.material.useMetalness = true; + this.material.update(); + } + updateSize(mCubeProps) { + this.entity.setLocalScale(mCubeProps.width, mCubeProps.height, mCubeProps.depth); + if (this.entity.collision) { + this.entity.collision.halfExtents.set( + mCubeProps.width / 2, + mCubeProps.height / 2, + mCubeProps.depth / 2 + ); + this.entity.collision.onSetHalfExtents(); + } + } + setWidth(width, mCubeProps) { + this.updateSize(mCubeProps); + } + setHeight(height, mCubeProps) { + this.updateSize(mCubeProps); + } + setDepth(depth, mCubeProps) { + this.updateSize(mCubeProps); + } + setCastShadows(castShadows) { + this.renderComponent.castShadows = castShadows; + } + setOpacity(opacity) { + if (opacity === 1) { + this.material.blendType = BLEND_NONE; + } else { + this.material.blendType = BLEND_NORMAL; + } + this.material.opacity = opacity; + this.material.update(); + } + dispose() { + this.entity.destroy(); + } +}; +var PlayCanvasCylinder = class extends CylinderGraphics { + constructor(cylinder) { + super(cylinder); + this.cylinder = cylinder; + this.material = new StandardMaterial(); + this.entity = new Entity( + "cylinder-internal", + cylinder.getScene().getGraphicsAdapter().getPlayCanvasApp() + ); + this.entity[MELEMENT_PROPERTY_NAME] = cylinder; + this.renderComponent = this.entity.addComponent("render", { + type: "cylinder", + material: this.material + }); + const collisionComponent = this.entity.addComponent("collision", { + type: "cylinder" + }); + collisionComponent.radius = 0.5; + collisionComponent.height = 1; + cylinder.getContainer().addChild(this.entity); + } + disable() { + } + enable() { + } + getCollisionElement() { + return this.entity; + } + setColor(color) { + this.material.diffuse.set(color.r, color.g, color.b); + this.material.metalness = 0; + this.material.useMetalness = true; + this.material.update(); + } + updateSize(mCylinderProps) { + this.entity.setLocalScale( + mCylinderProps.radius * 2, + mCylinderProps.height, + mCylinderProps.radius * 2 + ); + if (this.entity.collision) { + this.entity.collision.radius = mCylinderProps.radius; + this.entity.collision.height = mCylinderProps.height; + this.entity.collision.onSetHalfExtents(); + } + } + setRadius(radius, mCylinderProps) { + this.updateSize(mCylinderProps); + } + setHeight(height, mCylinderProps) { + this.updateSize(mCylinderProps); + } + setCastShadows(castShadows) { + this.renderComponent.castShadows = castShadows; + } + setOpacity(opacity) { + if (opacity === 1) { + this.material.blendType = BLEND_NONE; + } else { + this.material.blendType = BLEND_NORMAL; + } + this.material.opacity = opacity; + this.material.update(); + } + dispose() { + this.entity.destroy(); + } +}; +function createPlayCanvasDebugBoundingBox(graphicsAdapter, material) { + var _a; + const entity = new Entity("bounding-box", graphicsAdapter.getPlayCanvasApp()); + entity.addComponent("model", { + type: "box", + material + }); + (_a = entity.model) == null ? void 0 : _a.model.meshInstances.forEach((mi) => { + mi.renderStyle = RENDERSTYLE_WIREFRAME; + mi.castShadow = false; + }); + return entity; +} +var PlayCanvasDebugHelper = class extends DebugHelperGraphics { + constructor(debugHelper) { + super(debugHelper); + this.debugHelper = debugHelper; + this.debugAxes = null; + const graphicsAdapter = this.debugHelper.element.getScene().getGraphicsAdapter(); + const playcanvasApp = graphicsAdapter.getPlayCanvasApp(); + const playcanvasEntity = this.debugHelper.getContainer(); + this.debugAxes = new Entity("axes", playcanvasApp); + playcanvasEntity.addChild(this.debugAxes); + const xMaterial = new BasicMaterial(); + xMaterial.color = new Color(1, 0, 0); + const xAxis = createPlayCanvasDebugBoundingBox(graphicsAdapter, xMaterial); + xAxis.setLocalScale(0.5, 0, 0); + xAxis.setLocalPosition(0.25, 0, 0); + this.debugAxes.addChild(xAxis); + const yMaterial = new BasicMaterial(); + yMaterial.color = new Color(0, 1, 0); + const yAxis = createPlayCanvasDebugBoundingBox(graphicsAdapter, yMaterial); + yAxis.setLocalScale(0, 0.5, 0); + yAxis.setLocalPosition(0, 0.25, 0); + this.debugAxes.addChild(yAxis); + const zMaterial = new BasicMaterial(); + zMaterial.color = new Color(0, 0, 1); + const zAxis = createPlayCanvasDebugBoundingBox(graphicsAdapter, zMaterial); + zAxis.setLocalScale(0, 0, 0.5); + zAxis.setLocalPosition(0, 0, 0.25); + this.debugAxes.addChild(zAxis); + } + dispose() { + if (this.debugAxes) { + this.debugHelper.getContainer().removeChild(this.debugAxes); + this.debugAxes.destroy(); + } + this.debugAxes = null; + } +}; +function setEntityToBoundingBox(debugBoxConstraintMesh, minX, maxX, minY, maxY, minZ, maxZ) { + debugBoxConstraintMesh.setLocalPosition((maxX + minX) / 2, (maxY + minY) / 2, (maxZ + minZ) / 2); + debugBoxConstraintMesh.setLocalScale(-(maxX - minX), maxY - minY, maxZ - minZ); +} +var PlayCanvasFrame = class extends FrameGraphics { + constructor(frame) { + super(frame); + this.frame = frame; + this.debugMaterial = null; + this.loadRangeMaterial = null; + this.unloadRangeMaterial = null; + this.debugMeshes = null; + this.updateDebugVisualisation(); + } + setSrc() { + } + setDebug() { + this.updateDebugVisualisation(); + } + setLoadRange() { + this.updateDebugVisualisation(); + } + setUnloadRange() { + this.updateDebugVisualisation(); + } + setMinX() { + this.updateDebugVisualisation(); + } + setMaxX() { + this.updateDebugVisualisation(); + } + setMinY() { + this.updateDebugVisualisation(); + } + setMaxY() { + this.updateDebugVisualisation(); + } + setMinZ() { + this.updateDebugVisualisation(); + } + setMaxZ() { + this.updateDebugVisualisation(); + } + disable() { + } + enable() { + } + dispose() { + this.clearDebugVisualisation(); + } + clearDebugVisualisation() { + if (this.debugMeshes) { + this.debugMeshes.debugBoxConstraintMesh.destroy(); + this.debugMeshes.debugBoxLoadRangeMesh.destroy(); + this.debugMeshes.debugBoxUnloadRangeMesh.destroy(); + this.debugMeshes = null; + } + if (this.debugMaterial) { + this.debugMaterial.destroy(); + this.debugMaterial = null; + } + if (this.loadRangeMaterial) { + this.loadRangeMaterial.destroy(); + this.loadRangeMaterial = null; + } + if (this.unloadRangeMaterial) { + this.unloadRangeMaterial.destroy(); + this.unloadRangeMaterial = null; + } + } + updateDebugVisualisation() { + if (!this.frame.props.debug) { + this.clearDebugVisualisation(); + } else { + if (!this.frame.isConnected) { + return; + } + if (!this.debugMeshes) { + if (!this.debugMaterial) { + this.debugMaterial = new BasicMaterial(); + this.debugMaterial.color = new Color(1, 0, 0); + } + if (!this.loadRangeMaterial) { + this.loadRangeMaterial = new BasicMaterial(); + this.loadRangeMaterial.color = new Color(0, 1, 0); + } + if (!this.unloadRangeMaterial) { + this.unloadRangeMaterial = new BasicMaterial(); + this.unloadRangeMaterial.color = new Color(0, 0, 1); + } + const graphicsAdapter = this.frame.getScene().getGraphicsAdapter(); + this.debugMeshes = { + debugBoxConstraintMesh: createPlayCanvasDebugBoundingBox( + graphicsAdapter, + this.debugMaterial + ), + debugBoxLoadRangeMesh: createPlayCanvasDebugBoundingBox( + graphicsAdapter, + this.loadRangeMaterial + ), + debugBoxUnloadRangeMesh: createPlayCanvasDebugBoundingBox( + graphicsAdapter, + this.unloadRangeMaterial + ) + }; + this.frame.getContainer().addChild(this.debugMeshes.debugBoxConstraintMesh); + this.frame.getContainer().addChild(this.debugMeshes.debugBoxLoadRangeMesh); + this.frame.getContainer().addChild(this.debugMeshes.debugBoxUnloadRangeMesh); + } + let boxBounds = this.frame.getDefinedBoxBounds(); + if (!boxBounds) { + boxBounds = [0, 0, 0, 0, 0, 0]; + } + const [minX, maxX, minY, maxY, minZ, maxZ] = boxBounds; + this.debugMeshes.debugBoxConstraintMesh.enabled = true; + setEntityToBoundingBox( + this.debugMeshes.debugBoxConstraintMesh, + minX, + maxX, + minY, + maxY, + minZ, + maxZ + ); + if (this.frame.props.loadRange === null) { + this.debugMeshes.debugBoxLoadRangeMesh.enabled = false; + this.debugMeshes.debugBoxUnloadRangeMesh.enabled = false; + } else { + this.debugMeshes.debugBoxLoadRangeMesh.enabled = true; + this.debugMeshes.debugBoxUnloadRangeMesh.enabled = true; + setEntityToBoundingBox( + this.debugMeshes.debugBoxLoadRangeMesh, + minX - this.frame.props.loadRange, + maxX + this.frame.props.loadRange, + minY - this.frame.props.loadRange, + maxY + this.frame.props.loadRange, + minZ - this.frame.props.loadRange, + maxZ + this.frame.props.loadRange + ); + setEntityToBoundingBox( + this.debugMeshes.debugBoxUnloadRangeMesh, + minX - this.frame.props.loadRange - this.frame.props.unloadRange, + maxX + this.frame.props.loadRange + this.frame.props.unloadRange, + minY - this.frame.props.loadRange - this.frame.props.unloadRange, + maxY + this.frame.props.loadRange + this.frame.props.unloadRange, + minZ - this.frame.props.loadRange - this.frame.props.unloadRange, + maxZ + this.frame.props.loadRange + this.frame.props.unloadRange + ); + } + } + } +}; +function createPlaneMesh(app2) { + const vertices = [ + // First triangle + // bottom left + -0.5, + -0.5, + 0, + // bottom right + 0.5, + -0.5, + 0, + // top left + -0.5, + 0.5, + 0, + // Second triangle + // bottom right + 0.5, + -0.5, + 0, + // top right + 0.5, + 0.5, + 0, + // top left + -0.5, + 0.5, + 0, + // First triangle + // top left + -0.5, + 0.5, + 0, + // bottom right + 0.5, + -0.5, + 0, + // bottom left + -0.5, + -0.5, + 0, + // Second triangle + // top left + -0.5, + 0.5, + 0, + // top right + 0.5, + 0.5, + 0, + // bottom right + 0.5, + -0.5, + 0 + ]; + const uvs = [ + // First triangle + // bottom left + 0, + 1, + // bottom right + 1, + 1, + // top left + 0, + 0, + // Second triangle + // bottom right + 1, + 1, + // top right + 1, + 0, + // top left + 0, + 0, + // First triangle + // top left + 0, + 0, + // bottom right + 1, + 1, + // bottom left + 0, + 1, + // Second triangle + // top left + 0, + 0, + // top right + 1, + 0, + // bottom right + 1, + 1 + ]; + const normals = Array.from({ length: vertices.length / 3 }).flatMap((value, index) => { + return index < 6 ? [0, 0, 1] : [0, 0, -1]; + }); + const mesh = new Mesh(app2.graphicsDevice); + mesh.setPositions(vertices); + mesh.setUvs(0, uvs); + mesh.setNormals(normals); + mesh.update(); + return mesh; +} +function createPlaneModel(app2, material) { + const mesh = createPlaneMesh(app2); + const rootNode = new GraphNode(); + const meshInstance = new MeshInstance(mesh, material, rootNode); + meshInstance.renderStyle = RENDERSTYLE_SOLID; + const model = new Model2(); + model.graph = rootNode; + model.meshInstances.push(meshInstance); + return { model, meshInstance }; +} +var PlayCanvasImage = class extends ImageGraphics { + constructor(image, updateMeshCallback) { + super(image, updateMeshCallback); + this.image = image; + this.updateMeshCallback = updateMeshCallback; + this.srcLoadingInstanceManager = new LoadingInstanceManager(`${Image2.tagName}.src`); + this.latestSrcImagePromise = null; + this.material = new StandardMaterial(); + this.loadedState = null; + this.entity = image.getContainer(); + this.internalEntity = new Entity( + "image-internal", + image.getScene().getGraphicsAdapter().getPlayCanvasApp() + ); + this.internalEntity[MELEMENT_PROPERTY_NAME] = image; + const { model } = createPlaneModel(this.getPlayCanvasApp(), this.material); + this.modelComponent = this.internalEntity.addComponent( + "model", + {} + ); + this.modelComponent.model = model; + this.entity.addComponent("collision", { + type: "box", + halfExtents: new Vec3(0.5, 0, 0.5) + }); + this.entity.addChild(this.internalEntity); + } + disable() { + } + enable() { + } + getWidthAndHeight() { + return { + width: this.internalEntity.getLocalScale().x, + height: this.internalEntity.getLocalScale().y + }; + } + getCollisionElement() { + return this.entity; + } + getPlayCanvasApp() { + return this.image.getScene().getGraphicsAdapter().getPlayCanvasApp(); + } + updateWidthAndHeight() { + var _a; + const loadedImage = (_a = this.loadedState) == null ? void 0 : _a.asset.resource; + const { width, height } = calculateContentSize({ + content: loadedImage ? { width: loadedImage.width, height: loadedImage.height } : void 0, + width: this.image.props.width, + height: this.image.props.height + }); + this.internalEntity.setLocalScale(width, height, 1); + if (this.entity.collision) { + this.entity.collision.halfExtents.set(width / 2, height / 2, 0); + this.entity.collision.onSetHalfExtents(); + } + this.updateMeshCallback(); + } + setWidth() { + this.updateWidthAndHeight(); + } + setHeight() { + this.updateWidthAndHeight(); + } + clearImage() { + if (this.material) { + this.material.diffuseMap = null; + this.material.opacityMap = null; + this.material.emissiveMap = null; + this.material.update(); + } + this.updateWidthAndHeight(); + } + setSrc(src) { + if (this.loadedState !== null) { + this.loadedState.asset.unload(); + this.loadedState = null; + } + if (!src) { + this.clearImage(); + this.srcLoadingInstanceManager.abortIfLoading(); + return; + } + const contentSrc = this.image.contentSrcToContentAddress(src); + const srcImagePromise = this.asyncLoadSourceAsset(contentSrc, (loaded, total) => { + this.srcLoadingInstanceManager.setProgress(loaded / total); + }); + this.srcLoadingInstanceManager.start(this.image.getLoadingProgressManager(), contentSrc); + this.latestSrcImagePromise = srcImagePromise; + srcImagePromise.then((asset2) => { + if (this.latestSrcImagePromise !== srcImagePromise || !this.image.isConnected) { + return; + } + this.latestSrcImagePromise = null; + this.loadedState = { + asset: asset2 + }; + const texture = asset2.resource; + texture.premultiplyAlpha = true; + this.material.diffuseMap = texture; + this.material.blendType = BLEND_NORMAL; + this.material.opacityMap = texture; + this.material.update(); + this.updateWidthAndHeight(); + this.updateMaterialEmissiveIntensity(); + this.srcLoadingInstanceManager.finish(); + }).catch((err) => { + console.error("Error loading m-image.src", err); + this.clearImage(); + this.srcLoadingInstanceManager.error(err); + }); + } + setCastShadows(castShadows) { + this.modelComponent.castShadows = castShadows; + } + setOpacity(opacity) { + if (opacity === 1) { + this.material.blendType = BLEND_NONE; + } else { + this.material.blendType = BLEND_NORMAL; + } + this.material.opacity = opacity; + this.material.update(); + } + setEmissive() { + this.updateMaterialEmissiveIntensity(); + } + updateMaterialEmissiveIntensity() { + if (this.image.props.emissive) { + this.material.emissiveMap = this.material.diffuseMap; + this.material.emissiveIntensity = this.image.props.emissive; + } else { + this.material.emissiveMap = null; + this.material.emissiveIntensity = 0; + } + this.material.update(); + } + async asyncLoadSourceAsset(url, onProgress) { + return new Promise((resolve, reject) => { + const asset2 = new Asset(url, "texture", { url }); + this.getPlayCanvasApp().assets.add(asset2); + this.getPlayCanvasApp().assets.load(asset2); + asset2.ready((asset22) => { + resolve(asset22); + }); + asset2.on("error", (err) => { + reject(err); + }); + }); + } + dispose() { + if (this.loadedState) { + this.loadedState.asset.unload(); + this.loadedState = null; + } + this.internalEntity.destroy(); + } +}; +var PlayCanvasInteraction = class extends InteractionGraphics { + constructor(positionProbe) { + super(positionProbe); + this.positionProbe = positionProbe; + this.entity = null; + this.debugMaterial = null; + this.updateDebugVisualisation(); + } + disable() { + } + enable() { + } + setRange() { + this.updateDebugVisualisation(); + } + setInFocus() { + } + setLineOfSight() { + } + setPriority() { + } + setPrompt() { + } + setDebug() { + this.updateDebugVisualisation(); + } + clearDebugVisualisation() { + if (this.entity) { + this.entity.destroy(); + this.entity = null; + } + if (this.debugMaterial) { + this.debugMaterial.destroy(); + this.debugMaterial = null; + } + } + updateDebugVisualisation() { + var _a; + if (!this.positionProbe.props.debug) { + this.clearDebugVisualisation(); + } else { + if (this.positionProbe.isConnected && !this.entity) { + this.entity = new Entity( + "interaction-internal", + this.positionProbe.getScene().getGraphicsAdapter().getPlayCanvasApp() + ); + if (!this.debugMaterial) { + this.debugMaterial = new BasicMaterial(); + this.debugMaterial.color = new Color(0, 1, 0); + } + this.entity.addComponent("model", { + type: "sphere", + material: this.debugMaterial + }); + (_a = this.entity.model) == null ? void 0 : _a.model.meshInstances.forEach((mi) => { + mi.renderStyle = RENDERSTYLE_WIREFRAME; + mi.castShadow = false; + }); + this.positionProbe.getContainer().addChild(this.entity); + } + if (this.entity) { + this.entity.setLocalScale( + this.positionProbe.props.range * 2, + this.positionProbe.props.range * 2, + this.positionProbe.props.range * 2 + ); + } + } + } + dispose() { + this.clearDebugVisualisation(); + } +}; +var PlayCanvasLabel = class extends LabelGraphics { + constructor(label) { + super(label); + this.label = label; + this.material = new StandardMaterial(); + this.canvasText = new CanvasText(); + this.entity = new Entity( + "label-internal", + label.getScene().getGraphicsAdapter().getPlayCanvasApp() + ); + this.entity[MELEMENT_PROPERTY_NAME] = label; + this.renderComponent = this.entity.addComponent("render", { + type: "plane", + material: this.material, + castShadows: this.label.props.castShadows + }); + this.entity.rotate(90, 0, 0); + this.entity.addComponent("collision", { + type: "box", + halfExtents: new Vec3(0.5, 0, 0.5) + }); + label.getContainer().addChild(this.entity); + } + disable() { + } + enable() { + } + getCollisionElement() { + return this.entity; + } + updateSize(mLabelProps) { + this.entity.setLocalScale(mLabelProps.width, 1, mLabelProps.height); + if (this.entity.collision) { + this.entity.collision.halfExtents.set(mLabelProps.width / 2, 0, mLabelProps.height / 2); + this.entity.collision.onSetHalfExtents(); + } + } + setWidth(width, mLabelProps) { + this.updateSize(mLabelProps); + this.redrawText(); + } + setHeight(height, mLabelProps) { + this.updateSize(mLabelProps); + this.redrawText(); + } + setContent() { + this.redrawText(); + } + setAlignment() { + this.redrawText(); + } + setFontSize() { + this.redrawText(); + } + setPadding() { + this.redrawText(); + } + setColor() { + this.redrawText(); + } + setFontColor() { + this.redrawText(); + } + setEmissive() { + this.updateMaterialEmissiveIntensity(); + } + updateMaterialEmissiveIntensity() { + if (this.label.props.emissive) { + this.material.emissiveMap = this.material.diffuseMap; + this.material.emissiveIntensity = this.label.props.emissive; + } else { + this.material.emissiveMap = null; + this.material.emissiveIntensity = 0; + } + this.material.update(); + } + redrawText() { + if (!this.material) { + return; + } + const canvas = this.canvasText.renderText(this.label.props.content, { + bold: true, + fontSize: this.label.props.fontSize * 2, + paddingPx: this.label.props.padding, + textColorRGB255A1: { + r: this.label.props.fontColor.r * 255, + g: this.label.props.fontColor.g * 255, + b: this.label.props.fontColor.b * 255, + a: this.label.props.fontColor.a ?? 1 + }, + backgroundColorRGB255A1: { + r: this.label.props.color.r * 255, + g: this.label.props.color.g * 255, + b: this.label.props.color.b * 255, + a: this.label.props.color.a ?? 1 + }, + dimensions: { + width: this.label.props.width * 200, + height: this.label.props.height * 200 + }, + alignment: this.label.props.alignment + }); + const texture = new Texture( + this.label.getScene().getGraphicsAdapter().getPlayCanvasApp().graphicsDevice, + { + width: canvas.width, + height: canvas.height + } + ); + texture.setSource(canvas); + this.material.diffuseMap = texture; + if ((this.label.props.color.a ?? 1) < 1) { + this.material.blendType = BLEND_NORMAL; + this.material.opacityMap = texture; + } else { + this.material.blendType = BLEND_NONE; + this.material.opacityMap = null; + } + this.material.update(); + this.updateMaterialEmissiveIntensity(); + texture.destroy(); + } + setCastShadows(castShadows) { + this.renderComponent.castShadows = castShadows; + } + dispose() { + this.entity.destroy(); + } +}; +var lightIntensityFactor = 1 / 100; +var lightLuminanceFactor = 4e3; +var PlayCanvasLight = class extends LightGraphics { + constructor(light) { + super(light); + this.light = light; + this.createLight(); + } + createLight() { + const lightEntity = this.light.getContainer(); + if (this.lightComponent) { + lightEntity.removeComponent("light"); + } + const { r, g, b } = this.light.props.color; + if (this.light.props.type === "spotlight") { + this.lightComponent = lightEntity.addComponent("light", { + type: "spot", + luminance: this.light.props.intensity * lightLuminanceFactor, + intensity: this.light.props.intensity * lightIntensityFactor, + castShadows: this.light.props.castShadows, + color: new Color(r, g, b), + shadowBias: 1e-3, + normalOffsetBias: 1e-3, + shape: LIGHTSHAPE_DISK, + innerConeAngle: this.light.props.angleDeg, + outerConeAngle: this.light.props.angleDeg, + range: this.light.props.distance ?? 100, + falloffMode: LIGHTFALLOFF_INVERSESQUARED, + enabled: this.light.props.enabled + }); + } else { + this.lightComponent = lightEntity.addComponent("light", { + type: "point", + luminance: this.light.props.intensity * lightLuminanceFactor, + intensity: this.light.props.intensity * lightIntensityFactor, + castShadows: this.light.props.castShadows, + color: new Color(r, g, b), + shadowBias: 1e-3, + normalOffsetBias: 1e-3, + range: this.light.props.distance ?? 100, + falloffMode: LIGHTFALLOFF_INVERSESQUARED, + enabled: this.light.props.enabled + }); + } + } + disable() { + } + enable() { + } + setEnabled(enabled) { + this.lightComponent.enabled = enabled; + } + setCastShadows(castShadows) { + this.lightComponent.castShadows = castShadows; + this.lightComponent.refreshProperties(); + } + setAngle(angle) { + if (this.lightComponent.type !== "spot") { + return; + } + this.lightComponent.innerConeAngle = angle; + this.lightComponent.outerConeAngle = angle; + this.lightComponent.refreshProperties(); + } + setIntensity(intensity) { + this.lightComponent.luminance = intensity * lightLuminanceFactor; + this.lightComponent.intensity = intensity * lightIntensityFactor; + this.lightComponent.refreshProperties(); + } + setDistance(distance) { + this.lightComponent.range = distance ?? 100; + this.lightComponent.refreshProperties(); + } + setType() { + this.createLight(); + } + setDebug() { + } + setColor(color) { + this.lightComponent.color.set(color.r, color.g, color.b); + this.lightComponent.refreshProperties(); + } + dispose() { + const lightEntity = this.light.getContainer(); + lightEntity.removeComponent("light"); + } +}; +var PlayCanvasLink = class extends LinkGraphics { + constructor(link) { + super(link); + this.link = link; + } + disable() { + } + enable() { + } + setHref() { + } + setTarget() { + } + dispose() { + } +}; +var PlayCanvasMElement = class extends MElementGraphics { + constructor(element) { + super(element); + this.element = element; + this.currentParentContainer = null; + this.container = new Entity( + element.constructor.name, + element.getScene().getGraphicsAdapter().getPlayCanvasApp() + ); + this.container[MELEMENT_PROPERTY_NAME] = element; + if (this.currentParentContainer !== null) { + throw new Error("Already connected to a parent"); + } + const mElementParent = this.element.getMElementParent(); + if (mElementParent) { + this.currentParentContainer = mElementParent.getContainer(); + this.currentParentContainer.addChild(this.container); + return; + } + const scene2 = this.element.getScene(); + this.currentParentContainer = scene2.getRootContainer(); + this.currentParentContainer.addChild(this.container); + } + getContainer() { + return this.container; + } + dispose() { + if (this.currentParentContainer === null) { + throw new Error("Was not connected to a parent"); + } + this.currentParentContainer.removeChild(this.container); + this.currentParentContainer = null; + this.container.destroy(); + } +}; +var PlayCanvasModel = class extends ModelGraphics { + constructor(model, updateMeshCallback) { + super(model, updateMeshCallback); + this.model = model; + this.updateMeshCallback = updateMeshCallback; + this.srcLoadingInstanceManager = new LoadingInstanceManager(`${Model.tagName}.src`); + this.animLoadingInstanceManager = new LoadingInstanceManager(`${Model.tagName}.anim`); + this.latestSrcModelPromise = null; + this.debugMaterial = null; + this.latestAnimPromise = null; + this.documentTimeTickListener = null; + this.attachments = /* @__PURE__ */ new Map(); + this.registeredParentAttachment = null; + this.socketChildrenByBone = /* @__PURE__ */ new Map(); + this.debugBoundingBox = null; + this.loadedState = null; + this.animState = null; + } + getPlayCanvasApp() { + return this.model.getScene().getGraphicsAdapter().getPlayCanvasApp(); + } + hasLoadedModel() { + var _a; + return !!((_a = this.loadedState) == null ? void 0 : _a.renderEntity); + } + hasLoadedAnimation() { + var _a; + return !!((_a = this.animState) == null ? void 0 : _a.animAsset); + } + disable() { + } + enable() { + } + getCollisionElement() { + return this.model.getContainer(); + } + setDebug() { + this.updateDebugVisualisation(); + } + setCastShadows() { + } + registerAttachment(attachment) { + let animState = null; + if (this.animState) { + const attachmentLoadedState = attachment.modelGraphics.loadedState; + if (!attachmentLoadedState) { + throw new Error("Attachment must be loaded before registering"); + } + const playcanvasEntity = attachmentLoadedState.renderEntity; + const animComponent = playcanvasEntity.addComponent("anim", {}); + animComponent.assignAnimation("SingleAnimation", this.animState.animAsset.resource); + animState = { + animComponent + }; + } + this.attachments.set(attachment, animState); + } + unregisterAttachment(attachment) { + const animState = this.attachments.get(attachment); + if (animState) { + animState.animComponent.reset(); + animState.animComponent.unbind(); + animState.animComponent.entity.removeComponent("anim"); + } + this.attachments.delete(attachment); + } + getBoundingBox() { + if (this.loadedState) { + return { + centerOffset: this.loadedState.boundingBox.center, + size: this.loadedState.boundingBox.halfExtents + }; + } + return null; + } + setAnim(anim2) { + if (this.animState) { + if (this.animState.animComponent) { + this.animState.animComponent.reset(); + this.animState.animComponent.unbind(); + this.animState.animComponent.entity.removeComponent("anim"); + } + this.animState = null; + for (const [attachment, animState] of this.attachments) { + if (animState) { + animState.animComponent.reset(); + animState.animComponent.unbind(); + animState.animComponent.entity.removeComponent("anim"); + } + this.attachments.set(attachment, null); + } + } + if (!anim2) { + this.latestAnimPromise = null; + if (this.loadedState && !this.registeredParentAttachment) { + const parent = this.model.parentElement; + if (parent instanceof Model) { + this.registeredParentAttachment = parent; + parent.modelGraphics.registerAttachment(this.model); + } + } + return; + } + const animSrc = this.model.contentSrcToContentAddress(anim2); + const animPromise = this.asyncLoadAnimAsset(animSrc, (loaded, total) => { + this.animLoadingInstanceManager.setProgress(loaded / total); + }); + this.animLoadingInstanceManager.start(this.model.getLoadingProgressManager(), anim2); + this.latestAnimPromise = animPromise; + animPromise.then((asset2) => { + if (this.latestAnimPromise !== animPromise || !this.model.isConnected) { + return; + } + this.latestAnimPromise = null; + this.animState = { + animAsset: asset2, + animComponent: null + }; + this.connectAnimationToModel(); + for (const [attachment] of this.attachments) { + const playcanvasEntity = attachment.getContainer(); + const animComponent = playcanvasEntity.addComponent( + "anim", + {} + ); + animComponent.assignAnimation("SingleAnimation", this.animState.animAsset.resource); + const animState = { + animComponent + }; + this.attachments.set(attachment, animState); + } + if (!this.documentTimeTickListener) { + this.documentTimeTickListener = this.model.addDocumentTimeTickListener( + (documentTime) => { + this.updateAnimation(documentTime); + } + ); + } + this.animLoadingInstanceManager.finish(); + }).catch((err) => { + console.error("Error loading m-model.anim", err); + this.animLoadingInstanceManager.error(err); + }); + } + connectAnimationToModel() { + if (this.animState && this.loadedState) { + const playcanvasEntity = this.loadedState.renderEntity; + const animComponent = playcanvasEntity.addComponent("anim", {}); + animComponent.assignAnimation("SingleAnimation", this.animState.animAsset.resource); + this.animState.animComponent = animComponent; + } + } + registerSocketChild(child, socketName) { + let children = this.socketChildrenByBone.get(socketName); + if (!children) { + children = /* @__PURE__ */ new Set(); + this.socketChildrenByBone.set(socketName, children); + } + children.add(child); + if (this.loadedState) { + const bone = this.loadedState.bones.get(socketName); + if (bone) { + bone.addChild(child.getContainer()); + } else { + this.model.getContainer().addChild(child.getContainer()); + } + } + } + unregisterSocketChild(child, socketName, addToRoot = true) { + const socketChildren = this.socketChildrenByBone.get(socketName); + if (socketChildren) { + socketChildren.delete(child); + if (addToRoot) { + this.model.getContainer().addChild(child.getContainer()); + } + if (socketChildren.size === 0) { + this.socketChildrenByBone.delete(socketName); + } + } + } + setAnimEnabled() { + } + setAnimLoop() { + } + setAnimStartTime() { + } + setAnimPauseTime() { + } + transformed() { + var _a; + const scale2 = (_a = this.loadedState) == null ? void 0 : _a.renderEntity.getWorldTransform().getScale(); + if (scale2 && this.loadedState) { + if (Math.abs(this.loadedState.collisionWorldScale.x - scale2.x) > 1e-3 || Math.abs(this.loadedState.collisionWorldScale.y - scale2.y) > 1e-3 || Math.abs(this.loadedState.collisionWorldScale.z - scale2.z) > 1e-3) { + this.loadedState.collisionWorldScale = { x: scale2.x, y: scale2.y, z: scale2.z }; + const collisionComponent = this.loadedState.renderEntity.collision; + if (collisionComponent) { + for (const mesh of collisionComponent.data.render.meshes) { + const triMesh = collisionComponent.system._triMeshCache[mesh.id]; + if (triMesh) { + window.Ammo.destroy(triMesh); + delete collisionComponent.system._triMeshCache[mesh.id]; + } + } + collisionComponent.onSetModel(); + } + } + } + } + setSrc(src) { + const playcanvasEntity = this.model.getContainer(); + if (this.loadedState !== null) { + this.loadedState.renderEntity.remove(); + this.loadedState = null; + if (this.animState) { + this.animState.animComponent = null; + } + if (this.registeredParentAttachment) { + this.registeredParentAttachment.modelGraphics.unregisterAttachment( + this.model + ); + this.registeredParentAttachment = null; + } + this.updateMeshCallback(); + this.updateDebugVisualisation(); + } + if (!src) { + this.srcLoadingInstanceManager.abortIfLoading(); + this.socketChildrenByBone.forEach((children) => { + children.forEach((child) => { + this.model.getContainer().addChild(child.getContainer()); + }); + }); + this.updateMeshCallback(); + this.updateDebugVisualisation(); + return; + } + const contentSrc = this.model.contentSrcToContentAddress(src); + const srcModelPromise = this.asyncLoadSourceAsset(contentSrc, (loaded, total) => { + this.srcLoadingInstanceManager.setProgress(loaded / total); + }); + this.srcLoadingInstanceManager.start(this.model.getLoadingProgressManager(), contentSrc); + this.latestSrcModelPromise = srcModelPromise; + srcModelPromise.then((asset2) => { + if (this.latestSrcModelPromise !== srcModelPromise || !this.model.isConnected) { + return; + } + this.latestSrcModelPromise = null; + const renderEntity = asset2.resource.instantiateRenderEntity(); + let boundingBox = null; + const renders = renderEntity.findComponents("render"); + for (const render of renders) { + for (const meshInstance of render.meshInstances) { + if (boundingBox) { + boundingBox.add(meshInstance.aabb); + } else { + boundingBox = meshInstance.aabb.clone(); + } + } + render.entity.addComponent("collision", { + type: "mesh", + renderAsset: render.asset + }); + } + if (!boundingBox) { + boundingBox = new BoundingBox( + new Vec3(0, 0, 0), + new Vec3(0, 0, 0) + ); + } + boundingBox.halfExtents.mulScalar(2); + const bones = /* @__PURE__ */ new Map(); + renderEntity.forEach((node) => { + bones.set(node.name, node); + }); + this.loadedState = { + renderEntity, + boundingBox, + collisionWorldScale: { x: 1, y: 1, z: 1 }, + bones + }; + playcanvasEntity.addChild(renderEntity); + this.transformed(); + for (const [boneName, children] of this.socketChildrenByBone) { + const bone = bones.get(boneName); + if (bone) { + children.forEach((child) => { + bone.addChild(child.getContainer()); + }); + } + } + this.connectAnimationToModel(); + this.updateMeshCallback(); + const parent = this.model.parentElement; + if (parent instanceof Model) { + if (!this.latestAnimPromise && !this.animState) { + this.registeredParentAttachment = parent; + parent.modelGraphics.registerAttachment(this.model); + } + } + this.srcLoadingInstanceManager.finish(); + this.updateDebugVisualisation(); + }).catch((err) => { + console.error("Error loading m-model.src", err); + this.srcLoadingInstanceManager.error(err); + }); + } + updateDebugVisualisation() { + if (!this.model.props.debug) { + this.clearDebugVisualisation(); + } else { + if (!this.debugBoundingBox) { + const graphicsAdapter = this.model.getScene().getGraphicsAdapter(); + if (!this.debugMaterial) { + this.debugMaterial = new BasicMaterial(); + this.debugMaterial.color = new Color(1, 0, 0); + } + this.debugBoundingBox = createPlayCanvasDebugBoundingBox( + graphicsAdapter, + this.debugMaterial + ); + this.model.getContainer().addChild(this.debugBoundingBox); + } + if (this.loadedState) { + const boundingBox = this.loadedState.boundingBox; + this.debugBoundingBox.setLocalPosition(boundingBox.center); + this.debugBoundingBox.setLocalScale(boundingBox.halfExtents); + } else { + this.debugBoundingBox.setLocalScale(0, 0, 0); + } + } + } + clearDebugVisualisation() { + if (this.debugBoundingBox) { + this.debugBoundingBox.remove(); + this.debugBoundingBox = null; + } + if (this.debugMaterial) { + this.debugMaterial.destroy(); + this.debugMaterial = null; + } + } + async asyncLoadSourceAsset(url, onProgress) { + return new Promise((resolve, reject) => { + const rewrittenUrl = new URL(url); + rewrittenUrl.hash = Math.random().toString(10); + const asset2 = new Asset(url, "container", { url: rewrittenUrl.toString() }); + this.getPlayCanvasApp().assets.add(asset2); + this.getPlayCanvasApp().assets.load(asset2); + asset2.ready((asset22) => { + resolve(asset22); + }); + asset2.on("error", (err) => { + reject(err); + }); + }); + } + async asyncLoadAnimAsset(url, onProgress) { + return new Promise((resolve, reject) => { + const asset2 = new Asset(url, "animation", { url }); + this.getPlayCanvasApp().assets.add(asset2); + this.getPlayCanvasApp().assets.load(asset2); + asset2.ready((asset22) => { + resolve(asset22); + }); + asset2.on("error", (err) => { + reject(err); + }); + }); + } + dispose() { + var _a, _b; + if (this.documentTimeTickListener) { + this.documentTimeTickListener.remove(); + this.documentTimeTickListener = null; + } + if (this.registeredParentAttachment) { + (_b = (_a = this.registeredParentAttachment) == null ? void 0 : _a.modelGraphics) == null ? void 0 : _b.unregisterAttachment( + this.model + ); + this.registeredParentAttachment = null; + } + if (this.loadedState) { + this.loadedState.renderEntity.destroy(); + this.loadedState = null; + } + this.clearDebugVisualisation(); + this.animLoadingInstanceManager.dispose(); + this.srcLoadingInstanceManager.dispose(); + } + triggerSocketedChildrenTransformed() { + this.socketChildrenByBone.forEach((children) => { + children.forEach((child) => { + if (child instanceof TransformableElement) { + child.didUpdateTransformation(); + } + }); + }); + } + updateAnimation(docTimeMs) { + var _a; + let animationTimeMs = docTimeMs - this.model.props.animStartTime; + if (docTimeMs < this.model.props.animStartTime) { + animationTimeMs = 0; + } else if (this.model.props.animPauseTime !== null) { + if (docTimeMs > this.model.props.animPauseTime) { + animationTimeMs = this.model.props.animPauseTime - this.model.props.animStartTime; + } + } + const animComponent = (_a = this.animState) == null ? void 0 : _a.animComponent; + if (animComponent) { + if (!this.model.props.animEnabled) { + animComponent.playing = false; + this.triggerSocketedChildrenTransformed(); + } else { + animComponent.playing = true; + const clip = animComponent.baseLayer._controller._animEvaluator.clips[0]; + if (clip) { + clip.time = animationTimeMs / 1e3; + } + } + } + for (const [model, animState] of this.attachments) { + if (animState) { + animState.animComponent.playing = this.model.props.animEnabled; + const clip = animState.animComponent.baseLayer._controller._animEvaluator.clips[0]; + if (clip) { + clip.time = animationTimeMs / 1e3; + model.modelGraphics.triggerSocketedChildrenTransformed(); + } + } + } + this.triggerSocketedChildrenTransformed(); + } +}; +var PlayCanvasPlane = class extends PlaneGraphics { + constructor(plane) { + super(plane); + this.plane = plane; + this.material = new StandardMaterial(); + this.entity = new Entity( + "plane-internal", + plane.getScene().getGraphicsAdapter().getPlayCanvasApp() + ); + this.entity[MELEMENT_PROPERTY_NAME] = plane; + this.renderComponent = this.entity.addComponent("render", { + type: "plane", + material: this.material + }); + this.entity.rotate(90, 0, 0); + this.entity.addComponent("collision", { + type: "box", + halfExtents: new Vec3(0.5, 0, 0.5) + }); + plane.getContainer().addChild(this.entity); + } + disable() { + } + enable() { + } + getCollisionElement() { + return this.entity; + } + setColor(color) { + this.material.diffuse.set(color.r, color.g, color.b); + this.material.update(); + } + updateSize(mPlaneProps) { + this.entity.setLocalScale(mPlaneProps.width, 1, mPlaneProps.height); + if (this.entity.collision) { + this.entity.collision.halfExtents.set(mPlaneProps.width / 2, 0, mPlaneProps.height / 2); + this.entity.collision.onSetHalfExtents(); + } + } + setWidth(width, mPlaneProps) { + this.updateSize(mPlaneProps); + } + setHeight(height, mPlaneProps) { + this.updateSize(mPlaneProps); + } + setCastShadows(castShadows) { + this.renderComponent.castShadows = castShadows; + } + setOpacity(opacity) { + if (opacity === 1) { + this.material.blendType = BLEND_NONE; + } else { + this.material.blendType = BLEND_NORMAL; + } + this.material.opacity = opacity; + this.material.update(); + } + dispose() { + this.entity.destroy(); + } +}; +var PlayCanvasPositionProbe = class extends PositionProbeGraphics { + constructor(positionProbe) { + super(positionProbe); + this.positionProbe = positionProbe; + this.entity = null; + this.debugMaterial = null; + this.updateDebugVisualisation(); + } + disable() { + } + enable() { + } + setRange() { + this.updateDebugVisualisation(); + } + setDebug() { + this.updateDebugVisualisation(); + } + clearDebugVisualisation() { + if (this.entity) { + this.entity.destroy(); + this.entity = null; + } + if (this.debugMaterial) { + this.debugMaterial.destroy(); + this.debugMaterial = null; + } + } + updateDebugVisualisation() { + var _a; + if (!this.positionProbe.props.debug) { + this.clearDebugVisualisation(); + } else { + if (this.positionProbe.isConnected && !this.entity) { + this.entity = new Entity( + "position-probe-internal", + this.positionProbe.getScene().getGraphicsAdapter().getPlayCanvasApp() + ); + if (!this.debugMaterial) { + this.debugMaterial = new BasicMaterial(); + this.debugMaterial.color = new Color(0, 1, 0); + } + this.entity.addComponent("model", { + type: "sphere", + material: this.debugMaterial + }); + (_a = this.entity.model) == null ? void 0 : _a.model.meshInstances.forEach((mi) => { + mi.renderStyle = RENDERSTYLE_WIREFRAME; + mi.castShadow = false; + }); + this.positionProbe.getContainer().addChild(this.entity); + } + if (this.entity) { + this.entity.setLocalScale( + this.positionProbe.props.range * 2, + this.positionProbe.props.range * 2, + this.positionProbe.props.range * 2 + ); + } + } + } + dispose() { + this.clearDebugVisualisation(); + } +}; +var PlayCanvasPrompt = class extends PromptGraphics { + constructor(prompt) { + super(prompt); + this.prompt = prompt; + } + disable() { + } + enable() { + } + setMessage() { + } + setPlaceholder() { + } + setPrefill() { + } + setDebug() { + } + dispose() { + } +}; +function createReconnectingStatus(playCanvasApp) { + const canvas = new CanvasText().renderText("Reconnecting", { + bold: true, + fontSize: 32, + paddingPx: 10, + textColorRGB255A1: { + r: 255, + g: 0, + b: 0, + a: 1 + }, + backgroundColorRGB255A1: { + r: 255, + g: 255, + b: 255, + a: 1 + }, + alignment: "center" + }); + const texture = new Texture(playCanvasApp.graphicsDevice, { + width: canvas.width, + height: canvas.height + }); + texture.setSource(canvas); + const material = new StandardMaterial(); + material.useLighting = false; + material.emissiveMap = texture; + material.update(); + texture.destroy(); + const width = canvas.width; + const height = canvas.height; + return { material, width: width / 100, height: height / 100 }; +} +var reconnectingStatus = null; +function getPlayCanvasReconnectingStatus(playCanvasApp) { + if (!reconnectingStatus) { + reconnectingStatus = createReconnectingStatus(playCanvasApp); + } + return reconnectingStatus; +} +var PlayCanvasRemoteDocument = class extends RemoteDocumentGraphics { + constructor(element) { + super(element); + this.element = element; + this.statusUI = null; + } + showError(showError) { + if (!showError) { + if (this.statusUI !== null) { + this.element.getContainer().removeChild(this.statusUI); + this.statusUI = null; + } + } else { + if (this.statusUI === null) { + const playCanvasApp = this.element.getScene().getGraphicsAdapter().getPlayCanvasApp(); + this.statusUI = new Entity("label-internal", playCanvasApp); + this.statusUI.rotate(90, 0, 0); + const { material, width, height } = getPlayCanvasReconnectingStatus(playCanvasApp); + this.statusUI.addComponent("render", { + type: "plane", + material + }); + this.statusUI.setLocalScale(width, 1, height); + this.statusUI.setPosition(0, height / 2, 0); + this.element.getContainer().addChild(this.statusUI); + } + } + } + dispose() { + } +}; +var PlayCanvasSphere = class extends SphereGraphics { + constructor(sphere) { + super(sphere); + this.sphere = sphere; + this.material = new StandardMaterial(); + this.entity = new Entity( + "sphere-internal", + sphere.getScene().getGraphicsAdapter().getPlayCanvasApp() + ); + this.entity[MELEMENT_PROPERTY_NAME] = sphere; + this.renderComponent = this.entity.addComponent("render", { + type: "sphere", + material: this.material + }); + this.entity.addComponent("collision", { + type: "sphere" + }); + if (this.entity.collision) { + this.entity.collision.radius = 1; + } + sphere.getContainer().addChild(this.entity); + } + disable() { + } + enable() { + } + getCollisionElement() { + return this.entity; + } + setColor(color) { + this.material.diffuse.set(color.r, color.g, color.b); + this.material.metalness = 0; + this.material.useMetalness = true; + this.material.update(); + } + updateSize(mSphereProps) { + this.entity.setLocalScale( + mSphereProps.radius * 2, + mSphereProps.radius * 2, + mSphereProps.radius * 2 + ); + if (this.entity.collision) { + this.entity.collision.radius = mSphereProps.radius; + this.entity.collision.onSetRadius(); + } + } + setRadius(radius, mSphereProps) { + this.updateSize(mSphereProps); + } + setCastShadows(castShadows) { + this.renderComponent.castShadows = castShadows; + } + setOpacity(opacity) { + if (opacity === 1) { + this.material.blendType = BLEND_NONE; + } else { + this.material.blendType = BLEND_NORMAL; + } + this.material.opacity = opacity; + this.material.update(); + } + dispose() { + this.entity.destroy(); + } +}; +var halfToRad = 0.5 * math.DEG_TO_RAD; +function xyzDegreesToQuaternion(x2, y2, z2) { + x2 *= halfToRad; + y2 *= halfToRad; + z2 *= halfToRad; + const cx = Math.cos(x2); + const cy = Math.cos(y2); + const cz = Math.cos(z2); + const sx = Math.sin(x2); + const sy = Math.sin(y2); + const sz = Math.sin(z2); + return [ + sx * cy * cz + cx * sy * sz, + // x + cx * sy * cz - sx * cy * sz, + // y + cx * cy * sz + sx * sy * cz, + // z + cx * cy * cz - sx * sy * sz + // w + ]; +} +var PlayCanvasTransformable = class extends TransformableGraphics { + constructor(transformableElement) { + super(transformableElement); + this.transformableElement = transformableElement; + this.socketName = null; + this.registeredSocketParent = null; + } + getWorldMatrix() { + return new Matr4(this.getPlayCanvasEntity().getWorldTransform().data); + } + setSocket(socketName) { + if (this.socketName !== socketName) { + if (this.socketName !== null && this.registeredSocketParent) { + this.registeredSocketParent.unregisterSocketChild( + this.transformableElement, + this.socketName + ); + } + this.socketName = socketName; + if (socketName !== null) { + this.registerWithParentModel(socketName); + } + } else { + this.socketName = socketName; + } + } + registerWithParentModel(socketName) { + var _a; + if ((_a = this.transformableElement.parentElement) == null ? void 0 : _a.isModel) { + const parentModel = this.transformableElement.parentElement; + this.registeredSocketParent = parentModel.modelGraphics; + this.registeredSocketParent.registerSocketChild(this.transformableElement, socketName); + } + } + setVisible(visible) { + this.getPlayCanvasEntity().enabled = visible; + } + updatePosition(x2, y2, z2) { + this.getPlayCanvasEntity().setLocalPosition(x2, y2, z2); + } + setX(x2, transformableElementProps) { + this.updatePosition( + transformableElementProps.x, + transformableElementProps.y, + transformableElementProps.z + ); + } + setY(y2, transformableElementProps) { + this.updatePosition( + transformableElementProps.x, + transformableElementProps.y, + transformableElementProps.z + ); + } + setZ(z2, transformableElementProps) { + this.updatePosition( + transformableElementProps.x, + transformableElementProps.y, + transformableElementProps.z + ); + } + getPlayCanvasEntity() { + return this.transformableElement.getContainer(); + } + updateRotation(rx, ry, rz) { + this.getPlayCanvasEntity().setLocalRotation(...xyzDegreesToQuaternion(rx, ry, rz)); + } + setRotationX(rotationX, transformableElementProps) { + this.updateRotation( + transformableElementProps.rx, + transformableElementProps.ry, + transformableElementProps.rz + ); + } + setRotationY(rotationY, transformableElementProps) { + this.updateRotation( + transformableElementProps.rx, + transformableElementProps.ry, + transformableElementProps.rz + ); + } + setRotationZ(rotationZ, transformableElementProps) { + this.updateRotation( + transformableElementProps.rx, + transformableElementProps.ry, + transformableElementProps.rz + ); + } + updateScale(sx, sy, sz) { + this.getPlayCanvasEntity().setLocalScale(sx, sy, sz); + } + setScaleX(scaleX, transformableElementProps) { + this.updateScale( + transformableElementProps.sx, + transformableElementProps.sy, + transformableElementProps.sz + ); + } + setScaleY(scaleY, transformableElementProps) { + this.updateScale( + transformableElementProps.sx, + transformableElementProps.sy, + transformableElementProps.sz + ); + } + setScaleZ(scaleZ, transformableElementProps) { + this.updateScale( + transformableElementProps.sx, + transformableElementProps.sy, + transformableElementProps.sz + ); + } + dispose() { + if (this.socketName && this.registeredSocketParent !== null) { + this.registeredSocketParent.unregisterSocketChild( + this.transformableElement, + this.socketName, + false + ); + } + } +}; +var audioRefDistance = 1; +var audioRolloffFactor = 1; +var PlayCanvasVideo = class extends VideoGraphics { + constructor(video, updateMeshCallback) { + super(video, updateMeshCallback); + this.video = video; + this.updateMeshCallback = updateMeshCallback; + this.videoSource = null; + this.videoMaterial = new StandardMaterial(); + this.disabledVideoMaterial = new StandardMaterial(); + this.loadedVideoState = null; + this.eventCollection = new EventHandlerCollection(); + this.disabledVideoMaterial.diffuse = new Color(0, 0, 0); + this.documentTimeTickListener = this.video.addDocumentTimeTickListener(() => { + this.tick(); + }); + this.eventCollection.add(this.getAudioContext(), "statechange", () => { + this.syncVideoTime(); + }); + this.entity = new Entity( + "video-internal", + video.getScene().getGraphicsAdapter().getPlayCanvasApp() + ); + this.entity[MELEMENT_PROPERTY_NAME] = video; + const { model, meshInstance } = createPlaneModel( + this.video.getScene().getGraphicsAdapter().getPlayCanvasApp(), + this.disabledVideoMaterial + ); + this.modelComponent = this.entity.addComponent("model", {}); + this.modelComponent.model = model; + this.meshInstance = meshInstance; + this.entity.addComponent("collision", { + type: "box", + halfExtents: new Vec3(0.5, 0, 0.5) + }); + video.getContainer().addChild(this.entity); + } + getPlayCanvasApp() { + return this.video.getScene().getGraphicsAdapter().getPlayCanvasApp(); + } + getWidthAndHeight() { + return { + width: this.entity.getLocalScale().x, + height: this.entity.getLocalScale().y + }; + } + getAudioContext() { + const playcanvasApp = this.getPlayCanvasApp(); + const soundSystem = playcanvasApp.systems.sound; + if (!soundSystem) { + throw new Error("Playcanvas sound system not enabled"); + } + return soundSystem.context; + } + syncVideoTime() { + if (this.loadedVideoState) { + const videoTag = this.loadedVideoState.video; + if (videoTag.readyState === 0) { + return; + } + const audioContext = this.getAudioContext(); + if (audioContext.state === "running") { + videoTag.muted = false; + } + if (this.video.isDisabled()) { + videoTag.muted = true; + } + if (this.videoSource) { + this.videoSource.syncVideoSource(this.video.props); + } + } + } + enable() { + this.updateVideo(); + } + disable() { + this.updateVideo(); + } + setSrc() { + this.updateVideo(); + } + setWidth() { + this.updateWidthAndHeight(); + } + setHeight() { + this.updateWidthAndHeight(); + } + setEnabled() { + this.updateVideo(); + } + setCastShadows() { + this.updateVideo(); + } + setLoop() { + this.updateVideo(); + } + setVolume() { + var _a; + if ((_a = this.loadedVideoState) == null ? void 0 : _a.audio) { + this.loadedVideoState.audio.gainNode.gain.value = this.video.props.volume; + } + } + setEmissive() { + this.updateMaterialEmissiveIntensity(); + } + setStartTime() { + this.updateVideo(); + } + setPauseTime() { + this.updateVideo(); + } + updateVideo() { + if (!this.video.isConnected) { + return; + } + if (!this.video.props.enabled) { + this.clearSource(); + return; + } + if (!this.video.props.src) { + this.clearSource(); + } else { + const contentAddress = this.video.contentSrcToContentAddress(this.video.props.src); + if (this.videoSource === null || this.videoSource.getContentAddress() !== contentAddress) { + this.clearSource(); + const video = document.createElement("video"); + video.playsInline = true; + video.muted = true; + video.autoplay = true; + video.crossOrigin = "anonymous"; + const videoLoadEventCollection = new EventHandlerCollection(); + this.loadedVideoState = { + video, + videoLoadEventCollection, + videoTexture: null, + audio: null + }; + video.loop = this.video.props.loop; + const url = new URL(contentAddress); + if (WHEPVideoSource.isWHEPURL(url)) { + this.videoSource = new WHEPVideoSource(url, video); + } else { + this.videoSource = new StaticFileVideoSource(url, video, this.video.props, () => { + return this.video.getDocumentTime(); + }); + } + videoLoadEventCollection.add(video, "loadeddata", () => { + if (!this.loadedVideoState || this.loadedVideoState.video !== video) { + return; + } + this.loadedVideoState.videoTexture = new Texture( + this.getPlayCanvasApp().graphicsDevice, + { + format: PIXELFORMAT_R8_G8_B8, + mipmaps: false, + width: video.videoWidth, + height: video.videoHeight + } + ); + this.loadedVideoState.videoTexture.setSource(this.loadedVideoState.video); + this.videoMaterial.diffuseMap = this.loadedVideoState.videoTexture; + this.videoMaterial.update(); + this.meshInstance.material = this.videoMaterial; + this.syncVideoTime(); + this.updateWidthAndHeight(); + this.updateMaterialEmissiveIntensity(); + const audioContext = this.getAudioContext(); + const pos = this.entity.getPosition(); + const orientationX = 1; + const orientationY = 0; + const orientationZ = 0; + const panner = new PannerNode(audioContext, { + panningModel: "HRTF", + distanceModel: "inverse", + positionX: pos.x, + positionY: pos.y, + positionZ: pos.z, + orientationX, + orientationY, + orientationZ, + refDistance: audioRefDistance, + rolloffFactor: audioRolloffFactor + }); + const gainNode = audioContext.createGain(); + gainNode.gain.value = this.video.props.volume; + const stereoPanner = new StereoPannerNode(audioContext, { pan: 0 }); + const audioNode = audioContext.createMediaElementSource(video); + audioNode.connect(gainNode).connect(stereoPanner).connect(panner).connect(audioContext.destination); + this.loadedVideoState.audio = { gainNode, audioNode, panner }; + }); + } + } + if (this.videoSource) { + this.syncVideoTime(); + } + } + tick() { + var _a, _b; + const videoTexture = (_a = this.loadedVideoState) == null ? void 0 : _a.videoTexture; + if (videoTexture) { + videoTexture.upload(); + } + const audio2 = (_b = this.loadedVideoState) == null ? void 0 : _b.audio; + if (audio2) { + const pos = this.entity.getPosition(); + const rotation2 = this.entity.getEulerAngles(); + audio2.panner.positionX.value = pos.x; + audio2.panner.positionY.value = pos.y; + audio2.panner.positionZ.value = pos.z; + audio2.panner.orientationX.value = Math.cos(rotation2.y); + audio2.panner.orientationY.value = 0; + audio2.panner.orientationZ.value = Math.sin(rotation2.y); + } + } + clearSource() { + if (this.videoSource) { + this.videoSource.dispose(); + this.videoSource = null; + } + if (this.loadedVideoState) { + const tag = this.loadedVideoState.video; + tag.pause(); + tag.src = ""; + tag.load(); + if (this.loadedVideoState.audio) { + this.loadedVideoState.audio.audioNode.disconnect(); + this.loadedVideoState.audio = null; + } + if (this.loadedVideoState.videoTexture) { + this.loadedVideoState.videoTexture.destroy(); + this.loadedVideoState.videoTexture = null; + } + this.loadedVideoState.videoLoadEventCollection.clear(); + this.loadedVideoState = null; + this.meshInstance.material = this.disabledVideoMaterial; + this.updateWidthAndHeight(); + } + } + updateMaterialEmissiveIntensity() { + var _a; + if (((_a = this.loadedVideoState) == null ? void 0 : _a.videoTexture) && this.video.props.emissive) { + this.videoMaterial.emissiveMap = this.loadedVideoState.videoTexture; + this.videoMaterial.emissiveIntensity = this.video.props.emissive; + } else { + this.videoMaterial.emissiveMap = null; + this.videoMaterial.emissiveIntensity = 0; + } + this.videoMaterial.update(); + } + dispose() { + this.clearSource(); + this.documentTimeTickListener.remove(); + this.eventCollection.clear(); + this.entity.destroy(); + } + getCollisionElement() { + return this.entity; + } + updateWidthAndHeight() { + const { width, height } = calculateContentSize({ + content: this.loadedVideoState ? { + width: this.loadedVideoState.video.videoWidth, + height: this.loadedVideoState.video.videoHeight + } : void 0, + width: this.video.props.width, + height: this.video.props.height + }); + this.entity.setLocalScale(width, height, 1); + if (this.entity.collision) { + this.entity.collision.halfExtents.set(width / 2, height / 2, 0); + this.entity.collision.onSetHalfExtents(); + } + this.updateMeshCallback(); + } +}; +var PlayCanvasGraphicsInterface = { + MElementGraphicsInterface: (element) => new PlayCanvasMElement(element), + MMLDebugHelperGraphicsInterface: (debugHelper) => new PlayCanvasDebugHelper(debugHelper), + MMLAudioGraphicsInterface: (element) => new PlayCanvasAudio(element), + MMLChatProbeGraphicsInterface: (element) => new PlayCanvasChatProbe(element), + MMLCubeGraphicsInterface: (element) => new PlayCanvasCube(element), + MMLCylinderGraphicsInterface: (element) => new PlayCanvasCylinder(element), + MMLFrameGraphicsInterface: (element) => new PlayCanvasFrame(element), + MMLImageGraphicsInterface: (element, updateMeshCallback) => new PlayCanvasImage(element, updateMeshCallback), + MMLInteractionGraphicsInterface: (element) => new PlayCanvasInteraction(element), + MMLLabelGraphicsInterface: (element) => new PlayCanvasLabel(element), + MMLLightGraphicsInterface: (element) => new PlayCanvasLight(element), + MMLLinkGraphicsInterface: (element) => new PlayCanvasLink(element), + MMLModelGraphicsInterface: (element, updateMeshCallback) => new PlayCanvasModel(element, updateMeshCallback), + MMLPlaneGraphicsInterface: (element) => new PlayCanvasPlane(element), + MMLPositionProbeGraphicsInterface: (element) => new PlayCanvasPositionProbe(element), + MMLPromptGraphicsInterface: (element) => new PlayCanvasPrompt(element), + MMLSphereGraphicsInterface: (element) => new PlayCanvasSphere(element), + MMLTransformableGraphicsInterface: (element) => new PlayCanvasTransformable(element), + MMLVideoGraphicsInterface: (element, updateMeshCallback) => new PlayCanvasVideo(element, updateMeshCallback), + RemoteDocumentGraphicsInterface: (element) => new PlayCanvasRemoteDocument(element) +}; +var PlayCanvasInteractionAdapter = class _PlayCanvasInteractionAdapter { + static interactionShouldShowDistance(interaction, cameraEntity, cameraComponent, app2) { + const worldPos = interaction.getContainer().getPosition(); + const cameraPos = cameraEntity.getPosition(); + const distance = cameraPos.distance(worldPos); + if (distance > interaction.props.range) { + return null; + } + if (interaction.props.inFocus) { + if (!cameraComponent.frustum.containsPoint(worldPos)) { + return null; + } + } + if (interaction.props.lineOfSight) { + const rigidbodySystem = app2.systems.rigidbody; + if (!rigidbodySystem) { + console.warn("Rigidbody system not found. Line of sight check will not work."); + } else { + const raycastResults = rigidbodySystem.raycastAll(cameraPos, worldPos); + if (raycastResults.length > 0) { + for (const result of raycastResults) { + if (!_PlayCanvasInteractionAdapter.hasAncestor(result.entity, interaction.getContainer())) { + return null; + } + } + } + } + } + return distance; + } + static hasAncestor(object, ancestor) { + let parent = object.parent; + while (parent !== null) { + if (parent === ancestor) { + return true; + } + parent = parent.parent; + } + return false; + } +}; + +// ../../node_modules/@mml-io/mml-web-playcanvas-standalone/build/index.js +var up2 = { x: 0, y: 1, z: 0 }; +var right = { x: 1, y: 0, z: 0 }; +var quaternion = new Quat(); +var qPitch = new Quat(); +var qYaw = new Quat(); +var PlayCanvasDragFlyCameraControls = class { + constructor(camera, domElement, speed = 15) { + this.type = "drag-fly"; + this.enabled = false; + this.yaw = 0; + this.pitch = 0; + this.forward = false; + this.backward = false; + this.left = false; + this.right = false; + this.up = false; + this.down = false; + this.minPolarAngle = 0 * (Math.PI / 180); + this.maxPolarAngle = 180 * (Math.PI / 180); + this.invertedMouseY = false; + this.eventHandlerCollection = new EventHandlerCollection(); + this.mouseDown = false; + this.camera = camera; + this.domElement = domElement; + this.domElement.style.userSelect = "none"; + this.speed = speed; + } + fitContent(boundingBox) { + var _a, _b; + const center2 = { + x: (boundingBox.min.x + boundingBox.max.x) / 2, + y: (boundingBox.min.y + boundingBox.max.y) / 2, + z: (boundingBox.min.z + boundingBox.max.z) / 2 + }; + const size = { + x: boundingBox.max.x - boundingBox.min.x, + y: boundingBox.max.y - boundingBox.min.y, + z: boundingBox.max.z - boundingBox.min.z + }; + const fov = ((_b = (_a = this.camera) == null ? void 0 : _a.camera) == null ? void 0 : _b.fov) || 1; + const maximumDimension = Math.max(size.x, size.y, size.z); + const distance = Math.abs(maximumDimension / 4 / Math.tan(fov / 2)); + const currentCameraRay = this.camera.forward.clone().normalize(); + currentCameraRay.mulScalar(-distance); + this.camera.setLocalPosition( + center2.x + currentCameraRay.x, + center2.y + currentCameraRay.y, + center2.z + currentCameraRay.z + ); + this.setLookAt(center2.x, center2.y, center2.z); + } + enable() { + if (this.enabled) { + return; + } + this.enabled = true; + this.eventHandlerCollection.add(document, "keydown", this.onKeyDown.bind(this)); + this.eventHandlerCollection.add(document, "keyup", this.onKeyUp.bind(this)); + this.eventHandlerCollection.add(window, "blur", this.onBlur.bind(this)); + this.eventHandlerCollection.add(document, "mousemove", this.onMouseMove.bind(this)); + this.eventHandlerCollection.add(this.domElement, "mousedown", this.onMouseDown.bind(this)); + this.eventHandlerCollection.add(document, "mouseup", this.onMouseUp.bind(this)); + this.eventHandlerCollection.add(document, "wheel", this.onMouseWheel.bind(this)); + } + disable() { + if (!this.enabled) { + return; + } + this.eventHandlerCollection.clear(); + this.enabled = false; + } + setInvert(invert) { + this.invertedMouseY = invert; + } + dispose() { + this.disable(); + } + setCameraPosition(x2, y2, z2) { + this.camera.setLocalPosition(x2, y2, z2); + } + setLookAt(x2, y2, z2) { + this.camera.lookAt(x2, y2, z2); + const { yaw, pitch } = getYawPitchFromQuaternion(this.camera.getRotation()); + this.yaw = yaw; + this.pitch = pitch; + this.updateCameraFromYawAndPitch(); + } + update(dt) { + if (!this.mouseDown) { + return; + } + this.camera.translateLocal( + (Number(this.right) - Number(this.left)) * dt * 30, + (Number(this.up) - Number(this.down)) * dt * 30, + (Number(this.backward) - Number(this.forward)) * dt * 30 + ); + } + onKeyDown(event) { + if (!this.mouseDown) { + return; + } + switch (event.code) { + case "ArrowUp": + case "KeyW": + this.forward = true; + break; + case "ArrowLeft": + case "KeyA": + this.left = true; + break; + case "ArrowDown": + case "KeyS": + this.backward = true; + break; + case "ArrowRight": + case "KeyD": + this.right = true; + break; + case "Space": + this.up = true; + break; + case "ShiftLeft": + this.down = true; + break; + } + event.preventDefault(); + } + onKeyUp(event) { + switch (event.code) { + case "ArrowUp": + case "KeyW": + this.forward = false; + break; + case "ArrowLeft": + case "KeyA": + this.left = false; + break; + case "ArrowDown": + case "KeyS": + this.backward = false; + break; + case "ArrowRight": + case "KeyD": + this.right = false; + break; + case "Space": + this.up = false; + break; + case "ShiftLeft": + this.down = false; + break; + } + } + onBlur() { + this.mouseDown = false; + this.forward = false; + this.left = false; + this.backward = false; + this.right = false; + this.up = false; + this.down = false; + } + onMouseDown() { + this.mouseDown = true; + } + onMouseMove(event) { + if (!this.mouseDown) { + return; + } + const movementX = event.movementX; + let movementY = event.movementY; + if (this.invertedMouseY) { + movementY *= -1; + } + this.yaw += movementX * -2e-3; + this.pitch += movementY * -2e-3; + this.updateCameraFromYawAndPitch(); + } + updateCameraFromYawAndPitch() { + this.yaw = this.yaw % (Math.PI * 2); + this.pitch = this.pitch % (Math.PI * 2); + this.pitch = Math.max( + Math.PI / 2 - this.maxPolarAngle, + Math.min(Math.PI / 2 - this.minPolarAngle, this.pitch) + ); + qPitch.setFromAxisAngle(right, this.pitch); + qYaw.setFromAxisAngle(up2, this.yaw); + quaternion.set(0, 0, 0, 1); + quaternion.multiply(qYaw); + quaternion.multiply(qPitch); + this.camera.setLocalRotation(quaternion.x, quaternion.y, quaternion.z, quaternion.w); + } + onMouseUp() { + this.mouseDown = false; + } + onMouseWheel(event) { + if (!this.mouseDown) { + return; + } + this.speed -= event.deltaY * 0.1; + this.speed = Math.max(5, Math.min(this.speed, 1e3)); + } +}; +function clamp(value, min, max) { + return Math.max(min, Math.min(max, value)); +} +function getYawPitchFromQuaternion(quaternion2) { + const matr4 = new Matr4(); + matr4.setRotationFromQuaternion(quaternion2); + const d = matr4.data; + const m11 = d[0]; + const m13 = d[8]; + const m23 = d[9]; + const m31 = d[2]; + const m33 = d[10]; + const yaw = Math.abs(m23) < 0.9999999 ? Math.atan2(m13, m33) : Math.atan2(-m31, m11); + const pitch = Math.asin(-clamp(m23, -1, 1)); + return { yaw, pitch }; +} +var PlayCanvasOrbitCameraControls = class { + constructor(camera, domElement, distance = 15) { + this.camera = camera; + this.domElement = domElement; + this.distance = distance; + this.type = "orbit"; + this.enabled = false; + this.degreesPerSecond = 10; + this.yaw = 0; + this.pitch = Math.PI * 0.4; + this.minPolarAngle = -89.9999 * (Math.PI / 180); + this.maxPolarAngle = 89.9999 * (Math.PI / 180); + this.invertedMouseY = false; + this.eventHandlerCollection = new EventHandlerCollection(); + this.mouseDown = false; + this.cameraLookAt = new Vect3(); + this.domElement.style.userSelect = "none"; + } + fitContent(boundingBox) { + var _a, _b; + const center2 = { + x: (boundingBox.min.x + boundingBox.max.x) / 2, + y: (boundingBox.min.y + boundingBox.max.y) / 2, + z: (boundingBox.min.z + boundingBox.max.z) / 2 + }; + const size = { + x: boundingBox.max.x - boundingBox.min.x, + y: boundingBox.max.y - boundingBox.min.y, + z: boundingBox.max.z - boundingBox.min.z + }; + const fov = ((_b = (_a = this.camera) == null ? void 0 : _a.camera) == null ? void 0 : _b.fov) || 1; + const maximumDimension = Math.max(size.x, size.y, size.z); + this.distance = Math.abs(maximumDimension / 4 / Math.tan(fov / 2)); + this.setLookAt(center2.x, center2.y, center2.z); + this.update(); + } + enable() { + if (this.enabled) { + return; + } + this.enabled = true; + this.eventHandlerCollection.add(window, "blur", this.onBlur.bind(this)); + this.eventHandlerCollection.add(document, "mousemove", this.onMouseMove.bind(this)); + this.eventHandlerCollection.add(this.domElement, "mousedown", this.onMouseDown.bind(this)); + this.eventHandlerCollection.add(document, "mouseup", this.onMouseUp.bind(this)); + this.eventHandlerCollection.add(document, "wheel", this.onMouseWheel.bind(this)); + } + disable() { + if (!this.enabled) { + return; + } + this.eventHandlerCollection.clear(); + this.enabled = false; + } + setInvert(invert) { + this.invertedMouseY = invert; + } + dispose() { + this.disable(); + } + getBaseYaw() { + return -(Date.now() / 1e3 * this.degreesPerSecond) % 360 * (Math.PI / 180); + } + update() { + const baseYaw = this.getBaseYaw(); + const yaw = baseYaw + this.yaw; + const sinPhiRadius = Math.sin(this.pitch) * this.distance; + const x2 = sinPhiRadius * Math.sin(yaw); + const y2 = Math.cos(this.pitch) * this.distance; + const z2 = sinPhiRadius * Math.cos(yaw); + this.camera.setPosition(x2, y2, z2); + this.camera.translate(this.cameraLookAt.x, this.cameraLookAt.y, this.cameraLookAt.z); + this.camera.lookAt(this.cameraLookAt.x, this.cameraLookAt.y, this.cameraLookAt.z); + } + onBlur() { + this.mouseDown = false; + } + onMouseDown() { + this.mouseDown = true; + } + setDegreesPerSecond(degreesPerSecond) { + this.degreesPerSecond = degreesPerSecond; + } + setLookAt(x2, y2, z2) { + this.cameraLookAt.set(x2, y2, z2); + } + setDistance(distance) { + this.distance = distance; + } + setPitchDegrees(pitch) { + this.pitch = pitch * (Math.PI / 180); + this.pitch = this.pitch % (Math.PI * 2); + } + onMouseMove(event) { + if (!this.mouseDown) { + return; + } + const movementX = event.movementX; + let movementY = event.movementY; + if (this.invertedMouseY) { + movementY *= -1; + } + this.yaw += movementX * -2e-3; + this.pitch += movementY * -2e-3; + this.yaw = this.yaw % (Math.PI * 2); + this.pitch = this.pitch % (Math.PI * 2); + this.pitch = Math.max( + Math.PI / 2 - this.maxPolarAngle, + Math.min(Math.PI / 2 - this.minPolarAngle, this.pitch) + ); + } + onMouseUp() { + this.mouseDown = false; + } + onMouseWheel(event) { + this.distance += event.deltaY * 0.1; + this.distance = Math.max(0.01, Math.min(this.distance, 1e3)); + } +}; +var ammo_wasm_default = "// This is ammo.js, a port of Bullet Physics to JavaScript. zlib licensed.

var Ammo = (function() {
    var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined;
    if (typeof __filename !== 'undefined')
      _scriptDir = _scriptDir || __filename;
    return (function(Ammo) {
        Ammo = Ammo || {};

        var b;
        b || (b = typeof Ammo !== 'undefined' ? Ammo : {});
        var aa = {}, ba;
        for (ba in b)
          b.hasOwnProperty(ba) && (aa[ba] = b[ba]);
        var ca = !1
          , da = !1
          , ea = !1
          , fa = !1;
        ca = "object" === typeof window;
        da = "function" === typeof importScripts;
        ea = "object" === typeof process && "object" === typeof process.versions && "string" === typeof process.versions.node;
        fa = !ca && !ea && !da;
        var ha = "", ja, ka, la, ma;
        if (ea)
          ha = da ? require("path").dirname(ha) + "/" : __dirname + "/",
            ja = function(a, c) {
              la || (la = require("fs"));
              ma || (ma = require("path"));
              a = ma.normalize(a);
              return la.readFileSync(a, c ? null : "utf8")
            }
            ,
            ka = function(a) {
              a = ja(a, !0);
              a.buffer || (a = new Uint8Array(a));
              assert(a.buffer);
              return a
            }
            ,
          1 < process.argv.length && process.argv[1].replace(/\\/g, "/"),
            process.argv.slice(2),
            process.on("uncaughtException", function(a) {
              throw a;
            }),
            process.on("unhandledRejection", na),
            b.inspect = function() {
              return "[Emscripten Module object]"
            }
          ;
        else if (fa)
          "undefined" != typeof read && (ja = function(a) {
              return read(a)
            }
          ),
            ka = function(a) {
              if ("function" === typeof readbuffer)
                return new Uint8Array(readbuffer(a));
              a = read(a, "binary");
              assert("object" === typeof a);
              return a
            }
            ,
          "undefined" !== typeof print && ("undefined" === typeof console && (console = {}),
            console.log = print,
            console.warn = console.error = "undefined" !== typeof printErr ? printErr : print);
        else if (ca || da)
          da ? ha = self.location.href : document.currentScript && (ha = document.currentScript.src),
          _scriptDir && (ha = _scriptDir),
            ha = 0 !== ha.indexOf("blob:") ? ha.substr(0, ha.lastIndexOf("/") + 1) : "",
            ja = function(a) {
              var c = new XMLHttpRequest;
              c.open("GET", a, !1);
              c.send(null);
              return c.responseText
            }
            ,
          da && (ka = function(a) {
              var c = new XMLHttpRequest;
              c.open("GET", a, !1);
              c.responseType = "arraybuffer";
              c.send(null);
              return new Uint8Array(c.response)
            }
          );
        var oa = b.print || console.log.bind(console)
          , pa = b.printErr || console.warn.bind(console);
        for (ba in aa)
          aa.hasOwnProperty(ba) && (b[ba] = aa[ba]);
        aa = null;
        var qa = [], ra, sa;
        b.wasmBinary && (sa = b.wasmBinary);
        var noExitRuntime;
        b.noExitRuntime && (noExitRuntime = b.noExitRuntime);
        "object" !== typeof WebAssembly && pa("no native wasm support detected");
        var ta, ua = new WebAssembly.Table({
          initial: 935,
          maximum: 955,
          element: "anyfunc"
        }), va = !1;
        function assert(a, c) {
          a || na("Assertion failed: " + c)
        }
        var wa = "undefined" !== typeof TextDecoder ? new TextDecoder("utf8") : void 0;
        function xa(a, c, d) {
          var e = c + d;
          for (d = c; a[d] && !(d >= e); )
            ++d;
          if (16 < d - c && a.subarray && wa)
            return wa.decode(a.subarray(c, d));
          for (e = ""; c < d; ) {
            var f = a[c++];
            if (f & 128) {
              var m = a[c++] & 63;
              if (192 == (f & 224))
                e += String.fromCharCode((f & 31) << 6 | m);
              else {
                var C = a[c++] & 63;
                f = 224 == (f & 240) ? (f & 15) << 12 | m << 6 | C : (f & 7) << 18 | m << 12 | C << 6 | a[c++] & 63;
                65536 > f ? e += String.fromCharCode(f) : (f -= 65536,
                  e += String.fromCharCode(55296 | f >> 10, 56320 | f & 1023))
              }
            } else
              e += String.fromCharCode(f)
          }
          return e
        }
        "undefined" !== typeof TextDecoder && new TextDecoder("utf-16le");
        var ya, za, Aa, Ba, Ca, Da, Ea = b.INITIAL_MEMORY || 67108864;
        if (ta = b.wasmMemory ? b.wasmMemory : new WebAssembly.Memory({
          initial: Ea / 65536,
          maximum: Ea / 65536
        }))
          ya = ta.buffer;
        Ea = ya.byteLength;
        var Fa = ya;
        ya = Fa;
        b.HEAP8 = za = new Int8Array(Fa);
        b.HEAP16 = new Int16Array(Fa);
        b.HEAP32 = Ba = new Int32Array(Fa);
        b.HEAPU8 = Aa = new Uint8Array(Fa);
        b.HEAPU16 = new Uint16Array(Fa);
        b.HEAPU32 = new Uint32Array(Fa);
        b.HEAPF32 = Ca = new Float32Array(Fa);
        b.HEAPF64 = Da = new Float64Array(Fa);
        Ba[8080] = 5275360;
        function Ga(a) {
          for (; 0 < a.length; ) {
            var c = a.shift();
            if ("function" == typeof c)
              c(b);
            else {
              var d = c.Ky;
              "number" === typeof d ? void 0 === c.vy ? b.dynCall_v(d) : b.dynCall_vi(d, c.vy) : d(void 0 === c.vy ? null : c.vy)
            }
          }
        }
        var Ha = []
          , Ia = []
          , Ja = []
          , Ka = []
          , La = !1;
        function Ma() {
          var a = b.preRun.shift();
          Ha.unshift(a)
        }
        var Na = 0
          , Oa = null
          , Pa = null;
        b.preloadedImages = {};
        b.preloadedAudios = {};
        function na(a) {
          if (b.onAbort)
            b.onAbort(a);
          a += "";
          oa(a);
          pa(a);
          va = !0;
          throw new WebAssembly.RuntimeError("abort(" + a + "). Build with -s ASSERTIONS=1 for more info.");
        }
        function Qa() {
          var a = Ra;
          return String.prototype.startsWith ? a.startsWith("data:application/octet-stream;base64,") : 0 === a.indexOf("data:application/octet-stream;base64,")
        }
        var Ra = "ammo.wasm.wasm";
        if (!Qa()) {
          var Sa = Ra;
          Ra = b.locateFile ? b.locateFile(Sa, ha) : ha + Sa
        }
        function Ta() {
          try {
            if (sa)
              return new Uint8Array(sa);
            if (ka)
              return ka(Ra);
            throw "both async and sync fetching of the wasm failed";
          } catch (a) {
            na(a)
          }
        }
        function Ua() {
          return sa || !ca && !da || "function" !== typeof fetch ? new Promise(function(a) {
              a(Ta())
            }
          ) : fetch(Ra, {
            credentials: "same-origin"
          }).then(function(a) {
            if (!a.ok)
              throw "failed to load wasm binary file at '" + Ra + "'";
            return a.arrayBuffer()
          }).catch(function() {
            return Ta()
          })
        }
        var Va = {
          1864: function(a, c, d, e, f, m, C, P) {
            a = b.getCache(b.ConcreteContactResultCallback)[a];
            if (!a.hasOwnProperty("addSingleResult"))
              throw "a JSImplementation must implement all functions, you forgot ConcreteContactResultCallback::addSingleResult.";
            return a.addSingleResult(c, d, e, f, m, C, P)
          },
          2424: function(a, c, d, e) {
            a = b.getCache(b.DebugDrawer)[a];
            if (!a.hasOwnProperty("drawLine"))
              throw "a JSImplementation must implement all functions, you forgot DebugDrawer::drawLine.";
            a.drawLine(c, d, e)
          },
          2649: function(a, c, d, e, f, m) {
            a = b.getCache(b.DebugDrawer)[a];
            if (!a.hasOwnProperty("drawContactPoint"))
              throw "a JSImplementation must implement all functions, you forgot DebugDrawer::drawContactPoint.";
            a.drawContactPoint(c, d, e, f, m)
          },
          2906: function(a, c) {
            a = b.getCache(b.DebugDrawer)[a];
            if (!a.hasOwnProperty("reportErrorWarning"))
              throw "a JSImplementation must implement all functions, you forgot DebugDrawer::reportErrorWarning.";
            a.reportErrorWarning(c)
          },
          3153: function(a, c, d) {
            a = b.getCache(b.DebugDrawer)[a];
            if (!a.hasOwnProperty("draw3dText"))
              throw "a JSImplementation must implement all functions, you forgot DebugDrawer::draw3dText.";
            a.draw3dText(c, d)
          },
          3380: function(a, c) {
            a = b.getCache(b.DebugDrawer)[a];
            if (!a.hasOwnProperty("setDebugMode"))
              throw "a JSImplementation must implement all functions, you forgot DebugDrawer::setDebugMode.";
            a.setDebugMode(c)
          },
          3606: function(a) {
            a = b.getCache(b.DebugDrawer)[a];
            if (!a.hasOwnProperty("getDebugMode"))
              throw "a JSImplementation must implement all functions, you forgot DebugDrawer::getDebugMode.";
            return a.getDebugMode()
          }
        };
        Ia.push({
          Ky: function() {
            Wa()
          }
        });
        var Xa = [null, [], []];
        function Ya(a, c) {
          Za || (Za = []);
          var d = Za;
          d.length = 0;
          for (var e; e = Aa[a++]; )
            100 === e || 102 === e ? (c = c + 7 & -8,
              d.push(Da[c >> 3]),
              c += 8) : (c = c + 3 & -4,
              d.push(Ba[c >> 2]),
              c += 4);
          return d
        }
        var Za, $a = {
          i: function() {
            na()
          },
          d: function(a, c, d) {
            c = Ya(c, d);
            return Va[a].apply(null, c)
          },
          a: function(a, c, d) {
            c = Ya(c, d);
            return Va[a].apply(null, c)
          },
          f: function(a, c, d) {
            Aa.copyWithin(a, c, c + d)
          },
          g: function() {
            na("OOM")
          },
          h: function() {
            return 0
          },
          e: function() {},
          c: function(a, c, d, e) {
            for (var f = 0, m = 0; m < d; m++) {
              for (var C = Ba[c + 8 * m >> 2], P = Ba[c + (8 * m + 4) >> 2], ia = 0; ia < P; ia++) {
                var nb = Aa[C + ia]
                  , Wb = Xa[a];
                0 === nb || 10 === nb ? ((1 === a ? oa : pa)(xa(Wb, 0)),
                  Wb.length = 0) : Wb.push(nb)
              }
              f += P
            }
            Ba[e >> 2] = f;
            return 0
          },
          b: function(a) {
            var c = Date.now();
            Ba[a >> 2] = c / 1E3 | 0;
            Ba[a + 4 >> 2] = c % 1E3 * 1E3 | 0;
            return 0
          },
          memory: ta,
          table: ua
        }, ab = function() {
          function a(f) {
            b.asm = f.exports;
            Na--;
            b.monitorRunDependencies && b.monitorRunDependencies(Na);
            0 == Na && (null !== Oa && (clearInterval(Oa),
              Oa = null),
            Pa && (f = Pa,
              Pa = null,
              f()))
          }
          function c(f) {
            a(f.instance)
          }
          function d(f) {
            return Ua().then(function(m) {
              return WebAssembly.instantiate(m, e)
            }).then(f, function(m) {
              pa("failed to asynchronously prepare wasm: " + m);
              na(m)
            })
          }
          var e = {
            a: $a
          };
          Na++;
          b.monitorRunDependencies && b.monitorRunDependencies(Na);
          if (b.instantiateWasm)
            try {
              return b.instantiateWasm(e, a)
            } catch (f) {
              return pa("Module.instantiateWasm callback failed with error: " + f),
                !1
            }
          (function() {
              if (sa || "function" !== typeof WebAssembly.instantiateStreaming || Qa() || "function" !== typeof fetch)
                return d(c);
              fetch(Ra, {
                credentials: "same-origin"
              }).then(function(f) {
                return WebAssembly.instantiateStreaming(f, e).then(c, function(m) {
                  pa("wasm streaming compile failed: " + m);
                  pa("falling back to ArrayBuffer instantiation");
                  d(c)
                })
              })
            }
          )();
          return {}
        }();
        b.asm = ab;
        var Wa = b.___wasm_call_ctors = function() {
            return (Wa = b.___wasm_call_ctors = b.asm.j).apply(null, arguments)
          }
          , bb = b._emscripten_bind_btCollisionWorld_getDispatcher_0 = function() {
            return (bb = b._emscripten_bind_btCollisionWorld_getDispatcher_0 = b.asm.k).apply(null, arguments)
          }
          , cb = b._emscripten_bind_btCollisionWorld_rayTest_3 = function() {
            return (cb = b._emscripten_bind_btCollisionWorld_rayTest_3 = b.asm.l).apply(null, arguments)
          }
          , db = b._emscripten_bind_btCollisionWorld_getPairCache_0 = function() {
            return (db = b._emscripten_bind_btCollisionWorld_getPairCache_0 = b.asm.m).apply(null, arguments)
          }
          , eb = b._emscripten_bind_btCollisionWorld_getDispatchInfo_0 = function() {
            return (eb = b._emscripten_bind_btCollisionWorld_getDispatchInfo_0 = b.asm.n).apply(null, arguments)
          }
          , fb = b._emscripten_bind_btCollisionWorld_addCollisionObject_1 = function() {
            return (fb = b._emscripten_bind_btCollisionWorld_addCollisionObject_1 = b.asm.o).apply(null, arguments)
          }
          , gb = b._emscripten_bind_btCollisionWorld_addCollisionObject_2 = function() {
            return (gb = b._emscripten_bind_btCollisionWorld_addCollisionObject_2 = b.asm.p).apply(null, arguments)
          }
          , hb = b._emscripten_bind_btCollisionWorld_addCollisionObject_3 = function() {
            return (hb = b._emscripten_bind_btCollisionWorld_addCollisionObject_3 = b.asm.q).apply(null, arguments)
          }
          , ib = b._emscripten_bind_btCollisionWorld_removeCollisionObject_1 = function() {
            return (ib = b._emscripten_bind_btCollisionWorld_removeCollisionObject_1 = b.asm.r).apply(null, arguments)
          }
          , jb = b._emscripten_bind_btCollisionWorld_getBroadphase_0 = function() {
            return (jb = b._emscripten_bind_btCollisionWorld_getBroadphase_0 = b.asm.s).apply(null, arguments)
          }
          , kb = b._emscripten_bind_btCollisionWorld_convexSweepTest_5 = function() {
            return (kb = b._emscripten_bind_btCollisionWorld_convexSweepTest_5 = b.asm.t).apply(null, arguments)
          }
          , lb = b._emscripten_bind_btCollisionWorld_contactPairTest_3 = function() {
            return (lb = b._emscripten_bind_btCollisionWorld_contactPairTest_3 = b.asm.u).apply(null, arguments)
          }
          , mb = b._emscripten_bind_btCollisionWorld_contactTest_2 = function() {
            return (mb = b._emscripten_bind_btCollisionWorld_contactTest_2 = b.asm.v).apply(null, arguments)
          }
          , ob = b._emscripten_bind_btCollisionWorld_updateSingleAabb_1 = function() {
            return (ob = b._emscripten_bind_btCollisionWorld_updateSingleAabb_1 = b.asm.w).apply(null, arguments)
          }
          , pb = b._emscripten_bind_btCollisionWorld_setDebugDrawer_1 = function() {
            return (pb = b._emscripten_bind_btCollisionWorld_setDebugDrawer_1 = b.asm.x).apply(null, arguments)
          }
          , qb = b._emscripten_bind_btCollisionWorld_getDebugDrawer_0 = function() {
            return (qb = b._emscripten_bind_btCollisionWorld_getDebugDrawer_0 = b.asm.y).apply(null, arguments)
          }
          , rb = b._emscripten_bind_btCollisionWorld_debugDrawWorld_0 = function() {
            return (rb = b._emscripten_bind_btCollisionWorld_debugDrawWorld_0 = b.asm.z).apply(null, arguments)
          }
          , sb = b._emscripten_bind_btCollisionWorld_debugDrawObject_3 = function() {
            return (sb = b._emscripten_bind_btCollisionWorld_debugDrawObject_3 = b.asm.A).apply(null, arguments)
          }
          , tb = b._emscripten_bind_btCollisionWorld___destroy___0 = function() {
            return (tb = b._emscripten_bind_btCollisionWorld___destroy___0 = b.asm.B).apply(null, arguments)
          }
          , ub = b._emscripten_bind_btCollisionShape_setLocalScaling_1 = function() {
            return (ub = b._emscripten_bind_btCollisionShape_setLocalScaling_1 = b.asm.C).apply(null, arguments)
          }
          , vb = b._emscripten_bind_btCollisionShape_getLocalScaling_0 = function() {
            return (vb = b._emscripten_bind_btCollisionShape_getLocalScaling_0 = b.asm.D).apply(null, arguments)
          }
          , wb = b._emscripten_bind_btCollisionShape_calculateLocalInertia_2 = function() {
            return (wb = b._emscripten_bind_btCollisionShape_calculateLocalInertia_2 = b.asm.E).apply(null, arguments)
          }
          , xb = b._emscripten_bind_btCollisionShape_setMargin_1 = function() {
            return (xb = b._emscripten_bind_btCollisionShape_setMargin_1 = b.asm.F).apply(null, arguments)
          }
          , yb = b._emscripten_bind_btCollisionShape_getMargin_0 = function() {
            return (yb = b._emscripten_bind_btCollisionShape_getMargin_0 = b.asm.G).apply(null, arguments)
          }
          , zb = b._emscripten_bind_btCollisionShape___destroy___0 = function() {
            return (zb = b._emscripten_bind_btCollisionShape___destroy___0 = b.asm.H).apply(null, arguments)
          }
          , Ab = b._emscripten_bind_btCollisionObject_setAnisotropicFriction_2 = function() {
            return (Ab = b._emscripten_bind_btCollisionObject_setAnisotropicFriction_2 = b.asm.I).apply(null, arguments)
          }
          , Bb = b._emscripten_bind_btCollisionObject_getCollisionShape_0 = function() {
            return (Bb = b._emscripten_bind_btCollisionObject_getCollisionShape_0 = b.asm.J).apply(null, arguments)
          }
          , Cb = b._emscripten_bind_btCollisionObject_setContactProcessingThreshold_1 = function() {
            return (Cb = b._emscripten_bind_btCollisionObject_setContactProcessingThreshold_1 = b.asm.K).apply(null, arguments)
          }
          , Db = b._emscripten_bind_btCollisionObject_setActivationState_1 = function() {
            return (Db = b._emscripten_bind_btCollisionObject_setActivationState_1 = b.asm.L).apply(null, arguments)
          }
          , Eb = b._emscripten_bind_btCollisionObject_forceActivationState_1 = function() {
            return (Eb = b._emscripten_bind_btCollisionObject_forceActivationState_1 = b.asm.M).apply(null, arguments)
          }
          , Fb = b._emscripten_bind_btCollisionObject_activate_0 = function() {
            return (Fb = b._emscripten_bind_btCollisionObject_activate_0 = b.asm.N).apply(null, arguments)
          }
          , Gb = b._emscripten_bind_btCollisionObject_activate_1 = function() {
            return (Gb = b._emscripten_bind_btCollisionObject_activate_1 = b.asm.O).apply(null, arguments)
          }
          , Hb = b._emscripten_bind_btCollisionObject_isActive_0 = function() {
            return (Hb = b._emscripten_bind_btCollisionObject_isActive_0 = b.asm.P).apply(null, arguments)
          }
          , Ib = b._emscripten_bind_btCollisionObject_isKinematicObject_0 = function() {
            return (Ib = b._emscripten_bind_btCollisionObject_isKinematicObject_0 = b.asm.Q).apply(null, arguments)
          }
          , Jb = b._emscripten_bind_btCollisionObject_isStaticObject_0 = function() {
            return (Jb = b._emscripten_bind_btCollisionObject_isStaticObject_0 = b.asm.R).apply(null, arguments)
          }
          , Kb = b._emscripten_bind_btCollisionObject_isStaticOrKinematicObject_0 = function() {
            return (Kb = b._emscripten_bind_btCollisionObject_isStaticOrKinematicObject_0 = b.asm.S).apply(null, arguments)
          }
          , Lb = b._emscripten_bind_btCollisionObject_getRestitution_0 = function() {
            return (Lb = b._emscripten_bind_btCollisionObject_getRestitution_0 = b.asm.T).apply(null, arguments)
          }
          , Mb = b._emscripten_bind_btCollisionObject_getFriction_0 = function() {
            return (Mb = b._emscripten_bind_btCollisionObject_getFriction_0 = b.asm.U).apply(null, arguments)
          }
          , Nb = b._emscripten_bind_btCollisionObject_getRollingFriction_0 = function() {
            return (Nb = b._emscripten_bind_btCollisionObject_getRollingFriction_0 = b.asm.V).apply(null, arguments)
          }
          , Ob = b._emscripten_bind_btCollisionObject_setRestitution_1 = function() {
            return (Ob = b._emscripten_bind_btCollisionObject_setRestitution_1 = b.asm.W).apply(null, arguments)
          }
          , Pb = b._emscripten_bind_btCollisionObject_setFriction_1 = function() {
            return (Pb = b._emscripten_bind_btCollisionObject_setFriction_1 = b.asm.X).apply(null, arguments)
          }
          , Qb = b._emscripten_bind_btCollisionObject_setRollingFriction_1 = function() {
            return (Qb = b._emscripten_bind_btCollisionObject_setRollingFriction_1 = b.asm.Y).apply(null, arguments)
          }
          , Rb = b._emscripten_bind_btCollisionObject_getWorldTransform_0 = function() {
            return (Rb = b._emscripten_bind_btCollisionObject_getWorldTransform_0 = b.asm.Z).apply(null, arguments)
          }
          , Sb = b._emscripten_bind_btCollisionObject_getCollisionFlags_0 = function() {
            return (Sb = b._emscripten_bind_btCollisionObject_getCollisionFlags_0 = b.asm._).apply(null, arguments)
          }
          , Tb = b._emscripten_bind_btCollisionObject_setCollisionFlags_1 = function() {
            return (Tb = b._emscripten_bind_btCollisionObject_setCollisionFlags_1 = b.asm.$).apply(null, arguments)
          }
          , Ub = b._emscripten_bind_btCollisionObject_setWorldTransform_1 = function() {
            return (Ub = b._emscripten_bind_btCollisionObject_setWorldTransform_1 = b.asm.aa).apply(null, arguments)
          }
          , Vb = b._emscripten_bind_btCollisionObject_setCollisionShape_1 = function() {
            return (Vb = b._emscripten_bind_btCollisionObject_setCollisionShape_1 = b.asm.ba).apply(null, arguments)
          }
          , Xb = b._emscripten_bind_btCollisionObject_setCcdMotionThreshold_1 = function() {
            return (Xb = b._emscripten_bind_btCollisionObject_setCcdMotionThreshold_1 = b.asm.ca).apply(null, arguments)
          }
          , Yb = b._emscripten_bind_btCollisionObject_setCcdSweptSphereRadius_1 = function() {
            return (Yb = b._emscripten_bind_btCollisionObject_setCcdSweptSphereRadius_1 = b.asm.da).apply(null, arguments)
          }
          , Zb = b._emscripten_bind_btCollisionObject_getUserIndex_0 = function() {
            return (Zb = b._emscripten_bind_btCollisionObject_getUserIndex_0 = b.asm.ea).apply(null, arguments)
          }
          , $b = b._emscripten_bind_btCollisionObject_setUserIndex_1 = function() {
            return ($b = b._emscripten_bind_btCollisionObject_setUserIndex_1 = b.asm.fa).apply(null, arguments)
          }
          , ac = b._emscripten_bind_btCollisionObject_getUserPointer_0 = function() {
            return (ac = b._emscripten_bind_btCollisionObject_getUserPointer_0 = b.asm.ga).apply(null, arguments)
          }
          , bc = b._emscripten_bind_btCollisionObject_setUserPointer_1 = function() {
            return (bc = b._emscripten_bind_btCollisionObject_setUserPointer_1 = b.asm.ha).apply(null, arguments)
          }
          , cc = b._emscripten_bind_btCollisionObject_getBroadphaseHandle_0 = function() {
            return (cc = b._emscripten_bind_btCollisionObject_getBroadphaseHandle_0 = b.asm.ia).apply(null, arguments)
          }
          , dc = b._emscripten_bind_btCollisionObject___destroy___0 = function() {
            return (dc = b._emscripten_bind_btCollisionObject___destroy___0 = b.asm.ja).apply(null, arguments)
          }
          , ec = b._emscripten_bind_btDynamicsWorld_addAction_1 = function() {
            return (ec = b._emscripten_bind_btDynamicsWorld_addAction_1 = b.asm.ka).apply(null, arguments)
          }
          , fc = b._emscripten_bind_btDynamicsWorld_removeAction_1 = function() {
            return (fc = b._emscripten_bind_btDynamicsWorld_removeAction_1 = b.asm.la).apply(null, arguments)
          }
          , hc = b._emscripten_bind_btDynamicsWorld_getSolverInfo_0 = function() {
            return (hc = b._emscripten_bind_btDynamicsWorld_getSolverInfo_0 = b.asm.ma).apply(null, arguments)
          }
          , ic = b._emscripten_bind_btDynamicsWorld_setInternalTickCallback_1 = function() {
            return (ic = b._emscripten_bind_btDynamicsWorld_setInternalTickCallback_1 = b.asm.na).apply(null, arguments)
          }
          , jc = b._emscripten_bind_btDynamicsWorld_setInternalTickCallback_2 = function() {
            return (jc = b._emscripten_bind_btDynamicsWorld_setInternalTickCallback_2 = b.asm.oa).apply(null, arguments)
          }
          , kc = b._emscripten_bind_btDynamicsWorld_setInternalTickCallback_3 = function() {
            return (kc = b._emscripten_bind_btDynamicsWorld_setInternalTickCallback_3 = b.asm.pa).apply(null, arguments)
          }
          , lc = b._emscripten_bind_btDynamicsWorld_getDispatcher_0 = function() {
            return (lc = b._emscripten_bind_btDynamicsWorld_getDispatcher_0 = b.asm.qa).apply(null, arguments)
          }
          , mc = b._emscripten_bind_btDynamicsWorld_rayTest_3 = function() {
            return (mc = b._emscripten_bind_btDynamicsWorld_rayTest_3 = b.asm.ra).apply(null, arguments)
          }
          , nc = b._emscripten_bind_btDynamicsWorld_getPairCache_0 = function() {
            return (nc = b._emscripten_bind_btDynamicsWorld_getPairCache_0 = b.asm.sa).apply(null, arguments)
          }
          , oc = b._emscripten_bind_btDynamicsWorld_getDispatchInfo_0 = function() {
            return (oc = b._emscripten_bind_btDynamicsWorld_getDispatchInfo_0 = b.asm.ta).apply(null, arguments)
          }
          , pc = b._emscripten_bind_btDynamicsWorld_addCollisionObject_1 = function() {
            return (pc = b._emscripten_bind_btDynamicsWorld_addCollisionObject_1 = b.asm.ua).apply(null, arguments)
          }
          , qc = b._emscripten_bind_btDynamicsWorld_addCollisionObject_2 = function() {
            return (qc = b._emscripten_bind_btDynamicsWorld_addCollisionObject_2 = b.asm.va).apply(null, arguments)
          }
          , rc = b._emscripten_bind_btDynamicsWorld_addCollisionObject_3 = function() {
            return (rc = b._emscripten_bind_btDynamicsWorld_addCollisionObject_3 = b.asm.wa).apply(null, arguments)
          }
          , sc = b._emscripten_bind_btDynamicsWorld_removeCollisionObject_1 = function() {
            return (sc = b._emscripten_bind_btDynamicsWorld_removeCollisionObject_1 = b.asm.xa).apply(null, arguments)
          }
          , tc = b._emscripten_bind_btDynamicsWorld_getBroadphase_0 = function() {
            return (tc = b._emscripten_bind_btDynamicsWorld_getBroadphase_0 = b.asm.ya).apply(null, arguments)
          }
          , uc = b._emscripten_bind_btDynamicsWorld_convexSweepTest_5 = function() {
            return (uc = b._emscripten_bind_btDynamicsWorld_convexSweepTest_5 = b.asm.za).apply(null, arguments)
          }
          , vc = b._emscripten_bind_btDynamicsWorld_contactPairTest_3 = function() {
            return (vc = b._emscripten_bind_btDynamicsWorld_contactPairTest_3 = b.asm.Aa).apply(null, arguments)
          }
          , wc = b._emscripten_bind_btDynamicsWorld_contactTest_2 = function() {
            return (wc = b._emscripten_bind_btDynamicsWorld_contactTest_2 = b.asm.Ba).apply(null, arguments)
          }
          , xc = b._emscripten_bind_btDynamicsWorld_updateSingleAabb_1 = function() {
            return (xc = b._emscripten_bind_btDynamicsWorld_updateSingleAabb_1 = b.asm.Ca).apply(null, arguments)
          }
          , yc = b._emscripten_bind_btDynamicsWorld_setDebugDrawer_1 = function() {
            return (yc = b._emscripten_bind_btDynamicsWorld_setDebugDrawer_1 = b.asm.Da).apply(null, arguments)
          }
          , zc = b._emscripten_bind_btDynamicsWorld_getDebugDrawer_0 = function() {
            return (zc = b._emscripten_bind_btDynamicsWorld_getDebugDrawer_0 = b.asm.Ea).apply(null, arguments)
          }
          , Ac = b._emscripten_bind_btDynamicsWorld_debugDrawWorld_0 = function() {
            return (Ac = b._emscripten_bind_btDynamicsWorld_debugDrawWorld_0 = b.asm.Fa).apply(null, arguments)
          }
          , Bc = b._emscripten_bind_btDynamicsWorld_debugDrawObject_3 = function() {
            return (Bc = b._emscripten_bind_btDynamicsWorld_debugDrawObject_3 = b.asm.Ga).apply(null, arguments)
          }
          , Cc = b._emscripten_bind_btDynamicsWorld___destroy___0 = function() {
            return (Cc = b._emscripten_bind_btDynamicsWorld___destroy___0 = b.asm.Ha).apply(null, arguments)
          }
          , Dc = b._emscripten_bind_btTypedConstraint_enableFeedback_1 = function() {
            return (Dc = b._emscripten_bind_btTypedConstraint_enableFeedback_1 = b.asm.Ia).apply(null, arguments)
          }
          , Ec = b._emscripten_bind_btTypedConstraint_getBreakingImpulseThreshold_0 = function() {
            return (Ec = b._emscripten_bind_btTypedConstraint_getBreakingImpulseThreshold_0 = b.asm.Ja).apply(null, arguments)
          }
          , Fc = b._emscripten_bind_btTypedConstraint_setBreakingImpulseThreshold_1 = function() {
            return (Fc = b._emscripten_bind_btTypedConstraint_setBreakingImpulseThreshold_1 = b.asm.Ka).apply(null, arguments)
          }
          , Gc = b._emscripten_bind_btTypedConstraint_getParam_2 = function() {
            return (Gc = b._emscripten_bind_btTypedConstraint_getParam_2 = b.asm.La).apply(null, arguments)
          }
          , Hc = b._emscripten_bind_btTypedConstraint_setParam_3 = function() {
            return (Hc = b._emscripten_bind_btTypedConstraint_setParam_3 = b.asm.Ma).apply(null, arguments)
          }
          , Ic = b._emscripten_bind_btTypedConstraint___destroy___0 = function() {
            return (Ic = b._emscripten_bind_btTypedConstraint___destroy___0 = b.asm.Na).apply(null, arguments)
          }
          , Jc = b._emscripten_bind_btConcaveShape_setLocalScaling_1 = function() {
            return (Jc = b._emscripten_bind_btConcaveShape_setLocalScaling_1 = b.asm.Oa).apply(null, arguments)
          }
          , Kc = b._emscripten_bind_btConcaveShape_getLocalScaling_0 = function() {
            return (Kc = b._emscripten_bind_btConcaveShape_getLocalScaling_0 = b.asm.Pa).apply(null, arguments)
          }
          , Lc = b._emscripten_bind_btConcaveShape_calculateLocalInertia_2 = function() {
            return (Lc = b._emscripten_bind_btConcaveShape_calculateLocalInertia_2 = b.asm.Qa).apply(null, arguments)
          }
          , Mc = b._emscripten_bind_btConcaveShape___destroy___0 = function() {
            return (Mc = b._emscripten_bind_btConcaveShape___destroy___0 = b.asm.Ra).apply(null, arguments)
          }
          , Nc = b._emscripten_bind_btCapsuleShape_btCapsuleShape_2 = function() {
            return (Nc = b._emscripten_bind_btCapsuleShape_btCapsuleShape_2 = b.asm.Sa).apply(null, arguments)
          }
          , Oc = b._emscripten_bind_btCapsuleShape_setMargin_1 = function() {
            return (Oc = b._emscripten_bind_btCapsuleShape_setMargin_1 = b.asm.Ta).apply(null, arguments)
          }
          , Pc = b._emscripten_bind_btCapsuleShape_getMargin_0 = function() {
            return (Pc = b._emscripten_bind_btCapsuleShape_getMargin_0 = b.asm.Ua).apply(null, arguments)
          }
          , Qc = b._emscripten_bind_btCapsuleShape_getUpAxis_0 = function() {
            return (Qc = b._emscripten_bind_btCapsuleShape_getUpAxis_0 = b.asm.Va).apply(null, arguments)
          }
          , Rc = b._emscripten_bind_btCapsuleShape_getRadius_0 = function() {
            return (Rc = b._emscripten_bind_btCapsuleShape_getRadius_0 = b.asm.Wa).apply(null, arguments)
          }
          , Sc = b._emscripten_bind_btCapsuleShape_getHalfHeight_0 = function() {
            return (Sc = b._emscripten_bind_btCapsuleShape_getHalfHeight_0 = b.asm.Xa).apply(null, arguments)
          }
          , Tc = b._emscripten_bind_btCapsuleShape_setLocalScaling_1 = function() {
            return (Tc = b._emscripten_bind_btCapsuleShape_setLocalScaling_1 = b.asm.Ya).apply(null, arguments)
          }
          , Uc = b._emscripten_bind_btCapsuleShape_getLocalScaling_0 = function() {
            return (Uc = b._emscripten_bind_btCapsuleShape_getLocalScaling_0 = b.asm.Za).apply(null, arguments)
          }
          , Vc = b._emscripten_bind_btCapsuleShape_calculateLocalInertia_2 = function() {
            return (Vc = b._emscripten_bind_btCapsuleShape_calculateLocalInertia_2 = b.asm._a).apply(null, arguments)
          }
          , Wc = b._emscripten_bind_btCapsuleShape___destroy___0 = function() {
            return (Wc = b._emscripten_bind_btCapsuleShape___destroy___0 = b.asm.$a).apply(null, arguments)
          }
          , Xc = b._emscripten_bind_btIDebugDraw_drawLine_3 = function() {
            return (Xc = b._emscripten_bind_btIDebugDraw_drawLine_3 = b.asm.ab).apply(null, arguments)
          }
          , Yc = b._emscripten_bind_btIDebugDraw_drawContactPoint_5 = function() {
            return (Yc = b._emscripten_bind_btIDebugDraw_drawContactPoint_5 = b.asm.bb).apply(null, arguments)
          }
          , Zc = b._emscripten_bind_btIDebugDraw_reportErrorWarning_1 = function() {
            return (Zc = b._emscripten_bind_btIDebugDraw_reportErrorWarning_1 = b.asm.cb).apply(null, arguments)
          }
          , $c = b._emscripten_bind_btIDebugDraw_draw3dText_2 = function() {
            return ($c = b._emscripten_bind_btIDebugDraw_draw3dText_2 = b.asm.db).apply(null, arguments)
          }
          , ad = b._emscripten_bind_btIDebugDraw_setDebugMode_1 = function() {
            return (ad = b._emscripten_bind_btIDebugDraw_setDebugMode_1 = b.asm.eb).apply(null, arguments)
          }
          , bd = b._emscripten_bind_btIDebugDraw_getDebugMode_0 = function() {
            return (bd = b._emscripten_bind_btIDebugDraw_getDebugMode_0 = b.asm.fb).apply(null, arguments)
          }
          , cd = b._emscripten_bind_btIDebugDraw___destroy___0 = function() {
            return (cd = b._emscripten_bind_btIDebugDraw___destroy___0 = b.asm.gb).apply(null, arguments)
          }
          , dd = b._emscripten_bind_btDefaultCollisionConfiguration_btDefaultCollisionConfiguration_0 = function() {
            return (dd = b._emscripten_bind_btDefaultCollisionConfiguration_btDefaultCollisionConfiguration_0 = b.asm.hb).apply(null, arguments)
          }
          , ed = b._emscripten_bind_btDefaultCollisionConfiguration_btDefaultCollisionConfiguration_1 = function() {
            return (ed = b._emscripten_bind_btDefaultCollisionConfiguration_btDefaultCollisionConfiguration_1 = b.asm.ib).apply(null, arguments)
          }
          , fd = b._emscripten_bind_btDefaultCollisionConfiguration___destroy___0 = function() {
            return (fd = b._emscripten_bind_btDefaultCollisionConfiguration___destroy___0 = b.asm.jb).apply(null, arguments)
          }
          , gd = b._emscripten_bind_btTriangleMeshShape_setLocalScaling_1 = function() {
            return (gd = b._emscripten_bind_btTriangleMeshShape_setLocalScaling_1 = b.asm.kb).apply(null, arguments)
          }
          , hd = b._emscripten_bind_btTriangleMeshShape_getLocalScaling_0 = function() {
            return (hd = b._emscripten_bind_btTriangleMeshShape_getLocalScaling_0 = b.asm.lb).apply(null, arguments)
          }
          , id = b._emscripten_bind_btTriangleMeshShape_calculateLocalInertia_2 = function() {
            return (id = b._emscripten_bind_btTriangleMeshShape_calculateLocalInertia_2 = b.asm.mb).apply(null, arguments)
          }
          , jd = b._emscripten_bind_btTriangleMeshShape___destroy___0 = function() {
            return (jd = b._emscripten_bind_btTriangleMeshShape___destroy___0 = b.asm.nb).apply(null, arguments)
          }
          , kd = b._emscripten_bind_btGhostObject_btGhostObject_0 = function() {
            return (kd = b._emscripten_bind_btGhostObject_btGhostObject_0 = b.asm.ob).apply(null, arguments)
          }
          , ld = b._emscripten_bind_btGhostObject_getNumOverlappingObjects_0 = function() {
            return (ld = b._emscripten_bind_btGhostObject_getNumOverlappingObjects_0 = b.asm.pb).apply(null, arguments)
          }
          , md = b._emscripten_bind_btGhostObject_getOverlappingObject_1 = function() {
            return (md = b._emscripten_bind_btGhostObject_getOverlappingObject_1 = b.asm.qb).apply(null, arguments)
          }
          , nd = b._emscripten_bind_btGhostObject_setAnisotropicFriction_2 = function() {
            return (nd = b._emscripten_bind_btGhostObject_setAnisotropicFriction_2 = b.asm.rb).apply(null, arguments)
          }
          , od = b._emscripten_bind_btGhostObject_getCollisionShape_0 = function() {
            return (od = b._emscripten_bind_btGhostObject_getCollisionShape_0 = b.asm.sb).apply(null, arguments)
          }
          , pd = b._emscripten_bind_btGhostObject_setContactProcessingThreshold_1 = function() {
            return (pd = b._emscripten_bind_btGhostObject_setContactProcessingThreshold_1 = b.asm.tb).apply(null, arguments)
          }
          , qd = b._emscripten_bind_btGhostObject_setActivationState_1 = function() {
            return (qd = b._emscripten_bind_btGhostObject_setActivationState_1 = b.asm.ub).apply(null, arguments)
          }
          , rd = b._emscripten_bind_btGhostObject_forceActivationState_1 = function() {
            return (rd = b._emscripten_bind_btGhostObject_forceActivationState_1 = b.asm.vb).apply(null, arguments)
          }
          , sd = b._emscripten_bind_btGhostObject_activate_0 = function() {
            return (sd = b._emscripten_bind_btGhostObject_activate_0 = b.asm.wb).apply(null, arguments)
          }
          , td = b._emscripten_bind_btGhostObject_activate_1 = function() {
            return (td = b._emscripten_bind_btGhostObject_activate_1 = b.asm.xb).apply(null, arguments)
          }
          , ud = b._emscripten_bind_btGhostObject_isActive_0 = function() {
            return (ud = b._emscripten_bind_btGhostObject_isActive_0 = b.asm.yb).apply(null, arguments)
          }
          , vd = b._emscripten_bind_btGhostObject_isKinematicObject_0 = function() {
            return (vd = b._emscripten_bind_btGhostObject_isKinematicObject_0 = b.asm.zb).apply(null, arguments)
          }
          , wd = b._emscripten_bind_btGhostObject_isStaticObject_0 = function() {
            return (wd = b._emscripten_bind_btGhostObject_isStaticObject_0 = b.asm.Ab).apply(null, arguments)
          }
          , xd = b._emscripten_bind_btGhostObject_isStaticOrKinematicObject_0 = function() {
            return (xd = b._emscripten_bind_btGhostObject_isStaticOrKinematicObject_0 = b.asm.Bb).apply(null, arguments)
          }
          , yd = b._emscripten_bind_btGhostObject_getRestitution_0 = function() {
            return (yd = b._emscripten_bind_btGhostObject_getRestitution_0 = b.asm.Cb).apply(null, arguments)
          }
          , zd = b._emscripten_bind_btGhostObject_getFriction_0 = function() {
            return (zd = b._emscripten_bind_btGhostObject_getFriction_0 = b.asm.Db).apply(null, arguments)
          }
          , Ad = b._emscripten_bind_btGhostObject_getRollingFriction_0 = function() {
            return (Ad = b._emscripten_bind_btGhostObject_getRollingFriction_0 = b.asm.Eb).apply(null, arguments)
          }
          , Bd = b._emscripten_bind_btGhostObject_setRestitution_1 = function() {
            return (Bd = b._emscripten_bind_btGhostObject_setRestitution_1 = b.asm.Fb).apply(null, arguments)
          }
          , Cd = b._emscripten_bind_btGhostObject_setFriction_1 = function() {
            return (Cd = b._emscripten_bind_btGhostObject_setFriction_1 = b.asm.Gb).apply(null, arguments)
          }
          , Dd = b._emscripten_bind_btGhostObject_setRollingFriction_1 = function() {
            return (Dd = b._emscripten_bind_btGhostObject_setRollingFriction_1 = b.asm.Hb).apply(null, arguments)
          }
          , Ed = b._emscripten_bind_btGhostObject_getWorldTransform_0 = function() {
            return (Ed = b._emscripten_bind_btGhostObject_getWorldTransform_0 = b.asm.Ib).apply(null, arguments)
          }
          , Fd = b._emscripten_bind_btGhostObject_getCollisionFlags_0 = function() {
            return (Fd = b._emscripten_bind_btGhostObject_getCollisionFlags_0 = b.asm.Jb).apply(null, arguments)
          }
          , Gd = b._emscripten_bind_btGhostObject_setCollisionFlags_1 = function() {
            return (Gd = b._emscripten_bind_btGhostObject_setCollisionFlags_1 = b.asm.Kb).apply(null, arguments)
          }
          , Hd = b._emscripten_bind_btGhostObject_setWorldTransform_1 = function() {
            return (Hd = b._emscripten_bind_btGhostObject_setWorldTransform_1 = b.asm.Lb).apply(null, arguments)
          }
          , Id = b._emscripten_bind_btGhostObject_setCollisionShape_1 = function() {
            return (Id = b._emscripten_bind_btGhostObject_setCollisionShape_1 = b.asm.Mb).apply(null, arguments)
          }
          , Jd = b._emscripten_bind_btGhostObject_setCcdMotionThreshold_1 = function() {
            return (Jd = b._emscripten_bind_btGhostObject_setCcdMotionThreshold_1 = b.asm.Nb).apply(null, arguments)
          }
          , Kd = b._emscripten_bind_btGhostObject_setCcdSweptSphereRadius_1 = function() {
            return (Kd = b._emscripten_bind_btGhostObject_setCcdSweptSphereRadius_1 = b.asm.Ob).apply(null, arguments)
          }
          , Ld = b._emscripten_bind_btGhostObject_getUserIndex_0 = function() {
            return (Ld = b._emscripten_bind_btGhostObject_getUserIndex_0 = b.asm.Pb).apply(null, arguments)
          }
          , Md = b._emscripten_bind_btGhostObject_setUserIndex_1 = function() {
            return (Md = b._emscripten_bind_btGhostObject_setUserIndex_1 = b.asm.Qb).apply(null, arguments)
          }
          , Nd = b._emscripten_bind_btGhostObject_getUserPointer_0 = function() {
            return (Nd = b._emscripten_bind_btGhostObject_getUserPointer_0 = b.asm.Rb).apply(null, arguments)
          }
          , Od = b._emscripten_bind_btGhostObject_setUserPointer_1 = function() {
            return (Od = b._emscripten_bind_btGhostObject_setUserPointer_1 = b.asm.Sb).apply(null, arguments)
          }
          , Pd = b._emscripten_bind_btGhostObject_getBroadphaseHandle_0 = function() {
            return (Pd = b._emscripten_bind_btGhostObject_getBroadphaseHandle_0 = b.asm.Tb).apply(null, arguments)
          }
          , Qd = b._emscripten_bind_btGhostObject___destroy___0 = function() {
            return (Qd = b._emscripten_bind_btGhostObject___destroy___0 = b.asm.Ub).apply(null, arguments)
          }
          , Rd = b._emscripten_bind_btConeShape_btConeShape_2 = function() {
            return (Rd = b._emscripten_bind_btConeShape_btConeShape_2 = b.asm.Vb).apply(null, arguments)
          }
          , Sd = b._emscripten_bind_btConeShape_setLocalScaling_1 = function() {
            return (Sd = b._emscripten_bind_btConeShape_setLocalScaling_1 = b.asm.Wb).apply(null, arguments)
          }
          , Td = b._emscripten_bind_btConeShape_getLocalScaling_0 = function() {
            return (Td = b._emscripten_bind_btConeShape_getLocalScaling_0 = b.asm.Xb).apply(null, arguments)
          }
          , Ud = b._emscripten_bind_btConeShape_calculateLocalInertia_2 = function() {
            return (Ud = b._emscripten_bind_btConeShape_calculateLocalInertia_2 = b.asm.Yb).apply(null, arguments)
          }
          , Vd = b._emscripten_bind_btConeShape___destroy___0 = function() {
            return (Vd = b._emscripten_bind_btConeShape___destroy___0 = b.asm.Zb).apply(null, arguments)
          }
          , Wd = b._emscripten_bind_btActionInterface_updateAction_2 = function() {
            return (Wd = b._emscripten_bind_btActionInterface_updateAction_2 = b.asm._b).apply(null, arguments)
          }
          , Xd = b._emscripten_bind_btActionInterface___destroy___0 = function() {
            return (Xd = b._emscripten_bind_btActionInterface___destroy___0 = b.asm.$b).apply(null, arguments)
          }
          , Yd = b._emscripten_bind_btVector3_btVector3_0 = function() {
            return (Yd = b._emscripten_bind_btVector3_btVector3_0 = b.asm.ac).apply(null, arguments)
          }
          , Zd = b._emscripten_bind_btVector3_btVector3_3 = function() {
            return (Zd = b._emscripten_bind_btVector3_btVector3_3 = b.asm.bc).apply(null, arguments)
          }
          , $d = b._emscripten_bind_btVector3_length_0 = function() {
            return ($d = b._emscripten_bind_btVector3_length_0 = b.asm.cc).apply(null, arguments)
          }
          , ae = b._emscripten_bind_btVector3_x_0 = function() {
            return (ae = b._emscripten_bind_btVector3_x_0 = b.asm.dc).apply(null, arguments)
          }
          , be = b._emscripten_bind_btVector3_y_0 = function() {
            return (be = b._emscripten_bind_btVector3_y_0 = b.asm.ec).apply(null, arguments)
          }
          , ce = b._emscripten_bind_btVector3_z_0 = function() {
            return (ce = b._emscripten_bind_btVector3_z_0 = b.asm.fc).apply(null, arguments)
          }
          , de = b._emscripten_bind_btVector3_setX_1 = function() {
            return (de = b._emscripten_bind_btVector3_setX_1 = b.asm.gc).apply(null, arguments)
          }
          , ee = b._emscripten_bind_btVector3_setY_1 = function() {
            return (ee = b._emscripten_bind_btVector3_setY_1 = b.asm.hc).apply(null, arguments)
          }
          , fe = b._emscripten_bind_btVector3_setZ_1 = function() {
            return (fe = b._emscripten_bind_btVector3_setZ_1 = b.asm.ic).apply(null, arguments)
          }
          , ge = b._emscripten_bind_btVector3_setValue_3 = function() {
            return (ge = b._emscripten_bind_btVector3_setValue_3 = b.asm.jc).apply(null, arguments)
          }
          , he = b._emscripten_bind_btVector3_normalize_0 = function() {
            return (he = b._emscripten_bind_btVector3_normalize_0 = b.asm.kc).apply(null, arguments)
          }
          , ie = b._emscripten_bind_btVector3_rotate_2 = function() {
            return (ie = b._emscripten_bind_btVector3_rotate_2 = b.asm.lc).apply(null, arguments)
          }
          , je = b._emscripten_bind_btVector3_dot_1 = function() {
            return (je = b._emscripten_bind_btVector3_dot_1 = b.asm.mc).apply(null, arguments)
          }
          , ke = b._emscripten_bind_btVector3_op_mul_1 = function() {
            return (ke = b._emscripten_bind_btVector3_op_mul_1 = b.asm.nc).apply(null, arguments)
          }
          , le = b._emscripten_bind_btVector3_op_add_1 = function() {
            return (le = b._emscripten_bind_btVector3_op_add_1 = b.asm.oc).apply(null, arguments)
          }
          , me = b._emscripten_bind_btVector3_op_sub_1 = function() {
            return (me = b._emscripten_bind_btVector3_op_sub_1 = b.asm.pc).apply(null, arguments)
          }
          , ne = b._emscripten_bind_btVector3___destroy___0 = function() {
            return (ne = b._emscripten_bind_btVector3___destroy___0 = b.asm.qc).apply(null, arguments)
          }
          , oe = b._emscripten_bind_btVehicleRaycaster_castRay_3 = function() {
            return (oe = b._emscripten_bind_btVehicleRaycaster_castRay_3 = b.asm.rc).apply(null, arguments)
          }
          , pe = b._emscripten_bind_btVehicleRaycaster___destroy___0 = function() {
            return (pe = b._emscripten_bind_btVehicleRaycaster___destroy___0 = b.asm.sc).apply(null, arguments)
          }
          , qe = b._emscripten_bind_btQuadWord_x_0 = function() {
            return (qe = b._emscripten_bind_btQuadWord_x_0 = b.asm.tc).apply(null, arguments)
          }
          , re = b._emscripten_bind_btQuadWord_y_0 = function() {
            return (re = b._emscripten_bind_btQuadWord_y_0 = b.asm.uc).apply(null, arguments)
          }
          , se = b._emscripten_bind_btQuadWord_z_0 = function() {
            return (se = b._emscripten_bind_btQuadWord_z_0 = b.asm.vc).apply(null, arguments)
          }
          , te = b._emscripten_bind_btQuadWord_w_0 = function() {
            return (te = b._emscripten_bind_btQuadWord_w_0 = b.asm.wc).apply(null, arguments)
          }
          , ue = b._emscripten_bind_btQuadWord_setX_1 = function() {
            return (ue = b._emscripten_bind_btQuadWord_setX_1 = b.asm.xc).apply(null, arguments)
          }
          , ve = b._emscripten_bind_btQuadWord_setY_1 = function() {
            return (ve = b._emscripten_bind_btQuadWord_setY_1 = b.asm.yc).apply(null, arguments)
          }
          , we = b._emscripten_bind_btQuadWord_setZ_1 = function() {
            return (we = b._emscripten_bind_btQuadWord_setZ_1 = b.asm.zc).apply(null, arguments)
          }
          , xe = b._emscripten_bind_btQuadWord_setW_1 = function() {
            return (xe = b._emscripten_bind_btQuadWord_setW_1 = b.asm.Ac).apply(null, arguments)
          }
          , ye = b._emscripten_bind_btQuadWord___destroy___0 = function() {
            return (ye = b._emscripten_bind_btQuadWord___destroy___0 = b.asm.Bc).apply(null, arguments)
          }
          , ze = b._emscripten_bind_btCylinderShape_btCylinderShape_1 = function() {
            return (ze = b._emscripten_bind_btCylinderShape_btCylinderShape_1 = b.asm.Cc).apply(null, arguments)
          }
          , Ae = b._emscripten_bind_btCylinderShape_setMargin_1 = function() {
            return (Ae = b._emscripten_bind_btCylinderShape_setMargin_1 = b.asm.Dc).apply(null, arguments)
          }
          , Be = b._emscripten_bind_btCylinderShape_getMargin_0 = function() {
            return (Be = b._emscripten_bind_btCylinderShape_getMargin_0 = b.asm.Ec).apply(null, arguments)
          }
          , Ce = b._emscripten_bind_btCylinderShape_setLocalScaling_1 = function() {
            return (Ce = b._emscripten_bind_btCylinderShape_setLocalScaling_1 = b.asm.Fc).apply(null, arguments)
          }
          , De = b._emscripten_bind_btCylinderShape_getLocalScaling_0 = function() {
            return (De = b._emscripten_bind_btCylinderShape_getLocalScaling_0 = b.asm.Gc).apply(null, arguments)
          }
          , Ee = b._emscripten_bind_btCylinderShape_calculateLocalInertia_2 = function() {
            return (Ee = b._emscripten_bind_btCylinderShape_calculateLocalInertia_2 = b.asm.Hc).apply(null, arguments)
          }
          , Fe = b._emscripten_bind_btCylinderShape___destroy___0 = function() {
            return (Fe = b._emscripten_bind_btCylinderShape___destroy___0 = b.asm.Ic).apply(null, arguments)
          }
          , Ge = b._emscripten_bind_btDiscreteDynamicsWorld_btDiscreteDynamicsWorld_4 = function() {
            return (Ge = b._emscripten_bind_btDiscreteDynamicsWorld_btDiscreteDynamicsWorld_4 = b.asm.Jc).apply(null, arguments)
          }
          , He = b._emscripten_bind_btDiscreteDynamicsWorld_setGravity_1 = function() {
            return (He = b._emscripten_bind_btDiscreteDynamicsWorld_setGravity_1 = b.asm.Kc).apply(null, arguments)
          }
          , Ie = b._emscripten_bind_btDiscreteDynamicsWorld_getGravity_0 = function() {
            return (Ie = b._emscripten_bind_btDiscreteDynamicsWorld_getGravity_0 = b.asm.Lc).apply(null, arguments)
          }
          , Je = b._emscripten_bind_btDiscreteDynamicsWorld_addRigidBody_1 = function() {
            return (Je = b._emscripten_bind_btDiscreteDynamicsWorld_addRigidBody_1 = b.asm.Mc).apply(null, arguments)
          }
          , Ke = b._emscripten_bind_btDiscreteDynamicsWorld_addRigidBody_3 = function() {
            return (Ke = b._emscripten_bind_btDiscreteDynamicsWorld_addRigidBody_3 = b.asm.Nc).apply(null, arguments)
          }
          , Le = b._emscripten_bind_btDiscreteDynamicsWorld_removeRigidBody_1 = function() {
            return (Le = b._emscripten_bind_btDiscreteDynamicsWorld_removeRigidBody_1 = b.asm.Oc).apply(null, arguments)
          }
          , Me = b._emscripten_bind_btDiscreteDynamicsWorld_addConstraint_1 = function() {
            return (Me = b._emscripten_bind_btDiscreteDynamicsWorld_addConstraint_1 = b.asm.Pc).apply(null, arguments)
          }
          , Ne = b._emscripten_bind_btDiscreteDynamicsWorld_addConstraint_2 = function() {
            return (Ne = b._emscripten_bind_btDiscreteDynamicsWorld_addConstraint_2 = b.asm.Qc).apply(null, arguments)
          }
          , Oe = b._emscripten_bind_btDiscreteDynamicsWorld_removeConstraint_1 = function() {
            return (Oe = b._emscripten_bind_btDiscreteDynamicsWorld_removeConstraint_1 = b.asm.Rc).apply(null, arguments)
          }
          , Pe = b._emscripten_bind_btDiscreteDynamicsWorld_stepSimulation_1 = function() {
            return (Pe = b._emscripten_bind_btDiscreteDynamicsWorld_stepSimulation_1 = b.asm.Sc).apply(null, arguments)
          }
          , Qe = b._emscripten_bind_btDiscreteDynamicsWorld_stepSimulation_2 = function() {
            return (Qe = b._emscripten_bind_btDiscreteDynamicsWorld_stepSimulation_2 = b.asm.Tc).apply(null, arguments)
          }
          , Re = b._emscripten_bind_btDiscreteDynamicsWorld_stepSimulation_3 = function() {
            return (Re = b._emscripten_bind_btDiscreteDynamicsWorld_stepSimulation_3 = b.asm.Uc).apply(null, arguments)
          }
          , Se = b._emscripten_bind_btDiscreteDynamicsWorld_setContactAddedCallback_1 = function() {
            return (Se = b._emscripten_bind_btDiscreteDynamicsWorld_setContactAddedCallback_1 = b.asm.Vc).apply(null, arguments)
          }
          , Te = b._emscripten_bind_btDiscreteDynamicsWorld_setContactProcessedCallback_1 = function() {
            return (Te = b._emscripten_bind_btDiscreteDynamicsWorld_setContactProcessedCallback_1 = b.asm.Wc).apply(null, arguments)
          }
          , Ue = b._emscripten_bind_btDiscreteDynamicsWorld_setContactDestroyedCallback_1 = function() {
            return (Ue = b._emscripten_bind_btDiscreteDynamicsWorld_setContactDestroyedCallback_1 = b.asm.Xc).apply(null, arguments)
          }
          , Ve = b._emscripten_bind_btDiscreteDynamicsWorld_getDispatcher_0 = function() {
            return (Ve = b._emscripten_bind_btDiscreteDynamicsWorld_getDispatcher_0 = b.asm.Yc).apply(null, arguments)
          }
          , We = b._emscripten_bind_btDiscreteDynamicsWorld_rayTest_3 = function() {
            return (We = b._emscripten_bind_btDiscreteDynamicsWorld_rayTest_3 = b.asm.Zc).apply(null, arguments)
          }
          , Xe = b._emscripten_bind_btDiscreteDynamicsWorld_getPairCache_0 = function() {
            return (Xe = b._emscripten_bind_btDiscreteDynamicsWorld_getPairCache_0 = b.asm._c).apply(null, arguments)
          }
          , Ye = b._emscripten_bind_btDiscreteDynamicsWorld_getDispatchInfo_0 = function() {
            return (Ye = b._emscripten_bind_btDiscreteDynamicsWorld_getDispatchInfo_0 = b.asm.$c).apply(null, arguments)
          }
          , Ze = b._emscripten_bind_btDiscreteDynamicsWorld_addCollisionObject_1 = function() {
            return (Ze = b._emscripten_bind_btDiscreteDynamicsWorld_addCollisionObject_1 = b.asm.ad).apply(null, arguments)
          }
          , $e = b._emscripten_bind_btDiscreteDynamicsWorld_addCollisionObject_2 = function() {
            return ($e = b._emscripten_bind_btDiscreteDynamicsWorld_addCollisionObject_2 = b.asm.bd).apply(null, arguments)
          }
          , af = b._emscripten_bind_btDiscreteDynamicsWorld_addCollisionObject_3 = function() {
            return (af = b._emscripten_bind_btDiscreteDynamicsWorld_addCollisionObject_3 = b.asm.cd).apply(null, arguments)
          }
          , bf = b._emscripten_bind_btDiscreteDynamicsWorld_removeCollisionObject_1 = function() {
            return (bf = b._emscripten_bind_btDiscreteDynamicsWorld_removeCollisionObject_1 = b.asm.dd).apply(null, arguments)
          }
          , cf = b._emscripten_bind_btDiscreteDynamicsWorld_getBroadphase_0 = function() {
            return (cf = b._emscripten_bind_btDiscreteDynamicsWorld_getBroadphase_0 = b.asm.ed).apply(null, arguments)
          }
          , df = b._emscripten_bind_btDiscreteDynamicsWorld_convexSweepTest_5 = function() {
            return (df = b._emscripten_bind_btDiscreteDynamicsWorld_convexSweepTest_5 = b.asm.fd).apply(null, arguments)
          }
          , ef = b._emscripten_bind_btDiscreteDynamicsWorld_contactPairTest_3 = function() {
            return (ef = b._emscripten_bind_btDiscreteDynamicsWorld_contactPairTest_3 = b.asm.gd).apply(null, arguments)
          }
          , ff = b._emscripten_bind_btDiscreteDynamicsWorld_contactTest_2 = function() {
            return (ff = b._emscripten_bind_btDiscreteDynamicsWorld_contactTest_2 = b.asm.hd).apply(null, arguments)
          }
          , gf = b._emscripten_bind_btDiscreteDynamicsWorld_updateSingleAabb_1 = function() {
            return (gf = b._emscripten_bind_btDiscreteDynamicsWorld_updateSingleAabb_1 = b.asm.id).apply(null, arguments)
          }
          , hf = b._emscripten_bind_btDiscreteDynamicsWorld_setDebugDrawer_1 = function() {
            return (hf = b._emscripten_bind_btDiscreteDynamicsWorld_setDebugDrawer_1 = b.asm.jd).apply(null, arguments)
          }
          , jf = b._emscripten_bind_btDiscreteDynamicsWorld_getDebugDrawer_0 = function() {
            return (jf = b._emscripten_bind_btDiscreteDynamicsWorld_getDebugDrawer_0 = b.asm.kd).apply(null, arguments)
          }
          , kf = b._emscripten_bind_btDiscreteDynamicsWorld_debugDrawWorld_0 = function() {
            return (kf = b._emscripten_bind_btDiscreteDynamicsWorld_debugDrawWorld_0 = b.asm.ld).apply(null, arguments)
          }
          , lf = b._emscripten_bind_btDiscreteDynamicsWorld_debugDrawObject_3 = function() {
            return (lf = b._emscripten_bind_btDiscreteDynamicsWorld_debugDrawObject_3 = b.asm.md).apply(null, arguments)
          }
          , mf = b._emscripten_bind_btDiscreteDynamicsWorld_addAction_1 = function() {
            return (mf = b._emscripten_bind_btDiscreteDynamicsWorld_addAction_1 = b.asm.nd).apply(null, arguments)
          }
          , nf = b._emscripten_bind_btDiscreteDynamicsWorld_removeAction_1 = function() {
            return (nf = b._emscripten_bind_btDiscreteDynamicsWorld_removeAction_1 = b.asm.od).apply(null, arguments)
          }
          , of = b._emscripten_bind_btDiscreteDynamicsWorld_getSolverInfo_0 = function() {
            return (of = b._emscripten_bind_btDiscreteDynamicsWorld_getSolverInfo_0 = b.asm.pd).apply(null, arguments)
          }
          , pf = b._emscripten_bind_btDiscreteDynamicsWorld_setInternalTickCallback_1 = function() {
            return (pf = b._emscripten_bind_btDiscreteDynamicsWorld_setInternalTickCallback_1 = b.asm.qd).apply(null, arguments)
          }
          , qf = b._emscripten_bind_btDiscreteDynamicsWorld_setInternalTickCallback_2 = function() {
            return (qf = b._emscripten_bind_btDiscreteDynamicsWorld_setInternalTickCallback_2 = b.asm.rd).apply(null, arguments)
          }
          , rf = b._emscripten_bind_btDiscreteDynamicsWorld_setInternalTickCallback_3 = function() {
            return (rf = b._emscripten_bind_btDiscreteDynamicsWorld_setInternalTickCallback_3 = b.asm.sd).apply(null, arguments)
          }
          , sf = b._emscripten_bind_btDiscreteDynamicsWorld___destroy___0 = function() {
            return (sf = b._emscripten_bind_btDiscreteDynamicsWorld___destroy___0 = b.asm.td).apply(null, arguments)
          }
          , tf = b._emscripten_bind_btConvexShape_setLocalScaling_1 = function() {
            return (tf = b._emscripten_bind_btConvexShape_setLocalScaling_1 = b.asm.ud).apply(null, arguments)
          }
          , uf = b._emscripten_bind_btConvexShape_getLocalScaling_0 = function() {
            return (uf = b._emscripten_bind_btConvexShape_getLocalScaling_0 = b.asm.vd).apply(null, arguments)
          }
          , vf = b._emscripten_bind_btConvexShape_calculateLocalInertia_2 = function() {
            return (vf = b._emscripten_bind_btConvexShape_calculateLocalInertia_2 = b.asm.wd).apply(null, arguments)
          }
          , wf = b._emscripten_bind_btConvexShape_setMargin_1 = function() {
            return (wf = b._emscripten_bind_btConvexShape_setMargin_1 = b.asm.xd).apply(null, arguments)
          }
          , xf = b._emscripten_bind_btConvexShape_getMargin_0 = function() {
            return (xf = b._emscripten_bind_btConvexShape_getMargin_0 = b.asm.yd).apply(null, arguments)
          }
          , yf = b._emscripten_bind_btConvexShape___destroy___0 = function() {
            return (yf = b._emscripten_bind_btConvexShape___destroy___0 = b.asm.zd).apply(null, arguments)
          }
          , zf = b._emscripten_bind_btDispatcher_getNumManifolds_0 = function() {
            return (zf = b._emscripten_bind_btDispatcher_getNumManifolds_0 = b.asm.Ad).apply(null, arguments)
          }
          , Af = b._emscripten_bind_btDispatcher_getManifoldByIndexInternal_1 = function() {
            return (Af = b._emscripten_bind_btDispatcher_getManifoldByIndexInternal_1 = b.asm.Bd).apply(null, arguments)
          }
          , Bf = b._emscripten_bind_btDispatcher___destroy___0 = function() {
            return (Bf = b._emscripten_bind_btDispatcher___destroy___0 = b.asm.Cd).apply(null, arguments)
          }
          , Cf = b._emscripten_bind_btGeneric6DofConstraint_btGeneric6DofConstraint_3 = function() {
            return (Cf = b._emscripten_bind_btGeneric6DofConstraint_btGeneric6DofConstraint_3 = b.asm.Dd).apply(null, arguments)
          }
          , Df = b._emscripten_bind_btGeneric6DofConstraint_btGeneric6DofConstraint_5 = function() {
            return (Df = b._emscripten_bind_btGeneric6DofConstraint_btGeneric6DofConstraint_5 = b.asm.Ed).apply(null, arguments)
          }
          , Ef = b._emscripten_bind_btGeneric6DofConstraint_setLinearLowerLimit_1 = function() {
            return (Ef = b._emscripten_bind_btGeneric6DofConstraint_setLinearLowerLimit_1 = b.asm.Fd).apply(null, arguments)
          }
          , Ff = b._emscripten_bind_btGeneric6DofConstraint_setLinearUpperLimit_1 = function() {
            return (Ff = b._emscripten_bind_btGeneric6DofConstraint_setLinearUpperLimit_1 = b.asm.Gd).apply(null, arguments)
          }
          , Gf = b._emscripten_bind_btGeneric6DofConstraint_setAngularLowerLimit_1 = function() {
            return (Gf = b._emscripten_bind_btGeneric6DofConstraint_setAngularLowerLimit_1 = b.asm.Hd).apply(null, arguments)
          }
          , Hf = b._emscripten_bind_btGeneric6DofConstraint_setAngularUpperLimit_1 = function() {
            return (Hf = b._emscripten_bind_btGeneric6DofConstraint_setAngularUpperLimit_1 = b.asm.Id).apply(null, arguments)
          }
          , If = b._emscripten_bind_btGeneric6DofConstraint_getFrameOffsetA_0 = function() {
            return (If = b._emscripten_bind_btGeneric6DofConstraint_getFrameOffsetA_0 = b.asm.Jd).apply(null, arguments)
          }
          , Jf = b._emscripten_bind_btGeneric6DofConstraint_enableFeedback_1 = function() {
            return (Jf = b._emscripten_bind_btGeneric6DofConstraint_enableFeedback_1 = b.asm.Kd).apply(null, arguments)
          }
          , Kf = b._emscripten_bind_btGeneric6DofConstraint_getBreakingImpulseThreshold_0 = function() {
            return (Kf = b._emscripten_bind_btGeneric6DofConstraint_getBreakingImpulseThreshold_0 = b.asm.Ld).apply(null, arguments)
          }
          , Lf = b._emscripten_bind_btGeneric6DofConstraint_setBreakingImpulseThreshold_1 = function() {
            return (Lf = b._emscripten_bind_btGeneric6DofConstraint_setBreakingImpulseThreshold_1 = b.asm.Md).apply(null, arguments)
          }
          , Mf = b._emscripten_bind_btGeneric6DofConstraint_getParam_2 = function() {
            return (Mf = b._emscripten_bind_btGeneric6DofConstraint_getParam_2 = b.asm.Nd).apply(null, arguments)
          }
          , Nf = b._emscripten_bind_btGeneric6DofConstraint_setParam_3 = function() {
            return (Nf = b._emscripten_bind_btGeneric6DofConstraint_setParam_3 = b.asm.Od).apply(null, arguments)
          }
          , Of = b._emscripten_bind_btGeneric6DofConstraint___destroy___0 = function() {
            return (Of = b._emscripten_bind_btGeneric6DofConstraint___destroy___0 = b.asm.Pd).apply(null, arguments)
          }
          , Pf = b._emscripten_bind_btStridingMeshInterface_setScaling_1 = function() {
            return (Pf = b._emscripten_bind_btStridingMeshInterface_setScaling_1 = b.asm.Qd).apply(null, arguments)
          }
          , Qf = b._emscripten_bind_btStridingMeshInterface___destroy___0 = function() {
            return (Qf = b._emscripten_bind_btStridingMeshInterface___destroy___0 = b.asm.Rd).apply(null, arguments)
          }
          , Rf = b._emscripten_bind_btMotionState_getWorldTransform_1 = function() {
            return (Rf = b._emscripten_bind_btMotionState_getWorldTransform_1 = b.asm.Sd).apply(null, arguments)
          }
          , Sf = b._emscripten_bind_btMotionState_setWorldTransform_1 = function() {
            return (Sf = b._emscripten_bind_btMotionState_setWorldTransform_1 = b.asm.Td).apply(null, arguments)
          }
          , Tf = b._emscripten_bind_btMotionState___destroy___0 = function() {
            return (Tf = b._emscripten_bind_btMotionState___destroy___0 = b.asm.Ud).apply(null, arguments)
          }
          , Uf = b._emscripten_bind_ConvexResultCallback_hasHit_0 = function() {
            return (Uf = b._emscripten_bind_ConvexResultCallback_hasHit_0 = b.asm.Vd).apply(null, arguments)
          }
          , Vf = b._emscripten_bind_ConvexResultCallback_get_m_collisionFilterGroup_0 = function() {
            return (Vf = b._emscripten_bind_ConvexResultCallback_get_m_collisionFilterGroup_0 = b.asm.Wd).apply(null, arguments)
          }
          , Wf = b._emscripten_bind_ConvexResultCallback_set_m_collisionFilterGroup_1 = function() {
            return (Wf = b._emscripten_bind_ConvexResultCallback_set_m_collisionFilterGroup_1 = b.asm.Xd).apply(null, arguments)
          }
          , Xf = b._emscripten_bind_ConvexResultCallback_get_m_collisionFilterMask_0 = function() {
            return (Xf = b._emscripten_bind_ConvexResultCallback_get_m_collisionFilterMask_0 = b.asm.Yd).apply(null, arguments)
          }
          , Yf = b._emscripten_bind_ConvexResultCallback_set_m_collisionFilterMask_1 = function() {
            return (Yf = b._emscripten_bind_ConvexResultCallback_set_m_collisionFilterMask_1 = b.asm.Zd).apply(null, arguments)
          }
          , Zf = b._emscripten_bind_ConvexResultCallback_get_m_closestHitFraction_0 = function() {
            return (Zf = b._emscripten_bind_ConvexResultCallback_get_m_closestHitFraction_0 = b.asm._d).apply(null, arguments)
          }
          , $f = b._emscripten_bind_ConvexResultCallback_set_m_closestHitFraction_1 = function() {
            return ($f = b._emscripten_bind_ConvexResultCallback_set_m_closestHitFraction_1 = b.asm.$d).apply(null, arguments)
          }
          , ag = b._emscripten_bind_ConvexResultCallback___destroy___0 = function() {
            return (ag = b._emscripten_bind_ConvexResultCallback___destroy___0 = b.asm.ae).apply(null, arguments)
          }
          , bg = b._emscripten_bind_ContactResultCallback_addSingleResult_7 = function() {
            return (bg = b._emscripten_bind_ContactResultCallback_addSingleResult_7 = b.asm.be).apply(null, arguments)
          }
          , cg = b._emscripten_bind_ContactResultCallback___destroy___0 = function() {
            return (cg = b._emscripten_bind_ContactResultCallback___destroy___0 = b.asm.ce).apply(null, arguments)
          }
          , dg = b._emscripten_bind_btSoftBodySolver___destroy___0 = function() {
            return (dg = b._emscripten_bind_btSoftBodySolver___destroy___0 = b.asm.de).apply(null, arguments)
          }
          , eg = b._emscripten_bind_RayResultCallback_hasHit_0 = function() {
            return (eg = b._emscripten_bind_RayResultCallback_hasHit_0 = b.asm.ee).apply(null, arguments)
          }
          , fg = b._emscripten_bind_RayResultCallback_get_m_collisionFilterGroup_0 = function() {
            return (fg = b._emscripten_bind_RayResultCallback_get_m_collisionFilterGroup_0 = b.asm.fe).apply(null, arguments)
          }
          , gg = b._emscripten_bind_RayResultCallback_set_m_collisionFilterGroup_1 = function() {
            return (gg = b._emscripten_bind_RayResultCallback_set_m_collisionFilterGroup_1 = b.asm.ge).apply(null, arguments)
          }
          , hg = b._emscripten_bind_RayResultCallback_get_m_collisionFilterMask_0 = function() {
            return (hg = b._emscripten_bind_RayResultCallback_get_m_collisionFilterMask_0 = b.asm.he).apply(null, arguments)
          }
          , ig = b._emscripten_bind_RayResultCallback_set_m_collisionFilterMask_1 = function() {
            return (ig = b._emscripten_bind_RayResultCallback_set_m_collisionFilterMask_1 = b.asm.ie).apply(null, arguments)
          }
          , jg = b._emscripten_bind_RayResultCallback_get_m_closestHitFraction_0 = function() {
            return (jg = b._emscripten_bind_RayResultCallback_get_m_closestHitFraction_0 = b.asm.je).apply(null, arguments)
          }
          , kg = b._emscripten_bind_RayResultCallback_set_m_closestHitFraction_1 = function() {
            return (kg = b._emscripten_bind_RayResultCallback_set_m_closestHitFraction_1 = b.asm.ke).apply(null, arguments)
          }
          , lg = b._emscripten_bind_RayResultCallback_get_m_collisionObject_0 = function() {
            return (lg = b._emscripten_bind_RayResultCallback_get_m_collisionObject_0 = b.asm.le).apply(null, arguments)
          }
          , mg = b._emscripten_bind_RayResultCallback_set_m_collisionObject_1 = function() {
            return (mg = b._emscripten_bind_RayResultCallback_set_m_collisionObject_1 = b.asm.me).apply(null, arguments)
          }
          , ng = b._emscripten_bind_RayResultCallback___destroy___0 = function() {
            return (ng = b._emscripten_bind_RayResultCallback___destroy___0 = b.asm.ne).apply(null, arguments)
          }
          , og = b._emscripten_bind_btMatrix3x3_setEulerZYX_3 = function() {
            return (og = b._emscripten_bind_btMatrix3x3_setEulerZYX_3 = b.asm.oe).apply(null, arguments)
          }
          , pg = b._emscripten_bind_btMatrix3x3_getRotation_1 = function() {
            return (pg = b._emscripten_bind_btMatrix3x3_getRotation_1 = b.asm.pe).apply(null, arguments)
          }
          , qg = b._emscripten_bind_btMatrix3x3_getRow_1 = function() {
            return (qg = b._emscripten_bind_btMatrix3x3_getRow_1 = b.asm.qe).apply(null, arguments)
          }
          , rg = b._emscripten_bind_btMatrix3x3___destroy___0 = function() {
            return (rg = b._emscripten_bind_btMatrix3x3___destroy___0 = b.asm.re).apply(null, arguments)
          }
          , sg = b._emscripten_bind_btScalarArray_size_0 = function() {
            return (sg = b._emscripten_bind_btScalarArray_size_0 = b.asm.se).apply(null, arguments)
          }
          , tg = b._emscripten_bind_btScalarArray_at_1 = function() {
            return (tg = b._emscripten_bind_btScalarArray_at_1 = b.asm.te).apply(null, arguments)
          }
          , ug = b._emscripten_bind_btScalarArray___destroy___0 = function() {
            return (ug = b._emscripten_bind_btScalarArray___destroy___0 = b.asm.ue).apply(null, arguments)
          }
          , vg = b._emscripten_bind_Material_get_m_kLST_0 = function() {
            return (vg = b._emscripten_bind_Material_get_m_kLST_0 = b.asm.ve).apply(null, arguments)
          }
          , wg = b._emscripten_bind_Material_set_m_kLST_1 = function() {
            return (wg = b._emscripten_bind_Material_set_m_kLST_1 = b.asm.we).apply(null, arguments)
          }
          , xg = b._emscripten_bind_Material_get_m_kAST_0 = function() {
            return (xg = b._emscripten_bind_Material_get_m_kAST_0 = b.asm.xe).apply(null, arguments)
          }
          , yg = b._emscripten_bind_Material_set_m_kAST_1 = function() {
            return (yg = b._emscripten_bind_Material_set_m_kAST_1 = b.asm.ye).apply(null, arguments)
          }
          , zg = b._emscripten_bind_Material_get_m_kVST_0 = function() {
            return (zg = b._emscripten_bind_Material_get_m_kVST_0 = b.asm.ze).apply(null, arguments)
          }
          , Ag = b._emscripten_bind_Material_set_m_kVST_1 = function() {
            return (Ag = b._emscripten_bind_Material_set_m_kVST_1 = b.asm.Ae).apply(null, arguments)
          }
          , Bg = b._emscripten_bind_Material_get_m_flags_0 = function() {
            return (Bg = b._emscripten_bind_Material_get_m_flags_0 = b.asm.Be).apply(null, arguments)
          }
          , Cg = b._emscripten_bind_Material_set_m_flags_1 = function() {
            return (Cg = b._emscripten_bind_Material_set_m_flags_1 = b.asm.Ce).apply(null, arguments)
          }
          , Dg = b._emscripten_bind_Material___destroy___0 = function() {
            return (Dg = b._emscripten_bind_Material___destroy___0 = b.asm.De).apply(null, arguments)
          }
          , Eg = b._emscripten_bind_btDispatcherInfo_get_m_timeStep_0 = function() {
            return (Eg = b._emscripten_bind_btDispatcherInfo_get_m_timeStep_0 = b.asm.Ee).apply(null, arguments)
          }
          , Fg = b._emscripten_bind_btDispatcherInfo_set_m_timeStep_1 = function() {
            return (Fg = b._emscripten_bind_btDispatcherInfo_set_m_timeStep_1 = b.asm.Fe).apply(null, arguments)
          }
          , Gg = b._emscripten_bind_btDispatcherInfo_get_m_stepCount_0 = function() {
            return (Gg = b._emscripten_bind_btDispatcherInfo_get_m_stepCount_0 = b.asm.Ge).apply(null, arguments)
          }
          , Hg = b._emscripten_bind_btDispatcherInfo_set_m_stepCount_1 = function() {
            return (Hg = b._emscripten_bind_btDispatcherInfo_set_m_stepCount_1 = b.asm.He).apply(null, arguments)
          }
          , Ig = b._emscripten_bind_btDispatcherInfo_get_m_dispatchFunc_0 = function() {
            return (Ig = b._emscripten_bind_btDispatcherInfo_get_m_dispatchFunc_0 = b.asm.Ie).apply(null, arguments)
          }
          , Jg = b._emscripten_bind_btDispatcherInfo_set_m_dispatchFunc_1 = function() {
            return (Jg = b._emscripten_bind_btDispatcherInfo_set_m_dispatchFunc_1 = b.asm.Je).apply(null, arguments)
          }
          , Kg = b._emscripten_bind_btDispatcherInfo_get_m_timeOfImpact_0 = function() {
            return (Kg = b._emscripten_bind_btDispatcherInfo_get_m_timeOfImpact_0 = b.asm.Ke).apply(null, arguments)
          }
          , Lg = b._emscripten_bind_btDispatcherInfo_set_m_timeOfImpact_1 = function() {
            return (Lg = b._emscripten_bind_btDispatcherInfo_set_m_timeOfImpact_1 = b.asm.Le).apply(null, arguments)
          }
          , Mg = b._emscripten_bind_btDispatcherInfo_get_m_useContinuous_0 = function() {
            return (Mg = b._emscripten_bind_btDispatcherInfo_get_m_useContinuous_0 = b.asm.Me).apply(null, arguments)
          }
          , Ng = b._emscripten_bind_btDispatcherInfo_set_m_useContinuous_1 = function() {
            return (Ng = b._emscripten_bind_btDispatcherInfo_set_m_useContinuous_1 = b.asm.Ne).apply(null, arguments)
          }
          , Og = b._emscripten_bind_btDispatcherInfo_get_m_enableSatConvex_0 = function() {
            return (Og = b._emscripten_bind_btDispatcherInfo_get_m_enableSatConvex_0 = b.asm.Oe).apply(null, arguments)
          }
          , Pg = b._emscripten_bind_btDispatcherInfo_set_m_enableSatConvex_1 = function() {
            return (Pg = b._emscripten_bind_btDispatcherInfo_set_m_enableSatConvex_1 = b.asm.Pe).apply(null, arguments)
          }
          , Qg = b._emscripten_bind_btDispatcherInfo_get_m_enableSPU_0 = function() {
            return (Qg = b._emscripten_bind_btDispatcherInfo_get_m_enableSPU_0 = b.asm.Qe).apply(null, arguments)
          }
          , Rg = b._emscripten_bind_btDispatcherInfo_set_m_enableSPU_1 = function() {
            return (Rg = b._emscripten_bind_btDispatcherInfo_set_m_enableSPU_1 = b.asm.Re).apply(null, arguments)
          }
          , Sg = b._emscripten_bind_btDispatcherInfo_get_m_useEpa_0 = function() {
            return (Sg = b._emscripten_bind_btDispatcherInfo_get_m_useEpa_0 = b.asm.Se).apply(null, arguments)
          }
          , Tg = b._emscripten_bind_btDispatcherInfo_set_m_useEpa_1 = function() {
            return (Tg = b._emscripten_bind_btDispatcherInfo_set_m_useEpa_1 = b.asm.Te).apply(null, arguments)
          }
          , Ug = b._emscripten_bind_btDispatcherInfo_get_m_allowedCcdPenetration_0 = function() {
            return (Ug = b._emscripten_bind_btDispatcherInfo_get_m_allowedCcdPenetration_0 = b.asm.Ue).apply(null, arguments)
          }
          , Vg = b._emscripten_bind_btDispatcherInfo_set_m_allowedCcdPenetration_1 = function() {
            return (Vg = b._emscripten_bind_btDispatcherInfo_set_m_allowedCcdPenetration_1 = b.asm.Ve).apply(null, arguments)
          }
          , Wg = b._emscripten_bind_btDispatcherInfo_get_m_useConvexConservativeDistanceUtil_0 = function() {
            return (Wg = b._emscripten_bind_btDispatcherInfo_get_m_useConvexConservativeDistanceUtil_0 = b.asm.We).apply(null, arguments)
          }
          , Xg = b._emscripten_bind_btDispatcherInfo_set_m_useConvexConservativeDistanceUtil_1 = function() {
            return (Xg = b._emscripten_bind_btDispatcherInfo_set_m_useConvexConservativeDistanceUtil_1 = b.asm.Xe).apply(null, arguments)
          }
          , Yg = b._emscripten_bind_btDispatcherInfo_get_m_convexConservativeDistanceThreshold_0 = function() {
            return (Yg = b._emscripten_bind_btDispatcherInfo_get_m_convexConservativeDistanceThreshold_0 = b.asm.Ye).apply(null, arguments)
          }
          , Zg = b._emscripten_bind_btDispatcherInfo_set_m_convexConservativeDistanceThreshold_1 = function() {
            return (Zg = b._emscripten_bind_btDispatcherInfo_set_m_convexConservativeDistanceThreshold_1 = b.asm.Ze).apply(null, arguments)
          }
          , $g = b._emscripten_bind_btDispatcherInfo___destroy___0 = function() {
            return ($g = b._emscripten_bind_btDispatcherInfo___destroy___0 = b.asm._e).apply(null, arguments)
          }
          , ah = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_chassisConnectionCS_0 = function() {
            return (ah = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_chassisConnectionCS_0 = b.asm.$e).apply(null, arguments)
          }
          , bh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_chassisConnectionCS_1 = function() {
            return (bh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_chassisConnectionCS_1 = b.asm.af).apply(null, arguments)
          }
          , ch = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_wheelDirectionCS_0 = function() {
            return (ch = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_wheelDirectionCS_0 = b.asm.bf).apply(null, arguments)
          }
          , dh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_wheelDirectionCS_1 = function() {
            return (dh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_wheelDirectionCS_1 = b.asm.cf).apply(null, arguments)
          }
          , eh = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_wheelAxleCS_0 = function() {
            return (eh = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_wheelAxleCS_0 = b.asm.df).apply(null, arguments)
          }
          , fh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_wheelAxleCS_1 = function() {
            return (fh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_wheelAxleCS_1 = b.asm.ef).apply(null, arguments)
          }
          , gh = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_suspensionRestLength_0 = function() {
            return (gh = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_suspensionRestLength_0 = b.asm.ff).apply(null, arguments)
          }
          , hh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_suspensionRestLength_1 = function() {
            return (hh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_suspensionRestLength_1 = b.asm.gf).apply(null, arguments)
          }
          , ih = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_maxSuspensionTravelCm_0 = function() {
            return (ih = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_maxSuspensionTravelCm_0 = b.asm.hf).apply(null, arguments)
          }
          , jh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_maxSuspensionTravelCm_1 = function() {
            return (jh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_maxSuspensionTravelCm_1 = b.asm.jf).apply(null, arguments)
          }
          , kh = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_wheelRadius_0 = function() {
            return (kh = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_wheelRadius_0 = b.asm.kf).apply(null, arguments)
          }
          , lh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_wheelRadius_1 = function() {
            return (lh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_wheelRadius_1 = b.asm.lf).apply(null, arguments)
          }
          , mh = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_suspensionStiffness_0 = function() {
            return (mh = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_suspensionStiffness_0 = b.asm.mf).apply(null, arguments)
          }
          , nh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_suspensionStiffness_1 = function() {
            return (nh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_suspensionStiffness_1 = b.asm.nf).apply(null, arguments)
          }
          , oh = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_wheelsDampingCompression_0 = function() {
            return (oh = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_wheelsDampingCompression_0 = b.asm.of).apply(null, arguments)
          }
          , ph = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_wheelsDampingCompression_1 = function() {
            return (ph = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_wheelsDampingCompression_1 = b.asm.pf).apply(null, arguments)
          }
          , qh = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_wheelsDampingRelaxation_0 = function() {
            return (qh = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_wheelsDampingRelaxation_0 = b.asm.qf).apply(null, arguments)
          }
          , rh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_wheelsDampingRelaxation_1 = function() {
            return (rh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_wheelsDampingRelaxation_1 = b.asm.rf).apply(null, arguments)
          }
          , sh = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_frictionSlip_0 = function() {
            return (sh = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_frictionSlip_0 = b.asm.sf).apply(null, arguments)
          }
          , th = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_frictionSlip_1 = function() {
            return (th = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_frictionSlip_1 = b.asm.tf).apply(null, arguments)
          }
          , uh = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_maxSuspensionForce_0 = function() {
            return (uh = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_maxSuspensionForce_0 = b.asm.uf).apply(null, arguments)
          }
          , vh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_maxSuspensionForce_1 = function() {
            return (vh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_maxSuspensionForce_1 = b.asm.vf).apply(null, arguments)
          }
          , wh = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_bIsFrontWheel_0 = function() {
            return (wh = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_bIsFrontWheel_0 = b.asm.wf).apply(null, arguments)
          }
          , xh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_bIsFrontWheel_1 = function() {
            return (xh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_bIsFrontWheel_1 = b.asm.xf).apply(null, arguments)
          }
          , yh = b._emscripten_bind_btWheelInfoConstructionInfo___destroy___0 = function() {
            return (yh = b._emscripten_bind_btWheelInfoConstructionInfo___destroy___0 = b.asm.yf).apply(null, arguments)
          }
          , zh = b._emscripten_bind_btConvexTriangleMeshShape_btConvexTriangleMeshShape_1 = function() {
            return (zh = b._emscripten_bind_btConvexTriangleMeshShape_btConvexTriangleMeshShape_1 = b.asm.zf).apply(null, arguments)
          }
          , Ah = b._emscripten_bind_btConvexTriangleMeshShape_btConvexTriangleMeshShape_2 = function() {
            return (Ah = b._emscripten_bind_btConvexTriangleMeshShape_btConvexTriangleMeshShape_2 = b.asm.Af).apply(null, arguments)
          }
          , Bh = b._emscripten_bind_btConvexTriangleMeshShape_setLocalScaling_1 = function() {
            return (Bh = b._emscripten_bind_btConvexTriangleMeshShape_setLocalScaling_1 = b.asm.Bf).apply(null, arguments)
          }
          , Ch = b._emscripten_bind_btConvexTriangleMeshShape_getLocalScaling_0 = function() {
            return (Ch = b._emscripten_bind_btConvexTriangleMeshShape_getLocalScaling_0 = b.asm.Cf).apply(null, arguments)
          }
          , Dh = b._emscripten_bind_btConvexTriangleMeshShape_calculateLocalInertia_2 = function() {
            return (Dh = b._emscripten_bind_btConvexTriangleMeshShape_calculateLocalInertia_2 = b.asm.Df).apply(null, arguments)
          }
          , Eh = b._emscripten_bind_btConvexTriangleMeshShape_setMargin_1 = function() {
            return (Eh = b._emscripten_bind_btConvexTriangleMeshShape_setMargin_1 = b.asm.Ef).apply(null, arguments)
          }
          , Fh = b._emscripten_bind_btConvexTriangleMeshShape_getMargin_0 = function() {
            return (Fh = b._emscripten_bind_btConvexTriangleMeshShape_getMargin_0 = b.asm.Ff).apply(null, arguments)
          }
          , Gh = b._emscripten_bind_btConvexTriangleMeshShape___destroy___0 = function() {
            return (Gh = b._emscripten_bind_btConvexTriangleMeshShape___destroy___0 = b.asm.Gf).apply(null, arguments)
          }
          , Hh = b._emscripten_bind_btBroadphaseInterface_getOverlappingPairCache_0 = function() {
            return (Hh = b._emscripten_bind_btBroadphaseInterface_getOverlappingPairCache_0 = b.asm.Hf).apply(null, arguments)
          }
          , Ih = b._emscripten_bind_btBroadphaseInterface___destroy___0 = function() {
            return (Ih = b._emscripten_bind_btBroadphaseInterface___destroy___0 = b.asm.If).apply(null, arguments)
          }
          , Jh = b._emscripten_bind_btRigidBodyConstructionInfo_btRigidBodyConstructionInfo_3 = function() {
            return (Jh = b._emscripten_bind_btRigidBodyConstructionInfo_btRigidBodyConstructionInfo_3 = b.asm.Jf).apply(null, arguments)
          }
          , Kh = b._emscripten_bind_btRigidBodyConstructionInfo_btRigidBodyConstructionInfo_4 = function() {
            return (Kh = b._emscripten_bind_btRigidBodyConstructionInfo_btRigidBodyConstructionInfo_4 = b.asm.Kf).apply(null, arguments)
          }
          , Lh = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_linearDamping_0 = function() {
            return (Lh = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_linearDamping_0 = b.asm.Lf).apply(null, arguments)
          }
          , Mh = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_linearDamping_1 = function() {
            return (Mh = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_linearDamping_1 = b.asm.Mf).apply(null, arguments)
          }
          , Nh = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_angularDamping_0 = function() {
            return (Nh = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_angularDamping_0 = b.asm.Nf).apply(null, arguments)
          }
          , Oh = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_angularDamping_1 = function() {
            return (Oh = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_angularDamping_1 = b.asm.Of).apply(null, arguments)
          }
          , Ph = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_friction_0 = function() {
            return (Ph = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_friction_0 = b.asm.Pf).apply(null, arguments)
          }
          , Qh = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_friction_1 = function() {
            return (Qh = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_friction_1 = b.asm.Qf).apply(null, arguments)
          }
          , Rh = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_rollingFriction_0 = function() {
            return (Rh = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_rollingFriction_0 = b.asm.Rf).apply(null, arguments)
          }
          , Sh = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_rollingFriction_1 = function() {
            return (Sh = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_rollingFriction_1 = b.asm.Sf).apply(null, arguments)
          }
          , Th = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_restitution_0 = function() {
            return (Th = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_restitution_0 = b.asm.Tf).apply(null, arguments)
          }
          , Uh = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_restitution_1 = function() {
            return (Uh = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_restitution_1 = b.asm.Uf).apply(null, arguments)
          }
          , Vh = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_linearSleepingThreshold_0 = function() {
            return (Vh = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_linearSleepingThreshold_0 = b.asm.Vf).apply(null, arguments)
          }
          , Wh = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_linearSleepingThreshold_1 = function() {
            return (Wh = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_linearSleepingThreshold_1 = b.asm.Wf).apply(null, arguments)
          }
          , Xh = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_angularSleepingThreshold_0 = function() {
            return (Xh = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_angularSleepingThreshold_0 = b.asm.Xf).apply(null, arguments)
          }
          , Yh = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_angularSleepingThreshold_1 = function() {
            return (Yh = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_angularSleepingThreshold_1 = b.asm.Yf).apply(null, arguments)
          }
          , Zh = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_additionalDamping_0 = function() {
            return (Zh = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_additionalDamping_0 = b.asm.Zf).apply(null, arguments)
          }
          , $h = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_additionalDamping_1 = function() {
            return ($h = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_additionalDamping_1 = b.asm._f).apply(null, arguments)
          }
          , ai = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_additionalDampingFactor_0 = function() {
            return (ai = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_additionalDampingFactor_0 = b.asm.$f).apply(null, arguments)
          }
          , bi = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_additionalDampingFactor_1 = function() {
            return (bi = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_additionalDampingFactor_1 = b.asm.ag).apply(null, arguments)
          }
          , ci = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_additionalLinearDampingThresholdSqr_0 = function() {
            return (ci = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_additionalLinearDampingThresholdSqr_0 = b.asm.bg).apply(null, arguments)
          }
          , di = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_additionalLinearDampingThresholdSqr_1 = function() {
            return (di = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_additionalLinearDampingThresholdSqr_1 = b.asm.cg).apply(null, arguments)
          }
          , ei = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_additionalAngularDampingThresholdSqr_0 = function() {
            return (ei = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_additionalAngularDampingThresholdSqr_0 = b.asm.dg).apply(null, arguments)
          }
          , fi = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_additionalAngularDampingThresholdSqr_1 = function() {
            return (fi = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_additionalAngularDampingThresholdSqr_1 = b.asm.eg).apply(null, arguments)
          }
          , gi = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_additionalAngularDampingFactor_0 = function() {
            return (gi = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_additionalAngularDampingFactor_0 = b.asm.fg).apply(null, arguments)
          }
          , hi = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_additionalAngularDampingFactor_1 = function() {
            return (hi = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_additionalAngularDampingFactor_1 = b.asm.gg).apply(null, arguments)
          }
          , ii = b._emscripten_bind_btRigidBodyConstructionInfo___destroy___0 = function() {
            return (ii = b._emscripten_bind_btRigidBodyConstructionInfo___destroy___0 = b.asm.hg).apply(null, arguments)
          }
          , ji = b._emscripten_bind_btCollisionConfiguration___destroy___0 = function() {
            return (ji = b._emscripten_bind_btCollisionConfiguration___destroy___0 = b.asm.ig).apply(null, arguments)
          }
          , ki = b._emscripten_bind_btPersistentManifold_btPersistentManifold_0 = function() {
            return (ki = b._emscripten_bind_btPersistentManifold_btPersistentManifold_0 = b.asm.jg).apply(null, arguments)
          }
          , li = b._emscripten_bind_btPersistentManifold_getBody0_0 = function() {
            return (li = b._emscripten_bind_btPersistentManifold_getBody0_0 = b.asm.kg).apply(null, arguments)
          }
          , mi = b._emscripten_bind_btPersistentManifold_getBody1_0 = function() {
            return (mi = b._emscripten_bind_btPersistentManifold_getBody1_0 = b.asm.lg).apply(null, arguments)
          }
          , ni = b._emscripten_bind_btPersistentManifold_getNumContacts_0 = function() {
            return (ni = b._emscripten_bind_btPersistentManifold_getNumContacts_0 = b.asm.mg).apply(null, arguments)
          }
          , oi = b._emscripten_bind_btPersistentManifold_getContactPoint_1 = function() {
            return (oi = b._emscripten_bind_btPersistentManifold_getContactPoint_1 = b.asm.ng).apply(null, arguments)
          }
          , pi = b._emscripten_bind_btPersistentManifold___destroy___0 = function() {
            return (pi = b._emscripten_bind_btPersistentManifold___destroy___0 = b.asm.og).apply(null, arguments)
          }
          , qi = b._emscripten_bind_btCompoundShape_btCompoundShape_0 = function() {
            return (qi = b._emscripten_bind_btCompoundShape_btCompoundShape_0 = b.asm.pg).apply(null, arguments)
          }
          , ri = b._emscripten_bind_btCompoundShape_btCompoundShape_1 = function() {
            return (ri = b._emscripten_bind_btCompoundShape_btCompoundShape_1 = b.asm.qg).apply(null, arguments)
          }
          , si = b._emscripten_bind_btCompoundShape_addChildShape_2 = function() {
            return (si = b._emscripten_bind_btCompoundShape_addChildShape_2 = b.asm.rg).apply(null, arguments)
          }
          , ti = b._emscripten_bind_btCompoundShape_removeChildShape_1 = function() {
            return (ti = b._emscripten_bind_btCompoundShape_removeChildShape_1 = b.asm.sg).apply(null, arguments)
          }
          , ui = b._emscripten_bind_btCompoundShape_removeChildShapeByIndex_1 = function() {
            return (ui = b._emscripten_bind_btCompoundShape_removeChildShapeByIndex_1 = b.asm.tg).apply(null, arguments)
          }
          , vi = b._emscripten_bind_btCompoundShape_getNumChildShapes_0 = function() {
            return (vi = b._emscripten_bind_btCompoundShape_getNumChildShapes_0 = b.asm.ug).apply(null, arguments)
          }
          , wi = b._emscripten_bind_btCompoundShape_getChildShape_1 = function() {
            return (wi = b._emscripten_bind_btCompoundShape_getChildShape_1 = b.asm.vg).apply(null, arguments)
          }
          , xi = b._emscripten_bind_btCompoundShape_updateChildTransform_2 = function() {
            return (xi = b._emscripten_bind_btCompoundShape_updateChildTransform_2 = b.asm.wg).apply(null, arguments)
          }
          , yi = b._emscripten_bind_btCompoundShape_updateChildTransform_3 = function() {
            return (yi = b._emscripten_bind_btCompoundShape_updateChildTransform_3 = b.asm.xg).apply(null, arguments)
          }
          , zi = b._emscripten_bind_btCompoundShape_setMargin_1 = function() {
            return (zi = b._emscripten_bind_btCompoundShape_setMargin_1 = b.asm.yg).apply(null, arguments)
          }
          , Ai = b._emscripten_bind_btCompoundShape_getMargin_0 = function() {
            return (Ai = b._emscripten_bind_btCompoundShape_getMargin_0 = b.asm.zg).apply(null, arguments)
          }
          , Bi = b._emscripten_bind_btCompoundShape_setLocalScaling_1 = function() {
            return (Bi = b._emscripten_bind_btCompoundShape_setLocalScaling_1 = b.asm.Ag).apply(null, arguments)
          }
          , Ci = b._emscripten_bind_btCompoundShape_getLocalScaling_0 = function() {
            return (Ci = b._emscripten_bind_btCompoundShape_getLocalScaling_0 = b.asm.Bg).apply(null, arguments)
          }
          , Di = b._emscripten_bind_btCompoundShape_calculateLocalInertia_2 = function() {
            return (Di = b._emscripten_bind_btCompoundShape_calculateLocalInertia_2 = b.asm.Cg).apply(null, arguments)
          }
          , Ei = b._emscripten_bind_btCompoundShape___destroy___0 = function() {
            return (Ei = b._emscripten_bind_btCompoundShape___destroy___0 = b.asm.Dg).apply(null, arguments)
          }
          , Fi = b._emscripten_bind_ClosestConvexResultCallback_ClosestConvexResultCallback_2 = function() {
            return (Fi = b._emscripten_bind_ClosestConvexResultCallback_ClosestConvexResultCallback_2 = b.asm.Eg).apply(null, arguments)
          }
          , Gi = b._emscripten_bind_ClosestConvexResultCallback_hasHit_0 = function() {
            return (Gi = b._emscripten_bind_ClosestConvexResultCallback_hasHit_0 = b.asm.Fg).apply(null, arguments)
          }
          , Hi = b._emscripten_bind_ClosestConvexResultCallback_get_m_convexFromWorld_0 = function() {
            return (Hi = b._emscripten_bind_ClosestConvexResultCallback_get_m_convexFromWorld_0 = b.asm.Gg).apply(null, arguments)
          }
          , Ii = b._emscripten_bind_ClosestConvexResultCallback_set_m_convexFromWorld_1 = function() {
            return (Ii = b._emscripten_bind_ClosestConvexResultCallback_set_m_convexFromWorld_1 = b.asm.Hg).apply(null, arguments)
          }
          , Ji = b._emscripten_bind_ClosestConvexResultCallback_get_m_convexToWorld_0 = function() {
            return (Ji = b._emscripten_bind_ClosestConvexResultCallback_get_m_convexToWorld_0 = b.asm.Ig).apply(null, arguments)
          }
          , Ki = b._emscripten_bind_ClosestConvexResultCallback_set_m_convexToWorld_1 = function() {
            return (Ki = b._emscripten_bind_ClosestConvexResultCallback_set_m_convexToWorld_1 = b.asm.Jg).apply(null, arguments)
          }
          , Li = b._emscripten_bind_ClosestConvexResultCallback_get_m_hitNormalWorld_0 = function() {
            return (Li = b._emscripten_bind_ClosestConvexResultCallback_get_m_hitNormalWorld_0 = b.asm.Kg).apply(null, arguments)
          }
          , Mi = b._emscripten_bind_ClosestConvexResultCallback_set_m_hitNormalWorld_1 = function() {
            return (Mi = b._emscripten_bind_ClosestConvexResultCallback_set_m_hitNormalWorld_1 = b.asm.Lg).apply(null, arguments)
          }
          , Ni = b._emscripten_bind_ClosestConvexResultCallback_get_m_hitPointWorld_0 = function() {
            return (Ni = b._emscripten_bind_ClosestConvexResultCallback_get_m_hitPointWorld_0 = b.asm.Mg).apply(null, arguments)
          }
          , Oi = b._emscripten_bind_ClosestConvexResultCallback_set_m_hitPointWorld_1 = function() {
            return (Oi = b._emscripten_bind_ClosestConvexResultCallback_set_m_hitPointWorld_1 = b.asm.Ng).apply(null, arguments)
          }
          , Pi = b._emscripten_bind_ClosestConvexResultCallback_get_m_collisionFilterGroup_0 = function() {
            return (Pi = b._emscripten_bind_ClosestConvexResultCallback_get_m_collisionFilterGroup_0 = b.asm.Og).apply(null, arguments)
          }
          , Qi = b._emscripten_bind_ClosestConvexResultCallback_set_m_collisionFilterGroup_1 = function() {
            return (Qi = b._emscripten_bind_ClosestConvexResultCallback_set_m_collisionFilterGroup_1 = b.asm.Pg).apply(null, arguments)
          }
          , Ri = b._emscripten_bind_ClosestConvexResultCallback_get_m_collisionFilterMask_0 = function() {
            return (Ri = b._emscripten_bind_ClosestConvexResultCallback_get_m_collisionFilterMask_0 = b.asm.Qg).apply(null, arguments)
          }
          , Si = b._emscripten_bind_ClosestConvexResultCallback_set_m_collisionFilterMask_1 = function() {
            return (Si = b._emscripten_bind_ClosestConvexResultCallback_set_m_collisionFilterMask_1 = b.asm.Rg).apply(null, arguments)
          }
          , Ti = b._emscripten_bind_ClosestConvexResultCallback_get_m_closestHitFraction_0 = function() {
            return (Ti = b._emscripten_bind_ClosestConvexResultCallback_get_m_closestHitFraction_0 = b.asm.Sg).apply(null, arguments)
          }
          , Ui = b._emscripten_bind_ClosestConvexResultCallback_set_m_closestHitFraction_1 = function() {
            return (Ui = b._emscripten_bind_ClosestConvexResultCallback_set_m_closestHitFraction_1 = b.asm.Tg).apply(null, arguments)
          }
          , Vi = b._emscripten_bind_ClosestConvexResultCallback___destroy___0 = function() {
            return (Vi = b._emscripten_bind_ClosestConvexResultCallback___destroy___0 = b.asm.Ug).apply(null, arguments)
          }
          , Wi = b._emscripten_bind_AllHitsRayResultCallback_AllHitsRayResultCallback_2 = function() {
            return (Wi = b._emscripten_bind_AllHitsRayResultCallback_AllHitsRayResultCallback_2 = b.asm.Vg).apply(null, arguments)
          }
          , Xi = b._emscripten_bind_AllHitsRayResultCallback_hasHit_0 = function() {
            return (Xi = b._emscripten_bind_AllHitsRayResultCallback_hasHit_0 = b.asm.Wg).apply(null, arguments)
          }
          , Yi = b._emscripten_bind_AllHitsRayResultCallback_get_m_collisionObjects_0 = function() {
            return (Yi = b._emscripten_bind_AllHitsRayResultCallback_get_m_collisionObjects_0 = b.asm.Xg).apply(null, arguments)
          }
          , Zi = b._emscripten_bind_AllHitsRayResultCallback_set_m_collisionObjects_1 = function() {
            return (Zi = b._emscripten_bind_AllHitsRayResultCallback_set_m_collisionObjects_1 = b.asm.Yg).apply(null, arguments)
          }
          , $i = b._emscripten_bind_AllHitsRayResultCallback_get_m_rayFromWorld_0 = function() {
            return ($i = b._emscripten_bind_AllHitsRayResultCallback_get_m_rayFromWorld_0 = b.asm.Zg).apply(null, arguments)
          }
          , aj = b._emscripten_bind_AllHitsRayResultCallback_set_m_rayFromWorld_1 = function() {
            return (aj = b._emscripten_bind_AllHitsRayResultCallback_set_m_rayFromWorld_1 = b.asm._g).apply(null, arguments)
          }
          , bj = b._emscripten_bind_AllHitsRayResultCallback_get_m_rayToWorld_0 = function() {
            return (bj = b._emscripten_bind_AllHitsRayResultCallback_get_m_rayToWorld_0 = b.asm.$g).apply(null, arguments)
          }
          , cj = b._emscripten_bind_AllHitsRayResultCallback_set_m_rayToWorld_1 = function() {
            return (cj = b._emscripten_bind_AllHitsRayResultCallback_set_m_rayToWorld_1 = b.asm.ah).apply(null, arguments)
          }
          , dj = b._emscripten_bind_AllHitsRayResultCallback_get_m_hitNormalWorld_0 = function() {
            return (dj = b._emscripten_bind_AllHitsRayResultCallback_get_m_hitNormalWorld_0 = b.asm.bh).apply(null, arguments)
          }
          , ej = b._emscripten_bind_AllHitsRayResultCallback_set_m_hitNormalWorld_1 = function() {
            return (ej = b._emscripten_bind_AllHitsRayResultCallback_set_m_hitNormalWorld_1 = b.asm.ch).apply(null, arguments)
          }
          , fj = b._emscripten_bind_AllHitsRayResultCallback_get_m_hitPointWorld_0 = function() {
            return (fj = b._emscripten_bind_AllHitsRayResultCallback_get_m_hitPointWorld_0 = b.asm.dh).apply(null, arguments)
          }
          , gj = b._emscripten_bind_AllHitsRayResultCallback_set_m_hitPointWorld_1 = function() {
            return (gj = b._emscripten_bind_AllHitsRayResultCallback_set_m_hitPointWorld_1 = b.asm.eh).apply(null, arguments)
          }
          , hj = b._emscripten_bind_AllHitsRayResultCallback_get_m_hitFractions_0 = function() {
            return (hj = b._emscripten_bind_AllHitsRayResultCallback_get_m_hitFractions_0 = b.asm.fh).apply(null, arguments)
          }
          , ij = b._emscripten_bind_AllHitsRayResultCallback_set_m_hitFractions_1 = function() {
            return (ij = b._emscripten_bind_AllHitsRayResultCallback_set_m_hitFractions_1 = b.asm.gh).apply(null, arguments)
          }
          , jj = b._emscripten_bind_AllHitsRayResultCallback_get_m_collisionFilterGroup_0 = function() {
            return (jj = b._emscripten_bind_AllHitsRayResultCallback_get_m_collisionFilterGroup_0 = b.asm.hh).apply(null, arguments)
          }
          , kj = b._emscripten_bind_AllHitsRayResultCallback_set_m_collisionFilterGroup_1 = function() {
            return (kj = b._emscripten_bind_AllHitsRayResultCallback_set_m_collisionFilterGroup_1 = b.asm.ih).apply(null, arguments)
          }
          , lj = b._emscripten_bind_AllHitsRayResultCallback_get_m_collisionFilterMask_0 = function() {
            return (lj = b._emscripten_bind_AllHitsRayResultCallback_get_m_collisionFilterMask_0 = b.asm.jh).apply(null, arguments)
          }
          , mj = b._emscripten_bind_AllHitsRayResultCallback_set_m_collisionFilterMask_1 = function() {
            return (mj = b._emscripten_bind_AllHitsRayResultCallback_set_m_collisionFilterMask_1 = b.asm.kh).apply(null, arguments)
          }
          , nj = b._emscripten_bind_AllHitsRayResultCallback_get_m_closestHitFraction_0 = function() {
            return (nj = b._emscripten_bind_AllHitsRayResultCallback_get_m_closestHitFraction_0 = b.asm.lh).apply(null, arguments)
          }
          , oj = b._emscripten_bind_AllHitsRayResultCallback_set_m_closestHitFraction_1 = function() {
            return (oj = b._emscripten_bind_AllHitsRayResultCallback_set_m_closestHitFraction_1 = b.asm.mh).apply(null, arguments)
          }
          , pj = b._emscripten_bind_AllHitsRayResultCallback_get_m_collisionObject_0 = function() {
            return (pj = b._emscripten_bind_AllHitsRayResultCallback_get_m_collisionObject_0 = b.asm.nh).apply(null, arguments)
          }
          , qj = b._emscripten_bind_AllHitsRayResultCallback_set_m_collisionObject_1 = function() {
            return (qj = b._emscripten_bind_AllHitsRayResultCallback_set_m_collisionObject_1 = b.asm.oh).apply(null, arguments)
          }
          , rj = b._emscripten_bind_AllHitsRayResultCallback___destroy___0 = function() {
            return (rj = b._emscripten_bind_AllHitsRayResultCallback___destroy___0 = b.asm.ph).apply(null, arguments)
          }
          , sj = b._emscripten_bind_tMaterialArray_size_0 = function() {
            return (sj = b._emscripten_bind_tMaterialArray_size_0 = b.asm.qh).apply(null, arguments)
          }
          , tj = b._emscripten_bind_tMaterialArray_at_1 = function() {
            return (tj = b._emscripten_bind_tMaterialArray_at_1 = b.asm.rh).apply(null, arguments)
          }
          , uj = b._emscripten_bind_tMaterialArray___destroy___0 = function() {
            return (uj = b._emscripten_bind_tMaterialArray___destroy___0 = b.asm.sh).apply(null, arguments)
          }
          , vj = b._emscripten_bind_btDefaultVehicleRaycaster_btDefaultVehicleRaycaster_1 = function() {
            return (vj = b._emscripten_bind_btDefaultVehicleRaycaster_btDefaultVehicleRaycaster_1 = b.asm.th).apply(null, arguments)
          }
          , wj = b._emscripten_bind_btDefaultVehicleRaycaster_castRay_3 = function() {
            return (wj = b._emscripten_bind_btDefaultVehicleRaycaster_castRay_3 = b.asm.uh).apply(null, arguments)
          }
          , xj = b._emscripten_bind_btDefaultVehicleRaycaster___destroy___0 = function() {
            return (xj = b._emscripten_bind_btDefaultVehicleRaycaster___destroy___0 = b.asm.vh).apply(null, arguments)
          }
          , yj = b._emscripten_bind_btEmptyShape_btEmptyShape_0 = function() {
            return (yj = b._emscripten_bind_btEmptyShape_btEmptyShape_0 = b.asm.wh).apply(null, arguments)
          }
          , zj = b._emscripten_bind_btEmptyShape_setLocalScaling_1 = function() {
            return (zj = b._emscripten_bind_btEmptyShape_setLocalScaling_1 = b.asm.xh).apply(null, arguments)
          }
          , Aj = b._emscripten_bind_btEmptyShape_getLocalScaling_0 = function() {
            return (Aj = b._emscripten_bind_btEmptyShape_getLocalScaling_0 = b.asm.yh).apply(null, arguments)
          }
          , Bj = b._emscripten_bind_btEmptyShape_calculateLocalInertia_2 = function() {
            return (Bj = b._emscripten_bind_btEmptyShape_calculateLocalInertia_2 = b.asm.zh).apply(null, arguments)
          }
          , Cj = b._emscripten_bind_btEmptyShape___destroy___0 = function() {
            return (Cj = b._emscripten_bind_btEmptyShape___destroy___0 = b.asm.Ah).apply(null, arguments)
          }
          , Dj = b._emscripten_bind_btConstraintSetting_btConstraintSetting_0 = function() {
            return (Dj = b._emscripten_bind_btConstraintSetting_btConstraintSetting_0 = b.asm.Bh).apply(null, arguments)
          }
          , Ej = b._emscripten_bind_btConstraintSetting_get_m_tau_0 = function() {
            return (Ej = b._emscripten_bind_btConstraintSetting_get_m_tau_0 = b.asm.Ch).apply(null, arguments)
          }
          , Fj = b._emscripten_bind_btConstraintSetting_set_m_tau_1 = function() {
            return (Fj = b._emscripten_bind_btConstraintSetting_set_m_tau_1 = b.asm.Dh).apply(null, arguments)
          }
          , Gj = b._emscripten_bind_btConstraintSetting_get_m_damping_0 = function() {
            return (Gj = b._emscripten_bind_btConstraintSetting_get_m_damping_0 = b.asm.Eh).apply(null, arguments)
          }
          , Hj = b._emscripten_bind_btConstraintSetting_set_m_damping_1 = function() {
            return (Hj = b._emscripten_bind_btConstraintSetting_set_m_damping_1 = b.asm.Fh).apply(null, arguments)
          }
          , Ij = b._emscripten_bind_btConstraintSetting_get_m_impulseClamp_0 = function() {
            return (Ij = b._emscripten_bind_btConstraintSetting_get_m_impulseClamp_0 = b.asm.Gh).apply(null, arguments)
          }
          , Jj = b._emscripten_bind_btConstraintSetting_set_m_impulseClamp_1 = function() {
            return (Jj = b._emscripten_bind_btConstraintSetting_set_m_impulseClamp_1 = b.asm.Hh).apply(null, arguments)
          }
          , Kj = b._emscripten_bind_btConstraintSetting___destroy___0 = function() {
            return (Kj = b._emscripten_bind_btConstraintSetting___destroy___0 = b.asm.Ih).apply(null, arguments)
          }
          , Lj = b._emscripten_bind_LocalShapeInfo_get_m_shapePart_0 = function() {
            return (Lj = b._emscripten_bind_LocalShapeInfo_get_m_shapePart_0 = b.asm.Jh).apply(null, arguments)
          }
          , Mj = b._emscripten_bind_LocalShapeInfo_set_m_shapePart_1 = function() {
            return (Mj = b._emscripten_bind_LocalShapeInfo_set_m_shapePart_1 = b.asm.Kh).apply(null, arguments)
          }
          , Nj = b._emscripten_bind_LocalShapeInfo_get_m_triangleIndex_0 = function() {
            return (Nj = b._emscripten_bind_LocalShapeInfo_get_m_triangleIndex_0 = b.asm.Lh).apply(null, arguments)
          }
          , Oj = b._emscripten_bind_LocalShapeInfo_set_m_triangleIndex_1 = function() {
            return (Oj = b._emscripten_bind_LocalShapeInfo_set_m_triangleIndex_1 = b.asm.Mh).apply(null, arguments)
          }
          , Pj = b._emscripten_bind_LocalShapeInfo___destroy___0 = function() {
            return (Pj = b._emscripten_bind_LocalShapeInfo___destroy___0 = b.asm.Nh).apply(null, arguments)
          }
          , Qj = b._emscripten_bind_btRigidBody_btRigidBody_1 = function() {
            return (Qj = b._emscripten_bind_btRigidBody_btRigidBody_1 = b.asm.Oh).apply(null, arguments)
          }
          , Rj = b._emscripten_bind_btRigidBody_getCenterOfMassTransform_0 = function() {
            return (Rj = b._emscripten_bind_btRigidBody_getCenterOfMassTransform_0 = b.asm.Ph).apply(null, arguments)
          }
          , Sj = b._emscripten_bind_btRigidBody_setCenterOfMassTransform_1 = function() {
            return (Sj = b._emscripten_bind_btRigidBody_setCenterOfMassTransform_1 = b.asm.Qh).apply(null, arguments)
          }
          , Tj = b._emscripten_bind_btRigidBody_setSleepingThresholds_2 = function() {
            return (Tj = b._emscripten_bind_btRigidBody_setSleepingThresholds_2 = b.asm.Rh).apply(null, arguments)
          }
          , Uj = b._emscripten_bind_btRigidBody_getLinearDamping_0 = function() {
            return (Uj = b._emscripten_bind_btRigidBody_getLinearDamping_0 = b.asm.Sh).apply(null, arguments)
          }
          , Vj = b._emscripten_bind_btRigidBody_getAngularDamping_0 = function() {
            return (Vj = b._emscripten_bind_btRigidBody_getAngularDamping_0 = b.asm.Th).apply(null, arguments)
          }
          , Wj = b._emscripten_bind_btRigidBody_setDamping_2 = function() {
            return (Wj = b._emscripten_bind_btRigidBody_setDamping_2 = b.asm.Uh).apply(null, arguments)
          }
          , Xj = b._emscripten_bind_btRigidBody_setMassProps_2 = function() {
            return (Xj = b._emscripten_bind_btRigidBody_setMassProps_2 = b.asm.Vh).apply(null, arguments)
          }
          , Yj = b._emscripten_bind_btRigidBody_getLinearFactor_0 = function() {
            return (Yj = b._emscripten_bind_btRigidBody_getLinearFactor_0 = b.asm.Wh).apply(null, arguments)
          }
          , Zj = b._emscripten_bind_btRigidBody_setLinearFactor_1 = function() {
            return (Zj = b._emscripten_bind_btRigidBody_setLinearFactor_1 = b.asm.Xh).apply(null, arguments)
          }
          , ak = b._emscripten_bind_btRigidBody_applyTorque_1 = function() {
            return (ak = b._emscripten_bind_btRigidBody_applyTorque_1 = b.asm.Yh).apply(null, arguments)
          }
          , bk = b._emscripten_bind_btRigidBody_applyLocalTorque_1 = function() {
            return (bk = b._emscripten_bind_btRigidBody_applyLocalTorque_1 = b.asm.Zh).apply(null, arguments)
          }
          , ck = b._emscripten_bind_btRigidBody_applyForce_2 = function() {
            return (ck = b._emscripten_bind_btRigidBody_applyForce_2 = b.asm._h).apply(null, arguments)
          }
          , dk = b._emscripten_bind_btRigidBody_applyCentralForce_1 = function() {
            return (dk = b._emscripten_bind_btRigidBody_applyCentralForce_1 = b.asm.$h).apply(null, arguments)
          }
          , ek = b._emscripten_bind_btRigidBody_applyCentralLocalForce_1 = function() {
            return (ek = b._emscripten_bind_btRigidBody_applyCentralLocalForce_1 = b.asm.ai).apply(null, arguments)
          }
          , fk = b._emscripten_bind_btRigidBody_applyTorqueImpulse_1 = function() {
            return (fk = b._emscripten_bind_btRigidBody_applyTorqueImpulse_1 = b.asm.bi).apply(null, arguments)
          }
          , gk = b._emscripten_bind_btRigidBody_applyImpulse_2 = function() {
            return (gk = b._emscripten_bind_btRigidBody_applyImpulse_2 = b.asm.ci).apply(null, arguments)
          }
          , hk = b._emscripten_bind_btRigidBody_applyCentralImpulse_1 = function() {
            return (hk = b._emscripten_bind_btRigidBody_applyCentralImpulse_1 = b.asm.di).apply(null, arguments)
          }
          , ik = b._emscripten_bind_btRigidBody_updateInertiaTensor_0 = function() {
            return (ik = b._emscripten_bind_btRigidBody_updateInertiaTensor_0 = b.asm.ei).apply(null, arguments)
          }
          , jk = b._emscripten_bind_btRigidBody_getLinearVelocity_0 = function() {
            return (jk = b._emscripten_bind_btRigidBody_getLinearVelocity_0 = b.asm.fi).apply(null, arguments)
          }
          , kk = b._emscripten_bind_btRigidBody_getAngularVelocity_0 = function() {
            return (kk = b._emscripten_bind_btRigidBody_getAngularVelocity_0 = b.asm.gi).apply(null, arguments)
          }
          , lk = b._emscripten_bind_btRigidBody_setLinearVelocity_1 = function() {
            return (lk = b._emscripten_bind_btRigidBody_setLinearVelocity_1 = b.asm.hi).apply(null, arguments)
          }
          , mk = b._emscripten_bind_btRigidBody_setAngularVelocity_1 = function() {
            return (mk = b._emscripten_bind_btRigidBody_setAngularVelocity_1 = b.asm.ii).apply(null, arguments)
          }
          , nk = b._emscripten_bind_btRigidBody_getMotionState_0 = function() {
            return (nk = b._emscripten_bind_btRigidBody_getMotionState_0 = b.asm.ji).apply(null, arguments)
          }
          , ok = b._emscripten_bind_btRigidBody_setMotionState_1 = function() {
            return (ok = b._emscripten_bind_btRigidBody_setMotionState_1 = b.asm.ki).apply(null, arguments)
          }
          , pk = b._emscripten_bind_btRigidBody_getAngularFactor_0 = function() {
            return (pk = b._emscripten_bind_btRigidBody_getAngularFactor_0 = b.asm.li).apply(null, arguments)
          }
          , qk = b._emscripten_bind_btRigidBody_setAngularFactor_1 = function() {
            return (qk = b._emscripten_bind_btRigidBody_setAngularFactor_1 = b.asm.mi).apply(null, arguments)
          }
          , rk = b._emscripten_bind_btRigidBody_upcast_1 = function() {
            return (rk = b._emscripten_bind_btRigidBody_upcast_1 = b.asm.ni).apply(null, arguments)
          }
          , sk = b._emscripten_bind_btRigidBody_getAabb_2 = function() {
            return (sk = b._emscripten_bind_btRigidBody_getAabb_2 = b.asm.oi).apply(null, arguments)
          }
          , tk = b._emscripten_bind_btRigidBody_applyGravity_0 = function() {
            return (tk = b._emscripten_bind_btRigidBody_applyGravity_0 = b.asm.pi).apply(null, arguments)
          }
          , uk = b._emscripten_bind_btRigidBody_getGravity_0 = function() {
            return (uk = b._emscripten_bind_btRigidBody_getGravity_0 = b.asm.qi).apply(null, arguments)
          }
          , vk = b._emscripten_bind_btRigidBody_setGravity_1 = function() {
            return (vk = b._emscripten_bind_btRigidBody_setGravity_1 = b.asm.ri).apply(null, arguments)
          }
          , wk = b._emscripten_bind_btRigidBody_getBroadphaseProxy_0 = function() {
            return (wk = b._emscripten_bind_btRigidBody_getBroadphaseProxy_0 = b.asm.si).apply(null, arguments)
          }
          , xk = b._emscripten_bind_btRigidBody_clearForces_0 = function() {
            return (xk = b._emscripten_bind_btRigidBody_clearForces_0 = b.asm.ti).apply(null, arguments)
          }
          , yk = b._emscripten_bind_btRigidBody_setAnisotropicFriction_2 = function() {
            return (yk = b._emscripten_bind_btRigidBody_setAnisotropicFriction_2 = b.asm.ui).apply(null, arguments)
          }
          , zk = b._emscripten_bind_btRigidBody_getCollisionShape_0 = function() {
            return (zk = b._emscripten_bind_btRigidBody_getCollisionShape_0 = b.asm.vi).apply(null, arguments)
          }
          , Ak = b._emscripten_bind_btRigidBody_setContactProcessingThreshold_1 = function() {
            return (Ak = b._emscripten_bind_btRigidBody_setContactProcessingThreshold_1 = b.asm.wi).apply(null, arguments)
          }
          , Bk = b._emscripten_bind_btRigidBody_setActivationState_1 = function() {
            return (Bk = b._emscripten_bind_btRigidBody_setActivationState_1 = b.asm.xi).apply(null, arguments)
          }
          , Ck = b._emscripten_bind_btRigidBody_forceActivationState_1 = function() {
            return (Ck = b._emscripten_bind_btRigidBody_forceActivationState_1 = b.asm.yi).apply(null, arguments)
          }
          , Dk = b._emscripten_bind_btRigidBody_activate_0 = function() {
            return (Dk = b._emscripten_bind_btRigidBody_activate_0 = b.asm.zi).apply(null, arguments)
          }
          , Ek = b._emscripten_bind_btRigidBody_activate_1 = function() {
            return (Ek = b._emscripten_bind_btRigidBody_activate_1 = b.asm.Ai).apply(null, arguments)
          }
          , Fk = b._emscripten_bind_btRigidBody_isActive_0 = function() {
            return (Fk = b._emscripten_bind_btRigidBody_isActive_0 = b.asm.Bi).apply(null, arguments)
          }
          , Gk = b._emscripten_bind_btRigidBody_isKinematicObject_0 = function() {
            return (Gk = b._emscripten_bind_btRigidBody_isKinematicObject_0 = b.asm.Ci).apply(null, arguments)
          }
          , Hk = b._emscripten_bind_btRigidBody_isStaticObject_0 = function() {
            return (Hk = b._emscripten_bind_btRigidBody_isStaticObject_0 = b.asm.Di).apply(null, arguments)
          }
          , Ik = b._emscripten_bind_btRigidBody_isStaticOrKinematicObject_0 = function() {
            return (Ik = b._emscripten_bind_btRigidBody_isStaticOrKinematicObject_0 = b.asm.Ei).apply(null, arguments)
          }
          , Jk = b._emscripten_bind_btRigidBody_getRestitution_0 = function() {
            return (Jk = b._emscripten_bind_btRigidBody_getRestitution_0 = b.asm.Fi).apply(null, arguments)
          }
          , Kk = b._emscripten_bind_btRigidBody_getFriction_0 = function() {
            return (Kk = b._emscripten_bind_btRigidBody_getFriction_0 = b.asm.Gi).apply(null, arguments)
          }
          , Lk = b._emscripten_bind_btRigidBody_getRollingFriction_0 = function() {
            return (Lk = b._emscripten_bind_btRigidBody_getRollingFriction_0 = b.asm.Hi).apply(null, arguments)
          }
          , Mk = b._emscripten_bind_btRigidBody_setRestitution_1 = function() {
            return (Mk = b._emscripten_bind_btRigidBody_setRestitution_1 = b.asm.Ii).apply(null, arguments)
          }
          , Nk = b._emscripten_bind_btRigidBody_setFriction_1 = function() {
            return (Nk = b._emscripten_bind_btRigidBody_setFriction_1 = b.asm.Ji).apply(null, arguments)
          }
          , Ok = b._emscripten_bind_btRigidBody_setRollingFriction_1 = function() {
            return (Ok = b._emscripten_bind_btRigidBody_setRollingFriction_1 = b.asm.Ki).apply(null, arguments)
          }
          , Pk = b._emscripten_bind_btRigidBody_getWorldTransform_0 = function() {
            return (Pk = b._emscripten_bind_btRigidBody_getWorldTransform_0 = b.asm.Li).apply(null, arguments)
          }
          , Qk = b._emscripten_bind_btRigidBody_getCollisionFlags_0 = function() {
            return (Qk = b._emscripten_bind_btRigidBody_getCollisionFlags_0 = b.asm.Mi).apply(null, arguments)
          }
          , Rk = b._emscripten_bind_btRigidBody_setCollisionFlags_1 = function() {
            return (Rk = b._emscripten_bind_btRigidBody_setCollisionFlags_1 = b.asm.Ni).apply(null, arguments)
          }
          , Sk = b._emscripten_bind_btRigidBody_setWorldTransform_1 = function() {
            return (Sk = b._emscripten_bind_btRigidBody_setWorldTransform_1 = b.asm.Oi).apply(null, arguments)
          }
          , Tk = b._emscripten_bind_btRigidBody_setCollisionShape_1 = function() {
            return (Tk = b._emscripten_bind_btRigidBody_setCollisionShape_1 = b.asm.Pi).apply(null, arguments)
          }
          , Uk = b._emscripten_bind_btRigidBody_setCcdMotionThreshold_1 = function() {
            return (Uk = b._emscripten_bind_btRigidBody_setCcdMotionThreshold_1 = b.asm.Qi).apply(null, arguments)
          }
          , Vk = b._emscripten_bind_btRigidBody_setCcdSweptSphereRadius_1 = function() {
            return (Vk = b._emscripten_bind_btRigidBody_setCcdSweptSphereRadius_1 = b.asm.Ri).apply(null, arguments)
          }
          , Wk = b._emscripten_bind_btRigidBody_getUserIndex_0 = function() {
            return (Wk = b._emscripten_bind_btRigidBody_getUserIndex_0 = b.asm.Si).apply(null, arguments)
          }
          , Xk = b._emscripten_bind_btRigidBody_setUserIndex_1 = function() {
            return (Xk = b._emscripten_bind_btRigidBody_setUserIndex_1 = b.asm.Ti).apply(null, arguments)
          }
          , Yk = b._emscripten_bind_btRigidBody_getUserPointer_0 = function() {
            return (Yk = b._emscripten_bind_btRigidBody_getUserPointer_0 = b.asm.Ui).apply(null, arguments)
          }
          , Zk = b._emscripten_bind_btRigidBody_setUserPointer_1 = function() {
            return (Zk = b._emscripten_bind_btRigidBody_setUserPointer_1 = b.asm.Vi).apply(null, arguments)
          }
          , $k = b._emscripten_bind_btRigidBody_getBroadphaseHandle_0 = function() {
            return ($k = b._emscripten_bind_btRigidBody_getBroadphaseHandle_0 = b.asm.Wi).apply(null, arguments)
          }
          , al = b._emscripten_bind_btRigidBody___destroy___0 = function() {
            return (al = b._emscripten_bind_btRigidBody___destroy___0 = b.asm.Xi).apply(null, arguments)
          }
          , bl = b._emscripten_bind_btIndexedMeshArray_size_0 = function() {
            return (bl = b._emscripten_bind_btIndexedMeshArray_size_0 = b.asm.Yi).apply(null, arguments)
          }
          , cl = b._emscripten_bind_btIndexedMeshArray_at_1 = function() {
            return (cl = b._emscripten_bind_btIndexedMeshArray_at_1 = b.asm.Zi).apply(null, arguments)
          }
          , dl = b._emscripten_bind_btIndexedMeshArray___destroy___0 = function() {
            return (dl = b._emscripten_bind_btIndexedMeshArray___destroy___0 = b.asm._i).apply(null, arguments)
          }
          , el = b._emscripten_bind_btDbvtBroadphase_btDbvtBroadphase_0 = function() {
            return (el = b._emscripten_bind_btDbvtBroadphase_btDbvtBroadphase_0 = b.asm.$i).apply(null, arguments)
          }
          , fl = b._emscripten_bind_btDbvtBroadphase___destroy___0 = function() {
            return (fl = b._emscripten_bind_btDbvtBroadphase___destroy___0 = b.asm.aj).apply(null, arguments)
          }
          , gl = b._emscripten_bind_btHeightfieldTerrainShape_btHeightfieldTerrainShape_9 = function() {
            return (gl = b._emscripten_bind_btHeightfieldTerrainShape_btHeightfieldTerrainShape_9 = b.asm.bj).apply(null, arguments)
          }
          , hl = b._emscripten_bind_btHeightfieldTerrainShape_setMargin_1 = function() {
            return (hl = b._emscripten_bind_btHeightfieldTerrainShape_setMargin_1 = b.asm.cj).apply(null, arguments)
          }
          , il = b._emscripten_bind_btHeightfieldTerrainShape_getMargin_0 = function() {
            return (il = b._emscripten_bind_btHeightfieldTerrainShape_getMargin_0 = b.asm.dj).apply(null, arguments)
          }
          , jl = b._emscripten_bind_btHeightfieldTerrainShape_setLocalScaling_1 = function() {
            return (jl = b._emscripten_bind_btHeightfieldTerrainShape_setLocalScaling_1 = b.asm.ej).apply(null, arguments)
          }
          , kl = b._emscripten_bind_btHeightfieldTerrainShape_getLocalScaling_0 = function() {
            return (kl = b._emscripten_bind_btHeightfieldTerrainShape_getLocalScaling_0 = b.asm.fj).apply(null, arguments)
          }
          , ll = b._emscripten_bind_btHeightfieldTerrainShape_calculateLocalInertia_2 = function() {
            return (ll = b._emscripten_bind_btHeightfieldTerrainShape_calculateLocalInertia_2 = b.asm.gj).apply(null, arguments)
          }
          , ml = b._emscripten_bind_btHeightfieldTerrainShape___destroy___0 = function() {
            return (ml = b._emscripten_bind_btHeightfieldTerrainShape___destroy___0 = b.asm.hj).apply(null, arguments)
          }
          , nl = b._emscripten_bind_btDefaultSoftBodySolver_btDefaultSoftBodySolver_0 = function() {
            return (nl = b._emscripten_bind_btDefaultSoftBodySolver_btDefaultSoftBodySolver_0 = b.asm.ij).apply(null, arguments)
          }
          , ol = b._emscripten_bind_btDefaultSoftBodySolver___destroy___0 = function() {
            return (ol = b._emscripten_bind_btDefaultSoftBodySolver___destroy___0 = b.asm.jj).apply(null, arguments)
          }
          , pl = b._emscripten_bind_btCollisionDispatcher_btCollisionDispatcher_1 = function() {
            return (pl = b._emscripten_bind_btCollisionDispatcher_btCollisionDispatcher_1 = b.asm.kj).apply(null, arguments)
          }
          , ql = b._emscripten_bind_btCollisionDispatcher_getNumManifolds_0 = function() {
            return (ql = b._emscripten_bind_btCollisionDispatcher_getNumManifolds_0 = b.asm.lj).apply(null, arguments)
          }
          , rl = b._emscripten_bind_btCollisionDispatcher_getManifoldByIndexInternal_1 = function() {
            return (rl = b._emscripten_bind_btCollisionDispatcher_getManifoldByIndexInternal_1 = b.asm.mj).apply(null, arguments)
          }
          , sl = b._emscripten_bind_btCollisionDispatcher___destroy___0 = function() {
            return (sl = b._emscripten_bind_btCollisionDispatcher___destroy___0 = b.asm.nj).apply(null, arguments)
          }
          , tl = b._emscripten_bind_btAxisSweep3_btAxisSweep3_2 = function() {
            return (tl = b._emscripten_bind_btAxisSweep3_btAxisSweep3_2 = b.asm.oj).apply(null, arguments)
          }
          , ul = b._emscripten_bind_btAxisSweep3_btAxisSweep3_3 = function() {
            return (ul = b._emscripten_bind_btAxisSweep3_btAxisSweep3_3 = b.asm.pj).apply(null, arguments)
          }
          , vl = b._emscripten_bind_btAxisSweep3_btAxisSweep3_4 = function() {
            return (vl = b._emscripten_bind_btAxisSweep3_btAxisSweep3_4 = b.asm.qj).apply(null, arguments)
          }
          , wl = b._emscripten_bind_btAxisSweep3_btAxisSweep3_5 = function() {
            return (wl = b._emscripten_bind_btAxisSweep3_btAxisSweep3_5 = b.asm.rj).apply(null, arguments)
          }
          , xl = b._emscripten_bind_btAxisSweep3___destroy___0 = function() {
            return (xl = b._emscripten_bind_btAxisSweep3___destroy___0 = b.asm.sj).apply(null, arguments)
          }
          , yl = b._emscripten_bind_VoidPtr___destroy___0 = function() {
            return (yl = b._emscripten_bind_VoidPtr___destroy___0 = b.asm.tj).apply(null, arguments)
          }
          , zl = b._emscripten_bind_btSoftBodyWorldInfo_btSoftBodyWorldInfo_0 = function() {
            return (zl = b._emscripten_bind_btSoftBodyWorldInfo_btSoftBodyWorldInfo_0 = b.asm.uj).apply(null, arguments)
          }
          , Al = b._emscripten_bind_btSoftBodyWorldInfo_get_air_density_0 = function() {
            return (Al = b._emscripten_bind_btSoftBodyWorldInfo_get_air_density_0 = b.asm.vj).apply(null, arguments)
          }
          , Bl = b._emscripten_bind_btSoftBodyWorldInfo_set_air_density_1 = function() {
            return (Bl = b._emscripten_bind_btSoftBodyWorldInfo_set_air_density_1 = b.asm.wj).apply(null, arguments)
          }
          , Cl = b._emscripten_bind_btSoftBodyWorldInfo_get_water_density_0 = function() {
            return (Cl = b._emscripten_bind_btSoftBodyWorldInfo_get_water_density_0 = b.asm.xj).apply(null, arguments)
          }
          , Dl = b._emscripten_bind_btSoftBodyWorldInfo_set_water_density_1 = function() {
            return (Dl = b._emscripten_bind_btSoftBodyWorldInfo_set_water_density_1 = b.asm.yj).apply(null, arguments)
          }
          , El = b._emscripten_bind_btSoftBodyWorldInfo_get_water_offset_0 = function() {
            return (El = b._emscripten_bind_btSoftBodyWorldInfo_get_water_offset_0 = b.asm.zj).apply(null, arguments)
          }
          , Fl = b._emscripten_bind_btSoftBodyWorldInfo_set_water_offset_1 = function() {
            return (Fl = b._emscripten_bind_btSoftBodyWorldInfo_set_water_offset_1 = b.asm.Aj).apply(null, arguments)
          }
          , Gl = b._emscripten_bind_btSoftBodyWorldInfo_get_m_maxDisplacement_0 = function() {
            return (Gl = b._emscripten_bind_btSoftBodyWorldInfo_get_m_maxDisplacement_0 = b.asm.Bj).apply(null, arguments)
          }
          , Hl = b._emscripten_bind_btSoftBodyWorldInfo_set_m_maxDisplacement_1 = function() {
            return (Hl = b._emscripten_bind_btSoftBodyWorldInfo_set_m_maxDisplacement_1 = b.asm.Cj).apply(null, arguments)
          }
          , Il = b._emscripten_bind_btSoftBodyWorldInfo_get_water_normal_0 = function() {
            return (Il = b._emscripten_bind_btSoftBodyWorldInfo_get_water_normal_0 = b.asm.Dj).apply(null, arguments)
          }
          , Jl = b._emscripten_bind_btSoftBodyWorldInfo_set_water_normal_1 = function() {
            return (Jl = b._emscripten_bind_btSoftBodyWorldInfo_set_water_normal_1 = b.asm.Ej).apply(null, arguments)
          }
          , Kl = b._emscripten_bind_btSoftBodyWorldInfo_get_m_broadphase_0 = function() {
            return (Kl = b._emscripten_bind_btSoftBodyWorldInfo_get_m_broadphase_0 = b.asm.Fj).apply(null, arguments)
          }
          , Ll = b._emscripten_bind_btSoftBodyWorldInfo_set_m_broadphase_1 = function() {
            return (Ll = b._emscripten_bind_btSoftBodyWorldInfo_set_m_broadphase_1 = b.asm.Gj).apply(null, arguments)
          }
          , Ml = b._emscripten_bind_btSoftBodyWorldInfo_get_m_dispatcher_0 = function() {
            return (Ml = b._emscripten_bind_btSoftBodyWorldInfo_get_m_dispatcher_0 = b.asm.Hj).apply(null, arguments)
          }
          , Nl = b._emscripten_bind_btSoftBodyWorldInfo_set_m_dispatcher_1 = function() {
            return (Nl = b._emscripten_bind_btSoftBodyWorldInfo_set_m_dispatcher_1 = b.asm.Ij).apply(null, arguments)
          }
          , Ol = b._emscripten_bind_btSoftBodyWorldInfo_get_m_gravity_0 = function() {
            return (Ol = b._emscripten_bind_btSoftBodyWorldInfo_get_m_gravity_0 = b.asm.Jj).apply(null, arguments)
          }
          , Pl = b._emscripten_bind_btSoftBodyWorldInfo_set_m_gravity_1 = function() {
            return (Pl = b._emscripten_bind_btSoftBodyWorldInfo_set_m_gravity_1 = b.asm.Kj).apply(null, arguments)
          }
          , Ql = b._emscripten_bind_btSoftBodyWorldInfo___destroy___0 = function() {
            return (Ql = b._emscripten_bind_btSoftBodyWorldInfo___destroy___0 = b.asm.Lj).apply(null, arguments)
          }
          , Rl = b._emscripten_bind_btConeTwistConstraint_btConeTwistConstraint_2 = function() {
            return (Rl = b._emscripten_bind_btConeTwistConstraint_btConeTwistConstraint_2 = b.asm.Mj).apply(null, arguments)
          }
          , Sl = b._emscripten_bind_btConeTwistConstraint_btConeTwistConstraint_4 = function() {
            return (Sl = b._emscripten_bind_btConeTwistConstraint_btConeTwistConstraint_4 = b.asm.Nj).apply(null, arguments)
          }
          , Tl = b._emscripten_bind_btConeTwistConstraint_setLimit_2 = function() {
            return (Tl = b._emscripten_bind_btConeTwistConstraint_setLimit_2 = b.asm.Oj).apply(null, arguments)
          }
          , Ul = b._emscripten_bind_btConeTwistConstraint_setAngularOnly_1 = function() {
            return (Ul = b._emscripten_bind_btConeTwistConstraint_setAngularOnly_1 = b.asm.Pj).apply(null, arguments)
          }
          , Vl = b._emscripten_bind_btConeTwistConstraint_setDamping_1 = function() {
            return (Vl = b._emscripten_bind_btConeTwistConstraint_setDamping_1 = b.asm.Qj).apply(null, arguments)
          }
          , Wl = b._emscripten_bind_btConeTwistConstraint_enableMotor_1 = function() {
            return (Wl = b._emscripten_bind_btConeTwistConstraint_enableMotor_1 = b.asm.Rj).apply(null, arguments)
          }
          , Xl = b._emscripten_bind_btConeTwistConstraint_setMaxMotorImpulse_1 = function() {
            return (Xl = b._emscripten_bind_btConeTwistConstraint_setMaxMotorImpulse_1 = b.asm.Sj).apply(null, arguments)
          }
          , Yl = b._emscripten_bind_btConeTwistConstraint_setMaxMotorImpulseNormalized_1 = function() {
            return (Yl = b._emscripten_bind_btConeTwistConstraint_setMaxMotorImpulseNormalized_1 = b.asm.Tj).apply(null, arguments)
          }
          , Zl = b._emscripten_bind_btConeTwistConstraint_setMotorTarget_1 = function() {
            return (Zl = b._emscripten_bind_btConeTwistConstraint_setMotorTarget_1 = b.asm.Uj).apply(null, arguments)
          }
          , $l = b._emscripten_bind_btConeTwistConstraint_setMotorTargetInConstraintSpace_1 = function() {
            return ($l = b._emscripten_bind_btConeTwistConstraint_setMotorTargetInConstraintSpace_1 = b.asm.Vj).apply(null, arguments)
          }
          , am = b._emscripten_bind_btConeTwistConstraint_enableFeedback_1 = function() {
            return (am = b._emscripten_bind_btConeTwistConstraint_enableFeedback_1 = b.asm.Wj).apply(null, arguments)
          }
          , bm = b._emscripten_bind_btConeTwistConstraint_getBreakingImpulseThreshold_0 = function() {
            return (bm = b._emscripten_bind_btConeTwistConstraint_getBreakingImpulseThreshold_0 = b.asm.Xj).apply(null, arguments)
          }
          , cm = b._emscripten_bind_btConeTwistConstraint_setBreakingImpulseThreshold_1 = function() {
            return (cm = b._emscripten_bind_btConeTwistConstraint_setBreakingImpulseThreshold_1 = b.asm.Yj).apply(null, arguments)
          }
          , dm = b._emscripten_bind_btConeTwistConstraint_getParam_2 = function() {
            return (dm = b._emscripten_bind_btConeTwistConstraint_getParam_2 = b.asm.Zj).apply(null, arguments)
          }
          , em = b._emscripten_bind_btConeTwistConstraint_setParam_3 = function() {
            return (em = b._emscripten_bind_btConeTwistConstraint_setParam_3 = b.asm._j).apply(null, arguments)
          }
          , fm = b._emscripten_bind_btConeTwistConstraint___destroy___0 = function() {
            return (fm = b._emscripten_bind_btConeTwistConstraint___destroy___0 = b.asm.$j).apply(null, arguments)
          }
          , gm = b._emscripten_bind_btHingeConstraint_btHingeConstraint_2 = function() {
            return (gm = b._emscripten_bind_btHingeConstraint_btHingeConstraint_2 = b.asm.ak).apply(null, arguments)
          }
          , hm = b._emscripten_bind_btHingeConstraint_btHingeConstraint_3 = function() {
            return (hm = b._emscripten_bind_btHingeConstraint_btHingeConstraint_3 = b.asm.bk).apply(null, arguments)
          }
          , im = b._emscripten_bind_btHingeConstraint_btHingeConstraint_4 = function() {
            return (im = b._emscripten_bind_btHingeConstraint_btHingeConstraint_4 = b.asm.ck).apply(null, arguments)
          }
          , jm = b._emscripten_bind_btHingeConstraint_btHingeConstraint_5 = function() {
            return (jm = b._emscripten_bind_btHingeConstraint_btHingeConstraint_5 = b.asm.dk).apply(null, arguments)
          }
          , km = b._emscripten_bind_btHingeConstraint_btHingeConstraint_6 = function() {
            return (km = b._emscripten_bind_btHingeConstraint_btHingeConstraint_6 = b.asm.ek).apply(null, arguments)
          }
          , lm = b._emscripten_bind_btHingeConstraint_btHingeConstraint_7 = function() {
            return (lm = b._emscripten_bind_btHingeConstraint_btHingeConstraint_7 = b.asm.fk).apply(null, arguments)
          }
          , mm = b._emscripten_bind_btHingeConstraint_setLimit_4 = function() {
            return (mm = b._emscripten_bind_btHingeConstraint_setLimit_4 = b.asm.gk).apply(null, arguments)
          }
          , nm = b._emscripten_bind_btHingeConstraint_setLimit_5 = function() {
            return (nm = b._emscripten_bind_btHingeConstraint_setLimit_5 = b.asm.hk).apply(null, arguments)
          }
          , om = b._emscripten_bind_btHingeConstraint_enableAngularMotor_3 = function() {
            return (om = b._emscripten_bind_btHingeConstraint_enableAngularMotor_3 = b.asm.ik).apply(null, arguments)
          }
          , pm = b._emscripten_bind_btHingeConstraint_setAngularOnly_1 = function() {
            return (pm = b._emscripten_bind_btHingeConstraint_setAngularOnly_1 = b.asm.jk).apply(null, arguments)
          }
          , qm = b._emscripten_bind_btHingeConstraint_enableMotor_1 = function() {
            return (qm = b._emscripten_bind_btHingeConstraint_enableMotor_1 = b.asm.kk).apply(null, arguments)
          }
          , rm = b._emscripten_bind_btHingeConstraint_setMaxMotorImpulse_1 = function() {
            return (rm = b._emscripten_bind_btHingeConstraint_setMaxMotorImpulse_1 = b.asm.lk).apply(null, arguments)
          }
          , sm = b._emscripten_bind_btHingeConstraint_setMotorTarget_2 = function() {
            return (sm = b._emscripten_bind_btHingeConstraint_setMotorTarget_2 = b.asm.mk).apply(null, arguments)
          }
          , tm = b._emscripten_bind_btHingeConstraint_enableFeedback_1 = function() {
            return (tm = b._emscripten_bind_btHingeConstraint_enableFeedback_1 = b.asm.nk).apply(null, arguments)
          }
          , um = b._emscripten_bind_btHingeConstraint_getBreakingImpulseThreshold_0 = function() {
            return (um = b._emscripten_bind_btHingeConstraint_getBreakingImpulseThreshold_0 = b.asm.ok).apply(null, arguments)
          }
          , wm = b._emscripten_bind_btHingeConstraint_setBreakingImpulseThreshold_1 = function() {
            return (wm = b._emscripten_bind_btHingeConstraint_setBreakingImpulseThreshold_1 = b.asm.pk).apply(null, arguments)
          }
          , xm = b._emscripten_bind_btHingeConstraint_getParam_2 = function() {
            return (xm = b._emscripten_bind_btHingeConstraint_getParam_2 = b.asm.qk).apply(null, arguments)
          }
          , ym = b._emscripten_bind_btHingeConstraint_setParam_3 = function() {
            return (ym = b._emscripten_bind_btHingeConstraint_setParam_3 = b.asm.rk).apply(null, arguments)
          }
          , zm = b._emscripten_bind_btHingeConstraint___destroy___0 = function() {
            return (zm = b._emscripten_bind_btHingeConstraint___destroy___0 = b.asm.sk).apply(null, arguments)
          }
          , Am = b._emscripten_bind_btConeShapeZ_btConeShapeZ_2 = function() {
            return (Am = b._emscripten_bind_btConeShapeZ_btConeShapeZ_2 = b.asm.tk).apply(null, arguments)
          }
          , Bm = b._emscripten_bind_btConeShapeZ_setLocalScaling_1 = function() {
            return (Bm = b._emscripten_bind_btConeShapeZ_setLocalScaling_1 = b.asm.uk).apply(null, arguments)
          }
          , Cm = b._emscripten_bind_btConeShapeZ_getLocalScaling_0 = function() {
            return (Cm = b._emscripten_bind_btConeShapeZ_getLocalScaling_0 = b.asm.vk).apply(null, arguments)
          }
          , Dm = b._emscripten_bind_btConeShapeZ_calculateLocalInertia_2 = function() {
            return (Dm = b._emscripten_bind_btConeShapeZ_calculateLocalInertia_2 = b.asm.wk).apply(null, arguments)
          }
          , Em = b._emscripten_bind_btConeShapeZ___destroy___0 = function() {
            return (Em = b._emscripten_bind_btConeShapeZ___destroy___0 = b.asm.xk).apply(null, arguments)
          }
          , Fm = b._emscripten_bind_btConeShapeX_btConeShapeX_2 = function() {
            return (Fm = b._emscripten_bind_btConeShapeX_btConeShapeX_2 = b.asm.yk).apply(null, arguments)
          }
          , Gm = b._emscripten_bind_btConeShapeX_setLocalScaling_1 = function() {
            return (Gm = b._emscripten_bind_btConeShapeX_setLocalScaling_1 = b.asm.zk).apply(null, arguments)
          }
          , Hm = b._emscripten_bind_btConeShapeX_getLocalScaling_0 = function() {
            return (Hm = b._emscripten_bind_btConeShapeX_getLocalScaling_0 = b.asm.Ak).apply(null, arguments)
          }
          , Im = b._emscripten_bind_btConeShapeX_calculateLocalInertia_2 = function() {
            return (Im = b._emscripten_bind_btConeShapeX_calculateLocalInertia_2 = b.asm.Bk).apply(null, arguments)
          }
          , Jm = b._emscripten_bind_btConeShapeX___destroy___0 = function() {
            return (Jm = b._emscripten_bind_btConeShapeX___destroy___0 = b.asm.Ck).apply(null, arguments)
          }
          , Km = b._emscripten_bind_btTriangleMesh_btTriangleMesh_0 = function() {
            return (Km = b._emscripten_bind_btTriangleMesh_btTriangleMesh_0 = b.asm.Dk).apply(null, arguments)
          }
          , Lm = b._emscripten_bind_btTriangleMesh_btTriangleMesh_1 = function() {
            return (Lm = b._emscripten_bind_btTriangleMesh_btTriangleMesh_1 = b.asm.Ek).apply(null, arguments)
          }
          , Mm = b._emscripten_bind_btTriangleMesh_btTriangleMesh_2 = function() {
            return (Mm = b._emscripten_bind_btTriangleMesh_btTriangleMesh_2 = b.asm.Fk).apply(null, arguments)
          }
          , Nm = b._emscripten_bind_btTriangleMesh_addTriangle_3 = function() {
            return (Nm = b._emscripten_bind_btTriangleMesh_addTriangle_3 = b.asm.Gk).apply(null, arguments)
          }
          , Om = b._emscripten_bind_btTriangleMesh_addTriangle_4 = function() {
            return (Om = b._emscripten_bind_btTriangleMesh_addTriangle_4 = b.asm.Hk).apply(null, arguments)
          }
          , Pm = b._emscripten_bind_btTriangleMesh_findOrAddVertex_2 = function() {
            return (Pm = b._emscripten_bind_btTriangleMesh_findOrAddVertex_2 = b.asm.Ik).apply(null, arguments)
          }
          , Qm = b._emscripten_bind_btTriangleMesh_addIndex_1 = function() {
            return (Qm = b._emscripten_bind_btTriangleMesh_addIndex_1 = b.asm.Jk).apply(null, arguments)
          }
          , Rm = b._emscripten_bind_btTriangleMesh_getIndexedMeshArray_0 = function() {
            return (Rm = b._emscripten_bind_btTriangleMesh_getIndexedMeshArray_0 = b.asm.Kk).apply(null, arguments)
          }
          , Sm = b._emscripten_bind_btTriangleMesh_setScaling_1 = function() {
            return (Sm = b._emscripten_bind_btTriangleMesh_setScaling_1 = b.asm.Lk).apply(null, arguments)
          }
          , Tm = b._emscripten_bind_btTriangleMesh___destroy___0 = function() {
            return (Tm = b._emscripten_bind_btTriangleMesh___destroy___0 = b.asm.Mk).apply(null, arguments)
          }
          , Um = b._emscripten_bind_btConvexHullShape_btConvexHullShape_0 = function() {
            return (Um = b._emscripten_bind_btConvexHullShape_btConvexHullShape_0 = b.asm.Nk).apply(null, arguments)
          }
          , Vm = b._emscripten_bind_btConvexHullShape_btConvexHullShape_1 = function() {
            return (Vm = b._emscripten_bind_btConvexHullShape_btConvexHullShape_1 = b.asm.Ok).apply(null, arguments)
          }
          , Wm = b._emscripten_bind_btConvexHullShape_btConvexHullShape_2 = function() {
            return (Wm = b._emscripten_bind_btConvexHullShape_btConvexHullShape_2 = b.asm.Pk).apply(null, arguments)
          }
          , Xm = b._emscripten_bind_btConvexHullShape_addPoint_1 = function() {
            return (Xm = b._emscripten_bind_btConvexHullShape_addPoint_1 = b.asm.Qk).apply(null, arguments)
          }
          , Ym = b._emscripten_bind_btConvexHullShape_addPoint_2 = function() {
            return (Ym = b._emscripten_bind_btConvexHullShape_addPoint_2 = b.asm.Rk).apply(null, arguments)
          }
          , Zm = b._emscripten_bind_btConvexHullShape_setMargin_1 = function() {
            return (Zm = b._emscripten_bind_btConvexHullShape_setMargin_1 = b.asm.Sk).apply(null, arguments)
          }
          , $m = b._emscripten_bind_btConvexHullShape_getMargin_0 = function() {
            return ($m = b._emscripten_bind_btConvexHullShape_getMargin_0 = b.asm.Tk).apply(null, arguments)
          }
          , an = b._emscripten_bind_btConvexHullShape_getNumVertices_0 = function() {
            return (an = b._emscripten_bind_btConvexHullShape_getNumVertices_0 = b.asm.Uk).apply(null, arguments)
          }
          , bn = b._emscripten_bind_btConvexHullShape_initializePolyhedralFeatures_1 = function() {
            return (bn = b._emscripten_bind_btConvexHullShape_initializePolyhedralFeatures_1 = b.asm.Vk).apply(null, arguments)
          }
          , cn = b._emscripten_bind_btConvexHullShape_recalcLocalAabb_0 = function() {
            return (cn = b._emscripten_bind_btConvexHullShape_recalcLocalAabb_0 = b.asm.Wk).apply(null, arguments)
          }
          , dn = b._emscripten_bind_btConvexHullShape_getConvexPolyhedron_0 = function() {
            return (dn = b._emscripten_bind_btConvexHullShape_getConvexPolyhedron_0 = b.asm.Xk).apply(null, arguments)
          }
          , en = b._emscripten_bind_btConvexHullShape_setLocalScaling_1 = function() {
            return (en = b._emscripten_bind_btConvexHullShape_setLocalScaling_1 = b.asm.Yk).apply(null, arguments)
          }
          , fn = b._emscripten_bind_btConvexHullShape_getLocalScaling_0 = function() {
            return (fn = b._emscripten_bind_btConvexHullShape_getLocalScaling_0 = b.asm.Zk).apply(null, arguments)
          }
          , gn = b._emscripten_bind_btConvexHullShape_calculateLocalInertia_2 = function() {
            return (gn = b._emscripten_bind_btConvexHullShape_calculateLocalInertia_2 = b.asm._k).apply(null, arguments)
          }
          , hn = b._emscripten_bind_btConvexHullShape___destroy___0 = function() {
            return (hn = b._emscripten_bind_btConvexHullShape___destroy___0 = b.asm.$k).apply(null, arguments)
          }
          , jn = b._emscripten_bind_btVehicleTuning_btVehicleTuning_0 = function() {
            return (jn = b._emscripten_bind_btVehicleTuning_btVehicleTuning_0 = b.asm.al).apply(null, arguments)
          }
          , kn = b._emscripten_bind_btVehicleTuning_get_m_suspensionStiffness_0 = function() {
            return (kn = b._emscripten_bind_btVehicleTuning_get_m_suspensionStiffness_0 = b.asm.bl).apply(null, arguments)
          }
          , ln = b._emscripten_bind_btVehicleTuning_set_m_suspensionStiffness_1 = function() {
            return (ln = b._emscripten_bind_btVehicleTuning_set_m_suspensionStiffness_1 = b.asm.cl).apply(null, arguments)
          }
          , mn = b._emscripten_bind_btVehicleTuning_get_m_suspensionCompression_0 = function() {
            return (mn = b._emscripten_bind_btVehicleTuning_get_m_suspensionCompression_0 = b.asm.dl).apply(null, arguments)
          }
          , nn = b._emscripten_bind_btVehicleTuning_set_m_suspensionCompression_1 = function() {
            return (nn = b._emscripten_bind_btVehicleTuning_set_m_suspensionCompression_1 = b.asm.el).apply(null, arguments)
          }
          , on = b._emscripten_bind_btVehicleTuning_get_m_suspensionDamping_0 = function() {
            return (on = b._emscripten_bind_btVehicleTuning_get_m_suspensionDamping_0 = b.asm.fl).apply(null, arguments)
          }
          , pn = b._emscripten_bind_btVehicleTuning_set_m_suspensionDamping_1 = function() {
            return (pn = b._emscripten_bind_btVehicleTuning_set_m_suspensionDamping_1 = b.asm.gl).apply(null, arguments)
          }
          , qn = b._emscripten_bind_btVehicleTuning_get_m_maxSuspensionTravelCm_0 = function() {
            return (qn = b._emscripten_bind_btVehicleTuning_get_m_maxSuspensionTravelCm_0 = b.asm.hl).apply(null, arguments)
          }
          , rn = b._emscripten_bind_btVehicleTuning_set_m_maxSuspensionTravelCm_1 = function() {
            return (rn = b._emscripten_bind_btVehicleTuning_set_m_maxSuspensionTravelCm_1 = b.asm.il).apply(null, arguments)
          }
          , sn = b._emscripten_bind_btVehicleTuning_get_m_frictionSlip_0 = function() {
            return (sn = b._emscripten_bind_btVehicleTuning_get_m_frictionSlip_0 = b.asm.jl).apply(null, arguments)
          }
          , tn = b._emscripten_bind_btVehicleTuning_set_m_frictionSlip_1 = function() {
            return (tn = b._emscripten_bind_btVehicleTuning_set_m_frictionSlip_1 = b.asm.kl).apply(null, arguments)
          }
          , un = b._emscripten_bind_btVehicleTuning_get_m_maxSuspensionForce_0 = function() {
            return (un = b._emscripten_bind_btVehicleTuning_get_m_maxSuspensionForce_0 = b.asm.ll).apply(null, arguments)
          }
          , vn = b._emscripten_bind_btVehicleTuning_set_m_maxSuspensionForce_1 = function() {
            return (vn = b._emscripten_bind_btVehicleTuning_set_m_maxSuspensionForce_1 = b.asm.ml).apply(null, arguments)
          }
          , wn = b._emscripten_bind_btCollisionObjectWrapper_getWorldTransform_0 = function() {
            return (wn = b._emscripten_bind_btCollisionObjectWrapper_getWorldTransform_0 = b.asm.nl).apply(null, arguments)
          }
          , xn = b._emscripten_bind_btCollisionObjectWrapper_getCollisionObject_0 = function() {
            return (xn = b._emscripten_bind_btCollisionObjectWrapper_getCollisionObject_0 = b.asm.ol).apply(null, arguments)
          }
          , yn = b._emscripten_bind_btCollisionObjectWrapper_getCollisionShape_0 = function() {
            return (yn = b._emscripten_bind_btCollisionObjectWrapper_getCollisionShape_0 = b.asm.pl).apply(null, arguments)
          }
          , zn = b._emscripten_bind_btShapeHull_btShapeHull_1 = function() {
            return (zn = b._emscripten_bind_btShapeHull_btShapeHull_1 = b.asm.ql).apply(null, arguments)
          }
          , An = b._emscripten_bind_btShapeHull_buildHull_1 = function() {
            return (An = b._emscripten_bind_btShapeHull_buildHull_1 = b.asm.rl).apply(null, arguments)
          }
          , Bn = b._emscripten_bind_btShapeHull_numVertices_0 = function() {
            return (Bn = b._emscripten_bind_btShapeHull_numVertices_0 = b.asm.sl).apply(null, arguments)
          }
          , Cn = b._emscripten_bind_btShapeHull_getVertexPointer_0 = function() {
            return (Cn = b._emscripten_bind_btShapeHull_getVertexPointer_0 = b.asm.tl).apply(null, arguments)
          }
          , Dn = b._emscripten_bind_btShapeHull___destroy___0 = function() {
            return (Dn = b._emscripten_bind_btShapeHull___destroy___0 = b.asm.ul).apply(null, arguments)
          }
          , En = b._emscripten_bind_btDefaultMotionState_btDefaultMotionState_0 = function() {
            return (En = b._emscripten_bind_btDefaultMotionState_btDefaultMotionState_0 = b.asm.vl).apply(null, arguments)
          }
          , Fn = b._emscripten_bind_btDefaultMotionState_btDefaultMotionState_1 = function() {
            return (Fn = b._emscripten_bind_btDefaultMotionState_btDefaultMotionState_1 = b.asm.wl).apply(null, arguments)
          }
          , Gn = b._emscripten_bind_btDefaultMotionState_btDefaultMotionState_2 = function() {
            return (Gn = b._emscripten_bind_btDefaultMotionState_btDefaultMotionState_2 = b.asm.xl).apply(null, arguments)
          }
          , Hn = b._emscripten_bind_btDefaultMotionState_getWorldTransform_1 = function() {
            return (Hn = b._emscripten_bind_btDefaultMotionState_getWorldTransform_1 = b.asm.yl).apply(null, arguments)
          }
          , In = b._emscripten_bind_btDefaultMotionState_setWorldTransform_1 = function() {
            return (In = b._emscripten_bind_btDefaultMotionState_setWorldTransform_1 = b.asm.zl).apply(null, arguments)
          }
          , Jn = b._emscripten_bind_btDefaultMotionState_get_m_graphicsWorldTrans_0 = function() {
            return (Jn = b._emscripten_bind_btDefaultMotionState_get_m_graphicsWorldTrans_0 = b.asm.Al).apply(null, arguments)
          }
          , Kn = b._emscripten_bind_btDefaultMotionState_set_m_graphicsWorldTrans_1 = function() {
            return (Kn = b._emscripten_bind_btDefaultMotionState_set_m_graphicsWorldTrans_1 = b.asm.Bl).apply(null, arguments)
          }
          , Ln = b._emscripten_bind_btDefaultMotionState___destroy___0 = function() {
            return (Ln = b._emscripten_bind_btDefaultMotionState___destroy___0 = b.asm.Cl).apply(null, arguments)
          }
          , Mn = b._emscripten_bind_btWheelInfo_btWheelInfo_1 = function() {
            return (Mn = b._emscripten_bind_btWheelInfo_btWheelInfo_1 = b.asm.Dl).apply(null, arguments)
          }
          , Nn = b._emscripten_bind_btWheelInfo_getSuspensionRestLength_0 = function() {
            return (Nn = b._emscripten_bind_btWheelInfo_getSuspensionRestLength_0 = b.asm.El).apply(null, arguments)
          }
          , On = b._emscripten_bind_btWheelInfo_updateWheel_2 = function() {
            return (On = b._emscripten_bind_btWheelInfo_updateWheel_2 = b.asm.Fl).apply(null, arguments)
          }
          , Pn = b._emscripten_bind_btWheelInfo_get_m_suspensionStiffness_0 = function() {
            return (Pn = b._emscripten_bind_btWheelInfo_get_m_suspensionStiffness_0 = b.asm.Gl).apply(null, arguments)
          }
          , Qn = b._emscripten_bind_btWheelInfo_set_m_suspensionStiffness_1 = function() {
            return (Qn = b._emscripten_bind_btWheelInfo_set_m_suspensionStiffness_1 = b.asm.Hl).apply(null, arguments)
          }
          , Rn = b._emscripten_bind_btWheelInfo_get_m_frictionSlip_0 = function() {
            return (Rn = b._emscripten_bind_btWheelInfo_get_m_frictionSlip_0 = b.asm.Il).apply(null, arguments)
          }
          , Sn = b._emscripten_bind_btWheelInfo_set_m_frictionSlip_1 = function() {
            return (Sn = b._emscripten_bind_btWheelInfo_set_m_frictionSlip_1 = b.asm.Jl).apply(null, arguments)
          }
          , Tn = b._emscripten_bind_btWheelInfo_get_m_engineForce_0 = function() {
            return (Tn = b._emscripten_bind_btWheelInfo_get_m_engineForce_0 = b.asm.Kl).apply(null, arguments)
          }
          , Un = b._emscripten_bind_btWheelInfo_set_m_engineForce_1 = function() {
            return (Un = b._emscripten_bind_btWheelInfo_set_m_engineForce_1 = b.asm.Ll).apply(null, arguments)
          }
          , Vn = b._emscripten_bind_btWheelInfo_get_m_rollInfluence_0 = function() {
            return (Vn = b._emscripten_bind_btWheelInfo_get_m_rollInfluence_0 = b.asm.Ml).apply(null, arguments)
          }
          , Wn = b._emscripten_bind_btWheelInfo_set_m_rollInfluence_1 = function() {
            return (Wn = b._emscripten_bind_btWheelInfo_set_m_rollInfluence_1 = b.asm.Nl).apply(null, arguments)
          }
          , Xn = b._emscripten_bind_btWheelInfo_get_m_suspensionRestLength1_0 = function() {
            return (Xn = b._emscripten_bind_btWheelInfo_get_m_suspensionRestLength1_0 = b.asm.Ol).apply(null, arguments)
          }
          , Yn = b._emscripten_bind_btWheelInfo_set_m_suspensionRestLength1_1 = function() {
            return (Yn = b._emscripten_bind_btWheelInfo_set_m_suspensionRestLength1_1 = b.asm.Pl).apply(null, arguments)
          }
          , Zn = b._emscripten_bind_btWheelInfo_get_m_wheelsRadius_0 = function() {
            return (Zn = b._emscripten_bind_btWheelInfo_get_m_wheelsRadius_0 = b.asm.Ql).apply(null, arguments)
          }
          , $n = b._emscripten_bind_btWheelInfo_set_m_wheelsRadius_1 = function() {
            return ($n = b._emscripten_bind_btWheelInfo_set_m_wheelsRadius_1 = b.asm.Rl).apply(null, arguments)
          }
          , ao = b._emscripten_bind_btWheelInfo_get_m_wheelsDampingCompression_0 = function() {
            return (ao = b._emscripten_bind_btWheelInfo_get_m_wheelsDampingCompression_0 = b.asm.Sl).apply(null, arguments)
          }
          , bo = b._emscripten_bind_btWheelInfo_set_m_wheelsDampingCompression_1 = function() {
            return (bo = b._emscripten_bind_btWheelInfo_set_m_wheelsDampingCompression_1 = b.asm.Tl).apply(null, arguments)
          }
          , co = b._emscripten_bind_btWheelInfo_get_m_wheelsDampingRelaxation_0 = function() {
            return (co = b._emscripten_bind_btWheelInfo_get_m_wheelsDampingRelaxation_0 = b.asm.Ul).apply(null, arguments)
          }
          , eo = b._emscripten_bind_btWheelInfo_set_m_wheelsDampingRelaxation_1 = function() {
            return (eo = b._emscripten_bind_btWheelInfo_set_m_wheelsDampingRelaxation_1 = b.asm.Vl).apply(null, arguments)
          }
          , fo = b._emscripten_bind_btWheelInfo_get_m_steering_0 = function() {
            return (fo = b._emscripten_bind_btWheelInfo_get_m_steering_0 = b.asm.Wl).apply(null, arguments)
          }
          , go = b._emscripten_bind_btWheelInfo_set_m_steering_1 = function() {
            return (go = b._emscripten_bind_btWheelInfo_set_m_steering_1 = b.asm.Xl).apply(null, arguments)
          }
          , ho = b._emscripten_bind_btWheelInfo_get_m_maxSuspensionForce_0 = function() {
            return (ho = b._emscripten_bind_btWheelInfo_get_m_maxSuspensionForce_0 = b.asm.Yl).apply(null, arguments)
          }
          , io = b._emscripten_bind_btWheelInfo_set_m_maxSuspensionForce_1 = function() {
            return (io = b._emscripten_bind_btWheelInfo_set_m_maxSuspensionForce_1 = b.asm.Zl).apply(null, arguments)
          }
          , jo = b._emscripten_bind_btWheelInfo_get_m_maxSuspensionTravelCm_0 = function() {
            return (jo = b._emscripten_bind_btWheelInfo_get_m_maxSuspensionTravelCm_0 = b.asm._l).apply(null, arguments)
          }
          , ko = b._emscripten_bind_btWheelInfo_set_m_maxSuspensionTravelCm_1 = function() {
            return (ko = b._emscripten_bind_btWheelInfo_set_m_maxSuspensionTravelCm_1 = b.asm.$l).apply(null, arguments)
          }
          , lo = b._emscripten_bind_btWheelInfo_get_m_wheelsSuspensionForce_0 = function() {
            return (lo = b._emscripten_bind_btWheelInfo_get_m_wheelsSuspensionForce_0 = b.asm.am).apply(null, arguments)
          }
          , mo = b._emscripten_bind_btWheelInfo_set_m_wheelsSuspensionForce_1 = function() {
            return (mo = b._emscripten_bind_btWheelInfo_set_m_wheelsSuspensionForce_1 = b.asm.bm).apply(null, arguments)
          }
          , no = b._emscripten_bind_btWheelInfo_get_m_bIsFrontWheel_0 = function() {
            return (no = b._emscripten_bind_btWheelInfo_get_m_bIsFrontWheel_0 = b.asm.cm).apply(null, arguments)
          }
          , oo = b._emscripten_bind_btWheelInfo_set_m_bIsFrontWheel_1 = function() {
            return (oo = b._emscripten_bind_btWheelInfo_set_m_bIsFrontWheel_1 = b.asm.dm).apply(null, arguments)
          }
          , po = b._emscripten_bind_btWheelInfo_get_m_raycastInfo_0 = function() {
            return (po = b._emscripten_bind_btWheelInfo_get_m_raycastInfo_0 = b.asm.em).apply(null, arguments)
          }
          , qo = b._emscripten_bind_btWheelInfo_set_m_raycastInfo_1 = function() {
            return (qo = b._emscripten_bind_btWheelInfo_set_m_raycastInfo_1 = b.asm.fm).apply(null, arguments)
          }
          , ro = b._emscripten_bind_btWheelInfo_get_m_chassisConnectionPointCS_0 = function() {
            return (ro = b._emscripten_bind_btWheelInfo_get_m_chassisConnectionPointCS_0 = b.asm.gm).apply(null, arguments)
          }
          , so = b._emscripten_bind_btWheelInfo_set_m_chassisConnectionPointCS_1 = function() {
            return (so = b._emscripten_bind_btWheelInfo_set_m_chassisConnectionPointCS_1 = b.asm.hm).apply(null, arguments)
          }
          , to = b._emscripten_bind_btWheelInfo_get_m_worldTransform_0 = function() {
            return (to = b._emscripten_bind_btWheelInfo_get_m_worldTransform_0 = b.asm.im).apply(null, arguments)
          }
          , uo = b._emscripten_bind_btWheelInfo_set_m_worldTransform_1 = function() {
            return (uo = b._emscripten_bind_btWheelInfo_set_m_worldTransform_1 = b.asm.jm).apply(null, arguments)
          }
          , vo = b._emscripten_bind_btWheelInfo_get_m_wheelDirectionCS_0 = function() {
            return (vo = b._emscripten_bind_btWheelInfo_get_m_wheelDirectionCS_0 = b.asm.km).apply(null, arguments)
          }
          , wo = b._emscripten_bind_btWheelInfo_set_m_wheelDirectionCS_1 = function() {
            return (wo = b._emscripten_bind_btWheelInfo_set_m_wheelDirectionCS_1 = b.asm.lm).apply(null, arguments)
          }
          , xo = b._emscripten_bind_btWheelInfo_get_m_wheelAxleCS_0 = function() {
            return (xo = b._emscripten_bind_btWheelInfo_get_m_wheelAxleCS_0 = b.asm.mm).apply(null, arguments)
          }
          , yo = b._emscripten_bind_btWheelInfo_set_m_wheelAxleCS_1 = function() {
            return (yo = b._emscripten_bind_btWheelInfo_set_m_wheelAxleCS_1 = b.asm.nm).apply(null, arguments)
          }
          , zo = b._emscripten_bind_btWheelInfo_get_m_rotation_0 = function() {
            return (zo = b._emscripten_bind_btWheelInfo_get_m_rotation_0 = b.asm.om).apply(null, arguments)
          }
          , Ao = b._emscripten_bind_btWheelInfo_set_m_rotation_1 = function() {
            return (Ao = b._emscripten_bind_btWheelInfo_set_m_rotation_1 = b.asm.pm).apply(null, arguments)
          }
          , Bo = b._emscripten_bind_btWheelInfo_get_m_deltaRotation_0 = function() {
            return (Bo = b._emscripten_bind_btWheelInfo_get_m_deltaRotation_0 = b.asm.qm).apply(null, arguments)
          }
          , Co = b._emscripten_bind_btWheelInfo_set_m_deltaRotation_1 = function() {
            return (Co = b._emscripten_bind_btWheelInfo_set_m_deltaRotation_1 = b.asm.rm).apply(null, arguments)
          }
          , Do = b._emscripten_bind_btWheelInfo_get_m_brake_0 = function() {
            return (Do = b._emscripten_bind_btWheelInfo_get_m_brake_0 = b.asm.sm).apply(null, arguments)
          }
          , Eo = b._emscripten_bind_btWheelInfo_set_m_brake_1 = function() {
            return (Eo = b._emscripten_bind_btWheelInfo_set_m_brake_1 = b.asm.tm).apply(null, arguments)
          }
          , Fo = b._emscripten_bind_btWheelInfo_get_m_clippedInvContactDotSuspension_0 = function() {
            return (Fo = b._emscripten_bind_btWheelInfo_get_m_clippedInvContactDotSuspension_0 = b.asm.um).apply(null, arguments)
          }
          , Go = b._emscripten_bind_btWheelInfo_set_m_clippedInvContactDotSuspension_1 = function() {
            return (Go = b._emscripten_bind_btWheelInfo_set_m_clippedInvContactDotSuspension_1 = b.asm.vm).apply(null, arguments)
          }
          , Ho = b._emscripten_bind_btWheelInfo_get_m_suspensionRelativeVelocity_0 = function() {
            return (Ho = b._emscripten_bind_btWheelInfo_get_m_suspensionRelativeVelocity_0 = b.asm.wm).apply(null, arguments)
          }
          , Io = b._emscripten_bind_btWheelInfo_set_m_suspensionRelativeVelocity_1 = function() {
            return (Io = b._emscripten_bind_btWheelInfo_set_m_suspensionRelativeVelocity_1 = b.asm.xm).apply(null, arguments)
          }
          , Jo = b._emscripten_bind_btWheelInfo_get_m_skidInfo_0 = function() {
            return (Jo = b._emscripten_bind_btWheelInfo_get_m_skidInfo_0 = b.asm.ym).apply(null, arguments)
          }
          , Ko = b._emscripten_bind_btWheelInfo_set_m_skidInfo_1 = function() {
            return (Ko = b._emscripten_bind_btWheelInfo_set_m_skidInfo_1 = b.asm.zm).apply(null, arguments)
          }
          , Lo = b._emscripten_bind_btWheelInfo___destroy___0 = function() {
            return (Lo = b._emscripten_bind_btWheelInfo___destroy___0 = b.asm.Am).apply(null, arguments)
          }
          , Mo = b._emscripten_bind_btVector4_btVector4_0 = function() {
            return (Mo = b._emscripten_bind_btVector4_btVector4_0 = b.asm.Bm).apply(null, arguments)
          }
          , No = b._emscripten_bind_btVector4_btVector4_4 = function() {
            return (No = b._emscripten_bind_btVector4_btVector4_4 = b.asm.Cm).apply(null, arguments)
          }
          , Oo = b._emscripten_bind_btVector4_w_0 = function() {
            return (Oo = b._emscripten_bind_btVector4_w_0 = b.asm.Dm).apply(null, arguments)
          }
          , Po = b._emscripten_bind_btVector4_setValue_4 = function() {
            return (Po = b._emscripten_bind_btVector4_setValue_4 = b.asm.Em).apply(null, arguments)
          }
          , Qo = b._emscripten_bind_btVector4_length_0 = function() {
            return (Qo = b._emscripten_bind_btVector4_length_0 = b.asm.Fm).apply(null, arguments)
          }
          , Ro = b._emscripten_bind_btVector4_x_0 = function() {
            return (Ro = b._emscripten_bind_btVector4_x_0 = b.asm.Gm).apply(null, arguments)
          }
          , So = b._emscripten_bind_btVector4_y_0 = function() {
            return (So = b._emscripten_bind_btVector4_y_0 = b.asm.Hm).apply(null, arguments)
          }
          , To = b._emscripten_bind_btVector4_z_0 = function() {
            return (To = b._emscripten_bind_btVector4_z_0 = b.asm.Im).apply(null, arguments)
          }
          , Uo = b._emscripten_bind_btVector4_setX_1 = function() {
            return (Uo = b._emscripten_bind_btVector4_setX_1 = b.asm.Jm).apply(null, arguments)
          }
          , Vo = b._emscripten_bind_btVector4_setY_1 = function() {
            return (Vo = b._emscripten_bind_btVector4_setY_1 = b.asm.Km).apply(null, arguments)
          }
          , Wo = b._emscripten_bind_btVector4_setZ_1 = function() {
            return (Wo = b._emscripten_bind_btVector4_setZ_1 = b.asm.Lm).apply(null, arguments)
          }
          , Xo = b._emscripten_bind_btVector4_normalize_0 = function() {
            return (Xo = b._emscripten_bind_btVector4_normalize_0 = b.asm.Mm).apply(null, arguments)
          }
          , Yo = b._emscripten_bind_btVector4_rotate_2 = function() {
            return (Yo = b._emscripten_bind_btVector4_rotate_2 = b.asm.Nm).apply(null, arguments)
          }
          , Zo = b._emscripten_bind_btVector4_dot_1 = function() {
            return (Zo = b._emscripten_bind_btVector4_dot_1 = b.asm.Om).apply(null, arguments)
          }
          , $o = b._emscripten_bind_btVector4_op_mul_1 = function() {
            return ($o = b._emscripten_bind_btVector4_op_mul_1 = b.asm.Pm).apply(null, arguments)
          }
          , ap = b._emscripten_bind_btVector4_op_add_1 = function() {
            return (ap = b._emscripten_bind_btVector4_op_add_1 = b.asm.Qm).apply(null, arguments)
          }
          , bp = b._emscripten_bind_btVector4_op_sub_1 = function() {
            return (bp = b._emscripten_bind_btVector4_op_sub_1 = b.asm.Rm).apply(null, arguments)
          }
          , cp = b._emscripten_bind_btVector4___destroy___0 = function() {
            return (cp = b._emscripten_bind_btVector4___destroy___0 = b.asm.Sm).apply(null, arguments)
          }
          , dp = b._emscripten_bind_btDefaultCollisionConstructionInfo_btDefaultCollisionConstructionInfo_0 = function() {
            return (dp = b._emscripten_bind_btDefaultCollisionConstructionInfo_btDefaultCollisionConstructionInfo_0 = b.asm.Tm).apply(null, arguments)
          }
          , ep = b._emscripten_bind_btDefaultCollisionConstructionInfo___destroy___0 = function() {
            return (ep = b._emscripten_bind_btDefaultCollisionConstructionInfo___destroy___0 = b.asm.Um).apply(null, arguments)
          }
          , fp = b._emscripten_bind_Anchor_get_m_node_0 = function() {
            return (fp = b._emscripten_bind_Anchor_get_m_node_0 = b.asm.Vm).apply(null, arguments)
          }
          , gp = b._emscripten_bind_Anchor_set_m_node_1 = function() {
            return (gp = b._emscripten_bind_Anchor_set_m_node_1 = b.asm.Wm).apply(null, arguments)
          }
          , hp = b._emscripten_bind_Anchor_get_m_local_0 = function() {
            return (hp = b._emscripten_bind_Anchor_get_m_local_0 = b.asm.Xm).apply(null, arguments)
          }
          , ip = b._emscripten_bind_Anchor_set_m_local_1 = function() {
            return (ip = b._emscripten_bind_Anchor_set_m_local_1 = b.asm.Ym).apply(null, arguments)
          }
          , jp = b._emscripten_bind_Anchor_get_m_body_0 = function() {
            return (jp = b._emscripten_bind_Anchor_get_m_body_0 = b.asm.Zm).apply(null, arguments)
          }
          , kp = b._emscripten_bind_Anchor_set_m_body_1 = function() {
            return (kp = b._emscripten_bind_Anchor_set_m_body_1 = b.asm._m).apply(null, arguments)
          }
          , lp = b._emscripten_bind_Anchor_get_m_influence_0 = function() {
            return (lp = b._emscripten_bind_Anchor_get_m_influence_0 = b.asm.$m).apply(null, arguments)
          }
          , mp = b._emscripten_bind_Anchor_set_m_influence_1 = function() {
            return (mp = b._emscripten_bind_Anchor_set_m_influence_1 = b.asm.an).apply(null, arguments)
          }
          , np = b._emscripten_bind_Anchor_get_m_c0_0 = function() {
            return (np = b._emscripten_bind_Anchor_get_m_c0_0 = b.asm.bn).apply(null, arguments)
          }
          , op = b._emscripten_bind_Anchor_set_m_c0_1 = function() {
            return (op = b._emscripten_bind_Anchor_set_m_c0_1 = b.asm.cn).apply(null, arguments)
          }
          , pp = b._emscripten_bind_Anchor_get_m_c1_0 = function() {
            return (pp = b._emscripten_bind_Anchor_get_m_c1_0 = b.asm.dn).apply(null, arguments)
          }
          , qp = b._emscripten_bind_Anchor_set_m_c1_1 = function() {
            return (qp = b._emscripten_bind_Anchor_set_m_c1_1 = b.asm.en).apply(null, arguments)
          }
          , rp = b._emscripten_bind_Anchor_get_m_c2_0 = function() {
            return (rp = b._emscripten_bind_Anchor_get_m_c2_0 = b.asm.fn).apply(null, arguments)
          }
          , sp = b._emscripten_bind_Anchor_set_m_c2_1 = function() {
            return (sp = b._emscripten_bind_Anchor_set_m_c2_1 = b.asm.gn).apply(null, arguments)
          }
          , tp = b._emscripten_bind_Anchor___destroy___0 = function() {
            return (tp = b._emscripten_bind_Anchor___destroy___0 = b.asm.hn).apply(null, arguments)
          }
          , up = b._emscripten_bind_btVehicleRaycasterResult_get_m_hitPointInWorld_0 = function() {
            return (up = b._emscripten_bind_btVehicleRaycasterResult_get_m_hitPointInWorld_0 = b.asm.jn).apply(null, arguments)
          }
          , vp = b._emscripten_bind_btVehicleRaycasterResult_set_m_hitPointInWorld_1 = function() {
            return (vp = b._emscripten_bind_btVehicleRaycasterResult_set_m_hitPointInWorld_1 = b.asm.kn).apply(null, arguments)
          }
          , wp = b._emscripten_bind_btVehicleRaycasterResult_get_m_hitNormalInWorld_0 = function() {
            return (wp = b._emscripten_bind_btVehicleRaycasterResult_get_m_hitNormalInWorld_0 = b.asm.ln).apply(null, arguments)
          }
          , xp = b._emscripten_bind_btVehicleRaycasterResult_set_m_hitNormalInWorld_1 = function() {
            return (xp = b._emscripten_bind_btVehicleRaycasterResult_set_m_hitNormalInWorld_1 = b.asm.mn).apply(null, arguments)
          }
          , yp = b._emscripten_bind_btVehicleRaycasterResult_get_m_distFraction_0 = function() {
            return (yp = b._emscripten_bind_btVehicleRaycasterResult_get_m_distFraction_0 = b.asm.nn).apply(null, arguments)
          }
          , zp = b._emscripten_bind_btVehicleRaycasterResult_set_m_distFraction_1 = function() {
            return (zp = b._emscripten_bind_btVehicleRaycasterResult_set_m_distFraction_1 = b.asm.on).apply(null, arguments)
          }
          , Ap = b._emscripten_bind_btVehicleRaycasterResult___destroy___0 = function() {
            return (Ap = b._emscripten_bind_btVehicleRaycasterResult___destroy___0 = b.asm.pn).apply(null, arguments)
          }
          , Bp = b._emscripten_bind_btVector3Array_size_0 = function() {
            return (Bp = b._emscripten_bind_btVector3Array_size_0 = b.asm.qn).apply(null, arguments)
          }
          , Cp = b._emscripten_bind_btVector3Array_at_1 = function() {
            return (Cp = b._emscripten_bind_btVector3Array_at_1 = b.asm.rn).apply(null, arguments)
          }
          , Dp = b._emscripten_bind_btVector3Array___destroy___0 = function() {
            return (Dp = b._emscripten_bind_btVector3Array___destroy___0 = b.asm.sn).apply(null, arguments)
          }
          , Ep = b._emscripten_bind_btConstraintSolver___destroy___0 = function() {
            return (Ep = b._emscripten_bind_btConstraintSolver___destroy___0 = b.asm.tn).apply(null, arguments)
          }
          , Fp = b._emscripten_bind_btRaycastVehicle_btRaycastVehicle_3 = function() {
            return (Fp = b._emscripten_bind_btRaycastVehicle_btRaycastVehicle_3 = b.asm.un).apply(null, arguments)
          }
          , Gp = b._emscripten_bind_btRaycastVehicle_applyEngineForce_2 = function() {
            return (Gp = b._emscripten_bind_btRaycastVehicle_applyEngineForce_2 = b.asm.vn).apply(null, arguments)
          }
          , Hp = b._emscripten_bind_btRaycastVehicle_setSteeringValue_2 = function() {
            return (Hp = b._emscripten_bind_btRaycastVehicle_setSteeringValue_2 = b.asm.wn).apply(null, arguments)
          }
          , Ip = b._emscripten_bind_btRaycastVehicle_getWheelTransformWS_1 = function() {
            return (Ip = b._emscripten_bind_btRaycastVehicle_getWheelTransformWS_1 = b.asm.xn).apply(null, arguments)
          }
          , Jp = b._emscripten_bind_btRaycastVehicle_updateWheelTransform_2 = function() {
            return (Jp = b._emscripten_bind_btRaycastVehicle_updateWheelTransform_2 = b.asm.yn).apply(null, arguments)
          }
          , Kp = b._emscripten_bind_btRaycastVehicle_addWheel_7 = function() {
            return (Kp = b._emscripten_bind_btRaycastVehicle_addWheel_7 = b.asm.zn).apply(null, arguments)
          }
          , Lp = b._emscripten_bind_btRaycastVehicle_getNumWheels_0 = function() {
            return (Lp = b._emscripten_bind_btRaycastVehicle_getNumWheels_0 = b.asm.An).apply(null, arguments)
          }
          , Mp = b._emscripten_bind_btRaycastVehicle_getRigidBody_0 = function() {
            return (Mp = b._emscripten_bind_btRaycastVehicle_getRigidBody_0 = b.asm.Bn).apply(null, arguments)
          }
          , Np = b._emscripten_bind_btRaycastVehicle_getWheelInfo_1 = function() {
            return (Np = b._emscripten_bind_btRaycastVehicle_getWheelInfo_1 = b.asm.Cn).apply(null, arguments)
          }
          , Op = b._emscripten_bind_btRaycastVehicle_setBrake_2 = function() {
            return (Op = b._emscripten_bind_btRaycastVehicle_setBrake_2 = b.asm.Dn).apply(null, arguments)
          }
          , Pp = b._emscripten_bind_btRaycastVehicle_setCoordinateSystem_3 = function() {
            return (Pp = b._emscripten_bind_btRaycastVehicle_setCoordinateSystem_3 = b.asm.En).apply(null, arguments)
          }
          , Qp = b._emscripten_bind_btRaycastVehicle_getCurrentSpeedKmHour_0 = function() {
            return (Qp = b._emscripten_bind_btRaycastVehicle_getCurrentSpeedKmHour_0 = b.asm.Fn).apply(null, arguments)
          }
          , Rp = b._emscripten_bind_btRaycastVehicle_getChassisWorldTransform_0 = function() {
            return (Rp = b._emscripten_bind_btRaycastVehicle_getChassisWorldTransform_0 = b.asm.Gn).apply(null, arguments)
          }
          , Sp = b._emscripten_bind_btRaycastVehicle_rayCast_1 = function() {
            return (Sp = b._emscripten_bind_btRaycastVehicle_rayCast_1 = b.asm.Hn).apply(null, arguments)
          }
          , Tp = b._emscripten_bind_btRaycastVehicle_updateVehicle_1 = function() {
            return (Tp = b._emscripten_bind_btRaycastVehicle_updateVehicle_1 = b.asm.In).apply(null, arguments)
          }
          , Up = b._emscripten_bind_btRaycastVehicle_resetSuspension_0 = function() {
            return (Up = b._emscripten_bind_btRaycastVehicle_resetSuspension_0 = b.asm.Jn).apply(null, arguments)
          }
          , Vp = b._emscripten_bind_btRaycastVehicle_getSteeringValue_1 = function() {
            return (Vp = b._emscripten_bind_btRaycastVehicle_getSteeringValue_1 = b.asm.Kn).apply(null, arguments)
          }
          , Wp = b._emscripten_bind_btRaycastVehicle_updateWheelTransformsWS_1 = function() {
            return (Wp = b._emscripten_bind_btRaycastVehicle_updateWheelTransformsWS_1 = b.asm.Ln).apply(null, arguments)
          }
          , Xp = b._emscripten_bind_btRaycastVehicle_updateWheelTransformsWS_2 = function() {
            return (Xp = b._emscripten_bind_btRaycastVehicle_updateWheelTransformsWS_2 = b.asm.Mn).apply(null, arguments)
          }
          , Yp = b._emscripten_bind_btRaycastVehicle_setPitchControl_1 = function() {
            return (Yp = b._emscripten_bind_btRaycastVehicle_setPitchControl_1 = b.asm.Nn).apply(null, arguments)
          }
          , Zp = b._emscripten_bind_btRaycastVehicle_updateSuspension_1 = function() {
            return (Zp = b._emscripten_bind_btRaycastVehicle_updateSuspension_1 = b.asm.On).apply(null, arguments)
          }
          , $p = b._emscripten_bind_btRaycastVehicle_updateFriction_1 = function() {
            return ($p = b._emscripten_bind_btRaycastVehicle_updateFriction_1 = b.asm.Pn).apply(null, arguments)
          }
          , aq = b._emscripten_bind_btRaycastVehicle_getRightAxis_0 = function() {
            return (aq = b._emscripten_bind_btRaycastVehicle_getRightAxis_0 = b.asm.Qn).apply(null, arguments)
          }
          , bq = b._emscripten_bind_btRaycastVehicle_getUpAxis_0 = function() {
            return (bq = b._emscripten_bind_btRaycastVehicle_getUpAxis_0 = b.asm.Rn).apply(null, arguments)
          }
          , cq = b._emscripten_bind_btRaycastVehicle_getForwardAxis_0 = function() {
            return (cq = b._emscripten_bind_btRaycastVehicle_getForwardAxis_0 = b.asm.Sn).apply(null, arguments)
          }
          , dq = b._emscripten_bind_btRaycastVehicle_getForwardVector_0 = function() {
            return (dq = b._emscripten_bind_btRaycastVehicle_getForwardVector_0 = b.asm.Tn).apply(null, arguments)
          }
          , eq = b._emscripten_bind_btRaycastVehicle_getUserConstraintType_0 = function() {
            return (eq = b._emscripten_bind_btRaycastVehicle_getUserConstraintType_0 = b.asm.Un).apply(null, arguments)
          }
          , fq = b._emscripten_bind_btRaycastVehicle_setUserConstraintType_1 = function() {
            return (fq = b._emscripten_bind_btRaycastVehicle_setUserConstraintType_1 = b.asm.Vn).apply(null, arguments)
          }
          , gq = b._emscripten_bind_btRaycastVehicle_setUserConstraintId_1 = function() {
            return (gq = b._emscripten_bind_btRaycastVehicle_setUserConstraintId_1 = b.asm.Wn).apply(null, arguments)
          }
          , hq = b._emscripten_bind_btRaycastVehicle_getUserConstraintId_0 = function() {
            return (hq = b._emscripten_bind_btRaycastVehicle_getUserConstraintId_0 = b.asm.Xn).apply(null, arguments)
          }
          , iq = b._emscripten_bind_btRaycastVehicle_updateAction_2 = function() {
            return (iq = b._emscripten_bind_btRaycastVehicle_updateAction_2 = b.asm.Yn).apply(null, arguments)
          }
          , jq = b._emscripten_bind_btRaycastVehicle___destroy___0 = function() {
            return (jq = b._emscripten_bind_btRaycastVehicle___destroy___0 = b.asm.Zn).apply(null, arguments)
          }
          , kq = b._emscripten_bind_btCylinderShapeX_btCylinderShapeX_1 = function() {
            return (kq = b._emscripten_bind_btCylinderShapeX_btCylinderShapeX_1 = b.asm._n).apply(null, arguments)
          }
          , lq = b._emscripten_bind_btCylinderShapeX_setMargin_1 = function() {
            return (lq = b._emscripten_bind_btCylinderShapeX_setMargin_1 = b.asm.$n).apply(null, arguments)
          }
          , mq = b._emscripten_bind_btCylinderShapeX_getMargin_0 = function() {
            return (mq = b._emscripten_bind_btCylinderShapeX_getMargin_0 = b.asm.ao).apply(null, arguments)
          }
          , nq = b._emscripten_bind_btCylinderShapeX_setLocalScaling_1 = function() {
            return (nq = b._emscripten_bind_btCylinderShapeX_setLocalScaling_1 = b.asm.bo).apply(null, arguments)
          }
          , oq = b._emscripten_bind_btCylinderShapeX_getLocalScaling_0 = function() {
            return (oq = b._emscripten_bind_btCylinderShapeX_getLocalScaling_0 = b.asm.co).apply(null, arguments)
          }
          , pq = b._emscripten_bind_btCylinderShapeX_calculateLocalInertia_2 = function() {
            return (pq = b._emscripten_bind_btCylinderShapeX_calculateLocalInertia_2 = b.asm.eo).apply(null, arguments)
          }
          , qq = b._emscripten_bind_btCylinderShapeX___destroy___0 = function() {
            return (qq = b._emscripten_bind_btCylinderShapeX___destroy___0 = b.asm.fo).apply(null, arguments)
          }
          , rq = b._emscripten_bind_btCylinderShapeZ_btCylinderShapeZ_1 = function() {
            return (rq = b._emscripten_bind_btCylinderShapeZ_btCylinderShapeZ_1 = b.asm.go).apply(null, arguments)
          }
          , sq = b._emscripten_bind_btCylinderShapeZ_setMargin_1 = function() {
            return (sq = b._emscripten_bind_btCylinderShapeZ_setMargin_1 = b.asm.ho).apply(null, arguments)
          }
          , tq = b._emscripten_bind_btCylinderShapeZ_getMargin_0 = function() {
            return (tq = b._emscripten_bind_btCylinderShapeZ_getMargin_0 = b.asm.io).apply(null, arguments)
          }
          , uq = b._emscripten_bind_btCylinderShapeZ_setLocalScaling_1 = function() {
            return (uq = b._emscripten_bind_btCylinderShapeZ_setLocalScaling_1 = b.asm.jo).apply(null, arguments)
          }
          , vq = b._emscripten_bind_btCylinderShapeZ_getLocalScaling_0 = function() {
            return (vq = b._emscripten_bind_btCylinderShapeZ_getLocalScaling_0 = b.asm.ko).apply(null, arguments)
          }
          , wq = b._emscripten_bind_btCylinderShapeZ_calculateLocalInertia_2 = function() {
            return (wq = b._emscripten_bind_btCylinderShapeZ_calculateLocalInertia_2 = b.asm.lo).apply(null, arguments)
          }
          , xq = b._emscripten_bind_btCylinderShapeZ___destroy___0 = function() {
            return (xq = b._emscripten_bind_btCylinderShapeZ___destroy___0 = b.asm.mo).apply(null, arguments)
          }
          , yq = b._emscripten_bind_btConvexPolyhedron_get_m_vertices_0 = function() {
            return (yq = b._emscripten_bind_btConvexPolyhedron_get_m_vertices_0 = b.asm.no).apply(null, arguments)
          }
          , zq = b._emscripten_bind_btConvexPolyhedron_set_m_vertices_1 = function() {
            return (zq = b._emscripten_bind_btConvexPolyhedron_set_m_vertices_1 = b.asm.oo).apply(null, arguments)
          }
          , Aq = b._emscripten_bind_btConvexPolyhedron_get_m_faces_0 = function() {
            return (Aq = b._emscripten_bind_btConvexPolyhedron_get_m_faces_0 = b.asm.po).apply(null, arguments)
          }
          , Bq = b._emscripten_bind_btConvexPolyhedron_set_m_faces_1 = function() {
            return (Bq = b._emscripten_bind_btConvexPolyhedron_set_m_faces_1 = b.asm.qo).apply(null, arguments)
          }
          , Cq = b._emscripten_bind_btConvexPolyhedron___destroy___0 = function() {
            return (Cq = b._emscripten_bind_btConvexPolyhedron___destroy___0 = b.asm.ro).apply(null, arguments)
          }
          , Dq = b._emscripten_bind_btSequentialImpulseConstraintSolver_btSequentialImpulseConstraintSolver_0 = function() {
            return (Dq = b._emscripten_bind_btSequentialImpulseConstraintSolver_btSequentialImpulseConstraintSolver_0 = b.asm.so).apply(null, arguments)
          }
          , Eq = b._emscripten_bind_btSequentialImpulseConstraintSolver___destroy___0 = function() {
            return (Eq = b._emscripten_bind_btSequentialImpulseConstraintSolver___destroy___0 = b.asm.to).apply(null, arguments)
          }
          , Fq = b._emscripten_bind_tAnchorArray_size_0 = function() {
            return (Fq = b._emscripten_bind_tAnchorArray_size_0 = b.asm.uo).apply(null, arguments)
          }
          , Gq = b._emscripten_bind_tAnchorArray_at_1 = function() {
            return (Gq = b._emscripten_bind_tAnchorArray_at_1 = b.asm.vo).apply(null, arguments)
          }
          , Hq = b._emscripten_bind_tAnchorArray_clear_0 = function() {
            return (Hq = b._emscripten_bind_tAnchorArray_clear_0 = b.asm.wo).apply(null, arguments)
          }
          , Iq = b._emscripten_bind_tAnchorArray_push_back_1 = function() {
            return (Iq = b._emscripten_bind_tAnchorArray_push_back_1 = b.asm.xo).apply(null, arguments)
          }
          , Jq = b._emscripten_bind_tAnchorArray_pop_back_0 = function() {
            return (Jq = b._emscripten_bind_tAnchorArray_pop_back_0 = b.asm.yo).apply(null, arguments)
          }
          , Kq = b._emscripten_bind_tAnchorArray___destroy___0 = function() {
            return (Kq = b._emscripten_bind_tAnchorArray___destroy___0 = b.asm.zo).apply(null, arguments)
          }
          , Lq = b._emscripten_bind_RaycastInfo_get_m_contactNormalWS_0 = function() {
            return (Lq = b._emscripten_bind_RaycastInfo_get_m_contactNormalWS_0 = b.asm.Ao).apply(null, arguments)
          }
          , Mq = b._emscripten_bind_RaycastInfo_set_m_contactNormalWS_1 = function() {
            return (Mq = b._emscripten_bind_RaycastInfo_set_m_contactNormalWS_1 = b.asm.Bo).apply(null, arguments)
          }
          , Nq = b._emscripten_bind_RaycastInfo_get_m_contactPointWS_0 = function() {
            return (Nq = b._emscripten_bind_RaycastInfo_get_m_contactPointWS_0 = b.asm.Co).apply(null, arguments)
          }
          , Oq = b._emscripten_bind_RaycastInfo_set_m_contactPointWS_1 = function() {
            return (Oq = b._emscripten_bind_RaycastInfo_set_m_contactPointWS_1 = b.asm.Do).apply(null, arguments)
          }
          , Pq = b._emscripten_bind_RaycastInfo_get_m_suspensionLength_0 = function() {
            return (Pq = b._emscripten_bind_RaycastInfo_get_m_suspensionLength_0 = b.asm.Eo).apply(null, arguments)
          }
          , Qq = b._emscripten_bind_RaycastInfo_set_m_suspensionLength_1 = function() {
            return (Qq = b._emscripten_bind_RaycastInfo_set_m_suspensionLength_1 = b.asm.Fo).apply(null, arguments)
          }
          , Rq = b._emscripten_bind_RaycastInfo_get_m_hardPointWS_0 = function() {
            return (Rq = b._emscripten_bind_RaycastInfo_get_m_hardPointWS_0 = b.asm.Go).apply(null, arguments)
          }
          , Sq = b._emscripten_bind_RaycastInfo_set_m_hardPointWS_1 = function() {
            return (Sq = b._emscripten_bind_RaycastInfo_set_m_hardPointWS_1 = b.asm.Ho).apply(null, arguments)
          }
          , Tq = b._emscripten_bind_RaycastInfo_get_m_wheelDirectionWS_0 = function() {
            return (Tq = b._emscripten_bind_RaycastInfo_get_m_wheelDirectionWS_0 = b.asm.Io).apply(null, arguments)
          }
          , Uq = b._emscripten_bind_RaycastInfo_set_m_wheelDirectionWS_1 = function() {
            return (Uq = b._emscripten_bind_RaycastInfo_set_m_wheelDirectionWS_1 = b.asm.Jo).apply(null, arguments)
          }
          , Vq = b._emscripten_bind_RaycastInfo_get_m_wheelAxleWS_0 = function() {
            return (Vq = b._emscripten_bind_RaycastInfo_get_m_wheelAxleWS_0 = b.asm.Ko).apply(null, arguments)
          }
          , Wq = b._emscripten_bind_RaycastInfo_set_m_wheelAxleWS_1 = function() {
            return (Wq = b._emscripten_bind_RaycastInfo_set_m_wheelAxleWS_1 = b.asm.Lo).apply(null, arguments)
          }
          , Xq = b._emscripten_bind_RaycastInfo_get_m_isInContact_0 = function() {
            return (Xq = b._emscripten_bind_RaycastInfo_get_m_isInContact_0 = b.asm.Mo).apply(null, arguments)
          }
          , Yq = b._emscripten_bind_RaycastInfo_set_m_isInContact_1 = function() {
            return (Yq = b._emscripten_bind_RaycastInfo_set_m_isInContact_1 = b.asm.No).apply(null, arguments)
          }
          , Zq = b._emscripten_bind_RaycastInfo_get_m_groundObject_0 = function() {
            return (Zq = b._emscripten_bind_RaycastInfo_get_m_groundObject_0 = b.asm.Oo).apply(null, arguments)
          }
          , $q = b._emscripten_bind_RaycastInfo_set_m_groundObject_1 = function() {
            return ($q = b._emscripten_bind_RaycastInfo_set_m_groundObject_1 = b.asm.Po).apply(null, arguments)
          }
          , ar = b._emscripten_bind_RaycastInfo___destroy___0 = function() {
            return (ar = b._emscripten_bind_RaycastInfo___destroy___0 = b.asm.Qo).apply(null, arguments)
          }
          , br = b._emscripten_bind_btMultiSphereShape_btMultiSphereShape_3 = function() {
            return (br = b._emscripten_bind_btMultiSphereShape_btMultiSphereShape_3 = b.asm.Ro).apply(null, arguments)
          }
          , cr = b._emscripten_bind_btMultiSphereShape_setLocalScaling_1 = function() {
            return (cr = b._emscripten_bind_btMultiSphereShape_setLocalScaling_1 = b.asm.So).apply(null, arguments)
          }
          , dr = b._emscripten_bind_btMultiSphereShape_getLocalScaling_0 = function() {
            return (dr = b._emscripten_bind_btMultiSphereShape_getLocalScaling_0 = b.asm.To).apply(null, arguments)
          }
          , er = b._emscripten_bind_btMultiSphereShape_calculateLocalInertia_2 = function() {
            return (er = b._emscripten_bind_btMultiSphereShape_calculateLocalInertia_2 = b.asm.Uo).apply(null, arguments)
          }
          , fr = b._emscripten_bind_btMultiSphereShape___destroy___0 = function() {
            return (fr = b._emscripten_bind_btMultiSphereShape___destroy___0 = b.asm.Vo).apply(null, arguments)
          }
          , gr = b._emscripten_bind_btSoftBody_btSoftBody_4 = function() {
            return (gr = b._emscripten_bind_btSoftBody_btSoftBody_4 = b.asm.Wo).apply(null, arguments)
          }
          , hr = b._emscripten_bind_btSoftBody_checkLink_2 = function() {
            return (hr = b._emscripten_bind_btSoftBody_checkLink_2 = b.asm.Xo).apply(null, arguments)
          }
          , ir = b._emscripten_bind_btSoftBody_checkFace_3 = function() {
            return (ir = b._emscripten_bind_btSoftBody_checkFace_3 = b.asm.Yo).apply(null, arguments)
          }
          , jr = b._emscripten_bind_btSoftBody_appendMaterial_0 = function() {
            return (jr = b._emscripten_bind_btSoftBody_appendMaterial_0 = b.asm.Zo).apply(null, arguments)
          }
          , kr = b._emscripten_bind_btSoftBody_appendNode_2 = function() {
            return (kr = b._emscripten_bind_btSoftBody_appendNode_2 = b.asm._o).apply(null, arguments)
          }
          , lr = b._emscripten_bind_btSoftBody_appendLink_4 = function() {
            return (lr = b._emscripten_bind_btSoftBody_appendLink_4 = b.asm.$o).apply(null, arguments)
          }
          , mr = b._emscripten_bind_btSoftBody_appendFace_4 = function() {
            return (mr = b._emscripten_bind_btSoftBody_appendFace_4 = b.asm.ap).apply(null, arguments)
          }
          , nr = b._emscripten_bind_btSoftBody_appendTetra_5 = function() {
            return (nr = b._emscripten_bind_btSoftBody_appendTetra_5 = b.asm.bp).apply(null, arguments)
          }
          , or = b._emscripten_bind_btSoftBody_appendAnchor_4 = function() {
            return (or = b._emscripten_bind_btSoftBody_appendAnchor_4 = b.asm.cp).apply(null, arguments)
          }
          , pr = b._emscripten_bind_btSoftBody_addForce_1 = function() {
            return (pr = b._emscripten_bind_btSoftBody_addForce_1 = b.asm.dp).apply(null, arguments)
          }
          , qr = b._emscripten_bind_btSoftBody_addForce_2 = function() {
            return (qr = b._emscripten_bind_btSoftBody_addForce_2 = b.asm.ep).apply(null, arguments)
          }
          , rr = b._emscripten_bind_btSoftBody_addAeroForceToNode_2 = function() {
            return (rr = b._emscripten_bind_btSoftBody_addAeroForceToNode_2 = b.asm.fp).apply(null, arguments)
          }
          , sr = b._emscripten_bind_btSoftBody_getTotalMass_0 = function() {
            return (sr = b._emscripten_bind_btSoftBody_getTotalMass_0 = b.asm.gp).apply(null, arguments)
          }
          , tr = b._emscripten_bind_btSoftBody_setTotalMass_2 = function() {
            return (tr = b._emscripten_bind_btSoftBody_setTotalMass_2 = b.asm.hp).apply(null, arguments)
          }
          , ur = b._emscripten_bind_btSoftBody_setMass_2 = function() {
            return (ur = b._emscripten_bind_btSoftBody_setMass_2 = b.asm.ip).apply(null, arguments)
          }
          , vr = b._emscripten_bind_btSoftBody_transform_1 = function() {
            return (vr = b._emscripten_bind_btSoftBody_transform_1 = b.asm.jp).apply(null, arguments)
          }
          , wr = b._emscripten_bind_btSoftBody_translate_1 = function() {
            return (wr = b._emscripten_bind_btSoftBody_translate_1 = b.asm.kp).apply(null, arguments)
          }
          , xr = b._emscripten_bind_btSoftBody_rotate_1 = function() {
            return (xr = b._emscripten_bind_btSoftBody_rotate_1 = b.asm.lp).apply(null, arguments)
          }
          , yr = b._emscripten_bind_btSoftBody_scale_1 = function() {
            return (yr = b._emscripten_bind_btSoftBody_scale_1 = b.asm.mp).apply(null, arguments)
          }
          , zr = b._emscripten_bind_btSoftBody_generateClusters_1 = function() {
            return (zr = b._emscripten_bind_btSoftBody_generateClusters_1 = b.asm.np).apply(null, arguments)
          }
          , Ar = b._emscripten_bind_btSoftBody_generateClusters_2 = function() {
            return (Ar = b._emscripten_bind_btSoftBody_generateClusters_2 = b.asm.op).apply(null, arguments)
          }
          , Br = b._emscripten_bind_btSoftBody_generateBendingConstraints_2 = function() {
            return (Br = b._emscripten_bind_btSoftBody_generateBendingConstraints_2 = b.asm.pp).apply(null, arguments)
          }
          , Cr = b._emscripten_bind_btSoftBody_upcast_1 = function() {
            return (Cr = b._emscripten_bind_btSoftBody_upcast_1 = b.asm.qp).apply(null, arguments)
          }
          , Dr = b._emscripten_bind_btSoftBody_setAnisotropicFriction_2 = function() {
            return (Dr = b._emscripten_bind_btSoftBody_setAnisotropicFriction_2 = b.asm.rp).apply(null, arguments)
          }
          , Er = b._emscripten_bind_btSoftBody_getCollisionShape_0 = function() {
            return (Er = b._emscripten_bind_btSoftBody_getCollisionShape_0 = b.asm.sp).apply(null, arguments)
          }
          , Fr = b._emscripten_bind_btSoftBody_setContactProcessingThreshold_1 = function() {
            return (Fr = b._emscripten_bind_btSoftBody_setContactProcessingThreshold_1 = b.asm.tp).apply(null, arguments)
          }
          , Gr = b._emscripten_bind_btSoftBody_setActivationState_1 = function() {
            return (Gr = b._emscripten_bind_btSoftBody_setActivationState_1 = b.asm.up).apply(null, arguments)
          }
          , Hr = b._emscripten_bind_btSoftBody_forceActivationState_1 = function() {
            return (Hr = b._emscripten_bind_btSoftBody_forceActivationState_1 = b.asm.vp).apply(null, arguments)
          }
          , Ir = b._emscripten_bind_btSoftBody_activate_0 = function() {
            return (Ir = b._emscripten_bind_btSoftBody_activate_0 = b.asm.wp).apply(null, arguments)
          }
          , Jr = b._emscripten_bind_btSoftBody_activate_1 = function() {
            return (Jr = b._emscripten_bind_btSoftBody_activate_1 = b.asm.xp).apply(null, arguments)
          }
          , Kr = b._emscripten_bind_btSoftBody_isActive_0 = function() {
            return (Kr = b._emscripten_bind_btSoftBody_isActive_0 = b.asm.yp).apply(null, arguments)
          }
          , Lr = b._emscripten_bind_btSoftBody_isKinematicObject_0 = function() {
            return (Lr = b._emscripten_bind_btSoftBody_isKinematicObject_0 = b.asm.zp).apply(null, arguments)
          }
          , Mr = b._emscripten_bind_btSoftBody_isStaticObject_0 = function() {
            return (Mr = b._emscripten_bind_btSoftBody_isStaticObject_0 = b.asm.Ap).apply(null, arguments)
          }
          , Nr = b._emscripten_bind_btSoftBody_isStaticOrKinematicObject_0 = function() {
            return (Nr = b._emscripten_bind_btSoftBody_isStaticOrKinematicObject_0 = b.asm.Bp).apply(null, arguments)
          }
          , Or = b._emscripten_bind_btSoftBody_getRestitution_0 = function() {
            return (Or = b._emscripten_bind_btSoftBody_getRestitution_0 = b.asm.Cp).apply(null, arguments)
          }
          , Pr = b._emscripten_bind_btSoftBody_getFriction_0 = function() {
            return (Pr = b._emscripten_bind_btSoftBody_getFriction_0 = b.asm.Dp).apply(null, arguments)
          }
          , Qr = b._emscripten_bind_btSoftBody_getRollingFriction_0 = function() {
            return (Qr = b._emscripten_bind_btSoftBody_getRollingFriction_0 = b.asm.Ep).apply(null, arguments)
          }
          , Rr = b._emscripten_bind_btSoftBody_setRestitution_1 = function() {
            return (Rr = b._emscripten_bind_btSoftBody_setRestitution_1 = b.asm.Fp).apply(null, arguments)
          }
          , Sr = b._emscripten_bind_btSoftBody_setFriction_1 = function() {
            return (Sr = b._emscripten_bind_btSoftBody_setFriction_1 = b.asm.Gp).apply(null, arguments)
          }
          , Tr = b._emscripten_bind_btSoftBody_setRollingFriction_1 = function() {
            return (Tr = b._emscripten_bind_btSoftBody_setRollingFriction_1 = b.asm.Hp).apply(null, arguments)
          }
          , Ur = b._emscripten_bind_btSoftBody_getWorldTransform_0 = function() {
            return (Ur = b._emscripten_bind_btSoftBody_getWorldTransform_0 = b.asm.Ip).apply(null, arguments)
          }
          , Vr = b._emscripten_bind_btSoftBody_getCollisionFlags_0 = function() {
            return (Vr = b._emscripten_bind_btSoftBody_getCollisionFlags_0 = b.asm.Jp).apply(null, arguments)
          }
          , Wr = b._emscripten_bind_btSoftBody_setCollisionFlags_1 = function() {
            return (Wr = b._emscripten_bind_btSoftBody_setCollisionFlags_1 = b.asm.Kp).apply(null, arguments)
          }
          , Xr = b._emscripten_bind_btSoftBody_setWorldTransform_1 = function() {
            return (Xr = b._emscripten_bind_btSoftBody_setWorldTransform_1 = b.asm.Lp).apply(null, arguments)
          }
          , Yr = b._emscripten_bind_btSoftBody_setCollisionShape_1 = function() {
            return (Yr = b._emscripten_bind_btSoftBody_setCollisionShape_1 = b.asm.Mp).apply(null, arguments)
          }
          , Zr = b._emscripten_bind_btSoftBody_setCcdMotionThreshold_1 = function() {
            return (Zr = b._emscripten_bind_btSoftBody_setCcdMotionThreshold_1 = b.asm.Np).apply(null, arguments)
          }
          , $r = b._emscripten_bind_btSoftBody_setCcdSweptSphereRadius_1 = function() {
            return ($r = b._emscripten_bind_btSoftBody_setCcdSweptSphereRadius_1 = b.asm.Op).apply(null, arguments)
          }
          , as = b._emscripten_bind_btSoftBody_getUserIndex_0 = function() {
            return (as = b._emscripten_bind_btSoftBody_getUserIndex_0 = b.asm.Pp).apply(null, arguments)
          }
          , bs = b._emscripten_bind_btSoftBody_setUserIndex_1 = function() {
            return (bs = b._emscripten_bind_btSoftBody_setUserIndex_1 = b.asm.Qp).apply(null, arguments)
          }
          , cs = b._emscripten_bind_btSoftBody_getUserPointer_0 = function() {
            return (cs = b._emscripten_bind_btSoftBody_getUserPointer_0 = b.asm.Rp).apply(null, arguments)
          }
          , ds = b._emscripten_bind_btSoftBody_setUserPointer_1 = function() {
            return (ds = b._emscripten_bind_btSoftBody_setUserPointer_1 = b.asm.Sp).apply(null, arguments)
          }
          , es = b._emscripten_bind_btSoftBody_getBroadphaseHandle_0 = function() {
            return (es = b._emscripten_bind_btSoftBody_getBroadphaseHandle_0 = b.asm.Tp).apply(null, arguments)
          }
          , gs = b._emscripten_bind_btSoftBody_get_m_cfg_0 = function() {
            return (gs = b._emscripten_bind_btSoftBody_get_m_cfg_0 = b.asm.Up).apply(null, arguments)
          }
          , hs = b._emscripten_bind_btSoftBody_set_m_cfg_1 = function() {
            return (hs = b._emscripten_bind_btSoftBody_set_m_cfg_1 = b.asm.Vp).apply(null, arguments)
          }
          , is = b._emscripten_bind_btSoftBody_get_m_nodes_0 = function() {
            return (is = b._emscripten_bind_btSoftBody_get_m_nodes_0 = b.asm.Wp).apply(null, arguments)
          }
          , js = b._emscripten_bind_btSoftBody_set_m_nodes_1 = function() {
            return (js = b._emscripten_bind_btSoftBody_set_m_nodes_1 = b.asm.Xp).apply(null, arguments)
          }
          , ks = b._emscripten_bind_btSoftBody_get_m_materials_0 = function() {
            return (ks = b._emscripten_bind_btSoftBody_get_m_materials_0 = b.asm.Yp).apply(null, arguments)
          }
          , ls = b._emscripten_bind_btSoftBody_set_m_materials_1 = function() {
            return (ls = b._emscripten_bind_btSoftBody_set_m_materials_1 = b.asm.Zp).apply(null, arguments)
          }
          , ms = b._emscripten_bind_btSoftBody_get_m_anchors_0 = function() {
            return (ms = b._emscripten_bind_btSoftBody_get_m_anchors_0 = b.asm._p).apply(null, arguments)
          }
          , ns = b._emscripten_bind_btSoftBody_set_m_anchors_1 = function() {
            return (ns = b._emscripten_bind_btSoftBody_set_m_anchors_1 = b.asm.$p).apply(null, arguments)
          }
          , ps = b._emscripten_bind_btSoftBody___destroy___0 = function() {
            return (ps = b._emscripten_bind_btSoftBody___destroy___0 = b.asm.aq).apply(null, arguments)
          }
          , qs = b._emscripten_bind_btIntArray_size_0 = function() {
            return (qs = b._emscripten_bind_btIntArray_size_0 = b.asm.bq).apply(null, arguments)
          }
          , rs = b._emscripten_bind_btIntArray_at_1 = function() {
            return (rs = b._emscripten_bind_btIntArray_at_1 = b.asm.cq).apply(null, arguments)
          }
          , ss = b._emscripten_bind_btIntArray___destroy___0 = function() {
            return (ss = b._emscripten_bind_btIntArray___destroy___0 = b.asm.dq).apply(null, arguments)
          }
          , ts = b._emscripten_bind_Config_get_kVCF_0 = function() {
            return (ts = b._emscripten_bind_Config_get_kVCF_0 = b.asm.eq).apply(null, arguments)
          }
          , us = b._emscripten_bind_Config_set_kVCF_1 = function() {
            return (us = b._emscripten_bind_Config_set_kVCF_1 = b.asm.fq).apply(null, arguments)
          }
          , vs = b._emscripten_bind_Config_get_kDP_0 = function() {
            return (vs = b._emscripten_bind_Config_get_kDP_0 = b.asm.gq).apply(null, arguments)
          }
          , xs = b._emscripten_bind_Config_set_kDP_1 = function() {
            return (xs = b._emscripten_bind_Config_set_kDP_1 = b.asm.hq).apply(null, arguments)
          }
          , ys = b._emscripten_bind_Config_get_kDG_0 = function() {
            return (ys = b._emscripten_bind_Config_get_kDG_0 = b.asm.iq).apply(null, arguments)
          }
          , zs = b._emscripten_bind_Config_set_kDG_1 = function() {
            return (zs = b._emscripten_bind_Config_set_kDG_1 = b.asm.jq).apply(null, arguments)
          }
          , As = b._emscripten_bind_Config_get_kLF_0 = function() {
            return (As = b._emscripten_bind_Config_get_kLF_0 = b.asm.kq).apply(null, arguments)
          }
          , Bs = b._emscripten_bind_Config_set_kLF_1 = function() {
            return (Bs = b._emscripten_bind_Config_set_kLF_1 = b.asm.lq).apply(null, arguments)
          }
          , Cs = b._emscripten_bind_Config_get_kPR_0 = function() {
            return (Cs = b._emscripten_bind_Config_get_kPR_0 = b.asm.mq).apply(null, arguments)
          }
          , Ds = b._emscripten_bind_Config_set_kPR_1 = function() {
            return (Ds = b._emscripten_bind_Config_set_kPR_1 = b.asm.nq).apply(null, arguments)
          }
          , Es = b._emscripten_bind_Config_get_kVC_0 = function() {
            return (Es = b._emscripten_bind_Config_get_kVC_0 = b.asm.oq).apply(null, arguments)
          }
          , Fs = b._emscripten_bind_Config_set_kVC_1 = function() {
            return (Fs = b._emscripten_bind_Config_set_kVC_1 = b.asm.pq).apply(null, arguments)
          }
          , Gs = b._emscripten_bind_Config_get_kDF_0 = function() {
            return (Gs = b._emscripten_bind_Config_get_kDF_0 = b.asm.qq).apply(null, arguments)
          }
          , Hs = b._emscripten_bind_Config_set_kDF_1 = function() {
            return (Hs = b._emscripten_bind_Config_set_kDF_1 = b.asm.rq).apply(null, arguments)
          }
          , Is = b._emscripten_bind_Config_get_kMT_0 = function() {
            return (Is = b._emscripten_bind_Config_get_kMT_0 = b.asm.sq).apply(null, arguments)
          }
          , Js = b._emscripten_bind_Config_set_kMT_1 = function() {
            return (Js = b._emscripten_bind_Config_set_kMT_1 = b.asm.tq).apply(null, arguments)
          }
          , Ks = b._emscripten_bind_Config_get_kCHR_0 = function() {
            return (Ks = b._emscripten_bind_Config_get_kCHR_0 = b.asm.uq).apply(null, arguments)
          }
          , Ls = b._emscripten_bind_Config_set_kCHR_1 = function() {
            return (Ls = b._emscripten_bind_Config_set_kCHR_1 = b.asm.vq).apply(null, arguments)
          }
          , Ms = b._emscripten_bind_Config_get_kKHR_0 = function() {
            return (Ms = b._emscripten_bind_Config_get_kKHR_0 = b.asm.wq).apply(null, arguments)
          }
          , Ns = b._emscripten_bind_Config_set_kKHR_1 = function() {
            return (Ns = b._emscripten_bind_Config_set_kKHR_1 = b.asm.xq).apply(null, arguments)
          }
          , Os = b._emscripten_bind_Config_get_kSHR_0 = function() {
            return (Os = b._emscripten_bind_Config_get_kSHR_0 = b.asm.yq).apply(null, arguments)
          }
          , Ps = b._emscripten_bind_Config_set_kSHR_1 = function() {
            return (Ps = b._emscripten_bind_Config_set_kSHR_1 = b.asm.zq).apply(null, arguments)
          }
          , Qs = b._emscripten_bind_Config_get_kAHR_0 = function() {
            return (Qs = b._emscripten_bind_Config_get_kAHR_0 = b.asm.Aq).apply(null, arguments)
          }
          , Rs = b._emscripten_bind_Config_set_kAHR_1 = function() {
            return (Rs = b._emscripten_bind_Config_set_kAHR_1 = b.asm.Bq).apply(null, arguments)
          }
          , Ss = b._emscripten_bind_Config_get_kSRHR_CL_0 = function() {
            return (Ss = b._emscripten_bind_Config_get_kSRHR_CL_0 = b.asm.Cq).apply(null, arguments)
          }
          , Ts = b._emscripten_bind_Config_set_kSRHR_CL_1 = function() {
            return (Ts = b._emscripten_bind_Config_set_kSRHR_CL_1 = b.asm.Dq).apply(null, arguments)
          }
          , Us = b._emscripten_bind_Config_get_kSKHR_CL_0 = function() {
            return (Us = b._emscripten_bind_Config_get_kSKHR_CL_0 = b.asm.Eq).apply(null, arguments)
          }
          , Vs = b._emscripten_bind_Config_set_kSKHR_CL_1 = function() {
            return (Vs = b._emscripten_bind_Config_set_kSKHR_CL_1 = b.asm.Fq).apply(null, arguments)
          }
          , Ws = b._emscripten_bind_Config_get_kSSHR_CL_0 = function() {
            return (Ws = b._emscripten_bind_Config_get_kSSHR_CL_0 = b.asm.Gq).apply(null, arguments)
          }
          , Xs = b._emscripten_bind_Config_set_kSSHR_CL_1 = function() {
            return (Xs = b._emscripten_bind_Config_set_kSSHR_CL_1 = b.asm.Hq).apply(null, arguments)
          }
          , Ys = b._emscripten_bind_Config_get_kSR_SPLT_CL_0 = function() {
            return (Ys = b._emscripten_bind_Config_get_kSR_SPLT_CL_0 = b.asm.Iq).apply(null, arguments)
          }
          , Zs = b._emscripten_bind_Config_set_kSR_SPLT_CL_1 = function() {
            return (Zs = b._emscripten_bind_Config_set_kSR_SPLT_CL_1 = b.asm.Jq).apply(null, arguments)
          }
          , $s = b._emscripten_bind_Config_get_kSK_SPLT_CL_0 = function() {
            return ($s = b._emscripten_bind_Config_get_kSK_SPLT_CL_0 = b.asm.Kq).apply(null, arguments)
          }
          , at = b._emscripten_bind_Config_set_kSK_SPLT_CL_1 = function() {
            return (at = b._emscripten_bind_Config_set_kSK_SPLT_CL_1 = b.asm.Lq).apply(null, arguments)
          }
          , bt = b._emscripten_bind_Config_get_kSS_SPLT_CL_0 = function() {
            return (bt = b._emscripten_bind_Config_get_kSS_SPLT_CL_0 = b.asm.Mq).apply(null, arguments)
          }
          , ct = b._emscripten_bind_Config_set_kSS_SPLT_CL_1 = function() {
            return (ct = b._emscripten_bind_Config_set_kSS_SPLT_CL_1 = b.asm.Nq).apply(null, arguments)
          }
          , dt = b._emscripten_bind_Config_get_maxvolume_0 = function() {
            return (dt = b._emscripten_bind_Config_get_maxvolume_0 = b.asm.Oq).apply(null, arguments)
          }
          , et = b._emscripten_bind_Config_set_maxvolume_1 = function() {
            return (et = b._emscripten_bind_Config_set_maxvolume_1 = b.asm.Pq).apply(null, arguments)
          }
          , ft = b._emscripten_bind_Config_get_timescale_0 = function() {
            return (ft = b._emscripten_bind_Config_get_timescale_0 = b.asm.Qq).apply(null, arguments)
          }
          , gt = b._emscripten_bind_Config_set_timescale_1 = function() {
            return (gt = b._emscripten_bind_Config_set_timescale_1 = b.asm.Rq).apply(null, arguments)
          }
          , ht = b._emscripten_bind_Config_get_viterations_0 = function() {
            return (ht = b._emscripten_bind_Config_get_viterations_0 = b.asm.Sq).apply(null, arguments)
          }
          , it = b._emscripten_bind_Config_set_viterations_1 = function() {
            return (it = b._emscripten_bind_Config_set_viterations_1 = b.asm.Tq).apply(null, arguments)
          }
          , jt = b._emscripten_bind_Config_get_piterations_0 = function() {
            return (jt = b._emscripten_bind_Config_get_piterations_0 = b.asm.Uq).apply(null, arguments)
          }
          , kt = b._emscripten_bind_Config_set_piterations_1 = function() {
            return (kt = b._emscripten_bind_Config_set_piterations_1 = b.asm.Vq).apply(null, arguments)
          }
          , lt = b._emscripten_bind_Config_get_diterations_0 = function() {
            return (lt = b._emscripten_bind_Config_get_diterations_0 = b.asm.Wq).apply(null, arguments)
          }
          , mt = b._emscripten_bind_Config_set_diterations_1 = function() {
            return (mt = b._emscripten_bind_Config_set_diterations_1 = b.asm.Xq).apply(null, arguments)
          }
          , nt = b._emscripten_bind_Config_get_citerations_0 = function() {
            return (nt = b._emscripten_bind_Config_get_citerations_0 = b.asm.Yq).apply(null, arguments)
          }
          , ot = b._emscripten_bind_Config_set_citerations_1 = function() {
            return (ot = b._emscripten_bind_Config_set_citerations_1 = b.asm.Zq).apply(null, arguments)
          }
          , pt = b._emscripten_bind_Config_get_collisions_0 = function() {
            return (pt = b._emscripten_bind_Config_get_collisions_0 = b.asm._q).apply(null, arguments)
          }
          , qt = b._emscripten_bind_Config_set_collisions_1 = function() {
            return (qt = b._emscripten_bind_Config_set_collisions_1 = b.asm.$q).apply(null, arguments)
          }
          , rt = b._emscripten_bind_Config___destroy___0 = function() {
            return (rt = b._emscripten_bind_Config___destroy___0 = b.asm.ar).apply(null, arguments)
          }
          , st = b._emscripten_bind_Node_get_m_x_0 = function() {
            return (st = b._emscripten_bind_Node_get_m_x_0 = b.asm.br).apply(null, arguments)
          }
          , tt = b._emscripten_bind_Node_set_m_x_1 = function() {
            return (tt = b._emscripten_bind_Node_set_m_x_1 = b.asm.cr).apply(null, arguments)
          }
          , ut = b._emscripten_bind_Node_get_m_q_0 = function() {
            return (ut = b._emscripten_bind_Node_get_m_q_0 = b.asm.dr).apply(null, arguments)
          }
          , vt = b._emscripten_bind_Node_set_m_q_1 = function() {
            return (vt = b._emscripten_bind_Node_set_m_q_1 = b.asm.er).apply(null, arguments)
          }
          , wt = b._emscripten_bind_Node_get_m_v_0 = function() {
            return (wt = b._emscripten_bind_Node_get_m_v_0 = b.asm.fr).apply(null, arguments)
          }
          , xt = b._emscripten_bind_Node_set_m_v_1 = function() {
            return (xt = b._emscripten_bind_Node_set_m_v_1 = b.asm.gr).apply(null, arguments)
          }
          , yt = b._emscripten_bind_Node_get_m_f_0 = function() {
            return (yt = b._emscripten_bind_Node_get_m_f_0 = b.asm.hr).apply(null, arguments)
          }
          , zt = b._emscripten_bind_Node_set_m_f_1 = function() {
            return (zt = b._emscripten_bind_Node_set_m_f_1 = b.asm.ir).apply(null, arguments)
          }
          , At = b._emscripten_bind_Node_get_m_n_0 = function() {
            return (At = b._emscripten_bind_Node_get_m_n_0 = b.asm.jr).apply(null, arguments)
          }
          , Bt = b._emscripten_bind_Node_set_m_n_1 = function() {
            return (Bt = b._emscripten_bind_Node_set_m_n_1 = b.asm.kr).apply(null, arguments)
          }
          , Ct = b._emscripten_bind_Node_get_m_im_0 = function() {
            return (Ct = b._emscripten_bind_Node_get_m_im_0 = b.asm.lr).apply(null, arguments)
          }
          , Dt = b._emscripten_bind_Node_set_m_im_1 = function() {
            return (Dt = b._emscripten_bind_Node_set_m_im_1 = b.asm.mr).apply(null, arguments)
          }
          , Et = b._emscripten_bind_Node_get_m_area_0 = function() {
            return (Et = b._emscripten_bind_Node_get_m_area_0 = b.asm.nr).apply(null, arguments)
          }
          , Ft = b._emscripten_bind_Node_set_m_area_1 = function() {
            return (Ft = b._emscripten_bind_Node_set_m_area_1 = b.asm.or).apply(null, arguments)
          }
          , Gt = b._emscripten_bind_Node___destroy___0 = function() {
            return (Gt = b._emscripten_bind_Node___destroy___0 = b.asm.pr).apply(null, arguments)
          }
          , Ht = b._emscripten_bind_btGhostPairCallback_btGhostPairCallback_0 = function() {
            return (Ht = b._emscripten_bind_btGhostPairCallback_btGhostPairCallback_0 = b.asm.qr).apply(null, arguments)
          }
          , It = b._emscripten_bind_btGhostPairCallback___destroy___0 = function() {
            return (It = b._emscripten_bind_btGhostPairCallback___destroy___0 = b.asm.rr).apply(null, arguments)
          }
          , Jt = b._emscripten_bind_btOverlappingPairCallback___destroy___0 = function() {
            return (Jt = b._emscripten_bind_btOverlappingPairCallback___destroy___0 = b.asm.sr).apply(null, arguments)
          }
          , Kt = b._emscripten_bind_btKinematicCharacterController_btKinematicCharacterController_3 = function() {
            return (Kt = b._emscripten_bind_btKinematicCharacterController_btKinematicCharacterController_3 = b.asm.tr).apply(null, arguments)
          }
          , Lt = b._emscripten_bind_btKinematicCharacterController_btKinematicCharacterController_4 = function() {
            return (Lt = b._emscripten_bind_btKinematicCharacterController_btKinematicCharacterController_4 = b.asm.ur).apply(null, arguments)
          }
          , Mt = b._emscripten_bind_btKinematicCharacterController_setUpAxis_1 = function() {
            return (Mt = b._emscripten_bind_btKinematicCharacterController_setUpAxis_1 = b.asm.vr).apply(null, arguments)
          }
          , Nt = b._emscripten_bind_btKinematicCharacterController_setWalkDirection_1 = function() {
            return (Nt = b._emscripten_bind_btKinematicCharacterController_setWalkDirection_1 = b.asm.wr).apply(null, arguments)
          }
          , Ot = b._emscripten_bind_btKinematicCharacterController_setVelocityForTimeInterval_2 = function() {
            return (Ot = b._emscripten_bind_btKinematicCharacterController_setVelocityForTimeInterval_2 = b.asm.xr).apply(null, arguments)
          }
          , Pt = b._emscripten_bind_btKinematicCharacterController_warp_1 = function() {
            return (Pt = b._emscripten_bind_btKinematicCharacterController_warp_1 = b.asm.yr).apply(null, arguments)
          }
          , Qt = b._emscripten_bind_btKinematicCharacterController_preStep_1 = function() {
            return (Qt = b._emscripten_bind_btKinematicCharacterController_preStep_1 = b.asm.zr).apply(null, arguments)
          }
          , Rt = b._emscripten_bind_btKinematicCharacterController_playerStep_2 = function() {
            return (Rt = b._emscripten_bind_btKinematicCharacterController_playerStep_2 = b.asm.Ar).apply(null, arguments)
          }
          , St = b._emscripten_bind_btKinematicCharacterController_setFallSpeed_1 = function() {
            return (St = b._emscripten_bind_btKinematicCharacterController_setFallSpeed_1 = b.asm.Br).apply(null, arguments)
          }
          , Tt = b._emscripten_bind_btKinematicCharacterController_setJumpSpeed_1 = function() {
            return (Tt = b._emscripten_bind_btKinematicCharacterController_setJumpSpeed_1 = b.asm.Cr).apply(null, arguments)
          }
          , Ut = b._emscripten_bind_btKinematicCharacterController_setMaxJumpHeight_1 = function() {
            return (Ut = b._emscripten_bind_btKinematicCharacterController_setMaxJumpHeight_1 = b.asm.Dr).apply(null, arguments)
          }
          , Vt = b._emscripten_bind_btKinematicCharacterController_canJump_0 = function() {
            return (Vt = b._emscripten_bind_btKinematicCharacterController_canJump_0 = b.asm.Er).apply(null, arguments)
          }
          , Wt = b._emscripten_bind_btKinematicCharacterController_jump_0 = function() {
            return (Wt = b._emscripten_bind_btKinematicCharacterController_jump_0 = b.asm.Fr).apply(null, arguments)
          }
          , Xt = b._emscripten_bind_btKinematicCharacterController_setGravity_1 = function() {
            return (Xt = b._emscripten_bind_btKinematicCharacterController_setGravity_1 = b.asm.Gr).apply(null, arguments)
          }
          , Yt = b._emscripten_bind_btKinematicCharacterController_getGravity_0 = function() {
            return (Yt = b._emscripten_bind_btKinematicCharacterController_getGravity_0 = b.asm.Hr).apply(null, arguments)
          }
          , Zt = b._emscripten_bind_btKinematicCharacterController_setMaxSlope_1 = function() {
            return (Zt = b._emscripten_bind_btKinematicCharacterController_setMaxSlope_1 = b.asm.Ir).apply(null, arguments)
          }
          , $t = b._emscripten_bind_btKinematicCharacterController_getMaxSlope_0 = function() {
            return ($t = b._emscripten_bind_btKinematicCharacterController_getMaxSlope_0 = b.asm.Jr).apply(null, arguments)
          }
          , au = b._emscripten_bind_btKinematicCharacterController_getGhostObject_0 = function() {
            return (au = b._emscripten_bind_btKinematicCharacterController_getGhostObject_0 = b.asm.Kr).apply(null, arguments)
          }
          , bu = b._emscripten_bind_btKinematicCharacterController_setUseGhostSweepTest_1 = function() {
            return (bu = b._emscripten_bind_btKinematicCharacterController_setUseGhostSweepTest_1 = b.asm.Lr).apply(null, arguments)
          }
          , cu = b._emscripten_bind_btKinematicCharacterController_onGround_0 = function() {
            return (cu = b._emscripten_bind_btKinematicCharacterController_onGround_0 = b.asm.Mr).apply(null, arguments)
          }
          , du = b._emscripten_bind_btKinematicCharacterController_setUpInterpolate_1 = function() {
            return (du = b._emscripten_bind_btKinematicCharacterController_setUpInterpolate_1 = b.asm.Nr).apply(null, arguments)
          }
          , eu = b._emscripten_bind_btKinematicCharacterController_updateAction_2 = function() {
            return (eu = b._emscripten_bind_btKinematicCharacterController_updateAction_2 = b.asm.Or).apply(null, arguments)
          }
          , fu = b._emscripten_bind_btKinematicCharacterController___destroy___0 = function() {
            return (fu = b._emscripten_bind_btKinematicCharacterController___destroy___0 = b.asm.Pr).apply(null, arguments)
          }
          , gu = b._emscripten_bind_btSoftBodyArray_size_0 = function() {
            return (gu = b._emscripten_bind_btSoftBodyArray_size_0 = b.asm.Qr).apply(null, arguments)
          }
          , hu = b._emscripten_bind_btSoftBodyArray_at_1 = function() {
            return (hu = b._emscripten_bind_btSoftBodyArray_at_1 = b.asm.Rr).apply(null, arguments)
          }
          , iu = b._emscripten_bind_btSoftBodyArray___destroy___0 = function() {
            return (iu = b._emscripten_bind_btSoftBodyArray___destroy___0 = b.asm.Sr).apply(null, arguments)
          }
          , ju = b._emscripten_bind_btFaceArray_size_0 = function() {
            return (ju = b._emscripten_bind_btFaceArray_size_0 = b.asm.Tr).apply(null, arguments)
          }
          , ku = b._emscripten_bind_btFaceArray_at_1 = function() {
            return (ku = b._emscripten_bind_btFaceArray_at_1 = b.asm.Ur).apply(null, arguments)
          }
          , lu = b._emscripten_bind_btFaceArray___destroy___0 = function() {
            return (lu = b._emscripten_bind_btFaceArray___destroy___0 = b.asm.Vr).apply(null, arguments)
          }
          , mu = b._emscripten_bind_btStaticPlaneShape_btStaticPlaneShape_2 = function() {
            return (mu = b._emscripten_bind_btStaticPlaneShape_btStaticPlaneShape_2 = b.asm.Wr).apply(null, arguments)
          }
          , nu = b._emscripten_bind_btStaticPlaneShape_setLocalScaling_1 = function() {
            return (nu = b._emscripten_bind_btStaticPlaneShape_setLocalScaling_1 = b.asm.Xr).apply(null, arguments)
          }
          , ou = b._emscripten_bind_btStaticPlaneShape_getLocalScaling_0 = function() {
            return (ou = b._emscripten_bind_btStaticPlaneShape_getLocalScaling_0 = b.asm.Yr).apply(null, arguments)
          }
          , pu = b._emscripten_bind_btStaticPlaneShape_calculateLocalInertia_2 = function() {
            return (pu = b._emscripten_bind_btStaticPlaneShape_calculateLocalInertia_2 = b.asm.Zr).apply(null, arguments)
          }
          , qu = b._emscripten_bind_btStaticPlaneShape___destroy___0 = function() {
            return (qu = b._emscripten_bind_btStaticPlaneShape___destroy___0 = b.asm._r).apply(null, arguments)
          }
          , ru = b._emscripten_bind_btOverlappingPairCache_setInternalGhostPairCallback_1 = function() {
            return (ru = b._emscripten_bind_btOverlappingPairCache_setInternalGhostPairCallback_1 = b.asm.$r).apply(null, arguments)
          }
          , su = b._emscripten_bind_btOverlappingPairCache_getNumOverlappingPairs_0 = function() {
            return (su = b._emscripten_bind_btOverlappingPairCache_getNumOverlappingPairs_0 = b.asm.as).apply(null, arguments)
          }
          , tu = b._emscripten_bind_btOverlappingPairCache___destroy___0 = function() {
            return (tu = b._emscripten_bind_btOverlappingPairCache___destroy___0 = b.asm.bs).apply(null, arguments)
          }
          , uu = b._emscripten_bind_btIndexedMesh_get_m_numTriangles_0 = function() {
            return (uu = b._emscripten_bind_btIndexedMesh_get_m_numTriangles_0 = b.asm.cs).apply(null, arguments)
          }
          , vu = b._emscripten_bind_btIndexedMesh_set_m_numTriangles_1 = function() {
            return (vu = b._emscripten_bind_btIndexedMesh_set_m_numTriangles_1 = b.asm.ds).apply(null, arguments)
          }
          , wu = b._emscripten_bind_btIndexedMesh___destroy___0 = function() {
            return (wu = b._emscripten_bind_btIndexedMesh___destroy___0 = b.asm.es).apply(null, arguments)
          }
          , xu = b._emscripten_bind_btSoftRigidDynamicsWorld_btSoftRigidDynamicsWorld_5 = function() {
            return (xu = b._emscripten_bind_btSoftRigidDynamicsWorld_btSoftRigidDynamicsWorld_5 = b.asm.fs).apply(null, arguments)
          }
          , yu = b._emscripten_bind_btSoftRigidDynamicsWorld_addSoftBody_3 = function() {
            return (yu = b._emscripten_bind_btSoftRigidDynamicsWorld_addSoftBody_3 = b.asm.gs).apply(null, arguments)
          }
          , zu = b._emscripten_bind_btSoftRigidDynamicsWorld_removeSoftBody_1 = function() {
            return (zu = b._emscripten_bind_btSoftRigidDynamicsWorld_removeSoftBody_1 = b.asm.hs).apply(null, arguments)
          }
          , Au = b._emscripten_bind_btSoftRigidDynamicsWorld_removeCollisionObject_1 = function() {
            return (Au = b._emscripten_bind_btSoftRigidDynamicsWorld_removeCollisionObject_1 = b.asm.is).apply(null, arguments)
          }
          , Bu = b._emscripten_bind_btSoftRigidDynamicsWorld_getWorldInfo_0 = function() {
            return (Bu = b._emscripten_bind_btSoftRigidDynamicsWorld_getWorldInfo_0 = b.asm.js).apply(null, arguments)
          }
          , Cu = b._emscripten_bind_btSoftRigidDynamicsWorld_getSoftBodyArray_0 = function() {
            return (Cu = b._emscripten_bind_btSoftRigidDynamicsWorld_getSoftBodyArray_0 = b.asm.ks).apply(null, arguments)
          }
          , Du = b._emscripten_bind_btSoftRigidDynamicsWorld_getDispatcher_0 = function() {
            return (Du = b._emscripten_bind_btSoftRigidDynamicsWorld_getDispatcher_0 = b.asm.ls).apply(null, arguments)
          }
          , Eu = b._emscripten_bind_btSoftRigidDynamicsWorld_rayTest_3 = function() {
            return (Eu = b._emscripten_bind_btSoftRigidDynamicsWorld_rayTest_3 = b.asm.ms).apply(null, arguments)
          }
          , Fu = b._emscripten_bind_btSoftRigidDynamicsWorld_getPairCache_0 = function() {
            return (Fu = b._emscripten_bind_btSoftRigidDynamicsWorld_getPairCache_0 = b.asm.ns).apply(null, arguments)
          }
          , Gu = b._emscripten_bind_btSoftRigidDynamicsWorld_getDispatchInfo_0 = function() {
            return (Gu = b._emscripten_bind_btSoftRigidDynamicsWorld_getDispatchInfo_0 = b.asm.os).apply(null, arguments)
          }
          , Hu = b._emscripten_bind_btSoftRigidDynamicsWorld_addCollisionObject_1 = function() {
            return (Hu = b._emscripten_bind_btSoftRigidDynamicsWorld_addCollisionObject_1 = b.asm.ps).apply(null, arguments)
          }
          , Iu = b._emscripten_bind_btSoftRigidDynamicsWorld_addCollisionObject_2 = function() {
            return (Iu = b._emscripten_bind_btSoftRigidDynamicsWorld_addCollisionObject_2 = b.asm.qs).apply(null, arguments)
          }
          , Ju = b._emscripten_bind_btSoftRigidDynamicsWorld_addCollisionObject_3 = function() {
            return (Ju = b._emscripten_bind_btSoftRigidDynamicsWorld_addCollisionObject_3 = b.asm.rs).apply(null, arguments)
          }
          , Ku = b._emscripten_bind_btSoftRigidDynamicsWorld_getBroadphase_0 = function() {
            return (Ku = b._emscripten_bind_btSoftRigidDynamicsWorld_getBroadphase_0 = b.asm.ss).apply(null, arguments)
          }
          , Lu = b._emscripten_bind_btSoftRigidDynamicsWorld_convexSweepTest_5 = function() {
            return (Lu = b._emscripten_bind_btSoftRigidDynamicsWorld_convexSweepTest_5 = b.asm.ts).apply(null, arguments)
          }
          , Mu = b._emscripten_bind_btSoftRigidDynamicsWorld_contactPairTest_3 = function() {
            return (Mu = b._emscripten_bind_btSoftRigidDynamicsWorld_contactPairTest_3 = b.asm.us).apply(null, arguments)
          }
          , Nu = b._emscripten_bind_btSoftRigidDynamicsWorld_contactTest_2 = function() {
            return (Nu = b._emscripten_bind_btSoftRigidDynamicsWorld_contactTest_2 = b.asm.vs).apply(null, arguments)
          }
          , Ou = b._emscripten_bind_btSoftRigidDynamicsWorld_updateSingleAabb_1 = function() {
            return (Ou = b._emscripten_bind_btSoftRigidDynamicsWorld_updateSingleAabb_1 = b.asm.ws).apply(null, arguments)
          }
          , Pu = b._emscripten_bind_btSoftRigidDynamicsWorld_setDebugDrawer_1 = function() {
            return (Pu = b._emscripten_bind_btSoftRigidDynamicsWorld_setDebugDrawer_1 = b.asm.xs).apply(null, arguments)
          }
          , Qu = b._emscripten_bind_btSoftRigidDynamicsWorld_getDebugDrawer_0 = function() {
            return (Qu = b._emscripten_bind_btSoftRigidDynamicsWorld_getDebugDrawer_0 = b.asm.ys).apply(null, arguments)
          }
          , Ru = b._emscripten_bind_btSoftRigidDynamicsWorld_debugDrawWorld_0 = function() {
            return (Ru = b._emscripten_bind_btSoftRigidDynamicsWorld_debugDrawWorld_0 = b.asm.zs).apply(null, arguments)
          }
          , Su = b._emscripten_bind_btSoftRigidDynamicsWorld_debugDrawObject_3 = function() {
            return (Su = b._emscripten_bind_btSoftRigidDynamicsWorld_debugDrawObject_3 = b.asm.As).apply(null, arguments)
          }
          , Tu = b._emscripten_bind_btSoftRigidDynamicsWorld_setGravity_1 = function() {
            return (Tu = b._emscripten_bind_btSoftRigidDynamicsWorld_setGravity_1 = b.asm.Bs).apply(null, arguments)
          }
          , Uu = b._emscripten_bind_btSoftRigidDynamicsWorld_getGravity_0 = function() {
            return (Uu = b._emscripten_bind_btSoftRigidDynamicsWorld_getGravity_0 = b.asm.Cs).apply(null, arguments)
          }
          , Vu = b._emscripten_bind_btSoftRigidDynamicsWorld_addRigidBody_1 = function() {
            return (Vu = b._emscripten_bind_btSoftRigidDynamicsWorld_addRigidBody_1 = b.asm.Ds).apply(null, arguments)
          }
          , Wu = b._emscripten_bind_btSoftRigidDynamicsWorld_addRigidBody_3 = function() {
            return (Wu = b._emscripten_bind_btSoftRigidDynamicsWorld_addRigidBody_3 = b.asm.Es).apply(null, arguments)
          }
          , Xu = b._emscripten_bind_btSoftRigidDynamicsWorld_removeRigidBody_1 = function() {
            return (Xu = b._emscripten_bind_btSoftRigidDynamicsWorld_removeRigidBody_1 = b.asm.Fs).apply(null, arguments)
          }
          , Yu = b._emscripten_bind_btSoftRigidDynamicsWorld_addConstraint_1 = function() {
            return (Yu = b._emscripten_bind_btSoftRigidDynamicsWorld_addConstraint_1 = b.asm.Gs).apply(null, arguments)
          }
          , Zu = b._emscripten_bind_btSoftRigidDynamicsWorld_addConstraint_2 = function() {
            return (Zu = b._emscripten_bind_btSoftRigidDynamicsWorld_addConstraint_2 = b.asm.Hs).apply(null, arguments)
          }
          , $u = b._emscripten_bind_btSoftRigidDynamicsWorld_removeConstraint_1 = function() {
            return ($u = b._emscripten_bind_btSoftRigidDynamicsWorld_removeConstraint_1 = b.asm.Is).apply(null, arguments)
          }
          , av = b._emscripten_bind_btSoftRigidDynamicsWorld_stepSimulation_1 = function() {
            return (av = b._emscripten_bind_btSoftRigidDynamicsWorld_stepSimulation_1 = b.asm.Js).apply(null, arguments)
          }
          , bv = b._emscripten_bind_btSoftRigidDynamicsWorld_stepSimulation_2 = function() {
            return (bv = b._emscripten_bind_btSoftRigidDynamicsWorld_stepSimulation_2 = b.asm.Ks).apply(null, arguments)
          }
          , cv = b._emscripten_bind_btSoftRigidDynamicsWorld_stepSimulation_3 = function() {
            return (cv = b._emscripten_bind_btSoftRigidDynamicsWorld_stepSimulation_3 = b.asm.Ls).apply(null, arguments)
          }
          , dv = b._emscripten_bind_btSoftRigidDynamicsWorld_setContactAddedCallback_1 = function() {
            return (dv = b._emscripten_bind_btSoftRigidDynamicsWorld_setContactAddedCallback_1 = b.asm.Ms).apply(null, arguments)
          }
          , ev = b._emscripten_bind_btSoftRigidDynamicsWorld_setContactProcessedCallback_1 = function() {
            return (ev = b._emscripten_bind_btSoftRigidDynamicsWorld_setContactProcessedCallback_1 = b.asm.Ns).apply(null, arguments)
          }
          , fv = b._emscripten_bind_btSoftRigidDynamicsWorld_setContactDestroyedCallback_1 = function() {
            return (fv = b._emscripten_bind_btSoftRigidDynamicsWorld_setContactDestroyedCallback_1 = b.asm.Os).apply(null, arguments)
          }
          , gv = b._emscripten_bind_btSoftRigidDynamicsWorld_addAction_1 = function() {
            return (gv = b._emscripten_bind_btSoftRigidDynamicsWorld_addAction_1 = b.asm.Ps).apply(null, arguments)
          }
          , hv = b._emscripten_bind_btSoftRigidDynamicsWorld_removeAction_1 = function() {
            return (hv = b._emscripten_bind_btSoftRigidDynamicsWorld_removeAction_1 = b.asm.Qs).apply(null, arguments)
          }
          , iv = b._emscripten_bind_btSoftRigidDynamicsWorld_getSolverInfo_0 = function() {
            return (iv = b._emscripten_bind_btSoftRigidDynamicsWorld_getSolverInfo_0 = b.asm.Rs).apply(null, arguments)
          }
          , jv = b._emscripten_bind_btSoftRigidDynamicsWorld_setInternalTickCallback_1 = function() {
            return (jv = b._emscripten_bind_btSoftRigidDynamicsWorld_setInternalTickCallback_1 = b.asm.Ss).apply(null, arguments)
          }
          , kv = b._emscripten_bind_btSoftRigidDynamicsWorld_setInternalTickCallback_2 = function() {
            return (kv = b._emscripten_bind_btSoftRigidDynamicsWorld_setInternalTickCallback_2 = b.asm.Ts).apply(null, arguments)
          }
          , lv = b._emscripten_bind_btSoftRigidDynamicsWorld_setInternalTickCallback_3 = function() {
            return (lv = b._emscripten_bind_btSoftRigidDynamicsWorld_setInternalTickCallback_3 = b.asm.Us).apply(null, arguments)
          }
          , mv = b._emscripten_bind_btSoftRigidDynamicsWorld___destroy___0 = function() {
            return (mv = b._emscripten_bind_btSoftRigidDynamicsWorld___destroy___0 = b.asm.Vs).apply(null, arguments)
          }
          , nv = b._emscripten_bind_btFixedConstraint_btFixedConstraint_4 = function() {
            return (nv = b._emscripten_bind_btFixedConstraint_btFixedConstraint_4 = b.asm.Ws).apply(null, arguments)
          }
          , ov = b._emscripten_bind_btFixedConstraint_enableFeedback_1 = function() {
            return (ov = b._emscripten_bind_btFixedConstraint_enableFeedback_1 = b.asm.Xs).apply(null, arguments)
          }
          , pv = b._emscripten_bind_btFixedConstraint_getBreakingImpulseThreshold_0 = function() {
            return (pv = b._emscripten_bind_btFixedConstraint_getBreakingImpulseThreshold_0 = b.asm.Ys).apply(null, arguments)
          }
          , qv = b._emscripten_bind_btFixedConstraint_setBreakingImpulseThreshold_1 = function() {
            return (qv = b._emscripten_bind_btFixedConstraint_setBreakingImpulseThreshold_1 = b.asm.Zs).apply(null, arguments)
          }
          , rv = b._emscripten_bind_btFixedConstraint_getParam_2 = function() {
            return (rv = b._emscripten_bind_btFixedConstraint_getParam_2 = b.asm._s).apply(null, arguments)
          }
          , sv = b._emscripten_bind_btFixedConstraint_setParam_3 = function() {
            return (sv = b._emscripten_bind_btFixedConstraint_setParam_3 = b.asm.$s).apply(null, arguments)
          }
          , tv = b._emscripten_bind_btFixedConstraint___destroy___0 = function() {
            return (tv = b._emscripten_bind_btFixedConstraint___destroy___0 = b.asm.at).apply(null, arguments)
          }
          , uv = b._emscripten_bind_btTransform_btTransform_0 = function() {
            return (uv = b._emscripten_bind_btTransform_btTransform_0 = b.asm.bt).apply(null, arguments)
          }
          , vv = b._emscripten_bind_btTransform_btTransform_2 = function() {
            return (vv = b._emscripten_bind_btTransform_btTransform_2 = b.asm.ct).apply(null, arguments)
          }
          , wv = b._emscripten_bind_btTransform_setIdentity_0 = function() {
            return (wv = b._emscripten_bind_btTransform_setIdentity_0 = b.asm.dt).apply(null, arguments)
          }
          , xv = b._emscripten_bind_btTransform_setOrigin_1 = function() {
            return (xv = b._emscripten_bind_btTransform_setOrigin_1 = b.asm.et).apply(null, arguments)
          }
          , yv = b._emscripten_bind_btTransform_setRotation_1 = function() {
            return (yv = b._emscripten_bind_btTransform_setRotation_1 = b.asm.ft).apply(null, arguments)
          }
          , zv = b._emscripten_bind_btTransform_getOrigin_0 = function() {
            return (zv = b._emscripten_bind_btTransform_getOrigin_0 = b.asm.gt).apply(null, arguments)
          }
          , Av = b._emscripten_bind_btTransform_getRotation_0 = function() {
            return (Av = b._emscripten_bind_btTransform_getRotation_0 = b.asm.ht).apply(null, arguments)
          }
          , Bv = b._emscripten_bind_btTransform_getBasis_0 = function() {
            return (Bv = b._emscripten_bind_btTransform_getBasis_0 = b.asm.it).apply(null, arguments)
          }
          , Cv = b._emscripten_bind_btTransform_setFromOpenGLMatrix_1 = function() {
            return (Cv = b._emscripten_bind_btTransform_setFromOpenGLMatrix_1 = b.asm.jt).apply(null, arguments)
          }
          , Dv = b._emscripten_bind_btTransform_inverse_0 = function() {
            return (Dv = b._emscripten_bind_btTransform_inverse_0 = b.asm.kt).apply(null, arguments)
          }
          , Ev = b._emscripten_bind_btTransform_op_mul_1 = function() {
            return (Ev = b._emscripten_bind_btTransform_op_mul_1 = b.asm.lt).apply(null, arguments)
          }
          , Fv = b._emscripten_bind_btTransform___destroy___0 = function() {
            return (Fv = b._emscripten_bind_btTransform___destroy___0 = b.asm.mt).apply(null, arguments)
          }
          , Gv = b._emscripten_bind_ClosestRayResultCallback_ClosestRayResultCallback_2 = function() {
            return (Gv = b._emscripten_bind_ClosestRayResultCallback_ClosestRayResultCallback_2 = b.asm.nt).apply(null, arguments)
          }
          , Hv = b._emscripten_bind_ClosestRayResultCallback_hasHit_0 = function() {
            return (Hv = b._emscripten_bind_ClosestRayResultCallback_hasHit_0 = b.asm.ot).apply(null, arguments)
          }
          , Iv = b._emscripten_bind_ClosestRayResultCallback_get_m_rayFromWorld_0 = function() {
            return (Iv = b._emscripten_bind_ClosestRayResultCallback_get_m_rayFromWorld_0 = b.asm.pt).apply(null, arguments)
          }
          , Jv = b._emscripten_bind_ClosestRayResultCallback_set_m_rayFromWorld_1 = function() {
            return (Jv = b._emscripten_bind_ClosestRayResultCallback_set_m_rayFromWorld_1 = b.asm.qt).apply(null, arguments)
          }
          , Kv = b._emscripten_bind_ClosestRayResultCallback_get_m_rayToWorld_0 = function() {
            return (Kv = b._emscripten_bind_ClosestRayResultCallback_get_m_rayToWorld_0 = b.asm.rt).apply(null, arguments)
          }
          , Lv = b._emscripten_bind_ClosestRayResultCallback_set_m_rayToWorld_1 = function() {
            return (Lv = b._emscripten_bind_ClosestRayResultCallback_set_m_rayToWorld_1 = b.asm.st).apply(null, arguments)
          }
          , Mv = b._emscripten_bind_ClosestRayResultCallback_get_m_hitNormalWorld_0 = function() {
            return (Mv = b._emscripten_bind_ClosestRayResultCallback_get_m_hitNormalWorld_0 = b.asm.tt).apply(null, arguments)
          }
          , Nv = b._emscripten_bind_ClosestRayResultCallback_set_m_hitNormalWorld_1 = function() {
            return (Nv = b._emscripten_bind_ClosestRayResultCallback_set_m_hitNormalWorld_1 = b.asm.ut).apply(null, arguments)
          }
          , Ov = b._emscripten_bind_ClosestRayResultCallback_get_m_hitPointWorld_0 = function() {
            return (Ov = b._emscripten_bind_ClosestRayResultCallback_get_m_hitPointWorld_0 = b.asm.vt).apply(null, arguments)
          }
          , Pv = b._emscripten_bind_ClosestRayResultCallback_set_m_hitPointWorld_1 = function() {
            return (Pv = b._emscripten_bind_ClosestRayResultCallback_set_m_hitPointWorld_1 = b.asm.wt).apply(null, arguments)
          }
          , Qv = b._emscripten_bind_ClosestRayResultCallback_get_m_collisionFilterGroup_0 = function() {
            return (Qv = b._emscripten_bind_ClosestRayResultCallback_get_m_collisionFilterGroup_0 = b.asm.xt).apply(null, arguments)
          }
          , Rv = b._emscripten_bind_ClosestRayResultCallback_set_m_collisionFilterGroup_1 = function() {
            return (Rv = b._emscripten_bind_ClosestRayResultCallback_set_m_collisionFilterGroup_1 = b.asm.yt).apply(null, arguments)
          }
          , Sv = b._emscripten_bind_ClosestRayResultCallback_get_m_collisionFilterMask_0 = function() {
            return (Sv = b._emscripten_bind_ClosestRayResultCallback_get_m_collisionFilterMask_0 = b.asm.zt).apply(null, arguments)
          }
          , Tv = b._emscripten_bind_ClosestRayResultCallback_set_m_collisionFilterMask_1 = function() {
            return (Tv = b._emscripten_bind_ClosestRayResultCallback_set_m_collisionFilterMask_1 = b.asm.At).apply(null, arguments)
          }
          , Uv = b._emscripten_bind_ClosestRayResultCallback_get_m_closestHitFraction_0 = function() {
            return (Uv = b._emscripten_bind_ClosestRayResultCallback_get_m_closestHitFraction_0 = b.asm.Bt).apply(null, arguments)
          }
          , Vv = b._emscripten_bind_ClosestRayResultCallback_set_m_closestHitFraction_1 = function() {
            return (Vv = b._emscripten_bind_ClosestRayResultCallback_set_m_closestHitFraction_1 = b.asm.Ct).apply(null, arguments)
          }
          , Wv = b._emscripten_bind_ClosestRayResultCallback_get_m_collisionObject_0 = function() {
            return (Wv = b._emscripten_bind_ClosestRayResultCallback_get_m_collisionObject_0 = b.asm.Dt).apply(null, arguments)
          }
          , Xv = b._emscripten_bind_ClosestRayResultCallback_set_m_collisionObject_1 = function() {
            return (Xv = b._emscripten_bind_ClosestRayResultCallback_set_m_collisionObject_1 = b.asm.Et).apply(null, arguments)
          }
          , Yv = b._emscripten_bind_ClosestRayResultCallback___destroy___0 = function() {
            return (Yv = b._emscripten_bind_ClosestRayResultCallback___destroy___0 = b.asm.Ft).apply(null, arguments)
          }
          , Zv = b._emscripten_bind_btSoftBodyRigidBodyCollisionConfiguration_btSoftBodyRigidBodyCollisionConfiguration_0 = function() {
            return (Zv = b._emscripten_bind_btSoftBodyRigidBodyCollisionConfiguration_btSoftBodyRigidBodyCollisionConfiguration_0 = b.asm.Gt).apply(null, arguments)
          }
          , $v = b._emscripten_bind_btSoftBodyRigidBodyCollisionConfiguration_btSoftBodyRigidBodyCollisionConfiguration_1 = function() {
            return ($v = b._emscripten_bind_btSoftBodyRigidBodyCollisionConfiguration_btSoftBodyRigidBodyCollisionConfiguration_1 = b.asm.Ht).apply(null, arguments)
          }
          , aw = b._emscripten_bind_btSoftBodyRigidBodyCollisionConfiguration___destroy___0 = function() {
            return (aw = b._emscripten_bind_btSoftBodyRigidBodyCollisionConfiguration___destroy___0 = b.asm.It).apply(null, arguments)
          }
          , bw = b._emscripten_bind_ConcreteContactResultCallback_ConcreteContactResultCallback_0 = function() {
            return (bw = b._emscripten_bind_ConcreteContactResultCallback_ConcreteContactResultCallback_0 = b.asm.Jt).apply(null, arguments)
          }
          , cw = b._emscripten_bind_ConcreteContactResultCallback_addSingleResult_7 = function() {
            return (cw = b._emscripten_bind_ConcreteContactResultCallback_addSingleResult_7 = b.asm.Kt).apply(null, arguments)
          }
          , dw = b._emscripten_bind_ConcreteContactResultCallback___destroy___0 = function() {
            return (dw = b._emscripten_bind_ConcreteContactResultCallback___destroy___0 = b.asm.Lt).apply(null, arguments)
          }
          , ew = b._emscripten_bind_btBvhTriangleMeshShape_btBvhTriangleMeshShape_2 = function() {
            return (ew = b._emscripten_bind_btBvhTriangleMeshShape_btBvhTriangleMeshShape_2 = b.asm.Mt).apply(null, arguments)
          }
          , fw = b._emscripten_bind_btBvhTriangleMeshShape_btBvhTriangleMeshShape_3 = function() {
            return (fw = b._emscripten_bind_btBvhTriangleMeshShape_btBvhTriangleMeshShape_3 = b.asm.Nt).apply(null, arguments)
          }
          , gw = b._emscripten_bind_btBvhTriangleMeshShape_setLocalScaling_1 = function() {
            return (gw = b._emscripten_bind_btBvhTriangleMeshShape_setLocalScaling_1 = b.asm.Ot).apply(null, arguments)
          }
          , hw = b._emscripten_bind_btBvhTriangleMeshShape_getLocalScaling_0 = function() {
            return (hw = b._emscripten_bind_btBvhTriangleMeshShape_getLocalScaling_0 = b.asm.Pt).apply(null, arguments)
          }
          , iw = b._emscripten_bind_btBvhTriangleMeshShape_calculateLocalInertia_2 = function() {
            return (iw = b._emscripten_bind_btBvhTriangleMeshShape_calculateLocalInertia_2 = b.asm.Qt).apply(null, arguments)
          }
          , jw = b._emscripten_bind_btBvhTriangleMeshShape___destroy___0 = function() {
            return (jw = b._emscripten_bind_btBvhTriangleMeshShape___destroy___0 = b.asm.Rt).apply(null, arguments)
          }
          , kw = b._emscripten_bind_btConstCollisionObjectArray_size_0 = function() {
            return (kw = b._emscripten_bind_btConstCollisionObjectArray_size_0 = b.asm.St).apply(null, arguments)
          }
          , lw = b._emscripten_bind_btConstCollisionObjectArray_at_1 = function() {
            return (lw = b._emscripten_bind_btConstCollisionObjectArray_at_1 = b.asm.Tt).apply(null, arguments)
          }
          , mw = b._emscripten_bind_btConstCollisionObjectArray___destroy___0 = function() {
            return (mw = b._emscripten_bind_btConstCollisionObjectArray___destroy___0 = b.asm.Ut).apply(null, arguments)
          }
          , nw = b._emscripten_bind_btSliderConstraint_btSliderConstraint_3 = function() {
            return (nw = b._emscripten_bind_btSliderConstraint_btSliderConstraint_3 = b.asm.Vt).apply(null, arguments)
          }
          , ow = b._emscripten_bind_btSliderConstraint_btSliderConstraint_5 = function() {
            return (ow = b._emscripten_bind_btSliderConstraint_btSliderConstraint_5 = b.asm.Wt).apply(null, arguments)
          }
          , pw = b._emscripten_bind_btSliderConstraint_setLowerLinLimit_1 = function() {
            return (pw = b._emscripten_bind_btSliderConstraint_setLowerLinLimit_1 = b.asm.Xt).apply(null, arguments)
          }
          , qw = b._emscripten_bind_btSliderConstraint_setUpperLinLimit_1 = function() {
            return (qw = b._emscripten_bind_btSliderConstraint_setUpperLinLimit_1 = b.asm.Yt).apply(null, arguments)
          }
          , rw = b._emscripten_bind_btSliderConstraint_setLowerAngLimit_1 = function() {
            return (rw = b._emscripten_bind_btSliderConstraint_setLowerAngLimit_1 = b.asm.Zt).apply(null, arguments)
          }
          , sw = b._emscripten_bind_btSliderConstraint_setUpperAngLimit_1 = function() {
            return (sw = b._emscripten_bind_btSliderConstraint_setUpperAngLimit_1 = b.asm._t).apply(null, arguments)
          }
          , tw = b._emscripten_bind_btSliderConstraint_enableFeedback_1 = function() {
            return (tw = b._emscripten_bind_btSliderConstraint_enableFeedback_1 = b.asm.$t).apply(null, arguments)
          }
          , uw = b._emscripten_bind_btSliderConstraint_getBreakingImpulseThreshold_0 = function() {
            return (uw = b._emscripten_bind_btSliderConstraint_getBreakingImpulseThreshold_0 = b.asm.au).apply(null, arguments)
          }
          , vw = b._emscripten_bind_btSliderConstraint_setBreakingImpulseThreshold_1 = function() {
            return (vw = b._emscripten_bind_btSliderConstraint_setBreakingImpulseThreshold_1 = b.asm.bu).apply(null, arguments)
          }
          , ww = b._emscripten_bind_btSliderConstraint_getParam_2 = function() {
            return (ww = b._emscripten_bind_btSliderConstraint_getParam_2 = b.asm.cu).apply(null, arguments)
          }
          , xw = b._emscripten_bind_btSliderConstraint_setParam_3 = function() {
            return (xw = b._emscripten_bind_btSliderConstraint_setParam_3 = b.asm.du).apply(null, arguments)
          }
          , yw = b._emscripten_bind_btSliderConstraint___destroy___0 = function() {
            return (yw = b._emscripten_bind_btSliderConstraint___destroy___0 = b.asm.eu).apply(null, arguments)
          }
          , zw = b._emscripten_bind_btPairCachingGhostObject_btPairCachingGhostObject_0 = function() {
            return (zw = b._emscripten_bind_btPairCachingGhostObject_btPairCachingGhostObject_0 = b.asm.fu).apply(null, arguments)
          }
          , Aw = b._emscripten_bind_btPairCachingGhostObject_setAnisotropicFriction_2 = function() {
            return (Aw = b._emscripten_bind_btPairCachingGhostObject_setAnisotropicFriction_2 = b.asm.gu).apply(null, arguments)
          }
          , Bw = b._emscripten_bind_btPairCachingGhostObject_getCollisionShape_0 = function() {
            return (Bw = b._emscripten_bind_btPairCachingGhostObject_getCollisionShape_0 = b.asm.hu).apply(null, arguments)
          }
          , Cw = b._emscripten_bind_btPairCachingGhostObject_setContactProcessingThreshold_1 = function() {
            return (Cw = b._emscripten_bind_btPairCachingGhostObject_setContactProcessingThreshold_1 = b.asm.iu).apply(null, arguments)
          }
          , Dw = b._emscripten_bind_btPairCachingGhostObject_setActivationState_1 = function() {
            return (Dw = b._emscripten_bind_btPairCachingGhostObject_setActivationState_1 = b.asm.ju).apply(null, arguments)
          }
          , Ew = b._emscripten_bind_btPairCachingGhostObject_forceActivationState_1 = function() {
            return (Ew = b._emscripten_bind_btPairCachingGhostObject_forceActivationState_1 = b.asm.ku).apply(null, arguments)
          }
          , Fw = b._emscripten_bind_btPairCachingGhostObject_activate_0 = function() {
            return (Fw = b._emscripten_bind_btPairCachingGhostObject_activate_0 = b.asm.lu).apply(null, arguments)
          }
          , Gw = b._emscripten_bind_btPairCachingGhostObject_activate_1 = function() {
            return (Gw = b._emscripten_bind_btPairCachingGhostObject_activate_1 = b.asm.mu).apply(null, arguments)
          }
          , Hw = b._emscripten_bind_btPairCachingGhostObject_isActive_0 = function() {
            return (Hw = b._emscripten_bind_btPairCachingGhostObject_isActive_0 = b.asm.nu).apply(null, arguments)
          }
          , Iw = b._emscripten_bind_btPairCachingGhostObject_isKinematicObject_0 = function() {
            return (Iw = b._emscripten_bind_btPairCachingGhostObject_isKinematicObject_0 = b.asm.ou).apply(null, arguments)
          }
          , Jw = b._emscripten_bind_btPairCachingGhostObject_isStaticObject_0 = function() {
            return (Jw = b._emscripten_bind_btPairCachingGhostObject_isStaticObject_0 = b.asm.pu).apply(null, arguments)
          }
          , Kw = b._emscripten_bind_btPairCachingGhostObject_isStaticOrKinematicObject_0 = function() {
            return (Kw = b._emscripten_bind_btPairCachingGhostObject_isStaticOrKinematicObject_0 = b.asm.qu).apply(null, arguments)
          }
          , Lw = b._emscripten_bind_btPairCachingGhostObject_getRestitution_0 = function() {
            return (Lw = b._emscripten_bind_btPairCachingGhostObject_getRestitution_0 = b.asm.ru).apply(null, arguments)
          }
          , Mw = b._emscripten_bind_btPairCachingGhostObject_getFriction_0 = function() {
            return (Mw = b._emscripten_bind_btPairCachingGhostObject_getFriction_0 = b.asm.su).apply(null, arguments)
          }
          , Nw = b._emscripten_bind_btPairCachingGhostObject_getRollingFriction_0 = function() {
            return (Nw = b._emscripten_bind_btPairCachingGhostObject_getRollingFriction_0 = b.asm.tu).apply(null, arguments)
          }
          , Ow = b._emscripten_bind_btPairCachingGhostObject_setRestitution_1 = function() {
            return (Ow = b._emscripten_bind_btPairCachingGhostObject_setRestitution_1 = b.asm.uu).apply(null, arguments)
          }
          , Pw = b._emscripten_bind_btPairCachingGhostObject_setFriction_1 = function() {
            return (Pw = b._emscripten_bind_btPairCachingGhostObject_setFriction_1 = b.asm.vu).apply(null, arguments)
          }
          , Qw = b._emscripten_bind_btPairCachingGhostObject_setRollingFriction_1 = function() {
            return (Qw = b._emscripten_bind_btPairCachingGhostObject_setRollingFriction_1 = b.asm.wu).apply(null, arguments)
          }
          , Rw = b._emscripten_bind_btPairCachingGhostObject_getWorldTransform_0 = function() {
            return (Rw = b._emscripten_bind_btPairCachingGhostObject_getWorldTransform_0 = b.asm.xu).apply(null, arguments)
          }
          , Sw = b._emscripten_bind_btPairCachingGhostObject_getCollisionFlags_0 = function() {
            return (Sw = b._emscripten_bind_btPairCachingGhostObject_getCollisionFlags_0 = b.asm.yu).apply(null, arguments)
          }
          , Tw = b._emscripten_bind_btPairCachingGhostObject_setCollisionFlags_1 = function() {
            return (Tw = b._emscripten_bind_btPairCachingGhostObject_setCollisionFlags_1 = b.asm.zu).apply(null, arguments)
          }
          , Uw = b._emscripten_bind_btPairCachingGhostObject_setWorldTransform_1 = function() {
            return (Uw = b._emscripten_bind_btPairCachingGhostObject_setWorldTransform_1 = b.asm.Au).apply(null, arguments)
          }
          , Vw = b._emscripten_bind_btPairCachingGhostObject_setCollisionShape_1 = function() {
            return (Vw = b._emscripten_bind_btPairCachingGhostObject_setCollisionShape_1 = b.asm.Bu).apply(null, arguments)
          }
          , Ww = b._emscripten_bind_btPairCachingGhostObject_setCcdMotionThreshold_1 = function() {
            return (Ww = b._emscripten_bind_btPairCachingGhostObject_setCcdMotionThreshold_1 = b.asm.Cu).apply(null, arguments)
          }
          , Xw = b._emscripten_bind_btPairCachingGhostObject_setCcdSweptSphereRadius_1 = function() {
            return (Xw = b._emscripten_bind_btPairCachingGhostObject_setCcdSweptSphereRadius_1 = b.asm.Du).apply(null, arguments)
          }
          , Yw = b._emscripten_bind_btPairCachingGhostObject_getUserIndex_0 = function() {
            return (Yw = b._emscripten_bind_btPairCachingGhostObject_getUserIndex_0 = b.asm.Eu).apply(null, arguments)
          }
          , Zw = b._emscripten_bind_btPairCachingGhostObject_setUserIndex_1 = function() {
            return (Zw = b._emscripten_bind_btPairCachingGhostObject_setUserIndex_1 = b.asm.Fu).apply(null, arguments)
          }
          , $w = b._emscripten_bind_btPairCachingGhostObject_getUserPointer_0 = function() {
            return ($w = b._emscripten_bind_btPairCachingGhostObject_getUserPointer_0 = b.asm.Gu).apply(null, arguments)
          }
          , ax = b._emscripten_bind_btPairCachingGhostObject_setUserPointer_1 = function() {
            return (ax = b._emscripten_bind_btPairCachingGhostObject_setUserPointer_1 = b.asm.Hu).apply(null, arguments)
          }
          , bx = b._emscripten_bind_btPairCachingGhostObject_getBroadphaseHandle_0 = function() {
            return (bx = b._emscripten_bind_btPairCachingGhostObject_getBroadphaseHandle_0 = b.asm.Iu).apply(null, arguments)
          }
          , cx = b._emscripten_bind_btPairCachingGhostObject_getNumOverlappingObjects_0 = function() {
            return (cx = b._emscripten_bind_btPairCachingGhostObject_getNumOverlappingObjects_0 = b.asm.Ju).apply(null, arguments)
          }
          , dx = b._emscripten_bind_btPairCachingGhostObject_getOverlappingObject_1 = function() {
            return (dx = b._emscripten_bind_btPairCachingGhostObject_getOverlappingObject_1 = b.asm.Ku).apply(null, arguments)
          }
          , ex = b._emscripten_bind_btPairCachingGhostObject___destroy___0 = function() {
            return (ex = b._emscripten_bind_btPairCachingGhostObject___destroy___0 = b.asm.Lu).apply(null, arguments)
          }
          , fx = b._emscripten_bind_btManifoldPoint_getPositionWorldOnA_0 = function() {
            return (fx = b._emscripten_bind_btManifoldPoint_getPositionWorldOnA_0 = b.asm.Mu).apply(null, arguments)
          }
          , gx = b._emscripten_bind_btManifoldPoint_getPositionWorldOnB_0 = function() {
            return (gx = b._emscripten_bind_btManifoldPoint_getPositionWorldOnB_0 = b.asm.Nu).apply(null, arguments)
          }
          , hx = b._emscripten_bind_btManifoldPoint_getAppliedImpulse_0 = function() {
            return (hx = b._emscripten_bind_btManifoldPoint_getAppliedImpulse_0 = b.asm.Ou).apply(null, arguments)
          }
          , ix = b._emscripten_bind_btManifoldPoint_getDistance_0 = function() {
            return (ix = b._emscripten_bind_btManifoldPoint_getDistance_0 = b.asm.Pu).apply(null, arguments)
          }
          , jx = b._emscripten_bind_btManifoldPoint_get_m_localPointA_0 = function() {
            return (jx = b._emscripten_bind_btManifoldPoint_get_m_localPointA_0 = b.asm.Qu).apply(null, arguments)
          }
          , kx = b._emscripten_bind_btManifoldPoint_set_m_localPointA_1 = function() {
            return (kx = b._emscripten_bind_btManifoldPoint_set_m_localPointA_1 = b.asm.Ru).apply(null, arguments)
          }
          , lx = b._emscripten_bind_btManifoldPoint_get_m_localPointB_0 = function() {
            return (lx = b._emscripten_bind_btManifoldPoint_get_m_localPointB_0 = b.asm.Su).apply(null, arguments)
          }
          , mx = b._emscripten_bind_btManifoldPoint_set_m_localPointB_1 = function() {
            return (mx = b._emscripten_bind_btManifoldPoint_set_m_localPointB_1 = b.asm.Tu).apply(null, arguments)
          }
          , nx = b._emscripten_bind_btManifoldPoint_get_m_positionWorldOnB_0 = function() {
            return (nx = b._emscripten_bind_btManifoldPoint_get_m_positionWorldOnB_0 = b.asm.Uu).apply(null, arguments)
          }
          , ox = b._emscripten_bind_btManifoldPoint_set_m_positionWorldOnB_1 = function() {
            return (ox = b._emscripten_bind_btManifoldPoint_set_m_positionWorldOnB_1 = b.asm.Vu).apply(null, arguments)
          }
          , px = b._emscripten_bind_btManifoldPoint_get_m_positionWorldOnA_0 = function() {
            return (px = b._emscripten_bind_btManifoldPoint_get_m_positionWorldOnA_0 = b.asm.Wu).apply(null, arguments)
          }
          , qx = b._emscripten_bind_btManifoldPoint_set_m_positionWorldOnA_1 = function() {
            return (qx = b._emscripten_bind_btManifoldPoint_set_m_positionWorldOnA_1 = b.asm.Xu).apply(null, arguments)
          }
          , rx = b._emscripten_bind_btManifoldPoint_get_m_normalWorldOnB_0 = function() {
            return (rx = b._emscripten_bind_btManifoldPoint_get_m_normalWorldOnB_0 = b.asm.Yu).apply(null, arguments)
          }
          , sx = b._emscripten_bind_btManifoldPoint_set_m_normalWorldOnB_1 = function() {
            return (sx = b._emscripten_bind_btManifoldPoint_set_m_normalWorldOnB_1 = b.asm.Zu).apply(null, arguments)
          }
          , tx = b._emscripten_bind_btManifoldPoint_get_m_userPersistentData_0 = function() {
            return (tx = b._emscripten_bind_btManifoldPoint_get_m_userPersistentData_0 = b.asm._u).apply(null, arguments)
          }
          , ux = b._emscripten_bind_btManifoldPoint_set_m_userPersistentData_1 = function() {
            return (ux = b._emscripten_bind_btManifoldPoint_set_m_userPersistentData_1 = b.asm.$u).apply(null, arguments)
          }
          , vx = b._emscripten_bind_btManifoldPoint___destroy___0 = function() {
            return (vx = b._emscripten_bind_btManifoldPoint___destroy___0 = b.asm.av).apply(null, arguments)
          }
          , wx = b._emscripten_bind_btPoint2PointConstraint_btPoint2PointConstraint_2 = function() {
            return (wx = b._emscripten_bind_btPoint2PointConstraint_btPoint2PointConstraint_2 = b.asm.bv).apply(null, arguments)
          }
          , xx = b._emscripten_bind_btPoint2PointConstraint_btPoint2PointConstraint_4 = function() {
            return (xx = b._emscripten_bind_btPoint2PointConstraint_btPoint2PointConstraint_4 = b.asm.cv).apply(null, arguments)
          }
          , yx = b._emscripten_bind_btPoint2PointConstraint_setPivotA_1 = function() {
            return (yx = b._emscripten_bind_btPoint2PointConstraint_setPivotA_1 = b.asm.dv).apply(null, arguments)
          }
          , zx = b._emscripten_bind_btPoint2PointConstraint_setPivotB_1 = function() {
            return (zx = b._emscripten_bind_btPoint2PointConstraint_setPivotB_1 = b.asm.ev).apply(null, arguments)
          }
          , Ax = b._emscripten_bind_btPoint2PointConstraint_getPivotInA_0 = function() {
            return (Ax = b._emscripten_bind_btPoint2PointConstraint_getPivotInA_0 = b.asm.fv).apply(null, arguments)
          }
          , Bx = b._emscripten_bind_btPoint2PointConstraint_getPivotInB_0 = function() {
            return (Bx = b._emscripten_bind_btPoint2PointConstraint_getPivotInB_0 = b.asm.gv).apply(null, arguments)
          }
          , Cx = b._emscripten_bind_btPoint2PointConstraint_enableFeedback_1 = function() {
            return (Cx = b._emscripten_bind_btPoint2PointConstraint_enableFeedback_1 = b.asm.hv).apply(null, arguments)
          }
          , Dx = b._emscripten_bind_btPoint2PointConstraint_getBreakingImpulseThreshold_0 = function() {
            return (Dx = b._emscripten_bind_btPoint2PointConstraint_getBreakingImpulseThreshold_0 = b.asm.iv).apply(null, arguments)
          }
          , Ex = b._emscripten_bind_btPoint2PointConstraint_setBreakingImpulseThreshold_1 = function() {
            return (Ex = b._emscripten_bind_btPoint2PointConstraint_setBreakingImpulseThreshold_1 = b.asm.jv).apply(null, arguments)
          }
          , Fx = b._emscripten_bind_btPoint2PointConstraint_getParam_2 = function() {
            return (Fx = b._emscripten_bind_btPoint2PointConstraint_getParam_2 = b.asm.kv).apply(null, arguments)
          }
          , Gx = b._emscripten_bind_btPoint2PointConstraint_setParam_3 = function() {
            return (Gx = b._emscripten_bind_btPoint2PointConstraint_setParam_3 = b.asm.lv).apply(null, arguments)
          }
          , Hx = b._emscripten_bind_btPoint2PointConstraint_get_m_setting_0 = function() {
            return (Hx = b._emscripten_bind_btPoint2PointConstraint_get_m_setting_0 = b.asm.mv).apply(null, arguments)
          }
          , Ix = b._emscripten_bind_btPoint2PointConstraint_set_m_setting_1 = function() {
            return (Ix = b._emscripten_bind_btPoint2PointConstraint_set_m_setting_1 = b.asm.nv).apply(null, arguments)
          }
          , Jx = b._emscripten_bind_btPoint2PointConstraint___destroy___0 = function() {
            return (Jx = b._emscripten_bind_btPoint2PointConstraint___destroy___0 = b.asm.ov).apply(null, arguments)
          }
          , Kx = b._emscripten_bind_btSoftBodyHelpers_btSoftBodyHelpers_0 = function() {
            return (Kx = b._emscripten_bind_btSoftBodyHelpers_btSoftBodyHelpers_0 = b.asm.pv).apply(null, arguments)
          }
          , Lx = b._emscripten_bind_btSoftBodyHelpers_CreateRope_5 = function() {
            return (Lx = b._emscripten_bind_btSoftBodyHelpers_CreateRope_5 = b.asm.qv).apply(null, arguments)
          }
          , Mx = b._emscripten_bind_btSoftBodyHelpers_CreatePatch_9 = function() {
            return (Mx = b._emscripten_bind_btSoftBodyHelpers_CreatePatch_9 = b.asm.rv).apply(null, arguments)
          }
          , Nx = b._emscripten_bind_btSoftBodyHelpers_CreatePatchUV_10 = function() {
            return (Nx = b._emscripten_bind_btSoftBodyHelpers_CreatePatchUV_10 = b.asm.sv).apply(null, arguments)
          }
          , Ox = b._emscripten_bind_btSoftBodyHelpers_CreateEllipsoid_4 = function() {
            return (Ox = b._emscripten_bind_btSoftBodyHelpers_CreateEllipsoid_4 = b.asm.tv).apply(null, arguments)
          }
          , Px = b._emscripten_bind_btSoftBodyHelpers_CreateFromTriMesh_5 = function() {
            return (Px = b._emscripten_bind_btSoftBodyHelpers_CreateFromTriMesh_5 = b.asm.uv).apply(null, arguments)
          }
          , Qx = b._emscripten_bind_btSoftBodyHelpers_CreateFromConvexHull_4 = function() {
            return (Qx = b._emscripten_bind_btSoftBodyHelpers_CreateFromConvexHull_4 = b.asm.vv).apply(null, arguments)
          }
          , Rx = b._emscripten_bind_btSoftBodyHelpers___destroy___0 = function() {
            return (Rx = b._emscripten_bind_btSoftBodyHelpers___destroy___0 = b.asm.wv).apply(null, arguments)
          }
          , Sx = b._emscripten_bind_btBroadphaseProxy_get_m_collisionFilterGroup_0 = function() {
            return (Sx = b._emscripten_bind_btBroadphaseProxy_get_m_collisionFilterGroup_0 = b.asm.xv).apply(null, arguments)
          }
          , Tx = b._emscripten_bind_btBroadphaseProxy_set_m_collisionFilterGroup_1 = function() {
            return (Tx = b._emscripten_bind_btBroadphaseProxy_set_m_collisionFilterGroup_1 = b.asm.yv).apply(null, arguments)
          }
          , Ux = b._emscripten_bind_btBroadphaseProxy_get_m_collisionFilterMask_0 = function() {
            return (Ux = b._emscripten_bind_btBroadphaseProxy_get_m_collisionFilterMask_0 = b.asm.zv).apply(null, arguments)
          }
          , Vx = b._emscripten_bind_btBroadphaseProxy_set_m_collisionFilterMask_1 = function() {
            return (Vx = b._emscripten_bind_btBroadphaseProxy_set_m_collisionFilterMask_1 = b.asm.Av).apply(null, arguments)
          }
          , Wx = b._emscripten_bind_btBroadphaseProxy___destroy___0 = function() {
            return (Wx = b._emscripten_bind_btBroadphaseProxy___destroy___0 = b.asm.Bv).apply(null, arguments)
          }
          , Xx = b._emscripten_bind_tNodeArray_size_0 = function() {
            return (Xx = b._emscripten_bind_tNodeArray_size_0 = b.asm.Cv).apply(null, arguments)
          }
          , Yx = b._emscripten_bind_tNodeArray_at_1 = function() {
            return (Yx = b._emscripten_bind_tNodeArray_at_1 = b.asm.Dv).apply(null, arguments)
          }
          , Zx = b._emscripten_bind_tNodeArray___destroy___0 = function() {
            return (Zx = b._emscripten_bind_tNodeArray___destroy___0 = b.asm.Ev).apply(null, arguments)
          }
          , $x = b._emscripten_bind_btBoxShape_btBoxShape_1 = function() {
            return ($x = b._emscripten_bind_btBoxShape_btBoxShape_1 = b.asm.Fv).apply(null, arguments)
          }
          , ay = b._emscripten_bind_btBoxShape_setMargin_1 = function() {
            return (ay = b._emscripten_bind_btBoxShape_setMargin_1 = b.asm.Gv).apply(null, arguments)
          }
          , by = b._emscripten_bind_btBoxShape_getMargin_0 = function() {
            return (by = b._emscripten_bind_btBoxShape_getMargin_0 = b.asm.Hv).apply(null, arguments)
          }
          , cy = b._emscripten_bind_btBoxShape_setLocalScaling_1 = function() {
            return (cy = b._emscripten_bind_btBoxShape_setLocalScaling_1 = b.asm.Iv).apply(null, arguments)
          }
          , dy = b._emscripten_bind_btBoxShape_getLocalScaling_0 = function() {
            return (dy = b._emscripten_bind_btBoxShape_getLocalScaling_0 = b.asm.Jv).apply(null, arguments)
          }
          , ey = b._emscripten_bind_btBoxShape_calculateLocalInertia_2 = function() {
            return (ey = b._emscripten_bind_btBoxShape_calculateLocalInertia_2 = b.asm.Kv).apply(null, arguments)
          }
          , fy = b._emscripten_bind_btBoxShape___destroy___0 = function() {
            return (fy = b._emscripten_bind_btBoxShape___destroy___0 = b.asm.Lv).apply(null, arguments)
          }
          , gy = b._emscripten_bind_btFace_get_m_indices_0 = function() {
            return (gy = b._emscripten_bind_btFace_get_m_indices_0 = b.asm.Mv).apply(null, arguments)
          }
          , hy = b._emscripten_bind_btFace_set_m_indices_1 = function() {
            return (hy = b._emscripten_bind_btFace_set_m_indices_1 = b.asm.Nv).apply(null, arguments)
          }
          , iy = b._emscripten_bind_btFace_get_m_plane_1 = function() {
            return (iy = b._emscripten_bind_btFace_get_m_plane_1 = b.asm.Ov).apply(null, arguments)
          }
          , jy = b._emscripten_bind_btFace_set_m_plane_2 = function() {
            return (jy = b._emscripten_bind_btFace_set_m_plane_2 = b.asm.Pv).apply(null, arguments)
          }
          , ky = b._emscripten_bind_btFace___destroy___0 = function() {
            return (ky = b._emscripten_bind_btFace___destroy___0 = b.asm.Qv).apply(null, arguments)
          }
          , ly = b._emscripten_bind_DebugDrawer_DebugDrawer_0 = function() {
            return (ly = b._emscripten_bind_DebugDrawer_DebugDrawer_0 = b.asm.Rv).apply(null, arguments)
          }
          , my = b._emscripten_bind_DebugDrawer_drawLine_3 = function() {
            return (my = b._emscripten_bind_DebugDrawer_drawLine_3 = b.asm.Sv).apply(null, arguments)
          }
          , ny = b._emscripten_bind_DebugDrawer_drawContactPoint_5 = function() {
            return (ny = b._emscripten_bind_DebugDrawer_drawContactPoint_5 = b.asm.Tv).apply(null, arguments)
          }
          , oy = b._emscripten_bind_DebugDrawer_reportErrorWarning_1 = function() {
            return (oy = b._emscripten_bind_DebugDrawer_reportErrorWarning_1 = b.asm.Uv).apply(null, arguments)
          }
          , py = b._emscripten_bind_DebugDrawer_draw3dText_2 = function() {
            return (py = b._emscripten_bind_DebugDrawer_draw3dText_2 = b.asm.Vv).apply(null, arguments)
          }
          , qy = b._emscripten_bind_DebugDrawer_setDebugMode_1 = function() {
            return (qy = b._emscripten_bind_DebugDrawer_setDebugMode_1 = b.asm.Wv).apply(null, arguments)
          }
          , ry = b._emscripten_bind_DebugDrawer_getDebugMode_0 = function() {
            return (ry = b._emscripten_bind_DebugDrawer_getDebugMode_0 = b.asm.Xv).apply(null, arguments)
          }
          , sy = b._emscripten_bind_DebugDrawer___destroy___0 = function() {
            return (sy = b._emscripten_bind_DebugDrawer___destroy___0 = b.asm.Yv).apply(null, arguments)
          }
          , ty = b._emscripten_bind_btCapsuleShapeX_btCapsuleShapeX_2 = function() {
            return (ty = b._emscripten_bind_btCapsuleShapeX_btCapsuleShapeX_2 = b.asm.Zv).apply(null, arguments)
          }
          , uy = b._emscripten_bind_btCapsuleShapeX_setMargin_1 = function() {
            return (uy = b._emscripten_bind_btCapsuleShapeX_setMargin_1 = b.asm._v).apply(null, arguments)
          }
          , vy = b._emscripten_bind_btCapsuleShapeX_getMargin_0 = function() {
            return (vy = b._emscripten_bind_btCapsuleShapeX_getMargin_0 = b.asm.$v).apply(null, arguments)
          }
          , wy = b._emscripten_bind_btCapsuleShapeX_getUpAxis_0 = function() {
            return (wy = b._emscripten_bind_btCapsuleShapeX_getUpAxis_0 = b.asm.aw).apply(null, arguments)
          }
          , xy = b._emscripten_bind_btCapsuleShapeX_getRadius_0 = function() {
            return (xy = b._emscripten_bind_btCapsuleShapeX_getRadius_0 = b.asm.bw).apply(null, arguments)
          }
          , yy = b._emscripten_bind_btCapsuleShapeX_getHalfHeight_0 = function() {
            return (yy = b._emscripten_bind_btCapsuleShapeX_getHalfHeight_0 = b.asm.cw).apply(null, arguments)
          }
          , zy = b._emscripten_bind_btCapsuleShapeX_setLocalScaling_1 = function() {
            return (zy = b._emscripten_bind_btCapsuleShapeX_setLocalScaling_1 = b.asm.dw).apply(null, arguments)
          }
          , Ay = b._emscripten_bind_btCapsuleShapeX_getLocalScaling_0 = function() {
            return (Ay = b._emscripten_bind_btCapsuleShapeX_getLocalScaling_0 = b.asm.ew).apply(null, arguments)
          }
          , By = b._emscripten_bind_btCapsuleShapeX_calculateLocalInertia_2 = function() {
            return (By = b._emscripten_bind_btCapsuleShapeX_calculateLocalInertia_2 = b.asm.fw).apply(null, arguments)
          }
          , Cy = b._emscripten_bind_btCapsuleShapeX___destroy___0 = function() {
            return (Cy = b._emscripten_bind_btCapsuleShapeX___destroy___0 = b.asm.gw).apply(null, arguments)
          }
          , Dy = b._emscripten_bind_btQuaternion_btQuaternion_4 = function() {
            return (Dy = b._emscripten_bind_btQuaternion_btQuaternion_4 = b.asm.hw).apply(null, arguments)
          }
          , Ey = b._emscripten_bind_btQuaternion_setValue_4 = function() {
            return (Ey = b._emscripten_bind_btQuaternion_setValue_4 = b.asm.iw).apply(null, arguments)
          }
          , Fy = b._emscripten_bind_btQuaternion_setEulerZYX_3 = function() {
            return (Fy = b._emscripten_bind_btQuaternion_setEulerZYX_3 = b.asm.jw).apply(null, arguments)
          }
          , Gy = b._emscripten_bind_btQuaternion_setRotation_2 = function() {
            return (Gy = b._emscripten_bind_btQuaternion_setRotation_2 = b.asm.kw).apply(null, arguments)
          }
          , Hy = b._emscripten_bind_btQuaternion_normalize_0 = function() {
            return (Hy = b._emscripten_bind_btQuaternion_normalize_0 = b.asm.lw).apply(null, arguments)
          }
          , Iy = b._emscripten_bind_btQuaternion_length2_0 = function() {
            return (Iy = b._emscripten_bind_btQuaternion_length2_0 = b.asm.mw).apply(null, arguments)
          }
          , Jy = b._emscripten_bind_btQuaternion_length_0 = function() {
            return (Jy = b._emscripten_bind_btQuaternion_length_0 = b.asm.nw).apply(null, arguments)
          }
          , Ky = b._emscripten_bind_btQuaternion_dot_1 = function() {
            return (Ky = b._emscripten_bind_btQuaternion_dot_1 = b.asm.ow).apply(null, arguments)
          }
          , Ly = b._emscripten_bind_btQuaternion_normalized_0 = function() {
            return (Ly = b._emscripten_bind_btQuaternion_normalized_0 = b.asm.pw).apply(null, arguments)
          }
          , My = b._emscripten_bind_btQuaternion_getAxis_0 = function() {
            return (My = b._emscripten_bind_btQuaternion_getAxis_0 = b.asm.qw).apply(null, arguments)
          }
          , Ny = b._emscripten_bind_btQuaternion_inverse_0 = function() {
            return (Ny = b._emscripten_bind_btQuaternion_inverse_0 = b.asm.rw).apply(null, arguments)
          }
          , Oy = b._emscripten_bind_btQuaternion_getAngle_0 = function() {
            return (Oy = b._emscripten_bind_btQuaternion_getAngle_0 = b.asm.sw).apply(null, arguments)
          }
          , Py = b._emscripten_bind_btQuaternion_getAngleShortestPath_0 = function() {
            return (Py = b._emscripten_bind_btQuaternion_getAngleShortestPath_0 = b.asm.tw).apply(null, arguments)
          }
          , Qy = b._emscripten_bind_btQuaternion_angle_1 = function() {
            return (Qy = b._emscripten_bind_btQuaternion_angle_1 = b.asm.uw).apply(null, arguments)
          }
          , Ry = b._emscripten_bind_btQuaternion_angleShortestPath_1 = function() {
            return (Ry = b._emscripten_bind_btQuaternion_angleShortestPath_1 = b.asm.vw).apply(null, arguments)
          }
          , Sy = b._emscripten_bind_btQuaternion_op_add_1 = function() {
            return (Sy = b._emscripten_bind_btQuaternion_op_add_1 = b.asm.ww).apply(null, arguments)
          }
          , Ty = b._emscripten_bind_btQuaternion_op_sub_1 = function() {
            return (Ty = b._emscripten_bind_btQuaternion_op_sub_1 = b.asm.xw).apply(null, arguments)
          }
          , Uy = b._emscripten_bind_btQuaternion_op_mul_1 = function() {
            return (Uy = b._emscripten_bind_btQuaternion_op_mul_1 = b.asm.yw).apply(null, arguments)
          }
          , Vy = b._emscripten_bind_btQuaternion_op_mulq_1 = function() {
            return (Vy = b._emscripten_bind_btQuaternion_op_mulq_1 = b.asm.zw).apply(null, arguments)
          }
          , Wy = b._emscripten_bind_btQuaternion_op_div_1 = function() {
            return (Wy = b._emscripten_bind_btQuaternion_op_div_1 = b.asm.Aw).apply(null, arguments)
          }
          , Xy = b._emscripten_bind_btQuaternion_x_0 = function() {
            return (Xy = b._emscripten_bind_btQuaternion_x_0 = b.asm.Bw).apply(null, arguments)
          }
          , Yy = b._emscripten_bind_btQuaternion_y_0 = function() {
            return (Yy = b._emscripten_bind_btQuaternion_y_0 = b.asm.Cw).apply(null, arguments)
          }
          , Zy = b._emscripten_bind_btQuaternion_z_0 = function() {
            return (Zy = b._emscripten_bind_btQuaternion_z_0 = b.asm.Dw).apply(null, arguments)
          }
          , $y = b._emscripten_bind_btQuaternion_w_0 = function() {
            return ($y = b._emscripten_bind_btQuaternion_w_0 = b.asm.Ew).apply(null, arguments)
          }
          , az = b._emscripten_bind_btQuaternion_setX_1 = function() {
            return (az = b._emscripten_bind_btQuaternion_setX_1 = b.asm.Fw).apply(null, arguments)
          }
          , bz = b._emscripten_bind_btQuaternion_setY_1 = function() {
            return (bz = b._emscripten_bind_btQuaternion_setY_1 = b.asm.Gw).apply(null, arguments)
          }
          , cz = b._emscripten_bind_btQuaternion_setZ_1 = function() {
            return (cz = b._emscripten_bind_btQuaternion_setZ_1 = b.asm.Hw).apply(null, arguments)
          }
          , dz = b._emscripten_bind_btQuaternion_setW_1 = function() {
            return (dz = b._emscripten_bind_btQuaternion_setW_1 = b.asm.Iw).apply(null, arguments)
          }
          , ez = b._emscripten_bind_btQuaternion___destroy___0 = function() {
            return (ez = b._emscripten_bind_btQuaternion___destroy___0 = b.asm.Jw).apply(null, arguments)
          }
          , fz = b._emscripten_bind_btCapsuleShapeZ_btCapsuleShapeZ_2 = function() {
            return (fz = b._emscripten_bind_btCapsuleShapeZ_btCapsuleShapeZ_2 = b.asm.Kw).apply(null, arguments)
          }
          , gz = b._emscripten_bind_btCapsuleShapeZ_setMargin_1 = function() {
            return (gz = b._emscripten_bind_btCapsuleShapeZ_setMargin_1 = b.asm.Lw).apply(null, arguments)
          }
          , hz = b._emscripten_bind_btCapsuleShapeZ_getMargin_0 = function() {
            return (hz = b._emscripten_bind_btCapsuleShapeZ_getMargin_0 = b.asm.Mw).apply(null, arguments)
          }
          , iz = b._emscripten_bind_btCapsuleShapeZ_getUpAxis_0 = function() {
            return (iz = b._emscripten_bind_btCapsuleShapeZ_getUpAxis_0 = b.asm.Nw).apply(null, arguments)
          }
          , jz = b._emscripten_bind_btCapsuleShapeZ_getRadius_0 = function() {
            return (jz = b._emscripten_bind_btCapsuleShapeZ_getRadius_0 = b.asm.Ow).apply(null, arguments)
          }
          , kz = b._emscripten_bind_btCapsuleShapeZ_getHalfHeight_0 = function() {
            return (kz = b._emscripten_bind_btCapsuleShapeZ_getHalfHeight_0 = b.asm.Pw).apply(null, arguments)
          }
          , lz = b._emscripten_bind_btCapsuleShapeZ_setLocalScaling_1 = function() {
            return (lz = b._emscripten_bind_btCapsuleShapeZ_setLocalScaling_1 = b.asm.Qw).apply(null, arguments)
          }
          , mz = b._emscripten_bind_btCapsuleShapeZ_getLocalScaling_0 = function() {
            return (mz = b._emscripten_bind_btCapsuleShapeZ_getLocalScaling_0 = b.asm.Rw).apply(null, arguments)
          }
          , nz = b._emscripten_bind_btCapsuleShapeZ_calculateLocalInertia_2 = function() {
            return (nz = b._emscripten_bind_btCapsuleShapeZ_calculateLocalInertia_2 = b.asm.Sw).apply(null, arguments)
          }
          , oz = b._emscripten_bind_btCapsuleShapeZ___destroy___0 = function() {
            return (oz = b._emscripten_bind_btCapsuleShapeZ___destroy___0 = b.asm.Tw).apply(null, arguments)
          }
          , pz = b._emscripten_bind_btContactSolverInfo_get_m_splitImpulse_0 = function() {
            return (pz = b._emscripten_bind_btContactSolverInfo_get_m_splitImpulse_0 = b.asm.Uw).apply(null, arguments)
          }
          , qz = b._emscripten_bind_btContactSolverInfo_set_m_splitImpulse_1 = function() {
            return (qz = b._emscripten_bind_btContactSolverInfo_set_m_splitImpulse_1 = b.asm.Vw).apply(null, arguments)
          }
          , rz = b._emscripten_bind_btContactSolverInfo_get_m_splitImpulsePenetrationThreshold_0 = function() {
            return (rz = b._emscripten_bind_btContactSolverInfo_get_m_splitImpulsePenetrationThreshold_0 = b.asm.Ww).apply(null, arguments)
          }
          , sz = b._emscripten_bind_btContactSolverInfo_set_m_splitImpulsePenetrationThreshold_1 = function() {
            return (sz = b._emscripten_bind_btContactSolverInfo_set_m_splitImpulsePenetrationThreshold_1 = b.asm.Xw).apply(null, arguments)
          }
          , tz = b._emscripten_bind_btContactSolverInfo_get_m_numIterations_0 = function() {
            return (tz = b._emscripten_bind_btContactSolverInfo_get_m_numIterations_0 = b.asm.Yw).apply(null, arguments)
          }
          , uz = b._emscripten_bind_btContactSolverInfo_set_m_numIterations_1 = function() {
            return (uz = b._emscripten_bind_btContactSolverInfo_set_m_numIterations_1 = b.asm.Zw).apply(null, arguments)
          }
          , vz = b._emscripten_bind_btContactSolverInfo___destroy___0 = function() {
            return (vz = b._emscripten_bind_btContactSolverInfo___destroy___0 = b.asm._w).apply(null, arguments)
          }
          , wz = b._emscripten_bind_btGeneric6DofSpringConstraint_btGeneric6DofSpringConstraint_3 = function() {
            return (wz = b._emscripten_bind_btGeneric6DofSpringConstraint_btGeneric6DofSpringConstraint_3 = b.asm.$w).apply(null, arguments)
          }
          , xz = b._emscripten_bind_btGeneric6DofSpringConstraint_btGeneric6DofSpringConstraint_5 = function() {
            return (xz = b._emscripten_bind_btGeneric6DofSpringConstraint_btGeneric6DofSpringConstraint_5 = b.asm.ax).apply(null, arguments)
          }
          , yz = b._emscripten_bind_btGeneric6DofSpringConstraint_enableSpring_2 = function() {
            return (yz = b._emscripten_bind_btGeneric6DofSpringConstraint_enableSpring_2 = b.asm.bx).apply(null, arguments)
          }
          , zz = b._emscripten_bind_btGeneric6DofSpringConstraint_setStiffness_2 = function() {
            return (zz = b._emscripten_bind_btGeneric6DofSpringConstraint_setStiffness_2 = b.asm.cx).apply(null, arguments)
          }
          , Az = b._emscripten_bind_btGeneric6DofSpringConstraint_setDamping_2 = function() {
            return (Az = b._emscripten_bind_btGeneric6DofSpringConstraint_setDamping_2 = b.asm.dx).apply(null, arguments)
          }
          , Bz = b._emscripten_bind_btGeneric6DofSpringConstraint_setEquilibriumPoint_0 = function() {
            return (Bz = b._emscripten_bind_btGeneric6DofSpringConstraint_setEquilibriumPoint_0 = b.asm.ex).apply(null, arguments)
          }
          , Cz = b._emscripten_bind_btGeneric6DofSpringConstraint_setEquilibriumPoint_1 = function() {
            return (Cz = b._emscripten_bind_btGeneric6DofSpringConstraint_setEquilibriumPoint_1 = b.asm.fx).apply(null, arguments)
          }
          , Dz = b._emscripten_bind_btGeneric6DofSpringConstraint_setEquilibriumPoint_2 = function() {
            return (Dz = b._emscripten_bind_btGeneric6DofSpringConstraint_setEquilibriumPoint_2 = b.asm.gx).apply(null, arguments)
          }
          , Ez = b._emscripten_bind_btGeneric6DofSpringConstraint_setLinearLowerLimit_1 = function() {
            return (Ez = b._emscripten_bind_btGeneric6DofSpringConstraint_setLinearLowerLimit_1 = b.asm.hx).apply(null, arguments)
          }
          , Fz = b._emscripten_bind_btGeneric6DofSpringConstraint_setLinearUpperLimit_1 = function() {
            return (Fz = b._emscripten_bind_btGeneric6DofSpringConstraint_setLinearUpperLimit_1 = b.asm.ix).apply(null, arguments)
          }
          , Gz = b._emscripten_bind_btGeneric6DofSpringConstraint_setAngularLowerLimit_1 = function() {
            return (Gz = b._emscripten_bind_btGeneric6DofSpringConstraint_setAngularLowerLimit_1 = b.asm.jx).apply(null, arguments)
          }
          , Hz = b._emscripten_bind_btGeneric6DofSpringConstraint_setAngularUpperLimit_1 = function() {
            return (Hz = b._emscripten_bind_btGeneric6DofSpringConstraint_setAngularUpperLimit_1 = b.asm.kx).apply(null, arguments)
          }
          , Iz = b._emscripten_bind_btGeneric6DofSpringConstraint_getFrameOffsetA_0 = function() {
            return (Iz = b._emscripten_bind_btGeneric6DofSpringConstraint_getFrameOffsetA_0 = b.asm.lx).apply(null, arguments)
          }
          , Jz = b._emscripten_bind_btGeneric6DofSpringConstraint_enableFeedback_1 = function() {
            return (Jz = b._emscripten_bind_btGeneric6DofSpringConstraint_enableFeedback_1 = b.asm.mx).apply(null, arguments)
          }
          , Kz = b._emscripten_bind_btGeneric6DofSpringConstraint_getBreakingImpulseThreshold_0 = function() {
            return (Kz = b._emscripten_bind_btGeneric6DofSpringConstraint_getBreakingImpulseThreshold_0 = b.asm.nx).apply(null, arguments)
          }
          , Lz = b._emscripten_bind_btGeneric6DofSpringConstraint_setBreakingImpulseThreshold_1 = function() {
            return (Lz = b._emscripten_bind_btGeneric6DofSpringConstraint_setBreakingImpulseThreshold_1 = b.asm.ox).apply(null, arguments)
          }
          , Mz = b._emscripten_bind_btGeneric6DofSpringConstraint_getParam_2 = function() {
            return (Mz = b._emscripten_bind_btGeneric6DofSpringConstraint_getParam_2 = b.asm.px).apply(null, arguments)
          }
          , Nz = b._emscripten_bind_btGeneric6DofSpringConstraint_setParam_3 = function() {
            return (Nz = b._emscripten_bind_btGeneric6DofSpringConstraint_setParam_3 = b.asm.qx).apply(null, arguments)
          }
          , Oz = b._emscripten_bind_btGeneric6DofSpringConstraint___destroy___0 = function() {
            return (Oz = b._emscripten_bind_btGeneric6DofSpringConstraint___destroy___0 = b.asm.rx).apply(null, arguments)
          }
          , Pz = b._emscripten_bind_btSphereShape_btSphereShape_1 = function() {
            return (Pz = b._emscripten_bind_btSphereShape_btSphereShape_1 = b.asm.sx).apply(null, arguments)
          }
          , Qz = b._emscripten_bind_btSphereShape_setMargin_1 = function() {
            return (Qz = b._emscripten_bind_btSphereShape_setMargin_1 = b.asm.tx).apply(null, arguments)
          }
          , Rz = b._emscripten_bind_btSphereShape_getMargin_0 = function() {
            return (Rz = b._emscripten_bind_btSphereShape_getMargin_0 = b.asm.ux).apply(null, arguments)
          }
          , Sz = b._emscripten_bind_btSphereShape_setLocalScaling_1 = function() {
            return (Sz = b._emscripten_bind_btSphereShape_setLocalScaling_1 = b.asm.vx).apply(null, arguments)
          }
          , Tz = b._emscripten_bind_btSphereShape_getLocalScaling_0 = function() {
            return (Tz = b._emscripten_bind_btSphereShape_getLocalScaling_0 = b.asm.wx).apply(null, arguments)
          }
          , Uz = b._emscripten_bind_btSphereShape_calculateLocalInertia_2 = function() {
            return (Uz = b._emscripten_bind_btSphereShape_calculateLocalInertia_2 = b.asm.xx).apply(null, arguments)
          }
          , Vz = b._emscripten_bind_btSphereShape___destroy___0 = function() {
            return (Vz = b._emscripten_bind_btSphereShape___destroy___0 = b.asm.yx).apply(null, arguments)
          }
          , Wz = b._emscripten_bind_LocalConvexResult_LocalConvexResult_5 = function() {
            return (Wz = b._emscripten_bind_LocalConvexResult_LocalConvexResult_5 = b.asm.zx).apply(null, arguments)
          }
          , Xz = b._emscripten_bind_LocalConvexResult_get_m_hitCollisionObject_0 = function() {
            return (Xz = b._emscripten_bind_LocalConvexResult_get_m_hitCollisionObject_0 = b.asm.Ax).apply(null, arguments)
          }
          , Yz = b._emscripten_bind_LocalConvexResult_set_m_hitCollisionObject_1 = function() {
            return (Yz = b._emscripten_bind_LocalConvexResult_set_m_hitCollisionObject_1 = b.asm.Bx).apply(null, arguments)
          }
          , Zz = b._emscripten_bind_LocalConvexResult_get_m_localShapeInfo_0 = function() {
            return (Zz = b._emscripten_bind_LocalConvexResult_get_m_localShapeInfo_0 = b.asm.Cx).apply(null, arguments)
          }
          , $z = b._emscripten_bind_LocalConvexResult_set_m_localShapeInfo_1 = function() {
            return ($z = b._emscripten_bind_LocalConvexResult_set_m_localShapeInfo_1 = b.asm.Dx).apply(null, arguments)
          }
          , aA = b._emscripten_bind_LocalConvexResult_get_m_hitNormalLocal_0 = function() {
            return (aA = b._emscripten_bind_LocalConvexResult_get_m_hitNormalLocal_0 = b.asm.Ex).apply(null, arguments)
          }
          , bA = b._emscripten_bind_LocalConvexResult_set_m_hitNormalLocal_1 = function() {
            return (bA = b._emscripten_bind_LocalConvexResult_set_m_hitNormalLocal_1 = b.asm.Fx).apply(null, arguments)
          }
          , cA = b._emscripten_bind_LocalConvexResult_get_m_hitPointLocal_0 = function() {
            return (cA = b._emscripten_bind_LocalConvexResult_get_m_hitPointLocal_0 = b.asm.Gx).apply(null, arguments)
          }
          , dA = b._emscripten_bind_LocalConvexResult_set_m_hitPointLocal_1 = function() {
            return (dA = b._emscripten_bind_LocalConvexResult_set_m_hitPointLocal_1 = b.asm.Hx).apply(null, arguments)
          }
          , eA = b._emscripten_bind_LocalConvexResult_get_m_hitFraction_0 = function() {
            return (eA = b._emscripten_bind_LocalConvexResult_get_m_hitFraction_0 = b.asm.Ix).apply(null, arguments)
          }
          , fA = b._emscripten_bind_LocalConvexResult_set_m_hitFraction_1 = function() {
            return (fA = b._emscripten_bind_LocalConvexResult_set_m_hitFraction_1 = b.asm.Jx).apply(null, arguments)
          }
          , gA = b._emscripten_bind_LocalConvexResult___destroy___0 = function() {
            return (gA = b._emscripten_bind_LocalConvexResult___destroy___0 = b.asm.Kx).apply(null, arguments)
          }
          , hA = b._emscripten_enum_btConstraintParams_BT_CONSTRAINT_ERP = function() {
            return (hA = b._emscripten_enum_btConstraintParams_BT_CONSTRAINT_ERP = b.asm.Lx).apply(null, arguments)
          }
          , iA = b._emscripten_enum_btConstraintParams_BT_CONSTRAINT_STOP_ERP = function() {
            return (iA = b._emscripten_enum_btConstraintParams_BT_CONSTRAINT_STOP_ERP = b.asm.Mx).apply(null, arguments)
          }
          , jA = b._emscripten_enum_btConstraintParams_BT_CONSTRAINT_CFM = function() {
            return (jA = b._emscripten_enum_btConstraintParams_BT_CONSTRAINT_CFM = b.asm.Nx).apply(null, arguments)
          }
          , kA = b._emscripten_enum_btConstraintParams_BT_CONSTRAINT_STOP_CFM = function() {
            return (kA = b._emscripten_enum_btConstraintParams_BT_CONSTRAINT_STOP_CFM = b.asm.Ox).apply(null, arguments)
          }
          , lA = b._emscripten_enum_PHY_ScalarType_PHY_FLOAT = function() {
            return (lA = b._emscripten_enum_PHY_ScalarType_PHY_FLOAT = b.asm.Px).apply(null, arguments)
          }
          , mA = b._emscripten_enum_PHY_ScalarType_PHY_DOUBLE = function() {
            return (mA = b._emscripten_enum_PHY_ScalarType_PHY_DOUBLE = b.asm.Qx).apply(null, arguments)
          }
          , nA = b._emscripten_enum_PHY_ScalarType_PHY_INTEGER = function() {
            return (nA = b._emscripten_enum_PHY_ScalarType_PHY_INTEGER = b.asm.Rx).apply(null, arguments)
          }
          , oA = b._emscripten_enum_PHY_ScalarType_PHY_SHORT = function() {
            return (oA = b._emscripten_enum_PHY_ScalarType_PHY_SHORT = b.asm.Sx).apply(null, arguments)
          }
          , pA = b._emscripten_enum_PHY_ScalarType_PHY_FIXEDPOINT88 = function() {
            return (pA = b._emscripten_enum_PHY_ScalarType_PHY_FIXEDPOINT88 = b.asm.Tx).apply(null, arguments)
          }
          , qA = b._emscripten_enum_PHY_ScalarType_PHY_UCHAR = function() {
            return (qA = b._emscripten_enum_PHY_ScalarType_PHY_UCHAR = b.asm.Ux).apply(null, arguments)
          }
        ;
        b._malloc = function() {
          return (b._malloc = b.asm.Vx).apply(null, arguments)
        }
        ;
        b._free = function() {
          return (b._free = b.asm.Wx).apply(null, arguments)
        }
        ;
        b.dynCall_vi = function() {
          return (b.dynCall_vi = b.asm.Xx).apply(null, arguments)
        }
        ;
        b.dynCall_v = function() {
          return (b.dynCall_v = b.asm.Yx).apply(null, arguments)
        }
        ;
        b.asm = ab;
        b.UTF8ToString = function(a, c) {
          return a ? xa(Aa, a, c) : ""
        }
        ;
        b.addFunction = function(a, c) {
          if (!ra) {
            ra = new WeakMap;
            for (var d = 0; d < ua.length; d++) {
              var e = ua.get(d);
              e && ra.set(e, d)
            }
          }
          if (ra.has(a))
            a = ra.get(a);
          else {
            if (qa.length)
              d = qa.pop();
            else {
              d = ua.length;
              try {
                ua.grow(1)
              } catch (P) {
                if (!(P instanceof RangeError))
                  throw P;
                throw "Unable to grow wasm table. Set ALLOW_TABLE_GROWTH.";
              }
            }
            try {
              ua.set(d, a)
            } catch (P) {
              if (!(P instanceof TypeError))
                throw P;
              assert("undefined" !== typeof c, "Missing signature argument to addFunction");
              if ("function" === typeof WebAssembly.Function) {
                var f = {
                  i: "i32",
                  j: "i64",
                  f: "f32",
                  d: "f64"
                }
                  , m = {
                  parameters: [],
                  results: "v" == c[0] ? [] : [f[c[0]]]
                };
                for (e = 1; e < c.length; ++e)
                  m.parameters.push(f[c[e]]);
                c = new WebAssembly.Function(m,a)
              } else {
                f = [1, 0, 1, 96];
                m = c.slice(0, 1);
                c = c.slice(1);
                var C = {
                  i: 127,
                  j: 126,
                  f: 125,
                  d: 124
                };
                f.push(c.length);
                for (e = 0; e < c.length; ++e)
                  f.push(C[c[e]]);
                "v" == m ? f.push(0) : f = f.concat([1, C[m]]);
                f[1] = f.length - 2;
                c = new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0].concat(f, [2, 7, 1, 1, 101, 1, 102, 0, 0, 7, 5, 1, 1, 102, 0, 0]));
                c = new WebAssembly.Module(c);
                c = (new WebAssembly.Instance(c,{
                  e: {
                    f: a
                  }
                })).exports.f
              }
              ua.set(d, c)
            }
            a = ra[a] = d
          }
          return a
        }
        ;
        var rA;
        b.then = function(a) {
          if (rA)
            a(b);
          else {
            var c = b.onRuntimeInitialized;
            b.onRuntimeInitialized = function() {
              c && c();
              a(b)
            }
          }
          return b
        }
        ;
        Pa = function sA() {
          rA || tA();
          rA || (Pa = sA)
        }
        ;
        function tA() {
          function a() {
            if (!rA && (rA = !0,
              b.calledRun = !0,
              !va)) {
              La = !0;
              Ga(Ia);
              Ga(Ja);
              if (b.onRuntimeInitialized)
                b.onRuntimeInitialized();
              if (b.postRun)
                for ("function" == typeof b.postRun && (b.postRun = [b.postRun]); b.postRun.length; ) {
                  var c = b.postRun.shift();
                  Ka.unshift(c)
                }
              Ga(Ka)
            }
          }
          if (!(0 < Na)) {
            if (b.preRun)
              for ("function" == typeof b.preRun && (b.preRun = [b.preRun]); b.preRun.length; )
                Ma();
            Ga(Ha);
            0 < Na || (b.setStatus ? (b.setStatus("Running..."),
              setTimeout(function() {
                setTimeout(function() {
                  b.setStatus("")
                }, 1);
                a()
              }, 1)) : a())
          }
        }
        b.run = tA;
        if (b.preInit)
          for ("function" == typeof b.preInit && (b.preInit = [b.preInit]); 0 < b.preInit.length; )
            b.preInit.pop()();
        noExitRuntime = !0;
        tA();
        function g() {}
        g.prototype = Object.create(g.prototype);
        g.prototype.constructor = g;
        g.prototype.$x = g;
        g.ay = {};
        b.WrapperObject = g;
        function h(a) {
          return (a || g).ay
        }
        b.getCache = h;
        function k(a, c) {
          var d = h(c)
            , e = d[a];
          if (e)
            return e;
          e = Object.create((c || g).prototype);
          e.Zx = a;
          return d[a] = e
        }
        b.wrapPointer = k;
        b.castObject = function(a, c) {
          return k(a.Zx, c)
        }
        ;
        b.NULL = k(0);
        b.destroy = function(a) {
          if (!a.__destroy__)
            throw "Error: Cannot destroy object. (Did you create it yourself?)";
          a.__destroy__();
          delete h(a.$x)[a.Zx]
        }
        ;
        b.compare = function(a, c) {
          return a.Zx === c.Zx
        }
        ;
        b.getPointer = function(a) {
          return a.Zx
        }
        ;
        b.getClass = function(a) {
          return a.$x
        }
        ;
        var uA = 0
          , vA = 0
          , wA = 0
          , xA = []
          , yA = 0;
        function zA() {
          if (yA) {
            for (var a = 0; a < xA.length; a++)
              b._free(xA[a]);
            xA.length = 0;
            b._free(uA);
            uA = 0;
            vA += yA;
            yA = 0
          }
          uA || (vA += 128,
            uA = b._malloc(vA),
            assert(uA));
          wA = 0
        }
        function AA(a, c) {
          assert(uA);
          a = a.length * c.BYTES_PER_ELEMENT;
          a = a + 7 & -8;
          wA + a >= vA ? (assert(0 < a),
            yA += a,
            c = b._malloc(a),
            xA.push(c)) : (c = uA + wA,
            wA += a);
          return c
        }
        function BA(a, c, d) {
          d >>>= 0;
          switch (c.BYTES_PER_ELEMENT) {
            case 2:
              d >>>= 1;
              break;
            case 4:
              d >>>= 2;
              break;
            case 8:
              d >>>= 3
          }
          for (var e = 0; e < a.length; e++)
            c[d + e] = a[e]
        }
        function CA(a) {
          if ("string" === typeof a) {
            for (var c = 0, d = 0; d < a.length; ++d) {
              var e = a.charCodeAt(d);
              55296 <= e && 57343 >= e && (e = 65536 + ((e & 1023) << 10) | a.charCodeAt(++d) & 1023);
              127 >= e ? ++c : c = 2047 >= e ? c + 2 : 65535 >= e ? c + 3 : c + 4
            }
            c = Array(c + 1);
            e = c.length;
            d = 0;
            if (0 < e) {
              e = d + e - 1;
              for (var f = 0; f < a.length; ++f) {
                var m = a.charCodeAt(f);
                if (55296 <= m && 57343 >= m) {
                  var C = a.charCodeAt(++f);
                  m = 65536 + ((m & 1023) << 10) | C & 1023
                }
                if (127 >= m) {
                  if (d >= e)
                    break;
                  c[d++] = m
                } else {
                  if (2047 >= m) {
                    if (d + 1 >= e)
                      break;
                    c[d++] = 192 | m >> 6
                  } else {
                    if (65535 >= m) {
                      if (d + 2 >= e)
                        break;
                      c[d++] = 224 | m >> 12
                    } else {
                      if (d + 3 >= e)
                        break;
                      c[d++] = 240 | m >> 18;
                      c[d++] = 128 | m >> 12 & 63
                    }
                    c[d++] = 128 | m >> 6 & 63
                  }
                  c[d++] = 128 | m & 63
                }
              }
              c[d] = 0
            }
            a = AA(c, za);
            BA(c, za, a)
          }
          return a
        }
        function DA(a) {
          if ("object" === typeof a) {
            var c = AA(a, Ca);
            BA(a, Ca, c);
            return c
          }
          return a
        }
        function EA() {
          throw "cannot construct a btCollisionWorld, no constructor in IDL";
        }
        EA.prototype = Object.create(g.prototype);
        EA.prototype.constructor = EA;
        EA.prototype.$x = EA;
        EA.ay = {};
        b.btCollisionWorld = EA;
        EA.prototype.getDispatcher = function() {
          return k(bb(this.Zx), FA)
        }
        ;
        EA.prototype.rayTest = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          cb(e, a, c, d)
        }
        ;
        EA.prototype.getPairCache = function() {
          return k(db(this.Zx), GA)
        }
        ;
        EA.prototype.getDispatchInfo = function() {
          return k(eb(this.Zx), l)
        }
        ;
        EA.prototype.addCollisionObject = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          void 0 === c ? fb(e, a) : void 0 === d ? gb(e, a, c) : hb(e, a, c, d)
        }
        ;
        EA.prototype.removeCollisionObject = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ib(c, a)
        }
        ;
        EA.prototype.getBroadphase = function() {
          return k(jb(this.Zx), HA)
        }
        ;
        EA.prototype.convexSweepTest = function(a, c, d, e, f) {
          var m = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          kb(m, a, c, d, e, f)
        }
        ;
        EA.prototype.contactPairTest = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          lb(e, a, c, d)
        }
        ;
        EA.prototype.contactTest = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          mb(d, a, c)
        }
        ;
        EA.prototype.updateSingleAabb = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ob(c, a)
        }
        ;
        EA.prototype.setDebugDrawer = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          pb(c, a)
        }
        ;
        EA.prototype.getDebugDrawer = function() {
          return k(qb(this.Zx), IA)
        }
        ;
        EA.prototype.debugDrawWorld = function() {
          rb(this.Zx)
        }
        ;
        EA.prototype.debugDrawObject = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          sb(e, a, c, d)
        }
        ;
        EA.prototype.__destroy__ = function() {
          tb(this.Zx)
        }
        ;
        function n() {
          throw "cannot construct a btCollisionShape, no constructor in IDL";
        }
        n.prototype = Object.create(g.prototype);
        n.prototype.constructor = n;
        n.prototype.$x = n;
        n.ay = {};
        b.btCollisionShape = n;
        n.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ub(c, a)
        }
        ;
        n.prototype.getLocalScaling = function() {
          return k(vb(this.Zx), p)
        }
        ;
        n.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          wb(d, a, c)
        }
        ;
        n.prototype.setMargin = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          xb(c, a)
        }
        ;
        n.prototype.getMargin = function() {
          return yb(this.Zx)
        }
        ;
        n.prototype.__destroy__ = function() {
          zb(this.Zx)
        }
        ;
        function q() {
          throw "cannot construct a btCollisionObject, no constructor in IDL";
        }
        q.prototype = Object.create(g.prototype);
        q.prototype.constructor = q;
        q.prototype.$x = q;
        q.ay = {};
        b.btCollisionObject = q;
        q.prototype.setAnisotropicFriction = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Ab(d, a, c)
        }
        ;
        q.prototype.getCollisionShape = function() {
          return k(Bb(this.Zx), n)
        }
        ;
        q.prototype.setContactProcessingThreshold = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Cb(c, a)
        }
        ;
        q.prototype.setActivationState = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Db(c, a)
        }
        ;
        q.prototype.forceActivationState = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Eb(c, a)
        }
        ;
        q.prototype.activate = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          void 0 === a ? Fb(c) : Gb(c, a)
        }
        ;
        q.prototype.isActive = function() {
          return !!Hb(this.Zx)
        }
        ;
        q.prototype.isKinematicObject = function() {
          return !!Ib(this.Zx)
        }
        ;
        q.prototype.isStaticObject = function() {
          return !!Jb(this.Zx)
        }
        ;
        q.prototype.isStaticOrKinematicObject = function() {
          return !!Kb(this.Zx)
        }
        ;
        q.prototype.getRestitution = function() {
          return Lb(this.Zx)
        }
        ;
        q.prototype.getFriction = function() {
          return Mb(this.Zx)
        }
        ;
        q.prototype.getRollingFriction = function() {
          return Nb(this.Zx)
        }
        ;
        q.prototype.setRestitution = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ob(c, a)
        }
        ;
        q.prototype.setFriction = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Pb(c, a)
        }
        ;
        q.prototype.setRollingFriction = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Qb(c, a)
        }
        ;
        q.prototype.getWorldTransform = function() {
          return k(Rb(this.Zx), r)
        }
        ;
        q.prototype.getCollisionFlags = function() {
          return Sb(this.Zx)
        }
        ;
        q.prototype.setCollisionFlags = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Tb(c, a)
        }
        ;
        q.prototype.setWorldTransform = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ub(c, a)
        }
        ;
        q.prototype.setCollisionShape = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Vb(c, a)
        }
        ;
        q.prototype.setCcdMotionThreshold = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Xb(c, a)
        }
        ;
        q.prototype.setCcdSweptSphereRadius = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Yb(c, a)
        }
        ;
        q.prototype.getUserIndex = function() {
          return Zb(this.Zx)
        }
        ;
        q.prototype.setUserIndex = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          $b(c, a)
        }
        ;
        q.prototype.getUserPointer = function() {
          return k(ac(this.Zx), JA)
        }
        ;
        q.prototype.setUserPointer = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          bc(c, a)
        }
        ;
        q.prototype.getBroadphaseHandle = function() {
          return k(cc(this.Zx), t)
        }
        ;
        q.prototype.__destroy__ = function() {
          dc(this.Zx)
        }
        ;
        function u() {
          throw "cannot construct a btDynamicsWorld, no constructor in IDL";
        }
        u.prototype = Object.create(EA.prototype);
        u.prototype.constructor = u;
        u.prototype.$x = u;
        u.ay = {};
        b.btDynamicsWorld = u;
        u.prototype.addAction = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ec(c, a)
        }
        ;
        u.prototype.removeAction = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          fc(c, a)
        }
        ;
        u.prototype.getSolverInfo = function() {
          return k(hc(this.Zx), v)
        }
        ;
        u.prototype.setInternalTickCallback = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          void 0 === c ? ic(e, a) : void 0 === d ? jc(e, a, c) : kc(e, a, c, d)
        }
        ;
        u.prototype.getDispatcher = function() {
          return k(lc(this.Zx), FA)
        }
        ;
        u.prototype.rayTest = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          mc(e, a, c, d)
        }
        ;
        u.prototype.getPairCache = function() {
          return k(nc(this.Zx), GA)
        }
        ;
        u.prototype.getDispatchInfo = function() {
          return k(oc(this.Zx), l)
        }
        ;
        u.prototype.addCollisionObject = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          void 0 === c ? pc(e, a) : void 0 === d ? qc(e, a, c) : rc(e, a, c, d)
        }
        ;
        u.prototype.removeCollisionObject = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          sc(c, a)
        }
        ;
        u.prototype.getBroadphase = function() {
          return k(tc(this.Zx), HA)
        }
        ;
        u.prototype.convexSweepTest = function(a, c, d, e, f) {
          var m = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          uc(m, a, c, d, e, f)
        }
        ;
        u.prototype.contactPairTest = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          vc(e, a, c, d)
        }
        ;
        u.prototype.contactTest = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          wc(d, a, c)
        }
        ;
        u.prototype.updateSingleAabb = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          xc(c, a)
        }
        ;
        u.prototype.setDebugDrawer = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          yc(c, a)
        }
        ;
        u.prototype.getDebugDrawer = function() {
          return k(zc(this.Zx), IA)
        }
        ;
        u.prototype.debugDrawWorld = function() {
          Ac(this.Zx)
        }
        ;
        u.prototype.debugDrawObject = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          Bc(e, a, c, d)
        }
        ;
        u.prototype.__destroy__ = function() {
          Cc(this.Zx)
        }
        ;
        function KA() {
          throw "cannot construct a btTypedConstraint, no constructor in IDL";
        }
        KA.prototype = Object.create(g.prototype);
        KA.prototype.constructor = KA;
        KA.prototype.$x = KA;
        KA.ay = {};
        b.btTypedConstraint = KA;
        KA.prototype.enableFeedback = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Dc(c, a)
        }
        ;
        KA.prototype.getBreakingImpulseThreshold = function() {
          return Ec(this.Zx)
        }
        ;
        KA.prototype.setBreakingImpulseThreshold = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Fc(c, a)
        }
        ;
        KA.prototype.getParam = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          return Gc(d, a, c)
        }
        ;
        KA.prototype.setParam = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          Hc(e, a, c, d)
        }
        ;
        KA.prototype.__destroy__ = function() {
          Ic(this.Zx)
        }
        ;
        function LA() {
          throw "cannot construct a btConcaveShape, no constructor in IDL";
        }
        LA.prototype = Object.create(n.prototype);
        LA.prototype.constructor = LA;
        LA.prototype.$x = LA;
        LA.ay = {};
        b.btConcaveShape = LA;
        LA.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Jc(c, a)
        }
        ;
        LA.prototype.getLocalScaling = function() {
          return k(Kc(this.Zx), p)
        }
        ;
        LA.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Lc(d, a, c)
        }
        ;
        LA.prototype.__destroy__ = function() {
          Mc(this.Zx)
        }
        ;
        function MA(a, c) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          this.Zx = Nc(a, c);
          h(MA)[this.Zx] = this
        }
        MA.prototype = Object.create(n.prototype);
        MA.prototype.constructor = MA;
        MA.prototype.$x = MA;
        MA.ay = {};
        b.btCapsuleShape = MA;
        MA.prototype.setMargin = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Oc(c, a)
        }
        ;
        MA.prototype.getMargin = function() {
          return Pc(this.Zx)
        }
        ;
        MA.prototype.getUpAxis = function() {
          return Qc(this.Zx)
        }
        ;
        MA.prototype.getRadius = function() {
          return Rc(this.Zx)
        }
        ;
        MA.prototype.getHalfHeight = function() {
          return Sc(this.Zx)
        }
        ;
        MA.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Tc(c, a)
        }
        ;
        MA.prototype.getLocalScaling = function() {
          return k(Uc(this.Zx), p)
        }
        ;
        MA.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Vc(d, a, c)
        }
        ;
        MA.prototype.__destroy__ = function() {
          Wc(this.Zx)
        }
        ;
        function IA() {
          throw "cannot construct a btIDebugDraw, no constructor in IDL";
        }
        IA.prototype = Object.create(g.prototype);
        IA.prototype.constructor = IA;
        IA.prototype.$x = IA;
        IA.ay = {};
        b.btIDebugDraw = IA;
        IA.prototype.drawLine = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          Xc(e, a, c, d)
        }
        ;
        IA.prototype.drawContactPoint = function(a, c, d, e, f) {
          var m = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          Yc(m, a, c, d, e, f)
        }
        ;
        IA.prototype.reportErrorWarning = function(a) {
          var c = this.Zx;
          zA();
          a = a && "object" === typeof a ? a.Zx : CA(a);
          Zc(c, a)
        }
        ;
        IA.prototype.draw3dText = function(a, c) {
          var d = this.Zx;
          zA();
          a && "object" === typeof a && (a = a.Zx);
          c = c && "object" === typeof c ? c.Zx : CA(c);
          $c(d, a, c)
        }
        ;
        IA.prototype.setDebugMode = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ad(c, a)
        }
        ;
        IA.prototype.getDebugMode = function() {
          return bd(this.Zx)
        }
        ;
        IA.prototype.__destroy__ = function() {
          cd(this.Zx)
        }
        ;
        function NA(a) {
          a && "object" === typeof a && (a = a.Zx);
          this.Zx = void 0 === a ? dd() : ed(a);
          h(NA)[this.Zx] = this
        }
        NA.prototype = Object.create(g.prototype);
        NA.prototype.constructor = NA;
        NA.prototype.$x = NA;
        NA.ay = {};
        b.btDefaultCollisionConfiguration = NA;
        NA.prototype.__destroy__ = function() {
          fd(this.Zx)
        }
        ;
        function OA() {
          throw "cannot construct a btTriangleMeshShape, no constructor in IDL";
        }
        OA.prototype = Object.create(LA.prototype);
        OA.prototype.constructor = OA;
        OA.prototype.$x = OA;
        OA.ay = {};
        b.btTriangleMeshShape = OA;
        OA.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          gd(c, a)
        }
        ;
        OA.prototype.getLocalScaling = function() {
          return k(hd(this.Zx), p)
        }
        ;
        OA.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          id(d, a, c)
        }
        ;
        OA.prototype.__destroy__ = function() {
          jd(this.Zx)
        }
        ;
        function w() {
          this.Zx = kd();
          h(w)[this.Zx] = this
        }
        w.prototype = Object.create(q.prototype);
        w.prototype.constructor = w;
        w.prototype.$x = w;
        w.ay = {};
        b.btGhostObject = w;
        w.prototype.getNumOverlappingObjects = function() {
          return ld(this.Zx)
        }
        ;
        w.prototype.getOverlappingObject = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(md(c, a), q)
        }
        ;
        w.prototype.setAnisotropicFriction = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          nd(d, a, c)
        }
        ;
        w.prototype.getCollisionShape = function() {
          return k(od(this.Zx), n)
        }
        ;
        w.prototype.setContactProcessingThreshold = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          pd(c, a)
        }
        ;
        w.prototype.setActivationState = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          qd(c, a)
        }
        ;
        w.prototype.forceActivationState = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          rd(c, a)
        }
        ;
        w.prototype.activate = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          void 0 === a ? sd(c) : td(c, a)
        }
        ;
        w.prototype.isActive = function() {
          return !!ud(this.Zx)
        }
        ;
        w.prototype.isKinematicObject = function() {
          return !!vd(this.Zx)
        }
        ;
        w.prototype.isStaticObject = function() {
          return !!wd(this.Zx)
        }
        ;
        w.prototype.isStaticOrKinematicObject = function() {
          return !!xd(this.Zx)
        }
        ;
        w.prototype.getRestitution = function() {
          return yd(this.Zx)
        }
        ;
        w.prototype.getFriction = function() {
          return zd(this.Zx)
        }
        ;
        w.prototype.getRollingFriction = function() {
          return Ad(this.Zx)
        }
        ;
        w.prototype.setRestitution = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Bd(c, a)
        }
        ;
        w.prototype.setFriction = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Cd(c, a)
        }
        ;
        w.prototype.setRollingFriction = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Dd(c, a)
        }
        ;
        w.prototype.getWorldTransform = function() {
          return k(Ed(this.Zx), r)
        }
        ;
        w.prototype.getCollisionFlags = function() {
          return Fd(this.Zx)
        }
        ;
        w.prototype.setCollisionFlags = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Gd(c, a)
        }
        ;
        w.prototype.setWorldTransform = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Hd(c, a)
        }
        ;
        w.prototype.setCollisionShape = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Id(c, a)
        }
        ;
        w.prototype.setCcdMotionThreshold = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Jd(c, a)
        }
        ;
        w.prototype.setCcdSweptSphereRadius = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Kd(c, a)
        }
        ;
        w.prototype.getUserIndex = function() {
          return Ld(this.Zx)
        }
        ;
        w.prototype.setUserIndex = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Md(c, a)
        }
        ;
        w.prototype.getUserPointer = function() {
          return k(Nd(this.Zx), JA)
        }
        ;
        w.prototype.setUserPointer = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Od(c, a)
        }
        ;
        w.prototype.getBroadphaseHandle = function() {
          return k(Pd(this.Zx), t)
        }
        ;
        w.prototype.__destroy__ = function() {
          Qd(this.Zx)
        }
        ;
        function PA(a, c) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          this.Zx = Rd(a, c);
          h(PA)[this.Zx] = this
        }
        PA.prototype = Object.create(n.prototype);
        PA.prototype.constructor = PA;
        PA.prototype.$x = PA;
        PA.ay = {};
        b.btConeShape = PA;
        PA.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Sd(c, a)
        }
        ;
        PA.prototype.getLocalScaling = function() {
          return k(Td(this.Zx), p)
        }
        ;
        PA.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Ud(d, a, c)
        }
        ;
        PA.prototype.__destroy__ = function() {
          Vd(this.Zx)
        }
        ;
        function QA() {
          throw "cannot construct a btActionInterface, no constructor in IDL";
        }
        QA.prototype = Object.create(g.prototype);
        QA.prototype.constructor = QA;
        QA.prototype.$x = QA;
        QA.ay = {};
        b.btActionInterface = QA;
        QA.prototype.updateAction = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Wd(d, a, c)
        }
        ;
        QA.prototype.__destroy__ = function() {
          Xd(this.Zx)
        }
        ;
        function p(a, c, d) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          this.Zx = void 0 === a ? Yd() : void 0 === c ? _emscripten_bind_btVector3_btVector3_1(a) : void 0 === d ? _emscripten_bind_btVector3_btVector3_2(a, c) : Zd(a, c, d);
          h(p)[this.Zx] = this
        }
        p.prototype = Object.create(g.prototype);
        p.prototype.constructor = p;
        p.prototype.$x = p;
        p.ay = {};
        b.btVector3 = p;
        p.prototype.length = p.prototype.length = function() {
          return $d(this.Zx)
        }
        ;
        p.prototype.x = p.prototype.x = function() {
          return ae(this.Zx)
        }
        ;
        p.prototype.y = p.prototype.y = function() {
          return be(this.Zx)
        }
        ;
        p.prototype.z = p.prototype.z = function() {
          return ce(this.Zx)
        }
        ;
        p.prototype.setX = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          de(c, a)
        }
        ;
        p.prototype.setY = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ee(c, a)
        }
        ;
        p.prototype.setZ = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          fe(c, a)
        }
        ;
        p.prototype.setValue = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          ge(e, a, c, d)
        }
        ;
        p.prototype.normalize = p.prototype.normalize = function() {
          he(this.Zx)
        }
        ;
        p.prototype.rotate = p.prototype.rotate = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          return k(ie(d, a, c), p)
        }
        ;
        p.prototype.dot = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return je(c, a)
        }
        ;
        p.prototype.op_mul = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(ke(c, a), p)
        }
        ;
        p.prototype.op_add = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(le(c, a), p)
        }
        ;
        p.prototype.op_sub = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(me(c, a), p)
        }
        ;
        p.prototype.__destroy__ = function() {
          ne(this.Zx)
        }
        ;
        function RA() {
          throw "cannot construct a btVehicleRaycaster, no constructor in IDL";
        }
        RA.prototype = Object.create(g.prototype);
        RA.prototype.constructor = RA;
        RA.prototype.$x = RA;
        RA.ay = {};
        b.btVehicleRaycaster = RA;
        RA.prototype.castRay = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          oe(e, a, c, d)
        }
        ;
        RA.prototype.__destroy__ = function() {
          pe(this.Zx)
        }
        ;
        function SA() {
          throw "cannot construct a btQuadWord, no constructor in IDL";
        }
        SA.prototype = Object.create(g.prototype);
        SA.prototype.constructor = SA;
        SA.prototype.$x = SA;
        SA.ay = {};
        b.btQuadWord = SA;
        SA.prototype.x = SA.prototype.x = function() {
          return qe(this.Zx)
        }
        ;
        SA.prototype.y = SA.prototype.y = function() {
          return re(this.Zx)
        }
        ;
        SA.prototype.z = SA.prototype.z = function() {
          return se(this.Zx)
        }
        ;
        SA.prototype.w = function() {
          return te(this.Zx)
        }
        ;
        SA.prototype.setX = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ue(c, a)
        }
        ;
        SA.prototype.setY = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ve(c, a)
        }
        ;
        SA.prototype.setZ = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          we(c, a)
        }
        ;
        SA.prototype.setW = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          xe(c, a)
        }
        ;
        SA.prototype.__destroy__ = function() {
          ye(this.Zx)
        }
        ;
        function TA(a) {
          a && "object" === typeof a && (a = a.Zx);
          this.Zx = ze(a);
          h(TA)[this.Zx] = this
        }
        TA.prototype = Object.create(n.prototype);
        TA.prototype.constructor = TA;
        TA.prototype.$x = TA;
        TA.ay = {};
        b.btCylinderShape = TA;
        TA.prototype.setMargin = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ae(c, a)
        }
        ;
        TA.prototype.getMargin = function() {
          return Be(this.Zx)
        }
        ;
        TA.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ce(c, a)
        }
        ;
        TA.prototype.getLocalScaling = function() {
          return k(De(this.Zx), p)
        }
        ;
        TA.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Ee(d, a, c)
        }
        ;
        TA.prototype.__destroy__ = function() {
          Fe(this.Zx)
        }
        ;
        function x(a, c, d, e) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          this.Zx = Ge(a, c, d, e);
          h(x)[this.Zx] = this
        }
        x.prototype = Object.create(u.prototype);
        x.prototype.constructor = x;
        x.prototype.$x = x;
        x.ay = {};
        b.btDiscreteDynamicsWorld = x;
        x.prototype.setGravity = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          He(c, a)
        }
        ;
        x.prototype.getGravity = function() {
          return k(Ie(this.Zx), p)
        }
        ;
        x.prototype.addRigidBody = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          void 0 === c ? Je(e, a) : void 0 === d ? _emscripten_bind_btDiscreteDynamicsWorld_addRigidBody_2(e, a, c) : Ke(e, a, c, d)
        }
        ;
        x.prototype.removeRigidBody = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Le(c, a)
        }
        ;
        x.prototype.addConstraint = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          void 0 === c ? Me(d, a) : Ne(d, a, c)
        }
        ;
        x.prototype.removeConstraint = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Oe(c, a)
        }
        ;
        x.prototype.stepSimulation = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          return void 0 === c ? Pe(e, a) : void 0 === d ? Qe(e, a, c) : Re(e, a, c, d)
        }
        ;
        x.prototype.setContactAddedCallback = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Se(c, a)
        }
        ;
        x.prototype.setContactProcessedCallback = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Te(c, a)
        }
        ;
        x.prototype.setContactDestroyedCallback = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ue(c, a)
        }
        ;
        x.prototype.getDispatcher = function() {
          return k(Ve(this.Zx), FA)
        }
        ;
        x.prototype.rayTest = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          We(e, a, c, d)
        }
        ;
        x.prototype.getPairCache = function() {
          return k(Xe(this.Zx), GA)
        }
        ;
        x.prototype.getDispatchInfo = function() {
          return k(Ye(this.Zx), l)
        }
        ;
        x.prototype.addCollisionObject = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          void 0 === c ? Ze(e, a) : void 0 === d ? $e(e, a, c) : af(e, a, c, d)
        }
        ;
        x.prototype.removeCollisionObject = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          bf(c, a)
        }
        ;
        x.prototype.getBroadphase = function() {
          return k(cf(this.Zx), HA)
        }
        ;
        x.prototype.convexSweepTest = function(a, c, d, e, f) {
          var m = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          df(m, a, c, d, e, f)
        }
        ;
        x.prototype.contactPairTest = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          ef(e, a, c, d)
        }
        ;
        x.prototype.contactTest = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          ff(d, a, c)
        }
        ;
        x.prototype.updateSingleAabb = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          gf(c, a)
        }
        ;
        x.prototype.setDebugDrawer = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          hf(c, a)
        }
        ;
        x.prototype.getDebugDrawer = function() {
          return k(jf(this.Zx), IA)
        }
        ;
        x.prototype.debugDrawWorld = function() {
          kf(this.Zx)
        }
        ;
        x.prototype.debugDrawObject = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          lf(e, a, c, d)
        }
        ;
        x.prototype.addAction = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          mf(c, a)
        }
        ;
        x.prototype.removeAction = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          nf(c, a)
        }
        ;
        x.prototype.getSolverInfo = function() {
          return k(of(this.Zx), v)
        }
        ;
        x.prototype.setInternalTickCallback = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          void 0 === c ? pf(e, a) : void 0 === d ? qf(e, a, c) : rf(e, a, c, d)
        }
        ;
        x.prototype.__destroy__ = function() {
          sf(this.Zx)
        }
        ;
        function UA() {
          throw "cannot construct a btConvexShape, no constructor in IDL";
        }
        UA.prototype = Object.create(n.prototype);
        UA.prototype.constructor = UA;
        UA.prototype.$x = UA;
        UA.ay = {};
        b.btConvexShape = UA;
        UA.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          tf(c, a)
        }
        ;
        UA.prototype.getLocalScaling = function() {
          return k(uf(this.Zx), p)
        }
        ;
        UA.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          vf(d, a, c)
        }
        ;
        UA.prototype.setMargin = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          wf(c, a)
        }
        ;
        UA.prototype.getMargin = function() {
          return xf(this.Zx)
        }
        ;
        UA.prototype.__destroy__ = function() {
          yf(this.Zx)
        }
        ;
        function FA() {
          throw "cannot construct a btDispatcher, no constructor in IDL";
        }
        FA.prototype = Object.create(g.prototype);
        FA.prototype.constructor = FA;
        FA.prototype.$x = FA;
        FA.ay = {};
        b.btDispatcher = FA;
        FA.prototype.getNumManifolds = function() {
          return zf(this.Zx)
        }
        ;
        FA.prototype.getManifoldByIndexInternal = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(Af(c, a), VA)
        }
        ;
        FA.prototype.__destroy__ = function() {
          Bf(this.Zx)
        }
        ;
        function WA(a, c, d, e, f) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          this.Zx = void 0 === e ? Cf(a, c, d) : void 0 === f ? _emscripten_bind_btGeneric6DofConstraint_btGeneric6DofConstraint_4(a, c, d, e) : Df(a, c, d, e, f);
          h(WA)[this.Zx] = this
        }
        WA.prototype = Object.create(KA.prototype);
        WA.prototype.constructor = WA;
        WA.prototype.$x = WA;
        WA.ay = {};
        b.btGeneric6DofConstraint = WA;
        WA.prototype.setLinearLowerLimit = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ef(c, a)
        }
        ;
        WA.prototype.setLinearUpperLimit = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ff(c, a)
        }
        ;
        WA.prototype.setAngularLowerLimit = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Gf(c, a)
        }
        ;
        WA.prototype.setAngularUpperLimit = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Hf(c, a)
        }
        ;
        WA.prototype.getFrameOffsetA = function() {
          return k(If(this.Zx), r)
        }
        ;
        WA.prototype.enableFeedback = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Jf(c, a)
        }
        ;
        WA.prototype.getBreakingImpulseThreshold = function() {
          return Kf(this.Zx)
        }
        ;
        WA.prototype.setBreakingImpulseThreshold = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Lf(c, a)
        }
        ;
        WA.prototype.getParam = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          return Mf(d, a, c)
        }
        ;
        WA.prototype.setParam = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          Nf(e, a, c, d)
        }
        ;
        WA.prototype.__destroy__ = function() {
          Of(this.Zx)
        }
        ;
        function XA() {
          throw "cannot construct a btStridingMeshInterface, no constructor in IDL";
        }
        XA.prototype = Object.create(g.prototype);
        XA.prototype.constructor = XA;
        XA.prototype.$x = XA;
        XA.ay = {};
        b.btStridingMeshInterface = XA;
        XA.prototype.setScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Pf(c, a)
        }
        ;
        XA.prototype.__destroy__ = function() {
          Qf(this.Zx)
        }
        ;
        function YA() {
          throw "cannot construct a btMotionState, no constructor in IDL";
        }
        YA.prototype = Object.create(g.prototype);
        YA.prototype.constructor = YA;
        YA.prototype.$x = YA;
        YA.ay = {};
        b.btMotionState = YA;
        YA.prototype.getWorldTransform = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Rf(c, a)
        }
        ;
        YA.prototype.setWorldTransform = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Sf(c, a)
        }
        ;
        YA.prototype.__destroy__ = function() {
          Tf(this.Zx)
        }
        ;
        function y() {
          throw "cannot construct a ConvexResultCallback, no constructor in IDL";
        }
        y.prototype = Object.create(g.prototype);
        y.prototype.constructor = y;
        y.prototype.$x = y;
        y.ay = {};
        b.ConvexResultCallback = y;
        y.prototype.hasHit = function() {
          return !!Uf(this.Zx)
        }
        ;
        y.prototype.get_m_collisionFilterGroup = y.prototype.by = function() {
          return Vf(this.Zx)
        }
        ;
        y.prototype.set_m_collisionFilterGroup = y.prototype.dy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Wf(c, a)
        }
        ;
        Object.defineProperty(y.prototype, "m_collisionFilterGroup", {
          get: y.prototype.by,
          set: y.prototype.dy
        });
        y.prototype.get_m_collisionFilterMask = y.prototype.cy = function() {
          return Xf(this.Zx)
        }
        ;
        y.prototype.set_m_collisionFilterMask = y.prototype.ey = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Yf(c, a)
        }
        ;
        Object.defineProperty(y.prototype, "m_collisionFilterMask", {
          get: y.prototype.cy,
          set: y.prototype.ey
        });
        y.prototype.get_m_closestHitFraction = y.prototype.fy = function() {
          return Zf(this.Zx)
        }
        ;
        y.prototype.set_m_closestHitFraction = y.prototype.gy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          $f(c, a)
        }
        ;
        Object.defineProperty(y.prototype, "m_closestHitFraction", {
          get: y.prototype.fy,
          set: y.prototype.gy
        });
        y.prototype.__destroy__ = function() {
          ag(this.Zx)
        }
        ;
        function ZA() {
          throw "cannot construct a ContactResultCallback, no constructor in IDL";
        }
        ZA.prototype = Object.create(g.prototype);
        ZA.prototype.constructor = ZA;
        ZA.prototype.$x = ZA;
        ZA.ay = {};
        b.ContactResultCallback = ZA;
        ZA.prototype.addSingleResult = function(a, c, d, e, f, m, C) {
          var P = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          m && "object" === typeof m && (m = m.Zx);
          C && "object" === typeof C && (C = C.Zx);
          return bg(P, a, c, d, e, f, m, C)
        }
        ;
        ZA.prototype.__destroy__ = function() {
          cg(this.Zx)
        }
        ;
        function $A() {
          throw "cannot construct a btSoftBodySolver, no constructor in IDL";
        }
        $A.prototype = Object.create(g.prototype);
        $A.prototype.constructor = $A;
        $A.prototype.$x = $A;
        $A.ay = {};
        b.btSoftBodySolver = $A;
        $A.prototype.__destroy__ = function() {
          dg(this.Zx)
        }
        ;
        function z() {
          throw "cannot construct a RayResultCallback, no constructor in IDL";
        }
        z.prototype = Object.create(g.prototype);
        z.prototype.constructor = z;
        z.prototype.$x = z;
        z.ay = {};
        b.RayResultCallback = z;
        z.prototype.hasHit = function() {
          return !!eg(this.Zx)
        }
        ;
        z.prototype.get_m_collisionFilterGroup = z.prototype.by = function() {
          return fg(this.Zx)
        }
        ;
        z.prototype.set_m_collisionFilterGroup = z.prototype.dy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          gg(c, a)
        }
        ;
        Object.defineProperty(z.prototype, "m_collisionFilterGroup", {
          get: z.prototype.by,
          set: z.prototype.dy
        });
        z.prototype.get_m_collisionFilterMask = z.prototype.cy = function() {
          return hg(this.Zx)
        }
        ;
        z.prototype.set_m_collisionFilterMask = z.prototype.ey = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ig(c, a)
        }
        ;
        Object.defineProperty(z.prototype, "m_collisionFilterMask", {
          get: z.prototype.cy,
          set: z.prototype.ey
        });
        z.prototype.get_m_closestHitFraction = z.prototype.fy = function() {
          return jg(this.Zx)
        }
        ;
        z.prototype.set_m_closestHitFraction = z.prototype.gy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          kg(c, a)
        }
        ;
        Object.defineProperty(z.prototype, "m_closestHitFraction", {
          get: z.prototype.fy,
          set: z.prototype.gy
        });
        z.prototype.get_m_collisionObject = z.prototype.hy = function() {
          return k(lg(this.Zx), q)
        }
        ;
        z.prototype.set_m_collisionObject = z.prototype.oy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          mg(c, a)
        }
        ;
        Object.defineProperty(z.prototype, "m_collisionObject", {
          get: z.prototype.hy,
          set: z.prototype.oy
        });
        z.prototype.__destroy__ = function() {
          ng(this.Zx)
        }
        ;
        function aB() {
          throw "cannot construct a btMatrix3x3, no constructor in IDL";
        }
        aB.prototype = Object.create(g.prototype);
        aB.prototype.constructor = aB;
        aB.prototype.$x = aB;
        aB.ay = {};
        b.btMatrix3x3 = aB;
        aB.prototype.setEulerZYX = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          og(e, a, c, d)
        }
        ;
        aB.prototype.getRotation = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          pg(c, a)
        }
        ;
        aB.prototype.getRow = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(qg(c, a), p)
        }
        ;
        aB.prototype.__destroy__ = function() {
          rg(this.Zx)
        }
        ;
        function bB() {
          throw "cannot construct a btScalarArray, no constructor in IDL";
        }
        bB.prototype = Object.create(g.prototype);
        bB.prototype.constructor = bB;
        bB.prototype.$x = bB;
        bB.ay = {};
        b.btScalarArray = bB;
        bB.prototype.size = bB.prototype.size = function() {
          return sg(this.Zx)
        }
        ;
        bB.prototype.at = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return tg(c, a)
        }
        ;
        bB.prototype.__destroy__ = function() {
          ug(this.Zx)
        }
        ;
        function A() {
          throw "cannot construct a Material, no constructor in IDL";
        }
        A.prototype = Object.create(g.prototype);
        A.prototype.constructor = A;
        A.prototype.$x = A;
        A.ay = {};
        b.Material = A;
        A.prototype.get_m_kLST = A.prototype.jA = function() {
          return vg(this.Zx)
        }
        ;
        A.prototype.set_m_kLST = A.prototype.QC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          wg(c, a)
        }
        ;
        Object.defineProperty(A.prototype, "m_kLST", {
          get: A.prototype.jA,
          set: A.prototype.QC
        });
        A.prototype.get_m_kAST = A.prototype.iA = function() {
          return xg(this.Zx)
        }
        ;
        A.prototype.set_m_kAST = A.prototype.PC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          yg(c, a)
        }
        ;
        Object.defineProperty(A.prototype, "m_kAST", {
          get: A.prototype.iA,
          set: A.prototype.PC
        });
        A.prototype.get_m_kVST = A.prototype.kA = function() {
          return zg(this.Zx)
        }
        ;
        A.prototype.set_m_kVST = A.prototype.RC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ag(c, a)
        }
        ;
        Object.defineProperty(A.prototype, "m_kVST", {
          get: A.prototype.kA,
          set: A.prototype.RC
        });
        A.prototype.get_m_flags = A.prototype.Rz = function() {
          return Bg(this.Zx)
        }
        ;
        A.prototype.set_m_flags = A.prototype.xC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Cg(c, a)
        }
        ;
        Object.defineProperty(A.prototype, "m_flags", {
          get: A.prototype.Rz,
          set: A.prototype.xC
        });
        A.prototype.__destroy__ = function() {
          Dg(this.Zx)
        }
        ;
        function l() {
          throw "cannot construct a btDispatcherInfo, no constructor in IDL";
        }
        l.prototype = Object.create(g.prototype);
        l.prototype.constructor = l;
        l.prototype.$x = l;
        l.ay = {};
        b.btDispatcherInfo = l;
        l.prototype.get_m_timeStep = l.prototype.XA = function() {
          return Eg(this.Zx)
        }
        ;
        l.prototype.set_m_timeStep = l.prototype.DD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Fg(c, a)
        }
        ;
        Object.defineProperty(l.prototype, "m_timeStep", {
          get: l.prototype.XA,
          set: l.prototype.DD
        });
        l.prototype.get_m_stepCount = l.prototype.OA = function() {
          return Gg(this.Zx)
        }
        ;
        l.prototype.set_m_stepCount = l.prototype.uD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Hg(c, a)
        }
        ;
        Object.defineProperty(l.prototype, "m_stepCount", {
          get: l.prototype.OA,
          set: l.prototype.uD
        });
        l.prototype.get_m_dispatchFunc = l.prototype.Jz = function() {
          return Ig(this.Zx)
        }
        ;
        l.prototype.set_m_dispatchFunc = l.prototype.pC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Jg(c, a)
        }
        ;
        Object.defineProperty(l.prototype, "m_dispatchFunc", {
          get: l.prototype.Jz,
          set: l.prototype.pC
        });
        l.prototype.get_m_timeOfImpact = l.prototype.WA = function() {
          return Kg(this.Zx)
        }
        ;
        l.prototype.set_m_timeOfImpact = l.prototype.CD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Lg(c, a)
        }
        ;
        Object.defineProperty(l.prototype, "m_timeOfImpact", {
          get: l.prototype.WA,
          set: l.prototype.CD
        });
        l.prototype.get_m_useContinuous = l.prototype.ZA = function() {
          return !!Mg(this.Zx)
        }
        ;
        l.prototype.set_m_useContinuous = l.prototype.FD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ng(c, a)
        }
        ;
        Object.defineProperty(l.prototype, "m_useContinuous", {
          get: l.prototype.ZA,
          set: l.prototype.FD
        });
        l.prototype.get_m_enableSatConvex = l.prototype.Nz = function() {
          return !!Og(this.Zx)
        }
        ;
        l.prototype.set_m_enableSatConvex = l.prototype.tC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Pg(c, a)
        }
        ;
        Object.defineProperty(l.prototype, "m_enableSatConvex", {
          get: l.prototype.Nz,
          set: l.prototype.tC
        });
        l.prototype.get_m_enableSPU = l.prototype.Mz = function() {
          return !!Qg(this.Zx)
        }
        ;
        l.prototype.set_m_enableSPU = l.prototype.sC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Rg(c, a)
        }
        ;
        Object.defineProperty(l.prototype, "m_enableSPU", {
          get: l.prototype.Mz,
          set: l.prototype.sC
        });
        l.prototype.get_m_useEpa = l.prototype.aB = function() {
          return !!Sg(this.Zx)
        }
        ;
        l.prototype.set_m_useEpa = l.prototype.HD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Tg(c, a)
        }
        ;
        Object.defineProperty(l.prototype, "m_useEpa", {
          get: l.prototype.aB,
          set: l.prototype.HD
        });
        l.prototype.get_m_allowedCcdPenetration = l.prototype.lz = function() {
          return Ug(this.Zx)
        }
        ;
        l.prototype.set_m_allowedCcdPenetration = l.prototype.TB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Vg(c, a)
        }
        ;
        Object.defineProperty(l.prototype, "m_allowedCcdPenetration", {
          get: l.prototype.lz,
          set: l.prototype.TB
        });
        l.prototype.get_m_useConvexConservativeDistanceUtil = l.prototype.$A = function() {
          return !!Wg(this.Zx)
        }
        ;
        l.prototype.set_m_useConvexConservativeDistanceUtil = l.prototype.GD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Xg(c, a)
        }
        ;
        Object.defineProperty(l.prototype, "m_useConvexConservativeDistanceUtil", {
          get: l.prototype.$A,
          set: l.prototype.GD
        });
        l.prototype.get_m_convexConservativeDistanceThreshold = l.prototype.Ez = function() {
          return Yg(this.Zx)
        }
        ;
        l.prototype.set_m_convexConservativeDistanceThreshold = l.prototype.kC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Zg(c, a)
        }
        ;
        Object.defineProperty(l.prototype, "m_convexConservativeDistanceThreshold", {
          get: l.prototype.Ez,
          set: l.prototype.kC
        });
        l.prototype.__destroy__ = function() {
          $g(this.Zx)
        }
        ;
        function B() {
          throw "cannot construct a btWheelInfoConstructionInfo, no constructor in IDL";
        }
        B.prototype = Object.create(g.prototype);
        B.prototype.constructor = B;
        B.prototype.$x = B;
        B.ay = {};
        b.btWheelInfoConstructionInfo = B;
        B.prototype.get_m_chassisConnectionCS = B.prototype.yz = function() {
          return k(ah(this.Zx), p)
        }
        ;
        B.prototype.set_m_chassisConnectionCS = B.prototype.eC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          bh(c, a)
        }
        ;
        Object.defineProperty(B.prototype, "m_chassisConnectionCS", {
          get: B.prototype.yz,
          set: B.prototype.eC
        });
        B.prototype.get_m_wheelDirectionCS = B.prototype.Ay = function() {
          return k(ch(this.Zx), p)
        }
        ;
        B.prototype.set_m_wheelDirectionCS = B.prototype.Hy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          dh(c, a)
        }
        ;
        Object.defineProperty(B.prototype, "m_wheelDirectionCS", {
          get: B.prototype.Ay,
          set: B.prototype.Hy
        });
        B.prototype.get_m_wheelAxleCS = B.prototype.zy = function() {
          return k(eh(this.Zx), p)
        }
        ;
        B.prototype.set_m_wheelAxleCS = B.prototype.Gy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          fh(c, a)
        }
        ;
        Object.defineProperty(B.prototype, "m_wheelAxleCS", {
          get: B.prototype.zy,
          set: B.prototype.Gy
        });
        B.prototype.get_m_suspensionRestLength = B.prototype.TA = function() {
          return gh(this.Zx)
        }
        ;
        B.prototype.set_m_suspensionRestLength = B.prototype.zD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          hh(c, a)
        }
        ;
        Object.defineProperty(B.prototype, "m_suspensionRestLength", {
          get: B.prototype.TA,
          set: B.prototype.zD
        });
        B.prototype.get_m_maxSuspensionTravelCm = B.prototype.my = function() {
          return ih(this.Zx)
        }
        ;
        B.prototype.set_m_maxSuspensionTravelCm = B.prototype.ty = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          jh(c, a)
        }
        ;
        Object.defineProperty(B.prototype, "m_maxSuspensionTravelCm", {
          get: B.prototype.my,
          set: B.prototype.ty
        });
        B.prototype.get_m_wheelRadius = B.prototype.gB = function() {
          return kh(this.Zx)
        }
        ;
        B.prototype.set_m_wheelRadius = B.prototype.ND = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          lh(c, a)
        }
        ;
        Object.defineProperty(B.prototype, "m_wheelRadius", {
          get: B.prototype.gB,
          set: B.prototype.ND
        });
        B.prototype.get_m_suspensionStiffness = B.prototype.ny = function() {
          return mh(this.Zx)
        }
        ;
        B.prototype.set_m_suspensionStiffness = B.prototype.uy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          nh(c, a)
        }
        ;
        Object.defineProperty(B.prototype, "m_suspensionStiffness", {
          get: B.prototype.ny,
          set: B.prototype.uy
        });
        B.prototype.get_m_wheelsDampingCompression = B.prototype.By = function() {
          return oh(this.Zx)
        }
        ;
        B.prototype.set_m_wheelsDampingCompression = B.prototype.Iy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ph(c, a)
        }
        ;
        Object.defineProperty(B.prototype, "m_wheelsDampingCompression", {
          get: B.prototype.By,
          set: B.prototype.Iy
        });
        B.prototype.get_m_wheelsDampingRelaxation = B.prototype.Cy = function() {
          return qh(this.Zx)
        }
        ;
        B.prototype.set_m_wheelsDampingRelaxation = B.prototype.Jy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          rh(c, a)
        }
        ;
        Object.defineProperty(B.prototype, "m_wheelsDampingRelaxation", {
          get: B.prototype.Cy,
          set: B.prototype.Jy
        });
        B.prototype.get_m_frictionSlip = B.prototype.iy = function() {
          return sh(this.Zx)
        }
        ;
        B.prototype.set_m_frictionSlip = B.prototype.py = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          th(c, a)
        }
        ;
        Object.defineProperty(B.prototype, "m_frictionSlip", {
          get: B.prototype.iy,
          set: B.prototype.py
        });
        B.prototype.get_m_maxSuspensionForce = B.prototype.ly = function() {
          return uh(this.Zx)
        }
        ;
        B.prototype.set_m_maxSuspensionForce = B.prototype.sy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          vh(c, a)
        }
        ;
        Object.defineProperty(B.prototype, "m_maxSuspensionForce", {
          get: B.prototype.ly,
          set: B.prototype.sy
        });
        B.prototype.get_m_bIsFrontWheel = B.prototype.wy = function() {
          return !!wh(this.Zx)
        }
        ;
        B.prototype.set_m_bIsFrontWheel = B.prototype.Dy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          xh(c, a)
        }
        ;
        Object.defineProperty(B.prototype, "m_bIsFrontWheel", {
          get: B.prototype.wy,
          set: B.prototype.Dy
        });
        B.prototype.__destroy__ = function() {
          yh(this.Zx)
        }
        ;
        function cB(a, c) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          this.Zx = void 0 === c ? zh(a) : Ah(a, c);
          h(cB)[this.Zx] = this
        }
        cB.prototype = Object.create(UA.prototype);
        cB.prototype.constructor = cB;
        cB.prototype.$x = cB;
        cB.ay = {};
        b.btConvexTriangleMeshShape = cB;
        cB.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Bh(c, a)
        }
        ;
        cB.prototype.getLocalScaling = function() {
          return k(Ch(this.Zx), p)
        }
        ;
        cB.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Dh(d, a, c)
        }
        ;
        cB.prototype.setMargin = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Eh(c, a)
        }
        ;
        cB.prototype.getMargin = function() {
          return Fh(this.Zx)
        }
        ;
        cB.prototype.__destroy__ = function() {
          Gh(this.Zx)
        }
        ;
        function HA() {
          throw "cannot construct a btBroadphaseInterface, no constructor in IDL";
        }
        HA.prototype = Object.create(g.prototype);
        HA.prototype.constructor = HA;
        HA.prototype.$x = HA;
        HA.ay = {};
        b.btBroadphaseInterface = HA;
        HA.prototype.getOverlappingPairCache = function() {
          return k(Hh(this.Zx), GA)
        }
        ;
        HA.prototype.__destroy__ = function() {
          Ih(this.Zx)
        }
        ;
        function D(a, c, d, e) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          this.Zx = void 0 === e ? Jh(a, c, d) : Kh(a, c, d, e);
          h(D)[this.Zx] = this
        }
        D.prototype = Object.create(g.prototype);
        D.prototype.constructor = D;
        D.prototype.$x = D;
        D.ay = {};
        b.btRigidBodyConstructionInfo = D;
        D.prototype.get_m_linearDamping = D.prototype.lA = function() {
          return Lh(this.Zx)
        }
        ;
        D.prototype.set_m_linearDamping = D.prototype.SC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Mh(c, a)
        }
        ;
        Object.defineProperty(D.prototype, "m_linearDamping", {
          get: D.prototype.lA,
          set: D.prototype.SC
        });
        D.prototype.get_m_angularDamping = D.prototype.nz = function() {
          return Nh(this.Zx)
        }
        ;
        D.prototype.set_m_angularDamping = D.prototype.VB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Oh(c, a)
        }
        ;
        Object.defineProperty(D.prototype, "m_angularDamping", {
          get: D.prototype.nz,
          set: D.prototype.VB
        });
        D.prototype.get_m_friction = D.prototype.Sz = function() {
          return Ph(this.Zx)
        }
        ;
        D.prototype.set_m_friction = D.prototype.yC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Qh(c, a)
        }
        ;
        Object.defineProperty(D.prototype, "m_friction", {
          get: D.prototype.Sz,
          set: D.prototype.yC
        });
        D.prototype.get_m_rollingFriction = D.prototype.GA = function() {
          return Rh(this.Zx)
        }
        ;
        D.prototype.set_m_rollingFriction = D.prototype.mD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Sh(c, a)
        }
        ;
        Object.defineProperty(D.prototype, "m_rollingFriction", {
          get: D.prototype.GA,
          set: D.prototype.mD
        });
        D.prototype.get_m_restitution = D.prototype.EA = function() {
          return Th(this.Zx)
        }
        ;
        D.prototype.set_m_restitution = D.prototype.kD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Uh(c, a)
        }
        ;
        Object.defineProperty(D.prototype, "m_restitution", {
          get: D.prototype.EA,
          set: D.prototype.kD
        });
        D.prototype.get_m_linearSleepingThreshold = D.prototype.mA = function() {
          return Vh(this.Zx)
        }
        ;
        D.prototype.set_m_linearSleepingThreshold = D.prototype.TC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Wh(c, a)
        }
        ;
        Object.defineProperty(D.prototype, "m_linearSleepingThreshold", {
          get: D.prototype.mA,
          set: D.prototype.TC
        });
        D.prototype.get_m_angularSleepingThreshold = D.prototype.oz = function() {
          return Xh(this.Zx)
        }
        ;
        D.prototype.set_m_angularSleepingThreshold = D.prototype.WB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Yh(c, a)
        }
        ;
        Object.defineProperty(D.prototype, "m_angularSleepingThreshold", {
          get: D.prototype.oz,
          set: D.prototype.WB
        });
        D.prototype.get_m_additionalDamping = D.prototype.iz = function() {
          return !!Zh(this.Zx)
        }
        ;
        D.prototype.set_m_additionalDamping = D.prototype.QB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          $h(c, a)
        }
        ;
        Object.defineProperty(D.prototype, "m_additionalDamping", {
          get: D.prototype.iz,
          set: D.prototype.QB
        });
        D.prototype.get_m_additionalDampingFactor = D.prototype.jz = function() {
          return ai(this.Zx)
        }
        ;
        D.prototype.set_m_additionalDampingFactor = D.prototype.RB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          bi(c, a)
        }
        ;
        Object.defineProperty(D.prototype, "m_additionalDampingFactor", {
          get: D.prototype.jz,
          set: D.prototype.RB
        });
        D.prototype.get_m_additionalLinearDampingThresholdSqr = D.prototype.kz = function() {
          return ci(this.Zx)
        }
        ;
        D.prototype.set_m_additionalLinearDampingThresholdSqr = D.prototype.SB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          di(c, a)
        }
        ;
        Object.defineProperty(D.prototype, "m_additionalLinearDampingThresholdSqr", {
          get: D.prototype.kz,
          set: D.prototype.SB
        });
        D.prototype.get_m_additionalAngularDampingThresholdSqr = D.prototype.hz = function() {
          return ei(this.Zx)
        }
        ;
        D.prototype.set_m_additionalAngularDampingThresholdSqr = D.prototype.PB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          fi(c, a)
        }
        ;
        Object.defineProperty(D.prototype, "m_additionalAngularDampingThresholdSqr", {
          get: D.prototype.hz,
          set: D.prototype.PB
        });
        D.prototype.get_m_additionalAngularDampingFactor = D.prototype.gz = function() {
          return gi(this.Zx)
        }
        ;
        D.prototype.set_m_additionalAngularDampingFactor = D.prototype.OB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          hi(c, a)
        }
        ;
        Object.defineProperty(D.prototype, "m_additionalAngularDampingFactor", {
          get: D.prototype.gz,
          set: D.prototype.OB
        });
        D.prototype.__destroy__ = function() {
          ii(this.Zx)
        }
        ;
        function dB() {
          throw "cannot construct a btCollisionConfiguration, no constructor in IDL";
        }
        dB.prototype = Object.create(g.prototype);
        dB.prototype.constructor = dB;
        dB.prototype.$x = dB;
        dB.ay = {};
        b.btCollisionConfiguration = dB;
        dB.prototype.__destroy__ = function() {
          ji(this.Zx)
        }
        ;
        function VA() {
          this.Zx = ki();
          h(VA)[this.Zx] = this
        }
        VA.prototype = Object.create(g.prototype);
        VA.prototype.constructor = VA;
        VA.prototype.$x = VA;
        VA.ay = {};
        b.btPersistentManifold = VA;
        VA.prototype.getBody0 = function() {
          return k(li(this.Zx), q)
        }
        ;
        VA.prototype.getBody1 = function() {
          return k(mi(this.Zx), q)
        }
        ;
        VA.prototype.getNumContacts = function() {
          return ni(this.Zx)
        }
        ;
        VA.prototype.getContactPoint = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(oi(c, a), E)
        }
        ;
        VA.prototype.__destroy__ = function() {
          pi(this.Zx)
        }
        ;
        function eB(a) {
          a && "object" === typeof a && (a = a.Zx);
          this.Zx = void 0 === a ? qi() : ri(a);
          h(eB)[this.Zx] = this
        }
        eB.prototype = Object.create(n.prototype);
        eB.prototype.constructor = eB;
        eB.prototype.$x = eB;
        eB.ay = {};
        b.btCompoundShape = eB;
        eB.prototype.addChildShape = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          si(d, a, c)
        }
        ;
        eB.prototype.removeChildShape = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ti(c, a)
        }
        ;
        eB.prototype.removeChildShapeByIndex = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ui(c, a)
        }
        ;
        eB.prototype.getNumChildShapes = function() {
          return vi(this.Zx)
        }
        ;
        eB.prototype.getChildShape = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(wi(c, a), n)
        }
        ;
        eB.prototype.updateChildTransform = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          void 0 === d ? xi(e, a, c) : yi(e, a, c, d)
        }
        ;
        eB.prototype.setMargin = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          zi(c, a)
        }
        ;
        eB.prototype.getMargin = function() {
          return Ai(this.Zx)
        }
        ;
        eB.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Bi(c, a)
        }
        ;
        eB.prototype.getLocalScaling = function() {
          return k(Ci(this.Zx), p)
        }
        ;
        eB.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Di(d, a, c)
        }
        ;
        eB.prototype.__destroy__ = function() {
          Ei(this.Zx)
        }
        ;
        function F(a, c) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          this.Zx = Fi(a, c);
          h(F)[this.Zx] = this
        }
        F.prototype = Object.create(y.prototype);
        F.prototype.constructor = F;
        F.prototype.$x = F;
        F.ay = {};
        b.ClosestConvexResultCallback = F;
        F.prototype.hasHit = function() {
          return !!Gi(this.Zx)
        }
        ;
        F.prototype.get_m_convexFromWorld = F.prototype.Fz = function() {
          return k(Hi(this.Zx), p)
        }
        ;
        F.prototype.set_m_convexFromWorld = F.prototype.lC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ii(c, a)
        }
        ;
        Object.defineProperty(F.prototype, "m_convexFromWorld", {
          get: F.prototype.Fz,
          set: F.prototype.lC
        });
        F.prototype.get_m_convexToWorld = F.prototype.Gz = function() {
          return k(Ji(this.Zx), p)
        }
        ;
        F.prototype.set_m_convexToWorld = F.prototype.mC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ki(c, a)
        }
        ;
        Object.defineProperty(F.prototype, "m_convexToWorld", {
          get: F.prototype.Gz,
          set: F.prototype.mC
        });
        F.prototype.get_m_hitNormalWorld = F.prototype.jy = function() {
          return k(Li(this.Zx), p)
        }
        ;
        F.prototype.set_m_hitNormalWorld = F.prototype.qy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Mi(c, a)
        }
        ;
        Object.defineProperty(F.prototype, "m_hitNormalWorld", {
          get: F.prototype.jy,
          set: F.prototype.qy
        });
        F.prototype.get_m_hitPointWorld = F.prototype.ky = function() {
          return k(Ni(this.Zx), p)
        }
        ;
        F.prototype.set_m_hitPointWorld = F.prototype.ry = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Oi(c, a)
        }
        ;
        Object.defineProperty(F.prototype, "m_hitPointWorld", {
          get: F.prototype.ky,
          set: F.prototype.ry
        });
        F.prototype.get_m_collisionFilterGroup = F.prototype.by = function() {
          return Pi(this.Zx)
        }
        ;
        F.prototype.set_m_collisionFilterGroup = F.prototype.dy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Qi(c, a)
        }
        ;
        Object.defineProperty(F.prototype, "m_collisionFilterGroup", {
          get: F.prototype.by,
          set: F.prototype.dy
        });
        F.prototype.get_m_collisionFilterMask = F.prototype.cy = function() {
          return Ri(this.Zx)
        }
        ;
        F.prototype.set_m_collisionFilterMask = F.prototype.ey = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Si(c, a)
        }
        ;
        Object.defineProperty(F.prototype, "m_collisionFilterMask", {
          get: F.prototype.cy,
          set: F.prototype.ey
        });
        F.prototype.get_m_closestHitFraction = F.prototype.fy = function() {
          return Ti(this.Zx)
        }
        ;
        F.prototype.set_m_closestHitFraction = F.prototype.gy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ui(c, a)
        }
        ;
        Object.defineProperty(F.prototype, "m_closestHitFraction", {
          get: F.prototype.fy,
          set: F.prototype.gy
        });
        F.prototype.__destroy__ = function() {
          Vi(this.Zx)
        }
        ;
        function G(a, c) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          this.Zx = Wi(a, c);
          h(G)[this.Zx] = this
        }
        G.prototype = Object.create(z.prototype);
        G.prototype.constructor = G;
        G.prototype.$x = G;
        G.ay = {};
        b.AllHitsRayResultCallback = G;
        G.prototype.hasHit = function() {
          return !!Xi(this.Zx)
        }
        ;
        G.prototype.get_m_collisionObjects = G.prototype.Bz = function() {
          return k(Yi(this.Zx), fB)
        }
        ;
        G.prototype.set_m_collisionObjects = G.prototype.hC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Zi(c, a)
        }
        ;
        Object.defineProperty(G.prototype, "m_collisionObjects", {
          get: G.prototype.Bz,
          set: G.prototype.hC
        });
        G.prototype.get_m_rayFromWorld = G.prototype.xy = function() {
          return k($i(this.Zx), p)
        }
        ;
        G.prototype.set_m_rayFromWorld = G.prototype.Ey = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          aj(c, a)
        }
        ;
        Object.defineProperty(G.prototype, "m_rayFromWorld", {
          get: G.prototype.xy,
          set: G.prototype.Ey
        });
        G.prototype.get_m_rayToWorld = G.prototype.yy = function() {
          return k(bj(this.Zx), p)
        }
        ;
        G.prototype.set_m_rayToWorld = G.prototype.Fy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          cj(c, a)
        }
        ;
        Object.defineProperty(G.prototype, "m_rayToWorld", {
          get: G.prototype.yy,
          set: G.prototype.Fy
        });
        G.prototype.get_m_hitNormalWorld = G.prototype.jy = function() {
          return k(dj(this.Zx), gB)
        }
        ;
        G.prototype.set_m_hitNormalWorld = G.prototype.qy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ej(c, a)
        }
        ;
        Object.defineProperty(G.prototype, "m_hitNormalWorld", {
          get: G.prototype.jy,
          set: G.prototype.qy
        });
        G.prototype.get_m_hitPointWorld = G.prototype.ky = function() {
          return k(fj(this.Zx), gB)
        }
        ;
        G.prototype.set_m_hitPointWorld = G.prototype.ry = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          gj(c, a)
        }
        ;
        Object.defineProperty(G.prototype, "m_hitPointWorld", {
          get: G.prototype.ky,
          set: G.prototype.ry
        });
        G.prototype.get_m_hitFractions = G.prototype.Zz = function() {
          return k(hj(this.Zx), bB)
        }
        ;
        G.prototype.set_m_hitFractions = G.prototype.FC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ij(c, a)
        }
        ;
        Object.defineProperty(G.prototype, "m_hitFractions", {
          get: G.prototype.Zz,
          set: G.prototype.FC
        });
        G.prototype.get_m_collisionFilterGroup = G.prototype.by = function() {
          return jj(this.Zx)
        }
        ;
        G.prototype.set_m_collisionFilterGroup = G.prototype.dy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          kj(c, a)
        }
        ;
        Object.defineProperty(G.prototype, "m_collisionFilterGroup", {
          get: G.prototype.by,
          set: G.prototype.dy
        });
        G.prototype.get_m_collisionFilterMask = G.prototype.cy = function() {
          return lj(this.Zx)
        }
        ;
        G.prototype.set_m_collisionFilterMask = G.prototype.ey = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          mj(c, a)
        }
        ;
        Object.defineProperty(G.prototype, "m_collisionFilterMask", {
          get: G.prototype.cy,
          set: G.prototype.ey
        });
        G.prototype.get_m_closestHitFraction = G.prototype.fy = function() {
          return nj(this.Zx)
        }
        ;
        G.prototype.set_m_closestHitFraction = G.prototype.gy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          oj(c, a)
        }
        ;
        Object.defineProperty(G.prototype, "m_closestHitFraction", {
          get: G.prototype.fy,
          set: G.prototype.gy
        });
        G.prototype.get_m_collisionObject = G.prototype.hy = function() {
          return k(pj(this.Zx), q)
        }
        ;
        G.prototype.set_m_collisionObject = G.prototype.oy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          qj(c, a)
        }
        ;
        Object.defineProperty(G.prototype, "m_collisionObject", {
          get: G.prototype.hy,
          set: G.prototype.oy
        });
        G.prototype.__destroy__ = function() {
          rj(this.Zx)
        }
        ;
        function hB() {
          throw "cannot construct a tMaterialArray, no constructor in IDL";
        }
        hB.prototype = Object.create(g.prototype);
        hB.prototype.constructor = hB;
        hB.prototype.$x = hB;
        hB.ay = {};
        b.tMaterialArray = hB;
        hB.prototype.size = hB.prototype.size = function() {
          return sj(this.Zx)
        }
        ;
        hB.prototype.at = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(tj(c, a), A)
        }
        ;
        hB.prototype.__destroy__ = function() {
          uj(this.Zx)
        }
        ;
        function iB(a) {
          a && "object" === typeof a && (a = a.Zx);
          this.Zx = vj(a);
          h(iB)[this.Zx] = this
        }
        iB.prototype = Object.create(RA.prototype);
        iB.prototype.constructor = iB;
        iB.prototype.$x = iB;
        iB.ay = {};
        b.btDefaultVehicleRaycaster = iB;
        iB.prototype.castRay = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          wj(e, a, c, d)
        }
        ;
        iB.prototype.__destroy__ = function() {
          xj(this.Zx)
        }
        ;
        function jB() {
          this.Zx = yj();
          h(jB)[this.Zx] = this
        }
        jB.prototype = Object.create(LA.prototype);
        jB.prototype.constructor = jB;
        jB.prototype.$x = jB;
        jB.ay = {};
        b.btEmptyShape = jB;
        jB.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          zj(c, a)
        }
        ;
        jB.prototype.getLocalScaling = function() {
          return k(Aj(this.Zx), p)
        }
        ;
        jB.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Bj(d, a, c)
        }
        ;
        jB.prototype.__destroy__ = function() {
          Cj(this.Zx)
        }
        ;
        function H() {
          this.Zx = Dj();
          h(H)[this.Zx] = this
        }
        H.prototype = Object.create(g.prototype);
        H.prototype.constructor = H;
        H.prototype.$x = H;
        H.ay = {};
        b.btConstraintSetting = H;
        H.prototype.get_m_tau = H.prototype.VA = function() {
          return Ej(this.Zx)
        }
        ;
        H.prototype.set_m_tau = H.prototype.BD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Fj(c, a)
        }
        ;
        Object.defineProperty(H.prototype, "m_tau", {
          get: H.prototype.VA,
          set: H.prototype.BD
        });
        H.prototype.get_m_damping = H.prototype.Hz = function() {
          return Gj(this.Zx)
        }
        ;
        H.prototype.set_m_damping = H.prototype.nC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Hj(c, a)
        }
        ;
        Object.defineProperty(H.prototype, "m_damping", {
          get: H.prototype.Hz,
          set: H.prototype.nC
        });
        H.prototype.get_m_impulseClamp = H.prototype.eA = function() {
          return Ij(this.Zx)
        }
        ;
        H.prototype.set_m_impulseClamp = H.prototype.LC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Jj(c, a)
        }
        ;
        Object.defineProperty(H.prototype, "m_impulseClamp", {
          get: H.prototype.eA,
          set: H.prototype.LC
        });
        H.prototype.__destroy__ = function() {
          Kj(this.Zx)
        }
        ;
        function kB() {
          throw "cannot construct a LocalShapeInfo, no constructor in IDL";
        }
        kB.prototype = Object.create(g.prototype);
        kB.prototype.constructor = kB;
        kB.prototype.$x = kB;
        kB.ay = {};
        b.LocalShapeInfo = kB;
        kB.prototype.get_m_shapePart = kB.prototype.JA = function() {
          return Lj(this.Zx)
        }
        ;
        kB.prototype.set_m_shapePart = kB.prototype.pD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Mj(c, a)
        }
        ;
        Object.defineProperty(kB.prototype, "m_shapePart", {
          get: kB.prototype.JA,
          set: kB.prototype.pD
        });
        kB.prototype.get_m_triangleIndex = kB.prototype.YA = function() {
          return Nj(this.Zx)
        }
        ;
        kB.prototype.set_m_triangleIndex = kB.prototype.ED = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Oj(c, a)
        }
        ;
        Object.defineProperty(kB.prototype, "m_triangleIndex", {
          get: kB.prototype.YA,
          set: kB.prototype.ED
        });
        kB.prototype.__destroy__ = function() {
          Pj(this.Zx)
        }
        ;
        function I(a) {
          a && "object" === typeof a && (a = a.Zx);
          this.Zx = Qj(a);
          h(I)[this.Zx] = this
        }
        I.prototype = Object.create(q.prototype);
        I.prototype.constructor = I;
        I.prototype.$x = I;
        I.ay = {};
        b.btRigidBody = I;
        I.prototype.getCenterOfMassTransform = function() {
          return k(Rj(this.Zx), r)
        }
        ;
        I.prototype.setCenterOfMassTransform = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Sj(c, a)
        }
        ;
        I.prototype.setSleepingThresholds = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Tj(d, a, c)
        }
        ;
        I.prototype.getLinearDamping = function() {
          return Uj(this.Zx)
        }
        ;
        I.prototype.getAngularDamping = function() {
          return Vj(this.Zx)
        }
        ;
        I.prototype.setDamping = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Wj(d, a, c)
        }
        ;
        I.prototype.setMassProps = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Xj(d, a, c)
        }
        ;
        I.prototype.getLinearFactor = function() {
          return k(Yj(this.Zx), p)
        }
        ;
        I.prototype.setLinearFactor = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Zj(c, a)
        }
        ;
        I.prototype.applyTorque = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ak(c, a)
        }
        ;
        I.prototype.applyLocalTorque = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          bk(c, a)
        }
        ;
        I.prototype.applyForce = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          ck(d, a, c)
        }
        ;
        I.prototype.applyCentralForce = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          dk(c, a)
        }
        ;
        I.prototype.applyCentralLocalForce = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ek(c, a)
        }
        ;
        I.prototype.applyTorqueImpulse = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          fk(c, a)
        }
        ;
        I.prototype.applyImpulse = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          gk(d, a, c)
        }
        ;
        I.prototype.applyCentralImpulse = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          hk(c, a)
        }
        ;
        I.prototype.updateInertiaTensor = function() {
          ik(this.Zx)
        }
        ;
        I.prototype.getLinearVelocity = function() {
          return k(jk(this.Zx), p)
        }
        ;
        I.prototype.getAngularVelocity = function() {
          return k(kk(this.Zx), p)
        }
        ;
        I.prototype.setLinearVelocity = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          lk(c, a)
        }
        ;
        I.prototype.setAngularVelocity = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          mk(c, a)
        }
        ;
        I.prototype.getMotionState = function() {
          return k(nk(this.Zx), YA)
        }
        ;
        I.prototype.setMotionState = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ok(c, a)
        }
        ;
        I.prototype.getAngularFactor = function() {
          return k(pk(this.Zx), p)
        }
        ;
        I.prototype.setAngularFactor = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          qk(c, a)
        }
        ;
        I.prototype.upcast = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(rk(c, a), I)
        }
        ;
        I.prototype.getAabb = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          sk(d, a, c)
        }
        ;
        I.prototype.applyGravity = function() {
          tk(this.Zx)
        }
        ;
        I.prototype.getGravity = function() {
          return k(uk(this.Zx), p)
        }
        ;
        I.prototype.setGravity = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          vk(c, a)
        }
        ;
        I.prototype.getBroadphaseProxy = function() {
          return k(wk(this.Zx), t)
        }
        ;
        I.prototype.clearForces = function() {
          xk(this.Zx)
        }
        ;
        I.prototype.setAnisotropicFriction = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          yk(d, a, c)
        }
        ;
        I.prototype.getCollisionShape = function() {
          return k(zk(this.Zx), n)
        }
        ;
        I.prototype.setContactProcessingThreshold = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ak(c, a)
        }
        ;
        I.prototype.setActivationState = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Bk(c, a)
        }
        ;
        I.prototype.forceActivationState = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ck(c, a)
        }
        ;
        I.prototype.activate = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          void 0 === a ? Dk(c) : Ek(c, a)
        }
        ;
        I.prototype.isActive = function() {
          return !!Fk(this.Zx)
        }
        ;
        I.prototype.isKinematicObject = function() {
          return !!Gk(this.Zx)
        }
        ;
        I.prototype.isStaticObject = function() {
          return !!Hk(this.Zx)
        }
        ;
        I.prototype.isStaticOrKinematicObject = function() {
          return !!Ik(this.Zx)
        }
        ;
        I.prototype.getRestitution = function() {
          return Jk(this.Zx)
        }
        ;
        I.prototype.getFriction = function() {
          return Kk(this.Zx)
        }
        ;
        I.prototype.getRollingFriction = function() {
          return Lk(this.Zx)
        }
        ;
        I.prototype.setRestitution = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Mk(c, a)
        }
        ;
        I.prototype.setFriction = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Nk(c, a)
        }
        ;
        I.prototype.setRollingFriction = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ok(c, a)
        }
        ;
        I.prototype.getWorldTransform = function() {
          return k(Pk(this.Zx), r)
        }
        ;
        I.prototype.getCollisionFlags = function() {
          return Qk(this.Zx)
        }
        ;
        I.prototype.setCollisionFlags = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Rk(c, a)
        }
        ;
        I.prototype.setWorldTransform = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Sk(c, a)
        }
        ;
        I.prototype.setCollisionShape = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Tk(c, a)
        }
        ;
        I.prototype.setCcdMotionThreshold = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Uk(c, a)
        }
        ;
        I.prototype.setCcdSweptSphereRadius = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Vk(c, a)
        }
        ;
        I.prototype.getUserIndex = function() {
          return Wk(this.Zx)
        }
        ;
        I.prototype.setUserIndex = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Xk(c, a)
        }
        ;
        I.prototype.getUserPointer = function() {
          return k(Yk(this.Zx), JA)
        }
        ;
        I.prototype.setUserPointer = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Zk(c, a)
        }
        ;
        I.prototype.getBroadphaseHandle = function() {
          return k($k(this.Zx), t)
        }
        ;
        I.prototype.__destroy__ = function() {
          al(this.Zx)
        }
        ;
        function lB() {
          throw "cannot construct a btIndexedMeshArray, no constructor in IDL";
        }
        lB.prototype = Object.create(g.prototype);
        lB.prototype.constructor = lB;
        lB.prototype.$x = lB;
        lB.ay = {};
        b.btIndexedMeshArray = lB;
        lB.prototype.size = lB.prototype.size = function() {
          return bl(this.Zx)
        }
        ;
        lB.prototype.at = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(cl(c, a), mB)
        }
        ;
        lB.prototype.__destroy__ = function() {
          dl(this.Zx)
        }
        ;
        function nB() {
          this.Zx = el();
          h(nB)[this.Zx] = this
        }
        nB.prototype = Object.create(g.prototype);
        nB.prototype.constructor = nB;
        nB.prototype.$x = nB;
        nB.ay = {};
        b.btDbvtBroadphase = nB;
        nB.prototype.__destroy__ = function() {
          fl(this.Zx)
        }
        ;
        function oB(a, c, d, e, f, m, C, P, ia) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          m && "object" === typeof m && (m = m.Zx);
          C && "object" === typeof C && (C = C.Zx);
          P && "object" === typeof P && (P = P.Zx);
          ia && "object" === typeof ia && (ia = ia.Zx);
          this.Zx = gl(a, c, d, e, f, m, C, P, ia);
          h(oB)[this.Zx] = this
        }
        oB.prototype = Object.create(LA.prototype);
        oB.prototype.constructor = oB;
        oB.prototype.$x = oB;
        oB.ay = {};
        b.btHeightfieldTerrainShape = oB;
        oB.prototype.setMargin = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          hl(c, a)
        }
        ;
        oB.prototype.getMargin = function() {
          return il(this.Zx)
        }
        ;
        oB.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          jl(c, a)
        }
        ;
        oB.prototype.getLocalScaling = function() {
          return k(kl(this.Zx), p)
        }
        ;
        oB.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          ll(d, a, c)
        }
        ;
        oB.prototype.__destroy__ = function() {
          ml(this.Zx)
        }
        ;
        function pB() {
          this.Zx = nl();
          h(pB)[this.Zx] = this
        }
        pB.prototype = Object.create($A.prototype);
        pB.prototype.constructor = pB;
        pB.prototype.$x = pB;
        pB.ay = {};
        b.btDefaultSoftBodySolver = pB;
        pB.prototype.__destroy__ = function() {
          ol(this.Zx)
        }
        ;
        function qB(a) {
          a && "object" === typeof a && (a = a.Zx);
          this.Zx = pl(a);
          h(qB)[this.Zx] = this
        }
        qB.prototype = Object.create(FA.prototype);
        qB.prototype.constructor = qB;
        qB.prototype.$x = qB;
        qB.ay = {};
        b.btCollisionDispatcher = qB;
        qB.prototype.getNumManifolds = function() {
          return ql(this.Zx)
        }
        ;
        qB.prototype.getManifoldByIndexInternal = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(rl(c, a), VA)
        }
        ;
        qB.prototype.__destroy__ = function() {
          sl(this.Zx)
        }
        ;
        function rB(a, c, d, e, f) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          this.Zx = void 0 === d ? tl(a, c) : void 0 === e ? ul(a, c, d) : void 0 === f ? vl(a, c, d, e) : wl(a, c, d, e, f);
          h(rB)[this.Zx] = this
        }
        rB.prototype = Object.create(g.prototype);
        rB.prototype.constructor = rB;
        rB.prototype.$x = rB;
        rB.ay = {};
        b.btAxisSweep3 = rB;
        rB.prototype.__destroy__ = function() {
          xl(this.Zx)
        }
        ;
        function JA() {
          throw "cannot construct a VoidPtr, no constructor in IDL";
        }
        JA.prototype = Object.create(g.prototype);
        JA.prototype.constructor = JA;
        JA.prototype.$x = JA;
        JA.ay = {};
        b.VoidPtr = JA;
        JA.prototype.__destroy__ = function() {
          yl(this.Zx)
        }
        ;
        function J() {
          this.Zx = zl();
          h(J)[this.Zx] = this
        }
        J.prototype = Object.create(g.prototype);
        J.prototype.constructor = J;
        J.prototype.$x = J;
        J.ay = {};
        b.btSoftBodyWorldInfo = J;
        J.prototype.get_air_density = J.prototype.Ly = function() {
          return Al(this.Zx)
        }
        ;
        J.prototype.set_air_density = J.prototype.sB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Bl(c, a)
        }
        ;
        Object.defineProperty(J.prototype, "air_density", {
          get: J.prototype.Ly,
          set: J.prototype.sB
        });
        J.prototype.get_water_density = J.prototype.pB = function() {
          return Cl(this.Zx)
        }
        ;
        J.prototype.set_water_density = J.prototype.WD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Dl(c, a)
        }
        ;
        Object.defineProperty(J.prototype, "water_density", {
          get: J.prototype.pB,
          set: J.prototype.WD
        });
        J.prototype.get_water_offset = J.prototype.rB = function() {
          return El(this.Zx)
        }
        ;
        J.prototype.set_water_offset = J.prototype.YD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Fl(c, a)
        }
        ;
        Object.defineProperty(J.prototype, "water_offset", {
          get: J.prototype.rB,
          set: J.prototype.YD
        });
        J.prototype.get_m_maxDisplacement = J.prototype.sA = function() {
          return Gl(this.Zx)
        }
        ;
        J.prototype.set_m_maxDisplacement = J.prototype.ZC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Hl(c, a)
        }
        ;
        Object.defineProperty(J.prototype, "m_maxDisplacement", {
          get: J.prototype.sA,
          set: J.prototype.ZC
        });
        J.prototype.get_water_normal = J.prototype.qB = function() {
          return k(Il(this.Zx), p)
        }
        ;
        J.prototype.set_water_normal = J.prototype.XD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Jl(c, a)
        }
        ;
        Object.defineProperty(J.prototype, "water_normal", {
          get: J.prototype.qB,
          set: J.prototype.XD
        });
        J.prototype.get_m_broadphase = J.prototype.sz = function() {
          return k(Kl(this.Zx), HA)
        }
        ;
        J.prototype.set_m_broadphase = J.prototype.$B = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ll(c, a)
        }
        ;
        Object.defineProperty(J.prototype, "m_broadphase", {
          get: J.prototype.sz,
          set: J.prototype.$B
        });
        J.prototype.get_m_dispatcher = J.prototype.Kz = function() {
          return k(Ml(this.Zx), FA)
        }
        ;
        J.prototype.set_m_dispatcher = J.prototype.qC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Nl(c, a)
        }
        ;
        Object.defineProperty(J.prototype, "m_dispatcher", {
          get: J.prototype.Kz,
          set: J.prototype.qC
        });
        J.prototype.get_m_gravity = J.prototype.Uz = function() {
          return k(Ol(this.Zx), p)
        }
        ;
        J.prototype.set_m_gravity = J.prototype.AC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Pl(c, a)
        }
        ;
        Object.defineProperty(J.prototype, "m_gravity", {
          get: J.prototype.Uz,
          set: J.prototype.AC
        });
        J.prototype.__destroy__ = function() {
          Ql(this.Zx)
        }
        ;
        function sB(a, c, d, e) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          this.Zx = void 0 === d ? Rl(a, c) : void 0 === e ? _emscripten_bind_btConeTwistConstraint_btConeTwistConstraint_3(a, c, d) : Sl(a, c, d, e);
          h(sB)[this.Zx] = this
        }
        sB.prototype = Object.create(KA.prototype);
        sB.prototype.constructor = sB;
        sB.prototype.$x = sB;
        sB.ay = {};
        b.btConeTwistConstraint = sB;
        sB.prototype.setLimit = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Tl(d, a, c)
        }
        ;
        sB.prototype.setAngularOnly = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ul(c, a)
        }
        ;
        sB.prototype.setDamping = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Vl(c, a)
        }
        ;
        sB.prototype.enableMotor = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Wl(c, a)
        }
        ;
        sB.prototype.setMaxMotorImpulse = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Xl(c, a)
        }
        ;
        sB.prototype.setMaxMotorImpulseNormalized = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Yl(c, a)
        }
        ;
        sB.prototype.setMotorTarget = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Zl(c, a)
        }
        ;
        sB.prototype.setMotorTargetInConstraintSpace = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          $l(c, a)
        }
        ;
        sB.prototype.enableFeedback = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          am(c, a)
        }
        ;
        sB.prototype.getBreakingImpulseThreshold = function() {
          return bm(this.Zx)
        }
        ;
        sB.prototype.setBreakingImpulseThreshold = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          cm(c, a)
        }
        ;
        sB.prototype.getParam = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          return dm(d, a, c)
        }
        ;
        sB.prototype.setParam = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          em(e, a, c, d)
        }
        ;
        sB.prototype.__destroy__ = function() {
          fm(this.Zx)
        }
        ;
        function tB(a, c, d, e, f, m, C) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          m && "object" === typeof m && (m = m.Zx);
          C && "object" === typeof C && (C = C.Zx);
          this.Zx = void 0 === d ? gm(a, c) : void 0 === e ? hm(a, c, d) : void 0 === f ? im(a, c, d, e) : void 0 === m ? jm(a, c, d, e, f) : void 0 === C ? km(a, c, d, e, f, m) : lm(a, c, d, e, f, m, C);
          h(tB)[this.Zx] = this
        }
        tB.prototype = Object.create(KA.prototype);
        tB.prototype.constructor = tB;
        tB.prototype.$x = tB;
        tB.ay = {};
        b.btHingeConstraint = tB;
        tB.prototype.setLimit = function(a, c, d, e, f) {
          var m = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          void 0 === f ? mm(m, a, c, d, e) : nm(m, a, c, d, e, f)
        }
        ;
        tB.prototype.enableAngularMotor = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          om(e, a, c, d)
        }
        ;
        tB.prototype.setAngularOnly = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          pm(c, a)
        }
        ;
        tB.prototype.enableMotor = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          qm(c, a)
        }
        ;
        tB.prototype.setMaxMotorImpulse = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          rm(c, a)
        }
        ;
        tB.prototype.setMotorTarget = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          sm(d, a, c)
        }
        ;
        tB.prototype.enableFeedback = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          tm(c, a)
        }
        ;
        tB.prototype.getBreakingImpulseThreshold = function() {
          return um(this.Zx)
        }
        ;
        tB.prototype.setBreakingImpulseThreshold = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          wm(c, a)
        }
        ;
        tB.prototype.getParam = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          return xm(d, a, c)
        }
        ;
        tB.prototype.setParam = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          ym(e, a, c, d)
        }
        ;
        tB.prototype.__destroy__ = function() {
          zm(this.Zx)
        }
        ;
        function uB(a, c) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          this.Zx = Am(a, c);
          h(uB)[this.Zx] = this
        }
        uB.prototype = Object.create(PA.prototype);
        uB.prototype.constructor = uB;
        uB.prototype.$x = uB;
        uB.ay = {};
        b.btConeShapeZ = uB;
        uB.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Bm(c, a)
        }
        ;
        uB.prototype.getLocalScaling = function() {
          return k(Cm(this.Zx), p)
        }
        ;
        uB.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Dm(d, a, c)
        }
        ;
        uB.prototype.__destroy__ = function() {
          Em(this.Zx)
        }
        ;
        function vB(a, c) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          this.Zx = Fm(a, c);
          h(vB)[this.Zx] = this
        }
        vB.prototype = Object.create(PA.prototype);
        vB.prototype.constructor = vB;
        vB.prototype.$x = vB;
        vB.ay = {};
        b.btConeShapeX = vB;
        vB.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Gm(c, a)
        }
        ;
        vB.prototype.getLocalScaling = function() {
          return k(Hm(this.Zx), p)
        }
        ;
        vB.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Im(d, a, c)
        }
        ;
        vB.prototype.__destroy__ = function() {
          Jm(this.Zx)
        }
        ;
        function wB(a, c) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          this.Zx = void 0 === a ? Km() : void 0 === c ? Lm(a) : Mm(a, c);
          h(wB)[this.Zx] = this
        }
        wB.prototype = Object.create(XA.prototype);
        wB.prototype.constructor = wB;
        wB.prototype.$x = wB;
        wB.ay = {};
        b.btTriangleMesh = wB;
        wB.prototype.addTriangle = function(a, c, d, e) {
          var f = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          void 0 === e ? Nm(f, a, c, d) : Om(f, a, c, d, e)
        }
        ;
        wB.prototype.findOrAddVertex = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          return Pm(d, a, c)
        }
        ;
        wB.prototype.addIndex = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Qm(c, a)
        }
        ;
        wB.prototype.getIndexedMeshArray = function() {
          return k(Rm(this.Zx), lB)
        }
        ;
        wB.prototype.setScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Sm(c, a)
        }
        ;
        wB.prototype.__destroy__ = function() {
          Tm(this.Zx)
        }
        ;
        function xB(a, c) {
          zA();
          "object" == typeof a && (a = DA(a));
          c && "object" === typeof c && (c = c.Zx);
          this.Zx = void 0 === a ? Um() : void 0 === c ? Vm(a) : Wm(a, c);
          h(xB)[this.Zx] = this
        }
        xB.prototype = Object.create(n.prototype);
        xB.prototype.constructor = xB;
        xB.prototype.$x = xB;
        xB.ay = {};
        b.btConvexHullShape = xB;
        xB.prototype.addPoint = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          void 0 === c ? Xm(d, a) : Ym(d, a, c)
        }
        ;
        xB.prototype.setMargin = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Zm(c, a)
        }
        ;
        xB.prototype.getMargin = function() {
          return $m(this.Zx)
        }
        ;
        xB.prototype.getNumVertices = function() {
          return an(this.Zx)
        }
        ;
        xB.prototype.initializePolyhedralFeatures = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return !!bn(c, a)
        }
        ;
        xB.prototype.recalcLocalAabb = function() {
          cn(this.Zx)
        }
        ;
        xB.prototype.getConvexPolyhedron = function() {
          return k(dn(this.Zx), yB)
        }
        ;
        xB.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          en(c, a)
        }
        ;
        xB.prototype.getLocalScaling = function() {
          return k(fn(this.Zx), p)
        }
        ;
        xB.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          gn(d, a, c)
        }
        ;
        xB.prototype.__destroy__ = function() {
          hn(this.Zx)
        }
        ;
        function K() {
          this.Zx = jn();
          h(K)[this.Zx] = this
        }
        K.prototype = Object.create(g.prototype);
        K.prototype.constructor = K;
        K.prototype.$x = K;
        K.ay = {};
        b.btVehicleTuning = K;
        K.prototype.get_m_suspensionStiffness = K.prototype.ny = function() {
          return kn(this.Zx)
        }
        ;
        K.prototype.set_m_suspensionStiffness = K.prototype.uy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ln(c, a)
        }
        ;
        Object.defineProperty(K.prototype, "m_suspensionStiffness", {
          get: K.prototype.ny,
          set: K.prototype.uy
        });
        K.prototype.get_m_suspensionCompression = K.prototype.PA = function() {
          return mn(this.Zx)
        }
        ;
        K.prototype.set_m_suspensionCompression = K.prototype.vD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          nn(c, a)
        }
        ;
        Object.defineProperty(K.prototype, "m_suspensionCompression", {
          get: K.prototype.PA,
          set: K.prototype.vD
        });
        K.prototype.get_m_suspensionDamping = K.prototype.QA = function() {
          return on(this.Zx)
        }
        ;
        K.prototype.set_m_suspensionDamping = K.prototype.wD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          pn(c, a)
        }
        ;
        Object.defineProperty(K.prototype, "m_suspensionDamping", {
          get: K.prototype.QA,
          set: K.prototype.wD
        });
        K.prototype.get_m_maxSuspensionTravelCm = K.prototype.my = function() {
          return qn(this.Zx)
        }
        ;
        K.prototype.set_m_maxSuspensionTravelCm = K.prototype.ty = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          rn(c, a)
        }
        ;
        Object.defineProperty(K.prototype, "m_maxSuspensionTravelCm", {
          get: K.prototype.my,
          set: K.prototype.ty
        });
        K.prototype.get_m_frictionSlip = K.prototype.iy = function() {
          return sn(this.Zx)
        }
        ;
        K.prototype.set_m_frictionSlip = K.prototype.py = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          tn(c, a)
        }
        ;
        Object.defineProperty(K.prototype, "m_frictionSlip", {
          get: K.prototype.iy,
          set: K.prototype.py
        });
        K.prototype.get_m_maxSuspensionForce = K.prototype.ly = function() {
          return un(this.Zx)
        }
        ;
        K.prototype.set_m_maxSuspensionForce = K.prototype.sy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          vn(c, a)
        }
        ;
        Object.defineProperty(K.prototype, "m_maxSuspensionForce", {
          get: K.prototype.ly,
          set: K.prototype.sy
        });
        function zB() {
          throw "cannot construct a btCollisionObjectWrapper, no constructor in IDL";
        }
        zB.prototype = Object.create(g.prototype);
        zB.prototype.constructor = zB;
        zB.prototype.$x = zB;
        zB.ay = {};
        b.btCollisionObjectWrapper = zB;
        zB.prototype.getWorldTransform = function() {
          return k(wn(this.Zx), r)
        }
        ;
        zB.prototype.getCollisionObject = function() {
          return k(xn(this.Zx), q)
        }
        ;
        zB.prototype.getCollisionShape = function() {
          return k(yn(this.Zx), n)
        }
        ;
        function AB(a) {
          a && "object" === typeof a && (a = a.Zx);
          this.Zx = zn(a);
          h(AB)[this.Zx] = this
        }
        AB.prototype = Object.create(g.prototype);
        AB.prototype.constructor = AB;
        AB.prototype.$x = AB;
        AB.ay = {};
        b.btShapeHull = AB;
        AB.prototype.buildHull = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return !!An(c, a)
        }
        ;
        AB.prototype.numVertices = function() {
          return Bn(this.Zx)
        }
        ;
        AB.prototype.getVertexPointer = function() {
          return k(Cn(this.Zx), p)
        }
        ;
        AB.prototype.__destroy__ = function() {
          Dn(this.Zx)
        }
        ;
        function BB(a, c) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          this.Zx = void 0 === a ? En() : void 0 === c ? Fn(a) : Gn(a, c);
          h(BB)[this.Zx] = this
        }
        BB.prototype = Object.create(YA.prototype);
        BB.prototype.constructor = BB;
        BB.prototype.$x = BB;
        BB.ay = {};
        b.btDefaultMotionState = BB;
        BB.prototype.getWorldTransform = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Hn(c, a)
        }
        ;
        BB.prototype.setWorldTransform = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          In(c, a)
        }
        ;
        BB.prototype.get_m_graphicsWorldTrans = BB.prototype.Tz = function() {
          return k(Jn(this.Zx), r)
        }
        ;
        BB.prototype.set_m_graphicsWorldTrans = BB.prototype.zC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Kn(c, a)
        }
        ;
        Object.defineProperty(BB.prototype, "m_graphicsWorldTrans", {
          get: BB.prototype.Tz,
          set: BB.prototype.zC
        });
        BB.prototype.__destroy__ = function() {
          Ln(this.Zx)
        }
        ;
        function L(a) {
          a && "object" === typeof a && (a = a.Zx);
          this.Zx = Mn(a);
          h(L)[this.Zx] = this
        }
        L.prototype = Object.create(g.prototype);
        L.prototype.constructor = L;
        L.prototype.$x = L;
        L.ay = {};
        b.btWheelInfo = L;
        L.prototype.getSuspensionRestLength = function() {
          return Nn(this.Zx)
        }
        ;
        L.prototype.updateWheel = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          On(d, a, c)
        }
        ;
        L.prototype.get_m_suspensionStiffness = L.prototype.ny = function() {
          return Pn(this.Zx)
        }
        ;
        L.prototype.set_m_suspensionStiffness = L.prototype.uy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Qn(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_suspensionStiffness", {
          get: L.prototype.ny,
          set: L.prototype.uy
        });
        L.prototype.get_m_frictionSlip = L.prototype.iy = function() {
          return Rn(this.Zx)
        }
        ;
        L.prototype.set_m_frictionSlip = L.prototype.py = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Sn(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_frictionSlip", {
          get: L.prototype.iy,
          set: L.prototype.py
        });
        L.prototype.get_m_engineForce = L.prototype.Oz = function() {
          return Tn(this.Zx)
        }
        ;
        L.prototype.set_m_engineForce = L.prototype.uC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Un(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_engineForce", {
          get: L.prototype.Oz,
          set: L.prototype.uC
        });
        L.prototype.get_m_rollInfluence = L.prototype.FA = function() {
          return Vn(this.Zx)
        }
        ;
        L.prototype.set_m_rollInfluence = L.prototype.lD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Wn(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_rollInfluence", {
          get: L.prototype.FA,
          set: L.prototype.lD
        });
        L.prototype.get_m_suspensionRestLength1 = L.prototype.UA = function() {
          return Xn(this.Zx)
        }
        ;
        L.prototype.set_m_suspensionRestLength1 = L.prototype.AD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Yn(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_suspensionRestLength1", {
          get: L.prototype.UA,
          set: L.prototype.AD
        });
        L.prototype.get_m_wheelsRadius = L.prototype.hB = function() {
          return Zn(this.Zx)
        }
        ;
        L.prototype.set_m_wheelsRadius = L.prototype.OD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          $n(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_wheelsRadius", {
          get: L.prototype.hB,
          set: L.prototype.OD
        });
        L.prototype.get_m_wheelsDampingCompression = L.prototype.By = function() {
          return ao(this.Zx)
        }
        ;
        L.prototype.set_m_wheelsDampingCompression = L.prototype.Iy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          bo(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_wheelsDampingCompression", {
          get: L.prototype.By,
          set: L.prototype.Iy
        });
        L.prototype.get_m_wheelsDampingRelaxation = L.prototype.Cy = function() {
          return co(this.Zx)
        }
        ;
        L.prototype.set_m_wheelsDampingRelaxation = L.prototype.Jy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          eo(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_wheelsDampingRelaxation", {
          get: L.prototype.Cy,
          set: L.prototype.Jy
        });
        L.prototype.get_m_steering = L.prototype.NA = function() {
          return fo(this.Zx)
        }
        ;
        L.prototype.set_m_steering = L.prototype.tD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          go(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_steering", {
          get: L.prototype.NA,
          set: L.prototype.tD
        });
        L.prototype.get_m_maxSuspensionForce = L.prototype.ly = function() {
          return ho(this.Zx)
        }
        ;
        L.prototype.set_m_maxSuspensionForce = L.prototype.sy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          io(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_maxSuspensionForce", {
          get: L.prototype.ly,
          set: L.prototype.sy
        });
        L.prototype.get_m_maxSuspensionTravelCm = L.prototype.my = function() {
          return jo(this.Zx)
        }
        ;
        L.prototype.set_m_maxSuspensionTravelCm = L.prototype.ty = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ko(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_maxSuspensionTravelCm", {
          get: L.prototype.my,
          set: L.prototype.ty
        });
        L.prototype.get_m_wheelsSuspensionForce = L.prototype.iB = function() {
          return lo(this.Zx)
        }
        ;
        L.prototype.set_m_wheelsSuspensionForce = L.prototype.PD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          mo(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_wheelsSuspensionForce", {
          get: L.prototype.iB,
          set: L.prototype.PD
        });
        L.prototype.get_m_bIsFrontWheel = L.prototype.wy = function() {
          return !!no(this.Zx)
        }
        ;
        L.prototype.set_m_bIsFrontWheel = L.prototype.Dy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          oo(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_bIsFrontWheel", {
          get: L.prototype.wy,
          set: L.prototype.Dy
        });
        L.prototype.get_m_raycastInfo = L.prototype.DA = function() {
          return k(po(this.Zx), M)
        }
        ;
        L.prototype.set_m_raycastInfo = L.prototype.jD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          qo(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_raycastInfo", {
          get: L.prototype.DA,
          set: L.prototype.jD
        });
        L.prototype.get_m_chassisConnectionPointCS = L.prototype.zz = function() {
          return k(ro(this.Zx), p)
        }
        ;
        L.prototype.set_m_chassisConnectionPointCS = L.prototype.fC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          so(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_chassisConnectionPointCS", {
          get: L.prototype.zz,
          set: L.prototype.fC
        });
        L.prototype.get_m_worldTransform = L.prototype.jB = function() {
          return k(to(this.Zx), r)
        }
        ;
        L.prototype.set_m_worldTransform = L.prototype.QD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          uo(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_worldTransform", {
          get: L.prototype.jB,
          set: L.prototype.QD
        });
        L.prototype.get_m_wheelDirectionCS = L.prototype.Ay = function() {
          return k(vo(this.Zx), p)
        }
        ;
        L.prototype.set_m_wheelDirectionCS = L.prototype.Hy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          wo(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_wheelDirectionCS", {
          get: L.prototype.Ay,
          set: L.prototype.Hy
        });
        L.prototype.get_m_wheelAxleCS = L.prototype.zy = function() {
          return k(xo(this.Zx), p)
        }
        ;
        L.prototype.set_m_wheelAxleCS = L.prototype.Gy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          yo(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_wheelAxleCS", {
          get: L.prototype.zy,
          set: L.prototype.Gy
        });
        L.prototype.get_m_rotation = L.prototype.HA = function() {
          return zo(this.Zx)
        }
        ;
        L.prototype.set_m_rotation = L.prototype.nD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ao(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_rotation", {
          get: L.prototype.HA,
          set: L.prototype.nD
        });
        L.prototype.get_m_deltaRotation = L.prototype.Iz = function() {
          return Bo(this.Zx)
        }
        ;
        L.prototype.set_m_deltaRotation = L.prototype.oC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Co(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_deltaRotation", {
          get: L.prototype.Iz,
          set: L.prototype.oC
        });
        L.prototype.get_m_brake = L.prototype.rz = function() {
          return Do(this.Zx)
        }
        ;
        L.prototype.set_m_brake = L.prototype.ZB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Eo(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_brake", {
          get: L.prototype.rz,
          set: L.prototype.ZB
        });
        L.prototype.get_m_clippedInvContactDotSuspension = L.prototype.Az = function() {
          return Fo(this.Zx)
        }
        ;
        L.prototype.set_m_clippedInvContactDotSuspension = L.prototype.gC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Go(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_clippedInvContactDotSuspension", {
          get: L.prototype.Az,
          set: L.prototype.gC
        });
        L.prototype.get_m_suspensionRelativeVelocity = L.prototype.SA = function() {
          return Ho(this.Zx)
        }
        ;
        L.prototype.set_m_suspensionRelativeVelocity = L.prototype.yD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Io(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_suspensionRelativeVelocity", {
          get: L.prototype.SA,
          set: L.prototype.yD
        });
        L.prototype.get_m_skidInfo = L.prototype.KA = function() {
          return Jo(this.Zx)
        }
        ;
        L.prototype.set_m_skidInfo = L.prototype.qD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ko(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_skidInfo", {
          get: L.prototype.KA,
          set: L.prototype.qD
        });
        L.prototype.__destroy__ = function() {
          Lo(this.Zx)
        }
        ;
        function N(a, c, d, e) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          this.Zx = void 0 === a ? Mo() : void 0 === c ? _emscripten_bind_btVector4_btVector4_1(a) : void 0 === d ? _emscripten_bind_btVector4_btVector4_2(a, c) : void 0 === e ? _emscripten_bind_btVector4_btVector4_3(a, c, d) : No(a, c, d, e);
          h(N)[this.Zx] = this
        }
        N.prototype = Object.create(p.prototype);
        N.prototype.constructor = N;
        N.prototype.$x = N;
        N.ay = {};
        b.btVector4 = N;
        N.prototype.w = function() {
          return Oo(this.Zx)
        }
        ;
        N.prototype.setValue = function(a, c, d, e) {
          var f = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          Po(f, a, c, d, e)
        }
        ;
        N.prototype.length = N.prototype.length = function() {
          return Qo(this.Zx)
        }
        ;
        N.prototype.x = N.prototype.x = function() {
          return Ro(this.Zx)
        }
        ;
        N.prototype.y = N.prototype.y = function() {
          return So(this.Zx)
        }
        ;
        N.prototype.z = N.prototype.z = function() {
          return To(this.Zx)
        }
        ;
        N.prototype.setX = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Uo(c, a)
        }
        ;
        N.prototype.setY = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Vo(c, a)
        }
        ;
        N.prototype.setZ = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Wo(c, a)
        }
        ;
        N.prototype.normalize = N.prototype.normalize = function() {
          Xo(this.Zx)
        }
        ;
        N.prototype.rotate = N.prototype.rotate = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          return k(Yo(d, a, c), p)
        }
        ;
        N.prototype.dot = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return Zo(c, a)
        }
        ;
        N.prototype.op_mul = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k($o(c, a), p)
        }
        ;
        N.prototype.op_add = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(ap(c, a), p)
        }
        ;
        N.prototype.op_sub = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(bp(c, a), p)
        }
        ;
        N.prototype.__destroy__ = function() {
          cp(this.Zx)
        }
        ;
        function CB() {
          this.Zx = dp();
          h(CB)[this.Zx] = this
        }
        CB.prototype = Object.create(g.prototype);
        CB.prototype.constructor = CB;
        CB.prototype.$x = CB;
        CB.ay = {};
        b.btDefaultCollisionConstructionInfo = CB;
        CB.prototype.__destroy__ = function() {
          ep(this.Zx)
        }
        ;
        function O() {
          throw "cannot construct a Anchor, no constructor in IDL";
        }
        O.prototype = Object.create(g.prototype);
        O.prototype.constructor = O;
        O.prototype.$x = O;
        O.ay = {};
        b.Anchor = O;
        O.prototype.get_m_node = O.prototype.uA = function() {
          return k(fp(this.Zx), Node)
        }
        ;
        O.prototype.set_m_node = O.prototype.aD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          gp(c, a)
        }
        ;
        Object.defineProperty(O.prototype, "m_node", {
          get: O.prototype.uA,
          set: O.prototype.aD
        });
        O.prototype.get_m_local = O.prototype.nA = function() {
          return k(hp(this.Zx), p)
        }
        ;
        O.prototype.set_m_local = O.prototype.UC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ip(c, a)
        }
        ;
        Object.defineProperty(O.prototype, "m_local", {
          get: O.prototype.nA,
          set: O.prototype.UC
        });
        O.prototype.get_m_body = O.prototype.qz = function() {
          return k(jp(this.Zx), I)
        }
        ;
        O.prototype.set_m_body = O.prototype.YB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          kp(c, a)
        }
        ;
        Object.defineProperty(O.prototype, "m_body", {
          get: O.prototype.qz,
          set: O.prototype.YB
        });
        O.prototype.get_m_influence = O.prototype.gA = function() {
          return lp(this.Zx)
        }
        ;
        O.prototype.set_m_influence = O.prototype.NC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          mp(c, a)
        }
        ;
        Object.defineProperty(O.prototype, "m_influence", {
          get: O.prototype.gA,
          set: O.prototype.NC
        });
        O.prototype.get_m_c0 = O.prototype.uz = function() {
          return k(np(this.Zx), aB)
        }
        ;
        O.prototype.set_m_c0 = O.prototype.aC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          op(c, a)
        }
        ;
        Object.defineProperty(O.prototype, "m_c0", {
          get: O.prototype.uz,
          set: O.prototype.aC
        });
        O.prototype.get_m_c1 = O.prototype.vz = function() {
          return k(pp(this.Zx), p)
        }
        ;
        O.prototype.set_m_c1 = O.prototype.bC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          qp(c, a)
        }
        ;
        Object.defineProperty(O.prototype, "m_c1", {
          get: O.prototype.vz,
          set: O.prototype.bC
        });
        O.prototype.get_m_c2 = O.prototype.wz = function() {
          return rp(this.Zx)
        }
        ;
        O.prototype.set_m_c2 = O.prototype.cC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          sp(c, a)
        }
        ;
        Object.defineProperty(O.prototype, "m_c2", {
          get: O.prototype.wz,
          set: O.prototype.cC
        });
        O.prototype.__destroy__ = function() {
          tp(this.Zx)
        }
        ;
        function Q() {
          throw "cannot construct a btVehicleRaycasterResult, no constructor in IDL";
        }
        Q.prototype = Object.create(g.prototype);
        Q.prototype.constructor = Q;
        Q.prototype.$x = Q;
        Q.ay = {};
        b.btVehicleRaycasterResult = Q;
        Q.prototype.get_m_hitPointInWorld = Q.prototype.bA = function() {
          return k(up(this.Zx), p)
        }
        ;
        Q.prototype.set_m_hitPointInWorld = Q.prototype.IC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          vp(c, a)
        }
        ;
        Object.defineProperty(Q.prototype, "m_hitPointInWorld", {
          get: Q.prototype.bA,
          set: Q.prototype.IC
        });
        Q.prototype.get_m_hitNormalInWorld = Q.prototype.$z = function() {
          return k(wp(this.Zx), p)
        }
        ;
        Q.prototype.set_m_hitNormalInWorld = Q.prototype.GC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          xp(c, a)
        }
        ;
        Object.defineProperty(Q.prototype, "m_hitNormalInWorld", {
          get: Q.prototype.$z,
          set: Q.prototype.GC
        });
        Q.prototype.get_m_distFraction = Q.prototype.Lz = function() {
          return yp(this.Zx)
        }
        ;
        Q.prototype.set_m_distFraction = Q.prototype.rC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          zp(c, a)
        }
        ;
        Object.defineProperty(Q.prototype, "m_distFraction", {
          get: Q.prototype.Lz,
          set: Q.prototype.rC
        });
        Q.prototype.__destroy__ = function() {
          Ap(this.Zx)
        }
        ;
        function gB() {
          throw "cannot construct a btVector3Array, no constructor in IDL";
        }
        gB.prototype = Object.create(g.prototype);
        gB.prototype.constructor = gB;
        gB.prototype.$x = gB;
        gB.ay = {};
        b.btVector3Array = gB;
        gB.prototype.size = gB.prototype.size = function() {
          return Bp(this.Zx)
        }
        ;
        gB.prototype.at = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(Cp(c, a), p)
        }
        ;
        gB.prototype.__destroy__ = function() {
          Dp(this.Zx)
        }
        ;
        function DB() {
          throw "cannot construct a btConstraintSolver, no constructor in IDL";
        }
        DB.prototype = Object.create(g.prototype);
        DB.prototype.constructor = DB;
        DB.prototype.$x = DB;
        DB.ay = {};
        b.btConstraintSolver = DB;
        DB.prototype.__destroy__ = function() {
          Ep(this.Zx)
        }
        ;
        function R(a, c, d) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          this.Zx = Fp(a, c, d);
          h(R)[this.Zx] = this
        }
        R.prototype = Object.create(QA.prototype);
        R.prototype.constructor = R;
        R.prototype.$x = R;
        R.ay = {};
        b.btRaycastVehicle = R;
        R.prototype.applyEngineForce = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Gp(d, a, c)
        }
        ;
        R.prototype.setSteeringValue = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Hp(d, a, c)
        }
        ;
        R.prototype.getWheelTransformWS = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(Ip(c, a), r)
        }
        ;
        R.prototype.updateWheelTransform = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Jp(d, a, c)
        }
        ;
        R.prototype.addWheel = function(a, c, d, e, f, m, C) {
          var P = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          m && "object" === typeof m && (m = m.Zx);
          C && "object" === typeof C && (C = C.Zx);
          return k(Kp(P, a, c, d, e, f, m, C), L)
        }
        ;
        R.prototype.getNumWheels = function() {
          return Lp(this.Zx)
        }
        ;
        R.prototype.getRigidBody = function() {
          return k(Mp(this.Zx), I)
        }
        ;
        R.prototype.getWheelInfo = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(Np(c, a), L)
        }
        ;
        R.prototype.setBrake = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Op(d, a, c)
        }
        ;
        R.prototype.setCoordinateSystem = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          Pp(e, a, c, d)
        }
        ;
        R.prototype.getCurrentSpeedKmHour = function() {
          return Qp(this.Zx)
        }
        ;
        R.prototype.getChassisWorldTransform = function() {
          return k(Rp(this.Zx), r)
        }
        ;
        R.prototype.rayCast = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return Sp(c, a)
        }
        ;
        R.prototype.updateVehicle = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Tp(c, a)
        }
        ;
        R.prototype.resetSuspension = function() {
          Up(this.Zx)
        }
        ;
        R.prototype.getSteeringValue = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return Vp(c, a)
        }
        ;
        R.prototype.updateWheelTransformsWS = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          void 0 === c ? Wp(d, a) : Xp(d, a, c)
        }
        ;
        R.prototype.setPitchControl = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Yp(c, a)
        }
        ;
        R.prototype.updateSuspension = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Zp(c, a)
        }
        ;
        R.prototype.updateFriction = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          $p(c, a)
        }
        ;
        R.prototype.getRightAxis = function() {
          return aq(this.Zx)
        }
        ;
        R.prototype.getUpAxis = function() {
          return bq(this.Zx)
        }
        ;
        R.prototype.getForwardAxis = function() {
          return cq(this.Zx)
        }
        ;
        R.prototype.getForwardVector = function() {
          return k(dq(this.Zx), p)
        }
        ;
        R.prototype.getUserConstraintType = function() {
          return eq(this.Zx)
        }
        ;
        R.prototype.setUserConstraintType = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          fq(c, a)
        }
        ;
        R.prototype.setUserConstraintId = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          gq(c, a)
        }
        ;
        R.prototype.getUserConstraintId = function() {
          return hq(this.Zx)
        }
        ;
        R.prototype.updateAction = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          iq(d, a, c)
        }
        ;
        R.prototype.__destroy__ = function() {
          jq(this.Zx)
        }
        ;
        function EB(a) {
          a && "object" === typeof a && (a = a.Zx);
          this.Zx = kq(a);
          h(EB)[this.Zx] = this
        }
        EB.prototype = Object.create(TA.prototype);
        EB.prototype.constructor = EB;
        EB.prototype.$x = EB;
        EB.ay = {};
        b.btCylinderShapeX = EB;
        EB.prototype.setMargin = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          lq(c, a)
        }
        ;
        EB.prototype.getMargin = function() {
          return mq(this.Zx)
        }
        ;
        EB.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          nq(c, a)
        }
        ;
        EB.prototype.getLocalScaling = function() {
          return k(oq(this.Zx), p)
        }
        ;
        EB.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          pq(d, a, c)
        }
        ;
        EB.prototype.__destroy__ = function() {
          qq(this.Zx)
        }
        ;
        function FB(a) {
          a && "object" === typeof a && (a = a.Zx);
          this.Zx = rq(a);
          h(FB)[this.Zx] = this
        }
        FB.prototype = Object.create(TA.prototype);
        FB.prototype.constructor = FB;
        FB.prototype.$x = FB;
        FB.ay = {};
        b.btCylinderShapeZ = FB;
        FB.prototype.setMargin = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          sq(c, a)
        }
        ;
        FB.prototype.getMargin = function() {
          return tq(this.Zx)
        }
        ;
        FB.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          uq(c, a)
        }
        ;
        FB.prototype.getLocalScaling = function() {
          return k(vq(this.Zx), p)
        }
        ;
        FB.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          wq(d, a, c)
        }
        ;
        FB.prototype.__destroy__ = function() {
          xq(this.Zx)
        }
        ;
        function yB() {
          throw "cannot construct a btConvexPolyhedron, no constructor in IDL";
        }
        yB.prototype = Object.create(g.prototype);
        yB.prototype.constructor = yB;
        yB.prototype.$x = yB;
        yB.ay = {};
        b.btConvexPolyhedron = yB;
        yB.prototype.get_m_vertices = yB.prototype.dB = function() {
          return k(yq(this.Zx), gB)
        }
        ;
        yB.prototype.set_m_vertices = yB.prototype.KD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          zq(c, a)
        }
        ;
        Object.defineProperty(yB.prototype, "m_vertices", {
          get: yB.prototype.dB,
          set: yB.prototype.KD
        });
        yB.prototype.get_m_faces = yB.prototype.Qz = function() {
          return k(Aq(this.Zx), GB)
        }
        ;
        yB.prototype.set_m_faces = yB.prototype.wC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Bq(c, a)
        }
        ;
        Object.defineProperty(yB.prototype, "m_faces", {
          get: yB.prototype.Qz,
          set: yB.prototype.wC
        });
        yB.prototype.__destroy__ = function() {
          Cq(this.Zx)
        }
        ;
        function HB() {
          this.Zx = Dq();
          h(HB)[this.Zx] = this
        }
        HB.prototype = Object.create(g.prototype);
        HB.prototype.constructor = HB;
        HB.prototype.$x = HB;
        HB.ay = {};
        b.btSequentialImpulseConstraintSolver = HB;
        HB.prototype.__destroy__ = function() {
          Eq(this.Zx)
        }
        ;
        function IB() {
          throw "cannot construct a tAnchorArray, no constructor in IDL";
        }
        IB.prototype = Object.create(g.prototype);
        IB.prototype.constructor = IB;
        IB.prototype.$x = IB;
        IB.ay = {};
        b.tAnchorArray = IB;
        IB.prototype.size = IB.prototype.size = function() {
          return Fq(this.Zx)
        }
        ;
        IB.prototype.at = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(Gq(c, a), O)
        }
        ;
        IB.prototype.clear = IB.prototype.clear = function() {
          Hq(this.Zx)
        }
        ;
        IB.prototype.push_back = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Iq(c, a)
        }
        ;
        IB.prototype.pop_back = function() {
          Jq(this.Zx)
        }
        ;
        IB.prototype.__destroy__ = function() {
          Kq(this.Zx)
        }
        ;
        function M() {
          throw "cannot construct a RaycastInfo, no constructor in IDL";
        }
        M.prototype = Object.create(g.prototype);
        M.prototype.constructor = M;
        M.prototype.$x = M;
        M.ay = {};
        b.RaycastInfo = M;
        M.prototype.get_m_contactNormalWS = M.prototype.Cz = function() {
          return k(Lq(this.Zx), p)
        }
        ;
        M.prototype.set_m_contactNormalWS = M.prototype.iC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Mq(c, a)
        }
        ;
        Object.defineProperty(M.prototype, "m_contactNormalWS", {
          get: M.prototype.Cz,
          set: M.prototype.iC
        });
        M.prototype.get_m_contactPointWS = M.prototype.Dz = function() {
          return k(Nq(this.Zx), p)
        }
        ;
        M.prototype.set_m_contactPointWS = M.prototype.jC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Oq(c, a)
        }
        ;
        Object.defineProperty(M.prototype, "m_contactPointWS", {
          get: M.prototype.Dz,
          set: M.prototype.jC
        });
        M.prototype.get_m_suspensionLength = M.prototype.RA = function() {
          return Pq(this.Zx)
        }
        ;
        M.prototype.set_m_suspensionLength = M.prototype.xD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Qq(c, a)
        }
        ;
        Object.defineProperty(M.prototype, "m_suspensionLength", {
          get: M.prototype.RA,
          set: M.prototype.xD
        });
        M.prototype.get_m_hardPointWS = M.prototype.Wz = function() {
          return k(Rq(this.Zx), p)
        }
        ;
        M.prototype.set_m_hardPointWS = M.prototype.CC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Sq(c, a)
        }
        ;
        Object.defineProperty(M.prototype, "m_hardPointWS", {
          get: M.prototype.Wz,
          set: M.prototype.CC
        });
        M.prototype.get_m_wheelDirectionWS = M.prototype.fB = function() {
          return k(Tq(this.Zx), p)
        }
        ;
        M.prototype.set_m_wheelDirectionWS = M.prototype.MD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Uq(c, a)
        }
        ;
        Object.defineProperty(M.prototype, "m_wheelDirectionWS", {
          get: M.prototype.fB,
          set: M.prototype.MD
        });
        M.prototype.get_m_wheelAxleWS = M.prototype.eB = function() {
          return k(Vq(this.Zx), p)
        }
        ;
        M.prototype.set_m_wheelAxleWS = M.prototype.LD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Wq(c, a)
        }
        ;
        Object.defineProperty(M.prototype, "m_wheelAxleWS", {
          get: M.prototype.eB,
          set: M.prototype.LD
        });
        M.prototype.get_m_isInContact = M.prototype.hA = function() {
          return !!Xq(this.Zx)
        }
        ;
        M.prototype.set_m_isInContact = M.prototype.OC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Yq(c, a)
        }
        ;
        Object.defineProperty(M.prototype, "m_isInContact", {
          get: M.prototype.hA,
          set: M.prototype.OC
        });
        M.prototype.get_m_groundObject = M.prototype.Vz = function() {
          return Zq(this.Zx)
        }
        ;
        M.prototype.set_m_groundObject = M.prototype.BC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          $q(c, a)
        }
        ;
        Object.defineProperty(M.prototype, "m_groundObject", {
          get: M.prototype.Vz,
          set: M.prototype.BC
        });
        M.prototype.__destroy__ = function() {
          ar(this.Zx)
        }
        ;
        function JB(a, c, d) {
          zA();
          a && "object" === typeof a && (a = a.Zx);
          "object" == typeof c && (c = DA(c));
          d && "object" === typeof d && (d = d.Zx);
          this.Zx = br(a, c, d);
          h(JB)[this.Zx] = this
        }
        JB.prototype = Object.create(n.prototype);
        JB.prototype.constructor = JB;
        JB.prototype.$x = JB;
        JB.ay = {};
        b.btMultiSphereShape = JB;
        JB.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          cr(c, a)
        }
        ;
        JB.prototype.getLocalScaling = function() {
          return k(dr(this.Zx), p)
        }
        ;
        JB.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          er(d, a, c)
        }
        ;
        JB.prototype.__destroy__ = function() {
          fr(this.Zx)
        }
        ;
        function S(a, c, d, e) {
          zA();
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          "object" == typeof e && (e = DA(e));
          this.Zx = gr(a, c, d, e);
          h(S)[this.Zx] = this
        }
        S.prototype = Object.create(q.prototype);
        S.prototype.constructor = S;
        S.prototype.$x = S;
        S.ay = {};
        b.btSoftBody = S;
        S.prototype.checkLink = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          return !!hr(d, a, c)
        }
        ;
        S.prototype.checkFace = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          return !!ir(e, a, c, d)
        }
        ;
        S.prototype.appendMaterial = function() {
          return k(jr(this.Zx), A)
        }
        ;
        S.prototype.appendNode = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          kr(d, a, c)
        }
        ;
        S.prototype.appendLink = function(a, c, d, e) {
          var f = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          lr(f, a, c, d, e)
        }
        ;
        S.prototype.appendFace = function(a, c, d, e) {
          var f = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          mr(f, a, c, d, e)
        }
        ;
        S.prototype.appendTetra = function(a, c, d, e, f) {
          var m = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          nr(m, a, c, d, e, f)
        }
        ;
        S.prototype.appendAnchor = function(a, c, d, e) {
          var f = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          or(f, a, c, d, e)
        }
        ;
        S.prototype.addForce = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          void 0 === c ? pr(d, a) : qr(d, a, c)
        }
        ;
        S.prototype.addAeroForceToNode = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          rr(d, a, c)
        }
        ;
        S.prototype.getTotalMass = function() {
          return sr(this.Zx)
        }
        ;
        S.prototype.setTotalMass = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          tr(d, a, c)
        }
        ;
        S.prototype.setMass = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          ur(d, a, c)
        }
        ;
        S.prototype.transform = S.prototype.transform = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          vr(c, a)
        }
        ;
        S.prototype.translate = S.prototype.translate = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          wr(c, a)
        }
        ;
        S.prototype.rotate = S.prototype.rotate = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          xr(c, a)
        }
        ;
        S.prototype.scale = S.prototype.scale = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          yr(c, a)
        }
        ;
        S.prototype.generateClusters = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          return void 0 === c ? zr(d, a) : Ar(d, a, c)
        }
        ;
        S.prototype.generateBendingConstraints = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          return Br(d, a, c)
        }
        ;
        S.prototype.upcast = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(Cr(c, a), S)
        }
        ;
        S.prototype.setAnisotropicFriction = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Dr(d, a, c)
        }
        ;
        S.prototype.getCollisionShape = function() {
          return k(Er(this.Zx), n)
        }
        ;
        S.prototype.setContactProcessingThreshold = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Fr(c, a)
        }
        ;
        S.prototype.setActivationState = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Gr(c, a)
        }
        ;
        S.prototype.forceActivationState = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Hr(c, a)
        }
        ;
        S.prototype.activate = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          void 0 === a ? Ir(c) : Jr(c, a)
        }
        ;
        S.prototype.isActive = function() {
          return !!Kr(this.Zx)
        }
        ;
        S.prototype.isKinematicObject = function() {
          return !!Lr(this.Zx)
        }
        ;
        S.prototype.isStaticObject = function() {
          return !!Mr(this.Zx)
        }
        ;
        S.prototype.isStaticOrKinematicObject = function() {
          return !!Nr(this.Zx)
        }
        ;
        S.prototype.getRestitution = function() {
          return Or(this.Zx)
        }
        ;
        S.prototype.getFriction = function() {
          return Pr(this.Zx)
        }
        ;
        S.prototype.getRollingFriction = function() {
          return Qr(this.Zx)
        }
        ;
        S.prototype.setRestitution = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Rr(c, a)
        }
        ;
        S.prototype.setFriction = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Sr(c, a)
        }
        ;
        S.prototype.setRollingFriction = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Tr(c, a)
        }
        ;
        S.prototype.getWorldTransform = function() {
          return k(Ur(this.Zx), r)
        }
        ;
        S.prototype.getCollisionFlags = function() {
          return Vr(this.Zx)
        }
        ;
        S.prototype.setCollisionFlags = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Wr(c, a)
        }
        ;
        S.prototype.setWorldTransform = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Xr(c, a)
        }
        ;
        S.prototype.setCollisionShape = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Yr(c, a)
        }
        ;
        S.prototype.setCcdMotionThreshold = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Zr(c, a)
        }
        ;
        S.prototype.setCcdSweptSphereRadius = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          $r(c, a)
        }
        ;
        S.prototype.getUserIndex = function() {
          return as(this.Zx)
        }
        ;
        S.prototype.setUserIndex = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          bs(c, a)
        }
        ;
        S.prototype.getUserPointer = function() {
          return k(cs(this.Zx), JA)
        }
        ;
        S.prototype.setUserPointer = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ds(c, a)
        }
        ;
        S.prototype.getBroadphaseHandle = function() {
          return k(es(this.Zx), t)
        }
        ;
        S.prototype.get_m_cfg = S.prototype.xz = function() {
          return k(gs(this.Zx), T)
        }
        ;
        S.prototype.set_m_cfg = S.prototype.dC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          hs(c, a)
        }
        ;
        Object.defineProperty(S.prototype, "m_cfg", {
          get: S.prototype.xz,
          set: S.prototype.dC
        });
        S.prototype.get_m_nodes = S.prototype.vA = function() {
          return k(is(this.Zx), KB)
        }
        ;
        S.prototype.set_m_nodes = S.prototype.bD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          js(c, a)
        }
        ;
        Object.defineProperty(S.prototype, "m_nodes", {
          get: S.prototype.vA,
          set: S.prototype.bD
        });
        S.prototype.get_m_materials = S.prototype.rA = function() {
          return k(ks(this.Zx), hB)
        }
        ;
        S.prototype.set_m_materials = S.prototype.YC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ls(c, a)
        }
        ;
        Object.defineProperty(S.prototype, "m_materials", {
          get: S.prototype.rA,
          set: S.prototype.YC
        });
        S.prototype.get_m_anchors = S.prototype.mz = function() {
          return k(ms(this.Zx), IB)
        }
        ;
        S.prototype.set_m_anchors = S.prototype.UB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ns(c, a)
        }
        ;
        Object.defineProperty(S.prototype, "m_anchors", {
          get: S.prototype.mz,
          set: S.prototype.UB
        });
        S.prototype.__destroy__ = function() {
          ps(this.Zx)
        }
        ;
        function LB() {
          throw "cannot construct a btIntArray, no constructor in IDL";
        }
        LB.prototype = Object.create(g.prototype);
        LB.prototype.constructor = LB;
        LB.prototype.$x = LB;
        LB.ay = {};
        b.btIntArray = LB;
        LB.prototype.size = LB.prototype.size = function() {
          return qs(this.Zx)
        }
        ;
        LB.prototype.at = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return rs(c, a)
        }
        ;
        LB.prototype.__destroy__ = function() {
          ss(this.Zx)
        }
        ;
        function T() {
          throw "cannot construct a Config, no constructor in IDL";
        }
        T.prototype = Object.create(g.prototype);
        T.prototype.constructor = T;
        T.prototype.$x = T;
        T.ay = {};
        b.Config = T;
        T.prototype.get_kVCF = T.prototype.fz = function() {
          return ts(this.Zx)
        }
        ;
        T.prototype.set_kVCF = T.prototype.NB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          us(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "kVCF", {
          get: T.prototype.fz,
          set: T.prototype.NB
        });
        T.prototype.get_kDP = T.prototype.Ty = function() {
          return vs(this.Zx)
        }
        ;
        T.prototype.set_kDP = T.prototype.AB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          xs(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "kDP", {
          get: T.prototype.Ty,
          set: T.prototype.AB
        });
        T.prototype.get_kDG = T.prototype.Sy = function() {
          return ys(this.Zx)
        }
        ;
        T.prototype.set_kDG = T.prototype.zB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          zs(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "kDG", {
          get: T.prototype.Sy,
          set: T.prototype.zB
        });
        T.prototype.get_kLF = T.prototype.Vy = function() {
          return As(this.Zx)
        }
        ;
        T.prototype.set_kLF = T.prototype.CB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Bs(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "kLF", {
          get: T.prototype.Vy,
          set: T.prototype.CB
        });
        T.prototype.get_kPR = T.prototype.Xy = function() {
          return Cs(this.Zx)
        }
        ;
        T.prototype.set_kPR = T.prototype.EB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ds(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "kPR", {
          get: T.prototype.Xy,
          set: T.prototype.EB
        });
        T.prototype.get_kVC = T.prototype.ez = function() {
          return Es(this.Zx)
        }
        ;
        T.prototype.set_kVC = T.prototype.MB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Fs(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "kVC", {
          get: T.prototype.ez,
          set: T.prototype.MB
        });
        T.prototype.get_kDF = T.prototype.Ry = function() {
          return Gs(this.Zx)
        }
        ;
        T.prototype.set_kDF = T.prototype.yB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Hs(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "kDF", {
          get: T.prototype.Ry,
          set: T.prototype.yB
        });
        T.prototype.get_kMT = T.prototype.Wy = function() {
          return Is(this.Zx)
        }
        ;
        T.prototype.set_kMT = T.prototype.DB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Js(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "kMT", {
          get: T.prototype.Wy,
          set: T.prototype.DB
        });
        T.prototype.get_kCHR = T.prototype.Qy = function() {
          return Ks(this.Zx)
        }
        ;
        T.prototype.set_kCHR = T.prototype.xB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ls(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "kCHR", {
          get: T.prototype.Qy,
          set: T.prototype.xB
        });
        T.prototype.get_kKHR = T.prototype.Uy = function() {
          return Ms(this.Zx)
        }
        ;
        T.prototype.set_kKHR = T.prototype.BB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ns(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "kKHR", {
          get: T.prototype.Uy,
          set: T.prototype.BB
        });
        T.prototype.get_kSHR = T.prototype.Yy = function() {
          return Os(this.Zx)
        }
        ;
        T.prototype.set_kSHR = T.prototype.FB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ps(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "kSHR", {
          get: T.prototype.Yy,
          set: T.prototype.FB
        });
        T.prototype.get_kAHR = T.prototype.Py = function() {
          return Qs(this.Zx)
        }
        ;
        T.prototype.set_kAHR = T.prototype.wB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Rs(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "kAHR", {
          get: T.prototype.Py,
          set: T.prototype.wB
        });
        T.prototype.get_kSRHR_CL = T.prototype.az = function() {
          return Ss(this.Zx)
        }
        ;
        T.prototype.set_kSRHR_CL = T.prototype.IB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ts(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "kSRHR_CL", {
          get: T.prototype.az,
          set: T.prototype.IB
        });
        T.prototype.get_kSKHR_CL = T.prototype.Zy = function() {
          return Us(this.Zx)
        }
        ;
        T.prototype.set_kSKHR_CL = T.prototype.GB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Vs(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "kSKHR_CL", {
          get: T.prototype.Zy,
          set: T.prototype.GB
        });
        T.prototype.get_kSSHR_CL = T.prototype.cz = function() {
          return Ws(this.Zx)
        }
        ;
        T.prototype.set_kSSHR_CL = T.prototype.KB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Xs(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "kSSHR_CL", {
          get: T.prototype.cz,
          set: T.prototype.KB
        });
        T.prototype.get_kSR_SPLT_CL = T.prototype.bz = function() {
          return Ys(this.Zx)
        }
        ;
        T.prototype.set_kSR_SPLT_CL = T.prototype.JB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Zs(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "kSR_SPLT_CL", {
          get: T.prototype.bz,
          set: T.prototype.JB
        });
        T.prototype.get_kSK_SPLT_CL = T.prototype.$y = function() {
          return $s(this.Zx)
        }
        ;
        T.prototype.set_kSK_SPLT_CL = T.prototype.HB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          at(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "kSK_SPLT_CL", {
          get: T.prototype.$y,
          set: T.prototype.HB
        });
        T.prototype.get_kSS_SPLT_CL = T.prototype.dz = function() {
          return bt(this.Zx)
        }
        ;
        T.prototype.set_kSS_SPLT_CL = T.prototype.LB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ct(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "kSS_SPLT_CL", {
          get: T.prototype.dz,
          set: T.prototype.LB
        });
        T.prototype.get_maxvolume = T.prototype.lB = function() {
          return dt(this.Zx)
        }
        ;
        T.prototype.set_maxvolume = T.prototype.SD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          et(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "maxvolume", {
          get: T.prototype.lB,
          set: T.prototype.SD
        });
        T.prototype.get_timescale = T.prototype.nB = function() {
          return ft(this.Zx)
        }
        ;
        T.prototype.set_timescale = T.prototype.UD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          gt(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "timescale", {
          get: T.prototype.nB,
          set: T.prototype.UD
        });
        T.prototype.get_viterations = T.prototype.oB = function() {
          return ht(this.Zx)
        }
        ;
        T.prototype.set_viterations = T.prototype.VD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          it(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "viterations", {
          get: T.prototype.oB,
          set: T.prototype.VD
        });
        T.prototype.get_piterations = T.prototype.mB = function() {
          return jt(this.Zx)
        }
        ;
        T.prototype.set_piterations = T.prototype.TD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          kt(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "piterations", {
          get: T.prototype.mB,
          set: T.prototype.TD
        });
        T.prototype.get_diterations = T.prototype.Oy = function() {
          return lt(this.Zx)
        }
        ;
        T.prototype.set_diterations = T.prototype.vB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          mt(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "diterations", {
          get: T.prototype.Oy,
          set: T.prototype.vB
        });
        T.prototype.get_citerations = T.prototype.My = function() {
          return nt(this.Zx)
        }
        ;
        T.prototype.set_citerations = T.prototype.tB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ot(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "citerations", {
          get: T.prototype.My,
          set: T.prototype.tB
        });
        T.prototype.get_collisions = T.prototype.Ny = function() {
          return pt(this.Zx)
        }
        ;
        T.prototype.set_collisions = T.prototype.uB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          qt(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "collisions", {
          get: T.prototype.Ny,
          set: T.prototype.uB
        });
        T.prototype.__destroy__ = function() {
          rt(this.Zx)
        }
        ;
        function Node() {
          throw "cannot construct a Node, no constructor in IDL";
        }
        Node.prototype = Object.create(g.prototype);
        Node.prototype.constructor = Node;
        Node.prototype.$x = Node;
        Node.ay = {};
        b.Node = Node;
        Node.prototype.get_m_x = Node.prototype.kB = function() {
          return k(st(this.Zx), p)
        }
        ;
        Node.prototype.set_m_x = Node.prototype.RD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          tt(c, a)
        }
        ;
        Object.defineProperty(Node.prototype, "m_x", {
          get: Node.prototype.kB,
          set: Node.prototype.RD
        });
        Node.prototype.get_m_q = Node.prototype.CA = function() {
          return k(ut(this.Zx), p)
        }
        ;
        Node.prototype.set_m_q = Node.prototype.iD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          vt(c, a)
        }
        ;
        Object.defineProperty(Node.prototype, "m_q", {
          get: Node.prototype.CA,
          set: Node.prototype.iD
        });
        Node.prototype.get_m_v = Node.prototype.cB = function() {
          return k(wt(this.Zx), p)
        }
        ;
        Node.prototype.set_m_v = Node.prototype.JD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          xt(c, a)
        }
        ;
        Object.defineProperty(Node.prototype, "m_v", {
          get: Node.prototype.cB,
          set: Node.prototype.JD
        });
        Node.prototype.get_m_f = Node.prototype.Pz = function() {
          return k(yt(this.Zx), p)
        }
        ;
        Node.prototype.set_m_f = Node.prototype.vC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          zt(c, a)
        }
        ;
        Object.defineProperty(Node.prototype, "m_f", {
          get: Node.prototype.Pz,
          set: Node.prototype.vC
        });
        Node.prototype.get_m_n = Node.prototype.tA = function() {
          return k(At(this.Zx), p)
        }
        ;
        Node.prototype.set_m_n = Node.prototype.$C = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Bt(c, a)
        }
        ;
        Object.defineProperty(Node.prototype, "m_n", {
          get: Node.prototype.tA,
          set: Node.prototype.$C
        });
        Node.prototype.get_m_im = Node.prototype.dA = function() {
          return Ct(this.Zx)
        }
        ;
        Node.prototype.set_m_im = Node.prototype.KC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Dt(c, a)
        }
        ;
        Object.defineProperty(Node.prototype, "m_im", {
          get: Node.prototype.dA,
          set: Node.prototype.KC
        });
        Node.prototype.get_m_area = Node.prototype.pz = function() {
          return Et(this.Zx)
        }
        ;
        Node.prototype.set_m_area = Node.prototype.XB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ft(c, a)
        }
        ;
        Object.defineProperty(Node.prototype, "m_area", {
          get: Node.prototype.pz,
          set: Node.prototype.XB
        });
        Node.prototype.__destroy__ = function() {
          Gt(this.Zx)
        }
        ;
        function MB() {
          this.Zx = Ht();
          h(MB)[this.Zx] = this
        }
        MB.prototype = Object.create(g.prototype);
        MB.prototype.constructor = MB;
        MB.prototype.$x = MB;
        MB.ay = {};
        b.btGhostPairCallback = MB;
        MB.prototype.__destroy__ = function() {
          It(this.Zx)
        }
        ;
        function NB() {
          throw "cannot construct a btOverlappingPairCallback, no constructor in IDL";
        }
        NB.prototype = Object.create(g.prototype);
        NB.prototype.constructor = NB;
        NB.prototype.$x = NB;
        NB.ay = {};
        b.btOverlappingPairCallback = NB;
        NB.prototype.__destroy__ = function() {
          Jt(this.Zx)
        }
        ;
        function U(a, c, d, e) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          this.Zx = void 0 === e ? Kt(a, c, d) : Lt(a, c, d, e);
          h(U)[this.Zx] = this
        }
        U.prototype = Object.create(QA.prototype);
        U.prototype.constructor = U;
        U.prototype.$x = U;
        U.ay = {};
        b.btKinematicCharacterController = U;
        U.prototype.setUpAxis = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Mt(c, a)
        }
        ;
        U.prototype.setWalkDirection = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Nt(c, a)
        }
        ;
        U.prototype.setVelocityForTimeInterval = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Ot(d, a, c)
        }
        ;
        U.prototype.warp = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Pt(c, a)
        }
        ;
        U.prototype.preStep = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Qt(c, a)
        }
        ;
        U.prototype.playerStep = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Rt(d, a, c)
        }
        ;
        U.prototype.setFallSpeed = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          St(c, a)
        }
        ;
        U.prototype.setJumpSpeed = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Tt(c, a)
        }
        ;
        U.prototype.setMaxJumpHeight = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ut(c, a)
        }
        ;
        U.prototype.canJump = function() {
          return !!Vt(this.Zx)
        }
        ;
        U.prototype.jump = function() {
          Wt(this.Zx)
        }
        ;
        U.prototype.setGravity = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Xt(c, a)
        }
        ;
        U.prototype.getGravity = function() {
          return Yt(this.Zx)
        }
        ;
        U.prototype.setMaxSlope = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Zt(c, a)
        }
        ;
        U.prototype.getMaxSlope = function() {
          return $t(this.Zx)
        }
        ;
        U.prototype.getGhostObject = function() {
          return k(au(this.Zx), V)
        }
        ;
        U.prototype.setUseGhostSweepTest = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          bu(c, a)
        }
        ;
        U.prototype.onGround = function() {
          return !!cu(this.Zx)
        }
        ;
        U.prototype.setUpInterpolate = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          du(c, a)
        }
        ;
        U.prototype.updateAction = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          eu(d, a, c)
        }
        ;
        U.prototype.__destroy__ = function() {
          fu(this.Zx)
        }
        ;
        function OB() {
          throw "cannot construct a btSoftBodyArray, no constructor in IDL";
        }
        OB.prototype = Object.create(g.prototype);
        OB.prototype.constructor = OB;
        OB.prototype.$x = OB;
        OB.ay = {};
        b.btSoftBodyArray = OB;
        OB.prototype.size = OB.prototype.size = function() {
          return gu(this.Zx)
        }
        ;
        OB.prototype.at = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(hu(c, a), S)
        }
        ;
        OB.prototype.__destroy__ = function() {
          iu(this.Zx)
        }
        ;
        function GB() {
          throw "cannot construct a btFaceArray, no constructor in IDL";
        }
        GB.prototype = Object.create(g.prototype);
        GB.prototype.constructor = GB;
        GB.prototype.$x = GB;
        GB.ay = {};
        b.btFaceArray = GB;
        GB.prototype.size = GB.prototype.size = function() {
          return ju(this.Zx)
        }
        ;
        GB.prototype.at = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(ku(c, a), PB)
        }
        ;
        GB.prototype.__destroy__ = function() {
          lu(this.Zx)
        }
        ;
        function QB(a, c) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          this.Zx = mu(a, c);
          h(QB)[this.Zx] = this
        }
        QB.prototype = Object.create(LA.prototype);
        QB.prototype.constructor = QB;
        QB.prototype.$x = QB;
        QB.ay = {};
        b.btStaticPlaneShape = QB;
        QB.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          nu(c, a)
        }
        ;
        QB.prototype.getLocalScaling = function() {
          return k(ou(this.Zx), p)
        }
        ;
        QB.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          pu(d, a, c)
        }
        ;
        QB.prototype.__destroy__ = function() {
          qu(this.Zx)
        }
        ;
        function GA() {
          throw "cannot construct a btOverlappingPairCache, no constructor in IDL";
        }
        GA.prototype = Object.create(g.prototype);
        GA.prototype.constructor = GA;
        GA.prototype.$x = GA;
        GA.ay = {};
        b.btOverlappingPairCache = GA;
        GA.prototype.setInternalGhostPairCallback = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ru(c, a)
        }
        ;
        GA.prototype.getNumOverlappingPairs = function() {
          return su(this.Zx)
        }
        ;
        GA.prototype.__destroy__ = function() {
          tu(this.Zx)
        }
        ;
        function mB() {
          throw "cannot construct a btIndexedMesh, no constructor in IDL";
        }
        mB.prototype = Object.create(g.prototype);
        mB.prototype.constructor = mB;
        mB.prototype.$x = mB;
        mB.ay = {};
        b.btIndexedMesh = mB;
        mB.prototype.get_m_numTriangles = mB.prototype.yA = function() {
          return uu(this.Zx)
        }
        ;
        mB.prototype.set_m_numTriangles = mB.prototype.eD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          vu(c, a)
        }
        ;
        Object.defineProperty(mB.prototype, "m_numTriangles", {
          get: mB.prototype.yA,
          set: mB.prototype.eD
        });
        mB.prototype.__destroy__ = function() {
          wu(this.Zx)
        }
        ;
        function W(a, c, d, e, f) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          this.Zx = xu(a, c, d, e, f);
          h(W)[this.Zx] = this
        }
        W.prototype = Object.create(x.prototype);
        W.prototype.constructor = W;
        W.prototype.$x = W;
        W.ay = {};
        b.btSoftRigidDynamicsWorld = W;
        W.prototype.addSoftBody = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          yu(e, a, c, d)
        }
        ;
        W.prototype.removeSoftBody = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          zu(c, a)
        }
        ;
        W.prototype.removeCollisionObject = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Au(c, a)
        }
        ;
        W.prototype.getWorldInfo = function() {
          return k(Bu(this.Zx), J)
        }
        ;
        W.prototype.getSoftBodyArray = function() {
          return k(Cu(this.Zx), OB)
        }
        ;
        W.prototype.getDispatcher = function() {
          return k(Du(this.Zx), FA)
        }
        ;
        W.prototype.rayTest = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          Eu(e, a, c, d)
        }
        ;
        W.prototype.getPairCache = function() {
          return k(Fu(this.Zx), GA)
        }
        ;
        W.prototype.getDispatchInfo = function() {
          return k(Gu(this.Zx), l)
        }
        ;
        W.prototype.addCollisionObject = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          void 0 === c ? Hu(e, a) : void 0 === d ? Iu(e, a, c) : Ju(e, a, c, d)
        }
        ;
        W.prototype.getBroadphase = function() {
          return k(Ku(this.Zx), HA)
        }
        ;
        W.prototype.convexSweepTest = function(a, c, d, e, f) {
          var m = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          Lu(m, a, c, d, e, f)
        }
        ;
        W.prototype.contactPairTest = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          Mu(e, a, c, d)
        }
        ;
        W.prototype.contactTest = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Nu(d, a, c)
        }
        ;
        W.prototype.updateSingleAabb = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ou(c, a)
        }
        ;
        W.prototype.setDebugDrawer = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Pu(c, a)
        }
        ;
        W.prototype.getDebugDrawer = function() {
          return k(Qu(this.Zx), IA)
        }
        ;
        W.prototype.debugDrawWorld = function() {
          Ru(this.Zx)
        }
        ;
        W.prototype.debugDrawObject = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          Su(e, a, c, d)
        }
        ;
        W.prototype.setGravity = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Tu(c, a)
        }
        ;
        W.prototype.getGravity = function() {
          return k(Uu(this.Zx), p)
        }
        ;
        W.prototype.addRigidBody = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          void 0 === c ? Vu(e, a) : void 0 === d ? _emscripten_bind_btSoftRigidDynamicsWorld_addRigidBody_2(e, a, c) : Wu(e, a, c, d)
        }
        ;
        W.prototype.removeRigidBody = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Xu(c, a)
        }
        ;
        W.prototype.addConstraint = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          void 0 === c ? Yu(d, a) : Zu(d, a, c)
        }
        ;
        W.prototype.removeConstraint = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          $u(c, a)
        }
        ;
        W.prototype.stepSimulation = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          return void 0 === c ? av(e, a) : void 0 === d ? bv(e, a, c) : cv(e, a, c, d)
        }
        ;
        W.prototype.setContactAddedCallback = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          dv(c, a)
        }
        ;
        W.prototype.setContactProcessedCallback = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ev(c, a)
        }
        ;
        W.prototype.setContactDestroyedCallback = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          fv(c, a)
        }
        ;
        W.prototype.addAction = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          gv(c, a)
        }
        ;
        W.prototype.removeAction = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          hv(c, a)
        }
        ;
        W.prototype.getSolverInfo = function() {
          return k(iv(this.Zx), v)
        }
        ;
        W.prototype.setInternalTickCallback = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          void 0 === c ? jv(e, a) : void 0 === d ? kv(e, a, c) : lv(e, a, c, d)
        }
        ;
        W.prototype.__destroy__ = function() {
          mv(this.Zx)
        }
        ;
        function RB(a, c, d, e) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          this.Zx = nv(a, c, d, e);
          h(RB)[this.Zx] = this
        }
        RB.prototype = Object.create(KA.prototype);
        RB.prototype.constructor = RB;
        RB.prototype.$x = RB;
        RB.ay = {};
        b.btFixedConstraint = RB;
        RB.prototype.enableFeedback = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ov(c, a)
        }
        ;
        RB.prototype.getBreakingImpulseThreshold = function() {
          return pv(this.Zx)
        }
        ;
        RB.prototype.setBreakingImpulseThreshold = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          qv(c, a)
        }
        ;
        RB.prototype.getParam = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          return rv(d, a, c)
        }
        ;
        RB.prototype.setParam = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          sv(e, a, c, d)
        }
        ;
        RB.prototype.__destroy__ = function() {
          tv(this.Zx)
        }
        ;
        function r(a, c) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          this.Zx = void 0 === a ? uv() : void 0 === c ? _emscripten_bind_btTransform_btTransform_1(a) : vv(a, c);
          h(r)[this.Zx] = this
        }
        r.prototype = Object.create(g.prototype);
        r.prototype.constructor = r;
        r.prototype.$x = r;
        r.ay = {};
        b.btTransform = r;
        r.prototype.setIdentity = function() {
          wv(this.Zx)
        }
        ;
        r.prototype.setOrigin = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          xv(c, a)
        }
        ;
        r.prototype.setRotation = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          yv(c, a)
        }
        ;
        r.prototype.getOrigin = function() {
          return k(zv(this.Zx), p)
        }
        ;
        r.prototype.getRotation = function() {
          return k(Av(this.Zx), X)
        }
        ;
        r.prototype.getBasis = function() {
          return k(Bv(this.Zx), aB)
        }
        ;
        r.prototype.setFromOpenGLMatrix = function(a) {
          var c = this.Zx;
          zA();
          "object" == typeof a && (a = DA(a));
          Cv(c, a)
        }
        ;
        r.prototype.inverse = r.prototype.inverse = function() {
          return k(Dv(this.Zx), r)
        }
        ;
        r.prototype.op_mul = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(Ev(c, a), r)
        }
        ;
        r.prototype.__destroy__ = function() {
          Fv(this.Zx)
        }
        ;
        function Y(a, c) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          this.Zx = Gv(a, c);
          h(Y)[this.Zx] = this
        }
        Y.prototype = Object.create(z.prototype);
        Y.prototype.constructor = Y;
        Y.prototype.$x = Y;
        Y.ay = {};
        b.ClosestRayResultCallback = Y;
        Y.prototype.hasHit = function() {
          return !!Hv(this.Zx)
        }
        ;
        Y.prototype.get_m_rayFromWorld = Y.prototype.xy = function() {
          return k(Iv(this.Zx), p)
        }
        ;
        Y.prototype.set_m_rayFromWorld = Y.prototype.Ey = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Jv(c, a)
        }
        ;
        Object.defineProperty(Y.prototype, "m_rayFromWorld", {
          get: Y.prototype.xy,
          set: Y.prototype.Ey
        });
        Y.prototype.get_m_rayToWorld = Y.prototype.yy = function() {
          return k(Kv(this.Zx), p)
        }
        ;
        Y.prototype.set_m_rayToWorld = Y.prototype.Fy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Lv(c, a)
        }
        ;
        Object.defineProperty(Y.prototype, "m_rayToWorld", {
          get: Y.prototype.yy,
          set: Y.prototype.Fy
        });
        Y.prototype.get_m_hitNormalWorld = Y.prototype.jy = function() {
          return k(Mv(this.Zx), p)
        }
        ;
        Y.prototype.set_m_hitNormalWorld = Y.prototype.qy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Nv(c, a)
        }
        ;
        Object.defineProperty(Y.prototype, "m_hitNormalWorld", {
          get: Y.prototype.jy,
          set: Y.prototype.qy
        });
        Y.prototype.get_m_hitPointWorld = Y.prototype.ky = function() {
          return k(Ov(this.Zx), p)
        }
        ;
        Y.prototype.set_m_hitPointWorld = Y.prototype.ry = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Pv(c, a)
        }
        ;
        Object.defineProperty(Y.prototype, "m_hitPointWorld", {
          get: Y.prototype.ky,
          set: Y.prototype.ry
        });
        Y.prototype.get_m_collisionFilterGroup = Y.prototype.by = function() {
          return Qv(this.Zx)
        }
        ;
        Y.prototype.set_m_collisionFilterGroup = Y.prototype.dy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Rv(c, a)
        }
        ;
        Object.defineProperty(Y.prototype, "m_collisionFilterGroup", {
          get: Y.prototype.by,
          set: Y.prototype.dy
        });
        Y.prototype.get_m_collisionFilterMask = Y.prototype.cy = function() {
          return Sv(this.Zx)
        }
        ;
        Y.prototype.set_m_collisionFilterMask = Y.prototype.ey = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Tv(c, a)
        }
        ;
        Object.defineProperty(Y.prototype, "m_collisionFilterMask", {
          get: Y.prototype.cy,
          set: Y.prototype.ey
        });
        Y.prototype.get_m_closestHitFraction = Y.prototype.fy = function() {
          return Uv(this.Zx)
        }
        ;
        Y.prototype.set_m_closestHitFraction = Y.prototype.gy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Vv(c, a)
        }
        ;
        Object.defineProperty(Y.prototype, "m_closestHitFraction", {
          get: Y.prototype.fy,
          set: Y.prototype.gy
        });
        Y.prototype.get_m_collisionObject = Y.prototype.hy = function() {
          return k(Wv(this.Zx), q)
        }
        ;
        Y.prototype.set_m_collisionObject = Y.prototype.oy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Xv(c, a)
        }
        ;
        Object.defineProperty(Y.prototype, "m_collisionObject", {
          get: Y.prototype.hy,
          set: Y.prototype.oy
        });
        Y.prototype.__destroy__ = function() {
          Yv(this.Zx)
        }
        ;
        function SB(a) {
          a && "object" === typeof a && (a = a.Zx);
          this.Zx = void 0 === a ? Zv() : $v(a);
          h(SB)[this.Zx] = this
        }
        SB.prototype = Object.create(NA.prototype);
        SB.prototype.constructor = SB;
        SB.prototype.$x = SB;
        SB.ay = {};
        b.btSoftBodyRigidBodyCollisionConfiguration = SB;
        SB.prototype.__destroy__ = function() {
          aw(this.Zx)
        }
        ;
        function TB() {
          this.Zx = bw();
          h(TB)[this.Zx] = this
        }
        TB.prototype = Object.create(ZA.prototype);
        TB.prototype.constructor = TB;
        TB.prototype.$x = TB;
        TB.ay = {};
        b.ConcreteContactResultCallback = TB;
        TB.prototype.addSingleResult = function(a, c, d, e, f, m, C) {
          var P = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          m && "object" === typeof m && (m = m.Zx);
          C && "object" === typeof C && (C = C.Zx);
          return cw(P, a, c, d, e, f, m, C)
        }
        ;
        TB.prototype.__destroy__ = function() {
          dw(this.Zx)
        }
        ;
        function UB(a, c, d) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          this.Zx = void 0 === d ? ew(a, c) : fw(a, c, d);
          h(UB)[this.Zx] = this
        }
        UB.prototype = Object.create(OA.prototype);
        UB.prototype.constructor = UB;
        UB.prototype.$x = UB;
        UB.ay = {};
        b.btBvhTriangleMeshShape = UB;
        UB.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          gw(c, a)
        }
        ;
        UB.prototype.getLocalScaling = function() {
          return k(hw(this.Zx), p)
        }
        ;
        UB.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          iw(d, a, c)
        }
        ;
        UB.prototype.__destroy__ = function() {
          jw(this.Zx)
        }
        ;
        function fB() {
          throw "cannot construct a btConstCollisionObjectArray, no constructor in IDL";
        }
        fB.prototype = Object.create(g.prototype);
        fB.prototype.constructor = fB;
        fB.prototype.$x = fB;
        fB.ay = {};
        b.btConstCollisionObjectArray = fB;
        fB.prototype.size = fB.prototype.size = function() {
          return kw(this.Zx)
        }
        ;
        fB.prototype.at = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(lw(c, a), q)
        }
        ;
        fB.prototype.__destroy__ = function() {
          mw(this.Zx)
        }
        ;
        function VB(a, c, d, e, f) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          this.Zx = void 0 === e ? nw(a, c, d) : void 0 === f ? _emscripten_bind_btSliderConstraint_btSliderConstraint_4(a, c, d, e) : ow(a, c, d, e, f);
          h(VB)[this.Zx] = this
        }
        VB.prototype = Object.create(KA.prototype);
        VB.prototype.constructor = VB;
        VB.prototype.$x = VB;
        VB.ay = {};
        b.btSliderConstraint = VB;
        VB.prototype.setLowerLinLimit = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          pw(c, a)
        }
        ;
        VB.prototype.setUpperLinLimit = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          qw(c, a)
        }
        ;
        VB.prototype.setLowerAngLimit = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          rw(c, a)
        }
        ;
        VB.prototype.setUpperAngLimit = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          sw(c, a)
        }
        ;
        VB.prototype.enableFeedback = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          tw(c, a)
        }
        ;
        VB.prototype.getBreakingImpulseThreshold = function() {
          return uw(this.Zx)
        }
        ;
        VB.prototype.setBreakingImpulseThreshold = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          vw(c, a)
        }
        ;
        VB.prototype.getParam = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          return ww(d, a, c)
        }
        ;
        VB.prototype.setParam = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          xw(e, a, c, d)
        }
        ;
        VB.prototype.__destroy__ = function() {
          yw(this.Zx)
        }
        ;
        function V() {
          this.Zx = zw();
          h(V)[this.Zx] = this
        }
        V.prototype = Object.create(w.prototype);
        V.prototype.constructor = V;
        V.prototype.$x = V;
        V.ay = {};
        b.btPairCachingGhostObject = V;
        V.prototype.setAnisotropicFriction = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Aw(d, a, c)
        }
        ;
        V.prototype.getCollisionShape = function() {
          return k(Bw(this.Zx), n)
        }
        ;
        V.prototype.setContactProcessingThreshold = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Cw(c, a)
        }
        ;
        V.prototype.setActivationState = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Dw(c, a)
        }
        ;
        V.prototype.forceActivationState = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ew(c, a)
        }
        ;
        V.prototype.activate = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          void 0 === a ? Fw(c) : Gw(c, a)
        }
        ;
        V.prototype.isActive = function() {
          return !!Hw(this.Zx)
        }
        ;
        V.prototype.isKinematicObject = function() {
          return !!Iw(this.Zx)
        }
        ;
        V.prototype.isStaticObject = function() {
          return !!Jw(this.Zx)
        }
        ;
        V.prototype.isStaticOrKinematicObject = function() {
          return !!Kw(this.Zx)
        }
        ;
        V.prototype.getRestitution = function() {
          return Lw(this.Zx)
        }
        ;
        V.prototype.getFriction = function() {
          return Mw(this.Zx)
        }
        ;
        V.prototype.getRollingFriction = function() {
          return Nw(this.Zx)
        }
        ;
        V.prototype.setRestitution = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ow(c, a)
        }
        ;
        V.prototype.setFriction = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Pw(c, a)
        }
        ;
        V.prototype.setRollingFriction = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Qw(c, a)
        }
        ;
        V.prototype.getWorldTransform = function() {
          return k(Rw(this.Zx), r)
        }
        ;
        V.prototype.getCollisionFlags = function() {
          return Sw(this.Zx)
        }
        ;
        V.prototype.setCollisionFlags = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Tw(c, a)
        }
        ;
        V.prototype.setWorldTransform = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Uw(c, a)
        }
        ;
        V.prototype.setCollisionShape = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Vw(c, a)
        }
        ;
        V.prototype.setCcdMotionThreshold = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ww(c, a)
        }
        ;
        V.prototype.setCcdSweptSphereRadius = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Xw(c, a)
        }
        ;
        V.prototype.getUserIndex = function() {
          return Yw(this.Zx)
        }
        ;
        V.prototype.setUserIndex = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Zw(c, a)
        }
        ;
        V.prototype.getUserPointer = function() {
          return k($w(this.Zx), JA)
        }
        ;
        V.prototype.setUserPointer = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ax(c, a)
        }
        ;
        V.prototype.getBroadphaseHandle = function() {
          return k(bx(this.Zx), t)
        }
        ;
        V.prototype.getNumOverlappingObjects = function() {
          return cx(this.Zx)
        }
        ;
        V.prototype.getOverlappingObject = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(dx(c, a), q)
        }
        ;
        V.prototype.__destroy__ = function() {
          ex(this.Zx)
        }
        ;
        function E() {
          throw "cannot construct a btManifoldPoint, no constructor in IDL";
        }
        E.prototype = Object.create(g.prototype);
        E.prototype.constructor = E;
        E.prototype.$x = E;
        E.ay = {};
        b.btManifoldPoint = E;
        E.prototype.getPositionWorldOnA = function() {
          return k(fx(this.Zx), p)
        }
        ;
        E.prototype.getPositionWorldOnB = function() {
          return k(gx(this.Zx), p)
        }
        ;
        E.prototype.getAppliedImpulse = function() {
          return hx(this.Zx)
        }
        ;
        E.prototype.getDistance = function() {
          return ix(this.Zx)
        }
        ;
        E.prototype.get_m_localPointA = E.prototype.oA = function() {
          return k(jx(this.Zx), p)
        }
        ;
        E.prototype.set_m_localPointA = E.prototype.VC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          kx(c, a)
        }
        ;
        Object.defineProperty(E.prototype, "m_localPointA", {
          get: E.prototype.oA,
          set: E.prototype.VC
        });
        E.prototype.get_m_localPointB = E.prototype.pA = function() {
          return k(lx(this.Zx), p)
        }
        ;
        E.prototype.set_m_localPointB = E.prototype.WC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          mx(c, a)
        }
        ;
        Object.defineProperty(E.prototype, "m_localPointB", {
          get: E.prototype.pA,
          set: E.prototype.WC
        });
        E.prototype.get_m_positionWorldOnB = E.prototype.BA = function() {
          return k(nx(this.Zx), p)
        }
        ;
        E.prototype.set_m_positionWorldOnB = E.prototype.hD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ox(c, a)
        }
        ;
        Object.defineProperty(E.prototype, "m_positionWorldOnB", {
          get: E.prototype.BA,
          set: E.prototype.hD
        });
        E.prototype.get_m_positionWorldOnA = E.prototype.AA = function() {
          return k(px(this.Zx), p)
        }
        ;
        E.prototype.set_m_positionWorldOnA = E.prototype.gD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          qx(c, a)
        }
        ;
        Object.defineProperty(E.prototype, "m_positionWorldOnA", {
          get: E.prototype.AA,
          set: E.prototype.gD
        });
        E.prototype.get_m_normalWorldOnB = E.prototype.wA = function() {
          return k(rx(this.Zx), p)
        }
        ;
        E.prototype.set_m_normalWorldOnB = E.prototype.cD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          sx(c, a)
        }
        ;
        Object.defineProperty(E.prototype, "m_normalWorldOnB", {
          get: E.prototype.wA,
          set: E.prototype.cD
        });
        E.prototype.get_m_userPersistentData = E.prototype.bB = function() {
          return tx(this.Zx)
        }
        ;
        E.prototype.set_m_userPersistentData = E.prototype.ID = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ux(c, a)
        }
        ;
        Object.defineProperty(E.prototype, "m_userPersistentData", {
          get: E.prototype.bB,
          set: E.prototype.ID
        });
        E.prototype.__destroy__ = function() {
          vx(this.Zx)
        }
        ;
        function WB(a, c, d, e) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          this.Zx = void 0 === d ? wx(a, c) : void 0 === e ? _emscripten_bind_btPoint2PointConstraint_btPoint2PointConstraint_3(a, c, d) : xx(a, c, d, e);
          h(WB)[this.Zx] = this
        }
        WB.prototype = Object.create(KA.prototype);
        WB.prototype.constructor = WB;
        WB.prototype.$x = WB;
        WB.ay = {};
        b.btPoint2PointConstraint = WB;
        WB.prototype.setPivotA = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          yx(c, a)
        }
        ;
        WB.prototype.setPivotB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          zx(c, a)
        }
        ;
        WB.prototype.getPivotInA = function() {
          return k(Ax(this.Zx), p)
        }
        ;
        WB.prototype.getPivotInB = function() {
          return k(Bx(this.Zx), p)
        }
        ;
        WB.prototype.enableFeedback = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Cx(c, a)
        }
        ;
        WB.prototype.getBreakingImpulseThreshold = function() {
          return Dx(this.Zx)
        }
        ;
        WB.prototype.setBreakingImpulseThreshold = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ex(c, a)
        }
        ;
        WB.prototype.getParam = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          return Fx(d, a, c)
        }
        ;
        WB.prototype.setParam = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          Gx(e, a, c, d)
        }
        ;
        WB.prototype.get_m_setting = WB.prototype.IA = function() {
          return k(Hx(this.Zx), H)
        }
        ;
        WB.prototype.set_m_setting = WB.prototype.oD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ix(c, a)
        }
        ;
        Object.defineProperty(WB.prototype, "m_setting", {
          get: WB.prototype.IA,
          set: WB.prototype.oD
        });
        WB.prototype.__destroy__ = function() {
          Jx(this.Zx)
        }
        ;
        function XB() {
          this.Zx = Kx();
          h(XB)[this.Zx] = this
        }
        XB.prototype = Object.create(g.prototype);
        XB.prototype.constructor = XB;
        XB.prototype.$x = XB;
        XB.ay = {};
        b.btSoftBodyHelpers = XB;
        XB.prototype.CreateRope = function(a, c, d, e, f) {
          var m = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          return k(Lx(m, a, c, d, e, f), S)
        }
        ;
        XB.prototype.CreatePatch = function(a, c, d, e, f, m, C, P, ia) {
          var nb = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          m && "object" === typeof m && (m = m.Zx);
          C && "object" === typeof C && (C = C.Zx);
          P && "object" === typeof P && (P = P.Zx);
          ia && "object" === typeof ia && (ia = ia.Zx);
          return k(Mx(nb, a, c, d, e, f, m, C, P, ia), S)
        }
        ;
        XB.prototype.CreatePatchUV = function(a, c, d, e, f, m, C, P, ia, nb) {
          var Wb = this.Zx;
          zA();
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          m && "object" === typeof m && (m = m.Zx);
          C && "object" === typeof C && (C = C.Zx);
          P && "object" === typeof P && (P = P.Zx);
          ia && "object" === typeof ia && (ia = ia.Zx);
          "object" == typeof nb && (nb = DA(nb));
          return k(Nx(Wb, a, c, d, e, f, m, C, P, ia, nb), S)
        }
        ;
        XB.prototype.CreateEllipsoid = function(a, c, d, e) {
          var f = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          return k(Ox(f, a, c, d, e), S)
        }
        ;
        XB.prototype.CreateFromTriMesh = function(a, c, d, e, f) {
          var m = this.Zx;
          zA();
          a && "object" === typeof a && (a = a.Zx);
          "object" == typeof c && (c = DA(c));
          if ("object" == typeof d && "object" === typeof d) {
            var C = AA(d, Ba);
            BA(d, Ba, C);
            d = C
          }
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          return k(Px(m, a, c, d, e, f), S)
        }
        ;
        XB.prototype.CreateFromConvexHull = function(a, c, d, e) {
          var f = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          return k(Qx(f, a, c, d, e), S)
        }
        ;
        XB.prototype.__destroy__ = function() {
          Rx(this.Zx)
        }
        ;
        function t() {
          throw "cannot construct a btBroadphaseProxy, no constructor in IDL";
        }
        t.prototype = Object.create(g.prototype);
        t.prototype.constructor = t;
        t.prototype.$x = t;
        t.ay = {};
        b.btBroadphaseProxy = t;
        t.prototype.get_m_collisionFilterGroup = t.prototype.by = function() {
          return Sx(this.Zx)
        }
        ;
        t.prototype.set_m_collisionFilterGroup = t.prototype.dy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Tx(c, a)
        }
        ;
        Object.defineProperty(t.prototype, "m_collisionFilterGroup", {
          get: t.prototype.by,
          set: t.prototype.dy
        });
        t.prototype.get_m_collisionFilterMask = t.prototype.cy = function() {
          return Ux(this.Zx)
        }
        ;
        t.prototype.set_m_collisionFilterMask = t.prototype.ey = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Vx(c, a)
        }
        ;
        Object.defineProperty(t.prototype, "m_collisionFilterMask", {
          get: t.prototype.cy,
          set: t.prototype.ey
        });
        t.prototype.__destroy__ = function() {
          Wx(this.Zx)
        }
        ;
        function KB() {
          throw "cannot construct a tNodeArray, no constructor in IDL";
        }
        KB.prototype = Object.create(g.prototype);
        KB.prototype.constructor = KB;
        KB.prototype.$x = KB;
        KB.ay = {};
        b.tNodeArray = KB;
        KB.prototype.size = KB.prototype.size = function() {
          return Xx(this.Zx)
        }
        ;
        KB.prototype.at = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(Yx(c, a), Node)
        }
        ;
        KB.prototype.__destroy__ = function() {
          Zx(this.Zx)
        }
        ;
        function YB(a) {
          a && "object" === typeof a && (a = a.Zx);
          this.Zx = $x(a);
          h(YB)[this.Zx] = this
        }
        YB.prototype = Object.create(n.prototype);
        YB.prototype.constructor = YB;
        YB.prototype.$x = YB;
        YB.ay = {};
        b.btBoxShape = YB;
        YB.prototype.setMargin = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ay(c, a)
        }
        ;
        YB.prototype.getMargin = function() {
          return by(this.Zx)
        }
        ;
        YB.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          cy(c, a)
        }
        ;
        YB.prototype.getLocalScaling = function() {
          return k(dy(this.Zx), p)
        }
        ;
        YB.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          ey(d, a, c)
        }
        ;
        YB.prototype.__destroy__ = function() {
          fy(this.Zx)
        }
        ;
        function PB() {
          throw "cannot construct a btFace, no constructor in IDL";
        }
        PB.prototype = Object.create(g.prototype);
        PB.prototype.constructor = PB;
        PB.prototype.$x = PB;
        PB.ay = {};
        b.btFace = PB;
        PB.prototype.get_m_indices = PB.prototype.fA = function() {
          return k(gy(this.Zx), LB)
        }
        ;
        PB.prototype.set_m_indices = PB.prototype.MC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          hy(c, a)
        }
        ;
        Object.defineProperty(PB.prototype, "m_indices", {
          get: PB.prototype.fA,
          set: PB.prototype.MC
        });
        PB.prototype.get_m_plane = PB.prototype.zA = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return iy(c, a)
        }
        ;
        PB.prototype.set_m_plane = PB.prototype.fD = function(a, c) {
          var d = this.Zx;
          zA();
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          jy(d, a, c)
        }
        ;
        Object.defineProperty(PB.prototype, "m_plane", {
          get: PB.prototype.zA,
          set: PB.prototype.fD
        });
        PB.prototype.__destroy__ = function() {
          ky(this.Zx)
        }
        ;
        function ZB() {
          this.Zx = ly();
          h(ZB)[this.Zx] = this
        }
        ZB.prototype = Object.create(IA.prototype);
        ZB.prototype.constructor = ZB;
        ZB.prototype.$x = ZB;
        ZB.ay = {};
        b.DebugDrawer = ZB;
        ZB.prototype.drawLine = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          my(e, a, c, d)
        }
        ;
        ZB.prototype.drawContactPoint = function(a, c, d, e, f) {
          var m = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          ny(m, a, c, d, e, f)
        }
        ;
        ZB.prototype.reportErrorWarning = function(a) {
          var c = this.Zx;
          zA();
          a = a && "object" === typeof a ? a.Zx : CA(a);
          oy(c, a)
        }
        ;
        ZB.prototype.draw3dText = function(a, c) {
          var d = this.Zx;
          zA();
          a && "object" === typeof a && (a = a.Zx);
          c = c && "object" === typeof c ? c.Zx : CA(c);
          py(d, a, c)
        }
        ;
        ZB.prototype.setDebugMode = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          qy(c, a)
        }
        ;
        ZB.prototype.getDebugMode = function() {
          return ry(this.Zx)
        }
        ;
        ZB.prototype.__destroy__ = function() {
          sy(this.Zx)
        }
        ;
        function $B(a, c) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          this.Zx = ty(a, c);
          h($B)[this.Zx] = this
        }
        $B.prototype = Object.create(MA.prototype);
        $B.prototype.constructor = $B;
        $B.prototype.$x = $B;
        $B.ay = {};
        b.btCapsuleShapeX = $B;
        $B.prototype.setMargin = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          uy(c, a)
        }
        ;
        $B.prototype.getMargin = function() {
          return vy(this.Zx)
        }
        ;
        $B.prototype.getUpAxis = function() {
          return wy(this.Zx)
        }
        ;
        $B.prototype.getRadius = function() {
          return xy(this.Zx)
        }
        ;
        $B.prototype.getHalfHeight = function() {
          return yy(this.Zx)
        }
        ;
        $B.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          zy(c, a)
        }
        ;
        $B.prototype.getLocalScaling = function() {
          return k(Ay(this.Zx), p)
        }
        ;
        $B.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          By(d, a, c)
        }
        ;
        $B.prototype.__destroy__ = function() {
          Cy(this.Zx)
        }
        ;
        function X(a, c, d, e) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          this.Zx = Dy(a, c, d, e);
          h(X)[this.Zx] = this
        }
        X.prototype = Object.create(SA.prototype);
        X.prototype.constructor = X;
        X.prototype.$x = X;
        X.ay = {};
        b.btQuaternion = X;
        X.prototype.setValue = function(a, c, d, e) {
          var f = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          Ey(f, a, c, d, e)
        }
        ;
        X.prototype.setEulerZYX = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          Fy(e, a, c, d)
        }
        ;
        X.prototype.setRotation = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Gy(d, a, c)
        }
        ;
        X.prototype.normalize = X.prototype.normalize = function() {
          Hy(this.Zx)
        }
        ;
        X.prototype.length2 = function() {
          return Iy(this.Zx)
        }
        ;
        X.prototype.length = X.prototype.length = function() {
          return Jy(this.Zx)
        }
        ;
        X.prototype.dot = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return Ky(c, a)
        }
        ;
        X.prototype.normalized = function() {
          return k(Ly(this.Zx), X)
        }
        ;
        X.prototype.getAxis = function() {
          return k(My(this.Zx), p)
        }
        ;
        X.prototype.inverse = X.prototype.inverse = function() {
          return k(Ny(this.Zx), X)
        }
        ;
        X.prototype.getAngle = function() {
          return Oy(this.Zx)
        }
        ;
        X.prototype.getAngleShortestPath = function() {
          return Py(this.Zx)
        }
        ;
        X.prototype.angle = X.prototype.angle = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return Qy(c, a)
        }
        ;
        X.prototype.angleShortestPath = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return Ry(c, a)
        }
        ;
        X.prototype.op_add = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(Sy(c, a), X)
        }
        ;
        X.prototype.op_sub = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(Ty(c, a), X)
        }
        ;
        X.prototype.op_mul = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(Uy(c, a), X)
        }
        ;
        X.prototype.op_mulq = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(Vy(c, a), X)
        }
        ;
        X.prototype.op_div = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(Wy(c, a), X)
        }
        ;
        X.prototype.x = X.prototype.x = function() {
          return Xy(this.Zx)
        }
        ;
        X.prototype.y = X.prototype.y = function() {
          return Yy(this.Zx)
        }
        ;
        X.prototype.z = X.prototype.z = function() {
          return Zy(this.Zx)
        }
        ;
        X.prototype.w = function() {
          return $y(this.Zx)
        }
        ;
        X.prototype.setX = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          az(c, a)
        }
        ;
        X.prototype.setY = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          bz(c, a)
        }
        ;
        X.prototype.setZ = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          cz(c, a)
        }
        ;
        X.prototype.setW = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          dz(c, a)
        }
        ;
        X.prototype.__destroy__ = function() {
          ez(this.Zx)
        }
        ;
        function aC(a, c) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          this.Zx = fz(a, c);
          h(aC)[this.Zx] = this
        }
        aC.prototype = Object.create(MA.prototype);
        aC.prototype.constructor = aC;
        aC.prototype.$x = aC;
        aC.ay = {};
        b.btCapsuleShapeZ = aC;
        aC.prototype.setMargin = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          gz(c, a)
        }
        ;
        aC.prototype.getMargin = function() {
          return hz(this.Zx)
        }
        ;
        aC.prototype.getUpAxis = function() {
          return iz(this.Zx)
        }
        ;
        aC.prototype.getRadius = function() {
          return jz(this.Zx)
        }
        ;
        aC.prototype.getHalfHeight = function() {
          return kz(this.Zx)
        }
        ;
        aC.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          lz(c, a)
        }
        ;
        aC.prototype.getLocalScaling = function() {
          return k(mz(this.Zx), p)
        }
        ;
        aC.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          nz(d, a, c)
        }
        ;
        aC.prototype.__destroy__ = function() {
          oz(this.Zx)
        }
        ;
        function v() {
          throw "cannot construct a btContactSolverInfo, no constructor in IDL";
        }
        v.prototype = Object.create(g.prototype);
        v.prototype.constructor = v;
        v.prototype.$x = v;
        v.ay = {};
        b.btContactSolverInfo = v;
        v.prototype.get_m_splitImpulse = v.prototype.LA = function() {
          return !!pz(this.Zx)
        }
        ;
        v.prototype.set_m_splitImpulse = v.prototype.rD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          qz(c, a)
        }
        ;
        Object.defineProperty(v.prototype, "m_splitImpulse", {
          get: v.prototype.LA,
          set: v.prototype.rD
        });
        v.prototype.get_m_splitImpulsePenetrationThreshold = v.prototype.MA = function() {
          return rz(this.Zx)
        }
        ;
        v.prototype.set_m_splitImpulsePenetrationThreshold = v.prototype.sD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          sz(c, a)
        }
        ;
        Object.defineProperty(v.prototype, "m_splitImpulsePenetrationThreshold", {
          get: v.prototype.MA,
          set: v.prototype.sD
        });
        v.prototype.get_m_numIterations = v.prototype.xA = function() {
          return tz(this.Zx)
        }
        ;
        v.prototype.set_m_numIterations = v.prototype.dD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          uz(c, a)
        }
        ;
        Object.defineProperty(v.prototype, "m_numIterations", {
          get: v.prototype.xA,
          set: v.prototype.dD
        });
        v.prototype.__destroy__ = function() {
          vz(this.Zx)
        }
        ;
        function bC(a, c, d, e, f) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          this.Zx = void 0 === e ? wz(a, c, d) : void 0 === f ? _emscripten_bind_btGeneric6DofSpringConstraint_btGeneric6DofSpringConstraint_4(a, c, d, e) : xz(a, c, d, e, f);
          h(bC)[this.Zx] = this
        }
        bC.prototype = Object.create(WA.prototype);
        bC.prototype.constructor = bC;
        bC.prototype.$x = bC;
        bC.ay = {};
        b.btGeneric6DofSpringConstraint = bC;
        bC.prototype.enableSpring = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          yz(d, a, c)
        }
        ;
        bC.prototype.setStiffness = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          zz(d, a, c)
        }
        ;
        bC.prototype.setDamping = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Az(d, a, c)
        }
        ;
        bC.prototype.setEquilibriumPoint = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          void 0 === a ? Bz(d) : void 0 === c ? Cz(d, a) : Dz(d, a, c)
        }
        ;
        bC.prototype.setLinearLowerLimit = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ez(c, a)
        }
        ;
        bC.prototype.setLinearUpperLimit = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Fz(c, a)
        }
        ;
        bC.prototype.setAngularLowerLimit = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Gz(c, a)
        }
        ;
        bC.prototype.setAngularUpperLimit = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Hz(c, a)
        }
        ;
        bC.prototype.getFrameOffsetA = function() {
          return k(Iz(this.Zx), r)
        }
        ;
        bC.prototype.enableFeedback = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Jz(c, a)
        }
        ;
        bC.prototype.getBreakingImpulseThreshold = function() {
          return Kz(this.Zx)
        }
        ;
        bC.prototype.setBreakingImpulseThreshold = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Lz(c, a)
        }
        ;
        bC.prototype.getParam = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          return Mz(d, a, c)
        }
        ;
        bC.prototype.setParam = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          Nz(e, a, c, d)
        }
        ;
        bC.prototype.__destroy__ = function() {
          Oz(this.Zx)
        }
        ;
        function cC(a) {
          a && "object" === typeof a && (a = a.Zx);
          this.Zx = Pz(a);
          h(cC)[this.Zx] = this
        }
        cC.prototype = Object.create(n.prototype);
        cC.prototype.constructor = cC;
        cC.prototype.$x = cC;
        cC.ay = {};
        b.btSphereShape = cC;
        cC.prototype.setMargin = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Qz(c, a)
        }
        ;
        cC.prototype.getMargin = function() {
          return Rz(this.Zx)
        }
        ;
        cC.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Sz(c, a)
        }
        ;
        cC.prototype.getLocalScaling = function() {
          return k(Tz(this.Zx), p)
        }
        ;
        cC.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Uz(d, a, c)
        }
        ;
        cC.prototype.__destroy__ = function() {
          Vz(this.Zx)
        }
        ;
        function Z(a, c, d, e, f) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          this.Zx = Wz(a, c, d, e, f);
          h(Z)[this.Zx] = this
        }
        Z.prototype = Object.create(g.prototype);
        Z.prototype.constructor = Z;
        Z.prototype.$x = Z;
        Z.ay = {};
        b.LocalConvexResult = Z;
        Z.prototype.get_m_hitCollisionObject = Z.prototype.Xz = function() {
          return k(Xz(this.Zx), q)
        }
        ;
        Z.prototype.set_m_hitCollisionObject = Z.prototype.DC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Yz(c, a)
        }
        ;
        Object.defineProperty(Z.prototype, "m_hitCollisionObject", {
          get: Z.prototype.Xz,
          set: Z.prototype.DC
        });
        Z.prototype.get_m_localShapeInfo = Z.prototype.qA = function() {
          return k(Zz(this.Zx), kB)
        }
        ;
        Z.prototype.set_m_localShapeInfo = Z.prototype.XC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          $z(c, a)
        }
        ;
        Object.defineProperty(Z.prototype, "m_localShapeInfo", {
          get: Z.prototype.qA,
          set: Z.prototype.XC
        });
        Z.prototype.get_m_hitNormalLocal = Z.prototype.aA = function() {
          return k(aA(this.Zx), p)
        }
        ;
        Z.prototype.set_m_hitNormalLocal = Z.prototype.HC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          bA(c, a)
        }
        ;
        Object.defineProperty(Z.prototype, "m_hitNormalLocal", {
          get: Z.prototype.aA,
          set: Z.prototype.HC
        });
        Z.prototype.get_m_hitPointLocal = Z.prototype.cA = function() {
          return k(cA(this.Zx), p)
        }
        ;
        Z.prototype.set_m_hitPointLocal = Z.prototype.JC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          dA(c, a)
        }
        ;
        Object.defineProperty(Z.prototype, "m_hitPointLocal", {
          get: Z.prototype.cA,
          set: Z.prototype.JC
        });
        Z.prototype.get_m_hitFraction = Z.prototype.Yz = function() {
          return eA(this.Zx)
        }
        ;
        Z.prototype.set_m_hitFraction = Z.prototype.EC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          fA(c, a)
        }
        ;
        Object.defineProperty(Z.prototype, "m_hitFraction", {
          get: Z.prototype.Yz,
          set: Z.prototype.EC
        });
        Z.prototype.__destroy__ = function() {
          gA(this.Zx)
        }
        ;
        (function() {
            function a() {
              b.BT_CONSTRAINT_ERP = hA();
              b.BT_CONSTRAINT_STOP_ERP = iA();
              b.BT_CONSTRAINT_CFM = jA();
              b.BT_CONSTRAINT_STOP_CFM = kA();
              b.PHY_FLOAT = lA();
              b.PHY_DOUBLE = mA();
              b.PHY_INTEGER = nA();
              b.PHY_SHORT = oA();
              b.PHY_FIXEDPOINT88 = pA();
              b.PHY_UCHAR = qA()
            }
            La ? a() : Ja.unshift(a)
          }
        )();
        this.Ammo = b;

        return Ammo
      }
    );
  }
)();
if (typeof exports === 'object' && typeof module === 'object')
  module.exports = Ammo;
else if (typeof define === 'function' && define['amd'])
  define([], function() {
    return Ammo;
  });
else if (typeof exports === 'object')
  exports["Ammo"] = Ammo;
"; +var ammo_wasm_default2 = "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"; +var draco_wasm_default = "var $jscomp=$jscomp||{};$jscomp.scope={};$jscomp.arrayIteratorImpl=function(k){var n=0;return function(){return n<k.length?{done:!1,value:k[n++]}:{done:!0}}};$jscomp.arrayIterator=function(k){return{next:$jscomp.arrayIteratorImpl(k)}};$jscomp.makeIterator=function(k){var n="undefined"!=typeof Symbol&&Symbol.iterator&&k[Symbol.iterator];return n?n.call(k):$jscomp.arrayIterator(k)};$jscomp.ASSUME_ES5=!1;$jscomp.ASSUME_NO_NATIVE_MAP=!1;$jscomp.ASSUME_NO_NATIVE_SET=!1;$jscomp.SIMPLE_FROUND_POLYFILL=!1;
$jscomp.ISOLATE_POLYFILLS=!1;$jscomp.FORCE_POLYFILL_PROMISE=!1;$jscomp.FORCE_POLYFILL_PROMISE_WHEN_NO_UNHANDLED_REJECTION=!1;$jscomp.getGlobal=function(k){k=["object"==typeof globalThis&&globalThis,k,"object"==typeof window&&window,"object"==typeof self&&self,"object"==typeof global&&global];for(var n=0;n<k.length;++n){var l=k[n];if(l&&l.Math==Math)return l}throw Error("Cannot find global object");};$jscomp.global=$jscomp.getGlobal(this);
$jscomp.defineProperty=$jscomp.ASSUME_ES5||"function"==typeof Object.defineProperties?Object.defineProperty:function(k,n,l){if(k==Array.prototype||k==Object.prototype)return k;k[n]=l.value;return k};$jscomp.IS_SYMBOL_NATIVE="function"===typeof Symbol&&"symbol"===typeof Symbol("x");$jscomp.TRUST_ES6_POLYFILLS=!$jscomp.ISOLATE_POLYFILLS||$jscomp.IS_SYMBOL_NATIVE;$jscomp.polyfills={};$jscomp.propertyToPolyfillSymbol={};$jscomp.POLYFILL_PREFIX="$jscp$";
var $jscomp$lookupPolyfilledValue=function(k,n){var l=$jscomp.propertyToPolyfillSymbol[n];if(null==l)return k[n];l=k[l];return void 0!==l?l:k[n]};$jscomp.polyfill=function(k,n,l,p){n&&($jscomp.ISOLATE_POLYFILLS?$jscomp.polyfillIsolated(k,n,l,p):$jscomp.polyfillUnisolated(k,n,l,p))};
$jscomp.polyfillUnisolated=function(k,n,l,p){l=$jscomp.global;k=k.split(".");for(p=0;p<k.length-1;p++){var h=k[p];if(!(h in l))return;l=l[h]}k=k[k.length-1];p=l[k];n=n(p);n!=p&&null!=n&&$jscomp.defineProperty(l,k,{configurable:!0,writable:!0,value:n})};
$jscomp.polyfillIsolated=function(k,n,l,p){var h=k.split(".");k=1===h.length;p=h[0];p=!k&&p in $jscomp.polyfills?$jscomp.polyfills:$jscomp.global;for(var A=0;A<h.length-1;A++){var f=h[A];if(!(f in p))return;p=p[f]}h=h[h.length-1];l=$jscomp.IS_SYMBOL_NATIVE&&"es6"===l?p[h]:null;n=n(l);null!=n&&(k?$jscomp.defineProperty($jscomp.polyfills,h,{configurable:!0,writable:!0,value:n}):n!==l&&(void 0===$jscomp.propertyToPolyfillSymbol[h]&&(l=1E9*Math.random()>>>0,$jscomp.propertyToPolyfillSymbol[h]=$jscomp.IS_SYMBOL_NATIVE?
$jscomp.global.Symbol(h):$jscomp.POLYFILL_PREFIX+l+"$"+h),$jscomp.defineProperty(p,$jscomp.propertyToPolyfillSymbol[h],{configurable:!0,writable:!0,value:n})))};
$jscomp.polyfill("Promise",function(k){function n(){this.batch_=null}function l(f){return f instanceof h?f:new h(function(q,v){q(f)})}if(k&&(!($jscomp.FORCE_POLYFILL_PROMISE||$jscomp.FORCE_POLYFILL_PROMISE_WHEN_NO_UNHANDLED_REJECTION&&"undefined"===typeof $jscomp.global.PromiseRejectionEvent)||!$jscomp.global.Promise||-1===$jscomp.global.Promise.toString().indexOf("[native code]")))return k;n.prototype.asyncExecute=function(f){if(null==this.batch_){this.batch_=[];var q=this;this.asyncExecuteFunction(function(){q.executeBatch_()})}this.batch_.push(f)};
var p=$jscomp.global.setTimeout;n.prototype.asyncExecuteFunction=function(f){p(f,0)};n.prototype.executeBatch_=function(){for(;this.batch_&&this.batch_.length;){var f=this.batch_;this.batch_=[];for(var q=0;q<f.length;++q){var v=f[q];f[q]=null;try{v()}catch(z){this.asyncThrow_(z)}}}this.batch_=null};n.prototype.asyncThrow_=function(f){this.asyncExecuteFunction(function(){throw f;})};var h=function(f){this.state_=0;this.result_=void 0;this.onSettledCallbacks_=[];this.isRejectionHandled_=!1;var q=this.createResolveAndReject_();
try{f(q.resolve,q.reject)}catch(v){q.reject(v)}};h.prototype.createResolveAndReject_=function(){function f(z){return function(O){v||(v=!0,z.call(q,O))}}var q=this,v=!1;return{resolve:f(this.resolveTo_),reject:f(this.reject_)}};h.prototype.resolveTo_=function(f){if(f===this)this.reject_(new TypeError("A Promise cannot resolve to itself"));else if(f instanceof h)this.settleSameAsPromise_(f);else{a:switch(typeof f){case "object":var q=null!=f;break a;case "function":q=!0;break a;default:q=!1}q?this.resolveToNonPromiseObj_(f):
this.fulfill_(f)}};h.prototype.resolveToNonPromiseObj_=function(f){var q=void 0;try{q=f.then}catch(v){this.reject_(v);return}"function"==typeof q?this.settleSameAsThenable_(q,f):this.fulfill_(f)};h.prototype.reject_=function(f){this.settle_(2,f)};h.prototype.fulfill_=function(f){this.settle_(1,f)};h.prototype.settle_=function(f,q){if(0!=this.state_)throw Error("Cannot settle("+f+", "+q+"): Promise already settled in state"+this.state_);this.state_=f;this.result_=q;2===this.state_&&this.scheduleUnhandledRejectionCheck_();
this.executeOnSettledCallbacks_()};h.prototype.scheduleUnhandledRejectionCheck_=function(){var f=this;p(function(){if(f.notifyUnhandledRejection_()){var q=$jscomp.global.console;"undefined"!==typeof q&&q.error(f.result_)}},1)};h.prototype.notifyUnhandledRejection_=function(){if(this.isRejectionHandled_)return!1;var f=$jscomp.global.CustomEvent,q=$jscomp.global.Event,v=$jscomp.global.dispatchEvent;if("undefined"===typeof v)return!0;"function"===typeof f?f=new f("unhandledrejection",{cancelable:!0}):
"function"===typeof q?f=new q("unhandledrejection",{cancelable:!0}):(f=$jscomp.global.document.createEvent("CustomEvent"),f.initCustomEvent("unhandledrejection",!1,!0,f));f.promise=this;f.reason=this.result_;return v(f)};h.prototype.executeOnSettledCallbacks_=function(){if(null!=this.onSettledCallbacks_){for(var f=0;f<this.onSettledCallbacks_.length;++f)A.asyncExecute(this.onSettledCallbacks_[f]);this.onSettledCallbacks_=null}};var A=new n;h.prototype.settleSameAsPromise_=function(f){var q=this.createResolveAndReject_();
f.callWhenSettled_(q.resolve,q.reject)};h.prototype.settleSameAsThenable_=function(f,q){var v=this.createResolveAndReject_();try{f.call(q,v.resolve,v.reject)}catch(z){v.reject(z)}};h.prototype.then=function(f,q){function v(t,x){return"function"==typeof t?function(D){try{z(t(D))}catch(R){O(R)}}:x}var z,O,ba=new h(function(t,x){z=t;O=x});this.callWhenSettled_(v(f,z),v(q,O));return ba};h.prototype.catch=function(f){return this.then(void 0,f)};h.prototype.callWhenSettled_=function(f,q){function v(){switch(z.state_){case 1:f(z.result_);
break;case 2:q(z.result_);break;default:throw Error("Unexpected state: "+z.state_);}}var z=this;null==this.onSettledCallbacks_?A.asyncExecute(v):this.onSettledCallbacks_.push(v);this.isRejectionHandled_=!0};h.resolve=l;h.reject=function(f){return new h(function(q,v){v(f)})};h.race=function(f){return new h(function(q,v){for(var z=$jscomp.makeIterator(f),O=z.next();!O.done;O=z.next())l(O.value).callWhenSettled_(q,v)})};h.all=function(f){var q=$jscomp.makeIterator(f),v=q.next();return v.done?l([]):new h(function(z,
O){function ba(D){return function(R){t[D]=R;x--;0==x&&z(t)}}var t=[],x=0;do t.push(void 0),x++,l(v.value).callWhenSettled_(ba(t.length-1),O),v=q.next();while(!v.done)})};return h},"es6","es3");$jscomp.owns=function(k,n){return Object.prototype.hasOwnProperty.call(k,n)};$jscomp.assign=$jscomp.TRUST_ES6_POLYFILLS&&"function"==typeof Object.assign?Object.assign:function(k,n){for(var l=1;l<arguments.length;l++){var p=arguments[l];if(p)for(var h in p)$jscomp.owns(p,h)&&(k[h]=p[h])}return k};
$jscomp.polyfill("Object.assign",function(k){return k||$jscomp.assign},"es6","es3");$jscomp.checkStringArgs=function(k,n,l){if(null==k)throw new TypeError("The 'this' value for String.prototype."+l+" must not be null or undefined");if(n instanceof RegExp)throw new TypeError("First argument to String.prototype."+l+" must not be a regular expression");return k+""};
$jscomp.polyfill("String.prototype.startsWith",function(k){return k?k:function(n,l){var p=$jscomp.checkStringArgs(this,n,"startsWith");n+="";var h=p.length,A=n.length;l=Math.max(0,Math.min(l|0,p.length));for(var f=0;f<A&&l<h;)if(p[l++]!=n[f++])return!1;return f>=A}},"es6","es3");
$jscomp.polyfill("Array.prototype.copyWithin",function(k){function n(l){l=Number(l);return Infinity===l||-Infinity===l?l:l|0}return k?k:function(l,p,h){var A=this.length;l=n(l);p=n(p);h=void 0===h?A:n(h);l=0>l?Math.max(A+l,0):Math.min(l,A);p=0>p?Math.max(A+p,0):Math.min(p,A);h=0>h?Math.max(A+h,0):Math.min(h,A);if(l<p)for(;p<h;)p in this?this[l++]=this[p++]:(delete this[l++],p++);else for(h=Math.min(h,A+p-l),l+=h-p;h>p;)--h in this?this[--l]=this[h]:delete this[--l];return this}},"es6","es3");
$jscomp.typedArrayCopyWithin=function(k){return k?k:Array.prototype.copyWithin};$jscomp.polyfill("Int8Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");$jscomp.polyfill("Uint8Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");$jscomp.polyfill("Uint8ClampedArray.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");$jscomp.polyfill("Int16Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");
$jscomp.polyfill("Uint16Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");$jscomp.polyfill("Int32Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");$jscomp.polyfill("Uint32Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");$jscomp.polyfill("Float32Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");$jscomp.polyfill("Float64Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");
var DracoDecoderModule=function(){var k="undefined"!==typeof document&&document.currentScript?document.currentScript.src:void 0;"undefined"!==typeof __filename&&(k=k||__filename);return function(n){function l(e){return a.locateFile?a.locateFile(e,U):U+e}function p(e,b,c){var d=b+c;for(c=b;e[c]&&!(c>=d);)++c;if(16<c-b&&e.buffer&&va)return va.decode(e.subarray(b,c));for(d="";b<c;){var g=e[b++];if(g&128){var u=e[b++]&63;if(192==(g&224))d+=String.fromCharCode((g&31)<<6|u);else{var X=e[b++]&63;g=224==
(g&240)?(g&15)<<12|u<<6|X:(g&7)<<18|u<<12|X<<6|e[b++]&63;65536>g?d+=String.fromCharCode(g):(g-=65536,d+=String.fromCharCode(55296|g>>10,56320|g&1023))}}else d+=String.fromCharCode(g)}return d}function h(e,b){return e?p(ea,e,b):""}function A(){var e=ja.buffer;a.HEAP8=Y=new Int8Array(e);a.HEAP16=new Int16Array(e);a.HEAP32=ca=new Int32Array(e);a.HEAPU8=ea=new Uint8Array(e);a.HEAPU16=new Uint16Array(e);a.HEAPU32=V=new Uint32Array(e);a.HEAPF32=new Float32Array(e);a.HEAPF64=new Float64Array(e)}function f(e){if(a.onAbort)a.onAbort(e);
e="Aborted("+e+")";da(e);wa=!0;e=new WebAssembly.RuntimeError(e+". Build with -sASSERTIONS for more info.");ka(e);throw e;}function q(e){try{if(e==P&&fa)return new Uint8Array(fa);if(ma)return ma(e);throw"both async and sync fetching of the wasm failed";}catch(b){f(b)}}function v(){if(!fa&&(xa||ha)){if("function"==typeof fetch&&!P.startsWith("file://"))return fetch(P,{credentials:"same-origin"}).then(function(e){if(!e.ok)throw"failed to load wasm binary file at '"+P+"'";return e.arrayBuffer()}).catch(function(){return q(P)});
if(na)return new Promise(function(e,b){na(P,function(c){e(new Uint8Array(c))},b)})}return Promise.resolve().then(function(){return q(P)})}function z(e){for(;0<e.length;)e.shift()(a)}function O(e){this.excPtr=e;this.ptr=e-24;this.set_type=function(b){V[this.ptr+4>>2]=b};this.get_type=function(){return V[this.ptr+4>>2]};this.set_destructor=function(b){V[this.ptr+8>>2]=b};this.get_destructor=function(){return V[this.ptr+8>>2]};this.set_refcount=function(b){ca[this.ptr>>2]=b};this.set_caught=function(b){Y[this.ptr+
12>>0]=b?1:0};this.get_caught=function(){return 0!=Y[this.ptr+12>>0]};this.set_rethrown=function(b){Y[this.ptr+13>>0]=b?1:0};this.get_rethrown=function(){return 0!=Y[this.ptr+13>>0]};this.init=function(b,c){this.set_adjusted_ptr(0);this.set_type(b);this.set_destructor(c);this.set_refcount(0);this.set_caught(!1);this.set_rethrown(!1)};this.add_ref=function(){ca[this.ptr>>2]+=1};this.release_ref=function(){var b=ca[this.ptr>>2];ca[this.ptr>>2]=b-1;return 1===b};this.set_adjusted_ptr=function(b){V[this.ptr+
16>>2]=b};this.get_adjusted_ptr=function(){return V[this.ptr+16>>2]};this.get_exception_ptr=function(){if(ya(this.get_type()))return V[this.excPtr>>2];var b=this.get_adjusted_ptr();return 0!==b?b:this.excPtr}}function ba(){function e(){if(!la&&(la=!0,a.calledRun=!0,!wa)){za=!0;z(oa);Aa(a);if(a.onRuntimeInitialized)a.onRuntimeInitialized();if(a.postRun)for("function"==typeof a.postRun&&(a.postRun=[a.postRun]);a.postRun.length;)Ba.unshift(a.postRun.shift());z(Ba)}}if(!(0<aa)){if(a.preRun)for("function"==
typeof a.preRun&&(a.preRun=[a.preRun]);a.preRun.length;)Ca.unshift(a.preRun.shift());z(Ca);0<aa||(a.setStatus?(a.setStatus("Running..."),setTimeout(function(){setTimeout(function(){a.setStatus("")},1);e()},1)):e())}}function t(){}function x(e){return(e||t).__cache__}function D(e,b){var c=x(b),d=c[e];if(d)return d;d=Object.create((b||t).prototype);d.ptr=e;return c[e]=d}function R(e){if("string"===typeof e){for(var b=0,c=0;c<e.length;++c){var d=e.charCodeAt(c);127>=d?b++:2047>=d?b+=2:55296<=d&&57343>=
d?(b+=4,++c):b+=3}b=Array(b+1);c=0;d=b.length;if(0<d){d=c+d-1;for(var g=0;g<e.length;++g){var u=e.charCodeAt(g);if(55296<=u&&57343>=u){var X=e.charCodeAt(++g);u=65536+((u&1023)<<10)|X&1023}if(127>=u){if(c>=d)break;b[c++]=u}else{if(2047>=u){if(c+1>=d)break;b[c++]=192|u>>6}else{if(65535>=u){if(c+2>=d)break;b[c++]=224|u>>12}else{if(c+3>=d)break;b[c++]=240|u>>18;b[c++]=128|u>>12&63}b[c++]=128|u>>6&63}b[c++]=128|u&63}}b[c]=0}e=r.alloc(b,Y);r.copy(b,Y,e);return e}return e}function pa(e){if("object"===typeof e){var b=
r.alloc(e,Y);r.copy(e,Y,b);return b}return e}function Z(){throw"cannot construct a VoidPtr, no constructor in IDL";}function S(){this.ptr=Da();x(S)[this.ptr]=this}function Q(){this.ptr=Ea();x(Q)[this.ptr]=this}function W(){this.ptr=Fa();x(W)[this.ptr]=this}function w(){this.ptr=Ga();x(w)[this.ptr]=this}function C(){this.ptr=Ha();x(C)[this.ptr]=this}function F(){this.ptr=Ia();x(F)[this.ptr]=this}function G(){this.ptr=Ja();x(G)[this.ptr]=this}function E(){this.ptr=Ka();x(E)[this.ptr]=this}function T(){this.ptr=
La();x(T)[this.ptr]=this}function B(){throw"cannot construct a Status, no constructor in IDL";}function H(){this.ptr=Ma();x(H)[this.ptr]=this}function I(){this.ptr=Na();x(I)[this.ptr]=this}function J(){this.ptr=Oa();x(J)[this.ptr]=this}function K(){this.ptr=Pa();x(K)[this.ptr]=this}function L(){this.ptr=Qa();x(L)[this.ptr]=this}function M(){this.ptr=Ra();x(M)[this.ptr]=this}function N(){this.ptr=Sa();x(N)[this.ptr]=this}function y(){this.ptr=Ta();x(y)[this.ptr]=this}function m(){this.ptr=Ua();x(m)[this.ptr]=
this}n=void 0===n?{}:n;var a="undefined"!=typeof n?n:{},Aa,ka;a.ready=new Promise(function(e,b){Aa=e;ka=b});var Va=!1,Wa=!1;a.onRuntimeInitialized=function(){Va=!0;if(Wa&&"function"===typeof a.onModuleLoaded)a.onModuleLoaded(a)};a.onModuleParsed=function(){Wa=!0;if(Va&&"function"===typeof a.onModuleLoaded)a.onModuleLoaded(a)};a.isVersionSupported=function(e){if("string"!==typeof e)return!1;e=e.split(".");return 2>e.length||3<e.length?!1:1==e[0]&&0<=e[1]&&5>=e[1]?!0:0!=e[0]||10<e[1]?!1:!0};var Xa=
Object.assign({},a),xa="object"==typeof window,ha="function"==typeof importScripts,Ya="object"==typeof process&&"object"==typeof process.versions&&"string"==typeof process.versions.node,U="";if(Ya){var Za=require("fs"),qa=require("path");U=ha?qa.dirname(U)+"/":__dirname+"/";var $a=function(e,b){e=e.startsWith("file://")?new URL(e):qa.normalize(e);return Za.readFileSync(e,b?void 0:"utf8")};var ma=function(e){e=$a(e,!0);e.buffer||(e=new Uint8Array(e));return e};var na=function(e,b,c){e=e.startsWith("file://")?
new URL(e):qa.normalize(e);Za.readFile(e,function(d,g){d?c(d):b(g.buffer)})};1<process.argv.length&&process.argv[1].replace(/\\/g,"/");process.argv.slice(2);a.inspect=function(){return"[Emscripten Module object]"}}else if(xa||ha)ha?U=self.location.href:"undefined"!=typeof document&&document.currentScript&&(U=document.currentScript.src),k&&(U=k),U=0!==U.indexOf("blob:")?U.substr(0,U.replace(/[?#].*/,"").lastIndexOf("/")+1):"",$a=function(e){var b=new XMLHttpRequest;b.open("GET",e,!1);b.send(null);
return b.responseText},ha&&(ma=function(e){var b=new XMLHttpRequest;b.open("GET",e,!1);b.responseType="arraybuffer";b.send(null);return new Uint8Array(b.response)}),na=function(e,b,c){var d=new XMLHttpRequest;d.open("GET",e,!0);d.responseType="arraybuffer";d.onload=function(){200==d.status||0==d.status&&d.response?b(d.response):c()};d.onerror=c;d.send(null)};var ud=a.print||console.log.bind(console),da=a.printErr||console.warn.bind(console);Object.assign(a,Xa);Xa=null;var fa;a.wasmBinary&&(fa=a.wasmBinary);
"object"!=typeof WebAssembly&&f("no native wasm support detected");var ja,wa=!1,va="undefined"!=typeof TextDecoder?new TextDecoder("utf8"):void 0,Y,ea,ca,V,Ca=[],oa=[],Ba=[],za=!1,aa=0,ra=null,ia=null;var P="draco_decoder.wasm";P.startsWith("data:application/octet-stream;base64,")||(P=l(P));var vd=0,wd=[null,[],[]],xd={b:function(e,b,c){(new O(e)).init(b,c);vd++;throw e;},a:function(){f("")},g:function(e,b,c){ea.copyWithin(e,b,b+c)},e:function(e){var b=ea.length;e>>>=0;if(2147483648<e)return!1;for(var c=
1;4>=c;c*=2){var d=b*(1+.2/c);d=Math.min(d,e+100663296);var g=Math;d=Math.max(e,d);g=g.min.call(g,2147483648,d+(65536-d%65536)%65536);a:{d=ja.buffer;try{ja.grow(g-d.byteLength+65535>>>16);A();var u=1;break a}catch(X){}u=void 0}if(u)return!0}return!1},f:function(e){return 52},d:function(e,b,c,d,g){return 70},c:function(e,b,c,d){for(var g=0,u=0;u<c;u++){var X=V[b>>2],ab=V[b+4>>2];b+=8;for(var sa=0;sa<ab;sa++){var ta=ea[X+sa],ua=wd[e];0===ta||10===ta?((1===e?ud:da)(p(ua,0)),ua.length=0):ua.push(ta)}g+=
ab}V[d>>2]=g;return 0}};(function(){function e(g,u){a.asm=g.exports;ja=a.asm.h;A();oa.unshift(a.asm.i);aa--;a.monitorRunDependencies&&a.monitorRunDependencies(aa);0==aa&&(null!==ra&&(clearInterval(ra),ra=null),ia&&(g=ia,ia=null,g()))}function b(g){e(g.instance)}function c(g){return v().then(function(u){return WebAssembly.instantiate(u,d)}).then(function(u){return u}).then(g,function(u){da("failed to asynchronously prepare wasm: "+u);f(u)})}var d={a:xd};aa++;a.monitorRunDependencies&&a.monitorRunDependencies(aa);
if(a.instantiateWasm)try{return a.instantiateWasm(d,e)}catch(g){da("Module.instantiateWasm callback failed with error: "+g),ka(g)}(function(){return fa||"function"!=typeof WebAssembly.instantiateStreaming||P.startsWith("data:application/octet-stream;base64,")||P.startsWith("file://")||Ya||"function"!=typeof fetch?c(b):fetch(P,{credentials:"same-origin"}).then(function(g){return WebAssembly.instantiateStreaming(g,d).then(b,function(u){da("wasm streaming compile failed: "+u);da("falling back to ArrayBuffer instantiation");
return c(b)})})})().catch(ka);return{}})();var bb=a._emscripten_bind_VoidPtr___destroy___0=function(){return(bb=a._emscripten_bind_VoidPtr___destroy___0=a.asm.k).apply(null,arguments)},Da=a._emscripten_bind_DecoderBuffer_DecoderBuffer_0=function(){return(Da=a._emscripten_bind_DecoderBuffer_DecoderBuffer_0=a.asm.l).apply(null,arguments)},cb=a._emscripten_bind_DecoderBuffer_Init_2=function(){return(cb=a._emscripten_bind_DecoderBuffer_Init_2=a.asm.m).apply(null,arguments)},db=a._emscripten_bind_DecoderBuffer___destroy___0=
function(){return(db=a._emscripten_bind_DecoderBuffer___destroy___0=a.asm.n).apply(null,arguments)},Ea=a._emscripten_bind_AttributeTransformData_AttributeTransformData_0=function(){return(Ea=a._emscripten_bind_AttributeTransformData_AttributeTransformData_0=a.asm.o).apply(null,arguments)},eb=a._emscripten_bind_AttributeTransformData_transform_type_0=function(){return(eb=a._emscripten_bind_AttributeTransformData_transform_type_0=a.asm.p).apply(null,arguments)},fb=a._emscripten_bind_AttributeTransformData___destroy___0=
function(){return(fb=a._emscripten_bind_AttributeTransformData___destroy___0=a.asm.q).apply(null,arguments)},Fa=a._emscripten_bind_GeometryAttribute_GeometryAttribute_0=function(){return(Fa=a._emscripten_bind_GeometryAttribute_GeometryAttribute_0=a.asm.r).apply(null,arguments)},gb=a._emscripten_bind_GeometryAttribute___destroy___0=function(){return(gb=a._emscripten_bind_GeometryAttribute___destroy___0=a.asm.s).apply(null,arguments)},Ga=a._emscripten_bind_PointAttribute_PointAttribute_0=function(){return(Ga=
a._emscripten_bind_PointAttribute_PointAttribute_0=a.asm.t).apply(null,arguments)},hb=a._emscripten_bind_PointAttribute_size_0=function(){return(hb=a._emscripten_bind_PointAttribute_size_0=a.asm.u).apply(null,arguments)},ib=a._emscripten_bind_PointAttribute_GetAttributeTransformData_0=function(){return(ib=a._emscripten_bind_PointAttribute_GetAttributeTransformData_0=a.asm.v).apply(null,arguments)},jb=a._emscripten_bind_PointAttribute_attribute_type_0=function(){return(jb=a._emscripten_bind_PointAttribute_attribute_type_0=
a.asm.w).apply(null,arguments)},kb=a._emscripten_bind_PointAttribute_data_type_0=function(){return(kb=a._emscripten_bind_PointAttribute_data_type_0=a.asm.x).apply(null,arguments)},lb=a._emscripten_bind_PointAttribute_num_components_0=function(){return(lb=a._emscripten_bind_PointAttribute_num_components_0=a.asm.y).apply(null,arguments)},mb=a._emscripten_bind_PointAttribute_normalized_0=function(){return(mb=a._emscripten_bind_PointAttribute_normalized_0=a.asm.z).apply(null,arguments)},nb=a._emscripten_bind_PointAttribute_byte_stride_0=
function(){return(nb=a._emscripten_bind_PointAttribute_byte_stride_0=a.asm.A).apply(null,arguments)},ob=a._emscripten_bind_PointAttribute_byte_offset_0=function(){return(ob=a._emscripten_bind_PointAttribute_byte_offset_0=a.asm.B).apply(null,arguments)},pb=a._emscripten_bind_PointAttribute_unique_id_0=function(){return(pb=a._emscripten_bind_PointAttribute_unique_id_0=a.asm.C).apply(null,arguments)},qb=a._emscripten_bind_PointAttribute___destroy___0=function(){return(qb=a._emscripten_bind_PointAttribute___destroy___0=
a.asm.D).apply(null,arguments)},Ha=a._emscripten_bind_AttributeQuantizationTransform_AttributeQuantizationTransform_0=function(){return(Ha=a._emscripten_bind_AttributeQuantizationTransform_AttributeQuantizationTransform_0=a.asm.E).apply(null,arguments)},rb=a._emscripten_bind_AttributeQuantizationTransform_InitFromAttribute_1=function(){return(rb=a._emscripten_bind_AttributeQuantizationTransform_InitFromAttribute_1=a.asm.F).apply(null,arguments)},sb=a._emscripten_bind_AttributeQuantizationTransform_quantization_bits_0=
function(){return(sb=a._emscripten_bind_AttributeQuantizationTransform_quantization_bits_0=a.asm.G).apply(null,arguments)},tb=a._emscripten_bind_AttributeQuantizationTransform_min_value_1=function(){return(tb=a._emscripten_bind_AttributeQuantizationTransform_min_value_1=a.asm.H).apply(null,arguments)},ub=a._emscripten_bind_AttributeQuantizationTransform_range_0=function(){return(ub=a._emscripten_bind_AttributeQuantizationTransform_range_0=a.asm.I).apply(null,arguments)},vb=a._emscripten_bind_AttributeQuantizationTransform___destroy___0=
function(){return(vb=a._emscripten_bind_AttributeQuantizationTransform___destroy___0=a.asm.J).apply(null,arguments)},Ia=a._emscripten_bind_AttributeOctahedronTransform_AttributeOctahedronTransform_0=function(){return(Ia=a._emscripten_bind_AttributeOctahedronTransform_AttributeOctahedronTransform_0=a.asm.K).apply(null,arguments)},wb=a._emscripten_bind_AttributeOctahedronTransform_InitFromAttribute_1=function(){return(wb=a._emscripten_bind_AttributeOctahedronTransform_InitFromAttribute_1=a.asm.L).apply(null,
arguments)},xb=a._emscripten_bind_AttributeOctahedronTransform_quantization_bits_0=function(){return(xb=a._emscripten_bind_AttributeOctahedronTransform_quantization_bits_0=a.asm.M).apply(null,arguments)},yb=a._emscripten_bind_AttributeOctahedronTransform___destroy___0=function(){return(yb=a._emscripten_bind_AttributeOctahedronTransform___destroy___0=a.asm.N).apply(null,arguments)},Ja=a._emscripten_bind_PointCloud_PointCloud_0=function(){return(Ja=a._emscripten_bind_PointCloud_PointCloud_0=a.asm.O).apply(null,
arguments)},zb=a._emscripten_bind_PointCloud_num_attributes_0=function(){return(zb=a._emscripten_bind_PointCloud_num_attributes_0=a.asm.P).apply(null,arguments)},Ab=a._emscripten_bind_PointCloud_num_points_0=function(){return(Ab=a._emscripten_bind_PointCloud_num_points_0=a.asm.Q).apply(null,arguments)},Bb=a._emscripten_bind_PointCloud___destroy___0=function(){return(Bb=a._emscripten_bind_PointCloud___destroy___0=a.asm.R).apply(null,arguments)},Ka=a._emscripten_bind_Mesh_Mesh_0=function(){return(Ka=
a._emscripten_bind_Mesh_Mesh_0=a.asm.S).apply(null,arguments)},Cb=a._emscripten_bind_Mesh_num_faces_0=function(){return(Cb=a._emscripten_bind_Mesh_num_faces_0=a.asm.T).apply(null,arguments)},Db=a._emscripten_bind_Mesh_num_attributes_0=function(){return(Db=a._emscripten_bind_Mesh_num_attributes_0=a.asm.U).apply(null,arguments)},Eb=a._emscripten_bind_Mesh_num_points_0=function(){return(Eb=a._emscripten_bind_Mesh_num_points_0=a.asm.V).apply(null,arguments)},Fb=a._emscripten_bind_Mesh___destroy___0=function(){return(Fb=
a._emscripten_bind_Mesh___destroy___0=a.asm.W).apply(null,arguments)},La=a._emscripten_bind_Metadata_Metadata_0=function(){return(La=a._emscripten_bind_Metadata_Metadata_0=a.asm.X).apply(null,arguments)},Gb=a._emscripten_bind_Metadata___destroy___0=function(){return(Gb=a._emscripten_bind_Metadata___destroy___0=a.asm.Y).apply(null,arguments)},Hb=a._emscripten_bind_Status_code_0=function(){return(Hb=a._emscripten_bind_Status_code_0=a.asm.Z).apply(null,arguments)},Ib=a._emscripten_bind_Status_ok_0=function(){return(Ib=
a._emscripten_bind_Status_ok_0=a.asm._).apply(null,arguments)},Jb=a._emscripten_bind_Status_error_msg_0=function(){return(Jb=a._emscripten_bind_Status_error_msg_0=a.asm.$).apply(null,arguments)},Kb=a._emscripten_bind_Status___destroy___0=function(){return(Kb=a._emscripten_bind_Status___destroy___0=a.asm.aa).apply(null,arguments)},Ma=a._emscripten_bind_DracoFloat32Array_DracoFloat32Array_0=function(){return(Ma=a._emscripten_bind_DracoFloat32Array_DracoFloat32Array_0=a.asm.ba).apply(null,arguments)},
Lb=a._emscripten_bind_DracoFloat32Array_GetValue_1=function(){return(Lb=a._emscripten_bind_DracoFloat32Array_GetValue_1=a.asm.ca).apply(null,arguments)},Mb=a._emscripten_bind_DracoFloat32Array_size_0=function(){return(Mb=a._emscripten_bind_DracoFloat32Array_size_0=a.asm.da).apply(null,arguments)},Nb=a._emscripten_bind_DracoFloat32Array___destroy___0=function(){return(Nb=a._emscripten_bind_DracoFloat32Array___destroy___0=a.asm.ea).apply(null,arguments)},Na=a._emscripten_bind_DracoInt8Array_DracoInt8Array_0=
function(){return(Na=a._emscripten_bind_DracoInt8Array_DracoInt8Array_0=a.asm.fa).apply(null,arguments)},Ob=a._emscripten_bind_DracoInt8Array_GetValue_1=function(){return(Ob=a._emscripten_bind_DracoInt8Array_GetValue_1=a.asm.ga).apply(null,arguments)},Pb=a._emscripten_bind_DracoInt8Array_size_0=function(){return(Pb=a._emscripten_bind_DracoInt8Array_size_0=a.asm.ha).apply(null,arguments)},Qb=a._emscripten_bind_DracoInt8Array___destroy___0=function(){return(Qb=a._emscripten_bind_DracoInt8Array___destroy___0=
a.asm.ia).apply(null,arguments)},Oa=a._emscripten_bind_DracoUInt8Array_DracoUInt8Array_0=function(){return(Oa=a._emscripten_bind_DracoUInt8Array_DracoUInt8Array_0=a.asm.ja).apply(null,arguments)},Rb=a._emscripten_bind_DracoUInt8Array_GetValue_1=function(){return(Rb=a._emscripten_bind_DracoUInt8Array_GetValue_1=a.asm.ka).apply(null,arguments)},Sb=a._emscripten_bind_DracoUInt8Array_size_0=function(){return(Sb=a._emscripten_bind_DracoUInt8Array_size_0=a.asm.la).apply(null,arguments)},Tb=a._emscripten_bind_DracoUInt8Array___destroy___0=
function(){return(Tb=a._emscripten_bind_DracoUInt8Array___destroy___0=a.asm.ma).apply(null,arguments)},Pa=a._emscripten_bind_DracoInt16Array_DracoInt16Array_0=function(){return(Pa=a._emscripten_bind_DracoInt16Array_DracoInt16Array_0=a.asm.na).apply(null,arguments)},Ub=a._emscripten_bind_DracoInt16Array_GetValue_1=function(){return(Ub=a._emscripten_bind_DracoInt16Array_GetValue_1=a.asm.oa).apply(null,arguments)},Vb=a._emscripten_bind_DracoInt16Array_size_0=function(){return(Vb=a._emscripten_bind_DracoInt16Array_size_0=
a.asm.pa).apply(null,arguments)},Wb=a._emscripten_bind_DracoInt16Array___destroy___0=function(){return(Wb=a._emscripten_bind_DracoInt16Array___destroy___0=a.asm.qa).apply(null,arguments)},Qa=a._emscripten_bind_DracoUInt16Array_DracoUInt16Array_0=function(){return(Qa=a._emscripten_bind_DracoUInt16Array_DracoUInt16Array_0=a.asm.ra).apply(null,arguments)},Xb=a._emscripten_bind_DracoUInt16Array_GetValue_1=function(){return(Xb=a._emscripten_bind_DracoUInt16Array_GetValue_1=a.asm.sa).apply(null,arguments)},
Yb=a._emscripten_bind_DracoUInt16Array_size_0=function(){return(Yb=a._emscripten_bind_DracoUInt16Array_size_0=a.asm.ta).apply(null,arguments)},Zb=a._emscripten_bind_DracoUInt16Array___destroy___0=function(){return(Zb=a._emscripten_bind_DracoUInt16Array___destroy___0=a.asm.ua).apply(null,arguments)},Ra=a._emscripten_bind_DracoInt32Array_DracoInt32Array_0=function(){return(Ra=a._emscripten_bind_DracoInt32Array_DracoInt32Array_0=a.asm.va).apply(null,arguments)},$b=a._emscripten_bind_DracoInt32Array_GetValue_1=
function(){return($b=a._emscripten_bind_DracoInt32Array_GetValue_1=a.asm.wa).apply(null,arguments)},ac=a._emscripten_bind_DracoInt32Array_size_0=function(){return(ac=a._emscripten_bind_DracoInt32Array_size_0=a.asm.xa).apply(null,arguments)},bc=a._emscripten_bind_DracoInt32Array___destroy___0=function(){return(bc=a._emscripten_bind_DracoInt32Array___destroy___0=a.asm.ya).apply(null,arguments)},Sa=a._emscripten_bind_DracoUInt32Array_DracoUInt32Array_0=function(){return(Sa=a._emscripten_bind_DracoUInt32Array_DracoUInt32Array_0=
a.asm.za).apply(null,arguments)},cc=a._emscripten_bind_DracoUInt32Array_GetValue_1=function(){return(cc=a._emscripten_bind_DracoUInt32Array_GetValue_1=a.asm.Aa).apply(null,arguments)},dc=a._emscripten_bind_DracoUInt32Array_size_0=function(){return(dc=a._emscripten_bind_DracoUInt32Array_size_0=a.asm.Ba).apply(null,arguments)},ec=a._emscripten_bind_DracoUInt32Array___destroy___0=function(){return(ec=a._emscripten_bind_DracoUInt32Array___destroy___0=a.asm.Ca).apply(null,arguments)},Ta=a._emscripten_bind_MetadataQuerier_MetadataQuerier_0=
function(){return(Ta=a._emscripten_bind_MetadataQuerier_MetadataQuerier_0=a.asm.Da).apply(null,arguments)},fc=a._emscripten_bind_MetadataQuerier_HasEntry_2=function(){return(fc=a._emscripten_bind_MetadataQuerier_HasEntry_2=a.asm.Ea).apply(null,arguments)},gc=a._emscripten_bind_MetadataQuerier_GetIntEntry_2=function(){return(gc=a._emscripten_bind_MetadataQuerier_GetIntEntry_2=a.asm.Fa).apply(null,arguments)},hc=a._emscripten_bind_MetadataQuerier_GetIntEntryArray_3=function(){return(hc=a._emscripten_bind_MetadataQuerier_GetIntEntryArray_3=
a.asm.Ga).apply(null,arguments)},ic=a._emscripten_bind_MetadataQuerier_GetDoubleEntry_2=function(){return(ic=a._emscripten_bind_MetadataQuerier_GetDoubleEntry_2=a.asm.Ha).apply(null,arguments)},jc=a._emscripten_bind_MetadataQuerier_GetStringEntry_2=function(){return(jc=a._emscripten_bind_MetadataQuerier_GetStringEntry_2=a.asm.Ia).apply(null,arguments)},kc=a._emscripten_bind_MetadataQuerier_NumEntries_1=function(){return(kc=a._emscripten_bind_MetadataQuerier_NumEntries_1=a.asm.Ja).apply(null,arguments)},
lc=a._emscripten_bind_MetadataQuerier_GetEntryName_2=function(){return(lc=a._emscripten_bind_MetadataQuerier_GetEntryName_2=a.asm.Ka).apply(null,arguments)},mc=a._emscripten_bind_MetadataQuerier___destroy___0=function(){return(mc=a._emscripten_bind_MetadataQuerier___destroy___0=a.asm.La).apply(null,arguments)},Ua=a._emscripten_bind_Decoder_Decoder_0=function(){return(Ua=a._emscripten_bind_Decoder_Decoder_0=a.asm.Ma).apply(null,arguments)},nc=a._emscripten_bind_Decoder_DecodeArrayToPointCloud_3=function(){return(nc=
a._emscripten_bind_Decoder_DecodeArrayToPointCloud_3=a.asm.Na).apply(null,arguments)},oc=a._emscripten_bind_Decoder_DecodeArrayToMesh_3=function(){return(oc=a._emscripten_bind_Decoder_DecodeArrayToMesh_3=a.asm.Oa).apply(null,arguments)},pc=a._emscripten_bind_Decoder_GetAttributeId_2=function(){return(pc=a._emscripten_bind_Decoder_GetAttributeId_2=a.asm.Pa).apply(null,arguments)},qc=a._emscripten_bind_Decoder_GetAttributeIdByName_2=function(){return(qc=a._emscripten_bind_Decoder_GetAttributeIdByName_2=
a.asm.Qa).apply(null,arguments)},rc=a._emscripten_bind_Decoder_GetAttributeIdByMetadataEntry_3=function(){return(rc=a._emscripten_bind_Decoder_GetAttributeIdByMetadataEntry_3=a.asm.Ra).apply(null,arguments)},sc=a._emscripten_bind_Decoder_GetAttribute_2=function(){return(sc=a._emscripten_bind_Decoder_GetAttribute_2=a.asm.Sa).apply(null,arguments)},tc=a._emscripten_bind_Decoder_GetAttributeByUniqueId_2=function(){return(tc=a._emscripten_bind_Decoder_GetAttributeByUniqueId_2=a.asm.Ta).apply(null,arguments)},
uc=a._emscripten_bind_Decoder_GetMetadata_1=function(){return(uc=a._emscripten_bind_Decoder_GetMetadata_1=a.asm.Ua).apply(null,arguments)},vc=a._emscripten_bind_Decoder_GetAttributeMetadata_2=function(){return(vc=a._emscripten_bind_Decoder_GetAttributeMetadata_2=a.asm.Va).apply(null,arguments)},wc=a._emscripten_bind_Decoder_GetFaceFromMesh_3=function(){return(wc=a._emscripten_bind_Decoder_GetFaceFromMesh_3=a.asm.Wa).apply(null,arguments)},xc=a._emscripten_bind_Decoder_GetTriangleStripsFromMesh_2=
function(){return(xc=a._emscripten_bind_Decoder_GetTriangleStripsFromMesh_2=a.asm.Xa).apply(null,arguments)},yc=a._emscripten_bind_Decoder_GetTrianglesUInt16Array_3=function(){return(yc=a._emscripten_bind_Decoder_GetTrianglesUInt16Array_3=a.asm.Ya).apply(null,arguments)},zc=a._emscripten_bind_Decoder_GetTrianglesUInt32Array_3=function(){return(zc=a._emscripten_bind_Decoder_GetTrianglesUInt32Array_3=a.asm.Za).apply(null,arguments)},Ac=a._emscripten_bind_Decoder_GetAttributeFloat_3=function(){return(Ac=
a._emscripten_bind_Decoder_GetAttributeFloat_3=a.asm._a).apply(null,arguments)},Bc=a._emscripten_bind_Decoder_GetAttributeFloatForAllPoints_3=function(){return(Bc=a._emscripten_bind_Decoder_GetAttributeFloatForAllPoints_3=a.asm.$a).apply(null,arguments)},Cc=a._emscripten_bind_Decoder_GetAttributeIntForAllPoints_3=function(){return(Cc=a._emscripten_bind_Decoder_GetAttributeIntForAllPoints_3=a.asm.ab).apply(null,arguments)},Dc=a._emscripten_bind_Decoder_GetAttributeInt8ForAllPoints_3=function(){return(Dc=
a._emscripten_bind_Decoder_GetAttributeInt8ForAllPoints_3=a.asm.bb).apply(null,arguments)},Ec=a._emscripten_bind_Decoder_GetAttributeUInt8ForAllPoints_3=function(){return(Ec=a._emscripten_bind_Decoder_GetAttributeUInt8ForAllPoints_3=a.asm.cb).apply(null,arguments)},Fc=a._emscripten_bind_Decoder_GetAttributeInt16ForAllPoints_3=function(){return(Fc=a._emscripten_bind_Decoder_GetAttributeInt16ForAllPoints_3=a.asm.db).apply(null,arguments)},Gc=a._emscripten_bind_Decoder_GetAttributeUInt16ForAllPoints_3=
function(){return(Gc=a._emscripten_bind_Decoder_GetAttributeUInt16ForAllPoints_3=a.asm.eb).apply(null,arguments)},Hc=a._emscripten_bind_Decoder_GetAttributeInt32ForAllPoints_3=function(){return(Hc=a._emscripten_bind_Decoder_GetAttributeInt32ForAllPoints_3=a.asm.fb).apply(null,arguments)},Ic=a._emscripten_bind_Decoder_GetAttributeUInt32ForAllPoints_3=function(){return(Ic=a._emscripten_bind_Decoder_GetAttributeUInt32ForAllPoints_3=a.asm.gb).apply(null,arguments)},Jc=a._emscripten_bind_Decoder_GetAttributeDataArrayForAllPoints_5=
function(){return(Jc=a._emscripten_bind_Decoder_GetAttributeDataArrayForAllPoints_5=a.asm.hb).apply(null,arguments)},Kc=a._emscripten_bind_Decoder_SkipAttributeTransform_1=function(){return(Kc=a._emscripten_bind_Decoder_SkipAttributeTransform_1=a.asm.ib).apply(null,arguments)},Lc=a._emscripten_bind_Decoder_GetEncodedGeometryType_Deprecated_1=function(){return(Lc=a._emscripten_bind_Decoder_GetEncodedGeometryType_Deprecated_1=a.asm.jb).apply(null,arguments)},Mc=a._emscripten_bind_Decoder_DecodeBufferToPointCloud_2=
function(){return(Mc=a._emscripten_bind_Decoder_DecodeBufferToPointCloud_2=a.asm.kb).apply(null,arguments)},Nc=a._emscripten_bind_Decoder_DecodeBufferToMesh_2=function(){return(Nc=a._emscripten_bind_Decoder_DecodeBufferToMesh_2=a.asm.lb).apply(null,arguments)},Oc=a._emscripten_bind_Decoder___destroy___0=function(){return(Oc=a._emscripten_bind_Decoder___destroy___0=a.asm.mb).apply(null,arguments)},Pc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_INVALID_TRANSFORM=function(){return(Pc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_INVALID_TRANSFORM=
a.asm.nb).apply(null,arguments)},Qc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_NO_TRANSFORM=function(){return(Qc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_NO_TRANSFORM=a.asm.ob).apply(null,arguments)},Rc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_QUANTIZATION_TRANSFORM=function(){return(Rc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_QUANTIZATION_TRANSFORM=a.asm.pb).apply(null,arguments)},Sc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_OCTAHEDRON_TRANSFORM=
function(){return(Sc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_OCTAHEDRON_TRANSFORM=a.asm.qb).apply(null,arguments)},Tc=a._emscripten_enum_draco_GeometryAttribute_Type_INVALID=function(){return(Tc=a._emscripten_enum_draco_GeometryAttribute_Type_INVALID=a.asm.rb).apply(null,arguments)},Uc=a._emscripten_enum_draco_GeometryAttribute_Type_POSITION=function(){return(Uc=a._emscripten_enum_draco_GeometryAttribute_Type_POSITION=a.asm.sb).apply(null,arguments)},Vc=a._emscripten_enum_draco_GeometryAttribute_Type_NORMAL=
function(){return(Vc=a._emscripten_enum_draco_GeometryAttribute_Type_NORMAL=a.asm.tb).apply(null,arguments)},Wc=a._emscripten_enum_draco_GeometryAttribute_Type_COLOR=function(){return(Wc=a._emscripten_enum_draco_GeometryAttribute_Type_COLOR=a.asm.ub).apply(null,arguments)},Xc=a._emscripten_enum_draco_GeometryAttribute_Type_TEX_COORD=function(){return(Xc=a._emscripten_enum_draco_GeometryAttribute_Type_TEX_COORD=a.asm.vb).apply(null,arguments)},Yc=a._emscripten_enum_draco_GeometryAttribute_Type_GENERIC=
function(){return(Yc=a._emscripten_enum_draco_GeometryAttribute_Type_GENERIC=a.asm.wb).apply(null,arguments)},Zc=a._emscripten_enum_draco_EncodedGeometryType_INVALID_GEOMETRY_TYPE=function(){return(Zc=a._emscripten_enum_draco_EncodedGeometryType_INVALID_GEOMETRY_TYPE=a.asm.xb).apply(null,arguments)},$c=a._emscripten_enum_draco_EncodedGeometryType_POINT_CLOUD=function(){return($c=a._emscripten_enum_draco_EncodedGeometryType_POINT_CLOUD=a.asm.yb).apply(null,arguments)},ad=a._emscripten_enum_draco_EncodedGeometryType_TRIANGULAR_MESH=
function(){return(ad=a._emscripten_enum_draco_EncodedGeometryType_TRIANGULAR_MESH=a.asm.zb).apply(null,arguments)},bd=a._emscripten_enum_draco_DataType_DT_INVALID=function(){return(bd=a._emscripten_enum_draco_DataType_DT_INVALID=a.asm.Ab).apply(null,arguments)},cd=a._emscripten_enum_draco_DataType_DT_INT8=function(){return(cd=a._emscripten_enum_draco_DataType_DT_INT8=a.asm.Bb).apply(null,arguments)},dd=a._emscripten_enum_draco_DataType_DT_UINT8=function(){return(dd=a._emscripten_enum_draco_DataType_DT_UINT8=
a.asm.Cb).apply(null,arguments)},ed=a._emscripten_enum_draco_DataType_DT_INT16=function(){return(ed=a._emscripten_enum_draco_DataType_DT_INT16=a.asm.Db).apply(null,arguments)},fd=a._emscripten_enum_draco_DataType_DT_UINT16=function(){return(fd=a._emscripten_enum_draco_DataType_DT_UINT16=a.asm.Eb).apply(null,arguments)},gd=a._emscripten_enum_draco_DataType_DT_INT32=function(){return(gd=a._emscripten_enum_draco_DataType_DT_INT32=a.asm.Fb).apply(null,arguments)},hd=a._emscripten_enum_draco_DataType_DT_UINT32=
function(){return(hd=a._emscripten_enum_draco_DataType_DT_UINT32=a.asm.Gb).apply(null,arguments)},id=a._emscripten_enum_draco_DataType_DT_INT64=function(){return(id=a._emscripten_enum_draco_DataType_DT_INT64=a.asm.Hb).apply(null,arguments)},jd=a._emscripten_enum_draco_DataType_DT_UINT64=function(){return(jd=a._emscripten_enum_draco_DataType_DT_UINT64=a.asm.Ib).apply(null,arguments)},kd=a._emscripten_enum_draco_DataType_DT_FLOAT32=function(){return(kd=a._emscripten_enum_draco_DataType_DT_FLOAT32=a.asm.Jb).apply(null,
arguments)},ld=a._emscripten_enum_draco_DataType_DT_FLOAT64=function(){return(ld=a._emscripten_enum_draco_DataType_DT_FLOAT64=a.asm.Kb).apply(null,arguments)},md=a._emscripten_enum_draco_DataType_DT_BOOL=function(){return(md=a._emscripten_enum_draco_DataType_DT_BOOL=a.asm.Lb).apply(null,arguments)},nd=a._emscripten_enum_draco_DataType_DT_TYPES_COUNT=function(){return(nd=a._emscripten_enum_draco_DataType_DT_TYPES_COUNT=a.asm.Mb).apply(null,arguments)},od=a._emscripten_enum_draco_StatusCode_OK=function(){return(od=
a._emscripten_enum_draco_StatusCode_OK=a.asm.Nb).apply(null,arguments)},pd=a._emscripten_enum_draco_StatusCode_DRACO_ERROR=function(){return(pd=a._emscripten_enum_draco_StatusCode_DRACO_ERROR=a.asm.Ob).apply(null,arguments)},qd=a._emscripten_enum_draco_StatusCode_IO_ERROR=function(){return(qd=a._emscripten_enum_draco_StatusCode_IO_ERROR=a.asm.Pb).apply(null,arguments)},rd=a._emscripten_enum_draco_StatusCode_INVALID_PARAMETER=function(){return(rd=a._emscripten_enum_draco_StatusCode_INVALID_PARAMETER=
a.asm.Qb).apply(null,arguments)},sd=a._emscripten_enum_draco_StatusCode_UNSUPPORTED_VERSION=function(){return(sd=a._emscripten_enum_draco_StatusCode_UNSUPPORTED_VERSION=a.asm.Rb).apply(null,arguments)},td=a._emscripten_enum_draco_StatusCode_UNKNOWN_VERSION=function(){return(td=a._emscripten_enum_draco_StatusCode_UNKNOWN_VERSION=a.asm.Sb).apply(null,arguments)};a._malloc=function(){return(a._malloc=a.asm.Tb).apply(null,arguments)};a._free=function(){return(a._free=a.asm.Ub).apply(null,arguments)};
var ya=function(){return(ya=a.asm.Vb).apply(null,arguments)};a.___start_em_js=15856;a.___stop_em_js=15954;var la;ia=function b(){la||ba();la||(ia=b)};if(a.preInit)for("function"==typeof a.preInit&&(a.preInit=[a.preInit]);0<a.preInit.length;)a.preInit.pop()();ba();t.prototype=Object.create(t.prototype);t.prototype.constructor=t;t.prototype.__class__=t;t.__cache__={};a.WrapperObject=t;a.getCache=x;a.wrapPointer=D;a.castObject=function(b,c){return D(b.ptr,c)};a.NULL=D(0);a.destroy=function(b){if(!b.__destroy__)throw"Error: Cannot destroy object. (Did you create it yourself?)";
b.__destroy__();delete x(b.__class__)[b.ptr]};a.compare=function(b,c){return b.ptr===c.ptr};a.getPointer=function(b){return b.ptr};a.getClass=function(b){return b.__class__};var r={buffer:0,size:0,pos:0,temps:[],needed:0,prepare:function(){if(r.needed){for(var b=0;b<r.temps.length;b++)a._free(r.temps[b]);r.temps.length=0;a._free(r.buffer);r.buffer=0;r.size+=r.needed;r.needed=0}r.buffer||(r.size+=128,r.buffer=a._malloc(r.size),r.buffer||f(void 0));r.pos=0},alloc:function(b,c){r.buffer||f(void 0);b=
b.length*c.BYTES_PER_ELEMENT;b=b+7&-8;r.pos+b>=r.size?(0<b||f(void 0),r.needed+=b,c=a._malloc(b),r.temps.push(c)):(c=r.buffer+r.pos,r.pos+=b);return c},copy:function(b,c,d){d>>>=0;switch(c.BYTES_PER_ELEMENT){case 2:d>>>=1;break;case 4:d>>>=2;break;case 8:d>>>=3}for(var g=0;g<b.length;g++)c[d+g]=b[g]}};Z.prototype=Object.create(t.prototype);Z.prototype.constructor=Z;Z.prototype.__class__=Z;Z.__cache__={};a.VoidPtr=Z;Z.prototype.__destroy__=Z.prototype.__destroy__=function(){bb(this.ptr)};S.prototype=
Object.create(t.prototype);S.prototype.constructor=S;S.prototype.__class__=S;S.__cache__={};a.DecoderBuffer=S;S.prototype.Init=S.prototype.Init=function(b,c){var d=this.ptr;r.prepare();"object"==typeof b&&(b=pa(b));c&&"object"===typeof c&&(c=c.ptr);cb(d,b,c)};S.prototype.__destroy__=S.prototype.__destroy__=function(){db(this.ptr)};Q.prototype=Object.create(t.prototype);Q.prototype.constructor=Q;Q.prototype.__class__=Q;Q.__cache__={};a.AttributeTransformData=Q;Q.prototype.transform_type=Q.prototype.transform_type=
function(){return eb(this.ptr)};Q.prototype.__destroy__=Q.prototype.__destroy__=function(){fb(this.ptr)};W.prototype=Object.create(t.prototype);W.prototype.constructor=W;W.prototype.__class__=W;W.__cache__={};a.GeometryAttribute=W;W.prototype.__destroy__=W.prototype.__destroy__=function(){gb(this.ptr)};w.prototype=Object.create(t.prototype);w.prototype.constructor=w;w.prototype.__class__=w;w.__cache__={};a.PointAttribute=w;w.prototype.size=w.prototype.size=function(){return hb(this.ptr)};w.prototype.GetAttributeTransformData=
w.prototype.GetAttributeTransformData=function(){return D(ib(this.ptr),Q)};w.prototype.attribute_type=w.prototype.attribute_type=function(){return jb(this.ptr)};w.prototype.data_type=w.prototype.data_type=function(){return kb(this.ptr)};w.prototype.num_components=w.prototype.num_components=function(){return lb(this.ptr)};w.prototype.normalized=w.prototype.normalized=function(){return!!mb(this.ptr)};w.prototype.byte_stride=w.prototype.byte_stride=function(){return nb(this.ptr)};w.prototype.byte_offset=
w.prototype.byte_offset=function(){return ob(this.ptr)};w.prototype.unique_id=w.prototype.unique_id=function(){return pb(this.ptr)};w.prototype.__destroy__=w.prototype.__destroy__=function(){qb(this.ptr)};C.prototype=Object.create(t.prototype);C.prototype.constructor=C;C.prototype.__class__=C;C.__cache__={};a.AttributeQuantizationTransform=C;C.prototype.InitFromAttribute=C.prototype.InitFromAttribute=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return!!rb(c,b)};C.prototype.quantization_bits=
C.prototype.quantization_bits=function(){return sb(this.ptr)};C.prototype.min_value=C.prototype.min_value=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return tb(c,b)};C.prototype.range=C.prototype.range=function(){return ub(this.ptr)};C.prototype.__destroy__=C.prototype.__destroy__=function(){vb(this.ptr)};F.prototype=Object.create(t.prototype);F.prototype.constructor=F;F.prototype.__class__=F;F.__cache__={};a.AttributeOctahedronTransform=F;F.prototype.InitFromAttribute=F.prototype.InitFromAttribute=
function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return!!wb(c,b)};F.prototype.quantization_bits=F.prototype.quantization_bits=function(){return xb(this.ptr)};F.prototype.__destroy__=F.prototype.__destroy__=function(){yb(this.ptr)};G.prototype=Object.create(t.prototype);G.prototype.constructor=G;G.prototype.__class__=G;G.__cache__={};a.PointCloud=G;G.prototype.num_attributes=G.prototype.num_attributes=function(){return zb(this.ptr)};G.prototype.num_points=G.prototype.num_points=function(){return Ab(this.ptr)};
G.prototype.__destroy__=G.prototype.__destroy__=function(){Bb(this.ptr)};E.prototype=Object.create(t.prototype);E.prototype.constructor=E;E.prototype.__class__=E;E.__cache__={};a.Mesh=E;E.prototype.num_faces=E.prototype.num_faces=function(){return Cb(this.ptr)};E.prototype.num_attributes=E.prototype.num_attributes=function(){return Db(this.ptr)};E.prototype.num_points=E.prototype.num_points=function(){return Eb(this.ptr)};E.prototype.__destroy__=E.prototype.__destroy__=function(){Fb(this.ptr)};T.prototype=
Object.create(t.prototype);T.prototype.constructor=T;T.prototype.__class__=T;T.__cache__={};a.Metadata=T;T.prototype.__destroy__=T.prototype.__destroy__=function(){Gb(this.ptr)};B.prototype=Object.create(t.prototype);B.prototype.constructor=B;B.prototype.__class__=B;B.__cache__={};a.Status=B;B.prototype.code=B.prototype.code=function(){return Hb(this.ptr)};B.prototype.ok=B.prototype.ok=function(){return!!Ib(this.ptr)};B.prototype.error_msg=B.prototype.error_msg=function(){return h(Jb(this.ptr))};
B.prototype.__destroy__=B.prototype.__destroy__=function(){Kb(this.ptr)};H.prototype=Object.create(t.prototype);H.prototype.constructor=H;H.prototype.__class__=H;H.__cache__={};a.DracoFloat32Array=H;H.prototype.GetValue=H.prototype.GetValue=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return Lb(c,b)};H.prototype.size=H.prototype.size=function(){return Mb(this.ptr)};H.prototype.__destroy__=H.prototype.__destroy__=function(){Nb(this.ptr)};I.prototype=Object.create(t.prototype);I.prototype.constructor=
I;I.prototype.__class__=I;I.__cache__={};a.DracoInt8Array=I;I.prototype.GetValue=I.prototype.GetValue=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return Ob(c,b)};I.prototype.size=I.prototype.size=function(){return Pb(this.ptr)};I.prototype.__destroy__=I.prototype.__destroy__=function(){Qb(this.ptr)};J.prototype=Object.create(t.prototype);J.prototype.constructor=J;J.prototype.__class__=J;J.__cache__={};a.DracoUInt8Array=J;J.prototype.GetValue=J.prototype.GetValue=function(b){var c=
this.ptr;b&&"object"===typeof b&&(b=b.ptr);return Rb(c,b)};J.prototype.size=J.prototype.size=function(){return Sb(this.ptr)};J.prototype.__destroy__=J.prototype.__destroy__=function(){Tb(this.ptr)};K.prototype=Object.create(t.prototype);K.prototype.constructor=K;K.prototype.__class__=K;K.__cache__={};a.DracoInt16Array=K;K.prototype.GetValue=K.prototype.GetValue=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return Ub(c,b)};K.prototype.size=K.prototype.size=function(){return Vb(this.ptr)};
K.prototype.__destroy__=K.prototype.__destroy__=function(){Wb(this.ptr)};L.prototype=Object.create(t.prototype);L.prototype.constructor=L;L.prototype.__class__=L;L.__cache__={};a.DracoUInt16Array=L;L.prototype.GetValue=L.prototype.GetValue=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return Xb(c,b)};L.prototype.size=L.prototype.size=function(){return Yb(this.ptr)};L.prototype.__destroy__=L.prototype.__destroy__=function(){Zb(this.ptr)};M.prototype=Object.create(t.prototype);M.prototype.constructor=
M;M.prototype.__class__=M;M.__cache__={};a.DracoInt32Array=M;M.prototype.GetValue=M.prototype.GetValue=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return $b(c,b)};M.prototype.size=M.prototype.size=function(){return ac(this.ptr)};M.prototype.__destroy__=M.prototype.__destroy__=function(){bc(this.ptr)};N.prototype=Object.create(t.prototype);N.prototype.constructor=N;N.prototype.__class__=N;N.__cache__={};a.DracoUInt32Array=N;N.prototype.GetValue=N.prototype.GetValue=function(b){var c=
this.ptr;b&&"object"===typeof b&&(b=b.ptr);return cc(c,b)};N.prototype.size=N.prototype.size=function(){return dc(this.ptr)};N.prototype.__destroy__=N.prototype.__destroy__=function(){ec(this.ptr)};y.prototype=Object.create(t.prototype);y.prototype.constructor=y;y.prototype.__class__=y;y.__cache__={};a.MetadataQuerier=y;y.prototype.HasEntry=y.prototype.HasEntry=function(b,c){var d=this.ptr;r.prepare();b&&"object"===typeof b&&(b=b.ptr);c=c&&"object"===typeof c?c.ptr:R(c);return!!fc(d,b,c)};y.prototype.GetIntEntry=
y.prototype.GetIntEntry=function(b,c){var d=this.ptr;r.prepare();b&&"object"===typeof b&&(b=b.ptr);c=c&&"object"===typeof c?c.ptr:R(c);return gc(d,b,c)};y.prototype.GetIntEntryArray=y.prototype.GetIntEntryArray=function(b,c,d){var g=this.ptr;r.prepare();b&&"object"===typeof b&&(b=b.ptr);c=c&&"object"===typeof c?c.ptr:R(c);d&&"object"===typeof d&&(d=d.ptr);hc(g,b,c,d)};y.prototype.GetDoubleEntry=y.prototype.GetDoubleEntry=function(b,c){var d=this.ptr;r.prepare();b&&"object"===typeof b&&(b=b.ptr);c=
c&&"object"===typeof c?c.ptr:R(c);return ic(d,b,c)};y.prototype.GetStringEntry=y.prototype.GetStringEntry=function(b,c){var d=this.ptr;r.prepare();b&&"object"===typeof b&&(b=b.ptr);c=c&&"object"===typeof c?c.ptr:R(c);return h(jc(d,b,c))};y.prototype.NumEntries=y.prototype.NumEntries=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return kc(c,b)};y.prototype.GetEntryName=y.prototype.GetEntryName=function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=
c.ptr);return h(lc(d,b,c))};y.prototype.__destroy__=y.prototype.__destroy__=function(){mc(this.ptr)};m.prototype=Object.create(t.prototype);m.prototype.constructor=m;m.prototype.__class__=m;m.__cache__={};a.Decoder=m;m.prototype.DecodeArrayToPointCloud=m.prototype.DecodeArrayToPointCloud=function(b,c,d){var g=this.ptr;r.prepare();"object"==typeof b&&(b=pa(b));c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return D(nc(g,b,c,d),B)};m.prototype.DecodeArrayToMesh=m.prototype.DecodeArrayToMesh=
function(b,c,d){var g=this.ptr;r.prepare();"object"==typeof b&&(b=pa(b));c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return D(oc(g,b,c,d),B)};m.prototype.GetAttributeId=m.prototype.GetAttributeId=function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);return pc(d,b,c)};m.prototype.GetAttributeIdByName=m.prototype.GetAttributeIdByName=function(b,c){var d=this.ptr;r.prepare();b&&"object"===typeof b&&(b=b.ptr);c=c&&"object"===typeof c?
c.ptr:R(c);return qc(d,b,c)};m.prototype.GetAttributeIdByMetadataEntry=m.prototype.GetAttributeIdByMetadataEntry=function(b,c,d){var g=this.ptr;r.prepare();b&&"object"===typeof b&&(b=b.ptr);c=c&&"object"===typeof c?c.ptr:R(c);d=d&&"object"===typeof d?d.ptr:R(d);return rc(g,b,c,d)};m.prototype.GetAttribute=m.prototype.GetAttribute=function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);return D(sc(d,b,c),w)};m.prototype.GetAttributeByUniqueId=m.prototype.GetAttributeByUniqueId=
function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);return D(tc(d,b,c),w)};m.prototype.GetMetadata=m.prototype.GetMetadata=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return D(uc(c,b),T)};m.prototype.GetAttributeMetadata=m.prototype.GetAttributeMetadata=function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);return D(vc(d,b,c),T)};m.prototype.GetFaceFromMesh=m.prototype.GetFaceFromMesh=function(b,
c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!wc(g,b,c,d)};m.prototype.GetTriangleStripsFromMesh=m.prototype.GetTriangleStripsFromMesh=function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);return xc(d,b,c)};m.prototype.GetTrianglesUInt16Array=m.prototype.GetTrianglesUInt16Array=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);
d&&"object"===typeof d&&(d=d.ptr);return!!yc(g,b,c,d)};m.prototype.GetTrianglesUInt32Array=m.prototype.GetTrianglesUInt32Array=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!zc(g,b,c,d)};m.prototype.GetAttributeFloat=m.prototype.GetAttributeFloat=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!Ac(g,b,c,d)};m.prototype.GetAttributeFloatForAllPoints=
m.prototype.GetAttributeFloatForAllPoints=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!Bc(g,b,c,d)};m.prototype.GetAttributeIntForAllPoints=m.prototype.GetAttributeIntForAllPoints=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!Cc(g,b,c,d)};m.prototype.GetAttributeInt8ForAllPoints=m.prototype.GetAttributeInt8ForAllPoints=
function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!Dc(g,b,c,d)};m.prototype.GetAttributeUInt8ForAllPoints=m.prototype.GetAttributeUInt8ForAllPoints=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!Ec(g,b,c,d)};m.prototype.GetAttributeInt16ForAllPoints=m.prototype.GetAttributeInt16ForAllPoints=function(b,c,d){var g=this.ptr;
b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!Fc(g,b,c,d)};m.prototype.GetAttributeUInt16ForAllPoints=m.prototype.GetAttributeUInt16ForAllPoints=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!Gc(g,b,c,d)};m.prototype.GetAttributeInt32ForAllPoints=m.prototype.GetAttributeInt32ForAllPoints=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&
(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!Hc(g,b,c,d)};m.prototype.GetAttributeUInt32ForAllPoints=m.prototype.GetAttributeUInt32ForAllPoints=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!Ic(g,b,c,d)};m.prototype.GetAttributeDataArrayForAllPoints=m.prototype.GetAttributeDataArrayForAllPoints=function(b,c,d,g,u){var X=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&
"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);g&&"object"===typeof g&&(g=g.ptr);u&&"object"===typeof u&&(u=u.ptr);return!!Jc(X,b,c,d,g,u)};m.prototype.SkipAttributeTransform=m.prototype.SkipAttributeTransform=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);Kc(c,b)};m.prototype.GetEncodedGeometryType_Deprecated=m.prototype.GetEncodedGeometryType_Deprecated=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return Lc(c,b)};m.prototype.DecodeBufferToPointCloud=
m.prototype.DecodeBufferToPointCloud=function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);return D(Mc(d,b,c),B)};m.prototype.DecodeBufferToMesh=m.prototype.DecodeBufferToMesh=function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);return D(Nc(d,b,c),B)};m.prototype.__destroy__=m.prototype.__destroy__=function(){Oc(this.ptr)};(function(){function b(){a.ATTRIBUTE_INVALID_TRANSFORM=Pc();a.ATTRIBUTE_NO_TRANSFORM=Qc();
a.ATTRIBUTE_QUANTIZATION_TRANSFORM=Rc();a.ATTRIBUTE_OCTAHEDRON_TRANSFORM=Sc();a.INVALID=Tc();a.POSITION=Uc();a.NORMAL=Vc();a.COLOR=Wc();a.TEX_COORD=Xc();a.GENERIC=Yc();a.INVALID_GEOMETRY_TYPE=Zc();a.POINT_CLOUD=$c();a.TRIANGULAR_MESH=ad();a.DT_INVALID=bd();a.DT_INT8=cd();a.DT_UINT8=dd();a.DT_INT16=ed();a.DT_UINT16=fd();a.DT_INT32=gd();a.DT_UINT32=hd();a.DT_INT64=id();a.DT_UINT64=jd();a.DT_FLOAT32=kd();a.DT_FLOAT64=ld();a.DT_BOOL=md();a.DT_TYPES_COUNT=nd();a.OK=od();a.DRACO_ERROR=pd();a.IO_ERROR=qd();
a.INVALID_PARAMETER=rd();a.UNSUPPORTED_VERSION=sd();a.UNKNOWN_VERSION=td()}za?b():oa.unshift(b)})();if("function"===typeof a.onModuleParsed)a.onModuleParsed();a.Decoder.prototype.GetEncodedGeometryType=function(b){if(b.__class__&&b.__class__===a.DecoderBuffer)return a.Decoder.prototype.GetEncodedGeometryType_Deprecated(b);if(8>b.byteLength)return a.INVALID_GEOMETRY_TYPE;switch(b[7]){case 0:return a.POINT_CLOUD;case 1:return a.TRIANGULAR_MESH;default:return a.INVALID_GEOMETRY_TYPE}};return n.ready}}();
"object"===typeof exports&&"object"===typeof module?module.exports=DracoDecoderModule:"function"===typeof define&&define.amd?define([],function(){return DracoDecoderModule}):"object"===typeof exports&&(exports.DracoDecoderModule=DracoDecoderModule);
"; +var draco_wasm_default2 = "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"; +var glslang_default = "let Module = (function () {
  let _scriptDir =
    typeof document !== "undefined" && document.currentScript
      ? document.currentScript.src
      : undefined;

  return function (Module) {
    Module = Module || {};

    let c;
    c || (c = typeof Module !== "undefined" ? Module : {});
    c.compileGLSLZeroCopy = function (a, b, d, e) {
      d = !!d;
      switch (b) {
        case "vertex":
          var g = 0;
          break;
        case "fragment":
          g = 4;
          break;
        case "compute":
          g = 5;
          break;
        default:
          throw Error("shader_stage must be 'vertex', 'fragment', or 'compute'.");
      }
      switch (e || "1.0") {
        case "1.0":
          var f = 65536;
          break;
        case "1.1":
          f = 65792;
          break;
        case "1.2":
          f = 66048;
          break;
        case "1.3":
          f = 66304;
          break;
        case "1.4":
          f = 66560;
          break;
        case "1.5":
          f = 66816;
          break;
        default:
          throw Error("spirv_version must be '1.0' ~ '1.5'.");
      }
      e = c._malloc(4);
      b = c._malloc(4);
      let h = aa([a, g, d, f, e, b]);
      d = k(e);
      a = k(b);
      c._free(e);
      c._free(b);
      if (0 === h) throw Error("GLSL compilation failed");
      e = {};
      d /= 4;
      e.data = c.HEAPU32.subarray(d, d + a);
      e.free = function () {
        c._destroy_output_buffer(h);
      };
      return e;
    };
    c.compileGLSL = function (a, b, d, e) {
      a = c.compileGLSLZeroCopy(a, b, d, e);
      b = a.data.slice();
      a.free();
      return b;
    };
    let p = {},
      q;
    for (q in c) c.hasOwnProperty(q) && (p[q] = c[q]);
    let r = "./this.program",
      t = !1,
      u = !1;
    t = "object" === typeof window;
    u = "function" === typeof importScripts;
    let v = "",
      w;
    if (t || u)
      u ? (v = self.location.href) : document.currentScript && (v = document.currentScript.src),
        _scriptDir && (v = _scriptDir),
        0 !== v.indexOf("blob:") ? (v = v.substr(0, v.lastIndexOf("/") + 1)) : (v = ""),
        u &&
          (w = function (a) {
            let b = new XMLHttpRequest();
            b.open("GET", a, !1);
            b.responseType = "arraybuffer";
            b.send(null);
            return new Uint8Array(b.response);
          });
    let x = c.print || console.log.bind(console),
      y = c.printErr || console.warn.bind(console);
    for (q in p) p.hasOwnProperty(q) && (c[q] = p[q]);
    p = null;
    c.thisProgram && (r = c.thisProgram);
    let A;
    c.wasmBinary && (A = c.wasmBinary);
    "object" !== typeof WebAssembly && y("no native wasm support detected");
    function k(a) {
      let b = "i32";
      "*" === b.charAt(b.length - 1) && (b = "i32");
      switch (b) {
        case "i1":
          return B[a >> 0];
        case "i8":
          return B[a >> 0];
        case "i16":
          return ba[a >> 1];
        case "i32":
          return C[a >> 2];
        case "i64":
          return C[a >> 2];
        case "float":
          return ca[a >> 2];
        case "double":
          return da[a >> 3];
        default:
          D("invalid type for getValue: " + b);
      }
      return null;
    }
    let E,
      ea = new WebAssembly.Table({ initial: 859, maximum: 859, element: "anyfunc" }),
      fa = !1;
    function ha() {
      let a = c._convert_glsl_to_spirv;
      a ||
        D(
          "Assertion failed: Cannot call unknown function convert_glsl_to_spirv, make sure it is exported",
        );
      return a;
    }
    function aa(a) {
      let b = "string number boolean number number number".split(" "),
        d = {
          string(a) {
            let b = 0;
            if (null !== a && void 0 !== a && 0 !== a) {
              let d = (a.length << 2) + 1;
              b = G(d);
              ia(a, H, b, d);
            }
            return b;
          },
          array(a) {
            let b = G(a.length);
            B.set(a, b);
            return b;
          },
        },
        e = ha(),
        g = [],
        f = 0;
      if (a)
        for (let h = 0; h < a.length; h++) {
          let n = d[b[h]];
          n ? (0 === f && (f = ja()), (g[h] = n(a[h]))) : (g[h] = a[h]);
        }
      a = e.apply(null, g);
      0 !== f && ka(f);
      return a;
    }
    let la = "undefined" !== typeof TextDecoder ? new TextDecoder("utf8") : void 0;
    function I(a, b, d) {
      let e = b + d;
      for (d = b; a[d] && !(d >= e); ) ++d;
      if (16 < d - b && a.subarray && la) return la.decode(a.subarray(b, d));
      for (e = ""; b < d; ) {
        let g = a[b++];
        if (g & 128) {
          let f = a[b++] & 63;
          if (192 == (g & 224)) e += String.fromCharCode(((g & 31) << 6) | f);
          else {
            let h = a[b++] & 63;
            g =
              224 == (g & 240)
                ? ((g & 15) << 12) | (f << 6) | h
                : ((g & 7) << 18) | (f << 12) | (h << 6) | (a[b++] & 63);
            65536 > g
              ? (e += String.fromCharCode(g))
              : ((g -= 65536), (e += String.fromCharCode(55296 | (g >> 10), 56320 | (g & 1023))));
          }
        } else e += String.fromCharCode(g);
      }
      return e;
    }
    function ia(a, b, d, e) {
      if (0 < e) {
        e = d + e - 1;
        for (let g = 0; g < a.length; ++g) {
          let f = a.charCodeAt(g);
          if (55296 <= f && 57343 >= f) {
            let h = a.charCodeAt(++g);
            f = (65536 + ((f & 1023) << 10)) | (h & 1023);
          }
          if (127 >= f) {
            if (d >= e) break;
            b[d++] = f;
          } else {
            if (2047 >= f) {
              if (d + 1 >= e) break;
              b[d++] = 192 | (f >> 6);
            } else {
              if (65535 >= f) {
                if (d + 2 >= e) break;
                b[d++] = 224 | (f >> 12);
              } else {
                if (d + 3 >= e) break;
                b[d++] = 240 | (f >> 18);
                b[d++] = 128 | ((f >> 12) & 63);
              }
              b[d++] = 128 | ((f >> 6) & 63);
            }
            b[d++] = 128 | (f & 63);
          }
        }
        b[d] = 0;
      }
    }
    "undefined" !== typeof TextDecoder && new TextDecoder("utf-16le");
    let J, B, H, ba, C, ca, da;
    function ma(a) {
      J = a;
      c.HEAP8 = B = new Int8Array(a);
      c.HEAP16 = ba = new Int16Array(a);
      c.HEAP32 = C = new Int32Array(a);
      c.HEAPU8 = H = new Uint8Array(a);
      c.HEAPU16 = new Uint16Array(a);
      c.HEAPU32 = new Uint32Array(a);
      c.HEAPF32 = ca = new Float32Array(a);
      c.HEAPF64 = da = new Float64Array(a);
    }
    let na = c.TOTAL_MEMORY || 16777216;
    c.wasmMemory ? (E = c.wasmMemory) : (E = new WebAssembly.Memory({ initial: na / 65536 }));
    E && (J = E.buffer);
    na = J.byteLength;
    ma(J);
    C[84916] = 5582704;
    function K(a) {
      for (; 0 < a.length; ) {
        let b = a.shift();
        if ("function" === typeof b) b();
        else {
          let d = b.J;
          "number" === typeof d
            ? void 0 === b.H
              ? c.dynCall_v(d)
              : c.dynCall_vi(d, b.H)
            : d(void 0 === b.H ? null : b.H);
        }
      }
    }
    let oa = [],
      pa = [],
      qa = [],
      ra = [];
    function sa() {
      let a = c.preRun.shift();
      oa.unshift(a);
    }
    let L = 0,
      M = null,
      N = null;
    c.preloadedImages = {};
    c.preloadedAudios = {};
    function D(a) {
      if (c.onAbort) c.onAbort(a);
      x(a);
      y(a);
      fa = !0;
      throw new WebAssembly.RuntimeError(
        "abort(" + a + "). Build with -s ASSERTIONS=1 for more info.",
      );
    }
    function ta() {
      let a = O;
      return String.prototype.startsWith
        ? a.startsWith("data:application/octet-stream;base64,")
        : 0 === a.indexOf("data:application/octet-stream;base64,");
    }
    var O = "data:application/octet-stream;base64,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";
    if (!ta()) {
      let ua = O;
      O = c.locateFile ? c.locateFile(ua, v) : v + ua;
    }
    function wa() {
      try {
        if (A) return new Uint8Array(A);
        if (w) return w(O);
        throw "both async and sync fetching of the wasm failed";
      } catch (a) {
        D(a);
      }
    }
    function xa() {
      return A || (!t && !u) || "function" !== typeof fetch
        ? new Promise(function (a) {
            a(wa());
          })
        : fetch(O, { credentials: "same-origin" })
            .then(function (a) {
              if (!a.ok) throw "failed to load wasm binary file at '" + O + "'";
              return a.arrayBuffer();
            })
            .catch(function () {
              return wa();
            });
    }
    pa.push({
      J() {
        ya();
      },
    });
    let za = [null, [], []],
      P = 0;
    function Aa() {
      P += 4;
      return C[(P - 4) >> 2];
    }
    let Q = {},
      Ba = {};
    function Ca() {
      if (!R) {
        let a = {
            USER: "web_user",
            LOGNAME: "web_user",
            PATH: "/",
            PWD: "/",
            HOME: "/home/web_user",
            LANG:
              (
                ("object" === typeof navigator && navigator.languages && navigator.languages[0]) ||
                "C"
              ).replace("-", "_") + ".UTF-8",
            _: r,
          },
          b;
        for (b in Ba) a[b] = Ba[b];
        let d = [];
        for (b in a) d.push(b + "=" + a[b]);
        R = d;
      }
      return R;
    }
    let R;
    function S(a) {
      return 0 === a % 4 && (0 !== a % 100 || 0 === a % 400);
    }
    function T(a, b) {
      for (var d = 0, e = 0; e <= b; d += a[e++]);
      return d;
    }
    let U = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
      W = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
    function X(a, b) {
      for (a = new Date(a.getTime()); 0 < b; ) {
        let d = a.getMonth(),
          e = (S(a.getFullYear()) ? U : W)[d];
        if (b > e - a.getDate())
          (b -= e - a.getDate() + 1),
            a.setDate(1),
            11 > d ? a.setMonth(d + 1) : (a.setMonth(0), a.setFullYear(a.getFullYear() + 1));
        else {
          a.setDate(a.getDate() + b);
          break;
        }
      }
      return a;
    }
    function Da(a, b, d, e) {
      function g(a, b, d) {
        for (a = "number" === typeof a ? a.toString() : a || ""; a.length < b; ) a = d[0] + a;
        return a;
      }
      function f(a, b) {
        return g(a, b, "0");
      }
      function h(a, b) {
        function V(a) {
          return 0 > a ? -1 : 0 < a ? 1 : 0;
        }
        let d;
        0 === (d = V(a.getFullYear() - b.getFullYear())) &&
          0 === (d = V(a.getMonth() - b.getMonth())) &&
          (d = V(a.getDate() - b.getDate()));
        return d;
      }
      function n(a) {
        switch (a.getDay()) {
          case 0:
            return new Date(a.getFullYear() - 1, 11, 29);
          case 1:
            return a;
          case 2:
            return new Date(a.getFullYear(), 0, 3);
          case 3:
            return new Date(a.getFullYear(), 0, 2);
          case 4:
            return new Date(a.getFullYear(), 0, 1);
          case 5:
            return new Date(a.getFullYear() - 1, 11, 31);
          case 6:
            return new Date(a.getFullYear() - 1, 11, 30);
        }
      }
      function z(a) {
        a = X(new Date(a.A + 1900, 0, 1), a.G);
        let b = n(new Date(a.getFullYear() + 1, 0, 4));
        return 0 >= h(n(new Date(a.getFullYear(), 0, 4)), a)
          ? 0 >= h(b, a)
            ? a.getFullYear() + 1
            : a.getFullYear()
          : a.getFullYear() - 1;
      }
      let m = C[(e + 40) >> 2];
      e = {
        N: C[e >> 2],
        M: C[(e + 4) >> 2],
        D: C[(e + 8) >> 2],
        C: C[(e + 12) >> 2],
        B: C[(e + 16) >> 2],
        A: C[(e + 20) >> 2],
        F: C[(e + 24) >> 2],
        G: C[(e + 28) >> 2],
        X: C[(e + 32) >> 2],
        L: C[(e + 36) >> 2],
        O: m ? (m ? I(H, m, void 0) : "") : "",
      };
      d = d ? I(H, d, void 0) : "";
      m = {
        "%c": "%a %b %d %H:%M:%S %Y",
        "%D": "%m/%d/%y",
        "%F": "%Y-%m-%d",
        "%h": "%b",
        "%r": "%I:%M:%S %p",
        "%R": "%H:%M",
        "%T": "%H:%M:%S",
        "%x": "%m/%d/%y",
        "%X": "%H:%M:%S",
        "%Ec": "%c",
        "%EC": "%C",
        "%Ex": "%m/%d/%y",
        "%EX": "%H:%M:%S",
        "%Ey": "%y",
        "%EY": "%Y",
        "%Od": "%d",
        "%Oe": "%e",
        "%OH": "%H",
        "%OI": "%I",
        "%Om": "%m",
        "%OM": "%M",
        "%OS": "%S",
        "%Ou": "%u",
        "%OU": "%U",
        "%OV": "%V",
        "%Ow": "%w",
        "%OW": "%W",
        "%Oy": "%y",
      };
      for (var l in m) d = d.replace(new RegExp(l, "g"), m[l]);
      let F = "Sunday Monday Tuesday Wednesday Thursday Friday Saturday".split(" "),
        va =
          "January February March April May June July August September October November December".split(
            " ",
          );
      m = {
        "%a"(a) {
          return F[a.F].substring(0, 3);
        },
        "%A"(a) {
          return F[a.F];
        },
        "%b"(a) {
          return va[a.B].substring(0, 3);
        },
        "%B"(a) {
          return va[a.B];
        },
        "%C"(a) {
          return f(((a.A + 1900) / 100) | 0, 2);
        },
        "%d"(a) {
          return f(a.C, 2);
        },
        "%e"(a) {
          return g(a.C, 2, " ");
        },
        "%g"(a) {
          return z(a).toString().substring(2);
        },
        "%G"(a) {
          return z(a);
        },
        "%H"(a) {
          return f(a.D, 2);
        },
        "%I"(a) {
          a = a.D;
          0 == a ? (a = 12) : 12 < a && (a -= 12);
          return f(a, 2);
        },
        "%j"(a) {
          return f(a.C + T(S(a.A + 1900) ? U : W, a.B - 1), 3);
        },
        "%m"(a) {
          return f(a.B + 1, 2);
        },
        "%M"(a) {
          return f(a.M, 2);
        },
        "%n"() {
          return "\n";
        },
        "%p"(a) {
          return 0 <= a.D && 12 > a.D ? "AM" : "PM";
        },
        "%S"(a) {
          return f(a.N, 2);
        },
        "%t"() {
          return "\t";
        },
        "%u"(a) {
          return a.F || 7;
        },
        "%U"(a) {
          let b = new Date(a.A + 1900, 0, 1),
            d = 0 === b.getDay() ? b : X(b, 7 - b.getDay());
          a = new Date(a.A + 1900, a.B, a.C);
          return 0 > h(d, a)
            ? f(
                Math.ceil(
                  (31 -
                    d.getDate() +
                    (T(S(a.getFullYear()) ? U : W, a.getMonth() - 1) - 31) +
                    a.getDate()) /
                    7,
                ),
                2,
              )
            : 0 === h(d, b)
              ? "01"
              : "00";
        },
        "%V"(a) {
          let b = n(new Date(a.A + 1900, 0, 4)),
            d = n(new Date(a.A + 1901, 0, 4)),
            e = X(new Date(a.A + 1900, 0, 1), a.G);
          return 0 > h(e, b)
            ? "53"
            : 0 >= h(d, e)
              ? "01"
              : f(
                  Math.ceil(
                    (b.getFullYear() < a.A + 1900
                      ? a.G + 32 - b.getDate()
                      : a.G + 1 - b.getDate()) / 7,
                  ),
                  2,
                );
        },
        "%w"(a) {
          return a.F;
        },
        "%W"(a) {
          let b = new Date(a.A, 0, 1),
            d = 1 === b.getDay() ? b : X(b, 0 === b.getDay() ? 1 : 7 - b.getDay() + 1);
          a = new Date(a.A + 1900, a.B, a.C);
          return 0 > h(d, a)
            ? f(
                Math.ceil(
                  (31 -
                    d.getDate() +
                    (T(S(a.getFullYear()) ? U : W, a.getMonth() - 1) - 31) +
                    a.getDate()) /
                    7,
                ),
                2,
              )
            : 0 === h(d, b)
              ? "01"
              : "00";
        },
        "%y"(a) {
          return (a.A + 1900).toString().substring(2);
        },
        "%Y"(a) {
          return a.A + 1900;
        },
        "%z"(a) {
          a = a.L;
          let b = 0 <= a;
          a = Math.abs(a) / 60;
          return (b ? "+" : "-") + String("0000" + ((a / 60) * 100 + (a % 60))).slice(-4);
        },
        "%Z"(a) {
          return a.O;
        },
        "%%"() {
          return "%";
        },
      };
      for (l in m) 0 <= d.indexOf(l) && (d = d.replace(new RegExp(l, "g"), m[l](e)));
      l = Ea(d);
      if (l.length > b) return 0;
      B.set(l, a);
      return l.length - 1;
    }
    function Ea(a) {
      for (var b = 0, d = 0; d < a.length; ++d) {
        let e = a.charCodeAt(d);
        55296 <= e && 57343 >= e && (e = (65536 + ((e & 1023) << 10)) | (a.charCodeAt(++d) & 1023));
        127 >= e ? ++b : (b = 2047 >= e ? b + 2 : 65535 >= e ? b + 3 : b + 4);
      }
      b = Array(b + 1);
      ia(a, b, 0, b.length);
      return b;
    }
    let Ga = {
        f() {},
        c() {
          c.___errno_location && (C[c.___errno_location() >> 2] = 63);
          return -1;
        },
        n(a, b) {
          P = b;
          try {
            let d = Aa();
            let e = Aa();
            if (-1 === d || 0 === e) var g = -28;
            else {
              let f = Q.K[d];
              if (f && e === f.U) {
                let h = (void 0).T(f.S);
                Q.R(d, h, e, f.flags, f.offset);
                (void 0).W(h);
                Q.K[d] = null;
                f.P && Fa(f.V);
              }
              g = 0;
            }
            return g;
          } catch (n) {
            return D(n), -n.I;
          }
        },
        a() {},
        b() {
          D();
        },
        k(a, b, d) {
          H.set(H.subarray(b, b + d), a);
        },
        l(a) {
          let b = B.length;
          if (2147418112 < a) return !1;
          for (let d = 1; 4 >= d; d *= 2) {
            let e = b * (1 + 0.2 / d);
            e = Math.min(e, a + 100663296);
            e = Math.max(16777216, a, e);
            0 < e % 65536 && (e += 65536 - (e % 65536));
            a: {
              try {
                E.grow((Math.min(2147418112, e) - J.byteLength + 65535) >> 16);
                ma(E.buffer);
                var g = 1;
                break a;
              } catch (f) {}
              g = void 0;
            }
            if (g) return !0;
          }
          return !1;
        },
        d(a, b) {
          let d = 0;
          Ca().forEach(function (e, g) {
            let f = b + d;
            g = C[(a + 4 * g) >> 2] = f;
            for (f = 0; f < e.length; ++f) B[g++ >> 0] = e.charCodeAt(f);
            B[g >> 0] = 0;
            d += e.length + 1;
          });
          return 0;
        },
        e(a, b) {
          let d = Ca();
          C[a >> 2] = d.length;
          let e = 0;
          d.forEach(function (a) {
            e += a.length + 1;
          });
          C[b >> 2] = e;
          return 0;
        },
        h() {
          return 0;
        },
        j() {
          return 0;
        },
        g(a, b, d, e) {
          try {
            for (var g = 0, f = 0; f < d; f++) {
              for (var h = C[(b + 8 * f) >> 2], n = C[(b + (8 * f + 4)) >> 2], z = 0; z < n; z++) {
                let m = H[h + z],
                  l = za[a];
                0 === m || 10 === m ? ((1 === a ? x : y)(I(l, 0)), (l.length = 0)) : l.push(m);
              }
              g += n;
            }
            C[e >> 2] = g;
            return 0;
          } catch (F) {
            return D(F), F.I;
          }
        },
        memory: E,
        o() {},
        i() {},
        m(a, b, d, e) {
          return Da(a, b, d, e);
        },
        table: ea,
      },
      Ha = (function () {
        function a(a) {
          c.asm = a.exports;
          L--;
          c.monitorRunDependencies && c.monitorRunDependencies(L);
          0 == L && (null !== M && (clearInterval(M), (M = null)), N && ((a = N), (N = null), a()));
        }
        function b(b) {
          a(b.instance);
        }
        function d(a) {
          return xa()
            .then(function (a) {
              return WebAssembly.instantiate(a, e);
            })
            .then(a, function (a) {
              y("failed to asynchronously prepare wasm: " + a);
              D(a);
            });
        }
        var e = { env: Ga, wasi_snapshot_preview1: Ga };
        L++;
        c.monitorRunDependencies && c.monitorRunDependencies(L);
        if (c.instantiateWasm)
          try {
            return c.instantiateWasm(e, a);
          } catch (g) {
            return y("Module.instantiateWasm callback failed with error: " + g), !1;
          }
        (function () {
          if (
            A ||
            "function" !== typeof WebAssembly.instantiateStreaming ||
            ta() ||
            "function" !== typeof fetch
          )
            return d(b);
          fetch(O, { credentials: "same-origin" }).then(function (a) {
            return WebAssembly.instantiateStreaming(a, e).then(b, function (a) {
              y("wasm streaming compile failed: " + a);
              y("falling back to ArrayBuffer instantiation");
              d(b);
            });
          });
        })();
        return {};
      })();
    c.asm = Ha;
    var ya = (c.___wasm_call_ctors = function () {
      return (ya = c.___wasm_call_ctors = c.asm.p).apply(null, arguments);
    });
    c._convert_glsl_to_spirv = function () {
      return (c._convert_glsl_to_spirv = c.asm.q).apply(null, arguments);
    };
    c._destroy_output_buffer = function () {
      return (c._destroy_output_buffer = c.asm.r).apply(null, arguments);
    };
    c._malloc = function () {
      return (c._malloc = c.asm.s).apply(null, arguments);
    };
    var Fa = (c._free = function () {
        return (Fa = c._free = c.asm.t).apply(null, arguments);
      }),
      ja = (c.stackSave = function () {
        return (ja = c.stackSave = c.asm.u).apply(null, arguments);
      }),
      G = (c.stackAlloc = function () {
        return (G = c.stackAlloc = c.asm.v).apply(null, arguments);
      }),
      ka = (c.stackRestore = function () {
        return (ka = c.stackRestore = c.asm.w).apply(null, arguments);
      });
    c.dynCall_vi = function () {
      return (c.dynCall_vi = c.asm.x).apply(null, arguments);
    };
    c.dynCall_v = function () {
      return (c.dynCall_v = c.asm.y).apply(null, arguments);
    };
    c.asm = Ha;
    let Y;
    c.then = function (a) {
      if (Y) a(c);
      else {
        let b = c.onRuntimeInitialized;
        c.onRuntimeInitialized = function () {
          b && b();
          a(c);
        };
      }
      return c;
    };
    N = function Ia() {
      Y || Z();
      Y || (N = Ia);
    };
    function Z() {
      function a() {
        if (!Y && ((Y = !0), !fa)) {
          K(pa);
          K(qa);
          if (c.onRuntimeInitialized) c.onRuntimeInitialized();
          if (c.postRun)
            for ("function" === typeof c.postRun && (c.postRun = [c.postRun]); c.postRun.length; ) {
              let a = c.postRun.shift();
              ra.unshift(a);
            }
          K(ra);
        }
      }
      if (!(0 < L)) {
        if (c.preRun)
          for ("function" === typeof c.preRun && (c.preRun = [c.preRun]); c.preRun.length; ) sa();
        K(oa);
        0 < L ||
          (c.setStatus
            ? (c.setStatus("Running..."),
              setTimeout(function () {
                setTimeout(function () {
                  c.setStatus("");
                }, 1);
                a();
              }, 1))
            : a());
      }
    }
    c.run = Z;
    if (c.preInit)
      for ("function" === typeof c.preInit && (c.preInit = [c.preInit]); 0 < c.preInit.length; )
        c.preInit.pop()();
    Z();

    return Module;
  };
})();
if (typeof exports === "object" && typeof module === "object") module.exports = Module;
else if (typeof define === "function" && define["amd"])
  define([], function () {
    return Module;
  });
else if (typeof exports === "object") exports["Module"] = Module;
export default (() => {
  const initialize = () => {
    return new Promise((resolve) => {
      Module({
        locateFile() {
          const i = import.meta.url.lastIndexOf("/");
          return import.meta.url.substring(0, i) + "/glslang.wasm";
        },
        onRuntimeInitialized() {
          resolve({
            compileGLSLZeroCopy: this.compileGLSLZeroCopy,
            compileGLSL: this.compileGLSL,
          });
        },
      });
    });
  };

  let instance;
  return () => {
    if (!instance) {
      instance = initialize();
    }
    return instance;
  };
})();
"; +var twgsl_default = "let Module = function (Module) {
  Module = Module || {};
  var Module = typeof Module !== "undefined" ? Module : {};
  let moduleOverrides = Object.assign({}, Module);
  let arguments_ = [];
  let thisProgram = "./this.program";
  let quit_ = (status, toThrow) => {
    throw toThrow;
  };
  let ENVIRONMENT_IS_WEB = typeof window === "object";
  let ENVIRONMENT_IS_WORKER = typeof importScripts === "function";
  let ENVIRONMENT_IS_NODE =
    typeof process === "object" &&
    typeof process.versions === "object" &&
    typeof process.versions.node === "string";
  let scriptDirectory = "";
  function locateFile(path) {
    if (Module["locateFile"]) {
      return Module["locateFile"](path, scriptDirectory);
    }
    return scriptDirectory + path;
  }
  let read_, readAsync, readBinary, setWindowTitle;
  function logExceptionOnExit(e) {
    if (e instanceof ExitStatus) return;
    let toLog = e;
    err("exiting due to exception: " + toLog);
  }
  if (ENVIRONMENT_IS_NODE) {
    if (ENVIRONMENT_IS_WORKER) {
      scriptDirectory = require("path").dirname(scriptDirectory) + "/";
    } else {
      scriptDirectory = __dirname + "/";
    }
    var fs, nodePath;
    if (typeof require === "function") {
      fs = require("fs");
      nodePath = require("path");
    }
    read_ = (filename, binary) => {
      filename = nodePath["normalize"](filename);
      return fs.readFileSync(filename, binary ? undefined : "utf8");
    };
    readBinary = (filename) => {
      let ret = read_(filename, true);
      if (!ret.buffer) {
        ret = new Uint8Array(ret);
      }
      return ret;
    };
    readAsync = (filename, onload, onerror) => {
      filename = nodePath["normalize"](filename);
      fs.readFile(filename, function (err, data) {
        if (err) onerror(err);
        else onload(data.buffer);
      });
    };
    if (process["argv"].length > 1) {
      thisProgram = process["argv"][1].replace(/\\/g, "/");
    }
    arguments_ = process["argv"].slice(2);
    if (typeof module !== "undefined") {
      module["exports"] = Module;
    }
    process["on"]("uncaughtException", function (ex) {
      if (!(ex instanceof ExitStatus)) {
        throw ex;
      }
    });
    process["on"]("unhandledRejection", function (reason) {
      throw reason;
    });
    quit_ = (status, toThrow) => {
      if (keepRuntimeAlive()) {
        process["exitCode"] = status;
        throw toThrow;
      }
      logExceptionOnExit(toThrow);
      process["exit"](status);
    };
    Module["inspect"] = function () {
      return "[Emscripten Module object]";
    };
  } else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
    if (ENVIRONMENT_IS_WORKER) {
      scriptDirectory = self.location.href;
    } else if (typeof document !== "undefined" && document.currentScript) {
      scriptDirectory = document.currentScript.src;
    }
    if (scriptDirectory.indexOf("blob:") !== 0) {
      scriptDirectory = scriptDirectory.substr(
        0,
        scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1,
      );
    } else {
      scriptDirectory = "";
    }
    {
      read_ = (url) => {
        let xhr = new XMLHttpRequest();
        xhr.open("GET", url, false);
        xhr.send(null);
        return xhr.responseText;
      };
      if (ENVIRONMENT_IS_WORKER) {
        readBinary = (url) => {
          let xhr = new XMLHttpRequest();
          xhr.open("GET", url, false);
          xhr.responseType = "arraybuffer";
          xhr.send(null);
          return new Uint8Array(xhr.response);
        };
      }
      readAsync = (url, onload, onerror) => {
        let xhr = new XMLHttpRequest();
        xhr.open("GET", url, true);
        xhr.responseType = "arraybuffer";
        xhr.onload = () => {
          if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) {
            onload(xhr.response);
            return;
          }
          onerror();
        };
        xhr.onerror = onerror;
        xhr.send(null);
      };
    }
    setWindowTitle = (title) => (document.title = title);
  } else {
  }
  let out = Module["print"] || console.log.bind(console);
  var err = Module["printErr"] || console.warn.bind(console);
  Object.assign(Module, moduleOverrides);
  moduleOverrides = null;
  if (Module["arguments"]) arguments_ = Module["arguments"];
  if (Module["thisProgram"]) thisProgram = Module["thisProgram"];
  if (Module["quit"]) quit_ = Module["quit"];
  let wasmBinary;
  if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"];
  let noExitRuntime = Module["noExitRuntime"] || true;
  if (typeof WebAssembly !== "object") {
    abort("no native wasm support detected");
  }
  let wasmMemory;
  let ABORT = false;
  let EXITSTATUS;
  function assert(condition, text) {
    if (!condition) {
      abort(text);
    }
  }
  let UTF8Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf8") : undefined;
  function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) {
    let endIdx = idx + maxBytesToRead;
    let endPtr = idx;
    while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr;
    if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
      return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
    }
    let str = "";
    while (idx < endPtr) {
      let u0 = heapOrArray[idx++];
      if (!(u0 & 128)) {
        str += String.fromCharCode(u0);
        continue;
      }
      let u1 = heapOrArray[idx++] & 63;
      if ((u0 & 224) == 192) {
        str += String.fromCharCode(((u0 & 31) << 6) | u1);
        continue;
      }
      let u2 = heapOrArray[idx++] & 63;
      if ((u0 & 240) == 224) {
        u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
      } else {
        u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63);
      }
      if (u0 < 65536) {
        str += String.fromCharCode(u0);
      } else {
        let ch = u0 - 65536;
        str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023));
      }
    }
    return str;
  }
  function UTF8ToString(ptr, maxBytesToRead) {
    return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
  }
  function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) {
    if (!(maxBytesToWrite > 0)) return 0;
    let startIdx = outIdx;
    let endIdx = outIdx + maxBytesToWrite - 1;
    for (let i = 0; i < str.length; ++i) {
      let u = str.charCodeAt(i);
      if (u >= 55296 && u <= 57343) {
        let u1 = str.charCodeAt(++i);
        u = (65536 + ((u & 1023) << 10)) | (u1 & 1023);
      }
      if (u <= 127) {
        if (outIdx >= endIdx) break;
        heap[outIdx++] = u;
      } else if (u <= 2047) {
        if (outIdx + 1 >= endIdx) break;
        heap[outIdx++] = 192 | (u >> 6);
        heap[outIdx++] = 128 | (u & 63);
      } else if (u <= 65535) {
        if (outIdx + 2 >= endIdx) break;
        heap[outIdx++] = 224 | (u >> 12);
        heap[outIdx++] = 128 | ((u >> 6) & 63);
        heap[outIdx++] = 128 | (u & 63);
      } else {
        if (outIdx + 3 >= endIdx) break;
        heap[outIdx++] = 240 | (u >> 18);
        heap[outIdx++] = 128 | ((u >> 12) & 63);
        heap[outIdx++] = 128 | ((u >> 6) & 63);
        heap[outIdx++] = 128 | (u & 63);
      }
    }
    heap[outIdx] = 0;
    return outIdx - startIdx;
  }
  function lengthBytesUTF8(str) {
    let len = 0;
    for (let i = 0; i < str.length; ++i) {
      let c = str.charCodeAt(i);
      if (c <= 127) {
        len++;
      } else if (c <= 2047) {
        len += 2;
      } else if (c >= 55296 && c <= 57343) {
        len += 4;
        ++i;
      } else {
        len += 3;
      }
    }
    return len;
  }
  let buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
  function updateGlobalBufferAndViews(buf) {
    buffer = buf;
    Module["HEAP8"] = HEAP8 = new Int8Array(buf);
    Module["HEAP16"] = HEAP16 = new Int16Array(buf);
    Module["HEAP32"] = HEAP32 = new Int32Array(buf);
    Module["HEAPU8"] = HEAPU8 = new Uint8Array(buf);
    Module["HEAPU16"] = HEAPU16 = new Uint16Array(buf);
    Module["HEAPU32"] = HEAPU32 = new Uint32Array(buf);
    Module["HEAPF32"] = HEAPF32 = new Float32Array(buf);
    Module["HEAPF64"] = HEAPF64 = new Float64Array(buf);
  }
  let INITIAL_MEMORY = Module["INITIAL_MEMORY"] || 16777216;
  let wasmTable;
  let __ATPRERUN__ = [];
  let __ATINIT__ = [];
  let __ATPOSTRUN__ = [];
  let runtimeInitialized = false;
  function keepRuntimeAlive() {
    return noExitRuntime;
  }
  function preRun() {
    if (Module["preRun"]) {
      if (typeof Module["preRun"] === "function") Module["preRun"] = [Module["preRun"]];
      while (Module["preRun"].length) {
        addOnPreRun(Module["preRun"].shift());
      }
    }
    callRuntimeCallbacks(__ATPRERUN__);
  }
  function initRuntime() {
    runtimeInitialized = true;
    if (!Module["noFSInit"] && !FS.init.initialized) FS.init();
    FS.ignorePermissions = false;
    TTY.init();
    callRuntimeCallbacks(__ATINIT__);
  }
  function postRun() {
    if (Module["postRun"]) {
      if (typeof Module["postRun"] === "function") Module["postRun"] = [Module["postRun"]];
      while (Module["postRun"].length) {
        addOnPostRun(Module["postRun"].shift());
      }
    }
    callRuntimeCallbacks(__ATPOSTRUN__);
  }
  function addOnPreRun(cb) {
    __ATPRERUN__.unshift(cb);
  }
  function addOnInit(cb) {
    __ATINIT__.unshift(cb);
  }
  function addOnPostRun(cb) {
    __ATPOSTRUN__.unshift(cb);
  }
  let runDependencies = 0;
  let runDependencyWatcher = null;
  let dependenciesFulfilled = null;
  function getUniqueRunDependency(id) {
    return id;
  }
  function addRunDependency(id) {
    runDependencies++;
    if (Module["monitorRunDependencies"]) {
      Module["monitorRunDependencies"](runDependencies);
    }
  }
  function removeRunDependency(id) {
    runDependencies--;
    if (Module["monitorRunDependencies"]) {
      Module["monitorRunDependencies"](runDependencies);
    }
    if (runDependencies == 0) {
      if (runDependencyWatcher !== null) {
        clearInterval(runDependencyWatcher);
        runDependencyWatcher = null;
      }
      if (dependenciesFulfilled) {
        let callback = dependenciesFulfilled;
        dependenciesFulfilled = null;
        callback();
      }
    }
  }
  function abort(what) {
    {
      if (Module["onAbort"]) {
        Module["onAbort"](what);
      }
    }
    what = "Aborted(" + what + ")";
    err(what);
    ABORT = true;
    EXITSTATUS = 1;
    what += ". Build with -sASSERTIONS for more info.";
    let e = new WebAssembly.RuntimeError(what);
    throw e;
  }
  let dataURIPrefix = "data:application/octet-stream;base64,";
  function isDataURI(filename) {
    return filename.startsWith(dataURIPrefix);
  }
  function isFileURI(filename) {
    return filename.startsWith("file://");
  }
  let wasmBinaryFile;
  wasmBinaryFile = "data:application/octet-stream;base64,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";
  if (!isDataURI(wasmBinaryFile)) {
    wasmBinaryFile = locateFile(wasmBinaryFile);
  }
  function getBinary(file) {
    try {
      if (file == wasmBinaryFile && wasmBinary) {
        return new Uint8Array(wasmBinary);
      }
      if (readBinary) {
        return readBinary(file);
      }
      throw "both async and sync fetching of the wasm failed";
    } catch (err) {
      abort(err);
    }
  }
  function getBinaryPromise() {
    if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
      if (typeof fetch === "function" && !isFileURI(wasmBinaryFile)) {
        return fetch(wasmBinaryFile, { credentials: "same-origin" })
          .then(function (response) {
            if (!response["ok"]) {
              throw "failed to load wasm binary file at '" + wasmBinaryFile + "'";
            }
            return response["arrayBuffer"]();
          })
          .catch(function () {
            return getBinary(wasmBinaryFile);
          });
      } else {
        if (readAsync) {
          return new Promise(function (resolve, reject) {
            readAsync(
              wasmBinaryFile,
              function (response) {
                resolve(new Uint8Array(response));
              },
              reject,
            );
          });
        }
      }
    }
    return Promise.resolve().then(function () {
      return getBinary(wasmBinaryFile);
    });
  }
  function createWasm() {
    let info = { a: asmLibraryArg };
    function receiveInstance(instance, module) {
      let exports = instance.exports;
      Module["asm"] = exports;
      wasmMemory = Module["asm"]["o"];
      updateGlobalBufferAndViews(wasmMemory.buffer);
      wasmTable = Module["asm"]["s"];
      addOnInit(Module["asm"]["p"]);
      removeRunDependency("wasm-instantiate");
    }
    addRunDependency("wasm-instantiate");
    function receiveInstantiationResult(result) {
      receiveInstance(result["instance"]);
    }
    function instantiateArrayBuffer(receiver) {
      return getBinaryPromise()
        .then(function (binary) {
          return WebAssembly.instantiate(binary, info);
        })
        .then(function (instance) {
          return instance;
        })
        .then(receiver, function (reason) {
          err("failed to asynchronously prepare wasm: " + reason);
          abort(reason);
        });
    }
    function instantiateAsync() {
      if (
        !wasmBinary &&
        typeof WebAssembly.instantiateStreaming === "function" &&
        !isDataURI(wasmBinaryFile) &&
        !isFileURI(wasmBinaryFile) &&
        !ENVIRONMENT_IS_NODE &&
        typeof fetch === "function"
      ) {
        return fetch(wasmBinaryFile, { credentials: "same-origin" }).then(function (response) {
          let result = WebAssembly.instantiateStreaming(response, info);
          return result.then(receiveInstantiationResult, function (reason) {
            err("wasm streaming compile failed: " + reason);
            err("falling back to ArrayBuffer instantiation");
            return instantiateArrayBuffer(receiveInstantiationResult);
          });
        });
      } else {
        return instantiateArrayBuffer(receiveInstantiationResult);
      }
    }
    if (Module["instantiateWasm"]) {
      try {
        let exports = Module["instantiateWasm"](info, receiveInstance);
        return exports;
      } catch (e) {
        err("Module.instantiateWasm callback failed with error: " + e);
        return false;
      }
    }
    instantiateAsync();
    return {};
  }
  let tempDouble;
  let tempI64;
  function ExitStatus(status) {
    this.name = "ExitStatus";
    this.message = "Program terminated with exit(" + status + ")";
    this.status = status;
  }
  function callRuntimeCallbacks(callbacks) {
    while (callbacks.length > 0) {
      callbacks.shift()(Module);
    }
  }
  function ___assert_fail(condition, filename, line, func) {
    abort(
      "Assertion failed: " +
        UTF8ToString(condition) +
        ", at: " +
        [
          filename ? UTF8ToString(filename) : "unknown filename",
          line,
          func ? UTF8ToString(func) : "unknown function",
        ],
    );
  }
  function ___cxa_allocate_exception(size) {
    return _malloc(size + 24) + 24;
  }
  function ExceptionInfo(excPtr) {
    this.excPtr = excPtr;
    this.ptr = excPtr - 24;
    this.set_type = function (type) {
      HEAPU32[(this.ptr + 4) >> 2] = type;
    };
    this.get_type = function () {
      return HEAPU32[(this.ptr + 4) >> 2];
    };
    this.set_destructor = function (destructor) {
      HEAPU32[(this.ptr + 8) >> 2] = destructor;
    };
    this.get_destructor = function () {
      return HEAPU32[(this.ptr + 8) >> 2];
    };
    this.set_refcount = function (refcount) {
      HEAP32[this.ptr >> 2] = refcount;
    };
    this.set_caught = function (caught) {
      caught = caught ? 1 : 0;
      HEAP8[(this.ptr + 12) >> 0] = caught;
    };
    this.get_caught = function () {
      return HEAP8[(this.ptr + 12) >> 0] != 0;
    };
    this.set_rethrown = function (rethrown) {
      rethrown = rethrown ? 1 : 0;
      HEAP8[(this.ptr + 13) >> 0] = rethrown;
    };
    this.get_rethrown = function () {
      return HEAP8[(this.ptr + 13) >> 0] != 0;
    };
    this.init = function (type, destructor) {
      this.set_adjusted_ptr(0);
      this.set_type(type);
      this.set_destructor(destructor);
      this.set_refcount(0);
      this.set_caught(false);
      this.set_rethrown(false);
    };
    this.add_ref = function () {
      let value = HEAP32[this.ptr >> 2];
      HEAP32[this.ptr >> 2] = value + 1;
    };
    this.release_ref = function () {
      let prev = HEAP32[this.ptr >> 2];
      HEAP32[this.ptr >> 2] = prev - 1;
      return prev === 1;
    };
    this.set_adjusted_ptr = function (adjustedPtr) {
      HEAPU32[(this.ptr + 16) >> 2] = adjustedPtr;
    };
    this.get_adjusted_ptr = function () {
      return HEAPU32[(this.ptr + 16) >> 2];
    };
    this.get_exception_ptr = function () {
      let isPointer = ___cxa_is_pointer_type(this.get_type());
      if (isPointer) {
        return HEAPU32[this.excPtr >> 2];
      }
      let adjusted = this.get_adjusted_ptr();
      if (adjusted !== 0) return adjusted;
      return this.excPtr;
    };
  }
  let exceptionLast = 0;
  let uncaughtExceptionCount = 0;
  function ___cxa_throw(ptr, type, destructor) {
    let info = new ExceptionInfo(ptr);
    info.init(type, destructor);
    exceptionLast = ptr;
    uncaughtExceptionCount++;
    throw ptr;
  }
  function _abort() {
    abort("");
  }
  function getHeapMax() {
    return 2147483648;
  }
  function emscripten_realloc_buffer(size) {
    try {
      wasmMemory.grow((size - buffer.byteLength + 65535) >>> 16);
      updateGlobalBufferAndViews(wasmMemory.buffer);
      return 1;
    } catch (e) {}
  }
  function _emscripten_resize_heap(requestedSize) {
    let oldSize = HEAPU8.length;
    requestedSize = requestedSize >>> 0;
    let maxHeapSize = getHeapMax();
    if (requestedSize > maxHeapSize) {
      return false;
    }
    let alignUp = (x, multiple) => x + ((multiple - (x % multiple)) % multiple);
    for (let cutDown = 1; cutDown <= 4; cutDown *= 2) {
      let overGrownHeapSize = oldSize * (1 + 0.2 / cutDown);
      overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
      let newSize = Math.min(
        maxHeapSize,
        alignUp(Math.max(requestedSize, overGrownHeapSize), 65536),
      );
      let replacement = emscripten_realloc_buffer(newSize);
      if (replacement) {
        return true;
      }
    }
    return false;
  }
  let ENV = {};
  function getExecutableName() {
    return thisProgram || "./this.program";
  }
  function getEnvStrings() {
    if (!getEnvStrings.strings) {
      let lang =
        (
          (typeof navigator === "object" && navigator.languages && navigator.languages[0]) ||
          "C"
        ).replace("-", "_") + ".UTF-8";
      let env = {
        USER: "web_user",
        LOGNAME: "web_user",
        PATH: "/",
        PWD: "/",
        HOME: "/home/web_user",
        LANG: lang,
        _: getExecutableName(),
      };
      for (var x in ENV) {
        if (ENV[x] === undefined) delete env[x];
        else env[x] = ENV[x];
      }
      let strings = [];
      for (var x in env) {
        strings.push(x + "=" + env[x]);
      }
      getEnvStrings.strings = strings;
    }
    return getEnvStrings.strings;
  }
  function writeAsciiToMemory(str, buffer, dontAddNull) {
    for (let i = 0; i < str.length; ++i) {
      HEAP8[buffer++ >> 0] = str.charCodeAt(i);
    }
    if (!dontAddNull) HEAP8[buffer >> 0] = 0;
  }
  var PATH = {
    isAbs: (path) => path.charAt(0) === "/",
    splitPath: (filename) => {
      let splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
      return splitPathRe.exec(filename).slice(1);
    },
    normalizeArray: (parts, allowAboveRoot) => {
      let up = 0;
      for (let i = parts.length - 1; i >= 0; i--) {
        let last = parts[i];
        if (last === ".") {
          parts.splice(i, 1);
        } else if (last === "..") {
          parts.splice(i, 1);
          up++;
        } else if (up) {
          parts.splice(i, 1);
          up--;
        }
      }
      if (allowAboveRoot) {
        for (; up; up--) {
          parts.unshift("..");
        }
      }
      return parts;
    },
    normalize: (path) => {
      let isAbsolute = PATH.isAbs(path),
        trailingSlash = path.substr(-1) === "/";
      path = PATH.normalizeArray(
        path.split("/").filter((p) => !!p),
        !isAbsolute,
      ).join("/");
      if (!path && !isAbsolute) {
        path = ".";
      }
      if (path && trailingSlash) {
        path += "/";
      }
      return (isAbsolute ? "/" : "") + path;
    },
    dirname: (path) => {
      let result = PATH.splitPath(path),
        root = result[0],
        dir = result[1];
      if (!root && !dir) {
        return ".";
      }
      if (dir) {
        dir = dir.substr(0, dir.length - 1);
      }
      return root + dir;
    },
    basename: (path) => {
      if (path === "/") return "/";
      path = PATH.normalize(path);
      path = path.replace(/\/$/, "");
      let lastSlash = path.lastIndexOf("/");
      if (lastSlash === -1) return path;
      return path.substr(lastSlash + 1);
    },
    join() {
      let paths = Array.prototype.slice.call(arguments);
      return PATH.normalize(paths.join("/"));
    },
    join2: (l, r) => {
      return PATH.normalize(l + "/" + r);
    },
  };
  function getRandomDevice() {
    if (typeof crypto === "object" && typeof crypto["getRandomValues"] === "function") {
      let randomBuffer = new Uint8Array(1);
      return () => {
        crypto.getRandomValues(randomBuffer);
        return randomBuffer[0];
      };
    } else if (ENVIRONMENT_IS_NODE) {
      try {
        let crypto_module = require("crypto");
        return () => crypto_module["randomBytes"](1)[0];
      } catch (e) {}
    }
    return () => abort("randomDevice");
  }
  var PATH_FS = {
    resolve() {
      let resolvedPath = "",
        resolvedAbsolute = false;
      for (let i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
        let path = i >= 0 ? arguments[i] : FS.cwd();
        if (typeof path !== "string") {
          throw new TypeError("Arguments to path.resolve must be strings");
        } else if (!path) {
          return "";
        }
        resolvedPath = path + "/" + resolvedPath;
        resolvedAbsolute = PATH.isAbs(path);
      }
      resolvedPath = PATH.normalizeArray(
        resolvedPath.split("/").filter((p) => !!p),
        !resolvedAbsolute,
      ).join("/");
      return (resolvedAbsolute ? "/" : "") + resolvedPath || ".";
    },
    relative: (from, to) => {
      from = PATH_FS.resolve(from).substr(1);
      to = PATH_FS.resolve(to).substr(1);
      function trim(arr) {
        let start = 0;
        for (; start < arr.length; start++) {
          if (arr[start] !== "") break;
        }
        let end = arr.length - 1;
        for (; end >= 0; end--) {
          if (arr[end] !== "") break;
        }
        if (start > end) return [];
        return arr.slice(start, end - start + 1);
      }
      let fromParts = trim(from.split("/"));
      let toParts = trim(to.split("/"));
      let length = Math.min(fromParts.length, toParts.length);
      let samePartsLength = length;
      for (var i = 0; i < length; i++) {
        if (fromParts[i] !== toParts[i]) {
          samePartsLength = i;
          break;
        }
      }
      let outputParts = [];
      for (var i = samePartsLength; i < fromParts.length; i++) {
        outputParts.push("..");
      }
      outputParts = outputParts.concat(toParts.slice(samePartsLength));
      return outputParts.join("/");
    },
  };
  function intArrayFromString(stringy, dontAddNull, length) {
    let len = length > 0 ? length : lengthBytesUTF8(stringy) + 1;
    let u8array = new Array(len);
    let numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length);
    if (dontAddNull) u8array.length = numBytesWritten;
    return u8array;
  }
  var TTY = {
    ttys: [],
    init() {},
    shutdown() {},
    register(dev, ops) {
      TTY.ttys[dev] = { input: [], output: [], ops };
      FS.registerDevice(dev, TTY.stream_ops);
    },
    stream_ops: {
      open(stream) {
        let tty = TTY.ttys[stream.node.rdev];
        if (!tty) {
          throw new FS.ErrnoError(43);
        }
        stream.tty = tty;
        stream.seekable = false;
      },
      close(stream) {
        stream.tty.ops.fsync(stream.tty);
      },
      fsync(stream) {
        stream.tty.ops.fsync(stream.tty);
      },
      read(stream, buffer, offset, length, pos) {
        if (!stream.tty || !stream.tty.ops.get_char) {
          throw new FS.ErrnoError(60);
        }
        let bytesRead = 0;
        for (let i = 0; i < length; i++) {
          var result;
          try {
            result = stream.tty.ops.get_char(stream.tty);
          } catch (e) {
            throw new FS.ErrnoError(29);
          }
          if (result === undefined && bytesRead === 0) {
            throw new FS.ErrnoError(6);
          }
          if (result === null || result === undefined) break;
          bytesRead++;
          buffer[offset + i] = result;
        }
        if (bytesRead) {
          stream.node.timestamp = Date.now();
        }
        return bytesRead;
      },
      write(stream, buffer, offset, length, pos) {
        if (!stream.tty || !stream.tty.ops.put_char) {
          throw new FS.ErrnoError(60);
        }
        try {
          for (var i = 0; i < length; i++) {
            stream.tty.ops.put_char(stream.tty, buffer[offset + i]);
          }
        } catch (e) {
          throw new FS.ErrnoError(29);
        }
        if (length) {
          stream.node.timestamp = Date.now();
        }
        return i;
      },
    },
    default_tty_ops: {
      get_char(tty) {
        if (!tty.input.length) {
          let result = null;
          if (ENVIRONMENT_IS_NODE) {
            let BUFSIZE = 256;
            let buf = Buffer.alloc(BUFSIZE);
            let bytesRead = 0;
            try {
              bytesRead = fs.readSync(process.stdin.fd, buf, 0, BUFSIZE, -1);
            } catch (e) {
              if (e.toString().includes("EOF")) bytesRead = 0;
              else throw e;
            }
            if (bytesRead > 0) {
              result = buf.slice(0, bytesRead).toString("utf-8");
            } else {
              result = null;
            }
          } else if (typeof window !== "undefined" && typeof window.prompt === "function") {
            result = window.prompt("Input: ");
            if (result !== null) {
              result += "\n";
            }
          } else if (typeof readline === "function") {
            result = readline();
            if (result !== null) {
              result += "\n";
            }
          }
          if (!result) {
            return null;
          }
          tty.input = intArrayFromString(result, true);
        }
        return tty.input.shift();
      },
      put_char(tty, val) {
        if (val === null || val === 10) {
          out(UTF8ArrayToString(tty.output, 0));
          tty.output = [];
        } else {
          if (val != 0) tty.output.push(val);
        }
      },
      fsync(tty) {
        if (tty.output && tty.output.length > 0) {
          out(UTF8ArrayToString(tty.output, 0));
          tty.output = [];
        }
      },
    },
    default_tty1_ops: {
      put_char(tty, val) {
        if (val === null || val === 10) {
          err(UTF8ArrayToString(tty.output, 0));
          tty.output = [];
        } else {
          if (val != 0) tty.output.push(val);
        }
      },
      fsync(tty) {
        if (tty.output && tty.output.length > 0) {
          err(UTF8ArrayToString(tty.output, 0));
          tty.output = [];
        }
      },
    },
  };
  function mmapAlloc(size) {
    abort();
  }
  var MEMFS = {
    ops_table: null,
    mount(mount) {
      return MEMFS.createNode(null, "/", 16384 | 511, 0);
    },
    createNode(parent, name, mode, dev) {
      if (FS.isBlkdev(mode) || FS.isFIFO(mode)) {
        throw new FS.ErrnoError(63);
      }
      if (!MEMFS.ops_table) {
        MEMFS.ops_table = {
          dir: {
            node: {
              getattr: MEMFS.node_ops.getattr,
              setattr: MEMFS.node_ops.setattr,
              lookup: MEMFS.node_ops.lookup,
              mknod: MEMFS.node_ops.mknod,
              rename: MEMFS.node_ops.rename,
              unlink: MEMFS.node_ops.unlink,
              rmdir: MEMFS.node_ops.rmdir,
              readdir: MEMFS.node_ops.readdir,
              symlink: MEMFS.node_ops.symlink,
            },
            stream: { llseek: MEMFS.stream_ops.llseek },
          },
          file: {
            node: { getattr: MEMFS.node_ops.getattr, setattr: MEMFS.node_ops.setattr },
            stream: {
              llseek: MEMFS.stream_ops.llseek,
              read: MEMFS.stream_ops.read,
              write: MEMFS.stream_ops.write,
              allocate: MEMFS.stream_ops.allocate,
              mmap: MEMFS.stream_ops.mmap,
              msync: MEMFS.stream_ops.msync,
            },
          },
          link: {
            node: {
              getattr: MEMFS.node_ops.getattr,
              setattr: MEMFS.node_ops.setattr,
              readlink: MEMFS.node_ops.readlink,
            },
            stream: {},
          },
          chrdev: {
            node: { getattr: MEMFS.node_ops.getattr, setattr: MEMFS.node_ops.setattr },
            stream: FS.chrdev_stream_ops,
          },
        };
      }
      let node = FS.createNode(parent, name, mode, dev);
      if (FS.isDir(node.mode)) {
        node.node_ops = MEMFS.ops_table.dir.node;
        node.stream_ops = MEMFS.ops_table.dir.stream;
        node.contents = {};
      } else if (FS.isFile(node.mode)) {
        node.node_ops = MEMFS.ops_table.file.node;
        node.stream_ops = MEMFS.ops_table.file.stream;
        node.usedBytes = 0;
        node.contents = null;
      } else if (FS.isLink(node.mode)) {
        node.node_ops = MEMFS.ops_table.link.node;
        node.stream_ops = MEMFS.ops_table.link.stream;
      } else if (FS.isChrdev(node.mode)) {
        node.node_ops = MEMFS.ops_table.chrdev.node;
        node.stream_ops = MEMFS.ops_table.chrdev.stream;
      }
      node.timestamp = Date.now();
      if (parent) {
        parent.contents[name] = node;
        parent.timestamp = node.timestamp;
      }
      return node;
    },
    getFileDataAsTypedArray(node) {
      if (!node.contents) return new Uint8Array(0);
      if (node.contents.subarray) return node.contents.subarray(0, node.usedBytes);
      return new Uint8Array(node.contents);
    },
    expandFileStorage(node, newCapacity) {
      let prevCapacity = node.contents ? node.contents.length : 0;
      if (prevCapacity >= newCapacity) return;
      let CAPACITY_DOUBLING_MAX = 1024 * 1024;
      newCapacity = Math.max(
        newCapacity,
        (prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2 : 1.125)) >>> 0,
      );
      if (prevCapacity != 0) newCapacity = Math.max(newCapacity, 256);
      let oldContents = node.contents;
      node.contents = new Uint8Array(newCapacity);
      if (node.usedBytes > 0) node.contents.set(oldContents.subarray(0, node.usedBytes), 0);
    },
    resizeFileStorage(node, newSize) {
      if (node.usedBytes == newSize) return;
      if (newSize == 0) {
        node.contents = null;
        node.usedBytes = 0;
      } else {
        let oldContents = node.contents;
        node.contents = new Uint8Array(newSize);
        if (oldContents) {
          node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes)));
        }
        node.usedBytes = newSize;
      }
    },
    node_ops: {
      getattr(node) {
        let attr = {};
        attr.dev = FS.isChrdev(node.mode) ? node.id : 1;
        attr.ino = node.id;
        attr.mode = node.mode;
        attr.nlink = 1;
        attr.uid = 0;
        attr.gid = 0;
        attr.rdev = node.rdev;
        if (FS.isDir(node.mode)) {
          attr.size = 4096;
        } else if (FS.isFile(node.mode)) {
          attr.size = node.usedBytes;
        } else if (FS.isLink(node.mode)) {
          attr.size = node.link.length;
        } else {
          attr.size = 0;
        }
        attr.atime = new Date(node.timestamp);
        attr.mtime = new Date(node.timestamp);
        attr.ctime = new Date(node.timestamp);
        attr.blksize = 4096;
        attr.blocks = Math.ceil(attr.size / attr.blksize);
        return attr;
      },
      setattr(node, attr) {
        if (attr.mode !== undefined) {
          node.mode = attr.mode;
        }
        if (attr.timestamp !== undefined) {
          node.timestamp = attr.timestamp;
        }
        if (attr.size !== undefined) {
          MEMFS.resizeFileStorage(node, attr.size);
        }
      },
      lookup(parent, name) {
        throw FS.genericErrors[44];
      },
      mknod(parent, name, mode, dev) {
        return MEMFS.createNode(parent, name, mode, dev);
      },
      rename(old_node, new_dir, new_name) {
        if (FS.isDir(old_node.mode)) {
          let new_node;
          try {
            new_node = FS.lookupNode(new_dir, new_name);
          } catch (e) {}
          if (new_node) {
            for (let i in new_node.contents) {
              throw new FS.ErrnoError(55);
            }
          }
        }
        delete old_node.parent.contents[old_node.name];
        old_node.parent.timestamp = Date.now();
        old_node.name = new_name;
        new_dir.contents[new_name] = old_node;
        new_dir.timestamp = old_node.parent.timestamp;
        old_node.parent = new_dir;
      },
      unlink(parent, name) {
        delete parent.contents[name];
        parent.timestamp = Date.now();
      },
      rmdir(parent, name) {
        let node = FS.lookupNode(parent, name);
        for (let i in node.contents) {
          throw new FS.ErrnoError(55);
        }
        delete parent.contents[name];
        parent.timestamp = Date.now();
      },
      readdir(node) {
        let entries = [".", ".."];
        for (let key in node.contents) {
          if (!node.contents.hasOwnProperty(key)) {
            continue;
          }
          entries.push(key);
        }
        return entries;
      },
      symlink(parent, newname, oldpath) {
        let node = MEMFS.createNode(parent, newname, 511 | 40960, 0);
        node.link = oldpath;
        return node;
      },
      readlink(node) {
        if (!FS.isLink(node.mode)) {
          throw new FS.ErrnoError(28);
        }
        return node.link;
      },
    },
    stream_ops: {
      read(stream, buffer, offset, length, position) {
        let contents = stream.node.contents;
        if (position >= stream.node.usedBytes) return 0;
        let size = Math.min(stream.node.usedBytes - position, length);
        if (size > 8 && contents.subarray) {
          buffer.set(contents.subarray(position, position + size), offset);
        } else {
          for (let i = 0; i < size; i++) buffer[offset + i] = contents[position + i];
        }
        return size;
      },
      write(stream, buffer, offset, length, position, canOwn) {
        if (buffer.buffer === HEAP8.buffer) {
          canOwn = false;
        }
        if (!length) return 0;
        let node = stream.node;
        node.timestamp = Date.now();
        if (buffer.subarray && (!node.contents || node.contents.subarray)) {
          if (canOwn) {
            node.contents = buffer.subarray(offset, offset + length);
            node.usedBytes = length;
            return length;
          } else if (node.usedBytes === 0 && position === 0) {
            node.contents = buffer.slice(offset, offset + length);
            node.usedBytes = length;
            return length;
          } else if (position + length <= node.usedBytes) {
            node.contents.set(buffer.subarray(offset, offset + length), position);
            return length;
          }
        }
        MEMFS.expandFileStorage(node, position + length);
        if (node.contents.subarray && buffer.subarray) {
          node.contents.set(buffer.subarray(offset, offset + length), position);
        } else {
          for (let i = 0; i < length; i++) {
            node.contents[position + i] = buffer[offset + i];
          }
        }
        node.usedBytes = Math.max(node.usedBytes, position + length);
        return length;
      },
      llseek(stream, offset, whence) {
        let position = offset;
        if (whence === 1) {
          position += stream.position;
        } else if (whence === 2) {
          if (FS.isFile(stream.node.mode)) {
            position += stream.node.usedBytes;
          }
        }
        if (position < 0) {
          throw new FS.ErrnoError(28);
        }
        return position;
      },
      allocate(stream, offset, length) {
        MEMFS.expandFileStorage(stream.node, offset + length);
        stream.node.usedBytes = Math.max(stream.node.usedBytes, offset + length);
      },
      mmap(stream, length, position, prot, flags) {
        if (!FS.isFile(stream.node.mode)) {
          throw new FS.ErrnoError(43);
        }
        let ptr;
        let allocated;
        let contents = stream.node.contents;
        if (!(flags & 2) && contents.buffer === buffer) {
          allocated = false;
          ptr = contents.byteOffset;
        } else {
          if (position > 0 || position + length < contents.length) {
            if (contents.subarray) {
              contents = contents.subarray(position, position + length);
            } else {
              contents = Array.prototype.slice.call(contents, position, position + length);
            }
          }
          allocated = true;
          ptr = mmapAlloc(length);
          if (!ptr) {
            throw new FS.ErrnoError(48);
          }
          HEAP8.set(contents, ptr);
        }
        return { ptr, allocated };
      },
      msync(stream, buffer, offset, length, mmapFlags) {
        MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false);
        return 0;
      },
    },
  };
  function asyncLoad(url, onload, onerror, noRunDep) {
    let dep = !noRunDep ? getUniqueRunDependency("al " + url) : "";
    readAsync(
      url,
      (arrayBuffer) => {
        assert(arrayBuffer, 'Loading data file "' + url + '" failed (no arrayBuffer).');
        onload(new Uint8Array(arrayBuffer));
        if (dep) removeRunDependency(dep);
      },
      (event) => {
        if (onerror) {
          onerror();
        } else {
          throw 'Loading data file "' + url + '" failed.';
        }
      },
    );
    if (dep) addRunDependency(dep);
  }
  var FS = {
    root: null,
    mounts: [],
    devices: {},
    streams: [],
    nextInode: 1,
    nameTable: null,
    currentPath: "/",
    initialized: false,
    ignorePermissions: true,
    ErrnoError: null,
    genericErrors: {},
    filesystems: null,
    syncFSRequests: 0,
    lookupPath: (path, opts = {}) => {
      path = PATH_FS.resolve(FS.cwd(), path);
      if (!path) return { path: "", node: null };
      let defaults = { follow_mount: true, recurse_count: 0 };
      opts = Object.assign(defaults, opts);
      if (opts.recurse_count > 8) {
        throw new FS.ErrnoError(32);
      }
      let parts = PATH.normalizeArray(
        path.split("/").filter((p) => !!p),
        false,
      );
      let current = FS.root;
      let current_path = "/";
      for (let i = 0; i < parts.length; i++) {
        let islast = i === parts.length - 1;
        if (islast && opts.parent) {
          break;
        }
        current = FS.lookupNode(current, parts[i]);
        current_path = PATH.join2(current_path, parts[i]);
        if (FS.isMountpoint(current)) {
          if (!islast || (islast && opts.follow_mount)) {
            current = current.mounted.root;
          }
        }
        if (!islast || opts.follow) {
          let count = 0;
          while (FS.isLink(current.mode)) {
            let link = FS.readlink(current_path);
            current_path = PATH_FS.resolve(PATH.dirname(current_path), link);
            let lookup = FS.lookupPath(current_path, { recurse_count: opts.recurse_count + 1 });
            current = lookup.node;
            if (count++ > 40) {
              throw new FS.ErrnoError(32);
            }
          }
        }
      }
      return { path: current_path, node: current };
    },
    getPath: (node) => {
      let path;
      while (true) {
        if (FS.isRoot(node)) {
          let mount = node.mount.mountpoint;
          if (!path) return mount;
          return mount[mount.length - 1] !== "/" ? mount + "/" + path : mount + path;
        }
        path = path ? node.name + "/" + path : node.name;
        node = node.parent;
      }
    },
    hashName: (parentid, name) => {
      let hash = 0;
      for (let i = 0; i < name.length; i++) {
        hash = ((hash << 5) - hash + name.charCodeAt(i)) | 0;
      }
      return ((parentid + hash) >>> 0) % FS.nameTable.length;
    },
    hashAddNode: (node) => {
      let hash = FS.hashName(node.parent.id, node.name);
      node.name_next = FS.nameTable[hash];
      FS.nameTable[hash] = node;
    },
    hashRemoveNode: (node) => {
      let hash = FS.hashName(node.parent.id, node.name);
      if (FS.nameTable[hash] === node) {
        FS.nameTable[hash] = node.name_next;
      } else {
        let current = FS.nameTable[hash];
        while (current) {
          if (current.name_next === node) {
            current.name_next = node.name_next;
            break;
          }
          current = current.name_next;
        }
      }
    },
    lookupNode: (parent, name) => {
      let errCode = FS.mayLookup(parent);
      if (errCode) {
        throw new FS.ErrnoError(errCode, parent);
      }
      let hash = FS.hashName(parent.id, name);
      for (let node = FS.nameTable[hash]; node; node = node.name_next) {
        let nodeName = node.name;
        if (node.parent.id === parent.id && nodeName === name) {
          return node;
        }
      }
      return FS.lookup(parent, name);
    },
    createNode: (parent, name, mode, rdev) => {
      let node = new FS.FSNode(parent, name, mode, rdev);
      FS.hashAddNode(node);
      return node;
    },
    destroyNode: (node) => {
      FS.hashRemoveNode(node);
    },
    isRoot: (node) => {
      return node === node.parent;
    },
    isMountpoint: (node) => {
      return !!node.mounted;
    },
    isFile: (mode) => {
      return (mode & 61440) === 32768;
    },
    isDir: (mode) => {
      return (mode & 61440) === 16384;
    },
    isLink: (mode) => {
      return (mode & 61440) === 40960;
    },
    isChrdev: (mode) => {
      return (mode & 61440) === 8192;
    },
    isBlkdev: (mode) => {
      return (mode & 61440) === 24576;
    },
    isFIFO: (mode) => {
      return (mode & 61440) === 4096;
    },
    isSocket: (mode) => {
      return (mode & 49152) === 49152;
    },
    flagModes: { r: 0, "r+": 2, w: 577, "w+": 578, a: 1089, "a+": 1090 },
    modeStringToFlags: (str) => {
      let flags = FS.flagModes[str];
      if (typeof flags === "undefined") {
        throw new Error("Unknown file open mode: " + str);
      }
      return flags;
    },
    flagsToPermissionString: (flag) => {
      let perms = ["r", "w", "rw"][flag & 3];
      if (flag & 512) {
        perms += "w";
      }
      return perms;
    },
    nodePermissions: (node, perms) => {
      if (FS.ignorePermissions) {
        return 0;
      }
      if (perms.includes("r") && !(node.mode & 292)) {
        return 2;
      } else if (perms.includes("w") && !(node.mode & 146)) {
        return 2;
      } else if (perms.includes("x") && !(node.mode & 73)) {
        return 2;
      }
      return 0;
    },
    mayLookup: (dir) => {
      let errCode = FS.nodePermissions(dir, "x");
      if (errCode) return errCode;
      if (!dir.node_ops.lookup) return 2;
      return 0;
    },
    mayCreate: (dir, name) => {
      try {
        let node = FS.lookupNode(dir, name);
        return 20;
      } catch (e) {}
      return FS.nodePermissions(dir, "wx");
    },
    mayDelete: (dir, name, isdir) => {
      let node;
      try {
        node = FS.lookupNode(dir, name);
      } catch (e) {
        return e.errno;
      }
      let errCode = FS.nodePermissions(dir, "wx");
      if (errCode) {
        return errCode;
      }
      if (isdir) {
        if (!FS.isDir(node.mode)) {
          return 54;
        }
        if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) {
          return 10;
        }
      } else {
        if (FS.isDir(node.mode)) {
          return 31;
        }
      }
      return 0;
    },
    mayOpen: (node, flags) => {
      if (!node) {
        return 44;
      }
      if (FS.isLink(node.mode)) {
        return 32;
      } else if (FS.isDir(node.mode)) {
        if (FS.flagsToPermissionString(flags) !== "r" || flags & 512) {
          return 31;
        }
      }
      return FS.nodePermissions(node, FS.flagsToPermissionString(flags));
    },
    MAX_OPEN_FDS: 4096,
    nextfd: (fd_start = 0, fd_end = FS.MAX_OPEN_FDS) => {
      for (let fd = fd_start; fd <= fd_end; fd++) {
        if (!FS.streams[fd]) {
          return fd;
        }
      }
      throw new FS.ErrnoError(33);
    },
    getStream: (fd) => FS.streams[fd],
    createStream: (stream, fd_start, fd_end) => {
      if (!FS.FSStream) {
        FS.FSStream = function () {
          this.shared = {};
        };
        FS.FSStream.prototype = {};
        Object.defineProperties(FS.FSStream.prototype, {
          object: {
            get() {
              return this.node;
            },
            set(val) {
              this.node = val;
            },
          },
          isRead: {
            get() {
              return (this.flags & 2097155) !== 1;
            },
          },
          isWrite: {
            get() {
              return (this.flags & 2097155) !== 0;
            },
          },
          isAppend: {
            get() {
              return this.flags & 1024;
            },
          },
          flags: {
            get() {
              return this.shared.flags;
            },
            set(val) {
              this.shared.flags = val;
            },
          },
          position: {
            get() {
              return this.shared.position;
            },
            set(val) {
              this.shared.position = val;
            },
          },
        });
      }
      stream = Object.assign(new FS.FSStream(), stream);
      let fd = FS.nextfd(fd_start, fd_end);
      stream.fd = fd;
      FS.streams[fd] = stream;
      return stream;
    },
    closeStream: (fd) => {
      FS.streams[fd] = null;
    },
    chrdev_stream_ops: {
      open: (stream) => {
        let device = FS.getDevice(stream.node.rdev);
        stream.stream_ops = device.stream_ops;
        if (stream.stream_ops.open) {
          stream.stream_ops.open(stream);
        }
      },
      llseek: () => {
        throw new FS.ErrnoError(70);
      },
    },
    major: (dev) => dev >> 8,
    minor: (dev) => dev & 255,
    makedev: (ma, mi) => (ma << 8) | mi,
    registerDevice: (dev, ops) => {
      FS.devices[dev] = { stream_ops: ops };
    },
    getDevice: (dev) => FS.devices[dev],
    getMounts: (mount) => {
      let mounts = [];
      let check = [mount];
      while (check.length) {
        let m = check.pop();
        mounts.push(m);
        check.push.apply(check, m.mounts);
      }
      return mounts;
    },
    syncfs: (populate, callback) => {
      if (typeof populate === "function") {
        callback = populate;
        populate = false;
      }
      FS.syncFSRequests++;
      if (FS.syncFSRequests > 1) {
        err(
          "warning: " +
            FS.syncFSRequests +
            " FS.syncfs operations in flight at once, probably just doing extra work",
        );
      }
      let mounts = FS.getMounts(FS.root.mount);
      let completed = 0;
      function doCallback(errCode) {
        FS.syncFSRequests--;
        return callback(errCode);
      }
      function done(errCode) {
        if (errCode) {
          if (!done.errored) {
            done.errored = true;
            return doCallback(errCode);
          }
          return;
        }
        if (++completed >= mounts.length) {
          doCallback(null);
        }
      }
      mounts.forEach((mount) => {
        if (!mount.type.syncfs) {
          return done(null);
        }
        mount.type.syncfs(mount, populate, done);
      });
    },
    mount: (type, opts, mountpoint) => {
      let root = mountpoint === "/";
      let pseudo = !mountpoint;
      let node;
      if (root && FS.root) {
        throw new FS.ErrnoError(10);
      } else if (!root && !pseudo) {
        let lookup = FS.lookupPath(mountpoint, { follow_mount: false });
        mountpoint = lookup.path;
        node = lookup.node;
        if (FS.isMountpoint(node)) {
          throw new FS.ErrnoError(10);
        }
        if (!FS.isDir(node.mode)) {
          throw new FS.ErrnoError(54);
        }
      }
      let mount = { type, opts, mountpoint, mounts: [] };
      let mountRoot = type.mount(mount);
      mountRoot.mount = mount;
      mount.root = mountRoot;
      if (root) {
        FS.root = mountRoot;
      } else if (node) {
        node.mounted = mount;
        if (node.mount) {
          node.mount.mounts.push(mount);
        }
      }
      return mountRoot;
    },
    unmount: (mountpoint) => {
      let lookup = FS.lookupPath(mountpoint, { follow_mount: false });
      if (!FS.isMountpoint(lookup.node)) {
        throw new FS.ErrnoError(28);
      }
      let node = lookup.node;
      let mount = node.mounted;
      let mounts = FS.getMounts(mount);
      Object.keys(FS.nameTable).forEach((hash) => {
        let current = FS.nameTable[hash];
        while (current) {
          let next = current.name_next;
          if (mounts.includes(current.mount)) {
            FS.destroyNode(current);
          }
          current = next;
        }
      });
      node.mounted = null;
      let idx = node.mount.mounts.indexOf(mount);
      node.mount.mounts.splice(idx, 1);
    },
    lookup: (parent, name) => {
      return parent.node_ops.lookup(parent, name);
    },
    mknod: (path, mode, dev) => {
      let lookup = FS.lookupPath(path, { parent: true });
      let parent = lookup.node;
      let name = PATH.basename(path);
      if (!name || name === "." || name === "..") {
        throw new FS.ErrnoError(28);
      }
      let errCode = FS.mayCreate(parent, name);
      if (errCode) {
        throw new FS.ErrnoError(errCode);
      }
      if (!parent.node_ops.mknod) {
        throw new FS.ErrnoError(63);
      }
      return parent.node_ops.mknod(parent, name, mode, dev);
    },
    create: (path, mode) => {
      mode = mode !== undefined ? mode : 438;
      mode &= 4095;
      mode |= 32768;
      return FS.mknod(path, mode, 0);
    },
    mkdir: (path, mode) => {
      mode = mode !== undefined ? mode : 511;
      mode &= 511 | 512;
      mode |= 16384;
      return FS.mknod(path, mode, 0);
    },
    mkdirTree: (path, mode) => {
      let dirs = path.split("/");
      let d = "";
      for (let i = 0; i < dirs.length; ++i) {
        if (!dirs[i]) continue;
        d += "/" + dirs[i];
        try {
          FS.mkdir(d, mode);
        } catch (e) {
          if (e.errno != 20) throw e;
        }
      }
    },
    mkdev: (path, mode, dev) => {
      if (typeof dev === "undefined") {
        dev = mode;
        mode = 438;
      }
      mode |= 8192;
      return FS.mknod(path, mode, dev);
    },
    symlink: (oldpath, newpath) => {
      if (!PATH_FS.resolve(oldpath)) {
        throw new FS.ErrnoError(44);
      }
      let lookup = FS.lookupPath(newpath, { parent: true });
      let parent = lookup.node;
      if (!parent) {
        throw new FS.ErrnoError(44);
      }
      let newname = PATH.basename(newpath);
      let errCode = FS.mayCreate(parent, newname);
      if (errCode) {
        throw new FS.ErrnoError(errCode);
      }
      if (!parent.node_ops.symlink) {
        throw new FS.ErrnoError(63);
      }
      return parent.node_ops.symlink(parent, newname, oldpath);
    },
    rename: (old_path, new_path) => {
      let old_dirname = PATH.dirname(old_path);
      let new_dirname = PATH.dirname(new_path);
      let old_name = PATH.basename(old_path);
      let new_name = PATH.basename(new_path);
      let lookup, old_dir, new_dir;
      lookup = FS.lookupPath(old_path, { parent: true });
      old_dir = lookup.node;
      lookup = FS.lookupPath(new_path, { parent: true });
      new_dir = lookup.node;
      if (!old_dir || !new_dir) throw new FS.ErrnoError(44);
      if (old_dir.mount !== new_dir.mount) {
        throw new FS.ErrnoError(75);
      }
      let old_node = FS.lookupNode(old_dir, old_name);
      let relative = PATH_FS.relative(old_path, new_dirname);
      if (relative.charAt(0) !== ".") {
        throw new FS.ErrnoError(28);
      }
      relative = PATH_FS.relative(new_path, old_dirname);
      if (relative.charAt(0) !== ".") {
        throw new FS.ErrnoError(55);
      }
      let new_node;
      try {
        new_node = FS.lookupNode(new_dir, new_name);
      } catch (e) {}
      if (old_node === new_node) {
        return;
      }
      let isdir = FS.isDir(old_node.mode);
      let errCode = FS.mayDelete(old_dir, old_name, isdir);
      if (errCode) {
        throw new FS.ErrnoError(errCode);
      }
      errCode = new_node ? FS.mayDelete(new_dir, new_name, isdir) : FS.mayCreate(new_dir, new_name);
      if (errCode) {
        throw new FS.ErrnoError(errCode);
      }
      if (!old_dir.node_ops.rename) {
        throw new FS.ErrnoError(63);
      }
      if (FS.isMountpoint(old_node) || (new_node && FS.isMountpoint(new_node))) {
        throw new FS.ErrnoError(10);
      }
      if (new_dir !== old_dir) {
        errCode = FS.nodePermissions(old_dir, "w");
        if (errCode) {
          throw new FS.ErrnoError(errCode);
        }
      }
      FS.hashRemoveNode(old_node);
      try {
        old_dir.node_ops.rename(old_node, new_dir, new_name);
      } catch (e) {
        throw e;
      } finally {
        FS.hashAddNode(old_node);
      }
    },
    rmdir: (path) => {
      let lookup = FS.lookupPath(path, { parent: true });
      let parent = lookup.node;
      let name = PATH.basename(path);
      let node = FS.lookupNode(parent, name);
      let errCode = FS.mayDelete(parent, name, true);
      if (errCode) {
        throw new FS.ErrnoError(errCode);
      }
      if (!parent.node_ops.rmdir) {
        throw new FS.ErrnoError(63);
      }
      if (FS.isMountpoint(node)) {
        throw new FS.ErrnoError(10);
      }
      parent.node_ops.rmdir(parent, name);
      FS.destroyNode(node);
    },
    readdir: (path) => {
      let lookup = FS.lookupPath(path, { follow: true });
      let node = lookup.node;
      if (!node.node_ops.readdir) {
        throw new FS.ErrnoError(54);
      }
      return node.node_ops.readdir(node);
    },
    unlink: (path) => {
      let lookup = FS.lookupPath(path, { parent: true });
      let parent = lookup.node;
      if (!parent) {
        throw new FS.ErrnoError(44);
      }
      let name = PATH.basename(path);
      let node = FS.lookupNode(parent, name);
      let errCode = FS.mayDelete(parent, name, false);
      if (errCode) {
        throw new FS.ErrnoError(errCode);
      }
      if (!parent.node_ops.unlink) {
        throw new FS.ErrnoError(63);
      }
      if (FS.isMountpoint(node)) {
        throw new FS.ErrnoError(10);
      }
      parent.node_ops.unlink(parent, name);
      FS.destroyNode(node);
    },
    readlink: (path) => {
      let lookup = FS.lookupPath(path);
      let link = lookup.node;
      if (!link) {
        throw new FS.ErrnoError(44);
      }
      if (!link.node_ops.readlink) {
        throw new FS.ErrnoError(28);
      }
      return PATH_FS.resolve(FS.getPath(link.parent), link.node_ops.readlink(link));
    },
    stat: (path, dontFollow) => {
      let lookup = FS.lookupPath(path, { follow: !dontFollow });
      let node = lookup.node;
      if (!node) {
        throw new FS.ErrnoError(44);
      }
      if (!node.node_ops.getattr) {
        throw new FS.ErrnoError(63);
      }
      return node.node_ops.getattr(node);
    },
    lstat: (path) => {
      return FS.stat(path, true);
    },
    chmod: (path, mode, dontFollow) => {
      let node;
      if (typeof path === "string") {
        let lookup = FS.lookupPath(path, { follow: !dontFollow });
        node = lookup.node;
      } else {
        node = path;
      }
      if (!node.node_ops.setattr) {
        throw new FS.ErrnoError(63);
      }
      node.node_ops.setattr(node, {
        mode: (mode & 4095) | (node.mode & ~4095),
        timestamp: Date.now(),
      });
    },
    lchmod: (path, mode) => {
      FS.chmod(path, mode, true);
    },
    fchmod: (fd, mode) => {
      let stream = FS.getStream(fd);
      if (!stream) {
        throw new FS.ErrnoError(8);
      }
      FS.chmod(stream.node, mode);
    },
    chown: (path, uid, gid, dontFollow) => {
      let node;
      if (typeof path === "string") {
        let lookup = FS.lookupPath(path, { follow: !dontFollow });
        node = lookup.node;
      } else {
        node = path;
      }
      if (!node.node_ops.setattr) {
        throw new FS.ErrnoError(63);
      }
      node.node_ops.setattr(node, { timestamp: Date.now() });
    },
    lchown: (path, uid, gid) => {
      FS.chown(path, uid, gid, true);
    },
    fchown: (fd, uid, gid) => {
      let stream = FS.getStream(fd);
      if (!stream) {
        throw new FS.ErrnoError(8);
      }
      FS.chown(stream.node, uid, gid);
    },
    truncate: (path, len) => {
      if (len < 0) {
        throw new FS.ErrnoError(28);
      }
      let node;
      if (typeof path === "string") {
        let lookup = FS.lookupPath(path, { follow: true });
        node = lookup.node;
      } else {
        node = path;
      }
      if (!node.node_ops.setattr) {
        throw new FS.ErrnoError(63);
      }
      if (FS.isDir(node.mode)) {
        throw new FS.ErrnoError(31);
      }
      if (!FS.isFile(node.mode)) {
        throw new FS.ErrnoError(28);
      }
      let errCode = FS.nodePermissions(node, "w");
      if (errCode) {
        throw new FS.ErrnoError(errCode);
      }
      node.node_ops.setattr(node, { size: len, timestamp: Date.now() });
    },
    ftruncate: (fd, len) => {
      let stream = FS.getStream(fd);
      if (!stream) {
        throw new FS.ErrnoError(8);
      }
      if ((stream.flags & 2097155) === 0) {
        throw new FS.ErrnoError(28);
      }
      FS.truncate(stream.node, len);
    },
    utime: (path, atime, mtime) => {
      let lookup = FS.lookupPath(path, { follow: true });
      let node = lookup.node;
      node.node_ops.setattr(node, { timestamp: Math.max(atime, mtime) });
    },
    open: (path, flags, mode) => {
      if (path === "") {
        throw new FS.ErrnoError(44);
      }
      flags = typeof flags === "string" ? FS.modeStringToFlags(flags) : flags;
      mode = typeof mode === "undefined" ? 438 : mode;
      if (flags & 64) {
        mode = (mode & 4095) | 32768;
      } else {
        mode = 0;
      }
      let node;
      if (typeof path === "object") {
        node = path;
      } else {
        path = PATH.normalize(path);
        try {
          let lookup = FS.lookupPath(path, { follow: !(flags & 131072) });
          node = lookup.node;
        } catch (e) {}
      }
      let created = false;
      if (flags & 64) {
        if (node) {
          if (flags & 128) {
            throw new FS.ErrnoError(20);
          }
        } else {
          node = FS.mknod(path, mode, 0);
          created = true;
        }
      }
      if (!node) {
        throw new FS.ErrnoError(44);
      }
      if (FS.isChrdev(node.mode)) {
        flags &= ~512;
      }
      if (flags & 65536 && !FS.isDir(node.mode)) {
        throw new FS.ErrnoError(54);
      }
      if (!created) {
        let errCode = FS.mayOpen(node, flags);
        if (errCode) {
          throw new FS.ErrnoError(errCode);
        }
      }
      if (flags & 512 && !created) {
        FS.truncate(node, 0);
      }
      flags &= ~(128 | 512 | 131072);
      let stream = FS.createStream({
        node,
        path: FS.getPath(node),
        flags,
        seekable: true,
        position: 0,
        stream_ops: node.stream_ops,
        ungotten: [],
        error: false,
      });
      if (stream.stream_ops.open) {
        stream.stream_ops.open(stream);
      }
      if (Module["logReadFiles"] && !(flags & 1)) {
        if (!FS.readFiles) FS.readFiles = {};
        if (!(path in FS.readFiles)) {
          FS.readFiles[path] = 1;
        }
      }
      return stream;
    },
    close: (stream) => {
      if (FS.isClosed(stream)) {
        throw new FS.ErrnoError(8);
      }
      if (stream.getdents) stream.getdents = null;
      try {
        if (stream.stream_ops.close) {
          stream.stream_ops.close(stream);
        }
      } catch (e) {
        throw e;
      } finally {
        FS.closeStream(stream.fd);
      }
      stream.fd = null;
    },
    isClosed: (stream) => {
      return stream.fd === null;
    },
    llseek: (stream, offset, whence) => {
      if (FS.isClosed(stream)) {
        throw new FS.ErrnoError(8);
      }
      if (!stream.seekable || !stream.stream_ops.llseek) {
        throw new FS.ErrnoError(70);
      }
      if (whence != 0 && whence != 1 && whence != 2) {
        throw new FS.ErrnoError(28);
      }
      stream.position = stream.stream_ops.llseek(stream, offset, whence);
      stream.ungotten = [];
      return stream.position;
    },
    read: (stream, buffer, offset, length, position) => {
      if (length < 0 || position < 0) {
        throw new FS.ErrnoError(28);
      }
      if (FS.isClosed(stream)) {
        throw new FS.ErrnoError(8);
      }
      if ((stream.flags & 2097155) === 1) {
        throw new FS.ErrnoError(8);
      }
      if (FS.isDir(stream.node.mode)) {
        throw new FS.ErrnoError(31);
      }
      if (!stream.stream_ops.read) {
        throw new FS.ErrnoError(28);
      }
      let seeking = typeof position !== "undefined";
      if (!seeking) {
        position = stream.position;
      } else if (!stream.seekable) {
        throw new FS.ErrnoError(70);
      }
      let bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position);
      if (!seeking) stream.position += bytesRead;
      return bytesRead;
    },
    write: (stream, buffer, offset, length, position, canOwn) => {
      if (length < 0 || position < 0) {
        throw new FS.ErrnoError(28);
      }
      if (FS.isClosed(stream)) {
        throw new FS.ErrnoError(8);
      }
      if ((stream.flags & 2097155) === 0) {
        throw new FS.ErrnoError(8);
      }
      if (FS.isDir(stream.node.mode)) {
        throw new FS.ErrnoError(31);
      }
      if (!stream.stream_ops.write) {
        throw new FS.ErrnoError(28);
      }
      if (stream.seekable && stream.flags & 1024) {
        FS.llseek(stream, 0, 2);
      }
      let seeking = typeof position !== "undefined";
      if (!seeking) {
        position = stream.position;
      } else if (!stream.seekable) {
        throw new FS.ErrnoError(70);
      }
      let bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn);
      if (!seeking) stream.position += bytesWritten;
      return bytesWritten;
    },
    allocate: (stream, offset, length) => {
      if (FS.isClosed(stream)) {
        throw new FS.ErrnoError(8);
      }
      if (offset < 0 || length <= 0) {
        throw new FS.ErrnoError(28);
      }
      if ((stream.flags & 2097155) === 0) {
        throw new FS.ErrnoError(8);
      }
      if (!FS.isFile(stream.node.mode) && !FS.isDir(stream.node.mode)) {
        throw new FS.ErrnoError(43);
      }
      if (!stream.stream_ops.allocate) {
        throw new FS.ErrnoError(138);
      }
      stream.stream_ops.allocate(stream, offset, length);
    },
    mmap: (stream, length, position, prot, flags) => {
      if ((prot & 2) !== 0 && (flags & 2) === 0 && (stream.flags & 2097155) !== 2) {
        throw new FS.ErrnoError(2);
      }
      if ((stream.flags & 2097155) === 1) {
        throw new FS.ErrnoError(2);
      }
      if (!stream.stream_ops.mmap) {
        throw new FS.ErrnoError(43);
      }
      return stream.stream_ops.mmap(stream, length, position, prot, flags);
    },
    msync: (stream, buffer, offset, length, mmapFlags) => {
      if (!stream.stream_ops.msync) {
        return 0;
      }
      return stream.stream_ops.msync(stream, buffer, offset, length, mmapFlags);
    },
    munmap: (stream) => 0,
    ioctl: (stream, cmd, arg) => {
      if (!stream.stream_ops.ioctl) {
        throw new FS.ErrnoError(59);
      }
      return stream.stream_ops.ioctl(stream, cmd, arg);
    },
    readFile: (path, opts = {}) => {
      opts.flags = opts.flags || 0;
      opts.encoding = opts.encoding || "binary";
      if (opts.encoding !== "utf8" && opts.encoding !== "binary") {
        throw new Error('Invalid encoding type "' + opts.encoding + '"');
      }
      let ret;
      let stream = FS.open(path, opts.flags);
      let stat = FS.stat(path);
      let length = stat.size;
      let buf = new Uint8Array(length);
      FS.read(stream, buf, 0, length, 0);
      if (opts.encoding === "utf8") {
        ret = UTF8ArrayToString(buf, 0);
      } else if (opts.encoding === "binary") {
        ret = buf;
      }
      FS.close(stream);
      return ret;
    },
    writeFile: (path, data, opts = {}) => {
      opts.flags = opts.flags || 577;
      let stream = FS.open(path, opts.flags, opts.mode);
      if (typeof data === "string") {
        let buf = new Uint8Array(lengthBytesUTF8(data) + 1);
        let actualNumBytes = stringToUTF8Array(data, buf, 0, buf.length);
        FS.write(stream, buf, 0, actualNumBytes, undefined, opts.canOwn);
      } else if (ArrayBuffer.isView(data)) {
        FS.write(stream, data, 0, data.byteLength, undefined, opts.canOwn);
      } else {
        throw new Error("Unsupported data type");
      }
      FS.close(stream);
    },
    cwd: () => FS.currentPath,
    chdir: (path) => {
      let lookup = FS.lookupPath(path, { follow: true });
      if (lookup.node === null) {
        throw new FS.ErrnoError(44);
      }
      if (!FS.isDir(lookup.node.mode)) {
        throw new FS.ErrnoError(54);
      }
      let errCode = FS.nodePermissions(lookup.node, "x");
      if (errCode) {
        throw new FS.ErrnoError(errCode);
      }
      FS.currentPath = lookup.path;
    },
    createDefaultDirectories: () => {
      FS.mkdir("/tmp");
      FS.mkdir("/home");
      FS.mkdir("/home/web_user");
    },
    createDefaultDevices: () => {
      FS.mkdir("/dev");
      FS.registerDevice(FS.makedev(1, 3), {
        read: () => 0,
        write: (stream, buffer, offset, length, pos) => length,
      });
      FS.mkdev("/dev/null", FS.makedev(1, 3));
      TTY.register(FS.makedev(5, 0), TTY.default_tty_ops);
      TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops);
      FS.mkdev("/dev/tty", FS.makedev(5, 0));
      FS.mkdev("/dev/tty1", FS.makedev(6, 0));
      let random_device = getRandomDevice();
      FS.createDevice("/dev", "random", random_device);
      FS.createDevice("/dev", "urandom", random_device);
      FS.mkdir("/dev/shm");
      FS.mkdir("/dev/shm/tmp");
    },
    createSpecialDirectories: () => {
      FS.mkdir("/proc");
      let proc_self = FS.mkdir("/proc/self");
      FS.mkdir("/proc/self/fd");
      FS.mount(
        {
          mount: () => {
            let node = FS.createNode(proc_self, "fd", 16384 | 511, 73);
            node.node_ops = {
              lookup: (parent, name) => {
                let fd = +name;
                let stream = FS.getStream(fd);
                if (!stream) throw new FS.ErrnoError(8);
                let ret = {
                  parent: null,
                  mount: { mountpoint: "fake" },
                  node_ops: { readlink: () => stream.path },
                };
                ret.parent = ret;
                return ret;
              },
            };
            return node;
          },
        },
        {},
        "/proc/self/fd",
      );
    },
    createStandardStreams: () => {
      if (Module["stdin"]) {
        FS.createDevice("/dev", "stdin", Module["stdin"]);
      } else {
        FS.symlink("/dev/tty", "/dev/stdin");
      }
      if (Module["stdout"]) {
        FS.createDevice("/dev", "stdout", null, Module["stdout"]);
      } else {
        FS.symlink("/dev/tty", "/dev/stdout");
      }
      if (Module["stderr"]) {
        FS.createDevice("/dev", "stderr", null, Module["stderr"]);
      } else {
        FS.symlink("/dev/tty1", "/dev/stderr");
      }
      let stdin = FS.open("/dev/stdin", 0);
      let stdout = FS.open("/dev/stdout", 1);
      let stderr = FS.open("/dev/stderr", 1);
    },
    ensureErrnoError: () => {
      if (FS.ErrnoError) return;
      FS.ErrnoError = function ErrnoError(errno, node) {
        this.node = node;
        this.setErrno = function (errno) {
          this.errno = errno;
        };
        this.setErrno(errno);
        this.message = "FS error";
      };
      FS.ErrnoError.prototype = new Error();
      FS.ErrnoError.prototype.constructor = FS.ErrnoError;
      [44].forEach((code) => {
        FS.genericErrors[code] = new FS.ErrnoError(code);
        FS.genericErrors[code].stack = "<generic error, no stack>";
      });
    },
    staticInit: () => {
      FS.ensureErrnoError();
      FS.nameTable = new Array(4096);
      FS.mount(MEMFS, {}, "/");
      FS.createDefaultDirectories();
      FS.createDefaultDevices();
      FS.createSpecialDirectories();
      FS.filesystems = { MEMFS };
    },
    init: (input, output, error) => {
      FS.init.initialized = true;
      FS.ensureErrnoError();
      Module["stdin"] = input || Module["stdin"];
      Module["stdout"] = output || Module["stdout"];
      Module["stderr"] = error || Module["stderr"];
      FS.createStandardStreams();
    },
    quit: () => {
      FS.init.initialized = false;
      for (let i = 0; i < FS.streams.length; i++) {
        let stream = FS.streams[i];
        if (!stream) {
          continue;
        }
        FS.close(stream);
      }
    },
    getMode: (canRead, canWrite) => {
      let mode = 0;
      if (canRead) mode |= 292 | 73;
      if (canWrite) mode |= 146;
      return mode;
    },
    findObject: (path, dontResolveLastLink) => {
      let ret = FS.analyzePath(path, dontResolveLastLink);
      if (!ret.exists) {
        return null;
      }
      return ret.object;
    },
    analyzePath: (path, dontResolveLastLink) => {
      try {
        var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
        path = lookup.path;
      } catch (e) {}
      let ret = {
        isRoot: false,
        exists: false,
        error: 0,
        name: null,
        path: null,
        object: null,
        parentExists: false,
        parentPath: null,
        parentObject: null,
      };
      try {
        var lookup = FS.lookupPath(path, { parent: true });
        ret.parentExists = true;
        ret.parentPath = lookup.path;
        ret.parentObject = lookup.node;
        ret.name = PATH.basename(path);
        lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
        ret.exists = true;
        ret.path = lookup.path;
        ret.object = lookup.node;
        ret.name = lookup.node.name;
        ret.isRoot = lookup.path === "/";
      } catch (e) {
        ret.error = e.errno;
      }
      return ret;
    },
    createPath: (parent, path, canRead, canWrite) => {
      parent = typeof parent === "string" ? parent : FS.getPath(parent);
      let parts = path.split("/").reverse();
      while (parts.length) {
        let part = parts.pop();
        if (!part) continue;
        var current = PATH.join2(parent, part);
        try {
          FS.mkdir(current);
        } catch (e) {}
        parent = current;
      }
      return current;
    },
    createFile: (parent, name, properties, canRead, canWrite) => {
      let path = PATH.join2(typeof parent === "string" ? parent : FS.getPath(parent), name);
      let mode = FS.getMode(canRead, canWrite);
      return FS.create(path, mode);
    },
    createDataFile: (parent, name, data, canRead, canWrite, canOwn) => {
      let path = name;
      if (parent) {
        parent = typeof parent === "string" ? parent : FS.getPath(parent);
        path = name ? PATH.join2(parent, name) : parent;
      }
      let mode = FS.getMode(canRead, canWrite);
      let node = FS.create(path, mode);
      if (data) {
        if (typeof data === "string") {
          let arr = new Array(data.length);
          for (let i = 0, len = data.length; i < len; ++i) arr[i] = data.charCodeAt(i);
          data = arr;
        }
        FS.chmod(node, mode | 146);
        let stream = FS.open(node, 577);
        FS.write(stream, data, 0, data.length, 0, canOwn);
        FS.close(stream);
        FS.chmod(node, mode);
      }
      return node;
    },
    createDevice: (parent, name, input, output) => {
      let path = PATH.join2(typeof parent === "string" ? parent : FS.getPath(parent), name);
      let mode = FS.getMode(!!input, !!output);
      if (!FS.createDevice.major) FS.createDevice.major = 64;
      let dev = FS.makedev(FS.createDevice.major++, 0);
      FS.registerDevice(dev, {
        open: (stream) => {
          stream.seekable = false;
        },
        close: (stream) => {
          if (output && output.buffer && output.buffer.length) {
            output(10);
          }
        },
        read: (stream, buffer, offset, length, pos) => {
          let bytesRead = 0;
          for (let i = 0; i < length; i++) {
            var result;
            try {
              result = input();
            } catch (e) {
              throw new FS.ErrnoError(29);
            }
            if (result === undefined && bytesRead === 0) {
              throw new FS.ErrnoError(6);
            }
            if (result === null || result === undefined) break;
            bytesRead++;
            buffer[offset + i] = result;
          }
          if (bytesRead) {
            stream.node.timestamp = Date.now();
          }
          return bytesRead;
        },
        write: (stream, buffer, offset, length, pos) => {
          for (var i = 0; i < length; i++) {
            try {
              output(buffer[offset + i]);
            } catch (e) {
              throw new FS.ErrnoError(29);
            }
          }
          if (length) {
            stream.node.timestamp = Date.now();
          }
          return i;
        },
      });
      return FS.mkdev(path, mode, dev);
    },
    forceLoadFile: (obj) => {
      if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true;
      if (typeof XMLHttpRequest !== "undefined") {
        throw new Error(
          "Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.",
        );
      } else if (read_) {
        try {
          obj.contents = intArrayFromString(read_(obj.url), true);
          obj.usedBytes = obj.contents.length;
        } catch (e) {
          throw new FS.ErrnoError(29);
        }
      } else {
        throw new Error("Cannot load without read() or XMLHttpRequest.");
      }
    },
    createLazyFile: (parent, name, url, canRead, canWrite) => {
      function LazyUint8Array() {
        this.lengthKnown = false;
        this.chunks = [];
      }
      LazyUint8Array.prototype.get = function LazyUint8Array_get(idx) {
        if (idx > this.length - 1 || idx < 0) {
          return undefined;
        }
        let chunkOffset = idx % this.chunkSize;
        let chunkNum = (idx / this.chunkSize) | 0;
        return this.getter(chunkNum)[chunkOffset];
      };
      LazyUint8Array.prototype.setDataGetter = function LazyUint8Array_setDataGetter(getter) {
        this.getter = getter;
      };
      LazyUint8Array.prototype.cacheLength = function LazyUint8Array_cacheLength() {
        let xhr = new XMLHttpRequest();
        xhr.open("HEAD", url, false);
        xhr.send(null);
        if (!((xhr.status >= 200 && xhr.status < 300) || xhr.status === 304))
          throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
        let datalength = Number(xhr.getResponseHeader("Content-length"));
        let header;
        let hasByteServing =
          (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes";
        let usesGzip = (header = xhr.getResponseHeader("Content-Encoding")) && header === "gzip";
        let chunkSize = 1024 * 1024;
        if (!hasByteServing) chunkSize = datalength;
        let doXHR = (from, to) => {
          if (from > to)
            throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!");
          if (to > datalength - 1)
            throw new Error("only " + datalength + " bytes available! programmer error!");
          let xhr = new XMLHttpRequest();
          xhr.open("GET", url, false);
          if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to);
          xhr.responseType = "arraybuffer";
          if (xhr.overrideMimeType) {
            xhr.overrideMimeType("text/plain; charset=x-user-defined");
          }
          xhr.send(null);
          if (!((xhr.status >= 200 && xhr.status < 300) || xhr.status === 304))
            throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
          if (xhr.response !== undefined) {
            return new Uint8Array(xhr.response || []);
          }
          return intArrayFromString(xhr.responseText || "", true);
        };
        let lazyArray = this;
        lazyArray.setDataGetter((chunkNum) => {
          let start = chunkNum * chunkSize;
          let end = (chunkNum + 1) * chunkSize - 1;
          end = Math.min(end, datalength - 1);
          if (typeof lazyArray.chunks[chunkNum] === "undefined") {
            lazyArray.chunks[chunkNum] = doXHR(start, end);
          }
          if (typeof lazyArray.chunks[chunkNum] === "undefined") throw new Error("doXHR failed!");
          return lazyArray.chunks[chunkNum];
        });
        if (usesGzip || !datalength) {
          chunkSize = datalength = 1;
          datalength = this.getter(0).length;
          chunkSize = datalength;
          out("LazyFiles on gzip forces download of the whole file when length is accessed");
        }
        this._length = datalength;
        this._chunkSize = chunkSize;
        this.lengthKnown = true;
      };
      if (typeof XMLHttpRequest !== "undefined") {
        if (!ENVIRONMENT_IS_WORKER)
          throw "Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc";
        let lazyArray = new LazyUint8Array();
        Object.defineProperties(lazyArray, {
          length: {
            get() {
              if (!this.lengthKnown) {
                this.cacheLength();
              }
              return this._length;
            },
          },
          chunkSize: {
            get() {
              if (!this.lengthKnown) {
                this.cacheLength();
              }
              return this._chunkSize;
            },
          },
        });
        var properties = { isDevice: false, contents: lazyArray };
      } else {
        var properties = { isDevice: false, url };
      }
      let node = FS.createFile(parent, name, properties, canRead, canWrite);
      if (properties.contents) {
        node.contents = properties.contents;
      } else if (properties.url) {
        node.contents = null;
        node.url = properties.url;
      }
      Object.defineProperties(node, {
        usedBytes: {
          get() {
            return this.contents.length;
          },
        },
      });
      let stream_ops = {};
      let keys = Object.keys(node.stream_ops);
      keys.forEach((key) => {
        let fn = node.stream_ops[key];
        stream_ops[key] = function forceLoadLazyFile() {
          FS.forceLoadFile(node);
          return fn.apply(null, arguments);
        };
      });
      function writeChunks(stream, buffer, offset, length, position) {
        let contents = stream.node.contents;
        if (position >= contents.length) return 0;
        let size = Math.min(contents.length - position, length);
        if (contents.slice) {
          for (var i = 0; i < size; i++) {
            buffer[offset + i] = contents[position + i];
          }
        } else {
          for (var i = 0; i < size; i++) {
            buffer[offset + i] = contents.get(position + i);
          }
        }
        return size;
      }
      stream_ops.read = (stream, buffer, offset, length, position) => {
        FS.forceLoadFile(node);
        return writeChunks(stream, buffer, offset, length, position);
      };
      stream_ops.mmap = (stream, length, position, prot, flags) => {
        FS.forceLoadFile(node);
        let ptr = mmapAlloc(length);
        if (!ptr) {
          throw new FS.ErrnoError(48);
        }
        writeChunks(stream, HEAP8, ptr, length, position);
        return { ptr, allocated: true };
      };
      node.stream_ops = stream_ops;
      return node;
    },
    createPreloadedFile: (
      parent,
      name,
      url,
      canRead,
      canWrite,
      onload,
      onerror,
      dontCreateFile,
      canOwn,
      preFinish,
    ) => {
      let fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent;
      let dep = getUniqueRunDependency("cp " + fullname);
      function processData(byteArray) {
        function finish(byteArray) {
          if (preFinish) preFinish();
          if (!dontCreateFile) {
            FS.createDataFile(parent, name, byteArray, canRead, canWrite, canOwn);
          }
          if (onload) onload();
          removeRunDependency(dep);
        }
        if (
          Browser.handledByPreloadPlugin(byteArray, fullname, finish, () => {
            if (onerror) onerror();
            removeRunDependency(dep);
          })
        ) {
          return;
        }
        finish(byteArray);
      }
      addRunDependency(dep);
      if (typeof url === "string") {
        asyncLoad(url, (byteArray) => processData(byteArray), onerror);
      } else {
        processData(url);
      }
    },
    indexedDB: () => {
      return (
        window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB
      );
    },
    DB_NAME: () => {
      return "EM_FS_" + window.location.pathname;
    },
    DB_VERSION: 20,
    DB_STORE_NAME: "FILE_DATA",
    saveFilesToDB: (paths, onload, onerror) => {
      onload = onload || (() => {});
      onerror = onerror || (() => {});
      let indexedDB = FS.indexedDB();
      try {
        var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
      } catch (e) {
        return onerror(e);
      }
      openRequest.onupgradeneeded = () => {
        out("creating db");
        let db = openRequest.result;
        db.createObjectStore(FS.DB_STORE_NAME);
      };
      openRequest.onsuccess = () => {
        let db = openRequest.result;
        let transaction = db.transaction([FS.DB_STORE_NAME], "readwrite");
        let files = transaction.objectStore(FS.DB_STORE_NAME);
        let ok = 0,
          fail = 0,
          total = paths.length;
        function finish() {
          if (fail == 0) onload();
          else onerror();
        }
        paths.forEach((path) => {
          let putRequest = files.put(FS.analyzePath(path).object.contents, path);
          putRequest.onsuccess = () => {
            ok++;
            if (ok + fail == total) finish();
          };
          putRequest.onerror = () => {
            fail++;
            if (ok + fail == total) finish();
          };
        });
        transaction.onerror = onerror;
      };
      openRequest.onerror = onerror;
    },
    loadFilesFromDB: (paths, onload, onerror) => {
      onload = onload || (() => {});
      onerror = onerror || (() => {});
      let indexedDB = FS.indexedDB();
      try {
        var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
      } catch (e) {
        return onerror(e);
      }
      openRequest.onupgradeneeded = onerror;
      openRequest.onsuccess = () => {
        let db = openRequest.result;
        try {
          var transaction = db.transaction([FS.DB_STORE_NAME], "readonly");
        } catch (e) {
          onerror(e);
          return;
        }
        let files = transaction.objectStore(FS.DB_STORE_NAME);
        let ok = 0,
          fail = 0,
          total = paths.length;
        function finish() {
          if (fail == 0) onload();
          else onerror();
        }
        paths.forEach((path) => {
          let getRequest = files.get(path);
          getRequest.onsuccess = () => {
            if (FS.analyzePath(path).exists) {
              FS.unlink(path);
            }
            FS.createDataFile(
              PATH.dirname(path),
              PATH.basename(path),
              getRequest.result,
              true,
              true,
              true,
            );
            ok++;
            if (ok + fail == total) finish();
          };
          getRequest.onerror = () => {
            fail++;
            if (ok + fail == total) finish();
          };
        });
        transaction.onerror = onerror;
      };
      openRequest.onerror = onerror;
    },
  };
  var SYSCALLS = {
    DEFAULT_POLLMASK: 5,
    calculateAt(dirfd, path, allowEmpty) {
      if (PATH.isAbs(path)) {
        return path;
      }
      let dir;
      if (dirfd === -100) {
        dir = FS.cwd();
      } else {
        let dirstream = SYSCALLS.getStreamFromFD(dirfd);
        dir = dirstream.path;
      }
      if (path.length == 0) {
        if (!allowEmpty) {
          throw new FS.ErrnoError(44);
        }
        return dir;
      }
      return PATH.join2(dir, path);
    },
    doStat(func, path, buf) {
      try {
        var stat = func(path);
      } catch (e) {
        if (e && e.node && PATH.normalize(path) !== PATH.normalize(FS.getPath(e.node))) {
          return -54;
        }
        throw e;
      }
      HEAP32[buf >> 2] = stat.dev;
      HEAP32[(buf + 8) >> 2] = stat.ino;
      HEAP32[(buf + 12) >> 2] = stat.mode;
      HEAPU32[(buf + 16) >> 2] = stat.nlink;
      HEAP32[(buf + 20) >> 2] = stat.uid;
      HEAP32[(buf + 24) >> 2] = stat.gid;
      HEAP32[(buf + 28) >> 2] = stat.rdev;
      (tempI64 = [
        stat.size >>> 0,
        ((tempDouble = stat.size),
        +Math.abs(tempDouble) >= 1
          ? tempDouble > 0
            ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0
            : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0
          : 0),
      ]),
        (HEAP32[(buf + 40) >> 2] = tempI64[0]),
        (HEAP32[(buf + 44) >> 2] = tempI64[1]);
      HEAP32[(buf + 48) >> 2] = 4096;
      HEAP32[(buf + 52) >> 2] = stat.blocks;
      (tempI64 = [
        Math.floor(stat.atime.getTime() / 1e3) >>> 0,
        ((tempDouble = Math.floor(stat.atime.getTime() / 1e3)),
        +Math.abs(tempDouble) >= 1
          ? tempDouble > 0
            ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0
            : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0
          : 0),
      ]),
        (HEAP32[(buf + 56) >> 2] = tempI64[0]),
        (HEAP32[(buf + 60) >> 2] = tempI64[1]);
      HEAPU32[(buf + 64) >> 2] = 0;
      (tempI64 = [
        Math.floor(stat.mtime.getTime() / 1e3) >>> 0,
        ((tempDouble = Math.floor(stat.mtime.getTime() / 1e3)),
        +Math.abs(tempDouble) >= 1
          ? tempDouble > 0
            ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0
            : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0
          : 0),
      ]),
        (HEAP32[(buf + 72) >> 2] = tempI64[0]),
        (HEAP32[(buf + 76) >> 2] = tempI64[1]);
      HEAPU32[(buf + 80) >> 2] = 0;
      (tempI64 = [
        Math.floor(stat.ctime.getTime() / 1e3) >>> 0,
        ((tempDouble = Math.floor(stat.ctime.getTime() / 1e3)),
        +Math.abs(tempDouble) >= 1
          ? tempDouble > 0
            ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0
            : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0
          : 0),
      ]),
        (HEAP32[(buf + 88) >> 2] = tempI64[0]),
        (HEAP32[(buf + 92) >> 2] = tempI64[1]);
      HEAPU32[(buf + 96) >> 2] = 0;
      (tempI64 = [
        stat.ino >>> 0,
        ((tempDouble = stat.ino),
        +Math.abs(tempDouble) >= 1
          ? tempDouble > 0
            ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0
            : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0
          : 0),
      ]),
        (HEAP32[(buf + 104) >> 2] = tempI64[0]),
        (HEAP32[(buf + 108) >> 2] = tempI64[1]);
      return 0;
    },
    doMsync(addr, stream, len, flags, offset) {
      if (!FS.isFile(stream.node.mode)) {
        throw new FS.ErrnoError(43);
      }
      if (flags & 2) {
        return 0;
      }
      let buffer = HEAPU8.slice(addr, addr + len);
      FS.msync(stream, buffer, offset, len, flags);
    },
    varargs: undefined,
    get() {
      SYSCALLS.varargs += 4;
      let ret = HEAP32[(SYSCALLS.varargs - 4) >> 2];
      return ret;
    },
    getStr(ptr) {
      let ret = UTF8ToString(ptr);
      return ret;
    },
    getStreamFromFD(fd) {
      let stream = FS.getStream(fd);
      if (!stream) throw new FS.ErrnoError(8);
      return stream;
    },
  };
  function _environ_get(__environ, environ_buf) {
    let bufSize = 0;
    getEnvStrings().forEach(function (string, i) {
      let ptr = environ_buf + bufSize;
      HEAPU32[(__environ + i * 4) >> 2] = ptr;
      writeAsciiToMemory(string, ptr);
      bufSize += string.length + 1;
    });
    return 0;
  }
  function _environ_sizes_get(penviron_count, penviron_buf_size) {
    let strings = getEnvStrings();
    HEAPU32[penviron_count >> 2] = strings.length;
    let bufSize = 0;
    strings.forEach(function (string) {
      bufSize += string.length + 1;
    });
    HEAPU32[penviron_buf_size >> 2] = bufSize;
    return 0;
  }
  function _proc_exit(code) {
    EXITSTATUS = code;
    if (!keepRuntimeAlive()) {
      if (Module["onExit"]) Module["onExit"](code);
      ABORT = true;
    }
    quit_(code, new ExitStatus(code));
  }
  function exitJS(status, implicit) {
    EXITSTATUS = status;
    _proc_exit(status);
  }
  let _exit = exitJS;
  function _fd_close(fd) {
    try {
      let stream = SYSCALLS.getStreamFromFD(fd);
      FS.close(stream);
      return 0;
    } catch (e) {
      if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) throw e;
      return e.errno;
    }
  }
  function doReadv(stream, iov, iovcnt, offset) {
    let ret = 0;
    for (let i = 0; i < iovcnt; i++) {
      let ptr = HEAPU32[iov >> 2];
      let len = HEAPU32[(iov + 4) >> 2];
      iov += 8;
      let curr = FS.read(stream, HEAP8, ptr, len, offset);
      if (curr < 0) return -1;
      ret += curr;
      if (curr < len) break;
    }
    return ret;
  }
  function _fd_read(fd, iov, iovcnt, pnum) {
    try {
      let stream = SYSCALLS.getStreamFromFD(fd);
      let num = doReadv(stream, iov, iovcnt);
      HEAPU32[pnum >> 2] = num;
      return 0;
    } catch (e) {
      if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) throw e;
      return e.errno;
    }
  }
  function convertI32PairToI53Checked(lo, hi) {
    return (hi + 2097152) >>> 0 < 4194305 - !!lo ? (lo >>> 0) + hi * 4294967296 : NaN;
  }
  function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {
    try {
      let offset = convertI32PairToI53Checked(offset_low, offset_high);
      if (isNaN(offset)) return 61;
      let stream = SYSCALLS.getStreamFromFD(fd);
      FS.llseek(stream, offset, whence);
      (tempI64 = [
        stream.position >>> 0,
        ((tempDouble = stream.position),
        +Math.abs(tempDouble) >= 1
          ? tempDouble > 0
            ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0
            : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0
          : 0),
      ]),
        (HEAP32[newOffset >> 2] = tempI64[0]),
        (HEAP32[(newOffset + 4) >> 2] = tempI64[1]);
      if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null;
      return 0;
    } catch (e) {
      if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) throw e;
      return e.errno;
    }
  }
  function doWritev(stream, iov, iovcnt, offset) {
    let ret = 0;
    for (let i = 0; i < iovcnt; i++) {
      let ptr = HEAPU32[iov >> 2];
      let len = HEAPU32[(iov + 4) >> 2];
      iov += 8;
      let curr = FS.write(stream, HEAP8, ptr, len, offset);
      if (curr < 0) return -1;
      ret += curr;
    }
    return ret;
  }
  function _fd_write(fd, iov, iovcnt, pnum) {
    try {
      let stream = SYSCALLS.getStreamFromFD(fd);
      let num = doWritev(stream, iov, iovcnt);
      HEAPU32[pnum >> 2] = num;
      return 0;
    } catch (e) {
      if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) throw e;
      return e.errno;
    }
  }
  function _return_string(data, length) {
    Module._return_string_callback(data, length);
  }
  function __isLeapYear(year) {
    return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
  }
  function __arraySum(array, index) {
    let sum = 0;
    for (let i = 0; i <= index; sum += array[i++]) {}
    return sum;
  }
  let __MONTH_DAYS_LEAP = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
  let __MONTH_DAYS_REGULAR = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
  function __addDays(date, days) {
    let newDate = new Date(date.getTime());
    while (days > 0) {
      let leap = __isLeapYear(newDate.getFullYear());
      let currentMonth = newDate.getMonth();
      let daysInCurrentMonth = (leap ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR)[currentMonth];
      if (days > daysInCurrentMonth - newDate.getDate()) {
        days -= daysInCurrentMonth - newDate.getDate() + 1;
        newDate.setDate(1);
        if (currentMonth < 11) {
          newDate.setMonth(currentMonth + 1);
        } else {
          newDate.setMonth(0);
          newDate.setFullYear(newDate.getFullYear() + 1);
        }
      } else {
        newDate.setDate(newDate.getDate() + days);
        return newDate;
      }
    }
    return newDate;
  }
  function writeArrayToMemory(array, buffer) {
    HEAP8.set(array, buffer);
  }
  function _strftime(s, maxsize, format, tm) {
    let tm_zone = HEAP32[(tm + 40) >> 2];
    let date = {
      tm_sec: HEAP32[tm >> 2],
      tm_min: HEAP32[(tm + 4) >> 2],
      tm_hour: HEAP32[(tm + 8) >> 2],
      tm_mday: HEAP32[(tm + 12) >> 2],
      tm_mon: HEAP32[(tm + 16) >> 2],
      tm_year: HEAP32[(tm + 20) >> 2],
      tm_wday: HEAP32[(tm + 24) >> 2],
      tm_yday: HEAP32[(tm + 28) >> 2],
      tm_isdst: HEAP32[(tm + 32) >> 2],
      tm_gmtoff: HEAP32[(tm + 36) >> 2],
      tm_zone: tm_zone ? UTF8ToString(tm_zone) : "",
    };
    let pattern = UTF8ToString(format);
    let EXPANSION_RULES_1 = {
      "%c": "%a %b %d %H:%M:%S %Y",
      "%D": "%m/%d/%y",
      "%F": "%Y-%m-%d",
      "%h": "%b",
      "%r": "%I:%M:%S %p",
      "%R": "%H:%M",
      "%T": "%H:%M:%S",
      "%x": "%m/%d/%y",
      "%X": "%H:%M:%S",
      "%Ec": "%c",
      "%EC": "%C",
      "%Ex": "%m/%d/%y",
      "%EX": "%H:%M:%S",
      "%Ey": "%y",
      "%EY": "%Y",
      "%Od": "%d",
      "%Oe": "%e",
      "%OH": "%H",
      "%OI": "%I",
      "%Om": "%m",
      "%OM": "%M",
      "%OS": "%S",
      "%Ou": "%u",
      "%OU": "%U",
      "%OV": "%V",
      "%Ow": "%w",
      "%OW": "%W",
      "%Oy": "%y",
    };
    for (var rule in EXPANSION_RULES_1) {
      pattern = pattern.replace(new RegExp(rule, "g"), EXPANSION_RULES_1[rule]);
    }
    let WEEKDAYS = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
    let MONTHS = [
      "January",
      "February",
      "March",
      "April",
      "May",
      "June",
      "July",
      "August",
      "September",
      "October",
      "November",
      "December",
    ];
    function leadingSomething(value, digits, character) {
      let str = typeof value === "number" ? value.toString() : value || "";
      while (str.length < digits) {
        str = character[0] + str;
      }
      return str;
    }
    function leadingNulls(value, digits) {
      return leadingSomething(value, digits, "0");
    }
    function compareByDay(date1, date2) {
      function sgn(value) {
        return value < 0 ? -1 : value > 0 ? 1 : 0;
      }
      let compare;
      if ((compare = sgn(date1.getFullYear() - date2.getFullYear())) === 0) {
        if ((compare = sgn(date1.getMonth() - date2.getMonth())) === 0) {
          compare = sgn(date1.getDate() - date2.getDate());
        }
      }
      return compare;
    }
    function getFirstWeekStartDate(janFourth) {
      switch (janFourth.getDay()) {
        case 0:
          return new Date(janFourth.getFullYear() - 1, 11, 29);
        case 1:
          return janFourth;
        case 2:
          return new Date(janFourth.getFullYear(), 0, 3);
        case 3:
          return new Date(janFourth.getFullYear(), 0, 2);
        case 4:
          return new Date(janFourth.getFullYear(), 0, 1);
        case 5:
          return new Date(janFourth.getFullYear() - 1, 11, 31);
        case 6:
          return new Date(janFourth.getFullYear() - 1, 11, 30);
      }
    }
    function getWeekBasedYear(date) {
      let thisDate = __addDays(new Date(date.tm_year + 1900, 0, 1), date.tm_yday);
      let janFourthThisYear = new Date(thisDate.getFullYear(), 0, 4);
      let janFourthNextYear = new Date(thisDate.getFullYear() + 1, 0, 4);
      let firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear);
      let firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear);
      if (compareByDay(firstWeekStartThisYear, thisDate) <= 0) {
        if (compareByDay(firstWeekStartNextYear, thisDate) <= 0) {
          return thisDate.getFullYear() + 1;
        }
        return thisDate.getFullYear();
      }
      return thisDate.getFullYear() - 1;
    }
    let EXPANSION_RULES_2 = {
      "%a"(date) {
        return WEEKDAYS[date.tm_wday].substring(0, 3);
      },
      "%A"(date) {
        return WEEKDAYS[date.tm_wday];
      },
      "%b"(date) {
        return MONTHS[date.tm_mon].substring(0, 3);
      },
      "%B"(date) {
        return MONTHS[date.tm_mon];
      },
      "%C"(date) {
        let year = date.tm_year + 1900;
        return leadingNulls((year / 100) | 0, 2);
      },
      "%d"(date) {
        return leadingNulls(date.tm_mday, 2);
      },
      "%e"(date) {
        return leadingSomething(date.tm_mday, 2, " ");
      },
      "%g"(date) {
        return getWeekBasedYear(date).toString().substring(2);
      },
      "%G"(date) {
        return getWeekBasedYear(date);
      },
      "%H"(date) {
        return leadingNulls(date.tm_hour, 2);
      },
      "%I"(date) {
        let twelveHour = date.tm_hour;
        if (twelveHour == 0) twelveHour = 12;
        else if (twelveHour > 12) twelveHour -= 12;
        return leadingNulls(twelveHour, 2);
      },
      "%j"(date) {
        return leadingNulls(
          date.tm_mday +
            __arraySum(
              __isLeapYear(date.tm_year + 1900) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR,
              date.tm_mon - 1,
            ),
          3,
        );
      },
      "%m"(date) {
        return leadingNulls(date.tm_mon + 1, 2);
      },
      "%M"(date) {
        return leadingNulls(date.tm_min, 2);
      },
      "%n"() {
        return "\n";
      },
      "%p"(date) {
        if (date.tm_hour >= 0 && date.tm_hour < 12) {
          return "AM";
        }
        return "PM";
      },
      "%S"(date) {
        return leadingNulls(date.tm_sec, 2);
      },
      "%t"() {
        return "\t";
      },
      "%u"(date) {
        return date.tm_wday || 7;
      },
      "%U"(date) {
        let days = date.tm_yday + 7 - date.tm_wday;
        return leadingNulls(Math.floor(days / 7), 2);
      },
      "%V"(date) {
        let val = Math.floor((date.tm_yday + 7 - ((date.tm_wday + 6) % 7)) / 7);
        if ((date.tm_wday + 371 - date.tm_yday - 2) % 7 <= 2) {
          val++;
        }
        if (!val) {
          val = 52;
          let dec31 = (date.tm_wday + 7 - date.tm_yday - 1) % 7;
          if (dec31 == 4 || (dec31 == 5 && __isLeapYear((date.tm_year % 400) - 1))) {
            val++;
          }
        } else if (val == 53) {
          let jan1 = (date.tm_wday + 371 - date.tm_yday) % 7;
          if (jan1 != 4 && (jan1 != 3 || !__isLeapYear(date.tm_year))) val = 1;
        }
        return leadingNulls(val, 2);
      },
      "%w"(date) {
        return date.tm_wday;
      },
      "%W"(date) {
        let days = date.tm_yday + 7 - ((date.tm_wday + 6) % 7);
        return leadingNulls(Math.floor(days / 7), 2);
      },
      "%y"(date) {
        return (date.tm_year + 1900).toString().substring(2);
      },
      "%Y"(date) {
        return date.tm_year + 1900;
      },
      "%z"(date) {
        let off = date.tm_gmtoff;
        let ahead = off >= 0;
        off = Math.abs(off) / 60;
        off = (off / 60) * 100 + (off % 60);
        return (ahead ? "+" : "-") + String("0000" + off).slice(-4);
      },
      "%Z"(date) {
        return date.tm_zone;
      },
      "%%"() {
        return "%";
      },
    };
    pattern = pattern.replace(/%%/g, "\0\0");
    for (var rule in EXPANSION_RULES_2) {
      if (pattern.includes(rule)) {
        pattern = pattern.replace(new RegExp(rule, "g"), EXPANSION_RULES_2[rule](date));
      }
    }
    pattern = pattern.replace(/\0\0/g, "%");
    let bytes = intArrayFromString(pattern, false);
    if (bytes.length > maxsize) {
      return 0;
    }
    writeArrayToMemory(bytes, s);
    return bytes.length - 1;
  }
  function _strftime_l(s, maxsize, format, tm, loc) {
    return _strftime(s, maxsize, format, tm);
  }
  let FSNode = function (parent, name, mode, rdev) {
    if (!parent) {
      parent = this;
    }
    this.parent = parent;
    this.mount = parent.mount;
    this.mounted = null;
    this.id = FS.nextInode++;
    this.name = name;
    this.mode = mode;
    this.node_ops = {};
    this.stream_ops = {};
    this.rdev = rdev;
  };
  let readMode = 292 | 73;
  let writeMode = 146;
  Object.defineProperties(FSNode.prototype, {
    read: {
      get() {
        return (this.mode & readMode) === readMode;
      },
      set(val) {
        val ? (this.mode |= readMode) : (this.mode &= ~readMode);
      },
    },
    write: {
      get() {
        return (this.mode & writeMode) === writeMode;
      },
      set(val) {
        val ? (this.mode |= writeMode) : (this.mode &= ~writeMode);
      },
    },
    isFolder: {
      get() {
        return FS.isDir(this.mode);
      },
    },
    isDevice: {
      get() {
        return FS.isChrdev(this.mode);
      },
    },
  });
  FS.FSNode = FSNode;
  FS.staticInit();
  var asmLibraryArg = {
    a: ___assert_fail,
    f: ___cxa_allocate_exception,
    e: ___cxa_throw,
    b: _abort,
    i: _emscripten_resize_heap,
    l: _environ_get,
    m: _environ_sizes_get,
    d: _exit,
    g: _fd_close,
    h: _fd_read,
    k: _fd_seek,
    j: _fd_write,
    n: _return_string,
    c: _strftime_l,
  };
  let asm = createWasm();
  var ___wasm_call_ctors = (Module["___wasm_call_ctors"] = function () {
    return (___wasm_call_ctors = Module["___wasm_call_ctors"] = Module["asm"]["p"]).apply(
      null,
      arguments,
    );
  });
  var _test = (Module["_test"] = function () {
    return (_test = Module["_test"] = Module["asm"]["q"]).apply(null, arguments);
  });
  var _spirv_to_wgsl = (Module["_spirv_to_wgsl"] = function () {
    return (_spirv_to_wgsl = Module["_spirv_to_wgsl"] = Module["asm"]["r"]).apply(null, arguments);
  });
  var _malloc = (Module["_malloc"] = function () {
    return (_malloc = Module["_malloc"] = Module["asm"]["t"]).apply(null, arguments);
  });
  var _free = (Module["_free"] = function () {
    return (_free = Module["_free"] = Module["asm"]["u"]).apply(null, arguments);
  });
  var ___cxa_is_pointer_type = (Module["___cxa_is_pointer_type"] = function () {
    return (___cxa_is_pointer_type = Module["___cxa_is_pointer_type"] = Module["asm"]["v"]).apply(
      null,
      arguments,
    );
  });
  let calledRun;
  dependenciesFulfilled = function runCaller() {
    if (!calledRun) run();
    if (!calledRun) dependenciesFulfilled = runCaller;
  };
  function run(args) {
    args = args || arguments_;
    if (runDependencies > 0) {
      return;
    }
    preRun();
    if (runDependencies > 0) {
      return;
    }
    function doRun() {
      if (calledRun) return;
      calledRun = true;
      Module["calledRun"] = true;
      if (ABORT) return;
      initRuntime();
      if (Module["onRuntimeInitialized"]) Module["onRuntimeInitialized"]();
      postRun();
    }
    if (Module["setStatus"]) {
      Module["setStatus"]("Running...");
      setTimeout(function () {
        setTimeout(function () {
          Module["setStatus"]("");
        }, 1);
        doRun();
      }, 1);
    } else {
      doRun();
    }
  }
  if (Module["preInit"]) {
    if (typeof Module["preInit"] === "function") Module["preInit"] = [Module["preInit"]];
    while (Module["preInit"].length > 0) {
      Module["preInit"].pop()();
    }
  }
  run();
  return Module;
};
(function tryToExport(root, factory) {
  if (typeof exports === "object" && typeof module === "object") module.exports = factory();
  else if (typeof define === "function" && define.amd) define("twgsl", [], factory);
  else if (typeof exports === "object") exports["twgsl"] = factory();
  else root["twgsl"] = factory();
})(typeof self !== "undefined" ? self : typeof global !== "undefined" ? global : this, () => {
  const initialize = (wasmPath) => {
    wasmPath = wasmPath || "twgsl.wasm";
    return new Promise((resolve) => {
      Module({
        locateFile() {
          return wasmPath;
        },
        onRuntimeInitialized() {
          let twgsl = this;
          let wgsl = "";
          let textDecoder = new TextDecoder();
          let convertSpirV2WGSL = (code) => {
            if (!twgsl._return_string_callback) {
              twgsl._return_string_callback = (data, length) => {
                const bytes = new Uint8ClampedArray(twgsl.HEAPU8.subarray(data, data + length));
                wgsl = textDecoder.decode(bytes);
              };
            }
            let addr = twgsl._malloc(code.byteLength);
            twgsl.HEAPU32.set(code, addr / 4);
            twgsl._spirv_to_wgsl(addr, code.byteLength);
            twgsl._free(addr);
            return wgsl;
          };
          resolve({
            convertSpirV2WGSL,
          });
        },
      });
    });
  };
  let instance;
  return (wasmPath) => {
    if (!instance) {
      instance = initialize(wasmPath);
    }
    return instance;
  };
});
"; +var StandalonePlayCanvasAdapterControlsType = /* @__PURE__ */ ((StandalonePlayCanvasAdapterControlsType2) => { + StandalonePlayCanvasAdapterControlsType2[StandalonePlayCanvasAdapterControlsType2["None"] = 0] = "None"; + StandalonePlayCanvasAdapterControlsType2[StandalonePlayCanvasAdapterControlsType2["DragFly"] = 1] = "DragFly"; + StandalonePlayCanvasAdapterControlsType2[StandalonePlayCanvasAdapterControlsType2["Orbit"] = 2] = "Orbit"; + return StandalonePlayCanvasAdapterControlsType2; +})(StandalonePlayCanvasAdapterControlsType || {}); +var StandalonePlayCanvasAdapter = class _StandalonePlayCanvasAdapter { + constructor(element, options) { + this.element = element; + this.options = options; + this.controls = null; + this.canvas = null; + } + getPlayCanvasApp() { + return this.playcanvasApp; + } + getCamera() { + return this.camera; + } + getGraphicsAdapterFactory() { + return PlayCanvasGraphicsInterface; + } + static async create(element, options) { + const adapter = new _StandalonePlayCanvasAdapter(element, options); + await adapter.init(); + return adapter; + } + interactionShouldShowDistance(interaction) { + const cameraComponent = this.camera.camera; + if (!cameraComponent) { + console.error("Camera component not found"); + return null; + } + return PlayCanvasInteractionAdapter.interactionShouldShowDistance( + interaction, + this.camera, + cameraComponent, + this.playcanvasApp + ); + } + async init() { + WasmModule.setConfig("Ammo", { + glueUrl: "data:text/javascript;base64," + ammo_wasm_default, + wasmUrl: "data:application/octet-stream;base64," + ammo_wasm_default2 + }); + await new Promise((resolve) => { + WasmModule.getInstance("Ammo", () => resolve()); + }); + WasmModule.setConfig("DracoDecoderModule", { + glueUrl: "data:text/javascript;base64," + draco_wasm_default, + wasmUrl: "data:application/wasm;base64," + draco_wasm_default2 + }); + this.canvas = document.createElement("canvas"); + this.canvas.style.pointerEvents = "none"; + this.element.appendChild(this.canvas); + this.playcanvasApp = new AppBase(this.canvas); + const gfxOptions = { + deviceTypes: ["webgpu", "webgl2"], + glslangUrl: "data:text/javascript;base64," + glslang_default, + twgslUrl: "data:text/javascript;base64," + twgsl_default + }; + const soundManager = new SoundManager(); + const device = await createGraphicsDevice(this.canvas, gfxOptions); + device.maxPixelRatio = window.devicePixelRatio; + const createOptions = new AppOptions(); + createOptions.soundManager = soundManager; + createOptions.graphicsDevice = device; + createOptions.componentSystems = [ + RenderComponentSystem, + CollisionComponentSystem, + RigidBodyComponentSystem, + CameraComponentSystem, + LightComponentSystem, + ModelComponentSystem, + AnimComponentSystem, + SoundComponentSystem, + AudioListenerComponentSystem + ]; + createOptions.resourceHandlers = [ + AudioHandler, + TextureHandler, + ContainerHandler, + ModelHandler, + AnimationHandler + ]; + this.playcanvasApp.init(createOptions); + this.playcanvasApp.scene.physicalUnits = true; + this.playcanvasApp.setCanvasFillMode(FILLMODE_NONE); + this.playcanvasApp.setCanvasResolution(RESOLUTION_FIXED); + device.resizeCanvas(128, 128); + this.camera = new Entity("camera", this.playcanvasApp); + this.camera.addComponent("audiolistener"); + this.camera.addComponent("camera", { + fov: 75, + clearColor: new Color(1, 1, 1, 1) + }); + this.camera.setPosition(0, 5, 10); + this.playcanvasApp.root.addChild(this.camera); + this.setControlsType(this.options.controlsType); + this.clickTrigger = PlayCanvasClickTrigger.init(this.playcanvasApp, this.element, this.camera); + this.playcanvasApp.on("update", (delta) => { + if (this.controls) { + this.controls.update(delta); + } + }); + this.playcanvasApp.start(); + } + setControlsType(type2) { + if (this.controls) { + this.controls.dispose(); + this.controls = null; + } + switch (type2) { + case 0: + break; + case 2: + this.controls = new PlayCanvasOrbitCameraControls(this.camera, this.element); + break; + case 1: + default: + this.controls = new PlayCanvasDragFlyCameraControls(this.camera, this.element); + break; + } + if (this.controls) { + this.controls.enable(); + } + } + setCameraFOV(fov) { + const cameraComponent = this.camera.camera; + if (!cameraComponent) { + console.error("Camera component not found"); + return null; + } + cameraComponent.fov = fov; + } + start() { + } + getUserPositionAndRotation() { + const position2 = this.camera.getPosition(); + const rotation2 = this.camera.getEulerAngles(); + return { + position: { + x: position2.x, + y: position2.y, + z: position2.z + }, + rotation: { + x: rotation2.x, + y: rotation2.y, + z: rotation2.z + } + }; + } + resize(width, height) { + this.playcanvasApp.resizeCanvas(width, height); + this.playcanvasApp.graphicsDevice.resizeCanvas(width, height); + } + dispose() { + this.playcanvasApp.destroy(); + if (this.canvas) { + this.canvas.remove(); + this.canvas = null; + } + if (this.controls) { + this.controls.dispose(); + } + this.clickTrigger.dispose(); + } + getRootContainer() { + return this.playcanvasApp.root; + } + getBoundingBoxForElement(element) { + if (!(element instanceof TransformableElement)) { + return null; + } + const bounds = element.getContentBounds(); + if (!bounds) { + return null; + } + const camera = this.camera; + const cameraComponent = camera.camera; + if (!cameraComponent) { + throw new Error("Camera component not found"); + } + const renderer = this.playcanvasApp.graphicsDevice; + const clientWidth = renderer.canvas.clientWidth; + const clientHeight = renderer.canvas.clientHeight; + const toCanvasCoords = (point) => { + const vec2 = point.clone().applyMatrix4(new Matr4(camera.getWorldTransform().clone().invert().data)).applyMatrix4(new Matr4(cameraComponent.projectionMatrix.data)); + vec2.x = (vec2.x + 1) / 2 * clientWidth; + vec2.y = (1 - vec2.y) / 2 * clientHeight; + return vec2; + }; + const corners3D = bounds.getCorners(); + const corners2D = corners3D.map(toCanvasCoords); + const minX = Math.min(...corners2D.map((corner) => corner.x)); + const maxX = Math.max(...corners2D.map((corner) => corner.x)); + const minY = Math.min(...corners2D.map((corner) => corner.y)); + const maxY = Math.max(...corners2D.map((corner) => corner.y)); + return { + x: minX, + y: minY, + width: maxX - minX, + height: maxY - minY + }; + } +}; + +// src/PlayCanvasModeInternal.ts +var PlayCanvasModeInternal = class { + constructor(windowTarget, targetForWrappers, mmlSourceDefinition, formIteration) { + this.windowTarget = windowTarget; + this.targetForWrappers = targetForWrappers; + this.mmlSourceDefinition = mmlSourceDefinition; + this.formIteration = formIteration; + this.disposed = false; + this.type = "playcanvas"; + this.environmentMap = null; + this.loadedState = null; + this.init(); + } + async init() { + const fullScreenMMLScene = new FullScreenMMLScene(); + document.body.append(fullScreenMMLScene.element); + const graphicsAdapter = await StandalonePlayCanvasAdapter.create(fullScreenMMLScene.element, { + controlsType: StandalonePlayCanvasAdapterControlsType.DragFly + }); + if (this.disposed) { + graphicsAdapter.dispose(); + return; + } + fullScreenMMLScene.init(graphicsAdapter); + const statusUI = new StatusUI(); + const mmlNetworkSource = MMLNetworkSource.create({ + mmlScene: fullScreenMMLScene, + statusUpdated: (status) => { + if (status === NetworkedDOMWebsocketStatus.Connected) { + statusUI.setNoStatus(); + } else { + statusUI.setStatus(NetworkedDOMWebsocketStatusToString(status)); + } + }, + url: this.mmlSourceDefinition.url, + windowTarget: this.windowTarget, + targetForWrappers: this.targetForWrappers + }); + setDebugGlobals({ + mmlScene: fullScreenMMLScene, + remoteDocumentWrapper: mmlNetworkSource.remoteDocumentWrapper + }); + const loadingCallback = () => { + const [, completedLoading] = fullScreenMMLScene.getLoadingProgressManager().toRatio(); + if (completedLoading) { + fullScreenMMLScene.getLoadingProgressManager().removeProgressCallback(loadingCallback); + const fitContent = this.formIteration.getFieldValue(cameraFitContents); + if (fitContent === "true") { + graphicsAdapter.controls?.fitContent(calculateContentBounds(this.targetForWrappers)); + } + } + }; + fullScreenMMLScene.getLoadingProgressManager().addProgressCallback(loadingCallback); + this.loadedState = { + mmlNetworkSource, + graphicsAdapter, + fullScreenMMLScene, + statusUI + }; + this.update(this.formIteration); + } + update(formIteration) { + this.formIteration = formIteration; + if (!this.loadedState) { + return; + } + const graphicsAdapter = this.loadedState.graphicsAdapter; + const playcanvasScene = graphicsAdapter.getPlayCanvasApp().scene; + const cameraEntity = graphicsAdapter.getCamera(); + const cameraComponent = cameraEntity.camera; + this.setBackgroundColor(formIteration, cameraComponent); + this.setAmbientLight(formIteration, playcanvasScene); + this.setEnvironmentMap(formIteration, graphicsAdapter.getPlayCanvasApp(), playcanvasScene); + this.setCameraMode(formIteration, graphicsAdapter); + formIteration.completed(); + } + setEnvironmentMap(formIteration, playCanvasApp, playcanvasScene) { + let environmentMap = formIteration.getFieldValue(environmentMapField); + const foundEnvMap = envMaps[environmentMap]; + if (foundEnvMap) { + environmentMap = foundEnvMap.url; + } + if (!environmentMap) { + playcanvasScene.envAtlas = null; + playcanvasScene.skybox = null; + this.environmentMap = null; + return; + } + if (environmentMap === this.environmentMap) { + return; + } + const envMapAsset = new Asset("env-atlas", "texture", { url: environmentMap }); + playCanvasApp.assets.add(envMapAsset); + playCanvasApp.assets.load(envMapAsset); + const onEnvMapAssetLoad = (texture) => { + const skybox2 = EnvLighting.generateSkyboxCubemap(texture); + const lighting = EnvLighting.generateLightingSource(texture); + const envAtlas = EnvLighting.generateAtlas(lighting, {}); + lighting.destroy(); + playcanvasScene.envAtlas = envAtlas; + playcanvasScene.skybox = skybox2; + playcanvasScene.skyboxLuminance = 5e4; + }; + if (envMapAsset.loaded) { + onEnvMapAssetLoad(envMapAsset.resource); + } else { + envMapAsset.on("load", (envMapAsset2) => { + onEnvMapAssetLoad(envMapAsset2.resource); + }); + } + } + setAmbientLight(formIteration, playcanvasScene) { + const ambientLightIntensityString = formIteration.getFieldValue(ambientLightField) || "0"; + const ambientLightColorString = formIteration.getFieldValue(ambientLightColorField); + let ambientLightIntensity = parseFloat(ambientLightIntensityString); + if (isNaN(ambientLightIntensity)) { + ambientLightIntensity = 0; + } + if (ambientLightIntensity < 0) { + playcanvasScene.ambientLuminance = 0; + playcanvasScene.ambientLight = new Color(0, 0, 0); + } else { + const color = parseColorAttribute(ambientLightColorString, { + r: 1, + g: 1, + b: 1 + }); + playcanvasScene.ambientLuminance = ambientLightIntensity * 20; + playcanvasScene.ambientLight = new Color( + color.r * ambientLightIntensity * 20, + color.g * ambientLightIntensity * 20, + color.b * ambientLightIntensity * 20 + ); + } + } + setBackgroundColor(formIteration, cameraComponent) { + const backgroundColor = formIteration.getFieldValue(backgroundColorField); + if (!backgroundColor) { + cameraComponent.clearColor = new Color(0, 0, 0, 0); + return; + } + const color = parseColorAttribute(backgroundColor, { + r: 0, + g: 0, + b: 0, + a: 0 + }); + cameraComponent.clearColor = new Color(color.r, color.g, color.b, color.a); + } + setCameraMode(formIteration, graphicsAdapter) { + let cameraFOV = parseFloat(formIteration.getFieldValue(cameraFovField)); + if (isNaN(cameraFOV)) { + cameraFOV = 75; + } + graphicsAdapter.setCameraFOV(cameraFOV); + const cameraMode = formIteration.getFieldValue(cameraModeField); + if (cameraMode === "orbit") { + if (graphicsAdapter.controls?.type !== "orbit") { + graphicsAdapter.setControlsType(StandalonePlayCanvasAdapterControlsType.Orbit); + } + const controls = graphicsAdapter.controls; + let orbitSpeed = parseFloat(formIteration.getFieldValue(cameraOrbitSpeedField)); + if (isNaN(orbitSpeed)) { + orbitSpeed = 0; + } + controls.setDegreesPerSecond(orbitSpeed); + let orbitPitch = parseFloat(formIteration.getFieldValue(cameraOrbitPitchField)); + if (isNaN(orbitPitch)) { + orbitPitch = 0; + } + controls.setPitchDegrees(orbitPitch); + const fitContent = formIteration.getFieldValue(cameraFitContents); + if (fitContent === "true") { + controls.fitContent(calculateContentBounds(this.targetForWrappers)); + } else { + const lookAt = parseXYZ(formIteration.getFieldValue(cameraLookAtField)); + controls.setLookAt(lookAt[0], lookAt[1], lookAt[2]); + let orbitDistance = parseFloat(formIteration.getFieldValue(cameraOrbitDistanceField)); + if (isNaN(orbitDistance)) { + orbitDistance = 1; + } + controls.setDistance(orbitDistance); + } + } else if (cameraMode === "drag-fly") { + if (graphicsAdapter.controls?.type !== "drag-fly") { + graphicsAdapter.setControlsType(StandalonePlayCanvasAdapterControlsType.DragFly); + } + const controls = graphicsAdapter.controls; + const cameraPosition = parseXYZ(formIteration.getFieldValue(cameraPositionField)); + controls.setCameraPosition(cameraPosition[0], cameraPosition[1], cameraPosition[2]); + const lookAt = parseXYZ(formIteration.getFieldValue(cameraLookAtField)); + controls.setLookAt(lookAt[0], lookAt[1], lookAt[2]); + const fitContent = formIteration.getFieldValue(cameraFitContents); + if (fitContent === "true") { + controls.fitContent(calculateContentBounds(this.targetForWrappers)); + } + } else if (cameraMode === "none" && graphicsAdapter.controls !== null) { + graphicsAdapter.setControlsType(StandalonePlayCanvasAdapterControlsType.None); + } + } + dispose() { + this.disposed = true; + if (this.loadedState) { + this.loadedState.mmlNetworkSource.dispose(); + this.loadedState.graphicsAdapter.dispose(); + this.loadedState.fullScreenMMLScene.dispose(); + this.loadedState.statusUI.dispose(); + this.loadedState = null; + } + } +}; +export { + PlayCanvasModeInternal +}; +//# sourceMappingURL=PlayCanvasModeInternal-6JRQ32LR.js.map diff --git a/pull/212/v1/PlayCanvasModeInternal-6JRQ32LR.js.map b/pull/212/v1/PlayCanvasModeInternal-6JRQ32LR.js.map new file mode 100644 index 00000000..5859ad36 --- /dev/null +++ b/pull/212/v1/PlayCanvasModeInternal-6JRQ32LR.js.map @@ -0,0 +1,7 @@ +{ + "version": 3, + "sources": ["../../../node_modules/playcanvas/build/playcanvas/src/core/constants.js", "../../../node_modules/playcanvas/build/playcanvas/src/core/core.js", "../../../node_modules/playcanvas/build/playcanvas/src/core/event-handle.js", "../../../node_modules/playcanvas/build/playcanvas/src/core/event-handler.js", "../../../node_modules/playcanvas/build/playcanvas/src/core/events.js", "../../../node_modules/playcanvas/build/playcanvas/src/core/guid.js", "../../../node_modules/playcanvas/build/playcanvas/src/core/path.js", "../../../node_modules/playcanvas/build/playcanvas/src/core/platform.js", "../../../node_modules/playcanvas/build/playcanvas/src/core/string.js", "../../../node_modules/playcanvas/build/playcanvas/src/core/wasm-module.js", "../../../node_modules/playcanvas/build/playcanvas/src/core/read-stream.js", "../../../node_modules/playcanvas/build/playcanvas/src/core/tags.js", "../../../node_modules/playcanvas/build/playcanvas/src/core/time.js", "../../../node_modules/playcanvas/build/playcanvas/src/core/uri.js", "../../../node_modules/playcanvas/build/playcanvas/src/core/tracing.js", "../../../node_modules/playcanvas/build/playcanvas/src/core/math/math.js", "../../../node_modules/playcanvas/build/playcanvas/src/core/math/color.js", "../../../node_modules/playcanvas/build/playcanvas/src/core/math/float-packing.js", "../../../node_modules/playcanvas/build/playcanvas/src/core/math/vec3.js", "../../../node_modules/playcanvas/build/playcanvas/src/core/math/mat3.js", "../../../node_modules/playcanvas/build/playcanvas/src/core/math/vec2.js", "../../../node_modules/playcanvas/build/playcanvas/src/core/math/vec4.js", "../../../node_modules/playcanvas/build/playcanvas/src/core/math/mat4.js", "../../../node_modules/playcanvas/build/playcanvas/src/core/math/quat.js", "../../../node_modules/playcanvas/build/playcanvas/src/core/shape/bounding-box.js", "../../../node_modules/playcanvas/build/playcanvas/src/core/shape/bounding-sphere.js", "../../../node_modules/playcanvas/build/playcanvas/src/core/shape/frustum.js", "../../../node_modules/playcanvas/build/playcanvas/src/core/shape/ray.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/audio/constants.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/constants.js", "../../../node_modules/playcanvas/build/playcanvas/_virtual/_rollupPluginBabelHelpers.js", "../../../node_modules/playcanvas/build/playcanvas/src/core/math/bit-packing.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/blend-state.js", "../../../node_modules/playcanvas/build/playcanvas/src/core/string-ids.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/depth-state.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/version.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/versioned-object.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/scope-id.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/scope-space.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/vertex-buffer.js", "../../../node_modules/playcanvas/build/playcanvas/src/core/hash.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/device-cache.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/vertex-format.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/stencil-parameters.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/graphics-device.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/render-target.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-bind-group.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-utils.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/constants.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-bind-group-format.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-buffer.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-index-buffer.js", "../../../node_modules/playcanvas/build/playcanvas/src/core/array-utils.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-vertex-buffer-layout.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-pipeline.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-render-pipeline.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-compute-pipeline.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-render-target.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/uniform-buffer-format.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/bind-group-format.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/shader-processor.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-shader.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/texture-utils.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-texture.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-uniform-buffer.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-vertex-buffer.js", "../../../node_modules/playcanvas/build/playcanvas/src/core/preprocessor.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/shader.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/bind-group.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/dynamic-buffers.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/uniform-buffer.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-clear-renderer.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-mipmap-renderer.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-dynamic-buffer.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-dynamic-buffers.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/gpu-profiler.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-query-set.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-gpu-profiler.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-resolver.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-compute.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgpu/webgpu-graphics-device.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/texture.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgl/webgl-buffer.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgl/webgl-vertex-buffer.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgl/webgl-index-buffer.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgl/webgl-shader-input.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgl/webgl-shader.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgl/webgl-texture.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgl/webgl-render-target.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/shader-chunks/frag/gles2.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/shader-chunks/vert/gles2.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/shader-chunks/frag/gles3.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/shader-chunks/vert/gles3.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/shader-chunks/frag/webgpu.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/shader-chunks/vert/webgpu.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/shader-chunks/frag/shared.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/shader-utils.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgl/webgl-gpu-profiler.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/webgl/webgl-graphics-device.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/null/null-index-buffer.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/null/null-render-target.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/null/null-shader.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/null/null-texture.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/null/null-vertex-buffer.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/null/null-graphics-device.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/graphics-device-create.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/index-buffer.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/render-pass.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/shader-processor-options.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/graphics/vertex-iterator.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/input/constants.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/input/mouse-event.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/input/mouse.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/net/http.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/audio/capabilities.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/audio/channel.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/audio/channel3d.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/sound/listener.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/sound/manager.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/sound/sound.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/sound/instance.js", "../../../node_modules/playcanvas/build/playcanvas/src/platform/sound/instance3d.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/constants.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/alphaTest.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/ambientConstant.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/ambientEnv.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/ambientSH.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/ao.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/aoDetailMap.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/aoDiffuseOcc.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/aoSpecOcc.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/aoSpecOccConst.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/aoSpecOccConstSimple.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/aoSpecOccSimple.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/base.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/vert/base.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/baseNineSliced.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/vert/baseNineSliced.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/baseNineSlicedTiled.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/bayer.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/biasConst.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/blurVSM.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/clearCoat.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/clearCoatGloss.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/clearCoatNormal.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/clusteredLightUtils.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/clusteredLightCookies.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/clusteredLightShadows.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/clusteredLight.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/combine.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/cookie.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/cubeMapProjectBox.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/cubeMapProjectNone.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/cubeMapRotate.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/debug-output.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/debug-process-frontend.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/decode.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/detailModes.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/diffuse.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/diffuseDetailMap.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/emissive.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/encode.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/end.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/vert/end.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/envAtlas.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/envConst.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/envMultiply.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/extension.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/vert/extension.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/falloffInvSquared.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/falloffLinear.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/fixCubemapSeamsNone.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/fixCubemapSeamsStretch.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/float-unpacking.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/fogExp.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/fogExp2.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/fogLinear.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/fogNone.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/fresnelSchlick.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/fullscreenQuad.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/vert/fullscreenQuad.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/gamma1_0.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/gamma2_2.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/gloss.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/iridescenceDiffraction.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/iridescence.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/iridescenceThickness.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/vert/instancing.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/ior.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/lightDiffuseLambert.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/lightDirPoint.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/lightmapAdd.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/lightmapDirAdd.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/lightmapDir.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/lightmapSingle.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/lightSpecularAnisoGGX.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/lightSpecularBlinn.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/lightSpecularPhong.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/lightSheen.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/linearizeDepth.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/litShaderArgs.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/ltc.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/metalness.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/msdf.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/metalnessModulate.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/vert/msdf.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/vert/normal.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/normalDetailMap.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/vert/normalInstanced.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/normalMap.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/vert/normalSkinned.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/normalXY.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/normalXYZ.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/opacity.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/opacity-dither.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/output.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/outputAlpha.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/outputAlphaOpaque.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/outputAlphaPremul.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/outputTex2D.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/packDepth.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/sheen.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/sheenGloss.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/parallax.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particle.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/vert/particle.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/vert/particleAnimFrameClamp.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/vert/particleAnimFrameLoop.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/vert/particleAnimTex.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particleInputFloat.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particleInputRgba8.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particleOutputFloat.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particleOutputRgba8.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particleUpdaterAABB.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particleUpdaterEnd.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particleUpdaterInit.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particleUpdaterNoRespawn.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particleUpdaterOnStop.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particleUpdaterRespawn.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particleUpdaterSphere.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particleUpdaterStart.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/vert/particle_billboard.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particle_blendAdd.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particle_blendMultiply.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particle_blendNormal.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/vert/particle_cpu.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/vert/particle_cpu_end.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/vert/particle_customFace.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particle_end.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/vert/particle_end.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particle_halflambert.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/vert/particle_init.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particle_lambert.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particle_lighting.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/vert/particle_localShift.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/vert/particle_mesh.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/vert/particle_normal.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particle_normalMap.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/vert/particle_pointAlong.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/frag/particle_soft.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/vert/particle_soft.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/vert/particle_stretch.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/vert/particle_TBN.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/particle/vert/particle_wrap.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/reflDir.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/reflDirAniso.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/reflectionCC.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/reflectionCube.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/reflectionEnvHQ.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/reflectionEnv.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/reflectionSphere.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/reflectionSheen.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/refractionCube.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/refractionDynamic.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/reproject.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/sampleCatmullRom.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/screenDepth.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/shadowCascades.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/shadowEVSM.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/shadowEVSMn.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/shadowPCSS.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/shadowSampleCoord.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/shadowStandard.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/shadowStandardGL2.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/shadowVSM8.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/shadowVSM_common.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/vert/skinBatchConst.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/vert/skinBatchTex.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/vert/skinConst.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/vert/skinTex.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/skybox/frag/skyboxEnv.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/skybox/frag/skyboxHDR.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/skybox/vert/skybox.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/specular.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/spherical.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/specularityFactor.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/spot.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/start.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/vert/start.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/startNineSliced.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/startNineSlicedTiled.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/storeEVSM.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/vert/tangentBinormal.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/TBN.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/TBNderivative.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/TBNfast.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/TBNObjectSpace.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/textureSample.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/thickness.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/tonemappingAces.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/tonemappingAces2.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/tonemappingFilmic.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/tonemappingHejl.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/tonemappingLinear.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/tonemappingNeutral.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/frag/tonemappingNone.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/vert/transform.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/common/vert/transformDecl.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/standard/frag/transmission.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/twoSidedLighting.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/vert/uv0.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/vert/uv1.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/frag/viewDir.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/lit/vert/viewNormal.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunks/chunks.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/get-program-library.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/programs/shader-generator.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/utils.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/graphics/quad-render.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/graphics/render-pass-quad.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/graphics/quad-render-utils.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-pass.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/programs/basic.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/materials/default-material.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/materials/material.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/materials/basic-material.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/batching/batch.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/batching/batch-group.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/skin-instance.js", "../../../node_modules/playcanvas/build/playcanvas/src/core/ref-counted-object.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/mesh.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/graph-node.js", "../../../node_modules/playcanvas/build/playcanvas/src/core/ref-counted-cache.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/graphics/lightmap-cache.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/mesh-instance.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/graphics/render-pass-color-grab.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/graphics/render-pass-depth-grab.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/graphics/render-pass-depth.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/camera.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/programs/lit-shader-options.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/materials/lit-material-options-builder.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunk-builder.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/chunk-utils.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/renderer/light-camera.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/lighting/lights-buffer.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/programs/lit-shader.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/programs/lit-options-utils.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/lighting/world-clusters.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/renderer/shadow-map.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/lighting/light-texture-atlas.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/graphics/light-cube.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/renderer/shadow-map-cache.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/renderer/render-pass-shadow-local-non-clustered.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/renderer/shadow-renderer-local.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/renderer/render-pass-shadow-directional.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/renderer/shadow-renderer-directional.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/renderer/shadow-renderer.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/renderer/world-clusters-allocator.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/renderer/render-pass-cookie-renderer.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/renderer/render-pass-shadow-local-clustered.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/renderer/render-pass-update-clustered.js", "../../../node_modules/playcanvas/build/playcanvas/src/core/math/blue-noise.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/graphics/noise-textures.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/renderer/renderer.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/composition/render-action.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/renderer/render-pass-forward.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/renderer/render-pass-postprocessing.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/renderer/forward-renderer.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/layer.js", "../../../node_modules/playcanvas/build/playcanvas/src/core/sort.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/composition/layer-composition.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/light.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/lighting/lighting-params.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/morph-instance.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/model.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/morph.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/morph-target.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/programs/skybox.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/geometry/geometry-utils.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/geometry/geometry.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/geometry/box-geometry.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/geometry/sphere-geometry.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/geometry/dome-geometry.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/skybox/sky-geometry.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/skybox/sky-mesh.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/skybox/sky.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/immediate/immediate-batch.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/immediate/immediate-batches.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/immediate/immediate.js", "../../../node_modules/playcanvas/build/playcanvas/src/core/math/random.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/graphics/reproject-texture.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/graphics/env-lighting.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/scene.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/skin.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/materials/standard-material-options.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/programs/standard.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/materials/standard-material-options-builder.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/materials/standard-material-parameters.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/materials/standard-material.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/animation/animation.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/animation/skeleton.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/geometry/cone-base-geometry.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/geometry/capsule-geometry.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/geometry/cone-geometry.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/geometry/cylinder-geometry.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/geometry/plane-geometry.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/geometry/torus-geometry.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/shader-lib/program-library.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/constants.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/globals.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/script/script-types.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/script.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/frame-graph.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/area-light-luts.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/i18n/constants.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/i18n/utils.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/asset/constants.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/asset/asset-file.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/asset/asset.js", "../../../node_modules/playcanvas/build/playcanvas/src/core/tags-cache.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/asset/asset-registry.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/bundle/bundle-registry.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/components/registry.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/bundle/bundle.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/handlers/untar.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/handlers/handler.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/handlers/bundle.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/handlers/loader.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/i18n/i18n-parser.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/i18n/i18n.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/script/script-registry.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/entity.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/scene-registry-item.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/scene-registry.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/stats.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/app-base.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/app-options.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/components/component.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/components/system.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/anim/constants.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/anim/evaluator/anim-cache.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/anim/evaluator/anim-snapshot.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/anim/evaluator/anim-clip.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/anim/controller/constants.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/anim/evaluator/anim-blend.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/anim/evaluator/anim-target-value.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/anim/evaluator/anim-evaluator.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/anim/evaluator/anim-events.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/anim/evaluator/anim-track.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/anim/binder/anim-binder.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/anim/evaluator/anim-target.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/anim/binder/default-anim-binder.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/anim/controller/anim-node.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/anim/controller/anim-blend-tree.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/anim/controller/anim-blend-tree-1d.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/anim/controller/anim-blend-tree-2d-cartesian.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/anim/controller/anim-blend-tree-2d-directional.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/anim/controller/anim-blend-tree-direct.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/anim/controller/anim-state.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/anim/controller/anim-transition.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/anim/controller/anim-controller.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/components/anim/component-binder.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/components/anim/component-layer.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/anim/state-graph/anim-state-graph.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/components/anim/component.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/components/anim/data.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/components/anim/system.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/components/audio-listener/component.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/components/audio-listener/data.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/components/audio-listener/system.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/utils/entity-reference.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/components/collision/component.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/components/collision/data.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/components/rigid-body/constants.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/components/collision/trigger.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/components/collision/system.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/graphics/primitive-cache.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/components/model/component.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/components/model/data.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/components/model/system.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/skin-instance-cache.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/asset/asset-reference.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/components/render/component.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/components/render/data.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/components/render/system.js", "../../../node_modules/playcanvas/build/playcanvas/src/core/object-pool.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/components/rigid-body/component.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/components/rigid-body/data.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/components/rigid-body/system.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/components/sound/slot.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/components/sound/component.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/components/sound/data.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/components/sound/system.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/components/camera/post-effect-queue.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/components/camera/component.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/components/camera/data.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/components/camera/system.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/components/light/data.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/components/light/component.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/components/light/system.js", "../../../node_modules/playcanvas/build/playcanvas/src/scene/render.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/anim/evaluator/anim-curve.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/anim/evaluator/anim-data.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/parsers/draco-worker.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/parsers/draco-decoder.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/parsers/glb-parser.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/handlers/animation.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/handlers/audio.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/parsers/glb-container-resource.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/parsers/glb-container-parser.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/handlers/container.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/parsers/glb-model.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/parsers/json-model.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/handlers/model.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/handlers/basis-worker.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/handlers/basis.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/parsers/texture/texture.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/parsers/texture/basis.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/parsers/texture/img.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/parsers/texture/ktx.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/parsers/texture/ktx2.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/parsers/texture/dds.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/parsers/texture/hdr.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/handlers/texture.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/xr/constants.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/xr/xr-finger.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/xr/xr-joint.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/xr/xr-hand.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/xr/xr-input-source.js", "../../../node_modules/playcanvas/build/playcanvas/src/framework/input/element-input.js", "../../../node_modules/playcanvas/build/playcanvas/src/deprecated/deprecated.js", "../../../node_modules/@mml-io/mml-web-playcanvas/src/PlayCanvasClickTrigger.ts", "../../../node_modules/@mml-io/mml-web-playcanvas/src/elements/PlayCanvasAudio.ts", "../../../node_modules/@mml-io/mml-web-playcanvas/src/elements/PlayCanvasChatProbe.ts", "../../../node_modules/@mml-io/mml-web-playcanvas/src/elements/PlayCanvasCube.ts", "../../../node_modules/@mml-io/mml-web-playcanvas/src/elements/PlayCanvasCylinder.ts", "../../../node_modules/@mml-io/mml-web-playcanvas/src/elements/PlayCanvasDebugHelper.ts", "../../../node_modules/@mml-io/mml-web-playcanvas/src/debug-bounding-box/PlayCanvasDebugBoundingBox.ts", "../../../node_modules/@mml-io/mml-web-playcanvas/src/elements/PlayCanvasFrame.ts", "../../../node_modules/@mml-io/mml-web-playcanvas/src/elements/PlayCanvasImage.ts", "../../../node_modules/@mml-io/mml-web-playcanvas/src/plane/plane.ts", "../../../node_modules/@mml-io/mml-web-playcanvas/src/elements/PlayCanvasInteraction.ts", "../../../node_modules/@mml-io/mml-web-playcanvas/src/elements/PlayCanvasLabel.ts", "../../../node_modules/@mml-io/mml-web-playcanvas/src/elements/PlayCanvasLight.ts", "../../../node_modules/@mml-io/mml-web-playcanvas/src/elements/PlayCanvasLink.ts", "../../../node_modules/@mml-io/mml-web-playcanvas/src/elements/PlayCanvasMElement.ts", "../../../node_modules/@mml-io/mml-web-playcanvas/src/elements/PlayCanvasModel.ts", "../../../node_modules/@mml-io/mml-web-playcanvas/src/elements/PlayCanvasPlane.ts", "../../../node_modules/@mml-io/mml-web-playcanvas/src/elements/PlayCanvasPositionProbe.ts", "../../../node_modules/@mml-io/mml-web-playcanvas/src/elements/PlayCanvasPrompt.ts", "../../../node_modules/@mml-io/mml-web-playcanvas/src/elements/PlayCanvasRemoteDocument.ts", "../../../node_modules/@mml-io/mml-web-playcanvas/src/PlayCanvasReconnectingStatus.ts", "../../../node_modules/@mml-io/mml-web-playcanvas/src/elements/PlayCanvasSphere.ts", "../../../node_modules/@mml-io/mml-web-playcanvas/src/elements/PlayCanvasTransformable.ts", "../../../node_modules/@mml-io/mml-web-playcanvas/src/elements/PlayCanvasVideo.ts", "../../../node_modules/@mml-io/mml-web-playcanvas/src/PlayCanvasGraphicsInterface.ts", "../../../node_modules/@mml-io/mml-web-playcanvas/src/PlayCanvasInteractionAdapter.ts", "../../../node_modules/@mml-io/mml-web-playcanvas-standalone/src/controls/PlayCanvasDragFlyCameraControls.ts", "../../../node_modules/@mml-io/mml-web-playcanvas-standalone/src/controls/PlayCanvasOrbitCameraControls.ts", "../../../node_modules/@mml-io/mml-web-playcanvas-standalone/src/StandalonePlayCanvasAdapter.ts", "../../../node_modules/@mml-io/mml-web-playcanvas-standalone/build/base64:/home/runner/work/mml/mml/packages/mml-web-playcanvas-standalone/src/wasm/ammo.wasm.js", "../../../node_modules/@mml-io/mml-web-playcanvas-standalone/build/base64:/home/runner/work/mml/mml/packages/mml-web-playcanvas-standalone/src/wasm/ammo.wasm.wasm", "../../../node_modules/@mml-io/mml-web-playcanvas-standalone/build/base64:/home/runner/work/mml/mml/packages/mml-web-playcanvas-standalone/src/wasm/draco.wasm.js", "../../../node_modules/@mml-io/mml-web-playcanvas-standalone/build/base64:/home/runner/work/mml/mml/packages/mml-web-playcanvas-standalone/src/wasm/draco.wasm.wasm", "../../../node_modules/@mml-io/mml-web-playcanvas-standalone/build/base64:/home/runner/work/mml/mml/packages/mml-web-playcanvas-standalone/src/wasm/glslang.js", "../../../node_modules/@mml-io/mml-web-playcanvas-standalone/build/base64:/home/runner/work/mml/mml/packages/mml-web-playcanvas-standalone/src/wasm/twgsl.js", "../src/PlayCanvasModeInternal.ts"], + "sourcesContent": ["const TRACEID_RENDER_FRAME = 'RenderFrame';\nconst TRACEID_RENDER_FRAME_TIME = 'RenderFrameTime';\nconst TRACEID_RENDER_PASS = 'RenderPass';\nconst TRACEID_RENDER_PASS_DETAIL = 'RenderPassDetail';\nconst TRACEID_RENDER_ACTION = 'RenderAction';\nconst TRACEID_RENDER_TARGET_ALLOC = 'RenderTargetAlloc';\nconst TRACEID_TEXTURE_ALLOC = 'TextureAlloc';\nconst TRACEID_SHADER_ALLOC = 'ShaderAlloc';\nconst TRACEID_SHADER_COMPILE = 'ShaderCompile';\nconst TRACEID_VRAM_TEXTURE = 'VRAM.Texture';\nconst TRACEID_VRAM_VB = 'VRAM.Vb';\nconst TRACEID_VRAM_IB = 'VRAM.Ib';\nconst TRACEID_VRAM_SB = 'VRAM.Sb';\nconst TRACEID_BINDGROUP_ALLOC = 'BindGroupAlloc';\nconst TRACEID_BINDGROUPFORMAT_ALLOC = 'BindGroupFormatAlloc';\nconst TRACEID_RENDERPIPELINE_ALLOC = 'RenderPipelineAlloc';\nconst TRACEID_COMPUTEPIPELINE_ALLOC = 'ComputePipelineAlloc';\nconst TRACEID_PIPELINELAYOUT_ALLOC = 'PipelineLayoutAlloc';\nconst TRACE_ID_ELEMENT = \"Element\";\nconst TRACEID_TEXTURES = 'Textures';\nconst TRACEID_RENDER_QUEUE = 'RenderQueue';\nconst TRACEID_GPU_TIMINGS = 'GpuTimings';\n\nexport { TRACEID_BINDGROUPFORMAT_ALLOC, TRACEID_BINDGROUP_ALLOC, TRACEID_COMPUTEPIPELINE_ALLOC, TRACEID_GPU_TIMINGS, TRACEID_PIPELINELAYOUT_ALLOC, TRACEID_RENDERPIPELINE_ALLOC, TRACEID_RENDER_ACTION, TRACEID_RENDER_FRAME, TRACEID_RENDER_FRAME_TIME, TRACEID_RENDER_PASS, TRACEID_RENDER_PASS_DETAIL, TRACEID_RENDER_QUEUE, TRACEID_RENDER_TARGET_ALLOC, TRACEID_SHADER_ALLOC, TRACEID_SHADER_COMPILE, TRACEID_TEXTURES, TRACEID_TEXTURE_ALLOC, TRACEID_VRAM_IB, TRACEID_VRAM_SB, TRACEID_VRAM_TEXTURE, TRACEID_VRAM_VB, TRACE_ID_ELEMENT };\n", "const version = '1.73.5';\nconst revision = '26a4396';\nconst config = {};\nconst common = {};\nconst apps = {};\nconst data = {};\nconst typeofs = ['undefined', 'number', 'string', 'boolean'];\nconst objectTypes = {\n\t'[object Array]': 'array',\n\t'[object Object]': 'object',\n\t'[object Function]': 'function',\n\t'[object Date]': 'date',\n\t'[object RegExp]': 'regexp',\n\t'[object Float32Array]': 'float32array'\n};\nfunction type(obj) {\n\tif (obj === null) {\n\t\treturn 'null';\n\t}\n\tconst typeString = typeof obj;\n\tif (typeofs.includes(typeString)) {\n\t\treturn typeString;\n\t}\n\treturn objectTypes[Object.prototype.toString.call(obj)];\n}\nfunction extend(target, ex) {\n\tfor (const prop in ex) {\n\t\tconst copy = ex[prop];\n\t\tif (type(copy) === 'object') {\n\t\t\ttarget[prop] = extend({}, copy);\n\t\t} else if (type(copy) === 'array') {\n\t\t\ttarget[prop] = extend([], copy);\n\t\t} else {\n\t\t\ttarget[prop] = copy;\n\t\t}\n\t}\n\treturn target;\n}\n\nexport { apps, common, config, data, extend, revision, type, version };\n", "class EventHandle {\n\tconstructor(handler, name, callback, scope, once = false) {\n\t\tthis.handler = void 0;\n\t\tthis.name = void 0;\n\t\tthis.callback = void 0;\n\t\tthis.scope = void 0;\n\t\tthis._once = void 0;\n\t\tthis._removed = false;\n\t\tthis.handler = handler;\n\t\tthis.name = name;\n\t\tthis.callback = callback;\n\t\tthis.scope = scope;\n\t\tthis._once = once;\n\t}\n\toff() {\n\t\tif (this._removed) return;\n\t\tthis.handler.off(this.name, this.callback, this.scope);\n\t}\n\ton(name, callback, scope = this) {\n\t\treturn this.handler._addCallback(name, callback, scope, false);\n\t}\n\tonce(name, callback, scope = this) {\n\t\treturn this.handler._addCallback(name, callback, scope, true);\n\t}\n\tset removed(value) {\n\t\tif (!value) return;\n\t\tthis._removed = true;\n\t}\n\tget removed() {\n\t\treturn this._removed;\n\t}\n}\n\nexport { EventHandle };\n", "import { EventHandle } from './event-handle.js';\n\nclass EventHandler {\n\tconstructor() {\n\t\tthis._callbacks = new Map();\n\t\tthis._callbackActive = new Map();\n\t}\n\tinitEventHandler() {\n\t\tthis._callbacks = new Map();\n\t\tthis._callbackActive = new Map();\n\t}\n\t_addCallback(name, callback, scope, once) {\n\t\tif (!this._callbacks.has(name)) this._callbacks.set(name, []);\n\t\tif (this._callbackActive.has(name)) {\n\t\t\tconst callbackActive = this._callbackActive.get(name);\n\t\t\tif (callbackActive && callbackActive === this._callbacks.get(name)) {\n\t\t\t\tthis._callbackActive.set(name, callbackActive.slice());\n\t\t\t}\n\t\t}\n\t\tconst evt = new EventHandle(this, name, callback, scope, once);\n\t\tthis._callbacks.get(name).push(evt);\n\t\treturn evt;\n\t}\n\ton(name, callback, scope = this) {\n\t\treturn this._addCallback(name, callback, scope, false);\n\t}\n\tonce(name, callback, scope = this) {\n\t\treturn this._addCallback(name, callback, scope, true);\n\t}\n\toff(name, callback, scope) {\n\t\tif (name) {\n\t\t\tif (this._callbackActive.has(name) && this._callbackActive.get(name) === this._callbacks.get(name)) this._callbackActive.set(name, this._callbackActive.get(name).slice());\n\t\t} else {\n\t\t\tfor (const [key, callbacks] of this._callbackActive) {\n\t\t\t\tif (!this._callbacks.has(key)) continue;\n\t\t\t\tif (this._callbacks.get(key) !== callbacks) continue;\n\t\t\t\tthis._callbackActive.set(key, callbacks.slice());\n\t\t\t}\n\t\t}\n\t\tif (!name) {\n\t\t\tfor (const callbacks of this._callbacks.values()) {\n\t\t\t\tfor (let i = 0; i < callbacks.length; i++) {\n\t\t\t\t\tcallbacks[i].removed = true;\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis._callbacks.clear();\n\t\t} else if (!callback) {\n\t\t\tconst callbacks = this._callbacks.get(name);\n\t\t\tif (callbacks) {\n\t\t\t\tfor (let i = 0; i < callbacks.length; i++) {\n\t\t\t\t\tcallbacks[i].removed = true;\n\t\t\t\t}\n\t\t\t\tthis._callbacks.delete(name);\n\t\t\t}\n\t\t} else {\n\t\t\tconst callbacks = this._callbacks.get(name);\n\t\t\tif (!callbacks) return this;\n\t\t\tfor (let i = 0; i < callbacks.length; i++) {\n\t\t\t\tif (callbacks[i].callback !== callback) continue;\n\t\t\t\tif (scope && callbacks[i].scope !== scope) continue;\n\t\t\t\tcallbacks[i].removed = true;\n\t\t\t\tcallbacks.splice(i, 1);\n\t\t\t\ti--;\n\t\t\t}\n\t\t\tif (callbacks.length === 0) this._callbacks.delete(name);\n\t\t}\n\t\treturn this;\n\t}\n\tfire(name, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) {\n\t\tif (!name) return this;\n\t\tconst callbacksInitial = this._callbacks.get(name);\n\t\tif (!callbacksInitial) return this;\n\t\tlet callbacks;\n\t\tif (!this._callbackActive.has(name)) {\n\t\t\tthis._callbackActive.set(name, callbacksInitial);\n\t\t} else if (this._callbackActive.get(name) !== callbacksInitial) {\n\t\t\tcallbacks = callbacksInitial.slice();\n\t\t}\n\t\tfor (let i = 0; (callbacks || this._callbackActive.get(name)) && i < (callbacks || this._callbackActive.get(name)).length; i++) {\n\t\t\tconst evt = (callbacks || this._callbackActive.get(name))[i];\n\t\t\tif (!evt.callback) continue;\n\t\t\tevt.callback.call(evt.scope, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);\n\t\t\tif (evt._once) {\n\t\t\t\tconst existingCallback = this._callbacks.get(name);\n\t\t\t\tconst ind = existingCallback ? existingCallback.indexOf(evt) : -1;\n\t\t\t\tif (ind !== -1) {\n\t\t\t\t\tif (this._callbackActive.get(name) === existingCallback) this._callbackActive.set(name, this._callbackActive.get(name).slice());\n\t\t\t\t\tconst _callbacks = this._callbacks.get(name);\n\t\t\t\t\tif (!_callbacks) continue;\n\t\t\t\t\t_callbacks[ind].removed = true;\n\t\t\t\t\t_callbacks.splice(ind, 1);\n\t\t\t\t\tif (_callbacks.length === 0) this._callbacks.delete(name);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (!callbacks) this._callbackActive.delete(name);\n\t\treturn this;\n\t}\n\thasEvent(name) {\n\t\tvar _this$_callbacks$get;\n\t\treturn !!((_this$_callbacks$get = this._callbacks.get(name)) != null && _this$_callbacks$get.length);\n\t}\n}\n\nexport { EventHandler };\n", "import { EventHandler } from './event-handler.js';\n\nconst events = {\n\tattach(target) {\n\t\tconst ev = events;\n\t\ttarget._addCallback = ev._addCallback;\n\t\ttarget.on = ev.on;\n\t\ttarget.off = ev.off;\n\t\ttarget.fire = ev.fire;\n\t\ttarget.once = ev.once;\n\t\ttarget.hasEvent = ev.hasEvent;\n\t\tEventHandler.prototype.initEventHandler.call(target);\n\t\treturn target;\n\t},\n\t_addCallback: EventHandler.prototype._addCallback,\n\ton: EventHandler.prototype.on,\n\toff: EventHandler.prototype.off,\n\tfire: EventHandler.prototype.fire,\n\tonce: EventHandler.prototype.once,\n\thasEvent: EventHandler.prototype.hasEvent\n};\n\nexport { events };\n", "const guid = {\n\tcreate() {\n\t\treturn 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {\n\t\t\tconst r = Math.random() * 16 | 0;\n\t\t\tconst v = c === 'x' ? r : r & 0x3 | 0x8;\n\t\t\treturn v.toString(16);\n\t\t});\n\t}\n};\n\nexport { guid };\n", "const path = {\n\tdelimiter: '/',\n\tjoin(...sections) {\n\t\tlet result = sections[0];\n\t\tfor (let i = 0; i < sections.length - 1; i++) {\n\t\t\tconst one = sections[i];\n\t\t\tconst two = sections[i + 1];\n\t\t\tif (two[0] === path.delimiter) {\n\t\t\t\tresult = two;\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif (one && two && one[one.length - 1] !== path.delimiter && two[0] !== path.delimiter) {\n\t\t\t\tresult += path.delimiter + two;\n\t\t\t} else {\n\t\t\t\tresult += two;\n\t\t\t}\n\t\t}\n\t\treturn result;\n\t},\n\tnormalize(pathname) {\n\t\tconst lead = pathname.startsWith(path.delimiter);\n\t\tconst trail = pathname.endsWith(path.delimiter);\n\t\tconst parts = pathname.split('/');\n\t\tlet result = '';\n\t\tlet cleaned = [];\n\t\tfor (let i = 0; i < parts.length; i++) {\n\t\t\tif (parts[i] === '') continue;\n\t\t\tif (parts[i] === '.') continue;\n\t\t\tif (parts[i] === '..' && cleaned.length > 0) {\n\t\t\t\tcleaned = cleaned.slice(0, cleaned.length - 2);\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif (i > 0) cleaned.push(path.delimiter);\n\t\t\tcleaned.push(parts[i]);\n\t\t}\n\t\tresult = cleaned.join('');\n\t\tif (!lead && result[0] === path.delimiter) {\n\t\t\tresult = result.slice(1);\n\t\t}\n\t\tif (trail && result[result.length - 1] !== path.delimiter) {\n\t\t\tresult += path.delimiter;\n\t\t}\n\t\treturn result;\n\t},\n\tsplit(pathname) {\n\t\tconst lastDelimiterIndex = pathname.lastIndexOf(path.delimiter);\n\t\tif (lastDelimiterIndex !== -1) {\n\t\t\treturn [pathname.substring(0, lastDelimiterIndex), pathname.substring(lastDelimiterIndex + 1)];\n\t\t}\n\t\treturn [\"\", pathname];\n\t},\n\tgetBasename(pathname) {\n\t\treturn path.split(pathname)[1];\n\t},\n\tgetDirectory(pathname) {\n\t\treturn path.split(pathname)[0];\n\t},\n\tgetExtension(pathname) {\n\t\tconst ext = pathname.split('?')[0].split('.').pop();\n\t\tif (ext !== pathname) {\n\t\t\treturn '.' + ext;\n\t\t}\n\t\treturn '';\n\t},\n\tisRelativePath(pathname) {\n\t\treturn pathname.charAt(0) !== '/' && pathname.match(/:\\/\\//) === null;\n\t},\n\textractPath(pathname) {\n\t\tlet result = '';\n\t\tconst parts = pathname.split('/');\n\t\tlet i = 0;\n\t\tif (parts.length > 1) {\n\t\t\tif (path.isRelativePath(pathname)) {\n\t\t\t\tif (parts[0] === '.') {\n\t\t\t\t\tfor (i = 0; i < parts.length - 1; ++i) {\n\t\t\t\t\t\tresult += i === 0 ? parts[i] : '/' + parts[i];\n\t\t\t\t\t}\n\t\t\t\t} else if (parts[0] === '..') {\n\t\t\t\t\tfor (i = 0; i < parts.length - 1; ++i) {\n\t\t\t\t\t\tresult += i === 0 ? parts[i] : '/' + parts[i];\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tresult = '.';\n\t\t\t\t\tfor (i = 0; i < parts.length - 1; ++i) {\n\t\t\t\t\t\tresult += '/' + parts[i];\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tfor (i = 0; i < parts.length - 1; ++i) {\n\t\t\t\t\tresult += i === 0 ? parts[i] : '/' + parts[i];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn result;\n\t}\n};\n\nexport { path };\n", "var _ref, _ref2, _ref3;\nconst detectPassiveEvents = () => {\n\tlet result = false;\n\ttry {\n\t\tconst opts = Object.defineProperty({}, 'passive', {\n\t\t\tget: function () {\n\t\t\t\tresult = true;\n\t\t\t\treturn false;\n\t\t\t}\n\t\t});\n\t\twindow.addEventListener('testpassive', null, opts);\n\t\twindow.removeEventListener('testpassive', null, opts);\n\t} catch (e) {}\n\treturn result;\n};\nconst ua = typeof navigator !== 'undefined' ? navigator.userAgent : '';\nconst environment = typeof window !== 'undefined' ? 'browser' : typeof global !== 'undefined' ? 'node' : 'worker';\nconst platformName = /android/i.test(ua) ? 'android' : /ip([ao]d|hone)/i.test(ua) ? 'ios' : /windows/i.test(ua) ? 'windows' : /mac os/i.test(ua) ? 'osx' : /linux/i.test(ua) ? 'linux' : /cros/i.test(ua) ? 'cros' : null;\nconst browserName = environment !== 'browser' ? null : /(Chrome\\/|Chromium\\/|Edg.*\\/)/.test(ua) ? 'chrome' : /Safari\\//.test(ua) ? 'safari' : /Firefox\\//.test(ua) ? 'firefox' : 'other';\nconst xbox = /xbox/i.test(ua);\nconst touch = environment === 'browser' && ('ontouchstart' in window || 'maxTouchPoints' in navigator && navigator.maxTouchPoints > 0);\nconst gamepads = environment === 'browser' && (!!navigator.getGamepads || !!navigator.webkitGetGamepads);\nconst workers = typeof Worker !== 'undefined';\nconst passiveEvents = detectPassiveEvents();\nconst platform = {\n\tname: platformName,\n\tenvironment: environment,\n\tglobal: (_ref = (_ref2 = (_ref3 = typeof globalThis !== 'undefined' && globalThis) != null ? _ref3 : environment === 'browser' && window) != null ? _ref2 : environment === 'node' && global) != null ? _ref : environment === 'worker' && self,\n\tbrowser: environment === 'browser',\n\tworker: environment === 'worker',\n\tdesktop: ['windows', 'osx', 'linux', 'cros'].includes(platformName),\n\tmobile: ['android', 'ios'].includes(platformName),\n\tios: platformName === 'ios',\n\tandroid: platformName === 'android',\n\txbox: xbox,\n\tgamepads: gamepads,\n\ttouch: touch,\n\tworkers: workers,\n\tpassiveEvents: passiveEvents,\n\tbrowserName: browserName\n};\n\nexport { platform };\n", "const ASCII_LOWERCASE = 'abcdefghijklmnopqrstuvwxyz';\nconst ASCII_UPPERCASE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';\nconst ASCII_LETTERS = ASCII_LOWERCASE + ASCII_UPPERCASE;\nconst HIGH_SURROGATE_BEGIN = 0xD800;\nconst HIGH_SURROGATE_END = 0xDBFF;\nconst LOW_SURROGATE_BEGIN = 0xDC00;\nconst LOW_SURROGATE_END = 0xDFFF;\nconst ZERO_WIDTH_JOINER = 0x200D;\nconst REGIONAL_INDICATOR_BEGIN = 0x1F1E6;\nconst REGIONAL_INDICATOR_END = 0x1F1FF;\nconst FITZPATRICK_MODIFIER_BEGIN = 0x1F3FB;\nconst FITZPATRICK_MODIFIER_END = 0x1F3FF;\nconst DIACRITICAL_MARKS_BEGIN = 0x20D0;\nconst DIACRITICAL_MARKS_END = 0x20FF;\nconst VARIATION_MODIFIER_BEGIN = 0xFE00;\nconst VARIATION_MODIFIER_END = 0xFE0F;\nfunction getCodePointData(string, i = 0) {\n\tconst size = string.length;\n\tif (i < 0 || i >= size) {\n\t\treturn null;\n\t}\n\tconst first = string.charCodeAt(i);\n\tif (size > 1 && first >= HIGH_SURROGATE_BEGIN && first <= HIGH_SURROGATE_END) {\n\t\tconst second = string.charCodeAt(i + 1);\n\t\tif (second >= LOW_SURROGATE_BEGIN && second <= LOW_SURROGATE_END) {\n\t\t\treturn {\n\t\t\t\tcode: (first - HIGH_SURROGATE_BEGIN) * 0x400 + second - LOW_SURROGATE_BEGIN + 0x10000,\n\t\t\t\tlong: true\n\t\t\t};\n\t\t}\n\t}\n\treturn {\n\t\tcode: first,\n\t\tlong: false\n\t};\n}\nfunction isCodeBetween(string, begin, end) {\n\tif (!string) return false;\n\tconst codeData = getCodePointData(string);\n\tif (codeData) {\n\t\tconst code = codeData.code;\n\t\treturn code >= begin && code <= end;\n\t}\n\treturn false;\n}\nfunction numCharsToTakeForNextSymbol(string, index) {\n\tif (index === string.length - 1) {\n\t\treturn 1;\n\t}\n\tif (isCodeBetween(string[index], HIGH_SURROGATE_BEGIN, HIGH_SURROGATE_END)) {\n\t\tconst first = string.substring(index, index + 2);\n\t\tconst second = string.substring(index + 2, index + 4);\n\t\tif (isCodeBetween(second, FITZPATRICK_MODIFIER_BEGIN, FITZPATRICK_MODIFIER_END) || isCodeBetween(first, REGIONAL_INDICATOR_BEGIN, REGIONAL_INDICATOR_END) && isCodeBetween(second, REGIONAL_INDICATOR_BEGIN, REGIONAL_INDICATOR_END)) {\n\t\t\treturn 4;\n\t\t}\n\t\tif (isCodeBetween(second, VARIATION_MODIFIER_BEGIN, VARIATION_MODIFIER_END)) {\n\t\t\treturn 3;\n\t\t}\n\t\treturn 2;\n\t}\n\tif (isCodeBetween(string[index + 1], VARIATION_MODIFIER_BEGIN, VARIATION_MODIFIER_END)) {\n\t\treturn 2;\n\t}\n\treturn 1;\n}\nconst string = {\n\tASCII_LOWERCASE: ASCII_LOWERCASE,\n\tASCII_UPPERCASE: ASCII_UPPERCASE,\n\tASCII_LETTERS: ASCII_LETTERS,\n\tformat(s, ...args) {\n\t\tfor (let i = 0; i < args.length; i++) {\n\t\t\ts = s.replace(`{${i}}`, args[i]);\n\t\t}\n\t\treturn s;\n\t},\n\tgetCodePoint(string, i) {\n\t\tconst codePointData = getCodePointData(string, i);\n\t\treturn codePointData && codePointData.code;\n\t},\n\tgetCodePoints(string) {\n\t\tif (typeof string !== 'string') {\n\t\t\tthrow new TypeError('Not a string');\n\t\t}\n\t\tlet i = 0;\n\t\tconst arr = [];\n\t\tlet codePoint;\n\t\twhile (!!(codePoint = getCodePointData(string, i))) {\n\t\t\tarr.push(codePoint.code);\n\t\t\ti += codePoint.long ? 2 : 1;\n\t\t}\n\t\treturn arr;\n\t},\n\tgetSymbols(string) {\n\t\tif (typeof string !== 'string') {\n\t\t\tthrow new TypeError('Not a string');\n\t\t}\n\t\tlet index = 0;\n\t\tconst length = string.length;\n\t\tconst output = [];\n\t\tlet take = 0;\n\t\tlet ch;\n\t\twhile (index < length) {\n\t\t\ttake += numCharsToTakeForNextSymbol(string, index + take);\n\t\t\tch = string[index + take];\n\t\t\tif (isCodeBetween(ch, DIACRITICAL_MARKS_BEGIN, DIACRITICAL_MARKS_END)) {\n\t\t\t\tch = string[index + take++];\n\t\t\t}\n\t\t\tif (isCodeBetween(ch, VARIATION_MODIFIER_BEGIN, VARIATION_MODIFIER_END)) {\n\t\t\t\tch = string[index + take++];\n\t\t\t}\n\t\t\tif (ch && ch.charCodeAt(0) === ZERO_WIDTH_JOINER) {\n\t\t\t\tch = string[index + take++];\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tconst char = string.substring(index, index + take);\n\t\t\toutput.push(char);\n\t\t\tindex += take;\n\t\t\ttake = 0;\n\t\t}\n\t\treturn output;\n\t},\n\tfromCodePoint() {\n\t\tconst chars = [];\n\t\tlet current;\n\t\tlet codePoint;\n\t\tlet units;\n\t\tfor (let i = 0; i < arguments.length; ++i) {\n\t\t\tcurrent = Number(arguments[i]);\n\t\t\tcodePoint = current - 0x10000;\n\t\t\tunits = current > 0xFFFF ? [(codePoint >> 10) + 0xD800, codePoint % 0x400 + 0xDC00] : [current];\n\t\t\tchars.push(String.fromCharCode.apply(null, units));\n\t\t}\n\t\treturn chars.join('');\n\t}\n};\n\nexport { string };\n", "const cachedResult = func => {\n\tconst uninitToken = {};\n\tlet result = uninitToken;\n\treturn () => {\n\t\tif (result === uninitToken) {\n\t\t\tresult = func();\n\t\t}\n\t\treturn result;\n\t};\n};\nclass Impl {\n\tstatic loadScript(url, callback) {\n\t\tconst s = document.createElement('script');\n\t\ts.setAttribute('src', url);\n\t\ts.onload = () => {\n\t\t\tcallback(null);\n\t\t};\n\t\ts.onerror = () => {\n\t\t\tcallback(`Failed to load script='${url}'`);\n\t\t};\n\t\tdocument.body.appendChild(s);\n\t}\n\tstatic loadWasm(moduleName, config, callback) {\n\t\tconst loadUrl = Impl.wasmSupported() && config.glueUrl && config.wasmUrl ? config.glueUrl : config.fallbackUrl;\n\t\tif (loadUrl) {\n\t\t\tImpl.loadScript(loadUrl, err => {\n\t\t\t\tif (err) {\n\t\t\t\t\tcallback(err, null);\n\t\t\t\t} else {\n\t\t\t\t\tconst module = window[moduleName];\n\t\t\t\t\twindow[moduleName] = undefined;\n\t\t\t\t\tmodule({\n\t\t\t\t\t\tlocateFile: () => config.wasmUrl,\n\t\t\t\t\t\tonAbort: () => {\n\t\t\t\t\t\t\tcallback('wasm module aborted.');\n\t\t\t\t\t\t}\n\t\t\t\t\t}).then(instance => {\n\t\t\t\t\t\tcallback(null, instance);\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t});\n\t\t} else {\n\t\t\tcallback('No supported wasm modules found.', null);\n\t\t}\n\t}\n\tstatic getModule(name) {\n\t\tif (!Impl.modules.hasOwnProperty(name)) {\n\t\t\tImpl.modules[name] = {\n\t\t\t\tconfig: null,\n\t\t\t\tinitializing: false,\n\t\t\t\tinstance: null,\n\t\t\t\tcallbacks: []\n\t\t\t};\n\t\t}\n\t\treturn Impl.modules[name];\n\t}\n\tstatic initialize(moduleName, module) {\n\t\tif (module.initializing) {\n\t\t\treturn;\n\t\t}\n\t\tconst config = module.config;\n\t\tif (config.glueUrl || config.wasmUrl || config.fallbackUrl) {\n\t\t\tmodule.initializing = true;\n\t\t\tImpl.loadWasm(moduleName, config, (err, instance) => {\n\t\t\t\tif (err) {\n\t\t\t\t\tif (config.errorHandler) {\n\t\t\t\t\t\tconfig.errorHandler(err);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tconsole.error(`failed to initialize module=${moduleName} error=${err}`);\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tmodule.instance = instance;\n\t\t\t\t\tmodule.callbacks.forEach(callback => {\n\t\t\t\t\t\tcallback(instance);\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\t}\n}\nImpl.modules = {};\nImpl.wasmSupported = cachedResult(() => {\n\ttry {\n\t\tif (typeof WebAssembly === \"object\" && typeof WebAssembly.instantiate === \"function\") {\n\t\t\tconst module = new WebAssembly.Module(Uint8Array.of(0x0, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00));\n\t\t\tif (module instanceof WebAssembly.Module) return new WebAssembly.Instance(module) instanceof WebAssembly.Instance;\n\t\t}\n\t} catch (e) {}\n\treturn false;\n});\nclass WasmModule {\n\tstatic setConfig(moduleName, config) {\n\t\tconst module = Impl.getModule(moduleName);\n\t\tmodule.config = config;\n\t\tif (module.callbacks.length > 0) {\n\t\t\tImpl.initialize(moduleName, module);\n\t\t}\n\t}\n\tstatic getConfig(moduleName) {\n\t\tvar _Impl$modules;\n\t\treturn (_Impl$modules = Impl.modules) == null || (_Impl$modules = _Impl$modules[moduleName]) == null ? void 0 : _Impl$modules.config;\n\t}\n\tstatic getInstance(moduleName, callback) {\n\t\tconst module = Impl.getModule(moduleName);\n\t\tif (module.instance) {\n\t\t\tcallback(module.instance);\n\t\t} else {\n\t\t\tmodule.callbacks.push(callback);\n\t\t\tif (module.config) {\n\t\t\t\tImpl.initialize(moduleName, module);\n\t\t\t}\n\t\t}\n\t}\n}\n\nexport { WasmModule };\n", "class ReadStream {\n\tconstructor(arraybuffer) {\n\t\tthis.arraybuffer = void 0;\n\t\tthis.dataView = void 0;\n\t\tthis.offset = 0;\n\t\tthis.arraybuffer = arraybuffer;\n\t\tthis.dataView = new DataView(arraybuffer);\n\t}\n\tget remainingBytes() {\n\t\treturn this.dataView.byteLength - this.offset;\n\t}\n\treset(offset = 0) {\n\t\tthis.offset = offset;\n\t}\n\tskip(bytes) {\n\t\tthis.offset += bytes;\n\t}\n\talign(bytes) {\n\t\tthis.offset = this.offset + bytes - 1 & ~(bytes - 1);\n\t}\n\t_inc(amount) {\n\t\tthis.offset += amount;\n\t\treturn this.offset - amount;\n\t}\n\treadChar() {\n\t\treturn String.fromCharCode(this.dataView.getUint8(this.offset++));\n\t}\n\treadChars(numChars) {\n\t\tlet result = '';\n\t\tfor (let i = 0; i < numChars; ++i) {\n\t\t\tresult += this.readChar();\n\t\t}\n\t\treturn result;\n\t}\n\treadU8() {\n\t\treturn this.dataView.getUint8(this.offset++);\n\t}\n\treadU16() {\n\t\treturn this.dataView.getUint16(this._inc(2), true);\n\t}\n\treadU32() {\n\t\treturn this.dataView.getUint32(this._inc(4), true);\n\t}\n\treadU64() {\n\t\treturn this.readU32() + 2 ** 32 * this.readU32();\n\t}\n\treadU32be() {\n\t\treturn this.dataView.getUint32(this._inc(4), false);\n\t}\n\treadArray(result) {\n\t\tfor (let i = 0; i < result.length; ++i) {\n\t\t\tresult[i] = this.readU8();\n\t\t}\n\t}\n\treadLine() {\n\t\tconst view = this.dataView;\n\t\tlet result = '';\n\t\twhile (true) {\n\t\t\tif (this.offset >= view.byteLength) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tconst c = String.fromCharCode(this.readU8());\n\t\t\tif (c === '\\n') {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tresult += c;\n\t\t}\n\t\treturn result;\n\t}\n}\n\nexport { ReadStream };\n", "import { EventHandler } from './event-handler.js';\n\nclass Tags extends EventHandler {\n\tconstructor(parent) {\n\t\tsuper();\n\t\tthis._index = {};\n\t\tthis._list = [];\n\t\tthis._parent = parent;\n\t}\n\tadd(...args) {\n\t\tlet changed = false;\n\t\tconst tags = this._processArguments(args, true);\n\t\tif (!tags.length) return changed;\n\t\tfor (let i = 0; i < tags.length; i++) {\n\t\t\tif (this._index[tags[i]]) continue;\n\t\t\tchanged = true;\n\t\t\tthis._index[tags[i]] = true;\n\t\t\tthis._list.push(tags[i]);\n\t\t\tthis.fire('add', tags[i], this._parent);\n\t\t}\n\t\tif (changed) this.fire('change', this._parent);\n\t\treturn changed;\n\t}\n\tremove(...args) {\n\t\tlet changed = false;\n\t\tif (!this._list.length) return changed;\n\t\tconst tags = this._processArguments(args, true);\n\t\tif (!tags.length) return changed;\n\t\tfor (let i = 0; i < tags.length; i++) {\n\t\t\tif (!this._index[tags[i]]) continue;\n\t\t\tchanged = true;\n\t\t\tdelete this._index[tags[i]];\n\t\t\tthis._list.splice(this._list.indexOf(tags[i]), 1);\n\t\t\tthis.fire('remove', tags[i], this._parent);\n\t\t}\n\t\tif (changed) this.fire('change', this._parent);\n\t\treturn changed;\n\t}\n\tclear() {\n\t\tif (!this._list.length) return;\n\t\tconst tags = this._list.slice(0);\n\t\tthis._list = [];\n\t\tthis._index = {};\n\t\tfor (let i = 0; i < tags.length; i++) this.fire('remove', tags[i], this._parent);\n\t\tthis.fire('change', this._parent);\n\t}\n\thas(...query) {\n\t\tif (!this._list.length) return false;\n\t\treturn this._has(this._processArguments(query));\n\t}\n\t_has(tags) {\n\t\tif (!this._list.length || !tags.length) return false;\n\t\tfor (let i = 0; i < tags.length; i++) {\n\t\t\tif (tags[i].length === 1) {\n\t\t\t\tif (this._index[tags[i][0]]) return true;\n\t\t\t} else {\n\t\t\t\tlet multiple = true;\n\t\t\t\tfor (let t = 0; t < tags[i].length; t++) {\n\t\t\t\t\tif (this._index[tags[i][t]]) continue;\n\t\t\t\t\tmultiple = false;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\tif (multiple) return true;\n\t\t\t}\n\t\t}\n\t\treturn false;\n\t}\n\tlist() {\n\t\treturn this._list.slice(0);\n\t}\n\t_processArguments(args, flat) {\n\t\tconst tags = [];\n\t\tlet tmp = [];\n\t\tif (!args || !args.length) return tags;\n\t\tfor (let i = 0; i < args.length; i++) {\n\t\t\tif (args[i] instanceof Array) {\n\t\t\t\tif (!flat) tmp = [];\n\t\t\t\tfor (let t = 0; t < args[i].length; t++) {\n\t\t\t\t\tif (typeof args[i][t] !== 'string') continue;\n\t\t\t\t\tif (flat) {\n\t\t\t\t\t\ttags.push(args[i][t]);\n\t\t\t\t\t} else {\n\t\t\t\t\t\ttmp.push(args[i][t]);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tif (!flat && tmp.length) tags.push(tmp);\n\t\t\t} else if (typeof args[i] === 'string') {\n\t\t\t\tif (flat) {\n\t\t\t\t\ttags.push(args[i]);\n\t\t\t\t} else {\n\t\t\t\t\ttags.push([args[i]]);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn tags;\n\t}\n\tget size() {\n\t\treturn this._list.length;\n\t}\n}\nTags.EVENT_ADD = 'add';\nTags.EVENT_REMOVE = 'remove';\nTags.EVENT_CHANGE = 'change';\n\nexport { Tags };\n", "const now = typeof window !== 'undefined' && window.performance && window.performance.now ? performance.now.bind(performance) : Date.now;\n\nexport { now };\n", "function createURI(options) {\n\tlet s = '';\n\tif ((options.authority || options.scheme) && (options.host || options.hostpath)) {\n\t\tthrow new Error('Can\\'t have \\'scheme\\' or \\'authority\\' and \\'host\\' or \\'hostpath\\' option');\n\t}\n\tif (options.host && options.hostpath) {\n\t\tthrow new Error('Can\\'t have \\'host\\' and \\'hostpath\\' option');\n\t}\n\tif (options.path && options.hostpath) {\n\t\tthrow new Error('Can\\'t have \\'path\\' and \\'hostpath\\' option');\n\t}\n\tif (options.scheme) {\n\t\ts += options.scheme + ':';\n\t}\n\tif (options.authority) {\n\t\ts += '//' + options.authority;\n\t}\n\tif (options.host) {\n\t\ts += options.host;\n\t}\n\tif (options.path) {\n\t\ts += options.path;\n\t}\n\tif (options.hostpath) {\n\t\ts += options.hostpath;\n\t}\n\tif (options.query) {\n\t\ts += '?' + options.query;\n\t}\n\tif (options.fragment) {\n\t\ts += '#' + options.fragment;\n\t}\n\treturn s;\n}\nconst re = /^(([^:\\/?#]+):)?(\\/\\/([^\\/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?/;\nclass URI {\n\tconstructor(uri) {\n\t\tthis.scheme = void 0;\n\t\tthis.authority = void 0;\n\t\tthis.path = void 0;\n\t\tthis.query = void 0;\n\t\tthis.fragment = void 0;\n\t\tconst result = uri.match(re);\n\t\tthis.scheme = result[2];\n\t\tthis.authority = result[4];\n\t\tthis.path = result[5];\n\t\tthis.query = result[7];\n\t\tthis.fragment = result[9];\n\t}\n\ttoString() {\n\t\tlet s = '';\n\t\tif (this.scheme) {\n\t\t\ts += this.scheme + ':';\n\t\t}\n\t\tif (this.authority) {\n\t\t\ts += '//' + this.authority;\n\t\t}\n\t\ts += this.path;\n\t\tif (this.query) {\n\t\t\ts += '?' + this.query;\n\t\t}\n\t\tif (this.fragment) {\n\t\t\ts += '#' + this.fragment;\n\t\t}\n\t\treturn s;\n\t}\n\tgetQuery() {\n\t\tconst result = {};\n\t\tif (this.query) {\n\t\t\tconst queryParams = decodeURIComponent(this.query).split('&');\n\t\t\tfor (const queryParam of queryParams) {\n\t\t\t\tconst pair = queryParam.split('=');\n\t\t\t\tresult[pair[0]] = pair[1];\n\t\t\t}\n\t\t}\n\t\treturn result;\n\t}\n\tsetQuery(params) {\n\t\tlet q = '';\n\t\tfor (const key in params) {\n\t\t\tif (params.hasOwnProperty(key)) {\n\t\t\t\tif (q !== '') {\n\t\t\t\t\tq += '&';\n\t\t\t\t}\n\t\t\t\tq += encodeURIComponent(key) + '=' + encodeURIComponent(params[key]);\n\t\t\t}\n\t\t}\n\t\tthis.query = q;\n\t}\n}\n\nexport { URI, createURI };\n", "class Tracing {\n\tstatic set(channel, enabled = true) {}\n\tstatic get(channel) {\n\t\treturn Tracing._traceChannels.has(channel);\n\t}\n}\nTracing._traceChannels = new Set();\nTracing.stack = false;\n\nexport { Tracing };\n", "const math = {\n\tDEG_TO_RAD: Math.PI / 180,\n\tRAD_TO_DEG: 180 / Math.PI,\n\tclamp(value, min, max) {\n\t\tif (value >= max) return max;\n\t\tif (value <= min) return min;\n\t\treturn value;\n\t},\n\tintToBytes24(i) {\n\t\tconst r = i >> 16 & 0xff;\n\t\tconst g = i >> 8 & 0xff;\n\t\tconst b = i & 0xff;\n\t\treturn [r, g, b];\n\t},\n\tintToBytes32(i) {\n\t\tconst r = i >> 24 & 0xff;\n\t\tconst g = i >> 16 & 0xff;\n\t\tconst b = i >> 8 & 0xff;\n\t\tconst a = i & 0xff;\n\t\treturn [r, g, b, a];\n\t},\n\tbytesToInt24(r, g, b) {\n\t\tif (r.length) {\n\t\t\tb = r[2];\n\t\t\tg = r[1];\n\t\t\tr = r[0];\n\t\t}\n\t\treturn r << 16 | g << 8 | b;\n\t},\n\tbytesToInt32(r, g, b, a) {\n\t\tif (r.length) {\n\t\t\ta = r[3];\n\t\t\tb = r[2];\n\t\t\tg = r[1];\n\t\t\tr = r[0];\n\t\t}\n\t\treturn (r << 24 | g << 16 | b << 8 | a) >>> 0;\n\t},\n\tlerp(a, b, alpha) {\n\t\treturn a + (b - a) * math.clamp(alpha, 0, 1);\n\t},\n\tlerpAngle(a, b, alpha) {\n\t\tif (b - a > 180) {\n\t\t\tb -= 360;\n\t\t}\n\t\tif (b - a < -180) {\n\t\t\tb += 360;\n\t\t}\n\t\treturn math.lerp(a, b, math.clamp(alpha, 0, 1));\n\t},\n\tpowerOfTwo(x) {\n\t\treturn x !== 0 && !(x & x - 1);\n\t},\n\tnextPowerOfTwo(val) {\n\t\tval--;\n\t\tval |= val >> 1;\n\t\tval |= val >> 2;\n\t\tval |= val >> 4;\n\t\tval |= val >> 8;\n\t\tval |= val >> 16;\n\t\tval++;\n\t\treturn val;\n\t},\n\tnearestPowerOfTwo(val) {\n\t\treturn Math.pow(2, Math.round(Math.log(val) / Math.log(2)));\n\t},\n\trandom(min, max) {\n\t\tconst diff = max - min;\n\t\treturn Math.random() * diff + min;\n\t},\n\tsmoothstep(min, max, x) {\n\t\tif (x <= min) return 0;\n\t\tif (x >= max) return 1;\n\t\tx = (x - min) / (max - min);\n\t\treturn x * x * (3 - 2 * x);\n\t},\n\tsmootherstep(min, max, x) {\n\t\tif (x <= min) return 0;\n\t\tif (x >= max) return 1;\n\t\tx = (x - min) / (max - min);\n\t\treturn x * x * x * (x * (x * 6 - 15) + 10);\n\t},\n\troundUp(numToRound, multiple) {\n\t\tif (multiple === 0) return numToRound;\n\t\treturn Math.ceil(numToRound / multiple) * multiple;\n\t},\n\tbetween(num, a, b, inclusive) {\n\t\tconst min = Math.min(a, b);\n\t\tconst max = Math.max(a, b);\n\t\treturn inclusive ? num >= min && num <= max : num > min && num < max;\n\t}\n};\n\nexport { math };\n", "import { math } from './math.js';\n\nvar _Color;\nclass Color {\n\tconstructor(r = 0, g = 0, b = 0, a = 1) {\n\t\tthis.r = void 0;\n\t\tthis.g = void 0;\n\t\tthis.b = void 0;\n\t\tthis.a = void 0;\n\t\tconst length = r.length;\n\t\tif (length === 3 || length === 4) {\n\t\t\tthis.r = r[0];\n\t\t\tthis.g = r[1];\n\t\t\tthis.b = r[2];\n\t\t\tthis.a = r[3] !== undefined ? r[3] : 1;\n\t\t} else {\n\t\t\tthis.r = r;\n\t\t\tthis.g = g;\n\t\t\tthis.b = b;\n\t\t\tthis.a = a;\n\t\t}\n\t}\n\tclone() {\n\t\tconst cstr = this.constructor;\n\t\treturn new cstr(this.r, this.g, this.b, this.a);\n\t}\n\tcopy(rhs) {\n\t\tthis.r = rhs.r;\n\t\tthis.g = rhs.g;\n\t\tthis.b = rhs.b;\n\t\tthis.a = rhs.a;\n\t\treturn this;\n\t}\n\tequals(rhs) {\n\t\treturn this.r === rhs.r && this.g === rhs.g && this.b === rhs.b && this.a === rhs.a;\n\t}\n\tset(r, g, b, a = 1) {\n\t\tthis.r = r;\n\t\tthis.g = g;\n\t\tthis.b = b;\n\t\tthis.a = a;\n\t\treturn this;\n\t}\n\tlerp(lhs, rhs, alpha) {\n\t\tthis.r = lhs.r + alpha * (rhs.r - lhs.r);\n\t\tthis.g = lhs.g + alpha * (rhs.g - lhs.g);\n\t\tthis.b = lhs.b + alpha * (rhs.b - lhs.b);\n\t\tthis.a = lhs.a + alpha * (rhs.a - lhs.a);\n\t\treturn this;\n\t}\n\tfromString(hex) {\n\t\tconst i = parseInt(hex.replace('#', '0x'), 16);\n\t\tlet bytes;\n\t\tif (hex.length > 7) {\n\t\t\tbytes = math.intToBytes32(i);\n\t\t} else {\n\t\t\tbytes = math.intToBytes24(i);\n\t\t\tbytes[3] = 255;\n\t\t}\n\t\tthis.set(bytes[0] / 255, bytes[1] / 255, bytes[2] / 255, bytes[3] / 255);\n\t\treturn this;\n\t}\n\ttoString(alpha) {\n\t\tlet s = '#' + ((1 << 24) + (Math.round(this.r * 255) << 16) + (Math.round(this.g * 255) << 8) + Math.round(this.b * 255)).toString(16).slice(1);\n\t\tif (alpha === true) {\n\t\t\tconst a = Math.round(this.a * 255).toString(16);\n\t\t\tif (this.a < 16 / 255) {\n\t\t\t\ts += '0' + a;\n\t\t\t} else {\n\t\t\t\ts += a;\n\t\t\t}\n\t\t}\n\t\treturn s;\n\t}\n}\n_Color = Color;\nColor.BLACK = Object.freeze(new _Color(0, 0, 0, 1));\nColor.BLUE = Object.freeze(new _Color(0, 0, 1, 1));\nColor.CYAN = Object.freeze(new _Color(0, 1, 1, 1));\nColor.GRAY = Object.freeze(new _Color(0.5, 0.5, 0.5, 1));\nColor.GREEN = Object.freeze(new _Color(0, 1, 0, 1));\nColor.MAGENTA = Object.freeze(new _Color(1, 0, 1, 1));\nColor.RED = Object.freeze(new _Color(1, 0, 0, 1));\nColor.WHITE = Object.freeze(new _Color(1, 1, 1, 1));\nColor.YELLOW = Object.freeze(new _Color(1, 1, 0, 1));\n\nexport { Color };\n", "import { math } from './math.js';\n\nconst oneDiv255 = 1 / 255;\nconst floatView = new Float32Array(1);\nconst int32View = new Int32Array(floatView.buffer);\nclass FloatPacking {\n\tstatic float2Half(value) {\n\t\tfloatView[0] = value;\n\t\tconst x = int32View[0];\n\t\tlet bits = x >> 16 & 0x8000;\n\t\tlet m = x >> 12 & 0x07ff;\n\t\tconst e = x >> 23 & 0xff;\n\t\tif (e < 103) {\n\t\t\treturn bits;\n\t\t}\n\t\tif (e > 142) {\n\t\t\tbits |= 0x7c00;\n\t\t\tbits |= (e === 255 ? 0 : 1) && x & 0x007fffff;\n\t\t\treturn bits;\n\t\t}\n\t\tif (e < 113) {\n\t\t\tm |= 0x0800;\n\t\t\tbits |= (m >> 114 - e) + (m >> 113 - e & 1);\n\t\t\treturn bits;\n\t\t}\n\t\tbits |= e - 112 << 10 | m >> 1;\n\t\tbits += m & 1;\n\t\treturn bits;\n\t}\n\tstatic float2Bytes(value, array, offset, numBytes) {\n\t\tconst enc1 = 255.0 * value % 1;\n\t\tarray[offset + 0] = Math.round((value % 1 - oneDiv255 * enc1) * 255);\n\t\tif (numBytes > 1) {\n\t\t\tconst enc2 = 65025.0 * value % 1;\n\t\t\tarray[offset + 1] = Math.round((enc1 - oneDiv255 * enc2) * 255);\n\t\t\tif (numBytes > 2) {\n\t\t\t\tconst enc3 = 16581375.0 * value % 1;\n\t\t\t\tarray[offset + 2] = Math.round((enc2 - oneDiv255 * enc3) * 255);\n\t\t\t\tif (numBytes > 3) {\n\t\t\t\t\tarray[offset + 3] = Math.round(enc3 * 255);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\tstatic float2BytesRange(value, array, offset, min, max, numBytes) {\n\t\tvalue = math.clamp((value - min) / (max - min), 0, 1);\n\t\tFloatPacking.float2Bytes(value, array, offset, numBytes);\n\t}\n\tstatic float2MantissaExponent(value, array, offset, numBytes) {\n\t\tconst exponent = Math.floor(Math.log2(Math.abs(value))) + 1;\n\t\tvalue /= Math.pow(2, exponent);\n\t\tFloatPacking.float2BytesRange(value, array, offset, -1, 1, numBytes - 1);\n\t\tarray[offset + numBytes - 1] = Math.round(exponent + 127);\n\t}\n}\n\nexport { FloatPacking };\n", "var _Vec;\nclass Vec3 {\n\tconstructor(x = 0, y = 0, z = 0) {\n\t\tthis.x = void 0;\n\t\tthis.y = void 0;\n\t\tthis.z = void 0;\n\t\tif (x.length === 3) {\n\t\t\tthis.x = x[0];\n\t\t\tthis.y = x[1];\n\t\t\tthis.z = x[2];\n\t\t} else {\n\t\t\tthis.x = x;\n\t\t\tthis.y = y;\n\t\t\tthis.z = z;\n\t\t}\n\t}\n\tadd(rhs) {\n\t\tthis.x += rhs.x;\n\t\tthis.y += rhs.y;\n\t\tthis.z += rhs.z;\n\t\treturn this;\n\t}\n\tadd2(lhs, rhs) {\n\t\tthis.x = lhs.x + rhs.x;\n\t\tthis.y = lhs.y + rhs.y;\n\t\tthis.z = lhs.z + rhs.z;\n\t\treturn this;\n\t}\n\taddScalar(scalar) {\n\t\tthis.x += scalar;\n\t\tthis.y += scalar;\n\t\tthis.z += scalar;\n\t\treturn this;\n\t}\n\taddScaled(rhs, scalar) {\n\t\tthis.x += rhs.x * scalar;\n\t\tthis.y += rhs.y * scalar;\n\t\tthis.z += rhs.z * scalar;\n\t\treturn this;\n\t}\n\tclone() {\n\t\tconst cstr = this.constructor;\n\t\treturn new cstr(this.x, this.y, this.z);\n\t}\n\tcopy(rhs) {\n\t\tthis.x = rhs.x;\n\t\tthis.y = rhs.y;\n\t\tthis.z = rhs.z;\n\t\treturn this;\n\t}\n\tcross(lhs, rhs) {\n\t\tconst lx = lhs.x;\n\t\tconst ly = lhs.y;\n\t\tconst lz = lhs.z;\n\t\tconst rx = rhs.x;\n\t\tconst ry = rhs.y;\n\t\tconst rz = rhs.z;\n\t\tthis.x = ly * rz - ry * lz;\n\t\tthis.y = lz * rx - rz * lx;\n\t\tthis.z = lx * ry - rx * ly;\n\t\treturn this;\n\t}\n\tdistance(rhs) {\n\t\tconst x = this.x - rhs.x;\n\t\tconst y = this.y - rhs.y;\n\t\tconst z = this.z - rhs.z;\n\t\treturn Math.sqrt(x * x + y * y + z * z);\n\t}\n\tdiv(rhs) {\n\t\tthis.x /= rhs.x;\n\t\tthis.y /= rhs.y;\n\t\tthis.z /= rhs.z;\n\t\treturn this;\n\t}\n\tdiv2(lhs, rhs) {\n\t\tthis.x = lhs.x / rhs.x;\n\t\tthis.y = lhs.y / rhs.y;\n\t\tthis.z = lhs.z / rhs.z;\n\t\treturn this;\n\t}\n\tdivScalar(scalar) {\n\t\tthis.x /= scalar;\n\t\tthis.y /= scalar;\n\t\tthis.z /= scalar;\n\t\treturn this;\n\t}\n\tdot(rhs) {\n\t\treturn this.x * rhs.x + this.y * rhs.y + this.z * rhs.z;\n\t}\n\tequals(rhs) {\n\t\treturn this.x === rhs.x && this.y === rhs.y && this.z === rhs.z;\n\t}\n\tequalsApprox(rhs, epsilon = 1e-6) {\n\t\treturn Math.abs(this.x - rhs.x) < epsilon && Math.abs(this.y - rhs.y) < epsilon && Math.abs(this.z - rhs.z) < epsilon;\n\t}\n\tlength() {\n\t\treturn Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);\n\t}\n\tlengthSq() {\n\t\treturn this.x * this.x + this.y * this.y + this.z * this.z;\n\t}\n\tlerp(lhs, rhs, alpha) {\n\t\tthis.x = lhs.x + alpha * (rhs.x - lhs.x);\n\t\tthis.y = lhs.y + alpha * (rhs.y - lhs.y);\n\t\tthis.z = lhs.z + alpha * (rhs.z - lhs.z);\n\t\treturn this;\n\t}\n\tmul(rhs) {\n\t\tthis.x *= rhs.x;\n\t\tthis.y *= rhs.y;\n\t\tthis.z *= rhs.z;\n\t\treturn this;\n\t}\n\tmul2(lhs, rhs) {\n\t\tthis.x = lhs.x * rhs.x;\n\t\tthis.y = lhs.y * rhs.y;\n\t\tthis.z = lhs.z * rhs.z;\n\t\treturn this;\n\t}\n\tmulScalar(scalar) {\n\t\tthis.x *= scalar;\n\t\tthis.y *= scalar;\n\t\tthis.z *= scalar;\n\t\treturn this;\n\t}\n\tnormalize(src = this) {\n\t\tconst lengthSq = src.x * src.x + src.y * src.y + src.z * src.z;\n\t\tif (lengthSq > 0) {\n\t\t\tconst invLength = 1 / Math.sqrt(lengthSq);\n\t\t\tthis.x = src.x * invLength;\n\t\t\tthis.y = src.y * invLength;\n\t\t\tthis.z = src.z * invLength;\n\t\t}\n\t\treturn this;\n\t}\n\tfloor(src = this) {\n\t\tthis.x = Math.floor(src.x);\n\t\tthis.y = Math.floor(src.y);\n\t\tthis.z = Math.floor(src.z);\n\t\treturn this;\n\t}\n\tceil(src = this) {\n\t\tthis.x = Math.ceil(src.x);\n\t\tthis.y = Math.ceil(src.y);\n\t\tthis.z = Math.ceil(src.z);\n\t\treturn this;\n\t}\n\tround(src = this) {\n\t\tthis.x = Math.round(src.x);\n\t\tthis.y = Math.round(src.y);\n\t\tthis.z = Math.round(src.z);\n\t\treturn this;\n\t}\n\tmin(rhs) {\n\t\tif (rhs.x < this.x) this.x = rhs.x;\n\t\tif (rhs.y < this.y) this.y = rhs.y;\n\t\tif (rhs.z < this.z) this.z = rhs.z;\n\t\treturn this;\n\t}\n\tmax(rhs) {\n\t\tif (rhs.x > this.x) this.x = rhs.x;\n\t\tif (rhs.y > this.y) this.y = rhs.y;\n\t\tif (rhs.z > this.z) this.z = rhs.z;\n\t\treturn this;\n\t}\n\tproject(rhs) {\n\t\tconst a_dot_b = this.x * rhs.x + this.y * rhs.y + this.z * rhs.z;\n\t\tconst b_dot_b = rhs.x * rhs.x + rhs.y * rhs.y + rhs.z * rhs.z;\n\t\tconst s = a_dot_b / b_dot_b;\n\t\tthis.x = rhs.x * s;\n\t\tthis.y = rhs.y * s;\n\t\tthis.z = rhs.z * s;\n\t\treturn this;\n\t}\n\tset(x, y, z) {\n\t\tthis.x = x;\n\t\tthis.y = y;\n\t\tthis.z = z;\n\t\treturn this;\n\t}\n\tsub(rhs) {\n\t\tthis.x -= rhs.x;\n\t\tthis.y -= rhs.y;\n\t\tthis.z -= rhs.z;\n\t\treturn this;\n\t}\n\tsub2(lhs, rhs) {\n\t\tthis.x = lhs.x - rhs.x;\n\t\tthis.y = lhs.y - rhs.y;\n\t\tthis.z = lhs.z - rhs.z;\n\t\treturn this;\n\t}\n\tsubScalar(scalar) {\n\t\tthis.x -= scalar;\n\t\tthis.y -= scalar;\n\t\tthis.z -= scalar;\n\t\treturn this;\n\t}\n\ttoString() {\n\t\treturn `[${this.x}, ${this.y}, ${this.z}]`;\n\t}\n}\n_Vec = Vec3;\nVec3.ZERO = Object.freeze(new _Vec(0, 0, 0));\nVec3.ONE = Object.freeze(new _Vec(1, 1, 1));\nVec3.UP = Object.freeze(new _Vec(0, 1, 0));\nVec3.DOWN = Object.freeze(new _Vec(0, -1, 0));\nVec3.RIGHT = Object.freeze(new _Vec(1, 0, 0));\nVec3.LEFT = Object.freeze(new _Vec(-1, 0, 0));\nVec3.FORWARD = Object.freeze(new _Vec(0, 0, -1));\nVec3.BACK = Object.freeze(new _Vec(0, 0, 1));\n\nexport { Vec3 };\n", "import { Vec3 } from './vec3.js';\n\nvar _Mat;\nclass Mat3 {\n\tconstructor() {\n\t\tthis.data = new Float32Array(9);\n\t\tthis.data[0] = this.data[4] = this.data[8] = 1;\n\t}\n\tclone() {\n\t\tconst cstr = this.constructor;\n\t\treturn new cstr().copy(this);\n\t}\n\tcopy(rhs) {\n\t\tconst src = rhs.data;\n\t\tconst dst = this.data;\n\t\tdst[0] = src[0];\n\t\tdst[1] = src[1];\n\t\tdst[2] = src[2];\n\t\tdst[3] = src[3];\n\t\tdst[4] = src[4];\n\t\tdst[5] = src[5];\n\t\tdst[6] = src[6];\n\t\tdst[7] = src[7];\n\t\tdst[8] = src[8];\n\t\treturn this;\n\t}\n\tset(src) {\n\t\tconst dst = this.data;\n\t\tdst[0] = src[0];\n\t\tdst[1] = src[1];\n\t\tdst[2] = src[2];\n\t\tdst[3] = src[3];\n\t\tdst[4] = src[4];\n\t\tdst[5] = src[5];\n\t\tdst[6] = src[6];\n\t\tdst[7] = src[7];\n\t\tdst[8] = src[8];\n\t\treturn this;\n\t}\n\tgetX(x = new Vec3()) {\n\t\treturn x.set(this.data[0], this.data[1], this.data[2]);\n\t}\n\tgetY(y = new Vec3()) {\n\t\treturn y.set(this.data[3], this.data[4], this.data[5]);\n\t}\n\tgetZ(z = new Vec3()) {\n\t\treturn z.set(this.data[6], this.data[7], this.data[8]);\n\t}\n\tequals(rhs) {\n\t\tconst l = this.data;\n\t\tconst r = rhs.data;\n\t\treturn l[0] === r[0] && l[1] === r[1] && l[2] === r[2] && l[3] === r[3] && l[4] === r[4] && l[5] === r[5] && l[6] === r[6] && l[7] === r[7] && l[8] === r[8];\n\t}\n\tisIdentity() {\n\t\tconst m = this.data;\n\t\treturn m[0] === 1 && m[1] === 0 && m[2] === 0 && m[3] === 0 && m[4] === 1 && m[5] === 0 && m[6] === 0 && m[7] === 0 && m[8] === 1;\n\t}\n\tsetIdentity() {\n\t\tconst m = this.data;\n\t\tm[0] = 1;\n\t\tm[1] = 0;\n\t\tm[2] = 0;\n\t\tm[3] = 0;\n\t\tm[4] = 1;\n\t\tm[5] = 0;\n\t\tm[6] = 0;\n\t\tm[7] = 0;\n\t\tm[8] = 1;\n\t\treturn this;\n\t}\n\ttoString() {\n\t\treturn '[' + this.data.join(', ') + ']';\n\t}\n\ttranspose(src = this) {\n\t\tconst s = src.data;\n\t\tconst t = this.data;\n\t\tif (s === t) {\n\t\t\tlet tmp;\n\t\t\ttmp = s[1];\n\t\t\tt[1] = s[3];\n\t\t\tt[3] = tmp;\n\t\t\ttmp = s[2];\n\t\t\tt[2] = s[6];\n\t\t\tt[6] = tmp;\n\t\t\ttmp = s[5];\n\t\t\tt[5] = s[7];\n\t\t\tt[7] = tmp;\n\t\t} else {\n\t\t\tt[0] = s[0];\n\t\t\tt[1] = s[3];\n\t\t\tt[2] = s[6];\n\t\t\tt[3] = s[1];\n\t\t\tt[4] = s[4];\n\t\t\tt[5] = s[7];\n\t\t\tt[6] = s[2];\n\t\t\tt[7] = s[5];\n\t\t\tt[8] = s[8];\n\t\t}\n\t\treturn this;\n\t}\n\tsetFromMat4(m) {\n\t\tconst src = m.data;\n\t\tconst dst = this.data;\n\t\tdst[0] = src[0];\n\t\tdst[1] = src[1];\n\t\tdst[2] = src[2];\n\t\tdst[3] = src[4];\n\t\tdst[4] = src[5];\n\t\tdst[5] = src[6];\n\t\tdst[6] = src[8];\n\t\tdst[7] = src[9];\n\t\tdst[8] = src[10];\n\t\treturn this;\n\t}\n\tsetFromQuat(r) {\n\t\tconst qx = r.x;\n\t\tconst qy = r.y;\n\t\tconst qz = r.z;\n\t\tconst qw = r.w;\n\t\tconst x2 = qx + qx;\n\t\tconst y2 = qy + qy;\n\t\tconst z2 = qz + qz;\n\t\tconst xx = qx * x2;\n\t\tconst xy = qx * y2;\n\t\tconst xz = qx * z2;\n\t\tconst yy = qy * y2;\n\t\tconst yz = qy * z2;\n\t\tconst zz = qz * z2;\n\t\tconst wx = qw * x2;\n\t\tconst wy = qw * y2;\n\t\tconst wz = qw * z2;\n\t\tconst m = this.data;\n\t\tm[0] = 1 - (yy + zz);\n\t\tm[1] = xy + wz;\n\t\tm[2] = xz - wy;\n\t\tm[3] = xy - wz;\n\t\tm[4] = 1 - (xx + zz);\n\t\tm[5] = yz + wx;\n\t\tm[6] = xz + wy;\n\t\tm[7] = yz - wx;\n\t\tm[8] = 1 - (xx + yy);\n\t\treturn this;\n\t}\n\tinvertMat4(src) {\n\t\tconst s = src.data;\n\t\tconst a0 = s[0];\n\t\tconst a1 = s[1];\n\t\tconst a2 = s[2];\n\t\tconst a4 = s[4];\n\t\tconst a5 = s[5];\n\t\tconst a6 = s[6];\n\t\tconst a8 = s[8];\n\t\tconst a9 = s[9];\n\t\tconst a10 = s[10];\n\t\tconst b11 = a10 * a5 - a6 * a9;\n\t\tconst b21 = -a10 * a1 + a2 * a9;\n\t\tconst b31 = a6 * a1 - a2 * a5;\n\t\tconst b12 = -a10 * a4 + a6 * a8;\n\t\tconst b22 = a10 * a0 - a2 * a8;\n\t\tconst b32 = -a6 * a0 + a2 * a4;\n\t\tconst b13 = a9 * a4 - a5 * a8;\n\t\tconst b23 = -a9 * a0 + a1 * a8;\n\t\tconst b33 = a5 * a0 - a1 * a4;\n\t\tconst det = a0 * b11 + a1 * b12 + a2 * b13;\n\t\tif (det === 0) {\n\t\t\tthis.setIdentity();\n\t\t} else {\n\t\t\tconst invDet = 1 / det;\n\t\t\tconst t = this.data;\n\t\t\tt[0] = b11 * invDet;\n\t\t\tt[1] = b21 * invDet;\n\t\t\tt[2] = b31 * invDet;\n\t\t\tt[3] = b12 * invDet;\n\t\t\tt[4] = b22 * invDet;\n\t\t\tt[5] = b32 * invDet;\n\t\t\tt[6] = b13 * invDet;\n\t\t\tt[7] = b23 * invDet;\n\t\t\tt[8] = b33 * invDet;\n\t\t}\n\t\treturn this;\n\t}\n\ttransformVector(vec, res = new Vec3()) {\n\t\tconst m = this.data;\n\t\tconst {\n\t\t\tx,\n\t\t\ty,\n\t\t\tz\n\t\t} = vec;\n\t\tres.x = x * m[0] + y * m[3] + z * m[6];\n\t\tres.y = x * m[1] + y * m[4] + z * m[7];\n\t\tres.z = x * m[2] + y * m[5] + z * m[8];\n\t\treturn res;\n\t}\n}\n_Mat = Mat3;\nMat3.IDENTITY = Object.freeze(new _Mat());\nMat3.ZERO = Object.freeze(new _Mat().set([0, 0, 0, 0, 0, 0, 0, 0, 0]));\n\nexport { Mat3 };\n", "import { math } from './math.js';\n\nvar _Vec;\nclass Vec2 {\n\tconstructor(x = 0, y = 0) {\n\t\tthis.x = void 0;\n\t\tthis.y = void 0;\n\t\tif (x.length === 2) {\n\t\t\tthis.x = x[0];\n\t\t\tthis.y = x[1];\n\t\t} else {\n\t\t\tthis.x = x;\n\t\t\tthis.y = y;\n\t\t}\n\t}\n\tadd(rhs) {\n\t\tthis.x += rhs.x;\n\t\tthis.y += rhs.y;\n\t\treturn this;\n\t}\n\tadd2(lhs, rhs) {\n\t\tthis.x = lhs.x + rhs.x;\n\t\tthis.y = lhs.y + rhs.y;\n\t\treturn this;\n\t}\n\taddScalar(scalar) {\n\t\tthis.x += scalar;\n\t\tthis.y += scalar;\n\t\treturn this;\n\t}\n\taddScaled(rhs, scalar) {\n\t\tthis.x += rhs.x * scalar;\n\t\tthis.y += rhs.y * scalar;\n\t\treturn this;\n\t}\n\tclone() {\n\t\tconst cstr = this.constructor;\n\t\treturn new cstr(this.x, this.y);\n\t}\n\tcopy(rhs) {\n\t\tthis.x = rhs.x;\n\t\tthis.y = rhs.y;\n\t\treturn this;\n\t}\n\tcross(rhs) {\n\t\treturn this.x * rhs.y - this.y * rhs.x;\n\t}\n\tdistance(rhs) {\n\t\tconst x = this.x - rhs.x;\n\t\tconst y = this.y - rhs.y;\n\t\treturn Math.sqrt(x * x + y * y);\n\t}\n\tdiv(rhs) {\n\t\tthis.x /= rhs.x;\n\t\tthis.y /= rhs.y;\n\t\treturn this;\n\t}\n\tdiv2(lhs, rhs) {\n\t\tthis.x = lhs.x / rhs.x;\n\t\tthis.y = lhs.y / rhs.y;\n\t\treturn this;\n\t}\n\tdivScalar(scalar) {\n\t\tthis.x /= scalar;\n\t\tthis.y /= scalar;\n\t\treturn this;\n\t}\n\tdot(rhs) {\n\t\treturn this.x * rhs.x + this.y * rhs.y;\n\t}\n\tequals(rhs) {\n\t\treturn this.x === rhs.x && this.y === rhs.y;\n\t}\n\tequalsApprox(rhs, epsilon = 1e-6) {\n\t\treturn Math.abs(this.x - rhs.x) < epsilon && Math.abs(this.y - rhs.y) < epsilon;\n\t}\n\tlength() {\n\t\treturn Math.sqrt(this.x * this.x + this.y * this.y);\n\t}\n\tlengthSq() {\n\t\treturn this.x * this.x + this.y * this.y;\n\t}\n\tlerp(lhs, rhs, alpha) {\n\t\tthis.x = lhs.x + alpha * (rhs.x - lhs.x);\n\t\tthis.y = lhs.y + alpha * (rhs.y - lhs.y);\n\t\treturn this;\n\t}\n\tmul(rhs) {\n\t\tthis.x *= rhs.x;\n\t\tthis.y *= rhs.y;\n\t\treturn this;\n\t}\n\tmul2(lhs, rhs) {\n\t\tthis.x = lhs.x * rhs.x;\n\t\tthis.y = lhs.y * rhs.y;\n\t\treturn this;\n\t}\n\tmulScalar(scalar) {\n\t\tthis.x *= scalar;\n\t\tthis.y *= scalar;\n\t\treturn this;\n\t}\n\tnormalize(src = this) {\n\t\tconst lengthSq = src.x * src.x + src.y * src.y;\n\t\tif (lengthSq > 0) {\n\t\t\tconst invLength = 1 / Math.sqrt(lengthSq);\n\t\t\tthis.x = src.x * invLength;\n\t\t\tthis.y = src.y * invLength;\n\t\t}\n\t\treturn this;\n\t}\n\trotate(degrees) {\n\t\tconst angle = Math.atan2(this.x, this.y) + degrees * math.DEG_TO_RAD;\n\t\tconst len = Math.sqrt(this.x * this.x + this.y * this.y);\n\t\tthis.x = Math.sin(angle) * len;\n\t\tthis.y = Math.cos(angle) * len;\n\t\treturn this;\n\t}\n\tangle() {\n\t\treturn Math.atan2(this.x, this.y) * math.RAD_TO_DEG;\n\t}\n\tangleTo(rhs) {\n\t\treturn Math.atan2(this.x * rhs.y + this.y * rhs.x, this.x * rhs.x + this.y * rhs.y) * math.RAD_TO_DEG;\n\t}\n\tfloor(src = this) {\n\t\tthis.x = Math.floor(src.x);\n\t\tthis.y = Math.floor(src.y);\n\t\treturn this;\n\t}\n\tceil(src = this) {\n\t\tthis.x = Math.ceil(src.x);\n\t\tthis.y = Math.ceil(src.y);\n\t\treturn this;\n\t}\n\tround(src = this) {\n\t\tthis.x = Math.round(src.x);\n\t\tthis.y = Math.round(src.y);\n\t\treturn this;\n\t}\n\tmin(rhs) {\n\t\tif (rhs.x < this.x) this.x = rhs.x;\n\t\tif (rhs.y < this.y) this.y = rhs.y;\n\t\treturn this;\n\t}\n\tmax(rhs) {\n\t\tif (rhs.x > this.x) this.x = rhs.x;\n\t\tif (rhs.y > this.y) this.y = rhs.y;\n\t\treturn this;\n\t}\n\tset(x, y) {\n\t\tthis.x = x;\n\t\tthis.y = y;\n\t\treturn this;\n\t}\n\tsub(rhs) {\n\t\tthis.x -= rhs.x;\n\t\tthis.y -= rhs.y;\n\t\treturn this;\n\t}\n\tsub2(lhs, rhs) {\n\t\tthis.x = lhs.x - rhs.x;\n\t\tthis.y = lhs.y - rhs.y;\n\t\treturn this;\n\t}\n\tsubScalar(scalar) {\n\t\tthis.x -= scalar;\n\t\tthis.y -= scalar;\n\t\treturn this;\n\t}\n\ttoString() {\n\t\treturn `[${this.x}, ${this.y}]`;\n\t}\n\tstatic angleRad(lhs, rhs) {\n\t\treturn Math.atan2(lhs.x * rhs.y - lhs.y * rhs.x, lhs.x * rhs.x + lhs.y * rhs.y);\n\t}\n}\n_Vec = Vec2;\nVec2.ZERO = Object.freeze(new _Vec(0, 0));\nVec2.ONE = Object.freeze(new _Vec(1, 1));\nVec2.UP = Object.freeze(new _Vec(0, 1));\nVec2.DOWN = Object.freeze(new _Vec(0, -1));\nVec2.RIGHT = Object.freeze(new _Vec(1, 0));\nVec2.LEFT = Object.freeze(new _Vec(-1, 0));\n\nexport { Vec2 };\n", "var _Vec;\nclass Vec4 {\n\tconstructor(x = 0, y = 0, z = 0, w = 0) {\n\t\tthis.x = void 0;\n\t\tthis.y = void 0;\n\t\tthis.z = void 0;\n\t\tthis.w = void 0;\n\t\tif (x.length === 4) {\n\t\t\tthis.x = x[0];\n\t\t\tthis.y = x[1];\n\t\t\tthis.z = x[2];\n\t\t\tthis.w = x[3];\n\t\t} else {\n\t\t\tthis.x = x;\n\t\t\tthis.y = y;\n\t\t\tthis.z = z;\n\t\t\tthis.w = w;\n\t\t}\n\t}\n\tadd(rhs) {\n\t\tthis.x += rhs.x;\n\t\tthis.y += rhs.y;\n\t\tthis.z += rhs.z;\n\t\tthis.w += rhs.w;\n\t\treturn this;\n\t}\n\tadd2(lhs, rhs) {\n\t\tthis.x = lhs.x + rhs.x;\n\t\tthis.y = lhs.y + rhs.y;\n\t\tthis.z = lhs.z + rhs.z;\n\t\tthis.w = lhs.w + rhs.w;\n\t\treturn this;\n\t}\n\taddScalar(scalar) {\n\t\tthis.x += scalar;\n\t\tthis.y += scalar;\n\t\tthis.z += scalar;\n\t\tthis.w += scalar;\n\t\treturn this;\n\t}\n\taddScaled(rhs, scalar) {\n\t\tthis.x += rhs.x * scalar;\n\t\tthis.y += rhs.y * scalar;\n\t\tthis.z += rhs.z * scalar;\n\t\tthis.w += rhs.w * scalar;\n\t\treturn this;\n\t}\n\tclone() {\n\t\tconst cstr = this.constructor;\n\t\treturn new cstr(this.x, this.y, this.z, this.w);\n\t}\n\tcopy(rhs) {\n\t\tthis.x = rhs.x;\n\t\tthis.y = rhs.y;\n\t\tthis.z = rhs.z;\n\t\tthis.w = rhs.w;\n\t\treturn this;\n\t}\n\tdiv(rhs) {\n\t\tthis.x /= rhs.x;\n\t\tthis.y /= rhs.y;\n\t\tthis.z /= rhs.z;\n\t\tthis.w /= rhs.w;\n\t\treturn this;\n\t}\n\tdiv2(lhs, rhs) {\n\t\tthis.x = lhs.x / rhs.x;\n\t\tthis.y = lhs.y / rhs.y;\n\t\tthis.z = lhs.z / rhs.z;\n\t\tthis.w = lhs.w / rhs.w;\n\t\treturn this;\n\t}\n\tdivScalar(scalar) {\n\t\tthis.x /= scalar;\n\t\tthis.y /= scalar;\n\t\tthis.z /= scalar;\n\t\tthis.w /= scalar;\n\t\treturn this;\n\t}\n\tdot(rhs) {\n\t\treturn this.x * rhs.x + this.y * rhs.y + this.z * rhs.z + this.w * rhs.w;\n\t}\n\tequals(rhs) {\n\t\treturn this.x === rhs.x && this.y === rhs.y && this.z === rhs.z && this.w === rhs.w;\n\t}\n\tequalsApprox(rhs, epsilon = 1e-6) {\n\t\treturn Math.abs(this.x - rhs.x) < epsilon && Math.abs(this.y - rhs.y) < epsilon && Math.abs(this.z - rhs.z) < epsilon && Math.abs(this.w - rhs.w) < epsilon;\n\t}\n\tlength() {\n\t\treturn Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w);\n\t}\n\tlengthSq() {\n\t\treturn this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w;\n\t}\n\tlerp(lhs, rhs, alpha) {\n\t\tthis.x = lhs.x + alpha * (rhs.x - lhs.x);\n\t\tthis.y = lhs.y + alpha * (rhs.y - lhs.y);\n\t\tthis.z = lhs.z + alpha * (rhs.z - lhs.z);\n\t\tthis.w = lhs.w + alpha * (rhs.w - lhs.w);\n\t\treturn this;\n\t}\n\tmul(rhs) {\n\t\tthis.x *= rhs.x;\n\t\tthis.y *= rhs.y;\n\t\tthis.z *= rhs.z;\n\t\tthis.w *= rhs.w;\n\t\treturn this;\n\t}\n\tmul2(lhs, rhs) {\n\t\tthis.x = lhs.x * rhs.x;\n\t\tthis.y = lhs.y * rhs.y;\n\t\tthis.z = lhs.z * rhs.z;\n\t\tthis.w = lhs.w * rhs.w;\n\t\treturn this;\n\t}\n\tmulScalar(scalar) {\n\t\tthis.x *= scalar;\n\t\tthis.y *= scalar;\n\t\tthis.z *= scalar;\n\t\tthis.w *= scalar;\n\t\treturn this;\n\t}\n\tnormalize(src = this) {\n\t\tconst lengthSq = src.x * src.x + src.y * src.y + src.z * src.z + src.w * src.w;\n\t\tif (lengthSq > 0) {\n\t\t\tconst invLength = 1 / Math.sqrt(lengthSq);\n\t\t\tthis.x = src.x * invLength;\n\t\t\tthis.y = src.y * invLength;\n\t\t\tthis.z = src.z * invLength;\n\t\t\tthis.w = src.w * invLength;\n\t\t}\n\t\treturn this;\n\t}\n\tfloor(src = this) {\n\t\tthis.x = Math.floor(src.x);\n\t\tthis.y = Math.floor(src.y);\n\t\tthis.z = Math.floor(src.z);\n\t\tthis.w = Math.floor(src.w);\n\t\treturn this;\n\t}\n\tceil(src = this) {\n\t\tthis.x = Math.ceil(src.x);\n\t\tthis.y = Math.ceil(src.y);\n\t\tthis.z = Math.ceil(src.z);\n\t\tthis.w = Math.ceil(src.w);\n\t\treturn this;\n\t}\n\tround(src = this) {\n\t\tthis.x = Math.round(src.x);\n\t\tthis.y = Math.round(src.y);\n\t\tthis.z = Math.round(src.z);\n\t\tthis.w = Math.round(src.w);\n\t\treturn this;\n\t}\n\tmin(rhs) {\n\t\tif (rhs.x < this.x) this.x = rhs.x;\n\t\tif (rhs.y < this.y) this.y = rhs.y;\n\t\tif (rhs.z < this.z) this.z = rhs.z;\n\t\tif (rhs.w < this.w) this.w = rhs.w;\n\t\treturn this;\n\t}\n\tmax(rhs) {\n\t\tif (rhs.x > this.x) this.x = rhs.x;\n\t\tif (rhs.y > this.y) this.y = rhs.y;\n\t\tif (rhs.z > this.z) this.z = rhs.z;\n\t\tif (rhs.w > this.w) this.w = rhs.w;\n\t\treturn this;\n\t}\n\tset(x, y, z, w) {\n\t\tthis.x = x;\n\t\tthis.y = y;\n\t\tthis.z = z;\n\t\tthis.w = w;\n\t\treturn this;\n\t}\n\tsub(rhs) {\n\t\tthis.x -= rhs.x;\n\t\tthis.y -= rhs.y;\n\t\tthis.z -= rhs.z;\n\t\tthis.w -= rhs.w;\n\t\treturn this;\n\t}\n\tsub2(lhs, rhs) {\n\t\tthis.x = lhs.x - rhs.x;\n\t\tthis.y = lhs.y - rhs.y;\n\t\tthis.z = lhs.z - rhs.z;\n\t\tthis.w = lhs.w - rhs.w;\n\t\treturn this;\n\t}\n\tsubScalar(scalar) {\n\t\tthis.x -= scalar;\n\t\tthis.y -= scalar;\n\t\tthis.z -= scalar;\n\t\tthis.w -= scalar;\n\t\treturn this;\n\t}\n\ttoString() {\n\t\treturn `[${this.x}, ${this.y}, ${this.z}, ${this.w}]`;\n\t}\n}\n_Vec = Vec4;\nVec4.ZERO = Object.freeze(new _Vec(0, 0, 0, 0));\nVec4.ONE = Object.freeze(new _Vec(1, 1, 1, 1));\n\nexport { Vec4 };\n", "import { math } from './math.js';\nimport { Vec2 } from './vec2.js';\nimport { Vec3 } from './vec3.js';\nimport { Vec4 } from './vec4.js';\n\nvar _Mat;\nconst _halfSize = new Vec2();\nconst x = new Vec3();\nconst y = new Vec3();\nconst z = new Vec3();\nconst scale = new Vec3();\nclass Mat4 {\n\tconstructor() {\n\t\tthis.data = new Float32Array(16);\n\t\tthis.data[0] = this.data[5] = this.data[10] = this.data[15] = 1;\n\t}\n\tstatic _getPerspectiveHalfSize(halfSize, fov, aspect, znear, fovIsHorizontal) {\n\t\tif (fovIsHorizontal) {\n\t\t\thalfSize.x = znear * Math.tan(fov * Math.PI / 360);\n\t\t\thalfSize.y = halfSize.x / aspect;\n\t\t} else {\n\t\t\thalfSize.y = znear * Math.tan(fov * Math.PI / 360);\n\t\t\thalfSize.x = halfSize.y * aspect;\n\t\t}\n\t}\n\tadd2(lhs, rhs) {\n\t\tconst a = lhs.data,\n\t\t\tb = rhs.data,\n\t\t\tr = this.data;\n\t\tr[0] = a[0] + b[0];\n\t\tr[1] = a[1] + b[1];\n\t\tr[2] = a[2] + b[2];\n\t\tr[3] = a[3] + b[3];\n\t\tr[4] = a[4] + b[4];\n\t\tr[5] = a[5] + b[5];\n\t\tr[6] = a[6] + b[6];\n\t\tr[7] = a[7] + b[7];\n\t\tr[8] = a[8] + b[8];\n\t\tr[9] = a[9] + b[9];\n\t\tr[10] = a[10] + b[10];\n\t\tr[11] = a[11] + b[11];\n\t\tr[12] = a[12] + b[12];\n\t\tr[13] = a[13] + b[13];\n\t\tr[14] = a[14] + b[14];\n\t\tr[15] = a[15] + b[15];\n\t\treturn this;\n\t}\n\tadd(rhs) {\n\t\treturn this.add2(this, rhs);\n\t}\n\tclone() {\n\t\tconst cstr = this.constructor;\n\t\treturn new cstr().copy(this);\n\t}\n\tcopy(rhs) {\n\t\tconst src = rhs.data,\n\t\t\tdst = this.data;\n\t\tdst[0] = src[0];\n\t\tdst[1] = src[1];\n\t\tdst[2] = src[2];\n\t\tdst[3] = src[3];\n\t\tdst[4] = src[4];\n\t\tdst[5] = src[5];\n\t\tdst[6] = src[6];\n\t\tdst[7] = src[7];\n\t\tdst[8] = src[8];\n\t\tdst[9] = src[9];\n\t\tdst[10] = src[10];\n\t\tdst[11] = src[11];\n\t\tdst[12] = src[12];\n\t\tdst[13] = src[13];\n\t\tdst[14] = src[14];\n\t\tdst[15] = src[15];\n\t\treturn this;\n\t}\n\tequals(rhs) {\n\t\tconst l = this.data,\n\t\t\tr = rhs.data;\n\t\treturn l[0] === r[0] && l[1] === r[1] && l[2] === r[2] && l[3] === r[3] && l[4] === r[4] && l[5] === r[5] && l[6] === r[6] && l[7] === r[7] && l[8] === r[8] && l[9] === r[9] && l[10] === r[10] && l[11] === r[11] && l[12] === r[12] && l[13] === r[13] && l[14] === r[14] && l[15] === r[15];\n\t}\n\tisIdentity() {\n\t\tconst m = this.data;\n\t\treturn m[0] === 1 && m[1] === 0 && m[2] === 0 && m[3] === 0 && m[4] === 0 && m[5] === 1 && m[6] === 0 && m[7] === 0 && m[8] === 0 && m[9] === 0 && m[10] === 1 && m[11] === 0 && m[12] === 0 && m[13] === 0 && m[14] === 0 && m[15] === 1;\n\t}\n\tmul2(lhs, rhs) {\n\t\tconst a = lhs.data;\n\t\tconst b = rhs.data;\n\t\tconst r = this.data;\n\t\tconst a00 = a[0];\n\t\tconst a01 = a[1];\n\t\tconst a02 = a[2];\n\t\tconst a03 = a[3];\n\t\tconst a10 = a[4];\n\t\tconst a11 = a[5];\n\t\tconst a12 = a[6];\n\t\tconst a13 = a[7];\n\t\tconst a20 = a[8];\n\t\tconst a21 = a[9];\n\t\tconst a22 = a[10];\n\t\tconst a23 = a[11];\n\t\tconst a30 = a[12];\n\t\tconst a31 = a[13];\n\t\tconst a32 = a[14];\n\t\tconst a33 = a[15];\n\t\tlet b0, b1, b2, b3;\n\t\tb0 = b[0];\n\t\tb1 = b[1];\n\t\tb2 = b[2];\n\t\tb3 = b[3];\n\t\tr[0] = a00 * b0 + a10 * b1 + a20 * b2 + a30 * b3;\n\t\tr[1] = a01 * b0 + a11 * b1 + a21 * b2 + a31 * b3;\n\t\tr[2] = a02 * b0 + a12 * b1 + a22 * b2 + a32 * b3;\n\t\tr[3] = a03 * b0 + a13 * b1 + a23 * b2 + a33 * b3;\n\t\tb0 = b[4];\n\t\tb1 = b[5];\n\t\tb2 = b[6];\n\t\tb3 = b[7];\n\t\tr[4] = a00 * b0 + a10 * b1 + a20 * b2 + a30 * b3;\n\t\tr[5] = a01 * b0 + a11 * b1 + a21 * b2 + a31 * b3;\n\t\tr[6] = a02 * b0 + a12 * b1 + a22 * b2 + a32 * b3;\n\t\tr[7] = a03 * b0 + a13 * b1 + a23 * b2 + a33 * b3;\n\t\tb0 = b[8];\n\t\tb1 = b[9];\n\t\tb2 = b[10];\n\t\tb3 = b[11];\n\t\tr[8] = a00 * b0 + a10 * b1 + a20 * b2 + a30 * b3;\n\t\tr[9] = a01 * b0 + a11 * b1 + a21 * b2 + a31 * b3;\n\t\tr[10] = a02 * b0 + a12 * b1 + a22 * b2 + a32 * b3;\n\t\tr[11] = a03 * b0 + a13 * b1 + a23 * b2 + a33 * b3;\n\t\tb0 = b[12];\n\t\tb1 = b[13];\n\t\tb2 = b[14];\n\t\tb3 = b[15];\n\t\tr[12] = a00 * b0 + a10 * b1 + a20 * b2 + a30 * b3;\n\t\tr[13] = a01 * b0 + a11 * b1 + a21 * b2 + a31 * b3;\n\t\tr[14] = a02 * b0 + a12 * b1 + a22 * b2 + a32 * b3;\n\t\tr[15] = a03 * b0 + a13 * b1 + a23 * b2 + a33 * b3;\n\t\treturn this;\n\t}\n\tmulAffine2(lhs, rhs) {\n\t\tconst a = lhs.data;\n\t\tconst b = rhs.data;\n\t\tconst r = this.data;\n\t\tconst a00 = a[0];\n\t\tconst a01 = a[1];\n\t\tconst a02 = a[2];\n\t\tconst a10 = a[4];\n\t\tconst a11 = a[5];\n\t\tconst a12 = a[6];\n\t\tconst a20 = a[8];\n\t\tconst a21 = a[9];\n\t\tconst a22 = a[10];\n\t\tconst a30 = a[12];\n\t\tconst a31 = a[13];\n\t\tconst a32 = a[14];\n\t\tlet b0, b1, b2;\n\t\tb0 = b[0];\n\t\tb1 = b[1];\n\t\tb2 = b[2];\n\t\tr[0] = a00 * b0 + a10 * b1 + a20 * b2;\n\t\tr[1] = a01 * b0 + a11 * b1 + a21 * b2;\n\t\tr[2] = a02 * b0 + a12 * b1 + a22 * b2;\n\t\tr[3] = 0;\n\t\tb0 = b[4];\n\t\tb1 = b[5];\n\t\tb2 = b[6];\n\t\tr[4] = a00 * b0 + a10 * b1 + a20 * b2;\n\t\tr[5] = a01 * b0 + a11 * b1 + a21 * b2;\n\t\tr[6] = a02 * b0 + a12 * b1 + a22 * b2;\n\t\tr[7] = 0;\n\t\tb0 = b[8];\n\t\tb1 = b[9];\n\t\tb2 = b[10];\n\t\tr[8] = a00 * b0 + a10 * b1 + a20 * b2;\n\t\tr[9] = a01 * b0 + a11 * b1 + a21 * b2;\n\t\tr[10] = a02 * b0 + a12 * b1 + a22 * b2;\n\t\tr[11] = 0;\n\t\tb0 = b[12];\n\t\tb1 = b[13];\n\t\tb2 = b[14];\n\t\tr[12] = a00 * b0 + a10 * b1 + a20 * b2 + a30;\n\t\tr[13] = a01 * b0 + a11 * b1 + a21 * b2 + a31;\n\t\tr[14] = a02 * b0 + a12 * b1 + a22 * b2 + a32;\n\t\tr[15] = 1;\n\t\treturn this;\n\t}\n\tmul(rhs) {\n\t\treturn this.mul2(this, rhs);\n\t}\n\ttransformPoint(vec, res = new Vec3()) {\n\t\tconst m = this.data;\n\t\tconst {\n\t\t\tx,\n\t\t\ty,\n\t\t\tz\n\t\t} = vec;\n\t\tres.x = x * m[0] + y * m[4] + z * m[8] + m[12];\n\t\tres.y = x * m[1] + y * m[5] + z * m[9] + m[13];\n\t\tres.z = x * m[2] + y * m[6] + z * m[10] + m[14];\n\t\treturn res;\n\t}\n\ttransformVector(vec, res = new Vec3()) {\n\t\tconst m = this.data;\n\t\tconst {\n\t\t\tx,\n\t\t\ty,\n\t\t\tz\n\t\t} = vec;\n\t\tres.x = x * m[0] + y * m[4] + z * m[8];\n\t\tres.y = x * m[1] + y * m[5] + z * m[9];\n\t\tres.z = x * m[2] + y * m[6] + z * m[10];\n\t\treturn res;\n\t}\n\ttransformVec4(vec, res = new Vec4()) {\n\t\tconst m = this.data;\n\t\tconst {\n\t\t\tx,\n\t\t\ty,\n\t\t\tz,\n\t\t\tw\n\t\t} = vec;\n\t\tres.x = x * m[0] + y * m[4] + z * m[8] + w * m[12];\n\t\tres.y = x * m[1] + y * m[5] + z * m[9] + w * m[13];\n\t\tres.z = x * m[2] + y * m[6] + z * m[10] + w * m[14];\n\t\tres.w = x * m[3] + y * m[7] + z * m[11] + w * m[15];\n\t\treturn res;\n\t}\n\tsetLookAt(position, target, up) {\n\t\tz.sub2(position, target).normalize();\n\t\ty.copy(up).normalize();\n\t\tx.cross(y, z).normalize();\n\t\ty.cross(z, x);\n\t\tconst r = this.data;\n\t\tr[0] = x.x;\n\t\tr[1] = x.y;\n\t\tr[2] = x.z;\n\t\tr[3] = 0;\n\t\tr[4] = y.x;\n\t\tr[5] = y.y;\n\t\tr[6] = y.z;\n\t\tr[7] = 0;\n\t\tr[8] = z.x;\n\t\tr[9] = z.y;\n\t\tr[10] = z.z;\n\t\tr[11] = 0;\n\t\tr[12] = position.x;\n\t\tr[13] = position.y;\n\t\tr[14] = position.z;\n\t\tr[15] = 1;\n\t\treturn this;\n\t}\n\tsetFrustum(left, right, bottom, top, znear, zfar) {\n\t\tconst temp1 = 2 * znear;\n\t\tconst temp2 = right - left;\n\t\tconst temp3 = top - bottom;\n\t\tconst temp4 = zfar - znear;\n\t\tconst r = this.data;\n\t\tr[0] = temp1 / temp2;\n\t\tr[1] = 0;\n\t\tr[2] = 0;\n\t\tr[3] = 0;\n\t\tr[4] = 0;\n\t\tr[5] = temp1 / temp3;\n\t\tr[6] = 0;\n\t\tr[7] = 0;\n\t\tr[8] = (right + left) / temp2;\n\t\tr[9] = (top + bottom) / temp3;\n\t\tr[10] = (-zfar - znear) / temp4;\n\t\tr[11] = -1;\n\t\tr[12] = 0;\n\t\tr[13] = 0;\n\t\tr[14] = -temp1 * zfar / temp4;\n\t\tr[15] = 0;\n\t\treturn this;\n\t}\n\tsetPerspective(fov, aspect, znear, zfar, fovIsHorizontal) {\n\t\tMat4._getPerspectiveHalfSize(_halfSize, fov, aspect, znear, fovIsHorizontal);\n\t\treturn this.setFrustum(-_halfSize.x, _halfSize.x, -_halfSize.y, _halfSize.y, znear, zfar);\n\t}\n\tsetOrtho(left, right, bottom, top, near, far) {\n\t\tconst r = this.data;\n\t\tr[0] = 2 / (right - left);\n\t\tr[1] = 0;\n\t\tr[2] = 0;\n\t\tr[3] = 0;\n\t\tr[4] = 0;\n\t\tr[5] = 2 / (top - bottom);\n\t\tr[6] = 0;\n\t\tr[7] = 0;\n\t\tr[8] = 0;\n\t\tr[9] = 0;\n\t\tr[10] = -2 / (far - near);\n\t\tr[11] = 0;\n\t\tr[12] = -(right + left) / (right - left);\n\t\tr[13] = -(top + bottom) / (top - bottom);\n\t\tr[14] = -(far + near) / (far - near);\n\t\tr[15] = 1;\n\t\treturn this;\n\t}\n\tsetFromAxisAngle(axis, angle) {\n\t\tangle *= math.DEG_TO_RAD;\n\t\tconst {\n\t\t\tx,\n\t\t\ty,\n\t\t\tz\n\t\t} = axis;\n\t\tconst c = Math.cos(angle);\n\t\tconst s = Math.sin(angle);\n\t\tconst t = 1 - c;\n\t\tconst tx = t * x;\n\t\tconst ty = t * y;\n\t\tconst m = this.data;\n\t\tm[0] = tx * x + c;\n\t\tm[1] = tx * y + s * z;\n\t\tm[2] = tx * z - s * y;\n\t\tm[3] = 0;\n\t\tm[4] = tx * y - s * z;\n\t\tm[5] = ty * y + c;\n\t\tm[6] = ty * z + s * x;\n\t\tm[7] = 0;\n\t\tm[8] = tx * z + s * y;\n\t\tm[9] = ty * z - x * s;\n\t\tm[10] = t * z * z + c;\n\t\tm[11] = 0;\n\t\tm[12] = 0;\n\t\tm[13] = 0;\n\t\tm[14] = 0;\n\t\tm[15] = 1;\n\t\treturn this;\n\t}\n\tsetTranslate(x, y, z) {\n\t\tconst m = this.data;\n\t\tm[0] = 1;\n\t\tm[1] = 0;\n\t\tm[2] = 0;\n\t\tm[3] = 0;\n\t\tm[4] = 0;\n\t\tm[5] = 1;\n\t\tm[6] = 0;\n\t\tm[7] = 0;\n\t\tm[8] = 0;\n\t\tm[9] = 0;\n\t\tm[10] = 1;\n\t\tm[11] = 0;\n\t\tm[12] = x;\n\t\tm[13] = y;\n\t\tm[14] = z;\n\t\tm[15] = 1;\n\t\treturn this;\n\t}\n\tsetScale(x, y, z) {\n\t\tconst m = this.data;\n\t\tm[0] = x;\n\t\tm[1] = 0;\n\t\tm[2] = 0;\n\t\tm[3] = 0;\n\t\tm[4] = 0;\n\t\tm[5] = y;\n\t\tm[6] = 0;\n\t\tm[7] = 0;\n\t\tm[8] = 0;\n\t\tm[9] = 0;\n\t\tm[10] = z;\n\t\tm[11] = 0;\n\t\tm[12] = 0;\n\t\tm[13] = 0;\n\t\tm[14] = 0;\n\t\tm[15] = 1;\n\t\treturn this;\n\t}\n\tsetViewport(x, y, width, height) {\n\t\tconst m = this.data;\n\t\tm[0] = width * 0.5;\n\t\tm[1] = 0;\n\t\tm[2] = 0;\n\t\tm[3] = 0;\n\t\tm[4] = 0;\n\t\tm[5] = height * 0.5;\n\t\tm[6] = 0;\n\t\tm[7] = 0;\n\t\tm[8] = 0;\n\t\tm[9] = 0;\n\t\tm[10] = 0.5;\n\t\tm[11] = 0;\n\t\tm[12] = x + width * 0.5;\n\t\tm[13] = y + height * 0.5;\n\t\tm[14] = 0.5;\n\t\tm[15] = 1;\n\t\treturn this;\n\t}\n\tsetReflection(normal, distance) {\n\t\tconst a = normal.x;\n\t\tconst b = normal.y;\n\t\tconst c = normal.z;\n\t\tconst data = this.data;\n\t\tdata[0] = 1.0 - 2 * a * a;\n\t\tdata[1] = -2 * a * b;\n\t\tdata[2] = -2 * a * c;\n\t\tdata[3] = 0;\n\t\tdata[4] = -2 * a * b;\n\t\tdata[5] = 1.0 - 2 * b * b;\n\t\tdata[6] = -2 * b * c;\n\t\tdata[7] = 0;\n\t\tdata[8] = -2 * a * c;\n\t\tdata[9] = -2 * b * c;\n\t\tdata[10] = 1.0 - 2 * c * c;\n\t\tdata[11] = 0;\n\t\tdata[12] = -2 * a * distance;\n\t\tdata[13] = -2 * b * distance;\n\t\tdata[14] = -2 * c * distance;\n\t\tdata[15] = 1;\n\t\treturn this;\n\t}\n\tinvert(src = this) {\n\t\tconst s = src.data;\n\t\tconst a00 = s[0];\n\t\tconst a01 = s[1];\n\t\tconst a02 = s[2];\n\t\tconst a03 = s[3];\n\t\tconst a10 = s[4];\n\t\tconst a11 = s[5];\n\t\tconst a12 = s[6];\n\t\tconst a13 = s[7];\n\t\tconst a20 = s[8];\n\t\tconst a21 = s[9];\n\t\tconst a22 = s[10];\n\t\tconst a23 = s[11];\n\t\tconst a30 = s[12];\n\t\tconst a31 = s[13];\n\t\tconst a32 = s[14];\n\t\tconst a33 = s[15];\n\t\tconst b00 = a00 * a11 - a01 * a10;\n\t\tconst b01 = a00 * a12 - a02 * a10;\n\t\tconst b02 = a00 * a13 - a03 * a10;\n\t\tconst b03 = a01 * a12 - a02 * a11;\n\t\tconst b04 = a01 * a13 - a03 * a11;\n\t\tconst b05 = a02 * a13 - a03 * a12;\n\t\tconst b06 = a20 * a31 - a21 * a30;\n\t\tconst b07 = a20 * a32 - a22 * a30;\n\t\tconst b08 = a20 * a33 - a23 * a30;\n\t\tconst b09 = a21 * a32 - a22 * a31;\n\t\tconst b10 = a21 * a33 - a23 * a31;\n\t\tconst b11 = a22 * a33 - a23 * a32;\n\t\tconst det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;\n\t\tif (det === 0) {\n\t\t\tthis.setIdentity();\n\t\t} else {\n\t\t\tconst invDet = 1 / det;\n\t\t\tconst t = this.data;\n\t\t\tt[0] = (a11 * b11 - a12 * b10 + a13 * b09) * invDet;\n\t\t\tt[1] = (-a01 * b11 + a02 * b10 - a03 * b09) * invDet;\n\t\t\tt[2] = (a31 * b05 - a32 * b04 + a33 * b03) * invDet;\n\t\t\tt[3] = (-a21 * b05 + a22 * b04 - a23 * b03) * invDet;\n\t\t\tt[4] = (-a10 * b11 + a12 * b08 - a13 * b07) * invDet;\n\t\t\tt[5] = (a00 * b11 - a02 * b08 + a03 * b07) * invDet;\n\t\t\tt[6] = (-a30 * b05 + a32 * b02 - a33 * b01) * invDet;\n\t\t\tt[7] = (a20 * b05 - a22 * b02 + a23 * b01) * invDet;\n\t\t\tt[8] = (a10 * b10 - a11 * b08 + a13 * b06) * invDet;\n\t\t\tt[9] = (-a00 * b10 + a01 * b08 - a03 * b06) * invDet;\n\t\t\tt[10] = (a30 * b04 - a31 * b02 + a33 * b00) * invDet;\n\t\t\tt[11] = (-a20 * b04 + a21 * b02 - a23 * b00) * invDet;\n\t\t\tt[12] = (-a10 * b09 + a11 * b07 - a12 * b06) * invDet;\n\t\t\tt[13] = (a00 * b09 - a01 * b07 + a02 * b06) * invDet;\n\t\t\tt[14] = (-a30 * b03 + a31 * b01 - a32 * b00) * invDet;\n\t\t\tt[15] = (a20 * b03 - a21 * b01 + a22 * b00) * invDet;\n\t\t}\n\t\treturn this;\n\t}\n\tset(src) {\n\t\tconst dst = this.data;\n\t\tdst[0] = src[0];\n\t\tdst[1] = src[1];\n\t\tdst[2] = src[2];\n\t\tdst[3] = src[3];\n\t\tdst[4] = src[4];\n\t\tdst[5] = src[5];\n\t\tdst[6] = src[6];\n\t\tdst[7] = src[7];\n\t\tdst[8] = src[8];\n\t\tdst[9] = src[9];\n\t\tdst[10] = src[10];\n\t\tdst[11] = src[11];\n\t\tdst[12] = src[12];\n\t\tdst[13] = src[13];\n\t\tdst[14] = src[14];\n\t\tdst[15] = src[15];\n\t\treturn this;\n\t}\n\tsetIdentity() {\n\t\tconst m = this.data;\n\t\tm[0] = 1;\n\t\tm[1] = 0;\n\t\tm[2] = 0;\n\t\tm[3] = 0;\n\t\tm[4] = 0;\n\t\tm[5] = 1;\n\t\tm[6] = 0;\n\t\tm[7] = 0;\n\t\tm[8] = 0;\n\t\tm[9] = 0;\n\t\tm[10] = 1;\n\t\tm[11] = 0;\n\t\tm[12] = 0;\n\t\tm[13] = 0;\n\t\tm[14] = 0;\n\t\tm[15] = 1;\n\t\treturn this;\n\t}\n\tsetTRS(t, r, s) {\n\t\tconst qx = r.x;\n\t\tconst qy = r.y;\n\t\tconst qz = r.z;\n\t\tconst qw = r.w;\n\t\tconst sx = s.x;\n\t\tconst sy = s.y;\n\t\tconst sz = s.z;\n\t\tconst x2 = qx + qx;\n\t\tconst y2 = qy + qy;\n\t\tconst z2 = qz + qz;\n\t\tconst xx = qx * x2;\n\t\tconst xy = qx * y2;\n\t\tconst xz = qx * z2;\n\t\tconst yy = qy * y2;\n\t\tconst yz = qy * z2;\n\t\tconst zz = qz * z2;\n\t\tconst wx = qw * x2;\n\t\tconst wy = qw * y2;\n\t\tconst wz = qw * z2;\n\t\tconst m = this.data;\n\t\tm[0] = (1 - (yy + zz)) * sx;\n\t\tm[1] = (xy + wz) * sx;\n\t\tm[2] = (xz - wy) * sx;\n\t\tm[3] = 0;\n\t\tm[4] = (xy - wz) * sy;\n\t\tm[5] = (1 - (xx + zz)) * sy;\n\t\tm[6] = (yz + wx) * sy;\n\t\tm[7] = 0;\n\t\tm[8] = (xz + wy) * sz;\n\t\tm[9] = (yz - wx) * sz;\n\t\tm[10] = (1 - (xx + yy)) * sz;\n\t\tm[11] = 0;\n\t\tm[12] = t.x;\n\t\tm[13] = t.y;\n\t\tm[14] = t.z;\n\t\tm[15] = 1;\n\t\treturn this;\n\t}\n\ttranspose(src = this) {\n\t\tconst s = src.data;\n\t\tconst t = this.data;\n\t\tif (s === t) {\n\t\t\tlet tmp;\n\t\t\ttmp = s[1];\n\t\t\tt[1] = s[4];\n\t\t\tt[4] = tmp;\n\t\t\ttmp = s[2];\n\t\t\tt[2] = s[8];\n\t\t\tt[8] = tmp;\n\t\t\ttmp = s[3];\n\t\t\tt[3] = s[12];\n\t\t\tt[12] = tmp;\n\t\t\ttmp = s[6];\n\t\t\tt[6] = s[9];\n\t\t\tt[9] = tmp;\n\t\t\ttmp = s[7];\n\t\t\tt[7] = s[13];\n\t\t\tt[13] = tmp;\n\t\t\ttmp = s[11];\n\t\t\tt[11] = s[14];\n\t\t\tt[14] = tmp;\n\t\t} else {\n\t\t\tt[0] = s[0];\n\t\t\tt[1] = s[4];\n\t\t\tt[2] = s[8];\n\t\t\tt[3] = s[12];\n\t\t\tt[4] = s[1];\n\t\t\tt[5] = s[5];\n\t\t\tt[6] = s[9];\n\t\t\tt[7] = s[13];\n\t\t\tt[8] = s[2];\n\t\t\tt[9] = s[6];\n\t\t\tt[10] = s[10];\n\t\t\tt[11] = s[14];\n\t\t\tt[12] = s[3];\n\t\t\tt[13] = s[7];\n\t\t\tt[14] = s[11];\n\t\t\tt[15] = s[15];\n\t\t}\n\t\treturn this;\n\t}\n\tgetTranslation(t = new Vec3()) {\n\t\treturn t.set(this.data[12], this.data[13], this.data[14]);\n\t}\n\tgetX(x = new Vec3()) {\n\t\treturn x.set(this.data[0], this.data[1], this.data[2]);\n\t}\n\tgetY(y = new Vec3()) {\n\t\treturn y.set(this.data[4], this.data[5], this.data[6]);\n\t}\n\tgetZ(z = new Vec3()) {\n\t\treturn z.set(this.data[8], this.data[9], this.data[10]);\n\t}\n\tgetScale(scale = new Vec3()) {\n\t\tthis.getX(x);\n\t\tthis.getY(y);\n\t\tthis.getZ(z);\n\t\tscale.set(x.length(), y.length(), z.length());\n\t\treturn scale;\n\t}\n\tget scaleSign() {\n\t\tthis.getX(x);\n\t\tthis.getY(y);\n\t\tthis.getZ(z);\n\t\tx.cross(x, y);\n\t\treturn x.dot(z) < 0 ? -1 : 1;\n\t}\n\tsetFromEulerAngles(ex, ey, ez) {\n\t\tex *= math.DEG_TO_RAD;\n\t\tey *= math.DEG_TO_RAD;\n\t\tez *= math.DEG_TO_RAD;\n\t\tconst s1 = Math.sin(-ex);\n\t\tconst c1 = Math.cos(-ex);\n\t\tconst s2 = Math.sin(-ey);\n\t\tconst c2 = Math.cos(-ey);\n\t\tconst s3 = Math.sin(-ez);\n\t\tconst c3 = Math.cos(-ez);\n\t\tconst m = this.data;\n\t\tm[0] = c2 * c3;\n\t\tm[1] = -c2 * s3;\n\t\tm[2] = s2;\n\t\tm[3] = 0;\n\t\tm[4] = c1 * s3 + c3 * s1 * s2;\n\t\tm[5] = c1 * c3 - s1 * s2 * s3;\n\t\tm[6] = -c2 * s1;\n\t\tm[7] = 0;\n\t\tm[8] = s1 * s3 - c1 * c3 * s2;\n\t\tm[9] = c3 * s1 + c1 * s2 * s3;\n\t\tm[10] = c1 * c2;\n\t\tm[11] = 0;\n\t\tm[12] = 0;\n\t\tm[13] = 0;\n\t\tm[14] = 0;\n\t\tm[15] = 1;\n\t\treturn this;\n\t}\n\tgetEulerAngles(eulers = new Vec3()) {\n\t\tthis.getScale(scale);\n\t\tconst sx = scale.x;\n\t\tconst sy = scale.y;\n\t\tconst sz = scale.z;\n\t\tif (sx === 0 || sy === 0 || sz === 0) return eulers.set(0, 0, 0);\n\t\tconst m = this.data;\n\t\tconst y = Math.asin(-m[2] / sx);\n\t\tconst halfPi = Math.PI * 0.5;\n\t\tlet x, z;\n\t\tif (y < halfPi) {\n\t\t\tif (y > -halfPi) {\n\t\t\t\tx = Math.atan2(m[6] / sy, m[10] / sz);\n\t\t\t\tz = Math.atan2(m[1] / sx, m[0] / sx);\n\t\t\t} else {\n\t\t\t\tz = 0;\n\t\t\t\tx = -Math.atan2(m[4] / sy, m[5] / sy);\n\t\t\t}\n\t\t} else {\n\t\t\tz = 0;\n\t\t\tx = Math.atan2(m[4] / sy, m[5] / sy);\n\t\t}\n\t\treturn eulers.set(x, y, z).mulScalar(math.RAD_TO_DEG);\n\t}\n\ttoString() {\n\t\treturn '[' + this.data.join(', ') + ']';\n\t}\n}\n_Mat = Mat4;\nMat4.IDENTITY = Object.freeze(new _Mat());\nMat4.ZERO = Object.freeze(new _Mat().set([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));\n\nexport { Mat4 };\n", "import { math } from './math.js';\nimport { Vec3 } from './vec3.js';\n\nvar _Quat;\nclass Quat {\n\tconstructor(x = 0, y = 0, z = 0, w = 1) {\n\t\tthis.x = void 0;\n\t\tthis.y = void 0;\n\t\tthis.z = void 0;\n\t\tthis.w = void 0;\n\t\tif (x.length === 4) {\n\t\t\tthis.x = x[0];\n\t\t\tthis.y = x[1];\n\t\t\tthis.z = x[2];\n\t\t\tthis.w = x[3];\n\t\t} else {\n\t\t\tthis.x = x;\n\t\t\tthis.y = y;\n\t\t\tthis.z = z;\n\t\t\tthis.w = w;\n\t\t}\n\t}\n\tclone() {\n\t\tconst cstr = this.constructor;\n\t\treturn new cstr(this.x, this.y, this.z, this.w);\n\t}\n\tconjugate(src = this) {\n\t\tthis.x = src.x * -1;\n\t\tthis.y = src.y * -1;\n\t\tthis.z = src.z * -1;\n\t\tthis.w = src.w;\n\t\treturn this;\n\t}\n\tcopy(rhs) {\n\t\tthis.x = rhs.x;\n\t\tthis.y = rhs.y;\n\t\tthis.z = rhs.z;\n\t\tthis.w = rhs.w;\n\t\treturn this;\n\t}\n\tequals(rhs) {\n\t\treturn this.x === rhs.x && this.y === rhs.y && this.z === rhs.z && this.w === rhs.w;\n\t}\n\tequalsApprox(rhs, epsilon = 1e-6) {\n\t\treturn Math.abs(this.x - rhs.x) < epsilon && Math.abs(this.y - rhs.y) < epsilon && Math.abs(this.z - rhs.z) < epsilon && Math.abs(this.w - rhs.w) < epsilon;\n\t}\n\tgetAxisAngle(axis) {\n\t\tlet rad = Math.acos(this.w) * 2;\n\t\tconst s = Math.sin(rad / 2);\n\t\tif (s !== 0) {\n\t\t\taxis.x = this.x / s;\n\t\t\taxis.y = this.y / s;\n\t\t\taxis.z = this.z / s;\n\t\t\tif (axis.x < 0 || axis.y < 0 || axis.z < 0) {\n\t\t\t\taxis.x *= -1;\n\t\t\t\taxis.y *= -1;\n\t\t\t\taxis.z *= -1;\n\t\t\t\trad *= -1;\n\t\t\t}\n\t\t} else {\n\t\t\taxis.x = 1;\n\t\t\taxis.y = 0;\n\t\t\taxis.z = 0;\n\t\t}\n\t\treturn rad * math.RAD_TO_DEG;\n\t}\n\tgetEulerAngles(eulers = new Vec3()) {\n\t\tlet x, y, z;\n\t\tconst qx = this.x;\n\t\tconst qy = this.y;\n\t\tconst qz = this.z;\n\t\tconst qw = this.w;\n\t\tconst a2 = 2 * (qw * qy - qx * qz);\n\t\tif (a2 <= -0.99999) {\n\t\t\tx = 2 * Math.atan2(qx, qw);\n\t\t\ty = -Math.PI / 2;\n\t\t\tz = 0;\n\t\t} else if (a2 >= 0.99999) {\n\t\t\tx = 2 * Math.atan2(qx, qw);\n\t\t\ty = Math.PI / 2;\n\t\t\tz = 0;\n\t\t} else {\n\t\t\tx = Math.atan2(2 * (qw * qx + qy * qz), 1 - 2 * (qx * qx + qy * qy));\n\t\t\ty = Math.asin(a2);\n\t\t\tz = Math.atan2(2 * (qw * qz + qx * qy), 1 - 2 * (qy * qy + qz * qz));\n\t\t}\n\t\treturn eulers.set(x, y, z).mulScalar(math.RAD_TO_DEG);\n\t}\n\tinvert(src = this) {\n\t\treturn this.conjugate(src).normalize();\n\t}\n\tlength() {\n\t\treturn Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w);\n\t}\n\tlengthSq() {\n\t\treturn this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w;\n\t}\n\tmul(rhs) {\n\t\tconst q1x = this.x;\n\t\tconst q1y = this.y;\n\t\tconst q1z = this.z;\n\t\tconst q1w = this.w;\n\t\tconst q2x = rhs.x;\n\t\tconst q2y = rhs.y;\n\t\tconst q2z = rhs.z;\n\t\tconst q2w = rhs.w;\n\t\tthis.x = q1w * q2x + q1x * q2w + q1y * q2z - q1z * q2y;\n\t\tthis.y = q1w * q2y + q1y * q2w + q1z * q2x - q1x * q2z;\n\t\tthis.z = q1w * q2z + q1z * q2w + q1x * q2y - q1y * q2x;\n\t\tthis.w = q1w * q2w - q1x * q2x - q1y * q2y - q1z * q2z;\n\t\treturn this;\n\t}\n\tmulScalar(scalar, src = this) {\n\t\tthis.x = src.x * scalar;\n\t\tthis.y = src.y * scalar;\n\t\tthis.z = src.z * scalar;\n\t\tthis.w = src.w * scalar;\n\t\treturn this;\n\t}\n\tmul2(lhs, rhs) {\n\t\tconst q1x = lhs.x;\n\t\tconst q1y = lhs.y;\n\t\tconst q1z = lhs.z;\n\t\tconst q1w = lhs.w;\n\t\tconst q2x = rhs.x;\n\t\tconst q2y = rhs.y;\n\t\tconst q2z = rhs.z;\n\t\tconst q2w = rhs.w;\n\t\tthis.x = q1w * q2x + q1x * q2w + q1y * q2z - q1z * q2y;\n\t\tthis.y = q1w * q2y + q1y * q2w + q1z * q2x - q1x * q2z;\n\t\tthis.z = q1w * q2z + q1z * q2w + q1x * q2y - q1y * q2x;\n\t\tthis.w = q1w * q2w - q1x * q2x - q1y * q2y - q1z * q2z;\n\t\treturn this;\n\t}\n\tnormalize(src = this) {\n\t\tlet len = src.length();\n\t\tif (len === 0) {\n\t\t\tthis.x = this.y = this.z = 0;\n\t\t\tthis.w = 1;\n\t\t} else {\n\t\t\tlen = 1 / len;\n\t\t\tthis.x = src.x * len;\n\t\t\tthis.y = src.y * len;\n\t\t\tthis.z = src.z * len;\n\t\t\tthis.w = src.w * len;\n\t\t}\n\t\treturn this;\n\t}\n\tset(x, y, z, w) {\n\t\tthis.x = x;\n\t\tthis.y = y;\n\t\tthis.z = z;\n\t\tthis.w = w;\n\t\treturn this;\n\t}\n\tsetFromAxisAngle(axis, angle) {\n\t\tangle *= 0.5 * math.DEG_TO_RAD;\n\t\tconst sa = Math.sin(angle);\n\t\tconst ca = Math.cos(angle);\n\t\tthis.x = sa * axis.x;\n\t\tthis.y = sa * axis.y;\n\t\tthis.z = sa * axis.z;\n\t\tthis.w = ca;\n\t\treturn this;\n\t}\n\tsetFromEulerAngles(ex, ey, ez) {\n\t\tif (ex instanceof Vec3) {\n\t\t\tconst vec = ex;\n\t\t\tex = vec.x;\n\t\t\tey = vec.y;\n\t\t\tez = vec.z;\n\t\t}\n\t\tconst halfToRad = 0.5 * math.DEG_TO_RAD;\n\t\tex *= halfToRad;\n\t\tey *= halfToRad;\n\t\tez *= halfToRad;\n\t\tconst sx = Math.sin(ex);\n\t\tconst cx = Math.cos(ex);\n\t\tconst sy = Math.sin(ey);\n\t\tconst cy = Math.cos(ey);\n\t\tconst sz = Math.sin(ez);\n\t\tconst cz = Math.cos(ez);\n\t\tthis.x = sx * cy * cz - cx * sy * sz;\n\t\tthis.y = cx * sy * cz + sx * cy * sz;\n\t\tthis.z = cx * cy * sz - sx * sy * cz;\n\t\tthis.w = cx * cy * cz + sx * sy * sz;\n\t\treturn this;\n\t}\n\tsetFromMat4(m) {\n\t\tconst d = m.data;\n\t\tlet m00 = d[0];\n\t\tlet m01 = d[1];\n\t\tlet m02 = d[2];\n\t\tlet m10 = d[4];\n\t\tlet m11 = d[5];\n\t\tlet m12 = d[6];\n\t\tlet m20 = d[8];\n\t\tlet m21 = d[9];\n\t\tlet m22 = d[10];\n\t\tlet l;\n\t\tl = m00 * m00 + m01 * m01 + m02 * m02;\n\t\tif (l === 0) return this.set(0, 0, 0, 1);\n\t\tl = 1 / Math.sqrt(l);\n\t\tm00 *= l;\n\t\tm01 *= l;\n\t\tm02 *= l;\n\t\tl = m10 * m10 + m11 * m11 + m12 * m12;\n\t\tif (l === 0) return this.set(0, 0, 0, 1);\n\t\tl = 1 / Math.sqrt(l);\n\t\tm10 *= l;\n\t\tm11 *= l;\n\t\tm12 *= l;\n\t\tl = m20 * m20 + m21 * m21 + m22 * m22;\n\t\tif (l === 0) return this.set(0, 0, 0, 1);\n\t\tl = 1 / Math.sqrt(l);\n\t\tm20 *= l;\n\t\tm21 *= l;\n\t\tm22 *= l;\n\t\tif (m22 < 0) {\n\t\t\tif (m00 > m11) {\n\t\t\t\tthis.set(1 + m00 - m11 - m22, m01 + m10, m20 + m02, m12 - m21);\n\t\t\t} else {\n\t\t\t\tthis.set(m01 + m10, 1 - m00 + m11 - m22, m12 + m21, m20 - m02);\n\t\t\t}\n\t\t} else {\n\t\t\tif (m00 < -m11) {\n\t\t\t\tthis.set(m20 + m02, m12 + m21, 1 - m00 - m11 + m22, m01 - m10);\n\t\t\t} else {\n\t\t\t\tthis.set(m12 - m21, m20 - m02, m01 - m10, 1 + m00 + m11 + m22);\n\t\t\t}\n\t\t}\n\t\treturn this.mulScalar(1.0 / this.length());\n\t}\n\tsetFromDirections(from, to) {\n\t\tconst dotProduct = 1 + from.dot(to);\n\t\tif (dotProduct < Number.EPSILON) {\n\t\t\tif (Math.abs(from.x) > Math.abs(from.y)) {\n\t\t\t\tthis.x = -from.z;\n\t\t\t\tthis.y = 0;\n\t\t\t\tthis.z = from.x;\n\t\t\t\tthis.w = 0;\n\t\t\t} else {\n\t\t\t\tthis.x = 0;\n\t\t\t\tthis.y = -from.z;\n\t\t\t\tthis.z = from.y;\n\t\t\t\tthis.w = 0;\n\t\t\t}\n\t\t} else {\n\t\t\tthis.x = from.y * to.z - from.z * to.y;\n\t\t\tthis.y = from.z * to.x - from.x * to.z;\n\t\t\tthis.z = from.x * to.y - from.y * to.x;\n\t\t\tthis.w = dotProduct;\n\t\t}\n\t\treturn this.normalize();\n\t}\n\tslerp(lhs, rhs, alpha) {\n\t\tconst lx = lhs.x;\n\t\tconst ly = lhs.y;\n\t\tconst lz = lhs.z;\n\t\tconst lw = lhs.w;\n\t\tlet rx = rhs.x;\n\t\tlet ry = rhs.y;\n\t\tlet rz = rhs.z;\n\t\tlet rw = rhs.w;\n\t\tlet cosHalfTheta = lw * rw + lx * rx + ly * ry + lz * rz;\n\t\tif (cosHalfTheta < 0) {\n\t\t\trw = -rw;\n\t\t\trx = -rx;\n\t\t\try = -ry;\n\t\t\trz = -rz;\n\t\t\tcosHalfTheta = -cosHalfTheta;\n\t\t}\n\t\tif (Math.abs(cosHalfTheta) >= 1) {\n\t\t\tthis.w = lw;\n\t\t\tthis.x = lx;\n\t\t\tthis.y = ly;\n\t\t\tthis.z = lz;\n\t\t\treturn this;\n\t\t}\n\t\tconst halfTheta = Math.acos(cosHalfTheta);\n\t\tconst sinHalfTheta = Math.sqrt(1 - cosHalfTheta * cosHalfTheta);\n\t\tif (Math.abs(sinHalfTheta) < 0.001) {\n\t\t\tthis.w = lw * 0.5 + rw * 0.5;\n\t\t\tthis.x = lx * 0.5 + rx * 0.5;\n\t\t\tthis.y = ly * 0.5 + ry * 0.5;\n\t\t\tthis.z = lz * 0.5 + rz * 0.5;\n\t\t\treturn this;\n\t\t}\n\t\tconst ratioA = Math.sin((1 - alpha) * halfTheta) / sinHalfTheta;\n\t\tconst ratioB = Math.sin(alpha * halfTheta) / sinHalfTheta;\n\t\tthis.w = lw * ratioA + rw * ratioB;\n\t\tthis.x = lx * ratioA + rx * ratioB;\n\t\tthis.y = ly * ratioA + ry * ratioB;\n\t\tthis.z = lz * ratioA + rz * ratioB;\n\t\treturn this;\n\t}\n\ttransformVector(vec, res = new Vec3()) {\n\t\tconst x = vec.x,\n\t\t\ty = vec.y,\n\t\t\tz = vec.z;\n\t\tconst qx = this.x,\n\t\t\tqy = this.y,\n\t\t\tqz = this.z,\n\t\t\tqw = this.w;\n\t\tconst ix = qw * x + qy * z - qz * y;\n\t\tconst iy = qw * y + qz * x - qx * z;\n\t\tconst iz = qw * z + qx * y - qy * x;\n\t\tconst iw = -qx * x - qy * y - qz * z;\n\t\tres.x = ix * qw + iw * -qx + iy * -qz - iz * -qy;\n\t\tres.y = iy * qw + iw * -qy + iz * -qx - ix * -qz;\n\t\tres.z = iz * qw + iw * -qz + ix * -qy - iy * -qx;\n\t\treturn res;\n\t}\n\ttoString() {\n\t\treturn `[${this.x}, ${this.y}, ${this.z}, ${this.w}]`;\n\t}\n}\n_Quat = Quat;\nQuat.IDENTITY = Object.freeze(new _Quat(0, 0, 0, 1));\nQuat.ZERO = Object.freeze(new _Quat(0, 0, 0, 0));\n\nexport { Quat };\n", "import { Vec3 } from '../math/vec3.js';\n\nconst tmpVecA = new Vec3();\nconst tmpVecB = new Vec3();\nconst tmpVecC = new Vec3();\nconst tmpVecD = new Vec3();\nconst tmpVecE = new Vec3();\nclass BoundingBox {\n\tconstructor(center = new Vec3(), halfExtents = new Vec3(0.5, 0.5, 0.5)) {\n\t\tthis.center = void 0;\n\t\tthis.halfExtents = void 0;\n\t\tthis._min = new Vec3();\n\t\tthis._max = new Vec3();\n\t\tthis.center = center;\n\t\tthis.halfExtents = halfExtents;\n\t}\n\tadd(other) {\n\t\tconst tc = this.center;\n\t\tconst tcx = tc.x;\n\t\tconst tcy = tc.y;\n\t\tconst tcz = tc.z;\n\t\tconst th = this.halfExtents;\n\t\tconst thx = th.x;\n\t\tconst thy = th.y;\n\t\tconst thz = th.z;\n\t\tlet tminx = tcx - thx;\n\t\tlet tmaxx = tcx + thx;\n\t\tlet tminy = tcy - thy;\n\t\tlet tmaxy = tcy + thy;\n\t\tlet tminz = tcz - thz;\n\t\tlet tmaxz = tcz + thz;\n\t\tconst oc = other.center;\n\t\tconst ocx = oc.x;\n\t\tconst ocy = oc.y;\n\t\tconst ocz = oc.z;\n\t\tconst oh = other.halfExtents;\n\t\tconst ohx = oh.x;\n\t\tconst ohy = oh.y;\n\t\tconst ohz = oh.z;\n\t\tconst ominx = ocx - ohx;\n\t\tconst omaxx = ocx + ohx;\n\t\tconst ominy = ocy - ohy;\n\t\tconst omaxy = ocy + ohy;\n\t\tconst ominz = ocz - ohz;\n\t\tconst omaxz = ocz + ohz;\n\t\tif (ominx < tminx) tminx = ominx;\n\t\tif (omaxx > tmaxx) tmaxx = omaxx;\n\t\tif (ominy < tminy) tminy = ominy;\n\t\tif (omaxy > tmaxy) tmaxy = omaxy;\n\t\tif (ominz < tminz) tminz = ominz;\n\t\tif (omaxz > tmaxz) tmaxz = omaxz;\n\t\ttc.x = (tminx + tmaxx) * 0.5;\n\t\ttc.y = (tminy + tmaxy) * 0.5;\n\t\ttc.z = (tminz + tmaxz) * 0.5;\n\t\tth.x = (tmaxx - tminx) * 0.5;\n\t\tth.y = (tmaxy - tminy) * 0.5;\n\t\tth.z = (tmaxz - tminz) * 0.5;\n\t}\n\tcopy(src) {\n\t\tthis.center.copy(src.center);\n\t\tthis.halfExtents.copy(src.halfExtents);\n\t}\n\tclone() {\n\t\treturn new BoundingBox(this.center.clone(), this.halfExtents.clone());\n\t}\n\tintersects(other) {\n\t\tconst aMax = this.getMax();\n\t\tconst aMin = this.getMin();\n\t\tconst bMax = other.getMax();\n\t\tconst bMin = other.getMin();\n\t\treturn aMin.x <= bMax.x && aMax.x >= bMin.x && aMin.y <= bMax.y && aMax.y >= bMin.y && aMin.z <= bMax.z && aMax.z >= bMin.z;\n\t}\n\t_intersectsRay(ray, point) {\n\t\tconst tMin = tmpVecA.copy(this.getMin()).sub(ray.origin);\n\t\tconst tMax = tmpVecB.copy(this.getMax()).sub(ray.origin);\n\t\tconst dir = ray.direction;\n\t\tif (dir.x === 0) {\n\t\t\ttMin.x = tMin.x < 0 ? -Number.MAX_VALUE : Number.MAX_VALUE;\n\t\t\ttMax.x = tMax.x < 0 ? -Number.MAX_VALUE : Number.MAX_VALUE;\n\t\t} else {\n\t\t\ttMin.x /= dir.x;\n\t\t\ttMax.x /= dir.x;\n\t\t}\n\t\tif (dir.y === 0) {\n\t\t\ttMin.y = tMin.y < 0 ? -Number.MAX_VALUE : Number.MAX_VALUE;\n\t\t\ttMax.y = tMax.y < 0 ? -Number.MAX_VALUE : Number.MAX_VALUE;\n\t\t} else {\n\t\t\ttMin.y /= dir.y;\n\t\t\ttMax.y /= dir.y;\n\t\t}\n\t\tif (dir.z === 0) {\n\t\t\ttMin.z = tMin.z < 0 ? -Number.MAX_VALUE : Number.MAX_VALUE;\n\t\t\ttMax.z = tMax.z < 0 ? -Number.MAX_VALUE : Number.MAX_VALUE;\n\t\t} else {\n\t\t\ttMin.z /= dir.z;\n\t\t\ttMax.z /= dir.z;\n\t\t}\n\t\tconst realMin = tmpVecC.set(Math.min(tMin.x, tMax.x), Math.min(tMin.y, tMax.y), Math.min(tMin.z, tMax.z));\n\t\tconst realMax = tmpVecD.set(Math.max(tMin.x, tMax.x), Math.max(tMin.y, tMax.y), Math.max(tMin.z, tMax.z));\n\t\tconst minMax = Math.min(Math.min(realMax.x, realMax.y), realMax.z);\n\t\tconst maxMin = Math.max(Math.max(realMin.x, realMin.y), realMin.z);\n\t\tconst intersects = minMax >= maxMin && maxMin >= 0;\n\t\tif (intersects) point.copy(ray.direction).mulScalar(maxMin).add(ray.origin);\n\t\treturn intersects;\n\t}\n\t_fastIntersectsRay(ray) {\n\t\tconst diff = tmpVecA;\n\t\tconst cross = tmpVecB;\n\t\tconst prod = tmpVecC;\n\t\tconst absDiff = tmpVecD;\n\t\tconst absDir = tmpVecE;\n\t\tconst rayDir = ray.direction;\n\t\tdiff.sub2(ray.origin, this.center);\n\t\tabsDiff.set(Math.abs(diff.x), Math.abs(diff.y), Math.abs(diff.z));\n\t\tprod.mul2(diff, rayDir);\n\t\tif (absDiff.x > this.halfExtents.x && prod.x >= 0) return false;\n\t\tif (absDiff.y > this.halfExtents.y && prod.y >= 0) return false;\n\t\tif (absDiff.z > this.halfExtents.z && prod.z >= 0) return false;\n\t\tabsDir.set(Math.abs(rayDir.x), Math.abs(rayDir.y), Math.abs(rayDir.z));\n\t\tcross.cross(rayDir, diff);\n\t\tcross.set(Math.abs(cross.x), Math.abs(cross.y), Math.abs(cross.z));\n\t\tif (cross.x > this.halfExtents.y * absDir.z + this.halfExtents.z * absDir.y) return false;\n\t\tif (cross.y > this.halfExtents.x * absDir.z + this.halfExtents.z * absDir.x) return false;\n\t\tif (cross.z > this.halfExtents.x * absDir.y + this.halfExtents.y * absDir.x) return false;\n\t\treturn true;\n\t}\n\tintersectsRay(ray, point) {\n\t\tif (point) {\n\t\t\treturn this._intersectsRay(ray, point);\n\t\t}\n\t\treturn this._fastIntersectsRay(ray);\n\t}\n\tsetMinMax(min, max) {\n\t\tthis.center.add2(max, min).mulScalar(0.5);\n\t\tthis.halfExtents.sub2(max, min).mulScalar(0.5);\n\t}\n\tgetMin() {\n\t\treturn this._min.copy(this.center).sub(this.halfExtents);\n\t}\n\tgetMax() {\n\t\treturn this._max.copy(this.center).add(this.halfExtents);\n\t}\n\tcontainsPoint(point) {\n\t\tconst min = this.getMin();\n\t\tconst max = this.getMax();\n\t\tif (point.x < min.x || point.x > max.x || point.y < min.y || point.y > max.y || point.z < min.z || point.z > max.z) {\n\t\t\treturn false;\n\t\t}\n\t\treturn true;\n\t}\n\tsetFromTransformedAabb(aabb, m, ignoreScale = false) {\n\t\tconst ac = aabb.center;\n\t\tconst ar = aabb.halfExtents;\n\t\tconst d = m.data;\n\t\tlet mx0 = d[0];\n\t\tlet mx1 = d[4];\n\t\tlet mx2 = d[8];\n\t\tlet my0 = d[1];\n\t\tlet my1 = d[5];\n\t\tlet my2 = d[9];\n\t\tlet mz0 = d[2];\n\t\tlet mz1 = d[6];\n\t\tlet mz2 = d[10];\n\t\tif (ignoreScale) {\n\t\t\tlet lengthSq = mx0 * mx0 + mx1 * mx1 + mx2 * mx2;\n\t\t\tif (lengthSq > 0) {\n\t\t\t\tconst invLength = 1 / Math.sqrt(lengthSq);\n\t\t\t\tmx0 *= invLength;\n\t\t\t\tmx1 *= invLength;\n\t\t\t\tmx2 *= invLength;\n\t\t\t}\n\t\t\tlengthSq = my0 * my0 + my1 * my1 + my2 * my2;\n\t\t\tif (lengthSq > 0) {\n\t\t\t\tconst invLength = 1 / Math.sqrt(lengthSq);\n\t\t\t\tmy0 *= invLength;\n\t\t\t\tmy1 *= invLength;\n\t\t\t\tmy2 *= invLength;\n\t\t\t}\n\t\t\tlengthSq = mz0 * mz0 + mz1 * mz1 + mz2 * mz2;\n\t\t\tif (lengthSq > 0) {\n\t\t\t\tconst invLength = 1 / Math.sqrt(lengthSq);\n\t\t\t\tmz0 *= invLength;\n\t\t\t\tmz1 *= invLength;\n\t\t\t\tmz2 *= invLength;\n\t\t\t}\n\t\t}\n\t\tthis.center.set(d[12] + mx0 * ac.x + mx1 * ac.y + mx2 * ac.z, d[13] + my0 * ac.x + my1 * ac.y + my2 * ac.z, d[14] + mz0 * ac.x + mz1 * ac.y + mz2 * ac.z);\n\t\tthis.halfExtents.set(Math.abs(mx0) * ar.x + Math.abs(mx1) * ar.y + Math.abs(mx2) * ar.z, Math.abs(my0) * ar.x + Math.abs(my1) * ar.y + Math.abs(my2) * ar.z, Math.abs(mz0) * ar.x + Math.abs(mz1) * ar.y + Math.abs(mz2) * ar.z);\n\t}\n\tstatic computeMinMax(vertices, min, max, numVerts = vertices.length / 3) {\n\t\tif (numVerts > 0) {\n\t\t\tlet minx = vertices[0];\n\t\t\tlet miny = vertices[1];\n\t\t\tlet minz = vertices[2];\n\t\t\tlet maxx = minx;\n\t\t\tlet maxy = miny;\n\t\t\tlet maxz = minz;\n\t\t\tconst n = numVerts * 3;\n\t\t\tfor (let i = 3; i < n; i += 3) {\n\t\t\t\tconst x = vertices[i];\n\t\t\t\tconst y = vertices[i + 1];\n\t\t\t\tconst z = vertices[i + 2];\n\t\t\t\tif (x < minx) minx = x;\n\t\t\t\tif (y < miny) miny = y;\n\t\t\t\tif (z < minz) minz = z;\n\t\t\t\tif (x > maxx) maxx = x;\n\t\t\t\tif (y > maxy) maxy = y;\n\t\t\t\tif (z > maxz) maxz = z;\n\t\t\t}\n\t\t\tmin.set(minx, miny, minz);\n\t\t\tmax.set(maxx, maxy, maxz);\n\t\t}\n\t}\n\tcompute(vertices, numVerts) {\n\t\tBoundingBox.computeMinMax(vertices, tmpVecA, tmpVecB, numVerts);\n\t\tthis.setMinMax(tmpVecA, tmpVecB);\n\t}\n\tintersectsBoundingSphere(sphere) {\n\t\tconst sq = this._distanceToBoundingSphereSq(sphere);\n\t\tif (sq <= sphere.radius * sphere.radius) {\n\t\t\treturn true;\n\t\t}\n\t\treturn false;\n\t}\n\t_distanceToBoundingSphereSq(sphere) {\n\t\tconst boxMin = this.getMin();\n\t\tconst boxMax = this.getMax();\n\t\tlet sq = 0;\n\t\tconst axis = ['x', 'y', 'z'];\n\t\tfor (let i = 0; i < 3; ++i) {\n\t\t\tlet out = 0;\n\t\t\tconst pn = sphere.center[axis[i]];\n\t\t\tconst bMin = boxMin[axis[i]];\n\t\t\tconst bMax = boxMax[axis[i]];\n\t\t\tlet val = 0;\n\t\t\tif (pn < bMin) {\n\t\t\t\tval = bMin - pn;\n\t\t\t\tout += val * val;\n\t\t\t}\n\t\t\tif (pn > bMax) {\n\t\t\t\tval = pn - bMax;\n\t\t\t\tout += val * val;\n\t\t\t}\n\t\t\tsq += out;\n\t\t}\n\t\treturn sq;\n\t}\n\t_expand(expandMin, expandMax) {\n\t\ttmpVecA.add2(this.getMin(), expandMin);\n\t\ttmpVecB.add2(this.getMax(), expandMax);\n\t\tthis.setMinMax(tmpVecA, tmpVecB);\n\t}\n}\n\nexport { BoundingBox };\n", "import { Vec3 } from '../math/vec3.js';\n\nconst tmpVecA = new Vec3();\nconst tmpVecB = new Vec3();\nclass BoundingSphere {\n\tconstructor(center = new Vec3(), radius = 0.5) {\n\t\tthis.center = void 0;\n\t\tthis.radius = void 0;\n\t\tthis.center = center;\n\t\tthis.radius = radius;\n\t}\n\tcontainsPoint(point) {\n\t\tconst lenSq = tmpVecA.sub2(point, this.center).lengthSq();\n\t\tconst r = this.radius;\n\t\treturn lenSq < r * r;\n\t}\n\tintersectsRay(ray, point) {\n\t\tconst m = tmpVecA.copy(ray.origin).sub(this.center);\n\t\tconst b = m.dot(tmpVecB.copy(ray.direction).normalize());\n\t\tconst c = m.dot(m) - this.radius * this.radius;\n\t\tif (c > 0 && b > 0) return false;\n\t\tconst discr = b * b - c;\n\t\tif (discr < 0) return false;\n\t\tconst t = Math.abs(-b - Math.sqrt(discr));\n\t\tif (point) point.copy(ray.direction).mulScalar(t).add(ray.origin);\n\t\treturn true;\n\t}\n\tintersectsBoundingSphere(sphere) {\n\t\ttmpVecA.sub2(sphere.center, this.center);\n\t\tconst totalRadius = sphere.radius + this.radius;\n\t\tif (tmpVecA.lengthSq() <= totalRadius * totalRadius) {\n\t\t\treturn true;\n\t\t}\n\t\treturn false;\n\t}\n}\n\nexport { BoundingSphere };\n", "class Frustum {\n\tconstructor() {\n\t\tthis.planes = [];\n\t\tfor (let i = 0; i < 6; i++) this.planes[i] = [];\n\t}\n\tsetFromMat4(matrix) {\n\t\tconst vpm = matrix.data;\n\t\tlet plane;\n\t\tconst planes = this.planes;\n\t\tplane = planes[0];\n\t\tplane[0] = vpm[3] - vpm[0];\n\t\tplane[1] = vpm[7] - vpm[4];\n\t\tplane[2] = vpm[11] - vpm[8];\n\t\tplane[3] = vpm[15] - vpm[12];\n\t\tlet t = Math.sqrt(plane[0] * plane[0] + plane[1] * plane[1] + plane[2] * plane[2]);\n\t\tplane[0] /= t;\n\t\tplane[1] /= t;\n\t\tplane[2] /= t;\n\t\tplane[3] /= t;\n\t\tplane = planes[1];\n\t\tplane[0] = vpm[3] + vpm[0];\n\t\tplane[1] = vpm[7] + vpm[4];\n\t\tplane[2] = vpm[11] + vpm[8];\n\t\tplane[3] = vpm[15] + vpm[12];\n\t\tt = Math.sqrt(plane[0] * plane[0] + plane[1] * plane[1] + plane[2] * plane[2]);\n\t\tplane[0] /= t;\n\t\tplane[1] /= t;\n\t\tplane[2] /= t;\n\t\tplane[3] /= t;\n\t\tplane = planes[2];\n\t\tplane[0] = vpm[3] + vpm[1];\n\t\tplane[1] = vpm[7] + vpm[5];\n\t\tplane[2] = vpm[11] + vpm[9];\n\t\tplane[3] = vpm[15] + vpm[13];\n\t\tt = Math.sqrt(plane[0] * plane[0] + plane[1] * plane[1] + plane[2] * plane[2]);\n\t\tplane[0] /= t;\n\t\tplane[1] /= t;\n\t\tplane[2] /= t;\n\t\tplane[3] /= t;\n\t\tplane = planes[3];\n\t\tplane[0] = vpm[3] - vpm[1];\n\t\tplane[1] = vpm[7] - vpm[5];\n\t\tplane[2] = vpm[11] - vpm[9];\n\t\tplane[3] = vpm[15] - vpm[13];\n\t\tt = Math.sqrt(plane[0] * plane[0] + plane[1] * plane[1] + plane[2] * plane[2]);\n\t\tplane[0] /= t;\n\t\tplane[1] /= t;\n\t\tplane[2] /= t;\n\t\tplane[3] /= t;\n\t\tplane = planes[4];\n\t\tplane[0] = vpm[3] - vpm[2];\n\t\tplane[1] = vpm[7] - vpm[6];\n\t\tplane[2] = vpm[11] - vpm[10];\n\t\tplane[3] = vpm[15] - vpm[14];\n\t\tt = Math.sqrt(plane[0] * plane[0] + plane[1] * plane[1] + plane[2] * plane[2]);\n\t\tplane[0] /= t;\n\t\tplane[1] /= t;\n\t\tplane[2] /= t;\n\t\tplane[3] /= t;\n\t\tplane = planes[5];\n\t\tplane[0] = vpm[3] + vpm[2];\n\t\tplane[1] = vpm[7] + vpm[6];\n\t\tplane[2] = vpm[11] + vpm[10];\n\t\tplane[3] = vpm[15] + vpm[14];\n\t\tt = Math.sqrt(plane[0] * plane[0] + plane[1] * plane[1] + plane[2] * plane[2]);\n\t\tplane[0] /= t;\n\t\tplane[1] /= t;\n\t\tplane[2] /= t;\n\t\tplane[3] /= t;\n\t}\n\tcontainsPoint(point) {\n\t\tlet p, plane;\n\t\tfor (p = 0; p < 6; p++) {\n\t\t\tplane = this.planes[p];\n\t\t\tif (plane[0] * point.x + plane[1] * point.y + plane[2] * point.z + plane[3] <= 0) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\t\treturn true;\n\t}\n\tcontainsSphere(sphere) {\n\t\tlet c = 0;\n\t\tlet d;\n\t\tlet p;\n\t\tconst sr = sphere.radius;\n\t\tconst sc = sphere.center;\n\t\tconst scx = sc.x;\n\t\tconst scy = sc.y;\n\t\tconst scz = sc.z;\n\t\tconst planes = this.planes;\n\t\tlet plane;\n\t\tfor (p = 0; p < 6; p++) {\n\t\t\tplane = planes[p];\n\t\t\td = plane[0] * scx + plane[1] * scy + plane[2] * scz + plane[3];\n\t\t\tif (d <= -sr) return 0;\n\t\t\tif (d > sr) c++;\n\t\t}\n\t\treturn c === 6 ? 2 : 1;\n\t}\n}\n\nexport { Frustum };\n", "import { Vec3 } from '../math/vec3.js';\n\nclass Ray {\n\tconstructor(origin, direction) {\n\t\tthis.origin = new Vec3();\n\t\tthis.direction = Vec3.FORWARD.clone();\n\t\tif (origin) {\n\t\t\tthis.origin.copy(origin);\n\t\t}\n\t\tif (direction) {\n\t\t\tthis.direction.copy(direction);\n\t\t}\n\t}\n\tset(origin, direction) {\n\t\tthis.origin.copy(origin);\n\t\tthis.direction.copy(direction);\n\t\treturn this;\n\t}\n\tcopy(src) {\n\t\treturn this.set(src.origin, src.direction);\n\t}\n\tclone() {\n\t\treturn new this.constructor(this.origin, this.direction);\n\t}\n}\n\nexport { Ray };\n", "const DISTANCE_LINEAR = 'linear';\nconst DISTANCE_INVERSE = 'inverse';\nconst DISTANCE_EXPONENTIAL = 'exponential';\n\nexport { DISTANCE_EXPONENTIAL, DISTANCE_INVERSE, DISTANCE_LINEAR };\n", "const ADDRESS_REPEAT = 0;\nconst ADDRESS_CLAMP_TO_EDGE = 1;\nconst ADDRESS_MIRRORED_REPEAT = 2;\nconst BLENDMODE_ZERO = 0;\nconst BLENDMODE_ONE = 1;\nconst BLENDMODE_SRC_COLOR = 2;\nconst BLENDMODE_ONE_MINUS_SRC_COLOR = 3;\nconst BLENDMODE_DST_COLOR = 4;\nconst BLENDMODE_ONE_MINUS_DST_COLOR = 5;\nconst BLENDMODE_SRC_ALPHA = 6;\nconst BLENDMODE_SRC_ALPHA_SATURATE = 7;\nconst BLENDMODE_ONE_MINUS_SRC_ALPHA = 8;\nconst BLENDMODE_DST_ALPHA = 9;\nconst BLENDMODE_ONE_MINUS_DST_ALPHA = 10;\nconst BLENDMODE_CONSTANT = 11;\nconst BLENDMODE_ONE_MINUS_CONSTANT = 12;\nconst BLENDEQUATION_ADD = 0;\nconst BLENDEQUATION_SUBTRACT = 1;\nconst BLENDEQUATION_REVERSE_SUBTRACT = 2;\nconst BLENDEQUATION_MIN = 3;\nconst BLENDEQUATION_MAX = 4;\nconst BUFFERUSAGE_READ = 0x0001;\nconst BUFFERUSAGE_WRITE = 0x0002;\nconst BUFFERUSAGE_COPY_SRC = 0x0004;\nconst BUFFERUSAGE_COPY_DST = 0x0008;\nconst BUFFERUSAGE_INDEX = 0x0010;\nconst BUFFERUSAGE_VERTEX = 0x0020;\nconst BUFFERUSAGE_UNIFORM = 0x0040;\nconst BUFFERUSAGE_STORAGE = 0x0080;\nconst BUFFERUSAGE_INDIRECT = 0x0100;\nconst BUFFER_STATIC = 0;\nconst BUFFER_DYNAMIC = 1;\nconst BUFFER_STREAM = 2;\nconst BUFFER_GPUDYNAMIC = 3;\nconst CLEARFLAG_COLOR = 1;\nconst CLEARFLAG_DEPTH = 2;\nconst CLEARFLAG_STENCIL = 4;\nconst CUBEFACE_POSX = 0;\nconst CUBEFACE_NEGX = 1;\nconst CUBEFACE_POSY = 2;\nconst CUBEFACE_NEGY = 3;\nconst CUBEFACE_POSZ = 4;\nconst CUBEFACE_NEGZ = 5;\nconst CULLFACE_NONE = 0;\nconst CULLFACE_BACK = 1;\nconst CULLFACE_FRONT = 2;\nconst CULLFACE_FRONTANDBACK = 3;\nconst FILTER_NEAREST = 0;\nconst FILTER_LINEAR = 1;\nconst FILTER_NEAREST_MIPMAP_NEAREST = 2;\nconst FILTER_NEAREST_MIPMAP_LINEAR = 3;\nconst FILTER_LINEAR_MIPMAP_NEAREST = 4;\nconst FILTER_LINEAR_MIPMAP_LINEAR = 5;\nconst FUNC_NEVER = 0;\nconst FUNC_LESS = 1;\nconst FUNC_EQUAL = 2;\nconst FUNC_LESSEQUAL = 3;\nconst FUNC_GREATER = 4;\nconst FUNC_NOTEQUAL = 5;\nconst FUNC_GREATEREQUAL = 6;\nconst FUNC_ALWAYS = 7;\nconst INDEXFORMAT_UINT8 = 0;\nconst INDEXFORMAT_UINT16 = 1;\nconst INDEXFORMAT_UINT32 = 2;\nconst PIXELFORMAT_A8 = 0;\nconst PIXELFORMAT_L8 = 1;\nconst PIXELFORMAT_LA8 = 2;\nconst PIXELFORMAT_RGB565 = 3;\nconst PIXELFORMAT_RGBA5551 = 4;\nconst PIXELFORMAT_RGBA4 = 5;\nconst PIXELFORMAT_RGB8 = 6;\nconst PIXELFORMAT_RGBA8 = 7;\nconst PIXELFORMAT_DXT1 = 8;\nconst PIXELFORMAT_DXT3 = 9;\nconst PIXELFORMAT_DXT5 = 10;\nconst PIXELFORMAT_RGB16F = 11;\nconst PIXELFORMAT_RGBA16F = 12;\nconst PIXELFORMAT_RGB32F = 13;\nconst PIXELFORMAT_RGBA32F = 14;\nconst PIXELFORMAT_R32F = 15;\nconst PIXELFORMAT_DEPTH = 16;\nconst PIXELFORMAT_DEPTHSTENCIL = 17;\nconst PIXELFORMAT_111110F = 18;\nconst PIXELFORMAT_SRGB = 19;\nconst PIXELFORMAT_SRGBA = 20;\nconst PIXELFORMAT_ETC1 = 21;\nconst PIXELFORMAT_ETC2_RGB = 22;\nconst PIXELFORMAT_ETC2_RGBA = 23;\nconst PIXELFORMAT_PVRTC_2BPP_RGB_1 = 24;\nconst PIXELFORMAT_PVRTC_2BPP_RGBA_1 = 25;\nconst PIXELFORMAT_PVRTC_4BPP_RGB_1 = 26;\nconst PIXELFORMAT_PVRTC_4BPP_RGBA_1 = 27;\nconst PIXELFORMAT_ASTC_4x4 = 28;\nconst PIXELFORMAT_ATC_RGB = 29;\nconst PIXELFORMAT_ATC_RGBA = 30;\nconst PIXELFORMAT_BGRA8 = 31;\nconst PIXELFORMAT_R8I = 32;\nconst PIXELFORMAT_R8U = 33;\nconst PIXELFORMAT_R16I = 34;\nconst PIXELFORMAT_R16U = 35;\nconst PIXELFORMAT_R32I = 36;\nconst PIXELFORMAT_R32U = 37;\nconst PIXELFORMAT_RG8I = 38;\nconst PIXELFORMAT_RG8U = 39;\nconst PIXELFORMAT_RG16I = 40;\nconst PIXELFORMAT_RG16U = 41;\nconst PIXELFORMAT_RG32I = 42;\nconst PIXELFORMAT_RG32U = 43;\nconst PIXELFORMAT_RGBA8I = 44;\nconst PIXELFORMAT_RGBA8U = 45;\nconst PIXELFORMAT_RGBA16I = 46;\nconst PIXELFORMAT_RGBA16U = 47;\nconst PIXELFORMAT_RGBA32I = 48;\nconst PIXELFORMAT_RGBA32U = 49;\nconst PIXELFORMAT_R16F = 50;\nconst PIXELFORMAT_RG16F = 51;\nconst pixelFormatInfo = new Map([[PIXELFORMAT_A8, {\n\tname: 'A8',\n\tsize: 1\n}], [PIXELFORMAT_L8, {\n\tname: 'L8',\n\tsize: 1\n}], [PIXELFORMAT_LA8, {\n\tname: 'LA8',\n\tsize: 2\n}], [PIXELFORMAT_RGB565, {\n\tname: 'RGB565',\n\tsize: 2\n}], [PIXELFORMAT_RGBA5551, {\n\tname: 'RGBA5551',\n\tsize: 2\n}], [PIXELFORMAT_RGBA4, {\n\tname: 'RGBA4',\n\tsize: 2\n}], [PIXELFORMAT_RGB8, {\n\tname: 'RGB8',\n\tsize: 4\n}], [PIXELFORMAT_RGBA8, {\n\tname: 'RGBA8',\n\tsize: 4\n}], [PIXELFORMAT_R16F, {\n\tname: 'R16F',\n\tsize: 2\n}], [PIXELFORMAT_RG16F, {\n\tname: 'RG16F',\n\tsize: 4\n}], [PIXELFORMAT_RGB16F, {\n\tname: 'RGB16F',\n\tsize: 8\n}], [PIXELFORMAT_RGBA16F, {\n\tname: 'RGBA16F',\n\tsize: 8\n}], [PIXELFORMAT_RGB32F, {\n\tname: 'RGB32F',\n\tsize: 16\n}], [PIXELFORMAT_RGBA32F, {\n\tname: 'RGBA32F',\n\tsize: 16\n}], [PIXELFORMAT_R32F, {\n\tname: 'R32F',\n\tsize: 4\n}], [PIXELFORMAT_DEPTH, {\n\tname: 'DEPTH',\n\tsize: 4\n}], [PIXELFORMAT_DEPTHSTENCIL, {\n\tname: 'DEPTHSTENCIL',\n\tsize: 4\n}], [PIXELFORMAT_111110F, {\n\tname: '111110F',\n\tsize: 4\n}], [PIXELFORMAT_SRGB, {\n\tname: 'SRGB',\n\tsize: 4\n}], [PIXELFORMAT_SRGBA, {\n\tname: 'SRGBA',\n\tsize: 4\n}], [PIXELFORMAT_BGRA8, {\n\tname: 'BGRA8',\n\tsize: 4\n}], [PIXELFORMAT_DXT1, {\n\tname: 'DXT1',\n\tblockSize: 8\n}], [PIXELFORMAT_DXT3, {\n\tname: 'DXT3',\n\tblockSize: 16\n}], [PIXELFORMAT_DXT5, {\n\tname: 'DXT5',\n\tblockSize: 16\n}], [PIXELFORMAT_ETC1, {\n\tname: 'ETC1',\n\tblockSize: 8\n}], [PIXELFORMAT_ETC2_RGB, {\n\tname: 'ETC2_RGB',\n\tblockSize: 8\n}], [PIXELFORMAT_ETC2_RGBA, {\n\tname: 'ETC2_RGBA',\n\tblockSize: 16\n}], [PIXELFORMAT_PVRTC_2BPP_RGB_1, {\n\tname: 'PVRTC_2BPP_RGB_1',\n\tblockSize: 8\n}], [PIXELFORMAT_PVRTC_2BPP_RGBA_1, {\n\tname: 'PVRTC_2BPP_RGBA_1',\n\tblockSize: 8\n}], [PIXELFORMAT_PVRTC_4BPP_RGB_1, {\n\tname: 'PVRTC_4BPP_RGB_1',\n\tblockSize: 8\n}], [PIXELFORMAT_PVRTC_4BPP_RGBA_1, {\n\tname: 'PVRTC_4BPP_RGBA_1',\n\tblockSize: 8\n}], [PIXELFORMAT_ASTC_4x4, {\n\tname: 'ASTC_4x4',\n\tblockSize: 16\n}], [PIXELFORMAT_ATC_RGB, {\n\tname: 'ATC_RGB',\n\tblockSize: 8\n}], [PIXELFORMAT_ATC_RGBA, {\n\tname: 'ATC_RGBA',\n\tblockSize: 16\n}], [PIXELFORMAT_R8I, {\n\tname: 'R8I',\n\tsize: 1,\n\tisInt: true\n}], [PIXELFORMAT_R8U, {\n\tname: 'R8U',\n\tsize: 1,\n\tisInt: true\n}], [PIXELFORMAT_R16I, {\n\tname: 'R16I',\n\tsize: 2,\n\tisInt: true\n}], [PIXELFORMAT_R16U, {\n\tname: 'R16U',\n\tsize: 2,\n\tisInt: true\n}], [PIXELFORMAT_R32I, {\n\tname: 'R32I',\n\tsize: 4,\n\tisInt: true\n}], [PIXELFORMAT_R32U, {\n\tname: 'R32U',\n\tsize: 4,\n\tisInt: true\n}], [PIXELFORMAT_RG8I, {\n\tname: 'RG8I',\n\tsize: 2,\n\tisInt: true\n}], [PIXELFORMAT_RG8U, {\n\tname: 'RG8U',\n\tsize: 2,\n\tisInt: true\n}], [PIXELFORMAT_RG16I, {\n\tname: 'RG16I',\n\tsize: 4,\n\tisInt: true\n}], [PIXELFORMAT_RG16U, {\n\tname: 'RG16U',\n\tsize: 4,\n\tisInt: true\n}], [PIXELFORMAT_RG32I, {\n\tname: 'RG32I',\n\tsize: 8,\n\tisInt: true\n}], [PIXELFORMAT_RG32U, {\n\tname: 'RG32U',\n\tsize: 8,\n\tisInt: true\n}], [PIXELFORMAT_RGBA8I, {\n\tname: 'RGBA8I',\n\tsize: 4,\n\tisInt: true\n}], [PIXELFORMAT_RGBA8U, {\n\tname: 'RGBA8U',\n\tsize: 4,\n\tisInt: true\n}], [PIXELFORMAT_RGBA16I, {\n\tname: 'RGBA16I',\n\tsize: 8,\n\tisInt: true\n}], [PIXELFORMAT_RGBA16U, {\n\tname: 'RGBA16U',\n\tsize: 8,\n\tisInt: true\n}], [PIXELFORMAT_RGBA32I, {\n\tname: 'RGBA32I',\n\tsize: 16,\n\tisInt: true\n}], [PIXELFORMAT_RGBA32U, {\n\tname: 'RGBA32U',\n\tsize: 16,\n\tisInt: true\n}]]);\nconst isCompressedPixelFormat = format => {\n\tvar _pixelFormatInfo$get;\n\treturn ((_pixelFormatInfo$get = pixelFormatInfo.get(format)) == null ? void 0 : _pixelFormatInfo$get.blockSize) !== undefined;\n};\nconst isIntegerPixelFormat = format => {\n\tvar _pixelFormatInfo$get2;\n\treturn ((_pixelFormatInfo$get2 = pixelFormatInfo.get(format)) == null ? void 0 : _pixelFormatInfo$get2.isInt) === true;\n};\nconst getPixelFormatArrayType = format => {\n\tswitch (format) {\n\t\tcase PIXELFORMAT_R32F:\n\t\tcase PIXELFORMAT_RGB32F:\n\t\tcase PIXELFORMAT_RGBA32F:\n\t\t\treturn Float32Array;\n\t\tcase PIXELFORMAT_R32I:\n\t\tcase PIXELFORMAT_RG32I:\n\t\tcase PIXELFORMAT_RGBA32I:\n\t\t\treturn Int32Array;\n\t\tcase PIXELFORMAT_R32U:\n\t\tcase PIXELFORMAT_RG32U:\n\t\tcase PIXELFORMAT_RGBA32U:\n\t\t\treturn Uint32Array;\n\t\tcase PIXELFORMAT_R16I:\n\t\tcase PIXELFORMAT_RG16I:\n\t\tcase PIXELFORMAT_RGBA16I:\n\t\t\treturn Int16Array;\n\t\tcase PIXELFORMAT_R16U:\n\t\tcase PIXELFORMAT_RG16U:\n\t\tcase PIXELFORMAT_RGBA16U:\n\t\tcase PIXELFORMAT_RGB565:\n\t\tcase PIXELFORMAT_RGBA5551:\n\t\tcase PIXELFORMAT_RGBA4:\n\t\tcase PIXELFORMAT_R16F:\n\t\tcase PIXELFORMAT_RG16F:\n\t\tcase PIXELFORMAT_RGB16F:\n\t\tcase PIXELFORMAT_RGBA16F:\n\t\t\treturn Uint16Array;\n\t\tcase PIXELFORMAT_R8I:\n\t\tcase PIXELFORMAT_RG8I:\n\t\tcase PIXELFORMAT_RGBA8I:\n\t\t\treturn Int8Array;\n\t\tdefault:\n\t\t\treturn Uint8Array;\n\t}\n};\nconst PRIMITIVE_POINTS = 0;\nconst PRIMITIVE_LINES = 1;\nconst PRIMITIVE_LINELOOP = 2;\nconst PRIMITIVE_LINESTRIP = 3;\nconst PRIMITIVE_TRIANGLES = 4;\nconst PRIMITIVE_TRISTRIP = 5;\nconst PRIMITIVE_TRIFAN = 6;\nconst SEMANTIC_POSITION = \"POSITION\";\nconst SEMANTIC_NORMAL = \"NORMAL\";\nconst SEMANTIC_TANGENT = \"TANGENT\";\nconst SEMANTIC_BLENDWEIGHT = \"BLENDWEIGHT\";\nconst SEMANTIC_BLENDINDICES = \"BLENDINDICES\";\nconst SEMANTIC_COLOR = \"COLOR\";\nconst SEMANTIC_TEXCOORD = \"TEXCOORD\";\nconst SEMANTIC_TEXCOORD0 = \"TEXCOORD0\";\nconst SEMANTIC_TEXCOORD1 = \"TEXCOORD1\";\nconst SEMANTIC_TEXCOORD2 = \"TEXCOORD2\";\nconst SEMANTIC_TEXCOORD3 = \"TEXCOORD3\";\nconst SEMANTIC_TEXCOORD4 = \"TEXCOORD4\";\nconst SEMANTIC_TEXCOORD5 = \"TEXCOORD5\";\nconst SEMANTIC_TEXCOORD6 = \"TEXCOORD6\";\nconst SEMANTIC_TEXCOORD7 = \"TEXCOORD7\";\nconst SEMANTIC_ATTR = \"ATTR\";\nconst SEMANTIC_ATTR0 = \"ATTR0\";\nconst SEMANTIC_ATTR1 = \"ATTR1\";\nconst SEMANTIC_ATTR2 = \"ATTR2\";\nconst SEMANTIC_ATTR3 = \"ATTR3\";\nconst SEMANTIC_ATTR4 = \"ATTR4\";\nconst SEMANTIC_ATTR5 = \"ATTR5\";\nconst SEMANTIC_ATTR6 = \"ATTR6\";\nconst SEMANTIC_ATTR7 = \"ATTR7\";\nconst SEMANTIC_ATTR8 = \"ATTR8\";\nconst SEMANTIC_ATTR9 = \"ATTR9\";\nconst SEMANTIC_ATTR10 = \"ATTR10\";\nconst SEMANTIC_ATTR11 = \"ATTR11\";\nconst SEMANTIC_ATTR12 = \"ATTR12\";\nconst SEMANTIC_ATTR13 = \"ATTR13\";\nconst SEMANTIC_ATTR14 = \"ATTR14\";\nconst SEMANTIC_ATTR15 = \"ATTR15\";\nconst SHADERTAG_MATERIAL = 1;\nconst STENCILOP_KEEP = 0;\nconst STENCILOP_ZERO = 1;\nconst STENCILOP_REPLACE = 2;\nconst STENCILOP_INCREMENT = 3;\nconst STENCILOP_INCREMENTWRAP = 4;\nconst STENCILOP_DECREMENT = 5;\nconst STENCILOP_DECREMENTWRAP = 6;\nconst STENCILOP_INVERT = 7;\nconst TEXTURELOCK_NONE = 0;\nconst TEXTURELOCK_READ = 1;\nconst TEXTURELOCK_WRITE = 2;\nconst TEXTURETYPE_DEFAULT = 'default';\nconst TEXTURETYPE_RGBM = 'rgbm';\nconst TEXTURETYPE_RGBE = 'rgbe';\nconst TEXTURETYPE_RGBP = 'rgbp';\nconst TEXTURETYPE_SWIZZLEGGGR = 'swizzleGGGR';\nconst TEXHINT_NONE = 0;\nconst TEXHINT_SHADOWMAP = 1;\nconst TEXHINT_ASSET = 2;\nconst TEXHINT_LIGHTMAP = 3;\nconst TEXTUREDIMENSION_1D = '1d';\nconst TEXTUREDIMENSION_2D = '2d';\nconst TEXTUREDIMENSION_2D_ARRAY = '2d-array';\nconst TEXTUREDIMENSION_CUBE = 'cube';\nconst TEXTUREDIMENSION_CUBE_ARRAY = 'cube-array';\nconst TEXTUREDIMENSION_3D = '3d';\nconst SAMPLETYPE_FLOAT = 0;\nconst SAMPLETYPE_UNFILTERABLE_FLOAT = 1;\nconst SAMPLETYPE_DEPTH = 2;\nconst SAMPLETYPE_INT = 3;\nconst SAMPLETYPE_UINT = 4;\nconst TEXTUREPROJECTION_NONE = \"none\";\nconst TEXTUREPROJECTION_CUBE = \"cube\";\nconst TEXTUREPROJECTION_EQUIRECT = \"equirect\";\nconst TEXTUREPROJECTION_OCTAHEDRAL = \"octahedral\";\nconst SHADERLANGUAGE_GLSL = 'glsl';\nconst SHADERLANGUAGE_WGSL = 'wgsl';\nconst TYPE_INT8 = 0;\nconst TYPE_UINT8 = 1;\nconst TYPE_INT16 = 2;\nconst TYPE_UINT16 = 3;\nconst TYPE_INT32 = 4;\nconst TYPE_UINT32 = 5;\nconst TYPE_FLOAT32 = 6;\nconst TYPE_FLOAT16 = 7;\nconst UNIFORMTYPE_BOOL = 0;\nconst UNIFORMTYPE_INT = 1;\nconst UNIFORMTYPE_FLOAT = 2;\nconst UNIFORMTYPE_VEC2 = 3;\nconst UNIFORMTYPE_VEC3 = 4;\nconst UNIFORMTYPE_VEC4 = 5;\nconst UNIFORMTYPE_IVEC2 = 6;\nconst UNIFORMTYPE_IVEC3 = 7;\nconst UNIFORMTYPE_IVEC4 = 8;\nconst UNIFORMTYPE_BVEC2 = 9;\nconst UNIFORMTYPE_BVEC3 = 10;\nconst UNIFORMTYPE_BVEC4 = 11;\nconst UNIFORMTYPE_MAT2 = 12;\nconst UNIFORMTYPE_MAT3 = 13;\nconst UNIFORMTYPE_MAT4 = 14;\nconst UNIFORMTYPE_TEXTURE2D = 15;\nconst UNIFORMTYPE_TEXTURECUBE = 16;\nconst UNIFORMTYPE_FLOATARRAY = 17;\nconst UNIFORMTYPE_TEXTURE2D_SHADOW = 18;\nconst UNIFORMTYPE_TEXTURECUBE_SHADOW = 19;\nconst UNIFORMTYPE_TEXTURE3D = 20;\nconst UNIFORMTYPE_VEC2ARRAY = 21;\nconst UNIFORMTYPE_VEC3ARRAY = 22;\nconst UNIFORMTYPE_VEC4ARRAY = 23;\nconst UNIFORMTYPE_MAT4ARRAY = 24;\nconst UNIFORMTYPE_TEXTURE2D_ARRAY = 25;\nconst UNIFORMTYPE_UINT = 26;\nconst UNIFORMTYPE_UVEC2 = 27;\nconst UNIFORMTYPE_UVEC3 = 28;\nconst UNIFORMTYPE_UVEC4 = 29;\nconst UNIFORMTYPE_INTARRAY = 30;\nconst UNIFORMTYPE_UINTARRAY = 31;\nconst UNIFORMTYPE_BOOLARRAY = 32;\nconst UNIFORMTYPE_IVEC2ARRAY = 33;\nconst UNIFORMTYPE_UVEC2ARRAY = 34;\nconst UNIFORMTYPE_BVEC2ARRAY = 35;\nconst UNIFORMTYPE_IVEC3ARRAY = 36;\nconst UNIFORMTYPE_UVEC3ARRAY = 37;\nconst UNIFORMTYPE_BVEC3ARRAY = 38;\nconst UNIFORMTYPE_IVEC4ARRAY = 39;\nconst UNIFORMTYPE_UVEC4ARRAY = 40;\nconst UNIFORMTYPE_BVEC4ARRAY = 41;\nconst UNIFORMTYPE_ITEXTURE2D = 42;\nconst UNIFORMTYPE_UTEXTURE2D = 43;\nconst UNIFORMTYPE_ITEXTURECUBE = 44;\nconst UNIFORMTYPE_UTEXTURECUBE = 45;\nconst UNIFORMTYPE_ITEXTURE3D = 46;\nconst UNIFORMTYPE_UTEXTURE3D = 47;\nconst UNIFORMTYPE_ITEXTURE2D_ARRAY = 48;\nconst UNIFORMTYPE_UTEXTURE2D_ARRAY = 49;\nconst uniformTypeToName = ['bool', 'int', 'float', 'vec2', 'vec3', 'vec4', 'ivec2', 'ivec3', 'ivec4', 'bvec2', 'bvec3', 'bvec4', 'mat2', 'mat3', 'mat4', 'sampler2D', 'samplerCube', '', 'sampler2DShadow', 'samplerCubeShadow', 'sampler3D', '', '', '', '', 'sampler2DArray', 'uint', 'uvec2', 'uvec3', 'uvec4', '', '', '', '', '', '', '', '', '', '', '', '', 'isampler2D', 'usampler2D', 'isamplerCube', 'usamplerCube', 'isampler3D', 'usampler3D', 'isampler2DArray', 'usampler2DArray'];\nconst uniformTypeToStorage = new Uint8Array([TYPE_INT32, TYPE_INT32, TYPE_FLOAT32, TYPE_FLOAT32, TYPE_FLOAT32, TYPE_FLOAT32, TYPE_INT32, TYPE_INT32, TYPE_INT32, TYPE_INT32, TYPE_INT32, TYPE_INT32, TYPE_FLOAT32, TYPE_FLOAT32, TYPE_FLOAT32, TYPE_INT32, TYPE_INT32, TYPE_FLOAT32, TYPE_INT32, TYPE_INT32, TYPE_INT32, TYPE_FLOAT32, TYPE_FLOAT32, TYPE_FLOAT32, TYPE_FLOAT32, TYPE_INT32, TYPE_UINT32, TYPE_UINT32, TYPE_UINT32, TYPE_UINT32, TYPE_INT32, TYPE_UINT32, TYPE_INT32, TYPE_INT32, TYPE_UINT32, TYPE_INT32, TYPE_INT32, TYPE_UINT32, TYPE_INT32, TYPE_INT32, TYPE_UINT32, TYPE_INT32, TYPE_INT32, TYPE_UINT32, TYPE_INT32, TYPE_UINT32, TYPE_INT32, TYPE_UINT32, TYPE_INT32, TYPE_UINT32]);\nconst DEVICETYPE_WEBGL1 = 'webgl1';\nconst DEVICETYPE_WEBGL2 = 'webgl2';\nconst DEVICETYPE_WEBGPU = 'webgpu';\nconst DEVICETYPE_NULL = 'null';\nconst SHADERSTAGE_VERTEX = 1;\nconst SHADERSTAGE_FRAGMENT = 2;\nconst SHADERSTAGE_COMPUTE = 4;\nconst BINDGROUP_MESH = 0;\nconst BINDGROUP_VIEW = 1;\nconst bindGroupNames = ['mesh', 'view'];\nconst UNIFORM_BUFFER_DEFAULT_SLOT_NAME = 'default';\nconst typedArrayTypes = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Uint16Array];\nconst typedArrayTypesByteSize = [1, 1, 2, 2, 4, 4, 4, 2];\nconst vertexTypesNames = ['INT8', 'UINT8', 'INT16', 'UINT16', 'INT32', 'UINT32', 'FLOAT32', 'FLOAT16'];\nconst typedArrayToType = {\n\t\"Int8Array\": TYPE_INT8,\n\t\"Uint8Array\": TYPE_UINT8,\n\t\"Int16Array\": TYPE_INT16,\n\t\"Uint16Array\": TYPE_UINT16,\n\t\"Int32Array\": TYPE_INT32,\n\t\"Uint32Array\": TYPE_UINT32,\n\t\"Float32Array\": TYPE_FLOAT32\n};\nconst typedArrayIndexFormats = [Uint8Array, Uint16Array, Uint32Array];\nconst typedArrayIndexFormatsByteSize = [1, 2, 4];\nconst semanticToLocation = {};\nsemanticToLocation[SEMANTIC_POSITION] = 0;\nsemanticToLocation[SEMANTIC_NORMAL] = 1;\nsemanticToLocation[SEMANTIC_BLENDWEIGHT] = 2;\nsemanticToLocation[SEMANTIC_BLENDINDICES] = 3;\nsemanticToLocation[SEMANTIC_COLOR] = 4;\nsemanticToLocation[SEMANTIC_TEXCOORD0] = 5;\nsemanticToLocation[SEMANTIC_TEXCOORD1] = 6;\nsemanticToLocation[SEMANTIC_TEXCOORD2] = 7;\nsemanticToLocation[SEMANTIC_TEXCOORD3] = 8;\nsemanticToLocation[SEMANTIC_TEXCOORD4] = 9;\nsemanticToLocation[SEMANTIC_TEXCOORD5] = 10;\nsemanticToLocation[SEMANTIC_TEXCOORD6] = 11;\nsemanticToLocation[SEMANTIC_TEXCOORD7] = 12;\nsemanticToLocation[SEMANTIC_TANGENT] = 13;\nsemanticToLocation[SEMANTIC_ATTR0] = 0;\nsemanticToLocation[SEMANTIC_ATTR1] = 1;\nsemanticToLocation[SEMANTIC_ATTR2] = 2;\nsemanticToLocation[SEMANTIC_ATTR3] = 3;\nsemanticToLocation[SEMANTIC_ATTR4] = 4;\nsemanticToLocation[SEMANTIC_ATTR5] = 5;\nsemanticToLocation[SEMANTIC_ATTR6] = 6;\nsemanticToLocation[SEMANTIC_ATTR7] = 7;\nsemanticToLocation[SEMANTIC_ATTR8] = 8;\nsemanticToLocation[SEMANTIC_ATTR9] = 9;\nsemanticToLocation[SEMANTIC_ATTR10] = 10;\nsemanticToLocation[SEMANTIC_ATTR11] = 11;\nsemanticToLocation[SEMANTIC_ATTR12] = 12;\nsemanticToLocation[SEMANTIC_ATTR13] = 13;\nsemanticToLocation[SEMANTIC_ATTR14] = 14;\nsemanticToLocation[SEMANTIC_ATTR15] = 15;\nconst CHUNKAPI_1_51 = '1.51';\nconst CHUNKAPI_1_55 = '1.55';\nconst CHUNKAPI_1_56 = '1.56';\nconst CHUNKAPI_1_57 = '1.57';\nconst CHUNKAPI_1_58 = '1.58';\nconst CHUNKAPI_1_60 = '1.60';\nconst CHUNKAPI_1_62 = '1.62';\nconst CHUNKAPI_1_65 = '1.65';\nconst CHUNKAPI_1_70 = '1.70';\n\nexport { ADDRESS_CLAMP_TO_EDGE, ADDRESS_MIRRORED_REPEAT, ADDRESS_REPEAT, BINDGROUP_MESH, BINDGROUP_VIEW, BLENDEQUATION_ADD, BLENDEQUATION_MAX, BLENDEQUATION_MIN, BLENDEQUATION_REVERSE_SUBTRACT, BLENDEQUATION_SUBTRACT, BLENDMODE_CONSTANT, BLENDMODE_DST_ALPHA, BLENDMODE_DST_COLOR, BLENDMODE_ONE, BLENDMODE_ONE_MINUS_CONSTANT, BLENDMODE_ONE_MINUS_DST_ALPHA, BLENDMODE_ONE_MINUS_DST_COLOR, BLENDMODE_ONE_MINUS_SRC_ALPHA, BLENDMODE_ONE_MINUS_SRC_COLOR, BLENDMODE_SRC_ALPHA, BLENDMODE_SRC_ALPHA_SATURATE, BLENDMODE_SRC_COLOR, BLENDMODE_ZERO, BUFFERUSAGE_COPY_DST, BUFFERUSAGE_COPY_SRC, BUFFERUSAGE_INDEX, BUFFERUSAGE_INDIRECT, BUFFERUSAGE_READ, BUFFERUSAGE_STORAGE, BUFFERUSAGE_UNIFORM, BUFFERUSAGE_VERTEX, BUFFERUSAGE_WRITE, BUFFER_DYNAMIC, BUFFER_GPUDYNAMIC, BUFFER_STATIC, BUFFER_STREAM, CHUNKAPI_1_51, CHUNKAPI_1_55, CHUNKAPI_1_56, CHUNKAPI_1_57, CHUNKAPI_1_58, CHUNKAPI_1_60, CHUNKAPI_1_62, CHUNKAPI_1_65, CHUNKAPI_1_70, CLEARFLAG_COLOR, CLEARFLAG_DEPTH, CLEARFLAG_STENCIL, CUBEFACE_NEGX, CUBEFACE_NEGY, CUBEFACE_NEGZ, CUBEFACE_POSX, CUBEFACE_POSY, CUBEFACE_POSZ, CULLFACE_BACK, CULLFACE_FRONT, CULLFACE_FRONTANDBACK, CULLFACE_NONE, DEVICETYPE_NULL, DEVICETYPE_WEBGL1, DEVICETYPE_WEBGL2, DEVICETYPE_WEBGPU, FILTER_LINEAR, FILTER_LINEAR_MIPMAP_LINEAR, FILTER_LINEAR_MIPMAP_NEAREST, FILTER_NEAREST, FILTER_NEAREST_MIPMAP_LINEAR, FILTER_NEAREST_MIPMAP_NEAREST, FUNC_ALWAYS, FUNC_EQUAL, FUNC_GREATER, FUNC_GREATEREQUAL, FUNC_LESS, FUNC_LESSEQUAL, FUNC_NEVER, FUNC_NOTEQUAL, INDEXFORMAT_UINT16, INDEXFORMAT_UINT32, INDEXFORMAT_UINT8, PIXELFORMAT_111110F, PIXELFORMAT_A8, PIXELFORMAT_ASTC_4x4, PIXELFORMAT_ATC_RGB, PIXELFORMAT_ATC_RGBA, PIXELFORMAT_BGRA8, PIXELFORMAT_DEPTH, PIXELFORMAT_DEPTHSTENCIL, PIXELFORMAT_DXT1, PIXELFORMAT_DXT3, PIXELFORMAT_DXT5, PIXELFORMAT_ETC1, PIXELFORMAT_ETC2_RGB, PIXELFORMAT_ETC2_RGBA, PIXELFORMAT_L8, PIXELFORMAT_LA8, PIXELFORMAT_PVRTC_2BPP_RGBA_1, PIXELFORMAT_PVRTC_2BPP_RGB_1, PIXELFORMAT_PVRTC_4BPP_RGBA_1, PIXELFORMAT_PVRTC_4BPP_RGB_1, PIXELFORMAT_R16F, PIXELFORMAT_R16I, PIXELFORMAT_R16U, PIXELFORMAT_R32F, PIXELFORMAT_R32I, PIXELFORMAT_R32U, PIXELFORMAT_R8I, PIXELFORMAT_R8U, PIXELFORMAT_RG16F, PIXELFORMAT_RG16I, PIXELFORMAT_RG16U, PIXELFORMAT_RG32I, PIXELFORMAT_RG32U, PIXELFORMAT_RG8I, PIXELFORMAT_RG8U, PIXELFORMAT_RGB16F, PIXELFORMAT_RGB32F, PIXELFORMAT_RGB565, PIXELFORMAT_RGB8, PIXELFORMAT_RGBA16F, PIXELFORMAT_RGBA16I, PIXELFORMAT_RGBA16U, PIXELFORMAT_RGBA32F, PIXELFORMAT_RGBA32I, PIXELFORMAT_RGBA32U, PIXELFORMAT_RGBA4, PIXELFORMAT_RGBA5551, PIXELFORMAT_RGBA8, PIXELFORMAT_RGBA8I, PIXELFORMAT_RGBA8U, PIXELFORMAT_SRGB, PIXELFORMAT_SRGBA, PRIMITIVE_LINELOOP, PRIMITIVE_LINES, PRIMITIVE_LINESTRIP, PRIMITIVE_POINTS, PRIMITIVE_TRIANGLES, PRIMITIVE_TRIFAN, PRIMITIVE_TRISTRIP, SAMPLETYPE_DEPTH, SAMPLETYPE_FLOAT, SAMPLETYPE_INT, SAMPLETYPE_UINT, SAMPLETYPE_UNFILTERABLE_FLOAT, SEMANTIC_ATTR, SEMANTIC_ATTR0, SEMANTIC_ATTR1, SEMANTIC_ATTR10, SEMANTIC_ATTR11, SEMANTIC_ATTR12, SEMANTIC_ATTR13, SEMANTIC_ATTR14, SEMANTIC_ATTR15, SEMANTIC_ATTR2, SEMANTIC_ATTR3, SEMANTIC_ATTR4, SEMANTIC_ATTR5, SEMANTIC_ATTR6, SEMANTIC_ATTR7, SEMANTIC_ATTR8, SEMANTIC_ATTR9, SEMANTIC_BLENDINDICES, SEMANTIC_BLENDWEIGHT, SEMANTIC_COLOR, SEMANTIC_NORMAL, SEMANTIC_POSITION, SEMANTIC_TANGENT, SEMANTIC_TEXCOORD, SEMANTIC_TEXCOORD0, SEMANTIC_TEXCOORD1, SEMANTIC_TEXCOORD2, SEMANTIC_TEXCOORD3, SEMANTIC_TEXCOORD4, SEMANTIC_TEXCOORD5, SEMANTIC_TEXCOORD6, SEMANTIC_TEXCOORD7, SHADERLANGUAGE_GLSL, SHADERLANGUAGE_WGSL, SHADERSTAGE_COMPUTE, SHADERSTAGE_FRAGMENT, SHADERSTAGE_VERTEX, SHADERTAG_MATERIAL, STENCILOP_DECREMENT, STENCILOP_DECREMENTWRAP, STENCILOP_INCREMENT, STENCILOP_INCREMENTWRAP, STENCILOP_INVERT, STENCILOP_KEEP, STENCILOP_REPLACE, STENCILOP_ZERO, TEXHINT_ASSET, TEXHINT_LIGHTMAP, TEXHINT_NONE, TEXHINT_SHADOWMAP, TEXTUREDIMENSION_1D, TEXTUREDIMENSION_2D, TEXTUREDIMENSION_2D_ARRAY, TEXTUREDIMENSION_3D, TEXTUREDIMENSION_CUBE, TEXTUREDIMENSION_CUBE_ARRAY, TEXTURELOCK_NONE, TEXTURELOCK_READ, TEXTURELOCK_WRITE, TEXTUREPROJECTION_CUBE, TEXTUREPROJECTION_EQUIRECT, TEXTUREPROJECTION_NONE, TEXTUREPROJECTION_OCTAHEDRAL, TEXTURETYPE_DEFAULT, TEXTURETYPE_RGBE, TEXTURETYPE_RGBM, TEXTURETYPE_RGBP, TEXTURETYPE_SWIZZLEGGGR, TYPE_FLOAT16, TYPE_FLOAT32, TYPE_INT16, TYPE_INT32, TYPE_INT8, TYPE_UINT16, TYPE_UINT32, TYPE_UINT8, UNIFORMTYPE_BOOL, UNIFORMTYPE_BOOLARRAY, UNIFORMTYPE_BVEC2, UNIFORMTYPE_BVEC2ARRAY, UNIFORMTYPE_BVEC3, UNIFORMTYPE_BVEC3ARRAY, UNIFORMTYPE_BVEC4, UNIFORMTYPE_BVEC4ARRAY, UNIFORMTYPE_FLOAT, UNIFORMTYPE_FLOATARRAY, UNIFORMTYPE_INT, UNIFORMTYPE_INTARRAY, UNIFORMTYPE_ITEXTURE2D, UNIFORMTYPE_ITEXTURE2D_ARRAY, UNIFORMTYPE_ITEXTURE3D, UNIFORMTYPE_ITEXTURECUBE, UNIFORMTYPE_IVEC2, UNIFORMTYPE_IVEC2ARRAY, UNIFORMTYPE_IVEC3, UNIFORMTYPE_IVEC3ARRAY, UNIFORMTYPE_IVEC4, UNIFORMTYPE_IVEC4ARRAY, UNIFORMTYPE_MAT2, UNIFORMTYPE_MAT3, UNIFORMTYPE_MAT4, UNIFORMTYPE_MAT4ARRAY, UNIFORMTYPE_TEXTURE2D, UNIFORMTYPE_TEXTURE2D_ARRAY, UNIFORMTYPE_TEXTURE2D_SHADOW, UNIFORMTYPE_TEXTURE3D, UNIFORMTYPE_TEXTURECUBE, UNIFORMTYPE_TEXTURECUBE_SHADOW, UNIFORMTYPE_UINT, UNIFORMTYPE_UINTARRAY, UNIFORMTYPE_UTEXTURE2D, UNIFORMTYPE_UTEXTURE2D_ARRAY, UNIFORMTYPE_UTEXTURE3D, UNIFORMTYPE_UTEXTURECUBE, UNIFORMTYPE_UVEC2, UNIFORMTYPE_UVEC2ARRAY, UNIFORMTYPE_UVEC3, UNIFORMTYPE_UVEC3ARRAY, UNIFORMTYPE_UVEC4, UNIFORMTYPE_UVEC4ARRAY, UNIFORMTYPE_VEC2, UNIFORMTYPE_VEC2ARRAY, UNIFORMTYPE_VEC3, UNIFORMTYPE_VEC3ARRAY, UNIFORMTYPE_VEC4, UNIFORMTYPE_VEC4ARRAY, UNIFORM_BUFFER_DEFAULT_SLOT_NAME, bindGroupNames, getPixelFormatArrayType, isCompressedPixelFormat, isIntegerPixelFormat, pixelFormatInfo, semanticToLocation, typedArrayIndexFormats, typedArrayIndexFormatsByteSize, typedArrayToType, typedArrayTypes, typedArrayTypesByteSize, uniformTypeToName, uniformTypeToStorage, vertexTypesNames };\n", "function _extends() {\n _extends = Object.assign ? Object.assign.bind() : function (target) {\n for (var i = 1; i < arguments.length; i++) {\n var source = arguments[i];\n for (var key in source) {\n if (Object.prototype.hasOwnProperty.call(source, key)) {\n target[key] = source[key];\n }\n }\n }\n return target;\n };\n return _extends.apply(this, arguments);\n}\n\nexport { _extends as extends };\n", "const BitPacking = {\n\tset(storage, value, shift, mask = 1) {\n\t\tconst data = storage & ~(mask << shift);\n\t\treturn data | value << shift;\n\t},\n\tget(storage, shift, mask = 1) {\n\t\treturn storage >> shift & mask;\n\t},\n\tall(storage, shift, mask = 1) {\n\t\tconst shifted = mask << shift;\n\t\treturn (storage & shifted) === shifted;\n\t},\n\tany(storage, shift, mask = 1) {\n\t\treturn (storage & mask << shift) !== 0;\n\t}\n};\n\nexport { BitPacking };\n", "import { BitPacking } from '../../core/math/bit-packing.js';\nimport { BLENDEQUATION_ADD, BLENDMODE_ONE, BLENDMODE_ZERO, BLENDMODE_SRC_ALPHA, BLENDMODE_ONE_MINUS_SRC_ALPHA } from './constants.js';\n\nvar _BlendState;\nconst opMask = 0b111;\nconst factorMask = 0b1111;\nconst colorOpShift = 0;\nconst colorSrcFactorShift = 3;\nconst colorDstFactorShift = 7;\nconst alphaOpShift = 11;\nconst alphaSrcFactorShift = 14;\nconst alphaDstFactorShift = 18;\nconst redWriteShift = 22;\nconst greenWriteShift = 23;\nconst blueWriteShift = 24;\nconst alphaWriteShift = 25;\nconst blendShift = 26;\nconst allWriteMasks = 0b1111;\nconst allWriteShift = redWriteShift;\nclass BlendState {\n\tconstructor(blend = false, colorOp = BLENDEQUATION_ADD, colorSrcFactor = BLENDMODE_ONE, colorDstFactor = BLENDMODE_ZERO, alphaOp, alphaSrcFactor, alphaDstFactor, redWrite = true, greenWrite = true, blueWrite = true, alphaWrite = true) {\n\t\tthis.target0 = 0;\n\t\tthis.setColorBlend(colorOp, colorSrcFactor, colorDstFactor);\n\t\tthis.setAlphaBlend(alphaOp != null ? alphaOp : colorOp, alphaSrcFactor != null ? alphaSrcFactor : colorSrcFactor, alphaDstFactor != null ? alphaDstFactor : colorDstFactor);\n\t\tthis.setColorWrite(redWrite, greenWrite, blueWrite, alphaWrite);\n\t\tthis.blend = blend;\n\t}\n\tset blend(value) {\n\t\tthis.target0 = BitPacking.set(this.target0, value ? 1 : 0, blendShift);\n\t}\n\tget blend() {\n\t\treturn BitPacking.all(this.target0, blendShift);\n\t}\n\tsetColorBlend(op, srcFactor, dstFactor) {\n\t\tthis.target0 = BitPacking.set(this.target0, op, colorOpShift, opMask);\n\t\tthis.target0 = BitPacking.set(this.target0, srcFactor, colorSrcFactorShift, factorMask);\n\t\tthis.target0 = BitPacking.set(this.target0, dstFactor, colorDstFactorShift, factorMask);\n\t}\n\tsetAlphaBlend(op, srcFactor, dstFactor) {\n\t\tthis.target0 = BitPacking.set(this.target0, op, alphaOpShift, opMask);\n\t\tthis.target0 = BitPacking.set(this.target0, srcFactor, alphaSrcFactorShift, factorMask);\n\t\tthis.target0 = BitPacking.set(this.target0, dstFactor, alphaDstFactorShift, factorMask);\n\t}\n\tsetColorWrite(redWrite, greenWrite, blueWrite, alphaWrite) {\n\t\tthis.redWrite = redWrite;\n\t\tthis.greenWrite = greenWrite;\n\t\tthis.blueWrite = blueWrite;\n\t\tthis.alphaWrite = alphaWrite;\n\t}\n\tget colorOp() {\n\t\treturn BitPacking.get(this.target0, colorOpShift, opMask);\n\t}\n\tget colorSrcFactor() {\n\t\treturn BitPacking.get(this.target0, colorSrcFactorShift, factorMask);\n\t}\n\tget colorDstFactor() {\n\t\treturn BitPacking.get(this.target0, colorDstFactorShift, factorMask);\n\t}\n\tget alphaOp() {\n\t\treturn BitPacking.get(this.target0, alphaOpShift, opMask);\n\t}\n\tget alphaSrcFactor() {\n\t\treturn BitPacking.get(this.target0, alphaSrcFactorShift, factorMask);\n\t}\n\tget alphaDstFactor() {\n\t\treturn BitPacking.get(this.target0, alphaDstFactorShift, factorMask);\n\t}\n\tset redWrite(value) {\n\t\tthis.target0 = BitPacking.set(this.target0, value ? 1 : 0, redWriteShift);\n\t}\n\tget redWrite() {\n\t\treturn BitPacking.all(this.target0, redWriteShift);\n\t}\n\tset greenWrite(value) {\n\t\tthis.target0 = BitPacking.set(this.target0, value ? 1 : 0, greenWriteShift);\n\t}\n\tget greenWrite() {\n\t\treturn BitPacking.all(this.target0, greenWriteShift);\n\t}\n\tset blueWrite(value) {\n\t\tthis.target0 = BitPacking.set(this.target0, value ? 1 : 0, blueWriteShift);\n\t}\n\tget blueWrite() {\n\t\treturn BitPacking.all(this.target0, blueWriteShift);\n\t}\n\tset alphaWrite(value) {\n\t\tthis.target0 = BitPacking.set(this.target0, value ? 1 : 0, alphaWriteShift);\n\t}\n\tget alphaWrite() {\n\t\treturn BitPacking.all(this.target0, alphaWriteShift);\n\t}\n\tget allWrite() {\n\t\treturn BitPacking.get(this.target0, allWriteShift, allWriteMasks);\n\t}\n\tcopy(rhs) {\n\t\tthis.target0 = rhs.target0;\n\t\treturn this;\n\t}\n\tclone() {\n\t\tconst clone = new this.constructor();\n\t\treturn clone.copy(this);\n\t}\n\tget key() {\n\t\treturn this.target0;\n\t}\n\tequals(rhs) {\n\t\treturn this.target0 === rhs.target0;\n\t}\n}\n_BlendState = BlendState;\nBlendState.NOBLEND = Object.freeze(new _BlendState());\nBlendState.NOWRITE = Object.freeze(new _BlendState(undefined, undefined, undefined, undefined, undefined, undefined, undefined, false, false, false, false));\nBlendState.ALPHABLEND = Object.freeze(new _BlendState(true, BLENDEQUATION_ADD, BLENDMODE_SRC_ALPHA, BLENDMODE_ONE_MINUS_SRC_ALPHA));\nBlendState.ADDBLEND = Object.freeze(new _BlendState(true, BLENDEQUATION_ADD, BLENDMODE_ONE, BLENDMODE_ONE));\n\nexport { BlendState };\n", "class StringIds {\n\tconstructor() {\n\t\tthis.map = new Map();\n\t\tthis.id = 0;\n\t}\n\tget(name) {\n\t\tlet value = this.map.get(name);\n\t\tif (value === undefined) {\n\t\t\tvalue = this.id++;\n\t\t\tthis.map.set(name, value);\n\t\t}\n\t\treturn value;\n\t}\n}\n\nexport { StringIds };\n", "import { BitPacking } from '../../core/math/bit-packing.js';\nimport { StringIds } from '../../core/string-ids.js';\nimport { FUNC_LESSEQUAL, FUNC_ALWAYS } from './constants.js';\n\nvar _DepthState;\nconst stringIds = new StringIds();\nconst funcMask = 0b111;\nconst funcShift = 0;\nconst writeShift = 3;\nclass DepthState {\n\tconstructor(func = FUNC_LESSEQUAL, write = true) {\n\t\tthis.data = 0;\n\t\tthis._depthBias = 0;\n\t\tthis._depthBiasSlope = 0;\n\t\tthis.key = 0;\n\t\tthis.func = func;\n\t\tthis.write = write;\n\t}\n\tset test(value) {\n\t\tthis.func = value ? FUNC_LESSEQUAL : FUNC_ALWAYS;\n\t\tthis.updateKey();\n\t}\n\tget test() {\n\t\treturn this.func !== FUNC_ALWAYS;\n\t}\n\tset write(value) {\n\t\tthis.data = BitPacking.set(this.data, value ? 1 : 0, writeShift);\n\t\tthis.updateKey();\n\t}\n\tget write() {\n\t\treturn BitPacking.all(this.data, writeShift);\n\t}\n\tset func(value) {\n\t\tthis.data = BitPacking.set(this.data, value, funcShift, funcMask);\n\t\tthis.updateKey();\n\t}\n\tget func() {\n\t\treturn BitPacking.get(this.data, funcShift, funcMask);\n\t}\n\tset depthBias(value) {\n\t\tthis._depthBias = value;\n\t\tthis.updateKey();\n\t}\n\tget depthBias() {\n\t\treturn this._depthBias;\n\t}\n\tset depthBiasSlope(value) {\n\t\tthis._depthBiasSlope = value;\n\t\tthis.updateKey();\n\t}\n\tget depthBiasSlope() {\n\t\treturn this._depthBiasSlope;\n\t}\n\tcopy(rhs) {\n\t\tthis.data = rhs.data;\n\t\tthis._depthBias = rhs._depthBias;\n\t\tthis._depthBiasSlope = rhs._depthBiasSlope;\n\t\tthis.key = rhs.key;\n\t\treturn this;\n\t}\n\tclone() {\n\t\tconst clone = new this.constructor();\n\t\treturn clone.copy(this);\n\t}\n\tupdateKey() {\n\t\tconst {\n\t\t\tdata,\n\t\t\t_depthBias,\n\t\t\t_depthBiasSlope\n\t\t} = this;\n\t\tconst key = `${data}-${_depthBias}-${_depthBiasSlope}`;\n\t\tthis.key = stringIds.get(key);\n\t}\n\tequals(rhs) {\n\t\treturn this.key === rhs.key;\n\t}\n}\n_DepthState = DepthState;\nDepthState.DEFAULT = Object.freeze(new _DepthState());\nDepthState.NODEPTH = Object.freeze(new _DepthState(FUNC_ALWAYS, false));\nDepthState.WRITEDEPTH = Object.freeze(new _DepthState(FUNC_ALWAYS, true));\n\nexport { DepthState };\n", "class Version {\n\tconstructor() {\n\t\tthis.globalId = 0;\n\t\tthis.revision = 0;\n\t}\n\tequals(other) {\n\t\treturn this.globalId === other.globalId && this.revision === other.revision;\n\t}\n\tcopy(other) {\n\t\tthis.globalId = other.globalId;\n\t\tthis.revision = other.revision;\n\t}\n\treset() {\n\t\tthis.globalId = 0;\n\t\tthis.revision = 0;\n\t}\n}\n\nexport { Version };\n", "import { Version } from './version.js';\n\nlet idCounter = 0;\nclass VersionedObject {\n\tconstructor() {\n\t\tidCounter++;\n\t\tthis.version = new Version();\n\t\tthis.version.globalId = idCounter;\n\t}\n\tincrement() {\n\t\tthis.version.revision++;\n\t}\n}\n\nexport { VersionedObject };\n", "import { VersionedObject } from './versioned-object.js';\n\nclass ScopeId {\n\tconstructor(name) {\n\t\tthis.name = name;\n\t\tthis.value = null;\n\t\tthis.versionObject = new VersionedObject();\n\t}\n\ttoJSON(key) {\n\t\treturn undefined;\n\t}\n\tsetValue(value) {\n\t\tthis.value = value;\n\t\tthis.versionObject.increment();\n\t}\n\tgetValue() {\n\t\treturn this.value;\n\t}\n}\n\nexport { ScopeId };\n", "import { ScopeId } from './scope-id.js';\n\nclass ScopeSpace {\n\tconstructor(name) {\n\t\tthis.name = name;\n\t\tthis.variables = new Map();\n\t}\n\tresolve(name) {\n\t\tif (!this.variables.has(name)) {\n\t\t\tthis.variables.set(name, new ScopeId(name));\n\t\t}\n\t\treturn this.variables.get(name);\n\t}\n\tremoveValue(value) {\n\t\tfor (const uniformName in this.variables) {\n\t\t\tconst uniform = this.variables[uniformName];\n\t\t\tif (uniform.value === value) {\n\t\t\t\tuniform.value = null;\n\t\t\t}\n\t\t}\n\t}\n}\n\nexport { ScopeSpace };\n", "import { BUFFER_STATIC } from './constants.js';\n\nlet id = 0;\nclass VertexBuffer {\n\tconstructor(graphicsDevice, format, numVertices, options) {\n\t\tthis.usage = BUFFER_STATIC;\n\t\tlet initialData;\n\t\tif (typeof options === 'object') {\n\t\t\tvar _options$usage;\n\t\t\tthis.usage = (_options$usage = options.usage) != null ? _options$usage : BUFFER_STATIC;\n\t\t\tinitialData = options.data;\n\t\t} else if (arguments.length > 3) {\n\t\t\tvar _arguments$;\n\t\t\tthis.usage = (_arguments$ = arguments[3]) != null ? _arguments$ : BUFFER_STATIC;\n\t\t\tinitialData = arguments[4];\n\t\t}\n\t\tthis.device = graphicsDevice;\n\t\tthis.format = format;\n\t\tthis.numVertices = numVertices;\n\t\tthis.id = id++;\n\t\tthis.impl = graphicsDevice.createVertexBufferImpl(this, format, options);\n\t\tthis.numBytes = format.verticesByteSize ? format.verticesByteSize : format.size * numVertices;\n\t\tthis.adjustVramSizeTracking(graphicsDevice._vram, this.numBytes);\n\t\tif (initialData) {\n\t\t\tthis.setData(initialData);\n\t\t} else {\n\t\t\tthis.storage = new ArrayBuffer(this.numBytes);\n\t\t}\n\t\tthis.device.buffers.push(this);\n\t}\n\tdestroy() {\n\t\tconst device = this.device;\n\t\tconst idx = device.buffers.indexOf(this);\n\t\tif (idx !== -1) {\n\t\t\tdevice.buffers.splice(idx, 1);\n\t\t}\n\t\tif (this.impl.initialized) {\n\t\t\tthis.impl.destroy(device);\n\t\t\tthis.adjustVramSizeTracking(device._vram, -this.storage.byteLength);\n\t\t}\n\t}\n\tadjustVramSizeTracking(vram, size) {\n\t\tvram.vb += size;\n\t}\n\tloseContext() {\n\t\tthis.impl.loseContext();\n\t}\n\tgetFormat() {\n\t\treturn this.format;\n\t}\n\tgetUsage() {\n\t\treturn this.usage;\n\t}\n\tgetNumVertices() {\n\t\treturn this.numVertices;\n\t}\n\tlock() {\n\t\treturn this.storage;\n\t}\n\tunlock() {\n\t\tthis.impl.unlock(this);\n\t}\n\tsetData(data) {\n\t\tif (data.byteLength !== this.numBytes) {\n\t\t\treturn false;\n\t\t}\n\t\tthis.storage = data;\n\t\tthis.unlock();\n\t\treturn true;\n\t}\n}\n\nexport { VertexBuffer };\n", "function hashCode(str) {\n\tlet hash = 0;\n\tfor (let i = 0, len = str.length; i < len; i++) {\n\t\thash = (hash << 5) - hash + str.charCodeAt(i);\n\t\thash |= 0;\n\t}\n\treturn hash;\n}\nfunction hash32Fnv1a(array) {\n\tconst prime = 16777619;\n\tlet hash = 2166136261;\n\tfor (let i = 0; i < array.length; i++) {\n\t\thash ^= array[i];\n\t\thash *= prime;\n\t}\n\treturn hash >>> 0;\n}\n\nexport { hash32Fnv1a, hashCode };\n", "class DeviceCache {\n\tconstructor() {\n\t\tthis._cache = new Map();\n\t}\n\tget(device, onCreate) {\n\t\tif (!this._cache.has(device)) {\n\t\t\tthis._cache.set(device, onCreate());\n\t\t\tdevice.on('destroy', () => {\n\t\t\t\tthis.remove(device);\n\t\t\t});\n\t\t\tdevice.on('devicelost', () => {\n\t\t\t\tvar _this$_cache$get;\n\t\t\t\t(_this$_cache$get = this._cache.get(device)) == null || _this$_cache$get.loseContext == null || _this$_cache$get.loseContext(device);\n\t\t\t});\n\t\t}\n\t\treturn this._cache.get(device);\n\t}\n\tremove(device) {\n\t\tvar _this$_cache$get2;\n\t\t(_this$_cache$get2 = this._cache.get(device)) == null || _this$_cache$get2.destroy == null || _this$_cache$get2.destroy(device);\n\t\tthis._cache.delete(device);\n\t}\n}\n\nexport { DeviceCache };\n", "import { hashCode } from '../../core/hash.js';\nimport { math } from '../../core/math/math.js';\nimport { StringIds } from '../../core/string-ids.js';\nimport { typedArrayTypesByteSize, SEMANTIC_TEXCOORD0, SEMANTIC_TEXCOORD1, SEMANTIC_COLOR, SEMANTIC_TANGENT, SEMANTIC_ATTR12, TYPE_FLOAT32, SEMANTIC_ATTR13, SEMANTIC_ATTR14, SEMANTIC_ATTR15 } from './constants.js';\nimport { DeviceCache } from './device-cache.js';\n\nconst stringIds = new StringIds();\nconst webgpuValidElementSizes = [2, 4, 8, 12, 16];\nconst deviceCache = new DeviceCache();\nclass VertexFormat {\n\tconstructor(graphicsDevice, description, vertexCount) {\n\t\tthis.device = graphicsDevice;\n\t\tthis._elements = [];\n\t\tthis.hasUv0 = false;\n\t\tthis.hasUv1 = false;\n\t\tthis.hasColor = false;\n\t\tthis.hasTangents = false;\n\t\tthis.verticesByteSize = 0;\n\t\tthis.vertexCount = vertexCount;\n\t\tthis.interleaved = vertexCount === undefined;\n\t\tthis.instancing = false;\n\t\tthis.size = description.reduce((total, desc) => {\n\t\t\treturn total + Math.ceil(desc.components * typedArrayTypesByteSize[desc.type] / 4) * 4;\n\t\t}, 0);\n\t\tlet offset = 0,\n\t\t\telementSize;\n\t\tfor (let i = 0, len = description.length; i < len; i++) {\n\t\t\tvar _elementDesc$asInt, _elementDesc$normaliz;\n\t\t\tconst elementDesc = description[i];\n\t\t\telementSize = elementDesc.components * typedArrayTypesByteSize[elementDesc.type];\n\t\t\tif (vertexCount) {\n\t\t\t\toffset = math.roundUp(offset, elementSize);\n\t\t\t}\n\t\t\tconst asInt = (_elementDesc$asInt = elementDesc.asInt) != null ? _elementDesc$asInt : false;\n\t\t\tconst normalize = asInt ? false : (_elementDesc$normaliz = elementDesc.normalize) != null ? _elementDesc$normaliz : false;\n\t\t\tconst element = {\n\t\t\t\tname: elementDesc.semantic,\n\t\t\t\toffset: vertexCount ? offset : elementDesc.hasOwnProperty('offset') ? elementDesc.offset : offset,\n\t\t\t\tstride: vertexCount ? elementSize : elementDesc.hasOwnProperty('stride') ? elementDesc.stride : this.size,\n\t\t\t\tdataType: elementDesc.type,\n\t\t\t\tnumComponents: elementDesc.components,\n\t\t\t\tnormalize: normalize,\n\t\t\t\tsize: elementSize,\n\t\t\t\tasInt: asInt\n\t\t\t};\n\t\t\tthis._elements.push(element);\n\t\t\tif (vertexCount) {\n\t\t\t\toffset += elementSize * vertexCount;\n\t\t\t} else {\n\t\t\t\toffset += Math.ceil(elementSize / 4) * 4;\n\t\t\t}\n\t\t\tif (elementDesc.semantic === SEMANTIC_TEXCOORD0) {\n\t\t\t\tthis.hasUv0 = true;\n\t\t\t} else if (elementDesc.semantic === SEMANTIC_TEXCOORD1) {\n\t\t\t\tthis.hasUv1 = true;\n\t\t\t} else if (elementDesc.semantic === SEMANTIC_COLOR) {\n\t\t\t\tthis.hasColor = true;\n\t\t\t} else if (elementDesc.semantic === SEMANTIC_TANGENT) {\n\t\t\t\tthis.hasTangents = true;\n\t\t\t}\n\t\t}\n\t\tif (vertexCount) {\n\t\t\tthis.verticesByteSize = offset;\n\t\t}\n\t\tthis._evaluateHash();\n\t}\n\tget elements() {\n\t\treturn this._elements;\n\t}\n\tstatic getDefaultInstancingFormat(graphicsDevice) {\n\t\treturn deviceCache.get(graphicsDevice, () => {\n\t\t\treturn new VertexFormat(graphicsDevice, [{\n\t\t\t\tsemantic: SEMANTIC_ATTR12,\n\t\t\t\tcomponents: 4,\n\t\t\t\ttype: TYPE_FLOAT32\n\t\t\t}, {\n\t\t\t\tsemantic: SEMANTIC_ATTR13,\n\t\t\t\tcomponents: 4,\n\t\t\t\ttype: TYPE_FLOAT32\n\t\t\t}, {\n\t\t\t\tsemantic: SEMANTIC_ATTR14,\n\t\t\t\tcomponents: 4,\n\t\t\t\ttype: TYPE_FLOAT32\n\t\t\t}, {\n\t\t\t\tsemantic: SEMANTIC_ATTR15,\n\t\t\t\tcomponents: 4,\n\t\t\t\ttype: TYPE_FLOAT32\n\t\t\t}]);\n\t\t});\n\t}\n\tstatic isElementValid(graphicsDevice, elementDesc) {\n\t\tconst elementSize = elementDesc.components * typedArrayTypesByteSize[elementDesc.type];\n\t\tif (graphicsDevice.isWebGPU && !webgpuValidElementSizes.includes(elementSize)) return false;\n\t\treturn true;\n\t}\n\tupdate() {\n\t\tthis._evaluateHash();\n\t}\n\t_evaluateHash() {\n\t\tconst stringElementsBatch = [];\n\t\tconst stringElementsRender = [];\n\t\tconst len = this._elements.length;\n\t\tfor (let i = 0; i < len; i++) {\n\t\t\tconst {\n\t\t\t\tname,\n\t\t\t\tdataType,\n\t\t\t\tnumComponents,\n\t\t\t\tnormalize,\n\t\t\t\toffset,\n\t\t\t\tstride,\n\t\t\t\tsize,\n\t\t\t\tasInt\n\t\t\t} = this._elements[i];\n\t\t\tconst stringElementBatch = name + dataType + numComponents + normalize + asInt;\n\t\t\tstringElementsBatch.push(stringElementBatch);\n\t\t\tconst stringElementRender = stringElementBatch + offset + stride + size;\n\t\t\tstringElementsRender.push(stringElementRender);\n\t\t}\n\t\tstringElementsBatch.sort();\n\t\tconst batchingString = stringElementsBatch.join();\n\t\tthis.batchingHash = hashCode(batchingString);\n\t\tthis.shaderProcessingHashString = batchingString;\n\t\tthis.renderingHashString = stringElementsRender.join('_');\n\t\tthis.renderingHash = stringIds.get(this.renderingHashString);\n\t}\n}\n\nexport { VertexFormat };\n", "import { FUNC_ALWAYS, STENCILOP_KEEP } from './constants.js';\nimport { StringIds } from '../../core/string-ids.js';\n\nvar _StencilParameters;\nconst stringIds = new StringIds();\nclass StencilParameters {\n\tset func(value) {\n\t\tthis._func = value;\n\t\tthis._dirty = true;\n\t}\n\tget func() {\n\t\treturn this._func;\n\t}\n\tset ref(value) {\n\t\tthis._ref = value;\n\t\tthis._dirty = true;\n\t}\n\tget ref() {\n\t\treturn this._ref;\n\t}\n\tset fail(value) {\n\t\tthis._fail = value;\n\t\tthis._dirty = true;\n\t}\n\tget fail() {\n\t\treturn this._fail;\n\t}\n\tset zfail(value) {\n\t\tthis._zfail = value;\n\t\tthis._dirty = true;\n\t}\n\tget zfail() {\n\t\treturn this._zfail;\n\t}\n\tset zpass(value) {\n\t\tthis._zpass = value;\n\t\tthis._dirty = true;\n\t}\n\tget zpass() {\n\t\treturn this._zpass;\n\t}\n\tset readMask(value) {\n\t\tthis._readMask = value;\n\t\tthis._dirty = true;\n\t}\n\tget readMask() {\n\t\treturn this._readMask;\n\t}\n\tset writeMask(value) {\n\t\tthis._writeMask = value;\n\t\tthis._dirty = true;\n\t}\n\tget writeMask() {\n\t\treturn this._writeMask;\n\t}\n\tconstructor(options = {}) {\n\t\tvar _options$func, _options$ref, _options$readMask, _options$writeMask, _options$fail, _options$zfail, _options$zpass;\n\t\tthis._func = void 0;\n\t\tthis._ref = void 0;\n\t\tthis._fail = void 0;\n\t\tthis._zfail = void 0;\n\t\tthis._zpass = void 0;\n\t\tthis._readMask = void 0;\n\t\tthis._writeMask = void 0;\n\t\tthis._dirty = true;\n\t\tthis._key = void 0;\n\t\tthis._func = (_options$func = options.func) != null ? _options$func : FUNC_ALWAYS;\n\t\tthis._ref = (_options$ref = options.ref) != null ? _options$ref : 0;\n\t\tthis._readMask = (_options$readMask = options.readMask) != null ? _options$readMask : 0xFF;\n\t\tthis._writeMask = (_options$writeMask = options.writeMask) != null ? _options$writeMask : 0xFF;\n\t\tthis._fail = (_options$fail = options.fail) != null ? _options$fail : STENCILOP_KEEP;\n\t\tthis._zfail = (_options$zfail = options.zfail) != null ? _options$zfail : STENCILOP_KEEP;\n\t\tthis._zpass = (_options$zpass = options.zpass) != null ? _options$zpass : STENCILOP_KEEP;\n\t\tthis._evalKey();\n\t}\n\t_evalKey() {\n\t\tconst {\n\t\t\t_func,\n\t\t\t_ref,\n\t\t\t_fail,\n\t\t\t_zfail,\n\t\t\t_zpass,\n\t\t\t_readMask,\n\t\t\t_writeMask\n\t\t} = this;\n\t\tconst key = `${_func},${_ref},${_fail},${_zfail},${_zpass},${_readMask},${_writeMask}`;\n\t\tthis._key = stringIds.get(key);\n\t\tthis._dirty = false;\n\t}\n\tget key() {\n\t\tif (this._dirty) {\n\t\t\tthis._evalKey();\n\t\t}\n\t\treturn this._key;\n\t}\n\tcopy(rhs) {\n\t\tthis._func = rhs._func;\n\t\tthis._ref = rhs._ref;\n\t\tthis._readMask = rhs._readMask;\n\t\tthis._writeMask = rhs._writeMask;\n\t\tthis._fail = rhs._fail;\n\t\tthis._zfail = rhs._zfail;\n\t\tthis._zpass = rhs._zpass;\n\t\tthis._dirty = rhs._dirty;\n\t\tthis._key = rhs._key;\n\t\treturn this;\n\t}\n\tclone() {\n\t\tconst clone = new this.constructor();\n\t\treturn clone.copy(this);\n\t}\n}\n_StencilParameters = StencilParameters;\nStencilParameters.DEFAULT = Object.freeze(new _StencilParameters());\n\nexport { StencilParameters };\n", "import { extends as _extends } from '../../../_virtual/_rollupPluginBabelHelpers.js';\nimport { EventHandler } from '../../core/event-handler.js';\nimport { platform } from '../../core/platform.js';\nimport { Vec2 } from '../../core/math/vec2.js';\nimport { Color } from '../../core/math/color.js';\nimport { CLEARFLAG_COLOR, CLEARFLAG_DEPTH, PRIMITIVE_TRIFAN, SEMANTIC_POSITION, TYPE_FLOAT32, CULLFACE_BACK, PIXELFORMAT_RGBA32F, PIXELFORMAT_RGBA16F, PIXELFORMAT_111110F, PRIMITIVE_POINTS } from './constants.js';\nimport { BlendState } from './blend-state.js';\nimport { DepthState } from './depth-state.js';\nimport { ScopeSpace } from './scope-space.js';\nimport { VertexBuffer } from './vertex-buffer.js';\nimport { VertexFormat } from './vertex-format.js';\nimport { StencilParameters } from './stencil-parameters.js';\n\nclass GraphicsDevice extends EventHandler {\n\tconstructor(canvas, options) {\n\t\tvar _this$initOptions, _this$initOptions$dep, _this$initOptions2, _this$initOptions2$st, _this$initOptions3, _this$initOptions3$an, _this$initOptions4, _this$initOptions4$po;\n\t\tsuper();\n\t\tthis.canvas = void 0;\n\t\tthis.backBuffer = null;\n\t\tthis.backBufferSize = new Vec2();\n\t\tthis.backBufferFormat = void 0;\n\t\tthis.backBufferAntialias = false;\n\t\tthis.isWebGPU = false;\n\t\tthis.isWebGL1 = false;\n\t\tthis.isWebGL2 = false;\n\t\tthis.scope = void 0;\n\t\tthis.boneLimit = void 0;\n\t\tthis.maxAnisotropy = void 0;\n\t\tthis.maxCubeMapSize = void 0;\n\t\tthis.maxTextureSize = void 0;\n\t\tthis.maxVolumeSize = void 0;\n\t\tthis.maxColorAttachments = 1;\n\t\tthis.precision = void 0;\n\t\tthis.samples = void 0;\n\t\tthis.supportsStencil = void 0;\n\t\tthis.supportsMrt = false;\n\t\tthis.supportsVolumeTextures = false;\n\t\tthis.supportsCompute = false;\n\t\tthis.supportsStorageTextureRead = false;\n\t\tthis.renderTarget = null;\n\t\tthis.shaders = [];\n\t\tthis.textures = [];\n\t\tthis.targets = new Set();\n\t\tthis.renderVersion = 0;\n\t\tthis.renderPassIndex = void 0;\n\t\tthis.insideRenderPass = false;\n\t\tthis.supportsInstancing = void 0;\n\t\tthis.supportsUniformBuffers = false;\n\t\tthis.textureFloatRenderable = void 0;\n\t\tthis.textureHalfFloatRenderable = void 0;\n\t\tthis.textureFloatFilterable = false;\n\t\tthis.textureHalfFloatFilterable = false;\n\t\tthis.quadVertexBuffer = void 0;\n\t\tthis.blendState = new BlendState();\n\t\tthis.depthState = new DepthState();\n\t\tthis.stencilEnabled = false;\n\t\tthis.stencilFront = new StencilParameters();\n\t\tthis.stencilBack = new StencilParameters();\n\t\tthis.dynamicBuffers = void 0;\n\t\tthis.gpuProfiler = void 0;\n\t\tthis.defaultClearOptions = {\n\t\t\tcolor: [0, 0, 0, 1],\n\t\t\tdepth: 1,\n\t\t\tstencil: 0,\n\t\t\tflags: CLEARFLAG_COLOR | CLEARFLAG_DEPTH\n\t\t};\n\t\tthis.clientRect = {\n\t\t\twidth: 0,\n\t\t\theight: 0\n\t\t};\n\t\tthis.canvas = canvas;\n\t\tthis.initOptions = _extends({}, options);\n\t\t(_this$initOptions$dep = (_this$initOptions = this.initOptions).depth) != null ? _this$initOptions$dep : _this$initOptions.depth = true;\n\t\t(_this$initOptions2$st = (_this$initOptions2 = this.initOptions).stencil) != null ? _this$initOptions2$st : _this$initOptions2.stencil = true;\n\t\t(_this$initOptions3$an = (_this$initOptions3 = this.initOptions).antialias) != null ? _this$initOptions3$an : _this$initOptions3.antialias = true;\n\t\t(_this$initOptions4$po = (_this$initOptions4 = this.initOptions).powerPreference) != null ? _this$initOptions4$po : _this$initOptions4.powerPreference = 'high-performance';\n\t\tthis._maxPixelRatio = platform.browser ? Math.min(1, window.devicePixelRatio) : 1;\n\t\tthis.buffers = [];\n\t\tthis._vram = {\n\t\t\ttex: 0,\n\t\t\tvb: 0,\n\t\t\tib: 0,\n\t\t\tub: 0,\n\t\t\tsb: 0\n\t\t};\n\t\tthis._shaderStats = {\n\t\t\tvsCompiled: 0,\n\t\t\tfsCompiled: 0,\n\t\t\tlinked: 0,\n\t\t\tmaterialShaders: 0,\n\t\t\tcompileTime: 0\n\t\t};\n\t\tthis.initializeContextCaches();\n\t\tthis._drawCallsPerFrame = 0;\n\t\tthis._shaderSwitchesPerFrame = 0;\n\t\tthis._primsPerFrame = [];\n\t\tfor (let i = PRIMITIVE_POINTS; i <= PRIMITIVE_TRIFAN; i++) {\n\t\t\tthis._primsPerFrame[i] = 0;\n\t\t}\n\t\tthis._renderTargetCreationTime = 0;\n\t\tthis.scope = new ScopeSpace(\"Device\");\n\t\tthis.textureBias = this.scope.resolve(\"textureBias\");\n\t\tthis.textureBias.setValue(0.0);\n\t}\n\tpostInit() {\n\t\tconst vertexFormat = new VertexFormat(this, [{\n\t\t\tsemantic: SEMANTIC_POSITION,\n\t\t\tcomponents: 2,\n\t\t\ttype: TYPE_FLOAT32\n\t\t}]);\n\t\tconst positions = new Float32Array([-1, -1, 1, -1, -1, 1, 1, 1]);\n\t\tthis.quadVertexBuffer = new VertexBuffer(this, vertexFormat, 4, {\n\t\t\tdata: positions\n\t\t});\n\t}\n\tdestroy() {\n\t\tvar _this$quadVertexBuffe, _this$dynamicBuffers, _this$gpuProfiler;\n\t\tthis.fire('destroy');\n\t\t(_this$quadVertexBuffe = this.quadVertexBuffer) == null || _this$quadVertexBuffe.destroy();\n\t\tthis.quadVertexBuffer = null;\n\t\t(_this$dynamicBuffers = this.dynamicBuffers) == null || _this$dynamicBuffers.destroy();\n\t\tthis.dynamicBuffers = null;\n\t\t(_this$gpuProfiler = this.gpuProfiler) == null || _this$gpuProfiler.destroy();\n\t\tthis.gpuProfiler = null;\n\t}\n\tonDestroyShader(shader) {\n\t\tthis.fire('destroy:shader', shader);\n\t\tconst idx = this.shaders.indexOf(shader);\n\t\tif (idx !== -1) {\n\t\t\tthis.shaders.splice(idx, 1);\n\t\t}\n\t}\n\tpostDestroy() {\n\t\tthis.scope = null;\n\t\tthis.canvas = null;\n\t}\n\tloseContext() {\n\t\tvar _this$gpuProfiler2;\n\t\tthis.contextLost = true;\n\t\tthis.backBufferSize.set(-1, -1);\n\t\tfor (const texture of this.textures) {\n\t\t\ttexture.loseContext();\n\t\t}\n\t\tfor (const buffer of this.buffers) {\n\t\t\tbuffer.loseContext();\n\t\t}\n\t\tfor (const target of this.targets) {\n\t\t\ttarget.loseContext();\n\t\t}\n\t\t(_this$gpuProfiler2 = this.gpuProfiler) == null || _this$gpuProfiler2.loseContext();\n\t}\n\trestoreContext() {\n\t\tvar _this$gpuProfiler3;\n\t\tthis.contextLost = false;\n\t\tthis.initializeRenderState();\n\t\tthis.initializeContextCaches();\n\t\tfor (const buffer of this.buffers) {\n\t\t\tbuffer.unlock();\n\t\t}\n\t\t(_this$gpuProfiler3 = this.gpuProfiler) == null || _this$gpuProfiler3.restoreContext == null || _this$gpuProfiler3.restoreContext();\n\t}\n\ttoJSON(key) {\n\t\treturn undefined;\n\t}\n\tinitializeContextCaches() {\n\t\tthis.indexBuffer = null;\n\t\tthis.vertexBuffers = [];\n\t\tthis.shader = null;\n\t\tthis.shaderValid = undefined;\n\t\tthis.shaderAsyncCompile = false;\n\t\tthis.renderTarget = null;\n\t}\n\tinitializeRenderState() {\n\t\tthis.blendState = new BlendState();\n\t\tthis.depthState = new DepthState();\n\t\tthis.cullMode = CULLFACE_BACK;\n\t\tthis.vx = this.vy = this.vw = this.vh = 0;\n\t\tthis.sx = this.sy = this.sw = this.sh = 0;\n\t\tthis.blendColor = new Color(0, 0, 0, 0);\n\t}\n\tsetStencilState(stencilFront, stencilBack) {}\n\tsetBlendState(blendState) {}\n\tsetBlendColor(r, g, b, a) {}\n\tsetDepthState(depthState) {}\n\tsetCullMode(cullMode) {}\n\tsetRenderTarget(renderTarget) {\n\t\tthis.renderTarget = renderTarget;\n\t}\n\tsetIndexBuffer(indexBuffer) {\n\t\tthis.indexBuffer = indexBuffer;\n\t}\n\tsetVertexBuffer(vertexBuffer) {\n\t\tif (vertexBuffer) {\n\t\t\tthis.vertexBuffers.push(vertexBuffer);\n\t\t}\n\t}\n\tclearVertexBuffer() {\n\t\tthis.vertexBuffers.length = 0;\n\t}\n\tgetRenderTarget() {\n\t\treturn this.renderTarget;\n\t}\n\tinitRenderTarget(target) {\n\t\tif (target.initialized) return;\n\t\ttarget.init();\n\t\tthis.targets.add(target);\n\t}\n\t_isBrowserInterface(texture) {\n\t\treturn this._isImageBrowserInterface(texture) || this._isImageCanvasInterface(texture) || this._isImageVideoInterface(texture);\n\t}\n\t_isImageBrowserInterface(texture) {\n\t\treturn typeof ImageBitmap !== 'undefined' && texture instanceof ImageBitmap || typeof HTMLImageElement !== 'undefined' && texture instanceof HTMLImageElement;\n\t}\n\t_isImageCanvasInterface(texture) {\n\t\treturn typeof HTMLCanvasElement !== 'undefined' && texture instanceof HTMLCanvasElement;\n\t}\n\t_isImageVideoInterface(texture) {\n\t\treturn typeof HTMLVideoElement !== 'undefined' && texture instanceof HTMLVideoElement;\n\t}\n\tresizeCanvas(width, height) {\n\t\tconst pixelRatio = Math.min(this._maxPixelRatio, platform.browser ? window.devicePixelRatio : 1);\n\t\tconst w = Math.floor(width * pixelRatio);\n\t\tconst h = Math.floor(height * pixelRatio);\n\t\tif (w !== this.canvas.width || h !== this.canvas.height) {\n\t\t\tthis.setResolution(w, h);\n\t\t}\n\t}\n\tsetResolution(width, height) {\n\t\tthis.canvas.width = width;\n\t\tthis.canvas.height = height;\n\t\tthis.fire(GraphicsDevice.EVENT_RESIZE, width, height);\n\t}\n\tupdateClientRect() {\n\t\tif (platform.worker) {\n\t\t\tthis.clientRect.width = this.canvas.width;\n\t\t\tthis.clientRect.height = this.canvas.height;\n\t\t} else {\n\t\t\tconst rect = this.canvas.getBoundingClientRect();\n\t\t\tthis.clientRect.width = rect.width;\n\t\t\tthis.clientRect.height = rect.height;\n\t\t}\n\t}\n\tget width() {\n\t\treturn this.canvas.width;\n\t}\n\tget height() {\n\t\treturn this.canvas.height;\n\t}\n\tset fullscreen(fullscreen) {}\n\tget fullscreen() {\n\t\treturn false;\n\t}\n\tset maxPixelRatio(ratio) {\n\t\tthis._maxPixelRatio = ratio;\n\t}\n\tget maxPixelRatio() {\n\t\treturn this._maxPixelRatio;\n\t}\n\tget deviceType() {\n\t\treturn this._deviceType;\n\t}\n\tgetBoneLimit() {\n\t\treturn this.boneLimit;\n\t}\n\tsetBoneLimit(maxBones) {\n\t\tthis.boneLimit = maxBones;\n\t}\n\tstartRenderPass(renderPass) {}\n\tendRenderPass(renderPass) {}\n\tstartComputePass() {}\n\tendComputePass() {}\n\tframeStart() {\n\t\tthis.renderPassIndex = 0;\n\t\tthis.renderVersion++;\n\t}\n\tframeEnd() {}\n\tcomputeDispatch(computes) {}\n\tgetRenderableHdrFormat(formats = [PIXELFORMAT_111110F, PIXELFORMAT_RGBA16F, PIXELFORMAT_RGBA32F], filterable = true) {\n\t\tfor (let i = 0; i < formats.length; i++) {\n\t\t\tconst format = formats[i];\n\t\t\tswitch (format) {\n\t\t\t\tcase PIXELFORMAT_111110F:\n\t\t\t\t\t{\n\t\t\t\t\t\tif (this.textureRG11B10Renderable) return format;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\tcase PIXELFORMAT_RGBA16F:\n\t\t\t\t\tif (this.textureHalfFloatRenderable && (!filterable || this.textureHalfFloatFilterable)) {\n\t\t\t\t\t\treturn format;\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\tcase PIXELFORMAT_RGBA32F:\n\t\t\t\t\tif (this.textureFloatRenderable && (!filterable || this.textureFloatFilterable)) {\n\t\t\t\t\t\treturn format;\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\treturn undefined;\n\t}\n}\nGraphicsDevice.EVENT_RESIZE = 'resizecanvas';\n\nexport { GraphicsDevice };\n", "import { PIXELFORMAT_DEPTH, PIXELFORMAT_DEPTHSTENCIL } from './constants.js';\nimport { GraphicsDevice } from './graphics-device.js';\n\nlet id = 0;\nclass RenderTarget {\n\tconstructor(options = {}) {\n\t\tvar _options$face, _this$_colorBuffer, _this$_depthBuffer, _options$samples, _options$autoResolve, _options$flipY;\n\t\tthis.name = void 0;\n\t\tthis._device = void 0;\n\t\tthis._colorBuffer = void 0;\n\t\tthis._colorBuffers = void 0;\n\t\tthis._depthBuffer = void 0;\n\t\tthis._depth = void 0;\n\t\tthis._stencil = void 0;\n\t\tthis._samples = void 0;\n\t\tthis.autoResolve = void 0;\n\t\tthis._face = void 0;\n\t\tthis.flipY = void 0;\n\t\tthis.id = id++;\n\t\tconst _arg2 = arguments[1];\n\t\tconst _arg3 = arguments[2];\n\t\tif (options instanceof GraphicsDevice) {\n\t\t\tthis._colorBuffer = _arg2;\n\t\t\toptions = _arg3;\n\t\t} else {\n\t\t\tthis._colorBuffer = options.colorBuffer;\n\t\t}\n\t\tif (this._colorBuffer) {\n\t\t\tthis._colorBuffers = [this._colorBuffer];\n\t\t}\n\t\tthis._depthBuffer = options.depthBuffer;\n\t\tthis._face = (_options$face = options.face) != null ? _options$face : 0;\n\t\tif (this._depthBuffer) {\n\t\t\tconst format = this._depthBuffer._format;\n\t\t\tif (format === PIXELFORMAT_DEPTH) {\n\t\t\t\tthis._depth = true;\n\t\t\t\tthis._stencil = false;\n\t\t\t} else if (format === PIXELFORMAT_DEPTHSTENCIL) {\n\t\t\t\tthis._depth = true;\n\t\t\t\tthis._stencil = true;\n\t\t\t} else {\n\t\t\t\tthis._depth = false;\n\t\t\t\tthis._stencil = false;\n\t\t\t}\n\t\t} else {\n\t\t\tvar _options$depth, _options$stencil;\n\t\t\tthis._depth = (_options$depth = options.depth) != null ? _options$depth : true;\n\t\t\tthis._stencil = (_options$stencil = options.stencil) != null ? _options$stencil : false;\n\t\t}\n\t\tif (options.colorBuffers) {\n\t\t\tif (!this._colorBuffers) {\n\t\t\t\tthis._colorBuffers = [...options.colorBuffers];\n\t\t\t\tthis._colorBuffer = options.colorBuffers[0];\n\t\t\t}\n\t\t}\n\t\tconst device = ((_this$_colorBuffer = this._colorBuffer) == null ? void 0 : _this$_colorBuffer.device) || ((_this$_depthBuffer = this._depthBuffer) == null ? void 0 : _this$_depthBuffer.device) || options.graphicsDevice;\n\t\tthis._device = device;\n\t\tconst {\n\t\t\tmaxSamples\n\t\t} = this._device;\n\t\tthis._samples = Math.min((_options$samples = options.samples) != null ? _options$samples : 1, maxSamples);\n\t\tif (device.isWebGPU) {\n\t\t\tthis._samples = this._samples > 1 ? maxSamples : 1;\n\t\t}\n\t\tthis.autoResolve = (_options$autoResolve = options.autoResolve) != null ? _options$autoResolve : true;\n\t\tthis.name = options.name;\n\t\tif (!this.name) {\n\t\t\tvar _this$_colorBuffer2;\n\t\t\tthis.name = (_this$_colorBuffer2 = this._colorBuffer) == null ? void 0 : _this$_colorBuffer2.name;\n\t\t}\n\t\tif (!this.name) {\n\t\t\tvar _this$_depthBuffer2;\n\t\t\tthis.name = (_this$_depthBuffer2 = this._depthBuffer) == null ? void 0 : _this$_depthBuffer2.name;\n\t\t}\n\t\tif (!this.name) {\n\t\t\tthis.name = \"Untitled\";\n\t\t}\n\t\tthis.flipY = (_options$flipY = options.flipY) != null ? _options$flipY : false;\n\t\tthis.validateMrt();\n\t\tthis.impl = device.createRenderTargetImpl(this);\n\t}\n\tdestroy() {\n\t\tconst device = this._device;\n\t\tif (device) {\n\t\t\tdevice.targets.delete(this);\n\t\t\tif (device.renderTarget === this) {\n\t\t\t\tdevice.setRenderTarget(null);\n\t\t\t}\n\t\t\tthis.destroyFrameBuffers();\n\t\t}\n\t}\n\tdestroyFrameBuffers() {\n\t\tconst device = this._device;\n\t\tif (device) {\n\t\t\tthis.impl.destroy(device);\n\t\t}\n\t}\n\tdestroyTextureBuffers() {\n\t\tvar _this$_depthBuffer3, _this$_colorBuffers;\n\t\t(_this$_depthBuffer3 = this._depthBuffer) == null || _this$_depthBuffer3.destroy();\n\t\tthis._depthBuffer = null;\n\t\t(_this$_colorBuffers = this._colorBuffers) == null || _this$_colorBuffers.forEach(colorBuffer => {\n\t\t\tcolorBuffer.destroy();\n\t\t});\n\t\tthis._colorBuffers = null;\n\t\tthis._colorBuffer = null;\n\t}\n\tresize(width, height) {\n\t\tif (this.width !== width || this.height !== height) {\n\t\t\tvar _this$_depthBuffer4, _this$_colorBuffers2;\n\t\t\tconst device = this._device;\n\t\t\tthis.destroyFrameBuffers();\n\t\t\tif (device.renderTarget === this) {\n\t\t\t\tdevice.setRenderTarget(null);\n\t\t\t}\n\t\t\t(_this$_depthBuffer4 = this._depthBuffer) == null || _this$_depthBuffer4.resize(width, height);\n\t\t\t(_this$_colorBuffers2 = this._colorBuffers) == null || _this$_colorBuffers2.forEach(colorBuffer => {\n\t\t\t\tcolorBuffer.resize(width, height);\n\t\t\t});\n\t\t\tthis.validateMrt();\n\t\t\tthis.impl = device.createRenderTargetImpl(this);\n\t\t}\n\t}\n\tvalidateMrt() {}\n\tinit() {\n\t\tthis.impl.init(this._device, this);\n\t}\n\tget initialized() {\n\t\treturn this.impl.initialized;\n\t}\n\tget device() {\n\t\treturn this._device;\n\t}\n\tloseContext() {\n\t\tthis.impl.loseContext();\n\t}\n\tresolve(color = true, depth = !!this._depthBuffer) {\n\t\tif (this._device && this._samples > 1) {\n\t\t\tthis.impl.resolve(this._device, this, color, depth);\n\t\t}\n\t}\n\tcopy(source, color, depth) {\n\t\tif (!this._device) {\n\t\t\tif (source._device) {\n\t\t\t\tthis._device = source._device;\n\t\t\t} else {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\t\tconst success = this._device.copyRenderTarget(source, this, color, depth);\n\t\treturn success;\n\t}\n\tget samples() {\n\t\treturn this._samples;\n\t}\n\tget depth() {\n\t\treturn this._depth;\n\t}\n\tget stencil() {\n\t\treturn this._stencil;\n\t}\n\tget colorBuffer() {\n\t\treturn this._colorBuffer;\n\t}\n\tgetColorBuffer(index) {\n\t\tvar _this$_colorBuffers3;\n\t\treturn (_this$_colorBuffers3 = this._colorBuffers) == null ? void 0 : _this$_colorBuffers3[index];\n\t}\n\tget depthBuffer() {\n\t\treturn this._depthBuffer;\n\t}\n\tget face() {\n\t\treturn this._face;\n\t}\n\tget width() {\n\t\tvar _this$_colorBuffer3, _this$_depthBuffer5;\n\t\treturn ((_this$_colorBuffer3 = this._colorBuffer) == null ? void 0 : _this$_colorBuffer3.width) || ((_this$_depthBuffer5 = this._depthBuffer) == null ? void 0 : _this$_depthBuffer5.width) || this._device.width;\n\t}\n\tget height() {\n\t\tvar _this$_colorBuffer4, _this$_depthBuffer6;\n\t\treturn ((_this$_colorBuffer4 = this._colorBuffer) == null ? void 0 : _this$_colorBuffer4.height) || ((_this$_depthBuffer6 = this._depthBuffer) == null ? void 0 : _this$_depthBuffer6.height) || this._device.height;\n\t}\n}\n\nexport { RenderTarget };\n", "class WebgpuBindGroup {\n\tconstructor() {\n\t\tthis.bindGroup = void 0;\n\t}\n\tupdate(bindGroup) {\n\t\tthis.destroy();\n\t\tconst device = bindGroup.device;\n\t\tconst descr = this.createDescriptor(device, bindGroup);\n\t\tthis.bindGroup = device.wgpu.createBindGroup(descr);\n\t}\n\tdestroy() {\n\t\tthis.bindGroup = null;\n\t}\n\tcreateDescriptor(device, bindGroup) {\n\t\tconst entries = [];\n\t\tconst format = bindGroup.format;\n\t\tconst uniformBufferFormats = bindGroup.format.uniformBufferFormats;\n\t\tbindGroup.uniformBuffers.forEach((ub, i) => {\n\t\t\tconst slot = uniformBufferFormats[i].slot;\n\t\t\tconst buffer = ub.persistent ? ub.impl.buffer : ub.allocation.gpuBuffer.buffer;\n\t\t\tentries.push({\n\t\t\t\tbinding: slot,\n\t\t\t\tresource: {\n\t\t\t\t\tbuffer: buffer,\n\t\t\t\t\toffset: 0,\n\t\t\t\t\tsize: ub.format.byteSize\n\t\t\t\t}\n\t\t\t});\n\t\t});\n\t\tconst textureFormats = bindGroup.format.textureFormats;\n\t\tbindGroup.textures.forEach((tex, textureIndex) => {\n\t\t\tconst wgpuTexture = tex.impl;\n\t\t\tconst textureFormat = format.textureFormats[textureIndex];\n\t\t\tconst slot = textureFormats[textureIndex].slot;\n\t\t\tconst view = wgpuTexture.getView(device);\n\t\t\tentries.push({\n\t\t\t\tbinding: slot,\n\t\t\t\tresource: view\n\t\t\t});\n\t\t\tif (textureFormat.hasSampler) {\n\t\t\t\tconst sampler = wgpuTexture.getSampler(device, textureFormat.sampleType);\n\t\t\t\tentries.push({\n\t\t\t\t\tbinding: slot + 1,\n\t\t\t\t\tresource: sampler\n\t\t\t\t});\n\t\t\t}\n\t\t});\n\t\tconst storageTextureFormats = bindGroup.format.storageTextureFormats;\n\t\tbindGroup.storageTextures.forEach((tex, textureIndex) => {\n\t\t\tconst wgpuTexture = tex.impl;\n\t\t\tconst slot = storageTextureFormats[textureIndex].slot;\n\t\t\tconst view = wgpuTexture.getView(device);\n\t\t\tentries.push({\n\t\t\t\tbinding: slot,\n\t\t\t\tresource: view\n\t\t\t});\n\t\t});\n\t\tconst storageBufferFormats = bindGroup.format.storageBufferFormats;\n\t\tbindGroup.storageBuffers.forEach((buffer, bufferIndex) => {\n\t\t\tconst wgpuBuffer = buffer.impl.buffer;\n\t\t\tconst slot = storageBufferFormats[bufferIndex].slot;\n\t\t\tentries.push({\n\t\t\t\tbinding: slot,\n\t\t\t\tresource: {\n\t\t\t\t\tbuffer: wgpuBuffer\n\t\t\t\t}\n\t\t\t});\n\t\t});\n\t\tconst descr = {\n\t\t\tlayout: bindGroup.format.impl.bindGroupLayout,\n\t\t\tentries: entries\n\t\t};\n\t\treturn descr;\n\t}\n}\n\nexport { WebgpuBindGroup };\n", "import { SHADERSTAGE_VERTEX, SHADERSTAGE_FRAGMENT, SHADERSTAGE_COMPUTE } from '../constants.js';\n\nclass WebgpuUtils {\n\tstatic shaderStage(stage) {\n\t\tlet ret = 0;\n\t\tif (stage & SHADERSTAGE_VERTEX) ret |= GPUShaderStage.VERTEX;\n\t\tif (stage & SHADERSTAGE_FRAGMENT) ret |= GPUShaderStage.FRAGMENT;\n\t\tif (stage & SHADERSTAGE_COMPUTE) ret |= GPUShaderStage.COMPUTE;\n\t\treturn ret;\n\t}\n}\n\nexport { WebgpuUtils };\n", "import { PIXELFORMAT_A8, PIXELFORMAT_L8, PIXELFORMAT_LA8, PIXELFORMAT_RGB565, PIXELFORMAT_RGBA5551, PIXELFORMAT_RGBA4, PIXELFORMAT_RGB8, PIXELFORMAT_RGBA8, PIXELFORMAT_DXT1, PIXELFORMAT_DXT3, PIXELFORMAT_DXT5, PIXELFORMAT_RGB16F, PIXELFORMAT_RGBA16F, PIXELFORMAT_R16F, PIXELFORMAT_RG16F, PIXELFORMAT_RGB32F, PIXELFORMAT_RGBA32F, PIXELFORMAT_R32F, PIXELFORMAT_DEPTH, PIXELFORMAT_DEPTHSTENCIL, PIXELFORMAT_111110F, PIXELFORMAT_SRGB, PIXELFORMAT_SRGBA, PIXELFORMAT_ETC1, PIXELFORMAT_ETC2_RGB, PIXELFORMAT_ETC2_RGBA, PIXELFORMAT_PVRTC_2BPP_RGB_1, PIXELFORMAT_PVRTC_2BPP_RGBA_1, PIXELFORMAT_PVRTC_4BPP_RGB_1, PIXELFORMAT_PVRTC_4BPP_RGBA_1, PIXELFORMAT_ASTC_4x4, PIXELFORMAT_ATC_RGB, PIXELFORMAT_ATC_RGBA, PIXELFORMAT_BGRA8, PIXELFORMAT_R8I, PIXELFORMAT_R8U, PIXELFORMAT_R16I, PIXELFORMAT_R16U, PIXELFORMAT_R32I, PIXELFORMAT_R32U, PIXELFORMAT_RG8I, PIXELFORMAT_RG8U, PIXELFORMAT_RG16I, PIXELFORMAT_RG16U, PIXELFORMAT_RG32I, PIXELFORMAT_RG32U, PIXELFORMAT_RGBA8I, PIXELFORMAT_RGBA8U, PIXELFORMAT_RGBA16I, PIXELFORMAT_RGBA16U, PIXELFORMAT_RGBA32I, PIXELFORMAT_RGBA32U } from '../constants.js';\n\nconst gpuTextureFormats = [];\ngpuTextureFormats[PIXELFORMAT_A8] = '';\ngpuTextureFormats[PIXELFORMAT_L8] = 'r8unorm';\ngpuTextureFormats[PIXELFORMAT_LA8] = 'rg8unorm';\ngpuTextureFormats[PIXELFORMAT_RGB565] = '';\ngpuTextureFormats[PIXELFORMAT_RGBA5551] = '';\ngpuTextureFormats[PIXELFORMAT_RGBA4] = '';\ngpuTextureFormats[PIXELFORMAT_RGB8] = 'rgba8unorm';\ngpuTextureFormats[PIXELFORMAT_RGBA8] = 'rgba8unorm';\ngpuTextureFormats[PIXELFORMAT_DXT1] = 'bc1-rgba-unorm';\ngpuTextureFormats[PIXELFORMAT_DXT3] = 'bc2-rgba-unorm';\ngpuTextureFormats[PIXELFORMAT_DXT5] = 'bc3-rgba-unorm';\ngpuTextureFormats[PIXELFORMAT_RGB16F] = '';\ngpuTextureFormats[PIXELFORMAT_RGBA16F] = 'rgba16float';\ngpuTextureFormats[PIXELFORMAT_R16F] = 'r16float';\ngpuTextureFormats[PIXELFORMAT_RG16F] = 'rg16float';\ngpuTextureFormats[PIXELFORMAT_RGB32F] = '';\ngpuTextureFormats[PIXELFORMAT_RGBA32F] = 'rgba32float';\ngpuTextureFormats[PIXELFORMAT_R32F] = 'r32float';\ngpuTextureFormats[PIXELFORMAT_DEPTH] = 'depth32float';\ngpuTextureFormats[PIXELFORMAT_DEPTHSTENCIL] = 'depth24plus-stencil8';\ngpuTextureFormats[PIXELFORMAT_111110F] = 'rg11b10ufloat';\ngpuTextureFormats[PIXELFORMAT_SRGB] = '';\ngpuTextureFormats[PIXELFORMAT_SRGBA] = '';\ngpuTextureFormats[PIXELFORMAT_ETC1] = '';\ngpuTextureFormats[PIXELFORMAT_ETC2_RGB] = 'etc2-rgb8unorm';\ngpuTextureFormats[PIXELFORMAT_ETC2_RGBA] = 'etc2-rgba8unorm';\ngpuTextureFormats[PIXELFORMAT_PVRTC_2BPP_RGB_1] = '';\ngpuTextureFormats[PIXELFORMAT_PVRTC_2BPP_RGBA_1] = '';\ngpuTextureFormats[PIXELFORMAT_PVRTC_4BPP_RGB_1] = '';\ngpuTextureFormats[PIXELFORMAT_PVRTC_4BPP_RGBA_1] = '';\ngpuTextureFormats[PIXELFORMAT_ASTC_4x4] = 'astc-4x4-unorm';\ngpuTextureFormats[PIXELFORMAT_ATC_RGB] = '';\ngpuTextureFormats[PIXELFORMAT_ATC_RGBA] = '';\ngpuTextureFormats[PIXELFORMAT_BGRA8] = 'bgra8unorm';\ngpuTextureFormats[PIXELFORMAT_R8I] = 'r8sint';\ngpuTextureFormats[PIXELFORMAT_R8U] = 'r8uint';\ngpuTextureFormats[PIXELFORMAT_R16I] = 'r16sint';\ngpuTextureFormats[PIXELFORMAT_R16U] = 'r16uint';\ngpuTextureFormats[PIXELFORMAT_R32I] = 'r32sint';\ngpuTextureFormats[PIXELFORMAT_R32U] = 'r32uint';\ngpuTextureFormats[PIXELFORMAT_RG8I] = 'rg8sint';\ngpuTextureFormats[PIXELFORMAT_RG8U] = 'rg8uint';\ngpuTextureFormats[PIXELFORMAT_RG16I] = 'rg16sint';\ngpuTextureFormats[PIXELFORMAT_RG16U] = 'rg16uint';\ngpuTextureFormats[PIXELFORMAT_RG32I] = 'rg32sint';\ngpuTextureFormats[PIXELFORMAT_RG32U] = 'rg32uint';\ngpuTextureFormats[PIXELFORMAT_RGBA8I] = 'rgba8sint';\ngpuTextureFormats[PIXELFORMAT_RGBA8U] = 'rgba8uint';\ngpuTextureFormats[PIXELFORMAT_RGBA16I] = 'rgba16sint';\ngpuTextureFormats[PIXELFORMAT_RGBA16U] = 'rgba16uint';\ngpuTextureFormats[PIXELFORMAT_RGBA32I] = 'rgba32sint';\ngpuTextureFormats[PIXELFORMAT_RGBA32U] = 'rgba32uint';\n\nexport { gpuTextureFormats };\n", "import { StringIds } from '../../../core/string-ids.js';\nimport { SAMPLETYPE_FLOAT, SAMPLETYPE_UNFILTERABLE_FLOAT, SAMPLETYPE_DEPTH, SAMPLETYPE_INT, SAMPLETYPE_UINT } from '../constants.js';\nimport { WebgpuUtils } from './webgpu-utils.js';\nimport { gpuTextureFormats } from './constants.js';\n\nconst samplerTypes = [];\nsamplerTypes[SAMPLETYPE_FLOAT] = 'filtering';\nsamplerTypes[SAMPLETYPE_UNFILTERABLE_FLOAT] = 'non-filtering';\nsamplerTypes[SAMPLETYPE_DEPTH] = 'comparison';\nsamplerTypes[SAMPLETYPE_INT] = 'comparison';\nsamplerTypes[SAMPLETYPE_UINT] = 'comparison';\nconst sampleTypes = [];\nsampleTypes[SAMPLETYPE_FLOAT] = 'float';\nsampleTypes[SAMPLETYPE_UNFILTERABLE_FLOAT] = 'unfilterable-float';\nsampleTypes[SAMPLETYPE_DEPTH] = 'depth';\nsampleTypes[SAMPLETYPE_INT] = 'sint';\nsampleTypes[SAMPLETYPE_UINT] = 'uint';\nconst stringIds = new StringIds();\nclass WebgpuBindGroupFormat {\n\tconstructor(bindGroupFormat) {\n\t\tconst device = bindGroupFormat.device;\n\t\tconst {\n\t\t\tkey,\n\t\t\tdescr\n\t\t} = this.createDescriptor(bindGroupFormat);\n\t\tthis.key = stringIds.get(key);\n\t\tthis.bindGroupLayout = device.wgpu.createBindGroupLayout(descr);\n\t}\n\tdestroy() {\n\t\tthis.bindGroupLayout = null;\n\t}\n\tloseContext() {}\n\tcreateDescriptor(bindGroupFormat) {\n\t\tconst entries = [];\n\t\tlet key = '';\n\t\tbindGroupFormat.uniformBufferFormats.forEach(bufferFormat => {\n\t\t\tconst visibility = WebgpuUtils.shaderStage(bufferFormat.visibility);\n\t\t\tkey += `#${bufferFormat.slot}U:${visibility}`;\n\t\t\tentries.push({\n\t\t\t\tbinding: bufferFormat.slot,\n\t\t\t\tvisibility: visibility,\n\t\t\t\tbuffer: {\n\t\t\t\t\ttype: 'uniform',\n\t\t\t\t\thasDynamicOffset: true\n\t\t\t\t}\n\t\t\t});\n\t\t});\n\t\tbindGroupFormat.textureFormats.forEach(textureFormat => {\n\t\t\tconst visibility = WebgpuUtils.shaderStage(textureFormat.visibility);\n\t\t\tconst sampleType = textureFormat.sampleType;\n\t\t\tconst viewDimension = textureFormat.textureDimension;\n\t\t\tconst multisampled = false;\n\t\t\tconst gpuSampleType = sampleTypes[sampleType];\n\t\t\tkey += `#${textureFormat.slot}T:${visibility}-${gpuSampleType}-${viewDimension}-${multisampled}`;\n\t\t\tentries.push({\n\t\t\t\tbinding: textureFormat.slot,\n\t\t\t\tvisibility: visibility,\n\t\t\t\ttexture: {\n\t\t\t\t\tsampleType: gpuSampleType,\n\t\t\t\t\tviewDimension: viewDimension,\n\t\t\t\t\tmultisampled: multisampled\n\t\t\t\t}\n\t\t\t});\n\t\t\tif (textureFormat.hasSampler) {\n\t\t\t\tconst gpuSamplerType = samplerTypes[sampleType];\n\t\t\t\tkey += `#${textureFormat.slot + 1}S:${visibility}-${gpuSamplerType}`;\n\t\t\t\tentries.push({\n\t\t\t\t\tbinding: textureFormat.slot + 1,\n\t\t\t\t\tvisibility: visibility,\n\t\t\t\t\tsampler: {\n\t\t\t\t\t\ttype: gpuSamplerType\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t}\n\t\t});\n\t\tbindGroupFormat.storageTextureFormats.forEach(textureFormat => {\n\t\t\tconst {\n\t\t\t\tformat,\n\t\t\t\ttextureDimension\n\t\t\t} = textureFormat;\n\t\t\tconst {\n\t\t\t\tread,\n\t\t\t\twrite\n\t\t\t} = textureFormat;\n\t\t\tkey += `#${textureFormat.slot}ST:${format}-${textureDimension}-${read ? 'r1' : 'r0'}-${write ? 'w1' : 'w0'}`;\n\t\t\tentries.push({\n\t\t\t\tbinding: textureFormat.slot,\n\t\t\t\tvisibility: GPUShaderStage.COMPUTE,\n\t\t\t\tstorageTexture: {\n\t\t\t\t\taccess: read ? write ? 'read-write' : 'read-only' : 'write-only',\n\t\t\t\t\tformat: gpuTextureFormats[format],\n\t\t\t\t\tviewDimension: textureDimension\n\t\t\t\t}\n\t\t\t});\n\t\t});\n\t\tbindGroupFormat.storageBufferFormats.forEach(bufferFormat => {\n\t\t\tconst readOnly = bufferFormat.readOnly;\n\t\t\tconst visibility = WebgpuUtils.shaderStage(bufferFormat.visibility);\n\t\t\tkey += `#${bufferFormat.slot}SB:${visibility}-${readOnly ? 'ro' : 'rw'}`;\n\t\t\tentries.push({\n\t\t\t\tbinding: bufferFormat.slot,\n\t\t\t\tvisibility: visibility,\n\t\t\t\tbuffer: {\n\t\t\t\t\ttype: readOnly ? 'read-only-storage' : 'storage'\n\t\t\t\t}\n\t\t\t});\n\t\t});\n\t\tconst descr = {\n\t\t\tentries: entries\n\t\t};\n\t\treturn {\n\t\t\tkey,\n\t\t\tdescr\n\t\t};\n\t}\n}\n\nexport { WebgpuBindGroupFormat };\n", "class WebgpuBuffer {\n\tconstructor(usageFlags = 0) {\n\t\tthis.buffer = null;\n\t\tthis.usageFlags = 0;\n\t\tthis.usageFlags = usageFlags;\n\t}\n\tdestroy(device) {\n\t\tif (this.buffer) {\n\t\t\tthis.buffer.destroy();\n\t\t\tthis.buffer = null;\n\t\t}\n\t}\n\tget initialized() {\n\t\treturn !!this.buffer;\n\t}\n\tloseContext() {}\n\tallocate(device, size) {\n\t\tthis.buffer = device.wgpu.createBuffer({\n\t\t\tsize,\n\t\t\tusage: this.usageFlags\n\t\t});\n\t}\n\tunlock(device, storage) {\n\t\tvar _storage$byteOffset, _storage$buffer;\n\t\tconst wgpu = device.wgpu;\n\t\tif (!this.buffer) {\n\t\t\tconst size = storage.byteLength + 3 & ~3;\n\t\t\tthis.usageFlags |= GPUBufferUsage.COPY_DST;\n\t\t\tthis.allocate(device, size);\n\t\t}\n\t\tconst srcOffset = (_storage$byteOffset = storage.byteOffset) != null ? _storage$byteOffset : 0;\n\t\tconst srcData = new Uint8Array((_storage$buffer = storage.buffer) != null ? _storage$buffer : storage, srcOffset, storage.byteLength);\n\t\tconst data = new Uint8Array(this.buffer.size);\n\t\tdata.set(srcData);\n\t\twgpu.queue.writeBuffer(this.buffer, 0, data, 0, data.length);\n\t}\n\tread(device, offset, size, data) {\n\t\treturn device.readStorageBuffer(this, offset, size, data);\n\t}\n\twrite(device, bufferOffset, data, dataOffset, size) {\n\t\tdevice.writeStorageBuffer(this, bufferOffset, data, dataOffset, size);\n\t}\n\tclear(device, offset, size) {\n\t\tdevice.clearStorageBuffer(this, offset, size);\n\t}\n}\n\nexport { WebgpuBuffer };\n", "import { BUFFERUSAGE_INDEX, BUFFERUSAGE_STORAGE, INDEXFORMAT_UINT16 } from '../constants.js';\nimport { WebgpuBuffer } from './webgpu-buffer.js';\n\nclass WebgpuIndexBuffer extends WebgpuBuffer {\n\tconstructor(indexBuffer, options) {\n\t\tsuper(BUFFERUSAGE_INDEX | (options != null && options.storage ? BUFFERUSAGE_STORAGE : 0));\n\t\tthis.format = null;\n\t\tthis.format = indexBuffer.format === INDEXFORMAT_UINT16 ? \"uint16\" : \"uint32\";\n\t}\n\tunlock(indexBuffer) {\n\t\tconst device = indexBuffer.device;\n\t\tsuper.unlock(device, indexBuffer.storage);\n\t}\n}\n\nexport { WebgpuIndexBuffer };\n", "const array = {\n\tequals(arr1, arr2) {\n\t\tif (arr1.length !== arr2.length) {\n\t\t\treturn false;\n\t\t}\n\t\tfor (let i = 0; i < arr1.length; i++) {\n\t\t\tif (arr1[i] !== arr2[i]) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\t\treturn true;\n\t}\n};\n\nexport { array };\n", "import { semanticToLocation, TYPE_INT8, TYPE_UINT8, TYPE_INT16, TYPE_UINT16, TYPE_INT32, TYPE_UINT32, TYPE_FLOAT32, TYPE_FLOAT16 } from '../constants.js';\n\nconst gpuVertexFormats = [];\ngpuVertexFormats[TYPE_INT8] = 'sint8';\ngpuVertexFormats[TYPE_UINT8] = 'uint8';\ngpuVertexFormats[TYPE_INT16] = 'sint16';\ngpuVertexFormats[TYPE_UINT16] = 'uint16';\ngpuVertexFormats[TYPE_INT32] = 'sint32';\ngpuVertexFormats[TYPE_UINT32] = 'uint32';\ngpuVertexFormats[TYPE_FLOAT32] = 'float32';\ngpuVertexFormats[TYPE_FLOAT16] = 'float16';\nconst gpuVertexFormatsNormalized = [];\ngpuVertexFormatsNormalized[TYPE_INT8] = 'snorm8';\ngpuVertexFormatsNormalized[TYPE_UINT8] = 'unorm8';\ngpuVertexFormatsNormalized[TYPE_INT16] = 'snorm16';\ngpuVertexFormatsNormalized[TYPE_UINT16] = 'unorm16';\ngpuVertexFormatsNormalized[TYPE_INT32] = 'sint32';\ngpuVertexFormatsNormalized[TYPE_UINT32] = 'uint32';\ngpuVertexFormatsNormalized[TYPE_FLOAT32] = 'float32';\ngpuVertexFormatsNormalized[TYPE_FLOAT16] = 'float16';\nclass WebgpuVertexBufferLayout {\n\tconstructor() {\n\t\tthis.cache = new Map();\n\t}\n\tget(vertexFormat0, vertexFormat1 = null) {\n\t\tconst key = this.getKey(vertexFormat0, vertexFormat1);\n\t\tlet layout = this.cache.get(key);\n\t\tif (!layout) {\n\t\t\tlayout = this.create(vertexFormat0, vertexFormat1);\n\t\t\tthis.cache.set(key, layout);\n\t\t}\n\t\treturn layout;\n\t}\n\tgetKey(vertexFormat0, vertexFormat1 = null) {\n\t\treturn `${vertexFormat0 == null ? void 0 : vertexFormat0.renderingHashString}-${vertexFormat1 == null ? void 0 : vertexFormat1.renderingHashString}`;\n\t}\n\tcreate(vertexFormat0, vertexFormat1) {\n\t\tconst layout = [];\n\t\tconst addFormat = format => {\n\t\t\tconst interleaved = format.interleaved;\n\t\t\tconst stepMode = format.instancing ? 'instance' : 'vertex';\n\t\t\tlet attributes = [];\n\t\t\tconst elementCount = format.elements.length;\n\t\t\tfor (let i = 0; i < elementCount; i++) {\n\t\t\t\tconst element = format.elements[i];\n\t\t\t\tconst location = semanticToLocation[element.name];\n\t\t\t\tconst formatTable = element.normalize ? gpuVertexFormatsNormalized : gpuVertexFormats;\n\t\t\t\tattributes.push({\n\t\t\t\t\tshaderLocation: location,\n\t\t\t\t\toffset: interleaved ? element.offset : 0,\n\t\t\t\t\tformat: `${formatTable[element.dataType]}${element.numComponents > 1 ? 'x' + element.numComponents : ''}`\n\t\t\t\t});\n\t\t\t\tif (!interleaved || i === elementCount - 1) {\n\t\t\t\t\tlayout.push({\n\t\t\t\t\t\tattributes: attributes,\n\t\t\t\t\t\tarrayStride: element.stride,\n\t\t\t\t\t\tstepMode: stepMode\n\t\t\t\t\t});\n\t\t\t\t\tattributes = [];\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t\tif (vertexFormat0) addFormat(vertexFormat0);\n\t\tif (vertexFormat1) addFormat(vertexFormat1);\n\t\treturn layout;\n\t}\n}\n\nexport { WebgpuVertexBufferLayout };\n", "class WebgpuPipeline {\n\tconstructor(device) {\n\t\tthis.device = device;\n\t}\n\tgetPipelineLayout(bindGroupFormats) {\n\t\tconst bindGroupLayouts = [];\n\t\tbindGroupFormats.forEach(format => {\n\t\t\tbindGroupLayouts.push(format.bindGroupLayout);\n\t\t});\n\t\tconst descr = {\n\t\t\tbindGroupLayouts: bindGroupLayouts\n\t\t};\n\t\tconst pipelineLayout = this.device.wgpu.createPipelineLayout(descr);\n\t\treturn pipelineLayout;\n\t}\n}\n\nexport { WebgpuPipeline };\n", "import { hash32Fnv1a } from '../../../core/hash.js';\nimport { array } from '../../../core/array-utils.js';\nimport { WebgpuVertexBufferLayout } from './webgpu-vertex-buffer-layout.js';\nimport { WebgpuPipeline } from './webgpu-pipeline.js';\n\nconst _primitiveTopology = ['point-list', 'line-list', undefined, 'line-strip', 'triangle-list', 'triangle-strip', undefined];\nconst _blendOperation = ['add', 'subtract', 'reverse-subtract', 'min', 'max'];\nconst _blendFactor = ['zero', 'one', 'src', 'one-minus-src', 'dst', 'one-minus-dst', 'src-alpha', 'src-alpha-saturated', 'one-minus-src-alpha', 'dst-alpha', 'one-minus-dst-alpha', 'constant', 'one-minus-constant'];\nconst _compareFunction = ['never', 'less', 'equal', 'less-equal', 'greater', 'not-equal', 'greater-equal', 'always'];\nconst _cullModes = ['none', 'back', 'front'];\nconst _stencilOps = ['keep', 'zero', 'replace', 'increment-clamp', 'increment-wrap', 'decrement-clamp', 'decrement-wrap', 'invert'];\nclass CacheEntry {\n\tconstructor() {\n\t\tthis.pipeline = void 0;\n\t\tthis.hashes = void 0;\n\t}\n}\nclass WebgpuRenderPipeline extends WebgpuPipeline {\n\tconstructor(device) {\n\t\tsuper(device);\n\t\tthis.lookupHashes = new Uint32Array(13);\n\t\tthis.vertexBufferLayout = new WebgpuVertexBufferLayout();\n\t\tthis.cache = new Map();\n\t}\n\tget(primitive, vertexFormat0, vertexFormat1, shader, renderTarget, bindGroupFormats, blendState, depthState, cullMode, stencilEnabled, stencilFront, stencilBack) {\n\t\tvar _vertexFormat0$render, _vertexFormat1$render, _bindGroupFormats$0$k, _bindGroupFormats$, _bindGroupFormats$1$k, _bindGroupFormats$2, _bindGroupFormats$2$k, _bindGroupFormats$3;\n\t\tconst lookupHashes = this.lookupHashes;\n\t\tlookupHashes[0] = primitive.type;\n\t\tlookupHashes[1] = shader.id;\n\t\tlookupHashes[2] = cullMode;\n\t\tlookupHashes[3] = depthState.key;\n\t\tlookupHashes[4] = blendState.key;\n\t\tlookupHashes[5] = (_vertexFormat0$render = vertexFormat0 == null ? void 0 : vertexFormat0.renderingHash) != null ? _vertexFormat0$render : 0;\n\t\tlookupHashes[6] = (_vertexFormat1$render = vertexFormat1 == null ? void 0 : vertexFormat1.renderingHash) != null ? _vertexFormat1$render : 0;\n\t\tlookupHashes[7] = renderTarget.impl.key;\n\t\tlookupHashes[8] = (_bindGroupFormats$0$k = (_bindGroupFormats$ = bindGroupFormats[0]) == null ? void 0 : _bindGroupFormats$.key) != null ? _bindGroupFormats$0$k : 0;\n\t\tlookupHashes[9] = (_bindGroupFormats$1$k = (_bindGroupFormats$2 = bindGroupFormats[1]) == null ? void 0 : _bindGroupFormats$2.key) != null ? _bindGroupFormats$1$k : 0;\n\t\tlookupHashes[10] = (_bindGroupFormats$2$k = (_bindGroupFormats$3 = bindGroupFormats[2]) == null ? void 0 : _bindGroupFormats$3.key) != null ? _bindGroupFormats$2$k : 0;\n\t\tlookupHashes[11] = stencilEnabled ? stencilFront.key : 0;\n\t\tlookupHashes[12] = stencilEnabled ? stencilBack.key : 0;\n\t\tconst hash = hash32Fnv1a(lookupHashes);\n\t\tlet cacheEntries = this.cache.get(hash);\n\t\tif (cacheEntries) {\n\t\t\tfor (let i = 0; i < cacheEntries.length; i++) {\n\t\t\t\tconst entry = cacheEntries[i];\n\t\t\t\tif (array.equals(entry.hashes, lookupHashes)) {\n\t\t\t\t\treturn entry.pipeline;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tconst primitiveTopology = _primitiveTopology[primitive.type];\n\t\tconst pipelineLayout = this.getPipelineLayout(bindGroupFormats);\n\t\tconst vertexBufferLayout = this.vertexBufferLayout.get(vertexFormat0, vertexFormat1);\n\t\tconst cacheEntry = new CacheEntry();\n\t\tcacheEntry.hashes = new Uint32Array(lookupHashes);\n\t\tcacheEntry.pipeline = this.create(primitiveTopology, shader, renderTarget, pipelineLayout, blendState, depthState, vertexBufferLayout, cullMode, stencilEnabled, stencilFront, stencilBack);\n\t\tif (cacheEntries) {\n\t\t\tcacheEntries.push(cacheEntry);\n\t\t} else {\n\t\t\tcacheEntries = [cacheEntry];\n\t\t}\n\t\tthis.cache.set(hash, cacheEntries);\n\t\treturn cacheEntry.pipeline;\n\t}\n\tgetBlend(blendState) {\n\t\tlet blend;\n\t\tif (blendState.blend) {\n\t\t\tblend = {\n\t\t\t\tcolor: {\n\t\t\t\t\toperation: _blendOperation[blendState.colorOp],\n\t\t\t\t\tsrcFactor: _blendFactor[blendState.colorSrcFactor],\n\t\t\t\t\tdstFactor: _blendFactor[blendState.colorDstFactor]\n\t\t\t\t},\n\t\t\t\talpha: {\n\t\t\t\t\toperation: _blendOperation[blendState.alphaOp],\n\t\t\t\t\tsrcFactor: _blendFactor[blendState.alphaSrcFactor],\n\t\t\t\t\tdstFactor: _blendFactor[blendState.alphaDstFactor]\n\t\t\t\t}\n\t\t\t};\n\t\t}\n\t\treturn blend;\n\t}\n\tgetDepthStencil(depthState, renderTarget, stencilEnabled, stencilFront, stencilBack) {\n\t\tlet depthStencil;\n\t\tconst {\n\t\t\tdepth,\n\t\t\tstencil\n\t\t} = renderTarget;\n\t\tif (depth || stencil) {\n\t\t\tdepthStencil = {\n\t\t\t\tformat: renderTarget.impl.depthFormat\n\t\t\t};\n\t\t\tif (depth) {\n\t\t\t\tdepthStencil.depthWriteEnabled = depthState.write;\n\t\t\t\tdepthStencil.depthCompare = _compareFunction[depthState.func];\n\t\t\t\tdepthStencil.depthBias = depthState.depthBias;\n\t\t\t\tdepthStencil.depthBiasSlopeScale = depthState.depthBiasSlope;\n\t\t\t} else {\n\t\t\t\tdepthStencil.depthWriteEnabled = false;\n\t\t\t\tdepthStencil.depthCompare = 'always';\n\t\t\t}\n\t\t\tif (stencil && stencilEnabled) {\n\t\t\t\tdepthStencil.stencilReadMas = stencilFront.readMask;\n\t\t\t\tdepthStencil.stencilWriteMask = stencilFront.writeMask;\n\t\t\t\tdepthStencil.stencilFront = {\n\t\t\t\t\tcompare: _compareFunction[stencilFront.func],\n\t\t\t\t\tfailOp: _stencilOps[stencilFront.fail],\n\t\t\t\t\tpassOp: _stencilOps[stencilFront.zpass],\n\t\t\t\t\tdepthFailOp: _stencilOps[stencilFront.zfail]\n\t\t\t\t};\n\t\t\t\tdepthStencil.stencilBack = {\n\t\t\t\t\tcompare: _compareFunction[stencilBack.func],\n\t\t\t\t\tfailOp: _stencilOps[stencilBack.fail],\n\t\t\t\t\tpassOp: _stencilOps[stencilBack.zpass],\n\t\t\t\t\tdepthFailOp: _stencilOps[stencilBack.zfail]\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\t\treturn depthStencil;\n\t}\n\tcreate(primitiveTopology, shader, renderTarget, pipelineLayout, blendState, depthState, vertexBufferLayout, cullMode, stencilEnabled, stencilFront, stencilBack) {\n\t\tconst wgpu = this.device.wgpu;\n\t\tconst webgpuShader = shader.impl;\n\t\tconst descr = {\n\t\t\tvertex: {\n\t\t\t\tmodule: webgpuShader.getVertexShaderModule(),\n\t\t\t\tentryPoint: webgpuShader.vertexEntryPoint,\n\t\t\t\tbuffers: vertexBufferLayout\n\t\t\t},\n\t\t\tprimitive: {\n\t\t\t\ttopology: primitiveTopology,\n\t\t\t\tfrontFace: 'ccw',\n\t\t\t\tcullMode: _cullModes[cullMode]\n\t\t\t},\n\t\t\tdepthStencil: this.getDepthStencil(depthState, renderTarget, stencilEnabled, stencilFront, stencilBack),\n\t\t\tmultisample: {\n\t\t\t\tcount: renderTarget.samples\n\t\t\t},\n\t\t\tlayout: pipelineLayout\n\t\t};\n\t\tdescr.fragment = {\n\t\t\tmodule: webgpuShader.getFragmentShaderModule(),\n\t\t\tentryPoint: webgpuShader.fragmentEntryPoint,\n\t\t\ttargets: []\n\t\t};\n\t\tconst colorAttachments = renderTarget.impl.colorAttachments;\n\t\tif (colorAttachments.length > 0) {\n\t\t\tlet writeMask = 0;\n\t\t\tif (blendState.redWrite) writeMask |= GPUColorWrite.RED;\n\t\t\tif (blendState.greenWrite) writeMask |= GPUColorWrite.GREEN;\n\t\t\tif (blendState.blueWrite) writeMask |= GPUColorWrite.BLUE;\n\t\t\tif (blendState.alphaWrite) writeMask |= GPUColorWrite.ALPHA;\n\t\t\tconst blend = this.getBlend(blendState);\n\t\t\tcolorAttachments.forEach(attachment => {\n\t\t\t\tdescr.fragment.targets.push({\n\t\t\t\t\tformat: attachment.format,\n\t\t\t\t\twriteMask: writeMask,\n\t\t\t\t\tblend: blend\n\t\t\t\t});\n\t\t\t});\n\t\t}\n\t\tconst pipeline = wgpu.createRenderPipeline(descr);\n\t\treturn pipeline;\n\t}\n}\n\nexport { WebgpuRenderPipeline };\n", "import { WebgpuPipeline } from './webgpu-pipeline.js';\n\nclass WebgpuComputePipeline extends WebgpuPipeline {\n\tget(shader, bindGroupFormat) {\n\t\tconst pipelineLayout = this.getPipelineLayout([bindGroupFormat.impl]);\n\t\tconst pipeline = this.create(shader, pipelineLayout);\n\t\treturn pipeline;\n\t}\n\tcreate(shader, pipelineLayout) {\n\t\tconst wgpu = this.device.wgpu;\n\t\tconst webgpuShader = shader.impl;\n\t\tconst descr = {\n\t\t\tcompute: {\n\t\t\t\tmodule: webgpuShader.getComputeShaderModule(),\n\t\t\t\tentryPoint: webgpuShader.computeEntryPoint\n\t\t\t},\n\t\t\tlayout: pipelineLayout\n\t\t};\n\t\tconst pipeline = wgpu.createComputePipeline(descr);\n\t\treturn pipeline;\n\t}\n}\n\nexport { WebgpuComputePipeline };\n", "import { StringIds } from '../../../core/string-ids.js';\n\nconst stringIds = new StringIds();\nclass ColorAttachment {\n\tconstructor() {\n\t\tthis.format = void 0;\n\t\tthis.multisampledBuffer = void 0;\n\t}\n\tdestroy() {\n\t\tvar _this$multisampledBuf;\n\t\t(_this$multisampledBuf = this.multisampledBuffer) == null || _this$multisampledBuf.destroy();\n\t\tthis.multisampledBuffer = null;\n\t}\n}\nclass WebgpuRenderTarget {\n\tconstructor(renderTarget) {\n\t\tthis.initialized = false;\n\t\tthis.key = void 0;\n\t\tthis.colorAttachments = [];\n\t\tthis.depthFormat = void 0;\n\t\tthis.hasStencil = void 0;\n\t\tthis.depthTexture = null;\n\t\tthis.depthTextureInternal = false;\n\t\tthis.assignedColorTexture = null;\n\t\tthis.renderPassDescriptor = {};\n\t\tthis.renderTarget = renderTarget;\n\t\tif (renderTarget._colorBuffers) {\n\t\t\trenderTarget._colorBuffers.forEach((colorBuffer, index) => {\n\t\t\t\tthis.setColorAttachment(index, undefined, colorBuffer.impl.format);\n\t\t\t});\n\t\t}\n\t\tthis.updateKey();\n\t}\n\tdestroy(device) {\n\t\tthis.initialized = false;\n\t\tif (this.depthTextureInternal) {\n\t\t\tvar _this$depthTexture;\n\t\t\t(_this$depthTexture = this.depthTexture) == null || _this$depthTexture.destroy();\n\t\t\tthis.depthTexture = null;\n\t\t}\n\t\tthis.assignedColorTexture = null;\n\t\tthis.colorAttachments.forEach(colorAttachment => {\n\t\t\tcolorAttachment.destroy();\n\t\t});\n\t\tthis.colorAttachments.length = 0;\n\t}\n\tupdateKey() {\n\t\tconst rt = this.renderTarget;\n\t\tlet key = `${rt.samples}:${rt.depth ? this.depthFormat : 'nodepth'}`;\n\t\tthis.colorAttachments.forEach(colorAttachment => {\n\t\t\tkey += `:${colorAttachment.format}`;\n\t\t});\n\t\tthis.key = stringIds.get(key);\n\t}\n\tsetDepthFormat(depthFormat) {\n\t\tthis.depthFormat = depthFormat;\n\t\tthis.hasStencil = depthFormat === 'depth24plus-stencil8';\n\t}\n\tassignColorTexture(gpuTexture) {\n\t\tthis.assignedColorTexture = gpuTexture;\n\t\tconst view = gpuTexture.createView();\n\t\tconst colorAttachment = this.renderPassDescriptor.colorAttachments[0];\n\t\tconst samples = this.renderTarget.samples;\n\t\tif (samples > 1) {\n\t\t\tcolorAttachment.resolveTarget = view;\n\t\t} else {\n\t\t\tcolorAttachment.view = view;\n\t\t}\n\t\tthis.setColorAttachment(0, undefined, gpuTexture.format);\n\t\tthis.updateKey();\n\t}\n\tsetColorAttachment(index, multisampledBuffer, format) {\n\t\tif (!this.colorAttachments[index]) {\n\t\t\tthis.colorAttachments[index] = new ColorAttachment();\n\t\t}\n\t\tif (multisampledBuffer) {\n\t\t\tthis.colorAttachments[index].multisampledBuffer = multisampledBuffer;\n\t\t}\n\t\tif (format) {\n\t\t\tthis.colorAttachments[index].format = format;\n\t\t}\n\t}\n\tinit(device, renderTarget) {\n\t\tvar _renderTarget$_colorB, _renderTarget$_colorB2;\n\t\tconst wgpu = device.wgpu;\n\t\tthis.initDepthStencil(wgpu, renderTarget);\n\t\tthis.renderPassDescriptor.colorAttachments = [];\n\t\tconst count = (_renderTarget$_colorB = (_renderTarget$_colorB2 = renderTarget._colorBuffers) == null ? void 0 : _renderTarget$_colorB2.length) != null ? _renderTarget$_colorB : 1;\n\t\tfor (let i = 0; i < count; ++i) {\n\t\t\tvar _this$colorAttachment;\n\t\t\tconst colorAttachment = this.initColor(wgpu, renderTarget, i);\n\t\t\tconst isDefaultFramebuffer = i === 0 && ((_this$colorAttachment = this.colorAttachments[0]) == null ? void 0 : _this$colorAttachment.format);\n\t\t\tif (colorAttachment.view || isDefaultFramebuffer) {\n\t\t\t\tthis.renderPassDescriptor.colorAttachments.push(colorAttachment);\n\t\t\t}\n\t\t}\n\t\tthis.initialized = true;\n\t}\n\tinitDepthStencil(wgpu, renderTarget) {\n\t\tconst {\n\t\t\tsamples,\n\t\t\twidth,\n\t\t\theight,\n\t\t\tdepth,\n\t\t\tdepthBuffer\n\t\t} = renderTarget;\n\t\tif (depth || depthBuffer) {\n\t\t\tif (!depthBuffer) {\n\t\t\t\tthis.setDepthFormat('depth24plus-stencil8');\n\t\t\t\tconst depthTextureDesc = {\n\t\t\t\t\tsize: [width, height, 1],\n\t\t\t\t\tdimension: '2d',\n\t\t\t\t\tsampleCount: samples,\n\t\t\t\t\tformat: this.depthFormat,\n\t\t\t\t\tusage: GPUTextureUsage.RENDER_ATTACHMENT\n\t\t\t\t};\n\t\t\t\tif (samples > 1) {\n\t\t\t\t\tdepthTextureDesc.usage |= GPUTextureUsage.TEXTURE_BINDING;\n\t\t\t\t} else {\n\t\t\t\t\tdepthTextureDesc.usage |= GPUTextureUsage.COPY_SRC;\n\t\t\t\t}\n\t\t\t\tthis.depthTexture = wgpu.createTexture(depthTextureDesc);\n\t\t\t\tthis.depthTextureInternal = true;\n\t\t\t} else {\n\t\t\t\tthis.depthTexture = depthBuffer.impl.gpuTexture;\n\t\t\t\tthis.setDepthFormat(depthBuffer.impl.format);\n\t\t\t}\n\t\t\tthis.renderPassDescriptor.depthStencilAttachment = {\n\t\t\t\tview: this.depthTexture.createView()\n\t\t\t};\n\t\t}\n\t}\n\tinitColor(wgpu, renderTarget, index) {\n\t\tconst colorAttachment = {};\n\t\tconst {\n\t\t\tsamples,\n\t\t\twidth,\n\t\t\theight\n\t\t} = renderTarget;\n\t\tconst colorBuffer = renderTarget.getColorBuffer(index);\n\t\tlet colorView = null;\n\t\tif (colorBuffer) {\n\t\t\tconst mipLevelCount = 1;\n\t\t\tif (colorBuffer.cubemap) {\n\t\t\t\tcolorView = colorBuffer.impl.createView({\n\t\t\t\t\tdimension: '2d',\n\t\t\t\t\tbaseArrayLayer: renderTarget.face,\n\t\t\t\t\tarrayLayerCount: 1,\n\t\t\t\t\tmipLevelCount\n\t\t\t\t});\n\t\t\t} else {\n\t\t\t\tcolorView = colorBuffer.impl.createView({\n\t\t\t\t\tmipLevelCount\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t\tif (samples > 1) {\n\t\t\tvar _this$colorAttachment2, _this$colorAttachment3;\n\t\t\tconst multisampledTextureDesc = {\n\t\t\t\tsize: [width, height, 1],\n\t\t\t\tdimension: '2d',\n\t\t\t\tsampleCount: samples,\n\t\t\t\tformat: (_this$colorAttachment2 = (_this$colorAttachment3 = this.colorAttachments[index]) == null ? void 0 : _this$colorAttachment3.format) != null ? _this$colorAttachment2 : colorBuffer.impl.format,\n\t\t\t\tusage: GPUTextureUsage.RENDER_ATTACHMENT\n\t\t\t};\n\t\t\tconst multisampledColorBuffer = wgpu.createTexture(multisampledTextureDesc);\n\t\t\tthis.setColorAttachment(index, multisampledColorBuffer, multisampledTextureDesc.format);\n\t\t\tcolorAttachment.view = multisampledColorBuffer.createView();\n\t\t\tcolorAttachment.resolveTarget = colorView;\n\t\t} else {\n\t\t\tcolorAttachment.view = colorView;\n\t\t}\n\t\treturn colorAttachment;\n\t}\n\tsetupForRenderPass(renderPass) {\n\t\tvar _this$renderPassDescr, _this$renderPassDescr2;\n\t\tconst count = (_this$renderPassDescr = (_this$renderPassDescr2 = this.renderPassDescriptor.colorAttachments) == null ? void 0 : _this$renderPassDescr2.length) != null ? _this$renderPassDescr : 0;\n\t\tfor (let i = 0; i < count; ++i) {\n\t\t\tconst colorAttachment = this.renderPassDescriptor.colorAttachments[i];\n\t\t\tconst colorOps = renderPass.colorArrayOps[i];\n\t\t\tcolorAttachment.clearValue = colorOps.clearValue;\n\t\t\tcolorAttachment.loadOp = colorOps.clear ? 'clear' : 'load';\n\t\t\tcolorAttachment.storeOp = colorOps.store ? 'store' : 'discard';\n\t\t}\n\t\tconst depthAttachment = this.renderPassDescriptor.depthStencilAttachment;\n\t\tif (depthAttachment) {\n\t\t\tdepthAttachment.depthClearValue = renderPass.depthStencilOps.clearDepthValue;\n\t\t\tdepthAttachment.depthLoadOp = renderPass.depthStencilOps.clearDepth ? 'clear' : 'load';\n\t\t\tdepthAttachment.depthStoreOp = renderPass.depthStencilOps.storeDepth ? 'store' : 'discard';\n\t\t\tdepthAttachment.depthReadOnly = false;\n\t\t\tif (this.hasStencil) {\n\t\t\t\tdepthAttachment.stencilClearValue = renderPass.depthStencilOps.clearStencilValue;\n\t\t\t\tdepthAttachment.stencilLoadOp = renderPass.depthStencilOps.clearStencil ? 'clear' : 'load';\n\t\t\t\tdepthAttachment.stencilStoreOp = renderPass.depthStencilOps.storeStencil ? 'store' : 'discard';\n\t\t\t\tdepthAttachment.stencilReadOnly = false;\n\t\t\t}\n\t\t}\n\t}\n\tloseContext() {\n\t\tthis.initialized = false;\n\t}\n\tresolve(device, target, color, depth) {}\n}\n\nexport { WebgpuRenderTarget };\n", "import { math } from '../../core/math/math.js';\nimport { UNIFORMTYPE_MAT4, UNIFORMTYPE_MAT4ARRAY, UNIFORMTYPE_BVEC4, UNIFORMTYPE_BVEC4ARRAY, UNIFORMTYPE_UVEC4, UNIFORMTYPE_UVEC4ARRAY, UNIFORMTYPE_IVEC4, UNIFORMTYPE_IVEC4ARRAY, UNIFORMTYPE_VEC4, UNIFORMTYPE_VEC4ARRAY, UNIFORMTYPE_BVEC3, UNIFORMTYPE_BVEC3ARRAY, UNIFORMTYPE_UVEC3, UNIFORMTYPE_UVEC3ARRAY, UNIFORMTYPE_IVEC3, UNIFORMTYPE_IVEC3ARRAY, UNIFORMTYPE_VEC3, UNIFORMTYPE_VEC3ARRAY, UNIFORMTYPE_BVEC2, UNIFORMTYPE_BVEC2ARRAY, UNIFORMTYPE_UVEC2, UNIFORMTYPE_UVEC2ARRAY, UNIFORMTYPE_IVEC2, UNIFORMTYPE_IVEC2ARRAY, UNIFORMTYPE_VEC2, UNIFORMTYPE_VEC2ARRAY, UNIFORMTYPE_BOOL, UNIFORMTYPE_BOOLARRAY, UNIFORMTYPE_UINT, UNIFORMTYPE_UINTARRAY, UNIFORMTYPE_INT, UNIFORMTYPE_INTARRAY, UNIFORMTYPE_FLOAT, UNIFORMTYPE_FLOATARRAY, bindGroupNames, uniformTypeToName, UNIFORMTYPE_MAT2, UNIFORMTYPE_MAT3 } from './constants.js';\n\nconst uniformTypeToNumComponents = [];\nuniformTypeToNumComponents[UNIFORMTYPE_FLOAT] = 1;\nuniformTypeToNumComponents[UNIFORMTYPE_VEC2] = 2;\nuniformTypeToNumComponents[UNIFORMTYPE_VEC3] = 3;\nuniformTypeToNumComponents[UNIFORMTYPE_VEC4] = 4;\nuniformTypeToNumComponents[UNIFORMTYPE_INT] = 1;\nuniformTypeToNumComponents[UNIFORMTYPE_IVEC2] = 2;\nuniformTypeToNumComponents[UNIFORMTYPE_IVEC3] = 3;\nuniformTypeToNumComponents[UNIFORMTYPE_IVEC4] = 4;\nuniformTypeToNumComponents[UNIFORMTYPE_BOOL] = 1;\nuniformTypeToNumComponents[UNIFORMTYPE_BVEC2] = 2;\nuniformTypeToNumComponents[UNIFORMTYPE_BVEC3] = 3;\nuniformTypeToNumComponents[UNIFORMTYPE_BVEC4] = 4;\nuniformTypeToNumComponents[UNIFORMTYPE_MAT2] = 8;\nuniformTypeToNumComponents[UNIFORMTYPE_MAT3] = 12;\nuniformTypeToNumComponents[UNIFORMTYPE_MAT4] = 16;\nuniformTypeToNumComponents[UNIFORMTYPE_UINT] = 1;\nuniformTypeToNumComponents[UNIFORMTYPE_UVEC2] = 2;\nuniformTypeToNumComponents[UNIFORMTYPE_UVEC3] = 3;\nuniformTypeToNumComponents[UNIFORMTYPE_UVEC4] = 4;\nclass UniformFormat {\n\tget isArrayType() {\n\t\treturn this.count > 0;\n\t}\n\tconstructor(name, type, count = 0) {\n\t\tthis.name = void 0;\n\t\tthis.type = void 0;\n\t\tthis.byteSize = void 0;\n\t\tthis.offset = void 0;\n\t\tthis.scopeId = void 0;\n\t\tthis.count = void 0;\n\t\tthis.numComponents = void 0;\n\t\tthis.shortName = name;\n\t\tthis.name = count ? `${name}[0]` : name;\n\t\tthis.type = type;\n\t\tthis.numComponents = uniformTypeToNumComponents[type];\n\t\tthis.updateType = type;\n\t\tif (count > 0) {\n\t\t\tswitch (type) {\n\t\t\t\tcase UNIFORMTYPE_FLOAT:\n\t\t\t\t\tthis.updateType = UNIFORMTYPE_FLOATARRAY;\n\t\t\t\t\tbreak;\n\t\t\t\tcase UNIFORMTYPE_INT:\n\t\t\t\t\tthis.updateType = UNIFORMTYPE_INTARRAY;\n\t\t\t\t\tbreak;\n\t\t\t\tcase UNIFORMTYPE_UINT:\n\t\t\t\t\tthis.updateType = UNIFORMTYPE_UINTARRAY;\n\t\t\t\t\tbreak;\n\t\t\t\tcase UNIFORMTYPE_BOOL:\n\t\t\t\t\tthis.updateType = UNIFORMTYPE_BOOLARRAY;\n\t\t\t\t\tbreak;\n\t\t\t\tcase UNIFORMTYPE_VEC2:\n\t\t\t\t\tthis.updateType = UNIFORMTYPE_VEC2ARRAY;\n\t\t\t\t\tbreak;\n\t\t\t\tcase UNIFORMTYPE_IVEC2:\n\t\t\t\t\tthis.updateType = UNIFORMTYPE_IVEC2ARRAY;\n\t\t\t\t\tbreak;\n\t\t\t\tcase UNIFORMTYPE_UVEC2:\n\t\t\t\t\tthis.updateType = UNIFORMTYPE_UVEC2ARRAY;\n\t\t\t\t\tbreak;\n\t\t\t\tcase UNIFORMTYPE_BVEC2:\n\t\t\t\t\tthis.updateType = UNIFORMTYPE_BVEC2ARRAY;\n\t\t\t\t\tbreak;\n\t\t\t\tcase UNIFORMTYPE_VEC3:\n\t\t\t\t\tthis.updateType = UNIFORMTYPE_VEC3ARRAY;\n\t\t\t\t\tbreak;\n\t\t\t\tcase UNIFORMTYPE_IVEC3:\n\t\t\t\t\tthis.updateType = UNIFORMTYPE_IVEC3ARRAY;\n\t\t\t\t\tbreak;\n\t\t\t\tcase UNIFORMTYPE_UVEC3:\n\t\t\t\t\tthis.updateType = UNIFORMTYPE_UVEC3ARRAY;\n\t\t\t\t\tbreak;\n\t\t\t\tcase UNIFORMTYPE_BVEC3:\n\t\t\t\t\tthis.updateType = UNIFORMTYPE_BVEC3ARRAY;\n\t\t\t\t\tbreak;\n\t\t\t\tcase UNIFORMTYPE_VEC4:\n\t\t\t\t\tthis.updateType = UNIFORMTYPE_VEC4ARRAY;\n\t\t\t\t\tbreak;\n\t\t\t\tcase UNIFORMTYPE_IVEC4:\n\t\t\t\t\tthis.updateType = UNIFORMTYPE_IVEC4ARRAY;\n\t\t\t\t\tbreak;\n\t\t\t\tcase UNIFORMTYPE_UVEC4:\n\t\t\t\t\tthis.updateType = UNIFORMTYPE_UVEC4ARRAY;\n\t\t\t\t\tbreak;\n\t\t\t\tcase UNIFORMTYPE_BVEC4:\n\t\t\t\t\tthis.updateType = UNIFORMTYPE_BVEC4ARRAY;\n\t\t\t\t\tbreak;\n\t\t\t\tcase UNIFORMTYPE_MAT4:\n\t\t\t\t\tthis.updateType = UNIFORMTYPE_MAT4ARRAY;\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\tthis.count = count;\n\t\tlet componentSize = this.numComponents;\n\t\tif (count) {\n\t\t\tcomponentSize = math.roundUp(componentSize, 4);\n\t\t}\n\t\tthis.byteSize = componentSize * 4;\n\t\tif (count) this.byteSize *= count;\n\t}\n\tcalculateOffset(offset) {\n\t\tlet alignment = this.byteSize <= 8 ? this.byteSize : 16;\n\t\tif (this.count) alignment = 16;\n\t\toffset = math.roundUp(offset, alignment);\n\t\tthis.offset = offset / 4;\n\t}\n}\nclass UniformBufferFormat {\n\tconstructor(graphicsDevice, uniforms) {\n\t\tthis.byteSize = 0;\n\t\tthis.map = new Map();\n\t\tthis.scope = graphicsDevice.scope;\n\t\tthis.uniforms = uniforms;\n\t\tlet offset = 0;\n\t\tfor (let i = 0; i < uniforms.length; i++) {\n\t\t\tconst uniform = uniforms[i];\n\t\t\tuniform.calculateOffset(offset);\n\t\t\toffset = uniform.offset * 4 + uniform.byteSize;\n\t\t\tuniform.scopeId = this.scope.resolve(uniform.name);\n\t\t\tthis.map.set(uniform.name, uniform);\n\t\t}\n\t\tthis.byteSize = math.roundUp(offset, 16);\n\t}\n\tget(name) {\n\t\treturn this.map.get(name);\n\t}\n\tgetShaderDeclaration(bindGroup, bindIndex) {\n\t\tconst name = bindGroupNames[bindGroup];\n\t\tlet code = `layout(set = ${bindGroup}, binding = ${bindIndex}, std140) uniform ub_${name} {\\n`;\n\t\tthis.uniforms.forEach(uniform => {\n\t\t\tconst typeString = uniformTypeToName[uniform.type];\n\t\t\tcode += ` ${typeString} ${uniform.shortName}${uniform.count ? `[${uniform.count}]` : ''};\\n`;\n\t\t});\n\t\treturn code + '};\\n';\n\t}\n}\n\nexport { UniformBufferFormat, UniformFormat };\n", "import { TEXTUREDIMENSION_2D, SAMPLETYPE_FLOAT, SHADERSTAGE_COMPUTE, PIXELFORMAT_RGBA8, SAMPLETYPE_INT, SAMPLETYPE_UINT, TEXTUREDIMENSION_CUBE, TEXTUREDIMENSION_3D, TEXTUREDIMENSION_2D_ARRAY } from './constants.js';\n\nlet id = 0;\nconst textureDimensionInfo = {\n\t[TEXTUREDIMENSION_2D]: 'texture2D',\n\t[TEXTUREDIMENSION_CUBE]: 'textureCube',\n\t[TEXTUREDIMENSION_3D]: 'texture3D',\n\t[TEXTUREDIMENSION_2D_ARRAY]: 'texture2DArray'\n};\nclass BindBaseFormat {\n\tconstructor(name, visibility) {\n\t\tthis.slot = -1;\n\t\tthis.scopeId = null;\n\t\tthis.name = name;\n\t\tthis.visibility = visibility;\n\t}\n}\nclass BindUniformBufferFormat extends BindBaseFormat {}\nclass BindStorageBufferFormat extends BindBaseFormat {\n\tconstructor(name, visibility, readOnly = false) {\n\t\tsuper(name, visibility);\n\t\tthis.readOnly = readOnly;\n\t}\n}\nclass BindTextureFormat extends BindBaseFormat {\n\tconstructor(name, visibility, textureDimension = TEXTUREDIMENSION_2D, sampleType = SAMPLETYPE_FLOAT, hasSampler = true) {\n\t\tsuper(name, visibility);\n\t\tthis.textureDimension = textureDimension;\n\t\tthis.sampleType = sampleType;\n\t\tthis.hasSampler = hasSampler;\n\t}\n}\nclass BindStorageTextureFormat extends BindBaseFormat {\n\tconstructor(name, format = PIXELFORMAT_RGBA8, textureDimension = TEXTUREDIMENSION_2D, write = true, read = false) {\n\t\tsuper(name, SHADERSTAGE_COMPUTE);\n\t\tthis.format = format;\n\t\tthis.textureDimension = textureDimension;\n\t\tthis.write = write;\n\t\tthis.read = read;\n\t}\n}\nclass BindGroupFormat {\n\tconstructor(graphicsDevice, formats) {\n\t\tthis.uniformBufferFormats = [];\n\t\tthis.textureFormats = [];\n\t\tthis.storageTextureFormats = [];\n\t\tthis.storageBufferFormats = [];\n\t\tthis.id = id++;\n\t\tlet slot = 0;\n\t\tformats.forEach(format => {\n\t\t\tformat.slot = slot++;\n\t\t\tif (format instanceof BindTextureFormat && format.hasSampler) {\n\t\t\t\tslot++;\n\t\t\t}\n\t\t\tif (format instanceof BindUniformBufferFormat) {\n\t\t\t\tthis.uniformBufferFormats.push(format);\n\t\t\t} else if (format instanceof BindTextureFormat) {\n\t\t\t\tthis.textureFormats.push(format);\n\t\t\t} else if (format instanceof BindStorageTextureFormat) {\n\t\t\t\tthis.storageTextureFormats.push(format);\n\t\t\t} else if (format instanceof BindStorageBufferFormat) {\n\t\t\t\tthis.storageBufferFormats.push(format);\n\t\t\t} else ;\n\t\t});\n\t\tthis.device = graphicsDevice;\n\t\tconst scope = graphicsDevice.scope;\n\t\tthis.bufferFormatsMap = new Map();\n\t\tthis.uniformBufferFormats.forEach((bf, i) => this.bufferFormatsMap.set(bf.name, i));\n\t\tthis.textureFormatsMap = new Map();\n\t\tthis.textureFormats.forEach((tf, i) => {\n\t\t\tthis.textureFormatsMap.set(tf.name, i);\n\t\t\ttf.scopeId = scope.resolve(tf.name);\n\t\t});\n\t\tthis.storageTextureFormatsMap = new Map();\n\t\tthis.storageTextureFormats.forEach((tf, i) => {\n\t\t\tthis.storageTextureFormatsMap.set(tf.name, i);\n\t\t\ttf.scopeId = scope.resolve(tf.name);\n\t\t});\n\t\tthis.storageBufferFormatsMap = new Map();\n\t\tthis.storageBufferFormats.forEach((bf, i) => {\n\t\t\tthis.storageBufferFormatsMap.set(bf.name, i);\n\t\t\tbf.scopeId = scope.resolve(bf.name);\n\t\t});\n\t\tthis.impl = graphicsDevice.createBindGroupFormatImpl(this);\n\t}\n\tdestroy() {\n\t\tthis.impl.destroy();\n\t}\n\tgetTexture(name) {\n\t\tconst index = this.textureFormatsMap.get(name);\n\t\tif (index !== undefined) {\n\t\t\treturn this.textureFormats[index];\n\t\t}\n\t\treturn null;\n\t}\n\tgetStorageTexture(name) {\n\t\tconst index = this.storageTextureFormatsMap.get(name);\n\t\tif (index !== undefined) {\n\t\t\treturn this.storageTextureFormats[index];\n\t\t}\n\t\treturn null;\n\t}\n\tgetShaderDeclarationTextures(bindGroup) {\n\t\tlet code = '';\n\t\tthis.textureFormats.forEach(format => {\n\t\t\tlet textureType = textureDimensionInfo[format.textureDimension];\n\t\t\tlet namePostfix = '';\n\t\t\tlet extraCode = '';\n\t\t\tif (textureType === 'texture2DArray') {\n\t\t\t\tnamePostfix = '_texture';\n\t\t\t\textraCode = `#define ${format.name} sampler2DArray(${format.name}${namePostfix}, ${format.name}_sampler)\\n`;\n\t\t\t}\n\t\t\tif (format.sampleType === SAMPLETYPE_INT) {\n\t\t\t\ttextureType = `i${textureType}`;\n\t\t\t} else if (format.sampleType === SAMPLETYPE_UINT) {\n\t\t\t\ttextureType = `u${textureType}`;\n\t\t\t}\n\t\t\tcode += `layout(set = ${bindGroup}, binding = ${format.slot}) uniform ${textureType} ${format.name}${namePostfix};\\n`;\n\t\t\tif (format.hasSampler) {\n\t\t\t\tcode += `layout(set = ${bindGroup}, binding = ${format.slot + 1}) uniform sampler ${format.name}_sampler;\\n`;\n\t\t\t}\n\t\t\tcode += extraCode;\n\t\t});\n\t\treturn code;\n\t}\n\tloseContext() {}\n}\n\nexport { BindGroupFormat, BindStorageBufferFormat, BindStorageTextureFormat, BindTextureFormat, BindUniformBufferFormat };\n", "import { uniformTypeToName, SHADERSTAGE_VERTEX, SHADERSTAGE_FRAGMENT, BINDGROUP_MESH, semanticToLocation, TYPE_FLOAT32, TYPE_FLOAT16, TEXTUREDIMENSION_2D, TEXTUREDIMENSION_3D, TEXTUREDIMENSION_CUBE, TEXTUREDIMENSION_2D_ARRAY, UNIFORM_BUFFER_DEFAULT_SLOT_NAME, SAMPLETYPE_FLOAT, SAMPLETYPE_INT, SAMPLETYPE_UINT, SAMPLETYPE_UNFILTERABLE_FLOAT, SAMPLETYPE_DEPTH, TYPE_INT8, TYPE_INT16, TYPE_INT32 } from './constants.js';\nimport { UniformFormat, UniformBufferFormat } from './uniform-buffer-format.js';\nimport { BindTextureFormat, BindGroupFormat, BindUniformBufferFormat } from './bind-group-format.js';\n\nconst KEYWORD = /[ \\t]*(\\battribute\\b|\\bvarying\\b|\\buniform\\b)/g;\nconst KEYWORD_LINE = /(\\battribute\\b|\\bvarying\\b|\\bout\\b|\\buniform\\b)[ \\t]*([^;]+)([;]+)/g;\nconst MARKER = '@@@';\nconst ARRAY_IDENTIFIER = /([\\w-]+)\\[(.*?)\\]/;\nconst precisionQualifiers = new Set(['highp', 'mediump', 'lowp']);\nconst shadowSamplers = new Set(['sampler2DShadow', 'samplerCubeShadow', 'sampler2DArrayShadow']);\nconst textureDimensions = {\n\tsampler2D: TEXTUREDIMENSION_2D,\n\tsampler3D: TEXTUREDIMENSION_3D,\n\tsamplerCube: TEXTUREDIMENSION_CUBE,\n\tsamplerCubeShadow: TEXTUREDIMENSION_CUBE,\n\tsampler2DShadow: TEXTUREDIMENSION_2D,\n\tsampler2DArray: TEXTUREDIMENSION_2D_ARRAY,\n\tsampler2DArrayShadow: TEXTUREDIMENSION_2D_ARRAY,\n\tisampler2D: TEXTUREDIMENSION_2D,\n\tusampler2D: TEXTUREDIMENSION_2D,\n\tisampler3D: TEXTUREDIMENSION_3D,\n\tusampler3D: TEXTUREDIMENSION_3D,\n\tisamplerCube: TEXTUREDIMENSION_CUBE,\n\tusamplerCube: TEXTUREDIMENSION_CUBE,\n\tisampler2DArray: TEXTUREDIMENSION_2D_ARRAY,\n\tusampler2DArray: TEXTUREDIMENSION_2D_ARRAY\n};\nclass UniformLine {\n\tconstructor(line, shader) {\n\t\tthis.line = line;\n\t\tconst words = line.trim().split(/\\s+/);\n\t\tif (precisionQualifiers.has(words[0])) {\n\t\t\tthis.precision = words.shift();\n\t\t}\n\t\tthis.type = words.shift();\n\t\tif (line.includes(',')) ;\n\t\tif (line.includes('[')) {\n\t\t\tconst rest = words.join(' ');\n\t\t\tconst match = ARRAY_IDENTIFIER.exec(rest);\n\t\t\tthis.name = match[1];\n\t\t\tthis.arraySize = Number(match[2]);\n\t\t\tif (isNaN(this.arraySize)) {\n\t\t\t\tshader.failed = true;\n\t\t\t}\n\t\t} else {\n\t\t\tthis.name = words.shift();\n\t\t\tthis.arraySize = 0;\n\t\t}\n\t\tthis.isSampler = this.type.indexOf('sampler') !== -1;\n\t\tthis.isSignedInt = this.type.indexOf('isampler') !== -1;\n\t\tthis.isUnsignedInt = this.type.indexOf('usampler') !== -1;\n\t}\n}\nclass ShaderProcessor {\n\tstatic run(device, shaderDefinition, shader) {\n\t\tconst varyingMap = new Map();\n\t\tconst vertexExtracted = ShaderProcessor.extract(shaderDefinition.vshader);\n\t\tconst fragmentExtracted = ShaderProcessor.extract(shaderDefinition.fshader);\n\t\tconst attributesBlock = ShaderProcessor.processAttributes(vertexExtracted.attributes, shaderDefinition.attributes, shaderDefinition.processingOptions);\n\t\tconst vertexVaryingsBlock = ShaderProcessor.processVaryings(vertexExtracted.varyings, varyingMap, true);\n\t\tconst fragmentVaryingsBlock = ShaderProcessor.processVaryings(fragmentExtracted.varyings, varyingMap, false);\n\t\tconst outBlock = ShaderProcessor.processOuts(fragmentExtracted.outs);\n\t\tconst concatUniforms = vertexExtracted.uniforms.concat(fragmentExtracted.uniforms);\n\t\tconst uniforms = Array.from(new Set(concatUniforms));\n\t\tconst parsedUniforms = uniforms.map(line => new UniformLine(line, shader));\n\t\tconst uniformsData = ShaderProcessor.processUniforms(device, parsedUniforms, shaderDefinition.processingOptions, shader);\n\t\tconst vBlock = attributesBlock + '\\n' + vertexVaryingsBlock + '\\n' + uniformsData.code;\n\t\tconst vshader = vertexExtracted.src.replace(MARKER, vBlock);\n\t\tconst fBlock = fragmentVaryingsBlock + '\\n' + outBlock + '\\n' + uniformsData.code;\n\t\tconst fshader = fragmentExtracted.src.replace(MARKER, fBlock);\n\t\treturn {\n\t\t\tvshader: vshader,\n\t\t\tfshader: fshader,\n\t\t\tmeshUniformBufferFormat: uniformsData.meshUniformBufferFormat,\n\t\t\tmeshBindGroupFormat: uniformsData.meshBindGroupFormat\n\t\t};\n\t}\n\tstatic extract(src) {\n\t\tconst attributes = [];\n\t\tconst varyings = [];\n\t\tconst outs = [];\n\t\tconst uniforms = [];\n\t\tlet replacement = `${MARKER}\\n`;\n\t\tlet match;\n\t\twhile ((match = KEYWORD.exec(src)) !== null) {\n\t\t\tconst keyword = match[1];\n\t\t\tswitch (keyword) {\n\t\t\t\tcase 'attribute':\n\t\t\t\tcase 'varying':\n\t\t\t\tcase 'uniform':\n\t\t\t\tcase 'out':\n\t\t\t\t\t{\n\t\t\t\t\t\tKEYWORD_LINE.lastIndex = match.index;\n\t\t\t\t\t\tconst lineMatch = KEYWORD_LINE.exec(src);\n\t\t\t\t\t\tif (keyword === 'attribute') {\n\t\t\t\t\t\t\tattributes.push(lineMatch[2]);\n\t\t\t\t\t\t} else if (keyword === 'varying') {\n\t\t\t\t\t\t\tvaryings.push(lineMatch[2]);\n\t\t\t\t\t\t} else if (keyword === 'out') {\n\t\t\t\t\t\t\touts.push(lineMatch[2]);\n\t\t\t\t\t\t} else if (keyword === 'uniform') {\n\t\t\t\t\t\t\tuniforms.push(lineMatch[2]);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tsrc = ShaderProcessor.cutOut(src, match.index, KEYWORD_LINE.lastIndex, replacement);\n\t\t\t\t\t\tKEYWORD.lastIndex = match.index + replacement.length;\n\t\t\t\t\t\treplacement = '';\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn {\n\t\t\tsrc,\n\t\t\tattributes,\n\t\t\tvaryings,\n\t\t\touts,\n\t\t\tuniforms\n\t\t};\n\t}\n\tstatic processUniforms(device, uniforms, processingOptions, shader) {\n\t\tconst uniformLinesSamplers = [];\n\t\tconst uniformLinesNonSamplers = [];\n\t\tuniforms.forEach(uniform => {\n\t\t\tif (uniform.isSampler) {\n\t\t\t\tuniformLinesSamplers.push(uniform);\n\t\t\t} else {\n\t\t\t\tuniformLinesNonSamplers.push(uniform);\n\t\t\t}\n\t\t});\n\t\tconst meshUniforms = [];\n\t\tuniformLinesNonSamplers.forEach(uniform => {\n\t\t\tif (!processingOptions.hasUniform(uniform.name)) {\n\t\t\t\tconst uniformType = uniformTypeToName.indexOf(uniform.type);\n\t\t\t\tconst uniformFormat = new UniformFormat(uniform.name, uniformType, uniform.arraySize);\n\t\t\t\tmeshUniforms.push(uniformFormat);\n\t\t\t}\n\t\t});\n\t\tconst meshUniformBufferFormat = meshUniforms.length ? new UniformBufferFormat(device, meshUniforms) : null;\n\t\tconst uniformBufferFormats = [];\n\t\tif (meshUniformBufferFormat) {\n\t\t\tuniformBufferFormats.push(new BindUniformBufferFormat(UNIFORM_BUFFER_DEFAULT_SLOT_NAME, SHADERSTAGE_VERTEX | SHADERSTAGE_FRAGMENT));\n\t\t}\n\t\tconst textureFormats = [];\n\t\tuniformLinesSamplers.forEach(uniform => {\n\t\t\tif (!processingOptions.hasTexture(uniform.name)) {\n\t\t\t\tlet sampleType = SAMPLETYPE_FLOAT;\n\t\t\t\tif (uniform.isSignedInt) {\n\t\t\t\t\tsampleType = SAMPLETYPE_INT;\n\t\t\t\t} else if (uniform.isUnsignedInt) {\n\t\t\t\t\tsampleType = SAMPLETYPE_UINT;\n\t\t\t\t} else {\n\t\t\t\t\tif (uniform.precision === 'highp') sampleType = SAMPLETYPE_UNFILTERABLE_FLOAT;\n\t\t\t\t\tif (shadowSamplers.has(uniform.type)) sampleType = SAMPLETYPE_DEPTH;\n\t\t\t\t}\n\t\t\t\tconst dimension = textureDimensions[uniform.type];\n\t\t\t\ttextureFormats.push(new BindTextureFormat(uniform.name, SHADERSTAGE_VERTEX | SHADERSTAGE_FRAGMENT, dimension, sampleType));\n\t\t\t}\n\t\t});\n\t\tconst meshBindGroupFormat = new BindGroupFormat(device, [...uniformBufferFormats, ...textureFormats]);\n\t\tlet code = '';\n\t\tprocessingOptions.uniformFormats.forEach((format, bindGroupIndex) => {\n\t\t\tif (format) {\n\t\t\t\tcode += format.getShaderDeclaration(bindGroupIndex, 0);\n\t\t\t}\n\t\t});\n\t\tif (meshUniformBufferFormat) {\n\t\t\tcode += meshUniformBufferFormat.getShaderDeclaration(BINDGROUP_MESH, 0);\n\t\t}\n\t\tprocessingOptions.bindGroupFormats.forEach((format, bindGroupIndex) => {\n\t\t\tif (format) {\n\t\t\t\tcode += format.getShaderDeclarationTextures(bindGroupIndex);\n\t\t\t}\n\t\t});\n\t\tcode += meshBindGroupFormat.getShaderDeclarationTextures(BINDGROUP_MESH);\n\t\treturn {\n\t\t\tcode,\n\t\t\tmeshUniformBufferFormat,\n\t\t\tmeshBindGroupFormat\n\t\t};\n\t}\n\tstatic processVaryings(varyingLines, varyingMap, isVertex) {\n\t\tlet block = '';\n\t\tconst op = isVertex ? 'out' : 'in';\n\t\tvaryingLines.forEach((line, index) => {\n\t\t\tconst words = ShaderProcessor.splitToWords(line);\n\t\t\tconst type = words[0];\n\t\t\tconst name = words[1];\n\t\t\tif (isVertex) {\n\t\t\t\tvaryingMap.set(name, index);\n\t\t\t} else {\n\t\t\t\tindex = varyingMap.get(name);\n\t\t\t}\n\t\t\tblock += `layout(location = ${index}) ${op} ${type} ${name};\\n`;\n\t\t});\n\t\treturn block;\n\t}\n\tstatic processOuts(outsLines) {\n\t\tlet block = '';\n\t\toutsLines.forEach((line, index) => {\n\t\t\tblock += `layout(location = ${index}) out ${line};\\n`;\n\t\t});\n\t\treturn block;\n\t}\n\tstatic getTypeCount(type) {\n\t\tconst lastChar = type.substring(type.length - 1);\n\t\tconst num = parseInt(lastChar, 10);\n\t\treturn isNaN(num) ? 1 : num;\n\t}\n\tstatic processAttributes(attributeLines, shaderDefinitionAttributes, processingOptions) {\n\t\tlet block = '';\n\t\tattributeLines.forEach(line => {\n\t\t\tconst words = ShaderProcessor.splitToWords(line);\n\t\t\tlet type = words[0];\n\t\t\tlet name = words[1];\n\t\t\tif (shaderDefinitionAttributes.hasOwnProperty(name)) {\n\t\t\t\tconst semantic = shaderDefinitionAttributes[name];\n\t\t\t\tconst location = semanticToLocation[semantic];\n\t\t\t\tlet copyCode;\n\t\t\t\tconst element = processingOptions.getVertexElement(semantic);\n\t\t\t\tif (element) {\n\t\t\t\t\tconst dataType = element.dataType;\n\t\t\t\t\tif (dataType !== TYPE_FLOAT32 && dataType !== TYPE_FLOAT16 && !element.normalize && !element.asInt) {\n\t\t\t\t\t\tconst attribNumElements = ShaderProcessor.getTypeCount(type);\n\t\t\t\t\t\tconst newName = `_private_${name}`;\n\t\t\t\t\t\tcopyCode = `vec${attribNumElements} ${name} = vec${attribNumElements}(${newName});\\n`;\n\t\t\t\t\t\tname = newName;\n\t\t\t\t\t\tconst isSignedType = dataType === TYPE_INT8 || dataType === TYPE_INT16 || dataType === TYPE_INT32;\n\t\t\t\t\t\tif (attribNumElements === 1) {\n\t\t\t\t\t\t\ttype = isSignedType ? 'int' : 'uint';\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\ttype = isSignedType ? `ivec${attribNumElements}` : `uvec${attribNumElements}`;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tblock += `layout(location = ${location}) in ${type} ${name};\\n`;\n\t\t\t\tif (copyCode) {\n\t\t\t\t\tblock += copyCode;\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t\treturn block;\n\t}\n\tstatic splitToWords(line) {\n\t\tline = line.replace(/\\s+/g, ' ').trim();\n\t\treturn line.split(' ');\n\t}\n\tstatic cutOut(src, start, end, replacement) {\n\t\treturn src.substring(0, start) + replacement + src.substring(end);\n\t}\n}\n\nexport { ShaderProcessor };\n", "import { SHADERLANGUAGE_WGSL } from '../constants.js';\nimport { ShaderProcessor } from '../shader-processor.js';\n\nclass WebgpuShader {\n\tconstructor(shader) {\n\t\tthis._vertexCode = null;\n\t\tthis._fragmentCode = null;\n\t\tthis._computeCode = null;\n\t\tthis.vertexEntryPoint = 'main';\n\t\tthis.fragmentEntryPoint = 'main';\n\t\tthis.computeEntryPoint = 'main';\n\t\tthis.shader = shader;\n\t\tconst definition = shader.definition;\n\t\tif (definition.shaderLanguage === SHADERLANGUAGE_WGSL) {\n\t\t\tvar _definition$vshader, _definition$fshader, _definition$cshader;\n\t\t\tthis._vertexCode = (_definition$vshader = definition.vshader) != null ? _definition$vshader : null;\n\t\t\tthis._fragmentCode = (_definition$fshader = definition.fshader) != null ? _definition$fshader : null;\n\t\t\tthis._computeCode = (_definition$cshader = definition.cshader) != null ? _definition$cshader : null;\n\t\t\tthis.meshUniformBufferFormat = definition.meshUniformBufferFormat;\n\t\t\tthis.meshBindGroupFormat = definition.meshBindGroupFormat;\n\t\t\tthis.computeUniformBufferFormats = definition.computeUniformBufferFormats;\n\t\t\tthis.computeBindGroupFormat = definition.computeBindGroupFormat;\n\t\t\tthis.vertexEntryPoint = 'vertexMain';\n\t\t\tthis.fragmentEntryPoint = 'fragmentMain';\n\t\t\tshader.ready = true;\n\t\t} else {\n\t\t\tif (definition.processingOptions) {\n\t\t\t\tthis.process();\n\t\t\t}\n\t\t}\n\t}\n\tdestroy(shader) {\n\t\tthis._vertexCode = null;\n\t\tthis._fragmentCode = null;\n\t}\n\tcreateShaderModule(code, shaderType) {\n\t\tconst device = this.shader.device;\n\t\tconst wgpu = device.wgpu;\n\t\tconst shaderModule = wgpu.createShaderModule({\n\t\t\tcode: code\n\t\t});\n\t\treturn shaderModule;\n\t}\n\tgetVertexShaderModule() {\n\t\treturn this.createShaderModule(this._vertexCode, 'Vertex');\n\t}\n\tgetFragmentShaderModule() {\n\t\treturn this.createShaderModule(this._fragmentCode, 'Fragment');\n\t}\n\tgetComputeShaderModule() {\n\t\treturn this.createShaderModule(this._computeCode, 'Compute');\n\t}\n\tprocess() {\n\t\tconst shader = this.shader;\n\t\tconst processed = ShaderProcessor.run(shader.device, shader.definition, shader);\n\t\tthis._vertexCode = this.transpile(processed.vshader, 'vertex', shader.definition.vshader);\n\t\tthis._fragmentCode = this.transpile(processed.fshader, 'fragment', shader.definition.fshader);\n\t\tif (!(this._vertexCode && this._fragmentCode)) {\n\t\t\tshader.failed = true;\n\t\t} else {\n\t\t\tshader.ready = true;\n\t\t}\n\t\tshader.meshUniformBufferFormat = processed.meshUniformBufferFormat;\n\t\tshader.meshBindGroupFormat = processed.meshBindGroupFormat;\n\t}\n\ttranspile(src, shaderType, originalSrc) {\n\t\ttry {\n\t\t\tconst spirv = this.shader.device.glslang.compileGLSL(src, shaderType);\n\t\t\treturn this.shader.device.twgsl.convertSpirV2WGSL(spirv);\n\t\t} catch (err) {\n\t\t\tconsole.error(`Failed to transpile webgl ${shaderType} shader [${this.shader.label}] to WebGPU: [${err.message}] while rendering ${void 0}`, {\n\t\t\t\tprocessed: src,\n\t\t\t\toriginal: originalSrc,\n\t\t\t\tshader: this.shader\n\t\t\t});\n\t\t}\n\t}\n\tget vertexCode() {\n\t\treturn this._vertexCode;\n\t}\n\tget fragmentCode() {\n\t\treturn this._fragmentCode;\n\t}\n\tloseContext() {}\n\trestoreContext(device, shader) {}\n}\n\nexport { WebgpuShader };\n", "import { pixelFormatInfo, PIXELFORMAT_PVRTC_2BPP_RGB_1, PIXELFORMAT_PVRTC_2BPP_RGBA_1 } from './constants.js';\n\nclass TextureUtils {\n\tstatic calcLevelDimension(dimension, mipLevel) {\n\t\treturn Math.max(dimension >> mipLevel, 1);\n\t}\n\tstatic calcMipLevelsCount(width, height, depth = 1) {\n\t\treturn 1 + Math.floor(Math.log2(Math.max(width, height, depth)));\n\t}\n\tstatic calcLevelGpuSize(width, height, depth, format) {\n\t\tvar _pixelFormatInfo$get$, _pixelFormatInfo$get, _formatInfo$blockSize;\n\t\tconst formatInfo = pixelFormatInfo.get(format);\n\t\tconst pixelSize = (_pixelFormatInfo$get$ = (_pixelFormatInfo$get = pixelFormatInfo.get(format)) == null ? void 0 : _pixelFormatInfo$get.size) != null ? _pixelFormatInfo$get$ : 0;\n\t\tif (pixelSize > 0) {\n\t\t\treturn width * height * depth * pixelSize;\n\t\t}\n\t\tconst blockSize = (_formatInfo$blockSize = formatInfo.blockSize) != null ? _formatInfo$blockSize : 0;\n\t\tlet blockWidth = Math.floor((width + 3) / 4);\n\t\tconst blockHeight = Math.floor((height + 3) / 4);\n\t\tconst blockDepth = Math.floor((depth + 3) / 4);\n\t\tif (format === PIXELFORMAT_PVRTC_2BPP_RGB_1 || format === PIXELFORMAT_PVRTC_2BPP_RGBA_1) {\n\t\t\tblockWidth = Math.max(Math.floor(blockWidth / 2), 1);\n\t\t}\n\t\treturn blockWidth * blockHeight * blockDepth * blockSize;\n\t}\n\tstatic calcGpuSize(width, height, depth, format, mipmaps, cubemap) {\n\t\tlet result = 0;\n\t\twhile (1) {\n\t\t\tresult += TextureUtils.calcLevelGpuSize(width, height, depth, format);\n\t\t\tif (!mipmaps || width === 1 && height === 1 && depth === 1) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\twidth = Math.max(width >> 1, 1);\n\t\t\theight = Math.max(height >> 1, 1);\n\t\t\tdepth = Math.max(depth >> 1, 1);\n\t\t}\n\t\treturn result * (cubemap ? 6 : 1);\n\t}\n}\n\nexport { TextureUtils };\n", "import { math } from '../../../core/math/math.js';\nimport { isCompressedPixelFormat, PIXELFORMAT_DEPTHSTENCIL, SAMPLETYPE_DEPTH, SAMPLETYPE_INT, SAMPLETYPE_UINT, SAMPLETYPE_UNFILTERABLE_FLOAT, PIXELFORMAT_RGBA32F, PIXELFORMAT_RGBA16F, isIntegerPixelFormat, pixelFormatInfo, ADDRESS_REPEAT, ADDRESS_CLAMP_TO_EDGE, ADDRESS_MIRRORED_REPEAT, FILTER_NEAREST, FILTER_LINEAR, FILTER_NEAREST_MIPMAP_NEAREST, FILTER_NEAREST_MIPMAP_LINEAR, FILTER_LINEAR_MIPMAP_NEAREST, FILTER_LINEAR_MIPMAP_LINEAR } from '../constants.js';\nimport { TextureUtils } from '../texture-utils.js';\nimport { gpuTextureFormats } from './constants.js';\n\nconst gpuAddressModes = [];\ngpuAddressModes[ADDRESS_REPEAT] = 'repeat';\ngpuAddressModes[ADDRESS_CLAMP_TO_EDGE] = 'clamp-to-edge';\ngpuAddressModes[ADDRESS_MIRRORED_REPEAT] = 'mirror-repeat';\nconst gpuFilterModes = [];\ngpuFilterModes[FILTER_NEAREST] = {\n\tlevel: 'nearest',\n\tmip: 'nearest'\n};\ngpuFilterModes[FILTER_LINEAR] = {\n\tlevel: 'linear',\n\tmip: 'nearest'\n};\ngpuFilterModes[FILTER_NEAREST_MIPMAP_NEAREST] = {\n\tlevel: 'nearest',\n\tmip: 'nearest'\n};\ngpuFilterModes[FILTER_NEAREST_MIPMAP_LINEAR] = {\n\tlevel: 'nearest',\n\tmip: 'linear'\n};\ngpuFilterModes[FILTER_LINEAR_MIPMAP_NEAREST] = {\n\tlevel: 'linear',\n\tmip: 'nearest'\n};\ngpuFilterModes[FILTER_LINEAR_MIPMAP_LINEAR] = {\n\tlevel: 'linear',\n\tmip: 'linear'\n};\nconst dummyUse = thingOne => {};\nclass WebgpuTexture {\n\tconstructor(texture) {\n\t\tthis.gpuTexture = void 0;\n\t\tthis.view = void 0;\n\t\tthis.samplers = [];\n\t\tthis.descr = void 0;\n\t\tthis.format = void 0;\n\t\tthis.texture = texture;\n\t\tthis.format = gpuTextureFormats[texture.format];\n\t\tthis.create(texture.device);\n\t}\n\tcreate(device) {\n\t\tconst texture = this.texture;\n\t\tconst wgpu = device.wgpu;\n\t\tconst mipLevelCount = texture.requiredMipLevels;\n\t\tthis.descr = {\n\t\t\tsize: {\n\t\t\t\twidth: texture.width,\n\t\t\t\theight: texture.height,\n\t\t\t\tdepthOrArrayLayers: texture.cubemap ? 6 : texture.array ? texture.arrayLength : 1\n\t\t\t},\n\t\t\tformat: this.format,\n\t\t\tmipLevelCount: mipLevelCount,\n\t\t\tsampleCount: 1,\n\t\t\tdimension: texture.volume ? '3d' : '2d',\n\t\t\tusage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | (isCompressedPixelFormat(texture.format) ? 0 : GPUTextureUsage.RENDER_ATTACHMENT) | (texture.storage ? GPUTextureUsage.STORAGE_BINDING : 0)\n\t\t};\n\t\tthis.gpuTexture = wgpu.createTexture(this.descr);\n\t\tlet viewDescr;\n\t\tif (this.texture.format === PIXELFORMAT_DEPTHSTENCIL) {\n\t\t\tviewDescr = {\n\t\t\t\tformat: 'depth24plus',\n\t\t\t\taspect: 'depth-only'\n\t\t\t};\n\t\t}\n\t\tthis.view = this.createView(viewDescr);\n\t}\n\tdestroy(device) {}\n\tpropertyChanged(flag) {\n\t\tthis.samplers.length = 0;\n\t}\n\tgetView(device) {\n\t\tthis.uploadImmediate(device, this.texture);\n\t\treturn this.view;\n\t}\n\tcreateView(viewDescr) {\n\t\tvar _options$format, _options$dimension, _options$aspect, _options$baseMipLevel, _options$mipLevelCoun, _options$baseArrayLay, _options$arrayLayerCo;\n\t\tconst options = viewDescr != null ? viewDescr : {};\n\t\tconst textureDescr = this.descr;\n\t\tconst texture = this.texture;\n\t\tconst defaultViewDimension = () => {\n\t\t\tif (texture.cubemap) return 'cube';\n\t\t\tif (texture.volume) return '3d';\n\t\t\tif (texture.array) return '2d-array';\n\t\t\treturn '2d';\n\t\t};\n\t\tconst descr = {\n\t\t\tformat: (_options$format = options.format) != null ? _options$format : textureDescr.format,\n\t\t\tdimension: (_options$dimension = options.dimension) != null ? _options$dimension : defaultViewDimension(),\n\t\t\taspect: (_options$aspect = options.aspect) != null ? _options$aspect : 'all',\n\t\t\tbaseMipLevel: (_options$baseMipLevel = options.baseMipLevel) != null ? _options$baseMipLevel : 0,\n\t\t\tmipLevelCount: (_options$mipLevelCoun = options.mipLevelCount) != null ? _options$mipLevelCoun : textureDescr.mipLevelCount,\n\t\t\tbaseArrayLayer: (_options$baseArrayLay = options.baseArrayLayer) != null ? _options$baseArrayLay : 0,\n\t\t\tarrayLayerCount: (_options$arrayLayerCo = options.arrayLayerCount) != null ? _options$arrayLayerCo : textureDescr.depthOrArrayLayers\n\t\t};\n\t\tconst view = this.gpuTexture.createView(descr);\n\t\treturn view;\n\t}\n\tgetSampler(device, sampleType) {\n\t\tlet sampler = this.samplers[sampleType];\n\t\tif (!sampler) {\n\t\t\tconst texture = this.texture;\n\t\t\tconst descr = {\n\t\t\t\taddressModeU: gpuAddressModes[texture.addressU],\n\t\t\t\taddressModeV: gpuAddressModes[texture.addressV],\n\t\t\t\taddressModeW: gpuAddressModes[texture.addressW]\n\t\t\t};\n\t\t\tif (!sampleType && texture.compareOnRead) {\n\t\t\t\tsampleType = SAMPLETYPE_DEPTH;\n\t\t\t}\n\t\t\tif (sampleType === SAMPLETYPE_DEPTH || sampleType === SAMPLETYPE_INT || sampleType === SAMPLETYPE_UINT) {\n\t\t\t\tdescr.compare = 'less';\n\t\t\t\tdescr.magFilter = 'linear';\n\t\t\t\tdescr.minFilter = 'linear';\n\t\t\t} else if (sampleType === SAMPLETYPE_UNFILTERABLE_FLOAT) {\n\t\t\t\tdescr.magFilter = 'nearest';\n\t\t\t\tdescr.minFilter = 'nearest';\n\t\t\t\tdescr.mipmapFilter = 'nearest';\n\t\t\t} else {\n\t\t\t\tconst forceNearest = !device.textureFloatFilterable && (texture.format === PIXELFORMAT_RGBA32F || texture.format === PIXELFORMAT_RGBA16F);\n\t\t\t\tif (forceNearest || this.texture.format === PIXELFORMAT_DEPTHSTENCIL || isIntegerPixelFormat(this.texture.format)) {\n\t\t\t\t\tdescr.magFilter = 'nearest';\n\t\t\t\t\tdescr.minFilter = 'nearest';\n\t\t\t\t\tdescr.mipmapFilter = 'nearest';\n\t\t\t\t} else {\n\t\t\t\t\tdescr.magFilter = gpuFilterModes[texture.magFilter].level;\n\t\t\t\t\tdescr.minFilter = gpuFilterModes[texture.minFilter].level;\n\t\t\t\t\tdescr.mipmapFilter = gpuFilterModes[texture.minFilter].mip;\n\t\t\t\t}\n\t\t\t}\n\t\t\tconst allLinear = descr.minFilter === 'linear' && descr.magFilter === 'linear' && descr.mipmapFilter === 'linear';\n\t\t\tdescr.maxAnisotropy = allLinear ? math.clamp(Math.round(texture._anisotropy), 1, device.maxTextureAnisotropy) : 1;\n\t\t\tsampler = device.wgpu.createSampler(descr);\n\t\t\tthis.samplers[sampleType] = sampler;\n\t\t}\n\t\treturn sampler;\n\t}\n\tloseContext() {}\n\tuploadImmediate(device, texture) {\n\t\tif (texture._needsUpload || texture._needsMipmapsUpload) {\n\t\t\tthis.uploadData(device);\n\t\t\ttexture._needsUpload = false;\n\t\t\ttexture._needsMipmapsUpload = false;\n\t\t}\n\t}\n\tuploadData(device) {\n\t\tconst texture = this.texture;\n\t\tif (texture._levels) {\n\t\t\tlet anyUploads = false;\n\t\t\tlet anyLevelMissing = false;\n\t\t\tconst requiredMipLevels = texture.requiredMipLevels;\n\t\t\tfor (let mipLevel = 0; mipLevel < requiredMipLevels; mipLevel++) {\n\t\t\t\tconst mipObject = texture._levels[mipLevel];\n\t\t\t\tif (mipObject) {\n\t\t\t\t\tif (texture.cubemap) {\n\t\t\t\t\t\tfor (let face = 0; face < 6; face++) {\n\t\t\t\t\t\t\tconst faceSource = mipObject[face];\n\t\t\t\t\t\t\tif (faceSource) {\n\t\t\t\t\t\t\t\tif (this.isExternalImage(faceSource)) {\n\t\t\t\t\t\t\t\t\tthis.uploadExternalImage(device, faceSource, mipLevel, face);\n\t\t\t\t\t\t\t\t\tanyUploads = true;\n\t\t\t\t\t\t\t\t} else if (ArrayBuffer.isView(faceSource)) {\n\t\t\t\t\t\t\t\t\tthis.uploadTypedArrayData(device, faceSource, mipLevel, face);\n\t\t\t\t\t\t\t\t\tanyUploads = true;\n\t\t\t\t\t\t\t\t} else ;\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tanyLevelMissing = true;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t} else if (texture._volume) ; else if (texture.array) {\n\t\t\t\t\t\tif (texture.arrayLength === mipObject.length) {\n\t\t\t\t\t\t\tfor (let index = 0; index < texture._arrayLength; index++) {\n\t\t\t\t\t\t\t\tconst arraySource = mipObject[index];\n\t\t\t\t\t\t\t\tif (this.isExternalImage(arraySource)) {\n\t\t\t\t\t\t\t\t\tthis.uploadExternalImage(device, arraySource, mipLevel, index);\n\t\t\t\t\t\t\t\t\tanyUploads = true;\n\t\t\t\t\t\t\t\t} else if (ArrayBuffer.isView(arraySource)) {\n\t\t\t\t\t\t\t\t\tthis.uploadTypedArrayData(device, arraySource, mipLevel, index);\n\t\t\t\t\t\t\t\t\tanyUploads = true;\n\t\t\t\t\t\t\t\t} else ;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tanyLevelMissing = true;\n\t\t\t\t\t\t}\n\t\t\t\t\t} else {\n\t\t\t\t\t\tif (this.isExternalImage(mipObject)) {\n\t\t\t\t\t\t\tthis.uploadExternalImage(device, mipObject, mipLevel, 0);\n\t\t\t\t\t\t\tanyUploads = true;\n\t\t\t\t\t\t} else if (ArrayBuffer.isView(mipObject)) {\n\t\t\t\t\t\t\tthis.uploadTypedArrayData(device, mipObject, mipLevel, 0);\n\t\t\t\t\t\t\tanyUploads = true;\n\t\t\t\t\t\t} else ;\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tanyLevelMissing = true;\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (anyUploads && anyLevelMissing && texture.mipmaps && !isCompressedPixelFormat(texture.format)) {\n\t\t\t\tdevice.mipmapRenderer.generate(this);\n\t\t\t}\n\t\t\tif (texture._gpuSize) {\n\t\t\t\ttexture.adjustVramSizeTracking(device._vram, -texture._gpuSize);\n\t\t\t}\n\t\t\ttexture._gpuSize = texture.gpuSize;\n\t\t\ttexture.adjustVramSizeTracking(device._vram, texture._gpuSize);\n\t\t}\n\t}\n\tisExternalImage(image) {\n\t\treturn image instanceof ImageBitmap || image instanceof HTMLVideoElement || image instanceof HTMLCanvasElement || image instanceof OffscreenCanvas;\n\t}\n\tuploadExternalImage(device, image, mipLevel, index) {\n\t\tconst src = {\n\t\t\tsource: image,\n\t\t\torigin: [0, 0],\n\t\t\tflipY: false\n\t\t};\n\t\tconst dst = {\n\t\t\ttexture: this.gpuTexture,\n\t\t\tmipLevel: mipLevel,\n\t\t\torigin: [0, 0, index],\n\t\t\taspect: 'all'\n\t\t};\n\t\tconst copySize = {\n\t\t\twidth: this.descr.size.width,\n\t\t\theight: this.descr.size.height,\n\t\t\tdepthOrArrayLayers: 1\n\t\t};\n\t\tdevice.submit();\n\t\tdummyUse(image instanceof HTMLCanvasElement && image.getContext('2d'));\n\t\tdevice.wgpu.queue.copyExternalImageToTexture(src, dst, copySize);\n\t}\n\tuploadTypedArrayData(device, data, mipLevel, index) {\n\t\tconst texture = this.texture;\n\t\tconst wgpu = device.wgpu;\n\t\tconst dest = {\n\t\t\ttexture: this.gpuTexture,\n\t\t\torigin: [0, 0, index],\n\t\t\tmipLevel: mipLevel\n\t\t};\n\t\tconst width = TextureUtils.calcLevelDimension(texture.width, mipLevel);\n\t\tconst height = TextureUtils.calcLevelDimension(texture.height, mipLevel);\n\t\tTextureUtils.calcLevelGpuSize(width, height, 1, texture.format);\n\t\tconst formatInfo = pixelFormatInfo.get(texture.format);\n\t\tlet dataLayout;\n\t\tlet size;\n\t\tif (formatInfo.size) {\n\t\t\tdataLayout = {\n\t\t\t\toffset: 0,\n\t\t\t\tbytesPerRow: formatInfo.size * width,\n\t\t\t\trowsPerImage: height\n\t\t\t};\n\t\t\tsize = {\n\t\t\t\twidth: width,\n\t\t\t\theight: height\n\t\t\t};\n\t\t} else if (formatInfo.blockSize) {\n\t\t\tconst blockDim = size => {\n\t\t\t\treturn Math.floor((size + 3) / 4);\n\t\t\t};\n\t\t\tdataLayout = {\n\t\t\t\toffset: 0,\n\t\t\t\tbytesPerRow: formatInfo.blockSize * blockDim(width),\n\t\t\t\trowsPerImage: blockDim(height)\n\t\t\t};\n\t\t\tsize = {\n\t\t\t\twidth: Math.max(4, width),\n\t\t\t\theight: Math.max(4, height)\n\t\t\t};\n\t\t} else ;\n\t\tdevice.submit();\n\t\twgpu.queue.writeTexture(dest, data, dataLayout, size);\n\t}\n}\n\nexport { WebgpuTexture };\n", "import { BUFFERUSAGE_UNIFORM } from '../constants.js';\nimport { WebgpuBuffer } from './webgpu-buffer.js';\n\nclass WebgpuUniformBuffer extends WebgpuBuffer {\n\tconstructor(uniformBuffer) {\n\t\tsuper(BUFFERUSAGE_UNIFORM);\n\t}\n\tunlock(uniformBuffer) {\n\t\tconst device = uniformBuffer.device;\n\t\tsuper.unlock(device, uniformBuffer.storageInt32.buffer);\n\t}\n}\n\nexport { WebgpuUniformBuffer };\n", "import { BUFFERUSAGE_VERTEX, BUFFERUSAGE_STORAGE } from '../constants.js';\nimport { WebgpuBuffer } from './webgpu-buffer.js';\n\nclass WebgpuVertexBuffer extends WebgpuBuffer {\n\tconstructor(vertexBuffer, format, options) {\n\t\tsuper(BUFFERUSAGE_VERTEX | (options != null && options.storage ? BUFFERUSAGE_STORAGE : 0));\n\t}\n\tunlock(vertexBuffer) {\n\t\tconst device = vertexBuffer.device;\n\t\tsuper.unlock(device, vertexBuffer.storage);\n\t}\n}\n\nexport { WebgpuVertexBuffer };\n", "const KEYWORD = /[ \\t]*#(ifn?def|if|endif|else|elif|define|undef|extension|include)/g;\nconst DEFINE = /define[ \\t]+([^\\n]+)\\r?(?:\\n|$)/g;\nconst EXTENSION = /extension[ \\t]+([\\w-]+)[ \\t]*:[ \\t]*(enable|require)/g;\nconst UNDEF = /undef[ \\t]+([^\\n]+)\\r?(?:\\n|$)/g;\nconst IF = /(ifdef|ifndef|if)[ \\t]*([^\\r\\n]+)\\r?\\n/g;\nconst ENDIF = /(endif|else|elif)([ \\t]+[^\\r\\n]+)?\\r?(?:\\n|$)/g;\nconst IDENTIFIER = /([\\w-]+)/;\nconst DEFINED = /(!|\\s)?defined\\(([\\w-]+)\\)/;\nconst INVALID = /[><=|&+-]/g;\nconst INCLUDE = /include[ \\t]+\"([\\w-]+)\"\\r?(?:\\n|$)/g;\nclass Preprocessor {\n\tstatic run(source, includes = new Map(), stripUnusedColorAttachments = false) {\n\t\tsource = source.replace(/\\/\\*[\\s\\S]*?\\*\\/|([^\\\\:]|^)\\/\\/.*$/gm, '$1');\n\t\tsource = source.split(/\\r?\\n/).map(line => line.trimEnd()).join('\\n');\n\t\tconst defines = new Map();\n\t\tif (stripUnusedColorAttachments) {\n\t\t\tconst counts = new Map();\n\t\t\tconst regex = /(pcFragColor[1-8])\\b/g;\n\t\t\tconst matches = source.match(regex);\n\t\t\tmatches == null || matches.forEach(match => {\n\t\t\t\tvar _counts$get;\n\t\t\t\tconst index = parseInt(match.charAt(match.length - 1), 10);\n\t\t\t\tcounts.set(index, ((_counts$get = counts.get(index)) != null ? _counts$get : 0) + 1);\n\t\t\t});\n\t\t\tcounts.forEach((count, index) => {\n\t\t\t\tif (count === 1) {\n\t\t\t\t\tdefines.set(`REMOVE_COLOR_ATTACHMENT_${index}`, '');\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\t\tsource = this._preprocess(source, defines, includes);\n\t\tconst intDefines = new Map();\n\t\tdefines.forEach((value, key) => {\n\t\t\tif (Number.isInteger(parseFloat(value)) && !value.includes('.')) {\n\t\t\t\tintDefines.set(key, value);\n\t\t\t}\n\t\t});\n\t\tsource = this.RemoveEmptyLines(source);\n\t\tsource = this.processArraySize(source, intDefines);\n\t\treturn source;\n\t}\n\tstatic processArraySize(source, intDefines) {\n\t\tif (source !== null) {\n\t\t\tintDefines.forEach((value, key) => {\n\t\t\t\tsource = source.replace(new RegExp(`\\\\[${key}\\\\]`, 'g'), `[${value}]`);\n\t\t\t});\n\t\t}\n\t\treturn source;\n\t}\n\tstatic RemoveEmptyLines(source) {\n\t\tif (source !== null) {\n\t\t\tsource = source.split(/\\r?\\n/).map(line => line.trim() === '' ? '' : line).join('\\n');\n\t\t\tsource = source.replace(/(\\n\\n){3,}/gm, '\\n\\n');\n\t\t}\n\t\treturn source;\n\t}\n\tstatic _preprocess(source, defines = new Map(), includes) {\n\t\tconst originalSource = source;\n\t\tconst stack = [];\n\t\tlet error = false;\n\t\tlet match;\n\t\twhile ((match = KEYWORD.exec(source)) !== null) {\n\t\t\tconst keyword = match[1];\n\t\t\tswitch (keyword) {\n\t\t\t\tcase 'define':\n\t\t\t\t\t{\n\t\t\t\t\t\tDEFINE.lastIndex = match.index;\n\t\t\t\t\t\tconst define = DEFINE.exec(source);\n\t\t\t\t\t\terror || (error = define === null);\n\t\t\t\t\t\tconst expression = define[1];\n\t\t\t\t\t\tIDENTIFIER.lastIndex = define.index;\n\t\t\t\t\t\tconst identifierValue = IDENTIFIER.exec(expression);\n\t\t\t\t\t\tconst identifier = identifierValue[1];\n\t\t\t\t\t\tlet value = expression.substring(identifier.length).trim();\n\t\t\t\t\t\tif (value === \"\") value = \"true\";\n\t\t\t\t\t\tconst keep = Preprocessor._keep(stack);\n\t\t\t\t\t\tif (keep) {\n\t\t\t\t\t\t\tdefines.set(identifier, value);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tKEYWORD.lastIndex = define.index + define[0].length;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\tcase 'undef':\n\t\t\t\t\t{\n\t\t\t\t\t\tUNDEF.lastIndex = match.index;\n\t\t\t\t\t\tconst undef = UNDEF.exec(source);\n\t\t\t\t\t\tconst identifier = undef[1].trim();\n\t\t\t\t\t\tconst keep = Preprocessor._keep(stack);\n\t\t\t\t\t\tif (keep) {\n\t\t\t\t\t\t\tdefines.delete(identifier);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tKEYWORD.lastIndex = undef.index + undef[0].length;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\tcase 'extension':\n\t\t\t\t\t{\n\t\t\t\t\t\tEXTENSION.lastIndex = match.index;\n\t\t\t\t\t\tconst extension = EXTENSION.exec(source);\n\t\t\t\t\t\terror || (error = extension === null);\n\t\t\t\t\t\tif (extension) {\n\t\t\t\t\t\t\tconst identifier = extension[1];\n\t\t\t\t\t\t\tconst keep = Preprocessor._keep(stack);\n\t\t\t\t\t\t\tif (keep) {\n\t\t\t\t\t\t\t\tdefines.set(identifier, \"true\");\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tKEYWORD.lastIndex = extension.index + extension[0].length;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\tcase 'ifdef':\n\t\t\t\tcase 'ifndef':\n\t\t\t\tcase 'if':\n\t\t\t\t\t{\n\t\t\t\t\t\tIF.lastIndex = match.index;\n\t\t\t\t\t\tconst iff = IF.exec(source);\n\t\t\t\t\t\tconst expression = iff[2];\n\t\t\t\t\t\tconst evaluated = Preprocessor.evaluate(expression, defines);\n\t\t\t\t\t\terror || (error = evaluated.error);\n\t\t\t\t\t\tlet result = evaluated.result;\n\t\t\t\t\t\tif (keyword === 'ifndef') {\n\t\t\t\t\t\t\tresult = !result;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tstack.push({\n\t\t\t\t\t\t\tanyKeep: result,\n\t\t\t\t\t\t\tkeep: result,\n\t\t\t\t\t\t\tstart: match.index,\n\t\t\t\t\t\t\tend: IF.lastIndex\n\t\t\t\t\t\t});\n\t\t\t\t\t\tKEYWORD.lastIndex = iff.index + iff[0].length;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\tcase 'endif':\n\t\t\t\tcase 'else':\n\t\t\t\tcase 'elif':\n\t\t\t\t\t{\n\t\t\t\t\t\tENDIF.lastIndex = match.index;\n\t\t\t\t\t\tconst endif = ENDIF.exec(source);\n\t\t\t\t\t\tconst blockInfo = stack.pop();\n\t\t\t\t\t\tconst blockCode = blockInfo.keep ? source.substring(blockInfo.end, match.index) : \"\";\n\t\t\t\t\t\tsource = source.substring(0, blockInfo.start) + blockCode + source.substring(ENDIF.lastIndex);\n\t\t\t\t\t\tKEYWORD.lastIndex = blockInfo.start + blockCode.length;\n\t\t\t\t\t\tconst endifCommand = endif[1];\n\t\t\t\t\t\tif (endifCommand === 'else' || endifCommand === 'elif') {\n\t\t\t\t\t\t\tlet result = false;\n\t\t\t\t\t\t\tif (!blockInfo.anyKeep) {\n\t\t\t\t\t\t\t\tif (endifCommand === 'else') {\n\t\t\t\t\t\t\t\t\tresult = !blockInfo.keep;\n\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\tconst evaluated = Preprocessor.evaluate(endif[2], defines);\n\t\t\t\t\t\t\t\t\tresult = evaluated.result;\n\t\t\t\t\t\t\t\t\terror || (error = evaluated.error);\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tstack.push({\n\t\t\t\t\t\t\t\tanyKeep: blockInfo.anyKeep || result,\n\t\t\t\t\t\t\t\tkeep: result,\n\t\t\t\t\t\t\t\tstart: KEYWORD.lastIndex,\n\t\t\t\t\t\t\t\tend: KEYWORD.lastIndex\n\t\t\t\t\t\t\t});\n\t\t\t\t\t\t}\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\tcase 'include':\n\t\t\t\t\t{\n\t\t\t\t\t\tINCLUDE.lastIndex = match.index;\n\t\t\t\t\t\tconst include = INCLUDE.exec(source);\n\t\t\t\t\t\terror || (error = include === null);\n\t\t\t\t\t\tconst identifier = include[1].trim();\n\t\t\t\t\t\tconst keep = Preprocessor._keep(stack);\n\t\t\t\t\t\tif (keep) {\n\t\t\t\t\t\t\tconst includeSource = includes == null ? void 0 : includes.get(identifier);\n\t\t\t\t\t\t\tif (includeSource) {\n\t\t\t\t\t\t\t\tsource = source.substring(0, include.index - 1) + includeSource + source.substring(INCLUDE.lastIndex);\n\t\t\t\t\t\t\t\tKEYWORD.lastIndex = include.index;\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tconsole.error(`Include not found: ${identifier}`);\n\t\t\t\t\t\t\t\terror = true;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (error) {\n\t\t\tconsole.warn(\"Failed to preprocess shader: \", {\n\t\t\t\tsource: originalSource\n\t\t\t});\n\t\t\treturn originalSource;\n\t\t}\n\t\treturn source;\n\t}\n\tstatic _keep(stack) {\n\t\tfor (let i = 0; i < stack.length; i++) {\n\t\t\tif (!stack[i].keep) return false;\n\t\t}\n\t\treturn true;\n\t}\n\tstatic evaluate(expression, defines) {\n\t\tconst correct = INVALID.exec(expression) === null;\n\t\tlet invert = false;\n\t\tconst defined = DEFINED.exec(expression);\n\t\tif (defined) {\n\t\t\tinvert = defined[1] === '!';\n\t\t\texpression = defined[2];\n\t\t}\n\t\texpression = expression.trim();\n\t\tlet exists = defines.has(expression);\n\t\tif (invert) {\n\t\t\texists = !exists;\n\t\t}\n\t\treturn {\n\t\t\tresult: exists,\n\t\t\terror: !correct\n\t\t};\n\t}\n}\n\nexport { Preprocessor };\n", "import { platform } from '../../core/platform.js';\nimport { Preprocessor } from '../../core/preprocessor.js';\n\nlet id = 0;\nclass Shader {\n\tconstructor(graphicsDevice, definition) {\n\t\tthis.meshUniformBufferFormat = void 0;\n\t\tthis.meshBindGroupFormat = void 0;\n\t\tthis.id = id++;\n\t\tthis.device = graphicsDevice;\n\t\tthis.definition = definition;\n\t\tthis.name = definition.name || 'Untitled';\n\t\tthis.init();\n\t\tif (definition.cshader) ; else {\n\t\t\tdefinition.vshader = Preprocessor.run(definition.vshader, definition.vincludes);\n\t\t\tconst stripUnusedColorAttachments = graphicsDevice.isWebGL2 && (platform.name === 'osx' || platform.name === 'ios');\n\t\t\tdefinition.fshader = Preprocessor.run(definition.fshader, definition.fincludes, stripUnusedColorAttachments);\n\t\t}\n\t\tthis.impl = graphicsDevice.createShaderImpl(this);\n\t}\n\tinit() {\n\t\tthis.ready = false;\n\t\tthis.failed = false;\n\t}\n\tget label() {\n\t\treturn `Shader Id ${this.id} ${this.name}`;\n\t}\n\tdestroy() {\n\t\tthis.device.onDestroyShader(this);\n\t\tthis.impl.destroy(this);\n\t}\n\tloseContext() {\n\t\tthis.init();\n\t\tthis.impl.loseContext();\n\t}\n\trestoreContext() {\n\t\tthis.impl.restoreContext(this.device, this);\n\t}\n}\n\nexport { Shader };\n", "import { UNIFORM_BUFFER_DEFAULT_SLOT_NAME } from './constants.js';\n\nlet id = 0;\nclass BindGroup {\n\tconstructor(graphicsDevice, format, defaultUniformBuffer) {\n\t\tthis.renderVersionUpdated = -1;\n\t\tthis.uniformBuffers = void 0;\n\t\tthis.uniformBufferOffsets = [];\n\t\tthis.id = id++;\n\t\tthis.device = graphicsDevice;\n\t\tthis.format = format;\n\t\tthis.dirty = true;\n\t\tthis.impl = graphicsDevice.createBindGroupImpl(this);\n\t\tthis.textures = [];\n\t\tthis.storageTextures = [];\n\t\tthis.storageBuffers = [];\n\t\tthis.uniformBuffers = [];\n\t\tthis.defaultUniformBuffer = defaultUniformBuffer;\n\t\tif (defaultUniformBuffer) {\n\t\t\tthis.setUniformBuffer(UNIFORM_BUFFER_DEFAULT_SLOT_NAME, defaultUniformBuffer);\n\t\t}\n\t}\n\tdestroy() {\n\t\tthis.impl.destroy();\n\t\tthis.impl = null;\n\t\tthis.format = null;\n\t\tthis.defaultUniformBuffer = null;\n\t}\n\tsetUniformBuffer(name, uniformBuffer) {\n\t\tconst index = this.format.bufferFormatsMap.get(name);\n\t\tif (this.uniformBuffers[index] !== uniformBuffer) {\n\t\t\tthis.uniformBuffers[index] = uniformBuffer;\n\t\t\tthis.dirty = true;\n\t\t}\n\t}\n\tsetStorageBuffer(name, storageBuffer) {\n\t\tconst index = this.format.storageBufferFormatsMap.get(name);\n\t\tif (this.storageBuffers[index] !== storageBuffer) {\n\t\t\tthis.storageBuffers[index] = storageBuffer;\n\t\t\tthis.dirty = true;\n\t\t}\n\t}\n\tsetTexture(name, texture) {\n\t\tconst index = this.format.textureFormatsMap.get(name);\n\t\tif (this.textures[index] !== texture) {\n\t\t\tthis.textures[index] = texture;\n\t\t\tthis.dirty = true;\n\t\t} else if (this.renderVersionUpdated < texture.renderVersionDirty) {\n\t\t\tthis.dirty = true;\n\t\t}\n\t}\n\tsetStorageTexture(name, texture) {\n\t\tconst index = this.format.storageTextureFormatsMap.get(name);\n\t\tif (this.storageTextures[index] !== texture) {\n\t\t\tthis.storageTextures[index] = texture;\n\t\t\tthis.dirty = true;\n\t\t} else if (this.renderVersionUpdated < texture.renderVersionDirty) {\n\t\t\tthis.dirty = true;\n\t\t}\n\t}\n\tupdateUniformBuffers() {\n\t\tfor (let i = 0; i < this.uniformBuffers.length; i++) {\n\t\t\tthis.uniformBuffers[i].update();\n\t\t}\n\t}\n\tupdate() {\n\t\tconst {\n\t\t\ttextureFormats,\n\t\t\tstorageTextureFormats,\n\t\t\tstorageBufferFormats\n\t\t} = this.format;\n\t\tfor (let i = 0; i < textureFormats.length; i++) {\n\t\t\tconst textureFormat = textureFormats[i];\n\t\t\tconst value = textureFormat.scopeId.value;\n\t\t\tthis.setTexture(textureFormat.name, value);\n\t\t}\n\t\tfor (let i = 0; i < storageTextureFormats.length; i++) {\n\t\t\tconst storageTextureFormat = storageTextureFormats[i];\n\t\t\tconst value = storageTextureFormat.scopeId.value;\n\t\t\tthis.setStorageTexture(storageTextureFormat.name, value);\n\t\t}\n\t\tfor (let i = 0; i < storageBufferFormats.length; i++) {\n\t\t\tconst storageBufferFormat = storageBufferFormats[i];\n\t\t\tconst value = storageBufferFormat.scopeId.value;\n\t\t\tthis.setStorageBuffer(storageBufferFormat.name, value);\n\t\t}\n\t\tthis.uniformBufferOffsets.length = this.uniformBuffers.length;\n\t\tfor (let i = 0; i < this.uniformBuffers.length; i++) {\n\t\t\tconst uniformBuffer = this.uniformBuffers[i];\n\t\t\tthis.uniformBufferOffsets[i] = uniformBuffer.offset;\n\t\t\tif (this.renderVersionUpdated < uniformBuffer.renderVersionDirty) {\n\t\t\t\tthis.dirty = true;\n\t\t\t}\n\t\t}\n\t\tif (this.dirty) {\n\t\t\tthis.dirty = false;\n\t\t\tthis.renderVersionUpdated = this.device.renderVersion;\n\t\t\tthis.impl.update(this);\n\t\t}\n\t}\n}\n\nexport { BindGroup };\n", "import { math } from '../../core/math/math.js';\n\nclass DynamicBuffer {\n\tconstructor(device) {\n\t\tthis.device = void 0;\n\t\tthis.device = device;\n\t}\n}\nclass UsedBuffer {\n\tconstructor() {\n\t\tthis.gpuBuffer = void 0;\n\t\tthis.stagingBuffer = void 0;\n\t\tthis.offset = void 0;\n\t\tthis.size = void 0;\n\t}\n}\nclass DynamicBufferAllocation {\n\tconstructor() {\n\t\tthis.storage = void 0;\n\t\tthis.gpuBuffer = void 0;\n\t\tthis.offset = void 0;\n\t}\n}\nclass DynamicBuffers {\n\tconstructor(device, bufferSize, bufferAlignment) {\n\t\tthis.bufferSize = void 0;\n\t\tthis.gpuBuffers = [];\n\t\tthis.stagingBuffers = [];\n\t\tthis.usedBuffers = [];\n\t\tthis.activeBuffer = null;\n\t\tthis.device = device;\n\t\tthis.bufferSize = bufferSize;\n\t\tthis.bufferAlignment = bufferAlignment;\n\t}\n\tdestroy() {\n\t\tthis.gpuBuffers.forEach(gpuBuffer => {\n\t\t\tgpuBuffer.destroy(this.device);\n\t\t});\n\t\tthis.gpuBuffers = null;\n\t\tthis.stagingBuffers.forEach(stagingBuffer => {\n\t\t\tstagingBuffer.destroy(this.device);\n\t\t});\n\t\tthis.stagingBuffers = null;\n\t\tthis.usedBuffers = null;\n\t\tthis.activeBuffer = null;\n\t}\n\talloc(allocation, size) {\n\t\tif (this.activeBuffer) {\n\t\t\tconst _alignedStart = math.roundUp(this.activeBuffer.size, this.bufferAlignment);\n\t\t\tconst space = this.bufferSize - _alignedStart;\n\t\t\tif (space < size) {\n\t\t\t\tthis.scheduleSubmit();\n\t\t\t}\n\t\t}\n\t\tif (!this.activeBuffer) {\n\t\t\tlet gpuBuffer = this.gpuBuffers.pop();\n\t\t\tif (!gpuBuffer) {\n\t\t\t\tgpuBuffer = this.createBuffer(this.device, this.bufferSize, false);\n\t\t\t}\n\t\t\tlet stagingBuffer = this.stagingBuffers.pop();\n\t\t\tif (!stagingBuffer) {\n\t\t\t\tstagingBuffer = this.createBuffer(this.device, this.bufferSize, true);\n\t\t\t}\n\t\t\tthis.activeBuffer = new UsedBuffer();\n\t\t\tthis.activeBuffer.stagingBuffer = stagingBuffer;\n\t\t\tthis.activeBuffer.gpuBuffer = gpuBuffer;\n\t\t\tthis.activeBuffer.offset = 0;\n\t\t\tthis.activeBuffer.size = 0;\n\t\t}\n\t\tconst activeBuffer = this.activeBuffer;\n\t\tconst alignedStart = math.roundUp(activeBuffer.size, this.bufferAlignment);\n\t\tallocation.gpuBuffer = activeBuffer.gpuBuffer;\n\t\tallocation.offset = alignedStart;\n\t\tallocation.storage = activeBuffer.stagingBuffer.alloc(alignedStart, size);\n\t\tactiveBuffer.size = alignedStart + size;\n\t}\n\tscheduleSubmit() {\n\t\tif (this.activeBuffer) {\n\t\t\tthis.usedBuffers.push(this.activeBuffer);\n\t\t\tthis.activeBuffer = null;\n\t\t}\n\t}\n\tsubmit() {\n\t\tthis.scheduleSubmit();\n\t}\n}\n\nexport { DynamicBuffer, DynamicBufferAllocation, DynamicBuffers };\n", "import { UNIFORMTYPE_FLOAT, UNIFORMTYPE_VEC2, UNIFORMTYPE_VEC3, UNIFORMTYPE_VEC4, UNIFORMTYPE_INT, UNIFORMTYPE_IVEC2, UNIFORMTYPE_IVEC3, UNIFORMTYPE_IVEC4, UNIFORMTYPE_MAT2, UNIFORMTYPE_MAT3, UNIFORMTYPE_FLOATARRAY, UNIFORMTYPE_VEC2ARRAY, UNIFORMTYPE_VEC3ARRAY, UNIFORMTYPE_UINT, UNIFORMTYPE_UVEC2, UNIFORMTYPE_UVEC3, UNIFORMTYPE_UVEC4, UNIFORMTYPE_INTARRAY, UNIFORMTYPE_BOOLARRAY, UNIFORMTYPE_UINTARRAY, UNIFORMTYPE_IVEC2ARRAY, UNIFORMTYPE_BVEC2ARRAY, UNIFORMTYPE_UVEC2ARRAY, UNIFORMTYPE_IVEC3ARRAY, UNIFORMTYPE_BVEC3ARRAY, UNIFORMTYPE_UVEC3ARRAY } from './constants.js';\nimport { DynamicBufferAllocation } from './dynamic-buffers.js';\n\nconst _updateFunctions = [];\n_updateFunctions[UNIFORMTYPE_FLOAT] = function (uniformBuffer, value, offset) {\n\tconst dst = uniformBuffer.storageFloat32;\n\tdst[offset] = value;\n};\n_updateFunctions[UNIFORMTYPE_VEC2] = (uniformBuffer, value, offset) => {\n\tconst dst = uniformBuffer.storageFloat32;\n\tdst[offset] = value[0];\n\tdst[offset + 1] = value[1];\n};\n_updateFunctions[UNIFORMTYPE_VEC3] = (uniformBuffer, value, offset) => {\n\tconst dst = uniformBuffer.storageFloat32;\n\tdst[offset] = value[0];\n\tdst[offset + 1] = value[1];\n\tdst[offset + 2] = value[2];\n};\n_updateFunctions[UNIFORMTYPE_VEC4] = (uniformBuffer, value, offset) => {\n\tconst dst = uniformBuffer.storageFloat32;\n\tdst[offset] = value[0];\n\tdst[offset + 1] = value[1];\n\tdst[offset + 2] = value[2];\n\tdst[offset + 3] = value[3];\n};\n_updateFunctions[UNIFORMTYPE_INT] = function (uniformBuffer, value, offset) {\n\tconst dst = uniformBuffer.storageInt32;\n\tdst[offset] = value;\n};\n_updateFunctions[UNIFORMTYPE_IVEC2] = function (uniformBuffer, value, offset) {\n\tconst dst = uniformBuffer.storageInt32;\n\tdst[offset] = value[0];\n\tdst[offset + 1] = value[1];\n};\n_updateFunctions[UNIFORMTYPE_IVEC3] = function (uniformBuffer, value, offset) {\n\tconst dst = uniformBuffer.storageInt32;\n\tdst[offset] = value[0];\n\tdst[offset + 1] = value[1];\n\tdst[offset + 2] = value[2];\n};\n_updateFunctions[UNIFORMTYPE_IVEC4] = function (uniformBuffer, value, offset) {\n\tconst dst = uniformBuffer.storageInt32;\n\tdst[offset] = value[0];\n\tdst[offset + 1] = value[1];\n\tdst[offset + 2] = value[2];\n\tdst[offset + 3] = value[3];\n};\n_updateFunctions[UNIFORMTYPE_MAT2] = (uniformBuffer, value, offset) => {\n\tconst dst = uniformBuffer.storageFloat32;\n\tdst[offset] = value[0];\n\tdst[offset + 1] = value[1];\n\tdst[offset + 4] = value[2];\n\tdst[offset + 5] = value[3];\n\tdst[offset + 8] = value[4];\n\tdst[offset + 9] = value[5];\n};\n_updateFunctions[UNIFORMTYPE_MAT3] = (uniformBuffer, value, offset) => {\n\tconst dst = uniformBuffer.storageFloat32;\n\tdst[offset] = value[0];\n\tdst[offset + 1] = value[1];\n\tdst[offset + 2] = value[2];\n\tdst[offset + 4] = value[3];\n\tdst[offset + 5] = value[4];\n\tdst[offset + 6] = value[5];\n\tdst[offset + 8] = value[6];\n\tdst[offset + 9] = value[7];\n\tdst[offset + 10] = value[8];\n};\n_updateFunctions[UNIFORMTYPE_FLOATARRAY] = function (uniformBuffer, value, offset, count) {\n\tconst dst = uniformBuffer.storageFloat32;\n\tfor (let i = 0; i < count; i++) {\n\t\tdst[offset + i * 4] = value[i];\n\t}\n};\n_updateFunctions[UNIFORMTYPE_VEC2ARRAY] = (uniformBuffer, value, offset, count) => {\n\tconst dst = uniformBuffer.storageFloat32;\n\tfor (let i = 0; i < count; i++) {\n\t\tdst[offset + i * 4] = value[i * 2];\n\t\tdst[offset + i * 4 + 1] = value[i * 2 + 1];\n\t}\n};\n_updateFunctions[UNIFORMTYPE_VEC3ARRAY] = (uniformBuffer, value, offset, count) => {\n\tconst dst = uniformBuffer.storageFloat32;\n\tfor (let i = 0; i < count; i++) {\n\t\tdst[offset + i * 4] = value[i * 3];\n\t\tdst[offset + i * 4 + 1] = value[i * 3 + 1];\n\t\tdst[offset + i * 4 + 2] = value[i * 3 + 2];\n\t}\n};\n_updateFunctions[UNIFORMTYPE_UINT] = (uniformBuffer, value, offset, count) => {\n\tconst dst = uniformBuffer.storageUint32;\n\tdst[offset] = value;\n};\n_updateFunctions[UNIFORMTYPE_UVEC2] = (uniformBuffer, value, offset, count) => {\n\tconst dst = uniformBuffer.storageUint32;\n\tdst[offset] = value[0];\n\tdst[offset + 1] = value[1];\n};\n_updateFunctions[UNIFORMTYPE_UVEC3] = (uniformBuffer, value, offset, count) => {\n\tconst dst = uniformBuffer.storageUint32;\n\tdst[offset] = value[0];\n\tdst[offset + 1] = value[1];\n\tdst[offset + 2] = value[2];\n};\n_updateFunctions[UNIFORMTYPE_UVEC4] = (uniformBuffer, value, offset, count) => {\n\tconst dst = uniformBuffer.storageUint32;\n\tdst[offset] = value[0];\n\tdst[offset + 1] = value[1];\n\tdst[offset + 2] = value[2];\n\tdst[offset + 3] = value[3];\n};\n_updateFunctions[UNIFORMTYPE_INTARRAY] = function (uniformBuffer, value, offset, count) {\n\tconst dst = uniformBuffer.storageInt32;\n\tfor (let i = 0; i < count; i++) {\n\t\tdst[offset + i * 4] = value[i];\n\t}\n};\n_updateFunctions[UNIFORMTYPE_BOOLARRAY] = _updateFunctions[UNIFORMTYPE_INTARRAY];\n_updateFunctions[UNIFORMTYPE_UINTARRAY] = function (uniformBuffer, value, offset, count) {\n\tconst dst = uniformBuffer.storageUint32;\n\tfor (let i = 0; i < count; i++) {\n\t\tdst[offset + i * 4] = value[i];\n\t}\n};\n_updateFunctions[UNIFORMTYPE_IVEC2ARRAY] = (uniformBuffer, value, offset, count) => {\n\tconst dst = uniformBuffer.storageInt32;\n\tfor (let i = 0; i < count; i++) {\n\t\tdst[offset + i * 4] = value[i * 2];\n\t\tdst[offset + i * 4 + 1] = value[i * 2 + 1];\n\t}\n};\n_updateFunctions[UNIFORMTYPE_BVEC2ARRAY] = _updateFunctions[UNIFORMTYPE_IVEC2ARRAY];\n_updateFunctions[UNIFORMTYPE_UVEC2ARRAY] = (uniformBuffer, value, offset, count) => {\n\tconst dst = uniformBuffer.storageUint32;\n\tfor (let i = 0; i < count; i++) {\n\t\tdst[offset + i * 4] = value[i * 2];\n\t\tdst[offset + i * 4 + 1] = value[i * 2 + 1];\n\t}\n};\n_updateFunctions[UNIFORMTYPE_IVEC3ARRAY] = (uniformBuffer, value, offset, count) => {\n\tconst dst = uniformBuffer.storageInt32;\n\tfor (let i = 0; i < count; i++) {\n\t\tdst[offset + i * 4] = value[i * 3];\n\t\tdst[offset + i * 4 + 1] = value[i * 3 + 1];\n\t\tdst[offset + i * 4 + 2] = value[i * 3 + 2];\n\t}\n};\n_updateFunctions[UNIFORMTYPE_BVEC3ARRAY] = _updateFunctions[UNIFORMTYPE_IVEC3ARRAY];\n_updateFunctions[UNIFORMTYPE_UVEC3ARRAY] = (uniformBuffer, value, offset, count) => {\n\tconst dst = uniformBuffer.storageUint32;\n\tfor (let i = 0; i < count; i++) {\n\t\tdst[offset + i * 4] = value[i * 3];\n\t\tdst[offset + i * 4 + 1] = value[i * 3 + 1];\n\t\tdst[offset + i * 4 + 2] = value[i * 3 + 2];\n\t}\n};\nclass UniformBuffer {\n\tconstructor(graphicsDevice, format, persistent = true) {\n\t\tthis.device = void 0;\n\t\tthis.persistent = void 0;\n\t\tthis.allocation = void 0;\n\t\tthis.storageFloat32 = void 0;\n\t\tthis.storageInt32 = void 0;\n\t\tthis.storageUint32 = void 0;\n\t\tthis.renderVersionDirty = 0;\n\t\tthis.device = graphicsDevice;\n\t\tthis.format = format;\n\t\tthis.persistent = persistent;\n\t\tif (persistent) {\n\t\t\tthis.impl = graphicsDevice.createUniformBufferImpl(this);\n\t\t\tconst storage = new ArrayBuffer(format.byteSize);\n\t\t\tthis.assignStorage(new Int32Array(storage));\n\t\t\tgraphicsDevice._vram.ub += this.format.byteSize;\n\t\t} else {\n\t\t\tthis.allocation = new DynamicBufferAllocation();\n\t\t}\n\t}\n\tdestroy() {\n\t\tif (this.persistent) {\n\t\t\tconst device = this.device;\n\t\t\tthis.impl.destroy(device);\n\t\t\tdevice._vram.ub -= this.format.byteSize;\n\t\t}\n\t}\n\tget offset() {\n\t\treturn this.persistent ? 0 : this.allocation.offset;\n\t}\n\tassignStorage(storage) {\n\t\tthis.storageInt32 = storage;\n\t\tthis.storageUint32 = new Uint32Array(storage.buffer, storage.byteOffset, storage.byteLength / 4);\n\t\tthis.storageFloat32 = new Float32Array(storage.buffer, storage.byteOffset, storage.byteLength / 4);\n\t}\n\tloseContext() {\n\t\tvar _this$impl;\n\t\t(_this$impl = this.impl) == null || _this$impl.loseContext();\n\t}\n\tsetUniform(uniformFormat) {\n\t\tconst offset = uniformFormat.offset;\n\t\tconst value = uniformFormat.scopeId.value;\n\t\tif (value !== null && value !== undefined) {\n\t\t\tconst updateFunction = _updateFunctions[uniformFormat.updateType];\n\t\t\tif (updateFunction) {\n\t\t\t\tupdateFunction(this, value, offset, uniformFormat.count);\n\t\t\t} else {\n\t\t\t\tthis.storageFloat32.set(value, offset);\n\t\t\t}\n\t\t}\n\t}\n\tset(name) {\n\t\tconst uniformFormat = this.format.map.get(name);\n\t\tif (uniformFormat) {\n\t\t\tthis.setUniform(uniformFormat);\n\t\t}\n\t}\n\tupdate() {\n\t\tconst persistent = this.persistent;\n\t\tif (!persistent) {\n\t\t\tconst allocation = this.allocation;\n\t\t\tconst oldGpuBuffer = allocation.gpuBuffer;\n\t\t\tthis.device.dynamicBuffers.alloc(allocation, this.format.byteSize);\n\t\t\tthis.assignStorage(allocation.storage);\n\t\t\tif (oldGpuBuffer !== allocation.gpuBuffer) {\n\t\t\t\tthis.renderVersionDirty = this.device.renderVersion;\n\t\t\t}\n\t\t}\n\t\tconst uniforms = this.format.uniforms;\n\t\tfor (let i = 0; i < uniforms.length; i++) {\n\t\t\tthis.setUniform(uniforms[i]);\n\t\t}\n\t\tif (persistent) {\n\t\t\tthis.impl.unlock(this);\n\t\t} else {\n\t\t\tthis.storageFloat32 = null;\n\t\t\tthis.storageInt32 = null;\n\t\t}\n\t}\n}\n\nexport { UniformBuffer };\n", "import { BindGroupFormat, BindUniformBufferFormat } from '../bind-group-format.js';\nimport { UniformBufferFormat, UniformFormat } from '../uniform-buffer-format.js';\nimport { BlendState } from '../blend-state.js';\nimport { SHADERLANGUAGE_WGSL, UNIFORMTYPE_VEC4, UNIFORMTYPE_FLOAT, UNIFORM_BUFFER_DEFAULT_SLOT_NAME, SHADERSTAGE_VERTEX, SHADERSTAGE_FRAGMENT, CLEARFLAG_COLOR, CLEARFLAG_DEPTH, CLEARFLAG_STENCIL, CULLFACE_NONE, BINDGROUP_MESH, PRIMITIVE_TRISTRIP } from '../constants.js';\nimport { Shader } from '../shader.js';\nimport { BindGroup } from '../bind-group.js';\nimport { UniformBuffer } from '../uniform-buffer.js';\nimport { DepthState } from '../depth-state.js';\n\nconst primitive = {\n\ttype: PRIMITIVE_TRISTRIP,\n\tbase: 0,\n\tcount: 4,\n\tindexed: false\n};\nclass WebgpuClearRenderer {\n\tconstructor(device) {\n\t\tconst code = `\n\n\t\t\t\t\t\tstruct ub_mesh {\n\t\t\t\t\t\t\t\tcolor : vec4f,\n\t\t\t\t\t\t\t\tdepth: f32\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t@group(0) @binding(0) var ubMesh : ub_mesh;\n\n\t\t\t\t\t\tvar pos : array = array(\n\t\t\t\t\t\t\t\tvec2(-1.0, 1.0), vec2(1.0, 1.0),\n\t\t\t\t\t\t\t\tvec2(-1.0, -1.0), vec2(1.0, -1.0)\n\t\t\t\t\t\t);\n\n\t\t\t\t\t\tstruct VertexOutput {\n\t\t\t\t\t\t\t\t@builtin(position) position : vec4f\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t@vertex\n\t\t\t\t\t\tfn vertexMain(@builtin(vertex_index) vertexIndex : u32) -> VertexOutput {\n\t\t\t\t\t\t\t\tvar output : VertexOutput;\n\t\t\t\t\t\t\t\toutput.position = vec4(pos[vertexIndex], ubMesh.depth, 1.0);\n\t\t\t\t\t\t\t\treturn output;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t@fragment\n\t\t\t\t\t\tfn fragmentMain() -> @location(0) vec4f {\n\t\t\t\t\t\t\t\treturn ubMesh.color;\n\t\t\t\t\t\t}\n\t\t\t\t`;\n\t\tthis.shader = new Shader(device, {\n\t\t\tname: 'WebGPUClearRendererShader',\n\t\t\tshaderLanguage: SHADERLANGUAGE_WGSL,\n\t\t\tvshader: code,\n\t\t\tfshader: code\n\t\t});\n\t\tthis.uniformBuffer = new UniformBuffer(device, new UniformBufferFormat(device, [new UniformFormat('color', UNIFORMTYPE_VEC4), new UniformFormat('depth', UNIFORMTYPE_FLOAT)]), false);\n\t\tconst bindGroupFormat = new BindGroupFormat(device, [new BindUniformBufferFormat(UNIFORM_BUFFER_DEFAULT_SLOT_NAME, SHADERSTAGE_VERTEX | SHADERSTAGE_FRAGMENT)]);\n\t\tthis.bindGroup = new BindGroup(device, bindGroupFormat, this.uniformBuffer);\n\t\tthis.colorData = new Float32Array(4);\n\t\tthis.colorId = device.scope.resolve('color');\n\t\tthis.depthId = device.scope.resolve('depth');\n\t}\n\tdestroy() {\n\t\tthis.shader.destroy();\n\t\tthis.shader = null;\n\t\tthis.uniformBuffer.destroy();\n\t\tthis.uniformBuffer = null;\n\t\tthis.bindGroup.destroy();\n\t\tthis.bindGroup = null;\n\t}\n\tclear(device, renderTarget, options, defaultOptions) {\n\t\tvar _options$flags;\n\t\toptions = options || defaultOptions;\n\t\tconst flags = (_options$flags = options.flags) != null ? _options$flags : defaultOptions.flags;\n\t\tif (flags !== 0) {\n\t\t\tif (flags & CLEARFLAG_COLOR && (renderTarget.colorBuffer || renderTarget.impl.assignedColorTexture)) {\n\t\t\t\tvar _options$color;\n\t\t\t\tconst color = (_options$color = options.color) != null ? _options$color : defaultOptions.color;\n\t\t\t\tthis.colorData.set(color);\n\t\t\t\tdevice.setBlendState(BlendState.NOBLEND);\n\t\t\t} else {\n\t\t\t\tdevice.setBlendState(BlendState.NOWRITE);\n\t\t\t}\n\t\t\tthis.colorId.setValue(this.colorData);\n\t\t\tif (flags & CLEARFLAG_DEPTH && renderTarget.depth) {\n\t\t\t\tvar _options$depth;\n\t\t\t\tconst depth = (_options$depth = options.depth) != null ? _options$depth : defaultOptions.depth;\n\t\t\t\tthis.depthId.setValue(depth);\n\t\t\t\tdevice.setDepthState(DepthState.WRITEDEPTH);\n\t\t\t} else {\n\t\t\t\tthis.depthId.setValue(1);\n\t\t\t\tdevice.setDepthState(DepthState.NODEPTH);\n\t\t\t}\n\t\t\tif (flags & CLEARFLAG_STENCIL && renderTarget.stencil) ;\n\t\t\tdevice.setCullMode(CULLFACE_NONE);\n\t\t\tdevice.setShader(this.shader);\n\t\t\tconst bindGroup = this.bindGroup;\n\t\t\tbindGroup.defaultUniformBuffer.update();\n\t\t\tbindGroup.update();\n\t\t\tdevice.setBindGroup(BINDGROUP_MESH, bindGroup);\n\t\t\tdevice.draw(primitive);\n\t\t}\n\t}\n}\n\nexport { WebgpuClearRenderer };\n", "import { Shader } from '../shader.js';\nimport { SHADERLANGUAGE_WGSL } from '../constants.js';\n\nclass WebgpuMipmapRenderer {\n\tconstructor(device) {\n\t\tthis.device = void 0;\n\t\tthis.device = device;\n\t\tconst code = `\n \n\t\t\t\t\t\tvar pos : array = array(\n\t\t\t\t\t\t\t\tvec2(-1.0, 1.0), vec2(1.0, 1.0),\n\t\t\t\t\t\t\t\tvec2(-1.0, -1.0), vec2(1.0, -1.0)\n\t\t\t\t\t\t);\n\n\t\t\t\t\t\tstruct VertexOutput {\n\t\t\t\t\t\t\t\t@builtin(position) position : vec4f,\n\t\t\t\t\t\t\t\t@location(0) texCoord : vec2f\n\t\t\t\t\t\t};\n\n\t\t\t\t\t\t@vertex\n\t\t\t\t\t\tfn vertexMain(@builtin(vertex_index) vertexIndex : u32) -> VertexOutput {\n\t\t\t\t\t\t\tvar output : VertexOutput;\n\t\t\t\t\t\t\toutput.texCoord = pos[vertexIndex] * vec2f(0.5, -0.5) + vec2f(0.5);\n\t\t\t\t\t\t\toutput.position = vec4f(pos[vertexIndex], 0, 1);\n\t\t\t\t\t\t\treturn output;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t@group(0) @binding(0) var imgSampler : sampler;\n\t\t\t\t\t\t@group(0) @binding(1) var img : texture_2d;\n\n\t\t\t\t\t\t@fragment\n\t\t\t\t\t\tfn fragmentMain(@location(0) texCoord : vec2f) -> @location(0) vec4f {\n\t\t\t\t\t\t\treturn textureSample(img, imgSampler, texCoord);\n\t\t\t\t\t\t}\n\t\t\t\t`;\n\t\tthis.shader = new Shader(device, {\n\t\t\tname: 'WebGPUMipmapRendererShader',\n\t\t\tshaderLanguage: SHADERLANGUAGE_WGSL,\n\t\t\tvshader: code,\n\t\t\tfshader: code\n\t\t});\n\t\tthis.minSampler = device.wgpu.createSampler({\n\t\t\tminFilter: 'linear'\n\t\t});\n\t}\n\tdestroy() {\n\t\tthis.shader.destroy();\n\t\tthis.shader = null;\n\t}\n\tgenerate(webgpuTexture) {\n\t\tvar _device$commandEncode;\n\t\tconst textureDescr = webgpuTexture.descr;\n\t\tif (textureDescr.mipLevelCount <= 1) {\n\t\t\treturn;\n\t\t}\n\t\tif (webgpuTexture.texture.volume) {\n\t\t\treturn;\n\t\t}\n\t\tconst device = this.device;\n\t\tconst wgpu = device.wgpu;\n\t\tconst webgpuShader = this.shader.impl;\n\t\tconst pipeline = wgpu.createRenderPipeline({\n\t\t\tlayout: 'auto',\n\t\t\tvertex: {\n\t\t\t\tmodule: webgpuShader.getVertexShaderModule(),\n\t\t\t\tentryPoint: webgpuShader.vertexEntryPoint\n\t\t\t},\n\t\t\tfragment: {\n\t\t\t\tmodule: webgpuShader.getFragmentShaderModule(),\n\t\t\t\tentryPoint: webgpuShader.fragmentEntryPoint,\n\t\t\t\ttargets: [{\n\t\t\t\t\tformat: textureDescr.format\n\t\t\t\t}]\n\t\t\t},\n\t\t\tprimitive: {\n\t\t\t\ttopology: 'triangle-strip'\n\t\t\t}\n\t\t});\n\t\tconst texture = webgpuTexture.texture;\n\t\tconst numFaces = texture.cubemap ? 6 : texture.array ? texture.arrayLength : 1;\n\t\tconst srcViews = [];\n\t\tfor (let face = 0; face < numFaces; face++) {\n\t\t\tsrcViews.push(webgpuTexture.createView({\n\t\t\t\tdimension: '2d',\n\t\t\t\tbaseMipLevel: 0,\n\t\t\t\tmipLevelCount: 1,\n\t\t\t\tbaseArrayLayer: face\n\t\t\t}));\n\t\t}\n\t\tconst commandEncoder = (_device$commandEncode = device.commandEncoder) != null ? _device$commandEncode : wgpu.createCommandEncoder();\n\t\tfor (let i = 1; i < textureDescr.mipLevelCount; i++) {\n\t\t\tfor (let face = 0; face < numFaces; face++) {\n\t\t\t\tconst dstView = webgpuTexture.createView({\n\t\t\t\t\tdimension: '2d',\n\t\t\t\t\tbaseMipLevel: i,\n\t\t\t\t\tmipLevelCount: 1,\n\t\t\t\t\tbaseArrayLayer: face\n\t\t\t\t});\n\t\t\t\tconst passEncoder = commandEncoder.beginRenderPass({\n\t\t\t\t\tcolorAttachments: [{\n\t\t\t\t\t\tview: dstView,\n\t\t\t\t\t\tloadOp: 'clear',\n\t\t\t\t\t\tstoreOp: 'store'\n\t\t\t\t\t}]\n\t\t\t\t});\n\t\t\t\tconst bindGroup = wgpu.createBindGroup({\n\t\t\t\t\tlayout: pipeline.getBindGroupLayout(0),\n\t\t\t\t\tentries: [{\n\t\t\t\t\t\tbinding: 0,\n\t\t\t\t\t\tresource: this.minSampler\n\t\t\t\t\t}, {\n\t\t\t\t\t\tbinding: 1,\n\t\t\t\t\t\tresource: srcViews[face]\n\t\t\t\t\t}]\n\t\t\t\t});\n\t\t\t\tpassEncoder.setPipeline(pipeline);\n\t\t\t\tpassEncoder.setBindGroup(0, bindGroup);\n\t\t\t\tpassEncoder.draw(4);\n\t\t\t\tpassEncoder.end();\n\t\t\t\tsrcViews[face] = dstView;\n\t\t\t}\n\t\t}\n\t\tif (!device.commandEncoder) {\n\t\t\tconst cb = commandEncoder.finish();\n\t\t\tdevice.addCommandBuffer(cb);\n\t\t}\n\t\tdevice.pipeline = null;\n\t}\n}\n\nexport { WebgpuMipmapRenderer };\n", "import { DynamicBuffer } from '../dynamic-buffers.js';\n\nclass WebgpuDynamicBuffer extends DynamicBuffer {\n\tconstructor(device, size, isStaging) {\n\t\tsuper(device);\n\t\tthis.buffer = null;\n\t\tthis.mappedRange = null;\n\t\tthis.buffer = device.wgpu.createBuffer({\n\t\t\tsize: size,\n\t\t\tusage: isStaging ? GPUBufferUsage.MAP_WRITE | GPUBufferUsage.COPY_SRC : GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,\n\t\t\tmappedAtCreation: isStaging\n\t\t});\n\t\tif (isStaging) {\n\t\t\tthis.onAvailable();\n\t\t}\n\t\tdevice._vram.ub += size;\n\t}\n\tdestroy(device) {\n\t\tdevice._vram.ub -= this.buffer.size;\n\t\tthis.buffer.destroy();\n\t\tthis.buffer = null;\n\t}\n\tonAvailable() {\n\t\tthis.mappedRange = this.buffer.getMappedRange();\n\t}\n\talloc(offset, size) {\n\t\treturn new Int32Array(this.mappedRange, offset, size / 4);\n\t}\n}\n\nexport { WebgpuDynamicBuffer };\n", "import { DynamicBuffers } from '../dynamic-buffers.js';\nimport { WebgpuDynamicBuffer } from './webgpu-dynamic-buffer.js';\n\nclass WebgpuDynamicBuffers extends DynamicBuffers {\n\tconstructor(...args) {\n\t\tsuper(...args);\n\t\tthis.pendingStagingBuffers = [];\n\t}\n\tcreateBuffer(device, size, isStaging) {\n\t\treturn new WebgpuDynamicBuffer(device, size, isStaging);\n\t}\n\tsubmit() {\n\t\tsuper.submit();\n\t\tconst count = this.usedBuffers.length;\n\t\tif (count) {\n\t\t\tconst device = this.device;\n\t\t\tconst gpuBuffers = this.gpuBuffers;\n\t\t\tconst commandEncoder = device.wgpu.createCommandEncoder();\n\t\t\tfor (let i = count - 1; i >= 0; i--) {\n\t\t\t\tconst usedBuffer = this.usedBuffers[i];\n\t\t\t\tconst {\n\t\t\t\t\tstagingBuffer,\n\t\t\t\t\tgpuBuffer,\n\t\t\t\t\toffset,\n\t\t\t\t\tsize\n\t\t\t\t} = usedBuffer;\n\t\t\t\tconst src = stagingBuffer.buffer;\n\t\t\t\tsrc.unmap();\n\t\t\t\tcommandEncoder.copyBufferToBuffer(src, offset, gpuBuffer.buffer, offset, size);\n\t\t\t\tgpuBuffers.push(gpuBuffer);\n\t\t\t}\n\t\t\tconst cb = commandEncoder.finish();\n\t\t\tdevice.addCommandBuffer(cb, true);\n\t\t\tfor (let i = 0; i < count; i++) {\n\t\t\t\tconst stagingBuffer = this.usedBuffers[i].stagingBuffer;\n\t\t\t\tthis.pendingStagingBuffers.push(stagingBuffer);\n\t\t\t}\n\t\t\tthis.usedBuffers.length = 0;\n\t\t}\n\t}\n\tonCommandBuffersSubmitted() {\n\t\tconst count = this.pendingStagingBuffers.length;\n\t\tif (count) {\n\t\t\tfor (let i = 0; i < count; i++) {\n\t\t\t\tconst stagingBuffer = this.pendingStagingBuffers[i];\n\t\t\t\tstagingBuffer.buffer.mapAsync(GPUMapMode.WRITE).then(() => {\n\t\t\t\t\tif (this.stagingBuffers) {\n\t\t\t\t\t\tstagingBuffer.onAvailable();\n\t\t\t\t\t\tthis.stagingBuffers.push(stagingBuffer);\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t}\n\t\t\tthis.pendingStagingBuffers.length = 0;\n\t\t}\n\t}\n}\n\nexport { WebgpuDynamicBuffers };\n", "import { TRACEID_GPU_TIMINGS } from '../../core/constants.js';\nimport { Tracing } from '../../core/tracing.js';\n\nclass GpuProfiler {\n\tconstructor() {\n\t\tthis.frameAllocations = [];\n\t\tthis.pastFrameAllocations = new Map();\n\t\tthis._enabled = false;\n\t\tthis._enableRequest = false;\n\t\tthis._frameTime = 0;\n\t}\n\tloseContext() {\n\t\tthis.pastFrameAllocations.clear();\n\t}\n\tset enabled(value) {\n\t\tthis._enableRequest = value;\n\t}\n\tget enabled() {\n\t\treturn this._enableRequest;\n\t}\n\tprocessEnableRequest() {\n\t\tif (this._enableRequest !== this._enabled) {\n\t\t\tthis._enabled = this._enableRequest;\n\t\t\tif (!this._enabled) {\n\t\t\t\tthis._frameTime = 0;\n\t\t\t}\n\t\t}\n\t}\n\trequest(renderVersion) {\n\t\tthis.pastFrameAllocations.set(renderVersion, this.frameAllocations);\n\t\tthis.frameAllocations = [];\n\t}\n\treport(renderVersion, timings) {\n\t\tif (timings) {\n\t\t\tconst allocations = this.pastFrameAllocations.get(renderVersion);\n\t\t\tif (timings.length > 0) {\n\t\t\t\tthis._frameTime = timings[0];\n\t\t\t}\n\t\t\tif (Tracing.get(TRACEID_GPU_TIMINGS)) {\n\t\t\t\tfor (let i = 0; i < allocations.length; ++i) {\n\t\t\t\t\tallocations[i];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tthis.pastFrameAllocations.delete(renderVersion);\n\t}\n\tgetSlot(name) {\n\t\tconst slot = this.frameAllocations.length;\n\t\tthis.frameAllocations.push(name);\n\t\treturn slot;\n\t}\n\tget slotCount() {\n\t\treturn this.frameAllocations.length;\n\t}\n}\n\nexport { GpuProfiler };\n", "class WebgpuQuerySet {\n\tconstructor(device, isTimestamp, capacity) {\n\t\tthis.querySet = void 0;\n\t\tthis.stagingBuffers = [];\n\t\tthis.activeStagingBuffer = null;\n\t\tthis.bytesPerSlot = void 0;\n\t\tthis.device = device;\n\t\tthis.capacity = capacity;\n\t\tthis.bytesPerSlot = isTimestamp ? 8 : 4;\n\t\tconst wgpu = device.wgpu;\n\t\tthis.querySet = wgpu.createQuerySet({\n\t\t\ttype: isTimestamp ? 'timestamp' : 'occlusion',\n\t\t\tcount: capacity\n\t\t});\n\t\tthis.queryBuffer = wgpu.createBuffer({\n\t\t\tsize: this.bytesPerSlot * capacity,\n\t\t\tusage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST\n\t\t});\n\t}\n\tdestroy() {\n\t\tvar _this$querySet, _this$queryBuffer;\n\t\t(_this$querySet = this.querySet) == null || _this$querySet.destroy();\n\t\tthis.querySet = null;\n\t\t(_this$queryBuffer = this.queryBuffer) == null || _this$queryBuffer.destroy();\n\t\tthis.queryBuffer = null;\n\t\tthis.activeStagingBuffer = null;\n\t\tthis.stagingBuffers.forEach(stagingBuffer => {\n\t\t\tstagingBuffer.destroy();\n\t\t});\n\t\tthis.stagingBuffers = null;\n\t}\n\tgetStagingBuffer() {\n\t\tlet stagingBuffer = this.stagingBuffers.pop();\n\t\tif (!stagingBuffer) {\n\t\t\tstagingBuffer = this.device.wgpu.createBuffer({\n\t\t\t\tsize: this.queryBuffer.size,\n\t\t\t\tusage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ\n\t\t\t});\n\t\t}\n\t\treturn stagingBuffer;\n\t}\n\tresolve(count) {\n\t\tconst device = this.device;\n\t\tconst commandEncoder = device.wgpu.createCommandEncoder();\n\t\tcommandEncoder.resolveQuerySet(this.querySet, 0, count, this.queryBuffer, 0);\n\t\tconst activeStagingBuffer = this.getStagingBuffer();\n\t\tthis.activeStagingBuffer = activeStagingBuffer;\n\t\tcommandEncoder.copyBufferToBuffer(this.queryBuffer, 0, activeStagingBuffer, 0, this.bytesPerSlot * count);\n\t\tconst cb = commandEncoder.finish();\n\t\tdevice.addCommandBuffer(cb);\n\t}\n\trequest(count, renderVersion) {\n\t\tconst stagingBuffer = this.activeStagingBuffer;\n\t\tthis.activeStagingBuffer = null;\n\t\treturn stagingBuffer.mapAsync(GPUMapMode.READ).then(() => {\n\t\t\tvar _this$stagingBuffers;\n\t\t\tconst srcTimings = new BigInt64Array(stagingBuffer.getMappedRange());\n\t\t\tconst timings = [];\n\t\t\tfor (let i = 0; i < count; i++) {\n\t\t\t\ttimings.push(Number(srcTimings[i * 2 + 1] - srcTimings[i * 2]) * 0.000001);\n\t\t\t}\n\t\t\tstagingBuffer.unmap();\n\t\t\t(_this$stagingBuffers = this.stagingBuffers) == null || _this$stagingBuffers.push(stagingBuffer);\n\t\t\treturn {\n\t\t\t\trenderVersion,\n\t\t\t\ttimings\n\t\t\t};\n\t\t});\n\t}\n}\n\nexport { WebgpuQuerySet };\n", "import { GpuProfiler } from '../gpu-profiler.js';\nimport { WebgpuQuerySet } from './webgpu-query-set.js';\n\nclass WebgpuGpuProfiler extends GpuProfiler {\n\tconstructor(device) {\n\t\tsuper();\n\t\tthis.device = void 0;\n\t\tthis.frameGPUMarkerSlot = void 0;\n\t\tthis.device = device;\n\t\tthis.timestampQueriesSet = device.supportsTimestampQuery ? new WebgpuQuerySet(device, true, 512) : null;\n\t}\n\tdestroy() {\n\t\tvar _this$timestampQuerie;\n\t\t(_this$timestampQuerie = this.timestampQueriesSet) == null || _this$timestampQuerie.destroy();\n\t\tthis.timestampQueriesSet = null;\n\t}\n\tframeStart() {\n\t\tthis.processEnableRequest();\n\t}\n\tframeEnd() {\n\t\tif (this._enabled) {\n\t\t\tvar _this$timestampQuerie2;\n\t\t\t(_this$timestampQuerie2 = this.timestampQueriesSet) == null || _this$timestampQuerie2.resolve(this.slotCount * 2);\n\t\t}\n\t}\n\trequest() {\n\t\tif (this._enabled) {\n\t\t\tvar _this$timestampQuerie3;\n\t\t\tconst renderVersion = this.device.renderVersion;\n\t\t\t(_this$timestampQuerie3 = this.timestampQueriesSet) == null || _this$timestampQuerie3.request(this.slotCount, renderVersion).then(results => {\n\t\t\t\tthis.report(results.renderVersion, results.timings);\n\t\t\t});\n\t\t\tsuper.request(renderVersion);\n\t\t}\n\t}\n}\n\nexport { WebgpuGpuProfiler };\n", "import { Shader } from '../shader.js';\nimport { SHADERLANGUAGE_WGSL } from '../constants.js';\n\nclass WebgpuResolver {\n\tconstructor(device) {\n\t\tthis.device = void 0;\n\t\tthis.pipelineCache = new Map();\n\t\tthis.device = device;\n\t\tconst code = `\n \n\t\t\t\t\t\tvar pos : array = array(\n\t\t\t\t\t\t\t\tvec2(-1.0, 1.0), vec2(1.0, 1.0), vec2(-1.0, -1.0), vec2(1.0, -1.0)\n\t\t\t\t\t\t);\n\n\t\t\t\t\t\tstruct VertexOutput {\n\t\t\t\t\t\t\t\t@builtin(position) position : vec4f,\n\t\t\t\t\t\t};\n\n\t\t\t\t\t\t@vertex\n\t\t\t\t\t\tfn vertexMain(@builtin(vertex_index) vertexIndex : u32) -> VertexOutput {\n\t\t\t\t\t\t\tvar output : VertexOutput;\n\t\t\t\t\t\t\toutput.position = vec4f(pos[vertexIndex], 0, 1);\n\t\t\t\t\t\t\treturn output;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t@group(0) @binding(0) var img : texture_depth_multisampled_2d;\n\n\t\t\t\t\t\t@fragment\n\t\t\t\t\t\tfn fragmentMain(@builtin(position) fragColor: vec4f) -> @location(0) vec4f {\n\t\t\t\t\t\t\t\t// load th depth value from sample index 0\n\t\t\t\t\t\t\t\tvar depth = textureLoad(img, vec2i(fragColor.xy), 0u);\n\t\t\t\t\t\t\t\treturn vec4(depth, 0.0, 0.0, 0.0);\n\t\t\t\t\t\t}\n\t\t\t\t`;\n\t\tthis.shader = new Shader(device, {\n\t\t\tname: 'WebGPUResolverDepthShader',\n\t\t\tshaderLanguage: SHADERLANGUAGE_WGSL,\n\t\t\tvshader: code,\n\t\t\tfshader: code\n\t\t});\n\t}\n\tdestroy() {\n\t\tthis.shader.destroy();\n\t\tthis.shader = null;\n\t\tthis.pipelineCache = null;\n\t}\n\tgetPipeline(format) {\n\t\tlet pipeline = this.pipelineCache.get(format);\n\t\tif (!pipeline) {\n\t\t\tpipeline = this.createPipeline(format);\n\t\t\tthis.pipelineCache.set(format, pipeline);\n\t\t}\n\t\treturn pipeline;\n\t}\n\tcreatePipeline(format) {\n\t\tconst webgpuShader = this.shader.impl;\n\t\tconst pipeline = this.device.wgpu.createRenderPipeline({\n\t\t\tlayout: 'auto',\n\t\t\tvertex: {\n\t\t\t\tmodule: webgpuShader.getVertexShaderModule(),\n\t\t\t\tentryPoint: webgpuShader.vertexEntryPoint\n\t\t\t},\n\t\t\tfragment: {\n\t\t\t\tmodule: webgpuShader.getFragmentShaderModule(),\n\t\t\t\tentryPoint: webgpuShader.fragmentEntryPoint,\n\t\t\t\ttargets: [{\n\t\t\t\t\tformat: format\n\t\t\t\t}]\n\t\t\t},\n\t\t\tprimitive: {\n\t\t\t\ttopology: 'triangle-strip'\n\t\t\t}\n\t\t});\n\t\treturn pipeline;\n\t}\n\tresolveDepth(commandEncoder, sourceTexture, destinationTexture) {\n\t\tconst device = this.device;\n\t\tconst wgpu = device.wgpu;\n\t\tconst pipeline = this.getPipeline(destinationTexture.format);\n\t\tconst numFaces = sourceTexture.depthOrArrayLayers;\n\t\tfor (let face = 0; face < numFaces; face++) {\n\t\t\tconst srcView = sourceTexture.createView({\n\t\t\t\tdimension: '2d',\n\t\t\t\taspect: 'depth-only',\n\t\t\t\tbaseMipLevel: 0,\n\t\t\t\tmipLevelCount: 1,\n\t\t\t\tbaseArrayLayer: face\n\t\t\t});\n\t\t\tconst dstView = destinationTexture.createView({\n\t\t\t\tdimension: '2d',\n\t\t\t\tbaseMipLevel: 0,\n\t\t\t\tmipLevelCount: 1,\n\t\t\t\tbaseArrayLayer: face\n\t\t\t});\n\t\t\tconst passEncoder = commandEncoder.beginRenderPass({\n\t\t\t\tcolorAttachments: [{\n\t\t\t\t\tview: dstView,\n\t\t\t\t\tloadOp: 'clear',\n\t\t\t\t\tstoreOp: 'store'\n\t\t\t\t}]\n\t\t\t});\n\t\t\tconst bindGroup = wgpu.createBindGroup({\n\t\t\t\tlayout: pipeline.getBindGroupLayout(0),\n\t\t\t\tentries: [{\n\t\t\t\t\tbinding: 0,\n\t\t\t\t\tresource: srcView\n\t\t\t\t}]\n\t\t\t});\n\t\t\tpassEncoder.setPipeline(pipeline);\n\t\t\tpassEncoder.setBindGroup(0, bindGroup);\n\t\t\tpassEncoder.draw(4);\n\t\t\tpassEncoder.end();\n\t\t}\n\t\tdevice.pipeline = null;\n\t}\n}\n\nexport { WebgpuResolver };\n", "import { BindGroup } from '../bind-group.js';\nimport { UniformBuffer } from '../uniform-buffer.js';\n\nclass WebgpuCompute {\n\tconstructor(compute) {\n\t\tthis.uniformBuffers = [];\n\t\tthis.bindGroup = null;\n\t\tthis.compute = compute;\n\t\tconst {\n\t\t\tdevice,\n\t\t\tshader\n\t\t} = compute;\n\t\tconst {\n\t\t\tcomputeBindGroupFormat,\n\t\t\tcomputeUniformBufferFormats\n\t\t} = shader.impl;\n\t\tthis.bindGroup = new BindGroup(device, computeBindGroupFormat);\n\t\tif (computeUniformBufferFormats) {\n\t\t\tfor (const name in computeUniformBufferFormats) {\n\t\t\t\tif (computeUniformBufferFormats.hasOwnProperty(name)) {\n\t\t\t\t\tconst ub = new UniformBuffer(device, computeUniformBufferFormats[name], true);\n\t\t\t\t\tthis.uniformBuffers.push(ub);\n\t\t\t\t\tthis.bindGroup.setUniformBuffer(name, ub);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tthis.pipeline = device.computePipeline.get(shader, computeBindGroupFormat);\n\t}\n\tdestroy() {\n\t\tthis.uniformBuffers.forEach(ub => ub.destroy());\n\t\tthis.uniformBuffers.length = 0;\n\t\tthis.bindGroup.destroy();\n\t\tthis.bindGroup = null;\n\t}\n\tupdateBindGroup() {\n\t\tconst {\n\t\t\tbindGroup\n\t\t} = this;\n\t\tbindGroup.updateUniformBuffers();\n\t\tbindGroup.update();\n\t}\n\tdispatch(x, y, z) {\n\t\tconst device = this.compute.device;\n\t\tdevice.setBindGroup(0, this.bindGroup);\n\t\tconst passEncoder = device.passEncoder;\n\t\tpassEncoder.setPipeline(this.pipeline);\n\t\tpassEncoder.dispatchWorkgroups(x, y, z);\n\t}\n}\n\nexport { WebgpuCompute };\n", "import { DEVICETYPE_WEBGPU, PIXELFORMAT_RGBA32F, PIXELFORMAT_RGBA8, PIXELFORMAT_BGRA8, BUFFERUSAGE_READ, BUFFERUSAGE_COPY_DST, semanticToLocation } from '../constants.js';\nimport { GraphicsDevice } from '../graphics-device.js';\nimport { RenderTarget } from '../render-target.js';\nimport { StencilParameters } from '../stencil-parameters.js';\nimport { WebgpuBindGroup } from './webgpu-bind-group.js';\nimport { WebgpuBindGroupFormat } from './webgpu-bind-group-format.js';\nimport { WebgpuIndexBuffer } from './webgpu-index-buffer.js';\nimport { WebgpuRenderPipeline } from './webgpu-render-pipeline.js';\nimport { WebgpuComputePipeline } from './webgpu-compute-pipeline.js';\nimport { WebgpuRenderTarget } from './webgpu-render-target.js';\nimport { WebgpuShader } from './webgpu-shader.js';\nimport { WebgpuTexture } from './webgpu-texture.js';\nimport { WebgpuUniformBuffer } from './webgpu-uniform-buffer.js';\nimport { WebgpuVertexBuffer } from './webgpu-vertex-buffer.js';\nimport { WebgpuClearRenderer } from './webgpu-clear-renderer.js';\nimport { WebgpuMipmapRenderer } from './webgpu-mipmap-renderer.js';\nimport { WebgpuDynamicBuffers } from './webgpu-dynamic-buffers.js';\nimport { WebgpuGpuProfiler } from './webgpu-gpu-profiler.js';\nimport { WebgpuResolver } from './webgpu-resolver.js';\nimport { WebgpuCompute } from './webgpu-compute.js';\nimport { WebgpuBuffer } from './webgpu-buffer.js';\n\nconst _uniqueLocations = new Map();\nclass WebgpuGraphicsDevice extends GraphicsDevice {\n\tconstructor(canvas, options = {}) {\n\t\tvar _options$alpha, _options$antialias;\n\t\tsuper(canvas, options);\n\t\tthis.renderPipeline = new WebgpuRenderPipeline(this);\n\t\tthis.computePipeline = new WebgpuComputePipeline(this);\n\t\tthis.clearRenderer = void 0;\n\t\tthis.mipmapRenderer = void 0;\n\t\tthis.pipeline = void 0;\n\t\tthis.bindGroupFormats = [];\n\t\tthis.commandEncoder = null;\n\t\tthis.commandBuffers = [];\n\t\tthis.limits = void 0;\n\t\toptions = this.initOptions;\n\t\toptions.alpha = (_options$alpha = options.alpha) != null ? _options$alpha : true;\n\t\tthis.backBufferAntialias = (_options$antialias = options.antialias) != null ? _options$antialias : false;\n\t\tthis.isWebGPU = true;\n\t\tthis._deviceType = DEVICETYPE_WEBGPU;\n\t}\n\tdestroy() {\n\t\tthis.clearRenderer.destroy();\n\t\tthis.clearRenderer = null;\n\t\tthis.mipmapRenderer.destroy();\n\t\tthis.mipmapRenderer = null;\n\t\tthis.resolver.destroy();\n\t\tthis.resolver = null;\n\t\tsuper.destroy();\n\t}\n\tinitDeviceCaps() {\n\t\tvar _this$wgpu;\n\t\tconst limits = (_this$wgpu = this.wgpu) == null ? void 0 : _this$wgpu.limits;\n\t\tthis.limits = limits;\n\t\tthis.precision = 'highp';\n\t\tthis.maxPrecision = 'highp';\n\t\tthis.maxSamples = 4;\n\t\tthis.maxTextures = 16;\n\t\tthis.maxTextureSize = limits.maxTextureDimension2D;\n\t\tthis.maxCubeMapSize = limits.maxTextureDimension2D;\n\t\tthis.maxVolumeSize = limits.maxTextureDimension3D;\n\t\tthis.maxColorAttachments = limits.maxColorAttachments;\n\t\tthis.maxPixelRatio = 1;\n\t\tthis.maxAnisotropy = 16;\n\t\tthis.fragmentUniformsCount = limits.maxUniformBufferBindingSize / 16;\n\t\tthis.vertexUniformsCount = limits.maxUniformBufferBindingSize / 16;\n\t\tthis.supportsInstancing = true;\n\t\tthis.supportsUniformBuffers = true;\n\t\tthis.supportsVolumeTextures = true;\n\t\tthis.supportsBoneTextures = true;\n\t\tthis.supportsMorphTargetTexturesCore = true;\n\t\tthis.supportsAreaLights = true;\n\t\tthis.supportsDepthShadow = true;\n\t\tthis.supportsGpuParticles = true;\n\t\tthis.supportsMrt = true;\n\t\tthis.supportsCompute = true;\n\t\tthis.extUintElement = true;\n\t\tthis.extTextureFloat = true;\n\t\tthis.textureFloatRenderable = true;\n\t\tthis.textureHalfFloatFilterable = true;\n\t\tthis.extTextureHalfFloat = true;\n\t\tthis.textureHalfFloatRenderable = true;\n\t\tthis.textureHalfFloatUpdatable = true;\n\t\tthis.boneLimit = 1024;\n\t\tthis.supportsImageBitmap = true;\n\t\tthis.extStandardDerivatives = true;\n\t\tthis.extBlendMinmax = true;\n\t\tthis.areaLightLutFormat = this.textureFloatFilterable ? PIXELFORMAT_RGBA32F : PIXELFORMAT_RGBA8;\n\t\tthis.supportsTextureFetch = true;\n\t\tthis.samples = this.backBufferAntialias ? 4 : 1;\n\t\tconst wgslFeatures = navigator.gpu.wgslLanguageFeatures;\n\t\tthis.supportsStorageTextureRead = wgslFeatures == null ? void 0 : wgslFeatures.has('readonly_and_readwrite_storage_textures');\n\t}\n\tasync initWebGpu(glslangUrl, twgslUrl) {\n\t\tvar _this$gpuAdapter, _this$wgpu$lost;\n\t\tif (!window.navigator.gpu) {\n\t\t\tthrow new Error('Unable to retrieve GPU. Ensure you are using a browser that supports WebGPU rendering.');\n\t\t}\n\t\tconst buildUrl = srcPath => {\n\t\t\treturn new URL(srcPath, window.location.href).toString();\n\t\t};\n\t\tconst results = await Promise.all([import(/* @vite-ignore */ /* webpackIgnore: true */ `${buildUrl(twgslUrl)}`).then(module => twgsl(twgslUrl.replace('.js', '.wasm'))), import(/* @vite-ignore */ /* webpackIgnore: true */ `${buildUrl(glslangUrl)}`).then(module => module.default())]);\n\t\tthis.twgsl = results[0];\n\t\tthis.glslang = results[1];\n\t\tconst adapterOptions = {\n\t\t\tpowerPreference: this.initOptions.powerPreference !== 'default' ? this.initOptions.powerPreference : undefined\n\t\t};\n\t\tthis.gpuAdapter = await window.navigator.gpu.requestAdapter(adapterOptions);\n\t\tconst requiredFeatures = [];\n\t\tconst requireFeature = feature => {\n\t\t\tconst supported = this.gpuAdapter.features.has(feature);\n\t\t\tif (supported) {\n\t\t\t\trequiredFeatures.push(feature);\n\t\t\t}\n\t\t\treturn supported;\n\t\t};\n\t\tthis.textureFloatFilterable = requireFeature('float32-filterable');\n\t\tthis.extCompressedTextureS3TC = requireFeature('texture-compression-bc');\n\t\tthis.extCompressedTextureETC = requireFeature('texture-compression-etc2');\n\t\tthis.extCompressedTextureASTC = requireFeature('texture-compression-astc');\n\t\tthis.supportsTimestampQuery = requireFeature('timestamp-query');\n\t\tthis.supportsDepthClip = requireFeature('depth-clip-control');\n\t\tthis.supportsDepth32Stencil = requireFeature('depth32float-stencil8');\n\t\tthis.supportsIndirectFirstInstance = requireFeature('indirect-first-instance');\n\t\tthis.supportsShaderF16 = requireFeature('shader-f16');\n\t\tthis.supportsStorageRGBA8 = requireFeature('bgra8unorm-storage');\n\t\tthis.textureRG11B10Renderable = requireFeature('rg11b10ufloat-renderable');\n\t\tconst adapterLimits = (_this$gpuAdapter = this.gpuAdapter) == null ? void 0 : _this$gpuAdapter.limits;\n\t\tconst requiredLimits = {};\n\t\tif (adapterLimits) {\n\t\t\tfor (const limitName in adapterLimits) {\n\t\t\t\tif (limitName === \"minSubgroupSize\" || limitName === \"maxSubgroupSize\") {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\trequiredLimits[limitName] = adapterLimits[limitName];\n\t\t\t}\n\t\t}\n\t\tconst deviceDescr = {\n\t\t\trequiredFeatures,\n\t\t\trequiredLimits,\n\t\t\tdefaultQueue: {\n\t\t\t\tlabel: 'Default Queue'\n\t\t\t}\n\t\t};\n\t\tthis.wgpu = await this.gpuAdapter.requestDevice(deviceDescr);\n\t\t(_this$wgpu$lost = this.wgpu.lost) == null || _this$wgpu$lost.then(info => {\n\t\t\tif (info.reason !== 'destroyed') ;\n\t\t});\n\t\tthis.initDeviceCaps();\n\t\tthis.gpuContext = this.canvas.getContext('webgpu');\n\t\tconst preferredCanvasFormat = navigator.gpu.getPreferredCanvasFormat();\n\t\tthis.backBufferFormat = preferredCanvasFormat === 'rgba8unorm' ? PIXELFORMAT_RGBA8 : PIXELFORMAT_BGRA8;\n\t\tthis.canvasConfig = {\n\t\t\tdevice: this.wgpu,\n\t\t\tcolorSpace: 'srgb',\n\t\t\talphaMode: this.initOptions.alpha ? 'premultiplied' : 'opaque',\n\t\t\tformat: preferredCanvasFormat,\n\t\t\tusage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC | GPUTextureUsage.COPY_DST,\n\t\t\tviewFormats: []\n\t\t};\n\t\tthis.gpuContext.configure(this.canvasConfig);\n\t\tthis.createBackbuffer();\n\t\tthis.clearRenderer = new WebgpuClearRenderer(this);\n\t\tthis.mipmapRenderer = new WebgpuMipmapRenderer(this);\n\t\tthis.resolver = new WebgpuResolver(this);\n\t\tthis.postInit();\n\t\treturn this;\n\t}\n\tpostInit() {\n\t\tsuper.postInit();\n\t\tthis.initializeRenderState();\n\t\tthis.setupPassEncoderDefaults();\n\t\tthis.gpuProfiler = new WebgpuGpuProfiler(this);\n\t\tthis.dynamicBuffers = new WebgpuDynamicBuffers(this, 1024 * 1024, this.limits.minUniformBufferOffsetAlignment);\n\t}\n\tcreateBackbuffer() {\n\t\tthis.supportsStencil = this.initOptions.stencil;\n\t\tthis.backBuffer = new RenderTarget({\n\t\t\tname: 'WebgpuFramebuffer',\n\t\t\tgraphicsDevice: this,\n\t\t\tdepth: this.initOptions.depth,\n\t\t\tstencil: this.supportsStencil,\n\t\t\tsamples: this.samples\n\t\t});\n\t}\n\tframeStart() {\n\t\tsuper.frameStart();\n\t\tthis.gpuProfiler.frameStart();\n\t\tthis.submit();\n\t\tconst outColorBuffer = this.gpuContext.getCurrentTexture();\n\t\tif (this.backBufferSize.x !== outColorBuffer.width || this.backBufferSize.y !== outColorBuffer.height) {\n\t\t\tthis.backBufferSize.set(outColorBuffer.width, outColorBuffer.height);\n\t\t\tthis.backBuffer.destroy();\n\t\t\tthis.backBuffer = null;\n\t\t\tthis.createBackbuffer();\n\t\t}\n\t\tconst rt = this.backBuffer;\n\t\tconst wrt = rt.impl;\n\t\twrt.setColorAttachment(0, undefined, outColorBuffer.format);\n\t\tthis.initRenderTarget(rt);\n\t\twrt.assignColorTexture(outColorBuffer);\n\t}\n\tframeEnd() {\n\t\tsuper.frameEnd();\n\t\tthis.gpuProfiler.frameEnd();\n\t\tthis.submit();\n\t\tif (!this.contextLost) {\n\t\t\tthis.gpuProfiler.request();\n\t\t}\n\t}\n\tcreateBufferImpl(usageFlags) {\n\t\treturn new WebgpuBuffer(usageFlags);\n\t}\n\tcreateUniformBufferImpl(uniformBuffer) {\n\t\treturn new WebgpuUniformBuffer(uniformBuffer);\n\t}\n\tcreateVertexBufferImpl(vertexBuffer, format, options) {\n\t\treturn new WebgpuVertexBuffer(vertexBuffer, format, options);\n\t}\n\tcreateIndexBufferImpl(indexBuffer, options) {\n\t\treturn new WebgpuIndexBuffer(indexBuffer, options);\n\t}\n\tcreateShaderImpl(shader) {\n\t\treturn new WebgpuShader(shader);\n\t}\n\tcreateTextureImpl(texture) {\n\t\treturn new WebgpuTexture(texture);\n\t}\n\tcreateRenderTargetImpl(renderTarget) {\n\t\treturn new WebgpuRenderTarget(renderTarget);\n\t}\n\tcreateBindGroupFormatImpl(bindGroupFormat) {\n\t\treturn new WebgpuBindGroupFormat(bindGroupFormat);\n\t}\n\tcreateBindGroupImpl(bindGroup) {\n\t\treturn new WebgpuBindGroup();\n\t}\n\tcreateComputeImpl(compute) {\n\t\treturn new WebgpuCompute(compute);\n\t}\n\tsetBindGroup(index, bindGroup) {\n\t\tif (this.passEncoder) {\n\t\t\tthis.passEncoder.setBindGroup(index, bindGroup.impl.bindGroup, bindGroup.uniformBufferOffsets);\n\t\t\tthis.bindGroupFormats[index] = bindGroup.format.impl;\n\t\t}\n\t}\n\tsubmitVertexBuffer(vertexBuffer, slot) {\n\t\tconst format = vertexBuffer.format;\n\t\tconst {\n\t\t\tinterleaved,\n\t\t\telements\n\t\t} = format;\n\t\tconst elementCount = elements.length;\n\t\tconst vbBuffer = vertexBuffer.impl.buffer;\n\t\tif (interleaved) {\n\t\t\tthis.passEncoder.setVertexBuffer(slot, vbBuffer);\n\t\t\treturn 1;\n\t\t}\n\t\tfor (let i = 0; i < elementCount; i++) {\n\t\t\tthis.passEncoder.setVertexBuffer(slot + i, vbBuffer, elements[i].offset);\n\t\t}\n\t\treturn elementCount;\n\t}\n\tvalidateVBLocations(vb0, vb1) {\n\t\tconst validateVB = vb => {\n\t\t\tconst {\n\t\t\t\telements\n\t\t\t} = vb.format;\n\t\t\tfor (let i = 0; i < elements.length; i++) {\n\t\t\t\tconst name = elements[i].name;\n\t\t\t\tconst location = semanticToLocation[name];\n\t\t\t\tif (_uniqueLocations.has(location)) ;\n\t\t\t\t_uniqueLocations.set(location, name);\n\t\t\t}\n\t\t};\n\t\tvalidateVB(vb0);\n\t\tvalidateVB(vb1);\n\t\t_uniqueLocations.clear();\n\t}\n\tdraw(primitive, numInstances = 1, keepBuffers) {\n\t\tif (this.shader.ready && !this.shader.failed) {\n\t\t\tconst passEncoder = this.passEncoder;\n\t\t\tconst vb0 = this.vertexBuffers[0];\n\t\t\tconst vb1 = this.vertexBuffers[1];\n\t\t\tthis.vertexBuffers.length = 0;\n\t\t\tif (vb0) {\n\t\t\t\tconst vbSlot = this.submitVertexBuffer(vb0, 0);\n\t\t\t\tif (vb1) {\n\t\t\t\t\tthis.submitVertexBuffer(vb1, vbSlot);\n\t\t\t\t}\n\t\t\t}\n\t\t\tconst pipeline = this.renderPipeline.get(primitive, vb0 == null ? void 0 : vb0.format, vb1 == null ? void 0 : vb1.format, this.shader, this.renderTarget, this.bindGroupFormats, this.blendState, this.depthState, this.cullMode, this.stencilEnabled, this.stencilFront, this.stencilBack);\n\t\t\tif (this.pipeline !== pipeline) {\n\t\t\t\tthis.pipeline = pipeline;\n\t\t\t\tpassEncoder.setPipeline(pipeline);\n\t\t\t}\n\t\t\tconst ib = this.indexBuffer;\n\t\t\tif (ib) {\n\t\t\t\tthis.indexBuffer = null;\n\t\t\t\tpassEncoder.setIndexBuffer(ib.impl.buffer, ib.impl.format);\n\t\t\t\tpassEncoder.drawIndexed(primitive.count, numInstances, primitive.base, 0, 0);\n\t\t\t} else {\n\t\t\t\tpassEncoder.draw(primitive.count, numInstances, primitive.base, 0);\n\t\t\t}\n\t\t}\n\t}\n\tsetShader(shader, asyncCompile = false) {\n\t\tif (shader !== this.shader) {\n\t\t\tthis.shader = shader;\n\t\t}\n\t}\n\tsetBlendState(blendState) {\n\t\tthis.blendState.copy(blendState);\n\t}\n\tsetDepthState(depthState) {\n\t\tthis.depthState.copy(depthState);\n\t}\n\tsetStencilState(stencilFront, stencilBack) {\n\t\tif (stencilFront || stencilBack) {\n\t\t\tthis.stencilEnabled = true;\n\t\t\tthis.stencilFront.copy(stencilFront != null ? stencilFront : StencilParameters.DEFAULT);\n\t\t\tthis.stencilBack.copy(stencilBack != null ? stencilBack : StencilParameters.DEFAULT);\n\t\t\tconst ref = this.stencilFront.ref;\n\t\t\tif (this.stencilRef !== ref) {\n\t\t\t\tthis.stencilRef = ref;\n\t\t\t\tthis.passEncoder.setStencilReference(ref);\n\t\t\t}\n\t\t} else {\n\t\t\tthis.stencilEnabled = false;\n\t\t}\n\t}\n\tsetBlendColor(r, g, b, a) {\n\t\tconst c = this.blendColor;\n\t\tif (r !== c.r || g !== c.g || b !== c.b || a !== c.a) {\n\t\t\tc.set(r, g, b, a);\n\t\t\tthis.passEncoder.setBlendConstant(c);\n\t\t}\n\t}\n\tsetCullMode(cullMode) {\n\t\tthis.cullMode = cullMode;\n\t}\n\tsetAlphaToCoverage(state) {}\n\tinitializeContextCaches() {\n\t\tsuper.initializeContextCaches();\n\t}\n\tsetupPassEncoderDefaults() {\n\t\tthis.pipeline = null;\n\t\tthis.stencilRef = 0;\n\t\tthis.blendColor.set(0, 0, 0, 0);\n\t}\n\t_uploadDirtyTextures() {\n\t\tthis.textures.forEach(texture => {\n\t\t\tif (texture._needsUpload || texture._needsMipmaps) {\n\t\t\t\ttexture.upload();\n\t\t\t}\n\t\t});\n\t}\n\tstartRenderPass(renderPass) {\n\t\tthis._uploadDirtyTextures();\n\t\tconst rt = renderPass.renderTarget || this.backBuffer;\n\t\tthis.renderTarget = rt;\n\t\tconst wrt = rt.impl;\n\t\tthis.commandEncoder = this.wgpu.createCommandEncoder();\n\t\tif (rt !== this.backBuffer) {\n\t\t\tthis.initRenderTarget(rt);\n\t\t}\n\t\twrt.setupForRenderPass(renderPass);\n\t\tconst renderPassDesc = wrt.renderPassDescriptor;\n\t\tif (this.gpuProfiler._enabled) {\n\t\t\tif (this.gpuProfiler.timestampQueriesSet) {\n\t\t\t\tconst slot = this.gpuProfiler.getSlot(renderPass.name);\n\t\t\t\trenderPassDesc.timestampWrites = {\n\t\t\t\t\tquerySet: this.gpuProfiler.timestampQueriesSet.querySet,\n\t\t\t\t\tbeginningOfPassWriteIndex: slot * 2,\n\t\t\t\t\tendOfPassWriteIndex: slot * 2 + 1\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\t\tthis.passEncoder = this.commandEncoder.beginRenderPass(renderPassDesc);\n\t\tthis.setupPassEncoderDefaults();\n\t\tconst {\n\t\t\twidth,\n\t\t\theight\n\t\t} = rt;\n\t\tthis.setViewport(0, 0, width, height);\n\t\tthis.setScissor(0, 0, width, height);\n\t\tthis.insideRenderPass = true;\n\t}\n\tendRenderPass(renderPass) {\n\t\tthis.passEncoder.end();\n\t\tthis.passEncoder = null;\n\t\tthis.insideRenderPass = false;\n\t\tthis.bindGroupFormats.length = 0;\n\t\tfor (let i = 0; i < renderPass.colorArrayOps.length; i++) {\n\t\t\tconst colorOps = renderPass.colorArrayOps[i];\n\t\t\tif (colorOps.mipmaps) {\n\t\t\t\tthis.mipmapRenderer.generate(renderPass.renderTarget._colorBuffers[i].impl);\n\t\t\t}\n\t\t}\n\t\tconst cb = this.commandEncoder.finish();\n\t\tthis.addCommandBuffer(cb);\n\t\tthis.commandEncoder = null;\n\t}\n\tstartComputePass() {\n\t\tthis.commandEncoder = this.wgpu.createCommandEncoder();\n\t\tthis.pipeline = null;\n\t\tthis.passEncoder = this.commandEncoder.beginComputePass();\n\t\tthis.insideRenderPass = true;\n\t}\n\tendComputePass() {\n\t\tthis.passEncoder.end();\n\t\tthis.passEncoder = null;\n\t\tthis.insideRenderPass = false;\n\t\tthis.bindGroupFormats.length = 0;\n\t\tconst cb = this.commandEncoder.finish();\n\t\tthis.addCommandBuffer(cb);\n\t\tthis.commandEncoder = null;\n\t}\n\tcomputeDispatch(computes) {\n\t\tthis.startComputePass();\n\t\tfor (let i = 0; i < computes.length; i++) {\n\t\t\tconst compute = computes[i];\n\t\t\tcompute.applyParameters();\n\t\t\tcompute.impl.updateBindGroup();\n\t\t}\n\t\tfor (let i = 0; i < computes.length; i++) {\n\t\t\tconst compute = computes[i];\n\t\t\tcompute.impl.dispatch(compute.countX, compute.countY, compute.countZ);\n\t\t}\n\t\tthis.endComputePass();\n\t}\n\taddCommandBuffer(commandBuffer, front = false) {\n\t\tif (front) {\n\t\t\tthis.commandBuffers.unshift(commandBuffer);\n\t\t} else {\n\t\t\tthis.commandBuffers.push(commandBuffer);\n\t\t}\n\t}\n\tsubmit() {\n\t\tif (this.commandBuffers.length > 0) {\n\t\t\tthis.dynamicBuffers.submit();\n\t\t\tthis.wgpu.queue.submit(this.commandBuffers);\n\t\t\tthis.commandBuffers.length = 0;\n\t\t\tthis.dynamicBuffers.onCommandBuffersSubmitted();\n\t\t}\n\t}\n\tclear(options) {\n\t\tif (options.flags) {\n\t\t\tthis.clearRenderer.clear(this, this.renderTarget, options, this.defaultClearOptions);\n\t\t}\n\t}\n\tsetViewport(x, y, w, h) {\n\t\tif (this.passEncoder) {\n\t\t\tif (!this.renderTarget.flipY) {\n\t\t\t\ty = this.renderTarget.height - y - h;\n\t\t\t}\n\t\t\tthis.vx = x;\n\t\t\tthis.vy = y;\n\t\t\tthis.vw = w;\n\t\t\tthis.vh = h;\n\t\t\tthis.passEncoder.setViewport(x, y, w, h, 0, 1);\n\t\t}\n\t}\n\tsetScissor(x, y, w, h) {\n\t\tif (this.passEncoder) {\n\t\t\tif (!this.renderTarget.flipY) {\n\t\t\t\ty = this.renderTarget.height - y - h;\n\t\t\t}\n\t\t\tthis.sx = x;\n\t\t\tthis.sy = y;\n\t\t\tthis.sw = w;\n\t\t\tthis.sh = h;\n\t\t\tthis.passEncoder.setScissorRect(x, y, w, h);\n\t\t}\n\t}\n\tclearStorageBuffer(storageBuffer, offset = 0, size = storageBuffer.byteSize) {\n\t\tvar _this$commandEncoder;\n\t\tconst commandEncoder = (_this$commandEncoder = this.commandEncoder) != null ? _this$commandEncoder : this.wgpu.createCommandEncoder();\n\t\tcommandEncoder.clearBuffer(storageBuffer.buffer, offset, size);\n\t\tif (!this.commandEncoder) {\n\t\t\tconst cb = commandEncoder.finish();\n\t\t\tthis.addCommandBuffer(cb);\n\t\t}\n\t}\n\treadStorageBuffer(storageBuffer, offset = 0, size = storageBuffer.byteSize - offset, data = null, immediate = false) {\n\t\tvar _this$commandEncoder2;\n\t\tconst stagingBuffer = this.createBufferImpl(BUFFERUSAGE_READ | BUFFERUSAGE_COPY_DST);\n\t\tstagingBuffer.allocate(this, size);\n\t\tconst destBuffer = stagingBuffer.buffer;\n\t\tconst commandEncoder = (_this$commandEncoder2 = this.commandEncoder) != null ? _this$commandEncoder2 : this.wgpu.createCommandEncoder();\n\t\tcommandEncoder.copyBufferToBuffer(storageBuffer.buffer, offset, destBuffer, 0, size);\n\t\tif (!this.commandEncoder) {\n\t\t\tconst cb = commandEncoder.finish();\n\t\t\tthis.addCommandBuffer(cb);\n\t\t}\n\t\treturn new Promise((resolve, reject) => {\n\t\t\tconst read = () => {\n\t\t\t\tdestBuffer == null || destBuffer.mapAsync(GPUMapMode.READ).then(() => {\n\t\t\t\t\tvar _data;\n\t\t\t\t\t(_data = data) != null ? _data : data = new Uint8Array(size);\n\t\t\t\t\tconst copySrc = destBuffer.getMappedRange(0, size);\n\t\t\t\t\tconst srcType = data.constructor;\n\t\t\t\t\tdata.set(new srcType(copySrc));\n\t\t\t\t\tdestBuffer.unmap();\n\t\t\t\t\tstagingBuffer.destroy(this);\n\t\t\t\t\tresolve(data);\n\t\t\t\t});\n\t\t\t};\n\t\t\tif (immediate) {\n\t\t\t\tthis.submit();\n\t\t\t\tread();\n\t\t\t} else {\n\t\t\t\tsetTimeout(() => {\n\t\t\t\t\tread();\n\t\t\t\t});\n\t\t\t}\n\t\t});\n\t}\n\twriteStorageBuffer(storageBuffer, bufferOffset = 0, data, dataOffset = 0, size) {\n\t\tthis.wgpu.queue.writeBuffer(storageBuffer.buffer, bufferOffset, data, dataOffset, size);\n\t}\n\tcopyRenderTarget(source, dest, color, depth) {\n\t\tvar _this$commandEncoder3;\n\t\tconst copySize = {\n\t\t\twidth: source ? source.width : dest.width,\n\t\t\theight: source ? source.height : dest.height,\n\t\t\tdepthOrArrayLayers: 1\n\t\t};\n\t\tconst commandEncoder = (_this$commandEncoder3 = this.commandEncoder) != null ? _this$commandEncoder3 : this.wgpu.createCommandEncoder();\n\t\tif (color) {\n\t\t\tconst copySrc = {\n\t\t\t\ttexture: source ? source.colorBuffer.impl.gpuTexture : this.renderTarget.impl.assignedColorTexture,\n\t\t\t\tmipLevel: 0\n\t\t\t};\n\t\t\tconst copyDst = {\n\t\t\t\ttexture: dest ? dest.colorBuffer.impl.gpuTexture : this.renderTarget.impl.assignedColorTexture,\n\t\t\t\tmipLevel: 0\n\t\t\t};\n\t\t\tcommandEncoder.copyTextureToTexture(copySrc, copyDst, copySize);\n\t\t}\n\t\tif (depth) {\n\t\t\tconst sourceRT = source ? source : this.renderTarget;\n\t\t\tconst sourceTexture = sourceRT.impl.depthTexture;\n\t\t\tif (source.samples > 1) {\n\t\t\t\tconst destTexture = dest.colorBuffer.impl.gpuTexture;\n\t\t\t\tthis.resolver.resolveDepth(commandEncoder, sourceTexture, destTexture);\n\t\t\t} else {\n\t\t\t\tconst destTexture = dest ? dest.depthBuffer.impl.gpuTexture : this.renderTarget.impl.depthTexture;\n\t\t\t\tconst copySrc = {\n\t\t\t\t\ttexture: sourceTexture,\n\t\t\t\t\tmipLevel: 0\n\t\t\t\t};\n\t\t\t\tconst copyDst = {\n\t\t\t\t\ttexture: destTexture,\n\t\t\t\t\tmipLevel: 0\n\t\t\t\t};\n\t\t\t\tcommandEncoder.copyTextureToTexture(copySrc, copyDst, copySize);\n\t\t\t}\n\t\t}\n\t\tif (!this.commandEncoder) {\n\t\t\tconst cb = commandEncoder.finish();\n\t\t\tthis.addCommandBuffer(cb);\n\t\t}\n\t\treturn true;\n\t}\n}\n\nexport { WebgpuGraphicsDevice };\n", "import { math } from '../../core/math/math.js';\nimport { RenderTarget } from './render-target.js';\nimport { TextureUtils } from './texture-utils.js';\nimport { TEXTURELOCK_NONE, PIXELFORMAT_RGBA8, isCompressedPixelFormat, isIntegerPixelFormat, FILTER_NEAREST, FILTER_LINEAR_MIPMAP_LINEAR, FILTER_LINEAR, ADDRESS_REPEAT, FUNC_LESS, TEXTURETYPE_DEFAULT, TEXTURETYPE_RGBM, TEXTURETYPE_SWIZZLEGGGR, TEXTUREPROJECTION_NONE, TEXTUREPROJECTION_CUBE, PIXELFORMAT_RGB16F, PIXELFORMAT_RGB32F, PIXELFORMAT_RGBA16F, PIXELFORMAT_RGBA32F, TEXTURETYPE_RGBP, TEXTURETYPE_RGBE, TEXTURELOCK_WRITE, getPixelFormatArrayType } from './constants.js';\n\nlet id = 0;\nclass Texture {\n\tconstructor(graphicsDevice, options = {}) {\n\t\tvar _options$name, _options$width, _options$height, _options$format, _options$storage, _options$cubemap, _options$fixCubemapSe, _options$flipY, _options$premultiplyA, _ref, _options$mipmaps, _options$minFilter, _options$magFilter, _options$anisotropy, _options$addressU, _options$addressV, _options$addressW, _options$compareOnRea, _options$compareFunc;\n\t\tthis.name = void 0;\n\t\tthis._gpuSize = 0;\n\t\tthis.id = id++;\n\t\tthis._invalid = false;\n\t\tthis._lockedLevel = -1;\n\t\tthis._lockedMode = TEXTURELOCK_NONE;\n\t\tthis.renderVersionDirty = 0;\n\t\tthis._storage = false;\n\t\tthis.device = graphicsDevice;\n\t\tthis.name = (_options$name = options.name) != null ? _options$name : '';\n\t\tthis._width = Math.floor((_options$width = options.width) != null ? _options$width : 4);\n\t\tthis._height = Math.floor((_options$height = options.height) != null ? _options$height : 4);\n\t\tthis._format = (_options$format = options.format) != null ? _options$format : PIXELFORMAT_RGBA8;\n\t\tthis._compressed = isCompressedPixelFormat(this._format);\n\t\tthis._integerFormat = isIntegerPixelFormat(this._format);\n\t\tif (this._integerFormat) {\n\t\t\toptions.mipmaps = false;\n\t\t\toptions.minFilter = FILTER_NEAREST;\n\t\t\toptions.magFilter = FILTER_NEAREST;\n\t\t}\n\t\tif (graphicsDevice.supportsVolumeTextures) {\n\t\t\tvar _options$volume, _options$depth, _options$arrayLength;\n\t\t\tthis._volume = (_options$volume = options.volume) != null ? _options$volume : false;\n\t\t\tthis._depth = Math.floor((_options$depth = options.depth) != null ? _options$depth : 1);\n\t\t\tthis._arrayLength = Math.floor((_options$arrayLength = options.arrayLength) != null ? _options$arrayLength : 0);\n\t\t} else {\n\t\t\tthis._volume = false;\n\t\t\tthis._depth = 1;\n\t\t\tthis._arrayLength = 0;\n\t\t}\n\t\tthis._storage = (_options$storage = options.storage) != null ? _options$storage : false;\n\t\tthis._cubemap = (_options$cubemap = options.cubemap) != null ? _options$cubemap : false;\n\t\tthis.fixCubemapSeams = (_options$fixCubemapSe = options.fixCubemapSeams) != null ? _options$fixCubemapSe : false;\n\t\tthis._flipY = (_options$flipY = options.flipY) != null ? _options$flipY : false;\n\t\tthis._premultiplyAlpha = (_options$premultiplyA = options.premultiplyAlpha) != null ? _options$premultiplyA : false;\n\t\tthis._mipmaps = (_ref = (_options$mipmaps = options.mipmaps) != null ? _options$mipmaps : options.autoMipmap) != null ? _ref : true;\n\t\tthis._minFilter = (_options$minFilter = options.minFilter) != null ? _options$minFilter : FILTER_LINEAR_MIPMAP_LINEAR;\n\t\tthis._magFilter = (_options$magFilter = options.magFilter) != null ? _options$magFilter : FILTER_LINEAR;\n\t\tthis._anisotropy = (_options$anisotropy = options.anisotropy) != null ? _options$anisotropy : 1;\n\t\tthis._addressU = (_options$addressU = options.addressU) != null ? _options$addressU : ADDRESS_REPEAT;\n\t\tthis._addressV = (_options$addressV = options.addressV) != null ? _options$addressV : ADDRESS_REPEAT;\n\t\tthis._addressW = (_options$addressW = options.addressW) != null ? _options$addressW : ADDRESS_REPEAT;\n\t\tthis._compareOnRead = (_options$compareOnRea = options.compareOnRead) != null ? _options$compareOnRea : false;\n\t\tthis._compareFunc = (_options$compareFunc = options.compareFunc) != null ? _options$compareFunc : FUNC_LESS;\n\t\tthis.type = TEXTURETYPE_DEFAULT;\n\t\tif (options.hasOwnProperty('type')) {\n\t\t\tthis.type = options.type;\n\t\t} else if (options.hasOwnProperty('rgbm')) {\n\t\t\tthis.type = options.rgbm ? TEXTURETYPE_RGBM : TEXTURETYPE_DEFAULT;\n\t\t} else if (options.hasOwnProperty('swizzleGGGR')) {\n\t\t\tthis.type = options.swizzleGGGR ? TEXTURETYPE_SWIZZLEGGGR : TEXTURETYPE_DEFAULT;\n\t\t}\n\t\tthis.projection = TEXTUREPROJECTION_NONE;\n\t\tif (this._cubemap) {\n\t\t\tthis.projection = TEXTUREPROJECTION_CUBE;\n\t\t} else if (options.projection && options.projection !== TEXTUREPROJECTION_CUBE) {\n\t\t\tthis.projection = options.projection;\n\t\t}\n\t\tthis.impl = graphicsDevice.createTextureImpl(this);\n\t\tthis.dirtyAll();\n\t\tthis._levels = options.levels;\n\t\tif (this._levels) {\n\t\t\tthis.upload();\n\t\t} else {\n\t\t\tthis._levels = this._cubemap ? [[null, null, null, null, null, null]] : [null];\n\t\t}\n\t\tgraphicsDevice.textures.push(this);\n\t}\n\tdestroy() {\n\t\tconst device = this.device;\n\t\tif (device) {\n\t\t\tconst idx = device.textures.indexOf(this);\n\t\t\tif (idx !== -1) {\n\t\t\t\tdevice.textures.splice(idx, 1);\n\t\t\t}\n\t\t\tdevice.scope.removeValue(this);\n\t\t\tthis.impl.destroy(device);\n\t\t\tthis.adjustVramSizeTracking(device._vram, -this._gpuSize);\n\t\t\tthis._levels = null;\n\t\t\tthis.device = null;\n\t\t}\n\t}\n\tresize(width, height, depth = 1) {\n\t\tconst device = this.device;\n\t\tthis.adjustVramSizeTracking(device._vram, -this._gpuSize);\n\t\tthis.impl.destroy(device);\n\t\tthis._width = Math.floor(width);\n\t\tthis._height = Math.floor(height);\n\t\tthis._depth = Math.floor(depth);\n\t\tthis.impl = device.createTextureImpl(this);\n\t\tthis.dirtyAll();\n\t}\n\tloseContext() {\n\t\tthis.impl.loseContext();\n\t\tthis.dirtyAll();\n\t}\n\tadjustVramSizeTracking(vram, size) {\n\t\tvram.tex += size;\n\t}\n\tpropertyChanged(flag) {\n\t\tthis.impl.propertyChanged(flag);\n\t\tthis.renderVersionDirty = this.device.renderVersion;\n\t}\n\tget requiredMipLevels() {\n\t\treturn this.mipmaps ? TextureUtils.calcMipLevelsCount(this.width, this.height) : 1;\n\t}\n\tget lockedMode() {\n\t\treturn this._lockedMode;\n\t}\n\tset minFilter(v) {\n\t\tif (this._minFilter !== v) {\n\t\t\tif (isIntegerPixelFormat(this._format)) ; else {\n\t\t\t\tthis._minFilter = v;\n\t\t\t\tthis.propertyChanged(1);\n\t\t\t}\n\t\t}\n\t}\n\tget minFilter() {\n\t\treturn this._minFilter;\n\t}\n\tset magFilter(v) {\n\t\tif (this._magFilter !== v) {\n\t\t\tif (isIntegerPixelFormat(this._format)) ; else {\n\t\t\t\tthis._magFilter = v;\n\t\t\t\tthis.propertyChanged(2);\n\t\t\t}\n\t\t}\n\t}\n\tget magFilter() {\n\t\treturn this._magFilter;\n\t}\n\tset addressU(v) {\n\t\tif (this._addressU !== v) {\n\t\t\tthis._addressU = v;\n\t\t\tthis.propertyChanged(4);\n\t\t}\n\t}\n\tget addressU() {\n\t\treturn this._addressU;\n\t}\n\tset addressV(v) {\n\t\tif (this._addressV !== v) {\n\t\t\tthis._addressV = v;\n\t\t\tthis.propertyChanged(8);\n\t\t}\n\t}\n\tget addressV() {\n\t\treturn this._addressV;\n\t}\n\tset addressW(addressW) {\n\t\tif (!this.device.supportsVolumeTextures) return;\n\t\tif (!this._volume) {\n\t\t\treturn;\n\t\t}\n\t\tif (addressW !== this._addressW) {\n\t\t\tthis._addressW = addressW;\n\t\t\tthis.propertyChanged(16);\n\t\t}\n\t}\n\tget addressW() {\n\t\treturn this._addressW;\n\t}\n\tset compareOnRead(v) {\n\t\tif (this._compareOnRead !== v) {\n\t\t\tthis._compareOnRead = v;\n\t\t\tthis.propertyChanged(32);\n\t\t}\n\t}\n\tget compareOnRead() {\n\t\treturn this._compareOnRead;\n\t}\n\tset compareFunc(v) {\n\t\tif (this._compareFunc !== v) {\n\t\t\tthis._compareFunc = v;\n\t\t\tthis.propertyChanged(64);\n\t\t}\n\t}\n\tget compareFunc() {\n\t\treturn this._compareFunc;\n\t}\n\tset anisotropy(v) {\n\t\tif (this._anisotropy !== v) {\n\t\t\tthis._anisotropy = v;\n\t\t\tthis.propertyChanged(128);\n\t\t}\n\t}\n\tget anisotropy() {\n\t\treturn this._anisotropy;\n\t}\n\tset mipmaps(v) {\n\t\tif (this._mipmaps !== v) {\n\t\t\tif (this.device.isWebGPU) ; else if (isIntegerPixelFormat(this._format)) ; else {\n\t\t\t\tthis._mipmaps = v;\n\t\t\t}\n\t\t\tif (v) this._needsMipmapsUpload = true;\n\t\t}\n\t}\n\tget mipmaps() {\n\t\treturn this._mipmaps;\n\t}\n\tget storage() {\n\t\treturn this._storage;\n\t}\n\tget width() {\n\t\treturn this._width;\n\t}\n\tget height() {\n\t\treturn this._height;\n\t}\n\tget depth() {\n\t\treturn this._depth;\n\t}\n\tget format() {\n\t\treturn this._format;\n\t}\n\tget cubemap() {\n\t\treturn this._cubemap;\n\t}\n\tget gpuSize() {\n\t\tconst mips = this.pot && this._mipmaps && !(this._compressed && this._levels.length === 1);\n\t\treturn TextureUtils.calcGpuSize(this._width, this._height, this._depth, this._format, mips, this._cubemap);\n\t}\n\tget array() {\n\t\treturn this._arrayLength > 0;\n\t}\n\tget arrayLength() {\n\t\treturn this._arrayLength;\n\t}\n\tget volume() {\n\t\treturn this._volume;\n\t}\n\tset flipY(flipY) {\n\t\tif (this._flipY !== flipY) {\n\t\t\tthis._flipY = flipY;\n\t\t\tthis._needsUpload = true;\n\t\t}\n\t}\n\tget flipY() {\n\t\treturn this._flipY;\n\t}\n\tset premultiplyAlpha(premultiplyAlpha) {\n\t\tif (this._premultiplyAlpha !== premultiplyAlpha) {\n\t\t\tthis._premultiplyAlpha = premultiplyAlpha;\n\t\t\tthis._needsUpload = true;\n\t\t}\n\t}\n\tget premultiplyAlpha() {\n\t\treturn this._premultiplyAlpha;\n\t}\n\tget pot() {\n\t\treturn math.powerOfTwo(this._width) && math.powerOfTwo(this._height);\n\t}\n\tget encoding() {\n\t\tswitch (this.type) {\n\t\t\tcase TEXTURETYPE_RGBM:\n\t\t\t\treturn 'rgbm';\n\t\t\tcase TEXTURETYPE_RGBE:\n\t\t\t\treturn 'rgbe';\n\t\t\tcase TEXTURETYPE_RGBP:\n\t\t\t\treturn 'rgbp';\n\t\t\tdefault:\n\t\t\t\treturn this.format === PIXELFORMAT_RGB16F || this.format === PIXELFORMAT_RGB32F || this.format === PIXELFORMAT_RGBA16F || this.format === PIXELFORMAT_RGBA32F || isIntegerPixelFormat(this.format) ? 'linear' : 'srgb';\n\t\t}\n\t}\n\tdirtyAll() {\n\t\tthis._levelsUpdated = this._cubemap ? [[true, true, true, true, true, true]] : [true];\n\t\tthis._needsUpload = true;\n\t\tthis._needsMipmapsUpload = this._mipmaps;\n\t\tthis._mipmapsUploaded = false;\n\t\tthis.propertyChanged(255);\n\t}\n\tlock(options = {}) {\n\t\tvar _options$level, _options$face, _options$mode;\n\t\t(_options$level = options.level) != null ? _options$level : options.level = 0;\n\t\t(_options$face = options.face) != null ? _options$face : options.face = 0;\n\t\t(_options$mode = options.mode) != null ? _options$mode : options.mode = TEXTURELOCK_WRITE;\n\t\tthis._lockedMode = options.mode;\n\t\tthis._lockedLevel = options.level;\n\t\tconst levels = this.cubemap ? this._levels[options.face] : this._levels;\n\t\tif (levels[options.level] === null) {\n\t\t\tconst width = Math.max(1, this._width >> options.level);\n\t\t\tconst height = Math.max(1, this._height >> options.level);\n\t\t\tconst depth = Math.max(1, this._depth >> options.level);\n\t\t\tconst data = new ArrayBuffer(TextureUtils.calcLevelGpuSize(width, height, depth, this._format));\n\t\t\tlevels[options.level] = new (getPixelFormatArrayType(this._format))(data);\n\t\t}\n\t\treturn levels[options.level];\n\t}\n\tsetSource(source, mipLevel = 0) {\n\t\tlet invalid = false;\n\t\tlet width, height;\n\t\tif (this._cubemap) {\n\t\t\tif (source[0]) {\n\t\t\t\twidth = source[0].width || 0;\n\t\t\t\theight = source[0].height || 0;\n\t\t\t\tfor (let i = 0; i < 6; i++) {\n\t\t\t\t\tconst face = source[i];\n\t\t\t\t\tif (!face || face.width !== width || face.height !== height || !this.device._isBrowserInterface(face)) {\n\t\t\t\t\t\tinvalid = true;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tinvalid = true;\n\t\t\t}\n\t\t\tif (!invalid) {\n\t\t\t\tfor (let i = 0; i < 6; i++) {\n\t\t\t\t\tif (this._levels[mipLevel][i] !== source[i]) this._levelsUpdated[mipLevel][i] = true;\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tif (!this.device._isBrowserInterface(source)) invalid = true;\n\t\t\tif (!invalid) {\n\t\t\t\tif (source !== this._levels[mipLevel]) this._levelsUpdated[mipLevel] = true;\n\t\t\t\twidth = source.width;\n\t\t\t\theight = source.height;\n\t\t\t}\n\t\t}\n\t\tif (invalid) {\n\t\t\tthis._width = 4;\n\t\t\tthis._height = 4;\n\t\t\tif (this._cubemap) {\n\t\t\t\tfor (let i = 0; i < 6; i++) {\n\t\t\t\t\tthis._levels[mipLevel][i] = null;\n\t\t\t\t\tthis._levelsUpdated[mipLevel][i] = true;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tthis._levels[mipLevel] = null;\n\t\t\t\tthis._levelsUpdated[mipLevel] = true;\n\t\t\t}\n\t\t} else {\n\t\t\tif (mipLevel === 0) {\n\t\t\t\tthis._width = width;\n\t\t\t\tthis._height = height;\n\t\t\t}\n\t\t\tthis._levels[mipLevel] = source;\n\t\t}\n\t\tif (this._invalid !== invalid || !invalid) {\n\t\t\tthis._invalid = invalid;\n\t\t\tthis.upload();\n\t\t}\n\t}\n\tgetSource(mipLevel = 0) {\n\t\treturn this._levels[mipLevel];\n\t}\n\tunlock() {\n\t\tif (this._lockedMode === TEXTURELOCK_NONE) ;\n\t\tif (this._lockedMode === TEXTURELOCK_WRITE) {\n\t\t\tthis.upload();\n\t\t}\n\t\tthis._lockedLevel = -1;\n\t\tthis._lockedMode = TEXTURELOCK_NONE;\n\t}\n\tupload() {\n\t\tvar _this$impl$uploadImme, _this$impl;\n\t\tthis._needsUpload = true;\n\t\tthis._needsMipmapsUpload = this._mipmaps;\n\t\t(_this$impl$uploadImme = (_this$impl = this.impl).uploadImmediate) == null || _this$impl$uploadImme.call(_this$impl, this.device, this);\n\t}\n\tasync downloadAsync() {\n\t\tconst promises = [];\n\t\tfor (let i = 0; i < (this.cubemap ? 6 : 1); i++) {\n\t\t\tvar _this$device$readPixe, _this$device;\n\t\t\tconst renderTarget = new RenderTarget({\n\t\t\t\tcolorBuffer: this,\n\t\t\t\tdepth: false,\n\t\t\t\tface: i\n\t\t\t});\n\t\t\tthis.device.setRenderTarget(renderTarget);\n\t\t\tthis.device.initRenderTarget(renderTarget);\n\t\t\tconst levels = this.cubemap ? this._levels[i] : this._levels;\n\t\t\tlet level = levels[0];\n\t\t\tif (levels[0] && this.device._isBrowserInterface(levels[0])) {\n\t\t\t\tlevels[0] = null;\n\t\t\t}\n\t\t\tlevel = this.lock({\n\t\t\t\tface: i\n\t\t\t});\n\t\t\tconst promise = (_this$device$readPixe = (_this$device = this.device).readPixelsAsync) == null ? void 0 : _this$device$readPixe.call(_this$device, 0, 0, this.width, this.height, level).then(() => renderTarget.destroy());\n\t\t\tpromises.push(promise);\n\t\t}\n\t\tawait Promise.all(promises);\n\t}\n}\n\nexport { Texture };\n", "import { BUFFER_GPUDYNAMIC, BUFFER_STREAM, BUFFER_DYNAMIC, BUFFER_STATIC } from '../constants.js';\n\nclass WebglBuffer {\n\tconstructor() {\n\t\tthis.bufferId = null;\n\t}\n\tdestroy(device) {\n\t\tif (this.bufferId) {\n\t\t\tdevice.gl.deleteBuffer(this.bufferId);\n\t\t\tthis.bufferId = null;\n\t\t}\n\t}\n\tget initialized() {\n\t\treturn !!this.bufferId;\n\t}\n\tloseContext() {\n\t\tthis.bufferId = null;\n\t}\n\tunlock(device, usage, target, storage) {\n\t\tconst gl = device.gl;\n\t\tif (!this.bufferId) {\n\t\t\tlet glUsage;\n\t\t\tswitch (usage) {\n\t\t\t\tcase BUFFER_STATIC:\n\t\t\t\t\tglUsage = gl.STATIC_DRAW;\n\t\t\t\t\tbreak;\n\t\t\t\tcase BUFFER_DYNAMIC:\n\t\t\t\t\tglUsage = gl.DYNAMIC_DRAW;\n\t\t\t\t\tbreak;\n\t\t\t\tcase BUFFER_STREAM:\n\t\t\t\t\tglUsage = gl.STREAM_DRAW;\n\t\t\t\t\tbreak;\n\t\t\t\tcase BUFFER_GPUDYNAMIC:\n\t\t\t\t\tglUsage = device.isWebGL2 ? gl.DYNAMIC_COPY : gl.STATIC_DRAW;\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t\tthis.bufferId = gl.createBuffer();\n\t\t\tgl.bindBuffer(target, this.bufferId);\n\t\t\tgl.bufferData(target, storage, glUsage);\n\t\t} else {\n\t\t\tgl.bindBuffer(target, this.bufferId);\n\t\t\tgl.bufferSubData(target, 0, storage);\n\t\t}\n\t}\n}\n\nexport { WebglBuffer };\n", "import { WebglBuffer } from './webgl-buffer.js';\n\nclass WebglVertexBuffer extends WebglBuffer {\n\tconstructor(...args) {\n\t\tsuper(...args);\n\t\tthis.vao = null;\n\t}\n\tdestroy(device) {\n\t\tsuper.destroy(device);\n\t\tdevice.unbindVertexArray();\n\t}\n\tloseContext() {\n\t\tsuper.loseContext();\n\t\tthis.vao = null;\n\t}\n\tunlock(vertexBuffer) {\n\t\tconst device = vertexBuffer.device;\n\t\tsuper.unlock(device, vertexBuffer.usage, device.gl.ARRAY_BUFFER, vertexBuffer.storage);\n\t}\n}\n\nexport { WebglVertexBuffer };\n", "import { INDEXFORMAT_UINT8, INDEXFORMAT_UINT16, INDEXFORMAT_UINT32 } from '../constants.js';\nimport { WebglBuffer } from './webgl-buffer.js';\n\nclass WebglIndexBuffer extends WebglBuffer {\n\tconstructor(indexBuffer) {\n\t\tsuper();\n\t\tconst gl = indexBuffer.device.gl;\n\t\tconst format = indexBuffer.format;\n\t\tif (format === INDEXFORMAT_UINT8) {\n\t\t\tthis.glFormat = gl.UNSIGNED_BYTE;\n\t\t} else if (format === INDEXFORMAT_UINT16) {\n\t\t\tthis.glFormat = gl.UNSIGNED_SHORT;\n\t\t} else if (format === INDEXFORMAT_UINT32) {\n\t\t\tthis.glFormat = gl.UNSIGNED_INT;\n\t\t}\n\t}\n\tunlock(indexBuffer) {\n\t\tconst device = indexBuffer.device;\n\t\tsuper.unlock(device, indexBuffer.usage, device.gl.ELEMENT_ARRAY_BUFFER, indexBuffer.storage);\n\t}\n}\n\nexport { WebglIndexBuffer };\n", "import { UNIFORMTYPE_BVEC4, UNIFORMTYPE_BVEC4ARRAY, UNIFORMTYPE_UVEC4, UNIFORMTYPE_UVEC4ARRAY, UNIFORMTYPE_IVEC4, UNIFORMTYPE_IVEC4ARRAY, UNIFORMTYPE_VEC4, UNIFORMTYPE_VEC4ARRAY, UNIFORMTYPE_BVEC3, UNIFORMTYPE_BVEC3ARRAY, UNIFORMTYPE_UVEC3, UNIFORMTYPE_UVEC3ARRAY, UNIFORMTYPE_IVEC3, UNIFORMTYPE_IVEC3ARRAY, UNIFORMTYPE_VEC3, UNIFORMTYPE_VEC3ARRAY, UNIFORMTYPE_BVEC2, UNIFORMTYPE_BVEC2ARRAY, UNIFORMTYPE_UVEC2, UNIFORMTYPE_UVEC2ARRAY, UNIFORMTYPE_IVEC2, UNIFORMTYPE_IVEC2ARRAY, UNIFORMTYPE_VEC2, UNIFORMTYPE_VEC2ARRAY, UNIFORMTYPE_BOOL, UNIFORMTYPE_BOOLARRAY, UNIFORMTYPE_UINT, UNIFORMTYPE_UINTARRAY, UNIFORMTYPE_INT, UNIFORMTYPE_INTARRAY, UNIFORMTYPE_FLOAT, UNIFORMTYPE_FLOATARRAY } from '../constants.js';\nimport { Version } from '../version.js';\n\nclass WebglShaderInput {\n\tconstructor(graphicsDevice, name, type, locationId) {\n\t\tthis.locationId = locationId;\n\t\tthis.scopeId = graphicsDevice.scope.resolve(name);\n\t\tthis.version = new Version();\n\t\tif (name.substring(name.length - 3) === \"[0]\") {\n\t\t\tswitch (type) {\n\t\t\t\tcase UNIFORMTYPE_FLOAT:\n\t\t\t\t\ttype = UNIFORMTYPE_FLOATARRAY;\n\t\t\t\t\tbreak;\n\t\t\t\tcase UNIFORMTYPE_INT:\n\t\t\t\t\ttype = UNIFORMTYPE_INTARRAY;\n\t\t\t\t\tbreak;\n\t\t\t\tcase UNIFORMTYPE_UINT:\n\t\t\t\t\ttype = UNIFORMTYPE_UINTARRAY;\n\t\t\t\t\tbreak;\n\t\t\t\tcase UNIFORMTYPE_BOOL:\n\t\t\t\t\ttype = UNIFORMTYPE_BOOLARRAY;\n\t\t\t\t\tbreak;\n\t\t\t\tcase UNIFORMTYPE_VEC2:\n\t\t\t\t\ttype = UNIFORMTYPE_VEC2ARRAY;\n\t\t\t\t\tbreak;\n\t\t\t\tcase UNIFORMTYPE_IVEC2:\n\t\t\t\t\ttype = UNIFORMTYPE_IVEC2ARRAY;\n\t\t\t\t\tbreak;\n\t\t\t\tcase UNIFORMTYPE_UVEC2:\n\t\t\t\t\ttype = UNIFORMTYPE_UVEC2ARRAY;\n\t\t\t\t\tbreak;\n\t\t\t\tcase UNIFORMTYPE_BVEC2:\n\t\t\t\t\ttype = UNIFORMTYPE_BVEC2ARRAY;\n\t\t\t\t\tbreak;\n\t\t\t\tcase UNIFORMTYPE_VEC3:\n\t\t\t\t\ttype = UNIFORMTYPE_VEC3ARRAY;\n\t\t\t\t\tbreak;\n\t\t\t\tcase UNIFORMTYPE_IVEC3:\n\t\t\t\t\ttype = UNIFORMTYPE_IVEC3ARRAY;\n\t\t\t\t\tbreak;\n\t\t\t\tcase UNIFORMTYPE_UVEC3:\n\t\t\t\t\ttype = UNIFORMTYPE_UVEC3ARRAY;\n\t\t\t\t\tbreak;\n\t\t\t\tcase UNIFORMTYPE_BVEC3:\n\t\t\t\t\ttype = UNIFORMTYPE_BVEC3ARRAY;\n\t\t\t\t\tbreak;\n\t\t\t\tcase UNIFORMTYPE_VEC4:\n\t\t\t\t\ttype = UNIFORMTYPE_VEC4ARRAY;\n\t\t\t\t\tbreak;\n\t\t\t\tcase UNIFORMTYPE_IVEC4:\n\t\t\t\t\ttype = UNIFORMTYPE_IVEC4ARRAY;\n\t\t\t\t\tbreak;\n\t\t\t\tcase UNIFORMTYPE_UVEC4:\n\t\t\t\t\ttype = UNIFORMTYPE_UVEC4ARRAY;\n\t\t\t\t\tbreak;\n\t\t\t\tcase UNIFORMTYPE_BVEC4:\n\t\t\t\t\ttype = UNIFORMTYPE_BVEC4ARRAY;\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\tthis.dataType = type;\n\t\tthis.value = [null, null, null, null];\n\t\tthis.array = [];\n\t}\n}\n\nexport { WebglShaderInput };\n", "import { WebglShaderInput } from './webgl-shader-input.js';\nimport { semanticToLocation } from '../constants.js';\nimport { DeviceCache } from '../device-cache.js';\n\nconst _vertexShaderBuiltins = new Set(['gl_VertexID', 'gl_InstanceID', 'gl_DrawID', 'gl_BaseVertex', 'gl_BaseInstance']);\nclass CompiledShaderCache {\n\tconstructor() {\n\t\tthis.map = new Map();\n\t}\n\tdestroy(device) {\n\t\tthis.map.forEach(shader => {\n\t\t\tdevice.gl.deleteShader(shader);\n\t\t});\n\t}\n\tloseContext(device) {\n\t\tthis.map.clear();\n\t}\n}\nconst _vertexShaderCache = new DeviceCache();\nconst _fragmentShaderCache = new DeviceCache();\nclass WebglShader {\n\tconstructor(shader) {\n\t\tthis.compileDuration = 0;\n\t\tthis.init();\n\t\tthis.compile(shader.device, shader);\n\t\tthis.link(shader.device, shader);\n\t\tshader.device.shaders.push(shader);\n\t}\n\tdestroy(shader) {\n\t\tif (this.glProgram) {\n\t\t\tshader.device.gl.deleteProgram(this.glProgram);\n\t\t\tthis.glProgram = null;\n\t\t}\n\t}\n\tinit() {\n\t\tthis.uniforms = [];\n\t\tthis.samplers = [];\n\t\tthis.attributes = [];\n\t\tthis.glProgram = null;\n\t\tthis.glVertexShader = null;\n\t\tthis.glFragmentShader = null;\n\t}\n\tloseContext() {\n\t\tthis.init();\n\t}\n\trestoreContext(device, shader) {\n\t\tthis.compile(device, shader);\n\t\tthis.link(device, shader);\n\t}\n\tcompile(device, shader) {\n\t\tconst definition = shader.definition;\n\t\tthis.glVertexShader = this._compileShaderSource(device, definition.vshader, true);\n\t\tthis.glFragmentShader = this._compileShaderSource(device, definition.fshader, false);\n\t}\n\tlink(device, shader) {\n\t\tif (this.glProgram) return;\n\t\tconst gl = device.gl;\n\t\tif (gl.isContextLost()) {\n\t\t\treturn;\n\t\t}\n\t\tconst glProgram = gl.createProgram();\n\t\tthis.glProgram = glProgram;\n\t\tgl.attachShader(glProgram, this.glVertexShader);\n\t\tgl.attachShader(glProgram, this.glFragmentShader);\n\t\tconst definition = shader.definition;\n\t\tconst attrs = definition.attributes;\n\t\tif (device.isWebGL2 && definition.useTransformFeedback) {\n\t\t\tconst outNames = [];\n\t\t\tfor (const attr in attrs) {\n\t\t\t\tif (attrs.hasOwnProperty(attr)) {\n\t\t\t\t\toutNames.push(\"out_\" + attr);\n\t\t\t\t}\n\t\t\t}\n\t\t\tgl.transformFeedbackVaryings(glProgram, outNames, gl.INTERLEAVED_ATTRIBS);\n\t\t}\n\t\tfor (const attr in attrs) {\n\t\t\tif (attrs.hasOwnProperty(attr)) {\n\t\t\t\tconst semantic = attrs[attr];\n\t\t\t\tconst loc = semanticToLocation[semantic];\n\t\t\t\tgl.bindAttribLocation(glProgram, loc, attr);\n\t\t\t}\n\t\t}\n\t\tgl.linkProgram(glProgram);\n\t}\n\t_compileShaderSource(device, src, isVertexShader) {\n\t\tconst gl = device.gl;\n\t\tconst shaderDeviceCache = isVertexShader ? _vertexShaderCache : _fragmentShaderCache;\n\t\tconst shaderCache = shaderDeviceCache.get(device, () => {\n\t\t\treturn new CompiledShaderCache();\n\t\t});\n\t\tlet glShader = shaderCache.map.get(src);\n\t\tif (!glShader) {\n\t\t\tglShader = gl.createShader(isVertexShader ? gl.VERTEX_SHADER : gl.FRAGMENT_SHADER);\n\t\t\tif (!glShader && gl.isContextLost()) {\n\t\t\t\treturn glShader;\n\t\t\t}\n\t\t\tgl.shaderSource(glShader, src);\n\t\t\tgl.compileShader(glShader);\n\t\t\tshaderCache.map.set(src, glShader);\n\t\t}\n\t\treturn glShader;\n\t}\n\tfinalize(device, shader) {\n\t\tconst gl = device.gl;\n\t\tif (gl.isContextLost()) {\n\t\t\treturn true;\n\t\t}\n\t\tconst glProgram = this.glProgram;\n\t\tconst definition = shader.definition;\n\t\tconst linkStatus = gl.getProgramParameter(glProgram, gl.LINK_STATUS);\n\t\tif (!linkStatus) {\n\t\t\tif (!this._isCompiled(device, shader, this.glVertexShader, definition.vshader, \"vertex\")) return false;\n\t\t\tif (!this._isCompiled(device, shader, this.glFragmentShader, definition.fshader, \"fragment\")) return false;\n\t\t\tconst message = \"Failed to link shader program. Error: \" + gl.getProgramInfoLog(glProgram);\n\t\t\tconsole.error(message);\n\t\t\treturn false;\n\t\t}\n\t\tconst numAttributes = gl.getProgramParameter(glProgram, gl.ACTIVE_ATTRIBUTES);\n\t\tfor (let i = 0; i < numAttributes; i++) {\n\t\t\tconst info = gl.getActiveAttrib(glProgram, i);\n\t\t\tconst location = gl.getAttribLocation(glProgram, info.name);\n\t\t\tif (_vertexShaderBuiltins.has(info.name)) continue;\n\t\t\tif (definition.attributes[info.name] === undefined) {\n\t\t\t\tconsole.error(`Vertex shader attribute \"${info.name}\" is not mapped to a semantic in shader definition, shader [${shader.label}]`, shader);\n\t\t\t\tshader.failed = true;\n\t\t\t} else {\n\t\t\t\tconst shaderInput = new WebglShaderInput(device, definition.attributes[info.name], device.pcUniformType[info.type], location);\n\t\t\t\tthis.attributes.push(shaderInput);\n\t\t\t}\n\t\t}\n\t\tconst samplerTypes = device._samplerTypes;\n\t\tconst numUniforms = gl.getProgramParameter(glProgram, gl.ACTIVE_UNIFORMS);\n\t\tfor (let i = 0; i < numUniforms; i++) {\n\t\t\tconst info = gl.getActiveUniform(glProgram, i);\n\t\t\tconst location = gl.getUniformLocation(glProgram, info.name);\n\t\t\tconst shaderInput = new WebglShaderInput(device, info.name, device.pcUniformType[info.type], location);\n\t\t\tif (samplerTypes.has(info.type)) {\n\t\t\t\tthis.samplers.push(shaderInput);\n\t\t\t} else {\n\t\t\t\tthis.uniforms.push(shaderInput);\n\t\t\t}\n\t\t}\n\t\tshader.ready = true;\n\t\treturn true;\n\t}\n\t_isCompiled(device, shader, glShader, source, shaderType) {\n\t\tconst gl = device.gl;\n\t\tif (!gl.getShaderParameter(glShader, gl.COMPILE_STATUS)) {\n\t\t\tconst infoLog = gl.getShaderInfoLog(glShader);\n\t\t\tconst [code, error] = this._processError(source, infoLog);\n\t\t\tconst message = `Failed to compile ${shaderType} shader:\\n\\n${infoLog}\\n${code} while rendering ${void 0}`;\n\t\t\tconsole.error(message);\n\t\t\treturn false;\n\t\t}\n\t\treturn true;\n\t}\n\tisLinked(device) {\n\t\tconst {\n\t\t\textParallelShaderCompile\n\t\t} = device;\n\t\tif (extParallelShaderCompile) {\n\t\t\treturn device.gl.getProgramParameter(this.glProgram, extParallelShaderCompile.COMPLETION_STATUS_KHR);\n\t\t}\n\t\treturn true;\n\t}\n\t_processError(src, infoLog) {\n\t\tconst error = {};\n\t\tlet code = '';\n\t\tif (src) {\n\t\t\tconst lines = src.split('\\n');\n\t\t\tlet from = 0;\n\t\t\tlet to = lines.length;\n\t\t\tif (infoLog && infoLog.startsWith('ERROR:')) {\n\t\t\t\tconst match = infoLog.match(/^ERROR:\\s([0-9]+):([0-9]+):\\s*(.+)/);\n\t\t\t\tif (match) {\n\t\t\t\t\terror.message = match[3];\n\t\t\t\t\terror.line = parseInt(match[2], 10);\n\t\t\t\t\tfrom = Math.max(0, error.line - 6);\n\t\t\t\t\tto = Math.min(lines.length, error.line + 5);\n\t\t\t\t}\n\t\t\t}\n\t\t\tfor (let i = from; i < to; i++) {\n\t\t\t\tcode += i + 1 + \":\\t\" + lines[i] + '\\n';\n\t\t\t}\n\t\t\terror.source = src;\n\t\t}\n\t\treturn [code, error];\n\t}\n}\n\nexport { WebglShader };\n", "import { PIXELFORMAT_RGBA32U, PIXELFORMAT_RGBA32I, PIXELFORMAT_RGBA16U, PIXELFORMAT_RGBA16I, PIXELFORMAT_RGBA8U, PIXELFORMAT_RGBA8I, PIXELFORMAT_RG32U, PIXELFORMAT_RG32I, PIXELFORMAT_RG16U, PIXELFORMAT_RG16I, PIXELFORMAT_RG8U, PIXELFORMAT_RG8I, PIXELFORMAT_R32U, PIXELFORMAT_R32I, PIXELFORMAT_R16U, PIXELFORMAT_R16I, PIXELFORMAT_R8U, PIXELFORMAT_R8I, PIXELFORMAT_SRGBA, PIXELFORMAT_SRGB, PIXELFORMAT_111110F, PIXELFORMAT_DEPTHSTENCIL, PIXELFORMAT_DEPTH, PIXELFORMAT_R32F, PIXELFORMAT_RGBA32F, PIXELFORMAT_RGB32F, PIXELFORMAT_RGBA16F, PIXELFORMAT_RGB16F, PIXELFORMAT_RG16F, PIXELFORMAT_R16F, PIXELFORMAT_ATC_RGBA, PIXELFORMAT_ATC_RGB, PIXELFORMAT_ASTC_4x4, PIXELFORMAT_ETC2_RGBA, PIXELFORMAT_ETC2_RGB, PIXELFORMAT_PVRTC_4BPP_RGBA_1, PIXELFORMAT_PVRTC_4BPP_RGB_1, PIXELFORMAT_PVRTC_2BPP_RGBA_1, PIXELFORMAT_PVRTC_2BPP_RGB_1, PIXELFORMAT_ETC1, PIXELFORMAT_DXT5, PIXELFORMAT_DXT3, PIXELFORMAT_DXT1, PIXELFORMAT_RGBA8, PIXELFORMAT_RGB8, PIXELFORMAT_RGBA4, PIXELFORMAT_RGBA5551, PIXELFORMAT_RGB565, PIXELFORMAT_LA8, PIXELFORMAT_L8, PIXELFORMAT_A8 } from '../constants.js';\n\nfunction downsampleImage(image, size) {\n\tconst srcW = image.width;\n\tconst srcH = image.height;\n\tif (srcW > size || srcH > size) {\n\t\tconst scale = size / Math.max(srcW, srcH);\n\t\tconst dstW = Math.floor(srcW * scale);\n\t\tconst dstH = Math.floor(srcH * scale);\n\t\tconst canvas = document.createElement('canvas');\n\t\tcanvas.width = dstW;\n\t\tcanvas.height = dstH;\n\t\tconst context = canvas.getContext('2d');\n\t\tcontext.drawImage(image, 0, 0, srcW, srcH, 0, 0, dstW, dstH);\n\t\treturn canvas;\n\t}\n\treturn image;\n}\nclass WebglTexture {\n\tconstructor() {\n\t\tthis._glTexture = null;\n\t\tthis._glTarget = void 0;\n\t\tthis._glFormat = void 0;\n\t\tthis._glInternalFormat = void 0;\n\t\tthis._glPixelType = void 0;\n\t\tthis._glCreated = void 0;\n\t\tthis.dirtyParameterFlags = 0;\n\t}\n\tdestroy(device) {\n\t\tif (this._glTexture) {\n\t\t\tfor (let i = 0; i < device.textureUnits.length; i++) {\n\t\t\t\tconst textureUnit = device.textureUnits[i];\n\t\t\t\tfor (let j = 0; j < textureUnit.length; j++) {\n\t\t\t\t\tif (textureUnit[j] === this._glTexture) {\n\t\t\t\t\t\ttextureUnit[j] = null;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tdevice.gl.deleteTexture(this._glTexture);\n\t\t\tthis._glTexture = null;\n\t\t}\n\t}\n\tloseContext() {\n\t\tthis._glTexture = null;\n\t}\n\tpropertyChanged(flag) {\n\t\tthis.dirtyParameterFlags |= flag;\n\t}\n\tinitialize(device, texture) {\n\t\tconst gl = device.gl;\n\t\tthis._glTexture = gl.createTexture();\n\t\tthis._glTarget = texture._cubemap ? gl.TEXTURE_CUBE_MAP : texture._volume ? gl.TEXTURE_3D : texture.array ? gl.TEXTURE_2D_ARRAY : gl.TEXTURE_2D;\n\t\tswitch (texture._format) {\n\t\t\tcase PIXELFORMAT_A8:\n\t\t\t\tthis._glFormat = gl.ALPHA;\n\t\t\t\tthis._glInternalFormat = gl.ALPHA;\n\t\t\t\tthis._glPixelType = gl.UNSIGNED_BYTE;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_L8:\n\t\t\t\tthis._glFormat = gl.LUMINANCE;\n\t\t\t\tthis._glInternalFormat = gl.LUMINANCE;\n\t\t\t\tthis._glPixelType = gl.UNSIGNED_BYTE;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_LA8:\n\t\t\t\tthis._glFormat = gl.LUMINANCE_ALPHA;\n\t\t\t\tthis._glInternalFormat = gl.LUMINANCE_ALPHA;\n\t\t\t\tthis._glPixelType = gl.UNSIGNED_BYTE;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_RGB565:\n\t\t\t\tthis._glFormat = gl.RGB;\n\t\t\t\tthis._glInternalFormat = gl.RGB;\n\t\t\t\tthis._glPixelType = gl.UNSIGNED_SHORT_5_6_5;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_RGBA5551:\n\t\t\t\tthis._glFormat = gl.RGBA;\n\t\t\t\tthis._glInternalFormat = gl.RGBA;\n\t\t\t\tthis._glPixelType = gl.UNSIGNED_SHORT_5_5_5_1;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_RGBA4:\n\t\t\t\tthis._glFormat = gl.RGBA;\n\t\t\t\tthis._glInternalFormat = gl.RGBA;\n\t\t\t\tthis._glPixelType = gl.UNSIGNED_SHORT_4_4_4_4;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_RGB8:\n\t\t\t\tthis._glFormat = gl.RGB;\n\t\t\t\tthis._glInternalFormat = device.isWebGL2 ? gl.RGB8 : gl.RGB;\n\t\t\t\tthis._glPixelType = gl.UNSIGNED_BYTE;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_RGBA8:\n\t\t\t\tthis._glFormat = gl.RGBA;\n\t\t\t\tthis._glInternalFormat = device.isWebGL2 ? gl.RGBA8 : gl.RGBA;\n\t\t\t\tthis._glPixelType = gl.UNSIGNED_BYTE;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_DXT1:\n\t\t\t\tthis._glFormat = gl.RGB;\n\t\t\t\tthis._glInternalFormat = device.extCompressedTextureS3TC.COMPRESSED_RGB_S3TC_DXT1_EXT;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_DXT3:\n\t\t\t\tthis._glFormat = gl.RGBA;\n\t\t\t\tthis._glInternalFormat = device.extCompressedTextureS3TC.COMPRESSED_RGBA_S3TC_DXT3_EXT;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_DXT5:\n\t\t\t\tthis._glFormat = gl.RGBA;\n\t\t\t\tthis._glInternalFormat = device.extCompressedTextureS3TC.COMPRESSED_RGBA_S3TC_DXT5_EXT;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_ETC1:\n\t\t\t\tthis._glFormat = gl.RGB;\n\t\t\t\tthis._glInternalFormat = device.extCompressedTextureETC1.COMPRESSED_RGB_ETC1_WEBGL;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_PVRTC_2BPP_RGB_1:\n\t\t\t\tthis._glFormat = gl.RGB;\n\t\t\t\tthis._glInternalFormat = device.extCompressedTexturePVRTC.COMPRESSED_RGB_PVRTC_2BPPV1_IMG;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_PVRTC_2BPP_RGBA_1:\n\t\t\t\tthis._glFormat = gl.RGBA;\n\t\t\t\tthis._glInternalFormat = device.extCompressedTexturePVRTC.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_PVRTC_4BPP_RGB_1:\n\t\t\t\tthis._glFormat = gl.RGB;\n\t\t\t\tthis._glInternalFormat = device.extCompressedTexturePVRTC.COMPRESSED_RGB_PVRTC_4BPPV1_IMG;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_PVRTC_4BPP_RGBA_1:\n\t\t\t\tthis._glFormat = gl.RGBA;\n\t\t\t\tthis._glInternalFormat = device.extCompressedTexturePVRTC.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_ETC2_RGB:\n\t\t\t\tthis._glFormat = gl.RGB;\n\t\t\t\tthis._glInternalFormat = device.extCompressedTextureETC.COMPRESSED_RGB8_ETC2;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_ETC2_RGBA:\n\t\t\t\tthis._glFormat = gl.RGBA;\n\t\t\t\tthis._glInternalFormat = device.extCompressedTextureETC.COMPRESSED_RGBA8_ETC2_EAC;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_ASTC_4x4:\n\t\t\t\tthis._glFormat = gl.RGBA;\n\t\t\t\tthis._glInternalFormat = device.extCompressedTextureASTC.COMPRESSED_RGBA_ASTC_4x4_KHR;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_ATC_RGB:\n\t\t\t\tthis._glFormat = gl.RGB;\n\t\t\t\tthis._glInternalFormat = device.extCompressedTextureATC.COMPRESSED_RGB_ATC_WEBGL;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_ATC_RGBA:\n\t\t\t\tthis._glFormat = gl.RGBA;\n\t\t\t\tthis._glInternalFormat = device.extCompressedTextureATC.COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_R16F:\n\t\t\t\tif (device.isWebGL2) {\n\t\t\t\t\tthis._glFormat = gl.RED;\n\t\t\t\t\tthis._glInternalFormat = gl.R16F;\n\t\t\t\t\tthis._glPixelType = gl.HALF_FLOAT;\n\t\t\t\t} else {\n\t\t\t\t\tthis._glFormat = gl.LUMINANCE;\n\t\t\t\t\tthis._glInternalFormat = gl.LUMINANCE;\n\t\t\t\t\tthis._glPixelType = device.extTextureHalfFloat.HALF_FLOAT_OES;\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_RG16F:\n\t\t\t\tif (device.isWebGL2) {\n\t\t\t\t\tthis._glFormat = gl.RG;\n\t\t\t\t\tthis._glInternalFormat = gl.RG16F;\n\t\t\t\t\tthis._glPixelType = gl.HALF_FLOAT;\n\t\t\t\t} else {\n\t\t\t\t\tthis._glFormat = gl.RG;\n\t\t\t\t\tthis._glInternalFormat = gl.RG;\n\t\t\t\t\tthis._glPixelType = device.extTextureHalfFloat.HALF_FLOAT_OES;\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_RGB16F:\n\t\t\t\tthis._glFormat = gl.RGB;\n\t\t\t\tif (device.isWebGL2) {\n\t\t\t\t\tthis._glInternalFormat = gl.RGB16F;\n\t\t\t\t\tthis._glPixelType = gl.HALF_FLOAT;\n\t\t\t\t} else {\n\t\t\t\t\tthis._glInternalFormat = gl.RGB;\n\t\t\t\t\tthis._glPixelType = device.extTextureHalfFloat.HALF_FLOAT_OES;\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_RGBA16F:\n\t\t\t\tthis._glFormat = gl.RGBA;\n\t\t\t\tif (device.isWebGL2) {\n\t\t\t\t\tthis._glInternalFormat = gl.RGBA16F;\n\t\t\t\t\tthis._glPixelType = gl.HALF_FLOAT;\n\t\t\t\t} else {\n\t\t\t\t\tthis._glInternalFormat = gl.RGBA;\n\t\t\t\t\tthis._glPixelType = device.extTextureHalfFloat.HALF_FLOAT_OES;\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_RGB32F:\n\t\t\t\tthis._glFormat = gl.RGB;\n\t\t\t\tif (device.isWebGL2) {\n\t\t\t\t\tthis._glInternalFormat = gl.RGB32F;\n\t\t\t\t} else {\n\t\t\t\t\tthis._glInternalFormat = gl.RGB;\n\t\t\t\t}\n\t\t\t\tthis._glPixelType = gl.FLOAT;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_RGBA32F:\n\t\t\t\tthis._glFormat = gl.RGBA;\n\t\t\t\tif (device.isWebGL2) {\n\t\t\t\t\tthis._glInternalFormat = gl.RGBA32F;\n\t\t\t\t} else {\n\t\t\t\t\tthis._glInternalFormat = gl.RGBA;\n\t\t\t\t}\n\t\t\t\tthis._glPixelType = gl.FLOAT;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_R32F:\n\t\t\t\tthis._glFormat = gl.RED;\n\t\t\t\tthis._glInternalFormat = gl.R32F;\n\t\t\t\tthis._glPixelType = gl.FLOAT;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_DEPTH:\n\t\t\t\tif (device.isWebGL2) {\n\t\t\t\t\tthis._glFormat = gl.DEPTH_COMPONENT;\n\t\t\t\t\tthis._glInternalFormat = gl.DEPTH_COMPONENT32F;\n\t\t\t\t\tthis._glPixelType = gl.FLOAT;\n\t\t\t\t} else {\n\t\t\t\t\tthis._glFormat = gl.DEPTH_COMPONENT;\n\t\t\t\t\tthis._glInternalFormat = gl.DEPTH_COMPONENT;\n\t\t\t\t\tthis._glPixelType = gl.UNSIGNED_SHORT;\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_DEPTHSTENCIL:\n\t\t\t\tthis._glFormat = gl.DEPTH_STENCIL;\n\t\t\t\tif (device.isWebGL2) {\n\t\t\t\t\tthis._glInternalFormat = gl.DEPTH24_STENCIL8;\n\t\t\t\t\tthis._glPixelType = gl.UNSIGNED_INT_24_8;\n\t\t\t\t} else {\n\t\t\t\t\tthis._glInternalFormat = gl.DEPTH_STENCIL;\n\t\t\t\t\tthis._glPixelType = device.extDepthTexture.UNSIGNED_INT_24_8_WEBGL;\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_111110F:\n\t\t\t\tthis._glFormat = gl.RGB;\n\t\t\t\tthis._glInternalFormat = gl.R11F_G11F_B10F;\n\t\t\t\tthis._glPixelType = gl.UNSIGNED_INT_10F_11F_11F_REV;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_SRGB:\n\t\t\t\tthis._glFormat = gl.RGB;\n\t\t\t\tthis._glInternalFormat = gl.SRGB8;\n\t\t\t\tthis._glPixelType = gl.UNSIGNED_BYTE;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_SRGBA:\n\t\t\t\tthis._glFormat = gl.RGBA;\n\t\t\t\tthis._glInternalFormat = gl.SRGB8_ALPHA8;\n\t\t\t\tthis._glPixelType = gl.UNSIGNED_BYTE;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_R8I:\n\t\t\t\tthis._glFormat = gl.RED_INTEGER;\n\t\t\t\tthis._glInternalFormat = gl.R8I;\n\t\t\t\tthis._glPixelType = gl.BYTE;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_R8U:\n\t\t\t\tthis._glFormat = gl.RED_INTEGER;\n\t\t\t\tthis._glInternalFormat = gl.R8UI;\n\t\t\t\tthis._glPixelType = gl.UNSIGNED_BYTE;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_R16I:\n\t\t\t\tthis._glFormat = gl.RED_INTEGER;\n\t\t\t\tthis._glInternalFormat = gl.R16I;\n\t\t\t\tthis._glPixelType = gl.SHORT;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_R16U:\n\t\t\t\tthis._glFormat = gl.RED_INTEGER;\n\t\t\t\tthis._glInternalFormat = gl.R16UI;\n\t\t\t\tthis._glPixelType = gl.UNSIGNED_SHORT;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_R32I:\n\t\t\t\tthis._glFormat = gl.RED_INTEGER;\n\t\t\t\tthis._glInternalFormat = gl.R32I;\n\t\t\t\tthis._glPixelType = gl.INT;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_R32U:\n\t\t\t\tthis._glFormat = gl.RED_INTEGER;\n\t\t\t\tthis._glInternalFormat = gl.R32UI;\n\t\t\t\tthis._glPixelType = gl.UNSIGNED_INT;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_RG8I:\n\t\t\t\tthis._glFormat = gl.RG_INTEGER;\n\t\t\t\tthis._glInternalFormat = gl.RG8I;\n\t\t\t\tthis._glPixelType = gl.BYTE;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_RG8U:\n\t\t\t\tthis._glFormat = gl.RG_INTEGER;\n\t\t\t\tthis._glInternalFormat = gl.RG8UI;\n\t\t\t\tthis._glPixelType = gl.UNSIGNED_BYTE;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_RG16I:\n\t\t\t\tthis._glFormat = gl.RG_INTEGER;\n\t\t\t\tthis._glInternalFormat = gl.RG16I;\n\t\t\t\tthis._glPixelType = gl.SHORT;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_RG16U:\n\t\t\t\tthis._glFormat = gl.RG_INTEGER;\n\t\t\t\tthis._glInternalFormat = gl.RG16UI;\n\t\t\t\tthis._glPixelType = gl.UNSIGNED_SHORT;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_RG32I:\n\t\t\t\tthis._glFormat = gl.RG_INTEGER;\n\t\t\t\tthis._glInternalFormat = gl.RG32I;\n\t\t\t\tthis._glPixelType = gl.INT;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_RG32U:\n\t\t\t\tthis._glFormat = gl.RG_INTEGER;\n\t\t\t\tthis._glInternalFormat = gl.RG32UI;\n\t\t\t\tthis._glPixelType = gl.UNSIGNED_INT;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_RGBA8I:\n\t\t\t\tthis._glFormat = gl.RGBA_INTEGER;\n\t\t\t\tthis._glInternalFormat = gl.RGBA8I;\n\t\t\t\tthis._glPixelType = gl.BYTE;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_RGBA8U:\n\t\t\t\tthis._glFormat = gl.RGBA_INTEGER;\n\t\t\t\tthis._glInternalFormat = gl.RGBA8UI;\n\t\t\t\tthis._glPixelType = gl.UNSIGNED_BYTE;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_RGBA16I:\n\t\t\t\tthis._glFormat = gl.RGBA_INTEGER;\n\t\t\t\tthis._glInternalFormat = gl.RGBA16I;\n\t\t\t\tthis._glPixelType = gl.SHORT;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_RGBA16U:\n\t\t\t\tthis._glFormat = gl.RGBA_INTEGER;\n\t\t\t\tthis._glInternalFormat = gl.RGBA16UI;\n\t\t\t\tthis._glPixelType = gl.UNSIGNED_SHORT;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_RGBA32I:\n\t\t\t\tthis._glFormat = gl.RGBA_INTEGER;\n\t\t\t\tthis._glInternalFormat = gl.RGBA32I;\n\t\t\t\tthis._glPixelType = gl.INT;\n\t\t\t\tbreak;\n\t\t\tcase PIXELFORMAT_RGBA32U:\n\t\t\t\tthis._glFormat = gl.RGBA_INTEGER;\n\t\t\t\tthis._glInternalFormat = gl.RGBA32UI;\n\t\t\t\tthis._glPixelType = gl.UNSIGNED_INT;\n\t\t\t\tbreak;\n\t\t}\n\t\tthis._glCreated = false;\n\t}\n\tupload(device, texture) {\n\t\tconst gl = device.gl;\n\t\tif (!texture._needsUpload && (texture._needsMipmapsUpload && texture._mipmapsUploaded || !texture.pot)) return;\n\t\tlet mipLevel = 0;\n\t\tlet mipObject;\n\t\tlet resMult;\n\t\tconst requiredMipLevels = texture.requiredMipLevels;\n\t\tif (texture.array) {\n\t\t\tgl.texStorage3D(gl.TEXTURE_2D_ARRAY, requiredMipLevels, this._glInternalFormat, texture._width, texture._height, texture._arrayLength);\n\t\t}\n\t\twhile (texture._levels[mipLevel] || mipLevel === 0) {\n\t\t\tif (!texture._needsUpload && mipLevel === 0) {\n\t\t\t\tmipLevel++;\n\t\t\t\tcontinue;\n\t\t\t} else if (mipLevel && (!texture._needsMipmapsUpload || !texture._mipmaps)) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tmipObject = texture._levels[mipLevel];\n\t\t\tresMult = 1 / Math.pow(2, mipLevel);\n\t\t\tif (mipLevel === 1 && !texture._compressed && !texture._integerFormat && texture._levels.length < requiredMipLevels) {\n\t\t\t\tgl.generateMipmap(this._glTarget);\n\t\t\t\ttexture._mipmapsUploaded = true;\n\t\t\t}\n\t\t\tif (texture._cubemap) {\n\t\t\t\tlet face;\n\t\t\t\tif (device._isBrowserInterface(mipObject[0])) {\n\t\t\t\t\tfor (face = 0; face < 6; face++) {\n\t\t\t\t\t\tif (!texture._levelsUpdated[0][face]) continue;\n\t\t\t\t\t\tlet src = mipObject[face];\n\t\t\t\t\t\tif (device._isImageBrowserInterface(src)) {\n\t\t\t\t\t\t\tif (src.width > device.maxCubeMapSize || src.height > device.maxCubeMapSize) {\n\t\t\t\t\t\t\t\tsrc = downsampleImage(src, device.maxCubeMapSize);\n\t\t\t\t\t\t\t\tif (mipLevel === 0) {\n\t\t\t\t\t\t\t\t\ttexture._width = src.width;\n\t\t\t\t\t\t\t\t\ttexture._height = src.height;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tdevice.setUnpackFlipY(false);\n\t\t\t\t\t\tdevice.setUnpackPremultiplyAlpha(texture._premultiplyAlpha);\n\t\t\t\t\t\tif (this._glCreated) {\n\t\t\t\t\t\t\tgl.texSubImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + face, mipLevel, 0, 0, this._glFormat, this._glPixelType, src);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tgl.texImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + face, mipLevel, this._glInternalFormat, this._glFormat, this._glPixelType, src);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tresMult = 1 / Math.pow(2, mipLevel);\n\t\t\t\t\tfor (face = 0; face < 6; face++) {\n\t\t\t\t\t\tif (!texture._levelsUpdated[0][face]) continue;\n\t\t\t\t\t\tconst texData = mipObject[face];\n\t\t\t\t\t\tif (texture._compressed) {\n\t\t\t\t\t\t\tif (this._glCreated && texData) {\n\t\t\t\t\t\t\t\tgl.compressedTexSubImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + face, mipLevel, 0, 0, Math.max(texture._width * resMult, 1), Math.max(texture._height * resMult, 1), this._glInternalFormat, texData);\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tgl.compressedTexImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + face, mipLevel, this._glInternalFormat, Math.max(texture._width * resMult, 1), Math.max(texture._height * resMult, 1), 0, texData);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tdevice.setUnpackFlipY(false);\n\t\t\t\t\t\t\tdevice.setUnpackPremultiplyAlpha(texture._premultiplyAlpha);\n\t\t\t\t\t\t\tif (this._glCreated && texData) {\n\t\t\t\t\t\t\t\tgl.texSubImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + face, mipLevel, 0, 0, Math.max(texture._width * resMult, 1), Math.max(texture._height * resMult, 1), this._glFormat, this._glPixelType, texData);\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tgl.texImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + face, mipLevel, this._glInternalFormat, Math.max(texture._width * resMult, 1), Math.max(texture._height * resMult, 1), 0, this._glFormat, this._glPixelType, texData);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else if (texture._volume) {\n\t\t\t\tif (texture._compressed) {\n\t\t\t\t\tgl.compressedTexImage3D(gl.TEXTURE_3D, mipLevel, this._glInternalFormat, Math.max(texture._width * resMult, 1), Math.max(texture._height * resMult, 1), Math.max(texture._depth * resMult, 1), 0, mipObject);\n\t\t\t\t} else {\n\t\t\t\t\tdevice.setUnpackFlipY(false);\n\t\t\t\t\tdevice.setUnpackPremultiplyAlpha(texture._premultiplyAlpha);\n\t\t\t\t\tgl.texImage3D(gl.TEXTURE_3D, mipLevel, this._glInternalFormat, Math.max(texture._width * resMult, 1), Math.max(texture._height * resMult, 1), Math.max(texture._depth * resMult, 1), 0, this._glFormat, this._glPixelType, mipObject);\n\t\t\t\t}\n\t\t\t} else if (texture.array && typeof mipObject === \"object\") {\n\t\t\t\tif (texture._arrayLength === mipObject.length) {\n\t\t\t\t\tif (texture._compressed) {\n\t\t\t\t\t\tfor (let index = 0; index < texture._arrayLength; index++) {\n\t\t\t\t\t\t\tgl.compressedTexSubImage3D(gl.TEXTURE_2D_ARRAY, mipLevel, 0, 0, index, Math.max(Math.floor(texture._width * resMult), 1), Math.max(Math.floor(texture._height * resMult), 1), 1, this._glFormat, mipObject[index]);\n\t\t\t\t\t\t}\n\t\t\t\t\t} else {\n\t\t\t\t\t\tfor (let index = 0; index < texture._arrayLength; index++) {\n\t\t\t\t\t\t\tgl.texSubImage3D(gl.TEXTURE_2D_ARRAY, mipLevel, 0, 0, index, Math.max(Math.floor(texture._width * resMult), 1), Math.max(Math.floor(texture._height * resMult), 1), 1, this._glFormat, this._glPixelType, mipObject[index]);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tif (device._isBrowserInterface(mipObject)) {\n\t\t\t\t\tif (device._isImageBrowserInterface(mipObject)) {\n\t\t\t\t\t\tif (mipObject.width > device.maxTextureSize || mipObject.height > device.maxTextureSize) {\n\t\t\t\t\t\t\tmipObject = downsampleImage(mipObject, device.maxTextureSize);\n\t\t\t\t\t\t\tif (mipLevel === 0) {\n\t\t\t\t\t\t\t\ttexture._width = mipObject.width;\n\t\t\t\t\t\t\t\ttexture._height = mipObject.height;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tconst w = mipObject.width || mipObject.videoWidth;\n\t\t\t\t\tconst h = mipObject.height || mipObject.videoHeight;\n\t\t\t\t\tdevice.setUnpackFlipY(texture._flipY);\n\t\t\t\t\tdevice.setUnpackPremultiplyAlpha(texture._premultiplyAlpha);\n\t\t\t\t\tif (this._glCreated && texture._width === w && texture._height === h && !device._isImageVideoInterface(mipObject)) {\n\t\t\t\t\t\tgl.texSubImage2D(gl.TEXTURE_2D, mipLevel, 0, 0, this._glFormat, this._glPixelType, mipObject);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tgl.texImage2D(gl.TEXTURE_2D, mipLevel, this._glInternalFormat, this._glFormat, this._glPixelType, mipObject);\n\t\t\t\t\t\tif (mipLevel === 0) {\n\t\t\t\t\t\t\ttexture._width = w;\n\t\t\t\t\t\t\ttexture._height = h;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tresMult = 1 / Math.pow(2, mipLevel);\n\t\t\t\t\tif (texture._compressed) {\n\t\t\t\t\t\tif (this._glCreated && mipObject) {\n\t\t\t\t\t\t\tgl.compressedTexSubImage2D(gl.TEXTURE_2D, mipLevel, 0, 0, Math.max(Math.floor(texture._width * resMult), 1), Math.max(Math.floor(texture._height * resMult), 1), this._glInternalFormat, mipObject);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tgl.compressedTexImage2D(gl.TEXTURE_2D, mipLevel, this._glInternalFormat, Math.max(Math.floor(texture._width * resMult), 1), Math.max(Math.floor(texture._height * resMult), 1), 0, mipObject);\n\t\t\t\t\t\t}\n\t\t\t\t\t} else {\n\t\t\t\t\t\tdevice.setUnpackFlipY(false);\n\t\t\t\t\t\tdevice.setUnpackPremultiplyAlpha(texture._premultiplyAlpha);\n\t\t\t\t\t\tif (this._glCreated && mipObject) {\n\t\t\t\t\t\t\tgl.texSubImage2D(gl.TEXTURE_2D, mipLevel, 0, 0, Math.max(texture._width * resMult, 1), Math.max(texture._height * resMult, 1), this._glFormat, this._glPixelType, mipObject);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tgl.texImage2D(gl.TEXTURE_2D, mipLevel, this._glInternalFormat, Math.max(texture._width * resMult, 1), Math.max(texture._height * resMult, 1), 0, this._glFormat, this._glPixelType, mipObject);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tif (mipLevel === 0) {\n\t\t\t\t\ttexture._mipmapsUploaded = false;\n\t\t\t\t} else {\n\t\t\t\t\ttexture._mipmapsUploaded = true;\n\t\t\t\t}\n\t\t\t}\n\t\t\tmipLevel++;\n\t\t}\n\t\tif (texture._needsUpload) {\n\t\t\tif (texture._cubemap) {\n\t\t\t\tfor (let i = 0; i < 6; i++) texture._levelsUpdated[0][i] = false;\n\t\t\t} else {\n\t\t\t\ttexture._levelsUpdated[0] = false;\n\t\t\t}\n\t\t}\n\t\tif (!texture._compressed && !texture._integerFormat && texture._mipmaps && texture._needsMipmapsUpload && (texture.pot || device.isWebGL2) && texture._levels.length === 1) {\n\t\t\tgl.generateMipmap(this._glTarget);\n\t\t\ttexture._mipmapsUploaded = true;\n\t\t}\n\t\tif (texture._gpuSize) {\n\t\t\ttexture.adjustVramSizeTracking(device._vram, -texture._gpuSize);\n\t\t}\n\t\ttexture._gpuSize = texture.gpuSize;\n\t\ttexture.adjustVramSizeTracking(device._vram, texture._gpuSize);\n\t\tthis._glCreated = true;\n\t}\n}\n\nexport { WebglTexture };\n", "import { PIXELFORMAT_RGBA8 } from '../constants.js';\n\nclass FramebufferPair {\n\tconstructor(msaaFB, resolveFB) {\n\t\tthis.msaaFB = void 0;\n\t\tthis.resolveFB = void 0;\n\t\tthis.msaaFB = msaaFB;\n\t\tthis.resolveFB = resolveFB;\n\t}\n\tdestroy(gl) {\n\t\tif (this.msaaFB) {\n\t\t\tgl.deleteRenderbuffer(this.msaaFB);\n\t\t\tthis.msaaFB = null;\n\t\t}\n\t\tif (this.resolveFB) {\n\t\t\tgl.deleteRenderbuffer(this.resolveFB);\n\t\t\tthis.resolveFB = null;\n\t\t}\n\t}\n}\nclass WebglRenderTarget {\n\tconstructor() {\n\t\tthis._glFrameBuffer = null;\n\t\tthis._glDepthBuffer = null;\n\t\tthis._glResolveFrameBuffer = null;\n\t\tthis.colorMrtFramebuffers = null;\n\t\tthis._glMsaaColorBuffers = [];\n\t\tthis._glMsaaDepthBuffer = null;\n\t\tthis.suppliedColorFramebuffer = void 0;\n\t\tthis._isInitialized = false;\n\t}\n\tdestroy(device) {\n\t\tvar _this$colorMrtFramebu;\n\t\tconst gl = device.gl;\n\t\tthis._isInitialized = false;\n\t\tif (this._glFrameBuffer) {\n\t\t\tif (this._glFrameBuffer !== this.suppliedColorFramebuffer) gl.deleteFramebuffer(this._glFrameBuffer);\n\t\t\tthis._glFrameBuffer = null;\n\t\t}\n\t\tif (this._glDepthBuffer) {\n\t\t\tgl.deleteRenderbuffer(this._glDepthBuffer);\n\t\t\tthis._glDepthBuffer = null;\n\t\t}\n\t\tif (this._glResolveFrameBuffer) {\n\t\t\tif (this._glResolveFrameBuffer !== this.suppliedColorFramebuffer) gl.deleteFramebuffer(this._glResolveFrameBuffer);\n\t\t\tthis._glResolveFrameBuffer = null;\n\t\t}\n\t\tthis._glMsaaColorBuffers.forEach(buffer => {\n\t\t\tgl.deleteRenderbuffer(buffer);\n\t\t});\n\t\tthis._glMsaaColorBuffers.length = 0;\n\t\t(_this$colorMrtFramebu = this.colorMrtFramebuffers) == null || _this$colorMrtFramebu.forEach(framebuffer => {\n\t\t\tframebuffer.destroy(gl);\n\t\t});\n\t\tthis.colorMrtFramebuffers = null;\n\t\tif (this._glMsaaDepthBuffer) {\n\t\t\tgl.deleteRenderbuffer(this._glMsaaDepthBuffer);\n\t\t\tthis._glMsaaDepthBuffer = null;\n\t\t}\n\t\tthis.suppliedColorFramebuffer = undefined;\n\t}\n\tget initialized() {\n\t\treturn this._isInitialized;\n\t}\n\tinit(device, target) {\n\t\tconst gl = device.gl;\n\t\tthis._isInitialized = true;\n\t\tconst buffers = [];\n\t\tif (this.suppliedColorFramebuffer !== undefined) {\n\t\t\tthis._glFrameBuffer = this.suppliedColorFramebuffer;\n\t\t} else {\n\t\t\tvar _target$_colorBuffers, _target$_colorBuffers2, _device$extDrawBuffer, _device$extDrawBuffer2;\n\t\t\tthis._glFrameBuffer = gl.createFramebuffer();\n\t\t\tdevice.setFramebuffer(this._glFrameBuffer);\n\t\t\tconst colorBufferCount = (_target$_colorBuffers = (_target$_colorBuffers2 = target._colorBuffers) == null ? void 0 : _target$_colorBuffers2.length) != null ? _target$_colorBuffers : 0;\n\t\t\tconst attachmentBaseConstant = device.isWebGL2 ? gl.COLOR_ATTACHMENT0 : (_device$extDrawBuffer = (_device$extDrawBuffer2 = device.extDrawBuffers) == null ? void 0 : _device$extDrawBuffer2.COLOR_ATTACHMENT0_WEBGL) != null ? _device$extDrawBuffer : gl.COLOR_ATTACHMENT0;\n\t\t\tfor (let i = 0; i < colorBufferCount; ++i) {\n\t\t\t\tconst colorBuffer = target.getColorBuffer(i);\n\t\t\t\tif (colorBuffer) {\n\t\t\t\t\tif (!colorBuffer.impl._glTexture) {\n\t\t\t\t\t\tcolorBuffer._width = Math.min(colorBuffer.width, device.maxRenderBufferSize);\n\t\t\t\t\t\tcolorBuffer._height = Math.min(colorBuffer.height, device.maxRenderBufferSize);\n\t\t\t\t\t\tdevice.setTexture(colorBuffer, 0);\n\t\t\t\t\t}\n\t\t\t\t\tgl.framebufferTexture2D(gl.FRAMEBUFFER, attachmentBaseConstant + i, colorBuffer._cubemap ? gl.TEXTURE_CUBE_MAP_POSITIVE_X + target._face : gl.TEXTURE_2D, colorBuffer.impl._glTexture, 0);\n\t\t\t\t\tbuffers.push(attachmentBaseConstant + i);\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (device.drawBuffers) {\n\t\t\t\tdevice.drawBuffers(buffers);\n\t\t\t}\n\t\t\tconst depthBuffer = target._depthBuffer;\n\t\t\tif (depthBuffer) {\n\t\t\t\tif (!depthBuffer.impl._glTexture) {\n\t\t\t\t\tdepthBuffer._width = Math.min(depthBuffer.width, device.maxRenderBufferSize);\n\t\t\t\t\tdepthBuffer._height = Math.min(depthBuffer.height, device.maxRenderBufferSize);\n\t\t\t\t\tdevice.setTexture(depthBuffer, 0);\n\t\t\t\t}\n\t\t\t\tif (target._stencil) {\n\t\t\t\t\tgl.framebufferTexture2D(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, depthBuffer._cubemap ? gl.TEXTURE_CUBE_MAP_POSITIVE_X + target._face : gl.TEXTURE_2D, target._depthBuffer.impl._glTexture, 0);\n\t\t\t\t} else {\n\t\t\t\t\tgl.framebufferTexture2D(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, depthBuffer._cubemap ? gl.TEXTURE_CUBE_MAP_POSITIVE_X + target._face : gl.TEXTURE_2D, target._depthBuffer.impl._glTexture, 0);\n\t\t\t\t}\n\t\t\t} else if (target._depth) {\n\t\t\t\tconst willRenderMsaa = target._samples > 1 && device.isWebGL2;\n\t\t\t\tif (!willRenderMsaa) {\n\t\t\t\t\tif (!this._glDepthBuffer) {\n\t\t\t\t\t\tthis._glDepthBuffer = gl.createRenderbuffer();\n\t\t\t\t\t}\n\t\t\t\t\tgl.bindRenderbuffer(gl.RENDERBUFFER, this._glDepthBuffer);\n\t\t\t\t\tif (target._stencil) {\n\t\t\t\t\t\tgl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_STENCIL, target.width, target.height);\n\t\t\t\t\t\tgl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, gl.RENDERBUFFER, this._glDepthBuffer);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tconst depthFormat = device.isWebGL2 ? gl.DEPTH_COMPONENT32F : gl.DEPTH_COMPONENT16;\n\t\t\t\t\t\tgl.renderbufferStorage(gl.RENDERBUFFER, depthFormat, target.width, target.height);\n\t\t\t\t\t\tgl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, this._glDepthBuffer);\n\t\t\t\t\t}\n\t\t\t\t\tgl.bindRenderbuffer(gl.RENDERBUFFER, null);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (device.isWebGL2 && target._samples > 1) {\n\t\t\tvar _target$_colorBuffers3, _target$_colorBuffers4;\n\t\t\tthis._glResolveFrameBuffer = this._glFrameBuffer;\n\t\t\tthis._glFrameBuffer = gl.createFramebuffer();\n\t\t\tdevice.setFramebuffer(this._glFrameBuffer);\n\t\t\tconst colorBufferCount = (_target$_colorBuffers3 = (_target$_colorBuffers4 = target._colorBuffers) == null ? void 0 : _target$_colorBuffers4.length) != null ? _target$_colorBuffers3 : 0;\n\t\t\tif (this.suppliedColorFramebuffer !== undefined) {\n\t\t\t\tconst buffer = gl.createRenderbuffer();\n\t\t\t\tthis._glMsaaColorBuffers.push(buffer);\n\t\t\t\tconst internalFormat = device.backBufferFormat === PIXELFORMAT_RGBA8 ? gl.RGBA8 : gl.RGB8;\n\t\t\t\tgl.bindRenderbuffer(gl.RENDERBUFFER, buffer);\n\t\t\t\tgl.renderbufferStorageMultisample(gl.RENDERBUFFER, target._samples, internalFormat, target.width, target.height);\n\t\t\t\tgl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, buffer);\n\t\t\t} else {\n\t\t\t\tfor (let i = 0; i < colorBufferCount; ++i) {\n\t\t\t\t\tconst colorBuffer = target.getColorBuffer(i);\n\t\t\t\t\tif (colorBuffer) {\n\t\t\t\t\t\tconst buffer = gl.createRenderbuffer();\n\t\t\t\t\t\tthis._glMsaaColorBuffers.push(buffer);\n\t\t\t\t\t\tgl.bindRenderbuffer(gl.RENDERBUFFER, buffer);\n\t\t\t\t\t\tgl.renderbufferStorageMultisample(gl.RENDERBUFFER, target._samples, colorBuffer.impl._glInternalFormat, target.width, target.height);\n\t\t\t\t\t\tgl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + i, gl.RENDERBUFFER, buffer);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (target._depth) {\n\t\t\t\tif (!this._glMsaaDepthBuffer) {\n\t\t\t\t\tthis._glMsaaDepthBuffer = gl.createRenderbuffer();\n\t\t\t\t}\n\t\t\t\tgl.bindRenderbuffer(gl.RENDERBUFFER, this._glMsaaDepthBuffer);\n\t\t\t\tif (target._stencil) {\n\t\t\t\t\tgl.renderbufferStorageMultisample(gl.RENDERBUFFER, target._samples, gl.DEPTH24_STENCIL8, target.width, target.height);\n\t\t\t\t\tgl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, gl.RENDERBUFFER, this._glMsaaDepthBuffer);\n\t\t\t\t} else {\n\t\t\t\t\tgl.renderbufferStorageMultisample(gl.RENDERBUFFER, target._samples, gl.DEPTH_COMPONENT32F, target.width, target.height);\n\t\t\t\t\tgl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, this._glMsaaDepthBuffer);\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (colorBufferCount > 1) {\n\t\t\t\tthis._createMsaaMrtFramebuffers(device, target, colorBufferCount);\n\t\t\t\tdevice.setFramebuffer(this._glFrameBuffer);\n\t\t\t\tdevice.drawBuffers(buffers);\n\t\t\t}\n\t\t}\n\t}\n\t_createMsaaMrtFramebuffers(device, target, colorBufferCount) {\n\t\tconst gl = device.gl;\n\t\tthis.colorMrtFramebuffers = [];\n\t\tfor (let i = 0; i < colorBufferCount; ++i) {\n\t\t\tconst colorBuffer = target.getColorBuffer(i);\n\t\t\tconst srcFramebuffer = gl.createFramebuffer();\n\t\t\tdevice.setFramebuffer(srcFramebuffer);\n\t\t\tconst buffer = this._glMsaaColorBuffers[i];\n\t\t\tgl.bindRenderbuffer(gl.RENDERBUFFER, buffer);\n\t\t\tgl.renderbufferStorageMultisample(gl.RENDERBUFFER, target._samples, colorBuffer.impl._glInternalFormat, target.width, target.height);\n\t\t\tgl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, buffer);\n\t\t\tdevice.drawBuffers([gl.COLOR_ATTACHMENT0]);\n\t\t\tconst dstFramebuffer = gl.createFramebuffer();\n\t\t\tdevice.setFramebuffer(dstFramebuffer);\n\t\t\tgl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, colorBuffer._cubemap ? gl.TEXTURE_CUBE_MAP_POSITIVE_X + target._face : gl.TEXTURE_2D, colorBuffer.impl._glTexture, 0);\n\t\t\tthis.colorMrtFramebuffers[i] = new FramebufferPair(srcFramebuffer, dstFramebuffer);\n\t\t}\n\t}\n\t_checkFbo(device, target, type = '') {\n\t\tconst gl = device.gl;\n\t\tconst status = gl.checkFramebufferStatus(gl.FRAMEBUFFER);\n\t\tswitch (status) {\n\t\t\tcase gl.FRAMEBUFFER_INCOMPLETE_ATTACHMENT:\n\t\t\t\tbreak;\n\t\t\tcase gl.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:\n\t\t\t\tbreak;\n\t\t\tcase gl.FRAMEBUFFER_INCOMPLETE_DIMENSIONS:\n\t\t\t\tbreak;\n\t\t\tcase gl.FRAMEBUFFER_UNSUPPORTED:\n\t\t\t\tbreak;\n\t\t}\n\t}\n\tloseContext() {\n\t\tthis._glFrameBuffer = null;\n\t\tthis._glDepthBuffer = null;\n\t\tthis._glResolveFrameBuffer = null;\n\t\tthis._glMsaaColorBuffers.length = 0;\n\t\tthis._glMsaaDepthBuffer = null;\n\t\tthis.colorMrtFramebuffers = null;\n\t\tthis.suppliedColorFramebuffer = undefined;\n\t\tthis._isInitialized = false;\n\t}\n\tinternalResolve(device, src, dst, target, mask) {\n\t\tdevice.setScissor(0, 0, target.width, target.height);\n\t\tconst gl = device.gl;\n\t\tgl.bindFramebuffer(gl.READ_FRAMEBUFFER, src);\n\t\tgl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, dst);\n\t\tgl.blitFramebuffer(0, 0, target.width, target.height, 0, 0, target.width, target.height, mask, gl.NEAREST);\n\t}\n\tresolve(device, target, color, depth) {\n\t\tif (device.isWebGL2) {\n\t\t\tconst gl = device.gl;\n\t\t\tif (this.colorMrtFramebuffers) {\n\t\t\t\tif (color) {\n\t\t\t\t\tfor (let i = 0; i < this.colorMrtFramebuffers.length; i++) {\n\t\t\t\t\t\tconst fbPair = this.colorMrtFramebuffers[i];\n\t\t\t\t\t\tthis.internalResolve(device, fbPair.msaaFB, fbPair.resolveFB, target, gl.COLOR_BUFFER_BIT);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tif (depth) {\n\t\t\t\t\tthis.internalResolve(device, this._glFrameBuffer, this._glResolveFrameBuffer, target, gl.DEPTH_BUFFER_BIT);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tthis.internalResolve(device, this._glFrameBuffer, this._glResolveFrameBuffer, target, (color ? gl.COLOR_BUFFER_BIT : 0) | (depth ? gl.DEPTH_BUFFER_BIT : 0));\n\t\t\t}\n\t\t\tgl.bindFramebuffer(gl.FRAMEBUFFER, this._glFrameBuffer);\n\t\t}\n\t}\n}\n\nexport { WebglRenderTarget };\n", "var gles2PS = `\n#define pcFragColor0 gl_FragData[0]\n#if COLOR_ATTACHMENT_1\n#define pcFragColor1 gl_FragData[1]\n#endif\n#if COLOR_ATTACHMENT_2\n#define pcFragColor2 gl_FragData[2]\n#endif\n#if COLOR_ATTACHMENT_3\n#define pcFragColor3 gl_FragData[3]\n#endif\n#if COLOR_ATTACHMENT_4\n#define pcFragColor4 gl_FragData[4]\n#endif\n#if COLOR_ATTACHMENT_5\n#define pcFragColor5 gl_FragData[5]\n#endif\n#if COLOR_ATTACHMENT_6\n#define pcFragColor6 gl_FragData[6]\n#endif\n#if COLOR_ATTACHMENT_7\n#define pcFragColor7 gl_FragData[7]\n#endif\n#define texture2DBias texture2D\n#define itexture2D texture2D\n#define utexture2D texture2D\n#define SHADOWMAP_PASS(name) name\n#define SHADOWMAP_ACCEPT(name) sampler2D name\n#define TEXTURE_PASS(name) name\n#define TEXTURE_ACCEPT(name) sampler2D name\n#define TEXTURE_ACCEPT_HIGHP(name) highp sampler2D name\n#ifndef SUPPORTS_TEXLOD\n\t#define texture2DLodEXT texture2D\n\t#define texture2DProjLodEXT textureProj\n\t#define textureCubeLodEXT textureCube\n\t#define textureShadow texture2D\n#else\n\t#define textureShadow(res, uv) texture2DGradEXT(res, uv, vec2(1, 1), vec2(1, 1))\n#endif\n#ifdef SUPPORTS_MRT\n\t#define gl_FragColor pcFragColor0\n#endif\n`;\n\nexport { gles2PS as default };\n", "var gles2VS = `\n#define TEXTURE_PASS(name) name\n#define TEXTURE_ACCEPT(name) sampler2D name\n#define TEXTURE_ACCEPT_HIGHP(name) highp sampler2D name\n`;\n\nexport { gles2VS as default };\n", "var gles3PS = `\n#ifndef outType_0\n#define outType_0 vec4\n#endif\nlayout(location = 0) out highp outType_0 pc_fragColor;\n#ifndef REMOVE_COLOR_ATTACHMENT_1\n#if COLOR_ATTACHMENT_1\nlayout(location = 1) out highp outType_1 pc_fragColor1;\n#endif\n#endif\n#ifndef REMOVE_COLOR_ATTACHMENT_2\n#if COLOR_ATTACHMENT_2\nlayout(location = 2) out highp outType_2 pc_fragColor2;\n#endif\n#endif\n#ifndef REMOVE_COLOR_ATTACHMENT_3\n#if COLOR_ATTACHMENT_3\nlayout(location = 3) out highp outType_3 pc_fragColor3;\n#endif\n#endif\n#ifndef REMOVE_COLOR_ATTACHMENT_4\n#if COLOR_ATTACHMENT_4\nlayout(location = 4) out highp outType_4 pc_fragColor4;\n#endif\n#endif\n#ifndef REMOVE_COLOR_ATTACHMENT_5\n#if COLOR_ATTACHMENT_5\nlayout(location = 5) out highp outType_5 pc_fragColor5;\n#endif\n#endif\n#ifndef REMOVE_COLOR_ATTACHMENT_6\n#if COLOR_ATTACHMENT_6\nlayout(location = 6) out highp outType_6 pc_fragColor6;\n#endif\n#endif\n#ifndef REMOVE_COLOR_ATTACHMENT_7\n#if COLOR_ATTACHMENT_7\nlayout(location = 7) out highp outType_7 pc_fragColor7;\n#endif\n#endif\n#define gl_FragColor pc_fragColor\n#define pcFragColor0 pc_fragColor\n#define pcFragColor1 pc_fragColor1\n#define pcFragColor2 pc_fragColor2\n#define pcFragColor3 pc_fragColor3\n#define pcFragColor4 pc_fragColor4\n#define pcFragColor5 pc_fragColor5\n#define pcFragColor6 pc_fragColor6\n#define pcFragColor7 pc_fragColor7\n#define varying in\n#define texture2D texture\n#define texture2DBias texture\n#define textureCube texture\n#define texture2DProj textureProj\n#define texture2DLodEXT textureLod\n#define texture2DProjLodEXT textureProjLod\n#define textureCubeLodEXT textureLod\n#define texture2DGradEXT textureGrad\n#define texture2DProjGradEXT textureProjGrad\n#define textureCubeGradEXT textureGrad\n#define utexture2D texture\n#define itexture2D texture\n#define textureShadow(res, uv) textureGrad(res, uv, vec2(1, 1), vec2(1, 1))\n#define SHADOWMAP_PASS(name) name\n#define SHADOWMAP_ACCEPT(name) sampler2DShadow name\n#define TEXTURE_PASS(name) name\n#define TEXTURE_ACCEPT(name) sampler2D name\n#define TEXTURE_ACCEPT_HIGHP(name) highp sampler2D name\n#define GL2\n#define SUPPORTS_TEXLOD\n#define SUPPORTS_MRT\n`;\n\nexport { gles3PS as default };\n", "var gles3VS = `\n#define attribute in\n#define varying out\n#define texture2D texture\n#define utexture2D texture\n#define itexture2D texture\n#define GL2\n#define VERTEXSHADER\n#define TEXTURE_PASS(name) name\n#define TEXTURE_ACCEPT(name) sampler2D name\n#define TEXTURE_ACCEPT_HIGHP(name) highp sampler2D name\n`;\n\nexport { gles3VS as default };\n", "var webgpuPS = `\n#extension GL_EXT_samplerless_texture_functions : require\n#ifndef outType_0\n#define outType_0 vec4\n#endif\n#ifndef outType_1\n#define outType_1 vec4\n#endif\n#ifndef outType_2\n#define outType_2 vec4\n#endif\n#ifndef outType_3\n#define outType_3 vec4\n#endif\n#ifndef outType_4\n#define outType_4 vec4\n#endif\n#ifndef outType_5\n#define outType_5 vec4\n#endif\n#ifndef outType_6\n#define outType_6 vec4\n#endif\n#ifndef outType_7\n#define outType_7 vec4\n#endif\nlayout(location = 0) out highp outType_0 pc_fragColor;\nlayout(location = 1) out highp outType_1 pc_fragColor1;\nlayout(location = 2) out highp outType_2 pc_fragColor2;\nlayout(location = 3) out highp outType_3 pc_fragColor3;\nlayout(location = 4) out highp outType_4 pc_fragColor4;\nlayout(location = 5) out highp outType_5 pc_fragColor5;\nlayout(location = 6) out highp outType_6 pc_fragColor6;\nlayout(location = 7) out highp outType_7 pc_fragColor7;\n#define gl_FragColor pc_fragColor\n#define pcFragColor0 pc_fragColor\n#define pcFragColor1 pc_fragColor1\n#define pcFragColor2 pc_fragColor2\n#define pcFragColor3 pc_fragColor3\n#define pcFragColor4 pc_fragColor4\n#define pcFragColor5 pc_fragColor5\n#define pcFragColor6 pc_fragColor6\n#define pcFragColor7 pc_fragColor7\n#define texture2D(res, uv) texture(sampler2D(res, res ## _sampler), uv)\n#define texture2DBias(res, uv, bias) texture(sampler2D(res, res ## _sampler), uv, bias)\n#define texture2DLodEXT(res, uv, lod) textureLod(sampler2D(res, res ## _sampler), uv, lod)\n#define textureCube(res, uv) texture(samplerCube(res, res ## _sampler), uv)\n#define textureCubeLodEXT(res, uv, lod) textureLod(samplerCube(res, res ## _sampler), uv, lod)\n#define textureShadow(res, uv) textureLod(sampler2DShadow(res, res ## _sampler), uv, 0.0)\n#define itexture2D(res, uv) texture(isampler2D(res, res ## _sampler), uv)\n#define utexture2D(res, uv) texture(usampler2D(res, res ## _sampler), uv)\n#define SHADOWMAP_PASS(name) name, name ## _sampler\n#define SHADOWMAP_ACCEPT(name) texture2D name, sampler name ## _sampler\n#define TEXTURE_PASS(name) name, name ## _sampler\n#define TEXTURE_ACCEPT(name) texture2D name, sampler name ## _sampler\n#define TEXTURE_ACCEPT_HIGHP TEXTURE_ACCEPT\n#define GL2\n#define WEBGPU\n#define SUPPORTS_TEXLOD\n#define SUPPORTS_MRT\n`;\n\nexport { webgpuPS as default };\n", "var webgpuVS = `\n#extension GL_EXT_samplerless_texture_functions : require\n#define texture2D(res, uv) texture(sampler2D(res, res ## _sampler), uv)\n#define itexture2D(res, uv) texture(isampler2D(res, res ## _sampler), uv)\n#define utexture2D(res, uv) texture(usampler2D(res, res ## _sampler), uv)\n#define TEXTURE_PASS(name) name, name ## _sampler\n#define TEXTURE_ACCEPT(name) texture2D name, sampler name ## _sampler\n#define TEXTURE_ACCEPT_HIGHP TEXTURE_ACCEPT\n#define GL2\n#define WEBGPU\n#define VERTEXSHADER\n#define gl_VertexID gl_VertexIndex\n`;\n\nexport { webgpuVS as default };\n", "var sharedFS = `\nvec2 getGrabScreenPos(vec4 clipPos) {\n\tvec2 uv = (clipPos.xy / clipPos.w) * 0.5 + 0.5;\n\t#ifdef WEBGPU\n\t\tuv.y = 1.0 - uv.y;\n\t#endif\n\treturn uv;\n}\nvec2 getImageEffectUV(vec2 uv) {\n\t#ifdef WEBGPU\n\t\tuv.y = 1.0 - uv.y;\n\t#endif\n\treturn uv;\n}\n`;\n\nexport { sharedFS as default };\n", "import { SEMANTIC_POSITION, SEMANTIC_NORMAL, SEMANTIC_TANGENT, SEMANTIC_TEXCOORD0, SEMANTIC_TEXCOORD1, SEMANTIC_TEXCOORD2, SEMANTIC_TEXCOORD3, SEMANTIC_TEXCOORD4, SEMANTIC_TEXCOORD5, SEMANTIC_TEXCOORD6, SEMANTIC_TEXCOORD7, SEMANTIC_COLOR, SEMANTIC_BLENDINDICES, SEMANTIC_BLENDWEIGHT } from './constants.js';\nimport gles2PS from './shader-chunks/frag/gles2.js';\nimport gles2VS from './shader-chunks/vert/gles2.js';\nimport gles3PS from './shader-chunks/frag/gles3.js';\nimport gles3VS from './shader-chunks/vert/gles3.js';\nimport webgpuPS from './shader-chunks/frag/webgpu.js';\nimport webgpuVS from './shader-chunks/vert/webgpu.js';\nimport sharedFS from './shader-chunks/frag/shared.js';\n\nconst _attrib2Semantic = {\n\tvertex_position: SEMANTIC_POSITION,\n\tvertex_normal: SEMANTIC_NORMAL,\n\tvertex_tangent: SEMANTIC_TANGENT,\n\tvertex_texCoord0: SEMANTIC_TEXCOORD0,\n\tvertex_texCoord1: SEMANTIC_TEXCOORD1,\n\tvertex_texCoord2: SEMANTIC_TEXCOORD2,\n\tvertex_texCoord3: SEMANTIC_TEXCOORD3,\n\tvertex_texCoord4: SEMANTIC_TEXCOORD4,\n\tvertex_texCoord5: SEMANTIC_TEXCOORD5,\n\tvertex_texCoord6: SEMANTIC_TEXCOORD6,\n\tvertex_texCoord7: SEMANTIC_TEXCOORD7,\n\tvertex_color: SEMANTIC_COLOR,\n\tvertex_boneIndices: SEMANTIC_BLENDINDICES,\n\tvertex_boneWeights: SEMANTIC_BLENDWEIGHT\n};\nclass ShaderUtils {\n\tstatic createDefinition(device, options) {\n\t\tvar _options$name, _options$attributes;\n\t\tconst getDefines = (gpu, gl2, gl1, isVertex, options) => {\n\t\t\tconst deviceIntro = device.isWebGPU ? gpu : device.isWebGL2 ? gl2 : ShaderUtils.gl1Extensions(device, options) + gl1;\n\t\t\tlet attachmentsDefine = '';\n\t\t\tif (!isVertex) {\n\t\t\t\tvar _options$fragmentOutp;\n\t\t\t\tlet fragmentOutputTypes = (_options$fragmentOutp = options.fragmentOutputTypes) != null ? _options$fragmentOutp : 'vec4';\n\t\t\t\tif (!Array.isArray(fragmentOutputTypes)) {\n\t\t\t\t\tfragmentOutputTypes = [fragmentOutputTypes];\n\t\t\t\t}\n\t\t\t\tfor (let i = 0; i < device.maxColorAttachments; i++) {\n\t\t\t\t\tvar _fragmentOutputTypes$;\n\t\t\t\t\tattachmentsDefine += `#define COLOR_ATTACHMENT_${i}\\n`;\n\t\t\t\t\tconst outType = (_fragmentOutputTypes$ = fragmentOutputTypes[i]) != null ? _fragmentOutputTypes$ : 'vec4';\n\t\t\t\t\tattachmentsDefine += `#define outType_${i} ${outType}\\n`;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn attachmentsDefine + deviceIntro;\n\t\t};\n\t\tconst name = (_options$name = options.name) != null ? _options$name : 'Untitled';\n\t\tconst vertCode = ShaderUtils.versionCode(device) + getDefines(webgpuVS, gles3VS, gles2VS, true, options) + ShaderUtils.getDefinesCode(options.vertexDefines) + sharedFS + ShaderUtils.getShaderNameCode(name) + options.vertexCode;\n\t\tconst fragCode = (options.fragmentPreamble || '') + ShaderUtils.versionCode(device) + getDefines(webgpuPS, gles3PS, gles2PS, false, options) + ShaderUtils.getDefinesCode(options.fragmentDefines) + ShaderUtils.precisionCode(device) + '\\n' + sharedFS + ShaderUtils.getShaderNameCode(name) + (options.fragmentCode || ShaderUtils.dummyFragmentCode());\n\t\tconst attribs = (_options$attributes = options.attributes) != null ? _options$attributes : ShaderUtils.collectAttributes(options.vertexCode);\n\t\treturn {\n\t\t\tname: name,\n\t\t\tattributes: attribs,\n\t\t\tvshader: vertCode,\n\t\t\tvincludes: options.vertexIncludes,\n\t\t\tfincludes: options.fragmentIncludes,\n\t\t\tfshader: fragCode,\n\t\t\tuseTransformFeedback: options.useTransformFeedback\n\t\t};\n\t}\n\tstatic getDefinesCode(defines) {\n\t\tlet code = '';\n\t\tdefines == null || defines.forEach((value, key) => {\n\t\t\tcode += `#define ${key} ${value}\\n`;\n\t\t});\n\t\treturn code;\n\t}\n\tstatic getShaderNameCode(name) {\n\t\treturn `#define SHADER_NAME ${name}\\n`;\n\t}\n\tstatic gl1Extensions(device, options, isVertex) {\n\t\tlet code;\n\t\tif (isVertex) {\n\t\t\tcode = options.vertexExtensions ? `${options.vertexExtensions}\\n` : '';\n\t\t} else {\n\t\t\tcode = options.fragmentExtensions ? `${options.fragmentExtensions}\\n` : '';\n\t\t\tif (device.extStandardDerivatives) {\n\t\t\t\tcode += \"#extension GL_OES_standard_derivatives : enable\\n\";\n\t\t\t}\n\t\t\tif (device.extTextureLod) {\n\t\t\t\tcode += \"#extension GL_EXT_shader_texture_lod : enable\\n\";\n\t\t\t\tcode += \"#define SUPPORTS_TEXLOD\\n\";\n\t\t\t}\n\t\t\tif (device.extDrawBuffers) {\n\t\t\t\tcode += \"#extension GL_EXT_draw_buffers : require\\n\";\n\t\t\t\tcode += \"#define SUPPORTS_MRT\\n\";\n\t\t\t}\n\t\t}\n\t\treturn code;\n\t}\n\tstatic dummyFragmentCode() {\n\t\treturn \"void main(void) {gl_FragColor = vec4(0.0);}\";\n\t}\n\tstatic versionCode(device) {\n\t\tif (device.isWebGPU) {\n\t\t\treturn '#version 450\\n';\n\t\t}\n\t\treturn device.isWebGL2 ? \"#version 300 es\\n\" : \"\";\n\t}\n\tstatic precisionCode(device, forcePrecision) {\n\t\tlet code = '';\n\t\tif (forcePrecision && forcePrecision !== 'highp' && forcePrecision !== 'mediump' && forcePrecision !== 'lowp') {\n\t\t\tforcePrecision = null;\n\t\t}\n\t\tif (forcePrecision) {\n\t\t\tif (forcePrecision === 'highp' && device.maxPrecision !== 'highp') {\n\t\t\t\tforcePrecision = 'mediump';\n\t\t\t}\n\t\t\tif (forcePrecision === 'mediump' && device.maxPrecision === 'lowp') {\n\t\t\t\tforcePrecision = 'lowp';\n\t\t\t}\n\t\t}\n\t\tconst precision = forcePrecision ? forcePrecision : device.precision;\n\t\tif (!device.isWebGPU) {\n\t\t\tcode = `precision ${precision} float;\\nprecision ${precision} int;`;\n\t\t\tif (device.isWebGL2) {\n\t\t\t\tcode += `precision ${precision} sampler2DShadow;\\n`;\n\t\t\t}\n\t\t} else {\n\t\t\tcode = `precision ${precision} float;\\nprecision ${precision} int;\\n`;\n\t\t}\n\t\treturn code;\n\t}\n\tstatic collectAttributes(vsCode) {\n\t\tconst attribs = {};\n\t\tlet attrs = 0;\n\t\tlet found = vsCode.indexOf(\"attribute\");\n\t\twhile (found >= 0) {\n\t\t\tif (found > 0 && vsCode[found - 1] === \"/\") break;\n\t\t\tconst endOfLine = vsCode.indexOf(';', found);\n\t\t\tconst startOfAttribName = vsCode.lastIndexOf(' ', endOfLine);\n\t\t\tconst attribName = vsCode.substring(startOfAttribName + 1, endOfLine);\n\t\t\tif (attribs[attribName]) ; else {\n\t\t\t\tconst semantic = _attrib2Semantic[attribName];\n\t\t\t\tif (semantic !== undefined) {\n\t\t\t\t\tattribs[attribName] = semantic;\n\t\t\t\t} else {\n\t\t\t\t\tattribs[attribName] = \"ATTR\" + attrs;\n\t\t\t\t\tattrs++;\n\t\t\t\t}\n\t\t\t}\n\t\t\tfound = vsCode.indexOf(\"attribute\", found + 1);\n\t\t}\n\t\treturn attribs;\n\t}\n}\n\nexport { ShaderUtils };\n", "import { GpuProfiler } from '../gpu-profiler.js';\n\nclass FrameQueriesInfo {\n\tconstructor() {\n\t\tthis.renderVersion = void 0;\n\t\tthis.queries = [];\n\t}\n\tdestroy(gl) {\n\t\tthis.queries.forEach(query => gl.deleteQuery(query));\n\t\tthis.queries = null;\n\t}\n}\nclass WebglGpuProfiler extends GpuProfiler {\n\tconstructor(device) {\n\t\tsuper();\n\t\tthis.device = void 0;\n\t\tthis.freeQueries = [];\n\t\tthis.frameQueries = [];\n\t\tthis.previousFrameQueries = [];\n\t\tthis.timings = [];\n\t\tthis.device = device;\n\t\tthis.ext = device.extDisjointTimerQuery;\n\t}\n\tdestroy() {\n\t\tthis.freeQueries.forEach(query => this.device.gl.deleteQuery(query));\n\t\tthis.frameQueries.forEach(query => this.device.gl.deleteQuery(query));\n\t\tthis.previousFrameQueries.forEach(frameQueriesInfo => frameQueriesInfo.destroy(this.device.gl));\n\t\tthis.freeQueries = null;\n\t\tthis.frameQueries = null;\n\t\tthis.previousFrameQueries = null;\n\t}\n\tloseContext() {\n\t\tsuper.loseContext();\n\t\tthis.freeQueries = [];\n\t\tthis.frameQueries = [];\n\t\tthis.previousFrameQueries = [];\n\t}\n\trestoreContext() {\n\t\tthis.ext = this.device.extDisjointTimerQuery;\n\t}\n\tgetQuery() {\n\t\tvar _this$freeQueries$pop;\n\t\treturn (_this$freeQueries$pop = this.freeQueries.pop()) != null ? _this$freeQueries$pop : this.device.gl.createQuery();\n\t}\n\tstart(name) {\n\t\tif (this.ext) {\n\t\t\tconst slot = this.getSlot(name);\n\t\t\tconst query = this.getQuery();\n\t\t\tthis.frameQueries[slot] = query;\n\t\t\tthis.device.gl.beginQuery(this.ext.TIME_ELAPSED_EXT, query);\n\t\t\treturn slot;\n\t\t}\n\t\treturn undefined;\n\t}\n\tend(slot) {\n\t\tif (slot !== undefined) {\n\t\t\tthis.device.gl.endQuery(this.ext.TIME_ELAPSED_EXT);\n\t\t}\n\t}\n\tframeStart() {\n\t\tthis.processEnableRequest();\n\t\tif (this._enabled) {\n\t\t\tthis.frameGPUMarkerSlot = this.start('GpuFrame');\n\t\t}\n\t}\n\tframeEnd() {\n\t\tif (this._enabled) {\n\t\t\tthis.end(this.frameGPUMarkerSlot);\n\t\t}\n\t}\n\trequest() {\n\t\tif (this._enabled) {\n\t\t\tconst ext = this.ext;\n\t\t\tconst gl = this.device.gl;\n\t\t\tconst renderVersion = this.device.renderVersion;\n\t\t\tconst frameQueries = this.frameQueries;\n\t\t\tif (frameQueries.length > 0) {\n\t\t\t\tthis.frameQueries = [];\n\t\t\t\tconst frameQueriesInfo = new FrameQueriesInfo();\n\t\t\t\tframeQueriesInfo.queries = frameQueries;\n\t\t\t\tframeQueriesInfo.renderVersion = renderVersion;\n\t\t\t\tthis.previousFrameQueries.push(frameQueriesInfo);\n\t\t\t}\n\t\t\tif (this.previousFrameQueries.length > 0) {\n\t\t\t\tconst previousQueriesInfo = this.previousFrameQueries[0];\n\t\t\t\tconst previousQueries = previousQueriesInfo.queries;\n\t\t\t\tconst lastQuery = previousQueries[previousQueries.length - 1];\n\t\t\t\tconst available = gl.getQueryParameter(lastQuery, gl.QUERY_RESULT_AVAILABLE);\n\t\t\t\tconst disjoint = gl.getParameter(ext.GPU_DISJOINT_EXT);\n\t\t\t\tif (available && !disjoint) {\n\t\t\t\t\tthis.previousFrameQueries.shift();\n\t\t\t\t\tconst timings = this.timings;\n\t\t\t\t\ttimings.length = 0;\n\t\t\t\t\tfor (let i = 0; i < previousQueries.length; i++) {\n\t\t\t\t\t\tconst query = previousQueries[i];\n\t\t\t\t\t\tconst duration = gl.getQueryParameter(query, gl.QUERY_RESULT);\n\t\t\t\t\t\ttimings[i] = duration * 0.000001;\n\t\t\t\t\t\tthis.freeQueries.push(query);\n\t\t\t\t\t}\n\t\t\t\t\tthis.report(previousQueriesInfo.renderVersion, timings);\n\t\t\t\t}\n\t\t\t\tif (disjoint) {\n\t\t\t\t\tthis.previousFrameQueries.forEach(frameQueriesInfo => {\n\t\t\t\t\t\tthis.report(frameQueriesInfo.renderVersion, null);\n\t\t\t\t\t\tframeQueriesInfo.destroy(gl);\n\t\t\t\t\t});\n\t\t\t\t\tthis.previousFrameQueries.length = 0;\n\t\t\t\t}\n\t\t\t}\n\t\t\tsuper.request(renderVersion);\n\t\t}\n\t}\n}\n\nexport { WebglGpuProfiler };\n", "import { math } from '../../../core/math/math.js';\nimport { platform } from '../../../core/platform.js';\nimport { Color } from '../../../core/math/color.js';\nimport { DEVICETYPE_WEBGL2, DEVICETYPE_WEBGL1, UNIFORMTYPE_BOOL, UNIFORMTYPE_INT, UNIFORMTYPE_FLOAT, UNIFORMTYPE_VEC2, UNIFORMTYPE_VEC3, UNIFORMTYPE_VEC4, UNIFORMTYPE_IVEC2, UNIFORMTYPE_IVEC3, UNIFORMTYPE_IVEC4, UNIFORMTYPE_BVEC2, UNIFORMTYPE_BVEC3, UNIFORMTYPE_BVEC4, UNIFORMTYPE_MAT2, UNIFORMTYPE_MAT3, UNIFORMTYPE_MAT4, UNIFORMTYPE_TEXTURE2D, UNIFORMTYPE_TEXTURECUBE, UNIFORMTYPE_UINT, UNIFORMTYPE_UVEC2, UNIFORMTYPE_UVEC3, UNIFORMTYPE_UVEC4, UNIFORMTYPE_TEXTURE2D_SHADOW, UNIFORMTYPE_TEXTURECUBE_SHADOW, UNIFORMTYPE_TEXTURE2D_ARRAY, UNIFORMTYPE_TEXTURE3D, UNIFORMTYPE_ITEXTURE2D, UNIFORMTYPE_UTEXTURE2D, UNIFORMTYPE_ITEXTURECUBE, UNIFORMTYPE_UTEXTURECUBE, UNIFORMTYPE_ITEXTURE3D, UNIFORMTYPE_UTEXTURE3D, UNIFORMTYPE_ITEXTURE2D_ARRAY, UNIFORMTYPE_UTEXTURE2D_ARRAY, UNIFORMTYPE_FLOATARRAY, UNIFORMTYPE_VEC2ARRAY, UNIFORMTYPE_VEC3ARRAY, UNIFORMTYPE_VEC4ARRAY, UNIFORMTYPE_INTARRAY, UNIFORMTYPE_UINTARRAY, UNIFORMTYPE_BOOLARRAY, UNIFORMTYPE_IVEC2ARRAY, UNIFORMTYPE_UVEC2ARRAY, UNIFORMTYPE_BVEC2ARRAY, UNIFORMTYPE_IVEC3ARRAY, UNIFORMTYPE_UVEC3ARRAY, UNIFORMTYPE_BVEC3ARRAY, UNIFORMTYPE_IVEC4ARRAY, UNIFORMTYPE_UVEC4ARRAY, UNIFORMTYPE_BVEC4ARRAY, UNIFORMTYPE_MAT4ARRAY, PIXELFORMAT_RGBA8, PIXELFORMAT_RGBA16F, PIXELFORMAT_RGBA32F, PIXELFORMAT_RGB8, FUNC_ALWAYS, STENCILOP_KEEP, ADDRESS_CLAMP_TO_EDGE, semanticToLocation, CLEARFLAG_COLOR, CLEARFLAG_DEPTH, CLEARFLAG_STENCIL, CULLFACE_NONE, PRIMITIVE_TRISTRIP, FILTER_NEAREST_MIPMAP_NEAREST, FILTER_NEAREST_MIPMAP_LINEAR, FILTER_NEAREST, FILTER_LINEAR_MIPMAP_NEAREST, FILTER_LINEAR_MIPMAP_LINEAR, FILTER_LINEAR } from '../constants.js';\nimport { GraphicsDevice } from '../graphics-device.js';\nimport { RenderTarget } from '../render-target.js';\nimport { Texture } from '../texture.js';\nimport { WebglVertexBuffer } from './webgl-vertex-buffer.js';\nimport { WebglIndexBuffer } from './webgl-index-buffer.js';\nimport { WebglShader } from './webgl-shader.js';\nimport { WebglTexture } from './webgl-texture.js';\nimport { WebglRenderTarget } from './webgl-render-target.js';\nimport { ShaderUtils } from '../shader-utils.js';\nimport { Shader } from '../shader.js';\nimport { BlendState } from '../blend-state.js';\nimport { DepthState } from '../depth-state.js';\nimport { StencilParameters } from '../stencil-parameters.js';\nimport { WebglGpuProfiler } from './webgl-gpu-profiler.js';\n\nconst invalidateAttachments = [];\nconst _fullScreenQuadVS = `\nattribute vec2 vertex_position;\nvarying vec2 vUv0;\nvoid main(void)\n{\n\tgl_Position = vec4(vertex_position, 0.5, 1.0);\n\tvUv0 = vertex_position.xy*0.5+0.5;\n}\n`;\nconst _precisionTest1PS = `\nvoid main(void) { \n\tgl_FragColor = vec4(2147483648.0);\n}\n`;\nconst _precisionTest2PS = `\nuniform sampler2D source;\nvec4 packFloat(float depth) {\n\tconst vec4 bit_shift = vec4(256.0 * 256.0 * 256.0, 256.0 * 256.0, 256.0, 1.0);\n\tconst vec4 bit_mask = vec4(0.0, 1.0 / 256.0, 1.0 / 256.0, 1.0 / 256.0);\n\tvec4 res = mod(depth * bit_shift * vec4(255), vec4(256) ) / vec4(255);\n\tres -= res.xxyz * bit_mask;\n\treturn res;\n}\nvoid main(void) {\n\tfloat c = texture2D(source, vec2(0.0)).r;\n\tfloat diff = abs(c - 2147483648.0) / 2147483648.0;\n\tgl_FragColor = packFloat(diff);\n}\n`;\nconst _outputTexture2D = `\nvarying vec2 vUv0;\nuniform sampler2D source;\nvoid main(void) {\n\tgl_FragColor = texture2D(source, vUv0);\n}\n`;\nfunction quadWithShader(device, target, shader) {\n\tconst oldRt = device.renderTarget;\n\tdevice.setRenderTarget(target);\n\tdevice.updateBegin();\n\tdevice.setCullMode(CULLFACE_NONE);\n\tdevice.setBlendState(BlendState.NOBLEND);\n\tdevice.setDepthState(DepthState.NODEPTH);\n\tdevice.setStencilState(null, null);\n\tdevice.setVertexBuffer(device.quadVertexBuffer, 0);\n\tdevice.setShader(shader);\n\tdevice.draw({\n\t\ttype: PRIMITIVE_TRISTRIP,\n\t\tbase: 0,\n\t\tcount: 4,\n\t\tindexed: false\n\t});\n\tdevice.updateEnd();\n\tdevice.setRenderTarget(oldRt);\n\tdevice.updateBegin();\n}\nfunction testRenderable(gl, pixelFormat) {\n\tlet result = true;\n\tconst texture = gl.createTexture();\n\tgl.bindTexture(gl.TEXTURE_2D, texture);\n\tgl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);\n\tgl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);\n\tgl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);\n\tgl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);\n\tgl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 2, 2, 0, gl.RGBA, pixelFormat, null);\n\tconst framebuffer = gl.createFramebuffer();\n\tgl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);\n\tgl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);\n\tif (gl.checkFramebufferStatus(gl.FRAMEBUFFER) !== gl.FRAMEBUFFER_COMPLETE) {\n\t\tresult = false;\n\t}\n\tgl.bindTexture(gl.TEXTURE_2D, null);\n\tgl.deleteTexture(texture);\n\tgl.bindFramebuffer(gl.FRAMEBUFFER, null);\n\tgl.deleteFramebuffer(framebuffer);\n\treturn result;\n}\nfunction testTextureHalfFloatUpdatable(gl, pixelFormat) {\n\tlet result = true;\n\tconst texture = gl.createTexture();\n\tgl.bindTexture(gl.TEXTURE_2D, texture);\n\tgl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);\n\tgl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);\n\tgl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);\n\tgl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);\n\tconst data = new Uint16Array(4 * 2 * 2);\n\tgl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 2, 2, 0, gl.RGBA, pixelFormat, data);\n\tif (gl.getError() !== gl.NO_ERROR) {\n\t\tresult = false;\n\t\tconsole.log(\"Above error related to HALF_FLOAT_OES can be ignored, it was triggered by testing half float texture support\");\n\t}\n\tgl.bindTexture(gl.TEXTURE_2D, null);\n\tgl.deleteTexture(texture);\n\treturn result;\n}\nfunction testTextureFloatHighPrecision(device) {\n\tif (!device.textureFloatRenderable) return false;\n\tconst shader1 = new Shader(device, ShaderUtils.createDefinition(device, {\n\t\tname: 'ptest1',\n\t\tvertexCode: _fullScreenQuadVS,\n\t\tfragmentCode: _precisionTest1PS\n\t}));\n\tconst shader2 = new Shader(device, ShaderUtils.createDefinition(device, {\n\t\tname: 'ptest2',\n\t\tvertexCode: _fullScreenQuadVS,\n\t\tfragmentCode: _precisionTest2PS\n\t}));\n\tconst textureOptions = {\n\t\tformat: PIXELFORMAT_RGBA32F,\n\t\twidth: 1,\n\t\theight: 1,\n\t\tmipmaps: false,\n\t\tminFilter: FILTER_NEAREST,\n\t\tmagFilter: FILTER_NEAREST,\n\t\tname: 'testFHP'\n\t};\n\tconst tex1 = new Texture(device, textureOptions);\n\tconst targ1 = new RenderTarget({\n\t\tcolorBuffer: tex1,\n\t\tdepth: false\n\t});\n\tquadWithShader(device, targ1, shader1);\n\ttextureOptions.format = PIXELFORMAT_RGBA8;\n\tconst tex2 = new Texture(device, textureOptions);\n\tconst targ2 = new RenderTarget({\n\t\tcolorBuffer: tex2,\n\t\tdepth: false\n\t});\n\tdevice.constantTexSource.setValue(tex1);\n\tquadWithShader(device, targ2, shader2);\n\tconst prevFramebuffer = device.activeFramebuffer;\n\tdevice.setFramebuffer(targ2.impl._glFrameBuffer);\n\tconst pixels = new Uint8Array(4);\n\tdevice.readPixels(0, 0, 1, 1, pixels);\n\tdevice.setFramebuffer(prevFramebuffer);\n\tconst x = pixels[0] / 255;\n\tconst y = pixels[1] / 255;\n\tconst z = pixels[2] / 255;\n\tconst w = pixels[3] / 255;\n\tconst f = x / (256 * 256 * 256) + y / (256 * 256) + z / 256 + w;\n\ttex1.destroy();\n\ttarg1.destroy();\n\ttex2.destroy();\n\ttarg2.destroy();\n\tshader1.destroy();\n\tshader2.destroy();\n\treturn f === 0;\n}\nclass WebglGraphicsDevice extends GraphicsDevice {\n\tconstructor(canvas, options = {}) {\n\t\tvar _options$antialias;\n\t\tsuper(canvas, options);\n\t\tthis.gl = void 0;\n\t\tthis._defaultFramebuffer = null;\n\t\tthis._defaultFramebufferChanged = false;\n\t\toptions = this.initOptions;\n\t\tthis.updateClientRect();\n\t\tthis.initTextureUnits();\n\t\tthis.contextLost = false;\n\t\tthis._contextLostHandler = event => {\n\t\t\tevent.preventDefault();\n\t\t\tthis.loseContext();\n\t\t\tthis.fire('devicelost');\n\t\t};\n\t\tthis._contextRestoredHandler = () => {\n\t\t\tthis.restoreContext();\n\t\t\tthis.fire('devicerestored');\n\t\t};\n\t\tconst ua = typeof navigator !== 'undefined' && navigator.userAgent;\n\t\tthis.forceDisableMultisampling = ua && ua.includes('AppleWebKit') && (ua.includes('15.4') || ua.includes('15_4'));\n\t\tif (this.forceDisableMultisampling) {\n\t\t\toptions.antialias = false;\n\t\t}\n\t\tif (platform.browserName === 'firefox' && platform.name === 'windows') {\n\t\t\tconst _ua = typeof navigator !== 'undefined' ? navigator.userAgent : '';\n\t\t\tconst match = _ua.match(/Firefox\\/(\\d+(\\.\\d+)*)/);\n\t\t\tconst firefoxVersion = match ? match[1] : null;\n\t\t\tif (firefoxVersion) {\n\t\t\t\tconst version = parseFloat(firefoxVersion);\n\t\t\t\tif (version >= 120 || version === 115) {\n\t\t\t\t\toptions.antialias = false;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tlet gl = null;\n\t\tthis.backBufferAntialias = (_options$antialias = options.antialias) != null ? _options$antialias : false;\n\t\toptions.antialias = false;\n\t\tif (options.gl) {\n\t\t\tgl = options.gl;\n\t\t} else {\n\t\t\tconst preferWebGl2 = options.preferWebGl2 !== undefined ? options.preferWebGl2 : true;\n\t\t\tconst names = preferWebGl2 ? [\"webgl2\", \"webgl\", \"experimental-webgl\"] : [\"webgl\", \"experimental-webgl\"];\n\t\t\tfor (let i = 0; i < names.length; i++) {\n\t\t\t\tgl = canvas.getContext(names[i], options);\n\t\t\t\tif (gl) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (!gl) {\n\t\t\tthrow new Error(\"WebGL not supported\");\n\t\t}\n\t\tthis.gl = gl;\n\t\tthis.isWebGL2 = typeof WebGL2RenderingContext !== 'undefined' && gl instanceof WebGL2RenderingContext;\n\t\tthis.isWebGL1 = !this.isWebGL2;\n\t\tthis._deviceType = this.isWebGL2 ? DEVICETYPE_WEBGL2 : DEVICETYPE_WEBGL1;\n\t\tthis.updateBackbufferFormat(null);\n\t\tconst isChrome = platform.browserName === 'chrome';\n\t\tconst isSafari = platform.browserName === 'safari';\n\t\tconst isMac = platform.browser && navigator.appVersion.indexOf(\"Mac\") !== -1;\n\t\tthis._tempEnableSafariTextureUnitWorkaround = isSafari;\n\t\tthis._tempMacChromeBlitFramebufferWorkaround = isMac && isChrome && !options.alpha;\n\t\tcanvas.addEventListener(\"webglcontextlost\", this._contextLostHandler, false);\n\t\tcanvas.addEventListener(\"webglcontextrestored\", this._contextRestoredHandler, false);\n\t\tthis.initializeExtensions();\n\t\tthis.initializeCapabilities();\n\t\tthis.initializeRenderState();\n\t\tthis.initializeContextCaches();\n\t\tthis.createBackbuffer(null);\n\t\tthis.supportsImageBitmap = !isSafari && typeof ImageBitmap !== 'undefined';\n\t\tthis._samplerTypes = new Set([...[gl.SAMPLER_2D, gl.SAMPLER_CUBE], ...(this.isWebGL2 ? [gl.UNSIGNED_INT_SAMPLER_2D, gl.INT_SAMPLER_2D, gl.SAMPLER_2D_SHADOW, gl.SAMPLER_CUBE_SHADOW, gl.SAMPLER_3D, gl.INT_SAMPLER_3D, gl.UNSIGNED_INT_SAMPLER_3D, gl.SAMPLER_2D_ARRAY, gl.INT_SAMPLER_2D_ARRAY, gl.UNSIGNED_INT_SAMPLER_2D_ARRAY] : [])]);\n\t\tthis.glAddress = [gl.REPEAT, gl.CLAMP_TO_EDGE, gl.MIRRORED_REPEAT];\n\t\tthis.glBlendEquation = [gl.FUNC_ADD, gl.FUNC_SUBTRACT, gl.FUNC_REVERSE_SUBTRACT, this.isWebGL2 ? gl.MIN : this.extBlendMinmax ? this.extBlendMinmax.MIN_EXT : gl.FUNC_ADD, this.isWebGL2 ? gl.MAX : this.extBlendMinmax ? this.extBlendMinmax.MAX_EXT : gl.FUNC_ADD];\n\t\tthis.glBlendFunctionColor = [gl.ZERO, gl.ONE, gl.SRC_COLOR, gl.ONE_MINUS_SRC_COLOR, gl.DST_COLOR, gl.ONE_MINUS_DST_COLOR, gl.SRC_ALPHA, gl.SRC_ALPHA_SATURATE, gl.ONE_MINUS_SRC_ALPHA, gl.DST_ALPHA, gl.ONE_MINUS_DST_ALPHA, gl.CONSTANT_COLOR, gl.ONE_MINUS_CONSTANT_COLOR];\n\t\tthis.glBlendFunctionAlpha = [gl.ZERO, gl.ONE, gl.SRC_COLOR, gl.ONE_MINUS_SRC_COLOR, gl.DST_COLOR, gl.ONE_MINUS_DST_COLOR, gl.SRC_ALPHA, gl.SRC_ALPHA_SATURATE, gl.ONE_MINUS_SRC_ALPHA, gl.DST_ALPHA, gl.ONE_MINUS_DST_ALPHA, gl.CONSTANT_ALPHA, gl.ONE_MINUS_CONSTANT_ALPHA];\n\t\tthis.glComparison = [gl.NEVER, gl.LESS, gl.EQUAL, gl.LEQUAL, gl.GREATER, gl.NOTEQUAL, gl.GEQUAL, gl.ALWAYS];\n\t\tthis.glStencilOp = [gl.KEEP, gl.ZERO, gl.REPLACE, gl.INCR, gl.INCR_WRAP, gl.DECR, gl.DECR_WRAP, gl.INVERT];\n\t\tthis.glClearFlag = [0, gl.COLOR_BUFFER_BIT, gl.DEPTH_BUFFER_BIT, gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT, gl.STENCIL_BUFFER_BIT, gl.STENCIL_BUFFER_BIT | gl.COLOR_BUFFER_BIT, gl.STENCIL_BUFFER_BIT | gl.DEPTH_BUFFER_BIT, gl.STENCIL_BUFFER_BIT | gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT];\n\t\tthis.glCull = [0, gl.BACK, gl.FRONT, gl.FRONT_AND_BACK];\n\t\tthis.glFilter = [gl.NEAREST, gl.LINEAR, gl.NEAREST_MIPMAP_NEAREST, gl.NEAREST_MIPMAP_LINEAR, gl.LINEAR_MIPMAP_NEAREST, gl.LINEAR_MIPMAP_LINEAR];\n\t\tthis.glPrimitive = [gl.POINTS, gl.LINES, gl.LINE_LOOP, gl.LINE_STRIP, gl.TRIANGLES, gl.TRIANGLE_STRIP, gl.TRIANGLE_FAN];\n\t\tthis.glType = [gl.BYTE, gl.UNSIGNED_BYTE, gl.SHORT, gl.UNSIGNED_SHORT, gl.INT, gl.UNSIGNED_INT, gl.FLOAT, gl.HALF_FLOAT];\n\t\tthis.pcUniformType = {};\n\t\tthis.pcUniformType[gl.BOOL] = UNIFORMTYPE_BOOL;\n\t\tthis.pcUniformType[gl.INT] = UNIFORMTYPE_INT;\n\t\tthis.pcUniformType[gl.FLOAT] = UNIFORMTYPE_FLOAT;\n\t\tthis.pcUniformType[gl.FLOAT_VEC2] = UNIFORMTYPE_VEC2;\n\t\tthis.pcUniformType[gl.FLOAT_VEC3] = UNIFORMTYPE_VEC3;\n\t\tthis.pcUniformType[gl.FLOAT_VEC4] = UNIFORMTYPE_VEC4;\n\t\tthis.pcUniformType[gl.INT_VEC2] = UNIFORMTYPE_IVEC2;\n\t\tthis.pcUniformType[gl.INT_VEC3] = UNIFORMTYPE_IVEC3;\n\t\tthis.pcUniformType[gl.INT_VEC4] = UNIFORMTYPE_IVEC4;\n\t\tthis.pcUniformType[gl.BOOL_VEC2] = UNIFORMTYPE_BVEC2;\n\t\tthis.pcUniformType[gl.BOOL_VEC3] = UNIFORMTYPE_BVEC3;\n\t\tthis.pcUniformType[gl.BOOL_VEC4] = UNIFORMTYPE_BVEC4;\n\t\tthis.pcUniformType[gl.FLOAT_MAT2] = UNIFORMTYPE_MAT2;\n\t\tthis.pcUniformType[gl.FLOAT_MAT3] = UNIFORMTYPE_MAT3;\n\t\tthis.pcUniformType[gl.FLOAT_MAT4] = UNIFORMTYPE_MAT4;\n\t\tthis.pcUniformType[gl.SAMPLER_2D] = UNIFORMTYPE_TEXTURE2D;\n\t\tthis.pcUniformType[gl.SAMPLER_CUBE] = UNIFORMTYPE_TEXTURECUBE;\n\t\tthis.pcUniformType[gl.UNSIGNED_INT] = UNIFORMTYPE_UINT;\n\t\tthis.pcUniformType[gl.UNSIGNED_INT_VEC2] = UNIFORMTYPE_UVEC2;\n\t\tthis.pcUniformType[gl.UNSIGNED_INT_VEC3] = UNIFORMTYPE_UVEC3;\n\t\tthis.pcUniformType[gl.UNSIGNED_INT_VEC4] = UNIFORMTYPE_UVEC4;\n\t\tif (this.isWebGL2) {\n\t\t\tthis.pcUniformType[gl.SAMPLER_2D_SHADOW] = UNIFORMTYPE_TEXTURE2D_SHADOW;\n\t\t\tthis.pcUniformType[gl.SAMPLER_CUBE_SHADOW] = UNIFORMTYPE_TEXTURECUBE_SHADOW;\n\t\t\tthis.pcUniformType[gl.SAMPLER_2D_ARRAY] = UNIFORMTYPE_TEXTURE2D_ARRAY;\n\t\t\tthis.pcUniformType[gl.SAMPLER_3D] = UNIFORMTYPE_TEXTURE3D;\n\t\t\tthis.pcUniformType[gl.INT_SAMPLER_2D] = UNIFORMTYPE_ITEXTURE2D;\n\t\t\tthis.pcUniformType[gl.UNSIGNED_INT_SAMPLER_2D] = UNIFORMTYPE_UTEXTURE2D;\n\t\t\tthis.pcUniformType[gl.INT_SAMPLER_CUBE] = UNIFORMTYPE_ITEXTURECUBE;\n\t\t\tthis.pcUniformType[gl.UNSIGNED_INT_SAMPLER_2D] = UNIFORMTYPE_UTEXTURECUBE;\n\t\t\tthis.pcUniformType[gl.INT_SAMPLER_3D] = UNIFORMTYPE_ITEXTURE3D;\n\t\t\tthis.pcUniformType[gl.UNSIGNED_INT_SAMPLER_3D] = UNIFORMTYPE_UTEXTURE3D;\n\t\t\tthis.pcUniformType[gl.INT_SAMPLER_2D_ARRAY] = UNIFORMTYPE_ITEXTURE2D_ARRAY;\n\t\t\tthis.pcUniformType[gl.UNSIGNED_INT_SAMPLER_2D_ARRAY] = UNIFORMTYPE_UTEXTURE2D_ARRAY;\n\t\t}\n\t\tthis.targetToSlot = {};\n\t\tthis.targetToSlot[gl.TEXTURE_2D] = 0;\n\t\tthis.targetToSlot[gl.TEXTURE_CUBE_MAP] = 1;\n\t\tthis.targetToSlot[gl.TEXTURE_3D] = 2;\n\t\tlet scopeX, scopeY, scopeZ, scopeW;\n\t\tlet uniformValue;\n\t\tthis.commitFunction = [];\n\t\tthis.commitFunction[UNIFORMTYPE_BOOL] = function (uniform, value) {\n\t\t\tif (uniform.value !== value) {\n\t\t\t\tgl.uniform1i(uniform.locationId, value);\n\t\t\t\tuniform.value = value;\n\t\t\t}\n\t\t};\n\t\tthis.commitFunction[UNIFORMTYPE_INT] = this.commitFunction[UNIFORMTYPE_BOOL];\n\t\tthis.commitFunction[UNIFORMTYPE_FLOAT] = function (uniform, value) {\n\t\t\tif (uniform.value !== value) {\n\t\t\t\tgl.uniform1f(uniform.locationId, value);\n\t\t\t\tuniform.value = value;\n\t\t\t}\n\t\t};\n\t\tthis.commitFunction[UNIFORMTYPE_VEC2] = function (uniform, value) {\n\t\t\tuniformValue = uniform.value;\n\t\t\tscopeX = value[0];\n\t\t\tscopeY = value[1];\n\t\t\tif (uniformValue[0] !== scopeX || uniformValue[1] !== scopeY) {\n\t\t\t\tgl.uniform2fv(uniform.locationId, value);\n\t\t\t\tuniformValue[0] = scopeX;\n\t\t\t\tuniformValue[1] = scopeY;\n\t\t\t}\n\t\t};\n\t\tthis.commitFunction[UNIFORMTYPE_VEC3] = function (uniform, value) {\n\t\t\tuniformValue = uniform.value;\n\t\t\tscopeX = value[0];\n\t\t\tscopeY = value[1];\n\t\t\tscopeZ = value[2];\n\t\t\tif (uniformValue[0] !== scopeX || uniformValue[1] !== scopeY || uniformValue[2] !== scopeZ) {\n\t\t\t\tgl.uniform3fv(uniform.locationId, value);\n\t\t\t\tuniformValue[0] = scopeX;\n\t\t\t\tuniformValue[1] = scopeY;\n\t\t\t\tuniformValue[2] = scopeZ;\n\t\t\t}\n\t\t};\n\t\tthis.commitFunction[UNIFORMTYPE_VEC4] = function (uniform, value) {\n\t\t\tuniformValue = uniform.value;\n\t\t\tscopeX = value[0];\n\t\t\tscopeY = value[1];\n\t\t\tscopeZ = value[2];\n\t\t\tscopeW = value[3];\n\t\t\tif (uniformValue[0] !== scopeX || uniformValue[1] !== scopeY || uniformValue[2] !== scopeZ || uniformValue[3] !== scopeW) {\n\t\t\t\tgl.uniform4fv(uniform.locationId, value);\n\t\t\t\tuniformValue[0] = scopeX;\n\t\t\t\tuniformValue[1] = scopeY;\n\t\t\t\tuniformValue[2] = scopeZ;\n\t\t\t\tuniformValue[3] = scopeW;\n\t\t\t}\n\t\t};\n\t\tthis.commitFunction[UNIFORMTYPE_IVEC2] = function (uniform, value) {\n\t\t\tuniformValue = uniform.value;\n\t\t\tscopeX = value[0];\n\t\t\tscopeY = value[1];\n\t\t\tif (uniformValue[0] !== scopeX || uniformValue[1] !== scopeY) {\n\t\t\t\tgl.uniform2iv(uniform.locationId, value);\n\t\t\t\tuniformValue[0] = scopeX;\n\t\t\t\tuniformValue[1] = scopeY;\n\t\t\t}\n\t\t};\n\t\tthis.commitFunction[UNIFORMTYPE_BVEC2] = this.commitFunction[UNIFORMTYPE_IVEC2];\n\t\tthis.commitFunction[UNIFORMTYPE_IVEC3] = function (uniform, value) {\n\t\t\tuniformValue = uniform.value;\n\t\t\tscopeX = value[0];\n\t\t\tscopeY = value[1];\n\t\t\tscopeZ = value[2];\n\t\t\tif (uniformValue[0] !== scopeX || uniformValue[1] !== scopeY || uniformValue[2] !== scopeZ) {\n\t\t\t\tgl.uniform3iv(uniform.locationId, value);\n\t\t\t\tuniformValue[0] = scopeX;\n\t\t\t\tuniformValue[1] = scopeY;\n\t\t\t\tuniformValue[2] = scopeZ;\n\t\t\t}\n\t\t};\n\t\tthis.commitFunction[UNIFORMTYPE_BVEC3] = this.commitFunction[UNIFORMTYPE_IVEC3];\n\t\tthis.commitFunction[UNIFORMTYPE_IVEC4] = function (uniform, value) {\n\t\t\tuniformValue = uniform.value;\n\t\t\tscopeX = value[0];\n\t\t\tscopeY = value[1];\n\t\t\tscopeZ = value[2];\n\t\t\tscopeW = value[3];\n\t\t\tif (uniformValue[0] !== scopeX || uniformValue[1] !== scopeY || uniformValue[2] !== scopeZ || uniformValue[3] !== scopeW) {\n\t\t\t\tgl.uniform4iv(uniform.locationId, value);\n\t\t\t\tuniformValue[0] = scopeX;\n\t\t\t\tuniformValue[1] = scopeY;\n\t\t\t\tuniformValue[2] = scopeZ;\n\t\t\t\tuniformValue[3] = scopeW;\n\t\t\t}\n\t\t};\n\t\tthis.commitFunction[UNIFORMTYPE_BVEC4] = this.commitFunction[UNIFORMTYPE_IVEC4];\n\t\tthis.commitFunction[UNIFORMTYPE_MAT2] = function (uniform, value) {\n\t\t\tgl.uniformMatrix2fv(uniform.locationId, false, value);\n\t\t};\n\t\tthis.commitFunction[UNIFORMTYPE_MAT3] = function (uniform, value) {\n\t\t\tgl.uniformMatrix3fv(uniform.locationId, false, value);\n\t\t};\n\t\tthis.commitFunction[UNIFORMTYPE_MAT4] = function (uniform, value) {\n\t\t\tgl.uniformMatrix4fv(uniform.locationId, false, value);\n\t\t};\n\t\tthis.commitFunction[UNIFORMTYPE_FLOATARRAY] = function (uniform, value) {\n\t\t\tgl.uniform1fv(uniform.locationId, value);\n\t\t};\n\t\tthis.commitFunction[UNIFORMTYPE_VEC2ARRAY] = function (uniform, value) {\n\t\t\tgl.uniform2fv(uniform.locationId, value);\n\t\t};\n\t\tthis.commitFunction[UNIFORMTYPE_VEC3ARRAY] = function (uniform, value) {\n\t\t\tgl.uniform3fv(uniform.locationId, value);\n\t\t};\n\t\tthis.commitFunction[UNIFORMTYPE_VEC4ARRAY] = function (uniform, value) {\n\t\t\tgl.uniform4fv(uniform.locationId, value);\n\t\t};\n\t\tthis.commitFunction[UNIFORMTYPE_UINT] = function (uniform, value) {\n\t\t\tif (uniform.value !== value) {\n\t\t\t\tgl.uniform1ui(uniform.locationId, value);\n\t\t\t\tuniform.value = value;\n\t\t\t}\n\t\t};\n\t\tthis.commitFunction[UNIFORMTYPE_UVEC2] = function (uniform, value) {\n\t\t\tuniformValue = uniform.value;\n\t\t\tscopeX = value[0];\n\t\t\tscopeY = value[1];\n\t\t\tif (uniformValue[0] !== scopeX || uniformValue[1] !== scopeY) {\n\t\t\t\tgl.uniform2uiv(uniform.locationId, value);\n\t\t\t\tuniformValue[0] = scopeX;\n\t\t\t\tuniformValue[1] = scopeY;\n\t\t\t}\n\t\t};\n\t\tthis.commitFunction[UNIFORMTYPE_UVEC3] = function (uniform, value) {\n\t\t\tuniformValue = uniform.value;\n\t\t\tscopeX = value[0];\n\t\t\tscopeY = value[1];\n\t\t\tscopeZ = value[2];\n\t\t\tif (uniformValue[0] !== scopeX || uniformValue[1] !== scopeY || uniformValue[2] !== scopeZ) {\n\t\t\t\tgl.uniform3uiv(uniform.locationId, value);\n\t\t\t\tuniformValue[0] = scopeX;\n\t\t\t\tuniformValue[1] = scopeY;\n\t\t\t\tuniformValue[2] = scopeZ;\n\t\t\t}\n\t\t};\n\t\tthis.commitFunction[UNIFORMTYPE_UVEC4] = function (uniform, value) {\n\t\t\tuniformValue = uniform.value;\n\t\t\tscopeX = value[0];\n\t\t\tscopeY = value[1];\n\t\t\tscopeZ = value[2];\n\t\t\tscopeW = value[3];\n\t\t\tif (uniformValue[0] !== scopeX || uniformValue[1] !== scopeY || uniformValue[2] !== scopeZ || uniformValue[3] !== scopeW) {\n\t\t\t\tgl.uniform4uiv(uniform.locationId, value);\n\t\t\t\tuniformValue[0] = scopeX;\n\t\t\t\tuniformValue[1] = scopeY;\n\t\t\t\tuniformValue[2] = scopeZ;\n\t\t\t\tuniformValue[3] = scopeW;\n\t\t\t}\n\t\t};\n\t\tthis.commitFunction[UNIFORMTYPE_INTARRAY] = function (uniform, value) {\n\t\t\tgl.uniform1iv(uniform.locationId, value);\n\t\t};\n\t\tthis.commitFunction[UNIFORMTYPE_UINTARRAY] = function (uniform, value) {\n\t\t\tgl.uniform1uiv(uniform.locationId, value);\n\t\t};\n\t\tthis.commitFunction[UNIFORMTYPE_BOOLARRAY] = this.commitFunction[UNIFORMTYPE_INTARRAY];\n\t\tthis.commitFunction[UNIFORMTYPE_IVEC2ARRAY] = function (uniform, value) {\n\t\t\tgl.uniform2iv(uniform.locationId, value);\n\t\t};\n\t\tthis.commitFunction[UNIFORMTYPE_UVEC2ARRAY] = function (uniform, value) {\n\t\t\tgl.uniform2uiv(uniform.locationId, value);\n\t\t};\n\t\tthis.commitFunction[UNIFORMTYPE_BVEC2ARRAY] = this.commitFunction[UNIFORMTYPE_IVEC2ARRAY];\n\t\tthis.commitFunction[UNIFORMTYPE_IVEC3ARRAY] = function (uniform, value) {\n\t\t\tgl.uniform3iv(uniform.locationId, value);\n\t\t};\n\t\tthis.commitFunction[UNIFORMTYPE_UVEC3ARRAY] = function (uniform, value) {\n\t\t\tgl.uniform3uiv(uniform.locationId, value);\n\t\t};\n\t\tthis.commitFunction[UNIFORMTYPE_BVEC3ARRAY] = this.commitFunction[UNIFORMTYPE_IVEC3ARRAY];\n\t\tthis.commitFunction[UNIFORMTYPE_IVEC4ARRAY] = function (uniform, value) {\n\t\t\tgl.uniform4iv(uniform.locationId, value);\n\t\t};\n\t\tthis.commitFunction[UNIFORMTYPE_UVEC4ARRAY] = function (uniform, value) {\n\t\t\tgl.uniform4uiv(uniform.locationId, value);\n\t\t};\n\t\tthis.commitFunction[UNIFORMTYPE_BVEC4ARRAY] = this.commitFunction[UNIFORMTYPE_IVEC4ARRAY];\n\t\tthis.commitFunction[UNIFORMTYPE_MAT4ARRAY] = function (uniform, value) {\n\t\t\tgl.uniformMatrix4fv(uniform.locationId, false, value);\n\t\t};\n\t\tthis.supportsBoneTextures = this.extTextureFloat && this.maxVertexTextures > 0;\n\t\tlet numUniforms = this.vertexUniformsCount;\n\t\tnumUniforms -= 4 * 4;\n\t\tnumUniforms -= 8;\n\t\tnumUniforms -= 1;\n\t\tnumUniforms -= 4 * 4;\n\t\tthis.boneLimit = Math.floor(numUniforms / 3);\n\t\tthis.boneLimit = Math.min(this.boneLimit, 128);\n\t\tthis.constantTexSource = this.scope.resolve(\"source\");\n\t\tif (this.extTextureFloat) {\n\t\t\tif (this.isWebGL2) {\n\t\t\t\tthis.textureFloatRenderable = !!this.extColorBufferFloat;\n\t\t\t} else {\n\t\t\t\tthis.textureFloatRenderable = testRenderable(gl, gl.FLOAT);\n\t\t\t}\n\t\t} else {\n\t\t\tthis.textureFloatRenderable = false;\n\t\t}\n\t\tif (this.extColorBufferHalfFloat) {\n\t\t\tthis.textureHalfFloatRenderable = !!this.extColorBufferHalfFloat;\n\t\t} else if (this.extTextureHalfFloat) {\n\t\t\tif (this.isWebGL2) {\n\t\t\t\tthis.textureHalfFloatRenderable = !!this.extColorBufferFloat;\n\t\t\t} else {\n\t\t\t\tthis.textureHalfFloatRenderable = testRenderable(gl, this.extTextureHalfFloat.HALF_FLOAT_OES);\n\t\t\t}\n\t\t} else {\n\t\t\tthis.textureHalfFloatRenderable = false;\n\t\t}\n\t\tthis.supportsMorphTargetTexturesCore = this.maxPrecision === \"highp\" && this.maxVertexTextures >= 2;\n\t\tthis.supportsDepthShadow = this.isWebGL2;\n\t\tthis._textureFloatHighPrecision = undefined;\n\t\tthis._textureHalfFloatUpdatable = undefined;\n\t\tthis.areaLightLutFormat = PIXELFORMAT_RGBA8;\n\t\tif (this.extTextureHalfFloat && this.textureHalfFloatUpdatable && this.extTextureHalfFloatLinear) {\n\t\t\tthis.areaLightLutFormat = PIXELFORMAT_RGBA16F;\n\t\t} else if (this.extTextureFloat && this.extTextureFloatLinear) {\n\t\t\tthis.areaLightLutFormat = PIXELFORMAT_RGBA32F;\n\t\t}\n\t\tthis.postInit();\n\t}\n\tpostInit() {\n\t\tsuper.postInit();\n\t\tthis.gpuProfiler = new WebglGpuProfiler(this);\n\t}\n\tdestroy() {\n\t\tsuper.destroy();\n\t\tconst gl = this.gl;\n\t\tif (this.isWebGL2 && this.feedback) {\n\t\t\tgl.deleteTransformFeedback(this.feedback);\n\t\t}\n\t\tthis.clearVertexArrayObjectCache();\n\t\tthis.canvas.removeEventListener('webglcontextlost', this._contextLostHandler, false);\n\t\tthis.canvas.removeEventListener('webglcontextrestored', this._contextRestoredHandler, false);\n\t\tthis._contextLostHandler = null;\n\t\tthis._contextRestoredHandler = null;\n\t\tthis.gl = null;\n\t\tsuper.postDestroy();\n\t}\n\tcreateBackbuffer(frameBuffer) {\n\t\tthis.supportsStencil = this.initOptions.stencil;\n\t\tthis.backBuffer = new RenderTarget({\n\t\t\tname: 'WebglFramebuffer',\n\t\t\tgraphicsDevice: this,\n\t\t\tdepth: this.initOptions.depth,\n\t\t\tstencil: this.supportsStencil,\n\t\t\tsamples: this.samples\n\t\t});\n\t\tthis.backBuffer.impl.suppliedColorFramebuffer = frameBuffer;\n\t}\n\tupdateBackbufferFormat(framebuffer) {\n\t\tconst gl = this.gl;\n\t\tgl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);\n\t\tconst alphaBits = this.gl.getParameter(this.gl.ALPHA_BITS);\n\t\tthis.backBufferFormat = alphaBits ? PIXELFORMAT_RGBA8 : PIXELFORMAT_RGB8;\n\t}\n\tupdateBackbuffer() {\n\t\tconst resolutionChanged = this.canvas.width !== this.backBufferSize.x || this.canvas.height !== this.backBufferSize.y;\n\t\tif (this._defaultFramebufferChanged || resolutionChanged) {\n\t\t\tif (this._defaultFramebufferChanged) {\n\t\t\t\tthis.updateBackbufferFormat(this._defaultFramebuffer);\n\t\t\t}\n\t\t\tthis._defaultFramebufferChanged = false;\n\t\t\tthis.backBufferSize.set(this.canvas.width, this.canvas.height);\n\t\t\tthis.backBuffer.destroy();\n\t\t\tthis.createBackbuffer(this._defaultFramebuffer);\n\t\t}\n\t}\n\tcreateVertexBufferImpl(vertexBuffer, format) {\n\t\treturn new WebglVertexBuffer();\n\t}\n\tcreateIndexBufferImpl(indexBuffer) {\n\t\treturn new WebglIndexBuffer(indexBuffer);\n\t}\n\tcreateShaderImpl(shader) {\n\t\treturn new WebglShader(shader);\n\t}\n\tcreateTextureImpl(texture) {\n\t\treturn new WebglTexture();\n\t}\n\tcreateRenderTargetImpl(renderTarget) {\n\t\treturn new WebglRenderTarget();\n\t}\n\tgetPrecision() {\n\t\tconst gl = this.gl;\n\t\tlet precision = \"highp\";\n\t\tif (gl.getShaderPrecisionFormat) {\n\t\t\tconst vertexShaderPrecisionHighpFloat = gl.getShaderPrecisionFormat(gl.VERTEX_SHADER, gl.HIGH_FLOAT);\n\t\t\tconst vertexShaderPrecisionMediumpFloat = gl.getShaderPrecisionFormat(gl.VERTEX_SHADER, gl.MEDIUM_FLOAT);\n\t\t\tconst fragmentShaderPrecisionHighpFloat = gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER, gl.HIGH_FLOAT);\n\t\t\tconst fragmentShaderPrecisionMediumpFloat = gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER, gl.MEDIUM_FLOAT);\n\t\t\tif (vertexShaderPrecisionHighpFloat && vertexShaderPrecisionMediumpFloat && fragmentShaderPrecisionHighpFloat && fragmentShaderPrecisionMediumpFloat) {\n\t\t\t\tconst highpAvailable = vertexShaderPrecisionHighpFloat.precision > 0 && fragmentShaderPrecisionHighpFloat.precision > 0;\n\t\t\t\tconst mediumpAvailable = vertexShaderPrecisionMediumpFloat.precision > 0 && fragmentShaderPrecisionMediumpFloat.precision > 0;\n\t\t\t\tif (!highpAvailable) {\n\t\t\t\t\tif (mediumpAvailable) {\n\t\t\t\t\t\tprecision = \"mediump\";\n\t\t\t\t\t} else {\n\t\t\t\t\t\tprecision = \"lowp\";\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn precision;\n\t}\n\tgetExtension() {\n\t\tfor (let i = 0; i < arguments.length; i++) {\n\t\t\tif (this.supportedExtensions.indexOf(arguments[i]) !== -1) {\n\t\t\t\treturn this.gl.getExtension(arguments[i]);\n\t\t\t}\n\t\t}\n\t\treturn null;\n\t}\n\tget extDisjointTimerQuery() {\n\t\tif (!this._extDisjointTimerQuery) {\n\t\t\tif (this.isWebGL2) {\n\t\t\t\tthis._extDisjointTimerQuery = this.getExtension('EXT_disjoint_timer_query_webgl2', 'EXT_disjoint_timer_query');\n\t\t\t}\n\t\t}\n\t\treturn this._extDisjointTimerQuery;\n\t}\n\tinitializeExtensions() {\n\t\tvar _gl$getSupportedExten;\n\t\tconst gl = this.gl;\n\t\tthis.supportedExtensions = (_gl$getSupportedExten = gl.getSupportedExtensions()) != null ? _gl$getSupportedExten : [];\n\t\tthis._extDisjointTimerQuery = null;\n\t\tif (this.isWebGL2) {\n\t\t\tthis.extBlendMinmax = true;\n\t\t\tthis.extDrawBuffers = true;\n\t\t\tthis.drawBuffers = gl.drawBuffers.bind(gl);\n\t\t\tthis.extInstancing = true;\n\t\t\tthis.extStandardDerivatives = true;\n\t\t\tthis.extTextureFloat = true;\n\t\t\tthis.extTextureHalfFloat = true;\n\t\t\tthis.textureHalfFloatFilterable = true;\n\t\t\tthis.extTextureLod = true;\n\t\t\tthis.extUintElement = true;\n\t\t\tthis.extVertexArrayObject = true;\n\t\t\tthis.extColorBufferFloat = this.getExtension('EXT_color_buffer_float');\n\t\t\tthis.extDepthTexture = true;\n\t\t\tthis.textureRG11B10Renderable = true;\n\t\t} else {\n\t\t\tvar _this$extDrawBuffers;\n\t\t\tthis.extBlendMinmax = this.getExtension(\"EXT_blend_minmax\");\n\t\t\tthis.extDrawBuffers = this.getExtension('WEBGL_draw_buffers');\n\t\t\tthis.extInstancing = this.getExtension(\"ANGLE_instanced_arrays\");\n\t\t\tthis.drawBuffers = (_this$extDrawBuffers = this.extDrawBuffers) == null ? void 0 : _this$extDrawBuffers.drawBuffersWEBGL.bind(this.extDrawBuffers);\n\t\t\tif (this.extInstancing) {\n\t\t\t\tconst ext = this.extInstancing;\n\t\t\t\tgl.drawArraysInstanced = ext.drawArraysInstancedANGLE.bind(ext);\n\t\t\t\tgl.drawElementsInstanced = ext.drawElementsInstancedANGLE.bind(ext);\n\t\t\t\tgl.vertexAttribDivisor = ext.vertexAttribDivisorANGLE.bind(ext);\n\t\t\t}\n\t\t\tthis.extStandardDerivatives = this.getExtension(\"OES_standard_derivatives\");\n\t\t\tthis.extTextureFloat = this.getExtension(\"OES_texture_float\");\n\t\t\tthis.extTextureLod = this.getExtension('EXT_shader_texture_lod');\n\t\t\tthis.extUintElement = this.getExtension(\"OES_element_index_uint\");\n\t\t\tthis.extVertexArrayObject = this.getExtension(\"OES_vertex_array_object\");\n\t\t\tif (this.extVertexArrayObject) {\n\t\t\t\tconst ext = this.extVertexArrayObject;\n\t\t\t\tgl.createVertexArray = ext.createVertexArrayOES.bind(ext);\n\t\t\t\tgl.deleteVertexArray = ext.deleteVertexArrayOES.bind(ext);\n\t\t\t\tgl.isVertexArray = ext.isVertexArrayOES.bind(ext);\n\t\t\t\tgl.bindVertexArray = ext.bindVertexArrayOES.bind(ext);\n\t\t\t}\n\t\t\tthis.extColorBufferFloat = null;\n\t\t\tthis.extDepthTexture = gl.getExtension('WEBGL_depth_texture');\n\t\t\tthis.extTextureHalfFloat = this.getExtension(\"OES_texture_half_float\");\n\t\t\tthis.extTextureHalfFloatLinear = this.getExtension(\"OES_texture_half_float_linear\");\n\t\t\tthis.textureHalfFloatFilterable = !!this.extTextureHalfFloatLinear;\n\t\t}\n\t\tthis.extDebugRendererInfo = this.getExtension('WEBGL_debug_renderer_info');\n\t\tthis.extTextureFloatLinear = this.getExtension(\"OES_texture_float_linear\");\n\t\tthis.textureFloatFilterable = !!this.extTextureFloatLinear;\n\t\tthis.extFloatBlend = this.getExtension(\"EXT_float_blend\");\n\t\tthis.extTextureFilterAnisotropic = this.getExtension('EXT_texture_filter_anisotropic', 'WEBKIT_EXT_texture_filter_anisotropic');\n\t\tthis.extCompressedTextureETC1 = this.getExtension('WEBGL_compressed_texture_etc1');\n\t\tthis.extCompressedTextureETC = this.getExtension('WEBGL_compressed_texture_etc');\n\t\tthis.extCompressedTexturePVRTC = this.getExtension('WEBGL_compressed_texture_pvrtc', 'WEBKIT_WEBGL_compressed_texture_pvrtc');\n\t\tthis.extCompressedTextureS3TC = this.getExtension('WEBGL_compressed_texture_s3tc', 'WEBKIT_WEBGL_compressed_texture_s3tc');\n\t\tthis.extCompressedTextureATC = this.getExtension('WEBGL_compressed_texture_atc');\n\t\tthis.extCompressedTextureASTC = this.getExtension('WEBGL_compressed_texture_astc');\n\t\tthis.extParallelShaderCompile = this.getExtension('KHR_parallel_shader_compile');\n\t\tthis.extColorBufferHalfFloat = this.getExtension(\"EXT_color_buffer_half_float\");\n\t}\n\tinitializeCapabilities() {\n\t\tvar _contextAttribs$antia, _contextAttribs$stenc;\n\t\tconst gl = this.gl;\n\t\tlet ext;\n\t\tconst userAgent = typeof navigator !== 'undefined' ? navigator.userAgent : \"\";\n\t\tthis.maxPrecision = this.precision = this.getPrecision();\n\t\tconst contextAttribs = gl.getContextAttributes();\n\t\tthis.supportsMsaa = (_contextAttribs$antia = contextAttribs == null ? void 0 : contextAttribs.antialias) != null ? _contextAttribs$antia : false;\n\t\tthis.supportsStencil = (_contextAttribs$stenc = contextAttribs == null ? void 0 : contextAttribs.stencil) != null ? _contextAttribs$stenc : false;\n\t\tthis.supportsInstancing = !!this.extInstancing;\n\t\tthis.maxTextureSize = gl.getParameter(gl.MAX_TEXTURE_SIZE);\n\t\tthis.maxCubeMapSize = gl.getParameter(gl.MAX_CUBE_MAP_TEXTURE_SIZE);\n\t\tthis.maxRenderBufferSize = gl.getParameter(gl.MAX_RENDERBUFFER_SIZE);\n\t\tthis.maxTextures = gl.getParameter(gl.MAX_TEXTURE_IMAGE_UNITS);\n\t\tthis.maxCombinedTextures = gl.getParameter(gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS);\n\t\tthis.maxVertexTextures = gl.getParameter(gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS);\n\t\tthis.vertexUniformsCount = gl.getParameter(gl.MAX_VERTEX_UNIFORM_VECTORS);\n\t\tthis.fragmentUniformsCount = gl.getParameter(gl.MAX_FRAGMENT_UNIFORM_VECTORS);\n\t\tif (this.isWebGL2) {\n\t\t\tthis.maxDrawBuffers = gl.getParameter(gl.MAX_DRAW_BUFFERS);\n\t\t\tthis.maxColorAttachments = gl.getParameter(gl.MAX_COLOR_ATTACHMENTS);\n\t\t\tthis.maxVolumeSize = gl.getParameter(gl.MAX_3D_TEXTURE_SIZE);\n\t\t\tthis.supportsMrt = true;\n\t\t\tthis.supportsVolumeTextures = true;\n\t\t} else {\n\t\t\text = this.extDrawBuffers;\n\t\t\tthis.supportsMrt = !!ext;\n\t\t\tthis.maxDrawBuffers = ext ? gl.getParameter(ext.MAX_DRAW_BUFFERS_WEBGL) : 1;\n\t\t\tthis.maxColorAttachments = ext ? gl.getParameter(ext.MAX_COLOR_ATTACHMENTS_WEBGL) : 1;\n\t\t\tthis.maxVolumeSize = 1;\n\t\t}\n\t\text = this.extDebugRendererInfo;\n\t\tthis.unmaskedRenderer = ext ? gl.getParameter(ext.UNMASKED_RENDERER_WEBGL) : '';\n\t\tthis.unmaskedVendor = ext ? gl.getParameter(ext.UNMASKED_VENDOR_WEBGL) : '';\n\t\tconst maliRendererRegex = /\\bMali-G52+/;\n\t\tconst samsungModelRegex = /SM-[a-zA-Z0-9]+/;\n\t\tthis.supportsGpuParticles = !(this.unmaskedVendor === 'ARM' && userAgent.match(samsungModelRegex)) && !this.unmaskedRenderer.match(maliRendererRegex);\n\t\text = this.extTextureFilterAnisotropic;\n\t\tthis.maxAnisotropy = ext ? gl.getParameter(ext.MAX_TEXTURE_MAX_ANISOTROPY_EXT) : 1;\n\t\tconst antialiasSupported = this.isWebGL2 && !this.forceDisableMultisampling;\n\t\tthis.maxSamples = antialiasSupported ? gl.getParameter(gl.MAX_SAMPLES) : 1;\n\t\tthis.maxSamples = Math.min(this.maxSamples, 4);\n\t\tthis.samples = antialiasSupported && this.backBufferAntialias ? this.maxSamples : 1;\n\t\tthis.supportsAreaLights = this.isWebGL2 || !platform.android;\n\t\tthis.supportsTextureFetch = this.isWebGL2;\n\t\tif (this.maxTextures <= 8) {\n\t\t\tthis.supportsAreaLights = false;\n\t\t}\n\t}\n\tinitializeRenderState() {\n\t\tsuper.initializeRenderState();\n\t\tconst gl = this.gl;\n\t\tgl.disable(gl.BLEND);\n\t\tgl.blendFunc(gl.ONE, gl.ZERO);\n\t\tgl.blendEquation(gl.FUNC_ADD);\n\t\tgl.colorMask(true, true, true, true);\n\t\tgl.blendColor(0, 0, 0, 0);\n\t\tgl.enable(gl.CULL_FACE);\n\t\tthis.cullFace = gl.BACK;\n\t\tgl.cullFace(gl.BACK);\n\t\tgl.enable(gl.DEPTH_TEST);\n\t\tgl.depthFunc(gl.LEQUAL);\n\t\tgl.depthMask(true);\n\t\tthis.stencil = false;\n\t\tgl.disable(gl.STENCIL_TEST);\n\t\tthis.stencilFuncFront = this.stencilFuncBack = FUNC_ALWAYS;\n\t\tthis.stencilRefFront = this.stencilRefBack = 0;\n\t\tthis.stencilMaskFront = this.stencilMaskBack = 0xFF;\n\t\tgl.stencilFunc(gl.ALWAYS, 0, 0xFF);\n\t\tthis.stencilFailFront = this.stencilFailBack = STENCILOP_KEEP;\n\t\tthis.stencilZfailFront = this.stencilZfailBack = STENCILOP_KEEP;\n\t\tthis.stencilZpassFront = this.stencilZpassBack = STENCILOP_KEEP;\n\t\tthis.stencilWriteMaskFront = 0xFF;\n\t\tthis.stencilWriteMaskBack = 0xFF;\n\t\tgl.stencilOp(gl.KEEP, gl.KEEP, gl.KEEP);\n\t\tgl.stencilMask(0xFF);\n\t\tthis.alphaToCoverage = false;\n\t\tthis.raster = true;\n\t\tif (this.isWebGL2) {\n\t\t\tgl.disable(gl.SAMPLE_ALPHA_TO_COVERAGE);\n\t\t\tgl.disable(gl.RASTERIZER_DISCARD);\n\t\t}\n\t\tthis.depthBiasEnabled = false;\n\t\tgl.disable(gl.POLYGON_OFFSET_FILL);\n\t\tthis.clearDepth = 1;\n\t\tgl.clearDepth(1);\n\t\tthis.clearColor = new Color(0, 0, 0, 0);\n\t\tgl.clearColor(0, 0, 0, 0);\n\t\tthis.clearStencil = 0;\n\t\tgl.clearStencil(0);\n\t\tif (this.isWebGL2) {\n\t\t\tgl.hint(gl.FRAGMENT_SHADER_DERIVATIVE_HINT, gl.NICEST);\n\t\t} else {\n\t\t\tif (this.extStandardDerivatives) {\n\t\t\t\tgl.hint(this.extStandardDerivatives.FRAGMENT_SHADER_DERIVATIVE_HINT_OES, gl.NICEST);\n\t\t\t}\n\t\t}\n\t\tgl.enable(gl.SCISSOR_TEST);\n\t\tgl.pixelStorei(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, gl.NONE);\n\t\tthis.unpackFlipY = false;\n\t\tgl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);\n\t\tthis.unpackPremultiplyAlpha = false;\n\t\tgl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);\n\t\tgl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);\n\t}\n\tinitTextureUnits(count = 16) {\n\t\tthis.textureUnits = [];\n\t\tfor (let i = 0; i < count; i++) {\n\t\t\tthis.textureUnits.push([null, null, null]);\n\t\t}\n\t}\n\tinitializeContextCaches() {\n\t\tsuper.initializeContextCaches();\n\t\tthis._vaoMap = new Map();\n\t\tthis.boundVao = null;\n\t\tthis.activeFramebuffer = null;\n\t\tthis.feedback = null;\n\t\tthis.transformFeedbackBuffer = null;\n\t\tthis.textureUnit = 0;\n\t\tthis.initTextureUnits(this.maxCombinedTextures);\n\t}\n\tloseContext() {\n\t\tsuper.loseContext();\n\t\tfor (const shader of this.shaders) {\n\t\t\tshader.loseContext();\n\t\t}\n\t}\n\trestoreContext() {\n\t\tthis.initializeExtensions();\n\t\tthis.initializeCapabilities();\n\t\tsuper.restoreContext();\n\t\tfor (const shader of this.shaders) {\n\t\t\tshader.restoreContext();\n\t\t}\n\t}\n\tsetViewport(x, y, w, h) {\n\t\tif (this.vx !== x || this.vy !== y || this.vw !== w || this.vh !== h) {\n\t\t\tthis.gl.viewport(x, y, w, h);\n\t\t\tthis.vx = x;\n\t\t\tthis.vy = y;\n\t\t\tthis.vw = w;\n\t\t\tthis.vh = h;\n\t\t}\n\t}\n\tsetScissor(x, y, w, h) {\n\t\tif (this.sx !== x || this.sy !== y || this.sw !== w || this.sh !== h) {\n\t\t\tthis.gl.scissor(x, y, w, h);\n\t\t\tthis.sx = x;\n\t\t\tthis.sy = y;\n\t\t\tthis.sw = w;\n\t\t\tthis.sh = h;\n\t\t}\n\t}\n\tsetFramebuffer(fb) {\n\t\tif (this.activeFramebuffer !== fb) {\n\t\t\tconst gl = this.gl;\n\t\t\tgl.bindFramebuffer(gl.FRAMEBUFFER, fb);\n\t\t\tthis.activeFramebuffer = fb;\n\t\t}\n\t}\n\tcopyRenderTarget(source, dest, color, depth) {\n\t\tconst gl = this.gl;\n\t\tif (source === this.backBuffer) {\n\t\t\tsource = null;\n\t\t}\n\t\tif (!this.isWebGL2 && depth) {\n\t\t\treturn false;\n\t\t}\n\t\tif (color) {\n\t\t\tif (!dest) {\n\t\t\t\tif (!source._colorBuffer) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t} else if (source) {\n\t\t\t\tif (!source._colorBuffer || !dest._colorBuffer) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t\tif (source._colorBuffer._format !== dest._colorBuffer._format) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (depth && source) {\n\t\t\tif (!source._depth) {\n\t\t\t\tif (!source._depthBuffer || !dest._depthBuffer) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t\tif (source._depthBuffer._format !== dest._depthBuffer._format) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (this.isWebGL2) {\n\t\t\tvar _this$backBuffer, _this$backBuffer2;\n\t\t\tconst prevRt = this.renderTarget;\n\t\t\tthis.renderTarget = dest;\n\t\t\tthis.updateBegin();\n\t\t\tconst src = source ? source.impl._glFrameBuffer : (_this$backBuffer = this.backBuffer) == null ? void 0 : _this$backBuffer.impl._glFrameBuffer;\n\t\t\tconst dst = dest ? dest.impl._glFrameBuffer : (_this$backBuffer2 = this.backBuffer) == null ? void 0 : _this$backBuffer2.impl._glFrameBuffer;\n\t\t\tgl.bindFramebuffer(gl.READ_FRAMEBUFFER, src);\n\t\t\tgl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, dst);\n\t\t\tconst w = source ? source.width : dest ? dest.width : this.width;\n\t\t\tconst h = source ? source.height : dest ? dest.height : this.height;\n\t\t\tgl.blitFramebuffer(0, 0, w, h, 0, 0, w, h, (color ? gl.COLOR_BUFFER_BIT : 0) | (depth ? gl.DEPTH_BUFFER_BIT : 0), gl.NEAREST);\n\t\t\tthis.renderTarget = prevRt;\n\t\t\tgl.bindFramebuffer(gl.FRAMEBUFFER, prevRt ? prevRt.impl._glFrameBuffer : null);\n\t\t} else {\n\t\t\tconst shader = this.getCopyShader();\n\t\t\tthis.constantTexSource.setValue(source._colorBuffer);\n\t\t\tquadWithShader(this, dest, shader);\n\t\t}\n\t\treturn true;\n\t}\n\tgetCopyShader() {\n\t\tif (!this._copyShader) {\n\t\t\tthis._copyShader = new Shader(this, ShaderUtils.createDefinition(this, {\n\t\t\t\tname: 'outputTex2D',\n\t\t\t\tvertexCode: _fullScreenQuadVS,\n\t\t\t\tfragmentCode: _outputTexture2D\n\t\t\t}));\n\t\t}\n\t\treturn this._copyShader;\n\t}\n\tframeStart() {\n\t\tsuper.frameStart();\n\t\tthis.updateBackbuffer();\n\t\tthis.gpuProfiler.frameStart();\n\t}\n\tframeEnd() {\n\t\tsuper.frameEnd();\n\t\tthis.gpuProfiler.frameEnd();\n\t\tthis.gpuProfiler.request();\n\t}\n\tstartRenderPass(renderPass) {\n\t\tvar _renderPass$renderTar;\n\t\tconst rt = (_renderPass$renderTar = renderPass.renderTarget) != null ? _renderPass$renderTar : this.backBuffer;\n\t\tthis.renderTarget = rt;\n\t\tthis.updateBegin();\n\t\tconst {\n\t\t\twidth,\n\t\t\theight\n\t\t} = rt;\n\t\tthis.setViewport(0, 0, width, height);\n\t\tthis.setScissor(0, 0, width, height);\n\t\tconst colorOps = renderPass.colorOps;\n\t\tconst depthStencilOps = renderPass.depthStencilOps;\n\t\tif (colorOps != null && colorOps.clear || depthStencilOps.clearDepth || depthStencilOps.clearStencil) {\n\t\t\tlet clearFlags = 0;\n\t\t\tconst clearOptions = {};\n\t\t\tif (colorOps != null && colorOps.clear) {\n\t\t\t\tclearFlags |= CLEARFLAG_COLOR;\n\t\t\t\tclearOptions.color = [colorOps.clearValue.r, colorOps.clearValue.g, colorOps.clearValue.b, colorOps.clearValue.a];\n\t\t\t}\n\t\t\tif (depthStencilOps.clearDepth) {\n\t\t\t\tclearFlags |= CLEARFLAG_DEPTH;\n\t\t\t\tclearOptions.depth = depthStencilOps.clearDepthValue;\n\t\t\t}\n\t\t\tif (depthStencilOps.clearStencil) {\n\t\t\t\tclearFlags |= CLEARFLAG_STENCIL;\n\t\t\t\tclearOptions.stencil = depthStencilOps.clearStencilValue;\n\t\t\t}\n\t\t\tclearOptions.flags = clearFlags;\n\t\t\tthis.clear(clearOptions);\n\t\t}\n\t\tthis.insideRenderPass = true;\n\t}\n\tendRenderPass(renderPass) {\n\t\tthis.unbindVertexArray();\n\t\tconst target = this.renderTarget;\n\t\tconst colorBufferCount = renderPass.colorArrayOps.length;\n\t\tif (target) {\n\t\t\tvar _renderPass$colorOps;\n\t\t\tif (this.isWebGL2) {\n\t\t\t\tinvalidateAttachments.length = 0;\n\t\t\t\tconst gl = this.gl;\n\t\t\t\tfor (let i = 0; i < colorBufferCount; i++) {\n\t\t\t\t\tconst colorOps = renderPass.colorArrayOps[i];\n\t\t\t\t\tif (!(colorOps.store || colorOps.resolve)) {\n\t\t\t\t\t\tinvalidateAttachments.push(gl.COLOR_ATTACHMENT0 + i);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tif (target !== this.backBuffer) {\n\t\t\t\t\tif (!renderPass.depthStencilOps.storeDepth) {\n\t\t\t\t\t\tinvalidateAttachments.push(gl.DEPTH_ATTACHMENT);\n\t\t\t\t\t}\n\t\t\t\t\tif (!renderPass.depthStencilOps.storeStencil) {\n\t\t\t\t\t\tinvalidateAttachments.push(gl.STENCIL_ATTACHMENT);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tif (invalidateAttachments.length > 0) {\n\t\t\t\t\tif (renderPass.fullSizeClearRect) {\n\t\t\t\t\t\tgl.invalidateFramebuffer(gl.DRAW_FRAMEBUFFER, invalidateAttachments);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tif ((_renderPass$colorOps = renderPass.colorOps) != null && _renderPass$colorOps.resolve) {\n\t\t\t\tif (this.isWebGL2 && renderPass.samples > 1 && target.autoResolve) {\n\t\t\t\t\ttarget.resolve(true, false);\n\t\t\t\t}\n\t\t\t}\n\t\t\tfor (let i = 0; i < colorBufferCount; i++) {\n\t\t\t\tconst colorOps = renderPass.colorArrayOps[i];\n\t\t\t\tif (colorOps.mipmaps) {\n\t\t\t\t\tconst colorBuffer = target._colorBuffers[i];\n\t\t\t\t\tif (colorBuffer && colorBuffer.impl._glTexture && colorBuffer.mipmaps && (colorBuffer.pot || this.isWebGL2)) {\n\t\t\t\t\t\tthis.activeTexture(this.maxCombinedTextures - 1);\n\t\t\t\t\t\tthis.bindTexture(colorBuffer);\n\t\t\t\t\t\tthis.gl.generateMipmap(colorBuffer.impl._glTarget);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tthis.insideRenderPass = false;\n\t}\n\tset defaultFramebuffer(value) {\n\t\tif (this._defaultFramebuffer !== value) {\n\t\t\tthis._defaultFramebuffer = value;\n\t\t\tthis._defaultFramebufferChanged = true;\n\t\t}\n\t}\n\tget defaultFramebuffer() {\n\t\treturn this._defaultFramebuffer;\n\t}\n\tupdateBegin() {\n\t\tvar _this$renderTarget;\n\t\tthis.boundVao = null;\n\t\tif (this._tempEnableSafariTextureUnitWorkaround) {\n\t\t\tfor (let unit = 0; unit < this.textureUnits.length; ++unit) {\n\t\t\t\tfor (let slot = 0; slot < 3; ++slot) {\n\t\t\t\t\tthis.textureUnits[unit][slot] = null;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tconst target = (_this$renderTarget = this.renderTarget) != null ? _this$renderTarget : this.backBuffer;\n\t\tconst targetImpl = target.impl;\n\t\tif (!targetImpl.initialized) {\n\t\t\tthis.initRenderTarget(target);\n\t\t}\n\t\tthis.setFramebuffer(targetImpl._glFrameBuffer);\n\t}\n\tupdateEnd() {\n\t\tthis.unbindVertexArray();\n\t\tconst target = this.renderTarget;\n\t\tif (target && target !== this.backBuffer) {\n\t\t\tif (this.isWebGL2 && target._samples > 1 && target.autoResolve) {\n\t\t\t\ttarget.resolve();\n\t\t\t}\n\t\t\tconst colorBuffer = target._colorBuffer;\n\t\t\tif (colorBuffer && colorBuffer.impl._glTexture && colorBuffer.mipmaps && (colorBuffer.pot || this.isWebGL2)) {\n\t\t\t\tthis.activeTexture(this.maxCombinedTextures - 1);\n\t\t\t\tthis.bindTexture(colorBuffer);\n\t\t\t\tthis.gl.generateMipmap(colorBuffer.impl._glTarget);\n\t\t\t}\n\t\t}\n\t}\n\tsetUnpackFlipY(flipY) {\n\t\tif (this.unpackFlipY !== flipY) {\n\t\t\tthis.unpackFlipY = flipY;\n\t\t\tconst gl = this.gl;\n\t\t\tgl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, flipY);\n\t\t}\n\t}\n\tsetUnpackPremultiplyAlpha(premultiplyAlpha) {\n\t\tif (this.unpackPremultiplyAlpha !== premultiplyAlpha) {\n\t\t\tthis.unpackPremultiplyAlpha = premultiplyAlpha;\n\t\t\tconst gl = this.gl;\n\t\t\tgl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, premultiplyAlpha);\n\t\t}\n\t}\n\tactiveTexture(textureUnit) {\n\t\tif (this.textureUnit !== textureUnit) {\n\t\t\tthis.gl.activeTexture(this.gl.TEXTURE0 + textureUnit);\n\t\t\tthis.textureUnit = textureUnit;\n\t\t}\n\t}\n\tbindTexture(texture) {\n\t\tconst impl = texture.impl;\n\t\tconst textureTarget = impl._glTarget;\n\t\tconst textureObject = impl._glTexture;\n\t\tconst textureUnit = this.textureUnit;\n\t\tconst slot = this.targetToSlot[textureTarget];\n\t\tif (this.textureUnits[textureUnit][slot] !== textureObject) {\n\t\t\tthis.gl.bindTexture(textureTarget, textureObject);\n\t\t\tthis.textureUnits[textureUnit][slot] = textureObject;\n\t\t}\n\t}\n\tbindTextureOnUnit(texture, textureUnit) {\n\t\tconst impl = texture.impl;\n\t\tconst textureTarget = impl._glTarget;\n\t\tconst textureObject = impl._glTexture;\n\t\tconst slot = this.targetToSlot[textureTarget];\n\t\tif (this.textureUnits[textureUnit][slot] !== textureObject) {\n\t\t\tthis.activeTexture(textureUnit);\n\t\t\tthis.gl.bindTexture(textureTarget, textureObject);\n\t\t\tthis.textureUnits[textureUnit][slot] = textureObject;\n\t\t}\n\t}\n\tsetTextureParameters(texture) {\n\t\tconst gl = this.gl;\n\t\tconst flags = texture.impl.dirtyParameterFlags;\n\t\tconst target = texture.impl._glTarget;\n\t\tif (flags & 1) {\n\t\t\tlet filter = texture._minFilter;\n\t\t\tif (!texture.pot && !this.isWebGL2 || !texture._mipmaps || texture._compressed && texture._levels.length === 1) {\n\t\t\t\tif (filter === FILTER_NEAREST_MIPMAP_NEAREST || filter === FILTER_NEAREST_MIPMAP_LINEAR) {\n\t\t\t\t\tfilter = FILTER_NEAREST;\n\t\t\t\t} else if (filter === FILTER_LINEAR_MIPMAP_NEAREST || filter === FILTER_LINEAR_MIPMAP_LINEAR) {\n\t\t\t\t\tfilter = FILTER_LINEAR;\n\t\t\t\t}\n\t\t\t}\n\t\t\tgl.texParameteri(target, gl.TEXTURE_MIN_FILTER, this.glFilter[filter]);\n\t\t}\n\t\tif (flags & 2) {\n\t\t\tgl.texParameteri(target, gl.TEXTURE_MAG_FILTER, this.glFilter[texture._magFilter]);\n\t\t}\n\t\tif (flags & 4) {\n\t\t\tif (this.isWebGL2) {\n\t\t\t\tgl.texParameteri(target, gl.TEXTURE_WRAP_S, this.glAddress[texture._addressU]);\n\t\t\t} else {\n\t\t\t\tgl.texParameteri(target, gl.TEXTURE_WRAP_S, this.glAddress[texture.pot ? texture._addressU : ADDRESS_CLAMP_TO_EDGE]);\n\t\t\t}\n\t\t}\n\t\tif (flags & 8) {\n\t\t\tif (this.isWebGL2) {\n\t\t\t\tgl.texParameteri(target, gl.TEXTURE_WRAP_T, this.glAddress[texture._addressV]);\n\t\t\t} else {\n\t\t\t\tgl.texParameteri(target, gl.TEXTURE_WRAP_T, this.glAddress[texture.pot ? texture._addressV : ADDRESS_CLAMP_TO_EDGE]);\n\t\t\t}\n\t\t}\n\t\tif (flags & 16) {\n\t\t\tif (this.isWebGL2) {\n\t\t\t\tgl.texParameteri(target, gl.TEXTURE_WRAP_R, this.glAddress[texture._addressW]);\n\t\t\t}\n\t\t}\n\t\tif (flags & 32) {\n\t\t\tif (this.isWebGL2) {\n\t\t\t\tgl.texParameteri(target, gl.TEXTURE_COMPARE_MODE, texture._compareOnRead ? gl.COMPARE_REF_TO_TEXTURE : gl.NONE);\n\t\t\t}\n\t\t}\n\t\tif (flags & 64) {\n\t\t\tif (this.isWebGL2) {\n\t\t\t\tgl.texParameteri(target, gl.TEXTURE_COMPARE_FUNC, this.glComparison[texture._compareFunc]);\n\t\t\t}\n\t\t}\n\t\tif (flags & 128) {\n\t\t\tconst ext = this.extTextureFilterAnisotropic;\n\t\t\tif (ext) {\n\t\t\t\tgl.texParameterf(target, ext.TEXTURE_MAX_ANISOTROPY_EXT, math.clamp(Math.round(texture._anisotropy), 1, this.maxAnisotropy));\n\t\t\t}\n\t\t}\n\t}\n\tsetTexture(texture, textureUnit) {\n\t\tconst impl = texture.impl;\n\t\tif (!impl._glTexture) impl.initialize(this, texture);\n\t\tif (impl.dirtyParameterFlags > 0 || texture._needsUpload || texture._needsMipmapsUpload) {\n\t\t\tthis.activeTexture(textureUnit);\n\t\t\tthis.bindTexture(texture);\n\t\t\tif (impl.dirtyParameterFlags) {\n\t\t\t\tthis.setTextureParameters(texture);\n\t\t\t\timpl.dirtyParameterFlags = 0;\n\t\t\t}\n\t\t\tif (texture._needsUpload || texture._needsMipmapsUpload) {\n\t\t\t\timpl.upload(this, texture);\n\t\t\t\ttexture._needsUpload = false;\n\t\t\t\ttexture._needsMipmapsUpload = false;\n\t\t\t}\n\t\t} else {\n\t\t\tthis.bindTextureOnUnit(texture, textureUnit);\n\t\t}\n\t}\n\tcreateVertexArray(vertexBuffers) {\n\t\tlet key, vao;\n\t\tconst useCache = vertexBuffers.length > 1;\n\t\tif (useCache) {\n\t\t\tkey = \"\";\n\t\t\tfor (let i = 0; i < vertexBuffers.length; i++) {\n\t\t\t\tconst vertexBuffer = vertexBuffers[i];\n\t\t\t\tkey += vertexBuffer.id + vertexBuffer.format.renderingHash;\n\t\t\t}\n\t\t\tvao = this._vaoMap.get(key);\n\t\t}\n\t\tif (!vao) {\n\t\t\tconst gl = this.gl;\n\t\t\tvao = gl.createVertexArray();\n\t\t\tgl.bindVertexArray(vao);\n\t\t\tgl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);\n\t\t\tfor (let i = 0; i < vertexBuffers.length; i++) {\n\t\t\t\tconst vertexBuffer = vertexBuffers[i];\n\t\t\t\tgl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer.impl.bufferId);\n\t\t\t\tconst elements = vertexBuffer.format.elements;\n\t\t\t\tfor (let j = 0; j < elements.length; j++) {\n\t\t\t\t\tconst e = elements[j];\n\t\t\t\t\tconst loc = semanticToLocation[e.name];\n\t\t\t\t\tif (e.asInt) {\n\t\t\t\t\t\tgl.vertexAttribIPointer(loc, e.numComponents, this.glType[e.dataType], e.stride, e.offset);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tgl.vertexAttribPointer(loc, e.numComponents, this.glType[e.dataType], e.normalize, e.stride, e.offset);\n\t\t\t\t\t}\n\t\t\t\t\tgl.enableVertexAttribArray(loc);\n\t\t\t\t\tif (vertexBuffer.format.instancing) {\n\t\t\t\t\t\tgl.vertexAttribDivisor(loc, 1);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tgl.bindVertexArray(null);\n\t\t\tgl.bindBuffer(gl.ARRAY_BUFFER, null);\n\t\t\tif (useCache) {\n\t\t\t\tthis._vaoMap.set(key, vao);\n\t\t\t}\n\t\t}\n\t\treturn vao;\n\t}\n\tunbindVertexArray() {\n\t\tif (this.boundVao) {\n\t\t\tthis.boundVao = null;\n\t\t\tthis.gl.bindVertexArray(null);\n\t\t}\n\t}\n\tsetBuffers() {\n\t\tconst gl = this.gl;\n\t\tlet vao;\n\t\tif (this.vertexBuffers.length === 1) {\n\t\t\tconst vertexBuffer = this.vertexBuffers[0];\n\t\t\tif (!vertexBuffer.impl.vao) {\n\t\t\t\tvertexBuffer.impl.vao = this.createVertexArray(this.vertexBuffers);\n\t\t\t}\n\t\t\tvao = vertexBuffer.impl.vao;\n\t\t} else {\n\t\t\tvao = this.createVertexArray(this.vertexBuffers);\n\t\t}\n\t\tif (this.boundVao !== vao) {\n\t\t\tthis.boundVao = vao;\n\t\t\tgl.bindVertexArray(vao);\n\t\t}\n\t\tthis.clearVertexBuffer();\n\t\tconst bufferId = this.indexBuffer ? this.indexBuffer.impl.bufferId : null;\n\t\tgl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, bufferId);\n\t}\n\tdraw(primitive, numInstances, keepBuffers) {\n\t\tconst gl = this.gl;\n\t\tthis.activateShader(this);\n\t\tif (!this.shaderValid) return;\n\t\tlet sampler, samplerValue, texture, numTextures;\n\t\tlet uniform, scopeId, uniformVersion, programVersion;\n\t\tconst shader = this.shader;\n\t\tif (!shader) return;\n\t\tconst samplers = shader.impl.samplers;\n\t\tconst uniforms = shader.impl.uniforms;\n\t\tif (!keepBuffers) {\n\t\t\tthis.setBuffers();\n\t\t}\n\t\tlet textureUnit = 0;\n\t\tfor (let i = 0, len = samplers.length; i < len; i++) {\n\t\t\tsampler = samplers[i];\n\t\t\tsamplerValue = sampler.scopeId.value;\n\t\t\tif (!samplerValue) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif (samplerValue instanceof Texture) {\n\t\t\t\ttexture = samplerValue;\n\t\t\t\tthis.setTexture(texture, textureUnit);\n\t\t\t\tif (sampler.slot !== textureUnit) {\n\t\t\t\t\tgl.uniform1i(sampler.locationId, textureUnit);\n\t\t\t\t\tsampler.slot = textureUnit;\n\t\t\t\t}\n\t\t\t\ttextureUnit++;\n\t\t\t} else {\n\t\t\t\tsampler.array.length = 0;\n\t\t\t\tnumTextures = samplerValue.length;\n\t\t\t\tfor (let j = 0; j < numTextures; j++) {\n\t\t\t\t\ttexture = samplerValue[j];\n\t\t\t\t\tthis.setTexture(texture, textureUnit);\n\t\t\t\t\tsampler.array[j] = textureUnit;\n\t\t\t\t\ttextureUnit++;\n\t\t\t\t}\n\t\t\t\tgl.uniform1iv(sampler.locationId, sampler.array);\n\t\t\t}\n\t\t}\n\t\tfor (let i = 0, len = uniforms.length; i < len; i++) {\n\t\t\tuniform = uniforms[i];\n\t\t\tscopeId = uniform.scopeId;\n\t\t\tuniformVersion = uniform.version;\n\t\t\tprogramVersion = scopeId.versionObject.version;\n\t\t\tif (uniformVersion.globalId !== programVersion.globalId || uniformVersion.revision !== programVersion.revision) {\n\t\t\t\tuniformVersion.globalId = programVersion.globalId;\n\t\t\t\tuniformVersion.revision = programVersion.revision;\n\t\t\t\tif (scopeId.value !== null) {\n\t\t\t\t\tthis.commitFunction[uniform.dataType](uniform, scopeId.value);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (this.isWebGL2 && this.transformFeedbackBuffer) {\n\t\t\tgl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, this.transformFeedbackBuffer.impl.bufferId);\n\t\t\tgl.beginTransformFeedback(gl.POINTS);\n\t\t}\n\t\tconst mode = this.glPrimitive[primitive.type];\n\t\tconst count = primitive.count;\n\t\tif (primitive.indexed) {\n\t\t\tconst indexBuffer = this.indexBuffer;\n\t\t\tconst format = indexBuffer.impl.glFormat;\n\t\t\tconst offset = primitive.base * indexBuffer.bytesPerIndex;\n\t\t\tif (numInstances > 0) {\n\t\t\t\tgl.drawElementsInstanced(mode, count, format, offset, numInstances);\n\t\t\t} else {\n\t\t\t\tgl.drawElements(mode, count, format, offset);\n\t\t\t}\n\t\t} else {\n\t\t\tconst first = primitive.base;\n\t\t\tif (numInstances > 0) {\n\t\t\t\tgl.drawArraysInstanced(mode, first, count, numInstances);\n\t\t\t} else {\n\t\t\t\tgl.drawArrays(mode, first, count);\n\t\t\t}\n\t\t}\n\t\tif (this.isWebGL2 && this.transformFeedbackBuffer) {\n\t\t\tgl.endTransformFeedback();\n\t\t\tgl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, null);\n\t\t}\n\t\tthis._drawCallsPerFrame++;\n\t}\n\tclear(options) {\n\t\tvar _options$flags;\n\t\tconst defaultOptions = this.defaultClearOptions;\n\t\toptions = options || defaultOptions;\n\t\tconst flags = (_options$flags = options.flags) != null ? _options$flags : defaultOptions.flags;\n\t\tif (flags !== 0) {\n\t\t\tconst gl = this.gl;\n\t\t\tif (flags & CLEARFLAG_COLOR) {\n\t\t\t\tvar _options$color;\n\t\t\t\tconst color = (_options$color = options.color) != null ? _options$color : defaultOptions.color;\n\t\t\t\tconst r = color[0];\n\t\t\t\tconst g = color[1];\n\t\t\t\tconst b = color[2];\n\t\t\t\tconst a = color[3];\n\t\t\t\tconst c = this.clearColor;\n\t\t\t\tif (r !== c.r || g !== c.g || b !== c.b || a !== c.a) {\n\t\t\t\t\tthis.gl.clearColor(r, g, b, a);\n\t\t\t\t\tthis.clearColor.set(r, g, b, a);\n\t\t\t\t}\n\t\t\t\tthis.setBlendState(BlendState.NOBLEND);\n\t\t\t}\n\t\t\tif (flags & CLEARFLAG_DEPTH) {\n\t\t\t\tvar _options$depth;\n\t\t\t\tconst depth = (_options$depth = options.depth) != null ? _options$depth : defaultOptions.depth;\n\t\t\t\tif (depth !== this.clearDepth) {\n\t\t\t\t\tthis.gl.clearDepth(depth);\n\t\t\t\t\tthis.clearDepth = depth;\n\t\t\t\t}\n\t\t\t\tthis.setDepthState(DepthState.WRITEDEPTH);\n\t\t\t}\n\t\t\tif (flags & CLEARFLAG_STENCIL) {\n\t\t\t\tvar _options$stencil;\n\t\t\t\tconst stencil = (_options$stencil = options.stencil) != null ? _options$stencil : defaultOptions.stencil;\n\t\t\t\tif (stencil !== this.clearStencil) {\n\t\t\t\t\tthis.gl.clearStencil(stencil);\n\t\t\t\t\tthis.clearStencil = stencil;\n\t\t\t\t}\n\t\t\t\tgl.stencilMask(0xFF);\n\t\t\t\tthis.stencilWriteMaskFront = 0xFF;\n\t\t\t\tthis.stencilWriteMaskBack = 0xFF;\n\t\t\t}\n\t\t\tgl.clear(this.glClearFlag[flags]);\n\t\t}\n\t}\n\tsubmit() {\n\t\tthis.gl.flush();\n\t}\n\treadPixels(x, y, w, h, pixels) {\n\t\tconst gl = this.gl;\n\t\tgl.readPixels(x, y, w, h, gl.RGBA, gl.UNSIGNED_BYTE, pixels);\n\t}\n\tasync readPixelsAsync(x, y, w, h, pixels) {\n\t\tvar _this$renderTarget$co, _impl$_glFormat, _impl$_glPixelType;\n\t\tconst gl = this.gl;\n\t\tif (!this.isWebGL2) {\n\t\t\tthis.readPixels(x, y, w, h, pixels);\n\t\t\treturn;\n\t\t}\n\t\tconst clientWaitAsync = (flags, interval_ms) => {\n\t\t\tconst sync = gl.fenceSync(gl.SYNC_GPU_COMMANDS_COMPLETE, 0);\n\t\t\tthis.submit();\n\t\t\treturn new Promise((resolve, reject) => {\n\t\t\t\tfunction test() {\n\t\t\t\t\tconst res = gl.clientWaitSync(sync, flags, 0);\n\t\t\t\t\tif (res === gl.WAIT_FAILED) {\n\t\t\t\t\t\tgl.deleteSync(sync);\n\t\t\t\t\t\treject(new Error('webgl clientWaitSync sync failed'));\n\t\t\t\t\t} else if (res === gl.TIMEOUT_EXPIRED) {\n\t\t\t\t\t\tsetTimeout(test, interval_ms);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tgl.deleteSync(sync);\n\t\t\t\t\t\tresolve();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\ttest();\n\t\t\t});\n\t\t};\n\t\tconst impl = (_this$renderTarget$co = this.renderTarget.colorBuffer) == null ? void 0 : _this$renderTarget$co.impl;\n\t\tconst format = (_impl$_glFormat = impl == null ? void 0 : impl._glFormat) != null ? _impl$_glFormat : gl.RGBA;\n\t\tconst pixelType = (_impl$_glPixelType = impl == null ? void 0 : impl._glPixelType) != null ? _impl$_glPixelType : gl.UNSIGNED_BYTE;\n\t\tconst buf = gl.createBuffer();\n\t\tgl.bindBuffer(gl.PIXEL_PACK_BUFFER, buf);\n\t\tgl.bufferData(gl.PIXEL_PACK_BUFFER, pixels.byteLength, gl.STREAM_READ);\n\t\tgl.readPixels(x, y, w, h, format, pixelType, 0);\n\t\tgl.bindBuffer(gl.PIXEL_PACK_BUFFER, null);\n\t\tawait clientWaitAsync(0, 20);\n\t\tgl.bindBuffer(gl.PIXEL_PACK_BUFFER, buf);\n\t\tgl.getBufferSubData(gl.PIXEL_PACK_BUFFER, 0, pixels);\n\t\tgl.bindBuffer(gl.PIXEL_PACK_BUFFER, null);\n\t\tgl.deleteBuffer(buf);\n\t}\n\tsetAlphaToCoverage(state) {\n\t\tif (this.isWebGL1) return;\n\t\tif (this.alphaToCoverage === state) return;\n\t\tthis.alphaToCoverage = state;\n\t\tif (state) {\n\t\t\tthis.gl.enable(this.gl.SAMPLE_ALPHA_TO_COVERAGE);\n\t\t} else {\n\t\t\tthis.gl.disable(this.gl.SAMPLE_ALPHA_TO_COVERAGE);\n\t\t}\n\t}\n\tsetTransformFeedbackBuffer(tf) {\n\t\tif (this.transformFeedbackBuffer === tf) return;\n\t\tthis.transformFeedbackBuffer = tf;\n\t\tif (this.isWebGL2) {\n\t\t\tconst gl = this.gl;\n\t\t\tif (tf) {\n\t\t\t\tif (!this.feedback) {\n\t\t\t\t\tthis.feedback = gl.createTransformFeedback();\n\t\t\t\t}\n\t\t\t\tgl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, this.feedback);\n\t\t\t} else {\n\t\t\t\tgl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, null);\n\t\t\t}\n\t\t}\n\t}\n\tsetRaster(on) {\n\t\tif (this.raster === on) return;\n\t\tthis.raster = on;\n\t\tif (this.isWebGL2) {\n\t\t\tif (on) {\n\t\t\t\tthis.gl.disable(this.gl.RASTERIZER_DISCARD);\n\t\t\t} else {\n\t\t\t\tthis.gl.enable(this.gl.RASTERIZER_DISCARD);\n\t\t\t}\n\t\t}\n\t}\n\tsetStencilTest(enable) {\n\t\tif (this.stencil !== enable) {\n\t\t\tconst gl = this.gl;\n\t\t\tif (enable) {\n\t\t\t\tgl.enable(gl.STENCIL_TEST);\n\t\t\t} else {\n\t\t\t\tgl.disable(gl.STENCIL_TEST);\n\t\t\t}\n\t\t\tthis.stencil = enable;\n\t\t}\n\t}\n\tsetStencilFunc(func, ref, mask) {\n\t\tif (this.stencilFuncFront !== func || this.stencilRefFront !== ref || this.stencilMaskFront !== mask || this.stencilFuncBack !== func || this.stencilRefBack !== ref || this.stencilMaskBack !== mask) {\n\t\t\tthis.gl.stencilFunc(this.glComparison[func], ref, mask);\n\t\t\tthis.stencilFuncFront = this.stencilFuncBack = func;\n\t\t\tthis.stencilRefFront = this.stencilRefBack = ref;\n\t\t\tthis.stencilMaskFront = this.stencilMaskBack = mask;\n\t\t}\n\t}\n\tsetStencilFuncFront(func, ref, mask) {\n\t\tif (this.stencilFuncFront !== func || this.stencilRefFront !== ref || this.stencilMaskFront !== mask) {\n\t\t\tconst gl = this.gl;\n\t\t\tgl.stencilFuncSeparate(gl.FRONT, this.glComparison[func], ref, mask);\n\t\t\tthis.stencilFuncFront = func;\n\t\t\tthis.stencilRefFront = ref;\n\t\t\tthis.stencilMaskFront = mask;\n\t\t}\n\t}\n\tsetStencilFuncBack(func, ref, mask) {\n\t\tif (this.stencilFuncBack !== func || this.stencilRefBack !== ref || this.stencilMaskBack !== mask) {\n\t\t\tconst gl = this.gl;\n\t\t\tgl.stencilFuncSeparate(gl.BACK, this.glComparison[func], ref, mask);\n\t\t\tthis.stencilFuncBack = func;\n\t\t\tthis.stencilRefBack = ref;\n\t\t\tthis.stencilMaskBack = mask;\n\t\t}\n\t}\n\tsetStencilOperation(fail, zfail, zpass, writeMask) {\n\t\tif (this.stencilFailFront !== fail || this.stencilZfailFront !== zfail || this.stencilZpassFront !== zpass || this.stencilFailBack !== fail || this.stencilZfailBack !== zfail || this.stencilZpassBack !== zpass) {\n\t\t\tthis.gl.stencilOp(this.glStencilOp[fail], this.glStencilOp[zfail], this.glStencilOp[zpass]);\n\t\t\tthis.stencilFailFront = this.stencilFailBack = fail;\n\t\t\tthis.stencilZfailFront = this.stencilZfailBack = zfail;\n\t\t\tthis.stencilZpassFront = this.stencilZpassBack = zpass;\n\t\t}\n\t\tif (this.stencilWriteMaskFront !== writeMask || this.stencilWriteMaskBack !== writeMask) {\n\t\t\tthis.gl.stencilMask(writeMask);\n\t\t\tthis.stencilWriteMaskFront = writeMask;\n\t\t\tthis.stencilWriteMaskBack = writeMask;\n\t\t}\n\t}\n\tsetStencilOperationFront(fail, zfail, zpass, writeMask) {\n\t\tif (this.stencilFailFront !== fail || this.stencilZfailFront !== zfail || this.stencilZpassFront !== zpass) {\n\t\t\tthis.gl.stencilOpSeparate(this.gl.FRONT, this.glStencilOp[fail], this.glStencilOp[zfail], this.glStencilOp[zpass]);\n\t\t\tthis.stencilFailFront = fail;\n\t\t\tthis.stencilZfailFront = zfail;\n\t\t\tthis.stencilZpassFront = zpass;\n\t\t}\n\t\tif (this.stencilWriteMaskFront !== writeMask) {\n\t\t\tthis.gl.stencilMaskSeparate(this.gl.FRONT, writeMask);\n\t\t\tthis.stencilWriteMaskFront = writeMask;\n\t\t}\n\t}\n\tsetStencilOperationBack(fail, zfail, zpass, writeMask) {\n\t\tif (this.stencilFailBack !== fail || this.stencilZfailBack !== zfail || this.stencilZpassBack !== zpass) {\n\t\t\tthis.gl.stencilOpSeparate(this.gl.BACK, this.glStencilOp[fail], this.glStencilOp[zfail], this.glStencilOp[zpass]);\n\t\t\tthis.stencilFailBack = fail;\n\t\t\tthis.stencilZfailBack = zfail;\n\t\t\tthis.stencilZpassBack = zpass;\n\t\t}\n\t\tif (this.stencilWriteMaskBack !== writeMask) {\n\t\t\tthis.gl.stencilMaskSeparate(this.gl.BACK, writeMask);\n\t\t\tthis.stencilWriteMaskBack = writeMask;\n\t\t}\n\t}\n\tsetBlendState(blendState) {\n\t\tconst currentBlendState = this.blendState;\n\t\tif (!currentBlendState.equals(blendState)) {\n\t\t\tconst gl = this.gl;\n\t\t\tconst {\n\t\t\t\tblend,\n\t\t\t\tcolorOp,\n\t\t\t\talphaOp,\n\t\t\t\tcolorSrcFactor,\n\t\t\t\tcolorDstFactor,\n\t\t\t\talphaSrcFactor,\n\t\t\t\talphaDstFactor\n\t\t\t} = blendState;\n\t\t\tif (currentBlendState.blend !== blend) {\n\t\t\t\tif (blend) {\n\t\t\t\t\tgl.enable(gl.BLEND);\n\t\t\t\t} else {\n\t\t\t\t\tgl.disable(gl.BLEND);\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (currentBlendState.colorOp !== colorOp || currentBlendState.alphaOp !== alphaOp) {\n\t\t\t\tconst glBlendEquation = this.glBlendEquation;\n\t\t\t\tgl.blendEquationSeparate(glBlendEquation[colorOp], glBlendEquation[alphaOp]);\n\t\t\t}\n\t\t\tif (currentBlendState.colorSrcFactor !== colorSrcFactor || currentBlendState.colorDstFactor !== colorDstFactor || currentBlendState.alphaSrcFactor !== alphaSrcFactor || currentBlendState.alphaDstFactor !== alphaDstFactor) {\n\t\t\t\tgl.blendFuncSeparate(this.glBlendFunctionColor[colorSrcFactor], this.glBlendFunctionColor[colorDstFactor], this.glBlendFunctionAlpha[alphaSrcFactor], this.glBlendFunctionAlpha[alphaDstFactor]);\n\t\t\t}\n\t\t\tif (currentBlendState.allWrite !== blendState.allWrite) {\n\t\t\t\tthis.gl.colorMask(blendState.redWrite, blendState.greenWrite, blendState.blueWrite, blendState.alphaWrite);\n\t\t\t}\n\t\t\tcurrentBlendState.copy(blendState);\n\t\t}\n\t}\n\tsetBlendColor(r, g, b, a) {\n\t\tconst c = this.blendColor;\n\t\tif (r !== c.r || g !== c.g || b !== c.b || a !== c.a) {\n\t\t\tthis.gl.blendColor(r, g, b, a);\n\t\t\tc.set(r, g, b, a);\n\t\t}\n\t}\n\tsetStencilState(stencilFront, stencilBack) {\n\t\tif (stencilFront || stencilBack) {\n\t\t\tthis.setStencilTest(true);\n\t\t\tif (stencilFront === stencilBack) {\n\t\t\t\tthis.setStencilFunc(stencilFront.func, stencilFront.ref, stencilFront.readMask);\n\t\t\t\tthis.setStencilOperation(stencilFront.fail, stencilFront.zfail, stencilFront.zpass, stencilFront.writeMask);\n\t\t\t} else {\n\t\t\t\tvar _stencilFront, _stencilBack;\n\t\t\t\t(_stencilFront = stencilFront) != null ? _stencilFront : stencilFront = StencilParameters.DEFAULT;\n\t\t\t\tthis.setStencilFuncFront(stencilFront.func, stencilFront.ref, stencilFront.readMask);\n\t\t\t\tthis.setStencilOperationFront(stencilFront.fail, stencilFront.zfail, stencilFront.zpass, stencilFront.writeMask);\n\t\t\t\t(_stencilBack = stencilBack) != null ? _stencilBack : stencilBack = StencilParameters.DEFAULT;\n\t\t\t\tthis.setStencilFuncBack(stencilBack.func, stencilBack.ref, stencilBack.readMask);\n\t\t\t\tthis.setStencilOperationBack(stencilBack.fail, stencilBack.zfail, stencilBack.zpass, stencilBack.writeMask);\n\t\t\t}\n\t\t} else {\n\t\t\tthis.setStencilTest(false);\n\t\t}\n\t}\n\tsetDepthState(depthState) {\n\t\tconst currentDepthState = this.depthState;\n\t\tif (!currentDepthState.equals(depthState)) {\n\t\t\tconst gl = this.gl;\n\t\t\tconst write = depthState.write;\n\t\t\tif (currentDepthState.write !== write) {\n\t\t\t\tgl.depthMask(write);\n\t\t\t}\n\t\t\tlet {\n\t\t\t\tfunc,\n\t\t\t\ttest\n\t\t\t} = depthState;\n\t\t\tif (!test && write) {\n\t\t\t\ttest = true;\n\t\t\t\tfunc = FUNC_ALWAYS;\n\t\t\t}\n\t\t\tif (currentDepthState.func !== func) {\n\t\t\t\tgl.depthFunc(this.glComparison[func]);\n\t\t\t}\n\t\t\tif (currentDepthState.test !== test) {\n\t\t\t\tif (test) {\n\t\t\t\t\tgl.enable(gl.DEPTH_TEST);\n\t\t\t\t} else {\n\t\t\t\t\tgl.disable(gl.DEPTH_TEST);\n\t\t\t\t}\n\t\t\t}\n\t\t\tconst {\n\t\t\t\tdepthBias,\n\t\t\t\tdepthBiasSlope\n\t\t\t} = depthState;\n\t\t\tif (depthBias || depthBiasSlope) {\n\t\t\t\tif (!this.depthBiasEnabled) {\n\t\t\t\t\tthis.depthBiasEnabled = true;\n\t\t\t\t\tthis.gl.enable(this.gl.POLYGON_OFFSET_FILL);\n\t\t\t\t}\n\t\t\t\tgl.polygonOffset(depthBiasSlope, depthBias);\n\t\t\t} else {\n\t\t\t\tif (this.depthBiasEnabled) {\n\t\t\t\t\tthis.depthBiasEnabled = false;\n\t\t\t\t\tthis.gl.disable(this.gl.POLYGON_OFFSET_FILL);\n\t\t\t\t}\n\t\t\t}\n\t\t\tcurrentDepthState.copy(depthState);\n\t\t}\n\t}\n\tsetCullMode(cullMode) {\n\t\tif (this.cullMode !== cullMode) {\n\t\t\tif (cullMode === CULLFACE_NONE) {\n\t\t\t\tthis.gl.disable(this.gl.CULL_FACE);\n\t\t\t} else {\n\t\t\t\tif (this.cullMode === CULLFACE_NONE) {\n\t\t\t\t\tthis.gl.enable(this.gl.CULL_FACE);\n\t\t\t\t}\n\t\t\t\tconst mode = this.glCull[cullMode];\n\t\t\t\tif (this.cullFace !== mode) {\n\t\t\t\t\tthis.gl.cullFace(mode);\n\t\t\t\t\tthis.cullFace = mode;\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis.cullMode = cullMode;\n\t\t}\n\t}\n\tsetShader(shader, asyncCompile = false) {\n\t\tif (shader !== this.shader) {\n\t\t\tthis.shader = shader;\n\t\t\tthis.shaderAsyncCompile = asyncCompile;\n\t\t\tthis.shaderValid = undefined;\n\t\t}\n\t}\n\tactivateShader(device) {\n\t\tconst {\n\t\t\tshader\n\t\t} = this;\n\t\tconst {\n\t\t\timpl\n\t\t} = shader;\n\t\tif (this.shaderValid === undefined) {\n\t\t\tif (shader.failed) {\n\t\t\t\tthis.shaderValid = false;\n\t\t\t} else if (!shader.ready) {\n\t\t\t\tif (this.shaderAsyncCompile) {\n\t\t\t\t\tif (impl.isLinked(device)) {\n\t\t\t\t\t\tif (!impl.finalize(this, shader)) {\n\t\t\t\t\t\t\tshader.failed = true;\n\t\t\t\t\t\t\tthis.shaderValid = false;\n\t\t\t\t\t\t}\n\t\t\t\t\t} else {\n\t\t\t\t\t\tthis.shaderValid = false;\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tif (!impl.finalize(this, shader)) {\n\t\t\t\t\t\tshader.failed = true;\n\t\t\t\t\t\tthis.shaderValid = false;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (this.shaderValid === undefined) {\n\t\t\tthis.gl.useProgram(impl.glProgram);\n\t\t\tthis.shaderValid = true;\n\t\t}\n\t}\n\tclearVertexArrayObjectCache() {\n\t\tconst gl = this.gl;\n\t\tthis._vaoMap.forEach((item, key, mapObj) => {\n\t\t\tgl.deleteVertexArray(item);\n\t\t});\n\t\tthis._vaoMap.clear();\n\t}\n\tset fullscreen(fullscreen) {\n\t\tif (fullscreen) {\n\t\t\tconst canvas = this.gl.canvas;\n\t\t\tcanvas.requestFullscreen();\n\t\t} else {\n\t\t\tdocument.exitFullscreen();\n\t\t}\n\t}\n\tget fullscreen() {\n\t\treturn !!document.fullscreenElement;\n\t}\n\tget textureFloatHighPrecision() {\n\t\tif (this._textureFloatHighPrecision === undefined) {\n\t\t\tthis._textureFloatHighPrecision = testTextureFloatHighPrecision(this);\n\t\t}\n\t\treturn this._textureFloatHighPrecision;\n\t}\n\tget textureHalfFloatUpdatable() {\n\t\tif (this._textureHalfFloatUpdatable === undefined) {\n\t\t\tif (this.isWebGL2) {\n\t\t\t\tthis._textureHalfFloatUpdatable = true;\n\t\t\t} else {\n\t\t\t\tthis._textureHalfFloatUpdatable = testTextureHalfFloatUpdatable(this.gl, this.extTextureHalfFloat.HALF_FLOAT_OES);\n\t\t\t}\n\t\t}\n\t\treturn this._textureHalfFloatUpdatable;\n\t}\n}\n\nexport { WebglGraphicsDevice };\n", "class NullIndexBuffer {\n\tunlock(indexBuffer) {}\n}\n\nexport { NullIndexBuffer };\n", "class NullRenderTarget {\n\tdestroy(device) {}\n\tinit(device, renderTarget) {}\n\tloseContext() {}\n\tresolve(device, target, color, depth) {}\n}\n\nexport { NullRenderTarget };\n", "class NullShader {\n\tdestroy(shader) {}\n\tloseContext() {}\n\trestoreContext(device, shader) {}\n}\n\nexport { NullShader };\n", "class NullTexture {\n\tdestroy(device) {}\n\tpropertyChanged(flag) {}\n\tloseContext() {}\n}\n\nexport { NullTexture };\n", "class NullVertexBuffer {\n\tdestroy(device) {}\n\tunlock(vertexBuffer) {}\n}\n\nexport { NullVertexBuffer };\n", "import { DEVICETYPE_NULL, PIXELFORMAT_RGBA8 } from '../constants.js';\nimport { GraphicsDevice } from '../graphics-device.js';\nimport { NullIndexBuffer } from './null-index-buffer.js';\nimport { NullRenderTarget } from './null-render-target.js';\nimport { NullShader } from './null-shader.js';\nimport { NullTexture } from './null-texture.js';\nimport { NullVertexBuffer } from './null-vertex-buffer.js';\n\nclass NullGraphicsDevice extends GraphicsDevice {\n\tconstructor(canvas, options = {}) {\n\t\tsuper(canvas, options);\n\t\toptions = this.initOptions;\n\t\tthis.isNull = true;\n\t\tthis._deviceType = DEVICETYPE_NULL;\n\t\tthis.samples = 1;\n\t}\n\tdestroy() {\n\t\tsuper.destroy();\n\t}\n\tinitDeviceCaps() {\n\t\tthis.disableParticleSystem = true;\n\t\tthis.precision = 'highp';\n\t\tthis.maxPrecision = 'highp';\n\t\tthis.maxSamples = 4;\n\t\tthis.maxTextures = 16;\n\t\tthis.maxTextureSize = 4096;\n\t\tthis.maxCubeMapSize = 4096;\n\t\tthis.maxVolumeSize = 4096;\n\t\tthis.maxColorAttachments = 8;\n\t\tthis.maxPixelRatio = 1;\n\t\tthis.maxAnisotropy = 16;\n\t\tthis.supportsInstancing = true;\n\t\tthis.supportsUniformBuffers = false;\n\t\tthis.supportsVolumeTextures = true;\n\t\tthis.supportsBoneTextures = true;\n\t\tthis.supportsMorphTargetTexturesCore = true;\n\t\tthis.supportsAreaLights = true;\n\t\tthis.supportsDepthShadow = true;\n\t\tthis.supportsGpuParticles = false;\n\t\tthis.supportsMrt = true;\n\t\tthis.extUintElement = true;\n\t\tthis.extTextureFloat = true;\n\t\tthis.textureFloatRenderable = true;\n\t\tthis.extTextureHalfFloat = true;\n\t\tthis.textureHalfFloatRenderable = true;\n\t\tthis.textureHalfFloatUpdatable = true;\n\t\tthis.boneLimit = 1024;\n\t\tthis.supportsImageBitmap = true;\n\t\tthis.extStandardDerivatives = true;\n\t\tthis.extBlendMinmax = true;\n\t\tthis.areaLightLutFormat = PIXELFORMAT_RGBA8;\n\t\tthis.supportsTextureFetch = true;\n\t}\n\tpostInit() {\n\t\tsuper.postInit();\n\t}\n\tframeStart() {\n\t\tsuper.frameStart();\n\t}\n\tframeEnd() {\n\t\tsuper.frameEnd();\n\t}\n\tupdateBegin() {}\n\tupdateEnd() {}\n\treadPixels(x, y, w, h, pixels) {}\n\tcreateVertexBufferImpl(vertexBuffer, format) {\n\t\treturn new NullVertexBuffer(vertexBuffer, format);\n\t}\n\tcreateIndexBufferImpl(indexBuffer) {\n\t\treturn new NullIndexBuffer(indexBuffer);\n\t}\n\tcreateShaderImpl(shader) {\n\t\treturn new NullShader(shader);\n\t}\n\tcreateTextureImpl(texture) {\n\t\treturn new NullTexture(texture);\n\t}\n\tcreateRenderTargetImpl(renderTarget) {\n\t\treturn new NullRenderTarget(renderTarget);\n\t}\n\tdraw(primitive, numInstances = 1, keepBuffers) {}\n\tsetShader(shader, asyncCompile = false) {}\n\tsetBlendState(blendState) {}\n\tsetDepthState(depthState) {}\n\tsetStencilState(stencilFront, stencilBack) {}\n\tsetBlendColor(r, g, b, a) {}\n\tsetCullMode(cullMode) {}\n\tsetAlphaToCoverage(state) {}\n\tinitializeContextCaches() {\n\t\tsuper.initializeContextCaches();\n\t}\n\tclear(options) {}\n\tsetViewport(x, y, w, h) {}\n\tsetScissor(x, y, w, h) {}\n\tcopyRenderTarget(source, dest, color, depth) {\n\t\treturn true;\n\t}\n}\n\nexport { NullGraphicsDevice };\n", "import { platform } from '../../core/platform.js';\nimport { DEVICETYPE_WEBGL2, DEVICETYPE_WEBGL1, DEVICETYPE_NULL, DEVICETYPE_WEBGPU } from './constants.js';\nimport { WebgpuGraphicsDevice } from './webgpu/webgpu-graphics-device.js';\nimport { WebglGraphicsDevice } from './webgl/webgl-graphics-device.js';\nimport { NullGraphicsDevice } from './null/null-graphics-device.js';\n\nfunction createGraphicsDevice(canvas, options = {}) {\n\tvar _options$deviceTypes;\n\tconst deviceTypes = (_options$deviceTypes = options.deviceTypes) != null ? _options$deviceTypes : [];\n\tif (!deviceTypes.includes(DEVICETYPE_WEBGL2)) {\n\t\tdeviceTypes.push(DEVICETYPE_WEBGL2);\n\t}\n\tif (!deviceTypes.includes(DEVICETYPE_WEBGL1)) {\n\t\tdeviceTypes.push(DEVICETYPE_WEBGL1);\n\t}\n\tif (!deviceTypes.includes(DEVICETYPE_NULL)) {\n\t\tdeviceTypes.push(DEVICETYPE_NULL);\n\t}\n\tif (platform.browser && !!navigator.xr) {\n\t\tvar _options$xrCompatible;\n\t\t(_options$xrCompatible = options.xrCompatible) != null ? _options$xrCompatible : options.xrCompatible = true;\n\t}\n\tconst deviceCreateFuncs = [];\n\tfor (let i = 0; i < deviceTypes.length; i++) {\n\t\tvar _window;\n\t\tconst deviceType = deviceTypes[i];\n\t\tif (deviceType === DEVICETYPE_WEBGPU && (_window = window) != null && (_window = _window.navigator) != null && _window.gpu) {\n\t\t\tdeviceCreateFuncs.push(() => {\n\t\t\t\tconst device = new WebgpuGraphicsDevice(canvas, options);\n\t\t\t\treturn device.initWebGpu(options.glslangUrl, options.twgslUrl);\n\t\t\t});\n\t\t}\n\t\tif (deviceType === DEVICETYPE_WEBGL1 || deviceType === DEVICETYPE_WEBGL2) {\n\t\t\tdeviceCreateFuncs.push(() => {\n\t\t\t\toptions.preferWebGl2 = deviceType === DEVICETYPE_WEBGL2;\n\t\t\t\treturn new WebglGraphicsDevice(canvas, options);\n\t\t\t});\n\t\t}\n\t\tif (deviceType === DEVICETYPE_NULL) {\n\t\t\tdeviceCreateFuncs.push(() => {\n\t\t\t\treturn new NullGraphicsDevice(canvas, options);\n\t\t\t});\n\t\t}\n\t}\n\treturn new Promise((resolve, reject) => {\n\t\tlet attempt = 0;\n\t\tconst next = () => {\n\t\t\tif (attempt >= deviceCreateFuncs.length) {\n\t\t\t\treject(new Error('Failed to create a graphics device'));\n\t\t\t} else {\n\t\t\t\tPromise.resolve(deviceCreateFuncs[attempt++]()).then(device => {\n\t\t\t\t\tif (device) {\n\t\t\t\t\t\tresolve(device);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tnext();\n\t\t\t\t\t}\n\t\t\t\t}).catch(err => {\n\t\t\t\t\tconsole.log(err);\n\t\t\t\t\tnext();\n\t\t\t\t});\n\t\t\t}\n\t\t};\n\t\tnext();\n\t});\n}\n\nexport { createGraphicsDevice };\n", "import { typedArrayIndexFormatsByteSize, BUFFER_STATIC, INDEXFORMAT_UINT32, INDEXFORMAT_UINT16 } from './constants.js';\n\nlet id = 0;\nclass IndexBuffer {\n\tconstructor(graphicsDevice, format, numIndices, usage = BUFFER_STATIC, initialData, options) {\n\t\tthis.device = graphicsDevice;\n\t\tthis.format = format;\n\t\tthis.numIndices = numIndices;\n\t\tthis.usage = usage;\n\t\tthis.id = id++;\n\t\tthis.impl = graphicsDevice.createIndexBufferImpl(this, options);\n\t\tconst bytesPerIndex = typedArrayIndexFormatsByteSize[format];\n\t\tthis.bytesPerIndex = bytesPerIndex;\n\t\tthis.numBytes = this.numIndices * bytesPerIndex;\n\t\tif (initialData) {\n\t\t\tthis.setData(initialData);\n\t\t} else {\n\t\t\tthis.storage = new ArrayBuffer(this.numBytes);\n\t\t}\n\t\tthis.adjustVramSizeTracking(graphicsDevice._vram, this.numBytes);\n\t\tthis.device.buffers.push(this);\n\t}\n\tdestroy() {\n\t\tconst device = this.device;\n\t\tconst idx = device.buffers.indexOf(this);\n\t\tif (idx !== -1) {\n\t\t\tdevice.buffers.splice(idx, 1);\n\t\t}\n\t\tif (this.device.indexBuffer === this) {\n\t\t\tthis.device.indexBuffer = null;\n\t\t}\n\t\tif (this.impl.initialized) {\n\t\t\tthis.impl.destroy(device);\n\t\t\tthis.adjustVramSizeTracking(device._vram, -this.storage.byteLength);\n\t\t}\n\t}\n\tadjustVramSizeTracking(vram, size) {\n\t\tvram.ib += size;\n\t}\n\tloseContext() {\n\t\tthis.impl.loseContext();\n\t}\n\tgetFormat() {\n\t\treturn this.format;\n\t}\n\tgetNumIndices() {\n\t\treturn this.numIndices;\n\t}\n\tlock() {\n\t\treturn this.storage;\n\t}\n\tunlock() {\n\t\tthis.impl.unlock(this);\n\t}\n\tsetData(data) {\n\t\tif (data.byteLength !== this.numBytes) {\n\t\t\treturn false;\n\t\t}\n\t\tthis.storage = data;\n\t\tthis.unlock();\n\t\treturn true;\n\t}\n\t_lockTypedArray() {\n\t\tconst lock = this.lock();\n\t\tconst indices = this.format === INDEXFORMAT_UINT32 ? new Uint32Array(lock) : this.format === INDEXFORMAT_UINT16 ? new Uint16Array(lock) : new Uint8Array(lock);\n\t\treturn indices;\n\t}\n\twriteData(data, count) {\n\t\tconst indices = this._lockTypedArray();\n\t\tif (data.length > count) {\n\t\t\tif (ArrayBuffer.isView(data)) {\n\t\t\t\tdata = data.subarray(0, count);\n\t\t\t\tindices.set(data);\n\t\t\t} else {\n\t\t\t\tfor (let i = 0; i < count; i++) indices[i] = data[i];\n\t\t\t}\n\t\t} else {\n\t\t\tindices.set(data);\n\t\t}\n\t\tthis.unlock();\n\t}\n\treadData(data) {\n\t\tconst indices = this._lockTypedArray();\n\t\tconst count = this.numIndices;\n\t\tif (ArrayBuffer.isView(data)) {\n\t\t\tdata.set(indices);\n\t\t} else {\n\t\t\tdata.length = 0;\n\t\t\tfor (let i = 0; i < count; i++) data[i] = indices[i];\n\t\t}\n\t\treturn count;\n\t}\n}\n\nexport { IndexBuffer };\n", "import { Color } from '../../core/math/color.js';\n\nclass ColorAttachmentOps {\n\tconstructor() {\n\t\tthis.clearValue = new Color(0, 0, 0, 1);\n\t\tthis.clear = false;\n\t\tthis.store = false;\n\t\tthis.resolve = true;\n\t\tthis.mipmaps = false;\n\t}\n}\nclass DepthStencilAttachmentOps {\n\tconstructor() {\n\t\tthis.clearDepthValue = 1;\n\t\tthis.clearStencilValue = 0;\n\t\tthis.clearDepth = false;\n\t\tthis.clearStencil = false;\n\t\tthis.storeDepth = false;\n\t\tthis.storeStencil = false;\n\t}\n}\nclass RenderPass {\n\tget colorOps() {\n\t\treturn this.colorArrayOps[0];\n\t}\n\tconstructor(graphicsDevice) {\n\t\tthis._name = void 0;\n\t\tthis.device = void 0;\n\t\tthis._enabled = true;\n\t\tthis.executeEnabled = true;\n\t\tthis.renderTarget = void 0;\n\t\tthis._options = void 0;\n\t\tthis.samples = 0;\n\t\tthis.colorArrayOps = [];\n\t\tthis.depthStencilOps = void 0;\n\t\tthis.requiresCubemaps = true;\n\t\tthis.fullSizeClearRect = true;\n\t\tthis.beforePasses = [];\n\t\tthis.afterPasses = [];\n\t\tthis.device = graphicsDevice;\n\t}\n\tset name(value) {\n\t\tthis._name = value;\n\t}\n\tget name() {\n\t\tif (!this._name) this._name = this.constructor.name;\n\t\treturn this._name;\n\t}\n\tset options(value) {\n\t\tthis._options = value;\n\t\tif (value) {\n\t\t\tvar _this$_options$scaleX, _this$_options$scaleY;\n\t\t\tthis._options.scaleX = (_this$_options$scaleX = this._options.scaleX) != null ? _this$_options$scaleX : 1;\n\t\t\tthis._options.scaleY = (_this$_options$scaleY = this._options.scaleY) != null ? _this$_options$scaleY : 1;\n\t\t}\n\t}\n\tget options() {\n\t\treturn this._options;\n\t}\n\tinit(renderTarget = null, options = null) {\n\t\tvar _renderTarget$_colorB;\n\t\tthis.options = options;\n\t\tthis.renderTarget = renderTarget;\n\t\tthis.samples = Math.max(this.renderTarget ? this.renderTarget.samples : this.device.samples, 1);\n\t\tthis.depthStencilOps = new DepthStencilAttachmentOps();\n\t\tconst numColorOps = renderTarget ? (_renderTarget$_colorB = renderTarget._colorBuffers) == null ? void 0 : _renderTarget$_colorB.length : 1;\n\t\tthis.colorArrayOps.length = 0;\n\t\tfor (let i = 0; i < numColorOps; i++) {\n\t\t\tvar _this$renderTarget;\n\t\t\tconst colorOps = new ColorAttachmentOps();\n\t\t\tthis.colorArrayOps[i] = colorOps;\n\t\t\tif (this.samples === 1) {\n\t\t\t\tcolorOps.store = true;\n\t\t\t\tcolorOps.resolve = false;\n\t\t\t}\n\t\t\tif ((_this$renderTarget = this.renderTarget) != null && (_this$renderTarget = _this$renderTarget._colorBuffers) != null && _this$renderTarget[i].mipmaps) {\n\t\t\t\tcolorOps.mipmaps = true;\n\t\t\t}\n\t\t}\n\t\tthis.postInit();\n\t}\n\tdestroy() {}\n\tpostInit() {}\n\tframeUpdate() {\n\t\tif (this._options && this.renderTarget) {\n\t\t\tvar _this$_options$resize;\n\t\t\tconst resizeSource = (_this$_options$resize = this._options.resizeSource) != null ? _this$_options$resize : this.device.backBuffer;\n\t\t\tconst width = Math.floor(resizeSource.width * this._options.scaleX);\n\t\t\tconst height = Math.floor(resizeSource.height * this._options.scaleY);\n\t\t\tthis.renderTarget.resize(width, height);\n\t\t}\n\t}\n\tbefore() {}\n\texecute() {}\n\tafter() {}\n\tonEnable() {}\n\tonDisable() {}\n\tset enabled(value) {\n\t\tif (this._enabled !== value) {\n\t\t\tthis._enabled = value;\n\t\t\tif (value) {\n\t\t\t\tthis.onEnable();\n\t\t\t} else {\n\t\t\t\tthis.onDisable();\n\t\t\t}\n\t\t}\n\t}\n\tget enabled() {\n\t\treturn this._enabled;\n\t}\n\tsetClearColor(color) {\n\t\tconst count = this.colorArrayOps.length;\n\t\tfor (let i = 0; i < count; i++) {\n\t\t\tconst colorOps = this.colorArrayOps[i];\n\t\t\tif (color) colorOps.clearValue.copy(color);\n\t\t\tcolorOps.clear = !!color;\n\t\t}\n\t}\n\tsetClearDepth(depthValue) {\n\t\tif (depthValue) this.depthStencilOps.clearDepthValue = depthValue;\n\t\tthis.depthStencilOps.clearDepth = depthValue !== undefined;\n\t}\n\tsetClearStencil(stencilValue) {\n\t\tif (stencilValue) this.depthStencilOps.clearStencilValue = stencilValue;\n\t\tthis.depthStencilOps.clearStencil = stencilValue !== undefined;\n\t}\n\trender() {\n\t\tif (this.enabled) {\n\t\t\tconst device = this.device;\n\t\t\tconst realPass = this.renderTarget !== undefined;\n\t\t\tthis.before();\n\t\t\tif (this.executeEnabled) {\n\t\t\t\tif (realPass) {\n\t\t\t\t\tdevice.startRenderPass(this);\n\t\t\t\t}\n\t\t\t\tthis.execute();\n\t\t\t\tif (realPass) {\n\t\t\t\t\tdevice.endRenderPass(this);\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis.after();\n\t\t\tdevice.renderPassIndex++;\n\t\t}\n\t}\n}\n\nexport { ColorAttachmentOps, DepthStencilAttachmentOps, RenderPass };\n", "import { BINDGROUP_VIEW } from './constants.js';\n\nclass ShaderProcessorOptions {\n\tconstructor(viewUniformFormat, viewBindGroupFormat, vertexFormat) {\n\t\tthis.uniformFormats = [];\n\t\tthis.bindGroupFormats = [];\n\t\tthis.vertexFormat = void 0;\n\t\tthis.uniformFormats[BINDGROUP_VIEW] = viewUniformFormat;\n\t\tthis.bindGroupFormats[BINDGROUP_VIEW] = viewBindGroupFormat;\n\t\tthis.vertexFormat = vertexFormat;\n\t}\n\thasUniform(name) {\n\t\tfor (let i = 0; i < this.uniformFormats.length; i++) {\n\t\t\tconst uniformFormat = this.uniformFormats[i];\n\t\t\tif (uniformFormat != null && uniformFormat.get(name)) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\t\treturn false;\n\t}\n\thasTexture(name) {\n\t\tfor (let i = 0; i < this.bindGroupFormats.length; i++) {\n\t\t\tconst groupFormat = this.bindGroupFormats[i];\n\t\t\tif (groupFormat != null && groupFormat.getTexture(name)) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\t\treturn false;\n\t}\n\tgetVertexElement(semantic) {\n\t\tvar _this$vertexFormat;\n\t\treturn (_this$vertexFormat = this.vertexFormat) == null ? void 0 : _this$vertexFormat.elements.find(element => element.name === semantic);\n\t}\n\tgenerateKey(device) {\n\t\tlet key = JSON.stringify(this.uniformFormats) + JSON.stringify(this.bindGroupFormats);\n\t\tif (device.isWebGPU) {\n\t\t\tvar _this$vertexFormat2;\n\t\t\tkey += (_this$vertexFormat2 = this.vertexFormat) == null ? void 0 : _this$vertexFormat2.shaderProcessingHashString;\n\t\t}\n\t\treturn key;\n\t}\n}\n\nexport { ShaderProcessorOptions };\n", "import { typedArrayTypes } from './constants.js';\n\nfunction set1(a) {\n\tthis.array[this.index] = a;\n}\nfunction set2(a, b) {\n\tthis.array[this.index] = a;\n\tthis.array[this.index + 1] = b;\n}\nfunction set3(a, b, c) {\n\tthis.array[this.index] = a;\n\tthis.array[this.index + 1] = b;\n\tthis.array[this.index + 2] = c;\n}\nfunction set4(a, b, c, d) {\n\tthis.array[this.index] = a;\n\tthis.array[this.index + 1] = b;\n\tthis.array[this.index + 2] = c;\n\tthis.array[this.index + 3] = d;\n}\nfunction arraySet1(index, inputArray, inputIndex) {\n\tthis.array[index] = inputArray[inputIndex];\n}\nfunction arraySet2(index, inputArray, inputIndex) {\n\tthis.array[index] = inputArray[inputIndex];\n\tthis.array[index + 1] = inputArray[inputIndex + 1];\n}\nfunction arraySet3(index, inputArray, inputIndex) {\n\tthis.array[index] = inputArray[inputIndex];\n\tthis.array[index + 1] = inputArray[inputIndex + 1];\n\tthis.array[index + 2] = inputArray[inputIndex + 2];\n}\nfunction arraySet4(index, inputArray, inputIndex) {\n\tthis.array[index] = inputArray[inputIndex];\n\tthis.array[index + 1] = inputArray[inputIndex + 1];\n\tthis.array[index + 2] = inputArray[inputIndex + 2];\n\tthis.array[index + 3] = inputArray[inputIndex + 3];\n}\nfunction arrayGet1(offset, outputArray, outputIndex) {\n\toutputArray[outputIndex] = this.array[offset];\n}\nfunction arrayGet2(offset, outputArray, outputIndex) {\n\toutputArray[outputIndex] = this.array[offset];\n\toutputArray[outputIndex + 1] = this.array[offset + 1];\n}\nfunction arrayGet3(offset, outputArray, outputIndex) {\n\toutputArray[outputIndex] = this.array[offset];\n\toutputArray[outputIndex + 1] = this.array[offset + 1];\n\toutputArray[outputIndex + 2] = this.array[offset + 2];\n}\nfunction arrayGet4(offset, outputArray, outputIndex) {\n\toutputArray[outputIndex] = this.array[offset];\n\toutputArray[outputIndex + 1] = this.array[offset + 1];\n\toutputArray[outputIndex + 2] = this.array[offset + 2];\n\toutputArray[outputIndex + 3] = this.array[offset + 3];\n}\nclass VertexIteratorAccessor {\n\tconstructor(buffer, vertexElement, vertexFormat) {\n\t\tthis.index = 0;\n\t\tthis.numComponents = vertexElement.numComponents;\n\t\tif (vertexFormat.interleaved) {\n\t\t\tthis.array = new typedArrayTypes[vertexElement.dataType](buffer, vertexElement.offset);\n\t\t} else {\n\t\t\tthis.array = new typedArrayTypes[vertexElement.dataType](buffer, vertexElement.offset, vertexFormat.vertexCount * vertexElement.numComponents);\n\t\t}\n\t\tthis.stride = vertexElement.stride / this.array.constructor.BYTES_PER_ELEMENT;\n\t\tswitch (vertexElement.numComponents) {\n\t\t\tcase 1:\n\t\t\t\tthis.set = set1;\n\t\t\t\tthis.getToArray = arrayGet1;\n\t\t\t\tthis.setFromArray = arraySet1;\n\t\t\t\tbreak;\n\t\t\tcase 2:\n\t\t\t\tthis.set = set2;\n\t\t\t\tthis.getToArray = arrayGet2;\n\t\t\t\tthis.setFromArray = arraySet2;\n\t\t\t\tbreak;\n\t\t\tcase 3:\n\t\t\t\tthis.set = set3;\n\t\t\t\tthis.getToArray = arrayGet3;\n\t\t\t\tthis.setFromArray = arraySet3;\n\t\t\t\tbreak;\n\t\t\tcase 4:\n\t\t\t\tthis.set = set4;\n\t\t\t\tthis.getToArray = arrayGet4;\n\t\t\t\tthis.setFromArray = arraySet4;\n\t\t\t\tbreak;\n\t\t}\n\t}\n\tget(offset) {\n\t\treturn this.array[this.index + offset];\n\t}\n\tset(a, b, c, d) {}\n\tgetToArray(offset, outputArray, outputIndex) {}\n\tsetFromArray(index, inputArray, inputIndex) {}\n}\nclass VertexIterator {\n\tconstructor(vertexBuffer) {\n\t\tthis.vertexBuffer = vertexBuffer;\n\t\tthis.vertexFormatSize = vertexBuffer.getFormat().size;\n\t\tthis.buffer = this.vertexBuffer.lock();\n\t\tthis.accessors = [];\n\t\tthis.element = {};\n\t\tconst vertexFormat = this.vertexBuffer.getFormat();\n\t\tfor (let i = 0; i < vertexFormat.elements.length; i++) {\n\t\t\tconst vertexElement = vertexFormat.elements[i];\n\t\t\tthis.accessors[i] = new VertexIteratorAccessor(this.buffer, vertexElement, vertexFormat);\n\t\t\tthis.element[vertexElement.name] = this.accessors[i];\n\t\t}\n\t}\n\tnext(count = 1) {\n\t\tlet i = 0;\n\t\tconst accessors = this.accessors;\n\t\tconst numAccessors = this.accessors.length;\n\t\twhile (i < numAccessors) {\n\t\t\tconst accessor = accessors[i++];\n\t\t\taccessor.index += count * accessor.stride;\n\t\t}\n\t}\n\tend() {\n\t\tthis.vertexBuffer.unlock();\n\t}\n\twriteData(semantic, data, numVertices) {\n\t\tconst element = this.element[semantic];\n\t\tif (element) {\n\t\t\tif (numVertices > this.vertexBuffer.numVertices) {\n\t\t\t\tnumVertices = this.vertexBuffer.numVertices;\n\t\t\t}\n\t\t\tconst numComponents = element.numComponents;\n\t\t\tif (this.vertexBuffer.getFormat().interleaved) {\n\t\t\t\tlet index = 0;\n\t\t\t\tfor (let i = 0; i < numVertices; i++) {\n\t\t\t\t\telement.setFromArray(index, data, i * numComponents);\n\t\t\t\t\tindex += element.stride;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tif (data.length > numVertices * numComponents) {\n\t\t\t\t\tconst copyCount = numVertices * numComponents;\n\t\t\t\t\tif (ArrayBuffer.isView(data)) {\n\t\t\t\t\t\tdata = data.subarray(0, copyCount);\n\t\t\t\t\t\telement.array.set(data);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tfor (let i = 0; i < copyCount; i++) element.array[i] = data[i];\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\telement.array.set(data);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\treadData(semantic, data) {\n\t\tconst element = this.element[semantic];\n\t\tlet count = 0;\n\t\tif (element) {\n\t\t\tcount = this.vertexBuffer.numVertices;\n\t\t\tlet i;\n\t\t\tconst numComponents = element.numComponents;\n\t\t\tif (this.vertexBuffer.getFormat().interleaved) {\n\t\t\t\tif (Array.isArray(data)) data.length = 0;\n\t\t\t\telement.index = 0;\n\t\t\t\tlet offset = 0;\n\t\t\t\tfor (i = 0; i < count; i++) {\n\t\t\t\t\telement.getToArray(offset, data, i * numComponents);\n\t\t\t\t\toffset += element.stride;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tif (ArrayBuffer.isView(data)) {\n\t\t\t\t\tdata.set(element.array);\n\t\t\t\t} else {\n\t\t\t\t\tdata.length = 0;\n\t\t\t\t\tconst copyCount = count * numComponents;\n\t\t\t\t\tfor (i = 0; i < copyCount; i++) data[i] = element.array[i];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn count;\n\t}\n}\n\nexport { VertexIterator, VertexIteratorAccessor };\n", "const ACTION_MOUSE = 'mouse';\nconst ACTION_KEYBOARD = 'keyboard';\nconst ACTION_GAMEPAD = 'gamepad';\nconst AXIS_MOUSE_X = 'mousex';\nconst AXIS_MOUSE_Y = 'mousey';\nconst AXIS_PAD_L_X = 'padlx';\nconst AXIS_PAD_L_Y = 'padly';\nconst AXIS_PAD_R_X = 'padrx';\nconst AXIS_PAD_R_Y = 'padry';\nconst AXIS_KEY = 'key';\nconst EVENT_KEYDOWN = 'keydown';\nconst EVENT_KEYUP = 'keyup';\nconst EVENT_MOUSEDOWN = 'mousedown';\nconst EVENT_MOUSEMOVE = 'mousemove';\nconst EVENT_MOUSEUP = 'mouseup';\nconst EVENT_MOUSEWHEEL = 'mousewheel';\nconst EVENT_TOUCHSTART = 'touchstart';\nconst EVENT_TOUCHEND = 'touchend';\nconst EVENT_TOUCHMOVE = 'touchmove';\nconst EVENT_TOUCHCANCEL = 'touchcancel';\nconst EVENT_SELECT = 'select';\nconst EVENT_SELECTSTART = 'selectstart';\nconst EVENT_SELECTEND = 'selectend';\nconst KEY_BACKSPACE = 8;\nconst KEY_TAB = 9;\nconst KEY_RETURN = 13;\nconst KEY_ENTER = 13;\nconst KEY_SHIFT = 16;\nconst KEY_CONTROL = 17;\nconst KEY_ALT = 18;\nconst KEY_PAUSE = 19;\nconst KEY_CAPS_LOCK = 20;\nconst KEY_ESCAPE = 27;\nconst KEY_SPACE = 32;\nconst KEY_PAGE_UP = 33;\nconst KEY_PAGE_DOWN = 34;\nconst KEY_END = 35;\nconst KEY_HOME = 36;\nconst KEY_LEFT = 37;\nconst KEY_UP = 38;\nconst KEY_RIGHT = 39;\nconst KEY_DOWN = 40;\nconst KEY_PRINT_SCREEN = 44;\nconst KEY_INSERT = 45;\nconst KEY_DELETE = 46;\nconst KEY_0 = 48;\nconst KEY_1 = 49;\nconst KEY_2 = 50;\nconst KEY_3 = 51;\nconst KEY_4 = 52;\nconst KEY_5 = 53;\nconst KEY_6 = 54;\nconst KEY_7 = 55;\nconst KEY_8 = 56;\nconst KEY_9 = 57;\nconst KEY_SEMICOLON = 59;\nconst KEY_EQUAL = 61;\nconst KEY_A = 65;\nconst KEY_B = 66;\nconst KEY_C = 67;\nconst KEY_D = 68;\nconst KEY_E = 69;\nconst KEY_F = 70;\nconst KEY_G = 71;\nconst KEY_H = 72;\nconst KEY_I = 73;\nconst KEY_J = 74;\nconst KEY_K = 75;\nconst KEY_L = 76;\nconst KEY_M = 77;\nconst KEY_N = 78;\nconst KEY_O = 79;\nconst KEY_P = 80;\nconst KEY_Q = 81;\nconst KEY_R = 82;\nconst KEY_S = 83;\nconst KEY_T = 84;\nconst KEY_U = 85;\nconst KEY_V = 86;\nconst KEY_W = 87;\nconst KEY_X = 88;\nconst KEY_Y = 89;\nconst KEY_Z = 90;\nconst KEY_WINDOWS = 91;\nconst KEY_CONTEXT_MENU = 93;\nconst KEY_NUMPAD_0 = 96;\nconst KEY_NUMPAD_1 = 97;\nconst KEY_NUMPAD_2 = 98;\nconst KEY_NUMPAD_3 = 99;\nconst KEY_NUMPAD_4 = 100;\nconst KEY_NUMPAD_5 = 101;\nconst KEY_NUMPAD_6 = 102;\nconst KEY_NUMPAD_7 = 103;\nconst KEY_NUMPAD_8 = 104;\nconst KEY_NUMPAD_9 = 105;\nconst KEY_MULTIPLY = 106;\nconst KEY_ADD = 107;\nconst KEY_SEPARATOR = 108;\nconst KEY_SUBTRACT = 109;\nconst KEY_DECIMAL = 110;\nconst KEY_DIVIDE = 111;\nconst KEY_F1 = 112;\nconst KEY_F2 = 113;\nconst KEY_F3 = 114;\nconst KEY_F4 = 115;\nconst KEY_F5 = 116;\nconst KEY_F6 = 117;\nconst KEY_F7 = 118;\nconst KEY_F8 = 119;\nconst KEY_F9 = 120;\nconst KEY_F10 = 121;\nconst KEY_F11 = 122;\nconst KEY_F12 = 123;\nconst KEY_COMMA = 188;\nconst KEY_PERIOD = 190;\nconst KEY_SLASH = 191;\nconst KEY_OPEN_BRACKET = 219;\nconst KEY_BACK_SLASH = 220;\nconst KEY_CLOSE_BRACKET = 221;\nconst KEY_META = 224;\nconst MOUSEBUTTON_NONE = -1;\nconst MOUSEBUTTON_LEFT = 0;\nconst MOUSEBUTTON_MIDDLE = 1;\nconst MOUSEBUTTON_RIGHT = 2;\nconst PAD_1 = 0;\nconst PAD_2 = 1;\nconst PAD_3 = 2;\nconst PAD_4 = 3;\nconst PAD_FACE_1 = 0;\nconst PAD_FACE_2 = 1;\nconst PAD_FACE_3 = 2;\nconst PAD_FACE_4 = 3;\nconst PAD_L_SHOULDER_1 = 4;\nconst PAD_R_SHOULDER_1 = 5;\nconst PAD_L_SHOULDER_2 = 6;\nconst PAD_R_SHOULDER_2 = 7;\nconst PAD_SELECT = 8;\nconst PAD_START = 9;\nconst PAD_L_STICK_BUTTON = 10;\nconst PAD_R_STICK_BUTTON = 11;\nconst PAD_UP = 12;\nconst PAD_DOWN = 13;\nconst PAD_LEFT = 14;\nconst PAD_RIGHT = 15;\nconst PAD_VENDOR = 16;\nconst PAD_L_STICK_X = 0;\nconst PAD_L_STICK_Y = 1;\nconst PAD_R_STICK_X = 2;\nconst PAD_R_STICK_Y = 3;\nconst EVENT_GAMEPADCONNECTED = 'gamepadconnected';\nconst EVENT_GAMEPADDISCONNECTED = 'gamepaddisconnected';\nconst XRPAD_TOUCHPAD_X = 0;\nconst XRPAD_TOUCHPAD_Y = 1;\nconst XRPAD_STICK_X = 2;\nconst XRPAD_STICK_Y = 3;\nconst XRPAD_TOUCHPAD_BUTTON = 2;\nconst XRPAD_TRIGGER = 0;\nconst XRPAD_SQUEEZE = 1;\nconst XRPAD_STICK_BUTTON = 3;\nconst XRPAD_A = 4;\nconst XRPAD_B = 5;\n\nexport { ACTION_GAMEPAD, ACTION_KEYBOARD, ACTION_MOUSE, AXIS_KEY, AXIS_MOUSE_X, AXIS_MOUSE_Y, AXIS_PAD_L_X, AXIS_PAD_L_Y, AXIS_PAD_R_X, AXIS_PAD_R_Y, EVENT_GAMEPADCONNECTED, EVENT_GAMEPADDISCONNECTED, EVENT_KEYDOWN, EVENT_KEYUP, EVENT_MOUSEDOWN, EVENT_MOUSEMOVE, EVENT_MOUSEUP, EVENT_MOUSEWHEEL, EVENT_SELECT, EVENT_SELECTEND, EVENT_SELECTSTART, EVENT_TOUCHCANCEL, EVENT_TOUCHEND, EVENT_TOUCHMOVE, EVENT_TOUCHSTART, KEY_0, KEY_1, KEY_2, KEY_3, KEY_4, KEY_5, KEY_6, KEY_7, KEY_8, KEY_9, KEY_A, KEY_ADD, KEY_ALT, KEY_B, KEY_BACKSPACE, KEY_BACK_SLASH, KEY_C, KEY_CAPS_LOCK, KEY_CLOSE_BRACKET, KEY_COMMA, KEY_CONTEXT_MENU, KEY_CONTROL, KEY_D, KEY_DECIMAL, KEY_DELETE, KEY_DIVIDE, KEY_DOWN, KEY_E, KEY_END, KEY_ENTER, KEY_EQUAL, KEY_ESCAPE, KEY_F, KEY_F1, KEY_F10, KEY_F11, KEY_F12, KEY_F2, KEY_F3, KEY_F4, KEY_F5, KEY_F6, KEY_F7, KEY_F8, KEY_F9, KEY_G, KEY_H, KEY_HOME, KEY_I, KEY_INSERT, KEY_J, KEY_K, KEY_L, KEY_LEFT, KEY_M, KEY_META, KEY_MULTIPLY, KEY_N, KEY_NUMPAD_0, KEY_NUMPAD_1, KEY_NUMPAD_2, KEY_NUMPAD_3, KEY_NUMPAD_4, KEY_NUMPAD_5, KEY_NUMPAD_6, KEY_NUMPAD_7, KEY_NUMPAD_8, KEY_NUMPAD_9, KEY_O, KEY_OPEN_BRACKET, KEY_P, KEY_PAGE_DOWN, KEY_PAGE_UP, KEY_PAUSE, KEY_PERIOD, KEY_PRINT_SCREEN, KEY_Q, KEY_R, KEY_RETURN, KEY_RIGHT, KEY_S, KEY_SEMICOLON, KEY_SEPARATOR, KEY_SHIFT, KEY_SLASH, KEY_SPACE, KEY_SUBTRACT, KEY_T, KEY_TAB, KEY_U, KEY_UP, KEY_V, KEY_W, KEY_WINDOWS, KEY_X, KEY_Y, KEY_Z, MOUSEBUTTON_LEFT, MOUSEBUTTON_MIDDLE, MOUSEBUTTON_NONE, MOUSEBUTTON_RIGHT, PAD_1, PAD_2, PAD_3, PAD_4, PAD_DOWN, PAD_FACE_1, PAD_FACE_2, PAD_FACE_3, PAD_FACE_4, PAD_LEFT, PAD_L_SHOULDER_1, PAD_L_SHOULDER_2, PAD_L_STICK_BUTTON, PAD_L_STICK_X, PAD_L_STICK_Y, PAD_RIGHT, PAD_R_SHOULDER_1, PAD_R_SHOULDER_2, PAD_R_STICK_BUTTON, PAD_R_STICK_X, PAD_R_STICK_Y, PAD_SELECT, PAD_START, PAD_UP, PAD_VENDOR, XRPAD_A, XRPAD_B, XRPAD_SQUEEZE, XRPAD_STICK_BUTTON, XRPAD_STICK_X, XRPAD_STICK_Y, XRPAD_TOUCHPAD_BUTTON, XRPAD_TOUCHPAD_X, XRPAD_TOUCHPAD_Y, XRPAD_TRIGGER };\n", "import { MOUSEBUTTON_NONE } from './constants.js';\n\nfunction isMousePointerLocked() {\n\treturn !!(document.pointerLockElement || document.mozPointerLockElement || document.webkitPointerLockElement);\n}\nclass MouseEvent {\n\tconstructor(mouse, event) {\n\t\tvar _event$ctrlKey, _event$altKey, _event$shiftKey, _event$metaKey;\n\t\tthis.x = 0;\n\t\tthis.y = 0;\n\t\tthis.dx = 0;\n\t\tthis.dy = 0;\n\t\tthis.button = MOUSEBUTTON_NONE;\n\t\tthis.wheelDelta = 0;\n\t\tthis.element = void 0;\n\t\tthis.ctrlKey = false;\n\t\tthis.altKey = false;\n\t\tthis.shiftKey = false;\n\t\tthis.metaKey = false;\n\t\tthis.event = void 0;\n\t\tlet coords = {\n\t\t\tx: 0,\n\t\t\ty: 0\n\t\t};\n\t\tif (event) {\n\t\t\tif (event instanceof MouseEvent) {\n\t\t\t\tthrow Error('Expected MouseEvent');\n\t\t\t}\n\t\t\tcoords = mouse._getTargetCoords(event);\n\t\t} else {\n\t\t\tevent = {};\n\t\t}\n\t\tif (coords) {\n\t\t\tthis.x = coords.x;\n\t\t\tthis.y = coords.y;\n\t\t} else if (isMousePointerLocked()) {\n\t\t\tthis.x = 0;\n\t\t\tthis.y = 0;\n\t\t} else {\n\t\t\treturn;\n\t\t}\n\t\tif (event.type === 'wheel') {\n\t\t\tif (event.deltaY > 0) {\n\t\t\t\tthis.wheelDelta = 1;\n\t\t\t} else if (event.deltaY < 0) {\n\t\t\t\tthis.wheelDelta = -1;\n\t\t\t}\n\t\t}\n\t\tif (isMousePointerLocked()) {\n\t\t\tthis.dx = event.movementX || event.webkitMovementX || event.mozMovementX || 0;\n\t\t\tthis.dy = event.movementY || event.webkitMovementY || event.mozMovementY || 0;\n\t\t} else {\n\t\t\tthis.dx = this.x - mouse._lastX;\n\t\t\tthis.dy = this.y - mouse._lastY;\n\t\t}\n\t\tif (event.type === 'mousedown' || event.type === 'mouseup') {\n\t\t\tthis.button = event.button;\n\t\t}\n\t\tthis.buttons = mouse._buttons.slice(0);\n\t\tthis.element = event.target;\n\t\tthis.ctrlKey = (_event$ctrlKey = event.ctrlKey) != null ? _event$ctrlKey : false;\n\t\tthis.altKey = (_event$altKey = event.altKey) != null ? _event$altKey : false;\n\t\tthis.shiftKey = (_event$shiftKey = event.shiftKey) != null ? _event$shiftKey : false;\n\t\tthis.metaKey = (_event$metaKey = event.metaKey) != null ? _event$metaKey : false;\n\t\tthis.event = event;\n\t}\n}\n\nexport { MouseEvent, isMousePointerLocked };\n", "import { platform } from '../../core/platform.js';\nimport { EventHandler } from '../../core/event-handler.js';\nimport { EVENT_MOUSEUP, EVENT_MOUSEDOWN, EVENT_MOUSEMOVE, EVENT_MOUSEWHEEL } from './constants.js';\nimport { isMousePointerLocked, MouseEvent } from './mouse-event.js';\n\nclass Mouse extends EventHandler {\n\tconstructor(element) {\n\t\tsuper();\n\t\tthis._lastX = 0;\n\t\tthis._lastY = 0;\n\t\tthis._buttons = [false, false, false];\n\t\tthis._lastbuttons = [false, false, false];\n\t\tthis._target = null;\n\t\tthis._attached = false;\n\t\tthis._upHandler = this._handleUp.bind(this);\n\t\tthis._downHandler = this._handleDown.bind(this);\n\t\tthis._moveHandler = this._handleMove.bind(this);\n\t\tthis._wheelHandler = this._handleWheel.bind(this);\n\t\tthis._contextMenuHandler = event => {\n\t\t\tevent.preventDefault();\n\t\t};\n\t\tthis.attach(element);\n\t}\n\tstatic isPointerLocked() {\n\t\treturn isMousePointerLocked();\n\t}\n\tattach(element) {\n\t\tthis._target = element;\n\t\tif (this._attached) return;\n\t\tthis._attached = true;\n\t\tconst passiveOptions = {\n\t\t\tpassive: false\n\t\t};\n\t\tconst options = platform.passiveEvents ? passiveOptions : false;\n\t\twindow.addEventListener('mouseup', this._upHandler, options);\n\t\twindow.addEventListener('mousedown', this._downHandler, options);\n\t\twindow.addEventListener('mousemove', this._moveHandler, options);\n\t\twindow.addEventListener('wheel', this._wheelHandler, options);\n\t}\n\tdetach() {\n\t\tif (!this._attached) return;\n\t\tthis._attached = false;\n\t\tthis._target = null;\n\t\tconst passiveOptions = {\n\t\t\tpassive: false\n\t\t};\n\t\tconst options = platform.passiveEvents ? passiveOptions : false;\n\t\twindow.removeEventListener('mouseup', this._upHandler, options);\n\t\twindow.removeEventListener('mousedown', this._downHandler, options);\n\t\twindow.removeEventListener('mousemove', this._moveHandler, options);\n\t\twindow.removeEventListener('wheel', this._wheelHandler, options);\n\t}\n\tdisableContextMenu() {\n\t\tif (!this._target) return;\n\t\tthis._target.addEventListener('contextmenu', this._contextMenuHandler);\n\t}\n\tenableContextMenu() {\n\t\tif (!this._target) return;\n\t\tthis._target.removeEventListener('contextmenu', this._contextMenuHandler);\n\t}\n\tenablePointerLock(success, error) {\n\t\tif (!document.body.requestPointerLock) {\n\t\t\tif (error) error();\n\t\t\treturn;\n\t\t}\n\t\tconst s = () => {\n\t\t\tsuccess();\n\t\t\tdocument.removeEventListener('pointerlockchange', s);\n\t\t};\n\t\tconst e = () => {\n\t\t\terror();\n\t\t\tdocument.removeEventListener('pointerlockerror', e);\n\t\t};\n\t\tif (success) {\n\t\t\tdocument.addEventListener('pointerlockchange', s, false);\n\t\t}\n\t\tif (error) {\n\t\t\tdocument.addEventListener('pointerlockerror', e, false);\n\t\t}\n\t\tdocument.body.requestPointerLock();\n\t}\n\tdisablePointerLock(success) {\n\t\tif (!document.exitPointerLock) {\n\t\t\treturn;\n\t\t}\n\t\tconst s = () => {\n\t\t\tsuccess();\n\t\t\tdocument.removeEventListener('pointerlockchange', s);\n\t\t};\n\t\tif (success) {\n\t\t\tdocument.addEventListener('pointerlockchange', s, false);\n\t\t}\n\t\tdocument.exitPointerLock();\n\t}\n\tupdate() {\n\t\tthis._lastbuttons[0] = this._buttons[0];\n\t\tthis._lastbuttons[1] = this._buttons[1];\n\t\tthis._lastbuttons[2] = this._buttons[2];\n\t}\n\tisPressed(button) {\n\t\treturn this._buttons[button];\n\t}\n\twasPressed(button) {\n\t\treturn this._buttons[button] && !this._lastbuttons[button];\n\t}\n\twasReleased(button) {\n\t\treturn !this._buttons[button] && this._lastbuttons[button];\n\t}\n\t_handleUp(event) {\n\t\tthis._buttons[event.button] = false;\n\t\tconst e = new MouseEvent(this, event);\n\t\tif (!e.event) return;\n\t\tthis.fire(EVENT_MOUSEUP, e);\n\t}\n\t_handleDown(event) {\n\t\tthis._buttons[event.button] = true;\n\t\tconst e = new MouseEvent(this, event);\n\t\tif (!e.event) return;\n\t\tthis.fire(EVENT_MOUSEDOWN, e);\n\t}\n\t_handleMove(event) {\n\t\tconst e = new MouseEvent(this, event);\n\t\tif (!e.event) return;\n\t\tthis.fire(EVENT_MOUSEMOVE, e);\n\t\tthis._lastX = e.x;\n\t\tthis._lastY = e.y;\n\t}\n\t_handleWheel(event) {\n\t\tconst e = new MouseEvent(this, event);\n\t\tif (!e.event) return;\n\t\tthis.fire(EVENT_MOUSEWHEEL, e);\n\t}\n\t_getTargetCoords(event) {\n\t\tconst rect = this._target.getBoundingClientRect();\n\t\tconst left = Math.floor(rect.left);\n\t\tconst top = Math.floor(rect.top);\n\t\tif (event.clientX < left || event.clientX >= left + this._target.clientWidth || event.clientY < top || event.clientY >= top + this._target.clientHeight) {\n\t\t\treturn null;\n\t\t}\n\t\treturn {\n\t\t\tx: event.clientX - left,\n\t\t\ty: event.clientY - top\n\t\t};\n\t}\n}\nMouse.EVENT_MOUSEMOVE = EVENT_MOUSEMOVE;\nMouse.EVENT_MOUSEDOWN = EVENT_MOUSEDOWN;\nMouse.EVENT_MOUSEUP = EVENT_MOUSEUP;\nMouse.EVENT_MOUSEWHEEL = EVENT_MOUSEWHEEL;\n\nexport { Mouse };\n", "import { extend } from '../../core/core.js';\nimport { now } from '../../core/time.js';\nimport { path } from '../../core/path.js';\nimport { URI } from '../../core/uri.js';\nimport { math } from '../../core/math/math.js';\n\nclass Http {\n\tget(url, options, callback) {\n\t\tif (typeof options === 'function') {\n\t\t\tcallback = options;\n\t\t\toptions = {};\n\t\t}\n\t\treturn this.request('GET', url, options, callback);\n\t}\n\tpost(url, data, options, callback) {\n\t\tif (typeof options === 'function') {\n\t\t\tcallback = options;\n\t\t\toptions = {};\n\t\t}\n\t\toptions.postdata = data;\n\t\treturn this.request('POST', url, options, callback);\n\t}\n\tput(url, data, options, callback) {\n\t\tif (typeof options === 'function') {\n\t\t\tcallback = options;\n\t\t\toptions = {};\n\t\t}\n\t\toptions.postdata = data;\n\t\treturn this.request('PUT', url, options, callback);\n\t}\n\tdel(url, options, callback) {\n\t\tif (typeof options === 'function') {\n\t\t\tcallback = options;\n\t\t\toptions = {};\n\t\t}\n\t\treturn this.request('DELETE', url, options, callback);\n\t}\n\trequest(method, url, options, callback) {\n\t\tlet uri, query, postdata;\n\t\tlet errored = false;\n\t\tif (typeof options === 'function') {\n\t\t\tcallback = options;\n\t\t\toptions = {};\n\t\t}\n\t\tif (options.retry) {\n\t\t\toptions = Object.assign({\n\t\t\t\tretries: 0,\n\t\t\t\tmaxRetries: 5\n\t\t\t}, options);\n\t\t}\n\t\toptions.callback = callback;\n\t\tif (options.async == null) {\n\t\t\toptions.async = true;\n\t\t}\n\t\tif (options.headers == null) {\n\t\t\toptions.headers = {};\n\t\t}\n\t\tif (options.postdata != null) {\n\t\t\tif (options.postdata instanceof Document) {\n\t\t\t\tpostdata = options.postdata;\n\t\t\t} else if (options.postdata instanceof FormData) {\n\t\t\t\tpostdata = options.postdata;\n\t\t\t} else if (options.postdata instanceof Object) {\n\t\t\t\tlet contentType = options.headers['Content-Type'];\n\t\t\t\tif (contentType === undefined) {\n\t\t\t\t\toptions.headers['Content-Type'] = Http.ContentType.FORM_URLENCODED;\n\t\t\t\t\tcontentType = options.headers['Content-Type'];\n\t\t\t\t}\n\t\t\t\tswitch (contentType) {\n\t\t\t\t\tcase Http.ContentType.FORM_URLENCODED:\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tpostdata = '';\n\t\t\t\t\t\t\tlet bFirstItem = true;\n\t\t\t\t\t\t\tfor (const key in options.postdata) {\n\t\t\t\t\t\t\t\tif (options.postdata.hasOwnProperty(key)) {\n\t\t\t\t\t\t\t\t\tif (bFirstItem) {\n\t\t\t\t\t\t\t\t\t\tbFirstItem = false;\n\t\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\t\tpostdata += '&';\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\tconst encodedKey = encodeURIComponent(key);\n\t\t\t\t\t\t\t\t\tconst encodedValue = encodeURIComponent(options.postdata[key]);\n\t\t\t\t\t\t\t\t\tpostdata += `${encodedKey}=${encodedValue}`;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\tdefault:\n\t\t\t\t\tcase Http.ContentType.JSON:\n\t\t\t\t\t\tif (contentType == null) {\n\t\t\t\t\t\t\toptions.headers['Content-Type'] = Http.ContentType.JSON;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tpostdata = JSON.stringify(options.postdata);\n\t\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tpostdata = options.postdata;\n\t\t\t}\n\t\t}\n\t\tif (options.cache === false) {\n\t\t\tconst timestamp = now();\n\t\t\turi = new URI(url);\n\t\t\tif (!uri.query) {\n\t\t\t\turi.query = 'ts=' + timestamp;\n\t\t\t} else {\n\t\t\t\turi.query = uri.query + '&ts=' + timestamp;\n\t\t\t}\n\t\t\turl = uri.toString();\n\t\t}\n\t\tif (options.query) {\n\t\t\turi = new URI(url);\n\t\t\tquery = extend(uri.getQuery(), options.query);\n\t\t\turi.setQuery(query);\n\t\t\turl = uri.toString();\n\t\t}\n\t\tconst xhr = new XMLHttpRequest();\n\t\txhr.open(method, url, options.async);\n\t\txhr.withCredentials = options.withCredentials !== undefined ? options.withCredentials : false;\n\t\txhr.responseType = options.responseType || this._guessResponseType(url);\n\t\tfor (const header in options.headers) {\n\t\t\tif (options.headers.hasOwnProperty(header)) {\n\t\t\t\txhr.setRequestHeader(header, options.headers[header]);\n\t\t\t}\n\t\t}\n\t\txhr.onreadystatechange = () => {\n\t\t\tthis._onReadyStateChange(method, url, options, xhr);\n\t\t};\n\t\txhr.onerror = () => {\n\t\t\tthis._onError(method, url, options, xhr);\n\t\t\terrored = true;\n\t\t};\n\t\ttry {\n\t\t\txhr.send(postdata);\n\t\t} catch (e) {\n\t\t\tif (!errored) {\n\t\t\t\toptions.error(xhr.status, xhr, e);\n\t\t\t}\n\t\t}\n\t\treturn xhr;\n\t}\n\t_guessResponseType(url) {\n\t\tconst uri = new URI(url);\n\t\tconst ext = path.getExtension(uri.path).toLowerCase();\n\t\tif (Http.binaryExtensions.indexOf(ext) >= 0) {\n\t\t\treturn Http.ResponseType.ARRAY_BUFFER;\n\t\t} else if (ext === '.json') {\n\t\t\treturn Http.ResponseType.JSON;\n\t\t} else if (ext === '.xml') {\n\t\t\treturn Http.ResponseType.DOCUMENT;\n\t\t}\n\t\treturn Http.ResponseType.TEXT;\n\t}\n\t_isBinaryContentType(contentType) {\n\t\tconst binTypes = [Http.ContentType.BASIS, Http.ContentType.BIN, Http.ContentType.DDS, Http.ContentType.GLB, Http.ContentType.MP3, Http.ContentType.MP4, Http.ContentType.OGG, Http.ContentType.OPUS, Http.ContentType.WAV];\n\t\tif (binTypes.indexOf(contentType) >= 0) {\n\t\t\treturn true;\n\t\t}\n\t\treturn false;\n\t}\n\t_isBinaryResponseType(responseType) {\n\t\treturn responseType === Http.ResponseType.ARRAY_BUFFER || responseType === Http.ResponseType.BLOB || responseType === Http.ResponseType.JSON;\n\t}\n\t_onReadyStateChange(method, url, options, xhr) {\n\t\tif (xhr.readyState === 4) {\n\t\t\tswitch (xhr.status) {\n\t\t\t\tcase 0:\n\t\t\t\t\t{\n\t\t\t\t\t\tif (xhr.responseURL && xhr.responseURL.startsWith('file:///')) {\n\t\t\t\t\t\t\tthis._onSuccess(method, url, options, xhr);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tthis._onError(method, url, options, xhr);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\tcase 200:\n\t\t\t\tcase 201:\n\t\t\t\tcase 206:\n\t\t\t\tcase 304:\n\t\t\t\t\t{\n\t\t\t\t\t\tthis._onSuccess(method, url, options, xhr);\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\tdefault:\n\t\t\t\t\t{\n\t\t\t\t\t\tthis._onError(method, url, options, xhr);\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\t_onSuccess(method, url, options, xhr) {\n\t\tlet response;\n\t\tlet contentType;\n\t\tconst header = xhr.getResponseHeader('Content-Type');\n\t\tif (header) {\n\t\t\tconst parts = header.split(';');\n\t\t\tcontentType = parts[0].trim();\n\t\t}\n\t\ttry {\n\t\t\tif (this._isBinaryContentType(contentType) || this._isBinaryResponseType(xhr.responseType)) {\n\t\t\t\tresponse = xhr.response;\n\t\t\t} else if (contentType === Http.ContentType.JSON || url.split('?')[0].endsWith('.json')) {\n\t\t\t\tresponse = JSON.parse(xhr.responseText);\n\t\t\t} else if (xhr.responseType === Http.ResponseType.DOCUMENT || contentType === Http.ContentType.XML) {\n\t\t\t\tresponse = xhr.responseXML;\n\t\t\t} else {\n\t\t\t\tresponse = xhr.responseText;\n\t\t\t}\n\t\t\toptions.callback(null, response);\n\t\t} catch (err) {\n\t\t\toptions.callback(err);\n\t\t}\n\t}\n\t_onError(method, url, options, xhr) {\n\t\tif (options.retrying) {\n\t\t\treturn;\n\t\t}\n\t\tif (options.retry && options.retries < options.maxRetries) {\n\t\t\toptions.retries++;\n\t\t\toptions.retrying = true;\n\t\t\tconst retryDelay = math.clamp(Math.pow(2, options.retries) * Http.retryDelay, 0, options.maxRetryDelay || 5000);\n\t\t\tconsole.log(`${method}: ${url} - Error ${xhr.status}. Retrying in ${retryDelay} ms`);\n\t\t\tsetTimeout(() => {\n\t\t\t\toptions.retrying = false;\n\t\t\t\tthis.request(method, url, options, options.callback);\n\t\t\t}, retryDelay);\n\t\t} else {\n\t\t\toptions.callback(xhr.status === 0 ? 'Network error' : xhr.status, null);\n\t\t}\n\t}\n}\nHttp.ContentType = {\n\tAAC: 'audio/aac',\n\tBASIS: 'image/basis',\n\tBIN: 'application/octet-stream',\n\tDDS: 'image/dds',\n\tFORM_URLENCODED: 'application/x-www-form-urlencoded',\n\tGIF: 'image/gif',\n\tGLB: 'model/gltf-binary',\n\tJPEG: 'image/jpeg',\n\tJSON: 'application/json',\n\tMP3: 'audio/mpeg',\n\tMP4: 'audio/mp4',\n\tOGG: 'audio/ogg',\n\tOPUS: 'audio/ogg; codecs=\"opus\"',\n\tPNG: 'image/png',\n\tTEXT: 'text/plain',\n\tWAV: 'audio/x-wav',\n\tXML: 'application/xml'\n};\nHttp.ResponseType = {\n\tTEXT: 'text',\n\tARRAY_BUFFER: 'arraybuffer',\n\tBLOB: 'blob',\n\tDOCUMENT: 'document',\n\tJSON: 'json'\n};\nHttp.binaryExtensions = ['.model', '.wav', '.ogg', '.mp3', '.mp4', '.m4a', '.aac', '.dds', '.basis', '.glb', '.opus'];\nHttp.retryDelay = 100;\nconst http = new Http();\n\nexport { Http, http };\n", "function hasAudioContext() {\n\treturn !!(typeof AudioContext !== 'undefined' || typeof webkitAudioContext !== 'undefined');\n}\n\nexport { hasAudioContext };\n", "import { math } from '../../core/math/math.js';\nimport { hasAudioContext } from './capabilities.js';\n\nclass Channel {\n\tconstructor(manager, sound, options = {}) {\n\t\tvar _options$volume, _options$loop, _options$pitch;\n\t\tthis.volume = (_options$volume = options.volume) != null ? _options$volume : 1;\n\t\tthis.loop = (_options$loop = options.loop) != null ? _options$loop : false;\n\t\tthis.pitch = (_options$pitch = options.pitch) != null ? _options$pitch : 1;\n\t\tthis.sound = sound;\n\t\tthis.paused = false;\n\t\tthis.suspended = false;\n\t\tthis.manager = manager;\n\t\tthis.source = null;\n\t\tif (hasAudioContext()) {\n\t\t\tthis.startTime = 0;\n\t\t\tthis.startOffset = 0;\n\t\t\tconst context = manager.context;\n\t\t\tthis.gain = context.createGain();\n\t\t} else if (sound.audio) {\n\t\t\tthis.source = sound.audio.cloneNode(false);\n\t\t\tthis.source.pause();\n\t\t}\n\t}\n\tgetVolume() {\n\t\treturn this.volume;\n\t}\n\tgetLoop() {\n\t\treturn this.loop;\n\t}\n\tsetLoop(loop) {\n\t\tthis.loop = loop;\n\t\tif (this.source) {\n\t\t\tthis.source.loop = loop;\n\t\t}\n\t}\n\tgetPitch() {\n\t\treturn this.pitch;\n\t}\n\tonManagerVolumeChange() {\n\t\tthis.setVolume(this.getVolume());\n\t}\n\tonManagerSuspend() {\n\t\tif (this.isPlaying() && !this.suspended) {\n\t\t\tthis.suspended = true;\n\t\t\tthis.pause();\n\t\t}\n\t}\n\tonManagerResume() {\n\t\tif (this.suspended) {\n\t\t\tthis.suspended = false;\n\t\t\tthis.unpause();\n\t\t}\n\t}\n\tplay() {\n\t\tif (this.source) {\n\t\t\tthrow new Error('Call stop() before calling play()');\n\t\t}\n\t\tthis._createSource();\n\t\tif (!this.source) {\n\t\t\treturn;\n\t\t}\n\t\tthis.startTime = this.manager.context.currentTime;\n\t\tthis.source.start(0, this.startOffset % this.source.buffer.duration);\n\t\tthis.setVolume(this.volume);\n\t\tthis.setLoop(this.loop);\n\t\tthis.setPitch(this.pitch);\n\t\tthis.manager.on('volumechange', this.onManagerVolumeChange, this);\n\t\tthis.manager.on('suspend', this.onManagerSuspend, this);\n\t\tthis.manager.on('resume', this.onManagerResume, this);\n\t\tif (this.manager.suspended) this.onManagerSuspend();\n\t}\n\tpause() {\n\t\tif (this.source) {\n\t\t\tthis.paused = true;\n\t\t\tthis.startOffset += this.manager.context.currentTime - this.startTime;\n\t\t\tthis.source.stop(0);\n\t\t\tthis.source = null;\n\t\t}\n\t}\n\tunpause() {\n\t\tif (this.source || !this.paused) {\n\t\t\tconsole.warn('Call pause() before unpausing.');\n\t\t\treturn;\n\t\t}\n\t\tthis._createSource();\n\t\tif (!this.source) {\n\t\t\treturn;\n\t\t}\n\t\tthis.startTime = this.manager.context.currentTime;\n\t\tthis.source.start(0, this.startOffset % this.source.buffer.duration);\n\t\tthis.setVolume(this.volume);\n\t\tthis.setLoop(this.loop);\n\t\tthis.setPitch(this.pitch);\n\t\tthis.paused = false;\n\t}\n\tstop() {\n\t\tif (this.source) {\n\t\t\tthis.source.stop(0);\n\t\t\tthis.source = null;\n\t\t}\n\t\tthis.manager.off('volumechange', this.onManagerVolumeChange, this);\n\t\tthis.manager.off('suspend', this.onManagerSuspend, this);\n\t\tthis.manager.off('resume', this.onManagerResume, this);\n\t}\n\tsetVolume(volume) {\n\t\tvolume = math.clamp(volume, 0, 1);\n\t\tthis.volume = volume;\n\t\tif (this.gain) {\n\t\t\tthis.gain.gain.value = volume * this.manager.volume;\n\t\t}\n\t}\n\tsetPitch(pitch) {\n\t\tthis.pitch = pitch;\n\t\tif (this.source) {\n\t\t\tthis.source.playbackRate.value = pitch;\n\t\t}\n\t}\n\tisPlaying() {\n\t\treturn !this.paused && this.source.playbackState === this.source.PLAYING_STATE;\n\t}\n\tgetDuration() {\n\t\treturn this.source ? this.source.buffer.duration : 0;\n\t}\n\t_createSource() {\n\t\tconst context = this.manager.context;\n\t\tif (this.sound.buffer) {\n\t\t\tthis.source = context.createBufferSource();\n\t\t\tthis.source.buffer = this.sound.buffer;\n\t\t\tthis.source.connect(this.gain);\n\t\t\tthis.gain.connect(context.destination);\n\t\t\tif (!this.loop) {\n\t\t\t\tthis.source.onended = this.pause.bind(this);\n\t\t\t}\n\t\t}\n\t}\n}\nif (!hasAudioContext()) {\n\tObject.assign(Channel.prototype, {\n\t\tplay: function () {\n\t\t\tif (this.source) {\n\t\t\t\tthis.paused = false;\n\t\t\t\tthis.setVolume(this.volume);\n\t\t\t\tthis.setLoop(this.loop);\n\t\t\t\tthis.setPitch(this.pitch);\n\t\t\t\tthis.source.play();\n\t\t\t}\n\t\t\tthis.manager.on('volumechange', this.onManagerVolumeChange, this);\n\t\t\tthis.manager.on('suspend', this.onManagerSuspend, this);\n\t\t\tthis.manager.on('resume', this.onManagerResume, this);\n\t\t\tif (this.manager.suspended) this.onManagerSuspend();\n\t\t},\n\t\tpause: function () {\n\t\t\tif (this.source) {\n\t\t\t\tthis.paused = true;\n\t\t\t\tthis.source.pause();\n\t\t\t}\n\t\t},\n\t\tunpause: function () {\n\t\t\tif (this.source) {\n\t\t\t\tthis.paused = false;\n\t\t\t\tthis.source.play();\n\t\t\t}\n\t\t},\n\t\tstop: function () {\n\t\t\tif (this.source) {\n\t\t\t\tthis.source.pause();\n\t\t\t}\n\t\t\tthis.manager.off('volumechange', this.onManagerVolumeChange, this);\n\t\t\tthis.manager.off('suspend', this.onManagerSuspend, this);\n\t\t\tthis.manager.off('resume', this.onManagerResume, this);\n\t\t},\n\t\tsetVolume: function (volume) {\n\t\t\tvolume = math.clamp(volume, 0, 1);\n\t\t\tthis.volume = volume;\n\t\t\tif (this.source) {\n\t\t\t\tthis.source.volume = volume * this.manager.volume;\n\t\t\t}\n\t\t},\n\t\tsetPitch: function (pitch) {\n\t\t\tthis.pitch = pitch;\n\t\t\tif (this.source) {\n\t\t\t\tthis.source.playbackRate = pitch;\n\t\t\t}\n\t\t},\n\t\tgetDuration: function () {\n\t\t\treturn this.source && !isNaN(this.source.duration) ? this.source.duration : 0;\n\t\t},\n\t\tisPlaying: function () {\n\t\t\treturn !this.source.paused;\n\t\t}\n\t});\n}\n\nexport { Channel };\n", "import { math } from '../../core/math/math.js';\nimport { Vec3 } from '../../core/math/vec3.js';\nimport { DISTANCE_INVERSE, DISTANCE_LINEAR, DISTANCE_EXPONENTIAL } from './constants.js';\nimport { hasAudioContext } from './capabilities.js';\nimport { Channel } from './channel.js';\n\nconst MAX_DISTANCE = 10000;\nclass Channel3d extends Channel {\n\tconstructor(manager, sound, options) {\n\t\tsuper(manager, sound, options);\n\t\tthis.position = new Vec3();\n\t\tthis.velocity = new Vec3();\n\t\tif (hasAudioContext()) {\n\t\t\tthis.panner = manager.context.createPanner();\n\t\t} else {\n\t\t\tthis.maxDistance = MAX_DISTANCE;\n\t\t\tthis.minDistance = 1;\n\t\t\tthis.rollOffFactor = 1;\n\t\t\tthis.distanceModel = DISTANCE_INVERSE;\n\t\t}\n\t}\n\tgetPosition() {\n\t\treturn this.position;\n\t}\n\tsetPosition(position) {\n\t\tthis.position.copy(position);\n\t\tconst panner = this.panner;\n\t\tif ('positionX' in panner) {\n\t\t\tpanner.positionX.value = position.x;\n\t\t\tpanner.positionY.value = position.y;\n\t\t\tpanner.positionZ.value = position.z;\n\t\t} else if (panner.setPosition) {\n\t\t\tpanner.setPosition(position.x, position.y, position.z);\n\t\t}\n\t}\n\tgetVelocity() {\n\t\treturn this.velocity;\n\t}\n\tsetVelocity(velocity) {\n\t\tthis.velocity.copy(velocity);\n\t}\n\tgetMaxDistance() {\n\t\treturn this.panner.maxDistance;\n\t}\n\tsetMaxDistance(max) {\n\t\tthis.panner.maxDistance = max;\n\t}\n\tgetMinDistance() {\n\t\treturn this.panner.refDistance;\n\t}\n\tsetMinDistance(min) {\n\t\tthis.panner.refDistance = min;\n\t}\n\tgetRollOffFactor() {\n\t\treturn this.panner.rolloffFactor;\n\t}\n\tsetRollOffFactor(factor) {\n\t\tthis.panner.rolloffFactor = factor;\n\t}\n\tgetDistanceModel() {\n\t\treturn this.panner.distanceModel;\n\t}\n\tsetDistanceModel(distanceModel) {\n\t\tthis.panner.distanceModel = distanceModel;\n\t}\n\t_createSource() {\n\t\tconst context = this.manager.context;\n\t\tthis.source = context.createBufferSource();\n\t\tthis.source.buffer = this.sound.buffer;\n\t\tthis.source.connect(this.panner);\n\t\tthis.panner.connect(this.gain);\n\t\tthis.gain.connect(context.destination);\n\t\tif (!this.loop) {\n\t\t\tthis.source.onended = this.pause.bind(this);\n\t\t}\n\t}\n}\nif (!hasAudioContext()) {\n\tlet offset = new Vec3();\n\tconst fallOff = function fallOff(posOne, posTwo, refDistance, maxDistance, rolloffFactor, distanceModel) {\n\t\toffset = offset.sub2(posOne, posTwo);\n\t\tconst distance = offset.length();\n\t\tif (distance < refDistance) {\n\t\t\treturn 1;\n\t\t} else if (distance > maxDistance) {\n\t\t\treturn 0;\n\t\t}\n\t\tlet result = 0;\n\t\tif (distanceModel === DISTANCE_LINEAR) {\n\t\t\tresult = 1 - rolloffFactor * (distance - refDistance) / (maxDistance - refDistance);\n\t\t} else if (distanceModel === DISTANCE_INVERSE) {\n\t\t\tresult = refDistance / (refDistance + rolloffFactor * (distance - refDistance));\n\t\t} else if (distanceModel === DISTANCE_EXPONENTIAL) {\n\t\t\tresult = Math.pow(distance / refDistance, -rolloffFactor);\n\t\t}\n\t\treturn math.clamp(result, 0, 1);\n\t};\n\tObject.assign(Channel3d.prototype, {\n\t\tsetPosition: function (position) {\n\t\t\tthis.position.copy(position);\n\t\t\tif (this.source) {\n\t\t\t\tconst listener = this.manager.listener;\n\t\t\t\tconst lpos = listener.getPosition();\n\t\t\t\tconst factor = fallOff(lpos, this.position, this.minDistance, this.maxDistance, this.rollOffFactor, this.distanceModel);\n\t\t\t\tconst v = this.getVolume();\n\t\t\t\tthis.source.volume = v * factor;\n\t\t\t}\n\t\t},\n\t\tgetMaxDistance: function () {\n\t\t\treturn this.maxDistance;\n\t\t},\n\t\tsetMaxDistance: function (max) {\n\t\t\tthis.maxDistance = max;\n\t\t},\n\t\tgetMinDistance: function () {\n\t\t\treturn this.minDistance;\n\t\t},\n\t\tsetMinDistance: function (min) {\n\t\t\tthis.minDistance = min;\n\t\t},\n\t\tgetRollOffFactor: function () {\n\t\t\treturn this.rollOffFactor;\n\t\t},\n\t\tsetRollOffFactor: function (factor) {\n\t\t\tthis.rollOffFactor = factor;\n\t\t},\n\t\tgetDistanceModel: function () {\n\t\t\treturn this.distanceModel;\n\t\t},\n\t\tsetDistanceModel: function (distanceModel) {\n\t\t\tthis.distanceModel = distanceModel;\n\t\t}\n\t});\n}\n\nexport { Channel3d };\n", "import { Mat4 } from '../../core/math/mat4.js';\nimport { Vec3 } from '../../core/math/vec3.js';\n\nclass Listener {\n\tconstructor(manager) {\n\t\tthis._manager = void 0;\n\t\tthis.position = new Vec3();\n\t\tthis.velocity = new Vec3();\n\t\tthis.orientation = new Mat4();\n\t\tthis._manager = manager;\n\t}\n\tgetPosition() {\n\t\treturn this.position;\n\t}\n\tsetPosition(position) {\n\t\tthis.position.copy(position);\n\t\tconst listener = this.listener;\n\t\tif (listener) {\n\t\t\tif ('positionX' in listener) {\n\t\t\t\tlistener.positionX.value = position.x;\n\t\t\t\tlistener.positionY.value = position.y;\n\t\t\t\tlistener.positionZ.value = position.z;\n\t\t\t} else if (listener.setPosition) {\n\t\t\t\tlistener.setPosition(position.x, position.y, position.z);\n\t\t\t}\n\t\t}\n\t}\n\tgetVelocity() {\n\t\treturn this.velocity;\n\t}\n\tsetVelocity(velocity) {}\n\tsetOrientation(orientation) {\n\t\tthis.orientation.copy(orientation);\n\t\tconst listener = this.listener;\n\t\tif (listener) {\n\t\t\tconst m = orientation.data;\n\t\t\tif ('forwardX' in listener) {\n\t\t\t\tlistener.forwardX.value = -m[8];\n\t\t\t\tlistener.forwardY.value = -m[9];\n\t\t\t\tlistener.forwardZ.value = -m[10];\n\t\t\t\tlistener.upX.value = m[4];\n\t\t\t\tlistener.upY.value = m[5];\n\t\t\t\tlistener.upZ.value = m[6];\n\t\t\t} else if (listener.setOrientation) {\n\t\t\t\tlistener.setOrientation(-m[8], -m[9], -m[10], m[4], m[5], m[6]);\n\t\t\t}\n\t\t}\n\t}\n\tgetOrientation() {\n\t\treturn this.orientation;\n\t}\n\tget listener() {\n\t\tconst context = this._manager.context;\n\t\treturn context ? context.listener : null;\n\t}\n}\n\nexport { Listener };\n", "import { EventHandler } from '../../core/event-handler.js';\nimport { math } from '../../core/math/math.js';\nimport { Channel } from '../audio/channel.js';\nimport { Channel3d } from '../audio/channel3d.js';\nimport { Listener } from './listener.js';\n\nconst CONTEXT_STATE_RUNNING = 'running';\nconst USER_INPUT_EVENTS = ['click', 'touchstart', 'mousedown'];\nclass SoundManager extends EventHandler {\n\tconstructor() {\n\t\tsuper();\n\t\tthis._context = null;\n\t\tthis.AudioContext = typeof AudioContext !== 'undefined' && AudioContext || typeof webkitAudioContext !== 'undefined' && webkitAudioContext;\n\t\tif (!this.AudioContext) ;\n\t\tthis._unlockHandlerFunc = this._unlockHandler.bind(this);\n\t\tthis._userSuspended = false;\n\t\tthis.listener = new Listener(this);\n\t\tthis._volume = 1;\n\t}\n\tset volume(volume) {\n\t\tvolume = math.clamp(volume, 0, 1);\n\t\tthis._volume = volume;\n\t\tthis.fire('volumechange', volume);\n\t}\n\tget volume() {\n\t\treturn this._volume;\n\t}\n\tget suspended() {\n\t\treturn this._userSuspended;\n\t}\n\tget context() {\n\t\tif (!this._context && this.AudioContext) {\n\t\t\tthis._context = new this.AudioContext();\n\t\t\tif (this._context.state !== CONTEXT_STATE_RUNNING) {\n\t\t\t\tthis._registerUnlockListeners();\n\t\t\t}\n\t\t}\n\t\treturn this._context;\n\t}\n\tsuspend() {\n\t\tif (!this._userSuspended) {\n\t\t\tthis._userSuspended = true;\n\t\t\tif (this._context && this._context.state === CONTEXT_STATE_RUNNING) {\n\t\t\t\tthis._suspend();\n\t\t\t}\n\t\t}\n\t}\n\tresume() {\n\t\tif (this._userSuspended) {\n\t\t\tthis._userSuspended = false;\n\t\t\tif (this._context && this._context.state !== CONTEXT_STATE_RUNNING) {\n\t\t\t\tthis._resume();\n\t\t\t}\n\t\t}\n\t}\n\tdestroy() {\n\t\tthis.fire('destroy');\n\t\tif (this._context) {\n\t\t\tvar _this$_context;\n\t\t\tthis._removeUnlockListeners();\n\t\t\t(_this$_context = this._context) == null || _this$_context.close();\n\t\t\tthis._context = null;\n\t\t}\n\t}\n\tplaySound(sound, options = {}) {\n\t\tlet channel = null;\n\t\tif (Channel) {\n\t\t\tchannel = new Channel(this, sound, options);\n\t\t\tchannel.play();\n\t\t}\n\t\treturn channel;\n\t}\n\tplaySound3d(sound, position, options = {}) {\n\t\tlet channel = null;\n\t\tif (Channel3d) {\n\t\t\tchannel = new Channel3d(this, sound, options);\n\t\t\tchannel.setPosition(position);\n\t\t\tif (options.volume) {\n\t\t\t\tchannel.setVolume(options.volume);\n\t\t\t}\n\t\t\tif (options.loop) {\n\t\t\t\tchannel.setLoop(options.loop);\n\t\t\t}\n\t\t\tif (options.maxDistance) {\n\t\t\t\tchannel.setMaxDistance(options.maxDistance);\n\t\t\t}\n\t\t\tif (options.minDistance) {\n\t\t\t\tchannel.setMinDistance(options.minDistance);\n\t\t\t}\n\t\t\tif (options.rollOffFactor) {\n\t\t\t\tchannel.setRollOffFactor(options.rollOffFactor);\n\t\t\t}\n\t\t\tif (options.distanceModel) {\n\t\t\t\tchannel.setDistanceModel(options.distanceModel);\n\t\t\t}\n\t\t\tchannel.play();\n\t\t}\n\t\treturn channel;\n\t}\n\t_resume() {\n\t\tthis._context.resume().then(() => {\n\t\t\tconst source = this._context.createBufferSource();\n\t\t\tsource.buffer = this._context.createBuffer(1, 1, this._context.sampleRate);\n\t\t\tsource.connect(this._context.destination);\n\t\t\tsource.start(0);\n\t\t\tsource.onended = event => {\n\t\t\t\tsource.disconnect(0);\n\t\t\t\tthis.fire('resume');\n\t\t\t};\n\t\t}, e => {}).catch(e => {});\n\t}\n\t_suspend() {\n\t\tthis._context.suspend().then(() => {\n\t\t\tthis.fire('suspend');\n\t\t}, e => {}).catch(e => {});\n\t}\n\t_unlockHandler() {\n\t\tthis._removeUnlockListeners();\n\t\tif (!this._userSuspended && this._context.state !== CONTEXT_STATE_RUNNING) {\n\t\t\tthis._resume();\n\t\t}\n\t}\n\t_registerUnlockListeners() {\n\t\tUSER_INPUT_EVENTS.forEach(eventName => {\n\t\t\twindow.addEventListener(eventName, this._unlockHandlerFunc, false);\n\t\t});\n\t}\n\t_removeUnlockListeners() {\n\t\tUSER_INPUT_EVENTS.forEach(eventName => {\n\t\t\twindow.removeEventListener(eventName, this._unlockHandlerFunc, false);\n\t\t});\n\t}\n}\n\nexport { SoundManager };\n", "class Sound {\n\tconstructor(resource) {\n\t\tthis.audio = void 0;\n\t\tthis.buffer = void 0;\n\t\tif (resource instanceof Audio) {\n\t\t\tthis.audio = resource;\n\t\t} else {\n\t\t\tthis.buffer = resource;\n\t\t}\n\t}\n\tget duration() {\n\t\tlet duration = 0;\n\t\tif (this.buffer) {\n\t\t\tduration = this.buffer.duration;\n\t\t} else if (this.audio) {\n\t\t\tduration = this.audio.duration;\n\t\t}\n\t\treturn duration || 0;\n\t}\n}\n\nexport { Sound };\n", "import { EventHandler } from '../../core/event-handler.js';\nimport { math } from '../../core/math/math.js';\nimport { hasAudioContext } from '../audio/capabilities.js';\n\nconst STATE_PLAYING = 0;\nconst STATE_PAUSED = 1;\nconst STATE_STOPPED = 2;\nfunction capTime(time, duration) {\n\treturn time % duration || 0;\n}\nclass SoundInstance extends EventHandler {\n\tconstructor(manager, sound, options) {\n\t\tsuper();\n\t\tthis.source = null;\n\t\tthis._manager = manager;\n\t\tthis._volume = options.volume !== undefined ? math.clamp(Number(options.volume) || 0, 0, 1) : 1;\n\t\tthis._pitch = options.pitch !== undefined ? Math.max(0.01, Number(options.pitch) || 0) : 1;\n\t\tthis._loop = !!(options.loop !== undefined ? options.loop : false);\n\t\tthis._sound = sound;\n\t\tthis._state = STATE_STOPPED;\n\t\tthis._suspended = false;\n\t\tthis._suspendEndEvent = 0;\n\t\tthis._suspendInstanceEvents = false;\n\t\tthis._playWhenLoaded = true;\n\t\tthis._startTime = Math.max(0, Number(options.startTime) || 0);\n\t\tthis._duration = Math.max(0, Number(options.duration) || 0);\n\t\tthis._startOffset = null;\n\t\tthis._onPlayCallback = options.onPlay;\n\t\tthis._onPauseCallback = options.onPause;\n\t\tthis._onResumeCallback = options.onResume;\n\t\tthis._onStopCallback = options.onStop;\n\t\tthis._onEndCallback = options.onEnd;\n\t\tif (hasAudioContext()) {\n\t\t\tthis._startedAt = 0;\n\t\t\tthis._currentTime = 0;\n\t\t\tthis._currentOffset = 0;\n\t\t\tthis._inputNode = null;\n\t\t\tthis._connectorNode = null;\n\t\t\tthis._firstNode = null;\n\t\t\tthis._lastNode = null;\n\t\t\tthis._waitingContextSuspension = false;\n\t\t\tthis._initializeNodes();\n\t\t\tthis._endedHandler = this._onEnded.bind(this);\n\t\t} else {\n\t\t\tthis._isReady = false;\n\t\t\tthis._loadedMetadataHandler = this._onLoadedMetadata.bind(this);\n\t\t\tthis._timeUpdateHandler = this._onTimeUpdate.bind(this);\n\t\t\tthis._endedHandler = this._onEnded.bind(this);\n\t\t\tthis._createSource();\n\t\t}\n\t}\n\tset currentTime(value) {\n\t\tif (value < 0) return;\n\t\tif (this._state === STATE_PLAYING) {\n\t\t\tconst suspend = this._suspendInstanceEvents;\n\t\t\tthis._suspendInstanceEvents = true;\n\t\t\tthis.stop();\n\t\t\tthis._startOffset = value;\n\t\t\tthis.play();\n\t\t\tthis._suspendInstanceEvents = suspend;\n\t\t} else {\n\t\t\tthis._startOffset = value;\n\t\t\tthis._currentTime = value;\n\t\t}\n\t}\n\tget currentTime() {\n\t\tif (this._startOffset !== null) {\n\t\t\treturn this._startOffset;\n\t\t}\n\t\tif (this._state === STATE_PAUSED) {\n\t\t\treturn this._currentTime;\n\t\t}\n\t\tif (this._state === STATE_STOPPED || !this.source) {\n\t\t\treturn 0;\n\t\t}\n\t\tthis._updateCurrentTime();\n\t\treturn this._currentTime;\n\t}\n\tset duration(value) {\n\t\tthis._duration = Math.max(0, Number(value) || 0);\n\t\tconst isPlaying = this._state === STATE_PLAYING;\n\t\tthis.stop();\n\t\tif (isPlaying) {\n\t\t\tthis.play();\n\t\t}\n\t}\n\tget duration() {\n\t\tif (!this._sound) {\n\t\t\treturn 0;\n\t\t}\n\t\tif (this._duration) {\n\t\t\treturn capTime(this._duration, this._sound.duration);\n\t\t}\n\t\treturn this._sound.duration;\n\t}\n\tget isPaused() {\n\t\treturn this._state === STATE_PAUSED;\n\t}\n\tget isPlaying() {\n\t\treturn this._state === STATE_PLAYING;\n\t}\n\tget isStopped() {\n\t\treturn this._state === STATE_STOPPED;\n\t}\n\tget isSuspended() {\n\t\treturn this._suspended;\n\t}\n\tset loop(value) {\n\t\tthis._loop = !!value;\n\t\tif (this.source) {\n\t\t\tthis.source.loop = this._loop;\n\t\t}\n\t}\n\tget loop() {\n\t\treturn this._loop;\n\t}\n\tset pitch(pitch) {\n\t\tthis._currentOffset = this.currentTime;\n\t\tthis._startedAt = this._manager.context.currentTime;\n\t\tthis._pitch = Math.max(Number(pitch) || 0, 0.01);\n\t\tif (this.source) {\n\t\t\tthis.source.playbackRate.value = this._pitch;\n\t\t}\n\t}\n\tget pitch() {\n\t\treturn this._pitch;\n\t}\n\tset sound(value) {\n\t\tthis._sound = value;\n\t\tif (this._state !== STATE_STOPPED) {\n\t\t\tthis.stop();\n\t\t} else {\n\t\t\tthis._createSource();\n\t\t}\n\t}\n\tget sound() {\n\t\treturn this._sound;\n\t}\n\tset startTime(value) {\n\t\tthis._startTime = Math.max(0, Number(value) || 0);\n\t\tconst isPlaying = this._state === STATE_PLAYING;\n\t\tthis.stop();\n\t\tif (isPlaying) {\n\t\t\tthis.play();\n\t\t}\n\t}\n\tget startTime() {\n\t\treturn this._startTime;\n\t}\n\tset volume(volume) {\n\t\tvolume = math.clamp(volume, 0, 1);\n\t\tthis._volume = volume;\n\t\tif (this.gain) {\n\t\t\tthis.gain.gain.value = volume * this._manager.volume;\n\t\t}\n\t}\n\tget volume() {\n\t\treturn this._volume;\n\t}\n\t_onPlay() {\n\t\tthis.fire('play');\n\t\tif (this._onPlayCallback) this._onPlayCallback(this);\n\t}\n\t_onPause() {\n\t\tthis.fire('pause');\n\t\tif (this._onPauseCallback) this._onPauseCallback(this);\n\t}\n\t_onResume() {\n\t\tthis.fire('resume');\n\t\tif (this._onResumeCallback) this._onResumeCallback(this);\n\t}\n\t_onStop() {\n\t\tthis.fire('stop');\n\t\tif (this._onStopCallback) this._onStopCallback(this);\n\t}\n\t_onEnded() {\n\t\tif (this._suspendEndEvent > 0) {\n\t\t\tthis._suspendEndEvent--;\n\t\t\treturn;\n\t\t}\n\t\tthis.fire('end');\n\t\tif (this._onEndCallback) this._onEndCallback(this);\n\t\tthis.stop();\n\t}\n\t_onManagerVolumeChange() {\n\t\tthis.volume = this._volume;\n\t}\n\t_onManagerSuspend() {\n\t\tif (this._state === STATE_PLAYING && !this._suspended) {\n\t\t\tthis._suspended = true;\n\t\t\tthis.pause();\n\t\t}\n\t}\n\t_onManagerResume() {\n\t\tif (this._suspended) {\n\t\t\tthis._suspended = false;\n\t\t\tthis.resume();\n\t\t}\n\t}\n\t_initializeNodes() {\n\t\tthis.gain = this._manager.context.createGain();\n\t\tthis._inputNode = this.gain;\n\t\tthis._connectorNode = this.gain;\n\t\tthis._connectorNode.connect(this._manager.context.destination);\n\t}\n\tplay() {\n\t\tif (this._state !== STATE_STOPPED) {\n\t\t\tthis.stop();\n\t\t}\n\t\tthis._state = STATE_PLAYING;\n\t\tthis._playWhenLoaded = false;\n\t\tif (this._waitingContextSuspension) {\n\t\t\treturn false;\n\t\t}\n\t\tif (this._manager.suspended) {\n\t\t\tthis._manager.once('resume', this._playAudioImmediate, this);\n\t\t\tthis._waitingContextSuspension = true;\n\t\t\treturn false;\n\t\t}\n\t\tthis._playAudioImmediate();\n\t\treturn true;\n\t}\n\t_playAudioImmediate() {\n\t\tthis._waitingContextSuspension = false;\n\t\tif (this._state !== STATE_PLAYING) {\n\t\t\treturn;\n\t\t}\n\t\tif (!this.source) {\n\t\t\tthis._createSource();\n\t\t}\n\t\tlet offset = capTime(this._startOffset, this.duration);\n\t\toffset = capTime(this._startTime + offset, this._sound.duration);\n\t\tthis._startOffset = null;\n\t\tif (this._duration) {\n\t\t\tthis.source.start(0, offset, this._duration);\n\t\t} else {\n\t\t\tthis.source.start(0, offset);\n\t\t}\n\t\tthis._startedAt = this._manager.context.currentTime;\n\t\tthis._currentTime = 0;\n\t\tthis._currentOffset = offset;\n\t\tthis.volume = this._volume;\n\t\tthis.loop = this._loop;\n\t\tthis.pitch = this._pitch;\n\t\tthis._manager.on('volumechange', this._onManagerVolumeChange, this);\n\t\tthis._manager.on('suspend', this._onManagerSuspend, this);\n\t\tthis._manager.on('resume', this._onManagerResume, this);\n\t\tthis._manager.on('destroy', this._onManagerDestroy, this);\n\t\tif (!this._suspendInstanceEvents) {\n\t\t\tthis._onPlay();\n\t\t}\n\t}\n\tpause() {\n\t\tthis._playWhenLoaded = false;\n\t\tif (this._state !== STATE_PLAYING) return false;\n\t\tthis._state = STATE_PAUSED;\n\t\tif (this._waitingContextSuspension) {\n\t\t\treturn true;\n\t\t}\n\t\tthis._updateCurrentTime();\n\t\tthis._suspendEndEvent++;\n\t\tthis.source.stop(0);\n\t\tthis.source = null;\n\t\tthis._startOffset = null;\n\t\tif (!this._suspendInstanceEvents) this._onPause();\n\t\treturn true;\n\t}\n\tresume() {\n\t\tif (this._state !== STATE_PAUSED) {\n\t\t\treturn false;\n\t\t}\n\t\tlet offset = this.currentTime;\n\t\tthis._state = STATE_PLAYING;\n\t\tif (this._waitingContextSuspension) {\n\t\t\treturn true;\n\t\t}\n\t\tif (!this.source) {\n\t\t\tthis._createSource();\n\t\t}\n\t\tif (this._startOffset !== null) {\n\t\t\toffset = capTime(this._startOffset, this.duration);\n\t\t\toffset = capTime(this._startTime + offset, this._sound.duration);\n\t\t\tthis._startOffset = null;\n\t\t}\n\t\tif (this._duration) {\n\t\t\tthis.source.start(0, offset, this._duration);\n\t\t} else {\n\t\t\tthis.source.start(0, offset);\n\t\t}\n\t\tthis._startedAt = this._manager.context.currentTime;\n\t\tthis._currentOffset = offset;\n\t\tthis.volume = this._volume;\n\t\tthis.loop = this._loop;\n\t\tthis.pitch = this._pitch;\n\t\tthis._playWhenLoaded = false;\n\t\tif (!this._suspendInstanceEvents) this._onResume();\n\t\treturn true;\n\t}\n\tstop() {\n\t\tthis._playWhenLoaded = false;\n\t\tif (this._state === STATE_STOPPED) return false;\n\t\tconst wasPlaying = this._state === STATE_PLAYING;\n\t\tthis._state = STATE_STOPPED;\n\t\tif (this._waitingContextSuspension) {\n\t\t\treturn true;\n\t\t}\n\t\tthis._manager.off('volumechange', this._onManagerVolumeChange, this);\n\t\tthis._manager.off('suspend', this._onManagerSuspend, this);\n\t\tthis._manager.off('resume', this._onManagerResume, this);\n\t\tthis._manager.off('destroy', this._onManagerDestroy, this);\n\t\tthis._startedAt = 0;\n\t\tthis._currentTime = 0;\n\t\tthis._currentOffset = 0;\n\t\tthis._startOffset = null;\n\t\tthis._suspendEndEvent++;\n\t\tif (wasPlaying && this.source) {\n\t\t\tthis.source.stop(0);\n\t\t}\n\t\tthis.source = null;\n\t\tif (!this._suspendInstanceEvents) this._onStop();\n\t\treturn true;\n\t}\n\tsetExternalNodes(firstNode, lastNode) {\n\t\tif (!firstNode) {\n\t\t\tconsole.error('The firstNode must be a valid Audio Node');\n\t\t\treturn;\n\t\t}\n\t\tif (!lastNode) {\n\t\t\tlastNode = firstNode;\n\t\t}\n\t\tconst speakers = this._manager.context.destination;\n\t\tif (this._firstNode !== firstNode) {\n\t\t\tif (this._firstNode) {\n\t\t\t\tthis._connectorNode.disconnect(this._firstNode);\n\t\t\t} else {\n\t\t\t\tthis._connectorNode.disconnect(speakers);\n\t\t\t}\n\t\t\tthis._firstNode = firstNode;\n\t\t\tthis._connectorNode.connect(firstNode);\n\t\t}\n\t\tif (this._lastNode !== lastNode) {\n\t\t\tif (this._lastNode) {\n\t\t\t\tthis._lastNode.disconnect(speakers);\n\t\t\t}\n\t\t\tthis._lastNode = lastNode;\n\t\t\tthis._lastNode.connect(speakers);\n\t\t}\n\t}\n\tclearExternalNodes() {\n\t\tconst speakers = this._manager.context.destination;\n\t\tif (this._firstNode) {\n\t\t\tthis._connectorNode.disconnect(this._firstNode);\n\t\t\tthis._firstNode = null;\n\t\t}\n\t\tif (this._lastNode) {\n\t\t\tthis._lastNode.disconnect(speakers);\n\t\t\tthis._lastNode = null;\n\t\t}\n\t\tthis._connectorNode.connect(speakers);\n\t}\n\tgetExternalNodes() {\n\t\treturn [this._firstNode, this._lastNode];\n\t}\n\t_createSource() {\n\t\tif (!this._sound) {\n\t\t\treturn null;\n\t\t}\n\t\tconst context = this._manager.context;\n\t\tif (this._sound.buffer) {\n\t\t\tthis.source = context.createBufferSource();\n\t\t\tthis.source.buffer = this._sound.buffer;\n\t\t\tthis.source.connect(this._inputNode);\n\t\t\tthis.source.onended = this._endedHandler;\n\t\t\tthis.source.loopStart = capTime(this._startTime, this.source.buffer.duration);\n\t\t\tif (this._duration) {\n\t\t\t\tthis.source.loopEnd = Math.max(this.source.loopStart, capTime(this._startTime + this._duration, this.source.buffer.duration));\n\t\t\t}\n\t\t}\n\t\treturn this.source;\n\t}\n\t_updateCurrentTime() {\n\t\tthis._currentTime = capTime((this._manager.context.currentTime - this._startedAt) * this._pitch + this._currentOffset, this.duration);\n\t}\n\t_onManagerDestroy() {\n\t\tif (this.source && this._state === STATE_PLAYING) {\n\t\t\tthis.source.stop(0);\n\t\t\tthis.source = null;\n\t\t}\n\t}\n}\nSoundInstance.EVENT_PLAY = 'play';\nSoundInstance.EVENT_PAUSE = 'pause';\nSoundInstance.EVENT_RESUME = 'resume';\nSoundInstance.EVENT_STOP = 'stop';\nSoundInstance.EVENT_END = 'end';\nif (!hasAudioContext()) {\n\tObject.assign(SoundInstance.prototype, {\n\t\tplay: function () {\n\t\t\tif (this._state !== STATE_STOPPED) {\n\t\t\t\tthis.stop();\n\t\t\t}\n\t\t\tif (!this.source) {\n\t\t\t\tif (!this._createSource()) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis.volume = this._volume;\n\t\t\tthis.pitch = this._pitch;\n\t\t\tthis.loop = this._loop;\n\t\t\tthis.source.play();\n\t\t\tthis._state = STATE_PLAYING;\n\t\t\tthis._playWhenLoaded = false;\n\t\t\tthis._manager.on('volumechange', this._onManagerVolumeChange, this);\n\t\t\tthis._manager.on('suspend', this._onManagerSuspend, this);\n\t\t\tthis._manager.on('resume', this._onManagerResume, this);\n\t\t\tthis._manager.on('destroy', this._onManagerDestroy, this);\n\t\t\tif (this._manager.suspended) this._onManagerSuspend();\n\t\t\tif (!this._suspendInstanceEvents) this._onPlay();\n\t\t\treturn true;\n\t\t},\n\t\tpause: function () {\n\t\t\tif (!this.source || this._state !== STATE_PLAYING) return false;\n\t\t\tthis._suspendEndEvent++;\n\t\t\tthis.source.pause();\n\t\t\tthis._playWhenLoaded = false;\n\t\t\tthis._state = STATE_PAUSED;\n\t\t\tthis._startOffset = null;\n\t\t\tif (!this._suspendInstanceEvents) this._onPause();\n\t\t\treturn true;\n\t\t},\n\t\tresume: function () {\n\t\t\tif (!this.source || this._state !== STATE_PAUSED) return false;\n\t\t\tthis._state = STATE_PLAYING;\n\t\t\tthis._playWhenLoaded = false;\n\t\t\tif (this.source.paused) {\n\t\t\t\tthis.source.play();\n\t\t\t\tif (!this._suspendInstanceEvents) this._onResume();\n\t\t\t}\n\t\t\treturn true;\n\t\t},\n\t\tstop: function () {\n\t\t\tif (!this.source || this._state === STATE_STOPPED) return false;\n\t\t\tthis._manager.off('volumechange', this._onManagerVolumeChange, this);\n\t\t\tthis._manager.off('suspend', this._onManagerSuspend, this);\n\t\t\tthis._manager.off('resume', this._onManagerResume, this);\n\t\t\tthis._manager.off('destroy', this._onManagerDestroy, this);\n\t\t\tthis._suspendEndEvent++;\n\t\t\tthis.source.pause();\n\t\t\tthis._playWhenLoaded = false;\n\t\t\tthis._state = STATE_STOPPED;\n\t\t\tthis._startOffset = null;\n\t\t\tif (!this._suspendInstanceEvents) this._onStop();\n\t\t\treturn true;\n\t\t},\n\t\tsetExternalNodes: function () {},\n\t\tclearExternalNodes: function () {},\n\t\tgetExternalNodes: function () {\n\t\t\treturn [null, null];\n\t\t},\n\t\t_onLoadedMetadata: function () {\n\t\t\tthis.source.removeEventListener('loadedmetadata', this._loadedMetadataHandler);\n\t\t\tthis._isReady = true;\n\t\t\tlet offset = capTime(this._startOffset, this.duration);\n\t\t\toffset = capTime(this._startTime + offset, this._sound.duration);\n\t\t\tthis._startOffset = null;\n\t\t\tthis.source.currentTime = offset;\n\t\t},\n\t\t_createSource: function () {\n\t\t\tif (this._sound && this._sound.audio) {\n\t\t\t\tthis._isReady = false;\n\t\t\t\tthis.source = this._sound.audio.cloneNode(true);\n\t\t\t\tthis.source.addEventListener('loadedmetadata', this._loadedMetadataHandler);\n\t\t\t\tthis.source.addEventListener('timeupdate', this._timeUpdateHandler);\n\t\t\t\tthis.source.onended = this._endedHandler;\n\t\t\t}\n\t\t\treturn this.source;\n\t\t},\n\t\t_onTimeUpdate: function () {\n\t\t\tif (!this._duration) return;\n\t\t\tif (this.source.currentTime > capTime(this._startTime + this._duration, this.source.duration)) {\n\t\t\t\tif (this.loop) {\n\t\t\t\t\tthis.source.currentTime = capTime(this._startTime, this.source.duration);\n\t\t\t\t} else {\n\t\t\t\t\tthis.source.removeEventListener('timeupdate', this._timeUpdateHandler);\n\t\t\t\t\tthis.source.pause();\n\t\t\t\t\tthis._onEnded();\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\t_onManagerDestroy: function () {\n\t\t\tif (this.source) {\n\t\t\t\tthis.source.pause();\n\t\t\t}\n\t\t}\n\t});\n\tObject.defineProperty(SoundInstance.prototype, 'volume', {\n\t\tget: function () {\n\t\t\treturn this._volume;\n\t\t},\n\t\tset: function (volume) {\n\t\t\tvolume = math.clamp(volume, 0, 1);\n\t\t\tthis._volume = volume;\n\t\t\tif (this.source) {\n\t\t\t\tthis.source.volume = volume * this._manager.volume;\n\t\t\t}\n\t\t}\n\t});\n\tObject.defineProperty(SoundInstance.prototype, 'pitch', {\n\t\tget: function () {\n\t\t\treturn this._pitch;\n\t\t},\n\t\tset: function (pitch) {\n\t\t\tthis._pitch = Math.max(Number(pitch) || 0, 0.01);\n\t\t\tif (this.source) {\n\t\t\t\tthis.source.playbackRate = this._pitch;\n\t\t\t}\n\t\t}\n\t});\n\tObject.defineProperty(SoundInstance.prototype, 'sound', {\n\t\tget: function () {\n\t\t\treturn this._sound;\n\t\t},\n\t\tset: function (value) {\n\t\t\tthis.stop();\n\t\t\tthis._sound = value;\n\t\t}\n\t});\n\tObject.defineProperty(SoundInstance.prototype, 'currentTime', {\n\t\tget: function () {\n\t\t\tif (this._startOffset !== null) {\n\t\t\t\treturn this._startOffset;\n\t\t\t}\n\t\t\tif (this._state === STATE_STOPPED || !this.source) {\n\t\t\t\treturn 0;\n\t\t\t}\n\t\t\treturn this.source.currentTime - this._startTime;\n\t\t},\n\t\tset: function (value) {\n\t\t\tif (value < 0) return;\n\t\t\tthis._startOffset = value;\n\t\t\tif (this.source && this._isReady) {\n\t\t\t\tthis.source.currentTime = capTime(this._startTime + capTime(value, this.duration), this._sound.duration);\n\t\t\t\tthis._startOffset = null;\n\t\t\t}\n\t\t}\n\t});\n}\n\nexport { SoundInstance };\n", "import { math } from '../../core/math/math.js';\nimport { Vec3 } from '../../core/math/vec3.js';\nimport { DISTANCE_LINEAR, DISTANCE_INVERSE, DISTANCE_EXPONENTIAL } from '../audio/constants.js';\nimport { hasAudioContext } from '../audio/capabilities.js';\nimport { SoundInstance } from './instance.js';\n\nconst MAX_DISTANCE = 10000;\nclass SoundInstance3d extends SoundInstance {\n\tconstructor(manager, sound, options = {}) {\n\t\tsuper(manager, sound, options);\n\t\tthis._position = new Vec3();\n\t\tthis._velocity = new Vec3();\n\t\tif (options.position) this.position = options.position;\n\t\tthis.maxDistance = options.maxDistance !== undefined ? Number(options.maxDistance) : MAX_DISTANCE;\n\t\tthis.refDistance = options.refDistance !== undefined ? Number(options.refDistance) : 1;\n\t\tthis.rollOffFactor = options.rollOffFactor !== undefined ? Number(options.rollOffFactor) : 1;\n\t\tthis.distanceModel = options.distanceModel !== undefined ? options.distanceModel : DISTANCE_LINEAR;\n\t}\n\t_initializeNodes() {\n\t\tthis.gain = this._manager.context.createGain();\n\t\tthis.panner = this._manager.context.createPanner();\n\t\tthis.panner.connect(this.gain);\n\t\tthis._inputNode = this.panner;\n\t\tthis._connectorNode = this.gain;\n\t\tthis._connectorNode.connect(this._manager.context.destination);\n\t}\n\tset position(value) {\n\t\tthis._position.copy(value);\n\t\tconst panner = this.panner;\n\t\tif ('positionX' in panner) {\n\t\t\tpanner.positionX.value = value.x;\n\t\t\tpanner.positionY.value = value.y;\n\t\t\tpanner.positionZ.value = value.z;\n\t\t} else if (panner.setPosition) {\n\t\t\tpanner.setPosition(value.x, value.y, value.z);\n\t\t}\n\t}\n\tget position() {\n\t\treturn this._position;\n\t}\n\tset velocity(velocity) {\n\t\tthis._velocity.copy(velocity);\n\t}\n\tget velocity() {\n\t\treturn this._velocity;\n\t}\n\tset maxDistance(value) {\n\t\tthis.panner.maxDistance = value;\n\t}\n\tget maxDistance() {\n\t\treturn this.panner.maxDistance;\n\t}\n\tset refDistance(value) {\n\t\tthis.panner.refDistance = value;\n\t}\n\tget refDistance() {\n\t\treturn this.panner.refDistance;\n\t}\n\tset rollOffFactor(value) {\n\t\tthis.panner.rolloffFactor = value;\n\t}\n\tget rollOffFactor() {\n\t\treturn this.panner.rolloffFactor;\n\t}\n\tset distanceModel(value) {\n\t\tthis.panner.distanceModel = value;\n\t}\n\tget distanceModel() {\n\t\treturn this.panner.distanceModel;\n\t}\n}\nif (!hasAudioContext()) {\n\tlet offset = new Vec3();\n\tconst fallOff = function fallOff(posOne, posTwo, refDistance, maxDistance, rollOffFactor, distanceModel) {\n\t\toffset = offset.sub2(posOne, posTwo);\n\t\tconst distance = offset.length();\n\t\tif (distance < refDistance) {\n\t\t\treturn 1;\n\t\t} else if (distance > maxDistance) {\n\t\t\treturn 0;\n\t\t}\n\t\tlet result = 0;\n\t\tif (distanceModel === DISTANCE_LINEAR) {\n\t\t\tresult = 1 - rollOffFactor * (distance - refDistance) / (maxDistance - refDistance);\n\t\t} else if (distanceModel === DISTANCE_INVERSE) {\n\t\t\tresult = refDistance / (refDistance + rollOffFactor * (distance - refDistance));\n\t\t} else if (distanceModel === DISTANCE_EXPONENTIAL) {\n\t\t\tresult = Math.pow(distance / refDistance, -rollOffFactor);\n\t\t}\n\t\treturn math.clamp(result, 0, 1);\n\t};\n\tObject.defineProperty(SoundInstance3d.prototype, 'position', {\n\t\tget: function () {\n\t\t\treturn this._position;\n\t\t},\n\t\tset: function (position) {\n\t\t\tthis._position.copy(position);\n\t\t\tif (this.source) {\n\t\t\t\tconst listener = this._manager.listener;\n\t\t\t\tconst lpos = listener.getPosition();\n\t\t\t\tconst factor = fallOff(lpos, this._position, this.refDistance, this.maxDistance, this.rollOffFactor, this.distanceModel);\n\t\t\t\tconst v = this.volume;\n\t\t\t\tthis.source.volume = v * factor * this._manager.volume;\n\t\t\t}\n\t\t}\n\t});\n\tObject.defineProperty(SoundInstance3d.prototype, 'maxDistance', {\n\t\tget: function () {\n\t\t\treturn this._maxDistance;\n\t\t},\n\t\tset: function (value) {\n\t\t\tthis._maxDistance = value;\n\t\t}\n\t});\n\tObject.defineProperty(SoundInstance3d.prototype, 'refDistance', {\n\t\tget: function () {\n\t\t\treturn this._refDistance;\n\t\t},\n\t\tset: function (value) {\n\t\t\tthis._refDistance = value;\n\t\t}\n\t});\n\tObject.defineProperty(SoundInstance3d.prototype, 'rollOffFactor', {\n\t\tget: function () {\n\t\t\treturn this._rollOffFactor;\n\t\t},\n\t\tset: function (value) {\n\t\t\tthis._rollOffFactor = value;\n\t\t}\n\t});\n\tObject.defineProperty(SoundInstance3d.prototype, 'distanceModel', {\n\t\tget: function () {\n\t\t\treturn this._distanceModel;\n\t\t},\n\t\tset: function (value) {\n\t\t\tthis._distanceModel = value;\n\t\t}\n\t});\n}\n\nexport { SoundInstance3d };\n", "const BLEND_SUBTRACTIVE = 0;\nconst BLEND_ADDITIVE = 1;\nconst BLEND_NORMAL = 2;\nconst BLEND_NONE = 3;\nconst BLEND_PREMULTIPLIED = 4;\nconst BLEND_MULTIPLICATIVE = 5;\nconst BLEND_ADDITIVEALPHA = 6;\nconst BLEND_MULTIPLICATIVE2X = 7;\nconst BLEND_SCREEN = 8;\nconst BLEND_MIN = 9;\nconst BLEND_MAX = 10;\nconst FOG_NONE = 'none';\nconst FOG_LINEAR = 'linear';\nconst FOG_EXP = 'exp';\nconst FOG_EXP2 = 'exp2';\nconst FRESNEL_NONE = 0;\nconst FRESNEL_SCHLICK = 2;\nconst LAYER_HUD = 0;\nconst LAYER_GIZMO = 1;\nconst LAYER_FX = 2;\nconst LAYER_WORLD = 15;\nconst LAYERID_WORLD = 0;\nconst LAYERID_DEPTH = 1;\nconst LAYERID_SKYBOX = 2;\nconst LAYERID_IMMEDIATE = 3;\nconst LAYERID_UI = 4;\nconst LIGHTTYPE_DIRECTIONAL = 0;\nconst LIGHTTYPE_OMNI = 1;\nconst LIGHTTYPE_POINT = LIGHTTYPE_OMNI;\nconst LIGHTTYPE_SPOT = 2;\nconst LIGHTTYPE_COUNT = 3;\nconst LIGHTSHAPE_PUNCTUAL = 0;\nconst LIGHTSHAPE_RECT = 1;\nconst LIGHTSHAPE_DISK = 2;\nconst LIGHTSHAPE_SPHERE = 3;\nconst LIGHTFALLOFF_LINEAR = 0;\nconst LIGHTFALLOFF_INVERSESQUARED = 1;\nconst SHADOW_PCF3 = 0;\nconst SHADOW_DEPTH = 0;\nconst SHADOW_VSM8 = 1;\nconst SHADOW_VSM16 = 2;\nconst SHADOW_VSM32 = 3;\nconst SHADOW_PCF5 = 4;\nconst SHADOW_PCF1 = 5;\nconst SHADOW_PCSS = 6;\nconst shadowTypeToString = {};\nshadowTypeToString[SHADOW_PCF3] = 'PCF3';\nshadowTypeToString[SHADOW_VSM8] = 'VSM8';\nshadowTypeToString[SHADOW_VSM16] = 'VSM16';\nshadowTypeToString[SHADOW_VSM32] = 'VSM32';\nshadowTypeToString[SHADOW_PCF5] = 'PCF5';\nshadowTypeToString[SHADOW_PCF1] = 'PCF1';\nshadowTypeToString[SHADOW_PCSS] = 'PCSS';\nconst BLUR_BOX = 0;\nconst BLUR_GAUSSIAN = 1;\nconst PARTICLESORT_NONE = 0;\nconst PARTICLESORT_DISTANCE = 1;\nconst PARTICLESORT_NEWER_FIRST = 2;\nconst PARTICLESORT_OLDER_FIRST = 3;\nconst PARTICLEMODE_GPU = 0;\nconst PARTICLEMODE_CPU = 1;\nconst EMITTERSHAPE_BOX = 0;\nconst EMITTERSHAPE_SPHERE = 1;\nconst PARTICLEORIENTATION_SCREEN = 0;\nconst PARTICLEORIENTATION_WORLD = 1;\nconst PARTICLEORIENTATION_EMITTER = 2;\nconst PROJECTION_PERSPECTIVE = 0;\nconst PROJECTION_ORTHOGRAPHIC = 1;\nconst RENDERSTYLE_SOLID = 0;\nconst RENDERSTYLE_WIREFRAME = 1;\nconst RENDERSTYLE_POINTS = 2;\nconst CUBEPROJ_NONE = 0;\nconst CUBEPROJ_BOX = 1;\nconst SPECULAR_PHONG = 0;\nconst SPECULAR_BLINN = 1;\nconst DETAILMODE_MUL = 'mul';\nconst DETAILMODE_ADD = 'add';\nconst DETAILMODE_SCREEN = 'screen';\nconst DETAILMODE_OVERLAY = 'overlay';\nconst DETAILMODE_MIN = 'min';\nconst DETAILMODE_MAX = 'max';\nconst GAMMA_NONE = 0;\nconst GAMMA_SRGB = 1;\nconst GAMMA_SRGBFAST = 2;\nconst GAMMA_SRGBHDR = 3;\nconst TONEMAP_LINEAR = 0;\nconst TONEMAP_FILMIC = 1;\nconst TONEMAP_HEJL = 2;\nconst TONEMAP_ACES = 3;\nconst TONEMAP_ACES2 = 4;\nconst TONEMAP_NEUTRAL = 5;\nconst SPECOCC_NONE = 0;\nconst SPECOCC_AO = 1;\nconst SPECOCC_GLOSSDEPENDENT = 2;\nconst SHADERDEF_NOSHADOW = 1;\nconst SHADERDEF_SKIN = 2;\nconst SHADERDEF_UV0 = 4;\nconst SHADERDEF_UV1 = 8;\nconst SHADERDEF_VCOLOR = 16;\nconst SHADERDEF_INSTANCING = 32;\nconst SHADERDEF_LM = 64;\nconst SHADERDEF_DIRLM = 128;\nconst SHADERDEF_SCREENSPACE = 256;\nconst SHADERDEF_TANGENTS = 512;\nconst SHADERDEF_MORPH_POSITION = 1024;\nconst SHADERDEF_MORPH_NORMAL = 2048;\nconst SHADERDEF_MORPH_TEXTURE_BASED = 4096;\nconst SHADERDEF_LMAMBIENT = 8192;\nconst SHADOWUPDATE_NONE = 0;\nconst SHADOWUPDATE_THISFRAME = 1;\nconst SHADOWUPDATE_REALTIME = 2;\nconst SORTKEY_FORWARD = 0;\nconst SORTKEY_DEPTH = 1;\nconst MASK_AFFECT_DYNAMIC = 1;\nconst MASK_AFFECT_LIGHTMAPPED = 2;\nconst MASK_BAKE = 4;\nconst SHADER_FORWARD = 0;\nconst SHADER_FORWARDHDR = 1;\nconst SHADER_DEPTH = 2;\nconst SHADER_PICK = 3;\nconst SHADER_SHADOW = 4;\nconst SHADER_PREPASS_VELOCITY = 5;\nconst SHADERPASS_FORWARD = 'forward';\nconst SHADERPASS_ALBEDO = 'debug_albedo';\nconst SHADERPASS_WORLDNORMAL = 'debug_world_normal';\nconst SHADERPASS_OPACITY = 'debug_opacity';\nconst SHADERPASS_SPECULARITY = 'debug_specularity';\nconst SHADERPASS_GLOSS = 'debug_gloss';\nconst SHADERPASS_METALNESS = 'debug_metalness';\nconst SHADERPASS_AO = 'debug_ao';\nconst SHADERPASS_EMISSION = 'debug_emission';\nconst SHADERPASS_LIGHTING = 'debug_lighting';\nconst SHADERPASS_UV0 = 'debug_uv0';\nconst SPRITE_RENDERMODE_SIMPLE = 0;\nconst SPRITE_RENDERMODE_SLICED = 1;\nconst SPRITE_RENDERMODE_TILED = 2;\nconst BAKE_COLOR = 0;\nconst BAKE_COLORDIR = 1;\nconst VIEW_CENTER = 0;\nconst VIEW_LEFT = 1;\nconst VIEW_RIGHT = 2;\nconst SORTMODE_NONE = 0;\nconst SORTMODE_MANUAL = 1;\nconst SORTMODE_MATERIALMESH = 2;\nconst SORTMODE_BACK2FRONT = 3;\nconst SORTMODE_FRONT2BACK = 4;\nconst SORTMODE_CUSTOM = 5;\nconst ASPECT_AUTO = 0;\nconst ASPECT_MANUAL = 1;\nconst ORIENTATION_HORIZONTAL = 0;\nconst ORIENTATION_VERTICAL = 1;\nconst SKYTYPE_INFINITE = 'infinite';\nconst SKYTYPE_BOX = 'box';\nconst SKYTYPE_DOME = 'dome';\nconst DITHER_NONE = 'none';\nconst DITHER_BAYER8 = 'bayer8';\nconst DITHER_BLUENOISE = 'bluenoise';\nconst DITHER_IGNNOISE = 'ignnoise';\n\nexport { ASPECT_AUTO, ASPECT_MANUAL, BAKE_COLOR, BAKE_COLORDIR, BLEND_ADDITIVE, BLEND_ADDITIVEALPHA, BLEND_MAX, BLEND_MIN, BLEND_MULTIPLICATIVE, BLEND_MULTIPLICATIVE2X, BLEND_NONE, BLEND_NORMAL, BLEND_PREMULTIPLIED, BLEND_SCREEN, BLEND_SUBTRACTIVE, BLUR_BOX, BLUR_GAUSSIAN, CUBEPROJ_BOX, CUBEPROJ_NONE, DETAILMODE_ADD, DETAILMODE_MAX, DETAILMODE_MIN, DETAILMODE_MUL, DETAILMODE_OVERLAY, DETAILMODE_SCREEN, DITHER_BAYER8, DITHER_BLUENOISE, DITHER_IGNNOISE, DITHER_NONE, EMITTERSHAPE_BOX, EMITTERSHAPE_SPHERE, FOG_EXP, FOG_EXP2, FOG_LINEAR, FOG_NONE, FRESNEL_NONE, FRESNEL_SCHLICK, GAMMA_NONE, GAMMA_SRGB, GAMMA_SRGBFAST, GAMMA_SRGBHDR, LAYERID_DEPTH, LAYERID_IMMEDIATE, LAYERID_SKYBOX, LAYERID_UI, LAYERID_WORLD, LAYER_FX, LAYER_GIZMO, LAYER_HUD, LAYER_WORLD, LIGHTFALLOFF_INVERSESQUARED, LIGHTFALLOFF_LINEAR, LIGHTSHAPE_DISK, LIGHTSHAPE_PUNCTUAL, LIGHTSHAPE_RECT, LIGHTSHAPE_SPHERE, LIGHTTYPE_COUNT, LIGHTTYPE_DIRECTIONAL, LIGHTTYPE_OMNI, LIGHTTYPE_POINT, LIGHTTYPE_SPOT, MASK_AFFECT_DYNAMIC, MASK_AFFECT_LIGHTMAPPED, MASK_BAKE, ORIENTATION_HORIZONTAL, ORIENTATION_VERTICAL, PARTICLEMODE_CPU, PARTICLEMODE_GPU, PARTICLEORIENTATION_EMITTER, PARTICLEORIENTATION_SCREEN, PARTICLEORIENTATION_WORLD, PARTICLESORT_DISTANCE, PARTICLESORT_NEWER_FIRST, PARTICLESORT_NONE, PARTICLESORT_OLDER_FIRST, PROJECTION_ORTHOGRAPHIC, PROJECTION_PERSPECTIVE, RENDERSTYLE_POINTS, RENDERSTYLE_SOLID, RENDERSTYLE_WIREFRAME, SHADERDEF_DIRLM, SHADERDEF_INSTANCING, SHADERDEF_LM, SHADERDEF_LMAMBIENT, SHADERDEF_MORPH_NORMAL, SHADERDEF_MORPH_POSITION, SHADERDEF_MORPH_TEXTURE_BASED, SHADERDEF_NOSHADOW, SHADERDEF_SCREENSPACE, SHADERDEF_SKIN, SHADERDEF_TANGENTS, SHADERDEF_UV0, SHADERDEF_UV1, SHADERDEF_VCOLOR, SHADERPASS_ALBEDO, SHADERPASS_AO, SHADERPASS_EMISSION, SHADERPASS_FORWARD, SHADERPASS_GLOSS, SHADERPASS_LIGHTING, SHADERPASS_METALNESS, SHADERPASS_OPACITY, SHADERPASS_SPECULARITY, SHADERPASS_UV0, SHADERPASS_WORLDNORMAL, SHADER_DEPTH, SHADER_FORWARD, SHADER_FORWARDHDR, SHADER_PICK, SHADER_PREPASS_VELOCITY, SHADER_SHADOW, SHADOWUPDATE_NONE, SHADOWUPDATE_REALTIME, SHADOWUPDATE_THISFRAME, SHADOW_DEPTH, SHADOW_PCF1, SHADOW_PCF3, SHADOW_PCF5, SHADOW_PCSS, SHADOW_VSM16, SHADOW_VSM32, SHADOW_VSM8, SKYTYPE_BOX, SKYTYPE_DOME, SKYTYPE_INFINITE, SORTKEY_DEPTH, SORTKEY_FORWARD, SORTMODE_BACK2FRONT, SORTMODE_CUSTOM, SORTMODE_FRONT2BACK, SORTMODE_MANUAL, SORTMODE_MATERIALMESH, SORTMODE_NONE, SPECOCC_AO, SPECOCC_GLOSSDEPENDENT, SPECOCC_NONE, SPECULAR_BLINN, SPECULAR_PHONG, SPRITE_RENDERMODE_SIMPLE, SPRITE_RENDERMODE_SLICED, SPRITE_RENDERMODE_TILED, TONEMAP_ACES, TONEMAP_ACES2, TONEMAP_FILMIC, TONEMAP_HEJL, TONEMAP_LINEAR, TONEMAP_NEUTRAL, VIEW_CENTER, VIEW_LEFT, VIEW_RIGHT, shadowTypeToString };\n", "var alphaTestPS = `\nuniform float alpha_ref;\nvoid alphaTest(float a) {\n\tif (a < alpha_ref) discard;\n}\n`;\n\nexport { alphaTestPS as default };\n", "var ambientConstantPS = `\nvoid addAmbient(vec3 worldNormal) {\n\tdDiffuseLight += light_globalAmbient;\n}\n`;\n\nexport { ambientConstantPS as default };\n", "var ambientEnvPS = `\n#ifndef ENV_ATLAS\n#define ENV_ATLAS\nuniform sampler2D texture_envAtlas;\n#endif\nvoid addAmbient(vec3 worldNormal) {\n\tvec3 dir = normalize(cubeMapRotate(worldNormal) * vec3(-1.0, 1.0, 1.0));\n\tvec2 uv = mapUv(toSphericalUv(dir), vec4(128.0, 256.0 + 128.0, 64.0, 32.0) / atlasSize);\n\tvec4 raw = texture2D(texture_envAtlas, uv);\n\tvec3 linear = $DECODE(raw);\n\tdDiffuseLight += processEnvironment(linear);\n}\n`;\n\nexport { ambientEnvPS as default };\n", "var ambientSHPS = `\nuniform vec3 ambientSH[9];\nvoid addAmbient(vec3 worldNormal) {\n\tvec3 n = cubeMapRotate(worldNormal);\n\tvec3 color =\n\t\tambientSH[0] +\n\t\tambientSH[1] * n.x +\n\t\tambientSH[2] * n.y +\n\t\tambientSH[3] * n.z +\n\t\tambientSH[4] * n.x * n.z +\n\t\tambientSH[5] * n.z * n.y +\n\t\tambientSH[6] * n.y * n.x +\n\t\tambientSH[7] * (3.0 * n.z * n.z - 1.0) +\n\t\tambientSH[8] * (n.x * n.x - n.y * n.y);\n\tdDiffuseLight += processEnvironment(max(color, vec3(0.0)));\n}\n`;\n\nexport { ambientSHPS as default };\n", "var aoPS = `\nvoid getAO() {\n\tdAo = 1.0;\n\t#ifdef MAPTEXTURE\n\tfloat aoBase = texture2DBias($SAMPLER, $UV, textureBias).$CH;\n\tdAo *= addAoDetail(aoBase);\n\t#endif\n\t#ifdef MAPVERTEX\n\tdAo *= saturate(vVertexColor.$VC);\n\t#endif\n}\n`;\n\nexport { aoPS as default };\n", "var aoDetailMapPS = `\nfloat addAoDetail(float ao) {\n#ifdef MAPTEXTURE\n\tfloat aoDetail = texture2DBias($SAMPLER, $UV, textureBias).$CH;\n\treturn detailMode_$DETAILMODE(vec3(ao), vec3(aoDetail)).r;\n#else\n\treturn ao;\n#endif\n}\n`;\n\nexport { aoDetailMapPS as default };\n", "var aoDiffuseOccPS = `\nvoid occludeDiffuse(float ao) {\n\tdDiffuseLight *= ao;\n}\n`;\n\nexport { aoDiffuseOccPS as default };\n", "var aoSpecOccPS = `\nuniform float material_occludeSpecularIntensity;\nvoid occludeSpecular(float gloss, float ao, vec3 worldNormal, vec3 viewDir) {\n\tfloat specPow = exp2(gloss * 11.0);\n\tfloat specOcc = saturate(pow(dot(worldNormal, viewDir) + ao, 0.01*specPow) - 1.0 + ao);\n\tspecOcc = mix(1.0, specOcc, material_occludeSpecularIntensity);\n\tdSpecularLight *= specOcc;\n\tdReflection *= specOcc;\n\t\n#ifdef LIT_SHEEN\n\tsSpecularLight *= specOcc;\n\tsReflection *= specOcc;\n#endif\n}\n`;\n\nexport { aoSpecOccPS as default };\n", "var aoSpecOccConstPS = `\nvoid occludeSpecular(float gloss, float ao, vec3 worldNormal, vec3 viewDir) {\n\tfloat specPow = exp2(gloss * 11.0);\n\tfloat specOcc = saturate(pow(dot(worldNormal, viewDir) + ao, 0.01*specPow) - 1.0 + ao);\n\tdSpecularLight *= specOcc;\n\tdReflection *= specOcc;\n\t\n#ifdef LIT_SHEEN\n\tsSpecularLight *= specOcc;\n\tsReflection *= specOcc;\n#endif\n}\n`;\n\nexport { aoSpecOccConstPS as default };\n", "var aoSpecOccConstSimplePS = `\nvoid occludeSpecular(float gloss, float ao, vec3 worldNormal, vec3 viewDir) {\n\tdSpecularLight *= ao;\n\tdReflection *= ao;\n#ifdef LIT_SHEEN\n\tsSpecularLight *= ao;\n\tsReflection *= ao;\n#endif\n}\n`;\n\nexport { aoSpecOccConstSimplePS as default };\n", "var aoSpecOccSimplePS = `\nuniform float material_occludeSpecularIntensity;\nvoid occludeSpecular(float gloss, float ao, vec3 worldNormal, vec3 viewDir) {\n\tfloat specOcc = mix(1.0, ao, material_occludeSpecularIntensity);\n\tdSpecularLight *= specOcc;\n\tdReflection *= specOcc;\n#ifdef LIT_SHEEN\n\tsSpecularLight *= specOcc;\n\tsReflection *= specOcc;\n#endif\n}\n`;\n\nexport { aoSpecOccSimplePS as default };\n", "var basePS = `\nuniform vec3 view_position;\nuniform vec3 light_globalAmbient;\nfloat square(float x) {\n\treturn x*x;\n}\nfloat saturate(float x) {\n\treturn clamp(x, 0.0, 1.0);\n}\nvec3 saturate(vec3 x) {\n\treturn clamp(x, vec3(0.0), vec3(1.0));\n}\n`;\n\nexport { basePS as default };\n", "var baseVS = `\nattribute vec3 vertex_position;\nattribute vec3 vertex_normal;\nattribute vec4 vertex_tangent;\nattribute vec2 vertex_texCoord0;\nattribute vec2 vertex_texCoord1;\nattribute vec4 vertex_color;\nuniform mat4 matrix_viewProjection;\nuniform mat4 matrix_model;\nuniform mat3 matrix_normal;\nvec3 dPositionW;\nmat4 dModelMatrix;\nmat3 dNormalMatrix;\n`;\n\nexport { baseVS as default };\n", "var baseNineSlicedPS = `\n#define NINESLICED\nvarying vec2 vMask;\nvarying vec2 vTiledUv;\nuniform mediump vec4 innerOffset;\nuniform mediump vec2 outerScale;\nuniform mediump vec4 atlasRect;\nvec2 nineSlicedUv;\n`;\n\nexport { baseNineSlicedPS as default };\n", "var baseNineSlicedVS = `\n#define NINESLICED\nvarying vec2 vMask;\nvarying vec2 vTiledUv;\nuniform mediump vec4 innerOffset;\nuniform mediump vec2 outerScale;\nuniform mediump vec4 atlasRect;\n`;\n\nexport { baseNineSlicedVS as default };\n", "var baseNineSlicedTiledPS = `\n#define NINESLICED\n#define NINESLICETILED\nvarying vec2 vMask;\nvarying vec2 vTiledUv;\nuniform mediump vec4 innerOffset;\nuniform mediump vec2 outerScale;\nuniform mediump vec4 atlasRect;\nvec2 nineSlicedUv;\n`;\n\nexport { baseNineSlicedTiledPS as default };\n", "var bayerPS = `\nfloat bayer2(vec2 p) {\n\treturn mod(2.0 * p.y + p.x + 1.0, 4.0);\n}\nfloat bayer4(vec2 p) {\n\tvec2 p1 = mod(p, 2.0);\n\tvec2 p2 = floor(0.5 * mod(p, 4.0));\n\treturn 4.0 * bayer2(p1) + bayer2(p2);\n}\nfloat bayer8(vec2 p) {\n\tvec2 p1 = mod(p, 2.0);\n\tvec2 p2 = floor(0.5 * mod(p, 4.0));\n\tvec2 p4 = floor(0.25 * mod(p, 8.0));\n\treturn 4.0 * (4.0 * bayer2(p1) + bayer2(p2)) + bayer2(p4);\n}\n`;\n\nexport { bayerPS as default };\n", "var biasConstPS = `\n#define SHADOWBIAS\n#define SHADOW_SAMPLE_Z_BIAS\nfloat getShadowBias(float resolution, float maxBias) {\n\treturn maxBias;\n}\n`;\n\nexport { biasConstPS as default };\n", "var blurVSMPS = `\nvarying vec2 vUv0;\nuniform sampler2D source;\nuniform vec2 pixelOffset;\n#ifdef GAUSS\nuniform float weight[SAMPLES];\n#endif\n#ifdef PACKED\nfloat decodeFloatRG(vec2 rg) {\n\treturn rg.y*(1.0/255.0) + rg.x;\n}\nvec2 encodeFloatRG( float v ) {\n\tvec2 enc = vec2(1.0, 255.0) * v;\n\tenc = fract(enc);\n\tenc -= enc.yy * vec2(1.0/255.0, 1.0/255.0);\n\treturn enc;\n}\n#endif\nvoid main(void) {\n\tvec3 moments = vec3(0.0);\n\tvec2 uv = vUv0 - pixelOffset * (float(SAMPLES) * 0.5);\n\tfor (int i=0; i= vAbs.x && vAbs.z >= vAbs.y) {\n\t\tfaceIndex = dir.z < 0.0 ? 5.0 : 4.0;\n\t\tma = 0.5 / vAbs.z;\n\t\tuv = vec2(dir.z < 0.0 ? -dir.x : dir.x, -dir.y);\n\t\ttileOffset.x = 2.0;\n\t\ttileOffset.y = dir.z < 0.0 ? 1.0 : 0.0;\n\t} else if(vAbs.y >= vAbs.x) {\n\t\tfaceIndex = dir.y < 0.0 ? 3.0 : 2.0;\n\t\tma = 0.5 / vAbs.y;\n\t\tuv = vec2(dir.x, dir.y < 0.0 ? -dir.z : dir.z);\n\t\ttileOffset.x = 1.0;\n\t\ttileOffset.y = dir.y < 0.0 ? 1.0 : 0.0;\n\t} else {\n\t\tfaceIndex = dir.x < 0.0 ? 1.0 : 0.0;\n\t\tma = 0.5 / vAbs.x;\n\t\tuv = vec2(dir.x < 0.0 ? dir.z : -dir.z, -dir.y);\n\t\ttileOffset.x = 0.0;\n\t\ttileOffset.y = dir.x < 0.0 ? 1.0 : 0.0;\n\t}\n\treturn uv * ma + 0.5;\n}\nvec2 getCubemapAtlasCoordinates(const vec3 omniAtlasViewport, float shadowEdgePixels, float shadowTextureResolution, const vec3 dir) {\n\tfloat faceIndex;\n\tvec2 tileOffset;\n\tvec2 uv = getCubemapFaceCoordinates(dir, faceIndex, tileOffset);\n\tfloat atlasFaceSize = omniAtlasViewport.z;\n\tfloat tileSize = shadowTextureResolution * atlasFaceSize;\n\tfloat offset = shadowEdgePixels / tileSize;\n\tuv = uv * vec2(1.0 - offset * 2.0) + vec2(offset * 1.0);\n\tuv *= atlasFaceSize;\n\tuv += tileOffset * atlasFaceSize;\n\tuv += omniAtlasViewport.xy;\n\treturn uv;\n}\n`;\n\nexport { clusteredLightUtilsPS as default };\n", "var clusteredLightCookiesPS = `\nvec3 _getCookieClustered(TEXTURE_ACCEPT(tex), vec2 uv, float intensity, bool isRgb, vec4 cookieChannel) {\n\tvec4 pixel = mix(vec4(1.0), texture2DLodEXT(tex, uv, 0.0), intensity);\n\treturn isRgb == true ? pixel.rgb : vec3(dot(pixel, cookieChannel));\n}\nvec3 getCookie2DClustered(TEXTURE_ACCEPT(tex), mat4 transform, vec3 worldPosition, float intensity, bool isRgb, vec4 cookieChannel) {\n\tvec4 projPos = transform * vec4(worldPosition, 1.0);\n\treturn _getCookieClustered(TEXTURE_PASS(tex), projPos.xy / projPos.w, intensity, isRgb, cookieChannel);\n}\nvec3 getCookieCubeClustered(TEXTURE_ACCEPT(tex), vec3 dir, float intensity, bool isRgb, vec4 cookieChannel, float shadowTextureResolution, float shadowEdgePixels, vec3 omniAtlasViewport) {\n\tvec2 uv = getCubemapAtlasCoordinates(omniAtlasViewport, shadowEdgePixels, shadowTextureResolution, dir);\n\treturn _getCookieClustered(TEXTURE_PASS(tex), uv, intensity, isRgb, cookieChannel);\n}\n`;\n\nexport { clusteredLightCookiesPS as default };\n", "var clusteredLightShadowsPS = `\nvoid _getShadowCoordPerspZbuffer(mat4 shadowMatrix, vec4 shadowParams, vec3 wPos) {\n\tvec4 projPos = shadowMatrix * vec4(wPos, 1.0);\n\tprojPos.xyz /= projPos.w;\n\tdShadowCoord = projPos.xyz;\n}\nvoid getShadowCoordPerspZbufferNormalOffset(mat4 shadowMatrix, vec4 shadowParams, vec3 normal) {\n\tvec3 wPos = vPositionW + normal * shadowParams.y;\n\t_getShadowCoordPerspZbuffer(shadowMatrix, shadowParams, wPos);\n}\nvec3 normalOffsetPointShadow(vec4 shadowParams, vec3 lightPos, inout vec3 lightDir, vec3 lightDirNorm, vec3 normal) {\n\tfloat distScale = length(lightDir);\n\tvec3 wPos = vPositionW + normal * shadowParams.y * clamp(1.0 - dot(normal, -lightDirNorm), 0.0, 1.0) * distScale;\n\tvec3 dir = wPos - lightPos;\n\treturn dir;\n}\n#ifdef GL2\n\t#if defined(CLUSTER_SHADOW_TYPE_PCF1)\n\tfloat getShadowOmniClusteredPCF1(SHADOWMAP_ACCEPT(shadowMap), vec4 shadowParams, vec3 omniAtlasViewport, float shadowEdgePixels, vec3 lightDir) {\n\t\tfloat shadowTextureResolution = shadowParams.x;\n\t\tvec2 uv = getCubemapAtlasCoordinates(omniAtlasViewport, shadowEdgePixels, shadowTextureResolution, lightDir);\n\t\tfloat shadowZ = length(lightDir) * shadowParams.w + shadowParams.z;\n\t\treturn textureShadow(shadowMap, vec3(uv, shadowZ));\n\t}\n\t#endif\n\t#if defined(CLUSTER_SHADOW_TYPE_PCF3)\n\tfloat getShadowOmniClusteredPCF3(SHADOWMAP_ACCEPT(shadowMap), vec4 shadowParams, vec3 omniAtlasViewport, float shadowEdgePixels, vec3 lightDir) {\n\t\tfloat shadowTextureResolution = shadowParams.x;\n\t\tvec2 uv = getCubemapAtlasCoordinates(omniAtlasViewport, shadowEdgePixels, shadowTextureResolution, lightDir);\n\t\tfloat shadowZ = length(lightDir) * shadowParams.w + shadowParams.z;\n\t\tvec3 shadowCoord = vec3(uv, shadowZ);\n\t\treturn getShadowPCF3x3(SHADOWMAP_PASS(shadowMap), shadowCoord, shadowParams);\n\t}\n\t#endif\n\t#if defined(CLUSTER_SHADOW_TYPE_PCF5)\n\tfloat getShadowOmniClusteredPCF5(SHADOWMAP_ACCEPT(shadowMap), vec4 shadowParams, vec3 omniAtlasViewport, float shadowEdgePixels, vec3 lightDir) {\n\t\tfloat shadowTextureResolution = shadowParams.x;\n\t\tvec2 uv = getCubemapAtlasCoordinates(omniAtlasViewport, shadowEdgePixels, shadowTextureResolution, lightDir);\n\t\tfloat shadowZ = length(lightDir) * shadowParams.w + shadowParams.z;\n\t\tvec3 shadowCoord = vec3(uv, shadowZ);\n\t\treturn getShadowPCF5x5(SHADOWMAP_PASS(shadowMap), shadowCoord, shadowParams);\n\t}\n\t#endif\n#else\n\t#if defined(CLUSTER_SHADOW_TYPE_PCF1)\n\tfloat getShadowOmniClusteredPCF1(sampler2D shadowMap, vec4 shadowParams, vec3 omniAtlasViewport, float shadowEdgePixels, vec3 lightDir) {\n\t\tfloat shadowTextureResolution = shadowParams.x;\n\t\tvec2 uv = getCubemapAtlasCoordinates(omniAtlasViewport, shadowEdgePixels, shadowTextureResolution, lightDir);\n\t\tfloat depth = unpackFloat(textureShadow(shadowMap, uv));\n\t\tfloat shadowZ = length(lightDir) * shadowParams.w + shadowParams.z;\n\t\treturn depth > shadowZ ? 1.0 : 0.0;\n\t}\n\t#endif\n\t#if defined(CLUSTER_SHADOW_TYPE_PCF3)\n\tfloat getShadowOmniClusteredPCF3(sampler2D shadowMap, vec4 shadowParams, vec3 omniAtlasViewport, float shadowEdgePixels, vec3 lightDir) {\n\t\tfloat shadowTextureResolution = shadowParams.x;\n\t\tvec2 uv = getCubemapAtlasCoordinates(omniAtlasViewport, shadowEdgePixels, shadowTextureResolution, lightDir);\n\t\tfloat shadowZ = length(lightDir) * shadowParams.w + shadowParams.z;\n\t\tvec3 shadowCoord = vec3(uv, shadowZ);\n\t\treturn getShadowPCF3x3(shadowMap, shadowCoord, shadowParams);\n\t}\n\t#endif\n\t#if defined(CLUSTER_SHADOW_TYPE_PCF5)\n\tfloat getShadowOmniClusteredPCF5(sampler2D shadowMap, vec4 shadowParams, vec3 omniAtlasViewport, float shadowEdgePixels, vec3 lightDir) {\n\t\tfloat shadowTextureResolution = shadowParams.x;\n\t\tvec2 uv = getCubemapAtlasCoordinates(omniAtlasViewport, shadowEdgePixels, shadowTextureResolution, lightDir);\n\t\tfloat shadowZ = length(lightDir) * shadowParams.w + shadowParams.z;\n\t\tvec3 shadowCoord = vec3(uv, shadowZ);\n\t\treturn getShadowPCF3x3(shadowMap, shadowCoord, shadowParams);\n\t}\n\t#endif\n#endif\n#ifdef GL2\n\t#if defined(CLUSTER_SHADOW_TYPE_PCF1)\n\tfloat getShadowSpotClusteredPCF1(SHADOWMAP_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams) {\n\t\treturn textureShadow(shadowMap, shadowCoord);\n\t}\n\t#endif\n\t#if defined(CLUSTER_SHADOW_TYPE_PCF3)\n\tfloat getShadowSpotClusteredPCF3(SHADOWMAP_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams) {\n\t\treturn getShadowSpotPCF3x3(SHADOWMAP_PASS(shadowMap), shadowCoord, shadowParams);\n\t}\n\t#endif\n\t#if defined(CLUSTER_SHADOW_TYPE_PCF5)\n\tfloat getShadowSpotClusteredPCF5(SHADOWMAP_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams) {\n\t\treturn getShadowPCF5x5(SHADOWMAP_PASS(shadowMap), shadowCoord, shadowParams);\n\t}\n\t#endif\n#else\n\t#if defined(CLUSTER_SHADOW_TYPE_PCF1)\n\tfloat getShadowSpotClusteredPCF1(sampler2D shadowMap, vec3 shadowCoord, vec4 shadowParams) {\n\t\tfloat depth = unpackFloat(textureShadow(shadowMap, shadowCoord.xy));\n\t\treturn depth > shadowCoord.z ? 1.0 : 0.0;\n\t}\n\t#endif\n\t#if defined(CLUSTER_SHADOW_TYPE_PCF3)\n\tfloat getShadowSpotClusteredPCF3(sampler2D shadowMap, vec3 shadowCoord, vec4 shadowParams) {\n\t\treturn getShadowSpotPCF3x3(shadowMap, shadowCoord, shadowParams);\n\t}\n\t#endif\n\t#if defined(CLUSTER_SHADOW_TYPE_PCF5)\n\tfloat getShadowSpotClusteredPCF5(sampler2D shadowMap, vec3 shadowCoord, vec4 shadowParams) {\n\t\treturn getShadowSpotPCF3x3(shadowMap, shadowCoord, shadowParams);\n\t}\n\t#endif\n#endif\n`;\n\nexport { clusteredLightShadowsPS as default };\n", "var clusteredLightPS = `\nuniform highp sampler2D clusterWorldTexture;\nuniform highp sampler2D lightsTexture8;\nuniform highp sampler2D lightsTextureFloat;\n#if defined(CLUSTER_COOKIES)\n\t#define CLUSTER_COOKIES_OR_SHADOWS\n#endif\n#if defined(CLUSTER_SHADOWS)\n\t#define CLUSTER_COOKIES_OR_SHADOWS\n#endif\n#ifdef CLUSTER_SHADOWS\n\t#ifdef GL2\n\t\tuniform sampler2DShadow shadowAtlasTexture;\n\t#else\n\t\tuniform sampler2D shadowAtlasTexture;\n\t#endif\n#endif\n#ifdef CLUSTER_COOKIES\n\tuniform sampler2D cookieAtlasTexture;\n#endif\n#ifdef GL2\n\tuniform int clusterMaxCells;\n#else\n\tuniform float clusterMaxCells;\n\tuniform vec4 lightsTextureInvSize;\n#endif\nuniform float clusterSkip;\nuniform vec3 clusterCellsCountByBoundsSize;\nuniform vec3 clusterTextureSize;\nuniform vec3 clusterBoundsMin;\nuniform vec3 clusterBoundsDelta;\nuniform vec3 clusterCellsDot;\nuniform vec3 clusterCellsMax;\nuniform vec2 clusterCompressionLimit0;\nuniform vec2 shadowAtlasParams;\nstruct ClusterLightData {\n\tvec3 halfWidth;\n\tfloat lightType;\n\tvec3 halfHeight;\n\t#ifdef GL2\n\t\tint lightIndex;\n\t#else\n\t\tfloat lightV;\n\t#endif\n\tvec3 position;\n\tfloat shape;\n\tvec3 direction;\n\tfloat falloffMode;\n\tvec3 color;\n\tfloat shadowIntensity;\n\tvec3 omniAtlasViewport;\n\tfloat range;\n\tvec4 cookieChannelMask;\n\tfloat shadowBias;\n\tfloat shadowNormalBias;\n\tfloat innerConeAngleCos;\n\tfloat outerConeAngleCos;\n\tfloat cookie;\n\tfloat cookieRgb;\n\tfloat cookieIntensity;\n\tfloat mask;\n};\nmat4 lightProjectionMatrix;\n#define isClusteredLightCastShadow(light) ( light.shadowIntensity > 0.0 )\n#define isClusteredLightCookie(light) (light.cookie > 0.5 )\n#define isClusteredLightCookieRgb(light) (light.cookieRgb > 0.5 )\n#define isClusteredLightSpot(light) ( light.lightType > 0.5 )\n#define isClusteredLightFalloffLinear(light) ( light.falloffMode < 0.5 )\n#define isClusteredLightArea(light) ( light.shape > 0.1 )\n#define isClusteredLightRect(light) ( light.shape < 0.3 )\n#define isClusteredLightDisk(light) ( light.shape < 0.6 )\n#ifdef CLUSTER_MESH_DYNAMIC_LIGHTS\n\t#define acceptLightMask(light) ( light.mask < 0.75)\n#else\n\t#define acceptLightMask(light) ( light.mask > 0.25)\n#endif\nvec4 decodeClusterLowRange4Vec4(vec4 d0, vec4 d1, vec4 d2, vec4 d3) {\n\treturn vec4(\n\t\tbytes2floatRange4(d0, -2.0, 2.0),\n\t\tbytes2floatRange4(d1, -2.0, 2.0),\n\t\tbytes2floatRange4(d2, -2.0, 2.0),\n\t\tbytes2floatRange4(d3, -2.0, 2.0)\n\t);\n}\n#ifdef GL2\n\tvec4 sampleLightsTexture8(const ClusterLightData clusterLightData, int index) {\n\t\treturn texelFetch(lightsTexture8, ivec2(index, clusterLightData.lightIndex), 0);\n\t}\n\tvec4 sampleLightTextureF(const ClusterLightData clusterLightData, int index) {\n\t\treturn texelFetch(lightsTextureFloat, ivec2(index, clusterLightData.lightIndex), 0);\n\t}\n#else\n\tvec4 sampleLightsTexture8(const ClusterLightData clusterLightData, float index) {\n\t\treturn texture2DLodEXT(lightsTexture8, vec2(index * lightsTextureInvSize.z, clusterLightData.lightV), 0.0);\n\t}\n\tvec4 sampleLightTextureF(const ClusterLightData clusterLightData, float index) {\n\t\treturn texture2DLodEXT(lightsTextureFloat, vec2(index * lightsTextureInvSize.x, clusterLightData.lightV), 0.0);\n\t}\n#endif\nvoid decodeClusterLightCore(inout ClusterLightData clusterLightData, float lightIndex) {\n\t#ifdef GL2\n\t\tclusterLightData.lightIndex = int(lightIndex);\n\t#else\n\t\tclusterLightData.lightV = (lightIndex + 0.5) * lightsTextureInvSize.w;\n\t#endif\n\tvec4 lightInfo = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_FLAGS);\n\tclusterLightData.lightType = lightInfo.x;\n\tclusterLightData.shape = lightInfo.y;\n\tclusterLightData.falloffMode = lightInfo.z;\n\tclusterLightData.shadowIntensity = lightInfo.w;\n\tvec4 colorA = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_COLOR_A);\n\tvec4 colorB = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_COLOR_B);\n\tclusterLightData.color = vec3(bytes2float2(colorA.xy), bytes2float2(colorA.zw), bytes2float2(colorB.xy)) * clusterCompressionLimit0.y;\n\tclusterLightData.cookie = colorB.z;\n\tclusterLightData.mask = colorB.w;\n\t#ifdef CLUSTER_TEXTURE_FLOAT\n\t\tvec4 lightPosRange = sampleLightTextureF(clusterLightData, CLUSTER_TEXTURE_F_POSITION_RANGE);\n\t\tclusterLightData.position = lightPosRange.xyz;\n\t\tclusterLightData.range = lightPosRange.w;\n\t\tvec4 lightDir_Unused = sampleLightTextureF(clusterLightData, CLUSTER_TEXTURE_F_SPOT_DIRECTION);\n\t\tclusterLightData.direction = lightDir_Unused.xyz;\n\t#else\n\t\tvec4 encPosX = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_POSITION_X);\n\t\tvec4 encPosY = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_POSITION_Y);\n\t\tvec4 encPosZ = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_POSITION_Z);\n\t\tclusterLightData.position = vec3(bytes2float4(encPosX), bytes2float4(encPosY), bytes2float4(encPosZ)) * clusterBoundsDelta + clusterBoundsMin;\n\t\tvec4 encRange = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_RANGE);\n\t\tclusterLightData.range = bytes2float4(encRange) * clusterCompressionLimit0.x;\n\t\tvec4 encDirX = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_SPOT_DIRECTION_X);\n\t\tvec4 encDirY = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_SPOT_DIRECTION_Y);\n\t\tvec4 encDirZ = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_SPOT_DIRECTION_Z);\n\t\tclusterLightData.direction = vec3(bytes2float4(encDirX), bytes2float4(encDirY), bytes2float4(encDirZ)) * 2.0 - 1.0;\n\t#endif\n}\nvoid decodeClusterLightSpot(inout ClusterLightData clusterLightData) {\n\tvec4 coneAngle = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_SPOT_ANGLES);\n\tclusterLightData.innerConeAngleCos = bytes2float2(coneAngle.xy) * 2.0 - 1.0;\n\tclusterLightData.outerConeAngleCos = bytes2float2(coneAngle.zw) * 2.0 - 1.0;\n}\nvoid decodeClusterLightOmniAtlasViewport(inout ClusterLightData clusterLightData) {\n\t#ifdef CLUSTER_TEXTURE_FLOAT\n\t\tclusterLightData.omniAtlasViewport = sampleLightTextureF(clusterLightData, CLUSTER_TEXTURE_F_PROJ_MAT_0).xyz;\n\t#else\n\t\tvec4 viewportA = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_ATLAS_VIEWPORT_A);\n\t\tvec4 viewportB = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_ATLAS_VIEWPORT_B);\n\t\tclusterLightData.omniAtlasViewport = vec3(bytes2float2(viewportA.xy), bytes2float2(viewportA.zw), bytes2float2(viewportB.xy));\n\t#endif\n}\nvoid decodeClusterLightAreaData(inout ClusterLightData clusterLightData) {\n\t#ifdef CLUSTER_TEXTURE_FLOAT\n\t\tclusterLightData.halfWidth = sampleLightTextureF(clusterLightData, CLUSTER_TEXTURE_F_AREA_DATA_WIDTH).xyz;\n\t\tclusterLightData.halfHeight = sampleLightTextureF(clusterLightData, CLUSTER_TEXTURE_F_AREA_DATA_HEIGHT).xyz;\n\t#else\n\t\tvec4 areaWidthX = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_AREA_DATA_WIDTH_X);\n\t\tvec4 areaWidthY = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_AREA_DATA_WIDTH_Y);\n\t\tvec4 areaWidthZ = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_AREA_DATA_WIDTH_Z);\n\t\tclusterLightData.halfWidth = vec3(mantissaExponent2Float(areaWidthX), mantissaExponent2Float(areaWidthY), mantissaExponent2Float(areaWidthZ));\n\t\tvec4 areaHeightX = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_AREA_DATA_HEIGHT_X);\n\t\tvec4 areaHeightY = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_AREA_DATA_HEIGHT_Y);\n\t\tvec4 areaHeightZ = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_AREA_DATA_HEIGHT_Z);\n\t\tclusterLightData.halfHeight = vec3(mantissaExponent2Float(areaHeightX), mantissaExponent2Float(areaHeightY), mantissaExponent2Float(areaHeightZ));\n\t#endif\n}\nvoid decodeClusterLightProjectionMatrixData(inout ClusterLightData clusterLightData) {\n\t\n\t#ifdef CLUSTER_TEXTURE_FLOAT\n\t\tvec4 m0 = sampleLightTextureF(clusterLightData, CLUSTER_TEXTURE_F_PROJ_MAT_0);\n\t\tvec4 m1 = sampleLightTextureF(clusterLightData, CLUSTER_TEXTURE_F_PROJ_MAT_1);\n\t\tvec4 m2 = sampleLightTextureF(clusterLightData, CLUSTER_TEXTURE_F_PROJ_MAT_2);\n\t\tvec4 m3 = sampleLightTextureF(clusterLightData, CLUSTER_TEXTURE_F_PROJ_MAT_3);\n\t#else\n\t\tvec4 m00 = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_PROJ_MAT_00);\n\t\tvec4 m01 = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_PROJ_MAT_01);\n\t\tvec4 m02 = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_PROJ_MAT_02);\n\t\tvec4 m03 = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_PROJ_MAT_03);\n\t\tvec4 m0 = decodeClusterLowRange4Vec4(m00, m01, m02, m03);\n\t\tvec4 m10 = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_PROJ_MAT_10);\n\t\tvec4 m11 = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_PROJ_MAT_11);\n\t\tvec4 m12 = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_PROJ_MAT_12);\n\t\tvec4 m13 = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_PROJ_MAT_13);\n\t\tvec4 m1 = decodeClusterLowRange4Vec4(m10, m11, m12, m13);\n\t\tvec4 m20 = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_PROJ_MAT_20);\n\t\tvec4 m21 = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_PROJ_MAT_21);\n\t\tvec4 m22 = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_PROJ_MAT_22);\n\t\tvec4 m23 = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_PROJ_MAT_23);\n\t\tvec4 m2 = decodeClusterLowRange4Vec4(m20, m21, m22, m23);\n\t\tvec4 m30 = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_PROJ_MAT_30);\n\t\tvec4 m31 = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_PROJ_MAT_31);\n\t\tvec4 m32 = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_PROJ_MAT_32);\n\t\tvec4 m33 = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_PROJ_MAT_33);\n\t\tvec4 m3 = vec4(mantissaExponent2Float(m30), mantissaExponent2Float(m31), mantissaExponent2Float(m32), mantissaExponent2Float(m33));\n\t#endif\n\t\n\tlightProjectionMatrix = mat4(m0, m1, m2, m3);\n}\nvoid decodeClusterLightShadowData(inout ClusterLightData clusterLightData) {\n\t\n\tvec4 biases = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_SHADOW_BIAS);\n\tclusterLightData.shadowBias = bytes2floatRange2(biases.xy, -1.0, 20.0),\n\tclusterLightData.shadowNormalBias = bytes2float2(biases.zw);\n}\nvoid decodeClusterLightCookieData(inout ClusterLightData clusterLightData) {\n\tvec4 cookieA = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_COOKIE_A);\n\tclusterLightData.cookieIntensity = cookieA.x;\n\tclusterLightData.cookieRgb = cookieA.y;\n\tclusterLightData.cookieChannelMask = sampleLightsTexture8(clusterLightData, CLUSTER_TEXTURE_8_COOKIE_B);\n}\nvoid evaluateLight(\n\tClusterLightData light, \n\tvec3 worldNormal, \n\tvec3 viewDir, \n\tvec3 reflectionDir,\n#if defined(LIT_CLEARCOAT)\n\tvec3 clearcoatReflectionDir,\n#endif\n\tfloat gloss, \n\tvec3 specularity, \n\tvec3 geometricNormal, \n\tmat3 tbn, \n#if defined(LIT_IRIDESCENCE)\n\tvec3 iridescenceFresnel,\n#endif\n\tvec3 clearcoat_worldNormal,\n\tfloat clearcoat_gloss,\n\tfloat sheen_gloss,\n\tfloat iridescence_intensity\n) {\n\tvec3 cookieAttenuation = vec3(1.0);\n\tfloat diffuseAttenuation = 1.0;\n\tfloat falloffAttenuation = 1.0;\n\tgetLightDirPoint(light.position);\n\t#ifdef CLUSTER_AREALIGHTS\n\tif (isClusteredLightArea(light)) {\n\t\tdecodeClusterLightAreaData(light);\n\t\tif (isClusteredLightRect(light)) {\n\t\t\tcalcRectLightValues(light.position, light.halfWidth, light.halfHeight);\n\t\t} else if (isClusteredLightDisk(light)) {\n\t\t\tcalcDiskLightValues(light.position, light.halfWidth, light.halfHeight);\n\t\t} else {\n\t\t\tcalcSphereLightValues(light.position, light.halfWidth, light.halfHeight);\n\t\t}\n\t\tfalloffAttenuation = getFalloffWindow(light.range, dLightDirW);\n\t} else\n\t#endif\n\t{\n\t\tif (isClusteredLightFalloffLinear(light))\n\t\t\tfalloffAttenuation = getFalloffLinear(light.range, dLightDirW);\n\t\telse\n\t\t\tfalloffAttenuation = getFalloffInvSquared(light.range, dLightDirW);\n\t}\n\tif (falloffAttenuation > 0.00001) {\n\t\t#ifdef CLUSTER_AREALIGHTS\n\t\tif (isClusteredLightArea(light)) {\n\t\t\tif (isClusteredLightRect(light)) {\n\t\t\t\tdiffuseAttenuation = getRectLightDiffuse(worldNormal, viewDir, dLightDirW, dLightDirNormW) * 16.0;\n\t\t\t} else if (isClusteredLightDisk(light)) {\n\t\t\t\tdiffuseAttenuation = getDiskLightDiffuse(worldNormal, viewDir, dLightDirW, dLightDirNormW) * 16.0;\n\t\t\t} else {\n\t\t\t\tdiffuseAttenuation = getSphereLightDiffuse(worldNormal, viewDir, dLightDirW, dLightDirNormW) * 16.0;\n\t\t\t}\n\t\t} else\n\t\t#endif\n\t\t{\n\t\t\tfalloffAttenuation *= getLightDiffuse(worldNormal, viewDir, dLightDirW, dLightDirNormW); \n\t\t}\n\t\tif (isClusteredLightSpot(light)) {\n\t\t\tdecodeClusterLightSpot(light);\n\t\t\tfalloffAttenuation *= getSpotEffect(light.direction, light.innerConeAngleCos, light.outerConeAngleCos, dLightDirNormW);\n\t\t}\n\t\t#if defined(CLUSTER_COOKIES_OR_SHADOWS)\n\t\tif (falloffAttenuation > 0.00001) {\n\t\t\tif (isClusteredLightCastShadow(light) || isClusteredLightCookie(light)) {\n\t\t\t\tif (isClusteredLightSpot(light)) {\n\t\t\t\t\tdecodeClusterLightProjectionMatrixData(light);\n\t\t\t\t} else {\n\t\t\t\t\tdecodeClusterLightOmniAtlasViewport(light);\n\t\t\t\t}\n\t\t\t\tfloat shadowTextureResolution = shadowAtlasParams.x;\n\t\t\t\tfloat shadowEdgePixels = shadowAtlasParams.y;\n\t\t\t\t#ifdef CLUSTER_COOKIES\n\t\t\t\tif (isClusteredLightCookie(light)) {\n\t\t\t\t\tdecodeClusterLightCookieData(light);\n\t\t\t\t\tif (isClusteredLightSpot(light)) {\n\t\t\t\t\t\tcookieAttenuation = getCookie2DClustered(TEXTURE_PASS(cookieAtlasTexture), lightProjectionMatrix, vPositionW, light.cookieIntensity, isClusteredLightCookieRgb(light), light.cookieChannelMask);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tcookieAttenuation = getCookieCubeClustered(TEXTURE_PASS(cookieAtlasTexture), dLightDirW, light.cookieIntensity, isClusteredLightCookieRgb(light), light.cookieChannelMask, shadowTextureResolution, shadowEdgePixels, light.omniAtlasViewport);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\t#endif\n\t\t\t\t#ifdef CLUSTER_SHADOWS\n\t\t\t\tif (isClusteredLightCastShadow(light)) {\n\t\t\t\t\tdecodeClusterLightShadowData(light);\n\t\t\t\t\tvec4 shadowParams = vec4(shadowTextureResolution, light.shadowNormalBias, light.shadowBias, 1.0 / light.range);\n\t\t\t\t\tif (isClusteredLightSpot(light)) {\n\t\t\t\t\t\tgetShadowCoordPerspZbufferNormalOffset(lightProjectionMatrix, shadowParams, geometricNormal);\n\t\t\t\t\t\t\n\t\t\t\t\t\t#if defined(CLUSTER_SHADOW_TYPE_PCF1)\n\t\t\t\t\t\t\tfloat shadow = getShadowSpotClusteredPCF1(SHADOWMAP_PASS(shadowAtlasTexture), dShadowCoord, shadowParams);\n\t\t\t\t\t\t#elif defined(CLUSTER_SHADOW_TYPE_PCF3)\n\t\t\t\t\t\t\tfloat shadow = getShadowSpotClusteredPCF3(SHADOWMAP_PASS(shadowAtlasTexture), dShadowCoord, shadowParams);\n\t\t\t\t\t\t#elif defined(CLUSTER_SHADOW_TYPE_PCF5)\n\t\t\t\t\t\t\tfloat shadow = getShadowSpotClusteredPCF5(SHADOWMAP_PASS(shadowAtlasTexture), dShadowCoord, shadowParams);\n\t\t\t\t\t\t#elif defined(CLUSTER_SHADOW_TYPE_PCSS)\n\t\t\t\t\t\t\tfloat shadow = getShadowSpotClusteredPCSS(SHADOWMAP_PASS(shadowAtlasTexture), dShadowCoord, shadowParams);\n\t\t\t\t\t\t#endif\n\t\t\t\t\t\tfalloffAttenuation *= mix(1.0, shadow, light.shadowIntensity);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tvec3 dir = normalOffsetPointShadow(shadowParams, dLightPosW, dLightDirW, dLightDirNormW, geometricNormal);\n\t\t\t\t\t\t#if defined(CLUSTER_SHADOW_TYPE_PCF1)\n\t\t\t\t\t\t\tfloat shadow = getShadowOmniClusteredPCF1(SHADOWMAP_PASS(shadowAtlasTexture), shadowParams, light.omniAtlasViewport, shadowEdgePixels, dir);\n\t\t\t\t\t\t#elif defined(CLUSTER_SHADOW_TYPE_PCF3)\n\t\t\t\t\t\t\tfloat shadow = getShadowOmniClusteredPCF3(SHADOWMAP_PASS(shadowAtlasTexture), shadowParams, light.omniAtlasViewport, shadowEdgePixels, dir);\n\t\t\t\t\t\t#elif defined(CLUSTER_SHADOW_TYPE_PCF5)\n\t\t\t\t\t\t\tfloat shadow = getShadowOmniClusteredPCF5(SHADOWMAP_PASS(shadowAtlasTexture), shadowParams, light.omniAtlasViewport, shadowEdgePixels, dir);\n\t\t\t\t\t\t#endif\n\t\t\t\t\t\tfalloffAttenuation *= mix(1.0, shadow, light.shadowIntensity);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\t#endif\n\t\t\t}\n\t\t}\n\t\t#endif\n\t\t#ifdef CLUSTER_AREALIGHTS\n\t\tif (isClusteredLightArea(light)) {\n\t\t\t{\n\t\t\t\tvec3 areaDiffuse = (diffuseAttenuation * falloffAttenuation) * light.color * cookieAttenuation;\n\t\t\t\t#if defined(LIT_SPECULAR)\n\t\t\t\t\t#if defined(LIT_CONSERVE_ENERGY)\n\t\t\t\t\t\tareaDiffuse = mix(areaDiffuse, vec3(0), dLTCSpecFres);\n\t\t\t\t\t#endif\n\t\t\t\t#endif\n\t\t\t\tdDiffuseLight += areaDiffuse;\n\t\t\t}\n\t\t\t#ifdef LIT_SPECULAR\n\t\t\t\tfloat areaLightSpecular;\n\t\t\t\tif (isClusteredLightRect(light)) {\n\t\t\t\t\tareaLightSpecular = getRectLightSpecular(worldNormal, viewDir);\n\t\t\t\t} else if (isClusteredLightDisk(light)) {\n\t\t\t\t\tareaLightSpecular = getDiskLightSpecular(worldNormal, viewDir);\n\t\t\t\t} else {\n\t\t\t\t\tareaLightSpecular = getSphereLightSpecular(worldNormal, viewDir);\n\t\t\t\t}\n\t\t\t\tdSpecularLight += dLTCSpecFres * areaLightSpecular * falloffAttenuation * light.color * cookieAttenuation;\n\t\t\t\t#ifdef LIT_CLEARCOAT\n\t\t\t\t\tfloat areaLightSpecularCC;\n\t\t\t\t\tif (isClusteredLightRect(light)) {\n\t\t\t\t\t\tareaLightSpecularCC = getRectLightSpecular(clearcoat_worldNormal, viewDir);\n\t\t\t\t\t} else if (isClusteredLightDisk(light)) {\n\t\t\t\t\t\tareaLightSpecularCC = getDiskLightSpecular(clearcoat_worldNormal, viewDir);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tareaLightSpecularCC = getSphereLightSpecular(clearcoat_worldNormal, viewDir);\n\t\t\t\t\t}\n\t\t\t\t\tccSpecularLight += ccLTCSpecFres * areaLightSpecularCC * falloffAttenuation * light.color * cookieAttenuation;\n\t\t\t\t#endif\n\t\t\t#endif\n\t\t} else\n\t\t#endif\n\t\t{\n\t\t\t{\n\t\t\t\tvec3 punctualDiffuse = falloffAttenuation * light.color * cookieAttenuation;\n\t\t\t\t#if defined(CLUSTER_AREALIGHTS)\n\t\t\t\t#if defined(LIT_SPECULAR)\n\t\t\t\t#if defined(LIT_CONSERVE_ENERGY)\n\t\t\t\t\tpunctualDiffuse = mix(punctualDiffuse, vec3(0), specularity);\n\t\t\t\t#endif\n\t\t\t\t#endif\n\t\t\t\t#endif\n\t\t\t\tdDiffuseLight += punctualDiffuse;\n\t\t\t}\n\t \n\t\t\t#ifdef LIT_SPECULAR\n\t\t\t\tvec3 halfDir = normalize(-dLightDirNormW + viewDir);\n\t\t\t\t\n\t\t\t\t#ifdef LIT_SPECULAR_FRESNEL\n\t\t\t\t\tdSpecularLight += \n\t\t\t\t\t\tgetLightSpecular(halfDir, reflectionDir, worldNormal, viewDir, dLightDirNormW, gloss, tbn) * falloffAttenuation * light.color * cookieAttenuation * \n\t\t\t\t\t\tgetFresnel(\n\t\t\t\t\t\t\tdot(viewDir, halfDir), \n\t\t\t\t\t\t\tgloss, \n\t\t\t\t\t\t\tspecularity\n\t\t\t\t\t\t#if defined(LIT_IRIDESCENCE)\n\t\t\t\t\t\t\t, iridescenceFresnel,\n\t\t\t\t\t\t\tiridescence_intensity\n\t\t\t\t\t\t#endif\n\t\t\t\t\t\t\t);\n\t\t\t\t#else\n\t\t\t\t\tdSpecularLight += getLightSpecular(halfDir, reflectionDir, worldNormal, viewDir, dLightDirNormW, gloss, tbn) * falloffAttenuation * light.color * cookieAttenuation * specularity;\n\t\t\t\t#endif\n\t\t\t\t#ifdef LIT_CLEARCOAT\n\t\t\t\t\t#ifdef LIT_SPECULAR_FRESNEL\n\t\t\t\t\t\tccSpecularLight += getLightSpecular(halfDir, clearcoatReflectionDir, clearcoat_worldNormal, viewDir, dLightDirNormW, clearcoat_gloss, tbn) * falloffAttenuation * light.color * cookieAttenuation * getFresnelCC(dot(viewDir, halfDir));\n\t\t\t\t\t#else\n\t\t\t\t\t\tccSpecularLight += getLightSpecular(halfDir, clearcoatReflectionDir, clearcoat_worldNormal, viewDir, dLightDirNormW, clearcoat_gloss, tbn) * falloffAttenuation * light.color * cookieAttenuation; \n\t\t\t\t\t#endif\n\t\t\t\t#endif\n\t\t\t\t#ifdef LIT_SHEEN\n\t\t\t\t\tsSpecularLight += getLightSpecularSheen(halfDir, worldNormal, viewDir, dLightDirNormW, sheen_gloss) * falloffAttenuation * light.color * cookieAttenuation;\n\t\t\t\t#endif\n\t\t\t#endif\n\t\t}\n\t}\n\tdAtten = falloffAttenuation;\n\tdAttenD = diffuseAttenuation;\n\tdAtten3 = cookieAttenuation;\n}\nvoid evaluateClusterLight(\n\tfloat lightIndex, \n\tvec3 worldNormal, \n\tvec3 viewDir, \n\tvec3 reflectionDir, \n#if defined(LIT_CLEARCOAT)\n\tvec3 clearcoatReflectionDir,\n#endif\n\tfloat gloss, \n\tvec3 specularity, \n\tvec3 geometricNormal, \n\tmat3 tbn, \n#if defined(LIT_IRIDESCENCE)\n\tvec3 iridescenceFresnel,\n#endif\n\tvec3 clearcoat_worldNormal,\n\tfloat clearcoat_gloss,\n\tfloat sheen_gloss,\n\tfloat iridescence_intensity\n) {\n\tClusterLightData clusterLightData;\n\tdecodeClusterLightCore(clusterLightData, lightIndex);\n\tif (acceptLightMask(clusterLightData))\n\t\tevaluateLight(\n\t\t\tclusterLightData, \n\t\t\tworldNormal, \n\t\t\tviewDir, \n\t\t\treflectionDir, \n#if defined(LIT_CLEARCOAT)\n\t\t\tclearcoatReflectionDir, \n#endif\n\t\t\tgloss, \n\t\t\tspecularity, \n\t\t\tgeometricNormal, \n\t\t\ttbn, \n#if defined(LIT_IRIDESCENCE)\n\t\t\tiridescenceFresnel,\n#endif\n\t\t\tclearcoat_worldNormal,\n\t\t\tclearcoat_gloss,\n\t\t\tsheen_gloss,\n\t\t\tiridescence_intensity\n\t\t);\n}\nvoid addClusteredLights(\n\tvec3 worldNormal, \n\tvec3 viewDir, \n\tvec3 reflectionDir, \n#if defined(LIT_CLEARCOAT)\n\tvec3 clearcoatReflectionDir,\n#endif\n\tfloat gloss, \n\tvec3 specularity, \n\tvec3 geometricNormal, \n\tmat3 tbn, \n#if defined(LIT_IRIDESCENCE)\n\tvec3 iridescenceFresnel,\n#endif\n\tvec3 clearcoat_worldNormal,\n\tfloat clearcoat_gloss,\n\tfloat sheen_gloss,\n\tfloat iridescence_intensity\n) {\n\tif (clusterSkip > 0.5)\n\t\treturn;\n\tvec3 cellCoords = floor((vPositionW - clusterBoundsMin) * clusterCellsCountByBoundsSize);\n\tif (!(any(lessThan(cellCoords, vec3(0.0))) || any(greaterThanEqual(cellCoords, clusterCellsMax)))) {\n\t\tfloat cellIndex = dot(clusterCellsDot, cellCoords);\n\t\tfloat clusterV = floor(cellIndex * clusterTextureSize.y);\n\t\tfloat clusterU = cellIndex - (clusterV * clusterTextureSize.x);\n\t\t#ifdef GL2\n\t\t\tfor (int lightCellIndex = 0; lightCellIndex < clusterMaxCells; lightCellIndex++) {\n\t\t\t\tfloat lightIndex = texelFetch(clusterWorldTexture, ivec2(int(clusterU) + lightCellIndex, clusterV), 0).x;\n\t\t\t\tif (lightIndex <= 0.0)\n\t\t\t\t\t\treturn;\n\t\t\t\tevaluateClusterLight(\n\t\t\t\t\tlightIndex * 255.0, \n\t\t\t\t\tworldNormal, \n\t\t\t\t\tviewDir, \n\t\t\t\t\treflectionDir,\n#if defined(LIT_CLEARCOAT)\n\t\t\t\t\tclearcoatReflectionDir,\n#endif\n\t\t\t\t\tgloss, \n\t\t\t\t\tspecularity, \n\t\t\t\t\tgeometricNormal, \n\t\t\t\t\ttbn, \n#if defined(LIT_IRIDESCENCE)\n\t\t\t\t\tiridescenceFresnel,\n#endif\n\t\t\t\t\tclearcoat_worldNormal,\n\t\t\t\t\tclearcoat_gloss,\n\t\t\t\t\tsheen_gloss,\n\t\t\t\t\tiridescence_intensity\n\t\t\t\t); \n\t\t\t}\n\t\t#else\n\t\t\tclusterV = (clusterV + 0.5) * clusterTextureSize.z;\n\t\t\tconst float maxLightCells = 256.0;\n\t\t\tfor (float lightCellIndex = 0.5; lightCellIndex < maxLightCells; lightCellIndex++) {\n\t\t\t\tfloat lightIndex = texture2DLodEXT(clusterWorldTexture, vec2(clusterTextureSize.y * (clusterU + lightCellIndex), clusterV), 0.0).x;\n\t\t\t\tif (lightIndex <= 0.0)\n\t\t\t\t\treturn;\n\t\t\t\t\n\t\t\t\tevaluateClusterLight(\n\t\t\t\t\tlightIndex * 255.0, \n\t\t\t\t\tworldNormal, \n\t\t\t\t\tviewDir, \n\t\t\t\t\treflectionDir,\n#if defined(LIT_CLEARCOAT)\n\t\t\t\t\tclearcoatReflectionDir,\n#endif\n\t\t\t\t\tgloss, \n\t\t\t\t\tspecularity, \n\t\t\t\t\tgeometricNormal, \n\t\t\t\t\ttbn, \n#if defined(LIT_IRIDESCENCE)\n\t\t\t\t\tiridescenceFresnel,\n#endif\n\t\t\t\t\tclearcoat_worldNormal,\n\t\t\t\t\tclearcoat_gloss,\n\t\t\t\t\tsheen_gloss,\n\t\t\t\t\tiridescence_intensity\n\t\t\t\t); \n\t\t\t\tif (lightCellIndex >= clusterMaxCells) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t#endif\n\t}\n}\n`;\n\nexport { clusteredLightPS as default };\n", "var combinePS = `\nvec3 combineColor(vec3 albedo, vec3 sheenSpecularity, float clearcoatSpecularity) {\n\tvec3 ret = vec3(0);\n#ifdef LIT_OLD_AMBIENT\n\tret += (dDiffuseLight - light_globalAmbient) * albedo + material_ambient * light_globalAmbient;\n#else\n\tret += albedo * dDiffuseLight;\n#endif\n#ifdef LIT_SPECULAR\n\tret += dSpecularLight;\n#endif\n#ifdef LIT_REFLECTIONS\n\tret += dReflection.rgb * dReflection.a;\n#endif\n#ifdef LIT_SHEEN\n\tfloat sheenScaling = 1.0 - max(max(sheenSpecularity.r, sheenSpecularity.g), sheenSpecularity.b) * 0.157;\n\tret = ret * sheenScaling + (sSpecularLight + sReflection.rgb) * sheenSpecularity;\n#endif\n#ifdef LIT_CLEARCOAT\n\tfloat clearCoatScaling = 1.0 - ccFresnel * clearcoatSpecularity;\n\tret = ret * clearCoatScaling + (ccSpecularLight + ccReflection.rgb) * clearcoatSpecularity;\n#endif\n\treturn ret;\n}\n`;\n\nexport { combinePS as default };\n", "var cookiePS = `\nvec4 getCookie2D(sampler2D tex, mat4 transform, float intensity) {\n\tvec4 projPos = transform * vec4(vPositionW, 1.0);\n\tprojPos.xy /= projPos.w;\n\treturn mix(vec4(1.0), texture2D(tex, projPos.xy), intensity);\n}\nvec4 getCookie2DClip(sampler2D tex, mat4 transform, float intensity) {\n\tvec4 projPos = transform * vec4(vPositionW, 1.0);\n\tprojPos.xy /= projPos.w;\n\tif (projPos.x < 0.0 || projPos.x > 1.0 || projPos.y < 0.0 || projPos.y > 1.0 || projPos.z < 0.0) return vec4(0.0);\n\treturn mix(vec4(1.0), texture2D(tex, projPos.xy), intensity);\n}\nvec4 getCookie2DXform(sampler2D tex, mat4 transform, float intensity, vec4 cookieMatrix, vec2 cookieOffset) {\n\tvec4 projPos = transform * vec4(vPositionW, 1.0);\n\tprojPos.xy /= projPos.w;\n\tprojPos.xy += cookieOffset;\n\tvec2 uv = mat2(cookieMatrix) * (projPos.xy-vec2(0.5)) + vec2(0.5);\n\treturn mix(vec4(1.0), texture2D(tex, uv), intensity);\n}\nvec4 getCookie2DClipXform(sampler2D tex, mat4 transform, float intensity, vec4 cookieMatrix, vec2 cookieOffset) {\n\tvec4 projPos = transform * vec4(vPositionW, 1.0);\n\tprojPos.xy /= projPos.w;\n\tprojPos.xy += cookieOffset;\n\tif (projPos.x < 0.0 || projPos.x > 1.0 || projPos.y < 0.0 || projPos.y > 1.0 || projPos.z < 0.0) return vec4(0.0);\n\tvec2 uv = mat2(cookieMatrix) * (projPos.xy-vec2(0.5)) + vec2(0.5);\n\treturn mix(vec4(1.0), texture2D(tex, uv), intensity);\n}\nvec4 getCookieCube(samplerCube tex, mat4 transform, float intensity) {\n\treturn mix(vec4(1.0), textureCube(tex, dLightDirNormW * mat3(transform)), intensity);\n}\n`;\n\nexport { cookiePS as default };\n", "var cubeMapProjectBoxPS = `\nuniform vec3 envBoxMin;\nuniform vec3 envBoxMax;\nvec3 cubeMapProject(vec3 nrdir) {\n\tnrdir = cubeMapRotate(nrdir);\n\tvec3 rbmax = (envBoxMax - vPositionW) / nrdir;\n\tvec3 rbmin = (envBoxMin - vPositionW) / nrdir;\n\tvec3 rbminmax;\n\trbminmax.x = nrdir.x>0.0? rbmax.x : rbmin.x;\n\trbminmax.y = nrdir.y>0.0? rbmax.y : rbmin.y;\n\trbminmax.z = nrdir.z>0.0? rbmax.z : rbmin.z;\n\tfloat fa = min(min(rbminmax.x, rbminmax.y), rbminmax.z);\n\tvec3 posonbox = vPositionW + nrdir * fa;\n\tvec3 envBoxPos = (envBoxMin + envBoxMax) * 0.5;\n\treturn normalize(posonbox - envBoxPos);\n}\n`;\n\nexport { cubeMapProjectBoxPS as default };\n", "var cubeMapProjectNonePS = `\nvec3 cubeMapProject(vec3 dir) {\n\treturn cubeMapRotate(dir);\n}\n`;\n\nexport { cubeMapProjectNonePS as default };\n", "var cubeMapRotatePS = `\n#ifdef CUBEMAP_ROTATION\nuniform mat3 cubeMapRotationMatrix;\n#endif\nvec3 cubeMapRotate(vec3 refDir) {\n#ifdef CUBEMAP_ROTATION\n\treturn refDir * cubeMapRotationMatrix;\n#else\n\treturn refDir;\n#endif\n}\n`;\n\nexport { cubeMapRotatePS as default };\n", "var debugOutputPS = `\n#ifdef DEBUG_ALBEDO_PASS\ngl_FragColor = vec4(gammaCorrectOutput(dAlbedo), 1.0);\n#endif\n#ifdef DEBUG_UV0_PASS\ngl_FragColor = vec4(litArgs_albedo , 1.0);\n#endif\n#ifdef DEBUG_WORLD_NORMAL_PASS\ngl_FragColor = vec4(litArgs_worldNormal * 0.5 + 0.5, 1.0);\n#endif\n#ifdef DEBUG_OPACITY_PASS\ngl_FragColor = vec4(vec3(litArgs_opacity) , 1.0);\n#endif\n#ifdef DEBUG_SPECULARITY_PASS\ngl_FragColor = vec4(litArgs_specularity, 1.0);\n#endif\n#ifdef DEBUG_GLOSS_PASS\ngl_FragColor = vec4(vec3(litArgs_gloss) , 1.0);\n#endif\n#ifdef DEBUG_METALNESS_PASS\ngl_FragColor = vec4(vec3(litArgs_metalness) , 1.0);\n#endif\n#ifdef DEBUG_AO_PASS\ngl_FragColor = vec4(vec3(litArgs_ao) , 1.0);\n#endif\n#ifdef DEBUG_EMISSION_PASS\ngl_FragColor = vec4(gammaCorrectOutput(litArgs_emission), 1.0);\n#endif\n`;\n\nexport { debugOutputPS as default };\n", "var debugProcessFrontendPS = `\n#ifdef DEBUG_LIGHTING_PASS\nlitArgs_albedo = vec3(0.5);\n#endif\n#ifdef DEBUG_UV0_PASS\n#ifdef VARYING_VUV0\nlitArgs_albedo = vec3(vUv0, 0);\n#else\nlitArgs_albedo = vec3(0);\n#endif\n#endif\n`;\n\nexport { debugProcessFrontendPS as default };\n", "var decodePS = `\nvec3 decodeLinear(vec4 raw) {\n\treturn raw.rgb;\n}\nfloat decodeGamma(float raw) {\n\treturn pow(raw, 2.2);\n}\nvec3 decodeGamma(vec3 raw) {\n\treturn pow(raw, vec3(2.2));\n}\nvec3 decodeGamma(vec4 raw) {\n\treturn pow(raw.xyz, vec3(2.2));\n}\nvec3 decodeRGBM(vec4 raw) {\n\tvec3 color = (8.0 * raw.a) * raw.rgb;\n\treturn color * color;\n}\nvec3 decodeRGBP(vec4 raw) {\n\tvec3 color = raw.rgb * (-raw.a * 7.0 + 8.0);\n\treturn color * color;\n}\nvec3 decodeRGBE(vec4 raw) {\n\tif (raw.a == 0.0) {\n\t\treturn vec3(0.0, 0.0, 0.0);\n\t} else {\n\t\treturn raw.xyz * pow(2.0, raw.w * 255.0 - 128.0);\n\t}\n}\nvec4 passThrough(vec4 raw) {\n\treturn raw;\n}\n`;\n\nexport { decodePS as default };\n", "var detailModesPS = `\nvec3 detailMode_mul(vec3 c1, vec3 c2) {\n\treturn c1 * c2;\n}\nvec3 detailMode_add(vec3 c1, vec3 c2) {\n\treturn c1 + c2;\n}\nvec3 detailMode_screen(vec3 c1, vec3 c2) {\n\treturn 1.0 - (1.0 - c1)*(1.0 - c2);\n}\nvec3 detailMode_overlay(vec3 c1, vec3 c2) {\n\treturn mix(1.0 - 2.0*(1.0 - c1)*(1.0 - c2), 2.0*c1*c2, step(c1, vec3(0.5)));\n}\nvec3 detailMode_min(vec3 c1, vec3 c2) {\n\treturn min(c1, c2);\n}\nvec3 detailMode_max(vec3 c1, vec3 c2) {\n\treturn max(c1, c2);\n}\n`;\n\nexport { detailModesPS as default };\n", "var diffusePS = `\n#ifdef MAPCOLOR\nuniform vec3 material_diffuse;\n#endif\nvoid getAlbedo() {\n\tdAlbedo = vec3(1.0);\n#ifdef MAPCOLOR\n\tdAlbedo *= material_diffuse.rgb;\n#endif\n#ifdef MAPTEXTURE\n\tvec3 albedoBase = $DECODE(texture2DBias($SAMPLER, $UV, textureBias)).$CH;\n\tdAlbedo *= addAlbedoDetail(albedoBase);\n#endif\n#ifdef MAPVERTEX\n\tdAlbedo *= gammaCorrectInput(saturate(vVertexColor.$VC));\n#endif\n}\n`;\n\nexport { diffusePS as default };\n", "var diffuseDetailMapPS = `\nvec3 addAlbedoDetail(vec3 albedo) {\n#ifdef MAPTEXTURE\n\tvec3 albedoDetail = $DECODE(texture2DBias($SAMPLER, $UV, textureBias)).$CH;\n\treturn detailMode_$DETAILMODE(albedo, albedoDetail);\n#else\n\treturn albedo;\n#endif\n}\n`;\n\nexport { diffuseDetailMapPS as default };\n", "var emissivePS = `\n#ifdef MAPCOLOR\nuniform vec3 material_emissive;\n#endif\n#ifdef MAPFLOAT\nuniform float material_emissiveIntensity;\n#endif\nvoid getEmission() {\n\tdEmission = vec3(1.0);\n\t#ifdef MAPFLOAT\n\tdEmission *= material_emissiveIntensity;\n\t#endif\n\t#ifdef MAPCOLOR\n\tdEmission *= material_emissive;\n\t#endif\n\t#ifdef MAPTEXTURE\n\tdEmission *= $DECODE(texture2DBias($SAMPLER, $UV, textureBias)).$CH;\n\t#endif\n\t#ifdef MAPVERTEX\n\tdEmission *= gammaCorrectInput(saturate(vVertexColor.$VC));\n\t#endif\n}\n`;\n\nexport { emissivePS as default };\n", "var encodePS = `\nvec4 encodeLinear(vec3 source) {\n\treturn vec4(source, 1.0);\n}\nvec4 encodeGamma(vec3 source) {\n\treturn vec4(pow(source + 0.0000001, vec3(1.0 / 2.2)), 1.0);\n}\nvec4 encodeRGBM(vec3 source) {\n\tvec4 result;\n\tresult.rgb = pow(source.rgb, vec3(0.5));\n\tresult.rgb *= 1.0 / 8.0;\n\tresult.a = saturate( max( max( result.r, result.g ), max( result.b, 1.0 / 255.0 ) ) );\n\tresult.a = ceil(result.a * 255.0) / 255.0;\n\tresult.rgb /= result.a;\n\treturn result;\n}\nvec4 encodeRGBP(vec3 source) {\n\tvec3 gamma = pow(source, vec3(0.5));\n\tfloat maxVal = min(8.0, max(1.0, max(gamma.x, max(gamma.y, gamma.z))));\n\tfloat v = 1.0 - ((maxVal - 1.0) / 7.0);\n\tv = ceil(v * 255.0) / 255.0;\n\treturn vec4(gamma / (-v * 7.0 + 8.0), v);\t\n}\nvec4 encodeRGBE(vec3 source) {\n\tfloat maxVal = max(source.x, max(source.y, source.z));\n\tif (maxVal < 1e-32) {\n\t\treturn vec4(0, 0, 0, 0);\n\t} else {\n\t\tfloat e = ceil(log2(maxVal));\n\t\treturn vec4(source / pow(2.0, e), (e + 128.0) / 255.0);\n\t}\n}\n`;\n\nexport { encodePS as default };\n", "var endPS = `\n\tgl_FragColor.rgb = combineColor(litArgs_albedo, litArgs_sheen_specularity, litArgs_clearcoat_specularity);\n\tgl_FragColor.rgb += litArgs_emission;\n\tgl_FragColor.rgb = addFog(gl_FragColor.rgb);\n\t#ifndef HDR\n\tgl_FragColor.rgb = toneMap(gl_FragColor.rgb);\n\tgl_FragColor.rgb = gammaCorrectOutput(gl_FragColor.rgb);\n\t#endif\n`;\n\nexport { endPS as default };\n", "var endVS = `\n`;\n\nexport { endVS as default };\n", "var envAtlasPS = `\nconst float atlasSize = 512.0;\nconst float seamSize = 1.0 / atlasSize;\nvec2 mapUv(vec2 uv, vec4 rect) {\n\treturn vec2(mix(rect.x + seamSize, rect.x + rect.z - seamSize, uv.x),\n\t\t\t\tmix(rect.y + seamSize, rect.y + rect.w - seamSize, uv.y));\n}\nvec2 mapRoughnessUv(vec2 uv, float level) {\n\tfloat t = 1.0 / exp2(level);\n\treturn mapUv(uv, vec4(0, 1.0 - t, t, t * 0.5));\n}\nvec2 mapShinyUv(vec2 uv, float level) {\n\tfloat t = 1.0 / exp2(level);\n\treturn mapUv(uv, vec4(1.0 - t, 1.0 - t, t, t * 0.5));\n}\n`;\n\nexport { envAtlasPS as default };\n", "var envConstPS = `\nvec3 processEnvironment(vec3 color) {\n\treturn color;\n}\n`;\n\nexport { envConstPS as default };\n", "var envMultiplyPS = `\nuniform float skyboxIntensity;\nvec3 processEnvironment(vec3 color) {\n\treturn color * skyboxIntensity;\n}\n`;\n\nexport { envMultiplyPS as default };\n", "var extensionPS = `\n`;\n\nexport { extensionPS as default };\n", "var extensionVS = `\n`;\n\nexport { extensionVS as default };\n", "var falloffInvSquaredPS = `\nfloat getFalloffWindow(float lightRadius, vec3 lightDir) {\n\tfloat sqrDist = dot(lightDir, lightDir);\n\tfloat invRadius = 1.0 / lightRadius;\n\treturn square( saturate( 1.0 - square( sqrDist * square(invRadius) ) ) );\n}\nfloat getFalloffInvSquared(float lightRadius, vec3 lightDir) {\n\tfloat sqrDist = dot(lightDir, lightDir);\n\tfloat falloff = 1.0 / (sqrDist + 1.0);\n\tfloat invRadius = 1.0 / lightRadius;\n\tfalloff *= 16.0;\n\tfalloff *= square( saturate( 1.0 - square( sqrDist * square(invRadius) ) ) );\n\treturn falloff;\n}\n`;\n\nexport { falloffInvSquaredPS as default };\n", "var falloffLinearPS = `\nfloat getFalloffLinear(float lightRadius, vec3 lightDir) {\n\tfloat d = length(lightDir);\n\treturn max(((lightRadius - d) / lightRadius), 0.0);\n}\n`;\n\nexport { falloffLinearPS as default };\n", "var fixCubemapSeamsNonePS = `\nvec3 fixSeams(vec3 vec, float mipmapIndex) {\n\treturn vec;\n}\nvec3 fixSeams(vec3 vec) {\n\treturn vec;\n}\nvec3 fixSeamsStatic(vec3 vec, float invRecMipSize) {\n\treturn vec;\n}\nvec3 calcSeam(vec3 vec) {\n\treturn vec3(0);\n}\nvec3 applySeam(vec3 vec, vec3 seam, float scale) {\n\treturn vec;\n}\n`;\n\nexport { fixCubemapSeamsNonePS as default };\n", "var fixCubemapSeamsStretchPS = `\nvec3 fixSeams(vec3 vec, float mipmapIndex) {\n\tvec3 avec = abs(vec);\n\tfloat scale = 1.0 - exp2(mipmapIndex) / 128.0;\n\tfloat M = max(max(avec.x, avec.y), avec.z);\n\tif (avec.x != M) vec.x *= scale;\n\tif (avec.y != M) vec.y *= scale;\n\tif (avec.z != M) vec.z *= scale;\n\treturn vec;\n}\nvec3 fixSeams(vec3 vec) {\n\tvec3 avec = abs(vec);\n\tfloat scale = 1.0 - 1.0 / 128.0;\n\tfloat M = max(max(avec.x, avec.y), avec.z);\n\tif (avec.x != M) vec.x *= scale;\n\tif (avec.y != M) vec.y *= scale;\n\tif (avec.z != M) vec.z *= scale;\n\treturn vec;\n}\nvec3 fixSeamsStatic(vec3 vec, float invRecMipSize) {\n\tvec3 avec = abs(vec);\n\tfloat scale = invRecMipSize;\n\tfloat M = max(max(avec.x, avec.y), avec.z);\n\tif (avec.x != M) vec.x *= scale;\n\tif (avec.y != M) vec.y *= scale;\n\tif (avec.z != M) vec.z *= scale;\n\treturn vec;\n}\nvec3 calcSeam(vec3 vec) {\n\tvec3 avec = abs(vec);\n\tfloat M = max(avec.x, max(avec.y, avec.z));\n\treturn vec3(avec.x != M ? 1.0 : 0.0,\n\t\t\t\tavec.y != M ? 1.0 : 0.0,\n\t\t\t\tavec.z != M ? 1.0 : 0.0);\n}\nvec3 applySeam(vec3 vec, vec3 seam, float scale) {\n\treturn vec * (seam * -scale + vec3(1.0));\n}\n`;\n\nexport { fixCubemapSeamsStretchPS as default };\n", "var floatUnpackingPS = `\nfloat bytes2float2(vec2 data) {\n\treturn dot(data, vec2(1.0, 1.0 / 255.0));\n}\nfloat bytes2float3(vec3 data) {\n\treturn dot(data, vec3(1.0, 1.0 / 255.0, 1.0 / 65025.0));\n}\nfloat bytes2float4(vec4 data) {\n\treturn dot(data, vec4(1.0, 1.0 / 255.0, 1.0 / 65025.0, 1.0 / 16581375.0));\n}\nfloat bytes2floatRange2(vec2 data, float min, float max) {\n\treturn mix(min, max, bytes2float2(data));\n}\nfloat bytes2floatRange3(vec3 data, float min, float max) {\n\treturn mix(min, max, bytes2float3(data));\n}\nfloat bytes2floatRange4(vec4 data, float min, float max) {\n\treturn mix(min, max, bytes2float4(data));\n}\nfloat mantissaExponent2Float(vec4 pack)\n{\n\tfloat value = bytes2floatRange3(pack.xyz, -1.0, 1.0);\n\tfloat exponent = floor(pack.w * 255.0 - 127.0);\n\treturn value * exp2(exponent);\n}\n`;\n\nexport { floatUnpackingPS as default };\n", "var fogExpPS = `\nuniform vec3 fog_color;\nuniform float fog_density;\nfloat dBlendModeFogFactor = 1.0;\nvec3 addFog(vec3 color) {\n\tfloat depth = gl_FragCoord.z / gl_FragCoord.w;\n\tfloat fogFactor = exp(-depth * fog_density);\n\tfogFactor = clamp(fogFactor, 0.0, 1.0);\n\treturn mix(fog_color * dBlendModeFogFactor, color, fogFactor);\n}\n`;\n\nexport { fogExpPS as default };\n", "var fogExp2PS = `\nuniform vec3 fog_color;\nuniform float fog_density;\nfloat dBlendModeFogFactor = 1.0;\nvec3 addFog(vec3 color) {\n\tfloat depth = gl_FragCoord.z / gl_FragCoord.w;\n\tfloat fogFactor = exp(-depth * depth * fog_density * fog_density);\n\tfogFactor = clamp(fogFactor, 0.0, 1.0);\n\treturn mix(fog_color * dBlendModeFogFactor, color, fogFactor);\n}\n`;\n\nexport { fogExp2PS as default };\n", "var fogLinearPS = `\nuniform vec3 fog_color;\nuniform float fog_start;\nuniform float fog_end;\nfloat dBlendModeFogFactor = 1.0;\nvec3 addFog(vec3 color) {\n\tfloat depth = gl_FragCoord.z / gl_FragCoord.w;\n\tfloat fogFactor = (fog_end - depth) / (fog_end - fog_start);\n\tfogFactor = clamp(fogFactor, 0.0, 1.0);\n\treturn mix(fog_color * dBlendModeFogFactor, color, fogFactor);\n}\n`;\n\nexport { fogLinearPS as default };\n", "var fogNonePS = `\nfloat dBlendModeFogFactor = 1.0;\nvec3 addFog(vec3 color) {\n\treturn color;\n}\n`;\n\nexport { fogNonePS as default };\n", "var fresnelSchlickPS = `\nvec3 getFresnel(\n\t\tfloat cosTheta, \n\t\tfloat gloss, \n\t\tvec3 specularity\n#if defined(LIT_IRIDESCENCE)\n\t\t, vec3 iridescenceFresnel, \n\t\tfloat iridescenceIntensity\n#endif\n\t) {\n\tfloat fresnel = pow(1.0 - max(cosTheta, 0.0), 5.0);\n\tfloat glossSq = gloss * gloss;\n\tvec3 ret = specularity + (max(vec3(glossSq), specularity) - specularity) * fresnel;\n#if defined(LIT_IRIDESCENCE)\n\treturn mix(ret, iridescenceFresnel, iridescenceIntensity);\n#else\n\treturn ret;\n#endif\t\n}\nfloat getFresnelCC(float cosTheta) {\n\tfloat fresnel = pow(1.0 - max(cosTheta, 0.0), 5.0);\n\treturn 0.04 + (1.0 - 0.04) * fresnel;\n}\n`;\n\nexport { fresnelSchlickPS as default };\n", "var fullscreenQuadPS = `\nvarying vec2 vUv0;\nuniform sampler2D source;\nvoid main(void) {\n\tgl_FragColor = texture2D(source, vUv0);\n}\n`;\n\nexport { fullscreenQuadPS as default };\n", "var fullscreenQuadVS = `\nattribute vec2 vertex_position;\nvarying vec2 vUv0;\nvoid main(void)\n{\n\tgl_Position = vec4(vertex_position, 0.5, 1.0);\n\tvUv0 = vertex_position.xy*0.5+0.5;\n}\n`;\n\nexport { fullscreenQuadVS as default };\n", "var gamma1_0PS = `\nfloat gammaCorrectInput(float color) {\n\treturn color;\n}\nvec3 gammaCorrectInput(vec3 color) {\n\treturn color;\n}\nvec4 gammaCorrectInput(vec4 color) {\n\treturn color;\n}\nvec3 gammaCorrectOutput(vec3 color) {\n\treturn color;\n}\n`;\n\nexport { gamma1_0PS as default };\n", "var gamma2_2PS = `\nfloat gammaCorrectInput(float color) {\n\treturn decodeGamma(color);\n}\nvec3 gammaCorrectInput(vec3 color) {\n\treturn decodeGamma(color);\n}\nvec4 gammaCorrectInput(vec4 color) {\n\treturn vec4(decodeGamma(color.xyz), color.w);\n}\nvec3 gammaCorrectOutput(vec3 color) {\n#ifdef HDR\n\treturn color;\n#else\n\treturn pow(color + 0.0000001, vec3(1.0 / 2.2));\n#endif\n}\n`;\n\nexport { gamma2_2PS as default };\n", "var glossPS = `\n#ifdef MAPFLOAT\nuniform float material_gloss;\n#endif\nvoid getGlossiness() {\n\tdGlossiness = 1.0;\n\t#ifdef MAPFLOAT\n\tdGlossiness *= material_gloss;\n\t#endif\n\t#ifdef MAPTEXTURE\n\tdGlossiness *= texture2DBias($SAMPLER, $UV, textureBias).$CH;\n\t#endif\n\t#ifdef MAPVERTEX\n\tdGlossiness *= saturate(vVertexColor.$VC);\n\t#endif\n\t#ifdef MAPINVERT\n\tdGlossiness = 1.0 - dGlossiness;\n\t#endif\n\tdGlossiness += 0.0000001;\n}\n`;\n\nexport { glossPS as default };\n", "var iridescenceDiffractionPS = `\nuniform float material_iridescenceRefractionIndex;\n#ifndef PI\n#define PI 3.14159265\n#endif\nfloat iridescence_iorToFresnel(float transmittedIor, float incidentIor) {\n\treturn pow((transmittedIor - incidentIor) / (transmittedIor + incidentIor), 2.0);\n}\nvec3 iridescence_iorToFresnel(vec3 transmittedIor, float incidentIor) {\n\treturn pow((transmittedIor - vec3(incidentIor)) / (transmittedIor + vec3(incidentIor)), vec3(2.0));\n}\nvec3 iridescence_fresnelToIor(vec3 f0) {\n\tvec3 sqrtF0 = sqrt(f0);\n\treturn (vec3(1.0) + sqrtF0) / (vec3(1.0) - sqrtF0);\n}\nvec3 iridescence_sensitivity(float opd, vec3 shift) {\n\tfloat phase = 2.0 * PI * opd * 1.0e-9;\n\tconst vec3 val = vec3(5.4856e-13, 4.4201e-13, 5.2481e-13);\n\tconst vec3 pos = vec3(1.6810e+06, 1.7953e+06, 2.2084e+06);\n\tconst vec3 var = vec3(4.3278e+09, 9.3046e+09, 6.6121e+09);\n\tvec3 xyz = val * sqrt(2.0 * PI * var) * cos(pos * phase + shift) * exp(-pow(phase, 2.0) * var);\n\txyz.x += 9.7470e-14 * sqrt(2.0 * PI * 4.5282e+09) * cos(2.2399e+06 * phase + shift[0]) * exp(-4.5282e+09 * pow(phase, 2.0));\n\txyz /= vec3(1.0685e-07);\n\tconst mat3 XYZ_TO_REC709 = mat3(\n\t\t3.2404542, -0.9692660, 0.0556434,\n\t -1.5371385, 1.8760108, -0.2040259,\n\t -0.4985314, 0.0415560, 1.0572252\n\t);\n\treturn XYZ_TO_REC709 * xyz;\n}\nfloat iridescence_fresnel(float cosTheta, float f0) {\n\tfloat x = clamp(1.0 - cosTheta, 0.0, 1.0);\n\tfloat x2 = x * x;\n\tfloat x5 = x * x2 * x2;\n\treturn f0 + (1.0 - f0) * x5;\n} \nvec3 iridescence_fresnel(float cosTheta, vec3 f0) {\n\tfloat x = clamp(1.0 - cosTheta, 0.0, 1.0);\n\tfloat x2 = x * x;\n\tfloat x5 = x * x2 * x2; \n\treturn f0 + (vec3(1.0) - f0) * x5;\n}\nvec3 calcIridescence(float outsideIor, float cosTheta, vec3 base_f0, float iridescenceThickness) {\n\tfloat iridescenceIor = mix(outsideIor, material_iridescenceRefractionIndex, smoothstep(0.0, 0.03, iridescenceThickness));\n\tfloat sinTheta2Sq = pow(outsideIor / iridescenceIor, 2.0) * (1.0 - pow(cosTheta, 2.0));\n\tfloat cosTheta2Sq = 1.0 - sinTheta2Sq;\n\tif (cosTheta2Sq < 0.0) {\n\t\treturn vec3(1.0);\n\t}\n\tfloat cosTheta2 = sqrt(cosTheta2Sq);\n\tfloat r0 = iridescence_iorToFresnel(iridescenceIor, outsideIor);\n\tfloat r12 = iridescence_fresnel(cosTheta, r0);\n\tfloat r21 = r12;\n\tfloat t121 = 1.0 - r12;\n\tfloat phi12 = iridescenceIor < outsideIor ? PI : 0.0;\n\tfloat phi21 = PI - phi12;\n\tvec3 baseIor = iridescence_fresnelToIor(base_f0 + vec3(0.0001));\n\tvec3 r1 = iridescence_iorToFresnel(baseIor, iridescenceIor);\n\tvec3 r23 = iridescence_fresnel(cosTheta2, r1);\n\tvec3 phi23 = vec3(0.0);\n\tif (baseIor[0] < iridescenceIor) phi23[0] = PI;\n\tif (baseIor[1] < iridescenceIor) phi23[1] = PI;\n\tif (baseIor[2] < iridescenceIor) phi23[2] = PI;\n\tfloat opd = 2.0 * iridescenceIor * iridescenceThickness * cosTheta2;\n\tvec3 phi = vec3(phi21) + phi23; \n\tvec3 r123Sq = clamp(r12 * r23, 1e-5, 0.9999);\n\tvec3 r123 = sqrt(r123Sq);\n\tvec3 rs = pow(t121, 2.0) * r23 / (1.0 - r123Sq);\n\tvec3 c0 = r12 + rs;\n\tvec3 i = c0;\n\tvec3 cm = rs - t121;\n\tfor (int m = 1; m <= 2; m++) {\n\t\tcm *= r123;\n\t\tvec3 sm = 2.0 * iridescence_sensitivity(float(m) * opd, float(m) * phi);\n\t\ti += cm * sm;\n\t}\n\treturn max(i, vec3(0.0));\n}\nvec3 getIridescence(float cosTheta, vec3 specularity, float iridescenceThickness) {\n\treturn calcIridescence(1.0, cosTheta, specularity, iridescenceThickness);\n}\n`;\n\nexport { iridescenceDiffractionPS as default };\n", "var iridescencePS = `\n#ifdef MAPFLOAT\nuniform float material_iridescence;\n#endif\nvoid getIridescence() {\n\tfloat iridescence = 1.0;\n\t#ifdef MAPFLOAT\n\tiridescence *= material_iridescence;\n\t#endif\n\t#ifdef MAPTEXTURE\n\tiridescence *= texture2DBias($SAMPLER, $UV, textureBias).$CH;\n\t#endif\n\tdIridescence = iridescence; \n}\n`;\n\nexport { iridescencePS as default };\n", "var iridescenceThicknessPS = `\nuniform float material_iridescenceThicknessMax;\n#ifdef MAPTEXTURE\nuniform float material_iridescenceThicknessMin;\n#endif\nvoid getIridescenceThickness() {\n\t#ifdef MAPTEXTURE\n\tfloat blend = texture2DBias($SAMPLER, $UV, textureBias).$CH;\n\tfloat iridescenceThickness = mix(material_iridescenceThicknessMin, material_iridescenceThicknessMax, blend);\n\t#else\n\tfloat iridescenceThickness = material_iridescenceThicknessMax;\n\t#endif\n\tdIridescenceThickness = iridescenceThickness; \n}\n`;\n\nexport { iridescenceThicknessPS as default };\n", "var instancingVS = `\nattribute vec4 instance_line1;\nattribute vec4 instance_line2;\nattribute vec4 instance_line3;\nattribute vec4 instance_line4;\n`;\n\nexport { instancingVS as default };\n", "var iorPS = `\n#ifdef MAPFLOAT\nuniform float material_refractionIndex;\n#endif\nvoid getIor() {\n#ifdef MAPFLOAT\n\tdIor = material_refractionIndex;\n#else\n\tdIor = 1.0 / 1.5;\n#endif\n}\n`;\n\nexport { iorPS as default };\n", "var lightDiffuseLambertPS = `\nfloat getLightDiffuse(vec3 worldNormal, vec3 viewDir, vec3 lightDir, vec3 lightDirNorm) {\n\treturn max(dot(worldNormal, -lightDirNorm), 0.0);\n}\n`;\n\nexport { lightDiffuseLambertPS as default };\n", "var lightDirPointPS = `\nvoid getLightDirPoint(vec3 lightPosW) {\n\tdLightDirW = vPositionW - lightPosW;\n\tdLightDirNormW = normalize(dLightDirW);\n\tdLightPosW = lightPosW;\n}\n`;\n\nexport { lightDirPointPS as default };\n", "var lightmapAddPS = `\nvoid addLightMap(\n\tvec3 lightmap, \n\tvec3 dir, \n\tvec3 worldNormal, \n\tvec3 viewDir, \n\tvec3 reflectionDir, \n\tfloat gloss, \n\tvec3 specularity, \n\tvec3 vertexNormal, \n\tmat3 tbn\n#if defined(LIT_IRIDESCENCE)\n\tvec3 iridescenceFresnel, \n\tfloat iridescenceIntensity\n#endif\n) {\n\tdDiffuseLight += lightmap;\n}\n`;\n\nexport { lightmapAddPS as default };\n", "var lightmapDirAddPS = `\nvoid addLightMap(\n\tvec3 lightmap, \n\tvec3 dir, \n\tvec3 worldNormal, \n\tvec3 viewDir, \n\tvec3 reflectionDir, \n\tfloat gloss, \n\tvec3 specularity, \n\tvec3 vertexNormal, \n\tmat3 tbn\n#if defined(LIT_IRIDESCENCE)\n\tvec3 iridescenceFresnel, \n\tfloat iridescenceIntensity\n#endif\n) {\n\tif (dot(dir, dir) < 0.0001) {\n\t\tdDiffuseLight += lightmap;\n\t} else {\n\t\tfloat vlight = saturate(dot(dir, -vertexNormal));\n\t\tfloat flight = saturate(dot(dir, -worldNormal));\n\t\tfloat nlight = (flight / max(vlight, 0.01)) * 0.5;\n\t\tdDiffuseLight += lightmap * nlight * 2.0;\n\t\tvec3 halfDir = normalize(-dir + viewDir);\n\t\tvec3 specularLight = lightmap * getLightSpecular(halfDir, reflectionDir, worldNormal, viewDir, dir, gloss, tbn);\n#ifdef LIT_SPECULAR_FRESNEL\n\t\tspecularLight *= \n\t\t\tgetFresnel(dot(viewDir, halfDir), \n\t\t\tgloss, \n\t\t\tspecularity\n\t\t#if defined(LIT_IRIDESCENCE)\n\t\t\t, iridescenceFresnel,\n\t\t\tiridescenceIntensity\n\t\t#endif\n\t\t\t);\n#endif\n\t\tdSpecularLight += specularLight;\n\t}\n}\n`;\n\nexport { lightmapDirAddPS as default };\n", "var lightmapDirPS = `\nuniform sampler2D texture_lightMap;\nuniform sampler2D texture_dirLightMap;\nvoid getLightMap() {\n\tdLightmap = $DECODE(texture2DBias(texture_lightMap, $UV, textureBias)).$CH;\n\tvec3 dir = texture2DBias(texture_dirLightMap, $UV, textureBias).xyz * 2.0 - 1.0;\n\tfloat dirDot = dot(dir, dir);\n\tdLightmapDir = (dirDot > 0.001) ? dir / sqrt(dirDot) : vec3(0.0);\n}\n`;\n\nexport { lightmapDirPS as default };\n", "var lightmapSinglePS = `\nvoid getLightMap() {\n\tdLightmap = vec3(1.0);\n\t#ifdef MAPTEXTURE\n\tdLightmap *= $DECODE(texture2DBias($SAMPLER, $UV, textureBias)).$CH;\n\t#endif\n\t#ifdef MAPVERTEX\n\tdLightmap *= saturate(vVertexColor.$VC);\n\t#endif\n}\n`;\n\nexport { lightmapSinglePS as default };\n", "var lightSpecularAnisoGGXPS = `\nfloat calcLightSpecular(float gloss, vec3 worldNormal, vec3 viewDir, vec3 h, vec3 lightDirNorm, mat3 tbn) {\n\tfloat PI = 3.141592653589793;\n\tfloat roughness = max((1.0 - gloss) * (1.0 - gloss), 0.001);\n\tfloat anisotropy = material_anisotropy * roughness;\n \n\tfloat at = max((roughness + anisotropy), roughness / 4.0);\n\tfloat ab = max((roughness - anisotropy), roughness / 4.0);\n\tfloat NoH = dot(worldNormal, h);\n\tfloat ToH = dot(tbn[0], h);\n\tfloat BoH = dot(tbn[1], h);\n\tfloat a2 = at * ab;\n\tvec3 v = vec3(ab * ToH, at * BoH, a2 * NoH);\n\tfloat v2 = dot(v, v);\n\tfloat w2 = a2 / v2;\n\tfloat D = a2 * w2 * w2 * (1.0 / PI);\n\tfloat ToV = dot(tbn[0], viewDir);\n\tfloat BoV = dot(tbn[1], viewDir);\n\tfloat ToL = dot(tbn[0], -lightDirNorm);\n\tfloat BoL = dot(tbn[1], -lightDirNorm);\n\tfloat NoV = dot(worldNormal, viewDir);\n\tfloat NoL = dot(worldNormal, -lightDirNorm);\n\tfloat lambdaV = NoL * length(vec3(at * ToV, ab * BoV, NoV));\n\tfloat lambdaL = NoV * length(vec3(at * ToL, ab * BoL, NoL));\n\tfloat G = 0.5 / (lambdaV + lambdaL);\n\treturn D * G;\n}\nfloat getLightSpecular(vec3 h, vec3 reflDir, vec3 worldNormal, vec3 viewDir, vec3 lightDirNorm, float gloss, mat3 tbn) {\n\treturn calcLightSpecular(gloss, worldNormal, viewDir, h, lightDirNorm, tbn);\n}\n`;\n\nexport { lightSpecularAnisoGGXPS as default };\n", "var lightSpecularBlinnPS = `\nfloat calcLightSpecular(float gloss, vec3 worldNormal, vec3 h) {\n\tfloat nh = max( dot( h, worldNormal ), 0.0 );\n\tfloat specPow = exp2(gloss * 11.0);\n\tspecPow = max(specPow, 0.0001);\n\treturn pow(nh, specPow) * (specPow + 2.0) / 8.0;\n}\nfloat getLightSpecular(vec3 h, vec3 reflDir, vec3 worldNormal, vec3 viewDir, vec3 lightDirNorm, float gloss, mat3 tbn) {\n\treturn calcLightSpecular(gloss, worldNormal, h);\n}\n`;\n\nexport { lightSpecularBlinnPS as default };\n", "var lightSpecularPhongPS = `\nfloat calcLightSpecular(float gloss, vec3 reflDir, vec3 lightDirNorm) {\n\tfloat specPow = gloss;\n\treturn pow(max(dot(reflDir, -lightDirNorm), 0.0), specPow + 0.0001);\n}\nfloat getLightSpecular(vec3 h, vec3 reflDir, vec3 worldNormal, vec3 viewDir, vec3 lightDirNorm, float gloss, mat3 tbn) {\n\treturn calcLightSpecular(gloss, reflDir, lightDirNorm);\n}\n`;\n\nexport { lightSpecularPhongPS as default };\n", "var lightSheenPS = `\nfloat sheenD(vec3 normal, vec3 h, float roughness) {\n\tfloat invR = 1.0 / (roughness * roughness);\n\tfloat cos2h = max(dot(normal, h), 0.0);\n\tcos2h *= cos2h;\n\tfloat sin2h = max(1.0 - cos2h, 0.0078125);\n\treturn (2.0 + invR) * pow(sin2h, invR * 0.5) / (2.0 * PI);\n}\nfloat sheenV(vec3 normal, vec3 viewDir, vec3 light) {\n\tfloat NoV = max(dot(normal, viewDir), 0.000001);\n\tfloat NoL = max(dot(normal, light), 0.000001);\n\treturn 1.0 / (4.0 * (NoL + NoV - NoL * NoV));\n}\nfloat getLightSpecularSheen(vec3 h, vec3 worldNormal, vec3 viewDir, vec3 lightDirNorm, float sheenGloss) {\n\tfloat D = sheenD(worldNormal, h, sheenGloss);\n\tfloat V = sheenV(worldNormal, viewDir, -lightDirNorm);\n\treturn D * V;\n}\n`;\n\nexport { lightSheenPS as default };\n", "var linearizeDepthPS = `\n#ifndef LINEARIZE_DEPTH\n#define LINEARIZE_DEPTH\nfloat linearizeDepth(float z, vec4 cameraParams) {\n\tif (cameraParams.w == 0.0)\n\t\treturn (cameraParams.z * cameraParams.y) / (cameraParams.y + z * (cameraParams.z - cameraParams.y));\n\telse\n\t\treturn cameraParams.z + z * (cameraParams.y - cameraParams.z);\n}\n#ifndef CAMERAPLANES\n#define CAMERAPLANES\nuniform vec4 camera_params;\n#endif\n#ifdef GL2\nfloat linearizeDepth(float z) {\n\treturn linearizeDepth(z, camera_params);\n}\n#else\n#ifndef UNPACKFLOAT\n#define UNPACKFLOAT\nfloat unpackFloat(vec4 rgbaDepth) {\n\tconst vec4 bitShift = vec4(1.0 / (256.0 * 256.0 * 256.0), 1.0 / (256.0 * 256.0), 1.0 / 256.0, 1.0);\n\treturn dot(rgbaDepth, bitShift);\n}\n#endif\n#endif\n#endif\n`;\n\nexport { linearizeDepthPS as default };\n", "var litShaderArgsPS = `\nvec3 litArgs_albedo;\nfloat litArgs_opacity;\nvec3 litArgs_emission;\nvec3 litArgs_worldNormal;\nfloat litArgs_ao;\nvec3 litArgs_lightmap;\nvec3 litArgs_lightmapDir;\nfloat litArgs_metalness;\nvec3 litArgs_specularity;\nfloat litArgs_specularityFactor;\nfloat litArgs_gloss;\nfloat litArgs_sheen_gloss;\nvec3 litArgs_sheen_specularity;\nfloat litArgs_transmission;\nfloat litArgs_thickness;\nfloat litArgs_ior;\nfloat litArgs_dispersion;\nfloat litArgs_iridescence_intensity;\nfloat litArgs_iridescence_thickness;\nvec3 litArgs_clearcoat_worldNormal;\nfloat litArgs_clearcoat_specularity;\nfloat litArgs_clearcoat_gloss;\n`;\n\nexport { litShaderArgsPS as default };\n", "var ltcPS = `\nmat3 transposeMat3( const in mat3 m ) {\n\tmat3 tmp;\n\ttmp[ 0 ] = vec3( m[ 0 ].x, m[ 1 ].x, m[ 2 ].x );\n\ttmp[ 1 ] = vec3( m[ 0 ].y, m[ 1 ].y, m[ 2 ].y );\n\ttmp[ 2 ] = vec3( m[ 0 ].z, m[ 1 ].z, m[ 2 ].z );\n\treturn tmp;\n}\nvec2 LTC_Uv( const in vec3 N, const in vec3 V, const in float roughness ) {\n\tconst float LUT_SIZE = 64.0;\n\tconst float LUT_SCALE = ( LUT_SIZE - 1.0 ) / LUT_SIZE;\n\tconst float LUT_BIAS = 0.5 / LUT_SIZE;\n\tfloat dotNV = saturate( dot( N, V ) );\n\tvec2 uv = vec2( roughness, sqrt( 1.0 - dotNV ) );\n\tuv = uv * LUT_SCALE + LUT_BIAS;\n\treturn uv;\n}\nfloat LTC_ClippedSphereFormFactor( const in vec3 f ) {\n\tfloat l = length( f );\n\treturn max( ( l * l + f.z ) / ( l + 1.0 ), 0.0 );\n}\nvec3 LTC_EdgeVectorFormFactor( const in vec3 v1, const in vec3 v2 ) {\n\tfloat x = dot( v1, v2 );\n\tfloat y = abs( x );\n\tfloat a = 0.8543985 + ( 0.4965155 + 0.0145206 * y ) * y;\n\tfloat b = 3.4175940 + ( 4.1616724 + y ) * y;\n\tfloat v = a / b;\n\tfloat theta_sintheta = ( x > 0.0 ) ? v : 0.5 * inversesqrt( max( 1.0 - x * x, 1e-7 ) ) - v;\n\treturn cross( v1, v2 ) * theta_sintheta;\n}\nstruct Coords {\n\tvec3 coord0;\n\tvec3 coord1;\n\tvec3 coord2;\n\tvec3 coord3;\n};\nfloat LTC_EvaluateRect( const in vec3 N, const in vec3 V, const in vec3 P, const in mat3 mInv, const in Coords rectCoords) {\n\tvec3 v1 = rectCoords.coord1 - rectCoords.coord0;\n\tvec3 v2 = rectCoords.coord3 - rectCoords.coord0;\n\t\n\tvec3 lightNormal = cross( v1, v2 );\n\tfloat factor = sign(-dot( lightNormal, P - rectCoords.coord0 ));\n\tvec3 T1, T2;\n\tT1 = normalize( V - N * dot( V, N ) );\n\tT2 = factor * cross( N, T1 );\n\tmat3 mat = mInv * transposeMat3( mat3( T1, T2, N ) );\n\tvec3 coords[ 4 ];\n\tcoords[ 0 ] = mat * ( rectCoords.coord0 - P );\n\tcoords[ 1 ] = mat * ( rectCoords.coord1 - P );\n\tcoords[ 2 ] = mat * ( rectCoords.coord2 - P );\n\tcoords[ 3 ] = mat * ( rectCoords.coord3 - P );\n\tcoords[ 0 ] = normalize( coords[ 0 ] );\n\tcoords[ 1 ] = normalize( coords[ 1 ] );\n\tcoords[ 2 ] = normalize( coords[ 2 ] );\n\tcoords[ 3 ] = normalize( coords[ 3 ] );\n\tvec3 vectorFormFactor = vec3( 0.0 );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 0 ], coords[ 1 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 1 ], coords[ 2 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 2 ], coords[ 3 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 3 ], coords[ 0 ] );\n\tfloat result = LTC_ClippedSphereFormFactor( vectorFormFactor );\n\treturn result;\n}\nCoords dLTCCoords;\nCoords getLTCLightCoords(vec3 lightPos, vec3 halfWidth, vec3 halfHeight){\n\tCoords coords;\n\tcoords.coord0 = lightPos + halfWidth - halfHeight;\n\tcoords.coord1 = lightPos - halfWidth - halfHeight;\n\tcoords.coord2 = lightPos - halfWidth + halfHeight;\n\tcoords.coord3 = lightPos + halfWidth + halfHeight;\n\treturn coords;\n}\nfloat dSphereRadius;\nCoords getSphereLightCoords(vec3 lightPos, vec3 halfWidth, vec3 halfHeight){\n\tdSphereRadius = max(length(halfWidth), length(halfHeight));\n\tvec3 f = reflect(normalize(lightPos - view_position), vNormalW);\n\tvec3 w = normalize(cross(f, halfHeight));\n\tvec3 h = normalize(cross(f, w));\n\treturn getLTCLightCoords(lightPos, w * dSphereRadius, h * dSphereRadius);\n}\nvec2 dLTCUV;\n#ifdef LIT_CLEARCOAT\nvec2 ccLTCUV;\n#endif\nvec2 getLTCLightUV(float gloss, vec3 worldNormal, vec3 viewDir)\n{\n\tfloat roughness = max((1.0 - gloss) * (1.0 - gloss), 0.001);\n\treturn LTC_Uv( worldNormal, viewDir, roughness );\n}\nvec3 dLTCSpecFres;\n#ifdef LIT_CLEARCOAT\nvec3 ccLTCSpecFres;\n#endif\nvec3 getLTCLightSpecFres(vec2 uv, vec3 specularity)\n{\n\tvec4 t2 = texture2DLodEXT(areaLightsLutTex2, uv, 0.0);\n\t#ifdef AREA_R8_G8_B8_A8_LUTS\n\tt2 *= vec4(0.693103,1,1,1);\n\tt2 += vec4(0.306897,0,0,0);\n\t#endif\n\treturn specularity * t2.x + ( vec3( 1.0 ) - specularity) * t2.y;\n}\nvoid calcLTCLightValues(float gloss, vec3 worldNormal, vec3 viewDir, vec3 specularity, float clearcoatGloss, vec3 clearcoatWorldNormal, float clearcoatSpecularity)\n{\n\tdLTCUV = getLTCLightUV(gloss, worldNormal, viewDir);\n\tdLTCSpecFres = getLTCLightSpecFres(dLTCUV, specularity); \n#ifdef LIT_CLEARCOAT\n\tccLTCUV = getLTCLightUV(clearcoatGloss, clearcoatWorldNormal, viewDir);\n\tccLTCSpecFres = getLTCLightSpecFres(ccLTCUV, vec3(clearcoatSpecularity));\n#endif\n}\nvoid calcRectLightValues(vec3 lightPos, vec3 halfWidth, vec3 halfHeight)\n{\n\tdLTCCoords = getLTCLightCoords(lightPos, halfWidth, halfHeight);\n}\nvoid calcDiskLightValues(vec3 lightPos, vec3 halfWidth, vec3 halfHeight)\n{\n\tcalcRectLightValues(lightPos, halfWidth, halfHeight);\n}\nvoid calcSphereLightValues(vec3 lightPos, vec3 halfWidth, vec3 halfHeight)\n{\n\tdLTCCoords = getSphereLightCoords(lightPos, halfWidth, halfHeight);\n}\nvec3 SolveCubic(vec4 Coefficient)\n{\n\tfloat pi = 3.14159;\n\tCoefficient.xyz /= Coefficient.w;\n\tCoefficient.yz /= 3.0;\n\tfloat A = Coefficient.w;\n\tfloat B = Coefficient.z;\n\tfloat C = Coefficient.y;\n\tfloat D = Coefficient.x;\n\tvec3 Delta = vec3(\n\t\t-Coefficient.z * Coefficient.z + Coefficient.y,\n\t\t-Coefficient.y * Coefficient.z + Coefficient.x,\n\t\tdot(vec2(Coefficient.z, -Coefficient.y), Coefficient.xy)\n\t);\n\tfloat Discriminant = dot(vec2(4.0 * Delta.x, -Delta.y), Delta.zy);\n\tvec3 RootsA, RootsD;\n\tvec2 xlc, xsc;\n\t{\n\t\tfloat A_a = 1.0;\n\t\tfloat C_a = Delta.x;\n\t\tfloat D_a = -2.0 * B * Delta.x + Delta.y;\n\t\tfloat Theta = atan(sqrt(Discriminant), -D_a) / 3.0;\n\t\tfloat x_1a = 2.0 * sqrt(-C_a) * cos(Theta);\n\t\tfloat x_3a = 2.0 * sqrt(-C_a) * cos(Theta + (2.0 / 3.0) * pi);\n\t\tfloat xl;\n\t\tif ((x_1a + x_3a) > 2.0 * B)\n\t\t\txl = x_1a;\n\t\telse\n\t\t\txl = x_3a;\n\t\txlc = vec2(xl - B, A);\n\t}\n\t{\n\t\tfloat A_d = D;\n\t\tfloat C_d = Delta.z;\n\t\tfloat D_d = -D * Delta.y + 2.0 * C * Delta.z;\n\t\tfloat Theta = atan(D * sqrt(Discriminant), -D_d) / 3.0;\n\t\tfloat x_1d = 2.0 * sqrt(-C_d) * cos(Theta);\n\t\tfloat x_3d = 2.0 * sqrt(-C_d) * cos(Theta + (2.0 / 3.0) * pi);\n\t\tfloat xs;\n\t\tif (x_1d + x_3d < 2.0 * C)\n\t\t\txs = x_1d;\n\t\telse\n\t\t\txs = x_3d;\n\t\txsc = vec2(-D, xs + C);\n\t}\n\tfloat E = xlc.y * xsc.y;\n\tfloat F = -xlc.x * xsc.y - xlc.y * xsc.x;\n\tfloat G = xlc.x * xsc.x;\n\tvec2 xmc = vec2(C * F - B * G, -B * F + C * E);\n\tvec3 Root = vec3(xsc.x / xsc.y, xmc.x / xmc.y, xlc.x / xlc.y);\n\tif (Root.x < Root.y && Root.x < Root.z)\n\t\tRoot.xyz = Root.yxz;\n\telse if (Root.z < Root.x && Root.z < Root.y)\n\t\tRoot.xyz = Root.xzy;\n\treturn Root;\n}\nfloat LTC_EvaluateDisk(vec3 N, vec3 V, vec3 P, mat3 Minv, Coords points)\n{\n\tvec3 T1, T2;\n\tT1 = normalize(V - N * dot(V, N));\n\tT2 = cross(N, T1);\n\tmat3 R = transposeMat3( mat3( T1, T2, N ) );\n\tvec3 L_[ 3 ];\n\tL_[ 0 ] = R * ( points.coord0 - P );\n\tL_[ 1 ] = R * ( points.coord1 - P );\n\tL_[ 2 ] = R * ( points.coord2 - P );\n\tvec3 Lo_i = vec3(0);\n\tvec3 C = 0.5 * (L_[0] + L_[2]);\n\tvec3 V1 = 0.5 * (L_[1] - L_[2]);\n\tvec3 V2 = 0.5 * (L_[1] - L_[0]);\n\tC = Minv * C;\n\tV1 = Minv * V1;\n\tV2 = Minv * V2;\n\tfloat a, b;\n\tfloat d11 = dot(V1, V1);\n\tfloat d22 = dot(V2, V2);\n\tfloat d12 = dot(V1, V2);\n\tif (abs(d12) / sqrt(d11 * d22) > 0.0001)\n\t{\n\t\tfloat tr = d11 + d22;\n\t\tfloat det = -d12 * d12 + d11 * d22;\n\t\tdet = sqrt(det);\n\t\tfloat u = 0.5 * sqrt(tr - 2.0 * det);\n\t\tfloat v = 0.5 * sqrt(tr + 2.0 * det);\n\t\tfloat e_max = (u + v) * (u + v);\n\t\tfloat e_min = (u - v) * (u - v);\n\t\tvec3 V1_, V2_;\n\t\tif (d11 > d22)\n\t\t{\n\t\t\tV1_ = d12 * V1 + (e_max - d11) * V2;\n\t\t\tV2_ = d12 * V1 + (e_min - d11) * V2;\n\t\t}\n\t\telse\n\t\t{\n\t\t\tV1_ = d12*V2 + (e_max - d22)*V1;\n\t\t\tV2_ = d12*V2 + (e_min - d22)*V1;\n\t\t}\n\t\ta = 1.0 / e_max;\n\t\tb = 1.0 / e_min;\n\t\tV1 = normalize(V1_);\n\t\tV2 = normalize(V2_);\n\t}\n\telse\n\t{\n\t\ta = 1.0 / dot(V1, V1);\n\t\tb = 1.0 / dot(V2, V2);\n\t\tV1 *= sqrt(a);\n\t\tV2 *= sqrt(b);\n\t}\n\tvec3 V3 = cross(V1, V2);\n\tif (dot(C, V3) < 0.0)\n\t\tV3 *= -1.0;\n\tfloat L = dot(V3, C);\n\tfloat x0 = dot(V1, C) / L;\n\tfloat y0 = dot(V2, C) / L;\n\tfloat E1 = inversesqrt(a);\n\tfloat E2 = inversesqrt(b);\n\ta *= L * L;\n\tb *= L * L;\n\tfloat c0 = a * b;\n\tfloat c1 = a * b * (1.0 + x0 * x0 + y0 * y0) - a - b;\n\tfloat c2 = 1.0 - a * (1.0 + x0 * x0) - b * (1.0 + y0 * y0);\n\tfloat c3 = 1.0;\n\tvec3 roots = SolveCubic(vec4(c0, c1, c2, c3));\n\tfloat e1 = roots.x;\n\tfloat e2 = roots.y;\n\tfloat e3 = roots.z;\n\tvec3 avgDir = vec3(a * x0 / (a - e2), b * y0 / (b - e2), 1.0);\n\tmat3 rotate = mat3(V1, V2, V3);\n\tavgDir = rotate * avgDir;\n\tavgDir = normalize(avgDir);\n\tfloat L1 = sqrt(-e2 / e3);\n\tfloat L2 = sqrt(-e2 / e1);\n\tfloat formFactor = L1 * L2 * inversesqrt((1.0 + L1 * L1) * (1.0 + L2 * L2));\n\t\n\tconst float LUT_SIZE = 64.0;\n\tconst float LUT_SCALE = ( LUT_SIZE - 1.0 ) / LUT_SIZE;\n\tconst float LUT_BIAS = 0.5 / LUT_SIZE;\n\tvec2 uv = vec2(avgDir.z * 0.5 + 0.5, formFactor);\n\tuv = uv*LUT_SCALE + LUT_BIAS;\n\tfloat scale = texture2DLodEXT(areaLightsLutTex2, uv, 0.0).w;\n\treturn formFactor*scale;\n}\nfloat getRectLightDiffuse(vec3 worldNormal, vec3 viewDir, vec3 lightDir, vec3 lightDirNorm) {\n\treturn LTC_EvaluateRect( worldNormal, viewDir, vPositionW, mat3( 1.0 ), dLTCCoords );\n}\nfloat getDiskLightDiffuse(vec3 worldNormal, vec3 viewDir, vec3 lightDir, vec3 lightDirNorm) {\n\treturn LTC_EvaluateDisk( worldNormal, viewDir, vPositionW, mat3( 1.0 ), dLTCCoords );\n}\nfloat getSphereLightDiffuse(vec3 worldNormal, vec3 viewDir, vec3 lightDir, vec3 lightDirNorm) {\n\tfloat falloff = dSphereRadius / (dot(lightDir, lightDir) + dSphereRadius);\n\treturn getLightDiffuse(worldNormal, viewDir, lightDir, lightDirNorm) * falloff;\n}\nmat3 getLTCLightInvMat(vec2 uv)\n{\n\tvec4 t1 = texture2DLodEXT(areaLightsLutTex1, uv, 0.0);\n\t#ifdef AREA_R8_G8_B8_A8_LUTS\n\tt1 *= vec4(1.001, 0.3239, 0.60437568, 1.0);\n\tt1 += vec4(0.0, -0.2976, -0.01381, 0.0);\n\t#endif\n\treturn mat3(\n\t\tvec3( t1.x, 0, t1.y ),\n\t\tvec3(\t0, 1,\t0 ),\n\t\tvec3( t1.z, 0, t1.w )\n\t);\n}\nfloat calcRectLightSpecular(vec3 worldNormal, vec3 viewDir, vec2 uv) {\n\tmat3 mInv = getLTCLightInvMat(uv);\n\treturn LTC_EvaluateRect( worldNormal, viewDir, vPositionW, mInv, dLTCCoords );\n}\nfloat getRectLightSpecular(vec3 worldNormal, vec3 viewDir) {\n\treturn calcRectLightSpecular(worldNormal, viewDir, dLTCUV);\n}\nfloat calcDiskLightSpecular(vec3 worldNormal, vec3 viewDir, vec2 uv) {\n\tmat3 mInv = getLTCLightInvMat(uv);\n\treturn LTC_EvaluateDisk( worldNormal, viewDir, vPositionW, mInv, dLTCCoords );\n}\nfloat getDiskLightSpecular(vec3 worldNormal, vec3 viewDir) {\n\treturn calcDiskLightSpecular(worldNormal, viewDir, dLTCUV);\n}\nfloat getSphereLightSpecular(vec3 worldNormal, vec3 viewDir) {\n\treturn calcDiskLightSpecular(worldNormal, viewDir, dLTCUV);\n}\n`;\n\nexport { ltcPS as default };\n", "var metalnessPS = `\n#ifdef MAPFLOAT\nuniform float material_metalness;\n#endif\nvoid getMetalness() {\n\tfloat metalness = 1.0;\n\t#ifdef MAPFLOAT\n\tmetalness *= material_metalness;\n\t#endif\n\t#ifdef MAPTEXTURE\n\tmetalness *= texture2DBias($SAMPLER, $UV, textureBias).$CH;\n\t#endif\n\t#ifdef MAPVERTEX\n\tmetalness *= saturate(vVertexColor.$VC);\n\t#endif\n\tdMetalness = metalness;\n}\n`;\n\nexport { metalnessPS as default };\n", "var msdfPS = `\nuniform sampler2D texture_msdfMap;\n#ifdef GL_OES_standard_derivatives\n#define USE_FWIDTH\n#endif\n#ifdef GL2\n#define USE_FWIDTH\n#endif\nfloat median(float r, float g, float b) {\n\treturn max(min(r, g), min(max(r, g), b));\n}\nfloat map (float min, float max, float v) {\n\treturn (v - min) / (max - min);\n}\nuniform float font_sdfIntensity;\nuniform float font_pxrange;\nuniform float font_textureWidth;\n#ifdef UNIFORM_TEXT_PARAMETERS\nuniform vec4 outline_color;\nuniform float outline_thickness;\nuniform vec4 shadow_color;\nuniform vec2 shadow_offset;\n#else\nvarying vec4 outline_color;\nvarying float outline_thickness;\nvarying vec4 shadow_color;\nvarying vec2 shadow_offset;\n#endif\nvec4 applyMsdf(vec4 color) {\n\tvec3 tsample = texture2D(texture_msdfMap, vUv0).rgb;\n\tvec2 uvShdw = vUv0 - shadow_offset;\n\tvec3 ssample = texture2D(texture_msdfMap, uvShdw).rgb;\n\tfloat sigDist = median(tsample.r, tsample.g, tsample.b);\n\tfloat sigDistShdw = median(ssample.r, ssample.g, ssample.b);\n\tfloat smoothingMax = 0.2;\n\t#ifdef USE_FWIDTH\n\tvec2 w = fwidth(vUv0);\n\tfloat smoothing = clamp(w.x * font_textureWidth / font_pxrange, 0.0, smoothingMax);\n\t#else\n\tfloat font_size = 16.0;\n\tfloat smoothing = clamp(font_pxrange / font_size, 0.0, smoothingMax);\n\t#endif\n\tfloat mapMin = 0.05;\n\tfloat mapMax = clamp(1.0 - font_sdfIntensity, mapMin, 1.0);\n\tfloat sigDistInner = map(mapMin, mapMax, sigDist);\n\tfloat sigDistOutline = map(mapMin, mapMax, sigDist + outline_thickness);\n\tsigDistShdw = map(mapMin, mapMax, sigDistShdw + outline_thickness);\n\tfloat center = 0.5;\n\tfloat inside = smoothstep(center-smoothing, center+smoothing, sigDistInner);\n\tfloat outline = smoothstep(center-smoothing, center+smoothing, sigDistOutline);\n\tfloat shadow = smoothstep(center-smoothing, center+smoothing, sigDistShdw);\n\tvec4 tcolor = (outline > inside) ? outline * vec4(outline_color.a * outline_color.rgb, outline_color.a) : vec4(0.0);\n\ttcolor = mix(tcolor, color, inside);\n\tvec4 scolor = (shadow > outline) ? shadow * vec4(shadow_color.a * shadow_color.rgb, shadow_color.a) : tcolor;\n\ttcolor = mix(scolor, tcolor, outline);\n\t\n\treturn tcolor;\n}\n`;\n\nexport { msdfPS as default };\n", "var metalnessModulatePS = `\nvec3 getSpecularModulate(in vec3 specularity, in vec3 albedo, in float metalness, in float f0) {\n\tvec3 dielectricF0 = f0 * specularity;\n\treturn mix(dielectricF0, albedo, metalness);\n}\nvec3 getAlbedoModulate(in vec3 albedo, in float metalness) {\n\treturn albedo * (1.0 - metalness);\n}\n`;\n\nexport { metalnessModulatePS as default };\n", "var msdfVS = `\nattribute vec3 vertex_outlineParameters;\nattribute vec3 vertex_shadowParameters;\nvarying vec4 outline_color;\nvarying float outline_thickness;\nvarying vec4 shadow_color;\nvarying vec2 shadow_offset;\nvoid unpackMsdfParams() {\n\tvec3 little = mod(vertex_outlineParameters, 256.);\n\tvec3 big = (vertex_outlineParameters - little) / 256.;\n\toutline_color.rb = little.xy / 255.;\n\toutline_color.ga = big.xy / 255.;\n\toutline_thickness = little.z / 255. * 0.2;\n\tlittle = mod(vertex_shadowParameters, 256.);\n\tbig = (vertex_shadowParameters - little) / 256.;\n\tshadow_color.rb = little.xy / 255.;\n\tshadow_color.ga = big.xy / 255.;\n\tshadow_offset = (vec2(little.z, big.z) / 127. - 1.) * 0.005;\n}\n`;\n\nexport { msdfVS as default };\n", "var normalVS = `\n#ifdef MORPHING_TEXTURE_BASED_NORMAL\nuniform highp sampler2D morphNormalTex;\n#endif\nvec3 getNormal() {\n\t#ifdef SKIN\n\tdNormalMatrix = mat3(dModelMatrix[0].xyz, dModelMatrix[1].xyz, dModelMatrix[2].xyz);\n\t#elif defined(INSTANCING)\n\tdNormalMatrix = mat3(instance_line1.xyz, instance_line2.xyz, instance_line3.xyz);\n\t#else\n\tdNormalMatrix = matrix_normal;\n\t#endif\n\tvec3 tempNormal = vertex_normal;\n\t#ifdef MORPHING\n\t#ifdef MORPHING_NRM03\n\ttempNormal += morph_weights_a[0] * morph_nrm0;\n\ttempNormal += morph_weights_a[1] * morph_nrm1;\n\ttempNormal += morph_weights_a[2] * morph_nrm2;\n\ttempNormal += morph_weights_a[3] * morph_nrm3;\n\t#endif\n\t#ifdef MORPHING_NRM47\n\ttempNormal += morph_weights_b[0] * morph_nrm4;\n\ttempNormal += morph_weights_b[1] * morph_nrm5;\n\ttempNormal += morph_weights_b[2] * morph_nrm6;\n\ttempNormal += morph_weights_b[3] * morph_nrm7;\n\t#endif\n\t#endif\n\t#ifdef MORPHING_TEXTURE_BASED_NORMAL\n\t\t#ifdef WEBGPU\n\t\t\tivec2 morphUV = getTextureMorphCoords();\n\t\t\tvec3 morphNormal = texelFetch(morphNormalTex, ivec2(morphUV), 0).xyz;\n\t\t#else\n\t\t\tvec2 morphUV = getTextureMorphCoords();\n\t\t\tvec3 morphNormal = texture2D(morphNormalTex, morphUV).xyz;\n\t\t#endif\n\ttempNormal += morphNormal;\n\t#endif\n\treturn normalize(dNormalMatrix * tempNormal);\n}\n`;\n\nexport { normalVS as default };\n", "var normalDetailMapPS = `\n#ifdef MAPTEXTURE\nuniform float material_normalDetailMapBumpiness;\nvec3 blendNormals(vec3 n1, vec3 n2) {\n\tn1 += vec3(0, 0, 1);\n\tn2 *= vec3(-1, -1, 1);\n\treturn n1 * dot(n1, n2) / n1.z - n2;\n}\n#endif\nvec3 addNormalDetail(vec3 normalMap) {\n#ifdef MAPTEXTURE\n\tvec3 normalDetailMap = unpackNormal(texture2DBias($SAMPLER, $UV, textureBias));\n\tnormalDetailMap = mix(vec3(0.0, 0.0, 1.0), normalDetailMap, material_normalDetailMapBumpiness);\n\treturn blendNormals(normalMap, normalDetailMap);\n#else\n\treturn normalMap;\n#endif\n}\n`;\n\nexport { normalDetailMapPS as default };\n", "var normalInstancedVS = `\nvec3 getNormal() {\n\tdNormalMatrix = mat3(instance_line1.xyz, instance_line2.xyz, instance_line3.xyz);\n\treturn normalize(dNormalMatrix * vertex_normal);\n}\n`;\n\nexport { normalInstancedVS as default };\n", "var normalMapPS = `\n#ifdef MAPTEXTURE\nuniform float material_bumpiness;\n#endif\nvoid getNormal() {\n#ifdef MAPTEXTURE\n\tvec3 normalMap = unpackNormal(texture2DBias($SAMPLER, $UV, textureBias));\n\tnormalMap = mix(vec3(0.0, 0.0, 1.0), normalMap, material_bumpiness);\n\tdNormalW = normalize(dTBN * addNormalDetail(normalMap));\n#else\n\tdNormalW = dVertexNormalW;\n#endif\n}\n`;\n\nexport { normalMapPS as default };\n", "var normalSkinnedVS = `\nvec3 getNormal() {\n\tdNormalMatrix = mat3(dModelMatrix[0].xyz, dModelMatrix[1].xyz, dModelMatrix[2].xyz);\n\treturn normalize(dNormalMatrix * vertex_normal);\n}\n`;\n\nexport { normalSkinnedVS as default };\n", "var normalXYPS = `\nvec3 unpackNormal(vec4 nmap) {\n\tvec3 normal;\n\tnormal.xy = nmap.wy * 2.0 - 1.0;\n\tnormal.z = sqrt(1.0 - saturate(dot(normal.xy, normal.xy)));\n\treturn normal;\n}\n`;\n\nexport { normalXYPS as default };\n", "var normalXYZPS = `\nvec3 unpackNormal(vec4 nmap) {\n\treturn nmap.xyz * 2.0 - 1.0;\n}\n`;\n\nexport { normalXYZPS as default };\n", "var opacityPS = `\n#ifdef MAPFLOAT\nuniform float material_opacity;\n#endif\nvoid getOpacity() {\n\tdAlpha = 1.0;\n\t#ifdef MAPFLOAT\n\tdAlpha *= material_opacity;\n\t#endif\n\t#ifdef MAPTEXTURE\n\tdAlpha *= texture2DBias($SAMPLER, $UV, textureBias).$CH;\n\t#endif\n\t#ifdef MAPVERTEX\n\tdAlpha *= clamp(vVertexColor.$VC, 0.0, 1.0);\n\t#endif\n}\n`;\n\nexport { opacityPS as default };\n", "var opacityDitherPS = `\nuniform vec4 blueNoiseJitter;\n#ifdef DITHER_BLUENOISE\n\tuniform sampler2D blueNoiseTex32;\n#endif\nvoid opacityDither(float alpha, float id) {\n\t#ifdef DITHER_BAYER8\n\t\tfloat noise = bayer8(floor(mod(gl_FragCoord.xy + blueNoiseJitter.xy + id, 8.0))) / 64.0;\n\t#else\n\t\t#ifdef DITHER_BLUENOISE\n\t\t\tvec2 uv = fract(gl_FragCoord.xy / 32.0 + blueNoiseJitter.xy + id);\n\t\t\tfloat noise = texture2DLodEXT(blueNoiseTex32, uv, 0.0).y;\n\t\t#endif\n\t\t#ifdef DITHER_IGNNOISE\n\t\t\tvec3 magic = vec3(0.06711056, 0.00583715, 52.9829189);\n\t\t\tfloat noise = fract(magic.z * fract(dot(gl_FragCoord.xy + blueNoiseJitter.xy + id, magic.xy)));\n\t\t#endif\n\t#endif\n\tif (alpha < noise)\n\t\tdiscard;\n}\n`;\n\nexport { opacityDitherPS as default };\n", "var outputPS = `\n`;\n\nexport { outputPS as default };\n", "var outputAlphaPS = `\ngl_FragColor.a = litArgs_opacity;\n`;\n\nexport { outputAlphaPS as default };\n", "var outputAlphaOpaquePS = `\n\tgl_FragColor.a = 1.0;\n`;\n\nexport { outputAlphaOpaquePS as default };\n", "var outputAlphaPremulPS = `\ngl_FragColor.rgb *= litArgs_opacity;\ngl_FragColor.a = litArgs_opacity;\n`;\n\nexport { outputAlphaPremulPS as default };\n", "var outputTex2DPS = `\nvarying vec2 vUv0;\nuniform sampler2D source;\nvoid main(void) {\n\tgl_FragColor = texture2D(source, vUv0);\n}\n`;\n\nexport { outputTex2DPS as default };\n", "var packDepthPS = `\nvec4 packFloat(float depth) {\n\tconst vec4 bit_shift = vec4(256.0 * 256.0 * 256.0, 256.0 * 256.0, 256.0, 1.0);\n\tconst vec4 bit_mask = vec4(0.0, 1.0 / 256.0, 1.0 / 256.0, 1.0 / 256.0);\n\tvec4 res = mod(depth * bit_shift * vec4(255), vec4(256) ) / vec4(255);\n\tres -= res.xxyz * bit_mask;\n\treturn res;\n}\n`;\n\nexport { packDepthPS as default };\n", "var sheenPS = `\n#ifdef MAPCOLOR\nuniform vec3 material_sheen;\n#endif\nvoid getSheen() {\n\tvec3 sheenColor = vec3(1, 1, 1);\n\t#ifdef MAPCOLOR\n\tsheenColor *= material_sheen;\n\t#endif\n\t#ifdef MAPTEXTURE\n\tsheenColor *= $DECODE(texture2DBias($SAMPLER, $UV, textureBias)).$CH;\n\t#endif\n\t#ifdef MAPVERTEX\n\tsheenColor *= saturate(vVertexColor.$VC);\n\t#endif\n\tsSpecularity = sheenColor;\n}\n`;\n\nexport { sheenPS as default };\n", "var sheenGlossPS = `\n#ifdef MAPFLOAT\nuniform float material_sheenGloss;\n#endif\nvoid getSheenGlossiness() {\n\tfloat sheenGlossiness = 1.0;\n\t#ifdef MAPFLOAT\n\tsheenGlossiness *= material_sheenGloss;\n\t#endif\n\t#ifdef MAPTEXTURE\n\tsheenGlossiness *= texture2DBias($SAMPLER, $UV, textureBias).$CH;\n\t#endif\n\t#ifdef MAPVERTEX\n\tsheenGlossiness *= saturate(vVertexColor.$VC);\n\t#endif\n\t#ifdef MAPINVERT\n\tsheenGlossiness = 1.0 - sheenGlossiness;\n\t#endif\n\tsheenGlossiness += 0.0000001;\n\tsGlossiness = sheenGlossiness;\n}\n`;\n\nexport { sheenGlossPS as default };\n", "var parallaxPS = `\nuniform float material_heightMapFactor;\nvoid getParallax() {\n\tfloat parallaxScale = material_heightMapFactor;\n\tfloat height = texture2DBias($SAMPLER, $UV, textureBias).$CH;\n\theight = height * parallaxScale - parallaxScale*0.5;\n\tvec3 viewDirT = dViewDirW * dTBN;\n\tviewDirT.z += 0.42;\n\tdUvOffset = height * (viewDirT.xy / viewDirT.z);\n}\n`;\n\nexport { parallaxPS as default };\n", "var particlePS = `\nvarying vec4 texCoordsAlphaLife;\nuniform sampler2D colorMap;\nuniform sampler2D colorParam;\nuniform float graphSampleSize;\nuniform float graphNumSamples;\n#ifndef CAMERAPLANES\n#define CAMERAPLANES\nuniform vec4 camera_params;\n#endif\nuniform float softening;\nuniform float colorMult;\nfloat saturate(float x) {\n\treturn clamp(x, 0.0, 1.0);\n}\n#ifndef UNPACKFLOAT\n#define UNPACKFLOAT\nfloat unpackFloat(vec4 rgbaDepth) {\n\tconst vec4 bitShift = vec4(1.0 / (256.0 * 256.0 * 256.0), 1.0 / (256.0 * 256.0), 1.0 / 256.0, 1.0);\n\tfloat depth = dot(rgbaDepth, bitShift);\n\treturn depth;\n}\n#endif\nvoid main(void) {\n\tvec4 tex = gammaCorrectInput(texture2D(colorMap, vec2(texCoordsAlphaLife.x, 1.0 - texCoordsAlphaLife.y)));\n\tvec4 ramp = gammaCorrectInput(texture2D(colorParam, vec2(texCoordsAlphaLife.w, 0.0)));\n\tramp.rgb *= colorMult;\n\tramp.a += texCoordsAlphaLife.z;\n\tvec3 rgb = tex.rgb * ramp.rgb;\n\tfloat a = tex.a * ramp.a;\n`;\n\nexport { particlePS as default };\n", "var particleVS = `\nvec3 unpack3NFloats(float src) {\n\tfloat r = fract(src);\n\tfloat g = fract(src * 256.0);\n\tfloat b = fract(src * 65536.0);\n\treturn vec3(r, g, b);\n}\nfloat saturate(float x) {\n\treturn clamp(x, 0.0, 1.0);\n}\nvec4 tex1Dlod_lerp(TEXTURE_ACCEPT_HIGHP(tex), vec2 tc) {\n\treturn mix( texture2D(tex,tc), texture2D(tex,tc + graphSampleSize), fract(tc.x*graphNumSamples) );\n}\nvec4 tex1Dlod_lerp(TEXTURE_ACCEPT_HIGHP(tex), vec2 tc, out vec3 w) {\n\tvec4 a = texture2D(tex,tc);\n\tvec4 b = texture2D(tex,tc + graphSampleSize);\n\tfloat c = fract(tc.x*graphNumSamples);\n\tvec3 unpackedA = unpack3NFloats(a.w);\n\tvec3 unpackedB = unpack3NFloats(b.w);\n\tw = mix(unpackedA, unpackedB, c);\n\treturn mix(a, b, c);\n}\nvec2 rotate(vec2 quadXY, float pRotation, out mat2 rotMatrix) {\n\tfloat c = cos(pRotation);\n\tfloat s = sin(pRotation);\n\tmat2 m = mat2(c, -s, s, c);\n\trotMatrix = m;\n\treturn m * quadXY;\n}\nvec3 billboard(vec3 InstanceCoords, vec2 quadXY) {\n\t#ifdef SCREEN_SPACE\n\t\tvec3 pos = vec3(-1, 0, 0) * quadXY.x + vec3(0, -1, 0) * quadXY.y;\n\t#else\n\t\tvec3 pos = -matrix_viewInverse[0].xyz * quadXY.x + -matrix_viewInverse[1].xyz * quadXY.y;\n\t#endif\n\treturn pos;\n}\nvec3 customFace(vec3 InstanceCoords, vec2 quadXY) {\n\tvec3 pos = faceTangent * quadXY.x + faceBinorm * quadXY.y;\n\treturn pos;\n}\nvec2 safeNormalize(vec2 v) {\n\tfloat l = length(v);\n\treturn (l > 1e-06) ? v / l : v;\n}\nvoid main(void) {\n\tvec3 meshLocalPos = particle_vertexData.xyz;\n\tfloat id = floor(particle_vertexData.w);\n\tfloat rndFactor = fract(sin(id + 1.0 + seed));\n\tvec3 rndFactor3 = vec3(rndFactor, fract(rndFactor*10.0), fract(rndFactor*100.0));\n\tfloat uv = id / numParticlesPot;\n\treadInput(uv);\n#ifdef LOCAL_SPACE\n\tinVel = mat3(matrix_model) * inVel;\n#endif\n\tvec2 velocityV = safeNormalize((mat3(matrix_view) * inVel).xy);\n\tfloat particleLifetime = lifetime;\n\tif (inLife <= 0.0 || inLife > particleLifetime || !inShow) meshLocalPos = vec3(0.0);\n\tvec2 quadXY = meshLocalPos.xy;\n\tfloat nlife = clamp(inLife / particleLifetime, 0.0, 1.0);\n\tvec3 paramDiv;\n\tvec4 params = tex1Dlod_lerp(TEXTURE_PASS(internalTex2), vec2(nlife, 0), paramDiv);\n\tfloat scale = params.y;\n\tfloat scaleDiv = paramDiv.x;\n\tfloat alphaDiv = paramDiv.z;\n\tscale += (scaleDiv * 2.0 - 1.0) * scaleDivMult * fract(rndFactor*10000.0);\n#ifndef USE_MESH\n\ttexCoordsAlphaLife = vec4(quadXY * -0.5 + 0.5, (alphaDiv * 2.0 - 1.0) * alphaDivMult * fract(rndFactor*1000.0), nlife);\n#else\n\ttexCoordsAlphaLife = vec4(particle_uv, (alphaDiv * 2.0 - 1.0) * alphaDivMult * fract(rndFactor*1000.0), nlife);\n#endif\n\tvec3 particlePos = inPos;\n\tvec3 particlePosMoved = vec3(0.0);\n\tmat2 rotMatrix;\n`;\n\nexport { particleVS as default };\n", "var particleAnimFrameClampVS = `\n\tfloat animFrame = min(floor(texCoordsAlphaLife.w * animTexParams.y) + animTexParams.x, animTexParams.z);\n`;\n\nexport { particleAnimFrameClampVS as default };\n", "var particleAnimFrameLoopVS = `\n\tfloat animFrame = floor(mod(texCoordsAlphaLife.w * animTexParams.y + animTexParams.x, animTexParams.z + 1.0));\n`;\n\nexport { particleAnimFrameLoopVS as default };\n", "var particleAnimTexVS = `\n\tfloat animationIndex;\n\tif (animTexIndexParams.y == 1.0) {\n\t\tanimationIndex = floor((animTexParams.w + 1.0) * rndFactor3.z) * (animTexParams.z + 1.0);\n\t} else {\n\t\tanimationIndex = animTexIndexParams.x * (animTexParams.z + 1.0);\n\t}\n\tfloat atlasX = (animationIndex + animFrame) * animTexTilesParams.x;\n\tfloat atlasY = 1.0 - floor(atlasX + 1.0) * animTexTilesParams.y;\n\tatlasX = fract(atlasX);\n\ttexCoordsAlphaLife.xy *= animTexTilesParams.xy;\n\ttexCoordsAlphaLife.xy += vec2(atlasX, atlasY);\n`;\n\nexport { particleAnimTexVS as default };\n", "var particleInputFloatPS = `\nvoid readInput(float uv) {\n\tvec4 tex = texture2D(particleTexIN, vec2(uv, 0.25));\n\tvec4 tex2 = texture2D(particleTexIN, vec2(uv, 0.75));\n\tinPos = tex.xyz;\n\tinVel = tex2.xyz;\n\tinAngle = (tex.w < 0.0? -tex.w : tex.w) - 1000.0;\n\tinShow = tex.w >= 0.0;\n\tinLife = tex2.w;\n}\n`;\n\nexport { particleInputFloatPS as default };\n", "var particleInputRgba8PS = `\n#define PI2 6.283185307179586\nuniform vec3 inBoundsSize;\nuniform vec3 inBoundsCenter;\nuniform float maxVel;\nfloat decodeFloatRG(vec2 rg) {\n\treturn rg.y*(1.0/255.0) + rg.x;\n}\nfloat decodeFloatRGBA( vec4 rgba ) {\n\treturn dot( rgba, vec4(1.0, 1.0/255.0, 1.0/65025.0, 1.0/160581375.0) );\n}\nvoid readInput(float uv) {\n\tvec4 tex0 = texture2D(particleTexIN, vec2(uv, 0.125));\n\tvec4 tex1 = texture2D(particleTexIN, vec2(uv, 0.375));\n\tvec4 tex2 = texture2D(particleTexIN, vec2(uv, 0.625));\n\tvec4 tex3 = texture2D(particleTexIN, vec2(uv, 0.875));\n\tinPos = vec3(decodeFloatRG(tex0.rg), decodeFloatRG(tex0.ba), decodeFloatRG(tex1.rg));\n\tinPos = (inPos - vec3(0.5)) * inBoundsSize + inBoundsCenter;\n\tinVel = tex2.xyz;\n\tinVel = (inVel - vec3(0.5)) * maxVel;\n\tinAngle = decodeFloatRG(tex1.ba) * PI2;\n\tinShow = tex2.a > 0.5;\n\tinLife = decodeFloatRGBA(tex3);\n\tfloat maxNegLife = max(lifetime, (numParticles - 1.0) * (rate+rateDiv));\n\tfloat maxPosLife = lifetime+1.0;\n\tinLife = inLife * (maxNegLife + maxPosLife) - maxNegLife;\n}\n`;\n\nexport { particleInputRgba8PS as default };\n", "var particleOutputFloatPS = `\nvoid writeOutput() {\n\tif (gl_FragCoord.y<1.0) {\n\t\tgl_FragColor = vec4(outPos, (outAngle + 1000.0) * visMode);\n\t} else {\n\t\tgl_FragColor = vec4(outVel, outLife);\n\t}\n}\n`;\n\nexport { particleOutputFloatPS as default };\n", "var particleOutputRgba8PS = `\nuniform vec3 outBoundsMul;\nuniform vec3 outBoundsAdd;\nvec2 encodeFloatRG( float v ) {\n\tvec2 enc = vec2(1.0, 255.0) * v;\n\tenc = fract(enc);\n\tenc -= enc.yy * vec2(1.0/255.0, 1.0/255.0);\n\treturn enc;\n}\nvec4 encodeFloatRGBA( float v ) {\n\tvec4 enc = vec4(1.0, 255.0, 65025.0, 160581375.0) * v;\n\tenc = fract(enc);\n\tenc -= enc.yzww * vec4(1.0/255.0,1.0/255.0,1.0/255.0,0.0);\n\treturn enc;\n}\nvoid writeOutput() {\n\toutPos = outPos * outBoundsMul + outBoundsAdd;\n\toutAngle = fract(outAngle / PI2);\n\toutVel = (outVel / maxVel) + vec3(0.5);\n\tfloat maxNegLife = max(lifetime, (numParticles - 1.0) * (rate+rateDiv));\n\tfloat maxPosLife = lifetime+1.0;\n\toutLife = (outLife + maxNegLife) / (maxNegLife + maxPosLife);\n\tif (gl_FragCoord.y < 1.0) {\n\t\tgl_FragColor = vec4(encodeFloatRG(outPos.x), encodeFloatRG(outPos.y));\n\t} else if (gl_FragCoord.y < 2.0) {\n\t\tgl_FragColor = vec4(encodeFloatRG(outPos.z), encodeFloatRG(outAngle));\n\t} else if (gl_FragCoord.y < 3.0) {\n\t\tgl_FragColor = vec4(outVel, visMode*0.5+0.5);\n\t} else {\n\t\tgl_FragColor = encodeFloatRGBA(outLife);\n\t}\n}\n`;\n\nexport { particleOutputRgba8PS as default };\n", "var particleUpdaterAABBPS = `\nuniform mat3 spawnBounds;\nuniform vec3 spawnPosInnerRatio;\nvec3 calcSpawnPosition(vec3 inBounds, float rndFactor) {\n\tvec3 pos = inBounds - vec3(0.5);\n\tvec3 posAbs = abs(pos);\n\tvec3 maxPos = vec3(max(posAbs.x, max(posAbs.y, posAbs.z)));\n\tvec3 edge = maxPos + (vec3(0.5) - maxPos) * spawnPosInnerRatio;\n\tpos.x = edge.x * (maxPos.x == posAbs.x ? sign(pos.x) : 2.0 * pos.x);\n\tpos.y = edge.y * (maxPos.y == posAbs.y ? sign(pos.y) : 2.0 * pos.y);\n\tpos.z = edge.z * (maxPos.z == posAbs.z ? sign(pos.z) : 2.0 * pos.z);\n#ifndef LOCAL_SPACE\n\treturn emitterPos + spawnBounds * pos;\n#else\n\treturn spawnBounds * pos;\n#endif\n}\nvoid addInitialVelocity(inout vec3 localVelocity, vec3 inBounds) {\n\tlocalVelocity -= vec3(0, 0, initialVelocity);\n}\n`;\n\nexport { particleUpdaterAABBPS as default };\n", "var particleUpdaterEndPS = `\n\twriteOutput();\n}\n`;\n\nexport { particleUpdaterEndPS as default };\n", "var particleUpdaterInitPS = `\nvarying vec2 vUv0;\nuniform highp sampler2D particleTexIN;\nuniform highp sampler2D internalTex0;\nuniform highp sampler2D internalTex1;\nuniform highp sampler2D internalTex2;\nuniform highp sampler2D internalTex3;\nuniform mat3 emitterMatrix;\nuniform mat3 emitterMatrixInv;\nuniform vec3 emitterScale;\nuniform vec3 emitterPos;\nuniform vec3 frameRandom;\nuniform vec3 localVelocityDivMult;\nuniform vec3 velocityDivMult;\nuniform float delta;\nuniform float rate;\nuniform float rateDiv;\nuniform float lifetime;\nuniform float numParticles;\nuniform float rotSpeedDivMult;\nuniform float radialSpeedDivMult;\nuniform float seed;\nuniform float startAngle;\nuniform float startAngle2;\nuniform float initialVelocity;\nuniform float graphSampleSize;\nuniform float graphNumSamples;\nvec3 inPos;\nvec3 inVel;\nfloat inAngle;\nbool inShow;\nfloat inLife;\nfloat visMode;\nvec3 outPos;\nvec3 outVel;\nfloat outAngle;\nbool outShow;\nfloat outLife;\n`;\n\nexport { particleUpdaterInitPS as default };\n", "var particleUpdaterNoRespawnPS = `\n\tif (outLife >= lifetime) {\n\t\toutLife -= max(lifetime, (numParticles - 1.0) * particleRate);\n\t\tvisMode = -1.0;\n\t}\n`;\n\nexport { particleUpdaterNoRespawnPS as default };\n", "var particleUpdaterOnStopPS = `\n\tvisMode = outLife < 0.0? -1.0: visMode;\n`;\n\nexport { particleUpdaterOnStopPS as default };\n", "var particleUpdaterRespawnPS = `\n\tif (outLife >= lifetime) {\n\t\toutLife -= max(lifetime, (numParticles - 1.0) * particleRate);\n\t\tvisMode = 1.0;\n\t}\n\tvisMode = outLife < 0.0? 1.0: visMode;\n`;\n\nexport { particleUpdaterRespawnPS as default };\n", "var particleUpdaterSpherePS = `\nuniform float spawnBoundsSphere;\nuniform float spawnBoundsSphereInnerRatio;\nvec3 calcSpawnPosition(vec3 inBounds, float rndFactor) {\n\tfloat rnd4 = fract(rndFactor * 1000.0);\n\tvec3 norm = normalize(inBounds.xyz - vec3(0.5));\n\tfloat r = rnd4 * (1.0 - spawnBoundsSphereInnerRatio) + spawnBoundsSphereInnerRatio;\n#ifndef LOCAL_SPACE\n\treturn emitterPos + norm * r * spawnBoundsSphere;\n#else\n\treturn norm * r * spawnBoundsSphere;\n#endif\n}\nvoid addInitialVelocity(inout vec3 localVelocity, vec3 inBounds) {\n\tlocalVelocity += normalize(inBounds - vec3(0.5)) * initialVelocity;\n}\n`;\n\nexport { particleUpdaterSpherePS as default };\n", "var particleUpdaterStartPS = `\nfloat saturate(float x) {\n\treturn clamp(x, 0.0, 1.0);\n}\nvec3 unpack3NFloats(float src) {\n\tfloat r = fract(src);\n\tfloat g = fract(src * 256.0);\n\tfloat b = fract(src * 65536.0);\n\treturn vec3(r, g, b);\n}\nvec3 tex1Dlod_lerp(TEXTURE_ACCEPT_HIGHP(tex), vec2 tc, out vec3 w) {\n\tvec4 a = texture2D(tex, tc);\n\tvec4 b = texture2D(tex, tc + graphSampleSize);\n\tfloat c = fract(tc.x * graphNumSamples);\n\tvec3 unpackedA = unpack3NFloats(a.w);\n\tvec3 unpackedB = unpack3NFloats(b.w);\n\tw = mix(unpackedA, unpackedB, c);\n\treturn mix(a.xyz, b.xyz, c);\n}\n#define HASHSCALE4 vec4(1031, .1030, .0973, .1099)\nvec4 hash41(float p) {\n\tvec4 p4 = fract(vec4(p) * HASHSCALE4);\n\tp4 += dot(p4, p4.wzxy+19.19);\n\treturn fract(vec4((p4.x + p4.y)*p4.z, (p4.x + p4.z)*p4.y, (p4.y + p4.z)*p4.w, (p4.z + p4.w)*p4.x));\n}\nvoid main(void) {\n\tif (gl_FragCoord.x > numParticles) discard;\n\treadInput(vUv0.x);\n\tvisMode = inShow? 1.0 : -1.0;\n\tvec4 rndFactor = hash41(gl_FragCoord.x + seed);\n\tfloat particleRate = rate + rateDiv * rndFactor.x;\n\toutLife = inLife + delta;\n\tfloat nlife = clamp(outLife / lifetime, 0.0, 1.0);\n\tvec3 localVelocityDiv;\n\tvec3 velocityDiv;\n\tvec3 paramDiv;\n\tvec3 localVelocity = tex1Dlod_lerp(TEXTURE_PASS(internalTex0), vec2(nlife, 0), localVelocityDiv);\n\tvec3 velocity =\t tex1Dlod_lerp(TEXTURE_PASS(internalTex1), vec2(nlife, 0), velocityDiv);\n\tvec3 params =\t\ttex1Dlod_lerp(TEXTURE_PASS(internalTex2), vec2(nlife, 0), paramDiv);\n\tfloat rotSpeed = params.x;\n\tfloat rotSpeedDiv = paramDiv.y;\n\tvec3 radialParams = tex1Dlod_lerp(TEXTURE_PASS(internalTex3), vec2(nlife, 0), paramDiv);\n\tfloat radialSpeed = radialParams.x;\n\tfloat radialSpeedDiv = radialParams.y;\n\tbool respawn = inLife <= 0.0 || outLife >= lifetime;\n\tinPos = respawn ? calcSpawnPosition(rndFactor.xyz, rndFactor.x) : inPos;\n\tinAngle = respawn ? mix(startAngle, startAngle2, rndFactor.x) : inAngle;\n#ifndef LOCAL_SPACE\n\tvec3 radialVel = inPos - emitterPos;\n#else\n\tvec3 radialVel = inPos;\n#endif\n\tradialVel = (dot(radialVel, radialVel) > 1.0E-8) ? radialSpeed * normalize(radialVel) : vec3(0.0);\n\tradialVel += (radialSpeedDiv * vec3(2.0) - vec3(1.0)) * radialSpeedDivMult * rndFactor.xyz;\n\tlocalVelocity +=\t(localVelocityDiv * vec3(2.0) - vec3(1.0)) * localVelocityDivMult * rndFactor.xyz;\n\tvelocity +=\t\t (velocityDiv * vec3(2.0) - vec3(1.0)) * velocityDivMult * rndFactor.xyz;\n\trotSpeed +=\t\t (rotSpeedDiv * 2.0 - 1.0) * rotSpeedDivMult * rndFactor.y;\n\taddInitialVelocity(localVelocity, rndFactor.xyz);\n#ifndef LOCAL_SPACE\n\toutVel = emitterMatrix * localVelocity + (radialVel + velocity) * emitterScale;\n#else\n\toutVel = (localVelocity + radialVel) / emitterScale + emitterMatrixInv * velocity;\n#endif\n\toutPos = inPos + outVel * delta;\n\toutAngle = inAngle + rotSpeed * delta;\n`;\n\nexport { particleUpdaterStartPS as default };\n", "var particle_billboardVS = `\n\tquadXY = rotate(quadXY, inAngle, rotMatrix);\n\tvec3 localPos = billboard(particlePos, quadXY);\n`;\n\nexport { particle_billboardVS as default };\n", "var particle_blendAddPS = `\n\tdBlendModeFogFactor = 0.0;\n\trgb *= saturate(gammaCorrectInput(max(a, 0.0)));\n\tif ((rgb.r + rgb.g + rgb.b) < 0.000001) discard;\n`;\n\nexport { particle_blendAddPS as default };\n", "var particle_blendMultiplyPS = `\n\trgb = mix(vec3(1.0), rgb, vec3(a));\n\tif (rgb.r + rgb.g + rgb.b > 2.99) discard;\n`;\n\nexport { particle_blendMultiplyPS as default };\n", "var particle_blendNormalPS = `\n\tif (a < 0.01) discard;\n`;\n\nexport { particle_blendNormalPS as default };\n", "var particle_cpuVS = `\nattribute vec4 particle_vertexData;\nattribute vec4 particle_vertexData2;\nattribute vec4 particle_vertexData3;\nattribute float particle_vertexData4;\n#ifndef USE_MESH\nattribute vec2 particle_vertexData5;\n#else\nattribute vec4 particle_vertexData5;\n#endif\nuniform mat4 matrix_viewProjection;\nuniform mat4 matrix_model;\n#ifndef VIEWMATRIX\n#define VIEWMATRIX\nuniform mat4 matrix_view;\n#endif\nuniform mat3 matrix_normal;\nuniform mat4 matrix_viewInverse;\nuniform float numParticles;\nuniform float lifetime;\nuniform float stretch;\nuniform float seed;\nuniform vec3 wrapBounds;\nuniform vec3 emitterScale;\nuniform vec3 faceTangent;\nuniform vec3 faceBinorm;\n#ifdef PARTICLE_GPU\n\tuniform highp sampler2D internalTex0;\n\tuniform highp sampler2D internalTex1;\n\tuniform highp sampler2D internalTex2;\n#endif\nuniform vec3 emitterPos;\nvarying vec4 texCoordsAlphaLife;\nvec2 rotate(vec2 quadXY, float pRotation, out mat2 rotMatrix)\n{\n\tfloat c = cos(pRotation);\n\tfloat s = sin(pRotation);\n\tmat2 m = mat2(c, -s, s, c);\n\trotMatrix = m;\n\treturn m * quadXY;\n}\nvec3 billboard(vec3 InstanceCoords, vec2 quadXY)\n{\n\tvec3 pos = -matrix_viewInverse[0].xyz * quadXY.x + -matrix_viewInverse[1].xyz * quadXY.y;\n\treturn pos;\n}\nvec3 customFace(vec3 InstanceCoords, vec2 quadXY)\n{\n\tvec3 pos = faceTangent * quadXY.x + faceBinorm * quadXY.y;\n\treturn pos;\n}\nvoid main(void)\n{\n\tvec3 particlePos = particle_vertexData.xyz;\n\tvec3 inPos = particlePos;\n\tvec3 vertPos = particle_vertexData3.xyz;\n\tvec3 inVel = vec3(particle_vertexData2.w, particle_vertexData3.w, particle_vertexData5.x);\n\tfloat id = floor(particle_vertexData4);\n\tfloat rndFactor = fract(sin(id + 1.0 + seed));\n\tvec3 rndFactor3 = vec3(rndFactor, fract(rndFactor*10.0), fract(rndFactor*100.0));\n#ifdef LOCAL_SPACE\n\tinVel = mat3(matrix_model) * inVel;\n#endif\n\tvec2 velocityV = normalize((mat3(matrix_view) * inVel).xy);\n\tvec2 quadXY = vertPos.xy;\n#ifdef USE_MESH\n\ttexCoordsAlphaLife = vec4(particle_vertexData5.zw, particle_vertexData2.z, particle_vertexData.w);\n#else\n\ttexCoordsAlphaLife = vec4(quadXY * -0.5 + 0.5, particle_vertexData2.z, particle_vertexData.w);\n#endif\n\tmat2 rotMatrix;\n\tfloat inAngle = particle_vertexData2.x;\n\tvec3 particlePosMoved = vec3(0.0);\n\tvec3 meshLocalPos = particle_vertexData3.xyz;\n`;\n\nexport { particle_cpuVS as default };\n", "var particle_cpu_endVS = `\n\tlocalPos *= particle_vertexData2.y * emitterScale;\n\tlocalPos += particlePos;\n\tgl_Position = matrix_viewProjection * vec4(localPos, 1.0);\n`;\n\nexport { particle_cpu_endVS as default };\n", "var particle_customFaceVS = `\n\tquadXY = rotate(quadXY, inAngle, rotMatrix);\n\tvec3 localPos = customFace(particlePos, quadXY);\n`;\n\nexport { particle_customFaceVS as default };\n", "var particle_endPS = `\n\trgb = addFog(rgb);\n\trgb = toneMap(rgb);\n\trgb = gammaCorrectOutput(rgb);\n\tgl_FragColor = vec4(rgb, a);\n}\n`;\n\nexport { particle_endPS as default };\n", "var particle_endVS = `\n\tlocalPos *= scale * emitterScale;\n\tlocalPos += particlePos;\n\t#ifdef SCREEN_SPACE\n\tgl_Position = vec4(localPos.x, localPos.y, 0.0, 1.0);\n\t#else\n\tgl_Position = matrix_viewProjection * vec4(localPos.xyz, 1.0);\n\t#endif\n`;\n\nexport { particle_endVS as default };\n", "var particle_halflambertPS = `\n\tvec3 negNormal = normal*0.5+0.5;\n\tvec3 posNormal = -normal*0.5+0.5;\n\tnegNormal *= negNormal;\n\tposNormal *= posNormal;\n`;\n\nexport { particle_halflambertPS as default };\n", "var particle_initVS = `\nattribute vec4 particle_vertexData;\n#ifdef USE_MESH\nattribute vec2 particle_uv;\n#endif\nuniform mat4 matrix_viewProjection;\nuniform mat4 matrix_model;\nuniform mat3 matrix_normal;\nuniform mat4 matrix_viewInverse;\n#ifndef VIEWMATRIX\n#define VIEWMATRIX\nuniform mat4 matrix_view;\n#endif\nuniform float numParticles;\nuniform float numParticlesPot;\nuniform float graphSampleSize;\nuniform float graphNumSamples;\nuniform float stretch;\nuniform vec3 wrapBounds;\nuniform vec3 emitterScale;\nuniform vec3 emitterPos;\nuniform vec3 faceTangent;\nuniform vec3 faceBinorm;\nuniform float rate;\nuniform float rateDiv;\nuniform float lifetime;\nuniform float deltaRandomnessStatic;\nuniform float scaleDivMult;\nuniform float alphaDivMult;\nuniform float seed;\nuniform float delta;\nuniform sampler2D particleTexOUT;\nuniform sampler2D particleTexIN;\n#ifdef PARTICLE_GPU\n\tuniform highp sampler2D internalTex0;\n\tuniform highp sampler2D internalTex1;\n\tuniform highp sampler2D internalTex2;\n#endif\n#ifndef CAMERAPLANES\n#define CAMERAPLANES\nuniform vec4 camera_params;\n#endif\nvarying vec4 texCoordsAlphaLife;\nvec3 inPos;\nvec3 inVel;\nfloat inAngle;\nbool inShow;\nfloat inLife;\n`;\n\nexport { particle_initVS as default };\n", "var particle_lambertPS = `\n\tvec3 negNormal = max(normal, vec3(0.0));\n\tvec3 posNormal = max(-normal, vec3(0.0));\n`;\n\nexport { particle_lambertPS as default };\n", "var particle_lightingPS = `\n\tvec3 light = negNormal.x*lightCube[0] + posNormal.x*lightCube[1] +\n\t\t\t\t\t\tnegNormal.y*lightCube[2] + posNormal.y*lightCube[3] +\n\t\t\t\t\t\tnegNormal.z*lightCube[4] + posNormal.z*lightCube[5];\n\trgb *= light;\n`;\n\nexport { particle_lightingPS as default };\n", "var particle_localShiftVS = `\n\tparticlePos = (matrix_model * vec4(particlePos, 1.0)).xyz;\n`;\n\nexport { particle_localShiftVS as default };\n", "var particle_meshVS = `\n\tvec3 localPos = meshLocalPos;\n\tlocalPos.xy = rotate(localPos.xy, inAngle, rotMatrix);\n\tlocalPos.yz = rotate(localPos.yz, inAngle, rotMatrix);\n\tbillboard(particlePos, quadXY);\n`;\n\nexport { particle_meshVS as default };\n", "var particle_normalVS = `\n\tNormal = normalize(localPos + matrix_viewInverse[2].xyz);\n`;\n\nexport { particle_normalVS as default };\n", "var particle_normalMapPS = `\n\tvec3 normalMap = normalize(texture2D(normalMap, vec2(texCoordsAlphaLife.x, 1.0 - texCoordsAlphaLife.y)).xyz * 2.0 - 1.0);\n\tvec3 normal = ParticleMat * normalMap;\n`;\n\nexport { particle_normalMapPS as default };\n", "var particle_pointAlongVS = `\n\tinAngle = atan(velocityV.x, velocityV.y);\n`;\n\nexport { particle_pointAlongVS as default };\n", "var particle_softPS = `\n\tfloat depth = getLinearScreenDepth();\n\tfloat particleDepth = vDepth;\n\tfloat depthDiff = saturate(abs(particleDepth - depth) * softening);\n\ta *= depthDiff;\n`;\n\nexport { particle_softPS as default };\n", "var particle_softVS = `\n\tvDepth = getLinearDepth(localPos);\n`;\n\nexport { particle_softVS as default };\n", "var particle_stretchVS = `\n\tvec3 moveDir = inVel * stretch;\n\tvec3 posPrev = particlePos - moveDir;\n\tposPrev += particlePosMoved;\n\tvec2 centerToVertexV = normalize((mat3(matrix_view) * localPos).xy);\n\tfloat interpolation = dot(-velocityV, centerToVertexV) * 0.5 + 0.5;\n\tparticlePos = mix(particlePos, posPrev, interpolation);\n`;\n\nexport { particle_stretchVS as default };\n", "var particle_TBNVS = `\n\tmat3 rot3 = mat3(rotMatrix[0][0], rotMatrix[0][1], 0.0, rotMatrix[1][0], rotMatrix[1][1], 0.0, 0.0, 0.0, 1.0);\n\tParticleMat = mat3(-matrix_viewInverse[0].xyz, -matrix_viewInverse[1].xyz, matrix_viewInverse[2].xyz) * rot3;\n`;\n\nexport { particle_TBNVS as default };\n", "var particle_wrapVS = `\n\tvec3 origParticlePos = particlePos;\n\tparticlePos -= matrix_model[3].xyz;\n\tparticlePos = mod(particlePos, wrapBounds) - wrapBounds * 0.5;\n\tparticlePos += matrix_model[3].xyz;\n\tparticlePosMoved = particlePos - origParticlePos;\n`;\n\nexport { particle_wrapVS as default };\n", "var reflDirPS = `\nvoid getReflDir(vec3 worldNormal, vec3 viewDir, float gloss, mat3 tbn) {\n\tdReflDirW = normalize(-reflect(viewDir, worldNormal));\n}\n`;\n\nexport { reflDirPS as default };\n", "var reflDirAnisoPS = `\nvoid getReflDir(vec3 worldNormal, vec3 viewDir, float gloss, mat3 tbn) {\n\tfloat roughness = sqrt(1.0 - min(gloss, 1.0));\n\tfloat anisotropy = material_anisotropy * roughness;\n\tvec3 anisotropicDirection = anisotropy >= 0.0 ? tbn[1] : tbn[0];\n\tvec3 anisotropicTangent = cross(anisotropicDirection, viewDir);\n\tvec3 anisotropicNormal = cross(anisotropicTangent, anisotropicDirection);\n\tvec3 bentNormal = normalize(mix(normalize(worldNormal), normalize(anisotropicNormal), anisotropy));\n\tdReflDirW = reflect(-viewDir, bentNormal);\n}\n`;\n\nexport { reflDirAnisoPS as default };\n", "var reflectionCCPS = `\n#ifdef LIT_CLEARCOAT\nvoid addReflectionCC(vec3 reflDir, float gloss) {\n\tccReflection += calcReflection(reflDir, gloss);\n}\n#endif\n`;\n\nexport { reflectionCCPS as default };\n", "var reflectionCubePS = `\nuniform samplerCube texture_cubeMap;\nuniform float material_reflectivity;\nvec3 calcReflection(vec3 reflDir, float gloss) {\n\tvec3 lookupVec = fixSeams(cubeMapProject(reflDir));\n\tlookupVec.x *= -1.0;\n\treturn $DECODE(textureCube(texture_cubeMap, lookupVec));\n}\nvoid addReflection(vec3 reflDir, float gloss) { \n\tdReflection += vec4(calcReflection(reflDir, gloss), material_reflectivity);\n}\n`;\n\nexport { reflectionCubePS as default };\n", "var reflectionEnvHQPS = `\n#ifndef ENV_ATLAS\n#define ENV_ATLAS\nuniform sampler2D texture_envAtlas;\n#endif\nuniform samplerCube texture_cubeMap;\nuniform float material_reflectivity;\nvec3 calcReflection(vec3 reflDir, float gloss) {\n\tvec3 dir = cubeMapProject(reflDir) * vec3(-1.0, 1.0, 1.0);\n\tvec2 uv = toSphericalUv(dir);\n\tfloat level = saturate(1.0 - gloss) * 5.0;\n\tfloat ilevel = floor(level);\n\tfloat flevel = level - ilevel;\n\tvec3 sharp = $DECODE_CUBEMAP(textureCube(texture_cubeMap, fixSeams(dir)));\n\tvec3 roughA = $DECODE(texture2D(texture_envAtlas, mapRoughnessUv(uv, ilevel)));\n\tvec3 roughB = $DECODE(texture2D(texture_envAtlas, mapRoughnessUv(uv, ilevel + 1.0)));\n\treturn processEnvironment(mix(sharp, mix(roughA, roughB, flevel), min(level, 1.0)));\n}\nvoid addReflection(vec3 reflDir, float gloss) { \n\tdReflection += vec4(calcReflection(reflDir, gloss), material_reflectivity);\n}\n`;\n\nexport { reflectionEnvHQPS as default };\n", "var reflectionEnvPS = `\n#ifndef ENV_ATLAS\n#define ENV_ATLAS\nuniform sampler2D texture_envAtlas;\n#endif\nuniform float material_reflectivity;\nfloat shinyMipLevel(vec2 uv) {\n\tvec2 dx = dFdx(uv);\n\tvec2 dy = dFdy(uv);\n\tvec2 uv2 = vec2(fract(uv.x + 0.5), uv.y);\n\tvec2 dx2 = dFdx(uv2);\n\tvec2 dy2 = dFdy(uv2);\n\tfloat maxd = min(max(dot(dx, dx), dot(dy, dy)), max(dot(dx2, dx2), dot(dy2, dy2)));\n\treturn clamp(0.5 * log2(maxd) - 1.0 + textureBias, 0.0, 5.0);\n}\nvec3 calcReflection(vec3 reflDir, float gloss) {\n\tvec3 dir = cubeMapProject(reflDir) * vec3(-1.0, 1.0, 1.0);\n\tvec2 uv = toSphericalUv(dir);\n\tfloat level = saturate(1.0 - gloss) * 5.0;\n\tfloat ilevel = floor(level);\n\tfloat level2 = shinyMipLevel(uv * atlasSize);\n\tfloat ilevel2 = floor(level2);\n\tvec2 uv0, uv1;\n\tfloat weight;\n\tif (ilevel == 0.0) {\n\t\tuv0 = mapShinyUv(uv, ilevel2);\n\t\tuv1 = mapShinyUv(uv, ilevel2 + 1.0);\n\t\tweight = level2 - ilevel2;\n\t} else {\n\t\tuv0 = uv1 = mapRoughnessUv(uv, ilevel);\n\t\tweight = 0.0;\n\t}\n\tvec3 linearA = $DECODE(texture2D(texture_envAtlas, uv0));\n\tvec3 linearB = $DECODE(texture2D(texture_envAtlas, uv1));\n\tvec3 linear0 = mix(linearA, linearB, weight);\n\tvec3 linear1 = $DECODE(texture2D(texture_envAtlas, mapRoughnessUv(uv, ilevel + 1.0)));\n\treturn processEnvironment(mix(linear0, linear1, level - ilevel));\n}\nvoid addReflection(vec3 reflDir, float gloss) { \n\tdReflection += vec4(calcReflection(reflDir, gloss), material_reflectivity);\n}\n`;\n\nexport { reflectionEnvPS as default };\n", "var reflectionSpherePS = `\n#ifndef VIEWMATRIX\n#define VIEWMATRIX\nuniform mat4 matrix_view;\n#endif\nuniform sampler2D texture_sphereMap;\nuniform float material_reflectivity;\nvec3 calcReflection(vec3 reflDir, float gloss) {\n\tvec3 reflDirV = (mat3(matrix_view) * reflDir).xyz;\n\tfloat m = 2.0 * sqrt( dot(reflDirV.xy, reflDirV.xy) + (reflDirV.z+1.0)*(reflDirV.z+1.0) );\n\tvec2 sphereMapUv = reflDirV.xy / m + 0.5;\n\treturn $DECODE(texture2D(texture_sphereMap, sphereMapUv));\n}\nvoid addReflection(vec3 reflDir, float gloss) { \n\tdReflection += vec4(calcReflection(reflDir, gloss), material_reflectivity);\n}\n`;\n\nexport { reflectionSpherePS as default };\n", "var reflectionSheenPS = `\nvoid addReflectionSheen(vec3 worldNormal, vec3 viewDir, float gloss) {\n\tfloat NoV = dot(worldNormal, viewDir);\n\tfloat alphaG = gloss * gloss;\n\tfloat a = gloss < 0.25 ? -339.2 * alphaG + 161.4 * gloss - 25.9 : -8.48 * alphaG + 14.3 * gloss - 9.95;\n\tfloat b = gloss < 0.25 ? 44.0 * alphaG - 23.7 * gloss + 3.26 : 1.97 * alphaG - 3.27 * gloss + 0.72;\n\tfloat DG = exp( a * NoV + b ) + ( gloss < 0.25 ? 0.0 : 0.1 * ( gloss - 0.25 ) );\n\tsReflection += calcReflection(worldNormal, 0.0) * saturate(DG);\n}\n`;\n\nexport { reflectionSheenPS as default };\n", "var refractionCubePS = `\nvec3 refract2(vec3 viewVec, vec3 normal, float IOR) {\n\tfloat vn = dot(viewVec, normal);\n\tfloat k = 1.0 - IOR * IOR * (1.0 - vn * vn);\n\tvec3 refrVec = IOR * viewVec - (IOR * vn + sqrt(k)) * normal;\n\treturn refrVec;\n}\nvoid addRefraction(\n\tvec3 worldNormal, \n\tvec3 viewDir, \n\tfloat thickness, \n\tfloat gloss, \n\tvec3 specularity, \n\tvec3 albedo, \n\tfloat transmission,\n\tfloat refractionIndex,\n\tfloat dispersion\n#if defined(LIT_IRIDESCENCE)\n\t, vec3 iridescenceFresnel,\n\tfloat iridescenceIntensity\n#endif \n) {\n\tvec4 tmpRefl = dReflection;\n\tvec3 reflectionDir = refract2(-viewDir, worldNormal, refractionIndex);\n\tdReflection = vec4(0);\n\taddReflection(reflectionDir, gloss);\n\tdDiffuseLight = mix(dDiffuseLight, dReflection.rgb * albedo, transmission);\n\tdReflection = tmpRefl;\n}\n`;\n\nexport { refractionCubePS as default };\n", "var refractionDynamicPS = `\nuniform float material_invAttenuationDistance;\nuniform vec3 material_attenuation;\nvec3 evalRefractionColor(vec3 refractionVector, float gloss, float refractionIndex) {\n\tvec4 pointOfRefraction = vec4(vPositionW + refractionVector, 1.0);\n\tvec4 projectionPoint = matrix_viewProjection * pointOfRefraction;\n\tvec2 uv = getGrabScreenPos(projectionPoint);\n\t#ifdef SUPPORTS_TEXLOD\n\t\tfloat iorToRoughness = (1.0 - gloss) * clamp((1.0 / refractionIndex) * 2.0 - 2.0, 0.0, 1.0);\n\t\tfloat refractionLod = log2(uScreenSize.x) * iorToRoughness;\n\t\tvec3 refraction = texture2DLodEXT(uSceneColorMap, uv, refractionLod).rgb;\n\t#else\n\t\tvec3 refraction = texture2D(uSceneColorMap, uv).rgb;\n\t#endif\n\treturn refraction;\n}\nvoid addRefraction(\n\tvec3 worldNormal, \n\tvec3 viewDir, \n\tfloat thickness, \n\tfloat gloss, \n\tvec3 specularity, \n\tvec3 albedo, \n\tfloat transmission,\n\tfloat refractionIndex,\n\tfloat dispersion\n#if defined(LIT_IRIDESCENCE)\n\t, vec3 iridescenceFresnel,\n\tfloat iridescenceIntensity\n#endif\n) {\n\tvec3 modelScale;\n\tmodelScale.x = length(vec3(matrix_model[0].xyz));\n\tmodelScale.y = length(vec3(matrix_model[1].xyz));\n\tmodelScale.z = length(vec3(matrix_model[2].xyz));\n\tvec3 scale = thickness * modelScale;\n\tvec3 refractionVector = normalize(refract(-viewDir, worldNormal, refractionIndex)) * scale;\n\tvec3 refraction = evalRefractionColor(refractionVector, gloss, refractionIndex);\n\t#ifdef DISPERSION\n\t\tfloat halfSpread = (1.0 / refractionIndex - 1.0) * 0.025 * dispersion;\n\t\tfloat refractionIndexR = refractionIndex - halfSpread;\n\t\trefractionVector = normalize(refract(-viewDir, worldNormal, refractionIndexR)) * scale;\n\t\trefraction.r = evalRefractionColor(refractionVector, gloss, refractionIndexR).r;\n\t\tfloat refractionIndexB = refractionIndex + halfSpread;\n\t\trefractionVector = normalize(refract(-viewDir, worldNormal, refractionIndexB)) * scale;\n\t\trefraction.b = evalRefractionColor(refractionVector, gloss, refractionIndexB).b;\n\t#endif\n\tvec3 transmittance;\n\tif (material_invAttenuationDistance != 0.0)\n\t{\n\t\tvec3 attenuation = -log(material_attenuation) * material_invAttenuationDistance;\n\t\ttransmittance = exp(-attenuation * length(refractionVector));\n\t}\n\telse\n\t{\n\t\ttransmittance = refraction;\n\t}\n\tvec3 fresnel = vec3(1.0) - \n\t\tgetFresnel(\n\t\t\tdot(viewDir, worldNormal), \n\t\t\tgloss, \n\t\t\tspecularity\n\t\t#if defined(LIT_IRIDESCENCE)\n\t\t\t, iridescenceFresnel,\n\t\t\tiridescenceIntensity\n\t\t#endif\n\t\t);\n\tdDiffuseLight = mix(dDiffuseLight, refraction * transmittance * fresnel, transmission);\n}\n`;\n\nexport { refractionDynamicPS as default };\n", "import decodePS from './decode.js';\nimport encodePS from './encode.js';\n\nvar reprojectPS = `\nvarying vec2 vUv0;\n#ifdef CUBEMAP_SOURCE\n\tuniform samplerCube sourceCube;\n#else\n\tuniform sampler2D sourceTex;\n#endif\n#ifdef USE_SAMPLES_TEX\n\tuniform sampler2D samplesTex;\n\tuniform vec2 samplesTexInverseSize;\n#endif\nuniform vec3 params;\nfloat targetFace() { return params.x; }\nfloat sourceCubeSeamScale() { return params.y; }\nfloat targetCubeSeamScale() { return params.z; }\nfloat PI = 3.141592653589793;\nfloat saturate(float x) {\n\treturn clamp(x, 0.0, 1.0);\n}\n${decodePS}\n${encodePS}\nvec3 modifySeams(vec3 dir, float scale) {\n\tvec3 adir = abs(dir);\n\tfloat M = max(max(adir.x, adir.y), adir.z);\n\treturn dir / M * vec3(\n\t\tadir.x == M ? 1.0 : scale,\n\t\tadir.y == M ? 1.0 : scale,\n\t\tadir.z == M ? 1.0 : scale\n\t);\n}\nvec2 toSpherical(vec3 dir) {\n\treturn vec2(dir.xz == vec2(0.0) ? 0.0 : atan(dir.x, dir.z), asin(dir.y));\n}\nvec3 fromSpherical(vec2 uv) {\n\treturn vec3(cos(uv.y) * sin(uv.x),\n\t\t\t\tsin(uv.y),\n\t\t\t\tcos(uv.y) * cos(uv.x));\n}\nvec3 getDirectionEquirect() {\n\treturn fromSpherical((vec2(vUv0.x, 1.0 - vUv0.y) * 2.0 - 1.0) * vec2(PI, PI * 0.5));\n}\nfloat signNotZero(float k){\n\treturn(k >= 0.0) ? 1.0 : -1.0;\n}\nvec2 signNotZero(vec2 v) {\n\treturn vec2(signNotZero(v.x), signNotZero(v.y));\n}\nvec3 octDecode(vec2 o) {\n\tvec3 v = vec3(o.x, 1.0 - abs(o.x) - abs(o.y), o.y);\n\tif (v.y < 0.0) {\n\t\tv.xz = (1.0 - abs(v.zx)) * signNotZero(v.xz);\n\t}\n\treturn normalize(v);\n}\nvec3 getDirectionOctahedral() {\n\treturn octDecode(vec2(vUv0.x, 1.0 - vUv0.y) * 2.0 - 1.0);\n}\nvec2 octEncode(in vec3 v) {\n\tfloat l1norm = abs(v.x) + abs(v.y) + abs(v.z);\n\tvec2 result = v.xz * (1.0 / l1norm);\n\tif (v.y < 0.0) {\n\t\tresult = (1.0 - abs(result.yx)) * signNotZero(result.xy);\n\t}\n\treturn result;\n}\n#ifdef CUBEMAP_SOURCE\n\tvec4 sampleCubemap(vec3 dir) {\n\t\treturn textureCube(sourceCube, modifySeams(dir, 1.0 - sourceCubeSeamScale()));\n\t}\n\tvec4 sampleCubemap(vec2 sph) {\n\treturn sampleCubemap(fromSpherical(sph));\n}\n\tvec4 sampleCubemap(vec3 dir, float mipLevel) {\n\t\treturn textureCubeLodEXT(sourceCube, modifySeams(dir, 1.0 - exp2(mipLevel) * sourceCubeSeamScale()), mipLevel);\n\t}\n\tvec4 sampleCubemap(vec2 sph, float mipLevel) {\n\t\treturn sampleCubemap(fromSpherical(sph), mipLevel);\n\t}\n#else\n\tvec4 sampleEquirect(vec2 sph) {\n\t\tvec2 uv = sph / vec2(PI * 2.0, PI) + 0.5;\n\t\treturn texture2D(sourceTex, vec2(uv.x, 1.0 - uv.y));\n\t}\n\tvec4 sampleEquirect(vec3 dir) {\n\t\treturn sampleEquirect(toSpherical(dir));\n\t}\n\tvec4 sampleEquirect(vec2 sph, float mipLevel) {\n\t\tvec2 uv = sph / vec2(PI * 2.0, PI) + 0.5;\n\t\treturn texture2DLodEXT(sourceTex, vec2(uv.x, 1.0 - uv.y), mipLevel);\n\t}\n\tvec4 sampleEquirect(vec3 dir, float mipLevel) {\n\t\treturn sampleEquirect(toSpherical(dir), mipLevel);\n\t}\n\tvec4 sampleOctahedral(vec3 dir) {\n\t\tvec2 uv = octEncode(dir) * 0.5 + 0.5;\n\t\treturn texture2D(sourceTex, vec2(uv.x, 1.0 - uv.y));\n\t}\n\tvec4 sampleOctahedral(vec2 sph) {\n\t\treturn sampleOctahedral(fromSpherical(sph));\n\t}\n\tvec4 sampleOctahedral(vec3 dir, float mipLevel) {\n\t\tvec2 uv = octEncode(dir) * 0.5 + 0.5;\n\t\treturn texture2DLodEXT(sourceTex, vec2(uv.x, 1.0 - uv.y), mipLevel);\n\t}\n\tvec4 sampleOctahedral(vec2 sph, float mipLevel) {\n\t\treturn sampleOctahedral(fromSpherical(sph), mipLevel);\n\t}\n#endif\nvec3 getDirectionCubemap() {\n\tvec2 st = vUv0 * 2.0 - 1.0;\n\tfloat face = targetFace();\n\tvec3 vec;\n\tif (face == 0.0) {\n\t\tvec = vec3(1, -st.y, -st.x);\n\t} else if (face == 1.0) {\n\t\tvec = vec3(-1, -st.y, st.x);\n\t} else if (face == 2.0) {\n\t\tvec = vec3(st.x, 1, st.y);\n\t} else if (face == 3.0) {\n\t\tvec = vec3(st.x, -1, -st.y);\n\t} else if (face == 4.0) {\n\t\tvec = vec3(st.x, -st.y, 1);\n\t} else {\n\t\tvec = vec3(-st.x, -st.y, -1);\n\t}\n\treturn normalize(modifySeams(vec, 1.0 / (1.0 - targetCubeSeamScale())));\n}\nmat3 matrixFromVector(vec3 n) {\n\tfloat a = 1.0 / (1.0 + n.z);\n\tfloat b = -n.x * n.y * a;\n\tvec3 b1 = vec3(1.0 - n.x * n.x * a, b, -n.x);\n\tvec3 b2 = vec3(b, 1.0 - n.y * n.y * a, -n.y);\n\treturn mat3(b1, b2, n);\n}\nmat3 matrixFromVectorSlow(vec3 n) {\n\tvec3 up = (1.0 - abs(n.y) <= 0.0000001) ? vec3(0.0, 0.0, n.y > 0.0 ? 1.0 : -1.0) : vec3(0.0, 1.0, 0.0);\n\tvec3 x = normalize(cross(up, n));\n\tvec3 y = cross(n, x);\n\treturn mat3(x, y, n);\n}\nvec4 reproject() {\n\tif (NUM_SAMPLES <= 1) {\n\t\treturn ENCODE_FUNC(DECODE_FUNC(SOURCE_FUNC(TARGET_FUNC())));\n\t} else {\n\t\tvec3 t = TARGET_FUNC();\n\t\tvec3 tu = dFdx(t);\n\t\tvec3 tv = dFdy(t);\n\t\tvec3 result = vec3(0.0);\n\t\tfor (float u = 0.0; u < NUM_SAMPLES_SQRT; ++u) {\n\t\t\tfor (float v = 0.0; v < NUM_SAMPLES_SQRT; ++v) {\n\t\t\t\tresult += DECODE_FUNC(SOURCE_FUNC(normalize(t +\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\ttu * (u / NUM_SAMPLES_SQRT - 0.5) +\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\ttv * (v / NUM_SAMPLES_SQRT - 0.5))));\n\t\t\t}\n\t\t}\n\t\treturn ENCODE_FUNC(result / (NUM_SAMPLES_SQRT * NUM_SAMPLES_SQRT));\n\t}\n}\nvec4 unpackFloat = vec4(1.0, 1.0 / 255.0, 1.0 / 65025.0, 1.0 / 16581375.0);\n#ifdef USE_SAMPLES_TEX\n\tvoid unpackSample(int i, out vec3 L, out float mipLevel) {\n\t\tfloat u = (float(i * 4) + 0.5) * samplesTexInverseSize.x;\n\t\tfloat v = (floor(u) + 0.5) * samplesTexInverseSize.y;\n\t\tvec4 raw;\n\t\traw.x = dot(texture2D(samplesTex, vec2(u, v)), unpackFloat); u += samplesTexInverseSize.x;\n\t\traw.y = dot(texture2D(samplesTex, vec2(u, v)), unpackFloat); u += samplesTexInverseSize.x;\n\t\traw.z = dot(texture2D(samplesTex, vec2(u, v)), unpackFloat); u += samplesTexInverseSize.x;\n\t\traw.w = dot(texture2D(samplesTex, vec2(u, v)), unpackFloat);\n\t\tL.xyz = raw.xyz * 2.0 - 1.0;\n\t\tmipLevel = raw.w * 8.0;\n\t}\n\tvec4 prefilterSamples() {\n\t\tmat3 vecSpace = matrixFromVectorSlow(TARGET_FUNC());\n\t\tvec3 L;\n\t\tfloat mipLevel;\n\t\tvec3 result = vec3(0.0);\n\t\tfloat totalWeight = 0.0;\n\t\tfor (int i = 0; i < NUM_SAMPLES; ++i) {\n\t\t\tunpackSample(i, L, mipLevel);\n\t\t\tresult += DECODE_FUNC(SOURCE_FUNC(vecSpace * L, mipLevel)) * L.z;\n\t\t\ttotalWeight += L.z;\n\t\t}\n\t\treturn ENCODE_FUNC(result / totalWeight);\n\t}\n\tvec4 prefilterSamplesUnweighted() {\n\t\tmat3 vecSpace = matrixFromVectorSlow(TARGET_FUNC());\n\t\tvec3 L;\n\t\tfloat mipLevel;\n\t\tvec3 result = vec3(0.0);\n\t\tfloat totalWeight = 0.0;\n\t\tfor (int i = 0; i < NUM_SAMPLES; ++i) {\n\t\t\tunpackSample(i, L, mipLevel);\n\t\t\tresult += DECODE_FUNC(SOURCE_FUNC(vecSpace * L, mipLevel));\n\t\t}\n\t\treturn ENCODE_FUNC(result / float(NUM_SAMPLES));\n\t}\n#endif\nvoid main(void) {\n\tgl_FragColor = PROCESS_FUNC();\n}\n`;\n\nexport { reprojectPS as default };\n", "var sampleCatmullRomPS = `\nvec4 SampleTextureCatmullRom(TEXTURE_ACCEPT(tex), vec2 uv, vec2 texSize) {\n\tvec2 samplePos = uv * texSize;\n\tvec2 texPos1 = floor(samplePos - 0.5) + 0.5;\n\tvec2 f = samplePos - texPos1;\n\tvec2 w0 = f * (-0.5 + f * (1.0 - 0.5 * f));\n\tvec2 w1 = 1.0 + f * f * (-2.5 + 1.5 * f);\n\tvec2 w2 = f * (0.5 + f * (2.0 - 1.5 * f));\n\tvec2 w3 = f * f * (-0.5 + 0.5 * f);\n\tvec2 w12 = w1 + w2;\n\tvec2 offset12 = w2 / (w1 + w2);\n\tvec2 texPos0 = (texPos1 - 1.0) / texSize;\n\tvec2 texPos3 = (texPos1 + 2.0) / texSize;\n\tvec2 texPos12 = (texPos1 + offset12) / texSize;\n\tvec4 result = vec4(0.0);\n\tresult += texture2DLodEXT(tex, vec2(texPos0.x, texPos0.y), 0.0) * w0.x * w0.y;\n\tresult += texture2DLodEXT(tex, vec2(texPos12.x, texPos0.y), 0.0) * w12.x * w0.y;\n\tresult += texture2DLodEXT(tex, vec2(texPos3.x, texPos0.y), 0.0) * w3.x * w0.y;\n\tresult += texture2DLodEXT(tex, vec2(texPos0.x, texPos12.y), 0.0) * w0.x * w12.y;\n\tresult += texture2DLodEXT(tex, vec2(texPos12.x, texPos12.y), 0.0) * w12.x * w12.y;\n\tresult += texture2DLodEXT(tex, vec2(texPos3.x, texPos12.y), 0.0) * w3.x * w12.y;\n\tresult += texture2DLodEXT(tex, vec2(texPos0.x, texPos3.y), 0.0) * w0.x * w3.y;\n\tresult += texture2DLodEXT(tex, vec2(texPos12.x, texPos3.y), 0.0) * w12.x * w3.y;\n\tresult += texture2DLodEXT(tex, vec2(texPos3.x, texPos3.y), 0.0) * w3.x * w3.y;\n\treturn result;\n}\n`;\n\nexport { sampleCatmullRomPS as default };\n", "var screenDepthPS = `\nuniform highp sampler2D uSceneDepthMap;\n#ifndef SCREENSIZE\n#define SCREENSIZE\nuniform vec4 uScreenSize;\n#endif\n#ifndef VIEWMATRIX\n#define VIEWMATRIX\nuniform mat4 matrix_view;\n#endif\n#ifndef LINEARIZE_DEPTH\n#ifndef CAMERAPLANES\n#define CAMERAPLANES\nuniform vec4 camera_params;\n#endif\n#define LINEARIZE_DEPTH\n#ifdef GL2\nfloat linearizeDepth(float z) {\n\tif (camera_params.w == 0.0)\n\t\treturn (camera_params.z * camera_params.y) / (camera_params.y + z * (camera_params.z - camera_params.y));\n\telse\n\t\treturn camera_params.z + z * (camera_params.y - camera_params.z);\n}\n#else\n#ifndef UNPACKFLOAT\n#define UNPACKFLOAT\nfloat unpackFloat(vec4 rgbaDepth) {\n\tconst vec4 bitShift = vec4(1.0 / (256.0 * 256.0 * 256.0), 1.0 / (256.0 * 256.0), 1.0 / 256.0, 1.0);\n\treturn dot(rgbaDepth, bitShift);\n}\n#endif\n#endif\n#endif\nfloat getLinearScreenDepth(vec2 uv) {\n\t#ifdef GL2\n\t\treturn linearizeDepth(texture2D(uSceneDepthMap, uv).r);\n\t#else\n\t\treturn unpackFloat(texture2D(uSceneDepthMap, uv)) * camera_params.y;\n\t#endif\n}\n#ifndef VERTEXSHADER\nfloat getLinearScreenDepth() {\n\tvec2 uv = gl_FragCoord.xy * uScreenSize.zw;\n\treturn getLinearScreenDepth(uv);\n}\n#endif\nfloat getLinearDepth(vec3 pos) {\n\treturn -(matrix_view * vec4(pos, 1.0)).z;\n}\n`;\n\nexport { screenDepthPS as default };\n", "var shadowCascadesPS = `\nconst float maxCascades = 4.0;\nmat4 cascadeShadowMat;\nvoid getShadowCascadeMatrix(mat4 shadowMatrixPalette[4], float shadowCascadeDistances[4], float shadowCascadeCount) {\n\tfloat depth = 1.0 / gl_FragCoord.w;\n\tfloat cascadeIndex = 0.0;\n\tfor (float i = 0.0; i < maxCascades; i++) {\n\t\tif (depth < shadowCascadeDistances[int(i)]) {\n\t\t\tcascadeIndex = i;\n\t\t\tbreak;\n\t\t}\n\t}\n\tcascadeIndex = min(cascadeIndex, shadowCascadeCount - 1.0);\n\t#ifdef GL2\n\t\tcascadeShadowMat = shadowMatrixPalette[int(cascadeIndex)];\n\t#else\n\t\tif (cascadeIndex == 0.0) {\n\t\t\tcascadeShadowMat = shadowMatrixPalette[0];\n\t\t}\n\t\telse if (cascadeIndex == 1.0) {\n\t\t\tcascadeShadowMat = shadowMatrixPalette[1];\n\t\t}\n\t\telse if (cascadeIndex == 2.0) {\n\t\t\tcascadeShadowMat = shadowMatrixPalette[2];\n\t\t}\n\t\telse {\n\t\t\tcascadeShadowMat = shadowMatrixPalette[3];\n\t\t}\n\t#endif\n}\nvoid fadeShadow(float shadowCascadeDistances[4]) {\t\t\t\t \n\tfloat depth = 1.0 / gl_FragCoord.w;\n\tif (depth > shadowCascadeDistances[int(maxCascades - 1.0)]) {\n\t\tdShadowCoord.z = -9999999.0;\n\t}\n}\n`;\n\nexport { shadowCascadesPS as default };\n", "var shadowEVSMPS = `\nfloat VSM$(TEXTURE_ACCEPT(tex), vec2 texCoords, float resolution, float Z, float vsmBias, float exponent) {\n\tvec3 moments = texture2D(tex, texCoords).xyz;\n\treturn calculateEVSM(moments, Z, vsmBias, exponent);\n}\nfloat getShadowVSM$(TEXTURE_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams, float exponent, vec3 lightDir) {\n\treturn VSM$(TEXTURE_PASS(shadowMap), shadowCoord.xy, shadowParams.x, shadowCoord.z, shadowParams.y, exponent);\n}\nfloat getShadowSpotVSM$(TEXTURE_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams, float exponent, vec3 lightDir) {\n\treturn VSM$(TEXTURE_PASS(shadowMap), shadowCoord.xy, shadowParams.x, length(lightDir) * shadowParams.w + shadowParams.z, shadowParams.y, exponent);\n}\n`;\n\nexport { shadowEVSMPS as default };\n", "var shadowEVSMnPS = `\nfloat VSM$(TEXTURE_ACCEPT(tex), vec2 texCoords, float resolution, float Z, float vsmBias, float exponent) {\n\tfloat pixelSize = 1.0 / resolution;\n\ttexCoords -= vec2(pixelSize);\n\tvec3 s00 = texture2D(tex, texCoords).xyz;\n\tvec3 s10 = texture2D(tex, texCoords + vec2(pixelSize, 0)).xyz;\n\tvec3 s01 = texture2D(tex, texCoords + vec2(0, pixelSize)).xyz;\n\tvec3 s11 = texture2D(tex, texCoords + vec2(pixelSize)).xyz;\n\tvec2 fr = fract(texCoords * resolution);\n\tvec3 h0 = mix(s00, s10, fr.x);\n\tvec3 h1 = mix(s01, s11, fr.x);\n\tvec3 moments = mix(h0, h1, fr.y);\n\treturn calculateEVSM(moments, Z, vsmBias, exponent);\n}\nfloat getShadowVSM$(TEXTURE_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams, float exponent, vec3 lightDir) {\n\treturn VSM$(TEXTURE_PASS(shadowMap), shadowCoord.xy, shadowParams.x, shadowCoord.z, shadowParams.y, exponent);\n}\nfloat getShadowSpotVSM$(TEXTURE_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams, float exponent, vec3 lightDir) {\n\treturn VSM$(TEXTURE_PASS(shadowMap), shadowCoord.xy, shadowParams.x, length(lightDir) * shadowParams.w + shadowParams.z, shadowParams.y, exponent);\n}\n`;\n\nexport { shadowEVSMnPS as default };\n", "var shadowPCSSPS = `\n#define PCSS_SAMPLE_COUNT 16\nuniform float pcssDiskSamples[PCSS_SAMPLE_COUNT];\nuniform float pcssSphereSamples[PCSS_SAMPLE_COUNT];\nvec2 vogelDisk(int sampleIndex, float count, float phi, float r) {\n\tconst float GoldenAngle = 2.4;\n\tfloat theta = float(sampleIndex) * GoldenAngle + phi;\n\tfloat sine = sin(theta);\n\tfloat cosine = cos(theta);\n\treturn vec2(r * cosine, r * sine);\n}\nvec3 vogelSphere(int sampleIndex, float count, float phi, float r) {\n\tconst float GoldenAngle = 2.4;\n\tfloat theta = float(sampleIndex) * GoldenAngle + phi;\n\tfloat weight = float(sampleIndex) / count;\n\treturn vec3(cos(theta) * r, weight, sin(theta) * r);\n}\nfloat noise(vec2 screenPos) {\n\tconst float PHI = 1.61803398874989484820459;\n\treturn fract(sin(dot(screenPos * PHI, screenPos)) * screenPos.x);\n}\n#ifndef UNPACKFLOAT\n#define UNPACKFLOAT\nfloat unpackFloat(vec4 rgbaDepth) {\n\tconst vec4 bitShift = vec4(1.0 / (256.0 * 256.0 * 256.0), 1.0 / (256.0 * 256.0), 1.0 / 256.0, 1.0);\n\treturn dot(rgbaDepth, bitShift);\n}\n#endif\nfloat viewSpaceDepth(float depth, mat4 invProjection) {\n\tfloat z = depth * 2.0 - 1.0;\n\tvec4 clipSpace = vec4(0.0, 0.0, z, 1.0);\n\tvec4 viewSpace = invProjection * clipSpace;\n\treturn viewSpace.z;\n}\nfloat PCSSBlockerDistance(TEXTURE_ACCEPT(shadowMap), vec2 sampleCoords[PCSS_SAMPLE_COUNT], vec2 shadowCoords, vec2 searchSize, float z) {\n\tfloat blockers = 0.0;\n\tfloat averageBlocker = 0.0;\n\tfor (int i = 0; i < PCSS_SAMPLE_COUNT; i++) {\n\t\tvec2 offset = sampleCoords[i] * searchSize;\n\t\tvec2 sampleUV = shadowCoords + offset;\n\t#ifdef GL2\n\t\tfloat blocker = textureLod(shadowMap, sampleUV, 0.0).r;\n\t#else\n\t\tfloat blocker = unpackFloat(texture2D(shadowMap, sampleUV));\n\t#endif\t\t\n\t\tfloat isBlocking = step(blocker, z);\n\t\tblockers += isBlocking;\n\t\taverageBlocker += blocker * isBlocking;\n\t}\n\tif (blockers > 0.0)\n\t\treturn averageBlocker /= blockers;\n\treturn -1.0;\n}\nfloat PCSS(TEXTURE_ACCEPT(shadowMap), vec3 shadowCoords, vec4 cameraParams, vec2 shadowSearchArea) {\n\tfloat receiverDepth = shadowCoords.z;\n#ifndef GL2\n\treceiverDepth *= 1.0 / (cameraParams.y - cameraParams.z);\n#endif\n\tvec2 samplePoints[PCSS_SAMPLE_COUNT];\n\tfloat noise = noise( gl_FragCoord.xy ) * 2.0 * PI;\n\tfor (int i = 0; i < PCSS_SAMPLE_COUNT; i++) {\n\t\tfloat pcssPresample = pcssDiskSamples[i];\n\t\tsamplePoints[i] = vogelDisk(i, float(PCSS_SAMPLE_COUNT), noise, pcssPresample);\n\t}\n\tfloat averageBlocker = PCSSBlockerDistance(TEXTURE_PASS(shadowMap), samplePoints, shadowCoords.xy, shadowSearchArea, receiverDepth);\n\tif (averageBlocker == -1.0) {\n\t\treturn 1.0;\n\t} else {\n\t\tvec2 filterRadius = ((receiverDepth - averageBlocker) / averageBlocker) * shadowSearchArea * cameraParams.x;\n\t\tfloat shadow = 0.0;\n\t\tfor (int i = 0; i < PCSS_SAMPLE_COUNT; i ++)\n\t\t{\n\t\t\tvec2 sampleUV = samplePoints[i] * filterRadius;\n\t\t\tsampleUV = shadowCoords.xy + sampleUV;\n\t\t#ifdef GL2\n\t\t\tfloat depth = textureLod(shadowMap, sampleUV, 0.0).r;\n\t\t#else\n\t\t\tfloat depth = unpackFloat(texture2D(shadowMap, sampleUV));\n\t\t#endif\n\t\t\tshadow += step(receiverDepth, depth);\n\t\t}\n\t\treturn shadow / float(PCSS_SAMPLE_COUNT);\n\t} \n}\nfloat PCSSCubeBlockerDistance(samplerCube shadowMap, vec3 lightDirNorm, vec3 samplePoints[PCSS_SAMPLE_COUNT], float z, float shadowSearchArea) {\n\tfloat blockers = 0.0;\n\tfloat averageBlocker = 0.0;\n\tfor (int i = 0; i < PCSS_SAMPLE_COUNT; i++) {\n\t\tvec3 sampleDir = lightDirNorm + samplePoints[i] * shadowSearchArea;\n\t\tsampleDir = normalize(sampleDir);\n\t#ifdef GL2\n\t\tfloat blocker = textureCubeLodEXT(shadowMap, sampleDir, 0.0).r;\n\t#else\n\t\tfloat blocker = unpackFloat(textureCube(shadowMap, sampleDir));\n\t#endif\n\t\tfloat isBlocking = step(blocker, z);\n\t\tblockers += isBlocking;\n\t\taverageBlocker += blocker * isBlocking;\n\t}\n\tif (blockers > 0.0)\n\t\treturn averageBlocker /= float(blockers);\n\treturn -1.0;\n}\nfloat PCSSCube(samplerCube shadowMap, vec4 shadowParams, vec3 shadowCoords, vec4 cameraParams, float shadowSearchArea, vec3 lightDir) {\n\t\n\tvec3 samplePoints[PCSS_SAMPLE_COUNT];\n\tfloat noise = noise( gl_FragCoord.xy ) * 2.0 * PI;\n\tfor (int i = 0; i < PCSS_SAMPLE_COUNT; i++) {\n\t\tfloat r = pcssSphereSamples[i];\n\t\tsamplePoints[i] = vogelSphere(i, float(PCSS_SAMPLE_COUNT), noise, r);\n\t}\n\tfloat receiverDepth = length(lightDir) * shadowParams.w + shadowParams.z;\n\tvec3 lightDirNorm = normalize(lightDir);\n\t\n\tfloat averageBlocker = PCSSCubeBlockerDistance(shadowMap, lightDirNorm, samplePoints, receiverDepth, shadowSearchArea);\n\tif (averageBlocker == -1.0) {\n\t\treturn 1.0;\n\t} else {\n\t\tfloat filterRadius = ((receiverDepth - averageBlocker) / averageBlocker) * shadowSearchArea;\n\t\tfloat shadow = 0.0;\n\t\tfor (int i = 0; i < PCSS_SAMPLE_COUNT; i++)\n\t\t{\n\t\t\tvec3 offset = samplePoints[i] * filterRadius;\n\t\t\tvec3 sampleDir = lightDirNorm + offset;\n\t\t\tsampleDir = normalize(sampleDir);\n\t\t\t#ifdef GL2\n\t\t\t\tfloat depth = textureCubeLodEXT(shadowMap, sampleDir, 0.0).r;\n\t\t\t#else\n\t\t\t\tfloat depth = unpackFloat(textureCube(shadowMap, sampleDir));\n\t\t\t#endif\n\t\t\tshadow += step(receiverDepth, depth);\n\t\t}\n\t\treturn shadow / float(PCSS_SAMPLE_COUNT);\n\t}\n}\nfloat getShadowPointPCSS(samplerCube shadowMap, vec3 shadowCoord, vec4 shadowParams, vec4 cameraParams, vec2 shadowSearchArea, vec3 lightDir) {\n\treturn PCSSCube(shadowMap, shadowParams, shadowCoord, cameraParams, shadowSearchArea.x, lightDir);\n}\nfloat getShadowSpotPCSS(TEXTURE_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams, vec4 cameraParams, vec2 shadowSearchArea, vec3 lightDir) {\n\treturn PCSS(TEXTURE_PASS(shadowMap), shadowCoord, cameraParams, shadowSearchArea);\n}\nfloat getShadowPCSS(TEXTURE_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams, vec4 cameraParams, vec2 shadowSearchArea, vec3 lightDir) {\n\treturn PCSS(TEXTURE_PASS(shadowMap), shadowCoord, cameraParams, shadowSearchArea);\n}\n`;\n\nexport { shadowPCSSPS as default };\n", "var shadowSampleCoordPS = `\nvec3 getShadowSampleCoord$LIGHT(mat4 shadowTransform, vec4 shadowParams, vec3 worldPosition, vec3 lightPos, inout vec3 lightDir, vec3 lightDirNorm, vec3 normal) {\n\tvec3 surfacePosition = worldPosition;\n#ifdef SHADOW_SAMPLE_POINT\n\t#ifdef SHADOW_SAMPLE_NORMAL_OFFSET\n\t\tfloat distScale = length(lightDir);\n\t\tsurfacePosition = worldPosition + normal * shadowParams.y * clamp(1.0 - dot(normal, -lightDirNorm), 0.0, 1.0) * distScale;\n\t\tlightDir = surfacePosition - lightPos;\n\t\treturn lightDir;\n\t#endif\n#else\n\t#ifdef SHADOW_SAMPLE_SOURCE_ZBUFFER\n\t\t#ifdef SHADOW_SAMPLE_NORMAL_OFFSET\n\t\t\tsurfacePosition = worldPosition + normal * shadowParams.y;\n\t\t#endif\n\t#else\n\t\t#ifdef SHADOW_SAMPLE_NORMAL_OFFSET\n\t\t\t#ifdef SHADOW_SAMPLE_ORTHO\n\t\t\t\tfloat distScale = 1.0;\n\t\t\t#else\n\t\t\t\tfloat distScale = abs(dot(vPositionW - lightPos, lightDirNorm));\n\t\t\t#endif\n\t\t\tsurfacePosition = worldPosition + normal * shadowParams.y * clamp(1.0 - dot(normal, -lightDirNorm), 0.0, 1.0) * distScale;\n\t\t#endif\n\t#endif\n\tvec4 positionInShadowSpace = shadowTransform * vec4(surfacePosition, 1.0);\n\t#ifdef SHADOW_SAMPLE_ORTHO\n\t\tpositionInShadowSpace.z = saturate(positionInShadowSpace.z) - 0.0001;\n\t#else\n\t\t#ifdef SHADOW_SAMPLE_SOURCE_ZBUFFER\n\t\t\tpositionInShadowSpace.xyz /= positionInShadowSpace.w;\n\t\t#else\n\t\t\tpositionInShadowSpace.xy /= positionInShadowSpace.w;\n\t\t\tpositionInShadowSpace.z = length(lightDir) * shadowParams.w;\n\t\t#endif\n\t#endif\n\t#ifdef SHADOW_SAMPLE_Z_BIAS\n\t\tpositionInShadowSpace.z += getShadowBias(shadowParams.x, shadowParams.z);\n\t#endif\n\tsurfacePosition = positionInShadowSpace.xyz;\n#endif\n\treturn surfacePosition;\n}\n`;\n\nexport { shadowSampleCoordPS as default };\n", "var shadowStandardPS = `\nvec3 lessThan2(vec3 a, vec3 b) {\n\treturn clamp((b - a)*1000.0, 0.0, 1.0);\n}\n#ifndef UNPACKFLOAT\n#define UNPACKFLOAT\n\tfloat unpackFloat(vec4 rgbaDepth) {\n\t\tconst vec4 bitShift = vec4(1.0 / (256.0 * 256.0 * 256.0), 1.0 / (256.0 * 256.0), 1.0 / 256.0, 1.0);\n\t\treturn dot(rgbaDepth, bitShift);\n\t}\n#endif\n#ifdef GL2\nfloat _getShadowPCF3x3(SHADOWMAP_ACCEPT(shadowMap), vec3 shadowCoord, vec3 shadowParams) {\n\tfloat z = shadowCoord.z;\n\tvec2 uv = shadowCoord.xy * shadowParams.x;\n\tfloat shadowMapSizeInv = 1.0 / shadowParams.x;\n\tvec2 base_uv = floor(uv + 0.5);\n\tfloat s = (uv.x + 0.5 - base_uv.x);\n\tfloat t = (uv.y + 0.5 - base_uv.y);\n\tbase_uv -= vec2(0.5);\n\tbase_uv *= shadowMapSizeInv;\n\tfloat sum = 0.0;\n\tfloat uw0 = (3.0 - 2.0 * s);\n\tfloat uw1 = (1.0 + 2.0 * s);\n\tfloat u0 = (2.0 - s) / uw0 - 1.0;\n\tfloat u1 = s / uw1 + 1.0;\n\tfloat vw0 = (3.0 - 2.0 * t);\n\tfloat vw1 = (1.0 + 2.0 * t);\n\tfloat v0 = (2.0 - t) / vw0 - 1.0;\n\tfloat v1 = t / vw1 + 1.0;\n\tu0 = u0 * shadowMapSizeInv + base_uv.x;\n\tv0 = v0 * shadowMapSizeInv + base_uv.y;\n\tu1 = u1 * shadowMapSizeInv + base_uv.x;\n\tv1 = v1 * shadowMapSizeInv + base_uv.y;\n\tsum += uw0 * vw0 * textureShadow(shadowMap, vec3(u0, v0, z));\n\tsum += uw1 * vw0 * textureShadow(shadowMap, vec3(u1, v0, z));\n\tsum += uw0 * vw1 * textureShadow(shadowMap, vec3(u0, v1, z));\n\tsum += uw1 * vw1 * textureShadow(shadowMap, vec3(u1, v1, z));\n\tsum *= 1.0f / 16.0;\n\treturn sum;\n}\nfloat getShadowPCF3x3(SHADOWMAP_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams) {\n\treturn _getShadowPCF3x3(SHADOWMAP_PASS(shadowMap), shadowCoord, shadowParams.xyz);\n}\nfloat getShadowSpotPCF3x3(SHADOWMAP_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams) {\n\treturn _getShadowPCF3x3(SHADOWMAP_PASS(shadowMap), shadowCoord, shadowParams.xyz);\n}\nfloat getShadowPCF1x1(SHADOWMAP_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams) {\n\treturn textureShadow(shadowMap, shadowCoord);\n}\nfloat getShadowSpotPCF1x1(SHADOWMAP_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams) {\n\treturn textureShadow(shadowMap, shadowCoord);\n}\n#else\nfloat _xgetShadowPCF3x3(mat3 depthKernel, vec3 shadowCoord, sampler2D shadowMap, vec3 shadowParams) {\n\tmat3 shadowKernel;\n\tvec3 shadowZ = vec3(shadowCoord.z);\n\tshadowKernel[0] = vec3(greaterThan(depthKernel[0], shadowZ));\n\tshadowKernel[1] = vec3(greaterThan(depthKernel[1], shadowZ));\n\tshadowKernel[2] = vec3(greaterThan(depthKernel[2], shadowZ));\n\tvec2 fractionalCoord = fract( shadowCoord.xy * shadowParams.x );\n\tshadowKernel[0] = mix(shadowKernel[0], shadowKernel[1], fractionalCoord.x);\n\tshadowKernel[1] = mix(shadowKernel[1], shadowKernel[2], fractionalCoord.x);\n\tvec4 shadowValues;\n\tshadowValues.x = mix(shadowKernel[0][0], shadowKernel[0][1], fractionalCoord.y);\n\tshadowValues.y = mix(shadowKernel[0][1], shadowKernel[0][2], fractionalCoord.y);\n\tshadowValues.z = mix(shadowKernel[1][0], shadowKernel[1][1], fractionalCoord.y);\n\tshadowValues.w = mix(shadowKernel[1][1], shadowKernel[1][2], fractionalCoord.y);\n\treturn dot( shadowValues, vec4( 1.0 ) ) * 0.25;\n}\nfloat _getShadowPCF3x3(sampler2D shadowMap, vec3 shadowCoord, vec3 shadowParams) {\n\tfloat xoffset = 1.0 / shadowParams.x;\n\tfloat dx0 = -xoffset;\n\tfloat dx1 = xoffset;\n\tmat3 depthKernel;\n\tdepthKernel[0][0] = unpackFloat(textureShadow(shadowMap, shadowCoord.xy + vec2(dx0, dx0)));\n\tdepthKernel[0][1] = unpackFloat(textureShadow(shadowMap, shadowCoord.xy + vec2(dx0, 0.0)));\n\tdepthKernel[0][2] = unpackFloat(textureShadow(shadowMap, shadowCoord.xy + vec2(dx0, dx1)));\n\tdepthKernel[1][0] = unpackFloat(textureShadow(shadowMap, shadowCoord.xy + vec2(0.0, dx0)));\n\tdepthKernel[1][1] = unpackFloat(textureShadow(shadowMap, shadowCoord.xy));\n\tdepthKernel[1][2] = unpackFloat(textureShadow(shadowMap, shadowCoord.xy + vec2(0.0, dx1)));\n\tdepthKernel[2][0] = unpackFloat(textureShadow(shadowMap, shadowCoord.xy + vec2(dx1, dx0)));\n\tdepthKernel[2][1] = unpackFloat(textureShadow(shadowMap, shadowCoord.xy + vec2(dx1, 0.0)));\n\tdepthKernel[2][2] = unpackFloat(textureShadow(shadowMap, shadowCoord.xy + vec2(dx1, dx1)));\n\treturn _xgetShadowPCF3x3(depthKernel, shadowCoord, shadowMap, shadowParams);\n}\nfloat getShadowPCF3x3(sampler2D shadowMap, vec3 shadowCoord, vec4 shadowParams) {\n\treturn _getShadowPCF3x3(shadowMap, shadowCoord, shadowParams.xyz);\n}\nfloat getShadowSpotPCF3x3(sampler2D shadowMap, vec3 shadowCoord, vec4 shadowParams) {\n\treturn _getShadowPCF3x3(shadowMap, shadowCoord, shadowParams.xyz);\n}\nfloat _getShadowPCF1x1(sampler2D shadowMap, vec3 shadowCoord) {\n\tfloat shadowSample = unpackFloat(textureShadow(shadowMap, shadowCoord.xy));\n\treturn shadowSample > shadowCoord.z ? 1.0 : 0.0;\n}\nfloat getShadowPCF1x1(sampler2D shadowMap, vec3 shadowCoord, vec4 shadowParams) {\n\treturn _getShadowPCF1x1(shadowMap, shadowCoord);\n}\nfloat getShadowSpotPCF1x1(sampler2D shadowMap, vec3 shadowCoord, vec4 shadowParams) {\n\treturn _getShadowPCF1x1(shadowMap, shadowCoord);\n}\n#endif\n#ifndef WEBGPU\nfloat _getShadowPoint(samplerCube shadowMap, vec4 shadowParams, vec3 dir) {\n\tvec3 tc = normalize(dir);\n\tvec3 tcAbs = abs(tc);\n\tvec4 dirX = vec4(1,0,0, tc.x);\n\tvec4 dirY = vec4(0,1,0, tc.y);\n\tfloat majorAxisLength = tc.z;\n\tif ((tcAbs.x > tcAbs.y) && (tcAbs.x > tcAbs.z)) {\n\t\tdirX = vec4(0,0,1, tc.z);\n\t\tdirY = vec4(0,1,0, tc.y);\n\t\tmajorAxisLength = tc.x;\n\t} else if ((tcAbs.y > tcAbs.x) && (tcAbs.y > tcAbs.z)) {\n\t\tdirX = vec4(1,0,0, tc.x);\n\t\tdirY = vec4(0,0,1, tc.z);\n\t\tmajorAxisLength = tc.y;\n\t}\n\tfloat shadowParamsInFaceSpace = ((1.0/shadowParams.x) * 2.0) * abs(majorAxisLength);\n\tvec3 xoffset = (dirX.xyz * shadowParamsInFaceSpace);\n\tvec3 yoffset = (dirY.xyz * shadowParamsInFaceSpace);\n\tvec3 dx0 = -xoffset;\n\tvec3 dy0 = -yoffset;\n\tvec3 dx1 = xoffset;\n\tvec3 dy1 = yoffset;\n\tmat3 shadowKernel;\n\tmat3 depthKernel;\n\tdepthKernel[0][0] = unpackFloat(textureCube(shadowMap, tc + dx0 + dy0));\n\tdepthKernel[0][1] = unpackFloat(textureCube(shadowMap, tc + dx0));\n\tdepthKernel[0][2] = unpackFloat(textureCube(shadowMap, tc + dx0 + dy1));\n\tdepthKernel[1][0] = unpackFloat(textureCube(shadowMap, tc + dy0));\n\tdepthKernel[1][1] = unpackFloat(textureCube(shadowMap, tc));\n\tdepthKernel[1][2] = unpackFloat(textureCube(shadowMap, tc + dy1));\n\tdepthKernel[2][0] = unpackFloat(textureCube(shadowMap, tc + dx1 + dy0));\n\tdepthKernel[2][1] = unpackFloat(textureCube(shadowMap, tc + dx1));\n\tdepthKernel[2][2] = unpackFloat(textureCube(shadowMap, tc + dx1 + dy1));\n\tvec3 shadowZ = vec3(length(dir) * shadowParams.w + shadowParams.z);\n\tshadowKernel[0] = vec3(lessThan2(depthKernel[0], shadowZ));\n\tshadowKernel[1] = vec3(lessThan2(depthKernel[1], shadowZ));\n\tshadowKernel[2] = vec3(lessThan2(depthKernel[2], shadowZ));\n\tvec2 uv = (vec2(dirX.w, dirY.w) / abs(majorAxisLength)) * 0.5;\n\tvec2 fractionalCoord = fract( uv * shadowParams.x );\n\tshadowKernel[0] = mix(shadowKernel[0], shadowKernel[1], fractionalCoord.x);\n\tshadowKernel[1] = mix(shadowKernel[1], shadowKernel[2], fractionalCoord.x);\n\tvec4 shadowValues;\n\tshadowValues.x = mix(shadowKernel[0][0], shadowKernel[0][1], fractionalCoord.y);\n\tshadowValues.y = mix(shadowKernel[0][1], shadowKernel[0][2], fractionalCoord.y);\n\tshadowValues.z = mix(shadowKernel[1][0], shadowKernel[1][1], fractionalCoord.y);\n\tshadowValues.w = mix(shadowKernel[1][1], shadowKernel[1][2], fractionalCoord.y);\n\treturn 1.0 - dot( shadowValues, vec4( 1.0 ) ) * 0.25;\n}\nfloat getShadowPointPCF3x3(samplerCube shadowMap, vec3 shadowCoord, vec4 shadowParams, vec3 lightDir) {\n\treturn _getShadowPoint(shadowMap, shadowParams, lightDir);\n}\n#endif\n`;\n\nexport { shadowStandardPS as default };\n", "var shadowStandardGL2PS = `\nfloat _getShadowPCF5x5(SHADOWMAP_ACCEPT(shadowMap), vec3 shadowCoord, vec3 shadowParams) {\n\tfloat z = shadowCoord.z;\n\tvec2 uv = shadowCoord.xy * shadowParams.x;\n\tfloat shadowMapSizeInv = 1.0 / shadowParams.x;\n\tvec2 base_uv = floor(uv + 0.5);\n\tfloat s = (uv.x + 0.5 - base_uv.x);\n\tfloat t = (uv.y + 0.5 - base_uv.y);\n\tbase_uv -= vec2(0.5);\n\tbase_uv *= shadowMapSizeInv;\n\tfloat uw0 = (4.0 - 3.0 * s);\n\tfloat uw1 = 7.0;\n\tfloat uw2 = (1.0 + 3.0 * s);\n\tfloat u0 = (3.0 - 2.0 * s) / uw0 - 2.0;\n\tfloat u1 = (3.0 + s) / uw1;\n\tfloat u2 = s / uw2 + 2.0;\n\tfloat vw0 = (4.0 - 3.0 * t);\n\tfloat vw1 = 7.0;\n\tfloat vw2 = (1.0 + 3.0 * t);\n\tfloat v0 = (3.0 - 2.0 * t) / vw0 - 2.0;\n\tfloat v1 = (3.0 + t) / vw1;\n\tfloat v2 = t / vw2 + 2.0;\n\tfloat sum = 0.0;\n\tu0 = u0 * shadowMapSizeInv + base_uv.x;\n\tv0 = v0 * shadowMapSizeInv + base_uv.y;\n\tu1 = u1 * shadowMapSizeInv + base_uv.x;\n\tv1 = v1 * shadowMapSizeInv + base_uv.y;\n\tu2 = u2 * shadowMapSizeInv + base_uv.x;\n\tv2 = v2 * shadowMapSizeInv + base_uv.y;\n\tsum += uw0 * vw0 * textureShadow(shadowMap, vec3(u0, v0, z));\n\tsum += uw1 * vw0 * textureShadow(shadowMap, vec3(u1, v0, z));\n\tsum += uw2 * vw0 * textureShadow(shadowMap, vec3(u2, v0, z));\n\tsum += uw0 * vw1 * textureShadow(shadowMap, vec3(u0, v1, z));\n\tsum += uw1 * vw1 * textureShadow(shadowMap, vec3(u1, v1, z));\n\tsum += uw2 * vw1 * textureShadow(shadowMap, vec3(u2, v1, z));\n\tsum += uw0 * vw2 * textureShadow(shadowMap, vec3(u0, v2, z));\n\tsum += uw1 * vw2 * textureShadow(shadowMap, vec3(u1, v2, z));\n\tsum += uw2 * vw2 * textureShadow(shadowMap, vec3(u2, v2, z));\n\tsum *= 1.0f / 144.0;\n\tsum = saturate(sum);\n\treturn sum;\n}\nfloat getShadowPCF5x5(SHADOWMAP_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams) {\n\treturn _getShadowPCF5x5(SHADOWMAP_PASS(shadowMap), shadowCoord, shadowParams.xyz);\n}\nfloat getShadowSpotPCF5x5(SHADOWMAP_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams) {\n\treturn _getShadowPCF5x5(SHADOWMAP_PASS(shadowMap), shadowCoord, shadowParams.xyz);\n}\n`;\n\nexport { shadowStandardGL2PS as default };\n", "var shadowVSM8PS = `\nfloat calculateVSM8(vec3 moments, float Z, float vsmBias) {\n\tfloat VSMBias = vsmBias;\n\tfloat depthScale = VSMBias * Z;\n\tfloat minVariance1 = depthScale * depthScale;\n\treturn chebyshevUpperBound(moments.xy, Z, minVariance1, 0.1);\n}\nfloat decodeFloatRG(vec2 rg) {\n\treturn rg.y*(1.0/255.0) + rg.x;\n}\nfloat VSM8(TEXTURE_ACCEPT(tex), vec2 texCoords, float resolution, float Z, float vsmBias, float exponent) {\n\tvec4 c = texture2D(tex, texCoords);\n\tvec3 moments = vec3(decodeFloatRG(c.xy), decodeFloatRG(c.zw), 0.0);\n\treturn calculateVSM8(moments, Z, vsmBias);\n}\nfloat getShadowVSM8(TEXTURE_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams, float exponent, vec3 lightDir) {\n\treturn VSM8(TEXTURE_PASS(shadowMap), shadowCoord.xy, shadowParams.x, shadowCoord.z, shadowParams.y, 0.0);\n}\nfloat getShadowSpotVSM8(TEXTURE_ACCEPT(shadowMap), vec3 shadowCoord, vec4 shadowParams, float exponent, vec3 lightDir) {\n\treturn VSM8(TEXTURE_PASS(shadowMap), shadowCoord.xy, shadowParams.x, length(lightDir) * shadowParams.w + shadowParams.z, shadowParams.y, 0.0);\n}\n`;\n\nexport { shadowVSM8PS as default };\n", "var shadowVSM_commonPS = `\nfloat linstep(float a, float b, float v) {\n\treturn saturate((v - a) / (b - a));\n}\nfloat reduceLightBleeding(float pMax, float amount) {\n\t return linstep(amount, 1.0, pMax);\n}\nfloat chebyshevUpperBound(vec2 moments, float mean, float minVariance, float lightBleedingReduction) {\n\tfloat variance = moments.y - (moments.x * moments.x);\n\tvariance = max(variance, minVariance);\n\tfloat d = mean - moments.x;\n\tfloat pMax = variance / (variance + (d * d));\n\tpMax = reduceLightBleeding(pMax, lightBleedingReduction);\n\treturn (mean <= moments.x ? 1.0 : pMax);\n}\nfloat calculateEVSM(vec3 moments, float Z, float vsmBias, float exponent) {\n\tZ = 2.0 * Z - 1.0;\n\tfloat warpedDepth = exp(exponent * Z);\n\tmoments.xy += vec2(warpedDepth, warpedDepth*warpedDepth) * (1.0 - moments.z);\n\tfloat VSMBias = vsmBias;\n\tfloat depthScale = VSMBias * exponent * warpedDepth;\n\tfloat minVariance1 = depthScale * depthScale;\n\treturn chebyshevUpperBound(moments.xy, warpedDepth, minVariance1, 0.1);\n}\n`;\n\nexport { shadowVSM_commonPS as default };\n", "var skinBatchConstVS = `\nattribute float vertex_boneIndices;\nuniform vec4 matrix_pose[BONE_LIMIT * 3];\nmat4 getBoneMatrix(const in float i) {\n\tvec4 v1 = matrix_pose[int(3.0 * i)];\n\tvec4 v2 = matrix_pose[int(3.0 * i + 1.0)];\n\tvec4 v3 = matrix_pose[int(3.0 * i + 2.0)];\n\treturn mat4(\n\t\tv1.x, v2.x, v3.x, 0,\n\t\tv1.y, v2.y, v3.y, 0,\n\t\tv1.z, v2.z, v3.z, 0,\n\t\tv1.w, v2.w, v3.w, 1\n\t);\n}\n`;\n\nexport { skinBatchConstVS as default };\n", "var skinBatchTexVS = `\nattribute float vertex_boneIndices;\nuniform highp sampler2D texture_poseMap;\nuniform vec4 texture_poseMapSize;\nmat4 getBoneMatrix(const in float i) {\n\tfloat j = i * 3.0;\n\tfloat dx = texture_poseMapSize.z;\n\tfloat dy = texture_poseMapSize.w;\n\tfloat y = floor(j * dx);\n\tfloat x = j - (y * texture_poseMapSize.x);\n\ty = dy * (y + 0.5);\n\tvec4 v1 = texture2D(texture_poseMap, vec2(dx * (x + 0.5), y));\n\tvec4 v2 = texture2D(texture_poseMap, vec2(dx * (x + 1.5), y));\n\tvec4 v3 = texture2D(texture_poseMap, vec2(dx * (x + 2.5), y));\n\treturn mat4(\n\t\tv1.x, v2.x, v3.x, 0,\n\t\tv1.y, v2.y, v3.y, 0,\n\t\tv1.z, v2.z, v3.z, 0,\n\t\tv1.w, v2.w, v3.w, 1\n\t);\n}\n`;\n\nexport { skinBatchTexVS as default };\n", "var skinConstVS = `\nattribute vec4 vertex_boneWeights;\nattribute vec4 vertex_boneIndices;\nuniform vec4 matrix_pose[BONE_LIMIT * 3];\nvoid getBoneMatrix(const in float i, out vec4 v1, out vec4 v2, out vec4 v3) {\n\tv1 = matrix_pose[int(3.0 * i)];\n\tv2 = matrix_pose[int(3.0 * i + 1.0)];\n\tv3 = matrix_pose[int(3.0 * i + 2.0)];\n}\nmat4 getSkinMatrix(const in vec4 indices, const in vec4 weights) {\n\tvec4 a1, a2, a3;\n\tgetBoneMatrix(indices.x, a1, a2, a3);\n\tvec4 b1, b2, b3;\n\tgetBoneMatrix(indices.y, b1, b2, b3);\n\tvec4 c1, c2, c3;\n\tgetBoneMatrix(indices.z, c1, c2, c3);\n\tvec4 d1, d2, d3;\n\tgetBoneMatrix(indices.w, d1, d2, d3);\n\tvec4 v1 = a1 * weights.x + b1 * weights.y + c1 * weights.z + d1 * weights.w;\n\tvec4 v2 = a2 * weights.x + b2 * weights.y + c2 * weights.z + d2 * weights.w;\n\tvec4 v3 = a3 * weights.x + b3 * weights.y + c3 * weights.z + d3 * weights.w;\n\tfloat one = dot(weights, vec4(1.0));\n\treturn mat4(\n\t\tv1.x, v2.x, v3.x, 0,\n\t\tv1.y, v2.y, v3.y, 0,\n\t\tv1.z, v2.z, v3.z, 0,\n\t\tv1.w, v2.w, v3.w, one\n\t);\n}\n`;\n\nexport { skinConstVS as default };\n", "var skinTexVS = `\nattribute vec4 vertex_boneWeights;\nattribute vec4 vertex_boneIndices;\nuniform highp sampler2D texture_poseMap;\nuniform vec4 texture_poseMapSize;\nvoid getBoneMatrix(const in float index, out vec4 v1, out vec4 v2, out vec4 v3) {\n\tfloat i = float(index);\n\tfloat j = i * 3.0;\n\tfloat dx = texture_poseMapSize.z;\n\tfloat dy = texture_poseMapSize.w;\n\t\n\tfloat y = floor(j * dx);\n\tfloat x = j - (y * texture_poseMapSize.x);\n\ty = dy * (y + 0.5);\n\tv1 = texture2D(texture_poseMap, vec2(dx * (x + 0.5), y));\n\tv2 = texture2D(texture_poseMap, vec2(dx * (x + 1.5), y));\n\tv3 = texture2D(texture_poseMap, vec2(dx * (x + 2.5), y));\n}\nmat4 getSkinMatrix(const in vec4 indices, const in vec4 weights) {\n\tvec4 a1, a2, a3;\n\tgetBoneMatrix(indices.x, a1, a2, a3);\n\tvec4 b1, b2, b3;\n\tgetBoneMatrix(indices.y, b1, b2, b3);\n\tvec4 c1, c2, c3;\n\tgetBoneMatrix(indices.z, c1, c2, c3);\n\tvec4 d1, d2, d3;\n\tgetBoneMatrix(indices.w, d1, d2, d3);\n\tvec4 v1 = a1 * weights.x + b1 * weights.y + c1 * weights.z + d1 * weights.w;\n\tvec4 v2 = a2 * weights.x + b2 * weights.y + c2 * weights.z + d2 * weights.w;\n\tvec4 v3 = a3 * weights.x + b3 * weights.y + c3 * weights.z + d3 * weights.w;\n\tfloat one = dot(weights, vec4(1.0));\n\treturn mat4(\n\t\tv1.x, v2.x, v3.x, 0,\n\t\tv1.y, v2.y, v3.y, 0,\n\t\tv1.z, v2.z, v3.z, 0,\n\t\tv1.w, v2.w, v3.w, one\n\t);\n}\n`;\n\nexport { skinTexVS as default };\n", "var skyboxEnvPS = `\nvarying vec3 vViewDir;\nuniform sampler2D texture_envAtlas;\nuniform float mipLevel;\nvoid main(void) {\n\tvec3 dir = vViewDir * vec3(-1.0, 1.0, 1.0);\n\tvec2 uv = toSphericalUv(normalize(dir));\n\tvec3 linear = SKYBOX_DECODE_FNC(texture2D(texture_envAtlas, mapRoughnessUv(uv, mipLevel)));\n\tgl_FragColor = vec4(gammaCorrectOutput(toneMap(processEnvironment(linear))), 1.0);\n}\n`;\n\nexport { skyboxEnvPS as default };\n", "var skyboxHDRPS = `\nvarying vec3 vViewDir;\nuniform samplerCube texture_cubeMap;\n#ifdef SKYMESH\n\tvarying vec3 vWorldPos;\n\tuniform mat3 cubeMapRotationMatrix;\n\tuniform vec3 projectedSkydomeCenter;\n#endif\nvoid main(void) {\n\t#ifdef SKYMESH\n\t\tvec3 envDir = normalize(vWorldPos - projectedSkydomeCenter);\n\t\tvec3 dir = envDir * cubeMapRotationMatrix;\n\t#else\n\t\tvec3 dir = vViewDir;\n\t#endif\n\tdir.x *= -1.0;\n\tvec3 linear = SKYBOX_DECODE_FNC(textureCube(texture_cubeMap, fixSeamsStatic(dir, SKYBOX_MIP)));\n\tgl_FragColor = vec4(gammaCorrectOutput(toneMap(processEnvironment(linear))), 1.0);\n}\n`;\n\nexport { skyboxHDRPS as default };\n", "var skyboxVS = `\nattribute vec3 aPosition;\n#ifndef VIEWMATRIX\n#define VIEWMATRIX\nuniform mat4 matrix_view;\n#endif\nuniform mat4 matrix_projectionSkybox;\nuniform mat3 cubeMapRotationMatrix;\nvarying vec3 vViewDir;\n#ifdef SKYMESH\n\tuniform mat4 matrix_model;\n\tvarying vec3 vWorldPos;\n#endif\nvoid main(void) {\n\tmat4 view = matrix_view;\n\t#ifdef SKYMESH\n\t\tvec4 worldPos = matrix_model * vec4(aPosition, 1.0);\n\t\tvWorldPos = worldPos.xyz;\n\t\tgl_Position = matrix_projectionSkybox * view * worldPos;\n\t#else\n\t\tview[3][0] = view[3][1] = view[3][2] = 0.0;\n\t\tgl_Position = matrix_projectionSkybox * view * vec4(aPosition, 1.0);\n\t\tvViewDir = aPosition * cubeMapRotationMatrix;\n\t#endif\n\tgl_Position.z = gl_Position.w - 1.0e-7;\n}\n`;\n\nexport { skyboxVS as default };\n", "var specularPS = `\n#ifdef MAPCOLOR\nuniform vec3 material_specular;\n#endif\nvoid getSpecularity() {\n\tvec3 specularColor = vec3(1,1,1);\n\t#ifdef MAPCOLOR\n\tspecularColor *= material_specular;\n\t#endif\n\t#ifdef MAPTEXTURE\n\tspecularColor *= $DECODE(texture2DBias($SAMPLER, $UV, textureBias)).$CH;\n\t#endif\n\t#ifdef MAPVERTEX\n\tspecularColor *= saturate(vVertexColor.$VC);\n\t#endif\n\tdSpecularity = specularColor;\n}\n`;\n\nexport { specularPS as default };\n", "var sphericalPS = `\nconst float PI = 3.141592653589793;\nvec2 toSpherical(vec3 dir) {\n\treturn vec2(dir.xz == vec2(0.0) ? 0.0 : atan(dir.x, dir.z), asin(dir.y));\n}\nvec2 toSphericalUv(vec3 dir) {\n\tvec2 uv = toSpherical(dir) / vec2(PI * 2.0, PI) + 0.5;\n\treturn vec2(uv.x, 1.0 - uv.y);\n}\n`;\n\nexport { sphericalPS as default };\n", "var specularityFactorPS = `\n#ifdef MAPFLOAT\nuniform float material_specularityFactor;\n#endif\nvoid getSpecularityFactor() {\n\tfloat specularityFactor = 1.0;\n\t#ifdef MAPFLOAT\n\tspecularityFactor *= material_specularityFactor;\n\t#endif\n\t#ifdef MAPTEXTURE\n\tspecularityFactor *= texture2DBias($SAMPLER, $UV, textureBias).$CH;\n\t#endif\n\t#ifdef MAPVERTEX\n\tspecularityFactor *= saturate(vVertexColor.$VC);\n\t#endif\n\tdSpecularityFactor = specularityFactor;\n}\n`;\n\nexport { specularityFactorPS as default };\n", "var spotPS = `\nfloat getSpotEffect(vec3 lightSpotDir, float lightInnerConeAngle, float lightOuterConeAngle, vec3 lightDirNorm) {\n\tfloat cosAngle = dot(lightDirNorm, lightSpotDir);\n\treturn smoothstep(lightOuterConeAngle, lightInnerConeAngle, cosAngle);\n}\n`;\n\nexport { spotPS as default };\n", "var startPS = `\nvoid main(void) {\n\tdReflection = vec4(0);\n\t#ifdef LIT_CLEARCOAT\n\tccSpecularLight = vec3(0);\n\tccReflection = vec3(0);\n\t#endif\n`;\n\nexport { startPS as default };\n", "var startVS = `\nvoid main(void) {\n\tgl_Position = getPosition();\n`;\n\nexport { startVS as default };\n", "var startNineSlicedPS = `\n\tnineSlicedUv = vUv0;\n\tnineSlicedUv.y = 1.0 - nineSlicedUv.y;\n`;\n\nexport { startNineSlicedPS as default };\n", "var startNineSlicedTiledPS = `\n\tvec2 tileMask = step(vMask, vec2(0.99999));\n\tvec2 tileSize = 0.5 * (innerOffset.xy + innerOffset.zw);\n\tvec2 tileScale = vec2(1.0) / (vec2(1.0) - tileSize);\n\tvec2 clampedUv = mix(innerOffset.xy * 0.5, vec2(1.0) - innerOffset.zw * 0.5, fract((vTiledUv - tileSize) * tileScale));\n\tclampedUv = clampedUv * atlasRect.zw + atlasRect.xy;\n\tnineSlicedUv = vUv0 * tileMask + clampedUv * (vec2(1.0) - tileMask);\n\tnineSlicedUv.y = 1.0 - nineSlicedUv.y;\n\t\n`;\n\nexport { startNineSlicedTiledPS as default };\n", "var storeEVSMPS = `\nfloat exponent = VSM_EXPONENT;\ndepth = 2.0 * depth - 1.0;\ndepth = exp(exponent * depth);\ngl_FragColor = vec4(depth, depth*depth, 1.0, 1.0);\n`;\n\nexport { storeEVSMPS as default };\n", "var tangentBinormalVS = `\nvec3 getTangent() {\n\treturn normalize(dNormalMatrix * vertex_tangent.xyz);\n}\nvec3 getBinormal() {\n\treturn cross(vNormalW, vTangentW) * vertex_tangent.w;\n}\n`;\n\nexport { tangentBinormalVS as default };\n", "var TBNPS = `\nvoid getTBN(vec3 tangent, vec3 binormal, vec3 normal) {\n\tdTBN = mat3(normalize(tangent), normalize(binormal), normalize(normal));\n}\n`;\n\nexport { TBNPS as default };\n", "var TBNderivativePS = `\nuniform float tbnBasis;\nvoid getTBN(vec3 tangent, vec3 binormal, vec3 normal) {\n\tvec2 uv = $UV;\n\tvec3 dp1 = dFdx( vPositionW );\n\tvec3 dp2 = dFdy( vPositionW );\n\tvec2 duv1 = dFdx( uv );\n\tvec2 duv2 = dFdy( uv );\n\tvec3 dp2perp = cross( dp2, normal );\n\tvec3 dp1perp = cross( normal, dp1 );\n\tvec3 T = dp2perp * duv1.x + dp1perp * duv2.x;\n\tvec3 B = dp2perp * duv1.y + dp1perp * duv2.y;\n\tfloat denom = max( dot(T,T), dot(B,B) );\n\tfloat invmax = (denom == 0.0) ? 0.0 : tbnBasis / sqrt( denom );\n\tdTBN = mat3(T * invmax, -B * invmax, normal );\n}\n`;\n\nexport { TBNderivativePS as default };\n", "var TBNfastPS = `\nvoid getTBN(vec3 tangent, vec3 binormal, vec3 normal) {\n\tdTBN = mat3(tangent, binormal, normal);\n}\n`;\n\nexport { TBNfastPS as default };\n", "var TBNObjectSpacePS = `\nvoid getTBN(vec3 tangent, vec3 binormal, vec3 normal) {\n\tvec3 B = cross(normal, vObjectSpaceUpW);\n\tvec3 T = cross(normal, B);\n\tif (dot(B,B)==0.0)\n\t{\n\t\tfloat major=max(max(normal.x, normal.y), normal.z);\n\t\tif (normal.x == major)\n\t\t{\n\t\t\tB=cross(normal, vec3(0,1,0));\n\t\t\tT=cross(normal, B);\n\t\t}\n\t\telse if (normal.y == major)\n\t\t{\n\t\t\tB=cross(normal, vec3(0,0,1));\n\t\t\tT=cross(normal, B);\n\t\t}\n\t\telse if (normal.z == major)\n\t\t{\n\t\t\tB=cross(normal, vec3(1,0,0));\n\t\t\tT=cross(normal, B);\n\t\t}\n\t}\n\tdTBN = mat3(normalize(T), normalize(B), normalize(normal));\n}\n`;\n\nexport { TBNObjectSpacePS as default };\n", "var textureSamplePS = `\nvec4 texture2DSRGB(sampler2D tex, vec2 uv) {\n\treturn gammaCorrectInput(texture2D(tex, uv));\n}\nvec4 texture2DSRGB(sampler2D tex, vec2 uv, float bias) {\n\treturn gammaCorrectInput(texture2D(tex, uv, bias));\n}\nvec3 texture2DRGBM(sampler2D tex, vec2 uv) {\n\treturn decodeRGBM(texture2D(tex, uv));\n}\nvec3 texture2DRGBM(sampler2D tex, vec2 uv, float bias) {\n\treturn decodeRGBM(texture2D(tex, uv, bias));\n}\nvec3 texture2DRGBE(sampler2D tex, vec2 uv) {\n\treturn decodeRGBM(texture2D(tex, uv));\n}\nvec3 texture2DRGBE(sampler2D tex, vec2 uv, float bias) {\n\treturn decodeRGBM(texture2D(tex, uv, bias));\n}\n`;\n\nexport { textureSamplePS as default };\n", "var thicknessPS = `\n#ifdef MAPFLOAT\nuniform float material_thickness;\n#endif\nvoid getThickness() {\n\tdThickness = 1.0;\n\t#ifdef MAPFLOAT\n\tdThickness *= material_thickness;\n\t#endif\n\t#ifdef MAPTEXTURE\n\tdThickness *= texture2DBias($SAMPLER, $UV, textureBias).$CH;\n\t#endif\n\t#ifdef MAPVERTEX\n\tdThickness *= saturate(vVertexColor.$VC);\n\t#endif\n}\n`;\n\nexport { thicknessPS as default };\n", "var tonemappingAcesPS = `\nuniform float exposure;\nvec3 toneMap(vec3 color) {\n\tfloat tA = 2.51;\n\tfloat tB = 0.03;\n\tfloat tC = 2.43;\n\tfloat tD = 0.59;\n\tfloat tE = 0.14;\n\tvec3 x = color * exposure;\n\treturn (x*(tA*x+tB))/(x*(tC*x+tD)+tE);\n}\n`;\n\nexport { tonemappingAcesPS as default };\n", "var tonemappingAces2PS = `\nuniform float exposure;\nconst mat3 ACESInputMat = mat3(\n\t0.59719, 0.35458, 0.04823,\n\t0.07600, 0.90834, 0.01566,\n\t0.02840, 0.13383, 0.83777\n);\nconst mat3 ACESOutputMat = mat3(\n\t 1.60475, -0.53108, -0.07367,\n\t-0.10208, 1.10813, -0.00605,\n\t-0.00327, -0.07276, 1.07602\n);\nvec3 RRTAndODTFit(vec3 v) {\n\tvec3 a = v * (v + 0.0245786) - 0.000090537;\n\tvec3 b = v * (0.983729 * v + 0.4329510) + 0.238081;\n\treturn a / b;\n}\nvec3 toneMap(vec3 color) {\n\tcolor *= exposure / 0.6;\n\tcolor = color * ACESInputMat;\n\tcolor = RRTAndODTFit(color);\n\tcolor = color * ACESOutputMat;\n\tcolor = clamp(color, 0.0, 1.0);\n\treturn color;\n}\n`;\n\nexport { tonemappingAces2PS as default };\n", "var tonemappingFilmicPS = `\nconst float A = 0.15;\nconst float B = 0.50;\nconst float C = 0.10;\nconst float D = 0.20;\nconst float E = 0.02;\nconst float F = 0.30;\nconst float W = 11.2;\nuniform float exposure;\nvec3 uncharted2Tonemap(vec3 x) {\n\t return ((x*(A*x+C*B)+D*E)/(x*(A*x+B)+D*F))-E/F;\n}\nvec3 toneMap(vec3 color) {\n\tcolor = uncharted2Tonemap(color * exposure);\n\tvec3 whiteScale = 1.0 / uncharted2Tonemap(vec3(W,W,W));\n\tcolor = color * whiteScale;\n\treturn color;\n}\n`;\n\nexport { tonemappingFilmicPS as default };\n", "var tonemappingHejlPS = `\nuniform float exposure;\nvec3 toneMap(vec3 color) {\n\tcolor *= exposure;\n\tconst float A = 0.22, B = 0.3, C = .1, D = 0.2, E = .01, F = 0.3;\n\tconst float Scl = 1.25;\n\tvec3 h = max( vec3(0.0), color - vec3(0.004) );\n\treturn (h*((Scl*A)*h+Scl*vec3(C*B,C*B,C*B))+Scl*vec3(D*E,D*E,D*E)) / (h*(A*h+vec3(B,B,B))+vec3(D*F,D*F,D*F)) - Scl*vec3(E/F,E/F,E/F);\n}\n`;\n\nexport { tonemappingHejlPS as default };\n", "var tonemappingLinearPS = `\nuniform float exposure;\nvec3 toneMap(vec3 color) {\n\treturn color * exposure;\n}\n`;\n\nexport { tonemappingLinearPS as default };\n", "var tonemappingNeutralPS = `\nuniform float exposure;\nvec3 toneMap(vec3 color) {\n\tcolor *= exposure;\n\tfloat startCompression = 0.8 - 0.04;\n\tfloat desaturation = 0.15;\n\tfloat x = min(color.r, min(color.g, color.b));\n\tfloat offset = x < 0.08 ? x - 6.25 * x * x : 0.04;\n\tcolor -= offset;\n\tfloat peak = max(color.r, max(color.g, color.b));\n\tif (peak < startCompression) return color;\n\tfloat d = 1. - startCompression;\n\tfloat newPeak = 1. - d * d / (peak + d - startCompression);\n\tcolor *= newPeak / peak;\n\tfloat g = 1. - 1. / (desaturation * (peak - newPeak) + 1.);\n\treturn mix(color, newPeak * vec3(1, 1, 1), g);\n}\n`;\n\nexport { tonemappingNeutralPS as default };\n", "var tonemappingNonePS = `\nvec3 toneMap(vec3 color) {\n\treturn color;\n}\n`;\n\nexport { tonemappingNonePS as default };\n", "var transformVS = `\n#ifdef PIXELSNAP\nuniform vec4 uScreenSize;\n#endif\n#ifdef SCREENSPACE\nuniform float projectionFlipY;\n#endif\n#ifdef MORPHING\nuniform vec4 morph_weights_a;\nuniform vec4 morph_weights_b;\n#endif\n#ifdef MORPHING_TEXTURE_BASED\n\tuniform vec4 morph_tex_params;\n\t#ifdef WEBGPU\n\t\tivec2 getTextureMorphCoords() {\n\t\t\tivec2 textureSize = ivec2(morph_tex_params.xy);\n\t\t\tint morphGridV = int(morph_vertex_id / textureSize.x);\n\t\t\tint morphGridU = int(morph_vertex_id - (morphGridV * textureSize.x));\n\t\t\tmorphGridV = textureSize.y - morphGridV - 1;\n\t\t\treturn ivec2(morphGridU, morphGridV);\n\t\t}\n\t#else\n\t\tvec2 getTextureMorphCoords() {\n\t\t\tvec2 textureSize = morph_tex_params.xy;\n\t\t\tvec2 invTextureSize = morph_tex_params.zw;\n\t\t\tfloat morphGridV = floor(morph_vertex_id * invTextureSize.x);\n\t\t\tfloat morphGridU = morph_vertex_id - (morphGridV * textureSize.x);\n\t\t\treturn vec2(morphGridU, morphGridV) * invTextureSize + (0.5 * invTextureSize);\n\t\t}\n\t#endif\n#endif\n#ifdef MORPHING_TEXTURE_BASED_POSITION\nuniform highp sampler2D morphPositionTex;\n#endif\nmat4 getModelMatrix() {\n\t#ifdef DYNAMICBATCH\n\treturn getBoneMatrix(vertex_boneIndices);\n\t#elif defined(SKIN)\n\treturn matrix_model * getSkinMatrix(vertex_boneIndices, vertex_boneWeights);\n\t#elif defined(INSTANCING)\n\treturn mat4(instance_line1, instance_line2, instance_line3, instance_line4);\n\t#else\n\treturn matrix_model;\n\t#endif\n}\nvec4 getPosition() {\n\tdModelMatrix = getModelMatrix();\n\tvec3 localPos = vertex_position;\n\t#ifdef NINESLICED\n\tlocalPos.xz *= outerScale;\n\tvec2 positiveUnitOffset = clamp(vertex_position.xz, vec2(0.0), vec2(1.0));\n\tvec2 negativeUnitOffset = clamp(-vertex_position.xz, vec2(0.0), vec2(1.0));\n\tlocalPos.xz += (-positiveUnitOffset * innerOffset.xy + negativeUnitOffset * innerOffset.zw) * vertex_texCoord0.xy;\n\tvTiledUv = (localPos.xz - outerScale + innerOffset.xy) * -0.5 + 1.0;\n\tlocalPos.xz *= -0.5;\n\tlocalPos = localPos.xzy;\n\t#endif\n\t#ifdef MORPHING\n\t#ifdef MORPHING_POS03\n\tlocalPos.xyz += morph_weights_a[0] * morph_pos0;\n\tlocalPos.xyz += morph_weights_a[1] * morph_pos1;\n\tlocalPos.xyz += morph_weights_a[2] * morph_pos2;\n\tlocalPos.xyz += morph_weights_a[3] * morph_pos3;\n\t#endif\n\t#ifdef MORPHING_POS47\n\tlocalPos.xyz += morph_weights_b[0] * morph_pos4;\n\tlocalPos.xyz += morph_weights_b[1] * morph_pos5;\n\tlocalPos.xyz += morph_weights_b[2] * morph_pos6;\n\tlocalPos.xyz += morph_weights_b[3] * morph_pos7;\n\t#endif\n\t#endif\n\t#ifdef MORPHING_TEXTURE_BASED_POSITION\n\t\t#ifdef WEBGPU\n\t\t\tivec2 morphUV = getTextureMorphCoords();\n\t\t\tvec3 morphPos = texelFetch(morphPositionTex, ivec2(morphUV), 0).xyz;\n\t\t#else\n\t\t\tvec2 morphUV = getTextureMorphCoords();\n\t\t\tvec3 morphPos = texture2D(morphPositionTex, morphUV).xyz;\n\t\t#endif\n\t\tlocalPos += morphPos;\n\t#endif\n\tvec4 posW = dModelMatrix * vec4(localPos, 1.0);\n\t#ifdef SCREENSPACE\n\tposW.zw = vec2(0.0, 1.0);\n\t#endif\n\tdPositionW = posW.xyz;\n\tvec4 screenPos;\n\t#ifdef UV1LAYOUT\n\tscreenPos = vec4(vertex_texCoord1.xy * 2.0 - 1.0, 0.5, 1);\n\t\t#ifdef WEBGPU\n\t\tscreenPos.y *= -1.0;\n\t\t#endif\n\t#else\n\t#ifdef SCREENSPACE\n\tscreenPos = posW;\n\tscreenPos.y *= projectionFlipY;\n\t#else\n\tscreenPos = matrix_viewProjection * posW;\n\t#endif\n\t#ifdef PIXELSNAP\n\tscreenPos.xy = (screenPos.xy * 0.5) + 0.5;\n\tscreenPos.xy *= uScreenSize.xy;\n\tscreenPos.xy = floor(screenPos.xy);\n\tscreenPos.xy *= uScreenSize.zw;\n\tscreenPos.xy = (screenPos.xy * 2.0) - 1.0;\n\t#endif\n\t#endif\n\treturn screenPos;\n}\nvec3 getWorldPosition() {\n\treturn dPositionW;\n}\n`;\n\nexport { transformVS as default };\n", "var transformDeclVS = `\nattribute vec3 vertex_position;\nuniform mat4 matrix_model;\nuniform mat4 matrix_viewProjection;\nvec3 dPositionW;\nmat4 dModelMatrix;\n`;\n\nexport { transformDeclVS as default };\n", "var transmissionPS = `\n#ifdef MAPFLOAT\nuniform float material_refraction;\n#endif\nvoid getRefraction() {\n\tfloat refraction = 1.0;\n\t#ifdef MAPFLOAT\n\trefraction = material_refraction;\n\t#endif\n\t#ifdef MAPTEXTURE\n\trefraction *= texture2DBias($SAMPLER, $UV, textureBias).$CH;\n\t#endif\n\t#ifdef MAPVERTEX\n\trefraction *= saturate(vVertexColor.$VC);\n\t#endif\n\tdTransmission = refraction;\n}\n`;\n\nexport { transmissionPS as default };\n", "var twoSidedLightingPS = `\nuniform float twoSidedLightingNegScaleFactor;\nvoid handleTwoSidedLighting() {\n\tdTBN[2] *= gl_FrontFacing ? twoSidedLightingNegScaleFactor : -twoSidedLightingNegScaleFactor;\n}\n`;\n\nexport { twoSidedLightingPS as default };\n", "var uv0VS = `\n#ifdef NINESLICED\nvec2 getUv0() {\n\tvec2 uv = vertex_position.xz;\n\tvec2 positiveUnitOffset = clamp(vertex_position.xz, vec2(0.0), vec2(1.0));\n\tvec2 negativeUnitOffset = clamp(-vertex_position.xz, vec2(0.0), vec2(1.0));\n\tuv += (-positiveUnitOffset * innerOffset.xy + negativeUnitOffset * innerOffset.zw) * vertex_texCoord0.xy;\n\tuv = uv * -0.5 + 0.5;\n\tuv = uv * atlasRect.zw + atlasRect.xy;\n\tvMask = vertex_texCoord0.xy;\n\treturn uv;\n}\n#else\nvec2 getUv0() {\n\treturn vertex_texCoord0;\n}\n#endif\n`;\n\nexport { uv0VS as default };\n", "var uv1VS = `\nvec2 getUv1() {\n\treturn vertex_texCoord1;\n}\n`;\n\nexport { uv1VS as default };\n", "var viewDirPS = `\nvoid getViewDir() {\n\tdViewDirW = normalize(view_position - vPositionW);\n}\n`;\n\nexport { viewDirPS as default };\n", "var viewNormalVS = `\n#ifndef VIEWMATRIX\n#define VIEWMATRIX\nuniform mat4 matrix_view;\n#endif\nvec3 getViewNormal() {\n\treturn mat3(matrix_view) * vNormalW;\n}\n`;\n\nexport { viewNormalVS as default };\n", "import alphaTestPS from './standard/frag/alphaTest.js';\nimport ambientConstantPS from './lit/frag/ambientConstant.js';\nimport ambientEnvPS from './lit/frag/ambientEnv.js';\nimport ambientSHPS from './lit/frag/ambientSH.js';\nimport aoPS from './standard/frag/ao.js';\nimport aoDetailMapPS from './standard/frag/aoDetailMap.js';\nimport aoDiffuseOccPS from './lit/frag/aoDiffuseOcc.js';\nimport aoSpecOccPS from './lit/frag/aoSpecOcc.js';\nimport aoSpecOccConstPS from './lit/frag/aoSpecOccConst.js';\nimport aoSpecOccConstSimplePS from './lit/frag/aoSpecOccConstSimple.js';\nimport aoSpecOccSimplePS from './lit/frag/aoSpecOccSimple.js';\nimport basePS from './lit/frag/base.js';\nimport baseVS from './lit/vert/base.js';\nimport baseNineSlicedPS from './lit/frag/baseNineSliced.js';\nimport baseNineSlicedVS from './lit/vert/baseNineSliced.js';\nimport baseNineSlicedTiledPS from './lit/frag/baseNineSlicedTiled.js';\nimport bayerPS from './common/frag/bayer.js';\nimport biasConstPS from './lit/frag/biasConst.js';\nimport blurVSMPS from './lit/frag/blurVSM.js';\nimport clearCoatPS from './standard/frag/clearCoat.js';\nimport clearCoatGlossPS from './standard/frag/clearCoatGloss.js';\nimport clearCoatNormalPS from './standard/frag/clearCoatNormal.js';\nimport clusteredLightUtilsPS from './lit/frag/clusteredLightUtils.js';\nimport clusteredLightCookiesPS from './lit/frag/clusteredLightCookies.js';\nimport clusteredLightShadowsPS from './lit/frag/clusteredLightShadows.js';\nimport clusteredLightPS from './lit/frag/clusteredLight.js';\nimport combinePS from './lit/frag/combine.js';\nimport cookiePS from './lit/frag/cookie.js';\nimport cubeMapProjectBoxPS from './lit/frag/cubeMapProjectBox.js';\nimport cubeMapProjectNonePS from './lit/frag/cubeMapProjectNone.js';\nimport cubeMapRotatePS from './lit/frag/cubeMapRotate.js';\nimport debugOutputPS from './lit/frag/debug-output.js';\nimport debugProcessFrontendPS from './lit/frag/debug-process-frontend.js';\nimport decodePS from './common/frag/decode.js';\nimport detailModesPS from './standard/frag/detailModes.js';\nimport diffusePS from './standard/frag/diffuse.js';\nimport diffuseDetailMapPS from './standard/frag/diffuseDetailMap.js';\nimport emissivePS from './standard/frag/emissive.js';\nimport encodePS from './common/frag/encode.js';\nimport endPS from './lit/frag/end.js';\nimport endVS from './lit/vert/end.js';\nimport envAtlasPS from './common/frag/envAtlas.js';\nimport envConstPS from './common/frag/envConst.js';\nimport envMultiplyPS from './common/frag/envMultiply.js';\nimport extensionPS from './lit/frag/extension.js';\nimport extensionVS from './lit/vert/extension.js';\nimport falloffInvSquaredPS from './lit/frag/falloffInvSquared.js';\nimport falloffLinearPS from './lit/frag/falloffLinear.js';\nimport fixCubemapSeamsNonePS from './common/frag/fixCubemapSeamsNone.js';\nimport fixCubemapSeamsStretchPS from './common/frag/fixCubemapSeamsStretch.js';\nimport floatUnpackingPS from './lit/frag/float-unpacking.js';\nimport fogExpPS from './lit/frag/fogExp.js';\nimport fogExp2PS from './lit/frag/fogExp2.js';\nimport fogLinearPS from './lit/frag/fogLinear.js';\nimport fogNonePS from './lit/frag/fogNone.js';\nimport fresnelSchlickPS from './lit/frag/fresnelSchlick.js';\nimport fullscreenQuadPS from './common/frag/fullscreenQuad.js';\nimport fullscreenQuadVS from './common/vert/fullscreenQuad.js';\nimport gamma1_0PS from './common/frag/gamma1_0.js';\nimport gamma2_2PS from './common/frag/gamma2_2.js';\nimport gles2PS from '../../../platform/graphics/shader-chunks/frag/gles2.js';\nimport gles2VS from '../../../platform/graphics/shader-chunks/vert/gles2.js';\nimport gles3PS from '../../../platform/graphics/shader-chunks/frag/gles3.js';\nimport gles3VS from '../../../platform/graphics/shader-chunks/vert/gles3.js';\nimport glossPS from './standard/frag/gloss.js';\nimport iridescenceDiffractionPS from './lit/frag/iridescenceDiffraction.js';\nimport iridescencePS from './standard/frag/iridescence.js';\nimport iridescenceThicknessPS from './standard/frag/iridescenceThickness.js';\nimport instancingVS from './lit/vert/instancing.js';\nimport iorPS from './standard/frag/ior.js';\nimport lightDiffuseLambertPS from './lit/frag/lightDiffuseLambert.js';\nimport lightDirPointPS from './lit/frag/lightDirPoint.js';\nimport lightmapAddPS from './lit/frag/lightmapAdd.js';\nimport lightmapDirAddPS from './lit/frag/lightmapDirAdd.js';\nimport lightmapDirPS from './standard/frag/lightmapDir.js';\nimport lightmapSinglePS from './standard/frag/lightmapSingle.js';\nimport lightSpecularAnisoGGXPS from './lit/frag/lightSpecularAnisoGGX.js';\nimport lightSpecularBlinnPS from './lit/frag/lightSpecularBlinn.js';\nimport lightSpecularPhongPS from './lit/frag/lightSpecularPhong.js';\nimport lightSheenPS from './lit/frag/lightSheen.js';\nimport linearizeDepthPS from './common/frag/linearizeDepth.js';\nimport litShaderArgsPS from './standard/frag/litShaderArgs.js';\nimport ltcPS from './lit/frag/ltc.js';\nimport metalnessPS from './standard/frag/metalness.js';\nimport msdfPS from './common/frag/msdf.js';\nimport metalnessModulatePS from './lit/frag/metalnessModulate.js';\nimport msdfVS from './common/vert/msdf.js';\nimport normalVS from './lit/vert/normal.js';\nimport normalDetailMapPS from './standard/frag/normalDetailMap.js';\nimport normalInstancedVS from './lit/vert/normalInstanced.js';\nimport normalMapPS from './standard/frag/normalMap.js';\nimport normalSkinnedVS from './lit/vert/normalSkinned.js';\nimport normalXYPS from './standard/frag/normalXY.js';\nimport normalXYZPS from './standard/frag/normalXYZ.js';\nimport opacityPS from './standard/frag/opacity.js';\nimport opacityDitherPS from './standard/frag/opacity-dither.js';\nimport outputPS from './lit/frag/output.js';\nimport outputAlphaPS from './lit/frag/outputAlpha.js';\nimport outputAlphaOpaquePS from './lit/frag/outputAlphaOpaque.js';\nimport outputAlphaPremulPS from './lit/frag/outputAlphaPremul.js';\nimport outputTex2DPS from './common/frag/outputTex2D.js';\nimport packDepthPS from './common/frag/packDepth.js';\nimport sheenPS from './standard/frag/sheen.js';\nimport sheenGlossPS from './standard/frag/sheenGloss.js';\nimport parallaxPS from './standard/frag/parallax.js';\nimport particlePS from './particle/frag/particle.js';\nimport particleVS from './particle/vert/particle.js';\nimport particleAnimFrameClampVS from './particle/vert/particleAnimFrameClamp.js';\nimport particleAnimFrameLoopVS from './particle/vert/particleAnimFrameLoop.js';\nimport particleAnimTexVS from './particle/vert/particleAnimTex.js';\nimport particleInputFloatPS from './particle/frag/particleInputFloat.js';\nimport particleInputRgba8PS from './particle/frag/particleInputRgba8.js';\nimport particleOutputFloatPS from './particle/frag/particleOutputFloat.js';\nimport particleOutputRgba8PS from './particle/frag/particleOutputRgba8.js';\nimport particleUpdaterAABBPS from './particle/frag/particleUpdaterAABB.js';\nimport particleUpdaterEndPS from './particle/frag/particleUpdaterEnd.js';\nimport particleUpdaterInitPS from './particle/frag/particleUpdaterInit.js';\nimport particleUpdaterNoRespawnPS from './particle/frag/particleUpdaterNoRespawn.js';\nimport particleUpdaterOnStopPS from './particle/frag/particleUpdaterOnStop.js';\nimport particleUpdaterRespawnPS from './particle/frag/particleUpdaterRespawn.js';\nimport particleUpdaterSpherePS from './particle/frag/particleUpdaterSphere.js';\nimport particleUpdaterStartPS from './particle/frag/particleUpdaterStart.js';\nimport particle_billboardVS from './particle/vert/particle_billboard.js';\nimport particle_blendAddPS from './particle/frag/particle_blendAdd.js';\nimport particle_blendMultiplyPS from './particle/frag/particle_blendMultiply.js';\nimport particle_blendNormalPS from './particle/frag/particle_blendNormal.js';\nimport particle_cpuVS from './particle/vert/particle_cpu.js';\nimport particle_cpu_endVS from './particle/vert/particle_cpu_end.js';\nimport particle_customFaceVS from './particle/vert/particle_customFace.js';\nimport particle_endPS from './particle/frag/particle_end.js';\nimport particle_endVS from './particle/vert/particle_end.js';\nimport particle_halflambertPS from './particle/frag/particle_halflambert.js';\nimport particle_initVS from './particle/vert/particle_init.js';\nimport particle_lambertPS from './particle/frag/particle_lambert.js';\nimport particle_lightingPS from './particle/frag/particle_lighting.js';\nimport particle_localShiftVS from './particle/vert/particle_localShift.js';\nimport particle_meshVS from './particle/vert/particle_mesh.js';\nimport particle_normalVS from './particle/vert/particle_normal.js';\nimport particle_normalMapPS from './particle/frag/particle_normalMap.js';\nimport particle_pointAlongVS from './particle/vert/particle_pointAlong.js';\nimport particle_softPS from './particle/frag/particle_soft.js';\nimport particle_softVS from './particle/vert/particle_soft.js';\nimport particle_stretchVS from './particle/vert/particle_stretch.js';\nimport particle_TBNVS from './particle/vert/particle_TBN.js';\nimport particle_wrapVS from './particle/vert/particle_wrap.js';\nimport reflDirPS from './lit/frag/reflDir.js';\nimport reflDirAnisoPS from './lit/frag/reflDirAniso.js';\nimport reflectionCCPS from './lit/frag/reflectionCC.js';\nimport reflectionCubePS from './lit/frag/reflectionCube.js';\nimport reflectionEnvHQPS from './lit/frag/reflectionEnvHQ.js';\nimport reflectionEnvPS from './lit/frag/reflectionEnv.js';\nimport reflectionSpherePS from './lit/frag/reflectionSphere.js';\nimport reflectionSheenPS from './lit/frag/reflectionSheen.js';\nimport refractionCubePS from './lit/frag/refractionCube.js';\nimport refractionDynamicPS from './lit/frag/refractionDynamic.js';\nimport reprojectPS from './common/frag/reproject.js';\nimport sampleCatmullRomPS from './common/frag/sampleCatmullRom.js';\nimport screenDepthPS from './common/frag/screenDepth.js';\nimport shadowCascadesPS from './lit/frag/shadowCascades.js';\nimport shadowEVSMPS from './lit/frag/shadowEVSM.js';\nimport shadowEVSMnPS from './lit/frag/shadowEVSMn.js';\nimport shadowPCSSPS from './lit/frag/shadowPCSS.js';\nimport shadowSampleCoordPS from './lit/frag/shadowSampleCoord.js';\nimport shadowStandardPS from './lit/frag/shadowStandard.js';\nimport shadowStandardGL2PS from './lit/frag/shadowStandardGL2.js';\nimport shadowVSM8PS from './lit/frag/shadowVSM8.js';\nimport shadowVSM_commonPS from './lit/frag/shadowVSM_common.js';\nimport skinBatchConstVS from './common/vert/skinBatchConst.js';\nimport skinBatchTexVS from './common/vert/skinBatchTex.js';\nimport skinConstVS from './common/vert/skinConst.js';\nimport skinTexVS from './common/vert/skinTex.js';\nimport skyboxEnvPS from './skybox/frag/skyboxEnv.js';\nimport skyboxHDRPS from './skybox/frag/skyboxHDR.js';\nimport skyboxVS from './skybox/vert/skybox.js';\nimport specularPS from './standard/frag/specular.js';\nimport sphericalPS from './common/frag/spherical.js';\nimport specularityFactorPS from './standard/frag/specularityFactor.js';\nimport spotPS from './lit/frag/spot.js';\nimport startPS from './lit/frag/start.js';\nimport startVS from './lit/vert/start.js';\nimport startNineSlicedPS from './lit/frag/startNineSliced.js';\nimport startNineSlicedTiledPS from './lit/frag/startNineSlicedTiled.js';\nimport storeEVSMPS from './lit/frag/storeEVSM.js';\nimport tangentBinormalVS from './lit/vert/tangentBinormal.js';\nimport TBNPS from './lit/frag/TBN.js';\nimport TBNderivativePS from './lit/frag/TBNderivative.js';\nimport TBNfastPS from './lit/frag/TBNfast.js';\nimport TBNObjectSpacePS from './lit/frag/TBNObjectSpace.js';\nimport textureSamplePS from './standard/frag/textureSample.js';\nimport thicknessPS from './standard/frag/thickness.js';\nimport tonemappingAcesPS from './common/frag/tonemappingAces.js';\nimport tonemappingAces2PS from './common/frag/tonemappingAces2.js';\nimport tonemappingFilmicPS from './common/frag/tonemappingFilmic.js';\nimport tonemappingHejlPS from './common/frag/tonemappingHejl.js';\nimport tonemappingLinearPS from './common/frag/tonemappingLinear.js';\nimport tonemappingNeutralPS from './common/frag/tonemappingNeutral.js';\nimport tonemappingNonePS from './common/frag/tonemappingNone.js';\nimport transformVS from './common/vert/transform.js';\nimport transformDeclVS from './common/vert/transformDecl.js';\nimport transmissionPS from './standard/frag/transmission.js';\nimport twoSidedLightingPS from './lit/frag/twoSidedLighting.js';\nimport uv0VS from './lit/vert/uv0.js';\nimport uv1VS from './lit/vert/uv1.js';\nimport viewDirPS from './lit/frag/viewDir.js';\nimport viewNormalVS from './lit/vert/viewNormal.js';\nimport webgpuPS from '../../../platform/graphics/shader-chunks/frag/webgpu.js';\nimport webgpuVS from '../../../platform/graphics/shader-chunks/vert/webgpu.js';\n\nconst shaderChunks = {\n\talphaTestPS,\n\tambientConstantPS,\n\tambientEnvPS,\n\tambientSHPS,\n\taoPS,\n\taoDetailMapPS,\n\taoDiffuseOccPS,\n\taoSpecOccPS,\n\taoSpecOccConstPS,\n\taoSpecOccConstSimplePS,\n\taoSpecOccSimplePS,\n\tbasePS,\n\tbaseVS,\n\tbaseNineSlicedPS,\n\tbaseNineSlicedVS,\n\tbaseNineSlicedTiledPS,\n\tbayerPS,\n\tbiasConstPS,\n\tblurVSMPS,\n\tclearCoatPS,\n\tclearCoatGlossPS,\n\tclearCoatNormalPS,\n\tclusteredLightCookiesPS,\n\tclusteredLightShadowsPS,\n\tclusteredLightUtilsPS,\n\tclusteredLightPS,\n\tcombinePS,\n\tcookiePS,\n\tcubeMapProjectBoxPS,\n\tcubeMapProjectNonePS,\n\tcubeMapRotatePS,\n\tdebugOutputPS,\n\tdebugProcessFrontendPS,\n\tdetailModesPS,\n\tdiffusePS,\n\tdiffuseDetailMapPS,\n\tdecodePS,\n\temissivePS,\n\tencodePS,\n\tendPS,\n\tendVS,\n\tenvAtlasPS,\n\tenvConstPS,\n\tenvMultiplyPS,\n\textensionPS,\n\textensionVS,\n\tfalloffInvSquaredPS,\n\tfalloffLinearPS,\n\tfixCubemapSeamsNonePS,\n\tfixCubemapSeamsStretchPS,\n\tfloatUnpackingPS,\n\tfogExpPS,\n\tfogExp2PS,\n\tfogLinearPS,\n\tfogNonePS,\n\tfresnelSchlickPS,\n\tfullscreenQuadPS,\n\tfullscreenQuadVS,\n\tgamma1_0PS,\n\tgamma2_2PS,\n\tgles2PS,\n\tgles2VS,\n\tgles3PS,\n\tgles3VS,\n\tglossPS,\n\tiridescenceDiffractionPS,\n\tiridescencePS,\n\tiridescenceThicknessPS,\n\tinstancingVS,\n\tiorPS,\n\tlightDiffuseLambertPS,\n\tlightDirPointPS,\n\tlightmapAddPS,\n\tlightmapDirAddPS,\n\tlightmapDirPS,\n\tlightmapSinglePS,\n\tlightSpecularAnisoGGXPS,\n\tlightSpecularBlinnPS,\n\tlightSpecularPhongPS,\n\tlightSheenPS,\n\tlinearizeDepthPS,\n\tlitShaderArgsPS,\n\tltcPS,\n\tmetalnessPS,\n\tmetalnessModulatePS,\n\tmsdfPS,\n\tmsdfVS,\n\tnormalVS,\n\tnormalDetailMapPS,\n\tnormalInstancedVS,\n\tnormalMapPS,\n\tnormalSkinnedVS,\n\tnormalXYPS,\n\tnormalXYZPS,\n\topacityPS,\n\topacityDitherPS,\n\toutputPS,\n\toutputAlphaPS,\n\toutputAlphaOpaquePS,\n\toutputAlphaPremulPS,\n\toutputTex2DPS,\n\tpackDepthPS,\n\tsheenPS,\n\tsheenGlossPS,\n\tparallaxPS,\n\tparticlePS,\n\tparticleVS,\n\tparticleAnimFrameClampVS,\n\tparticleAnimFrameLoopVS,\n\tparticleAnimTexVS,\n\tparticleInputFloatPS,\n\tparticleInputRgba8PS,\n\tparticleOutputFloatPS,\n\tparticleOutputRgba8PS,\n\tparticleUpdaterAABBPS,\n\tparticleUpdaterEndPS,\n\tparticleUpdaterInitPS,\n\tparticleUpdaterNoRespawnPS,\n\tparticleUpdaterOnStopPS,\n\tparticleUpdaterRespawnPS,\n\tparticleUpdaterSpherePS,\n\tparticleUpdaterStartPS,\n\tparticle_billboardVS,\n\tparticle_blendAddPS,\n\tparticle_blendMultiplyPS,\n\tparticle_blendNormalPS,\n\tparticle_cpuVS,\n\tparticle_cpu_endVS,\n\tparticle_customFaceVS,\n\tparticle_endPS,\n\tparticle_endVS,\n\tparticle_halflambertPS,\n\tparticle_initVS,\n\tparticle_lambertPS,\n\tparticle_lightingPS,\n\tparticle_localShiftVS,\n\tparticle_meshVS,\n\tparticle_normalVS,\n\tparticle_normalMapPS,\n\tparticle_pointAlongVS,\n\tparticle_softPS,\n\tparticle_softVS,\n\tparticle_stretchVS,\n\tparticle_TBNVS,\n\tparticle_wrapVS,\n\treflDirPS,\n\treflDirAnisoPS,\n\treflectionCCPS,\n\treflectionCubePS,\n\treflectionEnvHQPS,\n\treflectionEnvPS,\n\treflectionSpherePS,\n\treflectionSheenPS,\n\trefractionCubePS,\n\trefractionDynamicPS,\n\treprojectPS,\n\tsampleCatmullRomPS,\n\tscreenDepthPS,\n\tshadowCascadesPS,\n\tshadowEVSMPS,\n\tshadowEVSMnPS,\n\tshadowPCSSPS,\n\tshadowSampleCoordPS,\n\tshadowStandardPS,\n\tshadowStandardGL2PS,\n\tshadowVSM8PS,\n\tshadowVSM_commonPS,\n\tskinBatchConstVS,\n\tskinBatchTexVS,\n\tskinConstVS,\n\tskinTexVS,\n\tskyboxEnvPS,\n\tskyboxHDRPS,\n\tskyboxVS,\n\tspecularPS,\n\tsphericalPS,\n\tspecularityFactorPS,\n\tspotPS,\n\tstartPS,\n\tstartVS,\n\tstartNineSlicedPS,\n\tstartNineSlicedTiledPS,\n\tstoreEVSMPS,\n\ttangentBinormalVS,\n\tTBNPS,\n\tTBNderivativePS,\n\tTBNfastPS,\n\tTBNObjectSpacePS,\n\ttextureSamplePS,\n\tthicknessPS,\n\ttonemappingAcesPS,\n\ttonemappingAces2PS,\n\ttonemappingFilmicPS,\n\ttonemappingHejlPS,\n\ttonemappingLinearPS,\n\ttonemappingNeutralPS,\n\ttonemappingNonePS,\n\ttransformVS,\n\ttransformDeclVS,\n\ttransmissionPS,\n\ttwoSidedLightingPS,\n\tuv0VS,\n\tuv1VS,\n\tviewDirPS,\n\tviewNormalVS,\n\twebgpuPS,\n\twebgpuVS\n};\n\nexport { shaderChunks };\n", "import { DeviceCache } from '../../platform/graphics/device-cache.js';\n\nconst programLibraryDeviceCache = new DeviceCache();\nfunction getProgramLibrary(device) {\n\tconst library = programLibraryDeviceCache.get(device);\n\treturn library;\n}\nfunction setProgramLibrary(device, library) {\n\tprogramLibraryDeviceCache.get(device, () => {\n\t\treturn library;\n\t});\n}\n\nexport { getProgramLibrary, setProgramLibrary };\n", "import { GAMMA_SRGB, GAMMA_SRGBFAST, GAMMA_SRGBHDR, TONEMAP_NEUTRAL, TONEMAP_ACES2, TONEMAP_ACES, TONEMAP_HEJL, TONEMAP_LINEAR, TONEMAP_FILMIC } from '../../constants.js';\nimport { shaderChunks } from '../chunks/chunks.js';\n\nclass ShaderGenerator {\n\tstatic begin() {\n\t\treturn 'void main(void)\\n{\\n';\n\t}\n\tstatic end() {\n\t\treturn '}\\n';\n\t}\n\tstatic skinCode(device, chunks = shaderChunks) {\n\t\tif (device.supportsBoneTextures) {\n\t\t\treturn chunks.skinTexVS;\n\t\t}\n\t\treturn \"#define BONE_LIMIT \" + device.getBoneLimit() + \"\\n\" + chunks.skinConstVS;\n\t}\n\tstatic fogCode(value, chunks = shaderChunks) {\n\t\tif (value === 'linear') {\n\t\t\treturn chunks.fogLinearPS ? chunks.fogLinearPS : shaderChunks.fogLinearPS;\n\t\t} else if (value === 'exp') {\n\t\t\treturn chunks.fogExpPS ? chunks.fogExpPS : shaderChunks.fogExpPS;\n\t\t} else if (value === 'exp2') {\n\t\t\treturn chunks.fogExp2PS ? chunks.fogExp2PS : shaderChunks.fogExp2PS;\n\t\t}\n\t\treturn chunks.fogNonePS ? chunks.fogNonePS : shaderChunks.fogNonePS;\n\t}\n\tstatic gammaCode(value, chunks = shaderChunks) {\n\t\tif (value === GAMMA_SRGB || value === GAMMA_SRGBFAST) {\n\t\t\treturn chunks.gamma2_2PS ? chunks.gamma2_2PS : shaderChunks.gamma2_2PS;\n\t\t} else if (value === GAMMA_SRGBHDR) {\n\t\t\treturn \"#define HDR\\n\" + (chunks.gamma2_2PS ? chunks.gamma2_2PS : shaderChunks.gamma2_2PS);\n\t\t}\n\t\treturn chunks.gamma1_0PS ? chunks.gamma1_0PS : shaderChunks.gamma1_0PS;\n\t}\n\tstatic tonemapCode(value, chunks = shaderChunks) {\n\t\tvar _chunks$tonemappingFi, _chunks$tonemappingLi, _chunks$tonemappingHe, _chunks$tonemappingAc, _chunks$tonemappingAc2, _chunks$tonemappingNe, _chunks$tonemapingNon;\n\t\tswitch (value) {\n\t\t\tcase TONEMAP_FILMIC:\n\t\t\t\treturn (_chunks$tonemappingFi = chunks.tonemappingFilmicPS) != null ? _chunks$tonemappingFi : shaderChunks.tonemappingFilmicPS;\n\t\t\tcase TONEMAP_LINEAR:\n\t\t\t\treturn (_chunks$tonemappingLi = chunks.tonemappingLinearPS) != null ? _chunks$tonemappingLi : shaderChunks.tonemappingLinearPS;\n\t\t\tcase TONEMAP_HEJL:\n\t\t\t\treturn (_chunks$tonemappingHe = chunks.tonemappingHejlPS) != null ? _chunks$tonemappingHe : shaderChunks.tonemappingHejlPS;\n\t\t\tcase TONEMAP_ACES:\n\t\t\t\treturn (_chunks$tonemappingAc = chunks.tonemappingAcesPS) != null ? _chunks$tonemappingAc : shaderChunks.tonemappingAcesPS;\n\t\t\tcase TONEMAP_ACES2:\n\t\t\t\treturn (_chunks$tonemappingAc2 = chunks.tonemappingAces2PS) != null ? _chunks$tonemappingAc2 : shaderChunks.tonemappingAces2PS;\n\t\t\tcase TONEMAP_NEUTRAL:\n\t\t\t\treturn (_chunks$tonemappingNe = chunks.tonemappingNeutralPS) != null ? _chunks$tonemappingNe : shaderChunks.tonemappingNeutralPS;\n\t\t}\n\t\treturn (_chunks$tonemapingNon = chunks.tonemapingNonePS) != null ? _chunks$tonemapingNon : shaderChunks.tonemappingNonePS;\n\t}\n}\n\nexport { ShaderGenerator };\n", "import { extends as _extends } from '../../../_virtual/_rollupPluginBabelHelpers.js';\nimport { Shader } from '../../platform/graphics/shader.js';\nimport { ShaderUtils } from '../../platform/graphics/shader-utils.js';\nimport { shaderChunks } from './chunks/chunks.js';\nimport { getProgramLibrary } from './get-program-library.js';\nimport { ShaderGenerator } from './programs/shader-generator.js';\nimport { SHADERLANGUAGE_WGSL } from '../../platform/graphics/constants.js';\n\nfunction createShader(device, vsName, fsName, useTransformFeedback = false, shaderDefinitionOptions = {}) {\n\tif (typeof useTransformFeedback === 'boolean') {\n\t\tshaderDefinitionOptions.useTransformFeedback = useTransformFeedback;\n\t} else if (typeof useTransformFeedback === 'object') {\n\t\tshaderDefinitionOptions = _extends({}, shaderDefinitionOptions, useTransformFeedback);\n\t}\n\treturn new Shader(device, ShaderUtils.createDefinition(device, _extends({}, shaderDefinitionOptions, {\n\t\tname: `${vsName}_${fsName}`,\n\t\tvertexCode: shaderChunks[vsName],\n\t\tfragmentCode: shaderChunks[fsName]\n\t})));\n}\nfunction createShaderFromCode(device, vsCode, fsCode, uniqueName, attributes, useTransformFeedback = false, shaderDefinitionOptions = {}) {\n\tif (typeof useTransformFeedback === 'boolean') {\n\t\tshaderDefinitionOptions.useTransformFeedback = useTransformFeedback;\n\t} else if (typeof useTransformFeedback === 'object') {\n\t\tshaderDefinitionOptions = _extends({}, shaderDefinitionOptions, useTransformFeedback);\n\t}\n\tconst programLibrary = getProgramLibrary(device);\n\tlet shader = programLibrary.getCachedShader(uniqueName);\n\tif (!shader) {\n\t\tshader = new Shader(device, ShaderUtils.createDefinition(device, _extends({}, shaderDefinitionOptions, {\n\t\t\tname: uniqueName,\n\t\t\tvertexCode: vsCode,\n\t\t\tfragmentCode: fsCode,\n\t\t\tattributes: attributes\n\t\t})));\n\t\tprogramLibrary.setCachedShader(uniqueName, shader);\n\t}\n\treturn shader;\n}\nclass ShaderGeneratorPassThrough extends ShaderGenerator {\n\tconstructor(key, shaderDefinition) {\n\t\tsuper();\n\t\tthis.key = key;\n\t\tthis.shaderDefinition = shaderDefinition;\n\t}\n\tgenerateKey(options) {\n\t\treturn this.key;\n\t}\n\tcreateShaderDefinition(device, options) {\n\t\treturn this.shaderDefinition;\n\t}\n}\nfunction processShader(shader, processingOptions) {\n\tvar _shaderDefinition$nam;\n\tconst shaderDefinition = shader.definition;\n\tconst name = (_shaderDefinition$nam = shaderDefinition.name) != null ? _shaderDefinition$nam : 'shader';\n\tconst key = `${name}-id-${shader.id}`;\n\tconst materialGenerator = new ShaderGeneratorPassThrough(key, shaderDefinition);\n\tconst libraryModuleName = 'shader';\n\tconst library = getProgramLibrary(shader.device);\n\tlibrary.register(libraryModuleName, materialGenerator);\n\tconst variant = library.getProgram(libraryModuleName, {}, processingOptions);\n\tif (shader.definition.shaderLanguage === SHADERLANGUAGE_WGSL) {\n\t\tvariant.meshUniformBufferFormat = shaderDefinition.meshUniformBufferFormat;\n\t\tvariant.meshBindGroupFormat = shaderDefinition.meshBindGroupFormat;\n\t}\n\tlibrary.unregister(libraryModuleName);\n\treturn variant;\n}\nshaderChunks.createShader = createShader;\nshaderChunks.createShaderFromCode = createShaderFromCode;\n\nexport { createShader, createShaderFromCode, processShader };\n", "import { Vec4 } from '../../core/math/vec4.js';\nimport { BindGroup } from '../../platform/graphics/bind-group.js';\nimport { BINDGROUP_MESH, PRIMITIVE_TRISTRIP } from '../../platform/graphics/constants.js';\nimport { ShaderProcessorOptions } from '../../platform/graphics/shader-processor-options.js';\nimport { UniformBuffer } from '../../platform/graphics/uniform-buffer.js';\nimport { processShader } from '../shader-lib/utils.js';\n\nconst _quadPrimitive = {\n\ttype: PRIMITIVE_TRISTRIP,\n\tbase: 0,\n\tcount: 4,\n\tindexed: false\n};\nconst _tempViewport = new Vec4();\nconst _tempScissor = new Vec4();\nclass QuadRender {\n\tconstructor(shader) {\n\t\tthis.uniformBuffer = void 0;\n\t\tthis.bindGroup = void 0;\n\t\tconst device = shader.device;\n\t\tthis.shader = shader;\n\t\tif (device.supportsUniformBuffers) {\n\t\t\tconst processingOptions = new ShaderProcessorOptions();\n\t\t\tthis.shader = processShader(shader, processingOptions);\n\t\t\tconst ubFormat = this.shader.meshUniformBufferFormat;\n\t\t\tif (ubFormat) {\n\t\t\t\tthis.uniformBuffer = new UniformBuffer(device, ubFormat, false);\n\t\t\t}\n\t\t\tconst bindGroupFormat = this.shader.meshBindGroupFormat;\n\t\t\tthis.bindGroup = new BindGroup(device, bindGroupFormat, this.uniformBuffer);\n\t\t}\n\t}\n\tdestroy() {\n\t\tvar _this$uniformBuffer, _this$bindGroup;\n\t\t(_this$uniformBuffer = this.uniformBuffer) == null || _this$uniformBuffer.destroy();\n\t\tthis.uniformBuffer = null;\n\t\t(_this$bindGroup = this.bindGroup) == null || _this$bindGroup.destroy();\n\t\tthis.bindGroup = null;\n\t}\n\trender(viewport, scissor) {\n\t\tconst device = this.shader.device;\n\t\tif (viewport) {\n\t\t\tvar _scissor;\n\t\t\t_tempViewport.set(device.vx, device.vy, device.vw, device.vh);\n\t\t\t_tempScissor.set(device.sx, device.sy, device.sw, device.sh);\n\t\t\tscissor = (_scissor = scissor) != null ? _scissor : viewport;\n\t\t\tdevice.setViewport(viewport.x, viewport.y, viewport.z, viewport.w);\n\t\t\tdevice.setScissor(scissor.x, scissor.y, scissor.z, scissor.w);\n\t\t}\n\t\tdevice.setVertexBuffer(device.quadVertexBuffer, 0);\n\t\tconst shader = this.shader;\n\t\tdevice.setShader(shader);\n\t\tif (device.supportsUniformBuffers) {\n\t\t\tvar _bindGroup$defaultUni;\n\t\t\tconst bindGroup = this.bindGroup;\n\t\t\t(_bindGroup$defaultUni = bindGroup.defaultUniformBuffer) == null || _bindGroup$defaultUni.update();\n\t\t\tbindGroup.update();\n\t\t\tdevice.setBindGroup(BINDGROUP_MESH, bindGroup);\n\t\t}\n\t\tdevice.draw(_quadPrimitive);\n\t\tif (viewport) {\n\t\t\tdevice.setViewport(_tempViewport.x, _tempViewport.y, _tempViewport.z, _tempViewport.w);\n\t\t\tdevice.setScissor(_tempScissor.x, _tempScissor.y, _tempScissor.z, _tempScissor.w);\n\t\t}\n\t}\n}\n\nexport { QuadRender };\n", "import { CULLFACE_NONE } from '../../platform/graphics/constants.js';\nimport { DepthState } from '../../platform/graphics/depth-state.js';\nimport { RenderPass } from '../../platform/graphics/render-pass.js';\n\nclass RenderPassQuad extends RenderPass {\n\tconstructor(device, quad, rect, scissorRect) {\n\t\tsuper(device);\n\t\tthis.quad = quad;\n\t\tthis.rect = rect;\n\t\tthis.scissorRect = scissorRect;\n\t}\n\texecute() {\n\t\tconst {\n\t\t\tdevice\n\t\t} = this;\n\t\tdevice.setCullMode(CULLFACE_NONE);\n\t\tdevice.setDepthState(DepthState.NODEPTH);\n\t\tdevice.setStencilState(null, null);\n\t\tthis.quad.render(this.rect, this.scissorRect);\n\t}\n}\n\nexport { RenderPassQuad };\n", "import { Vec4 } from '../../core/math/vec4.js';\nimport { QuadRender } from './quad-render.js';\nimport { RenderPassQuad } from './render-pass-quad.js';\n\nconst _tempRect = new Vec4();\nfunction drawQuadWithShader(device, target, shader, rect, scissorRect) {\n\tconst quad = new QuadRender(shader);\n\tif (!rect) {\n\t\trect = _tempRect;\n\t\trect.x = 0;\n\t\trect.y = 0;\n\t\trect.z = target ? target.width : device.width;\n\t\trect.w = target ? target.height : device.height;\n\t}\n\tconst renderPass = new RenderPassQuad(device, quad, rect, scissorRect);\n\trenderPass.init(target);\n\trenderPass.colorOps.clear = false;\n\trenderPass.depthStencilOps.clearDepth = false;\n\tif (device.isWebGPU && target === null && device.samples > 1) {\n\t\trenderPass.colorOps.store = true;\n\t}\n\trenderPass.render();\n\tquad.destroy();\n}\nfunction drawTexture(device, texture, target, shader, rect, scissorRect) {\n\tshader = shader || device.getCopyShader();\n\tdevice.constantTexSource.setValue(texture);\n\tdrawQuadWithShader(device, target, shader, rect, scissorRect);\n}\n\nexport { drawQuadWithShader, drawTexture };\n", "import { SHADER_DEPTH, SHADER_PICK, SHADER_FORWARD, SHADER_FORWARDHDR } from './constants.js';\nimport { DeviceCache } from '../platform/graphics/device-cache.js';\n\nconst shaderPassDeviceCache = new DeviceCache();\nclass ShaderPassInfo {\n\tconstructor(name, index, options = {}) {\n\t\tthis.index = void 0;\n\t\tthis.name = void 0;\n\t\tthis.shaderDefines = void 0;\n\t\tthis.name = name;\n\t\tthis.index = index;\n\t\tObject.assign(this, options);\n\t\tthis.shaderDefines = this.buildShaderDefines();\n\t}\n\tbuildShaderDefines() {\n\t\tlet keyword;\n\t\tif (this.isShadow) {\n\t\t\tkeyword = 'SHADOW';\n\t\t} else if (this.isForward) {\n\t\t\tkeyword = 'FORWARD';\n\t\t} else if (this.index === SHADER_DEPTH) {\n\t\t\tkeyword = 'DEPTH';\n\t\t} else if (this.index === SHADER_PICK) {\n\t\t\tkeyword = 'PICK';\n\t\t}\n\t\tconst define1 = keyword ? `#define ${keyword}_PASS\\n` : '';\n\t\tconst define2 = `#define ${this.name.toUpperCase()}_PASS\\n`;\n\t\treturn define1 + define2;\n\t}\n}\nclass ShaderPass {\n\tconstructor() {\n\t\tthis.passesNamed = new Map();\n\t\tthis.passesIndexed = [];\n\t\tthis.nextIndex = 0;\n\t\tconst add = (name, index, options) => {\n\t\t\tthis.allocate(name, options);\n\t\t};\n\t\tadd('forward', SHADER_FORWARD, {\n\t\t\tisForward: true\n\t\t});\n\t\tadd('forward_hdr', SHADER_FORWARDHDR, {\n\t\t\tisForward: true\n\t\t});\n\t\tadd('depth');\n\t\tadd('pick');\n\t\tadd('shadow');\n\t\tadd('prepass');\n\t}\n\tstatic get(device) {\n\t\treturn shaderPassDeviceCache.get(device, () => {\n\t\t\treturn new ShaderPass();\n\t\t});\n\t}\n\tallocate(name, options) {\n\t\tlet info = this.passesNamed.get(name);\n\t\tif (info === undefined) {\n\t\t\tinfo = new ShaderPassInfo(name, this.nextIndex, options);\n\t\t\tthis.passesNamed.set(info.name, info);\n\t\t\tthis.passesIndexed[info.index] = info;\n\t\t\tthis.nextIndex++;\n\t\t}\n\t\treturn info;\n\t}\n\tgetByIndex(index) {\n\t\tconst info = this.passesIndexed[index];\n\t\treturn info;\n\t}\n\tgetByName(name) {\n\t\treturn this.passesNamed.get(name);\n\t}\n}\n\nexport { ShaderPass, ShaderPassInfo };\n", "import { SEMANTIC_POSITION, SEMANTIC_BLENDWEIGHT, SEMANTIC_BLENDINDICES, SEMANTIC_COLOR, SEMANTIC_TEXCOORD0 } from '../../../platform/graphics/constants.js';\nimport { ShaderUtils } from '../../../platform/graphics/shader-utils.js';\nimport { shaderChunks } from '../chunks/chunks.js';\nimport { ShaderPass } from '../../shader-pass.js';\nimport { ShaderGenerator } from './shader-generator.js';\n\nconst vShader = `\n\n\t\t#include \"shaderPassDefines\"\n\t\t#include \"transformDeclVS\"\n\n\t\t#ifdef SKIN\n\t\t\t\t#include \"skinCode\"\n\t\t#endif\n\n\t\t#include \"transformVS\"\n\n\t\t#ifdef VERTEX_COLORS\n\t\t\t\tattribute vec4 vertex_color;\n\t\t\t\tvarying vec4 vColor;\n\t\t#endif\n\n\t\t#ifdef DIFFUSE_MAP\n\t\t\t\tattribute vec2 vertex_texCoord0;\n\t\t\t\tvarying vec2 vUv0;\n\t\t#endif\n\n\t\t#ifdef DEPTH_PASS\n\t\t\t\tvarying float vDepth;\n\t\t\t\t\n\t\t\t\t#ifndef VIEWMATRIX\n\t\t\t\t#define VIEWMATRIX\n\t\t\t\t\t\tuniform mat4 matrix_view;\n\t\t\t\t#endif\n\n\t\t\t\t#ifndef CAMERAPLANES\n\t\t\t\t#define CAMERAPLANES\n\t\t\t\t\t\tuniform vec4 camera_params;\n\t\t\t\t#endif\n\t\t#endif\n\n\t\tvoid main(void) {\n\t\t\t\tgl_Position = getPosition();\n\n\t\t\t\t#ifdef DEPTH_PASS\n\t\t\t\t\t\tvDepth = -(matrix_view * vec4(getWorldPosition(),1.0)).z * camera_params.x;\n\t\t\t\t#endif \n\n\t\t\t\t#ifdef VERTEX_COLORS\n\t\t\t\t\t\tvColor = vertex_color;\n\t\t\t\t#endif\n\n\t\t\t\t#ifdef DIFFUSE_MAP\n\t\t\t\t\t\tvUv0 = vertex_texCoord0;\n\t\t\t\t#endif\n\t\t}\n`;\nconst fShader = `\n\n\t\t#include \"shaderPassDefines\"\n\n\t\t#ifdef VERTEX_COLORS\n\t\t\t\tvarying vec4 vColor;\n\t\t#else\n\t\t\t\tuniform vec4 uColor;\n\t\t#endif\n\n\t\t#ifdef DIFFUSE_MAP\n\t\t\t\tvarying vec2 vUv0;\n\t\t\t\tuniform sampler2D texture_diffuseMap;\n\t\t#endif\n\n\t\t#ifdef FOG\n\t\t\t\t#include \"fogCode\"\n\t\t#endif\n\n\t\t#ifdef ALPHA_TEST\n\t\t\t\t#include \"alphaTestPS\"\n\t\t#endif\n\n\t\t#ifdef DEPTH_PASS\n\t\t\t\tvarying float vDepth;\n\t\t\t\t#include \"packDepthPS\"\n\t\t#endif\n\n\t\tvoid main(void) {\n\n\t\t\t\t#ifdef VERTEX_COLORS\n\t\t\t\t\t\tgl_FragColor = vColor;\n\t\t\t\t#else\n\t\t\t\t\t\tgl_FragColor = uColor;\n\t\t\t\t#endif\n\n\t\t\t\t#ifdef DIFFUSE_MAP\n\t\t\t\t\t\tgl_FragColor *= texture2D(texture_diffuseMap, vUv0);\n\t\t\t\t#endif\n\n\t\t\t\t#ifdef ALPHA_TEST\n\t\t\t\t\t\talphaTest(gl_FragColor.a);\n\t\t\t\t#endif\n\n\t\t\t\t#ifndef PICK_PASS\n\n\t\t\t\t\t\t#ifdef DEPTH_PASS\n\t\t\t\t\t\t\t\tgl_FragColor = packFloat(vDepth);\n\t\t\t\t\t\t#else\n\t\t\t\t\t\t\t\t#ifdef FOG\n\t\t\t\t\t\t\t\t\t\tglFragColor.rgb = addFog(gl_FragColor.rgb);\n\t\t\t\t\t\t\t\t#endif\n\t\t\t\t\t\t#endif\n\t\t\t\t#endif\n\t\t}\n`;\nclass ShaderGeneratorBasic extends ShaderGenerator {\n\tgenerateKey(options) {\n\t\tlet key = 'basic';\n\t\tif (options.fog) key += '_fog';\n\t\tif (options.alphaTest) key += '_atst';\n\t\tif (options.vertexColors) key += '_vcol';\n\t\tif (options.diffuseMap) key += '_diff';\n\t\tif (options.skin) key += '_skin';\n\t\tif (options.screenSpace) key += '_ss';\n\t\tif (options.useInstancing) key += '_inst';\n\t\tif (options.useMorphPosition) key += '_morphp';\n\t\tif (options.useMorphNormal) key += '_morphn';\n\t\tif (options.useMorphTextureBased) key += '_morpht';\n\t\tkey += '_' + options.pass;\n\t\treturn key;\n\t}\n\tcreateAttributesDefinition(definitionOptions, options) {\n\t\tconst attributes = {\n\t\t\tvertex_position: SEMANTIC_POSITION\n\t\t};\n\t\tif (options.skin) {\n\t\t\tattributes.vertex_boneWeights = SEMANTIC_BLENDWEIGHT;\n\t\t\tattributes.vertex_boneIndices = SEMANTIC_BLENDINDICES;\n\t\t}\n\t\tif (options.vertexColors) {\n\t\t\tattributes.vertex_color = SEMANTIC_COLOR;\n\t\t}\n\t\tif (options.diffuseMap) {\n\t\t\tattributes.vertex_texCoord0 = SEMANTIC_TEXCOORD0;\n\t\t}\n\t\tdefinitionOptions.attributes = attributes;\n\t}\n\tcreateVertexDefinition(device, definitionOptions, options, shaderPassInfo) {\n\t\tconst includes = new Map();\n\t\tconst defines = new Map();\n\t\tincludes.set('shaderPassDefines', shaderPassInfo.shaderDefines);\n\t\tincludes.set('transformDeclVS', shaderChunks.transformDeclVS);\n\t\tincludes.set('transformVS', shaderChunks.transformVS);\n\t\tincludes.set('skinCode', ShaderGenerator.skinCode(device));\n\t\tif (options.skin) defines.set('SKIN', true);\n\t\tif (options.vertexColors) defines.set('VERTEX_COLORS', true);\n\t\tif (options.diffuseMap) defines.set('DIFFUSE_MAP', true);\n\t\tdefinitionOptions.vertexCode = vShader;\n\t\tdefinitionOptions.vertexIncludes = includes;\n\t\tdefinitionOptions.vertexDefines = defines;\n\t}\n\tcreateFragmentDefinition(definitionOptions, options, shaderPassInfo) {\n\t\tconst includes = new Map();\n\t\tconst defines = new Map();\n\t\tincludes.set('shaderPassDefines', shaderPassInfo.shaderDefines);\n\t\tincludes.set('fogCode', ShaderGenerator.fogCode(options.fog));\n\t\tincludes.set('alphaTestPS', shaderChunks.alphaTestPS);\n\t\tincludes.set('packDepthPS', shaderChunks.packDepthPS);\n\t\tif (options.vertexColors) defines.set('VERTEX_COLORS', true);\n\t\tif (options.diffuseMap) defines.set('DIFFUSE_MAP', true);\n\t\tif (options.fog) defines.set('FOG', true);\n\t\tif (options.alphaTest) defines.set('ALPHA_TEST', true);\n\t\tdefinitionOptions.fragmentCode = fShader;\n\t\tdefinitionOptions.fragmentIncludes = includes;\n\t\tdefinitionOptions.fragmentDefines = defines;\n\t}\n\tcreateShaderDefinition(device, options) {\n\t\tconst definitionOptions = {\n\t\t\tname: 'BasicShader'\n\t\t};\n\t\tconst shaderPassInfo = ShaderPass.get(device).getByIndex(options.pass);\n\t\tthis.createAttributesDefinition(definitionOptions, options);\n\t\tthis.createVertexDefinition(device, definitionOptions, options, shaderPassInfo);\n\t\tthis.createFragmentDefinition(definitionOptions, options, shaderPassInfo);\n\t\treturn ShaderUtils.createDefinition(device, definitionOptions);\n\t}\n}\nconst basic = new ShaderGeneratorBasic();\n\nexport { basic };\n", "import { DeviceCache } from '../../platform/graphics/device-cache.js';\n\nconst defaultMaterialDeviceCache = new DeviceCache();\nfunction getDefaultMaterial(device) {\n\tconst material = defaultMaterialDeviceCache.get(device);\n\treturn material;\n}\nfunction setDefaultMaterial(device, material) {\n\tdefaultMaterialDeviceCache.get(device, () => {\n\t\treturn material;\n\t});\n}\n\nexport { getDefaultMaterial, setDefaultMaterial };\n", "import { CULLFACE_BACK, BLENDMODE_ONE, BLENDEQUATION_REVERSE_SUBTRACT, BLENDMODE_ZERO, BLENDEQUATION_ADD, BLENDMODE_SRC_ALPHA, BLENDMODE_ONE_MINUS_SRC_ALPHA, BLENDMODE_DST_COLOR, BLENDMODE_SRC_COLOR, BLENDMODE_ONE_MINUS_DST_COLOR, BLENDEQUATION_MIN, BLENDEQUATION_MAX } from '../../platform/graphics/constants.js';\nimport { BlendState } from '../../platform/graphics/blend-state.js';\nimport { DepthState } from '../../platform/graphics/depth-state.js';\nimport { ShaderProcessorOptions } from '../../platform/graphics/shader-processor-options.js';\nimport { BLEND_NONE, BLEND_NORMAL, BLEND_SUBTRACTIVE, BLEND_PREMULTIPLIED, BLEND_ADDITIVE, BLEND_ADDITIVEALPHA, BLEND_MULTIPLICATIVE2X, BLEND_SCREEN, BLEND_MULTIPLICATIVE, BLEND_MIN, BLEND_MAX } from '../constants.js';\nimport { processShader } from '../shader-lib/utils.js';\nimport { getDefaultMaterial } from './default-material.js';\n\nconst blendModes = [];\nblendModes[BLEND_SUBTRACTIVE] = {\n\tsrc: BLENDMODE_ONE,\n\tdst: BLENDMODE_ONE,\n\top: BLENDEQUATION_REVERSE_SUBTRACT\n};\nblendModes[BLEND_NONE] = {\n\tsrc: BLENDMODE_ONE,\n\tdst: BLENDMODE_ZERO,\n\top: BLENDEQUATION_ADD\n};\nblendModes[BLEND_NORMAL] = {\n\tsrc: BLENDMODE_SRC_ALPHA,\n\tdst: BLENDMODE_ONE_MINUS_SRC_ALPHA,\n\top: BLENDEQUATION_ADD\n};\nblendModes[BLEND_PREMULTIPLIED] = {\n\tsrc: BLENDMODE_ONE,\n\tdst: BLENDMODE_ONE_MINUS_SRC_ALPHA,\n\top: BLENDEQUATION_ADD\n};\nblendModes[BLEND_ADDITIVE] = {\n\tsrc: BLENDMODE_ONE,\n\tdst: BLENDMODE_ONE,\n\top: BLENDEQUATION_ADD\n};\nblendModes[BLEND_ADDITIVEALPHA] = {\n\tsrc: BLENDMODE_SRC_ALPHA,\n\tdst: BLENDMODE_ONE,\n\top: BLENDEQUATION_ADD\n};\nblendModes[BLEND_MULTIPLICATIVE2X] = {\n\tsrc: BLENDMODE_DST_COLOR,\n\tdst: BLENDMODE_SRC_COLOR,\n\top: BLENDEQUATION_ADD\n};\nblendModes[BLEND_SCREEN] = {\n\tsrc: BLENDMODE_ONE_MINUS_DST_COLOR,\n\tdst: BLENDMODE_ONE,\n\top: BLENDEQUATION_ADD\n};\nblendModes[BLEND_MULTIPLICATIVE] = {\n\tsrc: BLENDMODE_DST_COLOR,\n\tdst: BLENDMODE_ZERO,\n\top: BLENDEQUATION_ADD\n};\nblendModes[BLEND_MIN] = {\n\tsrc: BLENDMODE_ONE,\n\tdst: BLENDMODE_ONE,\n\top: BLENDEQUATION_MIN\n};\nblendModes[BLEND_MAX] = {\n\tsrc: BLENDMODE_ONE,\n\tdst: BLENDMODE_ONE,\n\top: BLENDEQUATION_MAX\n};\nlet id = 0;\nclass Material {\n\tconstructor() {\n\t\tthis._shader = null;\n\t\tthis.meshInstances = [];\n\t\tthis.name = 'Untitled';\n\t\tthis.userId = '';\n\t\tthis.id = id++;\n\t\tthis.variants = new Map();\n\t\tthis.parameters = {};\n\t\tthis.alphaTest = 0;\n\t\tthis.alphaToCoverage = false;\n\t\tthis._blendState = new BlendState();\n\t\tthis._depthState = new DepthState();\n\t\tthis.cull = CULLFACE_BACK;\n\t\tthis.stencilFront = null;\n\t\tthis.stencilBack = null;\n\t\tthis._shaderVersion = 0;\n\t\tthis._scene = null;\n\t\tthis.dirty = true;\n\t}\n\tset depthBias(value) {\n\t\tthis._depthState.depthBias = value;\n\t}\n\tget depthBias() {\n\t\treturn this._depthState.depthBias;\n\t}\n\tset slopeDepthBias(value) {\n\t\tthis._depthState.depthBiasSlope = value;\n\t}\n\tget slopeDepthBias() {\n\t\treturn this._depthState.depthBiasSlope;\n\t}\n\tset redWrite(value) {\n\t\tthis._blendState.redWrite = value;\n\t}\n\tget redWrite() {\n\t\treturn this._blendState.redWrite;\n\t}\n\tset greenWrite(value) {\n\t\tthis._blendState.greenWrite = value;\n\t}\n\tget greenWrite() {\n\t\treturn this._blendState.greenWrite;\n\t}\n\tset blueWrite(value) {\n\t\tthis._blendState.blueWrite = value;\n\t}\n\tget blueWrite() {\n\t\treturn this._blendState.blueWrite;\n\t}\n\tset alphaWrite(value) {\n\t\tthis._blendState.alphaWrite = value;\n\t}\n\tget alphaWrite() {\n\t\treturn this._blendState.alphaWrite;\n\t}\n\tset shader(shader) {\n\t\tthis._shader = shader;\n\t}\n\tget shader() {\n\t\treturn this._shader;\n\t}\n\tget transparent() {\n\t\treturn this._blendState.blend;\n\t}\n\t_updateTransparency() {\n\t\tconst transparent = this.transparent;\n\t\tconst meshInstances = this.meshInstances;\n\t\tfor (let i = 0; i < meshInstances.length; i++) {\n\t\t\tmeshInstances[i].transparent = transparent;\n\t\t}\n\t}\n\tset blendState(value) {\n\t\tthis._blendState.copy(value);\n\t\tthis._updateTransparency();\n\t}\n\tget blendState() {\n\t\treturn this._blendState;\n\t}\n\tset blendType(type) {\n\t\tconst blendMode = blendModes[type];\n\t\tthis._blendState.setColorBlend(blendMode.op, blendMode.src, blendMode.dst);\n\t\tthis._blendState.setAlphaBlend(blendMode.op, blendMode.src, blendMode.dst);\n\t\tconst blend = type !== BLEND_NONE;\n\t\tif (this._blendState.blend !== blend) {\n\t\t\tthis._blendState.blend = blend;\n\t\t\tthis._updateTransparency();\n\t\t}\n\t\tthis._updateMeshInstanceKeys();\n\t}\n\tget blendType() {\n\t\tif (!this.transparent) {\n\t\t\treturn BLEND_NONE;\n\t\t}\n\t\tconst {\n\t\t\tcolorOp,\n\t\t\tcolorSrcFactor,\n\t\t\tcolorDstFactor,\n\t\t\talphaOp,\n\t\t\talphaSrcFactor,\n\t\t\talphaDstFactor\n\t\t} = this._blendState;\n\t\tfor (let i = 0; i < blendModes.length; i++) {\n\t\t\tconst blendMode = blendModes[i];\n\t\t\tif (blendMode.src === colorSrcFactor && blendMode.dst === colorDstFactor && blendMode.op === colorOp && blendMode.src === alphaSrcFactor && blendMode.dst === alphaDstFactor && blendMode.op === alphaOp) {\n\t\t\t\treturn i;\n\t\t\t}\n\t\t}\n\t\treturn BLEND_NORMAL;\n\t}\n\tset depthState(value) {\n\t\tthis._depthState.copy(value);\n\t}\n\tget depthState() {\n\t\treturn this._depthState;\n\t}\n\tset depthTest(value) {\n\t\tthis._depthState.test = value;\n\t}\n\tget depthTest() {\n\t\treturn this._depthState.test;\n\t}\n\tset depthFunc(value) {\n\t\tthis._depthState.func = value;\n\t}\n\tget depthFunc() {\n\t\treturn this._depthState.func;\n\t}\n\tset depthWrite(value) {\n\t\tthis._depthState.write = value;\n\t}\n\tget depthWrite() {\n\t\treturn this._depthState.write;\n\t}\n\tcopy(source) {\n\t\tvar _source$stencilFront;\n\t\tthis.name = source.name;\n\t\tthis._shader = source._shader;\n\t\tthis.alphaTest = source.alphaTest;\n\t\tthis.alphaToCoverage = source.alphaToCoverage;\n\t\tthis._blendState.copy(source._blendState);\n\t\tthis._depthState.copy(source._depthState);\n\t\tthis.cull = source.cull;\n\t\tthis.stencilFront = (_source$stencilFront = source.stencilFront) == null ? void 0 : _source$stencilFront.clone();\n\t\tif (source.stencilBack) {\n\t\t\tthis.stencilBack = source.stencilFront === source.stencilBack ? this.stencilFront : source.stencilBack.clone();\n\t\t}\n\t\treturn this;\n\t}\n\tclone() {\n\t\tconst clone = new this.constructor();\n\t\treturn clone.copy(this);\n\t}\n\t_updateMeshInstanceKeys() {\n\t\tconst meshInstances = this.meshInstances;\n\t\tfor (let i = 0; i < meshInstances.length; i++) {\n\t\t\tmeshInstances[i].updateKey();\n\t\t}\n\t}\n\tupdateUniforms(device, scene) {}\n\tgetShaderVariant(device, scene, objDefs, unused, pass, sortedLights, viewUniformFormat, viewBindGroupFormat, vertexFormat) {\n\t\tconst processingOptions = new ShaderProcessorOptions(viewUniformFormat, viewBindGroupFormat, vertexFormat);\n\t\treturn processShader(this._shader, processingOptions);\n\t}\n\tupdate() {\n\t\tthis.dirty = true;\n\t\tif (this._shader) this._shader.failed = false;\n\t}\n\tclearParameters() {\n\t\tthis.parameters = {};\n\t}\n\tgetParameters() {\n\t\treturn this.parameters;\n\t}\n\tclearVariants() {\n\t\tthis.variants.clear();\n\t\tconst meshInstances = this.meshInstances;\n\t\tconst count = meshInstances.length;\n\t\tfor (let i = 0; i < count; i++) {\n\t\t\tmeshInstances[i].clearShaders();\n\t\t}\n\t}\n\tgetParameter(name) {\n\t\treturn this.parameters[name];\n\t}\n\tsetParameter(name, data) {\n\t\tif (data === undefined && typeof name === 'object') {\n\t\t\tconst uniformObject = name;\n\t\t\tif (uniformObject.length) {\n\t\t\t\tfor (let i = 0; i < uniformObject.length; i++) {\n\t\t\t\t\tthis.setParameter(uniformObject[i]);\n\t\t\t\t}\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tname = uniformObject.name;\n\t\t\tdata = uniformObject.value;\n\t\t}\n\t\tconst param = this.parameters[name];\n\t\tif (param) {\n\t\t\tparam.data = data;\n\t\t} else {\n\t\t\tthis.parameters[name] = {\n\t\t\t\tscopeId: null,\n\t\t\t\tdata: data\n\t\t\t};\n\t\t}\n\t}\n\tdeleteParameter(name) {\n\t\tif (this.parameters[name]) {\n\t\t\tdelete this.parameters[name];\n\t\t}\n\t}\n\tsetParameters(device, names) {\n\t\tconst parameters = this.parameters;\n\t\tif (names === undefined) names = parameters;\n\t\tfor (const paramName in names) {\n\t\t\tconst parameter = parameters[paramName];\n\t\t\tif (parameter) {\n\t\t\t\tif (!parameter.scopeId) {\n\t\t\t\t\tparameter.scopeId = device.scope.resolve(paramName);\n\t\t\t\t}\n\t\t\t\tparameter.scopeId.setValue(parameter.data);\n\t\t\t}\n\t\t}\n\t}\n\tdestroy() {\n\t\tthis.variants.clear();\n\t\tthis._shader = null;\n\t\tfor (let i = 0; i < this.meshInstances.length; i++) {\n\t\t\tconst meshInstance = this.meshInstances[i];\n\t\t\tmeshInstance.clearShaders();\n\t\t\tmeshInstance._material = null;\n\t\t\tif (meshInstance.mesh) {\n\t\t\t\tconst defaultMaterial = getDefaultMaterial(meshInstance.mesh.device);\n\t\t\t\tif (this !== defaultMaterial) {\n\t\t\t\t\tmeshInstance.material = defaultMaterial;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tthis.meshInstances.length = 0;\n\t}\n\taddMeshInstanceRef(meshInstance) {\n\t\tthis.meshInstances.push(meshInstance);\n\t}\n\tremoveMeshInstanceRef(meshInstance) {\n\t\tconst meshInstances = this.meshInstances;\n\t\tconst i = meshInstances.indexOf(meshInstance);\n\t\tif (i !== -1) {\n\t\t\tmeshInstances.splice(i, 1);\n\t\t}\n\t}\n}\n\nexport { Material };\n", "import { Color } from '../../core/math/color.js';\nimport { ShaderProcessorOptions } from '../../platform/graphics/shader-processor-options.js';\nimport { SHADERDEF_SKIN, SHADERDEF_SCREENSPACE, SHADERDEF_INSTANCING, SHADERDEF_MORPH_POSITION, SHADERDEF_MORPH_NORMAL, SHADERDEF_MORPH_TEXTURE_BASED } from '../constants.js';\nimport { getProgramLibrary } from '../shader-lib/get-program-library.js';\nimport { basic } from '../shader-lib/programs/basic.js';\nimport { Material } from './material.js';\n\nclass BasicMaterial extends Material {\n\tconstructor(...args) {\n\t\tsuper(...args);\n\t\tthis.color = new Color(1, 1, 1, 1);\n\t\tthis.colorUniform = new Float32Array(4);\n\t\tthis.colorMap = null;\n\t\tthis.vertexColors = false;\n\t}\n\tcopy(source) {\n\t\tsuper.copy(source);\n\t\tthis.color.copy(source.color);\n\t\tthis.colorMap = source.colorMap;\n\t\tthis.vertexColors = source.vertexColors;\n\t\treturn this;\n\t}\n\tupdateUniforms(device, scene) {\n\t\tthis.clearParameters();\n\t\tthis.colorUniform[0] = this.color.r;\n\t\tthis.colorUniform[1] = this.color.g;\n\t\tthis.colorUniform[2] = this.color.b;\n\t\tthis.colorUniform[3] = this.color.a;\n\t\tthis.setParameter('uColor', this.colorUniform);\n\t\tif (this.colorMap) {\n\t\t\tthis.setParameter('texture_diffuseMap', this.colorMap);\n\t\t}\n\t}\n\tgetShaderVariant(device, scene, objDefs, unused, pass, sortedLights, viewUniformFormat, viewBindGroupFormat, vertexFormat) {\n\t\tconst options = {\n\t\t\tskin: objDefs && (objDefs & SHADERDEF_SKIN) !== 0,\n\t\t\tscreenSpace: objDefs && (objDefs & SHADERDEF_SCREENSPACE) !== 0,\n\t\t\tuseInstancing: objDefs && (objDefs & SHADERDEF_INSTANCING) !== 0,\n\t\t\tuseMorphPosition: objDefs && (objDefs & SHADERDEF_MORPH_POSITION) !== 0,\n\t\t\tuseMorphNormal: objDefs && (objDefs & SHADERDEF_MORPH_NORMAL) !== 0,\n\t\t\tuseMorphTextureBased: objDefs && (objDefs & SHADERDEF_MORPH_TEXTURE_BASED) !== 0,\n\t\t\talphaTest: this.alphaTest > 0,\n\t\t\tvertexColors: this.vertexColors,\n\t\t\tdiffuseMap: !!this.colorMap,\n\t\t\tpass: pass\n\t\t};\n\t\tconst processingOptions = new ShaderProcessorOptions(viewUniformFormat, viewBindGroupFormat, vertexFormat);\n\t\tconst library = getProgramLibrary(device);\n\t\tlibrary.register('basic', basic);\n\t\treturn library.getProgram('basic', options, processingOptions, this.userId);\n\t}\n}\n\nexport { BasicMaterial };\n", "import { BoundingBox } from '../../core/shape/bounding-box.js';\n\nclass Batch {\n\tconstructor(meshInstances, dynamic, batchGroupId) {\n\t\tthis._aabb = new BoundingBox();\n\t\tthis.origMeshInstances = void 0;\n\t\tthis.meshInstance = null;\n\t\tthis.dynamic = void 0;\n\t\tthis.batchGroupId = void 0;\n\t\tthis.origMeshInstances = meshInstances;\n\t\tthis.dynamic = dynamic;\n\t\tthis.batchGroupId = batchGroupId;\n\t}\n\tdestroy(scene, layers) {\n\t\tif (this.meshInstance) {\n\t\t\tthis.removeFromLayers(scene, layers);\n\t\t\tthis.meshInstance.destroy();\n\t\t\tthis.meshInstance = null;\n\t\t}\n\t}\n\taddToLayers(scene, layers) {\n\t\tfor (let i = 0; i < layers.length; i++) {\n\t\t\tconst layer = scene.layers.getLayerById(layers[i]);\n\t\t\tif (layer) {\n\t\t\t\tlayer.addMeshInstances([this.meshInstance]);\n\t\t\t}\n\t\t}\n\t}\n\tremoveFromLayers(scene, layers) {\n\t\tfor (let i = 0; i < layers.length; i++) {\n\t\t\tconst layer = scene.layers.getLayerById(layers[i]);\n\t\t\tif (layer) {\n\t\t\t\tlayer.removeMeshInstances([this.meshInstance]);\n\t\t\t}\n\t\t}\n\t}\n\tupdateBoundingBox() {\n\t\tthis._aabb.copy(this.origMeshInstances[0].aabb);\n\t\tfor (let i = 1; i < this.origMeshInstances.length; i++) {\n\t\t\tthis._aabb.add(this.origMeshInstances[i].aabb);\n\t\t}\n\t\tthis.meshInstance.aabb = this._aabb;\n\t\tthis.meshInstance._aabbVer = 0;\n\t}\n}\n\nexport { Batch };\n", "import { LAYERID_WORLD } from '../constants.js';\n\nclass BatchGroup {\n\tconstructor(id, name, dynamic, maxAabbSize, layers = [LAYERID_WORLD]) {\n\t\tthis._ui = false;\n\t\tthis._sprite = false;\n\t\tthis._obj = {\n\t\t\tmodel: [],\n\t\t\telement: [],\n\t\t\tsprite: [],\n\t\t\trender: []\n\t\t};\n\t\tthis.id = void 0;\n\t\tthis.name = void 0;\n\t\tthis.dynamic = void 0;\n\t\tthis.maxAabbSize = void 0;\n\t\tthis.layers = void 0;\n\t\tthis.id = id;\n\t\tthis.name = name;\n\t\tthis.dynamic = dynamic;\n\t\tthis.maxAabbSize = maxAabbSize;\n\t\tthis.layers = layers;\n\t}\n}\nBatchGroup.MODEL = 'model';\nBatchGroup.ELEMENT = 'element';\nBatchGroup.SPRITE = 'sprite';\nBatchGroup.RENDER = 'render';\n\nexport { BatchGroup };\n", "import { math } from '../core/math/math.js';\nimport { Mat4 } from '../core/math/mat4.js';\nimport { PIXELFORMAT_RGBA32F, FILTER_NEAREST, TEXTURELOCK_READ } from '../platform/graphics/constants.js';\nimport { Texture } from '../platform/graphics/texture.js';\n\nconst _invMatrix = new Mat4();\nclass SkinInstance {\n\tconstructor(skin) {\n\t\tthis.bones = void 0;\n\t\tthis.boneTextureSize = void 0;\n\t\tthis._dirty = true;\n\t\tthis._rootBone = null;\n\t\tthis._skinUpdateIndex = -1;\n\t\tthis._updateBeforeCull = true;\n\t\tif (skin) {\n\t\t\tthis.initSkin(skin);\n\t\t}\n\t}\n\tset rootBone(rootBone) {\n\t\tthis._rootBone = rootBone;\n\t}\n\tget rootBone() {\n\t\treturn this._rootBone;\n\t}\n\tinit(device, numBones) {\n\t\tif (device.supportsBoneTextures) {\n\t\t\tconst numPixels = numBones * 3;\n\t\t\tlet width = Math.ceil(Math.sqrt(numPixels));\n\t\t\twidth = math.roundUp(width, 3);\n\t\t\tconst height = Math.ceil(numPixels / width);\n\t\t\tthis.boneTexture = new Texture(device, {\n\t\t\t\twidth: width,\n\t\t\t\theight: height,\n\t\t\t\tformat: PIXELFORMAT_RGBA32F,\n\t\t\t\tmipmaps: false,\n\t\t\t\tminFilter: FILTER_NEAREST,\n\t\t\t\tmagFilter: FILTER_NEAREST,\n\t\t\t\tname: 'skin'\n\t\t\t});\n\t\t\tthis.boneTextureSize = [width, height, 1.0 / width, 1.0 / height];\n\t\t\tthis.matrixPalette = this.boneTexture.lock({\n\t\t\t\tmode: TEXTURELOCK_READ\n\t\t\t});\n\t\t\tthis.boneTexture.unlock();\n\t\t} else {\n\t\t\tthis.matrixPalette = new Float32Array(numBones * 12);\n\t\t}\n\t}\n\tdestroy() {\n\t\tif (this.boneTexture) {\n\t\t\tthis.boneTexture.destroy();\n\t\t\tthis.boneTexture = null;\n\t\t}\n\t}\n\tresolve(rootBone, entity) {\n\t\tthis.rootBone = rootBone;\n\t\tconst skin = this.skin;\n\t\tconst bones = [];\n\t\tfor (let j = 0; j < skin.boneNames.length; j++) {\n\t\t\tconst boneName = skin.boneNames[j];\n\t\t\tlet bone = rootBone.findByName(boneName);\n\t\t\tif (!bone) {\n\t\t\t\tbone = entity;\n\t\t\t}\n\t\t\tbones.push(bone);\n\t\t}\n\t\tthis.bones = bones;\n\t}\n\tinitSkin(skin) {\n\t\tthis.skin = skin;\n\t\tthis.bones = [];\n\t\tconst numBones = skin.inverseBindPose.length;\n\t\tthis.init(skin.device, numBones);\n\t\tthis.matrices = [];\n\t\tfor (let i = 0; i < numBones; i++) {\n\t\t\tthis.matrices[i] = new Mat4();\n\t\t}\n\t}\n\tuploadBones(device) {\n\t\tif (device.supportsBoneTextures) {\n\t\t\tthis.boneTexture.lock();\n\t\t\tthis.boneTexture.unlock();\n\t\t}\n\t}\n\t_updateMatrices(rootNode, skinUpdateIndex) {\n\t\tif (this._skinUpdateIndex !== skinUpdateIndex) {\n\t\t\tthis._skinUpdateIndex = skinUpdateIndex;\n\t\t\t_invMatrix.copy(rootNode.getWorldTransform()).invert();\n\t\t\tfor (let i = this.bones.length - 1; i >= 0; i--) {\n\t\t\t\tthis.matrices[i].mulAffine2(_invMatrix, this.bones[i].getWorldTransform());\n\t\t\t\tthis.matrices[i].mulAffine2(this.matrices[i], this.skin.inverseBindPose[i]);\n\t\t\t}\n\t\t}\n\t}\n\tupdateMatrices(rootNode, skinUpdateIndex) {\n\t\tif (this._updateBeforeCull) {\n\t\t\tthis._updateMatrices(rootNode, skinUpdateIndex);\n\t\t}\n\t}\n\tupdateMatrixPalette(rootNode, skinUpdateIndex) {\n\t\tthis._updateMatrices(rootNode, skinUpdateIndex);\n\t\tconst mp = this.matrixPalette;\n\t\tconst count = this.bones.length;\n\t\tfor (let i = 0; i < count; i++) {\n\t\t\tconst pe = this.matrices[i].data;\n\t\t\tconst base = i * 12;\n\t\t\tmp[base] = pe[0];\n\t\t\tmp[base + 1] = pe[4];\n\t\t\tmp[base + 2] = pe[8];\n\t\t\tmp[base + 3] = pe[12];\n\t\t\tmp[base + 4] = pe[1];\n\t\t\tmp[base + 5] = pe[5];\n\t\t\tmp[base + 6] = pe[9];\n\t\t\tmp[base + 7] = pe[13];\n\t\t\tmp[base + 8] = pe[2];\n\t\t\tmp[base + 9] = pe[6];\n\t\t\tmp[base + 10] = pe[10];\n\t\t\tmp[base + 11] = pe[14];\n\t\t}\n\t\tthis.uploadBones(this.skin.device);\n\t}\n}\n\nexport { SkinInstance };\n", "class RefCountedObject {\n\tconstructor() {\n\t\tthis._refCount = 0;\n\t}\n\tincRefCount() {\n\t\tthis._refCount++;\n\t}\n\tdecRefCount() {\n\t\tthis._refCount--;\n\t}\n\tget refCount() {\n\t\treturn this._refCount;\n\t}\n}\n\nexport { RefCountedObject };\n", "import { RefCountedObject } from '../core/ref-counted-object.js';\nimport { Vec3 } from '../core/math/vec3.js';\nimport { BoundingBox } from '../core/shape/bounding-box.js';\nimport { SEMANTIC_TANGENT, SEMANTIC_BLENDINDICES, TYPE_UINT8, SEMANTIC_BLENDWEIGHT, SEMANTIC_POSITION, TYPE_UINT16, TYPE_INT16, TYPE_INT8, BUFFER_STATIC, BUFFER_DYNAMIC, TYPE_FLOAT32, SEMANTIC_NORMAL, SEMANTIC_TEXCOORD, SEMANTIC_COLOR, PRIMITIVE_TRIANGLES, PRIMITIVE_POINTS, typedArrayIndexFormats, PRIMITIVE_LINES, INDEXFORMAT_UINT32, INDEXFORMAT_UINT16 } from '../platform/graphics/constants.js';\nimport { IndexBuffer } from '../platform/graphics/index-buffer.js';\nimport { VertexBuffer } from '../platform/graphics/vertex-buffer.js';\nimport { VertexFormat } from '../platform/graphics/vertex-format.js';\nimport { VertexIterator } from '../platform/graphics/vertex-iterator.js';\nimport { RENDERSTYLE_WIREFRAME, RENDERSTYLE_POINTS, RENDERSTYLE_SOLID } from './constants.js';\n\nlet id = 0;\nclass GeometryData {\n\tconstructor() {\n\t\tthis.initDefaults();\n\t}\n\tinitDefaults() {\n\t\tthis.recreate = false;\n\t\tthis.verticesUsage = BUFFER_STATIC;\n\t\tthis.indicesUsage = BUFFER_STATIC;\n\t\tthis.maxVertices = 0;\n\t\tthis.maxIndices = 0;\n\t\tthis.vertexCount = 0;\n\t\tthis.indexCount = 0;\n\t\tthis.vertexStreamsUpdated = false;\n\t\tthis.indexStreamUpdated = false;\n\t\tthis.vertexStreamDictionary = {};\n\t\tthis.indices = null;\n\t}\n\t_changeVertexCount(count, semantic) {\n\t\tif (!this.vertexCount) {\n\t\t\tthis.vertexCount = count;\n\t\t}\n\t}\n}\nGeometryData.DEFAULT_COMPONENTS_POSITION = 3;\nGeometryData.DEFAULT_COMPONENTS_NORMAL = 3;\nGeometryData.DEFAULT_COMPONENTS_UV = 2;\nGeometryData.DEFAULT_COMPONENTS_COLORS = 4;\nclass GeometryVertexStream {\n\tconstructor(data, componentCount, dataType, dataTypeNormalize, asInt) {\n\t\tthis.data = data;\n\t\tthis.componentCount = componentCount;\n\t\tthis.dataType = dataType;\n\t\tthis.dataTypeNormalize = dataTypeNormalize;\n\t\tthis.asInt = asInt;\n\t}\n}\nclass Mesh extends RefCountedObject {\n\tconstructor(graphicsDevice, options) {\n\t\tsuper();\n\t\tthis._aabbVer = 0;\n\t\tthis._aabb = new BoundingBox();\n\t\tthis._storageVertex = false;\n\t\tthis._storageIndex = false;\n\t\tthis.id = id++;\n\t\tthis.device = graphicsDevice;\n\t\tthis._storageIndex = (options == null ? void 0 : options.storageIndex) || false;\n\t\tthis._storageVertex = (options == null ? void 0 : options.storageVertex) || false;\n\t\tthis.vertexBuffer = null;\n\t\tthis.indexBuffer = [null];\n\t\tthis.primitive = [{\n\t\t\ttype: 0,\n\t\t\tbase: 0,\n\t\t\tcount: 0\n\t\t}];\n\t\tthis.skin = null;\n\t\tthis._morph = null;\n\t\tthis._geometryData = null;\n\t\tthis.boneAabb = null;\n\t}\n\tstatic fromGeometry(graphicsDevice, geometry, options = {}) {\n\t\tconst mesh = new Mesh(graphicsDevice, options);\n\t\tconst {\n\t\t\tpositions,\n\t\t\tnormals,\n\t\t\ttangents,\n\t\t\tcolors,\n\t\t\tuvs,\n\t\t\tuvs1,\n\t\t\tblendIndices,\n\t\t\tblendWeights,\n\t\t\tindices\n\t\t} = geometry;\n\t\tif (positions) {\n\t\t\tmesh.setPositions(positions);\n\t\t}\n\t\tif (normals) {\n\t\t\tmesh.setNormals(normals);\n\t\t}\n\t\tif (tangents) {\n\t\t\tmesh.setVertexStream(SEMANTIC_TANGENT, tangents, 4);\n\t\t}\n\t\tif (colors) {\n\t\t\tmesh.setColors32(colors);\n\t\t}\n\t\tif (uvs) {\n\t\t\tmesh.setUvs(0, uvs);\n\t\t}\n\t\tif (uvs1) {\n\t\t\tmesh.setUvs(1, uvs1);\n\t\t}\n\t\tif (blendIndices) {\n\t\t\tmesh.setVertexStream(SEMANTIC_BLENDINDICES, blendIndices, 4, blendIndices.length / 4, TYPE_UINT8);\n\t\t}\n\t\tif (blendWeights) {\n\t\t\tmesh.setVertexStream(SEMANTIC_BLENDWEIGHT, blendWeights, 4);\n\t\t}\n\t\tif (indices) {\n\t\t\tmesh.setIndices(indices);\n\t\t}\n\t\tmesh.update();\n\t\treturn mesh;\n\t}\n\tset morph(morph) {\n\t\tif (morph !== this._morph) {\n\t\t\tif (this._morph) {\n\t\t\t\tthis._morph.decRefCount();\n\t\t\t}\n\t\t\tthis._morph = morph;\n\t\t\tif (morph) {\n\t\t\t\tmorph.incRefCount();\n\t\t\t}\n\t\t}\n\t}\n\tget morph() {\n\t\treturn this._morph;\n\t}\n\tset aabb(aabb) {\n\t\tthis._aabb = aabb;\n\t\tthis._aabbVer++;\n\t}\n\tget aabb() {\n\t\treturn this._aabb;\n\t}\n\tdestroy() {\n\t\tconst morph = this.morph;\n\t\tif (morph) {\n\t\t\tthis.morph = null;\n\t\t\tif (morph.refCount < 1) {\n\t\t\t\tmorph.destroy();\n\t\t\t}\n\t\t}\n\t\tif (this.vertexBuffer) {\n\t\t\tthis.vertexBuffer.destroy();\n\t\t\tthis.vertexBuffer = null;\n\t\t}\n\t\tfor (let j = 0; j < this.indexBuffer.length; j++) {\n\t\t\tthis._destroyIndexBuffer(j);\n\t\t}\n\t\tthis.indexBuffer.length = 0;\n\t\tthis._geometryData = null;\n\t}\n\t_destroyIndexBuffer(index) {\n\t\tif (this.indexBuffer[index]) {\n\t\t\tthis.indexBuffer[index].destroy();\n\t\t\tthis.indexBuffer[index] = null;\n\t\t}\n\t}\n\t_initBoneAabbs(morphTargets) {\n\t\tthis.boneAabb = [];\n\t\tthis.boneUsed = [];\n\t\tlet x, y, z;\n\t\tlet bMax, bMin;\n\t\tconst boneMin = [];\n\t\tconst boneMax = [];\n\t\tconst boneUsed = this.boneUsed;\n\t\tconst numBones = this.skin.boneNames.length;\n\t\tlet maxMorphX, maxMorphY, maxMorphZ;\n\t\tfor (let i = 0; i < numBones; i++) {\n\t\t\tboneMin[i] = new Vec3(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE);\n\t\t\tboneMax[i] = new Vec3(-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE);\n\t\t}\n\t\tconst iterator = new VertexIterator(this.vertexBuffer);\n\t\tconst posElement = iterator.element[SEMANTIC_POSITION];\n\t\tconst weightsElement = iterator.element[SEMANTIC_BLENDWEIGHT];\n\t\tconst indicesElement = iterator.element[SEMANTIC_BLENDINDICES];\n\t\tconst numVerts = this.vertexBuffer.numVertices;\n\t\tfor (let j = 0; j < numVerts; j++) {\n\t\t\tfor (let k = 0; k < 4; k++) {\n\t\t\t\tconst boneWeight = weightsElement.array[weightsElement.index + k];\n\t\t\t\tif (boneWeight > 0) {\n\t\t\t\t\tconst boneIndex = indicesElement.array[indicesElement.index + k];\n\t\t\t\t\tboneUsed[boneIndex] = true;\n\t\t\t\t\tx = posElement.array[posElement.index];\n\t\t\t\t\ty = posElement.array[posElement.index + 1];\n\t\t\t\t\tz = posElement.array[posElement.index + 2];\n\t\t\t\t\tbMax = boneMax[boneIndex];\n\t\t\t\t\tbMin = boneMin[boneIndex];\n\t\t\t\t\tif (bMin.x > x) bMin.x = x;\n\t\t\t\t\tif (bMin.y > y) bMin.y = y;\n\t\t\t\t\tif (bMin.z > z) bMin.z = z;\n\t\t\t\t\tif (bMax.x < x) bMax.x = x;\n\t\t\t\t\tif (bMax.y < y) bMax.y = y;\n\t\t\t\t\tif (bMax.z < z) bMax.z = z;\n\t\t\t\t\tif (morphTargets) {\n\t\t\t\t\t\tlet minMorphX = maxMorphX = x;\n\t\t\t\t\t\tlet minMorphY = maxMorphY = y;\n\t\t\t\t\t\tlet minMorphZ = maxMorphZ = z;\n\t\t\t\t\t\tfor (let l = 0; l < morphTargets.length; l++) {\n\t\t\t\t\t\t\tconst target = morphTargets[l];\n\t\t\t\t\t\t\tconst dx = target.deltaPositions[j * 3];\n\t\t\t\t\t\t\tconst dy = target.deltaPositions[j * 3 + 1];\n\t\t\t\t\t\t\tconst dz = target.deltaPositions[j * 3 + 2];\n\t\t\t\t\t\t\tif (dx < 0) {\n\t\t\t\t\t\t\t\tminMorphX += dx;\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tmaxMorphX += dx;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tif (dy < 0) {\n\t\t\t\t\t\t\t\tminMorphY += dy;\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tmaxMorphY += dy;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tif (dz < 0) {\n\t\t\t\t\t\t\t\tminMorphZ += dz;\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tmaxMorphZ += dz;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (bMin.x > minMorphX) bMin.x = minMorphX;\n\t\t\t\t\t\tif (bMin.y > minMorphY) bMin.y = minMorphY;\n\t\t\t\t\t\tif (bMin.z > minMorphZ) bMin.z = minMorphZ;\n\t\t\t\t\t\tif (bMax.x < maxMorphX) bMax.x = maxMorphX;\n\t\t\t\t\t\tif (bMax.y < maxMorphY) bMax.y = maxMorphY;\n\t\t\t\t\t\tif (bMax.z < maxMorphZ) bMax.z = maxMorphZ;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\titerator.next();\n\t\t}\n\t\tconst positionElement = this.vertexBuffer.getFormat().elements.find(e => e.name === SEMANTIC_POSITION);\n\t\tif (positionElement && positionElement.normalize) {\n\t\t\tconst func = (() => {\n\t\t\t\tswitch (positionElement.dataType) {\n\t\t\t\t\tcase TYPE_INT8:\n\t\t\t\t\t\treturn x => Math.max(x / 127.0, -1.0);\n\t\t\t\t\tcase TYPE_UINT8:\n\t\t\t\t\t\treturn x => x / 255.0;\n\t\t\t\t\tcase TYPE_INT16:\n\t\t\t\t\t\treturn x => Math.max(x / 32767.0, -1.0);\n\t\t\t\t\tcase TYPE_UINT16:\n\t\t\t\t\t\treturn x => x / 65535.0;\n\t\t\t\t\tdefault:\n\t\t\t\t\t\treturn x => x;\n\t\t\t\t}\n\t\t\t})();\n\t\t\tfor (let i = 0; i < numBones; i++) {\n\t\t\t\tif (boneUsed[i]) {\n\t\t\t\t\tconst min = boneMin[i];\n\t\t\t\t\tconst max = boneMax[i];\n\t\t\t\t\tmin.set(func(min.x), func(min.y), func(min.z));\n\t\t\t\t\tmax.set(func(max.x), func(max.y), func(max.z));\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tfor (let i = 0; i < numBones; i++) {\n\t\t\tconst aabb = new BoundingBox();\n\t\t\taabb.setMinMax(boneMin[i], boneMax[i]);\n\t\t\tthis.boneAabb.push(aabb);\n\t\t}\n\t}\n\t_initGeometryData() {\n\t\tif (!this._geometryData) {\n\t\t\tthis._geometryData = new GeometryData();\n\t\t\tif (this.vertexBuffer) {\n\t\t\t\tthis._geometryData.vertexCount = this.vertexBuffer.numVertices;\n\t\t\t\tthis._geometryData.maxVertices = this.vertexBuffer.numVertices;\n\t\t\t}\n\t\t\tif (this.indexBuffer.length > 0 && this.indexBuffer[0]) {\n\t\t\t\tthis._geometryData.indexCount = this.indexBuffer[0].numIndices;\n\t\t\t\tthis._geometryData.maxIndices = this.indexBuffer[0].numIndices;\n\t\t\t}\n\t\t}\n\t}\n\tclear(verticesDynamic, indicesDynamic, maxVertices = 0, maxIndices = 0) {\n\t\tthis._initGeometryData();\n\t\tthis._geometryData.initDefaults();\n\t\tthis._geometryData.recreate = true;\n\t\tthis._geometryData.maxVertices = maxVertices;\n\t\tthis._geometryData.maxIndices = maxIndices;\n\t\tthis._geometryData.verticesUsage = verticesDynamic ? BUFFER_STATIC : BUFFER_DYNAMIC;\n\t\tthis._geometryData.indicesUsage = indicesDynamic ? BUFFER_STATIC : BUFFER_DYNAMIC;\n\t}\n\tsetVertexStream(semantic, data, componentCount, numVertices, dataType = TYPE_FLOAT32, dataTypeNormalize = false, asInt = false) {\n\t\tthis._initGeometryData();\n\t\tconst vertexCount = numVertices || data.length / componentCount;\n\t\tthis._geometryData._changeVertexCount(vertexCount, semantic);\n\t\tthis._geometryData.vertexStreamsUpdated = true;\n\t\tthis._geometryData.vertexStreamDictionary[semantic] = new GeometryVertexStream(data, componentCount, dataType, dataTypeNormalize, asInt);\n\t}\n\tgetVertexStream(semantic, data) {\n\t\tlet count = 0;\n\t\tlet done = false;\n\t\tif (this._geometryData) {\n\t\t\tconst stream = this._geometryData.vertexStreamDictionary[semantic];\n\t\t\tif (stream) {\n\t\t\t\tdone = true;\n\t\t\t\tcount = this._geometryData.vertexCount;\n\t\t\t\tif (ArrayBuffer.isView(data)) {\n\t\t\t\t\tdata.set(stream.data);\n\t\t\t\t} else {\n\t\t\t\t\tdata.length = 0;\n\t\t\t\t\tdata.push(stream.data);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (!done) {\n\t\t\tif (this.vertexBuffer) {\n\t\t\t\tconst iterator = new VertexIterator(this.vertexBuffer);\n\t\t\t\tcount = iterator.readData(semantic, data);\n\t\t\t}\n\t\t}\n\t\treturn count;\n\t}\n\tsetPositions(positions, componentCount = GeometryData.DEFAULT_COMPONENTS_POSITION, numVertices) {\n\t\tthis.setVertexStream(SEMANTIC_POSITION, positions, componentCount, numVertices, TYPE_FLOAT32, false);\n\t}\n\tsetNormals(normals, componentCount = GeometryData.DEFAULT_COMPONENTS_NORMAL, numVertices) {\n\t\tthis.setVertexStream(SEMANTIC_NORMAL, normals, componentCount, numVertices, TYPE_FLOAT32, false);\n\t}\n\tsetUvs(channel, uvs, componentCount = GeometryData.DEFAULT_COMPONENTS_UV, numVertices) {\n\t\tthis.setVertexStream(SEMANTIC_TEXCOORD + channel, uvs, componentCount, numVertices, TYPE_FLOAT32, false);\n\t}\n\tsetColors(colors, componentCount = GeometryData.DEFAULT_COMPONENTS_COLORS, numVertices) {\n\t\tthis.setVertexStream(SEMANTIC_COLOR, colors, componentCount, numVertices, TYPE_FLOAT32, false);\n\t}\n\tsetColors32(colors, numVertices) {\n\t\tthis.setVertexStream(SEMANTIC_COLOR, colors, GeometryData.DEFAULT_COMPONENTS_COLORS, numVertices, TYPE_UINT8, true);\n\t}\n\tsetIndices(indices, numIndices) {\n\t\tthis._initGeometryData();\n\t\tthis._geometryData.indexStreamUpdated = true;\n\t\tthis._geometryData.indices = indices;\n\t\tthis._geometryData.indexCount = numIndices || indices.length;\n\t}\n\tgetPositions(positions) {\n\t\treturn this.getVertexStream(SEMANTIC_POSITION, positions);\n\t}\n\tgetNormals(normals) {\n\t\treturn this.getVertexStream(SEMANTIC_NORMAL, normals);\n\t}\n\tgetUvs(channel, uvs) {\n\t\treturn this.getVertexStream(SEMANTIC_TEXCOORD + channel, uvs);\n\t}\n\tgetColors(colors) {\n\t\treturn this.getVertexStream(SEMANTIC_COLOR, colors);\n\t}\n\tgetIndices(indices) {\n\t\tlet count = 0;\n\t\tif (this._geometryData && this._geometryData.indices) {\n\t\t\tconst streamIndices = this._geometryData.indices;\n\t\t\tcount = this._geometryData.indexCount;\n\t\t\tif (ArrayBuffer.isView(indices)) {\n\t\t\t\tindices.set(streamIndices);\n\t\t\t} else {\n\t\t\t\tindices.length = 0;\n\t\t\t\tfor (let i = 0, il = streamIndices.length; i < il; i++) {\n\t\t\t\t\tindices.push(streamIndices[i]);\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tif (this.indexBuffer.length > 0 && this.indexBuffer[0]) {\n\t\t\t\tconst indexBuffer = this.indexBuffer[0];\n\t\t\t\tcount = indexBuffer.readData(indices);\n\t\t\t}\n\t\t}\n\t\treturn count;\n\t}\n\tupdate(primitiveType = PRIMITIVE_TRIANGLES, updateBoundingBox = true) {\n\t\tif (this._geometryData) {\n\t\t\tif (updateBoundingBox) {\n\t\t\t\tconst stream = this._geometryData.vertexStreamDictionary[SEMANTIC_POSITION];\n\t\t\t\tif (stream) {\n\t\t\t\t\tif (stream.componentCount === 3) {\n\t\t\t\t\t\tthis._aabb.compute(stream.data, this._geometryData.vertexCount);\n\t\t\t\t\t\tthis._aabbVer++;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tlet destroyVB = this._geometryData.recreate;\n\t\t\tif (this._geometryData.vertexCount > this._geometryData.maxVertices) {\n\t\t\t\tdestroyVB = true;\n\t\t\t\tthis._geometryData.maxVertices = this._geometryData.vertexCount;\n\t\t\t}\n\t\t\tif (destroyVB) {\n\t\t\t\tif (this.vertexBuffer) {\n\t\t\t\t\tthis.vertexBuffer.destroy();\n\t\t\t\t\tthis.vertexBuffer = null;\n\t\t\t\t}\n\t\t\t}\n\t\t\tlet destroyIB = this._geometryData.recreate;\n\t\t\tif (this._geometryData.indexCount > this._geometryData.maxIndices) {\n\t\t\t\tdestroyIB = true;\n\t\t\t\tthis._geometryData.maxIndices = this._geometryData.indexCount;\n\t\t\t}\n\t\t\tif (destroyIB) {\n\t\t\t\tif (this.indexBuffer.length > 0 && this.indexBuffer[0]) {\n\t\t\t\t\tthis.indexBuffer[0].destroy();\n\t\t\t\t\tthis.indexBuffer[0] = null;\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (this._geometryData.vertexStreamsUpdated) {\n\t\t\t\tthis._updateVertexBuffer();\n\t\t\t}\n\t\t\tif (this._geometryData.indexStreamUpdated) {\n\t\t\t\tthis._updateIndexBuffer();\n\t\t\t}\n\t\t\tthis.primitive[0].type = primitiveType;\n\t\t\tif (this.indexBuffer.length > 0 && this.indexBuffer[0]) {\n\t\t\t\tif (this._geometryData.indexStreamUpdated) {\n\t\t\t\t\tthis.primitive[0].count = this._geometryData.indexCount;\n\t\t\t\t\tthis.primitive[0].indexed = true;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tif (this._geometryData.vertexStreamsUpdated) {\n\t\t\t\t\tthis.primitive[0].count = this._geometryData.vertexCount;\n\t\t\t\t\tthis.primitive[0].indexed = false;\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis._geometryData.vertexCount = 0;\n\t\t\tthis._geometryData.indexCount = 0;\n\t\t\tthis._geometryData.vertexStreamsUpdated = false;\n\t\t\tthis._geometryData.indexStreamUpdated = false;\n\t\t\tthis._geometryData.recreate = false;\n\t\t\tthis.updateRenderStates();\n\t\t}\n\t}\n\t_buildVertexFormat(vertexCount) {\n\t\tconst vertexDesc = [];\n\t\tfor (const semantic in this._geometryData.vertexStreamDictionary) {\n\t\t\tconst stream = this._geometryData.vertexStreamDictionary[semantic];\n\t\t\tvertexDesc.push({\n\t\t\t\tsemantic: semantic,\n\t\t\t\tcomponents: stream.componentCount,\n\t\t\t\ttype: stream.dataType,\n\t\t\t\tnormalize: stream.dataTypeNormalize,\n\t\t\t\tasInt: stream.asInt\n\t\t\t});\n\t\t}\n\t\treturn new VertexFormat(this.device, vertexDesc, vertexCount);\n\t}\n\t_updateVertexBuffer() {\n\t\tif (!this.vertexBuffer) {\n\t\t\tconst allocateVertexCount = this._geometryData.maxVertices;\n\t\t\tconst format = this._buildVertexFormat(allocateVertexCount);\n\t\t\tthis.vertexBuffer = new VertexBuffer(this.device, format, allocateVertexCount, {\n\t\t\t\tusage: this._geometryData.verticesUsage,\n\t\t\t\tstorage: this._storageVertex\n\t\t\t});\n\t\t}\n\t\tconst iterator = new VertexIterator(this.vertexBuffer);\n\t\tconst numVertices = this._geometryData.vertexCount;\n\t\tfor (const semantic in this._geometryData.vertexStreamDictionary) {\n\t\t\tconst stream = this._geometryData.vertexStreamDictionary[semantic];\n\t\t\titerator.writeData(semantic, stream.data, numVertices);\n\t\t\tdelete this._geometryData.vertexStreamDictionary[semantic];\n\t\t}\n\t\titerator.end();\n\t}\n\t_updateIndexBuffer() {\n\t\tif (this.indexBuffer.length <= 0 || !this.indexBuffer[0]) {\n\t\t\tconst maxVertices = this._geometryData.maxVertices;\n\t\t\tconst createFormat = maxVertices > 0xffff || maxVertices === 0 ? INDEXFORMAT_UINT32 : INDEXFORMAT_UINT16;\n\t\t\tconst options = this._storageIndex ? {\n\t\t\t\tstorage: true\n\t\t\t} : undefined;\n\t\t\tthis.indexBuffer[0] = new IndexBuffer(this.device, createFormat, this._geometryData.maxIndices, this._geometryData.indicesUsage, undefined, options);\n\t\t}\n\t\tconst srcIndices = this._geometryData.indices;\n\t\tif (srcIndices) {\n\t\t\tconst indexBuffer = this.indexBuffer[0];\n\t\t\tindexBuffer.writeData(srcIndices, this._geometryData.indexCount);\n\t\t\tthis._geometryData.indices = null;\n\t\t}\n\t}\n\tprepareRenderState(renderStyle) {\n\t\tif (renderStyle === RENDERSTYLE_WIREFRAME) {\n\t\t\tthis.generateWireframe();\n\t\t} else if (renderStyle === RENDERSTYLE_POINTS) {\n\t\t\tthis.primitive[RENDERSTYLE_POINTS] = {\n\t\t\t\ttype: PRIMITIVE_POINTS,\n\t\t\t\tbase: 0,\n\t\t\t\tcount: this.vertexBuffer ? this.vertexBuffer.numVertices : 0,\n\t\t\t\tindexed: false\n\t\t\t};\n\t\t}\n\t}\n\tupdateRenderStates() {\n\t\tif (this.primitive[RENDERSTYLE_POINTS]) {\n\t\t\tthis.prepareRenderState(RENDERSTYLE_POINTS);\n\t\t}\n\t\tif (this.primitive[RENDERSTYLE_WIREFRAME]) {\n\t\t\tthis.prepareRenderState(RENDERSTYLE_WIREFRAME);\n\t\t}\n\t}\n\tgenerateWireframe() {\n\t\tthis._destroyIndexBuffer(RENDERSTYLE_WIREFRAME);\n\t\tconst numVertices = this.vertexBuffer.numVertices;\n\t\tconst lines = [];\n\t\tlet format;\n\t\tif (this.indexBuffer.length > 0 && this.indexBuffer[0]) {\n\t\t\tconst offsets = [[0, 1], [1, 2], [2, 0]];\n\t\t\tconst base = this.primitive[RENDERSTYLE_SOLID].base;\n\t\t\tconst count = this.primitive[RENDERSTYLE_SOLID].count;\n\t\t\tconst indexBuffer = this.indexBuffer[RENDERSTYLE_SOLID];\n\t\t\tconst srcIndices = new typedArrayIndexFormats[indexBuffer.format](indexBuffer.storage);\n\t\t\tconst seen = new Set();\n\t\t\tfor (let j = base; j < base + count; j += 3) {\n\t\t\t\tfor (let k = 0; k < 3; k++) {\n\t\t\t\t\tconst i1 = srcIndices[j + offsets[k][0]];\n\t\t\t\t\tconst i2 = srcIndices[j + offsets[k][1]];\n\t\t\t\t\tconst hash = i1 > i2 ? i2 * numVertices + i1 : i1 * numVertices + i2;\n\t\t\t\t\tif (!seen.has(hash)) {\n\t\t\t\t\t\tseen.add(hash);\n\t\t\t\t\t\tlines.push(i1, i2);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tformat = indexBuffer.format;\n\t\t} else {\n\t\t\tfor (let i = 0; i < numVertices; i += 3) {\n\t\t\t\tlines.push(i, i + 1, i + 1, i + 2, i + 2, i);\n\t\t\t}\n\t\t\tformat = lines.length > 65535 ? INDEXFORMAT_UINT32 : INDEXFORMAT_UINT16;\n\t\t}\n\t\tconst wireBuffer = new IndexBuffer(this.vertexBuffer.device, format, lines.length);\n\t\tconst dstIndices = new typedArrayIndexFormats[wireBuffer.format](wireBuffer.storage);\n\t\tdstIndices.set(lines);\n\t\twireBuffer.unlock();\n\t\tthis.primitive[RENDERSTYLE_WIREFRAME] = {\n\t\t\ttype: PRIMITIVE_LINES,\n\t\t\tbase: 0,\n\t\t\tcount: lines.length,\n\t\t\tindexed: true\n\t\t};\n\t\tthis.indexBuffer[RENDERSTYLE_WIREFRAME] = wireBuffer;\n\t}\n}\n\nexport { Mesh };\n", "import { EventHandler } from '../core/event-handler.js';\nimport { Tags } from '../core/tags.js';\nimport { Mat3 } from '../core/math/mat3.js';\nimport { Mat4 } from '../core/math/mat4.js';\nimport { Quat } from '../core/math/quat.js';\nimport { Vec3 } from '../core/math/vec3.js';\n\nconst scaleCompensatePosTransform = new Mat4();\nconst scaleCompensatePos = new Vec3();\nconst scaleCompensateRot = new Quat();\nconst scaleCompensateRot2 = new Quat();\nconst scaleCompensateScale = new Vec3();\nconst scaleCompensateScaleForParent = new Vec3();\nconst tmpMat4 = new Mat4();\nconst tmpQuat = new Quat();\nconst position = new Vec3();\nconst invParentWtm = new Mat4();\nconst rotation = new Quat();\nconst invParentRot = new Quat();\nconst matrix = new Mat4();\nconst target = new Vec3();\nconst up = new Vec3();\nfunction createTest(attr, value) {\n\tif (attr instanceof Function) {\n\t\treturn attr;\n\t}\n\treturn node => {\n\t\tlet x = node[attr];\n\t\tif (x instanceof Function) {\n\t\t\tx = x();\n\t\t}\n\t\treturn x === value;\n\t};\n}\nfunction findNode(node, test) {\n\tif (test(node)) return node;\n\tconst children = node._children;\n\tconst len = children.length;\n\tfor (let i = 0; i < len; ++i) {\n\t\tconst result = findNode(children[i], test);\n\t\tif (result) return result;\n\t}\n\treturn null;\n}\nclass GraphNode extends EventHandler {\n\tconstructor(name = 'Untitled') {\n\t\tsuper();\n\t\tthis.name = void 0;\n\t\tthis.tags = new Tags(this);\n\t\tthis._labels = {};\n\t\tthis.localPosition = new Vec3();\n\t\tthis.localRotation = new Quat();\n\t\tthis.localScale = new Vec3(1, 1, 1);\n\t\tthis.localEulerAngles = new Vec3();\n\t\tthis.position = new Vec3();\n\t\tthis.rotation = new Quat();\n\t\tthis.eulerAngles = new Vec3();\n\t\tthis._scale = null;\n\t\tthis.localTransform = new Mat4();\n\t\tthis._dirtyLocal = false;\n\t\tthis._aabbVer = 0;\n\t\tthis._frozen = false;\n\t\tthis.worldTransform = new Mat4();\n\t\tthis._dirtyWorld = false;\n\t\tthis._worldScaleSign = 0;\n\t\tthis._normalMatrix = new Mat3();\n\t\tthis._dirtyNormal = true;\n\t\tthis._right = null;\n\t\tthis._up = null;\n\t\tthis._forward = null;\n\t\tthis._parent = null;\n\t\tthis._children = [];\n\t\tthis._graphDepth = 0;\n\t\tthis._enabled = true;\n\t\tthis._enabledInHierarchy = false;\n\t\tthis.scaleCompensation = false;\n\t\tthis.name = name;\n\t}\n\tget right() {\n\t\tif (!this._right) {\n\t\t\tthis._right = new Vec3();\n\t\t}\n\t\treturn this.getWorldTransform().getX(this._right).normalize();\n\t}\n\tget up() {\n\t\tif (!this._up) {\n\t\t\tthis._up = new Vec3();\n\t\t}\n\t\treturn this.getWorldTransform().getY(this._up).normalize();\n\t}\n\tget forward() {\n\t\tif (!this._forward) {\n\t\t\tthis._forward = new Vec3();\n\t\t}\n\t\treturn this.getWorldTransform().getZ(this._forward).normalize().mulScalar(-1);\n\t}\n\tget normalMatrix() {\n\t\tconst normalMat = this._normalMatrix;\n\t\tif (this._dirtyNormal) {\n\t\t\tnormalMat.invertMat4(this.getWorldTransform()).transpose();\n\t\t\tthis._dirtyNormal = false;\n\t\t}\n\t\treturn normalMat;\n\t}\n\tset enabled(enabled) {\n\t\tif (this._enabled !== enabled) {\n\t\t\tvar _this$_parent;\n\t\t\tthis._enabled = enabled;\n\t\t\tif (enabled && (_this$_parent = this._parent) != null && _this$_parent.enabled || !enabled) {\n\t\t\t\tthis._notifyHierarchyStateChanged(this, enabled);\n\t\t\t}\n\t\t}\n\t}\n\tget enabled() {\n\t\treturn this._enabled && this._enabledInHierarchy;\n\t}\n\tget parent() {\n\t\treturn this._parent;\n\t}\n\tget path() {\n\t\tlet node = this._parent;\n\t\tif (!node) {\n\t\t\treturn '';\n\t\t}\n\t\tlet result = this.name;\n\t\twhile (node && node._parent) {\n\t\t\tresult = `${node.name}/${result}`;\n\t\t\tnode = node._parent;\n\t\t}\n\t\treturn result;\n\t}\n\tget root() {\n\t\tlet result = this;\n\t\twhile (result._parent) {\n\t\t\tresult = result._parent;\n\t\t}\n\t\treturn result;\n\t}\n\tget children() {\n\t\treturn this._children;\n\t}\n\tget graphDepth() {\n\t\treturn this._graphDepth;\n\t}\n\t_notifyHierarchyStateChanged(node, enabled) {\n\t\tnode._onHierarchyStateChanged(enabled);\n\t\tconst c = node._children;\n\t\tfor (let i = 0, len = c.length; i < len; i++) {\n\t\t\tif (c[i]._enabled) this._notifyHierarchyStateChanged(c[i], enabled);\n\t\t}\n\t}\n\t_onHierarchyStateChanged(enabled) {\n\t\tthis._enabledInHierarchy = enabled;\n\t\tif (enabled && !this._frozen) this._unfreezeParentToRoot();\n\t}\n\t_cloneInternal(clone) {\n\t\tclone.name = this.name;\n\t\tconst tags = this.tags._list;\n\t\tclone.tags.clear();\n\t\tfor (let i = 0; i < tags.length; i++) clone.tags.add(tags[i]);\n\t\tclone._labels = Object.assign({}, this._labels);\n\t\tclone.localPosition.copy(this.localPosition);\n\t\tclone.localRotation.copy(this.localRotation);\n\t\tclone.localScale.copy(this.localScale);\n\t\tclone.localEulerAngles.copy(this.localEulerAngles);\n\t\tclone.position.copy(this.position);\n\t\tclone.rotation.copy(this.rotation);\n\t\tclone.eulerAngles.copy(this.eulerAngles);\n\t\tclone.localTransform.copy(this.localTransform);\n\t\tclone._dirtyLocal = this._dirtyLocal;\n\t\tclone.worldTransform.copy(this.worldTransform);\n\t\tclone._dirtyWorld = this._dirtyWorld;\n\t\tclone._dirtyNormal = this._dirtyNormal;\n\t\tclone._aabbVer = this._aabbVer + 1;\n\t\tclone._enabled = this._enabled;\n\t\tclone.scaleCompensation = this.scaleCompensation;\n\t\tclone._enabledInHierarchy = false;\n\t}\n\tclone() {\n\t\tconst clone = new this.constructor();\n\t\tthis._cloneInternal(clone);\n\t\treturn clone;\n\t}\n\tcopy(source) {\n\t\tsource._cloneInternal(this);\n\t\treturn this;\n\t}\n\tdestroy() {\n\t\tthis.remove();\n\t\tconst children = this._children;\n\t\twhile (children.length) {\n\t\t\tconst child = children.pop();\n\t\t\tchild._parent = null;\n\t\t\tchild.destroy();\n\t\t}\n\t\tthis.fire('destroy', this);\n\t\tthis.off();\n\t}\n\tfind(attr, value) {\n\t\tconst results = [];\n\t\tconst test = createTest(attr, value);\n\t\tthis.forEach(node => {\n\t\t\tif (test(node)) results.push(node);\n\t\t});\n\t\treturn results;\n\t}\n\tfindOne(attr, value) {\n\t\tconst test = createTest(attr, value);\n\t\treturn findNode(this, test);\n\t}\n\tfindByTag() {\n\t\tconst query = arguments;\n\t\tconst results = [];\n\t\tconst queryNode = (node, checkNode) => {\n\t\t\tif (checkNode && node.tags.has(...query)) {\n\t\t\t\tresults.push(node);\n\t\t\t}\n\t\t\tfor (let i = 0; i < node._children.length; i++) {\n\t\t\t\tqueryNode(node._children[i], true);\n\t\t\t}\n\t\t};\n\t\tqueryNode(this, false);\n\t\treturn results;\n\t}\n\tfindByName(name) {\n\t\treturn this.findOne('name', name);\n\t}\n\tfindByPath(path) {\n\t\tconst parts = Array.isArray(path) ? path : path.split('/');\n\t\tlet result = this;\n\t\tfor (let i = 0, imax = parts.length; i < imax; ++i) {\n\t\t\tresult = result.children.find(c => c.name === parts[i]);\n\t\t\tif (!result) {\n\t\t\t\treturn null;\n\t\t\t}\n\t\t}\n\t\treturn result;\n\t}\n\tforEach(callback, thisArg) {\n\t\tcallback.call(thisArg, this);\n\t\tconst children = this._children;\n\t\tconst len = children.length;\n\t\tfor (let i = 0; i < len; ++i) {\n\t\t\tchildren[i].forEach(callback, thisArg);\n\t\t}\n\t}\n\tisDescendantOf(node) {\n\t\tlet parent = this._parent;\n\t\twhile (parent) {\n\t\t\tif (parent === node) return true;\n\t\t\tparent = parent._parent;\n\t\t}\n\t\treturn false;\n\t}\n\tisAncestorOf(node) {\n\t\treturn node.isDescendantOf(this);\n\t}\n\tgetEulerAngles() {\n\t\tthis.getWorldTransform().getEulerAngles(this.eulerAngles);\n\t\treturn this.eulerAngles;\n\t}\n\tgetLocalEulerAngles() {\n\t\tthis.localRotation.getEulerAngles(this.localEulerAngles);\n\t\treturn this.localEulerAngles;\n\t}\n\tgetLocalPosition() {\n\t\treturn this.localPosition;\n\t}\n\tgetLocalRotation() {\n\t\treturn this.localRotation;\n\t}\n\tgetLocalScale() {\n\t\treturn this.localScale;\n\t}\n\tgetLocalTransform() {\n\t\tif (this._dirtyLocal) {\n\t\t\tthis.localTransform.setTRS(this.localPosition, this.localRotation, this.localScale);\n\t\t\tthis._dirtyLocal = false;\n\t\t}\n\t\treturn this.localTransform;\n\t}\n\tgetPosition() {\n\t\tthis.getWorldTransform().getTranslation(this.position);\n\t\treturn this.position;\n\t}\n\tgetRotation() {\n\t\tthis.rotation.setFromMat4(this.getWorldTransform());\n\t\treturn this.rotation;\n\t}\n\tgetScale() {\n\t\tif (!this._scale) {\n\t\t\tthis._scale = new Vec3();\n\t\t}\n\t\treturn this.getWorldTransform().getScale(this._scale);\n\t}\n\tgetWorldTransform() {\n\t\tif (!this._dirtyLocal && !this._dirtyWorld) return this.worldTransform;\n\t\tif (this._parent) this._parent.getWorldTransform();\n\t\tthis._sync();\n\t\treturn this.worldTransform;\n\t}\n\tget worldScaleSign() {\n\t\tif (this._worldScaleSign === 0) {\n\t\t\tthis._worldScaleSign = this.getWorldTransform().scaleSign;\n\t\t}\n\t\treturn this._worldScaleSign;\n\t}\n\tremove() {\n\t\tvar _this$_parent2;\n\t\t(_this$_parent2 = this._parent) == null || _this$_parent2.removeChild(this);\n\t}\n\treparent(parent, index) {\n\t\tthis.remove();\n\t\tif (parent) {\n\t\t\tif (index >= 0) {\n\t\t\t\tparent.insertChild(this, index);\n\t\t\t} else {\n\t\t\t\tparent.addChild(this);\n\t\t\t}\n\t\t}\n\t}\n\tsetLocalEulerAngles(x, y, z) {\n\t\tthis.localRotation.setFromEulerAngles(x, y, z);\n\t\tif (!this._dirtyLocal) this._dirtifyLocal();\n\t}\n\tsetLocalPosition(x, y, z) {\n\t\tif (x instanceof Vec3) {\n\t\t\tthis.localPosition.copy(x);\n\t\t} else {\n\t\t\tthis.localPosition.set(x, y, z);\n\t\t}\n\t\tif (!this._dirtyLocal) this._dirtifyLocal();\n\t}\n\tsetLocalRotation(x, y, z, w) {\n\t\tif (x instanceof Quat) {\n\t\t\tthis.localRotation.copy(x);\n\t\t} else {\n\t\t\tthis.localRotation.set(x, y, z, w);\n\t\t}\n\t\tif (!this._dirtyLocal) this._dirtifyLocal();\n\t}\n\tsetLocalScale(x, y, z) {\n\t\tif (x instanceof Vec3) {\n\t\t\tthis.localScale.copy(x);\n\t\t} else {\n\t\t\tthis.localScale.set(x, y, z);\n\t\t}\n\t\tif (!this._dirtyLocal) this._dirtifyLocal();\n\t}\n\t_dirtifyLocal() {\n\t\tif (!this._dirtyLocal) {\n\t\t\tthis._dirtyLocal = true;\n\t\t\tif (!this._dirtyWorld) this._dirtifyWorld();\n\t\t}\n\t}\n\t_unfreezeParentToRoot() {\n\t\tlet p = this._parent;\n\t\twhile (p) {\n\t\t\tp._frozen = false;\n\t\t\tp = p._parent;\n\t\t}\n\t}\n\t_dirtifyWorld() {\n\t\tif (!this._dirtyWorld) this._unfreezeParentToRoot();\n\t\tthis._dirtifyWorldInternal();\n\t}\n\t_dirtifyWorldInternal() {\n\t\tif (!this._dirtyWorld) {\n\t\t\tthis._frozen = false;\n\t\t\tthis._dirtyWorld = true;\n\t\t\tfor (let i = 0; i < this._children.length; i++) {\n\t\t\t\tif (!this._children[i]._dirtyWorld) this._children[i]._dirtifyWorldInternal();\n\t\t\t}\n\t\t}\n\t\tthis._dirtyNormal = true;\n\t\tthis._worldScaleSign = 0;\n\t\tthis._aabbVer++;\n\t}\n\tsetPosition(x, y, z) {\n\t\tif (x instanceof Vec3) {\n\t\t\tposition.copy(x);\n\t\t} else {\n\t\t\tposition.set(x, y, z);\n\t\t}\n\t\tif (this._parent === null) {\n\t\t\tthis.localPosition.copy(position);\n\t\t} else {\n\t\t\tinvParentWtm.copy(this._parent.getWorldTransform()).invert();\n\t\t\tinvParentWtm.transformPoint(position, this.localPosition);\n\t\t}\n\t\tif (!this._dirtyLocal) this._dirtifyLocal();\n\t}\n\tsetRotation(x, y, z, w) {\n\t\tif (x instanceof Quat) {\n\t\t\trotation.copy(x);\n\t\t} else {\n\t\t\trotation.set(x, y, z, w);\n\t\t}\n\t\tif (this._parent === null) {\n\t\t\tthis.localRotation.copy(rotation);\n\t\t} else {\n\t\t\tconst parentRot = this._parent.getRotation();\n\t\t\tinvParentRot.copy(parentRot).invert();\n\t\t\tthis.localRotation.copy(invParentRot).mul(rotation);\n\t\t}\n\t\tif (!this._dirtyLocal) this._dirtifyLocal();\n\t}\n\tsetEulerAngles(x, y, z) {\n\t\tthis.localRotation.setFromEulerAngles(x, y, z);\n\t\tif (this._parent !== null) {\n\t\t\tconst parentRot = this._parent.getRotation();\n\t\t\tinvParentRot.copy(parentRot).invert();\n\t\t\tthis.localRotation.mul2(invParentRot, this.localRotation);\n\t\t}\n\t\tif (!this._dirtyLocal) this._dirtifyLocal();\n\t}\n\taddChild(node) {\n\t\tthis._prepareInsertChild(node);\n\t\tthis._children.push(node);\n\t\tthis._onInsertChild(node);\n\t}\n\taddChildAndSaveTransform(node) {\n\t\tconst wPos = node.getPosition();\n\t\tconst wRot = node.getRotation();\n\t\tthis._prepareInsertChild(node);\n\t\tnode.setPosition(tmpMat4.copy(this.worldTransform).invert().transformPoint(wPos));\n\t\tnode.setRotation(tmpQuat.copy(this.getRotation()).invert().mul(wRot));\n\t\tthis._children.push(node);\n\t\tthis._onInsertChild(node);\n\t}\n\tinsertChild(node, index) {\n\t\tthis._prepareInsertChild(node);\n\t\tthis._children.splice(index, 0, node);\n\t\tthis._onInsertChild(node);\n\t}\n\t_prepareInsertChild(node) {\n\t\tnode.remove();\n\t}\n\t_fireOnHierarchy(name, nameHierarchy, parent) {\n\t\tthis.fire(name, parent);\n\t\tfor (let i = 0; i < this._children.length; i++) {\n\t\t\tthis._children[i]._fireOnHierarchy(nameHierarchy, nameHierarchy, parent);\n\t\t}\n\t}\n\t_onInsertChild(node) {\n\t\tnode._parent = this;\n\t\tconst enabledInHierarchy = node._enabled && this.enabled;\n\t\tif (node._enabledInHierarchy !== enabledInHierarchy) {\n\t\t\tnode._enabledInHierarchy = enabledInHierarchy;\n\t\t\tnode._notifyHierarchyStateChanged(node, enabledInHierarchy);\n\t\t}\n\t\tnode._updateGraphDepth();\n\t\tnode._dirtifyWorld();\n\t\tif (this._frozen) node._unfreezeParentToRoot();\n\t\tnode._fireOnHierarchy('insert', 'inserthierarchy', this);\n\t\tif (this.fire) this.fire('childinsert', node);\n\t}\n\t_updateGraphDepth() {\n\t\tthis._graphDepth = this._parent ? this._parent._graphDepth + 1 : 0;\n\t\tfor (let i = 0, len = this._children.length; i < len; i++) {\n\t\t\tthis._children[i]._updateGraphDepth();\n\t\t}\n\t}\n\tremoveChild(child) {\n\t\tconst index = this._children.indexOf(child);\n\t\tif (index === -1) {\n\t\t\treturn;\n\t\t}\n\t\tthis._children.splice(index, 1);\n\t\tchild._parent = null;\n\t\tchild._fireOnHierarchy('remove', 'removehierarchy', this);\n\t\tthis.fire('childremove', child);\n\t}\n\t_sync() {\n\t\tif (this._dirtyLocal) {\n\t\t\tthis.localTransform.setTRS(this.localPosition, this.localRotation, this.localScale);\n\t\t\tthis._dirtyLocal = false;\n\t\t}\n\t\tif (this._dirtyWorld) {\n\t\t\tif (this._parent === null) {\n\t\t\t\tthis.worldTransform.copy(this.localTransform);\n\t\t\t} else {\n\t\t\t\tif (this.scaleCompensation) {\n\t\t\t\t\tlet parentWorldScale;\n\t\t\t\t\tconst parent = this._parent;\n\t\t\t\t\tlet scale = this.localScale;\n\t\t\t\t\tlet parentToUseScaleFrom = parent;\n\t\t\t\t\tif (parentToUseScaleFrom) {\n\t\t\t\t\t\twhile (parentToUseScaleFrom && parentToUseScaleFrom.scaleCompensation) {\n\t\t\t\t\t\t\tparentToUseScaleFrom = parentToUseScaleFrom._parent;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (parentToUseScaleFrom) {\n\t\t\t\t\t\t\tparentToUseScaleFrom = parentToUseScaleFrom._parent;\n\t\t\t\t\t\t\tif (parentToUseScaleFrom) {\n\t\t\t\t\t\t\t\tparentWorldScale = parentToUseScaleFrom.worldTransform.getScale();\n\t\t\t\t\t\t\t\tscaleCompensateScale.mul2(parentWorldScale, this.localScale);\n\t\t\t\t\t\t\t\tscale = scaleCompensateScale;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tscaleCompensateRot2.setFromMat4(parent.worldTransform);\n\t\t\t\t\tscaleCompensateRot.mul2(scaleCompensateRot2, this.localRotation);\n\t\t\t\t\tlet tmatrix = parent.worldTransform;\n\t\t\t\t\tif (parent.scaleCompensation) {\n\t\t\t\t\t\tscaleCompensateScaleForParent.mul2(parentWorldScale, parent.getLocalScale());\n\t\t\t\t\t\tscaleCompensatePosTransform.setTRS(parent.worldTransform.getTranslation(scaleCompensatePos), scaleCompensateRot2, scaleCompensateScaleForParent);\n\t\t\t\t\t\ttmatrix = scaleCompensatePosTransform;\n\t\t\t\t\t}\n\t\t\t\t\ttmatrix.transformPoint(this.localPosition, scaleCompensatePos);\n\t\t\t\t\tthis.worldTransform.setTRS(scaleCompensatePos, scaleCompensateRot, scale);\n\t\t\t\t} else {\n\t\t\t\t\tthis.worldTransform.mulAffine2(this._parent.worldTransform, this.localTransform);\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis._dirtyWorld = false;\n\t\t}\n\t}\n\tsyncHierarchy() {\n\t\tif (!this._enabled) return;\n\t\tif (this._frozen) return;\n\t\tthis._frozen = true;\n\t\tif (this._dirtyLocal || this._dirtyWorld) {\n\t\t\tthis._sync();\n\t\t}\n\t\tconst children = this._children;\n\t\tfor (let i = 0, len = children.length; i < len; i++) {\n\t\t\tchildren[i].syncHierarchy();\n\t\t}\n\t}\n\tlookAt(x, y, z, ux = 0, uy = 1, uz = 0) {\n\t\tif (x instanceof Vec3) {\n\t\t\ttarget.copy(x);\n\t\t\tif (y instanceof Vec3) {\n\t\t\t\tup.copy(y);\n\t\t\t} else {\n\t\t\t\tup.copy(Vec3.UP);\n\t\t\t}\n\t\t} else if (z === undefined) {\n\t\t\treturn;\n\t\t} else {\n\t\t\ttarget.set(x, y, z);\n\t\t\tup.set(ux, uy, uz);\n\t\t}\n\t\tmatrix.setLookAt(this.getPosition(), target, up);\n\t\trotation.setFromMat4(matrix);\n\t\tthis.setRotation(rotation);\n\t}\n\ttranslate(x, y, z) {\n\t\tif (x instanceof Vec3) {\n\t\t\tposition.copy(x);\n\t\t} else {\n\t\t\tposition.set(x, y, z);\n\t\t}\n\t\tposition.add(this.getPosition());\n\t\tthis.setPosition(position);\n\t}\n\ttranslateLocal(x, y, z) {\n\t\tif (x instanceof Vec3) {\n\t\t\tposition.copy(x);\n\t\t} else {\n\t\t\tposition.set(x, y, z);\n\t\t}\n\t\tthis.localRotation.transformVector(position, position);\n\t\tthis.localPosition.add(position);\n\t\tif (!this._dirtyLocal) this._dirtifyLocal();\n\t}\n\trotate(x, y, z) {\n\t\trotation.setFromEulerAngles(x, y, z);\n\t\tif (this._parent === null) {\n\t\t\tthis.localRotation.mul2(rotation, this.localRotation);\n\t\t} else {\n\t\t\tconst rot = this.getRotation();\n\t\t\tconst parentRot = this._parent.getRotation();\n\t\t\tinvParentRot.copy(parentRot).invert();\n\t\t\trotation.mul2(invParentRot, rotation);\n\t\t\tthis.localRotation.mul2(rotation, rot);\n\t\t}\n\t\tif (!this._dirtyLocal) this._dirtifyLocal();\n\t}\n\trotateLocal(x, y, z) {\n\t\trotation.setFromEulerAngles(x, y, z);\n\t\tthis.localRotation.mul(rotation);\n\t\tif (!this._dirtyLocal) this._dirtifyLocal();\n\t}\n}\n\nexport { GraphNode };\n", "class RefCountedCache {\n\tconstructor() {\n\t\tthis.cache = new Map();\n\t}\n\tdestroy() {\n\t\tthis.cache.forEach((refCount, object) => {\n\t\t\tobject.destroy();\n\t\t});\n\t\tthis.cache.clear();\n\t}\n\tincRef(object) {\n\t\tconst refCount = (this.cache.get(object) || 0) + 1;\n\t\tthis.cache.set(object, refCount);\n\t}\n\tdecRef(object) {\n\t\tif (object) {\n\t\t\tlet refCount = this.cache.get(object);\n\t\t\tif (refCount) {\n\t\t\t\trefCount--;\n\t\t\t\tif (refCount === 0) {\n\t\t\t\t\tthis.cache.delete(object);\n\t\t\t\t\tobject.destroy();\n\t\t\t\t} else {\n\t\t\t\t\tthis.cache.set(object, refCount);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n\nexport { RefCountedCache };\n", "import { RefCountedCache } from '../../core/ref-counted-cache.js';\n\nclass LightmapCache {\n\tstatic incRef(texture) {\n\t\tthis.cache.incRef(texture);\n\t}\n\tstatic decRef(texture) {\n\t\tthis.cache.decRef(texture);\n\t}\n\tstatic destroy() {\n\t\tthis.cache.destroy();\n\t}\n}\nLightmapCache.cache = new RefCountedCache();\n\nexport { LightmapCache };\n", "import { BoundingBox } from '../core/shape/bounding-box.js';\nimport { BoundingSphere } from '../core/shape/bounding-sphere.js';\nimport { BindGroup } from '../platform/graphics/bind-group.js';\nimport { UniformBuffer } from '../platform/graphics/uniform-buffer.js';\nimport { MASK_AFFECT_DYNAMIC, SHADERDEF_UV0, SHADERDEF_UV1, SHADERDEF_VCOLOR, SHADERDEF_TANGENTS, LAYER_WORLD, RENDERSTYLE_SOLID, SHADERDEF_NOSHADOW, SHADERDEF_SKIN, SHADERDEF_MORPH_TEXTURE_BASED, SHADERDEF_MORPH_POSITION, SHADERDEF_MORPH_NORMAL, SHADERDEF_SCREENSPACE, SORTKEY_FORWARD, BLEND_NORMAL, BLEND_NONE, SHADERDEF_INSTANCING, MASK_AFFECT_LIGHTMAPPED, MASK_BAKE, SHADERDEF_LM, SHADERDEF_DIRLM, SHADERDEF_LMAMBIENT } from './constants.js';\nimport { GraphNode } from './graph-node.js';\nimport { getDefaultMaterial } from './materials/default-material.js';\nimport { LightmapCache } from './graphics/lightmap-cache.js';\n\nlet id = 0;\nconst _tmpAabb = new BoundingBox();\nconst _tempBoneAabb = new BoundingBox();\nconst _tempSphere = new BoundingSphere();\nconst _meshSet = new Set();\nclass InstancingData {\n\tconstructor(numObjects) {\n\t\tthis.vertexBuffer = null;\n\t\tthis.count = numObjects;\n\t}\n}\nclass ShaderInstance {\n\tconstructor() {\n\t\tthis.shader = void 0;\n\t\tthis.bindGroup = null;\n\t}\n\tgetBindGroup(device) {\n\t\tif (!this.bindGroup) {\n\t\t\tconst shader = this.shader;\n\t\t\tconst ubFormat = shader.meshUniformBufferFormat;\n\t\t\tconst uniformBuffer = new UniformBuffer(device, ubFormat, false);\n\t\t\tconst bindGroupFormat = shader.meshBindGroupFormat;\n\t\t\tthis.bindGroup = new BindGroup(device, bindGroupFormat, uniformBuffer);\n\t\t}\n\t\treturn this.bindGroup;\n\t}\n\tdestroy() {\n\t\tconst group = this.bindGroup;\n\t\tif (group) {\n\t\t\tvar _group$defaultUniform;\n\t\t\t(_group$defaultUniform = group.defaultUniformBuffer) == null || _group$defaultUniform.destroy();\n\t\t\tgroup.destroy();\n\t\t\tthis.bindGroup = null;\n\t\t}\n\t}\n}\nclass ShaderCacheEntry {\n\tconstructor() {\n\t\tthis.shaderInstances = new Map();\n\t}\n\tdestroy() {\n\t\tthis.shaderInstances.forEach(instance => instance.destroy());\n\t\tthis.shaderInstances.clear();\n\t}\n}\nclass MeshInstance {\n\tconstructor(mesh, material, node = null) {\n\t\tthis.visible = true;\n\t\tthis.castShadow = false;\n\t\tthis.transparent = false;\n\t\tthis._material = null;\n\t\tthis._shaderCache = [];\n\t\tthis.id = id++;\n\t\tthis.pick = true;\n\t\tif (mesh instanceof GraphNode) {\n\t\t\tconst temp = mesh;\n\t\t\tmesh = material;\n\t\t\tmaterial = node;\n\t\t\tnode = temp;\n\t\t}\n\t\tthis._key = [0, 0];\n\t\tthis.node = node;\n\t\tthis._mesh = mesh;\n\t\tmesh.incRefCount();\n\t\tthis.material = material;\n\t\tthis._shaderDefs = MASK_AFFECT_DYNAMIC << 16;\n\t\tif (mesh.vertexBuffer) {\n\t\t\tconst format = mesh.vertexBuffer.format;\n\t\t\tthis._shaderDefs |= format.hasUv0 ? SHADERDEF_UV0 : 0;\n\t\t\tthis._shaderDefs |= format.hasUv1 ? SHADERDEF_UV1 : 0;\n\t\t\tthis._shaderDefs |= format.hasColor ? SHADERDEF_VCOLOR : 0;\n\t\t\tthis._shaderDefs |= format.hasTangents ? SHADERDEF_TANGENTS : 0;\n\t\t}\n\t\tthis.layer = LAYER_WORLD;\n\t\tthis._renderStyle = RENDERSTYLE_SOLID;\n\t\tthis._receiveShadow = true;\n\t\tthis._screenSpace = false;\n\t\tthis.cull = true;\n\t\tthis._updateAabb = true;\n\t\tthis._updateAabbFunc = null;\n\t\tthis._calculateSortDistance = null;\n\t\tthis.updateKey();\n\t\tthis._skinInstance = null;\n\t\tthis._morphInstance = null;\n\t\tthis.gsplatInstance = null;\n\t\tthis.instancingData = null;\n\t\tthis._customAabb = null;\n\t\tthis.aabb = new BoundingBox();\n\t\tthis._aabbVer = -1;\n\t\tthis._aabbMeshVer = -1;\n\t\tthis.drawOrder = 0;\n\t\tthis.visibleThisFrame = false;\n\t\tthis.isVisibleFunc = null;\n\t\tthis.parameters = {};\n\t\tthis.stencilFront = null;\n\t\tthis.stencilBack = null;\n\t\tthis.flipFacesFactor = 1;\n\t}\n\tset renderStyle(renderStyle) {\n\t\tthis._renderStyle = renderStyle;\n\t\tthis.mesh.prepareRenderState(renderStyle);\n\t}\n\tget renderStyle() {\n\t\treturn this._renderStyle;\n\t}\n\tset mesh(mesh) {\n\t\tif (mesh === this._mesh) return;\n\t\tif (this._mesh) {\n\t\t\tthis._mesh.decRefCount();\n\t\t}\n\t\tthis._mesh = mesh;\n\t\tif (mesh) {\n\t\t\tmesh.incRefCount();\n\t\t}\n\t}\n\tget mesh() {\n\t\treturn this._mesh;\n\t}\n\tset aabb(aabb) {\n\t\tthis._aabb = aabb;\n\t}\n\tget aabb() {\n\t\tif (!this._updateAabb) {\n\t\t\treturn this._aabb;\n\t\t}\n\t\tif (this._updateAabbFunc) {\n\t\t\treturn this._updateAabbFunc(this._aabb);\n\t\t}\n\t\tlet localAabb = this._customAabb;\n\t\tlet toWorldSpace = !!localAabb;\n\t\tif (!localAabb) {\n\t\t\tlocalAabb = _tmpAabb;\n\t\t\tif (this.skinInstance) {\n\t\t\t\tif (!this.mesh.boneAabb) {\n\t\t\t\t\tconst morphTargets = this._morphInstance ? this._morphInstance.morph._targets : null;\n\t\t\t\t\tthis.mesh._initBoneAabbs(morphTargets);\n\t\t\t\t}\n\t\t\t\tconst boneUsed = this.mesh.boneUsed;\n\t\t\t\tlet first = true;\n\t\t\t\tfor (let i = 0; i < this.mesh.boneAabb.length; i++) {\n\t\t\t\t\tif (boneUsed[i]) {\n\t\t\t\t\t\t_tempBoneAabb.setFromTransformedAabb(this.mesh.boneAabb[i], this.skinInstance.matrices[i]);\n\t\t\t\t\t\tif (first) {\n\t\t\t\t\t\t\tfirst = false;\n\t\t\t\t\t\t\tlocalAabb.center.copy(_tempBoneAabb.center);\n\t\t\t\t\t\t\tlocalAabb.halfExtents.copy(_tempBoneAabb.halfExtents);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tlocalAabb.add(_tempBoneAabb);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\ttoWorldSpace = true;\n\t\t\t} else if (this.node._aabbVer !== this._aabbVer || this.mesh._aabbVer !== this._aabbMeshVer) {\n\t\t\t\tif (this.mesh) {\n\t\t\t\t\tlocalAabb.center.copy(this.mesh.aabb.center);\n\t\t\t\t\tlocalAabb.halfExtents.copy(this.mesh.aabb.halfExtents);\n\t\t\t\t} else {\n\t\t\t\t\tlocalAabb.center.set(0, 0, 0);\n\t\t\t\t\tlocalAabb.halfExtents.set(0, 0, 0);\n\t\t\t\t}\n\t\t\t\tif (this.mesh && this.mesh.morph) {\n\t\t\t\t\tconst morphAabb = this.mesh.morph.aabb;\n\t\t\t\t\tlocalAabb._expand(morphAabb.getMin(), morphAabb.getMax());\n\t\t\t\t}\n\t\t\t\ttoWorldSpace = true;\n\t\t\t\tthis._aabbVer = this.node._aabbVer;\n\t\t\t\tthis._aabbMeshVer = this.mesh._aabbVer;\n\t\t\t}\n\t\t}\n\t\tif (toWorldSpace) {\n\t\t\tthis._aabb.setFromTransformedAabb(localAabb, this.node.getWorldTransform());\n\t\t}\n\t\treturn this._aabb;\n\t}\n\tclearShaders() {\n\t\tconst shaderCache = this._shaderCache;\n\t\tfor (let i = 0; i < shaderCache.length; i++) {\n\t\t\tvar _shaderCache$i;\n\t\t\t(_shaderCache$i = shaderCache[i]) == null || _shaderCache$i.destroy();\n\t\t\tshaderCache[i] = null;\n\t\t}\n\t}\n\tgetShaderInstance(shaderPass, lightHash, scene, viewUniformFormat, viewBindGroupFormat, sortedLights) {\n\t\tlet shaderInstance;\n\t\tlet passEntry = this._shaderCache[shaderPass];\n\t\tif (passEntry) {\n\t\t\tshaderInstance = passEntry.shaderInstances.get(lightHash);\n\t\t} else {\n\t\t\tpassEntry = new ShaderCacheEntry();\n\t\t\tthis._shaderCache[shaderPass] = passEntry;\n\t\t}\n\t\tif (!shaderInstance) {\n\t\t\tconst mat = this._material;\n\t\t\tconst shaderDefs = this._shaderDefs;\n\t\t\tconst variantKey = shaderPass + '_' + shaderDefs + '_' + lightHash;\n\t\t\tshaderInstance = new ShaderInstance();\n\t\t\tshaderInstance.shader = mat.variants.get(variantKey);\n\t\t\tif (!shaderInstance.shader) {\n\t\t\t\tvar _this$_mesh$vertexBuf;\n\t\t\t\tconst shader = mat.getShaderVariant(this.mesh.device, scene, shaderDefs, null, shaderPass, sortedLights, viewUniformFormat, viewBindGroupFormat, (_this$_mesh$vertexBuf = this._mesh.vertexBuffer) == null ? void 0 : _this$_mesh$vertexBuf.format);\n\t\t\t\tmat.variants.set(variantKey, shader);\n\t\t\t\tshaderInstance.shader = shader;\n\t\t\t}\n\t\t\tpassEntry.shaderInstances.set(lightHash, shaderInstance);\n\t\t}\n\t\treturn shaderInstance;\n\t}\n\tset material(material) {\n\t\tthis.clearShaders();\n\t\tconst prevMat = this._material;\n\t\tif (prevMat) {\n\t\t\tprevMat.removeMeshInstanceRef(this);\n\t\t}\n\t\tthis._material = material;\n\t\tif (material) {\n\t\t\tmaterial.addMeshInstanceRef(this);\n\t\t\tthis.transparent = material.transparent;\n\t\t\tthis.updateKey();\n\t\t}\n\t}\n\tget material() {\n\t\treturn this._material;\n\t}\n\tset layer(layer) {\n\t\tthis._layer = layer;\n\t\tthis.updateKey();\n\t}\n\tget layer() {\n\t\treturn this._layer;\n\t}\n\t_updateShaderDefs(shaderDefs) {\n\t\tif (shaderDefs !== this._shaderDefs) {\n\t\t\tthis._shaderDefs = shaderDefs;\n\t\t\tthis.clearShaders();\n\t\t}\n\t}\n\tset calculateSortDistance(calculateSortDistance) {\n\t\tthis._calculateSortDistance = calculateSortDistance;\n\t}\n\tget calculateSortDistance() {\n\t\treturn this._calculateSortDistance;\n\t}\n\tset receiveShadow(val) {\n\t\tif (this._receiveShadow !== val) {\n\t\t\tthis._receiveShadow = val;\n\t\t\tthis._updateShaderDefs(val ? this._shaderDefs & ~SHADERDEF_NOSHADOW : this._shaderDefs | SHADERDEF_NOSHADOW);\n\t\t}\n\t}\n\tget receiveShadow() {\n\t\treturn this._receiveShadow;\n\t}\n\tset skinInstance(val) {\n\t\tthis._skinInstance = val;\n\t\tthis._updateShaderDefs(val ? this._shaderDefs | SHADERDEF_SKIN : this._shaderDefs & ~SHADERDEF_SKIN);\n\t\tthis._setupSkinUpdate();\n\t}\n\tget skinInstance() {\n\t\treturn this._skinInstance;\n\t}\n\tset morphInstance(val) {\n\t\tvar _this$_morphInstance;\n\t\t(_this$_morphInstance = this._morphInstance) == null || _this$_morphInstance.destroy();\n\t\tthis._morphInstance = val;\n\t\tlet shaderDefs = this._shaderDefs;\n\t\tshaderDefs = val && val.morph.useTextureMorph ? shaderDefs | SHADERDEF_MORPH_TEXTURE_BASED : shaderDefs & ~SHADERDEF_MORPH_TEXTURE_BASED;\n\t\tshaderDefs = val && val.morph.morphPositions ? shaderDefs | SHADERDEF_MORPH_POSITION : shaderDefs & ~SHADERDEF_MORPH_POSITION;\n\t\tshaderDefs = val && val.morph.morphNormals ? shaderDefs | SHADERDEF_MORPH_NORMAL : shaderDefs & ~SHADERDEF_MORPH_NORMAL;\n\t\tthis._updateShaderDefs(shaderDefs);\n\t}\n\tget morphInstance() {\n\t\treturn this._morphInstance;\n\t}\n\tset screenSpace(val) {\n\t\tif (this._screenSpace !== val) {\n\t\t\tthis._screenSpace = val;\n\t\t\tthis._updateShaderDefs(val ? this._shaderDefs | SHADERDEF_SCREENSPACE : this._shaderDefs & ~SHADERDEF_SCREENSPACE);\n\t\t}\n\t}\n\tget screenSpace() {\n\t\treturn this._screenSpace;\n\t}\n\tset key(val) {\n\t\tthis._key[SORTKEY_FORWARD] = val;\n\t}\n\tget key() {\n\t\treturn this._key[SORTKEY_FORWARD];\n\t}\n\tset mask(val) {\n\t\tconst toggles = this._shaderDefs & 0x0000FFFF;\n\t\tthis._updateShaderDefs(toggles | val << 16);\n\t}\n\tget mask() {\n\t\treturn this._shaderDefs >> 16;\n\t}\n\tset instancingCount(value) {\n\t\tif (this.instancingData) this.instancingData.count = value;\n\t}\n\tget instancingCount() {\n\t\treturn this.instancingData ? this.instancingData.count : 0;\n\t}\n\tdestroy() {\n\t\tvar _this$_skinInstance, _this$morphInstance;\n\t\tconst mesh = this.mesh;\n\t\tif (mesh) {\n\t\t\tthis.mesh = null;\n\t\t\tif (mesh.refCount < 1) {\n\t\t\t\tmesh.destroy();\n\t\t\t}\n\t\t}\n\t\tthis.setRealtimeLightmap(MeshInstance.lightmapParamNames[0], null);\n\t\tthis.setRealtimeLightmap(MeshInstance.lightmapParamNames[1], null);\n\t\t(_this$_skinInstance = this._skinInstance) == null || _this$_skinInstance.destroy();\n\t\tthis._skinInstance = null;\n\t\t(_this$morphInstance = this.morphInstance) == null || _this$morphInstance.destroy();\n\t\tthis.morphInstance = null;\n\t\tthis.clearShaders();\n\t\tthis.material = null;\n\t}\n\tstatic _prepareRenderStyleForArray(meshInstances, renderStyle) {\n\t\tif (meshInstances) {\n\t\t\tfor (let i = 0; i < meshInstances.length; i++) {\n\t\t\t\tmeshInstances[i]._renderStyle = renderStyle;\n\t\t\t\tconst mesh = meshInstances[i].mesh;\n\t\t\t\tif (!_meshSet.has(mesh)) {\n\t\t\t\t\t_meshSet.add(mesh);\n\t\t\t\t\tmesh.prepareRenderState(renderStyle);\n\t\t\t\t}\n\t\t\t}\n\t\t\t_meshSet.clear();\n\t\t}\n\t}\n\t_isVisible(camera) {\n\t\tif (this.visible) {\n\t\t\tif (this.isVisibleFunc) {\n\t\t\t\treturn this.isVisibleFunc(camera);\n\t\t\t}\n\t\t\t_tempSphere.center = this.aabb.center;\n\t\t\t_tempSphere.radius = this._aabb.halfExtents.length();\n\t\t\treturn camera.frustum.containsSphere(_tempSphere);\n\t\t}\n\t\treturn false;\n\t}\n\tupdateKey() {\n\t\tconst material = this.material;\n\t\tconst blendType = material.alphaToCoverage || material.alphaTest ? BLEND_NORMAL : material.blendType;\n\t\tthis._key[SORTKEY_FORWARD] = (this.layer & 0x0f) << 27 | (blendType === BLEND_NONE ? 1 : 0) << 26 | (material.id & 0x1ffffff) << 0;\n\t}\n\tsetInstancing(vertexBuffer, cull = false) {\n\t\tif (vertexBuffer) {\n\t\t\tthis.instancingData = new InstancingData(vertexBuffer.numVertices);\n\t\t\tthis.instancingData.vertexBuffer = vertexBuffer;\n\t\t\tvertexBuffer.format.instancing = true;\n\t\t\tthis.cull = cull;\n\t\t} else {\n\t\t\tthis.instancingData = null;\n\t\t\tthis.cull = true;\n\t\t}\n\t\tthis._updateShaderDefs(vertexBuffer ? this._shaderDefs | SHADERDEF_INSTANCING : this._shaderDefs & ~SHADERDEF_INSTANCING);\n\t}\n\tensureMaterial(device) {\n\t\tif (!this.material) {\n\t\t\tthis.material = getDefaultMaterial(device);\n\t\t}\n\t}\n\tclearParameters() {\n\t\tthis.parameters = {};\n\t}\n\tgetParameters() {\n\t\treturn this.parameters;\n\t}\n\tgetParameter(name) {\n\t\treturn this.parameters[name];\n\t}\n\tsetParameter(name, data, passFlags = -262141) {\n\t\tif (data === undefined && typeof name === 'object') {\n\t\t\tconst uniformObject = name;\n\t\t\tif (uniformObject.length) {\n\t\t\t\tfor (let i = 0; i < uniformObject.length; i++) {\n\t\t\t\t\tthis.setParameter(uniformObject[i]);\n\t\t\t\t}\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tname = uniformObject.name;\n\t\t\tdata = uniformObject.value;\n\t\t}\n\t\tconst param = this.parameters[name];\n\t\tif (param) {\n\t\t\tparam.data = data;\n\t\t\tparam.passFlags = passFlags;\n\t\t} else {\n\t\t\tthis.parameters[name] = {\n\t\t\t\tscopeId: null,\n\t\t\t\tdata: data,\n\t\t\t\tpassFlags: passFlags\n\t\t\t};\n\t\t}\n\t}\n\tsetRealtimeLightmap(name, texture) {\n\t\tconst old = this.getParameter(name);\n\t\tif (old === texture) return;\n\t\tif (old) {\n\t\t\tLightmapCache.decRef(old.data);\n\t\t}\n\t\tif (texture) {\n\t\t\tLightmapCache.incRef(texture);\n\t\t\tthis.setParameter(name, texture);\n\t\t} else {\n\t\t\tthis.deleteParameter(name);\n\t\t}\n\t}\n\tdeleteParameter(name) {\n\t\tif (this.parameters[name]) {\n\t\t\tdelete this.parameters[name];\n\t\t}\n\t}\n\tsetParameters(device, passFlag) {\n\t\tconst parameters = this.parameters;\n\t\tfor (const paramName in parameters) {\n\t\t\tconst parameter = parameters[paramName];\n\t\t\tif (parameter.passFlags & passFlag) {\n\t\t\t\tif (!parameter.scopeId) {\n\t\t\t\t\tparameter.scopeId = device.scope.resolve(paramName);\n\t\t\t\t}\n\t\t\t\tparameter.scopeId.setValue(parameter.data);\n\t\t\t}\n\t\t}\n\t}\n\tsetLightmapped(value) {\n\t\tif (value) {\n\t\t\tthis.mask = (this.mask | MASK_AFFECT_LIGHTMAPPED) & ~(MASK_AFFECT_DYNAMIC | MASK_BAKE);\n\t\t} else {\n\t\t\tthis.setRealtimeLightmap(MeshInstance.lightmapParamNames[0], null);\n\t\t\tthis.setRealtimeLightmap(MeshInstance.lightmapParamNames[1], null);\n\t\t\tthis._shaderDefs &= ~(SHADERDEF_LM | SHADERDEF_DIRLM | SHADERDEF_LMAMBIENT);\n\t\t\tthis.mask = (this.mask | MASK_AFFECT_DYNAMIC) & ~(MASK_AFFECT_LIGHTMAPPED | MASK_BAKE);\n\t\t}\n\t}\n\tsetCustomAabb(aabb) {\n\t\tif (aabb) {\n\t\t\tif (this._customAabb) {\n\t\t\t\tthis._customAabb.copy(aabb);\n\t\t\t} else {\n\t\t\t\tthis._customAabb = aabb.clone();\n\t\t\t}\n\t\t} else {\n\t\t\tthis._customAabb = null;\n\t\t\tthis._aabbVer = -1;\n\t\t}\n\t\tthis._setupSkinUpdate();\n\t}\n\t_setupSkinUpdate() {\n\t\tif (this._skinInstance) {\n\t\t\tthis._skinInstance._updateBeforeCull = !this._customAabb;\n\t\t}\n\t}\n}\nMeshInstance.lightmapParamNames = ['texture_lightMap', 'texture_dirLightMap'];\n\nexport { MeshInstance };\n", "import { FILTER_LINEAR_MIPMAP_LINEAR, FILTER_LINEAR, ADDRESS_CLAMP_TO_EDGE } from '../../platform/graphics/constants.js';\nimport { RenderPass } from '../../platform/graphics/render-pass.js';\nimport { RenderTarget } from '../../platform/graphics/render-target.js';\nimport { Texture } from '../../platform/graphics/texture.js';\n\nconst _colorUniformNames = ['uSceneColorMap', 'texture_grabPass'];\nclass RenderPassColorGrab extends RenderPass {\n\tconstructor(...args) {\n\t\tsuper(...args);\n\t\tthis.colorRenderTarget = null;\n\t\tthis.source = null;\n\t}\n\tdestroy() {\n\t\tsuper.destroy();\n\t\tthis.releaseRenderTarget(this.colorRenderTarget);\n\t}\n\tshouldReallocate(targetRT, sourceTexture, sourceFormat) {\n\t\tconst targetFormat = targetRT == null ? void 0 : targetRT.colorBuffer.format;\n\t\tif (targetFormat !== sourceFormat) return true;\n\t\tconst width = (sourceTexture == null ? void 0 : sourceTexture.width) || this.device.width;\n\t\tconst height = (sourceTexture == null ? void 0 : sourceTexture.height) || this.device.height;\n\t\treturn !targetRT || width !== targetRT.width || height !== targetRT.height;\n\t}\n\tallocateRenderTarget(renderTarget, sourceRenderTarget, device, format) {\n\t\tconst mipmaps = device.isWebGL2;\n\t\tconst texture = new Texture(device, {\n\t\t\tname: _colorUniformNames[0],\n\t\t\tformat,\n\t\t\twidth: sourceRenderTarget ? sourceRenderTarget.colorBuffer.width : device.width,\n\t\t\theight: sourceRenderTarget ? sourceRenderTarget.colorBuffer.height : device.height,\n\t\t\tmipmaps,\n\t\t\tminFilter: mipmaps ? FILTER_LINEAR_MIPMAP_LINEAR : FILTER_LINEAR,\n\t\t\tmagFilter: FILTER_LINEAR,\n\t\t\taddressU: ADDRESS_CLAMP_TO_EDGE,\n\t\t\taddressV: ADDRESS_CLAMP_TO_EDGE\n\t\t});\n\t\tif (renderTarget) {\n\t\t\trenderTarget.destroyFrameBuffers();\n\t\t\trenderTarget._colorBuffer = texture;\n\t\t\trenderTarget._colorBuffers = [texture];\n\t\t} else {\n\t\t\trenderTarget = new RenderTarget({\n\t\t\t\tname: 'ColorGrabRT',\n\t\t\t\tcolorBuffer: texture,\n\t\t\t\tdepth: false,\n\t\t\t\tstencil: false,\n\t\t\t\tautoResolve: false\n\t\t\t});\n\t\t}\n\t\treturn renderTarget;\n\t}\n\treleaseRenderTarget(rt) {\n\t\tif (rt) {\n\t\t\trt.destroyTextureBuffers();\n\t\t\trt.destroy();\n\t\t}\n\t}\n\tframeUpdate() {\n\t\tvar _sourceRt$colorBuffer;\n\t\tconst device = this.device;\n\t\tconst sourceRt = this.source;\n\t\tconst sourceFormat = (_sourceRt$colorBuffer = sourceRt == null ? void 0 : sourceRt.colorBuffer.format) != null ? _sourceRt$colorBuffer : this.device.backBufferFormat;\n\t\tif (this.shouldReallocate(this.colorRenderTarget, sourceRt == null ? void 0 : sourceRt.colorBuffer, sourceFormat)) {\n\t\t\tthis.releaseRenderTarget(this.colorRenderTarget);\n\t\t\tthis.colorRenderTarget = this.allocateRenderTarget(this.colorRenderTarget, sourceRt, device, sourceFormat);\n\t\t}\n\t\tconst colorBuffer = this.colorRenderTarget.colorBuffer;\n\t\t_colorUniformNames.forEach(name => device.scope.resolve(name).setValue(colorBuffer));\n\t}\n\texecute() {\n\t\tconst device = this.device;\n\t\tconst sourceRt = this.source;\n\t\tconst colorBuffer = this.colorRenderTarget.colorBuffer;\n\t\tif (device.isWebGPU) {\n\t\t\tdevice.copyRenderTarget(sourceRt, this.colorRenderTarget, true, false);\n\t\t\tdevice.mipmapRenderer.generate(this.colorRenderTarget.colorBuffer.impl);\n\t\t} else if (device.isWebGL2) {\n\t\t\tdevice.copyRenderTarget(sourceRt, this.colorRenderTarget, true, false);\n\t\t\tdevice.activeTexture(device.maxCombinedTextures - 1);\n\t\t\tdevice.bindTexture(colorBuffer);\n\t\t\tdevice.gl.generateMipmap(colorBuffer.impl._glTarget);\n\t\t} else {\n\t\t\tif (!colorBuffer.impl._glTexture) {\n\t\t\t\tcolorBuffer.impl.initialize(device, colorBuffer);\n\t\t\t}\n\t\t\tdevice.bindTexture(colorBuffer);\n\t\t\tconst gl = device.gl;\n\t\t\tgl.copyTexImage2D(gl.TEXTURE_2D, 0, colorBuffer.impl._glFormat, 0, 0, colorBuffer.width, colorBuffer.height, 0);\n\t\t\tcolorBuffer._needsUpload = false;\n\t\t\tcolorBuffer._needsMipmapsUpload = false;\n\t\t}\n\t}\n}\n\nexport { RenderPassColorGrab };\n", "import { FILTER_NEAREST, ADDRESS_CLAMP_TO_EDGE, PIXELFORMAT_DEPTHSTENCIL, PIXELFORMAT_DEPTH, PIXELFORMAT_R32F } from '../../platform/graphics/constants.js';\nimport { RenderPass } from '../../platform/graphics/render-pass.js';\nimport { RenderTarget } from '../../platform/graphics/render-target.js';\nimport { Texture } from '../../platform/graphics/texture.js';\n\nconst _depthUniformNames = ['uSceneDepthMap', 'uDepthMap'];\nclass RenderPassDepthGrab extends RenderPass {\n\tconstructor(device, camera) {\n\t\tsuper(device);\n\t\tthis.depthRenderTarget = null;\n\t\tthis.camera = null;\n\t\tthis.camera = camera;\n\t}\n\tdestroy() {\n\t\tsuper.destroy();\n\t\tthis.releaseRenderTarget(this.depthRenderTarget);\n\t}\n\tshouldReallocate(targetRT, sourceTexture) {\n\t\tconst width = (sourceTexture == null ? void 0 : sourceTexture.width) || this.device.width;\n\t\tconst height = (sourceTexture == null ? void 0 : sourceTexture.height) || this.device.height;\n\t\treturn !targetRT || width !== targetRT.width || height !== targetRT.height;\n\t}\n\tallocateRenderTarget(renderTarget, sourceRenderTarget, device, format, isDepth) {\n\t\tconst texture = new Texture(device, {\n\t\t\tname: _depthUniformNames[0],\n\t\t\tformat,\n\t\t\twidth: sourceRenderTarget ? sourceRenderTarget.colorBuffer.width : device.width,\n\t\t\theight: sourceRenderTarget ? sourceRenderTarget.colorBuffer.height : device.height,\n\t\t\tmipmaps: false,\n\t\t\tminFilter: FILTER_NEAREST,\n\t\t\tmagFilter: FILTER_NEAREST,\n\t\t\taddressU: ADDRESS_CLAMP_TO_EDGE,\n\t\t\taddressV: ADDRESS_CLAMP_TO_EDGE\n\t\t});\n\t\tif (renderTarget) {\n\t\t\trenderTarget.destroyFrameBuffers();\n\t\t\tif (isDepth) {\n\t\t\t\trenderTarget._depthBuffer = texture;\n\t\t\t} else {\n\t\t\t\trenderTarget._colorBuffer = texture;\n\t\t\t\trenderTarget._colorBuffers = [texture];\n\t\t\t}\n\t\t} else {\n\t\t\trenderTarget = new RenderTarget({\n\t\t\t\tname: 'DepthGrabRT',\n\t\t\t\tcolorBuffer: isDepth ? null : texture,\n\t\t\t\tdepthBuffer: isDepth ? texture : null,\n\t\t\t\tdepth: !isDepth,\n\t\t\t\tstencil: device.supportsStencil,\n\t\t\t\tautoResolve: false\n\t\t\t});\n\t\t}\n\t\treturn renderTarget;\n\t}\n\treleaseRenderTarget(rt) {\n\t\tif (rt) {\n\t\t\trt.destroyTextureBuffers();\n\t\t\trt.destroy();\n\t\t}\n\t}\n\tbefore() {\n\t\tvar _camera$renderTarget, _camera$renderTarget$, _camera$renderTarget2, _camera$renderTarget3;\n\t\tconst camera = this.camera;\n\t\tconst device = this.device;\n\t\tconst destinationRt = (_camera$renderTarget = camera == null ? void 0 : camera.renderTarget) != null ? _camera$renderTarget : device.backBuffer;\n\t\tlet useDepthBuffer = true;\n\t\tlet format = destinationRt.stencil ? PIXELFORMAT_DEPTHSTENCIL : PIXELFORMAT_DEPTH;\n\t\tif (device.isWebGPU) {\n\t\t\tconst numSamples = destinationRt.samples;\n\t\t\tif (numSamples > 1) {\n\t\t\t\tformat = PIXELFORMAT_R32F;\n\t\t\t\tuseDepthBuffer = false;\n\t\t\t}\n\t\t}\n\t\tconst sourceTexture = (_camera$renderTarget$ = (_camera$renderTarget2 = camera.renderTarget) == null ? void 0 : _camera$renderTarget2.depthBuffer) != null ? _camera$renderTarget$ : (_camera$renderTarget3 = camera.renderTarget) == null ? void 0 : _camera$renderTarget3.colorBuffer;\n\t\tif (this.shouldReallocate(this.depthRenderTarget, sourceTexture)) {\n\t\t\tthis.releaseRenderTarget(this.depthRenderTarget);\n\t\t\tthis.depthRenderTarget = this.allocateRenderTarget(this.depthRenderTarget, camera.renderTarget, device, format, useDepthBuffer);\n\t\t}\n\t\tconst colorBuffer = useDepthBuffer ? this.depthRenderTarget.depthBuffer : this.depthRenderTarget.colorBuffer;\n\t\t_depthUniformNames.forEach(name => device.scope.resolve(name).setValue(colorBuffer));\n\t}\n\texecute() {\n\t\tconst device = this.device;\n\t\tif (device.isWebGL2 && device.renderTarget.samples > 1) {\n\t\t\tconst src = device.renderTarget.impl._glFrameBuffer;\n\t\t\tconst dest = this.depthRenderTarget;\n\t\t\tdevice.renderTarget = dest;\n\t\t\tdevice.updateBegin();\n\t\t\tthis.depthRenderTarget.impl.internalResolve(device, src, dest.impl._glFrameBuffer, this.depthRenderTarget, device.gl.DEPTH_BUFFER_BIT);\n\t\t} else {\n\t\t\tdevice.copyRenderTarget(device.renderTarget, this.depthRenderTarget, false, true);\n\t\t}\n\t}\n}\n\nexport { RenderPassDepthGrab };\n", "import { Color } from '../../core/math/color.js';\nimport { PIXELFORMAT_RGBA8, FILTER_NEAREST, ADDRESS_CLAMP_TO_EDGE } from '../../platform/graphics/constants.js';\nimport { Texture } from '../../platform/graphics/texture.js';\nimport { RenderPass } from '../../platform/graphics/render-pass.js';\nimport { BlendState } from '../../platform/graphics/blend-state.js';\nimport { RenderTarget } from '../../platform/graphics/render-target.js';\nimport { LAYERID_DEPTH, SHADER_DEPTH } from '../constants.js';\n\nconst webgl1DepthClearColor = new Color(254.0 / 255, 254.0 / 255, 254.0 / 255, 254.0 / 255);\nconst tempMeshInstances = [];\nconst lights = [[], [], []];\nconst _depthUniformNames = ['uSceneDepthMap', 'uDepthMap'];\nclass RenderPassDepth extends RenderPass {\n\tconstructor(device, renderer, camera) {\n\t\tsuper(device);\n\t\tthis.renderer = renderer;\n\t\tthis.camera = camera;\n\t\tthis.setupRenderTarget();\n\t}\n\tdestroy() {\n\t\tsuper.destroy();\n\t\tif (this.renderTarget) {\n\t\t\tthis.renderTarget.destroyTextureBuffers();\n\t\t\tthis.renderTarget.destroy();\n\t\t\tthis.renderTarget = null;\n\t\t}\n\t}\n\tupdate(scene) {\n\t\tthis.scene = scene;\n\t}\n\tsetupRenderTarget() {\n\t\tconst texture = new Texture(this.device, {\n\t\t\tname: _depthUniformNames[0],\n\t\t\tformat: PIXELFORMAT_RGBA8,\n\t\t\twidth: 4,\n\t\t\theight: 4,\n\t\t\tmipmaps: false,\n\t\t\tminFilter: FILTER_NEAREST,\n\t\t\tmagFilter: FILTER_NEAREST,\n\t\t\taddressU: ADDRESS_CLAMP_TO_EDGE,\n\t\t\taddressV: ADDRESS_CLAMP_TO_EDGE\n\t\t});\n\t\tconst renderTarget = new RenderTarget({\n\t\t\tname: `${_depthUniformNames[0]}RT}`,\n\t\t\tcolorBuffer: texture,\n\t\t\tdepth: true,\n\t\t\tstencil: false\n\t\t});\n\t\tthis.init(renderTarget, {});\n\t\tthis.setClearColor(webgl1DepthClearColor);\n\t\tthis.setClearDepth(1.0);\n\t}\n\tbefore() {\n\t\tconst device = this.device;\n\t\tconst colorBuffer = this.renderTarget.colorBuffer;\n\t\t_depthUniformNames.forEach(name => device.scope.resolve(name).setValue(colorBuffer));\n\t}\n\texecute() {\n\t\tconst {\n\t\t\tdevice,\n\t\t\trenderer,\n\t\t\tcamera,\n\t\t\tscene,\n\t\t\trenderTarget\n\t\t} = this;\n\t\tconst layers = scene.layers.layerList;\n\t\tconst subLayerEnabled = scene.layers.subLayerEnabled;\n\t\tconst isTransparent = scene.layers.subLayerList;\n\t\tfor (let i = 0; i < layers.length; i++) {\n\t\t\tconst layer = layers[i];\n\t\t\tif (layer.enabled && subLayerEnabled[i]) {\n\t\t\t\tif (layer.camerasSet.has(camera)) {\n\t\t\t\t\tif (layer.id === LAYERID_DEPTH) break;\n\t\t\t\t\tconst culledInstances = layer.getCulledInstances(camera);\n\t\t\t\t\tconst meshInstances = isTransparent[i] ? culledInstances.transparent : culledInstances.opaque;\n\t\t\t\t\tfor (let j = 0; j < meshInstances.length; j++) {\n\t\t\t\t\t\tvar _meshInstance$materia;\n\t\t\t\t\t\tconst meshInstance = meshInstances[j];\n\t\t\t\t\t\tif ((_meshInstance$materia = meshInstance.material) != null && _meshInstance$materia.depthWrite) {\n\t\t\t\t\t\t\ttempMeshInstances.push(meshInstance);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\trenderer.setCameraUniforms(camera, renderTarget);\n\t\t\t\t\trenderer.renderForward(camera, tempMeshInstances, lights, SHADER_DEPTH, meshInstance => {\n\t\t\t\t\t\tdevice.setBlendState(BlendState.NOBLEND);\n\t\t\t\t\t}, layer);\n\t\t\t\t\ttempMeshInstances.length = 0;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n\nexport { RenderPassDepth };\n", "import { Color } from '../core/math/color.js';\nimport { Mat4 } from '../core/math/mat4.js';\nimport { Vec3 } from '../core/math/vec3.js';\nimport { Vec4 } from '../core/math/vec4.js';\nimport { math } from '../core/math/math.js';\nimport { Frustum } from '../core/shape/frustum.js';\nimport { ASPECT_AUTO, LAYERID_WORLD, LAYERID_DEPTH, LAYERID_SKYBOX, LAYERID_UI, LAYERID_IMMEDIATE, PROJECTION_PERSPECTIVE } from './constants.js';\nimport { RenderPassColorGrab } from './graphics/render-pass-color-grab.js';\nimport { RenderPassDepthGrab } from './graphics/render-pass-depth-grab.js';\nimport { RenderPassDepth } from './graphics/render-pass-depth.js';\n\nconst _deviceCoord = new Vec3();\nconst _halfSize = new Vec3();\nconst _point = new Vec3();\nconst _invViewProjMat = new Mat4();\nconst _frustumPoints = [new Vec3(), new Vec3(), new Vec3(), new Vec3(), new Vec3(), new Vec3(), new Vec3(), new Vec3()];\nclass Camera {\n\tconstructor() {\n\t\tthis.shaderPassInfo = null;\n\t\tthis.renderPassColorGrab = null;\n\t\tthis.renderPassDepthGrab = null;\n\t\tthis.renderPasses = [];\n\t\tthis.jitter = 0;\n\t\tthis._aspectRatio = 16 / 9;\n\t\tthis._aspectRatioMode = ASPECT_AUTO;\n\t\tthis._calculateProjection = null;\n\t\tthis._calculateTransform = null;\n\t\tthis._clearColor = new Color(0.75, 0.75, 0.75, 1);\n\t\tthis._clearColorBuffer = true;\n\t\tthis._clearDepth = 1;\n\t\tthis._clearDepthBuffer = true;\n\t\tthis._clearStencil = 0;\n\t\tthis._clearStencilBuffer = true;\n\t\tthis._cullFaces = true;\n\t\tthis._farClip = 1000;\n\t\tthis._flipFaces = false;\n\t\tthis._fov = 45;\n\t\tthis._frustumCulling = true;\n\t\tthis._horizontalFov = false;\n\t\tthis._layers = [LAYERID_WORLD, LAYERID_DEPTH, LAYERID_SKYBOX, LAYERID_UI, LAYERID_IMMEDIATE];\n\t\tthis._layersSet = new Set(this._layers);\n\t\tthis._nearClip = 0.1;\n\t\tthis._node = null;\n\t\tthis._orthoHeight = 10;\n\t\tthis._projection = PROJECTION_PERSPECTIVE;\n\t\tthis._rect = new Vec4(0, 0, 1, 1);\n\t\tthis._renderTarget = null;\n\t\tthis._scissorRect = new Vec4(0, 0, 1, 1);\n\t\tthis._scissorRectClear = false;\n\t\tthis._aperture = 16.0;\n\t\tthis._shutter = 1.0 / 1000.0;\n\t\tthis._sensitivity = 1000;\n\t\tthis._projMat = new Mat4();\n\t\tthis._projMatDirty = true;\n\t\tthis._projMatSkybox = new Mat4();\n\t\tthis._viewMat = new Mat4();\n\t\tthis._viewMatDirty = true;\n\t\tthis._viewProjMat = new Mat4();\n\t\tthis._viewProjMatDirty = true;\n\t\tthis._shaderMatricesVersion = 0;\n\t\tthis._viewProjInverse = new Mat4();\n\t\tthis._viewProjCurrent = null;\n\t\tthis._viewProjPrevious = new Mat4();\n\t\tthis._jitters = [0, 0, 0, 0];\n\t\tthis.frustum = new Frustum();\n\t\tthis._xr = null;\n\t\tthis._xrProperties = {\n\t\t\thorizontalFov: this._horizontalFov,\n\t\t\tfov: this._fov,\n\t\t\taspectRatio: this._aspectRatio,\n\t\t\tfarClip: this._farClip,\n\t\t\tnearClip: this._nearClip\n\t\t};\n\t}\n\tdestroy() {\n\t\tvar _this$renderPassColor, _this$renderPassDepth;\n\t\t(_this$renderPassColor = this.renderPassColorGrab) == null || _this$renderPassColor.destroy();\n\t\tthis.renderPassColorGrab = null;\n\t\t(_this$renderPassDepth = this.renderPassDepthGrab) == null || _this$renderPassDepth.destroy();\n\t\tthis.renderPassDepthGrab = null;\n\t\tthis.renderPasses.length = 0;\n\t}\n\t_storeShaderMatrices(viewProjMat, jitterX, jitterY, renderVersion) {\n\t\tif (this._shaderMatricesVersion !== renderVersion) {\n\t\t\tvar _this$_viewProjCurren, _this$_viewProjCurren2;\n\t\t\tthis._shaderMatricesVersion = renderVersion;\n\t\t\tthis._viewProjPrevious.copy((_this$_viewProjCurren = this._viewProjCurrent) != null ? _this$_viewProjCurren : viewProjMat);\n\t\t\t(_this$_viewProjCurren2 = this._viewProjCurrent) != null ? _this$_viewProjCurren2 : this._viewProjCurrent = new Mat4();\n\t\t\tthis._viewProjCurrent.copy(viewProjMat);\n\t\t\tthis._viewProjInverse.invert(viewProjMat);\n\t\t\tthis._jitters[2] = this._jitters[0];\n\t\t\tthis._jitters[3] = this._jitters[1];\n\t\t\tthis._jitters[0] = jitterX;\n\t\t\tthis._jitters[1] = jitterY;\n\t\t}\n\t}\n\tget fullSizeClearRect() {\n\t\tconst rect = this._scissorRectClear ? this.scissorRect : this._rect;\n\t\treturn rect.x === 0 && rect.y === 0 && rect.z === 1 && rect.w === 1;\n\t}\n\tset aspectRatio(newValue) {\n\t\tif (this._aspectRatio !== newValue) {\n\t\t\tthis._aspectRatio = newValue;\n\t\t\tthis._projMatDirty = true;\n\t\t}\n\t}\n\tget aspectRatio() {\n\t\tvar _this$xr;\n\t\treturn (_this$xr = this.xr) != null && _this$xr.active ? this._xrProperties.aspectRatio : this._aspectRatio;\n\t}\n\tset aspectRatioMode(newValue) {\n\t\tif (this._aspectRatioMode !== newValue) {\n\t\t\tthis._aspectRatioMode = newValue;\n\t\t\tthis._projMatDirty = true;\n\t\t}\n\t}\n\tget aspectRatioMode() {\n\t\treturn this._aspectRatioMode;\n\t}\n\tset calculateProjection(newValue) {\n\t\tthis._calculateProjection = newValue;\n\t\tthis._projMatDirty = true;\n\t}\n\tget calculateProjection() {\n\t\treturn this._calculateProjection;\n\t}\n\tset calculateTransform(newValue) {\n\t\tthis._calculateTransform = newValue;\n\t}\n\tget calculateTransform() {\n\t\treturn this._calculateTransform;\n\t}\n\tset clearColor(newValue) {\n\t\tthis._clearColor.copy(newValue);\n\t}\n\tget clearColor() {\n\t\treturn this._clearColor;\n\t}\n\tset clearColorBuffer(newValue) {\n\t\tthis._clearColorBuffer = newValue;\n\t}\n\tget clearColorBuffer() {\n\t\treturn this._clearColorBuffer;\n\t}\n\tset clearDepth(newValue) {\n\t\tthis._clearDepth = newValue;\n\t}\n\tget clearDepth() {\n\t\treturn this._clearDepth;\n\t}\n\tset clearDepthBuffer(newValue) {\n\t\tthis._clearDepthBuffer = newValue;\n\t}\n\tget clearDepthBuffer() {\n\t\treturn this._clearDepthBuffer;\n\t}\n\tset clearStencil(newValue) {\n\t\tthis._clearStencil = newValue;\n\t}\n\tget clearStencil() {\n\t\treturn this._clearStencil;\n\t}\n\tset clearStencilBuffer(newValue) {\n\t\tthis._clearStencilBuffer = newValue;\n\t}\n\tget clearStencilBuffer() {\n\t\treturn this._clearStencilBuffer;\n\t}\n\tset cullFaces(newValue) {\n\t\tthis._cullFaces = newValue;\n\t}\n\tget cullFaces() {\n\t\treturn this._cullFaces;\n\t}\n\tset farClip(newValue) {\n\t\tif (this._farClip !== newValue) {\n\t\t\tthis._farClip = newValue;\n\t\t\tthis._projMatDirty = true;\n\t\t}\n\t}\n\tget farClip() {\n\t\tvar _this$xr2;\n\t\treturn (_this$xr2 = this.xr) != null && _this$xr2.active ? this._xrProperties.farClip : this._farClip;\n\t}\n\tset flipFaces(newValue) {\n\t\tthis._flipFaces = newValue;\n\t}\n\tget flipFaces() {\n\t\treturn this._flipFaces;\n\t}\n\tset fov(newValue) {\n\t\tif (this._fov !== newValue) {\n\t\t\tthis._fov = newValue;\n\t\t\tthis._projMatDirty = true;\n\t\t}\n\t}\n\tget fov() {\n\t\tvar _this$xr3;\n\t\treturn (_this$xr3 = this.xr) != null && _this$xr3.active ? this._xrProperties.fov : this._fov;\n\t}\n\tset frustumCulling(newValue) {\n\t\tthis._frustumCulling = newValue;\n\t}\n\tget frustumCulling() {\n\t\treturn this._frustumCulling;\n\t}\n\tset horizontalFov(newValue) {\n\t\tif (this._horizontalFov !== newValue) {\n\t\t\tthis._horizontalFov = newValue;\n\t\t\tthis._projMatDirty = true;\n\t\t}\n\t}\n\tget horizontalFov() {\n\t\tvar _this$xr4;\n\t\treturn (_this$xr4 = this.xr) != null && _this$xr4.active ? this._xrProperties.horizontalFov : this._horizontalFov;\n\t}\n\tset layers(newValue) {\n\t\tthis._layers = newValue.slice(0);\n\t\tthis._layersSet = new Set(this._layers);\n\t}\n\tget layers() {\n\t\treturn this._layers;\n\t}\n\tget layersSet() {\n\t\treturn this._layersSet;\n\t}\n\tset nearClip(newValue) {\n\t\tif (this._nearClip !== newValue) {\n\t\t\tthis._nearClip = newValue;\n\t\t\tthis._projMatDirty = true;\n\t\t}\n\t}\n\tget nearClip() {\n\t\tvar _this$xr5;\n\t\treturn (_this$xr5 = this.xr) != null && _this$xr5.active ? this._xrProperties.nearClip : this._nearClip;\n\t}\n\tset node(newValue) {\n\t\tthis._node = newValue;\n\t}\n\tget node() {\n\t\treturn this._node;\n\t}\n\tset orthoHeight(newValue) {\n\t\tif (this._orthoHeight !== newValue) {\n\t\t\tthis._orthoHeight = newValue;\n\t\t\tthis._projMatDirty = true;\n\t\t}\n\t}\n\tget orthoHeight() {\n\t\treturn this._orthoHeight;\n\t}\n\tset projection(newValue) {\n\t\tif (this._projection !== newValue) {\n\t\t\tthis._projection = newValue;\n\t\t\tthis._projMatDirty = true;\n\t\t}\n\t}\n\tget projection() {\n\t\treturn this._projection;\n\t}\n\tget projectionMatrix() {\n\t\tthis._evaluateProjectionMatrix();\n\t\treturn this._projMat;\n\t}\n\tset rect(newValue) {\n\t\tthis._rect.copy(newValue);\n\t}\n\tget rect() {\n\t\treturn this._rect;\n\t}\n\tset renderTarget(newValue) {\n\t\tthis._renderTarget = newValue;\n\t}\n\tget renderTarget() {\n\t\treturn this._renderTarget;\n\t}\n\tset scissorRect(newValue) {\n\t\tthis._scissorRect.copy(newValue);\n\t}\n\tget scissorRect() {\n\t\treturn this._scissorRect;\n\t}\n\tget viewMatrix() {\n\t\tif (this._viewMatDirty) {\n\t\t\tconst wtm = this._node.getWorldTransform();\n\t\t\tthis._viewMat.copy(wtm).invert();\n\t\t\tthis._viewMatDirty = false;\n\t\t}\n\t\treturn this._viewMat;\n\t}\n\tset aperture(newValue) {\n\t\tthis._aperture = newValue;\n\t}\n\tget aperture() {\n\t\treturn this._aperture;\n\t}\n\tset sensitivity(newValue) {\n\t\tthis._sensitivity = newValue;\n\t}\n\tget sensitivity() {\n\t\treturn this._sensitivity;\n\t}\n\tset shutter(newValue) {\n\t\tthis._shutter = newValue;\n\t}\n\tget shutter() {\n\t\treturn this._shutter;\n\t}\n\tset xr(newValue) {\n\t\tif (this._xr !== newValue) {\n\t\t\tthis._xr = newValue;\n\t\t\tthis._projMatDirty = true;\n\t\t}\n\t}\n\tget xr() {\n\t\treturn this._xr;\n\t}\n\tclone() {\n\t\treturn new Camera().copy(this);\n\t}\n\tcopy(other) {\n\t\tthis._aspectRatio = other._aspectRatio;\n\t\tthis._farClip = other._farClip;\n\t\tthis._fov = other._fov;\n\t\tthis._horizontalFov = other._horizontalFov;\n\t\tthis._nearClip = other._nearClip;\n\t\tthis._xrProperties.aspectRatio = other._xrProperties.aspectRatio;\n\t\tthis._xrProperties.farClip = other._xrProperties.farClip;\n\t\tthis._xrProperties.fov = other._xrProperties.fov;\n\t\tthis._xrProperties.horizontalFov = other._xrProperties.horizontalFov;\n\t\tthis._xrProperties.nearClip = other._xrProperties.nearClip;\n\t\tthis.aspectRatioMode = other.aspectRatioMode;\n\t\tthis.calculateProjection = other.calculateProjection;\n\t\tthis.calculateTransform = other.calculateTransform;\n\t\tthis.clearColor = other.clearColor;\n\t\tthis.clearColorBuffer = other.clearColorBuffer;\n\t\tthis.clearDepth = other.clearDepth;\n\t\tthis.clearDepthBuffer = other.clearDepthBuffer;\n\t\tthis.clearStencil = other.clearStencil;\n\t\tthis.clearStencilBuffer = other.clearStencilBuffer;\n\t\tthis.cullFaces = other.cullFaces;\n\t\tthis.flipFaces = other.flipFaces;\n\t\tthis.frustumCulling = other.frustumCulling;\n\t\tthis.layers = other.layers;\n\t\tthis.orthoHeight = other.orthoHeight;\n\t\tthis.projection = other.projection;\n\t\tthis.rect = other.rect;\n\t\tthis.renderTarget = other.renderTarget;\n\t\tthis.scissorRect = other.scissorRect;\n\t\tthis.aperture = other.aperture;\n\t\tthis.shutter = other.shutter;\n\t\tthis.sensitivity = other.sensitivity;\n\t\tthis.shaderPassInfo = other.shaderPassInfo;\n\t\tthis.jitter = other.jitter;\n\t\tthis._projMatDirty = true;\n\t\treturn this;\n\t}\n\t_enableRenderPassColorGrab(device, enable) {\n\t\tif (enable) {\n\t\t\tif (!this.renderPassColorGrab) {\n\t\t\t\tthis.renderPassColorGrab = new RenderPassColorGrab(device);\n\t\t\t}\n\t\t} else {\n\t\t\tvar _this$renderPassColor2;\n\t\t\t(_this$renderPassColor2 = this.renderPassColorGrab) == null || _this$renderPassColor2.destroy();\n\t\t\tthis.renderPassColorGrab = null;\n\t\t}\n\t}\n\t_enableRenderPassDepthGrab(device, renderer, enable) {\n\t\tif (enable) {\n\t\t\tif (!this.renderPassDepthGrab) {\n\t\t\t\tthis.renderPassDepthGrab = device.isWebGL1 ? new RenderPassDepth(device, renderer, this) : new RenderPassDepthGrab(device, this);\n\t\t\t}\n\t\t} else {\n\t\t\tvar _this$renderPassDepth2;\n\t\t\t(_this$renderPassDepth2 = this.renderPassDepthGrab) == null || _this$renderPassDepth2.destroy();\n\t\t\tthis.renderPassDepthGrab = null;\n\t\t}\n\t}\n\t_updateViewProjMat() {\n\t\tif (this._projMatDirty || this._viewMatDirty || this._viewProjMatDirty) {\n\t\t\tthis._viewProjMat.mul2(this.projectionMatrix, this.viewMatrix);\n\t\t\tthis._viewProjMatDirty = false;\n\t\t}\n\t}\n\tworldToScreen(worldCoord, cw, ch, screenCoord = new Vec3()) {\n\t\tthis._updateViewProjMat();\n\t\tthis._viewProjMat.transformPoint(worldCoord, screenCoord);\n\t\tconst vpm = this._viewProjMat.data;\n\t\tconst w = worldCoord.x * vpm[3] + worldCoord.y * vpm[7] + worldCoord.z * vpm[11] + 1 * vpm[15];\n\t\tscreenCoord.x = (screenCoord.x / w + 1) * 0.5 * cw;\n\t\tscreenCoord.y = (1 - screenCoord.y / w) * 0.5 * ch;\n\t\treturn screenCoord;\n\t}\n\tscreenToWorld(x, y, z, cw, ch, worldCoord = new Vec3()) {\n\t\tconst range = this.farClip - this.nearClip;\n\t\t_deviceCoord.set(x / cw, (ch - y) / ch, z / range);\n\t\t_deviceCoord.mulScalar(2);\n\t\t_deviceCoord.sub(Vec3.ONE);\n\t\tif (this._projection === PROJECTION_PERSPECTIVE) {\n\t\t\tMat4._getPerspectiveHalfSize(_halfSize, this.fov, this.aspectRatio, this.nearClip, this.horizontalFov);\n\t\t\t_halfSize.x *= _deviceCoord.x;\n\t\t\t_halfSize.y *= _deviceCoord.y;\n\t\t\tconst invView = this._node.getWorldTransform();\n\t\t\t_halfSize.z = -this.nearClip;\n\t\t\tinvView.transformPoint(_halfSize, _point);\n\t\t\tconst cameraPos = this._node.getPosition();\n\t\t\tworldCoord.sub2(_point, cameraPos);\n\t\t\tworldCoord.normalize();\n\t\t\tworldCoord.mulScalar(z);\n\t\t\tworldCoord.add(cameraPos);\n\t\t} else {\n\t\t\tthis._updateViewProjMat();\n\t\t\t_invViewProjMat.copy(this._viewProjMat).invert();\n\t\t\t_invViewProjMat.transformPoint(_deviceCoord, worldCoord);\n\t\t}\n\t\treturn worldCoord;\n\t}\n\t_evaluateProjectionMatrix() {\n\t\tif (this._projMatDirty) {\n\t\t\tif (this._projection === PROJECTION_PERSPECTIVE) {\n\t\t\t\tthis._projMat.setPerspective(this.fov, this.aspectRatio, this.nearClip, this.farClip, this.horizontalFov);\n\t\t\t\tthis._projMatSkybox.copy(this._projMat);\n\t\t\t} else {\n\t\t\t\tconst y = this._orthoHeight;\n\t\t\t\tconst x = y * this.aspectRatio;\n\t\t\t\tthis._projMat.setOrtho(-x, x, -y, y, this.nearClip, this.farClip);\n\t\t\t\tthis._projMatSkybox.setPerspective(this.fov, this.aspectRatio, this.nearClip, this.farClip);\n\t\t\t}\n\t\t\tthis._projMatDirty = false;\n\t\t}\n\t}\n\tgetProjectionMatrixSkybox() {\n\t\tthis._evaluateProjectionMatrix();\n\t\treturn this._projMatSkybox;\n\t}\n\tgetExposure() {\n\t\tconst ev100 = Math.log2(this._aperture * this._aperture / this._shutter * 100.0 / this._sensitivity);\n\t\treturn 1.0 / (Math.pow(2.0, ev100) * 1.2);\n\t}\n\tgetScreenSize(sphere) {\n\t\tif (this._projection === PROJECTION_PERSPECTIVE) {\n\t\t\tconst distance = this._node.getPosition().distance(sphere.center);\n\t\t\tif (distance < sphere.radius) {\n\t\t\t\treturn 1;\n\t\t\t}\n\t\t\tconst viewAngle = Math.asin(sphere.radius / distance);\n\t\t\tconst sphereViewHeight = Math.tan(viewAngle);\n\t\t\tconst screenViewHeight = Math.tan(this.fov / 2 * math.DEG_TO_RAD);\n\t\t\treturn Math.min(sphereViewHeight / screenViewHeight, 1);\n\t\t}\n\t\treturn math.clamp(sphere.radius / this._orthoHeight, 0, 1);\n\t}\n\tgetFrustumCorners(near = this.nearClip, far = this.farClip) {\n\t\tconst fov = this.fov * Math.PI / 180.0;\n\t\tlet y = this._projection === PROJECTION_PERSPECTIVE ? Math.tan(fov / 2.0) * near : this._orthoHeight;\n\t\tlet x = y * this.aspectRatio;\n\t\tconst points = _frustumPoints;\n\t\tpoints[0].x = x;\n\t\tpoints[0].y = -y;\n\t\tpoints[0].z = -near;\n\t\tpoints[1].x = x;\n\t\tpoints[1].y = y;\n\t\tpoints[1].z = -near;\n\t\tpoints[2].x = -x;\n\t\tpoints[2].y = y;\n\t\tpoints[2].z = -near;\n\t\tpoints[3].x = -x;\n\t\tpoints[3].y = -y;\n\t\tpoints[3].z = -near;\n\t\tif (this._projection === PROJECTION_PERSPECTIVE) {\n\t\t\ty = Math.tan(fov / 2.0) * far;\n\t\t\tx = y * this.aspectRatio;\n\t\t}\n\t\tpoints[4].x = x;\n\t\tpoints[4].y = -y;\n\t\tpoints[4].z = -far;\n\t\tpoints[5].x = x;\n\t\tpoints[5].y = y;\n\t\tpoints[5].z = -far;\n\t\tpoints[6].x = -x;\n\t\tpoints[6].y = y;\n\t\tpoints[6].z = -far;\n\t\tpoints[7].x = -x;\n\t\tpoints[7].y = -y;\n\t\tpoints[7].z = -far;\n\t\treturn points;\n\t}\n\tsetXrProperties(properties) {\n\t\tObject.assign(this._xrProperties, properties);\n\t\tthis._projMatDirty = true;\n\t}\n}\n\nexport { Camera };\n", "import { BLEND_NONE, DITHER_NONE, FOG_NONE, GAMMA_NONE } from '../../constants.js';\n\nclass LitShaderOptions {\n\tconstructor() {\n\t\tthis.hasTangents = false;\n\t\tthis.chunks = {};\n\t\tthis.pass = 0;\n\t\tthis.alphaTest = false;\n\t\tthis.blendType = BLEND_NONE;\n\t\tthis.separateAmbient = false;\n\t\tthis.screenSpace = false;\n\t\tthis.skin = false;\n\t\tthis.useInstancing = false;\n\t\tthis.useMorphPosition = false;\n\t\tthis.useMorphNormal = false;\n\t\tthis.useMorphTextureBased = false;\n\t\tthis.nineSlicedMode = 0;\n\t\tthis.clusteredLightingEnabled = true;\n\t\tthis.clusteredLightingCookiesEnabled = false;\n\t\tthis.clusteredLightingShadowsEnabled = false;\n\t\tthis.clusteredLightingShadowType = 0;\n\t\tthis.clusteredLightingAreaLightsEnabled = false;\n\t\tthis.vertexColors = false;\n\t\tthis.lightMapEnabled = false;\n\t\tthis.dirLightMapEnabled = false;\n\t\tthis.useHeights = false;\n\t\tthis.useNormals = false;\n\t\tthis.useClearCoatNormals = false;\n\t\tthis.useAo = false;\n\t\tthis.diffuseMapEnabled = false;\n\t\tthis.useAmbientTint = false;\n\t\tthis.customFragmentShader = null;\n\t\tthis.pixelSnap = false;\n\t\tthis.shadingModel = 0;\n\t\tthis.ambientSH = false;\n\t\tthis.fastTbn = false;\n\t\tthis.twoSidedLighting = false;\n\t\tthis.occludeDirect = false;\n\t\tthis.occludeSpecular = 0;\n\t\tthis.occludeSpecularFloat = false;\n\t\tthis.useMsdf = false;\n\t\tthis.msdfTextAttribute = false;\n\t\tthis.alphaToCoverage = false;\n\t\tthis.opacityFadesSpecular = false;\n\t\tthis.opacityDither = DITHER_NONE;\n\t\tthis.opacityShadowDither = DITHER_NONE;\n\t\tthis.cubeMapProjection = 0;\n\t\tthis.conserveEnergy = false;\n\t\tthis.useSpecular = false;\n\t\tthis.useSpecularityFactor = false;\n\t\tthis.enableGGXSpecular = false;\n\t\tthis.fresnelModel = 0;\n\t\tthis.useRefraction = false;\n\t\tthis.useClearCoat = false;\n\t\tthis.useSheen = false;\n\t\tthis.useIridescence = false;\n\t\tthis.useMetalness = false;\n\t\tthis.useDynamicRefraction = false;\n\t\tthis.dispersion = false;\n\t\tthis.fog = FOG_NONE;\n\t\tthis.gamma = GAMMA_NONE;\n\t\tthis.toneMap = -1;\n\t\tthis.fixSeams = false;\n\t\tthis.reflectionSource = null;\n\t\tthis.reflectionEncoding = null;\n\t\tthis.reflectionCubemapEncoding = null;\n\t\tthis.ambientSource = 'constant';\n\t\tthis.ambientEncoding = null;\n\t\tthis.skyboxIntensity = 1.0;\n\t\tthis.useCubeMapRotation = false;\n\t\tthis.lightMapWithoutAmbient = false;\n\t\tthis.lights = [];\n\t\tthis.noShadow = false;\n\t\tthis.lightMaskDynamic = 0x0;\n\t\tthis.userAttributes = {};\n\t}\n}\n\nexport { LitShaderOptions };\n", "import { SHADER_FORWARDHDR, GAMMA_SRGBHDR, TONEMAP_LINEAR, SHADERDEF_SCREENSPACE, SHADERDEF_SKIN, SHADERDEF_INSTANCING, SHADERDEF_MORPH_POSITION, SHADERDEF_MORPH_NORMAL, SHADERDEF_MORPH_TEXTURE_BASED, SHADERDEF_TANGENTS, SPRITE_RENDERMODE_SIMPLE, CUBEPROJ_NONE, SPECULAR_BLINN, GAMMA_NONE, MASK_AFFECT_DYNAMIC, LIGHTTYPE_DIRECTIONAL, LIGHTTYPE_OMNI, LIGHTTYPE_SPOT, SHADERDEF_NOSHADOW } from '../constants.js';\n\nclass LitMaterialOptionsBuilder {\n\tstatic update(litOptions, material, scene, objDefs, pass, sortedLights) {\n\t\tLitMaterialOptionsBuilder.updateSharedOptions(litOptions, material, scene, objDefs, pass);\n\t\tLitMaterialOptionsBuilder.updateMaterialOptions(litOptions, material);\n\t\tLitMaterialOptionsBuilder.updateEnvOptions(litOptions, material, scene);\n\t\tLitMaterialOptionsBuilder.updateLightingOptions(litOptions, material, objDefs, sortedLights);\n\t\tif (pass === SHADER_FORWARDHDR) {\n\t\t\tlitOptions.gamma = GAMMA_SRGBHDR;\n\t\t\tlitOptions.toneMap = TONEMAP_LINEAR;\n\t\t}\n\t}\n\tstatic updateSharedOptions(litOptions, material, scene, objDefs, pass) {\n\t\tlitOptions.chunks = material.chunks;\n\t\tlitOptions.pass = pass;\n\t\tlitOptions.alphaTest = material.alphaTest > 0;\n\t\tlitOptions.blendType = material.blendType;\n\t\tlitOptions.screenSpace = objDefs && (objDefs & SHADERDEF_SCREENSPACE) !== 0;\n\t\tlitOptions.skin = objDefs && (objDefs & SHADERDEF_SKIN) !== 0;\n\t\tlitOptions.useInstancing = objDefs && (objDefs & SHADERDEF_INSTANCING) !== 0;\n\t\tlitOptions.useMorphPosition = objDefs && (objDefs & SHADERDEF_MORPH_POSITION) !== 0;\n\t\tlitOptions.useMorphNormal = objDefs && (objDefs & SHADERDEF_MORPH_NORMAL) !== 0;\n\t\tlitOptions.useMorphTextureBased = objDefs && (objDefs & SHADERDEF_MORPH_TEXTURE_BASED) !== 0;\n\t\tlitOptions.hasTangents = objDefs && (objDefs & SHADERDEF_TANGENTS) !== 0;\n\t\tlitOptions.nineSlicedMode = material.nineSlicedMode || SPRITE_RENDERMODE_SIMPLE;\n\t\tif (material.useLighting && scene.clusteredLightingEnabled) {\n\t\t\tlitOptions.clusteredLightingEnabled = true;\n\t\t\tlitOptions.clusteredLightingCookiesEnabled = scene.lighting.cookiesEnabled;\n\t\t\tlitOptions.clusteredLightingShadowsEnabled = scene.lighting.shadowsEnabled;\n\t\t\tlitOptions.clusteredLightingShadowType = scene.lighting.shadowType;\n\t\t\tlitOptions.clusteredLightingAreaLightsEnabled = scene.lighting.areaLightsEnabled;\n\t\t} else {\n\t\t\tlitOptions.clusteredLightingEnabled = false;\n\t\t\tlitOptions.clusteredLightingCookiesEnabled = false;\n\t\t\tlitOptions.clusteredLightingShadowsEnabled = false;\n\t\t\tlitOptions.clusteredLightingAreaLightsEnabled = false;\n\t\t}\n\t}\n\tstatic updateMaterialOptions(litOptions, material) {\n\t\tlitOptions.useAmbientTint = false;\n\t\tlitOptions.separateAmbient = false;\n\t\tlitOptions.customFragmentShader = null;\n\t\tlitOptions.pixelSnap = material.pixelSnap;\n\t\tlitOptions.shadingModel = material.shadingModel;\n\t\tlitOptions.ambientSH = material.ambientSH;\n\t\tlitOptions.fastTbn = material.fastTbn;\n\t\tlitOptions.twoSidedLighting = material.twoSidedLighting;\n\t\tlitOptions.occludeDirect = material.occludeDirect;\n\t\tlitOptions.occludeSpecular = material.occludeSpecular;\n\t\tlitOptions.occludeSpecularFloat = material.occludeSpecularIntensity !== 1.0;\n\t\tlitOptions.useMsdf = false;\n\t\tlitOptions.msdfTextAttribute = false;\n\t\tlitOptions.alphaToCoverage = material.alphaToCoverage;\n\t\tlitOptions.opacityFadesSpecular = material.opacityFadesSpecular;\n\t\tlitOptions.opacityDither = material.opacityDither;\n\t\tlitOptions.cubeMapProjection = CUBEPROJ_NONE;\n\t\tlitOptions.conserveEnergy = material.conserveEnergy && material.shadingModel === SPECULAR_BLINN;\n\t\tlitOptions.useSpecular = material.hasSpecular;\n\t\tlitOptions.useSpecularityFactor = material.hasSpecularityFactor;\n\t\tlitOptions.enableGGXSpecular = material.ggxSpecular;\n\t\tlitOptions.fresnelModel = material.fresnelModel;\n\t\tlitOptions.useRefraction = material.hasRefraction;\n\t\tlitOptions.useClearCoat = material.hasClearCoat;\n\t\tlitOptions.useSheen = material.hasSheen;\n\t\tlitOptions.useIridescence = material.hasIrridescence;\n\t\tlitOptions.useMetalness = material.hasMetalness;\n\t\tlitOptions.useDynamicRefraction = material.dynamicRefraction;\n\t\tlitOptions.dispersion = material.dispersion > 0;\n\t\tlitOptions.vertexColors = false;\n\t\tlitOptions.lightMapEnabled = material.hasLighting;\n\t\tlitOptions.dirLightMapEnabled = material.dirLightMap;\n\t\tlitOptions.useHeights = material.hasHeights;\n\t\tlitOptions.useNormals = material.hasNormals;\n\t\tlitOptions.useClearCoatNormals = material.hasClearCoatNormals;\n\t\tlitOptions.useAo = material.hasAo;\n\t\tlitOptions.diffuseMapEnabled = material.hasDiffuseMap;\n\t}\n\tstatic updateEnvOptions(litOptions, material, scene) {\n\t\tlitOptions.fog = material.useFog ? scene.fog : 'none';\n\t\tlitOptions.gamma = material.useGammaTonemap ? scene.gammaCorrection : GAMMA_NONE;\n\t\tlitOptions.toneMap = material.useGammaTonemap ? scene.toneMapping : -1;\n\t\tlitOptions.fixSeams = false;\n\t\tif (material.useSkybox && scene.envAtlas && scene.skybox) {\n\t\t\tlitOptions.reflectionSource = 'envAtlasHQ';\n\t\t\tlitOptions.reflectionEncoding = scene.envAtlas.encoding;\n\t\t\tlitOptions.reflectionCubemapEncoding = scene.skybox.encoding;\n\t\t} else if (material.useSkybox && scene.envAtlas) {\n\t\t\tlitOptions.reflectionSource = 'envAtlas';\n\t\t\tlitOptions.reflectionEncoding = scene.envAtlas.encoding;\n\t\t} else if (material.useSkybox && scene.skybox) {\n\t\t\tlitOptions.reflectionSource = 'cubeMap';\n\t\t\tlitOptions.reflectionEncoding = scene.skybox.encoding;\n\t\t} else {\n\t\t\tlitOptions.reflectionSource = null;\n\t\t\tlitOptions.reflectionEncoding = null;\n\t\t}\n\t\tif (material.ambientSH) {\n\t\t\tlitOptions.ambientSource = 'ambientSH';\n\t\t\tlitOptions.ambientEncoding = null;\n\t\t} else if (litOptions.reflectionSource && scene.envAtlas) {\n\t\t\tlitOptions.ambientSource = 'envAtlas';\n\t\t\tlitOptions.ambientEncoding = scene.envAtlas.encoding;\n\t\t} else {\n\t\t\tlitOptions.ambientSource = 'constant';\n\t\t\tlitOptions.ambientEncoding = null;\n\t\t}\n\t\tconst hasSkybox = !!litOptions.reflectionSource;\n\t\tlitOptions.skyboxIntensity = hasSkybox;\n\t\tlitOptions.useCubeMapRotation = hasSkybox && scene._skyboxRotationShaderInclude;\n\t}\n\tstatic updateLightingOptions(litOptions, material, objDefs, sortedLights) {\n\t\tlitOptions.lightMapWithoutAmbient = false;\n\t\tif (material.useLighting) {\n\t\t\tconst lightsFiltered = [];\n\t\t\tconst mask = objDefs ? objDefs >> 16 : MASK_AFFECT_DYNAMIC;\n\t\t\tlitOptions.lightMaskDynamic = !!(mask & MASK_AFFECT_DYNAMIC);\n\t\t\tlitOptions.lightMapWithoutAmbient = false;\n\t\t\tif (sortedLights) {\n\t\t\t\tLitMaterialOptionsBuilder.collectLights(LIGHTTYPE_DIRECTIONAL, sortedLights[LIGHTTYPE_DIRECTIONAL], lightsFiltered, mask);\n\t\t\t\tLitMaterialOptionsBuilder.collectLights(LIGHTTYPE_OMNI, sortedLights[LIGHTTYPE_OMNI], lightsFiltered, mask);\n\t\t\t\tLitMaterialOptionsBuilder.collectLights(LIGHTTYPE_SPOT, sortedLights[LIGHTTYPE_SPOT], lightsFiltered, mask);\n\t\t\t}\n\t\t\tlitOptions.lights = lightsFiltered;\n\t\t} else {\n\t\t\tlitOptions.lights = [];\n\t\t}\n\t\tif (litOptions.lights.length === 0 || (objDefs & SHADERDEF_NOSHADOW) !== 0) {\n\t\t\tlitOptions.noShadow = true;\n\t\t}\n\t}\n\tstatic collectLights(lType, lights, lightsFiltered, mask) {\n\t\tfor (let i = 0; i < lights.length; i++) {\n\t\t\tconst light = lights[i];\n\t\t\tif (light.enabled) {\n\t\t\t\tif (light.mask & mask) {\n\t\t\t\t\tlightsFiltered.push(light);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n\nexport { LitMaterialOptionsBuilder };\n", "class ChunkBuilder {\n\tconstructor() {\n\t\tthis.code = '';\n\t}\n\tappend(...chunks) {\n\t\tchunks.forEach(chunk => {\n\t\t\tif (chunk.endsWith('\\n')) {\n\t\t\t\tthis.code += chunk;\n\t\t\t} else {\n\t\t\t\tthis.code += chunk + '\\n';\n\t\t\t}\n\t\t});\n\t}\n\tprepend(...chunks) {\n\t\tchunks.forEach(chunk => {\n\t\t\tif (chunk.endsWith('\\n')) {\n\t\t\t\tthis.code = chunk + this.code;\n\t\t\t} else {\n\t\t\t\tthis.code = chunk + '\\n' + this.code;\n\t\t\t}\n\t\t});\n\t}\n}\n\nexport { ChunkBuilder };\n", "const decodeTable = {\n\t'linear': 'decodeLinear',\n\t'srgb': 'decodeGamma',\n\t'rgbm': 'decodeRGBM',\n\t'rgbe': 'decodeRGBE',\n\t'rgbp': 'decodeRGBP'\n};\nconst encodeTable = {\n\t'linear': 'encodeLinear',\n\t'srgb': 'encodeGamma',\n\t'rgbm': 'encodeRGBM',\n\t'rgbe': 'encodeRGBE',\n\t'rgbp': 'encodeRGBP'\n};\nclass ChunkUtils {\n\tstatic decodeFunc(encoding) {\n\t\treturn decodeTable[encoding] || 'decodeGamma';\n\t}\n\tstatic encodeFunc(encoding) {\n\t\treturn encodeTable[encoding] || 'encodeGamma';\n\t}\n}\n\nexport { ChunkUtils };\n", "import { Quat } from '../../core/math/quat.js';\nimport { Vec3 } from '../../core/math/vec3.js';\nimport { Mat4 } from '../../core/math/mat4.js';\nimport { ASPECT_MANUAL, LIGHTTYPE_DIRECTIONAL, PROJECTION_ORTHOGRAPHIC, LIGHTTYPE_SPOT, PROJECTION_PERSPECTIVE, LIGHTTYPE_OMNI } from '../constants.js';\nimport { Camera } from '../camera.js';\nimport { GraphNode } from '../graph-node.js';\n\nconst _viewMat = new Mat4();\nconst _viewProjMat = new Mat4();\nconst _viewportMatrix = new Mat4();\nclass LightCamera {\n\tstatic create(name, lightType, face) {\n\t\tconst camera = new Camera();\n\t\tcamera.node = new GraphNode(name);\n\t\tcamera.aspectRatio = 1;\n\t\tcamera.aspectRatioMode = ASPECT_MANUAL;\n\t\tcamera._scissorRectClear = true;\n\t\tswitch (lightType) {\n\t\t\tcase LIGHTTYPE_OMNI:\n\t\t\t\tcamera.node.setRotation(LightCamera.pointLightRotations[face]);\n\t\t\t\tcamera.fov = 90;\n\t\t\t\tcamera.projection = PROJECTION_PERSPECTIVE;\n\t\t\t\tbreak;\n\t\t\tcase LIGHTTYPE_SPOT:\n\t\t\t\tcamera.projection = PROJECTION_PERSPECTIVE;\n\t\t\t\tbreak;\n\t\t\tcase LIGHTTYPE_DIRECTIONAL:\n\t\t\t\tcamera.projection = PROJECTION_ORTHOGRAPHIC;\n\t\t\t\tbreak;\n\t\t}\n\t\treturn camera;\n\t}\n\tstatic evalSpotCookieMatrix(light) {\n\t\tlet cookieCamera = LightCamera._spotCookieCamera;\n\t\tif (!cookieCamera) {\n\t\t\tcookieCamera = LightCamera.create('SpotCookieCamera', LIGHTTYPE_SPOT);\n\t\t\tLightCamera._spotCookieCamera = cookieCamera;\n\t\t}\n\t\tcookieCamera.fov = light._outerConeAngle * 2;\n\t\tconst cookieNode = cookieCamera._node;\n\t\tcookieNode.setPosition(light._node.getPosition());\n\t\tcookieNode.setRotation(light._node.getRotation());\n\t\tcookieNode.rotateLocal(-90, 0, 0);\n\t\t_viewMat.setTRS(cookieNode.getPosition(), cookieNode.getRotation(), Vec3.ONE).invert();\n\t\t_viewProjMat.mul2(cookieCamera.projectionMatrix, _viewMat);\n\t\tconst cookieMatrix = light.cookieMatrix;\n\t\tconst rectViewport = light.atlasViewport;\n\t\t_viewportMatrix.setViewport(rectViewport.x, rectViewport.y, rectViewport.z, rectViewport.w);\n\t\tcookieMatrix.mul2(_viewportMatrix, _viewProjMat);\n\t\treturn cookieMatrix;\n\t}\n}\nLightCamera.pointLightRotations = [new Quat().setFromEulerAngles(0, 90, 180), new Quat().setFromEulerAngles(0, -90, 180), new Quat().setFromEulerAngles(90, 0, 0), new Quat().setFromEulerAngles(-90, 0, 0), new Quat().setFromEulerAngles(0, 180, 180), new Quat().setFromEulerAngles(0, 0, 180)];\nLightCamera._spotCookieCamera = null;\n\nexport { LightCamera };\n", "import { Vec3 } from '../../core/math/vec3.js';\nimport { PIXELFORMAT_RGBA8, PIXELFORMAT_RGBA32F, ADDRESS_CLAMP_TO_EDGE, TEXTURETYPE_DEFAULT, FILTER_NEAREST } from '../../platform/graphics/constants.js';\nimport { FloatPacking } from '../../core/math/float-packing.js';\nimport { MASK_AFFECT_DYNAMIC, MASK_AFFECT_LIGHTMAPPED, LIGHTTYPE_SPOT, LIGHTSHAPE_PUNCTUAL } from '../constants.js';\nimport { Texture } from '../../platform/graphics/texture.js';\nimport { DeviceCache } from '../../platform/graphics/device-cache.js';\nimport { LightCamera } from '../renderer/light-camera.js';\n\nconst epsilon = 0.000001;\nconst tempVec3 = new Vec3();\nconst tempAreaLightSizes = new Float32Array(6);\nconst areaHalfAxisWidth = new Vec3(-0.5, 0, 0);\nconst areaHalfAxisHeight = new Vec3(0, 0, 0.5);\nconst TextureIndex8 = {\n\tFLAGS: 0,\n\tCOLOR_A: 1,\n\tCOLOR_B: 2,\n\tSPOT_ANGLES: 3,\n\tSHADOW_BIAS: 4,\n\tCOOKIE_A: 5,\n\tCOOKIE_B: 6,\n\tCOUNT_ALWAYS: 7,\n\tPOSITION_X: 7,\n\tPOSITION_Y: 8,\n\tPOSITION_Z: 9,\n\tRANGE: 10,\n\tSPOT_DIRECTION_X: 11,\n\tSPOT_DIRECTION_Y: 12,\n\tSPOT_DIRECTION_Z: 13,\n\tPROJ_MAT_00: 14,\n\tATLAS_VIEWPORT_A: 14,\n\tPROJ_MAT_01: 15,\n\tATLAS_VIEWPORT_B: 15,\n\tPROJ_MAT_02: 16,\n\tPROJ_MAT_03: 17,\n\tPROJ_MAT_10: 18,\n\tPROJ_MAT_11: 19,\n\tPROJ_MAT_12: 20,\n\tPROJ_MAT_13: 21,\n\tPROJ_MAT_20: 22,\n\tPROJ_MAT_21: 23,\n\tPROJ_MAT_22: 24,\n\tPROJ_MAT_23: 25,\n\tPROJ_MAT_30: 26,\n\tPROJ_MAT_31: 27,\n\tPROJ_MAT_32: 28,\n\tPROJ_MAT_33: 29,\n\tAREA_DATA_WIDTH_X: 30,\n\tAREA_DATA_WIDTH_Y: 31,\n\tAREA_DATA_WIDTH_Z: 32,\n\tAREA_DATA_HEIGHT_X: 33,\n\tAREA_DATA_HEIGHT_Y: 34,\n\tAREA_DATA_HEIGHT_Z: 35,\n\tCOUNT: 36\n};\nconst TextureIndexFloat = {\n\tPOSITION_RANGE: 0,\n\tSPOT_DIRECTION: 1,\n\tPROJ_MAT_0: 2,\n\tATLAS_VIEWPORT: 2,\n\tPROJ_MAT_1: 3,\n\tPROJ_MAT_2: 4,\n\tPROJ_MAT_3: 5,\n\tAREA_DATA_WIDTH: 6,\n\tAREA_DATA_HEIGHT: 7,\n\tCOUNT: 8\n};\nconst FORMAT_FLOAT = 0;\nconst FORMAT_8BIT = 1;\nconst shaderDefinesDeviceCache = new DeviceCache();\nclass LightsBuffer {\n\tstatic getLightTextureFormat(device) {\n\t\treturn device.extTextureFloat && device.maxTextures > 8 ? FORMAT_FLOAT : FORMAT_8BIT;\n\t}\n\tstatic getShaderDefines(device) {\n\t\treturn shaderDefinesDeviceCache.get(device, () => {\n\t\t\tconst buildShaderDefines = (device, object, prefix, floatOffset) => {\n\t\t\t\treturn Object.keys(object).map(key => `#define ${prefix}${key} ${object[key]}${floatOffset}`).join('\\n');\n\t\t\t};\n\t\t\tconst lightTextureFormat = LightsBuffer.getLightTextureFormat(device);\n\t\t\tconst clusterTextureFormat = lightTextureFormat === FORMAT_FLOAT ? 'FLOAT' : '8BIT';\n\t\t\tconst floatOffset = device.supportsTextureFetch ? '' : '.5';\n\t\t\treturn `\n\t\t\t\t\t\t\t\t\\n#define CLUSTER_TEXTURE_${clusterTextureFormat}\n\t\t\t\t\t\t\t\t${buildShaderDefines(device, TextureIndex8, 'CLUSTER_TEXTURE_8_', floatOffset)}\n\t\t\t\t\t\t\t\t${buildShaderDefines(device, TextureIndexFloat, 'CLUSTER_TEXTURE_F_', floatOffset)}\n\t\t\t\t\t\t`;\n\t\t});\n\t}\n\tconstructor(device) {\n\t\tthis.device = device;\n\t\tthis.cookiesEnabled = false;\n\t\tthis.shadowsEnabled = false;\n\t\tthis.areaLightsEnabled = false;\n\t\tthis.maxLights = 255;\n\t\tlet pixelsPerLight8 = TextureIndex8.COUNT_ALWAYS;\n\t\tlet pixelsPerLightFloat = 0;\n\t\tthis.lightTextureFormat = LightsBuffer.getLightTextureFormat(device);\n\t\tif (this.lightTextureFormat === FORMAT_FLOAT) {\n\t\t\tpixelsPerLightFloat = TextureIndexFloat.COUNT;\n\t\t} else {\n\t\t\tpixelsPerLight8 = TextureIndex8.COUNT;\n\t\t}\n\t\tthis.lights8 = new Uint8ClampedArray(4 * pixelsPerLight8 * this.maxLights);\n\t\tthis.lightsTexture8 = this.createTexture(this.device, pixelsPerLight8, this.maxLights, PIXELFORMAT_RGBA8, 'LightsTexture8');\n\t\tthis._lightsTexture8Id = this.device.scope.resolve('lightsTexture8');\n\t\tif (pixelsPerLightFloat) {\n\t\t\tthis.lightsFloat = new Float32Array(4 * pixelsPerLightFloat * this.maxLights);\n\t\t\tthis.lightsTextureFloat = this.createTexture(this.device, pixelsPerLightFloat, this.maxLights, PIXELFORMAT_RGBA32F, 'LightsTextureFloat');\n\t\t\tthis._lightsTextureFloatId = this.device.scope.resolve('lightsTextureFloat');\n\t\t} else {\n\t\t\tthis.lightsFloat = null;\n\t\t\tthis.lightsTextureFloat = null;\n\t\t\tthis._lightsTextureFloatId = undefined;\n\t\t}\n\t\tthis._lightsTextureInvSizeId = this.device.scope.resolve('lightsTextureInvSize');\n\t\tthis._lightsTextureInvSizeData = new Float32Array(4);\n\t\tthis._lightsTextureInvSizeData[0] = pixelsPerLightFloat ? 1.0 / this.lightsTextureFloat.width : 0;\n\t\tthis._lightsTextureInvSizeData[1] = pixelsPerLightFloat ? 1.0 / this.lightsTextureFloat.height : 0;\n\t\tthis._lightsTextureInvSizeData[2] = 1.0 / this.lightsTexture8.width;\n\t\tthis._lightsTextureInvSizeData[3] = 1.0 / this.lightsTexture8.height;\n\t\tthis.invMaxColorValue = 0;\n\t\tthis.invMaxAttenuation = 0;\n\t\tthis.boundsMin = new Vec3();\n\t\tthis.boundsDelta = new Vec3();\n\t}\n\tdestroy() {\n\t\tif (this.lightsTexture8) {\n\t\t\tthis.lightsTexture8.destroy();\n\t\t\tthis.lightsTexture8 = null;\n\t\t}\n\t\tif (this.lightsTextureFloat) {\n\t\t\tthis.lightsTextureFloat.destroy();\n\t\t\tthis.lightsTextureFloat = null;\n\t\t}\n\t}\n\tcreateTexture(device, width, height, format, name) {\n\t\tconst tex = new Texture(device, {\n\t\t\tname: name,\n\t\t\twidth: width,\n\t\t\theight: height,\n\t\t\tmipmaps: false,\n\t\t\tformat: format,\n\t\t\taddressU: ADDRESS_CLAMP_TO_EDGE,\n\t\t\taddressV: ADDRESS_CLAMP_TO_EDGE,\n\t\t\ttype: TEXTURETYPE_DEFAULT,\n\t\t\tmagFilter: FILTER_NEAREST,\n\t\t\tminFilter: FILTER_NEAREST,\n\t\t\tanisotropy: 1\n\t\t});\n\t\treturn tex;\n\t}\n\tsetCompressionRanges(maxAttenuation, maxColorValue) {\n\t\tthis.invMaxColorValue = 1 / maxColorValue;\n\t\tthis.invMaxAttenuation = 1 / maxAttenuation;\n\t}\n\tsetBounds(min, delta) {\n\t\tthis.boundsMin.copy(min);\n\t\tthis.boundsDelta.copy(delta);\n\t}\n\tuploadTextures() {\n\t\tif (this.lightsTextureFloat) {\n\t\t\tthis.lightsTextureFloat.lock().set(this.lightsFloat);\n\t\t\tthis.lightsTextureFloat.unlock();\n\t\t}\n\t\tthis.lightsTexture8.lock().set(this.lights8);\n\t\tthis.lightsTexture8.unlock();\n\t}\n\tupdateUniforms() {\n\t\tthis._lightsTexture8Id.setValue(this.lightsTexture8);\n\t\tif (this.lightTextureFormat === FORMAT_FLOAT) {\n\t\t\tthis._lightsTextureFloatId.setValue(this.lightsTextureFloat);\n\t\t}\n\t\tthis._lightsTextureInvSizeId.setValue(this._lightsTextureInvSizeData);\n\t}\n\tgetSpotDirection(direction, spot) {\n\t\tconst mat = spot._node.getWorldTransform();\n\t\tmat.getY(direction).mulScalar(-1);\n\t\tdirection.normalize();\n\t}\n\tgetLightAreaSizes(light) {\n\t\tconst mat = light._node.getWorldTransform();\n\t\tmat.transformVector(areaHalfAxisWidth, tempVec3);\n\t\ttempAreaLightSizes[0] = tempVec3.x;\n\t\ttempAreaLightSizes[1] = tempVec3.y;\n\t\ttempAreaLightSizes[2] = tempVec3.z;\n\t\tmat.transformVector(areaHalfAxisHeight, tempVec3);\n\t\ttempAreaLightSizes[3] = tempVec3.x;\n\t\ttempAreaLightSizes[4] = tempVec3.y;\n\t\ttempAreaLightSizes[5] = tempVec3.z;\n\t\treturn tempAreaLightSizes;\n\t}\n\taddLightDataFlags(data8, index, light, isSpot, castShadows, shadowIntensity) {\n\t\tdata8[index + 0] = isSpot ? 255 : 0;\n\t\tdata8[index + 1] = light._shape * 64;\n\t\tdata8[index + 2] = light._falloffMode * 255;\n\t\tdata8[index + 3] = castShadows ? shadowIntensity * 255 : 0;\n\t}\n\taddLightDataColor(data8, index, light, gammaCorrection, isCookie) {\n\t\tconst invMaxColorValue = this.invMaxColorValue;\n\t\tconst color = gammaCorrection ? light._linearFinalColor : light._finalColor;\n\t\tFloatPacking.float2Bytes(color[0] * invMaxColorValue, data8, index + 0, 2);\n\t\tFloatPacking.float2Bytes(color[1] * invMaxColorValue, data8, index + 2, 2);\n\t\tFloatPacking.float2Bytes(color[2] * invMaxColorValue, data8, index + 4, 2);\n\t\tdata8[index + 6] = isCookie ? 255 : 0;\n\t\tconst isDynamic = !!(light.mask & MASK_AFFECT_DYNAMIC);\n\t\tconst isLightmapped = !!(light.mask & MASK_AFFECT_LIGHTMAPPED);\n\t\tdata8[index + 7] = isDynamic && isLightmapped ? 127 : isLightmapped ? 255 : 0;\n\t}\n\taddLightDataSpotAngles(data8, index, light) {\n\t\tFloatPacking.float2Bytes(light._innerConeAngleCos * (0.5 - epsilon) + 0.5, data8, index + 0, 2);\n\t\tFloatPacking.float2Bytes(light._outerConeAngleCos * (0.5 - epsilon) + 0.5, data8, index + 2, 2);\n\t}\n\taddLightDataShadowBias(data8, index, light) {\n\t\tconst lightRenderData = light.getRenderData(null, 0);\n\t\tconst biases = light._getUniformBiasValues(lightRenderData);\n\t\tFloatPacking.float2BytesRange(biases.bias, data8, index, -1, 20, 2);\n\t\tFloatPacking.float2Bytes(biases.normalBias, data8, index + 2, 2);\n\t}\n\taddLightDataPositionRange(data8, index, light, pos) {\n\t\tconst normPos = tempVec3.sub2(pos, this.boundsMin).div(this.boundsDelta);\n\t\tFloatPacking.float2Bytes(normPos.x, data8, index + 0, 4);\n\t\tFloatPacking.float2Bytes(normPos.y, data8, index + 4, 4);\n\t\tFloatPacking.float2Bytes(normPos.z, data8, index + 8, 4);\n\t\tFloatPacking.float2Bytes(light.attenuationEnd * this.invMaxAttenuation, data8, index + 12, 4);\n\t}\n\taddLightDataSpotDirection(data8, index, light) {\n\t\tthis.getSpotDirection(tempVec3, light);\n\t\tFloatPacking.float2Bytes(tempVec3.x * (0.5 - epsilon) + 0.5, data8, index + 0, 4);\n\t\tFloatPacking.float2Bytes(tempVec3.y * (0.5 - epsilon) + 0.5, data8, index + 4, 4);\n\t\tFloatPacking.float2Bytes(tempVec3.z * (0.5 - epsilon) + 0.5, data8, index + 8, 4);\n\t}\n\taddLightDataLightProjMatrix(data8, index, lightProjectionMatrix) {\n\t\tconst matData = lightProjectionMatrix.data;\n\t\tfor (let m = 0; m < 12; m++) FloatPacking.float2BytesRange(matData[m], data8, index + 4 * m, -2, 2, 4);\n\t\tfor (let m = 12; m < 16; m++) {\n\t\t\tFloatPacking.float2MantissaExponent(matData[m], data8, index + 4 * m, 4);\n\t\t}\n\t}\n\taddLightDataCookies(data8, index, light) {\n\t\tconst isRgb = light._cookieChannel === 'rgb';\n\t\tdata8[index + 0] = Math.floor(light.cookieIntensity * 255);\n\t\tdata8[index + 1] = isRgb ? 255 : 0;\n\t\tif (!isRgb) {\n\t\t\tconst channel = light._cookieChannel;\n\t\t\tdata8[index + 4] = channel === 'rrr' ? 255 : 0;\n\t\t\tdata8[index + 5] = channel === 'ggg' ? 255 : 0;\n\t\t\tdata8[index + 6] = channel === 'bbb' ? 255 : 0;\n\t\t\tdata8[index + 7] = channel === 'aaa' ? 255 : 0;\n\t\t}\n\t}\n\taddLightAtlasViewport(data8, index, atlasViewport) {\n\t\tFloatPacking.float2Bytes(atlasViewport.x, data8, index + 0, 2);\n\t\tFloatPacking.float2Bytes(atlasViewport.y, data8, index + 2, 2);\n\t\tFloatPacking.float2Bytes(atlasViewport.z / 3, data8, index + 4, 2);\n\t}\n\taddLightAreaSizes(data8, index, light) {\n\t\tconst areaSizes = this.getLightAreaSizes(light);\n\t\tfor (let i = 0; i < 6; i++) {\n\t\t\tFloatPacking.float2MantissaExponent(areaSizes[i], data8, index + 4 * i, 4);\n\t\t}\n\t}\n\taddLightData(light, lightIndex, gammaCorrection) {\n\t\tconst isSpot = light._type === LIGHTTYPE_SPOT;\n\t\tconst hasAtlasViewport = light.atlasViewportAllocated;\n\t\tconst isCookie = this.cookiesEnabled && !!light._cookie && hasAtlasViewport;\n\t\tconst isArea = this.areaLightsEnabled && light.shape !== LIGHTSHAPE_PUNCTUAL;\n\t\tconst castShadows = this.shadowsEnabled && light.castShadows && hasAtlasViewport;\n\t\tconst pos = light._node.getPosition();\n\t\tlet lightProjectionMatrix = null;\n\t\tlet atlasViewport = null;\n\t\tif (isSpot) {\n\t\t\tif (castShadows) {\n\t\t\t\tconst lightRenderData = light.getRenderData(null, 0);\n\t\t\t\tlightProjectionMatrix = lightRenderData.shadowMatrix;\n\t\t\t} else if (isCookie) {\n\t\t\t\tlightProjectionMatrix = LightCamera.evalSpotCookieMatrix(light);\n\t\t\t}\n\t\t} else {\n\t\t\tif (castShadows || isCookie) {\n\t\t\t\tatlasViewport = light.atlasViewport;\n\t\t\t}\n\t\t}\n\t\tconst data8 = this.lights8;\n\t\tconst data8Start = lightIndex * this.lightsTexture8.width * 4;\n\t\tthis.addLightDataFlags(data8, data8Start + 4 * TextureIndex8.FLAGS, light, isSpot, castShadows, light.shadowIntensity);\n\t\tthis.addLightDataColor(data8, data8Start + 4 * TextureIndex8.COLOR_A, light, gammaCorrection, isCookie);\n\t\tif (isSpot) {\n\t\t\tthis.addLightDataSpotAngles(data8, data8Start + 4 * TextureIndex8.SPOT_ANGLES, light);\n\t\t}\n\t\tif (light.castShadows) {\n\t\t\tthis.addLightDataShadowBias(data8, data8Start + 4 * TextureIndex8.SHADOW_BIAS, light);\n\t\t}\n\t\tif (isCookie) {\n\t\t\tthis.addLightDataCookies(data8, data8Start + 4 * TextureIndex8.COOKIE_A, light);\n\t\t}\n\t\tif (this.lightTextureFormat === FORMAT_FLOAT) {\n\t\t\tconst dataFloat = this.lightsFloat;\n\t\t\tconst dataFloatStart = lightIndex * this.lightsTextureFloat.width * 4;\n\t\t\tdataFloat[dataFloatStart + 4 * TextureIndexFloat.POSITION_RANGE + 0] = pos.x;\n\t\t\tdataFloat[dataFloatStart + 4 * TextureIndexFloat.POSITION_RANGE + 1] = pos.y;\n\t\t\tdataFloat[dataFloatStart + 4 * TextureIndexFloat.POSITION_RANGE + 2] = pos.z;\n\t\t\tdataFloat[dataFloatStart + 4 * TextureIndexFloat.POSITION_RANGE + 3] = light.attenuationEnd;\n\t\t\tif (isSpot) {\n\t\t\t\tthis.getSpotDirection(tempVec3, light);\n\t\t\t\tdataFloat[dataFloatStart + 4 * TextureIndexFloat.SPOT_DIRECTION + 0] = tempVec3.x;\n\t\t\t\tdataFloat[dataFloatStart + 4 * TextureIndexFloat.SPOT_DIRECTION + 1] = tempVec3.y;\n\t\t\t\tdataFloat[dataFloatStart + 4 * TextureIndexFloat.SPOT_DIRECTION + 2] = tempVec3.z;\n\t\t\t}\n\t\t\tif (lightProjectionMatrix) {\n\t\t\t\tconst matData = lightProjectionMatrix.data;\n\t\t\t\tfor (let m = 0; m < 16; m++) dataFloat[dataFloatStart + 4 * TextureIndexFloat.PROJ_MAT_0 + m] = matData[m];\n\t\t\t}\n\t\t\tif (atlasViewport) {\n\t\t\t\tdataFloat[dataFloatStart + 4 * TextureIndexFloat.ATLAS_VIEWPORT + 0] = atlasViewport.x;\n\t\t\t\tdataFloat[dataFloatStart + 4 * TextureIndexFloat.ATLAS_VIEWPORT + 1] = atlasViewport.y;\n\t\t\t\tdataFloat[dataFloatStart + 4 * TextureIndexFloat.ATLAS_VIEWPORT + 2] = atlasViewport.z / 3;\n\t\t\t}\n\t\t\tif (isArea) {\n\t\t\t\tconst areaSizes = this.getLightAreaSizes(light);\n\t\t\t\tdataFloat[dataFloatStart + 4 * TextureIndexFloat.AREA_DATA_WIDTH + 0] = areaSizes[0];\n\t\t\t\tdataFloat[dataFloatStart + 4 * TextureIndexFloat.AREA_DATA_WIDTH + 1] = areaSizes[1];\n\t\t\t\tdataFloat[dataFloatStart + 4 * TextureIndexFloat.AREA_DATA_WIDTH + 2] = areaSizes[2];\n\t\t\t\tdataFloat[dataFloatStart + 4 * TextureIndexFloat.AREA_DATA_HEIGHT + 0] = areaSizes[3];\n\t\t\t\tdataFloat[dataFloatStart + 4 * TextureIndexFloat.AREA_DATA_HEIGHT + 1] = areaSizes[4];\n\t\t\t\tdataFloat[dataFloatStart + 4 * TextureIndexFloat.AREA_DATA_HEIGHT + 2] = areaSizes[5];\n\t\t\t}\n\t\t} else {\n\t\t\tthis.addLightDataPositionRange(data8, data8Start + 4 * TextureIndex8.POSITION_X, light, pos);\n\t\t\tif (isSpot) {\n\t\t\t\tthis.addLightDataSpotDirection(data8, data8Start + 4 * TextureIndex8.SPOT_DIRECTION_X, light);\n\t\t\t}\n\t\t\tif (lightProjectionMatrix) {\n\t\t\t\tthis.addLightDataLightProjMatrix(data8, data8Start + 4 * TextureIndex8.PROJ_MAT_00, lightProjectionMatrix);\n\t\t\t}\n\t\t\tif (atlasViewport) {\n\t\t\t\tthis.addLightAtlasViewport(data8, data8Start + 4 * TextureIndex8.ATLAS_VIEWPORT_A, atlasViewport);\n\t\t\t}\n\t\t\tif (isArea) {\n\t\t\t\tthis.addLightAreaSizes(data8, data8Start + 4 * TextureIndex8.AREA_DATA_WIDTH_X, light);\n\t\t\t}\n\t\t}\n\t}\n}\n\nexport { LightsBuffer };\n", "import { SEMANTIC_POSITION, SEMANTIC_ATTR12, SEMANTIC_ATTR13, SEMANTIC_ATTR14, SEMANTIC_ATTR15, SEMANTIC_NORMAL, SEMANTIC_TANGENT, SEMANTIC_COLOR, SEMANTIC_ATTR8, SEMANTIC_ATTR9, SEMANTIC_ATTR10, SEMANTIC_ATTR11, SEMANTIC_BLENDWEIGHT, SEMANTIC_BLENDINDICES, PIXELFORMAT_RGBA8, SHADERTAG_MATERIAL, SEMANTIC_TEXCOORD0, SEMANTIC_TEXCOORD1 } from '../../../platform/graphics/constants.js';\nimport { shaderChunks } from '../chunks/chunks.js';\nimport { ChunkUtils } from '../chunk-utils.js';\nimport { SPRITE_RENDERMODE_SLICED, SPRITE_RENDERMODE_TILED, LIGHTSHAPE_SPHERE, LIGHTSHAPE_DISK, LIGHTSHAPE_RECT, SHADER_DEPTH, SHADER_PREPASS_VELOCITY, LIGHTTYPE_DIRECTIONAL, SHADOW_VSM32, LIGHTTYPE_OMNI, SHADOW_PCSS, SHADOW_VSM8, LIGHTSHAPE_PUNCTUAL, LIGHTTYPE_SPOT, FRESNEL_SCHLICK, SPECOCC_GLOSSDEPENDENT, SPECOCC_AO, SHADOW_PCF3, SHADOW_PCF5, SHADOW_PCF1, SHADOW_VSM16, SPECULAR_PHONG, shadowTypeToString, LIGHTFALLOFF_LINEAR, BLEND_NORMAL, BLEND_PREMULTIPLIED, BLEND_ADDITIVEALPHA, SHADER_PICK } from '../../constants.js';\nimport { LightsBuffer } from '../../lighting/lights-buffer.js';\nimport { ShaderPass } from '../../shader-pass.js';\nimport { ShaderUtils } from '../../../platform/graphics/shader-utils.js';\nimport { ChunkBuilder } from '../chunk-builder.js';\nimport { ShaderGenerator } from './shader-generator.js';\n\nconst builtinAttributes = {\n\tvertex_normal: SEMANTIC_NORMAL,\n\tvertex_tangent: SEMANTIC_TANGENT,\n\tvertex_texCoord0: SEMANTIC_TEXCOORD0,\n\tvertex_texCoord1: SEMANTIC_TEXCOORD1,\n\tvertex_color: SEMANTIC_COLOR,\n\tvertex_boneWeights: SEMANTIC_BLENDWEIGHT,\n\tvertex_boneIndices: SEMANTIC_BLENDINDICES\n};\nconst builtinVaryings = {\n\tvVertexColor: \"vec4\",\n\tvPositionW: \"vec3\",\n\tvNormalV: \"vec3\",\n\tvNormalW: \"vec3\",\n\tvTangentW: \"vec3\",\n\tvBinormalW: \"vec3\",\n\tvObjectSpaceUpW: \"vec3\",\n\tvUv0: \"vec2\",\n\tvUv1: \"vec2\"\n};\nclass LitShader {\n\tconstructor(device, options) {\n\t\tthis.device = device;\n\t\tthis.options = options;\n\t\tthis.attributes = {\n\t\t\tvertex_position: SEMANTIC_POSITION\n\t\t};\n\t\tif (options.userAttributes) {\n\t\t\tfor (const [semantic, name] of Object.entries(options.userAttributes)) {\n\t\t\t\tthis.attributes[name] = semantic;\n\t\t\t}\n\t\t}\n\t\tif (options.chunks) {\n\t\t\tconst userChunks = options.chunks;\n\t\t\tthis.chunks = Object.create(shaderChunks);\n\t\t\tfor (const chunkName in shaderChunks) {\n\t\t\t\tif (userChunks.hasOwnProperty(chunkName)) {\n\t\t\t\t\tconst chunk = userChunks[chunkName];\n\t\t\t\t\tfor (const a in builtinAttributes) {\n\t\t\t\t\t\tif (builtinAttributes.hasOwnProperty(a) && chunk.indexOf(a) >= 0) {\n\t\t\t\t\t\t\tthis.attributes[a] = builtinAttributes[a];\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tthis.chunks[chunkName] = chunk;\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tthis.chunks = shaderChunks;\n\t\t}\n\t\tthis.shaderPassInfo = ShaderPass.get(this.device).getByIndex(options.pass);\n\t\tthis.shadowPass = this.shaderPassInfo.isShadow;\n\t\tthis.lighting = options.lights.length > 0 || options.dirLightMapEnabled || options.clusteredLightingEnabled;\n\t\tthis.reflections = !!options.reflectionSource;\n\t\tthis.needsNormal = this.lighting || this.reflections || options.useSpecular || options.ambientSH || options.useHeights || options.enableGGXSpecular || options.clusteredLightingEnabled && !this.shadowPass || options.useClearCoatNormals;\n\t\tthis.needsNormal = this.needsNormal && !this.shadowPass;\n\t\tthis.needsSceneColor = options.useDynamicRefraction;\n\t\tthis.needsScreenSize = options.useDynamicRefraction;\n\t\tthis.needsTransforms = options.useDynamicRefraction;\n\t\tthis.varyings = \"\";\n\t\tthis.varyingDefines = \"\";\n\t\tthis.vshader = null;\n\t\tthis.frontendDecl = null;\n\t\tthis.frontendCode = null;\n\t\tthis.frontendFunc = null;\n\t\tthis.lightingUv = null;\n\t\tthis.defines = [];\n\t\tthis.fshader = null;\n\t}\n\t_vsAddBaseCode(code, chunks, options) {\n\t\tcode += chunks.baseVS;\n\t\tif (options.nineSlicedMode === SPRITE_RENDERMODE_SLICED || options.nineSlicedMode === SPRITE_RENDERMODE_TILED) {\n\t\t\tcode += chunks.baseNineSlicedVS;\n\t\t}\n\t\treturn code;\n\t}\n\t_vsAddTransformCode(code, device, chunks, options) {\n\t\tcode += this.chunks.transformVS;\n\t\treturn code;\n\t}\n\t_setMapTransform(codes, name, id, uv) {\n\t\tconst checkId = id + uv * 100;\n\t\tif (!codes[3][checkId]) {\n\t\t\tconst varName = `texture_${name}MapTransform`;\n\t\t\tcodes[0] += `uniform vec3 ${varName}0;\\n`;\n\t\t\tcodes[0] += `uniform vec3 ${varName}1;\\n`;\n\t\t\tcodes[1] += `varying vec2 vUV${uv}_${id};\\n`;\n\t\t\tcodes[2] += ` vUV${uv}_${id} = vec2(dot(vec3(uv${uv}, 1), ${varName}0), dot(vec3(uv${uv}, 1), ${varName}1));\\n`;\n\t\t\tcodes[3][checkId] = true;\n\t\t}\n\t\treturn codes;\n\t}\n\t_fsGetBaseCode() {\n\t\tconst options = this.options;\n\t\tconst chunks = this.chunks;\n\t\tlet result = this.chunks.basePS;\n\t\tif (options.nineSlicedMode === SPRITE_RENDERMODE_SLICED) {\n\t\t\tresult += chunks.baseNineSlicedPS;\n\t\t} else if (options.nineSlicedMode === SPRITE_RENDERMODE_TILED) {\n\t\t\tresult += chunks.baseNineSlicedTiledPS;\n\t\t}\n\t\treturn result;\n\t}\n\t_fsGetStartCode(code, device, chunks, options) {\n\t\tlet result = chunks.startPS;\n\t\tif (options.nineSlicedMode === SPRITE_RENDERMODE_SLICED) {\n\t\t\tresult += chunks.startNineSlicedPS;\n\t\t} else if (options.nineSlicedMode === SPRITE_RENDERMODE_TILED) {\n\t\t\tresult += chunks.startNineSlicedTiledPS;\n\t\t}\n\t\treturn result;\n\t}\n\t_getLightSourceShapeString(shape) {\n\t\tswitch (shape) {\n\t\t\tcase LIGHTSHAPE_RECT:\n\t\t\t\treturn 'Rect';\n\t\t\tcase LIGHTSHAPE_DISK:\n\t\t\t\treturn 'Disk';\n\t\t\tcase LIGHTSHAPE_SPHERE:\n\t\t\t\treturn 'Sphere';\n\t\t\tdefault:\n\t\t\t\treturn '';\n\t\t}\n\t}\n\tgenerateVertexShader(useUv, useUnmodifiedUv, mapTransforms) {\n\t\tconst device = this.device;\n\t\tconst options = this.options;\n\t\tconst chunks = this.chunks;\n\t\tlet code = '';\n\t\tlet codeBody = '';\n\t\tcode = this._vsAddBaseCode(code, chunks, options);\n\t\tcodeBody += \" vPositionW = getWorldPosition();\\n\";\n\t\tif (this.options.pass === SHADER_DEPTH || this.options.pass === SHADER_PREPASS_VELOCITY) {\n\t\t\tcode += 'varying float vDepth;\\n';\n\t\t\tcode += '#ifndef VIEWMATRIX\\n';\n\t\t\tcode += '#define VIEWMATRIX\\n';\n\t\t\tcode += 'uniform mat4 matrix_view;\\n';\n\t\t\tcode += '#endif\\n';\n\t\t\tcode += '#ifndef CAMERAPLANES\\n';\n\t\t\tcode += '#define CAMERAPLANES\\n';\n\t\t\tcode += 'uniform vec4 camera_params;\\n\\n';\n\t\t\tcode += '#endif\\n';\n\t\t\tcodeBody += \" vDepth = -(matrix_view * vec4(vPositionW,1.0)).z * camera_params.x;\\n\";\n\t\t}\n\t\tif (this.options.pass === SHADER_PREPASS_VELOCITY) ;\n\t\tif (this.options.useInstancing) {\n\t\t\tthis.attributes.instance_line1 = SEMANTIC_ATTR12;\n\t\t\tthis.attributes.instance_line2 = SEMANTIC_ATTR13;\n\t\t\tthis.attributes.instance_line3 = SEMANTIC_ATTR14;\n\t\t\tthis.attributes.instance_line4 = SEMANTIC_ATTR15;\n\t\t\tcode += chunks.instancingVS;\n\t\t}\n\t\tif (this.needsNormal) {\n\t\t\tthis.attributes.vertex_normal = SEMANTIC_NORMAL;\n\t\t\tcodeBody += \" vNormalW = getNormal();\\n\";\n\t\t\tif (options.reflectionSource === 'sphereMap' && device.fragmentUniformsCount <= 16) {\n\t\t\t\tcode += chunks.viewNormalVS;\n\t\t\t\tcodeBody += \" vNormalV = getViewNormal();\\n\";\n\t\t\t}\n\t\t\tif (options.hasTangents && (options.useHeights || options.useNormals || options.enableGGXSpecular)) {\n\t\t\t\tthis.attributes.vertex_tangent = SEMANTIC_TANGENT;\n\t\t\t\tcode += chunks.tangentBinormalVS;\n\t\t\t\tcodeBody += \" vTangentW = getTangent();\\n\";\n\t\t\t\tcodeBody += \" vBinormalW = getBinormal();\\n\";\n\t\t\t} else if (options.enableGGXSpecular || !device.extStandardDerivatives) {\n\t\t\t\tcodeBody += \" vObjectSpaceUpW = normalize(dNormalMatrix * vec3(0, 1, 0));\\n\";\n\t\t\t}\n\t\t}\n\t\tconst maxUvSets = 2;\n\t\tfor (let i = 0; i < maxUvSets; i++) {\n\t\t\tif (useUv[i]) {\n\t\t\t\tthis.attributes[\"vertex_texCoord\" + i] = \"TEXCOORD\" + i;\n\t\t\t\tcode += chunks[\"uv\" + i + \"VS\"];\n\t\t\t\tcodeBody += \" vec2 uv\" + i + \" = getUv\" + i + \"();\\n\";\n\t\t\t}\n\t\t\tif (useUnmodifiedUv[i]) {\n\t\t\t\tcodeBody += \" vUv\" + i + \" = uv\" + i + \";\\n\";\n\t\t\t}\n\t\t}\n\t\tconst codes = [code, this.varyings, codeBody, []];\n\t\tmapTransforms.forEach(mapTransform => {\n\t\t\tthis._setMapTransform(codes, mapTransform.name, mapTransform.id, mapTransform.uv);\n\t\t});\n\t\tcode = codes[0];\n\t\tthis.varyings = codes[1];\n\t\tcodeBody = codes[2];\n\t\tif (options.vertexColors) {\n\t\t\tthis.attributes.vertex_color = SEMANTIC_COLOR;\n\t\t\tcodeBody += \" vVertexColor = vertex_color;\\n\";\n\t\t}\n\t\tif (options.useMsdf && options.msdfTextAttribute) {\n\t\t\tthis.attributes.vertex_outlineParameters = SEMANTIC_ATTR8;\n\t\t\tthis.attributes.vertex_shadowParameters = SEMANTIC_ATTR9;\n\t\t\tcodeBody += \" unpackMsdfParams();\\n\";\n\t\t\tcode += chunks.msdfVS;\n\t\t}\n\t\tif (options.useMorphPosition || options.useMorphNormal) {\n\t\t\tif (options.useMorphTextureBased) {\n\t\t\t\tcode += \"#define MORPHING_TEXTURE_BASED\\n\";\n\t\t\t\tif (options.useMorphPosition) {\n\t\t\t\t\tcode += \"#define MORPHING_TEXTURE_BASED_POSITION\\n\";\n\t\t\t\t}\n\t\t\t\tif (options.useMorphNormal) {\n\t\t\t\t\tcode += \"#define MORPHING_TEXTURE_BASED_NORMAL\\n\";\n\t\t\t\t}\n\t\t\t\tthis.attributes.morph_vertex_id = SEMANTIC_ATTR15;\n\t\t\t\tconst morphIdType = device.isWebGPU ? 'uint' : 'float';\n\t\t\t\tcode += `attribute ${morphIdType} morph_vertex_id;\\n`;\n\t\t\t} else {\n\t\t\t\tcode += \"#define MORPHING\\n\";\n\t\t\t\tif (options.useMorphPosition) {\n\t\t\t\t\tthis.attributes.morph_pos0 = SEMANTIC_ATTR8;\n\t\t\t\t\tthis.attributes.morph_pos1 = SEMANTIC_ATTR9;\n\t\t\t\t\tthis.attributes.morph_pos2 = SEMANTIC_ATTR10;\n\t\t\t\t\tthis.attributes.morph_pos3 = SEMANTIC_ATTR11;\n\t\t\t\t\tcode += \"#define MORPHING_POS03\\n\";\n\t\t\t\t\tcode += \"attribute vec3 morph_pos0;\\n\";\n\t\t\t\t\tcode += \"attribute vec3 morph_pos1;\\n\";\n\t\t\t\t\tcode += \"attribute vec3 morph_pos2;\\n\";\n\t\t\t\t\tcode += \"attribute vec3 morph_pos3;\\n\";\n\t\t\t\t} else if (options.useMorphNormal) {\n\t\t\t\t\tthis.attributes.morph_nrm0 = SEMANTIC_ATTR8;\n\t\t\t\t\tthis.attributes.morph_nrm1 = SEMANTIC_ATTR9;\n\t\t\t\t\tthis.attributes.morph_nrm2 = SEMANTIC_ATTR10;\n\t\t\t\t\tthis.attributes.morph_nrm3 = SEMANTIC_ATTR11;\n\t\t\t\t\tcode += \"#define MORPHING_NRM03\\n\";\n\t\t\t\t\tcode += \"attribute vec3 morph_nrm0;\\n\";\n\t\t\t\t\tcode += \"attribute vec3 morph_nrm1;\\n\";\n\t\t\t\t\tcode += \"attribute vec3 morph_nrm2;\\n\";\n\t\t\t\t\tcode += \"attribute vec3 morph_nrm3;\\n\";\n\t\t\t\t}\n\t\t\t\tif (!options.useMorphNormal) {\n\t\t\t\t\tthis.attributes.morph_pos4 = SEMANTIC_ATTR12;\n\t\t\t\t\tthis.attributes.morph_pos5 = SEMANTIC_ATTR13;\n\t\t\t\t\tthis.attributes.morph_pos6 = SEMANTIC_ATTR14;\n\t\t\t\t\tthis.attributes.morph_pos7 = SEMANTIC_ATTR15;\n\t\t\t\t\tcode += \"#define MORPHING_POS47\\n\";\n\t\t\t\t\tcode += \"attribute vec3 morph_pos4;\\n\";\n\t\t\t\t\tcode += \"attribute vec3 morph_pos5;\\n\";\n\t\t\t\t\tcode += \"attribute vec3 morph_pos6;\\n\";\n\t\t\t\t\tcode += \"attribute vec3 morph_pos7;\\n\";\n\t\t\t\t} else {\n\t\t\t\t\tthis.attributes.morph_nrm4 = SEMANTIC_ATTR12;\n\t\t\t\t\tthis.attributes.morph_nrm5 = SEMANTIC_ATTR13;\n\t\t\t\t\tthis.attributes.morph_nrm6 = SEMANTIC_ATTR14;\n\t\t\t\t\tthis.attributes.morph_nrm7 = SEMANTIC_ATTR15;\n\t\t\t\t\tcode += \"#define MORPHING_NRM47\\n\";\n\t\t\t\t\tcode += \"attribute vec3 morph_nrm4;\\n\";\n\t\t\t\t\tcode += \"attribute vec3 morph_nrm5;\\n\";\n\t\t\t\t\tcode += \"attribute vec3 morph_nrm6;\\n\";\n\t\t\t\t\tcode += \"attribute vec3 morph_nrm7;\\n\";\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (options.skin) {\n\t\t\tthis.attributes.vertex_boneWeights = SEMANTIC_BLENDWEIGHT;\n\t\t\tthis.attributes.vertex_boneIndices = SEMANTIC_BLENDINDICES;\n\t\t\tcode += ShaderGenerator.skinCode(device, chunks);\n\t\t\tcode += \"#define SKIN\\n\";\n\t\t} else if (options.useInstancing) {\n\t\t\tcode += \"#define INSTANCING\\n\";\n\t\t}\n\t\tif (options.screenSpace) {\n\t\t\tcode += \"#define SCREENSPACE\\n\";\n\t\t}\n\t\tif (options.pixelSnap) {\n\t\t\tcode += \"#define PIXELSNAP\\n\";\n\t\t}\n\t\tcode = this._vsAddTransformCode(code, device, chunks, options);\n\t\tif (this.needsNormal) {\n\t\t\tcode += chunks.normalVS;\n\t\t}\n\t\tcode += \"\\n\";\n\t\tcode += chunks.startVS;\n\t\tcode += codeBody;\n\t\tcode += chunks.endVS;\n\t\tcode += \"}\";\n\t\tObject.keys(builtinVaryings).forEach(v => {\n\t\t\tif (code.indexOf(v) >= 0) {\n\t\t\t\tthis.varyings += `varying ${builtinVaryings[v]} ${v};\\n`;\n\t\t\t\tthis.varyingDefines += `#define VARYING_${v.toUpperCase()}\\n`;\n\t\t\t}\n\t\t});\n\t\tconst shaderPassDefines = this.shaderPassInfo.shaderDefines;\n\t\tthis.vshader = shaderPassDefines + this.varyings + code;\n\t}\n\t_fsGetBeginCode() {\n\t\tlet code = this.shaderPassInfo.shaderDefines;\n\t\tfor (let i = 0; i < this.defines.length; i++) {\n\t\t\tcode += `#define ${this.defines[i]}\\n`;\n\t\t}\n\t\treturn code;\n\t}\n\t_fsGetPickPassCode() {\n\t\tlet code = this._fsGetBeginCode();\n\t\tcode += \"uniform vec4 uColor;\\n\";\n\t\tcode += this.varyings;\n\t\tcode += this.varyingDefines;\n\t\tcode += this.frontendDecl;\n\t\tcode += this.frontendCode;\n\t\tcode += ShaderGenerator.begin();\n\t\tcode += this.frontendFunc;\n\t\tcode += \" gl_FragColor = uColor;\\n\";\n\t\tcode += ShaderGenerator.end();\n\t\treturn code;\n\t}\n\t_fsGetDepthPassCode() {\n\t\tconst chunks = this.chunks;\n\t\tlet code = this._fsGetBeginCode();\n\t\tcode += 'varying float vDepth;\\n';\n\t\tcode += this.varyings;\n\t\tcode += this.varyingDefines;\n\t\tcode += chunks.packDepthPS;\n\t\tcode += this.frontendDecl;\n\t\tcode += this.frontendCode;\n\t\tcode += ShaderGenerator.begin();\n\t\tcode += this.frontendFunc;\n\t\tcode += \" gl_FragColor = packFloat(vDepth);\\n\";\n\t\tcode += ShaderGenerator.end();\n\t\treturn code;\n\t}\n\t_fsGetPrePassVelocityCode() {\n\t\treturn this._fsGetDepthPassCode();\n\t}\n\t_fsGetShadowPassCode() {\n\t\tconst device = this.device;\n\t\tconst options = this.options;\n\t\tconst chunks = this.chunks;\n\t\tconst varyings = this.varyings;\n\t\tconst lightType = this.shaderPassInfo.lightType;\n\t\tlet shadowType = this.shaderPassInfo.shadowType;\n\t\tif (lightType !== LIGHTTYPE_DIRECTIONAL && options.clusteredLightingEnabled) {\n\t\t\tif (shadowType === SHADOW_VSM8 || shadowType === SHADOW_VSM16 || shadowType === SHADOW_VSM32 || shadowType === SHADOW_PCSS) {\n\t\t\t\tshadowType = SHADOW_PCF3;\n\t\t\t}\n\t\t}\n\t\tlet code = this._fsGetBeginCode();\n\t\tif (device.extStandardDerivatives && device.isWebGL1) {\n\t\t\tcode += 'uniform vec2 polygonOffset;\\n';\n\t\t}\n\t\tif (shadowType === SHADOW_VSM32) {\n\t\t\tif (device.textureFloatHighPrecision) {\n\t\t\t\tcode += '#define VSM_EXPONENT 15.0\\n\\n';\n\t\t\t} else {\n\t\t\t\tcode += '#define VSM_EXPONENT 5.54\\n\\n';\n\t\t\t}\n\t\t} else if (shadowType === SHADOW_VSM16) {\n\t\t\tcode += '#define VSM_EXPONENT 5.54\\n\\n';\n\t\t}\n\t\tif (lightType !== LIGHTTYPE_DIRECTIONAL) {\n\t\t\tcode += 'uniform vec3 view_position;\\n';\n\t\t\tcode += 'uniform float light_radius;\\n';\n\t\t}\n\t\tcode += varyings;\n\t\tcode += this.varyingDefines;\n\t\tcode += this.frontendDecl;\n\t\tcode += this.frontendCode;\n\t\tconst mayPackDepth = shadowType === SHADOW_PCF1 || shadowType === SHADOW_PCF3 || shadowType === SHADOW_PCF5 || shadowType === SHADOW_PCSS;\n\t\tconst mustPackDepth = lightType === LIGHTTYPE_OMNI && shadowType !== SHADOW_PCSS && !options.clusteredLightingEnabled;\n\t\tconst usePackedDepth = mayPackDepth && !device.supportsDepthShadow || mustPackDepth;\n\t\tif (usePackedDepth) {\n\t\t\tcode += chunks.packDepthPS;\n\t\t} else if (shadowType === SHADOW_VSM8) {\n\t\t\tcode += \"vec2 encodeFloatRG( float v ) {\\n\";\n\t\t\tcode += \" vec2 enc = vec2(1.0, 255.0) * v;\\n\";\n\t\t\tcode += \" enc = fract(enc);\\n\";\n\t\t\tcode += \" enc -= enc.yy * vec2(1.0/255.0, 1.0/255.0);\\n\";\n\t\t\tcode += \" return enc;\\n\";\n\t\t\tcode += \"}\\n\\n\";\n\t\t}\n\t\tif (shadowType === SHADOW_PCSS) {\n\t\t\tcode += shaderChunks.linearizeDepthPS;\n\t\t}\n\t\tcode += ShaderGenerator.begin();\n\t\tcode += this.frontendFunc;\n\t\tconst isVsm = shadowType === SHADOW_VSM8 || shadowType === SHADOW_VSM16 || shadowType === SHADOW_VSM32;\n\t\tconst applySlopeScaleBias = device.isWebGL1 && device.extStandardDerivatives;\n\t\tconst usePerspectiveDepth = lightType === LIGHTTYPE_DIRECTIONAL || !isVsm && lightType === LIGHTTYPE_SPOT;\n\t\tlet hasModifiedDepth = false;\n\t\tif (usePerspectiveDepth) {\n\t\t\tcode += \" float depth = gl_FragCoord.z;\\n\";\n\t\t} else {\n\t\t\tcode += \" float depth = min(distance(view_position, vPositionW) / light_radius, 0.99999);\\n\";\n\t\t\thasModifiedDepth = true;\n\t\t}\n\t\tif (applySlopeScaleBias) {\n\t\t\tcode += \" float minValue = 2.3374370500153186e-10; //(1.0 / 255.0) / (256.0 * 256.0 * 256.0);\\n\";\n\t\t\tcode += \" depth += polygonOffset.x * max(abs(dFdx(depth)), abs(dFdy(depth))) + minValue * polygonOffset.y;\\n\";\n\t\t\thasModifiedDepth = true;\n\t\t}\n\t\tif (usePackedDepth) {\n\t\t\tcode += \" gl_FragColor = packFloat(depth);\\n\";\n\t\t} else if (!isVsm) {\n\t\t\tconst exportR32 = shadowType === SHADOW_PCSS;\n\t\t\tif (exportR32) {\n\t\t\t\tcode += \" gl_FragColor.r = depth;\\n\";\n\t\t\t} else {\n\t\t\t\tif (hasModifiedDepth) {\n\t\t\t\t\tcode += \" gl_FragDepth = depth;\\n\";\n\t\t\t\t}\n\t\t\t\tcode += \" gl_FragColor = vec4(1.0);\\n\";\n\t\t\t}\n\t\t} else if (shadowType === SHADOW_VSM8) {\n\t\t\tcode += \" gl_FragColor = vec4(encodeFloatRG(depth), encodeFloatRG(depth*depth));\\n\";\n\t\t} else {\n\t\t\tcode += chunks.storeEVSMPS;\n\t\t}\n\t\tcode += ShaderGenerator.end();\n\t\treturn code;\n\t}\n\t_fsGetLitPassCode() {\n\t\tconst device = this.device;\n\t\tconst options = this.options;\n\t\tconst chunks = this.chunks;\n\t\tconst decl = new ChunkBuilder();\n\t\tconst func = new ChunkBuilder();\n\t\tconst backend = new ChunkBuilder();\n\t\tconst code = new ChunkBuilder();\n\t\tif (options.opacityFadesSpecular === false) {\n\t\t\tdecl.append('uniform float material_alphaFade;');\n\t\t}\n\t\tif (options.useSpecular) {\n\t\t\tthis.defines.push(\"LIT_SPECULAR\");\n\t\t\tif (this.reflections) {\n\t\t\t\tthis.defines.push(\"LIT_REFLECTIONS\");\n\t\t\t}\n\t\t\tif (options.useClearCoat) {\n\t\t\t\tthis.defines.push(\"LIT_CLEARCOAT\");\n\t\t\t}\n\t\t\tif (options.fresnelModel > 0) {\n\t\t\t\tthis.defines.push(\"LIT_SPECULAR_FRESNEL\");\n\t\t\t}\n\t\t\tif (options.conserveEnergy) {\n\t\t\t\tthis.defines.push(\"LIT_CONSERVE_ENERGY\");\n\t\t\t}\n\t\t\tif (options.useSheen) {\n\t\t\t\tthis.defines.push(\"LIT_SHEEN\");\n\t\t\t}\n\t\t\tif (options.useIridescence) {\n\t\t\t\tthis.defines.push(\"LIT_IRIDESCENCE\");\n\t\t\t}\n\t\t}\n\t\tconst shadowTypeUsed = [];\n\t\tlet numShadowLights = 0;\n\t\tlet shadowedDirectionalLightUsed = false;\n\t\tlet useVsm = false;\n\t\tlet usePcss = false;\n\t\tlet hasAreaLights = options.lights.some(function (light) {\n\t\t\treturn light._shape && light._shape !== LIGHTSHAPE_PUNCTUAL;\n\t\t});\n\t\tif (options.clusteredLightingEnabled && options.clusteredLightingAreaLightsEnabled) {\n\t\t\thasAreaLights = true;\n\t\t}\n\t\tif (hasAreaLights || options.clusteredLightingEnabled) {\n\t\t\tlet areaLutsPrecision = 'highp';\n\t\t\tif (device.areaLightLutFormat === PIXELFORMAT_RGBA8) {\n\t\t\t\tdecl.append(\"#define AREA_R8_G8_B8_A8_LUTS\");\n\t\t\t\tareaLutsPrecision = 'lowp';\n\t\t\t}\n\t\t\tdecl.append(\"#define AREA_LIGHTS\");\n\t\t\tdecl.append(`uniform ${areaLutsPrecision} sampler2D areaLightsLutTex1;`);\n\t\t\tdecl.append(`uniform ${areaLutsPrecision} sampler2D areaLightsLutTex2;`);\n\t\t}\n\t\tfor (let i = 0; i < options.lights.length; i++) {\n\t\t\tconst light = options.lights[i];\n\t\t\tconst lightType = light._type;\n\t\t\tif (options.clusteredLightingEnabled && lightType !== LIGHTTYPE_DIRECTIONAL) continue;\n\t\t\tconst lightShape = hasAreaLights && light._shape ? light._shape : LIGHTSHAPE_PUNCTUAL;\n\t\t\tdecl.append(\"uniform vec3 light\" + i + \"_color;\");\n\t\t\tif (light._shadowType === SHADOW_PCSS && light.castShadows && !options.noShadow) {\n\t\t\t\tdecl.append(`uniform float light${i}_shadowSearchArea;`);\n\t\t\t\tdecl.append(`uniform vec4 light${i}_cameraParams;`);\n\t\t\t}\n\t\t\tif (lightType === LIGHTTYPE_DIRECTIONAL) {\n\t\t\t\tdecl.append(\"uniform vec3 light\" + i + \"_direction;\");\n\t\t\t} else {\n\t\t\t\tdecl.append(\"uniform vec3 light\" + i + \"_position;\");\n\t\t\t\tdecl.append(\"uniform float light\" + i + \"_radius;\");\n\t\t\t\tif (lightType === LIGHTTYPE_SPOT) {\n\t\t\t\t\tdecl.append(\"uniform vec3 light\" + i + \"_direction;\");\n\t\t\t\t\tdecl.append(\"uniform float light\" + i + \"_innerConeAngle;\");\n\t\t\t\t\tdecl.append(\"uniform float light\" + i + \"_outerConeAngle;\");\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (lightShape !== LIGHTSHAPE_PUNCTUAL) {\n\t\t\t\tif (lightType === LIGHTTYPE_DIRECTIONAL) {\n\t\t\t\t\tdecl.append(\"uniform vec3 light\" + i + \"_position;\");\n\t\t\t\t}\n\t\t\t\tdecl.append(\"uniform vec3 light\" + i + \"_halfWidth;\");\n\t\t\t\tdecl.append(\"uniform vec3 light\" + i + \"_halfHeight;\");\n\t\t\t}\n\t\t\tif (light.castShadows && !options.noShadow) {\n\t\t\t\tdecl.append(\"uniform mat4 light\" + i + \"_shadowMatrix;\");\n\t\t\t\tdecl.append(\"uniform float light\" + i + \"_shadowIntensity;\");\n\t\t\t\tif (lightType === LIGHTTYPE_DIRECTIONAL) {\n\t\t\t\t\tdecl.append(\"uniform mat4 light\" + i + \"_shadowMatrixPalette[4];\");\n\t\t\t\t\tdecl.append(\"uniform float light\" + i + \"_shadowCascadeDistances[4];\");\n\t\t\t\t\tdecl.append(\"uniform float light\" + i + \"_shadowCascadeCount;\");\n\t\t\t\t}\n\t\t\t\tdecl.append(\"uniform vec4 light\" + i + \"_shadowParams;\");\n\t\t\t\tif (lightType === LIGHTTYPE_DIRECTIONAL) {\n\t\t\t\t\tshadowedDirectionalLightUsed = true;\n\t\t\t\t}\n\t\t\t\tif (lightType === LIGHTTYPE_OMNI) {\n\t\t\t\t\tdecl.append(\"uniform samplerCube light\" + i + \"_shadowMap;\");\n\t\t\t\t} else {\n\t\t\t\t\tif (light._isPcf && device.supportsDepthShadow) {\n\t\t\t\t\t\tdecl.append(\"uniform sampler2DShadow light\" + i + \"_shadowMap;\");\n\t\t\t\t\t} else {\n\t\t\t\t\t\tdecl.append(\"uniform sampler2D light\" + i + \"_shadowMap;\");\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tnumShadowLights++;\n\t\t\t\tshadowTypeUsed[light._shadowType] = true;\n\t\t\t\tif (light._isVsm) useVsm = true;\n\t\t\t\tif (light._shadowType === SHADOW_PCSS) usePcss = true;\n\t\t\t}\n\t\t\tif (light._cookie) {\n\t\t\t\tif (light._cookie._cubemap) {\n\t\t\t\t\tif (lightType === LIGHTTYPE_OMNI) {\n\t\t\t\t\t\tdecl.append(\"uniform samplerCube light\" + i + \"_cookie;\");\n\t\t\t\t\t\tdecl.append(\"uniform float light\" + i + \"_cookieIntensity;\");\n\t\t\t\t\t\tif (!light.castShadows || options.noShadow) {\n\t\t\t\t\t\t\tdecl.append(\"uniform mat4 light\" + i + \"_shadowMatrix;\");\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tif (lightType === LIGHTTYPE_SPOT) {\n\t\t\t\t\t\tdecl.append(\"uniform sampler2D light\" + i + \"_cookie;\");\n\t\t\t\t\t\tdecl.append(\"uniform float light\" + i + \"_cookieIntensity;\");\n\t\t\t\t\t\tif (!light.castShadows || options.noShadow) {\n\t\t\t\t\t\t\tdecl.append(\"uniform mat4 light\" + i + \"_shadowMatrix;\");\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (light._cookieTransform) {\n\t\t\t\t\t\t\tdecl.append(\"uniform vec4 light\" + i + \"_cookieMatrix;\");\n\t\t\t\t\t\t\tdecl.append(\"uniform vec2 light\" + i + \"_cookieOffset;\");\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tconst hasTBN = this.needsNormal && (options.useNormals || options.useClearCoatNormals || options.enableGGXSpecular && !options.useHeights);\n\t\tif (hasTBN) {\n\t\t\tif (options.hasTangents) {\n\t\t\t\tfunc.append(options.fastTbn ? chunks.TBNfastPS : chunks.TBNPS);\n\t\t\t} else {\n\t\t\t\tif (device.extStandardDerivatives && (options.useNormals || options.useClearCoatNormals)) {\n\t\t\t\t\tfunc.append(chunks.TBNderivativePS.replace(/\\$UV/g, this.lightingUv));\n\t\t\t\t} else {\n\t\t\t\t\tfunc.append(chunks.TBNObjectSpacePS);\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (options.twoSidedLighting) {\n\t\t\t\tfunc.append(chunks.twoSidedLightingPS);\n\t\t\t}\n\t\t}\n\t\tfunc.append(chunks.sphericalPS);\n\t\tfunc.append(chunks.decodePS);\n\t\tfunc.append(ShaderGenerator.gammaCode(options.gamma, chunks));\n\t\tfunc.append(ShaderGenerator.tonemapCode(options.toneMap, chunks));\n\t\tfunc.append(ShaderGenerator.fogCode(options.fog, chunks));\n\t\tfunc.append(this.frontendCode);\n\t\tif (options.useCubeMapRotation) {\n\t\t\tdecl.append(\"#define CUBEMAP_ROTATION\");\n\t\t}\n\t\tif (this.needsNormal) {\n\t\t\tfunc.append(chunks.cubeMapRotatePS);\n\t\t\tfunc.append(options.cubeMapProjection > 0 ? chunks.cubeMapProjectBoxPS : chunks.cubeMapProjectNonePS);\n\t\t\tfunc.append(options.skyboxIntensity ? chunks.envMultiplyPS : chunks.envConstPS);\n\t\t}\n\t\tif (this.lighting && options.useSpecular || this.reflections) {\n\t\t\tif (options.useMetalness) {\n\t\t\t\tfunc.append(chunks.metalnessModulatePS);\n\t\t\t}\n\t\t\tif (options.fresnelModel === FRESNEL_SCHLICK) {\n\t\t\t\tfunc.append(chunks.fresnelSchlickPS);\n\t\t\t}\n\t\t\tif (options.useIridescence) {\n\t\t\t\tfunc.append(chunks.iridescenceDiffractionPS);\n\t\t\t}\n\t\t}\n\t\tif (options.useAo) {\n\t\t\tfunc.append(chunks.aoDiffuseOccPS);\n\t\t\tswitch (options.occludeSpecular) {\n\t\t\t\tcase SPECOCC_AO:\n\t\t\t\t\tfunc.append(options.occludeSpecularFloat ? chunks.aoSpecOccSimplePS : chunks.aoSpecOccConstSimplePS);\n\t\t\t\t\tbreak;\n\t\t\t\tcase SPECOCC_GLOSSDEPENDENT:\n\t\t\t\t\tfunc.append(options.occludeSpecularFloat ? chunks.aoSpecOccPS : chunks.aoSpecOccConstPS);\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\tif (options.reflectionSource === 'envAtlasHQ') {\n\t\t\tfunc.append(options.fixSeams ? chunks.fixCubemapSeamsStretchPS : chunks.fixCubemapSeamsNonePS);\n\t\t\tfunc.append(chunks.envAtlasPS);\n\t\t\tfunc.append(chunks.reflectionEnvHQPS.replace(/\\$DECODE_CUBEMAP/g, ChunkUtils.decodeFunc(options.reflectionCubemapEncoding)).replace(/\\$DECODE/g, ChunkUtils.decodeFunc(options.reflectionEncoding)));\n\t\t} else if (options.reflectionSource === 'envAtlas') {\n\t\t\tfunc.append(chunks.envAtlasPS);\n\t\t\tfunc.append(chunks.reflectionEnvPS.replace(/\\$DECODE/g, ChunkUtils.decodeFunc(options.reflectionEncoding)));\n\t\t} else if (options.reflectionSource === 'cubeMap') {\n\t\t\tfunc.append(options.fixSeams ? chunks.fixCubemapSeamsStretchPS : chunks.fixCubemapSeamsNonePS);\n\t\t\tfunc.append(chunks.reflectionCubePS.replace(/\\$DECODE/g, ChunkUtils.decodeFunc(options.reflectionEncoding)));\n\t\t} else if (options.reflectionSource === 'sphereMap') {\n\t\t\tfunc.append(chunks.reflectionSpherePS.replace(/\\$DECODE/g, ChunkUtils.decodeFunc(options.reflectionEncoding)));\n\t\t}\n\t\tif (this.reflections) {\n\t\t\tif (options.useClearCoat) {\n\t\t\t\tfunc.append(chunks.reflectionCCPS);\n\t\t\t}\n\t\t\tif (options.useSheen) {\n\t\t\t\tfunc.append(chunks.reflectionSheenPS);\n\t\t\t}\n\t\t}\n\t\tif (options.useRefraction) {\n\t\t\tif (options.useDynamicRefraction) {\n\t\t\t\tif (options.dispersion) {\n\t\t\t\t\tdecl.append(\"uniform float material_dispersion;\");\n\t\t\t\t\tdecl.append('#define DISPERSION\\n');\n\t\t\t\t}\n\t\t\t\tfunc.append(chunks.refractionDynamicPS);\n\t\t\t} else if (this.reflections) {\n\t\t\t\tfunc.append(chunks.refractionCubePS);\n\t\t\t}\n\t\t}\n\t\tif (options.useSheen) {\n\t\t\tfunc.append(chunks.lightSheenPS);\n\t\t}\n\t\tif (options.clusteredLightingEnabled) {\n\t\t\tfunc.append(chunks.clusteredLightUtilsPS);\n\t\t\tif (options.clusteredLightingCookiesEnabled) func.append(chunks.clusteredLightCookiesPS);\n\t\t\tif (options.clusteredLightingShadowsEnabled && !options.noShadow) {\n\t\t\t\tshadowTypeUsed[SHADOW_PCF3] = true;\n\t\t\t\tshadowTypeUsed[SHADOW_PCF5] = true;\n\t\t\t\tshadowTypeUsed[SHADOW_PCSS] = true;\n\t\t\t}\n\t\t}\n\t\tif (numShadowLights > 0 || options.clusteredLightingEnabled) {\n\t\t\tif (shadowedDirectionalLightUsed) {\n\t\t\t\tfunc.append(chunks.shadowCascadesPS);\n\t\t\t}\n\t\t\tif (shadowTypeUsed[SHADOW_PCF1] || shadowTypeUsed[SHADOW_PCF3]) {\n\t\t\t\tfunc.append(chunks.shadowStandardPS);\n\t\t\t}\n\t\t\tif (shadowTypeUsed[SHADOW_PCF5] && !device.isWebGL1) {\n\t\t\t\tfunc.append(chunks.shadowStandardGL2PS);\n\t\t\t}\n\t\t\tif (useVsm) {\n\t\t\t\tfunc.append(chunks.shadowVSM_commonPS);\n\t\t\t\tif (shadowTypeUsed[SHADOW_VSM8]) {\n\t\t\t\t\tfunc.append(chunks.shadowVSM8PS);\n\t\t\t\t}\n\t\t\t\tif (shadowTypeUsed[SHADOW_VSM16]) {\n\t\t\t\t\tfunc.append(device.extTextureHalfFloatLinear ? chunks.shadowEVSMPS.replace(/\\$/g, \"16\") : chunks.shadowEVSMnPS.replace(/\\$/g, \"16\"));\n\t\t\t\t}\n\t\t\t\tif (shadowTypeUsed[SHADOW_VSM32]) {\n\t\t\t\t\tfunc.append(device.extTextureFloatLinear ? chunks.shadowEVSMPS.replace(/\\$/g, \"32\") : chunks.shadowEVSMnPS.replace(/\\$/g, \"32\"));\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (usePcss) {\n\t\t\t\tfunc.append(chunks.linearizeDepthPS);\n\t\t\t\tfunc.append(chunks.shadowPCSSPS);\n\t\t\t}\n\t\t\tif (!(device.isWebGL2 || device.isWebGPU || device.extStandardDerivatives)) {\n\t\t\t\tfunc.append(chunks.biasConstPS);\n\t\t\t}\n\t\t}\n\t\tif (options.enableGGXSpecular) func.append(\"uniform float material_anisotropy;\");\n\t\tif (this.lighting) {\n\t\t\tfunc.append(chunks.lightDiffuseLambertPS);\n\t\t\tif (hasAreaLights || options.clusteredLightingAreaLightsEnabled) {\n\t\t\t\tfunc.append(chunks.ltcPS);\n\t\t\t}\n\t\t}\n\t\tlet useOldAmbient = false;\n\t\tif (options.useSpecular) {\n\t\t\tif (this.lighting) {\n\t\t\t\tfunc.append(options.shadingModel === SPECULAR_PHONG ? chunks.lightSpecularPhongPS : options.enableGGXSpecular ? chunks.lightSpecularAnisoGGXPS : chunks.lightSpecularBlinnPS);\n\t\t\t}\n\t\t\tif (!options.fresnelModel && !this.reflections && !options.diffuseMapEnabled) {\n\t\t\t\tdecl.append(\"uniform vec3 material_ambient;\");\n\t\t\t\tdecl.append(\"#define LIT_OLD_AMBIENT\");\n\t\t\t\tuseOldAmbient = true;\n\t\t\t}\n\t\t}\n\t\tfunc.append(chunks.combinePS);\n\t\tif (options.lightMapEnabled) {\n\t\t\tfunc.append(options.useSpecular && options.dirLightMapEnabled ? chunks.lightmapDirAddPS : chunks.lightmapAddPS);\n\t\t}\n\t\tconst addAmbient = !options.lightMapEnabled || options.lightMapWithoutAmbient;\n\t\tif (addAmbient) {\n\t\t\tif (options.ambientSource === 'ambientSH') {\n\t\t\t\tfunc.append(chunks.ambientSHPS);\n\t\t\t} else if (options.ambientSource === 'envAtlas') {\n\t\t\t\tif (options.reflectionSource !== 'envAtlas' && options.reflectionSource !== 'envAtlasHQ') {\n\t\t\t\t\tfunc.append(chunks.envAtlasPS);\n\t\t\t\t}\n\t\t\t\tfunc.append(chunks.ambientEnvPS.replace(/\\$DECODE/g, ChunkUtils.decodeFunc(options.ambientEncoding)));\n\t\t\t} else {\n\t\t\t\tfunc.append(chunks.ambientConstantPS);\n\t\t\t}\n\t\t}\n\t\tif (options.useAmbientTint && !useOldAmbient) {\n\t\t\tdecl.append(\"uniform vec3 material_ambient;\");\n\t\t}\n\t\tif (options.useMsdf) {\n\t\t\tif (!options.msdfTextAttribute) {\n\t\t\t\tdecl.append(\"#define UNIFORM_TEXT_PARAMETERS\");\n\t\t\t}\n\t\t\tfunc.append(chunks.msdfPS);\n\t\t}\n\t\tif (this.needsNormal) {\n\t\t\tfunc.append(chunks.viewDirPS);\n\t\t\tif (options.useSpecular) {\n\t\t\t\tfunc.append(options.enableGGXSpecular ? chunks.reflDirAnisoPS : chunks.reflDirPS);\n\t\t\t}\n\t\t}\n\t\tlet hasPointLights = false;\n\t\tlet usesLinearFalloff = false;\n\t\tlet usesInvSquaredFalloff = false;\n\t\tlet usesSpot = false;\n\t\tlet usesCookie = false;\n\t\tlet usesCookieNow;\n\t\tif (options.clusteredLightingEnabled && this.lighting) {\n\t\t\tusesSpot = true;\n\t\t\thasPointLights = true;\n\t\t\tusesLinearFalloff = true;\n\t\t\tusesCookie = true;\n\t\t\tfunc.append(chunks.floatUnpackingPS);\n\t\t\tif (options.lightMaskDynamic) decl.append(\"#define CLUSTER_MESH_DYNAMIC_LIGHTS\");\n\t\t\tif (options.clusteredLightingCookiesEnabled) decl.append(\"#define CLUSTER_COOKIES\");\n\t\t\tif (options.clusteredLightingShadowsEnabled && !options.noShadow) {\n\t\t\t\tdecl.append(\"#define CLUSTER_SHADOWS\");\n\t\t\t\tdecl.append(\"#define CLUSTER_SHADOW_TYPE_\" + shadowTypeToString[options.clusteredLightingShadowType]);\n\t\t\t}\n\t\t\tif (options.clusteredLightingAreaLightsEnabled) decl.append(\"#define CLUSTER_AREALIGHTS\");\n\t\t\tdecl.append(LightsBuffer.getShaderDefines(device));\n\t\t\tif (options.clusteredLightingShadowsEnabled && !options.noShadow) {\n\t\t\t\tfunc.append(chunks.clusteredLightShadowsPS);\n\t\t\t}\n\t\t\tfunc.append(chunks.clusteredLightPS);\n\t\t}\n\t\tcode.append(this._fsGetStartCode(code, device, chunks, options));\n\t\tif (this.needsNormal) {\n\t\t\tcode.append(\" dVertexNormalW = normalize(vNormalW);\");\n\t\t\tif ((options.useHeights || options.useNormals) && options.hasTangents) {\n\t\t\t\tcode.append(\" dTangentW = vTangentW;\");\n\t\t\t\tcode.append(\" dBinormalW = vBinormalW;\");\n\t\t\t}\n\t\t\tcode.append(\" getViewDir();\");\n\t\t\tif (hasTBN) {\n\t\t\t\tcode.append(\" getTBN(dTangentW, dBinormalW, dVertexNormalW);\");\n\t\t\t\tif (options.twoSidedLighting) {\n\t\t\t\t\tcode.append(\" handleTwoSidedLighting();\");\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tcode.append(this.frontendFunc);\n\t\tif (this.needsNormal) {\n\t\t\tif (options.useSpecular) {\n\t\t\t\tbackend.append(\" getReflDir(litArgs_worldNormal, dViewDirW, litArgs_gloss, dTBN);\");\n\t\t\t}\n\t\t\tif (options.useClearCoat) {\n\t\t\t\tbackend.append(\" ccReflDirW = normalize(-reflect(dViewDirW, litArgs_clearcoat_worldNormal));\");\n\t\t\t}\n\t\t}\n\t\tif (this.lighting && options.useSpecular || this.reflections) {\n\t\t\tif (options.useMetalness) {\n\t\t\t\tbackend.append(\" float f0 = 1.0 / litArgs_ior; f0 = (f0 - 1.0) / (f0 + 1.0); f0 *= f0;\");\n\t\t\t\tbackend.append(\" litArgs_specularity = getSpecularModulate(litArgs_specularity, litArgs_albedo, litArgs_metalness, f0);\");\n\t\t\t\tbackend.append(\" litArgs_albedo = getAlbedoModulate(litArgs_albedo, litArgs_metalness);\");\n\t\t\t}\n\t\t\tif (options.useIridescence) {\n\t\t\t\tbackend.append(\" vec3 iridescenceFresnel = getIridescence(saturate(dot(dViewDirW, litArgs_worldNormal)), litArgs_specularity, litArgs_iridescence_thickness);\");\n\t\t\t}\n\t\t}\n\t\tif (addAmbient) {\n\t\t\tbackend.append(\" addAmbient(litArgs_worldNormal);\");\n\t\t\tif (options.conserveEnergy && options.useSpecular) {\n\t\t\t\tbackend.append(` dDiffuseLight = dDiffuseLight * (1.0 - litArgs_specularity);`);\n\t\t\t}\n\t\t\tif (options.separateAmbient) {\n\t\t\t\tbackend.append(`\n\t\t\t\t\t\t\t\t\t\tvec3 dAmbientLight = dDiffuseLight;\n\t\t\t\t\t\t\t\t\t\tdDiffuseLight = vec3(0);\n\t\t\t\t\t\t\t\t`);\n\t\t\t}\n\t\t}\n\t\tif (options.useAmbientTint && !useOldAmbient) {\n\t\t\tbackend.append(\" dDiffuseLight *= material_ambient;\");\n\t\t}\n\t\tif (options.useAo && !options.occludeDirect) {\n\t\t\tbackend.append(\" occludeDiffuse(litArgs_ao);\");\n\t\t}\n\t\tif (options.lightMapEnabled) {\n\t\t\tbackend.append(` addLightMap(\n\t\t\t\t\t\t\t\tlitArgs_lightmap, \n\t\t\t\t\t\t\t\tlitArgs_lightmapDir, \n\t\t\t\t\t\t\t\tlitArgs_worldNormal, \n\t\t\t\t\t\t\t\tdViewDirW, \n\t\t\t\t\t\t\t\tdReflDirW, \n\t\t\t\t\t\t\t\tlitArgs_gloss, \n\t\t\t\t\t\t\t\tlitArgs_specularity, \n\t\t\t\t\t\t\t\tdVertexNormalW,\n\t\t\t\t\t\t\t\tdTBN\n\t\t\t\t\t\t#if defined(LIT_IRIDESCENCE)\n\t\t\t\t\t\t\t\t, iridescenceFresnel,\n\t\t\t\t\t\t\t\tlitArgs_iridescence_intensity\n\t\t\t\t\t\t#endif\n\t\t\t\t\t\t\t\t);`);\n\t\t}\n\t\tif (this.lighting || this.reflections) {\n\t\t\tif (this.reflections) {\n\t\t\t\tif (options.useClearCoat) {\n\t\t\t\t\tbackend.append(\" addReflectionCC(ccReflDirW, litArgs_clearcoat_gloss);\");\n\t\t\t\t\tif (options.fresnelModel > 0) {\n\t\t\t\t\t\tbackend.append(\" ccFresnel = getFresnelCC(dot(dViewDirW, litArgs_clearcoat_worldNormal));\");\n\t\t\t\t\t\tbackend.append(\" ccReflection.rgb *= ccFresnel;\");\n\t\t\t\t\t} else {\n\t\t\t\t\t\tbackend.append(\" ccFresnel = 0.0;\");\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tif (options.useSpecularityFactor) {\n\t\t\t\t\tbackend.append(\" ccReflection.rgb *= litArgs_specularityFactor;\");\n\t\t\t\t}\n\t\t\t\tif (options.useSheen) {\n\t\t\t\t\tbackend.append(\" addReflectionSheen(litArgs_worldNormal, dViewDirW, litArgs_sheen_gloss);\");\n\t\t\t\t}\n\t\t\t\tbackend.append(\" addReflection(dReflDirW, litArgs_gloss);\");\n\t\t\t\tif (options.fresnelModel > 0) {\n\t\t\t\t\tbackend.append(` dReflection.rgb *= \n\t\t\t\t\t\t\t\t\t\t\t\tgetFresnel(\n\t\t\t\t\t\t\t\t\t\t\t\t\t\tdot(dViewDirW, litArgs_worldNormal), \n\t\t\t\t\t\t\t\t\t\t\t\t\t\tlitArgs_gloss, \n\t\t\t\t\t\t\t\t\t\t\t\t\t\tlitArgs_specularity\n\t\t\t\t\t\t\t\t\t\t\t\t#if defined(LIT_IRIDESCENCE)\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t, iridescenceFresnel,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\tlitArgs_iridescence_intensity\n\t\t\t\t\t\t\t\t\t\t\t\t#endif\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t);`);\n\t\t\t\t} else {\n\t\t\t\t\tbackend.append(\" dReflection.rgb *= litArgs_specularity;\");\n\t\t\t\t}\n\t\t\t\tif (options.useSpecularityFactor) {\n\t\t\t\t\tbackend.append(\" dReflection.rgb *= litArgs_specularityFactor;\");\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (hasAreaLights) {\n\t\t\t\tbackend.append(\" dSpecularLight *= litArgs_specularity;\");\n\t\t\t\tif (options.useSpecular) {\n\t\t\t\t\tbackend.append(\" calcLTCLightValues(litArgs_gloss, litArgs_worldNormal, dViewDirW, litArgs_specularity, litArgs_clearcoat_gloss, litArgs_clearcoat_worldNormal, litArgs_clearcoat_specularity);\");\n\t\t\t\t}\n\t\t\t}\n\t\t\tfor (let i = 0; i < options.lights.length; i++) {\n\t\t\t\tconst light = options.lights[i];\n\t\t\t\tconst lightType = light._type;\n\t\t\t\tif (options.clusteredLightingEnabled && lightType !== LIGHTTYPE_DIRECTIONAL) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tusesCookieNow = false;\n\t\t\t\tconst lightShape = hasAreaLights && light._shape ? light.shape : LIGHTSHAPE_PUNCTUAL;\n\t\t\t\tconst shapeString = hasAreaLights && light._shape ? this._getLightSourceShapeString(lightShape) : '';\n\t\t\t\tif (lightShape !== LIGHTSHAPE_PUNCTUAL) {\n\t\t\t\t\tbackend.append(\" calc\" + shapeString + \"LightValues(light\" + i + \"_position, light\" + i + \"_halfWidth, light\" + i + \"_halfHeight);\");\n\t\t\t\t}\n\t\t\t\tif (lightType === LIGHTTYPE_DIRECTIONAL) {\n\t\t\t\t\tbackend.append(\" dLightDirNormW = light\" + i + \"_direction;\");\n\t\t\t\t\tbackend.append(\" dAtten = 1.0;\");\n\t\t\t\t} else {\n\t\t\t\t\tif (light._cookie) {\n\t\t\t\t\t\tif (lightType === LIGHTTYPE_SPOT && !light._cookie._cubemap) {\n\t\t\t\t\t\t\tusesCookie = true;\n\t\t\t\t\t\t\tusesCookieNow = true;\n\t\t\t\t\t\t} else if (lightType === LIGHTTYPE_OMNI && light._cookie._cubemap) {\n\t\t\t\t\t\t\tusesCookie = true;\n\t\t\t\t\t\t\tusesCookieNow = true;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tbackend.append(\" getLightDirPoint(light\" + i + \"_position);\");\n\t\t\t\t\thasPointLights = true;\n\t\t\t\t\tif (usesCookieNow) {\n\t\t\t\t\t\tif (lightType === LIGHTTYPE_SPOT) {\n\t\t\t\t\t\t\tbackend.append(\" dAtten3 = getCookie2D\" + (light._cookieFalloff ? \"\" : \"Clip\") + (light._cookieTransform ? \"Xform\" : \"\") + \"(light\" + i + \"_cookie, light\" + i + \"_shadowMatrix, light\" + i + \"_cookieIntensity\" + (light._cookieTransform ? \", light\" + i + \"_cookieMatrix, light\" + i + \"_cookieOffset\" : \"\") + \").\" + light._cookieChannel + \";\");\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tbackend.append(\" dAtten3 = getCookieCube(light\" + i + \"_cookie, light\" + i + \"_shadowMatrix, light\" + i + \"_cookieIntensity).\" + light._cookieChannel + \";\");\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif (lightShape === LIGHTSHAPE_PUNCTUAL) {\n\t\t\t\t\t\tif (light._falloffMode === LIGHTFALLOFF_LINEAR) {\n\t\t\t\t\t\t\tbackend.append(\" dAtten = getFalloffLinear(light\" + i + \"_radius, dLightDirW);\");\n\t\t\t\t\t\t\tusesLinearFalloff = true;\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tbackend.append(\" dAtten = getFalloffInvSquared(light\" + i + \"_radius, dLightDirW);\");\n\t\t\t\t\t\t\tusesInvSquaredFalloff = true;\n\t\t\t\t\t\t}\n\t\t\t\t\t} else {\n\t\t\t\t\t\tbackend.append(\" dAtten = getFalloffWindow(light\" + i + \"_radius, dLightDirW);\");\n\t\t\t\t\t\tusesInvSquaredFalloff = true;\n\t\t\t\t\t}\n\t\t\t\t\tbackend.append(\" if (dAtten > 0.00001) {\");\n\t\t\t\t\tif (lightType === LIGHTTYPE_SPOT) {\n\t\t\t\t\t\tif (!(usesCookieNow && !light._cookieFalloff)) {\n\t\t\t\t\t\t\tbackend.append(\" dAtten *= getSpotEffect(light\" + i + \"_direction, light\" + i + \"_innerConeAngle, light\" + i + \"_outerConeAngle, dLightDirNormW);\");\n\t\t\t\t\t\t\tusesSpot = true;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tif (lightShape !== LIGHTSHAPE_PUNCTUAL) {\n\t\t\t\t\tif (lightType === LIGHTTYPE_DIRECTIONAL) {\n\t\t\t\t\t\tbackend.append(\" dAttenD = getLightDiffuse(litArgs_worldNormal, dViewDirW, dLightDirW, dLightDirNormW);\");\n\t\t\t\t\t} else {\n\t\t\t\t\t\tbackend.append(\" dAttenD = get\" + shapeString + \"LightDiffuse(litArgs_worldNormal, dViewDirW, dLightDirW, dLightDirNormW) * 16.0;\");\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tbackend.append(\" dAtten *= getLightDiffuse(litArgs_worldNormal, dViewDirW, dLightDirW, dLightDirNormW);\");\n\t\t\t\t}\n\t\t\t\tif (light.castShadows && !options.noShadow) {\n\t\t\t\t\tconst pcssShadows = light._shadowType === SHADOW_PCSS;\n\t\t\t\t\tconst vsmShadows = light._shadowType === SHADOW_VSM8 || light._shadowType === SHADOW_VSM16 || light._shadowType === SHADOW_VSM32;\n\t\t\t\t\tconst pcfShadows = light._shadowType === SHADOW_PCF1 || light._shadowType === SHADOW_PCF3 || light._shadowType === SHADOW_PCF5;\n\t\t\t\t\tlet shadowReadMode = null;\n\t\t\t\t\tlet evsmExp;\n\t\t\t\t\tswitch (light._shadowType) {\n\t\t\t\t\t\tcase SHADOW_VSM8:\n\t\t\t\t\t\t\tshadowReadMode = \"VSM8\";\n\t\t\t\t\t\t\tevsmExp = \"0.0\";\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\tcase SHADOW_VSM16:\n\t\t\t\t\t\t\tshadowReadMode = \"VSM16\";\n\t\t\t\t\t\t\tevsmExp = \"5.54\";\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\tcase SHADOW_VSM32:\n\t\t\t\t\t\t\tshadowReadMode = \"VSM32\";\n\t\t\t\t\t\t\tif (device.textureFloatHighPrecision) {\n\t\t\t\t\t\t\t\tevsmExp = \"15.0\";\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tevsmExp = \"5.54\";\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\tcase SHADOW_PCF1:\n\t\t\t\t\t\t\tshadowReadMode = \"PCF1x1\";\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\tcase SHADOW_PCF5:\n\t\t\t\t\t\t\tshadowReadMode = \"PCF5x5\";\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\tcase SHADOW_PCSS:\n\t\t\t\t\t\t\tshadowReadMode = \"PCSS\";\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\tcase SHADOW_PCF3:\n\t\t\t\t\t\tdefault:\n\t\t\t\t\t\t\tshadowReadMode = \"PCF3x3\";\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t\tif (shadowReadMode !== null) {\n\t\t\t\t\t\tif (light._normalOffsetBias && !light._isVsm) {\n\t\t\t\t\t\t\tfunc.append(\"#define SHADOW_SAMPLE_NORMAL_OFFSET\");\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (lightType === LIGHTTYPE_DIRECTIONAL) {\n\t\t\t\t\t\t\tfunc.append(\"#define SHADOW_SAMPLE_ORTHO\");\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif ((pcfShadows || pcssShadows) && device.isWebGL2 || device.isWebGPU || device.extStandardDerivatives) {\n\t\t\t\t\t\t\tfunc.append(\"#define SHADOW_SAMPLE_SOURCE_ZBUFFER\");\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (lightType === LIGHTTYPE_OMNI) {\n\t\t\t\t\t\t\tfunc.append(\"#define SHADOW_SAMPLE_POINT\");\n\t\t\t\t\t\t}\n\t\t\t\t\t\tconst coordCode = chunks.shadowSampleCoordPS;\n\t\t\t\t\t\tfunc.append(coordCode.replace(\"$LIGHT\", i));\n\t\t\t\t\t\tfunc.append(\"#undef SHADOW_SAMPLE_NORMAL_OFFSET\");\n\t\t\t\t\t\tfunc.append(\"#undef SHADOW_SAMPLE_ORTHO\");\n\t\t\t\t\t\tfunc.append(\"#undef SHADOW_SAMPLE_SOURCE_ZBUFFER\");\n\t\t\t\t\t\tfunc.append(\"#undef SHADOW_SAMPLE_POINT\");\n\t\t\t\t\t\tlet shadowMatrix = `light${i}_shadowMatrix`;\n\t\t\t\t\t\tif (lightType === LIGHTTYPE_DIRECTIONAL && light.numCascades > 1) {\n\t\t\t\t\t\t\tbackend.append(` getShadowCascadeMatrix(light${i}_shadowMatrixPalette, light${i}_shadowCascadeDistances, light${i}_shadowCascadeCount);`);\n\t\t\t\t\t\t\tshadowMatrix = `cascadeShadowMat`;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tbackend.append(` dShadowCoord = getShadowSampleCoord${i}(${shadowMatrix}, light${i}_shadowParams, vPositionW, dLightPosW, dLightDirW, dLightDirNormW, dVertexNormalW);`);\n\t\t\t\t\t\tif (lightType === LIGHTTYPE_DIRECTIONAL) {\n\t\t\t\t\t\t\tbackend.append(` fadeShadow(light${i}_shadowCascadeDistances);`);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tvar shadowCoordArgs = `SHADOWMAP_PASS(light${i}_shadowMap), dShadowCoord, light${i}_shadowParams`;\n\t\t\t\t\t\tif (vsmShadows) {\n\t\t\t\t\t\t\tshadowCoordArgs = `${shadowCoordArgs}, ${evsmExp}, dLightDirW`;\n\t\t\t\t\t\t} else if (pcssShadows) {\n\t\t\t\t\t\t\tlet penumbraSizeArg = `vec2(light${i}_shadowSearchArea)`;\n\t\t\t\t\t\t\tif (lightShape !== LIGHTSHAPE_PUNCTUAL) {\n\t\t\t\t\t\t\t\tpenumbraSizeArg = `vec2(length(light${i}_halfWidth), length(light${i}_halfHeight)) * light${i}_shadowSearchArea`;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tshadowCoordArgs = `${shadowCoordArgs}, light${i}_cameraParams, ${penumbraSizeArg}, dLightDirW`;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (lightType === LIGHTTYPE_OMNI) {\n\t\t\t\t\t\t\tshadowReadMode = `Point${shadowReadMode}`;\n\t\t\t\t\t\t\tif (!pcssShadows) {\n\t\t\t\t\t\t\t\tshadowCoordArgs = `${shadowCoordArgs}, dLightDirW`;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else if (lightType === LIGHTTYPE_SPOT) {\n\t\t\t\t\t\t\tshadowReadMode = `Spot${shadowReadMode}`;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tbackend.append(` float shadow${i} = getShadow${shadowReadMode}(${shadowCoordArgs});`);\n\t\t\t\t\t\tbackend.append(` dAtten *= mix(1.0, shadow${i}, light${i}_shadowIntensity);`);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tif (lightShape !== LIGHTSHAPE_PUNCTUAL) {\n\t\t\t\t\tif (options.conserveEnergy && options.useSpecular) {\n\t\t\t\t\t\tbackend.append(\" dDiffuseLight += ((dAttenD * dAtten) * light\" + i + \"_color\" + (usesCookieNow ? \" * dAtten3\" : \"\") + \") * (1.0 - dLTCSpecFres);\");\n\t\t\t\t\t} else {\n\t\t\t\t\t\tbackend.append(\" dDiffuseLight += (dAttenD * dAtten) * light\" + i + \"_color\" + (usesCookieNow ? \" * dAtten3\" : \"\") + \";\");\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tif (hasAreaLights && options.conserveEnergy && options.useSpecular) {\n\t\t\t\t\t\tbackend.append(\" dDiffuseLight += (dAtten * light\" + i + \"_color\" + (usesCookieNow ? \" * dAtten3\" : \"\") + \") * (1.0 - litArgs_specularity);\");\n\t\t\t\t\t} else {\n\t\t\t\t\t\tbackend.append(\" dDiffuseLight += dAtten * light\" + i + \"_color\" + (usesCookieNow ? \" * dAtten3\" : \"\") + \";\");\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tif (options.useSpecular) {\n\t\t\t\t\tbackend.append(\" dHalfDirW = normalize(-dLightDirNormW + dViewDirW);\");\n\t\t\t\t}\n\t\t\t\tif (light.affectSpecularity) {\n\t\t\t\t\tif (lightShape !== LIGHTSHAPE_PUNCTUAL) {\n\t\t\t\t\t\tif (options.useClearCoat) {\n\t\t\t\t\t\t\tbackend.append(` ccSpecularLight += ccLTCSpecFres * get${shapeString}LightSpecular(litArgs_clearcoat_worldNormal, dViewDirW) * dAtten * light${i}_color` + (usesCookieNow ? \" * dAtten3\" : \"\") + \";\");\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (options.useSpecular) {\n\t\t\t\t\t\t\tbackend.append(` dSpecularLight += dLTCSpecFres * get${shapeString}LightSpecular(litArgs_worldNormal, dViewDirW) * dAtten * light${i}_color` + (usesCookieNow ? \" * dAtten3\" : \"\") + \";\");\n\t\t\t\t\t\t}\n\t\t\t\t\t} else {\n\t\t\t\t\t\tvar calcFresnel = false;\n\t\t\t\t\t\tif (lightType === LIGHTTYPE_DIRECTIONAL && options.fresnelModel > 0) {\n\t\t\t\t\t\t\tcalcFresnel = true;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (options.useClearCoat) {\n\t\t\t\t\t\t\tbackend.append(` ccSpecularLight += getLightSpecular(dHalfDirW, ccReflDirW, litArgs_clearcoat_worldNormal, dViewDirW, dLightDirNormW, litArgs_clearcoat_gloss, dTBN) * dAtten * light${i}_color` + (usesCookieNow ? \" * dAtten3\" : \"\") + (calcFresnel ? \" * getFresnelCC(dot(dViewDirW, dHalfDirW));\" : \";\"));\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (options.useSheen) {\n\t\t\t\t\t\t\tbackend.append(` sSpecularLight += getLightSpecularSheen(dHalfDirW, litArgs_worldNormal, dViewDirW, dLightDirNormW, litArgs_sheen_gloss) * dAtten * light${i}_color` + (usesCookieNow ? \" * dAtten3;\" : \";\"));\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (options.useSpecular) {\n\t\t\t\t\t\t\tbackend.append(` dSpecularLight += getLightSpecular(dHalfDirW, dReflDirW, litArgs_worldNormal, dViewDirW, dLightDirNormW, litArgs_gloss, dTBN) * dAtten * light${i}_color` + (usesCookieNow ? \" * dAtten3\" : \"\") + (calcFresnel ? ` \n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t* getFresnel(\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tdot(dViewDirW, dHalfDirW), \n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tlitArgs_gloss, \n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tlitArgs_specularity\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t#if defined(LIT_IRIDESCENCE)\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t, iridescenceFresnel, \n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tlitArgs_iridescence_intensity\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t#endif\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t);` : `* litArgs_specularity;`));\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tif (lightType !== LIGHTTYPE_DIRECTIONAL) {\n\t\t\t\t\tbackend.append(\" }\");\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (options.clusteredLightingEnabled && this.lighting) {\n\t\t\t\tusesLinearFalloff = true;\n\t\t\t\tusesInvSquaredFalloff = true;\n\t\t\t\thasPointLights = true;\n\t\t\t\tbackend.append(` addClusteredLights(\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tlitArgs_worldNormal, \n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tdViewDirW, \n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tdReflDirW,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t#if defined(LIT_CLEARCOAT)\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tccReflDirW,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t#endif\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tlitArgs_gloss, \n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tlitArgs_specularity, \n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tdVertexNormalW, \n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tdTBN, \n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t#if defined(LIT_IRIDESCENCE)\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tiridescenceFresnel,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t#endif\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tlitArgs_clearcoat_worldNormal, \n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tlitArgs_clearcoat_gloss,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tlitArgs_sheen_gloss,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tlitArgs_iridescence_intensity\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t);`);\n\t\t\t}\n\t\t\tif (hasAreaLights) {\n\t\t\t\tif (options.useClearCoat) {\n\t\t\t\t\tbackend.append(\" litArgs_clearcoat_specularity = 1.0;\");\n\t\t\t\t}\n\t\t\t\tif (options.useSpecular) {\n\t\t\t\t\tbackend.append(\" litArgs_specularity = vec3(1);\");\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (options.useRefraction) {\n\t\t\t\tbackend.append(` addRefraction(\n\t\t\t\t\t\t\t\t\t\t\t\tlitArgs_worldNormal, \n\t\t\t\t\t\t\t\t\t\t\t\tdViewDirW, \n\t\t\t\t\t\t\t\t\t\t\t\tlitArgs_thickness, \n\t\t\t\t\t\t\t\t\t\t\t\tlitArgs_gloss, \n\t\t\t\t\t\t\t\t\t\t\t\tlitArgs_specularity, \n\t\t\t\t\t\t\t\t\t\t\t\tlitArgs_albedo, \n\t\t\t\t\t\t\t\t\t\t\t\tlitArgs_transmission,\n\t\t\t\t\t\t\t\t\t\t\t\tlitArgs_ior,\n\t\t\t\t\t\t\t\t\t\t\t\tlitArgs_dispersion\n\t\t\t\t\t\t\t\t\t\t#if defined(LIT_IRIDESCENCE)\n\t\t\t\t\t\t\t\t\t\t\t\t, iridescenceFresnel, \n\t\t\t\t\t\t\t\t\t\t\t\tlitArgs_iridescence_intensity\n\t\t\t\t\t\t\t\t\t\t#endif\n\t\t\t\t\t\t\t\t\t\t);`);\n\t\t\t}\n\t\t}\n\t\tif (options.useAo) {\n\t\t\tif (options.occludeDirect) {\n\t\t\t\tbackend.append(\" occludeDiffuse(litArgs_ao);\");\n\t\t\t}\n\t\t\tif (options.occludeSpecular === SPECOCC_AO || options.occludeSpecular === SPECOCC_GLOSSDEPENDENT) {\n\t\t\t\tbackend.append(\" occludeSpecular(litArgs_gloss, litArgs_ao, litArgs_worldNormal, dViewDirW);\");\n\t\t\t}\n\t\t}\n\t\tif (options.useSpecularityFactor) {\n\t\t\tbackend.append(\" dSpecularLight *= litArgs_specularityFactor;\");\n\t\t}\n\t\tif (options.opacityFadesSpecular === false) {\n\t\t\tif (options.blendType === BLEND_NORMAL || options.blendType === BLEND_PREMULTIPLIED) {\n\t\t\t\tbackend.append(\"float specLum = dot((dSpecularLight + dReflection.rgb * dReflection.a), vec3( 0.2126, 0.7152, 0.0722 ));\");\n\t\t\t\tbackend.append(\"#ifdef LIT_CLEARCOAT\\n specLum += dot(ccSpecularLight * litArgs_clearcoat_specularity + ccReflection.rgb * litArgs_clearcoat_specularity, vec3( 0.2126, 0.7152, 0.0722 ));\\n#endif\");\n\t\t\t\tbackend.append(\"litArgs_opacity = clamp(litArgs_opacity + gammaCorrectInput(specLum), 0.0, 1.0);\");\n\t\t\t}\n\t\t\tbackend.append(\"litArgs_opacity *= material_alphaFade;\");\n\t\t}\n\t\tbackend.append(chunks.endPS);\n\t\tif (options.blendType === BLEND_NORMAL || options.blendType === BLEND_ADDITIVEALPHA || options.alphaToCoverage) {\n\t\t\tbackend.append(chunks.outputAlphaPS);\n\t\t} else if (options.blendType === BLEND_PREMULTIPLIED) {\n\t\t\tbackend.append(chunks.outputAlphaPremulPS);\n\t\t} else {\n\t\t\tbackend.append(chunks.outputAlphaOpaquePS);\n\t\t}\n\t\tif (options.useMsdf) {\n\t\t\tbackend.append(\" gl_FragColor = applyMsdf(gl_FragColor);\");\n\t\t}\n\t\tbackend.append(chunks.outputPS);\n\t\tbackend.append(chunks.debugOutputPS);\n\t\tif (hasPointLights) {\n\t\t\tfunc.prepend(chunks.lightDirPointPS);\n\t\t}\n\t\tif (usesLinearFalloff) {\n\t\t\tfunc.prepend(chunks.falloffLinearPS);\n\t\t}\n\t\tif (usesInvSquaredFalloff) {\n\t\t\tfunc.prepend(chunks.falloffInvSquaredPS);\n\t\t}\n\t\tif (usesSpot) {\n\t\t\tfunc.prepend(chunks.spotPS);\n\t\t}\n\t\tif (usesCookie && !options.clusteredLightingEnabled) {\n\t\t\tfunc.prepend(chunks.cookiePS);\n\t\t}\n\t\tlet structCode = \"\";\n\t\tconst backendCode = `void evaluateBackend() {\\n${backend.code}\\n}`;\n\t\tfunc.append(backendCode);\n\t\tcode.append(chunks.debugProcessFrontendPS);\n\t\tcode.append(\" evaluateBackend();\");\n\t\tcode.append(ShaderGenerator.end());\n\t\tconst mergedCode = decl.code + func.code + code.code;\n\t\tif (mergedCode.includes(\"dTBN\")) structCode += \"mat3 dTBN;\\n\";\n\t\tif (mergedCode.includes(\"dVertexNormalW\")) structCode += \"vec3 dVertexNormalW;\\n\";\n\t\tif (mergedCode.includes(\"dTangentW\")) structCode += \"vec3 dTangentW;\\n\";\n\t\tif (mergedCode.includes(\"dBinormalW\")) structCode += \"vec3 dBinormalW;\\n\";\n\t\tif (mergedCode.includes(\"dViewDirW\")) structCode += \"vec3 dViewDirW;\\n\";\n\t\tif (mergedCode.includes(\"dReflDirW\")) structCode += \"vec3 dReflDirW;\\n\";\n\t\tif (mergedCode.includes(\"dHalfDirW\")) structCode += \"vec3 dHalfDirW;\\n\";\n\t\tif (mergedCode.includes(\"ccReflDirW\")) structCode += \"vec3 ccReflDirW;\\n\";\n\t\tif (mergedCode.includes(\"dLightDirNormW\")) structCode += \"vec3 dLightDirNormW;\\n\";\n\t\tif (mergedCode.includes(\"dLightDirW\")) structCode += \"vec3 dLightDirW;\\n\";\n\t\tif (mergedCode.includes(\"dLightPosW\")) structCode += \"vec3 dLightPosW;\\n\";\n\t\tif (mergedCode.includes(\"dShadowCoord\")) structCode += \"vec3 dShadowCoord;\\n\";\n\t\tif (mergedCode.includes(\"dReflection\")) structCode += \"vec4 dReflection;\\n\";\n\t\tif (mergedCode.includes(\"dDiffuseLight\")) structCode += \"vec3 dDiffuseLight;\\n\";\n\t\tif (mergedCode.includes(\"dSpecularLight\")) structCode += \"vec3 dSpecularLight;\\n\";\n\t\tif (mergedCode.includes(\"dAtten\")) structCode += \"float dAtten;\\n\";\n\t\tif (mergedCode.includes(\"dAttenD\")) structCode += \"float dAttenD;\\n\";\n\t\tif (mergedCode.includes(\"dAtten3\")) structCode += \"vec3 dAtten3;\\n\";\n\t\tif (mergedCode.includes(\"dMsdf\")) structCode += \"vec4 dMsdf;\\n\";\n\t\tif (mergedCode.includes(\"ccFresnel\")) structCode += \"float ccFresnel;\\n\";\n\t\tif (mergedCode.includes(\"ccReflection\")) structCode += \"vec3 ccReflection;\\n\";\n\t\tif (mergedCode.includes(\"ccSpecularLight\")) structCode += \"vec3 ccSpecularLight;\\n\";\n\t\tif (mergedCode.includes(\"ccSpecularityNoFres\")) structCode += \"float ccSpecularityNoFres;\\n\";\n\t\tif (mergedCode.includes(\"sSpecularLight\")) structCode += \"vec3 sSpecularLight;\\n\";\n\t\tif (mergedCode.includes(\"sReflection\")) structCode += \"vec3 sReflection;\\n\";\n\t\tconst result = this._fsGetBeginCode() + this.varyings + this.varyingDefines + this._fsGetBaseCode() + structCode + this.frontendDecl + mergedCode;\n\t\treturn result;\n\t}\n\tgenerateFragmentShader(frontendDecl, frontendCode, frontendFunc, lightingUv) {\n\t\tvar _this$handleCompatibi;\n\t\tconst options = this.options;\n\t\tthis.frontendDecl = frontendDecl;\n\t\tthis.frontendCode = frontendCode;\n\t\tthis.frontendFunc = frontendFunc;\n\t\tthis.lightingUv = lightingUv;\n\t\tif (options.pass === SHADER_PICK) {\n\t\t\tthis.fshader = this._fsGetPickPassCode();\n\t\t} else if (options.pass === SHADER_DEPTH) {\n\t\t\tthis.fshader = this._fsGetDepthPassCode();\n\t\t} else if (options.pass === SHADER_PREPASS_VELOCITY) {\n\t\t\tthis.fshader = this._fsGetPrePassVelocityCode();\n\t\t} else if (this.shadowPass) {\n\t\t\tthis.fshader = this._fsGetShadowPassCode();\n\t\t} else if (options.customFragmentShader) {\n\t\t\tthis.fshader = this._fsGetBeginCode() + options.customFragmentShader;\n\t\t} else {\n\t\t\tthis.fshader = this._fsGetLitPassCode();\n\t\t}\n\t\t(_this$handleCompatibi = this.handleCompatibility) == null || _this$handleCompatibi.call(this);\n\t}\n\tgetDefinition() {\n\t\tconst definition = ShaderUtils.createDefinition(this.device, {\n\t\t\tname: 'LitShader',\n\t\t\tattributes: this.attributes,\n\t\t\tvertexCode: this.vshader,\n\t\t\tfragmentCode: this.fshader\n\t\t});\n\t\tif (this.shaderPassInfo.isForward) {\n\t\t\tdefinition.tag = SHADERTAG_MATERIAL;\n\t\t}\n\t\treturn definition;\n\t}\n}\n\nexport { LitShader };\n", "import { LIGHTTYPE_DIRECTIONAL } from '../../constants.js';\n\nconst LitOptionsUtils = {\n\tgenerateKey(options) {\n\t\treturn \"lit\" + Object.keys(options).sort().map(key => {\n\t\t\tif (key === \"chunks\") {\n\t\t\t\treturn LitOptionsUtils.generateChunksKey(options);\n\t\t\t} else if (key === \"lights\") {\n\t\t\t\treturn LitOptionsUtils.generateLightsKey(options);\n\t\t\t}\n\t\t\treturn key + options[key];\n\t\t}).join(\"\\n\");\n\t},\n\tgenerateLightsKey(options) {\n\t\treturn 'lights:' + options.lights.map(light => {\n\t\t\treturn !options.clusteredLightingEnabled || light._type === LIGHTTYPE_DIRECTIONAL ? `${light.key},` : '';\n\t\t}).join(\"\");\n\t},\n\tgenerateChunksKey(options) {\n\t\tvar _options$chunks;\n\t\treturn 'chunks:\\n' + Object.keys((_options$chunks = options.chunks) != null ? _options$chunks : {}).sort().map(key => key + options.chunks[key]).join(\"\");\n\t}\n};\n\nexport { LitOptionsUtils };\n", "import { Vec3 } from '../../core/math/vec3.js';\nimport { math } from '../../core/math/math.js';\nimport { BoundingBox } from '../../core/shape/bounding-box.js';\nimport { PIXELFORMAT_L8 } from '../../platform/graphics/constants.js';\nimport { MASK_AFFECT_DYNAMIC, MASK_AFFECT_LIGHTMAPPED, LIGHTTYPE_SPOT, LIGHTTYPE_DIRECTIONAL } from '../constants.js';\nimport { LightsBuffer } from './lights-buffer.js';\n\nconst tempVec3 = new Vec3();\nconst tempMin3 = new Vec3();\nconst tempMax3 = new Vec3();\nconst tempBox = new BoundingBox();\nconst epsilon = 0.000001;\nclass ClusterLight {\n\tconstructor() {\n\t\tthis.light = null;\n\t\tthis.min = new Vec3();\n\t\tthis.max = new Vec3();\n\t}\n}\nclass WorldClusters {\n\tconstructor(device) {\n\t\tthis.clusterTexture = void 0;\n\t\tthis.device = device;\n\t\tthis.name = 'Untitled';\n\t\tthis.reportCount = 0;\n\t\tthis.boundsMin = new Vec3();\n\t\tthis.boundsMax = new Vec3();\n\t\tthis.boundsDelta = new Vec3();\n\t\tthis._cells = new Vec3(1, 1, 1);\n\t\tthis._cellsLimit = new Vec3();\n\t\tthis.cells = this._cells;\n\t\tthis.maxCellLightCount = 4;\n\t\tthis._maxAttenuation = 0;\n\t\tthis._maxColorValue = 0;\n\t\tthis._usedLights = [];\n\t\tthis._usedLights.push(new ClusterLight());\n\t\tthis.lightsBuffer = new LightsBuffer(device);\n\t\tthis.registerUniforms(device);\n\t}\n\tset maxCellLightCount(count) {\n\t\tif (count !== this._maxCellLightCount) {\n\t\t\tthis._maxCellLightCount = count;\n\t\t\tthis._cellsDirty = true;\n\t\t}\n\t}\n\tget maxCellLightCount() {\n\t\treturn this._maxCellLightCount;\n\t}\n\tset cells(value) {\n\t\ttempVec3.copy(value).floor();\n\t\tif (!this._cells.equals(tempVec3)) {\n\t\t\tthis._cells.copy(tempVec3);\n\t\t\tthis._cellsLimit.copy(tempVec3).sub(Vec3.ONE);\n\t\t\tthis._cellsDirty = true;\n\t\t}\n\t}\n\tget cells() {\n\t\treturn this._cells;\n\t}\n\tdestroy() {\n\t\tthis.lightsBuffer.destroy();\n\t\tthis.releaseClusterTexture();\n\t}\n\treleaseClusterTexture() {\n\t\tif (this.clusterTexture) {\n\t\t\tthis.clusterTexture.destroy();\n\t\t\tthis.clusterTexture = null;\n\t\t}\n\t}\n\tregisterUniforms(device) {\n\t\tthis._clusterSkipId = device.scope.resolve('clusterSkip');\n\t\tthis._clusterMaxCellsId = device.scope.resolve('clusterMaxCells');\n\t\tthis._clusterWorldTextureId = device.scope.resolve('clusterWorldTexture');\n\t\tthis._clusterTextureSizeId = device.scope.resolve('clusterTextureSize');\n\t\tthis._clusterTextureSizeData = new Float32Array(3);\n\t\tthis._clusterBoundsMinId = device.scope.resolve('clusterBoundsMin');\n\t\tthis._clusterBoundsMinData = new Float32Array(3);\n\t\tthis._clusterBoundsDeltaId = device.scope.resolve('clusterBoundsDelta');\n\t\tthis._clusterBoundsDeltaData = new Float32Array(3);\n\t\tthis._clusterCellsCountByBoundsSizeId = device.scope.resolve('clusterCellsCountByBoundsSize');\n\t\tthis._clusterCellsCountByBoundsSizeData = new Float32Array(3);\n\t\tthis._clusterCellsDotId = device.scope.resolve('clusterCellsDot');\n\t\tthis._clusterCellsDotData = new Float32Array(3);\n\t\tthis._clusterCellsMaxId = device.scope.resolve('clusterCellsMax');\n\t\tthis._clusterCellsMaxData = new Float32Array(3);\n\t\tthis._clusterCompressionLimit0Id = device.scope.resolve('clusterCompressionLimit0');\n\t\tthis._clusterCompressionLimit0Data = new Float32Array(2);\n\t}\n\tupdateParams(lightingParams) {\n\t\tif (lightingParams) {\n\t\t\tthis.cells = lightingParams.cells;\n\t\t\tthis.maxCellLightCount = lightingParams.maxLightsPerCell;\n\t\t\tthis.lightsBuffer.cookiesEnabled = lightingParams.cookiesEnabled;\n\t\t\tthis.lightsBuffer.shadowsEnabled = lightingParams.shadowsEnabled;\n\t\t\tthis.lightsBuffer.areaLightsEnabled = lightingParams.areaLightsEnabled;\n\t\t}\n\t}\n\tupdateCells() {\n\t\tif (this._cellsDirty) {\n\t\t\tthis._cellsDirty = false;\n\t\t\tconst cx = this._cells.x;\n\t\t\tconst cy = this._cells.y;\n\t\t\tconst cz = this._cells.z;\n\t\t\tconst numCells = cx * cy * cz;\n\t\t\tconst totalPixels = this.maxCellLightCount * numCells;\n\t\t\tlet width = Math.ceil(Math.sqrt(totalPixels));\n\t\t\twidth = math.roundUp(width, this.maxCellLightCount);\n\t\t\tconst height = Math.ceil(totalPixels / width);\n\t\t\tthis._clusterCellsMaxData[0] = cx;\n\t\t\tthis._clusterCellsMaxData[1] = cy;\n\t\t\tthis._clusterCellsMaxData[2] = cz;\n\t\t\tthis._clusterCellsDotData[0] = this.maxCellLightCount;\n\t\t\tthis._clusterCellsDotData[1] = cx * cz * this.maxCellLightCount;\n\t\t\tthis._clusterCellsDotData[2] = cx * this.maxCellLightCount;\n\t\t\tthis.clusters = new Uint8ClampedArray(totalPixels);\n\t\t\tthis.counts = new Int32Array(numCells);\n\t\t\tthis._clusterTextureSizeData[0] = width;\n\t\t\tthis._clusterTextureSizeData[1] = 1.0 / width;\n\t\t\tthis._clusterTextureSizeData[2] = 1.0 / height;\n\t\t\tthis.releaseClusterTexture();\n\t\t\tthis.clusterTexture = this.lightsBuffer.createTexture(this.device, width, height, PIXELFORMAT_L8, 'ClusterTexture');\n\t\t}\n\t}\n\tuploadTextures() {\n\t\tthis.clusterTexture.lock().set(this.clusters);\n\t\tthis.clusterTexture.unlock();\n\t\tthis.lightsBuffer.uploadTextures();\n\t}\n\tupdateUniforms() {\n\t\tthis._clusterSkipId.setValue(this._usedLights.length > 1 ? 0 : 1);\n\t\tthis.lightsBuffer.updateUniforms();\n\t\tthis._clusterWorldTextureId.setValue(this.clusterTexture);\n\t\tthis._clusterMaxCellsId.setValue(this.maxCellLightCount);\n\t\tconst boundsDelta = this.boundsDelta;\n\t\tthis._clusterCellsCountByBoundsSizeData[0] = this._cells.x / boundsDelta.x;\n\t\tthis._clusterCellsCountByBoundsSizeData[1] = this._cells.y / boundsDelta.y;\n\t\tthis._clusterCellsCountByBoundsSizeData[2] = this._cells.z / boundsDelta.z;\n\t\tthis._clusterCellsCountByBoundsSizeId.setValue(this._clusterCellsCountByBoundsSizeData);\n\t\tthis._clusterBoundsMinData[0] = this.boundsMin.x;\n\t\tthis._clusterBoundsMinData[1] = this.boundsMin.y;\n\t\tthis._clusterBoundsMinData[2] = this.boundsMin.z;\n\t\tthis._clusterBoundsDeltaData[0] = boundsDelta.x;\n\t\tthis._clusterBoundsDeltaData[1] = boundsDelta.y;\n\t\tthis._clusterBoundsDeltaData[2] = boundsDelta.z;\n\t\tthis._clusterCompressionLimit0Data[0] = this._maxAttenuation;\n\t\tthis._clusterCompressionLimit0Data[1] = this._maxColorValue;\n\t\tthis._clusterTextureSizeId.setValue(this._clusterTextureSizeData);\n\t\tthis._clusterBoundsMinId.setValue(this._clusterBoundsMinData);\n\t\tthis._clusterBoundsDeltaId.setValue(this._clusterBoundsDeltaData);\n\t\tthis._clusterCellsDotId.setValue(this._clusterCellsDotData);\n\t\tthis._clusterCellsMaxId.setValue(this._clusterCellsMaxData);\n\t\tthis._clusterCompressionLimit0Id.setValue(this._clusterCompressionLimit0Data);\n\t}\n\tevalLightCellMinMax(clusteredLight, min, max) {\n\t\tmin.copy(clusteredLight.min);\n\t\tmin.sub(this.boundsMin);\n\t\tmin.div(this.boundsDelta);\n\t\tmin.mul2(min, this.cells);\n\t\tmin.floor();\n\t\tmax.copy(clusteredLight.max);\n\t\tmax.sub(this.boundsMin);\n\t\tmax.div(this.boundsDelta);\n\t\tmax.mul2(max, this.cells);\n\t\tmax.ceil();\n\t\tmin.max(Vec3.ZERO);\n\t\tmax.min(this._cellsLimit);\n\t}\n\tcollectLights(lights) {\n\t\tconst maxLights = this.lightsBuffer.maxLights;\n\t\tconst usedLights = this._usedLights;\n\t\tlet lightIndex = 1;\n\t\tlights.forEach(light => {\n\t\t\tconst runtimeLight = !!(light.mask & (MASK_AFFECT_DYNAMIC | MASK_AFFECT_LIGHTMAPPED));\n\t\t\tconst zeroAngleSpotlight = light.type === LIGHTTYPE_SPOT && light._outerConeAngle === 0;\n\t\t\tif (light.enabled && light.type !== LIGHTTYPE_DIRECTIONAL && light.visibleThisFrame && light.intensity > 0 && runtimeLight && !zeroAngleSpotlight) {\n\t\t\t\tif (lightIndex < maxLights) {\n\t\t\t\t\tlet clusteredLight;\n\t\t\t\t\tif (lightIndex < usedLights.length) {\n\t\t\t\t\t\tclusteredLight = usedLights[lightIndex];\n\t\t\t\t\t} else {\n\t\t\t\t\t\tclusteredLight = new ClusterLight();\n\t\t\t\t\t\tusedLights.push(clusteredLight);\n\t\t\t\t\t}\n\t\t\t\t\tclusteredLight.light = light;\n\t\t\t\t\tlight.getBoundingBox(tempBox);\n\t\t\t\t\tclusteredLight.min.copy(tempBox.getMin());\n\t\t\t\t\tclusteredLight.max.copy(tempBox.getMax());\n\t\t\t\t\tlightIndex++;\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t\tusedLights.length = lightIndex;\n\t}\n\tevaluateBounds() {\n\t\tconst usedLights = this._usedLights;\n\t\tconst min = this.boundsMin;\n\t\tconst max = this.boundsMax;\n\t\tif (usedLights.length > 1) {\n\t\t\tmin.copy(usedLights[1].min);\n\t\t\tmax.copy(usedLights[1].max);\n\t\t\tfor (let i = 2; i < usedLights.length; i++) {\n\t\t\t\tmin.min(usedLights[i].min);\n\t\t\t\tmax.max(usedLights[i].max);\n\t\t\t}\n\t\t} else {\n\t\t\tmin.set(0, 0, 0);\n\t\t\tmax.set(1, 1, 1);\n\t\t}\n\t\tthis.boundsDelta.sub2(max, min);\n\t\tthis.lightsBuffer.setBounds(min, this.boundsDelta);\n\t}\n\tevaluateCompressionLimits(gammaCorrection) {\n\t\tlet maxAttenuation = 0;\n\t\tlet maxColorValue = 0;\n\t\tconst usedLights = this._usedLights;\n\t\tfor (let i = 1; i < usedLights.length; i++) {\n\t\t\tconst light = usedLights[i].light;\n\t\t\tmaxAttenuation = Math.max(light.attenuationEnd, maxAttenuation);\n\t\t\tconst color = gammaCorrection ? light._linearFinalColor : light._finalColor;\n\t\t\tmaxColorValue = Math.max(color[0], maxColorValue);\n\t\t\tmaxColorValue = Math.max(color[1], maxColorValue);\n\t\t\tmaxColorValue = Math.max(color[2], maxColorValue);\n\t\t}\n\t\tthis._maxAttenuation = maxAttenuation + epsilon;\n\t\tthis._maxColorValue = maxColorValue + epsilon;\n\t\tthis.lightsBuffer.setCompressionRanges(this._maxAttenuation, this._maxColorValue);\n\t}\n\tupdateClusters(gammaCorrection) {\n\t\tthis.counts.fill(0);\n\t\tthis.clusters.fill(0);\n\t\tconst divX = this._cells.x;\n\t\tconst divZ = this._cells.z;\n\t\tconst counts = this.counts;\n\t\tconst limit = this._maxCellLightCount;\n\t\tconst clusters = this.clusters;\n\t\tconst pixelsPerCellCount = this.maxCellLightCount;\n\t\tconst usedLights = this._usedLights;\n\t\tfor (let i = 1; i < usedLights.length; i++) {\n\t\t\tconst clusteredLight = usedLights[i];\n\t\t\tconst light = clusteredLight.light;\n\t\t\tthis.lightsBuffer.addLightData(light, i, gammaCorrection);\n\t\t\tthis.evalLightCellMinMax(clusteredLight, tempMin3, tempMax3);\n\t\t\tconst xStart = tempMin3.x;\n\t\t\tconst xEnd = tempMax3.x;\n\t\t\tconst yStart = tempMin3.y;\n\t\t\tconst yEnd = tempMax3.y;\n\t\t\tconst zStart = tempMin3.z;\n\t\t\tconst zEnd = tempMax3.z;\n\t\t\tfor (let x = xStart; x <= xEnd; x++) {\n\t\t\t\tfor (let z = zStart; z <= zEnd; z++) {\n\t\t\t\t\tfor (let y = yStart; y <= yEnd; y++) {\n\t\t\t\t\t\tconst clusterIndex = x + divX * (z + y * divZ);\n\t\t\t\t\t\tconst count = counts[clusterIndex];\n\t\t\t\t\t\tif (count < limit) {\n\t\t\t\t\t\t\tclusters[pixelsPerCellCount * clusterIndex + count] = i;\n\t\t\t\t\t\t\tcounts[clusterIndex] = count + 1;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\tupdate(lights, gammaCorrection, lightingParams) {\n\t\tthis.updateParams(lightingParams);\n\t\tthis.updateCells();\n\t\tthis.collectLights(lights);\n\t\tthis.evaluateBounds();\n\t\tthis.evaluateCompressionLimits(gammaCorrection);\n\t\tthis.updateClusters(gammaCorrection);\n\t\tthis.uploadTextures();\n\t}\n\tactivate() {\n\t\tthis.updateUniforms();\n\t}\n}\n\nexport { WorldClusters };\n", "import { PIXELFORMAT_RGBA32F, PIXELFORMAT_RGBA16F, PIXELFORMAT_DEPTH, PIXELFORMAT_R32F, PIXELFORMAT_RGBA8, FILTER_NEAREST, FILTER_LINEAR, ADDRESS_CLAMP_TO_EDGE, FUNC_LESS } from '../../platform/graphics/constants.js';\nimport { RenderTarget } from '../../platform/graphics/render-target.js';\nimport { Texture } from '../../platform/graphics/texture.js';\nimport { SHADOW_VSM32, SHADOW_VSM16, SHADOW_PCF5, SHADOW_PCF1, SHADOW_PCF3, SHADOW_PCSS, LIGHTTYPE_OMNI } from '../constants.js';\n\nclass ShadowMap {\n\tconstructor(texture, targets) {\n\t\tthis.texture = texture;\n\t\tthis.cached = false;\n\t\tthis.renderTargets = targets;\n\t}\n\tdestroy() {\n\t\tif (this.texture) {\n\t\t\tthis.texture.destroy();\n\t\t\tthis.texture = null;\n\t\t}\n\t\tconst targets = this.renderTargets;\n\t\tfor (let i = 0; i < targets.length; i++) {\n\t\t\ttargets[i].destroy();\n\t\t}\n\t\tthis.renderTargets.length = 0;\n\t}\n\tstatic getShadowFormat(device, shadowType) {\n\t\tif (shadowType === SHADOW_VSM32) {\n\t\t\treturn PIXELFORMAT_RGBA32F;\n\t\t} else if (shadowType === SHADOW_VSM16) {\n\t\t\treturn PIXELFORMAT_RGBA16F;\n\t\t} else if (shadowType === SHADOW_PCF5) {\n\t\t\treturn PIXELFORMAT_DEPTH;\n\t\t} else if ((shadowType === SHADOW_PCF1 || shadowType === SHADOW_PCF3) && device.supportsDepthShadow) {\n\t\t\treturn PIXELFORMAT_DEPTH;\n\t\t} else if (shadowType === SHADOW_PCSS && !device.isWebGL1) {\n\t\t\treturn PIXELFORMAT_R32F;\n\t\t}\n\t\treturn PIXELFORMAT_RGBA8;\n\t}\n\tstatic getShadowFiltering(device, shadowType) {\n\t\tif ((shadowType === SHADOW_PCF1 || shadowType === SHADOW_PCF3 || shadowType === SHADOW_PCSS) && !device.supportsDepthShadow) {\n\t\t\treturn FILTER_NEAREST;\n\t\t} else if (shadowType === SHADOW_VSM32) {\n\t\t\treturn device.extTextureFloatLinear ? FILTER_LINEAR : FILTER_NEAREST;\n\t\t} else if (shadowType === SHADOW_VSM16) {\n\t\t\treturn device.extTextureHalfFloatLinear ? FILTER_LINEAR : FILTER_NEAREST;\n\t\t}\n\t\treturn FILTER_LINEAR;\n\t}\n\tstatic create(device, light) {\n\t\tlet shadowMap = null;\n\t\tif (light._type === LIGHTTYPE_OMNI) {\n\t\t\tshadowMap = this.createCubemap(device, light._shadowResolution, light._shadowType);\n\t\t} else {\n\t\t\tshadowMap = this.create2dMap(device, light._shadowResolution, light._shadowType);\n\t\t}\n\t\treturn shadowMap;\n\t}\n\tstatic createAtlas(device, resolution, shadowType) {\n\t\tconst shadowMap = this.create2dMap(device, resolution, shadowType);\n\t\tconst targets = shadowMap.renderTargets;\n\t\tconst rt = targets[0];\n\t\tfor (let i = 0; i < 5; i++) {\n\t\t\ttargets.push(rt);\n\t\t}\n\t\treturn shadowMap;\n\t}\n\tstatic create2dMap(device, size, shadowType) {\n\t\tconst format = this.getShadowFormat(device, shadowType);\n\t\tconst filter = this.getShadowFiltering(device, shadowType);\n\t\tconst texture = new Texture(device, {\n\t\t\tformat: format,\n\t\t\twidth: size,\n\t\t\theight: size,\n\t\t\tmipmaps: false,\n\t\t\tminFilter: filter,\n\t\t\tmagFilter: filter,\n\t\t\taddressU: ADDRESS_CLAMP_TO_EDGE,\n\t\t\taddressV: ADDRESS_CLAMP_TO_EDGE,\n\t\t\tname: 'ShadowMap2D'\n\t\t});\n\t\tlet target = null;\n\t\tif (shadowType === SHADOW_PCF5 || (shadowType === SHADOW_PCF1 || shadowType === SHADOW_PCF3) && device.supportsDepthShadow) {\n\t\t\ttexture.compareOnRead = true;\n\t\t\ttexture.compareFunc = FUNC_LESS;\n\t\t\ttarget = new RenderTarget({\n\t\t\t\tdepthBuffer: texture\n\t\t\t});\n\t\t} else {\n\t\t\ttarget = new RenderTarget({\n\t\t\t\tcolorBuffer: texture,\n\t\t\t\tdepth: true\n\t\t\t});\n\t\t}\n\t\tif (device.isWebGPU) {\n\t\t\ttarget.flipY = true;\n\t\t}\n\t\treturn new ShadowMap(texture, [target]);\n\t}\n\tstatic createCubemap(device, size, shadowType) {\n\t\tconst format = shadowType === SHADOW_PCSS && !device.isWebGL1 ? PIXELFORMAT_R32F : PIXELFORMAT_RGBA8;\n\t\tconst cubemap = new Texture(device, {\n\t\t\tformat: format,\n\t\t\twidth: size,\n\t\t\theight: size,\n\t\t\tcubemap: true,\n\t\t\tmipmaps: false,\n\t\t\tminFilter: FILTER_NEAREST,\n\t\t\tmagFilter: FILTER_NEAREST,\n\t\t\taddressU: ADDRESS_CLAMP_TO_EDGE,\n\t\t\taddressV: ADDRESS_CLAMP_TO_EDGE,\n\t\t\tname: 'ShadowMapCube'\n\t\t});\n\t\tconst targets = [];\n\t\tfor (let i = 0; i < 6; i++) {\n\t\t\tconst target = new RenderTarget({\n\t\t\t\tcolorBuffer: cubemap,\n\t\t\t\tface: i,\n\t\t\t\tdepth: true\n\t\t\t});\n\t\t\ttargets.push(target);\n\t\t}\n\t\treturn new ShadowMap(cubemap, targets);\n\t}\n}\n\nexport { ShadowMap };\n", "import { Vec2 } from '../../core/math/vec2.js';\nimport { Vec4 } from '../../core/math/vec4.js';\nimport { PIXELFORMAT_RGBA8, FILTER_NEAREST, ADDRESS_CLAMP_TO_EDGE } from '../../platform/graphics/constants.js';\nimport { RenderTarget } from '../../platform/graphics/render-target.js';\nimport { Texture } from '../../platform/graphics/texture.js';\nimport { SHADOW_PCF3, LIGHTTYPE_SPOT, LIGHTTYPE_OMNI } from '../constants.js';\nimport { ShadowMap } from '../renderer/shadow-map.js';\n\nconst _tempArray = [];\nconst _tempArray2 = [];\nconst _viewport = new Vec4();\nconst _scissor = new Vec4();\nclass Slot {\n\tconstructor(rect) {\n\t\tthis.size = Math.floor(rect.w * 1024);\n\t\tthis.used = false;\n\t\tthis.lightId = -1;\n\t\tthis.rect = rect;\n\t}\n}\nclass LightTextureAtlas {\n\tconstructor(device) {\n\t\tthis.device = device;\n\t\tthis.version = 1;\n\t\tthis.shadowAtlasResolution = 2048;\n\t\tthis.shadowAtlas = null;\n\t\tthis.shadowEdgePixels = 3;\n\t\tthis.cookieAtlasResolution = 4;\n\t\tthis.cookieAtlas = new Texture(this.device, {\n\t\t\tname: 'CookieAtlas',\n\t\t\twidth: this.cookieAtlasResolution,\n\t\t\theight: this.cookieAtlasResolution,\n\t\t\tformat: PIXELFORMAT_RGBA8,\n\t\t\tcubemap: false,\n\t\t\tmipmaps: false,\n\t\t\tminFilter: FILTER_NEAREST,\n\t\t\tmagFilter: FILTER_NEAREST,\n\t\t\taddressU: ADDRESS_CLAMP_TO_EDGE,\n\t\t\taddressV: ADDRESS_CLAMP_TO_EDGE\n\t\t});\n\t\tthis.cookieRenderTarget = new RenderTarget({\n\t\t\tcolorBuffer: this.cookieAtlas,\n\t\t\tdepth: false,\n\t\t\tflipY: true\n\t\t});\n\t\tthis.slots = [];\n\t\tthis.atlasSplit = [];\n\t\tthis.cubeSlotsOffsets = [new Vec2(0, 0), new Vec2(0, 1), new Vec2(1, 0), new Vec2(1, 1), new Vec2(2, 0), new Vec2(2, 1)];\n\t\tthis.scissorVec = new Vec4();\n\t\tthis.allocateShadowAtlas(1);\n\t\tthis.allocateCookieAtlas(1);\n\t\tthis.allocateUniforms();\n\t}\n\tdestroy() {\n\t\tthis.destroyShadowAtlas();\n\t\tthis.destroyCookieAtlas();\n\t}\n\tdestroyShadowAtlas() {\n\t\tvar _this$shadowAtlas;\n\t\t(_this$shadowAtlas = this.shadowAtlas) == null || _this$shadowAtlas.destroy();\n\t\tthis.shadowAtlas = null;\n\t}\n\tdestroyCookieAtlas() {\n\t\tvar _this$cookieAtlas, _this$cookieRenderTar;\n\t\t(_this$cookieAtlas = this.cookieAtlas) == null || _this$cookieAtlas.destroy();\n\t\tthis.cookieAtlas = null;\n\t\t(_this$cookieRenderTar = this.cookieRenderTarget) == null || _this$cookieRenderTar.destroy();\n\t\tthis.cookieRenderTarget = null;\n\t}\n\tallocateShadowAtlas(resolution) {\n\t\tif (!this.shadowAtlas || this.shadowAtlas.texture.width !== resolution) {\n\t\t\tthis.version++;\n\t\t\tthis.destroyShadowAtlas();\n\t\t\tthis.shadowAtlas = ShadowMap.createAtlas(this.device, resolution, SHADOW_PCF3);\n\t\t\tthis.shadowAtlas.cached = true;\n\t\t\tconst scissorOffset = 4 / this.shadowAtlasResolution;\n\t\t\tthis.scissorVec.set(scissorOffset, scissorOffset, -2 * scissorOffset, -2 * scissorOffset);\n\t\t}\n\t}\n\tallocateCookieAtlas(resolution) {\n\t\tif (this.cookieAtlas.width !== resolution) {\n\t\t\tthis.cookieRenderTarget.resize(resolution, resolution);\n\t\t\tthis.version++;\n\t\t}\n\t}\n\tallocateUniforms() {\n\t\tthis._shadowAtlasTextureId = this.device.scope.resolve('shadowAtlasTexture');\n\t\tthis._shadowAtlasParamsId = this.device.scope.resolve('shadowAtlasParams');\n\t\tthis._shadowAtlasParams = new Float32Array(2);\n\t\tthis._cookieAtlasTextureId = this.device.scope.resolve('cookieAtlasTexture');\n\t}\n\tupdateUniforms() {\n\t\tconst isShadowFilterPcf = true;\n\t\tconst rt = this.shadowAtlas.renderTargets[0];\n\t\tconst isDepthShadow = !this.device.isWebGL1 && isShadowFilterPcf;\n\t\tconst shadowBuffer = isDepthShadow ? rt.depthBuffer : rt.colorBuffer;\n\t\tthis._shadowAtlasTextureId.setValue(shadowBuffer);\n\t\tthis._shadowAtlasParams[0] = this.shadowAtlasResolution;\n\t\tthis._shadowAtlasParams[1] = this.shadowEdgePixels;\n\t\tthis._shadowAtlasParamsId.setValue(this._shadowAtlasParams);\n\t\tthis._cookieAtlasTextureId.setValue(this.cookieAtlas);\n\t}\n\tsubdivide(numLights, lightingParams) {\n\t\tlet atlasSplit = lightingParams.atlasSplit;\n\t\tif (!atlasSplit) {\n\t\t\tconst gridSize = Math.ceil(Math.sqrt(numLights));\n\t\t\tatlasSplit = _tempArray2;\n\t\t\tatlasSplit[0] = gridSize;\n\t\t\tatlasSplit.length = 1;\n\t\t}\n\t\tconst arraysEqual = (a, b) => a.length === b.length && a.every((v, i) => v === b[i]);\n\t\tif (!arraysEqual(atlasSplit, this.atlasSplit)) {\n\t\t\tthis.version++;\n\t\t\tthis.slots.length = 0;\n\t\t\tthis.atlasSplit.length = 0;\n\t\t\tthis.atlasSplit.push(...atlasSplit);\n\t\t\tconst splitCount = this.atlasSplit[0];\n\t\t\tif (splitCount > 1) {\n\t\t\t\tconst invSize = 1 / splitCount;\n\t\t\t\tfor (let i = 0; i < splitCount; i++) {\n\t\t\t\t\tfor (let j = 0; j < splitCount; j++) {\n\t\t\t\t\t\tconst rect = new Vec4(i * invSize, j * invSize, invSize, invSize);\n\t\t\t\t\t\tconst nextLevelSplit = this.atlasSplit[1 + i * splitCount + j];\n\t\t\t\t\t\tif (nextLevelSplit > 1) {\n\t\t\t\t\t\t\tfor (let x = 0; x < nextLevelSplit; x++) {\n\t\t\t\t\t\t\t\tfor (let y = 0; y < nextLevelSplit; y++) {\n\t\t\t\t\t\t\t\t\tconst invSizeNext = invSize / nextLevelSplit;\n\t\t\t\t\t\t\t\t\tconst rectNext = new Vec4(rect.x + x * invSizeNext, rect.y + y * invSizeNext, invSizeNext, invSizeNext);\n\t\t\t\t\t\t\t\t\tthis.slots.push(new Slot(rectNext));\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tthis.slots.push(new Slot(rect));\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tthis.slots.push(new Slot(new Vec4(0, 0, 1, 1)));\n\t\t\t}\n\t\t\tthis.slots.sort((a, b) => {\n\t\t\t\treturn b.size - a.size;\n\t\t\t});\n\t\t}\n\t}\n\tcollectLights(localLights, lightingParams) {\n\t\tconst cookiesEnabled = lightingParams.cookiesEnabled;\n\t\tconst shadowsEnabled = lightingParams.shadowsEnabled;\n\t\tlet needsShadowAtlas = false;\n\t\tlet needsCookieAtlas = false;\n\t\tconst lights = _tempArray;\n\t\tlights.length = 0;\n\t\tconst processLights = list => {\n\t\t\tfor (let i = 0; i < list.length; i++) {\n\t\t\t\tconst light = list[i];\n\t\t\t\tif (light.visibleThisFrame) {\n\t\t\t\t\tconst lightShadow = shadowsEnabled && light.castShadows;\n\t\t\t\t\tconst lightCookie = cookiesEnabled && !!light.cookie;\n\t\t\t\t\tneedsShadowAtlas || (needsShadowAtlas = lightShadow);\n\t\t\t\t\tneedsCookieAtlas || (needsCookieAtlas = lightCookie);\n\t\t\t\t\tif (lightShadow || lightCookie) {\n\t\t\t\t\t\tlights.push(light);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t\tif (cookiesEnabled || shadowsEnabled) {\n\t\t\tprocessLights(localLights);\n\t\t}\n\t\tlights.sort((a, b) => {\n\t\t\treturn b.maxScreenSize - a.maxScreenSize;\n\t\t});\n\t\tif (needsShadowAtlas) {\n\t\t\tthis.allocateShadowAtlas(this.shadowAtlasResolution);\n\t\t}\n\t\tif (needsCookieAtlas) {\n\t\t\tthis.allocateCookieAtlas(this.cookieAtlasResolution);\n\t\t}\n\t\tif (needsShadowAtlas || needsCookieAtlas) {\n\t\t\tthis.subdivide(lights.length, lightingParams);\n\t\t}\n\t\treturn lights;\n\t}\n\tsetupSlot(light, rect) {\n\t\tlight.atlasViewport.copy(rect);\n\t\tconst faceCount = light.numShadowFaces;\n\t\tfor (let face = 0; face < faceCount; face++) {\n\t\t\tif (light.castShadows || light._cookie) {\n\t\t\t\t_viewport.copy(rect);\n\t\t\t\t_scissor.copy(rect);\n\t\t\t\tif (light._type === LIGHTTYPE_SPOT) {\n\t\t\t\t\t_viewport.add(this.scissorVec);\n\t\t\t\t}\n\t\t\t\tif (light._type === LIGHTTYPE_OMNI) {\n\t\t\t\t\tconst smallSize = _viewport.z / 3;\n\t\t\t\t\tconst offset = this.cubeSlotsOffsets[face];\n\t\t\t\t\t_viewport.x += smallSize * offset.x;\n\t\t\t\t\t_viewport.y += smallSize * offset.y;\n\t\t\t\t\t_viewport.z = smallSize;\n\t\t\t\t\t_viewport.w = smallSize;\n\t\t\t\t\t_scissor.copy(_viewport);\n\t\t\t\t}\n\t\t\t\tif (light.castShadows) {\n\t\t\t\t\tconst lightRenderData = light.getRenderData(null, face);\n\t\t\t\t\tlightRenderData.shadowViewport.copy(_viewport);\n\t\t\t\t\tlightRenderData.shadowScissor.copy(_scissor);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\tassignSlot(light, slotIndex, slotReassigned) {\n\t\tlight.atlasViewportAllocated = true;\n\t\tconst slot = this.slots[slotIndex];\n\t\tslot.lightId = light.id;\n\t\tslot.used = true;\n\t\tif (slotReassigned) {\n\t\t\tlight.atlasSlotUpdated = true;\n\t\t\tlight.atlasVersion = this.version;\n\t\t\tlight.atlasSlotIndex = slotIndex;\n\t\t}\n\t}\n\tupdate(localLights, lightingParams) {\n\t\tthis.shadowAtlasResolution = lightingParams.shadowAtlasResolution;\n\t\tthis.cookieAtlasResolution = lightingParams.cookieAtlasResolution;\n\t\tconst lights = this.collectLights(localLights, lightingParams);\n\t\tif (lights.length > 0) {\n\t\t\tconst slots = this.slots;\n\t\t\tfor (let i = 0; i < slots.length; i++) {\n\t\t\t\tslots[i].used = false;\n\t\t\t}\n\t\t\tconst assignCount = Math.min(lights.length, slots.length);\n\t\t\tfor (let i = 0; i < assignCount; i++) {\n\t\t\t\tconst light = lights[i];\n\t\t\t\tif (light.castShadows) light._shadowMap = this.shadowAtlas;\n\t\t\t\tconst previousSlot = slots[light.atlasSlotIndex];\n\t\t\t\tif (light.atlasVersion === this.version && light.id === (previousSlot == null ? void 0 : previousSlot.lightId)) {\n\t\t\t\t\tconst _previousSlot = slots[light.atlasSlotIndex];\n\t\t\t\t\tif (_previousSlot.size === slots[i].size && !_previousSlot.used) {\n\t\t\t\t\t\tthis.assignSlot(light, light.atlasSlotIndex, false);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tlet usedCount = 0;\n\t\t\tfor (let i = 0; i < assignCount; i++) {\n\t\t\t\twhile (usedCount < slots.length && slots[usedCount].used) usedCount++;\n\t\t\t\tconst light = lights[i];\n\t\t\t\tif (!light.atlasViewportAllocated) {\n\t\t\t\t\tthis.assignSlot(light, usedCount, true);\n\t\t\t\t}\n\t\t\t\tconst slot = slots[light.atlasSlotIndex];\n\t\t\t\tthis.setupSlot(light, slot.rect);\n\t\t\t}\n\t\t}\n\t\tthis.updateUniforms();\n\t}\n}\n\nexport { LightTextureAtlas };\n", "import { Vec3 } from '../../core/math/vec3.js';\nimport { LIGHTTYPE_DIRECTIONAL } from '../constants.js';\n\nconst lightCubeDir = [new Vec3(-1, 0, 0), new Vec3(1, 0, 0), new Vec3(0, -1, 0), new Vec3(0, 1, 0), new Vec3(0, 0, -1), new Vec3(0, 0, 1)];\nclass LightCube {\n\tconstructor() {\n\t\tthis.colors = new Float32Array(6 * 3);\n\t}\n\tupdate(ambientLight, lights) {\n\t\tconst colors = this.colors;\n\t\tconst {\n\t\t\tr,\n\t\t\tg,\n\t\t\tb\n\t\t} = ambientLight;\n\t\tfor (let j = 0; j < 6; j++) {\n\t\t\tcolors[j * 3] = r;\n\t\t\tcolors[j * 3 + 1] = g;\n\t\t\tcolors[j * 3 + 2] = b;\n\t\t}\n\t\tfor (let j = 0; j < lights.length; j++) {\n\t\t\tconst light = lights[j];\n\t\t\tif (light._type === LIGHTTYPE_DIRECTIONAL) {\n\t\t\t\tfor (let c = 0; c < 6; c++) {\n\t\t\t\t\tconst weight = Math.max(lightCubeDir[c].dot(light._direction), 0) * light._intensity;\n\t\t\t\t\tconst lightColor = light._color;\n\t\t\t\t\tcolors[c * 3] += lightColor.r * weight;\n\t\t\t\t\tcolors[c * 3 + 1] += lightColor.g * weight;\n\t\t\t\t\tcolors[c * 3 + 2] += lightColor.b * weight;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n\nexport { LightCube };\n", "import { LIGHTTYPE_OMNI } from '../constants.js';\nimport { ShadowMap } from './shadow-map.js';\n\nclass ShadowMapCache {\n\tconstructor() {\n\t\tthis.cache = new Map();\n\t}\n\tdestroy() {\n\t\tthis.clear();\n\t\tthis.cache = null;\n\t}\n\tclear() {\n\t\tthis.cache.forEach(shadowMaps => {\n\t\t\tshadowMaps.forEach(shadowMap => {\n\t\t\t\tshadowMap.destroy();\n\t\t\t});\n\t\t});\n\t\tthis.cache.clear();\n\t}\n\tgetKey(light) {\n\t\tconst isCubeMap = light._type === LIGHTTYPE_OMNI;\n\t\tconst shadowType = light._shadowType;\n\t\tconst resolution = light._shadowResolution;\n\t\treturn `${isCubeMap}-${shadowType}-${resolution}`;\n\t}\n\tget(device, light) {\n\t\tconst key = this.getKey(light);\n\t\tconst shadowMaps = this.cache.get(key);\n\t\tif (shadowMaps && shadowMaps.length) {\n\t\t\treturn shadowMaps.pop();\n\t\t}\n\t\tconst shadowMap = ShadowMap.create(device, light);\n\t\tshadowMap.cached = true;\n\t\treturn shadowMap;\n\t}\n\tadd(light, shadowMap) {\n\t\tconst key = this.getKey(light);\n\t\tconst shadowMaps = this.cache.get(key);\n\t\tif (shadowMaps) {\n\t\t\tshadowMaps.push(shadowMap);\n\t\t} else {\n\t\t\tthis.cache.set(key, [shadowMap]);\n\t\t}\n\t}\n}\n\nexport { ShadowMapCache };\n", "import { RenderPass } from '../../platform/graphics/render-pass.js';\n\nclass RenderPassShadowLocalNonClustered extends RenderPass {\n\tconstructor(device, shadowRenderer, light, face, applyVsm) {\n\t\tsuper(device);\n\t\tthis.requiresCubemaps = false;\n\t\tthis.shadowRenderer = shadowRenderer;\n\t\tthis.light = light;\n\t\tthis.face = face;\n\t\tthis.applyVsm = applyVsm;\n\t\tthis.shadowCamera = shadowRenderer.prepareFace(light, null, face);\n\t\tshadowRenderer.setupRenderPass(this, this.shadowCamera, true);\n\t}\n\texecute() {\n\t\tthis.shadowRenderer.renderFace(this.light, null, this.face, false);\n\t}\n\tafter() {\n\t\tif (this.applyVsm) {\n\t\t\tthis.shadowRenderer.renderVsm(this.light, this.shadowCamera);\n\t\t}\n\t}\n}\n\nexport { RenderPassShadowLocalNonClustered };\n", "import { math } from '../../core/math/math.js';\nimport { ShadowMap } from './shadow-map.js';\nimport { LIGHTTYPE_SPOT, LIGHTTYPE_OMNI } from '../constants.js';\nimport { RenderPassShadowLocalNonClustered } from './render-pass-shadow-local-non-clustered.js';\n\nclass ShadowRendererLocal {\n\tconstructor(renderer, shadowRenderer) {\n\t\tthis.shadowLights = [];\n\t\tthis.renderer = void 0;\n\t\tthis.shadowRenderer = void 0;\n\t\tthis.device = void 0;\n\t\tthis.renderer = renderer;\n\t\tthis.shadowRenderer = shadowRenderer;\n\t\tthis.device = renderer.device;\n\t}\n\tcull(light, comp, casters = null) {\n\t\tconst isClustered = this.renderer.scene.clusteredLightingEnabled;\n\t\tlight.visibleThisFrame = true;\n\t\tif (!isClustered) {\n\t\t\tif (!light._shadowMap) {\n\t\t\t\tlight._shadowMap = ShadowMap.create(this.device, light);\n\t\t\t}\n\t\t}\n\t\tconst type = light._type;\n\t\tconst faceCount = type === LIGHTTYPE_SPOT ? 1 : 6;\n\t\tfor (let face = 0; face < faceCount; face++) {\n\t\t\tconst lightRenderData = light.getRenderData(null, face);\n\t\t\tconst shadowCam = lightRenderData.shadowCamera;\n\t\t\tshadowCam.nearClip = light.attenuationEnd / 1000;\n\t\t\tshadowCam.farClip = light.attenuationEnd;\n\t\t\tlightRenderData.depthRangeCompensation = shadowCam.farClip - shadowCam.nearClip;\n\t\t\tconst shadowCamNode = shadowCam._node;\n\t\t\tconst lightNode = light._node;\n\t\t\tshadowCamNode.setPosition(lightNode.getPosition());\n\t\t\tif (type === LIGHTTYPE_SPOT) {\n\t\t\t\tshadowCam.fov = light._outerConeAngle * 2;\n\t\t\t\tshadowCamNode.setRotation(lightNode.getRotation());\n\t\t\t\tshadowCamNode.rotateLocal(-90, 0, 0);\n\t\t\t} else if (type === LIGHTTYPE_OMNI) {\n\t\t\t\tif (isClustered) {\n\t\t\t\t\tconst tileSize = this.shadowRenderer.lightTextureAtlas.shadowAtlasResolution * light.atlasViewport.z / 3;\n\t\t\t\t\tconst texelSize = 2 / tileSize;\n\t\t\t\t\tconst filterSize = texelSize * this.shadowRenderer.lightTextureAtlas.shadowEdgePixels;\n\t\t\t\t\tshadowCam.fov = Math.atan(1 + filterSize) * math.RAD_TO_DEG * 2;\n\t\t\t\t} else {\n\t\t\t\t\tshadowCam.fov = 90;\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis.renderer.updateCameraFrustum(shadowCam);\n\t\t\tthis.shadowRenderer.cullShadowCasters(comp, light, lightRenderData.visibleCasters, shadowCam, casters);\n\t\t}\n\t}\n\tprepareLights(shadowLights, lights) {\n\t\tlet shadowCamera;\n\t\tfor (let i = 0; i < lights.length; i++) {\n\t\t\tconst light = lights[i];\n\t\t\tif (this.shadowRenderer.needsShadowRendering(light) && light.atlasViewportAllocated) {\n\t\t\t\tshadowLights.push(light);\n\t\t\t\tfor (let face = 0; face < light.numShadowFaces; face++) {\n\t\t\t\t\tshadowCamera = this.shadowRenderer.prepareFace(light, null, face);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn shadowCamera;\n\t}\n\tbuildNonClusteredRenderPasses(frameGraph, localLights) {\n\t\tfor (let i = 0; i < localLights.length; i++) {\n\t\t\tconst light = localLights[i];\n\t\t\tif (this.shadowRenderer.needsShadowRendering(light)) {\n\t\t\t\tconst applyVsm = light._type === LIGHTTYPE_SPOT;\n\t\t\t\tconst faceCount = light.numShadowFaces;\n\t\t\t\tfor (let face = 0; face < faceCount; face++) {\n\t\t\t\t\tconst renderPass = new RenderPassShadowLocalNonClustered(this.device, this.shadowRenderer, light, face, applyVsm);\n\t\t\t\t\tframeGraph.addRenderPass(renderPass);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n\nexport { ShadowRendererLocal };\n", "import { RenderPass } from '../../platform/graphics/render-pass.js';\nimport { SHADOWUPDATE_NONE, SHADOWUPDATE_THISFRAME } from '../constants.js';\n\nclass RenderPassShadowDirectional extends RenderPass {\n\tconstructor(device, shadowRenderer, light, camera, allCascadesRendering) {\n\t\tsuper(device);\n\t\tthis.shadowRenderer = shadowRenderer;\n\t\tthis.light = light;\n\t\tthis.camera = camera;\n\t\tthis.allCascadesRendering = allCascadesRendering;\n\t}\n\texecute() {\n\t\tconst {\n\t\t\tlight,\n\t\t\tcamera,\n\t\t\tshadowRenderer,\n\t\t\tallCascadesRendering\n\t\t} = this;\n\t\tconst faceCount = light.numShadowFaces;\n\t\tconst shadowUpdateOverrides = light.shadowUpdateOverrides;\n\t\tfor (let face = 0; face < faceCount; face++) {\n\t\t\tif ((shadowUpdateOverrides == null ? void 0 : shadowUpdateOverrides[face]) !== SHADOWUPDATE_NONE) {\n\t\t\t\tshadowRenderer.renderFace(light, camera, face, !allCascadesRendering);\n\t\t\t}\n\t\t\tif ((shadowUpdateOverrides == null ? void 0 : shadowUpdateOverrides[face]) === SHADOWUPDATE_THISFRAME) {\n\t\t\t\tshadowUpdateOverrides[face] = SHADOWUPDATE_NONE;\n\t\t\t}\n\t\t}\n\t}\n\tafter() {\n\t\tthis.shadowRenderer.renderVsm(this.light, this.camera);\n\t}\n}\n\nexport { RenderPassShadowDirectional };\n", "import { math } from '../../core/math/math.js';\nimport { Vec3 } from '../../core/math/vec3.js';\nimport { Mat4 } from '../../core/math/mat4.js';\nimport { BoundingBox } from '../../core/shape/bounding-box.js';\nimport { SHADOWUPDATE_NONE } from '../constants.js';\nimport { ShadowMap } from './shadow-map.js';\nimport { RenderPassShadowDirectional } from './render-pass-shadow-directional.js';\n\nconst visibleSceneAabb = new BoundingBox();\nconst center = new Vec3();\nconst shadowCamView = new Mat4();\nconst aabbPoints = [new Vec3(), new Vec3(), new Vec3(), new Vec3(), new Vec3(), new Vec3(), new Vec3(), new Vec3()];\nconst _depthRange = {\n\tmin: 0,\n\tmax: 0\n};\nfunction getDepthRange(cameraViewMatrix, aabbMin, aabbMax) {\n\taabbPoints[0].x = aabbPoints[1].x = aabbPoints[2].x = aabbPoints[3].x = aabbMin.x;\n\taabbPoints[1].y = aabbPoints[3].y = aabbPoints[7].y = aabbPoints[5].y = aabbMin.y;\n\taabbPoints[2].z = aabbPoints[3].z = aabbPoints[6].z = aabbPoints[7].z = aabbMin.z;\n\taabbPoints[4].x = aabbPoints[5].x = aabbPoints[6].x = aabbPoints[7].x = aabbMax.x;\n\taabbPoints[0].y = aabbPoints[2].y = aabbPoints[4].y = aabbPoints[6].y = aabbMax.y;\n\taabbPoints[0].z = aabbPoints[1].z = aabbPoints[4].z = aabbPoints[5].z = aabbMax.z;\n\tlet minz = 9999999999;\n\tlet maxz = -9999999999;\n\tfor (let i = 0; i < 8; ++i) {\n\t\tcameraViewMatrix.transformPoint(aabbPoints[i], aabbPoints[i]);\n\t\tconst z = aabbPoints[i].z;\n\t\tif (z < minz) minz = z;\n\t\tif (z > maxz) maxz = z;\n\t}\n\t_depthRange.min = minz;\n\t_depthRange.max = maxz;\n\treturn _depthRange;\n}\nclass ShadowRendererDirectional {\n\tconstructor(renderer, shadowRenderer) {\n\t\tthis.renderer = void 0;\n\t\tthis.shadowRenderer = void 0;\n\t\tthis.device = void 0;\n\t\tthis.renderer = renderer;\n\t\tthis.shadowRenderer = shadowRenderer;\n\t\tthis.device = renderer.device;\n\t}\n\tcull(light, comp, camera, casters = null) {\n\t\tlight.visibleThisFrame = true;\n\t\tif (!light._shadowMap) {\n\t\t\tlight._shadowMap = ShadowMap.create(this.device, light);\n\t\t}\n\t\tconst nearDist = camera._nearClip;\n\t\tthis.generateSplitDistances(light, nearDist, Math.min(camera._farClip, light.shadowDistance));\n\t\tconst shadowUpdateOverrides = light.shadowUpdateOverrides;\n\t\tfor (let cascade = 0; cascade < light.numCascades; cascade++) {\n\t\t\tif ((shadowUpdateOverrides == null ? void 0 : shadowUpdateOverrides[cascade]) === SHADOWUPDATE_NONE) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tconst lightRenderData = light.getRenderData(camera, cascade);\n\t\t\tconst shadowCam = lightRenderData.shadowCamera;\n\t\t\tshadowCam.renderTarget = light._shadowMap.renderTargets[0];\n\t\t\tlightRenderData.shadowViewport.copy(light.cascades[cascade]);\n\t\t\tlightRenderData.shadowScissor.copy(light.cascades[cascade]);\n\t\t\tconst shadowCamNode = shadowCam._node;\n\t\t\tconst lightNode = light._node;\n\t\t\tshadowCamNode.setPosition(lightNode.getPosition());\n\t\t\tshadowCamNode.setRotation(lightNode.getRotation());\n\t\t\tshadowCamNode.rotateLocal(-90, 0, 0);\n\t\t\tconst frustumNearDist = cascade === 0 ? nearDist : light._shadowCascadeDistances[cascade - 1];\n\t\t\tconst frustumFarDist = light._shadowCascadeDistances[cascade];\n\t\t\tconst frustumPoints = camera.getFrustumCorners(frustumNearDist, frustumFarDist);\n\t\t\tcenter.set(0, 0, 0);\n\t\t\tconst cameraWorldMat = camera.node.getWorldTransform();\n\t\t\tfor (let i = 0; i < 8; i++) {\n\t\t\t\tcameraWorldMat.transformPoint(frustumPoints[i], frustumPoints[i]);\n\t\t\t\tcenter.add(frustumPoints[i]);\n\t\t\t}\n\t\t\tcenter.mulScalar(1 / 8);\n\t\t\tlet radius = 0;\n\t\t\tfor (let i = 0; i < 8; i++) {\n\t\t\t\tconst dist = frustumPoints[i].sub(center).length();\n\t\t\t\tif (dist > radius) radius = dist;\n\t\t\t}\n\t\t\tconst right = shadowCamNode.right;\n\t\t\tconst up = shadowCamNode.up;\n\t\t\tconst lightDir = shadowCamNode.forward;\n\t\t\tconst sizeRatio = 0.25 * light._shadowResolution / radius;\n\t\t\tconst x = Math.ceil(center.dot(up) * sizeRatio) / sizeRatio;\n\t\t\tconst y = Math.ceil(center.dot(right) * sizeRatio) / sizeRatio;\n\t\t\tconst scaledUp = up.mulScalar(x);\n\t\t\tconst scaledRight = right.mulScalar(y);\n\t\t\tconst dot = center.dot(lightDir);\n\t\t\tconst scaledDir = lightDir.mulScalar(dot);\n\t\t\tcenter.add2(scaledUp, scaledRight).add(scaledDir);\n\t\t\tshadowCamNode.setPosition(center);\n\t\t\tshadowCamNode.translateLocal(0, 0, 1000000);\n\t\t\tshadowCam.nearClip = 0.01;\n\t\t\tshadowCam.farClip = 2000000;\n\t\t\tshadowCam.orthoHeight = radius;\n\t\t\tthis.renderer.updateCameraFrustum(shadowCam);\n\t\t\tthis.shadowRenderer.cullShadowCasters(comp, light, lightRenderData.visibleCasters, shadowCam, casters);\n\t\t\tlet emptyAabb = true;\n\t\t\tconst visibleCasters = lightRenderData.visibleCasters;\n\t\t\tfor (let i = 0; i < visibleCasters.length; i++) {\n\t\t\t\tconst meshInstance = visibleCasters[i];\n\t\t\t\tif (emptyAabb) {\n\t\t\t\t\temptyAabb = false;\n\t\t\t\t\tvisibleSceneAabb.copy(meshInstance.aabb);\n\t\t\t\t} else {\n\t\t\t\t\tvisibleSceneAabb.add(meshInstance.aabb);\n\t\t\t\t}\n\t\t\t}\n\t\t\tshadowCamView.copy(shadowCamNode.getWorldTransform()).invert();\n\t\t\tconst depthRange = getDepthRange(shadowCamView, visibleSceneAabb.getMin(), visibleSceneAabb.getMax());\n\t\t\tshadowCamNode.translateLocal(0, 0, depthRange.max + 0.1);\n\t\t\tshadowCam.farClip = depthRange.max - depthRange.min + 0.2;\n\t\t\tlightRenderData.depthRangeCompensation = shadowCam.farClip;\n\t\t\tlightRenderData.projectionCompensation = radius;\n\t\t}\n\t}\n\tgenerateSplitDistances(light, nearDist, farDist) {\n\t\tlight._shadowCascadeDistances.fill(farDist);\n\t\tfor (let i = 1; i < light.numCascades; i++) {\n\t\t\tconst fraction = i / light.numCascades;\n\t\t\tconst linearDist = nearDist + (farDist - nearDist) * fraction;\n\t\t\tconst logDist = nearDist * (farDist / nearDist) ** fraction;\n\t\t\tconst dist = math.lerp(linearDist, logDist, light.cascadeDistribution);\n\t\t\tlight._shadowCascadeDistances[i - 1] = dist;\n\t\t}\n\t}\n\tgetLightRenderPass(light, camera) {\n\t\tlet renderPass = null;\n\t\tif (this.shadowRenderer.needsShadowRendering(light)) {\n\t\t\tconst faceCount = light.numShadowFaces;\n\t\t\tconst shadowUpdateOverrides = light.shadowUpdateOverrides;\n\t\t\tlet allCascadesRendering = true;\n\t\t\tlet shadowCamera;\n\t\t\tfor (let face = 0; face < faceCount; face++) {\n\t\t\t\tif ((shadowUpdateOverrides == null ? void 0 : shadowUpdateOverrides[face]) === SHADOWUPDATE_NONE) allCascadesRendering = false;\n\t\t\t\tshadowCamera = this.shadowRenderer.prepareFace(light, camera, face);\n\t\t\t}\n\t\t\trenderPass = new RenderPassShadowDirectional(this.device, this.shadowRenderer, light, camera, allCascadesRendering);\n\t\t\tthis.shadowRenderer.setupRenderPass(renderPass, shadowCamera, allCascadesRendering);\n\t\t}\n\t\treturn renderPass;\n\t}\n}\n\nexport { ShadowRendererDirectional };\n", "import { Color } from '../../core/math/color.js';\nimport { Mat4 } from '../../core/math/mat4.js';\nimport { Vec3 } from '../../core/math/vec3.js';\nimport { Vec4 } from '../../core/math/vec4.js';\nimport { UNIFORMTYPE_MAT4, UNIFORM_BUFFER_DEFAULT_SLOT_NAME, SHADERSTAGE_VERTEX, SHADERSTAGE_FRAGMENT } from '../../platform/graphics/constants.js';\nimport { drawQuadWithShader } from '../graphics/quad-render-utils.js';\nimport { SHADOW_VSM8, SHADOW_VSM32, SHADOW_PCF5, SHADOW_PCF1, SHADOW_PCF3, LIGHTTYPE_OMNI, LIGHTTYPE_DIRECTIONAL, SORTKEY_DEPTH, SHADOWUPDATE_NONE, SHADOWUPDATE_THISFRAME, BLUR_GAUSSIAN, SHADER_SHADOW } from '../constants.js';\nimport { ShaderPass } from '../shader-pass.js';\nimport { shaderChunks } from '../shader-lib/chunks/chunks.js';\nimport { createShaderFromCode } from '../shader-lib/utils.js';\nimport { LightCamera } from './light-camera.js';\nimport { UniformBufferFormat, UniformFormat } from '../../platform/graphics/uniform-buffer-format.js';\nimport { BindGroupFormat, BindUniformBufferFormat } from '../../platform/graphics/bind-group-format.js';\nimport { BlendState } from '../../platform/graphics/blend-state.js';\n\nfunction gauss(x, sigma) {\n\treturn Math.exp(-(x * x) / (2.0 * sigma * sigma));\n}\nfunction gaussWeights(kernelSize) {\n\tconst sigma = (kernelSize - 1) / (2 * 3);\n\tconst halfWidth = (kernelSize - 1) * 0.5;\n\tconst values = new Array(kernelSize);\n\tlet sum = 0.0;\n\tfor (let i = 0; i < kernelSize; ++i) {\n\t\tvalues[i] = gauss(i - halfWidth, sigma);\n\t\tsum += values[i];\n\t}\n\tfor (let i = 0; i < kernelSize; ++i) {\n\t\tvalues[i] /= sum;\n\t}\n\treturn values;\n}\nconst tempSet = new Set();\nconst shadowCamView = new Mat4();\nconst shadowCamViewProj = new Mat4();\nconst pixelOffset = new Float32Array(2);\nconst blurScissorRect = new Vec4(1, 1, 0, 0);\nconst viewportMatrix = new Mat4();\nclass ShadowRenderer {\n\tconstructor(renderer, lightTextureAtlas) {\n\t\tthis.shadowPassCache = [];\n\t\tthis.device = renderer.device;\n\t\tthis.renderer = renderer;\n\t\tthis.lightTextureAtlas = lightTextureAtlas;\n\t\tconst scope = this.device.scope;\n\t\tthis.polygonOffsetId = scope.resolve('polygonOffset');\n\t\tthis.polygonOffset = new Float32Array(2);\n\t\tthis.sourceId = scope.resolve('source');\n\t\tthis.pixelOffsetId = scope.resolve('pixelOffset');\n\t\tthis.weightId = scope.resolve('weight[0]');\n\t\tthis.blurVsmShaderCode = [shaderChunks.blurVSMPS, '#define GAUSS\\n' + shaderChunks.blurVSMPS];\n\t\tconst packed = '#define PACKED\\n';\n\t\tthis.blurPackedVsmShaderCode = [packed + this.blurVsmShaderCode[0], packed + this.blurVsmShaderCode[1]];\n\t\tthis.blurVsmShader = [{}, {}];\n\t\tthis.blurPackedVsmShader = [{}, {}];\n\t\tthis.blurVsmWeights = {};\n\t\tthis.shadowMapLightRadiusId = scope.resolve('light_radius');\n\t\tthis.viewUniformFormat = null;\n\t\tthis.viewBindGroupFormat = null;\n\t\tthis.blendStateWrite = new BlendState();\n\t\tthis.blendStateNoWrite = new BlendState();\n\t\tthis.blendStateNoWrite.setColorWrite(false, false, false, false);\n\t}\n\tstatic createShadowCamera(device, shadowType, type, face) {\n\t\tconst shadowCam = LightCamera.create('ShadowCamera', type, face);\n\t\tif (shadowType >= SHADOW_VSM8 && shadowType <= SHADOW_VSM32) {\n\t\t\tshadowCam.clearColor = new Color(0, 0, 0, 0);\n\t\t} else {\n\t\t\tshadowCam.clearColor = new Color(1, 1, 1, 1);\n\t\t}\n\t\tshadowCam.clearDepthBuffer = true;\n\t\tshadowCam.clearStencilBuffer = false;\n\t\treturn shadowCam;\n\t}\n\tstatic setShadowCameraSettings(shadowCam, device, shadowType, type, isClustered) {\n\t\tlet hwPcf = shadowType === SHADOW_PCF5 || (shadowType === SHADOW_PCF1 || shadowType === SHADOW_PCF3) && device.supportsDepthShadow;\n\t\tif (type === LIGHTTYPE_OMNI && !isClustered) {\n\t\t\thwPcf = false;\n\t\t}\n\t\tshadowCam.clearColorBuffer = !hwPcf;\n\t}\n\t_cullShadowCastersInternal(meshInstances, visible, camera) {\n\t\tconst numInstances = meshInstances.length;\n\t\tfor (let i = 0; i < numInstances; i++) {\n\t\t\tconst meshInstance = meshInstances[i];\n\t\t\tif (meshInstance.castShadow) {\n\t\t\t\tif (!meshInstance.cull || meshInstance._isVisible(camera)) {\n\t\t\t\t\tmeshInstance.visibleThisFrame = true;\n\t\t\t\t\tvisible.push(meshInstance);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\tcullShadowCasters(comp, light, visible, camera, casters) {\n\t\tvisible.length = 0;\n\t\tif (casters) {\n\t\t\tthis._cullShadowCastersInternal(casters, visible, camera);\n\t\t} else {\n\t\t\tconst layers = comp.layerList;\n\t\t\tconst len = layers.length;\n\t\t\tfor (let i = 0; i < len; i++) {\n\t\t\t\tconst layer = layers[i];\n\t\t\t\tif (layer._lightsSet.has(light)) {\n\t\t\t\t\tif (!tempSet.has(layer)) {\n\t\t\t\t\t\ttempSet.add(layer);\n\t\t\t\t\t\tthis._cullShadowCastersInternal(layer.shadowCasters, visible, camera);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\ttempSet.clear();\n\t\t}\n\t\tvisible.sort(this.renderer.sortCompareDepth);\n\t}\n\tsetupRenderState(device, light) {\n\t\tif (device.isWebGL1 && device.extStandardDerivatives) {\n\t\t\tif (light._type === LIGHTTYPE_OMNI) {\n\t\t\t\tthis.polygonOffset[0] = 0;\n\t\t\t\tthis.polygonOffset[1] = 0;\n\t\t\t\tthis.polygonOffsetId.setValue(this.polygonOffset);\n\t\t\t} else {\n\t\t\t\tthis.polygonOffset[0] = light.shadowBias * -1000.0;\n\t\t\t\tthis.polygonOffset[1] = light.shadowBias * -1000.0;\n\t\t\t\tthis.polygonOffsetId.setValue(this.polygonOffset);\n\t\t\t}\n\t\t}\n\t\tconst isClustered = this.renderer.scene.clusteredLightingEnabled;\n\t\tconst gpuOrGl2 = device.isWebGL2 || device.isWebGPU;\n\t\tconst useShadowSampler = isClustered ? light._isPcf && gpuOrGl2 : light._isPcf && gpuOrGl2 && light._type !== LIGHTTYPE_OMNI;\n\t\tdevice.setBlendState(useShadowSampler ? this.blendStateNoWrite : this.blendStateWrite);\n\t\tdevice.setDepthState(light.shadowDepthState);\n\t\tdevice.setStencilState(null, null);\n\t}\n\tdispatchUniforms(light, shadowCam, lightRenderData, face) {\n\t\tconst shadowCamNode = shadowCam._node;\n\t\tif (light._type !== LIGHTTYPE_DIRECTIONAL) {\n\t\t\tthis.renderer.dispatchViewPos(shadowCamNode.getPosition());\n\t\t\tthis.shadowMapLightRadiusId.setValue(light.attenuationEnd);\n\t\t}\n\t\tshadowCamView.setTRS(shadowCamNode.getPosition(), shadowCamNode.getRotation(), Vec3.ONE).invert();\n\t\tshadowCamViewProj.mul2(shadowCam.projectionMatrix, shadowCamView);\n\t\tconst rectViewport = lightRenderData.shadowViewport;\n\t\tshadowCam.rect = rectViewport;\n\t\tshadowCam.scissorRect = lightRenderData.shadowScissor;\n\t\tviewportMatrix.setViewport(rectViewport.x, rectViewport.y, rectViewport.z, rectViewport.w);\n\t\tlightRenderData.shadowMatrix.mul2(viewportMatrix, shadowCamViewProj);\n\t\tif (light._type === LIGHTTYPE_DIRECTIONAL) {\n\t\t\tlight._shadowMatrixPalette.set(lightRenderData.shadowMatrix.data, face * 16);\n\t\t}\n\t}\n\tgetShadowPass(light) {\n\t\tvar _this$shadowPassCache;\n\t\tconst lightType = light._type;\n\t\tconst shadowType = light._shadowType;\n\t\tlet shadowPassInfo = (_this$shadowPassCache = this.shadowPassCache[lightType]) == null ? void 0 : _this$shadowPassCache[shadowType];\n\t\tif (!shadowPassInfo) {\n\t\t\tconst shadowPassName = `ShadowPass_${lightType}_${shadowType}`;\n\t\t\tshadowPassInfo = ShaderPass.get(this.device).allocate(shadowPassName, {\n\t\t\t\tisShadow: true,\n\t\t\t\tlightType: lightType,\n\t\t\t\tshadowType: shadowType\n\t\t\t});\n\t\t\tif (!this.shadowPassCache[lightType]) this.shadowPassCache[lightType] = [];\n\t\t\tthis.shadowPassCache[lightType][shadowType] = shadowPassInfo;\n\t\t}\n\t\treturn shadowPassInfo.index;\n\t}\n\tsubmitCasters(visibleCasters, light) {\n\t\tconst device = this.device;\n\t\tconst renderer = this.renderer;\n\t\tconst scene = renderer.scene;\n\t\tconst passFlags = 1 << SHADER_SHADOW;\n\t\tconst shadowPass = this.getShadowPass(light);\n\t\tconst count = visibleCasters.length;\n\t\tfor (let i = 0; i < count; i++) {\n\t\t\tconst meshInstance = visibleCasters[i];\n\t\t\tconst mesh = meshInstance.mesh;\n\t\t\tmeshInstance.ensureMaterial(device);\n\t\t\tconst material = meshInstance.material;\n\t\t\trenderer.setBaseConstants(device, material);\n\t\t\trenderer.setSkinning(device, meshInstance);\n\t\t\tif (material.dirty) {\n\t\t\t\tmaterial.updateUniforms(device, scene);\n\t\t\t\tmaterial.dirty = false;\n\t\t\t}\n\t\t\tif (material.chunks) {\n\t\t\t\trenderer.setupCullMode(true, 1, meshInstance);\n\t\t\t\tmaterial.setParameters(device);\n\t\t\t\tmeshInstance.setParameters(device, passFlags);\n\t\t\t}\n\t\t\tconst shaderInstance = meshInstance.getShaderInstance(shadowPass, 0, scene, this.viewUniformFormat, this.viewBindGroupFormat);\n\t\t\tconst shadowShader = shaderInstance.shader;\n\t\t\tmeshInstance._key[SORTKEY_DEPTH] = shadowShader.id;\n\t\t\tdevice.setShader(shadowShader);\n\t\t\trenderer.setVertexBuffers(device, mesh);\n\t\t\trenderer.setMorphing(device, meshInstance.morphInstance);\n\t\t\tthis.renderer.setupMeshUniformBuffers(shaderInstance, meshInstance);\n\t\t\tconst style = meshInstance.renderStyle;\n\t\t\tdevice.setIndexBuffer(mesh.indexBuffer[style]);\n\t\t\trenderer.drawInstance(device, meshInstance, mesh, style);\n\t\t\trenderer._shadowDrawCalls++;\n\t\t}\n\t}\n\tneedsShadowRendering(light) {\n\t\tconst needs = light.enabled && light.castShadows && light.shadowUpdateMode !== SHADOWUPDATE_NONE && light.visibleThisFrame;\n\t\tif (light.shadowUpdateMode === SHADOWUPDATE_THISFRAME) {\n\t\t\tlight.shadowUpdateMode = SHADOWUPDATE_NONE;\n\t\t}\n\t\tif (needs) {\n\t\t\tthis.renderer._shadowMapUpdates += light.numShadowFaces;\n\t\t}\n\t\treturn needs;\n\t}\n\tgetLightRenderData(light, camera, face) {\n\t\treturn light.getRenderData(light._type === LIGHTTYPE_DIRECTIONAL ? camera : null, face);\n\t}\n\tsetupRenderPass(renderPass, shadowCamera, clearRenderTarget) {\n\t\tconst rt = shadowCamera.renderTarget;\n\t\trenderPass.init(rt);\n\t\trenderPass.depthStencilOps.clearDepthValue = 1;\n\t\trenderPass.depthStencilOps.clearDepth = clearRenderTarget;\n\t\tif (rt.depthBuffer) {\n\t\t\trenderPass.depthStencilOps.storeDepth = true;\n\t\t} else {\n\t\t\trenderPass.colorOps.clearValue.copy(shadowCamera.clearColor);\n\t\t\trenderPass.colorOps.clear = clearRenderTarget;\n\t\t\trenderPass.depthStencilOps.storeDepth = false;\n\t\t}\n\t\trenderPass.requiresCubemaps = false;\n\t}\n\tprepareFace(light, camera, face) {\n\t\tconst type = light._type;\n\t\tconst shadowType = light._shadowType;\n\t\tconst isClustered = this.renderer.scene.clusteredLightingEnabled;\n\t\tconst lightRenderData = this.getLightRenderData(light, camera, face);\n\t\tconst shadowCam = lightRenderData.shadowCamera;\n\t\tShadowRenderer.setShadowCameraSettings(shadowCam, this.device, shadowType, type, isClustered);\n\t\tconst renderTargetIndex = type === LIGHTTYPE_DIRECTIONAL ? 0 : face;\n\t\tshadowCam.renderTarget = light._shadowMap.renderTargets[renderTargetIndex];\n\t\treturn shadowCam;\n\t}\n\trenderFace(light, camera, face, clear, insideRenderPass = true) {\n\t\tconst device = this.device;\n\t\tconst lightRenderData = this.getLightRenderData(light, camera, face);\n\t\tconst shadowCam = lightRenderData.shadowCamera;\n\t\tthis.dispatchUniforms(light, shadowCam, lightRenderData, face);\n\t\tconst rt = shadowCam.renderTarget;\n\t\tconst renderer = this.renderer;\n\t\trenderer.setCameraUniforms(shadowCam, rt);\n\t\tif (device.supportsUniformBuffers) {\n\t\t\trenderer.setupViewUniformBuffers(lightRenderData.viewBindGroups, this.viewUniformFormat, this.viewBindGroupFormat, 1);\n\t\t}\n\t\tif (insideRenderPass) {\n\t\t\trenderer.setupViewport(shadowCam, rt);\n\t\t\tif (clear) {\n\t\t\t\trenderer.clear(shadowCam);\n\t\t\t}\n\t\t} else {\n\t\t\trenderer.clearView(shadowCam, rt, true, false);\n\t\t}\n\t\tthis.setupRenderState(device, light);\n\t\tthis.submitCasters(lightRenderData.visibleCasters, light);\n\t}\n\trender(light, camera, insideRenderPass = true) {\n\t\tif (this.needsShadowRendering(light)) {\n\t\t\tconst faceCount = light.numShadowFaces;\n\t\t\tfor (let face = 0; face < faceCount; face++) {\n\t\t\t\tthis.prepareFace(light, camera, face);\n\t\t\t\tthis.renderFace(light, camera, face, true, insideRenderPass);\n\t\t\t}\n\t\t\tthis.renderVsm(light, camera);\n\t\t}\n\t}\n\trenderVsm(light, camera) {\n\t\tif (light._isVsm && light._vsmBlurSize > 1) {\n\t\t\tconst isClustered = this.renderer.scene.clusteredLightingEnabled;\n\t\t\tif (!isClustered || light._type === LIGHTTYPE_DIRECTIONAL) {\n\t\t\t\tthis.applyVsmBlur(light, camera);\n\t\t\t}\n\t\t}\n\t}\n\tgetVsmBlurShader(isVsm8, blurMode, filterSize) {\n\t\tlet blurShader = (isVsm8 ? this.blurPackedVsmShader : this.blurVsmShader)[blurMode][filterSize];\n\t\tif (!blurShader) {\n\t\t\tthis.blurVsmWeights[filterSize] = gaussWeights(filterSize);\n\t\t\tconst blurVS = shaderChunks.fullscreenQuadVS;\n\t\t\tlet blurFS = '#define SAMPLES ' + filterSize + '\\n';\n\t\t\tif (isVsm8) {\n\t\t\t\tblurFS += this.blurPackedVsmShaderCode[blurMode];\n\t\t\t} else {\n\t\t\t\tblurFS += this.blurVsmShaderCode[blurMode];\n\t\t\t}\n\t\t\tconst blurShaderName = 'blurVsm' + blurMode + '' + filterSize + '' + isVsm8;\n\t\t\tblurShader = createShaderFromCode(this.device, blurVS, blurFS, blurShaderName);\n\t\t\tif (isVsm8) {\n\t\t\t\tthis.blurPackedVsmShader[blurMode][filterSize] = blurShader;\n\t\t\t} else {\n\t\t\t\tthis.blurVsmShader[blurMode][filterSize] = blurShader;\n\t\t\t}\n\t\t}\n\t\treturn blurShader;\n\t}\n\tapplyVsmBlur(light, camera) {\n\t\tconst device = this.device;\n\t\tdevice.setBlendState(BlendState.NOBLEND);\n\t\tconst lightRenderData = light.getRenderData(light._type === LIGHTTYPE_DIRECTIONAL ? camera : null, 0);\n\t\tconst shadowCam = lightRenderData.shadowCamera;\n\t\tconst origShadowMap = shadowCam.renderTarget;\n\t\tconst tempShadowMap = this.renderer.shadowMapCache.get(device, light);\n\t\tconst tempRt = tempShadowMap.renderTargets[0];\n\t\tconst isVsm8 = light._shadowType === SHADOW_VSM8;\n\t\tconst blurMode = light.vsmBlurMode;\n\t\tconst filterSize = light._vsmBlurSize;\n\t\tconst blurShader = this.getVsmBlurShader(isVsm8, blurMode, filterSize);\n\t\tblurScissorRect.z = light._shadowResolution - 2;\n\t\tblurScissorRect.w = blurScissorRect.z;\n\t\tthis.sourceId.setValue(origShadowMap.colorBuffer);\n\t\tpixelOffset[0] = 1 / light._shadowResolution;\n\t\tpixelOffset[1] = 0;\n\t\tthis.pixelOffsetId.setValue(pixelOffset);\n\t\tif (blurMode === BLUR_GAUSSIAN) this.weightId.setValue(this.blurVsmWeights[filterSize]);\n\t\tdrawQuadWithShader(device, tempRt, blurShader, null, blurScissorRect);\n\t\tthis.sourceId.setValue(tempRt.colorBuffer);\n\t\tpixelOffset[1] = pixelOffset[0];\n\t\tpixelOffset[0] = 0;\n\t\tthis.pixelOffsetId.setValue(pixelOffset);\n\t\tdrawQuadWithShader(device, origShadowMap, blurShader, null, blurScissorRect);\n\t\tthis.renderer.shadowMapCache.add(light, tempShadowMap);\n\t}\n\tinitViewBindGroupFormat() {\n\t\tif (this.device.supportsUniformBuffers && !this.viewUniformFormat) {\n\t\t\tthis.viewUniformFormat = new UniformBufferFormat(this.device, [new UniformFormat(\"matrix_viewProjection\", UNIFORMTYPE_MAT4)]);\n\t\t\tthis.viewBindGroupFormat = new BindGroupFormat(this.device, [new BindUniformBufferFormat(UNIFORM_BUFFER_DEFAULT_SLOT_NAME, SHADERSTAGE_VERTEX | SHADERSTAGE_FRAGMENT)]);\n\t\t}\n\t}\n\tframeUpdate() {\n\t\tthis.initViewBindGroupFormat();\n\t}\n}\n\nexport { ShadowRenderer };\n", "import { WorldClusters } from '../lighting/world-clusters.js';\n\nconst tempClusterArray = [];\nclass WorldClustersAllocator {\n\tconstructor(graphicsDevice) {\n\t\tthis._empty = null;\n\t\tthis._allocated = [];\n\t\tthis._clusters = new Map();\n\t\tthis.device = graphicsDevice;\n\t}\n\tdestroy() {\n\t\tif (this._empty) {\n\t\t\tthis._empty.destroy();\n\t\t\tthis._empty = null;\n\t\t}\n\t\tthis._allocated.forEach(cluster => {\n\t\t\tcluster.destroy();\n\t\t});\n\t\tthis._allocated.length = 0;\n\t}\n\tget count() {\n\t\treturn this._allocated.length;\n\t}\n\tget empty() {\n\t\tif (!this._empty) {\n\t\t\tconst empty = new WorldClusters(this.device);\n\t\t\tempty.name = 'ClusterEmpty';\n\t\t\tempty.update([], false, null);\n\t\t\tthis._empty = empty;\n\t\t}\n\t\treturn this._empty;\n\t}\n\tassign(renderPasses) {\n\t\tconst empty = this.empty;\n\t\ttempClusterArray.push(...this._allocated);\n\t\tthis._allocated.length = 0;\n\t\tthis._clusters.clear();\n\t\tconst passCount = renderPasses.length;\n\t\tfor (let p = 0; p < passCount; p++) {\n\t\t\tconst renderPass = renderPasses[p];\n\t\t\tconst renderActions = renderPass.renderActions;\n\t\t\tif (renderActions) {\n\t\t\t\tconst count = renderActions.length;\n\t\t\t\tfor (let i = 0; i < count; i++) {\n\t\t\t\t\tconst ra = renderActions[i];\n\t\t\t\t\tra.lightClusters = null;\n\t\t\t\t\tconst layer = ra.layer;\n\t\t\t\t\tif (layer.hasClusteredLights && layer.meshInstances.length) {\n\t\t\t\t\t\tconst hash = layer.getLightIdHash();\n\t\t\t\t\t\tconst existingRenderAction = this._clusters.get(hash);\n\t\t\t\t\t\tlet clusters = existingRenderAction == null ? void 0 : existingRenderAction.lightClusters;\n\t\t\t\t\t\tif (!clusters) {\n\t\t\t\t\t\t\tvar _tempClusterArray$pop;\n\t\t\t\t\t\t\tclusters = (_tempClusterArray$pop = tempClusterArray.pop()) != null ? _tempClusterArray$pop : new WorldClusters(this.device);\n\t\t\t\t\t\t\tthis._allocated.push(clusters);\n\t\t\t\t\t\t\tthis._clusters.set(hash, ra);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tra.lightClusters = clusters;\n\t\t\t\t\t}\n\t\t\t\t\tif (!ra.lightClusters) {\n\t\t\t\t\t\tra.lightClusters = empty;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\ttempClusterArray.forEach(item => item.destroy());\n\t\ttempClusterArray.length = 0;\n\t}\n\tupdate(renderPasses, gammaCorrection, lighting) {\n\t\tthis.assign(renderPasses);\n\t\tthis._clusters.forEach(renderAction => {\n\t\t\tconst layer = renderAction.layer;\n\t\t\tconst cluster = renderAction.lightClusters;\n\t\t\tcluster.update(layer.clusteredLightsSet, gammaCorrection, lighting);\n\t\t});\n\t}\n}\n\nexport { WorldClustersAllocator };\n", "import { Vec4 } from '../../core/math/vec4.js';\nimport { Mat4 } from '../../core/math/mat4.js';\nimport { CULLFACE_NONE } from '../../platform/graphics/constants.js';\nimport { LIGHTTYPE_DIRECTIONAL, LIGHTTYPE_OMNI } from '../constants.js';\nimport { createShaderFromCode } from '../shader-lib/utils.js';\nimport { LightCamera } from './light-camera.js';\nimport { BlendState } from '../../platform/graphics/blend-state.js';\nimport { QuadRender } from '../graphics/quad-render.js';\nimport { DepthState } from '../../platform/graphics/depth-state.js';\nimport { RenderPass } from '../../platform/graphics/render-pass.js';\n\nconst textureBlitVertexShader = `\n\tattribute vec2 vertex_position;\n\tvarying vec2 uv0;\n\tvoid main(void) {\n\t\tgl_Position = vec4(vertex_position, 0.5, 1.0);\n\t\tuv0 = vertex_position.xy * 0.5 + 0.5;\n\t\t#ifndef WEBGPU\n\t\t\tuv0.y = 1.0 - uv0.y;\n\t\t#endif\n\t}`;\nconst textureBlitFragmentShader = `\n\tvarying vec2 uv0;\n\tuniform sampler2D blitTexture;\n\tvoid main(void) {\n\t\tgl_FragColor = texture2D(blitTexture, uv0);\n\t}`;\nconst textureCubeBlitFragmentShader = `\n\tvarying vec2 uv0;\n\tuniform samplerCube blitTexture;\n\tuniform mat4 invViewProj;\n\tvoid main(void) {\n\t\tvec4 projPos = vec4(uv0 * 2.0 - 1.0, 0.5, 1.0);\n\t\tvec4 worldPos = invViewProj * projPos;\n\t\tgl_FragColor = textureCube(blitTexture, worldPos.xyz);\n\t}`;\nconst _viewport = new Vec4();\nconst _invViewProjMatrices = [];\nclass RenderPassCookieRenderer extends RenderPass {\n\tconstructor(device, cubeSlotsOffsets) {\n\t\tsuper(device);\n\t\tthis._quadRenderer2D = null;\n\t\tthis._quadRendererCube = null;\n\t\tthis._filteredLights = [];\n\t\tthis._cubeSlotsOffsets = cubeSlotsOffsets;\n\t\tthis.requiresCubemaps = false;\n\t\tthis.blitTextureId = device.scope.resolve('blitTexture');\n\t\tthis.invViewProjId = device.scope.resolve('invViewProj');\n\t}\n\tdestroy() {\n\t\tvar _this$_quadRenderer2D, _this$_quadRendererCu;\n\t\t(_this$_quadRenderer2D = this._quadRenderer2D) == null || _this$_quadRenderer2D.destroy();\n\t\tthis._quadRenderer2D = null;\n\t\t(_this$_quadRendererCu = this._quadRendererCube) == null || _this$_quadRendererCu.destroy();\n\t\tthis._quadRendererCube = null;\n\t}\n\tstatic create(renderTarget, cubeSlotsOffsets) {\n\t\tconst renderPass = new RenderPassCookieRenderer(renderTarget.device, cubeSlotsOffsets);\n\t\trenderPass.init(renderTarget);\n\t\trenderPass.colorOps.clear = false;\n\t\trenderPass.depthStencilOps.clearDepth = false;\n\t\treturn renderPass;\n\t}\n\tupdate(lights) {\n\t\tconst filteredLights = this._filteredLights;\n\t\tthis.filter(lights, filteredLights);\n\t\tthis.executeEnabled = filteredLights.length > 0;\n\t}\n\tfilter(lights, filteredLights) {\n\t\tfor (let i = 0; i < lights.length; i++) {\n\t\t\tconst light = lights[i];\n\t\t\tif (light._type === LIGHTTYPE_DIRECTIONAL) continue;\n\t\t\tif (!light.atlasViewportAllocated) continue;\n\t\t\tif (!light.atlasSlotUpdated) continue;\n\t\t\tif (light.enabled && light.cookie && light.visibleThisFrame) {\n\t\t\t\tfilteredLights.push(light);\n\t\t\t}\n\t\t}\n\t}\n\tinitInvViewProjMatrices() {\n\t\tif (!_invViewProjMatrices.length) {\n\t\t\tfor (let face = 0; face < 6; face++) {\n\t\t\t\tconst camera = LightCamera.create(null, LIGHTTYPE_OMNI, face);\n\t\t\t\tconst projMat = camera.projectionMatrix;\n\t\t\t\tconst viewMat = camera.node.getLocalTransform().clone().invert();\n\t\t\t\t_invViewProjMatrices[face] = new Mat4().mul2(projMat, viewMat).invert();\n\t\t\t}\n\t\t}\n\t}\n\tget quadRenderer2D() {\n\t\tif (!this._quadRenderer2D) {\n\t\t\tconst shader = createShaderFromCode(this.device, textureBlitVertexShader, textureBlitFragmentShader, `cookieRenderer2d`);\n\t\t\tthis._quadRenderer2D = new QuadRender(shader);\n\t\t}\n\t\treturn this._quadRenderer2D;\n\t}\n\tget quadRendererCube() {\n\t\tif (!this._quadRendererCube) {\n\t\t\tconst shader = createShaderFromCode(this.device, textureBlitVertexShader, textureCubeBlitFragmentShader, `cookieRendererCube`);\n\t\t\tthis._quadRendererCube = new QuadRender(shader);\n\t\t}\n\t\treturn this._quadRendererCube;\n\t}\n\texecute() {\n\t\tconst device = this.device;\n\t\tdevice.setBlendState(BlendState.NOBLEND);\n\t\tdevice.setCullMode(CULLFACE_NONE);\n\t\tdevice.setDepthState(DepthState.NODEPTH);\n\t\tdevice.setStencilState();\n\t\tconst renderTargetWidth = this.renderTarget.colorBuffer.width;\n\t\tconst cubeSlotsOffsets = this._cubeSlotsOffsets;\n\t\tconst filteredLights = this._filteredLights;\n\t\tfor (let i = 0; i < filteredLights.length; i++) {\n\t\t\tconst light = filteredLights[i];\n\t\t\tconst faceCount = light.numShadowFaces;\n\t\t\tconst quad = faceCount > 1 ? this.quadRendererCube : this.quadRenderer2D;\n\t\t\tif (faceCount > 1) {\n\t\t\t\tthis.initInvViewProjMatrices();\n\t\t\t}\n\t\t\tthis.blitTextureId.setValue(light.cookie);\n\t\t\tfor (let face = 0; face < faceCount; face++) {\n\t\t\t\t_viewport.copy(light.atlasViewport);\n\t\t\t\tif (faceCount > 1) {\n\t\t\t\t\tconst smallSize = _viewport.z / 3;\n\t\t\t\t\tconst offset = cubeSlotsOffsets[face];\n\t\t\t\t\t_viewport.x += smallSize * offset.x;\n\t\t\t\t\t_viewport.y += smallSize * offset.y;\n\t\t\t\t\t_viewport.z = smallSize;\n\t\t\t\t\t_viewport.w = smallSize;\n\t\t\t\t\tthis.invViewProjId.setValue(_invViewProjMatrices[face].data);\n\t\t\t\t}\n\t\t\t\t_viewport.mulScalar(renderTargetWidth);\n\t\t\t\tquad.render(_viewport);\n\t\t\t}\n\t\t}\n\t\tfilteredLights.length = 0;\n\t}\n}\n\nexport { RenderPassCookieRenderer };\n", "import { RenderPass } from '../../platform/graphics/render-pass.js';\n\nclass RenderPassShadowLocalClustered extends RenderPass {\n\tconstructor(device, shadowRenderer, shadowRendererLocal) {\n\t\tsuper(device);\n\t\tthis.requiresCubemaps = false;\n\t\tthis.shadowRenderer = shadowRenderer;\n\t\tthis.shadowRendererLocal = shadowRendererLocal;\n\t}\n\tupdate(localLights) {\n\t\tconst shadowLights = this.shadowRendererLocal.shadowLights;\n\t\tconst shadowCamera = this.shadowRendererLocal.prepareLights(shadowLights, localLights);\n\t\tconst count = shadowLights.length;\n\t\tthis.enabled = count > 0;\n\t\tif (count) {\n\t\t\tthis.shadowRenderer.setupRenderPass(this, shadowCamera, false);\n\t\t}\n\t}\n\texecute() {\n\t\tconst shadowLights = this.shadowRendererLocal.shadowLights;\n\t\tconst count = shadowLights.length;\n\t\tfor (let i = 0; i < count; i++) {\n\t\t\tconst light = shadowLights[i];\n\t\t\tfor (let face = 0; face < light.numShadowFaces; face++) {\n\t\t\t\tthis.shadowRenderer.renderFace(light, null, face, true);\n\t\t\t}\n\t\t}\n\t\tshadowLights.length = 0;\n\t}\n}\n\nexport { RenderPassShadowLocalClustered };\n", "import { RenderPass } from '../../platform/graphics/render-pass.js';\nimport { RenderPassCookieRenderer } from './render-pass-cookie-renderer.js';\nimport { RenderPassShadowLocalClustered } from './render-pass-shadow-local-clustered.js';\n\nclass RenderPassUpdateClustered extends RenderPass {\n\tconstructor(device, renderer, shadowRenderer, shadowRendererLocal, lightTextureAtlas) {\n\t\tsuper(device);\n\t\tthis.renderer = renderer;\n\t\tthis.frameGraph = null;\n\t\tthis.cookiesRenderPass = RenderPassCookieRenderer.create(lightTextureAtlas.cookieRenderTarget, lightTextureAtlas.cubeSlotsOffsets);\n\t\tthis.beforePasses.push(this.cookiesRenderPass);\n\t\tthis.shadowRenderPass = new RenderPassShadowLocalClustered(device, shadowRenderer, shadowRendererLocal);\n\t\tthis.beforePasses.push(this.shadowRenderPass);\n\t}\n\tupdate(frameGraph, shadowsEnabled, cookiesEnabled, lights, localLights) {\n\t\tthis.frameGraph = frameGraph;\n\t\tthis.cookiesRenderPass.enabled = cookiesEnabled;\n\t\tif (cookiesEnabled) {\n\t\t\tthis.cookiesRenderPass.update(lights);\n\t\t}\n\t\tthis.shadowRenderPass.enabled = shadowsEnabled;\n\t\tif (shadowsEnabled) {\n\t\t\tthis.shadowRenderPass.update(localLights);\n\t\t}\n\t}\n\tdestroy() {\n\t\tthis.cookiesRenderPass.destroy();\n\t\tthis.cookiesRenderPass = null;\n\t}\n\texecute() {\n\t\tconst {\n\t\t\trenderer\n\t\t} = this;\n\t\tconst {\n\t\t\tscene\n\t\t} = renderer;\n\t\trenderer.worldClustersAllocator.update(this.frameGraph.renderPasses, scene.gammaCorrection, scene.lighting);\n\t}\n}\n\nexport { RenderPassUpdateClustered };\n", "import { Vec4 } from './vec4.js';\n\nconst base64String = \"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\";\nlet data = null;\nconst initData = () => {\n\tif (!data) {\n\t\tconst binaryString = atob(base64String);\n\t\tdata = Uint8Array.from(binaryString, char => char.charCodeAt(0));\n\t}\n};\nconst blueNoiseData = () => {\n\tinitData();\n\treturn data;\n};\nclass BlueNoise {\n\tconstructor(seed = 0) {\n\t\tthis.seed = 0;\n\t\tthis.seed = seed * 4;\n\t\tinitData();\n\t}\n\t_next() {\n\t\tthis.seed = (this.seed + 4) % data.length;\n\t}\n\tvalue() {\n\t\tthis._next();\n\t\treturn data[this.seed] / 255;\n\t}\n\tvec4(dest = new Vec4()) {\n\t\tthis._next();\n\t\treturn dest.set(data[this.seed], data[this.seed + 1], data[this.seed + 2], data[this.seed + 3]).mulScalar(1 / 255);\n\t}\n}\n\nexport { BlueNoise, blueNoiseData };\n", "import { blueNoiseData } from '../../core/math/blue-noise.js';\nimport { PIXELFORMAT_RGBA8, ADDRESS_REPEAT, TEXTURETYPE_DEFAULT, FILTER_NEAREST } from '../../platform/graphics/constants.js';\nimport { DeviceCache } from '../../platform/graphics/device-cache.js';\nimport { Texture } from '../../platform/graphics/texture.js';\n\nconst createTexture = (device, namePrefix, size, data) => {\n\tconst texture = new Texture(device, {\n\t\tname: `${namePrefix}${size}`,\n\t\twidth: size,\n\t\theight: size,\n\t\tformat: PIXELFORMAT_RGBA8,\n\t\taddressU: ADDRESS_REPEAT,\n\t\taddressV: ADDRESS_REPEAT,\n\t\ttype: TEXTURETYPE_DEFAULT,\n\t\tmagFilter: FILTER_NEAREST,\n\t\tminFilter: FILTER_NEAREST,\n\t\tanisotropy: 1,\n\t\tmipmaps: false\n\t});\n\ttexture.lock().set(data);\n\ttexture.unlock();\n\treturn texture;\n};\nconst deviceCacheBlueNoise = new DeviceCache();\nconst getBlueNoiseTexture = device => {\n\treturn deviceCacheBlueNoise.get(device, () => {\n\t\tconst data = blueNoiseData();\n\t\tconst size = Math.sqrt(data.length / 4);\n\t\treturn createTexture(device, \"BlueNoise\", size, data);\n\t});\n};\n\nexport { getBlueNoiseTexture };\n", "import { Vec2 } from '../../core/math/vec2.js';\nimport { Vec3 } from '../../core/math/vec3.js';\nimport { Vec4 } from '../../core/math/vec4.js';\nimport { Mat3 } from '../../core/math/mat3.js';\nimport { Mat4 } from '../../core/math/mat4.js';\nimport { BoundingSphere } from '../../core/shape/bounding-sphere.js';\nimport { SORTKEY_FORWARD, SORTKEY_DEPTH, VIEW_CENTER, PROJECTION_ORTHOGRAPHIC, LIGHTTYPE_DIRECTIONAL, SHADOWUPDATE_NONE, SHADOWUPDATE_THISFRAME } from '../constants.js';\nimport { LightTextureAtlas } from '../lighting/light-texture-atlas.js';\nimport { Material } from '../materials/material.js';\nimport { LightCube } from '../graphics/light-cube.js';\nimport { CLEARFLAG_COLOR, CLEARFLAG_DEPTH, CLEARFLAG_STENCIL, CULLFACE_FRONT, CULLFACE_BACK, CULLFACE_NONE, UNIFORMTYPE_MAT4, UNIFORMTYPE_MAT3, UNIFORMTYPE_VEC3, UNIFORMTYPE_FLOAT, UNIFORMTYPE_VEC2, UNIFORMTYPE_INT, UNIFORM_BUFFER_DEFAULT_SLOT_NAME, SHADERSTAGE_VERTEX, SHADERSTAGE_FRAGMENT, TEXTUREDIMENSION_2D, SAMPLETYPE_UNFILTERABLE_FLOAT, SAMPLETYPE_DEPTH, SAMPLETYPE_FLOAT, BINDGROUP_VIEW, BINDGROUP_MESH, SEMANTIC_ATTR } from '../../platform/graphics/constants.js';\nimport { UniformBuffer } from '../../platform/graphics/uniform-buffer.js';\nimport { BindGroup } from '../../platform/graphics/bind-group.js';\nimport { UniformFormat, UniformBufferFormat } from '../../platform/graphics/uniform-buffer-format.js';\nimport { BindUniformBufferFormat, BindTextureFormat, BindGroupFormat } from '../../platform/graphics/bind-group-format.js';\nimport { ShadowMapCache } from './shadow-map-cache.js';\nimport { ShadowRendererLocal } from './shadow-renderer-local.js';\nimport { ShadowRendererDirectional } from './shadow-renderer-directional.js';\nimport { ShadowRenderer } from './shadow-renderer.js';\nimport { WorldClustersAllocator } from './world-clusters-allocator.js';\nimport { RenderPassUpdateClustered } from './render-pass-update-clustered.js';\nimport { getBlueNoiseTexture } from '../graphics/noise-textures.js';\nimport { BlueNoise } from '../../core/math/blue-noise.js';\n\nlet _skinUpdateIndex = 0;\nconst viewProjMat = new Mat4();\nconst viewInvMat = new Mat4();\nconst viewMat = new Mat4();\nconst viewMat3 = new Mat3();\nconst tempSphere = new BoundingSphere();\nconst _flipYMat = new Mat4().setScale(1, -1, 1);\nconst _tempLightSet = new Set();\nconst _tempLayerSet = new Set();\nconst _fixProjRangeMat = new Mat4().set([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0.5, 0, 0, 0, 0.5, 1]);\nconst _haltonSequence = [new Vec2(0.5, 0.333333), new Vec2(0.25, 0.666667), new Vec2(0.75, 0.111111), new Vec2(0.125, 0.444444), new Vec2(0.625, 0.777778), new Vec2(0.375, 0.222222), new Vec2(0.875, 0.555556), new Vec2(0.0625, 0.888889), new Vec2(0.5625, 0.037037), new Vec2(0.3125, 0.370370), new Vec2(0.8125, 0.703704), new Vec2(0.1875, 0.148148), new Vec2(0.6875, 0.481481), new Vec2(0.4375, 0.814815), new Vec2(0.9375, 0.259259), new Vec2(0.03125, 0.592593)];\nconst _tempProjMat0 = new Mat4();\nconst _tempProjMat1 = new Mat4();\nconst _tempProjMat2 = new Mat4();\nconst _tempProjMat3 = new Mat4();\nconst _tempProjMat4 = new Mat4();\nconst _tempProjMat5 = new Mat4();\nconst _tempSet = new Set();\nconst _tempMeshInstances = [];\nconst _tempMeshInstancesSkinned = [];\nclass Renderer {\n\tconstructor(graphicsDevice) {\n\t\tthis.clustersDebugRendered = false;\n\t\tthis.processingMeshInstances = new Set();\n\t\tthis.worldClustersAllocator = void 0;\n\t\tthis.lights = [];\n\t\tthis.localLights = [];\n\t\tthis.cameraDirShadowLights = new Map();\n\t\tthis.dirLightShadows = new Map();\n\t\tthis.blueNoise = new BlueNoise(123);\n\t\tthis.device = graphicsDevice;\n\t\tthis.scene = null;\n\t\tthis.worldClustersAllocator = new WorldClustersAllocator(graphicsDevice);\n\t\tthis.lightTextureAtlas = new LightTextureAtlas(graphicsDevice);\n\t\tthis.shadowMapCache = new ShadowMapCache();\n\t\tthis.shadowRenderer = new ShadowRenderer(this, this.lightTextureAtlas);\n\t\tthis._shadowRendererLocal = new ShadowRendererLocal(this, this.shadowRenderer);\n\t\tthis._shadowRendererDirectional = new ShadowRendererDirectional(this, this.shadowRenderer);\n\t\tthis._renderPassUpdateClustered = new RenderPassUpdateClustered(this.device, this, this.shadowRenderer, this._shadowRendererLocal, this.lightTextureAtlas);\n\t\tthis.viewUniformFormat = null;\n\t\tthis.viewBindGroupFormat = null;\n\t\tthis._skinTime = 0;\n\t\tthis._morphTime = 0;\n\t\tthis._cullTime = 0;\n\t\tthis._shadowMapTime = 0;\n\t\tthis._lightClustersTime = 0;\n\t\tthis._layerCompositionUpdateTime = 0;\n\t\tthis._shadowDrawCalls = 0;\n\t\tthis._skinDrawCalls = 0;\n\t\tthis._instancedDrawCalls = 0;\n\t\tthis._shadowMapUpdates = 0;\n\t\tthis._numDrawCallsCulled = 0;\n\t\tthis._camerasRendered = 0;\n\t\tthis._lightClusters = 0;\n\t\tconst scope = graphicsDevice.scope;\n\t\tthis.boneTextureId = scope.resolve('texture_poseMap');\n\t\tthis.boneTextureSizeId = scope.resolve('texture_poseMapSize');\n\t\tthis.poseMatrixId = scope.resolve('matrix_pose[0]');\n\t\tthis.modelMatrixId = scope.resolve('matrix_model');\n\t\tthis.normalMatrixId = scope.resolve('matrix_normal');\n\t\tthis.viewInvId = scope.resolve('matrix_viewInverse');\n\t\tthis.viewPos = new Float32Array(3);\n\t\tthis.viewPosId = scope.resolve('view_position');\n\t\tthis.projId = scope.resolve('matrix_projection');\n\t\tthis.projSkyboxId = scope.resolve('matrix_projectionSkybox');\n\t\tthis.viewId = scope.resolve('matrix_view');\n\t\tthis.viewId3 = scope.resolve('matrix_view3');\n\t\tthis.viewProjId = scope.resolve('matrix_viewProjection');\n\t\tthis.flipYId = scope.resolve('projectionFlipY');\n\t\tthis.tbnBasis = scope.resolve('tbnBasis');\n\t\tthis.nearClipId = scope.resolve('camera_near');\n\t\tthis.farClipId = scope.resolve('camera_far');\n\t\tthis.cameraParams = new Float32Array(4);\n\t\tthis.cameraParamsId = scope.resolve('camera_params');\n\t\tthis.viewIndexId = scope.resolve('view_index');\n\t\tthis.blueNoiseJitterVersion = 0;\n\t\tthis.blueNoiseJitterVec = new Vec4();\n\t\tthis.blueNoiseJitterData = new Float32Array(4);\n\t\tthis.blueNoiseJitterId = scope.resolve('blueNoiseJitter');\n\t\tthis.blueNoiseTextureId = scope.resolve('blueNoiseTex32');\n\t\tthis.alphaTestId = scope.resolve('alpha_ref');\n\t\tthis.opacityMapId = scope.resolve('texture_opacityMap');\n\t\tthis.exposureId = scope.resolve('exposure');\n\t\tthis.twoSidedLightingNegScaleFactorId = scope.resolve('twoSidedLightingNegScaleFactor');\n\t\tthis.twoSidedLightingNegScaleFactorId.setValue(0);\n\t\tthis.morphWeightsA = scope.resolve('morph_weights_a');\n\t\tthis.morphWeightsB = scope.resolve('morph_weights_b');\n\t\tthis.morphPositionTex = scope.resolve('morphPositionTex');\n\t\tthis.morphNormalTex = scope.resolve('morphNormalTex');\n\t\tthis.morphTexParams = scope.resolve('morph_tex_params');\n\t\tthis.lightCube = new LightCube();\n\t\tthis.constantLightCube = scope.resolve('lightCube[0]');\n\t}\n\tdestroy() {\n\t\tthis.shadowRenderer = null;\n\t\tthis._shadowRendererLocal = null;\n\t\tthis._shadowRendererDirectional = null;\n\t\tthis.shadowMapCache.destroy();\n\t\tthis.shadowMapCache = null;\n\t\tthis._renderPassUpdateClustered.destroy();\n\t\tthis._renderPassUpdateClustered = null;\n\t\tthis.lightTextureAtlas.destroy();\n\t\tthis.lightTextureAtlas = null;\n\t}\n\tsortCompare(drawCallA, drawCallB) {\n\t\tif (drawCallA.layer === drawCallB.layer) {\n\t\t\tif (drawCallA.drawOrder && drawCallB.drawOrder) {\n\t\t\t\treturn drawCallA.drawOrder - drawCallB.drawOrder;\n\t\t\t} else if (drawCallA.zdist && drawCallB.zdist) {\n\t\t\t\treturn drawCallB.zdist - drawCallA.zdist;\n\t\t\t} else if (drawCallA.zdist2 && drawCallB.zdist2) {\n\t\t\t\treturn drawCallA.zdist2 - drawCallB.zdist2;\n\t\t\t}\n\t\t}\n\t\treturn drawCallB._key[SORTKEY_FORWARD] - drawCallA._key[SORTKEY_FORWARD];\n\t}\n\tsortCompareMesh(drawCallA, drawCallB) {\n\t\tif (drawCallA.layer === drawCallB.layer) {\n\t\t\tif (drawCallA.drawOrder && drawCallB.drawOrder) {\n\t\t\t\treturn drawCallA.drawOrder - drawCallB.drawOrder;\n\t\t\t} else if (drawCallA.zdist && drawCallB.zdist) {\n\t\t\t\treturn drawCallB.zdist - drawCallA.zdist;\n\t\t\t}\n\t\t}\n\t\tconst keyA = drawCallA._key[SORTKEY_FORWARD];\n\t\tconst keyB = drawCallB._key[SORTKEY_FORWARD];\n\t\tif (keyA === keyB && drawCallA.mesh && drawCallB.mesh) {\n\t\t\treturn drawCallB.mesh.id - drawCallA.mesh.id;\n\t\t}\n\t\treturn keyB - keyA;\n\t}\n\tsortCompareDepth(drawCallA, drawCallB) {\n\t\tconst keyA = drawCallA._key[SORTKEY_DEPTH];\n\t\tconst keyB = drawCallB._key[SORTKEY_DEPTH];\n\t\tif (keyA === keyB && drawCallA.mesh && drawCallB.mesh) {\n\t\t\treturn drawCallB.mesh.id - drawCallA.mesh.id;\n\t\t}\n\t\treturn keyB - keyA;\n\t}\n\tsetupViewport(camera, renderTarget) {\n\t\tconst device = this.device;\n\t\tconst pixelWidth = renderTarget ? renderTarget.width : device.width;\n\t\tconst pixelHeight = renderTarget ? renderTarget.height : device.height;\n\t\tconst rect = camera.rect;\n\t\tlet x = Math.floor(rect.x * pixelWidth);\n\t\tlet y = Math.floor(rect.y * pixelHeight);\n\t\tlet w = Math.floor(rect.z * pixelWidth);\n\t\tlet h = Math.floor(rect.w * pixelHeight);\n\t\tdevice.setViewport(x, y, w, h);\n\t\tif (camera._scissorRectClear) {\n\t\t\tconst scissorRect = camera.scissorRect;\n\t\t\tx = Math.floor(scissorRect.x * pixelWidth);\n\t\t\ty = Math.floor(scissorRect.y * pixelHeight);\n\t\t\tw = Math.floor(scissorRect.z * pixelWidth);\n\t\t\th = Math.floor(scissorRect.w * pixelHeight);\n\t\t}\n\t\tdevice.setScissor(x, y, w, h);\n\t}\n\tsetCameraUniforms(camera, target) {\n\t\tconst flipY = target == null ? void 0 : target.flipY;\n\t\tlet viewCount = 1;\n\t\tif (camera.xr && camera.xr.session) {\n\t\t\tvar _camera$_node;\n\t\t\tconst transform = ((_camera$_node = camera._node) == null || (_camera$_node = _camera$_node.parent) == null ? void 0 : _camera$_node.getWorldTransform()) || null;\n\t\t\tconst views = camera.xr.views;\n\t\t\tviewCount = views.list.length;\n\t\t\tfor (let v = 0; v < viewCount; v++) {\n\t\t\t\tconst view = views.list[v];\n\t\t\t\tview.updateTransforms(transform);\n\t\t\t\tcamera.frustum.setFromMat4(view.projViewOffMat);\n\t\t\t}\n\t\t} else {\n\t\t\tlet projMat = camera.projectionMatrix;\n\t\t\tif (camera.calculateProjection) {\n\t\t\t\tcamera.calculateProjection(projMat, VIEW_CENTER);\n\t\t\t}\n\t\t\tlet projMatSkybox = camera.getProjectionMatrixSkybox();\n\t\t\tif (flipY) {\n\t\t\t\tprojMat = _tempProjMat0.mul2(_flipYMat, projMat);\n\t\t\t\tprojMatSkybox = _tempProjMat1.mul2(_flipYMat, projMatSkybox);\n\t\t\t}\n\t\t\tif (this.device.isWebGPU) {\n\t\t\t\tprojMat = _tempProjMat2.mul2(_fixProjRangeMat, projMat);\n\t\t\t\tprojMatSkybox = _tempProjMat3.mul2(_fixProjRangeMat, projMatSkybox);\n\t\t\t}\n\t\t\tconst {\n\t\t\t\tjitter\n\t\t\t} = camera;\n\t\t\tlet jitterX = 0;\n\t\t\tlet jitterY = 0;\n\t\t\tif (jitter > 0) {\n\t\t\t\tconst targetWidth = target ? target.width : this.device.width;\n\t\t\t\tconst targetHeight = target ? target.height : this.device.height;\n\t\t\t\tconst offset = _haltonSequence[this.device.renderVersion % _haltonSequence.length];\n\t\t\t\tjitterX = jitter * (offset.x * 2 - 1) / targetWidth;\n\t\t\t\tjitterY = jitter * (offset.y * 2 - 1) / targetHeight;\n\t\t\t\tprojMat = _tempProjMat4.copy(projMat);\n\t\t\t\tprojMat.data[8] = jitterX;\n\t\t\t\tprojMat.data[9] = jitterY;\n\t\t\t\tprojMatSkybox = _tempProjMat5.copy(projMatSkybox);\n\t\t\t\tprojMatSkybox.data[8] = jitterX;\n\t\t\t\tprojMatSkybox.data[9] = jitterY;\n\t\t\t\tif (this.blueNoiseJitterVersion !== this.device.renderVersion) {\n\t\t\t\t\tthis.blueNoiseJitterVersion = this.device.renderVersion;\n\t\t\t\t\tthis.blueNoise.vec4(this.blueNoiseJitterVec);\n\t\t\t\t}\n\t\t\t}\n\t\t\tconst jitterVec = jitter > 0 ? this.blueNoiseJitterVec : Vec4.ZERO;\n\t\t\tthis.blueNoiseJitterData[0] = jitterVec.x;\n\t\t\tthis.blueNoiseJitterData[1] = jitterVec.y;\n\t\t\tthis.blueNoiseJitterData[2] = jitterVec.z;\n\t\t\tthis.blueNoiseJitterData[3] = jitterVec.w;\n\t\t\tthis.blueNoiseJitterId.setValue(this.blueNoiseJitterData);\n\t\t\tthis.projId.setValue(projMat.data);\n\t\t\tthis.projSkyboxId.setValue(projMatSkybox.data);\n\t\t\tif (camera.calculateTransform) {\n\t\t\t\tcamera.calculateTransform(viewInvMat, VIEW_CENTER);\n\t\t\t} else {\n\t\t\t\tconst pos = camera._node.getPosition();\n\t\t\t\tconst rot = camera._node.getRotation();\n\t\t\t\tviewInvMat.setTRS(pos, rot, Vec3.ONE);\n\t\t\t}\n\t\t\tthis.viewInvId.setValue(viewInvMat.data);\n\t\t\tviewMat.copy(viewInvMat).invert();\n\t\t\tthis.viewId.setValue(viewMat.data);\n\t\t\tviewMat3.setFromMat4(viewMat);\n\t\t\tthis.viewId3.setValue(viewMat3.data);\n\t\t\tviewProjMat.mul2(projMat, viewMat);\n\t\t\tthis.viewProjId.setValue(viewProjMat.data);\n\t\t\tcamera._storeShaderMatrices(viewProjMat, jitterX, jitterY, this.device.renderVersion);\n\t\t\tthis.flipYId.setValue(flipY ? -1 : 1);\n\t\t\tthis.dispatchViewPos(camera._node.getPosition());\n\t\t\tcamera.frustum.setFromMat4(viewProjMat);\n\t\t}\n\t\tthis.tbnBasis.setValue(flipY ? -1 : 1);\n\t\tconst n = camera._nearClip;\n\t\tconst f = camera._farClip;\n\t\tthis.nearClipId.setValue(n);\n\t\tthis.farClipId.setValue(f);\n\t\tthis.cameraParams[0] = 1 / f;\n\t\tthis.cameraParams[1] = f;\n\t\tthis.cameraParams[2] = n;\n\t\tthis.cameraParams[3] = camera.projection === PROJECTION_ORTHOGRAPHIC ? 1 : 0;\n\t\tthis.cameraParamsId.setValue(this.cameraParams);\n\t\tthis.exposureId.setValue(this.scene.physicalUnits ? camera.getExposure() : this.scene.exposure);\n\t\treturn viewCount;\n\t}\n\tclear(camera, clearColor, clearDepth, clearStencil) {\n\t\tconst flags = ((clearColor != null ? clearColor : camera._clearColorBuffer) ? CLEARFLAG_COLOR : 0) | ((clearDepth != null ? clearDepth : camera._clearDepthBuffer) ? CLEARFLAG_DEPTH : 0) | ((clearStencil != null ? clearStencil : camera._clearStencilBuffer) ? CLEARFLAG_STENCIL : 0);\n\t\tif (flags) {\n\t\t\tconst device = this.device;\n\t\t\tdevice.clear({\n\t\t\t\tcolor: [camera._clearColor.r, camera._clearColor.g, camera._clearColor.b, camera._clearColor.a],\n\t\t\t\tdepth: camera._clearDepth,\n\t\t\t\tstencil: camera._clearStencil,\n\t\t\t\tflags: flags\n\t\t\t});\n\t\t}\n\t}\n\tsetCamera(camera, target, clear, renderAction = null) {\n\t\tthis.setCameraUniforms(camera, target);\n\t\tthis.clearView(camera, target, clear, false);\n\t}\n\tclearView(camera, target, clear, forceWrite) {\n\t\tconst device = this.device;\n\t\tdevice.setRenderTarget(target);\n\t\tdevice.updateBegin();\n\t\tif (forceWrite) {\n\t\t\tdevice.setColorWrite(true, true, true, true);\n\t\t\tdevice.setDepthWrite(true);\n\t\t}\n\t\tthis.setupViewport(camera, target);\n\t\tif (clear) {\n\t\t\tconst options = camera._clearOptions;\n\t\t\tdevice.clear(options ? options : {\n\t\t\t\tcolor: [camera._clearColor.r, camera._clearColor.g, camera._clearColor.b, camera._clearColor.a],\n\t\t\t\tdepth: camera._clearDepth,\n\t\t\t\tflags: (camera._clearColorBuffer ? CLEARFLAG_COLOR : 0) | (camera._clearDepthBuffer ? CLEARFLAG_DEPTH : 0) | (camera._clearStencilBuffer ? CLEARFLAG_STENCIL : 0),\n\t\t\t\tstencil: camera._clearStencil\n\t\t\t});\n\t\t}\n\t}\n\tsetupCullMode(cullFaces, flipFactor, drawCall) {\n\t\tconst material = drawCall.material;\n\t\tlet mode = CULLFACE_NONE;\n\t\tif (cullFaces) {\n\t\t\tlet flipFaces = 1;\n\t\t\tif (material.cull === CULLFACE_FRONT || material.cull === CULLFACE_BACK) {\n\t\t\t\tflipFaces = flipFactor * drawCall.flipFacesFactor * drawCall.node.worldScaleSign;\n\t\t\t}\n\t\t\tif (flipFaces < 0) {\n\t\t\t\tmode = material.cull === CULLFACE_FRONT ? CULLFACE_BACK : CULLFACE_FRONT;\n\t\t\t} else {\n\t\t\t\tmode = material.cull;\n\t\t\t}\n\t\t}\n\t\tthis.device.setCullMode(mode);\n\t\tif (mode === CULLFACE_NONE && material.cull === CULLFACE_NONE) {\n\t\t\tthis.twoSidedLightingNegScaleFactorId.setValue(drawCall.node.worldScaleSign);\n\t\t}\n\t}\n\tupdateCameraFrustum(camera) {\n\t\tif (camera.xr && camera.xr.views.list.length) {\n\t\t\tconst view = camera.xr.views.list[0];\n\t\t\tviewProjMat.mul2(view.projMat, view.viewOffMat);\n\t\t\tcamera.frustum.setFromMat4(viewProjMat);\n\t\t\treturn;\n\t\t}\n\t\tconst projMat = camera.projectionMatrix;\n\t\tif (camera.calculateProjection) {\n\t\t\tcamera.calculateProjection(projMat, VIEW_CENTER);\n\t\t}\n\t\tif (camera.calculateTransform) {\n\t\t\tcamera.calculateTransform(viewInvMat, VIEW_CENTER);\n\t\t} else {\n\t\t\tconst pos = camera._node.getPosition();\n\t\t\tconst rot = camera._node.getRotation();\n\t\t\tviewInvMat.setTRS(pos, rot, Vec3.ONE);\n\t\t\tthis.viewInvId.setValue(viewInvMat.data);\n\t\t}\n\t\tviewMat.copy(viewInvMat).invert();\n\t\tviewProjMat.mul2(projMat, viewMat);\n\t\tcamera.frustum.setFromMat4(viewProjMat);\n\t}\n\tsetBaseConstants(device, material) {\n\t\tdevice.setCullMode(material.cull);\n\t\tif (material.opacityMap) {\n\t\t\tthis.opacityMapId.setValue(material.opacityMap);\n\t\t}\n\t\tif (material.opacityMap || material.alphaTest > 0) {\n\t\t\tthis.alphaTestId.setValue(material.alphaTest);\n\t\t}\n\t}\n\tupdateCpuSkinMatrices(drawCalls) {\n\t\t_skinUpdateIndex++;\n\t\tconst drawCallsCount = drawCalls.length;\n\t\tif (drawCallsCount === 0) return;\n\t\tfor (let i = 0; i < drawCallsCount; i++) {\n\t\t\tconst si = drawCalls[i].skinInstance;\n\t\t\tif (si) {\n\t\t\t\tsi.updateMatrices(drawCalls[i].node, _skinUpdateIndex);\n\t\t\t\tsi._dirty = true;\n\t\t\t}\n\t\t}\n\t}\n\tupdateGpuSkinMatrices(drawCalls) {\n\t\tfor (const drawCall of drawCalls) {\n\t\t\tconst skin = drawCall.skinInstance;\n\t\t\tif (skin && skin._dirty) {\n\t\t\t\tskin.updateMatrixPalette(drawCall.node, _skinUpdateIndex);\n\t\t\t\tskin._dirty = false;\n\t\t\t}\n\t\t}\n\t}\n\tupdateMorphing(drawCalls) {\n\t\tfor (const drawCall of drawCalls) {\n\t\t\tconst morphInst = drawCall.morphInstance;\n\t\t\tif (morphInst && morphInst._dirty) {\n\t\t\t\tmorphInst.update();\n\t\t\t}\n\t\t}\n\t}\n\tupdateGSplats(drawCalls) {\n\t\tfor (const drawCall of drawCalls) {\n\t\t\tvar _drawCall$gsplatInsta;\n\t\t\t(_drawCall$gsplatInsta = drawCall.gsplatInstance) == null || _drawCall$gsplatInsta.update();\n\t\t}\n\t}\n\tgpuUpdate(drawCalls) {\n\t\tthis.updateGpuSkinMatrices(drawCalls);\n\t\tthis.updateMorphing(drawCalls);\n\t\tthis.updateGSplats(drawCalls);\n\t}\n\tsetVertexBuffers(device, mesh) {\n\t\tdevice.setVertexBuffer(mesh.vertexBuffer);\n\t}\n\tsetMorphing(device, morphInstance) {\n\t\tif (morphInstance) {\n\t\t\tif (morphInstance.morph.useTextureMorph) {\n\t\t\t\tdevice.setVertexBuffer(morphInstance.morph.vertexBufferIds);\n\t\t\t\tthis.morphPositionTex.setValue(morphInstance.texturePositions);\n\t\t\t\tthis.morphNormalTex.setValue(morphInstance.textureNormals);\n\t\t\t\tthis.morphTexParams.setValue(morphInstance._textureParams);\n\t\t\t} else {\n\t\t\t\tfor (let t = 0; t < morphInstance._activeVertexBuffers.length; t++) {\n\t\t\t\t\tconst vb = morphInstance._activeVertexBuffers[t];\n\t\t\t\t\tif (vb) {\n\t\t\t\t\t\tconst semantic = SEMANTIC_ATTR + (t + 8);\n\t\t\t\t\t\tvb.format.elements[0].name = semantic;\n\t\t\t\t\t\tvb.format.elements[0].scopeId = device.scope.resolve(semantic);\n\t\t\t\t\t\tvb.format.update();\n\t\t\t\t\t\tdevice.setVertexBuffer(vb);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tthis.morphWeightsA.setValue(morphInstance._shaderMorphWeightsA);\n\t\t\t\tthis.morphWeightsB.setValue(morphInstance._shaderMorphWeightsB);\n\t\t\t}\n\t\t}\n\t}\n\tsetSkinning(device, meshInstance) {\n\t\tconst skinInstance = meshInstance.skinInstance;\n\t\tif (skinInstance) {\n\t\t\tthis._skinDrawCalls++;\n\t\t\tif (device.supportsBoneTextures) {\n\t\t\t\tconst boneTexture = skinInstance.boneTexture;\n\t\t\t\tthis.boneTextureId.setValue(boneTexture);\n\t\t\t\tthis.boneTextureSizeId.setValue(skinInstance.boneTextureSize);\n\t\t\t} else {\n\t\t\t\tthis.poseMatrixId.setValue(skinInstance.matrixPalette);\n\t\t\t}\n\t\t}\n\t}\n\tdispatchViewPos(position) {\n\t\tconst vp = this.viewPos;\n\t\tvp[0] = position.x;\n\t\tvp[1] = position.y;\n\t\tvp[2] = position.z;\n\t\tthis.viewPosId.setValue(vp);\n\t}\n\tinitViewBindGroupFormat(isClustered) {\n\t\tif (this.device.supportsUniformBuffers && !this.viewUniformFormat) {\n\t\t\tconst uniforms = [new UniformFormat(\"matrix_viewProjection\", UNIFORMTYPE_MAT4), new UniformFormat(\"cubeMapRotationMatrix\", UNIFORMTYPE_MAT3), new UniformFormat(\"view_position\", UNIFORMTYPE_VEC3), new UniformFormat(\"skyboxIntensity\", UNIFORMTYPE_FLOAT), new UniformFormat(\"exposure\", UNIFORMTYPE_FLOAT), new UniformFormat(\"textureBias\", UNIFORMTYPE_FLOAT)];\n\t\t\tif (isClustered) {\n\t\t\t\tuniforms.push(...[new UniformFormat(\"clusterCellsCountByBoundsSize\", UNIFORMTYPE_VEC3), new UniformFormat(\"clusterTextureSize\", UNIFORMTYPE_VEC3), new UniformFormat(\"clusterBoundsMin\", UNIFORMTYPE_VEC3), new UniformFormat(\"clusterBoundsDelta\", UNIFORMTYPE_VEC3), new UniformFormat(\"clusterCellsDot\", UNIFORMTYPE_VEC3), new UniformFormat(\"clusterCellsMax\", UNIFORMTYPE_VEC3), new UniformFormat(\"clusterCompressionLimit0\", UNIFORMTYPE_VEC2), new UniformFormat(\"shadowAtlasParams\", UNIFORMTYPE_VEC2), new UniformFormat(\"clusterMaxCells\", UNIFORMTYPE_INT), new UniformFormat(\"clusterSkip\", UNIFORMTYPE_FLOAT)]);\n\t\t\t}\n\t\t\tthis.viewUniformFormat = new UniformBufferFormat(this.device, uniforms);\n\t\t\tconst formats = [new BindUniformBufferFormat(UNIFORM_BUFFER_DEFAULT_SLOT_NAME, SHADERSTAGE_VERTEX | SHADERSTAGE_FRAGMENT), new BindTextureFormat('lightsTextureFloat', SHADERSTAGE_FRAGMENT, TEXTUREDIMENSION_2D, SAMPLETYPE_UNFILTERABLE_FLOAT), new BindTextureFormat('lightsTexture8', SHADERSTAGE_FRAGMENT, TEXTUREDIMENSION_2D, SAMPLETYPE_UNFILTERABLE_FLOAT), new BindTextureFormat('shadowAtlasTexture', SHADERSTAGE_FRAGMENT, TEXTUREDIMENSION_2D, SAMPLETYPE_DEPTH), new BindTextureFormat('cookieAtlasTexture', SHADERSTAGE_FRAGMENT, TEXTUREDIMENSION_2D, SAMPLETYPE_FLOAT), new BindTextureFormat('areaLightsLutTex1', SHADERSTAGE_FRAGMENT, TEXTUREDIMENSION_2D, SAMPLETYPE_FLOAT), new BindTextureFormat('areaLightsLutTex2', SHADERSTAGE_FRAGMENT, TEXTUREDIMENSION_2D, SAMPLETYPE_FLOAT)];\n\t\t\tif (isClustered) {\n\t\t\t\tformats.push(...[new BindTextureFormat('clusterWorldTexture', SHADERSTAGE_FRAGMENT, TEXTUREDIMENSION_2D, SAMPLETYPE_UNFILTERABLE_FLOAT)]);\n\t\t\t}\n\t\t\tthis.viewBindGroupFormat = new BindGroupFormat(this.device, formats);\n\t\t}\n\t}\n\tsetupViewUniformBuffers(viewBindGroups, viewUniformFormat, viewBindGroupFormat, viewCount) {\n\t\tconst device = this.device;\n\t\twhile (viewBindGroups.length < viewCount) {\n\t\t\tconst ub = new UniformBuffer(device, viewUniformFormat, false);\n\t\t\tconst bg = new BindGroup(device, viewBindGroupFormat, ub);\n\t\t\tviewBindGroups.push(bg);\n\t\t}\n\t\tconst viewBindGroup = viewBindGroups[0];\n\t\tviewBindGroup.defaultUniformBuffer.update();\n\t\tviewBindGroup.update();\n\t\tdevice.setBindGroup(BINDGROUP_VIEW, viewBindGroup);\n\t}\n\tsetupMeshUniformBuffers(shaderInstance, meshInstance) {\n\t\tconst device = this.device;\n\t\tif (device.supportsUniformBuffers) {\n\t\t\tthis.modelMatrixId.setValue(meshInstance.node.worldTransform.data);\n\t\t\tthis.normalMatrixId.setValue(meshInstance.node.normalMatrix.data);\n\t\t\tconst meshBindGroup = shaderInstance.getBindGroup(device);\n\t\t\tmeshBindGroup.defaultUniformBuffer.update();\n\t\t\tmeshBindGroup.update();\n\t\t\tdevice.setBindGroup(BINDGROUP_MESH, meshBindGroup);\n\t\t}\n\t}\n\tdrawInstance(device, meshInstance, mesh, style, normal) {\n\t\tconst modelMatrix = meshInstance.node.worldTransform;\n\t\tthis.modelMatrixId.setValue(modelMatrix.data);\n\t\tif (normal) {\n\t\t\tthis.normalMatrixId.setValue(meshInstance.node.normalMatrix.data);\n\t\t}\n\t\tconst instancingData = meshInstance.instancingData;\n\t\tif (instancingData) {\n\t\t\tif (instancingData.count > 0) {\n\t\t\t\tthis._instancedDrawCalls++;\n\t\t\t\tdevice.setVertexBuffer(instancingData.vertexBuffer);\n\t\t\t\tdevice.draw(mesh.primitive[style], instancingData.count);\n\t\t\t} else {\n\t\t\t\tdevice.clearVertexBuffer();\n\t\t\t}\n\t\t} else {\n\t\t\tdevice.draw(mesh.primitive[style]);\n\t\t}\n\t}\n\tdrawInstance2(device, meshInstance, mesh, style) {\n\t\tconst instancingData = meshInstance.instancingData;\n\t\tif (instancingData) {\n\t\t\tif (instancingData.count > 0) {\n\t\t\t\tthis._instancedDrawCalls++;\n\t\t\t\tdevice.draw(mesh.primitive[style], instancingData.count, true);\n\t\t\t} else {\n\t\t\t\tdevice.clearVertexBuffer();\n\t\t\t}\n\t\t} else {\n\t\t\tdevice.draw(mesh.primitive[style], undefined, true);\n\t\t}\n\t}\n\tcull(camera, drawCalls, culledInstances) {\n\t\tconst opaque = culledInstances.opaque;\n\t\topaque.length = 0;\n\t\tconst transparent = culledInstances.transparent;\n\t\ttransparent.length = 0;\n\t\tconst doCull = camera.frustumCulling;\n\t\tconst count = drawCalls.length;\n\t\tfor (let i = 0; i < count; i++) {\n\t\t\tconst drawCall = drawCalls[i];\n\t\t\tif (drawCall.visible) {\n\t\t\t\tconst visible = !doCull || !drawCall.cull || drawCall._isVisible(camera);\n\t\t\t\tif (visible) {\n\t\t\t\t\tdrawCall.visibleThisFrame = true;\n\t\t\t\t\tconst bucket = drawCall.transparent ? transparent : opaque;\n\t\t\t\t\tbucket.push(drawCall);\n\t\t\t\t\tif (drawCall.skinInstance || drawCall.morphInstance || drawCall.gsplatInstance) {\n\t\t\t\t\t\tthis.processingMeshInstances.add(drawCall);\n\t\t\t\t\t\tif (drawCall.gsplatInstance) {\n\t\t\t\t\t\t\tdrawCall.gsplatInstance.cameras.push(camera);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\tcollectLights(comp) {\n\t\tthis.lights.length = 0;\n\t\tthis.localLights.length = 0;\n\t\tconst stats = this.scene._stats;\n\t\tconst count = comp.layerList.length;\n\t\tfor (let i = 0; i < count; i++) {\n\t\t\tconst layer = comp.layerList[i];\n\t\t\tif (!_tempLayerSet.has(layer)) {\n\t\t\t\t_tempLayerSet.add(layer);\n\t\t\t\tconst lights = layer._lights;\n\t\t\t\tfor (let j = 0; j < lights.length; j++) {\n\t\t\t\t\tconst light = lights[j];\n\t\t\t\t\tif (!_tempLightSet.has(light)) {\n\t\t\t\t\t\t_tempLightSet.add(light);\n\t\t\t\t\t\tthis.lights.push(light);\n\t\t\t\t\t\tif (light._type !== LIGHTTYPE_DIRECTIONAL) {\n\t\t\t\t\t\t\tthis.localLights.push(light);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tstats.lights = this.lights.length;\n\t\t_tempLightSet.clear();\n\t\t_tempLayerSet.clear();\n\t}\n\tcullLights(camera, lights) {\n\t\tconst clusteredLightingEnabled = this.scene.clusteredLightingEnabled;\n\t\tconst physicalUnits = this.scene.physicalUnits;\n\t\tfor (let i = 0; i < lights.length; i++) {\n\t\t\tconst light = lights[i];\n\t\t\tif (light.enabled) {\n\t\t\t\tif (light._type !== LIGHTTYPE_DIRECTIONAL) {\n\t\t\t\t\tlight.getBoundingSphere(tempSphere);\n\t\t\t\t\tif (camera.frustum.containsSphere(tempSphere)) {\n\t\t\t\t\t\tlight.visibleThisFrame = true;\n\t\t\t\t\t\tlight.usePhysicalUnits = physicalUnits;\n\t\t\t\t\t\tconst screenSize = camera.getScreenSize(tempSphere);\n\t\t\t\t\t\tlight.maxScreenSize = Math.max(light.maxScreenSize, screenSize);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tif (!clusteredLightingEnabled) {\n\t\t\t\t\t\t\tif (light.castShadows && !light.shadowMap) {\n\t\t\t\t\t\t\t\tlight.visibleThisFrame = true;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tlight.usePhysicalUnits = this.scene.physicalUnits;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\tcullShadowmaps(comp) {\n\t\tconst isClustered = this.scene.clusteredLightingEnabled;\n\t\tfor (let i = 0; i < this.localLights.length; i++) {\n\t\t\tconst light = this.localLights[i];\n\t\t\tif (light._type !== LIGHTTYPE_DIRECTIONAL) {\n\t\t\t\tif (isClustered) {\n\t\t\t\t\tif (light.atlasSlotUpdated && light.shadowUpdateMode === SHADOWUPDATE_NONE) {\n\t\t\t\t\t\tlight.shadowUpdateMode = SHADOWUPDATE_THISFRAME;\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tif (light.shadowUpdateMode === SHADOWUPDATE_NONE && light.castShadows) {\n\t\t\t\t\t\tif (!light.getRenderData(null, 0).shadowCamera.renderTarget) {\n\t\t\t\t\t\t\tlight.shadowUpdateMode = SHADOWUPDATE_THISFRAME;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tif (light.visibleThisFrame && light.castShadows && light.shadowUpdateMode !== SHADOWUPDATE_NONE) {\n\t\t\t\t\tthis._shadowRendererLocal.cull(light, comp);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tthis.cameraDirShadowLights.clear();\n\t\tconst cameras = comp.cameras;\n\t\tfor (let i = 0; i < cameras.length; i++) {\n\t\t\tconst cameraComponent = cameras[i];\n\t\t\tif (cameraComponent.enabled) {\n\t\t\t\tconst camera = cameraComponent.camera;\n\t\t\t\tlet lightList;\n\t\t\t\tconst cameraLayers = camera.layers;\n\t\t\t\tfor (let l = 0; l < cameraLayers.length; l++) {\n\t\t\t\t\tconst cameraLayer = comp.getLayerById(cameraLayers[l]);\n\t\t\t\t\tif (cameraLayer) {\n\t\t\t\t\t\tconst layerDirLights = cameraLayer.splitLights[LIGHTTYPE_DIRECTIONAL];\n\t\t\t\t\t\tfor (let j = 0; j < layerDirLights.length; j++) {\n\t\t\t\t\t\t\tconst light = layerDirLights[j];\n\t\t\t\t\t\t\tif (light.castShadows && !_tempSet.has(light)) {\n\t\t\t\t\t\t\t\tvar _lightList;\n\t\t\t\t\t\t\t\t_tempSet.add(light);\n\t\t\t\t\t\t\t\tlightList = (_lightList = lightList) != null ? _lightList : [];\n\t\t\t\t\t\t\t\tlightList.push(light);\n\t\t\t\t\t\t\t\tthis._shadowRendererDirectional.cull(light, comp, camera);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tif (lightList) {\n\t\t\t\t\tthis.cameraDirShadowLights.set(camera, lightList);\n\t\t\t\t}\n\t\t\t\t_tempSet.clear();\n\t\t\t}\n\t\t}\n\t}\n\tcullComposition(comp) {\n\t\tthis.processingMeshInstances.clear();\n\t\tconst numCameras = comp.cameras.length;\n\t\tfor (let i = 0; i < numCameras; i++) {\n\t\t\tconst camera = comp.cameras[i];\n\t\t\tlet currentRenderTarget;\n\t\t\tlet cameraChanged = true;\n\t\t\tthis._camerasRendered++;\n\t\t\tconst layerIds = camera.layers;\n\t\t\tfor (let j = 0; j < layerIds.length; j++) {\n\t\t\t\tconst layer = comp.getLayerById(layerIds[j]);\n\t\t\t\tif (layer && layer.enabled) {\n\t\t\t\t\tvar _camera$renderTarget;\n\t\t\t\t\tconst renderTarget = (_camera$renderTarget = camera.renderTarget) != null ? _camera$renderTarget : layer.renderTarget;\n\t\t\t\t\tif (cameraChanged || renderTarget !== currentRenderTarget) {\n\t\t\t\t\t\tcameraChanged = false;\n\t\t\t\t\t\tcurrentRenderTarget = renderTarget;\n\t\t\t\t\t\tcamera.frameUpdate(renderTarget);\n\t\t\t\t\t\tthis.updateCameraFrustum(camera.camera);\n\t\t\t\t\t}\n\t\t\t\t\tthis.cullLights(camera.camera, layer._lights);\n\t\t\t\t\tlayer.onPreCull == null || layer.onPreCull(comp.camerasMap.get(camera));\n\t\t\t\t\tconst culledInstances = layer.getCulledInstances(camera.camera);\n\t\t\t\t\tthis.cull(camera.camera, layer.meshInstances, culledInstances);\n\t\t\t\t\tlayer.onPostCull == null || layer.onPostCull(comp.camerasMap.get(camera));\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (this.scene.clusteredLightingEnabled) {\n\t\t\tthis.updateLightTextureAtlas();\n\t\t}\n\t\tthis.cullShadowmaps(comp);\n\t}\n\tupdateShaders(drawCalls, onlyLitShaders) {\n\t\tconst count = drawCalls.length;\n\t\tfor (let i = 0; i < count; i++) {\n\t\t\tconst mat = drawCalls[i].material;\n\t\t\tif (mat) {\n\t\t\t\tif (!_tempSet.has(mat)) {\n\t\t\t\t\t_tempSet.add(mat);\n\t\t\t\t\tif (mat.getShaderVariant !== Material.prototype.getShaderVariant) {\n\t\t\t\t\t\tif (onlyLitShaders) {\n\t\t\t\t\t\t\tif (!mat.useLighting || mat.emitter && !mat.emitter.lighting) continue;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tmat.clearVariants();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\t_tempSet.clear();\n\t}\n\tupdateFrameUniforms() {\n\t\tthis.blueNoiseTextureId.setValue(getBlueNoiseTexture(this.device));\n\t}\n\tbeginFrame(comp) {\n\t\tconst scene = this.scene;\n\t\tconst updateShaders = scene.updateShaders;\n\t\tconst layers = comp.layerList;\n\t\tconst layerCount = layers.length;\n\t\tfor (let i = 0; i < layerCount; i++) {\n\t\t\tconst layer = layers[i];\n\t\t\tconst meshInstances = layer.meshInstances;\n\t\t\tconst count = meshInstances.length;\n\t\t\tfor (let j = 0; j < count; j++) {\n\t\t\t\tconst meshInst = meshInstances[j];\n\t\t\t\tmeshInst.visibleThisFrame = false;\n\t\t\t\tif (updateShaders) {\n\t\t\t\t\t_tempMeshInstances.push(meshInst);\n\t\t\t\t}\n\t\t\t\tif (meshInst.skinInstance) {\n\t\t\t\t\t_tempMeshInstancesSkinned.push(meshInst);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (updateShaders) {\n\t\t\tconst onlyLitShaders = !scene.updateShaders;\n\t\t\tthis.updateShaders(_tempMeshInstances, onlyLitShaders);\n\t\t\tscene.updateShaders = false;\n\t\t\tscene._shaderVersion++;\n\t\t}\n\t\tthis.updateFrameUniforms();\n\t\tthis.updateCpuSkinMatrices(_tempMeshInstancesSkinned);\n\t\t_tempMeshInstances.length = 0;\n\t\t_tempMeshInstancesSkinned.length = 0;\n\t\tconst lights = this.lights;\n\t\tconst lightCount = lights.length;\n\t\tfor (let i = 0; i < lightCount; i++) {\n\t\t\tlights[i].beginFrame();\n\t\t}\n\t}\n\tupdateLightTextureAtlas() {\n\t\tthis.lightTextureAtlas.update(this.localLights, this.scene.lighting);\n\t}\n\tupdateLayerComposition(comp) {\n\t\tconst len = comp.layerList.length;\n\t\tfor (let i = 0; i < len; i++) {\n\t\t\tcomp.layerList[i]._postRenderCounter = 0;\n\t\t}\n\t\tconst scene = this.scene;\n\t\tconst shaderVersion = scene._shaderVersion;\n\t\tfor (let i = 0; i < len; i++) {\n\t\t\tconst layer = comp.layerList[i];\n\t\t\tlayer._shaderVersion = shaderVersion;\n\t\t\tlayer._preRenderCalledForCameras = 0;\n\t\t\tlayer._postRenderCalledForCameras = 0;\n\t\t\tconst transparent = comp.subLayerList[i];\n\t\t\tif (transparent) {\n\t\t\t\tlayer._postRenderCounter |= 2;\n\t\t\t} else {\n\t\t\t\tlayer._postRenderCounter |= 1;\n\t\t\t}\n\t\t\tlayer._postRenderCounterMax = layer._postRenderCounter;\n\t\t}\n\t\tcomp._update();\n\t}\n\tframeUpdate() {\n\t\tthis.clustersDebugRendered = false;\n\t\tthis.initViewBindGroupFormat(this.scene.clusteredLightingEnabled);\n\t\tthis.dirLightShadows.clear();\n\t}\n}\n\nexport { Renderer };\n", "class RenderAction {\n\tconstructor() {\n\t\tthis.layer = null;\n\t\tthis.transparent = false;\n\t\tthis.camera = null;\n\t\tthis.renderTarget = null;\n\t\tthis.lightClusters = null;\n\t\tthis.clearColor = false;\n\t\tthis.clearDepth = false;\n\t\tthis.clearStencil = false;\n\t\tthis.triggerPostprocess = false;\n\t\tthis.firstCameraUse = false;\n\t\tthis.lastCameraUse = false;\n\t\tthis.viewBindGroups = [];\n\t\tthis.useCameraPasses = false;\n\t}\n\tdestroy() {\n\t\tthis.viewBindGroups.forEach(bg => {\n\t\t\tbg.defaultUniformBuffer.destroy();\n\t\t\tbg.destroy();\n\t\t});\n\t\tthis.viewBindGroups.length = 0;\n\t}\n\tsetupClears(camera, layer) {\n\t\tthis.clearColor = (camera == null ? void 0 : camera.clearColorBuffer) || layer.clearColorBuffer;\n\t\tthis.clearDepth = (camera == null ? void 0 : camera.clearDepthBuffer) || layer.clearDepthBuffer;\n\t\tthis.clearStencil = (camera == null ? void 0 : camera.clearStencilBuffer) || layer.clearStencilBuffer;\n\t}\n}\n\nexport { RenderAction };\n", "import { BlendState } from '../../platform/graphics/blend-state.js';\nimport { RenderPass } from '../../platform/graphics/render-pass.js';\nimport { RenderAction } from '../composition/render-action.js';\n\nclass RenderPassForward extends RenderPass {\n\tconstructor(device, layerComposition, scene, renderer) {\n\t\tsuper(device);\n\t\tthis.layerComposition = void 0;\n\t\tthis.scene = void 0;\n\t\tthis.renderer = void 0;\n\t\tthis.renderActions = [];\n\t\tthis.noDepthClear = false;\n\t\tthis.layerComposition = layerComposition;\n\t\tthis.scene = scene;\n\t\tthis.renderer = renderer;\n\t}\n\taddRenderAction(renderAction) {\n\t\tthis.renderActions.push(renderAction);\n\t}\n\taddLayer(cameraComponent, layer, transparent, autoClears = true) {\n\t\tconst ra = new RenderAction();\n\t\tra.renderTarget = this.renderTarget;\n\t\tra.camera = cameraComponent;\n\t\tra.layer = layer;\n\t\tra.transparent = transparent;\n\t\tif (autoClears) {\n\t\t\tconst firstRa = this.renderActions.length === 0;\n\t\t\tra.setupClears(firstRa ? cameraComponent : undefined, layer);\n\t\t}\n\t\tthis.addRenderAction(ra);\n\t}\n\taddLayers(composition, cameraComponent, startIndex, firstLayerClears, lastLayerId, lastLayerIsTransparent = true) {\n\t\tconst {\n\t\t\tlayerList,\n\t\t\tsubLayerEnabled,\n\t\t\tsubLayerList\n\t\t} = composition;\n\t\tlet clearRenderTarget = firstLayerClears;\n\t\tlet index = startIndex;\n\t\twhile (index < layerList.length) {\n\t\t\tconst layer = layerList[index];\n\t\t\tconst isTransparent = subLayerList[index];\n\t\t\tconst enabled = layer.enabled && subLayerEnabled[index];\n\t\t\tconst renderedbyCamera = cameraComponent.camera.layersSet.has(layer.id);\n\t\t\tif (enabled && renderedbyCamera) {\n\t\t\t\tthis.addLayer(cameraComponent, layer, isTransparent, clearRenderTarget);\n\t\t\t\tclearRenderTarget = false;\n\t\t\t}\n\t\t\tindex++;\n\t\t\tif (layer.id === lastLayerId && isTransparent === lastLayerIsTransparent) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\treturn index;\n\t}\n\tupdateDirectionalShadows() {\n\t\tconst {\n\t\t\trenderer,\n\t\t\trenderActions\n\t\t} = this;\n\t\tfor (let i = 0; i < renderActions.length; i++) {\n\t\t\tconst renderAction = renderActions[i];\n\t\t\tconst cameraComp = renderAction.camera;\n\t\t\tconst camera = cameraComp.camera;\n\t\t\tconst shadowDirLights = this.renderer.cameraDirShadowLights.get(camera);\n\t\t\tif (shadowDirLights) {\n\t\t\t\tfor (let l = 0; l < shadowDirLights.length; l++) {\n\t\t\t\t\tconst light = shadowDirLights[l];\n\t\t\t\t\tif (renderer.dirLightShadows.get(light) !== camera) {\n\t\t\t\t\t\trenderer.dirLightShadows.set(light, camera);\n\t\t\t\t\t\tconst shadowPass = renderer._shadowRendererDirectional.getLightRenderPass(light, camera);\n\t\t\t\t\t\tif (shadowPass) {\n\t\t\t\t\t\t\tthis.beforePasses.push(shadowPass);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\tupdateClears() {\n\t\tconst renderAction = this.renderActions[0];\n\t\tif (renderAction) {\n\t\t\tconst cameraComponent = renderAction.camera;\n\t\t\tconst camera = cameraComponent.camera;\n\t\t\tconst fullSizeClearRect = camera.fullSizeClearRect;\n\t\t\tthis.setClearColor(fullSizeClearRect && renderAction.clearColor ? camera.clearColor : undefined);\n\t\t\tthis.setClearDepth(fullSizeClearRect && renderAction.clearDepth && !this.noDepthClear ? camera.clearDepth : undefined);\n\t\t\tthis.setClearStencil(fullSizeClearRect && renderAction.clearStencil ? camera.clearStencil : undefined);\n\t\t}\n\t}\n\tframeUpdate() {\n\t\tsuper.frameUpdate();\n\t\tthis.updateDirectionalShadows();\n\t\tthis.updateClears();\n\t}\n\tbefore() {\n\t\tconst {\n\t\t\trenderActions\n\t\t} = this;\n\t\tif (renderActions.length) {\n\t\t\tconst ra = renderActions[0];\n\t\t\tif (ra.camera.onPreRender && ra.firstCameraUse) {\n\t\t\t\tra.camera.onPreRender();\n\t\t\t}\n\t\t}\n\t}\n\texecute() {\n\t\tconst {\n\t\t\tlayerComposition,\n\t\t\trenderActions\n\t\t} = this;\n\t\tfor (let i = 0; i < renderActions.length; i++) {\n\t\t\tconst ra = renderActions[i];\n\t\t\tif (layerComposition.isEnabled(ra.layer, ra.transparent)) {\n\t\t\t\tthis.renderRenderAction(ra, i === 0);\n\t\t\t}\n\t\t}\n\t}\n\tafter() {\n\t\tconst {\n\t\t\trenderActions\n\t\t} = this;\n\t\tif (renderActions.length) {\n\t\t\tconst ra = renderActions[renderActions.length - 1];\n\t\t\tif (ra.camera.onPostRender && ra.lastCameraUse) {\n\t\t\t\tra.camera.onPostRender();\n\t\t\t}\n\t\t}\n\t\tthis.beforePasses.length = 0;\n\t}\n\trenderRenderAction(renderAction, firstRenderAction) {\n\t\tconst {\n\t\t\trenderer,\n\t\t\tlayerComposition\n\t\t} = this;\n\t\tconst device = renderer.device;\n\t\tconst {\n\t\t\tlayer,\n\t\t\ttransparent,\n\t\t\tcamera\n\t\t} = renderAction;\n\t\tconst cameraPass = layerComposition.camerasMap.get(camera);\n\t\tif (!transparent && layer.onPreRenderOpaque) {\n\t\t\tlayer.onPreRenderOpaque(cameraPass);\n\t\t} else if (transparent && layer.onPreRenderTransparent) {\n\t\t\tlayer.onPreRenderTransparent(cameraPass);\n\t\t}\n\t\tif (!(layer._preRenderCalledForCameras & 1 << cameraPass)) {\n\t\t\tif (layer.onPreRender) {\n\t\t\t\tlayer.onPreRender(cameraPass);\n\t\t\t}\n\t\t\tlayer._preRenderCalledForCameras |= 1 << cameraPass;\n\t\t}\n\t\tif (camera) {\n\t\t\tvar _camera$camera$shader, _camera$camera$shader2;\n\t\t\tconst options = {\n\t\t\t\tlightClusters: renderAction.lightClusters\n\t\t\t};\n\t\t\tconst shaderPass = (_camera$camera$shader = (_camera$camera$shader2 = camera.camera.shaderPassInfo) == null ? void 0 : _camera$camera$shader2.index) != null ? _camera$camera$shader : layer.shaderPass;\n\t\t\tif (!firstRenderAction || !camera.camera.fullSizeClearRect) {\n\t\t\t\toptions.clearColor = renderAction.clearColor;\n\t\t\t\toptions.clearDepth = renderAction.clearDepth;\n\t\t\t\toptions.clearStencil = renderAction.clearStencil;\n\t\t\t}\n\t\t\trenderer.renderForwardLayer(camera.camera, renderAction.renderTarget, layer, transparent, shaderPass, renderAction.viewBindGroups, options);\n\t\t\tdevice.setBlendState(BlendState.NOBLEND);\n\t\t\tdevice.setStencilState(null, null);\n\t\t\tdevice.setAlphaToCoverage(false);\n\t\t}\n\t\tif (!transparent && layer.onPostRenderOpaque) {\n\t\t\tlayer.onPostRenderOpaque(cameraPass);\n\t\t} else if (transparent && layer.onPostRenderTransparent) {\n\t\t\tlayer.onPostRenderTransparent(cameraPass);\n\t\t}\n\t\tif (layer.onPostRender && !(layer._postRenderCalledForCameras & 1 << cameraPass)) {\n\t\t\tlayer._postRenderCounter &= ~(transparent ? 2 : 1);\n\t\t\tif (layer._postRenderCounter === 0) {\n\t\t\t\tlayer.onPostRender(cameraPass);\n\t\t\t\tlayer._postRenderCalledForCameras |= 1 << cameraPass;\n\t\t\t\tlayer._postRenderCounter = layer._postRenderCounterMax;\n\t\t\t}\n\t\t}\n\t}\n}\n\nexport { RenderPassForward };\n", "import { RenderPass } from '../../platform/graphics/render-pass.js';\n\nclass RenderPassPostprocessing extends RenderPass {\n\tconstructor(device, renderer, renderAction) {\n\t\tsuper(device);\n\t\tthis.renderer = renderer;\n\t\tthis.renderAction = renderAction;\n\t\tthis.requiresCubemaps = false;\n\t}\n\texecute() {\n\t\tconst renderAction = this.renderAction;\n\t\tconst camera = renderAction.camera;\n\t\tcamera.onPostprocessing();\n\t}\n}\n\nexport { RenderPassPostprocessing };\n", "import { Vec3 } from '../../core/math/vec3.js';\nimport { LIGHTSHAPE_PUNCTUAL, LIGHTTYPE_OMNI, LIGHTTYPE_SPOT, LIGHTTYPE_DIRECTIONAL, FOG_NONE, FOG_LINEAR, LAYERID_DEPTH } from '../constants.js';\nimport { Renderer } from './renderer.js';\nimport { LightCamera } from './light-camera.js';\nimport { RenderPassForward } from './render-pass-forward.js';\nimport { RenderPassPostprocessing } from './render-pass-postprocessing.js';\n\nconst _noLights = [[], [], []];\nconst _drawCallList = {\n\tdrawCalls: [],\n\tshaderInstances: [],\n\tisNewMaterial: [],\n\tlightMaskChanged: [],\n\tclear: function () {\n\t\tthis.drawCalls.length = 0;\n\t\tthis.shaderInstances.length = 0;\n\t\tthis.isNewMaterial.length = 0;\n\t\tthis.lightMaskChanged.length = 0;\n\t}\n};\nfunction vogelDiskPrecalculationSamples(numSamples) {\n\tconst samples = [];\n\tfor (let i = 0; i < numSamples; ++i) {\n\t\tconst r = Math.sqrt(i + 0.5) / Math.sqrt(numSamples);\n\t\tsamples.push(r);\n\t}\n\treturn samples;\n}\nfunction vogelSpherePrecalculationSamples(numSamples) {\n\tconst samples = [];\n\tfor (let i = 0; i < numSamples; i++) {\n\t\tconst weight = i / numSamples;\n\t\tconst radius = Math.sqrt(1.0 - weight * weight);\n\t\tsamples.push(radius);\n\t}\n\treturn samples;\n}\nclass ForwardRenderer extends Renderer {\n\tconstructor(graphicsDevice) {\n\t\tsuper(graphicsDevice);\n\t\tconst device = this.device;\n\t\tthis._forwardDrawCalls = 0;\n\t\tthis._materialSwitches = 0;\n\t\tthis._depthMapTime = 0;\n\t\tthis._forwardTime = 0;\n\t\tthis._sortTime = 0;\n\t\tconst scope = device.scope;\n\t\tthis.fogColorId = scope.resolve('fog_color');\n\t\tthis.fogStartId = scope.resolve('fog_start');\n\t\tthis.fogEndId = scope.resolve('fog_end');\n\t\tthis.fogDensityId = scope.resolve('fog_density');\n\t\tthis.ambientId = scope.resolve('light_globalAmbient');\n\t\tthis.skyboxIntensityId = scope.resolve('skyboxIntensity');\n\t\tthis.cubeMapRotationMatrixId = scope.resolve('cubeMapRotationMatrix');\n\t\tthis.pcssDiskSamplesId = scope.resolve('pcssDiskSamples[0]');\n\t\tthis.pcssSphereSamplesId = scope.resolve('pcssSphereSamples[0]');\n\t\tthis.lightColorId = [];\n\t\tthis.lightDir = [];\n\t\tthis.lightDirId = [];\n\t\tthis.lightShadowMapId = [];\n\t\tthis.lightShadowMatrixId = [];\n\t\tthis.lightShadowParamsId = [];\n\t\tthis.lightShadowIntensity = [];\n\t\tthis.lightRadiusId = [];\n\t\tthis.lightPos = [];\n\t\tthis.lightPosId = [];\n\t\tthis.lightWidth = [];\n\t\tthis.lightWidthId = [];\n\t\tthis.lightHeight = [];\n\t\tthis.lightHeightId = [];\n\t\tthis.lightInAngleId = [];\n\t\tthis.lightOutAngleId = [];\n\t\tthis.lightCookieId = [];\n\t\tthis.lightCookieIntId = [];\n\t\tthis.lightCookieMatrixId = [];\n\t\tthis.lightCookieOffsetId = [];\n\t\tthis.lightShadowSearchAreaId = [];\n\t\tthis.lightCameraParamsId = [];\n\t\tthis.shadowMatrixPaletteId = [];\n\t\tthis.shadowCascadeDistancesId = [];\n\t\tthis.shadowCascadeCountId = [];\n\t\tthis.screenSizeId = scope.resolve('uScreenSize');\n\t\tthis._screenSize = new Float32Array(4);\n\t\tthis.fogColor = new Float32Array(3);\n\t\tthis.ambientColor = new Float32Array(3);\n\t\tthis.pcssDiskSamples = vogelDiskPrecalculationSamples(16);\n\t\tthis.pcssSphereSamples = vogelSpherePrecalculationSamples(16);\n\t}\n\tdestroy() {\n\t\tsuper.destroy();\n\t}\n\tdispatchGlobalLights(scene) {\n\t\tthis.ambientColor[0] = scene.ambientLight.r;\n\t\tthis.ambientColor[1] = scene.ambientLight.g;\n\t\tthis.ambientColor[2] = scene.ambientLight.b;\n\t\tif (scene.gammaCorrection) {\n\t\t\tfor (let i = 0; i < 3; i++) {\n\t\t\t\tthis.ambientColor[i] = Math.pow(this.ambientColor[i], 2.2);\n\t\t\t}\n\t\t}\n\t\tif (scene.physicalUnits) {\n\t\t\tfor (let i = 0; i < 3; i++) {\n\t\t\t\tthis.ambientColor[i] *= scene.ambientLuminance;\n\t\t\t}\n\t\t}\n\t\tthis.ambientId.setValue(this.ambientColor);\n\t\tthis.skyboxIntensityId.setValue(scene.physicalUnits ? scene.skyboxLuminance : scene.skyboxIntensity);\n\t\tthis.cubeMapRotationMatrixId.setValue(scene._skyboxRotationMat3.data);\n\t}\n\t_resolveLight(scope, i) {\n\t\tconst light = 'light' + i;\n\t\tthis.lightColorId[i] = scope.resolve(light + '_color');\n\t\tthis.lightDir[i] = new Float32Array(3);\n\t\tthis.lightDirId[i] = scope.resolve(light + '_direction');\n\t\tthis.lightShadowMapId[i] = scope.resolve(light + '_shadowMap');\n\t\tthis.lightShadowMatrixId[i] = scope.resolve(light + '_shadowMatrix');\n\t\tthis.lightShadowParamsId[i] = scope.resolve(light + '_shadowParams');\n\t\tthis.lightShadowIntensity[i] = scope.resolve(light + '_shadowIntensity');\n\t\tthis.lightShadowSearchAreaId[i] = scope.resolve(light + '_shadowSearchArea');\n\t\tthis.lightRadiusId[i] = scope.resolve(light + '_radius');\n\t\tthis.lightPos[i] = new Float32Array(3);\n\t\tthis.lightPosId[i] = scope.resolve(light + '_position');\n\t\tthis.lightWidth[i] = new Float32Array(3);\n\t\tthis.lightWidthId[i] = scope.resolve(light + '_halfWidth');\n\t\tthis.lightHeight[i] = new Float32Array(3);\n\t\tthis.lightHeightId[i] = scope.resolve(light + '_halfHeight');\n\t\tthis.lightInAngleId[i] = scope.resolve(light + '_innerConeAngle');\n\t\tthis.lightOutAngleId[i] = scope.resolve(light + '_outerConeAngle');\n\t\tthis.lightCookieId[i] = scope.resolve(light + '_cookie');\n\t\tthis.lightCookieIntId[i] = scope.resolve(light + '_cookieIntensity');\n\t\tthis.lightCookieMatrixId[i] = scope.resolve(light + '_cookieMatrix');\n\t\tthis.lightCookieOffsetId[i] = scope.resolve(light + '_cookieOffset');\n\t\tthis.lightCameraParamsId[i] = scope.resolve(light + '_cameraParams');\n\t\tthis.shadowMatrixPaletteId[i] = scope.resolve(light + '_shadowMatrixPalette[0]');\n\t\tthis.shadowCascadeDistancesId[i] = scope.resolve(light + '_shadowCascadeDistances[0]');\n\t\tthis.shadowCascadeCountId[i] = scope.resolve(light + '_shadowCascadeCount');\n\t}\n\tsetLTCDirectionalLight(wtm, cnt, dir, campos, far) {\n\t\tthis.lightPos[cnt][0] = campos.x - dir.x * far;\n\t\tthis.lightPos[cnt][1] = campos.y - dir.y * far;\n\t\tthis.lightPos[cnt][2] = campos.z - dir.z * far;\n\t\tthis.lightPosId[cnt].setValue(this.lightPos[cnt]);\n\t\tconst hWidth = wtm.transformVector(new Vec3(-0.5, 0, 0));\n\t\tthis.lightWidth[cnt][0] = hWidth.x * far;\n\t\tthis.lightWidth[cnt][1] = hWidth.y * far;\n\t\tthis.lightWidth[cnt][2] = hWidth.z * far;\n\t\tthis.lightWidthId[cnt].setValue(this.lightWidth[cnt]);\n\t\tconst hHeight = wtm.transformVector(new Vec3(0, 0, 0.5));\n\t\tthis.lightHeight[cnt][0] = hHeight.x * far;\n\t\tthis.lightHeight[cnt][1] = hHeight.y * far;\n\t\tthis.lightHeight[cnt][2] = hHeight.z * far;\n\t\tthis.lightHeightId[cnt].setValue(this.lightHeight[cnt]);\n\t}\n\tdispatchDirectLights(dirs, scene, mask, camera) {\n\t\tlet cnt = 0;\n\t\tconst scope = this.device.scope;\n\t\tfor (let i = 0; i < dirs.length; i++) {\n\t\t\tif (!(dirs[i].mask & mask)) continue;\n\t\t\tconst directional = dirs[i];\n\t\t\tconst wtm = directional._node.getWorldTransform();\n\t\t\tif (!this.lightColorId[cnt]) {\n\t\t\t\tthis._resolveLight(scope, cnt);\n\t\t\t}\n\t\t\tthis.lightColorId[cnt].setValue(scene.gammaCorrection ? directional._linearFinalColor : directional._finalColor);\n\t\t\twtm.getY(directional._direction).mulScalar(-1);\n\t\t\tdirectional._direction.normalize();\n\t\t\tthis.lightDir[cnt][0] = directional._direction.x;\n\t\t\tthis.lightDir[cnt][1] = directional._direction.y;\n\t\t\tthis.lightDir[cnt][2] = directional._direction.z;\n\t\t\tthis.lightDirId[cnt].setValue(this.lightDir[cnt]);\n\t\t\tif (directional.shape !== LIGHTSHAPE_PUNCTUAL) {\n\t\t\t\tthis.setLTCDirectionalLight(wtm, cnt, directional._direction, camera._node.getPosition(), camera.farClip);\n\t\t\t}\n\t\t\tif (directional.castShadows) {\n\t\t\t\tconst lightRenderData = directional.getRenderData(camera, 0);\n\t\t\t\tconst biases = directional._getUniformBiasValues(lightRenderData);\n\t\t\t\tthis.lightShadowMapId[cnt].setValue(lightRenderData.shadowBuffer);\n\t\t\t\tthis.lightShadowMatrixId[cnt].setValue(lightRenderData.shadowMatrix.data);\n\t\t\t\tthis.shadowMatrixPaletteId[cnt].setValue(directional._shadowMatrixPalette);\n\t\t\t\tthis.shadowCascadeDistancesId[cnt].setValue(directional._shadowCascadeDistances);\n\t\t\t\tthis.shadowCascadeCountId[cnt].setValue(directional.numCascades);\n\t\t\t\tthis.lightShadowIntensity[cnt].setValue(directional.shadowIntensity);\n\t\t\t\tconst projectionCompensation = 50.0 / lightRenderData.projectionCompensation;\n\t\t\t\tconst pixelsPerMeter = directional.penumbraSize / lightRenderData.shadowCamera.renderTarget.width;\n\t\t\t\tthis.lightShadowSearchAreaId[cnt].setValue(pixelsPerMeter * projectionCompensation);\n\t\t\t\tconst cameraParams = directional._shadowCameraParams;\n\t\t\t\tcameraParams.length = 4;\n\t\t\t\tcameraParams[0] = lightRenderData.depthRangeCompensation;\n\t\t\t\tcameraParams[1] = lightRenderData.shadowCamera._farClip;\n\t\t\t\tcameraParams[2] = lightRenderData.shadowCamera._nearClip;\n\t\t\t\tcameraParams[3] = 1;\n\t\t\t\tthis.lightCameraParamsId[cnt].setValue(cameraParams);\n\t\t\t\tconst params = directional._shadowRenderParams;\n\t\t\t\tparams.length = 4;\n\t\t\t\tparams[0] = directional._shadowResolution;\n\t\t\t\tparams[1] = biases.normalBias;\n\t\t\t\tparams[2] = biases.bias;\n\t\t\t\tparams[3] = 0;\n\t\t\t\tthis.lightShadowParamsId[cnt].setValue(params);\n\t\t\t}\n\t\t\tcnt++;\n\t\t}\n\t\treturn cnt;\n\t}\n\tsetLTCPositionalLight(wtm, cnt) {\n\t\tconst hWidth = wtm.transformVector(new Vec3(-0.5, 0, 0));\n\t\tthis.lightWidth[cnt][0] = hWidth.x;\n\t\tthis.lightWidth[cnt][1] = hWidth.y;\n\t\tthis.lightWidth[cnt][2] = hWidth.z;\n\t\tthis.lightWidthId[cnt].setValue(this.lightWidth[cnt]);\n\t\tconst hHeight = wtm.transformVector(new Vec3(0, 0, 0.5));\n\t\tthis.lightHeight[cnt][0] = hHeight.x;\n\t\tthis.lightHeight[cnt][1] = hHeight.y;\n\t\tthis.lightHeight[cnt][2] = hHeight.z;\n\t\tthis.lightHeightId[cnt].setValue(this.lightHeight[cnt]);\n\t}\n\tdispatchOmniLight(scene, scope, omni, cnt) {\n\t\tconst wtm = omni._node.getWorldTransform();\n\t\tif (!this.lightColorId[cnt]) {\n\t\t\tthis._resolveLight(scope, cnt);\n\t\t}\n\t\tthis.lightRadiusId[cnt].setValue(omni.attenuationEnd);\n\t\tthis.lightColorId[cnt].setValue(scene.gammaCorrection ? omni._linearFinalColor : omni._finalColor);\n\t\twtm.getTranslation(omni._position);\n\t\tthis.lightPos[cnt][0] = omni._position.x;\n\t\tthis.lightPos[cnt][1] = omni._position.y;\n\t\tthis.lightPos[cnt][2] = omni._position.z;\n\t\tthis.lightPosId[cnt].setValue(this.lightPos[cnt]);\n\t\tif (omni.shape !== LIGHTSHAPE_PUNCTUAL) {\n\t\t\tthis.setLTCPositionalLight(wtm, cnt);\n\t\t}\n\t\tif (omni.castShadows) {\n\t\t\tconst lightRenderData = omni.getRenderData(null, 0);\n\t\t\tthis.lightShadowMapId[cnt].setValue(lightRenderData.shadowBuffer);\n\t\t\tconst biases = omni._getUniformBiasValues(lightRenderData);\n\t\t\tconst params = omni._shadowRenderParams;\n\t\t\tparams.length = 4;\n\t\t\tparams[0] = omni._shadowResolution;\n\t\t\tparams[1] = biases.normalBias;\n\t\t\tparams[2] = biases.bias;\n\t\t\tparams[3] = 1.0 / omni.attenuationEnd;\n\t\t\tthis.lightShadowParamsId[cnt].setValue(params);\n\t\t\tthis.lightShadowIntensity[cnt].setValue(omni.shadowIntensity);\n\t\t\tconst pixelsPerMeter = omni.penumbraSize / lightRenderData.shadowCamera.renderTarget.width;\n\t\t\tthis.lightShadowSearchAreaId[cnt].setValue(pixelsPerMeter);\n\t\t\tconst cameraParams = omni._shadowCameraParams;\n\t\t\tcameraParams.length = 4;\n\t\t\tcameraParams[0] = lightRenderData.depthRangeCompensation;\n\t\t\tcameraParams[1] = lightRenderData.shadowCamera._farClip;\n\t\t\tcameraParams[2] = lightRenderData.shadowCamera._nearClip;\n\t\t\tcameraParams[3] = 0;\n\t\t\tthis.lightCameraParamsId[cnt].setValue(cameraParams);\n\t\t}\n\t\tif (omni._cookie) {\n\t\t\tthis.lightCookieId[cnt].setValue(omni._cookie);\n\t\t\tthis.lightShadowMatrixId[cnt].setValue(wtm.data);\n\t\t\tthis.lightCookieIntId[cnt].setValue(omni.cookieIntensity);\n\t\t}\n\t}\n\tdispatchSpotLight(scene, scope, spot, cnt) {\n\t\tconst wtm = spot._node.getWorldTransform();\n\t\tif (!this.lightColorId[cnt]) {\n\t\t\tthis._resolveLight(scope, cnt);\n\t\t}\n\t\tthis.lightInAngleId[cnt].setValue(spot._innerConeAngleCos);\n\t\tthis.lightOutAngleId[cnt].setValue(spot._outerConeAngleCos);\n\t\tthis.lightRadiusId[cnt].setValue(spot.attenuationEnd);\n\t\tthis.lightColorId[cnt].setValue(scene.gammaCorrection ? spot._linearFinalColor : spot._finalColor);\n\t\twtm.getTranslation(spot._position);\n\t\tthis.lightPos[cnt][0] = spot._position.x;\n\t\tthis.lightPos[cnt][1] = spot._position.y;\n\t\tthis.lightPos[cnt][2] = spot._position.z;\n\t\tthis.lightPosId[cnt].setValue(this.lightPos[cnt]);\n\t\tif (spot.shape !== LIGHTSHAPE_PUNCTUAL) {\n\t\t\tthis.setLTCPositionalLight(wtm, cnt);\n\t\t}\n\t\twtm.getY(spot._direction).mulScalar(-1);\n\t\tspot._direction.normalize();\n\t\tthis.lightDir[cnt][0] = spot._direction.x;\n\t\tthis.lightDir[cnt][1] = spot._direction.y;\n\t\tthis.lightDir[cnt][2] = spot._direction.z;\n\t\tthis.lightDirId[cnt].setValue(this.lightDir[cnt]);\n\t\tif (spot.castShadows) {\n\t\t\tconst lightRenderData = spot.getRenderData(null, 0);\n\t\t\tthis.lightShadowMapId[cnt].setValue(lightRenderData.shadowBuffer);\n\t\t\tthis.lightShadowMatrixId[cnt].setValue(lightRenderData.shadowMatrix.data);\n\t\t\tconst biases = spot._getUniformBiasValues(lightRenderData);\n\t\t\tconst params = spot._shadowRenderParams;\n\t\t\tparams.length = 4;\n\t\t\tparams[0] = spot._shadowResolution;\n\t\t\tparams[1] = biases.normalBias;\n\t\t\tparams[2] = biases.bias;\n\t\t\tparams[3] = 1.0 / spot.attenuationEnd;\n\t\t\tthis.lightShadowParamsId[cnt].setValue(params);\n\t\t\tthis.lightShadowIntensity[cnt].setValue(spot.shadowIntensity);\n\t\t\tconst pixelsPerMeter = spot.penumbraSize / lightRenderData.shadowCamera.renderTarget.width;\n\t\t\tconst fov = lightRenderData.shadowCamera._fov * Math.PI / 180.0;\n\t\t\tconst fovRatio = 1.0 / Math.tan(fov / 2.0);\n\t\t\tthis.lightShadowSearchAreaId[cnt].setValue(pixelsPerMeter * fovRatio);\n\t\t\tconst cameraParams = spot._shadowCameraParams;\n\t\t\tcameraParams.length = 4;\n\t\t\tcameraParams[0] = lightRenderData.depthRangeCompensation;\n\t\t\tcameraParams[1] = lightRenderData.shadowCamera._farClip;\n\t\t\tcameraParams[2] = lightRenderData.shadowCamera._nearClip;\n\t\t\tcameraParams[3] = 0;\n\t\t\tthis.lightCameraParamsId[cnt].setValue(cameraParams);\n\t\t}\n\t\tif (spot._cookie) {\n\t\t\tif (!spot.castShadows) {\n\t\t\t\tconst cookieMatrix = LightCamera.evalSpotCookieMatrix(spot);\n\t\t\t\tthis.lightShadowMatrixId[cnt].setValue(cookieMatrix.data);\n\t\t\t}\n\t\t\tthis.lightCookieId[cnt].setValue(spot._cookie);\n\t\t\tthis.lightCookieIntId[cnt].setValue(spot.cookieIntensity);\n\t\t\tif (spot._cookieTransform) {\n\t\t\t\tspot._cookieTransformUniform[0] = spot._cookieTransform.x;\n\t\t\t\tspot._cookieTransformUniform[1] = spot._cookieTransform.y;\n\t\t\t\tspot._cookieTransformUniform[2] = spot._cookieTransform.z;\n\t\t\t\tspot._cookieTransformUniform[3] = spot._cookieTransform.w;\n\t\t\t\tthis.lightCookieMatrixId[cnt].setValue(spot._cookieTransformUniform);\n\t\t\t\tspot._cookieOffsetUniform[0] = spot._cookieOffset.x;\n\t\t\t\tspot._cookieOffsetUniform[1] = spot._cookieOffset.y;\n\t\t\t\tthis.lightCookieOffsetId[cnt].setValue(spot._cookieOffsetUniform);\n\t\t\t}\n\t\t}\n\t}\n\tdispatchLocalLights(sortedLights, scene, mask, usedDirLights) {\n\t\tlet cnt = usedDirLights;\n\t\tconst scope = this.device.scope;\n\t\tconst omnis = sortedLights[LIGHTTYPE_OMNI];\n\t\tconst numOmnis = omnis.length;\n\t\tfor (let i = 0; i < numOmnis; i++) {\n\t\t\tconst omni = omnis[i];\n\t\t\tif (!(omni.mask & mask)) continue;\n\t\t\tthis.dispatchOmniLight(scene, scope, omni, cnt);\n\t\t\tcnt++;\n\t\t}\n\t\tconst spts = sortedLights[LIGHTTYPE_SPOT];\n\t\tconst numSpts = spts.length;\n\t\tfor (let i = 0; i < numSpts; i++) {\n\t\t\tconst spot = spts[i];\n\t\t\tif (!(spot.mask & mask)) continue;\n\t\t\tthis.dispatchSpotLight(scene, scope, spot, cnt);\n\t\t\tcnt++;\n\t\t}\n\t}\n\trenderForwardPrepareMaterials(camera, drawCalls, sortedLights, layer, pass) {\n\t\tvar _layer$getLightHash;\n\t\tconst addCall = (drawCall, shaderInstance, isNewMaterial, lightMaskChanged) => {\n\t\t\t_drawCallList.drawCalls.push(drawCall);\n\t\t\t_drawCallList.shaderInstances.push(shaderInstance);\n\t\t\t_drawCallList.isNewMaterial.push(isNewMaterial);\n\t\t\t_drawCallList.lightMaskChanged.push(lightMaskChanged);\n\t\t};\n\t\t_drawCallList.clear();\n\t\tconst device = this.device;\n\t\tconst scene = this.scene;\n\t\tconst clusteredLightingEnabled = scene.clusteredLightingEnabled;\n\t\tconst lightHash = (_layer$getLightHash = layer == null ? void 0 : layer.getLightHash(clusteredLightingEnabled)) != null ? _layer$getLightHash : 0;\n\t\tlet prevMaterial = null,\n\t\t\tprevObjDefs,\n\t\t\tprevLightMask;\n\t\tconst drawCallsCount = drawCalls.length;\n\t\tfor (let i = 0; i < drawCallsCount; i++) {\n\t\t\tconst drawCall = drawCalls[i];\n\t\t\tdrawCall.ensureMaterial(device);\n\t\t\tconst material = drawCall.material;\n\t\t\tconst objDefs = drawCall._shaderDefs;\n\t\t\tconst lightMask = drawCall.mask;\n\t\t\tif (material && material === prevMaterial && objDefs !== prevObjDefs) {\n\t\t\t\tprevMaterial = null;\n\t\t\t}\n\t\t\tif (material !== prevMaterial) {\n\t\t\t\tthis._materialSwitches++;\n\t\t\t\tmaterial._scene = scene;\n\t\t\t\tif (material.dirty) {\n\t\t\t\t\tmaterial.updateUniforms(device, scene);\n\t\t\t\t\tmaterial.dirty = false;\n\t\t\t\t}\n\t\t\t}\n\t\t\tconst shaderInstance = drawCall.getShaderInstance(pass, lightHash, scene, this.viewUniformFormat, this.viewBindGroupFormat, sortedLights);\n\t\t\taddCall(drawCall, shaderInstance, material !== prevMaterial, !prevMaterial || lightMask !== prevLightMask);\n\t\t\tprevMaterial = material;\n\t\t\tprevObjDefs = objDefs;\n\t\t\tprevLightMask = lightMask;\n\t\t}\n\t\treturn _drawCallList;\n\t}\n\trenderForwardInternal(camera, preparedCalls, sortedLights, pass, drawCallback, flipFaces) {\n\t\tconst device = this.device;\n\t\tconst scene = this.scene;\n\t\tconst passFlag = 1 << pass;\n\t\tconst flipFactor = flipFaces ? -1 : 1;\n\t\tconst clusteredLightingEnabled = this.scene.clusteredLightingEnabled;\n\t\tconst preparedCallsCount = preparedCalls.drawCalls.length;\n\t\tfor (let i = 0; i < preparedCallsCount; i++) {\n\t\t\tvar _drawCall$stencilFron, _drawCall$stencilBack;\n\t\t\tconst drawCall = preparedCalls.drawCalls[i];\n\t\t\tconst newMaterial = preparedCalls.isNewMaterial[i];\n\t\t\tconst lightMaskChanged = preparedCalls.lightMaskChanged[i];\n\t\t\tconst shaderInstance = preparedCalls.shaderInstances[i];\n\t\t\tconst material = drawCall.material;\n\t\t\tconst lightMask = drawCall.mask;\n\t\t\tif (newMaterial) {\n\t\t\t\tconst asyncCompile = false;\n\t\t\t\tdevice.setShader(shaderInstance.shader, asyncCompile);\n\t\t\t\tmaterial.setParameters(device);\n\t\t\t\tif (lightMaskChanged) {\n\t\t\t\t\tconst usedDirLights = this.dispatchDirectLights(sortedLights[LIGHTTYPE_DIRECTIONAL], scene, lightMask, camera);\n\t\t\t\t\tif (!clusteredLightingEnabled) {\n\t\t\t\t\t\tthis.dispatchLocalLights(sortedLights, scene, lightMask, usedDirLights);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tthis.alphaTestId.setValue(material.alphaTest);\n\t\t\t\tdevice.setBlendState(material.blendState);\n\t\t\t\tdevice.setDepthState(material.depthState);\n\t\t\t\tdevice.setAlphaToCoverage(material.alphaToCoverage);\n\t\t\t}\n\t\t\tthis.setupCullMode(camera._cullFaces, flipFactor, drawCall);\n\t\t\tconst stencilFront = (_drawCall$stencilFron = drawCall.stencilFront) != null ? _drawCall$stencilFron : material.stencilFront;\n\t\t\tconst stencilBack = (_drawCall$stencilBack = drawCall.stencilBack) != null ? _drawCall$stencilBack : material.stencilBack;\n\t\t\tdevice.setStencilState(stencilFront, stencilBack);\n\t\t\tconst mesh = drawCall.mesh;\n\t\t\tdrawCall.setParameters(device, passFlag);\n\t\t\tthis.setVertexBuffers(device, mesh);\n\t\t\tthis.setMorphing(device, drawCall.morphInstance);\n\t\t\tthis.setSkinning(device, drawCall);\n\t\t\tthis.setupMeshUniformBuffers(shaderInstance, drawCall);\n\t\t\tconst style = drawCall.renderStyle;\n\t\t\tdevice.setIndexBuffer(mesh.indexBuffer[style]);\n\t\t\tdrawCallback == null || drawCallback(drawCall, i);\n\t\t\tif (camera.xr && camera.xr.session && camera.xr.views.list.length) {\n\t\t\t\tconst views = camera.xr.views;\n\t\t\t\tfor (let v = 0; v < views.list.length; v++) {\n\t\t\t\t\tconst view = views.list[v];\n\t\t\t\t\tdevice.setViewport(view.viewport.x, view.viewport.y, view.viewport.z, view.viewport.w);\n\t\t\t\t\tthis.projId.setValue(view.projMat.data);\n\t\t\t\t\tthis.projSkyboxId.setValue(view.projMat.data);\n\t\t\t\t\tthis.viewId.setValue(view.viewOffMat.data);\n\t\t\t\t\tthis.viewInvId.setValue(view.viewInvOffMat.data);\n\t\t\t\t\tthis.viewId3.setValue(view.viewMat3.data);\n\t\t\t\t\tthis.viewProjId.setValue(view.projViewOffMat.data);\n\t\t\t\t\tthis.viewPosId.setValue(view.positionData);\n\t\t\t\t\tthis.viewIndexId.setValue(v);\n\t\t\t\t\tif (v === 0) {\n\t\t\t\t\t\tthis.drawInstance(device, drawCall, mesh, style, true);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tthis.drawInstance2(device, drawCall, mesh, style);\n\t\t\t\t\t}\n\t\t\t\t\tthis._forwardDrawCalls++;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tthis.drawInstance(device, drawCall, mesh, style, true);\n\t\t\t\tthis._forwardDrawCalls++;\n\t\t\t}\n\t\t\tif (i < preparedCallsCount - 1 && !preparedCalls.isNewMaterial[i + 1]) {\n\t\t\t\tmaterial.setParameters(device, drawCall.parameters);\n\t\t\t}\n\t\t}\n\t}\n\trenderForward(camera, allDrawCalls, sortedLights, pass, drawCallback, layer, flipFaces) {\n\t\tconst preparedCalls = this.renderForwardPrepareMaterials(camera, allDrawCalls, sortedLights, layer, pass);\n\t\tthis.renderForwardInternal(camera, preparedCalls, sortedLights, pass, drawCallback, flipFaces);\n\t\t_drawCallList.clear();\n\t}\n\trenderForwardLayer(camera, renderTarget, layer, transparent, shaderPass, viewBindGroups, options = {}) {\n\t\tvar _options$clearColor, _options$clearDepth, _options$clearStencil;\n\t\tconst {\n\t\t\tscene,\n\t\t\tdevice\n\t\t} = this;\n\t\tconst clusteredLightingEnabled = scene.clusteredLightingEnabled;\n\t\tthis.setupViewport(camera, renderTarget);\n\t\tconst clearColor = (_options$clearColor = options.clearColor) != null ? _options$clearColor : false;\n\t\tconst clearDepth = (_options$clearDepth = options.clearDepth) != null ? _options$clearDepth : false;\n\t\tconst clearStencil = (_options$clearStencil = options.clearStencil) != null ? _options$clearStencil : false;\n\t\tif (clearColor || clearDepth || clearStencil) {\n\t\t\tthis.clear(camera, clearColor, clearDepth, clearStencil);\n\t\t}\n\t\tlet visible, splitLights;\n\t\tif (layer) {\n\t\t\tlayer.sortVisible(camera, transparent);\n\t\t\tconst culledInstances = layer.getCulledInstances(camera);\n\t\t\tvisible = transparent ? culledInstances.transparent : culledInstances.opaque;\n\t\t\tscene.immediate.onPreRenderLayer(layer, visible, transparent);\n\t\t\tif (layer.requiresLightCube) {\n\t\t\t\tthis.lightCube.update(scene.ambientLight, layer._lights);\n\t\t\t\tthis.constantLightCube.setValue(this.lightCube.colors);\n\t\t\t}\n\t\t\tsplitLights = layer.splitLights;\n\t\t} else {\n\t\t\tvar _options$splitLights;\n\t\t\tvisible = options.meshInstances;\n\t\t\tsplitLights = (_options$splitLights = options.splitLights) != null ? _options$splitLights : _noLights;\n\t\t}\n\t\tif (clusteredLightingEnabled) {\n\t\t\tvar _options$lightCluster;\n\t\t\tconst lightClusters = (_options$lightCluster = options.lightClusters) != null ? _options$lightCluster : this.worldClustersAllocator.empty;\n\t\t\tlightClusters.activate();\n\t\t\tif (layer) {\n\t\t\t\tif (!this.clustersDebugRendered && scene.lighting.debugLayer === layer.id) {\n\t\t\t\t\tthis.clustersDebugRendered = true;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tscene._activeCamera = camera;\n\t\tconst viewCount = this.setCameraUniforms(camera, renderTarget);\n\t\tif (device.supportsUniformBuffers) {\n\t\t\tthis.setupViewUniformBuffers(viewBindGroups, this.viewUniformFormat, this.viewBindGroupFormat, viewCount);\n\t\t}\n\t\tconst flipFaces = !!(camera._flipFaces ^ (renderTarget == null ? void 0 : renderTarget.flipY));\n\t\tconst forwardDrawCalls = this._forwardDrawCalls;\n\t\tthis.renderForward(camera, visible, splitLights, shaderPass, layer == null ? void 0 : layer.onDrawCall, layer, flipFaces);\n\t\tif (layer) layer._forwardDrawCalls += this._forwardDrawCalls - forwardDrawCalls;\n\t}\n\tsetSceneConstants() {\n\t\tconst scene = this.scene;\n\t\tthis.dispatchGlobalLights(scene);\n\t\tif (scene.fog !== FOG_NONE) {\n\t\t\tthis.fogColor[0] = scene.fogColor.r;\n\t\t\tthis.fogColor[1] = scene.fogColor.g;\n\t\t\tthis.fogColor[2] = scene.fogColor.b;\n\t\t\tif (scene.gammaCorrection) {\n\t\t\t\tfor (let i = 0; i < 3; i++) {\n\t\t\t\t\tthis.fogColor[i] = Math.pow(this.fogColor[i], 2.2);\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis.fogColorId.setValue(this.fogColor);\n\t\t\tif (scene.fog === FOG_LINEAR) {\n\t\t\t\tthis.fogStartId.setValue(scene.fogStart);\n\t\t\t\tthis.fogEndId.setValue(scene.fogEnd);\n\t\t\t} else {\n\t\t\t\tthis.fogDensityId.setValue(scene.fogDensity);\n\t\t\t}\n\t\t}\n\t\tconst device = this.device;\n\t\tthis._screenSize[0] = device.width;\n\t\tthis._screenSize[1] = device.height;\n\t\tthis._screenSize[2] = 1 / device.width;\n\t\tthis._screenSize[3] = 1 / device.height;\n\t\tthis.screenSizeId.setValue(this._screenSize);\n\t\tthis.pcssDiskSamplesId.setValue(this.pcssDiskSamples);\n\t\tthis.pcssSphereSamplesId.setValue(this.pcssSphereSamples);\n\t}\n\tbuildFrameGraph(frameGraph, layerComposition) {\n\t\tconst scene = this.scene;\n\t\tconst webgl1 = this.device.isWebGL1;\n\t\tframeGraph.reset();\n\t\tthis.update(layerComposition);\n\t\tif (scene.clusteredLightingEnabled) {\n\t\t\tconst {\n\t\t\t\tshadowsEnabled,\n\t\t\t\tcookiesEnabled\n\t\t\t} = scene.lighting;\n\t\t\tthis._renderPassUpdateClustered.update(frameGraph, shadowsEnabled, cookiesEnabled, this.lights, this.localLights);\n\t\t\tframeGraph.addRenderPass(this._renderPassUpdateClustered);\n\t\t} else {\n\t\t\tthis._shadowRendererLocal.buildNonClusteredRenderPasses(frameGraph, this.localLights);\n\t\t}\n\t\tlet startIndex = 0;\n\t\tlet newStart = true;\n\t\tlet renderTarget = null;\n\t\tconst renderActions = layerComposition._renderActions;\n\t\tfor (let i = startIndex; i < renderActions.length; i++) {\n\t\t\tconst renderAction = renderActions[i];\n\t\t\tconst {\n\t\t\t\tlayer,\n\t\t\t\tcamera\n\t\t\t} = renderAction;\n\t\t\tif (renderAction.useCameraPasses) {\n\t\t\t\tcamera.camera.renderPasses.forEach(renderPass => {\n\t\t\t\t\tframeGraph.addRenderPass(renderPass);\n\t\t\t\t});\n\t\t\t} else {\n\t\t\t\tconst depthPass = camera.camera.renderPassDepthGrab;\n\t\t\t\tif (depthPass && webgl1 && renderAction.firstCameraUse) {\n\t\t\t\t\tdepthPass.options.resizeSource = camera.camera.renderTarget;\n\t\t\t\t\tdepthPass.update(this.scene);\n\t\t\t\t\tframeGraph.addRenderPass(depthPass);\n\t\t\t\t}\n\t\t\t\tconst isDepthLayer = layer.id === LAYERID_DEPTH;\n\t\t\t\tif (webgl1 && isDepthLayer && !camera.renderSceneColorMap) continue;\n\t\t\t\tconst isGrabPass = isDepthLayer && (camera.renderSceneColorMap || camera.renderSceneDepthMap);\n\t\t\t\tif (newStart) {\n\t\t\t\t\tnewStart = false;\n\t\t\t\t\tstartIndex = i;\n\t\t\t\t\trenderTarget = renderAction.renderTarget;\n\t\t\t\t}\n\t\t\t\tconst nextRenderAction = renderActions[i + 1];\n\t\t\t\tconst isNextLayerDepth = nextRenderAction ? nextRenderAction.layer.id === LAYERID_DEPTH : false;\n\t\t\t\tconst isNextLayerGrabPass = isNextLayerDepth && (camera.renderSceneColorMap || camera.renderSceneDepthMap) && !webgl1;\n\t\t\t\tconst nextNeedDirShadows = nextRenderAction ? nextRenderAction.firstCameraUse && this.cameraDirShadowLights.has(nextRenderAction.camera.camera) : false;\n\t\t\t\tif (!nextRenderAction || nextRenderAction.renderTarget !== renderTarget || nextNeedDirShadows || isNextLayerGrabPass || isGrabPass) {\n\t\t\t\t\tconst isDepthOnly = isDepthLayer && startIndex === i;\n\t\t\t\t\tif (!isDepthOnly) {\n\t\t\t\t\t\tthis.addMainRenderPass(frameGraph, layerComposition, renderTarget, startIndex, i);\n\t\t\t\t\t}\n\t\t\t\t\tif (isDepthLayer) {\n\t\t\t\t\t\tif (camera.renderSceneColorMap) {\n\t\t\t\t\t\t\tconst colorGrabPass = camera.camera.renderPassColorGrab;\n\t\t\t\t\t\t\tcolorGrabPass.source = camera.renderTarget;\n\t\t\t\t\t\t\tframeGraph.addRenderPass(colorGrabPass);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (camera.renderSceneDepthMap && !webgl1) {\n\t\t\t\t\t\t\tframeGraph.addRenderPass(camera.camera.renderPassDepthGrab);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif (renderAction.triggerPostprocess && camera != null && camera.onPostprocessing) {\n\t\t\t\t\t\tconst renderPass = new RenderPassPostprocessing(this.device, this, renderAction);\n\t\t\t\t\t\tframeGraph.addRenderPass(renderPass);\n\t\t\t\t\t}\n\t\t\t\t\tnewStart = true;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\taddMainRenderPass(frameGraph, layerComposition, renderTarget, startIndex, endIndex) {\n\t\tconst renderPass = new RenderPassForward(this.device, layerComposition, this.scene, this);\n\t\trenderPass.init(renderTarget);\n\t\tconst renderActions = layerComposition._renderActions;\n\t\tfor (let i = startIndex; i <= endIndex; i++) {\n\t\t\trenderPass.addRenderAction(renderActions[i]);\n\t\t}\n\t\tframeGraph.addRenderPass(renderPass);\n\t}\n\tupdate(comp) {\n\t\tthis.frameUpdate();\n\t\tthis.shadowRenderer.frameUpdate();\n\t\tthis.scene._updateSkyMesh();\n\t\tthis.updateLayerComposition(comp);\n\t\tthis.collectLights(comp);\n\t\tthis.beginFrame(comp);\n\t\tthis.setSceneConstants();\n\t\tthis.cullComposition(comp);\n\t\tthis.gpuUpdate(this.processingMeshInstances);\n\t}\n}\n\nexport { ForwardRenderer };\n", "import { hash32Fnv1a } from '../core/hash.js';\nimport { SORTMODE_MATERIALMESH, SORTMODE_BACK2FRONT, SHADER_FORWARD, LIGHTTYPE_DIRECTIONAL, LAYER_FX, SORTMODE_NONE, SORTMODE_CUSTOM, SORTMODE_FRONT2BACK, SORTKEY_FORWARD } from './constants.js';\nimport { Material } from './materials/material.js';\n\nfunction sortManual(drawCallA, drawCallB) {\n\treturn drawCallA.drawOrder - drawCallB.drawOrder;\n}\nfunction sortMaterialMesh(drawCallA, drawCallB) {\n\tconst keyA = drawCallA._key[SORTKEY_FORWARD];\n\tconst keyB = drawCallB._key[SORTKEY_FORWARD];\n\tif (keyA === keyB && drawCallA.mesh && drawCallB.mesh) {\n\t\treturn drawCallB.mesh.id - drawCallA.mesh.id;\n\t}\n\treturn keyB - keyA;\n}\nfunction sortBackToFront(drawCallA, drawCallB) {\n\treturn drawCallB.zdist - drawCallA.zdist;\n}\nfunction sortFrontToBack(drawCallA, drawCallB) {\n\treturn drawCallA.zdist - drawCallB.zdist;\n}\nconst sortCallbacks = [null, sortManual, sortMaterialMesh, sortBackToFront, sortFrontToBack];\nlet layerCounter = 0;\nconst lightKeys = [];\nconst _tempMaterials = new Set();\nclass CulledInstances {\n\tconstructor() {\n\t\tthis.opaque = [];\n\t\tthis.transparent = [];\n\t}\n}\nclass Layer {\n\tconstructor(options = {}) {\n\t\tvar _options$enabled, _options$opaqueSortMo, _options$transparentS, _options$shaderPass;\n\t\tthis.meshInstances = [];\n\t\tthis.meshInstancesSet = new Set();\n\t\tthis.shadowCasters = [];\n\t\tthis.shadowCastersSet = new Set();\n\t\tthis._visibleInstances = new WeakMap();\n\t\tthis._lights = [];\n\t\tthis._lightsSet = new Set();\n\t\tthis._clusteredLightsSet = new Set();\n\t\tthis._splitLights = [[], [], []];\n\t\tthis._splitLightsDirty = true;\n\t\tthis.requiresLightCube = false;\n\t\tthis.cameras = [];\n\t\tthis.camerasSet = new Set();\n\t\tthis._dirtyComposition = false;\n\t\tif (options.id !== undefined) {\n\t\t\tthis.id = options.id;\n\t\t\tlayerCounter = Math.max(this.id + 1, layerCounter);\n\t\t} else {\n\t\t\tthis.id = layerCounter++;\n\t\t}\n\t\tthis.name = options.name;\n\t\tthis._enabled = (_options$enabled = options.enabled) != null ? _options$enabled : true;\n\t\tthis._refCounter = this._enabled ? 1 : 0;\n\t\tthis.opaqueSortMode = (_options$opaqueSortMo = options.opaqueSortMode) != null ? _options$opaqueSortMo : SORTMODE_MATERIALMESH;\n\t\tthis.transparentSortMode = (_options$transparentS = options.transparentSortMode) != null ? _options$transparentS : SORTMODE_BACK2FRONT;\n\t\tif (options.renderTarget) {\n\t\t\tthis.renderTarget = options.renderTarget;\n\t\t}\n\t\tthis.shaderPass = (_options$shaderPass = options.shaderPass) != null ? _options$shaderPass : SHADER_FORWARD;\n\t\tthis._clearColorBuffer = !!options.clearColorBuffer;\n\t\tthis._clearDepthBuffer = !!options.clearDepthBuffer;\n\t\tthis._clearStencilBuffer = !!options.clearStencilBuffer;\n\t\tthis.onPreCull = options.onPreCull;\n\t\tthis.onPreRender = options.onPreRender;\n\t\tthis.onPreRenderOpaque = options.onPreRenderOpaque;\n\t\tthis.onPreRenderTransparent = options.onPreRenderTransparent;\n\t\tthis.onPostCull = options.onPostCull;\n\t\tthis.onPostRender = options.onPostRender;\n\t\tthis.onPostRenderOpaque = options.onPostRenderOpaque;\n\t\tthis.onPostRenderTransparent = options.onPostRenderTransparent;\n\t\tthis.onDrawCall = options.onDrawCall;\n\t\tthis.onEnable = options.onEnable;\n\t\tthis.onDisable = options.onDisable;\n\t\tif (this._enabled && this.onEnable) {\n\t\t\tthis.onEnable();\n\t\t}\n\t\tthis.layerReference = options.layerReference;\n\t\tthis.customSortCallback = null;\n\t\tthis.customCalculateSortValues = null;\n\t\tthis._lightHash = 0;\n\t\tthis._lightHashDirty = false;\n\t\tthis._lightIdHash = 0;\n\t\tthis._lightIdHashDirty = false;\n\t\tthis._shaderVersion = -1;\n\t}\n\tset enabled(val) {\n\t\tif (val !== this._enabled) {\n\t\t\tthis._dirtyComposition = true;\n\t\t\tthis._enabled = val;\n\t\t\tif (val) {\n\t\t\t\tthis.incrementCounter();\n\t\t\t\tif (this.onEnable) this.onEnable();\n\t\t\t} else {\n\t\t\t\tthis.decrementCounter();\n\t\t\t\tif (this.onDisable) this.onDisable();\n\t\t\t}\n\t\t}\n\t}\n\tget enabled() {\n\t\treturn this._enabled;\n\t}\n\tset clearColorBuffer(val) {\n\t\tthis._clearColorBuffer = val;\n\t\tthis._dirtyComposition = true;\n\t}\n\tget clearColorBuffer() {\n\t\treturn this._clearColorBuffer;\n\t}\n\tset clearDepthBuffer(val) {\n\t\tthis._clearDepthBuffer = val;\n\t\tthis._dirtyComposition = true;\n\t}\n\tget clearDepthBuffer() {\n\t\treturn this._clearDepthBuffer;\n\t}\n\tset clearStencilBuffer(val) {\n\t\tthis._clearStencilBuffer = val;\n\t\tthis._dirtyComposition = true;\n\t}\n\tget clearStencilBuffer() {\n\t\treturn this._clearStencilBuffer;\n\t}\n\tget hasClusteredLights() {\n\t\treturn this._clusteredLightsSet.size > 0;\n\t}\n\tget clusteredLightsSet() {\n\t\treturn this._clusteredLightsSet;\n\t}\n\tincrementCounter() {\n\t\tif (this._refCounter === 0) {\n\t\t\tthis._enabled = true;\n\t\t\tif (this.onEnable) this.onEnable();\n\t\t}\n\t\tthis._refCounter++;\n\t}\n\tdecrementCounter() {\n\t\tif (this._refCounter === 1) {\n\t\t\tthis._enabled = false;\n\t\t\tif (this.onDisable) this.onDisable();\n\t\t} else if (this._refCounter === 0) {\n\t\t\treturn;\n\t\t}\n\t\tthis._refCounter--;\n\t}\n\taddMeshInstances(meshInstances, skipShadowCasters) {\n\t\tconst destMeshInstances = this.meshInstances;\n\t\tconst destMeshInstancesSet = this.meshInstancesSet;\n\t\tfor (let i = 0; i < meshInstances.length; i++) {\n\t\t\tconst mi = meshInstances[i];\n\t\t\tif (!destMeshInstancesSet.has(mi)) {\n\t\t\t\tdestMeshInstances.push(mi);\n\t\t\t\tdestMeshInstancesSet.add(mi);\n\t\t\t\t_tempMaterials.add(mi.material);\n\t\t\t}\n\t\t}\n\t\tif (!skipShadowCasters) {\n\t\t\tthis.addShadowCasters(meshInstances);\n\t\t}\n\t\tif (_tempMaterials.size > 0) {\n\t\t\tconst sceneShaderVer = this._shaderVersion;\n\t\t\t_tempMaterials.forEach(mat => {\n\t\t\t\tif (sceneShaderVer >= 0 && mat._shaderVersion !== sceneShaderVer) {\n\t\t\t\t\tif (mat.getShaderVariant !== Material.prototype.getShaderVariant) {\n\t\t\t\t\t\tmat.clearVariants();\n\t\t\t\t\t}\n\t\t\t\t\tmat._shaderVersion = sceneShaderVer;\n\t\t\t\t}\n\t\t\t});\n\t\t\t_tempMaterials.clear();\n\t\t}\n\t}\n\tremoveMeshInstances(meshInstances, skipShadowCasters) {\n\t\tconst destMeshInstances = this.meshInstances;\n\t\tconst destMeshInstancesSet = this.meshInstancesSet;\n\t\tfor (let i = 0; i < meshInstances.length; i++) {\n\t\t\tconst mi = meshInstances[i];\n\t\t\tif (destMeshInstancesSet.has(mi)) {\n\t\t\t\tdestMeshInstancesSet.delete(mi);\n\t\t\t\tconst j = destMeshInstances.indexOf(mi);\n\t\t\t\tif (j >= 0) {\n\t\t\t\t\tdestMeshInstances.splice(j, 1);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (!skipShadowCasters) {\n\t\t\tthis.removeShadowCasters(meshInstances);\n\t\t}\n\t}\n\taddShadowCasters(meshInstances) {\n\t\tconst shadowCasters = this.shadowCasters;\n\t\tconst shadowCastersSet = this.shadowCastersSet;\n\t\tfor (let i = 0; i < meshInstances.length; i++) {\n\t\t\tconst mi = meshInstances[i];\n\t\t\tif (mi.castShadow && !shadowCastersSet.has(mi)) {\n\t\t\t\tshadowCastersSet.add(mi);\n\t\t\t\tshadowCasters.push(mi);\n\t\t\t}\n\t\t}\n\t}\n\tremoveShadowCasters(meshInstances) {\n\t\tconst shadowCasters = this.shadowCasters;\n\t\tconst shadowCastersSet = this.shadowCastersSet;\n\t\tfor (let i = 0; i < meshInstances.length; i++) {\n\t\t\tconst mi = meshInstances[i];\n\t\t\tif (shadowCastersSet.has(mi)) {\n\t\t\t\tshadowCastersSet.delete(mi);\n\t\t\t\tconst j = shadowCasters.indexOf(mi);\n\t\t\t\tif (j >= 0) {\n\t\t\t\t\tshadowCasters.splice(j, 1);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\tclearMeshInstances(skipShadowCasters = false) {\n\t\tthis.meshInstances.length = 0;\n\t\tthis.meshInstancesSet.clear();\n\t\tif (!skipShadowCasters) {\n\t\t\tthis.shadowCasters.length = 0;\n\t\t\tthis.shadowCastersSet.clear();\n\t\t}\n\t}\n\tmarkLightsDirty() {\n\t\tthis._lightHashDirty = true;\n\t\tthis._lightIdHashDirty = true;\n\t\tthis._splitLightsDirty = true;\n\t}\n\taddLight(light) {\n\t\tconst l = light.light;\n\t\tif (!this._lightsSet.has(l)) {\n\t\t\tthis._lightsSet.add(l);\n\t\t\tthis._lights.push(l);\n\t\t\tthis.markLightsDirty();\n\t\t}\n\t\tif (l.type !== LIGHTTYPE_DIRECTIONAL) {\n\t\t\tthis._clusteredLightsSet.add(l);\n\t\t}\n\t}\n\tremoveLight(light) {\n\t\tconst l = light.light;\n\t\tif (this._lightsSet.has(l)) {\n\t\t\tthis._lightsSet.delete(l);\n\t\t\tthis._lights.splice(this._lights.indexOf(l), 1);\n\t\t\tthis.markLightsDirty();\n\t\t}\n\t\tif (l.type !== LIGHTTYPE_DIRECTIONAL) {\n\t\t\tthis._clusteredLightsSet.delete(l);\n\t\t}\n\t}\n\tclearLights() {\n\t\tthis._lightsSet.forEach(light => light.removeLayer(this));\n\t\tthis._lightsSet.clear();\n\t\tthis._clusteredLightsSet.clear();\n\t\tthis._lights.length = 0;\n\t\tthis.markLightsDirty();\n\t}\n\tget splitLights() {\n\t\tif (this._splitLightsDirty) {\n\t\t\tthis._splitLightsDirty = false;\n\t\t\tconst splitLights = this._splitLights;\n\t\t\tfor (let i = 0; i < splitLights.length; i++) splitLights[i].length = 0;\n\t\t\tconst lights = this._lights;\n\t\t\tfor (let i = 0; i < lights.length; i++) {\n\t\t\t\tconst light = lights[i];\n\t\t\t\tif (light.enabled) {\n\t\t\t\t\tsplitLights[light._type].push(light);\n\t\t\t\t}\n\t\t\t}\n\t\t\tfor (let i = 0; i < splitLights.length; i++) splitLights[i].sort((a, b) => a.key - b.key);\n\t\t}\n\t\treturn this._splitLights;\n\t}\n\tevaluateLightHash(localLights, directionalLights, useIds) {\n\t\tlet hash = 0;\n\t\tconst lights = this._lights;\n\t\tfor (let i = 0; i < lights.length; i++) {\n\t\t\tconst isLocalLight = lights[i].type !== LIGHTTYPE_DIRECTIONAL;\n\t\t\tif (localLights && isLocalLight || directionalLights && !isLocalLight) {\n\t\t\t\tlightKeys.push(useIds ? lights[i].id : lights[i].key);\n\t\t\t}\n\t\t}\n\t\tif (lightKeys.length > 0) {\n\t\t\tlightKeys.sort();\n\t\t\thash = hash32Fnv1a(lightKeys);\n\t\t\tlightKeys.length = 0;\n\t\t}\n\t\treturn hash;\n\t}\n\tgetLightHash(isClustered) {\n\t\tif (this._lightHashDirty) {\n\t\t\tthis._lightHashDirty = false;\n\t\t\tthis._lightHash = this.evaluateLightHash(!isClustered, true, false);\n\t\t}\n\t\treturn this._lightHash;\n\t}\n\tgetLightIdHash() {\n\t\tif (this._lightIdHashDirty) {\n\t\t\tthis._lightIdHashDirty = false;\n\t\t\tthis._lightIdHash = this.evaluateLightHash(true, false, true);\n\t\t}\n\t\treturn this._lightIdHash;\n\t}\n\taddCamera(camera) {\n\t\tif (!this.camerasSet.has(camera.camera)) {\n\t\t\tthis.camerasSet.add(camera.camera);\n\t\t\tthis.cameras.push(camera);\n\t\t\tthis._dirtyComposition = true;\n\t\t}\n\t}\n\tremoveCamera(camera) {\n\t\tif (this.camerasSet.has(camera.camera)) {\n\t\t\tthis.camerasSet.delete(camera.camera);\n\t\t\tconst index = this.cameras.indexOf(camera);\n\t\t\tthis.cameras.splice(index, 1);\n\t\t\tthis._dirtyComposition = true;\n\t\t}\n\t}\n\tclearCameras() {\n\t\tthis.cameras.length = 0;\n\t\tthis.camerasSet.clear();\n\t\tthis._dirtyComposition = true;\n\t}\n\t_calculateSortDistances(drawCalls, drawCallsCount, camPos, camFwd) {\n\t\tfor (let i = 0; i < drawCallsCount; i++) {\n\t\t\tconst drawCall = drawCalls[i];\n\t\t\tif (drawCall.layer <= LAYER_FX) continue;\n\t\t\tif (drawCall.calculateSortDistance) {\n\t\t\t\tdrawCall.zdist = drawCall.calculateSortDistance(drawCall, camPos, camFwd);\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tconst meshPos = drawCall.aabb.center;\n\t\t\tconst tempx = meshPos.x - camPos.x;\n\t\t\tconst tempy = meshPos.y - camPos.y;\n\t\t\tconst tempz = meshPos.z - camPos.z;\n\t\t\tdrawCall.zdist = tempx * camFwd.x + tempy * camFwd.y + tempz * camFwd.z;\n\t\t}\n\t}\n\tgetCulledInstances(camera) {\n\t\tlet instances = this._visibleInstances.get(camera);\n\t\tif (!instances) {\n\t\t\tinstances = new CulledInstances();\n\t\t\tthis._visibleInstances.set(camera, instances);\n\t\t}\n\t\treturn instances;\n\t}\n\tsortVisible(camera, transparent) {\n\t\tconst sortMode = transparent ? this.transparentSortMode : this.opaqueSortMode;\n\t\tif (sortMode === SORTMODE_NONE) return;\n\t\tconst culledInstances = this.getCulledInstances(camera);\n\t\tconst instances = transparent ? culledInstances.transparent : culledInstances.opaque;\n\t\tconst cameraNode = camera.node;\n\t\tif (sortMode === SORTMODE_CUSTOM) {\n\t\t\tconst sortPos = cameraNode.getPosition();\n\t\t\tconst sortDir = cameraNode.forward;\n\t\t\tif (this.customCalculateSortValues) {\n\t\t\t\tthis.customCalculateSortValues(instances, instances.length, sortPos, sortDir);\n\t\t\t}\n\t\t\tif (this.customSortCallback) {\n\t\t\t\tinstances.sort(this.customSortCallback);\n\t\t\t}\n\t\t} else {\n\t\t\tif (sortMode === SORTMODE_BACK2FRONT || sortMode === SORTMODE_FRONT2BACK) {\n\t\t\t\tconst sortPos = cameraNode.getPosition();\n\t\t\t\tconst sortDir = cameraNode.forward;\n\t\t\t\tthis._calculateSortDistances(instances, instances.length, sortPos, sortDir);\n\t\t\t}\n\t\t\tinstances.sort(sortCallbacks[sortMode]);\n\t\t}\n\t}\n}\n\nexport { CulledInstances, Layer };\n", "const cmpPriority = (a, b) => a.priority - b.priority;\nconst sortPriority = arr => arr.sort(cmpPriority);\n\nexport { sortPriority };\n", "import { EventHandler } from '../../core/event-handler.js';\nimport { sortPriority } from '../../core/sort.js';\nimport { LAYERID_DEPTH } from '../constants.js';\nimport { RenderAction } from './render-action.js';\n\nclass LayerComposition extends EventHandler {\n\tconstructor(name = 'Untitled') {\n\t\tsuper();\n\t\tthis.layerList = [];\n\t\tthis.layerIdMap = new Map();\n\t\tthis.layerNameMap = new Map();\n\t\tthis.layerOpaqueIndexMap = new Map();\n\t\tthis.layerTransparentIndexMap = new Map();\n\t\tthis.subLayerList = [];\n\t\tthis.subLayerEnabled = [];\n\t\tthis.cameras = [];\n\t\tthis.camerasMap = new Map();\n\t\tthis._renderActions = [];\n\t\tthis._dirty = false;\n\t\tthis.name = name;\n\t\tthis._opaqueOrder = {};\n\t\tthis._transparentOrder = {};\n\t}\n\tdestroy() {\n\t\tthis.destroyRenderActions();\n\t}\n\tdestroyRenderActions() {\n\t\tthis._renderActions.forEach(ra => ra.destroy());\n\t\tthis._renderActions.length = 0;\n\t}\n\t_update() {\n\t\tconst len = this.layerList.length;\n\t\tif (!this._dirty) {\n\t\t\tfor (let i = 0; i < len; i++) {\n\t\t\t\tif (this.layerList[i]._dirtyComposition) {\n\t\t\t\t\tthis._dirty = true;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (this._dirty) {\n\t\t\tthis._dirty = false;\n\t\t\tthis.cameras.length = 0;\n\t\t\tfor (let i = 0; i < len; i++) {\n\t\t\t\tconst layer = this.layerList[i];\n\t\t\t\tlayer._dirtyComposition = false;\n\t\t\t\tfor (let j = 0; j < layer.cameras.length; j++) {\n\t\t\t\t\tconst camera = layer.cameras[j];\n\t\t\t\t\tconst index = this.cameras.indexOf(camera);\n\t\t\t\t\tif (index < 0) {\n\t\t\t\t\t\tthis.cameras.push(camera);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (this.cameras.length > 1) {\n\t\t\t\tsortPriority(this.cameras);\n\t\t\t}\n\t\t\tthis.camerasMap.clear();\n\t\t\tfor (let i = 0; i < this.cameras.length; i++) {\n\t\t\t\tthis.camerasMap.set(this.cameras[i], i);\n\t\t\t}\n\t\t\tlet renderActionCount = 0;\n\t\t\tthis.destroyRenderActions();\n\t\t\tfor (let i = 0; i < this.cameras.length; i++) {\n\t\t\t\tconst camera = this.cameras[i];\n\t\t\t\tif (camera.camera.renderPasses.length > 0) {\n\t\t\t\t\tthis.addDummyRenderAction(renderActionCount, camera);\n\t\t\t\t\trenderActionCount++;\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tlet cameraFirstRenderAction = true;\n\t\t\t\tconst cameraFirstRenderActionIndex = renderActionCount;\n\t\t\t\tlet lastRenderAction = null;\n\t\t\t\tlet postProcessMarked = false;\n\t\t\t\tfor (let j = 0; j < len; j++) {\n\t\t\t\t\tconst layer = this.layerList[j];\n\t\t\t\t\tconst isLayerEnabled = layer.enabled && this.subLayerEnabled[j];\n\t\t\t\t\tif (isLayerEnabled) {\n\t\t\t\t\t\tif (layer.cameras.length > 0) {\n\t\t\t\t\t\t\tif (camera.layers.indexOf(layer.id) >= 0) {\n\t\t\t\t\t\t\t\tif (!postProcessMarked && layer.id === camera.disablePostEffectsLayer) {\n\t\t\t\t\t\t\t\t\tpostProcessMarked = true;\n\t\t\t\t\t\t\t\t\tif (lastRenderAction) {\n\t\t\t\t\t\t\t\t\t\tlastRenderAction.triggerPostprocess = true;\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tconst isTransparent = this.subLayerList[j];\n\t\t\t\t\t\t\t\tlastRenderAction = this.addRenderAction(renderActionCount, layer, isTransparent, camera, cameraFirstRenderAction, postProcessMarked);\n\t\t\t\t\t\t\t\trenderActionCount++;\n\t\t\t\t\t\t\t\tcameraFirstRenderAction = false;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tif (cameraFirstRenderActionIndex < renderActionCount) {\n\t\t\t\t\tlastRenderAction.lastCameraUse = true;\n\t\t\t\t}\n\t\t\t\tif (!postProcessMarked && lastRenderAction) {\n\t\t\t\t\tlastRenderAction.triggerPostprocess = true;\n\t\t\t\t}\n\t\t\t\tif (camera.renderTarget && camera.postEffectsEnabled) {\n\t\t\t\t\tthis.propagateRenderTarget(cameraFirstRenderActionIndex - 1, camera);\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis._logRenderActions();\n\t\t}\n\t}\n\tgetNextRenderAction(renderActionIndex) {\n\t\tconst renderAction = new RenderAction();\n\t\tthis._renderActions.push(renderAction);\n\t\treturn renderAction;\n\t}\n\taddDummyRenderAction(renderActionIndex, camera) {\n\t\tconst renderAction = this.getNextRenderAction(renderActionIndex);\n\t\trenderAction.camera = camera;\n\t\trenderAction.useCameraPasses = true;\n\t}\n\taddRenderAction(renderActionIndex, layer, isTransparent, camera, cameraFirstRenderAction, postProcessMarked) {\n\t\tlet rt = layer.renderTarget;\n\t\tif (camera && camera.renderTarget) {\n\t\t\tif (layer.id !== LAYERID_DEPTH) {\n\t\t\t\trt = camera.renderTarget;\n\t\t\t}\n\t\t}\n\t\tlet used = false;\n\t\tconst renderActions = this._renderActions;\n\t\tfor (let i = renderActionIndex - 1; i >= 0; i--) {\n\t\t\tif (renderActions[i].camera === camera && renderActions[i].renderTarget === rt) {\n\t\t\t\tused = true;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\tif (postProcessMarked && camera.postEffectsEnabled) {\n\t\t\trt = null;\n\t\t}\n\t\tconst renderAction = this.getNextRenderAction(renderActionIndex);\n\t\trenderAction.triggerPostprocess = false;\n\t\trenderAction.layer = layer;\n\t\trenderAction.transparent = isTransparent;\n\t\trenderAction.camera = camera;\n\t\trenderAction.renderTarget = rt;\n\t\trenderAction.firstCameraUse = cameraFirstRenderAction;\n\t\trenderAction.lastCameraUse = false;\n\t\tconst needsCameraClear = cameraFirstRenderAction || !used;\n\t\tconst needsLayerClear = layer.clearColorBuffer || layer.clearDepthBuffer || layer.clearStencilBuffer;\n\t\tif (needsCameraClear || needsLayerClear) {\n\t\t\trenderAction.setupClears(needsCameraClear ? camera : undefined, layer);\n\t\t}\n\t\treturn renderAction;\n\t}\n\tpropagateRenderTarget(startIndex, fromCamera) {\n\t\tfor (let a = startIndex; a >= 0; a--) {\n\t\t\tconst ra = this._renderActions[a];\n\t\t\tconst layer = ra.layer;\n\t\t\tif (ra.renderTarget && layer.id !== LAYERID_DEPTH) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif (layer.id === LAYERID_DEPTH) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif (ra.useCameraPasses) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tconst thisCamera = ra == null ? void 0 : ra.camera.camera;\n\t\t\tif (thisCamera) {\n\t\t\t\tif (!fromCamera.camera.rect.equals(thisCamera.rect) || !fromCamera.camera.scissorRect.equals(thisCamera.scissorRect)) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\tra.renderTarget = fromCamera.renderTarget;\n\t\t}\n\t}\n\t_logRenderActions() {}\n\t_isLayerAdded(layer) {\n\t\tconst found = this.layerIdMap.get(layer.id) === layer;\n\t\treturn found;\n\t}\n\t_isSublayerAdded(layer, transparent) {\n\t\tconst map = transparent ? this.layerTransparentIndexMap : this.layerOpaqueIndexMap;\n\t\tif (map.get(layer) !== undefined) {\n\t\t\treturn true;\n\t\t}\n\t\treturn false;\n\t}\n\tpush(layer) {\n\t\tif (this._isLayerAdded(layer)) return;\n\t\tthis.layerList.push(layer);\n\t\tthis.layerList.push(layer);\n\t\tthis._opaqueOrder[layer.id] = this.subLayerList.push(false) - 1;\n\t\tthis._transparentOrder[layer.id] = this.subLayerList.push(true) - 1;\n\t\tthis.subLayerEnabled.push(true);\n\t\tthis.subLayerEnabled.push(true);\n\t\tthis._updateLayerMaps();\n\t\tthis._dirty = true;\n\t\tthis.fire('add', layer);\n\t}\n\tinsert(layer, index) {\n\t\tif (this._isLayerAdded(layer)) return;\n\t\tthis.layerList.splice(index, 0, layer, layer);\n\t\tthis.subLayerList.splice(index, 0, false, true);\n\t\tconst count = this.layerList.length;\n\t\tthis._updateOpaqueOrder(index, count - 1);\n\t\tthis._updateTransparentOrder(index, count - 1);\n\t\tthis.subLayerEnabled.splice(index, 0, true, true);\n\t\tthis._updateLayerMaps();\n\t\tthis._dirty = true;\n\t\tthis.fire('add', layer);\n\t}\n\tremove(layer) {\n\t\tlet id = this.layerList.indexOf(layer);\n\t\tdelete this._opaqueOrder[id];\n\t\tdelete this._transparentOrder[id];\n\t\twhile (id >= 0) {\n\t\t\tthis.layerList.splice(id, 1);\n\t\t\tthis.subLayerList.splice(id, 1);\n\t\t\tthis.subLayerEnabled.splice(id, 1);\n\t\t\tid = this.layerList.indexOf(layer);\n\t\t\tthis._dirty = true;\n\t\t\tthis.fire('remove', layer);\n\t\t}\n\t\tconst count = this.layerList.length;\n\t\tthis._updateOpaqueOrder(0, count - 1);\n\t\tthis._updateTransparentOrder(0, count - 1);\n\t\tthis._updateLayerMaps();\n\t}\n\tpushOpaque(layer) {\n\t\tif (this._isSublayerAdded(layer, false)) return;\n\t\tthis.layerList.push(layer);\n\t\tthis._opaqueOrder[layer.id] = this.subLayerList.push(false) - 1;\n\t\tthis.subLayerEnabled.push(true);\n\t\tthis._updateLayerMaps();\n\t\tthis._dirty = true;\n\t\tthis.fire('add', layer);\n\t}\n\tinsertOpaque(layer, index) {\n\t\tif (this._isSublayerAdded(layer, false)) return;\n\t\tthis.layerList.splice(index, 0, layer);\n\t\tthis.subLayerList.splice(index, 0, false);\n\t\tconst count = this.subLayerList.length;\n\t\tthis._updateOpaqueOrder(index, count - 1);\n\t\tthis.subLayerEnabled.splice(index, 0, true);\n\t\tthis._updateLayerMaps();\n\t\tthis._dirty = true;\n\t\tthis.fire('add', layer);\n\t}\n\tremoveOpaque(layer) {\n\t\tfor (let i = 0, len = this.layerList.length; i < len; i++) {\n\t\t\tif (this.layerList[i] === layer && !this.subLayerList[i]) {\n\t\t\t\tthis.layerList.splice(i, 1);\n\t\t\t\tthis.subLayerList.splice(i, 1);\n\t\t\t\tlen--;\n\t\t\t\tthis._updateOpaqueOrder(i, len - 1);\n\t\t\t\tthis.subLayerEnabled.splice(i, 1);\n\t\t\t\tthis._dirty = true;\n\t\t\t\tif (this.layerList.indexOf(layer) < 0) {\n\t\t\t\t\tthis.fire('remove', layer);\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\tthis._updateLayerMaps();\n\t}\n\tpushTransparent(layer) {\n\t\tif (this._isSublayerAdded(layer, true)) return;\n\t\tthis.layerList.push(layer);\n\t\tthis._transparentOrder[layer.id] = this.subLayerList.push(true) - 1;\n\t\tthis.subLayerEnabled.push(true);\n\t\tthis._updateLayerMaps();\n\t\tthis._dirty = true;\n\t\tthis.fire('add', layer);\n\t}\n\tinsertTransparent(layer, index) {\n\t\tif (this._isSublayerAdded(layer, true)) return;\n\t\tthis.layerList.splice(index, 0, layer);\n\t\tthis.subLayerList.splice(index, 0, true);\n\t\tconst count = this.subLayerList.length;\n\t\tthis._updateTransparentOrder(index, count - 1);\n\t\tthis.subLayerEnabled.splice(index, 0, true);\n\t\tthis._updateLayerMaps();\n\t\tthis._dirty = true;\n\t\tthis.fire('add', layer);\n\t}\n\tremoveTransparent(layer) {\n\t\tfor (let i = 0, len = this.layerList.length; i < len; i++) {\n\t\t\tif (this.layerList[i] === layer && this.subLayerList[i]) {\n\t\t\t\tthis.layerList.splice(i, 1);\n\t\t\t\tthis.subLayerList.splice(i, 1);\n\t\t\t\tlen--;\n\t\t\t\tthis._updateTransparentOrder(i, len - 1);\n\t\t\t\tthis.subLayerEnabled.splice(i, 1);\n\t\t\t\tthis._dirty = true;\n\t\t\t\tif (this.layerList.indexOf(layer) < 0) {\n\t\t\t\t\tthis.fire('remove', layer);\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\tthis._updateLayerMaps();\n\t}\n\tgetOpaqueIndex(layer) {\n\t\tvar _this$layerOpaqueInde;\n\t\treturn (_this$layerOpaqueInde = this.layerOpaqueIndexMap.get(layer)) != null ? _this$layerOpaqueInde : -1;\n\t}\n\tgetTransparentIndex(layer) {\n\t\tvar _this$layerTransparen;\n\t\treturn (_this$layerTransparen = this.layerTransparentIndexMap.get(layer)) != null ? _this$layerTransparen : -1;\n\t}\n\tisEnabled(layer, transparent) {\n\t\tconst index = transparent ? this.getTransparentIndex(layer) : this.getOpaqueIndex(layer);\n\t\treturn this.subLayerEnabled[index];\n\t}\n\t_updateLayerMaps() {\n\t\tthis.layerIdMap.clear();\n\t\tthis.layerNameMap.clear();\n\t\tthis.layerOpaqueIndexMap.clear();\n\t\tthis.layerTransparentIndexMap.clear();\n\t\tfor (let i = 0; i < this.layerList.length; i++) {\n\t\t\tconst layer = this.layerList[i];\n\t\t\tthis.layerIdMap.set(layer.id, layer);\n\t\t\tthis.layerNameMap.set(layer.name, layer);\n\t\t\tconst subLayerIndexMap = this.subLayerList[i] ? this.layerTransparentIndexMap : this.layerOpaqueIndexMap;\n\t\t\tsubLayerIndexMap.set(layer, i);\n\t\t}\n\t}\n\tgetLayerById(id) {\n\t\tvar _this$layerIdMap$get;\n\t\treturn (_this$layerIdMap$get = this.layerIdMap.get(id)) != null ? _this$layerIdMap$get : null;\n\t}\n\tgetLayerByName(name) {\n\t\tvar _this$layerNameMap$ge;\n\t\treturn (_this$layerNameMap$ge = this.layerNameMap.get(name)) != null ? _this$layerNameMap$ge : null;\n\t}\n\t_updateOpaqueOrder(startIndex, endIndex) {\n\t\tfor (let i = startIndex; i <= endIndex; i++) {\n\t\t\tif (this.subLayerList[i] === false) {\n\t\t\t\tthis._opaqueOrder[this.layerList[i].id] = i;\n\t\t\t}\n\t\t}\n\t}\n\t_updateTransparentOrder(startIndex, endIndex) {\n\t\tfor (let i = startIndex; i <= endIndex; i++) {\n\t\t\tif (this.subLayerList[i] === true) {\n\t\t\t\tthis._transparentOrder[this.layerList[i].id] = i;\n\t\t\t}\n\t\t}\n\t}\n\t_sortLayersDescending(layersA, layersB, order) {\n\t\tlet topLayerA = -1;\n\t\tlet topLayerB = -1;\n\t\tfor (let i = 0, len = layersA.length; i < len; i++) {\n\t\t\tconst id = layersA[i];\n\t\t\tif (order.hasOwnProperty(id)) {\n\t\t\t\ttopLayerA = Math.max(topLayerA, order[id]);\n\t\t\t}\n\t\t}\n\t\tfor (let i = 0, len = layersB.length; i < len; i++) {\n\t\t\tconst id = layersB[i];\n\t\t\tif (order.hasOwnProperty(id)) {\n\t\t\t\ttopLayerB = Math.max(topLayerB, order[id]);\n\t\t\t}\n\t\t}\n\t\tif (topLayerA === -1 && topLayerB !== -1) {\n\t\t\treturn 1;\n\t\t} else if (topLayerB === -1 && topLayerA !== -1) {\n\t\t\treturn -1;\n\t\t}\n\t\treturn topLayerB - topLayerA;\n\t}\n\tsortTransparentLayers(layersA, layersB) {\n\t\treturn this._sortLayersDescending(layersA, layersB, this._transparentOrder);\n\t}\n\tsortOpaqueLayers(layersA, layersB) {\n\t\treturn this._sortLayersDescending(layersA, layersB, this._opaqueOrder);\n\t}\n}\n\nexport { LayerComposition };\n", "import { math } from '../core/math/math.js';\nimport { Color } from '../core/math/color.js';\nimport { Mat4 } from '../core/math/mat4.js';\nimport { Vec2 } from '../core/math/vec2.js';\nimport { Vec3 } from '../core/math/vec3.js';\nimport { Vec4 } from '../core/math/vec4.js';\nimport { LIGHTTYPE_DIRECTIONAL, MASK_AFFECT_DYNAMIC, LIGHTFALLOFF_LINEAR, SHADOW_PCF3, BLUR_GAUSSIAN, LIGHTSHAPE_PUNCTUAL, SHADOWUPDATE_REALTIME, LIGHTTYPE_OMNI, SHADOW_PCSS, SHADOW_PCF5, SHADOW_VSM32, SHADOW_VSM16, SHADOW_VSM8, SHADOW_PCF1, MASK_BAKE, SHADOWUPDATE_NONE, SHADOWUPDATE_THISFRAME, LIGHTTYPE_SPOT } from './constants.js';\nimport { ShadowRenderer } from './renderer/shadow-renderer.js';\nimport { DepthState } from '../platform/graphics/depth-state.js';\n\nconst tmpVec = new Vec3();\nconst tmpBiases = {\n\tbias: 0,\n\tnormalBias: 0\n};\nconst chanId = {\n\tr: 0,\n\tg: 1,\n\tb: 2,\n\ta: 3\n};\nconst lightTypes = {\n\t'directional': LIGHTTYPE_DIRECTIONAL,\n\t'omni': LIGHTTYPE_OMNI,\n\t'point': LIGHTTYPE_OMNI,\n\t'spot': LIGHTTYPE_SPOT\n};\nconst directionalCascades = [[new Vec4(0, 0, 1, 1)], [new Vec4(0, 0, 0.5, 0.5), new Vec4(0, 0.5, 0.5, 0.5)], [new Vec4(0, 0, 0.5, 0.5), new Vec4(0, 0.5, 0.5, 0.5), new Vec4(0.5, 0, 0.5, 0.5)], [new Vec4(0, 0, 0.5, 0.5), new Vec4(0, 0.5, 0.5, 0.5), new Vec4(0.5, 0, 0.5, 0.5), new Vec4(0.5, 0.5, 0.5, 0.5)]];\nlet id = 0;\nclass LightRenderData {\n\tconstructor(device, camera, face, light) {\n\t\tthis.light = light;\n\t\tthis.camera = camera;\n\t\tthis.shadowCamera = ShadowRenderer.createShadowCamera(device, light._shadowType, light._type, face);\n\t\tthis.shadowMatrix = new Mat4();\n\t\tthis.shadowViewport = new Vec4(0, 0, 1, 1);\n\t\tthis.shadowScissor = new Vec4(0, 0, 1, 1);\n\t\tthis.depthRangeCompensation = 0;\n\t\tthis.projectionCompensation = 0;\n\t\tthis.face = face;\n\t\tthis.visibleCasters = [];\n\t\tthis.viewBindGroups = [];\n\t}\n\tdestroy() {\n\t\tthis.viewBindGroups.forEach(bg => {\n\t\t\tbg.defaultUniformBuffer.destroy();\n\t\t\tbg.destroy();\n\t\t});\n\t\tthis.viewBindGroups.length = 0;\n\t}\n\tget shadowBuffer() {\n\t\tconst rt = this.shadowCamera.renderTarget;\n\t\tif (rt) {\n\t\t\tconst light = this.light;\n\t\t\tif (light._type === LIGHTTYPE_OMNI) {\n\t\t\t\treturn rt.colorBuffer;\n\t\t\t}\n\t\t\treturn light._isPcf && light.device.supportsDepthShadow ? rt.depthBuffer : rt.colorBuffer;\n\t\t}\n\t\treturn null;\n\t}\n}\nclass Light {\n\tconstructor(graphicsDevice, clusteredLighting) {\n\t\tthis.layers = new Set();\n\t\tthis.clusteredLighting = void 0;\n\t\tthis.shadowDepthState = DepthState.DEFAULT.clone();\n\t\tthis.device = graphicsDevice;\n\t\tthis.clusteredLighting = clusteredLighting;\n\t\tthis.id = id++;\n\t\tthis._type = LIGHTTYPE_DIRECTIONAL;\n\t\tthis._color = new Color(0.8, 0.8, 0.8);\n\t\tthis._intensity = 1;\n\t\tthis._affectSpecularity = true;\n\t\tthis._luminance = 0;\n\t\tthis._castShadows = false;\n\t\tthis._enabled = false;\n\t\tthis._mask = MASK_AFFECT_DYNAMIC;\n\t\tthis.isStatic = false;\n\t\tthis.key = 0;\n\t\tthis.bakeDir = true;\n\t\tthis.bakeNumSamples = 1;\n\t\tthis.bakeArea = 0;\n\t\tthis.attenuationStart = 10;\n\t\tthis.attenuationEnd = 10;\n\t\tthis._falloffMode = LIGHTFALLOFF_LINEAR;\n\t\tthis._shadowType = SHADOW_PCF3;\n\t\tthis._vsmBlurSize = 11;\n\t\tthis.vsmBlurMode = BLUR_GAUSSIAN;\n\t\tthis.vsmBias = 0.01 * 0.25;\n\t\tthis._cookie = null;\n\t\tthis.cookieIntensity = 1;\n\t\tthis._cookieFalloff = true;\n\t\tthis._cookieChannel = 'rgb';\n\t\tthis._cookieTransform = null;\n\t\tthis._cookieTransformUniform = new Float32Array(4);\n\t\tthis._cookieOffset = null;\n\t\tthis._cookieOffsetUniform = new Float32Array(2);\n\t\tthis._cookieTransformSet = false;\n\t\tthis._cookieOffsetSet = false;\n\t\tthis._innerConeAngle = 40;\n\t\tthis._outerConeAngle = 45;\n\t\tthis.cascades = null;\n\t\tthis._shadowMatrixPalette = null;\n\t\tthis._shadowCascadeDistances = null;\n\t\tthis.numCascades = 1;\n\t\tthis.cascadeDistribution = 0.5;\n\t\tthis._shape = LIGHTSHAPE_PUNCTUAL;\n\t\tthis._finalColor = new Float32Array([0.8, 0.8, 0.8]);\n\t\tconst c = Math.pow(this._finalColor[0], 2.2);\n\t\tthis._linearFinalColor = new Float32Array([c, c, c]);\n\t\tthis._position = new Vec3(0, 0, 0);\n\t\tthis._direction = new Vec3(0, 0, 0);\n\t\tthis._innerConeAngleCos = Math.cos(this._innerConeAngle * Math.PI / 180);\n\t\tthis._updateOuterAngle(this._outerConeAngle);\n\t\tthis._usePhysicalUnits = undefined;\n\t\tthis._shadowMap = null;\n\t\tthis._shadowRenderParams = [];\n\t\tthis._shadowCameraParams = [];\n\t\tthis.shadowDistance = 40;\n\t\tthis._shadowResolution = 1024;\n\t\tthis._shadowBias = -0.0005;\n\t\tthis.shadowIntensity = 1.0;\n\t\tthis._normalOffsetBias = 0.0;\n\t\tthis.shadowUpdateMode = SHADOWUPDATE_REALTIME;\n\t\tthis.shadowUpdateOverrides = null;\n\t\tthis._penumbraSize = 1.0;\n\t\tthis._isVsm = false;\n\t\tthis._isPcf = true;\n\t\tthis._cookieMatrix = null;\n\t\tthis._atlasViewport = null;\n\t\tthis.atlasViewportAllocated = false;\n\t\tthis.atlasVersion = 0;\n\t\tthis.atlasSlotIndex = 0;\n\t\tthis.atlasSlotUpdated = false;\n\t\tthis._node = null;\n\t\tthis._renderData = [];\n\t\tthis.visibleThisFrame = false;\n\t\tthis.maxScreenSize = 0;\n\t\tthis._updateShadowBias();\n\t}\n\tdestroy() {\n\t\tthis._destroyShadowMap();\n\t\tthis.releaseRenderData();\n\t\tthis._renderData = null;\n\t}\n\treleaseRenderData() {\n\t\tif (this._renderData) {\n\t\t\tfor (let i = 0; i < this._renderData.length; i++) {\n\t\t\t\tthis._renderData[i].destroy();\n\t\t\t}\n\t\t\tthis._renderData.length = 0;\n\t\t}\n\t}\n\taddLayer(layer) {\n\t\tthis.layers.add(layer);\n\t}\n\tremoveLayer(layer) {\n\t\tthis.layers.delete(layer);\n\t}\n\tset shadowBias(value) {\n\t\tif (this._shadowBias !== value) {\n\t\t\tthis._shadowBias = value;\n\t\t\tthis._updateShadowBias();\n\t\t}\n\t}\n\tget shadowBias() {\n\t\treturn this._shadowBias;\n\t}\n\tset numCascades(value) {\n\t\tif (!this.cascades || this.numCascades !== value) {\n\t\t\tthis.cascades = directionalCascades[value - 1];\n\t\t\tthis._shadowMatrixPalette = new Float32Array(4 * 16);\n\t\t\tthis._shadowCascadeDistances = new Float32Array(4);\n\t\t\tthis._destroyShadowMap();\n\t\t\tthis.updateKey();\n\t\t}\n\t}\n\tget numCascades() {\n\t\treturn this.cascades.length;\n\t}\n\tset shadowMap(shadowMap) {\n\t\tif (this._shadowMap !== shadowMap) {\n\t\t\tthis._destroyShadowMap();\n\t\t\tthis._shadowMap = shadowMap;\n\t\t}\n\t}\n\tget shadowMap() {\n\t\treturn this._shadowMap;\n\t}\n\tset mask(value) {\n\t\tif (this._mask !== value) {\n\t\t\tthis._mask = value;\n\t\t\tthis.updateKey();\n\t\t}\n\t}\n\tget mask() {\n\t\treturn this._mask;\n\t}\n\tget numShadowFaces() {\n\t\tconst type = this._type;\n\t\tif (type === LIGHTTYPE_DIRECTIONAL) {\n\t\t\treturn this.numCascades;\n\t\t} else if (type === LIGHTTYPE_OMNI) {\n\t\t\treturn 6;\n\t\t}\n\t\treturn 1;\n\t}\n\tset type(value) {\n\t\tif (this._type === value) return;\n\t\tthis._type = value;\n\t\tthis._destroyShadowMap();\n\t\tthis._updateShadowBias();\n\t\tthis.updateKey();\n\t\tconst stype = this._shadowType;\n\t\tthis._shadowType = null;\n\t\tthis.shadowUpdateOverrides = null;\n\t\tthis.shadowType = stype;\n\t}\n\tget type() {\n\t\treturn this._type;\n\t}\n\tset shape(value) {\n\t\tif (this._shape === value) return;\n\t\tthis._shape = value;\n\t\tthis._destroyShadowMap();\n\t\tthis.updateKey();\n\t\tconst stype = this._shadowType;\n\t\tthis._shadowType = null;\n\t\tthis.shadowType = stype;\n\t}\n\tget shape() {\n\t\treturn this._shape;\n\t}\n\tset usePhysicalUnits(value) {\n\t\tif (this._usePhysicalUnits !== value) {\n\t\t\tthis._usePhysicalUnits = value;\n\t\t\tthis._updateFinalColor();\n\t\t}\n\t}\n\tget usePhysicalUnits() {\n\t\treturn this._usePhysicalUnits;\n\t}\n\tset shadowType(value) {\n\t\tif (this._shadowType === value) return;\n\t\tconst device = this.device;\n\t\tif (this._type === LIGHTTYPE_OMNI && value !== SHADOW_PCF3 && value !== SHADOW_PCSS) value = SHADOW_PCF3;\n\t\tconst supportsDepthShadow = device.supportsDepthShadow;\n\t\tif (value === SHADOW_PCF5 && !supportsDepthShadow) {\n\t\t\tvalue = SHADOW_PCF3;\n\t\t}\n\t\tif (value === SHADOW_VSM32 && (!device.textureFloatRenderable || !device.textureFloatFilterable)) value = SHADOW_VSM16;\n\t\tif (value === SHADOW_VSM16 && !device.textureHalfFloatRenderable) value = SHADOW_VSM8;\n\t\tthis._isVsm = value >= SHADOW_VSM8 && value <= SHADOW_VSM32;\n\t\tthis._isPcf = value === SHADOW_PCF1 || value === SHADOW_PCF3 || value === SHADOW_PCF5;\n\t\tthis._shadowType = value;\n\t\tthis._destroyShadowMap();\n\t\tthis.updateKey();\n\t}\n\tget shadowType() {\n\t\treturn this._shadowType;\n\t}\n\tset enabled(value) {\n\t\tif (this._enabled !== value) {\n\t\t\tthis._enabled = value;\n\t\t\tthis.layersDirty();\n\t\t}\n\t}\n\tget enabled() {\n\t\treturn this._enabled;\n\t}\n\tset castShadows(value) {\n\t\tif (this._castShadows !== value) {\n\t\t\tthis._castShadows = value;\n\t\t\tthis._destroyShadowMap();\n\t\t\tthis.layersDirty();\n\t\t\tthis.updateKey();\n\t\t}\n\t}\n\tget castShadows() {\n\t\treturn this._castShadows && this._mask !== MASK_BAKE && this._mask !== 0;\n\t}\n\tset shadowResolution(value) {\n\t\tif (this._shadowResolution !== value) {\n\t\t\tif (this._type === LIGHTTYPE_OMNI) {\n\t\t\t\tvalue = Math.min(value, this.device.maxCubeMapSize);\n\t\t\t} else {\n\t\t\t\tvalue = Math.min(value, this.device.maxTextureSize);\n\t\t\t}\n\t\t\tthis._shadowResolution = value;\n\t\t\tthis._destroyShadowMap();\n\t\t}\n\t}\n\tget shadowResolution() {\n\t\treturn this._shadowResolution;\n\t}\n\tset vsmBlurSize(value) {\n\t\tif (this._vsmBlurSize === value) return;\n\t\tif (value % 2 === 0) value++;\n\t\tthis._vsmBlurSize = value;\n\t}\n\tget vsmBlurSize() {\n\t\treturn this._vsmBlurSize;\n\t}\n\tset normalOffsetBias(value) {\n\t\tif (this._normalOffsetBias === value) return;\n\t\tif (!this._normalOffsetBias && value || this._normalOffsetBias && !value) {\n\t\t\tthis.updateKey();\n\t\t}\n\t\tthis._normalOffsetBias = value;\n\t}\n\tget normalOffsetBias() {\n\t\treturn this._normalOffsetBias;\n\t}\n\tset falloffMode(value) {\n\t\tif (this._falloffMode === value) return;\n\t\tthis._falloffMode = value;\n\t\tthis.updateKey();\n\t}\n\tget falloffMode() {\n\t\treturn this._falloffMode;\n\t}\n\tset innerConeAngle(value) {\n\t\tif (this._innerConeAngle === value) return;\n\t\tthis._innerConeAngle = value;\n\t\tthis._innerConeAngleCos = Math.cos(value * Math.PI / 180);\n\t\tif (this._usePhysicalUnits) {\n\t\t\tthis._updateFinalColor();\n\t\t}\n\t}\n\tget innerConeAngle() {\n\t\treturn this._innerConeAngle;\n\t}\n\tset outerConeAngle(value) {\n\t\tif (this._outerConeAngle === value) return;\n\t\tthis._outerConeAngle = value;\n\t\tthis._updateOuterAngle(value);\n\t\tif (this._usePhysicalUnits) {\n\t\t\tthis._updateFinalColor();\n\t\t}\n\t}\n\tget outerConeAngle() {\n\t\treturn this._outerConeAngle;\n\t}\n\tset penumbraSize(value) {\n\t\tthis._penumbraSize = value;\n\t}\n\tget penumbraSize() {\n\t\treturn this._penumbraSize;\n\t}\n\t_updateOuterAngle(angle) {\n\t\tconst radAngle = angle * Math.PI / 180;\n\t\tthis._outerConeAngleCos = Math.cos(radAngle);\n\t\tthis._outerConeAngleSin = Math.sin(radAngle);\n\t}\n\tset intensity(value) {\n\t\tif (this._intensity !== value) {\n\t\t\tthis._intensity = value;\n\t\t\tthis._updateFinalColor();\n\t\t}\n\t}\n\tget intensity() {\n\t\treturn this._intensity;\n\t}\n\tset affectSpecularity(value) {\n\t\tif (this._type === LIGHTTYPE_DIRECTIONAL) {\n\t\t\tthis._affectSpecularity = value;\n\t\t\tthis.updateKey();\n\t\t}\n\t}\n\tget affectSpecularity() {\n\t\treturn this._affectSpecularity;\n\t}\n\tset luminance(value) {\n\t\tif (this._luminance !== value) {\n\t\t\tthis._luminance = value;\n\t\t\tthis._updateFinalColor();\n\t\t}\n\t}\n\tget luminance() {\n\t\treturn this._luminance;\n\t}\n\tget cookieMatrix() {\n\t\tif (!this._cookieMatrix) {\n\t\t\tthis._cookieMatrix = new Mat4();\n\t\t}\n\t\treturn this._cookieMatrix;\n\t}\n\tget atlasViewport() {\n\t\tif (!this._atlasViewport) {\n\t\t\tthis._atlasViewport = new Vec4(0, 0, 1, 1);\n\t\t}\n\t\treturn this._atlasViewport;\n\t}\n\tset cookie(value) {\n\t\tif (this._cookie === value) return;\n\t\tthis._cookie = value;\n\t\tthis.updateKey();\n\t}\n\tget cookie() {\n\t\treturn this._cookie;\n\t}\n\tset cookieFalloff(value) {\n\t\tif (this._cookieFalloff === value) return;\n\t\tthis._cookieFalloff = value;\n\t\tthis.updateKey();\n\t}\n\tget cookieFalloff() {\n\t\treturn this._cookieFalloff;\n\t}\n\tset cookieChannel(value) {\n\t\tif (this._cookieChannel === value) return;\n\t\tif (value.length < 3) {\n\t\t\tconst chr = value.charAt(value.length - 1);\n\t\t\tconst addLen = 3 - value.length;\n\t\t\tfor (let i = 0; i < addLen; i++) value += chr;\n\t\t}\n\t\tthis._cookieChannel = value;\n\t\tthis.updateKey();\n\t}\n\tget cookieChannel() {\n\t\treturn this._cookieChannel;\n\t}\n\tset cookieTransform(value) {\n\t\tif (this._cookieTransform === value) return;\n\t\tthis._cookieTransform = value;\n\t\tthis._cookieTransformSet = !!value;\n\t\tif (value && !this._cookieOffset) {\n\t\t\tthis.cookieOffset = new Vec2();\n\t\t\tthis._cookieOffsetSet = false;\n\t\t}\n\t\tthis.updateKey();\n\t}\n\tget cookieTransform() {\n\t\treturn this._cookieTransform;\n\t}\n\tset cookieOffset(value) {\n\t\tif (this._cookieOffset === value) return;\n\t\tconst xformNew = !!(this._cookieTransformSet || value);\n\t\tif (xformNew && !value && this._cookieOffset) {\n\t\t\tthis._cookieOffset.set(0, 0);\n\t\t} else {\n\t\t\tthis._cookieOffset = value;\n\t\t}\n\t\tthis._cookieOffsetSet = !!value;\n\t\tif (value && !this._cookieTransform) {\n\t\t\tthis.cookieTransform = new Vec4(1, 1, 0, 0);\n\t\t\tthis._cookieTransformSet = false;\n\t\t}\n\t\tthis.updateKey();\n\t}\n\tget cookieOffset() {\n\t\treturn this._cookieOffset;\n\t}\n\tbeginFrame() {\n\t\tthis.visibleThisFrame = this._type === LIGHTTYPE_DIRECTIONAL && this._enabled;\n\t\tthis.maxScreenSize = 0;\n\t\tthis.atlasViewportAllocated = false;\n\t\tthis.atlasSlotUpdated = false;\n\t}\n\t_destroyShadowMap() {\n\t\tthis.releaseRenderData();\n\t\tif (this._shadowMap) {\n\t\t\tif (!this._shadowMap.cached) {\n\t\t\t\tthis._shadowMap.destroy();\n\t\t\t}\n\t\t\tthis._shadowMap = null;\n\t\t}\n\t\tif (this.shadowUpdateMode === SHADOWUPDATE_NONE) {\n\t\t\tthis.shadowUpdateMode = SHADOWUPDATE_THISFRAME;\n\t\t}\n\t\tif (this.shadowUpdateOverrides) {\n\t\t\tfor (let i = 0; i < this.shadowUpdateOverrides.length; i++) {\n\t\t\t\tif (this.shadowUpdateOverrides[i] === SHADOWUPDATE_NONE) {\n\t\t\t\t\tthis.shadowUpdateOverrides[i] = SHADOWUPDATE_THISFRAME;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\tgetRenderData(camera, face) {\n\t\tfor (let i = 0; i < this._renderData.length; i++) {\n\t\t\tconst current = this._renderData[i];\n\t\t\tif (current.camera === camera && current.face === face) {\n\t\t\t\treturn current;\n\t\t\t}\n\t\t}\n\t\tconst rd = new LightRenderData(this.device, camera, face, this);\n\t\tthis._renderData.push(rd);\n\t\treturn rd;\n\t}\n\tclone() {\n\t\tconst clone = new Light(this.device, this.clusteredLighting);\n\t\tclone.type = this._type;\n\t\tclone.setColor(this._color);\n\t\tclone.intensity = this._intensity;\n\t\tclone.affectSpecularity = this._affectSpecularity;\n\t\tclone.luminance = this._luminance;\n\t\tclone.castShadows = this.castShadows;\n\t\tclone._enabled = this._enabled;\n\t\tclone.attenuationStart = this.attenuationStart;\n\t\tclone.attenuationEnd = this.attenuationEnd;\n\t\tclone.falloffMode = this._falloffMode;\n\t\tclone.shadowType = this._shadowType;\n\t\tclone.vsmBlurSize = this._vsmBlurSize;\n\t\tclone.vsmBlurMode = this.vsmBlurMode;\n\t\tclone.vsmBias = this.vsmBias;\n\t\tclone.penumbraSize = this.penumbraSize;\n\t\tclone.shadowUpdateMode = this.shadowUpdateMode;\n\t\tclone.mask = this.mask;\n\t\tif (this.shadowUpdateOverrides) {\n\t\t\tclone.shadowUpdateOverrides = this.shadowUpdateOverrides.slice();\n\t\t}\n\t\tclone.innerConeAngle = this._innerConeAngle;\n\t\tclone.outerConeAngle = this._outerConeAngle;\n\t\tclone.numCascades = this.numCascades;\n\t\tclone.cascadeDistribution = this.cascadeDistribution;\n\t\tclone.shape = this._shape;\n\t\tclone.shadowDepthState.copy(this.shadowDepthState);\n\t\tclone.shadowBias = this.shadowBias;\n\t\tclone.normalOffsetBias = this._normalOffsetBias;\n\t\tclone.shadowResolution = this._shadowResolution;\n\t\tclone.shadowDistance = this.shadowDistance;\n\t\tclone.shadowIntensity = this.shadowIntensity;\n\t\treturn clone;\n\t}\n\tstatic getLightUnitConversion(type, outerAngle = Math.PI / 4, innerAngle = 0) {\n\t\tswitch (type) {\n\t\t\tcase LIGHTTYPE_SPOT:\n\t\t\t\t{\n\t\t\t\t\tconst falloffEnd = Math.cos(outerAngle);\n\t\t\t\t\tconst falloffStart = Math.cos(innerAngle);\n\t\t\t\t\treturn 2 * Math.PI * (1 - falloffStart + (falloffStart - falloffEnd) / 2.0);\n\t\t\t\t}\n\t\t\tcase LIGHTTYPE_OMNI:\n\t\t\t\treturn 4 * Math.PI;\n\t\t\tcase LIGHTTYPE_DIRECTIONAL:\n\t\t\t\treturn 1;\n\t\t}\n\t}\n\t_getUniformBiasValues(lightRenderData) {\n\t\tconst farClip = lightRenderData.shadowCamera._farClip;\n\t\tswitch (this._type) {\n\t\t\tcase LIGHTTYPE_OMNI:\n\t\t\t\ttmpBiases.bias = this.shadowBias;\n\t\t\t\ttmpBiases.normalBias = this._normalOffsetBias;\n\t\t\t\tbreak;\n\t\t\tcase LIGHTTYPE_SPOT:\n\t\t\t\tif (this._isVsm) {\n\t\t\t\t\ttmpBiases.bias = -0.00001 * 20;\n\t\t\t\t} else {\n\t\t\t\t\ttmpBiases.bias = this.shadowBias * 20;\n\t\t\t\t\tif (this.device.isWebGL1 && this.device.extStandardDerivatives) tmpBiases.bias *= -100;\n\t\t\t\t}\n\t\t\t\ttmpBiases.normalBias = this._isVsm ? this.vsmBias / (this.attenuationEnd / 7.0) : this._normalOffsetBias;\n\t\t\t\tbreak;\n\t\t\tcase LIGHTTYPE_DIRECTIONAL:\n\t\t\t\tif (this._isVsm) {\n\t\t\t\t\ttmpBiases.bias = -0.00001 * 20;\n\t\t\t\t} else {\n\t\t\t\t\ttmpBiases.bias = this.shadowBias / farClip * 100;\n\t\t\t\t\tif (this.device.isWebGL1 && this.device.extStandardDerivatives) tmpBiases.bias *= -100;\n\t\t\t\t}\n\t\t\t\ttmpBiases.normalBias = this._isVsm ? this.vsmBias / (farClip / 7.0) : this._normalOffsetBias;\n\t\t\t\tbreak;\n\t\t}\n\t\treturn tmpBiases;\n\t}\n\tgetColor() {\n\t\treturn this._color;\n\t}\n\tgetBoundingSphere(sphere) {\n\t\tif (this._type === LIGHTTYPE_SPOT) {\n\t\t\tconst size = this.attenuationEnd;\n\t\t\tconst angle = this._outerConeAngle;\n\t\t\tconst cosAngle = this._outerConeAngleCos;\n\t\t\tconst node = this._node;\n\t\t\ttmpVec.copy(node.up);\n\t\t\tif (angle > 45) {\n\t\t\t\tsphere.radius = size * this._outerConeAngleSin;\n\t\t\t\ttmpVec.mulScalar(-size * cosAngle);\n\t\t\t} else {\n\t\t\t\tsphere.radius = size / (2 * cosAngle);\n\t\t\t\ttmpVec.mulScalar(-sphere.radius);\n\t\t\t}\n\t\t\tsphere.center.add2(node.getPosition(), tmpVec);\n\t\t} else if (this._type === LIGHTTYPE_OMNI) {\n\t\t\tsphere.center = this._node.getPosition();\n\t\t\tsphere.radius = this.attenuationEnd;\n\t\t}\n\t}\n\tgetBoundingBox(box) {\n\t\tif (this._type === LIGHTTYPE_SPOT) {\n\t\t\tconst range = this.attenuationEnd;\n\t\t\tconst angle = this._outerConeAngle;\n\t\t\tconst node = this._node;\n\t\t\tconst scl = Math.abs(Math.sin(angle * math.DEG_TO_RAD) * range);\n\t\t\tbox.center.set(0, -range * 0.5, 0);\n\t\t\tbox.halfExtents.set(scl, range * 0.5, scl);\n\t\t\tbox.setFromTransformedAabb(box, node.getWorldTransform(), true);\n\t\t} else if (this._type === LIGHTTYPE_OMNI) {\n\t\t\tbox.center.copy(this._node.getPosition());\n\t\t\tbox.halfExtents.set(this.attenuationEnd, this.attenuationEnd, this.attenuationEnd);\n\t\t}\n\t}\n\t_updateShadowBias() {\n\t\tconst device = this.device;\n\t\tif (device.isWebGL2 || device.isWebGPU) {\n\t\t\tif (this._type === LIGHTTYPE_OMNI && !this.clusteredLighting) {\n\t\t\t\tthis.shadowDepthState.depthBias = 0;\n\t\t\t\tthis.shadowDepthState.depthBiasSlope = 0;\n\t\t\t} else {\n\t\t\t\tconst bias = this.shadowBias * -1000.0;\n\t\t\t\tthis.shadowDepthState.depthBias = bias;\n\t\t\t\tthis.shadowDepthState.depthBiasSlope = bias;\n\t\t\t}\n\t\t}\n\t}\n\t_updateFinalColor() {\n\t\tconst color = this._color;\n\t\tconst r = color.r;\n\t\tconst g = color.g;\n\t\tconst b = color.b;\n\t\tlet i = this._intensity;\n\t\tif (this._usePhysicalUnits) {\n\t\t\ti = this._luminance / Light.getLightUnitConversion(this._type, this._outerConeAngle * math.DEG_TO_RAD, this._innerConeAngle * math.DEG_TO_RAD);\n\t\t}\n\t\tconst finalColor = this._finalColor;\n\t\tconst linearFinalColor = this._linearFinalColor;\n\t\tfinalColor[0] = r * i;\n\t\tfinalColor[1] = g * i;\n\t\tfinalColor[2] = b * i;\n\t\tif (i >= 1) {\n\t\t\tlinearFinalColor[0] = Math.pow(r, 2.2) * i;\n\t\t\tlinearFinalColor[1] = Math.pow(g, 2.2) * i;\n\t\t\tlinearFinalColor[2] = Math.pow(b, 2.2) * i;\n\t\t} else {\n\t\t\tlinearFinalColor[0] = Math.pow(finalColor[0], 2.2);\n\t\t\tlinearFinalColor[1] = Math.pow(finalColor[1], 2.2);\n\t\t\tlinearFinalColor[2] = Math.pow(finalColor[2], 2.2);\n\t\t}\n\t}\n\tsetColor() {\n\t\tif (arguments.length === 1) {\n\t\t\tthis._color.set(arguments[0].r, arguments[0].g, arguments[0].b);\n\t\t} else if (arguments.length === 3) {\n\t\t\tthis._color.set(arguments[0], arguments[1], arguments[2]);\n\t\t}\n\t\tthis._updateFinalColor();\n\t}\n\tlayersDirty() {\n\t\tthis.layers.forEach(layer => {\n\t\t\tlayer.markLightsDirty();\n\t\t});\n\t}\n\tupdateKey() {\n\t\tlet key = this._type << 29 | (this._castShadows ? 1 : 0) << 28 | this._shadowType << 25 | this._falloffMode << 23 | (this._normalOffsetBias !== 0.0 ? 1 : 0) << 22 | (this._cookie ? 1 : 0) << 21 | (this._cookieFalloff ? 1 : 0) << 20 | chanId[this._cookieChannel.charAt(0)] << 18 | (this._cookieTransform ? 1 : 0) << 12 | this._shape << 10 | this.numCascades - 1 << 8 | (this.affectSpecularity ? 1 : 0) << 7 | this.mask << 6;\n\t\tif (this._cookieChannel.length === 3) {\n\t\t\tkey |= chanId[this._cookieChannel.charAt(1)] << 16;\n\t\t\tkey |= chanId[this._cookieChannel.charAt(2)] << 14;\n\t\t}\n\t\tif (key !== this.key) {\n\t\t\tthis.layersDirty();\n\t\t}\n\t\tthis.key = key;\n\t}\n}\n\nexport { Light, lightTypes };\n", "import { math } from '../../core/math/math.js';\nimport { Vec3 } from '../../core/math/vec3.js';\nimport { SHADOW_PCF3 } from '../constants.js';\n\nclass LightingParams {\n\tconstructor(supportsAreaLights, maxTextureSize, dirtyLightsFnc) {\n\t\tthis._areaLightsEnabled = false;\n\t\tthis._cells = new Vec3(10, 3, 10);\n\t\tthis._maxLightsPerCell = 255;\n\t\tthis._shadowsEnabled = true;\n\t\tthis._shadowType = SHADOW_PCF3;\n\t\tthis._shadowAtlasResolution = 2048;\n\t\tthis._cookiesEnabled = false;\n\t\tthis._cookieAtlasResolution = 2048;\n\t\tthis.debugLayer = void 0;\n\t\tthis.atlasSplit = null;\n\t\tthis._supportsAreaLights = supportsAreaLights;\n\t\tthis._maxTextureSize = maxTextureSize;\n\t\tthis._dirtyLightsFnc = dirtyLightsFnc;\n\t}\n\tapplySettings(render) {\n\t\tvar _render$lightingShado, _render$lightingCooki, _render$lightingAreaL, _render$lightingShado2, _render$lightingCooki2, _render$lightingMaxLi, _render$lightingShado3;\n\t\tthis.shadowsEnabled = (_render$lightingShado = render.lightingShadowsEnabled) != null ? _render$lightingShado : this.shadowsEnabled;\n\t\tthis.cookiesEnabled = (_render$lightingCooki = render.lightingCookiesEnabled) != null ? _render$lightingCooki : this.cookiesEnabled;\n\t\tthis.areaLightsEnabled = (_render$lightingAreaL = render.lightingAreaLightsEnabled) != null ? _render$lightingAreaL : this.areaLightsEnabled;\n\t\tthis.shadowAtlasResolution = (_render$lightingShado2 = render.lightingShadowAtlasResolution) != null ? _render$lightingShado2 : this.shadowAtlasResolution;\n\t\tthis.cookieAtlasResolution = (_render$lightingCooki2 = render.lightingCookieAtlasResolution) != null ? _render$lightingCooki2 : this.cookieAtlasResolution;\n\t\tthis.maxLightsPerCell = (_render$lightingMaxLi = render.lightingMaxLightsPerCell) != null ? _render$lightingMaxLi : this.maxLightsPerCell;\n\t\tthis.shadowType = (_render$lightingShado3 = render.lightingShadowType) != null ? _render$lightingShado3 : this.shadowType;\n\t\tif (render.lightingCells) this.cell = new Vec3(render.lightingCells);\n\t}\n\tset cells(value) {\n\t\tthis._cells.copy(value);\n\t}\n\tget cells() {\n\t\treturn this._cells;\n\t}\n\tset maxLightsPerCell(value) {\n\t\tthis._maxLightsPerCell = math.clamp(value, 1, 255);\n\t}\n\tget maxLightsPerCell() {\n\t\treturn this._maxLightsPerCell;\n\t}\n\tset cookieAtlasResolution(value) {\n\t\tthis._cookieAtlasResolution = math.clamp(value, 32, this._maxTextureSize);\n\t}\n\tget cookieAtlasResolution() {\n\t\treturn this._cookieAtlasResolution;\n\t}\n\tset shadowAtlasResolution(value) {\n\t\tthis._shadowAtlasResolution = math.clamp(value, 32, this._maxTextureSize);\n\t}\n\tget shadowAtlasResolution() {\n\t\treturn this._shadowAtlasResolution;\n\t}\n\tset shadowType(value) {\n\t\tif (this._shadowType !== value) {\n\t\t\tthis._shadowType = value;\n\t\t\tthis._dirtyLightsFnc();\n\t\t}\n\t}\n\tget shadowType() {\n\t\treturn this._shadowType;\n\t}\n\tset cookiesEnabled(value) {\n\t\tif (this._cookiesEnabled !== value) {\n\t\t\tthis._cookiesEnabled = value;\n\t\t\tthis._dirtyLightsFnc();\n\t\t}\n\t}\n\tget cookiesEnabled() {\n\t\treturn this._cookiesEnabled;\n\t}\n\tset areaLightsEnabled(value) {\n\t\tif (this._supportsAreaLights) {\n\t\t\tif (this._areaLightsEnabled !== value) {\n\t\t\t\tthis._areaLightsEnabled = value;\n\t\t\t\tthis._dirtyLightsFnc();\n\t\t\t}\n\t\t}\n\t}\n\tget areaLightsEnabled() {\n\t\treturn this._areaLightsEnabled;\n\t}\n\tset shadowsEnabled(value) {\n\t\tif (this._shadowsEnabled !== value) {\n\t\t\tthis._shadowsEnabled = value;\n\t\t\tthis._dirtyLightsFnc();\n\t\t}\n\t}\n\tget shadowsEnabled() {\n\t\treturn this._shadowsEnabled;\n\t}\n}\n\nexport { LightingParams };\n", "import { BLENDEQUATION_ADD, BLENDMODE_ONE } from '../platform/graphics/constants.js';\nimport { drawQuadWithShader } from './graphics/quad-render-utils.js';\nimport { RenderTarget } from '../platform/graphics/render-target.js';\nimport { createShaderFromCode } from './shader-lib/utils.js';\nimport { BlendState } from '../platform/graphics/blend-state.js';\n\nconst textureMorphVertexShader = `\n\tattribute vec2 vertex_position;\n\tvarying vec2 uv0;\n\tvoid main(void) {\n\t\tgl_Position = vec4(vertex_position, 0.5, 1.0);\n\t\tuv0 = vertex_position.xy * 0.5 + 0.5;\n\t}\n\t`;\nconst blendStateAdditive = new BlendState(true, BLENDEQUATION_ADD, BLENDMODE_ONE, BLENDMODE_ONE);\nclass MorphInstance {\n\tconstructor(morph) {\n\t\tthis.morph = morph;\n\t\tmorph.incRefCount();\n\t\tthis.device = morph.device;\n\t\tthis._weights = [];\n\t\tthis._weightMap = new Map();\n\t\tfor (let v = 0; v < morph._targets.length; v++) {\n\t\t\tconst target = morph._targets[v];\n\t\t\tif (target.name) {\n\t\t\t\tthis._weightMap.set(target.name, v);\n\t\t\t}\n\t\t\tthis.setWeight(v, target.defaultWeight);\n\t\t}\n\t\tthis._activeTargets = [];\n\t\tif (morph.useTextureMorph) {\n\t\t\tthis.shaderCache = {};\n\t\t\tthis.maxSubmitCount = this.device.maxTextures;\n\t\t\tthis._shaderMorphWeights = new Float32Array(this.maxSubmitCount);\n\t\t\tconst createRT = (name, textureVar) => {\n\t\t\t\tthis[textureVar] = morph._createTexture(name, morph._renderTextureFormat);\n\t\t\t\treturn new RenderTarget({\n\t\t\t\t\tcolorBuffer: this[textureVar],\n\t\t\t\t\tdepth: false\n\t\t\t\t});\n\t\t\t};\n\t\t\tif (morph.morphPositions) {\n\t\t\t\tthis.rtPositions = createRT('MorphRTPos', 'texturePositions');\n\t\t\t}\n\t\t\tif (morph.morphNormals) {\n\t\t\t\tthis.rtNormals = createRT('MorphRTNrm', 'textureNormals');\n\t\t\t}\n\t\t\tthis._textureParams = new Float32Array([morph.morphTextureWidth, morph.morphTextureHeight, 1 / morph.morphTextureWidth, 1 / morph.morphTextureHeight]);\n\t\t\tfor (let i = 0; i < this.maxSubmitCount; i++) {\n\t\t\t\tthis['morphBlendTex' + i] = this.device.scope.resolve('morphBlendTex' + i);\n\t\t\t}\n\t\t\tthis.morphFactor = this.device.scope.resolve('morphFactor[0]');\n\t\t\tthis.zeroTextures = false;\n\t\t} else {\n\t\t\tthis.maxSubmitCount = 8;\n\t\t\tthis._shaderMorphWeights = new Float32Array(this.maxSubmitCount);\n\t\t\tthis._shaderMorphWeightsA = new Float32Array(this._shaderMorphWeights.buffer, 0, 4);\n\t\t\tthis._shaderMorphWeightsB = new Float32Array(this._shaderMorphWeights.buffer, 4 * 4, 4);\n\t\t\tthis._activeVertexBuffers = new Array(this.maxSubmitCount);\n\t\t}\n\t}\n\tdestroy() {\n\t\tthis.shader = null;\n\t\tconst morph = this.morph;\n\t\tif (morph) {\n\t\t\tthis.morph = null;\n\t\t\tmorph.decRefCount();\n\t\t\tif (morph.refCount < 1) {\n\t\t\t\tmorph.destroy();\n\t\t\t}\n\t\t}\n\t\tif (this.rtPositions) {\n\t\t\tthis.rtPositions.destroy();\n\t\t\tthis.rtPositions = null;\n\t\t}\n\t\tif (this.texturePositions) {\n\t\t\tthis.texturePositions.destroy();\n\t\t\tthis.texturePositions = null;\n\t\t}\n\t\tif (this.rtNormals) {\n\t\t\tthis.rtNormals.destroy();\n\t\t\tthis.rtNormals = null;\n\t\t}\n\t\tif (this.textureNormals) {\n\t\t\tthis.textureNormals.destroy();\n\t\t\tthis.textureNormals = null;\n\t\t}\n\t}\n\tclone() {\n\t\treturn new MorphInstance(this.morph);\n\t}\n\t_getWeightIndex(key) {\n\t\tif (typeof key === 'string') {\n\t\t\tconst index = this._weightMap.get(key);\n\t\t\treturn index;\n\t\t}\n\t\treturn key;\n\t}\n\tgetWeight(key) {\n\t\tconst index = this._getWeightIndex(key);\n\t\treturn this._weights[index];\n\t}\n\tsetWeight(key, weight) {\n\t\tconst index = this._getWeightIndex(key);\n\t\tthis._weights[index] = weight;\n\t\tthis._dirty = true;\n\t}\n\t_getFragmentShader(numTextures) {\n\t\tlet fragmentShader = '';\n\t\tif (numTextures > 0) {\n\t\t\tfragmentShader += 'varying vec2 uv0;\\n' + 'uniform highp float morphFactor[' + numTextures + '];\\n';\n\t\t}\n\t\tfor (let i = 0; i < numTextures; i++) {\n\t\t\tfragmentShader += 'uniform highp sampler2D morphBlendTex' + i + ';\\n';\n\t\t}\n\t\tfragmentShader += 'void main (void) {\\n' + ' highp vec4 color = vec4(0, 0, 0, 1);\\n';\n\t\tfor (let i = 0; i < numTextures; i++) {\n\t\t\tfragmentShader += ' color.xyz += morphFactor[' + i + '] * texture2D(morphBlendTex' + i + ', uv0).xyz;\\n';\n\t\t}\n\t\tfragmentShader += ' gl_FragColor = color;\\n' + '}\\n';\n\t\treturn fragmentShader;\n\t}\n\t_getShader(count) {\n\t\tlet shader = this.shaderCache[count];\n\t\tif (!shader) {\n\t\t\tconst fs = this._getFragmentShader(count);\n\t\t\tshader = createShaderFromCode(this.device, textureMorphVertexShader, fs, 'textureMorph' + count);\n\t\t\tthis.shaderCache[count] = shader;\n\t\t}\n\t\treturn shader;\n\t}\n\t_updateTextureRenderTarget(renderTarget, srcTextureName) {\n\t\tconst device = this.device;\n\t\tconst submitBatch = (usedCount, blending) => {\n\t\t\tthis.morphFactor.setValue(this._shaderMorphWeights);\n\t\t\tdevice.setBlendState(blending ? blendStateAdditive : BlendState.NOBLEND);\n\t\t\tconst shader = this._getShader(usedCount);\n\t\t\tdrawQuadWithShader(device, renderTarget, shader);\n\t\t};\n\t\tlet usedCount = 0;\n\t\tlet blending = false;\n\t\tconst count = this._activeTargets.length;\n\t\tfor (let i = 0; i < count; i++) {\n\t\t\tconst activeTarget = this._activeTargets[i];\n\t\t\tconst tex = activeTarget.target[srcTextureName];\n\t\t\tif (tex) {\n\t\t\t\tthis['morphBlendTex' + usedCount].setValue(tex);\n\t\t\t\tthis._shaderMorphWeights[usedCount] = activeTarget.weight;\n\t\t\t\tusedCount++;\n\t\t\t\tif (usedCount >= this.maxSubmitCount) {\n\t\t\t\t\tsubmitBatch(usedCount, blending);\n\t\t\t\t\tusedCount = 0;\n\t\t\t\t\tblending = true;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (usedCount > 0 || count === 0 && !this.zeroTextures) {\n\t\t\tsubmitBatch(usedCount, blending);\n\t\t}\n\t}\n\t_updateTextureMorph() {\n\t\tthis.device;\n\t\tif (this._activeTargets.length > 0 || !this.zeroTextures) {\n\t\t\tif (this.rtPositions) this._updateTextureRenderTarget(this.rtPositions, 'texturePositions');\n\t\t\tif (this.rtNormals) this._updateTextureRenderTarget(this.rtNormals, 'textureNormals');\n\t\t\tthis.zeroTextures = this._activeTargets.length === 0;\n\t\t}\n\t}\n\t_updateVertexMorph() {\n\t\tconst count = this.maxSubmitCount;\n\t\tfor (let i = 0; i < count; i++) {\n\t\t\tthis._shaderMorphWeights[i] = 0;\n\t\t\tthis._activeVertexBuffers[i] = null;\n\t\t}\n\t\tlet posIndex = 0;\n\t\tlet nrmIndex = this.morph.morphPositions ? 4 : 0;\n\t\tfor (let i = 0; i < this._activeTargets.length; i++) {\n\t\t\tconst target = this._activeTargets[i].target;\n\t\t\tif (target._vertexBufferPositions) {\n\t\t\t\tthis._activeVertexBuffers[posIndex] = target._vertexBufferPositions;\n\t\t\t\tthis._shaderMorphWeights[posIndex] = this._activeTargets[i].weight;\n\t\t\t\tposIndex++;\n\t\t\t}\n\t\t\tif (target._vertexBufferNormals) {\n\t\t\t\tthis._activeVertexBuffers[nrmIndex] = target._vertexBufferNormals;\n\t\t\t\tthis._shaderMorphWeights[nrmIndex] = this._activeTargets[i].weight;\n\t\t\t\tnrmIndex++;\n\t\t\t}\n\t\t}\n\t}\n\tupdate() {\n\t\tthis._dirty = false;\n\t\tconst targets = this.morph._targets;\n\t\tlet activeCount = 0;\n\t\tconst epsilon = 0.00001;\n\t\tfor (let i = 0; i < targets.length; i++) {\n\t\t\tconst absWeight = Math.abs(this.getWeight(i));\n\t\t\tif (absWeight > epsilon) {\n\t\t\t\tif (this._activeTargets.length <= activeCount) {\n\t\t\t\t\tthis._activeTargets[activeCount] = {};\n\t\t\t\t}\n\t\t\t\tconst activeTarget = this._activeTargets[activeCount++];\n\t\t\t\tactiveTarget.absWeight = absWeight;\n\t\t\t\tactiveTarget.weight = this.getWeight(i);\n\t\t\t\tactiveTarget.target = targets[i];\n\t\t\t}\n\t\t}\n\t\tthis._activeTargets.length = activeCount;\n\t\tconst maxActiveTargets = this.morph.maxActiveTargets;\n\t\tif (this._activeTargets.length > maxActiveTargets) {\n\t\t\tthis._activeTargets.sort(function (l, r) {\n\t\t\t\treturn l.absWeight < r.absWeight ? 1 : r.absWeight < l.absWeight ? -1 : 0;\n\t\t\t});\n\t\t\tthis._activeTargets.length = maxActiveTargets;\n\t\t}\n\t\tif (this.morph.useTextureMorph) {\n\t\t\tthis._updateTextureMorph();\n\t\t} else {\n\t\t\tthis._updateVertexMorph();\n\t\t}\n\t}\n}\n\nexport { MorphInstance };\n", "import { RENDERSTYLE_WIREFRAME } from './constants.js';\nimport { MeshInstance } from './mesh-instance.js';\nimport { MorphInstance } from './morph-instance.js';\nimport { SkinInstance } from './skin-instance.js';\n\nclass Model {\n\tconstructor() {\n\t\tthis.graph = null;\n\t\tthis.meshInstances = [];\n\t\tthis.skinInstances = [];\n\t\tthis.morphInstances = [];\n\t\tthis.cameras = [];\n\t\tthis.lights = [];\n\t\tthis._shadersVersion = 0;\n\t\tthis._immutable = false;\n\t}\n\tgetGraph() {\n\t\treturn this.graph;\n\t}\n\tsetGraph(graph) {\n\t\tthis.graph = graph;\n\t}\n\tgetCameras() {\n\t\treturn this.cameras;\n\t}\n\tsetCameras(cameras) {\n\t\tthis.cameras = cameras;\n\t}\n\tgetLights() {\n\t\treturn this.lights;\n\t}\n\tsetLights(lights) {\n\t\tthis.lights = lights;\n\t}\n\tgetMaterials() {\n\t\tconst materials = [];\n\t\tfor (let i = 0; i < this.meshInstances.length; i++) {\n\t\t\tconst meshInstance = this.meshInstances[i];\n\t\t\tif (materials.indexOf(meshInstance.material) === -1) {\n\t\t\t\tmaterials.push(meshInstance.material);\n\t\t\t}\n\t\t}\n\t\treturn materials;\n\t}\n\tclone() {\n\t\tconst srcNodes = [];\n\t\tconst cloneNodes = [];\n\t\tconst _duplicate = function _duplicate(node) {\n\t\t\tconst newNode = node.clone();\n\t\t\tsrcNodes.push(node);\n\t\t\tcloneNodes.push(newNode);\n\t\t\tfor (let idx = 0; idx < node._children.length; idx++) {\n\t\t\t\tnewNode.addChild(_duplicate(node._children[idx]));\n\t\t\t}\n\t\t\treturn newNode;\n\t\t};\n\t\tconst cloneGraph = _duplicate(this.graph);\n\t\tconst cloneMeshInstances = [];\n\t\tconst cloneSkinInstances = [];\n\t\tconst cloneMorphInstances = [];\n\t\tfor (let i = 0; i < this.skinInstances.length; i++) {\n\t\t\tconst skin = this.skinInstances[i].skin;\n\t\t\tconst cloneSkinInstance = new SkinInstance(skin);\n\t\t\tconst bones = [];\n\t\t\tfor (let j = 0; j < skin.boneNames.length; j++) {\n\t\t\t\tconst boneName = skin.boneNames[j];\n\t\t\t\tconst bone = cloneGraph.findByName(boneName);\n\t\t\t\tbones.push(bone);\n\t\t\t}\n\t\t\tcloneSkinInstance.bones = bones;\n\t\t\tcloneSkinInstances.push(cloneSkinInstance);\n\t\t}\n\t\tfor (let i = 0; i < this.morphInstances.length; i++) {\n\t\t\tconst morph = this.morphInstances[i].morph;\n\t\t\tconst cloneMorphInstance = new MorphInstance(morph);\n\t\t\tcloneMorphInstances.push(cloneMorphInstance);\n\t\t}\n\t\tfor (let i = 0; i < this.meshInstances.length; i++) {\n\t\t\tconst meshInstance = this.meshInstances[i];\n\t\t\tconst nodeIndex = srcNodes.indexOf(meshInstance.node);\n\t\t\tconst cloneMeshInstance = new MeshInstance(meshInstance.mesh, meshInstance.material, cloneNodes[nodeIndex]);\n\t\t\tif (meshInstance.skinInstance) {\n\t\t\t\tconst skinInstanceIndex = this.skinInstances.indexOf(meshInstance.skinInstance);\n\t\t\t\tcloneMeshInstance.skinInstance = cloneSkinInstances[skinInstanceIndex];\n\t\t\t}\n\t\t\tif (meshInstance.morphInstance) {\n\t\t\t\tconst morphInstanceIndex = this.morphInstances.indexOf(meshInstance.morphInstance);\n\t\t\t\tcloneMeshInstance.morphInstance = cloneMorphInstances[morphInstanceIndex];\n\t\t\t}\n\t\t\tcloneMeshInstances.push(cloneMeshInstance);\n\t\t}\n\t\tconst clone = new Model();\n\t\tclone.graph = cloneGraph;\n\t\tclone.meshInstances = cloneMeshInstances;\n\t\tclone.skinInstances = cloneSkinInstances;\n\t\tclone.morphInstances = cloneMorphInstances;\n\t\tclone.getGraph().syncHierarchy();\n\t\treturn clone;\n\t}\n\tdestroy() {\n\t\tconst meshInstances = this.meshInstances;\n\t\tfor (let i = 0; i < meshInstances.length; i++) {\n\t\t\tmeshInstances[i].destroy();\n\t\t}\n\t\tthis.meshInstances.length = 0;\n\t}\n\tgenerateWireframe() {\n\t\tMeshInstance._prepareRenderStyleForArray(this.meshInstances, RENDERSTYLE_WIREFRAME);\n\t}\n}\n\nexport { Model };\n", "import { RefCountedObject } from '../core/ref-counted-object.js';\nimport { Vec3 } from '../core/math/vec3.js';\nimport { FloatPacking } from '../core/math/float-packing.js';\nimport { BoundingBox } from '../core/shape/bounding-box.js';\nimport { Texture } from '../platform/graphics/texture.js';\nimport { VertexBuffer } from '../platform/graphics/vertex-buffer.js';\nimport { VertexFormat } from '../platform/graphics/vertex-format.js';\nimport { PIXELFORMAT_RGBA16F, PIXELFORMAT_RGBA32F, PIXELFORMAT_RGB32F, FILTER_NEAREST, ADDRESS_CLAMP_TO_EDGE, SEMANTIC_ATTR15, TYPE_UINT32, TYPE_FLOAT32 } from '../platform/graphics/constants.js';\n\nclass Morph extends RefCountedObject {\n\tconstructor(targets, graphicsDevice, {\n\t\tpreferHighPrecision = false\n\t} = {}) {\n\t\tsuper();\n\t\tthis._aabb = void 0;\n\t\tthis.preferHighPrecision = void 0;\n\t\tthis.device = graphicsDevice;\n\t\tthis.preferHighPrecision = preferHighPrecision;\n\t\tthis._targets = targets.slice();\n\t\tconst device = this.device;\n\t\tif (device.supportsMorphTargetTexturesCore) {\n\t\t\tconst renderableHalf = device.extTextureHalfFloat && device.textureHalfFloatRenderable ? PIXELFORMAT_RGBA16F : undefined;\n\t\t\tconst renderableFloat = device.extTextureFloat && device.textureFloatRenderable ? PIXELFORMAT_RGBA32F : undefined;\n\t\t\tthis._renderTextureFormat = this.preferHighPrecision ? renderableFloat != null ? renderableFloat : renderableHalf : renderableHalf != null ? renderableHalf : renderableFloat;\n\t\t\tconst textureHalf = device.extTextureHalfFloat && device.textureHalfFloatUpdatable ? PIXELFORMAT_RGBA16F : undefined;\n\t\t\tconst textureFloat = device.extTextureFloat ? PIXELFORMAT_RGB32F : undefined;\n\t\t\tthis._textureFormat = this.preferHighPrecision ? textureFloat != null ? textureFloat : textureHalf : textureHalf != null ? textureHalf : textureFloat;\n\t\t\tif (this._renderTextureFormat !== undefined && this._textureFormat !== undefined) {\n\t\t\t\tthis._useTextureMorph = true;\n\t\t\t}\n\t\t}\n\t\tthis._init();\n\t\tthis._updateMorphFlags();\n\t}\n\tget aabb() {\n\t\tif (!this._aabb) {\n\t\t\tconst min = new Vec3();\n\t\t\tconst max = new Vec3();\n\t\t\tfor (let i = 0; i < this._targets.length; i++) {\n\t\t\t\tconst targetAabb = this._targets[i].aabb;\n\t\t\t\tmin.min(targetAabb.getMin());\n\t\t\t\tmax.max(targetAabb.getMax());\n\t\t\t}\n\t\t\tthis._aabb = new BoundingBox();\n\t\t\tthis._aabb.setMinMax(min, max);\n\t\t}\n\t\treturn this._aabb;\n\t}\n\tget morphPositions() {\n\t\treturn this._morphPositions;\n\t}\n\tget morphNormals() {\n\t\treturn this._morphNormals;\n\t}\n\tget maxActiveTargets() {\n\t\tif (this._useTextureMorph) return this._targets.length;\n\t\treturn this._morphPositions && this._morphNormals ? 4 : 8;\n\t}\n\tget useTextureMorph() {\n\t\treturn this._useTextureMorph;\n\t}\n\t_init() {\n\t\tif (this._useTextureMorph) {\n\t\t\tthis._useTextureMorph = this._initTextureBased();\n\t\t}\n\t\tif (!this._useTextureMorph) {\n\t\t\tfor (let i = 0; i < this._targets.length; i++) {\n\t\t\t\tthis._targets[i]._initVertexBuffers(this.device);\n\t\t\t}\n\t\t}\n\t\tfor (let i = 0; i < this._targets.length; i++) {\n\t\t\tthis._targets[i]._postInit();\n\t\t}\n\t}\n\t_findSparseSet(deltaArrays, ids, usedDataIndices, floatRounding) {\n\t\tlet freeIndex = 1;\n\t\tconst dataCount = deltaArrays[0].length;\n\t\tfor (let v = 0; v < dataCount; v += 3) {\n\t\t\tlet vertexUsed = false;\n\t\t\tfor (let i = 0; i < deltaArrays.length; i++) {\n\t\t\t\tconst data = deltaArrays[i];\n\t\t\t\tif (data[v] !== 0 || data[v + 1] !== 0 || data[v + 2] !== 0) {\n\t\t\t\t\tvertexUsed = true;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (vertexUsed) {\n\t\t\t\tids.push(freeIndex + floatRounding);\n\t\t\t\tusedDataIndices.push(v / 3);\n\t\t\t\tfreeIndex++;\n\t\t\t} else {\n\t\t\t\tids.push(0 + floatRounding);\n\t\t\t}\n\t\t}\n\t\treturn freeIndex;\n\t}\n\t_initTextureBased() {\n\t\tconst useUintIds = this.device.isWebGPU;\n\t\tconst floatRounding = useUintIds ? 0 : 0.2;\n\t\tconst deltaArrays = [],\n\t\t\tdeltaInfos = [];\n\t\tfor (let i = 0; i < this._targets.length; i++) {\n\t\t\tconst target = this._targets[i];\n\t\t\tif (target.options.deltaPositions) {\n\t\t\t\tdeltaArrays.push(target.options.deltaPositions);\n\t\t\t\tdeltaInfos.push({\n\t\t\t\t\ttarget: target,\n\t\t\t\t\tname: 'texturePositions'\n\t\t\t\t});\n\t\t\t}\n\t\t\tif (target.options.deltaNormals) {\n\t\t\t\tdeltaArrays.push(target.options.deltaNormals);\n\t\t\t\tdeltaInfos.push({\n\t\t\t\t\ttarget: target,\n\t\t\t\t\tname: 'textureNormals'\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t\tconst ids = [],\n\t\t\tusedDataIndices = [];\n\t\tconst freeIndex = this._findSparseSet(deltaArrays, ids, usedDataIndices, floatRounding);\n\t\tconst maxTextureSize = Math.min(this.device.maxTextureSize, 4096);\n\t\tlet morphTextureWidth = Math.ceil(Math.sqrt(freeIndex));\n\t\tmorphTextureWidth = Math.min(morphTextureWidth, maxTextureSize);\n\t\tconst morphTextureHeight = Math.ceil(freeIndex / morphTextureWidth);\n\t\tif (morphTextureHeight > maxTextureSize) {\n\t\t\treturn false;\n\t\t}\n\t\tthis.morphTextureWidth = morphTextureWidth;\n\t\tthis.morphTextureHeight = morphTextureHeight;\n\t\tlet halfFloat = false;\n\t\tlet numComponents = 3;\n\t\tconst float2Half = FloatPacking.float2Half;\n\t\tif (this._textureFormat === PIXELFORMAT_RGBA16F) {\n\t\t\thalfFloat = true;\n\t\t\tnumComponents = 4;\n\t\t}\n\t\tconst textures = [];\n\t\tfor (let i = 0; i < deltaArrays.length; i++) {\n\t\t\ttextures.push(this._createTexture('MorphTarget', this._textureFormat));\n\t\t}\n\t\tfor (let i = 0; i < deltaArrays.length; i++) {\n\t\t\tconst data = deltaArrays[i];\n\t\t\tconst texture = textures[i];\n\t\t\tconst textureData = texture.lock();\n\t\t\tif (halfFloat) {\n\t\t\t\tfor (let v = 0; v < usedDataIndices.length; v++) {\n\t\t\t\t\tconst index = usedDataIndices[v] * 3;\n\t\t\t\t\tconst dstIndex = v * numComponents + numComponents;\n\t\t\t\t\ttextureData[dstIndex] = float2Half(data[index]);\n\t\t\t\t\ttextureData[dstIndex + 1] = float2Half(data[index + 1]);\n\t\t\t\t\ttextureData[dstIndex + 2] = float2Half(data[index + 2]);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tfor (let v = 0; v < usedDataIndices.length; v++) {\n\t\t\t\t\tconst index = usedDataIndices[v] * 3;\n\t\t\t\t\tconst dstIndex = v * numComponents + numComponents;\n\t\t\t\t\ttextureData[dstIndex] = data[index];\n\t\t\t\t\ttextureData[dstIndex + 1] = data[index + 1];\n\t\t\t\t\ttextureData[dstIndex + 2] = data[index + 2];\n\t\t\t\t}\n\t\t\t}\n\t\t\ttexture.unlock();\n\t\t\tconst target = deltaInfos[i].target;\n\t\t\ttarget._setTexture(deltaInfos[i].name, texture);\n\t\t}\n\t\tconst formatDesc = [{\n\t\t\tsemantic: SEMANTIC_ATTR15,\n\t\t\tcomponents: 1,\n\t\t\ttype: useUintIds ? TYPE_UINT32 : TYPE_FLOAT32\n\t\t}];\n\t\tthis.vertexBufferIds = new VertexBuffer(this.device, new VertexFormat(this.device, formatDesc, ids.length), ids.length, {\n\t\t\tdata: useUintIds ? new Uint32Array(ids) : new Float32Array(ids)\n\t\t});\n\t\treturn true;\n\t}\n\tdestroy() {\n\t\tvar _this$vertexBufferIds;\n\t\t(_this$vertexBufferIds = this.vertexBufferIds) == null || _this$vertexBufferIds.destroy();\n\t\tthis.vertexBufferIds = null;\n\t\tfor (let i = 0; i < this._targets.length; i++) {\n\t\t\tthis._targets[i].destroy();\n\t\t}\n\t\tthis._targets.length = 0;\n\t}\n\tget targets() {\n\t\treturn this._targets;\n\t}\n\t_updateMorphFlags() {\n\t\tthis._morphPositions = false;\n\t\tthis._morphNormals = false;\n\t\tfor (let i = 0; i < this._targets.length; i++) {\n\t\t\tconst target = this._targets[i];\n\t\t\tif (target.morphPositions) {\n\t\t\t\tthis._morphPositions = true;\n\t\t\t}\n\t\t\tif (target.morphNormals) {\n\t\t\t\tthis._morphNormals = true;\n\t\t\t}\n\t\t}\n\t}\n\t_createTexture(name, format) {\n\t\treturn new Texture(this.device, {\n\t\t\twidth: this.morphTextureWidth,\n\t\t\theight: this.morphTextureHeight,\n\t\t\tformat: format,\n\t\t\tcubemap: false,\n\t\t\tmipmaps: false,\n\t\t\tminFilter: FILTER_NEAREST,\n\t\t\tmagFilter: FILTER_NEAREST,\n\t\t\taddressU: ADDRESS_CLAMP_TO_EDGE,\n\t\t\taddressV: ADDRESS_CLAMP_TO_EDGE,\n\t\t\tname: name\n\t\t});\n\t}\n}\n\nexport { Morph };\n", "import { BoundingBox } from '../core/shape/bounding-box.js';\nimport { TYPE_FLOAT32, SEMANTIC_ATTR0 } from '../platform/graphics/constants.js';\nimport { VertexBuffer } from '../platform/graphics/vertex-buffer.js';\nimport { VertexFormat } from '../platform/graphics/vertex-format.js';\n\nclass MorphTarget {\n\tconstructor(options) {\n\t\tthis.used = false;\n\t\tif (arguments.length === 2) {\n\t\t\toptions = arguments[1];\n\t\t}\n\t\tthis.options = options;\n\t\tthis._name = options.name;\n\t\tthis._defaultWeight = options.defaultWeight || 0;\n\t\tthis._aabb = options.aabb;\n\t\tthis.deltaPositions = options.deltaPositions;\n\t}\n\tdestroy() {\n\t\tvar _this$_vertexBufferPo, _this$_vertexBufferNo, _this$texturePosition, _this$textureNormals;\n\t\t(_this$_vertexBufferPo = this._vertexBufferPositions) == null || _this$_vertexBufferPo.destroy();\n\t\tthis._vertexBufferPositions = null;\n\t\t(_this$_vertexBufferNo = this._vertexBufferNormals) == null || _this$_vertexBufferNo.destroy();\n\t\tthis._vertexBufferNormals = null;\n\t\t(_this$texturePosition = this.texturePositions) == null || _this$texturePosition.destroy();\n\t\tthis.texturePositions = null;\n\t\t(_this$textureNormals = this.textureNormals) == null || _this$textureNormals.destroy();\n\t\tthis.textureNormals = null;\n\t}\n\tget name() {\n\t\treturn this._name;\n\t}\n\tget defaultWeight() {\n\t\treturn this._defaultWeight;\n\t}\n\tget aabb() {\n\t\tif (!this._aabb) {\n\t\t\tthis._aabb = new BoundingBox();\n\t\t\tif (this.deltaPositions) this._aabb.compute(this.deltaPositions);\n\t\t}\n\t\treturn this._aabb;\n\t}\n\tget morphPositions() {\n\t\treturn !!this._vertexBufferPositions || !!this.texturePositions;\n\t}\n\tget morphNormals() {\n\t\treturn !!this._vertexBufferNormals || !!this.textureNormals;\n\t}\n\tclone() {\n\t\treturn new MorphTarget(this.options);\n\t}\n\t_postInit() {\n\t\tif (!this.options.preserveData) {\n\t\t\tthis.options = null;\n\t\t}\n\t\tthis.used = true;\n\t}\n\t_initVertexBuffers(graphicsDevice) {\n\t\tconst options = this.options;\n\t\tthis._vertexBufferPositions = this._createVertexBuffer(graphicsDevice, options.deltaPositions, options.deltaPositionsType);\n\t\tthis._vertexBufferNormals = this._createVertexBuffer(graphicsDevice, options.deltaNormals, options.deltaNormalsType);\n\t\tif (this._vertexBufferPositions) {\n\t\t\tthis.deltaPositions = this._vertexBufferPositions.lock();\n\t\t}\n\t}\n\t_createVertexBuffer(device, data, dataType = TYPE_FLOAT32) {\n\t\tif (data) {\n\t\t\tconst formatDesc = [{\n\t\t\t\tsemantic: SEMANTIC_ATTR0,\n\t\t\t\tcomponents: 3,\n\t\t\t\ttype: dataType\n\t\t\t}];\n\t\t\treturn new VertexBuffer(device, new VertexFormat(device, formatDesc), data.length / 3, {\n\t\t\t\tdata: data\n\t\t\t});\n\t\t}\n\t\treturn null;\n\t}\n\t_setTexture(name, texture) {\n\t\tthis[name] = texture;\n\t}\n}\n\nexport { MorphTarget };\n", "import { SEMANTIC_POSITION } from '../../../platform/graphics/constants.js';\nimport { shaderChunks } from '../chunks/chunks.js';\nimport { ChunkUtils } from '../chunk-utils.js';\nimport { ShaderUtils } from '../../../platform/graphics/shader-utils.js';\nimport { ShaderGenerator } from './shader-generator.js';\nimport { SKYTYPE_INFINITE } from '../../constants.js';\n\nconst mip2size = [128, 64, 16, 8, 4, 2];\nconst fShader = `\n\t\t#include \"decodePS\"\n\t\t#include \"gamma\"\n\t\t#include \"tonemapping\"\n\t\t#include \"envMultiplyPS\"\n\n\t\t#ifdef SKY_CUBEMAP\n\t\t\t\t#include \"cubemapSeams\"\n\t\t\t\t#include \"skyboxHDRPS\"\n\t\t#else\n\t\t\t\t#include \"sphericalPS\"\n\t\t\t\t#include \"envAtlasPS\"\n\t\t\t\t#include \"skyboxEnvPS\"\n\t\t#endif\n`;\nclass ShaderGeneratorSkybox extends ShaderGenerator {\n\tgenerateKey(options) {\n\t\tconst sharedKey = `skybox-${options.type}-${options.encoding}-${options.gamma}-${options.toneMapping}-${options.skymesh}`;\n\t\treturn sharedKey + (options.type === 'cubemap' ? `-${options.mip}` : '');\n\t}\n\tcreateShaderDefinition(device, options) {\n\t\tconst defines = new Map();\n\t\tdefines.set('SKYBOX_DECODE_FNC', ChunkUtils.decodeFunc(options.encoding));\n\t\tif (options.skymesh !== SKYTYPE_INFINITE) defines.set('SKYMESH', '');\n\t\tif (options.type === 'cubemap') {\n\t\t\tdefines.set('SKY_CUBEMAP', '');\n\t\t\tdefines.set('SKYBOX_MIP', (1 - 1 / mip2size[options.mip]).toString());\n\t\t}\n\t\tconst includes = new Map();\n\t\tincludes.set('decodePS', shaderChunks.decodePS);\n\t\tincludes.set('gamma', ShaderGenerator.gammaCode(options.gamma));\n\t\tincludes.set('tonemapping', ShaderGenerator.tonemapCode(options.toneMapping));\n\t\tincludes.set('envMultiplyPS', shaderChunks.envMultiplyPS);\n\t\tif (options.type === 'cubemap') {\n\t\t\tincludes.set('cubemapSeams', options.mip ? shaderChunks.fixCubemapSeamsStretchPS : shaderChunks.fixCubemapSeamsNonePS);\n\t\t\tincludes.set('skyboxHDRPS', shaderChunks.skyboxHDRPS);\n\t\t} else {\n\t\t\tincludes.set('sphericalPS', shaderChunks.sphericalPS);\n\t\t\tincludes.set('envAtlasPS', shaderChunks.envAtlasPS);\n\t\t\tincludes.set('skyboxEnvPS', shaderChunks.skyboxEnvPS);\n\t\t}\n\t\treturn ShaderUtils.createDefinition(device, {\n\t\t\tname: 'SkyboxShader',\n\t\t\tattributes: {\n\t\t\t\taPosition: SEMANTIC_POSITION\n\t\t\t},\n\t\t\tvertexCode: shaderChunks.skyboxVS,\n\t\t\tvertexDefines: defines,\n\t\t\tfragmentCode: fShader,\n\t\t\tfragmentDefines: defines,\n\t\t\tfragmentIncludes: includes\n\t\t});\n\t}\n}\nconst skybox = new ShaderGeneratorSkybox();\n\nexport { skybox };\n", "import { Vec2 } from '../../core/math/vec2.js';\nimport { Vec3 } from '../../core/math/vec3.js';\n\nconst calculateNormals = (positions, indices) => {\n\tconst triangleCount = indices.length / 3;\n\tconst vertexCount = positions.length / 3;\n\tconst p1 = new Vec3();\n\tconst p2 = new Vec3();\n\tconst p3 = new Vec3();\n\tconst p1p2 = new Vec3();\n\tconst p1p3 = new Vec3();\n\tconst faceNormal = new Vec3();\n\tconst normals = [];\n\tfor (let i = 0; i < positions.length; i++) {\n\t\tnormals[i] = 0;\n\t}\n\tfor (let i = 0; i < triangleCount; i++) {\n\t\tconst i1 = indices[i * 3];\n\t\tconst i2 = indices[i * 3 + 1];\n\t\tconst i3 = indices[i * 3 + 2];\n\t\tp1.set(positions[i1 * 3], positions[i1 * 3 + 1], positions[i1 * 3 + 2]);\n\t\tp2.set(positions[i2 * 3], positions[i2 * 3 + 1], positions[i2 * 3 + 2]);\n\t\tp3.set(positions[i3 * 3], positions[i3 * 3 + 1], positions[i3 * 3 + 2]);\n\t\tp1p2.sub2(p2, p1);\n\t\tp1p3.sub2(p3, p1);\n\t\tfaceNormal.cross(p1p2, p1p3).normalize();\n\t\tnormals[i1 * 3] += faceNormal.x;\n\t\tnormals[i1 * 3 + 1] += faceNormal.y;\n\t\tnormals[i1 * 3 + 2] += faceNormal.z;\n\t\tnormals[i2 * 3] += faceNormal.x;\n\t\tnormals[i2 * 3 + 1] += faceNormal.y;\n\t\tnormals[i2 * 3 + 2] += faceNormal.z;\n\t\tnormals[i3 * 3] += faceNormal.x;\n\t\tnormals[i3 * 3 + 1] += faceNormal.y;\n\t\tnormals[i3 * 3 + 2] += faceNormal.z;\n\t}\n\tfor (let i = 0; i < vertexCount; i++) {\n\t\tconst nx = normals[i * 3];\n\t\tconst ny = normals[i * 3 + 1];\n\t\tconst nz = normals[i * 3 + 2];\n\t\tconst invLen = 1 / Math.sqrt(nx * nx + ny * ny + nz * nz);\n\t\tnormals[i * 3] *= invLen;\n\t\tnormals[i * 3 + 1] *= invLen;\n\t\tnormals[i * 3 + 2] *= invLen;\n\t}\n\treturn normals;\n};\nconst calculateTangents = (positions, normals, uvs, indices) => {\n\tconst triangleCount = indices.length / 3;\n\tconst vertexCount = positions.length / 3;\n\tconst v1 = new Vec3();\n\tconst v2 = new Vec3();\n\tconst v3 = new Vec3();\n\tconst w1 = new Vec2();\n\tconst w2 = new Vec2();\n\tconst w3 = new Vec2();\n\tconst sdir = new Vec3();\n\tconst tdir = new Vec3();\n\tconst tan1 = new Float32Array(vertexCount * 3);\n\tconst tan2 = new Float32Array(vertexCount * 3);\n\tconst tangents = [];\n\tfor (let i = 0; i < triangleCount; i++) {\n\t\tconst i1 = indices[i * 3];\n\t\tconst i2 = indices[i * 3 + 1];\n\t\tconst i3 = indices[i * 3 + 2];\n\t\tv1.set(positions[i1 * 3], positions[i1 * 3 + 1], positions[i1 * 3 + 2]);\n\t\tv2.set(positions[i2 * 3], positions[i2 * 3 + 1], positions[i2 * 3 + 2]);\n\t\tv3.set(positions[i3 * 3], positions[i3 * 3 + 1], positions[i3 * 3 + 2]);\n\t\tw1.set(uvs[i1 * 2], uvs[i1 * 2 + 1]);\n\t\tw2.set(uvs[i2 * 2], uvs[i2 * 2 + 1]);\n\t\tw3.set(uvs[i3 * 2], uvs[i3 * 2 + 1]);\n\t\tconst x1 = v2.x - v1.x;\n\t\tconst x2 = v3.x - v1.x;\n\t\tconst y1 = v2.y - v1.y;\n\t\tconst y2 = v3.y - v1.y;\n\t\tconst z1 = v2.z - v1.z;\n\t\tconst z2 = v3.z - v1.z;\n\t\tconst s1 = w2.x - w1.x;\n\t\tconst s2 = w3.x - w1.x;\n\t\tconst _t = w2.y - w1.y;\n\t\tconst _t2 = w3.y - w1.y;\n\t\tconst area = s1 * _t2 - s2 * _t;\n\t\tif (area === 0) {\n\t\t\tsdir.set(0, 1, 0);\n\t\t\ttdir.set(1, 0, 0);\n\t\t} else {\n\t\t\tconst r = 1 / area;\n\t\t\tsdir.set((_t2 * x1 - _t * x2) * r, (_t2 * y1 - _t * y2) * r, (_t2 * z1 - _t * z2) * r);\n\t\t\ttdir.set((s1 * x2 - s2 * x1) * r, (s1 * y2 - s2 * y1) * r, (s1 * z2 - s2 * z1) * r);\n\t\t}\n\t\ttan1[i1 * 3 + 0] += sdir.x;\n\t\ttan1[i1 * 3 + 1] += sdir.y;\n\t\ttan1[i1 * 3 + 2] += sdir.z;\n\t\ttan1[i2 * 3 + 0] += sdir.x;\n\t\ttan1[i2 * 3 + 1] += sdir.y;\n\t\ttan1[i2 * 3 + 2] += sdir.z;\n\t\ttan1[i3 * 3 + 0] += sdir.x;\n\t\ttan1[i3 * 3 + 1] += sdir.y;\n\t\ttan1[i3 * 3 + 2] += sdir.z;\n\t\ttan2[i1 * 3 + 0] += tdir.x;\n\t\ttan2[i1 * 3 + 1] += tdir.y;\n\t\ttan2[i1 * 3 + 2] += tdir.z;\n\t\ttan2[i2 * 3 + 0] += tdir.x;\n\t\ttan2[i2 * 3 + 1] += tdir.y;\n\t\ttan2[i2 * 3 + 2] += tdir.z;\n\t\ttan2[i3 * 3 + 0] += tdir.x;\n\t\ttan2[i3 * 3 + 1] += tdir.y;\n\t\ttan2[i3 * 3 + 2] += tdir.z;\n\t}\n\tconst t1 = new Vec3();\n\tconst t2 = new Vec3();\n\tconst n = new Vec3();\n\tconst temp = new Vec3();\n\tfor (let i = 0; i < vertexCount; i++) {\n\t\tn.set(normals[i * 3], normals[i * 3 + 1], normals[i * 3 + 2]);\n\t\tt1.set(tan1[i * 3], tan1[i * 3 + 1], tan1[i * 3 + 2]);\n\t\tt2.set(tan2[i * 3], tan2[i * 3 + 1], tan2[i * 3 + 2]);\n\t\tconst ndott = n.dot(t1);\n\t\ttemp.copy(n).mulScalar(ndott);\n\t\ttemp.sub2(t1, temp).normalize();\n\t\ttangents[i * 4] = temp.x;\n\t\ttangents[i * 4 + 1] = temp.y;\n\t\ttangents[i * 4 + 2] = temp.z;\n\t\ttemp.cross(n, t1);\n\t\ttangents[i * 4 + 3] = temp.dot(t2) < 0.0 ? -1.0 : 1.0;\n\t}\n\treturn tangents;\n};\n\nexport { calculateNormals, calculateTangents };\n", "import { calculateNormals, calculateTangents } from './geometry-utils.js';\n\nclass Geometry {\n\tconstructor() {\n\t\tthis.positions = void 0;\n\t\tthis.normals = void 0;\n\t\tthis.colors = void 0;\n\t\tthis.uvs = void 0;\n\t\tthis.uvs1 = void 0;\n\t\tthis.blendIndices = void 0;\n\t\tthis.blendWeights = void 0;\n\t\tthis.tangents = void 0;\n\t\tthis.indices = void 0;\n\t}\n\tcalculateNormals() {\n\t\tthis.normals = calculateNormals(this.positions, this.indices);\n\t}\n\tcalculateTangents() {\n\t\tthis.tangents = calculateTangents(this.positions, this.normals, this.uvs, this.indices);\n\t}\n}\n\nexport { Geometry };\n", "import { Vec3 } from '../../core/math/vec3.js';\nimport { calculateTangents } from './geometry-utils.js';\nimport { Geometry } from './geometry.js';\n\nconst primitiveUv1Padding = 4.0 / 64;\nconst primitiveUv1PaddingScale = 1.0 - primitiveUv1Padding * 2;\nclass BoxGeometry extends Geometry {\n\tconstructor(opts = {}) {\n\t\tvar _opts$halfExtents, _opts$widthSegments, _opts$lengthSegments, _opts$heightSegments, _opts$yOffset;\n\t\tsuper();\n\t\tconst he = (_opts$halfExtents = opts.halfExtents) != null ? _opts$halfExtents : new Vec3(0.5, 0.5, 0.5);\n\t\tconst ws = (_opts$widthSegments = opts.widthSegments) != null ? _opts$widthSegments : 1;\n\t\tconst ls = (_opts$lengthSegments = opts.lengthSegments) != null ? _opts$lengthSegments : 1;\n\t\tconst hs = (_opts$heightSegments = opts.heightSegments) != null ? _opts$heightSegments : 1;\n\t\tconst yOffset = (_opts$yOffset = opts.yOffset) != null ? _opts$yOffset : 0;\n\t\tconst minY = -he.y + yOffset;\n\t\tconst maxY = he.y + yOffset;\n\t\tconst corners = [new Vec3(-he.x, minY, he.z), new Vec3(he.x, minY, he.z), new Vec3(he.x, maxY, he.z), new Vec3(-he.x, maxY, he.z), new Vec3(he.x, minY, -he.z), new Vec3(-he.x, minY, -he.z), new Vec3(-he.x, maxY, -he.z), new Vec3(he.x, maxY, -he.z)];\n\t\tconst faceAxes = [[0, 1, 3], [4, 5, 7], [3, 2, 6], [1, 0, 4], [1, 4, 2], [5, 0, 6]];\n\t\tconst faceNormals = [[0, 0, 1], [0, 0, -1], [0, 1, 0], [0, -1, 0], [1, 0, 0], [-1, 0, 0]];\n\t\tconst sides = {\n\t\t\tFRONT: 0,\n\t\t\tBACK: 1,\n\t\t\tTOP: 2,\n\t\t\tBOTTOM: 3,\n\t\t\tRIGHT: 4,\n\t\t\tLEFT: 5\n\t\t};\n\t\tconst positions = [];\n\t\tconst normals = [];\n\t\tconst uvs = [];\n\t\tconst indices = [];\n\t\tlet vcounter = 0;\n\t\tconst generateFace = (side, uSegments, vSegments) => {\n\t\t\tconst temp1 = new Vec3();\n\t\t\tconst temp2 = new Vec3();\n\t\t\tconst temp3 = new Vec3();\n\t\t\tconst r = new Vec3();\n\t\t\tfor (let i = 0; i <= uSegments; i++) {\n\t\t\t\tfor (let j = 0; j <= vSegments; j++) {\n\t\t\t\t\ttemp1.lerp(corners[faceAxes[side][0]], corners[faceAxes[side][1]], i / uSegments);\n\t\t\t\t\ttemp2.lerp(corners[faceAxes[side][0]], corners[faceAxes[side][2]], j / vSegments);\n\t\t\t\t\ttemp3.sub2(temp2, corners[faceAxes[side][0]]);\n\t\t\t\t\tr.add2(temp1, temp3);\n\t\t\t\t\tlet u = i / uSegments;\n\t\t\t\t\tlet v = j / vSegments;\n\t\t\t\t\tpositions.push(r.x, r.y, r.z);\n\t\t\t\t\tnormals.push(faceNormals[side][0], faceNormals[side][1], faceNormals[side][2]);\n\t\t\t\t\tuvs.push(u, 1 - v);\n\t\t\t\t\tu = u * primitiveUv1PaddingScale + primitiveUv1Padding;\n\t\t\t\t\tv = v * primitiveUv1PaddingScale + primitiveUv1Padding;\n\t\t\t\t\tu /= 3;\n\t\t\t\t\tv /= 3;\n\t\t\t\t\tu += side % 3 / 3;\n\t\t\t\t\tv += Math.floor(side / 3) / 3;\n\t\t\t\t\tif (i < uSegments && j < vSegments) {\n\t\t\t\t\t\tindices.push(vcounter + vSegments + 1, vcounter + 1, vcounter);\n\t\t\t\t\t\tindices.push(vcounter + vSegments + 1, vcounter + vSegments + 2, vcounter + 1);\n\t\t\t\t\t}\n\t\t\t\t\tvcounter++;\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t\tgenerateFace(sides.FRONT, ws, hs);\n\t\tgenerateFace(sides.BACK, ws, hs);\n\t\tgenerateFace(sides.TOP, ws, ls);\n\t\tgenerateFace(sides.BOTTOM, ws, ls);\n\t\tgenerateFace(sides.RIGHT, ls, hs);\n\t\tgenerateFace(sides.LEFT, ls, hs);\n\t\tthis.positions = positions;\n\t\tthis.normals = normals;\n\t\tthis.uvs = uvs;\n\t\tthis.uvs1 = uvs;\n\t\tthis.indices = indices;\n\t\tif (opts.calculateTangents) {\n\t\t\tthis.tangents = calculateTangents(positions, normals, uvs, indices);\n\t\t}\n\t}\n}\n\nexport { BoxGeometry };\n", "import { calculateTangents } from './geometry-utils.js';\nimport { Geometry } from './geometry.js';\n\nclass SphereGeometry extends Geometry {\n\tconstructor(opts = {}) {\n\t\tvar _opts$radius, _opts$latitudeBands, _opts$longitudeBands;\n\t\tsuper();\n\t\tconst radius = (_opts$radius = opts.radius) != null ? _opts$radius : 0.5;\n\t\tconst latitudeBands = (_opts$latitudeBands = opts.latitudeBands) != null ? _opts$latitudeBands : 16;\n\t\tconst longitudeBands = (_opts$longitudeBands = opts.longitudeBands) != null ? _opts$longitudeBands : 16;\n\t\tconst positions = [];\n\t\tconst normals = [];\n\t\tconst uvs = [];\n\t\tconst indices = [];\n\t\tfor (let lat = 0; lat <= latitudeBands; lat++) {\n\t\t\tconst theta = lat * Math.PI / latitudeBands;\n\t\t\tconst sinTheta = Math.sin(theta);\n\t\t\tconst cosTheta = Math.cos(theta);\n\t\t\tfor (let lon = 0; lon <= longitudeBands; lon++) {\n\t\t\t\tconst phi = lon * 2 * Math.PI / longitudeBands - Math.PI / 2;\n\t\t\t\tconst sinPhi = Math.sin(phi);\n\t\t\t\tconst cosPhi = Math.cos(phi);\n\t\t\t\tconst x = cosPhi * sinTheta;\n\t\t\t\tconst y = cosTheta;\n\t\t\t\tconst z = sinPhi * sinTheta;\n\t\t\t\tconst u = 1 - lon / longitudeBands;\n\t\t\t\tconst v = 1 - lat / latitudeBands;\n\t\t\t\tpositions.push(x * radius, y * radius, z * radius);\n\t\t\t\tnormals.push(x, y, z);\n\t\t\t\tuvs.push(u, 1 - v);\n\t\t\t}\n\t\t}\n\t\tfor (let lat = 0; lat < latitudeBands; ++lat) {\n\t\t\tfor (let lon = 0; lon < longitudeBands; ++lon) {\n\t\t\t\tconst first = lat * (longitudeBands + 1) + lon;\n\t\t\t\tconst second = first + longitudeBands + 1;\n\t\t\t\tindices.push(first + 1, second, first);\n\t\t\t\tindices.push(first + 1, second + 1, second);\n\t\t\t}\n\t\t}\n\t\tthis.positions = positions;\n\t\tthis.normals = normals;\n\t\tthis.uvs = uvs;\n\t\tthis.uvs1 = uvs;\n\t\tthis.indices = indices;\n\t\tif (opts.calculateTangents) {\n\t\t\tthis.tangents = calculateTangents(positions, normals, uvs, indices);\n\t\t}\n\t}\n}\n\nexport { SphereGeometry };\n", "import { SphereGeometry } from './sphere-geometry.js';\n\nclass DomeGeometry extends SphereGeometry {\n\tconstructor(opts = {}) {\n\t\tvar _opts$latitudeBands, _opts$longitudeBands;\n\t\tconst radius = 0.5;\n\t\tconst latitudeBands = (_opts$latitudeBands = opts.latitudeBands) != null ? _opts$latitudeBands : 16;\n\t\tconst longitudeBands = (_opts$longitudeBands = opts.longitudeBands) != null ? _opts$longitudeBands : 16;\n\t\tsuper({\n\t\t\tradius,\n\t\t\tlatitudeBands,\n\t\t\tlongitudeBands\n\t\t});\n\t\tconst bottomLimit = 0.1;\n\t\tconst curvatureRadius = 0.95;\n\t\tconst curvatureRadiusSq = curvatureRadius * curvatureRadius;\n\t\tconst positions = this.positions;\n\t\tfor (let i = 0; i < positions.length; i += 3) {\n\t\t\tconst x = positions[i] / radius;\n\t\t\tlet y = positions[i + 1] / radius;\n\t\t\tconst z = positions[i + 2] / radius;\n\t\t\tif (y < 0) {\n\t\t\t\ty *= 0.3;\n\t\t\t\tif (x * x + z * z < curvatureRadiusSq) {\n\t\t\t\t\ty = -bottomLimit;\n\t\t\t\t}\n\t\t\t}\n\t\t\ty += bottomLimit;\n\t\t\ty *= radius;\n\t\t\tpositions[i + 1] = y;\n\t\t}\n\t}\n}\n\nexport { DomeGeometry };\n", "import { SKYTYPE_DOME, SKYTYPE_BOX } from '../constants.js';\nimport { Mesh } from '../mesh.js';\nimport { BoxGeometry } from '../geometry/box-geometry.js';\nimport { DomeGeometry } from '../geometry/dome-geometry.js';\n\nclass SkyGeometry {\n\tstatic create(device, type) {\n\t\tswitch (type) {\n\t\t\tcase SKYTYPE_BOX:\n\t\t\t\treturn SkyGeometry.box(device);\n\t\t\tcase SKYTYPE_DOME:\n\t\t\t\treturn SkyGeometry.dome(device);\n\t\t}\n\t\treturn SkyGeometry.infinite(device);\n\t}\n\tstatic infinite(device) {\n\t\treturn Mesh.fromGeometry(device, new BoxGeometry(device));\n\t}\n\tstatic box(device) {\n\t\treturn Mesh.fromGeometry(device, new BoxGeometry({\n\t\t\tyOffset: 0.5\n\t\t}));\n\t}\n\tstatic dome(device) {\n\t\tconst geom = new DomeGeometry({\n\t\t\tlatitudeBands: 50,\n\t\t\tlongitudeBands: 50\n\t\t});\n\t\tgeom.normals = undefined;\n\t\tgeom.uvs = undefined;\n\t\treturn Mesh.fromGeometry(device, geom);\n\t}\n}\n\nexport { SkyGeometry };\n", "import { CULLFACE_FRONT } from '../../platform/graphics/constants.js';\nimport { ShaderProcessorOptions } from '../../platform/graphics/shader-processor-options.js';\nimport { SHADER_FORWARDHDR, GAMMA_SRGBHDR, GAMMA_NONE, TONEMAP_LINEAR, LAYERID_SKYBOX } from '../constants.js';\nimport { Material } from '../materials/material.js';\nimport { MeshInstance } from '../mesh-instance.js';\nimport { getProgramLibrary } from '../shader-lib/get-program-library.js';\nimport { skybox } from '../shader-lib/programs/skybox.js';\nimport { SkyGeometry } from './sky-geometry.js';\n\nclass SkyMesh {\n\tconstructor(device, scene, node, texture, type) {\n\t\tthis.meshInstance = null;\n\t\tconst material = new Material();\n\t\tmaterial.name = 'SkyMaterial';\n\t\tmaterial.getShaderVariant = function (dev, sc, defs, unused, pass, sortedLights, viewUniformFormat, viewBindGroupFormat) {\n\t\t\tconst options = {\n\t\t\t\tpass: pass,\n\t\t\t\tencoding: texture.encoding,\n\t\t\t\tgamma: pass === SHADER_FORWARDHDR ? scene.gammaCorrection ? GAMMA_SRGBHDR : GAMMA_NONE : scene.gammaCorrection,\n\t\t\t\ttoneMapping: pass === SHADER_FORWARDHDR ? TONEMAP_LINEAR : scene.toneMapping,\n\t\t\t\tskymesh: type\n\t\t\t};\n\t\t\tif (texture.cubemap) {\n\t\t\t\toptions.type = 'cubemap';\n\t\t\t\toptions.mip = texture.fixCubemapSeams ? scene.skyboxMip : 0;\n\t\t\t\toptions.fixSeams = texture.fixCubemapSeams;\n\t\t\t} else {\n\t\t\t\toptions.type = 'envAtlas';\n\t\t\t}\n\t\t\tconst processingOptions = new ShaderProcessorOptions(viewUniformFormat, viewBindGroupFormat);\n\t\t\tconst library = getProgramLibrary(device);\n\t\t\tlibrary.register('skybox', skybox);\n\t\t\treturn library.getProgram('skybox', options, processingOptions);\n\t\t};\n\t\tif (texture.cubemap) {\n\t\t\tmaterial.setParameter('texture_cubeMap', texture);\n\t\t} else {\n\t\t\tmaterial.setParameter('texture_envAtlas', texture);\n\t\t\tmaterial.setParameter('mipLevel', scene._skyboxMip);\n\t\t}\n\t\tmaterial.cull = CULLFACE_FRONT;\n\t\tmaterial.depthWrite = false;\n\t\tconst skyLayer = scene.layers.getLayerById(LAYERID_SKYBOX);\n\t\tif (skyLayer) {\n\t\t\tconst mesh = SkyGeometry.create(device, type);\n\t\t\tconst meshInstance = new MeshInstance(mesh, material, node);\n\t\t\tthis.meshInstance = meshInstance;\n\t\t\tmeshInstance.cull = false;\n\t\t\tmeshInstance.pick = false;\n\t\t\tskyLayer.addMeshInstances([meshInstance]);\n\t\t\tthis.skyLayer = skyLayer;\n\t\t}\n\t}\n\tdestroy() {\n\t\tif (this.meshInstance) {\n\t\t\tif (this.skyLayer) {\n\t\t\t\tthis.skyLayer.removeMeshInstances([this.meshInstance]);\n\t\t\t}\n\t\t\tthis.meshInstance.destroy();\n\t\t\tthis.meshInstance = null;\n\t\t}\n\t}\n}\n\nexport { SkyMesh };\n", "import { Vec3 } from '../../core/math/vec3.js';\nimport { SKYTYPE_INFINITE } from '../constants.js';\nimport { GraphNode } from '../graph-node.js';\nimport { SkyMesh } from './sky-mesh.js';\n\nclass Sky {\n\tconstructor(scene) {\n\t\tthis._type = SKYTYPE_INFINITE;\n\t\tthis._center = new Vec3(0, 1, 0);\n\t\tthis.skyMesh = null;\n\t\tthis.node = new GraphNode('SkyMeshNode');\n\t\tthis.device = scene.device;\n\t\tthis.scene = scene;\n\t\tthis.center = new Vec3(0, 1, 0);\n\t\tthis.centerArray = new Float32Array(3);\n\t\tthis.projectedSkydomeCenterId = this.device.scope.resolve('projectedSkydomeCenter');\n\t}\n\tapplySettings(render) {\n\t\tvar _render$skyType, _render$skyMeshPositi, _render$skyMeshRotati, _render$skyMeshScale;\n\t\tthis.type = (_render$skyType = render.skyType) != null ? _render$skyType : SKYTYPE_INFINITE;\n\t\tthis.node.setLocalPosition(new Vec3((_render$skyMeshPositi = render.skyMeshPosition) != null ? _render$skyMeshPositi : [0, 0, 0]));\n\t\tthis.node.setLocalEulerAngles(new Vec3((_render$skyMeshRotati = render.skyMeshRotation) != null ? _render$skyMeshRotati : [0, 0, 0]));\n\t\tthis.node.setLocalScale(new Vec3((_render$skyMeshScale = render.skyMeshScale) != null ? _render$skyMeshScale : [1, 1, 1]));\n\t\tif (render.skyCenter) {\n\t\t\tthis._center = new Vec3(render.skyCenter);\n\t\t}\n\t}\n\tset type(value) {\n\t\tif (this._type !== value) {\n\t\t\tthis._type = value;\n\t\t\tthis.scene.updateShaders = true;\n\t\t\tthis.updateSkyMesh();\n\t\t}\n\t}\n\tget type() {\n\t\treturn this._type;\n\t}\n\tset center(value) {\n\t\tthis._center.copy(value);\n\t}\n\tget center() {\n\t\treturn this._center;\n\t}\n\tupdateSkyMesh() {\n\t\tconst texture = this.scene._getSkyboxTex();\n\t\tif (texture) {\n\t\t\tthis.resetSkyMesh();\n\t\t\tthis.skyMesh = new SkyMesh(this.device, this.scene, this.node, texture, this.type);\n\t\t\tthis.scene.fire('set:skybox', texture);\n\t\t}\n\t}\n\tresetSkyMesh() {\n\t\tvar _this$skyMesh;\n\t\t(_this$skyMesh = this.skyMesh) == null || _this$skyMesh.destroy();\n\t\tthis.skyMesh = null;\n\t}\n\tupdate() {\n\t\tif (this.type !== SKYTYPE_INFINITE) {\n\t\t\tconst {\n\t\t\t\tcenter,\n\t\t\t\tcenterArray\n\t\t\t} = this;\n\t\t\tconst temp = new Vec3();\n\t\t\tthis.node.getWorldTransform().transformPoint(center, temp);\n\t\t\tcenterArray[0] = temp.x;\n\t\t\tcenterArray[1] = temp.y;\n\t\t\tcenterArray[2] = temp.z;\n\t\t\tthis.projectedSkydomeCenterId.setValue(centerArray);\n\t\t}\n\t}\n}\n\nexport { Sky };\n", "import { Mat4 } from '../../core/math/mat4.js';\nimport { PRIMITIVE_LINES } from '../../platform/graphics/constants.js';\nimport { Mesh } from '../mesh.js';\nimport { MeshInstance } from '../mesh-instance.js';\nimport { GraphNode } from '../graph-node.js';\n\nconst identityGraphNode = new GraphNode();\nidentityGraphNode.worldTransform = Mat4.IDENTITY;\nidentityGraphNode._dirtyWorld = identityGraphNode._dirtyNormal = false;\nclass ImmediateBatch {\n\tconstructor(device, material, layer) {\n\t\tthis.material = material;\n\t\tthis.layer = layer;\n\t\tthis.positions = [];\n\t\tthis.colors = [];\n\t\tthis.mesh = new Mesh(device);\n\t\tthis.meshInstance = null;\n\t}\n\taddLines(positions, color) {\n\t\tconst destPos = this.positions;\n\t\tconst count = positions.length;\n\t\tfor (let i = 0; i < count; i++) {\n\t\t\tconst pos = positions[i];\n\t\t\tdestPos.push(pos.x, pos.y, pos.z);\n\t\t}\n\t\tconst destCol = this.colors;\n\t\tif (color.length) {\n\t\t\tfor (let i = 0; i < count; i++) {\n\t\t\t\tconst col = color[i];\n\t\t\t\tdestCol.push(col.r, col.g, col.b, col.a);\n\t\t\t}\n\t\t} else {\n\t\t\tfor (let i = 0; i < count; i++) {\n\t\t\t\tdestCol.push(color.r, color.g, color.b, color.a);\n\t\t\t}\n\t\t}\n\t}\n\taddLinesArrays(positions, color) {\n\t\tconst destPos = this.positions;\n\t\tfor (let i = 0; i < positions.length; i += 3) {\n\t\t\tdestPos.push(positions[i], positions[i + 1], positions[i + 2]);\n\t\t}\n\t\tconst destCol = this.colors;\n\t\tif (color.length) {\n\t\t\tfor (let i = 0; i < color.length; i += 4) {\n\t\t\t\tdestCol.push(color[i], color[i + 1], color[i + 2], color[i + 3]);\n\t\t\t}\n\t\t} else {\n\t\t\tconst count = positions.length / 3;\n\t\t\tfor (let i = 0; i < count; i++) {\n\t\t\t\tdestCol.push(color.r, color.g, color.b, color.a);\n\t\t\t}\n\t\t}\n\t}\n\tonPreRender(visibleList, transparent) {\n\t\tif (this.positions.length > 0 && this.material.transparent === transparent) {\n\t\t\tthis.mesh.setPositions(this.positions);\n\t\t\tthis.mesh.setColors(this.colors);\n\t\t\tthis.mesh.update(PRIMITIVE_LINES, false);\n\t\t\tif (!this.meshInstance) {\n\t\t\t\tthis.meshInstance = new MeshInstance(this.mesh, this.material, identityGraphNode);\n\t\t\t}\n\t\t\tvisibleList.push(this.meshInstance);\n\t\t}\n\t}\n\tclear() {\n\t\tthis.positions.length = 0;\n\t\tthis.colors.length = 0;\n\t}\n}\n\nexport { ImmediateBatch };\n", "import { ImmediateBatch } from './immediate-batch.js';\n\nclass ImmediateBatches {\n\tconstructor(device) {\n\t\tthis.device = device;\n\t\tthis.map = new Map();\n\t}\n\tgetBatch(material, layer) {\n\t\tlet batch = this.map.get(material);\n\t\tif (!batch) {\n\t\t\tbatch = new ImmediateBatch(this.device, material, layer);\n\t\t\tthis.map.set(material, batch);\n\t\t}\n\t\treturn batch;\n\t}\n\tonPreRender(visibleList, transparent) {\n\t\tthis.map.forEach(batch => {\n\t\t\tbatch.onPreRender(visibleList, transparent);\n\t\t});\n\t}\n\tclear() {\n\t\tthis.map.forEach(batch => batch.clear());\n\t}\n}\n\nexport { ImmediateBatches };\n", "import { PRIMITIVE_TRISTRIP } from '../../platform/graphics/constants.js';\nimport { BLEND_NORMAL } from '../constants.js';\nimport { GraphNode } from '../graph-node.js';\nimport { Mesh } from '../mesh.js';\nimport { MeshInstance } from '../mesh-instance.js';\nimport { BasicMaterial } from '../materials/basic-material.js';\nimport { createShaderFromCode } from '../shader-lib/utils.js';\nimport { shaderChunks } from '../shader-lib/chunks/chunks.js';\nimport { ImmediateBatches } from './immediate-batches.js';\nimport { Vec3 } from '../../core/math/vec3.js';\n\nconst tempPoints = [];\nconst vec = new Vec3();\nclass Immediate {\n\tconstructor(device) {\n\t\tthis.device = device;\n\t\tthis.quadMesh = null;\n\t\tthis.textureShader = null;\n\t\tthis.depthTextureShader = null;\n\t\tthis.cubeLocalPos = null;\n\t\tthis.cubeWorldPos = null;\n\t\tthis.batchesMap = new Map();\n\t\tthis.allBatches = new Set();\n\t\tthis.updatedLayers = new Set();\n\t\tthis._materialDepth = null;\n\t\tthis._materialNoDepth = null;\n\t\tthis.layerMeshInstances = new Map();\n\t}\n\tcreateMaterial(depthTest) {\n\t\tconst material = new BasicMaterial();\n\t\tmaterial.vertexColors = true;\n\t\tmaterial.blendType = BLEND_NORMAL;\n\t\tmaterial.depthTest = depthTest;\n\t\tmaterial.update();\n\t\treturn material;\n\t}\n\tget materialDepth() {\n\t\tif (!this._materialDepth) {\n\t\t\tthis._materialDepth = this.createMaterial(true);\n\t\t}\n\t\treturn this._materialDepth;\n\t}\n\tget materialNoDepth() {\n\t\tif (!this._materialNoDepth) {\n\t\t\tthis._materialNoDepth = this.createMaterial(false);\n\t\t}\n\t\treturn this._materialNoDepth;\n\t}\n\tgetBatch(layer, depthTest) {\n\t\tlet batches = this.batchesMap.get(layer);\n\t\tif (!batches) {\n\t\t\tbatches = new ImmediateBatches(this.device);\n\t\t\tthis.batchesMap.set(layer, batches);\n\t\t}\n\t\tthis.allBatches.add(batches);\n\t\tconst material = depthTest ? this.materialDepth : this.materialNoDepth;\n\t\treturn batches.getBatch(material, layer);\n\t}\n\tgetShader(id, fragment) {\n\t\tif (!this[id]) {\n\t\t\tconst vertex = `\n\t\t\t\tattribute vec2 vertex_position;\n\t\t\t\tuniform mat4 matrix_model;\n\t\t\t\tvarying vec2 uv0;\n\t\t\t\tvoid main(void) {\n\t\t\t\t\tgl_Position = matrix_model * vec4(vertex_position, 0, 1);\n\t\t\t\t\tuv0 = vertex_position.xy + 0.5;\n\t\t\t\t}\n\t\t\t`;\n\t\t\tthis[id] = createShaderFromCode(this.device, vertex, fragment, `DebugShader:${id}`);\n\t\t}\n\t\treturn this[id];\n\t}\n\tgetTextureShader() {\n\t\treturn this.getShader('textureShader', `\n\t\t\tvarying vec2 uv0;\n\t\t\tuniform sampler2D colorMap;\n\t\t\tvoid main (void) {\n\t\t\t\tgl_FragColor = vec4(texture2D(colorMap, uv0).xyz, 1);\n\t\t\t}\n\t\t`);\n\t}\n\tgetUnfilterableTextureShader() {\n\t\treturn this.getShader('textureShaderUnfilterable', `\n\t\t\tvarying vec2 uv0;\n\t\t\tuniform highp sampler2D colorMap;\n\t\t\tvoid main (void) {\n\t\t\t\tivec2 uv = ivec2(uv0 * textureSize(colorMap, 0));\n\t\t\t\tgl_FragColor = vec4(texelFetch(colorMap, uv, 0).xyz, 1);\n\t\t\t}\n\t\t`);\n\t}\n\tgetDepthTextureShader() {\n\t\treturn this.getShader('depthTextureShader', `\n\t\t\t${shaderChunks.screenDepthPS}\n\t\t\tvarying vec2 uv0;\n\t\t\tvoid main() {\n\t\t\t\tfloat depth = getLinearScreenDepth(getImageEffectUV(uv0)) * camera_params.x;\n\t\t\t\tgl_FragColor = vec4(vec3(depth), 1.0);\n\t\t\t}\n\t\t`);\n\t}\n\tgetQuadMesh() {\n\t\tif (!this.quadMesh) {\n\t\t\tthis.quadMesh = new Mesh(this.device);\n\t\t\tthis.quadMesh.setPositions([-0.5, -0.5, 0, 0.5, -0.5, 0, -0.5, 0.5, 0, 0.5, 0.5, 0]);\n\t\t\tthis.quadMesh.update(PRIMITIVE_TRISTRIP);\n\t\t}\n\t\treturn this.quadMesh;\n\t}\n\tdrawMesh(material, matrix, mesh, meshInstance, layer) {\n\t\tif (!meshInstance) {\n\t\t\tconst graphNode = this.getGraphNode(matrix);\n\t\t\tmeshInstance = new MeshInstance(mesh, material, graphNode);\n\t\t}\n\t\tlet layerMeshInstances = this.layerMeshInstances.get(layer);\n\t\tif (!layerMeshInstances) {\n\t\t\tlayerMeshInstances = [];\n\t\t\tthis.layerMeshInstances.set(layer, layerMeshInstances);\n\t\t}\n\t\tlayerMeshInstances.push(meshInstance);\n\t}\n\tdrawWireAlignedBox(min, max, color, depthTest, layer, mat) {\n\t\tif (mat) {\n\t\t\tconst mulPoint = (x, y, z) => {\n\t\t\t\tvec.set(x, y, z);\n\t\t\t\tmat.transformPoint(vec, vec);\n\t\t\t\ttempPoints.push(vec.x, vec.y, vec.z);\n\t\t\t};\n\t\t\tmulPoint(min.x, min.y, min.z);\n\t\t\tmulPoint(min.x, max.y, min.z);\n\t\t\tmulPoint(min.x, max.y, min.z);\n\t\t\tmulPoint(max.x, max.y, min.z);\n\t\t\tmulPoint(max.x, max.y, min.z);\n\t\t\tmulPoint(max.x, min.y, min.z);\n\t\t\tmulPoint(max.x, min.y, min.z);\n\t\t\tmulPoint(min.x, min.y, min.z);\n\t\t\tmulPoint(min.x, min.y, max.z);\n\t\t\tmulPoint(min.x, max.y, max.z);\n\t\t\tmulPoint(min.x, max.y, max.z);\n\t\t\tmulPoint(max.x, max.y, max.z);\n\t\t\tmulPoint(max.x, max.y, max.z);\n\t\t\tmulPoint(max.x, min.y, max.z);\n\t\t\tmulPoint(max.x, min.y, max.z);\n\t\t\tmulPoint(min.x, min.y, max.z);\n\t\t\tmulPoint(min.x, min.y, min.z);\n\t\t\tmulPoint(min.x, min.y, max.z);\n\t\t\tmulPoint(min.x, max.y, min.z);\n\t\t\tmulPoint(min.x, max.y, max.z);\n\t\t\tmulPoint(max.x, max.y, min.z);\n\t\t\tmulPoint(max.x, max.y, max.z);\n\t\t\tmulPoint(max.x, min.y, min.z);\n\t\t\tmulPoint(max.x, min.y, max.z);\n\t\t} else {\n\t\t\ttempPoints.push(min.x, min.y, min.z, min.x, max.y, min.z, min.x, max.y, min.z, max.x, max.y, min.z, max.x, max.y, min.z, max.x, min.y, min.z, max.x, min.y, min.z, min.x, min.y, min.z, min.x, min.y, max.z, min.x, max.y, max.z, min.x, max.y, max.z, max.x, max.y, max.z, max.x, max.y, max.z, max.x, min.y, max.z, max.x, min.y, max.z, min.x, min.y, max.z, min.x, min.y, min.z, min.x, min.y, max.z, min.x, max.y, min.z, min.x, max.y, max.z, max.x, max.y, min.z, max.x, max.y, max.z, max.x, min.y, min.z, max.x, min.y, max.z);\n\t\t}\n\t\tconst batch = this.getBatch(layer, depthTest);\n\t\tbatch.addLinesArrays(tempPoints, color);\n\t\ttempPoints.length = 0;\n\t}\n\tdrawWireSphere(center, radius, color, numSegments, depthTest, layer) {\n\t\tconst step = 2 * Math.PI / numSegments;\n\t\tlet angle = 0;\n\t\tfor (let i = 0; i < numSegments; i++) {\n\t\t\tconst sin0 = Math.sin(angle);\n\t\t\tconst cos0 = Math.cos(angle);\n\t\t\tangle += step;\n\t\t\tconst sin1 = Math.sin(angle);\n\t\t\tconst cos1 = Math.cos(angle);\n\t\t\ttempPoints.push(center.x + radius * sin0, center.y, center.z + radius * cos0);\n\t\t\ttempPoints.push(center.x + radius * sin1, center.y, center.z + radius * cos1);\n\t\t\ttempPoints.push(center.x + radius * sin0, center.y + radius * cos0, center.z);\n\t\t\ttempPoints.push(center.x + radius * sin1, center.y + radius * cos1, center.z);\n\t\t\ttempPoints.push(center.x, center.y + radius * sin0, center.z + radius * cos0);\n\t\t\ttempPoints.push(center.x, center.y + radius * sin1, center.z + radius * cos1);\n\t\t}\n\t\tconst batch = this.getBatch(layer, depthTest);\n\t\tbatch.addLinesArrays(tempPoints, color);\n\t\ttempPoints.length = 0;\n\t}\n\tgetGraphNode(matrix) {\n\t\tconst graphNode = new GraphNode('ImmediateDebug');\n\t\tgraphNode.worldTransform = matrix;\n\t\tgraphNode._dirtyWorld = graphNode._dirtyNormal = false;\n\t\treturn graphNode;\n\t}\n\tonPreRenderLayer(layer, visibleList, transparent) {\n\t\tthis.batchesMap.forEach((batches, batchLayer) => {\n\t\t\tif (batchLayer === layer) {\n\t\t\t\tbatches.onPreRender(visibleList, transparent);\n\t\t\t}\n\t\t});\n\t\tif (!this.updatedLayers.has(layer)) {\n\t\t\tthis.updatedLayers.add(layer);\n\t\t\tconst meshInstances = this.layerMeshInstances.get(layer);\n\t\t\tif (meshInstances) {\n\t\t\t\tfor (let i = 0; i < meshInstances.length; i++) {\n\t\t\t\t\tvisibleList.push(meshInstances[i]);\n\t\t\t\t}\n\t\t\t\tmeshInstances.length = 0;\n\t\t\t}\n\t\t}\n\t}\n\tonPostRender() {\n\t\tthis.allBatches.forEach(batch => batch.clear());\n\t\tthis.allBatches.clear();\n\t\tthis.updatedLayers.clear();\n\t}\n}\n\nexport { Immediate };\n", "import { math } from './math.js';\n\nconst _goldenAngle = 2.399963229728653;\nconst random = {\n\tcirclePoint(point) {\n\t\tconst r = Math.sqrt(Math.random());\n\t\tconst theta = Math.random() * 2 * Math.PI;\n\t\tpoint.x = r * Math.cos(theta);\n\t\tpoint.y = r * Math.sin(theta);\n\t},\n\tcirclePointDeterministic(point, index, numPoints) {\n\t\tconst theta = index * _goldenAngle;\n\t\tconst r = Math.sqrt(index) / Math.sqrt(numPoints);\n\t\tpoint.x = r * Math.cos(theta);\n\t\tpoint.y = r * Math.sin(theta);\n\t},\n\tspherePointDeterministic(point, index, numPoints, start = 0, end = 1) {\n\t\tstart = 1 - 2 * start;\n\t\tend = 1 - 2 * end;\n\t\tconst y = math.lerp(start, end, index / numPoints);\n\t\tconst radius = Math.sqrt(1 - y * y);\n\t\tconst theta = _goldenAngle * index;\n\t\tpoint.x = Math.cos(theta) * radius;\n\t\tpoint.y = y;\n\t\tpoint.z = Math.sin(theta) * radius;\n\t},\n\tradicalInverse(i) {\n\t\tlet bits = (i << 16 | i >>> 16) >>> 0;\n\t\tbits = ((bits & 0x55555555) << 1 | (bits & 0xAAAAAAAA) >>> 1) >>> 0;\n\t\tbits = ((bits & 0x33333333) << 2 | (bits & 0xCCCCCCCC) >>> 2) >>> 0;\n\t\tbits = ((bits & 0x0F0F0F0F) << 4 | (bits & 0xF0F0F0F0) >>> 4) >>> 0;\n\t\tbits = ((bits & 0x00FF00FF) << 8 | (bits & 0xFF00FF00) >>> 8) >>> 0;\n\t\treturn bits * 2.3283064365386963e-10;\n\t}\n};\n\nexport { random };\n", "import { random } from '../../core/math/random.js';\nimport { Vec3 } from '../../core/math/vec3.js';\nimport { TEXTUREPROJECTION_OCTAHEDRAL, TEXTUREPROJECTION_CUBE, FILTER_NEAREST } from '../../platform/graphics/constants.js';\nimport { DeviceCache } from '../../platform/graphics/device-cache.js';\nimport { GraphicsDevice } from '../../platform/graphics/graphics-device.js';\nimport { RenderTarget } from '../../platform/graphics/render-target.js';\nimport { drawQuadWithShader } from './quad-render-utils.js';\nimport { Texture } from '../../platform/graphics/texture.js';\nimport { ChunkUtils } from '../shader-lib/chunk-utils.js';\nimport { shaderChunks } from '../shader-lib/chunks/chunks.js';\nimport { getProgramLibrary } from '../shader-lib/get-program-library.js';\nimport { createShaderFromCode } from '../shader-lib/utils.js';\nimport { BlendState } from '../../platform/graphics/blend-state.js';\n\nconst getProjectionName = projection => {\n\tswitch (projection) {\n\t\tcase TEXTUREPROJECTION_CUBE:\n\t\t\treturn \"Cubemap\";\n\t\tcase TEXTUREPROJECTION_OCTAHEDRAL:\n\t\t\treturn \"Octahedral\";\n\t\tdefault:\n\t\t\treturn \"Equirect\";\n\t}\n};\nconst packFloat32ToRGBA8 = (value, array, offset) => {\n\tif (value <= 0) {\n\t\tarray[offset + 0] = 0;\n\t\tarray[offset + 1] = 0;\n\t\tarray[offset + 2] = 0;\n\t\tarray[offset + 3] = 0;\n\t} else if (value >= 1.0) {\n\t\tarray[offset + 0] = 255;\n\t\tarray[offset + 1] = 0;\n\t\tarray[offset + 2] = 0;\n\t\tarray[offset + 3] = 0;\n\t} else {\n\t\tlet encX = 1 * value % 1;\n\t\tlet encY = 255 * value % 1;\n\t\tlet encZ = 65025 * value % 1;\n\t\tconst encW = 16581375.0 * value % 1;\n\t\tencX -= encY / 255;\n\t\tencY -= encZ / 255;\n\t\tencZ -= encW / 255;\n\t\tarray[offset + 0] = Math.min(255, Math.floor(encX * 256));\n\t\tarray[offset + 1] = Math.min(255, Math.floor(encY * 256));\n\t\tarray[offset + 2] = Math.min(255, Math.floor(encZ * 256));\n\t\tarray[offset + 3] = Math.min(255, Math.floor(encW * 256));\n\t}\n};\nconst packSamples = samples => {\n\tconst numSamples = samples.length;\n\tconst w = Math.min(numSamples, 512);\n\tconst h = Math.ceil(numSamples / w);\n\tconst data = new Uint8Array(w * h * 4);\n\tlet off = 0;\n\tfor (let i = 0; i < numSamples; i += 4) {\n\t\tpackFloat32ToRGBA8(samples[i + 0] * 0.5 + 0.5, data, off + 0);\n\t\tpackFloat32ToRGBA8(samples[i + 1] * 0.5 + 0.5, data, off + 4);\n\t\tpackFloat32ToRGBA8(samples[i + 2] * 0.5 + 0.5, data, off + 8);\n\t\tpackFloat32ToRGBA8(samples[i + 3] / 8, data, off + 12);\n\t\toff += 16;\n\t}\n\treturn {\n\t\twidth: w,\n\t\theight: h,\n\t\tdata: data\n\t};\n};\nconst hemisphereSamplePhong = (dstVec, x, y, specularPower) => {\n\tconst phi = y * 2 * Math.PI;\n\tconst cosTheta = Math.pow(1 - x, 1 / (specularPower + 1));\n\tconst sinTheta = Math.sqrt(1 - cosTheta * cosTheta);\n\tdstVec.set(Math.cos(phi) * sinTheta, Math.sin(phi) * sinTheta, cosTheta).normalize();\n};\nconst hemisphereSampleLambert = (dstVec, x, y) => {\n\tconst phi = y * 2 * Math.PI;\n\tconst cosTheta = Math.sqrt(1 - x);\n\tconst sinTheta = Math.sqrt(x);\n\tdstVec.set(Math.cos(phi) * sinTheta, Math.sin(phi) * sinTheta, cosTheta).normalize();\n};\nconst hemisphereSampleGGX = (dstVec, x, y, a) => {\n\tconst phi = y * 2 * Math.PI;\n\tconst cosTheta = Math.sqrt((1 - x) / (1 + (a * a - 1) * x));\n\tconst sinTheta = Math.sqrt(1 - cosTheta * cosTheta);\n\tdstVec.set(Math.cos(phi) * sinTheta, Math.sin(phi) * sinTheta, cosTheta).normalize();\n};\nconst D_GGX = (NoH, linearRoughness) => {\n\tconst a = NoH * linearRoughness;\n\tconst k = linearRoughness / (1.0 - NoH * NoH + a * a);\n\treturn k * k * (1 / Math.PI);\n};\nconst generatePhongSamples = (numSamples, specularPower) => {\n\tconst H = new Vec3();\n\tconst result = [];\n\tfor (let i = 0; i < numSamples; ++i) {\n\t\themisphereSamplePhong(H, i / numSamples, random.radicalInverse(i), specularPower);\n\t\tresult.push(H.x, H.y, H.z, 0);\n\t}\n\treturn result;\n};\nconst generateLambertSamples = (numSamples, sourceTotalPixels) => {\n\tconst pixelsPerSample = sourceTotalPixels / numSamples;\n\tconst H = new Vec3();\n\tconst result = [];\n\tfor (let i = 0; i < numSamples; ++i) {\n\t\themisphereSampleLambert(H, i / numSamples, random.radicalInverse(i));\n\t\tconst pdf = H.z / Math.PI;\n\t\tconst mipLevel = 0.5 * Math.log2(pixelsPerSample / pdf);\n\t\tresult.push(H.x, H.y, H.z, mipLevel);\n\t}\n\treturn result;\n};\nconst requiredSamplesGGX = {\n\t\"16\": {\n\t\t\"2\": 26,\n\t\t\"8\": 20,\n\t\t\"32\": 17,\n\t\t\"128\": 16,\n\t\t\"512\": 16\n\t},\n\t\"32\": {\n\t\t\"2\": 53,\n\t\t\"8\": 40,\n\t\t\"32\": 34,\n\t\t\"128\": 32,\n\t\t\"512\": 32\n\t},\n\t\"128\": {\n\t\t\"2\": 214,\n\t\t\"8\": 163,\n\t\t\"32\": 139,\n\t\t\"128\": 130,\n\t\t\"512\": 128\n\t},\n\t\"1024\": {\n\t\t\"2\": 1722,\n\t\t\"8\": 1310,\n\t\t\"32\": 1114,\n\t\t\"128\": 1041,\n\t\t\"512\": 1025\n\t}\n};\nconst getRequiredSamplesGGX = (numSamples, specularPower) => {\n\tconst table = requiredSamplesGGX[numSamples];\n\treturn table && table[specularPower] || numSamples;\n};\nconst generateGGXSamples = (numSamples, specularPower, sourceTotalPixels) => {\n\tconst pixelsPerSample = sourceTotalPixels / numSamples;\n\tconst roughness = 1 - Math.log2(specularPower) / 11.0;\n\tconst a = roughness * roughness;\n\tconst H = new Vec3();\n\tconst L = new Vec3();\n\tconst N = new Vec3(0, 0, 1);\n\tconst result = [];\n\tconst requiredSamples = getRequiredSamplesGGX(numSamples, specularPower);\n\tfor (let i = 0; i < requiredSamples; ++i) {\n\t\themisphereSampleGGX(H, i / requiredSamples, random.radicalInverse(i), a);\n\t\tconst NoH = H.z;\n\t\tL.set(H.x, H.y, H.z).mulScalar(2 * NoH).sub(N);\n\t\tif (L.z > 0) {\n\t\t\tconst pdf = D_GGX(Math.min(1, NoH), a) / 4 + 0.001;\n\t\t\tconst mipLevel = 0.5 * Math.log2(pixelsPerSample / pdf);\n\t\t\tresult.push(L.x, L.y, L.z, mipLevel);\n\t\t}\n\t}\n\twhile (result.length < numSamples * 4) {\n\t\tresult.push(0, 0, 0, 0);\n\t}\n\treturn result;\n};\nconst createSamplesTex = (device, name, samples) => {\n\tconst packedSamples = packSamples(samples);\n\treturn new Texture(device, {\n\t\tname: name,\n\t\twidth: packedSamples.width,\n\t\theight: packedSamples.height,\n\t\tmipmaps: false,\n\t\tminFilter: FILTER_NEAREST,\n\t\tmagFilter: FILTER_NEAREST,\n\t\tlevels: [packedSamples.data]\n\t});\n};\nclass SimpleCache {\n\tconstructor(destroyContent = true) {\n\t\tthis.map = new Map();\n\t\tthis.destroyContent = destroyContent;\n\t}\n\tdestroy() {\n\t\tif (this.destroyContent) {\n\t\t\tthis.map.forEach((value, key) => {\n\t\t\t\tvalue.destroy();\n\t\t\t});\n\t\t}\n\t}\n\tget(key, missFunc) {\n\t\tif (!this.map.has(key)) {\n\t\t\tconst result = missFunc();\n\t\t\tthis.map.set(key, result);\n\t\t\treturn result;\n\t\t}\n\t\treturn this.map.get(key);\n\t}\n}\nconst samplesCache = new SimpleCache(false);\nconst deviceCache = new DeviceCache();\nconst getCachedTexture = (device, key, getSamplesFnc) => {\n\tconst cache = deviceCache.get(device, () => {\n\t\treturn new SimpleCache();\n\t});\n\treturn cache.get(key, () => {\n\t\treturn createSamplesTex(device, key, samplesCache.get(key, getSamplesFnc));\n\t});\n};\nconst generateLambertSamplesTex = (device, numSamples, sourceTotalPixels) => {\n\tconst key = `lambert-samples-${numSamples}-${sourceTotalPixels}`;\n\treturn getCachedTexture(device, key, () => {\n\t\treturn generateLambertSamples(numSamples, sourceTotalPixels);\n\t});\n};\nconst generatePhongSamplesTex = (device, numSamples, specularPower) => {\n\tconst key = `phong-samples-${numSamples}-${specularPower}`;\n\treturn getCachedTexture(device, key, () => {\n\t\treturn generatePhongSamples(numSamples, specularPower);\n\t});\n};\nconst generateGGXSamplesTex = (device, numSamples, specularPower, sourceTotalPixels) => {\n\tconst key = `ggx-samples-${numSamples}-${specularPower}-${sourceTotalPixels}`;\n\treturn getCachedTexture(device, key, () => {\n\t\treturn generateGGXSamples(numSamples, specularPower, sourceTotalPixels);\n\t});\n};\nconst vsCode = `\nattribute vec2 vertex_position;\n\nuniform vec4 uvMod;\n\nvarying vec2 vUv0;\n\nvoid main(void) {\n\t\tgl_Position = vec4(vertex_position, 0.5, 1.0);\n\t\tvUv0 = getImageEffectUV((vertex_position.xy * 0.5 + 0.5) * uvMod.xy + uvMod.zw);\n}\n`;\nfunction reprojectTexture(source, target, options = {}) {\n\tvar _options$seamPixels, _options$rect$z, _options$rect, _options$rect$w, _options$rect2;\n\tif (source instanceof GraphicsDevice) {\n\t\tsource = arguments[1];\n\t\ttarget = arguments[2];\n\t\toptions = {};\n\t\tif (arguments[3] !== undefined) {\n\t\t\toptions.specularPower = arguments[3];\n\t\t}\n\t\tif (arguments[4] !== undefined) {\n\t\t\toptions.numSamples = arguments[4];\n\t\t}\n\t}\n\tconst seamPixels = (_options$seamPixels = options.seamPixels) != null ? _options$seamPixels : 0;\n\tconst innerWidth = ((_options$rect$z = (_options$rect = options.rect) == null ? void 0 : _options$rect.z) != null ? _options$rect$z : target.width) - seamPixels * 2;\n\tconst innerHeight = ((_options$rect$w = (_options$rect2 = options.rect) == null ? void 0 : _options$rect2.w) != null ? _options$rect$w : target.height) - seamPixels * 2;\n\tif (innerWidth < 1 || innerHeight < 1) {\n\t\treturn false;\n\t}\n\tconst funcNames = {\n\t\t'none': 'reproject',\n\t\t'lambert': 'prefilterSamplesUnweighted',\n\t\t'phong': 'prefilterSamplesUnweighted',\n\t\t'ggx': 'prefilterSamples'\n\t};\n\tconst specularPower = options.hasOwnProperty('specularPower') ? options.specularPower : 1;\n\tconst face = options.hasOwnProperty('face') ? options.face : null;\n\tconst distribution = options.hasOwnProperty('distribution') ? options.distribution : specularPower === 1 ? 'none' : 'phong';\n\tconst processFunc = funcNames[distribution] || 'reproject';\n\tconst prefilterSamples = processFunc.startsWith('prefilterSamples');\n\tconst decodeFunc = ChunkUtils.decodeFunc(source.encoding);\n\tconst encodeFunc = ChunkUtils.encodeFunc(target.encoding);\n\tconst sourceFunc = `sample${getProjectionName(source.projection)}`;\n\tconst targetFunc = `getDirection${getProjectionName(target.projection)}`;\n\tconst numSamples = options.hasOwnProperty('numSamples') ? options.numSamples : 1024;\n\tconst shaderKey = `${processFunc}_${decodeFunc}_${encodeFunc}_${sourceFunc}_${targetFunc}_${numSamples}`;\n\tconst device = source.device;\n\tlet shader = getProgramLibrary(device).getCachedShader(shaderKey);\n\tif (!shader) {\n\t\tconst defines = `#define PROCESS_FUNC ${processFunc}\\n` + (prefilterSamples ? `#define USE_SAMPLES_TEX\\n` : '') + (source.cubemap ? `#define CUBEMAP_SOURCE\\n` : '') + `#define DECODE_FUNC ${decodeFunc}\\n` + `#define ENCODE_FUNC ${encodeFunc}\\n` + `#define SOURCE_FUNC ${sourceFunc}\\n` + `#define TARGET_FUNC ${targetFunc}\\n` + `#define NUM_SAMPLES ${numSamples}\\n` + `#define NUM_SAMPLES_SQRT ${Math.round(Math.sqrt(numSamples)).toFixed(1)}\\n`;\n\t\tshader = createShaderFromCode(device, vsCode, `${defines}\\n${shaderChunks.reprojectPS}`, shaderKey);\n\t}\n\tdevice.setBlendState(BlendState.NOBLEND);\n\tconst constantSource = device.scope.resolve(source.cubemap ? \"sourceCube\" : \"sourceTex\");\n\tconstantSource.setValue(source);\n\tconst constantParams = device.scope.resolve(\"params\");\n\tdevice.scope.resolve(\"params2\");\n\tconst uvModParam = device.scope.resolve(\"uvMod\");\n\tif (seamPixels > 0) {\n\t\tuvModParam.setValue([(innerWidth + seamPixels * 2) / innerWidth, (innerHeight + seamPixels * 2) / innerHeight, -seamPixels / innerWidth, -seamPixels / innerHeight]);\n\t} else {\n\t\tuvModParam.setValue([1, 1, 0, 0]);\n\t}\n\tconst params = [0, source.fixCubemapSeams ? 1.0 / source.width : 0.0, target.fixCubemapSeams ? 1.0 / target.width : 0.0];\n\tif (prefilterSamples) {\n\t\tconst sourceTotalPixels = source.width * source.height * (source.cubemap ? 6 : 1);\n\t\tconst samplesTex = distribution === 'ggx' ? generateGGXSamplesTex(device, numSamples, specularPower, sourceTotalPixels) : distribution === 'lambert' ? generateLambertSamplesTex(device, numSamples, sourceTotalPixels) : generatePhongSamplesTex(device, numSamples, specularPower);\n\t\tdevice.scope.resolve(\"samplesTex\").setValue(samplesTex);\n\t\tdevice.scope.resolve(\"samplesTexInverseSize\").setValue([1.0 / samplesTex.width, 1.0 / samplesTex.height]);\n\t}\n\tfor (let f = 0; f < (target.cubemap ? 6 : 1); f++) {\n\t\tif (face === null || f === face) {\n\t\t\tvar _options;\n\t\t\tconst renderTarget = new RenderTarget({\n\t\t\t\tcolorBuffer: target,\n\t\t\t\tface: f,\n\t\t\t\tdepth: false,\n\t\t\t\tflipY: device.isWebGPU\n\t\t\t});\n\t\t\tparams[0] = f;\n\t\t\tconstantParams.setValue(params);\n\t\t\tdrawQuadWithShader(device, renderTarget, shader, (_options = options) == null ? void 0 : _options.rect);\n\t\t\trenderTarget.destroy();\n\t\t}\n\t}\n\treturn true;\n}\n\nexport { reprojectTexture };\n", "import { Vec4 } from '../../core/math/vec4.js';\nimport { Texture } from '../../platform/graphics/texture.js';\nimport { reprojectTexture } from './reproject-texture.js';\nimport { PIXELFORMAT_RGBA8, TEXTURETYPE_RGBP, TEXTURETYPE_DEFAULT, ADDRESS_CLAMP_TO_EDGE, TEXTUREPROJECTION_EQUIRECT, PIXELFORMAT_RGBA16F, PIXELFORMAT_RGBA32F } from '../../platform/graphics/constants.js';\n\nconst fixCubemapSeams = true;\nconst calcLevels = (width, height = 0) => {\n\treturn 1 + Math.floor(Math.log2(Math.max(width, height)));\n};\nconst supportsFloat16 = device => {\n\treturn device.extTextureHalfFloat && device.textureHalfFloatRenderable;\n};\nconst supportsFloat32 = device => {\n\treturn device.extTextureFloat && device.textureFloatRenderable;\n};\nconst lightingSourcePixelFormat = device => {\n\treturn supportsFloat16(device) ? PIXELFORMAT_RGBA16F : supportsFloat32(device) ? PIXELFORMAT_RGBA32F : PIXELFORMAT_RGBA8;\n};\nconst lightingPixelFormat = device => {\n\treturn PIXELFORMAT_RGBA8;\n};\nconst createCubemap = (device, size, format, mipmaps) => {\n\treturn new Texture(device, {\n\t\tname: `lighting-${size}`,\n\t\tcubemap: true,\n\t\twidth: size,\n\t\theight: size,\n\t\tformat: format,\n\t\ttype: format === PIXELFORMAT_RGBA8 ? TEXTURETYPE_RGBP : TEXTURETYPE_DEFAULT,\n\t\taddressU: ADDRESS_CLAMP_TO_EDGE,\n\t\taddressV: ADDRESS_CLAMP_TO_EDGE,\n\t\tfixCubemapSeams: fixCubemapSeams,\n\t\tmipmaps: !!mipmaps\n\t});\n};\nclass EnvLighting {\n\tstatic generateSkyboxCubemap(source, size) {\n\t\tconst device = source.device;\n\t\tconst result = createCubemap(device, size || (source.cubemap ? source.width : source.width / 4), PIXELFORMAT_RGBA8, false);\n\t\treprojectTexture(source, result, {\n\t\t\tnumSamples: 1024\n\t\t});\n\t\treturn result;\n\t}\n\tstatic generateLightingSource(source, options) {\n\t\tconst device = source.device;\n\t\tconst format = lightingSourcePixelFormat(device);\n\t\tconst result = (options == null ? void 0 : options.target) || new Texture(device, {\n\t\t\tname: `lighting-source`,\n\t\t\tcubemap: true,\n\t\t\twidth: (options == null ? void 0 : options.size) || 128,\n\t\t\theight: (options == null ? void 0 : options.size) || 128,\n\t\t\tformat: format,\n\t\t\ttype: format === PIXELFORMAT_RGBA8 ? TEXTURETYPE_RGBP : TEXTURETYPE_DEFAULT,\n\t\t\taddressU: ADDRESS_CLAMP_TO_EDGE,\n\t\t\taddressV: ADDRESS_CLAMP_TO_EDGE,\n\t\t\tfixCubemapSeams: false,\n\t\t\tmipmaps: true\n\t\t});\n\t\treprojectTexture(source, result, {\n\t\t\tnumSamples: source.mipmaps ? 1 : 1024\n\t\t});\n\t\treturn result;\n\t}\n\tstatic generateAtlas(source, options) {\n\t\tconst device = source.device;\n\t\tconst format = lightingPixelFormat();\n\t\tconst result = (options == null ? void 0 : options.target) || new Texture(device, {\n\t\t\tname: 'envAtlas',\n\t\t\twidth: (options == null ? void 0 : options.size) || 512,\n\t\t\theight: (options == null ? void 0 : options.size) || 512,\n\t\t\tformat: format,\n\t\t\ttype: TEXTURETYPE_RGBP ,\n\t\t\tprojection: TEXTUREPROJECTION_EQUIRECT,\n\t\t\taddressU: ADDRESS_CLAMP_TO_EDGE,\n\t\t\taddressV: ADDRESS_CLAMP_TO_EDGE,\n\t\t\tmipmaps: false\n\t\t});\n\t\tconst s = result.width / 512;\n\t\tconst rect = new Vec4(0, 0, 512 * s, 256 * s);\n\t\tconst levels = calcLevels(256) - calcLevels(4);\n\t\tfor (let i = 0; i < levels; ++i) {\n\t\t\treprojectTexture(source, result, {\n\t\t\t\tnumSamples: 1,\n\t\t\t\trect: rect,\n\t\t\t\tseamPixels: s\n\t\t\t});\n\t\t\trect.x += rect.w;\n\t\t\trect.y += rect.w;\n\t\t\trect.z = Math.max(1, Math.floor(rect.z * 0.5));\n\t\t\trect.w = Math.max(1, Math.floor(rect.w * 0.5));\n\t\t}\n\t\trect.set(0, 256 * s, 256 * s, 128 * s);\n\t\tfor (let i = 1; i < 7; ++i) {\n\t\t\treprojectTexture(source, result, {\n\t\t\t\tnumSamples: (options == null ? void 0 : options.numReflectionSamples) || 1024,\n\t\t\t\tdistribution: (options == null ? void 0 : options.distribution) || 'ggx',\n\t\t\t\tspecularPower: Math.max(1, 2048 >> i * 2),\n\t\t\t\trect: rect,\n\t\t\t\tseamPixels: s\n\t\t\t});\n\t\t\trect.y += rect.w;\n\t\t\trect.z = Math.max(1, Math.floor(rect.z * 0.5));\n\t\t\trect.w = Math.max(1, Math.floor(rect.w * 0.5));\n\t\t}\n\t\trect.set(128 * s, (256 + 128) * s, 64 * s, 32 * s);\n\t\treprojectTexture(source, result, {\n\t\t\tnumSamples: (options == null ? void 0 : options.numAmbientSamples) || 2048,\n\t\t\tdistribution: 'lambert',\n\t\t\trect: rect,\n\t\t\tseamPixels: s\n\t\t});\n\t\treturn result;\n\t}\n\tstatic generatePrefilteredAtlas(sources, options) {\n\t\tconst device = sources[0].device;\n\t\tconst format = sources[0].format;\n\t\tconst type = sources[0].type;\n\t\tconst result = (options == null ? void 0 : options.target) || new Texture(device, {\n\t\t\tname: 'envPrefilteredAtlas',\n\t\t\twidth: (options == null ? void 0 : options.size) || 512,\n\t\t\theight: (options == null ? void 0 : options.size) || 512,\n\t\t\tformat: format,\n\t\t\ttype: type,\n\t\t\tprojection: TEXTUREPROJECTION_EQUIRECT,\n\t\t\taddressU: ADDRESS_CLAMP_TO_EDGE,\n\t\t\taddressV: ADDRESS_CLAMP_TO_EDGE,\n\t\t\tmipmaps: false\n\t\t});\n\t\tconst s = result.width / 512;\n\t\tconst rect = new Vec4(0, 0, 512 * s, 256 * s);\n\t\tconst levels = calcLevels(512);\n\t\tfor (let i = 0; i < levels; ++i) {\n\t\t\treprojectTexture(sources[0], result, {\n\t\t\t\tnumSamples: 1,\n\t\t\t\trect: rect,\n\t\t\t\tseamPixels: s\n\t\t\t});\n\t\t\trect.x += rect.w;\n\t\t\trect.y += rect.w;\n\t\t\trect.z = Math.max(1, Math.floor(rect.z * 0.5));\n\t\t\trect.w = Math.max(1, Math.floor(rect.w * 0.5));\n\t\t}\n\t\trect.set(0, 256 * s, 256 * s, 128 * s);\n\t\tfor (let i = 1; i < sources.length; ++i) {\n\t\t\treprojectTexture(sources[i], result, {\n\t\t\t\tnumSamples: 1,\n\t\t\t\trect: rect,\n\t\t\t\tseamPixels: s\n\t\t\t});\n\t\t\trect.y += rect.w;\n\t\t\trect.z = Math.max(1, Math.floor(rect.z * 0.5));\n\t\t\trect.w = Math.max(1, Math.floor(rect.w * 0.5));\n\t\t}\n\t\trect.set(128 * s, (256 + 128) * s, 64 * s, 32 * s);\n\t\tif (options != null && options.legacyAmbient) {\n\t\t\treprojectTexture(sources[5], result, {\n\t\t\t\tnumSamples: 1,\n\t\t\t\trect: rect,\n\t\t\t\tseamPixels: s\n\t\t\t});\n\t\t} else {\n\t\t\treprojectTexture(sources[0], result, {\n\t\t\t\tnumSamples: (options == null ? void 0 : options.numSamples) || 2048,\n\t\t\t\tdistribution: 'lambert',\n\t\t\t\trect: rect,\n\t\t\t\tseamPixels: s\n\t\t\t});\n\t\t}\n\t\treturn result;\n\t}\n}\n\nexport { EnvLighting };\n", "import { EventHandler } from '../core/event-handler.js';\nimport { Color } from '../core/math/color.js';\nimport { Vec3 } from '../core/math/vec3.js';\nimport { Quat } from '../core/math/quat.js';\nimport { math } from '../core/math/math.js';\nimport { Mat3 } from '../core/math/mat3.js';\nimport { Mat4 } from '../core/math/mat4.js';\nimport { ADDRESS_CLAMP_TO_EDGE, FILTER_LINEAR, PIXELFORMAT_RGBA8 } from '../platform/graphics/constants.js';\nimport { BAKE_COLORDIR, FOG_NONE, GAMMA_SRGB, LAYERID_IMMEDIATE } from './constants.js';\nimport { LightingParams } from './lighting/lighting-params.js';\nimport { Sky } from './skybox/sky.js';\nimport { Immediate } from './immediate/immediate.js';\nimport { EnvLighting } from './graphics/env-lighting.js';\n\nclass Scene extends EventHandler {\n\tconstructor(graphicsDevice) {\n\t\tsuper();\n\t\tthis.ambientBake = false;\n\t\tthis.ambientBakeOcclusionBrightness = 0;\n\t\tthis.ambientBakeOcclusionContrast = 0;\n\t\tthis.ambientLight = new Color(0, 0, 0);\n\t\tthis.ambientLuminance = 0;\n\t\tthis.exposure = 1;\n\t\tthis.fogColor = new Color(0, 0, 0);\n\t\tthis.fogDensity = 0;\n\t\tthis.fogEnd = 1000;\n\t\tthis.fogStart = 1;\n\t\tthis.lightmapSizeMultiplier = 1;\n\t\tthis.lightmapMaxResolution = 2048;\n\t\tthis.lightmapMode = BAKE_COLORDIR;\n\t\tthis.lightmapFilterEnabled = false;\n\t\tthis.lightmapHDR = false;\n\t\tthis.root = null;\n\t\tthis.physicalUnits = false;\n\t\tthis._envAtlas = null;\n\t\tthis._skyboxCubeMap = null;\n\t\tthis.device = graphicsDevice;\n\t\tthis._gravity = new Vec3(0, -9.8, 0);\n\t\tthis._layers = null;\n\t\tthis._fog = FOG_NONE;\n\t\tthis._gammaCorrection = GAMMA_SRGB;\n\t\tthis._toneMapping = 0;\n\t\tthis._prefilteredCubemaps = [];\n\t\tthis._internalEnvAtlas = null;\n\t\tthis._skyboxIntensity = 1;\n\t\tthis._skyboxLuminance = 0;\n\t\tthis._skyboxMip = 0;\n\t\tthis._skyboxRotationShaderInclude = false;\n\t\tthis._skyboxRotation = new Quat();\n\t\tthis._skyboxRotationMat3 = new Mat3();\n\t\tthis._skyboxRotationMat4 = new Mat4();\n\t\tthis._ambientBakeNumSamples = 1;\n\t\tthis._ambientBakeSpherePart = 0.4;\n\t\tthis._lightmapFilterRange = 10;\n\t\tthis._lightmapFilterSmoothness = 0.2;\n\t\tthis._clusteredLightingEnabled = true;\n\t\tthis._lightingParams = new LightingParams(this.device.supportsAreaLights, this.device.maxTextureSize, () => {\n\t\t\tthis.updateShaders = true;\n\t\t});\n\t\tthis._sky = new Sky(this);\n\t\tthis._stats = {\n\t\t\tmeshInstances: 0,\n\t\t\tlights: 0,\n\t\t\tdynamicLights: 0,\n\t\t\tbakedLights: 0,\n\t\t\tupdateShadersTime: 0\n\t\t};\n\t\tthis.updateShaders = true;\n\t\tthis._shaderVersion = 0;\n\t\tthis.immediate = new Immediate(this.device);\n\t}\n\tget defaultDrawLayer() {\n\t\treturn this.layers.getLayerById(LAYERID_IMMEDIATE);\n\t}\n\tset ambientBakeNumSamples(value) {\n\t\tthis._ambientBakeNumSamples = math.clamp(Math.floor(value), 1, 255);\n\t}\n\tget ambientBakeNumSamples() {\n\t\treturn this._ambientBakeNumSamples;\n\t}\n\tset ambientBakeSpherePart(value) {\n\t\tthis._ambientBakeSpherePart = math.clamp(value, 0.001, 1);\n\t}\n\tget ambientBakeSpherePart() {\n\t\treturn this._ambientBakeSpherePart;\n\t}\n\tset clusteredLightingEnabled(value) {\n\t\tif (this.device.isWebGPU && !value) {\n\t\t\treturn;\n\t\t}\n\t\tif (!this._clusteredLightingEnabled && value) {\n\t\t\tconsole.error('Turning on disabled clustered lighting is not currently supported');\n\t\t\treturn;\n\t\t}\n\t\tthis._clusteredLightingEnabled = value;\n\t}\n\tget clusteredLightingEnabled() {\n\t\treturn this._clusteredLightingEnabled;\n\t}\n\tset envAtlas(value) {\n\t\tif (value !== this._envAtlas) {\n\t\t\tthis._envAtlas = value;\n\t\t\tif (value) {\n\t\t\t\tvalue.addressU = ADDRESS_CLAMP_TO_EDGE;\n\t\t\t\tvalue.addressV = ADDRESS_CLAMP_TO_EDGE;\n\t\t\t\tvalue.minFilter = FILTER_LINEAR;\n\t\t\t\tvalue.magFilter = FILTER_LINEAR;\n\t\t\t\tvalue.mipmaps = false;\n\t\t\t}\n\t\t\tthis._prefilteredCubemaps = [];\n\t\t\tif (this._internalEnvAtlas) {\n\t\t\t\tthis._internalEnvAtlas.destroy();\n\t\t\t\tthis._internalEnvAtlas = null;\n\t\t\t}\n\t\t\tthis._resetSkyMesh();\n\t\t}\n\t}\n\tget envAtlas() {\n\t\treturn this._envAtlas;\n\t}\n\tset fog(type) {\n\t\tif (type !== this._fog) {\n\t\t\tthis._fog = type;\n\t\t\tthis.updateShaders = true;\n\t\t}\n\t}\n\tget fog() {\n\t\treturn this._fog;\n\t}\n\tset gammaCorrection(value) {\n\t\tif (value !== this._gammaCorrection) {\n\t\t\tthis._gammaCorrection = value;\n\t\t\tthis.updateShaders = true;\n\t\t}\n\t}\n\tget gammaCorrection() {\n\t\treturn this._gammaCorrection;\n\t}\n\tset layers(layers) {\n\t\tconst prev = this._layers;\n\t\tthis._layers = layers;\n\t\tthis.fire('set:layers', prev, layers);\n\t}\n\tget layers() {\n\t\treturn this._layers;\n\t}\n\tget sky() {\n\t\treturn this._sky;\n\t}\n\tget lighting() {\n\t\treturn this._lightingParams;\n\t}\n\tset lightmapFilterRange(value) {\n\t\tthis._lightmapFilterRange = Math.max(value, 0.001);\n\t}\n\tget lightmapFilterRange() {\n\t\treturn this._lightmapFilterRange;\n\t}\n\tset lightmapFilterSmoothness(value) {\n\t\tthis._lightmapFilterSmoothness = Math.max(value, 0.001);\n\t}\n\tget lightmapFilterSmoothness() {\n\t\treturn this._lightmapFilterSmoothness;\n\t}\n\tset prefilteredCubemaps(value) {\n\t\tvalue = value || [];\n\t\tconst cubemaps = this._prefilteredCubemaps;\n\t\tconst changed = cubemaps.length !== value.length || cubemaps.some((c, i) => c !== value[i]);\n\t\tif (changed) {\n\t\t\tconst complete = value.length === 6 && value.every(c => !!c);\n\t\t\tif (complete) {\n\t\t\t\tthis._internalEnvAtlas = EnvLighting.generatePrefilteredAtlas(value, {\n\t\t\t\t\ttarget: this._internalEnvAtlas\n\t\t\t\t});\n\t\t\t\tthis._envAtlas = this._internalEnvAtlas;\n\t\t\t} else {\n\t\t\t\tif (this._internalEnvAtlas) {\n\t\t\t\t\tthis._internalEnvAtlas.destroy();\n\t\t\t\t\tthis._internalEnvAtlas = null;\n\t\t\t\t}\n\t\t\t\tthis._envAtlas = null;\n\t\t\t}\n\t\t\tthis._prefilteredCubemaps = value.slice();\n\t\t\tthis._resetSkyMesh();\n\t\t}\n\t}\n\tget prefilteredCubemaps() {\n\t\treturn this._prefilteredCubemaps;\n\t}\n\tset skybox(value) {\n\t\tif (value !== this._skyboxCubeMap) {\n\t\t\tthis._skyboxCubeMap = value;\n\t\t\tthis._resetSkyMesh();\n\t\t}\n\t}\n\tget skybox() {\n\t\treturn this._skyboxCubeMap;\n\t}\n\tset skyboxIntensity(value) {\n\t\tif (value !== this._skyboxIntensity) {\n\t\t\tthis._skyboxIntensity = value;\n\t\t\tthis._resetSkyMesh();\n\t\t}\n\t}\n\tget skyboxIntensity() {\n\t\treturn this._skyboxIntensity;\n\t}\n\tset skyboxLuminance(value) {\n\t\tif (value !== this._skyboxLuminance) {\n\t\t\tthis._skyboxLuminance = value;\n\t\t\tthis._resetSkyMesh();\n\t\t}\n\t}\n\tget skyboxLuminance() {\n\t\treturn this._skyboxLuminance;\n\t}\n\tset skyboxMip(value) {\n\t\tif (value !== this._skyboxMip) {\n\t\t\tthis._skyboxMip = value;\n\t\t\tthis._resetSkyMesh();\n\t\t}\n\t}\n\tget skyboxMip() {\n\t\treturn this._skyboxMip;\n\t}\n\tset skyboxRotation(value) {\n\t\tif (!this._skyboxRotation.equals(value)) {\n\t\t\tconst isIdentity = value.equals(Quat.IDENTITY);\n\t\t\tthis._skyboxRotation.copy(value);\n\t\t\tif (isIdentity) {\n\t\t\t\tthis._skyboxRotationMat3.setIdentity();\n\t\t\t} else {\n\t\t\t\tthis._skyboxRotationMat4.setTRS(Vec3.ZERO, value, Vec3.ONE);\n\t\t\t\tthis._skyboxRotationMat3.invertMat4(this._skyboxRotationMat4);\n\t\t\t}\n\t\t\tif (!this._skyboxRotationShaderInclude && !isIdentity) {\n\t\t\t\tthis._skyboxRotationShaderInclude = true;\n\t\t\t\tthis._resetSkyMesh();\n\t\t\t}\n\t\t}\n\t}\n\tget skyboxRotation() {\n\t\treturn this._skyboxRotation;\n\t}\n\tset toneMapping(value) {\n\t\tif (value !== this._toneMapping) {\n\t\t\tthis._toneMapping = value;\n\t\t\tthis.updateShaders = true;\n\t\t}\n\t}\n\tget toneMapping() {\n\t\treturn this._toneMapping;\n\t}\n\tdestroy() {\n\t\tthis._resetSkyMesh();\n\t\tthis.root = null;\n\t\tthis.off();\n\t}\n\tdrawLine(start, end, color = Color.WHITE, depthTest = true, layer = this.defaultDrawLayer) {\n\t\tconst batch = this.immediate.getBatch(layer, depthTest);\n\t\tbatch.addLines([start, end], [color, color]);\n\t}\n\tdrawLines(positions, colors, depthTest = true, layer = this.defaultDrawLayer) {\n\t\tconst batch = this.immediate.getBatch(layer, depthTest);\n\t\tbatch.addLines(positions, colors);\n\t}\n\tdrawLineArrays(positions, colors, depthTest = true, layer = this.defaultDrawLayer) {\n\t\tconst batch = this.immediate.getBatch(layer, depthTest);\n\t\tbatch.addLinesArrays(positions, colors);\n\t}\n\tapplySettings(settings) {\n\t\tvar _render$skyboxIntensi, _render$skyboxLuminan, _render$skyboxMip, _render$clusteredLigh;\n\t\tconst physics = settings.physics;\n\t\tconst render = settings.render;\n\t\tthis._gravity.set(physics.gravity[0], physics.gravity[1], physics.gravity[2]);\n\t\tthis.ambientLight.set(render.global_ambient[0], render.global_ambient[1], render.global_ambient[2]);\n\t\tthis.ambientLuminance = render.ambientLuminance;\n\t\tthis._fog = render.fog;\n\t\tthis.fogColor.set(render.fog_color[0], render.fog_color[1], render.fog_color[2]);\n\t\tthis.fogStart = render.fog_start;\n\t\tthis.fogEnd = render.fog_end;\n\t\tthis.fogDensity = render.fog_density;\n\t\tthis._gammaCorrection = render.gamma_correction;\n\t\tthis._toneMapping = render.tonemapping;\n\t\tthis.lightmapSizeMultiplier = render.lightmapSizeMultiplier;\n\t\tthis.lightmapMaxResolution = render.lightmapMaxResolution;\n\t\tthis.lightmapMode = render.lightmapMode;\n\t\tthis.exposure = render.exposure;\n\t\tthis._skyboxIntensity = (_render$skyboxIntensi = render.skyboxIntensity) != null ? _render$skyboxIntensi : 1;\n\t\tthis._skyboxLuminance = (_render$skyboxLuminan = render.skyboxLuminance) != null ? _render$skyboxLuminan : 20000;\n\t\tthis._skyboxMip = (_render$skyboxMip = render.skyboxMip) != null ? _render$skyboxMip : 0;\n\t\tif (render.skyboxRotation) {\n\t\t\tthis.skyboxRotation = new Quat().setFromEulerAngles(render.skyboxRotation[0], render.skyboxRotation[1], render.skyboxRotation[2]);\n\t\t}\n\t\tthis.sky.applySettings(render);\n\t\tthis.clusteredLightingEnabled = (_render$clusteredLigh = render.clusteredLightingEnabled) != null ? _render$clusteredLigh : false;\n\t\tthis.lighting.applySettings(render);\n\t\t['lightmapFilterEnabled', 'lightmapFilterRange', 'lightmapFilterSmoothness', 'ambientBake', 'ambientBakeNumSamples', 'ambientBakeSpherePart', 'ambientBakeOcclusionBrightness', 'ambientBakeOcclusionContrast'].forEach(setting => {\n\t\t\tif (render.hasOwnProperty(setting)) {\n\t\t\t\tthis[setting] = render[setting];\n\t\t\t}\n\t\t});\n\t\tthis._resetSkyMesh();\n\t}\n\t_getSkyboxTex() {\n\t\tconst cubemaps = this._prefilteredCubemaps;\n\t\tif (this._skyboxMip) {\n\t\t\tconst skyboxMapping = [0, 1, 3, 4, 5, 6];\n\t\t\treturn cubemaps[skyboxMapping[this._skyboxMip]] || this._envAtlas || cubemaps[0] || this._skyboxCubeMap;\n\t\t}\n\t\treturn this._skyboxCubeMap || cubemaps[0] || this._envAtlas;\n\t}\n\t_updateSkyMesh() {\n\t\tif (!this.sky.skyMesh) {\n\t\t\tthis.sky.updateSkyMesh();\n\t\t}\n\t\tthis.sky.update();\n\t}\n\t_resetSkyMesh() {\n\t\tthis.sky.resetSkyMesh();\n\t\tthis.updateShaders = true;\n\t}\n\tsetSkybox(cubemaps) {\n\t\tif (!cubemaps) {\n\t\t\tthis.skybox = null;\n\t\t\tthis.envAtlas = null;\n\t\t} else {\n\t\t\tthis.skybox = cubemaps[0] || null;\n\t\t\tif (cubemaps[1] && !cubemaps[1].cubemap) {\n\t\t\t\tthis.envAtlas = cubemaps[1];\n\t\t\t} else {\n\t\t\t\tthis.prefilteredCubemaps = cubemaps.slice(1);\n\t\t\t}\n\t\t}\n\t}\n\tget lightmapPixelFormat() {\n\t\treturn this.lightmapHDR && this.device.getRenderableHdrFormat() || PIXELFORMAT_RGBA8;\n\t}\n}\nScene.EVENT_SETLAYERS = 'set:layers';\nScene.EVENT_SETSKYBOX = 'set:skybox';\n\nexport { Scene };\n", "class Skin {\n\tconstructor(graphicsDevice, ibp, boneNames) {\n\t\tthis.device = graphicsDevice;\n\t\tthis.inverseBindPose = ibp;\n\t\tthis.boneNames = boneNames;\n\t}\n}\n\nexport { Skin };\n", "import { LitShaderOptions } from '../shader-lib/programs/lit-shader-options.js';\n\nclass StandardMaterialOptions {\n\tconstructor() {\n\t\tthis.forceUv1 = false;\n\t\tthis.ambientTint = false;\n\t\tthis.diffuseTint = false;\n\t\tthis.specularTint = false;\n\t\tthis.metalnessTint = false;\n\t\tthis.glossTint = false;\n\t\tthis.emissiveTint = false;\n\t\tthis.opacityTint = false;\n\t\tthis.emissiveEncoding = 'linear';\n\t\tthis.lightMapEncoding = 'linear';\n\t\tthis.packedNormal = false;\n\t\tthis.glossInvert = false;\n\t\tthis.sheenGlossInvert = false;\n\t\tthis.clearCoatGlossInvert = false;\n\t\tthis.litOptions = new LitShaderOptions();\n\t}\n\tget pass() {\n\t\treturn this.litOptions.pass;\n\t}\n}\n\nexport { StandardMaterialOptions };\n", "import { SHADER_FORWARD, SHADER_FORWARDHDR, SPRITE_RENDERMODE_SLICED, SPRITE_RENDERMODE_TILED, SPECULAR_PHONG, FRESNEL_SCHLICK, BLEND_NONE, DITHER_NONE, DITHER_BAYER8 } from '../../constants.js';\nimport { ShaderPass } from '../../shader-pass.js';\nimport { LitShader } from './lit-shader.js';\nimport { ChunkBuilder } from '../chunk-builder.js';\nimport { ChunkUtils } from '../chunk-utils.js';\nimport { StandardMaterialOptions } from '../../materials/standard-material-options.js';\nimport { LitOptionsUtils } from './lit-options-utils.js';\nimport { ShaderGenerator } from './shader-generator.js';\n\nconst _matTex2D = [];\nconst buildPropertiesList = options => {\n\treturn Object.keys(options).filter(key => key !== \"litOptions\").sort();\n};\nclass ShaderGeneratorStandard extends ShaderGenerator {\n\tconstructor(...args) {\n\t\tsuper(...args);\n\t\tthis.optionsContext = new StandardMaterialOptions();\n\t\tthis.optionsContextMin = new StandardMaterialOptions();\n\t}\n\tgenerateKey(options) {\n\t\tlet props;\n\t\tif (options === this.optionsContextMin) {\n\t\t\tif (!this.propsMin) this.propsMin = buildPropertiesList(options);\n\t\t\tprops = this.propsMin;\n\t\t} else if (options === this.optionsContext) {\n\t\t\tif (!this.props) this.props = buildPropertiesList(options);\n\t\t\tprops = this.props;\n\t\t} else {\n\t\t\tprops = buildPropertiesList(options);\n\t\t}\n\t\tconst key = \"standard:\\n\" + props.map(prop => prop + options[prop]).join('\\n') + LitOptionsUtils.generateKey(options.litOptions);\n\t\treturn key;\n\t}\n\t_getUvSourceExpression(transformPropName, uVPropName, options) {\n\t\tconst transformId = options[transformPropName];\n\t\tconst uvChannel = options[uVPropName];\n\t\tconst isMainPass = options.litOptions.pass === SHADER_FORWARD || options.litOptions.pass === SHADER_FORWARDHDR;\n\t\tlet expression;\n\t\tif (isMainPass && options.litOptions.nineSlicedMode === SPRITE_RENDERMODE_SLICED) {\n\t\t\texpression = \"nineSlicedUv\";\n\t\t} else if (isMainPass && options.litOptions.nineSlicedMode === SPRITE_RENDERMODE_TILED) {\n\t\t\texpression = \"nineSlicedUv\";\n\t\t} else {\n\t\t\tif (transformId === 0) {\n\t\t\t\texpression = \"vUv\" + uvChannel;\n\t\t\t} else {\n\t\t\t\texpression = \"vUV\" + uvChannel + \"_\" + transformId;\n\t\t\t}\n\t\t\tif (options.heightMap && transformPropName !== \"heightMapTransform\") {\n\t\t\t\texpression += \" + dUvOffset\";\n\t\t\t}\n\t\t}\n\t\treturn expression;\n\t}\n\t_addMapDef(name, enabled) {\n\t\treturn enabled ? `#define ${name}\\n` : `#undef ${name}\\n`;\n\t}\n\t_addMapDefs(float, color, vertex, map, invert) {\n\t\treturn this._addMapDef(\"MAPFLOAT\", float) + this._addMapDef(\"MAPCOLOR\", color) + this._addMapDef(\"MAPVERTEX\", vertex) + this._addMapDef(\"MAPTEXTURE\", map) + this._addMapDef(\"MAPINVERT\", invert);\n\t}\n\t_addMap(propName, chunkName, options, chunks, mapping, encoding = null) {\n\t\tconst mapPropName = propName + \"Map\";\n\t\tconst uVPropName = mapPropName + \"Uv\";\n\t\tconst identifierPropName = mapPropName + \"Identifier\";\n\t\tconst transformPropName = mapPropName + \"Transform\";\n\t\tconst channelPropName = mapPropName + \"Channel\";\n\t\tconst vertexColorChannelPropName = propName + \"VertexColorChannel\";\n\t\tconst tintPropName = propName + \"Tint\";\n\t\tconst vertexColorPropName = propName + \"VertexColor\";\n\t\tconst detailModePropName = propName + \"Mode\";\n\t\tconst invertName = propName + \"Invert\";\n\t\tconst tintOption = options[tintPropName];\n\t\tconst vertexColorOption = options[vertexColorPropName];\n\t\tconst textureOption = options[mapPropName];\n\t\tconst textureIdentifier = options[identifierPropName];\n\t\tconst detailModeOption = options[detailModePropName];\n\t\tlet subCode = chunks[chunkName];\n\t\tif (textureOption) {\n\t\t\tconst uv = this._getUvSourceExpression(transformPropName, uVPropName, options);\n\t\t\tsubCode = subCode.replace(/\\$UV/g, uv).replace(/\\$CH/g, options[channelPropName]);\n\t\t\tif (mapping && subCode.search(/\\$SAMPLER/g) !== -1) {\n\t\t\t\tlet samplerName = \"texture_\" + mapPropName;\n\t\t\t\tconst alias = mapping[textureIdentifier];\n\t\t\t\tif (alias) {\n\t\t\t\t\tsamplerName = alias;\n\t\t\t\t} else {\n\t\t\t\t\tmapping[textureIdentifier] = samplerName;\n\t\t\t\t}\n\t\t\t\tsubCode = subCode.replace(/\\$SAMPLER/g, samplerName);\n\t\t\t}\n\t\t\tif (encoding) {\n\t\t\t\tif (options[channelPropName] === 'aaa') {\n\t\t\t\t\tsubCode = subCode.replace(/\\$DECODE/g, 'passThrough');\n\t\t\t\t} else {\n\t\t\t\t\tsubCode = subCode.replace(/\\$DECODE/g, ChunkUtils.decodeFunc(!options.litOptions.gamma && encoding === 'srgb' ? 'linear' : encoding));\n\t\t\t\t}\n\t\t\t\tif (subCode.indexOf('$texture2DSAMPLE')) {\n\t\t\t\t\tconst decodeTable = {\n\t\t\t\t\t\tlinear: 'texture2D',\n\t\t\t\t\t\tsrgb: 'texture2DSRGB',\n\t\t\t\t\t\trgbm: 'texture2DRGBM',\n\t\t\t\t\t\trgbe: 'texture2DRGBE'\n\t\t\t\t\t};\n\t\t\t\t\tsubCode = subCode.replace(/\\$texture2DSAMPLE/g, decodeTable[encoding] || 'texture2D');\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (vertexColorOption) {\n\t\t\tsubCode = subCode.replace(/\\$VC/g, options[vertexColorChannelPropName]);\n\t\t}\n\t\tif (detailModeOption) {\n\t\t\tsubCode = subCode.replace(/\\$DETAILMODE/g, detailModeOption);\n\t\t}\n\t\tconst isFloatTint = !!(tintOption & 1);\n\t\tconst isVecTint = !!(tintOption & 2);\n\t\tconst invertOption = !!options[invertName];\n\t\tsubCode = this._addMapDefs(isFloatTint, isVecTint, vertexColorOption, textureOption, invertOption) + subCode;\n\t\treturn subCode.replace(/\\$/g, \"\");\n\t}\n\t_correctChannel(p, chan, _matTex2D) {\n\t\tif (_matTex2D[p] > 0) {\n\t\t\tif (_matTex2D[p] < chan.length) {\n\t\t\t\treturn chan.substring(0, _matTex2D[p]);\n\t\t\t} else if (_matTex2D[p] > chan.length) {\n\t\t\t\tlet str = chan;\n\t\t\t\tconst chr = str.charAt(str.length - 1);\n\t\t\t\tconst addLen = _matTex2D[p] - str.length;\n\t\t\t\tfor (let i = 0; i < addLen; i++) str += chr;\n\t\t\t\treturn str;\n\t\t\t}\n\t\t\treturn chan;\n\t\t}\n\t}\n\tcreateShaderDefinition(device, options) {\n\t\tconst shaderPassInfo = ShaderPass.get(device).getByIndex(options.litOptions.pass);\n\t\tconst isForwardPass = shaderPassInfo.isForward;\n\t\tconst litShader = new LitShader(device, options.litOptions);\n\t\tconst useUv = [];\n\t\tconst useUnmodifiedUv = [];\n\t\tconst mapTransforms = [];\n\t\tconst maxUvSets = 2;\n\t\tconst textureMapping = {};\n\t\tfor (const p in _matTex2D) {\n\t\t\tconst mname = p + \"Map\";\n\t\t\tif (options[p + \"VertexColor\"]) {\n\t\t\t\tconst cname = p + \"VertexColorChannel\";\n\t\t\t\toptions[cname] = this._correctChannel(p, options[cname], _matTex2D);\n\t\t\t}\n\t\t\tif (options[mname]) {\n\t\t\t\tconst cname = mname + \"Channel\";\n\t\t\t\tconst tname = mname + \"Transform\";\n\t\t\t\tconst uname = mname + \"Uv\";\n\t\t\t\toptions[uname] = Math.min(options[uname], maxUvSets - 1);\n\t\t\t\toptions[cname] = this._correctChannel(p, options[cname], _matTex2D);\n\t\t\t\tconst uvSet = options[uname];\n\t\t\t\tuseUv[uvSet] = true;\n\t\t\t\tuseUnmodifiedUv[uvSet] = useUnmodifiedUv[uvSet] || options[mname] && !options[tname];\n\t\t\t\tif (options[tname]) {\n\t\t\t\t\tmapTransforms.push({\n\t\t\t\t\t\tname: p,\n\t\t\t\t\t\tid: options[tname],\n\t\t\t\t\t\tuv: options[uname]\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (options.forceUv1) {\n\t\t\tuseUv[1] = true;\n\t\t\tuseUnmodifiedUv[1] = useUnmodifiedUv[1] !== undefined ? useUnmodifiedUv[1] : true;\n\t\t}\n\t\tlitShader.generateVertexShader(useUv, useUnmodifiedUv, mapTransforms);\n\t\tif (options.litOptions.shadingModel === SPECULAR_PHONG) {\n\t\t\toptions.litOptions.fresnelModel = 0;\n\t\t\toptions.litOptions.ambientSH = false;\n\t\t} else {\n\t\t\toptions.litOptions.fresnelModel = options.litOptions.fresnelModel === 0 ? FRESNEL_SCHLICK : options.litOptions.fresnelModel;\n\t\t}\n\t\tconst decl = new ChunkBuilder();\n\t\tconst code = new ChunkBuilder();\n\t\tconst func = new ChunkBuilder();\n\t\tconst args = new ChunkBuilder();\n\t\tlet lightingUv = \"\";\n\t\tif (options.litOptions.nineSlicedMode === SPRITE_RENDERMODE_TILED) {\n\t\t\tdecl.append(`const float textureBias = -1000.0;`);\n\t\t} else {\n\t\t\tdecl.append(`uniform float textureBias;`);\n\t\t}\n\t\tif (isForwardPass) {\n\t\t\tif (options.heightMap) {\n\t\t\t\tdecl.append(\"vec2 dUvOffset;\");\n\t\t\t\tcode.append(this._addMap(\"height\", \"parallaxPS\", options, litShader.chunks, textureMapping));\n\t\t\t\tfunc.append(\"getParallax();\");\n\t\t\t}\n\t\t\tif (options.litOptions.blendType !== BLEND_NONE || options.litOptions.alphaTest || options.litOptions.alphaToCoverage || options.litOptions.opacityDither !== DITHER_NONE) {\n\t\t\t\tdecl.append(\"float dAlpha;\");\n\t\t\t\tcode.append(this._addMap(\"opacity\", \"opacityPS\", options, litShader.chunks, textureMapping));\n\t\t\t\tfunc.append(\"getOpacity();\");\n\t\t\t\targs.append(\"litArgs_opacity = dAlpha;\");\n\t\t\t\tif (options.litOptions.alphaTest) {\n\t\t\t\t\tcode.append(litShader.chunks.alphaTestPS);\n\t\t\t\t\tfunc.append(\"alphaTest(dAlpha);\");\n\t\t\t\t}\n\t\t\t\tconst opacityDither = options.litOptions.opacityDither;\n\t\t\t\tif (opacityDither !== DITHER_NONE) {\n\t\t\t\t\tif (opacityDither === DITHER_BAYER8) decl.append(litShader.chunks.bayerPS);\n\t\t\t\t\tdecl.append(`#define DITHER_${opacityDither.toUpperCase()}\\n`);\n\t\t\t\t\tdecl.append(litShader.chunks.opacityDitherPS);\n\t\t\t\t\tfunc.append(\"opacityDither(dAlpha, 0.0);\");\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tdecl.append(\"float dAlpha = 1.0;\");\n\t\t\t}\n\t\t\tif (litShader.needsNormal) {\n\t\t\t\tif (options.normalMap || options.clearCoatNormalMap) {\n\t\t\t\t\tcode.append(options.packedNormal ? litShader.chunks.normalXYPS : litShader.chunks.normalXYZPS);\n\t\t\t\t\tif (!options.litOptions.hasTangents) {\n\t\t\t\t\t\tconst baseName = options.normalMap ? \"normalMap\" : \"clearCoatNormalMap\";\n\t\t\t\t\t\tlightingUv = this._getUvSourceExpression(`${baseName}Transform`, `${baseName}Uv`, options);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tdecl.append(\"vec3 dNormalW;\");\n\t\t\t\tcode.append(this._addMap(\"normalDetail\", \"normalDetailMapPS\", options, litShader.chunks, textureMapping));\n\t\t\t\tcode.append(this._addMap(\"normal\", \"normalMapPS\", options, litShader.chunks, textureMapping));\n\t\t\t\tfunc.append(\"getNormal();\");\n\t\t\t\targs.append(\"litArgs_worldNormal = dNormalW;\");\n\t\t\t}\n\t\t\tif (litShader.needsSceneColor) {\n\t\t\t\tdecl.append(\"uniform sampler2D uSceneColorMap;\");\n\t\t\t}\n\t\t\tif (litShader.needsScreenSize) {\n\t\t\t\tdecl.append(\"uniform vec4 uScreenSize;\");\n\t\t\t}\n\t\t\tif (litShader.needsTransforms) {\n\t\t\t\tdecl.append(\"uniform mat4 matrix_viewProjection;\");\n\t\t\t\tdecl.append(\"uniform mat4 matrix_model;\");\n\t\t\t}\n\t\t\tif (options.diffuseDetail || options.aoDetail) {\n\t\t\t\tcode.append(litShader.chunks.detailModesPS);\n\t\t\t}\n\t\t\tdecl.append(\"vec3 dAlbedo;\");\n\t\t\tif (options.diffuseDetail) {\n\t\t\t\tcode.append(this._addMap(\"diffuseDetail\", \"diffuseDetailMapPS\", options, litShader.chunks, textureMapping, options.diffuseDetailEncoding));\n\t\t\t}\n\t\t\tcode.append(this._addMap(\"diffuse\", \"diffusePS\", options, litShader.chunks, textureMapping, options.diffuseEncoding));\n\t\t\tfunc.append(\"getAlbedo();\");\n\t\t\targs.append(\"litArgs_albedo = dAlbedo;\");\n\t\t\tif (options.litOptions.useRefraction) {\n\t\t\t\tdecl.append(\"float dTransmission;\");\n\t\t\t\tcode.append(this._addMap(\"refraction\", \"transmissionPS\", options, litShader.chunks, textureMapping));\n\t\t\t\tfunc.append(\"getRefraction();\");\n\t\t\t\targs.append(\"litArgs_transmission = dTransmission;\");\n\t\t\t\tdecl.append(\"float dThickness;\");\n\t\t\t\tcode.append(this._addMap(\"thickness\", \"thicknessPS\", options, litShader.chunks, textureMapping));\n\t\t\t\tfunc.append(\"getThickness();\");\n\t\t\t\targs.append(\"litArgs_thickness = dThickness;\");\n\t\t\t\tif (options.litOptions.dispersion) {\n\t\t\t\t\targs.append(\"litArgs_dispersion = material_dispersion;\");\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (options.litOptions.useIridescence) {\n\t\t\t\tdecl.append(\"float dIridescence;\");\n\t\t\t\tcode.append(this._addMap(\"iridescence\", \"iridescencePS\", options, litShader.chunks, textureMapping));\n\t\t\t\tfunc.append(\"getIridescence();\");\n\t\t\t\targs.append(\"litArgs_iridescence_intensity = dIridescence;\");\n\t\t\t\tdecl.append(\"float dIridescenceThickness;\");\n\t\t\t\tcode.append(this._addMap(\"iridescenceThickness\", \"iridescenceThicknessPS\", options, litShader.chunks, textureMapping));\n\t\t\t\tfunc.append(\"getIridescenceThickness();\");\n\t\t\t\targs.append(\"litArgs_iridescence_thickness = dIridescenceThickness;\");\n\t\t\t}\n\t\t\tif (litShader.lighting && options.litOptions.useSpecular || litShader.reflections) {\n\t\t\t\tdecl.append(\"vec3 dSpecularity;\");\n\t\t\t\tdecl.append(\"float dGlossiness;\");\n\t\t\t\tif (options.litOptions.useSheen) {\n\t\t\t\t\tdecl.append(\"vec3 sSpecularity;\");\n\t\t\t\t\tcode.append(this._addMap(\"sheen\", \"sheenPS\", options, litShader.chunks, textureMapping, options.sheenEncoding));\n\t\t\t\t\tfunc.append(\"getSheen();\");\n\t\t\t\t\targs.append(\"litArgs_sheen_specularity = sSpecularity;\");\n\t\t\t\t\tdecl.append(\"float sGlossiness;\");\n\t\t\t\t\tcode.append(this._addMap(\"sheenGloss\", \"sheenGlossPS\", options, litShader.chunks, textureMapping));\n\t\t\t\t\tfunc.append(\"getSheenGlossiness();\");\n\t\t\t\t\targs.append(\"litArgs_sheen_gloss = sGlossiness;\");\n\t\t\t\t}\n\t\t\t\tif (options.litOptions.useMetalness) {\n\t\t\t\t\tdecl.append(\"float dMetalness;\");\n\t\t\t\t\tcode.append(this._addMap(\"metalness\", \"metalnessPS\", options, litShader.chunks, textureMapping));\n\t\t\t\t\tfunc.append(\"getMetalness();\");\n\t\t\t\t\targs.append(\"litArgs_metalness = dMetalness;\");\n\t\t\t\t\tdecl.append(\"float dIor;\");\n\t\t\t\t\tcode.append(this._addMap(\"ior\", \"iorPS\", options, litShader.chunks, textureMapping));\n\t\t\t\t\tfunc.append(\"getIor();\");\n\t\t\t\t\targs.append(\"litArgs_ior = dIor;\");\n\t\t\t\t}\n\t\t\t\tif (options.litOptions.useSpecularityFactor) {\n\t\t\t\t\tdecl.append(\"float dSpecularityFactor;\");\n\t\t\t\t\tcode.append(this._addMap(\"specularityFactor\", \"specularityFactorPS\", options, litShader.chunks, textureMapping));\n\t\t\t\t\tfunc.append(\"getSpecularityFactor();\");\n\t\t\t\t\targs.append(\"litArgs_specularityFactor = dSpecularityFactor;\");\n\t\t\t\t}\n\t\t\t\tif (options.useSpecularColor) {\n\t\t\t\t\tcode.append(this._addMap(\"specular\", \"specularPS\", options, litShader.chunks, textureMapping, options.specularEncoding));\n\t\t\t\t} else {\n\t\t\t\t\tcode.append(\"void getSpecularity() { dSpecularity = vec3(1); }\");\n\t\t\t\t}\n\t\t\t\tcode.append(this._addMap(\"gloss\", \"glossPS\", options, litShader.chunks, textureMapping));\n\t\t\t\tfunc.append(\"getGlossiness();\");\n\t\t\t\tfunc.append(\"getSpecularity();\");\n\t\t\t\targs.append(\"litArgs_specularity = dSpecularity;\");\n\t\t\t\targs.append(\"litArgs_gloss = dGlossiness;\");\n\t\t\t} else {\n\t\t\t\tdecl.append(\"vec3 dSpecularity = vec3(0.0);\");\n\t\t\t\tdecl.append(\"float dGlossiness = 0.0;\");\n\t\t\t}\n\t\t\tif (options.aoDetail) {\n\t\t\t\tcode.append(this._addMap(\"aoDetail\", \"aoDetailMapPS\", options, litShader.chunks, textureMapping));\n\t\t\t}\n\t\t\tif (options.aoMap || options.aoVertexColor) {\n\t\t\t\tdecl.append(\"float dAo;\");\n\t\t\t\tcode.append(this._addMap(\"ao\", \"aoPS\", options, litShader.chunks, textureMapping));\n\t\t\t\tfunc.append(\"getAO();\");\n\t\t\t\targs.append(\"litArgs_ao = dAo;\");\n\t\t\t}\n\t\t\tdecl.append(\"vec3 dEmission;\");\n\t\t\tcode.append(this._addMap(\"emissive\", \"emissivePS\", options, litShader.chunks, textureMapping, options.emissiveEncoding));\n\t\t\tfunc.append(\"getEmission();\");\n\t\t\targs.append(\"litArgs_emission = dEmission;\");\n\t\t\tif (options.litOptions.useClearCoat) {\n\t\t\t\tdecl.append(\"float ccSpecularity;\");\n\t\t\t\tdecl.append(\"float ccGlossiness;\");\n\t\t\t\tdecl.append(\"vec3 ccNormalW;\");\n\t\t\t\tcode.append(this._addMap(\"clearCoat\", \"clearCoatPS\", options, litShader.chunks, textureMapping));\n\t\t\t\tcode.append(this._addMap(\"clearCoatGloss\", \"clearCoatGlossPS\", options, litShader.chunks, textureMapping));\n\t\t\t\tcode.append(this._addMap(\"clearCoatNormal\", \"clearCoatNormalPS\", options, litShader.chunks, textureMapping));\n\t\t\t\tfunc.append(\"getClearCoat();\");\n\t\t\t\tfunc.append(\"getClearCoatGlossiness();\");\n\t\t\t\tfunc.append(\"getClearCoatNormal();\");\n\t\t\t\targs.append(\"litArgs_clearcoat_specularity = ccSpecularity;\");\n\t\t\t\targs.append(\"litArgs_clearcoat_gloss = ccGlossiness;\");\n\t\t\t\targs.append(\"litArgs_clearcoat_worldNormal = ccNormalW;\");\n\t\t\t}\n\t\t\tif (options.lightMap || options.lightVertexColor) {\n\t\t\t\tconst lightmapDir = options.dirLightMap && options.litOptions.useSpecular;\n\t\t\t\tconst lightmapChunkPropName = lightmapDir ? 'lightmapDirPS' : 'lightmapSinglePS';\n\t\t\t\tdecl.append(\"vec3 dLightmap;\");\n\t\t\t\tif (lightmapDir) {\n\t\t\t\t\tdecl.append(\"vec3 dLightmapDir;\");\n\t\t\t\t}\n\t\t\t\tcode.append(this._addMap(\"light\", lightmapChunkPropName, options, litShader.chunks, textureMapping, options.lightMapEncoding));\n\t\t\t\tfunc.append(\"getLightMap();\");\n\t\t\t\targs.append(\"litArgs_lightmap = dLightmap;\");\n\t\t\t\tif (lightmapDir) {\n\t\t\t\t\targs.append(\"litArgs_lightmapDir = dLightmapDir;\");\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (code.code.indexOf('texture2DSRGB') !== -1 || code.code.indexOf('texture2DRGBM') !== -1 || code.code.indexOf('texture2DRGBE') !== -1) {\n\t\t\t\tcode.prepend(litShader.chunks.textureSamplePS);\n\t\t\t}\n\t\t} else {\n\t\t\tconst opacityShadowDither = options.litOptions.opacityShadowDither;\n\t\t\tif (options.litOptions.alphaTest || opacityShadowDither) {\n\t\t\t\tdecl.append(\"float dAlpha;\");\n\t\t\t\tcode.append(this._addMap(\"opacity\", \"opacityPS\", options, litShader.chunks, textureMapping));\n\t\t\t\tfunc.append(\"getOpacity();\");\n\t\t\t\targs.append(\"litArgs_opacity = dAlpha;\");\n\t\t\t\tif (options.litOptions.alphaTest) {\n\t\t\t\t\tcode.append(litShader.chunks.alphaTestPS);\n\t\t\t\t\tfunc.append(\"alphaTest(dAlpha);\");\n\t\t\t\t}\n\t\t\t\tif (opacityShadowDither !== DITHER_NONE) {\n\t\t\t\t\tif (opacityShadowDither === DITHER_BAYER8) decl.append(litShader.chunks.bayerPS);\n\t\t\t\t\tdecl.append(`#define DITHER_${opacityShadowDither.toUpperCase()}\\n`);\n\t\t\t\t\tdecl.append(litShader.chunks.opacityDitherPS);\n\t\t\t\t\tfunc.append(\"opacityDither(dAlpha, 0.0);\");\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tdecl.append(litShader.chunks.litShaderArgsPS);\n\t\tcode.append(`void evaluateFrontend() { \\n${func.code}\\n${args.code}\\n }\\n`);\n\t\tfunc.code = `evaluateFrontend();`;\n\t\tfor (const texture in textureMapping) {\n\t\t\tdecl.append(`uniform sampler2D ${textureMapping[texture]};`);\n\t\t}\n\t\tfunc.code = `\\n${func.code.split('\\n').map(l => ` ${l}`).join('\\n')}\\n\\n`;\n\t\tlitShader.generateFragmentShader(decl.code, code.code, func.code, lightingUv);\n\t\treturn litShader.getDefinition();\n\t}\n}\nconst standard = new ShaderGeneratorStandard();\n\nexport { _matTex2D, standard };\n", "import { PIXELFORMAT_DXT5, TEXTURETYPE_SWIZZLEGGGR, PIXELFORMAT_RGBA8 } from '../../platform/graphics/constants.js';\nimport { SHADER_FORWARDHDR, GAMMA_SRGBHDR, TONEMAP_LINEAR, SHADERDEF_TANGENTS, SHADERDEF_SCREENSPACE, SHADERDEF_SKIN, SHADERDEF_INSTANCING, SHADERDEF_MORPH_POSITION, SHADERDEF_MORPH_NORMAL, SHADERDEF_MORPH_TEXTURE_BASED, BLEND_NONE, DITHER_NONE, SPECULAR_PHONG, GAMMA_NONE, SHADERDEF_NOSHADOW, SHADERDEF_LM, SHADERDEF_DIRLM, SHADERDEF_LMAMBIENT, MASK_AFFECT_DYNAMIC, LIGHTTYPE_DIRECTIONAL, LIGHTTYPE_OMNI, LIGHTTYPE_SPOT, SHADERDEF_UV0, SHADERDEF_UV1, SHADERDEF_VCOLOR, SHADER_PREPASS_VELOCITY } from '../constants.js';\nimport { _matTex2D } from '../shader-lib/programs/standard.js';\nimport { LitMaterialOptionsBuilder } from './lit-material-options-builder.js';\n\nconst arraysEqual = (a, b) => {\n\tif (a.length !== b.length) {\n\t\treturn false;\n\t}\n\tfor (let i = 0; i < a.length; ++i) {\n\t\tif (a[i] !== b[i]) {\n\t\t\treturn false;\n\t\t}\n\t}\n\treturn true;\n};\nconst notWhite = color => {\n\treturn color.r !== 1 || color.g !== 1 || color.b !== 1;\n};\nconst notBlack = color => {\n\treturn color.r !== 0 || color.g !== 0 || color.b !== 0;\n};\nclass StandardMaterialOptionsBuilder {\n\tconstructor() {\n\t\tthis._mapXForms = null;\n\t}\n\tupdateMinRef(options, scene, stdMat, objDefs, pass, sortedLights) {\n\t\tthis._updateSharedOptions(options, scene, stdMat, objDefs, pass);\n\t\tthis._updateMinOptions(options, stdMat, pass);\n\t\tthis._updateUVOptions(options, stdMat, objDefs, true);\n\t}\n\tupdateRef(options, scene, stdMat, objDefs, pass, sortedLights) {\n\t\tthis._updateSharedOptions(options, scene, stdMat, objDefs, pass);\n\t\tthis._updateEnvOptions(options, stdMat, scene);\n\t\tthis._updateMaterialOptions(options, stdMat);\n\t\tif (pass === SHADER_FORWARDHDR) {\n\t\t\tif (options.litOptions.gamma) options.litOptions.gamma = GAMMA_SRGBHDR;\n\t\t\toptions.litOptions.toneMap = TONEMAP_LINEAR;\n\t\t}\n\t\toptions.litOptions.hasTangents = objDefs && (objDefs & SHADERDEF_TANGENTS) !== 0;\n\t\tthis._updateLightOptions(options, scene, stdMat, objDefs, sortedLights);\n\t\tthis._updateUVOptions(options, stdMat, objDefs, false);\n\t}\n\t_updateSharedOptions(options, scene, stdMat, objDefs, pass) {\n\t\toptions.forceUv1 = stdMat.forceUv1;\n\t\tif (stdMat.userAttributes) {\n\t\t\toptions.litOptions.userAttributes = Object.fromEntries(stdMat.userAttributes.entries());\n\t\t}\n\t\toptions.litOptions.chunks = stdMat.chunks || {};\n\t\toptions.litOptions.pass = pass;\n\t\toptions.litOptions.alphaTest = stdMat.alphaTest > 0;\n\t\toptions.litOptions.blendType = stdMat.blendType;\n\t\toptions.litOptions.screenSpace = objDefs && (objDefs & SHADERDEF_SCREENSPACE) !== 0;\n\t\toptions.litOptions.skin = objDefs && (objDefs & SHADERDEF_SKIN) !== 0;\n\t\toptions.litOptions.useInstancing = objDefs && (objDefs & SHADERDEF_INSTANCING) !== 0;\n\t\toptions.litOptions.useMorphPosition = objDefs && (objDefs & SHADERDEF_MORPH_POSITION) !== 0;\n\t\toptions.litOptions.useMorphNormal = objDefs && (objDefs & SHADERDEF_MORPH_NORMAL) !== 0;\n\t\toptions.litOptions.useMorphTextureBased = objDefs && (objDefs & SHADERDEF_MORPH_TEXTURE_BASED) !== 0;\n\t\toptions.litOptions.nineSlicedMode = stdMat.nineSlicedMode || 0;\n\t\tif (scene.clusteredLightingEnabled && stdMat.useLighting) {\n\t\t\toptions.litOptions.clusteredLightingEnabled = true;\n\t\t\toptions.litOptions.clusteredLightingCookiesEnabled = scene.lighting.cookiesEnabled;\n\t\t\toptions.litOptions.clusteredLightingShadowsEnabled = scene.lighting.shadowsEnabled;\n\t\t\toptions.litOptions.clusteredLightingShadowType = scene.lighting.shadowType;\n\t\t\toptions.litOptions.clusteredLightingAreaLightsEnabled = scene.lighting.areaLightsEnabled;\n\t\t} else {\n\t\t\toptions.litOptions.clusteredLightingEnabled = false;\n\t\t\toptions.litOptions.clusteredLightingCookiesEnabled = false;\n\t\t\toptions.litOptions.clusteredLightingShadowsEnabled = false;\n\t\t\toptions.litOptions.clusteredLightingAreaLightsEnabled = false;\n\t\t}\n\t}\n\t_updateUVOptions(options, stdMat, objDefs, minimalOptions) {\n\t\tlet hasUv0 = false;\n\t\tlet hasUv1 = false;\n\t\tlet hasVcolor = false;\n\t\tif (objDefs) {\n\t\t\thasUv0 = (objDefs & SHADERDEF_UV0) !== 0;\n\t\t\thasUv1 = (objDefs & SHADERDEF_UV1) !== 0;\n\t\t\thasVcolor = (objDefs & SHADERDEF_VCOLOR) !== 0;\n\t\t}\n\t\toptions.litOptions.vertexColors = false;\n\t\tthis._mapXForms = [];\n\t\tconst uniqueTextureMap = {};\n\t\tfor (const p in _matTex2D) {\n\t\t\tthis._updateTexOptions(options, stdMat, p, hasUv0, hasUv1, hasVcolor, minimalOptions, uniqueTextureMap);\n\t\t}\n\t\tthis._mapXForms = null;\n\t\toptions.litOptions.lightMapEnabled = options.lightMap;\n\t\toptions.litOptions.dirLightMapEnabled = options.dirLightMap;\n\t\toptions.litOptions.useHeights = options.heightMap;\n\t\toptions.litOptions.useNormals = options.normalMap;\n\t\toptions.litOptions.useClearCoatNormals = options.clearCoatNormalMap;\n\t\toptions.litOptions.useAo = options.aoMap || options.aoVertexColor;\n\t\toptions.litOptions.diffuseMapEnabled = options.diffuseMap;\n\t}\n\t_updateTexOptions(options, stdMat, p, hasUv0, hasUv1, hasVcolor, minimalOptions, uniqueTextureMap) {\n\t\tconst isOpacity = p === 'opacity';\n\t\tif (!minimalOptions || isOpacity) {\n\t\t\tconst mname = p + 'Map';\n\t\t\tconst vname = p + 'VertexColor';\n\t\t\tconst vcname = p + 'VertexColorChannel';\n\t\t\tconst cname = mname + 'Channel';\n\t\t\tconst tname = mname + 'Transform';\n\t\t\tconst uname = mname + 'Uv';\n\t\t\tconst iname = mname + 'Identifier';\n\t\t\tif (p !== 'light') {\n\t\t\t\toptions[mname] = false;\n\t\t\t\toptions[iname] = undefined;\n\t\t\t\toptions[cname] = '';\n\t\t\t\toptions[tname] = 0;\n\t\t\t\toptions[uname] = 0;\n\t\t\t}\n\t\t\toptions[vname] = false;\n\t\t\toptions[vcname] = '';\n\t\t\tif (isOpacity && stdMat.blendType === BLEND_NONE && stdMat.alphaTest === 0.0 && !stdMat.alphaToCoverage && stdMat.opacityDither === DITHER_NONE) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif (p !== 'height' && stdMat[vname]) {\n\t\t\t\tif (hasVcolor) {\n\t\t\t\t\toptions[vname] = stdMat[vname];\n\t\t\t\t\toptions[vcname] = stdMat[vcname];\n\t\t\t\t\toptions.litOptions.vertexColors = true;\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (stdMat[mname]) {\n\t\t\t\tlet allow = true;\n\t\t\t\tif (stdMat[uname] === 0 && !hasUv0) allow = false;\n\t\t\t\tif (stdMat[uname] === 1 && !hasUv1) allow = false;\n\t\t\t\tif (allow) {\n\t\t\t\t\tconst mapId = stdMat[mname].id;\n\t\t\t\t\tlet identifier = uniqueTextureMap[mapId];\n\t\t\t\t\tif (identifier === undefined) {\n\t\t\t\t\t\tuniqueTextureMap[mapId] = p;\n\t\t\t\t\t\tidentifier = p;\n\t\t\t\t\t}\n\t\t\t\t\toptions[mname] = !!stdMat[mname];\n\t\t\t\t\toptions[iname] = identifier;\n\t\t\t\t\toptions[tname] = this._getMapTransformID(stdMat.getUniform(tname), stdMat[uname]);\n\t\t\t\t\toptions[cname] = stdMat[cname];\n\t\t\t\t\toptions[uname] = stdMat[uname];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\t_updateMinOptions(options, stdMat, pass) {\n\t\toptions.opacityTint = stdMat.blendType !== BLEND_NONE || stdMat.opacityShadowDither !== DITHER_NONE;\n\t\tconst isPrepass = pass === SHADER_PREPASS_VELOCITY;\n\t\toptions.litOptions.opacityShadowDither = isPrepass ? stdMat.opacityDither : stdMat.opacityShadowDither;\n\t\toptions.litOptions.lights = [];\n\t}\n\t_updateMaterialOptions(options, stdMat) {\n\t\tvar _stdMat$diffuseMap, _stdMat$diffuseDetail, _stdMat$emissiveMap, _stdMat$lightMap;\n\t\tconst diffuseTint = stdMat.diffuseTint || !stdMat.diffuseMap && !stdMat.diffuseVertexColor;\n\t\tconst useSpecular = !!(stdMat.useMetalness || stdMat.specularMap || stdMat.sphereMap || stdMat.cubeMap || notBlack(stdMat.specular) || stdMat.specularityFactor > 0 && stdMat.useMetalness || stdMat.enableGGXSpecular || stdMat.clearCoat > 0);\n\t\tconst useSpecularColor = !stdMat.useMetalness || stdMat.useMetalnessSpecularColor;\n\t\tconst specularTint = useSpecular && (stdMat.specularTint || !stdMat.specularMap && !stdMat.specularVertexColor) && notWhite(stdMat.specular);\n\t\tconst specularityFactorTint = useSpecular && stdMat.useMetalnessSpecularColor && (stdMat.specularityFactorTint || stdMat.specularityFactor < 1 && !stdMat.specularityFactorMap);\n\t\tconst emissiveTintColor = !stdMat.emissiveMap || notWhite(stdMat.emissive) && stdMat.emissiveTint;\n\t\tconst emissiveTintIntensity = stdMat.emissiveIntensity !== 1;\n\t\tconst isPackedNormalMap = stdMat.normalMap ? stdMat.normalMap.format === PIXELFORMAT_DXT5 || stdMat.normalMap.type === TEXTURETYPE_SWIZZLEGGGR : false;\n\t\toptions.opacityTint = stdMat.blendType !== BLEND_NONE || stdMat.alphaTest > 0 || stdMat.opacityDither !== DITHER_NONE ? 1 : 0;\n\t\toptions.ambientTint = stdMat.ambientTint;\n\t\toptions.diffuseTint = diffuseTint ? 2 : 0;\n\t\toptions.specularTint = specularTint ? 2 : 0;\n\t\toptions.specularityFactorTint = specularityFactorTint ? 1 : 0;\n\t\toptions.metalnessTint = stdMat.useMetalness && stdMat.metalness < 1 ? 1 : 0;\n\t\toptions.glossTint = 1;\n\t\toptions.emissiveTint = (emissiveTintColor ? 2 : 0) + (emissiveTintIntensity ? 1 : 0);\n\t\toptions.diffuseEncoding = (_stdMat$diffuseMap = stdMat.diffuseMap) == null ? void 0 : _stdMat$diffuseMap.encoding;\n\t\toptions.diffuseDetailEncoding = (_stdMat$diffuseDetail = stdMat.diffuseDetailMap) == null ? void 0 : _stdMat$diffuseDetail.encoding;\n\t\toptions.emissiveEncoding = (_stdMat$emissiveMap = stdMat.emissiveMap) == null ? void 0 : _stdMat$emissiveMap.encoding;\n\t\toptions.lightMapEncoding = (_stdMat$lightMap = stdMat.lightMap) == null ? void 0 : _stdMat$lightMap.encoding;\n\t\toptions.packedNormal = isPackedNormalMap;\n\t\toptions.refractionTint = stdMat.refraction !== 1.0 ? 1 : 0;\n\t\toptions.refractionIndexTint = stdMat.refractionIndex !== 1.0 / 1.5 ? 1 : 0;\n\t\toptions.thicknessTint = stdMat.useDynamicRefraction && stdMat.thickness !== 1.0 ? 1 : 0;\n\t\toptions.specularEncoding = stdMat.specularEncoding || 'linear';\n\t\toptions.sheenEncoding = stdMat.sheenEncoding || 'linear';\n\t\toptions.aoMapUv = stdMat.aoUvSet;\n\t\toptions.aoDetail = !!stdMat.aoMap;\n\t\toptions.diffuseDetail = !!stdMat.diffuseMap;\n\t\toptions.normalDetail = !!stdMat.normalMap;\n\t\toptions.diffuseDetailMode = stdMat.diffuseDetailMode;\n\t\toptions.aoDetailMode = stdMat.aoDetailMode;\n\t\toptions.clearCoatTint = stdMat.clearCoat !== 1.0 ? 1 : 0;\n\t\toptions.clearCoatGloss = !!stdMat.clearCoatGloss;\n\t\toptions.clearCoatGlossTint = stdMat.clearCoatGloss !== 1.0 ? 1 : 0;\n\t\toptions.iorTint = stdMat.refractionIndex !== 1.0 / 1.5 ? 1 : 0;\n\t\toptions.iridescenceTint = stdMat.iridescence !== 1.0 ? 1 : 0;\n\t\toptions.sheenTint = stdMat.useSheen && notWhite(stdMat.sheen) ? 2 : 0;\n\t\toptions.sheenGlossTint = 1;\n\t\toptions.glossInvert = stdMat.glossInvert;\n\t\toptions.sheenGlossInvert = stdMat.sheenGlossInvert;\n\t\toptions.clearCoatGlossInvert = stdMat.clearCoatGlossInvert;\n\t\toptions.useSpecularColor = useSpecularColor;\n\t\toptions.litOptions.separateAmbient = false;\n\t\toptions.litOptions.useAmbientTint = stdMat.ambientTint;\n\t\toptions.litOptions.customFragmentShader = stdMat.customFragmentShader;\n\t\toptions.litOptions.pixelSnap = stdMat.pixelSnap;\n\t\toptions.litOptions.shadingModel = stdMat.shadingModel;\n\t\toptions.litOptions.ambientSH = !!stdMat.ambientSH;\n\t\toptions.litOptions.fastTbn = stdMat.fastTbn;\n\t\toptions.litOptions.twoSidedLighting = stdMat.twoSidedLighting;\n\t\toptions.litOptions.occludeSpecular = stdMat.occludeSpecular;\n\t\toptions.litOptions.occludeSpecularFloat = stdMat.occludeSpecularIntensity !== 1.0;\n\t\toptions.litOptions.useMsdf = !!stdMat.msdfMap;\n\t\toptions.litOptions.msdfTextAttribute = !!stdMat.msdfTextAttribute;\n\t\toptions.litOptions.alphaToCoverage = stdMat.alphaToCoverage;\n\t\toptions.litOptions.opacityFadesSpecular = stdMat.opacityFadesSpecular;\n\t\toptions.litOptions.opacityDither = stdMat.opacityDither;\n\t\toptions.litOptions.cubeMapProjection = stdMat.cubeMapProjection;\n\t\toptions.litOptions.occludeDirect = stdMat.occludeDirect;\n\t\toptions.litOptions.conserveEnergy = stdMat.conserveEnergy && stdMat.shadingModel !== SPECULAR_PHONG;\n\t\toptions.litOptions.useSpecular = useSpecular;\n\t\toptions.litOptions.useSpecularityFactor = (specularityFactorTint || !!stdMat.specularityFactorMap) && stdMat.useMetalnessSpecularColor;\n\t\toptions.litOptions.enableGGXSpecular = stdMat.enableGGXSpecular;\n\t\toptions.litOptions.fresnelModel = stdMat.fresnelModel;\n\t\toptions.litOptions.useRefraction = (stdMat.refraction || !!stdMat.refractionMap) && (stdMat.useDynamicRefraction || !!options.litOptions.reflectionSource);\n\t\toptions.litOptions.useClearCoat = !!stdMat.clearCoat;\n\t\toptions.litOptions.useSheen = stdMat.useSheen;\n\t\toptions.litOptions.useIridescence = stdMat.useIridescence && stdMat.iridescence !== 0.0;\n\t\toptions.litOptions.useMetalness = stdMat.useMetalness;\n\t\toptions.litOptions.useDynamicRefraction = stdMat.useDynamicRefraction;\n\t\toptions.litOptions.dispersion = stdMat.dispersion > 0;\n\t}\n\t_updateEnvOptions(options, stdMat, scene) {\n\t\toptions.litOptions.fog = stdMat.useFog ? scene.fog : 'none';\n\t\toptions.litOptions.gamma = stdMat.useGammaTonemap ? scene.gammaCorrection : GAMMA_NONE;\n\t\toptions.litOptions.toneMap = stdMat.useGammaTonemap ? scene.toneMapping : -1;\n\t\toptions.litOptions.fixSeams = stdMat.cubeMap ? stdMat.cubeMap.fixCubemapSeams : false;\n\t\tconst isPhong = stdMat.shadingModel === SPECULAR_PHONG;\n\t\tlet usingSceneEnv = false;\n\t\tif (stdMat.envAtlas && stdMat.cubeMap && !isPhong) {\n\t\t\toptions.litOptions.reflectionSource = 'envAtlasHQ';\n\t\t\toptions.litOptions.reflectionEncoding = stdMat.envAtlas.encoding;\n\t\t\toptions.litOptions.reflectionCubemapEncoding = stdMat.cubeMap.encoding;\n\t\t} else if (stdMat.envAtlas && !isPhong) {\n\t\t\toptions.litOptions.reflectionSource = 'envAtlas';\n\t\t\toptions.litOptions.reflectionEncoding = stdMat.envAtlas.encoding;\n\t\t} else if (stdMat.cubeMap) {\n\t\t\toptions.litOptions.reflectionSource = 'cubeMap';\n\t\t\toptions.litOptions.reflectionEncoding = stdMat.cubeMap.encoding;\n\t\t} else if (stdMat.sphereMap) {\n\t\t\toptions.litOptions.reflectionSource = 'sphereMap';\n\t\t\toptions.litOptions.reflectionEncoding = stdMat.sphereMap.encoding;\n\t\t} else if (stdMat.useSkybox && scene.envAtlas && scene.skybox && !isPhong) {\n\t\t\toptions.litOptions.reflectionSource = 'envAtlasHQ';\n\t\t\toptions.litOptions.reflectionEncoding = scene.envAtlas.encoding;\n\t\t\toptions.litOptions.reflectionCubemapEncoding = scene.skybox.encoding;\n\t\t\tusingSceneEnv = true;\n\t\t} else if (stdMat.useSkybox && scene.envAtlas && !isPhong) {\n\t\t\toptions.litOptions.reflectionSource = 'envAtlas';\n\t\t\toptions.litOptions.reflectionEncoding = scene.envAtlas.encoding;\n\t\t\tusingSceneEnv = true;\n\t\t} else if (stdMat.useSkybox && scene.skybox) {\n\t\t\toptions.litOptions.reflectionSource = 'cubeMap';\n\t\t\toptions.litOptions.reflectionEncoding = scene.skybox.encoding;\n\t\t\tusingSceneEnv = true;\n\t\t} else {\n\t\t\toptions.litOptions.reflectionSource = null;\n\t\t\toptions.litOptions.reflectionEncoding = null;\n\t\t}\n\t\tif (stdMat.ambientSH && !isPhong) {\n\t\t\toptions.litOptions.ambientSource = 'ambientSH';\n\t\t\toptions.litOptions.ambientEncoding = null;\n\t\t} else {\n\t\t\tconst envAtlas = stdMat.envAtlas || (stdMat.useSkybox && scene.envAtlas ? scene.envAtlas : null);\n\t\t\tif (envAtlas && !isPhong) {\n\t\t\t\toptions.litOptions.ambientSource = 'envAtlas';\n\t\t\t\toptions.litOptions.ambientEncoding = envAtlas.encoding;\n\t\t\t} else {\n\t\t\t\toptions.litOptions.ambientSource = 'constant';\n\t\t\t\toptions.litOptions.ambientEncoding = null;\n\t\t\t}\n\t\t}\n\t\toptions.litOptions.skyboxIntensity = usingSceneEnv;\n\t\toptions.litOptions.useCubeMapRotation = usingSceneEnv && scene._skyboxRotationShaderInclude;\n\t}\n\t_updateLightOptions(options, scene, stdMat, objDefs, sortedLights) {\n\t\toptions.lightMap = false;\n\t\toptions.lightMapChannel = '';\n\t\toptions.lightMapUv = 0;\n\t\toptions.lightMapTransform = 0;\n\t\toptions.litOptions.lightMapWithoutAmbient = false;\n\t\toptions.dirLightMap = false;\n\t\tif (objDefs) {\n\t\t\toptions.litOptions.noShadow = (objDefs & SHADERDEF_NOSHADOW) !== 0;\n\t\t\tif ((objDefs & SHADERDEF_LM) !== 0) {\n\t\t\t\toptions.lightMapEncoding = scene.lightmapPixelFormat === PIXELFORMAT_RGBA8 ? 'rgbm' : 'linear';\n\t\t\t\toptions.lightMap = true;\n\t\t\t\toptions.lightMapChannel = 'rgb';\n\t\t\t\toptions.lightMapUv = 1;\n\t\t\t\toptions.lightMapTransform = 0;\n\t\t\t\toptions.litOptions.lightMapWithoutAmbient = !stdMat.lightMap;\n\t\t\t\tif ((objDefs & SHADERDEF_DIRLM) !== 0) {\n\t\t\t\t\toptions.dirLightMap = true;\n\t\t\t\t}\n\t\t\t\tif ((objDefs & SHADERDEF_LMAMBIENT) !== 0) {\n\t\t\t\t\toptions.litOptions.lightMapWithoutAmbient = false;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (stdMat.useLighting) {\n\t\t\tconst lightsFiltered = [];\n\t\t\tconst mask = objDefs ? objDefs >> 16 : MASK_AFFECT_DYNAMIC;\n\t\t\toptions.litOptions.lightMaskDynamic = !!(mask & MASK_AFFECT_DYNAMIC);\n\t\t\tif (sortedLights) {\n\t\t\t\tLitMaterialOptionsBuilder.collectLights(LIGHTTYPE_DIRECTIONAL, sortedLights[LIGHTTYPE_DIRECTIONAL], lightsFiltered, mask);\n\t\t\t\tLitMaterialOptionsBuilder.collectLights(LIGHTTYPE_OMNI, sortedLights[LIGHTTYPE_OMNI], lightsFiltered, mask);\n\t\t\t\tLitMaterialOptionsBuilder.collectLights(LIGHTTYPE_SPOT, sortedLights[LIGHTTYPE_SPOT], lightsFiltered, mask);\n\t\t\t}\n\t\t\toptions.litOptions.lights = lightsFiltered;\n\t\t} else {\n\t\t\toptions.litOptions.lights = [];\n\t\t}\n\t\tif (options.litOptions.lights.length === 0) {\n\t\t\toptions.litOptions.noShadow = true;\n\t\t}\n\t}\n\t_getMapTransformID(xform, uv) {\n\t\tif (!xform) return 0;\n\t\tlet xforms = this._mapXForms[uv];\n\t\tif (!xforms) {\n\t\t\txforms = [];\n\t\t\tthis._mapXForms[uv] = xforms;\n\t\t}\n\t\tfor (let i = 0; i < xforms.length; i++) {\n\t\t\tif (arraysEqual(xforms[i][0].value, xform[0].value) && arraysEqual(xforms[i][1].value, xform[1].value)) {\n\t\t\t\treturn i + 1;\n\t\t\t}\n\t\t}\n\t\treturn xforms.push(xform);\n\t}\n}\n\nexport { StandardMaterialOptionsBuilder };\n", "import { extends as _extends } from '../../../_virtual/_rollupPluginBabelHelpers.js';\n\nfunction _textureParameter(name, channel = true, vertexColor = true) {\n\tconst result = {};\n\tresult[`${name}Map`] = 'texture';\n\tresult[`${name}MapTiling`] = 'vec2';\n\tresult[`${name}MapOffset`] = 'vec2';\n\tresult[`${name}MapRotation`] = 'number';\n\tresult[`${name}MapUv`] = 'number';\n\tif (channel) {\n\t\tresult[`${name}MapChannel`] = 'string';\n\t\tif (vertexColor) {\n\t\t\tresult[`${name}VertexColor`] = 'boolean';\n\t\t\tresult[`${name}VertexColorChannel`] = 'string';\n\t\t}\n\t}\n\treturn result;\n}\nconst standardMaterialParameterTypes = _extends({\n\tname: 'string',\n\tchunks: 'chunks',\n\tmappingFormat: 'string',\n\t_engine: 'boolean',\n\tambient: 'rgb',\n\tambientTint: 'boolean'\n}, _textureParameter('ao'), _textureParameter('aoDetail', true, false), {\n\taoDetailMode: 'string',\n\tdiffuse: 'rgb',\n\tdiffuseTint: 'boolean'\n}, _textureParameter('diffuse'), _textureParameter('diffuseDetail', true, false), {\n\tdiffuseDetailMode: 'string',\n\tspecular: 'rgb',\n\tspecularTint: 'boolean'\n}, _textureParameter('specular'), {\n\toccludeSpecular: 'enum:occludeSpecular',\n\tspecularityFactor: 'number',\n\tspecularityFactorTint: 'boolean'\n}, _textureParameter('specularityFactor'), {\n\tuseMetalness: 'boolean',\n\tmetalness: 'number',\n\tenableGGXSpecular: 'boolean',\n\tanisotropy: 'number',\n\tmetalnessTint: 'boolean'\n}, _textureParameter('metalness'), {\n\tuseMetalnessSpecularColor: 'boolean',\n\tconserveEnergy: 'boolean',\n\tshininess: 'number',\n\tgloss: 'number',\n\tglossInvert: 'boolean'\n}, _textureParameter('gloss'), {\n\tclearCoat: 'number'\n}, _textureParameter('clearCoat'), {\n\tclearCoatGloss: 'number',\n\tclearCoatGlossInvert: 'boolean'\n}, _textureParameter('clearCoatGloss'), {\n\tclearCoatBumpiness: 'number'\n}, _textureParameter('clearCoatNormal', false), {\n\tuseSheen: 'boolean',\n\tsheen: 'rgb',\n\tsheenTint: 'boolean'\n}, _textureParameter('sheen'), {\n\tsheenGloss: 'number',\n\tsheenGlossTint: 'boolean',\n\tsheenGlossInvert: 'boolean'\n}, _textureParameter('sheenGloss'), {\n\tfresnelModel: 'number',\n\temissive: 'rgb',\n\temissiveTint: 'boolean'\n}, _textureParameter('emissive'), {\n\temissiveIntensity: 'number'\n}, _textureParameter('normal', false), {\n\tbumpiness: 'number'\n}, _textureParameter('normalDetail', false), {\n\tnormalDetailMapBumpiness: 'number'\n}, _textureParameter('height', true, false), {\n\theightMapFactor: 'number',\n\talphaToCoverage: 'boolean',\n\talphaTest: 'number',\n\talphaFade: 'number',\n\topacity: 'number'\n}, _textureParameter('opacity'), {\n\topacityFadesSpecular: 'boolean',\n\topacityDither: 'string',\n\topacityShadowDither: 'string',\n\treflectivity: 'number',\n\trefraction: 'number',\n\trefractionTint: 'boolean'\n}, _textureParameter('refraction'), {\n\trefractionIndex: 'number',\n\tdispersion: 'number',\n\tthickness: 'number',\n\tthicknessTint: 'boolean'\n}, _textureParameter('thickness'), {\n\tattenuation: 'rgb',\n\tattenuationDistance: 'number',\n\tuseDynamicRefraction: 'boolean',\n\tsphereMap: 'texture',\n\tcubeMap: 'cubemap',\n\tcubeMapProjection: 'number',\n\tcubeMapProjectionBox: 'boundingbox',\n\tuseIridescence: 'boolean',\n\tiridescence: 'number',\n\tiridescenceTint: 'boolean'\n}, _textureParameter('iridescence'), {\n\tiridescenceThicknessTint: 'boolean',\n\tiridescenceThicknessMin: 'number',\n\tiridescenceThicknessMax: 'number',\n\tiridescenceRefractionIndex: 'number'\n}, _textureParameter('iridescenceThickness'), _textureParameter('light'), {\n\tdepthTest: 'boolean',\n\tdepthFunc: 'enum:depthFunc',\n\tdepthWrite: 'boolean',\n\tdepthBias: 'number',\n\tslopeDepthBias: 'number',\n\tcull: 'enum:cull',\n\tblendType: 'enum:blendType',\n\tshadingModel: 'enum:shadingModel',\n\tuseFog: 'boolean',\n\tuseLighting: 'boolean',\n\tuseSkybox: 'boolean',\n\tuseGammaTonemap: 'boolean',\n\tenvAtlas: 'texture',\n\ttwoSidedLighting: 'boolean'\n});\nconst standardMaterialTextureParameters = [];\nfor (const key in standardMaterialParameterTypes) {\n\tconst type = standardMaterialParameterTypes[key];\n\tif (type === 'texture') {\n\t\tstandardMaterialTextureParameters.push(key);\n\t}\n}\nconst standardMaterialCubemapParameters = [];\nfor (const key in standardMaterialParameterTypes) {\n\tconst type = standardMaterialParameterTypes[key];\n\tif (type === 'cubemap') {\n\t\tstandardMaterialCubemapParameters.push(key);\n\t}\n}\nconst standardMaterialRemovedParameters = {\n\taoMapVertexColor: 'boolean',\n\tdiffuseMapTint: 'boolean',\n\tdiffuseMapVertexColor: 'boolean',\n\temissiveMapTint: 'boolean',\n\temissiveMapVertexColor: 'boolean',\n\tglossMapVertexColor: 'boolean',\n\tmetalnessMapVertexColor: 'boolean',\n\topacityMapVertexColor: 'boolean',\n\tspecularAntialias: 'boolean',\n\tspecularMapTint: 'boolean',\n\tspecularMapVertexColor: 'boolean'\n};\n\nexport { standardMaterialCubemapParameters, standardMaterialParameterTypes, standardMaterialRemovedParameters, standardMaterialTextureParameters };\n", "import { Color } from '../../core/math/color.js';\nimport { math } from '../../core/math/math.js';\nimport { Vec2 } from '../../core/math/vec2.js';\nimport { ShaderProcessorOptions } from '../../platform/graphics/shader-processor-options.js';\nimport { CUBEPROJ_BOX, SPECULAR_PHONG, SHADER_DEPTH, SHADER_PICK, SHADER_PREPASS_VELOCITY, SPECOCC_AO, SPECULAR_BLINN, FRESNEL_SCHLICK, CUBEPROJ_NONE, DITHER_NONE, DETAILMODE_MUL } from '../constants.js';\nimport { ShaderPass } from '../shader-pass.js';\nimport { EnvLighting } from '../graphics/env-lighting.js';\nimport { getProgramLibrary } from '../shader-lib/get-program-library.js';\nimport { _matTex2D, standard } from '../shader-lib/programs/standard.js';\nimport { Material } from './material.js';\nimport { StandardMaterialOptionsBuilder } from './standard-material-options-builder.js';\nimport { standardMaterialTextureParameters, standardMaterialCubemapParameters } from './standard-material-parameters.js';\n\nconst _props = {};\nconst _uniforms = {};\nlet _params = new Set();\nclass StandardMaterial extends Material {\n\tconstructor() {\n\t\tsuper();\n\t\tthis.userAttributes = new Map();\n\t\tthis._dirtyShader = true;\n\t\tthis._assetReferences = {};\n\t\tthis._activeParams = new Set();\n\t\tthis._activeLightingParams = new Set();\n\t\tthis.shaderOptBuilder = new StandardMaterialOptionsBuilder();\n\t\tthis.reset();\n\t}\n\treset() {\n\t\tObject.keys(_props).forEach(name => {\n\t\t\tthis[`_${name}`] = _props[name].value();\n\t\t});\n\t\tthis._chunks = {};\n\t\tthis._uniformCache = {};\n\t}\n\tset shader(shader) {}\n\tget shader() {\n\t\treturn null;\n\t}\n\tset chunks(value) {\n\t\tthis._dirtyShader = true;\n\t\tthis._chunks = value;\n\t}\n\tget chunks() {\n\t\tthis._dirtyShader = true;\n\t\treturn this._chunks;\n\t}\n\tcopy(source) {\n\t\tsuper.copy(source);\n\t\tObject.keys(_props).forEach(k => {\n\t\t\tthis[k] = source[k];\n\t\t});\n\t\tfor (const p in source._chunks) {\n\t\t\tif (source._chunks.hasOwnProperty(p)) this._chunks[p] = source._chunks[p];\n\t\t}\n\t\treturn this;\n\t}\n\tsetAttribute(name, semantic) {\n\t\tthis.userAttributes.set(semantic, name);\n\t}\n\t_setParameter(name, value) {\n\t\t_params.add(name);\n\t\tthis.setParameter(name, value);\n\t}\n\t_setParameters(parameters) {\n\t\tparameters.forEach(v => {\n\t\t\tthis._setParameter(v.name, v.value);\n\t\t});\n\t}\n\t_processParameters(paramsName) {\n\t\tconst prevParams = this[paramsName];\n\t\tprevParams.forEach(param => {\n\t\t\tif (!_params.has(param)) {\n\t\t\t\tdelete this.parameters[param];\n\t\t\t}\n\t\t});\n\t\tthis[paramsName] = _params;\n\t\t_params = prevParams;\n\t\t_params.clear();\n\t}\n\t_updateMap(p) {\n\t\tconst mname = p + 'Map';\n\t\tconst map = this[mname];\n\t\tif (map) {\n\t\t\tthis._setParameter('texture_' + mname, map);\n\t\t\tconst tname = mname + 'Transform';\n\t\t\tconst uniform = this.getUniform(tname);\n\t\t\tif (uniform) {\n\t\t\t\tthis._setParameters(uniform);\n\t\t\t}\n\t\t}\n\t}\n\t_allocUniform(name, allocFunc) {\n\t\tlet uniform = this._uniformCache[name];\n\t\tif (!uniform) {\n\t\t\tuniform = allocFunc();\n\t\t\tthis._uniformCache[name] = uniform;\n\t\t}\n\t\treturn uniform;\n\t}\n\tgetUniform(name, device, scene) {\n\t\treturn _uniforms[name](this, device, scene);\n\t}\n\tupdateUniforms(device, scene) {\n\t\tconst getUniform = name => {\n\t\t\treturn this.getUniform(name, device, scene);\n\t\t};\n\t\tthis._setParameter('material_ambient', getUniform('ambient'));\n\t\tif (!this.diffuseMap || this.diffuseTint) {\n\t\t\tthis._setParameter('material_diffuse', getUniform('diffuse'));\n\t\t}\n\t\tif (this.useMetalness) {\n\t\t\tif (!this.metalnessMap || this.metalness < 1) {\n\t\t\t\tthis._setParameter('material_metalness', this.metalness);\n\t\t\t}\n\t\t\tif (!this.specularMap || this.specularTint) {\n\t\t\t\tthis._setParameter('material_specular', getUniform('specular'));\n\t\t\t}\n\t\t\tif (!this.specularityFactorMap || this.specularityFactorTint) {\n\t\t\t\tthis._setParameter('material_specularityFactor', this.specularityFactor);\n\t\t\t}\n\t\t\tif (!this.sheenMap || this.sheenTint) {\n\t\t\t\tthis._setParameter('material_sheen', getUniform('sheen'));\n\t\t\t}\n\t\t\tif (!this.sheenGlossMap || this.sheenGlossTint) {\n\t\t\t\tthis._setParameter('material_sheenGloss', this.sheenGloss);\n\t\t\t}\n\t\t\tthis._setParameter('material_refractionIndex', this.refractionIndex);\n\t\t} else {\n\t\t\tif (!this.specularMap || this.specularTint) {\n\t\t\t\tthis._setParameter('material_specular', getUniform('specular'));\n\t\t\t}\n\t\t}\n\t\tif (this.enableGGXSpecular) {\n\t\t\tthis._setParameter('material_anisotropy', this.anisotropy);\n\t\t}\n\t\tif (this.clearCoat > 0) {\n\t\t\tthis._setParameter('material_clearCoat', this.clearCoat);\n\t\t\tthis._setParameter('material_clearCoatGloss', this.clearCoatGloss);\n\t\t\tthis._setParameter('material_clearCoatBumpiness', this.clearCoatBumpiness);\n\t\t}\n\t\tthis._setParameter('material_gloss', getUniform('gloss'));\n\t\tif (!this.emissiveMap || this.emissiveTint) {\n\t\t\tthis._setParameter('material_emissive', getUniform('emissive'));\n\t\t}\n\t\tif (this.emissiveIntensity !== 1) {\n\t\t\tthis._setParameter('material_emissiveIntensity', this.emissiveIntensity);\n\t\t}\n\t\tif (this.refraction > 0) {\n\t\t\tthis._setParameter('material_refraction', this.refraction);\n\t\t}\n\t\tif (this.dispersion > 0) {\n\t\t\tthis._setParameter('material_dispersion', this.dispersion);\n\t\t}\n\t\tif (this.useDynamicRefraction) {\n\t\t\tthis._setParameter('material_thickness', this.thickness);\n\t\t\tthis._setParameter('material_attenuation', getUniform('attenuation'));\n\t\t\tthis._setParameter('material_invAttenuationDistance', this.attenuationDistance === 0 ? 0 : 1.0 / this.attenuationDistance);\n\t\t}\n\t\tif (this.useIridescence) {\n\t\t\tthis._setParameter('material_iridescence', this.iridescence);\n\t\t\tthis._setParameter('material_iridescenceRefractionIndex', this.iridescenceRefractionIndex);\n\t\t\tthis._setParameter('material_iridescenceThicknessMin', this.iridescenceThicknessMin);\n\t\t\tthis._setParameter('material_iridescenceThicknessMax', this.iridescenceThicknessMax);\n\t\t}\n\t\tthis._setParameter('material_opacity', this.opacity);\n\t\tif (this.opacityFadesSpecular === false) {\n\t\t\tthis._setParameter('material_alphaFade', this.alphaFade);\n\t\t}\n\t\tif (this.occludeSpecular) {\n\t\t\tthis._setParameter('material_occludeSpecularIntensity', this.occludeSpecularIntensity);\n\t\t}\n\t\tif (this.cubeMapProjection === CUBEPROJ_BOX) {\n\t\t\tthis._setParameter(getUniform('cubeMapProjectionBox'));\n\t\t}\n\t\tfor (const p in _matTex2D) {\n\t\t\tthis._updateMap(p);\n\t\t}\n\t\tif (this.ambientSH) {\n\t\t\tthis._setParameter('ambientSH[0]', this.ambientSH);\n\t\t}\n\t\tif (this.normalMap) {\n\t\t\tthis._setParameter('material_bumpiness', this.bumpiness);\n\t\t}\n\t\tif (this.normalMap && this.normalDetailMap) {\n\t\t\tthis._setParameter('material_normalDetailMapBumpiness', this.normalDetailMapBumpiness);\n\t\t}\n\t\tif (this.heightMap) {\n\t\t\tthis._setParameter('material_heightMapFactor', getUniform('heightMapFactor'));\n\t\t}\n\t\tconst isPhong = this.shadingModel === SPECULAR_PHONG;\n\t\tif (this.envAtlas && this.cubeMap && !isPhong) {\n\t\t\tthis._setParameter('texture_envAtlas', this.envAtlas);\n\t\t\tthis._setParameter('texture_cubeMap', this.cubeMap);\n\t\t} else if (this.envAtlas && !isPhong) {\n\t\t\tthis._setParameter('texture_envAtlas', this.envAtlas);\n\t\t} else if (this.cubeMap) {\n\t\t\tthis._setParameter('texture_cubeMap', this.cubeMap);\n\t\t} else if (this.sphereMap) {\n\t\t\tthis._setParameter('texture_sphereMap', this.sphereMap);\n\t\t}\n\t\tthis._setParameter('material_reflectivity', this.reflectivity);\n\t\tthis._processParameters('_activeParams');\n\t\tif (this._dirtyShader) {\n\t\t\tthis.clearVariants();\n\t\t}\n\t}\n\tupdateEnvUniforms(device, scene) {\n\t\tconst isPhong = this.shadingModel === SPECULAR_PHONG;\n\t\tconst hasLocalEnvOverride = this.envAtlas && !isPhong || this.cubeMap || this.sphereMap;\n\t\tif (!hasLocalEnvOverride && this.useSkybox) {\n\t\t\tif (scene.envAtlas && scene.skybox && !isPhong) {\n\t\t\t\tthis._setParameter('texture_envAtlas', scene.envAtlas);\n\t\t\t\tthis._setParameter('texture_cubeMap', scene.skybox);\n\t\t\t} else if (scene.envAtlas && !isPhong) {\n\t\t\t\tthis._setParameter('texture_envAtlas', scene.envAtlas);\n\t\t\t} else if (scene.skybox) {\n\t\t\t\tthis._setParameter('texture_cubeMap', scene.skybox);\n\t\t\t}\n\t\t}\n\t\tthis._processParameters('_activeLightingParams');\n\t}\n\tgetShaderVariant(device, scene, objDefs, unused, pass, sortedLights, viewUniformFormat, viewBindGroupFormat, vertexFormat) {\n\t\tthis.updateEnvUniforms(device, scene);\n\t\tconst shaderPassInfo = ShaderPass.get(device).getByIndex(pass);\n\t\tconst minimalOptions = pass === SHADER_DEPTH || pass === SHADER_PICK || pass === SHADER_PREPASS_VELOCITY || shaderPassInfo.isShadow;\n\t\tlet options = minimalOptions ? standard.optionsContextMin : standard.optionsContext;\n\t\tif (minimalOptions) this.shaderOptBuilder.updateMinRef(options, scene, this, objDefs, pass, sortedLights);else this.shaderOptBuilder.updateRef(options, scene, this, objDefs, pass, sortedLights);\n\t\tif (this.onUpdateShader) {\n\t\t\toptions = this.onUpdateShader(options);\n\t\t}\n\t\tconst processingOptions = new ShaderProcessorOptions(viewUniformFormat, viewBindGroupFormat, vertexFormat);\n\t\tconst library = getProgramLibrary(device);\n\t\tlibrary.register('standard', standard);\n\t\tconst shader = library.getProgram('standard', options, processingOptions, this.userId);\n\t\tthis._dirtyShader = false;\n\t\treturn shader;\n\t}\n\tdestroy() {\n\t\tfor (const asset in this._assetReferences) {\n\t\t\tthis._assetReferences[asset]._unbind();\n\t\t}\n\t\tthis._assetReferences = null;\n\t\tsuper.destroy();\n\t}\n}\nStandardMaterial.TEXTURE_PARAMETERS = standardMaterialTextureParameters;\nStandardMaterial.CUBEMAP_PARAMETERS = standardMaterialCubemapParameters;\nconst defineUniform = (name, getUniformFunc) => {\n\t_uniforms[name] = getUniformFunc;\n};\nconst definePropInternal = (name, constructorFunc, setterFunc, getterFunc) => {\n\tObject.defineProperty(StandardMaterial.prototype, name, {\n\t\tget: getterFunc || function () {\n\t\t\treturn this[`_${name}`];\n\t\t},\n\t\tset: setterFunc\n\t});\n\t_props[name] = {\n\t\tvalue: constructorFunc\n\t};\n};\nconst defineValueProp = prop => {\n\tconst internalName = `_${prop.name}`;\n\tconst dirtyShaderFunc = prop.dirtyShaderFunc || (() => true);\n\tconst setterFunc = function setterFunc(value) {\n\t\tconst oldValue = this[internalName];\n\t\tif (oldValue !== value) {\n\t\t\tthis._dirtyShader = this._dirtyShader || dirtyShaderFunc(oldValue, value);\n\t\t\tthis[internalName] = value;\n\t\t}\n\t};\n\tdefinePropInternal(prop.name, () => prop.defaultValue, setterFunc, prop.getterFunc);\n};\nconst defineAggProp = prop => {\n\tconst internalName = `_${prop.name}`;\n\tconst dirtyShaderFunc = prop.dirtyShaderFunc || (() => true);\n\tconst setterFunc = function setterFunc(value) {\n\t\tconst oldValue = this[internalName];\n\t\tif (!oldValue.equals(value)) {\n\t\t\tthis._dirtyShader = this._dirtyShader || dirtyShaderFunc(oldValue, value);\n\t\t\tthis[internalName] = oldValue.copy(value);\n\t\t}\n\t};\n\tdefinePropInternal(prop.name, () => prop.defaultValue.clone(), setterFunc, prop.getterFunc);\n};\nconst defineProp = prop => {\n\treturn prop.defaultValue && prop.defaultValue.clone ? defineAggProp(prop) : defineValueProp(prop);\n};\nfunction _defineTex2D(name, channel = \"rgb\", vertexColor = true, uv = 0) {\n\t_matTex2D[name] = channel.length || -1;\n\tdefineProp({\n\t\tname: `${name}Map`,\n\t\tdefaultValue: null,\n\t\tdirtyShaderFunc: (oldValue, newValue) => {\n\t\t\treturn !!oldValue !== !!newValue || oldValue && (oldValue.type !== newValue.type || oldValue.fixCubemapSeams !== newValue.fixCubemapSeams || oldValue.format !== newValue.format);\n\t\t}\n\t});\n\tdefineProp({\n\t\tname: `${name}MapTiling`,\n\t\tdefaultValue: new Vec2(1, 1)\n\t});\n\tdefineProp({\n\t\tname: `${name}MapOffset`,\n\t\tdefaultValue: new Vec2(0, 0)\n\t});\n\tdefineProp({\n\t\tname: `${name}MapRotation`,\n\t\tdefaultValue: 0\n\t});\n\tdefineProp({\n\t\tname: `${name}MapUv`,\n\t\tdefaultValue: uv\n\t});\n\tif (channel) {\n\t\tdefineProp({\n\t\t\tname: `${name}MapChannel`,\n\t\t\tdefaultValue: channel\n\t\t});\n\t\tif (vertexColor) {\n\t\t\tdefineProp({\n\t\t\t\tname: `${name}VertexColor`,\n\t\t\t\tdefaultValue: false\n\t\t\t});\n\t\t\tdefineProp({\n\t\t\t\tname: `${name}VertexColorChannel`,\n\t\t\t\tdefaultValue: channel\n\t\t\t});\n\t\t}\n\t}\n\tconst mapTiling = `${name}MapTiling`;\n\tconst mapOffset = `${name}MapOffset`;\n\tconst mapRotation = `${name}MapRotation`;\n\tconst mapTransform = `${name}MapTransform`;\n\tdefineUniform(mapTransform, (material, device, scene) => {\n\t\tconst tiling = material[mapTiling];\n\t\tconst offset = material[mapOffset];\n\t\tconst rotation = material[mapRotation];\n\t\tif (tiling.x === 1 && tiling.y === 1 && offset.x === 0 && offset.y === 0 && rotation === 0) {\n\t\t\treturn null;\n\t\t}\n\t\tconst uniform = material._allocUniform(mapTransform, () => {\n\t\t\treturn [{\n\t\t\t\tname: `texture_${mapTransform}0`,\n\t\t\t\tvalue: new Float32Array(3)\n\t\t\t}, {\n\t\t\t\tname: `texture_${mapTransform}1`,\n\t\t\t\tvalue: new Float32Array(3)\n\t\t\t}];\n\t\t});\n\t\tconst cr = Math.cos(rotation * math.DEG_TO_RAD);\n\t\tconst sr = Math.sin(rotation * math.DEG_TO_RAD);\n\t\tconst uniform0 = uniform[0].value;\n\t\tuniform0[0] = cr * tiling.x;\n\t\tuniform0[1] = -sr * tiling.y;\n\t\tuniform0[2] = offset.x;\n\t\tconst uniform1 = uniform[1].value;\n\t\tuniform1[0] = sr * tiling.x;\n\t\tuniform1[1] = cr * tiling.y;\n\t\tuniform1[2] = 1.0 - tiling.y - offset.y;\n\t\treturn uniform;\n\t});\n}\nfunction _defineColor(name, defaultValue) {\n\tdefineProp({\n\t\tname: name,\n\t\tdefaultValue: defaultValue,\n\t\tgetterFunc: function () {\n\t\t\tthis._dirtyShader = true;\n\t\t\treturn this[`_${name}`];\n\t\t}\n\t});\n\tdefineUniform(name, (material, device, scene) => {\n\t\tconst uniform = material._allocUniform(name, () => new Float32Array(3));\n\t\tconst color = material[name];\n\t\tconst gamma = material.useGammaTonemap && scene.gammaCorrection;\n\t\tif (gamma) {\n\t\t\tuniform[0] = Math.pow(color.r, 2.2);\n\t\t\tuniform[1] = Math.pow(color.g, 2.2);\n\t\t\tuniform[2] = Math.pow(color.b, 2.2);\n\t\t} else {\n\t\t\tuniform[0] = color.r;\n\t\t\tuniform[1] = color.g;\n\t\t\tuniform[2] = color.b;\n\t\t}\n\t\treturn uniform;\n\t});\n}\nfunction _defineFloat(name, defaultValue, getUniformFunc) {\n\tdefineProp({\n\t\tname: name,\n\t\tdefaultValue: defaultValue,\n\t\tdirtyShaderFunc: (oldValue, newValue) => {\n\t\t\treturn (oldValue === 0 || oldValue === 1) !== (newValue === 0 || newValue === 1);\n\t\t}\n\t});\n\tdefineUniform(name, getUniformFunc);\n}\nfunction _defineObject(name, getUniformFunc) {\n\tdefineProp({\n\t\tname: name,\n\t\tdefaultValue: null,\n\t\tdirtyShaderFunc: (oldValue, newValue) => {\n\t\t\treturn !!oldValue === !!newValue;\n\t\t}\n\t});\n\tdefineUniform(name, getUniformFunc);\n}\nfunction _defineFlag(name, defaultValue) {\n\tdefineProp({\n\t\tname: name,\n\t\tdefaultValue: defaultValue\n\t});\n}\nfunction _defineMaterialProps() {\n\t_defineColor('ambient', new Color(0.7, 0.7, 0.7));\n\t_defineColor('diffuse', new Color(1, 1, 1));\n\t_defineColor('specular', new Color(0, 0, 0));\n\t_defineColor('emissive', new Color(0, 0, 0));\n\t_defineColor('sheen', new Color(1, 1, 1));\n\t_defineColor('attenuation', new Color(1, 1, 1));\n\t_defineFloat('emissiveIntensity', 1);\n\t_defineFloat('specularityFactor', 1);\n\t_defineFloat('sheenGloss', 0.0);\n\t_defineFloat('gloss', 0.25, (material, device, scene) => {\n\t\treturn material.shadingModel === SPECULAR_PHONG ? Math.pow(2, material.gloss * 11) : material.gloss;\n\t});\n\t_defineFloat('heightMapFactor', 1, (material, device, scene) => {\n\t\treturn material.heightMapFactor * 0.025;\n\t});\n\t_defineFloat('opacity', 1);\n\t_defineFloat('alphaFade', 1);\n\t_defineFloat('alphaTest', 0);\n\t_defineFloat('bumpiness', 1);\n\t_defineFloat('normalDetailMapBumpiness', 1);\n\t_defineFloat('reflectivity', 1);\n\t_defineFloat('occludeSpecularIntensity', 1);\n\t_defineFloat('refraction', 0);\n\t_defineFloat('refractionIndex', 1.0 / 1.5);\n\t_defineFloat('dispersion', 0);\n\t_defineFloat('thickness', 0);\n\t_defineFloat('attenuationDistance', 0);\n\t_defineFloat('metalness', 1);\n\t_defineFloat('anisotropy', 0);\n\t_defineFloat('clearCoat', 0);\n\t_defineFloat('clearCoatGloss', 1);\n\t_defineFloat('clearCoatBumpiness', 1);\n\t_defineFloat('aoUvSet', 0, null);\n\t_defineFloat('iridescence', 0);\n\t_defineFloat('iridescenceRefractionIndex', 1.0 / 1.5);\n\t_defineFloat('iridescenceThicknessMin', 0);\n\t_defineFloat('iridescenceThicknessMax', 0);\n\t_defineObject('ambientSH');\n\t_defineObject('cubeMapProjectionBox', (material, device, scene) => {\n\t\tconst uniform = material._allocUniform('cubeMapProjectionBox', () => {\n\t\t\treturn [{\n\t\t\t\tname: 'envBoxMin',\n\t\t\t\tvalue: new Float32Array(3)\n\t\t\t}, {\n\t\t\t\tname: 'envBoxMax',\n\t\t\t\tvalue: new Float32Array(3)\n\t\t\t}];\n\t\t});\n\t\tconst bboxMin = material.cubeMapProjectionBox.getMin();\n\t\tconst minUniform = uniform[0].value;\n\t\tminUniform[0] = bboxMin.x;\n\t\tminUniform[1] = bboxMin.y;\n\t\tminUniform[2] = bboxMin.z;\n\t\tconst bboxMax = material.cubeMapProjectionBox.getMax();\n\t\tconst maxUniform = uniform[1].value;\n\t\tmaxUniform[0] = bboxMax.x;\n\t\tmaxUniform[1] = bboxMax.y;\n\t\tmaxUniform[2] = bboxMax.z;\n\t\treturn uniform;\n\t});\n\t_defineFlag('ambientTint', false);\n\t_defineFlag('diffuseTint', false);\n\t_defineFlag('sheenTint', false);\n\t_defineFlag('specularTint', false);\n\t_defineFlag('specularityFactorTint', false);\n\t_defineFlag('emissiveTint', false);\n\t_defineFlag('fastTbn', false);\n\t_defineFlag('useMetalness', false);\n\t_defineFlag('useMetalnessSpecularColor', false);\n\t_defineFlag('useSheen', false);\n\t_defineFlag('enableGGXSpecular', false);\n\t_defineFlag('occludeDirect', false);\n\t_defineFlag('normalizeNormalMap', true);\n\t_defineFlag('conserveEnergy', true);\n\t_defineFlag('opacityFadesSpecular', true);\n\t_defineFlag('occludeSpecular', SPECOCC_AO);\n\t_defineFlag('shadingModel', SPECULAR_BLINN);\n\t_defineFlag('fresnelModel', FRESNEL_SCHLICK);\n\t_defineFlag('useDynamicRefraction', false);\n\t_defineFlag('cubeMapProjection', CUBEPROJ_NONE);\n\t_defineFlag('customFragmentShader', null);\n\t_defineFlag('useFog', true);\n\t_defineFlag('useLighting', true);\n\t_defineFlag('useGammaTonemap', true);\n\t_defineFlag('useSkybox', true);\n\t_defineFlag('forceUv1', false);\n\t_defineFlag('pixelSnap', false);\n\t_defineFlag('twoSidedLighting', false);\n\t_defineFlag('nineSlicedMode', undefined);\n\t_defineFlag('msdfTextAttribute', false);\n\t_defineFlag('useIridescence', false);\n\t_defineFlag('glossInvert', false);\n\t_defineFlag('sheenGlossInvert', false);\n\t_defineFlag('clearCoatGlossInvert', false);\n\t_defineFlag('opacityDither', DITHER_NONE);\n\t_defineFlag('opacityShadowDither', DITHER_NONE);\n\t_defineTex2D('diffuse');\n\t_defineTex2D('specular');\n\t_defineTex2D('emissive');\n\t_defineTex2D('thickness', 'g');\n\t_defineTex2D('specularityFactor', 'g');\n\t_defineTex2D('normal', '');\n\t_defineTex2D('metalness', 'g');\n\t_defineTex2D('gloss', 'g');\n\t_defineTex2D('opacity', 'a');\n\t_defineTex2D('refraction', 'g');\n\t_defineTex2D('height', 'g', false);\n\t_defineTex2D('ao', 'g');\n\t_defineTex2D('light', 'rgb', true, 1);\n\t_defineTex2D('msdf', '');\n\t_defineTex2D('diffuseDetail', 'rgb', false);\n\t_defineTex2D('normalDetail', '');\n\t_defineTex2D('aoDetail', 'g', false);\n\t_defineTex2D('clearCoat', 'g');\n\t_defineTex2D('clearCoatGloss', 'g');\n\t_defineTex2D('clearCoatNormal', '');\n\t_defineTex2D('sheen', 'rgb');\n\t_defineTex2D('sheenGloss', 'g');\n\t_defineTex2D('iridescence', 'g');\n\t_defineTex2D('iridescenceThickness', 'g');\n\t_defineFlag('diffuseDetailMode', DETAILMODE_MUL);\n\t_defineFlag('aoDetailMode', DETAILMODE_MUL);\n\t_defineObject('cubeMap');\n\t_defineObject('sphereMap');\n\t_defineObject('envAtlas');\n\tconst getterFunc = function getterFunc() {\n\t\treturn this._prefilteredCubemaps;\n\t};\n\tconst setterFunc = function setterFunc(value) {\n\t\tconst cubemaps = this._prefilteredCubemaps;\n\t\tvalue = value || [];\n\t\tlet changed = false;\n\t\tlet complete = true;\n\t\tfor (let i = 0; i < 6; ++i) {\n\t\t\tconst v = value[i] || null;\n\t\t\tif (cubemaps[i] !== v) {\n\t\t\t\tcubemaps[i] = v;\n\t\t\t\tchanged = true;\n\t\t\t}\n\t\t\tcomplete = complete && !!cubemaps[i];\n\t\t}\n\t\tif (changed) {\n\t\t\tif (complete) {\n\t\t\t\tthis.envAtlas = EnvLighting.generatePrefilteredAtlas(cubemaps, {\n\t\t\t\t\ttarget: this.envAtlas\n\t\t\t\t});\n\t\t\t} else {\n\t\t\t\tif (this.envAtlas) {\n\t\t\t\t\tthis.envAtlas.destroy();\n\t\t\t\t\tthis.envAtlas = null;\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis._dirtyShader = true;\n\t\t}\n\t};\n\tconst empty = [null, null, null, null, null, null];\n\tdefinePropInternal('prefilteredCubemaps', () => empty.slice(), setterFunc, getterFunc);\n}\n_defineMaterialProps();\n\nexport { StandardMaterial };\n", "class Key {\n\tconstructor(time, position, rotation, scale) {\n\t\tthis.time = time;\n\t\tthis.position = position;\n\t\tthis.rotation = rotation;\n\t\tthis.scale = scale;\n\t}\n}\nclass Node {\n\tconstructor() {\n\t\tthis._name = '';\n\t\tthis._keys = [];\n\t}\n}\nclass Animation {\n\tconstructor() {\n\t\tthis.name = '';\n\t\tthis.duration = 0;\n\t\tthis._nodes = [];\n\t\tthis._nodeDict = {};\n\t}\n\tgetNode(name) {\n\t\treturn this._nodeDict[name];\n\t}\n\taddNode(node) {\n\t\tthis._nodes.push(node);\n\t\tthis._nodeDict[node._name] = node;\n\t}\n\tget nodes() {\n\t\treturn this._nodes;\n\t}\n}\n\nexport { Animation, Key, Node };\n", "import { Quat } from '../../core/math/quat.js';\nimport { Vec3 } from '../../core/math/vec3.js';\n\nclass InterpolatedKey {\n\tconstructor() {\n\t\tthis._written = false;\n\t\tthis._name = '';\n\t\tthis._keyFrames = [];\n\t\tthis._quat = new Quat();\n\t\tthis._pos = new Vec3();\n\t\tthis._scale = new Vec3();\n\t\tthis._targetNode = null;\n\t}\n\tgetTarget() {\n\t\treturn this._targetNode;\n\t}\n\tsetTarget(node) {\n\t\tthis._targetNode = node;\n\t}\n}\nclass Skeleton {\n\tconstructor(graph) {\n\t\tthis.looping = true;\n\t\tthis._animation = null;\n\t\tthis._time = 0;\n\t\tthis._interpolatedKeys = [];\n\t\tthis._interpolatedKeyDict = {};\n\t\tthis._currKeyIndices = {};\n\t\tthis.graph = null;\n\t\tconst addInterpolatedKeys = node => {\n\t\t\tconst interpKey = new InterpolatedKey();\n\t\t\tinterpKey._name = node.name;\n\t\t\tthis._interpolatedKeys.push(interpKey);\n\t\t\tthis._interpolatedKeyDict[node.name] = interpKey;\n\t\t\tthis._currKeyIndices[node.name] = 0;\n\t\t\tfor (let i = 0; i < node._children.length; i++) addInterpolatedKeys(node._children[i]);\n\t\t};\n\t\taddInterpolatedKeys(graph);\n\t}\n\tset animation(value) {\n\t\tthis._animation = value;\n\t\tthis.currentTime = 0;\n\t}\n\tget animation() {\n\t\treturn this._animation;\n\t}\n\tset currentTime(value) {\n\t\tthis._time = value;\n\t\tconst numNodes = this._interpolatedKeys.length;\n\t\tfor (let i = 0; i < numNodes; i++) {\n\t\t\tconst node = this._interpolatedKeys[i];\n\t\t\tconst nodeName = node._name;\n\t\t\tthis._currKeyIndices[nodeName] = 0;\n\t\t}\n\t\tthis.addTime(0);\n\t\tthis.updateGraph();\n\t}\n\tget currentTime() {\n\t\treturn this._time;\n\t}\n\tget numNodes() {\n\t\treturn this._interpolatedKeys.length;\n\t}\n\taddTime(delta) {\n\t\tif (this._animation !== null) {\n\t\t\tconst nodes = this._animation._nodes;\n\t\t\tconst duration = this._animation.duration;\n\t\t\tif (this._time === duration && !this.looping) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tthis._time += delta;\n\t\t\tif (this._time > duration) {\n\t\t\t\tthis._time = this.looping ? 0.0 : duration;\n\t\t\t\tfor (let i = 0; i < nodes.length; i++) {\n\t\t\t\t\tconst node = nodes[i];\n\t\t\t\t\tconst nodeName = node._name;\n\t\t\t\t\tthis._currKeyIndices[nodeName] = 0;\n\t\t\t\t}\n\t\t\t} else if (this._time < 0) {\n\t\t\t\tthis._time = this.looping ? duration : 0.0;\n\t\t\t\tfor (let i = 0; i < nodes.length; i++) {\n\t\t\t\t\tconst node = nodes[i];\n\t\t\t\t\tconst nodeName = node._name;\n\t\t\t\t\tthis._currKeyIndices[nodeName] = node._keys.length - 2;\n\t\t\t\t}\n\t\t\t}\n\t\t\tconst offset = delta >= 0 ? 1 : -1;\n\t\t\tfor (let i = 0; i < nodes.length; i++) {\n\t\t\t\tconst node = nodes[i];\n\t\t\t\tconst nodeName = node._name;\n\t\t\t\tconst keys = node._keys;\n\t\t\t\tconst interpKey = this._interpolatedKeyDict[nodeName];\n\t\t\t\tif (interpKey === undefined) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tlet foundKey = false;\n\t\t\t\tif (keys.length !== 1) {\n\t\t\t\t\tfor (let currKeyIndex = this._currKeyIndices[nodeName]; currKeyIndex < keys.length - 1 && currKeyIndex >= 0; currKeyIndex += offset) {\n\t\t\t\t\t\tconst k1 = keys[currKeyIndex];\n\t\t\t\t\t\tconst k2 = keys[currKeyIndex + 1];\n\t\t\t\t\t\tif (k1.time <= this._time && k2.time >= this._time) {\n\t\t\t\t\t\t\tconst alpha = (this._time - k1.time) / (k2.time - k1.time);\n\t\t\t\t\t\t\tinterpKey._pos.lerp(k1.position, k2.position, alpha);\n\t\t\t\t\t\t\tinterpKey._quat.slerp(k1.rotation, k2.rotation, alpha);\n\t\t\t\t\t\t\tinterpKey._scale.lerp(k1.scale, k2.scale, alpha);\n\t\t\t\t\t\t\tinterpKey._written = true;\n\t\t\t\t\t\t\tthis._currKeyIndices[nodeName] = currKeyIndex;\n\t\t\t\t\t\t\tfoundKey = true;\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tif (keys.length === 1 || !foundKey && this._time === 0.0 && this.looping) {\n\t\t\t\t\tinterpKey._pos.copy(keys[0].position);\n\t\t\t\t\tinterpKey._quat.copy(keys[0].rotation);\n\t\t\t\t\tinterpKey._scale.copy(keys[0].scale);\n\t\t\t\t\tinterpKey._written = true;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\tblend(skel1, skel2, alpha) {\n\t\tconst numNodes = this._interpolatedKeys.length;\n\t\tfor (let i = 0; i < numNodes; i++) {\n\t\t\tconst key1 = skel1._interpolatedKeys[i];\n\t\t\tconst key2 = skel2._interpolatedKeys[i];\n\t\t\tconst dstKey = this._interpolatedKeys[i];\n\t\t\tif (key1._written && key2._written) {\n\t\t\t\tdstKey._quat.slerp(key1._quat, skel2._interpolatedKeys[i]._quat, alpha);\n\t\t\t\tdstKey._pos.lerp(key1._pos, skel2._interpolatedKeys[i]._pos, alpha);\n\t\t\t\tdstKey._scale.lerp(key1._scale, key2._scale, alpha);\n\t\t\t\tdstKey._written = true;\n\t\t\t} else if (key1._written) {\n\t\t\t\tdstKey._quat.copy(key1._quat);\n\t\t\t\tdstKey._pos.copy(key1._pos);\n\t\t\t\tdstKey._scale.copy(key1._scale);\n\t\t\t\tdstKey._written = true;\n\t\t\t} else if (key2._written) {\n\t\t\t\tdstKey._quat.copy(key2._quat);\n\t\t\t\tdstKey._pos.copy(key2._pos);\n\t\t\t\tdstKey._scale.copy(key2._scale);\n\t\t\t\tdstKey._written = true;\n\t\t\t}\n\t\t}\n\t}\n\tsetGraph(graph) {\n\t\tthis.graph = graph;\n\t\tif (graph) {\n\t\t\tfor (let i = 0; i < this._interpolatedKeys.length; i++) {\n\t\t\t\tconst interpKey = this._interpolatedKeys[i];\n\t\t\t\tconst graphNode = graph.findByName(interpKey._name);\n\t\t\t\tthis._interpolatedKeys[i].setTarget(graphNode);\n\t\t\t}\n\t\t} else {\n\t\t\tfor (let i = 0; i < this._interpolatedKeys.length; i++) {\n\t\t\t\tthis._interpolatedKeys[i].setTarget(null);\n\t\t\t}\n\t\t}\n\t}\n\tupdateGraph() {\n\t\tif (this.graph) {\n\t\t\tfor (let i = 0; i < this._interpolatedKeys.length; i++) {\n\t\t\t\tconst interpKey = this._interpolatedKeys[i];\n\t\t\t\tif (interpKey._written) {\n\t\t\t\t\tconst transform = interpKey.getTarget();\n\t\t\t\t\ttransform.localPosition.copy(interpKey._pos);\n\t\t\t\t\ttransform.localRotation.copy(interpKey._quat);\n\t\t\t\t\ttransform.localScale.copy(interpKey._scale);\n\t\t\t\t\tif (!transform._dirtyLocal) transform._dirtifyLocal();\n\t\t\t\t\tinterpKey._written = false;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n\nexport { Skeleton };\n", "import { Vec3 } from '../../core/math/vec3.js';\nimport { Geometry } from './geometry.js';\n\nconst primitiveUv1Padding = 4.0 / 64;\nconst primitiveUv1PaddingScale = 1.0 - primitiveUv1Padding * 2;\nclass ConeBaseGeometry extends Geometry {\n\tconstructor(baseRadius, peakRadius, height, heightSegments, capSegments, roundedCaps) {\n\t\tsuper();\n\t\tconst pos = new Vec3();\n\t\tconst bottomToTop = new Vec3();\n\t\tconst norm = new Vec3();\n\t\tconst top = new Vec3();\n\t\tconst bottom = new Vec3();\n\t\tconst tangent = new Vec3();\n\t\tconst positions = [];\n\t\tconst normals = [];\n\t\tconst uvs = [];\n\t\tconst uvs1 = [];\n\t\tconst indices = [];\n\t\tlet offset;\n\t\tif (height > 0) {\n\t\t\tfor (let i = 0; i <= heightSegments; i++) {\n\t\t\t\tfor (let j = 0; j <= capSegments; j++) {\n\t\t\t\t\tconst theta = j / capSegments * 2 * Math.PI - Math.PI;\n\t\t\t\t\tconst sinTheta = Math.sin(theta);\n\t\t\t\t\tconst cosTheta = Math.cos(theta);\n\t\t\t\t\tbottom.set(sinTheta * baseRadius, -height / 2, cosTheta * baseRadius);\n\t\t\t\t\ttop.set(sinTheta * peakRadius, height / 2, cosTheta * peakRadius);\n\t\t\t\t\tpos.lerp(bottom, top, i / heightSegments);\n\t\t\t\t\tbottomToTop.sub2(top, bottom).normalize();\n\t\t\t\t\ttangent.set(cosTheta, 0, -sinTheta);\n\t\t\t\t\tnorm.cross(tangent, bottomToTop).normalize();\n\t\t\t\t\tpositions.push(pos.x, pos.y, pos.z);\n\t\t\t\t\tnormals.push(norm.x, norm.y, norm.z);\n\t\t\t\t\tlet u = j / capSegments;\n\t\t\t\t\tlet v = i / heightSegments;\n\t\t\t\t\tuvs.push(u, 1 - v);\n\t\t\t\t\tconst _v = v;\n\t\t\t\t\tv = u;\n\t\t\t\t\tu = _v;\n\t\t\t\t\tu = u * primitiveUv1PaddingScale + primitiveUv1Padding;\n\t\t\t\t\tv = v * primitiveUv1PaddingScale + primitiveUv1Padding;\n\t\t\t\t\tu /= 3;\n\t\t\t\t\tuvs1.push(u, 1 - v);\n\t\t\t\t\tif (i < heightSegments && j < capSegments) {\n\t\t\t\t\t\tconst first = i * (capSegments + 1) + j;\n\t\t\t\t\t\tconst second = i * (capSegments + 1) + (j + 1);\n\t\t\t\t\t\tconst third = (i + 1) * (capSegments + 1) + j;\n\t\t\t\t\t\tconst fourth = (i + 1) * (capSegments + 1) + (j + 1);\n\t\t\t\t\t\tindices.push(first, second, third);\n\t\t\t\t\t\tindices.push(second, fourth, third);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (roundedCaps) {\n\t\t\tconst latitudeBands = Math.floor(capSegments / 2);\n\t\t\tconst longitudeBands = capSegments;\n\t\t\tconst capOffset = height / 2;\n\t\t\tfor (let lat = 0; lat <= latitudeBands; lat++) {\n\t\t\t\tconst theta = lat * Math.PI * 0.5 / latitudeBands;\n\t\t\t\tconst sinTheta = Math.sin(theta);\n\t\t\t\tconst cosTheta = Math.cos(theta);\n\t\t\t\tfor (let lon = 0; lon <= longitudeBands; lon++) {\n\t\t\t\t\tconst phi = lon * 2 * Math.PI / longitudeBands - Math.PI / 2;\n\t\t\t\t\tconst sinPhi = Math.sin(phi);\n\t\t\t\t\tconst cosPhi = Math.cos(phi);\n\t\t\t\t\tconst x = cosPhi * sinTheta;\n\t\t\t\t\tconst y = cosTheta;\n\t\t\t\t\tconst z = sinPhi * sinTheta;\n\t\t\t\t\tlet u = 1 - lon / longitudeBands;\n\t\t\t\t\tlet v = 1 - lat / latitudeBands;\n\t\t\t\t\tpositions.push(x * peakRadius, y * peakRadius + capOffset, z * peakRadius);\n\t\t\t\t\tnormals.push(x, y, z);\n\t\t\t\t\tuvs.push(u, 1 - v);\n\t\t\t\t\tu = u * primitiveUv1PaddingScale + primitiveUv1Padding;\n\t\t\t\t\tv = v * primitiveUv1PaddingScale + primitiveUv1Padding;\n\t\t\t\t\tu /= 3;\n\t\t\t\t\tv /= 3;\n\t\t\t\t\tu += 1.0 / 3;\n\t\t\t\t\tuvs1.push(u, 1 - v);\n\t\t\t\t}\n\t\t\t}\n\t\t\toffset = (heightSegments + 1) * (capSegments + 1);\n\t\t\tfor (let lat = 0; lat < latitudeBands; ++lat) {\n\t\t\t\tfor (let lon = 0; lon < longitudeBands; ++lon) {\n\t\t\t\t\tconst first = lat * (longitudeBands + 1) + lon;\n\t\t\t\t\tconst second = first + longitudeBands + 1;\n\t\t\t\t\tindices.push(offset + first + 1, offset + second, offset + first);\n\t\t\t\t\tindices.push(offset + first + 1, offset + second + 1, offset + second);\n\t\t\t\t}\n\t\t\t}\n\t\t\tfor (let lat = 0; lat <= latitudeBands; lat++) {\n\t\t\t\tconst theta = Math.PI * 0.5 + lat * Math.PI * 0.5 / latitudeBands;\n\t\t\t\tconst sinTheta = Math.sin(theta);\n\t\t\t\tconst cosTheta = Math.cos(theta);\n\t\t\t\tfor (let lon = 0; lon <= longitudeBands; lon++) {\n\t\t\t\t\tconst phi = lon * 2 * Math.PI / longitudeBands - Math.PI / 2;\n\t\t\t\t\tconst sinPhi = Math.sin(phi);\n\t\t\t\t\tconst cosPhi = Math.cos(phi);\n\t\t\t\t\tconst x = cosPhi * sinTheta;\n\t\t\t\t\tconst y = cosTheta;\n\t\t\t\t\tconst z = sinPhi * sinTheta;\n\t\t\t\t\tlet u = 1 - lon / longitudeBands;\n\t\t\t\t\tlet v = 1 - lat / latitudeBands;\n\t\t\t\t\tpositions.push(x * peakRadius, y * peakRadius - capOffset, z * peakRadius);\n\t\t\t\t\tnormals.push(x, y, z);\n\t\t\t\t\tuvs.push(u, 1 - v);\n\t\t\t\t\tu = u * primitiveUv1PaddingScale + primitiveUv1Padding;\n\t\t\t\t\tv = v * primitiveUv1PaddingScale + primitiveUv1Padding;\n\t\t\t\t\tu /= 3;\n\t\t\t\t\tv /= 3;\n\t\t\t\t\tu += 2.0 / 3;\n\t\t\t\t\tuvs1.push(u, 1 - v);\n\t\t\t\t}\n\t\t\t}\n\t\t\toffset = (heightSegments + 1) * (capSegments + 1) + (longitudeBands + 1) * (latitudeBands + 1);\n\t\t\tfor (let lat = 0; lat < latitudeBands; ++lat) {\n\t\t\t\tfor (let lon = 0; lon < longitudeBands; ++lon) {\n\t\t\t\t\tconst first = lat * (longitudeBands + 1) + lon;\n\t\t\t\t\tconst second = first + longitudeBands + 1;\n\t\t\t\t\tindices.push(offset + first + 1, offset + second, offset + first);\n\t\t\t\t\tindices.push(offset + first + 1, offset + second + 1, offset + second);\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\toffset = (heightSegments + 1) * (capSegments + 1);\n\t\t\tif (baseRadius > 0) {\n\t\t\t\tfor (let i = 0; i < capSegments; i++) {\n\t\t\t\t\tconst theta = i / capSegments * 2 * Math.PI;\n\t\t\t\t\tconst x = Math.sin(theta);\n\t\t\t\t\tconst y = -height / 2;\n\t\t\t\t\tconst z = Math.cos(theta);\n\t\t\t\t\tlet u = 1 - (x + 1) / 2;\n\t\t\t\t\tlet v = (z + 1) / 2;\n\t\t\t\t\tpositions.push(x * baseRadius, y, z * baseRadius);\n\t\t\t\t\tnormals.push(0, -1, 0);\n\t\t\t\t\tuvs.push(u, 1 - v);\n\t\t\t\t\tu = u * primitiveUv1PaddingScale + primitiveUv1Padding;\n\t\t\t\t\tv = v * primitiveUv1PaddingScale + primitiveUv1Padding;\n\t\t\t\t\tu /= 3;\n\t\t\t\t\tv /= 3;\n\t\t\t\t\tu += 1 / 3;\n\t\t\t\t\tuvs1.push(u, 1 - v);\n\t\t\t\t\tif (i > 1) {\n\t\t\t\t\t\tindices.push(offset, offset + i, offset + i - 1);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\toffset += capSegments;\n\t\t\tif (peakRadius > 0) {\n\t\t\t\tfor (let i = 0; i < capSegments; i++) {\n\t\t\t\t\tconst theta = i / capSegments * 2 * Math.PI;\n\t\t\t\t\tconst x = Math.sin(theta);\n\t\t\t\t\tconst y = height / 2;\n\t\t\t\t\tconst z = Math.cos(theta);\n\t\t\t\t\tlet u = 1 - (x + 1) / 2;\n\t\t\t\t\tlet v = (z + 1) / 2;\n\t\t\t\t\tpositions.push(x * peakRadius, y, z * peakRadius);\n\t\t\t\t\tnormals.push(0, 1, 0);\n\t\t\t\t\tuvs.push(u, 1 - v);\n\t\t\t\t\tu = u * primitiveUv1PaddingScale + primitiveUv1Padding;\n\t\t\t\t\tv = v * primitiveUv1PaddingScale + primitiveUv1Padding;\n\t\t\t\t\tu /= 3;\n\t\t\t\t\tv /= 3;\n\t\t\t\t\tu += 2 / 3;\n\t\t\t\t\tuvs1.push(u, 1 - v);\n\t\t\t\t\tif (i > 1) {\n\t\t\t\t\t\tindices.push(offset, offset + i - 1, offset + i);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tthis.positions = positions;\n\t\tthis.normals = normals;\n\t\tthis.uvs = uvs;\n\t\tthis.uvs1 = uvs1;\n\t\tthis.indices = indices;\n\t}\n}\n\nexport { ConeBaseGeometry };\n", "import { ConeBaseGeometry } from './cone-base-geometry.js';\nimport { calculateTangents } from './geometry-utils.js';\n\nclass CapsuleGeometry extends ConeBaseGeometry {\n\tconstructor(opts = {}) {\n\t\tvar _opts$radius, _opts$height, _opts$heightSegments, _opts$sides;\n\t\tconst radius = (_opts$radius = opts.radius) != null ? _opts$radius : 0.3;\n\t\tconst height = (_opts$height = opts.height) != null ? _opts$height : 1;\n\t\tconst heightSegments = (_opts$heightSegments = opts.heightSegments) != null ? _opts$heightSegments : 1;\n\t\tconst sides = (_opts$sides = opts.sides) != null ? _opts$sides : 20;\n\t\tsuper(radius, radius, height - 2 * radius, heightSegments, sides, true);\n\t\tif (opts.calculateTangents) {\n\t\t\tthis.tangents = calculateTangents(this.positions, this.normals, this.uvs, this.indices);\n\t\t}\n\t}\n}\n\nexport { CapsuleGeometry };\n", "import { ConeBaseGeometry } from './cone-base-geometry.js';\nimport { calculateTangents } from './geometry-utils.js';\n\nclass ConeGeometry extends ConeBaseGeometry {\n\tconstructor(opts = {}) {\n\t\tvar _opts$baseRadius, _opts$peakRadius, _opts$height, _opts$heightSegments, _opts$capSegments;\n\t\tconst baseRadius = (_opts$baseRadius = opts.baseRadius) != null ? _opts$baseRadius : 0.5;\n\t\tconst peakRadius = (_opts$peakRadius = opts.peakRadius) != null ? _opts$peakRadius : 0;\n\t\tconst height = (_opts$height = opts.height) != null ? _opts$height : 1;\n\t\tconst heightSegments = (_opts$heightSegments = opts.heightSegments) != null ? _opts$heightSegments : 5;\n\t\tconst capSegments = (_opts$capSegments = opts.capSegments) != null ? _opts$capSegments : 18;\n\t\tsuper(baseRadius, peakRadius, height, heightSegments, capSegments, false);\n\t\tif (opts.calculateTangents) {\n\t\t\tthis.tangents = calculateTangents(this.positions, this.normals, this.uvs, this.indices);\n\t\t}\n\t}\n}\n\nexport { ConeGeometry };\n", "import { ConeBaseGeometry } from './cone-base-geometry.js';\nimport { calculateTangents } from './geometry-utils.js';\n\nclass CylinderGeometry extends ConeBaseGeometry {\n\tconstructor(opts = {}) {\n\t\tvar _opts$radius, _opts$height, _opts$heightSegments, _opts$capSegments;\n\t\tconst radius = (_opts$radius = opts.radius) != null ? _opts$radius : 0.5;\n\t\tconst height = (_opts$height = opts.height) != null ? _opts$height : 1;\n\t\tconst heightSegments = (_opts$heightSegments = opts.heightSegments) != null ? _opts$heightSegments : 5;\n\t\tconst capSegments = (_opts$capSegments = opts.capSegments) != null ? _opts$capSegments : 20;\n\t\tsuper(radius, radius, height, heightSegments, capSegments, false);\n\t\tif (opts.calculateTangents) {\n\t\t\tthis.tangents = calculateTangents(this.positions, this.normals, this.uvs, this.indices);\n\t\t}\n\t}\n}\n\nexport { CylinderGeometry };\n", "import { Vec2 } from '../../core/math/vec2.js';\nimport { calculateTangents } from './geometry-utils.js';\nimport { Geometry } from './geometry.js';\n\nclass PlaneGeometry extends Geometry {\n\tconstructor(opts = {}) {\n\t\tvar _opts$halfExtents, _opts$widthSegments, _opts$lengthSegments;\n\t\tsuper();\n\t\tconst he = (_opts$halfExtents = opts.halfExtents) != null ? _opts$halfExtents : new Vec2(0.5, 0.5);\n\t\tconst ws = (_opts$widthSegments = opts.widthSegments) != null ? _opts$widthSegments : 5;\n\t\tconst ls = (_opts$lengthSegments = opts.lengthSegments) != null ? _opts$lengthSegments : 5;\n\t\tconst positions = [];\n\t\tconst normals = [];\n\t\tconst uvs = [];\n\t\tconst indices = [];\n\t\tlet vcounter = 0;\n\t\tfor (let i = 0; i <= ws; i++) {\n\t\t\tfor (let j = 0; j <= ls; j++) {\n\t\t\t\tconst x = -he.x + 2 * he.x * i / ws;\n\t\t\t\tconst y = 0.0;\n\t\t\t\tconst z = -(-he.y + 2 * he.y * j / ls);\n\t\t\t\tconst u = i / ws;\n\t\t\t\tconst v = j / ls;\n\t\t\t\tpositions.push(x, y, z);\n\t\t\t\tnormals.push(0, 1, 0);\n\t\t\t\tuvs.push(u, 1 - v);\n\t\t\t\tif (i < ws && j < ls) {\n\t\t\t\t\tindices.push(vcounter + ls + 1, vcounter + 1, vcounter);\n\t\t\t\t\tindices.push(vcounter + ls + 1, vcounter + ls + 2, vcounter + 1);\n\t\t\t\t}\n\t\t\t\tvcounter++;\n\t\t\t}\n\t\t}\n\t\tthis.positions = positions;\n\t\tthis.normals = normals;\n\t\tthis.uvs = uvs;\n\t\tthis.uvs1 = uvs;\n\t\tthis.indices = indices;\n\t\tif (opts.calculateTangents) {\n\t\t\tthis.tangents = calculateTangents(positions, normals, uvs, indices);\n\t\t}\n\t}\n}\n\nexport { PlaneGeometry };\n", "import { math } from '../../core/math/math.js';\nimport { calculateTangents } from './geometry-utils.js';\nimport { Geometry } from './geometry.js';\n\nclass TorusGeometry extends Geometry {\n\tconstructor(opts = {}) {\n\t\tvar _opts$tubeRadius, _opts$ringRadius, _opts$sectorAngle, _opts$segments, _opts$sides;\n\t\tsuper();\n\t\tconst rc = (_opts$tubeRadius = opts.tubeRadius) != null ? _opts$tubeRadius : 0.2;\n\t\tconst rt = (_opts$ringRadius = opts.ringRadius) != null ? _opts$ringRadius : 0.3;\n\t\tconst sectorAngle = ((_opts$sectorAngle = opts.sectorAngle) != null ? _opts$sectorAngle : 360) * math.DEG_TO_RAD;\n\t\tconst segments = (_opts$segments = opts.segments) != null ? _opts$segments : 30;\n\t\tconst sides = (_opts$sides = opts.sides) != null ? _opts$sides : 20;\n\t\tconst positions = [];\n\t\tconst normals = [];\n\t\tconst uvs = [];\n\t\tconst indices = [];\n\t\tfor (let i = 0; i <= sides; i++) {\n\t\t\tfor (let j = 0; j <= segments; j++) {\n\t\t\t\tconst x = Math.cos(sectorAngle * j / segments) * (rt + rc * Math.cos(2 * Math.PI * i / sides));\n\t\t\t\tconst y = Math.sin(2 * Math.PI * i / sides) * rc;\n\t\t\t\tconst z = Math.sin(sectorAngle * j / segments) * (rt + rc * Math.cos(2 * Math.PI * i / sides));\n\t\t\t\tconst nx = Math.cos(sectorAngle * j / segments) * Math.cos(2 * Math.PI * i / sides);\n\t\t\t\tconst ny = Math.sin(2 * Math.PI * i / sides);\n\t\t\t\tconst nz = Math.sin(sectorAngle * j / segments) * Math.cos(2 * Math.PI * i / sides);\n\t\t\t\tconst u = i / sides;\n\t\t\t\tconst v = 1 - j / segments;\n\t\t\t\tpositions.push(x, y, z);\n\t\t\t\tnormals.push(nx, ny, nz);\n\t\t\t\tuvs.push(u, 1.0 - v);\n\t\t\t\tif (i < sides && j < segments) {\n\t\t\t\t\tconst first = i * (segments + 1) + j;\n\t\t\t\t\tconst second = (i + 1) * (segments + 1) + j;\n\t\t\t\t\tconst third = i * (segments + 1) + (j + 1);\n\t\t\t\t\tconst fourth = (i + 1) * (segments + 1) + (j + 1);\n\t\t\t\t\tindices.push(first, second, third);\n\t\t\t\t\tindices.push(second, fourth, third);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tthis.positions = positions;\n\t\tthis.normals = normals;\n\t\tthis.uvs = uvs;\n\t\tthis.uvs1 = uvs;\n\t\tthis.indices = indices;\n\t\tif (opts.calculateTangents) {\n\t\t\tthis.tangents = calculateTangents(positions, normals, uvs, indices);\n\t\t}\n\t}\n}\n\nexport { TorusGeometry };\n", "import { hashCode } from '../../core/hash.js';\nimport { version, revision } from '../../core/core.js';\nimport { Shader } from '../../platform/graphics/shader.js';\nimport { SHADER_FORWARD, SHADER_SHADOW, SHADER_DEPTH, SHADER_PICK, SHADER_PREPASS_VELOCITY } from '../constants.js';\nimport { ShaderPass } from '../shader-pass.js';\nimport { StandardMaterialOptions } from '../materials/standard-material-options.js';\n\nclass ProgramLibrary {\n\tconstructor(device, standardMaterial) {\n\t\tthis.processedCache = new Map();\n\t\tthis.definitionsCache = new Map();\n\t\tthis._generators = new Map();\n\t\tthis._device = device;\n\t\tthis._isClearingCache = false;\n\t\tthis._precached = false;\n\t\tthis._programsCollection = [];\n\t\tthis._defaultStdMatOption = new StandardMaterialOptions();\n\t\tthis._defaultStdMatOptionMin = new StandardMaterialOptions();\n\t\tstandardMaterial.shaderOptBuilder.updateRef(this._defaultStdMatOption, {}, standardMaterial, null, [], SHADER_FORWARD, null);\n\t\tstandardMaterial.shaderOptBuilder.updateMinRef(this._defaultStdMatOptionMin, {}, standardMaterial, null, SHADER_SHADOW, null);\n\t\tdevice.on('destroy:shader', shader => {\n\t\t\tthis.removeFromCache(shader);\n\t\t});\n\t}\n\tdestroy() {\n\t\tthis.clearCache();\n\t}\n\tregister(name, generator) {\n\t\tif (!this._generators.has(name)) {\n\t\t\tthis._generators.set(name, generator);\n\t\t}\n\t}\n\tunregister(name) {\n\t\tif (this._generators.has(name)) {\n\t\t\tthis._generators.delete(name);\n\t\t}\n\t}\n\tisRegistered(name) {\n\t\treturn this._generators.has(name);\n\t}\n\tgenerateShaderDefinition(generator, name, key, options) {\n\t\tlet def = this.definitionsCache.get(key);\n\t\tif (!def) {\n\t\t\tvar _options$litOptions, _options$litOptions2, _def$name;\n\t\t\tlet lights;\n\t\t\tif ((_options$litOptions = options.litOptions) != null && _options$litOptions.lights) {\n\t\t\t\tlights = options.litOptions.lights;\n\t\t\t\toptions.litOptions.lights = lights.map(function (l) {\n\t\t\t\t\tconst lcopy = l.clone ? l.clone() : l;\n\t\t\t\t\tlcopy.key = l.key;\n\t\t\t\t\treturn lcopy;\n\t\t\t\t});\n\t\t\t}\n\t\t\tthis.storeNewProgram(name, options);\n\t\t\tif ((_options$litOptions2 = options.litOptions) != null && _options$litOptions2.lights) options.litOptions.lights = lights;\n\t\t\tif (this._precached) ;\n\t\t\tconst device = this._device;\n\t\t\tdef = generator.createShaderDefinition(device, options);\n\t\t\tdef.name = (_def$name = def.name) != null ? _def$name : options.pass ? `${name}-pass:${options.pass}` : name;\n\t\t\tthis.definitionsCache.set(key, def);\n\t\t}\n\t\treturn def;\n\t}\n\tgetCachedShader(key) {\n\t\treturn this.processedCache.get(key);\n\t}\n\tsetCachedShader(key, shader) {\n\t\tthis.processedCache.set(key, shader);\n\t}\n\tgetProgram(name, options, processingOptions, userMaterialId) {\n\t\tconst generator = this._generators.get(name);\n\t\tif (!generator) {\n\t\t\treturn null;\n\t\t}\n\t\tconst generationKeyString = generator.generateKey(options);\n\t\tconst generationKey = hashCode(generationKeyString);\n\t\tconst processingKeyString = processingOptions.generateKey(this._device);\n\t\tconst processingKey = hashCode(processingKeyString);\n\t\tconst totalKey = `${generationKey}#${processingKey}`;\n\t\tlet processedShader = this.getCachedShader(totalKey);\n\t\tif (!processedShader) {\n\t\t\tconst generatedShaderDef = this.generateShaderDefinition(generator, name, generationKey, options);\n\t\t\tlet passName = '';\n\t\t\tlet shaderPassInfo;\n\t\t\tif (options.pass !== undefined) {\n\t\t\t\tshaderPassInfo = ShaderPass.get(this._device).getByIndex(options.pass);\n\t\t\t\tpassName = `-${shaderPassInfo.name}`;\n\t\t\t}\n\t\t\tthis._device.fire('shader:generate', {\n\t\t\t\tuserMaterialId,\n\t\t\t\tshaderPassInfo,\n\t\t\t\tdefinition: generatedShaderDef\n\t\t\t});\n\t\t\tconst shaderDefinition = {\n\t\t\t\tname: `${generatedShaderDef.name}${passName}-proc`,\n\t\t\t\tattributes: generatedShaderDef.attributes,\n\t\t\t\tvshader: generatedShaderDef.vshader,\n\t\t\t\tvincludes: generatedShaderDef.vincludes,\n\t\t\t\tfincludes: generatedShaderDef.fincludes,\n\t\t\t\tfshader: generatedShaderDef.fshader,\n\t\t\t\tprocessingOptions: processingOptions,\n\t\t\t\tshaderLanguage: generatedShaderDef.shaderLanguage\n\t\t\t};\n\t\t\tprocessedShader = new Shader(this._device, shaderDefinition);\n\t\t\tthis.setCachedShader(totalKey, processedShader);\n\t\t}\n\t\treturn processedShader;\n\t}\n\tstoreNewProgram(name, options) {\n\t\tlet opt = {};\n\t\tif (name === \"standard\") {\n\t\t\tconst defaultMat = this._getDefaultStdMatOptions(options.pass);\n\t\t\tfor (const p in options) {\n\t\t\t\tif (options.hasOwnProperty(p) && defaultMat[p] !== options[p] || p === \"pass\") opt[p] = options[p];\n\t\t\t}\n\t\t\tfor (const p in options.litOptions) {\n\t\t\t\topt[p] = options.litOptions[p];\n\t\t\t}\n\t\t} else {\n\t\t\topt = options;\n\t\t}\n\t\tthis._programsCollection.push(JSON.stringify({\n\t\t\tname: name,\n\t\t\toptions: opt\n\t\t}));\n\t}\n\tdumpPrograms() {\n\t\tlet text = 'let device = pc.app ? pc.app.graphicsDevice : pc.Application.getApplication().graphicsDevice;\\n';\n\t\ttext += 'let shaders = [';\n\t\tif (this._programsCollection[0]) text += '\\n\\t' + this._programsCollection[0];\n\t\tfor (let i = 1; i < this._programsCollection.length; ++i) {\n\t\t\ttext += ',\\n\\t' + this._programsCollection[i];\n\t\t}\n\t\ttext += '\\n];\\n';\n\t\ttext += 'device.getProgramLibrary().precompile(shaders);\\n';\n\t\ttext += 'if (pc.version != \\\"' + version + '\\\" || pc.revision != \\\"' + revision + '\\\")\\n';\n\t\ttext += '\\tconsole.warn(\\\"precompile-shaders.js: engine version mismatch, rebuild shaders lib with current engine\\\");';\n\t\tconst element = document.createElement('a');\n\t\telement.setAttribute('href', 'data:text/plain;charset=utf-8,' + encodeURIComponent(text));\n\t\telement.setAttribute('download', 'precompile-shaders.js');\n\t\telement.style.display = 'none';\n\t\tdocument.body.appendChild(element);\n\t\telement.click();\n\t\tdocument.body.removeChild(element);\n\t}\n\tclearCache() {\n\t\tthis._isClearingCache = true;\n\t\tthis.processedCache.forEach(shader => {\n\t\t\tshader.destroy();\n\t\t});\n\t\tthis.processedCache.clear();\n\t\tthis._isClearingCache = false;\n\t}\n\tremoveFromCache(shader) {\n\t\tif (this._isClearingCache) return;\n\t\tthis.processedCache.forEach((cachedShader, key) => {\n\t\t\tif (shader === cachedShader) {\n\t\t\t\tthis.processedCache.delete(key);\n\t\t\t}\n\t\t});\n\t}\n\t_getDefaultStdMatOptions(pass) {\n\t\tconst shaderPassInfo = ShaderPass.get(this._device).getByIndex(pass);\n\t\treturn pass === SHADER_DEPTH || pass === SHADER_PICK || pass === SHADER_PREPASS_VELOCITY || shaderPassInfo.isShadow ? this._defaultStdMatOptionMin : this._defaultStdMatOption;\n\t}\n\tprecompile(cache) {\n\t\tif (cache) {\n\t\t\tconst shaders = new Array(cache.length);\n\t\t\tfor (let i = 0; i < cache.length; i++) {\n\t\t\t\tif (cache[i].name === \"standard\") {\n\t\t\t\t\tconst opt = cache[i].options;\n\t\t\t\t\tconst defaultMat = this._getDefaultStdMatOptions(opt.pass);\n\t\t\t\t\tfor (const p in defaultMat) {\n\t\t\t\t\t\tif (defaultMat.hasOwnProperty(p) && opt[p] === undefined) opt[p] = defaultMat[p];\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tshaders[i] = this.getProgram(cache[i].name, cache[i].options);\n\t\t\t}\n\t\t}\n\t\tthis._precached = true;\n\t}\n}\n\nexport { ProgramLibrary };\n", "const FILLMODE_NONE = 'NONE';\nconst FILLMODE_FILL_WINDOW = 'FILL_WINDOW';\nconst FILLMODE_KEEP_ASPECT = 'KEEP_ASPECT';\nconst RESOLUTION_AUTO = 'AUTO';\nconst RESOLUTION_FIXED = 'FIXED';\n\nexport { FILLMODE_FILL_WINDOW, FILLMODE_KEEP_ASPECT, FILLMODE_NONE, RESOLUTION_AUTO, RESOLUTION_FIXED };\n", "let currentApplication;\nfunction getApplication() {\n\treturn currentApplication;\n}\nfunction setApplication(app) {\n\tcurrentApplication = app;\n}\n\nexport { getApplication, setApplication };\n", "class ScriptTypes {\n\tstatic push(Type, isLegacy) {\n\t\tif (isLegacy && ScriptTypes._types.length > 0) {\n\t\t\tconsole.assert('Script Ordering Error. Contact support@playcanvas.com');\n\t\t} else {\n\t\t\tScriptTypes._types.push(Type);\n\t\t}\n\t}\n}\nScriptTypes._types = [];\n\nexport { ScriptTypes };\n", "import { events } from '../core/events.js';\nimport { getApplication } from './globals.js';\nimport { ScriptTypes } from './script/script-types.js';\n\nlet _legacy = false;\nlet _createdLoadingScreen = false;\nconst script = {\n\tapp: null,\n\tcreate(name, callback) {\n\t\tif (!_legacy) return;\n\t\tconst ScriptType = callback(script.app);\n\t\tScriptType._pcScriptName = name;\n\t\tScriptTypes.push(ScriptType, _legacy);\n\t\tthis.fire(\"created\", name, callback);\n\t},\n\tattribute(name, type, defaultValue, options) {},\n\tcreateLoadingScreen(callback) {\n\t\tif (_createdLoadingScreen) return;\n\t\t_createdLoadingScreen = true;\n\t\tconst app = getApplication();\n\t\tcallback(app);\n\t}\n};\nObject.defineProperty(script, 'legacy', {\n\tget: function () {\n\t\treturn _legacy;\n\t},\n\tset: function (value) {\n\t\t_legacy = value;\n\t}\n});\nevents.attach(script);\n\nexport { script };\n", "class FrameGraph {\n\tconstructor() {\n\t\tthis.renderPasses = [];\n\t\tthis.renderTargetMap = new Map();\n\t}\n\taddRenderPass(renderPass) {\n\t\trenderPass.frameUpdate();\n\t\tconst beforePasses = renderPass.beforePasses;\n\t\tfor (let i = 0; i < beforePasses.length; i++) {\n\t\t\tconst pass = beforePasses[i];\n\t\t\tif (pass.enabled) {\n\t\t\t\tthis.addRenderPass(pass);\n\t\t\t}\n\t\t}\n\t\tif (renderPass.enabled) {\n\t\t\tthis.renderPasses.push(renderPass);\n\t\t}\n\t\tconst afterPasses = renderPass.afterPasses;\n\t\tfor (let i = 0; i < afterPasses.length; i++) {\n\t\t\tconst pass = afterPasses[i];\n\t\t\tif (pass.enabled) {\n\t\t\t\tthis.addRenderPass(pass);\n\t\t\t}\n\t\t}\n\t}\n\treset() {\n\t\tthis.renderPasses.length = 0;\n\t}\n\tcompile() {\n\t\tconst renderTargetMap = this.renderTargetMap;\n\t\tconst renderPasses = this.renderPasses;\n\t\tfor (let i = 0; i < renderPasses.length; i++) {\n\t\t\tconst renderPass = renderPasses[i];\n\t\t\tconst renderTarget = renderPass.renderTarget;\n\t\t\tif (renderTarget !== undefined) {\n\t\t\t\tconst prevPass = renderTargetMap.get(renderTarget);\n\t\t\t\tif (prevPass) {\n\t\t\t\t\tconst count = renderPass.colorArrayOps.length;\n\t\t\t\t\tfor (let j = 0; j < count; j++) {\n\t\t\t\t\t\tconst colorOps = renderPass.colorArrayOps[j];\n\t\t\t\t\t\tif (!colorOps.clear) {\n\t\t\t\t\t\t\tprevPass.colorArrayOps[j].store = true;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif (!renderPass.depthStencilOps.clearDepth) {\n\t\t\t\t\t\tprevPass.depthStencilOps.storeDepth = true;\n\t\t\t\t\t}\n\t\t\t\t\tif (!renderPass.depthStencilOps.clearStencil) {\n\t\t\t\t\t\tprevPass.depthStencilOps.storeStencil = true;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\trenderTargetMap.set(renderTarget, renderPass);\n\t\t\t}\n\t\t}\n\t\tlet lastCubeTexture = null;\n\t\tlet lastCubeRenderPass = null;\n\t\tfor (let i = 0; i < renderPasses.length; i++) {\n\t\t\tconst renderPass = renderPasses[i];\n\t\t\tconst renderTarget = renderPass.renderTarget;\n\t\t\tconst thisTexture = renderTarget == null ? void 0 : renderTarget.colorBuffer;\n\t\t\tif (thisTexture != null && thisTexture.cubemap) {\n\t\t\t\tif (lastCubeTexture === thisTexture) {\n\t\t\t\t\tconst count = lastCubeRenderPass.colorArrayOps.length;\n\t\t\t\t\tfor (let j = 0; j < count; j++) {\n\t\t\t\t\t\tlastCubeRenderPass.colorArrayOps[j].mipmaps = false;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tlastCubeTexture = renderTarget.colorBuffer;\n\t\t\t\tlastCubeRenderPass = renderPass;\n\t\t\t} else if (renderPass.requiresCubemaps) {\n\t\t\t\tlastCubeTexture = null;\n\t\t\t\tlastCubeRenderPass = null;\n\t\t\t}\n\t\t}\n\t\trenderTargetMap.clear();\n\t}\n\trender(device) {\n\t\tthis.compile();\n\t\tconst renderPasses = this.renderPasses;\n\t\tfor (let i = 0; i < renderPasses.length; i++) {\n\t\t\trenderPasses[i].render();\n\t\t}\n\t}\n}\n\nexport { FrameGraph };\n", "import { FloatPacking } from '../core/math/float-packing.js';\nimport { Texture } from '../platform/graphics/texture.js';\nimport { DeviceCache } from '../platform/graphics/device-cache.js';\nimport { ADDRESS_CLAMP_TO_EDGE, TEXTURETYPE_DEFAULT, FILTER_LINEAR, FILTER_NEAREST, PIXELFORMAT_RGBA32F, PIXELFORMAT_RGBA16F } from '../platform/graphics/constants.js';\n\nclass AreaLightCacheEntry {\n\tconstructor(texture0, texture1) {\n\t\tthis.texture0 = texture0;\n\t\tthis.texture1 = texture1;\n\t}\n\tdestroy() {\n\t\tvar _this$texture, _this$texture2;\n\t\t(_this$texture = this.texture0) == null || _this$texture.destroy();\n\t\t(_this$texture2 = this.texture1) == null || _this$texture2.destroy();\n\t}\n}\nconst deviceCache = new DeviceCache();\nclass AreaLightLuts {\n\tstatic createTexture(device, format, size, postfix = '') {\n\t\tconst tex = new Texture(device, {\n\t\t\tname: `AreaLightLUT${postfix}`,\n\t\t\twidth: size,\n\t\t\theight: size,\n\t\t\tformat: format,\n\t\t\taddressU: ADDRESS_CLAMP_TO_EDGE,\n\t\t\taddressV: ADDRESS_CLAMP_TO_EDGE,\n\t\t\ttype: TEXTURETYPE_DEFAULT,\n\t\t\tmagFilter: FILTER_LINEAR,\n\t\t\tminFilter: FILTER_NEAREST,\n\t\t\tanisotropy: 1,\n\t\t\tmipmaps: false\n\t\t});\n\t\treturn tex;\n\t}\n\tstatic applyTextures(device, texture1, texture2) {\n\t\tdeviceCache.remove(device);\n\t\tdeviceCache.get(device, () => {\n\t\t\treturn new AreaLightCacheEntry(texture1, texture1 === texture2 ? null : texture2);\n\t\t});\n\t\tdevice.scope.resolve('areaLightsLutTex1').setValue(texture1);\n\t\tdevice.scope.resolve('areaLightsLutTex2').setValue(texture2);\n\t}\n\tstatic createPlaceholder(device) {\n\t\tconst texture = AreaLightLuts.createTexture(device, device.areaLightLutFormat, 2, 'placeholder');\n\t\tconst pixels = texture.lock();\n\t\tpixels.fill(0);\n\t\ttexture.unlock();\n\t\tAreaLightLuts.applyTextures(device, texture, texture);\n\t}\n\tstatic set(device, ltcMat1, ltcMat2) {\n\t\tfunction buildTexture(device, data, format) {\n\t\t\tconst texture = AreaLightLuts.createTexture(device, format, 64);\n\t\t\ttexture.lock().set(data);\n\t\t\ttexture.unlock();\n\t\t\treturn texture;\n\t\t}\n\t\tfunction offsetScale(data, offset, scale) {\n\t\t\tconst count = data.length;\n\t\t\tconst ret = new Float32Array(count);\n\t\t\tfor (let i = 0; i < count; i++) {\n\t\t\t\tconst n = i % 4;\n\t\t\t\tret[i] = (data[i] + offset[n]) * scale[n];\n\t\t\t}\n\t\t\treturn ret;\n\t\t}\n\t\tfunction convertToHalfFloat(data) {\n\t\t\tconst count = data.length;\n\t\t\tconst ret = new Uint16Array(count);\n\t\t\tconst float2Half = FloatPacking.float2Half;\n\t\t\tfor (let i = 0; i < count; i++) {\n\t\t\t\tret[i] = float2Half(data[i]);\n\t\t\t}\n\t\t\treturn ret;\n\t\t}\n\t\tfunction convertToUint(data) {\n\t\t\tconst count = data.length;\n\t\t\tconst ret = new Uint8ClampedArray(count);\n\t\t\tfor (let i = 0; i < count; i++) {\n\t\t\t\tret[i] = data[i] * 255;\n\t\t\t}\n\t\t\treturn ret;\n\t\t}\n\t\tconst srcData1 = ltcMat1;\n\t\tconst srcData2 = ltcMat2;\n\t\tlet data1, data2;\n\t\tconst format = device.areaLightLutFormat;\n\t\tif (format === PIXELFORMAT_RGBA32F) {\n\t\t\tdata1 = srcData1;\n\t\t\tdata2 = srcData2;\n\t\t} else if (format === PIXELFORMAT_RGBA16F) {\n\t\t\tdata1 = convertToHalfFloat(srcData1);\n\t\t\tdata2 = convertToHalfFloat(srcData2);\n\t\t} else {\n\t\t\tconst o1 = [0.0, 0.2976, 0.01381, 0.0];\n\t\t\tconst s1 = [0.999, 3.08737, 1.6546, 0.603249];\n\t\t\tconst o2 = [-0.306897, 0.0, 0.0, 0.0];\n\t\t\tconst s2 = [1.442787, 1.0, 1.0, 1.0];\n\t\t\tdata1 = convertToUint(offsetScale(srcData1, o1, s1));\n\t\t\tdata2 = convertToUint(offsetScale(srcData2, o2, s2));\n\t\t}\n\t\tconst tex1 = buildTexture(device, data1, format);\n\t\tconst tex2 = buildTexture(device, data2, format);\n\t\tAreaLightLuts.applyTextures(device, tex1, tex2);\n\t}\n}\n\nexport { AreaLightLuts };\n", "const DEFAULT_LOCALE = 'en-US';\nconst DEFAULT_LOCALE_FALLBACKS = {\n\t'en': 'en-US',\n\t'es': 'en-ES',\n\t'zh': 'zh-CN',\n\t'zh-HK': 'zh-TW',\n\t'zh-TW': 'zh-HK',\n\t'zh-MO': 'zh-HK',\n\t'fr': 'fr-FR',\n\t'de': 'de-DE',\n\t'it': 'it-IT',\n\t'ru': 'ru-RU',\n\t'ja': 'ja-JP'\n};\n\nexport { DEFAULT_LOCALE, DEFAULT_LOCALE_FALLBACKS };\n", "import { DEFAULT_LOCALE_FALLBACKS, DEFAULT_LOCALE } from './constants.js';\n\nconst PLURALS = {};\nfunction definePluralFn(locales, fn) {\n\tfor (let i = 0, len = locales.length; i < len; i++) {\n\t\tPLURALS[locales[i]] = fn;\n\t}\n}\nfunction getLang(locale) {\n\tconst idx = locale.indexOf('-');\n\tif (idx !== -1) {\n\t\treturn locale.substring(0, idx);\n\t}\n\treturn locale;\n}\nfunction replaceLang(locale, desiredLang) {\n\tconst idx = locale.indexOf('-');\n\tif (idx !== -1) {\n\t\treturn desiredLang + locale.substring(idx);\n\t}\n\treturn desiredLang;\n}\nfunction findAvailableLocale(desiredLocale, availableLocales) {\n\tif (availableLocales[desiredLocale]) {\n\t\treturn desiredLocale;\n\t}\n\tlet fallback = DEFAULT_LOCALE_FALLBACKS[desiredLocale];\n\tif (fallback && availableLocales[fallback]) {\n\t\treturn fallback;\n\t}\n\tconst lang = getLang(desiredLocale);\n\tfallback = DEFAULT_LOCALE_FALLBACKS[lang];\n\tif (availableLocales[fallback]) {\n\t\treturn fallback;\n\t}\n\tif (availableLocales[lang]) {\n\t\treturn lang;\n\t}\n\treturn DEFAULT_LOCALE;\n}\ndefinePluralFn(['ja', 'ko', 'th', 'vi', 'zh', 'id'], function (n) {\n\treturn 0;\n});\ndefinePluralFn(['fa', 'hi'], function (n) {\n\tif (n >= 0 && n <= 1) {\n\t\treturn 0;\n\t}\n\treturn 1;\n});\ndefinePluralFn(['fr', 'pt'], function (n) {\n\tif (n >= 0 && n < 2) {\n\t\treturn 0;\n\t}\n\treturn 1;\n});\ndefinePluralFn(['da'], function (n) {\n\tif (n === 1 || !Number.isInteger(n) && n >= 0 && n <= 1) {\n\t\treturn 0;\n\t}\n\treturn 1;\n});\ndefinePluralFn(['de', 'en', 'it', 'el', 'es', 'tr', 'fi', 'sv', 'nb', 'no', 'ur'], function (n) {\n\tif (n === 1) {\n\t\treturn 0;\n\t}\n\treturn 1;\n});\ndefinePluralFn(['ru', 'uk'], function (n) {\n\tif (Number.isInteger(n)) {\n\t\tconst mod10 = n % 10;\n\t\tconst mod100 = n % 100;\n\t\tif (mod10 === 1 && mod100 !== 11) {\n\t\t\treturn 0;\n\t\t} else if (mod10 >= 2 && mod10 <= 4 && (mod100 < 12 || mod100 > 14)) {\n\t\t\treturn 1;\n\t\t} else if (mod10 === 0 || mod10 >= 5 && mod10 <= 9 || mod100 >= 11 && mod100 <= 14) {\n\t\t\treturn 2;\n\t\t}\n\t}\n\treturn 3;\n});\ndefinePluralFn(['pl'], function (n) {\n\tif (Number.isInteger(n)) {\n\t\tif (n === 1) {\n\t\t\treturn 0;\n\t\t}\n\t\tconst mod10 = n % 10;\n\t\tconst mod100 = n % 100;\n\t\tif (mod10 >= 2 && mod10 <= 4 && (mod100 < 12 || mod100 > 14)) {\n\t\t\treturn 1;\n\t\t} else if (mod10 >= 0 && mod10 <= 1 || mod10 >= 5 && mod10 <= 9 || mod100 >= 12 && mod100 <= 14) {\n\t\t\treturn 2;\n\t\t}\n\t}\n\treturn 3;\n});\ndefinePluralFn(['ar'], function (n) {\n\tif (n === 0) {\n\t\treturn 0;\n\t} else if (n === 1) {\n\t\treturn 1;\n\t} else if (n === 2) {\n\t\treturn 2;\n\t}\n\tif (Number.isInteger(n)) {\n\t\tconst mod100 = n % 100;\n\t\tif (mod100 >= 3 && mod100 <= 10) {\n\t\t\treturn 3;\n\t\t} else if (mod100 >= 11 && mod100 <= 99) {\n\t\t\treturn 4;\n\t\t}\n\t}\n\treturn 5;\n});\nconst DEFAULT_PLURAL_FN = PLURALS[getLang(DEFAULT_LOCALE)];\nfunction getPluralFn(lang) {\n\treturn PLURALS[lang] || DEFAULT_PLURAL_FN;\n}\n\nexport { findAvailableLocale, getLang, getPluralFn, replaceLang };\n", "const ABSOLUTE_URL = new RegExp('^' + '\\\\s*' + '(?:' + '(?:' + '[a-z]+[a-z0-9\\\\-\\\\+\\\\.]*' + ':' + ')?' + '//' + '|' + 'data:' + '|blob:' + ')', 'i');\nconst ASSET_ANIMATION = 'animation';\nconst ASSET_AUDIO = 'audio';\nconst ASSET_IMAGE = 'image';\nconst ASSET_JSON = 'json';\nconst ASSET_MODEL = 'model';\nconst ASSET_MATERIAL = 'material';\nconst ASSET_TEXT = 'text';\nconst ASSET_TEXTURE = 'texture';\nconst ASSET_TEXTUREATLAS = 'textureatlas';\nconst ASSET_CUBEMAP = 'cubemap';\nconst ASSET_SHADER = 'shader';\nconst ASSET_CSS = 'css';\nconst ASSET_HTML = 'html';\nconst ASSET_SCRIPT = 'script';\nconst ASSET_CONTAINER = 'container';\n\nexport { ABSOLUTE_URL, ASSET_ANIMATION, ASSET_AUDIO, ASSET_CONTAINER, ASSET_CSS, ASSET_CUBEMAP, ASSET_HTML, ASSET_IMAGE, ASSET_JSON, ASSET_MATERIAL, ASSET_MODEL, ASSET_SCRIPT, ASSET_SHADER, ASSET_TEXT, ASSET_TEXTURE, ASSET_TEXTUREATLAS };\n", "class AssetFile {\n\tconstructor(url = '', filename = '', hash = null, size = null, opt = null, contents = null) {\n\t\tthis.url = url;\n\t\tthis.filename = filename;\n\t\tthis.hash = hash;\n\t\tthis.size = size;\n\t\tthis.opt = opt;\n\t\tthis.contents = contents;\n\t}\n\tequals(other) {\n\t\treturn this.url === other.url && this.filename === other.filename && this.hash === other.hash && this.size === other.size && this.opt === other.opt && this.contents === other.contents;\n\t}\n}\n\nexport { AssetFile };\n", "import { path } from '../../core/path.js';\nimport { Tags } from '../../core/tags.js';\nimport { EventHandler } from '../../core/event-handler.js';\nimport { findAvailableLocale } from '../i18n/utils.js';\nimport { ABSOLUTE_URL } from './constants.js';\nimport { AssetFile } from './asset-file.js';\nimport { getApplication } from '../globals.js';\nimport { http } from '../../platform/net/http.js';\n\nlet assetIdCounter = -1;\nconst VARIANT_SUPPORT = {\n\tpvr: 'extCompressedTexturePVRTC',\n\tdxt: 'extCompressedTextureS3TC',\n\tetc2: 'extCompressedTextureETC',\n\tetc1: 'extCompressedTextureETC1',\n\tbasis: 'canvas'\n};\nconst VARIANT_DEFAULT_PRIORITY = ['pvr', 'dxt', 'etc2', 'etc1', 'basis'];\nclass Asset extends EventHandler {\n\tconstructor(name, type, file, data, options) {\n\t\tsuper();\n\t\tthis._id = assetIdCounter--;\n\t\tthis._name = name || '';\n\t\tthis.type = type;\n\t\tthis.tags = new Tags(this);\n\t\tthis._preload = false;\n\t\tthis._file = null;\n\t\tthis._data = data || {};\n\t\tthis.options = options || {};\n\t\tthis._resources = [];\n\t\tthis.urlObject = null;\n\t\tthis._i18n = {};\n\t\tthis.loaded = false;\n\t\tthis.loading = false;\n\t\tthis.registry = null;\n\t\tif (file) this.file = file;\n\t}\n\tset id(value) {\n\t\tthis._id = value;\n\t}\n\tget id() {\n\t\treturn this._id;\n\t}\n\tset name(value) {\n\t\tif (this._name === value) return;\n\t\tconst old = this._name;\n\t\tthis._name = value;\n\t\tthis.fire('name', this, this._name, old);\n\t}\n\tget name() {\n\t\treturn this._name;\n\t}\n\tset file(value) {\n\t\tif (value && value.variants && ['texture', 'textureatlas', 'bundle'].indexOf(this.type) !== -1) {\n\t\t\tvar _this$registry;\n\t\t\tconst app = ((_this$registry = this.registry) == null || (_this$registry = _this$registry._loader) == null ? void 0 : _this$registry._app) || getApplication();\n\t\t\tconst device = app == null ? void 0 : app.graphicsDevice;\n\t\t\tif (device) {\n\t\t\t\tfor (let i = 0, len = VARIANT_DEFAULT_PRIORITY.length; i < len; i++) {\n\t\t\t\t\tconst variant = VARIANT_DEFAULT_PRIORITY[i];\n\t\t\t\t\tif (value.variants[variant] && device[VARIANT_SUPPORT[variant]]) {\n\t\t\t\t\t\tvalue = value.variants[variant];\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t\tif (app.enableBundles) {\n\t\t\t\t\t\tconst bundles = app.bundles.listBundlesForAsset(this);\n\t\t\t\t\t\tif (bundles && bundles.find(b => {\n\t\t\t\t\t\t\tvar _b$file;\n\t\t\t\t\t\t\treturn b == null || (_b$file = b.file) == null ? void 0 : _b$file.variants[variant];\n\t\t\t\t\t\t})) {\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tconst oldFile = this._file;\n\t\tconst newFile = value ? new AssetFile(value.url, value.filename, value.hash, value.size, value.opt, value.contents) : null;\n\t\tif (!!newFile !== !!oldFile || newFile && !newFile.equals(oldFile)) {\n\t\t\tthis._file = newFile;\n\t\t\tthis.fire('change', this, 'file', newFile, oldFile);\n\t\t\tthis.reload();\n\t\t}\n\t}\n\tget file() {\n\t\treturn this._file;\n\t}\n\tset data(value) {\n\t\tconst old = this._data;\n\t\tthis._data = value;\n\t\tif (value !== old) {\n\t\t\tthis.fire('change', this, 'data', value, old);\n\t\t\tif (this.loaded) this.registry._loader.patch(this, this.registry);\n\t\t}\n\t}\n\tget data() {\n\t\treturn this._data;\n\t}\n\tset resource(value) {\n\t\tconst _old = this._resources[0];\n\t\tthis._resources[0] = value;\n\t\tthis.fire('change', this, 'resource', value, _old);\n\t}\n\tget resource() {\n\t\treturn this._resources[0];\n\t}\n\tset resources(value) {\n\t\tconst _old = this._resources;\n\t\tthis._resources = value;\n\t\tthis.fire('change', this, 'resources', value, _old);\n\t}\n\tget resources() {\n\t\treturn this._resources;\n\t}\n\tset preload(value) {\n\t\tvalue = !!value;\n\t\tif (this._preload === value) return;\n\t\tthis._preload = value;\n\t\tif (this._preload && !this.loaded && !this.loading && this.registry) this.registry.load(this);\n\t}\n\tget preload() {\n\t\treturn this._preload;\n\t}\n\tset loadFaces(value) {\n\t\tvalue = !!value;\n\t\tif (!this.hasOwnProperty('_loadFaces') || value !== this._loadFaces) {\n\t\t\tthis._loadFaces = value;\n\t\t\tif (this.loaded) this.registry._loader.patch(this, this.registry);\n\t\t}\n\t}\n\tget loadFaces() {\n\t\treturn this._loadFaces;\n\t}\n\tgetFileUrl() {\n\t\tconst file = this.file;\n\t\tif (!file || !file.url) return null;\n\t\tlet url = file.url;\n\t\tif (this.registry && this.registry.prefix && !ABSOLUTE_URL.test(url)) url = this.registry.prefix + url;\n\t\tif (this.type !== 'script' && file.hash) {\n\t\t\tconst separator = url.indexOf('?') !== -1 ? '&' : '?';\n\t\t\turl += separator + 't=' + file.hash;\n\t\t}\n\t\treturn url;\n\t}\n\tgetAbsoluteUrl(relativePath) {\n\t\tif (relativePath.startsWith('blob:') || relativePath.startsWith('data:')) {\n\t\t\treturn relativePath;\n\t\t}\n\t\tconst base = path.getDirectory(this.file.url);\n\t\treturn path.join(base, relativePath);\n\t}\n\tgetLocalizedAssetId(locale) {\n\t\tlocale = findAvailableLocale(locale, this._i18n);\n\t\treturn this._i18n[locale] || null;\n\t}\n\taddLocalizedAssetId(locale, assetId) {\n\t\tthis._i18n[locale] = assetId;\n\t\tthis.fire('add:localized', locale, assetId);\n\t}\n\tremoveLocalizedAssetId(locale) {\n\t\tconst assetId = this._i18n[locale];\n\t\tif (assetId) {\n\t\t\tdelete this._i18n[locale];\n\t\t\tthis.fire('remove:localized', locale, assetId);\n\t\t}\n\t}\n\tready(callback, scope) {\n\t\tscope = scope || this;\n\t\tif (this.loaded) {\n\t\t\tcallback.call(scope, this);\n\t\t} else {\n\t\t\tthis.once('load', function (asset) {\n\t\t\t\tcallback.call(scope, asset);\n\t\t\t});\n\t\t}\n\t}\n\treload() {\n\t\tif (this.loaded) {\n\t\t\tthis.loaded = false;\n\t\t\tthis.registry.load(this);\n\t\t}\n\t}\n\tunload() {\n\t\tif (!this.loaded && this._resources.length === 0) return;\n\t\tthis.fire('unload', this);\n\t\tthis.registry.fire('unload:' + this.id, this);\n\t\tconst old = this._resources;\n\t\tif (this.urlObject) {\n\t\t\tURL.revokeObjectURL(this.urlObject);\n\t\t\tthis.urlObject = null;\n\t\t}\n\t\tthis.resources = [];\n\t\tthis.loaded = false;\n\t\tif (this.file) {\n\t\t\tthis.registry._loader.clearCache(this.getFileUrl(), this.type);\n\t\t}\n\t\tfor (let i = 0; i < old.length; ++i) {\n\t\t\tconst resource = old[i];\n\t\t\tif (resource && resource.destroy) {\n\t\t\t\tresource.destroy();\n\t\t\t}\n\t\t}\n\t}\n\tstatic fetchArrayBuffer(loadUrl, callback, asset, maxRetries = 0) {\n\t\tvar _asset$file;\n\t\tif (asset != null && (_asset$file = asset.file) != null && _asset$file.contents) {\n\t\t\tsetTimeout(() => {\n\t\t\t\tcallback(null, asset.file.contents);\n\t\t\t});\n\t\t} else {\n\t\t\thttp.get(loadUrl, {\n\t\t\t\tcache: true,\n\t\t\t\tresponseType: 'arraybuffer',\n\t\t\t\tretry: maxRetries > 0,\n\t\t\t\tmaxRetries: maxRetries\n\t\t\t}, callback);\n\t\t}\n\t}\n}\nAsset.EVENT_LOAD = 'load';\nAsset.EVENT_UNLOAD = 'unload';\nAsset.EVENT_REMOVE = 'remove';\nAsset.EVENT_ERROR = 'error';\nAsset.EVENT_CHANGE = 'change';\nAsset.EVENT_ADDLOCALIZED = 'add:localized';\nAsset.EVENT_REMOVELOCALIZED = 'remove:localized';\n\nexport { Asset };\n", "class TagsCache {\n\tconstructor(key = null) {\n\t\tthis._index = {};\n\t\tthis._key = void 0;\n\t\tthis._key = key;\n\t}\n\taddItem(item) {\n\t\tconst tags = item.tags._list;\n\t\tfor (const tag of tags) this.add(tag, item);\n\t}\n\tremoveItem(item) {\n\t\tconst tags = item.tags._list;\n\t\tfor (const tag of tags) this.remove(tag, item);\n\t}\n\tadd(tag, item) {\n\t\tif (this._index[tag] && this._index[tag].list.indexOf(item) !== -1) return;\n\t\tif (!this._index[tag]) {\n\t\t\tthis._index[tag] = {\n\t\t\t\tlist: []\n\t\t\t};\n\t\t\tif (this._key) this._index[tag].keys = {};\n\t\t}\n\t\tthis._index[tag].list.push(item);\n\t\tif (this._key) this._index[tag].keys[item[this._key]] = item;\n\t}\n\tremove(tag, item) {\n\t\tif (!this._index[tag]) return;\n\t\tif (this._key) {\n\t\t\tif (!this._index[tag].keys[item[this._key]]) return;\n\t\t}\n\t\tconst ind = this._index[tag].list.indexOf(item);\n\t\tif (ind === -1) return;\n\t\tthis._index[tag].list.splice(ind, 1);\n\t\tif (this._key) delete this._index[tag].keys[item[this._key]];\n\t\tif (this._index[tag].list.length === 0) delete this._index[tag];\n\t}\n\tfind(args) {\n\t\tconst index = {};\n\t\tconst items = [];\n\t\tlet item, tag, tags, tagsRest, missingIndex;\n\t\tconst sort = (a, b) => {\n\t\t\treturn this._index[a].list.length - this._index[b].list.length;\n\t\t};\n\t\tfor (let i = 0; i < args.length; i++) {\n\t\t\ttag = args[i];\n\t\t\tif (tag instanceof Array) {\n\t\t\t\tif (tag.length === 0) continue;\n\t\t\t\tif (tag.length === 1) {\n\t\t\t\t\ttag = tag[0];\n\t\t\t\t} else {\n\t\t\t\t\tmissingIndex = false;\n\t\t\t\t\tfor (let t = 0; t < tag.length; t++) {\n\t\t\t\t\t\tif (!this._index[tag[t]]) {\n\t\t\t\t\t\t\tmissingIndex = true;\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif (missingIndex) continue;\n\t\t\t\t\ttags = tag.slice(0).sort(sort);\n\t\t\t\t\ttagsRest = tags.slice(1);\n\t\t\t\t\tif (tagsRest.length === 1) tagsRest = tagsRest[0];\n\t\t\t\t\tfor (let n = 0; n < this._index[tags[0]].list.length; n++) {\n\t\t\t\t\t\titem = this._index[tags[0]].list[n];\n\t\t\t\t\t\tif ((this._key ? !index[item[this._key]] : items.indexOf(item) === -1) && item.tags.has(tagsRest)) {\n\t\t\t\t\t\t\tif (this._key) index[item[this._key]] = true;\n\t\t\t\t\t\t\titems.push(item);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (tag && typeof tag === 'string' && this._index[tag]) {\n\t\t\t\tfor (let n = 0; n < this._index[tag].list.length; n++) {\n\t\t\t\t\titem = this._index[tag].list[n];\n\t\t\t\t\tif (this._key) {\n\t\t\t\t\t\tif (!index[item[this._key]]) {\n\t\t\t\t\t\t\tindex[item[this._key]] = true;\n\t\t\t\t\t\t\titems.push(item);\n\t\t\t\t\t\t}\n\t\t\t\t\t} else if (items.indexOf(item) === -1) {\n\t\t\t\t\t\titems.push(item);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn items;\n\t}\n}\n\nexport { TagsCache };\n", "import { path } from '../../core/path.js';\nimport { EventHandler } from '../../core/event-handler.js';\nimport { TagsCache } from '../../core/tags-cache.js';\nimport { standardMaterialTextureParameters } from '../../scene/materials/standard-material-parameters.js';\nimport { script } from '../script.js';\nimport { Asset } from './asset.js';\n\nclass AssetRegistry extends EventHandler {\n\tconstructor(loader) {\n\t\tsuper();\n\t\tthis._assets = new Set();\n\t\tthis._idToAsset = new Map();\n\t\tthis._urlToAsset = new Map();\n\t\tthis._nameToAsset = new Map();\n\t\tthis._tags = new TagsCache('_id');\n\t\tthis.prefix = null;\n\t\tthis.bundles = null;\n\t\tthis._loader = loader;\n\t}\n\tlist(filters = {}) {\n\t\tconst assets = Array.from(this._assets);\n\t\tif (filters.preload !== undefined) {\n\t\t\treturn assets.filter(asset => asset.preload === filters.preload);\n\t\t}\n\t\treturn assets;\n\t}\n\tadd(asset) {\n\t\tvar _asset$file, _asset$file2;\n\t\tif (this._assets.has(asset)) return;\n\t\tthis._assets.add(asset);\n\t\tthis._idToAsset.set(asset.id, asset);\n\t\tif ((_asset$file = asset.file) != null && _asset$file.url) {\n\t\t\tthis._urlToAsset.set(asset.file.url, asset);\n\t\t}\n\t\tif (!this._nameToAsset.has(asset.name)) this._nameToAsset.set(asset.name, new Set());\n\t\tthis._nameToAsset.get(asset.name).add(asset);\n\t\tasset.on('name', this._onNameChange, this);\n\t\tasset.registry = this;\n\t\tthis._tags.addItem(asset);\n\t\tasset.tags.on('add', this._onTagAdd, this);\n\t\tasset.tags.on('remove', this._onTagRemove, this);\n\t\tthis.fire('add', asset);\n\t\tthis.fire('add:' + asset.id, asset);\n\t\tif ((_asset$file2 = asset.file) != null && _asset$file2.url) {\n\t\t\tthis.fire('add:url:' + asset.file.url, asset);\n\t\t}\n\t\tif (asset.preload) this.load(asset);\n\t}\n\tremove(asset) {\n\t\tvar _asset$file3, _asset$file4;\n\t\tif (!this._assets.has(asset)) return false;\n\t\tthis._assets.delete(asset);\n\t\tthis._idToAsset.delete(asset.id);\n\t\tif ((_asset$file3 = asset.file) != null && _asset$file3.url) {\n\t\t\tthis._urlToAsset.delete(asset.file.url);\n\t\t}\n\t\tasset.off('name', this._onNameChange, this);\n\t\tif (this._nameToAsset.has(asset.name)) {\n\t\t\tconst items = this._nameToAsset.get(asset.name);\n\t\t\titems.delete(asset);\n\t\t\tif (items.size === 0) {\n\t\t\t\tthis._nameToAsset.delete(asset.name);\n\t\t\t}\n\t\t}\n\t\tthis._tags.removeItem(asset);\n\t\tasset.tags.off('add', this._onTagAdd, this);\n\t\tasset.tags.off('remove', this._onTagRemove, this);\n\t\tasset.fire('remove', asset);\n\t\tthis.fire('remove', asset);\n\t\tthis.fire('remove:' + asset.id, asset);\n\t\tif ((_asset$file4 = asset.file) != null && _asset$file4.url) {\n\t\t\tthis.fire('remove:url:' + asset.file.url, asset);\n\t\t}\n\t\treturn true;\n\t}\n\tget(id) {\n\t\treturn this._idToAsset.get(Number(id));\n\t}\n\tgetByUrl(url) {\n\t\treturn this._urlToAsset.get(url);\n\t}\n\tload(asset, options) {\n\t\tif ((asset.loading || asset.loaded) && !(options != null && options.force)) {\n\t\t\treturn;\n\t\t}\n\t\tconst file = asset.file;\n\t\tconst _fireLoad = () => {\n\t\t\tthis.fire('load', asset);\n\t\t\tthis.fire('load:' + asset.id, asset);\n\t\t\tif (file && file.url) this.fire('load:url:' + file.url, asset);\n\t\t\tasset.fire('load', asset);\n\t\t};\n\t\tconst _opened = resource => {\n\t\t\tif (resource instanceof Array) {\n\t\t\t\tasset.resources = resource;\n\t\t\t} else {\n\t\t\t\tasset.resource = resource;\n\t\t\t}\n\t\t\tthis._loader.patch(asset, this);\n\t\t\tif (asset.type === 'bundle') {\n\t\t\t\tconst assetIds = asset.data.assets;\n\t\t\t\tfor (let i = 0; i < assetIds.length; i++) {\n\t\t\t\t\tconst assetInBundle = this._idToAsset.get(assetIds[i]);\n\t\t\t\t\tif (assetInBundle && !assetInBundle.loaded) {\n\t\t\t\t\t\tthis.load(assetInBundle, {\n\t\t\t\t\t\t\tforce: true\n\t\t\t\t\t\t});\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tif (asset.resource.loaded) {\n\t\t\t\t\t_fireLoad();\n\t\t\t\t} else {\n\t\t\t\t\tthis.fire('load:start', asset);\n\t\t\t\t\tthis.fire('load:start:' + asset.id, asset);\n\t\t\t\t\tif (file && file.url) this.fire('load:start:url:' + file.url, asset);\n\t\t\t\t\tasset.fire('load:start', asset);\n\t\t\t\t\tasset.resource.on('load', _fireLoad);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\t_fireLoad();\n\t\t\t}\n\t\t};\n\t\tconst _loaded = (err, resource, extra) => {\n\t\t\tasset.loaded = true;\n\t\t\tasset.loading = false;\n\t\t\tif (err) {\n\t\t\t\tthis.fire('error', err, asset);\n\t\t\t\tthis.fire('error:' + asset.id, err, asset);\n\t\t\t\tasset.fire('error', err, asset);\n\t\t\t} else {\n\t\t\t\tif (!script.legacy && asset.type === 'script') {\n\t\t\t\t\tconst handler = this._loader.getHandler('script');\n\t\t\t\t\tif (handler._cache[asset.id] && handler._cache[asset.id].parentNode === document.head) {\n\t\t\t\t\t\tdocument.head.removeChild(handler._cache[asset.id]);\n\t\t\t\t\t}\n\t\t\t\t\thandler._cache[asset.id] = extra;\n\t\t\t\t}\n\t\t\t\t_opened(resource);\n\t\t\t}\n\t\t};\n\t\tif (file || asset.type === 'cubemap') {\n\t\t\tthis.fire('load:start', asset);\n\t\t\tthis.fire('load:' + asset.id + ':start', asset);\n\t\t\tasset.loading = true;\n\t\t\tconst fileUrl = asset.getFileUrl();\n\t\t\tif (asset.type === 'bundle') {\n\t\t\t\tconst assetIds = asset.data.assets;\n\t\t\t\tfor (let i = 0; i < assetIds.length; i++) {\n\t\t\t\t\tconst assetInBundle = this._idToAsset.get(assetIds[i]);\n\t\t\t\t\tif (!assetInBundle) continue;\n\t\t\t\t\tif (assetInBundle.loaded || assetInBundle.resource || assetInBundle.loading) continue;\n\t\t\t\t\tassetInBundle.loading = true;\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis._loader.load(fileUrl, asset.type, _loaded, asset, options);\n\t\t} else {\n\t\t\tconst resource = this._loader.open(asset.type, asset.data);\n\t\t\tasset.loaded = true;\n\t\t\t_opened(resource);\n\t\t}\n\t}\n\tloadFromUrl(url, type, callback) {\n\t\tthis.loadFromUrlAndFilename(url, null, type, callback);\n\t}\n\tloadFromUrlAndFilename(url, filename, type, callback) {\n\t\tconst name = path.getBasename(filename || url);\n\t\tconst file = {\n\t\t\tfilename: filename || name,\n\t\t\turl: url\n\t\t};\n\t\tlet asset = this.getByUrl(url);\n\t\tif (!asset) {\n\t\t\tasset = new Asset(name, type, file);\n\t\t\tthis.add(asset);\n\t\t} else if (asset.loaded) {\n\t\t\tcallback(asset.loadFromUrlError || null, asset);\n\t\t\treturn;\n\t\t}\n\t\tconst startLoad = asset => {\n\t\t\tasset.once('load', loadedAsset => {\n\t\t\t\tif (type === 'material') {\n\t\t\t\t\tthis._loadTextures(loadedAsset, (err, textures) => {\n\t\t\t\t\t\tcallback(err, loadedAsset);\n\t\t\t\t\t});\n\t\t\t\t} else {\n\t\t\t\t\tcallback(null, loadedAsset);\n\t\t\t\t}\n\t\t\t});\n\t\t\tasset.once('error', err => {\n\t\t\t\tif (err) {\n\t\t\t\t\tthis.loadFromUrlError = err;\n\t\t\t\t}\n\t\t\t\tcallback(err, asset);\n\t\t\t});\n\t\t\tthis.load(asset);\n\t\t};\n\t\tif (asset.resource) {\n\t\t\tcallback(null, asset);\n\t\t} else if (type === 'model') {\n\t\t\tthis._loadModel(asset, startLoad);\n\t\t} else {\n\t\t\tstartLoad(asset);\n\t\t}\n\t}\n\t_loadModel(modelAsset, continuation) {\n\t\tconst url = modelAsset.getFileUrl();\n\t\tconst ext = path.getExtension(url);\n\t\tif (ext === '.json' || ext === '.glb') {\n\t\t\tconst dir = path.getDirectory(url);\n\t\t\tconst basename = path.getBasename(url);\n\t\t\tconst mappingUrl = path.join(dir, basename.replace(ext, '.mapping.json'));\n\t\t\tthis._loader.load(mappingUrl, 'json', (err, data) => {\n\t\t\t\tif (err) {\n\t\t\t\t\tmodelAsset.data = {\n\t\t\t\t\t\tmapping: []\n\t\t\t\t\t};\n\t\t\t\t\tcontinuation(modelAsset);\n\t\t\t\t} else {\n\t\t\t\t\tthis._loadMaterials(modelAsset, data, (e, materials) => {\n\t\t\t\t\t\tmodelAsset.data = data;\n\t\t\t\t\t\tcontinuation(modelAsset);\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t});\n\t\t} else {\n\t\t\tcontinuation(modelAsset);\n\t\t}\n\t}\n\t_loadMaterials(modelAsset, mapping, callback) {\n\t\tconst materials = [];\n\t\tlet count = 0;\n\t\tconst onMaterialLoaded = (err, materialAsset) => {\n\t\t\tthis._loadTextures(materialAsset, (err, textures) => {\n\t\t\t\tmaterials.push(materialAsset);\n\t\t\t\tif (materials.length === count) {\n\t\t\t\t\tcallback(null, materials);\n\t\t\t\t}\n\t\t\t});\n\t\t};\n\t\tfor (let i = 0; i < mapping.mapping.length; i++) {\n\t\t\tconst path = mapping.mapping[i].path;\n\t\t\tif (path) {\n\t\t\t\tcount++;\n\t\t\t\tconst url = modelAsset.getAbsoluteUrl(path);\n\t\t\t\tthis.loadFromUrl(url, 'material', onMaterialLoaded);\n\t\t\t}\n\t\t}\n\t\tif (count === 0) {\n\t\t\tcallback(null, materials);\n\t\t}\n\t}\n\t_loadTextures(materialAsset, callback) {\n\t\tconst textures = [];\n\t\tlet count = 0;\n\t\tconst data = materialAsset.data;\n\t\tif (data.mappingFormat !== 'path') {\n\t\t\tcallback(null, textures);\n\t\t\treturn;\n\t\t}\n\t\tconst onTextureLoaded = (err, texture) => {\n\t\t\tif (err) console.error(err);\n\t\t\ttextures.push(texture);\n\t\t\tif (textures.length === count) {\n\t\t\t\tcallback(null, textures);\n\t\t\t}\n\t\t};\n\t\tconst texParams = standardMaterialTextureParameters;\n\t\tfor (let i = 0; i < texParams.length; i++) {\n\t\t\tconst path = data[texParams[i]];\n\t\t\tif (path && typeof path === 'string') {\n\t\t\t\tcount++;\n\t\t\t\tconst url = materialAsset.getAbsoluteUrl(path);\n\t\t\t\tthis.loadFromUrl(url, 'texture', onTextureLoaded);\n\t\t\t}\n\t\t}\n\t\tif (count === 0) {\n\t\t\tcallback(null, textures);\n\t\t}\n\t}\n\t_onTagAdd(tag, asset) {\n\t\tthis._tags.add(tag, asset);\n\t}\n\t_onTagRemove(tag, asset) {\n\t\tthis._tags.remove(tag, asset);\n\t}\n\t_onNameChange(asset, name, nameOld) {\n\t\tif (this._nameToAsset.has(nameOld)) {\n\t\t\tconst items = this._nameToAsset.get(nameOld);\n\t\t\titems.delete(asset);\n\t\t\tif (items.size === 0) {\n\t\t\t\tthis._nameToAsset.delete(nameOld);\n\t\t\t}\n\t\t}\n\t\tif (!this._nameToAsset.has(asset.name)) this._nameToAsset.set(asset.name, new Set());\n\t\tthis._nameToAsset.get(asset.name).add(asset);\n\t}\n\tfindByTag() {\n\t\treturn this._tags.find(arguments);\n\t}\n\tfilter(callback) {\n\t\treturn Array.from(this._assets).filter(asset => callback(asset));\n\t}\n\tfind(name, type) {\n\t\tconst items = this._nameToAsset.get(name);\n\t\tif (!items) return null;\n\t\tfor (const asset of items) {\n\t\t\tif (!type || asset.type === type) {\n\t\t\t\treturn asset;\n\t\t\t}\n\t\t}\n\t\treturn null;\n\t}\n\tfindAll(name, type) {\n\t\tconst items = this._nameToAsset.get(name);\n\t\tif (!items) return [];\n\t\tconst results = Array.from(items);\n\t\tif (!type) return results;\n\t\treturn results.filter(asset => asset.type === type);\n\t}\n}\nAssetRegistry.EVENT_LOAD = 'load';\nAssetRegistry.EVENT_ADD = 'add';\nAssetRegistry.EVENT_REMOVE = 'remove';\nAssetRegistry.EVENT_ERROR = 'error';\n\nexport { AssetRegistry };\n", "class BundleRegistry {\n\tconstructor(assets) {\n\t\tthis._idToBundle = new Map();\n\t\tthis._assetToBundles = new Map();\n\t\tthis._urlsToBundles = new Map();\n\t\tthis._fileRequests = new Map();\n\t\tthis._assets = assets;\n\t\tthis._assets.bundles = this;\n\t\tthis._assets.on('add', this._onAssetAdd, this);\n\t\tthis._assets.on('remove', this._onAssetRemove, this);\n\t}\n\t_onAssetAdd(asset) {\n\t\tif (asset.type === 'bundle') {\n\t\t\tthis._idToBundle.set(asset.id, asset);\n\t\t\tthis._assets.on(`load:start:${asset.id}`, this._onBundleLoadStart, this);\n\t\t\tthis._assets.on(`load:${asset.id}`, this._onBundleLoad, this);\n\t\t\tthis._assets.on(`error:${asset.id}`, this._onBundleError, this);\n\t\t\tconst assetIds = asset.data.assets;\n\t\t\tfor (let i = 0; i < assetIds.length; i++) {\n\t\t\t\tthis._indexAssetInBundle(assetIds[i], asset);\n\t\t\t}\n\t\t} else {\n\t\t\tif (this._assetToBundles.has(asset.id)) {\n\t\t\t\tthis._indexAssetFileUrls(asset);\n\t\t\t}\n\t\t}\n\t}\n\t_unbindAssetEvents(id) {\n\t\tthis._assets.off('load:start:' + id, this._onBundleLoadStart, this);\n\t\tthis._assets.off('load:' + id, this._onBundleLoad, this);\n\t\tthis._assets.off('error:' + id, this._onBundleError, this);\n\t}\n\t_indexAssetInBundle(id, bundle) {\n\t\tlet bundles = this._assetToBundles.get(id);\n\t\tif (!bundles) {\n\t\t\tbundles = new Set();\n\t\t\tthis._assetToBundles.set(id, bundles);\n\t\t}\n\t\tbundles.add(bundle);\n\t\tconst asset = this._assets.get(id);\n\t\tif (asset) this._indexAssetFileUrls(asset);\n\t}\n\t_indexAssetFileUrls(asset) {\n\t\tconst urls = this._getAssetFileUrls(asset);\n\t\tif (!urls) return;\n\t\tfor (let i = 0; i < urls.length; i++) {\n\t\t\tconst bundles = this._assetToBundles.get(asset.id);\n\t\t\tif (!bundles) continue;\n\t\t\tthis._urlsToBundles.set(urls[i], bundles);\n\t\t}\n\t}\n\t_getAssetFileUrls(asset) {\n\t\tlet url = asset.getFileUrl();\n\t\tif (!url) return null;\n\t\turl = url.split('?')[0];\n\t\tconst urls = [url];\n\t\tif (asset.type === 'font') {\n\t\t\tconst numFiles = asset.data.info.maps.length;\n\t\t\tfor (let i = 1; i < numFiles; i++) {\n\t\t\t\turls.push(url.replace('.png', i + '.png'));\n\t\t\t}\n\t\t}\n\t\treturn urls;\n\t}\n\t_onAssetRemove(asset) {\n\t\tif (asset.type === 'bundle') {\n\t\t\tthis._idToBundle.delete(asset.id);\n\t\t\tthis._unbindAssetEvents(asset.id);\n\t\t\tconst assetIds = asset.data.assets;\n\t\t\tfor (let i = 0; i < assetIds.length; i++) {\n\t\t\t\tconst bundles = this._assetToBundles.get(assetIds[i]);\n\t\t\t\tif (!bundles) continue;\n\t\t\t\tbundles.delete(asset);\n\t\t\t\tif (bundles.size === 0) {\n\t\t\t\t\tthis._assetToBundles.delete(assetIds[i]);\n\t\t\t\t\tfor (const [url, otherBundles] of this._urlsToBundles) {\n\t\t\t\t\t\tif (otherBundles !== bundles) continue;\n\t\t\t\t\t\tthis._urlsToBundles.delete(url);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis._onBundleError(`Bundle ${asset.id} was removed`);\n\t\t} else {\n\t\t\tconst bundles = this._assetToBundles.get(asset.id);\n\t\t\tif (!bundles) return;\n\t\t\tthis._assetToBundles.delete(asset.id);\n\t\t\tconst urls = this._getAssetFileUrls(asset);\n\t\t\tif (!urls) return;\n\t\t\tfor (let i = 0; i < urls.length; i++) {\n\t\t\t\tthis._urlsToBundles.delete(urls[i]);\n\t\t\t}\n\t\t}\n\t}\n\t_onBundleLoadStart(asset) {\n\t\tasset.resource.on('add', (url, data) => {\n\t\t\tconst callbacks = this._fileRequests.get(url);\n\t\t\tif (!callbacks) return;\n\t\t\tfor (let i = 0; i < callbacks.length; i++) {\n\t\t\t\tcallbacks[i](null, data);\n\t\t\t}\n\t\t\tthis._fileRequests.delete(url);\n\t\t});\n\t}\n\t_onBundleLoad(asset) {\n\t\tif (!asset.resource) {\n\t\t\tthis._onBundleError(`Bundle ${asset.id} failed to load`);\n\t\t\treturn;\n\t\t}\n\t\tif (!this._fileRequests) return;\n\t\tfor (const [url, requests] of this._fileRequests) {\n\t\t\tconst bundles = this._urlsToBundles.get(url);\n\t\t\tif (!bundles || !bundles.has(asset)) continue;\n\t\t\tconst decodedUrl = decodeURIComponent(url);\n\t\t\tlet err, data;\n\t\t\tif (asset.resource.has(decodedUrl)) {\n\t\t\t\tdata = asset.resource.get(decodedUrl);\n\t\t\t} else if (asset.resource.loaded) {\n\t\t\t\terr = `Bundle ${asset.id} does not contain URL ${url}`;\n\t\t\t} else {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tfor (let i = 0; i < requests.length; i++) {\n\t\t\t\trequests[i](err, err || data);\n\t\t\t}\n\t\t\tthis._fileRequests.delete(url);\n\t\t}\n\t}\n\t_onBundleError(err) {\n\t\tfor (const [url, requests] of this._fileRequests) {\n\t\t\tconst bundle = this._findLoadedOrLoadingBundleForUrl(url);\n\t\t\tif (!bundle) {\n\t\t\t\tfor (let i = 0; i < requests.length; i++) requests[i](err);\n\t\t\t\tthis._fileRequests.delete(url);\n\t\t\t}\n\t\t}\n\t}\n\t_findLoadedOrLoadingBundleForUrl(url) {\n\t\tconst bundles = this._urlsToBundles.get(url);\n\t\tif (!bundles) return null;\n\t\tlet candidate = null;\n\t\tfor (const bundle of bundles) {\n\t\t\tif (bundle.loaded && bundle.resource) {\n\t\t\t\treturn bundle;\n\t\t\t} else if (bundle.loading) {\n\t\t\t\tcandidate = bundle;\n\t\t\t}\n\t\t}\n\t\treturn candidate;\n\t}\n\tlistBundlesForAsset(asset) {\n\t\tconst bundles = this._assetToBundles.get(asset.id);\n\t\tif (bundles) return Array.from(bundles);\n\t\treturn null;\n\t}\n\tlist() {\n\t\treturn Array.from(this._idToBundle.values());\n\t}\n\thasUrl(url) {\n\t\treturn this._urlsToBundles.has(url);\n\t}\n\turlIsLoadedOrLoading(url) {\n\t\treturn !!this._findLoadedOrLoadingBundleForUrl(url);\n\t}\n\tloadUrl(url, callback) {\n\t\tconst bundle = this._findLoadedOrLoadingBundleForUrl(url);\n\t\tif (!bundle) {\n\t\t\tcallback(`URL ${url} not found in any bundles`);\n\t\t\treturn;\n\t\t}\n\t\tif (bundle.loaded) {\n\t\t\tconst decodedUrl = decodeURIComponent(url);\n\t\t\tif (bundle.resource.has(decodedUrl)) {\n\t\t\t\tcallback(null, bundle.resource.get(decodedUrl));\n\t\t\t\treturn;\n\t\t\t} else if (bundle.resource.loaded) {\n\t\t\t\tcallback(`Bundle ${bundle.id} does not contain URL ${url}`);\n\t\t\t\treturn;\n\t\t\t}\n\t\t}\n\t\tlet callbacks = this._fileRequests.get(url);\n\t\tif (!callbacks) {\n\t\t\tcallbacks = [];\n\t\t\tthis._fileRequests.set(url, callbacks);\n\t\t}\n\t\tcallbacks.push(callback);\n\t}\n\tdestroy() {\n\t\tthis._assets.off('add', this._onAssetAdd, this);\n\t\tthis._assets.off('remove', this._onAssetRemove, this);\n\t\tfor (const id of this._idToBundle.keys()) {\n\t\t\tthis._unbindAssetEvents(id);\n\t\t}\n\t\tthis._assets = null;\n\t\tthis._idToBundle.clear();\n\t\tthis._idToBundle = null;\n\t\tthis._assetToBundles.clear();\n\t\tthis._assetToBundles = null;\n\t\tthis._urlsToBundles.clear();\n\t\tthis._urlsToBundles = null;\n\t\tthis._fileRequests.clear();\n\t\tthis._fileRequests = null;\n\t}\n}\n\nexport { BundleRegistry };\n", "import { EventHandler } from '../../core/event-handler.js';\n\nclass ComponentSystemRegistry extends EventHandler {\n\tconstructor() {\n\t\tsuper();\n\t\tthis.anim = void 0;\n\t\tthis.animation = void 0;\n\t\tthis.audiolistener = void 0;\n\t\tthis.audiosource = void 0;\n\t\tthis.button = void 0;\n\t\tthis.camera = void 0;\n\t\tthis.collision = void 0;\n\t\tthis.element = void 0;\n\t\tthis.joint = void 0;\n\t\tthis.layoutchild = void 0;\n\t\tthis.layoutgroup = void 0;\n\t\tthis.light = void 0;\n\t\tthis.model = void 0;\n\t\tthis.particlesystem = void 0;\n\t\tthis.render = void 0;\n\t\tthis.rigidbody = void 0;\n\t\tthis.screen = void 0;\n\t\tthis.script = void 0;\n\t\tthis.scrollbar = void 0;\n\t\tthis.scrollview = void 0;\n\t\tthis.sound = void 0;\n\t\tthis.sprite = void 0;\n\t\tthis.zone = void 0;\n\t\tthis.list = [];\n\t}\n\tadd(system) {\n\t\tconst id = system.id;\n\t\tif (this[id]) {\n\t\t\tthrow new Error(`ComponentSystem name '${id}' already registered or not allowed`);\n\t\t}\n\t\tthis[id] = system;\n\t\tthis.list.push(system);\n\t}\n\tremove(system) {\n\t\tconst id = system.id;\n\t\tif (!this[id]) {\n\t\t\tthrow new Error(`No ComponentSystem named '${id}' registered`);\n\t\t}\n\t\tdelete this[id];\n\t\tconst index = this.list.indexOf(this[id]);\n\t\tif (index !== -1) {\n\t\t\tthis.list.splice(index, 1);\n\t\t}\n\t}\n\tdestroy() {\n\t\tthis.off();\n\t\tfor (let i = 0; i < this.list.length; i++) {\n\t\t\tthis.list[i].destroy();\n\t\t}\n\t}\n}\n\nexport { ComponentSystemRegistry };\n", "import { EventHandler } from '../../core/event-handler.js';\n\nclass Bundle extends EventHandler {\n\tconstructor(...args) {\n\t\tsuper(...args);\n\t\tthis._index = new Map();\n\t\tthis._loaded = false;\n\t}\n\taddFile(url, data) {\n\t\tif (this._index.has(url)) return;\n\t\tthis._index.set(url, data);\n\t\tthis.fire('add', url, data);\n\t}\n\thas(url) {\n\t\treturn this._index.has(url);\n\t}\n\tget(url) {\n\t\treturn this._index.get(url) || null;\n\t}\n\tdestroy() {\n\t\tthis._index.clear();\n\t}\n\tset loaded(value) {\n\t\tif (!value || this._loaded) return;\n\t\tthis._loaded = true;\n\t\tthis.fire('load');\n\t}\n\tget loaded() {\n\t\treturn this._loaded;\n\t}\n}\nBundle.EVENT_ADD = 'add';\nBundle.EVENT_LOAD = 'load';\n\nexport { Bundle };\n", "import { EventHandler } from '../../core/event-handler.js';\n\nclass Untar extends EventHandler {\n\tconstructor(fetchPromise, assetsPrefix = '') {\n\t\tsuper();\n\t\tthis.headerSize = 512;\n\t\tthis.paddingSize = 512;\n\t\tthis.bytesRead = 0;\n\t\tthis.bytesReceived = 0;\n\t\tthis.headerRead = false;\n\t\tthis.reader = null;\n\t\tthis.data = new Uint8Array(0);\n\t\tthis.decoder = null;\n\t\tthis.prefix = '';\n\t\tthis.fileName = '';\n\t\tthis.fileSize = 0;\n\t\tthis.fileType = '';\n\t\tthis.ustarFormat = '';\n\t\tthis.prefix = assetsPrefix || '';\n\t\tthis.reader = fetchPromise.body.getReader();\n\t\tthis.reader.read().then(res => {\n\t\t\tthis.pump(res.done, res.value);\n\t\t}).catch(err => {\n\t\t\tthis.fire('error', err);\n\t\t});\n\t}\n\tpump(done, value) {\n\t\tif (done) {\n\t\t\tthis.fire('done');\n\t\t\treturn null;\n\t\t}\n\t\tthis.bytesReceived += value.byteLength;\n\t\tconst data = new Uint8Array(this.data.length + value.length);\n\t\tdata.set(this.data);\n\t\tdata.set(value, this.data.length);\n\t\tthis.data = data;\n\t\twhile (this.readFile());\n\t\treturn this.reader.read().then(res => {\n\t\t\tthis.pump(res.done, res.value);\n\t\t}).catch(err => {\n\t\t\tthis.fire('error', err);\n\t\t});\n\t}\n\treadFile() {\n\t\tif (!this.headerRead && this.bytesReceived > this.bytesRead + this.headerSize) {\n\t\t\tvar _this$decoder;\n\t\t\tthis.headerRead = true;\n\t\t\tconst view = new DataView(this.data.buffer, this.bytesRead, this.headerSize);\n\t\t\t(_this$decoder = this.decoder) != null ? _this$decoder : this.decoder = new TextDecoder('windows-1252');\n\t\t\tconst headers = this.decoder.decode(view);\n\t\t\tthis.fileName = headers.substring(0, 100).replace(/\\0/g, '');\n\t\t\tthis.fileSize = parseInt(headers.substring(124, 136), 8);\n\t\t\tthis.fileType = headers.substring(156, 157);\n\t\t\tthis.ustarFormat = headers.substring(257, 263);\n\t\t\tif (this.ustarFormat.indexOf('ustar') !== -1) {\n\t\t\t\tconst prefix = headers.substring(345, 500).replace(/\\0/g, '');\n\t\t\t\tif (prefix.length > 0) {\n\t\t\t\t\tthis.fileName = prefix.trim() + this.fileName.trim();\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis.bytesRead += 512;\n\t\t}\n\t\tif (this.headerRead) {\n\t\t\tif (this.bytesReceived < this.bytesRead + this.fileSize) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t\tif (this.fileType === '' || this.fileType === '0') {\n\t\t\t\tconst dataView = new DataView(this.data.buffer, this.bytesRead, this.fileSize);\n\t\t\t\tconst file = {\n\t\t\t\t\tname: this.prefix + this.fileName,\n\t\t\t\t\tsize: this.fileSize,\n\t\t\t\t\tdata: dataView\n\t\t\t\t};\n\t\t\t\tthis.fire('file', file);\n\t\t\t}\n\t\t\tthis.bytesRead += this.fileSize;\n\t\t\tthis.headerRead = false;\n\t\t\tconst bytesRemained = this.bytesRead % this.paddingSize;\n\t\t\tif (bytesRemained !== 0) this.bytesRead += this.paddingSize - bytesRemained;\n\t\t\treturn true;\n\t\t}\n\t\treturn false;\n\t}\n}\n\nexport { Untar };\n", "class ResourceHandler {\n\tconstructor(app, handlerType) {\n\t\tthis.handlerType = '';\n\t\tthis._app = void 0;\n\t\tthis._maxRetries = 0;\n\t\tthis._app = app;\n\t\tthis.handlerType = handlerType;\n\t}\n\tset maxRetries(value) {\n\t\tthis._maxRetries = value;\n\t}\n\tget maxRetries() {\n\t\treturn this._maxRetries;\n\t}\n\tload(url, callback, asset) {}\n\topen(url, data, asset) {\n\t\treturn data;\n\t}\n\tpatch(asset, assets) {}\n}\n\nexport { ResourceHandler };\n", "import { Bundle } from '../bundle/bundle.js';\nimport { Untar } from './untar.js';\nimport { ResourceHandler } from './handler.js';\n\nclass BundleHandler extends ResourceHandler {\n\tconstructor(app) {\n\t\tsuper(app, 'bundle');\n\t\tthis._assets = app.assets;\n\t}\n\t_fetchRetries(url, options, retries = 0) {\n\t\treturn new Promise((resolve, reject) => {\n\t\t\tconst tryFetch = () => {\n\t\t\t\tfetch(url, options).then(resolve).catch(err => {\n\t\t\t\t\tretries++;\n\t\t\t\t\tif (retries < this.maxRetries) {\n\t\t\t\t\t\ttryFetch();\n\t\t\t\t\t} else {\n\t\t\t\t\t\treject(err);\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t};\n\t\t\ttryFetch();\n\t\t});\n\t}\n\tload(url, callback) {\n\t\tif (typeof url === 'string') {\n\t\t\turl = {\n\t\t\t\tload: url,\n\t\t\t\toriginal: url\n\t\t\t};\n\t\t}\n\t\tthis._fetchRetries(url.load, {\n\t\t\tmode: 'cors',\n\t\t\tcredentials: 'include'\n\t\t}, this.maxRetries).then(res => {\n\t\t\tconst bundle = new Bundle();\n\t\t\tcallback(null, bundle);\n\t\t\tconst untar = new Untar(res, this._assets.prefix);\n\t\t\tuntar.on('file', file => {\n\t\t\t\tbundle.addFile(file.name, file.data);\n\t\t\t});\n\t\t\tuntar.on('done', () => {\n\t\t\t\tbundle.loaded = true;\n\t\t\t});\n\t\t\tuntar.on('error', err => {\n\t\t\t\tcallback(err);\n\t\t\t});\n\t\t}).catch(err => {\n\t\t\tcallback(err);\n\t\t});\n\t}\n\topen(url, bundle) {\n\t\treturn bundle;\n\t}\n}\n\nexport { BundleHandler };\n", "class ResourceLoader {\n\tconstructor(app) {\n\t\tthis._handlers = {};\n\t\tthis._requests = {};\n\t\tthis._cache = {};\n\t\tthis._app = app;\n\t}\n\taddHandler(type, handler) {\n\t\tthis._handlers[type] = handler;\n\t\thandler._loader = this;\n\t}\n\tremoveHandler(type) {\n\t\tdelete this._handlers[type];\n\t}\n\tgetHandler(type) {\n\t\treturn this._handlers[type];\n\t}\n\tstatic makeKey(url, type) {\n\t\treturn `${url}-${type}`;\n\t}\n\tload(url, type, callback, asset, options) {\n\t\tconst handler = this._handlers[type];\n\t\tif (!handler) {\n\t\t\tconst err = `No resource handler for asset type: '${type}' when loading [${url}]`;\n\t\t\tcallback(err);\n\t\t\treturn;\n\t\t}\n\t\tif (!url) {\n\t\t\tthis._loadNull(handler, callback, asset);\n\t\t\treturn;\n\t\t}\n\t\tconst key = ResourceLoader.makeKey(url, type);\n\t\tif (this._cache[key] !== undefined) {\n\t\t\tcallback(null, this._cache[key]);\n\t\t} else if (this._requests[key]) {\n\t\t\tthis._requests[key].push(callback);\n\t\t} else {\n\t\t\tthis._requests[key] = [callback];\n\t\t\tconst self = this;\n\t\t\tconst handleLoad = function handleLoad(err, urlObj) {\n\t\t\t\tif (err) {\n\t\t\t\t\tself._onFailure(key, err);\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tif (urlObj.load instanceof DataView) {\n\t\t\t\t\tif (handler.openBinary) {\n\t\t\t\t\t\tif (!self._requests[key]) return;\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tconst data = handler.openBinary(urlObj.load);\n\t\t\t\t\t\t\tself._onSuccess(key, data);\n\t\t\t\t\t\t} catch (err) {\n\t\t\t\t\t\t\tself._onFailure(key, err);\n\t\t\t\t\t\t}\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\turlObj.load = URL.createObjectURL(new Blob([urlObj.load]));\n\t\t\t\t\tif (asset) {\n\t\t\t\t\t\tif (asset.urlObject) URL.revokeObjectURL(asset.urlObject);\n\t\t\t\t\t\tasset.urlObject = urlObj.load;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\thandler.load(urlObj, function (err, data, extra) {\n\t\t\t\t\tif (!self._requests[key]) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tif (err) {\n\t\t\t\t\t\tself._onFailure(key, err);\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\ttry {\n\t\t\t\t\t\tself._onSuccess(key, handler.open(urlObj.original, data, asset), extra);\n\t\t\t\t\t} catch (e) {\n\t\t\t\t\t\tself._onFailure(key, e);\n\t\t\t\t\t}\n\t\t\t\t}, asset);\n\t\t\t};\n\t\t\tconst normalizedUrl = url.split('?')[0];\n\t\t\tif (this._app.enableBundles && this._app.bundles.hasUrl(normalizedUrl) && !(options && options.bundlesIgnore)) {\n\t\t\t\tif (!this._app.bundles.urlIsLoadedOrLoading(normalizedUrl)) {\n\t\t\t\t\tvar _this$_app$assets;\n\t\t\t\t\tconst bundles = this._app.bundles.listBundlesForAsset(asset);\n\t\t\t\t\tlet bundle;\n\t\t\t\t\tif (options && options.bundlesFilter) {\n\t\t\t\t\t\tbundle = options.bundlesFilter(bundles);\n\t\t\t\t\t}\n\t\t\t\t\tif (!bundle) {\n\t\t\t\t\t\tbundles == null || bundles.sort((a, b) => {\n\t\t\t\t\t\t\treturn a.file.size - b.file.size;\n\t\t\t\t\t\t});\n\t\t\t\t\t\tbundle = bundles == null ? void 0 : bundles[0];\n\t\t\t\t\t}\n\t\t\t\t\tif (bundle) (_this$_app$assets = this._app.assets) == null || _this$_app$assets.load(bundle);\n\t\t\t\t}\n\t\t\t\tthis._app.bundles.loadUrl(normalizedUrl, function (err, fileUrlFromBundle) {\n\t\t\t\t\thandleLoad(err, {\n\t\t\t\t\t\tload: fileUrlFromBundle,\n\t\t\t\t\t\toriginal: normalizedUrl\n\t\t\t\t\t});\n\t\t\t\t});\n\t\t\t} else {\n\t\t\t\thandleLoad(null, {\n\t\t\t\t\tload: url,\n\t\t\t\t\toriginal: asset && asset.file.filename || url\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t}\n\t_loadNull(handler, callback, asset) {\n\t\tconst onLoad = function onLoad(err, data, extra) {\n\t\t\tif (err) {\n\t\t\t\tcallback(err);\n\t\t\t} else {\n\t\t\t\ttry {\n\t\t\t\t\tcallback(null, handler.open(null, data, asset), extra);\n\t\t\t\t} catch (e) {\n\t\t\t\t\tcallback(e);\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t\thandler.load(null, onLoad, asset);\n\t}\n\t_onSuccess(key, result, extra) {\n\t\tif (result !== null) {\n\t\t\tthis._cache[key] = result;\n\t\t} else {\n\t\t\tdelete this._cache[key];\n\t\t}\n\t\tfor (let i = 0; i < this._requests[key].length; i++) {\n\t\t\tthis._requests[key][i](null, result, extra);\n\t\t}\n\t\tdelete this._requests[key];\n\t}\n\t_onFailure(key, err) {\n\t\tconsole.error(err);\n\t\tif (this._requests[key]) {\n\t\t\tfor (let i = 0; i < this._requests[key].length; i++) {\n\t\t\t\tthis._requests[key][i](err);\n\t\t\t}\n\t\t\tdelete this._requests[key];\n\t\t}\n\t}\n\topen(type, data) {\n\t\tconst handler = this._handlers[type];\n\t\tif (!handler) {\n\t\t\tconsole.warn('No resource handler found for: ' + type);\n\t\t\treturn data;\n\t\t}\n\t\treturn handler.open(null, data);\n\t}\n\tpatch(asset, assets) {\n\t\tconst handler = this._handlers[asset.type];\n\t\tif (!handler) {\n\t\t\tconsole.warn('No resource handler found for: ' + asset.type);\n\t\t\treturn;\n\t\t}\n\t\tif (handler.patch) {\n\t\t\thandler.patch(asset, assets);\n\t\t}\n\t}\n\tclearCache(url, type) {\n\t\tconst key = ResourceLoader.makeKey(url, type);\n\t\tdelete this._cache[key];\n\t}\n\tgetFromCache(url, type) {\n\t\tconst key = ResourceLoader.makeKey(url, type);\n\t\tif (this._cache[key]) {\n\t\t\treturn this._cache[key];\n\t\t}\n\t\treturn undefined;\n\t}\n\tenableRetry(maxRetries = 5) {\n\t\tmaxRetries = Math.max(0, maxRetries) || 0;\n\t\tfor (const key in this._handlers) {\n\t\t\tthis._handlers[key].maxRetries = maxRetries;\n\t\t}\n\t}\n\tdisableRetry() {\n\t\tfor (const key in this._handlers) {\n\t\t\tthis._handlers[key].maxRetries = 0;\n\t\t}\n\t}\n\tdestroy() {\n\t\tthis._handlers = {};\n\t\tthis._requests = {};\n\t\tthis._cache = {};\n\t}\n}\n\nexport { ResourceLoader };\n", "class I18nParser {\n\t_validate(data) {\n\t\tif (!data.header) {\n\t\t\tthrow new Error('pc.I18n#addData: Missing \"header\" field');\n\t\t}\n\t\tif (!data.header.version) {\n\t\t\tthrow new Error('pc.I18n#addData: Missing \"header.version\" field');\n\t\t}\n\t\tif (data.header.version !== 1) {\n\t\t\tthrow new Error('pc.I18n#addData: Invalid \"header.version\" field');\n\t\t}\n\t\tif (!data.data) {\n\t\t\tthrow new Error('pc.I18n#addData: Missing \"data\" field');\n\t\t} else if (!Array.isArray(data.data)) {\n\t\t\tthrow new Error('pc.I18n#addData: \"data\" field must be an array');\n\t\t}\n\t\tfor (let i = 0, len = data.data.length; i < len; i++) {\n\t\t\tconst entry = data.data[i];\n\t\t\tif (!entry.info) {\n\t\t\t\tthrow new Error(`pc.I18n#addData: missing \"data[${i}].info\" field`);\n\t\t\t}\n\t\t\tif (!entry.info.locale) {\n\t\t\t\tthrow new Error(`pc.I18n#addData: missing \"data[${i}].info.locale\" field`);\n\t\t\t}\n\t\t\tif (typeof entry.info.locale !== 'string') {\n\t\t\t\tthrow new Error(`pc.I18n#addData: \"data[${i}].info.locale\" must be a string`);\n\t\t\t}\n\t\t\tif (!entry.messages) {\n\t\t\t\tthrow new Error(`pc.I18n#addData: missing \"data[${i}].messages\" field`);\n\t\t\t}\n\t\t}\n\t}\n\tparse(data) {\n\t\treturn data.data;\n\t}\n}\n\nexport { I18nParser };\n", "import { EventHandler } from '../../core/event-handler.js';\nimport { Asset } from '../asset/asset.js';\nimport { I18nParser } from './i18n-parser.js';\nimport { DEFAULT_LOCALE, DEFAULT_LOCALE_FALLBACKS } from './constants.js';\nimport { getLang, replaceLang, getPluralFn, findAvailableLocale } from './utils.js';\n\nclass I18n extends EventHandler {\n\tconstructor(app) {\n\t\tsuper();\n\t\tthis.locale = DEFAULT_LOCALE;\n\t\tthis._translations = {};\n\t\tthis._availableLangs = {};\n\t\tthis._app = app;\n\t\tthis._assets = [];\n\t\tthis._parser = new I18nParser();\n\t}\n\tset assets(value) {\n\t\tconst index = {};\n\t\tfor (let _i = 0, len = value.length; _i < len; _i++) {\n\t\t\tconst id = value[_i] instanceof Asset ? value[_i].id : value[_i];\n\t\t\tindex[id] = true;\n\t\t}\n\t\tlet i = this._assets.length;\n\t\twhile (i--) {\n\t\t\tconst id = this._assets[i];\n\t\t\tif (!index[id]) {\n\t\t\t\tthis._app.assets.off('add:' + id, this._onAssetAdd, this);\n\t\t\t\tconst asset = this._app.assets.get(id);\n\t\t\t\tif (asset) {\n\t\t\t\t\tthis._onAssetRemove(asset);\n\t\t\t\t}\n\t\t\t\tthis._assets.splice(i, 1);\n\t\t\t}\n\t\t}\n\t\tfor (const id in index) {\n\t\t\tconst idNum = parseInt(id, 10);\n\t\t\tif (this._assets.indexOf(idNum) !== -1) continue;\n\t\t\tthis._assets.push(idNum);\n\t\t\tconst asset = this._app.assets.get(idNum);\n\t\t\tif (!asset) {\n\t\t\t\tthis._app.assets.once('add:' + idNum, this._onAssetAdd, this);\n\t\t\t} else {\n\t\t\t\tthis._onAssetAdd(asset);\n\t\t\t}\n\t\t}\n\t}\n\tget assets() {\n\t\treturn this._assets;\n\t}\n\tset locale(value) {\n\t\tif (this._locale === value) {\n\t\t\treturn;\n\t\t}\n\t\tlet lang = getLang(value);\n\t\tif (lang === 'in') {\n\t\t\tlang = 'id';\n\t\t\tvalue = replaceLang(value, lang);\n\t\t\tif (this._locale === value) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t}\n\t\tconst old = this._locale;\n\t\tthis._locale = value;\n\t\tthis._lang = lang;\n\t\tthis._pluralFn = getPluralFn(this._lang);\n\t\tthis.fire('set:locale', value, old);\n\t}\n\tget locale() {\n\t\treturn this._locale;\n\t}\n\tstatic findAvailableLocale(desiredLocale, availableLocales) {\n\t\treturn findAvailableLocale(desiredLocale, availableLocales);\n\t}\n\tfindAvailableLocale(desiredLocale) {\n\t\tif (this._translations[desiredLocale]) {\n\t\t\treturn desiredLocale;\n\t\t}\n\t\tconst lang = getLang(desiredLocale);\n\t\treturn this._findFallbackLocale(desiredLocale, lang);\n\t}\n\tgetText(key, locale) {\n\t\tlet result = key;\n\t\tlet lang;\n\t\tif (!locale) {\n\t\t\tlocale = this._locale;\n\t\t\tlang = this._lang;\n\t\t}\n\t\tlet translations = this._translations[locale];\n\t\tif (!translations) {\n\t\t\tif (!lang) {\n\t\t\t\tlang = getLang(locale);\n\t\t\t}\n\t\t\tlocale = this._findFallbackLocale(locale, lang);\n\t\t\ttranslations = this._translations[locale];\n\t\t}\n\t\tif (translations && translations.hasOwnProperty(key)) {\n\t\t\tresult = translations[key];\n\t\t\tif (Array.isArray(result)) {\n\t\t\t\tresult = result[0];\n\t\t\t}\n\t\t\tif (result === null || result === undefined) {\n\t\t\t\tresult = key;\n\t\t\t}\n\t\t}\n\t\treturn result;\n\t}\n\tgetPluralText(key, n, locale) {\n\t\tlet result = key;\n\t\tlet lang;\n\t\tlet pluralFn;\n\t\tif (!locale) {\n\t\t\tlocale = this._locale;\n\t\t\tlang = this._lang;\n\t\t\tpluralFn = this._pluralFn;\n\t\t} else {\n\t\t\tlang = getLang(locale);\n\t\t\tpluralFn = getPluralFn(lang);\n\t\t}\n\t\tlet translations = this._translations[locale];\n\t\tif (!translations) {\n\t\t\tlocale = this._findFallbackLocale(locale, lang);\n\t\t\tlang = getLang(locale);\n\t\t\tpluralFn = getPluralFn(lang);\n\t\t\ttranslations = this._translations[locale];\n\t\t}\n\t\tif (translations && translations[key] && pluralFn) {\n\t\t\tconst index = pluralFn(n);\n\t\t\tresult = translations[key][index];\n\t\t\tif (result === null || result === undefined) {\n\t\t\t\tresult = key;\n\t\t\t}\n\t\t}\n\t\treturn result;\n\t}\n\taddData(data) {\n\t\tlet parsed;\n\t\ttry {\n\t\t\tparsed = this._parser.parse(data);\n\t\t} catch (err) {\n\t\t\tconsole.error(err);\n\t\t\treturn;\n\t\t}\n\t\tfor (let i = 0, len = parsed.length; i < len; i++) {\n\t\t\tconst entry = parsed[i];\n\t\t\tconst locale = entry.info.locale;\n\t\t\tconst messages = entry.messages;\n\t\t\tif (!this._translations[locale]) {\n\t\t\t\tthis._translations[locale] = {};\n\t\t\t\tconst lang = getLang(locale);\n\t\t\t\tif (!this._availableLangs[lang]) {\n\t\t\t\t\tthis._availableLangs[lang] = locale;\n\t\t\t\t}\n\t\t\t}\n\t\t\tObject.assign(this._translations[locale], messages);\n\t\t\tthis.fire('data:add', locale, messages);\n\t\t}\n\t}\n\tremoveData(data) {\n\t\tlet parsed;\n\t\ttry {\n\t\t\tparsed = this._parser.parse(data);\n\t\t} catch (err) {\n\t\t\tconsole.error(err);\n\t\t\treturn;\n\t\t}\n\t\tfor (let i = 0, len = parsed.length; i < len; i++) {\n\t\t\tconst entry = parsed[i];\n\t\t\tconst locale = entry.info.locale;\n\t\t\tconst translations = this._translations[locale];\n\t\t\tif (!translations) continue;\n\t\t\tconst messages = entry.messages;\n\t\t\tfor (const key in messages) {\n\t\t\t\tdelete translations[key];\n\t\t\t}\n\t\t\tif (Object.keys(translations).length === 0) {\n\t\t\t\tdelete this._translations[locale];\n\t\t\t\tdelete this._availableLangs[getLang(locale)];\n\t\t\t}\n\t\t\tthis.fire('data:remove', locale, messages);\n\t\t}\n\t}\n\tdestroy() {\n\t\tthis._translations = null;\n\t\tthis._availableLangs = null;\n\t\tthis._assets = null;\n\t\tthis._parser = null;\n\t\tthis.off();\n\t}\n\t_findFallbackLocale(locale, lang) {\n\t\tlet result = DEFAULT_LOCALE_FALLBACKS[locale];\n\t\tif (result && this._translations[result]) {\n\t\t\treturn result;\n\t\t}\n\t\tresult = DEFAULT_LOCALE_FALLBACKS[lang];\n\t\tif (result && this._translations[result]) {\n\t\t\treturn result;\n\t\t}\n\t\tresult = this._availableLangs[lang];\n\t\tif (result && this._translations[result]) {\n\t\t\treturn result;\n\t\t}\n\t\treturn DEFAULT_LOCALE;\n\t}\n\t_onAssetAdd(asset) {\n\t\tasset.on('load', this._onAssetLoad, this);\n\t\tasset.on('change', this._onAssetChange, this);\n\t\tasset.on('remove', this._onAssetRemove, this);\n\t\tasset.on('unload', this._onAssetUnload, this);\n\t\tif (asset.resource) {\n\t\t\tthis._onAssetLoad(asset);\n\t\t}\n\t}\n\t_onAssetLoad(asset) {\n\t\tthis.addData(asset.resource);\n\t}\n\t_onAssetChange(asset) {\n\t\tif (asset.resource) {\n\t\t\tthis.addData(asset.resource);\n\t\t}\n\t}\n\t_onAssetRemove(asset) {\n\t\tasset.off('load', this._onAssetLoad, this);\n\t\tasset.off('change', this._onAssetChange, this);\n\t\tasset.off('remove', this._onAssetRemove, this);\n\t\tasset.off('unload', this._onAssetUnload, this);\n\t\tif (asset.resource) {\n\t\t\tthis.removeData(asset.resource);\n\t\t}\n\t\tthis._app.assets.once('add:' + asset.id, this._onAssetAdd, this);\n\t}\n\t_onAssetUnload(asset) {\n\t\tif (asset.resource) {\n\t\t\tthis.removeData(asset.resource);\n\t\t}\n\t}\n}\n\nexport { I18n };\n", "import { EventHandler } from '../../core/event-handler.js';\n\nclass ScriptRegistry extends EventHandler {\n\tconstructor(app) {\n\t\tsuper();\n\t\tthis._scripts = {};\n\t\tthis._list = [];\n\t\tthis.app = app;\n\t}\n\tdestroy() {\n\t\tthis.app = null;\n\t\tthis.off();\n\t}\n\tadd(script) {\n\t\tconst scriptName = script.__name;\n\t\tif (this._scripts.hasOwnProperty(scriptName)) {\n\t\t\tsetTimeout(() => {\n\t\t\t\tif (script.prototype.swap) {\n\t\t\t\t\tconst old = this._scripts[scriptName];\n\t\t\t\t\tconst ind = this._list.indexOf(old);\n\t\t\t\t\tthis._list[ind] = script;\n\t\t\t\t\tthis._scripts[scriptName] = script;\n\t\t\t\t\tthis.fire('swap', scriptName, script);\n\t\t\t\t\tthis.fire('swap:' + scriptName, script);\n\t\t\t\t} else {\n\t\t\t\t\tconsole.warn(`script registry already has '${scriptName}' script, define 'swap' method for new script type to enable code hot swapping`);\n\t\t\t\t}\n\t\t\t});\n\t\t\treturn false;\n\t\t}\n\t\tthis._scripts[scriptName] = script;\n\t\tthis._list.push(script);\n\t\tthis.fire('add', scriptName, script);\n\t\tthis.fire('add:' + scriptName, script);\n\t\tsetTimeout(() => {\n\t\t\tif (!this._scripts.hasOwnProperty(scriptName)) return;\n\t\t\tif (!this.app || !this.app.systems || !this.app.systems.script) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tconst components = this.app.systems.script._components;\n\t\t\tlet attributes;\n\t\t\tconst scriptInstances = [];\n\t\t\tconst scriptInstancesInitialized = [];\n\t\t\tfor (components.loopIndex = 0; components.loopIndex < components.length; components.loopIndex++) {\n\t\t\t\tconst component = components.items[components.loopIndex];\n\t\t\t\tif (component._scriptsIndex[scriptName] && component._scriptsIndex[scriptName].awaiting) {\n\t\t\t\t\tif (component._scriptsData && component._scriptsData[scriptName]) attributes = component._scriptsData[scriptName].attributes;\n\t\t\t\t\tconst scriptInstance = component.create(scriptName, {\n\t\t\t\t\t\tpreloading: true,\n\t\t\t\t\t\tind: component._scriptsIndex[scriptName].ind,\n\t\t\t\t\t\tattributes: attributes\n\t\t\t\t\t});\n\t\t\t\t\tif (scriptInstance) scriptInstances.push(scriptInstance);\n\t\t\t\t}\n\t\t\t}\n\t\t\tfor (let i = 0; i < scriptInstances.length; i++) scriptInstances[i].__initializeAttributes();\n\t\t\tfor (let i = 0; i < scriptInstances.length; i++) {\n\t\t\t\tif (scriptInstances[i].enabled) {\n\t\t\t\t\tscriptInstances[i]._initialized = true;\n\t\t\t\t\tscriptInstancesInitialized.push(scriptInstances[i]);\n\t\t\t\t\tif (scriptInstances[i].initialize) scriptInstances[i].initialize();\n\t\t\t\t}\n\t\t\t}\n\t\t\tfor (let i = 0; i < scriptInstancesInitialized.length; i++) {\n\t\t\t\tif (!scriptInstancesInitialized[i].enabled || scriptInstancesInitialized[i]._postInitialized) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tscriptInstancesInitialized[i]._postInitialized = true;\n\t\t\t\tif (scriptInstancesInitialized[i].postInitialize) scriptInstancesInitialized[i].postInitialize();\n\t\t\t}\n\t\t});\n\t\treturn true;\n\t}\n\tremove(nameOrType) {\n\t\tlet scriptType = nameOrType;\n\t\tlet scriptName = nameOrType;\n\t\tif (typeof scriptName !== 'string') {\n\t\t\tscriptName = scriptType.__name;\n\t\t} else {\n\t\t\tscriptType = this.get(scriptName);\n\t\t}\n\t\tif (this.get(scriptName) !== scriptType) return false;\n\t\tdelete this._scripts[scriptName];\n\t\tconst ind = this._list.indexOf(scriptType);\n\t\tthis._list.splice(ind, 1);\n\t\tthis.fire('remove', scriptName, scriptType);\n\t\tthis.fire('remove:' + scriptName, scriptType);\n\t\treturn true;\n\t}\n\tget(name) {\n\t\treturn this._scripts[name] || null;\n\t}\n\thas(nameOrType) {\n\t\tif (typeof nameOrType === 'string') {\n\t\t\treturn this._scripts.hasOwnProperty(nameOrType);\n\t\t}\n\t\tif (!nameOrType) return false;\n\t\tconst scriptName = nameOrType.__name;\n\t\treturn this._scripts[scriptName] === nameOrType;\n\t}\n\tlist() {\n\t\treturn this._list;\n\t}\n}\n\nexport { ScriptRegistry };\n", "import { guid } from '../core/guid.js';\nimport { GraphNode } from '../scene/graph-node.js';\nimport { getApplication } from './globals.js';\n\nconst _enableList = [];\nclass Entity extends GraphNode {\n\tconstructor(name, app = getApplication()) {\n\t\tsuper(name);\n\t\tthis.anim = void 0;\n\t\tthis.animation = void 0;\n\t\tthis.audiolistener = void 0;\n\t\tthis.button = void 0;\n\t\tthis.camera = void 0;\n\t\tthis.collision = void 0;\n\t\tthis.element = void 0;\n\t\tthis.gsplat = void 0;\n\t\tthis.layoutchild = void 0;\n\t\tthis.layoutgroup = void 0;\n\t\tthis.light = void 0;\n\t\tthis.model = void 0;\n\t\tthis.particlesystem = void 0;\n\t\tthis.render = void 0;\n\t\tthis.rigidbody = void 0;\n\t\tthis.screen = void 0;\n\t\tthis.script = void 0;\n\t\tthis.scrollbar = void 0;\n\t\tthis.scrollview = void 0;\n\t\tthis.sound = void 0;\n\t\tthis.sprite = void 0;\n\t\tthis.c = {};\n\t\tthis._app = void 0;\n\t\tthis._destroying = false;\n\t\tthis._guid = null;\n\t\tthis._template = false;\n\t\tthis._app = app;\n\t}\n\taddComponent(type, data) {\n\t\tconst system = this._app.systems[type];\n\t\tif (!system) {\n\t\t\treturn null;\n\t\t}\n\t\tif (this.c[type]) {\n\t\t\treturn null;\n\t\t}\n\t\treturn system.addComponent(this, data);\n\t}\n\tremoveComponent(type) {\n\t\tconst system = this._app.systems[type];\n\t\tif (!system) {\n\t\t\treturn;\n\t\t}\n\t\tif (!this.c[type]) {\n\t\t\treturn;\n\t\t}\n\t\tsystem.removeComponent(this);\n\t}\n\tfindComponent(type) {\n\t\tconst entity = this.findOne(function (node) {\n\t\t\treturn node.c && node.c[type];\n\t\t});\n\t\treturn entity && entity.c[type];\n\t}\n\tfindComponents(type) {\n\t\tconst entities = this.find(function (node) {\n\t\t\treturn node.c && node.c[type];\n\t\t});\n\t\treturn entities.map(function (entity) {\n\t\t\treturn entity.c[type];\n\t\t});\n\t}\n\tfindScript(nameOrType) {\n\t\tconst entity = this.findOne(node => {\n\t\t\tvar _node$c;\n\t\t\treturn (_node$c = node.c) == null || (_node$c = _node$c.script) == null ? void 0 : _node$c.has(nameOrType);\n\t\t});\n\t\treturn entity == null ? void 0 : entity.c.script.get(nameOrType);\n\t}\n\tfindScripts(nameOrType) {\n\t\tconst entities = this.find(node => {\n\t\t\tvar _node$c2;\n\t\t\treturn (_node$c2 = node.c) == null || (_node$c2 = _node$c2.script) == null ? void 0 : _node$c2.has(nameOrType);\n\t\t});\n\t\treturn entities.map(entity => entity.c.script.get(nameOrType));\n\t}\n\tgetGuid() {\n\t\tif (!this._guid) {\n\t\t\tthis.setGuid(guid.create());\n\t\t}\n\t\treturn this._guid;\n\t}\n\tsetGuid(guid) {\n\t\tconst index = this._app._entityIndex;\n\t\tif (this._guid) {\n\t\t\tdelete index[this._guid];\n\t\t}\n\t\tthis._guid = guid;\n\t\tindex[this._guid] = this;\n\t}\n\t_notifyHierarchyStateChanged(node, enabled) {\n\t\tlet enableFirst = false;\n\t\tif (node === this && _enableList.length === 0) enableFirst = true;\n\t\tnode._beingEnabled = true;\n\t\tnode._onHierarchyStateChanged(enabled);\n\t\tif (node._onHierarchyStatePostChanged) _enableList.push(node);\n\t\tconst c = node._children;\n\t\tfor (let i = 0, len = c.length; i < len; i++) {\n\t\t\tif (c[i]._enabled) this._notifyHierarchyStateChanged(c[i], enabled);\n\t\t}\n\t\tnode._beingEnabled = false;\n\t\tif (enableFirst) {\n\t\t\tfor (let i = 0; i < _enableList.length; i++) {\n\t\t\t\t_enableList[i]._onHierarchyStatePostChanged();\n\t\t\t}\n\t\t\t_enableList.length = 0;\n\t\t}\n\t}\n\t_onHierarchyStateChanged(enabled) {\n\t\tsuper._onHierarchyStateChanged(enabled);\n\t\tconst components = this.c;\n\t\tfor (const type in components) {\n\t\t\tif (components.hasOwnProperty(type)) {\n\t\t\t\tconst component = components[type];\n\t\t\t\tif (component.enabled) {\n\t\t\t\t\tif (enabled) {\n\t\t\t\t\t\tcomponent.onEnable();\n\t\t\t\t\t} else {\n\t\t\t\t\t\tcomponent.onDisable();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\t_onHierarchyStatePostChanged() {\n\t\tconst components = this.c;\n\t\tfor (const type in components) {\n\t\t\tif (components.hasOwnProperty(type)) components[type].onPostStateChange();\n\t\t}\n\t}\n\tfindByGuid(guid) {\n\t\tif (this._guid === guid) return this;\n\t\tconst e = this._app._entityIndex[guid];\n\t\tif (e && (e === this || e.isDescendantOf(this))) {\n\t\t\treturn e;\n\t\t}\n\t\treturn null;\n\t}\n\tdestroy() {\n\t\tthis._destroying = true;\n\t\tfor (const name in this.c) {\n\t\t\tthis.c[name].enabled = false;\n\t\t}\n\t\tfor (const name in this.c) {\n\t\t\tthis.c[name].system.removeComponent(this);\n\t\t}\n\t\tsuper.destroy();\n\t\tif (this._guid) {\n\t\t\tdelete this._app._entityIndex[this._guid];\n\t\t}\n\t\tthis._destroying = false;\n\t}\n\tclone() {\n\t\tconst duplicatedIdsMap = {};\n\t\tconst clone = this._cloneRecursively(duplicatedIdsMap);\n\t\tduplicatedIdsMap[this.getGuid()] = clone;\n\t\tresolveDuplicatedEntityReferenceProperties(this, this, clone, duplicatedIdsMap);\n\t\treturn clone;\n\t}\n\t_cloneRecursively(duplicatedIdsMap) {\n\t\tconst clone = new this.constructor(undefined, this._app);\n\t\tsuper._cloneInternal(clone);\n\t\tfor (const type in this.c) {\n\t\t\tconst component = this.c[type];\n\t\t\tcomponent.system.cloneComponent(this, clone);\n\t\t}\n\t\tfor (let i = 0; i < this._children.length; i++) {\n\t\t\tconst oldChild = this._children[i];\n\t\t\tif (oldChild instanceof Entity) {\n\t\t\t\tconst newChild = oldChild._cloneRecursively(duplicatedIdsMap);\n\t\t\t\tclone.addChild(newChild);\n\t\t\t\tduplicatedIdsMap[oldChild.getGuid()] = newChild;\n\t\t\t}\n\t\t}\n\t\treturn clone;\n\t}\n}\nEntity.EVENT_DESTROY = 'destroy';\nfunction resolveDuplicatedEntityReferenceProperties(oldSubtreeRoot, oldEntity, newEntity, duplicatedIdsMap) {\n\tif (oldEntity instanceof Entity) {\n\t\tconst components = oldEntity.c;\n\t\tfor (const componentName in components) {\n\t\t\tconst component = components[componentName];\n\t\t\tconst entityProperties = component.system.getPropertiesOfType('entity');\n\t\t\tfor (let i = 0, len = entityProperties.length; i < len; i++) {\n\t\t\t\tconst propertyDescriptor = entityProperties[i];\n\t\t\t\tconst propertyName = propertyDescriptor.name;\n\t\t\t\tconst oldEntityReferenceId = component[propertyName];\n\t\t\t\tconst entityIsWithinOldSubtree = !!oldSubtreeRoot.findByGuid(oldEntityReferenceId);\n\t\t\t\tif (entityIsWithinOldSubtree) {\n\t\t\t\t\tconst newEntityReferenceId = duplicatedIdsMap[oldEntityReferenceId].getGuid();\n\t\t\t\t\tif (newEntityReferenceId) {\n\t\t\t\t\t\tnewEntity.c[componentName][propertyName] = newEntityReferenceId;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (components.script && !newEntity._app.useLegacyScriptAttributeCloning) {\n\t\t\tnewEntity.script.resolveDuplicatedEntityReferenceProperties(components.script, duplicatedIdsMap);\n\t\t}\n\t\tif (components.render) {\n\t\t\tnewEntity.render.resolveDuplicatedEntityReferenceProperties(components.render, duplicatedIdsMap);\n\t\t}\n\t\tif (components.anim) {\n\t\t\tnewEntity.anim.resolveDuplicatedEntityReferenceProperties(components.anim, duplicatedIdsMap);\n\t\t}\n\t\tconst _old = oldEntity.children.filter(function (e) {\n\t\t\treturn e instanceof Entity;\n\t\t});\n\t\tconst _new = newEntity.children.filter(function (e) {\n\t\t\treturn e instanceof Entity;\n\t\t});\n\t\tfor (let i = 0, len = _old.length; i < len; i++) {\n\t\t\tresolveDuplicatedEntityReferenceProperties(oldSubtreeRoot, _old[i], _new[i], duplicatedIdsMap);\n\t\t}\n\t}\n}\n\nexport { Entity };\n", "class SceneRegistryItem {\n\tconstructor(name, url) {\n\t\tthis.name = void 0;\n\t\tthis.url = void 0;\n\t\tthis.data = null;\n\t\tthis._loading = false;\n\t\tthis._onLoadedCallbacks = [];\n\t\tthis.name = name;\n\t\tthis.url = url;\n\t}\n\tget loaded() {\n\t\treturn !!this.data;\n\t}\n\tget loading() {\n\t\treturn this._loading;\n\t}\n}\n\nexport { SceneRegistryItem };\n", "import { path } from '../core/path.js';\nimport { ABSOLUTE_URL } from './asset/constants.js';\nimport { SceneRegistryItem } from './scene-registry-item.js';\n\nclass SceneRegistry {\n\tconstructor(app) {\n\t\tthis._app = void 0;\n\t\tthis._list = [];\n\t\tthis._index = {};\n\t\tthis._urlIndex = {};\n\t\tthis._app = app;\n\t}\n\tdestroy() {\n\t\tthis._app = null;\n\t}\n\tlist() {\n\t\treturn this._list;\n\t}\n\tadd(name, url) {\n\t\tif (this._index.hasOwnProperty(name)) {\n\t\t\treturn false;\n\t\t}\n\t\tconst item = new SceneRegistryItem(name, url);\n\t\tconst i = this._list.push(item);\n\t\tthis._index[item.name] = i - 1;\n\t\tthis._urlIndex[item.url] = i - 1;\n\t\treturn true;\n\t}\n\tfind(name) {\n\t\tif (this._index.hasOwnProperty(name)) {\n\t\t\treturn this._list[this._index[name]];\n\t\t}\n\t\treturn null;\n\t}\n\tfindByUrl(url) {\n\t\tif (this._urlIndex.hasOwnProperty(url)) {\n\t\t\treturn this._list[this._urlIndex[url]];\n\t\t}\n\t\treturn null;\n\t}\n\tremove(name) {\n\t\tif (this._index.hasOwnProperty(name)) {\n\t\t\tconst idx = this._index[name];\n\t\t\tlet item = this._list[idx];\n\t\t\tdelete this._urlIndex[item.url];\n\t\t\tdelete this._index[name];\n\t\t\tthis._list.splice(idx, 1);\n\t\t\tfor (let i = 0; i < this._list.length; i++) {\n\t\t\t\titem = this._list[i];\n\t\t\t\tthis._index[item.name] = i;\n\t\t\t\tthis._urlIndex[item.url] = i;\n\t\t\t}\n\t\t}\n\t}\n\t_loadSceneData(sceneItem, storeInCache, callback) {\n\t\tconst app = this._app;\n\t\tlet url = sceneItem;\n\t\tif (typeof sceneItem === 'string') {\n\t\t\tsceneItem = this.findByUrl(url) || this.find(url) || new SceneRegistryItem('Untitled', url);\n\t\t}\n\t\turl = sceneItem.url;\n\t\tif (!url) {\n\t\t\tcallback(\"Cannot find scene to load\");\n\t\t\treturn;\n\t\t}\n\t\tif (sceneItem.loaded) {\n\t\t\tcallback(null, sceneItem);\n\t\t\treturn;\n\t\t}\n\t\tif (app.assets && app.assets.prefix && !ABSOLUTE_URL.test(url)) {\n\t\t\turl = path.join(app.assets.prefix, url);\n\t\t}\n\t\tsceneItem._onLoadedCallbacks.push(callback);\n\t\tif (!sceneItem._loading) {\n\t\t\tconst handler = app.loader.getHandler(\"hierarchy\");\n\t\t\thandler.load(url, (err, data) => {\n\t\t\t\tsceneItem.data = data;\n\t\t\t\tsceneItem._loading = false;\n\t\t\t\tfor (let i = 0; i < sceneItem._onLoadedCallbacks.length; i++) {\n\t\t\t\t\tsceneItem._onLoadedCallbacks[i](err, sceneItem);\n\t\t\t\t}\n\t\t\t\tif (!storeInCache) {\n\t\t\t\t\tsceneItem.data = null;\n\t\t\t\t}\n\t\t\t\tsceneItem._onLoadedCallbacks.length = 0;\n\t\t\t});\n\t\t}\n\t\tsceneItem._loading = true;\n\t}\n\tloadSceneData(sceneItem, callback) {\n\t\tthis._loadSceneData(sceneItem, true, callback);\n\t}\n\tunloadSceneData(sceneItem) {\n\t\tif (typeof sceneItem === 'string') {\n\t\t\tsceneItem = this.findByUrl(sceneItem);\n\t\t}\n\t\tif (sceneItem) {\n\t\t\tsceneItem.data = null;\n\t\t}\n\t}\n\t_loadSceneHierarchy(sceneItem, onBeforeAddHierarchy, callback) {\n\t\tthis._loadSceneData(sceneItem, false, (err, sceneItem) => {\n\t\t\tif (err) {\n\t\t\t\tif (callback) {\n\t\t\t\t\tcallback(err);\n\t\t\t\t}\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif (onBeforeAddHierarchy) {\n\t\t\t\tonBeforeAddHierarchy(sceneItem);\n\t\t\t}\n\t\t\tconst app = this._app;\n\t\t\tconst _loaded = () => {\n\t\t\t\tconst handler = app.loader.getHandler(\"hierarchy\");\n\t\t\t\tapp.systems.script.preloading = true;\n\t\t\t\tconst entity = handler.open(sceneItem.url, sceneItem.data);\n\t\t\t\tapp.systems.script.preloading = false;\n\t\t\t\tapp.loader.clearCache(sceneItem.url, \"hierarchy\");\n\t\t\t\tapp.root.addChild(entity);\n\t\t\t\tapp.systems.fire('initialize', entity);\n\t\t\t\tapp.systems.fire('postInitialize', entity);\n\t\t\t\tapp.systems.fire('postPostInitialize', entity);\n\t\t\t\tif (callback) callback(null, entity);\n\t\t\t};\n\t\t\tapp._preloadScripts(sceneItem.data, _loaded);\n\t\t});\n\t}\n\tloadSceneHierarchy(sceneItem, callback) {\n\t\tthis._loadSceneHierarchy(sceneItem, null, callback);\n\t}\n\tloadSceneSettings(sceneItem, callback) {\n\t\tthis._loadSceneData(sceneItem, false, (err, sceneItem) => {\n\t\t\tif (!err) {\n\t\t\t\tthis._app.applySceneSettings(sceneItem.data.settings);\n\t\t\t\tif (callback) {\n\t\t\t\t\tcallback(null);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tif (callback) {\n\t\t\t\t\tcallback(err);\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t}\n\tchangeScene(sceneItem, callback) {\n\t\tconst app = this._app;\n\t\tconst onBeforeAddHierarchy = sceneItem => {\n\t\t\tconst {\n\t\t\t\tchildren\n\t\t\t} = app.root;\n\t\t\twhile (children.length) {\n\t\t\t\tchildren[0].destroy();\n\t\t\t}\n\t\t\tapp.applySceneSettings(sceneItem.data.settings);\n\t\t};\n\t\tthis._loadSceneHierarchy(sceneItem, onBeforeAddHierarchy, callback);\n\t}\n\tloadScene(url, callback) {\n\t\tconst app = this._app;\n\t\tconst handler = app.loader.getHandler(\"scene\");\n\t\tif (app.assets && app.assets.prefix && !ABSOLUTE_URL.test(url)) {\n\t\t\turl = path.join(app.assets.prefix, url);\n\t\t}\n\t\thandler.load(url, (err, data) => {\n\t\t\tif (!err) {\n\t\t\t\tconst _loaded = () => {\n\t\t\t\t\tapp.systems.script.preloading = true;\n\t\t\t\t\tconst scene = handler.open(url, data);\n\t\t\t\t\tconst sceneItem = this.findByUrl(url);\n\t\t\t\t\tif (sceneItem && !sceneItem.loaded) {\n\t\t\t\t\t\tsceneItem.data = data;\n\t\t\t\t\t}\n\t\t\t\t\tapp.systems.script.preloading = false;\n\t\t\t\t\tapp.loader.clearCache(url, \"scene\");\n\t\t\t\t\tapp.loader.patch({\n\t\t\t\t\t\tresource: scene,\n\t\t\t\t\t\ttype: \"scene\"\n\t\t\t\t\t}, app.assets);\n\t\t\t\t\tapp.root.addChild(scene.root);\n\t\t\t\t\tif (app.systems.rigidbody && typeof Ammo !== 'undefined') {\n\t\t\t\t\t\tapp.systems.rigidbody.gravity.set(scene._gravity.x, scene._gravity.y, scene._gravity.z);\n\t\t\t\t\t}\n\t\t\t\t\tif (callback) {\n\t\t\t\t\t\tcallback(null, scene);\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t\t\tapp._preloadScripts(data, _loaded);\n\t\t\t} else {\n\t\t\t\tif (callback) {\n\t\t\t\t\tcallback(err);\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t}\n}\n\nexport { SceneRegistry };\n", "import { getApplication } from './globals.js';\n\nclass ApplicationStats {\n\tconstructor(device) {\n\t\tthis.frame = {\n\t\t\tfps: 0,\n\t\t\tms: 0,\n\t\t\tdt: 0,\n\t\t\tupdateStart: 0,\n\t\t\tupdateTime: 0,\n\t\t\trenderStart: 0,\n\t\t\trenderTime: 0,\n\t\t\tphysicsStart: 0,\n\t\t\tphysicsTime: 0,\n\t\t\tcullTime: 0,\n\t\t\tsortTime: 0,\n\t\t\tskinTime: 0,\n\t\t\tmorphTime: 0,\n\t\t\tinstancingTime: 0,\n\t\t\ttriangles: 0,\n\t\t\totherPrimitives: 0,\n\t\t\tshaders: 0,\n\t\t\tmaterials: 0,\n\t\t\tcameras: 0,\n\t\t\tshadowMapUpdates: 0,\n\t\t\tshadowMapTime: 0,\n\t\t\tdepthMapTime: 0,\n\t\t\tforwardTime: 0,\n\t\t\tlightClustersTime: 0,\n\t\t\tlightClusters: 0,\n\t\t\t_timeToCountFrames: 0,\n\t\t\t_fpsAccum: 0\n\t\t};\n\t\tthis.drawCalls = {\n\t\t\tforward: 0,\n\t\t\tdepth: 0,\n\t\t\tshadow: 0,\n\t\t\timmediate: 0,\n\t\t\tmisc: 0,\n\t\t\ttotal: 0,\n\t\t\tskinned: 0,\n\t\t\tinstanced: 0,\n\t\t\tremovedByInstancing: 0\n\t\t};\n\t\tthis.misc = {\n\t\t\trenderTargetCreationTime: 0\n\t\t};\n\t\tthis.particles = {\n\t\t\tupdatesPerFrame: 0,\n\t\t\t_updatesPerFrame: 0,\n\t\t\tframeTime: 0,\n\t\t\t_frameTime: 0\n\t\t};\n\t\tthis.shaders = device._shaderStats;\n\t\tthis.vram = device._vram;\n\t\tObject.defineProperty(this.vram, 'totalUsed', {\n\t\t\tget: function () {\n\t\t\t\treturn this.tex + this.vb + this.ib;\n\t\t\t}\n\t\t});\n\t\tObject.defineProperty(this.vram, 'geom', {\n\t\t\tget: function () {\n\t\t\t\treturn this.vb + this.ib;\n\t\t\t}\n\t\t});\n\t}\n\tget scene() {\n\t\treturn getApplication().scene._stats;\n\t}\n\tget lightmapper() {\n\t\tvar _getApplication$light;\n\t\treturn (_getApplication$light = getApplication().lightmapper) == null ? void 0 : _getApplication$light.stats;\n\t}\n\tget batcher() {\n\t\tconst batcher = getApplication()._batcher;\n\t\treturn batcher ? batcher._stats : null;\n\t}\n}\n\nexport { ApplicationStats };\n", "import { platform } from '../core/platform.js';\nimport { now } from '../core/time.js';\nimport { path } from '../core/path.js';\nimport { EventHandler } from '../core/event-handler.js';\nimport { Color } from '../core/math/color.js';\nimport { Mat4 } from '../core/math/mat4.js';\nimport { math } from '../core/math/math.js';\nimport { Quat } from '../core/math/quat.js';\nimport { Vec3 } from '../core/math/vec3.js';\nimport { PRIMITIVE_TRIANGLES, PRIMITIVE_TRISTRIP, PRIMITIVE_TRIFAN, CULLFACE_NONE } from '../platform/graphics/constants.js';\nimport { http } from '../platform/net/http.js';\nimport { LAYERID_WORLD, LAYERID_DEPTH, SORTMODE_NONE, LAYERID_SKYBOX, LAYERID_UI, SORTMODE_MANUAL, LAYERID_IMMEDIATE, SPECULAR_BLINN } from '../scene/constants.js';\nimport { setProgramLibrary } from '../scene/shader-lib/get-program-library.js';\nimport { ProgramLibrary } from '../scene/shader-lib/program-library.js';\nimport { ForwardRenderer } from '../scene/renderer/forward-renderer.js';\nimport { FrameGraph } from '../scene/frame-graph.js';\nimport { AreaLightLuts } from '../scene/area-light-luts.js';\nimport { Layer } from '../scene/layer.js';\nimport { LayerComposition } from '../scene/composition/layer-composition.js';\nimport { Scene } from '../scene/scene.js';\nimport { Material } from '../scene/materials/material.js';\nimport { StandardMaterial } from '../scene/materials/standard-material.js';\nimport { setDefaultMaterial } from '../scene/materials/default-material.js';\nimport { Asset } from './asset/asset.js';\nimport { AssetRegistry } from './asset/asset-registry.js';\nimport { BundleRegistry } from './bundle/bundle-registry.js';\nimport { ComponentSystemRegistry } from './components/registry.js';\nimport { BundleHandler } from './handlers/bundle.js';\nimport { ResourceLoader } from './handlers/loader.js';\nimport { I18n } from './i18n/i18n.js';\nimport { ScriptRegistry } from './script/script-registry.js';\nimport { Entity } from './entity.js';\nimport { SceneRegistry } from './scene-registry.js';\nimport { script } from './script.js';\nimport { ApplicationStats } from './stats.js';\nimport { FILLMODE_KEEP_ASPECT, RESOLUTION_FIXED, RESOLUTION_AUTO, FILLMODE_FILL_WINDOW } from './constants.js';\nimport { setApplication, getApplication } from './globals.js';\n\nclass Progress {\n\tconstructor(length) {\n\t\tthis.length = length;\n\t\tthis.count = 0;\n\t}\n\tinc() {\n\t\tthis.count++;\n\t}\n\tdone() {\n\t\treturn this.count === this.length;\n\t}\n}\nlet app = null;\nclass AppBase extends EventHandler {\n\tconstructor(canvas) {\n\t\tsuper();\n\t\tthis.frameRequestId = void 0;\n\t\tAppBase._applications[canvas.id] = this;\n\t\tsetApplication(this);\n\t\tapp = this;\n\t\tthis._destroyRequested = false;\n\t\tthis._inFrameUpdate = false;\n\t\tthis._time = 0;\n\t\tthis.timeScale = 1;\n\t\tthis.maxDeltaTime = 0.1;\n\t\tthis.frame = 0;\n\t\tthis.autoRender = true;\n\t\tthis.renderNextFrame = false;\n\t\tthis.useLegacyScriptAttributeCloning = script.legacy;\n\t\tthis._librariesLoaded = false;\n\t\tthis._fillMode = FILLMODE_KEEP_ASPECT;\n\t\tthis._resolutionMode = RESOLUTION_FIXED;\n\t\tthis._allowResize = true;\n\t\tthis.context = this;\n\t}\n\tinit(appOptions) {\n\t\tconst device = appOptions.graphicsDevice;\n\t\tthis.graphicsDevice = device;\n\t\tthis._initDefaultMaterial();\n\t\tthis._initProgramLibrary();\n\t\tthis.stats = new ApplicationStats(device);\n\t\tthis._soundManager = appOptions.soundManager;\n\t\tthis.loader = new ResourceLoader(this);\n\t\tthis._entityIndex = {};\n\t\tthis.scene = new Scene(device);\n\t\tthis._registerSceneImmediate(this.scene);\n\t\tthis.root = new Entity();\n\t\tthis.root._enabledInHierarchy = true;\n\t\tthis.assets = new AssetRegistry(this.loader);\n\t\tif (appOptions.assetPrefix) this.assets.prefix = appOptions.assetPrefix;\n\t\tthis.bundles = new BundleRegistry(this.assets);\n\t\tthis.enableBundles = typeof TextDecoder !== 'undefined';\n\t\tthis.scriptsOrder = appOptions.scriptsOrder || [];\n\t\tthis.scripts = new ScriptRegistry(this);\n\t\tthis.i18n = new I18n(this);\n\t\tthis.scenes = new SceneRegistry(this);\n\t\tthis.defaultLayerWorld = new Layer({\n\t\t\tname: \"World\",\n\t\t\tid: LAYERID_WORLD\n\t\t});\n\t\tthis.defaultLayerDepth = new Layer({\n\t\t\tname: \"Depth\",\n\t\t\tid: LAYERID_DEPTH,\n\t\t\tenabled: false,\n\t\t\topaqueSortMode: SORTMODE_NONE\n\t\t});\n\t\tthis.defaultLayerSkybox = new Layer({\n\t\t\tname: \"Skybox\",\n\t\t\tid: LAYERID_SKYBOX,\n\t\t\topaqueSortMode: SORTMODE_NONE\n\t\t});\n\t\tthis.defaultLayerUi = new Layer({\n\t\t\tname: \"UI\",\n\t\t\tid: LAYERID_UI,\n\t\t\ttransparentSortMode: SORTMODE_MANUAL\n\t\t});\n\t\tthis.defaultLayerImmediate = new Layer({\n\t\t\tname: \"Immediate\",\n\t\t\tid: LAYERID_IMMEDIATE,\n\t\t\topaqueSortMode: SORTMODE_NONE\n\t\t});\n\t\tconst defaultLayerComposition = new LayerComposition(\"default\");\n\t\tdefaultLayerComposition.pushOpaque(this.defaultLayerWorld);\n\t\tdefaultLayerComposition.pushOpaque(this.defaultLayerDepth);\n\t\tdefaultLayerComposition.pushOpaque(this.defaultLayerSkybox);\n\t\tdefaultLayerComposition.pushTransparent(this.defaultLayerWorld);\n\t\tdefaultLayerComposition.pushOpaque(this.defaultLayerImmediate);\n\t\tdefaultLayerComposition.pushTransparent(this.defaultLayerImmediate);\n\t\tdefaultLayerComposition.pushTransparent(this.defaultLayerUi);\n\t\tthis.scene.layers = defaultLayerComposition;\n\t\tAreaLightLuts.createPlaceholder(device);\n\t\tthis.renderer = new ForwardRenderer(device);\n\t\tthis.renderer.scene = this.scene;\n\t\tthis.frameGraph = new FrameGraph();\n\t\tthis.lightmapper = null;\n\t\tif (appOptions.lightmapper) {\n\t\t\tthis.lightmapper = new appOptions.lightmapper(device, this.root, this.scene, this.renderer, this.assets);\n\t\t\tthis.once('prerender', this._firstBake, this);\n\t\t}\n\t\tthis._batcher = null;\n\t\tif (appOptions.batchManager) {\n\t\t\tthis._batcher = new appOptions.batchManager(device, this.root, this.scene);\n\t\t\tthis.once('prerender', this._firstBatch, this);\n\t\t}\n\t\tthis.keyboard = appOptions.keyboard || null;\n\t\tthis.mouse = appOptions.mouse || null;\n\t\tthis.touch = appOptions.touch || null;\n\t\tthis.gamepads = appOptions.gamepads || null;\n\t\tthis.elementInput = appOptions.elementInput || null;\n\t\tif (this.elementInput) this.elementInput.app = this;\n\t\tthis.xr = appOptions.xr ? new appOptions.xr(this) : null;\n\t\tif (this.elementInput) this.elementInput.attachSelectEvents();\n\t\tthis._inTools = false;\n\t\tthis._skyboxAsset = null;\n\t\tthis._scriptPrefix = appOptions.scriptPrefix || '';\n\t\tif (this.enableBundles) {\n\t\t\tthis.loader.addHandler(\"bundle\", new BundleHandler(this));\n\t\t}\n\t\tappOptions.resourceHandlers.forEach(resourceHandler => {\n\t\t\tconst handler = new resourceHandler(this);\n\t\t\tthis.loader.addHandler(handler.handlerType, handler);\n\t\t});\n\t\tthis.systems = new ComponentSystemRegistry();\n\t\tappOptions.componentSystems.forEach(componentSystem => {\n\t\t\tthis.systems.add(new componentSystem(this));\n\t\t});\n\t\tthis._visibilityChangeHandler = this.onVisibilityChange.bind(this);\n\t\tif (typeof document !== 'undefined') {\n\t\t\tif (document.hidden !== undefined) {\n\t\t\t\tthis._hiddenAttr = 'hidden';\n\t\t\t\tdocument.addEventListener('visibilitychange', this._visibilityChangeHandler, false);\n\t\t\t} else if (document.mozHidden !== undefined) {\n\t\t\t\tthis._hiddenAttr = 'mozHidden';\n\t\t\t\tdocument.addEventListener('mozvisibilitychange', this._visibilityChangeHandler, false);\n\t\t\t} else if (document.msHidden !== undefined) {\n\t\t\t\tthis._hiddenAttr = 'msHidden';\n\t\t\t\tdocument.addEventListener('msvisibilitychange', this._visibilityChangeHandler, false);\n\t\t\t} else if (document.webkitHidden !== undefined) {\n\t\t\t\tthis._hiddenAttr = 'webkitHidden';\n\t\t\t\tdocument.addEventListener('webkitvisibilitychange', this._visibilityChangeHandler, false);\n\t\t\t}\n\t\t}\n\t\tthis.tick = makeTick(this);\n\t}\n\tstatic getApplication(id) {\n\t\treturn id ? AppBase._applications[id] : getApplication();\n\t}\n\t_initDefaultMaterial() {\n\t\tconst material = new StandardMaterial();\n\t\tmaterial.name = \"Default Material\";\n\t\tmaterial.shadingModel = SPECULAR_BLINN;\n\t\tsetDefaultMaterial(this.graphicsDevice, material);\n\t}\n\t_initProgramLibrary() {\n\t\tconst library = new ProgramLibrary(this.graphicsDevice, new StandardMaterial());\n\t\tsetProgramLibrary(this.graphicsDevice, library);\n\t}\n\tget soundManager() {\n\t\treturn this._soundManager;\n\t}\n\tget batcher() {\n\t\treturn this._batcher;\n\t}\n\tget fillMode() {\n\t\treturn this._fillMode;\n\t}\n\tget resolutionMode() {\n\t\treturn this._resolutionMode;\n\t}\n\tconfigure(url, callback) {\n\t\thttp.get(url, (err, response) => {\n\t\t\tif (err) {\n\t\t\t\tcallback(err);\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tconst props = response.application_properties;\n\t\t\tconst scenes = response.scenes;\n\t\t\tconst assets = response.assets;\n\t\t\tthis._parseApplicationProperties(props, err => {\n\t\t\t\tthis._parseScenes(scenes);\n\t\t\t\tthis._parseAssets(assets);\n\t\t\t\tif (!err) {\n\t\t\t\t\tcallback(null);\n\t\t\t\t} else {\n\t\t\t\t\tcallback(err);\n\t\t\t\t}\n\t\t\t});\n\t\t});\n\t}\n\tpreload(callback) {\n\t\tthis.fire(\"preload:start\");\n\t\tconst assets = this.assets.list({\n\t\t\tpreload: true\n\t\t});\n\t\tconst progress = new Progress(assets.length);\n\t\tlet _done = false;\n\t\tconst done = () => {\n\t\t\tif (!this.graphicsDevice) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif (!_done && progress.done()) {\n\t\t\t\t_done = true;\n\t\t\t\tthis.fire(\"preload:end\");\n\t\t\t\tcallback();\n\t\t\t}\n\t\t};\n\t\tconst total = assets.length;\n\t\tif (progress.length) {\n\t\t\tconst onAssetLoad = asset => {\n\t\t\t\tprogress.inc();\n\t\t\t\tthis.fire('preload:progress', progress.count / total);\n\t\t\t\tif (progress.done()) done();\n\t\t\t};\n\t\t\tconst onAssetError = (err, asset) => {\n\t\t\t\tprogress.inc();\n\t\t\t\tthis.fire('preload:progress', progress.count / total);\n\t\t\t\tif (progress.done()) done();\n\t\t\t};\n\t\t\tfor (let i = 0; i < assets.length; i++) {\n\t\t\t\tif (!assets[i].loaded) {\n\t\t\t\t\tassets[i].once('load', onAssetLoad);\n\t\t\t\t\tassets[i].once('error', onAssetError);\n\t\t\t\t\tthis.assets.load(assets[i]);\n\t\t\t\t} else {\n\t\t\t\t\tprogress.inc();\n\t\t\t\t\tthis.fire(\"preload:progress\", progress.count / total);\n\t\t\t\t\tif (progress.done()) done();\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tdone();\n\t\t}\n\t}\n\t_preloadScripts(sceneData, callback) {\n\t\tif (!script.legacy) {\n\t\t\tcallback();\n\t\t\treturn;\n\t\t}\n\t\tthis.systems.script.preloading = true;\n\t\tconst scripts = this._getScriptReferences(sceneData);\n\t\tconst l = scripts.length;\n\t\tconst progress = new Progress(l);\n\t\tconst regex = /^http(s)?:\\/\\//;\n\t\tif (l) {\n\t\t\tconst onLoad = (err, ScriptType) => {\n\t\t\t\tif (err) console.error(err);\n\t\t\t\tprogress.inc();\n\t\t\t\tif (progress.done()) {\n\t\t\t\t\tthis.systems.script.preloading = false;\n\t\t\t\t\tcallback();\n\t\t\t\t}\n\t\t\t};\n\t\t\tfor (let i = 0; i < l; i++) {\n\t\t\t\tlet scriptUrl = scripts[i];\n\t\t\t\tif (!regex.test(scriptUrl.toLowerCase()) && this._scriptPrefix) scriptUrl = path.join(this._scriptPrefix, scripts[i]);\n\t\t\t\tthis.loader.load(scriptUrl, 'script', onLoad);\n\t\t\t}\n\t\t} else {\n\t\t\tthis.systems.script.preloading = false;\n\t\t\tcallback();\n\t\t}\n\t}\n\t_parseApplicationProperties(props, callback) {\n\t\tif (typeof props.maxAssetRetries === 'number' && props.maxAssetRetries > 0) {\n\t\t\tthis.loader.enableRetry(props.maxAssetRetries);\n\t\t}\n\t\tif (!props.useDevicePixelRatio) props.useDevicePixelRatio = props.use_device_pixel_ratio;\n\t\tif (!props.resolutionMode) props.resolutionMode = props.resolution_mode;\n\t\tif (!props.fillMode) props.fillMode = props.fill_mode;\n\t\tthis._width = props.width;\n\t\tthis._height = props.height;\n\t\tif (props.useDevicePixelRatio) {\n\t\t\tthis.graphicsDevice.maxPixelRatio = window.devicePixelRatio;\n\t\t}\n\t\tthis.setCanvasResolution(props.resolutionMode, this._width, this._height);\n\t\tthis.setCanvasFillMode(props.fillMode, this._width, this._height);\n\t\tif (props.layers && props.layerOrder) {\n\t\t\tconst composition = new LayerComposition(\"application\");\n\t\t\tconst layers = {};\n\t\t\tfor (const key in props.layers) {\n\t\t\t\tconst data = props.layers[key];\n\t\t\t\tdata.id = parseInt(key, 10);\n\t\t\t\tdata.enabled = data.id !== LAYERID_DEPTH;\n\t\t\t\tlayers[key] = new Layer(data);\n\t\t\t}\n\t\t\tfor (let i = 0, len = props.layerOrder.length; i < len; i++) {\n\t\t\t\tconst sublayer = props.layerOrder[i];\n\t\t\t\tconst layer = layers[sublayer.layer];\n\t\t\t\tif (!layer) continue;\n\t\t\t\tif (sublayer.transparent) {\n\t\t\t\t\tcomposition.pushTransparent(layer);\n\t\t\t\t} else {\n\t\t\t\t\tcomposition.pushOpaque(layer);\n\t\t\t\t}\n\t\t\t\tcomposition.subLayerEnabled[i] = sublayer.enabled;\n\t\t\t}\n\t\t\tthis.scene.layers = composition;\n\t\t}\n\t\tif (props.batchGroups) {\n\t\t\tconst batcher = this.batcher;\n\t\t\tif (batcher) {\n\t\t\t\tfor (let i = 0, len = props.batchGroups.length; i < len; i++) {\n\t\t\t\t\tconst grp = props.batchGroups[i];\n\t\t\t\t\tbatcher.addGroup(grp.name, grp.dynamic, grp.maxAabbSize, grp.id, grp.layers);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (props.i18nAssets) {\n\t\t\tthis.i18n.assets = props.i18nAssets;\n\t\t}\n\t\tthis._loadLibraries(props.libraries, callback);\n\t}\n\t_loadLibraries(urls, callback) {\n\t\tconst len = urls.length;\n\t\tlet count = len;\n\t\tconst regex = /^http(s)?:\\/\\//;\n\t\tif (len) {\n\t\t\tconst onLoad = (err, script) => {\n\t\t\t\tcount--;\n\t\t\t\tif (err) {\n\t\t\t\t\tcallback(err);\n\t\t\t\t} else if (count === 0) {\n\t\t\t\t\tthis.onLibrariesLoaded();\n\t\t\t\t\tcallback(null);\n\t\t\t\t}\n\t\t\t};\n\t\t\tfor (let i = 0; i < len; ++i) {\n\t\t\t\tlet url = urls[i];\n\t\t\t\tif (!regex.test(url.toLowerCase()) && this._scriptPrefix) url = path.join(this._scriptPrefix, url);\n\t\t\t\tthis.loader.load(url, 'script', onLoad);\n\t\t\t}\n\t\t} else {\n\t\t\tthis.onLibrariesLoaded();\n\t\t\tcallback(null);\n\t\t}\n\t}\n\t_parseScenes(scenes) {\n\t\tif (!scenes) return;\n\t\tfor (let i = 0; i < scenes.length; i++) {\n\t\t\tthis.scenes.add(scenes[i].name, scenes[i].url);\n\t\t}\n\t}\n\t_parseAssets(assets) {\n\t\tconst list = [];\n\t\tconst scriptsIndex = {};\n\t\tconst bundlesIndex = {};\n\t\tif (!script.legacy) {\n\t\t\tfor (let i = 0; i < this.scriptsOrder.length; i++) {\n\t\t\t\tconst id = this.scriptsOrder[i];\n\t\t\t\tif (!assets[id]) continue;\n\t\t\t\tscriptsIndex[id] = true;\n\t\t\t\tlist.push(assets[id]);\n\t\t\t}\n\t\t\tif (this.enableBundles) {\n\t\t\t\tfor (const id in assets) {\n\t\t\t\t\tif (assets[id].type === 'bundle') {\n\t\t\t\t\t\tbundlesIndex[id] = true;\n\t\t\t\t\t\tlist.push(assets[id]);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tfor (const id in assets) {\n\t\t\t\tif (scriptsIndex[id] || bundlesIndex[id]) continue;\n\t\t\t\tlist.push(assets[id]);\n\t\t\t}\n\t\t} else {\n\t\t\tif (this.enableBundles) {\n\t\t\t\tfor (const id in assets) {\n\t\t\t\t\tif (assets[id].type === 'bundle') {\n\t\t\t\t\t\tbundlesIndex[id] = true;\n\t\t\t\t\t\tlist.push(assets[id]);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tfor (const id in assets) {\n\t\t\t\tif (bundlesIndex[id]) continue;\n\t\t\t\tlist.push(assets[id]);\n\t\t\t}\n\t\t}\n\t\tfor (let i = 0; i < list.length; i++) {\n\t\t\tconst data = list[i];\n\t\t\tconst asset = new Asset(data.name, data.type, data.file, data.data);\n\t\t\tasset.id = parseInt(data.id, 10);\n\t\t\tasset.preload = data.preload ? data.preload : false;\n\t\t\tasset.loaded = data.type === 'script' && data.data && data.data.loadingType > 0;\n\t\t\tasset.tags.add(data.tags);\n\t\t\tif (data.i18n) {\n\t\t\t\tfor (const locale in data.i18n) {\n\t\t\t\t\tasset.addLocalizedAssetId(locale, data.i18n[locale]);\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis.assets.add(asset);\n\t\t}\n\t}\n\t_getScriptReferences(scene) {\n\t\tlet priorityScripts = [];\n\t\tif (scene.settings.priority_scripts) {\n\t\t\tpriorityScripts = scene.settings.priority_scripts;\n\t\t}\n\t\tconst _scripts = [];\n\t\tconst _index = {};\n\t\tfor (let i = 0; i < priorityScripts.length; i++) {\n\t\t\t_scripts.push(priorityScripts[i]);\n\t\t\t_index[priorityScripts[i]] = true;\n\t\t}\n\t\tconst entities = scene.entities;\n\t\tfor (const key in entities) {\n\t\t\tif (!entities[key].components.script) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tconst scripts = entities[key].components.script.scripts;\n\t\t\tfor (let i = 0; i < scripts.length; i++) {\n\t\t\t\tif (_index[scripts[i].url]) continue;\n\t\t\t\t_scripts.push(scripts[i].url);\n\t\t\t\t_index[scripts[i].url] = true;\n\t\t\t}\n\t\t}\n\t\treturn _scripts;\n\t}\n\tstart() {\n\t\tthis.frame = 0;\n\t\tthis.fire(\"start\", {\n\t\t\ttimestamp: now(),\n\t\t\ttarget: this\n\t\t});\n\t\tif (!this._librariesLoaded) {\n\t\t\tthis.onLibrariesLoaded();\n\t\t}\n\t\tthis.systems.fire('initialize', this.root);\n\t\tthis.fire('initialize');\n\t\tthis.systems.fire('postInitialize', this.root);\n\t\tthis.systems.fire('postPostInitialize', this.root);\n\t\tthis.fire('postinitialize');\n\t\tthis.tick();\n\t}\n\tinputUpdate(dt) {\n\t\tif (this.controller) {\n\t\t\tthis.controller.update(dt);\n\t\t}\n\t\tif (this.mouse) {\n\t\t\tthis.mouse.update();\n\t\t}\n\t\tif (this.keyboard) {\n\t\t\tthis.keyboard.update();\n\t\t}\n\t\tif (this.gamepads) {\n\t\t\tthis.gamepads.update();\n\t\t}\n\t}\n\tupdate(dt) {\n\t\tthis.frame++;\n\t\tthis.graphicsDevice.updateClientRect();\n\t\tif (script.legacy) this.systems.fire('fixedUpdate', 1.0 / 60.0);\n\t\tthis.systems.fire(this._inTools ? 'toolsUpdate' : 'update', dt);\n\t\tthis.systems.fire('animationUpdate', dt);\n\t\tthis.systems.fire('postUpdate', dt);\n\t\tthis.fire(\"update\", dt);\n\t\tthis.inputUpdate(dt);\n\t}\n\tframeStart() {\n\t\tthis.graphicsDevice.frameStart();\n\t}\n\tframeEnd() {\n\t\tthis.graphicsDevice.frameEnd();\n\t}\n\trender() {\n\t\tthis.fire('prerender');\n\t\tthis.root.syncHierarchy();\n\t\tif (this._batcher) {\n\t\t\tthis._batcher.updateAll();\n\t\t}\n\t\tthis.renderComposition(this.scene.layers);\n\t\tthis.fire('postrender');\n\t}\n\trenderComposition(layerComposition) {\n\t\tthis.renderer.buildFrameGraph(this.frameGraph, layerComposition);\n\t\tthis.frameGraph.render(this.graphicsDevice);\n\t}\n\t_fillFrameStatsBasic(now, dt, ms) {\n\t\tconst stats = this.stats.frame;\n\t\tstats.dt = dt;\n\t\tstats.ms = ms;\n\t\tif (now > stats._timeToCountFrames) {\n\t\t\tstats.fps = stats._fpsAccum;\n\t\t\tstats._fpsAccum = 0;\n\t\t\tstats._timeToCountFrames = now + 1000;\n\t\t} else {\n\t\t\tstats._fpsAccum++;\n\t\t}\n\t\tthis.stats.drawCalls.total = this.graphicsDevice._drawCallsPerFrame;\n\t\tthis.graphicsDevice._drawCallsPerFrame = 0;\n\t}\n\t_fillFrameStats() {\n\t\tlet stats = this.stats.frame;\n\t\tstats.cameras = this.renderer._camerasRendered;\n\t\tstats.materials = this.renderer._materialSwitches;\n\t\tstats.shaders = this.graphicsDevice._shaderSwitchesPerFrame;\n\t\tstats.shadowMapUpdates = this.renderer._shadowMapUpdates;\n\t\tstats.shadowMapTime = this.renderer._shadowMapTime;\n\t\tstats.depthMapTime = this.renderer._depthMapTime;\n\t\tstats.forwardTime = this.renderer._forwardTime;\n\t\tconst prims = this.graphicsDevice._primsPerFrame;\n\t\tstats.triangles = prims[PRIMITIVE_TRIANGLES] / 3 + Math.max(prims[PRIMITIVE_TRISTRIP] - 2, 0) + Math.max(prims[PRIMITIVE_TRIFAN] - 2, 0);\n\t\tstats.cullTime = this.renderer._cullTime;\n\t\tstats.sortTime = this.renderer._sortTime;\n\t\tstats.skinTime = this.renderer._skinTime;\n\t\tstats.morphTime = this.renderer._morphTime;\n\t\tstats.lightClusters = this.renderer._lightClusters;\n\t\tstats.lightClustersTime = this.renderer._lightClustersTime;\n\t\tstats.otherPrimitives = 0;\n\t\tfor (let i = 0; i < prims.length; i++) {\n\t\t\tif (i < PRIMITIVE_TRIANGLES) {\n\t\t\t\tstats.otherPrimitives += prims[i];\n\t\t\t}\n\t\t\tprims[i] = 0;\n\t\t}\n\t\tthis.renderer._camerasRendered = 0;\n\t\tthis.renderer._materialSwitches = 0;\n\t\tthis.renderer._shadowMapUpdates = 0;\n\t\tthis.graphicsDevice._shaderSwitchesPerFrame = 0;\n\t\tthis.renderer._cullTime = 0;\n\t\tthis.renderer._layerCompositionUpdateTime = 0;\n\t\tthis.renderer._lightClustersTime = 0;\n\t\tthis.renderer._sortTime = 0;\n\t\tthis.renderer._skinTime = 0;\n\t\tthis.renderer._morphTime = 0;\n\t\tthis.renderer._shadowMapTime = 0;\n\t\tthis.renderer._depthMapTime = 0;\n\t\tthis.renderer._forwardTime = 0;\n\t\tstats = this.stats.drawCalls;\n\t\tstats.forward = this.renderer._forwardDrawCalls;\n\t\tstats.culled = this.renderer._numDrawCallsCulled;\n\t\tstats.depth = 0;\n\t\tstats.shadow = this.renderer._shadowDrawCalls;\n\t\tstats.skinned = this.renderer._skinDrawCalls;\n\t\tstats.immediate = 0;\n\t\tstats.instanced = 0;\n\t\tstats.removedByInstancing = 0;\n\t\tstats.misc = stats.total - (stats.forward + stats.shadow);\n\t\tthis.renderer._depthDrawCalls = 0;\n\t\tthis.renderer._shadowDrawCalls = 0;\n\t\tthis.renderer._forwardDrawCalls = 0;\n\t\tthis.renderer._numDrawCallsCulled = 0;\n\t\tthis.renderer._skinDrawCalls = 0;\n\t\tthis.renderer._immediateRendered = 0;\n\t\tthis.renderer._instancedDrawCalls = 0;\n\t\tthis.stats.misc.renderTargetCreationTime = this.graphicsDevice.renderTargetCreationTime;\n\t\tstats = this.stats.particles;\n\t\tstats.updatesPerFrame = stats._updatesPerFrame;\n\t\tstats.frameTime = stats._frameTime;\n\t\tstats._updatesPerFrame = 0;\n\t\tstats._frameTime = 0;\n\t}\n\tsetCanvasFillMode(mode, width, height) {\n\t\tthis._fillMode = mode;\n\t\tthis.resizeCanvas(width, height);\n\t}\n\tsetCanvasResolution(mode, width, height) {\n\t\tthis._resolutionMode = mode;\n\t\tif (mode === RESOLUTION_AUTO && width === undefined) {\n\t\t\twidth = this.graphicsDevice.canvas.clientWidth;\n\t\t\theight = this.graphicsDevice.canvas.clientHeight;\n\t\t}\n\t\tthis.graphicsDevice.resizeCanvas(width, height);\n\t}\n\tisHidden() {\n\t\treturn document[this._hiddenAttr];\n\t}\n\tonVisibilityChange() {\n\t\tif (this.isHidden()) {\n\t\t\tif (this._soundManager) {\n\t\t\t\tthis._soundManager.suspend();\n\t\t\t}\n\t\t} else {\n\t\t\tif (this._soundManager) {\n\t\t\t\tthis._soundManager.resume();\n\t\t\t}\n\t\t}\n\t}\n\tresizeCanvas(width, height) {\n\t\tif (!this._allowResize) return undefined;\n\t\tif (this.xr && this.xr.session) return undefined;\n\t\tconst windowWidth = window.innerWidth;\n\t\tconst windowHeight = window.innerHeight;\n\t\tif (this._fillMode === FILLMODE_KEEP_ASPECT) {\n\t\t\tconst r = this.graphicsDevice.canvas.width / this.graphicsDevice.canvas.height;\n\t\t\tconst winR = windowWidth / windowHeight;\n\t\t\tif (r > winR) {\n\t\t\t\twidth = windowWidth;\n\t\t\t\theight = width / r;\n\t\t\t} else {\n\t\t\t\theight = windowHeight;\n\t\t\t\twidth = height * r;\n\t\t\t}\n\t\t} else if (this._fillMode === FILLMODE_FILL_WINDOW) {\n\t\t\twidth = windowWidth;\n\t\t\theight = windowHeight;\n\t\t}\n\t\tthis.graphicsDevice.canvas.style.width = width + 'px';\n\t\tthis.graphicsDevice.canvas.style.height = height + 'px';\n\t\tthis.updateCanvasSize();\n\t\treturn {\n\t\t\twidth: width,\n\t\t\theight: height\n\t\t};\n\t}\n\tupdateCanvasSize() {\n\t\tvar _this$xr;\n\t\tif (!this._allowResize || (_this$xr = this.xr) != null && _this$xr.active) {\n\t\t\treturn;\n\t\t}\n\t\tif (this._resolutionMode === RESOLUTION_AUTO) {\n\t\t\tconst canvas = this.graphicsDevice.canvas;\n\t\t\tthis.graphicsDevice.resizeCanvas(canvas.clientWidth, canvas.clientHeight);\n\t\t}\n\t}\n\tonLibrariesLoaded() {\n\t\tthis._librariesLoaded = true;\n\t\tif (this.systems.rigidbody) {\n\t\t\tthis.systems.rigidbody.onLibraryLoaded();\n\t\t}\n\t}\n\tapplySceneSettings(settings) {\n\t\tlet asset;\n\t\tif (this.systems.rigidbody && typeof Ammo !== 'undefined') {\n\t\t\tconst gravity = settings.physics.gravity;\n\t\t\tthis.systems.rigidbody.gravity.set(gravity[0], gravity[1], gravity[2]);\n\t\t}\n\t\tthis.scene.applySettings(settings);\n\t\tif (settings.render.hasOwnProperty('skybox')) {\n\t\t\tif (settings.render.skybox) {\n\t\t\t\tasset = this.assets.get(settings.render.skybox);\n\t\t\t\tif (asset) {\n\t\t\t\t\tthis.setSkybox(asset);\n\t\t\t\t} else {\n\t\t\t\t\tthis.assets.once('add:' + settings.render.skybox, this.setSkybox, this);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tthis.setSkybox(null);\n\t\t\t}\n\t\t}\n\t}\n\tsetAreaLightLuts(ltcMat1, ltcMat2) {\n\t\tif (ltcMat1 && ltcMat2) {\n\t\t\tAreaLightLuts.set(this.graphicsDevice, ltcMat1, ltcMat2);\n\t\t}\n\t}\n\tsetSkybox(asset) {\n\t\tif (asset !== this._skyboxAsset) {\n\t\t\tconst onSkyboxRemoved = () => {\n\t\t\t\tthis.setSkybox(null);\n\t\t\t};\n\t\t\tconst onSkyboxChanged = () => {\n\t\t\t\tthis.scene.setSkybox(this._skyboxAsset ? this._skyboxAsset.resources : null);\n\t\t\t};\n\t\t\tif (this._skyboxAsset) {\n\t\t\t\tthis.assets.off('load:' + this._skyboxAsset.id, onSkyboxChanged, this);\n\t\t\t\tthis.assets.off('remove:' + this._skyboxAsset.id, onSkyboxRemoved, this);\n\t\t\t\tthis._skyboxAsset.off('change', onSkyboxChanged, this);\n\t\t\t}\n\t\t\tthis._skyboxAsset = asset;\n\t\t\tif (this._skyboxAsset) {\n\t\t\t\tthis.assets.on('load:' + this._skyboxAsset.id, onSkyboxChanged, this);\n\t\t\t\tthis.assets.once('remove:' + this._skyboxAsset.id, onSkyboxRemoved, this);\n\t\t\t\tthis._skyboxAsset.on('change', onSkyboxChanged, this);\n\t\t\t\tif (this.scene.skyboxMip === 0 && !this._skyboxAsset.loadFaces) {\n\t\t\t\t\tthis._skyboxAsset.loadFaces = true;\n\t\t\t\t}\n\t\t\t\tthis.assets.load(this._skyboxAsset);\n\t\t\t}\n\t\t\tonSkyboxChanged();\n\t\t}\n\t}\n\t_firstBake() {\n\t\tvar _this$lightmapper;\n\t\t(_this$lightmapper = this.lightmapper) == null || _this$lightmapper.bake(null, this.scene.lightmapMode);\n\t}\n\t_firstBatch() {\n\t\tvar _this$batcher;\n\t\t(_this$batcher = this.batcher) == null || _this$batcher.generate();\n\t}\n\t_processTimestamp(timestamp) {\n\t\treturn timestamp;\n\t}\n\tdrawLine(start, end, color, depthTest, layer) {\n\t\tthis.scene.drawLine(start, end, color, depthTest, layer);\n\t}\n\tdrawLines(positions, colors, depthTest = true, layer = this.scene.defaultDrawLayer) {\n\t\tthis.scene.drawLines(positions, colors, depthTest, layer);\n\t}\n\tdrawLineArrays(positions, colors, depthTest = true, layer = this.scene.defaultDrawLayer) {\n\t\tthis.scene.drawLineArrays(positions, colors, depthTest, layer);\n\t}\n\tdrawWireSphere(center, radius, color = Color.WHITE, segments = 20, depthTest = true, layer = this.scene.defaultDrawLayer) {\n\t\tthis.scene.immediate.drawWireSphere(center, radius, color, segments, depthTest, layer);\n\t}\n\tdrawWireAlignedBox(minPoint, maxPoint, color = Color.WHITE, depthTest = true, layer = this.scene.defaultDrawLayer, mat) {\n\t\tthis.scene.immediate.drawWireAlignedBox(minPoint, maxPoint, color, depthTest, layer, mat);\n\t}\n\tdrawMeshInstance(meshInstance, layer = this.scene.defaultDrawLayer) {\n\t\tthis.scene.immediate.drawMesh(null, null, null, meshInstance, layer);\n\t}\n\tdrawMesh(mesh, material, matrix, layer = this.scene.defaultDrawLayer) {\n\t\tthis.scene.immediate.drawMesh(material, matrix, mesh, null, layer);\n\t}\n\tdrawQuad(matrix, material, layer = this.scene.defaultDrawLayer) {\n\t\tthis.scene.immediate.drawMesh(material, matrix, this.scene.immediate.getQuadMesh(), null, layer);\n\t}\n\tdrawTexture(x, y, width, height, texture, material, layer = this.scene.defaultDrawLayer, filterable = true) {\n\t\tif (filterable === false && !this.graphicsDevice.isWebGPU) return;\n\t\tconst matrix = new Mat4();\n\t\tmatrix.setTRS(new Vec3(x, y, 0.0), Quat.IDENTITY, new Vec3(width, -height, 0.0));\n\t\tif (!material) {\n\t\t\tmaterial = new Material();\n\t\t\tmaterial.cull = CULLFACE_NONE;\n\t\t\tmaterial.setParameter(\"colorMap\", texture);\n\t\t\tmaterial.shader = filterable ? this.scene.immediate.getTextureShader() : this.scene.immediate.getUnfilterableTextureShader();\n\t\t\tmaterial.update();\n\t\t}\n\t\tthis.drawQuad(matrix, material, layer);\n\t}\n\tdrawDepthTexture(x, y, width, height, layer = this.scene.defaultDrawLayer) {\n\t\tconst material = new Material();\n\t\tmaterial.cull = CULLFACE_NONE;\n\t\tmaterial.shader = this.scene.immediate.getDepthTextureShader();\n\t\tmaterial.update();\n\t\tthis.drawTexture(x, y, width, height, null, material, layer);\n\t}\n\tdestroy() {\n\t\tvar _this$lightmapper2, _this$xr2, _this$xr3, _this$_soundManager;\n\t\tif (this._inFrameUpdate) {\n\t\t\tthis._destroyRequested = true;\n\t\t\treturn;\n\t\t}\n\t\tconst canvasId = this.graphicsDevice.canvas.id;\n\t\tthis.fire('destroy', this);\n\t\tthis.off('librariesloaded');\n\t\tif (typeof document !== 'undefined') {\n\t\t\tdocument.removeEventListener('visibilitychange', this._visibilityChangeHandler, false);\n\t\t\tdocument.removeEventListener('mozvisibilitychange', this._visibilityChangeHandler, false);\n\t\t\tdocument.removeEventListener('msvisibilitychange', this._visibilityChangeHandler, false);\n\t\t\tdocument.removeEventListener('webkitvisibilitychange', this._visibilityChangeHandler, false);\n\t\t}\n\t\tthis._visibilityChangeHandler = null;\n\t\tthis.root.destroy();\n\t\tthis.root = null;\n\t\tif (this.mouse) {\n\t\t\tthis.mouse.off();\n\t\t\tthis.mouse.detach();\n\t\t\tthis.mouse = null;\n\t\t}\n\t\tif (this.keyboard) {\n\t\t\tthis.keyboard.off();\n\t\t\tthis.keyboard.detach();\n\t\t\tthis.keyboard = null;\n\t\t}\n\t\tif (this.touch) {\n\t\t\tthis.touch.off();\n\t\t\tthis.touch.detach();\n\t\t\tthis.touch = null;\n\t\t}\n\t\tif (this.elementInput) {\n\t\t\tthis.elementInput.detach();\n\t\t\tthis.elementInput = null;\n\t\t}\n\t\tif (this.gamepads) {\n\t\t\tthis.gamepads.destroy();\n\t\t\tthis.gamepads = null;\n\t\t}\n\t\tif (this.controller) {\n\t\t\tthis.controller = null;\n\t\t}\n\t\tthis.systems.destroy();\n\t\tif (this.scene.layers) {\n\t\t\tthis.scene.layers.destroy();\n\t\t}\n\t\tconst assets = this.assets.list();\n\t\tfor (let i = 0; i < assets.length; i++) {\n\t\t\tassets[i].unload();\n\t\t\tassets[i].off();\n\t\t}\n\t\tthis.assets.off();\n\t\tthis.bundles.destroy();\n\t\tthis.bundles = null;\n\t\tthis.i18n.destroy();\n\t\tthis.i18n = null;\n\t\tconst scriptHandler = this.loader.getHandler('script');\n\t\tscriptHandler == null || scriptHandler.clearCache();\n\t\tthis.loader.destroy();\n\t\tthis.loader = null;\n\t\tthis.scene.destroy();\n\t\tthis.scene = null;\n\t\tthis.systems = null;\n\t\tthis.context = null;\n\t\tthis.scripts.destroy();\n\t\tthis.scripts = null;\n\t\tthis.scenes.destroy();\n\t\tthis.scenes = null;\n\t\t(_this$lightmapper2 = this.lightmapper) == null || _this$lightmapper2.destroy();\n\t\tthis.lightmapper = null;\n\t\tif (this._batcher) {\n\t\t\tthis._batcher.destroy();\n\t\t\tthis._batcher = null;\n\t\t}\n\t\tthis._entityIndex = {};\n\t\tthis.defaultLayerDepth.onPreRenderOpaque = null;\n\t\tthis.defaultLayerDepth.onPostRenderOpaque = null;\n\t\tthis.defaultLayerDepth.onDisable = null;\n\t\tthis.defaultLayerDepth.onEnable = null;\n\t\tthis.defaultLayerDepth = null;\n\t\tthis.defaultLayerWorld = null;\n\t\t(_this$xr2 = this.xr) == null || _this$xr2.end();\n\t\t(_this$xr3 = this.xr) == null || _this$xr3.destroy();\n\t\tthis.renderer.destroy();\n\t\tthis.renderer = null;\n\t\tthis.graphicsDevice.destroy();\n\t\tthis.graphicsDevice = null;\n\t\tthis.tick = null;\n\t\tthis.off();\n\t\t(_this$_soundManager = this._soundManager) == null || _this$_soundManager.destroy();\n\t\tthis._soundManager = null;\n\t\tscript.app = null;\n\t\tAppBase._applications[canvasId] = null;\n\t\tif (getApplication() === this) {\n\t\t\tsetApplication(null);\n\t\t}\n\t\tAppBase.cancelTick(this);\n\t}\n\tstatic cancelTick(app) {\n\t\tif (app.frameRequestId) {\n\t\t\twindow.cancelAnimationFrame(app.frameRequestId);\n\t\t\tapp.frameRequestId = undefined;\n\t\t}\n\t}\n\tgetEntityFromIndex(guid) {\n\t\treturn this._entityIndex[guid];\n\t}\n\t_registerSceneImmediate(scene) {\n\t\tthis.on('postrender', scene.immediate.onPostRender, scene.immediate);\n\t}\n}\nAppBase._applications = {};\nconst _frameEndData = {};\nconst makeTick = function makeTick(_app) {\n\tconst application = _app;\n\treturn function (timestamp, frame) {\n\t\tvar _application$xr2;\n\t\tif (!application.graphicsDevice) return;\n\t\tif (application.frameRequestId) {\n\t\t\tvar _application$xr;\n\t\t\t(_application$xr = application.xr) == null || (_application$xr = _application$xr.session) == null || _application$xr.cancelAnimationFrame(application.frameRequestId);\n\t\t\tcancelAnimationFrame(application.frameRequestId);\n\t\t\tapplication.frameRequestId = null;\n\t\t}\n\t\tapplication._inFrameUpdate = true;\n\t\tsetApplication(application);\n\t\tapp = application;\n\t\tconst currentTime = application._processTimestamp(timestamp) || now();\n\t\tconst ms = currentTime - (application._time || currentTime);\n\t\tlet dt = ms / 1000.0;\n\t\tdt = math.clamp(dt, 0, application.maxDeltaTime);\n\t\tdt *= application.timeScale;\n\t\tapplication._time = currentTime;\n\t\tif ((_application$xr2 = application.xr) != null && _application$xr2.session) {\n\t\t\tapplication.frameRequestId = application.xr.session.requestAnimationFrame(application.tick);\n\t\t} else {\n\t\t\tapplication.frameRequestId = platform.browser || platform.worker ? requestAnimationFrame(application.tick) : null;\n\t\t}\n\t\tif (application.graphicsDevice.contextLost) return;\n\t\tapplication._fillFrameStatsBasic(currentTime, dt, ms);\n\t\tapplication.fire(\"frameupdate\", ms);\n\t\tlet shouldRenderFrame = true;\n\t\tif (frame) {\n\t\t\tvar _application$xr3;\n\t\t\tshouldRenderFrame = (_application$xr3 = application.xr) == null ? void 0 : _application$xr3.update(frame);\n\t\t\tapplication.graphicsDevice.defaultFramebuffer = frame.session.renderState.baseLayer.framebuffer;\n\t\t} else {\n\t\t\tapplication.graphicsDevice.defaultFramebuffer = null;\n\t\t}\n\t\tif (shouldRenderFrame) {\n\t\t\tapplication.update(dt);\n\t\t\tapplication.fire(\"framerender\");\n\t\t\tif (application.autoRender || application.renderNextFrame) {\n\t\t\t\tapplication.updateCanvasSize();\n\t\t\t\tapplication.frameStart();\n\t\t\t\tapplication.render();\n\t\t\t\tapplication.frameEnd();\n\t\t\t\tapplication.renderNextFrame = false;\n\t\t\t}\n\t\t\t_frameEndData.timestamp = now();\n\t\t\t_frameEndData.target = application;\n\t\t\tapplication.fire(\"frameend\", _frameEndData);\n\t\t}\n\t\tapplication._inFrameUpdate = false;\n\t\tif (application._destroyRequested) {\n\t\t\tapplication.destroy();\n\t\t}\n\t};\n};\n\nexport { AppBase, app };\n", "class AppOptions {\n\tconstructor() {\n\t\tthis.elementInput = void 0;\n\t\tthis.keyboard = void 0;\n\t\tthis.mouse = void 0;\n\t\tthis.touch = void 0;\n\t\tthis.gamepads = void 0;\n\t\tthis.scriptPrefix = void 0;\n\t\tthis.assetPrefix = void 0;\n\t\tthis.scriptsOrder = void 0;\n\t\tthis.soundManager = void 0;\n\t\tthis.graphicsDevice = void 0;\n\t\tthis.lightmapper = void 0;\n\t\tthis.batchManager = void 0;\n\t\tthis.xr = void 0;\n\t\tthis.componentSystems = [];\n\t\tthis.resourceHandlers = [];\n\t}\n}\n\nexport { AppOptions };\n", "import { EventHandler } from '../../core/event-handler.js';\n\nclass Component extends EventHandler {\n\tconstructor(system, entity) {\n\t\tsuper();\n\t\tthis.system = void 0;\n\t\tthis.entity = void 0;\n\t\tthis.system = system;\n\t\tthis.entity = entity;\n\t\tif (this.system.schema && !this._accessorsBuilt) {\n\t\t\tthis.buildAccessors(this.system.schema);\n\t\t}\n\t\tthis.on('set', function (name, oldValue, newValue) {\n\t\t\tthis.fire('set_' + name, name, oldValue, newValue);\n\t\t});\n\t\tthis.on('set_enabled', this.onSetEnabled, this);\n\t}\n\tstatic _buildAccessors(obj, schema) {\n\t\tschema.forEach(function (descriptor) {\n\t\t\tconst name = typeof descriptor === 'object' ? descriptor.name : descriptor;\n\t\t\tObject.defineProperty(obj, name, {\n\t\t\t\tget: function () {\n\t\t\t\t\treturn this.data[name];\n\t\t\t\t},\n\t\t\t\tset: function (value) {\n\t\t\t\t\tconst data = this.data;\n\t\t\t\t\tconst oldValue = data[name];\n\t\t\t\t\tdata[name] = value;\n\t\t\t\t\tthis.fire('set', name, oldValue, value);\n\t\t\t\t},\n\t\t\t\tconfigurable: true\n\t\t\t});\n\t\t});\n\t\tobj._accessorsBuilt = true;\n\t}\n\tbuildAccessors(schema) {\n\t\tComponent._buildAccessors(this, schema);\n\t}\n\tonSetEnabled(name, oldValue, newValue) {\n\t\tif (oldValue !== newValue) {\n\t\t\tif (this.entity.enabled) {\n\t\t\t\tif (newValue) {\n\t\t\t\t\tthis.onEnable();\n\t\t\t\t} else {\n\t\t\t\t\tthis.onDisable();\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\tonEnable() {}\n\tonDisable() {}\n\tonPostStateChange() {}\n\tget data() {\n\t\tconst record = this.system.store[this.entity.getGuid()];\n\t\treturn record ? record.data : null;\n\t}\n\tset enabled(arg) {}\n\tget enabled() {\n\t\treturn true;\n\t}\n}\n\nexport { Component };\n", "import { EventHandler } from '../../core/event-handler.js';\nimport { Color } from '../../core/math/color.js';\nimport { Vec2 } from '../../core/math/vec2.js';\nimport { Vec3 } from '../../core/math/vec3.js';\nimport { Vec4 } from '../../core/math/vec4.js';\n\nclass ComponentSystem extends EventHandler {\n\tconstructor(app) {\n\t\tsuper();\n\t\tthis.app = app;\n\t\tthis.store = {};\n\t\tthis.schema = [];\n\t}\n\taddComponent(entity, data = {}) {\n\t\tconst component = new this.ComponentType(this, entity);\n\t\tconst componentData = new this.DataType();\n\t\tthis.store[entity.getGuid()] = {\n\t\t\tentity: entity,\n\t\t\tdata: componentData\n\t\t};\n\t\tentity[this.id] = component;\n\t\tentity.c[this.id] = component;\n\t\tthis.initializeComponentData(component, data, []);\n\t\tthis.fire('add', entity, component);\n\t\treturn component;\n\t}\n\tremoveComponent(entity) {\n\t\tconst record = this.store[entity.getGuid()];\n\t\tconst component = entity.c[this.id];\n\t\tthis.fire('beforeremove', entity, component);\n\t\tdelete this.store[entity.getGuid()];\n\t\tentity[this.id] = undefined;\n\t\tdelete entity.c[this.id];\n\t\tthis.fire('remove', entity, record.data);\n\t}\n\tcloneComponent(entity, clone) {\n\t\tconst src = this.store[entity.getGuid()];\n\t\treturn this.addComponent(clone, src.data);\n\t}\n\tinitializeComponentData(component, data = {}, properties) {\n\t\tfor (let i = 0, len = properties.length; i < len; i++) {\n\t\t\tconst descriptor = properties[i];\n\t\t\tlet name, type;\n\t\t\tif (typeof descriptor === 'object') {\n\t\t\t\tname = descriptor.name;\n\t\t\t\ttype = descriptor.type;\n\t\t\t} else {\n\t\t\t\tname = descriptor;\n\t\t\t\ttype = undefined;\n\t\t\t}\n\t\t\tlet value = data[name];\n\t\t\tif (value !== undefined) {\n\t\t\t\tif (type !== undefined) {\n\t\t\t\t\tvalue = convertValue(value, type);\n\t\t\t\t}\n\t\t\t\tcomponent[name] = value;\n\t\t\t} else {\n\t\t\t\tcomponent[name] = component.data[name];\n\t\t\t}\n\t\t}\n\t\tif (component.enabled && component.entity.enabled) {\n\t\t\tcomponent.onEnable();\n\t\t}\n\t}\n\tgetPropertiesOfType(type) {\n\t\tconst matchingProperties = [];\n\t\tconst schema = this.schema || [];\n\t\tschema.forEach(function (descriptor) {\n\t\t\tif (descriptor && typeof descriptor === 'object' && descriptor.type === type) {\n\t\t\t\tmatchingProperties.push(descriptor);\n\t\t\t}\n\t\t});\n\t\treturn matchingProperties;\n\t}\n\tdestroy() {\n\t\tthis.off();\n\t}\n}\nfunction convertValue(value, type) {\n\tif (!value) {\n\t\treturn value;\n\t}\n\tswitch (type) {\n\t\tcase 'rgb':\n\t\t\tif (value instanceof Color) {\n\t\t\t\treturn value.clone();\n\t\t\t}\n\t\t\treturn new Color(value[0], value[1], value[2]);\n\t\tcase 'rgba':\n\t\t\tif (value instanceof Color) {\n\t\t\t\treturn value.clone();\n\t\t\t}\n\t\t\treturn new Color(value[0], value[1], value[2], value[3]);\n\t\tcase 'vec2':\n\t\t\tif (value instanceof Vec2) {\n\t\t\t\treturn value.clone();\n\t\t\t}\n\t\t\treturn new Vec2(value[0], value[1]);\n\t\tcase 'vec3':\n\t\t\tif (value instanceof Vec3) {\n\t\t\t\treturn value.clone();\n\t\t\t}\n\t\t\treturn new Vec3(value[0], value[1], value[2]);\n\t\tcase 'vec4':\n\t\t\tif (value instanceof Vec4) {\n\t\t\t\treturn value.clone();\n\t\t\t}\n\t\t\treturn new Vec4(value[0], value[1], value[2], value[3]);\n\t\tcase 'boolean':\n\t\tcase 'number':\n\t\tcase 'string':\n\t\t\treturn value;\n\t\tcase 'entity':\n\t\t\treturn value;\n\t\tdefault:\n\t\t\tthrow new Error('Could not convert unhandled type: ' + type);\n\t}\n}\n\nexport { ComponentSystem };\n", "const INTERPOLATION_STEP = 0;\nconst INTERPOLATION_LINEAR = 1;\nconst INTERPOLATION_CUBIC = 2;\n\nexport { INTERPOLATION_CUBIC, INTERPOLATION_LINEAR, INTERPOLATION_STEP };\n", "import { math } from '../../../core/math/math.js';\nimport { INTERPOLATION_STEP, INTERPOLATION_CUBIC, INTERPOLATION_LINEAR } from '../constants.js';\n\nclass AnimCache {\n\tconstructor() {\n\t\tthis._left = Infinity;\n\t\tthis._right = -Infinity;\n\t\tthis._len = 0;\n\t\tthis._recip = 0;\n\t\tthis._p0 = 0;\n\t\tthis._p1 = 0;\n\t\tthis._t = 0;\n\t\tthis._hermite = {\n\t\t\tvalid: false,\n\t\t\tp0: 0,\n\t\t\tm0: 0,\n\t\t\tp1: 0,\n\t\t\tm1: 0\n\t\t};\n\t}\n\tupdate(time, input) {\n\t\tif (time < this._left || time >= this._right) {\n\t\t\tconst len = input.length;\n\t\t\tif (!len) {\n\t\t\t\tthis._left = -Infinity;\n\t\t\t\tthis._right = Infinity;\n\t\t\t\tthis._len = 0;\n\t\t\t\tthis._recip = 0;\n\t\t\t\tthis._p0 = this._p1 = 0;\n\t\t\t} else {\n\t\t\t\tif (time < input[0]) {\n\t\t\t\t\tthis._left = -Infinity;\n\t\t\t\t\tthis._right = input[0];\n\t\t\t\t\tthis._len = 0;\n\t\t\t\t\tthis._recip = 0;\n\t\t\t\t\tthis._p0 = this._p1 = 0;\n\t\t\t\t} else if (time >= input[len - 1]) {\n\t\t\t\t\tthis._left = input[len - 1];\n\t\t\t\t\tthis._right = Infinity;\n\t\t\t\t\tthis._len = 0;\n\t\t\t\t\tthis._recip = 0;\n\t\t\t\t\tthis._p0 = this._p1 = len - 1;\n\t\t\t\t} else {\n\t\t\t\t\tconst index = this._findKey(time, input);\n\t\t\t\t\tthis._left = input[index];\n\t\t\t\t\tthis._right = input[index + 1];\n\t\t\t\t\tthis._len = this._right - this._left;\n\t\t\t\t\tconst diff = 1.0 / this._len;\n\t\t\t\t\tthis._recip = isFinite(diff) ? diff : 0;\n\t\t\t\t\tthis._p0 = index;\n\t\t\t\t\tthis._p1 = index + 1;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tthis._t = this._recip === 0 ? 0 : (time - this._left) * this._recip;\n\t\tthis._hermite.valid = false;\n\t}\n\t_findKey(time, input) {\n\t\tlet index = 0;\n\t\twhile (time >= input[index + 1]) {\n\t\t\tindex++;\n\t\t}\n\t\treturn index;\n\t}\n\teval(result, interpolation, output) {\n\t\tconst data = output._data;\n\t\tconst comp = output._components;\n\t\tconst idx0 = this._p0 * comp;\n\t\tif (interpolation === INTERPOLATION_STEP) {\n\t\t\tfor (let i = 0; i < comp; ++i) {\n\t\t\t\tresult[i] = data[idx0 + i];\n\t\t\t}\n\t\t} else {\n\t\t\tconst t = this._t;\n\t\t\tconst idx1 = this._p1 * comp;\n\t\t\tswitch (interpolation) {\n\t\t\t\tcase INTERPOLATION_LINEAR:\n\t\t\t\t\tfor (let i = 0; i < comp; ++i) {\n\t\t\t\t\t\tresult[i] = math.lerp(data[idx0 + i], data[idx1 + i], t);\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\tcase INTERPOLATION_CUBIC:\n\t\t\t\t\t{\n\t\t\t\t\t\tconst hermite = this._hermite;\n\t\t\t\t\t\tif (!hermite.valid) {\n\t\t\t\t\t\t\tconst t2 = t * t;\n\t\t\t\t\t\t\tconst twot = t + t;\n\t\t\t\t\t\t\tconst omt = 1 - t;\n\t\t\t\t\t\t\tconst omt2 = omt * omt;\n\t\t\t\t\t\t\thermite.valid = true;\n\t\t\t\t\t\t\thermite.p0 = (1 + twot) * omt2;\n\t\t\t\t\t\t\thermite.m0 = t * omt2;\n\t\t\t\t\t\t\thermite.p1 = t2 * (3 - twot);\n\t\t\t\t\t\t\thermite.m1 = t2 * (t - 1);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tconst p0 = (this._p0 * 3 + 1) * comp;\n\t\t\t\t\t\tconst m0 = (this._p0 * 3 + 2) * comp;\n\t\t\t\t\t\tconst p1 = (this._p1 * 3 + 1) * comp;\n\t\t\t\t\t\tconst m1 = (this._p1 * 3 + 0) * comp;\n\t\t\t\t\t\tfor (let i = 0; i < comp; ++i) {\n\t\t\t\t\t\t\tresult[i] = hermite.p0 * data[p0 + i] + hermite.m0 * data[m0 + i] * this._len + hermite.p1 * data[p1 + i] + hermite.m1 * data[m1 + i] * this._len;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n\nexport { AnimCache };\n", "import { AnimCache } from './anim-cache.js';\n\nclass AnimSnapshot {\n\tconstructor(animTrack) {\n\t\tthis._name = animTrack.name + 'Snapshot';\n\t\tthis._time = -1;\n\t\tthis._cache = [];\n\t\tthis._results = [];\n\t\tfor (let i = 0; i < animTrack._inputs.length; ++i) {\n\t\t\tthis._cache[i] = new AnimCache();\n\t\t}\n\t\tconst curves = animTrack._curves;\n\t\tconst outputs = animTrack._outputs;\n\t\tfor (let i = 0; i < curves.length; ++i) {\n\t\t\tconst curve = curves[i];\n\t\t\tconst output = outputs[curve._output];\n\t\t\tconst storage = [];\n\t\t\tfor (let j = 0; j < output._components; ++j) {\n\t\t\t\tstorage[j] = 0;\n\t\t\t}\n\t\t\tthis._results[i] = storage;\n\t\t}\n\t}\n}\n\nexport { AnimSnapshot };\n", "import { extends as _extends } from '../../../../_virtual/_rollupPluginBabelHelpers.js';\nimport { AnimSnapshot } from './anim-snapshot.js';\n\nclass AnimClip {\n\tconstructor(track, time, speed, playing, loop, eventHandler) {\n\t\tthis._name = track.name;\n\t\tthis._track = track;\n\t\tthis._snapshot = new AnimSnapshot(track);\n\t\tthis._playing = playing;\n\t\tthis._time = time;\n\t\tthis._speed = speed;\n\t\tthis._loop = loop;\n\t\tthis._blendWeight = 1.0;\n\t\tthis._blendOrder = 0.0;\n\t\tthis._eventHandler = eventHandler;\n\t\tthis.alignCursorToCurrentTime();\n\t}\n\tset name(name) {\n\t\tthis._name = name;\n\t}\n\tget name() {\n\t\treturn this._name;\n\t}\n\tset track(track) {\n\t\tthis._track = track;\n\t\tthis._snapshot = new AnimSnapshot(track);\n\t}\n\tget track() {\n\t\treturn this._track;\n\t}\n\tget snapshot() {\n\t\treturn this._snapshot;\n\t}\n\tset time(time) {\n\t\tthis._time = time;\n\t\tthis.alignCursorToCurrentTime();\n\t}\n\tget time() {\n\t\treturn this._time;\n\t}\n\tset speed(speed) {\n\t\tconst signChanged = Math.sign(speed) !== Math.sign(this._speed);\n\t\tthis._speed = speed;\n\t\tif (signChanged) {\n\t\t\tthis.alignCursorToCurrentTime();\n\t\t}\n\t}\n\tget speed() {\n\t\treturn this._speed;\n\t}\n\tset loop(loop) {\n\t\tthis._loop = loop;\n\t}\n\tget loop() {\n\t\treturn this._loop;\n\t}\n\tset blendWeight(blendWeight) {\n\t\tthis._blendWeight = blendWeight;\n\t}\n\tget blendWeight() {\n\t\treturn this._blendWeight;\n\t}\n\tset blendOrder(blendOrder) {\n\t\tthis._blendOrder = blendOrder;\n\t}\n\tget blendOrder() {\n\t\treturn this._blendOrder;\n\t}\n\tset eventCursor(value) {\n\t\tthis._eventCursor = value;\n\t}\n\tget eventCursor() {\n\t\treturn this._eventCursor;\n\t}\n\tget eventCursorEnd() {\n\t\treturn this.isReverse ? 0 : this._track.events.length - 1;\n\t}\n\tget nextEvent() {\n\t\treturn this._track.events[this._eventCursor];\n\t}\n\tget isReverse() {\n\t\treturn this._speed < 0;\n\t}\n\tnextEventAheadOfTime(time) {\n\t\tif (!this.nextEvent) return false;\n\t\treturn this.isReverse ? this.nextEvent.time <= time : this.nextEvent.time >= time;\n\t}\n\tnextEventBehindTime(time) {\n\t\tif (!this.nextEvent) return false;\n\t\tif (time === this.track.duration) {\n\t\t\treturn this.isReverse ? this.nextEvent.time >= time : this.nextEvent.time <= time;\n\t\t}\n\t\treturn this.isReverse ? this.nextEvent.time > time : this.nextEvent.time < time;\n\t}\n\tresetEventCursor() {\n\t\tthis._eventCursor = this.isReverse ? this._track.events.length - 1 : 0;\n\t}\n\tmoveEventCursor() {\n\t\tthis._eventCursor += this.isReverse ? -1 : 1;\n\t\tif (this._eventCursor >= this.track.events.length) {\n\t\t\tthis._eventCursor = 0;\n\t\t} else if (this._eventCursor < 0) {\n\t\t\tthis._eventCursor = this.track.events.length - 1;\n\t\t}\n\t}\n\tclipFrameTime(frameEndTime) {\n\t\tconst eventFrame = AnimClip.eventFrame;\n\t\teventFrame.start = 0;\n\t\teventFrame.end = frameEndTime;\n\t\teventFrame.residual = 0;\n\t\tif (this.isReverse) {\n\t\t\tif (frameEndTime < 0) {\n\t\t\t\teventFrame.start = this.track.duration;\n\t\t\t\teventFrame.end = 0;\n\t\t\t\teventFrame.residual = frameEndTime + this.track.duration;\n\t\t\t}\n\t\t} else {\n\t\t\tif (frameEndTime > this.track.duration) {\n\t\t\t\teventFrame.start = 0;\n\t\t\t\teventFrame.end = this.track.duration;\n\t\t\t\teventFrame.residual = frameEndTime - this.track.duration;\n\t\t\t}\n\t\t}\n\t}\n\talignCursorToCurrentTime() {\n\t\tthis.resetEventCursor();\n\t\twhile (this.nextEventBehindTime(this._time) && this._eventCursor !== this.eventCursorEnd) {\n\t\t\tthis.moveEventCursor();\n\t\t}\n\t}\n\tfireNextEvent() {\n\t\tthis._eventHandler.fire(this.nextEvent.name, _extends({\n\t\t\ttrack: this.track\n\t\t}, this.nextEvent));\n\t\tthis.moveEventCursor();\n\t}\n\tfireNextEventInFrame(frameStartTime, frameEndTime) {\n\t\tif (this.nextEventAheadOfTime(frameStartTime) && this.nextEventBehindTime(frameEndTime)) {\n\t\t\tthis.fireNextEvent();\n\t\t\treturn true;\n\t\t}\n\t\treturn false;\n\t}\n\tactiveEventsForFrame(frameStartTime, frameEndTime) {\n\t\tconst eventFrame = AnimClip.eventFrame;\n\t\tthis.clipFrameTime(frameEndTime);\n\t\tconst initialCursor = this.eventCursor;\n\t\twhile (this.fireNextEventInFrame(frameStartTime, eventFrame.end)) {\n\t\t\tif (initialCursor === this.eventCursor) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\tif (this.loop && Math.abs(eventFrame.residual) > 0) {\n\t\t\tthis.activeEventsForFrame(eventFrame.start, eventFrame.residual);\n\t\t}\n\t}\n\tprogressForTime(time) {\n\t\treturn time * this._speed / this._track.duration;\n\t}\n\t_update(deltaTime) {\n\t\tif (this._playing) {\n\t\t\tlet time = this._time;\n\t\t\tconst duration = this._track.duration;\n\t\t\tconst speed = this._speed;\n\t\t\tconst loop = this._loop;\n\t\t\tif (this._track.events.length > 0 && duration > 0) {\n\t\t\t\tthis.activeEventsForFrame(time, time + speed * deltaTime);\n\t\t\t}\n\t\t\ttime += speed * deltaTime;\n\t\t\tif (speed >= 0) {\n\t\t\t\tif (time > duration) {\n\t\t\t\t\tif (loop) {\n\t\t\t\t\t\ttime = time % duration || 0;\n\t\t\t\t\t} else {\n\t\t\t\t\t\ttime = this._track.duration;\n\t\t\t\t\t\tthis.pause();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tif (time < 0) {\n\t\t\t\t\tif (loop) {\n\t\t\t\t\t\ttime = duration + (time % duration || 0);\n\t\t\t\t\t} else {\n\t\t\t\t\t\ttime = 0;\n\t\t\t\t\t\tthis.pause();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis._time = time;\n\t\t}\n\t\tif (this._time !== this._snapshot._time) {\n\t\t\tthis._track.eval(this._time, this._snapshot);\n\t\t}\n\t}\n\tplay() {\n\t\tthis._playing = true;\n\t\tthis._time = 0;\n\t}\n\tstop() {\n\t\tthis._playing = false;\n\t\tthis._time = 0;\n\t}\n\tpause() {\n\t\tthis._playing = false;\n\t}\n\tresume() {\n\t\tthis._playing = true;\n\t}\n\treset() {\n\t\tthis._time = 0;\n\t}\n}\nAnimClip.eventFrame = {\n\tstart: 0,\n\tend: 0,\n\tresidual: 0\n};\n\nexport { AnimClip };\n", "const ANIM_INTERRUPTION_NONE = 'NONE';\nconst ANIM_INTERRUPTION_PREV = 'PREV_STATE';\nconst ANIM_INTERRUPTION_NEXT = 'NEXT_STATE';\nconst ANIM_INTERRUPTION_PREV_NEXT = 'PREV_STATE_NEXT_STATE';\nconst ANIM_INTERRUPTION_NEXT_PREV = 'NEXT_STATE_PREV_STATE';\nconst ANIM_GREATER_THAN = 'GREATER_THAN';\nconst ANIM_LESS_THAN = 'LESS_THAN';\nconst ANIM_GREATER_THAN_EQUAL_TO = 'GREATER_THAN_EQUAL_TO';\nconst ANIM_LESS_THAN_EQUAL_TO = 'LESS_THAN_EQUAL_TO';\nconst ANIM_EQUAL_TO = 'EQUAL_TO';\nconst ANIM_NOT_EQUAL_TO = 'NOT_EQUAL_TO';\nconst ANIM_PARAMETER_INTEGER = 'INTEGER';\nconst ANIM_PARAMETER_FLOAT = 'FLOAT';\nconst ANIM_PARAMETER_BOOLEAN = 'BOOLEAN';\nconst ANIM_PARAMETER_TRIGGER = 'TRIGGER';\nconst ANIM_BLEND_1D = '1D';\nconst ANIM_BLEND_2D_DIRECTIONAL = '2D_DIRECTIONAL';\nconst ANIM_BLEND_2D_CARTESIAN = '2D_CARTESIAN';\nconst ANIM_BLEND_DIRECT = 'DIRECT';\nconst ANIM_STATE_START = 'START';\nconst ANIM_STATE_END = 'END';\nconst ANIM_STATE_ANY = 'ANY';\nconst ANIM_CONTROL_STATES = [ANIM_STATE_START, ANIM_STATE_END, ANIM_STATE_ANY];\nconst ANIM_LAYER_OVERWRITE = 'OVERWRITE';\nconst ANIM_LAYER_ADDITIVE = 'ADDITIVE';\n\nexport { ANIM_BLEND_1D, ANIM_BLEND_2D_CARTESIAN, ANIM_BLEND_2D_DIRECTIONAL, ANIM_BLEND_DIRECT, ANIM_CONTROL_STATES, ANIM_EQUAL_TO, ANIM_GREATER_THAN, ANIM_GREATER_THAN_EQUAL_TO, ANIM_INTERRUPTION_NEXT, ANIM_INTERRUPTION_NEXT_PREV, ANIM_INTERRUPTION_NONE, ANIM_INTERRUPTION_PREV, ANIM_INTERRUPTION_PREV_NEXT, ANIM_LAYER_ADDITIVE, ANIM_LAYER_OVERWRITE, ANIM_LESS_THAN, ANIM_LESS_THAN_EQUAL_TO, ANIM_NOT_EQUAL_TO, ANIM_PARAMETER_BOOLEAN, ANIM_PARAMETER_FLOAT, ANIM_PARAMETER_INTEGER, ANIM_PARAMETER_TRIGGER, ANIM_STATE_ANY, ANIM_STATE_END, ANIM_STATE_START };\n", "class AnimBlend {\n\tstatic dot(a, b) {\n\t\tconst len = a.length;\n\t\tlet result = 0;\n\t\tfor (let i = 0; i < len; ++i) {\n\t\t\tresult += a[i] * b[i];\n\t\t}\n\t\treturn result;\n\t}\n\tstatic normalize(a) {\n\t\tlet l = AnimBlend.dot(a, a);\n\t\tif (l > 0) {\n\t\t\tl = 1.0 / Math.sqrt(l);\n\t\t\tconst len = a.length;\n\t\t\tfor (let i = 0; i < len; ++i) {\n\t\t\t\ta[i] *= l;\n\t\t\t}\n\t\t}\n\t}\n\tstatic set(a, b, type) {\n\t\tconst len = a.length;\n\t\tif (type === 'quaternion') {\n\t\t\tlet l = AnimBlend.dot(b, b);\n\t\t\tif (l > 0) {\n\t\t\t\tl = 1.0 / Math.sqrt(l);\n\t\t\t}\n\t\t\tfor (let i = 0; i < len; ++i) {\n\t\t\t\ta[i] = b[i] * l;\n\t\t\t}\n\t\t} else {\n\t\t\tfor (let i = 0; i < len; ++i) {\n\t\t\t\ta[i] = b[i];\n\t\t\t}\n\t\t}\n\t}\n\tstatic blendVec(a, b, t, additive) {\n\t\tconst it = additive ? 1.0 : 1.0 - t;\n\t\tconst len = a.length;\n\t\tfor (let i = 0; i < len; ++i) {\n\t\t\ta[i] = a[i] * it + b[i] * t;\n\t\t}\n\t}\n\tstatic blendQuat(a, b, t, additive) {\n\t\tconst len = a.length;\n\t\tconst it = additive ? 1.0 : 1.0 - t;\n\t\tif (AnimBlend.dot(a, b) < 0) {\n\t\t\tt = -t;\n\t\t}\n\t\tfor (let i = 0; i < len; ++i) {\n\t\t\ta[i] = a[i] * it + b[i] * t;\n\t\t}\n\t\tif (!additive) {\n\t\t\tAnimBlend.normalize(a);\n\t\t}\n\t}\n\tstatic blend(a, b, t, type, additive) {\n\t\tif (type === 'quaternion') {\n\t\t\tAnimBlend.blendQuat(a, b, t, additive);\n\t\t} else {\n\t\t\tAnimBlend.blendVec(a, b, t, additive);\n\t\t}\n\t}\n\tstatic stableSort(a, lessFunc) {\n\t\tconst len = a.length;\n\t\tfor (let i = 0; i < len - 1; ++i) {\n\t\t\tfor (let j = i + 1; j < len; ++j) {\n\t\t\t\tif (lessFunc(a[j], a[i])) {\n\t\t\t\t\tconst tmp = a[i];\n\t\t\t\t\ta[i] = a[j];\n\t\t\t\t\ta[j] = tmp;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n\nexport { AnimBlend };\n", "import { Quat } from '../../../core/math/quat.js';\nimport { ANIM_LAYER_OVERWRITE, ANIM_LAYER_ADDITIVE } from '../controller/constants.js';\nimport { AnimBlend } from './anim-blend.js';\nimport { math } from '../../../core/math/math.js';\n\nclass AnimTargetValue {\n\tconstructor(component, type) {\n\t\tthis._component = component;\n\t\tthis.mask = new Int8Array(component.layers.length);\n\t\tthis.weights = new Float32Array(component.layers.length);\n\t\tthis.totalWeight = 0;\n\t\tthis.counter = 0;\n\t\tthis.layerCounter = 0;\n\t\tthis.valueType = type;\n\t\tthis.dirty = true;\n\t\tthis.value = type === AnimTargetValue.TYPE_QUAT ? [0, 0, 0, 1] : [0, 0, 0];\n\t\tthis.baseValue = null;\n\t\tthis.setter = null;\n\t}\n\tget _normalizeWeights() {\n\t\treturn this._component.normalizeWeights;\n\t}\n\tgetWeight(index) {\n\t\tif (this.dirty) this.updateWeights();\n\t\tif (this._normalizeWeights && this.totalWeight === 0 || !this.mask[index]) {\n\t\t\treturn 0;\n\t\t} else if (this._normalizeWeights) {\n\t\t\treturn this.weights[index] / this.totalWeight;\n\t\t}\n\t\treturn math.clamp(this.weights[index], 0, 1);\n\t}\n\t_layerBlendType(index) {\n\t\treturn this._component.layers[index].blendType;\n\t}\n\tsetMask(index, value) {\n\t\tthis.mask[index] = value;\n\t\tif (this._normalizeWeights) {\n\t\t\tif (this._component.layers[index].blendType === ANIM_LAYER_OVERWRITE) {\n\t\t\t\tthis.mask = this.mask.fill(0, 0, index);\n\t\t\t}\n\t\t\tthis.dirty = true;\n\t\t}\n\t}\n\tupdateWeights() {\n\t\tthis.totalWeight = 0;\n\t\tfor (let i = 0; i < this.weights.length; i++) {\n\t\t\tthis.weights[i] = this._component.layers[i].weight;\n\t\t\tthis.totalWeight += this.mask[i] * this.weights[i];\n\t\t}\n\t\tthis.dirty = false;\n\t}\n\tupdateValue(index, value) {\n\t\tif (this.counter === 0) {\n\t\t\tAnimBlend.set(this.value, AnimTargetValue.IDENTITY_QUAT_ARR, this.valueType);\n\t\t\tif (!this._normalizeWeights) {\n\t\t\t\tAnimBlend.blend(this.value, this.baseValue, 1, this.valueType);\n\t\t\t}\n\t\t}\n\t\tif (!this.mask[index] || this.getWeight(index) === 0) return;\n\t\tif (this._layerBlendType(index) === ANIM_LAYER_ADDITIVE && !this._normalizeWeights) {\n\t\t\tif (this.valueType === AnimTargetValue.TYPE_QUAT) {\n\t\t\t\tconst v = AnimTargetValue.q1.set(this.value[0], this.value[1], this.value[2], this.value[3]);\n\t\t\t\tconst aV1 = AnimTargetValue.q2.set(this.baseValue[0], this.baseValue[1], this.baseValue[2], this.baseValue[3]);\n\t\t\t\tconst aV2 = AnimTargetValue.q3.set(value[0], value[1], value[2], value[3]);\n\t\t\t\tconst aV = aV1.invert().mul(aV2);\n\t\t\t\taV.slerp(Quat.IDENTITY, aV, this.getWeight(index));\n\t\t\t\tv.mul(aV);\n\t\t\t\tAnimTargetValue.quatArr[0] = v.x;\n\t\t\t\tAnimTargetValue.quatArr[1] = v.y;\n\t\t\t\tAnimTargetValue.quatArr[2] = v.z;\n\t\t\t\tAnimTargetValue.quatArr[3] = v.w;\n\t\t\t\tAnimBlend.set(this.value, AnimTargetValue.quatArr, this.valueType);\n\t\t\t} else {\n\t\t\t\tAnimTargetValue.vecArr[0] = value[0] - this.baseValue[0];\n\t\t\t\tAnimTargetValue.vecArr[1] = value[1] - this.baseValue[1];\n\t\t\t\tAnimTargetValue.vecArr[2] = value[2] - this.baseValue[2];\n\t\t\t\tAnimBlend.blend(this.value, AnimTargetValue.vecArr, this.getWeight(index), this.valueType, true);\n\t\t\t}\n\t\t} else {\n\t\t\tAnimBlend.blend(this.value, value, this.getWeight(index), this.valueType);\n\t\t}\n\t\tif (this.setter) this.setter(this.value);\n\t}\n\tunbind() {\n\t\tif (this.setter) {\n\t\t\tthis.setter(this.baseValue);\n\t\t}\n\t}\n}\nAnimTargetValue.TYPE_QUAT = 'quaternion';\nAnimTargetValue.TYPE_VEC3 = 'vector3';\nAnimTargetValue.q1 = new Quat();\nAnimTargetValue.q2 = new Quat();\nAnimTargetValue.q3 = new Quat();\nAnimTargetValue.quatArr = [0, 0, 0, 1];\nAnimTargetValue.vecArr = [0, 0, 0];\nAnimTargetValue.IDENTITY_QUAT_ARR = [0, 0, 0, 1];\n\nexport { AnimTargetValue };\n", "import { AnimTargetValue } from './anim-target-value.js';\nimport { AnimBlend } from './anim-blend.js';\n\nclass AnimEvaluator {\n\tconstructor(binder) {\n\t\tthis._binder = binder;\n\t\tthis._clips = [];\n\t\tthis._inputs = [];\n\t\tthis._outputs = [];\n\t\tthis._targets = {};\n\t}\n\tget clips() {\n\t\treturn this._clips;\n\t}\n\taddClip(clip) {\n\t\tconst targets = this._targets;\n\t\tconst binder = this._binder;\n\t\tconst curves = clip.track.curves;\n\t\tconst snapshot = clip.snapshot;\n\t\tconst inputs = [];\n\t\tconst outputs = [];\n\t\tfor (let i = 0; i < curves.length; ++i) {\n\t\t\tconst curve = curves[i];\n\t\t\tconst paths = curve.paths;\n\t\t\tfor (let j = 0; j < paths.length; ++j) {\n\t\t\t\tconst path = paths[j];\n\t\t\t\tconst resolved = binder.resolve(path);\n\t\t\t\tlet target = targets[resolved && resolved.targetPath || null];\n\t\t\t\tif (!target && resolved) {\n\t\t\t\t\ttarget = {\n\t\t\t\t\t\ttarget: resolved,\n\t\t\t\t\t\tvalue: [],\n\t\t\t\t\t\tcurves: 0,\n\t\t\t\t\t\tblendCounter: 0\n\t\t\t\t\t};\n\t\t\t\t\tfor (let k = 0; k < target.target.components; ++k) {\n\t\t\t\t\t\ttarget.value.push(0);\n\t\t\t\t\t}\n\t\t\t\t\ttargets[resolved.targetPath] = target;\n\t\t\t\t\tif (binder.animComponent) {\n\t\t\t\t\t\tif (!binder.animComponent.targets[resolved.targetPath]) {\n\t\t\t\t\t\t\tlet type;\n\t\t\t\t\t\t\tif (resolved.targetPath.substring(resolved.targetPath.length - 13) === 'localRotation') {\n\t\t\t\t\t\t\t\ttype = AnimTargetValue.TYPE_QUAT;\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\ttype = AnimTargetValue.TYPE_VEC3;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tbinder.animComponent.targets[resolved.targetPath] = new AnimTargetValue(binder.animComponent, type);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tbinder.animComponent.targets[resolved.targetPath].layerCounter++;\n\t\t\t\t\t\tbinder.animComponent.targets[resolved.targetPath].setMask(binder.layerIndex, 1);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tif (target) {\n\t\t\t\t\ttarget.curves++;\n\t\t\t\t\tinputs.push(snapshot._results[i]);\n\t\t\t\t\toutputs.push(target);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tthis._clips.push(clip);\n\t\tthis._inputs.push(inputs);\n\t\tthis._outputs.push(outputs);\n\t}\n\tremoveClip(index) {\n\t\tconst targets = this._targets;\n\t\tconst binder = this._binder;\n\t\tconst clips = this._clips;\n\t\tconst clip = clips[index];\n\t\tconst curves = clip.track.curves;\n\t\tfor (let i = 0; i < curves.length; ++i) {\n\t\t\tconst curve = curves[i];\n\t\t\tconst paths = curve.paths;\n\t\t\tfor (let j = 0; j < paths.length; ++j) {\n\t\t\t\tconst path = paths[j];\n\t\t\t\tconst target = this._binder.resolve(path);\n\t\t\t\tif (target) {\n\t\t\t\t\ttarget.curves--;\n\t\t\t\t\tif (target.curves === 0) {\n\t\t\t\t\t\tbinder.unresolve(path);\n\t\t\t\t\t\tdelete targets[target.targetPath];\n\t\t\t\t\t\tif (binder.animComponent) {\n\t\t\t\t\t\t\tbinder.animComponent.targets[target.targetPath].layerCounter--;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tclips.splice(index, 1);\n\t\tthis._inputs.splice(index, 1);\n\t\tthis._outputs.splice(index, 1);\n\t}\n\tremoveClips() {\n\t\twhile (this._clips.length > 0) {\n\t\t\tthis.removeClip(0);\n\t\t}\n\t}\n\tupdateClipTrack(name, animTrack) {\n\t\tthis._clips.forEach(clip => {\n\t\t\tif (clip.name.includes(name)) {\n\t\t\t\tclip.track = animTrack;\n\t\t\t}\n\t\t});\n\t\tthis.rebind();\n\t}\n\tfindClip(name) {\n\t\tconst clips = this._clips;\n\t\tfor (let i = 0; i < clips.length; ++i) {\n\t\t\tconst clip = clips[i];\n\t\t\tif (clip.name === name) {\n\t\t\t\treturn clip;\n\t\t\t}\n\t\t}\n\t\treturn null;\n\t}\n\trebind() {\n\t\tthis._binder.rebind();\n\t\tthis._targets = {};\n\t\tconst clips = [...this.clips];\n\t\tthis.removeClips();\n\t\tclips.forEach(clip => {\n\t\t\tthis.addClip(clip);\n\t\t});\n\t}\n\tassignMask(mask) {\n\t\treturn this._binder.assignMask(mask);\n\t}\n\tupdate(deltaTime, outputAnimation = true) {\n\t\tconst clips = this._clips;\n\t\tconst order = clips.map(function (c, i) {\n\t\t\treturn i;\n\t\t});\n\t\tAnimBlend.stableSort(order, function (a, b) {\n\t\t\treturn clips[a].blendOrder < clips[b].blendOrder;\n\t\t});\n\t\tfor (let i = 0; i < order.length; ++i) {\n\t\t\tconst index = order[i];\n\t\t\tconst clip = clips[index];\n\t\t\tconst inputs = this._inputs[index];\n\t\t\tconst outputs = this._outputs[index];\n\t\t\tconst blendWeight = clip.blendWeight;\n\t\t\tif (blendWeight > 0.0) {\n\t\t\t\tclip._update(deltaTime);\n\t\t\t}\n\t\t\tif (!outputAnimation) break;\n\t\t\tlet input;\n\t\t\tlet output;\n\t\t\tlet value;\n\t\t\tif (blendWeight >= 1.0) {\n\t\t\t\tfor (let j = 0; j < inputs.length; ++j) {\n\t\t\t\t\tinput = inputs[j];\n\t\t\t\t\toutput = outputs[j];\n\t\t\t\t\tvalue = output.value;\n\t\t\t\t\tAnimBlend.set(value, input, output.target.type);\n\t\t\t\t\toutput.blendCounter++;\n\t\t\t\t}\n\t\t\t} else if (blendWeight > 0.0) {\n\t\t\t\tfor (let j = 0; j < inputs.length; ++j) {\n\t\t\t\t\tinput = inputs[j];\n\t\t\t\t\toutput = outputs[j];\n\t\t\t\t\tvalue = output.value;\n\t\t\t\t\tif (output.blendCounter === 0) {\n\t\t\t\t\t\tAnimBlend.set(value, input, output.target.type);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tAnimBlend.blend(value, input, blendWeight, output.target.type);\n\t\t\t\t\t}\n\t\t\t\t\toutput.blendCounter++;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tconst targets = this._targets;\n\t\tconst binder = this._binder;\n\t\tfor (const path in targets) {\n\t\t\tif (targets.hasOwnProperty(path)) {\n\t\t\t\tconst target = targets[path];\n\t\t\t\tif (binder.animComponent && target.target.isTransform) {\n\t\t\t\t\tconst animTarget = binder.animComponent.targets[path];\n\t\t\t\t\tif (animTarget.counter === animTarget.layerCounter) {\n\t\t\t\t\t\tanimTarget.counter = 0;\n\t\t\t\t\t}\n\t\t\t\t\tif (!animTarget.path) {\n\t\t\t\t\t\tanimTarget.path = path;\n\t\t\t\t\t\tanimTarget.baseValue = target.target.get();\n\t\t\t\t\t\tanimTarget.setter = target.target.set;\n\t\t\t\t\t}\n\t\t\t\t\tanimTarget.updateValue(binder.layerIndex, target.value);\n\t\t\t\t\tanimTarget.counter++;\n\t\t\t\t} else {\n\t\t\t\t\ttarget.target.set(target.value);\n\t\t\t\t}\n\t\t\t\ttarget.blendCounter = 0;\n\t\t\t}\n\t\t}\n\t\tthis._binder.update(deltaTime);\n\t}\n}\n\nexport { AnimEvaluator };\n", "class AnimEvents {\n\tconstructor(events) {\n\t\tthis._events = [...events];\n\t\tthis._events.sort((a, b) => a.time - b.time);\n\t}\n\tget events() {\n\t\treturn this._events;\n\t}\n}\n\nexport { AnimEvents };\n", "import { AnimEvents } from './anim-events.js';\n\nvar _AnimTrack;\nclass AnimTrack {\n\tconstructor(name, duration, inputs, outputs, curves, animEvents = new AnimEvents([])) {\n\t\tthis._name = name;\n\t\tthis._duration = duration;\n\t\tthis._inputs = inputs;\n\t\tthis._outputs = outputs;\n\t\tthis._curves = curves;\n\t\tthis._animEvents = animEvents;\n\t}\n\tget name() {\n\t\treturn this._name;\n\t}\n\tget duration() {\n\t\treturn this._duration;\n\t}\n\tget inputs() {\n\t\treturn this._inputs;\n\t}\n\tget outputs() {\n\t\treturn this._outputs;\n\t}\n\tget curves() {\n\t\treturn this._curves;\n\t}\n\tset events(animEvents) {\n\t\tthis._animEvents = animEvents;\n\t}\n\tget events() {\n\t\treturn this._animEvents.events;\n\t}\n\teval(time, snapshot) {\n\t\tsnapshot._time = time;\n\t\tconst inputs = this._inputs;\n\t\tconst outputs = this._outputs;\n\t\tconst curves = this._curves;\n\t\tconst cache = snapshot._cache;\n\t\tconst results = snapshot._results;\n\t\tfor (let i = 0; i < inputs.length; ++i) {\n\t\t\tcache[i].update(time, inputs[i]._data);\n\t\t}\n\t\tfor (let i = 0; i < curves.length; ++i) {\n\t\t\tconst curve = curves[i];\n\t\t\tconst output = outputs[curve._output];\n\t\t\tconst result = results[i];\n\t\t\tcache[curve._input].eval(result, curve._interpolation, output);\n\t\t}\n\t}\n}\n_AnimTrack = AnimTrack;\nAnimTrack.EMPTY = Object.freeze(new _AnimTrack('empty', Number.MAX_VALUE, [], [], []));\n\nexport { AnimTrack };\n", "class AnimBinder {\n\tstatic joinPath(pathSegments, character) {\n\t\tcharacter = character || '.';\n\t\tconst escape = function escape(string) {\n\t\t\treturn string.replace(/\\\\/g, '\\\\\\\\').replace(new RegExp('\\\\' + character, 'g'), '\\\\' + character);\n\t\t};\n\t\treturn pathSegments.map(escape).join(character);\n\t}\n\tstatic splitPath(path, character) {\n\t\tcharacter = character || '.';\n\t\tconst result = [];\n\t\tlet curr = \"\";\n\t\tlet i = 0;\n\t\twhile (i < path.length) {\n\t\t\tlet c = path[i++];\n\t\t\tif (c === '\\\\' && i < path.length) {\n\t\t\t\tc = path[i++];\n\t\t\t\tif (c === '\\\\' || c === character) {\n\t\t\t\t\tcurr += c;\n\t\t\t\t} else {\n\t\t\t\t\tcurr += '\\\\' + c;\n\t\t\t\t}\n\t\t\t} else if (c === character) {\n\t\t\t\tresult.push(curr);\n\t\t\t\tcurr = '';\n\t\t\t} else {\n\t\t\t\tcurr += c;\n\t\t\t}\n\t\t}\n\t\tif (curr.length > 0) {\n\t\t\tresult.push(curr);\n\t\t}\n\t\treturn result;\n\t}\n\tstatic encode(entityPath, component, propertyPath) {\n\t\treturn `${Array.isArray(entityPath) ? entityPath.join('/') : entityPath}/${component}/${Array.isArray(propertyPath) ? propertyPath.join('/') : propertyPath}`;\n\t}\n\tresolve(path) {\n\t\treturn null;\n\t}\n\tunresolve(path) {}\n\tupdate(deltaTime) {}\n}\n\nexport { AnimBinder };\n", "class AnimTarget {\n\tconstructor(func, type, components, targetPath) {\n\t\tif (func.set) {\n\t\t\tthis._set = func.set;\n\t\t\tthis._get = func.get;\n\t\t} else {\n\t\t\tthis._set = func;\n\t\t}\n\t\tthis._type = type;\n\t\tthis._components = components;\n\t\tthis._targetPath = targetPath;\n\t\tthis._isTransform = this._targetPath.substring(this._targetPath.length - 13) === 'localRotation' || this._targetPath.substring(this._targetPath.length - 13) === 'localPosition' || this._targetPath.substring(this._targetPath.length - 10) === 'localScale';\n\t}\n\tget set() {\n\t\treturn this._set;\n\t}\n\tget get() {\n\t\treturn this._get;\n\t}\n\tget type() {\n\t\treturn this._type;\n\t}\n\tget components() {\n\t\treturn this._components;\n\t}\n\tget targetPath() {\n\t\treturn this._targetPath;\n\t}\n\tget isTransform() {\n\t\treturn this._isTransform;\n\t}\n}\n\nexport { AnimTarget };\n", "import { AnimBinder } from './anim-binder.js';\nimport { AnimTarget } from '../evaluator/anim-target.js';\nimport { Entity } from '../../entity.js';\n\nclass DefaultAnimBinder {\n\tconstructor(graph) {\n\t\tthis._isPathInMask = (path, checkMaskValue) => {\n\t\t\tconst maskItem = this._mask[path];\n\t\t\tif (!maskItem) return false;else if (maskItem.children || checkMaskValue && maskItem.value !== false) return true;\n\t\t\treturn false;\n\t\t};\n\t\tthis.graph = graph;\n\t\tif (!graph) return;\n\t\tthis._mask = null;\n\t\tconst nodes = {};\n\t\tconst flatten = function flatten(node) {\n\t\t\tnodes[node.name] = node;\n\t\t\tfor (let i = 0; i < node.children.length; ++i) {\n\t\t\t\tflatten(node.children[i]);\n\t\t\t}\n\t\t};\n\t\tflatten(graph);\n\t\tthis.nodes = nodes;\n\t\tthis.targetCache = {};\n\t\tconst findMeshInstances = function findMeshInstances(node) {\n\t\t\tlet object = node;\n\t\t\twhile (object && !(object instanceof Entity)) {\n\t\t\t\tobject = object.parent;\n\t\t\t}\n\t\t\tlet meshInstances;\n\t\t\tif (object) {\n\t\t\t\tif (object.render) {\n\t\t\t\t\tmeshInstances = object.render.meshInstances;\n\t\t\t\t} else if (object.model) {\n\t\t\t\t\tmeshInstances = object.model.meshInstances;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn meshInstances;\n\t\t};\n\t\tthis.nodeCounts = {};\n\t\tthis.activeNodes = [];\n\t\tthis.handlers = {\n\t\t\t'localPosition': function (node) {\n\t\t\t\tconst object = node.localPosition;\n\t\t\t\tconst func = function func(value) {\n\t\t\t\t\tobject.set(...value);\n\t\t\t\t};\n\t\t\t\treturn DefaultAnimBinder.createAnimTarget(func, 'vector', 3, node, 'localPosition');\n\t\t\t},\n\t\t\t'localRotation': function (node) {\n\t\t\t\tconst object = node.localRotation;\n\t\t\t\tconst func = function func(value) {\n\t\t\t\t\tobject.set(...value);\n\t\t\t\t};\n\t\t\t\treturn DefaultAnimBinder.createAnimTarget(func, 'quaternion', 4, node, 'localRotation');\n\t\t\t},\n\t\t\t'localScale': function (node) {\n\t\t\t\tconst object = node.localScale;\n\t\t\t\tconst func = function func(value) {\n\t\t\t\t\tobject.set(...value);\n\t\t\t\t};\n\t\t\t\treturn DefaultAnimBinder.createAnimTarget(func, 'vector', 3, node, 'localScale');\n\t\t\t},\n\t\t\t'weight': function (node, weightName) {\n\t\t\t\tif (weightName.indexOf('name.') === 0) {\n\t\t\t\t\tweightName = weightName.replace('name.', '');\n\t\t\t\t} else {\n\t\t\t\t\tweightName = Number(weightName);\n\t\t\t\t}\n\t\t\t\tconst meshInstances = findMeshInstances(node);\n\t\t\t\tlet setters;\n\t\t\t\tif (meshInstances) {\n\t\t\t\t\tfor (let i = 0; i < meshInstances.length; ++i) {\n\t\t\t\t\t\tif (meshInstances[i].node.name === node.name && meshInstances[i].morphInstance) {\n\t\t\t\t\t\t\tconst morphInstance = meshInstances[i].morphInstance;\n\t\t\t\t\t\t\tconst func = value => {\n\t\t\t\t\t\t\t\tmorphInstance.setWeight(weightName, value[0]);\n\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\tif (!setters) setters = [];\n\t\t\t\t\t\t\tsetters.push(func);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tif (setters) {\n\t\t\t\t\tconst callSetters = value => {\n\t\t\t\t\t\tfor (let i = 0; i < setters.length; ++i) {\n\t\t\t\t\t\t\tsetters[i](value);\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\t\t\t\t\treturn DefaultAnimBinder.createAnimTarget(callSetters, 'number', 1, node, `weight.${weightName}`);\n\t\t\t\t}\n\t\t\t\treturn null;\n\t\t\t},\n\t\t\t'materialTexture': (node, textureName) => {\n\t\t\t\tconst meshInstances = findMeshInstances(node);\n\t\t\t\tif (meshInstances) {\n\t\t\t\t\tlet meshInstance;\n\t\t\t\t\tfor (let i = 0; i < meshInstances.length; ++i) {\n\t\t\t\t\t\tif (meshInstances[i].node.name === node.name) {\n\t\t\t\t\t\t\tmeshInstance = meshInstances[i];\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif (meshInstance) {\n\t\t\t\t\t\tconst func = value => {\n\t\t\t\t\t\t\tconst textureAsset = this.animComponent.system.app.assets.get(value[0]);\n\t\t\t\t\t\t\tif (textureAsset && textureAsset.resource && textureAsset.type === 'texture') {\n\t\t\t\t\t\t\t\tmeshInstance.material[textureName] = textureAsset.resource;\n\t\t\t\t\t\t\t\tmeshInstance.material.update();\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t};\n\t\t\t\t\t\treturn DefaultAnimBinder.createAnimTarget(func, 'vector', 1, node, 'materialTexture', 'material');\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn null;\n\t\t\t}\n\t\t};\n\t}\n\t_isPathActive(path) {\n\t\tif (!this._mask) return true;\n\t\tconst rootNodeNames = [path.entityPath[0], this.graph.name];\n\t\tfor (let j = 0; j < rootNodeNames.length; ++j) {\n\t\t\tlet currEntityPath = rootNodeNames[j];\n\t\t\tif (this._isPathInMask(currEntityPath, path.entityPath.length === 1)) return true;\n\t\t\tfor (let i = 1; i < path.entityPath.length; i++) {\n\t\t\t\tcurrEntityPath += '/' + path.entityPath[i];\n\t\t\t\tif (this._isPathInMask(currEntityPath, i === path.entityPath.length - 1)) return true;\n\t\t\t}\n\t\t}\n\t\treturn false;\n\t}\n\tfindNode(path) {\n\t\tif (!this._isPathActive(path)) {\n\t\t\treturn null;\n\t\t}\n\t\tlet node;\n\t\tif (this.graph) {\n\t\t\tnode = this.graph.findByPath(path.entityPath);\n\t\t\tif (!node) {\n\t\t\t\tnode = this.graph.findByPath(path.entityPath.slice(1));\n\t\t\t}\n\t\t}\n\t\tif (!node) {\n\t\t\tnode = this.nodes[path.entityPath[path.entityPath.length - 1] || \"\"];\n\t\t}\n\t\treturn node;\n\t}\n\tstatic createAnimTarget(func, type, valueCount, node, propertyPath, componentType) {\n\t\tconst targetPath = AnimBinder.encode(node.path, componentType ? componentType : 'entity', propertyPath);\n\t\treturn new AnimTarget(func, type, valueCount, targetPath);\n\t}\n\tresolve(path) {\n\t\tconst encodedPath = AnimBinder.encode(path.entityPath, path.component, path.propertyPath);\n\t\tlet target = this.targetCache[encodedPath];\n\t\tif (target) return target;\n\t\tconst node = this.findNode(path);\n\t\tif (!node) {\n\t\t\treturn null;\n\t\t}\n\t\tconst handler = this.handlers[path.propertyPath];\n\t\tif (!handler) {\n\t\t\treturn null;\n\t\t}\n\t\ttarget = handler(node);\n\t\tif (!target) {\n\t\t\treturn null;\n\t\t}\n\t\tthis.targetCache[encodedPath] = target;\n\t\tif (!this.nodeCounts[node.path]) {\n\t\t\tthis.activeNodes.push(node);\n\t\t\tthis.nodeCounts[node.path] = 1;\n\t\t} else {\n\t\t\tthis.nodeCounts[node.path]++;\n\t\t}\n\t\treturn target;\n\t}\n\tunresolve(path) {\n\t\tif (path.component !== 'graph') return;\n\t\tconst node = this.nodes[path.entityPath[path.entityPath.length - 1] || \"\"];\n\t\tthis.nodeCounts[node.path]--;\n\t\tif (this.nodeCounts[node.path] === 0) {\n\t\t\tconst activeNodes = this.activeNodes;\n\t\t\tconst i = activeNodes.indexOf(node.node);\n\t\t\tconst len = activeNodes.length;\n\t\t\tif (i < len - 1) {\n\t\t\t\tactiveNodes[i] = activeNodes[len - 1];\n\t\t\t}\n\t\t\tactiveNodes.pop();\n\t\t}\n\t}\n\tupdate(deltaTime) {\n\t\tconst activeNodes = this.activeNodes;\n\t\tfor (let i = 0; i < activeNodes.length; ++i) {\n\t\t\tactiveNodes[i]._dirtifyLocal();\n\t\t}\n\t}\n\tassignMask(mask) {\n\t\tif (mask !== this._mask) {\n\t\t\tthis._mask = mask;\n\t\t\treturn true;\n\t\t}\n\t\treturn false;\n\t}\n}\n\nexport { DefaultAnimBinder };\n", "import { Vec2 } from '../../../core/math/vec2.js';\n\nclass AnimNode {\n\tconstructor(state, parent, name, point, speed = 1) {\n\t\tthis._state = state;\n\t\tthis._parent = parent;\n\t\tthis._name = name;\n\t\tif (Array.isArray(point)) {\n\t\t\tthis._point = new Vec2(point[0], point[1]);\n\t\t\tthis._pointLength = this._point.length();\n\t\t} else {\n\t\t\tthis._point = point;\n\t\t\tthis._pointLength = point;\n\t\t}\n\t\tthis._speed = speed;\n\t\tthis._weightedSpeed = 1.0;\n\t\tthis._weight = 1.0;\n\t\tthis._animTrack = null;\n\t}\n\tget parent() {\n\t\treturn this._parent;\n\t}\n\tget name() {\n\t\treturn this._name;\n\t}\n\tget path() {\n\t\treturn this._parent ? this._parent.path + '.' + this._name : this._name;\n\t}\n\tget point() {\n\t\treturn this._point;\n\t}\n\tget pointLength() {\n\t\treturn this._pointLength;\n\t}\n\tset weight(value) {\n\t\tthis._weight = value;\n\t}\n\tget weight() {\n\t\treturn this._parent ? this._parent.weight * this._weight : this._weight;\n\t}\n\tget normalizedWeight() {\n\t\tconst totalWeight = this._state.totalWeight;\n\t\tif (totalWeight === 0.0) return 0.0;\n\t\treturn this.weight / totalWeight;\n\t}\n\tget speed() {\n\t\treturn this._weightedSpeed * this._speed;\n\t}\n\tget absoluteSpeed() {\n\t\treturn Math.abs(this._speed);\n\t}\n\tset weightedSpeed(weightedSpeed) {\n\t\tthis._weightedSpeed = weightedSpeed;\n\t}\n\tget weightedSpeed() {\n\t\treturn this._weightedSpeed;\n\t}\n\tset animTrack(value) {\n\t\tthis._animTrack = value;\n\t}\n\tget animTrack() {\n\t\treturn this._animTrack;\n\t}\n}\n\nexport { AnimNode };\n", "import { AnimNode } from './anim-node.js';\n\nclass AnimBlendTree extends AnimNode {\n\tconstructor(state, parent, name, point, parameters, children, syncAnimations, createTree, findParameter) {\n\t\tsuper(state, parent, name, point);\n\t\tthis._parameters = parameters;\n\t\tthis._parameterValues = new Array(parameters.length);\n\t\tthis._children = [];\n\t\tthis._findParameter = findParameter;\n\t\tthis._syncAnimations = syncAnimations !== false;\n\t\tthis._pointCache = {};\n\t\tfor (let i = 0; i < children.length; i++) {\n\t\t\tconst child = children[i];\n\t\t\tif (child.children) {\n\t\t\t\tthis._children.push(createTree(child.type, state, this, child.name, 1.0, child.parameter ? [child.parameter] : child.parameters, child.children, child.syncAnimations, createTree, findParameter));\n\t\t\t} else {\n\t\t\t\tthis._children.push(new AnimNode(state, this, child.name, child.point, child.speed));\n\t\t\t}\n\t\t}\n\t}\n\tget weight() {\n\t\tthis.calculateWeights();\n\t\treturn this._parent ? this._parent.weight * this._weight : this._weight;\n\t}\n\tget syncAnimations() {\n\t\treturn this._syncAnimations;\n\t}\n\tgetChild(name) {\n\t\tfor (let i = 0; i < this._children.length; i++) {\n\t\t\tif (this._children[i].name === name) return this._children[i];\n\t\t}\n\t\treturn null;\n\t}\n\tupdateParameterValues() {\n\t\tlet paramsEqual = true;\n\t\tfor (let i = 0; i < this._parameterValues.length; i++) {\n\t\t\tconst updatedParameter = this._findParameter(this._parameters[i]).value;\n\t\t\tif (this._parameterValues[i] !== updatedParameter) {\n\t\t\t\tthis._parameterValues[i] = updatedParameter;\n\t\t\t\tparamsEqual = false;\n\t\t\t}\n\t\t}\n\t\treturn paramsEqual;\n\t}\n\tgetNodeWeightedDuration(i) {\n\t\treturn this._children[i].animTrack.duration / this._children[i].speedMultiplier * this._children[i].weight;\n\t}\n\tgetNodeCount() {\n\t\tlet count = 0;\n\t\tfor (let i = 0; i < this._children.length; i++) {\n\t\t\tconst child = this._children[i];\n\t\t\tif (child.constructor === AnimBlendTree) {\n\t\t\t\tcount += this._children[i].getNodeCount();\n\t\t\t} else {\n\t\t\t\tcount++;\n\t\t\t}\n\t\t}\n\t\treturn count;\n\t}\n}\n\nexport { AnimBlendTree };\n", "import { math } from '../../../core/math/math.js';\nimport { AnimBlendTree } from './anim-blend-tree.js';\n\nclass AnimBlendTree1D extends AnimBlendTree {\n\tconstructor(state, parent, name, point, parameters, children, syncAnimations, createTree, findParameter) {\n\t\tchildren.sort((a, b) => a.point - b.point);\n\t\tsuper(state, parent, name, point, parameters, children, syncAnimations, createTree, findParameter);\n\t}\n\tcalculateWeights() {\n\t\tif (this.updateParameterValues()) return;\n\t\tlet weightedDurationSum = 0.0;\n\t\tthis._children[0].weight = 0.0;\n\t\tfor (let i = 0; i < this._children.length; i++) {\n\t\t\tconst c1 = this._children[i];\n\t\t\tif (i !== this._children.length - 1) {\n\t\t\t\tconst c2 = this._children[i + 1];\n\t\t\t\tif (c1.point === c2.point) {\n\t\t\t\t\tc1.weight = 0.5;\n\t\t\t\t\tc2.weight = 0.5;\n\t\t\t\t} else if (math.between(this._parameterValues[0], c1.point, c2.point, true)) {\n\t\t\t\t\tconst child2Distance = Math.abs(c1.point - c2.point);\n\t\t\t\t\tconst parameterDistance = Math.abs(c1.point - this._parameterValues[0]);\n\t\t\t\t\tconst weight = (child2Distance - parameterDistance) / child2Distance;\n\t\t\t\t\tc1.weight = weight;\n\t\t\t\t\tc2.weight = 1.0 - weight;\n\t\t\t\t} else {\n\t\t\t\t\tc2.weight = 0.0;\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (this._syncAnimations) {\n\t\t\t\tweightedDurationSum += c1.animTrack.duration / c1.absoluteSpeed * c1.weight;\n\t\t\t}\n\t\t}\n\t\tif (this._syncAnimations) {\n\t\t\tfor (let i = 0; i < this._children.length; i++) {\n\t\t\t\tconst child = this._children[i];\n\t\t\t\tchild.weightedSpeed = child.animTrack.duration / child.absoluteSpeed / weightedDurationSum;\n\t\t\t}\n\t\t}\n\t}\n}\n\nexport { AnimBlendTree1D };\n", "import { Vec2 } from '../../../core/math/vec2.js';\nimport { math } from '../../../core/math/math.js';\nimport { AnimBlendTree } from './anim-blend-tree.js';\n\nclass AnimBlendTreeCartesian2D extends AnimBlendTree {\n\tpointDistanceCache(i, j) {\n\t\tconst pointKey = `${i}${j}`;\n\t\tif (!this._pointCache[pointKey]) {\n\t\t\tthis._pointCache[pointKey] = this._children[j].point.clone().sub(this._children[i].point);\n\t\t}\n\t\treturn this._pointCache[pointKey];\n\t}\n\tcalculateWeights() {\n\t\tif (this.updateParameterValues()) return;\n\t\tlet weightSum, weightedDurationSum;\n\t\tAnimBlendTreeCartesian2D._p.set(...this._parameterValues);\n\t\tweightSum = 0.0;\n\t\tweightedDurationSum = 0.0;\n\t\tfor (let i = 0; i < this._children.length; i++) {\n\t\t\tconst child = this._children[i];\n\t\t\tconst pi = child.point;\n\t\t\tAnimBlendTreeCartesian2D._pip.set(AnimBlendTreeCartesian2D._p.x, AnimBlendTreeCartesian2D._p.y).sub(pi);\n\t\t\tlet minj = Number.MAX_VALUE;\n\t\t\tfor (let j = 0; j < this._children.length; j++) {\n\t\t\t\tif (i === j) continue;\n\t\t\t\tconst pipj = this.pointDistanceCache(i, j);\n\t\t\t\tconst result = math.clamp(1.0 - AnimBlendTreeCartesian2D._pip.dot(pipj) / pipj.lengthSq(), 0.0, 1.0);\n\t\t\t\tif (result < minj) minj = result;\n\t\t\t}\n\t\t\tchild.weight = minj;\n\t\t\tweightSum += minj;\n\t\t\tif (this._syncAnimations) {\n\t\t\t\tweightedDurationSum += child.animTrack.duration / child.absoluteSpeed * child.weight;\n\t\t\t}\n\t\t}\n\t\tfor (let i = 0; i < this._children.length; i++) {\n\t\t\tconst child = this._children[i];\n\t\t\tchild.weight = child._weight / weightSum;\n\t\t\tif (this._syncAnimations) {\n\t\t\t\tchild.weightedSpeed = child.animTrack.duration / child.absoluteSpeed / weightedDurationSum;\n\t\t\t}\n\t\t}\n\t}\n}\nAnimBlendTreeCartesian2D._p = new Vec2();\nAnimBlendTreeCartesian2D._pip = new Vec2();\n\nexport { AnimBlendTreeCartesian2D };\n", "import { Vec2 } from '../../../core/math/vec2.js';\nimport { math } from '../../../core/math/math.js';\nimport { AnimBlendTree } from './anim-blend-tree.js';\n\nclass AnimBlendTreeDirectional2D extends AnimBlendTree {\n\tpointCache(i, j) {\n\t\tconst pointKey = `${i}${j}`;\n\t\tif (!this._pointCache[pointKey]) {\n\t\t\tthis._pointCache[pointKey] = new Vec2((this._children[j].pointLength - this._children[i].pointLength) / ((this._children[j].pointLength + this._children[i].pointLength) / 2), Vec2.angleRad(this._children[i].point, this._children[j].point) * 2.0);\n\t\t}\n\t\treturn this._pointCache[pointKey];\n\t}\n\tcalculateWeights() {\n\t\tif (this.updateParameterValues()) return;\n\t\tlet weightSum, weightedDurationSum;\n\t\tAnimBlendTreeDirectional2D._p.set(...this._parameterValues);\n\t\tconst pLength = AnimBlendTreeDirectional2D._p.length();\n\t\tweightSum = 0.0;\n\t\tweightedDurationSum = 0.0;\n\t\tfor (let i = 0; i < this._children.length; i++) {\n\t\t\tconst child = this._children[i];\n\t\t\tconst pi = child.point;\n\t\t\tconst piLength = child.pointLength;\n\t\t\tlet minj = Number.MAX_VALUE;\n\t\t\tfor (let j = 0; j < this._children.length; j++) {\n\t\t\t\tif (i === j) continue;\n\t\t\t\tconst pipj = this.pointCache(i, j);\n\t\t\t\tconst pjLength = this._children[j].pointLength;\n\t\t\t\tAnimBlendTreeDirectional2D._pip.set((pLength - piLength) / ((pjLength + piLength) / 2), Vec2.angleRad(pi, AnimBlendTreeDirectional2D._p) * 2.0);\n\t\t\t\tconst result = math.clamp(1.0 - Math.abs(AnimBlendTreeDirectional2D._pip.dot(pipj) / pipj.lengthSq()), 0.0, 1.0);\n\t\t\t\tif (result < minj) minj = result;\n\t\t\t}\n\t\t\tchild.weight = minj;\n\t\t\tweightSum += minj;\n\t\t\tif (this._syncAnimations) {\n\t\t\t\tweightedDurationSum += child.animTrack.duration / child.absoluteSpeed * child.weight;\n\t\t\t}\n\t\t}\n\t\tfor (let i = 0; i < this._children.length; i++) {\n\t\t\tconst child = this._children[i];\n\t\t\tchild.weight = child._weight / weightSum;\n\t\t\tif (this._syncAnimations) {\n\t\t\t\tconst weightedChildDuration = child.animTrack.duration / weightedDurationSum * weightSum;\n\t\t\t\tchild.weightedSpeed = child.absoluteSpeed * weightedChildDuration;\n\t\t\t}\n\t\t}\n\t}\n}\nAnimBlendTreeDirectional2D._p = new Vec2();\nAnimBlendTreeDirectional2D._pip = new Vec2();\n\nexport { AnimBlendTreeDirectional2D };\n", "import { AnimBlendTree } from './anim-blend-tree.js';\n\nclass AnimBlendTreeDirect extends AnimBlendTree {\n\tcalculateWeights() {\n\t\tif (this.updateParameterValues()) return;\n\t\tlet weightSum = 0.0;\n\t\tlet weightedDurationSum = 0.0;\n\t\tfor (let i = 0; i < this._children.length; i++) {\n\t\t\tweightSum += Math.max(this._parameterValues[i], 0.0);\n\t\t\tif (this._syncAnimations) {\n\t\t\t\tconst child = this._children[i];\n\t\t\t\tweightedDurationSum += child.animTrack.duration / child.absoluteSpeed * child.weight;\n\t\t\t}\n\t\t}\n\t\tfor (let i = 0; i < this._children.length; i++) {\n\t\t\tconst child = this._children[i];\n\t\t\tconst weight = Math.max(this._parameterValues[i], 0.0);\n\t\t\tif (weightSum) {\n\t\t\t\tchild.weight = weight / weightSum;\n\t\t\t\tif (this._syncAnimations) {\n\t\t\t\t\tchild.weightedSpeed = child.animTrack.duration / child.absoluteSpeed / weightedDurationSum;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tchild.weight = 0.0;\n\t\t\t\tif (this._syncAnimations) {\n\t\t\t\t\tchild.weightedSpeed = 0;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n\nexport { AnimBlendTreeDirect };\n", "import { AnimTrack } from '../evaluator/anim-track.js';\nimport { AnimBlendTree1D } from './anim-blend-tree-1d.js';\nimport { AnimBlendTreeCartesian2D } from './anim-blend-tree-2d-cartesian.js';\nimport { AnimBlendTreeDirectional2D } from './anim-blend-tree-2d-directional.js';\nimport { AnimBlendTreeDirect } from './anim-blend-tree-direct.js';\nimport { AnimNode } from './anim-node.js';\nimport { ANIM_BLEND_DIRECT, ANIM_BLEND_2D_DIRECTIONAL, ANIM_BLEND_2D_CARTESIAN, ANIM_BLEND_1D, ANIM_CONTROL_STATES } from './constants.js';\n\nclass AnimState {\n\tconstructor(controller, name, speed = 1, loop = true, blendTree) {\n\t\tthis._animations = {};\n\t\tthis._animationList = [];\n\t\tthis._controller = controller;\n\t\tthis._name = name;\n\t\tthis._speed = speed;\n\t\tthis._loop = loop;\n\t\tthis._hasAnimations = false;\n\t\tif (blendTree) {\n\t\t\tthis._blendTree = this._createTree(blendTree.type, this, null, name, 1.0, blendTree.parameter ? [blendTree.parameter] : blendTree.parameters, blendTree.children, blendTree.syncAnimations, this._createTree, this._controller.findParameter);\n\t\t} else {\n\t\t\tthis._blendTree = new AnimNode(this, null, name, 1.0, speed);\n\t\t}\n\t}\n\t_createTree(type, state, parent, name, point, parameters, children, syncAnimations, createTree, findParameter) {\n\t\tswitch (type) {\n\t\t\tcase ANIM_BLEND_1D:\n\t\t\t\treturn new AnimBlendTree1D(state, parent, name, point, parameters, children, syncAnimations, createTree, findParameter);\n\t\t\tcase ANIM_BLEND_2D_CARTESIAN:\n\t\t\t\treturn new AnimBlendTreeCartesian2D(state, parent, name, point, parameters, children, syncAnimations, createTree, findParameter);\n\t\t\tcase ANIM_BLEND_2D_DIRECTIONAL:\n\t\t\t\treturn new AnimBlendTreeDirectional2D(state, parent, name, point, parameters, children, syncAnimations, createTree, findParameter);\n\t\t\tcase ANIM_BLEND_DIRECT:\n\t\t\t\treturn new AnimBlendTreeDirect(state, parent, name, point, parameters, children, syncAnimations, createTree, findParameter);\n\t\t}\n\t\treturn undefined;\n\t}\n\t_getNodeFromPath(path) {\n\t\tlet currNode = this._blendTree;\n\t\tfor (let i = 1; i < path.length; i++) {\n\t\t\tcurrNode = currNode.getChild(path[i]);\n\t\t}\n\t\treturn currNode;\n\t}\n\taddAnimation(path, animTrack) {\n\t\tconst pathString = path.join('.');\n\t\tconst indexOfAnimation = this._animationList.findIndex(function (animation) {\n\t\t\treturn animation.path === pathString;\n\t\t});\n\t\tif (indexOfAnimation >= 0) {\n\t\t\tthis._animationList[indexOfAnimation].animTrack = animTrack;\n\t\t} else {\n\t\t\tconst node = this._getNodeFromPath(path);\n\t\t\tnode.animTrack = animTrack;\n\t\t\tthis._animationList.push(node);\n\t\t}\n\t\tthis._updateHasAnimations();\n\t}\n\t_updateHasAnimations() {\n\t\tthis._hasAnimations = this._animationList.length > 0 && this._animationList.every(animation => animation.animTrack && animation.animTrack !== AnimTrack.EMPTY);\n\t}\n\tget name() {\n\t\treturn this._name;\n\t}\n\tset animations(value) {\n\t\tthis._animationList = value;\n\t\tthis._updateHasAnimations();\n\t}\n\tget animations() {\n\t\treturn this._animationList;\n\t}\n\tget hasAnimations() {\n\t\treturn this._hasAnimations;\n\t}\n\tset speed(value) {\n\t\tthis._speed = value;\n\t}\n\tget speed() {\n\t\treturn this._speed;\n\t}\n\tset loop(value) {\n\t\tthis._loop = value;\n\t}\n\tget loop() {\n\t\treturn this._loop;\n\t}\n\tget nodeCount() {\n\t\tif (!this._blendTree || this._blendTree.constructor === AnimNode) return 1;\n\t\treturn this._blendTree.getNodeCount();\n\t}\n\tget playable() {\n\t\treturn ANIM_CONTROL_STATES.indexOf(this.name) !== -1 || this.animations.length === this.nodeCount;\n\t}\n\tget looping() {\n\t\tif (this.animations.length > 0) {\n\t\t\tconst trackClipName = this.name + '.' + this.animations[0].animTrack.name;\n\t\t\tconst trackClip = this._controller.animEvaluator.findClip(trackClipName);\n\t\t\tif (trackClip) {\n\t\t\t\treturn trackClip.loop;\n\t\t\t}\n\t\t}\n\t\treturn false;\n\t}\n\tget totalWeight() {\n\t\tlet sum = 0;\n\t\tfor (let i = 0; i < this.animations.length; i++) {\n\t\t\tsum += this.animations[i].weight;\n\t\t}\n\t\treturn sum;\n\t}\n\tget timelineDuration() {\n\t\tlet duration = 0;\n\t\tfor (let i = 0; i < this.animations.length; i++) {\n\t\t\tconst animation = this.animations[i];\n\t\t\tif (animation.animTrack.duration > duration) {\n\t\t\t\tduration = animation.animTrack.duration;\n\t\t\t}\n\t\t}\n\t\treturn duration;\n\t}\n}\n\nexport { AnimState };\n", "import { ANIM_INTERRUPTION_NONE } from './constants.js';\n\nclass AnimTransition {\n\tconstructor({\n\t\tfrom,\n\t\tto,\n\t\ttime = 0,\n\t\tpriority = 0,\n\t\tconditions = [],\n\t\texitTime = null,\n\t\ttransitionOffset = null,\n\t\tinterruptionSource = ANIM_INTERRUPTION_NONE\n\t}) {\n\t\tthis._from = from;\n\t\tthis._to = to;\n\t\tthis._time = time;\n\t\tthis._priority = priority;\n\t\tthis._conditions = conditions;\n\t\tthis._exitTime = exitTime;\n\t\tthis._transitionOffset = transitionOffset;\n\t\tthis._interruptionSource = interruptionSource;\n\t}\n\tget from() {\n\t\treturn this._from;\n\t}\n\tset to(value) {\n\t\tthis._to = value;\n\t}\n\tget to() {\n\t\treturn this._to;\n\t}\n\tget time() {\n\t\treturn this._time;\n\t}\n\tget priority() {\n\t\treturn this._priority;\n\t}\n\tget conditions() {\n\t\treturn this._conditions;\n\t}\n\tget exitTime() {\n\t\treturn this._exitTime;\n\t}\n\tget transitionOffset() {\n\t\treturn this._transitionOffset;\n\t}\n\tget interruptionSource() {\n\t\treturn this._interruptionSource;\n\t}\n\tget hasExitTime() {\n\t\treturn !!this.exitTime;\n\t}\n}\n\nexport { AnimTransition };\n", "import { extends as _extends } from '../../../../_virtual/_rollupPluginBabelHelpers.js';\nimport { sortPriority } from '../../../core/sort.js';\nimport { AnimClip } from '../evaluator/anim-clip.js';\nimport { AnimState } from './anim-state.js';\nimport { AnimNode } from './anim-node.js';\nimport { AnimTransition } from './anim-transition.js';\nimport { ANIM_STATE_START, ANIM_INTERRUPTION_NONE, ANIM_STATE_END, ANIM_STATE_ANY, ANIM_NOT_EQUAL_TO, ANIM_EQUAL_TO, ANIM_LESS_THAN_EQUAL_TO, ANIM_GREATER_THAN_EQUAL_TO, ANIM_LESS_THAN, ANIM_GREATER_THAN, ANIM_INTERRUPTION_NEXT_PREV, ANIM_INTERRUPTION_PREV_NEXT, ANIM_INTERRUPTION_NEXT, ANIM_INTERRUPTION_PREV, ANIM_PARAMETER_TRIGGER, ANIM_CONTROL_STATES } from './constants.js';\n\nclass AnimController {\n\tconstructor(animEvaluator, states, transitions, activate, eventHandler, findParameter, consumeTrigger) {\n\t\tthis._states = {};\n\t\tthis._stateNames = [];\n\t\tthis._findTransitionsFromStateCache = {};\n\t\tthis._findTransitionsBetweenStatesCache = {};\n\t\tthis._previousStateName = null;\n\t\tthis._activeStateName = ANIM_STATE_START;\n\t\tthis._activeStateDuration = 0;\n\t\tthis._activeStateDurationDirty = true;\n\t\tthis._playing = false;\n\t\tthis._activate = void 0;\n\t\tthis._transitions = void 0;\n\t\tthis._currTransitionTime = 1;\n\t\tthis._totalTransitionTime = 1;\n\t\tthis._isTransitioning = false;\n\t\tthis._transitionInterruptionSource = ANIM_INTERRUPTION_NONE;\n\t\tthis._transitionPreviousStates = [];\n\t\tthis._timeInState = 0;\n\t\tthis._timeInStateBefore = 0;\n\t\tthis.findParameter = name => {\n\t\t\treturn this._findParameter(name);\n\t\t};\n\t\tthis._animEvaluator = animEvaluator;\n\t\tthis._eventHandler = eventHandler;\n\t\tthis._findParameter = findParameter;\n\t\tthis._consumeTrigger = consumeTrigger;\n\t\tfor (let i = 0; i < states.length; i++) {\n\t\t\tthis._states[states[i].name] = new AnimState(this, states[i].name, states[i].speed, states[i].loop, states[i].blendTree);\n\t\t\tthis._stateNames.push(states[i].name);\n\t\t}\n\t\tthis._transitions = transitions.map(transition => {\n\t\t\treturn new AnimTransition(_extends({}, transition));\n\t\t});\n\t\tthis._activate = activate;\n\t}\n\tget animEvaluator() {\n\t\treturn this._animEvaluator;\n\t}\n\tset activeState(stateName) {\n\t\tthis._activeStateName = stateName;\n\t}\n\tget activeState() {\n\t\treturn this._findState(this._activeStateName);\n\t}\n\tget activeStateName() {\n\t\treturn this._activeStateName;\n\t}\n\tget activeStateAnimations() {\n\t\treturn this.activeState.animations;\n\t}\n\tset previousState(stateName) {\n\t\tthis._previousStateName = stateName;\n\t}\n\tget previousState() {\n\t\treturn this._findState(this._previousStateName);\n\t}\n\tget previousStateName() {\n\t\treturn this._previousStateName;\n\t}\n\tget playable() {\n\t\tlet playable = true;\n\t\tfor (let i = 0; i < this._stateNames.length; i++) {\n\t\t\tif (!this._states[this._stateNames[i]].playable) {\n\t\t\t\tplayable = false;\n\t\t\t}\n\t\t}\n\t\treturn playable;\n\t}\n\tset playing(value) {\n\t\tthis._playing = value;\n\t}\n\tget playing() {\n\t\treturn this._playing;\n\t}\n\tget activeStateProgress() {\n\t\treturn this._getActiveStateProgressForTime(this._timeInState);\n\t}\n\tget activeStateDuration() {\n\t\tif (this._activeStateDurationDirty) {\n\t\t\tlet maxDuration = 0.0;\n\t\t\tfor (let i = 0; i < this.activeStateAnimations.length; i++) {\n\t\t\t\tconst activeClip = this._animEvaluator.findClip(this.activeStateAnimations[i].name);\n\t\t\t\tif (activeClip) {\n\t\t\t\t\tmaxDuration = Math.max(maxDuration, activeClip.track.duration);\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis._activeStateDuration = maxDuration;\n\t\t\tthis._activeStateDurationDirty = false;\n\t\t}\n\t\treturn this._activeStateDuration;\n\t}\n\tset activeStateCurrentTime(time) {\n\t\tthis._timeInStateBefore = time;\n\t\tthis._timeInState = time;\n\t\tfor (let i = 0; i < this.activeStateAnimations.length; i++) {\n\t\t\tconst clip = this.animEvaluator.findClip(this.activeStateAnimations[i].name);\n\t\t\tif (clip) {\n\t\t\t\tclip.time = time;\n\t\t\t}\n\t\t}\n\t}\n\tget activeStateCurrentTime() {\n\t\treturn this._timeInState;\n\t}\n\tget transitioning() {\n\t\treturn this._isTransitioning;\n\t}\n\tget transitionProgress() {\n\t\treturn this._currTransitionTime / this._totalTransitionTime;\n\t}\n\tget states() {\n\t\treturn this._stateNames;\n\t}\n\tassignMask(mask) {\n\t\treturn this._animEvaluator.assignMask(mask);\n\t}\n\t_findState(stateName) {\n\t\treturn this._states[stateName];\n\t}\n\t_getActiveStateProgressForTime(time) {\n\t\tif (this.activeStateName === ANIM_STATE_START || this.activeStateName === ANIM_STATE_END || this.activeStateName === ANIM_STATE_ANY) return 1.0;\n\t\tconst activeClip = this._animEvaluator.findClip(this.activeStateAnimations[0].name);\n\t\tif (activeClip) {\n\t\t\treturn activeClip.progressForTime(time);\n\t\t}\n\t\treturn null;\n\t}\n\t_findTransitionsFromState(stateName) {\n\t\tlet transitions = this._findTransitionsFromStateCache[stateName];\n\t\tif (!transitions) {\n\t\t\ttransitions = this._transitions.filter(function (transition) {\n\t\t\t\treturn transition.from === stateName;\n\t\t\t});\n\t\t\tsortPriority(transitions);\n\t\t\tthis._findTransitionsFromStateCache[stateName] = transitions;\n\t\t}\n\t\treturn transitions;\n\t}\n\t_findTransitionsBetweenStates(sourceStateName, destinationStateName) {\n\t\tlet transitions = this._findTransitionsBetweenStatesCache[sourceStateName + '->' + destinationStateName];\n\t\tif (!transitions) {\n\t\t\ttransitions = this._transitions.filter(function (transition) {\n\t\t\t\treturn transition.from === sourceStateName && transition.to === destinationStateName;\n\t\t\t});\n\t\t\tsortPriority(transitions);\n\t\t\tthis._findTransitionsBetweenStatesCache[sourceStateName + '->' + destinationStateName] = transitions;\n\t\t}\n\t\treturn transitions;\n\t}\n\t_transitionHasConditionsMet(transition) {\n\t\tconst conditions = transition.conditions;\n\t\tfor (let i = 0; i < conditions.length; i++) {\n\t\t\tconst condition = conditions[i];\n\t\t\tconst parameter = this._findParameter(condition.parameterName);\n\t\t\tswitch (condition.predicate) {\n\t\t\t\tcase ANIM_GREATER_THAN:\n\t\t\t\t\tif (!(parameter.value > condition.value)) return false;\n\t\t\t\t\tbreak;\n\t\t\t\tcase ANIM_LESS_THAN:\n\t\t\t\t\tif (!(parameter.value < condition.value)) return false;\n\t\t\t\t\tbreak;\n\t\t\t\tcase ANIM_GREATER_THAN_EQUAL_TO:\n\t\t\t\t\tif (!(parameter.value >= condition.value)) return false;\n\t\t\t\t\tbreak;\n\t\t\t\tcase ANIM_LESS_THAN_EQUAL_TO:\n\t\t\t\t\tif (!(parameter.value <= condition.value)) return false;\n\t\t\t\t\tbreak;\n\t\t\t\tcase ANIM_EQUAL_TO:\n\t\t\t\t\tif (!(parameter.value === condition.value)) return false;\n\t\t\t\t\tbreak;\n\t\t\t\tcase ANIM_NOT_EQUAL_TO:\n\t\t\t\t\tif (!(parameter.value !== condition.value)) return false;\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\treturn true;\n\t}\n\t_findTransition(from, to) {\n\t\tlet transitions = [];\n\t\tif (from && to) {\n\t\t\ttransitions = transitions.concat(this._findTransitionsBetweenStates(from, to));\n\t\t} else {\n\t\t\tif (!this._isTransitioning) {\n\t\t\t\ttransitions = transitions.concat(this._findTransitionsFromState(this._activeStateName));\n\t\t\t\ttransitions = transitions.concat(this._findTransitionsFromState(ANIM_STATE_ANY));\n\t\t\t} else {\n\t\t\t\tswitch (this._transitionInterruptionSource) {\n\t\t\t\t\tcase ANIM_INTERRUPTION_PREV:\n\t\t\t\t\t\ttransitions = transitions.concat(this._findTransitionsFromState(this._previousStateName));\n\t\t\t\t\t\ttransitions = transitions.concat(this._findTransitionsFromState(ANIM_STATE_ANY));\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase ANIM_INTERRUPTION_NEXT:\n\t\t\t\t\t\ttransitions = transitions.concat(this._findTransitionsFromState(this._activeStateName));\n\t\t\t\t\t\ttransitions = transitions.concat(this._findTransitionsFromState(ANIM_STATE_ANY));\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase ANIM_INTERRUPTION_PREV_NEXT:\n\t\t\t\t\t\ttransitions = transitions.concat(this._findTransitionsFromState(this._previousStateName));\n\t\t\t\t\t\ttransitions = transitions.concat(this._findTransitionsFromState(this._activeStateName));\n\t\t\t\t\t\ttransitions = transitions.concat(this._findTransitionsFromState(ANIM_STATE_ANY));\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase ANIM_INTERRUPTION_NEXT_PREV:\n\t\t\t\t\t\ttransitions = transitions.concat(this._findTransitionsFromState(this._activeStateName));\n\t\t\t\t\t\ttransitions = transitions.concat(this._findTransitionsFromState(this._previousStateName));\n\t\t\t\t\t\ttransitions = transitions.concat(this._findTransitionsFromState(ANIM_STATE_ANY));\n\t\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\ttransitions = transitions.filter(transition => {\n\t\t\tif (transition.to === this.activeStateName) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t\tif (transition.hasExitTime) {\n\t\t\t\tlet progressBefore = this._getActiveStateProgressForTime(this._timeInStateBefore);\n\t\t\t\tlet progress = this._getActiveStateProgressForTime(this._timeInState);\n\t\t\t\tif (transition.exitTime < 1.0 && this.activeState.loop) {\n\t\t\t\t\tprogressBefore -= Math.floor(progressBefore);\n\t\t\t\t\tprogress -= Math.floor(progress);\n\t\t\t\t}\n\t\t\t\tif (progress === progressBefore) {\n\t\t\t\t\tif (progress !== transition.exitTime) {\n\t\t\t\t\t\treturn null;\n\t\t\t\t\t}\n\t\t\t\t} else if (!(transition.exitTime > progressBefore && transition.exitTime <= progress)) {\n\t\t\t\t\treturn null;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn this._transitionHasConditionsMet(transition);\n\t\t});\n\t\tif (transitions.length > 0) {\n\t\t\tconst transition = transitions[0];\n\t\t\tif (transition.to === ANIM_STATE_END) {\n\t\t\t\tconst startTransition = this._findTransitionsFromState(ANIM_STATE_START)[0];\n\t\t\t\ttransition.to = startTransition.to;\n\t\t\t}\n\t\t\treturn transition;\n\t\t}\n\t\treturn null;\n\t}\n\tupdateStateFromTransition(transition) {\n\t\tlet state;\n\t\tlet animation;\n\t\tlet clip;\n\t\tthis.previousState = transition.from ? this.activeStateName : null;\n\t\tthis.activeState = transition.to;\n\t\tthis._activeStateDurationDirty = true;\n\t\tfor (let i = 0; i < transition.conditions.length; i++) {\n\t\t\tconst condition = transition.conditions[i];\n\t\t\tconst parameter = this._findParameter(condition.parameterName);\n\t\t\tif (parameter.type === ANIM_PARAMETER_TRIGGER) {\n\t\t\t\tthis._consumeTrigger(condition.parameterName);\n\t\t\t}\n\t\t}\n\t\tif (this.previousState) {\n\t\t\tif (!this._isTransitioning) {\n\t\t\t\tthis._transitionPreviousStates = [];\n\t\t\t}\n\t\t\tthis._transitionPreviousStates.push({\n\t\t\t\tname: this._previousStateName,\n\t\t\t\tweight: 1\n\t\t\t});\n\t\t\tconst interpolatedTime = Math.min(this._totalTransitionTime !== 0 ? this._currTransitionTime / this._totalTransitionTime : 1, 1.0);\n\t\t\tfor (let i = 0; i < this._transitionPreviousStates.length; i++) {\n\t\t\t\tif (!this._isTransitioning) {\n\t\t\t\t\tthis._transitionPreviousStates[i].weight = 1.0;\n\t\t\t\t} else if (i !== this._transitionPreviousStates.length - 1) {\n\t\t\t\t\tthis._transitionPreviousStates[i].weight *= 1.0 - interpolatedTime;\n\t\t\t\t} else {\n\t\t\t\t\tthis._transitionPreviousStates[i].weight = interpolatedTime;\n\t\t\t\t}\n\t\t\t\tstate = this._findState(this._transitionPreviousStates[i].name);\n\t\t\t\tfor (let j = 0; j < state.animations.length; j++) {\n\t\t\t\t\tanimation = state.animations[j];\n\t\t\t\t\tclip = this._animEvaluator.findClip(animation.name + '.previous.' + i);\n\t\t\t\t\tif (!clip) {\n\t\t\t\t\t\tclip = this._animEvaluator.findClip(animation.name);\n\t\t\t\t\t\tclip.name = animation.name + '.previous.' + i;\n\t\t\t\t\t}\n\t\t\t\t\tif (i !== this._transitionPreviousStates.length - 1) {\n\t\t\t\t\t\tclip.pause();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tthis._isTransitioning = true;\n\t\tthis._totalTransitionTime = transition.time;\n\t\tthis._currTransitionTime = 0;\n\t\tthis._transitionInterruptionSource = transition.interruptionSource;\n\t\tconst activeState = this.activeState;\n\t\tconst hasTransitionOffset = transition.transitionOffset && transition.transitionOffset > 0.0 && transition.transitionOffset < 1.0;\n\t\tlet timeInState = 0;\n\t\tlet timeInStateBefore = 0;\n\t\tif (hasTransitionOffset) {\n\t\t\tconst offsetTime = activeState.timelineDuration * transition.transitionOffset;\n\t\t\ttimeInState = offsetTime;\n\t\t\ttimeInStateBefore = offsetTime;\n\t\t}\n\t\tthis._timeInState = timeInState;\n\t\tthis._timeInStateBefore = timeInStateBefore;\n\t\tfor (let i = 0; i < activeState.animations.length; i++) {\n\t\t\tclip = this._animEvaluator.findClip(activeState.animations[i].name);\n\t\t\tif (!clip) {\n\t\t\t\tconst speed = Number.isFinite(activeState.animations[i].speed) ? activeState.animations[i].speed : activeState.speed;\n\t\t\t\tclip = new AnimClip(activeState.animations[i].animTrack, this._timeInState, speed, true, activeState.loop, this._eventHandler);\n\t\t\t\tclip.name = activeState.animations[i].name;\n\t\t\t\tthis._animEvaluator.addClip(clip);\n\t\t\t} else {\n\t\t\t\tclip.reset();\n\t\t\t}\n\t\t\tif (transition.time > 0) {\n\t\t\t\tclip.blendWeight = 0.0;\n\t\t\t} else {\n\t\t\t\tclip.blendWeight = activeState.animations[i].normalizedWeight;\n\t\t\t}\n\t\t\tclip.play();\n\t\t\tif (hasTransitionOffset) {\n\t\t\t\tclip.time = activeState.timelineDuration * transition.transitionOffset;\n\t\t\t} else {\n\t\t\t\tconst startTime = activeState.speed >= 0 ? 0 : this.activeStateDuration;\n\t\t\t\tclip.time = startTime;\n\t\t\t}\n\t\t}\n\t}\n\t_transitionToState(newStateName) {\n\t\tif (!this._findState(newStateName)) {\n\t\t\treturn;\n\t\t}\n\t\tlet transition = this._findTransition(this._activeStateName, newStateName);\n\t\tif (!transition) {\n\t\t\tthis._animEvaluator.removeClips();\n\t\t\ttransition = new AnimTransition({\n\t\t\t\tfrom: null,\n\t\t\t\tto: newStateName\n\t\t\t});\n\t\t}\n\t\tthis.updateStateFromTransition(transition);\n\t}\n\tassignAnimation(pathString, animTrack, speed, loop) {\n\t\tconst path = pathString.split('.');\n\t\tlet state = this._findState(path[0]);\n\t\tif (!state) {\n\t\t\tstate = new AnimState(this, path[0], speed);\n\t\t\tthis._states[path[0]] = state;\n\t\t\tthis._stateNames.push(path[0]);\n\t\t}\n\t\tstate.addAnimation(path, animTrack);\n\t\tthis._animEvaluator.updateClipTrack(state.name, animTrack);\n\t\tif (speed !== undefined) {\n\t\t\tstate.speed = speed;\n\t\t}\n\t\tif (loop !== undefined) {\n\t\t\tstate.loop = loop;\n\t\t}\n\t\tif (!this._playing && this._activate && this.playable) {\n\t\t\tthis.play();\n\t\t}\n\t\tthis._activeStateDurationDirty = true;\n\t}\n\tremoveNodeAnimations(nodeName) {\n\t\tif (ANIM_CONTROL_STATES.indexOf(nodeName) !== -1) {\n\t\t\treturn false;\n\t\t}\n\t\tconst state = this._findState(nodeName);\n\t\tif (!state) {\n\t\t\treturn false;\n\t\t}\n\t\tstate.animations = [];\n\t\treturn true;\n\t}\n\tplay(stateName) {\n\t\tif (stateName) {\n\t\t\tthis._transitionToState(stateName);\n\t\t}\n\t\tthis._playing = true;\n\t}\n\tpause() {\n\t\tthis._playing = false;\n\t}\n\treset() {\n\t\tthis._previousStateName = null;\n\t\tthis._activeStateName = ANIM_STATE_START;\n\t\tthis._playing = false;\n\t\tthis._currTransitionTime = 1.0;\n\t\tthis._totalTransitionTime = 1.0;\n\t\tthis._isTransitioning = false;\n\t\tthis._timeInState = 0;\n\t\tthis._timeInStateBefore = 0;\n\t\tthis._animEvaluator.removeClips();\n\t}\n\trebind() {\n\t\tthis._animEvaluator.rebind();\n\t}\n\tupdate(dt) {\n\t\tif (!this._playing) {\n\t\t\treturn;\n\t\t}\n\t\tlet state;\n\t\tlet animation;\n\t\tlet clip;\n\t\tif (this.activeState.loop || this._timeInState < this.activeStateDuration) {\n\t\t\tthis._timeInStateBefore = this._timeInState;\n\t\t\tthis._timeInState += dt * this.activeState.speed;\n\t\t\tif (!this.activeState.loop && this._timeInState > this.activeStateDuration) {\n\t\t\t\tthis._timeInState = this.activeStateDuration;\n\t\t\t\tdt = this.activeStateDuration - this._timeInStateBefore;\n\t\t\t}\n\t\t}\n\t\tconst transition = this._findTransition(this._activeStateName);\n\t\tif (transition) this.updateStateFromTransition(transition);\n\t\tif (this._isTransitioning) {\n\t\t\tthis._currTransitionTime += dt;\n\t\t\tif (this._currTransitionTime <= this._totalTransitionTime) {\n\t\t\t\tconst interpolatedTime = this._totalTransitionTime !== 0 ? this._currTransitionTime / this._totalTransitionTime : 1;\n\t\t\t\tfor (let i = 0; i < this._transitionPreviousStates.length; i++) {\n\t\t\t\t\tstate = this._findState(this._transitionPreviousStates[i].name);\n\t\t\t\t\tconst stateWeight = this._transitionPreviousStates[i].weight;\n\t\t\t\t\tfor (let j = 0; j < state.animations.length; j++) {\n\t\t\t\t\t\tanimation = state.animations[j];\n\t\t\t\t\t\tclip = this._animEvaluator.findClip(animation.name + '.previous.' + i);\n\t\t\t\t\t\tif (clip) {\n\t\t\t\t\t\t\tclip.blendWeight = (1.0 - interpolatedTime) * animation.normalizedWeight * stateWeight;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tstate = this.activeState;\n\t\t\t\tfor (let i = 0; i < state.animations.length; i++) {\n\t\t\t\t\tanimation = state.animations[i];\n\t\t\t\t\tthis._animEvaluator.findClip(animation.name).blendWeight = interpolatedTime * animation.normalizedWeight;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tthis._isTransitioning = false;\n\t\t\t\tconst activeClips = this.activeStateAnimations.length;\n\t\t\t\tconst totalClips = this._animEvaluator.clips.length;\n\t\t\t\tfor (let i = 0; i < totalClips - activeClips; i++) {\n\t\t\t\t\tthis._animEvaluator.removeClip(0);\n\t\t\t\t}\n\t\t\t\tthis._transitionPreviousStates = [];\n\t\t\t\tstate = this.activeState;\n\t\t\t\tfor (let i = 0; i < state.animations.length; i++) {\n\t\t\t\t\tanimation = state.animations[i];\n\t\t\t\t\tclip = this._animEvaluator.findClip(animation.name);\n\t\t\t\t\tif (clip) {\n\t\t\t\t\t\tclip.blendWeight = animation.normalizedWeight;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tif (this.activeState._blendTree.constructor !== AnimNode) {\n\t\t\t\tstate = this.activeState;\n\t\t\t\tfor (let i = 0; i < state.animations.length; i++) {\n\t\t\t\t\tanimation = state.animations[i];\n\t\t\t\t\tclip = this._animEvaluator.findClip(animation.name);\n\t\t\t\t\tif (clip) {\n\t\t\t\t\t\tclip.blendWeight = animation.normalizedWeight;\n\t\t\t\t\t\tif (animation.parent.syncAnimations) {\n\t\t\t\t\t\t\tclip.speed = animation.speed;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tthis._animEvaluator.update(dt, this.activeState.hasAnimations);\n\t}\n}\n\nexport { AnimController };\n", "import { AnimTarget } from '../../anim/evaluator/anim-target.js';\nimport { DefaultAnimBinder } from '../../anim/binder/default-anim-binder.js';\nimport { AnimBinder } from '../../anim/binder/anim-binder.js';\nimport { Color } from '../../../core/math/color.js';\nimport { Quat } from '../../../core/math/quat.js';\nimport { Vec2 } from '../../../core/math/vec2.js';\nimport { Vec3 } from '../../../core/math/vec3.js';\nimport { Vec4 } from '../../../core/math/vec4.js';\n\nconst v2 = new Vec2();\nconst v3 = new Vec3();\nconst v4 = new Vec4();\nconst c = new Color();\nconst q = new Quat();\nclass AnimComponentBinder extends DefaultAnimBinder {\n\tconstructor(animComponent, graph, layerName, mask, layerIndex) {\n\t\tsuper(graph);\n\t\tthis.animComponent = animComponent;\n\t\tthis._mask = mask;\n\t\tthis.layerName = layerName;\n\t\tthis.layerIndex = layerIndex;\n\t}\n\tstatic _packFloat(values) {\n\t\treturn values[0];\n\t}\n\tstatic _packBoolean(values) {\n\t\treturn !!values[0];\n\t}\n\tstatic _packVec2(values) {\n\t\tv2.x = values[0];\n\t\tv2.y = values[1];\n\t\treturn v2;\n\t}\n\tstatic _packVec3(values) {\n\t\tv3.x = values[0];\n\t\tv3.y = values[1];\n\t\tv3.z = values[2];\n\t\treturn v3;\n\t}\n\tstatic _packVec4(values) {\n\t\tv4.x = values[0];\n\t\tv4.y = values[1];\n\t\tv4.z = values[2];\n\t\tv4.w = values[3];\n\t\treturn v4;\n\t}\n\tstatic _packColor(values) {\n\t\tc.r = values[0];\n\t\tc.g = values[1];\n\t\tc.b = values[2];\n\t\tc.a = values[3];\n\t\treturn c;\n\t}\n\tstatic _packQuat(values) {\n\t\tq.x = values[0];\n\t\tq.y = values[1];\n\t\tq.z = values[2];\n\t\tq.w = values[3];\n\t\treturn q;\n\t}\n\tresolve(path) {\n\t\tconst encodedPath = AnimBinder.encode(path.entityPath, path.component, path.propertyPath);\n\t\tlet target = this.targetCache[encodedPath];\n\t\tif (target) return target;\n\t\tlet entity;\n\t\tlet propertyComponent;\n\t\tlet targetPath;\n\t\tswitch (path.component) {\n\t\t\tcase 'entity':\n\t\t\t\tentity = this._getEntityFromHierarchy(path.entityPath);\n\t\t\t\ttargetPath = AnimBinder.encode(entity.path, 'entity', path.propertyPath);\n\t\t\t\tpropertyComponent = entity;\n\t\t\t\tbreak;\n\t\t\tcase 'graph':\n\t\t\t\tpropertyComponent = this.findNode(path);\n\t\t\t\tif (!propertyComponent) return null;\n\t\t\t\ttargetPath = AnimBinder.encode(propertyComponent.path, 'graph', path.propertyPath);\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\tentity = this._getEntityFromHierarchy(path.entityPath);\n\t\t\t\tpropertyComponent = entity.findComponent(path.component);\n\t\t\t\tif (!propertyComponent) return null;\n\t\t\t\ttargetPath = AnimBinder.encode(entity.path, path.component, path.propertyPath);\n\t\t\t\tbreak;\n\t\t}\n\t\ttarget = this._createAnimTargetForProperty(propertyComponent, path.propertyPath, targetPath);\n\t\tthis.targetCache[encodedPath] = target;\n\t\treturn target;\n\t}\n\tupdate(deltaTime) {\n\t\tconst activeNodes = this.activeNodes;\n\t\tif (activeNodes) {\n\t\t\tfor (let i = 0; i < activeNodes.length; i++) {\n\t\t\t\tactiveNodes[i]._dirtifyLocal();\n\t\t\t}\n\t\t}\n\t}\n\t_getEntityFromHierarchy(entityHierarchy) {\n\t\tif (!this.animComponent.entity.name === entityHierarchy[0]) {\n\t\t\treturn null;\n\t\t}\n\t\tconst currEntity = this.animComponent.entity;\n\t\tif (entityHierarchy.length === 1) {\n\t\t\treturn currEntity;\n\t\t}\n\t\treturn currEntity._parent.findByPath(entityHierarchy);\n\t}\n\t_resolvePath(object, path, resolveLeaf) {\n\t\tconst steps = path.length - (resolveLeaf ? 0 : 1);\n\t\tfor (let i = 0; i < steps; i++) {\n\t\t\tobject = object[path[i]];\n\t\t}\n\t\treturn object;\n\t}\n\t_setter(object, path, packFunc) {\n\t\tconst obj = this._resolvePath(object, path);\n\t\tconst key = path[path.length - 1];\n\t\tconst setterFuncName = 'set' + key.substring(0, 1).toUpperCase() + key.substring(1);\n\t\tif (obj[setterFuncName]) {\n\t\t\tconst getterFunc = obj['get' + key.substring(0, 1).toUpperCase() + key.substring(1)].bind(obj);\n\t\t\tlet baseValues = getterFunc();\n\t\t\tbaseValues = [baseValues.x, baseValues.y, baseValues.z, baseValues.w];\n\t\t\tconst setterFunc = obj[setterFuncName].bind(obj);\n\t\t\treturn {\n\t\t\t\tset: values => {\n\t\t\t\t\tsetterFunc(packFunc(values));\n\t\t\t\t},\n\t\t\t\tget: () => baseValues\n\t\t\t};\n\t\t}\n\t\tconst prop = obj[key];\n\t\tif (typeof prop === 'object' && prop.hasOwnProperty('copy')) {\n\t\t\treturn function (values) {\n\t\t\t\tprop.copy(packFunc(values));\n\t\t\t};\n\t\t}\n\t\tif ([Vec2, Vec3, Vec4, Color, Quat].indexOf(obj.constructor) !== -1 && path.length > 1) {\n\t\t\tconst parent = path.length > 2 ? this._resolvePath(object, path.slice(0, -1)) : object;\n\t\t\tconst objKey = path[path.length - 2];\n\t\t\treturn function (values) {\n\t\t\t\tobj[key] = packFunc(values);\n\t\t\t\tparent[objKey] = obj;\n\t\t\t};\n\t\t}\n\t\treturn function (values) {\n\t\t\tobj[key] = packFunc(values);\n\t\t};\n\t}\n\t_createAnimTargetForProperty(propertyComponent, propertyHierarchy, targetPath) {\n\t\tif (this.handlers && propertyHierarchy[0].startsWith('weight.')) {\n\t\t\treturn this.handlers.weight(propertyComponent, propertyHierarchy[0].replace('weight.', ''));\n\t\t} else if (this.handlers && propertyHierarchy[0] === 'material' && propertyHierarchy.length === 2) {\n\t\t\tconst materialPropertyName = propertyHierarchy[1];\n\t\t\tif (materialPropertyName.endsWith('Map')) {\n\t\t\t\treturn this.handlers.materialTexture(propertyComponent, materialPropertyName);\n\t\t\t}\n\t\t}\n\t\tconst property = this._resolvePath(propertyComponent, propertyHierarchy, true);\n\t\tif (typeof property === 'undefined') return null;\n\t\tlet setter;\n\t\tlet animDataType;\n\t\tlet animDataComponents;\n\t\tif (typeof property === 'number') {\n\t\t\tsetter = this._setter(propertyComponent, propertyHierarchy, AnimComponentBinder._packFloat);\n\t\t\tanimDataType = 'vector';\n\t\t\tanimDataComponents = 1;\n\t\t} else if (typeof property === 'boolean') {\n\t\t\tsetter = this._setter(propertyComponent, propertyHierarchy, AnimComponentBinder._packBoolean);\n\t\t\tanimDataType = 'vector';\n\t\t\tanimDataComponents = 1;\n\t\t} else if (typeof property === 'object') {\n\t\t\tswitch (property.constructor) {\n\t\t\t\tcase Vec2:\n\t\t\t\t\tsetter = this._setter(propertyComponent, propertyHierarchy, AnimComponentBinder._packVec2);\n\t\t\t\t\tanimDataType = 'vector';\n\t\t\t\t\tanimDataComponents = 2;\n\t\t\t\t\tbreak;\n\t\t\t\tcase Vec3:\n\t\t\t\t\tsetter = this._setter(propertyComponent, propertyHierarchy, AnimComponentBinder._packVec3);\n\t\t\t\t\tanimDataType = 'vector';\n\t\t\t\t\tanimDataComponents = 3;\n\t\t\t\t\tbreak;\n\t\t\t\tcase Vec4:\n\t\t\t\t\tsetter = this._setter(propertyComponent, propertyHierarchy, AnimComponentBinder._packVec4);\n\t\t\t\t\tanimDataType = 'vector';\n\t\t\t\t\tanimDataComponents = 4;\n\t\t\t\t\tbreak;\n\t\t\t\tcase Color:\n\t\t\t\t\tsetter = this._setter(propertyComponent, propertyHierarchy, AnimComponentBinder._packColor);\n\t\t\t\t\tanimDataType = 'vector';\n\t\t\t\t\tanimDataComponents = 4;\n\t\t\t\t\tbreak;\n\t\t\t\tcase Quat:\n\t\t\t\t\tsetter = this._setter(propertyComponent, propertyHierarchy, AnimComponentBinder._packQuat);\n\t\t\t\t\tanimDataType = 'quaternion';\n\t\t\t\t\tanimDataComponents = 4;\n\t\t\t\t\tbreak;\n\t\t\t\tdefault:\n\t\t\t\t\treturn null;\n\t\t\t}\n\t\t}\n\t\tif (propertyHierarchy.indexOf('material') !== -1) {\n\t\t\treturn new AnimTarget(function (values) {\n\t\t\t\tsetter(values);\n\t\t\t\tpropertyComponent.material.update();\n\t\t\t}, animDataType, animDataComponents, targetPath);\n\t\t}\n\t\treturn new AnimTarget(setter, animDataType, animDataComponents, targetPath);\n\t}\n\trebind() {\n\t\tthis.targetCache = {};\n\t\tif (this.animComponent.rootBone) {\n\t\t\tthis.graph = this.animComponent.rootBone;\n\t\t} else {\n\t\t\tthis.graph = this.animComponent.entity;\n\t\t}\n\t\tconst nodes = {};\n\t\tconst flatten = function flatten(node) {\n\t\t\tnodes[node.name] = node;\n\t\t\tfor (let i = 0; i < node.children.length; ++i) {\n\t\t\t\tflatten(node.children[i]);\n\t\t\t}\n\t\t};\n\t\tflatten(this.graph);\n\t\tthis.nodes = nodes;\n\t}\n}\n\nexport { AnimComponentBinder };\n", "import { math } from '../../../core/math/math.js';\nimport { AnimTrack } from '../../anim/evaluator/anim-track.js';\nimport { AnimTransition } from '../../anim/controller/anim-transition.js';\nimport { ANIM_LAYER_OVERWRITE } from '../../anim/controller/constants.js';\n\nclass AnimComponentLayer {\n\tconstructor(name, controller, component, weight = 1, blendType = ANIM_LAYER_OVERWRITE) {\n\t\tthis._name = void 0;\n\t\tthis._controller = void 0;\n\t\tthis._component = void 0;\n\t\tthis._weight = void 0;\n\t\tthis._blendType = void 0;\n\t\tthis._mask = null;\n\t\tthis._blendTime = 0;\n\t\tthis._blendTimeElapsed = 0;\n\t\tthis._startingWeight = 0;\n\t\tthis._targetWeight = 0;\n\t\tthis._name = name;\n\t\tthis._controller = controller;\n\t\tthis._component = component;\n\t\tthis._weight = weight;\n\t\tthis._blendType = blendType;\n\t}\n\tget name() {\n\t\treturn this._name;\n\t}\n\tset playing(value) {\n\t\tthis._controller.playing = value;\n\t}\n\tget playing() {\n\t\treturn this._controller.playing;\n\t}\n\tget playable() {\n\t\treturn this._controller.playable;\n\t}\n\tget activeState() {\n\t\treturn this._controller.activeStateName;\n\t}\n\tget previousState() {\n\t\treturn this._controller.previousStateName;\n\t}\n\tget activeStateProgress() {\n\t\treturn this._controller.activeStateProgress;\n\t}\n\tget activeStateDuration() {\n\t\treturn this._controller.activeStateDuration;\n\t}\n\tset activeStateCurrentTime(time) {\n\t\tconst controller = this._controller;\n\t\tconst layerPlaying = controller.playing;\n\t\tcontroller.playing = true;\n\t\tcontroller.activeStateCurrentTime = time;\n\t\tif (!layerPlaying) {\n\t\t\tcontroller.update(0);\n\t\t}\n\t\tcontroller.playing = layerPlaying;\n\t}\n\tget activeStateCurrentTime() {\n\t\treturn this._controller.activeStateCurrentTime;\n\t}\n\tget transitioning() {\n\t\treturn this._controller.transitioning;\n\t}\n\tget transitionProgress() {\n\t\tif (this.transitioning) {\n\t\t\treturn this._controller.transitionProgress;\n\t\t}\n\t\treturn null;\n\t}\n\tget states() {\n\t\treturn this._controller.states;\n\t}\n\tset weight(value) {\n\t\tthis._weight = value;\n\t\tthis._component.dirtifyTargets();\n\t}\n\tget weight() {\n\t\treturn this._weight;\n\t}\n\tset blendType(value) {\n\t\tif (value !== this._blendType) {\n\t\t\tthis._blendType = value;\n\t\t\tif (this._controller.normalizeWeights) {\n\t\t\t\tthis._component.rebind();\n\t\t\t}\n\t\t}\n\t}\n\tget blendType() {\n\t\treturn this._blendType;\n\t}\n\tset mask(value) {\n\t\tif (this._controller.assignMask(value)) {\n\t\t\tthis._component.rebind();\n\t\t}\n\t\tthis._mask = value;\n\t}\n\tget mask() {\n\t\treturn this._mask;\n\t}\n\tplay(name) {\n\t\tthis._controller.play(name);\n\t}\n\tpause() {\n\t\tthis._controller.pause();\n\t}\n\treset() {\n\t\tthis._controller.reset();\n\t}\n\trebind() {\n\t\tthis._controller.rebind();\n\t}\n\tupdate(dt) {\n\t\tif (this._blendTime) {\n\t\t\tif (this._blendTimeElapsed < this._blendTime) {\n\t\t\t\tthis.weight = math.lerp(this._startingWeight, this._targetWeight, this._blendTimeElapsed / this._blendTime);\n\t\t\t\tthis._blendTimeElapsed += dt;\n\t\t\t} else {\n\t\t\t\tthis.weight = this._targetWeight;\n\t\t\t\tthis._blendTime = 0;\n\t\t\t\tthis._blendTimeElapsed = 0;\n\t\t\t\tthis._startingWeight = 0;\n\t\t\t\tthis._targetWeight = 0;\n\t\t\t}\n\t\t}\n\t\tthis._controller.update(dt);\n\t}\n\tblendToWeight(weight, time) {\n\t\tthis._startingWeight = this.weight;\n\t\tthis._targetWeight = weight;\n\t\tthis._blendTime = Math.max(0, time);\n\t\tthis._blendTimeElapsed = 0;\n\t}\n\tassignMask(mask) {\n\t\tif (this._controller.assignMask(mask)) {\n\t\t\tthis._component.rebind();\n\t\t}\n\t\tthis._mask = mask;\n\t}\n\tassignAnimation(nodePath, animTrack, speed, loop) {\n\t\tif (!(animTrack instanceof AnimTrack)) {\n\t\t\treturn;\n\t\t}\n\t\tthis._controller.assignAnimation(nodePath, animTrack, speed, loop);\n\t\tif (this._controller._transitions.length === 0) {\n\t\t\tthis._controller._transitions.push(new AnimTransition({\n\t\t\t\tfrom: 'START',\n\t\t\t\tto: nodePath\n\t\t\t}));\n\t\t}\n\t\tif (this._component.activate && this._component.playable) {\n\t\t\tthis._component.playing = true;\n\t\t}\n\t}\n\tremoveNodeAnimations(nodeName) {\n\t\tif (this._controller.removeNodeAnimations(nodeName)) {\n\t\t\tthis._component.playing = false;\n\t\t}\n\t}\n\tgetAnimationAsset(stateName) {\n\t\treturn this._component.animationAssets[`${this.name}:${stateName}`];\n\t}\n\ttransition(to, time = 0, transitionOffset = null) {\n\t\tthis._controller.updateStateFromTransition(new AnimTransition({\n\t\t\tfrom: this._controller.activeStateName,\n\t\t\tto,\n\t\t\ttime,\n\t\t\ttransitionOffset\n\t\t}));\n\t}\n}\n\nexport { AnimComponentLayer };\n", "class AnimStateGraph {\n\tconstructor(data) {\n\t\tthis._layers = [];\n\t\tthis._parameters = {};\n\t\tif (!Array.isArray(data.layers)) {\n\t\t\tfor (const layerId in data.layers) {\n\t\t\t\tconst dataLayer = data.layers[layerId];\n\t\t\t\tconst layer = {\n\t\t\t\t\tname: dataLayer.name,\n\t\t\t\t\tblendType: dataLayer.blendType,\n\t\t\t\t\tweight: dataLayer.weight,\n\t\t\t\t\tstates: [],\n\t\t\t\t\ttransitions: []\n\t\t\t\t};\n\t\t\t\tfor (let i = 0; i < dataLayer.states.length; i++) {\n\t\t\t\t\tlayer.states.push(data.states[dataLayer.states[i]]);\n\t\t\t\t}\n\t\t\t\tfor (let i = 0; i < dataLayer.transitions.length; i++) {\n\t\t\t\t\tconst dataLayerTransition = data.transitions[dataLayer.transitions[i]];\n\t\t\t\t\tif (dataLayerTransition.conditions && !Array.isArray(dataLayerTransition.conditions)) {\n\t\t\t\t\t\tconst conditionKeys = Object.keys(dataLayerTransition.conditions);\n\t\t\t\t\t\tconst conditions = [];\n\t\t\t\t\t\tfor (let j = 0; j < conditionKeys.length; j++) {\n\t\t\t\t\t\t\tconst condition = dataLayerTransition.conditions[conditionKeys[j]];\n\t\t\t\t\t\t\tif (condition.parameterName) {\n\t\t\t\t\t\t\t\tconditions.push(condition);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tdataLayerTransition.conditions = conditions;\n\t\t\t\t\t}\n\t\t\t\t\tif (Number.isInteger(dataLayerTransition.from)) {\n\t\t\t\t\t\tdataLayerTransition.from = data.states[dataLayerTransition.from].name;\n\t\t\t\t\t}\n\t\t\t\t\tif (Number.isInteger(dataLayerTransition.to)) {\n\t\t\t\t\t\tdataLayerTransition.to = data.states[dataLayerTransition.to].name;\n\t\t\t\t\t}\n\t\t\t\t\tlayer.transitions.push(dataLayerTransition);\n\t\t\t\t}\n\t\t\t\tthis._layers.push(layer);\n\t\t\t}\n\t\t} else {\n\t\t\tthis._layers = data.layers;\n\t\t}\n\t\tfor (const paramId in data.parameters) {\n\t\t\tconst param = data.parameters[paramId];\n\t\t\tthis._parameters[param.name] = {\n\t\t\t\ttype: param.type,\n\t\t\t\tvalue: param.value\n\t\t\t};\n\t\t}\n\t}\n\tget parameters() {\n\t\treturn Object.assign({}, this._parameters);\n\t}\n\tget layers() {\n\t\treturn this._layers;\n\t}\n}\n\nexport { AnimStateGraph };\n", "import { extends as _extends } from '../../../../_virtual/_rollupPluginBabelHelpers.js';\nimport { Asset } from '../../asset/asset.js';\nimport { AnimEvaluator } from '../../anim/evaluator/anim-evaluator.js';\nimport { AnimController } from '../../anim/controller/anim-controller.js';\nimport { Component } from '../component.js';\nimport { ANIM_CONTROL_STATES, ANIM_PARAMETER_FLOAT, ANIM_PARAMETER_INTEGER, ANIM_PARAMETER_BOOLEAN, ANIM_PARAMETER_TRIGGER } from '../../anim/controller/constants.js';\nimport { AnimComponentBinder } from './component-binder.js';\nimport { AnimComponentLayer } from './component-layer.js';\nimport { AnimStateGraph } from '../../anim/state-graph/anim-state-graph.js';\nimport { Entity } from '../../entity.js';\nimport { AnimTrack } from '../../anim/evaluator/anim-track.js';\n\nclass AnimComponent extends Component {\n\tconstructor(system, entity) {\n\t\tsuper(system, entity);\n\t\tthis.findParameter = name => {\n\t\t\treturn this._parameters[name];\n\t\t};\n\t\tthis.consumeTrigger = name => {\n\t\t\tthis._consumedTriggers.add(name);\n\t\t};\n\t\tthis._stateGraphAsset = null;\n\t\tthis._animationAssets = {};\n\t\tthis._speed = 1.0;\n\t\tthis._activate = true;\n\t\tthis._playing = false;\n\t\tthis._rootBone = null;\n\t\tthis._stateGraph = null;\n\t\tthis._layers = [];\n\t\tthis._layerIndices = {};\n\t\tthis._parameters = {};\n\t\tthis._targets = {};\n\t\tthis._consumedTriggers = new Set();\n\t\tthis._normalizeWeights = false;\n\t}\n\tset stateGraphAsset(value) {\n\t\tif (value === null) {\n\t\t\tthis.removeStateGraph();\n\t\t\treturn;\n\t\t}\n\t\tif (this._stateGraphAsset) {\n\t\t\tconst stateGraphAsset = this.system.app.assets.get(this._stateGraphAsset);\n\t\t\tstateGraphAsset.off('change', this._onStateGraphAssetChangeEvent, this);\n\t\t}\n\t\tlet _id;\n\t\tlet _asset;\n\t\tif (value instanceof Asset) {\n\t\t\t_id = value.id;\n\t\t\t_asset = this.system.app.assets.get(_id);\n\t\t\tif (!_asset) {\n\t\t\t\tthis.system.app.assets.add(value);\n\t\t\t\t_asset = this.system.app.assets.get(_id);\n\t\t\t}\n\t\t} else {\n\t\t\t_id = value;\n\t\t\t_asset = this.system.app.assets.get(_id);\n\t\t}\n\t\tif (!_asset || this._stateGraphAsset === _id) {\n\t\t\treturn;\n\t\t}\n\t\tif (_asset.resource) {\n\t\t\tthis._stateGraph = _asset.resource;\n\t\t\tthis.loadStateGraph(this._stateGraph);\n\t\t\t_asset.on('change', this._onStateGraphAssetChangeEvent, this);\n\t\t} else {\n\t\t\t_asset.once('load', asset => {\n\t\t\t\tthis._stateGraph = asset.resource;\n\t\t\t\tthis.loadStateGraph(this._stateGraph);\n\t\t\t});\n\t\t\t_asset.on('change', this._onStateGraphAssetChangeEvent, this);\n\t\t\tthis.system.app.assets.load(_asset);\n\t\t}\n\t\tthis._stateGraphAsset = _id;\n\t}\n\tget stateGraphAsset() {\n\t\treturn this._stateGraphAsset;\n\t}\n\tset normalizeWeights(value) {\n\t\tthis._normalizeWeights = value;\n\t\tthis.unbind();\n\t}\n\tget normalizeWeights() {\n\t\treturn this._normalizeWeights;\n\t}\n\tset animationAssets(value) {\n\t\tthis._animationAssets = value;\n\t\tthis.loadAnimationAssets();\n\t}\n\tget animationAssets() {\n\t\treturn this._animationAssets;\n\t}\n\tset speed(value) {\n\t\tthis._speed = value;\n\t}\n\tget speed() {\n\t\treturn this._speed;\n\t}\n\tset activate(value) {\n\t\tthis._activate = value;\n\t}\n\tget activate() {\n\t\treturn this._activate;\n\t}\n\tset playing(value) {\n\t\tthis._playing = value;\n\t}\n\tget playing() {\n\t\treturn this._playing;\n\t}\n\tset rootBone(value) {\n\t\tif (typeof value === 'string') {\n\t\t\tconst entity = this.entity.root.findByGuid(value);\n\t\t\tthis._rootBone = entity;\n\t\t} else if (value instanceof Entity) {\n\t\t\tthis._rootBone = value;\n\t\t} else {\n\t\t\tthis._rootBone = null;\n\t\t}\n\t\tthis.rebind();\n\t}\n\tget rootBone() {\n\t\treturn this._rootBone;\n\t}\n\tset stateGraph(value) {\n\t\tthis._stateGraph = value;\n\t}\n\tget stateGraph() {\n\t\treturn this._stateGraph;\n\t}\n\tget layers() {\n\t\treturn this._layers;\n\t}\n\tset layerIndices(value) {\n\t\tthis._layerIndices = value;\n\t}\n\tget layerIndices() {\n\t\treturn this._layerIndices;\n\t}\n\tset parameters(value) {\n\t\tthis._parameters = value;\n\t}\n\tget parameters() {\n\t\treturn this._parameters;\n\t}\n\tset targets(value) {\n\t\tthis._targets = value;\n\t}\n\tget targets() {\n\t\treturn this._targets;\n\t}\n\tget playable() {\n\t\tfor (let i = 0; i < this._layers.length; i++) {\n\t\t\tif (!this._layers[i].playable) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\t\treturn true;\n\t}\n\tget baseLayer() {\n\t\tif (this._layers.length > 0) {\n\t\t\treturn this._layers[0];\n\t\t}\n\t\treturn null;\n\t}\n\t_onStateGraphAssetChangeEvent(asset) {\n\t\tconst prevAnimationAssets = this.animationAssets;\n\t\tconst prevMasks = this.layers.map(layer => layer.mask);\n\t\tthis.removeStateGraph();\n\t\tthis._stateGraph = new AnimStateGraph(asset._data);\n\t\tthis.loadStateGraph(this._stateGraph);\n\t\tthis.animationAssets = prevAnimationAssets;\n\t\tthis.loadAnimationAssets();\n\t\tthis.layers.forEach((layer, i) => {\n\t\t\tlayer.mask = prevMasks[i];\n\t\t});\n\t\tthis.rebind();\n\t}\n\tdirtifyTargets() {\n\t\tconst targets = Object.values(this._targets);\n\t\tfor (let i = 0; i < targets.length; i++) {\n\t\t\ttargets[i].dirty = true;\n\t\t}\n\t}\n\t_addLayer({\n\t\tname,\n\t\tstates,\n\t\ttransitions,\n\t\tweight,\n\t\tmask,\n\t\tblendType\n\t}) {\n\t\tlet graph;\n\t\tif (this.rootBone) {\n\t\t\tgraph = this.rootBone;\n\t\t} else {\n\t\t\tgraph = this.entity;\n\t\t}\n\t\tconst layerIndex = this._layers.length;\n\t\tconst animBinder = new AnimComponentBinder(this, graph, name, mask, layerIndex);\n\t\tconst animEvaluator = new AnimEvaluator(animBinder);\n\t\tconst controller = new AnimController(animEvaluator, states, transitions, this._activate, this, this.findParameter, this.consumeTrigger);\n\t\tthis._layers.push(new AnimComponentLayer(name, controller, this, weight, blendType));\n\t\tthis._layerIndices[name] = layerIndex;\n\t\treturn this._layers[layerIndex];\n\t}\n\taddLayer(name, weight, mask, blendType) {\n\t\tconst layer = this.findAnimationLayer(name);\n\t\tif (layer) return layer;\n\t\tconst states = [{\n\t\t\t'name': 'START',\n\t\t\t'speed': 1\n\t\t}];\n\t\tconst transitions = [];\n\t\treturn this._addLayer({\n\t\t\tname,\n\t\t\tstates,\n\t\t\ttransitions,\n\t\t\tweight,\n\t\t\tmask,\n\t\t\tblendType\n\t\t});\n\t}\n\t_assignParameters(stateGraph) {\n\t\tthis._parameters = {};\n\t\tconst paramKeys = Object.keys(stateGraph.parameters);\n\t\tfor (let i = 0; i < paramKeys.length; i++) {\n\t\t\tconst paramKey = paramKeys[i];\n\t\t\tthis._parameters[paramKey] = {\n\t\t\t\ttype: stateGraph.parameters[paramKey].type,\n\t\t\t\tvalue: stateGraph.parameters[paramKey].value\n\t\t\t};\n\t\t}\n\t}\n\tloadStateGraph(stateGraph) {\n\t\tthis._stateGraph = stateGraph;\n\t\tthis._assignParameters(stateGraph);\n\t\tthis._layers = [];\n\t\tlet containsBlendTree = false;\n\t\tfor (let i = 0; i < stateGraph.layers.length; i++) {\n\t\t\tconst layer = stateGraph.layers[i];\n\t\t\tthis._addLayer(_extends({}, layer));\n\t\t\tif (layer.states.some(state => state.blendTree)) {\n\t\t\t\tcontainsBlendTree = true;\n\t\t\t}\n\t\t}\n\t\tif (!containsBlendTree) {\n\t\t\tthis.setupAnimationAssets();\n\t\t}\n\t}\n\tsetupAnimationAssets() {\n\t\tfor (let i = 0; i < this._layers.length; i++) {\n\t\t\tconst layer = this._layers[i];\n\t\t\tconst layerName = layer.name;\n\t\t\tfor (let j = 0; j < layer.states.length; j++) {\n\t\t\t\tconst stateName = layer.states[j];\n\t\t\t\tif (ANIM_CONTROL_STATES.indexOf(stateName) === -1) {\n\t\t\t\t\tconst stateKey = layerName + ':' + stateName;\n\t\t\t\t\tif (!this._animationAssets[stateKey]) {\n\t\t\t\t\t\tthis._animationAssets[stateKey] = {\n\t\t\t\t\t\t\tasset: null\n\t\t\t\t\t\t};\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tthis.loadAnimationAssets();\n\t}\n\tloadAnimationAssets() {\n\t\tfor (let i = 0; i < this._layers.length; i++) {\n\t\t\tconst layer = this._layers[i];\n\t\t\tfor (let j = 0; j < layer.states.length; j++) {\n\t\t\t\tconst stateName = layer.states[j];\n\t\t\t\tif (ANIM_CONTROL_STATES.indexOf(stateName) !== -1) continue;\n\t\t\t\tconst animationAsset = this._animationAssets[layer.name + ':' + stateName];\n\t\t\t\tif (!animationAsset || !animationAsset.asset) {\n\t\t\t\t\tthis.findAnimationLayer(layer.name).assignAnimation(stateName, AnimTrack.EMPTY);\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tconst assetId = animationAsset.asset;\n\t\t\t\tconst asset = this.system.app.assets.get(assetId);\n\t\t\t\tif (asset) {\n\t\t\t\t\tif (asset.resource) {\n\t\t\t\t\t\tthis.onAnimationAssetLoaded(layer.name, stateName, asset);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tasset.once('load', function (layerName, stateName) {\n\t\t\t\t\t\t\treturn function (asset) {\n\t\t\t\t\t\t\t\tthis.onAnimationAssetLoaded(layerName, stateName, asset);\n\t\t\t\t\t\t\t}.bind(this);\n\t\t\t\t\t\t}.bind(this)(layer.name, stateName));\n\t\t\t\t\t\tthis.system.app.assets.load(asset);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\tonAnimationAssetLoaded(layerName, stateName, asset) {\n\t\tthis.findAnimationLayer(layerName).assignAnimation(stateName, asset.resource);\n\t}\n\tremoveStateGraph() {\n\t\tthis._stateGraph = null;\n\t\tthis._stateGraphAsset = null;\n\t\tthis._animationAssets = {};\n\t\tthis._layers = [];\n\t\tthis._layerIndices = {};\n\t\tthis._parameters = {};\n\t\tthis._playing = false;\n\t\tthis.unbind();\n\t\tthis._targets = {};\n\t}\n\treset() {\n\t\tthis._assignParameters(this._stateGraph);\n\t\tfor (let i = 0; i < this._layers.length; i++) {\n\t\t\tconst layerPlaying = this._layers[i].playing;\n\t\t\tthis._layers[i].reset();\n\t\t\tthis._layers[i].playing = layerPlaying;\n\t\t}\n\t}\n\tunbind() {\n\t\tif (!this._normalizeWeights) {\n\t\t\tObject.keys(this._targets).forEach(targetKey => {\n\t\t\t\tthis._targets[targetKey].unbind();\n\t\t\t});\n\t\t}\n\t}\n\trebind() {\n\t\tthis._targets = {};\n\t\tfor (let i = 0; i < this._layers.length; i++) {\n\t\t\tthis._layers[i].rebind();\n\t\t}\n\t}\n\tfindAnimationLayer(name) {\n\t\tconst layerIndex = this._layerIndices[name];\n\t\treturn this._layers[layerIndex] || null;\n\t}\n\taddAnimationState(nodeName, animTrack, speed = 1, loop = true, layerName = 'Base') {\n\t\tif (!this._stateGraph) {\n\t\t\tthis.loadStateGraph(new AnimStateGraph({\n\t\t\t\t'layers': [{\n\t\t\t\t\t'name': layerName,\n\t\t\t\t\t'states': [{\n\t\t\t\t\t\t'name': 'START',\n\t\t\t\t\t\t'speed': 1\n\t\t\t\t\t}, {\n\t\t\t\t\t\t'name': nodeName,\n\t\t\t\t\t\t'speed': speed,\n\t\t\t\t\t\t'loop': loop,\n\t\t\t\t\t\t'defaultState': true\n\t\t\t\t\t}],\n\t\t\t\t\t'transitions': [{\n\t\t\t\t\t\t'from': 'START',\n\t\t\t\t\t\t'to': nodeName\n\t\t\t\t\t}]\n\t\t\t\t}],\n\t\t\t\t'parameters': {}\n\t\t\t}));\n\t\t}\n\t\tconst layer = this.findAnimationLayer(layerName);\n\t\tif (layer) {\n\t\t\tlayer.assignAnimation(nodeName, animTrack, speed, loop);\n\t\t} else {\n\t\t\tvar _this$addLayer;\n\t\t\t(_this$addLayer = this.addLayer(layerName)) == null || _this$addLayer.assignAnimation(nodeName, animTrack, speed, loop);\n\t\t}\n\t}\n\tassignAnimation(nodePath, animTrack, layerName, speed = 1, loop = true) {\n\t\tif (!this._stateGraph && nodePath.indexOf('.') === -1) {\n\t\t\tthis.loadStateGraph(new AnimStateGraph({\n\t\t\t\t'layers': [{\n\t\t\t\t\t'name': 'Base',\n\t\t\t\t\t'states': [{\n\t\t\t\t\t\t'name': 'START',\n\t\t\t\t\t\t'speed': 1\n\t\t\t\t\t}, {\n\t\t\t\t\t\t'name': nodePath,\n\t\t\t\t\t\t'speed': speed,\n\t\t\t\t\t\t'loop': loop,\n\t\t\t\t\t\t'defaultState': true\n\t\t\t\t\t}],\n\t\t\t\t\t'transitions': [{\n\t\t\t\t\t\t'from': 'START',\n\t\t\t\t\t\t'to': nodePath\n\t\t\t\t\t}]\n\t\t\t\t}],\n\t\t\t\t'parameters': {}\n\t\t\t}));\n\t\t\tthis.baseLayer.assignAnimation(nodePath, animTrack);\n\t\t\treturn;\n\t\t}\n\t\tconst layer = layerName ? this.findAnimationLayer(layerName) : this.baseLayer;\n\t\tif (!layer) {\n\t\t\treturn;\n\t\t}\n\t\tlayer.assignAnimation(nodePath, animTrack, speed, loop);\n\t}\n\tremoveNodeAnimations(nodeName, layerName) {\n\t\tconst layer = layerName ? this.findAnimationLayer(layerName) : this.baseLayer;\n\t\tif (!layer) {\n\t\t\treturn;\n\t\t}\n\t\tlayer.removeNodeAnimations(nodeName);\n\t}\n\tgetParameterValue(name, type) {\n\t\tconst param = this._parameters[name];\n\t\tif (param && param.type === type) {\n\t\t\treturn param.value;\n\t\t}\n\t\treturn undefined;\n\t}\n\tsetParameterValue(name, type, value) {\n\t\tconst param = this._parameters[name];\n\t\tif (param && param.type === type) {\n\t\t\tparam.value = value;\n\t\t\treturn;\n\t\t}\n\t}\n\tgetFloat(name) {\n\t\treturn this.getParameterValue(name, ANIM_PARAMETER_FLOAT);\n\t}\n\tsetFloat(name, value) {\n\t\tthis.setParameterValue(name, ANIM_PARAMETER_FLOAT, value);\n\t}\n\tgetInteger(name) {\n\t\treturn this.getParameterValue(name, ANIM_PARAMETER_INTEGER);\n\t}\n\tsetInteger(name, value) {\n\t\tif (typeof value === 'number' && value % 1 === 0) {\n\t\t\tthis.setParameterValue(name, ANIM_PARAMETER_INTEGER, value);\n\t\t}\n\t}\n\tgetBoolean(name) {\n\t\treturn this.getParameterValue(name, ANIM_PARAMETER_BOOLEAN);\n\t}\n\tsetBoolean(name, value) {\n\t\tthis.setParameterValue(name, ANIM_PARAMETER_BOOLEAN, !!value);\n\t}\n\tgetTrigger(name) {\n\t\treturn this.getParameterValue(name, ANIM_PARAMETER_TRIGGER);\n\t}\n\tsetTrigger(name, singleFrame = false) {\n\t\tthis.setParameterValue(name, ANIM_PARAMETER_TRIGGER, true);\n\t\tif (singleFrame) {\n\t\t\tthis._consumedTriggers.add(name);\n\t\t}\n\t}\n\tresetTrigger(name) {\n\t\tthis.setParameterValue(name, ANIM_PARAMETER_TRIGGER, false);\n\t}\n\tonBeforeRemove() {\n\t\tif (Number.isFinite(this._stateGraphAsset)) {\n\t\t\tconst stateGraphAsset = this.system.app.assets.get(this._stateGraphAsset);\n\t\t\tstateGraphAsset.off('change', this._onStateGraphAssetChangeEvent, this);\n\t\t}\n\t}\n\tupdate(dt) {\n\t\tfor (let i = 0; i < this.layers.length; i++) {\n\t\t\tthis.layers[i].update(dt * this.speed);\n\t\t}\n\t\tthis._consumedTriggers.forEach(trigger => {\n\t\t\tthis.parameters[trigger].value = false;\n\t\t});\n\t\tthis._consumedTriggers.clear();\n\t}\n\tresolveDuplicatedEntityReferenceProperties(oldAnim, duplicatedIdsMap) {\n\t\tif (oldAnim.rootBone && duplicatedIdsMap[oldAnim.rootBone.getGuid()]) {\n\t\t\tthis.rootBone = duplicatedIdsMap[oldAnim.rootBone.getGuid()];\n\t\t} else {\n\t\t\tthis.rebind();\n\t\t}\n\t}\n}\n\nexport { AnimComponent };\n", "class AnimComponentData {\n\tconstructor() {\n\t\tthis.enabled = true;\n\t}\n}\n\nexport { AnimComponentData };\n", "import { AnimTrack } from '../../anim/evaluator/anim-track.js';\nimport { Component } from '../component.js';\nimport { ComponentSystem } from '../system.js';\nimport { AnimComponent } from './component.js';\nimport { AnimComponentData } from './data.js';\n\nconst _schema = ['enabled'];\nclass AnimComponentSystem extends ComponentSystem {\n\tconstructor(app) {\n\t\tsuper(app);\n\t\tthis.id = 'anim';\n\t\tthis.ComponentType = AnimComponent;\n\t\tthis.DataType = AnimComponentData;\n\t\tthis.schema = _schema;\n\t\tthis.on('beforeremove', this.onBeforeRemove, this);\n\t\tthis.app.systems.on('animationUpdate', this.onAnimationUpdate, this);\n\t}\n\tinitializeComponentData(component, data, properties) {\n\t\tsuper.initializeComponentData(component, data, _schema);\n\t\tconst complexProperties = ['animationAssets', 'stateGraph', 'layers', 'masks'];\n\t\tObject.keys(data).forEach(key => {\n\t\t\tif (complexProperties.includes(key)) return;\n\t\t\tcomponent[key] = data[key];\n\t\t});\n\t\tif (data.stateGraph) {\n\t\t\tcomponent.stateGraph = data.stateGraph;\n\t\t\tcomponent.loadStateGraph(component.stateGraph);\n\t\t}\n\t\tif (data.layers) {\n\t\t\tdata.layers.forEach((layer, i) => {\n\t\t\t\tlayer._controller.states.forEach(stateKey => {\n\t\t\t\t\tlayer._controller._states[stateKey]._animationList.forEach(node => {\n\t\t\t\t\t\tif (!node.animTrack || node.animTrack === AnimTrack.EMPTY) {\n\t\t\t\t\t\t\tconst animationAsset = this.app.assets.get(layer._component._animationAssets[layer.name + ':' + node.name].asset);\n\t\t\t\t\t\t\tif (animationAsset && !animationAsset.loaded) {\n\t\t\t\t\t\t\t\tanimationAsset.once('load', () => {\n\t\t\t\t\t\t\t\t\tcomponent.layers[i].assignAnimation(node.name, animationAsset.resource);\n\t\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tcomponent.layers[i].assignAnimation(node.name, node.animTrack);\n\t\t\t\t\t\t}\n\t\t\t\t\t});\n\t\t\t\t});\n\t\t\t});\n\t\t}\n\t\tif (data.animationAssets) {\n\t\t\tcomponent.animationAssets = Object.assign(component.animationAssets, data.animationAssets);\n\t\t}\n\t\tif (data.masks) {\n\t\t\tObject.keys(data.masks).forEach(key => {\n\t\t\t\tif (component.layers[key]) {\n\t\t\t\t\tconst maskData = data.masks[key].mask;\n\t\t\t\t\tconst mask = {};\n\t\t\t\t\tObject.keys(maskData).forEach(maskKey => {\n\t\t\t\t\t\tmask[decodeURI(maskKey)] = maskData[maskKey];\n\t\t\t\t\t});\n\t\t\t\t\tcomponent.layers[key].mask = mask;\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\t}\n\tonAnimationUpdate(dt) {\n\t\tconst components = this.store;\n\t\tfor (const id in components) {\n\t\t\tif (components.hasOwnProperty(id)) {\n\t\t\t\tconst component = components[id].entity.anim;\n\t\t\t\tconst componentData = component.data;\n\t\t\t\tif (componentData.enabled && component.entity.enabled && component.playing) {\n\t\t\t\t\tcomponent.update(dt);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\tcloneComponent(entity, clone) {\n\t\tlet masks;\n\t\tif (!entity.anim.rootBone || entity.anim.rootBone === entity) {\n\t\t\tmasks = {};\n\t\t\tentity.anim.layers.forEach((layer, i) => {\n\t\t\t\tif (layer.mask) {\n\t\t\t\t\tconst mask = {};\n\t\t\t\t\tObject.keys(layer.mask).forEach(path => {\n\t\t\t\t\t\tconst pathArr = path.split('/');\n\t\t\t\t\t\tpathArr.shift();\n\t\t\t\t\t\tconst clonePath = [clone.name, ...pathArr].join('/');\n\t\t\t\t\t\tmask[clonePath] = layer.mask[path];\n\t\t\t\t\t});\n\t\t\t\t\tmasks[i] = {\n\t\t\t\t\t\tmask\n\t\t\t\t\t};\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\t\tconst data = {\n\t\t\tstateGraphAsset: entity.anim.stateGraphAsset,\n\t\t\tanimationAssets: entity.anim.animationAssets,\n\t\t\tspeed: entity.anim.speed,\n\t\t\tactivate: entity.anim.activate,\n\t\t\tplaying: entity.anim.playing,\n\t\t\trootBone: entity.anim.rootBone,\n\t\t\tstateGraph: entity.anim.stateGraph,\n\t\t\tlayers: entity.anim.layers,\n\t\t\tlayerIndices: entity.anim.layerIndices,\n\t\t\tparameters: entity.anim.parameters,\n\t\t\tnormalizeWeights: entity.anim.normalizeWeights,\n\t\t\tmasks\n\t\t};\n\t\treturn this.addComponent(clone, data);\n\t}\n\tonBeforeRemove(entity, component) {\n\t\tcomponent.onBeforeRemove();\n\t}\n\tdestroy() {\n\t\tsuper.destroy();\n\t\tthis.app.systems.off('animationUpdate', this.onAnimationUpdate, this);\n\t}\n}\nComponent._buildAccessors(AnimComponent.prototype, _schema);\n\nexport { AnimComponentSystem };\n", "import { Component } from '../component.js';\n\nclass AudioListenerComponent extends Component {\n\tconstructor(system, entity) {\n\t\tsuper(system, entity);\n\t}\n\tsetCurrentListener() {\n\t\tif (this.enabled && this.entity.audiolistener && this.entity.enabled) {\n\t\t\tthis.system.current = this.entity;\n\t\t\tconst position = this.system.current.getPosition();\n\t\t\tthis.system.manager.listener.setPosition(position);\n\t\t}\n\t}\n\tonEnable() {\n\t\tthis.setCurrentListener();\n\t}\n\tonDisable() {\n\t\tif (this.system.current === this.entity) {\n\t\t\tthis.system.current = null;\n\t\t}\n\t}\n}\n\nexport { AudioListenerComponent };\n", "class AudioListenerComponentData {\n\tconstructor() {\n\t\tthis.enabled = true;\n\t}\n}\n\nexport { AudioListenerComponentData };\n", "import { Component } from '../component.js';\nimport { ComponentSystem } from '../system.js';\nimport { AudioListenerComponent } from './component.js';\nimport { AudioListenerComponentData } from './data.js';\n\nconst _schema = ['enabled'];\nclass AudioListenerComponentSystem extends ComponentSystem {\n\tconstructor(app) {\n\t\tsuper(app);\n\t\tthis.id = 'audiolistener';\n\t\tthis.ComponentType = AudioListenerComponent;\n\t\tthis.DataType = AudioListenerComponentData;\n\t\tthis.schema = _schema;\n\t\tthis.manager = app.soundManager;\n\t\tthis.current = null;\n\t\tthis.app.systems.on('update', this.onUpdate, this);\n\t}\n\tinitializeComponentData(component, data, properties) {\n\t\tproperties = ['enabled'];\n\t\tsuper.initializeComponentData(component, data, properties);\n\t}\n\tonUpdate(dt) {\n\t\tif (this.current) {\n\t\t\tconst position = this.current.getPosition();\n\t\t\tthis.manager.listener.setPosition(position);\n\t\t\tconst wtm = this.current.getWorldTransform();\n\t\t\tthis.manager.listener.setOrientation(wtm);\n\t\t}\n\t}\n\tdestroy() {\n\t\tsuper.destroy();\n\t\tthis.app.systems.off('update', this.onUpdate, this);\n\t}\n}\nComponent._buildAccessors(AudioListenerComponent.prototype, _schema);\n\nexport { AudioListenerComponentSystem };\n", "import { Component } from '../components/component.js';\nimport { Entity } from '../entity.js';\nimport { EventHandler } from '../../core/event-handler.js';\n\nclass EntityReference extends EventHandler {\n\tconstructor(parentComponent, entityPropertyName, eventConfig) {\n\t\tsuper();\n\t\tif (!parentComponent || !(parentComponent instanceof Component)) {\n\t\t\tthrow new Error('The parentComponent argument is required and must be a Component');\n\t\t} else if (!entityPropertyName || typeof entityPropertyName !== 'string') {\n\t\t\tthrow new Error('The propertyName argument is required and must be a string');\n\t\t} else if (eventConfig && typeof eventConfig !== 'object') {\n\t\t\tthrow new Error('If provided, the eventConfig argument must be an object');\n\t\t}\n\t\tthis._parentComponent = parentComponent;\n\t\tthis._entityPropertyName = entityPropertyName;\n\t\tthis._entity = null;\n\t\tthis._app = parentComponent.system.app;\n\t\tthis._configureEventListeners(eventConfig || {}, {\n\t\t\t'entity#destroy': this._onEntityDestroy\n\t\t});\n\t\tthis._toggleLifecycleListeners('on');\n\t}\n\t_configureEventListeners(externalEventConfig, internalEventConfig) {\n\t\tconst externalEventListenerConfigs = this._parseEventListenerConfig(externalEventConfig, 'external', this._parentComponent);\n\t\tconst internalEventListenerConfigs = this._parseEventListenerConfig(internalEventConfig, 'internal', this);\n\t\tthis._eventListenerConfigs = externalEventListenerConfigs.concat(internalEventListenerConfigs);\n\t\tthis._listenerStatusFlags = {};\n\t\tthis._gainListeners = {};\n\t\tthis._loseListeners = {};\n\t}\n\t_parseEventListenerConfig(eventConfig, prefix, scope) {\n\t\treturn Object.keys(eventConfig).map(function (listenerDescription, index) {\n\t\t\tconst listenerDescriptionParts = listenerDescription.split('#');\n\t\t\tconst sourceName = listenerDescriptionParts[0];\n\t\t\tconst eventName = listenerDescriptionParts[1];\n\t\t\tconst callback = eventConfig[listenerDescription];\n\t\t\tif (listenerDescriptionParts.length !== 2 || typeof sourceName !== 'string' || sourceName.length === 0 || typeof eventName !== 'string' || eventName.length === 0) {\n\t\t\t\tthrow new Error('Invalid event listener description: `' + listenerDescription + '`');\n\t\t\t}\n\t\t\tif (typeof callback !== 'function') {\n\t\t\t\tthrow new Error('Invalid or missing callback for event listener `' + listenerDescription + '`');\n\t\t\t}\n\t\t\treturn {\n\t\t\t\tid: prefix + '_' + index + '_' + listenerDescription,\n\t\t\t\tsourceName: sourceName,\n\t\t\t\teventName: eventName,\n\t\t\t\tcallback: callback,\n\t\t\t\tscope: scope\n\t\t\t};\n\t\t}, this);\n\t}\n\t_toggleLifecycleListeners(onOrOff) {\n\t\tthis._parentComponent[onOrOff]('set_' + this._entityPropertyName, this._onSetEntity, this);\n\t\tthis._parentComponent.system[onOrOff]('beforeremove', this._onParentComponentRemove, this);\n\t\tthis._app.systems[onOrOff]('postPostInitialize', this._updateEntityReference, this);\n\t\tthis._app[onOrOff]('tools:sceneloaded', this._onSceneLoaded, this);\n\t\tconst allComponentSystems = [];\n\t\tfor (let i = 0; i < this._eventListenerConfigs.length; ++i) {\n\t\t\tconst config = this._eventListenerConfigs[i];\n\t\t\tconst componentSystem = this._app.systems[config.sourceName];\n\t\t\tif (componentSystem) {\n\t\t\t\tif (allComponentSystems.indexOf(componentSystem) === -1) {\n\t\t\t\t\tallComponentSystems.push(componentSystem);\n\t\t\t\t}\n\t\t\t\tif (componentSystem && config.eventName === 'gain') {\n\t\t\t\t\tthis._gainListeners[config.sourceName] = config;\n\t\t\t\t}\n\t\t\t\tif (componentSystem && config.eventName === 'lose') {\n\t\t\t\t\tthis._loseListeners[config.sourceName] = config;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tfor (let i = 0; i < allComponentSystems.length; ++i) {\n\t\t\tallComponentSystems[i][onOrOff]('add', this._onComponentAdd, this);\n\t\t\tallComponentSystems[i][onOrOff]('beforeremove', this._onComponentRemove, this);\n\t\t}\n\t}\n\t_onSetEntity(name, oldValue, newValue) {\n\t\tif (newValue instanceof Entity) {\n\t\t\tthis._updateEntityReference();\n\t\t} else {\n\t\t\tif (newValue !== null && newValue !== undefined && typeof newValue !== 'string') {\n\t\t\t\tconsole.warn(\"Entity field `\" + this._entityPropertyName + \"` was set to unexpected type '\" + typeof newValue + \"'\");\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif (oldValue !== newValue) {\n\t\t\t\tthis._updateEntityReference();\n\t\t\t}\n\t\t}\n\t}\n\tonParentComponentEnable() {\n\t\tif (!this._entity) {\n\t\t\tthis._updateEntityReference();\n\t\t}\n\t}\n\t_onSceneLoaded() {\n\t\tthis._updateEntityReference();\n\t}\n\t_updateEntityReference() {\n\t\tlet nextEntityGuid = this._parentComponent.data[this._entityPropertyName];\n\t\tlet nextEntity;\n\t\tif (nextEntityGuid instanceof Entity) {\n\t\t\tnextEntity = nextEntityGuid;\n\t\t\tnextEntityGuid = nextEntity.getGuid();\n\t\t\tthis._parentComponent.data[this._entityPropertyName] = nextEntityGuid;\n\t\t} else {\n\t\t\tconst root = this._parentComponent.system.app.root;\n\t\t\tconst isOnSceneGraph = this._parentComponent.entity.isDescendantOf(root);\n\t\t\tnextEntity = isOnSceneGraph && nextEntityGuid ? root.findByGuid(nextEntityGuid) : null;\n\t\t}\n\t\tconst hasChanged = this._entity !== nextEntity;\n\t\tif (hasChanged) {\n\t\t\tif (this._entity) {\n\t\t\t\tthis._onBeforeEntityChange();\n\t\t\t}\n\t\t\tthis._entity = nextEntity;\n\t\t\tif (this._entity) {\n\t\t\t\tthis._onAfterEntityChange();\n\t\t\t}\n\t\t\tthis.fire('set:entity', this._entity);\n\t\t}\n\t}\n\t_onBeforeEntityChange() {\n\t\tthis._toggleEntityListeners('off');\n\t\tthis._callAllGainOrLoseListeners(this._loseListeners);\n\t}\n\t_onAfterEntityChange() {\n\t\tthis._toggleEntityListeners('on');\n\t\tthis._callAllGainOrLoseListeners(this._gainListeners);\n\t}\n\t_onComponentAdd(entity, component) {\n\t\tconst componentName = component.system.id;\n\t\tif (entity === this._entity) {\n\t\t\tthis._callGainOrLoseListener(componentName, this._gainListeners);\n\t\t\tthis._toggleComponentListeners('on', componentName);\n\t\t}\n\t}\n\t_onComponentRemove(entity, component) {\n\t\tconst componentName = component.system.id;\n\t\tif (entity === this._entity) {\n\t\t\tthis._callGainOrLoseListener(componentName, this._loseListeners);\n\t\t\tthis._toggleComponentListeners('off', componentName, true);\n\t\t}\n\t}\n\t_callAllGainOrLoseListeners(listenerMap) {\n\t\tfor (const componentName in this._entity.c) {\n\t\t\tthis._callGainOrLoseListener(componentName, listenerMap);\n\t\t}\n\t}\n\t_callGainOrLoseListener(componentName, listenerMap) {\n\t\tif (this._entity.c.hasOwnProperty(componentName) && listenerMap[componentName]) {\n\t\t\tconst config = listenerMap[componentName];\n\t\t\tconfig.callback.call(config.scope);\n\t\t}\n\t}\n\t_toggleEntityListeners(onOrOff, isDestroying) {\n\t\tif (this._entity) {\n\t\t\tfor (let i = 0; i < this._eventListenerConfigs.length; ++i) {\n\t\t\t\tthis._safeToggleListener(onOrOff, this._eventListenerConfigs[i], isDestroying);\n\t\t\t}\n\t\t}\n\t}\n\t_toggleComponentListeners(onOrOff, componentName, isDestroying) {\n\t\tfor (let i = 0; i < this._eventListenerConfigs.length; ++i) {\n\t\t\tconst config = this._eventListenerConfigs[i];\n\t\t\tif (config.sourceName === componentName) {\n\t\t\t\tthis._safeToggleListener(onOrOff, config, isDestroying);\n\t\t\t}\n\t\t}\n\t}\n\t_safeToggleListener(onOrOff, config, isDestroying) {\n\t\tconst isAdding = onOrOff === 'on';\n\t\tif (isAdding && this._listenerStatusFlags[config.id]) {\n\t\t\treturn;\n\t\t}\n\t\tconst source = this._getEventSource(config.sourceName, isDestroying);\n\t\tif (source) {\n\t\t\tsource[onOrOff](config.eventName, config.callback, config.scope);\n\t\t\tthis._listenerStatusFlags[config.id] = isAdding;\n\t\t}\n\t}\n\t_getEventSource(sourceName, isDestroying) {\n\t\tif (sourceName === 'entity') {\n\t\t\treturn this._entity;\n\t\t}\n\t\tconst component = this._entity[sourceName];\n\t\tif (component) {\n\t\t\treturn component;\n\t\t}\n\t\tif (!isDestroying) {\n\t\t\tconsole.warn('Entity has no component with name ' + sourceName);\n\t\t}\n\t\treturn null;\n\t}\n\t_onEntityDestroy(entity) {\n\t\tif (this._entity === entity) {\n\t\t\tthis._toggleEntityListeners('off', true);\n\t\t\tthis._entity = null;\n\t\t}\n\t}\n\t_onParentComponentRemove(entity, component) {\n\t\tif (component === this._parentComponent) {\n\t\t\tthis._toggleLifecycleListeners('off');\n\t\t\tthis._toggleEntityListeners('off', true);\n\t\t}\n\t}\n\thasComponent(componentName) {\n\t\treturn this._entity && this._entity.c ? !!this._entity.c[componentName] : false;\n\t}\n\tget entity() {\n\t\treturn this._entity;\n\t}\n}\n\nexport { EntityReference };\n", "import { Quat } from '../../../core/math/quat.js';\nimport { Vec3 } from '../../../core/math/vec3.js';\nimport { Asset } from '../../asset/asset.js';\nimport { Component } from '../component.js';\n\nconst _vec3 = new Vec3();\nconst _quat = new Quat();\nclass CollisionComponent extends Component {\n\tconstructor(system, entity) {\n\t\tsuper(system, entity);\n\t\tthis._compoundParent = null;\n\t\tthis._hasOffset = false;\n\t\tthis.entity.on('insert', this._onInsert, this);\n\t\tthis.on('set_type', this.onSetType, this);\n\t\tthis.on('set_convexHull', this.onSetModel, this);\n\t\tthis.on('set_halfExtents', this.onSetHalfExtents, this);\n\t\tthis.on('set_linearOffset', this.onSetOffset, this);\n\t\tthis.on('set_angularOffset', this.onSetOffset, this);\n\t\tthis.on('set_radius', this.onSetRadius, this);\n\t\tthis.on('set_height', this.onSetHeight, this);\n\t\tthis.on('set_axis', this.onSetAxis, this);\n\t\tthis.on('set_asset', this.onSetAsset, this);\n\t\tthis.on('set_renderAsset', this.onSetRenderAsset, this);\n\t\tthis.on('set_model', this.onSetModel, this);\n\t\tthis.on('set_render', this.onSetRender, this);\n\t}\n\tget data() {\n\t\tconst record = this.system.store[this.entity.getGuid()];\n\t\treturn record ? record.data : null;\n\t}\n\tset enabled(arg) {\n\t\tthis._setValue('enabled', arg);\n\t}\n\tget enabled() {\n\t\treturn this.data.enabled;\n\t}\n\tset type(arg) {\n\t\tthis._setValue('type', arg);\n\t}\n\tget type() {\n\t\treturn this.data.type;\n\t}\n\tset halfExtents(arg) {\n\t\tthis._setValue('halfExtents', arg);\n\t}\n\tget halfExtents() {\n\t\treturn this.data.halfExtents;\n\t}\n\tset linearOffset(arg) {\n\t\tthis._setValue('linearOffset', arg);\n\t}\n\tget linearOffset() {\n\t\treturn this.data.linearOffset;\n\t}\n\tset angularOffset(arg) {\n\t\tthis._setValue('angularOffset', arg);\n\t}\n\tget angularOffset() {\n\t\treturn this.data.angularOffset;\n\t}\n\tset radius(arg) {\n\t\tthis._setValue('radius', arg);\n\t}\n\tget radius() {\n\t\treturn this.data.radius;\n\t}\n\tset axis(arg) {\n\t\tthis._setValue('axis', arg);\n\t}\n\tget axis() {\n\t\treturn this.data.axis;\n\t}\n\tset height(arg) {\n\t\tthis._setValue('height', arg);\n\t}\n\tget height() {\n\t\treturn this.data.height;\n\t}\n\tset asset(arg) {\n\t\tthis._setValue('asset', arg);\n\t}\n\tget asset() {\n\t\treturn this.data.asset;\n\t}\n\tset renderAsset(arg) {\n\t\tthis._setValue('renderAsset', arg);\n\t}\n\tget renderAsset() {\n\t\treturn this.data.renderAsset;\n\t}\n\tset convexHull(arg) {\n\t\tthis._setValue('convexHull', arg);\n\t}\n\tget convexHull() {\n\t\treturn this.data.convexHull;\n\t}\n\tset shape(arg) {\n\t\tthis._setValue('shape', arg);\n\t}\n\tget shape() {\n\t\treturn this.data.shape;\n\t}\n\tset model(arg) {\n\t\tthis._setValue('model', arg);\n\t}\n\tget model() {\n\t\treturn this.data.model;\n\t}\n\tset render(arg) {\n\t\tthis._setValue('render', arg);\n\t}\n\tget render() {\n\t\treturn this.data.render;\n\t}\n\tset checkVertexDuplicates(arg) {\n\t\tthis._setValue('checkVertexDuplicates', arg);\n\t}\n\tget checkVertexDuplicates() {\n\t\treturn this.data.checkVertexDuplicates;\n\t}\n\t_setValue(name, value) {\n\t\tconst data = this.data;\n\t\tconst oldValue = data[name];\n\t\tdata[name] = value;\n\t\tthis.fire('set', name, oldValue, value);\n\t}\n\tonSetType(name, oldValue, newValue) {\n\t\tif (oldValue !== newValue) {\n\t\t\tthis.system.changeType(this, oldValue, newValue);\n\t\t}\n\t}\n\tonSetHalfExtents(name, oldValue, newValue) {\n\t\tconst t = this.data.type;\n\t\tif (this.data.initialized && t === 'box') {\n\t\t\tthis.system.recreatePhysicalShapes(this);\n\t\t}\n\t}\n\tonSetOffset(name, oldValue, newValue) {\n\t\tthis._hasOffset = !this.data.linearOffset.equals(Vec3.ZERO) || !this.data.angularOffset.equals(Quat.IDENTITY);\n\t\tif (this.data.initialized) {\n\t\t\tthis.system.recreatePhysicalShapes(this);\n\t\t}\n\t}\n\tonSetRadius(name, oldValue, newValue) {\n\t\tconst t = this.data.type;\n\t\tif (this.data.initialized && (t === 'sphere' || t === 'capsule' || t === 'cylinder' || t === 'cone')) {\n\t\t\tthis.system.recreatePhysicalShapes(this);\n\t\t}\n\t}\n\tonSetHeight(name, oldValue, newValue) {\n\t\tconst t = this.data.type;\n\t\tif (this.data.initialized && (t === 'capsule' || t === 'cylinder' || t === 'cone')) {\n\t\t\tthis.system.recreatePhysicalShapes(this);\n\t\t}\n\t}\n\tonSetAxis(name, oldValue, newValue) {\n\t\tconst t = this.data.type;\n\t\tif (this.data.initialized && (t === 'capsule' || t === 'cylinder' || t === 'cone')) {\n\t\t\tthis.system.recreatePhysicalShapes(this);\n\t\t}\n\t}\n\tonSetAsset(name, oldValue, newValue) {\n\t\tconst assets = this.system.app.assets;\n\t\tif (oldValue) {\n\t\t\tconst asset = assets.get(oldValue);\n\t\t\tif (asset) {\n\t\t\t\tasset.off('remove', this.onAssetRemoved, this);\n\t\t\t}\n\t\t}\n\t\tif (newValue) {\n\t\t\tif (newValue instanceof Asset) {\n\t\t\t\tthis.data.asset = newValue.id;\n\t\t\t}\n\t\t\tconst asset = assets.get(this.data.asset);\n\t\t\tif (asset) {\n\t\t\t\tasset.off('remove', this.onAssetRemoved, this);\n\t\t\t\tasset.on('remove', this.onAssetRemoved, this);\n\t\t\t}\n\t\t}\n\t\tif (this.data.initialized && this.data.type === 'mesh') {\n\t\t\tif (!newValue) {\n\t\t\t\tthis.data.model = null;\n\t\t\t}\n\t\t\tthis.system.recreatePhysicalShapes(this);\n\t\t}\n\t}\n\tonSetRenderAsset(name, oldValue, newValue) {\n\t\tconst assets = this.system.app.assets;\n\t\tif (oldValue) {\n\t\t\tconst asset = assets.get(oldValue);\n\t\t\tif (asset) {\n\t\t\t\tasset.off('remove', this.onRenderAssetRemoved, this);\n\t\t\t}\n\t\t}\n\t\tif (newValue) {\n\t\t\tif (newValue instanceof Asset) {\n\t\t\t\tthis.data.renderAsset = newValue.id;\n\t\t\t}\n\t\t\tconst asset = assets.get(this.data.renderAsset);\n\t\t\tif (asset) {\n\t\t\t\tasset.off('remove', this.onRenderAssetRemoved, this);\n\t\t\t\tasset.on('remove', this.onRenderAssetRemoved, this);\n\t\t\t}\n\t\t}\n\t\tif (this.data.initialized && this.data.type === 'mesh') {\n\t\t\tif (!newValue) {\n\t\t\t\tthis.data.render = null;\n\t\t\t}\n\t\t\tthis.system.recreatePhysicalShapes(this);\n\t\t}\n\t}\n\tonSetModel(name, oldValue, newValue) {\n\t\tif (this.data.initialized && this.data.type === 'mesh') {\n\t\t\tthis.system.implementations.mesh.doRecreatePhysicalShape(this);\n\t\t}\n\t}\n\tonSetRender(name, oldValue, newValue) {\n\t\tthis.onSetModel(name, oldValue, newValue);\n\t}\n\tonAssetRemoved(asset) {\n\t\tasset.off('remove', this.onAssetRemoved, this);\n\t\tif (this.data.asset === asset.id) {\n\t\t\tthis.asset = null;\n\t\t}\n\t}\n\tonRenderAssetRemoved(asset) {\n\t\tasset.off('remove', this.onRenderAssetRemoved, this);\n\t\tif (this.data.renderAsset === asset.id) {\n\t\t\tthis.renderAsset = null;\n\t\t}\n\t}\n\t_getCompoundChildShapeIndex(shape) {\n\t\tconst compound = this.data.shape;\n\t\tconst shapes = compound.getNumChildShapes();\n\t\tfor (let i = 0; i < shapes; i++) {\n\t\t\tconst childShape = compound.getChildShape(i);\n\t\t\tif (childShape.ptr === shape.ptr) {\n\t\t\t\treturn i;\n\t\t\t}\n\t\t}\n\t\treturn null;\n\t}\n\t_onInsert(parent) {\n\t\tif (typeof Ammo === 'undefined') {\n\t\t\treturn;\n\t\t}\n\t\tif (this._compoundParent) {\n\t\t\tthis.system.recreatePhysicalShapes(this);\n\t\t} else if (!this.entity.rigidbody) {\n\t\t\tlet ancestor = this.entity.parent;\n\t\t\twhile (ancestor) {\n\t\t\t\tif (ancestor.collision && ancestor.collision.type === 'compound') {\n\t\t\t\t\tif (ancestor.collision.shape.getNumChildShapes() === 0) {\n\t\t\t\t\t\tthis.system.recreatePhysicalShapes(ancestor.collision);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tthis.system.recreatePhysicalShapes(this);\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\tancestor = ancestor.parent;\n\t\t\t}\n\t\t}\n\t}\n\t_updateCompound() {\n\t\tconst entity = this.entity;\n\t\tif (entity._dirtyWorld) {\n\t\t\tlet dirty = entity._dirtyLocal;\n\t\t\tlet parent = entity;\n\t\t\twhile (parent && !dirty) {\n\t\t\t\tif (parent.collision && parent.collision === this._compoundParent) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\tif (parent._dirtyLocal) {\n\t\t\t\t\tdirty = true;\n\t\t\t\t}\n\t\t\t\tparent = parent.parent;\n\t\t\t}\n\t\t\tif (dirty) {\n\t\t\t\tentity.forEach(this.system.implementations.compound._updateEachDescendantTransform, entity);\n\t\t\t\tconst bodyComponent = this._compoundParent.entity.rigidbody;\n\t\t\t\tif (bodyComponent) {\n\t\t\t\t\tbodyComponent.activate();\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\tgetShapePosition() {\n\t\tconst pos = this.entity.getPosition();\n\t\tif (this._hasOffset) {\n\t\t\tconst rot = this.entity.getRotation();\n\t\t\tconst lo = this.data.linearOffset;\n\t\t\t_quat.copy(rot).transformVector(lo, _vec3);\n\t\t\treturn _vec3.add(pos);\n\t\t}\n\t\treturn pos;\n\t}\n\tgetShapeRotation() {\n\t\tconst rot = this.entity.getRotation();\n\t\tif (this._hasOffset) {\n\t\t\treturn _quat.copy(rot).mul(this.data.angularOffset);\n\t\t}\n\t\treturn rot;\n\t}\n\tonEnable() {\n\t\tif (this.data.type === 'mesh' && (this.data.asset || this.data.renderAsset) && this.data.initialized) {\n\t\t\tconst asset = this.system.app.assets.get(this.data.asset || this.data.renderAsset);\n\t\t\tif (asset && (!asset.resource || !this.data.shape)) {\n\t\t\t\tthis.system.recreatePhysicalShapes(this);\n\t\t\t\treturn;\n\t\t\t}\n\t\t}\n\t\tif (this.entity.rigidbody) {\n\t\t\tif (this.entity.rigidbody.enabled) {\n\t\t\t\tthis.entity.rigidbody.enableSimulation();\n\t\t\t}\n\t\t} else if (this._compoundParent && this !== this._compoundParent) {\n\t\t\tif (this._compoundParent.shape.getNumChildShapes() === 0) {\n\t\t\t\tthis.system.recreatePhysicalShapes(this._compoundParent);\n\t\t\t} else {\n\t\t\t\tconst transform = this.system._getNodeTransform(this.entity, this._compoundParent.entity);\n\t\t\t\tthis._compoundParent.shape.addChildShape(transform, this.data.shape);\n\t\t\t\tAmmo.destroy(transform);\n\t\t\t\tif (this._compoundParent.entity.rigidbody) {\n\t\t\t\t\tthis._compoundParent.entity.rigidbody.activate();\n\t\t\t\t}\n\t\t\t}\n\t\t} else if (this.entity.trigger) {\n\t\t\tthis.entity.trigger.enable();\n\t\t}\n\t}\n\tonDisable() {\n\t\tif (this.entity.rigidbody) {\n\t\t\tthis.entity.rigidbody.disableSimulation();\n\t\t} else if (this._compoundParent && this !== this._compoundParent) {\n\t\t\tif (!this._compoundParent.entity._destroying) {\n\t\t\t\tthis.system._removeCompoundChild(this._compoundParent, this.data.shape);\n\t\t\t\tif (this._compoundParent.entity.rigidbody) {\n\t\t\t\t\tthis._compoundParent.entity.rigidbody.activate();\n\t\t\t\t}\n\t\t\t}\n\t\t} else if (this.entity.trigger) {\n\t\t\tthis.entity.trigger.disable();\n\t\t}\n\t}\n\tonBeforeRemove() {\n\t\tif (this.asset) {\n\t\t\tthis.asset = null;\n\t\t}\n\t\tif (this.renderAsset) {\n\t\t\tthis.renderAsset = null;\n\t\t}\n\t\tthis.entity.off('insert', this._onInsert, this);\n\t\tthis.off();\n\t}\n}\nCollisionComponent.EVENT_CONTACT = 'contact';\nCollisionComponent.EVENT_COLLISIONSTART = 'collisionstart';\nCollisionComponent.EVENT_COLLISIONEND = 'collisionend';\nCollisionComponent.EVENT_TRIGGERENTER = 'triggerenter';\nCollisionComponent.EVENT_TRIGGERLEAVE = 'triggerleave';\n\nexport { CollisionComponent };\n", "import { Quat } from '../../../core/math/quat.js';\nimport { Vec3 } from '../../../core/math/vec3.js';\n\nclass CollisionComponentData {\n\tconstructor() {\n\t\tthis.enabled = true;\n\t\tthis.type = 'box';\n\t\tthis.halfExtents = new Vec3(0.5, 0.5, 0.5);\n\t\tthis.linearOffset = new Vec3();\n\t\tthis.angularOffset = new Quat();\n\t\tthis.radius = 0.5;\n\t\tthis.axis = 1;\n\t\tthis.height = 2;\n\t\tthis.convexHull = false;\n\t\tthis.asset = null;\n\t\tthis.renderAsset = null;\n\t\tthis.checkVertexDuplicates = true;\n\t\tthis.shape = null;\n\t\tthis.model = null;\n\t\tthis.render = null;\n\t\tthis.initialized = false;\n\t}\n}\n\nexport { CollisionComponentData };\n", "const BODYTYPE_STATIC = 'static';\nconst BODYTYPE_DYNAMIC = 'dynamic';\nconst BODYTYPE_KINEMATIC = 'kinematic';\nconst BODYFLAG_STATIC_OBJECT = 1;\nconst BODYFLAG_KINEMATIC_OBJECT = 2;\nconst BODYFLAG_NORESPONSE_OBJECT = 4;\nconst BODYSTATE_ACTIVE_TAG = 1;\nconst BODYSTATE_ISLAND_SLEEPING = 2;\nconst BODYSTATE_WANTS_DEACTIVATION = 3;\nconst BODYSTATE_DISABLE_DEACTIVATION = 4;\nconst BODYSTATE_DISABLE_SIMULATION = 5;\nconst BODYGROUP_NONE = 0;\nconst BODYGROUP_DEFAULT = 1;\nconst BODYGROUP_DYNAMIC = 1;\nconst BODYGROUP_STATIC = 2;\nconst BODYGROUP_KINEMATIC = 4;\nconst BODYGROUP_ENGINE_1 = 8;\nconst BODYGROUP_TRIGGER = 16;\nconst BODYGROUP_ENGINE_2 = 32;\nconst BODYGROUP_ENGINE_3 = 64;\nconst BODYGROUP_USER_1 = 128;\nconst BODYGROUP_USER_2 = 256;\nconst BODYGROUP_USER_3 = 512;\nconst BODYGROUP_USER_4 = 1024;\nconst BODYGROUP_USER_5 = 2048;\nconst BODYGROUP_USER_6 = 4096;\nconst BODYGROUP_USER_7 = 8192;\nconst BODYGROUP_USER_8 = 16384;\nconst BODYMASK_NONE = 0;\nconst BODYMASK_ALL = 65535;\nconst BODYMASK_STATIC = 2;\nconst BODYMASK_NOT_STATIC = 65535 ^ 2;\nconst BODYMASK_NOT_STATIC_KINEMATIC = 65535 ^ (2 | 4);\n\nexport { BODYFLAG_KINEMATIC_OBJECT, BODYFLAG_NORESPONSE_OBJECT, BODYFLAG_STATIC_OBJECT, BODYGROUP_DEFAULT, BODYGROUP_DYNAMIC, BODYGROUP_ENGINE_1, BODYGROUP_ENGINE_2, BODYGROUP_ENGINE_3, BODYGROUP_KINEMATIC, BODYGROUP_NONE, BODYGROUP_STATIC, BODYGROUP_TRIGGER, BODYGROUP_USER_1, BODYGROUP_USER_2, BODYGROUP_USER_3, BODYGROUP_USER_4, BODYGROUP_USER_5, BODYGROUP_USER_6, BODYGROUP_USER_7, BODYGROUP_USER_8, BODYMASK_ALL, BODYMASK_NONE, BODYMASK_NOT_STATIC, BODYMASK_NOT_STATIC_KINEMATIC, BODYMASK_STATIC, BODYSTATE_ACTIVE_TAG, BODYSTATE_DISABLE_DEACTIVATION, BODYSTATE_DISABLE_SIMULATION, BODYSTATE_ISLAND_SLEEPING, BODYSTATE_WANTS_DEACTIVATION, BODYTYPE_DYNAMIC, BODYTYPE_KINEMATIC, BODYTYPE_STATIC };\n", "import { BODYFLAG_NORESPONSE_OBJECT, BODYGROUP_TRIGGER, BODYMASK_NOT_STATIC, BODYSTATE_ACTIVE_TAG, BODYSTATE_DISABLE_SIMULATION } from '../rigid-body/constants.js';\n\nlet _ammoVec1, _ammoQuat, _ammoTransform;\nclass Trigger {\n\tconstructor(app, component, data) {\n\t\tthis.entity = component.entity;\n\t\tthis.component = component;\n\t\tthis.app = app;\n\t\tif (typeof Ammo !== 'undefined' && !_ammoVec1) {\n\t\t\t_ammoVec1 = new Ammo.btVector3();\n\t\t\t_ammoQuat = new Ammo.btQuaternion();\n\t\t\t_ammoTransform = new Ammo.btTransform();\n\t\t}\n\t\tthis.initialize(data);\n\t}\n\tinitialize(data) {\n\t\tconst entity = this.entity;\n\t\tconst shape = data.shape;\n\t\tif (shape && typeof Ammo !== 'undefined') {\n\t\t\tif (entity.trigger) {\n\t\t\t\tentity.trigger.destroy();\n\t\t\t}\n\t\t\tconst mass = 1;\n\t\t\tconst component = this.component;\n\t\t\tif (component) {\n\t\t\t\tconst bodyPos = component.getShapePosition();\n\t\t\t\tconst bodyRot = component.getShapeRotation();\n\t\t\t\t_ammoVec1.setValue(bodyPos.x, bodyPos.y, bodyPos.z);\n\t\t\t\t_ammoQuat.setValue(bodyRot.x, bodyRot.y, bodyRot.z, bodyRot.w);\n\t\t\t} else {\n\t\t\t\tconst pos = entity.getPosition();\n\t\t\t\tconst rot = entity.getRotation();\n\t\t\t\t_ammoVec1.setValue(pos.x, pos.y, pos.z);\n\t\t\t\t_ammoQuat.setValue(rot.x, rot.y, rot.z, rot.w);\n\t\t\t}\n\t\t\t_ammoTransform.setOrigin(_ammoVec1);\n\t\t\t_ammoTransform.setRotation(_ammoQuat);\n\t\t\tconst body = this.app.systems.rigidbody.createBody(mass, shape, _ammoTransform);\n\t\t\tbody.setRestitution(0);\n\t\t\tbody.setFriction(0);\n\t\t\tbody.setDamping(0, 0);\n\t\t\t_ammoVec1.setValue(0, 0, 0);\n\t\t\tbody.setLinearFactor(_ammoVec1);\n\t\t\tbody.setAngularFactor(_ammoVec1);\n\t\t\tbody.setCollisionFlags(body.getCollisionFlags() | BODYFLAG_NORESPONSE_OBJECT);\n\t\t\tbody.entity = entity;\n\t\t\tthis.body = body;\n\t\t\tif (this.component.enabled && entity.enabled) {\n\t\t\t\tthis.enable();\n\t\t\t}\n\t\t}\n\t}\n\tdestroy() {\n\t\tconst body = this.body;\n\t\tif (!body) return;\n\t\tthis.disable();\n\t\tthis.app.systems.rigidbody.destroyBody(body);\n\t}\n\t_getEntityTransform(transform) {\n\t\tconst component = this.component;\n\t\tif (component) {\n\t\t\tconst bodyPos = component.getShapePosition();\n\t\t\tconst bodyRot = component.getShapeRotation();\n\t\t\t_ammoVec1.setValue(bodyPos.x, bodyPos.y, bodyPos.z);\n\t\t\t_ammoQuat.setValue(bodyRot.x, bodyRot.y, bodyRot.z, bodyRot.w);\n\t\t} else {\n\t\t\tconst pos = this.entity.getPosition();\n\t\t\tconst rot = this.entity.getRotation();\n\t\t\t_ammoVec1.setValue(pos.x, pos.y, pos.z);\n\t\t\t_ammoQuat.setValue(rot.x, rot.y, rot.z, rot.w);\n\t\t}\n\t\ttransform.setOrigin(_ammoVec1);\n\t\ttransform.setRotation(_ammoQuat);\n\t}\n\tupdateTransform() {\n\t\tthis._getEntityTransform(_ammoTransform);\n\t\tconst body = this.body;\n\t\tbody.setWorldTransform(_ammoTransform);\n\t\tbody.activate();\n\t}\n\tenable() {\n\t\tconst body = this.body;\n\t\tif (!body) return;\n\t\tconst systems = this.app.systems;\n\t\tsystems.rigidbody.addBody(body, BODYGROUP_TRIGGER, BODYMASK_NOT_STATIC ^ BODYGROUP_TRIGGER);\n\t\tsystems.rigidbody._triggers.push(this);\n\t\tbody.forceActivationState(BODYSTATE_ACTIVE_TAG);\n\t\tthis.updateTransform();\n\t}\n\tdisable() {\n\t\tconst body = this.body;\n\t\tif (!body) return;\n\t\tconst systems = this.app.systems;\n\t\tconst idx = systems.rigidbody._triggers.indexOf(this);\n\t\tif (idx > -1) {\n\t\t\tsystems.rigidbody._triggers.splice(idx, 1);\n\t\t}\n\t\tsystems.rigidbody.removeBody(body);\n\t\tbody.forceActivationState(BODYSTATE_DISABLE_SIMULATION);\n\t}\n}\n\nexport { Trigger };\n", "import { Mat4 } from '../../../core/math/mat4.js';\nimport { Quat } from '../../../core/math/quat.js';\nimport { Vec3 } from '../../../core/math/vec3.js';\nimport { SEMANTIC_POSITION } from '../../../platform/graphics/constants.js';\nimport { GraphNode } from '../../../scene/graph-node.js';\nimport { Model } from '../../../scene/model.js';\nimport { ComponentSystem } from '../system.js';\nimport { CollisionComponent } from './component.js';\nimport { CollisionComponentData } from './data.js';\nimport { Trigger } from './trigger.js';\n\nconst mat4 = new Mat4();\nconst p1 = new Vec3();\nconst p2 = new Vec3();\nconst quat = new Quat();\nconst tempGraphNode = new GraphNode();\nconst _schema = ['enabled', 'type', 'halfExtents', 'linearOffset', 'angularOffset', 'radius', 'axis', 'height', 'convexHull', 'asset', 'renderAsset', 'shape', 'model', 'render', 'checkVertexDuplicates'];\nclass CollisionSystemImpl {\n\tconstructor(system) {\n\t\tthis.system = system;\n\t}\n\tbeforeInitialize(component, data) {\n\t\tdata.shape = null;\n\t\tdata.model = new Model();\n\t\tdata.model.graph = new GraphNode();\n\t}\n\tafterInitialize(component, data) {\n\t\tthis.recreatePhysicalShapes(component);\n\t\tcomponent.data.initialized = true;\n\t}\n\treset(component, data) {\n\t\tthis.beforeInitialize(component, data);\n\t\tthis.afterInitialize(component, data);\n\t}\n\trecreatePhysicalShapes(component) {\n\t\tconst entity = component.entity;\n\t\tconst data = component.data;\n\t\tif (typeof Ammo !== 'undefined') {\n\t\t\tif (entity.trigger) {\n\t\t\t\tentity.trigger.destroy();\n\t\t\t\tdelete entity.trigger;\n\t\t\t}\n\t\t\tif (data.shape) {\n\t\t\t\tif (component._compoundParent) {\n\t\t\t\t\tthis.system._removeCompoundChild(component._compoundParent, data.shape);\n\t\t\t\t\tif (component._compoundParent.entity.rigidbody) component._compoundParent.entity.rigidbody.activate();\n\t\t\t\t}\n\t\t\t\tthis.destroyShape(data);\n\t\t\t}\n\t\t\tdata.shape = this.createPhysicalShape(component.entity, data);\n\t\t\tconst firstCompoundChild = !component._compoundParent;\n\t\t\tif (data.type === 'compound' && (!component._compoundParent || component === component._compoundParent)) {\n\t\t\t\tcomponent._compoundParent = component;\n\t\t\t\tentity.forEach(this._addEachDescendant, component);\n\t\t\t} else if (data.type !== 'compound') {\n\t\t\t\tif (component._compoundParent && component === component._compoundParent) {\n\t\t\t\t\tentity.forEach(this.system.implementations.compound._updateEachDescendant, component);\n\t\t\t\t}\n\t\t\t\tif (!component.rigidbody) {\n\t\t\t\t\tcomponent._compoundParent = null;\n\t\t\t\t\tlet parent = entity.parent;\n\t\t\t\t\twhile (parent) {\n\t\t\t\t\t\tif (parent.collision && parent.collision.type === 'compound') {\n\t\t\t\t\t\t\tcomponent._compoundParent = parent.collision;\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tparent = parent.parent;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (component._compoundParent) {\n\t\t\t\tif (component !== component._compoundParent) {\n\t\t\t\t\tif (firstCompoundChild && component._compoundParent.shape.getNumChildShapes() === 0) {\n\t\t\t\t\t\tthis.system.recreatePhysicalShapes(component._compoundParent);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tthis.system.updateCompoundChildTransform(entity);\n\t\t\t\t\t\tif (component._compoundParent.entity.rigidbody) component._compoundParent.entity.rigidbody.activate();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (entity.rigidbody) {\n\t\t\t\tentity.rigidbody.disableSimulation();\n\t\t\t\tentity.rigidbody.createBody();\n\t\t\t\tif (entity.enabled && entity.rigidbody.enabled) {\n\t\t\t\t\tentity.rigidbody.enableSimulation();\n\t\t\t\t}\n\t\t\t} else if (!component._compoundParent) {\n\t\t\t\tif (!entity.trigger) {\n\t\t\t\t\tentity.trigger = new Trigger(this.system.app, component, data);\n\t\t\t\t} else {\n\t\t\t\t\tentity.trigger.initialize(data);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\tcreatePhysicalShape(entity, data) {\n\t\treturn undefined;\n\t}\n\tupdateTransform(component, position, rotation, scale) {\n\t\tif (component.entity.trigger) {\n\t\t\tcomponent.entity.trigger.updateTransform();\n\t\t}\n\t}\n\tdestroyShape(data) {\n\t\tif (data.shape) {\n\t\t\tAmmo.destroy(data.shape);\n\t\t\tdata.shape = null;\n\t\t}\n\t}\n\tbeforeRemove(entity, component) {\n\t\tif (component.data.shape) {\n\t\t\tif (component._compoundParent && !component._compoundParent.entity._destroying) {\n\t\t\t\tthis.system._removeCompoundChild(component._compoundParent, component.data.shape);\n\t\t\t\tif (component._compoundParent.entity.rigidbody) component._compoundParent.entity.rigidbody.activate();\n\t\t\t}\n\t\t\tcomponent._compoundParent = null;\n\t\t\tthis.destroyShape(component.data);\n\t\t}\n\t}\n\tremove(entity, data) {\n\t\tif (entity.rigidbody && entity.rigidbody.body) {\n\t\t\tentity.rigidbody.disableSimulation();\n\t\t}\n\t\tif (entity.trigger) {\n\t\t\tentity.trigger.destroy();\n\t\t\tdelete entity.trigger;\n\t\t}\n\t}\n\tclone(entity, clone) {\n\t\tconst src = this.system.store[entity.getGuid()];\n\t\tconst data = {\n\t\t\tenabled: src.data.enabled,\n\t\t\ttype: src.data.type,\n\t\t\thalfExtents: [src.data.halfExtents.x, src.data.halfExtents.y, src.data.halfExtents.z],\n\t\t\tlinearOffset: [src.data.linearOffset.x, src.data.linearOffset.y, src.data.linearOffset.z],\n\t\t\tangularOffset: [src.data.angularOffset.x, src.data.angularOffset.y, src.data.angularOffset.z, src.data.angularOffset.w],\n\t\t\tradius: src.data.radius,\n\t\t\taxis: src.data.axis,\n\t\t\theight: src.data.height,\n\t\t\tconvexHull: src.data.convexHull,\n\t\t\tasset: src.data.asset,\n\t\t\trenderAsset: src.data.renderAsset,\n\t\t\tmodel: src.data.model,\n\t\t\trender: src.data.render,\n\t\t\tcheckVertexDuplicates: src.data.checkVertexDuplicates\n\t\t};\n\t\treturn this.system.addComponent(clone, data);\n\t}\n}\nclass CollisionBoxSystemImpl extends CollisionSystemImpl {\n\tcreatePhysicalShape(entity, data) {\n\t\tif (typeof Ammo !== 'undefined') {\n\t\t\tconst he = data.halfExtents;\n\t\t\tconst ammoHe = new Ammo.btVector3(he ? he.x : 0.5, he ? he.y : 0.5, he ? he.z : 0.5);\n\t\t\tconst shape = new Ammo.btBoxShape(ammoHe);\n\t\t\tAmmo.destroy(ammoHe);\n\t\t\treturn shape;\n\t\t}\n\t\treturn undefined;\n\t}\n}\nclass CollisionSphereSystemImpl extends CollisionSystemImpl {\n\tcreatePhysicalShape(entity, data) {\n\t\tif (typeof Ammo !== 'undefined') {\n\t\t\treturn new Ammo.btSphereShape(data.radius);\n\t\t}\n\t\treturn undefined;\n\t}\n}\nclass CollisionCapsuleSystemImpl extends CollisionSystemImpl {\n\tcreatePhysicalShape(entity, data) {\n\t\tvar _data$axis, _data$radius, _data$height;\n\t\tconst axis = (_data$axis = data.axis) != null ? _data$axis : 1;\n\t\tconst radius = (_data$radius = data.radius) != null ? _data$radius : 0.5;\n\t\tconst height = Math.max(((_data$height = data.height) != null ? _data$height : 2) - 2 * radius, 0);\n\t\tlet shape = null;\n\t\tif (typeof Ammo !== 'undefined') {\n\t\t\tswitch (axis) {\n\t\t\t\tcase 0:\n\t\t\t\t\tshape = new Ammo.btCapsuleShapeX(radius, height);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 1:\n\t\t\t\t\tshape = new Ammo.btCapsuleShape(radius, height);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 2:\n\t\t\t\t\tshape = new Ammo.btCapsuleShapeZ(radius, height);\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\treturn shape;\n\t}\n}\nclass CollisionCylinderSystemImpl extends CollisionSystemImpl {\n\tcreatePhysicalShape(entity, data) {\n\t\tvar _data$axis2, _data$radius2, _data$height2;\n\t\tconst axis = (_data$axis2 = data.axis) != null ? _data$axis2 : 1;\n\t\tconst radius = (_data$radius2 = data.radius) != null ? _data$radius2 : 0.5;\n\t\tconst height = (_data$height2 = data.height) != null ? _data$height2 : 1;\n\t\tlet halfExtents = null;\n\t\tlet shape = null;\n\t\tif (typeof Ammo !== 'undefined') {\n\t\t\tswitch (axis) {\n\t\t\t\tcase 0:\n\t\t\t\t\thalfExtents = new Ammo.btVector3(height * 0.5, radius, radius);\n\t\t\t\t\tshape = new Ammo.btCylinderShapeX(halfExtents);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 1:\n\t\t\t\t\thalfExtents = new Ammo.btVector3(radius, height * 0.5, radius);\n\t\t\t\t\tshape = new Ammo.btCylinderShape(halfExtents);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 2:\n\t\t\t\t\thalfExtents = new Ammo.btVector3(radius, radius, height * 0.5);\n\t\t\t\t\tshape = new Ammo.btCylinderShapeZ(halfExtents);\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\tif (halfExtents) Ammo.destroy(halfExtents);\n\t\treturn shape;\n\t}\n}\nclass CollisionConeSystemImpl extends CollisionSystemImpl {\n\tcreatePhysicalShape(entity, data) {\n\t\tvar _data$axis3, _data$radius3, _data$height3;\n\t\tconst axis = (_data$axis3 = data.axis) != null ? _data$axis3 : 1;\n\t\tconst radius = (_data$radius3 = data.radius) != null ? _data$radius3 : 0.5;\n\t\tconst height = (_data$height3 = data.height) != null ? _data$height3 : 1;\n\t\tlet shape = null;\n\t\tif (typeof Ammo !== 'undefined') {\n\t\t\tswitch (axis) {\n\t\t\t\tcase 0:\n\t\t\t\t\tshape = new Ammo.btConeShapeX(radius, height);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 1:\n\t\t\t\t\tshape = new Ammo.btConeShape(radius, height);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 2:\n\t\t\t\t\tshape = new Ammo.btConeShapeZ(radius, height);\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\treturn shape;\n\t}\n}\nclass CollisionMeshSystemImpl extends CollisionSystemImpl {\n\tbeforeInitialize(component, data) {}\n\tcreateAmmoHull(mesh, node, shape, scale) {\n\t\tconst hull = new Ammo.btConvexHullShape();\n\t\tconst point = new Ammo.btVector3();\n\t\tconst positions = [];\n\t\tmesh.getPositions(positions);\n\t\tfor (let i = 0; i < positions.length; i += 3) {\n\t\t\tpoint.setValue(positions[i] * scale.x, positions[i + 1] * scale.y, positions[i + 2] * scale.z);\n\t\t\thull.addPoint(point, false);\n\t\t}\n\t\tAmmo.destroy(point);\n\t\thull.recalcLocalAabb();\n\t\thull.setMargin(0.01);\n\t\tshape.addChildShape(this.system._getNodeTransform(node), hull);\n\t}\n\tcreateAmmoMesh(mesh, node, shape, scale, checkDupes = true) {\n\t\tconst system = this.system;\n\t\tlet triMesh;\n\t\tif (system._triMeshCache[mesh.id]) {\n\t\t\ttriMesh = system._triMeshCache[mesh.id];\n\t\t} else {\n\t\t\tconst vb = mesh.vertexBuffer;\n\t\t\tconst format = vb.getFormat();\n\t\t\tlet stride, positions;\n\t\t\tfor (let _i = 0; _i < format.elements.length; _i++) {\n\t\t\t\tconst element = format.elements[_i];\n\t\t\t\tif (element.name === SEMANTIC_POSITION) {\n\t\t\t\t\tpositions = new Float32Array(vb.lock(), element.offset);\n\t\t\t\t\tstride = element.stride / 4;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\tconst indices = [];\n\t\t\tmesh.getIndices(indices);\n\t\t\tconst numTriangles = mesh.primitive[0].count / 3;\n\t\t\tconst v1 = new Ammo.btVector3();\n\t\t\tlet i1, i2, i3;\n\t\t\tconst base = mesh.primitive[0].base;\n\t\t\ttriMesh = new Ammo.btTriangleMesh();\n\t\t\tsystem._triMeshCache[mesh.id] = triMesh;\n\t\t\tconst vertexCache = new Map();\n\t\t\tconst indexedArray = triMesh.getIndexedMeshArray();\n\t\t\tindexedArray.at(0).m_numTriangles = numTriangles;\n\t\t\tconst sx = scale ? scale.x : 1;\n\t\t\tconst sy = scale ? scale.y : 1;\n\t\t\tconst sz = scale ? scale.z : 1;\n\t\t\tconst addVertex = index => {\n\t\t\t\tconst x = positions[index * stride] * sx;\n\t\t\t\tconst y = positions[index * stride + 1] * sy;\n\t\t\t\tconst z = positions[index * stride + 2] * sz;\n\t\t\t\tlet idx;\n\t\t\t\tif (checkDupes) {\n\t\t\t\t\tconst str = `${x}:${y}:${z}`;\n\t\t\t\t\tidx = vertexCache.get(str);\n\t\t\t\t\tif (idx !== undefined) {\n\t\t\t\t\t\treturn idx;\n\t\t\t\t\t}\n\t\t\t\t\tv1.setValue(x, y, z);\n\t\t\t\t\tidx = triMesh.findOrAddVertex(v1, false);\n\t\t\t\t\tvertexCache.set(str, idx);\n\t\t\t\t} else {\n\t\t\t\t\tv1.setValue(x, y, z);\n\t\t\t\t\tidx = triMesh.findOrAddVertex(v1, false);\n\t\t\t\t}\n\t\t\t\treturn idx;\n\t\t\t};\n\t\t\tfor (var i = 0; i < numTriangles; i++) {\n\t\t\t\ti1 = addVertex(indices[base + i * 3]);\n\t\t\t\ti2 = addVertex(indices[base + i * 3 + 1]);\n\t\t\t\ti3 = addVertex(indices[base + i * 3 + 2]);\n\t\t\t\ttriMesh.addIndex(i1);\n\t\t\t\ttriMesh.addIndex(i2);\n\t\t\t\ttriMesh.addIndex(i3);\n\t\t\t}\n\t\t\tAmmo.destroy(v1);\n\t\t}\n\t\tconst triMeshShape = new Ammo.btBvhTriangleMeshShape(triMesh, true);\n\t\tif (!scale) {\n\t\t\tconst scaling = system._getNodeScaling(node);\n\t\t\ttriMeshShape.setLocalScaling(scaling);\n\t\t\tAmmo.destroy(scaling);\n\t\t}\n\t\tconst transform = system._getNodeTransform(node);\n\t\tshape.addChildShape(transform, triMeshShape);\n\t\tAmmo.destroy(transform);\n\t}\n\tcreatePhysicalShape(entity, data) {\n\t\tif (typeof Ammo === 'undefined') return undefined;\n\t\tif (data.model || data.render) {\n\t\t\tconst shape = new Ammo.btCompoundShape();\n\t\t\tconst entityTransform = entity.getWorldTransform();\n\t\t\tconst scale = entityTransform.getScale();\n\t\t\tif (data.model) {\n\t\t\t\tconst meshInstances = data.model.meshInstances;\n\t\t\t\tfor (let i = 0; i < meshInstances.length; i++) {\n\t\t\t\t\tthis.createAmmoMesh(meshInstances[i].mesh, meshInstances[i].node, shape, null, data.checkVertexDuplicates);\n\t\t\t\t}\n\t\t\t\tconst vec = new Ammo.btVector3(scale.x, scale.y, scale.z);\n\t\t\t\tshape.setLocalScaling(vec);\n\t\t\t\tAmmo.destroy(vec);\n\t\t\t} else if (data.render) {\n\t\t\t\tconst meshes = data.render.meshes;\n\t\t\t\tfor (let i = 0; i < meshes.length; i++) {\n\t\t\t\t\tif (data.convexHull) {\n\t\t\t\t\t\tthis.createAmmoHull(meshes[i], tempGraphNode, shape, scale);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tthis.createAmmoMesh(meshes[i], tempGraphNode, shape, scale, data.checkVertexDuplicates);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn shape;\n\t\t}\n\t\treturn undefined;\n\t}\n\trecreatePhysicalShapes(component) {\n\t\tconst data = component.data;\n\t\tif (data.renderAsset || data.asset) {\n\t\t\tif (component.enabled && component.entity.enabled) {\n\t\t\t\tthis.loadAsset(component, data.renderAsset || data.asset, data.renderAsset ? 'render' : 'model');\n\t\t\t\treturn;\n\t\t\t}\n\t\t}\n\t\tthis.doRecreatePhysicalShape(component);\n\t}\n\tloadAsset(component, id, property) {\n\t\tconst data = component.data;\n\t\tconst assets = this.system.app.assets;\n\t\tconst previousPropertyValue = data[property];\n\t\tconst onAssetFullyReady = asset => {\n\t\t\tif (data[property] !== previousPropertyValue) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tdata[property] = asset.resource;\n\t\t\tthis.doRecreatePhysicalShape(component);\n\t\t};\n\t\tconst loadAndHandleAsset = asset => {\n\t\t\tasset.ready(asset => {\n\t\t\t\tif (asset.data.containerAsset) {\n\t\t\t\t\tconst containerAsset = assets.get(asset.data.containerAsset);\n\t\t\t\t\tif (containerAsset.loaded) {\n\t\t\t\t\t\tonAssetFullyReady(asset);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tcontainerAsset.ready(() => {\n\t\t\t\t\t\t\tonAssetFullyReady(asset);\n\t\t\t\t\t\t});\n\t\t\t\t\t\tassets.load(containerAsset);\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tonAssetFullyReady(asset);\n\t\t\t\t}\n\t\t\t});\n\t\t\tassets.load(asset);\n\t\t};\n\t\tconst asset = assets.get(id);\n\t\tif (asset) {\n\t\t\tloadAndHandleAsset(asset);\n\t\t} else {\n\t\t\tassets.once('add:' + id, loadAndHandleAsset);\n\t\t}\n\t}\n\tdoRecreatePhysicalShape(component) {\n\t\tconst entity = component.entity;\n\t\tconst data = component.data;\n\t\tif (data.model || data.render) {\n\t\t\tthis.destroyShape(data);\n\t\t\tdata.shape = this.createPhysicalShape(entity, data);\n\t\t\tif (entity.rigidbody) {\n\t\t\t\tentity.rigidbody.disableSimulation();\n\t\t\t\tentity.rigidbody.createBody();\n\t\t\t\tif (entity.enabled && entity.rigidbody.enabled) {\n\t\t\t\t\tentity.rigidbody.enableSimulation();\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tif (!entity.trigger) {\n\t\t\t\t\tentity.trigger = new Trigger(this.system.app, component, data);\n\t\t\t\t} else {\n\t\t\t\t\tentity.trigger.initialize(data);\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tthis.beforeRemove(entity, component);\n\t\t\tthis.remove(entity, data);\n\t\t}\n\t}\n\tupdateTransform(component, position, rotation, scale) {\n\t\tif (component.shape) {\n\t\t\tconst entityTransform = component.entity.getWorldTransform();\n\t\t\tconst worldScale = entityTransform.getScale();\n\t\t\tconst previousScale = component.shape.getLocalScaling();\n\t\t\tif (worldScale.x !== previousScale.x() || worldScale.y !== previousScale.y() || worldScale.z !== previousScale.z()) {\n\t\t\t\tthis.doRecreatePhysicalShape(component);\n\t\t\t}\n\t\t}\n\t\tsuper.updateTransform(component, position, rotation, scale);\n\t}\n\tdestroyShape(data) {\n\t\tif (!data.shape) return;\n\t\tconst numShapes = data.shape.getNumChildShapes();\n\t\tfor (let i = 0; i < numShapes; i++) {\n\t\t\tconst shape = data.shape.getChildShape(i);\n\t\t\tAmmo.destroy(shape);\n\t\t}\n\t\tAmmo.destroy(data.shape);\n\t\tdata.shape = null;\n\t}\n}\nclass CollisionCompoundSystemImpl extends CollisionSystemImpl {\n\tcreatePhysicalShape(entity, data) {\n\t\tif (typeof Ammo !== 'undefined') {\n\t\t\treturn new Ammo.btCompoundShape();\n\t\t}\n\t\treturn undefined;\n\t}\n\t_addEachDescendant(entity) {\n\t\tif (!entity.collision || entity.rigidbody) return;\n\t\tentity.collision._compoundParent = this;\n\t\tif (entity !== this.entity) {\n\t\t\tentity.collision.system.recreatePhysicalShapes(entity.collision);\n\t\t}\n\t}\n\t_updateEachDescendant(entity) {\n\t\tif (!entity.collision) return;\n\t\tif (entity.collision._compoundParent !== this) return;\n\t\tentity.collision._compoundParent = null;\n\t\tif (entity !== this.entity && !entity.rigidbody) {\n\t\t\tentity.collision.system.recreatePhysicalShapes(entity.collision);\n\t\t}\n\t}\n\t_updateEachDescendantTransform(entity) {\n\t\tif (!entity.collision || entity.collision._compoundParent !== this.collision._compoundParent) return;\n\t\tthis.collision.system.updateCompoundChildTransform(entity);\n\t}\n}\nclass CollisionComponentSystem extends ComponentSystem {\n\tconstructor(app) {\n\t\tsuper(app);\n\t\tthis.id = 'collision';\n\t\tthis.ComponentType = CollisionComponent;\n\t\tthis.DataType = CollisionComponentData;\n\t\tthis.schema = _schema;\n\t\tthis.implementations = {};\n\t\tthis._triMeshCache = {};\n\t\tthis.on('beforeremove', this.onBeforeRemove, this);\n\t\tthis.on('remove', this.onRemove, this);\n\t}\n\tinitializeComponentData(component, _data, properties) {\n\t\tproperties = ['type', 'halfExtents', 'radius', 'axis', 'height', 'convexHull', 'shape', 'model', 'asset', 'render', 'renderAsset', 'enabled', 'linearOffset', 'angularOffset', 'checkVertexDuplicates'];\n\t\tconst data = {};\n\t\tfor (let i = 0, len = properties.length; i < len; i++) {\n\t\t\tconst property = properties[i];\n\t\t\tdata[property] = _data[property];\n\t\t}\n\t\tlet idx;\n\t\tif (_data.hasOwnProperty('asset')) {\n\t\t\tidx = properties.indexOf('model');\n\t\t\tif (idx !== -1) {\n\t\t\t\tproperties.splice(idx, 1);\n\t\t\t}\n\t\t\tidx = properties.indexOf('render');\n\t\t\tif (idx !== -1) {\n\t\t\t\tproperties.splice(idx, 1);\n\t\t\t}\n\t\t} else if (_data.hasOwnProperty('model')) {\n\t\t\tidx = properties.indexOf('asset');\n\t\t\tif (idx !== -1) {\n\t\t\t\tproperties.splice(idx, 1);\n\t\t\t}\n\t\t}\n\t\tif (!data.type) {\n\t\t\tdata.type = component.data.type;\n\t\t}\n\t\tcomponent.data.type = data.type;\n\t\tif (Array.isArray(data.halfExtents)) {\n\t\t\tdata.halfExtents = new Vec3(data.halfExtents);\n\t\t}\n\t\tif (Array.isArray(data.linearOffset)) {\n\t\t\tdata.linearOffset = new Vec3(data.linearOffset);\n\t\t}\n\t\tif (Array.isArray(data.angularOffset)) {\n\t\t\tconst values = data.angularOffset;\n\t\t\tif (values.length === 3) {\n\t\t\t\tdata.angularOffset = new Quat().setFromEulerAngles(values[0], values[1], values[2]);\n\t\t\t} else {\n\t\t\t\tdata.angularOffset = new Quat(data.angularOffset);\n\t\t\t}\n\t\t}\n\t\tconst impl = this._createImplementation(data.type);\n\t\timpl.beforeInitialize(component, data);\n\t\tsuper.initializeComponentData(component, data, properties);\n\t\timpl.afterInitialize(component, data);\n\t}\n\t_createImplementation(type) {\n\t\tif (this.implementations[type] === undefined) {\n\t\t\tlet impl;\n\t\t\tswitch (type) {\n\t\t\t\tcase 'box':\n\t\t\t\t\timpl = new CollisionBoxSystemImpl(this);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 'sphere':\n\t\t\t\t\timpl = new CollisionSphereSystemImpl(this);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 'capsule':\n\t\t\t\t\timpl = new CollisionCapsuleSystemImpl(this);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 'cylinder':\n\t\t\t\t\timpl = new CollisionCylinderSystemImpl(this);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 'cone':\n\t\t\t\t\timpl = new CollisionConeSystemImpl(this);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 'mesh':\n\t\t\t\t\timpl = new CollisionMeshSystemImpl(this);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 'compound':\n\t\t\t\t\timpl = new CollisionCompoundSystemImpl(this);\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t\tthis.implementations[type] = impl;\n\t\t}\n\t\treturn this.implementations[type];\n\t}\n\t_getImplementation(entity) {\n\t\treturn this.implementations[entity.collision.data.type];\n\t}\n\tcloneComponent(entity, clone) {\n\t\treturn this._getImplementation(entity).clone(entity, clone);\n\t}\n\tonBeforeRemove(entity, component) {\n\t\tthis.implementations[component.data.type].beforeRemove(entity, component);\n\t\tcomponent.onBeforeRemove();\n\t}\n\tonRemove(entity, data) {\n\t\tthis.implementations[data.type].remove(entity, data);\n\t}\n\tupdateCompoundChildTransform(entity) {\n\t\tthis._removeCompoundChild(entity.collision._compoundParent, entity.collision.data.shape);\n\t\tif (entity.enabled && entity.collision.enabled) {\n\t\t\tconst transform = this._getNodeTransform(entity, entity.collision._compoundParent.entity);\n\t\t\tentity.collision._compoundParent.shape.addChildShape(transform, entity.collision.data.shape);\n\t\t\tAmmo.destroy(transform);\n\t\t}\n\t}\n\t_removeCompoundChild(collision, shape) {\n\t\tif (collision.shape.removeChildShape) {\n\t\t\tcollision.shape.removeChildShape(shape);\n\t\t} else {\n\t\t\tconst ind = collision._getCompoundChildShapeIndex(shape);\n\t\t\tif (ind !== null) {\n\t\t\t\tcollision.shape.removeChildShapeByIndex(ind);\n\t\t\t}\n\t\t}\n\t}\n\tonTransformChanged(component, position, rotation, scale) {\n\t\tthis.implementations[component.data.type].updateTransform(component, position, rotation, scale);\n\t}\n\tchangeType(component, previousType, newType) {\n\t\tthis.implementations[previousType].beforeRemove(component.entity, component);\n\t\tthis.implementations[previousType].remove(component.entity, component.data);\n\t\tthis._createImplementation(newType).reset(component, component.data);\n\t}\n\trecreatePhysicalShapes(component) {\n\t\tthis.implementations[component.data.type].recreatePhysicalShapes(component);\n\t}\n\t_calculateNodeRelativeTransform(node, relative) {\n\t\tif (node === relative) {\n\t\t\tconst scale = node.getWorldTransform().getScale();\n\t\t\tmat4.setScale(scale.x, scale.y, scale.z);\n\t\t} else {\n\t\t\tthis._calculateNodeRelativeTransform(node.parent, relative);\n\t\t\tmat4.mul(node.getLocalTransform());\n\t\t}\n\t}\n\t_getNodeScaling(node) {\n\t\tconst wtm = node.getWorldTransform();\n\t\tconst scl = wtm.getScale();\n\t\treturn new Ammo.btVector3(scl.x, scl.y, scl.z);\n\t}\n\t_getNodeTransform(node, relative) {\n\t\tlet pos, rot;\n\t\tif (relative) {\n\t\t\tthis._calculateNodeRelativeTransform(node, relative);\n\t\t\tpos = p1;\n\t\t\trot = quat;\n\t\t\tmat4.getTranslation(pos);\n\t\t\trot.setFromMat4(mat4);\n\t\t} else {\n\t\t\tpos = node.getPosition();\n\t\t\trot = node.getRotation();\n\t\t}\n\t\tconst ammoQuat = new Ammo.btQuaternion();\n\t\tconst transform = new Ammo.btTransform();\n\t\ttransform.setIdentity();\n\t\tconst origin = transform.getOrigin();\n\t\tconst component = node.collision;\n\t\tif (component && component._hasOffset) {\n\t\t\tconst lo = component.data.linearOffset;\n\t\t\tconst ao = component.data.angularOffset;\n\t\t\tconst newOrigin = p2;\n\t\t\tquat.copy(rot).transformVector(lo, newOrigin);\n\t\t\tnewOrigin.add(pos);\n\t\t\tquat.copy(rot).mul(ao);\n\t\t\torigin.setValue(newOrigin.x, newOrigin.y, newOrigin.z);\n\t\t\tammoQuat.setValue(quat.x, quat.y, quat.z, quat.w);\n\t\t} else {\n\t\t\torigin.setValue(pos.x, pos.y, pos.z);\n\t\t\tammoQuat.setValue(rot.x, rot.y, rot.z, rot.w);\n\t\t}\n\t\ttransform.setRotation(ammoQuat);\n\t\tAmmo.destroy(ammoQuat);\n\t\tAmmo.destroy(origin);\n\t\treturn transform;\n\t}\n\tdestroy() {\n\t\tfor (const key in this._triMeshCache) {\n\t\t\tAmmo.destroy(this._triMeshCache[key]);\n\t\t}\n\t\tthis._triMeshCache = null;\n\t\tsuper.destroy();\n\t}\n}\n\nexport { CollisionComponentSystem };\n", "import { Vec2 } from '../../core/math/vec2.js';\nimport { CapsuleGeometry } from '../../scene/geometry/capsule-geometry.js';\nimport { ConeGeometry } from '../../scene/geometry/cone-geometry.js';\nimport { CylinderGeometry } from '../../scene/geometry/cylinder-geometry.js';\nimport { TorusGeometry } from '../../scene/geometry/torus-geometry.js';\nimport { Mesh } from '../../scene/mesh.js';\nimport { BoxGeometry } from '../../scene/geometry/box-geometry.js';\nimport { SphereGeometry } from '../../scene/geometry/sphere-geometry.js';\nimport { PlaneGeometry } from '../../scene/geometry/plane-geometry.js';\n\nconst shapePrimitives = [];\nfunction getShapePrimitive(device, type) {\n\tlet primData = null;\n\tfor (let i = 0; i < shapePrimitives.length; i++) {\n\t\tif (shapePrimitives[i].type === type && shapePrimitives[i].device === device) {\n\t\t\tprimData = shapePrimitives[i].primData;\n\t\t}\n\t}\n\tif (!primData) {\n\t\tlet mesh, area;\n\t\tswitch (type) {\n\t\t\tcase 'box':\n\t\t\t\tmesh = Mesh.fromGeometry(device, new BoxGeometry());\n\t\t\t\tarea = {\n\t\t\t\t\tx: 2,\n\t\t\t\t\ty: 2,\n\t\t\t\t\tz: 2,\n\t\t\t\t\tuv: 2.0 / 3\n\t\t\t\t};\n\t\t\t\tbreak;\n\t\t\tcase 'capsule':\n\t\t\t\tmesh = Mesh.fromGeometry(device, new CapsuleGeometry({\n\t\t\t\t\tradius: 0.5,\n\t\t\t\t\theight: 2\n\t\t\t\t}));\n\t\t\t\tarea = {\n\t\t\t\t\tx: Math.PI * 2,\n\t\t\t\t\ty: Math.PI,\n\t\t\t\t\tz: Math.PI * 2,\n\t\t\t\t\tuv: 1.0 / 3 + 1.0 / 3 / 3 * 2\n\t\t\t\t};\n\t\t\t\tbreak;\n\t\t\tcase 'cone':\n\t\t\t\tmesh = Mesh.fromGeometry(device, new ConeGeometry({\n\t\t\t\t\tbaseRadius: 0.5,\n\t\t\t\t\tpeakRadius: 0,\n\t\t\t\t\theight: 1\n\t\t\t\t}));\n\t\t\t\tarea = {\n\t\t\t\t\tx: 2.54,\n\t\t\t\t\ty: 2.54,\n\t\t\t\t\tz: 2.54,\n\t\t\t\t\tuv: 1.0 / 3 + 1.0 / 3 / 3\n\t\t\t\t};\n\t\t\t\tbreak;\n\t\t\tcase 'cylinder':\n\t\t\t\tmesh = Mesh.fromGeometry(device, new CylinderGeometry({\n\t\t\t\t\tradius: 0.5,\n\t\t\t\t\theight: 1\n\t\t\t\t}));\n\t\t\t\tarea = {\n\t\t\t\t\tx: Math.PI,\n\t\t\t\t\ty: 0.79 * 2,\n\t\t\t\t\tz: Math.PI,\n\t\t\t\t\tuv: 1.0 / 3 + 1.0 / 3 / 3 * 2\n\t\t\t\t};\n\t\t\t\tbreak;\n\t\t\tcase 'plane':\n\t\t\t\tmesh = Mesh.fromGeometry(device, new PlaneGeometry({\n\t\t\t\t\thalfExtents: new Vec2(0.5, 0.5),\n\t\t\t\t\twidthSegments: 1,\n\t\t\t\t\tlengthSegments: 1\n\t\t\t\t}));\n\t\t\t\tarea = {\n\t\t\t\t\tx: 0,\n\t\t\t\t\ty: 1,\n\t\t\t\t\tz: 0,\n\t\t\t\t\tuv: 1\n\t\t\t\t};\n\t\t\t\tbreak;\n\t\t\tcase 'sphere':\n\t\t\t\tmesh = Mesh.fromGeometry(device, new SphereGeometry({\n\t\t\t\t\tradius: 0.5\n\t\t\t\t}));\n\t\t\t\tarea = {\n\t\t\t\t\tx: Math.PI,\n\t\t\t\t\ty: Math.PI,\n\t\t\t\t\tz: Math.PI,\n\t\t\t\t\tuv: 1\n\t\t\t\t};\n\t\t\t\tbreak;\n\t\t\tcase 'torus':\n\t\t\t\tmesh = Mesh.fromGeometry(device, new TorusGeometry({\n\t\t\t\t\ttubeRadius: 0.2,\n\t\t\t\t\tringRadius: 0.3\n\t\t\t\t}));\n\t\t\t\tarea = {\n\t\t\t\t\tx: Math.PI * 0.5 * 0.5 - Math.PI * 0.1 * 0.1,\n\t\t\t\t\ty: 0.4,\n\t\t\t\t\tz: 0.4,\n\t\t\t\t\tuv: 1\n\t\t\t\t};\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\tthrow new Error('Invalid primitive type: ' + type);\n\t\t}\n\t\tmesh.incRefCount();\n\t\tprimData = {\n\t\t\tmesh: mesh,\n\t\t\tarea: area\n\t\t};\n\t\tshapePrimitives.push({\n\t\t\ttype: type,\n\t\t\tdevice: device,\n\t\t\tprimData: primData\n\t\t});\n\t}\n\treturn primData;\n}\n\nexport { getShapePrimitive };\n", "import { LAYERID_WORLD } from '../../../scene/constants.js';\nimport { BatchGroup } from '../../../scene/batching/batch-group.js';\nimport { GraphNode } from '../../../scene/graph-node.js';\nimport { MeshInstance } from '../../../scene/mesh-instance.js';\nimport { Model } from '../../../scene/model.js';\nimport { getShapePrimitive } from '../../graphics/primitive-cache.js';\nimport { Asset } from '../../asset/asset.js';\nimport { Component } from '../component.js';\n\nclass ModelComponent extends Component {\n\tconstructor(system, entity) {\n\t\tsuper(system, entity);\n\t\tthis._type = 'asset';\n\t\tthis._asset = null;\n\t\tthis._model = null;\n\t\tthis._mapping = {};\n\t\tthis._castShadows = true;\n\t\tthis._receiveShadows = true;\n\t\tthis._materialAsset = null;\n\t\tthis._material = void 0;\n\t\tthis._castShadowsLightmap = true;\n\t\tthis._lightmapped = false;\n\t\tthis._lightmapSizeMultiplier = 1;\n\t\tthis.isStatic = false;\n\t\tthis._layers = [LAYERID_WORLD];\n\t\tthis._batchGroupId = -1;\n\t\tthis._customAabb = null;\n\t\tthis._area = null;\n\t\tthis._materialEvents = null;\n\t\tthis._clonedModel = false;\n\t\tthis._material = system.defaultMaterial;\n\t\tentity.on('remove', this.onRemoveChild, this);\n\t\tentity.on('removehierarchy', this.onRemoveChild, this);\n\t\tentity.on('insert', this.onInsertChild, this);\n\t\tentity.on('inserthierarchy', this.onInsertChild, this);\n\t}\n\tset meshInstances(value) {\n\t\tif (!this._model) return;\n\t\tthis._model.meshInstances = value;\n\t}\n\tget meshInstances() {\n\t\tif (!this._model) return null;\n\t\treturn this._model.meshInstances;\n\t}\n\tset customAabb(value) {\n\t\tthis._customAabb = value;\n\t\tif (this._model) {\n\t\t\tconst mi = this._model.meshInstances;\n\t\t\tif (mi) {\n\t\t\t\tfor (let i = 0; i < mi.length; i++) {\n\t\t\t\t\tmi[i].setCustomAabb(this._customAabb);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\tget customAabb() {\n\t\treturn this._customAabb;\n\t}\n\tset type(value) {\n\t\tif (this._type === value) return;\n\t\tthis._area = null;\n\t\tthis._type = value;\n\t\tif (value === 'asset') {\n\t\t\tif (this._asset !== null) {\n\t\t\t\tthis._bindModelAsset(this._asset);\n\t\t\t} else {\n\t\t\t\tthis.model = null;\n\t\t\t}\n\t\t} else {\n\t\t\tconst primData = getShapePrimitive(this.system.app.graphicsDevice, value);\n\t\t\tthis._area = primData.area;\n\t\t\tconst mesh = primData.mesh;\n\t\t\tconst node = new GraphNode();\n\t\t\tconst model = new Model();\n\t\t\tmodel.graph = node;\n\t\t\tmodel.meshInstances = [new MeshInstance(mesh, this._material, node)];\n\t\t\tthis.model = model;\n\t\t\tthis._asset = null;\n\t\t}\n\t}\n\tget type() {\n\t\treturn this._type;\n\t}\n\tset asset(value) {\n\t\tconst assets = this.system.app.assets;\n\t\tlet _id = value;\n\t\tif (value instanceof Asset) {\n\t\t\t_id = value.id;\n\t\t}\n\t\tif (this._asset !== _id) {\n\t\t\tif (this._asset) {\n\t\t\t\tassets.off('add:' + this._asset, this._onModelAssetAdded, this);\n\t\t\t\tconst _prev = assets.get(this._asset);\n\t\t\t\tif (_prev) {\n\t\t\t\t\tthis._unbindModelAsset(_prev);\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis._asset = _id;\n\t\t\tif (this._asset) {\n\t\t\t\tconst asset = assets.get(this._asset);\n\t\t\t\tif (!asset) {\n\t\t\t\t\tthis.model = null;\n\t\t\t\t\tassets.on('add:' + this._asset, this._onModelAssetAdded, this);\n\t\t\t\t} else {\n\t\t\t\t\tthis._bindModelAsset(asset);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tthis.model = null;\n\t\t\t}\n\t\t}\n\t}\n\tget asset() {\n\t\treturn this._asset;\n\t}\n\tset model(value) {\n\t\tif (this._model === value) return;\n\t\tif (value && value._immutable) {\n\t\t\treturn;\n\t\t}\n\t\tif (this._model) {\n\t\t\tthis._model._immutable = false;\n\t\t\tthis.removeModelFromLayers();\n\t\t\tthis._model.getGraph().destroy();\n\t\t\tdelete this._model._entity;\n\t\t\tif (this._clonedModel) {\n\t\t\t\tthis._model.destroy();\n\t\t\t\tthis._clonedModel = false;\n\t\t\t}\n\t\t}\n\t\tthis._model = value;\n\t\tif (this._model) {\n\t\t\tthis._model._immutable = true;\n\t\t\tconst meshInstances = this._model.meshInstances;\n\t\t\tfor (let i = 0; i < meshInstances.length; i++) {\n\t\t\t\tmeshInstances[i].castShadow = this._castShadows;\n\t\t\t\tmeshInstances[i].receiveShadow = this._receiveShadows;\n\t\t\t\tmeshInstances[i].setCustomAabb(this._customAabb);\n\t\t\t}\n\t\t\tthis.lightmapped = this._lightmapped;\n\t\t\tthis.entity.addChild(this._model.graph);\n\t\t\tif (this.enabled && this.entity.enabled) {\n\t\t\t\tthis.addModelToLayers();\n\t\t\t}\n\t\t\tthis._model._entity = this.entity;\n\t\t\tif (this.entity.animation) this.entity.animation.setModel(this._model);\n\t\t\tif (this.entity.anim) {\n\t\t\t\tthis.entity.anim.rebind();\n\t\t\t}\n\t\t\tif (this.type === 'asset') {\n\t\t\t\tthis.mapping = this._mapping;\n\t\t\t} else {\n\t\t\t\tthis._unsetMaterialEvents();\n\t\t\t}\n\t\t}\n\t}\n\tget model() {\n\t\treturn this._model;\n\t}\n\tset lightmapped(value) {\n\t\tif (value !== this._lightmapped) {\n\t\t\tthis._lightmapped = value;\n\t\t\tif (this._model) {\n\t\t\t\tconst mi = this._model.meshInstances;\n\t\t\t\tfor (let i = 0; i < mi.length; i++) {\n\t\t\t\t\tmi[i].setLightmapped(value);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\tget lightmapped() {\n\t\treturn this._lightmapped;\n\t}\n\tset castShadows(value) {\n\t\tif (this._castShadows === value) return;\n\t\tconst model = this._model;\n\t\tif (model) {\n\t\t\tconst layers = this.layers;\n\t\t\tconst scene = this.system.app.scene;\n\t\t\tif (this._castShadows && !value) {\n\t\t\t\tfor (let i = 0; i < layers.length; i++) {\n\t\t\t\t\tconst layer = this.system.app.scene.layers.getLayerById(this.layers[i]);\n\t\t\t\t\tif (!layer) continue;\n\t\t\t\t\tlayer.removeShadowCasters(model.meshInstances);\n\t\t\t\t}\n\t\t\t}\n\t\t\tconst meshInstances = model.meshInstances;\n\t\t\tfor (let i = 0; i < meshInstances.length; i++) {\n\t\t\t\tmeshInstances[i].castShadow = value;\n\t\t\t}\n\t\t\tif (!this._castShadows && value) {\n\t\t\t\tfor (let i = 0; i < layers.length; i++) {\n\t\t\t\t\tconst layer = scene.layers.getLayerById(layers[i]);\n\t\t\t\t\tif (!layer) continue;\n\t\t\t\t\tlayer.addShadowCasters(model.meshInstances);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tthis._castShadows = value;\n\t}\n\tget castShadows() {\n\t\treturn this._castShadows;\n\t}\n\tset receiveShadows(value) {\n\t\tif (this._receiveShadows === value) return;\n\t\tthis._receiveShadows = value;\n\t\tif (this._model) {\n\t\t\tconst meshInstances = this._model.meshInstances;\n\t\t\tfor (let i = 0, len = meshInstances.length; i < len; i++) {\n\t\t\t\tmeshInstances[i].receiveShadow = value;\n\t\t\t}\n\t\t}\n\t}\n\tget receiveShadows() {\n\t\treturn this._receiveShadows;\n\t}\n\tset castShadowsLightmap(value) {\n\t\tthis._castShadowsLightmap = value;\n\t}\n\tget castShadowsLightmap() {\n\t\treturn this._castShadowsLightmap;\n\t}\n\tset lightmapSizeMultiplier(value) {\n\t\tthis._lightmapSizeMultiplier = value;\n\t}\n\tget lightmapSizeMultiplier() {\n\t\treturn this._lightmapSizeMultiplier;\n\t}\n\tset layers(value) {\n\t\tconst layers = this.system.app.scene.layers;\n\t\tif (this.meshInstances) {\n\t\t\tfor (let i = 0; i < this._layers.length; i++) {\n\t\t\t\tconst layer = layers.getLayerById(this._layers[i]);\n\t\t\t\tif (!layer) continue;\n\t\t\t\tlayer.removeMeshInstances(this.meshInstances);\n\t\t\t}\n\t\t}\n\t\tthis._layers.length = 0;\n\t\tfor (let i = 0; i < value.length; i++) {\n\t\t\tthis._layers[i] = value[i];\n\t\t}\n\t\tif (!this.enabled || !this.entity.enabled || !this.meshInstances) return;\n\t\tfor (let i = 0; i < this._layers.length; i++) {\n\t\t\tconst layer = layers.getLayerById(this._layers[i]);\n\t\t\tif (!layer) continue;\n\t\t\tlayer.addMeshInstances(this.meshInstances);\n\t\t}\n\t}\n\tget layers() {\n\t\treturn this._layers;\n\t}\n\tset batchGroupId(value) {\n\t\tif (this._batchGroupId === value) return;\n\t\tif (this.entity.enabled && this._batchGroupId >= 0) {\n\t\t\tvar _this$system$app$batc;\n\t\t\t(_this$system$app$batc = this.system.app.batcher) == null || _this$system$app$batc.remove(BatchGroup.MODEL, this.batchGroupId, this.entity);\n\t\t}\n\t\tif (this.entity.enabled && value >= 0) {\n\t\t\tvar _this$system$app$batc2;\n\t\t\t(_this$system$app$batc2 = this.system.app.batcher) == null || _this$system$app$batc2.insert(BatchGroup.MODEL, value, this.entity);\n\t\t}\n\t\tif (value < 0 && this._batchGroupId >= 0 && this.enabled && this.entity.enabled) {\n\t\t\tthis.addModelToLayers();\n\t\t}\n\t\tthis._batchGroupId = value;\n\t}\n\tget batchGroupId() {\n\t\treturn this._batchGroupId;\n\t}\n\tset materialAsset(value) {\n\t\tlet _id = value;\n\t\tif (value instanceof Asset) {\n\t\t\t_id = value.id;\n\t\t}\n\t\tconst assets = this.system.app.assets;\n\t\tif (_id !== this._materialAsset) {\n\t\t\tif (this._materialAsset) {\n\t\t\t\tassets.off('add:' + this._materialAsset, this._onMaterialAssetAdd, this);\n\t\t\t\tconst _prev = assets.get(this._materialAsset);\n\t\t\t\tif (_prev) {\n\t\t\t\t\tthis._unbindMaterialAsset(_prev);\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis._materialAsset = _id;\n\t\t\tif (this._materialAsset) {\n\t\t\t\tconst asset = assets.get(this._materialAsset);\n\t\t\t\tif (!asset) {\n\t\t\t\t\tthis._setMaterial(this.system.defaultMaterial);\n\t\t\t\t\tassets.on('add:' + this._materialAsset, this._onMaterialAssetAdd, this);\n\t\t\t\t} else {\n\t\t\t\t\tthis._bindMaterialAsset(asset);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tthis._setMaterial(this.system.defaultMaterial);\n\t\t\t}\n\t\t}\n\t}\n\tget materialAsset() {\n\t\treturn this._materialAsset;\n\t}\n\tset material(value) {\n\t\tif (this._material === value) return;\n\t\tthis.materialAsset = null;\n\t\tthis._setMaterial(value);\n\t}\n\tget material() {\n\t\treturn this._material;\n\t}\n\tset mapping(value) {\n\t\tif (this._type !== 'asset') return;\n\t\tthis._unsetMaterialEvents();\n\t\tif (!value) value = {};\n\t\tthis._mapping = value;\n\t\tif (!this._model) return;\n\t\tconst meshInstances = this._model.meshInstances;\n\t\tconst modelAsset = this.asset ? this.system.app.assets.get(this.asset) : null;\n\t\tconst assetMapping = modelAsset ? modelAsset.data.mapping : null;\n\t\tlet asset = null;\n\t\tfor (let i = 0, len = meshInstances.length; i < len; i++) {\n\t\t\tif (value[i] !== undefined) {\n\t\t\t\tif (value[i]) {\n\t\t\t\t\tasset = this.system.app.assets.get(value[i]);\n\t\t\t\t\tthis._loadAndSetMeshInstanceMaterial(asset, meshInstances[i], i);\n\t\t\t\t} else {\n\t\t\t\t\tmeshInstances[i].material = this.system.defaultMaterial;\n\t\t\t\t}\n\t\t\t} else if (assetMapping) {\n\t\t\t\tif (assetMapping[i] && (assetMapping[i].material || assetMapping[i].path)) {\n\t\t\t\t\tif (assetMapping[i].material !== undefined) {\n\t\t\t\t\t\tasset = this.system.app.assets.get(assetMapping[i].material);\n\t\t\t\t\t} else if (assetMapping[i].path !== undefined) {\n\t\t\t\t\t\tconst url = this._getMaterialAssetUrl(assetMapping[i].path);\n\t\t\t\t\t\tif (url) {\n\t\t\t\t\t\t\tasset = this.system.app.assets.getByUrl(url);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tthis._loadAndSetMeshInstanceMaterial(asset, meshInstances[i], i);\n\t\t\t\t} else {\n\t\t\t\t\tmeshInstances[i].material = this.system.defaultMaterial;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\tget mapping() {\n\t\treturn this._mapping;\n\t}\n\taddModelToLayers() {\n\t\tconst layers = this.system.app.scene.layers;\n\t\tfor (let i = 0; i < this._layers.length; i++) {\n\t\t\tconst layer = layers.getLayerById(this._layers[i]);\n\t\t\tif (layer) {\n\t\t\t\tlayer.addMeshInstances(this.meshInstances);\n\t\t\t}\n\t\t}\n\t}\n\tremoveModelFromLayers() {\n\t\tconst layers = this.system.app.scene.layers;\n\t\tfor (let i = 0; i < this._layers.length; i++) {\n\t\t\tconst layer = layers.getLayerById(this._layers[i]);\n\t\t\tif (!layer) continue;\n\t\t\tlayer.removeMeshInstances(this.meshInstances);\n\t\t}\n\t}\n\tonRemoveChild() {\n\t\tif (this._model) this.removeModelFromLayers();\n\t}\n\tonInsertChild() {\n\t\tif (this._model && this.enabled && this.entity.enabled) this.addModelToLayers();\n\t}\n\tonRemove() {\n\t\tthis.asset = null;\n\t\tthis.model = null;\n\t\tthis.materialAsset = null;\n\t\tthis._unsetMaterialEvents();\n\t\tthis.entity.off('remove', this.onRemoveChild, this);\n\t\tthis.entity.off('insert', this.onInsertChild, this);\n\t}\n\tonLayersChanged(oldComp, newComp) {\n\t\tthis.addModelToLayers();\n\t\toldComp.off('add', this.onLayerAdded, this);\n\t\toldComp.off('remove', this.onLayerRemoved, this);\n\t\tnewComp.on('add', this.onLayerAdded, this);\n\t\tnewComp.on('remove', this.onLayerRemoved, this);\n\t}\n\tonLayerAdded(layer) {\n\t\tconst index = this.layers.indexOf(layer.id);\n\t\tif (index < 0) return;\n\t\tlayer.addMeshInstances(this.meshInstances);\n\t}\n\tonLayerRemoved(layer) {\n\t\tconst index = this.layers.indexOf(layer.id);\n\t\tif (index < 0) return;\n\t\tlayer.removeMeshInstances(this.meshInstances);\n\t}\n\t_setMaterialEvent(index, event, id, handler) {\n\t\tconst evt = event + ':' + id;\n\t\tthis.system.app.assets.on(evt, handler, this);\n\t\tif (!this._materialEvents) this._materialEvents = [];\n\t\tif (!this._materialEvents[index]) this._materialEvents[index] = {};\n\t\tthis._materialEvents[index][evt] = {\n\t\t\tid: id,\n\t\t\thandler: handler\n\t\t};\n\t}\n\t_unsetMaterialEvents() {\n\t\tconst assets = this.system.app.assets;\n\t\tconst events = this._materialEvents;\n\t\tif (!events) return;\n\t\tfor (let i = 0, len = events.length; i < len; i++) {\n\t\t\tif (!events[i]) continue;\n\t\t\tconst evt = events[i];\n\t\t\tfor (const key in evt) {\n\t\t\t\tassets.off(key, evt[key].handler, this);\n\t\t\t}\n\t\t}\n\t\tthis._materialEvents = null;\n\t}\n\t_getAssetByIdOrPath(idOrPath) {\n\t\tlet asset = null;\n\t\tconst isPath = isNaN(parseInt(idOrPath, 10));\n\t\tif (!isPath) {\n\t\t\tasset = this.system.app.assets.get(idOrPath);\n\t\t} else if (this.asset) {\n\t\t\tconst url = this._getMaterialAssetUrl(idOrPath);\n\t\t\tif (url) asset = this.system.app.assets.getByUrl(url);\n\t\t}\n\t\treturn asset;\n\t}\n\t_getMaterialAssetUrl(path) {\n\t\tif (!this.asset) return null;\n\t\tconst modelAsset = this.system.app.assets.get(this.asset);\n\t\treturn modelAsset ? modelAsset.getAbsoluteUrl(path) : null;\n\t}\n\t_loadAndSetMeshInstanceMaterial(materialAsset, meshInstance, index) {\n\t\tconst assets = this.system.app.assets;\n\t\tif (!materialAsset) return;\n\t\tif (materialAsset.resource) {\n\t\t\tmeshInstance.material = materialAsset.resource;\n\t\t\tthis._setMaterialEvent(index, 'remove', materialAsset.id, function () {\n\t\t\t\tmeshInstance.material = this.system.defaultMaterial;\n\t\t\t});\n\t\t} else {\n\t\t\tthis._setMaterialEvent(index, 'load', materialAsset.id, function (asset) {\n\t\t\t\tmeshInstance.material = asset.resource;\n\t\t\t\tthis._setMaterialEvent(index, 'remove', materialAsset.id, function () {\n\t\t\t\t\tmeshInstance.material = this.system.defaultMaterial;\n\t\t\t\t});\n\t\t\t});\n\t\t\tif (this.enabled && this.entity.enabled) assets.load(materialAsset);\n\t\t}\n\t}\n\tonEnable() {\n\t\tconst app = this.system.app;\n\t\tconst scene = app.scene;\n\t\tscene.on('set:layers', this.onLayersChanged, this);\n\t\tif (scene.layers) {\n\t\t\tscene.layers.on('add', this.onLayerAdded, this);\n\t\t\tscene.layers.on('remove', this.onLayerRemoved, this);\n\t\t}\n\t\tconst isAsset = this._type === 'asset';\n\t\tlet asset;\n\t\tif (this._model) {\n\t\t\tthis.addModelToLayers();\n\t\t} else if (isAsset && this._asset) {\n\t\t\tasset = app.assets.get(this._asset);\n\t\t\tif (asset && asset.resource !== this._model) {\n\t\t\t\tthis._bindModelAsset(asset);\n\t\t\t}\n\t\t}\n\t\tif (this._materialAsset) {\n\t\t\tasset = app.assets.get(this._materialAsset);\n\t\t\tif (asset && asset.resource !== this._material) {\n\t\t\t\tthis._bindMaterialAsset(asset);\n\t\t\t}\n\t\t}\n\t\tif (isAsset) {\n\t\t\tif (this._mapping) {\n\t\t\t\tfor (const index in this._mapping) {\n\t\t\t\t\tif (this._mapping[index]) {\n\t\t\t\t\t\tasset = this._getAssetByIdOrPath(this._mapping[index]);\n\t\t\t\t\t\tif (asset && !asset.resource) {\n\t\t\t\t\t\t\tapp.assets.load(asset);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (this._batchGroupId >= 0) {\n\t\t\tvar _app$batcher;\n\t\t\t(_app$batcher = app.batcher) == null || _app$batcher.insert(BatchGroup.MODEL, this.batchGroupId, this.entity);\n\t\t}\n\t}\n\tonDisable() {\n\t\tconst app = this.system.app;\n\t\tconst scene = app.scene;\n\t\tscene.off('set:layers', this.onLayersChanged, this);\n\t\tif (scene.layers) {\n\t\t\tscene.layers.off('add', this.onLayerAdded, this);\n\t\t\tscene.layers.off('remove', this.onLayerRemoved, this);\n\t\t}\n\t\tif (this._batchGroupId >= 0) {\n\t\t\tvar _app$batcher2;\n\t\t\t(_app$batcher2 = app.batcher) == null || _app$batcher2.remove(BatchGroup.MODEL, this.batchGroupId, this.entity);\n\t\t}\n\t\tif (this._model) {\n\t\t\tthis.removeModelFromLayers();\n\t\t}\n\t}\n\thide() {\n\t\tif (this._model) {\n\t\t\tconst instances = this._model.meshInstances;\n\t\t\tfor (let i = 0, l = instances.length; i < l; i++) {\n\t\t\t\tinstances[i].visible = false;\n\t\t\t}\n\t\t}\n\t}\n\tshow() {\n\t\tif (this._model) {\n\t\t\tconst instances = this._model.meshInstances;\n\t\t\tfor (let i = 0, l = instances.length; i < l; i++) {\n\t\t\t\tinstances[i].visible = true;\n\t\t\t}\n\t\t}\n\t}\n\t_bindMaterialAsset(asset) {\n\t\tasset.on('load', this._onMaterialAssetLoad, this);\n\t\tasset.on('unload', this._onMaterialAssetUnload, this);\n\t\tasset.on('remove', this._onMaterialAssetRemove, this);\n\t\tasset.on('change', this._onMaterialAssetChange, this);\n\t\tif (asset.resource) {\n\t\t\tthis._onMaterialAssetLoad(asset);\n\t\t} else {\n\t\t\tif (!this.enabled || !this.entity.enabled) return;\n\t\t\tthis.system.app.assets.load(asset);\n\t\t}\n\t}\n\t_unbindMaterialAsset(asset) {\n\t\tasset.off('load', this._onMaterialAssetLoad, this);\n\t\tasset.off('unload', this._onMaterialAssetUnload, this);\n\t\tasset.off('remove', this._onMaterialAssetRemove, this);\n\t\tasset.off('change', this._onMaterialAssetChange, this);\n\t}\n\t_onMaterialAssetAdd(asset) {\n\t\tthis.system.app.assets.off('add:' + asset.id, this._onMaterialAssetAdd, this);\n\t\tif (this._materialAsset === asset.id) {\n\t\t\tthis._bindMaterialAsset(asset);\n\t\t}\n\t}\n\t_onMaterialAssetLoad(asset) {\n\t\tthis._setMaterial(asset.resource);\n\t}\n\t_onMaterialAssetUnload(asset) {\n\t\tthis._setMaterial(this.system.defaultMaterial);\n\t}\n\t_onMaterialAssetRemove(asset) {\n\t\tthis._onMaterialAssetUnload(asset);\n\t}\n\t_onMaterialAssetChange(asset) {}\n\t_bindModelAsset(asset) {\n\t\tthis._unbindModelAsset(asset);\n\t\tasset.on('load', this._onModelAssetLoad, this);\n\t\tasset.on('unload', this._onModelAssetUnload, this);\n\t\tasset.on('change', this._onModelAssetChange, this);\n\t\tasset.on('remove', this._onModelAssetRemove, this);\n\t\tif (asset.resource) {\n\t\t\tthis._onModelAssetLoad(asset);\n\t\t} else {\n\t\t\tif (!this.enabled || !this.entity.enabled) return;\n\t\t\tthis.system.app.assets.load(asset);\n\t\t}\n\t}\n\t_unbindModelAsset(asset) {\n\t\tasset.off('load', this._onModelAssetLoad, this);\n\t\tasset.off('unload', this._onModelAssetUnload, this);\n\t\tasset.off('change', this._onModelAssetChange, this);\n\t\tasset.off('remove', this._onModelAssetRemove, this);\n\t}\n\t_onModelAssetAdded(asset) {\n\t\tthis.system.app.assets.off('add:' + asset.id, this._onModelAssetAdded, this);\n\t\tif (asset.id === this._asset) {\n\t\t\tthis._bindModelAsset(asset);\n\t\t}\n\t}\n\t_onModelAssetLoad(asset) {\n\t\tthis.model = asset.resource.clone();\n\t\tthis._clonedModel = true;\n\t}\n\t_onModelAssetUnload(asset) {\n\t\tthis.model = null;\n\t}\n\t_onModelAssetChange(asset, attr, _new, _old) {\n\t\tif (attr === 'data') {\n\t\t\tthis.mapping = this._mapping;\n\t\t}\n\t}\n\t_onModelAssetRemove(asset) {\n\t\tthis.model = null;\n\t}\n\t_setMaterial(material) {\n\t\tif (this._material === material) return;\n\t\tthis._material = material;\n\t\tconst model = this._model;\n\t\tif (model && this._type !== 'asset') {\n\t\t\tconst meshInstances = model.meshInstances;\n\t\t\tfor (let i = 0, len = meshInstances.length; i < len; i++) {\n\t\t\t\tmeshInstances[i].material = material;\n\t\t\t}\n\t\t}\n\t}\n}\n\nexport { ModelComponent };\n", "class ModelComponentData {\n\tconstructor() {\n\t\tthis.enabled = true;\n\t}\n}\n\nexport { ModelComponentData };\n", "import { extend } from '../../../core/core.js';\nimport { Vec3 } from '../../../core/math/vec3.js';\nimport { BoundingBox } from '../../../core/shape/bounding-box.js';\nimport { getDefaultMaterial } from '../../../scene/materials/default-material.js';\nimport { Asset } from '../../asset/asset.js';\nimport { Component } from '../component.js';\nimport { ComponentSystem } from '../system.js';\nimport { ModelComponent } from './component.js';\nimport { ModelComponentData } from './data.js';\n\nconst _schema = ['enabled'];\nclass ModelComponentSystem extends ComponentSystem {\n\tconstructor(app) {\n\t\tsuper(app);\n\t\tthis.id = 'model';\n\t\tthis.ComponentType = ModelComponent;\n\t\tthis.DataType = ModelComponentData;\n\t\tthis.schema = _schema;\n\t\tthis.defaultMaterial = getDefaultMaterial(app.graphicsDevice);\n\t\tthis.on('beforeremove', this.onRemove, this);\n\t}\n\tinitializeComponentData(component, _data, properties) {\n\t\tproperties = ['material', 'materialAsset', 'asset', 'castShadows', 'receiveShadows', 'castShadowsLightmap', 'lightmapped', 'lightmapSizeMultiplier', 'type', 'mapping', 'layers', 'isStatic', 'batchGroupId'];\n\t\tif (_data.batchGroupId === null || _data.batchGroupId === undefined) {\n\t\t\t_data.batchGroupId = -1;\n\t\t}\n\t\tif (_data.layers && _data.layers.length) {\n\t\t\t_data.layers = _data.layers.slice(0);\n\t\t}\n\t\tfor (let i = 0; i < properties.length; i++) {\n\t\t\tif (_data.hasOwnProperty(properties[i])) {\n\t\t\t\tcomponent[properties[i]] = _data[properties[i]];\n\t\t\t}\n\t\t}\n\t\tif (_data.aabbCenter && _data.aabbHalfExtents) {\n\t\t\tcomponent.customAabb = new BoundingBox(new Vec3(_data.aabbCenter), new Vec3(_data.aabbHalfExtents));\n\t\t}\n\t\tsuper.initializeComponentData(component, _data, ['enabled']);\n\t}\n\tcloneComponent(entity, clone) {\n\t\tconst data = {\n\t\t\ttype: entity.model.type,\n\t\t\tasset: entity.model.asset,\n\t\t\tcastShadows: entity.model.castShadows,\n\t\t\treceiveShadows: entity.model.receiveShadows,\n\t\t\tcastShadowsLightmap: entity.model.castShadowsLightmap,\n\t\t\tlightmapped: entity.model.lightmapped,\n\t\t\tlightmapSizeMultiplier: entity.model.lightmapSizeMultiplier,\n\t\t\tisStatic: entity.model.isStatic,\n\t\t\tenabled: entity.model.enabled,\n\t\t\tlayers: entity.model.layers,\n\t\t\tbatchGroupId: entity.model.batchGroupId,\n\t\t\tmapping: extend({}, entity.model.mapping)\n\t\t};\n\t\tlet materialAsset = entity.model.materialAsset;\n\t\tif (!(materialAsset instanceof Asset) && materialAsset != null) {\n\t\t\tmaterialAsset = this.app.assets.get(materialAsset);\n\t\t}\n\t\tconst material = entity.model.material;\n\t\tif (!material || material === this.defaultMaterial || !materialAsset || material === materialAsset.resource) {\n\t\t\tdata.materialAsset = materialAsset;\n\t\t}\n\t\tconst component = this.addComponent(clone, data);\n\t\tif (entity.model.model && entity.model.type === 'asset' && !entity.model.asset) {\n\t\t\tcomponent.model = entity.model.model.clone();\n\t\t\tcomponent._clonedModel = true;\n\t\t}\n\t\tif (!data.materialAsset) component.material = material;\n\t\tif (entity.model.model) {\n\t\t\tconst meshInstances = entity.model.model.meshInstances;\n\t\t\tconst meshInstancesClone = component.model.meshInstances;\n\t\t\tfor (let i = 0; i < meshInstances.length; i++) {\n\t\t\t\tmeshInstancesClone[i].mask = meshInstances[i].mask;\n\t\t\t\tmeshInstancesClone[i].material = meshInstances[i].material;\n\t\t\t\tmeshInstancesClone[i].layer = meshInstances[i].layer;\n\t\t\t\tmeshInstancesClone[i].receiveShadow = meshInstances[i].receiveShadow;\n\t\t\t}\n\t\t}\n\t\tif (entity.model.customAabb) {\n\t\t\tcomponent.customAabb = entity.model.customAabb.clone();\n\t\t}\n\t\treturn component;\n\t}\n\tonRemove(entity, component) {\n\t\tcomponent.onRemove();\n\t}\n}\nComponent._buildAccessors(ModelComponent.prototype, _schema);\n\nexport { ModelComponentSystem };\n", "import { RefCountedObject } from '../core/ref-counted-object.js';\nimport { SkinInstance } from './skin-instance.js';\n\nclass SkinInstanceCachedObject extends RefCountedObject {\n\tconstructor(skin, skinInstance) {\n\t\tsuper();\n\t\tthis.skin = skin;\n\t\tthis.skinInstance = skinInstance;\n\t}\n}\nclass SkinInstanceCache {\n\tstatic createCachedSkinInstance(skin, rootBone, entity) {\n\t\tlet skinInst = SkinInstanceCache.getCachedSkinInstance(skin, rootBone);\n\t\tif (!skinInst) {\n\t\t\tskinInst = new SkinInstance(skin);\n\t\t\tskinInst.resolve(rootBone, entity);\n\t\t\tSkinInstanceCache.addCachedSkinInstance(skin, rootBone, skinInst);\n\t\t}\n\t\treturn skinInst;\n\t}\n\tstatic getCachedSkinInstance(skin, rootBone) {\n\t\tlet skinInstance = null;\n\t\tconst cachedObjArray = SkinInstanceCache._skinInstanceCache.get(rootBone);\n\t\tif (cachedObjArray) {\n\t\t\tconst cachedObj = cachedObjArray.find(element => element.skin === skin);\n\t\t\tif (cachedObj) {\n\t\t\t\tcachedObj.incRefCount();\n\t\t\t\tskinInstance = cachedObj.skinInstance;\n\t\t\t}\n\t\t}\n\t\treturn skinInstance;\n\t}\n\tstatic addCachedSkinInstance(skin, rootBone, skinInstance) {\n\t\tlet cachedObjArray = SkinInstanceCache._skinInstanceCache.get(rootBone);\n\t\tif (!cachedObjArray) {\n\t\t\tcachedObjArray = [];\n\t\t\tSkinInstanceCache._skinInstanceCache.set(rootBone, cachedObjArray);\n\t\t}\n\t\tlet cachedObj = cachedObjArray.find(element => element.skin === skin);\n\t\tif (!cachedObj) {\n\t\t\tcachedObj = new SkinInstanceCachedObject(skin, skinInstance);\n\t\t\tcachedObjArray.push(cachedObj);\n\t\t}\n\t\tcachedObj.incRefCount();\n\t}\n\tstatic removeCachedSkinInstance(skinInstance) {\n\t\tif (skinInstance) {\n\t\t\tconst rootBone = skinInstance.rootBone;\n\t\t\tif (rootBone) {\n\t\t\t\tconst cachedObjArray = SkinInstanceCache._skinInstanceCache.get(rootBone);\n\t\t\t\tif (cachedObjArray) {\n\t\t\t\t\tconst cachedObjIndex = cachedObjArray.findIndex(element => element.skinInstance === skinInstance);\n\t\t\t\t\tif (cachedObjIndex >= 0) {\n\t\t\t\t\t\tconst cachedObj = cachedObjArray[cachedObjIndex];\n\t\t\t\t\t\tcachedObj.decRefCount();\n\t\t\t\t\t\tif (cachedObj.refCount === 0) {\n\t\t\t\t\t\t\tcachedObjArray.splice(cachedObjIndex, 1);\n\t\t\t\t\t\t\tif (!cachedObjArray.length) {\n\t\t\t\t\t\t\t\tSkinInstanceCache._skinInstanceCache.delete(rootBone);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tif (skinInstance) {\n\t\t\t\t\t\t\t\tskinInstance.destroy();\n\t\t\t\t\t\t\t\tcachedObj.skinInstance = null;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\nSkinInstanceCache._skinInstanceCache = new Map();\n\nexport { SkinInstanceCache };\n", "class AssetReference {\n\tconstructor(propertyName, parent, registry, callbacks, scope) {\n\t\tthis.propertyName = propertyName;\n\t\tthis.parent = parent;\n\t\tthis._scope = scope;\n\t\tthis._registry = registry;\n\t\tthis.id = null;\n\t\tthis.url = null;\n\t\tthis.asset = null;\n\t\tthis._onAssetLoad = callbacks.load;\n\t\tthis._onAssetAdd = callbacks.add;\n\t\tthis._onAssetRemove = callbacks.remove;\n\t\tthis._onAssetUnload = callbacks.unload;\n\t}\n\tset id(value) {\n\t\tif (this.url) throw Error('Can\\'t set id and url');\n\t\tthis._unbind();\n\t\tthis._id = value;\n\t\tthis.asset = this._registry.get(this._id);\n\t\tthis._bind();\n\t}\n\tget id() {\n\t\treturn this._id;\n\t}\n\tset url(value) {\n\t\tif (this.id) throw Error('Can\\'t set id and url');\n\t\tthis._unbind();\n\t\tthis._url = value;\n\t\tthis.asset = this._registry.getByUrl(this._url);\n\t\tthis._bind();\n\t}\n\tget url() {\n\t\treturn this._url;\n\t}\n\t_bind() {\n\t\tif (this.id) {\n\t\t\tif (this._onAssetLoad) this._registry.on('load:' + this.id, this._onLoad, this);\n\t\t\tif (this._onAssetAdd) this._registry.once('add:' + this.id, this._onAdd, this);\n\t\t\tif (this._onAssetRemove) this._registry.on('remove:' + this.id, this._onRemove, this);\n\t\t\tif (this._onAssetUnload) this._registry.on('unload:' + this.id, this._onUnload, this);\n\t\t}\n\t\tif (this.url) {\n\t\t\tif (this._onAssetLoad) this._registry.on('load:url:' + this.url, this._onLoad, this);\n\t\t\tif (this._onAssetAdd) this._registry.once('add:url:' + this.url, this._onAdd, this);\n\t\t\tif (this._onAssetRemove) this._registry.on('remove:url:' + this.url, this._onRemove, this);\n\t\t}\n\t}\n\t_unbind() {\n\t\tif (this.id) {\n\t\t\tif (this._onAssetLoad) this._registry.off('load:' + this.id, this._onLoad, this);\n\t\t\tif (this._onAssetAdd) this._registry.off('add:' + this.id, this._onAdd, this);\n\t\t\tif (this._onAssetRemove) this._registry.off('remove:' + this.id, this._onRemove, this);\n\t\t\tif (this._onAssetUnload) this._registry.off('unload:' + this.id, this._onUnload, this);\n\t\t}\n\t\tif (this.url) {\n\t\t\tif (this._onAssetLoad) this._registry.off('load:' + this.url, this._onLoad, this);\n\t\t\tif (this._onAssetAdd) this._registry.off('add:' + this.url, this._onAdd, this);\n\t\t\tif (this._onAssetRemove) this._registry.off('remove:' + this.url, this._onRemove, this);\n\t\t}\n\t}\n\t_onLoad(asset) {\n\t\tthis._onAssetLoad.call(this._scope, this.propertyName, this.parent, asset);\n\t}\n\t_onAdd(asset) {\n\t\tthis.asset = asset;\n\t\tthis._onAssetAdd.call(this._scope, this.propertyName, this.parent, asset);\n\t}\n\t_onRemove(asset) {\n\t\tthis._onAssetRemove.call(this._scope, this.propertyName, this.parent, asset);\n\t\tthis.asset = null;\n\t}\n\t_onUnload(asset) {\n\t\tthis._onAssetUnload.call(this._scope, this.propertyName, this.parent, asset);\n\t}\n}\n\nexport { AssetReference };\n", "import { LAYERID_WORLD, RENDERSTYLE_SOLID } from '../../../scene/constants.js';\nimport { BatchGroup } from '../../../scene/batching/batch-group.js';\nimport { MeshInstance } from '../../../scene/mesh-instance.js';\nimport { MorphInstance } from '../../../scene/morph-instance.js';\nimport { getShapePrimitive } from '../../graphics/primitive-cache.js';\nimport { GraphNode } from '../../../scene/graph-node.js';\nimport { SkinInstanceCache } from '../../../scene/skin-instance-cache.js';\nimport { Asset } from '../../asset/asset.js';\nimport { AssetReference } from '../../asset/asset-reference.js';\nimport { Component } from '../component.js';\nimport { EntityReference } from '../../utils/entity-reference.js';\n\nclass RenderComponent extends Component {\n\tconstructor(system, entity) {\n\t\tsuper(system, entity);\n\t\tthis._type = 'asset';\n\t\tthis._castShadows = true;\n\t\tthis._receiveShadows = true;\n\t\tthis._castShadowsLightmap = true;\n\t\tthis._lightmapped = false;\n\t\tthis._lightmapSizeMultiplier = 1;\n\t\tthis.isStatic = false;\n\t\tthis._batchGroupId = -1;\n\t\tthis._layers = [LAYERID_WORLD];\n\t\tthis._renderStyle = RENDERSTYLE_SOLID;\n\t\tthis._meshInstances = [];\n\t\tthis._customAabb = null;\n\t\tthis._area = null;\n\t\tthis._assetReference = void 0;\n\t\tthis._materialReferences = [];\n\t\tthis._material = void 0;\n\t\tthis._rootBone = void 0;\n\t\tthis._rootBone = new EntityReference(this, 'rootBone');\n\t\tthis._rootBone.on('set:entity', this._onSetRootBone, this);\n\t\tthis._assetReference = new AssetReference('asset', this, system.app.assets, {\n\t\t\tadd: this._onRenderAssetAdded,\n\t\t\tload: this._onRenderAssetLoad,\n\t\t\tremove: this._onRenderAssetRemove,\n\t\t\tunload: this._onRenderAssetUnload\n\t\t}, this);\n\t\tthis._material = system.defaultMaterial;\n\t\tentity.on('remove', this.onRemoveChild, this);\n\t\tentity.on('removehierarchy', this.onRemoveChild, this);\n\t\tentity.on('insert', this.onInsertChild, this);\n\t\tentity.on('inserthierarchy', this.onInsertChild, this);\n\t}\n\tset renderStyle(renderStyle) {\n\t\tif (this._renderStyle !== renderStyle) {\n\t\t\tthis._renderStyle = renderStyle;\n\t\t\tMeshInstance._prepareRenderStyleForArray(this._meshInstances, renderStyle);\n\t\t}\n\t}\n\tget renderStyle() {\n\t\treturn this._renderStyle;\n\t}\n\tset customAabb(value) {\n\t\tthis._customAabb = value;\n\t\tconst mi = this._meshInstances;\n\t\tif (mi) {\n\t\t\tfor (let i = 0; i < mi.length; i++) {\n\t\t\t\tmi[i].setCustomAabb(this._customAabb);\n\t\t\t}\n\t\t}\n\t}\n\tget customAabb() {\n\t\treturn this._customAabb;\n\t}\n\tset type(value) {\n\t\tif (this._type !== value) {\n\t\t\tthis._area = null;\n\t\t\tthis._type = value;\n\t\t\tthis.destroyMeshInstances();\n\t\t\tif (value !== 'asset') {\n\t\t\t\tlet material = this._material;\n\t\t\t\tif (!material || material === this.system.defaultMaterial) {\n\t\t\t\t\tmaterial = this._materialReferences[0] && this._materialReferences[0].asset && this._materialReferences[0].asset.resource;\n\t\t\t\t}\n\t\t\t\tconst primData = getShapePrimitive(this.system.app.graphicsDevice, value);\n\t\t\t\tthis._area = primData.area;\n\t\t\t\tthis.meshInstances = [new MeshInstance(primData.mesh, material || this.system.defaultMaterial, this.entity)];\n\t\t\t}\n\t\t}\n\t}\n\tget type() {\n\t\treturn this._type;\n\t}\n\tset meshInstances(value) {\n\t\tthis.destroyMeshInstances();\n\t\tthis._meshInstances = value;\n\t\tif (this._meshInstances) {\n\t\t\tconst mi = this._meshInstances;\n\t\t\tfor (let i = 0; i < mi.length; i++) {\n\t\t\t\tif (!mi[i].node) {\n\t\t\t\t\tmi[i].node = this.entity;\n\t\t\t\t}\n\t\t\t\tmi[i].castShadow = this._castShadows;\n\t\t\t\tmi[i].receiveShadow = this._receiveShadows;\n\t\t\t\tmi[i].renderStyle = this._renderStyle;\n\t\t\t\tmi[i].setLightmapped(this._lightmapped);\n\t\t\t\tmi[i].setCustomAabb(this._customAabb);\n\t\t\t}\n\t\t\tif (this.enabled && this.entity.enabled) {\n\t\t\t\tthis.addToLayers();\n\t\t\t}\n\t\t}\n\t}\n\tget meshInstances() {\n\t\treturn this._meshInstances;\n\t}\n\tset lightmapped(value) {\n\t\tif (value !== this._lightmapped) {\n\t\t\tthis._lightmapped = value;\n\t\t\tconst mi = this._meshInstances;\n\t\t\tif (mi) {\n\t\t\t\tfor (let i = 0; i < mi.length; i++) {\n\t\t\t\t\tmi[i].setLightmapped(value);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\tget lightmapped() {\n\t\treturn this._lightmapped;\n\t}\n\tset castShadows(value) {\n\t\tif (this._castShadows !== value) {\n\t\t\tconst mi = this._meshInstances;\n\t\t\tif (mi) {\n\t\t\t\tconst layers = this.layers;\n\t\t\t\tconst scene = this.system.app.scene;\n\t\t\t\tif (this._castShadows && !value) {\n\t\t\t\t\tfor (let i = 0; i < layers.length; i++) {\n\t\t\t\t\t\tconst layer = scene.layers.getLayerById(this.layers[i]);\n\t\t\t\t\t\tif (layer) {\n\t\t\t\t\t\t\tlayer.removeShadowCasters(mi);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tfor (let i = 0; i < mi.length; i++) {\n\t\t\t\t\tmi[i].castShadow = value;\n\t\t\t\t}\n\t\t\t\tif (!this._castShadows && value) {\n\t\t\t\t\tfor (let i = 0; i < layers.length; i++) {\n\t\t\t\t\t\tconst layer = scene.layers.getLayerById(layers[i]);\n\t\t\t\t\t\tif (layer) {\n\t\t\t\t\t\t\tlayer.addShadowCasters(mi);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis._castShadows = value;\n\t\t}\n\t}\n\tget castShadows() {\n\t\treturn this._castShadows;\n\t}\n\tset receiveShadows(value) {\n\t\tif (this._receiveShadows !== value) {\n\t\t\tthis._receiveShadows = value;\n\t\t\tconst mi = this._meshInstances;\n\t\t\tif (mi) {\n\t\t\t\tfor (let i = 0; i < mi.length; i++) {\n\t\t\t\t\tmi[i].receiveShadow = value;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\tget receiveShadows() {\n\t\treturn this._receiveShadows;\n\t}\n\tset castShadowsLightmap(value) {\n\t\tthis._castShadowsLightmap = value;\n\t}\n\tget castShadowsLightmap() {\n\t\treturn this._castShadowsLightmap;\n\t}\n\tset lightmapSizeMultiplier(value) {\n\t\tthis._lightmapSizeMultiplier = value;\n\t}\n\tget lightmapSizeMultiplier() {\n\t\treturn this._lightmapSizeMultiplier;\n\t}\n\tset layers(value) {\n\t\tconst layers = this.system.app.scene.layers;\n\t\tlet layer;\n\t\tif (this._meshInstances) {\n\t\t\tfor (let i = 0; i < this._layers.length; i++) {\n\t\t\t\tlayer = layers.getLayerById(this._layers[i]);\n\t\t\t\tif (layer) {\n\t\t\t\t\tlayer.removeMeshInstances(this._meshInstances);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tthis._layers.length = 0;\n\t\tfor (let i = 0; i < value.length; i++) {\n\t\t\tthis._layers[i] = value[i];\n\t\t}\n\t\tif (!this.enabled || !this.entity.enabled || !this._meshInstances) return;\n\t\tfor (let i = 0; i < this._layers.length; i++) {\n\t\t\tlayer = layers.getLayerById(this._layers[i]);\n\t\t\tif (layer) {\n\t\t\t\tlayer.addMeshInstances(this._meshInstances);\n\t\t\t}\n\t\t}\n\t}\n\tget layers() {\n\t\treturn this._layers;\n\t}\n\tset batchGroupId(value) {\n\t\tif (this._batchGroupId !== value) {\n\t\t\tif (this.entity.enabled && this._batchGroupId >= 0) {\n\t\t\t\tvar _this$system$app$batc;\n\t\t\t\t(_this$system$app$batc = this.system.app.batcher) == null || _this$system$app$batc.remove(BatchGroup.RENDER, this.batchGroupId, this.entity);\n\t\t\t}\n\t\t\tif (this.entity.enabled && value >= 0) {\n\t\t\t\tvar _this$system$app$batc2;\n\t\t\t\t(_this$system$app$batc2 = this.system.app.batcher) == null || _this$system$app$batc2.insert(BatchGroup.RENDER, value, this.entity);\n\t\t\t}\n\t\t\tif (value < 0 && this._batchGroupId >= 0 && this.enabled && this.entity.enabled) {\n\t\t\t\tthis.addToLayers();\n\t\t\t}\n\t\t\tthis._batchGroupId = value;\n\t\t}\n\t}\n\tget batchGroupId() {\n\t\treturn this._batchGroupId;\n\t}\n\tset material(value) {\n\t\tif (this._material !== value) {\n\t\t\tthis._material = value;\n\t\t\tif (this._meshInstances && this._type !== 'asset') {\n\t\t\t\tfor (let i = 0; i < this._meshInstances.length; i++) {\n\t\t\t\t\tthis._meshInstances[i].material = value;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\tget material() {\n\t\treturn this._material;\n\t}\n\tset materialAssets(value = []) {\n\t\tif (this._materialReferences.length > value.length) {\n\t\t\tfor (let i = value.length; i < this._materialReferences.length; i++) {\n\t\t\t\tthis._materialReferences[i].id = null;\n\t\t\t}\n\t\t\tthis._materialReferences.length = value.length;\n\t\t}\n\t\tfor (let i = 0; i < value.length; i++) {\n\t\t\tif (!this._materialReferences[i]) {\n\t\t\t\tthis._materialReferences.push(new AssetReference(i, this, this.system.app.assets, {\n\t\t\t\t\tadd: this._onMaterialAdded,\n\t\t\t\t\tload: this._onMaterialLoad,\n\t\t\t\t\tremove: this._onMaterialRemove,\n\t\t\t\t\tunload: this._onMaterialUnload\n\t\t\t\t}, this));\n\t\t\t}\n\t\t\tif (value[i]) {\n\t\t\t\tconst id = value[i] instanceof Asset ? value[i].id : value[i];\n\t\t\t\tif (this._materialReferences[i].id !== id) {\n\t\t\t\t\tthis._materialReferences[i].id = id;\n\t\t\t\t}\n\t\t\t\tif (this._materialReferences[i].asset) {\n\t\t\t\t\tthis._onMaterialAdded(i, this, this._materialReferences[i].asset);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tthis._materialReferences[i].id = null;\n\t\t\t\tif (this._meshInstances[i]) {\n\t\t\t\t\tthis._meshInstances[i].material = this.system.defaultMaterial;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\tget materialAssets() {\n\t\treturn this._materialReferences.map(function (ref) {\n\t\t\treturn ref.id;\n\t\t});\n\t}\n\tset asset(value) {\n\t\tconst id = value instanceof Asset ? value.id : value;\n\t\tif (this._assetReference.id === id) return;\n\t\tif (this._assetReference.asset && this._assetReference.asset.resource) {\n\t\t\tthis._onRenderAssetRemove();\n\t\t}\n\t\tthis._assetReference.id = id;\n\t\tif (this._assetReference.asset) {\n\t\t\tthis._onRenderAssetAdded();\n\t\t}\n\t}\n\tget asset() {\n\t\treturn this._assetReference.id;\n\t}\n\tassignAsset(asset) {\n\t\tconst id = asset instanceof Asset ? asset.id : asset;\n\t\tthis._assetReference.id = id;\n\t}\n\t_onSetRootBone(entity) {\n\t\tif (entity) {\n\t\t\tthis._onRootBoneChanged();\n\t\t}\n\t}\n\t_onRootBoneChanged() {\n\t\tthis._clearSkinInstances();\n\t\tif (this.enabled && this.entity.enabled) {\n\t\t\tthis._cloneSkinInstances();\n\t\t}\n\t}\n\tdestroyMeshInstances() {\n\t\tconst meshInstances = this._meshInstances;\n\t\tif (meshInstances) {\n\t\t\tthis.removeFromLayers();\n\t\t\tthis._clearSkinInstances();\n\t\t\tfor (let i = 0; i < meshInstances.length; i++) {\n\t\t\t\tmeshInstances[i].destroy();\n\t\t\t}\n\t\t\tthis._meshInstances.length = 0;\n\t\t}\n\t}\n\taddToLayers() {\n\t\tconst layers = this.system.app.scene.layers;\n\t\tfor (let i = 0; i < this._layers.length; i++) {\n\t\t\tconst layer = layers.getLayerById(this._layers[i]);\n\t\t\tif (layer) {\n\t\t\t\tlayer.addMeshInstances(this._meshInstances);\n\t\t\t}\n\t\t}\n\t}\n\tremoveFromLayers() {\n\t\tif (this._meshInstances && this._meshInstances.length) {\n\t\t\tconst layers = this.system.app.scene.layers;\n\t\t\tfor (let i = 0; i < this._layers.length; i++) {\n\t\t\t\tconst layer = layers.getLayerById(this._layers[i]);\n\t\t\t\tif (layer) {\n\t\t\t\t\tlayer.removeMeshInstances(this._meshInstances);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\tonRemoveChild() {\n\t\tthis.removeFromLayers();\n\t}\n\tonInsertChild() {\n\t\tif (this._meshInstances && this.enabled && this.entity.enabled) {\n\t\t\tthis.addToLayers();\n\t\t}\n\t}\n\tonRemove() {\n\t\tthis.destroyMeshInstances();\n\t\tthis.asset = null;\n\t\tthis.materialAsset = null;\n\t\tthis._assetReference.id = null;\n\t\tfor (let i = 0; i < this._materialReferences.length; i++) {\n\t\t\tthis._materialReferences[i].id = null;\n\t\t}\n\t\tthis.entity.off('remove', this.onRemoveChild, this);\n\t\tthis.entity.off('insert', this.onInsertChild, this);\n\t}\n\tonLayersChanged(oldComp, newComp) {\n\t\tthis.addToLayers();\n\t\toldComp.off('add', this.onLayerAdded, this);\n\t\toldComp.off('remove', this.onLayerRemoved, this);\n\t\tnewComp.on('add', this.onLayerAdded, this);\n\t\tnewComp.on('remove', this.onLayerRemoved, this);\n\t}\n\tonLayerAdded(layer) {\n\t\tconst index = this.layers.indexOf(layer.id);\n\t\tif (index < 0) return;\n\t\tlayer.addMeshInstances(this._meshInstances);\n\t}\n\tonLayerRemoved(layer) {\n\t\tconst index = this.layers.indexOf(layer.id);\n\t\tif (index < 0) return;\n\t\tlayer.removeMeshInstances(this._meshInstances);\n\t}\n\tonEnable() {\n\t\tconst app = this.system.app;\n\t\tconst scene = app.scene;\n\t\tthis._rootBone.onParentComponentEnable();\n\t\tthis._cloneSkinInstances();\n\t\tscene.on('set:layers', this.onLayersChanged, this);\n\t\tif (scene.layers) {\n\t\t\tscene.layers.on('add', this.onLayerAdded, this);\n\t\t\tscene.layers.on('remove', this.onLayerRemoved, this);\n\t\t}\n\t\tconst isAsset = this._type === 'asset';\n\t\tif (this._meshInstances && this._meshInstances.length) {\n\t\t\tthis.addToLayers();\n\t\t} else if (isAsset && this.asset) {\n\t\t\tthis._onRenderAssetAdded();\n\t\t}\n\t\tfor (let i = 0; i < this._materialReferences.length; i++) {\n\t\t\tif (this._materialReferences[i].asset) {\n\t\t\t\tthis.system.app.assets.load(this._materialReferences[i].asset);\n\t\t\t}\n\t\t}\n\t\tif (this._batchGroupId >= 0) {\n\t\t\tvar _app$batcher;\n\t\t\t(_app$batcher = app.batcher) == null || _app$batcher.insert(BatchGroup.RENDER, this.batchGroupId, this.entity);\n\t\t}\n\t}\n\tonDisable() {\n\t\tconst app = this.system.app;\n\t\tconst scene = app.scene;\n\t\tscene.off('set:layers', this.onLayersChanged, this);\n\t\tif (scene.layers) {\n\t\t\tscene.layers.off('add', this.onLayerAdded, this);\n\t\t\tscene.layers.off('remove', this.onLayerRemoved, this);\n\t\t}\n\t\tif (this._batchGroupId >= 0) {\n\t\t\tvar _app$batcher2;\n\t\t\t(_app$batcher2 = app.batcher) == null || _app$batcher2.remove(BatchGroup.RENDER, this.batchGroupId, this.entity);\n\t\t}\n\t\tthis.removeFromLayers();\n\t}\n\thide() {\n\t\tif (this._meshInstances) {\n\t\t\tfor (let i = 0; i < this._meshInstances.length; i++) {\n\t\t\t\tthis._meshInstances[i].visible = false;\n\t\t\t}\n\t\t}\n\t}\n\tshow() {\n\t\tif (this._meshInstances) {\n\t\t\tfor (let i = 0; i < this._meshInstances.length; i++) {\n\t\t\t\tthis._meshInstances[i].visible = true;\n\t\t\t}\n\t\t}\n\t}\n\t_onRenderAssetAdded() {\n\t\tif (!this._assetReference.asset) return;\n\t\tif (this._assetReference.asset.resource) {\n\t\t\tthis._onRenderAssetLoad();\n\t\t} else if (this.enabled && this.entity.enabled) {\n\t\t\tthis.system.app.assets.load(this._assetReference.asset);\n\t\t}\n\t}\n\t_onRenderAssetLoad() {\n\t\tthis.destroyMeshInstances();\n\t\tif (this._assetReference.asset) {\n\t\t\tconst render = this._assetReference.asset.resource;\n\t\t\trender.off('set:meshes', this._onSetMeshes, this);\n\t\t\trender.on('set:meshes', this._onSetMeshes, this);\n\t\t\tif (render.meshes) {\n\t\t\t\tthis._onSetMeshes(render.meshes);\n\t\t\t}\n\t\t}\n\t}\n\t_onSetMeshes(meshes) {\n\t\tthis._cloneMeshes(meshes);\n\t}\n\t_clearSkinInstances() {\n\t\tfor (let i = 0; i < this._meshInstances.length; i++) {\n\t\t\tconst meshInstance = this._meshInstances[i];\n\t\t\tSkinInstanceCache.removeCachedSkinInstance(meshInstance.skinInstance);\n\t\t\tmeshInstance.skinInstance = null;\n\t\t}\n\t}\n\t_cloneSkinInstances() {\n\t\tif (this._meshInstances.length && this._rootBone.entity instanceof GraphNode) {\n\t\t\tfor (let i = 0; i < this._meshInstances.length; i++) {\n\t\t\t\tconst meshInstance = this._meshInstances[i];\n\t\t\t\tconst mesh = meshInstance.mesh;\n\t\t\t\tif (mesh.skin && !meshInstance.skinInstance) {\n\t\t\t\t\tmeshInstance.skinInstance = SkinInstanceCache.createCachedSkinInstance(mesh.skin, this._rootBone.entity, this.entity);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\t_cloneMeshes(meshes) {\n\t\tif (meshes && meshes.length) {\n\t\t\tconst meshInstances = [];\n\t\t\tfor (let i = 0; i < meshes.length; i++) {\n\t\t\t\tconst mesh = meshes[i];\n\t\t\t\tconst material = this._materialReferences[i] && this._materialReferences[i].asset && this._materialReferences[i].asset.resource;\n\t\t\t\tconst meshInst = new MeshInstance(mesh, material || this.system.defaultMaterial, this.entity);\n\t\t\t\tmeshInstances.push(meshInst);\n\t\t\t\tif (mesh.morph) {\n\t\t\t\t\tmeshInst.morphInstance = new MorphInstance(mesh.morph);\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis.meshInstances = meshInstances;\n\t\t\tthis._cloneSkinInstances();\n\t\t}\n\t}\n\t_onRenderAssetUnload() {\n\t\tif (this._type === 'asset') {\n\t\t\tthis.destroyMeshInstances();\n\t\t}\n\t}\n\t_onRenderAssetRemove() {\n\t\tif (this._assetReference.asset && this._assetReference.asset.resource) {\n\t\t\tthis._assetReference.asset.resource.off('set:meshes', this._onSetMeshes, this);\n\t\t}\n\t\tthis._onRenderAssetUnload();\n\t}\n\t_onMaterialAdded(index, component, asset) {\n\t\tif (asset.resource) {\n\t\t\tthis._onMaterialLoad(index, component, asset);\n\t\t} else {\n\t\t\tif (this.enabled && this.entity.enabled) {\n\t\t\t\tthis.system.app.assets.load(asset);\n\t\t\t}\n\t\t}\n\t}\n\t_updateMainMaterial(index, material) {\n\t\tif (index === 0) {\n\t\t\tthis.material = material;\n\t\t}\n\t}\n\t_onMaterialLoad(index, component, asset) {\n\t\tif (this._meshInstances[index]) {\n\t\t\tthis._meshInstances[index].material = asset.resource;\n\t\t}\n\t\tthis._updateMainMaterial(index, asset.resource);\n\t}\n\t_onMaterialRemove(index, component, asset) {\n\t\tif (this._meshInstances[index]) {\n\t\t\tthis._meshInstances[index].material = this.system.defaultMaterial;\n\t\t}\n\t\tthis._updateMainMaterial(index, this.system.defaultMaterial);\n\t}\n\t_onMaterialUnload(index, component, asset) {\n\t\tif (this._meshInstances[index]) {\n\t\t\tthis._meshInstances[index].material = this.system.defaultMaterial;\n\t\t}\n\t\tthis._updateMainMaterial(index, this.system.defaultMaterial);\n\t}\n\tresolveDuplicatedEntityReferenceProperties(oldRender, duplicatedIdsMap) {\n\t\tif (oldRender.rootBone && duplicatedIdsMap[oldRender.rootBone]) {\n\t\t\tthis.rootBone = duplicatedIdsMap[oldRender.rootBone];\n\t\t}\n\t\tthis._clearSkinInstances();\n\t}\n}\n\nexport { RenderComponent };\n", "class RenderComponentData {\n\tconstructor() {\n\t\tthis.enabled = true;\n\t\tthis.rootBone = null;\n\t}\n}\n\nexport { RenderComponentData };\n", "import { Vec3 } from '../../../core/math/vec3.js';\nimport { BoundingBox } from '../../../core/shape/bounding-box.js';\nimport { getDefaultMaterial } from '../../../scene/materials/default-material.js';\nimport { Component } from '../component.js';\nimport { ComponentSystem } from '../system.js';\nimport { RenderComponent } from './component.js';\nimport { RenderComponentData } from './data.js';\n\nconst _schema = [{\n\tname: 'rootBone',\n\ttype: 'entity'\n}, 'enabled'];\nconst _properties = ['material', 'meshInstances', 'asset', 'materialAssets', 'castShadows', 'receiveShadows', 'castShadowsLightmap', 'lightmapped', 'lightmapSizeMultiplier', 'renderStyle', 'type', 'layers', 'isStatic', 'batchGroupId'];\nclass RenderComponentSystem extends ComponentSystem {\n\tconstructor(app) {\n\t\tsuper(app);\n\t\tthis.id = 'render';\n\t\tthis.ComponentType = RenderComponent;\n\t\tthis.DataType = RenderComponentData;\n\t\tthis.schema = _schema;\n\t\tthis.defaultMaterial = getDefaultMaterial(app.graphicsDevice);\n\t\tthis.on('beforeremove', this.onRemove, this);\n\t}\n\tinitializeComponentData(component, _data, properties) {\n\t\tif (_data.batchGroupId === null || _data.batchGroupId === undefined) {\n\t\t\t_data.batchGroupId = -1;\n\t\t}\n\t\tif (_data.layers && _data.layers.length) {\n\t\t\t_data.layers = _data.layers.slice(0);\n\t\t}\n\t\tfor (let i = 0; i < _properties.length; i++) {\n\t\t\tif (_data.hasOwnProperty(_properties[i])) {\n\t\t\t\tcomponent[_properties[i]] = _data[_properties[i]];\n\t\t\t}\n\t\t}\n\t\tif (_data.aabbCenter && _data.aabbHalfExtents) {\n\t\t\tcomponent.customAabb = new BoundingBox(new Vec3(_data.aabbCenter), new Vec3(_data.aabbHalfExtents));\n\t\t}\n\t\tsuper.initializeComponentData(component, _data, _schema);\n\t}\n\tcloneComponent(entity, clone) {\n\t\tconst data = {};\n\t\tfor (let i = 0; i < _properties.length; i++) {\n\t\t\tdata[_properties[i]] = entity.render[_properties[i]];\n\t\t}\n\t\tdata.enabled = entity.render.enabled;\n\t\tdelete data.meshInstances;\n\t\tconst component = this.addComponent(clone, data);\n\t\tconst srcMeshInstances = entity.render.meshInstances;\n\t\tconst meshes = srcMeshInstances.map(mi => mi.mesh);\n\t\tcomponent._onSetMeshes(meshes);\n\t\tfor (let m = 0; m < srcMeshInstances.length; m++) {\n\t\t\tcomponent.meshInstances[m].material = srcMeshInstances[m].material;\n\t\t}\n\t\tif (entity.render.customAabb) {\n\t\t\tcomponent.customAabb = entity.render.customAabb.clone();\n\t\t}\n\t\treturn component;\n\t}\n\tonRemove(entity, component) {\n\t\tcomponent.onRemove();\n\t}\n}\nComponent._buildAccessors(RenderComponent.prototype, _schema);\n\nexport { RenderComponentSystem };\n", "class ObjectPool {\n\tconstructor(constructorFunc, size) {\n\t\tthis._constructor = void 0;\n\t\tthis._pool = [];\n\t\tthis._count = 0;\n\t\tthis._constructor = constructorFunc;\n\t\tthis._resize(size);\n\t}\n\t_resize(size) {\n\t\tif (size > this._pool.length) {\n\t\t\tfor (let i = this._pool.length; i < size; i++) {\n\t\t\t\tthis._pool[i] = new this._constructor();\n\t\t\t}\n\t\t}\n\t}\n\tallocate() {\n\t\tif (this._count >= this._pool.length) {\n\t\t\tthis._resize(this._pool.length * 2);\n\t\t}\n\t\treturn this._pool[this._count++];\n\t}\n\tfreeAll() {\n\t\tthis._count = 0;\n\t}\n}\n\nexport { ObjectPool };\n", "import { Quat } from '../../../core/math/quat.js';\nimport { Vec3 } from '../../../core/math/vec3.js';\nimport { BODYGROUP_STATIC, BODYMASK_NOT_STATIC, BODYTYPE_STATIC, BODYTYPE_DYNAMIC, BODYTYPE_KINEMATIC, BODYGROUP_KINEMATIC, BODYMASK_ALL, BODYGROUP_DYNAMIC, BODYFLAG_KINEMATIC_OBJECT, BODYSTATE_DISABLE_DEACTIVATION, BODYSTATE_ACTIVE_TAG, BODYSTATE_DISABLE_SIMULATION } from './constants.js';\nimport { Component } from '../component.js';\n\nlet _ammoTransform;\nlet _ammoVec1, _ammoVec2, _ammoQuat;\nconst _quat1 = new Quat();\nconst _quat2 = new Quat();\nconst _vec3 = new Vec3();\nclass RigidBodyComponent extends Component {\n\tconstructor(system, entity) {\n\t\tsuper(system, entity);\n\t\tthis._angularDamping = 0;\n\t\tthis._angularFactor = new Vec3(1, 1, 1);\n\t\tthis._angularVelocity = new Vec3();\n\t\tthis._body = null;\n\t\tthis._friction = 0.5;\n\t\tthis._group = BODYGROUP_STATIC;\n\t\tthis._linearDamping = 0;\n\t\tthis._linearFactor = new Vec3(1, 1, 1);\n\t\tthis._linearVelocity = new Vec3();\n\t\tthis._mask = BODYMASK_NOT_STATIC;\n\t\tthis._mass = 1;\n\t\tthis._restitution = 0;\n\t\tthis._rollingFriction = 0;\n\t\tthis._simulationEnabled = false;\n\t\tthis._type = BODYTYPE_STATIC;\n\t}\n\tstatic onLibraryLoaded() {\n\t\tif (typeof Ammo !== 'undefined') {\n\t\t\t_ammoTransform = new Ammo.btTransform();\n\t\t\t_ammoVec1 = new Ammo.btVector3();\n\t\t\t_ammoVec2 = new Ammo.btVector3();\n\t\t\t_ammoQuat = new Ammo.btQuaternion();\n\t\t}\n\t}\n\tset angularDamping(damping) {\n\t\tif (this._angularDamping !== damping) {\n\t\t\tthis._angularDamping = damping;\n\t\t\tif (this._body) {\n\t\t\t\tthis._body.setDamping(this._linearDamping, damping);\n\t\t\t}\n\t\t}\n\t}\n\tget angularDamping() {\n\t\treturn this._angularDamping;\n\t}\n\tset angularFactor(factor) {\n\t\tif (!this._angularFactor.equals(factor)) {\n\t\t\tthis._angularFactor.copy(factor);\n\t\t\tif (this._body && this._type === BODYTYPE_DYNAMIC) {\n\t\t\t\t_ammoVec1.setValue(factor.x, factor.y, factor.z);\n\t\t\t\tthis._body.setAngularFactor(_ammoVec1);\n\t\t\t}\n\t\t}\n\t}\n\tget angularFactor() {\n\t\treturn this._angularFactor;\n\t}\n\tset angularVelocity(velocity) {\n\t\tif (this._body && this._type === BODYTYPE_DYNAMIC) {\n\t\t\tthis._body.activate();\n\t\t\t_ammoVec1.setValue(velocity.x, velocity.y, velocity.z);\n\t\t\tthis._body.setAngularVelocity(_ammoVec1);\n\t\t\tthis._angularVelocity.copy(velocity);\n\t\t}\n\t}\n\tget angularVelocity() {\n\t\tif (this._body && this._type === BODYTYPE_DYNAMIC) {\n\t\t\tconst velocity = this._body.getAngularVelocity();\n\t\t\tthis._angularVelocity.set(velocity.x(), velocity.y(), velocity.z());\n\t\t}\n\t\treturn this._angularVelocity;\n\t}\n\tset body(body) {\n\t\tif (this._body !== body) {\n\t\t\tthis._body = body;\n\t\t\tif (body && this._simulationEnabled) {\n\t\t\t\tbody.activate();\n\t\t\t}\n\t\t}\n\t}\n\tget body() {\n\t\treturn this._body;\n\t}\n\tset friction(friction) {\n\t\tif (this._friction !== friction) {\n\t\t\tthis._friction = friction;\n\t\t\tif (this._body) {\n\t\t\t\tthis._body.setFriction(friction);\n\t\t\t}\n\t\t}\n\t}\n\tget friction() {\n\t\treturn this._friction;\n\t}\n\tset group(group) {\n\t\tif (this._group !== group) {\n\t\t\tthis._group = group;\n\t\t\tif (this.enabled && this.entity.enabled) {\n\t\t\t\tthis.disableSimulation();\n\t\t\t\tthis.enableSimulation();\n\t\t\t}\n\t\t}\n\t}\n\tget group() {\n\t\treturn this._group;\n\t}\n\tset linearDamping(damping) {\n\t\tif (this._linearDamping !== damping) {\n\t\t\tthis._linearDamping = damping;\n\t\t\tif (this._body) {\n\t\t\t\tthis._body.setDamping(damping, this._angularDamping);\n\t\t\t}\n\t\t}\n\t}\n\tget linearDamping() {\n\t\treturn this._linearDamping;\n\t}\n\tset linearFactor(factor) {\n\t\tif (!this._linearFactor.equals(factor)) {\n\t\t\tthis._linearFactor.copy(factor);\n\t\t\tif (this._body && this._type === BODYTYPE_DYNAMIC) {\n\t\t\t\t_ammoVec1.setValue(factor.x, factor.y, factor.z);\n\t\t\t\tthis._body.setLinearFactor(_ammoVec1);\n\t\t\t}\n\t\t}\n\t}\n\tget linearFactor() {\n\t\treturn this._linearFactor;\n\t}\n\tset linearVelocity(velocity) {\n\t\tif (this._body && this._type === BODYTYPE_DYNAMIC) {\n\t\t\tthis._body.activate();\n\t\t\t_ammoVec1.setValue(velocity.x, velocity.y, velocity.z);\n\t\t\tthis._body.setLinearVelocity(_ammoVec1);\n\t\t\tthis._linearVelocity.copy(velocity);\n\t\t}\n\t}\n\tget linearVelocity() {\n\t\tif (this._body && this._type === BODYTYPE_DYNAMIC) {\n\t\t\tconst velocity = this._body.getLinearVelocity();\n\t\t\tthis._linearVelocity.set(velocity.x(), velocity.y(), velocity.z());\n\t\t}\n\t\treturn this._linearVelocity;\n\t}\n\tset mask(mask) {\n\t\tif (this._mask !== mask) {\n\t\t\tthis._mask = mask;\n\t\t\tif (this.enabled && this.entity.enabled) {\n\t\t\t\tthis.disableSimulation();\n\t\t\t\tthis.enableSimulation();\n\t\t\t}\n\t\t}\n\t}\n\tget mask() {\n\t\treturn this._mask;\n\t}\n\tset mass(mass) {\n\t\tif (this._mass !== mass) {\n\t\t\tthis._mass = mass;\n\t\t\tif (this._body && this._type === BODYTYPE_DYNAMIC) {\n\t\t\t\tconst enabled = this.enabled && this.entity.enabled;\n\t\t\t\tif (enabled) {\n\t\t\t\t\tthis.disableSimulation();\n\t\t\t\t}\n\t\t\t\tthis._body.getCollisionShape().calculateLocalInertia(mass, _ammoVec1);\n\t\t\t\tthis._body.setMassProps(mass, _ammoVec1);\n\t\t\t\tthis._body.updateInertiaTensor();\n\t\t\t\tif (enabled) {\n\t\t\t\t\tthis.enableSimulation();\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\tget mass() {\n\t\treturn this._mass;\n\t}\n\tset restitution(restitution) {\n\t\tif (this._restitution !== restitution) {\n\t\t\tthis._restitution = restitution;\n\t\t\tif (this._body) {\n\t\t\t\tthis._body.setRestitution(restitution);\n\t\t\t}\n\t\t}\n\t}\n\tget restitution() {\n\t\treturn this._restitution;\n\t}\n\tset rollingFriction(friction) {\n\t\tif (this._rollingFriction !== friction) {\n\t\t\tthis._rollingFriction = friction;\n\t\t\tif (this._body) {\n\t\t\t\tthis._body.setRollingFriction(friction);\n\t\t\t}\n\t\t}\n\t}\n\tget rollingFriction() {\n\t\treturn this._rollingFriction;\n\t}\n\tset type(type) {\n\t\tif (this._type !== type) {\n\t\t\tthis._type = type;\n\t\t\tthis.disableSimulation();\n\t\t\tswitch (type) {\n\t\t\t\tcase BODYTYPE_DYNAMIC:\n\t\t\t\t\tthis._group = BODYGROUP_DYNAMIC;\n\t\t\t\t\tthis._mask = BODYMASK_ALL;\n\t\t\t\t\tbreak;\n\t\t\t\tcase BODYTYPE_KINEMATIC:\n\t\t\t\t\tthis._group = BODYGROUP_KINEMATIC;\n\t\t\t\t\tthis._mask = BODYMASK_ALL;\n\t\t\t\t\tbreak;\n\t\t\t\tcase BODYTYPE_STATIC:\n\t\t\t\tdefault:\n\t\t\t\t\tthis._group = BODYGROUP_STATIC;\n\t\t\t\t\tthis._mask = BODYMASK_NOT_STATIC;\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t\tthis.createBody();\n\t\t}\n\t}\n\tget type() {\n\t\treturn this._type;\n\t}\n\tcreateBody() {\n\t\tconst entity = this.entity;\n\t\tlet shape;\n\t\tif (entity.collision) {\n\t\t\tshape = entity.collision.shape;\n\t\t\tif (entity.trigger) {\n\t\t\t\tentity.trigger.destroy();\n\t\t\t\tdelete entity.trigger;\n\t\t\t}\n\t\t}\n\t\tif (shape) {\n\t\t\tif (this._body) {\n\t\t\t\tthis.system.removeBody(this._body);\n\t\t\t\tthis.system.destroyBody(this._body);\n\t\t\t\tthis._body = null;\n\t\t\t}\n\t\t\tconst mass = this._type === BODYTYPE_DYNAMIC ? this._mass : 0;\n\t\t\tthis._getEntityTransform(_ammoTransform);\n\t\t\tconst body = this.system.createBody(mass, shape, _ammoTransform);\n\t\t\tbody.setRestitution(this._restitution);\n\t\t\tbody.setFriction(this._friction);\n\t\t\tbody.setRollingFriction(this._rollingFriction);\n\t\t\tbody.setDamping(this._linearDamping, this._angularDamping);\n\t\t\tif (this._type === BODYTYPE_DYNAMIC) {\n\t\t\t\tconst linearFactor = this._linearFactor;\n\t\t\t\t_ammoVec1.setValue(linearFactor.x, linearFactor.y, linearFactor.z);\n\t\t\t\tbody.setLinearFactor(_ammoVec1);\n\t\t\t\tconst angularFactor = this._angularFactor;\n\t\t\t\t_ammoVec1.setValue(angularFactor.x, angularFactor.y, angularFactor.z);\n\t\t\t\tbody.setAngularFactor(_ammoVec1);\n\t\t\t} else if (this._type === BODYTYPE_KINEMATIC) {\n\t\t\t\tbody.setCollisionFlags(body.getCollisionFlags() | BODYFLAG_KINEMATIC_OBJECT);\n\t\t\t\tbody.setActivationState(BODYSTATE_DISABLE_DEACTIVATION);\n\t\t\t}\n\t\t\tbody.entity = entity;\n\t\t\tthis.body = body;\n\t\t\tif (this.enabled && entity.enabled) {\n\t\t\t\tthis.enableSimulation();\n\t\t\t}\n\t\t}\n\t}\n\tisActive() {\n\t\treturn this._body ? this._body.isActive() : false;\n\t}\n\tactivate() {\n\t\tif (this._body) {\n\t\t\tthis._body.activate();\n\t\t}\n\t}\n\tenableSimulation() {\n\t\tconst entity = this.entity;\n\t\tif (entity.collision && entity.collision.enabled && !this._simulationEnabled) {\n\t\t\tconst body = this._body;\n\t\t\tif (body) {\n\t\t\t\tthis.system.addBody(body, this._group, this._mask);\n\t\t\t\tswitch (this._type) {\n\t\t\t\t\tcase BODYTYPE_DYNAMIC:\n\t\t\t\t\t\tthis.system._dynamic.push(this);\n\t\t\t\t\t\tbody.forceActivationState(BODYSTATE_ACTIVE_TAG);\n\t\t\t\t\t\tthis.syncEntityToBody();\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase BODYTYPE_KINEMATIC:\n\t\t\t\t\t\tthis.system._kinematic.push(this);\n\t\t\t\t\t\tbody.forceActivationState(BODYSTATE_DISABLE_DEACTIVATION);\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase BODYTYPE_STATIC:\n\t\t\t\t\t\tbody.forceActivationState(BODYSTATE_ACTIVE_TAG);\n\t\t\t\t\t\tthis.syncEntityToBody();\n\t\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\tif (entity.collision.type === 'compound') {\n\t\t\t\t\tthis.system._compounds.push(entity.collision);\n\t\t\t\t}\n\t\t\t\tbody.activate();\n\t\t\t\tthis._simulationEnabled = true;\n\t\t\t}\n\t\t}\n\t}\n\tdisableSimulation() {\n\t\tconst body = this._body;\n\t\tif (body && this._simulationEnabled) {\n\t\t\tconst system = this.system;\n\t\t\tlet idx = system._compounds.indexOf(this.entity.collision);\n\t\t\tif (idx > -1) {\n\t\t\t\tsystem._compounds.splice(idx, 1);\n\t\t\t}\n\t\t\tidx = system._dynamic.indexOf(this);\n\t\t\tif (idx > -1) {\n\t\t\t\tsystem._dynamic.splice(idx, 1);\n\t\t\t}\n\t\t\tidx = system._kinematic.indexOf(this);\n\t\t\tif (idx > -1) {\n\t\t\t\tsystem._kinematic.splice(idx, 1);\n\t\t\t}\n\t\t\tsystem.removeBody(body);\n\t\t\tbody.forceActivationState(BODYSTATE_DISABLE_SIMULATION);\n\t\t\tthis._simulationEnabled = false;\n\t\t}\n\t}\n\tapplyForce(x, y, z, px, py, pz) {\n\t\tconst body = this._body;\n\t\tif (body) {\n\t\t\tbody.activate();\n\t\t\tif (x instanceof Vec3) {\n\t\t\t\t_ammoVec1.setValue(x.x, x.y, x.z);\n\t\t\t} else {\n\t\t\t\t_ammoVec1.setValue(x, y, z);\n\t\t\t}\n\t\t\tif (y instanceof Vec3) {\n\t\t\t\t_ammoVec2.setValue(y.x, y.y, y.z);\n\t\t\t} else if (px !== undefined) {\n\t\t\t\t_ammoVec2.setValue(px, py, pz);\n\t\t\t} else {\n\t\t\t\t_ammoVec2.setValue(0, 0, 0);\n\t\t\t}\n\t\t\tbody.applyForce(_ammoVec1, _ammoVec2);\n\t\t}\n\t}\n\tapplyTorque(x, y, z) {\n\t\tconst body = this._body;\n\t\tif (body) {\n\t\t\tbody.activate();\n\t\t\tif (x instanceof Vec3) {\n\t\t\t\t_ammoVec1.setValue(x.x, x.y, x.z);\n\t\t\t} else {\n\t\t\t\t_ammoVec1.setValue(x, y, z);\n\t\t\t}\n\t\t\tbody.applyTorque(_ammoVec1);\n\t\t}\n\t}\n\tapplyImpulse(x, y, z, px, py, pz) {\n\t\tconst body = this._body;\n\t\tif (body) {\n\t\t\tbody.activate();\n\t\t\tif (x instanceof Vec3) {\n\t\t\t\t_ammoVec1.setValue(x.x, x.y, x.z);\n\t\t\t} else {\n\t\t\t\t_ammoVec1.setValue(x, y, z);\n\t\t\t}\n\t\t\tif (y instanceof Vec3) {\n\t\t\t\t_ammoVec2.setValue(y.x, y.y, y.z);\n\t\t\t} else if (px !== undefined) {\n\t\t\t\t_ammoVec2.setValue(px, py, pz);\n\t\t\t} else {\n\t\t\t\t_ammoVec2.setValue(0, 0, 0);\n\t\t\t}\n\t\t\tbody.applyImpulse(_ammoVec1, _ammoVec2);\n\t\t}\n\t}\n\tapplyTorqueImpulse(x, y, z) {\n\t\tconst body = this._body;\n\t\tif (body) {\n\t\t\tbody.activate();\n\t\t\tif (x instanceof Vec3) {\n\t\t\t\t_ammoVec1.setValue(x.x, x.y, x.z);\n\t\t\t} else {\n\t\t\t\t_ammoVec1.setValue(x, y, z);\n\t\t\t}\n\t\t\tbody.applyTorqueImpulse(_ammoVec1);\n\t\t}\n\t}\n\tisStatic() {\n\t\treturn this._type === BODYTYPE_STATIC;\n\t}\n\tisStaticOrKinematic() {\n\t\treturn this._type === BODYTYPE_STATIC || this._type === BODYTYPE_KINEMATIC;\n\t}\n\tisKinematic() {\n\t\treturn this._type === BODYTYPE_KINEMATIC;\n\t}\n\t_getEntityTransform(transform) {\n\t\tconst entity = this.entity;\n\t\tconst component = entity.collision;\n\t\tif (component) {\n\t\t\tconst bodyPos = component.getShapePosition();\n\t\t\tconst bodyRot = component.getShapeRotation();\n\t\t\t_ammoVec1.setValue(bodyPos.x, bodyPos.y, bodyPos.z);\n\t\t\t_ammoQuat.setValue(bodyRot.x, bodyRot.y, bodyRot.z, bodyRot.w);\n\t\t} else {\n\t\t\tconst pos = entity.getPosition();\n\t\t\tconst rot = entity.getRotation();\n\t\t\t_ammoVec1.setValue(pos.x, pos.y, pos.z);\n\t\t\t_ammoQuat.setValue(rot.x, rot.y, rot.z, rot.w);\n\t\t}\n\t\ttransform.setOrigin(_ammoVec1);\n\t\ttransform.setRotation(_ammoQuat);\n\t}\n\tsyncEntityToBody() {\n\t\tconst body = this._body;\n\t\tif (body) {\n\t\t\tthis._getEntityTransform(_ammoTransform);\n\t\t\tbody.setWorldTransform(_ammoTransform);\n\t\t\tif (this._type === BODYTYPE_KINEMATIC) {\n\t\t\t\tconst motionState = body.getMotionState();\n\t\t\t\tif (motionState) {\n\t\t\t\t\tmotionState.setWorldTransform(_ammoTransform);\n\t\t\t\t}\n\t\t\t}\n\t\t\tbody.activate();\n\t\t}\n\t}\n\t_updateDynamic() {\n\t\tconst body = this._body;\n\t\tif (body.isActive()) {\n\t\t\tconst motionState = body.getMotionState();\n\t\t\tif (motionState) {\n\t\t\t\tconst entity = this.entity;\n\t\t\t\tmotionState.getWorldTransform(_ammoTransform);\n\t\t\t\tconst p = _ammoTransform.getOrigin();\n\t\t\t\tconst q = _ammoTransform.getRotation();\n\t\t\t\tconst component = entity.collision;\n\t\t\t\tif (component && component._hasOffset) {\n\t\t\t\t\tconst lo = component.data.linearOffset;\n\t\t\t\t\tconst ao = component.data.angularOffset;\n\t\t\t\t\tconst invertedAo = _quat2.copy(ao).invert();\n\t\t\t\t\tconst entityRot = _quat1.set(q.x(), q.y(), q.z(), q.w()).mul(invertedAo);\n\t\t\t\t\tentityRot.transformVector(lo, _vec3);\n\t\t\t\t\tentity.setPosition(p.x() - _vec3.x, p.y() - _vec3.y, p.z() - _vec3.z);\n\t\t\t\t\tentity.setRotation(entityRot);\n\t\t\t\t} else {\n\t\t\t\t\tentity.setPosition(p.x(), p.y(), p.z());\n\t\t\t\t\tentity.setRotation(q.x(), q.y(), q.z(), q.w());\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\t_updateKinematic() {\n\t\tconst motionState = this._body.getMotionState();\n\t\tif (motionState) {\n\t\t\tthis._getEntityTransform(_ammoTransform);\n\t\t\tmotionState.setWorldTransform(_ammoTransform);\n\t\t}\n\t}\n\tteleport(x, y, z, rx, ry, rz) {\n\t\tif (x instanceof Vec3) {\n\t\t\tthis.entity.setPosition(x);\n\t\t} else {\n\t\t\tthis.entity.setPosition(x, y, z);\n\t\t}\n\t\tif (y instanceof Quat) {\n\t\t\tthis.entity.setRotation(y);\n\t\t} else if (y instanceof Vec3) {\n\t\t\tthis.entity.setEulerAngles(y);\n\t\t} else if (rx !== undefined) {\n\t\t\tthis.entity.setEulerAngles(rx, ry, rz);\n\t\t}\n\t\tthis.syncEntityToBody();\n\t}\n\tonEnable() {\n\t\tif (!this._body) {\n\t\t\tthis.createBody();\n\t\t}\n\t\tthis.enableSimulation();\n\t}\n\tonDisable() {\n\t\tthis.disableSimulation();\n\t}\n}\nRigidBodyComponent.EVENT_CONTACT = 'contact';\nRigidBodyComponent.EVENT_COLLISIONSTART = 'collisionstart';\nRigidBodyComponent.EVENT_COLLISIONEND = 'collisionend';\nRigidBodyComponent.EVENT_TRIGGERENTER = 'triggerenter';\nRigidBodyComponent.EVENT_TRIGGERLEAVE = 'triggerleave';\n\nexport { RigidBodyComponent };\n", "class RigidBodyComponentData {\n\tconstructor() {\n\t\tthis.enabled = true;\n\t}\n}\n\nexport { RigidBodyComponentData };\n", "import { ObjectPool } from '../../../core/object-pool.js';\nimport { Vec3 } from '../../../core/math/vec3.js';\nimport { Component } from '../component.js';\nimport { ComponentSystem } from '../system.js';\nimport { BODYFLAG_NORESPONSE_OBJECT } from './constants.js';\nimport { RigidBodyComponent } from './component.js';\nimport { RigidBodyComponentData } from './data.js';\n\nlet ammoRayStart, ammoRayEnd;\nclass RaycastResult {\n\tconstructor(entity, point, normal, hitFraction) {\n\t\tthis.entity = void 0;\n\t\tthis.point = void 0;\n\t\tthis.normal = void 0;\n\t\tthis.hitFraction = void 0;\n\t\tthis.entity = entity;\n\t\tthis.point = point;\n\t\tthis.normal = normal;\n\t\tthis.hitFraction = hitFraction;\n\t}\n}\nclass SingleContactResult {\n\tconstructor(a, b, contactPoint) {\n\t\tthis.a = void 0;\n\t\tthis.b = void 0;\n\t\tthis.impulse = void 0;\n\t\tthis.localPointA = void 0;\n\t\tthis.localPointB = void 0;\n\t\tthis.pointA = void 0;\n\t\tthis.pointB = void 0;\n\t\tthis.normal = void 0;\n\t\tif (arguments.length !== 0) {\n\t\t\tthis.a = a;\n\t\t\tthis.b = b;\n\t\t\tthis.impulse = contactPoint.impulse;\n\t\t\tthis.localPointA = contactPoint.localPoint;\n\t\t\tthis.localPointB = contactPoint.localPointOther;\n\t\t\tthis.pointA = contactPoint.point;\n\t\t\tthis.pointB = contactPoint.pointOther;\n\t\t\tthis.normal = contactPoint.normal;\n\t\t} else {\n\t\t\tthis.a = null;\n\t\t\tthis.b = null;\n\t\t\tthis.impulse = 0;\n\t\t\tthis.localPointA = new Vec3();\n\t\t\tthis.localPointB = new Vec3();\n\t\t\tthis.pointA = new Vec3();\n\t\t\tthis.pointB = new Vec3();\n\t\t\tthis.normal = new Vec3();\n\t\t}\n\t}\n}\nclass ContactPoint {\n\tconstructor(localPoint = new Vec3(), localPointOther = new Vec3(), point = new Vec3(), pointOther = new Vec3(), normal = new Vec3(), impulse = 0) {\n\t\tthis.localPoint = void 0;\n\t\tthis.localPointOther = void 0;\n\t\tthis.point = void 0;\n\t\tthis.pointOther = void 0;\n\t\tthis.normal = void 0;\n\t\tthis.impulse = void 0;\n\t\tthis.localPoint = localPoint;\n\t\tthis.localPointOther = localPointOther;\n\t\tthis.point = point;\n\t\tthis.pointOther = pointOther;\n\t\tthis.normal = normal;\n\t\tthis.impulse = impulse;\n\t}\n}\nclass ContactResult {\n\tconstructor(other, contacts) {\n\t\tthis.other = void 0;\n\t\tthis.contacts = void 0;\n\t\tthis.other = other;\n\t\tthis.contacts = contacts;\n\t}\n}\nconst _schema = ['enabled'];\nclass RigidBodyComponentSystem extends ComponentSystem {\n\tconstructor(app) {\n\t\tsuper(app);\n\t\tthis.maxSubSteps = 10;\n\t\tthis.fixedTimeStep = 1 / 60;\n\t\tthis.gravity = new Vec3(0, -9.81, 0);\n\t\tthis._gravityFloat32 = new Float32Array(3);\n\t\tthis._dynamic = [];\n\t\tthis._kinematic = [];\n\t\tthis._triggers = [];\n\t\tthis._compounds = [];\n\t\tthis.id = 'rigidbody';\n\t\tthis._stats = app.stats.frame;\n\t\tthis.ComponentType = RigidBodyComponent;\n\t\tthis.DataType = RigidBodyComponentData;\n\t\tthis.contactPointPool = null;\n\t\tthis.contactResultPool = null;\n\t\tthis.singleContactResultPool = null;\n\t\tthis.schema = _schema;\n\t\tthis.collisions = {};\n\t\tthis.frameCollisions = {};\n\t\tthis.on('beforeremove', this.onBeforeRemove, this);\n\t}\n\tonLibraryLoaded() {\n\t\tif (typeof Ammo !== 'undefined') {\n\t\t\tthis.collisionConfiguration = new Ammo.btDefaultCollisionConfiguration();\n\t\t\tthis.dispatcher = new Ammo.btCollisionDispatcher(this.collisionConfiguration);\n\t\t\tthis.overlappingPairCache = new Ammo.btDbvtBroadphase();\n\t\t\tthis.solver = new Ammo.btSequentialImpulseConstraintSolver();\n\t\t\tthis.dynamicsWorld = new Ammo.btDiscreteDynamicsWorld(this.dispatcher, this.overlappingPairCache, this.solver, this.collisionConfiguration);\n\t\t\tif (this.dynamicsWorld.setInternalTickCallback) {\n\t\t\t\tconst checkForCollisionsPointer = Ammo.addFunction(this._checkForCollisions.bind(this), 'vif');\n\t\t\t\tthis.dynamicsWorld.setInternalTickCallback(checkForCollisionsPointer);\n\t\t\t}\n\t\t\tammoRayStart = new Ammo.btVector3();\n\t\t\tammoRayEnd = new Ammo.btVector3();\n\t\t\tRigidBodyComponent.onLibraryLoaded();\n\t\t\tthis.contactPointPool = new ObjectPool(ContactPoint, 1);\n\t\t\tthis.contactResultPool = new ObjectPool(ContactResult, 1);\n\t\t\tthis.singleContactResultPool = new ObjectPool(SingleContactResult, 1);\n\t\t\tthis.app.systems.on('update', this.onUpdate, this);\n\t\t} else {\n\t\t\tthis.app.systems.off('update', this.onUpdate, this);\n\t\t}\n\t}\n\tinitializeComponentData(component, data, properties) {\n\t\tconst props = ['mass', 'linearDamping', 'angularDamping', 'linearFactor', 'angularFactor', 'friction', 'rollingFriction', 'restitution', 'type', 'group', 'mask'];\n\t\tfor (const property of props) {\n\t\t\tif (data.hasOwnProperty(property)) {\n\t\t\t\tconst value = data[property];\n\t\t\t\tif (Array.isArray(value)) {\n\t\t\t\t\tcomponent[property] = new Vec3(value[0], value[1], value[2]);\n\t\t\t\t} else {\n\t\t\t\t\tcomponent[property] = value;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tsuper.initializeComponentData(component, data, ['enabled']);\n\t}\n\tcloneComponent(entity, clone) {\n\t\tconst rigidbody = entity.rigidbody;\n\t\tconst data = {\n\t\t\tenabled: rigidbody.enabled,\n\t\t\tmass: rigidbody.mass,\n\t\t\tlinearDamping: rigidbody.linearDamping,\n\t\t\tangularDamping: rigidbody.angularDamping,\n\t\t\tlinearFactor: [rigidbody.linearFactor.x, rigidbody.linearFactor.y, rigidbody.linearFactor.z],\n\t\t\tangularFactor: [rigidbody.angularFactor.x, rigidbody.angularFactor.y, rigidbody.angularFactor.z],\n\t\t\tfriction: rigidbody.friction,\n\t\t\trollingFriction: rigidbody.rollingFriction,\n\t\t\trestitution: rigidbody.restitution,\n\t\t\ttype: rigidbody.type,\n\t\t\tgroup: rigidbody.group,\n\t\t\tmask: rigidbody.mask\n\t\t};\n\t\treturn this.addComponent(clone, data);\n\t}\n\tonBeforeRemove(entity, component) {\n\t\tif (component.enabled) {\n\t\t\tcomponent.enabled = false;\n\t\t}\n\t\tif (component.body) {\n\t\t\tthis.destroyBody(component.body);\n\t\t\tcomponent.body = null;\n\t\t}\n\t}\n\taddBody(body, group, mask) {\n\t\tif (group !== undefined && mask !== undefined) {\n\t\t\tthis.dynamicsWorld.addRigidBody(body, group, mask);\n\t\t} else {\n\t\t\tthis.dynamicsWorld.addRigidBody(body);\n\t\t}\n\t}\n\tremoveBody(body) {\n\t\tthis.dynamicsWorld.removeRigidBody(body);\n\t}\n\tcreateBody(mass, shape, transform) {\n\t\tconst localInertia = new Ammo.btVector3(0, 0, 0);\n\t\tif (mass !== 0) {\n\t\t\tshape.calculateLocalInertia(mass, localInertia);\n\t\t}\n\t\tconst motionState = new Ammo.btDefaultMotionState(transform);\n\t\tconst bodyInfo = new Ammo.btRigidBodyConstructionInfo(mass, motionState, shape, localInertia);\n\t\tconst body = new Ammo.btRigidBody(bodyInfo);\n\t\tAmmo.destroy(bodyInfo);\n\t\tAmmo.destroy(localInertia);\n\t\treturn body;\n\t}\n\tdestroyBody(body) {\n\t\tconst motionState = body.getMotionState();\n\t\tif (motionState) {\n\t\t\tAmmo.destroy(motionState);\n\t\t}\n\t\tAmmo.destroy(body);\n\t}\n\traycastFirst(start, end, options = {}) {\n\t\tif (options.filterTags || options.filterCallback) {\n\t\t\toptions.sort = true;\n\t\t\treturn this.raycastAll(start, end, options)[0] || null;\n\t\t}\n\t\tlet result = null;\n\t\tammoRayStart.setValue(start.x, start.y, start.z);\n\t\tammoRayEnd.setValue(end.x, end.y, end.z);\n\t\tconst rayCallback = new Ammo.ClosestRayResultCallback(ammoRayStart, ammoRayEnd);\n\t\tif (typeof options.filterCollisionGroup === 'number') {\n\t\t\trayCallback.set_m_collisionFilterGroup(options.filterCollisionGroup);\n\t\t}\n\t\tif (typeof options.filterCollisionMask === 'number') {\n\t\t\trayCallback.set_m_collisionFilterMask(options.filterCollisionMask);\n\t\t}\n\t\tthis.dynamicsWorld.rayTest(ammoRayStart, ammoRayEnd, rayCallback);\n\t\tif (rayCallback.hasHit()) {\n\t\t\tconst collisionObj = rayCallback.get_m_collisionObject();\n\t\t\tconst body = Ammo.castObject(collisionObj, Ammo.btRigidBody);\n\t\t\tif (body) {\n\t\t\t\tconst point = rayCallback.get_m_hitPointWorld();\n\t\t\t\tconst normal = rayCallback.get_m_hitNormalWorld();\n\t\t\t\tresult = new RaycastResult(body.entity, new Vec3(point.x(), point.y(), point.z()), new Vec3(normal.x(), normal.y(), normal.z()), rayCallback.get_m_closestHitFraction());\n\t\t\t}\n\t\t}\n\t\tAmmo.destroy(rayCallback);\n\t\treturn result;\n\t}\n\traycastAll(start, end, options = {}) {\n\t\tconst results = [];\n\t\tammoRayStart.setValue(start.x, start.y, start.z);\n\t\tammoRayEnd.setValue(end.x, end.y, end.z);\n\t\tconst rayCallback = new Ammo.AllHitsRayResultCallback(ammoRayStart, ammoRayEnd);\n\t\tif (typeof options.filterCollisionGroup === 'number') {\n\t\t\trayCallback.set_m_collisionFilterGroup(options.filterCollisionGroup);\n\t\t}\n\t\tif (typeof options.filterCollisionMask === 'number') {\n\t\t\trayCallback.set_m_collisionFilterMask(options.filterCollisionMask);\n\t\t}\n\t\tthis.dynamicsWorld.rayTest(ammoRayStart, ammoRayEnd, rayCallback);\n\t\tif (rayCallback.hasHit()) {\n\t\t\tconst collisionObjs = rayCallback.get_m_collisionObjects();\n\t\t\tconst points = rayCallback.get_m_hitPointWorld();\n\t\t\tconst normals = rayCallback.get_m_hitNormalWorld();\n\t\t\tconst hitFractions = rayCallback.get_m_hitFractions();\n\t\t\tconst numHits = collisionObjs.size();\n\t\t\tfor (let i = 0; i < numHits; i++) {\n\t\t\t\tconst body = Ammo.castObject(collisionObjs.at(i), Ammo.btRigidBody);\n\t\t\t\tif (body && body.entity) {\n\t\t\t\t\tif (options.filterTags && !body.entity.tags.has(...options.filterTags) || options.filterCallback && !options.filterCallback(body.entity)) {\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t\tconst point = points.at(i);\n\t\t\t\t\tconst normal = normals.at(i);\n\t\t\t\t\tconst result = new RaycastResult(body.entity, new Vec3(point.x(), point.y(), point.z()), new Vec3(normal.x(), normal.y(), normal.z()), hitFractions.at(i));\n\t\t\t\t\tresults.push(result);\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (options.sort) {\n\t\t\t\tresults.sort((a, b) => a.hitFraction - b.hitFraction);\n\t\t\t}\n\t\t}\n\t\tAmmo.destroy(rayCallback);\n\t\treturn results;\n\t}\n\t_storeCollision(entity, other) {\n\t\tlet isNewCollision = false;\n\t\tconst guid = entity.getGuid();\n\t\tthis.collisions[guid] = this.collisions[guid] || {\n\t\t\tothers: [],\n\t\t\tentity: entity\n\t\t};\n\t\tif (this.collisions[guid].others.indexOf(other) < 0) {\n\t\t\tthis.collisions[guid].others.push(other);\n\t\t\tisNewCollision = true;\n\t\t}\n\t\tthis.frameCollisions[guid] = this.frameCollisions[guid] || {\n\t\t\tothers: [],\n\t\t\tentity: entity\n\t\t};\n\t\tthis.frameCollisions[guid].others.push(other);\n\t\treturn isNewCollision;\n\t}\n\t_createContactPointFromAmmo(contactPoint) {\n\t\tconst localPointA = contactPoint.get_m_localPointA();\n\t\tconst localPointB = contactPoint.get_m_localPointB();\n\t\tconst positionWorldOnA = contactPoint.getPositionWorldOnA();\n\t\tconst positionWorldOnB = contactPoint.getPositionWorldOnB();\n\t\tconst normalWorldOnB = contactPoint.get_m_normalWorldOnB();\n\t\tconst contact = this.contactPointPool.allocate();\n\t\tcontact.localPoint.set(localPointA.x(), localPointA.y(), localPointA.z());\n\t\tcontact.localPointOther.set(localPointB.x(), localPointB.y(), localPointB.z());\n\t\tcontact.point.set(positionWorldOnA.x(), positionWorldOnA.y(), positionWorldOnA.z());\n\t\tcontact.pointOther.set(positionWorldOnB.x(), positionWorldOnB.y(), positionWorldOnB.z());\n\t\tcontact.normal.set(normalWorldOnB.x(), normalWorldOnB.y(), normalWorldOnB.z());\n\t\tcontact.impulse = contactPoint.getAppliedImpulse();\n\t\treturn contact;\n\t}\n\t_createReverseContactPointFromAmmo(contactPoint) {\n\t\tconst localPointA = contactPoint.get_m_localPointA();\n\t\tconst localPointB = contactPoint.get_m_localPointB();\n\t\tconst positionWorldOnA = contactPoint.getPositionWorldOnA();\n\t\tconst positionWorldOnB = contactPoint.getPositionWorldOnB();\n\t\tconst normalWorldOnB = contactPoint.get_m_normalWorldOnB();\n\t\tconst contact = this.contactPointPool.allocate();\n\t\tcontact.localPointOther.set(localPointA.x(), localPointA.y(), localPointA.z());\n\t\tcontact.localPoint.set(localPointB.x(), localPointB.y(), localPointB.z());\n\t\tcontact.pointOther.set(positionWorldOnA.x(), positionWorldOnA.y(), positionWorldOnA.z());\n\t\tcontact.point.set(positionWorldOnB.x(), positionWorldOnB.y(), positionWorldOnB.z());\n\t\tcontact.normal.set(normalWorldOnB.x(), normalWorldOnB.y(), normalWorldOnB.z());\n\t\tcontact.impulse = contactPoint.getAppliedImpulse();\n\t\treturn contact;\n\t}\n\t_createSingleContactResult(a, b, contactPoint) {\n\t\tconst result = this.singleContactResultPool.allocate();\n\t\tresult.a = a;\n\t\tresult.b = b;\n\t\tresult.localPointA = contactPoint.localPoint;\n\t\tresult.localPointB = contactPoint.localPointOther;\n\t\tresult.pointA = contactPoint.point;\n\t\tresult.pointB = contactPoint.pointOther;\n\t\tresult.normal = contactPoint.normal;\n\t\tresult.impulse = contactPoint.impulse;\n\t\treturn result;\n\t}\n\t_createContactResult(other, contacts) {\n\t\tconst result = this.contactResultPool.allocate();\n\t\tresult.other = other;\n\t\tresult.contacts = contacts;\n\t\treturn result;\n\t}\n\t_cleanOldCollisions() {\n\t\tfor (const guid in this.collisions) {\n\t\t\tif (this.collisions.hasOwnProperty(guid)) {\n\t\t\t\tconst frameCollision = this.frameCollisions[guid];\n\t\t\t\tconst collision = this.collisions[guid];\n\t\t\t\tconst entity = collision.entity;\n\t\t\t\tconst entityCollision = entity.collision;\n\t\t\t\tconst entityRigidbody = entity.rigidbody;\n\t\t\t\tconst others = collision.others;\n\t\t\t\tconst length = others.length;\n\t\t\t\tlet i = length;\n\t\t\t\twhile (i--) {\n\t\t\t\t\tconst other = others[i];\n\t\t\t\t\tif (!frameCollision || frameCollision.others.indexOf(other) < 0) {\n\t\t\t\t\t\tothers.splice(i, 1);\n\t\t\t\t\t\tif (entity.trigger) {\n\t\t\t\t\t\t\tif (entityCollision) {\n\t\t\t\t\t\t\t\tentityCollision.fire('triggerleave', other);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tif (other.rigidbody) {\n\t\t\t\t\t\t\t\tother.rigidbody.fire('triggerleave', entity);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else if (!other.trigger) {\n\t\t\t\t\t\t\tif (entityRigidbody) {\n\t\t\t\t\t\t\t\tentityRigidbody.fire('collisionend', other);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tif (entityCollision) {\n\t\t\t\t\t\t\t\tentityCollision.fire('collisionend', other);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tif (others.length === 0) {\n\t\t\t\t\tdelete this.collisions[guid];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\t_hasContactEvent(entity) {\n\t\tconst c = entity.collision;\n\t\tif (c && (c.hasEvent('collisionstart') || c.hasEvent('collisionend') || c.hasEvent('contact'))) {\n\t\t\treturn true;\n\t\t}\n\t\tconst r = entity.rigidbody;\n\t\treturn r && (r.hasEvent('collisionstart') || r.hasEvent('collisionend') || r.hasEvent('contact'));\n\t}\n\t_checkForCollisions(world, timeStep) {\n\t\tconst dynamicsWorld = Ammo.wrapPointer(world, Ammo.btDynamicsWorld);\n\t\tconst dispatcher = dynamicsWorld.getDispatcher();\n\t\tconst numManifolds = dispatcher.getNumManifolds();\n\t\tthis.frameCollisions = {};\n\t\tfor (let i = 0; i < numManifolds; i++) {\n\t\t\tconst manifold = dispatcher.getManifoldByIndexInternal(i);\n\t\t\tconst body0 = manifold.getBody0();\n\t\t\tconst body1 = manifold.getBody1();\n\t\t\tconst wb0 = Ammo.castObject(body0, Ammo.btRigidBody);\n\t\t\tconst wb1 = Ammo.castObject(body1, Ammo.btRigidBody);\n\t\t\tconst e0 = wb0.entity;\n\t\t\tconst e1 = wb1.entity;\n\t\t\tif (!e0 || !e1) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tconst flags0 = wb0.getCollisionFlags();\n\t\t\tconst flags1 = wb1.getCollisionFlags();\n\t\t\tconst numContacts = manifold.getNumContacts();\n\t\t\tconst forwardContacts = [];\n\t\t\tconst reverseContacts = [];\n\t\t\tlet newCollision;\n\t\t\tif (numContacts > 0) {\n\t\t\t\tif (flags0 & BODYFLAG_NORESPONSE_OBJECT || flags1 & BODYFLAG_NORESPONSE_OBJECT) {\n\t\t\t\t\tconst e0Events = e0.collision && (e0.collision.hasEvent('triggerenter') || e0.collision.hasEvent('triggerleave'));\n\t\t\t\t\tconst e1Events = e1.collision && (e1.collision.hasEvent('triggerenter') || e1.collision.hasEvent('triggerleave'));\n\t\t\t\t\tconst e0BodyEvents = e0.rigidbody && (e0.rigidbody.hasEvent('triggerenter') || e0.rigidbody.hasEvent('triggerleave'));\n\t\t\t\t\tconst e1BodyEvents = e1.rigidbody && (e1.rigidbody.hasEvent('triggerenter') || e1.rigidbody.hasEvent('triggerleave'));\n\t\t\t\t\tif (e0Events) {\n\t\t\t\t\t\tnewCollision = this._storeCollision(e0, e1);\n\t\t\t\t\t\tif (newCollision && !(flags1 & BODYFLAG_NORESPONSE_OBJECT)) {\n\t\t\t\t\t\t\te0.collision.fire('triggerenter', e1);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif (e1Events) {\n\t\t\t\t\t\tnewCollision = this._storeCollision(e1, e0);\n\t\t\t\t\t\tif (newCollision && !(flags0 & BODYFLAG_NORESPONSE_OBJECT)) {\n\t\t\t\t\t\t\te1.collision.fire('triggerenter', e0);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif (e0BodyEvents) {\n\t\t\t\t\t\tif (!newCollision) {\n\t\t\t\t\t\t\tnewCollision = this._storeCollision(e1, e0);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (newCollision) {\n\t\t\t\t\t\t\te0.rigidbody.fire('triggerenter', e1);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif (e1BodyEvents) {\n\t\t\t\t\t\tif (!newCollision) {\n\t\t\t\t\t\t\tnewCollision = this._storeCollision(e0, e1);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (newCollision) {\n\t\t\t\t\t\t\te1.rigidbody.fire('triggerenter', e0);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tconst e0Events = this._hasContactEvent(e0);\n\t\t\t\t\tconst e1Events = this._hasContactEvent(e1);\n\t\t\t\t\tconst globalEvents = this.hasEvent('contact');\n\t\t\t\t\tif (globalEvents || e0Events || e1Events) {\n\t\t\t\t\t\tfor (let j = 0; j < numContacts; j++) {\n\t\t\t\t\t\t\tconst btContactPoint = manifold.getContactPoint(j);\n\t\t\t\t\t\t\tconst contactPoint = this._createContactPointFromAmmo(btContactPoint);\n\t\t\t\t\t\t\tif (e0Events || e1Events) {\n\t\t\t\t\t\t\t\tforwardContacts.push(contactPoint);\n\t\t\t\t\t\t\t\tconst reverseContactPoint = this._createReverseContactPointFromAmmo(btContactPoint);\n\t\t\t\t\t\t\t\treverseContacts.push(reverseContactPoint);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tif (globalEvents) {\n\t\t\t\t\t\t\t\tconst result = this._createSingleContactResult(e0, e1, contactPoint);\n\t\t\t\t\t\t\t\tthis.fire('contact', result);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (e0Events) {\n\t\t\t\t\t\t\tconst forwardResult = this._createContactResult(e1, forwardContacts);\n\t\t\t\t\t\t\tnewCollision = this._storeCollision(e0, e1);\n\t\t\t\t\t\t\tif (e0.collision) {\n\t\t\t\t\t\t\t\te0.collision.fire('contact', forwardResult);\n\t\t\t\t\t\t\t\tif (newCollision) {\n\t\t\t\t\t\t\t\t\te0.collision.fire('collisionstart', forwardResult);\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tif (e0.rigidbody) {\n\t\t\t\t\t\t\t\te0.rigidbody.fire('contact', forwardResult);\n\t\t\t\t\t\t\t\tif (newCollision) {\n\t\t\t\t\t\t\t\t\te0.rigidbody.fire('collisionstart', forwardResult);\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (e1Events) {\n\t\t\t\t\t\t\tconst reverseResult = this._createContactResult(e0, reverseContacts);\n\t\t\t\t\t\t\tnewCollision = this._storeCollision(e1, e0);\n\t\t\t\t\t\t\tif (e1.collision) {\n\t\t\t\t\t\t\t\te1.collision.fire('contact', reverseResult);\n\t\t\t\t\t\t\t\tif (newCollision) {\n\t\t\t\t\t\t\t\t\te1.collision.fire('collisionstart', reverseResult);\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tif (e1.rigidbody) {\n\t\t\t\t\t\t\t\te1.rigidbody.fire('contact', reverseResult);\n\t\t\t\t\t\t\t\tif (newCollision) {\n\t\t\t\t\t\t\t\t\te1.rigidbody.fire('collisionstart', reverseResult);\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tthis._cleanOldCollisions();\n\t\tthis.contactPointPool.freeAll();\n\t\tthis.contactResultPool.freeAll();\n\t\tthis.singleContactResultPool.freeAll();\n\t}\n\tonUpdate(dt) {\n\t\tlet i, len;\n\t\tthis._gravityFloat32[0] = this.gravity.x;\n\t\tthis._gravityFloat32[1] = this.gravity.y;\n\t\tthis._gravityFloat32[2] = this.gravity.z;\n\t\tconst gravity = this.dynamicsWorld.getGravity();\n\t\tif (gravity.x() !== this._gravityFloat32[0] || gravity.y() !== this._gravityFloat32[1] || gravity.z() !== this._gravityFloat32[2]) {\n\t\t\tgravity.setValue(this.gravity.x, this.gravity.y, this.gravity.z);\n\t\t\tthis.dynamicsWorld.setGravity(gravity);\n\t\t}\n\t\tconst triggers = this._triggers;\n\t\tfor (i = 0, len = triggers.length; i < len; i++) {\n\t\t\ttriggers[i].updateTransform();\n\t\t}\n\t\tconst compounds = this._compounds;\n\t\tfor (i = 0, len = compounds.length; i < len; i++) {\n\t\t\tcompounds[i]._updateCompound();\n\t\t}\n\t\tconst kinematic = this._kinematic;\n\t\tfor (i = 0, len = kinematic.length; i < len; i++) {\n\t\t\tkinematic[i]._updateKinematic();\n\t\t}\n\t\tthis.dynamicsWorld.stepSimulation(dt, this.maxSubSteps, this.fixedTimeStep);\n\t\tconst dynamic = this._dynamic;\n\t\tfor (i = 0, len = dynamic.length; i < len; i++) {\n\t\t\tdynamic[i]._updateDynamic();\n\t\t}\n\t\tif (!this.dynamicsWorld.setInternalTickCallback) this._checkForCollisions(Ammo.getPointer(this.dynamicsWorld), dt);\n\t}\n\tdestroy() {\n\t\tsuper.destroy();\n\t\tthis.app.systems.off('update', this.onUpdate, this);\n\t\tif (typeof Ammo !== 'undefined') {\n\t\t\tAmmo.destroy(this.dynamicsWorld);\n\t\t\tAmmo.destroy(this.solver);\n\t\t\tAmmo.destroy(this.overlappingPairCache);\n\t\t\tAmmo.destroy(this.dispatcher);\n\t\t\tAmmo.destroy(this.collisionConfiguration);\n\t\t\tthis.dynamicsWorld = null;\n\t\t\tthis.solver = null;\n\t\t\tthis.overlappingPairCache = null;\n\t\t\tthis.dispatcher = null;\n\t\t\tthis.collisionConfiguration = null;\n\t\t}\n\t}\n}\nRigidBodyComponentSystem.EVENT_CONTACT = 'contact';\nComponent._buildAccessors(RigidBodyComponent.prototype, _schema);\n\nexport { ContactPoint, ContactResult, RaycastResult, RigidBodyComponentSystem, SingleContactResult };\n", "import { EventHandler } from '../../../core/event-handler.js';\nimport { math } from '../../../core/math/math.js';\nimport { Vec3 } from '../../../core/math/vec3.js';\nimport { Asset } from '../../asset/asset.js';\nimport { SoundInstance } from '../../../platform/sound/instance.js';\nimport { SoundInstance3d } from '../../../platform/sound/instance3d.js';\n\nconst instanceOptions = {\n\tvolume: 0,\n\tpitch: 0,\n\tloop: false,\n\tstartTime: 0,\n\tduration: 0,\n\tposition: new Vec3(),\n\tmaxDistance: 0,\n\trefDistance: 0,\n\trollOffFactor: 0,\n\tdistanceModel: 0,\n\tonPlay: null,\n\tonPause: null,\n\tonResume: null,\n\tonStop: null,\n\tonEnd: null\n};\nclass SoundSlot extends EventHandler {\n\tconstructor(component, name = 'Untitled', options = {}) {\n\t\tsuper();\n\t\tthis.name = void 0;\n\t\tthis.instances = [];\n\t\tthis._component = component;\n\t\tthis._assets = component.system.app.assets;\n\t\tthis._manager = component.system.manager;\n\t\tthis.name = name;\n\t\tthis._volume = options.volume !== undefined ? math.clamp(Number(options.volume) || 0, 0, 1) : 1;\n\t\tthis._pitch = options.pitch !== undefined ? Math.max(0.01, Number(options.pitch) || 0) : 1;\n\t\tthis._loop = !!(options.loop !== undefined ? options.loop : false);\n\t\tthis._duration = options.duration > 0 ? options.duration : null;\n\t\tthis._startTime = Math.max(0, Number(options.startTime) || 0);\n\t\tthis._overlap = !!options.overlap;\n\t\tthis._autoPlay = !!options.autoPlay;\n\t\tthis._firstNode = null;\n\t\tthis._lastNode = null;\n\t\tthis._asset = options.asset;\n\t\tif (this._asset instanceof Asset) {\n\t\t\tthis._asset = this._asset.id;\n\t\t}\n\t\tthis._onInstancePlayHandler = this._onInstancePlay.bind(this);\n\t\tthis._onInstancePauseHandler = this._onInstancePause.bind(this);\n\t\tthis._onInstanceResumeHandler = this._onInstanceResume.bind(this);\n\t\tthis._onInstanceStopHandler = this._onInstanceStop.bind(this);\n\t\tthis._onInstanceEndHandler = this._onInstanceEnd.bind(this);\n\t}\n\tplay() {\n\t\tif (!this.overlap) {\n\t\t\tthis.stop();\n\t\t}\n\t\tif (!this.isLoaded && !this._hasAsset()) {\n\t\t\treturn undefined;\n\t\t}\n\t\tconst instance = this._createInstance();\n\t\tthis.instances.push(instance);\n\t\tif (!this.isLoaded) {\n\t\t\tconst onLoad = function onLoad(sound) {\n\t\t\t\tconst playWhenLoaded = instance._playWhenLoaded;\n\t\t\t\tinstance.sound = sound;\n\t\t\t\tif (playWhenLoaded) {\n\t\t\t\t\tinstance.play();\n\t\t\t\t}\n\t\t\t};\n\t\t\tthis.off('load', onLoad);\n\t\t\tthis.once('load', onLoad);\n\t\t\tthis.load();\n\t\t} else {\n\t\t\tinstance.play();\n\t\t}\n\t\treturn instance;\n\t}\n\tpause() {\n\t\tlet paused = false;\n\t\tconst instances = this.instances;\n\t\tfor (let i = 0, len = instances.length; i < len; i++) {\n\t\t\tif (instances[i].pause()) {\n\t\t\t\tpaused = true;\n\t\t\t}\n\t\t}\n\t\treturn paused;\n\t}\n\tresume() {\n\t\tlet resumed = false;\n\t\tconst instances = this.instances;\n\t\tfor (let i = 0, len = instances.length; i < len; i++) {\n\t\t\tif (instances[i].resume()) resumed = true;\n\t\t}\n\t\treturn resumed;\n\t}\n\tstop() {\n\t\tlet stopped = false;\n\t\tconst instances = this.instances;\n\t\tlet i = instances.length;\n\t\twhile (i--) {\n\t\t\tinstances[i].stop();\n\t\t\tstopped = true;\n\t\t}\n\t\tinstances.length = 0;\n\t\treturn stopped;\n\t}\n\tload() {\n\t\tif (!this._hasAsset()) return;\n\t\tconst asset = this._assets.get(this._asset);\n\t\tif (!asset) {\n\t\t\tthis._assets.off('add:' + this._asset, this._onAssetAdd, this);\n\t\t\tthis._assets.once('add:' + this._asset, this._onAssetAdd, this);\n\t\t\treturn;\n\t\t}\n\t\tasset.off('remove', this._onAssetRemoved, this);\n\t\tasset.on('remove', this._onAssetRemoved, this);\n\t\tif (!asset.resource) {\n\t\t\tasset.off('load', this._onAssetLoad, this);\n\t\t\tasset.once('load', this._onAssetLoad, this);\n\t\t\tthis._assets.load(asset);\n\t\t\treturn;\n\t\t}\n\t\tthis.fire('load', asset.resource);\n\t}\n\tsetExternalNodes(firstNode, lastNode) {\n\t\tif (!firstNode) {\n\t\t\tconsole.error('The firstNode must have a valid AudioNode');\n\t\t\treturn;\n\t\t}\n\t\tif (!lastNode) {\n\t\t\tlastNode = firstNode;\n\t\t}\n\t\tthis._firstNode = firstNode;\n\t\tthis._lastNode = lastNode;\n\t\tif (!this._overlap) {\n\t\t\tconst instances = this.instances;\n\t\t\tfor (let i = 0, len = instances.length; i < len; i++) {\n\t\t\t\tinstances[i].setExternalNodes(firstNode, lastNode);\n\t\t\t}\n\t\t}\n\t}\n\tclearExternalNodes() {\n\t\tthis._firstNode = null;\n\t\tthis._lastNode = null;\n\t\tif (!this._overlap) {\n\t\t\tconst instances = this.instances;\n\t\t\tfor (let i = 0, len = instances.length; i < len; i++) {\n\t\t\t\tinstances[i].clearExternalNodes();\n\t\t\t}\n\t\t}\n\t}\n\tgetExternalNodes() {\n\t\treturn [this._firstNode, this._lastNode];\n\t}\n\t_hasAsset() {\n\t\treturn this._asset != null;\n\t}\n\t_createInstance() {\n\t\tlet instance = null;\n\t\tconst component = this._component;\n\t\tlet sound = null;\n\t\tif (this._hasAsset()) {\n\t\t\tconst asset = this._assets.get(this._asset);\n\t\t\tif (asset) {\n\t\t\t\tsound = asset.resource;\n\t\t\t}\n\t\t}\n\t\tconst data = instanceOptions;\n\t\tdata.volume = this._volume * component.volume;\n\t\tdata.pitch = this._pitch * component.pitch;\n\t\tdata.loop = this._loop;\n\t\tdata.startTime = this._startTime;\n\t\tdata.duration = this._duration;\n\t\tdata.onPlay = this._onInstancePlayHandler;\n\t\tdata.onPause = this._onInstancePauseHandler;\n\t\tdata.onResume = this._onInstanceResumeHandler;\n\t\tdata.onStop = this._onInstanceStopHandler;\n\t\tdata.onEnd = this._onInstanceEndHandler;\n\t\tif (component.positional) {\n\t\t\tdata.position.copy(component.entity.getPosition());\n\t\t\tdata.maxDistance = component.maxDistance;\n\t\t\tdata.refDistance = component.refDistance;\n\t\t\tdata.rollOffFactor = component.rollOffFactor;\n\t\t\tdata.distanceModel = component.distanceModel;\n\t\t\tinstance = new SoundInstance3d(this._manager, sound, data);\n\t\t} else {\n\t\t\tinstance = new SoundInstance(this._manager, sound, data);\n\t\t}\n\t\tif (this._firstNode) {\n\t\t\tinstance.setExternalNodes(this._firstNode, this._lastNode);\n\t\t}\n\t\treturn instance;\n\t}\n\t_onInstancePlay(instance) {\n\t\tthis.fire('play', instance);\n\t\tthis._component.fire('play', this, instance);\n\t}\n\t_onInstancePause(instance) {\n\t\tthis.fire('pause', instance);\n\t\tthis._component.fire('pause', this, instance);\n\t}\n\t_onInstanceResume(instance) {\n\t\tthis.fire('resume', instance);\n\t\tthis._component.fire('resume', this, instance);\n\t}\n\t_onInstanceStop(instance) {\n\t\tconst idx = this.instances.indexOf(instance);\n\t\tif (idx !== -1) {\n\t\t\tthis.instances.splice(idx, 1);\n\t\t}\n\t\tthis.fire('stop', instance);\n\t\tthis._component.fire('stop', this, instance);\n\t}\n\t_onInstanceEnd(instance) {\n\t\tconst idx = this.instances.indexOf(instance);\n\t\tif (idx !== -1) {\n\t\t\tthis.instances.splice(idx, 1);\n\t\t}\n\t\tthis.fire('end', instance);\n\t\tthis._component.fire('end', this, instance);\n\t}\n\t_onAssetAdd(asset) {\n\t\tthis.load();\n\t}\n\t_onAssetLoad(asset) {\n\t\tthis.load();\n\t}\n\t_onAssetRemoved(asset) {\n\t\tasset.off('remove', this._onAssetRemoved, this);\n\t\tthis._assets.off('add:' + asset.id, this._onAssetAdd, this);\n\t\tthis.stop();\n\t}\n\tupdatePosition(position) {\n\t\tconst instances = this.instances;\n\t\tfor (let i = 0, len = instances.length; i < len; i++) {\n\t\t\tinstances[i].position = position;\n\t\t}\n\t}\n\tset asset(value) {\n\t\tconst old = this._asset;\n\t\tif (old) {\n\t\t\tthis._assets.off('add:' + old, this._onAssetAdd, this);\n\t\t\tconst oldAsset = this._assets.get(old);\n\t\t\tif (oldAsset) {\n\t\t\t\toldAsset.off('remove', this._onAssetRemoved, this);\n\t\t\t}\n\t\t}\n\t\tthis._asset = value;\n\t\tif (this._asset instanceof Asset) {\n\t\t\tthis._asset = this._asset.id;\n\t\t}\n\t\tif (this._hasAsset() && this._component.enabled && this._component.entity.enabled) {\n\t\t\tthis.load();\n\t\t}\n\t}\n\tget asset() {\n\t\treturn this._asset;\n\t}\n\tset autoPlay(value) {\n\t\tthis._autoPlay = !!value;\n\t}\n\tget autoPlay() {\n\t\treturn this._autoPlay;\n\t}\n\tset duration(value) {\n\t\tthis._duration = Math.max(0, Number(value) || 0) || null;\n\t\tif (!this._overlap) {\n\t\t\tconst instances = this.instances;\n\t\t\tfor (let i = 0, len = instances.length; i < len; i++) {\n\t\t\t\tinstances[i].duration = this._duration;\n\t\t\t}\n\t\t}\n\t}\n\tget duration() {\n\t\tlet assetDuration = 0;\n\t\tif (this._hasAsset()) {\n\t\t\tconst asset = this._assets.get(this._asset);\n\t\t\tassetDuration = asset != null && asset.resource ? asset.resource.duration : 0;\n\t\t}\n\t\tif (this._duration != null) {\n\t\t\treturn this._duration % (assetDuration || 1);\n\t\t}\n\t\treturn assetDuration;\n\t}\n\tget isLoaded() {\n\t\tif (this._hasAsset()) {\n\t\t\tconst asset = this._assets.get(this._asset);\n\t\t\tif (asset) {\n\t\t\t\treturn !!asset.resource;\n\t\t\t}\n\t\t}\n\t\treturn false;\n\t}\n\tget isPaused() {\n\t\tconst instances = this.instances;\n\t\tconst len = instances.length;\n\t\tif (len === 0) return false;\n\t\tfor (let i = 0; i < len; i++) {\n\t\t\tif (!instances[i].isPaused) return false;\n\t\t}\n\t\treturn true;\n\t}\n\tget isPlaying() {\n\t\tconst instances = this.instances;\n\t\tfor (let i = 0, len = instances.length; i < len; i++) {\n\t\t\tif (instances[i].isPlaying) return true;\n\t\t}\n\t\treturn false;\n\t}\n\tget isStopped() {\n\t\tconst instances = this.instances;\n\t\tfor (let i = 0, len = instances.length; i < len; i++) {\n\t\t\tif (!instances[i].isStopped) return false;\n\t\t}\n\t\treturn true;\n\t}\n\tset loop(value) {\n\t\tthis._loop = !!value;\n\t\tconst instances = this.instances;\n\t\tfor (let i = 0, len = instances.length; i < len; i++) {\n\t\t\tinstances[i].loop = this._loop;\n\t\t}\n\t}\n\tget loop() {\n\t\treturn this._loop;\n\t}\n\tset overlap(value) {\n\t\tthis._overlap = !!value;\n\t}\n\tget overlap() {\n\t\treturn this._overlap;\n\t}\n\tset pitch(value) {\n\t\tthis._pitch = Math.max(Number(value) || 0, 0.01);\n\t\tif (!this._overlap) {\n\t\t\tconst instances = this.instances;\n\t\t\tfor (let i = 0, len = instances.length; i < len; i++) {\n\t\t\t\tinstances[i].pitch = this.pitch * this._component.pitch;\n\t\t\t}\n\t\t}\n\t}\n\tget pitch() {\n\t\treturn this._pitch;\n\t}\n\tset startTime(value) {\n\t\tthis._startTime = Math.max(0, Number(value) || 0);\n\t\tif (!this._overlap) {\n\t\t\tconst instances = this.instances;\n\t\t\tfor (let i = 0, len = instances.length; i < len; i++) {\n\t\t\t\tinstances[i].startTime = this._startTime;\n\t\t\t}\n\t\t}\n\t}\n\tget startTime() {\n\t\treturn this._startTime;\n\t}\n\tset volume(value) {\n\t\tthis._volume = math.clamp(Number(value) || 0, 0, 1);\n\t\tif (!this._overlap) {\n\t\t\tconst instances = this.instances;\n\t\t\tfor (let i = 0, len = instances.length; i < len; i++) {\n\t\t\t\tinstances[i].volume = this._volume * this._component.volume;\n\t\t\t}\n\t\t}\n\t}\n\tget volume() {\n\t\treturn this._volume;\n\t}\n}\nSoundSlot.EVENT_PLAY = 'play';\nSoundSlot.EVENT_PAUSE = 'pause';\nSoundSlot.EVENT_RESUME = 'resume';\nSoundSlot.EVENT_STOP = 'stop';\nSoundSlot.EVENT_LOAD = 'load';\n\nexport { SoundSlot };\n", "import { DISTANCE_LINEAR } from '../../../platform/audio/constants.js';\nimport { Component } from '../component.js';\nimport { SoundSlot } from './slot.js';\n\nclass SoundComponent extends Component {\n\tconstructor(system, entity) {\n\t\tsuper(system, entity);\n\t\tthis._volume = 1;\n\t\tthis._pitch = 1;\n\t\tthis._positional = true;\n\t\tthis._refDistance = 1;\n\t\tthis._maxDistance = 10000;\n\t\tthis._rollOffFactor = 1;\n\t\tthis._distanceModel = DISTANCE_LINEAR;\n\t\tthis._slots = {};\n\t\tthis._playingBeforeDisable = {};\n\t}\n\t_updateSoundInstances(property, value, isFactor) {\n\t\tconst slots = this._slots;\n\t\tfor (const key in slots) {\n\t\t\tconst slot = slots[key];\n\t\t\tif (!slot.overlap) {\n\t\t\t\tconst instances = slot.instances;\n\t\t\t\tfor (let i = 0, len = instances.length; i < len; i++) {\n\t\t\t\t\tinstances[i][property] = isFactor ? slot[property] * value : value;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\tset distanceModel(value) {\n\t\tthis._distanceModel = value;\n\t\tthis._updateSoundInstances('distanceModel', value, false);\n\t}\n\tget distanceModel() {\n\t\treturn this._distanceModel;\n\t}\n\tset maxDistance(value) {\n\t\tthis._maxDistance = value;\n\t\tthis._updateSoundInstances('maxDistance', value, false);\n\t}\n\tget maxDistance() {\n\t\treturn this._maxDistance;\n\t}\n\tset refDistance(value) {\n\t\tthis._refDistance = value;\n\t\tthis._updateSoundInstances('refDistance', value, false);\n\t}\n\tget refDistance() {\n\t\treturn this._refDistance;\n\t}\n\tset rollOffFactor(value) {\n\t\tthis._rollOffFactor = value;\n\t\tthis._updateSoundInstances('rollOffFactor', value, false);\n\t}\n\tget rollOffFactor() {\n\t\treturn this._rollOffFactor;\n\t}\n\tset pitch(value) {\n\t\tthis._pitch = value;\n\t\tthis._updateSoundInstances('pitch', value, true);\n\t}\n\tget pitch() {\n\t\treturn this._pitch;\n\t}\n\tset volume(value) {\n\t\tthis._volume = value;\n\t\tthis._updateSoundInstances('volume', value, true);\n\t}\n\tget volume() {\n\t\treturn this._volume;\n\t}\n\tset positional(newValue) {\n\t\tthis._positional = newValue;\n\t\tconst slots = this._slots;\n\t\tfor (const key in slots) {\n\t\t\tconst slot = slots[key];\n\t\t\tif (!slot.overlap) {\n\t\t\t\tconst instances = slot.instances;\n\t\t\t\tconst oldLength = instances.length;\n\t\t\t\tfor (let i = oldLength - 1; i >= 0; i--) {\n\t\t\t\t\tconst isPlaying = instances[i].isPlaying || instances[i].isSuspended;\n\t\t\t\t\tconst currentTime = instances[i].currentTime;\n\t\t\t\t\tif (isPlaying) instances[i].stop();\n\t\t\t\t\tconst instance = slot._createInstance();\n\t\t\t\t\tif (isPlaying) {\n\t\t\t\t\t\tinstance.play();\n\t\t\t\t\t\tinstance.currentTime = currentTime;\n\t\t\t\t\t}\n\t\t\t\t\tinstances.push(instance);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\tget positional() {\n\t\treturn this._positional;\n\t}\n\tset slots(newValue) {\n\t\tconst oldValue = this._slots;\n\t\tif (oldValue) {\n\t\t\tfor (const key in oldValue) {\n\t\t\t\toldValue[key].stop();\n\t\t\t}\n\t\t}\n\t\tconst slots = {};\n\t\tfor (const key in newValue) {\n\t\t\tif (!(newValue[key] instanceof SoundSlot)) {\n\t\t\t\tif (newValue[key].name) {\n\t\t\t\t\tslots[newValue[key].name] = new SoundSlot(this, newValue[key].name, newValue[key]);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tslots[newValue[key].name] = newValue[key];\n\t\t\t}\n\t\t}\n\t\tthis._slots = slots;\n\t\tif (this.enabled && this.entity.enabled) this.onEnable();\n\t}\n\tget slots() {\n\t\treturn this._slots;\n\t}\n\tonEnable() {\n\t\tif (this.system._inTools) {\n\t\t\treturn;\n\t\t}\n\t\tconst slots = this._slots;\n\t\tconst playingBeforeDisable = this._playingBeforeDisable;\n\t\tfor (const key in slots) {\n\t\t\tconst slot = slots[key];\n\t\t\tif (slot.autoPlay && slot.isStopped) {\n\t\t\t\tslot.play();\n\t\t\t} else if (playingBeforeDisable[key]) {\n\t\t\t\tslot.resume();\n\t\t\t} else if (!slot.isLoaded) {\n\t\t\t\tslot.load();\n\t\t\t}\n\t\t}\n\t}\n\tonDisable() {\n\t\tconst slots = this._slots;\n\t\tconst playingBeforeDisable = {};\n\t\tfor (const key in slots) {\n\t\t\tif (!slots[key].overlap) {\n\t\t\t\tif (slots[key].isPlaying) {\n\t\t\t\t\tslots[key].pause();\n\t\t\t\t\tplayingBeforeDisable[key] = true;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tthis._playingBeforeDisable = playingBeforeDisable;\n\t}\n\tonRemove() {\n\t\tthis.off();\n\t}\n\taddSlot(name, options) {\n\t\tconst slots = this._slots;\n\t\tif (slots[name]) {\n\t\t\treturn null;\n\t\t}\n\t\tconst slot = new SoundSlot(this, name, options);\n\t\tslots[name] = slot;\n\t\tif (slot.autoPlay && this.enabled && this.entity.enabled) {\n\t\t\tslot.play();\n\t\t}\n\t\treturn slot;\n\t}\n\tremoveSlot(name) {\n\t\tconst slots = this._slots;\n\t\tif (slots[name]) {\n\t\t\tslots[name].stop();\n\t\t\tdelete slots[name];\n\t\t}\n\t}\n\tslot(name) {\n\t\treturn this._slots[name];\n\t}\n\t_getSlotProperty(name, property) {\n\t\tif (!this.enabled || !this.entity.enabled) {\n\t\t\treturn undefined;\n\t\t}\n\t\tconst slot = this._slots[name];\n\t\tif (!slot) {\n\t\t\treturn undefined;\n\t\t}\n\t\treturn slot[property];\n\t}\n\tisPlaying(name) {\n\t\treturn this._getSlotProperty(name, 'isPlaying') || false;\n\t}\n\tisLoaded(name) {\n\t\treturn this._getSlotProperty(name, 'isLoaded') || false;\n\t}\n\tisPaused(name) {\n\t\treturn this._getSlotProperty(name, 'isPaused') || false;\n\t}\n\tisStopped(name) {\n\t\treturn this._getSlotProperty(name, 'isStopped') || false;\n\t}\n\tplay(name) {\n\t\tif (!this.enabled || !this.entity.enabled) {\n\t\t\treturn null;\n\t\t}\n\t\tconst slot = this._slots[name];\n\t\tif (!slot) {\n\t\t\treturn null;\n\t\t}\n\t\treturn slot.play();\n\t}\n\tpause(name) {\n\t\tconst slots = this._slots;\n\t\tif (name) {\n\t\t\tconst slot = slots[name];\n\t\t\tif (!slot) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tslot.pause();\n\t\t} else {\n\t\t\tfor (const key in slots) {\n\t\t\t\tslots[key].pause();\n\t\t\t}\n\t\t}\n\t}\n\tresume(name) {\n\t\tconst slots = this._slots;\n\t\tif (name) {\n\t\t\tconst slot = slots[name];\n\t\t\tif (!slot) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif (slot.isPaused) {\n\t\t\t\tslot.resume();\n\t\t\t}\n\t\t} else {\n\t\t\tfor (const key in slots) {\n\t\t\t\tslots[key].resume();\n\t\t\t}\n\t\t}\n\t}\n\tstop(name) {\n\t\tconst slots = this._slots;\n\t\tif (name) {\n\t\t\tconst slot = slots[name];\n\t\t\tif (!slot) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tslot.stop();\n\t\t} else {\n\t\t\tfor (const key in slots) {\n\t\t\t\tslots[key].stop();\n\t\t\t}\n\t\t}\n\t}\n}\nSoundComponent.EVENT_PLAY = 'play';\nSoundComponent.EVENT_PAUSE = 'pause';\nSoundComponent.EVENT_RESUME = 'resume';\nSoundComponent.EVENT_STOP = 'stop';\nSoundComponent.EVENT_END = 'end';\n\nexport { SoundComponent };\n", "class SoundComponentData {\n\tconstructor() {\n\t\tthis.enabled = true;\n\t}\n}\n\nexport { SoundComponentData };\n", "import { hasAudioContext } from '../../../platform/audio/capabilities.js';\nimport { Component } from '../component.js';\nimport { ComponentSystem } from '../system.js';\nimport { SoundComponent } from './component.js';\nimport { SoundComponentData } from './data.js';\n\nconst _schema = ['enabled'];\nclass SoundComponentSystem extends ComponentSystem {\n\tconstructor(app) {\n\t\tsuper(app);\n\t\tthis.id = 'sound';\n\t\tthis.ComponentType = SoundComponent;\n\t\tthis.DataType = SoundComponentData;\n\t\tthis.schema = _schema;\n\t\tthis.manager = app.soundManager;\n\t\tthis.app.systems.on('update', this.onUpdate, this);\n\t\tthis.on('beforeremove', this.onBeforeRemove, this);\n\t}\n\tset volume(volume) {\n\t\tthis.manager.volume = volume;\n\t}\n\tget volume() {\n\t\treturn this.manager.volume;\n\t}\n\tget context() {\n\t\tif (!hasAudioContext()) {\n\t\t\treturn null;\n\t\t}\n\t\treturn this.manager.context;\n\t}\n\tinitializeComponentData(component, data, properties) {\n\t\tproperties = ['volume', 'pitch', 'positional', 'refDistance', 'maxDistance', 'rollOffFactor', 'distanceModel', 'slots'];\n\t\tfor (let i = 0; i < properties.length; i++) {\n\t\t\tif (data.hasOwnProperty(properties[i])) {\n\t\t\t\tcomponent[properties[i]] = data[properties[i]];\n\t\t\t}\n\t\t}\n\t\tsuper.initializeComponentData(component, data, ['enabled']);\n\t}\n\tcloneComponent(entity, clone) {\n\t\tconst srcComponent = entity.sound;\n\t\tconst srcSlots = srcComponent.slots;\n\t\tconst slots = {};\n\t\tfor (const key in srcSlots) {\n\t\t\tconst srcSlot = srcSlots[key];\n\t\t\tslots[key] = {\n\t\t\t\tname: srcSlot.name,\n\t\t\t\tvolume: srcSlot.volume,\n\t\t\t\tpitch: srcSlot.pitch,\n\t\t\t\tloop: srcSlot.loop,\n\t\t\t\tduration: srcSlot.duration,\n\t\t\t\tstartTime: srcSlot.startTime,\n\t\t\t\toverlap: srcSlot.overlap,\n\t\t\t\tautoPlay: srcSlot.autoPlay,\n\t\t\t\tasset: srcSlot.asset\n\t\t\t};\n\t\t}\n\t\tconst cloneData = {\n\t\t\tdistanceModel: srcComponent.distanceModel,\n\t\t\tenabled: srcComponent.enabled,\n\t\t\tmaxDistance: srcComponent.maxDistance,\n\t\t\tpitch: srcComponent.pitch,\n\t\t\tpositional: srcComponent.positional,\n\t\t\trefDistance: srcComponent.refDistance,\n\t\t\trollOffFactor: srcComponent.rollOffFactor,\n\t\t\tslots: slots,\n\t\t\tvolume: srcComponent.volume\n\t\t};\n\t\treturn this.addComponent(clone, cloneData);\n\t}\n\tonUpdate(dt) {\n\t\tconst store = this.store;\n\t\tfor (const id in store) {\n\t\t\tif (store.hasOwnProperty(id)) {\n\t\t\t\tconst item = store[id];\n\t\t\t\tconst entity = item.entity;\n\t\t\t\tif (entity.enabled) {\n\t\t\t\t\tconst component = entity.sound;\n\t\t\t\t\tif (component.enabled && component.positional) {\n\t\t\t\t\t\tconst position = entity.getPosition();\n\t\t\t\t\t\tconst slots = component.slots;\n\t\t\t\t\t\tfor (const key in slots) {\n\t\t\t\t\t\t\tslots[key].updatePosition(position);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\tonBeforeRemove(entity, component) {\n\t\tconst slots = component.slots;\n\t\tfor (const key in slots) {\n\t\t\tif (!slots[key].overlap) {\n\t\t\t\tslots[key].stop();\n\t\t\t}\n\t\t}\n\t\tcomponent.onRemove();\n\t}\n\tdestroy() {\n\t\tsuper.destroy();\n\t\tthis.app.systems.off('update', this.onUpdate, this);\n\t}\n}\nComponent._buildAccessors(SoundComponent.prototype, _schema);\n\nexport { SoundComponentSystem };\n", "import { FILTER_NEAREST, ADDRESS_CLAMP_TO_EDGE, PIXELFORMAT_RGBA16F, PIXELFORMAT_RGBA32F, PIXELFORMAT_RGBA8 } from '../../../platform/graphics/constants.js';\nimport { RenderTarget } from '../../../platform/graphics/render-target.js';\nimport { Texture } from '../../../platform/graphics/texture.js';\nimport { LAYERID_DEPTH } from '../../../scene/constants.js';\n\nclass PostEffectEntry {\n\tconstructor(effect, inputTarget) {\n\t\tthis.effect = effect;\n\t\tthis.inputTarget = inputTarget;\n\t\tthis.outputTarget = null;\n\t\tthis.name = effect.constructor.name;\n\t}\n}\nclass PostEffectQueue {\n\tconstructor(app, camera) {\n\t\tthis.app = app;\n\t\tthis.camera = camera;\n\t\tthis.destinationRenderTarget = null;\n\t\tthis.effects = [];\n\t\tthis.enabled = false;\n\t\tthis.depthTarget = null;\n\t\tcamera.on('set:rect', this.onCameraRectChanged, this);\n\t}\n\t_allocateColorBuffer(format, name) {\n\t\tvar _renderTarget$width, _renderTarget$height;\n\t\tconst rect = this.camera.rect;\n\t\tconst renderTarget = this.destinationRenderTarget;\n\t\tconst device = this.app.graphicsDevice;\n\t\tconst width = Math.floor(rect.z * ((_renderTarget$width = renderTarget == null ? void 0 : renderTarget.width) != null ? _renderTarget$width : device.width));\n\t\tconst height = Math.floor(rect.w * ((_renderTarget$height = renderTarget == null ? void 0 : renderTarget.height) != null ? _renderTarget$height : device.height));\n\t\tconst colorBuffer = new Texture(device, {\n\t\t\tname: name,\n\t\t\tformat: format,\n\t\t\twidth: width,\n\t\t\theight: height,\n\t\t\tmipmaps: false,\n\t\t\tminFilter: FILTER_NEAREST,\n\t\t\tmagFilter: FILTER_NEAREST,\n\t\t\taddressU: ADDRESS_CLAMP_TO_EDGE,\n\t\t\taddressV: ADDRESS_CLAMP_TO_EDGE\n\t\t});\n\t\treturn colorBuffer;\n\t}\n\t_createOffscreenTarget(useDepth, hdr) {\n\t\tconst device = this.app.graphicsDevice;\n\t\tconst format = hdr && device.getRenderableHdrFormat([PIXELFORMAT_RGBA16F, PIXELFORMAT_RGBA32F], true) || PIXELFORMAT_RGBA8;\n\t\tconst name = this.camera.entity.name + '-posteffect-' + this.effects.length;\n\t\tconst colorBuffer = this._allocateColorBuffer(format, name);\n\t\treturn new RenderTarget({\n\t\t\tcolorBuffer: colorBuffer,\n\t\t\tdepth: useDepth,\n\t\t\tstencil: useDepth && this.app.graphicsDevice.supportsStencil,\n\t\t\tsamples: useDepth ? device.samples : 1\n\t\t});\n\t}\n\t_resizeOffscreenTarget(rt) {\n\t\tconst format = rt.colorBuffer.format;\n\t\tconst name = rt.colorBuffer.name;\n\t\trt.destroyFrameBuffers();\n\t\trt.destroyTextureBuffers();\n\t\trt._colorBuffer = this._allocateColorBuffer(format, name);\n\t\trt._colorBuffers = [rt._colorBuffer];\n\t}\n\t_destroyOffscreenTarget(rt) {\n\t\trt.destroyTextureBuffers();\n\t\trt.destroy();\n\t}\n\taddEffect(effect) {\n\t\tconst effects = this.effects;\n\t\tconst isFirstEffect = effects.length === 0;\n\t\tconst inputTarget = this._createOffscreenTarget(isFirstEffect, effect.hdr);\n\t\tconst newEntry = new PostEffectEntry(effect, inputTarget);\n\t\teffects.push(newEntry);\n\t\tthis._sourceTarget = newEntry.inputTarget;\n\t\tif (effects.length > 1) {\n\t\t\teffects[effects.length - 2].outputTarget = newEntry.inputTarget;\n\t\t}\n\t\tthis._newPostEffect = effect;\n\t\tif (effect.needsDepthBuffer) {\n\t\t\tthis._requestDepthMap();\n\t\t}\n\t\tthis.enable();\n\t\tthis._newPostEffect = undefined;\n\t}\n\tremoveEffect(effect) {\n\t\tlet index = -1;\n\t\tfor (let i = 0, len = this.effects.length; i < len; i++) {\n\t\t\tif (this.effects[i].effect === effect) {\n\t\t\t\tindex = i;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\tif (index >= 0) {\n\t\t\tif (index > 0) {\n\t\t\t\tthis.effects[index - 1].outputTarget = index + 1 < this.effects.length ? this.effects[index + 1].inputTarget : null;\n\t\t\t} else {\n\t\t\t\tif (this.effects.length > 1) {\n\t\t\t\t\tif (!this.effects[1].inputTarget._depth) {\n\t\t\t\t\t\tthis._destroyOffscreenTarget(this.effects[1].inputTarget);\n\t\t\t\t\t\tthis.effects[1].inputTarget = this._createOffscreenTarget(true, this.effects[1].hdr);\n\t\t\t\t\t\tthis._sourceTarget = this.effects[1].inputTarget;\n\t\t\t\t\t}\n\t\t\t\t\tthis.camera.renderTarget = this.effects[1].inputTarget;\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis._destroyOffscreenTarget(this.effects[index].inputTarget);\n\t\t\tthis.effects.splice(index, 1);\n\t\t}\n\t\tif (this.enabled) {\n\t\t\tif (effect.needsDepthBuffer) {\n\t\t\t\tthis._releaseDepthMap();\n\t\t\t}\n\t\t}\n\t\tif (this.effects.length === 0) {\n\t\t\tthis.disable();\n\t\t}\n\t}\n\t_requestDepthMaps() {\n\t\tfor (let i = 0, len = this.effects.length; i < len; i++) {\n\t\t\tconst effect = this.effects[i].effect;\n\t\t\tif (this._newPostEffect === effect) continue;\n\t\t\tif (effect.needsDepthBuffer) {\n\t\t\t\tthis._requestDepthMap();\n\t\t\t}\n\t\t}\n\t}\n\t_releaseDepthMaps() {\n\t\tfor (let i = 0, len = this.effects.length; i < len; i++) {\n\t\t\tconst effect = this.effects[i].effect;\n\t\t\tif (effect.needsDepthBuffer) {\n\t\t\t\tthis._releaseDepthMap();\n\t\t\t}\n\t\t}\n\t}\n\t_requestDepthMap() {\n\t\tconst depthLayer = this.app.scene.layers.getLayerById(LAYERID_DEPTH);\n\t\tif (depthLayer) {\n\t\t\tdepthLayer.incrementCounter();\n\t\t\tthis.camera.requestSceneDepthMap(true);\n\t\t}\n\t}\n\t_releaseDepthMap() {\n\t\tconst depthLayer = this.app.scene.layers.getLayerById(LAYERID_DEPTH);\n\t\tif (depthLayer) {\n\t\t\tdepthLayer.decrementCounter();\n\t\t\tthis.camera.requestSceneDepthMap(false);\n\t\t}\n\t}\n\tdestroy() {\n\t\tfor (let i = 0, len = this.effects.length; i < len; i++) {\n\t\t\tthis.effects[i].inputTarget.destroy();\n\t\t}\n\t\tthis.effects.length = 0;\n\t\tthis.disable();\n\t}\n\tenable() {\n\t\tif (!this.enabled && this.effects.length) {\n\t\t\tthis.enabled = true;\n\t\t\tthis._requestDepthMaps();\n\t\t\tthis.app.graphicsDevice.on('resizecanvas', this._onCanvasResized, this);\n\t\t\tthis.destinationRenderTarget = this.camera.renderTarget;\n\t\t\tthis.camera.renderTarget = this.effects[0].inputTarget;\n\t\t\tthis.camera.onPostprocessing = () => {\n\t\t\t\tif (this.enabled) {\n\t\t\t\t\tlet rect = null;\n\t\t\t\t\tconst len = this.effects.length;\n\t\t\t\t\tif (len) {\n\t\t\t\t\t\tfor (let i = 0; i < len; i++) {\n\t\t\t\t\t\t\tconst fx = this.effects[i];\n\t\t\t\t\t\t\tlet destTarget = fx.outputTarget;\n\t\t\t\t\t\t\tif (i === len - 1) {\n\t\t\t\t\t\t\t\trect = this.camera.rect;\n\t\t\t\t\t\t\t\tif (this.destinationRenderTarget) {\n\t\t\t\t\t\t\t\t\tdestTarget = this.destinationRenderTarget;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tfx.effect.render(fx.inputTarget, destTarget, rect);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t};\n\t\t}\n\t}\n\tdisable() {\n\t\tif (this.enabled) {\n\t\t\tthis.enabled = false;\n\t\t\tthis.app.graphicsDevice.off('resizecanvas', this._onCanvasResized, this);\n\t\t\tthis._releaseDepthMaps();\n\t\t\tthis._destroyOffscreenTarget(this._sourceTarget);\n\t\t\tthis.camera.renderTarget = null;\n\t\t\tthis.camera.onPostprocessing = null;\n\t\t}\n\t}\n\t_onCanvasResized(width, height) {\n\t\tvar _renderTarget$width2, _renderTarget$height2;\n\t\tconst rect = this.camera.rect;\n\t\tconst renderTarget = this.destinationRenderTarget;\n\t\twidth = (_renderTarget$width2 = renderTarget == null ? void 0 : renderTarget.width) != null ? _renderTarget$width2 : width;\n\t\theight = (_renderTarget$height2 = renderTarget == null ? void 0 : renderTarget.height) != null ? _renderTarget$height2 : height;\n\t\tthis.camera.camera.aspectRatio = width * rect.z / (height * rect.w);\n\t\tthis.resizeRenderTargets();\n\t}\n\tresizeRenderTargets() {\n\t\tvar _renderTarget$width3, _renderTarget$height3;\n\t\tconst device = this.app.graphicsDevice;\n\t\tconst renderTarget = this.destinationRenderTarget;\n\t\tconst width = (_renderTarget$width3 = renderTarget == null ? void 0 : renderTarget.width) != null ? _renderTarget$width3 : device.width;\n\t\tconst height = (_renderTarget$height3 = renderTarget == null ? void 0 : renderTarget.height) != null ? _renderTarget$height3 : device.height;\n\t\tconst rect = this.camera.rect;\n\t\tconst desiredWidth = Math.floor(rect.z * width);\n\t\tconst desiredHeight = Math.floor(rect.w * height);\n\t\tconst effects = this.effects;\n\t\tfor (let i = 0, len = effects.length; i < len; i++) {\n\t\t\tconst fx = effects[i];\n\t\t\tif (fx.inputTarget.width !== desiredWidth || fx.inputTarget.height !== desiredHeight) {\n\t\t\t\tthis._resizeOffscreenTarget(fx.inputTarget);\n\t\t\t}\n\t\t}\n\t}\n\tonCameraRectChanged(name, oldValue, newValue) {\n\t\tif (this.enabled) {\n\t\t\tthis.resizeRenderTargets();\n\t\t}\n\t}\n}\n\nexport { PostEffectQueue };\n", "import { LAYERID_UI, LAYERID_DEPTH, ASPECT_AUTO } from '../../../scene/constants.js';\nimport { Camera } from '../../../scene/camera.js';\nimport { ShaderPass } from '../../../scene/shader-pass.js';\nimport { Component } from '../component.js';\nimport { PostEffectQueue } from './post-effect-queue.js';\n\nclass CameraComponent extends Component {\n\tconstructor(system, entity) {\n\t\tsuper(system, entity);\n\t\tthis.onPostprocessing = null;\n\t\tthis.onPreRender = null;\n\t\tthis.onPostRender = null;\n\t\tthis._renderSceneDepthMap = 0;\n\t\tthis._renderSceneColorMap = 0;\n\t\tthis._sceneDepthMapRequested = false;\n\t\tthis._sceneColorMapRequested = false;\n\t\tthis._priority = 0;\n\t\tthis._disablePostEffectsLayer = LAYERID_UI;\n\t\tthis._camera = new Camera();\n\t\tthis._camera.node = entity;\n\t\tthis._postEffects = new PostEffectQueue(system.app, this);\n\t}\n\tsetShaderPass(name) {\n\t\tconst shaderPass = ShaderPass.get(this.system.app.graphicsDevice);\n\t\tconst shaderPassInfo = name ? shaderPass.allocate(name, {\n\t\t\tisForward: true\n\t\t}) : null;\n\t\tthis._camera.shaderPassInfo = shaderPassInfo;\n\t\treturn shaderPassInfo.index;\n\t}\n\tgetShaderPass() {\n\t\tvar _this$_camera$shaderP;\n\t\treturn (_this$_camera$shaderP = this._camera.shaderPassInfo) == null ? void 0 : _this$_camera$shaderP.name;\n\t}\n\tset renderPasses(passes) {\n\t\tthis._camera.renderPasses = passes;\n\t}\n\tget renderPasses() {\n\t\treturn this._camera.renderPasses;\n\t}\n\tset aperture(value) {\n\t\tthis._camera.aperture = value;\n\t}\n\tget aperture() {\n\t\treturn this._camera.aperture;\n\t}\n\tset aspectRatio(value) {\n\t\tthis._camera.aspectRatio = value;\n\t}\n\tget aspectRatio() {\n\t\treturn this._camera.aspectRatio;\n\t}\n\tset aspectRatioMode(value) {\n\t\tthis._camera.aspectRatioMode = value;\n\t}\n\tget aspectRatioMode() {\n\t\treturn this._camera.aspectRatioMode;\n\t}\n\tset calculateProjection(value) {\n\t\tthis._camera.calculateProjection = value;\n\t}\n\tget calculateProjection() {\n\t\treturn this._camera.calculateProjection;\n\t}\n\tset calculateTransform(value) {\n\t\tthis._camera.calculateTransform = value;\n\t}\n\tget calculateTransform() {\n\t\treturn this._camera.calculateTransform;\n\t}\n\tget camera() {\n\t\treturn this._camera;\n\t}\n\tset clearColor(value) {\n\t\tthis._camera.clearColor = value;\n\t}\n\tget clearColor() {\n\t\treturn this._camera.clearColor;\n\t}\n\tset clearColorBuffer(value) {\n\t\tthis._camera.clearColorBuffer = value;\n\t\tthis.dirtyLayerCompositionCameras();\n\t}\n\tget clearColorBuffer() {\n\t\treturn this._camera.clearColorBuffer;\n\t}\n\tset clearDepthBuffer(value) {\n\t\tthis._camera.clearDepthBuffer = value;\n\t\tthis.dirtyLayerCompositionCameras();\n\t}\n\tget clearDepthBuffer() {\n\t\treturn this._camera.clearDepthBuffer;\n\t}\n\tset clearStencilBuffer(value) {\n\t\tthis._camera.clearStencilBuffer = value;\n\t\tthis.dirtyLayerCompositionCameras();\n\t}\n\tget clearStencilBuffer() {\n\t\treturn this._camera.clearStencilBuffer;\n\t}\n\tset cullFaces(value) {\n\t\tthis._camera.cullFaces = value;\n\t}\n\tget cullFaces() {\n\t\treturn this._camera.cullFaces;\n\t}\n\tset disablePostEffectsLayer(layer) {\n\t\tthis._disablePostEffectsLayer = layer;\n\t\tthis.dirtyLayerCompositionCameras();\n\t}\n\tget disablePostEffectsLayer() {\n\t\treturn this._disablePostEffectsLayer;\n\t}\n\tset farClip(value) {\n\t\tthis._camera.farClip = value;\n\t}\n\tget farClip() {\n\t\treturn this._camera.farClip;\n\t}\n\tset flipFaces(value) {\n\t\tthis._camera.flipFaces = value;\n\t}\n\tget flipFaces() {\n\t\treturn this._camera.flipFaces;\n\t}\n\tset fov(value) {\n\t\tthis._camera.fov = value;\n\t}\n\tget fov() {\n\t\treturn this._camera.fov;\n\t}\n\tget frustum() {\n\t\treturn this._camera.frustum;\n\t}\n\tset frustumCulling(value) {\n\t\tthis._camera.frustumCulling = value;\n\t}\n\tget frustumCulling() {\n\t\treturn this._camera.frustumCulling;\n\t}\n\tset horizontalFov(value) {\n\t\tthis._camera.horizontalFov = value;\n\t}\n\tget horizontalFov() {\n\t\treturn this._camera.horizontalFov;\n\t}\n\tset layers(newValue) {\n\t\tconst layers = this._camera.layers;\n\t\tfor (let i = 0; i < layers.length; i++) {\n\t\t\tconst layer = this.system.app.scene.layers.getLayerById(layers[i]);\n\t\t\tif (!layer) continue;\n\t\t\tlayer.removeCamera(this);\n\t\t}\n\t\tthis._camera.layers = newValue;\n\t\tif (!this.enabled || !this.entity.enabled) return;\n\t\tfor (let i = 0; i < newValue.length; i++) {\n\t\t\tconst layer = this.system.app.scene.layers.getLayerById(newValue[i]);\n\t\t\tif (!layer) continue;\n\t\t\tlayer.addCamera(this);\n\t\t}\n\t}\n\tget layers() {\n\t\treturn this._camera.layers;\n\t}\n\tget layersSet() {\n\t\treturn this._camera.layersSet;\n\t}\n\tset jitter(value) {\n\t\tthis._camera.jitter = value;\n\t}\n\tget jitter() {\n\t\treturn this._camera.jitter;\n\t}\n\tset nearClip(value) {\n\t\tthis._camera.nearClip = value;\n\t}\n\tget nearClip() {\n\t\treturn this._camera.nearClip;\n\t}\n\tset orthoHeight(value) {\n\t\tthis._camera.orthoHeight = value;\n\t}\n\tget orthoHeight() {\n\t\treturn this._camera.orthoHeight;\n\t}\n\tget postEffects() {\n\t\treturn this._postEffects;\n\t}\n\tget postEffectsEnabled() {\n\t\treturn this._postEffects.enabled;\n\t}\n\tset priority(newValue) {\n\t\tthis._priority = newValue;\n\t\tthis.dirtyLayerCompositionCameras();\n\t}\n\tget priority() {\n\t\treturn this._priority;\n\t}\n\tset projection(value) {\n\t\tthis._camera.projection = value;\n\t}\n\tget projection() {\n\t\treturn this._camera.projection;\n\t}\n\tget projectionMatrix() {\n\t\treturn this._camera.projectionMatrix;\n\t}\n\tset rect(value) {\n\t\tthis._camera.rect = value;\n\t\tthis.fire('set:rect', this._camera.rect);\n\t}\n\tget rect() {\n\t\treturn this._camera.rect;\n\t}\n\tset renderSceneColorMap(value) {\n\t\tif (value && !this._sceneColorMapRequested) {\n\t\t\tthis.requestSceneColorMap(true);\n\t\t\tthis._sceneColorMapRequested = true;\n\t\t} else if (this._sceneColorMapRequested) {\n\t\t\tthis.requestSceneColorMap(false);\n\t\t\tthis._sceneColorMapRequested = false;\n\t\t}\n\t}\n\tget renderSceneColorMap() {\n\t\treturn this._renderSceneColorMap > 0;\n\t}\n\tset renderSceneDepthMap(value) {\n\t\tif (value && !this._sceneDepthMapRequested) {\n\t\t\tthis.requestSceneDepthMap(true);\n\t\t\tthis._sceneDepthMapRequested = true;\n\t\t} else if (this._sceneDepthMapRequested) {\n\t\t\tthis.requestSceneDepthMap(false);\n\t\t\tthis._sceneDepthMapRequested = false;\n\t\t}\n\t}\n\tget renderSceneDepthMap() {\n\t\treturn this._renderSceneDepthMap > 0;\n\t}\n\tset renderTarget(value) {\n\t\tthis._camera.renderTarget = value;\n\t\tthis.dirtyLayerCompositionCameras();\n\t}\n\tget renderTarget() {\n\t\treturn this._camera.renderTarget;\n\t}\n\tset scissorRect(value) {\n\t\tthis._camera.scissorRect = value;\n\t}\n\tget scissorRect() {\n\t\treturn this._camera.scissorRect;\n\t}\n\tset sensitivity(value) {\n\t\tthis._camera.sensitivity = value;\n\t}\n\tget sensitivity() {\n\t\treturn this._camera.sensitivity;\n\t}\n\tset shutter(value) {\n\t\tthis._camera.shutter = value;\n\t}\n\tget shutter() {\n\t\treturn this._camera.shutter;\n\t}\n\tget viewMatrix() {\n\t\treturn this._camera.viewMatrix;\n\t}\n\t_enableDepthLayer(value) {\n\t\tconst hasDepthLayer = this.layers.find(layerId => layerId === LAYERID_DEPTH);\n\t\tif (hasDepthLayer) {\n\t\t\tconst depthLayer = this.system.app.scene.layers.getLayerById(LAYERID_DEPTH);\n\t\t\tif (value) {\n\t\t\t\tdepthLayer == null || depthLayer.incrementCounter();\n\t\t\t} else {\n\t\t\t\tdepthLayer == null || depthLayer.decrementCounter();\n\t\t\t}\n\t\t} else if (value) {\n\t\t\treturn false;\n\t\t}\n\t\treturn true;\n\t}\n\trequestSceneColorMap(enabled) {\n\t\tthis._renderSceneColorMap += enabled ? 1 : -1;\n\t\tthis._enableDepthLayer(enabled);\n\t\tthis.camera._enableRenderPassColorGrab(this.system.app.graphicsDevice, this.renderSceneColorMap);\n\t}\n\trequestSceneDepthMap(enabled) {\n\t\tthis._renderSceneDepthMap += enabled ? 1 : -1;\n\t\tthis._enableDepthLayer(enabled);\n\t\tthis.camera._enableRenderPassDepthGrab(this.system.app.graphicsDevice, this.system.app.renderer, this.renderSceneDepthMap);\n\t}\n\tdirtyLayerCompositionCameras() {\n\t\tconst layerComp = this.system.app.scene.layers;\n\t\tlayerComp._dirty = true;\n\t}\n\tscreenToWorld(screenx, screeny, cameraz, worldCoord) {\n\t\tconst device = this.system.app.graphicsDevice;\n\t\tconst w = device.clientRect.width;\n\t\tconst h = device.clientRect.height;\n\t\treturn this._camera.screenToWorld(screenx, screeny, cameraz, w, h, worldCoord);\n\t}\n\tworldToScreen(worldCoord, screenCoord) {\n\t\tconst device = this.system.app.graphicsDevice;\n\t\tconst w = device.clientRect.width;\n\t\tconst h = device.clientRect.height;\n\t\treturn this._camera.worldToScreen(worldCoord, w, h, screenCoord);\n\t}\n\tonAppPrerender() {\n\t\tthis._camera._viewMatDirty = true;\n\t\tthis._camera._viewProjMatDirty = true;\n\t}\n\taddCameraToLayers() {\n\t\tconst layers = this.layers;\n\t\tfor (let i = 0; i < layers.length; i++) {\n\t\t\tconst layer = this.system.app.scene.layers.getLayerById(layers[i]);\n\t\t\tif (layer) {\n\t\t\t\tlayer.addCamera(this);\n\t\t\t}\n\t\t}\n\t}\n\tremoveCameraFromLayers() {\n\t\tconst layers = this.layers;\n\t\tfor (let i = 0; i < layers.length; i++) {\n\t\t\tconst layer = this.system.app.scene.layers.getLayerById(layers[i]);\n\t\t\tif (layer) {\n\t\t\t\tlayer.removeCamera(this);\n\t\t\t}\n\t\t}\n\t}\n\tonLayersChanged(oldComp, newComp) {\n\t\tthis.addCameraToLayers();\n\t\toldComp.off('add', this.onLayerAdded, this);\n\t\toldComp.off('remove', this.onLayerRemoved, this);\n\t\tnewComp.on('add', this.onLayerAdded, this);\n\t\tnewComp.on('remove', this.onLayerRemoved, this);\n\t}\n\tonLayerAdded(layer) {\n\t\tconst index = this.layers.indexOf(layer.id);\n\t\tif (index < 0) return;\n\t\tlayer.addCamera(this);\n\t}\n\tonLayerRemoved(layer) {\n\t\tconst index = this.layers.indexOf(layer.id);\n\t\tif (index < 0) return;\n\t\tlayer.removeCamera(this);\n\t}\n\tonEnable() {\n\t\tconst system = this.system;\n\t\tconst scene = system.app.scene;\n\t\tconst layers = scene.layers;\n\t\tsystem.addCamera(this);\n\t\tscene.on('set:layers', this.onLayersChanged, this);\n\t\tif (layers) {\n\t\t\tlayers.on('add', this.onLayerAdded, this);\n\t\t\tlayers.on('remove', this.onLayerRemoved, this);\n\t\t}\n\t\tif (this.enabled && this.entity.enabled) {\n\t\t\tthis.addCameraToLayers();\n\t\t}\n\t\tthis.postEffects.enable();\n\t}\n\tonDisable() {\n\t\tconst system = this.system;\n\t\tconst scene = system.app.scene;\n\t\tconst layers = scene.layers;\n\t\tthis.postEffects.disable();\n\t\tthis.removeCameraFromLayers();\n\t\tscene.off('set:layers', this.onLayersChanged, this);\n\t\tif (layers) {\n\t\t\tlayers.off('add', this.onLayerAdded, this);\n\t\t\tlayers.off('remove', this.onLayerRemoved, this);\n\t\t}\n\t\tsystem.removeCamera(this);\n\t}\n\tonRemove() {\n\t\tthis.onDisable();\n\t\tthis.off();\n\t\tthis.camera.destroy();\n\t}\n\tcalculateAspectRatio(rt) {\n\t\tconst device = this.system.app.graphicsDevice;\n\t\tconst width = rt ? rt.width : device.width;\n\t\tconst height = rt ? rt.height : device.height;\n\t\treturn width * this.rect.z / (height * this.rect.w);\n\t}\n\tframeUpdate(rt) {\n\t\tif (this.aspectRatioMode === ASPECT_AUTO) {\n\t\t\tthis.aspectRatio = this.calculateAspectRatio(rt);\n\t\t}\n\t}\n\tstartXr(type, spaceType, options) {\n\t\tthis.system.app.xr.start(this, type, spaceType, options);\n\t}\n\tendXr(callback) {\n\t\tif (!this._camera.xr) {\n\t\t\tif (callback) callback(new Error('Camera is not in XR'));\n\t\t\treturn;\n\t\t}\n\t\tthis._camera.xr.end(callback);\n\t}\n\tcopy(source) {\n\t\tthis.aperture = source.aperture;\n\t\tthis.aspectRatio = source.aspectRatio;\n\t\tthis.aspectRatioMode = source.aspectRatioMode;\n\t\tthis.calculateProjection = source.calculateProjection;\n\t\tthis.calculateTransform = source.calculateTransform;\n\t\tthis.clearColor = source.clearColor;\n\t\tthis.clearColorBuffer = source.clearColorBuffer;\n\t\tthis.clearDepthBuffer = source.clearDepthBuffer;\n\t\tthis.clearStencilBuffer = source.clearStencilBuffer;\n\t\tthis.cullFaces = source.cullFaces;\n\t\tthis.disablePostEffectsLayer = source.disablePostEffectsLayer;\n\t\tthis.farClip = source.farClip;\n\t\tthis.flipFaces = source.flipFaces;\n\t\tthis.fov = source.fov;\n\t\tthis.frustumCulling = source.frustumCulling;\n\t\tthis.horizontalFov = source.horizontalFov;\n\t\tthis.layers = source.layers;\n\t\tthis.nearClip = source.nearClip;\n\t\tthis.orthoHeight = source.orthoHeight;\n\t\tthis.priority = source.priority;\n\t\tthis.projection = source.projection;\n\t\tthis.rect = source.rect;\n\t\tthis.renderTarget = source.renderTarget;\n\t\tthis.scissorRect = source.scissorRect;\n\t\tthis.sensitivity = source.sensitivity;\n\t\tthis.shutter = source.shutter;\n\t}\n}\n\nexport { CameraComponent };\n", "class CameraComponentData {\n\tconstructor() {\n\t\tthis.enabled = true;\n\t}\n}\n\nexport { CameraComponentData };\n", "import { sortPriority } from '../../../core/sort.js';\nimport { Color } from '../../../core/math/color.js';\nimport { Vec4 } from '../../../core/math/vec4.js';\nimport { Component } from '../component.js';\nimport { ComponentSystem } from '../system.js';\nimport { CameraComponent } from './component.js';\nimport { CameraComponentData } from './data.js';\n\nconst _schema = ['enabled'];\nclass CameraComponentSystem extends ComponentSystem {\n\tconstructor(app) {\n\t\tsuper(app);\n\t\tthis.cameras = [];\n\t\tthis.id = 'camera';\n\t\tthis.ComponentType = CameraComponent;\n\t\tthis.DataType = CameraComponentData;\n\t\tthis.schema = _schema;\n\t\tthis.on('beforeremove', this.onBeforeRemove, this);\n\t\tthis.app.on('prerender', this.onAppPrerender, this);\n\t\tthis.app.systems.on('update', this.onUpdate, this);\n\t}\n\tinitializeComponentData(component, data, properties) {\n\t\tproperties = ['aspectRatio', 'aspectRatioMode', 'calculateProjection', 'calculateTransform', 'clearColor', 'clearColorBuffer', 'clearDepthBuffer', 'clearStencilBuffer', 'renderSceneColorMap', 'renderSceneDepthMap', 'cullFaces', 'farClip', 'flipFaces', 'fov', 'frustumCulling', 'horizontalFov', 'layers', 'renderTarget', 'nearClip', 'orthoHeight', 'projection', 'priority', 'rect', 'scissorRect', 'aperture', 'shutter', 'sensitivity'];\n\t\tfor (let i = 0; i < properties.length; i++) {\n\t\t\tconst property = properties[i];\n\t\t\tif (data.hasOwnProperty(property)) {\n\t\t\t\tconst value = data[property];\n\t\t\t\tswitch (property) {\n\t\t\t\t\tcase 'rect':\n\t\t\t\t\tcase 'scissorRect':\n\t\t\t\t\t\tif (Array.isArray(value)) {\n\t\t\t\t\t\t\tcomponent[property] = new Vec4(value[0], value[1], value[2], value[3]);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tcomponent[property] = value;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase 'clearColor':\n\t\t\t\t\t\tif (Array.isArray(value)) {\n\t\t\t\t\t\t\tcomponent[property] = new Color(value[0], value[1], value[2], value[3]);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tcomponent[property] = value;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tdefault:\n\t\t\t\t\t\tcomponent[property] = value;\n\t\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tsuper.initializeComponentData(component, data, ['enabled']);\n\t}\n\tcloneComponent(entity, clone) {\n\t\tconst c = entity.camera;\n\t\treturn this.addComponent(clone, {\n\t\t\taspectRatio: c.aspectRatio,\n\t\t\taspectRatioMode: c.aspectRatioMode,\n\t\t\tcalculateProjection: c.calculateProjection,\n\t\t\tcalculateTransform: c.calculateTransform,\n\t\t\tclearColor: c.clearColor,\n\t\t\tclearColorBuffer: c.clearColorBuffer,\n\t\t\tclearDepthBuffer: c.clearDepthBuffer,\n\t\t\tclearStencilBuffer: c.clearStencilBuffer,\n\t\t\trenderSceneDepthMap: c.renderSceneDepthMap,\n\t\t\trenderSceneColorMap: c.renderSceneColorMap,\n\t\t\tcullFaces: c.cullFaces,\n\t\t\tenabled: c.enabled,\n\t\t\tfarClip: c.farClip,\n\t\t\tflipFaces: c.flipFaces,\n\t\t\tfov: c.fov,\n\t\t\tfrustumCulling: c.frustumCulling,\n\t\t\thorizontalFov: c.horizontalFov,\n\t\t\tlayers: c.layers,\n\t\t\trenderTarget: c.renderTarget,\n\t\t\tnearClip: c.nearClip,\n\t\t\torthoHeight: c.orthoHeight,\n\t\t\tprojection: c.projection,\n\t\t\tpriority: c.priority,\n\t\t\trect: c.rect,\n\t\t\tscissorRect: c.scissorRect,\n\t\t\taperture: c.aperture,\n\t\t\tsensitivity: c.sensitivity,\n\t\t\tshutter: c.shutter\n\t\t});\n\t}\n\tonBeforeRemove(entity, component) {\n\t\tthis.removeCamera(component);\n\t\tcomponent.onRemove();\n\t}\n\tonUpdate(dt) {}\n\tonAppPrerender() {\n\t\tfor (let i = 0, len = this.cameras.length; i < len; i++) {\n\t\t\tthis.cameras[i].onAppPrerender();\n\t\t}\n\t}\n\taddCamera(camera) {\n\t\tthis.cameras.push(camera);\n\t\tsortPriority(this.cameras);\n\t}\n\tremoveCamera(camera) {\n\t\tconst index = this.cameras.indexOf(camera);\n\t\tif (index >= 0) {\n\t\t\tthis.cameras.splice(index, 1);\n\t\t\tsortPriority(this.cameras);\n\t\t}\n\t}\n\tdestroy() {\n\t\tsuper.destroy();\n\t\tthis.app.systems.off('update', this.onUpdate, this);\n\t}\n}\nComponent._buildAccessors(CameraComponent.prototype, _schema);\n\nexport { CameraComponentSystem };\n", "import { LIGHTSHAPE_PUNCTUAL, LIGHTFALLOFF_LINEAR, SHADOW_PCF3, BLUR_GAUSSIAN, SHADOWUPDATE_REALTIME, LAYERID_WORLD } from '../../../scene/constants.js';\nimport { Color } from '../../../core/math/color.js';\n\nclass LightComponentData {\n\tconstructor() {\n\t\tthis.enabled = true;\n\t\tthis.light = void 0;\n\t\tthis.type = 'directional';\n\t\tthis.color = new Color(1, 1, 1);\n\t\tthis.intensity = 1;\n\t\tthis.luminance = 0;\n\t\tthis.shape = LIGHTSHAPE_PUNCTUAL;\n\t\tthis.affectSpecularity = true;\n\t\tthis.castShadows = false;\n\t\tthis.shadowDistance = 40;\n\t\tthis.shadowIntensity = 1;\n\t\tthis.shadowResolution = 1024;\n\t\tthis.shadowBias = 0.05;\n\t\tthis.numCascades = 1;\n\t\tthis.bakeNumSamples = 1;\n\t\tthis.bakeArea = 0;\n\t\tthis.cascadeDistribution = 0.5;\n\t\tthis.normalOffsetBias = 0;\n\t\tthis.range = 10;\n\t\tthis.innerConeAngle = 40;\n\t\tthis.outerConeAngle = 45;\n\t\tthis.falloffMode = LIGHTFALLOFF_LINEAR;\n\t\tthis.shadowType = SHADOW_PCF3;\n\t\tthis.vsmBlurSize = 11;\n\t\tthis.vsmBlurMode = BLUR_GAUSSIAN;\n\t\tthis.vsmBias = 0.01 * 0.25;\n\t\tthis.cookieAsset = null;\n\t\tthis.cookie = null;\n\t\tthis.cookieIntensity = 1;\n\t\tthis.cookieFalloff = true;\n\t\tthis.cookieChannel = 'rgb';\n\t\tthis.cookieAngle = 0;\n\t\tthis.cookieScale = null;\n\t\tthis.cookieOffset = null;\n\t\tthis.shadowUpdateMode = SHADOWUPDATE_REALTIME;\n\t\tthis.mask = 1;\n\t\tthis.affectDynamic = true;\n\t\tthis.affectLightmapped = false;\n\t\tthis.bake = false;\n\t\tthis.bakeDir = true;\n\t\tthis.isStatic = false;\n\t\tthis.layers = [LAYERID_WORLD];\n\t\tthis.penumbraSize = 1;\n\t}\n}\nconst properties = Object.keys(new LightComponentData());\n\nexport { LightComponentData, properties };\n", "import { math } from '../../../core/math/math.js';\nimport { Vec4 } from '../../../core/math/vec4.js';\nimport { MASK_AFFECT_DYNAMIC, MASK_AFFECT_LIGHTMAPPED, MASK_BAKE } from '../../../scene/constants.js';\nimport { Asset } from '../../asset/asset.js';\nimport { Component } from '../component.js';\nimport { properties } from './data.js';\n\nclass LightComponent extends Component {\n\tconstructor(system, entity) {\n\t\tsuper(system, entity);\n\t\tthis._cookieAsset = null;\n\t\tthis._cookieAssetId = null;\n\t\tthis._cookieAssetAdd = false;\n\t\tthis._cookieMatrix = null;\n\t}\n\tget data() {\n\t\tconst record = this.system.store[this.entity.getGuid()];\n\t\treturn record ? record.data : null;\n\t}\n\tset enabled(arg) {\n\t\tthis._setValue('enabled', arg, function (newValue, oldValue) {\n\t\t\tthis.onSetEnabled(null, oldValue, newValue);\n\t\t});\n\t}\n\tget enabled() {\n\t\treturn this.data.enabled;\n\t}\n\tset light(arg) {\n\t\tthis._setValue('light', arg);\n\t}\n\tget light() {\n\t\treturn this.data.light;\n\t}\n\tset type(arg) {\n\t\tthis._setValue('type', arg, function (newValue, oldValue) {\n\t\t\tthis.system.changeType(this, oldValue, newValue);\n\t\t\tthis.refreshProperties();\n\t\t});\n\t}\n\tget type() {\n\t\treturn this.data.type;\n\t}\n\tset color(arg) {\n\t\tthis._setValue('color', arg, function (newValue, oldValue) {\n\t\t\tthis.light.setColor(newValue);\n\t\t}, true);\n\t}\n\tget color() {\n\t\treturn this.data.color;\n\t}\n\tset intensity(arg) {\n\t\tthis._setValue('intensity', arg, function (newValue, oldValue) {\n\t\t\tthis.light.intensity = newValue;\n\t\t});\n\t}\n\tget intensity() {\n\t\treturn this.data.intensity;\n\t}\n\tset luminance(arg) {\n\t\tthis._setValue('luminance', arg, function (newValue, oldValue) {\n\t\t\tthis.light.luminance = newValue;\n\t\t});\n\t}\n\tget luminance() {\n\t\treturn this.data.luminance;\n\t}\n\tset shape(arg) {\n\t\tthis._setValue('shape', arg, function (newValue, oldValue) {\n\t\t\tthis.light.shape = newValue;\n\t\t});\n\t}\n\tget shape() {\n\t\treturn this.data.shape;\n\t}\n\tset affectSpecularity(arg) {\n\t\tthis._setValue('affectSpecularity', arg, function (newValue, oldValue) {\n\t\t\tthis.light.affectSpecularity = newValue;\n\t\t});\n\t}\n\tget affectSpecularity() {\n\t\treturn this.data.affectSpecularity;\n\t}\n\tset castShadows(arg) {\n\t\tthis._setValue('castShadows', arg, function (newValue, oldValue) {\n\t\t\tthis.light.castShadows = newValue;\n\t\t});\n\t}\n\tget castShadows() {\n\t\treturn this.data.castShadows;\n\t}\n\tset shadowDistance(arg) {\n\t\tthis._setValue('shadowDistance', arg, function (newValue, oldValue) {\n\t\t\tthis.light.shadowDistance = newValue;\n\t\t});\n\t}\n\tget shadowDistance() {\n\t\treturn this.data.shadowDistance;\n\t}\n\tset shadowIntensity(arg) {\n\t\tthis._setValue('shadowIntensity', arg, function (newValue, oldValue) {\n\t\t\tthis.light.shadowIntensity = newValue;\n\t\t});\n\t}\n\tget shadowIntensity() {\n\t\treturn this.data.shadowIntensity;\n\t}\n\tset shadowResolution(arg) {\n\t\tthis._setValue('shadowResolution', arg, function (newValue, oldValue) {\n\t\t\tthis.light.shadowResolution = newValue;\n\t\t});\n\t}\n\tget shadowResolution() {\n\t\treturn this.data.shadowResolution;\n\t}\n\tset shadowBias(arg) {\n\t\tthis._setValue('shadowBias', arg, function (newValue, oldValue) {\n\t\t\tthis.light.shadowBias = -0.01 * math.clamp(newValue, 0, 1);\n\t\t});\n\t}\n\tget shadowBias() {\n\t\treturn this.data.shadowBias;\n\t}\n\tset numCascades(arg) {\n\t\tthis._setValue('numCascades', arg, function (newValue, oldValue) {\n\t\t\tthis.light.numCascades = math.clamp(Math.floor(newValue), 1, 4);\n\t\t});\n\t}\n\tget numCascades() {\n\t\treturn this.data.numCascades;\n\t}\n\tset bakeNumSamples(arg) {\n\t\tthis._setValue('bakeNumSamples', arg, function (newValue, oldValue) {\n\t\t\tthis.light.bakeNumSamples = math.clamp(Math.floor(newValue), 1, 255);\n\t\t});\n\t}\n\tget bakeNumSamples() {\n\t\treturn this.data.bakeNumSamples;\n\t}\n\tset bakeArea(arg) {\n\t\tthis._setValue('bakeArea', arg, function (newValue, oldValue) {\n\t\t\tthis.light.bakeArea = math.clamp(newValue, 0, 180);\n\t\t});\n\t}\n\tget bakeArea() {\n\t\treturn this.data.bakeArea;\n\t}\n\tset cascadeDistribution(arg) {\n\t\tthis._setValue('cascadeDistribution', arg, function (newValue, oldValue) {\n\t\t\tthis.light.cascadeDistribution = math.clamp(newValue, 0, 1);\n\t\t});\n\t}\n\tget cascadeDistribution() {\n\t\treturn this.data.cascadeDistribution;\n\t}\n\tset normalOffsetBias(arg) {\n\t\tthis._setValue('normalOffsetBias', arg, function (newValue, oldValue) {\n\t\t\tthis.light.normalOffsetBias = math.clamp(newValue, 0, 1);\n\t\t});\n\t}\n\tget normalOffsetBias() {\n\t\treturn this.data.normalOffsetBias;\n\t}\n\tset range(arg) {\n\t\tthis._setValue('range', arg, function (newValue, oldValue) {\n\t\t\tthis.light.attenuationEnd = newValue;\n\t\t});\n\t}\n\tget range() {\n\t\treturn this.data.range;\n\t}\n\tset innerConeAngle(arg) {\n\t\tthis._setValue('innerConeAngle', arg, function (newValue, oldValue) {\n\t\t\tthis.light.innerConeAngle = newValue;\n\t\t});\n\t}\n\tget innerConeAngle() {\n\t\treturn this.data.innerConeAngle;\n\t}\n\tset outerConeAngle(arg) {\n\t\tthis._setValue('outerConeAngle', arg, function (newValue, oldValue) {\n\t\t\tthis.light.outerConeAngle = newValue;\n\t\t});\n\t}\n\tget outerConeAngle() {\n\t\treturn this.data.outerConeAngle;\n\t}\n\tset falloffMode(arg) {\n\t\tthis._setValue('falloffMode', arg, function (newValue, oldValue) {\n\t\t\tthis.light.falloffMode = newValue;\n\t\t});\n\t}\n\tget falloffMode() {\n\t\treturn this.data.falloffMode;\n\t}\n\tset shadowType(arg) {\n\t\tthis._setValue('shadowType', arg, function (newValue, oldValue) {\n\t\t\tthis.light.shadowType = newValue;\n\t\t});\n\t}\n\tget shadowType() {\n\t\treturn this.data.shadowType;\n\t}\n\tset vsmBlurSize(arg) {\n\t\tthis._setValue('vsmBlurSize', arg, function (newValue, oldValue) {\n\t\t\tthis.light.vsmBlurSize = newValue;\n\t\t});\n\t}\n\tget vsmBlurSize() {\n\t\treturn this.data.vsmBlurSize;\n\t}\n\tset vsmBlurMode(arg) {\n\t\tthis._setValue('vsmBlurMode', arg, function (newValue, oldValue) {\n\t\t\tthis.light.vsmBlurMode = newValue;\n\t\t});\n\t}\n\tget vsmBlurMode() {\n\t\treturn this.data.vsmBlurMode;\n\t}\n\tset vsmBias(arg) {\n\t\tthis._setValue('vsmBias', arg, function (newValue, oldValue) {\n\t\t\tthis.light.vsmBias = math.clamp(newValue, 0, 1);\n\t\t});\n\t}\n\tget vsmBias() {\n\t\treturn this.data.vsmBias;\n\t}\n\tset cookieAsset(arg) {\n\t\tthis._setValue('cookieAsset', arg, function (newValue, oldValue) {\n\t\t\tif (this._cookieAssetId && (newValue instanceof Asset && newValue.id === this._cookieAssetId || newValue === this._cookieAssetId)) return;\n\t\t\tthis.onCookieAssetRemove();\n\t\t\tthis._cookieAssetId = null;\n\t\t\tif (newValue instanceof Asset) {\n\t\t\t\tthis.data.cookieAsset = newValue.id;\n\t\t\t\tthis._cookieAssetId = newValue.id;\n\t\t\t\tthis.onCookieAssetAdd(newValue);\n\t\t\t} else if (typeof newValue === 'number') {\n\t\t\t\tthis._cookieAssetId = newValue;\n\t\t\t\tconst asset = this.system.app.assets.get(newValue);\n\t\t\t\tif (asset) {\n\t\t\t\t\tthis.onCookieAssetAdd(asset);\n\t\t\t\t} else {\n\t\t\t\t\tthis._cookieAssetAdd = true;\n\t\t\t\t\tthis.system.app.assets.on('add:' + this._cookieAssetId, this.onCookieAssetAdd, this);\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t}\n\tget cookieAsset() {\n\t\treturn this.data.cookieAsset;\n\t}\n\tset cookie(arg) {\n\t\tthis._setValue('cookie', arg, function (newValue, oldValue) {\n\t\t\tthis.light.cookie = newValue;\n\t\t});\n\t}\n\tget cookie() {\n\t\treturn this.data.cookie;\n\t}\n\tset cookieIntensity(arg) {\n\t\tthis._setValue('cookieIntensity', arg, function (newValue, oldValue) {\n\t\t\tthis.light.cookieIntensity = math.clamp(newValue, 0, 1);\n\t\t});\n\t}\n\tget cookieIntensity() {\n\t\treturn this.data.cookieIntensity;\n\t}\n\tset cookieFalloff(arg) {\n\t\tthis._setValue('cookieFalloff', arg, function (newValue, oldValue) {\n\t\t\tthis.light.cookieFalloff = newValue;\n\t\t});\n\t}\n\tget cookieFalloff() {\n\t\treturn this.data.cookieFalloff;\n\t}\n\tset cookieChannel(arg) {\n\t\tthis._setValue('cookieChannel', arg, function (newValue, oldValue) {\n\t\t\tthis.light.cookieChannel = newValue;\n\t\t});\n\t}\n\tget cookieChannel() {\n\t\treturn this.data.cookieChannel;\n\t}\n\tset cookieAngle(arg) {\n\t\tthis._setValue('cookieAngle', arg, function (newValue, oldValue) {\n\t\t\tif (newValue !== 0 || this.cookieScale !== null) {\n\t\t\t\tif (!this._cookieMatrix) this._cookieMatrix = new Vec4();\n\t\t\t\tlet scx = 1;\n\t\t\t\tlet scy = 1;\n\t\t\t\tif (this.cookieScale) {\n\t\t\t\t\tscx = this.cookieScale.x;\n\t\t\t\t\tscy = this.cookieScale.y;\n\t\t\t\t}\n\t\t\t\tconst c = Math.cos(newValue * math.DEG_TO_RAD);\n\t\t\t\tconst s = Math.sin(newValue * math.DEG_TO_RAD);\n\t\t\t\tthis._cookieMatrix.set(c / scx, -s / scx, s / scy, c / scy);\n\t\t\t\tthis.light.cookieTransform = this._cookieMatrix;\n\t\t\t} else {\n\t\t\t\tthis.light.cookieTransform = null;\n\t\t\t}\n\t\t});\n\t}\n\tget cookieAngle() {\n\t\treturn this.data.cookieAngle;\n\t}\n\tset cookieScale(arg) {\n\t\tthis._setValue('cookieScale', arg, function (newValue, oldValue) {\n\t\t\tif (newValue !== null || this.cookieAngle !== 0) {\n\t\t\t\tif (!this._cookieMatrix) this._cookieMatrix = new Vec4();\n\t\t\t\tconst scx = newValue.x;\n\t\t\t\tconst scy = newValue.y;\n\t\t\t\tconst c = Math.cos(this.cookieAngle * math.DEG_TO_RAD);\n\t\t\t\tconst s = Math.sin(this.cookieAngle * math.DEG_TO_RAD);\n\t\t\t\tthis._cookieMatrix.set(c / scx, -s / scx, s / scy, c / scy);\n\t\t\t\tthis.light.cookieTransform = this._cookieMatrix;\n\t\t\t} else {\n\t\t\t\tthis.light.cookieTransform = null;\n\t\t\t}\n\t\t}, true);\n\t}\n\tget cookieScale() {\n\t\treturn this.data.cookieScale;\n\t}\n\tset cookieOffset(arg) {\n\t\tthis._setValue('cookieOffset', arg, function (newValue, oldValue) {\n\t\t\tthis.light.cookieOffset = newValue;\n\t\t}, true);\n\t}\n\tget cookieOffset() {\n\t\treturn this.data.cookieOffset;\n\t}\n\tset shadowUpdateMode(arg) {\n\t\tthis._setValue('shadowUpdateMode', arg, function (newValue, oldValue) {\n\t\t\tthis.light.shadowUpdateMode = newValue;\n\t\t}, true);\n\t}\n\tget shadowUpdateMode() {\n\t\treturn this.data.shadowUpdateMode;\n\t}\n\tset mask(arg) {\n\t\tthis._setValue('mask', arg, function (newValue, oldValue) {\n\t\t\tthis.light.mask = newValue;\n\t\t});\n\t}\n\tget mask() {\n\t\treturn this.data.mask;\n\t}\n\tset affectDynamic(arg) {\n\t\tthis._setValue('affectDynamic', arg, function (newValue, oldValue) {\n\t\t\tif (newValue) {\n\t\t\t\tthis.light.mask |= MASK_AFFECT_DYNAMIC;\n\t\t\t} else {\n\t\t\t\tthis.light.mask &= ~MASK_AFFECT_DYNAMIC;\n\t\t\t}\n\t\t\tthis.light.layersDirty();\n\t\t});\n\t}\n\tget affectDynamic() {\n\t\treturn this.data.affectDynamic;\n\t}\n\tset affectLightmapped(arg) {\n\t\tthis._setValue('affectLightmapped', arg, function (newValue, oldValue) {\n\t\t\tif (newValue) {\n\t\t\t\tthis.light.mask |= MASK_AFFECT_LIGHTMAPPED;\n\t\t\t\tif (this.bake) this.light.mask &= ~MASK_BAKE;\n\t\t\t} else {\n\t\t\t\tthis.light.mask &= ~MASK_AFFECT_LIGHTMAPPED;\n\t\t\t\tif (this.bake) this.light.mask |= MASK_BAKE;\n\t\t\t}\n\t\t});\n\t}\n\tget affectLightmapped() {\n\t\treturn this.data.affectLightmapped;\n\t}\n\tset bake(arg) {\n\t\tthis._setValue('bake', arg, function (newValue, oldValue) {\n\t\t\tif (newValue) {\n\t\t\t\tthis.light.mask |= MASK_BAKE;\n\t\t\t\tif (this.affectLightmapped) this.light.mask &= ~MASK_AFFECT_LIGHTMAPPED;\n\t\t\t} else {\n\t\t\t\tthis.light.mask &= ~MASK_BAKE;\n\t\t\t\tif (this.affectLightmapped) this.light.mask |= MASK_AFFECT_LIGHTMAPPED;\n\t\t\t}\n\t\t\tthis.light.layersDirty();\n\t\t});\n\t}\n\tget bake() {\n\t\treturn this.data.bake;\n\t}\n\tset bakeDir(arg) {\n\t\tthis._setValue('bakeDir', arg, function (newValue, oldValue) {\n\t\t\tthis.light.bakeDir = newValue;\n\t\t});\n\t}\n\tget bakeDir() {\n\t\treturn this.data.bakeDir;\n\t}\n\tset isStatic(arg) {\n\t\tthis._setValue('isStatic', arg, function (newValue, oldValue) {\n\t\t\tthis.light.isStatic = newValue;\n\t\t});\n\t}\n\tget isStatic() {\n\t\treturn this.data.isStatic;\n\t}\n\tset layers(arg) {\n\t\tthis._setValue('layers', arg, function (newValue, oldValue) {\n\t\t\tfor (let i = 0; i < oldValue.length; i++) {\n\t\t\t\tconst layer = this.system.app.scene.layers.getLayerById(oldValue[i]);\n\t\t\t\tif (!layer) continue;\n\t\t\t\tlayer.removeLight(this);\n\t\t\t\tthis.light.removeLayer(layer);\n\t\t\t}\n\t\t\tfor (let i = 0; i < newValue.length; i++) {\n\t\t\t\tconst layer = this.system.app.scene.layers.getLayerById(newValue[i]);\n\t\t\t\tif (!layer) continue;\n\t\t\t\tif (this.enabled && this.entity.enabled) {\n\t\t\t\t\tlayer.addLight(this);\n\t\t\t\t\tthis.light.addLayer(layer);\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t}\n\tget layers() {\n\t\treturn this.data.layers;\n\t}\n\tset shadowUpdateOverrides(values) {\n\t\tthis.light.shadowUpdateOverrides = values;\n\t}\n\tget shadowUpdateOverrides() {\n\t\treturn this.light.shadowUpdateOverrides;\n\t}\n\tset penumbraSize(value) {\n\t\tthis.light.penumbraSize = value;\n\t}\n\tget penumbraSize() {\n\t\treturn this.light.penumbraSize;\n\t}\n\t_setValue(name, value, setFunc, skipEqualsCheck) {\n\t\tconst data = this.data;\n\t\tconst oldValue = data[name];\n\t\tif (!skipEqualsCheck && oldValue === value) return;\n\t\tdata[name] = value;\n\t\tif (setFunc) setFunc.call(this, value, oldValue);\n\t}\n\taddLightToLayers() {\n\t\tfor (let i = 0; i < this.layers.length; i++) {\n\t\t\tconst layer = this.system.app.scene.layers.getLayerById(this.layers[i]);\n\t\t\tif (layer) {\n\t\t\t\tlayer.addLight(this);\n\t\t\t\tthis.light.addLayer(layer);\n\t\t\t}\n\t\t}\n\t}\n\tremoveLightFromLayers() {\n\t\tfor (let i = 0; i < this.layers.length; i++) {\n\t\t\tconst layer = this.system.app.scene.layers.getLayerById(this.layers[i]);\n\t\t\tif (layer) {\n\t\t\t\tlayer.removeLight(this);\n\t\t\t\tthis.light.removeLayer(layer);\n\t\t\t}\n\t\t}\n\t}\n\tonLayersChanged(oldComp, newComp) {\n\t\tif (this.enabled && this.entity.enabled) {\n\t\t\tthis.addLightToLayers();\n\t\t}\n\t\toldComp.off('add', this.onLayerAdded, this);\n\t\toldComp.off('remove', this.onLayerRemoved, this);\n\t\tnewComp.on('add', this.onLayerAdded, this);\n\t\tnewComp.on('remove', this.onLayerRemoved, this);\n\t}\n\tonLayerAdded(layer) {\n\t\tconst index = this.layers.indexOf(layer.id);\n\t\tif (index >= 0 && this.enabled && this.entity.enabled) {\n\t\t\tlayer.addLight(this);\n\t\t\tthis.light.addLayer(layer);\n\t\t}\n\t}\n\tonLayerRemoved(layer) {\n\t\tconst index = this.layers.indexOf(layer.id);\n\t\tif (index >= 0) {\n\t\t\tlayer.removeLight(this);\n\t\t\tthis.light.removeLayer(layer);\n\t\t}\n\t}\n\trefreshProperties() {\n\t\tfor (let i = 0; i < properties.length; i++) {\n\t\t\tconst name = properties[i];\n\t\t\tthis[name] = this[name];\n\t\t}\n\t\tif (this.enabled && this.entity.enabled) {\n\t\t\tthis.onEnable();\n\t\t}\n\t}\n\tonCookieAssetSet() {\n\t\tlet forceLoad = false;\n\t\tif (this._cookieAsset.type === 'cubemap' && !this._cookieAsset.loadFaces) {\n\t\t\tthis._cookieAsset.loadFaces = true;\n\t\t\tforceLoad = true;\n\t\t}\n\t\tif (!this._cookieAsset.resource || forceLoad) this.system.app.assets.load(this._cookieAsset);\n\t\tif (this._cookieAsset.resource) {\n\t\t\tthis.onCookieAssetLoad();\n\t\t}\n\t}\n\tonCookieAssetAdd(asset) {\n\t\tif (this._cookieAssetId !== asset.id) return;\n\t\tthis._cookieAsset = asset;\n\t\tif (this.light.enabled) {\n\t\t\tthis.onCookieAssetSet();\n\t\t}\n\t\tthis._cookieAsset.on('load', this.onCookieAssetLoad, this);\n\t\tthis._cookieAsset.on('remove', this.onCookieAssetRemove, this);\n\t}\n\tonCookieAssetLoad() {\n\t\tif (!this._cookieAsset || !this._cookieAsset.resource) {\n\t\t\treturn;\n\t\t}\n\t\tthis.cookie = this._cookieAsset.resource;\n\t}\n\tonCookieAssetRemove() {\n\t\tif (!this._cookieAssetId) {\n\t\t\treturn;\n\t\t}\n\t\tif (this._cookieAssetAdd) {\n\t\t\tthis.system.app.assets.off('add:' + this._cookieAssetId, this.onCookieAssetAdd, this);\n\t\t\tthis._cookieAssetAdd = false;\n\t\t}\n\t\tif (this._cookieAsset) {\n\t\t\tthis._cookieAsset.off('load', this.onCookieAssetLoad, this);\n\t\t\tthis._cookieAsset.off('remove', this.onCookieAssetRemove, this);\n\t\t\tthis._cookieAsset = null;\n\t\t}\n\t\tthis.cookie = null;\n\t}\n\tonEnable() {\n\t\tthis.light.enabled = true;\n\t\tthis.system.app.scene.on('set:layers', this.onLayersChanged, this);\n\t\tif (this.system.app.scene.layers) {\n\t\t\tthis.system.app.scene.layers.on('add', this.onLayerAdded, this);\n\t\t\tthis.system.app.scene.layers.on('remove', this.onLayerRemoved, this);\n\t\t}\n\t\tif (this.enabled && this.entity.enabled) {\n\t\t\tthis.addLightToLayers();\n\t\t}\n\t\tif (this._cookieAsset && !this.cookie) {\n\t\t\tthis.onCookieAssetSet();\n\t\t}\n\t}\n\tonDisable() {\n\t\tthis.light.enabled = false;\n\t\tthis.system.app.scene.off('set:layers', this.onLayersChanged, this);\n\t\tif (this.system.app.scene.layers) {\n\t\t\tthis.system.app.scene.layers.off('add', this.onLayerAdded, this);\n\t\t\tthis.system.app.scene.layers.off('remove', this.onLayerRemoved, this);\n\t\t}\n\t\tthis.removeLightFromLayers();\n\t}\n\tonRemove() {\n\t\tthis.onDisable();\n\t\tthis.light.destroy();\n\t\tthis.cookieAsset = null;\n\t}\n}\n\nexport { LightComponent };\n", "import { extends as _extends } from '../../../../_virtual/_rollupPluginBabelHelpers.js';\nimport { Color } from '../../../core/math/color.js';\nimport { Vec2 } from '../../../core/math/vec2.js';\nimport { LIGHTSHAPE_PUNCTUAL } from '../../../scene/constants.js';\nimport { Light, lightTypes } from '../../../scene/light.js';\nimport { ComponentSystem } from '../system.js';\nimport { LightComponent } from './component.js';\nimport { LightComponentData, properties } from './data.js';\n\nclass LightComponentSystem extends ComponentSystem {\n\tconstructor(app) {\n\t\tsuper(app);\n\t\tthis.id = 'light';\n\t\tthis.ComponentType = LightComponent;\n\t\tthis.DataType = LightComponentData;\n\t\tthis.on('beforeremove', this._onRemoveComponent, this);\n\t}\n\tinitializeComponentData(component, _data) {\n\t\tconst data = _extends({}, _data);\n\t\tif (!data.type) data.type = component.data.type;\n\t\tcomponent.data.type = data.type;\n\t\tif (data.layers && Array.isArray(data.layers)) {\n\t\t\tdata.layers = data.layers.slice(0);\n\t\t}\n\t\tif (data.color && Array.isArray(data.color)) data.color = new Color(data.color[0], data.color[1], data.color[2]);\n\t\tif (data.cookieOffset && data.cookieOffset instanceof Array) data.cookieOffset = new Vec2(data.cookieOffset[0], data.cookieOffset[1]);\n\t\tif (data.cookieScale && data.cookieScale instanceof Array) data.cookieScale = new Vec2(data.cookieScale[0], data.cookieScale[1]);\n\t\tif (data.enable) {\n\t\t\tconsole.warn('WARNING: enable: Property is deprecated. Set enabled property instead.');\n\t\t\tdata.enabled = data.enable;\n\t\t}\n\t\tif (!data.shape) {\n\t\t\tdata.shape = LIGHTSHAPE_PUNCTUAL;\n\t\t}\n\t\tconst light = new Light(this.app.graphicsDevice, this.app.scene.clusteredLightingEnabled);\n\t\tlight.type = lightTypes[data.type];\n\t\tlight._node = component.entity;\n\t\tcomponent.data.light = light;\n\t\tsuper.initializeComponentData(component, data, properties);\n\t}\n\t_onRemoveComponent(entity, component) {\n\t\tcomponent.onRemove();\n\t}\n\tcloneComponent(entity, clone) {\n\t\tconst light = entity.light;\n\t\tconst data = [];\n\t\tlet name;\n\t\tfor (let i = 0; i < properties.length; i++) {\n\t\t\tname = properties[i];\n\t\t\tif (name === 'light') {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif (light[name] && light[name].clone) {\n\t\t\t\tdata[name] = light[name].clone();\n\t\t\t} else {\n\t\t\t\tdata[name] = light[name];\n\t\t\t}\n\t\t}\n\t\treturn this.addComponent(clone, data);\n\t}\n\tchangeType(component, oldValue, newValue) {\n\t\tif (oldValue !== newValue) {\n\t\t\tcomponent.light.type = lightTypes[newValue];\n\t\t}\n\t}\n}\n\nexport { LightComponentSystem };\n", "import { EventHandler } from '../core/event-handler.js';\n\nclass Render extends EventHandler {\n\tconstructor() {\n\t\tsuper();\n\t\tthis._meshes = null;\n\t}\n\tset meshes(value) {\n\t\tthis.decRefMeshes();\n\t\tthis._meshes = value;\n\t\tthis.incRefMeshes();\n\t\tthis.fire('set:meshes', value);\n\t}\n\tget meshes() {\n\t\treturn this._meshes;\n\t}\n\tdestroy() {\n\t\tthis.meshes = null;\n\t}\n\tdecRefMeshes() {\n\t\tif (this._meshes) {\n\t\t\tconst count = this._meshes.length;\n\t\t\tfor (let i = 0; i < count; i++) {\n\t\t\t\tconst mesh = this._meshes[i];\n\t\t\t\tif (mesh) {\n\t\t\t\t\tmesh.decRefCount();\n\t\t\t\t\tif (mesh.refCount < 1) {\n\t\t\t\t\t\tmesh.destroy();\n\t\t\t\t\t\tthis._meshes[i] = null;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\tincRefMeshes() {\n\t\tif (this._meshes) {\n\t\t\tconst count = this._meshes.length;\n\t\t\tfor (let i = 0; i < count; i++) {\n\t\t\t\tif (this._meshes[i]) {\n\t\t\t\t\tthis._meshes[i].incRefCount();\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\nRender.EVENT_SETMESHES = 'set:meshes';\n\nexport { Render };\n", "class AnimCurve {\n\tconstructor(paths, input, output, interpolation) {\n\t\tthis._paths = paths;\n\t\tthis._input = input;\n\t\tthis._output = output;\n\t\tthis._interpolation = interpolation;\n\t}\n\tget paths() {\n\t\treturn this._paths;\n\t}\n\tget input() {\n\t\treturn this._input;\n\t}\n\tget output() {\n\t\treturn this._output;\n\t}\n\tget interpolation() {\n\t\treturn this._interpolation;\n\t}\n}\n\nexport { AnimCurve };\n", "class AnimData {\n\tconstructor(components, data) {\n\t\tthis._components = components;\n\t\tthis._data = data;\n\t}\n\tget components() {\n\t\treturn this._components;\n\t}\n\tget data() {\n\t\treturn this._data;\n\t}\n}\n\nexport { AnimData };\n", "function DracoWorker(jsUrl, wasmUrl) {\n\tlet draco;\n\tconst POSITION_ATTRIBUTE = 0;\n\tconst NORMAL_ATTRIBUTE = 1;\n\tconst wrap = (typedArray, dataType) => {\n\t\tswitch (dataType) {\n\t\t\tcase draco.DT_INT8:\n\t\t\t\treturn new Int8Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength);\n\t\t\tcase draco.DT_INT16:\n\t\t\t\treturn new Int16Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength / 2);\n\t\t\tcase draco.DT_INT32:\n\t\t\t\treturn new Int32Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength / 4);\n\t\t\tcase draco.DT_UINT8:\n\t\t\t\treturn new Uint8Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength);\n\t\t\tcase draco.DT_UINT16:\n\t\t\t\treturn new Uint16Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength / 2);\n\t\t\tcase draco.DT_UINT32:\n\t\t\t\treturn new Uint32Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength / 4);\n\t\t\tcase draco.DT_FLOAT32:\n\t\t\t\treturn new Float32Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength / 4);\n\t\t}\n\t\treturn null;\n\t};\n\tconst componentSizeInBytes = dataType => {\n\t\tswitch (dataType) {\n\t\t\tcase draco.DT_INT8:\n\t\t\t\treturn 1;\n\t\t\tcase draco.DT_INT16:\n\t\t\t\treturn 2;\n\t\t\tcase draco.DT_INT32:\n\t\t\t\treturn 4;\n\t\t\tcase draco.DT_UINT8:\n\t\t\t\treturn 1;\n\t\t\tcase draco.DT_UINT16:\n\t\t\t\treturn 2;\n\t\t\tcase draco.DT_UINT32:\n\t\t\t\treturn 4;\n\t\t\tcase draco.DT_FLOAT32:\n\t\t\t\treturn 4;\n\t\t}\n\t\treturn 1;\n\t};\n\tconst attributeSizeInBytes = attribute => {\n\t\treturn attribute.num_components() * componentSizeInBytes(attribute.data_type());\n\t};\n\tconst attributeOrder = {\n\t\t0: 0,\n\t\t1: 1,\n\t\t5: 2,\n\t\t2: 3,\n\t\t7: 4,\n\t\t8: 5,\n\t\t4: 6,\n\t\t3: 7\n\t};\n\tconst generateNormals = (vertices, indices) => {\n\t\tconst subtract = (dst, a, b) => {\n\t\t\tdst[0] = a[0] - b[0];\n\t\t\tdst[1] = a[1] - b[1];\n\t\t\tdst[2] = a[2] - b[2];\n\t\t};\n\t\tconst cross = (dst, a, b) => {\n\t\t\tdst[0] = a[1] * b[2] - b[1] * a[2];\n\t\t\tdst[1] = a[2] * b[0] - b[2] * a[0];\n\t\t\tdst[2] = a[0] * b[1] - b[0] * a[1];\n\t\t};\n\t\tconst normalize = (dst, offset) => {\n\t\t\tconst a = dst[offset + 0];\n\t\t\tconst b = dst[offset + 1];\n\t\t\tconst c = dst[offset + 2];\n\t\t\tconst l = 1.0 / Math.sqrt(a * a + b * b + c * c);\n\t\t\tdst[offset + 0] *= l;\n\t\t\tdst[offset + 1] *= l;\n\t\t\tdst[offset + 2] *= l;\n\t\t};\n\t\tconst copy = (dst, src, srcOffset) => {\n\t\t\tfor (let i = 0; i < 3; ++i) {\n\t\t\t\tdst[i] = src[srcOffset + i];\n\t\t\t}\n\t\t};\n\t\tconst numTriangles = indices.length / 3;\n\t\tconst numVertices = vertices.length / 3;\n\t\tconst result = new Float32Array(vertices.length);\n\t\tconst a = [0, 0, 0],\n\t\t\tb = [0, 0, 0],\n\t\t\tc = [0, 0, 0],\n\t\t\tt1 = [0, 0, 0],\n\t\t\tt2 = [0, 0, 0],\n\t\t\tn = [0, 0, 0];\n\t\tfor (let i = 0; i < numTriangles; ++i) {\n\t\t\tconst v0 = indices[i * 3 + 0] * 3;\n\t\t\tconst v1 = indices[i * 3 + 1] * 3;\n\t\t\tconst v2 = indices[i * 3 + 2] * 3;\n\t\t\tcopy(a, vertices, v0);\n\t\t\tcopy(b, vertices, v1);\n\t\t\tcopy(c, vertices, v2);\n\t\t\tsubtract(t1, b, a);\n\t\t\tsubtract(t2, c, a);\n\t\t\tcross(n, t1, t2);\n\t\t\tnormalize(n, 0);\n\t\t\tfor (let j = 0; j < 3; ++j) {\n\t\t\t\tresult[v0 + j] += n[j];\n\t\t\t\tresult[v1 + j] += n[j];\n\t\t\t\tresult[v2 + j] += n[j];\n\t\t\t}\n\t\t}\n\t\tfor (let i = 0; i < numVertices; ++i) {\n\t\t\tnormalize(result, i * 3);\n\t\t}\n\t\treturn new Uint8Array(result.buffer);\n\t};\n\tconst decodeMesh = inputBuffer => {\n\t\tconst result = {};\n\t\tconst buffer = new draco.DecoderBuffer();\n\t\tbuffer.Init(inputBuffer, inputBuffer.length);\n\t\tconst decoder = new draco.Decoder();\n\t\tif (decoder.GetEncodedGeometryType(buffer) !== draco.TRIANGULAR_MESH) {\n\t\t\tresult.error = 'Failed to decode draco mesh: not a mesh';\n\t\t\treturn result;\n\t\t}\n\t\tconst mesh = new draco.Mesh();\n\t\tconst status = decoder.DecodeBufferToMesh(buffer, mesh);\n\t\tif (!status || !status.ok() || mesh.ptr === 0) {\n\t\t\tresult.error = 'Failed to decode draco asset';\n\t\t\treturn result;\n\t\t}\n\t\tconst numIndices = mesh.num_faces() * 3;\n\t\tconst shortIndices = mesh.num_points() <= 65535;\n\t\tconst indicesSize = numIndices * (shortIndices ? 2 : 4);\n\t\tconst indicesPtr = draco._malloc(indicesSize);\n\t\tif (shortIndices) {\n\t\t\tdecoder.GetTrianglesUInt16Array(mesh, indicesSize, indicesPtr);\n\t\t\tresult.indices = new Uint16Array(draco.HEAPU16.buffer, indicesPtr, numIndices).slice().buffer;\n\t\t} else {\n\t\t\tdecoder.GetTrianglesUInt32Array(mesh, indicesSize, indicesPtr);\n\t\t\tresult.indices = new Uint32Array(draco.HEAPU32.buffer, indicesPtr, numIndices).slice().buffer;\n\t\t}\n\t\tdraco._free(indicesPtr);\n\t\tconst attributes = [];\n\t\tfor (let i = 0; i < mesh.num_attributes(); ++i) {\n\t\t\tattributes.push(decoder.GetAttribute(mesh, i));\n\t\t}\n\t\tattributes.sort((a, b) => {\n\t\t\tvar _attributeOrder$a$att, _attributeOrder$b$att;\n\t\t\treturn ((_attributeOrder$a$att = attributeOrder[a.attribute_type()]) != null ? _attributeOrder$a$att : attributeOrder.length) - ((_attributeOrder$b$att = attributeOrder[b.attribute_type()]) != null ? _attributeOrder$b$att : attributeOrder.length);\n\t\t});\n\t\tresult.attributes = attributes.map(a => a.unique_id());\n\t\tlet totalVertexSize = 0;\n\t\tconst offsets = attributes.map(a => {\n\t\t\tconst offset = totalVertexSize;\n\t\t\ttotalVertexSize += Math.ceil(attributeSizeInBytes(a) / 4) * 4;\n\t\t\treturn offset;\n\t\t});\n\t\tconst hasNormals = attributes.some(a => a.attribute_type() === NORMAL_ATTRIBUTE);\n\t\tconst normalOffset = offsets[1];\n\t\tif (!hasNormals) {\n\t\t\tfor (let i = 1; i < offsets.length; ++i) {\n\t\t\t\toffsets[i] += 12;\n\t\t\t}\n\t\t\ttotalVertexSize += 12;\n\t\t}\n\t\tresult.vertices = new ArrayBuffer(mesh.num_points() * totalVertexSize);\n\t\tconst dst = new Uint8Array(result.vertices);\n\t\tfor (let i = 0; i < mesh.num_attributes(); ++i) {\n\t\t\tconst attribute = attributes[i];\n\t\t\tconst sizeInBytes = attributeSizeInBytes(attribute);\n\t\t\tconst ptrSize = mesh.num_points() * sizeInBytes;\n\t\t\tconst ptr = draco._malloc(ptrSize);\n\t\t\tdecoder.GetAttributeDataArrayForAllPoints(mesh, attribute, attribute.data_type(), ptrSize, ptr);\n\t\t\tconst src = new Uint8Array(draco.HEAPU8.buffer, ptr, ptrSize);\n\t\t\tfor (let j = 0; j < mesh.num_points(); ++j) {\n\t\t\t\tfor (let c = 0; c < sizeInBytes; ++c) {\n\t\t\t\t\tdst[j * totalVertexSize + offsets[i] + c] = src[j * sizeInBytes + c];\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (!hasNormals && attribute.attribute_type() === POSITION_ATTRIBUTE) {\n\t\t\t\tconst normals = generateNormals(wrap(src, attribute.data_type()), shortIndices ? new Uint16Array(result.indices) : new Uint32Array(result.indices));\n\t\t\t\tfor (let j = 0; j < mesh.num_points(); ++j) {\n\t\t\t\t\tfor (let c = 0; c < 12; ++c) {\n\t\t\t\t\t\tdst[j * totalVertexSize + normalOffset + c] = normals[j * 12 + c];\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tdraco._free(ptr);\n\t\t}\n\t\tdraco.destroy(mesh);\n\t\tdraco.destroy(decoder);\n\t\tdraco.destroy(buffer);\n\t\treturn result;\n\t};\n\tconst decode = data => {\n\t\tconst result = decodeMesh(new Uint8Array(data.buffer));\n\t\tself.postMessage({\n\t\t\tjobId: data.jobId,\n\t\t\terror: result.error,\n\t\t\tindices: result.indices,\n\t\t\tvertices: result.vertices,\n\t\t\tattributes: result.attributes\n\t\t}, [result.indices, result.vertices].filter(t => t != null));\n\t};\n\tconst workQueue = [];\n\tself.onmessage = message => {\n\t\tconst data = message.data;\n\t\tswitch (data.type) {\n\t\t\tcase 'init':\n\t\t\t\tself.DracoDecoderModule({\n\t\t\t\t\tinstantiateWasm: (imports, successCallback) => {\n\t\t\t\t\t\tWebAssembly.instantiate(data.module, imports).then(result => successCallback(result)).catch(reason => console.error('instantiate failed + ' + reason));\n\t\t\t\t\t\treturn {};\n\t\t\t\t\t}\n\t\t\t\t}).then(instance => {\n\t\t\t\t\tdraco = instance;\n\t\t\t\t\tworkQueue.forEach(data => decode(data));\n\t\t\t\t});\n\t\t\t\tbreak;\n\t\t\tcase 'decodeMesh':\n\t\t\t\tif (draco) {\n\t\t\t\t\tdecode(data);\n\t\t\t\t} else {\n\t\t\t\t\tworkQueue.push(data);\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t}\n\t};\n}\n\nexport { DracoWorker };\n", "import { WasmModule } from '../../core/wasm-module.js';\nimport { DracoWorker } from './draco-worker.js';\nimport { http } from '../../platform/net/http.js';\n\nconst downloadMaxRetries = 3;\nclass JobQueue {\n\tconstructor() {\n\t\tthis.workers = [[], [], []];\n\t\tthis.jobId = 0;\n\t\tthis.jobQueue = [];\n\t\tthis.jobCallbacks = new Map();\n\t\tthis.run = (worker, job) => {\n\t\t\tworker.postMessage({\n\t\t\t\ttype: 'decodeMesh',\n\t\t\t\tjobId: job.jobId,\n\t\t\t\tbuffer: job.buffer\n\t\t\t}, [job.buffer]);\n\t\t};\n\t}\n\tinit(workers) {\n\t\tworkers.forEach(worker => {\n\t\t\tworker.addEventListener('message', message => {\n\t\t\t\tconst data = message.data;\n\t\t\t\tconst callback = this.jobCallbacks.get(data.jobId);\n\t\t\t\tif (callback) {\n\t\t\t\t\tcallback(data.error, {\n\t\t\t\t\t\tindices: data.indices,\n\t\t\t\t\t\tvertices: data.vertices,\n\t\t\t\t\t\tattributes: data.attributes\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t\tthis.jobCallbacks.delete(data.jobId);\n\t\t\t\tif (this.jobQueue.length > 0) {\n\t\t\t\t\tconst job = this.jobQueue.shift();\n\t\t\t\t\tthis.run(worker, job);\n\t\t\t\t} else {\n\t\t\t\t\tconst index2 = this.workers[2].indexOf(worker);\n\t\t\t\t\tif (index2 !== -1) {\n\t\t\t\t\t\tthis.workers[2].splice(index2, 1);\n\t\t\t\t\t\tthis.workers[1].push(worker);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tconst index1 = this.workers[1].indexOf(worker);\n\t\t\t\t\t\tif (index1 !== -1) {\n\t\t\t\t\t\t\tthis.workers[1].splice(index1, 1);\n\t\t\t\t\t\t\tthis.workers[0].push(worker);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t});\n\t\t});\n\t\tthis.workers[0] = workers;\n\t\twhile (this.jobQueue.length && (this.workers[0].length || this.workers[1].length)) {\n\t\t\tconst job = this.jobQueue.shift();\n\t\t\tif (this.workers[0].length > 0) {\n\t\t\t\tconst worker = this.workers[0].shift();\n\t\t\t\tthis.workers[1].push(worker);\n\t\t\t\tthis.run(worker, job);\n\t\t\t} else {\n\t\t\t\tconst worker = this.workers[1].shift();\n\t\t\t\tthis.workers[2].push(worker);\n\t\t\t\tthis.run(worker, job);\n\t\t\t}\n\t\t}\n\t}\n\tenqueueJob(buffer, callback) {\n\t\tconst job = {\n\t\t\tjobId: this.jobId++,\n\t\t\tbuffer: buffer\n\t\t};\n\t\tthis.jobCallbacks.set(job.jobId, callback);\n\t\tif (this.workers[0].length > 0) {\n\t\t\tconst worker = this.workers[0].shift();\n\t\t\tthis.workers[1].push(worker);\n\t\t\tthis.run(worker, job);\n\t\t} else if (this.workers[1].length > 0) {\n\t\t\tconst worker = this.workers[1].shift();\n\t\t\tthis.workers[2].push(worker);\n\t\t\tthis.run(worker, job);\n\t\t} else {\n\t\t\tthis.jobQueue.push(job);\n\t\t}\n\t}\n}\nconst downloadScript = url => {\n\treturn new Promise((resolve, reject) => {\n\t\tconst options = {\n\t\t\tcache: true,\n\t\t\tresponseType: 'text',\n\t\t\tretry: downloadMaxRetries > 0,\n\t\t\tmaxRetries: downloadMaxRetries\n\t\t};\n\t\thttp.get(url, options, (err, response) => {\n\t\t\tif (err) {\n\t\t\t\treject(err);\n\t\t\t} else {\n\t\t\t\tresolve(response);\n\t\t\t}\n\t\t});\n\t});\n};\nconst compileModule = url => {\n\tconst compileManual = () => {\n\t\treturn fetch(url).then(result => result.arrayBuffer()).then(buffer => WebAssembly.compile(buffer));\n\t};\n\tconst compileStreaming = () => {\n\t\treturn WebAssembly.compileStreaming(fetch(url)).catch(err => {\n\t\t\treturn compileManual();\n\t\t});\n\t};\n\treturn WebAssembly.compileStreaming ? compileStreaming() : compileManual();\n};\nconst defaultNumWorkers = 1;\nlet jobQueue;\nlet lazyConfig;\nconst initializeWorkers = config => {\n\tif (jobQueue) {\n\t\treturn true;\n\t}\n\tif (!config) {\n\t\tif (lazyConfig) {\n\t\t\tconfig = lazyConfig;\n\t\t} else {\n\t\t\tconst moduleConfig = WasmModule.getConfig('DracoDecoderModule');\n\t\t\tif (moduleConfig) {\n\t\t\t\tconfig = {\n\t\t\t\t\tjsUrl: moduleConfig.glueUrl,\n\t\t\t\t\twasmUrl: moduleConfig.wasmUrl,\n\t\t\t\t\tnumWorkers: moduleConfig.numWorkers\n\t\t\t\t};\n\t\t\t} else {\n\t\t\t\tconfig = {\n\t\t\t\t\tjsUrl: 'draco.wasm.js',\n\t\t\t\t\twasmUrl: 'draco.wasm.wasm',\n\t\t\t\t\tnumWorkers: defaultNumWorkers\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\t}\n\tif (!config.jsUrl || !config.wasmUrl) {\n\t\treturn false;\n\t}\n\tjobQueue = new JobQueue();\n\tPromise.all([downloadScript(config.jsUrl), compileModule(config.wasmUrl)]).then(([dracoSource, dracoModule]) => {\n\t\tconst code = ['/* draco */', dracoSource, '/* worker */', `(\\n${DracoWorker.toString()}\\n)()\\n\\n`].join('\\n');\n\t\tconst blob = new Blob([code], {\n\t\t\ttype: 'application/javascript'\n\t\t});\n\t\tconst workerUrl = URL.createObjectURL(blob);\n\t\tconst numWorkers = Math.max(1, Math.min(16, config.numWorkers || defaultNumWorkers));\n\t\tconst workers = [];\n\t\tfor (let i = 0; i < numWorkers; ++i) {\n\t\t\tconst worker = new Worker(workerUrl);\n\t\t\tworker.postMessage({\n\t\t\t\ttype: 'init',\n\t\t\t\tmodule: dracoModule\n\t\t\t});\n\t\t\tworkers.push(worker);\n\t\t}\n\t\tjobQueue.init(workers);\n\t});\n\treturn true;\n};\nconst dracoInitialize = config => {\n\tif (config != null && config.lazyInit) {\n\t\tlazyConfig = config;\n\t} else {\n\t\tinitializeWorkers(config);\n\t}\n};\nconst dracoDecode = (buffer, callback) => {\n\tif (!initializeWorkers()) {\n\t\treturn false;\n\t}\n\tjobQueue.enqueueJob(buffer, callback);\n\treturn true;\n};\n\nexport { dracoDecode, dracoInitialize };\n", "import { path } from '../../core/path.js';\nimport { Color } from '../../core/math/color.js';\nimport { Mat4 } from '../../core/math/mat4.js';\nimport { math } from '../../core/math/math.js';\nimport { Vec2 } from '../../core/math/vec2.js';\nimport { Vec3 } from '../../core/math/vec3.js';\nimport { BoundingBox } from '../../core/shape/bounding-box.js';\nimport { CULLFACE_NONE, CULLFACE_BACK, INDEXFORMAT_UINT32, INDEXFORMAT_UINT16, INDEXFORMAT_UINT8, BUFFER_STATIC, FILTER_LINEAR_MIPMAP_LINEAR, FILTER_NEAREST_MIPMAP_LINEAR, FILTER_LINEAR_MIPMAP_NEAREST, FILTER_NEAREST_MIPMAP_NEAREST, FILTER_LINEAR, FILTER_NEAREST, ADDRESS_REPEAT, ADDRESS_MIRRORED_REPEAT, ADDRESS_CLAMP_TO_EDGE, PRIMITIVE_TRIANGLES, PRIMITIVE_TRIFAN, PRIMITIVE_TRISTRIP, PRIMITIVE_LINESTRIP, PRIMITIVE_LINELOOP, PRIMITIVE_LINES, PRIMITIVE_POINTS, SEMANTIC_NORMAL, SEMANTIC_COLOR, TYPE_UINT8, TYPE_UINT16, TYPE_FLOAT32, TYPE_UINT32, TYPE_INT32, TYPE_INT16, TYPE_INT8, SEMANTIC_POSITION, SEMANTIC_TANGENT, SEMANTIC_BLENDINDICES, SEMANTIC_BLENDWEIGHT, SEMANTIC_TEXCOORD0, SEMANTIC_TEXCOORD1, SEMANTIC_TEXCOORD2, SEMANTIC_TEXCOORD3, SEMANTIC_TEXCOORD4, SEMANTIC_TEXCOORD5, SEMANTIC_TEXCOORD6, SEMANTIC_TEXCOORD7, typedArrayTypesByteSize, typedArrayTypes } from '../../platform/graphics/constants.js';\nimport { IndexBuffer } from '../../platform/graphics/index-buffer.js';\nimport { Texture } from '../../platform/graphics/texture.js';\nimport { VertexBuffer } from '../../platform/graphics/vertex-buffer.js';\nimport { VertexFormat } from '../../platform/graphics/vertex-format.js';\nimport { http } from '../../platform/net/http.js';\nimport { SPECOCC_AO, BLEND_NONE, BLEND_NORMAL, PROJECTION_ORTHOGRAPHIC, PROJECTION_PERSPECTIVE, ASPECT_AUTO, LIGHTFALLOFF_INVERSESQUARED, ASPECT_MANUAL } from '../../scene/constants.js';\nimport { GraphNode } from '../../scene/graph-node.js';\nimport { Light, lightTypes } from '../../scene/light.js';\nimport { Mesh } from '../../scene/mesh.js';\nimport { Morph } from '../../scene/morph.js';\nimport { MorphTarget } from '../../scene/morph-target.js';\nimport { calculateNormals } from '../../scene/geometry/geometry-utils.js';\nimport { Render } from '../../scene/render.js';\nimport { Skin } from '../../scene/skin.js';\nimport { StandardMaterial } from '../../scene/materials/standard-material.js';\nimport { Entity } from '../entity.js';\nimport { INTERPOLATION_LINEAR, INTERPOLATION_CUBIC, INTERPOLATION_STEP } from '../anim/constants.js';\nimport { AnimCurve } from '../anim/evaluator/anim-curve.js';\nimport { AnimData } from '../anim/evaluator/anim-data.js';\nimport { AnimTrack } from '../anim/evaluator/anim-track.js';\nimport { Asset } from '../asset/asset.js';\nimport { ABSOLUTE_URL } from '../asset/constants.js';\nimport { dracoDecode } from './draco-decoder.js';\n\nclass GlbResources {\n\tconstructor() {\n\t\tthis.gltf = void 0;\n\t\tthis.nodes = void 0;\n\t\tthis.scenes = void 0;\n\t\tthis.animations = void 0;\n\t\tthis.textures = void 0;\n\t\tthis.materials = void 0;\n\t\tthis.variants = void 0;\n\t\tthis.meshVariants = void 0;\n\t\tthis.meshDefaultMaterials = void 0;\n\t\tthis.renders = void 0;\n\t\tthis.skins = void 0;\n\t\tthis.lights = void 0;\n\t\tthis.cameras = void 0;\n\t}\n\tdestroy() {\n\t\tif (this.renders) {\n\t\t\tthis.renders.forEach(render => {\n\t\t\t\trender.meshes = null;\n\t\t\t});\n\t\t}\n\t}\n}\nconst isDataURI = uri => {\n\treturn /^data:.*,.*$/i.test(uri);\n};\nconst getDataURIMimeType = uri => {\n\treturn uri.substring(uri.indexOf(':') + 1, uri.indexOf(';'));\n};\nconst getNumComponents = accessorType => {\n\tswitch (accessorType) {\n\t\tcase 'SCALAR':\n\t\t\treturn 1;\n\t\tcase 'VEC2':\n\t\t\treturn 2;\n\t\tcase 'VEC3':\n\t\t\treturn 3;\n\t\tcase 'VEC4':\n\t\t\treturn 4;\n\t\tcase 'MAT2':\n\t\t\treturn 4;\n\t\tcase 'MAT3':\n\t\t\treturn 9;\n\t\tcase 'MAT4':\n\t\t\treturn 16;\n\t\tdefault:\n\t\t\treturn 3;\n\t}\n};\nconst getComponentType = componentType => {\n\tswitch (componentType) {\n\t\tcase 5120:\n\t\t\treturn TYPE_INT8;\n\t\tcase 5121:\n\t\t\treturn TYPE_UINT8;\n\t\tcase 5122:\n\t\t\treturn TYPE_INT16;\n\t\tcase 5123:\n\t\t\treturn TYPE_UINT16;\n\t\tcase 5124:\n\t\t\treturn TYPE_INT32;\n\t\tcase 5125:\n\t\t\treturn TYPE_UINT32;\n\t\tcase 5126:\n\t\t\treturn TYPE_FLOAT32;\n\t\tdefault:\n\t\t\treturn 0;\n\t}\n};\nconst getComponentSizeInBytes = componentType => {\n\tswitch (componentType) {\n\t\tcase 5120:\n\t\t\treturn 1;\n\t\tcase 5121:\n\t\t\treturn 1;\n\t\tcase 5122:\n\t\t\treturn 2;\n\t\tcase 5123:\n\t\t\treturn 2;\n\t\tcase 5124:\n\t\t\treturn 4;\n\t\tcase 5125:\n\t\t\treturn 4;\n\t\tcase 5126:\n\t\t\treturn 4;\n\t\tdefault:\n\t\t\treturn 0;\n\t}\n};\nconst getComponentDataType = componentType => {\n\tswitch (componentType) {\n\t\tcase 5120:\n\t\t\treturn Int8Array;\n\t\tcase 5121:\n\t\t\treturn Uint8Array;\n\t\tcase 5122:\n\t\t\treturn Int16Array;\n\t\tcase 5123:\n\t\t\treturn Uint16Array;\n\t\tcase 5124:\n\t\t\treturn Int32Array;\n\t\tcase 5125:\n\t\t\treturn Uint32Array;\n\t\tcase 5126:\n\t\t\treturn Float32Array;\n\t\tdefault:\n\t\t\treturn null;\n\t}\n};\nconst gltfToEngineSemanticMap = {\n\t'POSITION': SEMANTIC_POSITION,\n\t'NORMAL': SEMANTIC_NORMAL,\n\t'TANGENT': SEMANTIC_TANGENT,\n\t'COLOR_0': SEMANTIC_COLOR,\n\t'JOINTS_0': SEMANTIC_BLENDINDICES,\n\t'WEIGHTS_0': SEMANTIC_BLENDWEIGHT,\n\t'TEXCOORD_0': SEMANTIC_TEXCOORD0,\n\t'TEXCOORD_1': SEMANTIC_TEXCOORD1,\n\t'TEXCOORD_2': SEMANTIC_TEXCOORD2,\n\t'TEXCOORD_3': SEMANTIC_TEXCOORD3,\n\t'TEXCOORD_4': SEMANTIC_TEXCOORD4,\n\t'TEXCOORD_5': SEMANTIC_TEXCOORD5,\n\t'TEXCOORD_6': SEMANTIC_TEXCOORD6,\n\t'TEXCOORD_7': SEMANTIC_TEXCOORD7\n};\nconst attributeOrder = {\n\t[SEMANTIC_POSITION]: 0,\n\t[SEMANTIC_NORMAL]: 1,\n\t[SEMANTIC_TANGENT]: 2,\n\t[SEMANTIC_COLOR]: 3,\n\t[SEMANTIC_BLENDINDICES]: 4,\n\t[SEMANTIC_BLENDWEIGHT]: 5,\n\t[SEMANTIC_TEXCOORD0]: 6,\n\t[SEMANTIC_TEXCOORD1]: 7,\n\t[SEMANTIC_TEXCOORD2]: 8,\n\t[SEMANTIC_TEXCOORD3]: 9,\n\t[SEMANTIC_TEXCOORD4]: 10,\n\t[SEMANTIC_TEXCOORD5]: 11,\n\t[SEMANTIC_TEXCOORD6]: 12,\n\t[SEMANTIC_TEXCOORD7]: 13\n};\nconst getDequantizeFunc = srcType => {\n\tswitch (srcType) {\n\t\tcase TYPE_INT8:\n\t\t\treturn x => Math.max(x / 127.0, -1.0);\n\t\tcase TYPE_UINT8:\n\t\t\treturn x => x / 255.0;\n\t\tcase TYPE_INT16:\n\t\t\treturn x => Math.max(x / 32767.0, -1.0);\n\t\tcase TYPE_UINT16:\n\t\t\treturn x => x / 65535.0;\n\t\tdefault:\n\t\t\treturn x => x;\n\t}\n};\nconst dequantizeArray = (dstArray, srcArray, srcType) => {\n\tconst convFunc = getDequantizeFunc(srcType);\n\tconst len = srcArray.length;\n\tfor (let i = 0; i < len; ++i) {\n\t\tdstArray[i] = convFunc(srcArray[i]);\n\t}\n\treturn dstArray;\n};\nconst getAccessorData = (gltfAccessor, bufferViews, flatten = false) => {\n\tconst numComponents = getNumComponents(gltfAccessor.type);\n\tconst dataType = getComponentDataType(gltfAccessor.componentType);\n\tif (!dataType) {\n\t\treturn null;\n\t}\n\tlet result;\n\tif (gltfAccessor.sparse) {\n\t\tconst sparse = gltfAccessor.sparse;\n\t\tconst indicesAccessor = {\n\t\t\tcount: sparse.count,\n\t\t\ttype: 'SCALAR'\n\t\t};\n\t\tconst indices = getAccessorData(Object.assign(indicesAccessor, sparse.indices), bufferViews, true);\n\t\tconst valuesAccessor = {\n\t\t\tcount: sparse.count,\n\t\t\ttype: gltfAccessor.type,\n\t\t\tcomponentType: gltfAccessor.componentType\n\t\t};\n\t\tconst values = getAccessorData(Object.assign(valuesAccessor, sparse.values), bufferViews, true);\n\t\tif (gltfAccessor.hasOwnProperty('bufferView')) {\n\t\t\tconst baseAccessor = {\n\t\t\t\tbufferView: gltfAccessor.bufferView,\n\t\t\t\tbyteOffset: gltfAccessor.byteOffset,\n\t\t\t\tcomponentType: gltfAccessor.componentType,\n\t\t\t\tcount: gltfAccessor.count,\n\t\t\t\ttype: gltfAccessor.type\n\t\t\t};\n\t\t\tresult = getAccessorData(baseAccessor, bufferViews, true).slice();\n\t\t} else {\n\t\t\tresult = new dataType(gltfAccessor.count * numComponents);\n\t\t}\n\t\tfor (let i = 0; i < sparse.count; ++i) {\n\t\t\tconst targetIndex = indices[i];\n\t\t\tfor (let j = 0; j < numComponents; ++j) {\n\t\t\t\tresult[targetIndex * numComponents + j] = values[i * numComponents + j];\n\t\t\t}\n\t\t}\n\t} else {\n\t\tif (gltfAccessor.hasOwnProperty(\"bufferView\")) {\n\t\t\tconst bufferView = bufferViews[gltfAccessor.bufferView];\n\t\t\tif (flatten && bufferView.hasOwnProperty('byteStride')) {\n\t\t\t\tconst bytesPerElement = numComponents * dataType.BYTES_PER_ELEMENT;\n\t\t\t\tconst storage = new ArrayBuffer(gltfAccessor.count * bytesPerElement);\n\t\t\t\tconst tmpArray = new Uint8Array(storage);\n\t\t\t\tlet dstOffset = 0;\n\t\t\t\tfor (let i = 0; i < gltfAccessor.count; ++i) {\n\t\t\t\t\tlet srcOffset = (gltfAccessor.byteOffset || 0) + i * bufferView.byteStride;\n\t\t\t\t\tfor (let b = 0; b < bytesPerElement; ++b) {\n\t\t\t\t\t\ttmpArray[dstOffset++] = bufferView[srcOffset++];\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tresult = new dataType(storage);\n\t\t\t} else {\n\t\t\t\tresult = new dataType(bufferView.buffer, bufferView.byteOffset + (gltfAccessor.byteOffset || 0), gltfAccessor.count * numComponents);\n\t\t\t}\n\t\t} else {\n\t\t\tresult = new dataType(gltfAccessor.count * numComponents);\n\t\t}\n\t}\n\treturn result;\n};\nconst getAccessorDataFloat32 = (gltfAccessor, bufferViews) => {\n\tconst data = getAccessorData(gltfAccessor, bufferViews, true);\n\tif (data instanceof Float32Array || !gltfAccessor.normalized) {\n\t\treturn data;\n\t}\n\tconst float32Data = new Float32Array(data.length);\n\tdequantizeArray(float32Data, data, getComponentType(gltfAccessor.componentType));\n\treturn float32Data;\n};\nconst getAccessorBoundingBox = gltfAccessor => {\n\tlet min = gltfAccessor.min;\n\tlet max = gltfAccessor.max;\n\tif (!min || !max) {\n\t\treturn null;\n\t}\n\tif (gltfAccessor.normalized) {\n\t\tconst ctype = getComponentType(gltfAccessor.componentType);\n\t\tmin = dequantizeArray([], min, ctype);\n\t\tmax = dequantizeArray([], max, ctype);\n\t}\n\treturn new BoundingBox(new Vec3((max[0] + min[0]) * 0.5, (max[1] + min[1]) * 0.5, (max[2] + min[2]) * 0.5), new Vec3((max[0] - min[0]) * 0.5, (max[1] - min[1]) * 0.5, (max[2] - min[2]) * 0.5));\n};\nconst getPrimitiveType = primitive => {\n\tif (!primitive.hasOwnProperty('mode')) {\n\t\treturn PRIMITIVE_TRIANGLES;\n\t}\n\tswitch (primitive.mode) {\n\t\tcase 0:\n\t\t\treturn PRIMITIVE_POINTS;\n\t\tcase 1:\n\t\t\treturn PRIMITIVE_LINES;\n\t\tcase 2:\n\t\t\treturn PRIMITIVE_LINELOOP;\n\t\tcase 3:\n\t\t\treturn PRIMITIVE_LINESTRIP;\n\t\tcase 4:\n\t\t\treturn PRIMITIVE_TRIANGLES;\n\t\tcase 5:\n\t\t\treturn PRIMITIVE_TRISTRIP;\n\t\tcase 6:\n\t\t\treturn PRIMITIVE_TRIFAN;\n\t\tdefault:\n\t\t\treturn PRIMITIVE_TRIANGLES;\n\t}\n};\nconst generateIndices = numVertices => {\n\tconst dummyIndices = new Uint16Array(numVertices);\n\tfor (let i = 0; i < numVertices; i++) {\n\t\tdummyIndices[i] = i;\n\t}\n\treturn dummyIndices;\n};\nconst generateNormals = (sourceDesc, indices) => {\n\tconst p = sourceDesc[SEMANTIC_POSITION];\n\tif (!p || p.components !== 3) {\n\t\treturn;\n\t}\n\tlet positions;\n\tif (p.size !== p.stride) {\n\t\tconst srcStride = p.stride / typedArrayTypesByteSize[p.type];\n\t\tconst src = new typedArrayTypes[p.type](p.buffer, p.offset, p.count * srcStride);\n\t\tpositions = new typedArrayTypes[p.type](p.count * 3);\n\t\tfor (let i = 0; i < p.count; ++i) {\n\t\t\tpositions[i * 3 + 0] = src[i * srcStride + 0];\n\t\t\tpositions[i * 3 + 1] = src[i * srcStride + 1];\n\t\t\tpositions[i * 3 + 2] = src[i * srcStride + 2];\n\t\t}\n\t} else {\n\t\tpositions = new typedArrayTypes[p.type](p.buffer, p.offset, p.count * 3);\n\t}\n\tconst numVertices = p.count;\n\tif (!indices) {\n\t\tindices = generateIndices(numVertices);\n\t}\n\tconst normalsTemp = calculateNormals(positions, indices);\n\tconst normals = new Float32Array(normalsTemp.length);\n\tnormals.set(normalsTemp);\n\tsourceDesc[SEMANTIC_NORMAL] = {\n\t\tbuffer: normals.buffer,\n\t\tsize: 12,\n\t\toffset: 0,\n\t\tstride: 12,\n\t\tcount: numVertices,\n\t\tcomponents: 3,\n\t\ttype: TYPE_FLOAT32\n\t};\n};\nconst flipTexCoordVs = vertexBuffer => {\n\tlet i, j;\n\tconst floatOffsets = [];\n\tconst shortOffsets = [];\n\tconst byteOffsets = [];\n\tfor (i = 0; i < vertexBuffer.format.elements.length; ++i) {\n\t\tconst element = vertexBuffer.format.elements[i];\n\t\tif (element.name === SEMANTIC_TEXCOORD0 || element.name === SEMANTIC_TEXCOORD1) {\n\t\t\tswitch (element.dataType) {\n\t\t\t\tcase TYPE_FLOAT32:\n\t\t\t\t\tfloatOffsets.push({\n\t\t\t\t\t\toffset: element.offset / 4 + 1,\n\t\t\t\t\t\tstride: element.stride / 4\n\t\t\t\t\t});\n\t\t\t\t\tbreak;\n\t\t\t\tcase TYPE_UINT16:\n\t\t\t\t\tshortOffsets.push({\n\t\t\t\t\t\toffset: element.offset / 2 + 1,\n\t\t\t\t\t\tstride: element.stride / 2\n\t\t\t\t\t});\n\t\t\t\t\tbreak;\n\t\t\t\tcase TYPE_UINT8:\n\t\t\t\t\tbyteOffsets.push({\n\t\t\t\t\t\toffset: element.offset + 1,\n\t\t\t\t\t\tstride: element.stride\n\t\t\t\t\t});\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n\tconst flip = (offsets, type, one) => {\n\t\tconst typedArray = new type(vertexBuffer.storage);\n\t\tfor (i = 0; i < offsets.length; ++i) {\n\t\t\tlet index = offsets[i].offset;\n\t\t\tconst stride = offsets[i].stride;\n\t\t\tfor (j = 0; j < vertexBuffer.numVertices; ++j) {\n\t\t\t\ttypedArray[index] = one - typedArray[index];\n\t\t\t\tindex += stride;\n\t\t\t}\n\t\t}\n\t};\n\tif (floatOffsets.length > 0) {\n\t\tflip(floatOffsets, Float32Array, 1.0);\n\t}\n\tif (shortOffsets.length > 0) {\n\t\tflip(shortOffsets, Uint16Array, 65535);\n\t}\n\tif (byteOffsets.length > 0) {\n\t\tflip(byteOffsets, Uint8Array, 255);\n\t}\n};\nconst cloneTexture = texture => {\n\tconst shallowCopyLevels = texture => {\n\t\tconst result = [];\n\t\tfor (let mip = 0; mip < texture._levels.length; ++mip) {\n\t\t\tlet level = [];\n\t\t\tif (texture.cubemap) {\n\t\t\t\tfor (let face = 0; face < 6; ++face) {\n\t\t\t\t\tlevel.push(texture._levels[mip][face]);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tlevel = texture._levels[mip];\n\t\t\t}\n\t\t\tresult.push(level);\n\t\t}\n\t\treturn result;\n\t};\n\tconst result = new Texture(texture.device, texture);\n\tresult._levels = shallowCopyLevels(texture);\n\treturn result;\n};\nconst cloneTextureAsset = src => {\n\tconst result = new Asset(src.name + '_clone', src.type, src.file, src.data, src.options);\n\tresult.loaded = true;\n\tresult.resource = cloneTexture(src.resource);\n\tsrc.registry.add(result);\n\treturn result;\n};\nconst createVertexBufferInternal = (device, sourceDesc, flipV) => {\n\tconst positionDesc = sourceDesc[SEMANTIC_POSITION];\n\tif (!positionDesc) {\n\t\treturn null;\n\t}\n\tconst numVertices = positionDesc.count;\n\tconst vertexDesc = [];\n\tfor (const semantic in sourceDesc) {\n\t\tif (sourceDesc.hasOwnProperty(semantic)) {\n\t\t\tconst element = {\n\t\t\t\tsemantic: semantic,\n\t\t\t\tcomponents: sourceDesc[semantic].components,\n\t\t\t\ttype: sourceDesc[semantic].type,\n\t\t\t\tnormalize: !!sourceDesc[semantic].normalize\n\t\t\t};\n\t\t\tif (!VertexFormat.isElementValid(device, element)) {\n\t\t\t\telement.components++;\n\t\t\t}\n\t\t\tvertexDesc.push(element);\n\t\t}\n\t}\n\tvertexDesc.sort((lhs, rhs) => {\n\t\treturn attributeOrder[lhs.semantic] - attributeOrder[rhs.semantic];\n\t});\n\tlet i, j, k;\n\tlet source, target, sourceOffset;\n\tconst vertexFormat = new VertexFormat(device, vertexDesc);\n\tlet isCorrectlyInterleaved = true;\n\tfor (i = 0; i < vertexFormat.elements.length; ++i) {\n\t\ttarget = vertexFormat.elements[i];\n\t\tsource = sourceDesc[target.name];\n\t\tsourceOffset = source.offset - positionDesc.offset;\n\t\tif (source.buffer !== positionDesc.buffer || source.stride !== target.stride || source.size !== target.size || sourceOffset !== target.offset) {\n\t\t\tisCorrectlyInterleaved = false;\n\t\t\tbreak;\n\t\t}\n\t}\n\tconst vertexBuffer = new VertexBuffer(device, vertexFormat, numVertices);\n\tconst vertexData = vertexBuffer.lock();\n\tconst targetArray = new Uint32Array(vertexData);\n\tlet sourceArray;\n\tif (isCorrectlyInterleaved) {\n\t\tsourceArray = new Uint32Array(positionDesc.buffer, positionDesc.offset, numVertices * vertexBuffer.format.size / 4);\n\t\ttargetArray.set(sourceArray);\n\t} else {\n\t\tlet targetStride, sourceStride;\n\t\tfor (i = 0; i < vertexBuffer.format.elements.length; ++i) {\n\t\t\ttarget = vertexBuffer.format.elements[i];\n\t\t\ttargetStride = target.stride / 4;\n\t\t\tsource = sourceDesc[target.name];\n\t\t\tsourceStride = source.stride / 4;\n\t\t\tsourceArray = new Uint32Array(source.buffer, source.offset, (source.count - 1) * sourceStride + (source.size + 3) / 4);\n\t\t\tlet src = 0;\n\t\t\tlet dst = target.offset / 4;\n\t\t\tconst kend = Math.floor((source.size + 3) / 4);\n\t\t\tfor (j = 0; j < numVertices; ++j) {\n\t\t\t\tfor (k = 0; k < kend; ++k) {\n\t\t\t\t\ttargetArray[dst + k] = sourceArray[src + k];\n\t\t\t\t}\n\t\t\t\tsrc += sourceStride;\n\t\t\t\tdst += targetStride;\n\t\t\t}\n\t\t}\n\t}\n\tif (flipV) {\n\t\tflipTexCoordVs(vertexBuffer);\n\t}\n\tvertexBuffer.unlock();\n\treturn vertexBuffer;\n};\nconst createVertexBuffer = (device, attributes, indices, accessors, bufferViews, flipV, vertexBufferDict) => {\n\tconst useAttributes = {};\n\tconst attribIds = [];\n\tfor (const attrib in attributes) {\n\t\tif (attributes.hasOwnProperty(attrib) && gltfToEngineSemanticMap.hasOwnProperty(attrib)) {\n\t\t\tuseAttributes[attrib] = attributes[attrib];\n\t\t\tattribIds.push(attrib + ':' + attributes[attrib]);\n\t\t}\n\t}\n\tattribIds.sort();\n\tconst vbKey = attribIds.join();\n\tlet vb = vertexBufferDict[vbKey];\n\tif (!vb) {\n\t\tconst sourceDesc = {};\n\t\tfor (const attrib in useAttributes) {\n\t\t\tconst accessor = accessors[attributes[attrib]];\n\t\t\tconst accessorData = getAccessorData(accessor, bufferViews);\n\t\t\tconst bufferView = bufferViews[accessor.bufferView];\n\t\t\tconst semantic = gltfToEngineSemanticMap[attrib];\n\t\t\tconst size = getNumComponents(accessor.type) * getComponentSizeInBytes(accessor.componentType);\n\t\t\tconst stride = bufferView && bufferView.hasOwnProperty('byteStride') ? bufferView.byteStride : size;\n\t\t\tsourceDesc[semantic] = {\n\t\t\t\tbuffer: accessorData.buffer,\n\t\t\t\tsize: size,\n\t\t\t\toffset: accessorData.byteOffset,\n\t\t\t\tstride: stride,\n\t\t\t\tcount: accessor.count,\n\t\t\t\tcomponents: getNumComponents(accessor.type),\n\t\t\t\ttype: getComponentType(accessor.componentType),\n\t\t\t\tnormalize: accessor.normalized\n\t\t\t};\n\t\t}\n\t\tif (!sourceDesc.hasOwnProperty(SEMANTIC_NORMAL)) {\n\t\t\tgenerateNormals(sourceDesc, indices);\n\t\t}\n\t\tvb = createVertexBufferInternal(device, sourceDesc, flipV);\n\t\tvertexBufferDict[vbKey] = vb;\n\t}\n\treturn vb;\n};\nconst createSkin = (device, gltfSkin, accessors, bufferViews, nodes, glbSkins) => {\n\tlet i, j, bindMatrix;\n\tconst joints = gltfSkin.joints;\n\tconst numJoints = joints.length;\n\tconst ibp = [];\n\tif (gltfSkin.hasOwnProperty('inverseBindMatrices')) {\n\t\tconst inverseBindMatrices = gltfSkin.inverseBindMatrices;\n\t\tconst ibmData = getAccessorData(accessors[inverseBindMatrices], bufferViews, true);\n\t\tconst ibmValues = [];\n\t\tfor (i = 0; i < numJoints; i++) {\n\t\t\tfor (j = 0; j < 16; j++) {\n\t\t\t\tibmValues[j] = ibmData[i * 16 + j];\n\t\t\t}\n\t\t\tbindMatrix = new Mat4();\n\t\t\tbindMatrix.set(ibmValues);\n\t\t\tibp.push(bindMatrix);\n\t\t}\n\t} else {\n\t\tfor (i = 0; i < numJoints; i++) {\n\t\t\tbindMatrix = new Mat4();\n\t\t\tibp.push(bindMatrix);\n\t\t}\n\t}\n\tconst boneNames = [];\n\tfor (i = 0; i < numJoints; i++) {\n\t\tboneNames[i] = nodes[joints[i]].name;\n\t}\n\tconst key = boneNames.join('#');\n\tlet skin = glbSkins.get(key);\n\tif (!skin) {\n\t\tskin = new Skin(device, ibp, boneNames);\n\t\tglbSkins.set(key, skin);\n\t}\n\treturn skin;\n};\nconst createDracoMesh = (device, primitive, accessors, bufferViews, meshVariants, meshDefaultMaterials, promises) => {\n\tvar _primitive$extensions;\n\tconst result = new Mesh(device);\n\tresult.aabb = getAccessorBoundingBox(accessors[primitive.attributes.POSITION]);\n\tconst vertexDesc = [];\n\tfor (const [name, index] of Object.entries(primitive.attributes)) {\n\t\tvar _accessor$normalized;\n\t\tconst accessor = accessors[index];\n\t\tconst semantic = gltfToEngineSemanticMap[name];\n\t\tconst componentType = getComponentType(accessor.componentType);\n\t\tvertexDesc.push({\n\t\t\tsemantic: semantic,\n\t\t\tcomponents: getNumComponents(accessor.type),\n\t\t\ttype: componentType,\n\t\t\tnormalize: (_accessor$normalized = accessor.normalized) != null ? _accessor$normalized : semantic === SEMANTIC_COLOR && (componentType === TYPE_UINT8 || componentType === TYPE_UINT16)\n\t\t});\n\t}\n\tpromises.push(new Promise((resolve, reject) => {\n\t\tconst dracoExt = primitive.extensions.KHR_draco_mesh_compression;\n\t\tdracoDecode(bufferViews[dracoExt.bufferView].slice().buffer, (err, decompressedData) => {\n\t\t\tif (err) {\n\t\t\t\tconsole.log(err);\n\t\t\t\treject(err);\n\t\t\t} else {\n\t\t\t\tvar _primitive$attributes;\n\t\t\t\tconst order = {};\n\t\t\t\tfor (const [name, index] of Object.entries(dracoExt.attributes)) {\n\t\t\t\t\torder[gltfToEngineSemanticMap[name]] = decompressedData.attributes.indexOf(index);\n\t\t\t\t}\n\t\t\t\tvertexDesc.sort((a, b) => {\n\t\t\t\t\treturn order[a.semantic] - order[b.semantic];\n\t\t\t\t});\n\t\t\t\tif (!((_primitive$attributes = primitive.attributes) != null && _primitive$attributes.NORMAL)) {\n\t\t\t\t\tvertexDesc.splice(1, 0, {\n\t\t\t\t\t\tsemantic: 'NORMAL',\n\t\t\t\t\t\tcomponents: 3,\n\t\t\t\t\t\ttype: TYPE_FLOAT32\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t\tconst vertexFormat = new VertexFormat(device, vertexDesc);\n\t\t\t\tconst numVertices = decompressedData.vertices.byteLength / vertexFormat.size;\n\t\t\t\tconst indexFormat = numVertices <= 65535 ? INDEXFORMAT_UINT16 : INDEXFORMAT_UINT32;\n\t\t\t\tconst numIndices = decompressedData.indices.byteLength / (numVertices <= 65535 ? 2 : 4);\n\t\t\t\tconst vertexBuffer = new VertexBuffer(device, vertexFormat, numVertices, {\n\t\t\t\t\tdata: decompressedData.vertices\n\t\t\t\t});\n\t\t\t\tconst indexBuffer = new IndexBuffer(device, indexFormat, numIndices, BUFFER_STATIC, decompressedData.indices);\n\t\t\t\tresult.vertexBuffer = vertexBuffer;\n\t\t\t\tresult.indexBuffer[0] = indexBuffer;\n\t\t\t\tresult.primitive[0].type = getPrimitiveType(primitive);\n\t\t\t\tresult.primitive[0].base = 0;\n\t\t\t\tresult.primitive[0].count = indexBuffer ? numIndices : numVertices;\n\t\t\t\tresult.primitive[0].indexed = !!indexBuffer;\n\t\t\t\tresolve();\n\t\t\t}\n\t\t});\n\t}));\n\tif (primitive != null && (_primitive$extensions = primitive.extensions) != null && _primitive$extensions.KHR_materials_variants) {\n\t\tconst variants = primitive.extensions.KHR_materials_variants;\n\t\tconst tempMapping = {};\n\t\tvariants.mappings.forEach(mapping => {\n\t\t\tmapping.variants.forEach(variant => {\n\t\t\t\ttempMapping[variant] = mapping.material;\n\t\t\t});\n\t\t});\n\t\tmeshVariants[result.id] = tempMapping;\n\t}\n\tmeshDefaultMaterials[result.id] = primitive.material;\n\treturn result;\n};\nconst createMesh = (device, gltfMesh, accessors, bufferViews, flipV, vertexBufferDict, meshVariants, meshDefaultMaterials, assetOptions, promises) => {\n\tconst meshes = [];\n\tgltfMesh.primitives.forEach(primitive => {\n\t\tvar _primitive$extensions2;\n\t\tif ((_primitive$extensions2 = primitive.extensions) != null && _primitive$extensions2.KHR_draco_mesh_compression) {\n\t\t\tmeshes.push(createDracoMesh(device, primitive, accessors, bufferViews, meshVariants, meshDefaultMaterials, promises));\n\t\t} else {\n\t\t\tlet indices = primitive.hasOwnProperty('indices') ? getAccessorData(accessors[primitive.indices], bufferViews, true) : null;\n\t\t\tconst vertexBuffer = createVertexBuffer(device, primitive.attributes, indices, accessors, bufferViews, flipV, vertexBufferDict);\n\t\t\tconst primitiveType = getPrimitiveType(primitive);\n\t\t\tconst mesh = new Mesh(device);\n\t\t\tmesh.vertexBuffer = vertexBuffer;\n\t\t\tmesh.primitive[0].type = primitiveType;\n\t\t\tmesh.primitive[0].base = 0;\n\t\t\tmesh.primitive[0].indexed = indices !== null;\n\t\t\tif (indices !== null) {\n\t\t\t\tlet indexFormat;\n\t\t\t\tif (indices instanceof Uint8Array) {\n\t\t\t\t\tindexFormat = INDEXFORMAT_UINT8;\n\t\t\t\t} else if (indices instanceof Uint16Array) {\n\t\t\t\t\tindexFormat = INDEXFORMAT_UINT16;\n\t\t\t\t} else {\n\t\t\t\t\tindexFormat = INDEXFORMAT_UINT32;\n\t\t\t\t}\n\t\t\t\tif (indexFormat === INDEXFORMAT_UINT32 && !device.extUintElement) {\n\t\t\t\t\tindexFormat = INDEXFORMAT_UINT16;\n\t\t\t\t\tindices = new Uint16Array(indices);\n\t\t\t\t}\n\t\t\t\tif (indexFormat === INDEXFORMAT_UINT8 && device.isWebGPU) {\n\t\t\t\t\tindexFormat = INDEXFORMAT_UINT16;\n\t\t\t\t\tindices = new Uint16Array(indices);\n\t\t\t\t}\n\t\t\t\tconst indexBuffer = new IndexBuffer(device, indexFormat, indices.length, BUFFER_STATIC, indices);\n\t\t\t\tmesh.indexBuffer[0] = indexBuffer;\n\t\t\t\tmesh.primitive[0].count = indices.length;\n\t\t\t} else {\n\t\t\t\tmesh.primitive[0].count = vertexBuffer.numVertices;\n\t\t\t}\n\t\t\tif (primitive.hasOwnProperty(\"extensions\") && primitive.extensions.hasOwnProperty(\"KHR_materials_variants\")) {\n\t\t\t\tconst variants = primitive.extensions.KHR_materials_variants;\n\t\t\t\tconst tempMapping = {};\n\t\t\t\tvariants.mappings.forEach(mapping => {\n\t\t\t\t\tmapping.variants.forEach(variant => {\n\t\t\t\t\t\ttempMapping[variant] = mapping.material;\n\t\t\t\t\t});\n\t\t\t\t});\n\t\t\t\tmeshVariants[mesh.id] = tempMapping;\n\t\t\t}\n\t\t\tmeshDefaultMaterials[mesh.id] = primitive.material;\n\t\t\tlet accessor = accessors[primitive.attributes.POSITION];\n\t\t\tmesh.aabb = getAccessorBoundingBox(accessor);\n\t\t\tif (primitive.hasOwnProperty('targets')) {\n\t\t\t\tconst targets = [];\n\t\t\t\tprimitive.targets.forEach((target, index) => {\n\t\t\t\t\tconst options = {};\n\t\t\t\t\tif (target.hasOwnProperty('POSITION')) {\n\t\t\t\t\t\taccessor = accessors[target.POSITION];\n\t\t\t\t\t\toptions.deltaPositions = getAccessorDataFloat32(accessor, bufferViews);\n\t\t\t\t\t\toptions.deltaPositionsType = TYPE_FLOAT32;\n\t\t\t\t\t\toptions.aabb = getAccessorBoundingBox(accessor);\n\t\t\t\t\t}\n\t\t\t\t\tif (target.hasOwnProperty('NORMAL')) {\n\t\t\t\t\t\taccessor = accessors[target.NORMAL];\n\t\t\t\t\t\toptions.deltaNormals = getAccessorDataFloat32(accessor, bufferViews);\n\t\t\t\t\t\toptions.deltaNormalsType = TYPE_FLOAT32;\n\t\t\t\t\t}\n\t\t\t\t\tif (gltfMesh.hasOwnProperty('extras') && gltfMesh.extras.hasOwnProperty('targetNames')) {\n\t\t\t\t\t\toptions.name = gltfMesh.extras.targetNames[index];\n\t\t\t\t\t} else {\n\t\t\t\t\t\toptions.name = index.toString(10);\n\t\t\t\t\t}\n\t\t\t\t\tif (gltfMesh.hasOwnProperty('weights')) {\n\t\t\t\t\t\toptions.defaultWeight = gltfMesh.weights[index];\n\t\t\t\t\t}\n\t\t\t\t\toptions.preserveData = assetOptions.morphPreserveData;\n\t\t\t\t\ttargets.push(new MorphTarget(options));\n\t\t\t\t});\n\t\t\t\tmesh.morph = new Morph(targets, device, {\n\t\t\t\t\tpreferHighPrecision: assetOptions.morphPreferHighPrecision\n\t\t\t\t});\n\t\t\t}\n\t\t\tmeshes.push(mesh);\n\t\t}\n\t});\n\treturn meshes;\n};\nconst extractTextureTransform = (source, material, maps) => {\n\tvar _source$extensions;\n\tlet map;\n\tconst texCoord = source.texCoord;\n\tif (texCoord) {\n\t\tfor (map = 0; map < maps.length; ++map) {\n\t\t\tmaterial[maps[map] + 'MapUv'] = texCoord;\n\t\t}\n\t}\n\tconst zeros = [0, 0];\n\tconst ones = [1, 1];\n\tconst textureTransform = (_source$extensions = source.extensions) == null ? void 0 : _source$extensions.KHR_texture_transform;\n\tif (textureTransform) {\n\t\tconst offset = textureTransform.offset || zeros;\n\t\tconst scale = textureTransform.scale || ones;\n\t\tconst rotation = textureTransform.rotation ? -textureTransform.rotation * math.RAD_TO_DEG : 0;\n\t\tconst tilingVec = new Vec2(scale[0], scale[1]);\n\t\tconst offsetVec = new Vec2(offset[0], 1.0 - scale[1] - offset[1]);\n\t\tfor (map = 0; map < maps.length; ++map) {\n\t\t\tmaterial[`${maps[map]}MapTiling`] = tilingVec;\n\t\t\tmaterial[`${maps[map]}MapOffset`] = offsetVec;\n\t\t\tmaterial[`${maps[map]}MapRotation`] = rotation;\n\t\t}\n\t}\n};\nconst extensionPbrSpecGlossiness = (data, material, textures) => {\n\tlet color, texture;\n\tif (data.hasOwnProperty('diffuseFactor')) {\n\t\tcolor = data.diffuseFactor;\n\t\tmaterial.diffuse.set(Math.pow(color[0], 1 / 2.2), Math.pow(color[1], 1 / 2.2), Math.pow(color[2], 1 / 2.2));\n\t\tmaterial.opacity = color[3];\n\t} else {\n\t\tmaterial.diffuse.set(1, 1, 1);\n\t\tmaterial.opacity = 1;\n\t}\n\tif (data.hasOwnProperty('diffuseTexture')) {\n\t\tconst diffuseTexture = data.diffuseTexture;\n\t\ttexture = textures[diffuseTexture.index];\n\t\tmaterial.diffuseMap = texture;\n\t\tmaterial.diffuseMapChannel = 'rgb';\n\t\tmaterial.opacityMap = texture;\n\t\tmaterial.opacityMapChannel = 'a';\n\t\textractTextureTransform(diffuseTexture, material, ['diffuse', 'opacity']);\n\t}\n\tmaterial.useMetalness = false;\n\tif (data.hasOwnProperty('specularFactor')) {\n\t\tcolor = data.specularFactor;\n\t\tmaterial.specular.set(Math.pow(color[0], 1 / 2.2), Math.pow(color[1], 1 / 2.2), Math.pow(color[2], 1 / 2.2));\n\t} else {\n\t\tmaterial.specular.set(1, 1, 1);\n\t}\n\tif (data.hasOwnProperty('glossinessFactor')) {\n\t\tmaterial.gloss = data.glossinessFactor;\n\t} else {\n\t\tmaterial.gloss = 1.0;\n\t}\n\tif (data.hasOwnProperty('specularGlossinessTexture')) {\n\t\tconst specularGlossinessTexture = data.specularGlossinessTexture;\n\t\tmaterial.specularEncoding = 'srgb';\n\t\tmaterial.specularMap = material.glossMap = textures[specularGlossinessTexture.index];\n\t\tmaterial.specularMapChannel = 'rgb';\n\t\tmaterial.glossMapChannel = 'a';\n\t\textractTextureTransform(specularGlossinessTexture, material, ['gloss', 'metalness']);\n\t}\n};\nconst extensionClearCoat = (data, material, textures) => {\n\tif (data.hasOwnProperty('clearcoatFactor')) {\n\t\tmaterial.clearCoat = data.clearcoatFactor * 0.25;\n\t} else {\n\t\tmaterial.clearCoat = 0;\n\t}\n\tif (data.hasOwnProperty('clearcoatTexture')) {\n\t\tconst clearcoatTexture = data.clearcoatTexture;\n\t\tmaterial.clearCoatMap = textures[clearcoatTexture.index];\n\t\tmaterial.clearCoatMapChannel = 'r';\n\t\textractTextureTransform(clearcoatTexture, material, ['clearCoat']);\n\t}\n\tif (data.hasOwnProperty('clearcoatRoughnessFactor')) {\n\t\tmaterial.clearCoatGloss = data.clearcoatRoughnessFactor;\n\t} else {\n\t\tmaterial.clearCoatGloss = 0;\n\t}\n\tif (data.hasOwnProperty('clearcoatRoughnessTexture')) {\n\t\tconst clearcoatRoughnessTexture = data.clearcoatRoughnessTexture;\n\t\tmaterial.clearCoatGlossMap = textures[clearcoatRoughnessTexture.index];\n\t\tmaterial.clearCoatGlossMapChannel = 'g';\n\t\textractTextureTransform(clearcoatRoughnessTexture, material, ['clearCoatGloss']);\n\t}\n\tif (data.hasOwnProperty('clearcoatNormalTexture')) {\n\t\tconst clearcoatNormalTexture = data.clearcoatNormalTexture;\n\t\tmaterial.clearCoatNormalMap = textures[clearcoatNormalTexture.index];\n\t\textractTextureTransform(clearcoatNormalTexture, material, ['clearCoatNormal']);\n\t\tif (clearcoatNormalTexture.hasOwnProperty('scale')) {\n\t\t\tmaterial.clearCoatBumpiness = clearcoatNormalTexture.scale;\n\t\t}\n\t}\n\tmaterial.clearCoatGlossInvert = true;\n};\nconst extensionUnlit = (data, material, textures) => {\n\tmaterial.useLighting = false;\n\tmaterial.emissive.copy(material.diffuse);\n\tmaterial.emissiveTint = material.diffuseTint;\n\tmaterial.emissiveMap = material.diffuseMap;\n\tmaterial.emissiveMapUv = material.diffuseMapUv;\n\tmaterial.emissiveMapTiling.copy(material.diffuseMapTiling);\n\tmaterial.emissiveMapOffset.copy(material.diffuseMapOffset);\n\tmaterial.emissiveMapRotation = material.diffuseMapRotation;\n\tmaterial.emissiveMapChannel = material.diffuseMapChannel;\n\tmaterial.emissiveVertexColor = material.diffuseVertexColor;\n\tmaterial.emissiveVertexColorChannel = material.diffuseVertexColorChannel;\n\tmaterial.useLighting = false;\n\tmaterial.useSkybox = false;\n\tmaterial.diffuse.set(0, 0, 0);\n\tmaterial.diffuseTint = false;\n\tmaterial.diffuseMap = null;\n\tmaterial.diffuseVertexColor = false;\n};\nconst extensionSpecular = (data, material, textures) => {\n\tmaterial.useMetalnessSpecularColor = true;\n\tif (data.hasOwnProperty('specularColorTexture')) {\n\t\tmaterial.specularEncoding = 'srgb';\n\t\tmaterial.specularMap = textures[data.specularColorTexture.index];\n\t\tmaterial.specularMapChannel = 'rgb';\n\t\textractTextureTransform(data.specularColorTexture, material, ['specular']);\n\t}\n\tif (data.hasOwnProperty('specularColorFactor')) {\n\t\tconst color = data.specularColorFactor;\n\t\tmaterial.specular.set(Math.pow(color[0], 1 / 2.2), Math.pow(color[1], 1 / 2.2), Math.pow(color[2], 1 / 2.2));\n\t} else {\n\t\tmaterial.specular.set(1, 1, 1);\n\t}\n\tif (data.hasOwnProperty('specularFactor')) {\n\t\tmaterial.specularityFactor = data.specularFactor;\n\t} else {\n\t\tmaterial.specularityFactor = 1;\n\t}\n\tif (data.hasOwnProperty('specularTexture')) {\n\t\tmaterial.specularityFactorMapChannel = 'a';\n\t\tmaterial.specularityFactorMap = textures[data.specularTexture.index];\n\t\textractTextureTransform(data.specularTexture, material, ['specularityFactor']);\n\t}\n};\nconst extensionIor = (data, material, textures) => {\n\tif (data.hasOwnProperty('ior')) {\n\t\tmaterial.refractionIndex = 1.0 / data.ior;\n\t}\n};\nconst extensionDispersion = (data, material, textures) => {\n\tif (data.hasOwnProperty('dispersion')) {\n\t\tmaterial.dispersion = data.dispersion;\n\t}\n};\nconst extensionTransmission = (data, material, textures) => {\n\tmaterial.blendType = BLEND_NORMAL;\n\tmaterial.useDynamicRefraction = true;\n\tif (data.hasOwnProperty('transmissionFactor')) {\n\t\tmaterial.refraction = data.transmissionFactor;\n\t}\n\tif (data.hasOwnProperty('transmissionTexture')) {\n\t\tmaterial.refractionMapChannel = 'r';\n\t\tmaterial.refractionMap = textures[data.transmissionTexture.index];\n\t\textractTextureTransform(data.transmissionTexture, material, ['refraction']);\n\t}\n};\nconst extensionSheen = (data, material, textures) => {\n\tmaterial.useSheen = true;\n\tif (data.hasOwnProperty('sheenColorFactor')) {\n\t\tconst color = data.sheenColorFactor;\n\t\tmaterial.sheen.set(Math.pow(color[0], 1 / 2.2), Math.pow(color[1], 1 / 2.2), Math.pow(color[2], 1 / 2.2));\n\t} else {\n\t\tmaterial.sheen.set(1, 1, 1);\n\t}\n\tif (data.hasOwnProperty('sheenColorTexture')) {\n\t\tmaterial.sheenMap = textures[data.sheenColorTexture.index];\n\t\tmaterial.sheenEncoding = 'srgb';\n\t\textractTextureTransform(data.sheenColorTexture, material, ['sheen']);\n\t}\n\tif (data.hasOwnProperty('sheenRoughnessFactor')) {\n\t\tmaterial.sheenGloss = data.sheenRoughnessFactor;\n\t} else {\n\t\tmaterial.sheenGloss = 0.0;\n\t}\n\tif (data.hasOwnProperty('sheenRoughnessTexture')) {\n\t\tmaterial.sheenGlossMap = textures[data.sheenRoughnessTexture.index];\n\t\tmaterial.sheenGlossMapChannel = 'a';\n\t\textractTextureTransform(data.sheenRoughnessTexture, material, ['sheenGloss']);\n\t}\n\tmaterial.sheenGlossInvert = true;\n};\nconst extensionVolume = (data, material, textures) => {\n\tmaterial.blendType = BLEND_NORMAL;\n\tmaterial.useDynamicRefraction = true;\n\tif (data.hasOwnProperty('thicknessFactor')) {\n\t\tmaterial.thickness = data.thicknessFactor;\n\t}\n\tif (data.hasOwnProperty('thicknessTexture')) {\n\t\tmaterial.thicknessMap = textures[data.thicknessTexture.index];\n\t\tmaterial.thicknessMapChannel = 'g';\n\t\textractTextureTransform(data.thicknessTexture, material, ['thickness']);\n\t}\n\tif (data.hasOwnProperty('attenuationDistance')) {\n\t\tmaterial.attenuationDistance = data.attenuationDistance;\n\t}\n\tif (data.hasOwnProperty('attenuationColor')) {\n\t\tconst color = data.attenuationColor;\n\t\tmaterial.attenuation.set(Math.pow(color[0], 1 / 2.2), Math.pow(color[1], 1 / 2.2), Math.pow(color[2], 1 / 2.2));\n\t}\n};\nconst extensionEmissiveStrength = (data, material, textures) => {\n\tif (data.hasOwnProperty('emissiveStrength')) {\n\t\tmaterial.emissiveIntensity = data.emissiveStrength;\n\t}\n};\nconst extensionIridescence = (data, material, textures) => {\n\tmaterial.useIridescence = true;\n\tif (data.hasOwnProperty('iridescenceFactor')) {\n\t\tmaterial.iridescence = data.iridescenceFactor;\n\t}\n\tif (data.hasOwnProperty('iridescenceTexture')) {\n\t\tmaterial.iridescenceMapChannel = 'r';\n\t\tmaterial.iridescenceMap = textures[data.iridescenceTexture.index];\n\t\textractTextureTransform(data.iridescenceTexture, material, ['iridescence']);\n\t}\n\tif (data.hasOwnProperty('iridescenceIor')) {\n\t\tmaterial.iridescenceRefractionIndex = data.iridescenceIor;\n\t}\n\tif (data.hasOwnProperty('iridescenceThicknessMinimum')) {\n\t\tmaterial.iridescenceThicknessMin = data.iridescenceThicknessMinimum;\n\t}\n\tif (data.hasOwnProperty('iridescenceThicknessMaximum')) {\n\t\tmaterial.iridescenceThicknessMax = data.iridescenceThicknessMaximum;\n\t}\n\tif (data.hasOwnProperty('iridescenceThicknessTexture')) {\n\t\tmaterial.iridescenceThicknessMapChannel = 'g';\n\t\tmaterial.iridescenceThicknessMap = textures[data.iridescenceThicknessTexture.index];\n\t\textractTextureTransform(data.iridescenceThicknessTexture, material, ['iridescenceThickness']);\n\t}\n};\nconst createMaterial = (gltfMaterial, textures, flipV) => {\n\tconst material = new StandardMaterial();\n\tmaterial.occludeSpecular = SPECOCC_AO;\n\tmaterial.diffuseTint = true;\n\tmaterial.diffuseVertexColor = true;\n\tmaterial.specularTint = true;\n\tmaterial.specularVertexColor = true;\n\tif (gltfMaterial.hasOwnProperty('name')) {\n\t\tmaterial.name = gltfMaterial.name;\n\t}\n\tlet color, texture;\n\tif (gltfMaterial.hasOwnProperty('pbrMetallicRoughness')) {\n\t\tconst pbrData = gltfMaterial.pbrMetallicRoughness;\n\t\tif (pbrData.hasOwnProperty('baseColorFactor')) {\n\t\t\tcolor = pbrData.baseColorFactor;\n\t\t\tmaterial.diffuse.set(Math.pow(color[0], 1 / 2.2), Math.pow(color[1], 1 / 2.2), Math.pow(color[2], 1 / 2.2));\n\t\t\tmaterial.opacity = color[3];\n\t\t} else {\n\t\t\tmaterial.diffuse.set(1, 1, 1);\n\t\t\tmaterial.opacity = 1;\n\t\t}\n\t\tif (pbrData.hasOwnProperty('baseColorTexture')) {\n\t\t\tconst baseColorTexture = pbrData.baseColorTexture;\n\t\t\ttexture = textures[baseColorTexture.index];\n\t\t\tmaterial.diffuseMap = texture;\n\t\t\tmaterial.diffuseMapChannel = 'rgb';\n\t\t\tmaterial.opacityMap = texture;\n\t\t\tmaterial.opacityMapChannel = 'a';\n\t\t\textractTextureTransform(baseColorTexture, material, ['diffuse', 'opacity']);\n\t\t}\n\t\tmaterial.useMetalness = true;\n\t\tmaterial.specular.set(1, 1, 1);\n\t\tif (pbrData.hasOwnProperty('metallicFactor')) {\n\t\t\tmaterial.metalness = pbrData.metallicFactor;\n\t\t} else {\n\t\t\tmaterial.metalness = 1;\n\t\t}\n\t\tif (pbrData.hasOwnProperty('roughnessFactor')) {\n\t\t\tmaterial.gloss = pbrData.roughnessFactor;\n\t\t} else {\n\t\t\tmaterial.gloss = 1;\n\t\t}\n\t\tmaterial.glossInvert = true;\n\t\tif (pbrData.hasOwnProperty('metallicRoughnessTexture')) {\n\t\t\tconst metallicRoughnessTexture = pbrData.metallicRoughnessTexture;\n\t\t\tmaterial.metalnessMap = material.glossMap = textures[metallicRoughnessTexture.index];\n\t\t\tmaterial.metalnessMapChannel = 'b';\n\t\t\tmaterial.glossMapChannel = 'g';\n\t\t\textractTextureTransform(metallicRoughnessTexture, material, ['gloss', 'metalness']);\n\t\t}\n\t}\n\tif (gltfMaterial.hasOwnProperty('normalTexture')) {\n\t\tconst normalTexture = gltfMaterial.normalTexture;\n\t\tmaterial.normalMap = textures[normalTexture.index];\n\t\textractTextureTransform(normalTexture, material, ['normal']);\n\t\tif (normalTexture.hasOwnProperty('scale')) {\n\t\t\tmaterial.bumpiness = normalTexture.scale;\n\t\t}\n\t}\n\tif (gltfMaterial.hasOwnProperty('occlusionTexture')) {\n\t\tconst occlusionTexture = gltfMaterial.occlusionTexture;\n\t\tmaterial.aoMap = textures[occlusionTexture.index];\n\t\tmaterial.aoMapChannel = 'r';\n\t\textractTextureTransform(occlusionTexture, material, ['ao']);\n\t}\n\tif (gltfMaterial.hasOwnProperty('emissiveFactor')) {\n\t\tcolor = gltfMaterial.emissiveFactor;\n\t\tmaterial.emissive.set(Math.pow(color[0], 1 / 2.2), Math.pow(color[1], 1 / 2.2), Math.pow(color[2], 1 / 2.2));\n\t\tmaterial.emissiveTint = true;\n\t} else {\n\t\tmaterial.emissive.set(0, 0, 0);\n\t\tmaterial.emissiveTint = false;\n\t}\n\tif (gltfMaterial.hasOwnProperty('emissiveTexture')) {\n\t\tconst emissiveTexture = gltfMaterial.emissiveTexture;\n\t\tmaterial.emissiveMap = textures[emissiveTexture.index];\n\t\textractTextureTransform(emissiveTexture, material, ['emissive']);\n\t}\n\tif (gltfMaterial.hasOwnProperty('alphaMode')) {\n\t\tswitch (gltfMaterial.alphaMode) {\n\t\t\tcase 'MASK':\n\t\t\t\tmaterial.blendType = BLEND_NONE;\n\t\t\t\tif (gltfMaterial.hasOwnProperty('alphaCutoff')) {\n\t\t\t\t\tmaterial.alphaTest = gltfMaterial.alphaCutoff;\n\t\t\t\t} else {\n\t\t\t\t\tmaterial.alphaTest = 0.5;\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tcase 'BLEND':\n\t\t\t\tmaterial.blendType = BLEND_NORMAL;\n\t\t\t\tmaterial.depthWrite = false;\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\tcase 'OPAQUE':\n\t\t\t\tmaterial.blendType = BLEND_NONE;\n\t\t\t\tbreak;\n\t\t}\n\t} else {\n\t\tmaterial.blendType = BLEND_NONE;\n\t}\n\tif (gltfMaterial.hasOwnProperty('doubleSided')) {\n\t\tmaterial.twoSidedLighting = gltfMaterial.doubleSided;\n\t\tmaterial.cull = gltfMaterial.doubleSided ? CULLFACE_NONE : CULLFACE_BACK;\n\t} else {\n\t\tmaterial.twoSidedLighting = false;\n\t\tmaterial.cull = CULLFACE_BACK;\n\t}\n\tconst extensions = {\n\t\t\"KHR_materials_clearcoat\": extensionClearCoat,\n\t\t\"KHR_materials_emissive_strength\": extensionEmissiveStrength,\n\t\t\"KHR_materials_ior\": extensionIor,\n\t\t\"KHR_materials_dispersion\": extensionDispersion,\n\t\t\"KHR_materials_iridescence\": extensionIridescence,\n\t\t\"KHR_materials_pbrSpecularGlossiness\": extensionPbrSpecGlossiness,\n\t\t\"KHR_materials_sheen\": extensionSheen,\n\t\t\"KHR_materials_specular\": extensionSpecular,\n\t\t\"KHR_materials_transmission\": extensionTransmission,\n\t\t\"KHR_materials_unlit\": extensionUnlit,\n\t\t\"KHR_materials_volume\": extensionVolume\n\t};\n\tif (gltfMaterial.hasOwnProperty('extensions')) {\n\t\tfor (const key in gltfMaterial.extensions) {\n\t\t\tconst extensionFunc = extensions[key];\n\t\t\tif (extensionFunc !== undefined) {\n\t\t\t\textensionFunc(gltfMaterial.extensions[key], material, textures);\n\t\t\t}\n\t\t}\n\t}\n\tmaterial.update();\n\treturn material;\n};\nconst createAnimation = (gltfAnimation, animationIndex, gltfAccessors, bufferViews, nodes, meshes, gltfNodes) => {\n\tconst createAnimData = gltfAccessor => {\n\t\treturn new AnimData(getNumComponents(gltfAccessor.type), getAccessorDataFloat32(gltfAccessor, bufferViews));\n\t};\n\tconst interpMap = {\n\t\t'STEP': INTERPOLATION_STEP,\n\t\t'LINEAR': INTERPOLATION_LINEAR,\n\t\t'CUBICSPLINE': INTERPOLATION_CUBIC\n\t};\n\tconst inputMap = {};\n\tconst outputMap = {};\n\tconst curveMap = {};\n\tlet outputCounter = 1;\n\tlet i;\n\tfor (i = 0; i < gltfAnimation.samplers.length; ++i) {\n\t\tconst sampler = gltfAnimation.samplers[i];\n\t\tif (!inputMap.hasOwnProperty(sampler.input)) {\n\t\t\tinputMap[sampler.input] = createAnimData(gltfAccessors[sampler.input]);\n\t\t}\n\t\tif (!outputMap.hasOwnProperty(sampler.output)) {\n\t\t\toutputMap[sampler.output] = createAnimData(gltfAccessors[sampler.output]);\n\t\t}\n\t\tconst interpolation = sampler.hasOwnProperty('interpolation') && interpMap.hasOwnProperty(sampler.interpolation) ? interpMap[sampler.interpolation] : INTERPOLATION_LINEAR;\n\t\tconst curve = {\n\t\t\tpaths: [],\n\t\t\tinput: sampler.input,\n\t\t\toutput: sampler.output,\n\t\t\tinterpolation: interpolation\n\t\t};\n\t\tcurveMap[i] = curve;\n\t}\n\tconst quatArrays = [];\n\tconst transformSchema = {\n\t\t'translation': 'localPosition',\n\t\t'rotation': 'localRotation',\n\t\t'scale': 'localScale'\n\t};\n\tconst constructNodePath = node => {\n\t\tconst path = [];\n\t\twhile (node) {\n\t\t\tpath.unshift(node.name);\n\t\t\tnode = node.parent;\n\t\t}\n\t\treturn path;\n\t};\n\tconst createMorphTargetCurves = (curve, gltfNode, entityPath) => {\n\t\tconst out = outputMap[curve.output];\n\t\tif (!out) {\n\t\t\treturn;\n\t\t}\n\t\tlet targetNames;\n\t\tif (meshes && meshes[gltfNode.mesh]) {\n\t\t\tconst mesh = meshes[gltfNode.mesh];\n\t\t\tif (mesh.hasOwnProperty('extras') && mesh.extras.hasOwnProperty('targetNames')) {\n\t\t\t\ttargetNames = mesh.extras.targetNames;\n\t\t\t}\n\t\t}\n\t\tconst outData = out.data;\n\t\tconst morphTargetCount = outData.length / inputMap[curve.input].data.length;\n\t\tconst keyframeCount = outData.length / morphTargetCount;\n\t\tconst singleBufferSize = keyframeCount * 4;\n\t\tconst buffer = new ArrayBuffer(singleBufferSize * morphTargetCount);\n\t\tfor (let j = 0; j < morphTargetCount; j++) {\n\t\t\tvar _targetNames;\n\t\t\tconst morphTargetOutput = new Float32Array(buffer, singleBufferSize * j, keyframeCount);\n\t\t\tfor (let k = 0; k < keyframeCount; k++) {\n\t\t\t\tmorphTargetOutput[k] = outData[k * morphTargetCount + j];\n\t\t\t}\n\t\t\tconst output = new AnimData(1, morphTargetOutput);\n\t\t\tconst weightName = (_targetNames = targetNames) != null && _targetNames[j] ? `name.${targetNames[j]}` : j;\n\t\t\toutputMap[-outputCounter] = output;\n\t\t\tconst morphCurve = {\n\t\t\t\tpaths: [{\n\t\t\t\t\tentityPath: entityPath,\n\t\t\t\t\tcomponent: 'graph',\n\t\t\t\t\tpropertyPath: [`weight.${weightName}`]\n\t\t\t\t}],\n\t\t\t\tinput: curve.input,\n\t\t\t\toutput: -outputCounter,\n\t\t\t\tinterpolation: curve.interpolation\n\t\t\t};\n\t\t\toutputCounter++;\n\t\t\tcurveMap[`morphCurve-${i}-${j}`] = morphCurve;\n\t\t}\n\t};\n\tfor (i = 0; i < gltfAnimation.channels.length; ++i) {\n\t\tconst channel = gltfAnimation.channels[i];\n\t\tconst target = channel.target;\n\t\tconst curve = curveMap[channel.sampler];\n\t\tconst node = nodes[target.node];\n\t\tconst gltfNode = gltfNodes[target.node];\n\t\tconst entityPath = constructNodePath(node);\n\t\tif (target.path.startsWith('weights')) {\n\t\t\tcreateMorphTargetCurves(curve, gltfNode, entityPath);\n\t\t\tcurveMap[channel.sampler].morphCurve = true;\n\t\t} else {\n\t\t\tcurve.paths.push({\n\t\t\t\tentityPath: entityPath,\n\t\t\t\tcomponent: 'graph',\n\t\t\t\tpropertyPath: [transformSchema[target.path]]\n\t\t\t});\n\t\t}\n\t}\n\tconst inputs = [];\n\tconst outputs = [];\n\tconst curves = [];\n\tfor (const inputKey in inputMap) {\n\t\tinputs.push(inputMap[inputKey]);\n\t\tinputMap[inputKey] = inputs.length - 1;\n\t}\n\tfor (const outputKey in outputMap) {\n\t\toutputs.push(outputMap[outputKey]);\n\t\toutputMap[outputKey] = outputs.length - 1;\n\t}\n\tfor (const curveKey in curveMap) {\n\t\tconst curveData = curveMap[curveKey];\n\t\tif (curveData.morphCurve) {\n\t\t\tcontinue;\n\t\t}\n\t\tcurves.push(new AnimCurve(curveData.paths, inputMap[curveData.input], outputMap[curveData.output], curveData.interpolation));\n\t\tif (curveData.paths.length > 0 && curveData.paths[0].propertyPath[0] === 'localRotation' && curveData.interpolation !== INTERPOLATION_CUBIC) {\n\t\t\tquatArrays.push(curves[curves.length - 1].output);\n\t\t}\n\t}\n\tquatArrays.sort();\n\tlet prevIndex = null;\n\tlet data;\n\tfor (i = 0; i < quatArrays.length; ++i) {\n\t\tconst index = quatArrays[i];\n\t\tif (i === 0 || index !== prevIndex) {\n\t\t\tdata = outputs[index];\n\t\t\tif (data.components === 4) {\n\t\t\t\tconst d = data.data;\n\t\t\t\tconst len = d.length - 4;\n\t\t\t\tfor (let j = 0; j < len; j += 4) {\n\t\t\t\t\tconst dp = d[j + 0] * d[j + 4] + d[j + 1] * d[j + 5] + d[j + 2] * d[j + 6] + d[j + 3] * d[j + 7];\n\t\t\t\t\tif (dp < 0) {\n\t\t\t\t\t\td[j + 4] *= -1;\n\t\t\t\t\t\td[j + 5] *= -1;\n\t\t\t\t\t\td[j + 6] *= -1;\n\t\t\t\t\t\td[j + 7] *= -1;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tprevIndex = index;\n\t\t}\n\t}\n\tlet duration = 0;\n\tfor (i = 0; i < inputs.length; i++) {\n\t\tdata = inputs[i]._data;\n\t\tduration = Math.max(duration, data.length === 0 ? 0 : data[data.length - 1]);\n\t}\n\treturn new AnimTrack(gltfAnimation.hasOwnProperty('name') ? gltfAnimation.name : 'animation_' + animationIndex, duration, inputs, outputs, curves);\n};\nconst tempMat = new Mat4();\nconst tempVec = new Vec3();\nconst createNode = (gltfNode, nodeIndex) => {\n\tconst entity = new GraphNode();\n\tif (gltfNode.hasOwnProperty('name') && gltfNode.name.length > 0) {\n\t\tentity.name = gltfNode.name;\n\t} else {\n\t\tentity.name = 'node_' + nodeIndex;\n\t}\n\tif (gltfNode.hasOwnProperty('matrix')) {\n\t\ttempMat.data.set(gltfNode.matrix);\n\t\ttempMat.getTranslation(tempVec);\n\t\tentity.setLocalPosition(tempVec);\n\t\ttempMat.getEulerAngles(tempVec);\n\t\tentity.setLocalEulerAngles(tempVec);\n\t\ttempMat.getScale(tempVec);\n\t\tentity.setLocalScale(tempVec);\n\t}\n\tif (gltfNode.hasOwnProperty('rotation')) {\n\t\tconst r = gltfNode.rotation;\n\t\tentity.setLocalRotation(r[0], r[1], r[2], r[3]);\n\t}\n\tif (gltfNode.hasOwnProperty('translation')) {\n\t\tconst t = gltfNode.translation;\n\t\tentity.setLocalPosition(t[0], t[1], t[2]);\n\t}\n\tif (gltfNode.hasOwnProperty('scale')) {\n\t\tconst s = gltfNode.scale;\n\t\tentity.setLocalScale(s[0], s[1], s[2]);\n\t}\n\treturn entity;\n};\nconst createCamera = (gltfCamera, node) => {\n\tconst projection = gltfCamera.type === 'orthographic' ? PROJECTION_ORTHOGRAPHIC : PROJECTION_PERSPECTIVE;\n\tconst gltfProperties = projection === PROJECTION_ORTHOGRAPHIC ? gltfCamera.orthographic : gltfCamera.perspective;\n\tconst componentData = {\n\t\tenabled: false,\n\t\tprojection: projection,\n\t\tnearClip: gltfProperties.znear,\n\t\taspectRatioMode: ASPECT_AUTO\n\t};\n\tif (gltfProperties.zfar) {\n\t\tcomponentData.farClip = gltfProperties.zfar;\n\t}\n\tif (projection === PROJECTION_ORTHOGRAPHIC) {\n\t\tcomponentData.orthoHeight = 0.5 * gltfProperties.ymag;\n\t\tif (gltfProperties.ymag) {\n\t\t\tcomponentData.aspectRatioMode = ASPECT_MANUAL;\n\t\t\tcomponentData.aspectRatio = gltfProperties.xmag / gltfProperties.ymag;\n\t\t}\n\t} else {\n\t\tcomponentData.fov = gltfProperties.yfov * math.RAD_TO_DEG;\n\t\tif (gltfProperties.aspectRatio) {\n\t\t\tcomponentData.aspectRatioMode = ASPECT_MANUAL;\n\t\t\tcomponentData.aspectRatio = gltfProperties.aspectRatio;\n\t\t}\n\t}\n\tconst cameraEntity = new Entity(gltfCamera.name);\n\tcameraEntity.addComponent('camera', componentData);\n\treturn cameraEntity;\n};\nconst createLight = (gltfLight, node) => {\n\tconst lightProps = {\n\t\tenabled: false,\n\t\ttype: gltfLight.type === 'point' ? 'omni' : gltfLight.type,\n\t\tcolor: gltfLight.hasOwnProperty('color') ? new Color(gltfLight.color) : Color.WHITE,\n\t\trange: gltfLight.hasOwnProperty('range') ? gltfLight.range : 9999,\n\t\tfalloffMode: LIGHTFALLOFF_INVERSESQUARED,\n\t\tintensity: gltfLight.hasOwnProperty('intensity') ? math.clamp(gltfLight.intensity, 0, 2) : 1\n\t};\n\tif (gltfLight.hasOwnProperty('spot')) {\n\t\tlightProps.innerConeAngle = gltfLight.spot.hasOwnProperty('innerConeAngle') ? gltfLight.spot.innerConeAngle * math.RAD_TO_DEG : 0;\n\t\tlightProps.outerConeAngle = gltfLight.spot.hasOwnProperty('outerConeAngle') ? gltfLight.spot.outerConeAngle * math.RAD_TO_DEG : Math.PI / 4;\n\t}\n\tif (gltfLight.hasOwnProperty(\"intensity\")) {\n\t\tlightProps.luminance = gltfLight.intensity * Light.getLightUnitConversion(lightTypes[lightProps.type], lightProps.outerConeAngle, lightProps.innerConeAngle);\n\t}\n\tconst lightEntity = new Entity(node.name);\n\tlightEntity.rotateLocal(90, 0, 0);\n\tlightEntity.addComponent('light', lightProps);\n\treturn lightEntity;\n};\nconst createSkins = (device, gltf, nodes, bufferViews) => {\n\tif (!gltf.hasOwnProperty('skins') || gltf.skins.length === 0) {\n\t\treturn [];\n\t}\n\tconst glbSkins = new Map();\n\treturn gltf.skins.map(gltfSkin => {\n\t\treturn createSkin(device, gltfSkin, gltf.accessors, bufferViews, nodes, glbSkins);\n\t});\n};\nconst createMeshes = (device, gltf, bufferViews, flipV, options) => {\n\tvar _gltf$meshes, _gltf$accessors, _gltf$bufferViews;\n\tconst vertexBufferDict = {};\n\tconst meshVariants = {};\n\tconst meshDefaultMaterials = {};\n\tconst promises = [];\n\tconst valid = !options.skipMeshes && (gltf == null || (_gltf$meshes = gltf.meshes) == null ? void 0 : _gltf$meshes.length) && (gltf == null || (_gltf$accessors = gltf.accessors) == null ? void 0 : _gltf$accessors.length) && (gltf == null || (_gltf$bufferViews = gltf.bufferViews) == null ? void 0 : _gltf$bufferViews.length);\n\tconst meshes = valid ? gltf.meshes.map(gltfMesh => {\n\t\treturn createMesh(device, gltfMesh, gltf.accessors, bufferViews, flipV, vertexBufferDict, meshVariants, meshDefaultMaterials, options, promises);\n\t}) : [];\n\treturn {\n\t\tmeshes,\n\t\tmeshVariants,\n\t\tmeshDefaultMaterials,\n\t\tpromises\n\t};\n};\nconst createMaterials = (gltf, textures, options, flipV) => {\n\tvar _options$material, _options$material$pro, _options$material2, _options$material3;\n\tif (!gltf.hasOwnProperty('materials') || gltf.materials.length === 0) {\n\t\treturn [];\n\t}\n\tconst preprocess = options == null || (_options$material = options.material) == null ? void 0 : _options$material.preprocess;\n\tconst process = (_options$material$pro = options == null || (_options$material2 = options.material) == null ? void 0 : _options$material2.process) != null ? _options$material$pro : createMaterial;\n\tconst postprocess = options == null || (_options$material3 = options.material) == null ? void 0 : _options$material3.postprocess;\n\treturn gltf.materials.map(gltfMaterial => {\n\t\tif (preprocess) {\n\t\t\tpreprocess(gltfMaterial);\n\t\t}\n\t\tconst material = process(gltfMaterial, textures, flipV);\n\t\tif (postprocess) {\n\t\t\tpostprocess(gltfMaterial, material);\n\t\t}\n\t\treturn material;\n\t});\n};\nconst createVariants = gltf => {\n\tif (!gltf.hasOwnProperty(\"extensions\") || !gltf.extensions.hasOwnProperty(\"KHR_materials_variants\")) return null;\n\tconst data = gltf.extensions.KHR_materials_variants.variants;\n\tconst variants = {};\n\tfor (let i = 0; i < data.length; i++) {\n\t\tvariants[data[i].name] = i;\n\t}\n\treturn variants;\n};\nconst createAnimations = (gltf, nodes, bufferViews, options) => {\n\tvar _options$animation, _options$animation2;\n\tif (!gltf.hasOwnProperty('animations') || gltf.animations.length === 0) {\n\t\treturn [];\n\t}\n\tconst preprocess = options == null || (_options$animation = options.animation) == null ? void 0 : _options$animation.preprocess;\n\tconst postprocess = options == null || (_options$animation2 = options.animation) == null ? void 0 : _options$animation2.postprocess;\n\treturn gltf.animations.map((gltfAnimation, index) => {\n\t\tif (preprocess) {\n\t\t\tpreprocess(gltfAnimation);\n\t\t}\n\t\tconst animation = createAnimation(gltfAnimation, index, gltf.accessors, bufferViews, nodes, gltf.meshes, gltf.nodes);\n\t\tif (postprocess) {\n\t\t\tpostprocess(gltfAnimation, animation);\n\t\t}\n\t\treturn animation;\n\t});\n};\nconst createNodes = (gltf, options) => {\n\tvar _options$node, _options$node$process, _options$node2, _options$node3;\n\tif (!gltf.hasOwnProperty('nodes') || gltf.nodes.length === 0) {\n\t\treturn [];\n\t}\n\tconst preprocess = options == null || (_options$node = options.node) == null ? void 0 : _options$node.preprocess;\n\tconst process = (_options$node$process = options == null || (_options$node2 = options.node) == null ? void 0 : _options$node2.process) != null ? _options$node$process : createNode;\n\tconst postprocess = options == null || (_options$node3 = options.node) == null ? void 0 : _options$node3.postprocess;\n\tconst nodes = gltf.nodes.map((gltfNode, index) => {\n\t\tif (preprocess) {\n\t\t\tpreprocess(gltfNode);\n\t\t}\n\t\tconst node = process(gltfNode, index);\n\t\tif (postprocess) {\n\t\t\tpostprocess(gltfNode, node);\n\t\t}\n\t\treturn node;\n\t});\n\tfor (let i = 0; i < gltf.nodes.length; ++i) {\n\t\tconst gltfNode = gltf.nodes[i];\n\t\tif (gltfNode.hasOwnProperty('children')) {\n\t\t\tconst parent = nodes[i];\n\t\t\tconst uniqueNames = {};\n\t\t\tfor (let j = 0; j < gltfNode.children.length; ++j) {\n\t\t\t\tconst child = nodes[gltfNode.children[j]];\n\t\t\t\tif (!child.parent) {\n\t\t\t\t\tif (uniqueNames.hasOwnProperty(child.name)) {\n\t\t\t\t\t\tchild.name += uniqueNames[child.name]++;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tuniqueNames[child.name] = 1;\n\t\t\t\t\t}\n\t\t\t\t\tparent.addChild(child);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\treturn nodes;\n};\nconst createScenes = (gltf, nodes) => {\n\tvar _gltf$scenes$0$nodes;\n\tconst scenes = [];\n\tconst count = gltf.scenes.length;\n\tif (count === 1 && ((_gltf$scenes$0$nodes = gltf.scenes[0].nodes) == null ? void 0 : _gltf$scenes$0$nodes.length) === 1) {\n\t\tconst nodeIndex = gltf.scenes[0].nodes[0];\n\t\tscenes.push(nodes[nodeIndex]);\n\t} else {\n\t\tfor (let i = 0; i < count; i++) {\n\t\t\tconst scene = gltf.scenes[i];\n\t\t\tif (scene.nodes) {\n\t\t\t\tconst sceneRoot = new GraphNode(scene.name);\n\t\t\t\tfor (let n = 0; n < scene.nodes.length; n++) {\n\t\t\t\t\tconst childNode = nodes[scene.nodes[n]];\n\t\t\t\t\tsceneRoot.addChild(childNode);\n\t\t\t\t}\n\t\t\t\tscenes.push(sceneRoot);\n\t\t\t}\n\t\t}\n\t}\n\treturn scenes;\n};\nconst createCameras = (gltf, nodes, options) => {\n\tlet cameras = null;\n\tif (gltf.hasOwnProperty('nodes') && gltf.hasOwnProperty('cameras') && gltf.cameras.length > 0) {\n\t\tvar _options$camera, _options$camera$proce, _options$camera2, _options$camera3;\n\t\tconst preprocess = options == null || (_options$camera = options.camera) == null ? void 0 : _options$camera.preprocess;\n\t\tconst process = (_options$camera$proce = options == null || (_options$camera2 = options.camera) == null ? void 0 : _options$camera2.process) != null ? _options$camera$proce : createCamera;\n\t\tconst postprocess = options == null || (_options$camera3 = options.camera) == null ? void 0 : _options$camera3.postprocess;\n\t\tgltf.nodes.forEach((gltfNode, nodeIndex) => {\n\t\t\tif (gltfNode.hasOwnProperty('camera')) {\n\t\t\t\tconst gltfCamera = gltf.cameras[gltfNode.camera];\n\t\t\t\tif (gltfCamera) {\n\t\t\t\t\tif (preprocess) {\n\t\t\t\t\t\tpreprocess(gltfCamera);\n\t\t\t\t\t}\n\t\t\t\t\tconst camera = process(gltfCamera, nodes[nodeIndex]);\n\t\t\t\t\tif (postprocess) {\n\t\t\t\t\t\tpostprocess(gltfCamera, camera);\n\t\t\t\t\t}\n\t\t\t\t\tif (camera) {\n\t\t\t\t\t\tif (!cameras) cameras = new Map();\n\t\t\t\t\t\tcameras.set(gltfNode, camera);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t}\n\treturn cameras;\n};\nconst createLights = (gltf, nodes, options) => {\n\tlet lights = null;\n\tif (gltf.hasOwnProperty('nodes') && gltf.hasOwnProperty('extensions') && gltf.extensions.hasOwnProperty('KHR_lights_punctual') && gltf.extensions.KHR_lights_punctual.hasOwnProperty('lights')) {\n\t\tconst gltfLights = gltf.extensions.KHR_lights_punctual.lights;\n\t\tif (gltfLights.length) {\n\t\t\tvar _options$light, _options$light$proces, _options$light2, _options$light3;\n\t\t\tconst preprocess = options == null || (_options$light = options.light) == null ? void 0 : _options$light.preprocess;\n\t\t\tconst process = (_options$light$proces = options == null || (_options$light2 = options.light) == null ? void 0 : _options$light2.process) != null ? _options$light$proces : createLight;\n\t\t\tconst postprocess = options == null || (_options$light3 = options.light) == null ? void 0 : _options$light3.postprocess;\n\t\t\tgltf.nodes.forEach((gltfNode, nodeIndex) => {\n\t\t\t\tif (gltfNode.hasOwnProperty('extensions') && gltfNode.extensions.hasOwnProperty('KHR_lights_punctual') && gltfNode.extensions.KHR_lights_punctual.hasOwnProperty('light')) {\n\t\t\t\t\tconst lightIndex = gltfNode.extensions.KHR_lights_punctual.light;\n\t\t\t\t\tconst gltfLight = gltfLights[lightIndex];\n\t\t\t\t\tif (gltfLight) {\n\t\t\t\t\t\tif (preprocess) {\n\t\t\t\t\t\t\tpreprocess(gltfLight);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tconst light = process(gltfLight, nodes[nodeIndex]);\n\t\t\t\t\t\tif (postprocess) {\n\t\t\t\t\t\t\tpostprocess(gltfLight, light);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (light) {\n\t\t\t\t\t\t\tif (!lights) lights = new Map();\n\t\t\t\t\t\t\tlights.set(gltfNode, light);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\t}\n\treturn lights;\n};\nconst linkSkins = (gltf, renders, skins) => {\n\tgltf.nodes.forEach(gltfNode => {\n\t\tif (gltfNode.hasOwnProperty('mesh') && gltfNode.hasOwnProperty('skin')) {\n\t\t\tconst meshGroup = renders[gltfNode.mesh].meshes;\n\t\t\tmeshGroup.forEach(mesh => {\n\t\t\t\tmesh.skin = skins[gltfNode.skin];\n\t\t\t});\n\t\t}\n\t});\n};\nconst createResources = async (device, gltf, bufferViews, textures, options) => {\n\tvar _options$global, _options$global2;\n\tconst preprocess = options == null || (_options$global = options.global) == null ? void 0 : _options$global.preprocess;\n\tconst postprocess = options == null || (_options$global2 = options.global) == null ? void 0 : _options$global2.postprocess;\n\tif (preprocess) {\n\t\tpreprocess(gltf);\n\t}\n\tconst flipV = gltf.asset && gltf.asset.generator === 'PlayCanvas';\n\tconst nodes = createNodes(gltf, options);\n\tconst scenes = createScenes(gltf, nodes);\n\tconst lights = createLights(gltf, nodes, options);\n\tconst cameras = createCameras(gltf, nodes, options);\n\tconst variants = createVariants(gltf);\n\tconst bufferViewData = await Promise.all(bufferViews);\n\tconst {\n\t\tmeshes,\n\t\tmeshVariants,\n\t\tmeshDefaultMaterials,\n\t\tpromises\n\t} = createMeshes(device, gltf, bufferViewData, flipV, options);\n\tconst animations = createAnimations(gltf, nodes, bufferViewData, options);\n\tconst textureAssets = await Promise.all(textures);\n\tconst textureInstances = textureAssets.map(t => t.resource);\n\tconst materials = createMaterials(gltf, textureInstances, options, flipV);\n\tconst skins = createSkins(device, gltf, nodes, bufferViewData);\n\tconst renders = [];\n\tfor (let i = 0; i < meshes.length; i++) {\n\t\trenders[i] = new Render();\n\t\trenders[i].meshes = meshes[i];\n\t}\n\tlinkSkins(gltf, renders, skins);\n\tconst result = new GlbResources();\n\tresult.gltf = gltf;\n\tresult.nodes = nodes;\n\tresult.scenes = scenes;\n\tresult.animations = animations;\n\tresult.textures = textureAssets;\n\tresult.materials = materials;\n\tresult.variants = variants;\n\tresult.meshVariants = meshVariants;\n\tresult.meshDefaultMaterials = meshDefaultMaterials;\n\tresult.renders = renders;\n\tresult.skins = skins;\n\tresult.lights = lights;\n\tresult.cameras = cameras;\n\tif (postprocess) {\n\t\tpostprocess(gltf, result);\n\t}\n\tawait Promise.all(promises);\n\treturn result;\n};\nconst applySampler = (texture, gltfSampler) => {\n\tconst getFilter = (filter, defaultValue) => {\n\t\tswitch (filter) {\n\t\t\tcase 9728:\n\t\t\t\treturn FILTER_NEAREST;\n\t\t\tcase 9729:\n\t\t\t\treturn FILTER_LINEAR;\n\t\t\tcase 9984:\n\t\t\t\treturn FILTER_NEAREST_MIPMAP_NEAREST;\n\t\t\tcase 9985:\n\t\t\t\treturn FILTER_LINEAR_MIPMAP_NEAREST;\n\t\t\tcase 9986:\n\t\t\t\treturn FILTER_NEAREST_MIPMAP_LINEAR;\n\t\t\tcase 9987:\n\t\t\t\treturn FILTER_LINEAR_MIPMAP_LINEAR;\n\t\t\tdefault:\n\t\t\t\treturn defaultValue;\n\t\t}\n\t};\n\tconst getWrap = (wrap, defaultValue) => {\n\t\tswitch (wrap) {\n\t\t\tcase 33071:\n\t\t\t\treturn ADDRESS_CLAMP_TO_EDGE;\n\t\t\tcase 33648:\n\t\t\t\treturn ADDRESS_MIRRORED_REPEAT;\n\t\t\tcase 10497:\n\t\t\t\treturn ADDRESS_REPEAT;\n\t\t\tdefault:\n\t\t\t\treturn defaultValue;\n\t\t}\n\t};\n\tif (texture) {\n\t\tvar _gltfSampler;\n\t\tgltfSampler = (_gltfSampler = gltfSampler) != null ? _gltfSampler : {};\n\t\ttexture.minFilter = getFilter(gltfSampler.minFilter, FILTER_LINEAR_MIPMAP_LINEAR);\n\t\ttexture.magFilter = getFilter(gltfSampler.magFilter, FILTER_LINEAR);\n\t\ttexture.addressU = getWrap(gltfSampler.wrapS, ADDRESS_REPEAT);\n\t\ttexture.addressV = getWrap(gltfSampler.wrapT, ADDRESS_REPEAT);\n\t}\n};\nlet gltfTextureUniqueId = 0;\nconst createImages = (gltf, bufferViews, urlBase, registry, options) => {\n\tvar _options$image, _options$image2, _options$image3;\n\tif (!gltf.images || gltf.images.length === 0) {\n\t\treturn [];\n\t}\n\tconst preprocess = options == null || (_options$image = options.image) == null ? void 0 : _options$image.preprocess;\n\tconst processAsync = options == null || (_options$image2 = options.image) == null ? void 0 : _options$image2.processAsync;\n\tconst postprocess = options == null || (_options$image3 = options.image) == null ? void 0 : _options$image3.postprocess;\n\tconst mimeTypeFileExtensions = {\n\t\t'image/png': 'png',\n\t\t'image/jpeg': 'jpg',\n\t\t'image/basis': 'basis',\n\t\t'image/ktx': 'ktx',\n\t\t'image/ktx2': 'ktx2',\n\t\t'image/vnd-ms.dds': 'dds'\n\t};\n\tconst loadTexture = (gltfImage, url, bufferView, mimeType, options) => {\n\t\treturn new Promise((resolve, reject) => {\n\t\t\tconst continuation = bufferViewData => {\n\t\t\t\tconst name = (gltfImage.name || 'gltf-texture') + '-' + gltfTextureUniqueId++;\n\t\t\t\tconst file = {\n\t\t\t\t\turl: url || name\n\t\t\t\t};\n\t\t\t\tif (bufferViewData) {\n\t\t\t\t\tfile.contents = bufferViewData.slice(0).buffer;\n\t\t\t\t}\n\t\t\t\tif (mimeType) {\n\t\t\t\t\tconst extension = mimeTypeFileExtensions[mimeType];\n\t\t\t\t\tif (extension) {\n\t\t\t\t\t\tfile.filename = file.url + '.' + extension;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tconst asset = new Asset(name, 'texture', file, null, options);\n\t\t\t\tasset.on('load', asset => resolve(asset));\n\t\t\t\tasset.on('error', err => reject(err));\n\t\t\t\tregistry.add(asset);\n\t\t\t\tregistry.load(asset);\n\t\t\t};\n\t\t\tif (bufferView) {\n\t\t\t\tbufferView.then(bufferViewData => continuation(bufferViewData));\n\t\t\t} else {\n\t\t\t\tcontinuation(null);\n\t\t\t}\n\t\t});\n\t};\n\treturn gltf.images.map((gltfImage, i) => {\n\t\tif (preprocess) {\n\t\t\tpreprocess(gltfImage);\n\t\t}\n\t\tlet promise;\n\t\tif (processAsync) {\n\t\t\tpromise = new Promise((resolve, reject) => {\n\t\t\t\tprocessAsync(gltfImage, (err, textureAsset) => {\n\t\t\t\t\tif (err) reject(err);else resolve(textureAsset);\n\t\t\t\t});\n\t\t\t});\n\t\t} else {\n\t\t\tpromise = new Promise(resolve => {\n\t\t\t\tresolve(null);\n\t\t\t});\n\t\t}\n\t\tpromise = promise.then(textureAsset => {\n\t\t\tif (textureAsset) {\n\t\t\t\treturn textureAsset;\n\t\t\t} else if (gltfImage.hasOwnProperty('uri')) {\n\t\t\t\tif (isDataURI(gltfImage.uri)) {\n\t\t\t\t\treturn loadTexture(gltfImage, gltfImage.uri, null, getDataURIMimeType(gltfImage.uri), null);\n\t\t\t\t}\n\t\t\t\treturn loadTexture(gltfImage, ABSOLUTE_URL.test(gltfImage.uri) ? gltfImage.uri : path.join(urlBase, gltfImage.uri), null, null, {\n\t\t\t\t\tcrossOrigin: 'anonymous'\n\t\t\t\t});\n\t\t\t} else if (gltfImage.hasOwnProperty('bufferView') && gltfImage.hasOwnProperty('mimeType')) {\n\t\t\t\treturn loadTexture(gltfImage, null, bufferViews[gltfImage.bufferView], gltfImage.mimeType, null);\n\t\t\t}\n\t\t\treturn Promise.reject(new Error(`Invalid image found in gltf (neither uri or bufferView found). index=${i}`));\n\t\t});\n\t\tif (postprocess) {\n\t\t\tpromise = promise.then(textureAsset => {\n\t\t\t\tpostprocess(gltfImage, textureAsset);\n\t\t\t\treturn textureAsset;\n\t\t\t});\n\t\t}\n\t\treturn promise;\n\t});\n};\nconst createTextures = (gltf, images, options) => {\n\tvar _gltf$images, _gltf$textures, _options$texture, _options$texture2, _options$texture3;\n\tif (!(gltf != null && (_gltf$images = gltf.images) != null && _gltf$images.length) || !(gltf != null && (_gltf$textures = gltf.textures) != null && _gltf$textures.length)) {\n\t\treturn [];\n\t}\n\tconst preprocess = options == null || (_options$texture = options.texture) == null ? void 0 : _options$texture.preprocess;\n\tconst processAsync = options == null || (_options$texture2 = options.texture) == null ? void 0 : _options$texture2.processAsync;\n\tconst postprocess = options == null || (_options$texture3 = options.texture) == null ? void 0 : _options$texture3.postprocess;\n\tconst seenImages = new Set();\n\treturn gltf.textures.map(gltfTexture => {\n\t\tif (preprocess) {\n\t\t\tpreprocess(gltfTexture);\n\t\t}\n\t\tlet promise;\n\t\tif (processAsync) {\n\t\t\tpromise = new Promise((resolve, reject) => {\n\t\t\t\tprocessAsync(gltfTexture, gltf.images, (err, gltfImageIndex) => {\n\t\t\t\t\tif (err) reject(err);else resolve(gltfImageIndex);\n\t\t\t\t});\n\t\t\t});\n\t\t} else {\n\t\t\tpromise = new Promise(resolve => {\n\t\t\t\tresolve(null);\n\t\t\t});\n\t\t}\n\t\tpromise = promise.then(gltfImageIndex => {\n\t\t\tvar _ref, _ref2, _gltfImageIndex, _gltfTexture$extensio, _gltfTexture$extensio2;\n\t\t\tgltfImageIndex = (_ref = (_ref2 = (_gltfImageIndex = gltfImageIndex) != null ? _gltfImageIndex : gltfTexture == null || (_gltfTexture$extensio = gltfTexture.extensions) == null || (_gltfTexture$extensio = _gltfTexture$extensio.KHR_texture_basisu) == null ? void 0 : _gltfTexture$extensio.source) != null ? _ref2 : gltfTexture == null || (_gltfTexture$extensio2 = gltfTexture.extensions) == null || (_gltfTexture$extensio2 = _gltfTexture$extensio2.EXT_texture_webp) == null ? void 0 : _gltfTexture$extensio2.source) != null ? _ref : gltfTexture.source;\n\t\t\tconst cloneAsset = seenImages.has(gltfImageIndex);\n\t\t\tseenImages.add(gltfImageIndex);\n\t\t\treturn images[gltfImageIndex].then(imageAsset => {\n\t\t\t\tvar _gltf$samplers;\n\t\t\t\tconst asset = cloneAsset ? cloneTextureAsset(imageAsset) : imageAsset;\n\t\t\t\tapplySampler(asset.resource, ((_gltf$samplers = gltf.samplers) != null ? _gltf$samplers : [])[gltfTexture.sampler]);\n\t\t\t\treturn asset;\n\t\t\t});\n\t\t});\n\t\tif (postprocess) {\n\t\t\tpromise = promise.then(textureAsset => {\n\t\t\t\tpostprocess(gltfTexture, textureAsset);\n\t\t\t\treturn textureAsset;\n\t\t\t});\n\t\t}\n\t\treturn promise;\n\t});\n};\nconst loadBuffers = (gltf, binaryChunk, urlBase, options) => {\n\tvar _options$buffer, _options$buffer2, _options$buffer3;\n\tif (!gltf.buffers || gltf.buffers.length === 0) {\n\t\treturn [];\n\t}\n\tconst preprocess = options == null || (_options$buffer = options.buffer) == null ? void 0 : _options$buffer.preprocess;\n\tconst processAsync = options == null || (_options$buffer2 = options.buffer) == null ? void 0 : _options$buffer2.processAsync;\n\tconst postprocess = options == null || (_options$buffer3 = options.buffer) == null ? void 0 : _options$buffer3.postprocess;\n\treturn gltf.buffers.map((gltfBuffer, i) => {\n\t\tif (preprocess) {\n\t\t\tpreprocess(gltfBuffer);\n\t\t}\n\t\tlet promise;\n\t\tif (processAsync) {\n\t\t\tpromise = new Promise((resolve, reject) => {\n\t\t\t\tprocessAsync(gltfBuffer, (err, arrayBuffer) => {\n\t\t\t\t\tif (err) reject(err);else resolve(arrayBuffer);\n\t\t\t\t});\n\t\t\t});\n\t\t} else {\n\t\t\tpromise = new Promise(resolve => {\n\t\t\t\tresolve(null);\n\t\t\t});\n\t\t}\n\t\tpromise = promise.then(arrayBuffer => {\n\t\t\tif (arrayBuffer) {\n\t\t\t\treturn arrayBuffer;\n\t\t\t} else if (gltfBuffer.hasOwnProperty('uri')) {\n\t\t\t\tif (isDataURI(gltfBuffer.uri)) {\n\t\t\t\t\tconst byteString = atob(gltfBuffer.uri.split(',')[1]);\n\t\t\t\t\tconst binaryArray = new Uint8Array(byteString.length);\n\t\t\t\t\tfor (let j = 0; j < byteString.length; j++) {\n\t\t\t\t\t\tbinaryArray[j] = byteString.charCodeAt(j);\n\t\t\t\t\t}\n\t\t\t\t\treturn binaryArray;\n\t\t\t\t}\n\t\t\t\treturn new Promise((resolve, reject) => {\n\t\t\t\t\thttp.get(ABSOLUTE_URL.test(gltfBuffer.uri) ? gltfBuffer.uri : path.join(urlBase, gltfBuffer.uri), {\n\t\t\t\t\t\tcache: true,\n\t\t\t\t\t\tresponseType: 'arraybuffer',\n\t\t\t\t\t\tretry: false\n\t\t\t\t\t}, (err, result) => {\n\t\t\t\t\t\tif (err) reject(err);else resolve(new Uint8Array(result));\n\t\t\t\t\t});\n\t\t\t\t});\n\t\t\t}\n\t\t\treturn binaryChunk;\n\t\t});\n\t\tif (postprocess) {\n\t\t\tpromise = promise.then(buffer => {\n\t\t\t\tpostprocess(gltf.buffers[i], buffer);\n\t\t\t\treturn buffer;\n\t\t\t});\n\t\t}\n\t\treturn promise;\n\t});\n};\nconst parseGltf = (gltfChunk, callback) => {\n\tconst decodeBinaryUtf8 = array => {\n\t\tif (typeof TextDecoder !== 'undefined') {\n\t\t\treturn new TextDecoder().decode(array);\n\t\t}\n\t\tlet str = '';\n\t\tfor (let i = 0; i < array.length; i++) {\n\t\t\tstr += String.fromCharCode(array[i]);\n\t\t}\n\t\treturn decodeURIComponent(escape(str));\n\t};\n\tconst gltf = JSON.parse(decodeBinaryUtf8(gltfChunk));\n\tif (gltf.asset && gltf.asset.version && parseFloat(gltf.asset.version) < 2) {\n\t\tcallback(`Invalid gltf version. Expected version 2.0 or above but found version '${gltf.asset.version}'.`);\n\t\treturn;\n\t}\n\tcallback(null, gltf);\n};\nconst parseGlb = (glbData, callback) => {\n\tconst data = glbData instanceof ArrayBuffer ? new DataView(glbData) : new DataView(glbData.buffer, glbData.byteOffset, glbData.byteLength);\n\tconst magic = data.getUint32(0, true);\n\tconst version = data.getUint32(4, true);\n\tconst length = data.getUint32(8, true);\n\tif (magic !== 0x46546C67) {\n\t\tcallback('Invalid magic number found in glb header. Expected 0x46546C67, found 0x' + magic.toString(16));\n\t\treturn;\n\t}\n\tif (version !== 2) {\n\t\tcallback('Invalid version number found in glb header. Expected 2, found ' + version);\n\t\treturn;\n\t}\n\tif (length <= 0 || length > data.byteLength) {\n\t\tcallback('Invalid length found in glb header. Found ' + length);\n\t\treturn;\n\t}\n\tconst chunks = [];\n\tlet offset = 12;\n\twhile (offset < length) {\n\t\tconst chunkLength = data.getUint32(offset, true);\n\t\tif (offset + chunkLength + 8 > data.byteLength) {\n\t\t\tcallback(`Invalid chunk length found in glb. Found ${chunkLength}`);\n\t\t}\n\t\tconst chunkType = data.getUint32(offset + 4, true);\n\t\tconst chunkData = new Uint8Array(data.buffer, data.byteOffset + offset + 8, chunkLength);\n\t\tchunks.push({\n\t\t\tlength: chunkLength,\n\t\t\ttype: chunkType,\n\t\t\tdata: chunkData\n\t\t});\n\t\toffset += chunkLength + 8;\n\t}\n\tif (chunks.length !== 1 && chunks.length !== 2) {\n\t\tcallback('Invalid number of chunks found in glb file.');\n\t\treturn;\n\t}\n\tif (chunks[0].type !== 0x4E4F534A) {\n\t\tcallback(`Invalid chunk type found in glb file. Expected 0x4E4F534A, found 0x${chunks[0].type.toString(16)}`);\n\t\treturn;\n\t}\n\tif (chunks.length > 1 && chunks[1].type !== 0x004E4942) {\n\t\tcallback(`Invalid chunk type found in glb file. Expected 0x004E4942, found 0x${chunks[1].type.toString(16)}`);\n\t\treturn;\n\t}\n\tcallback(null, {\n\t\tgltfChunk: chunks[0].data,\n\t\tbinaryChunk: chunks.length === 2 ? chunks[1].data : null\n\t});\n};\nconst parseChunk = (filename, data, callback) => {\n\tconst hasGlbHeader = () => {\n\t\tconst u8 = new Uint8Array(data);\n\t\treturn u8[0] === 103 && u8[1] === 108 && u8[2] === 84 && u8[3] === 70;\n\t};\n\tif (filename && filename.toLowerCase().endsWith('.glb') || hasGlbHeader()) {\n\t\tparseGlb(data, callback);\n\t} else {\n\t\tcallback(null, {\n\t\t\tgltfChunk: data,\n\t\t\tbinaryChunk: null\n\t\t});\n\t}\n};\nconst createBufferViews = (gltf, buffers, options) => {\n\tvar _options$bufferView, _options$bufferView2, _options$bufferView3, _gltf$bufferViews2;\n\tconst result = [];\n\tconst preprocess = options == null || (_options$bufferView = options.bufferView) == null ? void 0 : _options$bufferView.preprocess;\n\tconst processAsync = options == null || (_options$bufferView2 = options.bufferView) == null ? void 0 : _options$bufferView2.processAsync;\n\tconst postprocess = options == null || (_options$bufferView3 = options.bufferView) == null ? void 0 : _options$bufferView3.postprocess;\n\tif (!((_gltf$bufferViews2 = gltf.bufferViews) != null && _gltf$bufferViews2.length)) {\n\t\treturn result;\n\t}\n\tfor (let i = 0; i < gltf.bufferViews.length; ++i) {\n\t\tconst gltfBufferView = gltf.bufferViews[i];\n\t\tif (preprocess) {\n\t\t\tpreprocess(gltfBufferView);\n\t\t}\n\t\tlet promise;\n\t\tif (processAsync) {\n\t\t\tpromise = new Promise((resolve, reject) => {\n\t\t\t\tprocessAsync(gltfBufferView, buffers, (err, result) => {\n\t\t\t\t\tif (err) reject(err);else resolve(result);\n\t\t\t\t});\n\t\t\t});\n\t\t} else {\n\t\t\tpromise = new Promise(resolve => {\n\t\t\t\tresolve(null);\n\t\t\t});\n\t\t}\n\t\tpromise = promise.then(buffer => {\n\t\t\tif (buffer) {\n\t\t\t\treturn buffer;\n\t\t\t}\n\t\t\treturn buffers[gltfBufferView.buffer].then(buffer => {\n\t\t\t\treturn new Uint8Array(buffer.buffer, buffer.byteOffset + (gltfBufferView.byteOffset || 0), gltfBufferView.byteLength);\n\t\t\t});\n\t\t});\n\t\tif (gltfBufferView.hasOwnProperty('byteStride')) {\n\t\t\tpromise = promise.then(typedArray => {\n\t\t\t\ttypedArray.byteStride = gltfBufferView.byteStride;\n\t\t\t\treturn typedArray;\n\t\t\t});\n\t\t}\n\t\tif (postprocess) {\n\t\t\tpromise = promise.then(typedArray => {\n\t\t\t\tpostprocess(gltfBufferView, typedArray);\n\t\t\t\treturn typedArray;\n\t\t\t});\n\t\t}\n\t\tresult.push(promise);\n\t}\n\treturn result;\n};\nclass GlbParser {\n\tstatic parse(filename, urlBase, data, device, registry, options, callback) {\n\t\tparseChunk(filename, data, (err, chunks) => {\n\t\t\tif (err) {\n\t\t\t\tcallback(err);\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tparseGltf(chunks.gltfChunk, (err, gltf) => {\n\t\t\t\tif (err) {\n\t\t\t\t\tcallback(err);\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tconst buffers = loadBuffers(gltf, chunks.binaryChunk, urlBase, options);\n\t\t\t\tconst bufferViews = createBufferViews(gltf, buffers, options);\n\t\t\t\tconst images = createImages(gltf, bufferViews, urlBase, registry, options);\n\t\t\t\tconst textures = createTextures(gltf, images, options);\n\t\t\t\tcreateResources(device, gltf, bufferViews, textures, options).then(result => callback(null, result)).catch(err => callback(err));\n\t\t\t});\n\t\t});\n\t}\n\tstatic createDefaultMaterial() {\n\t\treturn createMaterial({\n\t\t\tname: 'defaultGlbMaterial'\n\t\t}, []);\n\t}\n}\n\nexport { GlbParser };\n", "import { path } from '../../core/path.js';\nimport { Quat } from '../../core/math/quat.js';\nimport { Vec3 } from '../../core/math/vec3.js';\nimport { Http, http } from '../../platform/net/http.js';\nimport { Animation, Node, Key } from '../../scene/animation/animation.js';\nimport { AnimEvents } from '../anim/evaluator/anim-events.js';\nimport { GlbParser } from '../parsers/glb-parser.js';\nimport { ResourceHandler } from './handler.js';\n\nclass AnimationHandler extends ResourceHandler {\n\tconstructor(app) {\n\t\tsuper(app, 'animation');\n\t\tthis.device = app.graphicsDevice;\n\t\tthis.assets = app.assets;\n\t}\n\tload(url, callback, asset) {\n\t\tif (typeof url === 'string') {\n\t\t\turl = {\n\t\t\t\tload: url,\n\t\t\t\toriginal: url\n\t\t\t};\n\t\t}\n\t\tconst options = {\n\t\t\tretry: this.maxRetries > 0,\n\t\t\tmaxRetries: this.maxRetries\n\t\t};\n\t\tif (url.load.startsWith('blob:') || url.load.startsWith('data:')) {\n\t\t\tif (path.getExtension(url.original).toLowerCase() === '.glb') {\n\t\t\t\toptions.responseType = Http.ResponseType.ARRAY_BUFFER;\n\t\t\t} else {\n\t\t\t\toptions.responseType = Http.ResponseType.JSON;\n\t\t\t}\n\t\t}\n\t\thttp.get(url.load, options, (err, response) => {\n\t\t\tif (err) {\n\t\t\t\tcallback(`Error loading animation resource: ${url.original} [${err}]`);\n\t\t\t} else {\n\t\t\t\tif (path.getExtension(url.original).toLowerCase() === '.glb') {\n\t\t\t\t\tvar _asset$options;\n\t\t\t\t\tGlbParser.parse('filename.glb', '', response, this.device, this.assets, (_asset$options = asset == null ? void 0 : asset.options) != null ? _asset$options : {}, (err, parseResult) => {\n\t\t\t\t\t\tif (err) {\n\t\t\t\t\t\t\tcallback(err);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tvar _asset$data;\n\t\t\t\t\t\t\tconst animations = parseResult.animations;\n\t\t\t\t\t\t\tif (asset != null && (_asset$data = asset.data) != null && _asset$data.events) {\n\t\t\t\t\t\t\t\tfor (let i = 0; i < animations.length; i++) {\n\t\t\t\t\t\t\t\t\tanimations[i].events = new AnimEvents(Object.values(asset.data.events));\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tparseResult.destroy();\n\t\t\t\t\t\t\tcallback(null, animations);\n\t\t\t\t\t\t}\n\t\t\t\t\t});\n\t\t\t\t} else {\n\t\t\t\t\tcallback(null, this['_parseAnimationV' + response.animation.version](response));\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t}\n\topen(url, data, asset) {\n\t\treturn data;\n\t}\n\t_parseAnimationV3(data) {\n\t\tconst animData = data.animation;\n\t\tconst anim = new Animation();\n\t\tanim.name = animData.name;\n\t\tanim.duration = animData.duration;\n\t\tfor (let i = 0; i < animData.nodes.length; i++) {\n\t\t\tconst node = new Node();\n\t\t\tconst n = animData.nodes[i];\n\t\t\tnode._name = n.name;\n\t\t\tfor (let j = 0; j < n.keys.length; j++) {\n\t\t\t\tconst k = n.keys[j];\n\t\t\t\tconst t = k.time;\n\t\t\t\tconst p = k.pos;\n\t\t\t\tconst r = k.rot;\n\t\t\t\tconst s = k.scale;\n\t\t\t\tconst pos = new Vec3(p[0], p[1], p[2]);\n\t\t\t\tconst rot = new Quat().setFromEulerAngles(r[0], r[1], r[2]);\n\t\t\t\tconst scl = new Vec3(s[0], s[1], s[2]);\n\t\t\t\tconst key = new Key(t, pos, rot, scl);\n\t\t\t\tnode._keys.push(key);\n\t\t\t}\n\t\t\tanim.addNode(node);\n\t\t}\n\t\treturn anim;\n\t}\n\t_parseAnimationV4(data) {\n\t\tconst animData = data.animation;\n\t\tconst anim = new Animation();\n\t\tanim.name = animData.name;\n\t\tanim.duration = animData.duration;\n\t\tfor (let i = 0; i < animData.nodes.length; i++) {\n\t\t\tconst node = new Node();\n\t\t\tconst n = animData.nodes[i];\n\t\t\tnode._name = n.name;\n\t\t\tconst defPos = n.defaults.p;\n\t\t\tconst defRot = n.defaults.r;\n\t\t\tconst defScl = n.defaults.s;\n\t\t\tfor (let j = 0; j < n.keys.length; j++) {\n\t\t\t\tconst k = n.keys[j];\n\t\t\t\tconst t = k.t;\n\t\t\t\tconst p = defPos ? defPos : k.p;\n\t\t\t\tconst r = defRot ? defRot : k.r;\n\t\t\t\tconst s = defScl ? defScl : k.s;\n\t\t\t\tconst pos = new Vec3(p[0], p[1], p[2]);\n\t\t\t\tconst rot = new Quat().setFromEulerAngles(r[0], r[1], r[2]);\n\t\t\t\tconst scl = new Vec3(s[0], s[1], s[2]);\n\t\t\t\tconst key = new Key(t, pos, rot, scl);\n\t\t\t\tnode._keys.push(key);\n\t\t\t}\n\t\t\tanim.addNode(node);\n\t\t}\n\t\treturn anim;\n\t}\n}\n\nexport { AnimationHandler };\n", "import { path } from '../../core/path.js';\nimport { Http, http } from '../../platform/net/http.js';\nimport { hasAudioContext } from '../../platform/audio/capabilities.js';\nimport { Sound } from '../../platform/sound/sound.js';\nimport { ResourceHandler } from './handler.js';\n\nconst ie = function () {\n\tif (typeof window === 'undefined') {\n\t\treturn false;\n\t}\n\tconst ua = window.navigator.userAgent;\n\tconst msie = ua.indexOf('MSIE ');\n\tif (msie > 0) {\n\t\treturn parseInt(ua.substring(msie + 5, ua.indexOf('.', msie)), 10);\n\t}\n\tconst trident = ua.indexOf('Trident/');\n\tif (trident > 0) {\n\t\tconst rv = ua.indexOf('rv:');\n\t\treturn parseInt(ua.substring(rv + 3, ua.indexOf('.', rv)), 10);\n\t}\n\treturn false;\n}();\nconst supportedExtensions = ['.ogg', '.mp3', '.wav', '.mp4a', '.m4a', '.mp4', '.aac', '.opus'];\nclass AudioHandler extends ResourceHandler {\n\tconstructor(app) {\n\t\tsuper(app, 'audio');\n\t\tthis.manager = app.soundManager;\n\t}\n\t_isSupported(url) {\n\t\tconst ext = path.getExtension(url);\n\t\treturn supportedExtensions.indexOf(ext) > -1;\n\t}\n\tload(url, callback) {\n\t\tif (typeof url === 'string') {\n\t\t\turl = {\n\t\t\t\tload: url,\n\t\t\t\toriginal: url\n\t\t\t};\n\t\t}\n\t\tconst success = function success(resource) {\n\t\t\tcallback(null, new Sound(resource));\n\t\t};\n\t\tconst error = function error(err) {\n\t\t\tlet msg = 'Error loading audio url: ' + url.original;\n\t\t\tif (err) {\n\t\t\t\tmsg += ': ' + (err.message || err);\n\t\t\t}\n\t\t\tconsole.warn(msg);\n\t\t\tcallback(msg);\n\t\t};\n\t\tif (this._createSound) {\n\t\t\tif (!this._isSupported(url.original)) {\n\t\t\t\terror(`Audio format for ${url.original} not supported`);\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tthis._createSound(url.load, success, error);\n\t\t} else {\n\t\t\terror(null);\n\t\t}\n\t}\n\t_createSound(url, success, error) {\n\t\tif (hasAudioContext()) {\n\t\t\tconst manager = this.manager;\n\t\t\tif (!manager.context) {\n\t\t\t\terror('Audio manager has no audio context');\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tconst options = {\n\t\t\t\tretry: this.maxRetries > 0,\n\t\t\t\tmaxRetries: this.maxRetries\n\t\t\t};\n\t\t\tif (url.startsWith('blob:') || url.startsWith('data:')) {\n\t\t\t\toptions.responseType = Http.ResponseType.ARRAY_BUFFER;\n\t\t\t}\n\t\t\thttp.get(url, options, function (err, response) {\n\t\t\t\tif (err) {\n\t\t\t\t\terror(err);\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tmanager.context.decodeAudioData(response, success, error);\n\t\t\t});\n\t\t} else {\n\t\t\tlet audio = null;\n\t\t\ttry {\n\t\t\t\taudio = new Audio();\n\t\t\t} catch (e) {\n\t\t\t\terror('No support for Audio element');\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif (ie) {\n\t\t\t\tdocument.body.appendChild(audio);\n\t\t\t}\n\t\t\tconst onReady = function onReady() {\n\t\t\t\taudio.removeEventListener('canplaythrough', onReady);\n\t\t\t\tif (ie) {\n\t\t\t\t\tdocument.body.removeChild(audio);\n\t\t\t\t}\n\t\t\t\tsuccess(audio);\n\t\t\t};\n\t\t\taudio.onerror = function () {\n\t\t\t\taudio.onerror = null;\n\t\t\t\tif (ie) {\n\t\t\t\t\tdocument.body.removeChild(audio);\n\t\t\t\t}\n\t\t\t\terror();\n\t\t\t};\n\t\t\taudio.addEventListener('canplaythrough', onReady);\n\t\t\taudio.src = url;\n\t\t}\n\t}\n}\n\nexport { AudioHandler };\n", "import { GraphNode } from '../../scene/graph-node.js';\nimport { MeshInstance } from '../../scene/mesh-instance.js';\nimport { Model } from '../../scene/model.js';\nimport { MorphInstance } from '../../scene/morph-instance.js';\nimport { SkinInstance } from '../../scene/skin-instance.js';\nimport { SkinInstanceCache } from '../../scene/skin-instance-cache.js';\nimport { Entity } from '../entity.js';\nimport { Asset } from '../asset/asset.js';\n\nclass GlbContainerResource {\n\tconstructor(data, asset, assets, defaultMaterial) {\n\t\tconst createAsset = function createAsset(type, resource, index) {\n\t\t\tconst subAsset = GlbContainerResource.createAsset(asset.name, type, resource, index);\n\t\t\tassets.add(subAsset);\n\t\t\treturn subAsset;\n\t\t};\n\t\tconst renders = [];\n\t\tfor (let i = 0; i < data.renders.length; ++i) {\n\t\t\trenders.push(createAsset('render', data.renders[i], i));\n\t\t}\n\t\tconst materials = [];\n\t\tfor (let i = 0; i < data.materials.length; ++i) {\n\t\t\tmaterials.push(createAsset('material', data.materials[i], i));\n\t\t}\n\t\tconst animations = [];\n\t\tfor (let i = 0; i < data.animations.length; ++i) {\n\t\t\tanimations.push(createAsset('animation', data.animations[i], i));\n\t\t}\n\t\tthis.data = data;\n\t\tthis._model = null;\n\t\tthis._assetName = asset.name;\n\t\tthis._assets = assets;\n\t\tthis._defaultMaterial = defaultMaterial;\n\t\tthis.renders = renders;\n\t\tthis.materials = materials;\n\t\tthis.textures = data.textures;\n\t\tthis.animations = animations;\n\t}\n\tget model() {\n\t\tif (!this._model) {\n\t\t\tconst model = GlbContainerResource.createModel(this.data, this._defaultMaterial);\n\t\t\tconst modelAsset = GlbContainerResource.createAsset(this._assetName, 'model', model, 0);\n\t\t\tthis._assets.add(modelAsset);\n\t\t\tthis._model = modelAsset;\n\t\t}\n\t\treturn this._model;\n\t}\n\tstatic createAsset(assetName, type, resource, index) {\n\t\tconst subAsset = new Asset(assetName + '/' + type + '/' + index, type, {\n\t\t\turl: ''\n\t\t});\n\t\tsubAsset.resource = resource;\n\t\tsubAsset.loaded = true;\n\t\treturn subAsset;\n\t}\n\tinstantiateModelEntity(options) {\n\t\tconst entity = new Entity();\n\t\tentity.addComponent('model', Object.assign({\n\t\t\ttype: 'asset',\n\t\t\tasset: this.model\n\t\t}, options));\n\t\treturn entity;\n\t}\n\tinstantiateRenderEntity(options) {\n\t\tconst defaultMaterial = this._defaultMaterial;\n\t\tconst skinnedMeshInstances = [];\n\t\tconst createMeshInstance = function createMeshInstance(root, entity, mesh, materials, meshDefaultMaterials, skins, gltfNode) {\n\t\t\tconst materialIndex = meshDefaultMaterials[mesh.id];\n\t\t\tconst material = materialIndex === undefined ? defaultMaterial : materials[materialIndex];\n\t\t\tconst meshInstance = new MeshInstance(mesh, material);\n\t\t\tif (mesh.morph) {\n\t\t\t\tmeshInstance.morphInstance = new MorphInstance(mesh.morph);\n\t\t\t}\n\t\t\tif (gltfNode.hasOwnProperty('skin')) {\n\t\t\t\tskinnedMeshInstances.push({\n\t\t\t\t\tmeshInstance: meshInstance,\n\t\t\t\t\trootBone: root,\n\t\t\t\t\tentity: entity\n\t\t\t\t});\n\t\t\t}\n\t\t\treturn meshInstance;\n\t\t};\n\t\tconst cloneHierarchy = (root, node, glb) => {\n\t\t\tconst entity = new Entity();\n\t\t\tnode._cloneInternal(entity);\n\t\t\tif (!root) root = entity;\n\t\t\tlet attachedMi = null;\n\t\t\tlet renderAsset = null;\n\t\t\tfor (let i = 0; i < glb.nodes.length; i++) {\n\t\t\t\tconst glbNode = glb.nodes[i];\n\t\t\t\tif (glbNode === node) {\n\t\t\t\t\tconst gltfNode = glb.gltf.nodes[i];\n\t\t\t\t\tif (gltfNode.hasOwnProperty('mesh')) {\n\t\t\t\t\t\tconst meshGroup = glb.renders[gltfNode.mesh].meshes;\n\t\t\t\t\t\trenderAsset = this.renders[gltfNode.mesh];\n\t\t\t\t\t\tfor (let mi = 0; mi < meshGroup.length; mi++) {\n\t\t\t\t\t\t\tconst mesh = meshGroup[mi];\n\t\t\t\t\t\t\tif (mesh) {\n\t\t\t\t\t\t\t\tconst cloneMi = createMeshInstance(root, entity, mesh, glb.materials, glb.meshDefaultMaterials, glb.skins, gltfNode);\n\t\t\t\t\t\t\t\tif (!attachedMi) {\n\t\t\t\t\t\t\t\t\tattachedMi = [];\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tattachedMi.push(cloneMi);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif (glb.lights) {\n\t\t\t\t\t\tconst lightEntity = glb.lights.get(gltfNode);\n\t\t\t\t\t\tif (lightEntity) {\n\t\t\t\t\t\t\tentity.addChild(lightEntity.clone());\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif (glb.cameras) {\n\t\t\t\t\t\tconst cameraEntity = glb.cameras.get(gltfNode);\n\t\t\t\t\t\tif (cameraEntity) {\n\t\t\t\t\t\t\tcameraEntity.camera.system.cloneComponent(cameraEntity, entity);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (attachedMi) {\n\t\t\t\tentity.addComponent('render', Object.assign({\n\t\t\t\t\ttype: 'asset',\n\t\t\t\t\tmeshInstances: attachedMi,\n\t\t\t\t\trootBone: root\n\t\t\t\t}, options));\n\t\t\t\tentity.render.assignAsset(renderAsset);\n\t\t\t}\n\t\t\tconst children = node.children;\n\t\t\tfor (let i = 0; i < children.length; i++) {\n\t\t\t\tconst childClone = cloneHierarchy(root, children[i], glb);\n\t\t\t\tentity.addChild(childClone);\n\t\t\t}\n\t\t\treturn entity;\n\t\t};\n\t\tconst sceneClones = [];\n\t\tfor (const scene of this.data.scenes) {\n\t\t\tsceneClones.push(cloneHierarchy(null, scene, this.data));\n\t\t}\n\t\tskinnedMeshInstances.forEach(data => {\n\t\t\tdata.meshInstance.skinInstance = SkinInstanceCache.createCachedSkinInstance(data.meshInstance.mesh.skin, data.rootBone, data.entity);\n\t\t});\n\t\treturn GlbContainerResource.createSceneHierarchy(sceneClones, Entity);\n\t}\n\tgetMaterialVariants() {\n\t\treturn this.data.variants ? Object.keys(this.data.variants) : [];\n\t}\n\tapplyMaterialVariant(entity, name) {\n\t\tconst variant = name ? this.data.variants[name] : null;\n\t\tif (variant === undefined) {\n\t\t\treturn;\n\t\t}\n\t\tconst renders = entity.findComponents(\"render\");\n\t\tfor (let i = 0; i < renders.length; i++) {\n\t\t\tconst renderComponent = renders[i];\n\t\t\tthis._applyMaterialVariant(variant, renderComponent.meshInstances);\n\t\t}\n\t}\n\tapplyMaterialVariantInstances(instances, name) {\n\t\tconst variant = name ? this.data.variants[name] : null;\n\t\tif (variant === undefined) {\n\t\t\treturn;\n\t\t}\n\t\tthis._applyMaterialVariant(variant, instances);\n\t}\n\t_applyMaterialVariant(variant, instances) {\n\t\tinstances.forEach(instance => {\n\t\t\tif (variant === null) {\n\t\t\t\tinstance.material = this._defaultMaterial;\n\t\t\t} else {\n\t\t\t\tconst meshVariants = this.data.meshVariants[instance.mesh.id];\n\t\t\t\tif (meshVariants) {\n\t\t\t\t\tinstance.material = this.data.materials[meshVariants[variant]];\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t}\n\tstatic createSceneHierarchy(sceneNodes, nodeType) {\n\t\tlet root = null;\n\t\tif (sceneNodes.length === 1) {\n\t\t\troot = sceneNodes[0];\n\t\t} else {\n\t\t\troot = new nodeType('SceneGroup');\n\t\t\tfor (const scene of sceneNodes) {\n\t\t\t\troot.addChild(scene);\n\t\t\t}\n\t\t}\n\t\treturn root;\n\t}\n\tstatic createModel(glb, defaultMaterial) {\n\t\tconst createMeshInstance = function createMeshInstance(model, mesh, skins, skinInstances, materials, node, gltfNode) {\n\t\t\tconst materialIndex = glb.meshDefaultMaterials[mesh.id];\n\t\t\tconst material = materialIndex === undefined ? defaultMaterial : materials[materialIndex];\n\t\t\tconst meshInstance = new MeshInstance(mesh, material, node);\n\t\t\tif (mesh.morph) {\n\t\t\t\tconst morphInstance = new MorphInstance(mesh.morph);\n\t\t\t\tmeshInstance.morphInstance = morphInstance;\n\t\t\t\tmodel.morphInstances.push(morphInstance);\n\t\t\t}\n\t\t\tif (gltfNode.hasOwnProperty('skin')) {\n\t\t\t\tconst skinIndex = gltfNode.skin;\n\t\t\t\tconst skin = skins[skinIndex];\n\t\t\t\tmesh.skin = skin;\n\t\t\t\tconst skinInstance = skinInstances[skinIndex];\n\t\t\t\tmeshInstance.skinInstance = skinInstance;\n\t\t\t\tmodel.skinInstances.push(skinInstance);\n\t\t\t}\n\t\t\tmodel.meshInstances.push(meshInstance);\n\t\t};\n\t\tconst model = new Model();\n\t\tconst skinInstances = [];\n\t\tfor (const skin of glb.skins) {\n\t\t\tconst skinInstance = new SkinInstance(skin);\n\t\t\tskinInstance.bones = skin.bones;\n\t\t\tskinInstances.push(skinInstance);\n\t\t}\n\t\tmodel.graph = GlbContainerResource.createSceneHierarchy(glb.scenes, GraphNode);\n\t\tfor (let i = 0; i < glb.nodes.length; i++) {\n\t\t\tconst node = glb.nodes[i];\n\t\t\tif (node.root === model.graph) {\n\t\t\t\tconst gltfNode = glb.gltf.nodes[i];\n\t\t\t\tif (gltfNode.hasOwnProperty('mesh')) {\n\t\t\t\t\tconst meshGroup = glb.renders[gltfNode.mesh].meshes;\n\t\t\t\t\tfor (let mi = 0; mi < meshGroup.length; mi++) {\n\t\t\t\t\t\tconst mesh = meshGroup[mi];\n\t\t\t\t\t\tif (mesh) {\n\t\t\t\t\t\t\tcreateMeshInstance(model, mesh, glb.skins, skinInstances, glb.materials, node, gltfNode);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn model;\n\t}\n\tdestroy() {\n\t\tconst registry = this._assets;\n\t\tconst destroyAsset = function destroyAsset(asset) {\n\t\t\tregistry.remove(asset);\n\t\t\tasset.unload();\n\t\t};\n\t\tconst destroyAssets = function destroyAssets(assets) {\n\t\t\tassets.forEach(function (asset) {\n\t\t\t\tdestroyAsset(asset);\n\t\t\t});\n\t\t};\n\t\tif (this.animations) {\n\t\t\tdestroyAssets(this.animations);\n\t\t\tthis.animations = null;\n\t\t}\n\t\tif (this.textures) {\n\t\t\tdestroyAssets(this.textures);\n\t\t\tthis.textures = null;\n\t\t}\n\t\tif (this.materials) {\n\t\t\tdestroyAssets(this.materials);\n\t\t\tthis.materials = null;\n\t\t}\n\t\tif (this.renders) {\n\t\t\tdestroyAssets(this.renders);\n\t\t\tthis.renders = null;\n\t\t}\n\t\tif (this._model) {\n\t\t\tdestroyAsset(this._model);\n\t\t\tthis._model = null;\n\t\t}\n\t\tthis.data = null;\n\t\tthis.assets = null;\n\t}\n}\n\nexport { GlbContainerResource };\n", "import { path } from '../../core/path.js';\nimport { Asset } from '../asset/asset.js';\nimport { GlbParser } from './glb-parser.js';\nimport { GlbContainerResource } from './glb-container-resource.js';\n\nclass GlbContainerParser {\n\tconstructor(device, assets, maxRetries) {\n\t\tthis._device = device;\n\t\tthis._assets = assets;\n\t\tthis._defaultMaterial = GlbParser.createDefaultMaterial();\n\t\tthis.maxRetries = maxRetries;\n\t}\n\t_getUrlWithoutParams(url) {\n\t\treturn url.indexOf('?') >= 0 ? url.split('?')[0] : url;\n\t}\n\tload(url, callback, asset) {\n\t\tAsset.fetchArrayBuffer(url.load, (err, result) => {\n\t\t\tif (err) {\n\t\t\t\tcallback(err);\n\t\t\t} else {\n\t\t\t\tGlbParser.parse(this._getUrlWithoutParams(url.original), path.extractPath(url.load), result, this._device, asset.registry, asset.options, (err, result) => {\n\t\t\t\t\tif (err) {\n\t\t\t\t\t\tcallback(err);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tcallback(null, new GlbContainerResource(result, asset, this._assets, this._defaultMaterial));\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t}\n\t\t}, asset, this.maxRetries);\n\t}\n\topen(url, data, asset) {\n\t\treturn data;\n\t}\n\tpatch(asset, assets) {}\n}\n\nexport { GlbContainerParser };\n", "import { path } from '../../core/path.js';\nimport { GlbContainerParser } from '../parsers/glb-container-parser.js';\nimport { ResourceHandler } from './handler.js';\n\nclass ContainerResource {\n\tinstantiateModelEntity(options) {\n\t\treturn null;\n\t}\n\tinstantiateRenderEntity(options) {\n\t\treturn null;\n\t}\n\tgetMaterialVariants() {\n\t\treturn null;\n\t}\n\tapplyMaterialVariant(entity, name) {}\n\tapplyMaterialVariantInstances(instances, name) {}\n}\nclass ContainerHandler extends ResourceHandler {\n\tconstructor(app) {\n\t\tsuper(app, 'container');\n\t\tthis.glbContainerParser = new GlbContainerParser(app.graphicsDevice, app.assets, 0);\n\t\tthis.parsers = {};\n\t}\n\tset maxRetries(value) {\n\t\tthis.glbContainerParser.maxRetries = value;\n\t\tfor (const parser in this.parsers) {\n\t\t\tif (this.parsers.hasOwnProperty(parser)) {\n\t\t\t\tthis.parsers[parser].maxRetries = value;\n\t\t\t}\n\t\t}\n\t}\n\tget maxRetries() {\n\t\treturn this.glbContainerParser.maxRetries;\n\t}\n\t_getUrlWithoutParams(url) {\n\t\treturn url.indexOf('?') >= 0 ? url.split('?')[0] : url;\n\t}\n\t_getParser(url) {\n\t\tconst ext = url ? path.getExtension(this._getUrlWithoutParams(url)).toLowerCase().replace('.', '') : null;\n\t\treturn this.parsers[ext] || this.glbContainerParser;\n\t}\n\tload(url, callback, asset) {\n\t\tif (typeof url === 'string') {\n\t\t\turl = {\n\t\t\t\tload: url,\n\t\t\t\toriginal: url\n\t\t\t};\n\t\t}\n\t\tthis._getParser(url.original).load(url, callback, asset);\n\t}\n\topen(url, data, asset) {\n\t\treturn this._getParser(url).open(url, data, asset);\n\t}\n}\n\nexport { ContainerHandler, ContainerResource };\n", "import { GlbContainerResource } from './glb-container-resource.js';\nimport { GlbParser } from './glb-parser.js';\n\nclass GlbModelParser {\n\tconstructor(modelHandler) {\n\t\tthis._device = modelHandler.device;\n\t\tthis._defaultMaterial = modelHandler.defaultMaterial;\n\t\tthis._assets = modelHandler.assets;\n\t}\n\tparse(data, callback, asset) {\n\t\tvar _asset$options;\n\t\tGlbParser.parse('filename.glb', '', data, this._device, this._assets, (_asset$options = asset == null ? void 0 : asset.options) != null ? _asset$options : {}, (err, result) => {\n\t\t\tif (err) {\n\t\t\t\tcallback(err);\n\t\t\t} else {\n\t\t\t\tconst model = GlbContainerResource.createModel(result, this._defaultMaterial);\n\t\t\t\tresult.destroy();\n\t\t\t\tcallback(null, model);\n\t\t\t}\n\t\t});\n\t}\n}\n\nexport { GlbModelParser };\n", "import { Mat4 } from '../../core/math/mat4.js';\nimport { Vec3 } from '../../core/math/vec3.js';\nimport { BoundingBox } from '../../core/shape/bounding-box.js';\nimport { SEMANTIC_COLOR, INDEXFORMAT_UINT32, INDEXFORMAT_UINT16, PRIMITIVE_POINTS, PRIMITIVE_LINES, PRIMITIVE_LINELOOP, PRIMITIVE_LINESTRIP, PRIMITIVE_TRIANGLES, PRIMITIVE_TRISTRIP, PRIMITIVE_TRIFAN, TYPE_INT8, TYPE_UINT8, TYPE_INT16, TYPE_UINT16, TYPE_INT32, TYPE_UINT32, TYPE_FLOAT32, SEMANTIC_POSITION, SEMANTIC_NORMAL, SEMANTIC_TANGENT, SEMANTIC_BLENDWEIGHT, SEMANTIC_BLENDINDICES, SEMANTIC_TEXCOORD0, SEMANTIC_TEXCOORD1, SEMANTIC_TEXCOORD2, SEMANTIC_TEXCOORD3, SEMANTIC_TEXCOORD4, SEMANTIC_TEXCOORD5, SEMANTIC_TEXCOORD6, SEMANTIC_TEXCOORD7 } from '../../platform/graphics/constants.js';\nimport { IndexBuffer } from '../../platform/graphics/index-buffer.js';\nimport { VertexBuffer } from '../../platform/graphics/vertex-buffer.js';\nimport { VertexFormat } from '../../platform/graphics/vertex-format.js';\nimport { VertexIterator } from '../../platform/graphics/vertex-iterator.js';\nimport { GraphNode } from '../../scene/graph-node.js';\nimport { Mesh } from '../../scene/mesh.js';\nimport { MeshInstance } from '../../scene/mesh-instance.js';\nimport { Model } from '../../scene/model.js';\nimport { Morph } from '../../scene/morph.js';\nimport { MorphInstance } from '../../scene/morph-instance.js';\nimport { MorphTarget } from '../../scene/morph-target.js';\nimport { Skin } from '../../scene/skin.js';\nimport { SkinInstance } from '../../scene/skin-instance.js';\n\nconst JSON_PRIMITIVE_TYPE = {\n\t'points': PRIMITIVE_POINTS,\n\t'lines': PRIMITIVE_LINES,\n\t'lineloop': PRIMITIVE_LINELOOP,\n\t'linestrip': PRIMITIVE_LINESTRIP,\n\t'triangles': PRIMITIVE_TRIANGLES,\n\t'trianglestrip': PRIMITIVE_TRISTRIP,\n\t'trianglefan': PRIMITIVE_TRIFAN\n};\nconst JSON_VERTEX_ELEMENT_TYPE = {\n\t'int8': TYPE_INT8,\n\t'uint8': TYPE_UINT8,\n\t'int16': TYPE_INT16,\n\t'uint16': TYPE_UINT16,\n\t'int32': TYPE_INT32,\n\t'uint32': TYPE_UINT32,\n\t'float32': TYPE_FLOAT32\n};\nclass JsonModelParser {\n\tconstructor(modelHandler) {\n\t\tthis._device = modelHandler.device;\n\t\tthis._defaultMaterial = modelHandler.defaultMaterial;\n\t}\n\tparse(data, callback) {\n\t\tconst modelData = data.model;\n\t\tif (!modelData) {\n\t\t\tcallback(null, null);\n\t\t\treturn;\n\t\t}\n\t\tif (modelData.version <= 1) {\n\t\t\tcallback('JsonModelParser#parse: Trying to parse unsupported model format.');\n\t\t\treturn;\n\t\t}\n\t\tconst nodes = this._parseNodes(data);\n\t\tconst skins = this._parseSkins(data, nodes);\n\t\tconst vertexBuffers = this._parseVertexBuffers(data);\n\t\tconst indices = this._parseIndexBuffers(data, vertexBuffers);\n\t\tconst morphs = this._parseMorphs(data, nodes, vertexBuffers);\n\t\tconst meshes = this._parseMeshes(data, skins.skins, morphs.morphs, vertexBuffers, indices.buffer, indices.data);\n\t\tconst meshInstances = this._parseMeshInstances(data, nodes, meshes, skins.skins, skins.instances, morphs.morphs, morphs.instances);\n\t\tconst model = new Model();\n\t\tmodel.graph = nodes[0];\n\t\tmodel.meshInstances = meshInstances;\n\t\tmodel.skinInstances = skins.instances;\n\t\tmodel.morphInstances = morphs.instances;\n\t\tmodel.getGraph().syncHierarchy();\n\t\tcallback(null, model);\n\t}\n\t_parseNodes(data) {\n\t\tconst modelData = data.model;\n\t\tconst nodes = [];\n\t\tlet i;\n\t\tfor (i = 0; i < modelData.nodes.length; i++) {\n\t\t\tconst nodeData = modelData.nodes[i];\n\t\t\tconst node = new GraphNode(nodeData.name);\n\t\t\tnode.setLocalPosition(nodeData.position[0], nodeData.position[1], nodeData.position[2]);\n\t\t\tnode.setLocalEulerAngles(nodeData.rotation[0], nodeData.rotation[1], nodeData.rotation[2]);\n\t\t\tnode.setLocalScale(nodeData.scale[0], nodeData.scale[1], nodeData.scale[2]);\n\t\t\tnode.scaleCompensation = !!nodeData.scaleCompensation;\n\t\t\tnodes.push(node);\n\t\t}\n\t\tfor (i = 1; i < modelData.parents.length; i++) {\n\t\t\tnodes[modelData.parents[i]].addChild(nodes[i]);\n\t\t}\n\t\treturn nodes;\n\t}\n\t_parseSkins(data, nodes) {\n\t\tconst modelData = data.model;\n\t\tconst skins = [];\n\t\tconst skinInstances = [];\n\t\tlet i, j;\n\t\tfor (i = 0; i < modelData.skins.length; i++) {\n\t\t\tconst skinData = modelData.skins[i];\n\t\t\tconst inverseBindMatrices = [];\n\t\t\tfor (j = 0; j < skinData.inverseBindMatrices.length; j++) {\n\t\t\t\tconst ibm = skinData.inverseBindMatrices[j];\n\t\t\t\tinverseBindMatrices[j] = new Mat4().set(ibm);\n\t\t\t}\n\t\t\tconst skin = new Skin(this._device, inverseBindMatrices, skinData.boneNames);\n\t\t\tskins.push(skin);\n\t\t\tconst skinInstance = new SkinInstance(skin);\n\t\t\tconst bones = [];\n\t\t\tfor (j = 0; j < skin.boneNames.length; j++) {\n\t\t\t\tconst boneName = skin.boneNames[j];\n\t\t\t\tconst bone = nodes[0].findByName(boneName);\n\t\t\t\tbones.push(bone);\n\t\t\t}\n\t\t\tskinInstance.bones = bones;\n\t\t\tskinInstances.push(skinInstance);\n\t\t}\n\t\treturn {\n\t\t\tskins: skins,\n\t\t\tinstances: skinInstances\n\t\t};\n\t}\n\t_getMorphVertexCount(modelData, morphIndex, vertexBuffers) {\n\t\tfor (let i = 0; i < modelData.meshes.length; i++) {\n\t\t\tconst meshData = modelData.meshes[i];\n\t\t\tif (meshData.morph === morphIndex) {\n\t\t\t\tconst vertexBuffer = vertexBuffers[meshData.vertices];\n\t\t\t\treturn vertexBuffer.numVertices;\n\t\t\t}\n\t\t}\n\t\treturn undefined;\n\t}\n\t_parseMorphs(data, nodes, vertexBuffers) {\n\t\tconst modelData = data.model;\n\t\tconst morphs = [];\n\t\tconst morphInstances = [];\n\t\tlet i, j, vertexCount;\n\t\tlet targets, morphTarget, morphTargetArray;\n\t\tif (modelData.morphs) {\n\t\t\tconst sparseToFull = function sparseToFull(data, indices, totalCount) {\n\t\t\t\tconst full = new Float32Array(totalCount * 3);\n\t\t\t\tfor (let s = 0; s < indices.length; s++) {\n\t\t\t\t\tconst dstIndex = indices[s] * 3;\n\t\t\t\t\tfull[dstIndex] = data[s * 3];\n\t\t\t\t\tfull[dstIndex + 1] = data[s * 3 + 1];\n\t\t\t\t\tfull[dstIndex + 2] = data[s * 3 + 2];\n\t\t\t\t}\n\t\t\t\treturn full;\n\t\t\t};\n\t\t\tfor (i = 0; i < modelData.morphs.length; i++) {\n\t\t\t\ttargets = modelData.morphs[i].targets;\n\t\t\t\tmorphTargetArray = [];\n\t\t\t\tvertexCount = this._getMorphVertexCount(modelData, i, vertexBuffers);\n\t\t\t\tfor (j = 0; j < targets.length; j++) {\n\t\t\t\t\tconst targetAabb = targets[j].aabb;\n\t\t\t\t\tconst min = targetAabb.min;\n\t\t\t\t\tconst max = targetAabb.max;\n\t\t\t\t\tconst aabb = new BoundingBox(new Vec3((max[0] + min[0]) * 0.5, (max[1] + min[1]) * 0.5, (max[2] + min[2]) * 0.5), new Vec3((max[0] - min[0]) * 0.5, (max[1] - min[1]) * 0.5, (max[2] - min[2]) * 0.5));\n\t\t\t\t\tconst indices = targets[j].indices;\n\t\t\t\t\tlet deltaPositions = targets[j].deltaPositions;\n\t\t\t\t\tlet deltaNormals = targets[j].deltaNormals;\n\t\t\t\t\tif (indices) {\n\t\t\t\t\t\tdeltaPositions = sparseToFull(deltaPositions, indices, vertexCount);\n\t\t\t\t\t\tdeltaNormals = sparseToFull(deltaNormals, indices, vertexCount);\n\t\t\t\t\t}\n\t\t\t\t\tmorphTarget = new MorphTarget({\n\t\t\t\t\t\tdeltaPositions: deltaPositions,\n\t\t\t\t\t\tdeltaNormals: deltaNormals,\n\t\t\t\t\t\tname: targets[j].name,\n\t\t\t\t\t\taabb: aabb\n\t\t\t\t\t});\n\t\t\t\t\tmorphTargetArray.push(morphTarget);\n\t\t\t\t}\n\t\t\t\tconst morph = new Morph(morphTargetArray, this._device);\n\t\t\t\tmorphs.push(morph);\n\t\t\t\tconst morphInstance = new MorphInstance(morph);\n\t\t\t\tmorphInstances.push(morphInstance);\n\t\t\t}\n\t\t}\n\t\treturn {\n\t\t\tmorphs: morphs,\n\t\t\tinstances: morphInstances\n\t\t};\n\t}\n\t_parseVertexBuffers(data) {\n\t\tconst modelData = data.model;\n\t\tconst vertexBuffers = [];\n\t\tconst attributeMap = {\n\t\t\tposition: SEMANTIC_POSITION,\n\t\t\tnormal: SEMANTIC_NORMAL,\n\t\t\ttangent: SEMANTIC_TANGENT,\n\t\t\tblendWeight: SEMANTIC_BLENDWEIGHT,\n\t\t\tblendIndices: SEMANTIC_BLENDINDICES,\n\t\t\tcolor: SEMANTIC_COLOR,\n\t\t\ttexCoord0: SEMANTIC_TEXCOORD0,\n\t\t\ttexCoord1: SEMANTIC_TEXCOORD1,\n\t\t\ttexCoord2: SEMANTIC_TEXCOORD2,\n\t\t\ttexCoord3: SEMANTIC_TEXCOORD3,\n\t\t\ttexCoord4: SEMANTIC_TEXCOORD4,\n\t\t\ttexCoord5: SEMANTIC_TEXCOORD5,\n\t\t\ttexCoord6: SEMANTIC_TEXCOORD6,\n\t\t\ttexCoord7: SEMANTIC_TEXCOORD7\n\t\t};\n\t\tfor (let i = 0; i < modelData.vertices.length; i++) {\n\t\t\tconst vertexData = modelData.vertices[i];\n\t\t\tconst formatDesc = [];\n\t\t\tfor (const attributeName in vertexData) {\n\t\t\t\tconst attribute = vertexData[attributeName];\n\t\t\t\tformatDesc.push({\n\t\t\t\t\tsemantic: attributeMap[attributeName],\n\t\t\t\t\tcomponents: attribute.components,\n\t\t\t\t\ttype: JSON_VERTEX_ELEMENT_TYPE[attribute.type],\n\t\t\t\t\tnormalize: attributeMap[attributeName] === SEMANTIC_COLOR\n\t\t\t\t});\n\t\t\t}\n\t\t\tconst vertexFormat = new VertexFormat(this._device, formatDesc);\n\t\t\tconst numVertices = vertexData.position.data.length / vertexData.position.components;\n\t\t\tconst vertexBuffer = new VertexBuffer(this._device, vertexFormat, numVertices);\n\t\t\tconst iterator = new VertexIterator(vertexBuffer);\n\t\t\tfor (let j = 0; j < numVertices; j++) {\n\t\t\t\tfor (const attributeName in vertexData) {\n\t\t\t\t\tconst attribute = vertexData[attributeName];\n\t\t\t\t\tswitch (attribute.components) {\n\t\t\t\t\t\tcase 1:\n\t\t\t\t\t\t\titerator.element[attributeMap[attributeName]].set(attribute.data[j]);\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\tcase 2:\n\t\t\t\t\t\t\titerator.element[attributeMap[attributeName]].set(attribute.data[j * 2], 1.0 - attribute.data[j * 2 + 1]);\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\tcase 3:\n\t\t\t\t\t\t\titerator.element[attributeMap[attributeName]].set(attribute.data[j * 3], attribute.data[j * 3 + 1], attribute.data[j * 3 + 2]);\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\tcase 4:\n\t\t\t\t\t\t\titerator.element[attributeMap[attributeName]].set(attribute.data[j * 4], attribute.data[j * 4 + 1], attribute.data[j * 4 + 2], attribute.data[j * 4 + 3]);\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\titerator.next();\n\t\t\t}\n\t\t\titerator.end();\n\t\t\tvertexBuffers.push(vertexBuffer);\n\t\t}\n\t\treturn vertexBuffers;\n\t}\n\t_parseIndexBuffers(data, vertexBuffers) {\n\t\tconst modelData = data.model;\n\t\tlet indexBuffer = null;\n\t\tlet indexData = null;\n\t\tlet i;\n\t\tlet numIndices = 0;\n\t\tfor (i = 0; i < modelData.meshes.length; i++) {\n\t\t\tconst meshData = modelData.meshes[i];\n\t\t\tif (meshData.indices !== undefined) {\n\t\t\t\tnumIndices += meshData.indices.length;\n\t\t\t}\n\t\t}\n\t\tlet maxVerts = 0;\n\t\tfor (i = 0; i < vertexBuffers.length; i++) {\n\t\t\tmaxVerts = Math.max(maxVerts, vertexBuffers[i].numVertices);\n\t\t}\n\t\tif (numIndices > 0) {\n\t\t\tif (maxVerts > 0xFFFF && this._device.extUintElement) {\n\t\t\t\tindexBuffer = new IndexBuffer(this._device, INDEXFORMAT_UINT32, numIndices);\n\t\t\t\tindexData = new Uint32Array(indexBuffer.lock());\n\t\t\t} else {\n\t\t\t\tindexBuffer = new IndexBuffer(this._device, INDEXFORMAT_UINT16, numIndices);\n\t\t\t\tindexData = new Uint16Array(indexBuffer.lock());\n\t\t\t}\n\t\t}\n\t\treturn {\n\t\t\tbuffer: indexBuffer,\n\t\t\tdata: indexData\n\t\t};\n\t}\n\t_parseMeshes(data, skins, morphs, vertexBuffers, indexBuffer, indexData) {\n\t\tconst modelData = data.model;\n\t\tconst meshes = [];\n\t\tlet indexBase = 0;\n\t\tfor (let i = 0; i < modelData.meshes.length; i++) {\n\t\t\tconst meshData = modelData.meshes[i];\n\t\t\tconst meshAabb = meshData.aabb;\n\t\t\tconst min = meshAabb.min;\n\t\t\tconst max = meshAabb.max;\n\t\t\tconst aabb = new BoundingBox(new Vec3((max[0] + min[0]) * 0.5, (max[1] + min[1]) * 0.5, (max[2] + min[2]) * 0.5), new Vec3((max[0] - min[0]) * 0.5, (max[1] - min[1]) * 0.5, (max[2] - min[2]) * 0.5));\n\t\t\tconst indexed = meshData.indices !== undefined;\n\t\t\tconst mesh = new Mesh(this._device);\n\t\t\tmesh.vertexBuffer = vertexBuffers[meshData.vertices];\n\t\t\tmesh.indexBuffer[0] = indexed ? indexBuffer : null;\n\t\t\tmesh.primitive[0].type = JSON_PRIMITIVE_TYPE[meshData.type];\n\t\t\tmesh.primitive[0].base = indexed ? meshData.base + indexBase : meshData.base;\n\t\t\tmesh.primitive[0].count = meshData.count;\n\t\t\tmesh.primitive[0].indexed = indexed;\n\t\t\tmesh.skin = meshData.skin !== undefined ? skins[meshData.skin] : null;\n\t\t\tmesh.morph = meshData.morph !== undefined ? morphs[meshData.morph] : null;\n\t\t\tmesh.aabb = aabb;\n\t\t\tif (indexed) {\n\t\t\t\tindexData.set(meshData.indices, indexBase);\n\t\t\t\tindexBase += meshData.indices.length;\n\t\t\t}\n\t\t\tmeshes.push(mesh);\n\t\t}\n\t\tif (indexBuffer !== null) {\n\t\t\tindexBuffer.unlock();\n\t\t}\n\t\treturn meshes;\n\t}\n\t_parseMeshInstances(data, nodes, meshes, skins, skinInstances, morphs, morphInstances) {\n\t\tconst modelData = data.model;\n\t\tconst meshInstances = [];\n\t\tlet i;\n\t\tfor (i = 0; i < modelData.meshInstances.length; i++) {\n\t\t\tconst meshInstanceData = modelData.meshInstances[i];\n\t\t\tconst node = nodes[meshInstanceData.node];\n\t\t\tconst mesh = meshes[meshInstanceData.mesh];\n\t\t\tconst meshInstance = new MeshInstance(mesh, this._defaultMaterial, node);\n\t\t\tif (mesh.skin) {\n\t\t\t\tconst skinIndex = skins.indexOf(mesh.skin);\n\t\t\t\tmeshInstance.skinInstance = skinInstances[skinIndex];\n\t\t\t}\n\t\t\tif (mesh.morph) {\n\t\t\t\tconst morphIndex = morphs.indexOf(mesh.morph);\n\t\t\t\tmeshInstance.morphInstance = morphInstances[morphIndex];\n\t\t\t}\n\t\t\tmeshInstances.push(meshInstance);\n\t\t}\n\t\treturn meshInstances;\n\t}\n}\n\nexport { JsonModelParser };\n", "import { path } from '../../core/path.js';\nimport { Http, http } from '../../platform/net/http.js';\nimport { getDefaultMaterial } from '../../scene/materials/default-material.js';\nimport { GlbModelParser } from '../parsers/glb-model.js';\nimport { JsonModelParser } from '../parsers/json-model.js';\nimport { ResourceHandler } from './handler.js';\n\nclass ModelHandler extends ResourceHandler {\n\tconstructor(app) {\n\t\tsuper(app, 'model');\n\t\tthis._parsers = [];\n\t\tthis.device = app.graphicsDevice;\n\t\tthis.assets = app.assets;\n\t\tthis.defaultMaterial = getDefaultMaterial(this.device);\n\t\tthis.addParser(new JsonModelParser(this), function (url, data) {\n\t\t\treturn path.getExtension(url) === '.json';\n\t\t});\n\t\tthis.addParser(new GlbModelParser(this), function (url, data) {\n\t\t\treturn path.getExtension(url) === '.glb';\n\t\t});\n\t}\n\tload(url, callback, asset) {\n\t\tif (typeof url === 'string') {\n\t\t\turl = {\n\t\t\t\tload: url,\n\t\t\t\toriginal: url\n\t\t\t};\n\t\t}\n\t\tconst options = {\n\t\t\tretry: this.maxRetries > 0,\n\t\t\tmaxRetries: this.maxRetries\n\t\t};\n\t\tif (url.load.startsWith('blob:') || url.load.startsWith('data:')) {\n\t\t\tif (path.getExtension(url.original).toLowerCase() === '.glb') {\n\t\t\t\toptions.responseType = Http.ResponseType.ARRAY_BUFFER;\n\t\t\t} else {\n\t\t\t\toptions.responseType = Http.ResponseType.JSON;\n\t\t\t}\n\t\t}\n\t\thttp.get(url.load, options, (err, response) => {\n\t\t\tif (!callback) return;\n\t\t\tif (!err) {\n\t\t\t\tfor (let i = 0; i < this._parsers.length; i++) {\n\t\t\t\t\tconst p = this._parsers[i];\n\t\t\t\t\tif (p.decider(url.original, response)) {\n\t\t\t\t\t\tp.parser.parse(response, (err, parseResult) => {\n\t\t\t\t\t\t\tif (err) {\n\t\t\t\t\t\t\t\tcallback(err);\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tcallback(null, parseResult);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}, asset);\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tcallback(\"No parsers found\");\n\t\t\t} else {\n\t\t\t\tcallback(`Error loading model: ${url.original} [${err}]`);\n\t\t\t}\n\t\t});\n\t}\n\topen(url, data) {\n\t\treturn data;\n\t}\n\tpatch(asset, assets) {\n\t\tif (!asset.resource) return;\n\t\tconst data = asset.data;\n\t\tconst self = this;\n\t\tasset.resource.meshInstances.forEach(function (meshInstance, i) {\n\t\t\tif (data.mapping) {\n\t\t\t\tconst handleMaterial = function handleMaterial(asset) {\n\t\t\t\t\tif (asset.resource) {\n\t\t\t\t\t\tmeshInstance.material = asset.resource;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tasset.once('load', handleMaterial);\n\t\t\t\t\t\tassets.load(asset);\n\t\t\t\t\t}\n\t\t\t\t\tasset.once('remove', function (asset) {\n\t\t\t\t\t\tif (meshInstance.material === asset.resource) {\n\t\t\t\t\t\t\tmeshInstance.material = self.defaultMaterial;\n\t\t\t\t\t\t}\n\t\t\t\t\t});\n\t\t\t\t};\n\t\t\t\tif (!data.mapping[i]) {\n\t\t\t\t\tmeshInstance.material = self.defaultMaterial;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tconst id = data.mapping[i].material;\n\t\t\t\tconst url = data.mapping[i].path;\n\t\t\t\tlet material;\n\t\t\t\tif (id !== undefined) {\n\t\t\t\t\tif (!id) {\n\t\t\t\t\t\tmeshInstance.material = self.defaultMaterial;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tmaterial = assets.get(id);\n\t\t\t\t\t\tif (material) {\n\t\t\t\t\t\t\thandleMaterial(material);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tassets.once('add:' + id, handleMaterial);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} else if (url) {\n\t\t\t\t\tconst path = asset.getAbsoluteUrl(data.mapping[i].path);\n\t\t\t\t\tmaterial = assets.getByUrl(path);\n\t\t\t\t\tif (material) {\n\t\t\t\t\t\thandleMaterial(material);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tassets.once('add:url:' + path, handleMaterial);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t}\n\taddParser(parser, decider) {\n\t\tthis._parsers.push({\n\t\t\tparser: parser,\n\t\t\tdecider: decider\n\t\t});\n\t}\n}\n\nexport { ModelHandler };\n", "function BasisWorker() {\n\tconst BASIS_FORMAT = {\n\t\tcTFETC1: 0,\n\t\tcTFETC2: 1,\n\t\tcTFBC1: 2,\n\t\tcTFBC3: 3,\n\t\tcTFPVRTC1_4_RGB: 8,\n\t\tcTFPVRTC1_4_RGBA: 9,\n\t\tcTFASTC_4x4: 10,\n\t\tcTFATC_RGB: 11,\n\t\tcTFATC_RGBA_INTERPOLATED_ALPHA: 12,\n\t\tcTFRGBA32: 13,\n\t\tcTFRGB565: 14,\n\t\tcTFRGBA4444: 16\n\t};\n\tconst opaqueMapping = {\n\t\tastc: BASIS_FORMAT.cTFASTC_4x4,\n\t\tdxt: BASIS_FORMAT.cTFBC1,\n\t\tetc1: BASIS_FORMAT.cTFETC1,\n\t\tetc2: BASIS_FORMAT.cTFETC1,\n\t\tpvr: BASIS_FORMAT.cTFPVRTC1_4_RGB,\n\t\tatc: BASIS_FORMAT.cTFATC_RGB,\n\t\tnone: BASIS_FORMAT.cTFRGB565\n\t};\n\tconst alphaMapping = {\n\t\tastc: BASIS_FORMAT.cTFASTC_4x4,\n\t\tdxt: BASIS_FORMAT.cTFBC3,\n\t\tetc1: BASIS_FORMAT.cTFRGBA4444,\n\t\tetc2: BASIS_FORMAT.cTFETC2,\n\t\tpvr: BASIS_FORMAT.cTFPVRTC1_4_RGBA,\n\t\tatc: BASIS_FORMAT.cTFATC_RGBA_INTERPOLATED_ALPHA,\n\t\tnone: BASIS_FORMAT.cTFRGBA4444\n\t};\n\tconst PIXEL_FORMAT = {\n\t\tETC1: 21,\n\t\tETC2_RGB: 22,\n\t\tETC2_RGBA: 23,\n\t\tDXT1: 8,\n\t\tDXT5: 10,\n\t\tPVRTC_4BPP_RGB_1: 26,\n\t\tPVRTC_4BPP_RGBA_1: 27,\n\t\tASTC_4x4: 28,\n\t\tATC_RGB: 29,\n\t\tATC_RGBA: 30,\n\t\tR8_G8_B8_A8: 7,\n\t\tR5_G6_B5: 3,\n\t\tR4_G4_B4_A4: 5\n\t};\n\tconst basisToEngineMapping = (basisFormat, deviceDetails) => {\n\t\tswitch (basisFormat) {\n\t\t\tcase BASIS_FORMAT.cTFETC1:\n\t\t\t\treturn deviceDetails.formats.etc1 ? PIXEL_FORMAT.ETC1 : PIXEL_FORMAT.ETC2_RGB;\n\t\t\tcase BASIS_FORMAT.cTFETC2:\n\t\t\t\treturn PIXEL_FORMAT.ETC2_RGBA;\n\t\t\tcase BASIS_FORMAT.cTFBC1:\n\t\t\t\treturn PIXEL_FORMAT.DXT1;\n\t\t\tcase BASIS_FORMAT.cTFBC3:\n\t\t\t\treturn PIXEL_FORMAT.DXT5;\n\t\t\tcase BASIS_FORMAT.cTFPVRTC1_4_RGB:\n\t\t\t\treturn PIXEL_FORMAT.PVRTC_4BPP_RGB_1;\n\t\t\tcase BASIS_FORMAT.cTFPVRTC1_4_RGBA:\n\t\t\t\treturn PIXEL_FORMAT.PVRTC_4BPP_RGBA_1;\n\t\t\tcase BASIS_FORMAT.cTFASTC_4x4:\n\t\t\t\treturn PIXEL_FORMAT.ASTC_4x4;\n\t\t\tcase BASIS_FORMAT.cTFATC_RGB:\n\t\t\t\treturn PIXEL_FORMAT.ATC_RGB;\n\t\t\tcase BASIS_FORMAT.cTFATC_RGBA_INTERPOLATED_ALPHA:\n\t\t\t\treturn PIXEL_FORMAT.ATC_RGBA;\n\t\t\tcase BASIS_FORMAT.cTFRGBA32:\n\t\t\t\treturn PIXEL_FORMAT.R8_G8_B8_A8;\n\t\t\tcase BASIS_FORMAT.cTFRGB565:\n\t\t\t\treturn PIXEL_FORMAT.R5_G6_B5;\n\t\t\tcase BASIS_FORMAT.cTFRGBA4444:\n\t\t\t\treturn PIXEL_FORMAT.R4_G4_B4_A4;\n\t\t}\n\t};\n\tconst unswizzleGGGR = data => {\n\t\tconst genB = function genB(R, G) {\n\t\t\tconst r = R * (2.0 / 255.0) - 1.0;\n\t\t\tconst g = G * (2.0 / 255.0) - 1.0;\n\t\t\tconst b = Math.sqrt(1.0 - Math.min(1.0, r * r + g * g));\n\t\t\treturn Math.max(0, Math.min(255, Math.floor((b + 1.0) * 0.5 * 255.0)));\n\t\t};\n\t\tfor (let offset = 0; offset < data.length; offset += 4) {\n\t\t\tconst R = data[offset + 3];\n\t\t\tconst G = data[offset + 1];\n\t\t\tdata[offset + 0] = R;\n\t\t\tdata[offset + 2] = genB(R, G);\n\t\t\tdata[offset + 3] = 255;\n\t\t}\n\t\treturn data;\n\t};\n\tconst pack565 = data => {\n\t\tconst result = new Uint16Array(data.length / 4);\n\t\tfor (let offset = 0; offset < data.length; offset += 4) {\n\t\t\tconst R = data[offset + 0];\n\t\t\tconst G = data[offset + 1];\n\t\t\tconst B = data[offset + 2];\n\t\t\tresult[offset / 4] = (R & 0xf8) << 8 | (G & 0xfc) << 3 | B >> 3;\n\t\t}\n\t\treturn result;\n\t};\n\tconst isPOT = (width, height) => {\n\t\treturn (width & width - 1) === 0 && (height & height - 1) === 0;\n\t};\n\tconst performanceNow = () => {\n\t\treturn typeof performance !== 'undefined' ? performance.now() : 0;\n\t};\n\tlet basis;\n\tlet rgbPriority;\n\tlet rgbaPriority;\n\tconst chooseTargetFormat = (deviceDetails, hasAlpha, isUASTC) => {\n\t\tif (isUASTC) {\n\t\t\tif (deviceDetails.formats.astc) {\n\t\t\t\treturn 'astc';\n\t\t\t}\n\t\t} else {\n\t\t\tif (hasAlpha) {\n\t\t\t\tif (deviceDetails.formats.etc2) {\n\t\t\t\t\treturn 'etc2';\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tif (deviceDetails.formats.etc1 || deviceDetails.formats.etc2) {\n\t\t\t\t\treturn 'etc1';\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tconst testInOrder = priority => {\n\t\t\tfor (let i = 0; i < priority.length; ++i) {\n\t\t\t\tconst format = priority[i];\n\t\t\t\tif (deviceDetails.formats[format]) {\n\t\t\t\t\treturn format;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn 'none';\n\t\t};\n\t\treturn testInOrder(hasAlpha ? rgbaPriority : rgbPriority);\n\t};\n\tconst dimensionsValid = (width, height, format, webgl2) => {\n\t\tswitch (format) {\n\t\t\tcase BASIS_FORMAT.cTFETC1:\n\t\t\tcase BASIS_FORMAT.cTFETC2:\n\t\t\t\treturn true;\n\t\t\tcase BASIS_FORMAT.cTFBC1:\n\t\t\tcase BASIS_FORMAT.cTFBC3:\n\t\t\t\treturn (width & 0x3) === 0 && (height & 0x3) === 0;\n\t\t\tcase BASIS_FORMAT.cTFPVRTC1_4_RGB:\n\t\t\tcase BASIS_FORMAT.cTFPVRTC1_4_RGBA:\n\t\t\t\treturn isPOT(width, height) && (width === height || webgl2);\n\t\t\tcase BASIS_FORMAT.cTFASTC_4x4:\n\t\t\t\treturn true;\n\t\t\tcase BASIS_FORMAT.cTFATC_RGB:\n\t\t\tcase BASIS_FORMAT.cTFATC_RGBA_INTERPOLATED_ALPHA:\n\t\t\t\treturn true;\n\t\t}\n\t\treturn false;\n\t};\n\tconst transcodeKTX2 = (url, data, options) => {\n\t\tif (!basis.KTX2File) {\n\t\t\tthrow new Error('Basis transcoder module does not include support for KTX2.');\n\t\t}\n\t\tconst funcStart = performanceNow();\n\t\tconst basisFile = new basis.KTX2File(new Uint8Array(data));\n\t\tconst width = basisFile.getWidth();\n\t\tconst height = basisFile.getHeight();\n\t\tconst levels = basisFile.getLevels();\n\t\tconst hasAlpha = !!basisFile.getHasAlpha();\n\t\tconst isUASTC = basisFile.isUASTC && basisFile.isUASTC();\n\t\tif (!width || !height || !levels) {\n\t\t\tbasisFile.close();\n\t\t\tbasisFile.delete();\n\t\t\tthrow new Error(`Invalid image dimensions url=${url} width=${width} height=${height} levels=${levels}`);\n\t\t}\n\t\tconst format = chooseTargetFormat(options.deviceDetails, hasAlpha, isUASTC);\n\t\tconst unswizzle = !!options.isGGGR && format === 'pvr';\n\t\tlet basisFormat;\n\t\tif (unswizzle) {\n\t\t\tbasisFormat = BASIS_FORMAT.cTFRGBA32;\n\t\t} else {\n\t\t\tbasisFormat = hasAlpha ? alphaMapping[format] : opaqueMapping[format];\n\t\t\tif (!dimensionsValid(width, height, basisFormat, options.deviceDetails.webgl2)) {\n\t\t\t\tbasisFormat = hasAlpha ? BASIS_FORMAT.cTFRGBA32 : BASIS_FORMAT.cTFRGB565;\n\t\t\t}\n\t\t}\n\t\tif (!basisFile.startTranscoding()) {\n\t\t\tbasisFile.close();\n\t\t\tbasisFile.delete();\n\t\t\tthrow new Error('Failed to start transcoding url=' + url);\n\t\t}\n\t\tlet i;\n\t\tconst levelData = [];\n\t\tfor (let mip = 0; mip < levels; ++mip) {\n\t\t\tconst dstSize = basisFile.getImageTranscodedSizeInBytes(mip, 0, 0, basisFormat);\n\t\t\tconst dst = new Uint8Array(dstSize);\n\t\t\tif (!basisFile.transcodeImage(dst, mip, 0, 0, basisFormat, 0, -1, -1)) {\n\t\t\t\tbasisFile.close();\n\t\t\t\tbasisFile.delete();\n\t\t\t\tthrow new Error('Failed to transcode image url=' + url);\n\t\t\t}\n\t\t\tconst is16BitFormat = basisFormat === BASIS_FORMAT.cTFRGB565 || basisFormat === BASIS_FORMAT.cTFRGBA4444;\n\t\t\tlevelData.push(is16BitFormat ? new Uint16Array(dst.buffer) : dst);\n\t\t}\n\t\tbasisFile.close();\n\t\tbasisFile.delete();\n\t\tif (unswizzle) {\n\t\t\tbasisFormat = BASIS_FORMAT.cTFRGB565;\n\t\t\tfor (i = 0; i < levelData.length; ++i) {\n\t\t\t\tlevelData[i] = pack565(unswizzleGGGR(levelData[i]));\n\t\t\t}\n\t\t}\n\t\treturn {\n\t\t\tformat: basisToEngineMapping(basisFormat, options.deviceDetails),\n\t\t\twidth: width,\n\t\t\theight: height,\n\t\t\tlevels: levelData,\n\t\t\tcubemap: false,\n\t\t\ttranscodeTime: performanceNow() - funcStart,\n\t\t\turl: url,\n\t\t\tunswizzledGGGR: unswizzle\n\t\t};\n\t};\n\tconst transcodeBasis = (url, data, options) => {\n\t\tconst funcStart = performanceNow();\n\t\tconst basisFile = new basis.BasisFile(new Uint8Array(data));\n\t\tconst width = basisFile.getImageWidth(0, 0);\n\t\tconst height = basisFile.getImageHeight(0, 0);\n\t\tconst images = basisFile.getNumImages();\n\t\tconst levels = basisFile.getNumLevels(0);\n\t\tconst hasAlpha = !!basisFile.getHasAlpha();\n\t\tconst isUASTC = basisFile.isUASTC && basisFile.isUASTC();\n\t\tif (!width || !height || !images || !levels) {\n\t\t\tbasisFile.close();\n\t\t\tbasisFile.delete();\n\t\t\tthrow new Error(`Invalid image dimensions url=${url} width=${width} height=${height} images=${images} levels=${levels}`);\n\t\t}\n\t\tconst format = chooseTargetFormat(options.deviceDetails, hasAlpha, isUASTC);\n\t\tconst unswizzle = !!options.isGGGR && format === 'pvr';\n\t\tlet basisFormat;\n\t\tif (unswizzle) {\n\t\t\tbasisFormat = BASIS_FORMAT.cTFRGBA32;\n\t\t} else {\n\t\t\tbasisFormat = hasAlpha ? alphaMapping[format] : opaqueMapping[format];\n\t\t\tif (!dimensionsValid(width, height, basisFormat, options.deviceDetails.webgl2)) {\n\t\t\t\tbasisFormat = hasAlpha ? BASIS_FORMAT.cTFRGBA32 : BASIS_FORMAT.cTFRGB565;\n\t\t\t}\n\t\t}\n\t\tif (!basisFile.startTranscoding()) {\n\t\t\tbasisFile.close();\n\t\t\tbasisFile.delete();\n\t\t\tthrow new Error('Failed to start transcoding url=' + url);\n\t\t}\n\t\tlet i;\n\t\tconst levelData = [];\n\t\tfor (let mip = 0; mip < levels; ++mip) {\n\t\t\tconst dstSize = basisFile.getImageTranscodedSizeInBytes(0, mip, basisFormat);\n\t\t\tconst dst = new Uint8Array(dstSize);\n\t\t\tif (!basisFile.transcodeImage(dst, 0, mip, basisFormat, 0, 0)) {\n\t\t\t\tif (mip === levels - 1 && dstSize === levelData[mip - 1].buffer.byteLength) {\n\t\t\t\t\tdst.set(new Uint8Array(levelData[mip - 1].buffer));\n\t\t\t\t\tconsole.warn('Failed to transcode last mipmap level, using previous level instead url=' + url);\n\t\t\t\t} else {\n\t\t\t\t\tbasisFile.close();\n\t\t\t\t\tbasisFile.delete();\n\t\t\t\t\tthrow new Error('Failed to transcode image url=' + url);\n\t\t\t\t}\n\t\t\t}\n\t\t\tconst is16BitFormat = basisFormat === BASIS_FORMAT.cTFRGB565 || basisFormat === BASIS_FORMAT.cTFRGBA4444;\n\t\t\tlevelData.push(is16BitFormat ? new Uint16Array(dst.buffer) : dst);\n\t\t}\n\t\tbasisFile.close();\n\t\tbasisFile.delete();\n\t\tif (unswizzle) {\n\t\t\tbasisFormat = BASIS_FORMAT.cTFRGB565;\n\t\t\tfor (i = 0; i < levelData.length; ++i) {\n\t\t\t\tlevelData[i] = pack565(unswizzleGGGR(levelData[i]));\n\t\t\t}\n\t\t}\n\t\treturn {\n\t\t\tformat: basisToEngineMapping(basisFormat, options.deviceDetails),\n\t\t\twidth: width,\n\t\t\theight: height,\n\t\t\tlevels: levelData,\n\t\t\tcubemap: false,\n\t\t\ttranscodeTime: performanceNow() - funcStart,\n\t\t\turl: url,\n\t\t\tunswizzledGGGR: unswizzle\n\t\t};\n\t};\n\tconst transcode = (url, data, options) => {\n\t\treturn options.isKTX2 ? transcodeKTX2(url, data, options) : transcodeBasis(url, data, options);\n\t};\n\tconst workerTranscode = (url, data, options) => {\n\t\ttry {\n\t\t\tconst result = transcode(url, data, options);\n\t\t\tresult.levels = result.levels.map(v => v.buffer);\n\t\t\tself.postMessage({\n\t\t\t\turl: url,\n\t\t\t\tdata: result\n\t\t\t}, result.levels);\n\t\t} catch (err) {\n\t\t\tself.postMessage({\n\t\t\t\turl: url,\n\t\t\t\terr: err\n\t\t\t}, null);\n\t\t}\n\t};\n\tconst workerInit = (config, callback) => {\n\t\tconst instantiateWasmFunc = (imports, successCallback) => {\n\t\t\tWebAssembly.instantiate(config.module, imports).then(result => {\n\t\t\t\tsuccessCallback(result);\n\t\t\t}).catch(reason => {\n\t\t\t\tconsole.error('instantiate failed + ' + reason);\n\t\t\t});\n\t\t\treturn {};\n\t\t};\n\t\tself.BASIS(config.module ? {\n\t\t\tinstantiateWasm: instantiateWasmFunc\n\t\t} : null).then(instance => {\n\t\t\tinstance.initializeBasis();\n\t\t\tbasis = instance;\n\t\t\trgbPriority = config.rgbPriority;\n\t\t\trgbaPriority = config.rgbaPriority;\n\t\t\tcallback(null);\n\t\t});\n\t};\n\tconst queue = [];\n\tself.onmessage = message => {\n\t\tconst data = message.data;\n\t\tswitch (data.type) {\n\t\t\tcase 'init':\n\t\t\t\tworkerInit(data.config, () => {\n\t\t\t\t\tfor (let i = 0; i < queue.length; ++i) {\n\t\t\t\t\t\tworkerTranscode(queue[i].url, queue[i].data, queue[i].options);\n\t\t\t\t\t}\n\t\t\t\t\tqueue.length = 0;\n\t\t\t\t});\n\t\t\t\tbreak;\n\t\t\tcase 'transcode':\n\t\t\t\tif (basis) {\n\t\t\t\t\tworkerTranscode(data.url, data.data, data.options);\n\t\t\t\t} else {\n\t\t\t\t\tqueue.push(data);\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t}\n\t};\n}\n\nexport { BasisWorker };\n", "import { WasmModule } from '../../core/wasm-module.js';\nimport { PIXELFORMAT_RGB565, PIXELFORMAT_RGBA4 } from '../../platform/graphics/constants.js';\nimport { BasisWorker } from './basis-worker.js';\nimport { http } from '../../platform/net/http.js';\n\nconst getCompressionFormats = device => {\n\treturn {\n\t\tastc: !!device.extCompressedTextureASTC,\n\t\tatc: !!device.extCompressedTextureATC,\n\t\tdxt: !!device.extCompressedTextureS3TC,\n\t\tetc1: !!device.extCompressedTextureETC1,\n\t\tetc2: !!device.extCompressedTextureETC,\n\t\tpvr: !!device.extCompressedTexturePVRTC\n\t};\n};\nconst prepareWorkerModules = (config, callback) => {\n\tconst getWorkerBlob = basisCode => {\n\t\tconst code = ['/* basis */', basisCode, \"\", '(' + BasisWorker.toString() + ')()\\n\\n'].join('\\n');\n\t\treturn new Blob([code], {\n\t\t\ttype: 'application/javascript'\n\t\t});\n\t};\n\tconst wasmSupported = () => {\n\t\ttry {\n\t\t\tif (typeof WebAssembly === 'object' && typeof WebAssembly.instantiate === 'function') {\n\t\t\t\tconst module = new WebAssembly.Module(Uint8Array.of(0x0, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00));\n\t\t\t\tif (module instanceof WebAssembly.Module) return new WebAssembly.Instance(module) instanceof WebAssembly.Instance;\n\t\t\t}\n\t\t} catch (e) {}\n\t\treturn false;\n\t};\n\tconst sendResponse = (basisCode, module) => {\n\t\tcallback(null, {\n\t\t\tworkerUrl: URL.createObjectURL(getWorkerBlob(basisCode)),\n\t\t\tmodule: module,\n\t\t\trgbPriority: config.rgbPriority,\n\t\t\trgbaPriority: config.rgbaPriority\n\t\t});\n\t};\n\tconst options = {\n\t\tcache: true,\n\t\tresponseType: 'text',\n\t\tretry: config.maxRetries > 0,\n\t\tmaxRetries: config.maxRetries\n\t};\n\tif (config.glueUrl && config.wasmUrl && wasmSupported()) {\n\t\tlet basisCode = null;\n\t\tlet module = null;\n\t\thttp.get(config.glueUrl, options, (err, response) => {\n\t\t\tif (err) {\n\t\t\t\tcallback(err);\n\t\t\t} else {\n\t\t\t\tif (module) {\n\t\t\t\t\tsendResponse(response, module);\n\t\t\t\t} else {\n\t\t\t\t\tbasisCode = response;\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t\tconst fetchPromise = fetch(config.wasmUrl);\n\t\tconst compileManual = () => {\n\t\t\tfetchPromise.then(result => result.arrayBuffer()).then(buffer => WebAssembly.compile(buffer)).then(module_ => {\n\t\t\t\tif (basisCode) {\n\t\t\t\t\tsendResponse(basisCode, module_);\n\t\t\t\t} else {\n\t\t\t\t\tmodule = module_;\n\t\t\t\t}\n\t\t\t}).catch(err => {\n\t\t\t\tcallback(err, null);\n\t\t\t});\n\t\t};\n\t\tif (WebAssembly.compileStreaming) {\n\t\t\tWebAssembly.compileStreaming(fetchPromise).then(module_ => {\n\t\t\t\tif (basisCode) {\n\t\t\t\t\tsendResponse(basisCode, module_);\n\t\t\t\t} else {\n\t\t\t\t\tmodule = module_;\n\t\t\t\t}\n\t\t\t}).catch(err => {\n\t\t\t\tcompileManual();\n\t\t\t});\n\t\t} else {\n\t\t\tcompileManual();\n\t\t}\n\t} else {\n\t\thttp.get(config.fallbackUrl, options, (err, response) => {\n\t\t\tif (err) {\n\t\t\t\tcallback(err, null);\n\t\t\t} else {\n\t\t\t\tsendResponse(response, null);\n\t\t\t}\n\t\t});\n\t}\n};\nclass BasisQueue {\n\tconstructor() {\n\t\tthis.callbacks = {};\n\t\tthis.queue = [];\n\t\tthis.clients = [];\n\t}\n\tenqueueJob(url, data, callback, options) {\n\t\tif (this.callbacks.hasOwnProperty(url)) {\n\t\t\tthis.callbacks[url].push(callback);\n\t\t} else {\n\t\t\tthis.callbacks[url] = [callback];\n\t\t\tconst job = {\n\t\t\t\turl: url,\n\t\t\t\tdata: data,\n\t\t\t\toptions: options\n\t\t\t};\n\t\t\tif (this.clients.length > 0) {\n\t\t\t\tthis.clients.shift().run(job);\n\t\t\t} else {\n\t\t\t\tthis.queue.push(job);\n\t\t\t}\n\t\t}\n\t}\n\tenqueueClient(client) {\n\t\tif (this.queue.length > 0) {\n\t\t\tclient.run(this.queue.shift());\n\t\t} else {\n\t\t\tthis.clients.push(client);\n\t\t}\n\t}\n\thandleResponse(url, err, data) {\n\t\tconst callback = this.callbacks[url];\n\t\tif (err) {\n\t\t\tfor (let i = 0; i < callback.length; ++i) {\n\t\t\t\tcallback[i](err);\n\t\t\t}\n\t\t} else {\n\t\t\tif (data.format === PIXELFORMAT_RGB565 || data.format === PIXELFORMAT_RGBA4) {\n\t\t\t\tdata.levels = data.levels.map(function (v) {\n\t\t\t\t\treturn new Uint16Array(v);\n\t\t\t\t});\n\t\t\t} else {\n\t\t\t\tdata.levels = data.levels.map(function (v) {\n\t\t\t\t\treturn new Uint8Array(v);\n\t\t\t\t});\n\t\t\t}\n\t\t\tfor (let i = 0; i < callback.length; ++i) {\n\t\t\t\tcallback[i](null, data);\n\t\t\t}\n\t\t}\n\t\tdelete this.callbacks[url];\n\t}\n}\nclass BasisClient {\n\tconstructor(queue, config, eager) {\n\t\tthis.queue = queue;\n\t\tthis.worker = new Worker(config.workerUrl);\n\t\tthis.worker.addEventListener('message', message => {\n\t\t\tconst data = message.data;\n\t\t\tthis.queue.handleResponse(data.url, data.err, data.data);\n\t\t\tif (!this.eager) {\n\t\t\t\tthis.queue.enqueueClient(this);\n\t\t\t}\n\t\t});\n\t\tthis.worker.postMessage({\n\t\t\ttype: 'init',\n\t\t\tconfig: config\n\t\t});\n\t\tthis.eager = eager;\n\t}\n\trun(job) {\n\t\tconst transfer = [];\n\t\tif (job.data instanceof ArrayBuffer) {\n\t\t\ttransfer.push(job.data);\n\t\t}\n\t\tthis.worker.postMessage({\n\t\t\ttype: 'transcode',\n\t\t\turl: job.url,\n\t\t\tformat: job.format,\n\t\t\tdata: job.data,\n\t\t\toptions: job.options\n\t\t}, transfer);\n\t\tif (this.eager) {\n\t\t\tthis.queue.enqueueClient(this);\n\t\t}\n\t}\n}\nconst defaultNumWorkers = 1;\nconst defaultRgbPriority = ['etc1', 'etc2', 'astc', 'dxt', 'pvr', 'atc'];\nconst defaultRgbaPriority = ['astc', 'dxt', 'etc2', 'pvr', 'atc'];\nconst defaultMaxRetries = 5;\nconst queue = new BasisQueue();\nlet lazyConfig = null;\nlet initializing = false;\nfunction basisInitialize(config) {\n\tif (initializing) {\n\t\treturn;\n\t}\n\tif (!config) {\n\t\tconfig = lazyConfig || {};\n\t} else if (config.lazyInit) {\n\t\tlazyConfig = config;\n\t\treturn;\n\t}\n\tif (!config.glueUrl || !config.wasmUrl || !config.fallbackUrl) {\n\t\tconst moduleConfig = WasmModule.getConfig('BASIS');\n\t\tif (moduleConfig) {\n\t\t\tconfig = {\n\t\t\t\tglueUrl: moduleConfig.glueUrl,\n\t\t\t\twasmUrl: moduleConfig.wasmUrl,\n\t\t\t\tfallbackUrl: moduleConfig.fallbackUrl,\n\t\t\t\tnumWorkers: moduleConfig.numWorkers\n\t\t\t};\n\t\t}\n\t}\n\tif (config.glueUrl || config.wasmUrl || config.fallbackUrl) {\n\t\tinitializing = true;\n\t\tconst numWorkers = Math.max(1, Math.min(16, config.numWorkers || defaultNumWorkers));\n\t\tconst eagerWorkers = config.numWorkers === 1 || (config.hasOwnProperty('eagerWorkers') ? config.eagerWorkers : true);\n\t\tconfig.rgbPriority = config.rgbPriority || defaultRgbPriority;\n\t\tconfig.rgbaPriority = config.rgbaPriority || defaultRgbaPriority;\n\t\tconfig.maxRetries = config.hasOwnProperty('maxRetries') ? config.maxRetries : defaultMaxRetries;\n\t\tprepareWorkerModules(config, (err, clientConfig) => {\n\t\t\tif (err) {\n\t\t\t\tconsole.error(`failed to initialize basis worker: ${err}`);\n\t\t\t} else {\n\t\t\t\tfor (let i = 0; i < numWorkers; ++i) {\n\t\t\t\t\tqueue.enqueueClient(new BasisClient(queue, clientConfig, eagerWorkers));\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t}\n}\nlet deviceDetails = null;\nfunction basisTranscode(device, url, data, callback, options) {\n\tbasisInitialize();\n\tif (!deviceDetails) {\n\t\tdeviceDetails = {\n\t\t\twebgl2: device.isWebGL2,\n\t\t\tformats: getCompressionFormats(device)\n\t\t};\n\t}\n\tqueue.enqueueJob(url, data, callback, {\n\t\tdeviceDetails: deviceDetails,\n\t\tisGGGR: !!(options != null && options.isGGGR),\n\t\tisKTX2: !!(options != null && options.isKTX2)\n\t});\n\treturn initializing;\n}\n\nexport { basisInitialize, basisTranscode };\n", "class TextureParser {\n\tload(url, callback, asset) {\n\t\tthrow new Error('not implemented');\n\t}\n\topen(url, data, device) {\n\t\tthrow new Error('not implemented');\n\t}\n}\n\nexport { TextureParser };\n", "import { extends as _extends } from '../../../../_virtual/_rollupPluginBabelHelpers.js';\nimport { ADDRESS_CLAMP_TO_EDGE, ADDRESS_REPEAT } from '../../../platform/graphics/constants.js';\nimport { Texture } from '../../../platform/graphics/texture.js';\nimport { Asset } from '../../asset/asset.js';\nimport { basisTranscode } from '../../handlers/basis.js';\nimport { TextureParser } from './texture.js';\n\nclass BasisParser extends TextureParser {\n\tconstructor(registry, device) {\n\t\tsuper();\n\t\tthis.device = device;\n\t\tthis.maxRetries = 0;\n\t}\n\tload(url, callback, asset) {\n\t\tconst device = this.device;\n\t\tconst transcode = data => {\n\t\t\tvar _asset$file;\n\t\t\tconst basisModuleFound = basisTranscode(device, url.load, data, callback, {\n\t\t\t\tisGGGR: ((asset == null || (_asset$file = asset.file) == null || (_asset$file = _asset$file.variants) == null || (_asset$file = _asset$file.basis) == null ? void 0 : _asset$file.opt) & 8) !== 0\n\t\t\t});\n\t\t\tif (!basisModuleFound) {\n\t\t\t\tcallback(`Basis module not found. Asset '${asset.name}' basis texture variant will not be loaded.`);\n\t\t\t}\n\t\t};\n\t\tAsset.fetchArrayBuffer(url.load, (err, result) => {\n\t\t\tif (err) {\n\t\t\t\tcallback(err);\n\t\t\t} else {\n\t\t\t\ttranscode(result);\n\t\t\t}\n\t\t}, asset, this.maxRetries);\n\t}\n\topen(url, data, device, textureOptions = {}) {\n\t\tconst texture = new Texture(device, _extends({\n\t\t\tname: url,\n\t\t\taddressU: data.cubemap ? ADDRESS_CLAMP_TO_EDGE : ADDRESS_REPEAT,\n\t\t\taddressV: data.cubemap ? ADDRESS_CLAMP_TO_EDGE : ADDRESS_REPEAT,\n\t\t\twidth: data.width,\n\t\t\theight: data.height,\n\t\t\tformat: data.format,\n\t\t\tcubemap: data.cubemap,\n\t\t\tlevels: data.levels\n\t\t}, textureOptions));\n\t\ttexture.upload();\n\t\treturn texture;\n\t}\n}\n\nexport { BasisParser };\n", "import { extends as _extends } from '../../../../_virtual/_rollupPluginBabelHelpers.js';\nimport { PIXELFORMAT_RGBA8 } from '../../../platform/graphics/constants.js';\nimport { Texture } from '../../../platform/graphics/texture.js';\nimport { http } from '../../../platform/net/http.js';\nimport { ABSOLUTE_URL } from '../../asset/constants.js';\nimport { TextureParser } from './texture.js';\n\nclass ImgParser extends TextureParser {\n\tconstructor(registry, device) {\n\t\tsuper();\n\t\tthis.crossOrigin = registry.prefix ? 'anonymous' : null;\n\t\tthis.maxRetries = 0;\n\t\tthis.device = device;\n\t}\n\tload(url, callback, asset) {\n\t\tvar _asset$file;\n\t\tconst hasContents = !!(asset != null && (_asset$file = asset.file) != null && _asset$file.contents);\n\t\tif (hasContents) {\n\t\t\tif (this.device.supportsImageBitmap) {\n\t\t\t\tthis._loadImageBitmapFromBlob(new Blob([asset.file.contents]), callback);\n\t\t\t\treturn;\n\t\t\t}\n\t\t\turl = {\n\t\t\t\tload: URL.createObjectURL(new Blob([asset.file.contents])),\n\t\t\t\toriginal: url.original\n\t\t\t};\n\t\t}\n\t\tconst handler = (err, result) => {\n\t\t\tif (hasContents) {\n\t\t\t\tURL.revokeObjectURL(url.load);\n\t\t\t}\n\t\t\tcallback(err, result);\n\t\t};\n\t\tlet crossOrigin;\n\t\tif (asset && asset.options && asset.options.hasOwnProperty('crossOrigin')) {\n\t\t\tcrossOrigin = asset.options.crossOrigin;\n\t\t} else if (ABSOLUTE_URL.test(url.load)) {\n\t\t\tcrossOrigin = this.crossOrigin;\n\t\t}\n\t\tif (this.device.supportsImageBitmap) {\n\t\t\tthis._loadImageBitmap(url.load, url.original, crossOrigin, handler);\n\t\t} else {\n\t\t\tthis._loadImage(url.load, url.original, crossOrigin, handler);\n\t\t}\n\t}\n\topen(url, data, device, textureOptions = {}) {\n\t\tconst texture = new Texture(device, _extends({\n\t\t\tname: url,\n\t\t\twidth: data.width,\n\t\t\theight: data.height,\n\t\t\tformat: PIXELFORMAT_RGBA8\n\t\t}, textureOptions));\n\t\ttexture.setSource(data);\n\t\treturn texture;\n\t}\n\t_loadImage(url, originalUrl, crossOrigin, callback) {\n\t\tconst image = new Image();\n\t\tif (crossOrigin) {\n\t\t\timage.crossOrigin = crossOrigin;\n\t\t}\n\t\tlet retries = 0;\n\t\tconst maxRetries = this.maxRetries;\n\t\tlet retryTimeout;\n\t\timage.onload = function () {\n\t\t\tcallback(null, image);\n\t\t};\n\t\timage.onerror = function () {\n\t\t\tif (retryTimeout) return;\n\t\t\tif (maxRetries > 0 && ++retries <= maxRetries) {\n\t\t\t\tconst retryDelay = Math.pow(2, retries) * 100;\n\t\t\t\tconsole.log(`Error loading Texture from: '${originalUrl}' - Retrying in ${retryDelay}ms...`);\n\t\t\t\tconst idx = url.indexOf('?');\n\t\t\t\tconst separator = idx >= 0 ? '&' : '?';\n\t\t\t\tretryTimeout = setTimeout(function () {\n\t\t\t\t\timage.src = url + separator + 'retry=' + Date.now();\n\t\t\t\t\tretryTimeout = null;\n\t\t\t\t}, retryDelay);\n\t\t\t} else {\n\t\t\t\tcallback(`Error loading Texture from: '${originalUrl}'`);\n\t\t\t}\n\t\t};\n\t\timage.src = url;\n\t}\n\t_loadImageBitmap(url, originalUrl, crossOrigin, callback) {\n\t\tconst options = {\n\t\t\tcache: true,\n\t\t\tresponseType: 'blob',\n\t\t\tretry: this.maxRetries > 0,\n\t\t\tmaxRetries: this.maxRetries\n\t\t};\n\t\thttp.get(url, options, (err, blob) => {\n\t\t\tif (err) {\n\t\t\t\tcallback(err);\n\t\t\t} else {\n\t\t\t\tthis._loadImageBitmapFromBlob(blob, callback);\n\t\t\t}\n\t\t});\n\t}\n\t_loadImageBitmapFromBlob(blob, callback) {\n\t\tcreateImageBitmap(blob, {\n\t\t\tpremultiplyAlpha: 'none',\n\t\t\tcolorSpaceConversion: 'none'\n\t\t}).then(imageBitmap => callback(null, imageBitmap)).catch(e => callback(e));\n\t}\n}\n\nexport { ImgParser };\n", "import { extends as _extends } from '../../../../_virtual/_rollupPluginBabelHelpers.js';\nimport { ADDRESS_CLAMP_TO_EDGE, ADDRESS_REPEAT, PIXELFORMAT_DXT1, PIXELFORMAT_DXT3, PIXELFORMAT_DXT5, PIXELFORMAT_ETC1, PIXELFORMAT_ETC2_RGB, PIXELFORMAT_ETC2_RGBA, PIXELFORMAT_PVRTC_4BPP_RGB_1, PIXELFORMAT_PVRTC_2BPP_RGB_1, PIXELFORMAT_PVRTC_4BPP_RGBA_1, PIXELFORMAT_PVRTC_2BPP_RGBA_1, PIXELFORMAT_RGB8, PIXELFORMAT_RGBA8, PIXELFORMAT_SRGB, PIXELFORMAT_SRGBA, PIXELFORMAT_111110F, PIXELFORMAT_RGB16F, PIXELFORMAT_RGBA16F } from '../../../platform/graphics/constants.js';\nimport { Texture } from '../../../platform/graphics/texture.js';\nimport { Asset } from '../../asset/asset.js';\nimport { TextureParser } from './texture.js';\n\nconst IDENTIFIER = [0x58544BAB, 0xBB313120, 0x0A1A0A0D];\nconst KNOWN_FORMATS = {\n\t0x83F0: PIXELFORMAT_DXT1,\n\t0x83F2: PIXELFORMAT_DXT3,\n\t0x83F3: PIXELFORMAT_DXT5,\n\t0x8D64: PIXELFORMAT_ETC1,\n\t0x9274: PIXELFORMAT_ETC2_RGB,\n\t0x9278: PIXELFORMAT_ETC2_RGBA,\n\t0x8C00: PIXELFORMAT_PVRTC_4BPP_RGB_1,\n\t0x8C01: PIXELFORMAT_PVRTC_2BPP_RGB_1,\n\t0x8C02: PIXELFORMAT_PVRTC_4BPP_RGBA_1,\n\t0x8C03: PIXELFORMAT_PVRTC_2BPP_RGBA_1,\n\t0x8051: PIXELFORMAT_RGB8,\n\t0x8058: PIXELFORMAT_RGBA8,\n\t0x8C41: PIXELFORMAT_SRGB,\n\t0x8C43: PIXELFORMAT_SRGBA,\n\t0x8C3A: PIXELFORMAT_111110F,\n\t0x881B: PIXELFORMAT_RGB16F,\n\t0x881A: PIXELFORMAT_RGBA16F\n};\nfunction createContainer(pixelFormat, buffer, byteOffset, byteSize) {\n\treturn pixelFormat === PIXELFORMAT_111110F ? new Uint32Array(buffer, byteOffset, byteSize / 4) : new Uint8Array(buffer, byteOffset, byteSize);\n}\nclass KtxParser extends TextureParser {\n\tconstructor(registry) {\n\t\tsuper();\n\t\tthis.maxRetries = 0;\n\t}\n\tload(url, callback, asset) {\n\t\tAsset.fetchArrayBuffer(url.load, callback, asset, this.maxRetries);\n\t}\n\topen(url, data, device, textureOptions = {}) {\n\t\tconst textureData = this.parse(data);\n\t\tif (!textureData) {\n\t\t\treturn null;\n\t\t}\n\t\tconst texture = new Texture(device, _extends({\n\t\t\tname: url,\n\t\t\taddressU: textureData.cubemap ? ADDRESS_CLAMP_TO_EDGE : ADDRESS_REPEAT,\n\t\t\taddressV: textureData.cubemap ? ADDRESS_CLAMP_TO_EDGE : ADDRESS_REPEAT,\n\t\t\twidth: textureData.width,\n\t\t\theight: textureData.height,\n\t\t\tformat: textureData.format,\n\t\t\tcubemap: textureData.cubemap,\n\t\t\tlevels: textureData.levels\n\t\t}, textureOptions));\n\t\ttexture.upload();\n\t\treturn texture;\n\t}\n\tparse(data) {\n\t\tconst dataU32 = new Uint32Array(data);\n\t\tif (IDENTIFIER[0] !== dataU32[0] || IDENTIFIER[1] !== dataU32[1] || IDENTIFIER[2] !== dataU32[2]) {\n\t\t\treturn null;\n\t\t}\n\t\tconst header = {\n\t\t\tendianness: dataU32[3],\n\t\t\tglType: dataU32[4],\n\t\t\tglTypeSize: dataU32[5],\n\t\t\tglFormat: dataU32[6],\n\t\t\tglInternalFormat: dataU32[7],\n\t\t\tglBaseInternalFormat: dataU32[8],\n\t\t\tpixelWidth: dataU32[9],\n\t\t\tpixelHeight: dataU32[10],\n\t\t\tpixelDepth: dataU32[11],\n\t\t\tnumberOfArrayElements: dataU32[12],\n\t\t\tnumberOfFaces: dataU32[13],\n\t\t\tnumberOfMipmapLevels: dataU32[14],\n\t\t\tbytesOfKeyValueData: dataU32[15]\n\t\t};\n\t\tif (header.pixelDepth > 1) {\n\t\t\treturn null;\n\t\t}\n\t\tif (header.numberOfArrayElements !== 0) {\n\t\t\treturn null;\n\t\t}\n\t\tconst format = KNOWN_FORMATS[header.glInternalFormat];\n\t\tif (format === undefined) {\n\t\t\treturn null;\n\t\t}\n\t\tlet offset = 16 + header.bytesOfKeyValueData / 4;\n\t\tconst isCubemap = header.numberOfFaces > 1;\n\t\tconst levels = [];\n\t\tfor (let mipmapLevel = 0; mipmapLevel < (header.numberOfMipmapLevels || 1); mipmapLevel++) {\n\t\t\tconst imageSizeInBytes = dataU32[offset++];\n\t\t\tif (isCubemap) {\n\t\t\t\tlevels.push([]);\n\t\t\t}\n\t\t\tconst target = isCubemap ? levels[mipmapLevel] : levels;\n\t\t\tfor (let face = 0; face < (isCubemap ? 6 : 1); ++face) {\n\t\t\t\ttarget.push(createContainer(format, data, offset * 4, imageSizeInBytes));\n\t\t\t\toffset += imageSizeInBytes + 3 >> 2;\n\t\t\t}\n\t\t}\n\t\treturn {\n\t\t\tformat: format,\n\t\t\twidth: header.pixelWidth,\n\t\t\theight: header.pixelHeight,\n\t\t\tlevels: levels,\n\t\t\tcubemap: isCubemap\n\t\t};\n\t}\n}\n\nexport { KtxParser };\n", "import { extends as _extends } from '../../../../_virtual/_rollupPluginBabelHelpers.js';\nimport { ReadStream } from '../../../core/read-stream.js';\nimport { ADDRESS_CLAMP_TO_EDGE, ADDRESS_REPEAT } from '../../../platform/graphics/constants.js';\nimport { Texture } from '../../../platform/graphics/texture.js';\nimport { Asset } from '../../asset/asset.js';\nimport { basisTranscode } from '../../handlers/basis.js';\nimport { TextureParser } from './texture.js';\n\nconst KHRConstants = {\n\tKHR_DF_MODEL_ETC1S: 163,\n\tKHR_DF_MODEL_UASTC: 166\n};\nclass Ktx2Parser extends TextureParser {\n\tconstructor(registry, device) {\n\t\tsuper();\n\t\tthis.maxRetries = 0;\n\t\tthis.device = device;\n\t}\n\tload(url, callback, asset) {\n\t\tAsset.fetchArrayBuffer(url.load, (err, result) => {\n\t\t\tif (err) {\n\t\t\t\tcallback(err, result);\n\t\t\t} else {\n\t\t\t\tthis.parse(result, url, callback, asset);\n\t\t\t}\n\t\t}, asset, this.maxRetries);\n\t}\n\topen(url, data, device, textureOptions = {}) {\n\t\tconst texture = new Texture(device, _extends({\n\t\t\tname: url,\n\t\t\taddressU: data.cubemap ? ADDRESS_CLAMP_TO_EDGE : ADDRESS_REPEAT,\n\t\t\taddressV: data.cubemap ? ADDRESS_CLAMP_TO_EDGE : ADDRESS_REPEAT,\n\t\t\twidth: data.width,\n\t\t\theight: data.height,\n\t\t\tformat: data.format,\n\t\t\tcubemap: data.cubemap,\n\t\t\tlevels: data.levels\n\t\t}, textureOptions));\n\t\ttexture.upload();\n\t\treturn texture;\n\t}\n\tparse(arraybuffer, url, callback, asset) {\n\t\tconst rs = new ReadStream(arraybuffer);\n\t\tconst magic = [rs.readU32be(), rs.readU32be(), rs.readU32be()];\n\t\tif (magic[0] !== 0xAB4B5458 || magic[1] !== 0x203230BB || magic[2] !== 0x0D0A1A0A) {\n\t\t\treturn null;\n\t\t}\n\t\tconst header = {\n\t\t\tvkFormat: rs.readU32(),\n\t\t\ttypeSize: rs.readU32(),\n\t\t\tpixelWidth: rs.readU32(),\n\t\t\tpixelHeight: rs.readU32(),\n\t\t\tpixelDepth: rs.readU32(),\n\t\t\tlayerCount: rs.readU32(),\n\t\t\tfaceCount: rs.readU32(),\n\t\t\tlevelCount: rs.readU32(),\n\t\t\tsupercompressionScheme: rs.readU32()\n\t\t};\n\t\tconst index = {\n\t\t\tdfdByteOffset: rs.readU32(),\n\t\t\tdfdByteLength: rs.readU32(),\n\t\t\tkvdByteOffset: rs.readU32(),\n\t\t\tkvdByteLength: rs.readU32(),\n\t\t\tsgdByteOffset: rs.readU64(),\n\t\t\tsgdByteLength: rs.readU64()\n\t\t};\n\t\tconst levels = [];\n\t\tfor (let i = 0; i < Math.max(1, header.levelCount); ++i) {\n\t\t\tlevels.push({\n\t\t\t\tbyteOffset: rs.readU64(),\n\t\t\t\tbyteLength: rs.readU64(),\n\t\t\t\tuncompressedByteLength: rs.readU64()\n\t\t\t});\n\t\t}\n\t\tconst dfdTotalSize = rs.readU32();\n\t\tif (dfdTotalSize !== index.kvdByteOffset - index.dfdByteOffset) {\n\t\t\treturn null;\n\t\t}\n\t\trs.skip(8);\n\t\tconst colorModel = rs.readU8();\n\t\trs.skip(index.dfdByteLength - 9);\n\t\trs.skip(index.kvdByteLength);\n\t\tif (header.supercompressionScheme === 1 || colorModel === KHRConstants.KHR_DF_MODEL_UASTC) {\n\t\t\tvar _asset$file;\n\t\t\tconst basisModuleFound = basisTranscode(this.device, url.load, arraybuffer, callback, {\n\t\t\t\tisGGGR: ((asset == null || (_asset$file = asset.file) == null || (_asset$file = _asset$file.variants) == null || (_asset$file = _asset$file.basis) == null ? void 0 : _asset$file.opt) & 8) !== 0,\n\t\t\t\tisKTX2: true\n\t\t\t});\n\t\t\tif (!basisModuleFound) {\n\t\t\t\tcallback('Basis module not found. Asset \"' + asset.name + '\" basis texture variant will not be loaded.');\n\t\t\t}\n\t\t} else {\n\t\t\tcallback('unsupported KTX2 pixel format');\n\t\t}\n\t}\n}\n\nexport { Ktx2Parser };\n", "import { extends as _extends } from '../../../../_virtual/_rollupPluginBabelHelpers.js';\nimport { PIXELFORMAT_RGB8, ADDRESS_CLAMP_TO_EDGE, ADDRESS_REPEAT, PIXELFORMAT_DXT1, PIXELFORMAT_DXT5, PIXELFORMAT_RGBA16F, PIXELFORMAT_RGBA32F, PIXELFORMAT_ETC1, PIXELFORMAT_PVRTC_2BPP_RGB_1, PIXELFORMAT_PVRTC_2BPP_RGBA_1, PIXELFORMAT_PVRTC_4BPP_RGB_1, PIXELFORMAT_PVRTC_4BPP_RGBA_1, PIXELFORMAT_RGBA8 } from '../../../platform/graphics/constants.js';\nimport { Texture } from '../../../platform/graphics/texture.js';\nimport { Asset } from '../../asset/asset.js';\nimport { TextureParser } from './texture.js';\n\nclass DdsParser extends TextureParser {\n\tconstructor(registry) {\n\t\tsuper();\n\t\tthis.maxRetries = 0;\n\t}\n\tload(url, callback, asset) {\n\t\tAsset.fetchArrayBuffer(url.load, callback, asset, this.maxRetries);\n\t}\n\topen(url, data, device, textureOptions = {}) {\n\t\tconst header = new Uint32Array(data, 0, 128 / 4);\n\t\tconst width = header[4];\n\t\tconst height = header[3];\n\t\tconst mips = Math.max(header[7], 1);\n\t\tconst isFourCc = header[20] === 4;\n\t\tconst fcc = header[21];\n\t\tconst bpp = header[22];\n\t\tconst isCubemap = header[28] === 65024;\n\t\tconst FCC_DXT1 = 827611204;\n\t\tconst FCC_DXT5 = 894720068;\n\t\tconst FCC_FP16 = 113;\n\t\tconst FCC_FP32 = 116;\n\t\tconst FCC_ETC1 = 826496069;\n\t\tconst FCC_PVRTC_2BPP_RGB_1 = 825438800;\n\t\tconst FCC_PVRTC_2BPP_RGBA_1 = 825504336;\n\t\tconst FCC_PVRTC_4BPP_RGB_1 = 825439312;\n\t\tconst FCC_PVRTC_4BPP_RGBA_1 = 825504848;\n\t\tlet compressed = false;\n\t\tlet etc1 = false;\n\t\tlet pvrtc2 = false;\n\t\tlet pvrtc4 = false;\n\t\tlet format = null;\n\t\tlet componentSize = 1;\n\t\tlet texture;\n\t\tif (isFourCc) {\n\t\t\tif (fcc === FCC_DXT1) {\n\t\t\t\tformat = PIXELFORMAT_DXT1;\n\t\t\t\tcompressed = true;\n\t\t\t} else if (fcc === FCC_DXT5) {\n\t\t\t\tformat = PIXELFORMAT_DXT5;\n\t\t\t\tcompressed = true;\n\t\t\t} else if (fcc === FCC_FP16) {\n\t\t\t\tformat = PIXELFORMAT_RGBA16F;\n\t\t\t\tcomponentSize = 2;\n\t\t\t} else if (fcc === FCC_FP32) {\n\t\t\t\tformat = PIXELFORMAT_RGBA32F;\n\t\t\t\tcomponentSize = 4;\n\t\t\t} else if (fcc === FCC_ETC1) {\n\t\t\t\tformat = PIXELFORMAT_ETC1;\n\t\t\t\tcompressed = true;\n\t\t\t\tetc1 = true;\n\t\t\t} else if (fcc === FCC_PVRTC_2BPP_RGB_1 || fcc === FCC_PVRTC_2BPP_RGBA_1) {\n\t\t\t\tformat = fcc === FCC_PVRTC_2BPP_RGB_1 ? PIXELFORMAT_PVRTC_2BPP_RGB_1 : PIXELFORMAT_PVRTC_2BPP_RGBA_1;\n\t\t\t\tcompressed = true;\n\t\t\t\tpvrtc2 = true;\n\t\t\t} else if (fcc === FCC_PVRTC_4BPP_RGB_1 || fcc === FCC_PVRTC_4BPP_RGBA_1) {\n\t\t\t\tformat = fcc === FCC_PVRTC_4BPP_RGB_1 ? PIXELFORMAT_PVRTC_4BPP_RGB_1 : PIXELFORMAT_PVRTC_4BPP_RGBA_1;\n\t\t\t\tcompressed = true;\n\t\t\t\tpvrtc4 = true;\n\t\t\t}\n\t\t} else {\n\t\t\tif (bpp === 32) {\n\t\t\t\tformat = PIXELFORMAT_RGBA8;\n\t\t\t}\n\t\t}\n\t\tif (!format) {\n\t\t\ttexture = new Texture(device, {\n\t\t\t\twidth: 4,\n\t\t\t\theight: 4,\n\t\t\t\tformat: PIXELFORMAT_RGB8,\n\t\t\t\tname: 'dds-legacy-empty'\n\t\t\t});\n\t\t\treturn texture;\n\t\t}\n\t\ttexture = new Texture(device, _extends({\n\t\t\tname: url,\n\t\t\taddressU: isCubemap ? ADDRESS_CLAMP_TO_EDGE : ADDRESS_REPEAT,\n\t\t\taddressV: isCubemap ? ADDRESS_CLAMP_TO_EDGE : ADDRESS_REPEAT,\n\t\t\twidth: width,\n\t\t\theight: height,\n\t\t\tformat: format,\n\t\t\tcubemap: isCubemap,\n\t\t\tmipmaps: mips > 1\n\t\t}, textureOptions));\n\t\tlet offset = 128;\n\t\tconst faces = isCubemap ? 6 : 1;\n\t\tlet mipSize;\n\t\tconst DXT_BLOCK_WIDTH = 4;\n\t\tconst DXT_BLOCK_HEIGHT = 4;\n\t\tconst blockSize = fcc === FCC_DXT1 ? 8 : 16;\n\t\tlet numBlocksAcross, numBlocksDown, numBlocks;\n\t\tfor (let face = 0; face < faces; face++) {\n\t\t\tlet mipWidth = width;\n\t\t\tlet mipHeight = height;\n\t\t\tfor (let i = 0; i < mips; i++) {\n\t\t\t\tif (compressed) {\n\t\t\t\t\tif (etc1) {\n\t\t\t\t\t\tmipSize = Math.floor((mipWidth + 3) / 4) * Math.floor((mipHeight + 3) / 4) * 8;\n\t\t\t\t\t} else if (pvrtc2) {\n\t\t\t\t\t\tmipSize = Math.max(mipWidth, 16) * Math.max(mipHeight, 8) / 4;\n\t\t\t\t\t} else if (pvrtc4) {\n\t\t\t\t\t\tmipSize = Math.max(mipWidth, 8) * Math.max(mipHeight, 8) / 2;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tnumBlocksAcross = Math.floor((mipWidth + DXT_BLOCK_WIDTH - 1) / DXT_BLOCK_WIDTH);\n\t\t\t\t\t\tnumBlocksDown = Math.floor((mipHeight + DXT_BLOCK_HEIGHT - 1) / DXT_BLOCK_HEIGHT);\n\t\t\t\t\t\tnumBlocks = numBlocksAcross * numBlocksDown;\n\t\t\t\t\t\tmipSize = numBlocks * blockSize;\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tmipSize = mipWidth * mipHeight * 4;\n\t\t\t\t}\n\t\t\t\tconst mipBuff = format === PIXELFORMAT_RGBA32F ? new Float32Array(data, offset, mipSize) : format === PIXELFORMAT_RGBA16F ? new Uint16Array(data, offset, mipSize) : new Uint8Array(data, offset, mipSize);\n\t\t\t\tif (!isCubemap) {\n\t\t\t\t\ttexture._levels[i] = mipBuff;\n\t\t\t\t} else {\n\t\t\t\t\tif (!texture._levels[i]) texture._levels[i] = [];\n\t\t\t\t\ttexture._levels[i][face] = mipBuff;\n\t\t\t\t}\n\t\t\t\toffset += mipSize * componentSize;\n\t\t\t\tmipWidth = Math.max(mipWidth * 0.5, 1);\n\t\t\t\tmipHeight = Math.max(mipHeight * 0.5, 1);\n\t\t\t}\n\t\t}\n\t\ttexture.upload();\n\t\treturn texture;\n\t}\n}\n\nexport { DdsParser };\n", "import { extends as _extends } from '../../../../_virtual/_rollupPluginBabelHelpers.js';\nimport { ReadStream } from '../../../core/read-stream.js';\nimport { ADDRESS_REPEAT, ADDRESS_CLAMP_TO_EDGE, FILTER_NEAREST, PIXELFORMAT_RGBA8, TEXTURETYPE_RGBE } from '../../../platform/graphics/constants.js';\nimport { Texture } from '../../../platform/graphics/texture.js';\nimport { Asset } from '../../asset/asset.js';\nimport { TextureParser } from './texture.js';\n\nclass HdrParser extends TextureParser {\n\tconstructor(registry) {\n\t\tsuper();\n\t\tthis.maxRetries = 0;\n\t}\n\tload(url, callback, asset) {\n\t\tAsset.fetchArrayBuffer(url.load, callback, asset, this.maxRetries);\n\t}\n\topen(url, data, device, textureOptions = {}) {\n\t\tconst textureData = this.parse(data);\n\t\tif (!textureData) {\n\t\t\treturn null;\n\t\t}\n\t\tconst texture = new Texture(device, _extends({\n\t\t\tname: url,\n\t\t\taddressU: ADDRESS_REPEAT,\n\t\t\taddressV: ADDRESS_CLAMP_TO_EDGE,\n\t\t\tminFilter: FILTER_NEAREST,\n\t\t\tmagFilter: FILTER_NEAREST,\n\t\t\twidth: textureData.width,\n\t\t\theight: textureData.height,\n\t\t\tlevels: textureData.levels,\n\t\t\tformat: PIXELFORMAT_RGBA8,\n\t\t\ttype: TEXTURETYPE_RGBE,\n\t\t\tmipmaps: false\n\t\t}, textureOptions));\n\t\ttexture.upload();\n\t\treturn texture;\n\t}\n\tparse(data) {\n\t\tconst readStream = new ReadStream(data);\n\t\tconst magic = readStream.readLine();\n\t\tif (!magic.startsWith('#?RADIANCE')) {\n\t\t\treturn null;\n\t\t}\n\t\tconst variables = {};\n\t\twhile (true) {\n\t\t\tconst line = readStream.readLine();\n\t\t\tif (line.length === 0) {\n\t\t\t\tbreak;\n\t\t\t} else {\n\t\t\t\tconst parts = line.split('=');\n\t\t\t\tif (parts.length === 2) {\n\t\t\t\t\tvariables[parts[0]] = parts[1];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (!variables.hasOwnProperty('FORMAT')) {\n\t\t\treturn null;\n\t\t}\n\t\tconst resolution = readStream.readLine().split(' ');\n\t\tif (resolution.length !== 4) {\n\t\t\treturn null;\n\t\t}\n\t\tconst height = parseInt(resolution[1], 10);\n\t\tconst width = parseInt(resolution[3], 10);\n\t\tconst pixels = this._readPixels(readStream, width, height, resolution[0] === '-Y');\n\t\tif (!pixels) {\n\t\t\treturn null;\n\t\t}\n\t\treturn {\n\t\t\twidth: width,\n\t\t\theight: height,\n\t\t\tlevels: [pixels]\n\t\t};\n\t}\n\t_readPixels(readStream, width, height, flipY) {\n\t\tif (width < 8 || width > 0x7fff) {\n\t\t\treturn this._readPixelsFlat(readStream, width, height);\n\t\t}\n\t\tconst rgbe = [0, 0, 0, 0];\n\t\treadStream.readArray(rgbe);\n\t\tif (rgbe[0] !== 2 || rgbe[1] !== 2 || (rgbe[2] & 0x80) !== 0) {\n\t\t\treadStream.skip(-4);\n\t\t\treturn this._readPixelsFlat(readStream, width, height);\n\t\t}\n\t\tconst buffer = new ArrayBuffer(width * height * 4);\n\t\tconst view = new Uint8Array(buffer);\n\t\tlet scanstart = flipY ? 0 : width * 4 * (height - 1);\n\t\tlet x, y, i, channel, count, value;\n\t\tfor (y = 0; y < height; ++y) {\n\t\t\tif (y) {\n\t\t\t\treadStream.readArray(rgbe);\n\t\t\t}\n\t\t\tif ((rgbe[2] << 8) + rgbe[3] !== width) {\n\t\t\t\treturn null;\n\t\t\t}\n\t\t\tfor (channel = 0; channel < 4; ++channel) {\n\t\t\t\tx = 0;\n\t\t\t\twhile (x < width) {\n\t\t\t\t\tcount = readStream.readU8();\n\t\t\t\t\tif (count > 128) {\n\t\t\t\t\t\tcount -= 128;\n\t\t\t\t\t\tif (x + count > width) {\n\t\t\t\t\t\t\treturn null;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tvalue = readStream.readU8();\n\t\t\t\t\t\tfor (i = 0; i < count; ++i) {\n\t\t\t\t\t\t\tview[scanstart + channel + 4 * x++] = value;\n\t\t\t\t\t\t}\n\t\t\t\t\t} else {\n\t\t\t\t\t\tif (count === 0 || x + count > width) {\n\t\t\t\t\t\t\treturn null;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tfor (i = 0; i < count; ++i) {\n\t\t\t\t\t\t\tview[scanstart + channel + 4 * x++] = readStream.readU8();\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tscanstart += width * 4 * (flipY ? 1 : -1);\n\t\t}\n\t\treturn view;\n\t}\n\t_readPixelsFlat(readStream, width, height) {\n\t\treturn readStream.remainingBytes === width * height * 4 ? new Uint8Array(readStream.arraybuffer, readStream.offset) : null;\n\t}\n}\n\nexport { HdrParser };\n", "import { path } from '../../core/path.js';\nimport { TEXTURETYPE_RGBM, TEXTURETYPE_SWIZZLEGGGR, PIXELFORMAT_RGB8, ADDRESS_REPEAT, ADDRESS_CLAMP_TO_EDGE, ADDRESS_MIRRORED_REPEAT, FILTER_NEAREST, FILTER_LINEAR, FILTER_NEAREST_MIPMAP_NEAREST, FILTER_LINEAR_MIPMAP_NEAREST, FILTER_NEAREST_MIPMAP_LINEAR, FILTER_LINEAR_MIPMAP_LINEAR, TEXTURETYPE_DEFAULT, TEXTURETYPE_RGBE, TEXTURETYPE_RGBP, PIXELFORMAT_RGBA8, PIXELFORMAT_RGBA32F } from '../../platform/graphics/constants.js';\nimport { Texture } from '../../platform/graphics/texture.js';\nimport { TextureUtils } from '../../platform/graphics/texture-utils.js';\nimport { BasisParser } from '../parsers/texture/basis.js';\nimport { ImgParser } from '../parsers/texture/img.js';\nimport { KtxParser } from '../parsers/texture/ktx.js';\nimport { Ktx2Parser } from '../parsers/texture/ktx2.js';\nimport { DdsParser } from '../parsers/texture/dds.js';\nimport { HdrParser } from '../parsers/texture/hdr.js';\nimport { ResourceHandler } from './handler.js';\n\nconst JSON_ADDRESS_MODE = {\n\t'repeat': ADDRESS_REPEAT,\n\t'clamp': ADDRESS_CLAMP_TO_EDGE,\n\t'mirror': ADDRESS_MIRRORED_REPEAT\n};\nconst JSON_FILTER_MODE = {\n\t'nearest': FILTER_NEAREST,\n\t'linear': FILTER_LINEAR,\n\t'nearest_mip_nearest': FILTER_NEAREST_MIPMAP_NEAREST,\n\t'linear_mip_nearest': FILTER_LINEAR_MIPMAP_NEAREST,\n\t'nearest_mip_linear': FILTER_NEAREST_MIPMAP_LINEAR,\n\t'linear_mip_linear': FILTER_LINEAR_MIPMAP_LINEAR\n};\nconst JSON_TEXTURE_TYPE = {\n\t'default': TEXTURETYPE_DEFAULT,\n\t'rgbm': TEXTURETYPE_RGBM,\n\t'rgbe': TEXTURETYPE_RGBE,\n\t'rgbp': TEXTURETYPE_RGBP,\n\t'swizzleGGGR': TEXTURETYPE_SWIZZLEGGGR\n};\nconst _completePartialMipmapChain = function _completePartialMipmapChain(texture) {\n\tconst requiredMipLevels = TextureUtils.calcMipLevelsCount(texture._width, texture._height);\n\tconst isHtmlElement = function isHtmlElement(object) {\n\t\treturn object instanceof HTMLCanvasElement || object instanceof HTMLImageElement || object instanceof HTMLVideoElement;\n\t};\n\tif (!(texture._format === PIXELFORMAT_RGBA8 || texture._format === PIXELFORMAT_RGBA32F) || texture._volume || texture._compressed || texture._levels.length === 1 || texture._levels.length === requiredMipLevels || isHtmlElement(texture._cubemap ? texture._levels[0][0] : texture._levels[0])) {\n\t\treturn;\n\t}\n\tconst downsample = function downsample(width, height, data) {\n\t\tconst sampledWidth = Math.max(1, width >> 1);\n\t\tconst sampledHeight = Math.max(1, height >> 1);\n\t\tconst sampledData = new data.constructor(sampledWidth * sampledHeight * 4);\n\t\tconst xs = Math.floor(width / sampledWidth);\n\t\tconst ys = Math.floor(height / sampledHeight);\n\t\tconst xsys = xs * ys;\n\t\tfor (let y = 0; y < sampledHeight; ++y) {\n\t\t\tfor (let x = 0; x < sampledWidth; ++x) {\n\t\t\t\tfor (let e = 0; e < 4; ++e) {\n\t\t\t\t\tlet sum = 0;\n\t\t\t\t\tfor (let sy = 0; sy < ys; ++sy) {\n\t\t\t\t\t\tfor (let sx = 0; sx < xs; ++sx) {\n\t\t\t\t\t\t\tsum += data[(x * xs + sx + (y * ys + sy) * width) * 4 + e];\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tsampledData[(x + y * sampledWidth) * 4 + e] = sum / xsys;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn sampledData;\n\t};\n\tfor (let level = texture._levels.length; level < requiredMipLevels; ++level) {\n\t\tconst width = Math.max(1, texture._width >> level - 1);\n\t\tconst height = Math.max(1, texture._height >> level - 1);\n\t\tif (texture._cubemap) {\n\t\t\tconst mips = [];\n\t\t\tfor (let face = 0; face < 6; ++face) {\n\t\t\t\tmips.push(downsample(width, height, texture._levels[level - 1][face]));\n\t\t\t}\n\t\t\ttexture._levels.push(mips);\n\t\t} else {\n\t\t\ttexture._levels.push(downsample(width, height, texture._levels[level - 1]));\n\t\t}\n\t}\n\ttexture._levelsUpdated = texture._cubemap ? [[true, true, true, true, true, true]] : [true];\n};\nclass TextureHandler extends ResourceHandler {\n\tconstructor(app) {\n\t\tsuper(app, 'texture');\n\t\tconst assets = app.assets;\n\t\tconst device = app.graphicsDevice;\n\t\tthis._device = device;\n\t\tthis._assets = assets;\n\t\tthis.imgParser = new ImgParser(assets, device);\n\t\tthis.parsers = {\n\t\t\tdds: new DdsParser(assets),\n\t\t\tktx: new KtxParser(assets),\n\t\t\tktx2: new Ktx2Parser(assets, device),\n\t\t\tbasis: new BasisParser(assets, device),\n\t\t\thdr: new HdrParser(assets)\n\t\t};\n\t}\n\tset crossOrigin(value) {\n\t\tthis.imgParser.crossOrigin = value;\n\t}\n\tget crossOrigin() {\n\t\treturn this.imgParser.crossOrigin;\n\t}\n\tset maxRetries(value) {\n\t\tthis.imgParser.maxRetries = value;\n\t\tfor (const parser in this.parsers) {\n\t\t\tif (this.parsers.hasOwnProperty(parser)) {\n\t\t\t\tthis.parsers[parser].maxRetries = value;\n\t\t\t}\n\t\t}\n\t}\n\tget maxRetries() {\n\t\treturn this.imgParser.maxRetries;\n\t}\n\t_getUrlWithoutParams(url) {\n\t\treturn url.indexOf('?') >= 0 ? url.split('?')[0] : url;\n\t}\n\t_getParser(url) {\n\t\tconst ext = path.getExtension(this._getUrlWithoutParams(url)).toLowerCase().replace('.', '');\n\t\treturn this.parsers[ext] || this.imgParser;\n\t}\n\t_getTextureOptions(asset) {\n\t\tconst options = {};\n\t\tif (asset) {\n\t\t\tvar _asset$name;\n\t\t\tif (((_asset$name = asset.name) == null ? void 0 : _asset$name.length) > 0) {\n\t\t\t\toptions.name = asset.name;\n\t\t\t}\n\t\t\tconst assetData = asset.data;\n\t\t\tif (assetData.hasOwnProperty('minfilter')) {\n\t\t\t\toptions.minFilter = JSON_FILTER_MODE[assetData.minfilter];\n\t\t\t}\n\t\t\tif (assetData.hasOwnProperty('magfilter')) {\n\t\t\t\toptions.magFilter = JSON_FILTER_MODE[assetData.magfilter];\n\t\t\t}\n\t\t\tif (assetData.hasOwnProperty('addressu')) {\n\t\t\t\toptions.addressU = JSON_ADDRESS_MODE[assetData.addressu];\n\t\t\t}\n\t\t\tif (assetData.hasOwnProperty('addressv')) {\n\t\t\t\toptions.addressV = JSON_ADDRESS_MODE[assetData.addressv];\n\t\t\t}\n\t\t\tif (assetData.hasOwnProperty('mipmaps')) {\n\t\t\t\toptions.mipmaps = assetData.mipmaps;\n\t\t\t}\n\t\t\tif (assetData.hasOwnProperty('anisotropy')) {\n\t\t\t\toptions.anisotropy = assetData.anisotropy;\n\t\t\t}\n\t\t\tif (assetData.hasOwnProperty('flipY')) {\n\t\t\t\toptions.flipY = !!assetData.flipY;\n\t\t\t}\n\t\t\tif (assetData.hasOwnProperty('type')) {\n\t\t\t\toptions.type = JSON_TEXTURE_TYPE[assetData.type];\n\t\t\t} else if (assetData.hasOwnProperty('rgbm') && assetData.rgbm) {\n\t\t\t\toptions.type = TEXTURETYPE_RGBM;\n\t\t\t} else if (asset.file && (asset.file.opt & 8) !== 0) {\n\t\t\t\toptions.type = TEXTURETYPE_SWIZZLEGGGR;\n\t\t\t}\n\t\t}\n\t\treturn options;\n\t}\n\tload(url, callback, asset) {\n\t\tif (typeof url === 'string') {\n\t\t\turl = {\n\t\t\t\tload: url,\n\t\t\t\toriginal: url\n\t\t\t};\n\t\t}\n\t\tthis._getParser(url.original).load(url, callback, asset);\n\t}\n\topen(url, data, asset) {\n\t\tif (!url) return undefined;\n\t\tconst textureOptions = this._getTextureOptions(asset);\n\t\tlet texture = this._getParser(url).open(url, data, this._device, textureOptions);\n\t\tif (texture === null) {\n\t\t\ttexture = new Texture(this._device, {\n\t\t\t\twidth: 4,\n\t\t\t\theight: 4,\n\t\t\t\tformat: PIXELFORMAT_RGB8\n\t\t\t});\n\t\t} else {\n\t\t\t_completePartialMipmapChain(texture);\n\t\t\tif (data.unswizzledGGGR) {\n\t\t\t\tasset.file.variants.basis.opt &= ~8;\n\t\t\t}\n\t\t}\n\t\treturn texture;\n\t}\n\tpatch(asset, assets) {\n\t\tconst texture = asset.resource;\n\t\tif (!texture) {\n\t\t\treturn;\n\t\t}\n\t\tconst options = this._getTextureOptions(asset);\n\t\tfor (const key of Object.keys(options)) {\n\t\t\ttexture[key] = options[key];\n\t\t}\n\t}\n}\n\nexport { TextureHandler };\n", "const XRTYPE_INLINE = 'inline';\nconst XRTYPE_VR = 'immersive-vr';\nconst XRTYPE_AR = 'immersive-ar';\nconst XRSPACE_VIEWER = 'viewer';\nconst XRSPACE_LOCAL = 'local';\nconst XRSPACE_LOCALFLOOR = 'local-floor';\nconst XRSPACE_BOUNDEDFLOOR = 'bounded-floor';\nconst XRSPACE_UNBOUNDED = 'unbounded';\nconst XRTARGETRAY_GAZE = 'gaze';\nconst XRTARGETRAY_SCREEN = 'screen';\nconst XRTARGETRAY_POINTER = 'tracked-pointer';\nconst XREYE_NONE = 'none';\nconst XREYE_LEFT = 'left';\nconst XREYE_RIGHT = 'right';\nconst XRHAND_NONE = 'none';\nconst XRHAND_LEFT = 'left';\nconst XRHAND_RIGHT = 'right';\nconst XRTRACKABLE_POINT = 'point';\nconst XRTRACKABLE_PLANE = 'plane';\nconst XRTRACKABLE_MESH = 'mesh';\nconst XRDEPTHSENSINGUSAGE_CPU = 'cpu-optimized';\nconst XRDEPTHSENSINGUSAGE_GPU = 'gpu-optimized';\nconst XRDEPTHSENSINGFORMAT_L8A8 = 'luminance-alpha';\nconst XRDEPTHSENSINGFORMAT_F32 = 'float32';\n\nexport { XRDEPTHSENSINGFORMAT_F32, XRDEPTHSENSINGFORMAT_L8A8, XRDEPTHSENSINGUSAGE_CPU, XRDEPTHSENSINGUSAGE_GPU, XREYE_LEFT, XREYE_NONE, XREYE_RIGHT, XRHAND_LEFT, XRHAND_NONE, XRHAND_RIGHT, XRSPACE_BOUNDEDFLOOR, XRSPACE_LOCAL, XRSPACE_LOCALFLOOR, XRSPACE_UNBOUNDED, XRSPACE_VIEWER, XRTARGETRAY_GAZE, XRTARGETRAY_POINTER, XRTARGETRAY_SCREEN, XRTRACKABLE_MESH, XRTRACKABLE_PLANE, XRTRACKABLE_POINT, XRTYPE_AR, XRTYPE_INLINE, XRTYPE_VR };\n", "class XrFinger {\n\tconstructor(index, hand) {\n\t\tthis._index = void 0;\n\t\tthis._hand = void 0;\n\t\tthis._joints = [];\n\t\tthis._tip = null;\n\t\tthis._index = index;\n\t\tthis._hand = hand;\n\t\tthis._hand._fingers.push(this);\n\t}\n\tget index() {\n\t\treturn this._index;\n\t}\n\tget hand() {\n\t\treturn this._hand;\n\t}\n\tget joints() {\n\t\treturn this._joints;\n\t}\n\tget tip() {\n\t\treturn this._tip;\n\t}\n}\n\nexport { XrFinger };\n", "import { platform } from '../../core/platform.js';\nimport { Mat4 } from '../../core/math/mat4.js';\nimport { Quat } from '../../core/math/quat.js';\nimport { Vec3 } from '../../core/math/vec3.js';\n\nconst tipJointIds = platform.browser && window.XRHand ? ['thumb-tip', 'index-finger-tip', 'middle-finger-tip', 'ring-finger-tip', 'pinky-finger-tip'] : [];\nconst tipJointIdsIndex = {};\nfor (let i = 0; i < tipJointIds.length; i++) {\n\ttipJointIdsIndex[tipJointIds[i]] = true;\n}\nclass XrJoint {\n\tconstructor(index, id, hand, finger = null) {\n\t\tthis._index = void 0;\n\t\tthis._id = void 0;\n\t\tthis._hand = void 0;\n\t\tthis._finger = void 0;\n\t\tthis._wrist = void 0;\n\t\tthis._tip = void 0;\n\t\tthis._radius = null;\n\t\tthis._localTransform = new Mat4();\n\t\tthis._worldTransform = new Mat4();\n\t\tthis._localPosition = new Vec3();\n\t\tthis._localRotation = new Quat();\n\t\tthis._position = new Vec3();\n\t\tthis._rotation = new Quat();\n\t\tthis._dirtyLocal = true;\n\t\tthis._index = index;\n\t\tthis._id = id;\n\t\tthis._hand = hand;\n\t\tthis._finger = finger;\n\t\tthis._wrist = id === 'wrist';\n\t\tthis._tip = this._finger && !!tipJointIdsIndex[id];\n\t}\n\tupdate(pose) {\n\t\tthis._dirtyLocal = true;\n\t\tthis._radius = pose.radius;\n\t\tthis._localPosition.copy(pose.transform.position);\n\t\tthis._localRotation.copy(pose.transform.orientation);\n\t}\n\t_updateTransforms() {\n\t\tif (this._dirtyLocal) {\n\t\t\tthis._dirtyLocal = false;\n\t\t\tthis._localTransform.setTRS(this._localPosition, this._localRotation, Vec3.ONE);\n\t\t}\n\t\tconst manager = this._hand._manager;\n\t\tconst parent = manager.camera.parent;\n\t\tif (parent) {\n\t\t\tthis._worldTransform.mul2(parent.getWorldTransform(), this._localTransform);\n\t\t} else {\n\t\t\tthis._worldTransform.copy(this._localTransform);\n\t\t}\n\t}\n\tgetPosition() {\n\t\tthis._updateTransforms();\n\t\tthis._worldTransform.getTranslation(this._position);\n\t\treturn this._position;\n\t}\n\tgetRotation() {\n\t\tthis._updateTransforms();\n\t\tthis._rotation.setFromMat4(this._worldTransform);\n\t\treturn this._rotation;\n\t}\n\tget index() {\n\t\treturn this._index;\n\t}\n\tget hand() {\n\t\treturn this._hand;\n\t}\n\tget finger() {\n\t\treturn this._finger;\n\t}\n\tget wrist() {\n\t\treturn this._wrist;\n\t}\n\tget tip() {\n\t\treturn this._tip;\n\t}\n\tget radius() {\n\t\treturn this._radius || 0.005;\n\t}\n}\n\nexport { XrJoint };\n", "import { EventHandler } from '../../core/event-handler.js';\nimport { platform } from '../../core/platform.js';\nimport { Vec3 } from '../../core/math/vec3.js';\nimport { XRHAND_LEFT } from './constants.js';\nimport { XrFinger } from './xr-finger.js';\nimport { XrJoint } from './xr-joint.js';\n\nlet fingerJointIds = [];\nconst vecA = new Vec3();\nconst vecB = new Vec3();\nconst vecC = new Vec3();\nif (platform.browser && window.XRHand) {\n\tfingerJointIds = [['thumb-metacarpal', 'thumb-phalanx-proximal', 'thumb-phalanx-distal', 'thumb-tip'], ['index-finger-metacarpal', 'index-finger-phalanx-proximal', 'index-finger-phalanx-intermediate', 'index-finger-phalanx-distal', 'index-finger-tip'], ['middle-finger-metacarpal', 'middle-finger-phalanx-proximal', 'middle-finger-phalanx-intermediate', 'middle-finger-phalanx-distal', 'middle-finger-tip'], ['ring-finger-metacarpal', 'ring-finger-phalanx-proximal', 'ring-finger-phalanx-intermediate', 'ring-finger-phalanx-distal', 'ring-finger-tip'], ['pinky-finger-metacarpal', 'pinky-finger-phalanx-proximal', 'pinky-finger-phalanx-intermediate', 'pinky-finger-phalanx-distal', 'pinky-finger-tip']];\n}\nclass XrHand extends EventHandler {\n\tconstructor(inputSource) {\n\t\tsuper();\n\t\tthis._manager = void 0;\n\t\tthis._inputSource = void 0;\n\t\tthis._tracking = false;\n\t\tthis._fingers = [];\n\t\tthis._joints = [];\n\t\tthis._jointsById = {};\n\t\tthis._tips = [];\n\t\tthis._wrist = null;\n\t\tconst xrHand = inputSource._xrInputSource.hand;\n\t\tthis._manager = inputSource._manager;\n\t\tthis._inputSource = inputSource;\n\t\tif (xrHand.get('wrist')) {\n\t\t\tconst joint = new XrJoint(0, 'wrist', this, null);\n\t\t\tthis._wrist = joint;\n\t\t\tthis._joints.push(joint);\n\t\t\tthis._jointsById.wrist = joint;\n\t\t}\n\t\tfor (let f = 0; f < fingerJointIds.length; f++) {\n\t\t\tconst finger = new XrFinger(f, this);\n\t\t\tfor (let j = 0; j < fingerJointIds[f].length; j++) {\n\t\t\t\tconst jointId = fingerJointIds[f][j];\n\t\t\t\tif (!xrHand.get(jointId)) continue;\n\t\t\t\tconst joint = new XrJoint(j, jointId, this, finger);\n\t\t\t\tthis._joints.push(joint);\n\t\t\t\tthis._jointsById[jointId] = joint;\n\t\t\t\tif (joint.tip) {\n\t\t\t\t\tthis._tips.push(joint);\n\t\t\t\t\tfinger._tip = joint;\n\t\t\t\t}\n\t\t\t\tfinger._joints.push(joint);\n\t\t\t}\n\t\t}\n\t}\n\tupdate(frame) {\n\t\tconst xrInputSource = this._inputSource._xrInputSource;\n\t\tfor (let j = 0; j < this._joints.length; j++) {\n\t\t\tconst joint = this._joints[j];\n\t\t\tconst jointSpace = xrInputSource.hand.get(joint._id);\n\t\t\tif (jointSpace) {\n\t\t\t\tlet pose;\n\t\t\t\tif (frame.session.visibilityState !== 'hidden') pose = frame.getJointPose(jointSpace, this._manager._referenceSpace);\n\t\t\t\tif (pose) {\n\t\t\t\t\tjoint.update(pose);\n\t\t\t\t\tif (joint.wrist && !this._tracking) {\n\t\t\t\t\t\tthis._tracking = true;\n\t\t\t\t\t\tthis.fire('tracking');\n\t\t\t\t\t}\n\t\t\t\t} else if (joint.wrist) {\n\t\t\t\t\tif (this._tracking) {\n\t\t\t\t\t\tthis._tracking = false;\n\t\t\t\t\t\tthis.fire('trackinglost');\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tconst j1 = this._jointsById['thumb-metacarpal'];\n\t\tconst j4 = this._jointsById['thumb-tip'];\n\t\tconst j6 = this._jointsById['index-finger-phalanx-proximal'];\n\t\tconst j9 = this._jointsById['index-finger-tip'];\n\t\tconst j16 = this._jointsById['ring-finger-phalanx-proximal'];\n\t\tconst j21 = this._jointsById['pinky-finger-phalanx-proximal'];\n\t\tif (j1 && j4 && j6 && j9 && j16 && j21) {\n\t\t\tthis._inputSource._dirtyRay = true;\n\t\t\tthis._inputSource._rayLocal.origin.lerp(j4._localPosition, j9._localPosition, 0.5);\n\t\t\tlet jointL = j1;\n\t\t\tlet jointR = j21;\n\t\t\tif (this._inputSource.handedness === XRHAND_LEFT) {\n\t\t\t\tconst t = jointL;\n\t\t\t\tjointL = jointR;\n\t\t\t\tjointR = t;\n\t\t\t}\n\t\t\tvecA.sub2(jointL._localPosition, this._wrist._localPosition);\n\t\t\tvecB.sub2(jointR._localPosition, this._wrist._localPosition);\n\t\t\tvecC.cross(vecA, vecB).normalize();\n\t\t\tvecA.lerp(j6._localPosition, j16._localPosition, 0.5);\n\t\t\tvecA.sub(this._wrist._localPosition).normalize();\n\t\t\tthis._inputSource._rayLocal.direction.lerp(vecC, vecA, 0.5).normalize();\n\t\t}\n\t\tconst squeezing = this._fingerIsClosed(1) && this._fingerIsClosed(2) && this._fingerIsClosed(3) && this._fingerIsClosed(4);\n\t\tif (squeezing) {\n\t\t\tif (!this._inputSource._squeezing) {\n\t\t\t\tthis._inputSource._squeezing = true;\n\t\t\t\tthis._inputSource.fire('squeezestart');\n\t\t\t\tthis._manager.input.fire('squeezestart', this._inputSource);\n\t\t\t}\n\t\t} else {\n\t\t\tif (this._inputSource._squeezing) {\n\t\t\t\tthis._inputSource._squeezing = false;\n\t\t\t\tthis._inputSource.fire('squeeze');\n\t\t\t\tthis._manager.input.fire('squeeze', this._inputSource);\n\t\t\t\tthis._inputSource.fire('squeezeend');\n\t\t\t\tthis._manager.input.fire('squeezeend', this._inputSource);\n\t\t\t}\n\t\t}\n\t}\n\t_fingerIsClosed(index) {\n\t\tconst finger = this._fingers[index];\n\t\tvecA.sub2(finger.joints[0]._localPosition, finger.joints[1]._localPosition).normalize();\n\t\tvecB.sub2(finger.joints[2]._localPosition, finger.joints[3]._localPosition).normalize();\n\t\treturn vecA.dot(vecB) < -0.8;\n\t}\n\tgetJointById(id) {\n\t\treturn this._jointsById[id] || null;\n\t}\n\tget fingers() {\n\t\treturn this._fingers;\n\t}\n\tget joints() {\n\t\treturn this._joints;\n\t}\n\tget tips() {\n\t\treturn this._tips;\n\t}\n\tget wrist() {\n\t\treturn this._wrist;\n\t}\n\tget tracking() {\n\t\treturn this._tracking;\n\t}\n}\nXrHand.EVENT_TRACKING = 'tracking';\nXrHand.EVENT_TRACKINGLOST = 'trackinglost';\n\nexport { XrHand };\n", "import { EventHandler } from '../../core/event-handler.js';\nimport { Mat4 } from '../../core/math/mat4.js';\nimport { Quat } from '../../core/math/quat.js';\nimport { Vec3 } from '../../core/math/vec3.js';\nimport { Ray } from '../../core/shape/ray.js';\nimport { XrHand } from './xr-hand.js';\nimport { now } from '../../core/time.js';\n\nconst vec3A = new Vec3();\nconst quat = new Quat();\nlet ids = 0;\nclass XrInputSource extends EventHandler {\n\tconstructor(manager, xrInputSource) {\n\t\tsuper();\n\t\tthis._id = void 0;\n\t\tthis._manager = void 0;\n\t\tthis._xrInputSource = void 0;\n\t\tthis._ray = new Ray();\n\t\tthis._rayLocal = new Ray();\n\t\tthis._grip = false;\n\t\tthis._hand = null;\n\t\tthis._velocitiesAvailable = false;\n\t\tthis._velocitiesTimestamp = now();\n\t\tthis._localTransform = null;\n\t\tthis._worldTransform = null;\n\t\tthis._position = new Vec3();\n\t\tthis._rotation = new Quat();\n\t\tthis._localPosition = null;\n\t\tthis._localPositionLast = null;\n\t\tthis._localRotation = null;\n\t\tthis._linearVelocity = null;\n\t\tthis._dirtyLocal = true;\n\t\tthis._dirtyRay = false;\n\t\tthis._selecting = false;\n\t\tthis._squeezing = false;\n\t\tthis._elementInput = true;\n\t\tthis._elementEntity = null;\n\t\tthis._hitTestSources = [];\n\t\tthis._id = ++ids;\n\t\tthis._manager = manager;\n\t\tthis._xrInputSource = xrInputSource;\n\t\tif (xrInputSource.hand) this._hand = new XrHand(this);\n\t}\n\tget id() {\n\t\treturn this._id;\n\t}\n\tget inputSource() {\n\t\treturn this._xrInputSource;\n\t}\n\tget targetRayMode() {\n\t\treturn this._xrInputSource.targetRayMode;\n\t}\n\tget handedness() {\n\t\treturn this._xrInputSource.handedness;\n\t}\n\tget profiles() {\n\t\treturn this._xrInputSource.profiles;\n\t}\n\tget grip() {\n\t\treturn this._grip;\n\t}\n\tget hand() {\n\t\treturn this._hand;\n\t}\n\tget gamepad() {\n\t\treturn this._xrInputSource.gamepad || null;\n\t}\n\tget selecting() {\n\t\treturn this._selecting;\n\t}\n\tget squeezing() {\n\t\treturn this._squeezing;\n\t}\n\tset elementInput(value) {\n\t\tif (this._elementInput === value) return;\n\t\tthis._elementInput = value;\n\t\tif (!this._elementInput) this._elementEntity = null;\n\t}\n\tget elementInput() {\n\t\treturn this._elementInput;\n\t}\n\tget elementEntity() {\n\t\treturn this._elementEntity;\n\t}\n\tget hitTestSources() {\n\t\treturn this._hitTestSources;\n\t}\n\tupdate(frame) {\n\t\tif (this._hand) {\n\t\t\tthis._hand.update(frame);\n\t\t} else {\n\t\t\tconst gripSpace = this._xrInputSource.gripSpace;\n\t\t\tif (gripSpace) {\n\t\t\t\tconst gripPose = frame.getPose(gripSpace, this._manager._referenceSpace);\n\t\t\t\tif (gripPose) {\n\t\t\t\t\tif (!this._grip) {\n\t\t\t\t\t\tthis._grip = true;\n\t\t\t\t\t\tthis._localTransform = new Mat4();\n\t\t\t\t\t\tthis._worldTransform = new Mat4();\n\t\t\t\t\t\tthis._localPositionLast = new Vec3();\n\t\t\t\t\t\tthis._localPosition = new Vec3();\n\t\t\t\t\t\tthis._localRotation = new Quat();\n\t\t\t\t\t\tthis._linearVelocity = new Vec3();\n\t\t\t\t\t}\n\t\t\t\t\tconst timestamp = now();\n\t\t\t\t\tconst dt = (timestamp - this._velocitiesTimestamp) / 1000;\n\t\t\t\t\tthis._velocitiesTimestamp = timestamp;\n\t\t\t\t\tthis._dirtyLocal = true;\n\t\t\t\t\tthis._localPositionLast.copy(this._localPosition);\n\t\t\t\t\tthis._localPosition.copy(gripPose.transform.position);\n\t\t\t\t\tthis._localRotation.copy(gripPose.transform.orientation);\n\t\t\t\t\tthis._velocitiesAvailable = true;\n\t\t\t\t\tif (this._manager.input.velocitiesSupported && gripPose.linearVelocity) {\n\t\t\t\t\t\tthis._linearVelocity.copy(gripPose.linearVelocity);\n\t\t\t\t\t} else if (dt > 0) {\n\t\t\t\t\t\tvec3A.sub2(this._localPosition, this._localPositionLast).divScalar(dt);\n\t\t\t\t\t\tthis._linearVelocity.lerp(this._linearVelocity, vec3A, 0.15);\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tthis._velocitiesAvailable = false;\n\t\t\t\t}\n\t\t\t}\n\t\t\tconst targetRayPose = frame.getPose(this._xrInputSource.targetRaySpace, this._manager._referenceSpace);\n\t\t\tif (targetRayPose) {\n\t\t\t\tthis._dirtyRay = true;\n\t\t\t\tthis._rayLocal.origin.copy(targetRayPose.transform.position);\n\t\t\t\tthis._rayLocal.direction.set(0, 0, -1);\n\t\t\t\tquat.copy(targetRayPose.transform.orientation);\n\t\t\t\tquat.transformVector(this._rayLocal.direction, this._rayLocal.direction);\n\t\t\t}\n\t\t}\n\t}\n\t_updateTransforms() {\n\t\tif (this._dirtyLocal) {\n\t\t\tthis._dirtyLocal = false;\n\t\t\tthis._localTransform.setTRS(this._localPosition, this._localRotation, Vec3.ONE);\n\t\t}\n\t\tconst parent = this._manager.camera.parent;\n\t\tif (parent) {\n\t\t\tthis._worldTransform.mul2(parent.getWorldTransform(), this._localTransform);\n\t\t} else {\n\t\t\tthis._worldTransform.copy(this._localTransform);\n\t\t}\n\t}\n\t_updateRayTransforms() {\n\t\tconst dirty = this._dirtyRay;\n\t\tthis._dirtyRay = false;\n\t\tconst parent = this._manager.camera.parent;\n\t\tif (parent) {\n\t\t\tconst parentTransform = this._manager.camera.parent.getWorldTransform();\n\t\t\tparentTransform.getTranslation(this._position);\n\t\t\tthis._rotation.setFromMat4(parentTransform);\n\t\t\tthis._rotation.transformVector(this._rayLocal.origin, this._ray.origin);\n\t\t\tthis._ray.origin.add(this._position);\n\t\t\tthis._rotation.transformVector(this._rayLocal.direction, this._ray.direction);\n\t\t} else if (dirty) {\n\t\t\tthis._ray.origin.copy(this._rayLocal.origin);\n\t\t\tthis._ray.direction.copy(this._rayLocal.direction);\n\t\t}\n\t}\n\tgetPosition() {\n\t\tif (!this._position) return null;\n\t\tthis._updateTransforms();\n\t\tthis._worldTransform.getTranslation(this._position);\n\t\treturn this._position;\n\t}\n\tgetLocalPosition() {\n\t\treturn this._localPosition;\n\t}\n\tgetRotation() {\n\t\tif (!this._rotation) return null;\n\t\tthis._updateTransforms();\n\t\tthis._rotation.setFromMat4(this._worldTransform);\n\t\treturn this._rotation;\n\t}\n\tgetLocalRotation() {\n\t\treturn this._localRotation;\n\t}\n\tgetLinearVelocity() {\n\t\tif (!this._velocitiesAvailable) return null;\n\t\treturn this._linearVelocity;\n\t}\n\tgetOrigin() {\n\t\tthis._updateRayTransforms();\n\t\treturn this._ray.origin;\n\t}\n\tgetDirection() {\n\t\tthis._updateRayTransforms();\n\t\treturn this._ray.direction;\n\t}\n\thitTestStart(options = {}) {\n\t\toptions.inputSource = this;\n\t\toptions.profile = this._xrInputSource.profiles[0];\n\t\tconst callback = options.callback;\n\t\toptions.callback = (err, hitTestSource) => {\n\t\t\tif (hitTestSource) this.onHitTestSourceAdd(hitTestSource);\n\t\t\tif (callback) callback(err, hitTestSource);\n\t\t};\n\t\tthis._manager.hitTest.start(options);\n\t}\n\tonHitTestSourceAdd(hitTestSource) {\n\t\tthis._hitTestSources.push(hitTestSource);\n\t\tthis.fire('hittest:add', hitTestSource);\n\t\thitTestSource.on('result', (position, rotation, inputSource, hitTestResult) => {\n\t\t\tif (inputSource !== this) return;\n\t\t\tthis.fire('hittest:result', hitTestSource, position, rotation, hitTestResult);\n\t\t});\n\t\thitTestSource.once('remove', () => {\n\t\t\tthis.onHitTestSourceRemove(hitTestSource);\n\t\t\tthis.fire('hittest:remove', hitTestSource);\n\t\t});\n\t}\n\tonHitTestSourceRemove(hitTestSource) {\n\t\tconst ind = this._hitTestSources.indexOf(hitTestSource);\n\t\tif (ind !== -1) this._hitTestSources.splice(ind, 1);\n\t}\n}\nXrInputSource.EVENT_REMOVE = 'remove';\nXrInputSource.EVENT_SELECT = 'select';\nXrInputSource.EVENT_SELECTSTART = 'selectstart';\nXrInputSource.EVENT_SELECTEND = 'selectend';\nXrInputSource.EVENT_SQUEEZE = 'squeeze';\nXrInputSource.EVENT_SQUEEZESTART = 'squeezestart';\nXrInputSource.EVENT_SQUEEZEEND = 'squeezeend';\nXrInputSource.EVENT_HITTESTADD = 'hittest:add';\nXrInputSource.EVENT_HITTESTREMOVE = 'hittest:remove';\nXrInputSource.EVENT_HITTESTRESULT = 'hittest:result';\n\nexport { XrInputSource };\n", "import { platform } from '../../core/platform.js';\nimport { Vec3 } from '../../core/math/vec3.js';\nimport { Vec4 } from '../../core/math/vec4.js';\nimport { Ray } from '../../core/shape/ray.js';\nimport { Mouse } from '../../platform/input/mouse.js';\nimport { getApplication } from '../globals.js';\n\nlet targetX, targetY;\nconst vecA = new Vec3();\nconst vecB = new Vec3();\nconst rayA = new Ray();\nconst rayB = new Ray();\nconst rayC = new Ray();\nrayA.end = new Vec3();\nrayB.end = new Vec3();\nrayC.end = new Vec3();\nconst _pq = new Vec3();\nconst _pa = new Vec3();\nconst _pb = new Vec3();\nconst _pc = new Vec3();\nconst _pd = new Vec3();\nconst _m = new Vec3();\nconst _au = new Vec3();\nconst _bv = new Vec3();\nconst _cw = new Vec3();\nconst _ir = new Vec3();\nconst _sct = new Vec3();\nconst _accumulatedScale = new Vec3();\nconst _paddingTop = new Vec3();\nconst _paddingBottom = new Vec3();\nconst _paddingLeft = new Vec3();\nconst _paddingRight = new Vec3();\nconst _cornerBottomLeft = new Vec3();\nconst _cornerBottomRight = new Vec3();\nconst _cornerTopRight = new Vec3();\nconst _cornerTopLeft = new Vec3();\nconst ZERO_VEC4 = new Vec4();\nfunction scalarTriple(p1, p2, p3) {\n\treturn _sct.cross(p1, p2).dot(p3);\n}\nfunction intersectLineQuad(p, q, corners) {\n\t_pq.sub2(q, p);\n\t_pa.sub2(corners[0], p);\n\t_pb.sub2(corners[1], p);\n\t_pc.sub2(corners[2], p);\n\t_m.cross(_pc, _pq);\n\tlet v = _pa.dot(_m);\n\tlet u;\n\tlet w;\n\tif (v >= 0) {\n\t\tu = -_pb.dot(_m);\n\t\tif (u < 0) return -1;\n\t\tw = scalarTriple(_pq, _pb, _pa);\n\t\tif (w < 0) return -1;\n\t\tconst denom = 1.0 / (u + v + w);\n\t\t_au.copy(corners[0]).mulScalar(u * denom);\n\t\t_bv.copy(corners[1]).mulScalar(v * denom);\n\t\t_cw.copy(corners[2]).mulScalar(w * denom);\n\t\t_ir.copy(_au).add(_bv).add(_cw);\n\t} else {\n\t\t_pd.sub2(corners[3], p);\n\t\tu = _pd.dot(_m);\n\t\tif (u < 0) return -1;\n\t\tw = scalarTriple(_pq, _pa, _pd);\n\t\tif (w < 0) return -1;\n\t\tv = -v;\n\t\tconst denom = 1.0 / (u + v + w);\n\t\t_au.copy(corners[0]).mulScalar(u * denom);\n\t\t_bv.copy(corners[3]).mulScalar(v * denom);\n\t\t_cw.copy(corners[2]).mulScalar(w * denom);\n\t\t_ir.copy(_au).add(_bv).add(_cw);\n\t}\n\tif (_pq.sub2(corners[0], corners[2]).lengthSq() < 0.0001 * 0.0001) return -1;\n\tif (_pq.sub2(corners[1], corners[3]).lengthSq() < 0.0001 * 0.0001) return -1;\n\treturn _ir.sub(p).lengthSq();\n}\nclass ElementInputEvent {\n\tconstructor(event, element, camera) {\n\t\tthis.event = event;\n\t\tthis.element = element;\n\t\tthis.camera = camera;\n\t\tthis._stopPropagation = false;\n\t}\n\tstopPropagation() {\n\t\tthis._stopPropagation = true;\n\t\tif (this.event) {\n\t\t\tthis.event.stopImmediatePropagation();\n\t\t\tthis.event.stopPropagation();\n\t\t}\n\t}\n}\nclass ElementMouseEvent extends ElementInputEvent {\n\tconstructor(event, element, camera, x, y, lastX, lastY) {\n\t\tsuper(event, element, camera);\n\t\tthis.x = x;\n\t\tthis.y = y;\n\t\tthis.ctrlKey = event.ctrlKey || false;\n\t\tthis.altKey = event.altKey || false;\n\t\tthis.shiftKey = event.shiftKey || false;\n\t\tthis.metaKey = event.metaKey || false;\n\t\tthis.button = event.button;\n\t\tif (Mouse.isPointerLocked()) {\n\t\t\tthis.dx = event.movementX || event.webkitMovementX || event.mozMovementX || 0;\n\t\t\tthis.dy = event.movementY || event.webkitMovementY || event.mozMovementY || 0;\n\t\t} else {\n\t\t\tthis.dx = x - lastX;\n\t\t\tthis.dy = y - lastY;\n\t\t}\n\t\tthis.wheelDelta = 0;\n\t\tif (event.type === 'wheel') {\n\t\t\tif (event.deltaY > 0) {\n\t\t\t\tthis.wheelDelta = 1;\n\t\t\t} else if (event.deltaY < 0) {\n\t\t\t\tthis.wheelDelta = -1;\n\t\t\t}\n\t\t}\n\t}\n}\nclass ElementTouchEvent extends ElementInputEvent {\n\tconstructor(event, element, camera, x, y, touch) {\n\t\tsuper(event, element, camera);\n\t\tthis.touches = event.touches;\n\t\tthis.changedTouches = event.changedTouches;\n\t\tthis.x = x;\n\t\tthis.y = y;\n\t\tthis.touch = touch;\n\t}\n}\nclass ElementSelectEvent extends ElementInputEvent {\n\tconstructor(event, element, camera, inputSource) {\n\t\tsuper(event, element, camera);\n\t\tthis.inputSource = inputSource;\n\t}\n}\nclass ElementInput {\n\tconstructor(domElement, options) {\n\t\tthis._app = null;\n\t\tthis._attached = false;\n\t\tthis._target = null;\n\t\tthis._enabled = true;\n\t\tthis._lastX = 0;\n\t\tthis._lastY = 0;\n\t\tthis._upHandler = this._handleUp.bind(this);\n\t\tthis._downHandler = this._handleDown.bind(this);\n\t\tthis._moveHandler = this._handleMove.bind(this);\n\t\tthis._wheelHandler = this._handleWheel.bind(this);\n\t\tthis._touchstartHandler = this._handleTouchStart.bind(this);\n\t\tthis._touchendHandler = this._handleTouchEnd.bind(this);\n\t\tthis._touchcancelHandler = this._touchendHandler;\n\t\tthis._touchmoveHandler = this._handleTouchMove.bind(this);\n\t\tthis._sortHandler = this._sortElements.bind(this);\n\t\tthis._elements = [];\n\t\tthis._hoveredElement = null;\n\t\tthis._pressedElement = null;\n\t\tthis._touchedElements = {};\n\t\tthis._touchesForWhichTouchLeaveHasFired = {};\n\t\tthis._selectedElements = {};\n\t\tthis._selectedPressedElements = {};\n\t\tthis._useMouse = !options || options.useMouse !== false;\n\t\tthis._useTouch = !options || options.useTouch !== false;\n\t\tthis._useXr = !options || options.useXr !== false;\n\t\tthis._selectEventsAttached = false;\n\t\tif (platform.touch) this._clickedEntities = {};\n\t\tthis.attach(domElement);\n\t}\n\tset enabled(value) {\n\t\tthis._enabled = value;\n\t}\n\tget enabled() {\n\t\treturn this._enabled;\n\t}\n\tset app(value) {\n\t\tthis._app = value;\n\t}\n\tget app() {\n\t\treturn this._app || getApplication();\n\t}\n\tattach(domElement) {\n\t\tif (this._attached) {\n\t\t\tthis._attached = false;\n\t\t\tthis.detach();\n\t\t}\n\t\tthis._target = domElement;\n\t\tthis._attached = true;\n\t\tconst opts = platform.passiveEvents ? {\n\t\t\tpassive: true\n\t\t} : false;\n\t\tif (this._useMouse) {\n\t\t\twindow.addEventListener('mouseup', this._upHandler, opts);\n\t\t\twindow.addEventListener('mousedown', this._downHandler, opts);\n\t\t\twindow.addEventListener('mousemove', this._moveHandler, opts);\n\t\t\twindow.addEventListener('wheel', this._wheelHandler, opts);\n\t\t}\n\t\tif (this._useTouch && platform.touch) {\n\t\t\tthis._target.addEventListener('touchstart', this._touchstartHandler, opts);\n\t\t\tthis._target.addEventListener('touchend', this._touchendHandler, false);\n\t\t\tthis._target.addEventListener('touchmove', this._touchmoveHandler, false);\n\t\t\tthis._target.addEventListener('touchcancel', this._touchcancelHandler, false);\n\t\t}\n\t\tthis.attachSelectEvents();\n\t}\n\tattachSelectEvents() {\n\t\tif (!this._selectEventsAttached && this._useXr && this.app && this.app.xr && this.app.xr.supported) {\n\t\t\tif (!this._clickedEntities) this._clickedEntities = {};\n\t\t\tthis._selectEventsAttached = true;\n\t\t\tthis.app.xr.on('start', this._onXrStart, this);\n\t\t}\n\t}\n\tdetach() {\n\t\tif (!this._attached) return;\n\t\tthis._attached = false;\n\t\tconst opts = platform.passiveEvents ? {\n\t\t\tpassive: true\n\t\t} : false;\n\t\tif (this._useMouse) {\n\t\t\twindow.removeEventListener('mouseup', this._upHandler, opts);\n\t\t\twindow.removeEventListener('mousedown', this._downHandler, opts);\n\t\t\twindow.removeEventListener('mousemove', this._moveHandler, opts);\n\t\t\twindow.removeEventListener('wheel', this._wheelHandler, opts);\n\t\t}\n\t\tif (this._useTouch) {\n\t\t\tthis._target.removeEventListener('touchstart', this._touchstartHandler, opts);\n\t\t\tthis._target.removeEventListener('touchend', this._touchendHandler, false);\n\t\t\tthis._target.removeEventListener('touchmove', this._touchmoveHandler, false);\n\t\t\tthis._target.removeEventListener('touchcancel', this._touchcancelHandler, false);\n\t\t}\n\t\tif (this._selectEventsAttached) {\n\t\t\tthis._selectEventsAttached = false;\n\t\t\tthis.app.xr.off('start', this._onXrStart, this);\n\t\t\tthis.app.xr.off('end', this._onXrEnd, this);\n\t\t\tthis.app.xr.off('update', this._onXrUpdate, this);\n\t\t\tthis.app.xr.input.off('selectstart', this._onSelectStart, this);\n\t\t\tthis.app.xr.input.off('selectend', this._onSelectEnd, this);\n\t\t\tthis.app.xr.input.off('remove', this._onXrInputRemove, this);\n\t\t}\n\t\tthis._target = null;\n\t}\n\taddElement(element) {\n\t\tif (this._elements.indexOf(element) === -1) this._elements.push(element);\n\t}\n\tremoveElement(element) {\n\t\tconst idx = this._elements.indexOf(element);\n\t\tif (idx !== -1) this._elements.splice(idx, 1);\n\t}\n\t_handleUp(event) {\n\t\tif (!this._enabled) return;\n\t\tif (Mouse.isPointerLocked()) return;\n\t\tthis._calcMouseCoords(event);\n\t\tthis._onElementMouseEvent('mouseup', event);\n\t}\n\t_handleDown(event) {\n\t\tif (!this._enabled) return;\n\t\tif (Mouse.isPointerLocked()) return;\n\t\tthis._calcMouseCoords(event);\n\t\tthis._onElementMouseEvent('mousedown', event);\n\t}\n\t_handleMove(event) {\n\t\tif (!this._enabled) return;\n\t\tthis._calcMouseCoords(event);\n\t\tthis._onElementMouseEvent('mousemove', event);\n\t\tthis._lastX = targetX;\n\t\tthis._lastY = targetY;\n\t}\n\t_handleWheel(event) {\n\t\tif (!this._enabled) return;\n\t\tthis._calcMouseCoords(event);\n\t\tthis._onElementMouseEvent('mousewheel', event);\n\t}\n\t_determineTouchedElements(event) {\n\t\tconst touchedElements = {};\n\t\tconst cameras = this.app.systems.camera.cameras;\n\t\tfor (let i = cameras.length - 1; i >= 0; i--) {\n\t\t\tconst camera = cameras[i];\n\t\t\tlet done = 0;\n\t\t\tconst len = event.changedTouches.length;\n\t\t\tfor (let j = 0; j < len; j++) {\n\t\t\t\tif (touchedElements[event.changedTouches[j].identifier]) {\n\t\t\t\t\tdone++;\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tconst coords = this._calcTouchCoords(event.changedTouches[j]);\n\t\t\t\tconst element = this._getTargetElementByCoords(camera, coords.x, coords.y);\n\t\t\t\tif (element) {\n\t\t\t\t\tdone++;\n\t\t\t\t\ttouchedElements[event.changedTouches[j].identifier] = {\n\t\t\t\t\t\telement: element,\n\t\t\t\t\t\tcamera: camera,\n\t\t\t\t\t\tx: coords.x,\n\t\t\t\t\t\ty: coords.y\n\t\t\t\t\t};\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (done === len) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\treturn touchedElements;\n\t}\n\t_handleTouchStart(event) {\n\t\tif (!this._enabled) return;\n\t\tconst newTouchedElements = this._determineTouchedElements(event);\n\t\tfor (let i = 0, len = event.changedTouches.length; i < len; i++) {\n\t\t\tconst touch = event.changedTouches[i];\n\t\t\tconst newTouchInfo = newTouchedElements[touch.identifier];\n\t\t\tconst oldTouchInfo = this._touchedElements[touch.identifier];\n\t\t\tif (newTouchInfo && (!oldTouchInfo || newTouchInfo.element !== oldTouchInfo.element)) {\n\t\t\t\tthis._fireEvent(event.type, new ElementTouchEvent(event, newTouchInfo.element, newTouchInfo.camera, newTouchInfo.x, newTouchInfo.y, touch));\n\t\t\t\tthis._touchesForWhichTouchLeaveHasFired[touch.identifier] = false;\n\t\t\t}\n\t\t}\n\t\tfor (const touchId in newTouchedElements) {\n\t\t\tthis._touchedElements[touchId] = newTouchedElements[touchId];\n\t\t}\n\t}\n\t_handleTouchEnd(event) {\n\t\tif (!this._enabled) return;\n\t\tconst cameras = this.app.systems.camera.cameras;\n\t\tfor (const key in this._clickedEntities) {\n\t\t\tdelete this._clickedEntities[key];\n\t\t}\n\t\tfor (let i = 0, len = event.changedTouches.length; i < len; i++) {\n\t\t\tconst touch = event.changedTouches[i];\n\t\t\tconst touchInfo = this._touchedElements[touch.identifier];\n\t\t\tif (!touchInfo) continue;\n\t\t\tconst element = touchInfo.element;\n\t\t\tconst camera = touchInfo.camera;\n\t\t\tconst x = touchInfo.x;\n\t\t\tconst y = touchInfo.y;\n\t\t\tdelete this._touchedElements[touch.identifier];\n\t\t\tdelete this._touchesForWhichTouchLeaveHasFired[touch.identifier];\n\t\t\tconst coords = this._calcTouchCoords(touch);\n\t\t\tfor (let c = cameras.length - 1; c >= 0; c--) {\n\t\t\t\tconst hovered = this._getTargetElementByCoords(cameras[c], coords.x, coords.y);\n\t\t\t\tif (hovered === element) {\n\t\t\t\t\tif (!this._clickedEntities[element.entity.getGuid()]) {\n\t\t\t\t\t\tthis._fireEvent('click', new ElementTouchEvent(event, element, camera, x, y, touch));\n\t\t\t\t\t\tthis._clickedEntities[element.entity.getGuid()] = Date.now();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis._fireEvent(event.type, new ElementTouchEvent(event, element, camera, x, y, touch));\n\t\t}\n\t}\n\t_handleTouchMove(event) {\n\t\tevent.preventDefault();\n\t\tif (!this._enabled) return;\n\t\tconst newTouchedElements = this._determineTouchedElements(event);\n\t\tfor (let i = 0, len = event.changedTouches.length; i < len; i++) {\n\t\t\tconst touch = event.changedTouches[i];\n\t\t\tconst newTouchInfo = newTouchedElements[touch.identifier];\n\t\t\tconst oldTouchInfo = this._touchedElements[touch.identifier];\n\t\t\tif (oldTouchInfo) {\n\t\t\t\tconst coords = this._calcTouchCoords(touch);\n\t\t\t\tif ((!newTouchInfo || newTouchInfo.element !== oldTouchInfo.element) && !this._touchesForWhichTouchLeaveHasFired[touch.identifier]) {\n\t\t\t\t\tthis._fireEvent('touchleave', new ElementTouchEvent(event, oldTouchInfo.element, oldTouchInfo.camera, coords.x, coords.y, touch));\n\t\t\t\t\tthis._touchesForWhichTouchLeaveHasFired[touch.identifier] = true;\n\t\t\t\t}\n\t\t\t\tthis._fireEvent('touchmove', new ElementTouchEvent(event, oldTouchInfo.element, oldTouchInfo.camera, coords.x, coords.y, touch));\n\t\t\t}\n\t\t}\n\t}\n\t_onElementMouseEvent(eventType, event) {\n\t\tlet element = null;\n\t\tconst lastHovered = this._hoveredElement;\n\t\tthis._hoveredElement = null;\n\t\tconst cameras = this.app.systems.camera.cameras;\n\t\tlet camera;\n\t\tfor (let i = cameras.length - 1; i >= 0; i--) {\n\t\t\tcamera = cameras[i];\n\t\t\telement = this._getTargetElementByCoords(camera, targetX, targetY);\n\t\t\tif (element) break;\n\t\t}\n\t\tthis._hoveredElement = element;\n\t\tif ((eventType === 'mousemove' || eventType === 'mouseup') && this._pressedElement) {\n\t\t\tthis._fireEvent(eventType, new ElementMouseEvent(event, this._pressedElement, camera, targetX, targetY, this._lastX, this._lastY));\n\t\t} else if (element) {\n\t\t\tthis._fireEvent(eventType, new ElementMouseEvent(event, element, camera, targetX, targetY, this._lastX, this._lastY));\n\t\t\tif (eventType === 'mousedown') {\n\t\t\t\tthis._pressedElement = element;\n\t\t\t}\n\t\t}\n\t\tif (lastHovered !== this._hoveredElement) {\n\t\t\tif (lastHovered) {\n\t\t\t\tthis._fireEvent('mouseleave', new ElementMouseEvent(event, lastHovered, camera, targetX, targetY, this._lastX, this._lastY));\n\t\t\t}\n\t\t\tif (this._hoveredElement) {\n\t\t\t\tthis._fireEvent('mouseenter', new ElementMouseEvent(event, this._hoveredElement, camera, targetX, targetY, this._lastX, this._lastY));\n\t\t\t}\n\t\t}\n\t\tif (eventType === 'mouseup' && this._pressedElement) {\n\t\t\tif (this._pressedElement === this._hoveredElement) {\n\t\t\t\tconst guid = this._hoveredElement.entity.getGuid();\n\t\t\t\tlet fireClick = !this._clickedEntities;\n\t\t\t\tif (this._clickedEntities) {\n\t\t\t\t\tconst lastTouchUp = this._clickedEntities[guid] || 0;\n\t\t\t\t\tconst dt = Date.now() - lastTouchUp;\n\t\t\t\t\tfireClick = dt > 300;\n\t\t\t\t\tdelete this._clickedEntities[guid];\n\t\t\t\t}\n\t\t\t\tif (fireClick) {\n\t\t\t\t\tthis._fireEvent('click', new ElementMouseEvent(event, this._hoveredElement, camera, targetX, targetY, this._lastX, this._lastY));\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis._pressedElement = null;\n\t\t}\n\t}\n\t_onXrStart() {\n\t\tthis.app.xr.on('end', this._onXrEnd, this);\n\t\tthis.app.xr.on('update', this._onXrUpdate, this);\n\t\tthis.app.xr.input.on('selectstart', this._onSelectStart, this);\n\t\tthis.app.xr.input.on('selectend', this._onSelectEnd, this);\n\t\tthis.app.xr.input.on('remove', this._onXrInputRemove, this);\n\t}\n\t_onXrEnd() {\n\t\tthis.app.xr.off('update', this._onXrUpdate, this);\n\t\tthis.app.xr.input.off('selectstart', this._onSelectStart, this);\n\t\tthis.app.xr.input.off('selectend', this._onSelectEnd, this);\n\t\tthis.app.xr.input.off('remove', this._onXrInputRemove, this);\n\t}\n\t_onXrUpdate() {\n\t\tif (!this._enabled) return;\n\t\tconst inputSources = this.app.xr.input.inputSources;\n\t\tfor (let i = 0; i < inputSources.length; i++) {\n\t\t\tthis._onElementSelectEvent('selectmove', inputSources[i], null);\n\t\t}\n\t}\n\t_onXrInputRemove(inputSource) {\n\t\tconst hovered = this._selectedElements[inputSource.id];\n\t\tif (hovered) {\n\t\t\tinputSource._elementEntity = null;\n\t\t\tthis._fireEvent('selectleave', new ElementSelectEvent(null, hovered, null, inputSource));\n\t\t}\n\t\tdelete this._selectedElements[inputSource.id];\n\t\tdelete this._selectedPressedElements[inputSource.id];\n\t}\n\t_onSelectStart(inputSource, event) {\n\t\tif (!this._enabled) return;\n\t\tthis._onElementSelectEvent('selectstart', inputSource, event);\n\t}\n\t_onSelectEnd(inputSource, event) {\n\t\tif (!this._enabled) return;\n\t\tthis._onElementSelectEvent('selectend', inputSource, event);\n\t}\n\t_onElementSelectEvent(eventType, inputSource, event) {\n\t\tlet element;\n\t\tconst hoveredBefore = this._selectedElements[inputSource.id];\n\t\tlet hoveredNow;\n\t\tconst cameras = this.app.systems.camera.cameras;\n\t\tlet camera;\n\t\tif (inputSource.elementInput) {\n\t\t\trayC.set(inputSource.getOrigin(), inputSource.getDirection());\n\t\t\tfor (let i = cameras.length - 1; i >= 0; i--) {\n\t\t\t\tcamera = cameras[i];\n\t\t\t\telement = this._getTargetElementByRay(rayC, camera);\n\t\t\t\tif (element) break;\n\t\t\t}\n\t\t}\n\t\tinputSource._elementEntity = element || null;\n\t\tif (element) {\n\t\t\tthis._selectedElements[inputSource.id] = element;\n\t\t\thoveredNow = element;\n\t\t} else {\n\t\t\tdelete this._selectedElements[inputSource.id];\n\t\t}\n\t\tif (hoveredBefore !== hoveredNow) {\n\t\t\tif (hoveredBefore) this._fireEvent('selectleave', new ElementSelectEvent(event, hoveredBefore, camera, inputSource));\n\t\t\tif (hoveredNow) this._fireEvent('selectenter', new ElementSelectEvent(event, hoveredNow, camera, inputSource));\n\t\t}\n\t\tconst pressed = this._selectedPressedElements[inputSource.id];\n\t\tif (eventType === 'selectmove' && pressed) {\n\t\t\tthis._fireEvent('selectmove', new ElementSelectEvent(event, pressed, camera, inputSource));\n\t\t}\n\t\tif (eventType === 'selectstart') {\n\t\t\tthis._selectedPressedElements[inputSource.id] = hoveredNow;\n\t\t\tif (hoveredNow) this._fireEvent('selectstart', new ElementSelectEvent(event, hoveredNow, camera, inputSource));\n\t\t}\n\t\tif (!inputSource.elementInput && pressed) {\n\t\t\tdelete this._selectedPressedElements[inputSource.id];\n\t\t\tif (hoveredBefore) {\n\t\t\t\tthis._fireEvent('selectend', new ElementSelectEvent(event, pressed, camera, inputSource));\n\t\t\t}\n\t\t}\n\t\tif (eventType === 'selectend' && inputSource.elementInput) {\n\t\t\tdelete this._selectedPressedElements[inputSource.id];\n\t\t\tif (pressed) {\n\t\t\t\tthis._fireEvent('selectend', new ElementSelectEvent(event, pressed, camera, inputSource));\n\t\t\t}\n\t\t\tif (pressed && pressed === hoveredBefore) {\n\t\t\t\tthis._fireEvent('click', new ElementSelectEvent(event, pressed, camera, inputSource));\n\t\t\t}\n\t\t}\n\t}\n\t_fireEvent(name, evt) {\n\t\tlet element = evt.element;\n\t\twhile (true) {\n\t\t\telement.fire(name, evt);\n\t\t\tif (evt._stopPropagation) break;\n\t\t\tif (!element.entity.parent) break;\n\t\t\telement = element.entity.parent.element;\n\t\t\tif (!element) break;\n\t\t}\n\t}\n\t_calcMouseCoords(event) {\n\t\tconst rect = this._target.getBoundingClientRect();\n\t\tconst left = Math.floor(rect.left);\n\t\tconst top = Math.floor(rect.top);\n\t\ttargetX = event.clientX - left;\n\t\ttargetY = event.clientY - top;\n\t}\n\t_calcTouchCoords(touch) {\n\t\tlet totalOffsetX = 0;\n\t\tlet totalOffsetY = 0;\n\t\tlet target = touch.target;\n\t\twhile (!(target instanceof HTMLElement)) {\n\t\t\ttarget = target.parentNode;\n\t\t}\n\t\tlet currentElement = target;\n\t\tdo {\n\t\t\ttotalOffsetX += currentElement.offsetLeft - currentElement.scrollLeft;\n\t\t\ttotalOffsetY += currentElement.offsetTop - currentElement.scrollTop;\n\t\t\tcurrentElement = currentElement.offsetParent;\n\t\t} while (currentElement);\n\t\treturn {\n\t\t\tx: touch.pageX - totalOffsetX,\n\t\t\ty: touch.pageY - totalOffsetY\n\t\t};\n\t}\n\t_sortElements(a, b) {\n\t\tconst layerOrder = this.app.scene.layers.sortTransparentLayers(a.layers, b.layers);\n\t\tif (layerOrder !== 0) return layerOrder;\n\t\tif (a.screen && !b.screen) return -1;\n\t\tif (!a.screen && b.screen) return 1;\n\t\tif (!a.screen && !b.screen) return 0;\n\t\tif (a.screen.screen.screenSpace && !b.screen.screen.screenSpace) return -1;\n\t\tif (b.screen.screen.screenSpace && !a.screen.screen.screenSpace) return 1;\n\t\treturn b.drawOrder - a.drawOrder;\n\t}\n\t_getTargetElementByCoords(camera, x, y) {\n\t\tconst rayScreen = this._calculateRayScreen(x, y, camera, rayA) ? rayA : null;\n\t\tconst ray3d = this._calculateRay3d(x, y, camera, rayB) ? rayB : null;\n\t\treturn this._getTargetElement(camera, rayScreen, ray3d);\n\t}\n\t_getTargetElementByRay(ray, camera) {\n\t\trayA.origin.copy(ray.origin);\n\t\trayA.direction.copy(ray.direction);\n\t\trayA.end.copy(rayA.direction).mulScalar(camera.farClip * 2).add(rayA.origin);\n\t\tconst ray3d = rayA;\n\t\tconst screenPos = camera.worldToScreen(ray3d.origin, vecA);\n\t\tconst rayScreen = this._calculateRayScreen(screenPos.x, screenPos.y, camera, rayB) ? rayB : null;\n\t\treturn this._getTargetElement(camera, rayScreen, ray3d);\n\t}\n\t_getTargetElement(camera, rayScreen, ray3d) {\n\t\tlet result = null;\n\t\tlet closestDistance3d = Infinity;\n\t\tthis._elements.sort(this._sortHandler);\n\t\tfor (let i = 0, len = this._elements.length; i < len; i++) {\n\t\t\tconst element = this._elements[i];\n\t\t\tif (!element.layers.some(v => camera.layersSet.has(v))) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif (element.screen && element.screen.screen.screenSpace) {\n\t\t\t\tif (!rayScreen) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tconst currentDistance = this._checkElement(rayScreen, element, true);\n\t\t\t\tif (currentDistance >= 0) {\n\t\t\t\t\tresult = element;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tif (!ray3d) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tconst currentDistance = this._checkElement(ray3d, element, false);\n\t\t\t\tif (currentDistance >= 0) {\n\t\t\t\t\tif (currentDistance < closestDistance3d) {\n\t\t\t\t\t\tresult = element;\n\t\t\t\t\t\tclosestDistance3d = currentDistance;\n\t\t\t\t\t}\n\t\t\t\t\tif (element.screen) {\n\t\t\t\t\t\tresult = element;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn result;\n\t}\n\t_calculateRayScreen(x, y, camera, ray) {\n\t\tconst sw = this.app.graphicsDevice.width;\n\t\tconst sh = this.app.graphicsDevice.height;\n\t\tconst cameraWidth = camera.rect.z * sw;\n\t\tconst cameraHeight = camera.rect.w * sh;\n\t\tconst cameraLeft = camera.rect.x * sw;\n\t\tconst cameraRight = cameraLeft + cameraWidth;\n\t\tconst cameraBottom = (1 - camera.rect.y) * sh;\n\t\tconst cameraTop = cameraBottom - cameraHeight;\n\t\tlet _x = x * sw / this._target.clientWidth;\n\t\tlet _y = y * sh / this._target.clientHeight;\n\t\tif (_x >= cameraLeft && _x <= cameraRight && _y <= cameraBottom && _y >= cameraTop) {\n\t\t\t_x = sw * (_x - cameraLeft) / cameraWidth;\n\t\t\t_y = sh * (_y - cameraTop) / cameraHeight;\n\t\t\t_y = sh - _y;\n\t\t\tray.origin.set(_x, _y, 1);\n\t\t\tray.direction.set(0, 0, -1);\n\t\t\tray.end.copy(ray.direction).mulScalar(2).add(ray.origin);\n\t\t\treturn true;\n\t\t}\n\t\treturn false;\n\t}\n\t_calculateRay3d(x, y, camera, ray) {\n\t\tconst sw = this._target.clientWidth;\n\t\tconst sh = this._target.clientHeight;\n\t\tconst cameraWidth = camera.rect.z * sw;\n\t\tconst cameraHeight = camera.rect.w * sh;\n\t\tconst cameraLeft = camera.rect.x * sw;\n\t\tconst cameraRight = cameraLeft + cameraWidth;\n\t\tconst cameraBottom = (1 - camera.rect.y) * sh;\n\t\tconst cameraTop = cameraBottom - cameraHeight;\n\t\tlet _x = x;\n\t\tlet _y = y;\n\t\tif (x >= cameraLeft && x <= cameraRight && y <= cameraBottom && _y >= cameraTop) {\n\t\t\t_x = sw * (_x - cameraLeft) / cameraWidth;\n\t\t\t_y = sh * (_y - cameraTop) / cameraHeight;\n\t\t\tcamera.screenToWorld(_x, _y, camera.nearClip, vecA);\n\t\t\tcamera.screenToWorld(_x, _y, camera.farClip, vecB);\n\t\t\tray.origin.copy(vecA);\n\t\t\tray.direction.set(0, 0, -1);\n\t\t\tray.end.copy(vecB);\n\t\t\treturn true;\n\t\t}\n\t\treturn false;\n\t}\n\t_checkElement(ray, element, screen) {\n\t\tif (element.maskedBy) {\n\t\t\tif (this._checkElement(ray, element.maskedBy.element, screen) < 0) {\n\t\t\t\treturn -1;\n\t\t\t}\n\t\t}\n\t\tlet scale;\n\t\tif (screen) {\n\t\t\tscale = ElementInput.calculateScaleToScreen(element);\n\t\t} else {\n\t\t\tscale = ElementInput.calculateScaleToWorld(element);\n\t\t}\n\t\tconst corners = ElementInput.buildHitCorners(element, screen ? element.screenCorners : element.worldCorners, scale);\n\t\treturn intersectLineQuad(ray.origin, ray.end, corners);\n\t}\n\tstatic buildHitCorners(element, screenOrWorldCorners, scale) {\n\t\tlet hitCorners = screenOrWorldCorners;\n\t\tconst button = element.entity && element.entity.button;\n\t\tif (button) {\n\t\t\tconst hitPadding = element.entity.button.hitPadding || ZERO_VEC4;\n\t\t\t_paddingTop.copy(element.entity.up);\n\t\t\t_paddingBottom.copy(_paddingTop).mulScalar(-1);\n\t\t\t_paddingRight.copy(element.entity.right);\n\t\t\t_paddingLeft.copy(_paddingRight).mulScalar(-1);\n\t\t\t_paddingTop.mulScalar(hitPadding.w * scale.y);\n\t\t\t_paddingBottom.mulScalar(hitPadding.y * scale.y);\n\t\t\t_paddingRight.mulScalar(hitPadding.z * scale.x);\n\t\t\t_paddingLeft.mulScalar(hitPadding.x * scale.x);\n\t\t\t_cornerBottomLeft.copy(hitCorners[0]).add(_paddingBottom).add(_paddingLeft);\n\t\t\t_cornerBottomRight.copy(hitCorners[1]).add(_paddingBottom).add(_paddingRight);\n\t\t\t_cornerTopRight.copy(hitCorners[2]).add(_paddingTop).add(_paddingRight);\n\t\t\t_cornerTopLeft.copy(hitCorners[3]).add(_paddingTop).add(_paddingLeft);\n\t\t\thitCorners = [_cornerBottomLeft, _cornerBottomRight, _cornerTopRight, _cornerTopLeft];\n\t\t}\n\t\tif (scale.x < 0) {\n\t\t\tconst left = hitCorners[2].x;\n\t\t\tconst right = hitCorners[0].x;\n\t\t\thitCorners[0].x = left;\n\t\t\thitCorners[1].x = right;\n\t\t\thitCorners[2].x = right;\n\t\t\thitCorners[3].x = left;\n\t\t}\n\t\tif (scale.y < 0) {\n\t\t\tconst bottom = hitCorners[2].y;\n\t\t\tconst top = hitCorners[0].y;\n\t\t\thitCorners[0].y = bottom;\n\t\t\thitCorners[1].y = bottom;\n\t\t\thitCorners[2].y = top;\n\t\t\thitCorners[3].y = top;\n\t\t}\n\t\tif (scale.z < 0) {\n\t\t\tconst x = hitCorners[2].x;\n\t\t\tconst y = hitCorners[2].y;\n\t\t\tconst z = hitCorners[2].z;\n\t\t\thitCorners[2].x = hitCorners[0].x;\n\t\t\thitCorners[2].y = hitCorners[0].y;\n\t\t\thitCorners[2].z = hitCorners[0].z;\n\t\t\thitCorners[0].x = x;\n\t\t\thitCorners[0].y = y;\n\t\t\thitCorners[0].z = z;\n\t\t}\n\t\treturn hitCorners;\n\t}\n\tstatic calculateScaleToScreen(element) {\n\t\tlet current = element.entity;\n\t\tconst screenScale = element.screen.screen.scale;\n\t\t_accumulatedScale.set(screenScale, screenScale, screenScale);\n\t\twhile (current && !current.screen) {\n\t\t\t_accumulatedScale.mul(current.getLocalScale());\n\t\t\tcurrent = current.parent;\n\t\t}\n\t\treturn _accumulatedScale;\n\t}\n\tstatic calculateScaleToWorld(element) {\n\t\tlet current = element.entity;\n\t\t_accumulatedScale.set(1, 1, 1);\n\t\twhile (current) {\n\t\t\t_accumulatedScale.mul(current.getLocalScale());\n\t\t\tcurrent = current.parent;\n\t\t}\n\t\treturn _accumulatedScale;\n\t}\n}\n\nexport { ElementInput, ElementInputEvent, ElementMouseEvent, ElementSelectEvent, ElementTouchEvent };\n", "import { version, revision } from '../core/core.js';\nimport { string } from '../core/string.js';\nimport { now } from '../core/time.js';\nimport { math } from '../core/math/math.js';\nimport { Color } from '../core/math/color.js';\nimport { Mat4 } from '../core/math/mat4.js';\nimport { Vec2 } from '../core/math/vec2.js';\nimport { Vec3 } from '../core/math/vec3.js';\nimport { Vec4 } from '../core/math/vec4.js';\nimport { BoundingBox } from '../core/shape/bounding-box.js';\nimport { BoundingSphere } from '../core/shape/bounding-sphere.js';\nimport { Frustum } from '../core/shape/frustum.js';\nimport { Plane } from '../core/shape/plane.js';\nimport { TYPE_INT8, TYPE_UINT8, TYPE_INT16, TYPE_UINT16, TYPE_INT32, TYPE_UINT32, TYPE_FLOAT32, PIXELFORMAT_LA8, PIXELFORMAT_RGB565, PIXELFORMAT_RGBA5551, PIXELFORMAT_RGBA4, PIXELFORMAT_RGB8, PIXELFORMAT_RGBA8, BLENDMODE_CONSTANT, BLENDMODE_ONE_MINUS_CONSTANT, ADDRESS_CLAMP_TO_EDGE, ADDRESS_MIRRORED_REPEAT, ADDRESS_REPEAT, BLENDMODE_ZERO, BLENDMODE_ONE, BLENDMODE_SRC_COLOR, BLENDMODE_ONE_MINUS_SRC_COLOR, BLENDMODE_DST_COLOR, BLENDMODE_ONE_MINUS_DST_COLOR, BLENDMODE_SRC_ALPHA, BLENDMODE_SRC_ALPHA_SATURATE, BLENDMODE_ONE_MINUS_SRC_ALPHA, BLENDMODE_DST_ALPHA, BLENDMODE_ONE_MINUS_DST_ALPHA, BUFFER_STATIC, BUFFER_DYNAMIC, BUFFER_STREAM, CULLFACE_NONE, CULLFACE_BACK, CULLFACE_FRONT, CULLFACE_FRONTANDBACK, FILTER_NEAREST, FILTER_LINEAR, FILTER_NEAREST_MIPMAP_NEAREST, FILTER_NEAREST_MIPMAP_LINEAR, FILTER_LINEAR_MIPMAP_NEAREST, FILTER_LINEAR_MIPMAP_LINEAR, INDEXFORMAT_UINT8, INDEXFORMAT_UINT16, INDEXFORMAT_UINT32, PRIMITIVE_POINTS, PRIMITIVE_LINES, PRIMITIVE_LINELOOP, PRIMITIVE_LINESTRIP, PRIMITIVE_TRIANGLES, PRIMITIVE_TRISTRIP, PRIMITIVE_TRIFAN, SEMANTIC_POSITION, SEMANTIC_NORMAL, SEMANTIC_COLOR, SEMANTIC_TEXCOORD, SEMANTIC_TEXCOORD0, SEMANTIC_TEXCOORD1, SEMANTIC_ATTR0, SEMANTIC_ATTR1, SEMANTIC_ATTR2, SEMANTIC_ATTR3, TEXTURELOCK_READ, TEXTURELOCK_WRITE, TEXTURETYPE_RGBM, TEXTURETYPE_DEFAULT, TEXTURETYPE_SWIZZLEGGGR } from '../platform/graphics/constants.js';\nimport { ShaderGenerator } from '../scene/shader-lib/programs/shader-generator.js';\nimport { drawQuadWithShader } from '../scene/graphics/quad-render-utils.js';\nimport { shaderChunks } from '../scene/shader-lib/chunks/chunks.js';\nimport { GraphicsDevice } from '../platform/graphics/graphics-device.js';\nimport { IndexBuffer } from '../platform/graphics/index-buffer.js';\nimport { LayerComposition } from '../scene/composition/layer-composition.js';\nimport { PostEffect } from '../scene/graphics/post-effect.js';\nimport { PostEffectQueue } from '../framework/components/camera/post-effect-queue.js';\nimport { ProgramLibrary } from '../scene/shader-lib/program-library.js';\nimport { getProgramLibrary, setProgramLibrary } from '../scene/shader-lib/get-program-library.js';\nimport { RenderTarget } from '../platform/graphics/render-target.js';\nimport { ScopeId } from '../platform/graphics/scope-id.js';\nimport { Shader } from '../platform/graphics/shader.js';\nimport { WebglShaderInput } from '../platform/graphics/webgl/webgl-shader-input.js';\nimport { Texture } from '../platform/graphics/texture.js';\nimport { VertexBuffer } from '../platform/graphics/vertex-buffer.js';\nimport { VertexFormat } from '../platform/graphics/vertex-format.js';\nimport { VertexIterator } from '../platform/graphics/vertex-iterator.js';\nimport { ShaderUtils } from '../platform/graphics/shader-utils.js';\nimport { BlendState } from '../platform/graphics/blend-state.js';\nimport { DepthState } from '../platform/graphics/depth-state.js';\nimport { PROJECTION_ORTHOGRAPHIC, PROJECTION_PERSPECTIVE, LAYERID_WORLD, LAYERID_IMMEDIATE } from '../scene/constants.js';\nimport { CylinderGeometry } from '../scene/geometry/cylinder-geometry.js';\nimport { BoxGeometry } from '../scene/geometry/box-geometry.js';\nimport { CapsuleGeometry } from '../scene/geometry/capsule-geometry.js';\nimport { ConeGeometry } from '../scene/geometry/cone-geometry.js';\nimport { PlaneGeometry } from '../scene/geometry/plane-geometry.js';\nimport { SphereGeometry } from '../scene/geometry/sphere-geometry.js';\nimport { TorusGeometry } from '../scene/geometry/torus-geometry.js';\nimport { calculateTangents } from '../scene/geometry/geometry-utils.js';\nimport { BasicMaterial } from '../scene/materials/basic-material.js';\nimport { ForwardRenderer } from '../scene/renderer/forward-renderer.js';\nimport { GraphNode } from '../scene/graph-node.js';\nimport { Material } from '../scene/materials/material.js';\nimport { Mesh } from '../scene/mesh.js';\nimport { Morph } from '../scene/morph.js';\nimport { MeshInstance } from '../scene/mesh-instance.js';\nimport { Model } from '../scene/model.js';\nimport { ParticleEmitter } from '../scene/particle-system/particle-emitter.js';\nimport { Picker } from '../framework/graphics/picker.js';\nimport { Scene } from '../scene/scene.js';\nimport { Skin } from '../scene/skin.js';\nimport { SkinInstance } from '../scene/skin-instance.js';\nimport { StandardMaterial } from '../scene/materials/standard-material.js';\nimport { Batch } from '../scene/batching/batch.js';\nimport { getDefaultMaterial } from '../scene/materials/default-material.js';\nimport { StandardMaterialOptions } from '../scene/materials/standard-material-options.js';\nimport { LitShaderOptions } from '../scene/shader-lib/programs/lit-shader-options.js';\nimport { Layer } from '../scene/layer.js';\nimport { Animation, Key, Node } from '../scene/animation/animation.js';\nimport { Skeleton } from '../scene/animation/skeleton.js';\nimport { Channel } from '../platform/audio/channel.js';\nimport { Channel3d } from '../platform/audio/channel3d.js';\nimport { Listener } from '../platform/sound/listener.js';\nimport { Sound } from '../platform/sound/sound.js';\nimport { SoundManager } from '../platform/sound/manager.js';\nimport { AssetRegistry } from '../framework/asset/asset-registry.js';\nimport { XrInputSource } from '../framework/xr/xr-input-source.js';\nimport { Controller } from '../platform/input/controller.js';\nimport { ElementInput } from '../framework/input/element-input.js';\nimport { GamePads } from '../platform/input/game-pads.js';\nimport { Keyboard } from '../platform/input/keyboard.js';\nimport { KeyboardEvent } from '../platform/input/keyboard-event.js';\nimport { Mouse } from '../platform/input/mouse.js';\nimport { MouseEvent } from '../platform/input/mouse-event.js';\nimport { TouchDevice } from '../platform/input/touch-device.js';\nimport { getTouchTargetCoords, Touch, TouchEvent } from '../platform/input/touch-event.js';\nimport { AppBase } from '../framework/app-base.js';\nimport { getApplication } from '../framework/globals.js';\nimport { CameraComponent } from '../framework/components/camera/component.js';\nimport { LightComponent } from '../framework/components/light/component.js';\nimport { ModelComponent } from '../framework/components/model/component.js';\nimport { RenderComponent } from '../framework/components/render/component.js';\nimport { BODYTYPE_STATIC, BODYTYPE_DYNAMIC, BODYTYPE_KINEMATIC, BODYFLAG_STATIC_OBJECT, BODYFLAG_KINEMATIC_OBJECT, BODYFLAG_NORESPONSE_OBJECT, BODYSTATE_ACTIVE_TAG, BODYSTATE_ISLAND_SLEEPING, BODYSTATE_WANTS_DEACTIVATION, BODYSTATE_DISABLE_DEACTIVATION, BODYSTATE_DISABLE_SIMULATION } from '../framework/components/rigid-body/constants.js';\nimport { RigidBodyComponent } from '../framework/components/rigid-body/component.js';\nimport { RigidBodyComponentSystem } from '../framework/components/rigid-body/system.js';\nimport { basisInitialize } from '../framework/handlers/basis.js';\nimport { Geometry } from '../scene/geometry/geometry.js';\n\nconst LINEBATCH_WORLD = 0;\nconst LINEBATCH_OVERLAY = 1;\nconst LINEBATCH_GIZMO = 2;\nconst log = {\n\twrite: function (text) {\n\t\tconsole.log(text);\n\t},\n\topen: function () {\n\t\tlog.write('Powered by PlayCanvas ' + version + ' ' + revision);\n\t},\n\tinfo: function (text) {\n\t\tconsole.info('INFO: ' + text);\n\t},\n\tdebug: function (text) {\n\t\tconsole.debug('DEBUG: ' + text);\n\t},\n\terror: function (text) {\n\t\tconsole.error('ERROR: ' + text);\n\t},\n\twarning: function (text) {\n\t\tconsole.warn('WARNING: ' + text);\n\t},\n\talert: function (text) {\n\t\tlog.write('ALERT: ' + text);\n\t\talert(text);\n\t},\n\tassert: function (condition, text) {\n\t\tif (condition === false) {\n\t\t\tlog.write('ASSERT: ' + text);\n\t\t}\n\t}\n};\nstring.endsWith = function (s, subs) {\n\treturn s.endsWith(subs);\n};\nstring.startsWith = function (s, subs) {\n\treturn s.startsWith(subs);\n};\nclass Timer {\n\tconstructor() {\n\t\tthis._isRunning = false;\n\t\tthis._a = 0;\n\t\tthis._b = 0;\n\t}\n\tstart() {\n\t\tthis._isRunning = true;\n\t\tthis._a = now();\n\t}\n\tstop() {\n\t\tthis._isRunning = false;\n\t\tthis._b = now();\n\t}\n\tgetMilliseconds() {\n\t\treturn this._b - this._a;\n\t}\n}\nconst time = {\n\tnow: now,\n\tTimer: Timer\n};\nObject.defineProperty(Color.prototype, 'data', {\n\tget: function () {\n\t\tif (!this._data) {\n\t\t\tthis._data = new Float32Array(4);\n\t\t}\n\t\tthis._data[0] = this.r;\n\t\tthis._data[1] = this.g;\n\t\tthis._data[2] = this.b;\n\t\tthis._data[3] = this.a;\n\t\treturn this._data;\n\t}\n});\nObject.defineProperty(Color.prototype, 'data3', {\n\tget: function () {\n\t\tif (!this._data3) {\n\t\t\tthis._data3 = new Float32Array(3);\n\t\t}\n\t\tthis._data3[0] = this.r;\n\t\tthis._data3[1] = this.g;\n\t\tthis._data3[2] = this.b;\n\t\treturn this._data3;\n\t}\n});\nfunction inherits(Self, Super) {\n\tconst Temp = function Temp() {};\n\tconst Func = function Func(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) {\n\t\tSuper.call(this, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);\n\t\tSelf.call(this, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);\n\t};\n\tFunc._super = Super.prototype;\n\tTemp.prototype = Super.prototype;\n\tFunc.prototype = new Temp();\n\treturn Func;\n}\nfunction makeArray(arr) {\n\treturn Array.prototype.slice.call(arr);\n}\nfunction createStyle(cssString) {\n\tconst result = document.createElement('style');\n\tresult.type = 'text/css';\n\tif (result.styleSheet) {\n\t\tresult.styleSheet.cssText = cssString;\n\t} else {\n\t\tresult.appendChild(document.createTextNode(cssString));\n\t}\n\treturn result;\n}\nmath.INV_LOG2 = Math.LOG2E;\nmath.intToBytes = math.intToBytes32;\nmath.bytesToInt = math.bytesToInt32;\nObject.defineProperty(Vec2.prototype, 'data', {\n\tget: function () {\n\t\tif (!this._data) {\n\t\t\tthis._data = new Float32Array(2);\n\t\t}\n\t\tthis._data[0] = this.x;\n\t\tthis._data[1] = this.y;\n\t\treturn this._data;\n\t}\n});\nVec2.prototype.scale = Vec2.prototype.mulScalar;\nObject.defineProperty(Vec3.prototype, 'data', {\n\tget: function () {\n\t\tif (!this._data) {\n\t\t\tthis._data = new Float32Array(3);\n\t\t}\n\t\tthis._data[0] = this.x;\n\t\tthis._data[1] = this.y;\n\t\tthis._data[2] = this.z;\n\t\treturn this._data;\n\t}\n});\nVec3.prototype.scale = Vec3.prototype.mulScalar;\nObject.defineProperty(Vec4.prototype, 'data', {\n\tget: function () {\n\t\tif (!this._data) {\n\t\t\tthis._data = new Float32Array(4);\n\t\t}\n\t\tthis._data[0] = this.x;\n\t\tthis._data[1] = this.y;\n\t\tthis._data[2] = this.z;\n\t\tthis._data[3] = this.w;\n\t\treturn this._data;\n\t}\n});\nVec4.prototype.scale = Vec4.prototype.mulScalar;\nconst shape = {\n\tAabb: BoundingBox,\n\tSphere: BoundingSphere,\n\tPlane: Plane\n};\nBoundingSphere.prototype.intersectRay = BoundingSphere.prototype.intersectsRay;\nFrustum.prototype.update = function (projectionMatrix, viewMatrix) {\n\tconst viewProj = new Mat4();\n\tviewProj.mul2(projectionMatrix, viewMatrix);\n\tthis.setFromMat4(viewProj);\n};\nconst ELEMENTTYPE_INT8 = TYPE_INT8;\nconst ELEMENTTYPE_UINT8 = TYPE_UINT8;\nconst ELEMENTTYPE_INT16 = TYPE_INT16;\nconst ELEMENTTYPE_UINT16 = TYPE_UINT16;\nconst ELEMENTTYPE_INT32 = TYPE_INT32;\nconst ELEMENTTYPE_UINT32 = TYPE_UINT32;\nconst ELEMENTTYPE_FLOAT32 = TYPE_FLOAT32;\nconst PIXELFORMAT_L8_A8 = PIXELFORMAT_LA8;\nconst PIXELFORMAT_R5_G6_B5 = PIXELFORMAT_RGB565;\nconst PIXELFORMAT_R5_G5_B5_A1 = PIXELFORMAT_RGBA5551;\nconst PIXELFORMAT_R4_G4_B4_A4 = PIXELFORMAT_RGBA4;\nconst PIXELFORMAT_R8_G8_B8 = PIXELFORMAT_RGB8;\nconst PIXELFORMAT_R8_G8_B8_A8 = PIXELFORMAT_RGBA8;\nconst BLENDMODE_CONSTANT_COLOR = BLENDMODE_CONSTANT;\nconst BLENDMODE_ONE_MINUS_CONSTANT_COLOR = BLENDMODE_ONE_MINUS_CONSTANT;\nconst BLENDMODE_CONSTANT_ALPHA = BLENDMODE_CONSTANT;\nconst BLENDMODE_ONE_MINUS_CONSTANT_ALPHA = BLENDMODE_ONE_MINUS_CONSTANT;\nfunction UnsupportedBrowserError(message) {\n\tthis.name = 'UnsupportedBrowserError';\n\tthis.message = message || '';\n}\nUnsupportedBrowserError.prototype = Error.prototype;\nfunction ContextCreationError(message) {\n\tthis.name = 'ContextCreationError';\n\tthis.message = message || '';\n}\nContextCreationError.prototype = Error.prototype;\nconst programlib = {\n\tbegin: ShaderGenerator.begin,\n\tdummyFragmentCode: ShaderUtils.dummyFragmentCode,\n\tend: ShaderGenerator.end,\n\tfogCode: ShaderGenerator.fogCode,\n\tgammaCode: ShaderGenerator.gammaCode,\n\tprecisionCode: ShaderUtils.precisionCode,\n\tskinCode: ShaderGenerator.skinCode,\n\ttonemapCode: ShaderGenerator.tonemapCode,\n\tversionCode: ShaderUtils.versionCode\n};\nconst gfx = {\n\tADDRESS_CLAMP_TO_EDGE: ADDRESS_CLAMP_TO_EDGE,\n\tADDRESS_MIRRORED_REPEAT: ADDRESS_MIRRORED_REPEAT,\n\tADDRESS_REPEAT: ADDRESS_REPEAT,\n\tBLENDMODE_ZERO: BLENDMODE_ZERO,\n\tBLENDMODE_ONE: BLENDMODE_ONE,\n\tBLENDMODE_SRC_COLOR: BLENDMODE_SRC_COLOR,\n\tBLENDMODE_ONE_MINUS_SRC_COLOR: BLENDMODE_ONE_MINUS_SRC_COLOR,\n\tBLENDMODE_DST_COLOR: BLENDMODE_DST_COLOR,\n\tBLENDMODE_ONE_MINUS_DST_COLOR: BLENDMODE_ONE_MINUS_DST_COLOR,\n\tBLENDMODE_SRC_ALPHA: BLENDMODE_SRC_ALPHA,\n\tBLENDMODE_SRC_ALPHA_SATURATE: BLENDMODE_SRC_ALPHA_SATURATE,\n\tBLENDMODE_ONE_MINUS_SRC_ALPHA: BLENDMODE_ONE_MINUS_SRC_ALPHA,\n\tBLENDMODE_DST_ALPHA: BLENDMODE_DST_ALPHA,\n\tBLENDMODE_ONE_MINUS_DST_ALPHA: BLENDMODE_ONE_MINUS_DST_ALPHA,\n\tBUFFER_STATIC: BUFFER_STATIC,\n\tBUFFER_DYNAMIC: BUFFER_DYNAMIC,\n\tBUFFER_STREAM: BUFFER_STREAM,\n\tCULLFACE_NONE: CULLFACE_NONE,\n\tCULLFACE_BACK: CULLFACE_BACK,\n\tCULLFACE_FRONT: CULLFACE_FRONT,\n\tCULLFACE_FRONTANDBACK: CULLFACE_FRONTANDBACK,\n\tELEMENTTYPE_INT8: TYPE_INT8,\n\tELEMENTTYPE_UINT8: TYPE_UINT8,\n\tELEMENTTYPE_INT16: TYPE_INT16,\n\tELEMENTTYPE_UINT16: TYPE_UINT16,\n\tELEMENTTYPE_INT32: TYPE_INT32,\n\tELEMENTTYPE_UINT32: TYPE_UINT32,\n\tELEMENTTYPE_FLOAT32: TYPE_FLOAT32,\n\tFILTER_NEAREST: FILTER_NEAREST,\n\tFILTER_LINEAR: FILTER_LINEAR,\n\tFILTER_NEAREST_MIPMAP_NEAREST: FILTER_NEAREST_MIPMAP_NEAREST,\n\tFILTER_NEAREST_MIPMAP_LINEAR: FILTER_NEAREST_MIPMAP_LINEAR,\n\tFILTER_LINEAR_MIPMAP_NEAREST: FILTER_LINEAR_MIPMAP_NEAREST,\n\tFILTER_LINEAR_MIPMAP_LINEAR: FILTER_LINEAR_MIPMAP_LINEAR,\n\tINDEXFORMAT_UINT8: INDEXFORMAT_UINT8,\n\tINDEXFORMAT_UINT16: INDEXFORMAT_UINT16,\n\tINDEXFORMAT_UINT32: INDEXFORMAT_UINT32,\n\tPIXELFORMAT_RGB565: PIXELFORMAT_RGB565,\n\tPIXELFORMAT_RGB8: PIXELFORMAT_RGB8,\n\tPIXELFORMAT_RGBA8: PIXELFORMAT_RGBA8,\n\tPRIMITIVE_POINTS: PRIMITIVE_POINTS,\n\tPRIMITIVE_LINES: PRIMITIVE_LINES,\n\tPRIMITIVE_LINELOOP: PRIMITIVE_LINELOOP,\n\tPRIMITIVE_LINESTRIP: PRIMITIVE_LINESTRIP,\n\tPRIMITIVE_TRIANGLES: PRIMITIVE_TRIANGLES,\n\tPRIMITIVE_TRISTRIP: PRIMITIVE_TRISTRIP,\n\tPRIMITIVE_TRIFAN: PRIMITIVE_TRIFAN,\n\tSEMANTIC_POSITION: SEMANTIC_POSITION,\n\tSEMANTIC_NORMAL: SEMANTIC_NORMAL,\n\tSEMANTIC_COLOR: SEMANTIC_COLOR,\n\tSEMANTIC_TEXCOORD: SEMANTIC_TEXCOORD,\n\tSEMANTIC_TEXCOORD0: SEMANTIC_TEXCOORD0,\n\tSEMANTIC_TEXCOORD1: SEMANTIC_TEXCOORD1,\n\tSEMANTIC_ATTR0: SEMANTIC_ATTR0,\n\tSEMANTIC_ATTR1: SEMANTIC_ATTR1,\n\tSEMANTIC_ATTR2: SEMANTIC_ATTR2,\n\tSEMANTIC_ATTR3: SEMANTIC_ATTR3,\n\tTEXTURELOCK_READ: TEXTURELOCK_READ,\n\tTEXTURELOCK_WRITE: TEXTURELOCK_WRITE,\n\tdrawQuadWithShader: drawQuadWithShader,\n\tprogramlib: programlib,\n\tshaderChunks: shaderChunks,\n\tContextCreationError: ContextCreationError,\n\tDevice: GraphicsDevice,\n\tIndexBuffer: IndexBuffer,\n\tProgramLibrary: ProgramLibrary,\n\tRenderTarget: RenderTarget,\n\tScopeId: ScopeId,\n\tShader: Shader,\n\tShaderInput: WebglShaderInput,\n\tTexture: Texture,\n\tUnsupportedBrowserError: UnsupportedBrowserError,\n\tVertexBuffer: VertexBuffer,\n\tVertexFormat: VertexFormat,\n\tVertexIterator: VertexIterator\n};\nconst _viewport = new Vec4();\nfunction createSphere(device, opts) {\n\treturn Mesh.fromGeometry(device, new SphereGeometry(opts));\n}\nfunction createPlane(device, opts) {\n\treturn Mesh.fromGeometry(device, new PlaneGeometry(opts));\n}\nfunction createBox(device, opts) {\n\treturn Mesh.fromGeometry(device, new BoxGeometry(opts));\n}\nfunction createTorus(device, opts) {\n\treturn Mesh.fromGeometry(device, new TorusGeometry(opts));\n}\nfunction createCapsule(device, opts) {\n\treturn Mesh.fromGeometry(device, new CapsuleGeometry(opts));\n}\nfunction createCone(device, opts) {\n\treturn Mesh.fromGeometry(device, new ConeGeometry(opts));\n}\nfunction createCylinder(device, opts) {\n\treturn Mesh.fromGeometry(device, new CylinderGeometry(opts));\n}\nfunction createMesh(device, positions, opts = {}) {\n\tconst geom = new Geometry();\n\tgeom.positions = positions;\n\tgeom.normals = opts.normals;\n\tgeom.tangents = opts.tangents;\n\tgeom.colors = opts.colors;\n\tgeom.uvs = opts.uvs;\n\tgeom.uvs1 = opts.uvs1;\n\tgeom.blendIndices = opts.blendIndices;\n\tgeom.blendWeights = opts.blendWeights;\n\tgeom.indices = opts.indices;\n\treturn Mesh.fromGeometry(device, geom, opts);\n}\nfunction drawFullscreenQuad(device, target, vertexBuffer, shader, rect) {\n\tlet viewport;\n\tif (rect) {\n\t\tconst w = target ? target.width : device.width;\n\t\tconst h = target ? target.height : device.height;\n\t\tviewport = _viewport.set(rect.x * w, rect.y * h, rect.z * w, rect.w * h);\n\t}\n\tdrawQuadWithShader(device, target, shader, viewport);\n}\nconst posteffect = {\n\tcreateFullscreenQuad: device => {\n\t\treturn device.quadVertexBuffer;\n\t},\n\tdrawFullscreenQuad: drawFullscreenQuad,\n\tPostEffect: PostEffect,\n\tPostEffectQueue: PostEffectQueue\n};\nObject.defineProperty(shaderChunks, 'transformSkinnedVS', {\n\tget: function () {\n\t\treturn '#define SKIN\\n' + shaderChunks.transformVS;\n\t}\n});\nconst deprecatedChunks = {\n\t'ambientPrefilteredCube.frag': 'ambientEnv.frag',\n\t'ambientPrefilteredCubeLod.frag': 'ambientEnv.frag',\n\t'dpAtlasQuad.frag': null,\n\t'genParaboloid.frag': null,\n\t'prefilterCubemap.frag': null,\n\t'reflectionDpAtlas.frag': 'reflectionEnv.frag',\n\t'reflectionPrefilteredCube.frag': 'reflectionEnv.frag',\n\t'reflectionPrefilteredCubeLod.frag': 'reflectionEnv.frag'\n};\nObject.keys(deprecatedChunks).forEach(chunkName => {\n\tObject.defineProperty(shaderChunks, chunkName, {\n\t\tget: function () {\n\t\t\treturn null;\n\t\t},\n\t\tset: function () {}\n\t});\n});\nObject.defineProperties(RenderTarget.prototype, {\n\t_glFrameBuffer: {\n\t\tget: function () {\n\t\t\treturn this.impl._glFrameBuffer;\n\t\t},\n\t\tset: function (rgbm) {}\n\t}\n});\nObject.defineProperty(VertexFormat, 'defaultInstancingFormat', {\n\tget: function () {\n\t\treturn null;\n\t}\n});\nObject.defineProperties(Texture.prototype, {\n\trgbm: {\n\t\tget: function () {\n\t\t\treturn this.type === TEXTURETYPE_RGBM;\n\t\t},\n\t\tset: function (rgbm) {\n\t\t\tthis.type = rgbm ? TEXTURETYPE_RGBM : TEXTURETYPE_DEFAULT;\n\t\t}\n\t},\n\tswizzleGGGR: {\n\t\tget: function () {\n\t\t\treturn this.type === TEXTURETYPE_SWIZZLEGGGR;\n\t\t},\n\t\tset: function (swizzleGGGR) {\n\t\t\tthis.type = swizzleGGGR ? TEXTURETYPE_SWIZZLEGGGR : TEXTURETYPE_DEFAULT;\n\t\t}\n\t},\n\t_glTexture: {\n\t\tget: function () {\n\t\t\treturn this.impl._glTexture;\n\t\t}\n\t},\n\tautoMipmap: {\n\t\tget: function () {\n\t\t\treturn this._mipmaps;\n\t\t},\n\t\tset: function (value) {\n\t\t\tthis._mipmaps = value;\n\t\t}\n\t}\n});\nObject.defineProperty(GraphicsDevice.prototype, 'webgl2', {\n\tget: function () {\n\t\treturn this.isWebGL2;\n\t}\n});\nGraphicsDevice.prototype.getProgramLibrary = function () {\n\treturn getProgramLibrary(this);\n};\nGraphicsDevice.prototype.setProgramLibrary = function (lib) {\n\tsetProgramLibrary(this, lib);\n};\nGraphicsDevice.prototype.removeShaderFromCache = function (shader) {\n\tgetProgramLibrary(this).removeFromCache(shader);\n};\nBlendState.DEFAULT = Object.freeze(new BlendState());\nconst _tempBlendState = new BlendState();\nconst _tempDepthState = new DepthState();\nGraphicsDevice.prototype.setBlendFunction = function (blendSrc, blendDst) {\n\tconst currentBlendState = this.blendState;\n\t_tempBlendState.copy(currentBlendState);\n\t_tempBlendState.setColorBlend(currentBlendState.colorOp, blendSrc, blendDst);\n\t_tempBlendState.setAlphaBlend(currentBlendState.alphaOp, blendSrc, blendDst);\n\tthis.setBlendState(_tempBlendState);\n};\nGraphicsDevice.prototype.setBlendFunctionSeparate = function (blendSrc, blendDst, blendSrcAlpha, blendDstAlpha) {\n\tconst currentBlendState = this.blendState;\n\t_tempBlendState.copy(currentBlendState);\n\t_tempBlendState.setColorBlend(currentBlendState.colorOp, blendSrc, blendDst);\n\t_tempBlendState.setAlphaBlend(currentBlendState.alphaOp, blendSrcAlpha, blendDstAlpha);\n\tthis.setBlendState(_tempBlendState);\n};\nGraphicsDevice.prototype.setBlendEquation = function (blendEquation) {\n\tconst currentBlendState = this.blendState;\n\t_tempBlendState.copy(currentBlendState);\n\t_tempBlendState.setColorBlend(blendEquation, currentBlendState.colorSrcFactor, currentBlendState.colorDstFactor);\n\t_tempBlendState.setAlphaBlend(blendEquation, currentBlendState.alphaSrcFactor, currentBlendState.alphaDstFactor);\n\tthis.setBlendState(_tempBlendState);\n};\nGraphicsDevice.prototype.setBlendEquationSeparate = function (blendEquation, blendAlphaEquation) {\n\tconst currentBlendState = this.blendState;\n\t_tempBlendState.copy(currentBlendState);\n\t_tempBlendState.setColorBlend(blendEquation, currentBlendState.colorSrcFactor, currentBlendState.colorDstFactor);\n\t_tempBlendState.setAlphaBlend(blendAlphaEquation, currentBlendState.alphaSrcFactor, currentBlendState.alphaDstFactor);\n\tthis.setBlendState(_tempBlendState);\n};\nGraphicsDevice.prototype.setColorWrite = function (redWrite, greenWrite, blueWrite, alphaWrite) {\n\tconst currentBlendState = this.blendState;\n\t_tempBlendState.copy(currentBlendState);\n\t_tempBlendState.setColorWrite(redWrite, greenWrite, blueWrite, alphaWrite);\n\tthis.setBlendState(_tempBlendState);\n};\nGraphicsDevice.prototype.getBlending = function () {\n\treturn this.blendState.blend;\n};\nGraphicsDevice.prototype.setBlending = function (blending) {\n\t_tempBlendState.copy(this.blendState);\n\t_tempBlendState.blend = blending;\n\tthis.setBlendState(_tempBlendState);\n};\nGraphicsDevice.prototype.setDepthWrite = function (write) {\n\t_tempDepthState.copy(this.depthState);\n\t_tempDepthState.write = write;\n\tthis.setDepthState(_tempDepthState);\n};\nGraphicsDevice.prototype.setDepthFunc = function (func) {\n\t_tempDepthState.copy(this.depthState);\n\t_tempDepthState.func = func;\n\tthis.setDepthState(_tempDepthState);\n};\nGraphicsDevice.prototype.setDepthTest = function (test) {\n\t_tempDepthState.copy(this.depthState);\n\t_tempDepthState.test = test;\n\tthis.setDepthState(_tempDepthState);\n};\nGraphicsDevice.prototype.getCullMode = function () {\n\treturn this.cullMode;\n};\nconst PhongMaterial = StandardMaterial;\nconst LitOptions = LitShaderOptions;\nconst scene = {\n\tprocedural: {\n\t\tcalculateTangents: calculateTangents,\n\t\tcreateMesh: createMesh,\n\t\tcreateTorus: createTorus,\n\t\tcreateCylinder: createCylinder,\n\t\tcreateCapsule: createCapsule,\n\t\tcreateCone: createCone,\n\t\tcreateSphere: createSphere,\n\t\tcreatePlane: createPlane,\n\t\tcreateBox: createBox\n\t},\n\tBasicMaterial: BasicMaterial,\n\tForwardRenderer: ForwardRenderer,\n\tGraphNode: GraphNode,\n\tMaterial: Material,\n\tMesh: Mesh,\n\tMeshInstance: MeshInstance,\n\tModel: Model,\n\tParticleEmitter: ParticleEmitter,\n\tPhongMaterial: StandardMaterial,\n\tPicker: Picker,\n\tProjection: {\n\t\tORTHOGRAPHIC: PROJECTION_ORTHOGRAPHIC,\n\t\tPERSPECTIVE: PROJECTION_PERSPECTIVE\n\t},\n\tScene: Scene,\n\tSkin: Skin,\n\tSkinInstance: SkinInstance\n};\nObject.defineProperty(Scene.prototype, 'defaultMaterial', {\n\tget: function () {\n\t\treturn getDefaultMaterial(getApplication().graphicsDevice);\n\t}\n});\nObject.defineProperty(LayerComposition.prototype, '_meshInstances', {\n\tget: function () {\n\t\treturn null;\n\t}\n});\nObject.defineProperty(Scene.prototype, 'drawCalls', {\n\tget: function () {\n\t\treturn null;\n\t}\n});\n['128', '64', '32', '16', '8', '4'].forEach((size, index) => {\n\tObject.defineProperty(Scene.prototype, `skyboxPrefiltered${size}`, {\n\t\tget: function () {\n\t\t\treturn this._prefilteredCubemaps[index];\n\t\t},\n\t\tset: function (value) {\n\t\t\tthis._prefilteredCubemaps[index] = value;\n\t\t\tthis.updateShaders = true;\n\t\t}\n\t});\n});\nObject.defineProperty(Scene.prototype, 'models', {\n\tget: function () {\n\t\tif (!this._models) {\n\t\t\tthis._models = [];\n\t\t}\n\t\treturn this._models;\n\t}\n});\nObject.defineProperty(Layer.prototype, 'renderTarget', {\n\tset: function (rt) {\n\t\tthis._renderTarget = rt;\n\t\tthis._dirtyComposition = true;\n\t},\n\tget: function () {\n\t\treturn this._renderTarget;\n\t}\n});\nScene.prototype.addModel = function (model) {\n\tif (this.containsModel(model)) return;\n\tconst layer = this.layers.getLayerById(LAYERID_WORLD);\n\tif (!layer) return;\n\tlayer.addMeshInstances(model.meshInstances);\n\tthis.models.push(model);\n};\nScene.prototype.addShadowCaster = function (model) {\n\tconst layer = this.layers.getLayerById(LAYERID_WORLD);\n\tif (!layer) return;\n\tlayer.addShadowCasters(model.meshInstances);\n};\nScene.prototype.removeModel = function (model) {\n\tconst index = this.models.indexOf(model);\n\tif (index !== -1) {\n\t\tconst layer = this.layers.getLayerById(LAYERID_WORLD);\n\t\tif (!layer) return;\n\t\tlayer.removeMeshInstances(model.meshInstances);\n\t\tthis.models.splice(index, 1);\n\t}\n};\nScene.prototype.removeShadowCasters = function (model) {\n\tconst layer = this.layers.getLayerById(LAYERID_WORLD);\n\tif (!layer) return;\n\tlayer.removeShadowCasters(model.meshInstances);\n};\nScene.prototype.containsModel = function (model) {\n\treturn this.models.indexOf(model) >= 0;\n};\nScene.prototype.getModels = function (model) {\n\treturn this.models;\n};\nObject.defineProperty(Batch.prototype, 'model', {\n\tget: function () {\n\t\treturn null;\n\t}\n});\nForwardRenderer.prototype.renderComposition = function (comp) {\n\tgetApplication().renderComposition(comp);\n};\nMeshInstance.prototype.syncAabb = function () {};\nMorph.prototype.getTarget = function (index) {\n\treturn this.targets[index];\n};\nGraphNode.prototype._dirtify = function (local) {\n\tif (local) this._dirtifyLocal();else this._dirtifyWorld();\n};\nGraphNode.prototype.addLabel = function (label) {\n\tthis._labels[label] = true;\n};\nGraphNode.prototype.getLabels = function () {\n\treturn Object.keys(this._labels);\n};\nGraphNode.prototype.hasLabel = function (label) {\n\treturn !!this._labels[label];\n};\nGraphNode.prototype.removeLabel = function (label) {\n\tdelete this._labels[label];\n};\nGraphNode.prototype.findByLabel = function (label, results = []) {\n\tif (this.hasLabel(label)) {\n\t\tresults.push(this);\n\t}\n\tfor (let i = 0; i < this._children.length; ++i) {\n\t\tresults = this._children[i].findByLabel(label, results);\n\t}\n\treturn results;\n};\nGraphNode.prototype.getChildren = function () {\n\treturn this.children;\n};\nGraphNode.prototype.getName = function () {\n\treturn this.name;\n};\nGraphNode.prototype.getPath = function () {\n\treturn this.path;\n};\nGraphNode.prototype.getRoot = function () {\n\treturn this.root;\n};\nGraphNode.prototype.getParent = function () {\n\treturn this.parent;\n};\nGraphNode.prototype.setName = function (name) {\n\tthis.name = name;\n};\nMaterial.prototype.getName = function () {\n\treturn this.name;\n};\nMaterial.prototype.setName = function (name) {\n\tthis.name = name;\n};\nMaterial.prototype.getShader = function () {\n\treturn this.shader;\n};\nMaterial.prototype.setShader = function (shader) {\n\tthis.shader = shader;\n};\nObject.defineProperty(Material.prototype, 'blend', {\n\tset: function (value) {\n\t\tthis.blendState.blend = value;\n\t},\n\tget: function () {\n\t\treturn this.blendState.blend;\n\t}\n});\nObject.defineProperty(Material.prototype, 'blendSrc', {\n\tset: function (value) {\n\t\tconst currentBlendState = this.blendState;\n\t\t_tempBlendState.copy(currentBlendState);\n\t\t_tempBlendState.setColorBlend(currentBlendState.colorOp, value, currentBlendState.colorDstFactor);\n\t\t_tempBlendState.setAlphaBlend(currentBlendState.alphaOp, value, currentBlendState.alphaDstFactor);\n\t\tthis.blendState = _tempBlendState;\n\t},\n\tget: function () {\n\t\treturn this.blendState.colorSrcFactor;\n\t}\n});\nObject.defineProperty(Material.prototype, 'blendDst', {\n\tset: function (value) {\n\t\tconst currentBlendState = this.blendState;\n\t\t_tempBlendState.copy(currentBlendState);\n\t\t_tempBlendState.setColorBlend(currentBlendState.colorOp, currentBlendState.colorSrcFactor, value);\n\t\t_tempBlendState.setAlphaBlend(currentBlendState.alphaOp, currentBlendState.alphaSrcFactor, value);\n\t\tthis.blendState = _tempBlendState;\n\t},\n\tget: function () {\n\t\treturn this.blendState.colorDstFactor;\n\t}\n});\nObject.defineProperty(StandardMaterial.prototype, 'shininess', {\n\tget: function () {\n\t\treturn this.gloss * 100;\n\t},\n\tset: function (value) {\n\t\tthis.gloss = value * 0.01;\n\t}\n});\nfunction _defineAlias(newName, oldName) {\n\tObject.defineProperty(StandardMaterial.prototype, oldName, {\n\t\tget: function () {\n\t\t\treturn this[newName];\n\t\t},\n\t\tset: function (value) {\n\t\t\tthis[newName] = value;\n\t\t}\n\t});\n}\n_defineAlias('diffuseTint', 'diffuseMapTint');\n_defineAlias('specularTint', 'specularMapTint');\n_defineAlias('emissiveTint', 'emissiveMapTint');\n_defineAlias('aoVertexColor', 'aoMapVertexColor');\n_defineAlias('diffuseVertexColor', 'diffuseMapVertexColor');\n_defineAlias('specularVertexColor', 'specularMapVertexColor');\n_defineAlias('emissiveVertexColor', 'emissiveMapVertexColor');\n_defineAlias('metalnessVertexColor', 'metalnessMapVertexColor');\n_defineAlias('glossVertexColor', 'glossMapVertexColor');\n_defineAlias('opacityVertexColor', 'opacityMapVertexColor');\n_defineAlias('lightVertexColor', 'lightMapVertexColor');\n_defineAlias('sheenGloss', 'sheenGlossiess');\n_defineAlias('clearCoatGloss', 'clearCostGlossiness');\nfunction _defineOption(name, newName) {\n\tif (name !== 'pass') {\n\t\tObject.defineProperty(StandardMaterialOptions.prototype, name, {\n\t\t\tget: function () {\n\t\t\t\treturn this.litOptions[newName || name];\n\t\t\t},\n\t\t\tset: function (value) {\n\t\t\t\tthis.litOptions[newName || name] = value;\n\t\t\t}\n\t\t});\n\t}\n}\n_defineOption('refraction', 'useRefraction');\nconst tempOptions = new LitShaderOptions();\nconst litOptionProperties = Object.getOwnPropertyNames(tempOptions);\nfor (const litOption in litOptionProperties) {\n\t_defineOption(litOptionProperties[litOption]);\n}\nconst anim = {\n\tAnimation: Animation,\n\tKey: Key,\n\tNode: Node,\n\tSkeleton: Skeleton\n};\nAnimation.prototype.getDuration = function () {\n\treturn this.duration;\n};\nAnimation.prototype.getName = function () {\n\treturn this.name;\n};\nAnimation.prototype.getNodes = function () {\n\treturn this.nodes;\n};\nAnimation.prototype.setDuration = function (duration) {\n\tthis.duration = duration;\n};\nAnimation.prototype.setName = function (name) {\n\tthis.name = name;\n};\nSkeleton.prototype.getAnimation = function () {\n\treturn this.animation;\n};\nSkeleton.prototype.getCurrentTime = function () {\n\treturn this.currentTime;\n};\nSkeleton.prototype.getLooping = function () {\n\treturn this.looping;\n};\nSkeleton.prototype.getNumNodes = function () {\n\treturn this.numNodes;\n};\nSkeleton.prototype.setAnimation = function (animation) {\n\tthis.animation = animation;\n};\nSkeleton.prototype.setCurrentTime = function (time) {\n\tthis.currentTime = time;\n};\nSkeleton.prototype.setLooping = function (looping) {\n\tthis.looping = looping;\n};\nconst audio = {\n\tAudioManager: SoundManager,\n\tChannel: Channel,\n\tChannel3d: Channel3d,\n\tListener: Listener,\n\tSound: Sound\n};\nSoundManager.prototype.getListener = function () {\n\treturn this.listener;\n};\nSoundManager.prototype.getVolume = function () {\n\treturn this.volume;\n};\nSoundManager.prototype.setVolume = function (volume) {\n\tthis.volume = volume;\n};\nconst asset = {\n\tASSET_ANIMATION: 'animation',\n\tASSET_AUDIO: 'audio',\n\tASSET_IMAGE: 'image',\n\tASSET_JSON: 'json',\n\tASSET_MODEL: 'model',\n\tASSET_MATERIAL: 'material',\n\tASSET_TEXT: 'text',\n\tASSET_TEXTURE: 'texture',\n\tASSET_CUBEMAP: 'cubemap',\n\tASSET_SCRIPT: 'script'\n};\nAssetRegistry.prototype.getAssetById = function (id) {\n\treturn this.get(id);\n};\nObject.defineProperty(XrInputSource.prototype, 'ray', {\n\tget: function () {\n\t\treturn this._rayLocal;\n\t}\n});\nObject.defineProperty(XrInputSource.prototype, 'position', {\n\tget: function () {\n\t\treturn this._localPosition;\n\t}\n});\nObject.defineProperty(XrInputSource.prototype, 'rotation', {\n\tget: function () {\n\t\treturn this._localRotation;\n\t}\n});\nconst input = {\n\tgetTouchTargetCoords: getTouchTargetCoords,\n\tController: Controller,\n\tGamePads: GamePads,\n\tKeyboard: Keyboard,\n\tKeyboardEvent: KeyboardEvent,\n\tMouse: Mouse,\n\tMouseEvent: MouseEvent,\n\tTouch: Touch,\n\tTouchDevice: TouchDevice,\n\tTouchEvent: TouchEvent\n};\nObject.defineProperty(ElementInput.prototype, 'wheel', {\n\tget: function () {\n\t\treturn this.wheelDelta * -2;\n\t}\n});\nObject.defineProperty(MouseEvent.prototype, 'wheel', {\n\tget: function () {\n\t\treturn this.wheelDelta * -2;\n\t}\n});\nconst RIGIDBODY_TYPE_STATIC = BODYTYPE_STATIC;\nconst RIGIDBODY_TYPE_DYNAMIC = BODYTYPE_DYNAMIC;\nconst RIGIDBODY_TYPE_KINEMATIC = BODYTYPE_KINEMATIC;\nconst RIGIDBODY_CF_STATIC_OBJECT = BODYFLAG_STATIC_OBJECT;\nconst RIGIDBODY_CF_KINEMATIC_OBJECT = BODYFLAG_KINEMATIC_OBJECT;\nconst RIGIDBODY_CF_NORESPONSE_OBJECT = BODYFLAG_NORESPONSE_OBJECT;\nconst RIGIDBODY_ACTIVE_TAG = BODYSTATE_ACTIVE_TAG;\nconst RIGIDBODY_ISLAND_SLEEPING = BODYSTATE_ISLAND_SLEEPING;\nconst RIGIDBODY_WANTS_DEACTIVATION = BODYSTATE_WANTS_DEACTIVATION;\nconst RIGIDBODY_DISABLE_DEACTIVATION = BODYSTATE_DISABLE_DEACTIVATION;\nconst RIGIDBODY_DISABLE_SIMULATION = BODYSTATE_DISABLE_SIMULATION;\nAppBase.prototype.isFullscreen = function () {\n\treturn !!document.fullscreenElement;\n};\nAppBase.prototype.enableFullscreen = function (element, success, error) {\n\telement = element || this.graphicsDevice.canvas;\n\tconst s = function s() {\n\t\tsuccess();\n\t\tdocument.removeEventListener('fullscreenchange', s);\n\t};\n\tconst e = function e() {\n\t\terror();\n\t\tdocument.removeEventListener('fullscreenerror', e);\n\t};\n\tif (success) {\n\t\tdocument.addEventListener('fullscreenchange', s, false);\n\t}\n\tif (error) {\n\t\tdocument.addEventListener('fullscreenerror', e, false);\n\t}\n\tif (element.requestFullscreen) {\n\t\telement.requestFullscreen(Element.ALLOW_KEYBOARD_INPUT);\n\t} else {\n\t\terror();\n\t}\n};\nAppBase.prototype.disableFullscreen = function (success) {\n\tconst s = function s() {\n\t\tsuccess();\n\t\tdocument.removeEventListener('fullscreenchange', s);\n\t};\n\tif (success) {\n\t\tdocument.addEventListener('fullscreenchange', s, false);\n\t}\n\tdocument.exitFullscreen();\n};\nAppBase.prototype.getSceneUrl = function (name) {\n\tconst entry = this.scenes.find(name);\n\tif (entry) {\n\t\treturn entry.url;\n\t}\n\treturn null;\n};\nAppBase.prototype.loadScene = function (url, callback) {\n\tthis.scenes.loadScene(url, callback);\n};\nAppBase.prototype.loadSceneHierarchy = function (url, callback) {\n\tthis.scenes.loadSceneHierarchy(url, callback);\n};\nAppBase.prototype.loadSceneSettings = function (url, callback) {\n\tthis.scenes.loadSceneSettings(url, callback);\n};\nAppBase.prototype.renderMeshInstance = function (meshInstance, options) {\n\tconst layer = options != null && options.layer ? options.layer : this.scene.defaultDrawLayer;\n\tthis.scene.immediate.drawMesh(null, null, null, meshInstance, layer);\n};\nAppBase.prototype.renderMesh = function (mesh, material, matrix, options) {\n\tconst layer = options != null && options.layer ? options.layer : this.scene.defaultDrawLayer;\n\tthis.scene.immediate.drawMesh(material, matrix, mesh, null, layer);\n};\nAppBase.prototype._addLines = function (positions, colors, options) {\n\tconst layer = options && options.layer ? options.layer : this.scene.layers.getLayerById(LAYERID_IMMEDIATE);\n\tconst depthTest = options && options.depthTest !== undefined ? options.depthTest : true;\n\tconst batch = this.scene.immediate.getBatch(layer, depthTest);\n\tbatch.addLines(positions, colors);\n};\nAppBase.prototype.renderLine = function (start, end, color) {\n\tlet endColor = color;\n\tlet options;\n\tconst arg3 = arguments[3];\n\tconst arg4 = arguments[4];\n\tif (arg3 instanceof Color) {\n\t\tendColor = arg3;\n\t\tif (typeof arg4 === 'number') {\n\t\t\tif (arg4 === LINEBATCH_OVERLAY) {\n\t\t\t\toptions = {\n\t\t\t\t\tlayer: this.scene.layers.getLayerById(LAYERID_IMMEDIATE),\n\t\t\t\t\tdepthTest: false\n\t\t\t\t};\n\t\t\t} else {\n\t\t\t\toptions = {\n\t\t\t\t\tlayer: this.scene.layers.getLayerById(LAYERID_IMMEDIATE),\n\t\t\t\t\tdepthTest: true\n\t\t\t\t};\n\t\t\t}\n\t\t} else {\n\t\t\toptions = arg4;\n\t\t}\n\t} else if (typeof arg3 === 'number') {\n\t\tendColor = color;\n\t\tif (arg3 === LINEBATCH_OVERLAY) {\n\t\t\toptions = {\n\t\t\t\tlayer: this.scene.layers.getLayerById(LAYERID_IMMEDIATE),\n\t\t\t\tdepthTest: false\n\t\t\t};\n\t\t} else {\n\t\t\toptions = {\n\t\t\t\tlayer: this.scene.layers.getLayerById(LAYERID_IMMEDIATE),\n\t\t\t\tdepthTest: true\n\t\t\t};\n\t\t}\n\t} else if (arg3) {\n\t\toptions = arg3;\n\t}\n\tthis._addLines([start, end], [color, endColor], options);\n};\nAppBase.prototype.renderLines = function (position, color, options) {\n\tif (!options) {\n\t\toptions = {\n\t\t\tlayer: this.scene.layers.getLayerById(LAYERID_IMMEDIATE),\n\t\t\tdepthTest: true\n\t\t};\n\t} else if (typeof options === 'number') {\n\t\tif (options === LINEBATCH_OVERLAY) {\n\t\t\toptions = {\n\t\t\t\tlayer: this.scene.layers.getLayerById(LAYERID_IMMEDIATE),\n\t\t\t\tdepthTest: false\n\t\t\t};\n\t\t} else {\n\t\t\toptions = {\n\t\t\t\tlayer: this.scene.layers.getLayerById(LAYERID_IMMEDIATE),\n\t\t\t\tdepthTest: true\n\t\t\t};\n\t\t}\n\t}\n\tconst multiColor = !!color.length;\n\tif (multiColor) {\n\t\tif (position.length !== color.length) {\n\t\t\tconsole.error('renderLines: position/color arrays have different lengths');\n\t\t\treturn;\n\t\t}\n\t}\n\tif (position.length % 2 !== 0) {\n\t\tconsole.error('renderLines: array length is not divisible by 2');\n\t\treturn;\n\t}\n\tthis._addLines(position, color, options);\n};\nAppBase.prototype.enableVr = function () {};\nObject.defineProperty(CameraComponent.prototype, 'node', {\n\tget: function () {\n\t\treturn this.entity;\n\t}\n});\nObject.defineProperty(LightComponent.prototype, 'enable', {\n\tget: function () {\n\t\treturn this.enabled;\n\t},\n\tset: function (value) {\n\t\tthis.enabled = value;\n\t}\n});\nModelComponent.prototype.setVisible = function (visible) {\n\tthis.enabled = visible;\n};\nObject.defineProperty(ModelComponent.prototype, 'aabb', {\n\tget: function () {\n\t\treturn null;\n\t},\n\tset: function (type) {}\n});\nObject.defineProperty(RenderComponent.prototype, 'aabb', {\n\tget: function () {\n\t\treturn null;\n\t},\n\tset: function (type) {}\n});\nObject.defineProperty(RigidBodyComponent.prototype, 'bodyType', {\n\tget: function () {\n\t\treturn this.type;\n\t},\n\tset: function (type) {\n\t\tthis.type = type;\n\t}\n});\nRigidBodyComponent.prototype.syncBodyToEntity = function () {\n\tthis._updateDynamic();\n};\nRigidBodyComponentSystem.prototype.setGravity = function () {\n\tif (arguments.length === 1) {\n\t\tthis.gravity.copy(arguments[0]);\n\t} else {\n\t\tthis.gravity.set(arguments[0], arguments[1], arguments[2]);\n\t}\n};\nfunction basisSetDownloadConfig(glueUrl, wasmUrl, fallbackUrl) {\n\tbasisInitialize({\n\t\tglueUrl: glueUrl,\n\t\twasmUrl: wasmUrl,\n\t\tfallbackUrl: fallbackUrl,\n\t\tlazyInit: true\n\t});\n}\nfunction prefilterCubemap(options) {}\n\nexport { BLENDMODE_CONSTANT_ALPHA, BLENDMODE_CONSTANT_COLOR, BLENDMODE_ONE_MINUS_CONSTANT_ALPHA, BLENDMODE_ONE_MINUS_CONSTANT_COLOR, ContextCreationError, ELEMENTTYPE_FLOAT32, ELEMENTTYPE_INT16, ELEMENTTYPE_INT32, ELEMENTTYPE_INT8, ELEMENTTYPE_UINT16, ELEMENTTYPE_UINT32, ELEMENTTYPE_UINT8, LINEBATCH_GIZMO, LINEBATCH_OVERLAY, LINEBATCH_WORLD, LitOptions, PIXELFORMAT_L8_A8, PIXELFORMAT_R4_G4_B4_A4, PIXELFORMAT_R5_G5_B5_A1, PIXELFORMAT_R5_G6_B5, PIXELFORMAT_R8_G8_B8, PIXELFORMAT_R8_G8_B8_A8, PhongMaterial, RIGIDBODY_ACTIVE_TAG, RIGIDBODY_CF_KINEMATIC_OBJECT, RIGIDBODY_CF_NORESPONSE_OBJECT, RIGIDBODY_CF_STATIC_OBJECT, RIGIDBODY_DISABLE_DEACTIVATION, RIGIDBODY_DISABLE_SIMULATION, RIGIDBODY_ISLAND_SLEEPING, RIGIDBODY_TYPE_DYNAMIC, RIGIDBODY_TYPE_KINEMATIC, RIGIDBODY_TYPE_STATIC, RIGIDBODY_WANTS_DEACTIVATION, UnsupportedBrowserError, anim, asset, audio, basisSetDownloadConfig, createBox, createCapsule, createCone, createCylinder, createMesh, createPlane, createSphere, createStyle, createTorus, drawFullscreenQuad, gfx, inherits, input, log, makeArray, posteffect, prefilterCubemap, programlib, scene, shape, time };\n", "import {\n EventHandlerCollection,\n getRelativePositionAndRotationRelativeToObject,\n MElement,\n TransformableElement,\n} from \"@mml-io/mml-web\";\nimport * as playcanvas from \"playcanvas\";\n\nconst mouseMovePixelsThreshold = 10;\nconst mouseMoveTimeThresholdMilliseconds = 500;\n\n/**\n * The PlayCanvasClickTrigger class is responsible for handling click events on the MML scene and raycasts into the scene to\n * determine which object was clicked and then dispatches events to those elements.\n */\nexport class PlayCanvasClickTrigger {\n private eventHandlerCollection: EventHandlerCollection = new EventHandlerCollection();\n private mouseDownTime: number | null = null;\n private mouseMoveDelta = 0;\n\n static init(\n playcanvasApp: playcanvas.AppBase,\n clickTarget: Document | HTMLElement,\n camera: playcanvas.Entity,\n ): PlayCanvasClickTrigger {\n return new PlayCanvasClickTrigger(playcanvasApp, clickTarget, camera);\n }\n\n private constructor(\n private playcanvasApp: playcanvas.AppBase,\n private clickTarget: Document | HTMLElement,\n private camera: playcanvas.Entity,\n ) {\n this.eventHandlerCollection.add(clickTarget, \"mousedown\", this.handleMouseDown.bind(this));\n this.eventHandlerCollection.add(clickTarget, \"mouseup\", this.handleMouseUp.bind(this));\n this.eventHandlerCollection.add(clickTarget, \"mousemove\", this.handleMouseMove.bind(this));\n }\n\n private handleMouseDown() {\n this.mouseDownTime = Date.now();\n this.mouseMoveDelta = 0;\n }\n\n private handleMouseUp(event: MouseEvent) {\n if (!this.mouseDownTime) {\n return;\n }\n const duration = Date.now() - this.mouseDownTime;\n this.mouseDownTime = null;\n if (\n this.mouseMoveDelta < mouseMovePixelsThreshold &&\n duration < mouseMoveTimeThresholdMilliseconds\n ) {\n this.handleClick(event);\n }\n }\n\n private handleMouseMove(event: MouseEvent) {\n if (this.mouseDownTime) {\n this.mouseMoveDelta += Math.abs(event.movementX) + Math.abs(event.movementY);\n }\n }\n\n private handleClick(event: MouseEvent) {\n if ((event.detail as any).element) {\n // Avoid infinite loop of handling click events that originated from this trigger\n return;\n }\n let x = 0;\n let y = 0;\n if (!document.pointerLockElement) {\n x = event.offsetX;\n y = event.offsetY;\n }\n\n const cameraEntity = this.camera;\n const from = cameraEntity.getPosition();\n const cameraComponent = cameraEntity.camera;\n if (!cameraComponent) {\n console.warn(\"No camera component found on the camera entity. Cannot raycast.\");\n return;\n }\n\n // The pc.Vec3 to raycast to (the click position projected onto the camera's far clip plane)\n const to = cameraComponent.screenToWorld(x, y, cameraComponent.farClip);\n\n // Raycast between the two points and return the closest hit result\n const rigidbodySystem = this.playcanvasApp.systems.rigidbody;\n if (!rigidbodySystem) {\n console.warn(\"No rigidbody system found in the PlayCanvas app. Cannot raycast.\");\n return;\n }\n const result = rigidbodySystem.raycastFirst(from, to);\n\n // If there was a hit, store the entity\n if (result) {\n const hitEntity = result.entity;\n let mElement;\n for (let entity: playcanvas.GraphNode = hitEntity; entity; entity = entity.parent) {\n mElement = MElement.getMElementFromObject(entity);\n if (mElement) {\n break;\n }\n }\n if (mElement && mElement instanceof TransformableElement && mElement.isClickable()) {\n // let's get the intersection point relative to the element origin\n\n const elementRelative = getRelativePositionAndRotationRelativeToObject(\n {\n position: result.point,\n rotation: {\n x: 0,\n y: 0,\n z: 0,\n },\n },\n mElement,\n );\n\n mElement.dispatchEvent(\n new CustomEvent(\"click\", {\n bubbles: true,\n detail: {\n position: {\n ...elementRelative.position,\n },\n },\n }),\n );\n return;\n }\n }\n }\n\n dispose() {\n this.eventHandlerCollection.clear();\n }\n}\n", "import { Audio, AudioGraphics, LoadingInstanceManager } from \"@mml-io/mml-web\";\nimport * as playcanvas from \"playcanvas\";\n\nimport { PlayCanvasGraphicsAdapter } from \"../PlayCanvasGraphicsAdapter\";\n\ntype AudioLoadedState = {\n asset: playcanvas.Asset;\n};\n\nexport class PlayCanvasAudio extends AudioGraphics {\n private soundComponent: playcanvas.SoundComponent;\n private srcLoadingInstanceManager = new LoadingInstanceManager(`${Audio.tagName}.src`);\n private latestSrcAudioPromise: Promise | null = null;\n protected loadedState: AudioLoadedState | null = null;\n private delayedStartTimer: NodeJS.Timeout | null = null;\n private delayedPauseTimer: NodeJS.Timeout | null = null;\n private static dataAudioFileCount: number = 0;\n\n constructor(private audio: Audio) {\n super(audio);\n const audioEntity = this.audio.getContainer() as playcanvas.Entity;\n this.soundComponent = audioEntity.addComponent(\"sound\", {\n positional: true,\n distanceModel: \"inverse\",\n volume: audio.props.volume,\n } as playcanvas.SoundComponent) as playcanvas.SoundComponent;\n }\n\n private getPlayCanvasApp(): playcanvas.AppBase {\n return this.audio.getScene().getGraphicsAdapter().getPlayCanvasApp();\n }\n\n setSrc(src: string | null): void {\n if (this.loadedState !== null) {\n this.soundComponent.removeSlot(\"slot\");\n this.loadedState.asset.unload();\n this.loadedState = null;\n }\n if (!src) {\n this.srcLoadingInstanceManager.abortIfLoading();\n return;\n }\n\n const contentSrc = this.audio.contentSrcToContentAddress(src);\n const srcAudioPromise = this.asyncLoadSourceAsset(\n contentSrc,\n this.getAudioContext(),\n (loaded, total) => {\n this.srcLoadingInstanceManager.setProgress(loaded / total);\n },\n );\n this.srcLoadingInstanceManager.start(this.audio.getLoadingProgressManager(), contentSrc);\n this.latestSrcAudioPromise = srcAudioPromise;\n srcAudioPromise\n .then((asset) => {\n if (this.latestSrcAudioPromise !== srcAudioPromise || !this.audio.isConnected) {\n // TODO - dispose?\n // If we've loaded a different audio since, or we're no longer connected, dispose of this one\n return;\n }\n this.latestSrcAudioPromise = null;\n this.loadedState = {\n asset,\n };\n\n const sound = asset;\n this.soundComponent.addSlot(\"slot\", {\n volume: 1,\n pitch: 1,\n asset: sound.id,\n loop: true,\n overlap: false,\n autoPlay: false,\n });\n\n const slot = this.soundComponent.slot(\"slot\");\n if (slot) {\n slot.stop();\n slot.overlap = false;\n this.syncAudioTime();\n }\n\n this.srcLoadingInstanceManager.finish();\n })\n .catch((err) => {\n console.error(\"Error loading m-audio.src\", err);\n this.srcLoadingInstanceManager.error(err);\n });\n }\n\n public setStartTime(): void {\n this.syncAudioTime();\n }\n\n public setPauseTime(): void {\n this.syncAudioTime();\n }\n\n public setLoopDuration(): void {\n this.syncAudioTime();\n }\n\n public syncAudioTime(): void {\n if (this.delayedStartTimer) {\n clearTimeout(this.delayedStartTimer);\n this.delayedStartTimer = null;\n }\n if (this.delayedPauseTimer !== null) {\n clearTimeout(this.delayedPauseTimer);\n this.delayedPauseTimer = null;\n }\n\n if (!this.audio.props.src) {\n return;\n }\n\n const slot = this.soundComponent.slot(\"slot\");\n if (slot) {\n if (!this.audio.props.enabled || this.audio.isDisabled()) {\n slot.stop();\n return;\n }\n\n if (slot.loop !== this.audio.props.loop) {\n slot.loop = this.audio.props.loop;\n }\n\n const documentTime = this.audio.getDocumentTime();\n\n if (this.audio.props.pauseTime !== null) {\n if (documentTime !== null && this.audio.props.pauseTime > documentTime) {\n // The pause time is in the future\n const delayedPauseTimer = setTimeout(() => {\n if (this.delayedPauseTimer === delayedPauseTimer) {\n this.delayedPauseTimer = null;\n }\n this.syncAudioTime();\n }, this.audio.props.pauseTime - documentTime);\n this.delayedPauseTimer = delayedPauseTimer;\n } else {\n slot.pause();\n return;\n }\n }\n\n let currentTime: number;\n if (documentTime) {\n currentTime = (documentTime - this.audio.props.startTime) / 1000;\n } else {\n currentTime = (this.audio.props.startTime ? this.audio.props.startTime : 0) / 1000;\n }\n\n // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n const asset = slot._assets.get(slot.asset)!;\n const assetDuration: number | null = asset?.resource.duration || null;\n let targetDuration: number | null = assetDuration;\n if (this.audio.props.loopDuration !== null && this.audio.props.loop) {\n const loopDuration = this.audio.props.loopDuration / 1000;\n if (assetDuration !== null && loopDuration > assetDuration) {\n asset.resource.buffer = extendAudioToDuration(\n this.getAudioContext(),\n asset.resource.buffer,\n loopDuration,\n );\n slot.pause();\n slot.duration = loopDuration;\n }\n targetDuration = loopDuration;\n }\n if (targetDuration !== null && slot.duration !== targetDuration) {\n slot.pause();\n slot.duration = targetDuration;\n }\n\n let desiredAudioTime;\n if (currentTime < 0) {\n // The audio should not start yet\n slot.pause();\n const delayedStartTimer = setTimeout(() => {\n if (this.delayedStartTimer === delayedStartTimer) {\n this.delayedStartTimer = null;\n }\n this.syncAudioTime();\n }, -currentTime * 1000);\n this.delayedStartTimer = delayedStartTimer;\n return;\n } else if (this.audio.props.loop) {\n const slotDuration = slot.duration;\n desiredAudioTime = currentTime % slotDuration;\n } else {\n desiredAudioTime = currentTime;\n }\n\n if (desiredAudioTime >= slot.duration) {\n slot.pause();\n return;\n } else {\n // playing\n }\n\n if (slot.isLoaded && (slot.isPaused || slot.isStopped)) {\n slot.play();\n }\n\n const soundInstance = slot.instances[0];\n let delta = desiredAudioTime - soundInstance.currentTime;\n if (this.audio.props.loop) {\n // Check if the delta wrapping around is smaller (i.e. the desired and current are closer together if we wrap around)\n const loopedDelta = delta - slot.duration;\n if (Math.abs(delta) > Math.abs(loopedDelta)) {\n delta = loopedDelta;\n }\n }\n\n if (Math.abs(delta) < 0.1) {\n // Do nothing - this is close enough - set the playback rate to 1\n slot.pitch = 1;\n } else if (Math.abs(delta) > 0.5) {\n slot.pitch = 1;\n slot.pause();\n soundInstance.currentTime = desiredAudioTime;\n slot.resume();\n return;\n } else {\n if (delta > 0) {\n slot.pitch = 1.02;\n } else {\n slot.pitch = 0.98;\n }\n }\n }\n }\n\n private getAudioContext(): AudioContext {\n const playcanvasApp = this.getPlayCanvasApp();\n const soundSystem = playcanvasApp.systems.sound;\n if (!soundSystem) {\n throw new Error(\"Playcanvas sound system not enabled\");\n }\n return soundSystem.context;\n }\n\n enable(): void {\n // TODO\n }\n disable(): void {\n // TODO\n }\n setLoop(): void {\n this.syncAudioTime();\n }\n setEnabled(): void {\n // TODO\n }\n setVolume(): void {\n this.soundComponent.volume = this.audio.props.volume;\n }\n setConeAngle(): void {\n // TODO\n }\n setConeFalloffAngle(): void {\n // TODO\n }\n setDebug(): void {\n // TODO\n }\n\n private async asyncLoadSourceAsset(\n url: string,\n audioContext: AudioContext,\n // TODO - report progress\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n onProgress: (loaded: number, total: number) => void,\n ): Promise {\n return new Promise((resolve, reject) => {\n if (url.startsWith(\"data:\")) {\n // Construct an AudioBuffer from the data URL\n const base64 = url.split(\",\", 2)[1];\n if (!base64) {\n reject(new Error(\"Invalid data URL\"));\n return;\n }\n let arrayBuffer;\n\n try {\n const binary = atob(base64);\n const uint8Array = new Uint8Array(binary.length);\n for (let i = 0; i < binary.length; i++) {\n uint8Array[i] = binary.charCodeAt(i);\n }\n arrayBuffer = uint8Array.buffer;\n } catch (e) {\n console.error(\"Failed to decode base64 data URL\", e);\n return;\n }\n audioContext\n .decodeAudioData(arrayBuffer)\n .then((audioBuffer) => {\n const soundComp = new playcanvas.Sound(audioBuffer);\n const asset = new playcanvas.Asset(\n \"dataAudioFile-\" + PlayCanvasAudio.dataAudioFileCount++,\n \"audio\",\n { url },\n base64,\n );\n asset.resource = soundComp;\n asset.loaded = true;\n this.getPlayCanvasApp().assets.add(asset);\n resolve(asset);\n })\n .catch((e) => {\n console.error(\"Failed to decode data URI audio data\", e);\n });\n return;\n }\n\n const asset = new playcanvas.Asset(url, \"audio\", { url });\n this.getPlayCanvasApp().assets.add(asset);\n this.getPlayCanvasApp().assets.load(asset);\n asset.ready((asset) => {\n resolve(asset);\n });\n // Listen for errors\n asset.on(\"error\", (err) => {\n console.error(\"Error loading audio asset\", err);\n reject(err);\n });\n });\n }\n\n dispose() {\n if (this.delayedPauseTimer) {\n clearTimeout(this.delayedPauseTimer);\n this.delayedPauseTimer = null;\n }\n if (this.delayedStartTimer) {\n clearTimeout(this.delayedStartTimer);\n this.delayedStartTimer = null;\n }\n const audioEntity = this.audio.getContainer() as playcanvas.Entity;\n audioEntity.removeComponent(\"sound\");\n }\n}\n\nfunction extendAudioToDuration(\n context: AudioContext,\n buffer: AudioBuffer,\n seconds: number,\n): AudioBuffer {\n const updatedBuffer = context.createBuffer(\n buffer.numberOfChannels,\n Math.ceil(seconds * buffer.sampleRate),\n buffer.sampleRate,\n );\n for (let channelNumber = 0; channelNumber < buffer.numberOfChannels; channelNumber++) {\n const channelData = buffer.getChannelData(channelNumber);\n const updatedChannelData = updatedBuffer.getChannelData(channelNumber);\n updatedChannelData.set(channelData, 0);\n }\n return updatedBuffer;\n}\n", "import { ChatProbe, ChatProbeGraphics } from \"@mml-io/mml-web\";\nimport * as playcanvas from \"playcanvas\";\n\nimport { PlayCanvasGraphicsAdapter } from \"../PlayCanvasGraphicsAdapter\";\n\nexport class PlayCanvasChatProbe extends ChatProbeGraphics {\n private entity: playcanvas.Entity | null = null;\n private debugMaterial: playcanvas.BasicMaterial | null = null;\n\n constructor(private chatProbe: ChatProbe) {\n super(chatProbe);\n this.updateDebugVisualisation();\n }\n\n public disable(): void {}\n\n public enable(): void {}\n\n public setRange(): void {\n this.updateDebugVisualisation();\n }\n\n public setDebug() {\n this.updateDebugVisualisation();\n }\n\n private clearDebugVisualisation() {\n if (this.entity) {\n this.entity.destroy();\n this.entity = null;\n }\n if (this.debugMaterial) {\n this.debugMaterial.destroy();\n this.debugMaterial = null;\n }\n }\n\n private updateDebugVisualisation() {\n if (!this.chatProbe.props.debug) {\n this.clearDebugVisualisation();\n } else {\n if (this.chatProbe.isConnected && !this.entity) {\n this.entity = new playcanvas.Entity(\n \"chat-probe-internal\",\n this.chatProbe.getScene().getGraphicsAdapter().getPlayCanvasApp(),\n );\n if (!this.debugMaterial) {\n this.debugMaterial = new playcanvas.BasicMaterial();\n this.debugMaterial.color = new playcanvas.Color(1, 1, 0);\n }\n this.entity.addComponent(\"model\", {\n type: \"sphere\",\n material: this.debugMaterial,\n });\n this.entity.model?.model.meshInstances.forEach((mi) => {\n mi.renderStyle = playcanvas.RENDERSTYLE_WIREFRAME;\n mi.castShadow = false;\n });\n\n this.chatProbe.getContainer().addChild(this.entity);\n }\n\n if (this.entity) {\n this.entity.setLocalScale(\n this.chatProbe.props.range * 2,\n this.chatProbe.props.range * 2,\n this.chatProbe.props.range * 2,\n );\n }\n }\n }\n\n public dispose() {\n this.clearDebugVisualisation();\n }\n}\n", "import { Cube, MCubeProps, MELEMENT_PROPERTY_NAME } from \"@mml-io/mml-web\";\nimport { CubeGraphics } from \"@mml-io/mml-web\";\nimport { MMLColor } from \"@mml-io/mml-web\";\nimport * as playcanvas from \"playcanvas\";\n\nimport { PlayCanvasGraphicsAdapter } from \"../PlayCanvasGraphicsAdapter\";\n\nexport class PlayCanvasCube extends CubeGraphics {\n private entity: playcanvas.Entity;\n private renderComponent: playcanvas.RenderComponent;\n private material: playcanvas.StandardMaterial = new playcanvas.StandardMaterial();\n\n constructor(private cube: Cube) {\n super(cube);\n\n /*\n The primitive must be in an internal entity to allow using setLocalScale\n without affecting children.\n */\n this.entity = new playcanvas.Entity(\n \"cube-internal\",\n cube.getScene().getGraphicsAdapter().getPlayCanvasApp(),\n );\n (this.entity as any)[MELEMENT_PROPERTY_NAME] = cube;\n this.renderComponent = this.entity.addComponent(\"render\", {\n type: \"box\",\n material: this.material,\n }) as playcanvas.RenderComponent;\n this.entity.addComponent(\"collision\", {\n type: \"box\",\n halfExtents: new playcanvas.Vec3(0.5, 0.5, 0.5),\n });\n cube.getContainer().addChild(this.entity);\n }\n\n disable(): void {}\n\n enable(): void {}\n\n getCollisionElement(): playcanvas.Entity {\n return this.entity;\n }\n\n setColor(color: MMLColor): void {\n this.material.diffuse.set(color.r, color.g, color.b);\n this.material.metalness = 0;\n this.material.useMetalness = true;\n this.material.update();\n }\n\n private updateSize(mCubeProps: MCubeProps): void {\n this.entity.setLocalScale(mCubeProps.width, mCubeProps.height, mCubeProps.depth);\n if (this.entity.collision) {\n this.entity.collision.halfExtents.set(\n mCubeProps.width / 2,\n mCubeProps.height / 2,\n mCubeProps.depth / 2,\n );\n // @ts-expect-error - accessing onSetHalfExtents private method\n this.entity.collision.onSetHalfExtents();\n }\n }\n\n setWidth(width: number, mCubeProps: MCubeProps): void {\n this.updateSize(mCubeProps);\n }\n\n setHeight(height: number, mCubeProps: MCubeProps): void {\n this.updateSize(mCubeProps);\n }\n\n setDepth(depth: number, mCubeProps: MCubeProps): void {\n this.updateSize(mCubeProps);\n }\n\n setCastShadows(castShadows: boolean): void {\n this.renderComponent.castShadows = castShadows;\n }\n\n setOpacity(opacity: number): void {\n if (opacity === 1) {\n this.material.blendType = playcanvas.BLEND_NONE;\n } else {\n this.material.blendType = playcanvas.BLEND_NORMAL;\n }\n this.material.opacity = opacity;\n this.material.update();\n }\n\n dispose() {\n this.entity.destroy();\n }\n}\n", "import { Cylinder, MCylinderProps, MELEMENT_PROPERTY_NAME } from \"@mml-io/mml-web\";\nimport { CylinderGraphics } from \"@mml-io/mml-web\";\nimport { MMLColor } from \"@mml-io/mml-web\";\nimport * as playcanvas from \"playcanvas\";\n\nimport { PlayCanvasGraphicsAdapter } from \"../PlayCanvasGraphicsAdapter\";\n\nexport class PlayCanvasCylinder extends CylinderGraphics {\n private entity: playcanvas.Entity;\n private renderComponent: playcanvas.RenderComponent;\n private material: playcanvas.StandardMaterial = new playcanvas.StandardMaterial();\n\n constructor(private cylinder: Cylinder) {\n super(cylinder);\n\n /*\n The primitive must be in an internal entity to allow using setLocalScale\n without affecting children.\n */\n this.entity = new playcanvas.Entity(\n \"cylinder-internal\",\n cylinder.getScene().getGraphicsAdapter().getPlayCanvasApp(),\n );\n (this.entity as any)[MELEMENT_PROPERTY_NAME] = cylinder;\n this.renderComponent = this.entity.addComponent(\"render\", {\n type: \"cylinder\",\n material: this.material,\n }) as playcanvas.RenderComponent;\n const collisionComponent = this.entity.addComponent(\"collision\", {\n type: \"cylinder\",\n }) as playcanvas.CollisionComponent;\n collisionComponent.radius = 0.5;\n collisionComponent.height = 1;\n cylinder.getContainer().addChild(this.entity);\n }\n\n disable(): void {}\n\n enable(): void {}\n\n getCollisionElement(): playcanvas.Entity {\n return this.entity;\n }\n\n setColor(color: MMLColor): void {\n this.material.diffuse.set(color.r, color.g, color.b);\n this.material.metalness = 0;\n this.material.useMetalness = true;\n this.material.update();\n }\n\n private updateSize(mCylinderProps: MCylinderProps): void {\n this.entity.setLocalScale(\n mCylinderProps.radius * 2,\n mCylinderProps.height,\n mCylinderProps.radius * 2,\n );\n if (this.entity.collision) {\n this.entity.collision.radius = mCylinderProps.radius;\n this.entity.collision.height = mCylinderProps.height;\n // @ts-expect-error - accessing onSetHalfExtents private method\n this.entity.collision.onSetHalfExtents();\n }\n }\n\n setRadius(radius: number, mCylinderProps: MCylinderProps): void {\n this.updateSize(mCylinderProps);\n }\n\n setHeight(height: number, mCylinderProps: MCylinderProps): void {\n this.updateSize(mCylinderProps);\n }\n\n setCastShadows(castShadows: boolean): void {\n this.renderComponent.castShadows = castShadows;\n }\n\n setOpacity(opacity: number): void {\n if (opacity === 1) {\n this.material.blendType = playcanvas.BLEND_NONE;\n } else {\n this.material.blendType = playcanvas.BLEND_NORMAL;\n }\n this.material.opacity = opacity;\n this.material.update();\n }\n\n dispose() {\n this.entity.destroy();\n }\n}\n", "import { DebugHelper, DebugHelperGraphics } from \"@mml-io/mml-web\";\nimport * as playcanvas from \"playcanvas\";\n\nimport { createPlayCanvasDebugBoundingBox } from \"../debug-bounding-box/PlayCanvasDebugBoundingBox\";\nimport { PlayCanvasGraphicsAdapter } from \"../PlayCanvasGraphicsAdapter\";\n\nexport class PlayCanvasDebugHelper extends DebugHelperGraphics {\n private debugAxes: playcanvas.Entity | null = null;\n\n constructor(private debugHelper: DebugHelper) {\n super(debugHelper);\n\n const graphicsAdapter = this.debugHelper.element.getScene().getGraphicsAdapter();\n\n const playcanvasApp = graphicsAdapter.getPlayCanvasApp();\n\n const playcanvasEntity: playcanvas.Entity = this.debugHelper.getContainer();\n this.debugAxes = new playcanvas.Entity(\"axes\", playcanvasApp);\n playcanvasEntity.addChild(this.debugAxes);\n\n const xMaterial = new playcanvas.BasicMaterial();\n xMaterial.color = new playcanvas.Color(1, 0, 0);\n const xAxis = createPlayCanvasDebugBoundingBox(graphicsAdapter, xMaterial);\n xAxis.setLocalScale(0.5, 0, 0);\n xAxis.setLocalPosition(0.25, 0, 0);\n this.debugAxes.addChild(xAxis);\n\n const yMaterial = new playcanvas.BasicMaterial();\n yMaterial.color = new playcanvas.Color(0, 1, 0);\n const yAxis = createPlayCanvasDebugBoundingBox(graphicsAdapter, yMaterial);\n yAxis.setLocalScale(0, 0.5, 0);\n yAxis.setLocalPosition(0, 0.25, 0);\n this.debugAxes.addChild(yAxis);\n\n const zMaterial = new playcanvas.BasicMaterial();\n zMaterial.color = new playcanvas.Color(0, 0, 1);\n const zAxis = createPlayCanvasDebugBoundingBox(graphicsAdapter, zMaterial);\n zAxis.setLocalScale(0, 0, 0.5);\n zAxis.setLocalPosition(0, 0, 0.25);\n this.debugAxes.addChild(zAxis);\n }\n\n dispose() {\n if (this.debugAxes) {\n this.debugHelper.getContainer().removeChild(this.debugAxes);\n this.debugAxes.destroy();\n }\n this.debugAxes = null;\n }\n}\n", "import * as playcanvas from \"playcanvas\";\n\nimport { PlayCanvasGraphicsAdapter } from \"../PlayCanvasGraphicsAdapter\";\n\nexport function createPlayCanvasDebugBoundingBox(\n graphicsAdapter: PlayCanvasGraphicsAdapter,\n material: playcanvas.Material,\n): playcanvas.Entity {\n const entity = new playcanvas.Entity(\"bounding-box\", graphicsAdapter.getPlayCanvasApp());\n entity.addComponent(\"model\", {\n type: \"box\",\n material,\n });\n entity.model?.model.meshInstances.forEach((mi) => {\n mi.renderStyle = playcanvas.RENDERSTYLE_WIREFRAME;\n mi.castShadow = false;\n });\n return entity;\n}\n", "import { Frame, FrameGraphics } from \"@mml-io/mml-web\";\nimport * as playcanvas from \"playcanvas\";\n\nimport { createPlayCanvasDebugBoundingBox } from \"../debug-bounding-box/PlayCanvasDebugBoundingBox\";\nimport { PlayCanvasGraphicsAdapter } from \"../PlayCanvasGraphicsAdapter\";\n\nfunction setEntityToBoundingBox(\n debugBoxConstraintMesh: playcanvas.Entity,\n minX: number,\n maxX: number,\n minY: number,\n maxY: number,\n minZ: number,\n maxZ: number,\n) {\n debugBoxConstraintMesh.setLocalPosition((maxX + minX) / 2, (maxY + minY) / 2, (maxZ + minZ) / 2);\n debugBoxConstraintMesh.setLocalScale(-(maxX - minX), maxY - minY, maxZ - minZ);\n}\n\nexport class PlayCanvasFrame extends FrameGraphics {\n private debugMaterial: playcanvas.BasicMaterial | null = null;\n private loadRangeMaterial: playcanvas.BasicMaterial | null = null;\n private unloadRangeMaterial: playcanvas.BasicMaterial | null = null;\n\n private debugMeshes: {\n debugBoxConstraintMesh: playcanvas.Entity;\n debugBoxLoadRangeMesh: playcanvas.Entity;\n debugBoxUnloadRangeMesh: playcanvas.Entity;\n } | null = null;\n\n constructor(private frame: Frame) {\n super(frame);\n this.updateDebugVisualisation();\n }\n\n setSrc(): void {\n // no-op\n }\n\n public setDebug(): void {\n this.updateDebugVisualisation();\n }\n public setLoadRange(): void {\n this.updateDebugVisualisation();\n }\n public setUnloadRange(): void {\n this.updateDebugVisualisation();\n }\n public setMinX(): void {\n this.updateDebugVisualisation();\n }\n public setMaxX(): void {\n this.updateDebugVisualisation();\n }\n public setMinY(): void {\n this.updateDebugVisualisation();\n }\n public setMaxY(): void {\n this.updateDebugVisualisation();\n }\n public setMinZ(): void {\n this.updateDebugVisualisation();\n }\n public setMaxZ(): void {\n this.updateDebugVisualisation();\n }\n\n disable(): void {}\n\n enable(): void {}\n\n dispose() {\n this.clearDebugVisualisation();\n }\n\n private clearDebugVisualisation() {\n if (this.debugMeshes) {\n this.debugMeshes.debugBoxConstraintMesh.destroy();\n this.debugMeshes.debugBoxLoadRangeMesh.destroy();\n this.debugMeshes.debugBoxUnloadRangeMesh.destroy();\n this.debugMeshes = null;\n }\n if (this.debugMaterial) {\n this.debugMaterial.destroy();\n this.debugMaterial = null;\n }\n if (this.loadRangeMaterial) {\n this.loadRangeMaterial.destroy();\n this.loadRangeMaterial = null;\n }\n if (this.unloadRangeMaterial) {\n this.unloadRangeMaterial.destroy();\n this.unloadRangeMaterial = null;\n }\n }\n\n private updateDebugVisualisation() {\n if (!this.frame.props.debug) {\n this.clearDebugVisualisation();\n } else {\n if (!this.frame.isConnected) {\n return;\n }\n if (!this.debugMeshes) {\n if (!this.debugMaterial) {\n this.debugMaterial = new playcanvas.BasicMaterial();\n this.debugMaterial.color = new playcanvas.Color(1, 0, 0);\n }\n if (!this.loadRangeMaterial) {\n this.loadRangeMaterial = new playcanvas.BasicMaterial();\n this.loadRangeMaterial.color = new playcanvas.Color(0, 1, 0);\n }\n if (!this.unloadRangeMaterial) {\n this.unloadRangeMaterial = new playcanvas.BasicMaterial();\n this.unloadRangeMaterial.color = new playcanvas.Color(0, 0, 1);\n }\n const graphicsAdapter = this.frame.getScene().getGraphicsAdapter();\n this.debugMeshes = {\n debugBoxConstraintMesh: createPlayCanvasDebugBoundingBox(\n graphicsAdapter,\n this.debugMaterial,\n ),\n debugBoxLoadRangeMesh: createPlayCanvasDebugBoundingBox(\n graphicsAdapter,\n this.loadRangeMaterial,\n ),\n debugBoxUnloadRangeMesh: createPlayCanvasDebugBoundingBox(\n graphicsAdapter,\n this.unloadRangeMaterial,\n ),\n };\n this.frame.getContainer().addChild(this.debugMeshes.debugBoxConstraintMesh);\n this.frame.getContainer().addChild(this.debugMeshes.debugBoxLoadRangeMesh);\n this.frame.getContainer().addChild(this.debugMeshes.debugBoxUnloadRangeMesh);\n }\n\n let boxBounds = this.frame.getDefinedBoxBounds();\n if (!boxBounds) {\n boxBounds = [0, 0, 0, 0, 0, 0];\n }\n\n const [minX, maxX, minY, maxY, minZ, maxZ] = boxBounds;\n this.debugMeshes.debugBoxConstraintMesh.enabled = true;\n\n setEntityToBoundingBox(\n this.debugMeshes.debugBoxConstraintMesh,\n minX,\n maxX,\n minY,\n maxY,\n minZ,\n maxZ,\n );\n\n if (this.frame.props.loadRange === null) {\n this.debugMeshes.debugBoxLoadRangeMesh.enabled = false;\n this.debugMeshes.debugBoxUnloadRangeMesh.enabled = false;\n } else {\n this.debugMeshes.debugBoxLoadRangeMesh.enabled = true;\n this.debugMeshes.debugBoxUnloadRangeMesh.enabled = true;\n\n setEntityToBoundingBox(\n this.debugMeshes.debugBoxLoadRangeMesh,\n minX - this.frame.props.loadRange,\n maxX + this.frame.props.loadRange,\n minY - this.frame.props.loadRange,\n maxY + this.frame.props.loadRange,\n minZ - this.frame.props.loadRange,\n maxZ + this.frame.props.loadRange,\n );\n\n setEntityToBoundingBox(\n this.debugMeshes.debugBoxUnloadRangeMesh,\n minX - this.frame.props.loadRange - this.frame.props.unloadRange,\n maxX + this.frame.props.loadRange + this.frame.props.unloadRange,\n minY - this.frame.props.loadRange - this.frame.props.unloadRange,\n maxY + this.frame.props.loadRange + this.frame.props.unloadRange,\n minZ - this.frame.props.loadRange - this.frame.props.unloadRange,\n maxZ + this.frame.props.loadRange + this.frame.props.unloadRange,\n );\n }\n }\n }\n}\n", "import {\n calculateContentSize,\n Image,\n ImageGraphics,\n LoadingInstanceManager,\n MELEMENT_PROPERTY_NAME,\n} from \"@mml-io/mml-web\";\nimport * as playcanvas from \"playcanvas\";\n\nimport { createPlaneModel } from \"../plane/plane\";\nimport { PlayCanvasGraphicsAdapter } from \"../PlayCanvasGraphicsAdapter\";\n\ntype ImageLoadedState = {\n asset: playcanvas.Asset;\n};\n\nexport class PlayCanvasImage extends ImageGraphics {\n private srcLoadingInstanceManager = new LoadingInstanceManager(`${Image.tagName}.src`);\n private latestSrcImagePromise: Promise | null = null;\n private entity: playcanvas.Entity;\n\n private internalEntity: playcanvas.Entity;\n private modelComponent: playcanvas.ModelComponent;\n private material: playcanvas.StandardMaterial = new playcanvas.StandardMaterial();\n protected loadedState: ImageLoadedState | null = null;\n constructor(\n private image: Image,\n private updateMeshCallback: () => void,\n ) {\n super(image, updateMeshCallback);\n\n this.entity = image.getContainer() as playcanvas.Entity;\n\n /*\n The primitive must be in an internal entity to allow using setLocalScale\n without affecting children.\n */\n this.internalEntity = new playcanvas.Entity(\n \"image-internal\",\n image.getScene().getGraphicsAdapter().getPlayCanvasApp(),\n );\n (this.internalEntity as any)[MELEMENT_PROPERTY_NAME] = image;\n\n const { model } = createPlaneModel(this.getPlayCanvasApp(), this.material);\n this.modelComponent = this.internalEntity.addComponent(\n \"model\",\n {},\n ) as playcanvas.ModelComponent;\n this.modelComponent.model = model;\n\n // Use the collision component of the element's entity\n this.entity.addComponent(\"collision\", {\n type: \"box\",\n halfExtents: new playcanvas.Vec3(0.5, 0, 0.5),\n });\n this.entity.addChild(this.internalEntity);\n }\n\n disable(): void {}\n\n enable(): void {}\n\n getWidthAndHeight(): { width: number; height: number } {\n return {\n width: this.internalEntity.getLocalScale().x,\n height: this.internalEntity.getLocalScale().y,\n };\n }\n\n getCollisionElement(): playcanvas.Entity {\n return this.entity;\n }\n\n private getPlayCanvasApp(): playcanvas.AppBase {\n return this.image.getScene().getGraphicsAdapter().getPlayCanvasApp();\n }\n\n private updateWidthAndHeight() {\n const loadedImage = this.loadedState?.asset.resource;\n\n const { width, height } = calculateContentSize({\n content: loadedImage ? { width: loadedImage.width, height: loadedImage.height } : undefined,\n width: this.image.props.width,\n height: this.image.props.height,\n });\n\n // Update the size of the visual representation\n this.internalEntity.setLocalScale(width, height, 1);\n\n // Update the collision shape\n if (this.entity.collision) {\n this.entity.collision.halfExtents.set(width / 2, height / 2, 0);\n // @ts-expect-error - accessing onSetHalfExtents private method\n this.entity.collision.onSetHalfExtents();\n }\n\n this.updateMeshCallback();\n }\n\n setWidth(): void {\n this.updateWidthAndHeight();\n }\n\n setHeight(): void {\n this.updateWidthAndHeight();\n }\n\n private clearImage() {\n if (this.material) {\n this.material.diffuseMap = null;\n this.material.opacityMap = null;\n this.material.emissiveMap = null;\n this.material.update();\n }\n this.updateWidthAndHeight();\n }\n\n public setSrc(src: string | null): void {\n if (this.loadedState !== null) {\n this.loadedState.asset.unload();\n this.loadedState = null;\n }\n if (!src) {\n this.clearImage();\n this.srcLoadingInstanceManager.abortIfLoading();\n return;\n }\n\n const contentSrc = this.image.contentSrcToContentAddress(src);\n const srcImagePromise = this.asyncLoadSourceAsset(contentSrc, (loaded, total) => {\n this.srcLoadingInstanceManager.setProgress(loaded / total);\n });\n this.srcLoadingInstanceManager.start(this.image.getLoadingProgressManager(), contentSrc);\n this.latestSrcImagePromise = srcImagePromise;\n srcImagePromise\n .then((asset) => {\n if (this.latestSrcImagePromise !== srcImagePromise || !this.image.isConnected) {\n // TODO\n // If we've loaded a different image since, or we're no longer connected, dispose of this one\n return;\n }\n this.latestSrcImagePromise = null;\n this.loadedState = {\n asset,\n };\n\n const texture = asset.resource;\n texture.premultiplyAlpha = true;\n this.material.diffuseMap = texture;\n this.material.blendType = playcanvas.BLEND_NORMAL;\n this.material.opacityMap = texture;\n this.material.update();\n this.updateWidthAndHeight();\n this.updateMaterialEmissiveIntensity();\n this.srcLoadingInstanceManager.finish();\n })\n .catch((err) => {\n console.error(\"Error loading m-image.src\", err);\n this.clearImage();\n this.srcLoadingInstanceManager.error(err);\n });\n }\n\n setCastShadows(castShadows: boolean): void {\n this.modelComponent.castShadows = castShadows;\n }\n\n setOpacity(opacity: number): void {\n if (opacity === 1) {\n this.material.blendType = playcanvas.BLEND_NONE;\n } else {\n this.material.blendType = playcanvas.BLEND_NORMAL;\n }\n this.material.opacity = opacity;\n this.material.update();\n }\n\n setEmissive(): void {\n this.updateMaterialEmissiveIntensity();\n }\n\n private updateMaterialEmissiveIntensity() {\n if (this.image.props.emissive) {\n this.material.emissiveMap = this.material.diffuseMap;\n this.material.emissiveIntensity = this.image.props.emissive;\n } else {\n this.material.emissiveMap = null;\n this.material.emissiveIntensity = 0;\n }\n this.material.update();\n }\n\n private async asyncLoadSourceAsset(\n url: string,\n // TODO - report progress\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n onProgress: (loaded: number, total: number) => void,\n ): Promise {\n return new Promise((resolve, reject) => {\n const asset = new playcanvas.Asset(url, \"texture\", { url });\n this.getPlayCanvasApp().assets.add(asset);\n this.getPlayCanvasApp().assets.load(asset);\n asset.ready((asset) => {\n resolve(asset);\n });\n asset.on(\"error\", (err) => {\n reject(err);\n });\n });\n }\n\n dispose() {\n if (this.loadedState) {\n this.loadedState.asset.unload();\n this.loadedState = null;\n }\n this.internalEntity.destroy();\n }\n}\n", "import * as playcanvas from \"playcanvas\";\n\nexport function createPlaneMesh(app: playcanvas.AppBase): playcanvas.Mesh {\n const vertices = [\n // First triangle\n // bottom left\n -0.5, -0.5, 0,\n // bottom right\n 0.5, -0.5, 0,\n // top left\n -0.5, 0.5, 0,\n\n // Second triangle\n // bottom right\n 0.5, -0.5, 0,\n // top right\n 0.5, 0.5, 0,\n // top left\n -0.5, 0.5, 0,\n\n // First triangle\n // top left\n -0.5, 0.5, 0,\n // bottom right\n 0.5, -0.5, 0,\n // bottom left\n -0.5, -0.5, 0,\n\n // Second triangle\n // top left\n -0.5, 0.5, 0,\n // top right\n 0.5, 0.5, 0,\n // bottom right\n 0.5, -0.5, 0,\n ];\n\n const uvs = [\n // First triangle\n // bottom left\n 0, 1,\n // bottom right\n 1, 1,\n // top left\n 0, 0,\n\n // Second triangle\n // bottom right\n 1, 1,\n // top right\n 1, 0,\n // top left\n 0, 0,\n\n // First triangle\n // top left\n 0, 0,\n // bottom right\n 1, 1,\n // bottom left\n 0, 1,\n\n // Second triangle\n // top left\n 0, 0,\n // top right\n 1, 0,\n // bottom right\n 1, 1,\n ];\n\n const normals = Array.from({ length: vertices.length / 3 }).flatMap((value, index) => {\n return index < 6 ? [0, 0, 1] : [0, 0, -1];\n });\n\n const mesh = new playcanvas.Mesh(app.graphicsDevice);\n mesh.setPositions(vertices);\n mesh.setUvs(0, uvs);\n mesh.setNormals(normals);\n mesh.update();\n return mesh;\n}\n\nexport function createPlaneModel(app: playcanvas.AppBase, material: playcanvas.StandardMaterial) {\n const mesh = createPlaneMesh(app);\n const rootNode = new playcanvas.GraphNode();\n const meshInstance = new playcanvas.MeshInstance(mesh, material, rootNode);\n meshInstance.renderStyle = playcanvas.RENDERSTYLE_SOLID;\n const model = new playcanvas.Model();\n model.graph = rootNode;\n model.meshInstances.push(meshInstance);\n return { model, meshInstance };\n}\n", "import { Interaction } from \"@mml-io/mml-web\";\nimport { InteractionGraphics } from \"@mml-io/mml-web\";\nimport * as playcanvas from \"playcanvas\";\n\nimport { PlayCanvasGraphicsAdapter } from \"../PlayCanvasGraphicsAdapter\";\n\nexport class PlayCanvasInteraction extends InteractionGraphics {\n private entity: playcanvas.Entity | null = null;\n private debugMaterial: playcanvas.BasicMaterial | null = null;\n\n constructor(private positionProbe: Interaction) {\n super(positionProbe);\n this.updateDebugVisualisation();\n }\n\n disable(): void {}\n\n enable(): void {}\n\n public setRange(): void {\n this.updateDebugVisualisation();\n }\n\n public setInFocus(): void {\n // no-op\n }\n\n public setLineOfSight(): void {\n // no-op\n }\n\n public setPriority(): void {\n // no-op\n }\n\n public setPrompt(): void {\n // no-op\n }\n\n public setDebug() {\n this.updateDebugVisualisation();\n }\n\n private clearDebugVisualisation() {\n if (this.entity) {\n this.entity.destroy();\n this.entity = null;\n }\n if (this.debugMaterial) {\n this.debugMaterial.destroy();\n this.debugMaterial = null;\n }\n }\n\n private updateDebugVisualisation() {\n if (!this.positionProbe.props.debug) {\n this.clearDebugVisualisation();\n } else {\n if (this.positionProbe.isConnected && !this.entity) {\n this.entity = new playcanvas.Entity(\n \"interaction-internal\",\n this.positionProbe.getScene().getGraphicsAdapter().getPlayCanvasApp(),\n );\n if (!this.debugMaterial) {\n this.debugMaterial = new playcanvas.BasicMaterial();\n this.debugMaterial.color = new playcanvas.Color(0, 1, 0);\n }\n this.entity.addComponent(\"model\", {\n type: \"sphere\",\n material: this.debugMaterial,\n });\n this.entity.model?.model.meshInstances.forEach((mi) => {\n mi.renderStyle = playcanvas.RENDERSTYLE_WIREFRAME;\n mi.castShadow = false;\n });\n\n this.positionProbe.getContainer().addChild(this.entity);\n }\n\n if (this.entity) {\n this.entity.setLocalScale(\n this.positionProbe.props.range * 2,\n this.positionProbe.props.range * 2,\n this.positionProbe.props.range * 2,\n );\n }\n }\n }\n\n dispose() {\n this.clearDebugVisualisation();\n }\n}\n", "import {\n CanvasText,\n Label,\n LabelGraphics,\n MELEMENT_PROPERTY_NAME,\n MLabelProps,\n} from \"@mml-io/mml-web\";\nimport * as playcanvas from \"playcanvas\";\n\nimport { PlayCanvasGraphicsAdapter } from \"../PlayCanvasGraphicsAdapter\";\n\nexport class PlayCanvasLabel extends LabelGraphics {\n private entity: playcanvas.Entity;\n private renderComponent: playcanvas.RenderComponent;\n private material: playcanvas.StandardMaterial = new playcanvas.StandardMaterial();\n private canvasText: CanvasText = new CanvasText();\n\n constructor(private label: Label) {\n super(label);\n\n /*\n The primitive must be in an internal entity to allow using setLocalScale\n without affecting children.\n */\n this.entity = new playcanvas.Entity(\n \"label-internal\",\n label.getScene().getGraphicsAdapter().getPlayCanvasApp(),\n );\n (this.entity as any)[MELEMENT_PROPERTY_NAME] = label;\n this.renderComponent = this.entity.addComponent(\"render\", {\n type: \"plane\",\n material: this.material,\n castShadows: this.label.props.castShadows,\n }) as playcanvas.RenderComponent;\n this.entity.rotate(90, 0, 0);\n this.entity.addComponent(\"collision\", {\n type: \"box\",\n halfExtents: new playcanvas.Vec3(0.5, 0, 0.5),\n });\n label.getContainer().addChild(this.entity);\n }\n\n disable(): void {}\n\n enable(): void {}\n\n getCollisionElement(): playcanvas.Entity {\n return this.entity;\n }\n\n private updateSize(mLabelProps: MLabelProps): void {\n this.entity.setLocalScale(mLabelProps.width, 1, mLabelProps.height);\n if (this.entity.collision) {\n this.entity.collision.halfExtents.set(mLabelProps.width / 2, 0, mLabelProps.height / 2);\n // @ts-expect-error - accessing onSetHalfExtents private method\n this.entity.collision.onSetHalfExtents();\n }\n }\n\n public setWidth(width: number, mLabelProps: MLabelProps): void {\n this.updateSize(mLabelProps);\n this.redrawText();\n }\n\n public setHeight(height: number, mLabelProps: MLabelProps): void {\n this.updateSize(mLabelProps);\n this.redrawText();\n }\n public setContent(): void {\n this.redrawText();\n }\n public setAlignment(): void {\n this.redrawText();\n }\n public setFontSize(): void {\n this.redrawText();\n }\n public setPadding(): void {\n this.redrawText();\n }\n public setColor(): void {\n this.redrawText();\n }\n public setFontColor(): void {\n this.redrawText();\n }\n\n public setEmissive(): void {\n this.updateMaterialEmissiveIntensity();\n }\n\n private updateMaterialEmissiveIntensity() {\n if (this.label.props.emissive) {\n this.material.emissiveMap = this.material.diffuseMap;\n this.material.emissiveIntensity = this.label.props.emissive;\n } else {\n this.material.emissiveMap = null;\n this.material.emissiveIntensity = 0;\n }\n this.material.update();\n }\n\n private redrawText() {\n if (!this.material) {\n return;\n }\n const canvas = this.canvasText.renderText(this.label.props.content, {\n bold: true,\n fontSize: this.label.props.fontSize * 2,\n paddingPx: this.label.props.padding,\n textColorRGB255A1: {\n r: this.label.props.fontColor.r * 255,\n g: this.label.props.fontColor.g * 255,\n b: this.label.props.fontColor.b * 255,\n a: this.label.props.fontColor.a ?? 1,\n },\n backgroundColorRGB255A1: {\n r: this.label.props.color.r * 255,\n g: this.label.props.color.g * 255,\n b: this.label.props.color.b * 255,\n a: this.label.props.color.a ?? 1,\n },\n dimensions: {\n width: this.label.props.width * 200,\n height: this.label.props.height * 200,\n },\n alignment: this.label.props.alignment,\n });\n\n const texture = new playcanvas.Texture(\n this.label.getScene().getGraphicsAdapter().getPlayCanvasApp().graphicsDevice,\n {\n width: canvas.width,\n height: canvas.height,\n },\n );\n texture.setSource(canvas);\n this.material.diffuseMap = texture;\n if ((this.label.props.color.a ?? 1) < 1) {\n this.material.blendType = playcanvas.BLEND_NORMAL;\n this.material.opacityMap = texture;\n } else {\n this.material.blendType = playcanvas.BLEND_NONE;\n this.material.opacityMap = null;\n }\n this.material.update();\n this.updateMaterialEmissiveIntensity();\n texture.destroy();\n }\n\n setCastShadows(castShadows: boolean): void {\n this.renderComponent.castShadows = castShadows;\n }\n\n dispose() {\n this.entity.destroy();\n }\n}\n", "import { Light } from \"@mml-io/mml-web\";\nimport { LightGraphics } from \"@mml-io/mml-web\";\nimport { MMLColor } from \"@mml-io/mml-web\";\nimport * as playcanvas from \"playcanvas\";\n\nimport { PlayCanvasGraphicsAdapter } from \"../PlayCanvasGraphicsAdapter\";\n\nconst lightIntensityFactor = 1 / 100;\nconst lightLuminanceFactor = 4000;\n\nexport class PlayCanvasLight extends LightGraphics {\n private lightComponent: playcanvas.LightComponent;\n\n constructor(private light: Light) {\n super(light);\n this.createLight();\n }\n\n private createLight() {\n const lightEntity = this.light.getContainer() as playcanvas.Entity;\n if (this.lightComponent) {\n lightEntity.removeComponent(\"light\");\n }\n\n const { r, g, b } = this.light.props.color;\n\n if (this.light.props.type === \"spotlight\") {\n this.lightComponent = lightEntity.addComponent(\"light\", {\n type: \"spot\",\n luminance: this.light.props.intensity * lightLuminanceFactor,\n intensity: this.light.props.intensity * lightIntensityFactor,\n castShadows: this.light.props.castShadows,\n color: new playcanvas.Color(r, g, b),\n shadowBias: 0.001,\n normalOffsetBias: 0.001,\n shape: playcanvas.LIGHTSHAPE_DISK,\n innerConeAngle: this.light.props.angleDeg,\n outerConeAngle: this.light.props.angleDeg,\n range: this.light.props.distance ?? 100,\n falloffMode: playcanvas.LIGHTFALLOFF_INVERSESQUARED,\n enabled: this.light.props.enabled,\n } as playcanvas.LightComponent) as playcanvas.LightComponent;\n } else {\n this.lightComponent = lightEntity.addComponent(\"light\", {\n type: \"point\",\n luminance: this.light.props.intensity * lightLuminanceFactor,\n intensity: this.light.props.intensity * lightIntensityFactor,\n castShadows: this.light.props.castShadows,\n color: new playcanvas.Color(r, g, b),\n shadowBias: 0.001,\n normalOffsetBias: 0.001,\n range: this.light.props.distance ?? 100,\n falloffMode: playcanvas.LIGHTFALLOFF_INVERSESQUARED,\n enabled: this.light.props.enabled,\n } as playcanvas.LightComponent) as playcanvas.LightComponent;\n }\n }\n\n disable(): void {}\n\n enable(): void {}\n\n setEnabled(enabled: boolean): void {\n this.lightComponent.enabled = enabled;\n }\n\n setCastShadows(castShadows: boolean) {\n this.lightComponent.castShadows = castShadows;\n this.lightComponent.refreshProperties();\n }\n\n setAngle(angle: number) {\n if (this.lightComponent.type !== \"spot\") {\n return;\n }\n this.lightComponent.innerConeAngle = angle;\n this.lightComponent.outerConeAngle = angle;\n this.lightComponent.refreshProperties();\n }\n\n setIntensity(intensity: number) {\n this.lightComponent.luminance = intensity * lightLuminanceFactor;\n this.lightComponent.intensity = intensity * lightIntensityFactor;\n this.lightComponent.refreshProperties();\n }\n\n setDistance(distance: number | null) {\n this.lightComponent.range = distance ?? 100;\n this.lightComponent.refreshProperties();\n }\n\n setType(): void {\n this.createLight();\n }\n\n setDebug(): void {\n // TODO\n }\n\n setColor(color: MMLColor): void {\n this.lightComponent.color.set(color.r, color.g, color.b);\n this.lightComponent.refreshProperties();\n }\n\n dispose() {\n const lightEntity = this.light.getContainer() as playcanvas.Entity;\n lightEntity.removeComponent(\"light\");\n }\n}\n", "import { Link } from \"@mml-io/mml-web\";\nimport { LinkGraphics } from \"@mml-io/mml-web\";\n\nimport { PlayCanvasGraphicsAdapter } from \"../PlayCanvasGraphicsAdapter\";\n\nexport class PlayCanvasLink extends LinkGraphics {\n constructor(private link: Link) {\n super(link);\n }\n\n disable(): void {}\n\n enable(): void {}\n\n setHref(): void {\n // no-op\n }\n\n setTarget(): void {\n // no-op\n }\n\n dispose() {}\n}\n", "import { MElement, MELEMENT_PROPERTY_NAME } from \"@mml-io/mml-web\";\nimport { MElementGraphics } from \"@mml-io/mml-web\";\nimport * as playcanvas from \"playcanvas\";\n\nimport { PlayCanvasGraphicsAdapter } from \"../PlayCanvasGraphicsAdapter\";\n\nexport class PlayCanvasMElement extends MElementGraphics {\n protected container: playcanvas.Entity;\n private currentParentContainer: playcanvas.Entity | null = null;\n\n constructor(private element: MElement) {\n super(element);\n this.container = new playcanvas.Entity(\n element.constructor.name,\n element.getScene().getGraphicsAdapter().getPlayCanvasApp(),\n );\n (this.container as any)[MELEMENT_PROPERTY_NAME] = element;\n\n if (this.currentParentContainer !== null) {\n throw new Error(\"Already connected to a parent\");\n }\n\n const mElementParent = this.element.getMElementParent();\n if (mElementParent) {\n this.currentParentContainer = mElementParent.getContainer();\n this.currentParentContainer.addChild(this.container);\n return;\n }\n\n // If none of the ancestors are MElements then this element may be directly connected to the body (without a wrapper).\n // Attempt to use a global scene that has been configured to attach this element to.\n const scene = this.element.getScene();\n this.currentParentContainer = scene.getRootContainer();\n this.currentParentContainer.addChild(this.container);\n }\n\n public getContainer(): playcanvas.Entity {\n return this.container;\n }\n\n public dispose() {\n if (this.currentParentContainer === null) {\n throw new Error(\"Was not connected to a parent\");\n }\n\n this.currentParentContainer.removeChild(this.container);\n this.currentParentContainer = null;\n\n this.container.destroy();\n }\n}\n", "import {\n IVect3,\n LoadingInstanceManager,\n MElement,\n Model,\n ModelGraphics,\n TransformableElement,\n} from \"@mml-io/mml-web\";\nimport * as playcanvas from \"playcanvas\";\n\nimport { createPlayCanvasDebugBoundingBox } from \"../debug-bounding-box/PlayCanvasDebugBoundingBox\";\nimport { PlayCanvasGraphicsAdapter } from \"../PlayCanvasGraphicsAdapter\";\n\ntype PlayCanvasModelLoadState = {\n renderEntity: playcanvas.Entity;\n boundingBox: playcanvas.BoundingBox;\n collisionWorldScale: IVect3;\n bones: Map;\n};\n\ntype PlayCanvasAnimLoadState = {\n animAsset: playcanvas.Asset;\n animComponent: playcanvas.AnimComponent | null;\n};\n\nexport class PlayCanvasModel extends ModelGraphics {\n private srcLoadingInstanceManager = new LoadingInstanceManager(`${Model.tagName}.src`);\n private animLoadingInstanceManager = new LoadingInstanceManager(`${Model.tagName}.anim`);\n private latestSrcModelPromise: Promise | null = null;\n\n private debugMaterial: playcanvas.BasicMaterial | null = null;\n\n private latestAnimPromise: Promise | null = null;\n private documentTimeTickListener: null | { remove: () => void } = null;\n\n private attachments = new Map<\n Model,\n {\n animComponent: playcanvas.AnimComponent;\n } | null\n >();\n private registeredParentAttachment: Model | null = null;\n\n private socketChildrenByBone = new Map>>();\n\n private debugBoundingBox: playcanvas.Entity | null = null;\n\n protected loadedState: PlayCanvasModelLoadState | null = null;\n protected animState: PlayCanvasAnimLoadState | null = null;\n\n constructor(\n private model: Model,\n private updateMeshCallback: () => void,\n ) {\n super(model, updateMeshCallback);\n }\n\n private getPlayCanvasApp(): playcanvas.AppBase {\n return this.model.getScene().getGraphicsAdapter().getPlayCanvasApp();\n }\n\n hasLoadedModel(): boolean {\n return !!this.loadedState?.renderEntity;\n }\n\n hasLoadedAnimation(): boolean {\n return !!this.animState?.animAsset;\n }\n\n disable(): void {}\n\n enable(): void {}\n\n getCollisionElement(): playcanvas.Entity {\n return this.model.getContainer();\n }\n\n setDebug(): void {\n this.updateDebugVisualisation();\n }\n\n setCastShadows(): void {\n // TODO\n }\n\n public registerAttachment(attachment: Model) {\n let animState = null;\n if (this.animState) {\n const attachmentLoadedState = (attachment.modelGraphics as PlayCanvasModel).loadedState;\n if (!attachmentLoadedState) {\n throw new Error(\"Attachment must be loaded before registering\");\n }\n const playcanvasEntity = attachmentLoadedState.renderEntity;\n const animComponent = playcanvasEntity.addComponent(\"anim\", {}) as playcanvas.AnimComponent;\n animComponent.assignAnimation(\"SingleAnimation\", this.animState.animAsset.resource);\n animState = {\n animComponent,\n };\n }\n this.attachments.set(attachment, animState);\n }\n\n public unregisterAttachment(attachment: Model) {\n const animState = this.attachments.get(attachment);\n if (animState) {\n animState.animComponent.reset();\n animState.animComponent.unbind();\n animState.animComponent.entity.removeComponent(\"anim\");\n }\n this.attachments.delete(attachment);\n }\n\n getBoundingBox(): { centerOffset: IVect3; size: IVect3 } | null {\n if (this.loadedState) {\n return {\n centerOffset: this.loadedState.boundingBox.center,\n size: this.loadedState.boundingBox.halfExtents,\n };\n }\n return null;\n }\n\n setAnim(anim: string): void {\n if (this.animState) {\n if (this.animState.animComponent) {\n this.animState.animComponent.reset();\n this.animState.animComponent.unbind();\n this.animState.animComponent.entity.removeComponent(\"anim\");\n }\n this.animState = null;\n // TODO - clear up the asset?\n for (const [attachment, animState] of this.attachments) {\n if (animState) {\n animState.animComponent.reset();\n animState.animComponent.unbind();\n animState.animComponent.entity.removeComponent(\"anim\");\n }\n this.attachments.set(attachment, null);\n }\n }\n if (!anim) {\n this.latestAnimPromise = null;\n // If the animation is removed then the model can be added to the parent attachment if the model is loaded\n if (this.loadedState && !this.registeredParentAttachment) {\n const parent = this.model.parentElement;\n if (parent instanceof Model) {\n this.registeredParentAttachment = parent;\n (parent.modelGraphics as PlayCanvasModel).registerAttachment(this.model);\n }\n }\n return;\n }\n const animSrc = this.model.contentSrcToContentAddress(anim);\n const animPromise = this.asyncLoadAnimAsset(animSrc, (loaded, total) => {\n this.animLoadingInstanceManager.setProgress(loaded / total);\n });\n this.animLoadingInstanceManager.start(this.model.getLoadingProgressManager(), anim);\n this.latestAnimPromise = animPromise;\n animPromise\n .then((asset) => {\n if (this.latestAnimPromise !== animPromise || !this.model.isConnected) {\n // TODO\n // If we've loaded a different model since, or we're no longer connected, dispose of this one\n // PlayCanvasModel.disposeOfGroup(result.group);\n return;\n }\n this.latestAnimPromise = null;\n this.animState = {\n animAsset: asset,\n animComponent: null,\n };\n // Play the animation\n this.connectAnimationToModel();\n\n for (const [attachment] of this.attachments) {\n const playcanvasEntity = attachment.getContainer() as playcanvas.Entity;\n const animComponent = playcanvasEntity.addComponent(\n \"anim\",\n {},\n ) as playcanvas.AnimComponent;\n animComponent.assignAnimation(\"SingleAnimation\", this.animState.animAsset.resource);\n const animState = {\n animComponent,\n };\n this.attachments.set(attachment, animState);\n }\n\n if (!this.documentTimeTickListener) {\n this.documentTimeTickListener = this.model.addDocumentTimeTickListener(\n (documentTime: number) => {\n this.updateAnimation(documentTime);\n },\n );\n }\n this.animLoadingInstanceManager.finish();\n })\n .catch((err) => {\n console.error(\"Error loading m-model.anim\", err);\n this.animLoadingInstanceManager.error(err);\n });\n }\n\n private connectAnimationToModel() {\n if (this.animState && this.loadedState) {\n const playcanvasEntity = this.loadedState.renderEntity;\n const animComponent = playcanvasEntity.addComponent(\"anim\", {}) as playcanvas.AnimComponent;\n animComponent.assignAnimation(\"SingleAnimation\", this.animState.animAsset.resource);\n this.animState.animComponent = animComponent;\n }\n }\n\n public registerSocketChild(\n child: TransformableElement,\n socketName: string,\n ): void {\n let children = this.socketChildrenByBone.get(socketName);\n if (!children) {\n children = new Set>();\n this.socketChildrenByBone.set(socketName, children);\n }\n children.add(child);\n\n if (this.loadedState) {\n const bone = this.loadedState.bones.get(socketName);\n if (bone) {\n bone.addChild(child.getContainer());\n } else {\n this.model.getContainer().addChild(child.getContainer());\n }\n }\n }\n\n public unregisterSocketChild(\n child: TransformableElement,\n socketName: string,\n addToRoot: boolean = true,\n ): void {\n const socketChildren = this.socketChildrenByBone.get(socketName);\n if (socketChildren) {\n socketChildren.delete(child);\n if (addToRoot) {\n this.model.getContainer().addChild(child.getContainer());\n }\n if (socketChildren.size === 0) {\n this.socketChildrenByBone.delete(socketName);\n }\n }\n }\n\n public setAnimEnabled(): void {\n // no-op\n }\n\n public setAnimLoop(): void {\n // no-op\n }\n\n public setAnimStartTime(): void {\n // no-op\n }\n\n public setAnimPauseTime(): void {\n // no-op\n }\n\n public transformed(): void {\n /*\n TODO - this hack is necessary to allow scaling of collision models in\n playcanvas. The meshes are cached by id (and potentially shared between\n entities). The scale changing does not cause a cache miss, so the cached\n mesh is used with the wrong scale. This is a workaround to clear the cache.\n */\n const scale = this.loadedState?.renderEntity.getWorldTransform().getScale();\n if (scale && this.loadedState) {\n if (\n Math.abs(this.loadedState.collisionWorldScale.x - scale.x) > 0.001 ||\n Math.abs(this.loadedState.collisionWorldScale.y - scale.y) > 0.001 ||\n Math.abs(this.loadedState.collisionWorldScale.z - scale.z) > 0.001\n ) {\n this.loadedState.collisionWorldScale = { x: scale.x, y: scale.y, z: scale.z };\n\n const collisionComponent = this.loadedState.renderEntity.collision;\n if (collisionComponent) {\n for (const mesh of collisionComponent.data.render.meshes) {\n // @ts-expect-error - accessing _triMeshCache private property\n const triMesh = collisionComponent.system._triMeshCache[mesh.id];\n if (triMesh) {\n // @ts-expect-error - accessing untyped Ammo global\n window.Ammo.destroy(triMesh);\n // @ts-expect-error - accessing _triMeshCache private property\n delete collisionComponent.system._triMeshCache[mesh.id];\n }\n }\n // @ts-expect-error - accessing onSetModel private method\n collisionComponent.onSetModel();\n }\n }\n }\n }\n\n setSrc(src: string): void {\n const playcanvasEntity = this.model.getContainer() as playcanvas.Entity;\n if (this.loadedState !== null) {\n this.loadedState.renderEntity.remove();\n this.loadedState = null;\n if (this.animState) {\n this.animState.animComponent = null;\n }\n if (this.registeredParentAttachment) {\n (this.registeredParentAttachment.modelGraphics as PlayCanvasModel).unregisterAttachment(\n this.model,\n );\n this.registeredParentAttachment = null;\n }\n this.updateMeshCallback();\n this.updateDebugVisualisation();\n }\n if (!src) {\n this.srcLoadingInstanceManager.abortIfLoading();\n this.socketChildrenByBone.forEach((children) => {\n children.forEach((child) => {\n this.model.getContainer().addChild(child.getContainer());\n });\n });\n this.updateMeshCallback();\n this.updateDebugVisualisation();\n return;\n }\n\n const contentSrc = this.model.contentSrcToContentAddress(src);\n const srcModelPromise = this.asyncLoadSourceAsset(contentSrc, (loaded, total) => {\n this.srcLoadingInstanceManager.setProgress(loaded / total);\n });\n this.srcLoadingInstanceManager.start(this.model.getLoadingProgressManager(), contentSrc);\n this.latestSrcModelPromise = srcModelPromise;\n srcModelPromise\n .then((asset) => {\n if (this.latestSrcModelPromise !== srcModelPromise || !this.model.isConnected) {\n // If we've loaded a different model since, or we're no longer connected, dispose of this one\n // PlayCanvasModel.disposeOfGroup(result.group);\n return;\n }\n this.latestSrcModelPromise = null;\n const renderEntity: playcanvas.Entity = asset.resource.instantiateRenderEntity();\n\n let boundingBox: playcanvas.BoundingBox | null = null;\n const renders = renderEntity.findComponents(\"render\") as Array;\n for (const render of renders) {\n for (const meshInstance of render.meshInstances) {\n if (boundingBox) {\n boundingBox.add(meshInstance.aabb);\n } else {\n boundingBox = meshInstance.aabb.clone();\n }\n }\n render.entity.addComponent(\"collision\", {\n type: \"mesh\",\n renderAsset: render.asset,\n });\n }\n if (!boundingBox) {\n boundingBox = new playcanvas.BoundingBox(\n new playcanvas.Vec3(0, 0, 0),\n new playcanvas.Vec3(0, 0, 0),\n );\n }\n boundingBox.halfExtents.mulScalar(2);\n\n const bones = new Map();\n renderEntity.forEach((node) => {\n bones.set(node.name, node);\n });\n\n this.loadedState = {\n renderEntity,\n boundingBox,\n collisionWorldScale: { x: 1, y: 1, z: 1 },\n bones,\n };\n\n playcanvasEntity.addChild(renderEntity);\n\n this.transformed();\n\n for (const [boneName, children] of this.socketChildrenByBone) {\n const bone = bones.get(boneName);\n if (bone) {\n children.forEach((child) => {\n bone.addChild(child.getContainer());\n });\n }\n }\n\n this.connectAnimationToModel();\n this.updateMeshCallback();\n\n const parent = this.model.parentElement;\n if (parent instanceof Model) {\n if (!this.latestAnimPromise && !this.animState) {\n this.registeredParentAttachment = parent;\n (parent.modelGraphics as PlayCanvasModel).registerAttachment(this.model);\n }\n }\n\n this.srcLoadingInstanceManager.finish();\n\n this.updateDebugVisualisation();\n })\n .catch((err) => {\n console.error(\"Error loading m-model.src\", err);\n this.srcLoadingInstanceManager.error(err);\n });\n }\n\n private updateDebugVisualisation() {\n if (!this.model.props.debug) {\n this.clearDebugVisualisation();\n } else {\n if (!this.debugBoundingBox) {\n const graphicsAdapter = this.model.getScene().getGraphicsAdapter();\n if (!this.debugMaterial) {\n this.debugMaterial = new playcanvas.BasicMaterial();\n this.debugMaterial.color = new playcanvas.Color(1, 0, 0);\n }\n this.debugBoundingBox = createPlayCanvasDebugBoundingBox(\n graphicsAdapter,\n this.debugMaterial,\n );\n this.model.getContainer().addChild(this.debugBoundingBox);\n }\n if (this.loadedState) {\n const boundingBox = this.loadedState.boundingBox;\n this.debugBoundingBox.setLocalPosition(boundingBox.center);\n this.debugBoundingBox.setLocalScale(boundingBox.halfExtents);\n } else {\n this.debugBoundingBox.setLocalScale(0, 0, 0);\n }\n }\n }\n\n private clearDebugVisualisation() {\n if (this.debugBoundingBox) {\n this.debugBoundingBox.remove();\n this.debugBoundingBox = null;\n }\n if (this.debugMaterial) {\n this.debugMaterial.destroy();\n this.debugMaterial = null;\n }\n }\n\n async asyncLoadSourceAsset(\n url: string,\n // TODO - report progress\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n onProgress: (loaded: number, total: number) => void,\n ): Promise {\n return new Promise((resolve, reject) => {\n /*\n Rewriting the url with an unused-for-networking fragment here causes the\n asset to be loaded uniquely across elements which allows the meshes to\n be independent and avoid a reuse of a (mis-)scaled mesh for collisions.\n */\n const rewrittenUrl = new URL(url);\n rewrittenUrl.hash = Math.random().toString(10);\n const asset = new playcanvas.Asset(url, \"container\", { url: rewrittenUrl.toString() });\n this.getPlayCanvasApp().assets.add(asset);\n this.getPlayCanvasApp().assets.load(asset);\n asset.ready((asset) => {\n resolve(asset);\n });\n asset.on(\"error\", (err) => {\n reject(err);\n });\n });\n }\n\n async asyncLoadAnimAsset(\n url: string,\n // TODO - report progress\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n onProgress: (loaded: number, total: number) => void,\n ): Promise {\n return new Promise((resolve, reject) => {\n const asset = new playcanvas.Asset(url, \"animation\", { url });\n this.getPlayCanvasApp().assets.add(asset);\n this.getPlayCanvasApp().assets.load(asset);\n asset.ready((asset) => {\n resolve(asset);\n });\n asset.on(\"error\", (err) => {\n reject(err);\n });\n });\n }\n\n dispose() {\n if (this.documentTimeTickListener) {\n this.documentTimeTickListener.remove();\n this.documentTimeTickListener = null;\n }\n if (this.registeredParentAttachment) {\n (this.registeredParentAttachment?.modelGraphics as PlayCanvasModel)?.unregisterAttachment(\n this.model,\n );\n this.registeredParentAttachment = null;\n }\n if (this.loadedState) {\n this.loadedState.renderEntity.destroy();\n this.loadedState = null;\n }\n this.clearDebugVisualisation();\n this.animLoadingInstanceManager.dispose();\n this.srcLoadingInstanceManager.dispose();\n }\n\n private triggerSocketedChildrenTransformed() {\n // Socketed children need to be updated when the animation is updated as their position may have updated\n this.socketChildrenByBone.forEach((children) => {\n children.forEach((child) => {\n if (child instanceof TransformableElement) {\n child.didUpdateTransformation();\n }\n });\n });\n }\n\n private updateAnimation(docTimeMs: number) {\n let animationTimeMs = docTimeMs - this.model.props.animStartTime;\n if (docTimeMs < this.model.props.animStartTime) {\n animationTimeMs = 0;\n } else if (this.model.props.animPauseTime !== null) {\n if (docTimeMs > this.model.props.animPauseTime) {\n animationTimeMs = this.model.props.animPauseTime - this.model.props.animStartTime;\n }\n }\n\n const animComponent = this.animState?.animComponent;\n if (animComponent) {\n if (!this.model.props.animEnabled) {\n animComponent.playing = false;\n this.triggerSocketedChildrenTransformed();\n } else {\n animComponent.playing = true;\n // @ts-expect-error - accessing _controller private property\n const clip = animComponent.baseLayer._controller._animEvaluator.clips[0];\n if (clip) {\n clip.time = animationTimeMs / 1000;\n }\n }\n }\n\n for (const [model, animState] of this.attachments) {\n if (animState) {\n animState.animComponent.playing = this.model.props.animEnabled;\n // @ts-expect-error - accessing _controller private property\n const clip = animState.animComponent.baseLayer._controller._animEvaluator.clips[0];\n if (clip) {\n clip.time = animationTimeMs / 1000;\n (model.modelGraphics as PlayCanvasModel).triggerSocketedChildrenTransformed();\n }\n }\n }\n this.triggerSocketedChildrenTransformed();\n }\n}\n", "import { MELEMENT_PROPERTY_NAME, MPlaneProps, Plane } from \"@mml-io/mml-web\";\nimport { MMLColor } from \"@mml-io/mml-web\";\nimport { PlaneGraphics } from \"@mml-io/mml-web\";\nimport * as playcanvas from \"playcanvas\";\n\nimport { PlayCanvasGraphicsAdapter } from \"../PlayCanvasGraphicsAdapter\";\n\nexport class PlayCanvasPlane extends PlaneGraphics {\n private entity: playcanvas.Entity;\n private renderComponent: playcanvas.RenderComponent;\n private material: playcanvas.StandardMaterial = new playcanvas.StandardMaterial();\n\n constructor(private plane: Plane) {\n super(plane);\n\n /*\n The primitive must be in an internal entity to allow using setLocalScale\n without affecting children.\n */\n this.entity = new playcanvas.Entity(\n \"plane-internal\",\n plane.getScene().getGraphicsAdapter().getPlayCanvasApp(),\n );\n (this.entity as any)[MELEMENT_PROPERTY_NAME] = plane;\n this.renderComponent = this.entity.addComponent(\"render\", {\n type: \"plane\",\n material: this.material,\n }) as playcanvas.RenderComponent;\n this.entity.rotate(90, 0, 0);\n this.entity.addComponent(\"collision\", {\n type: \"box\",\n halfExtents: new playcanvas.Vec3(0.5, 0, 0.5),\n });\n plane.getContainer().addChild(this.entity);\n }\n\n disable(): void {}\n\n enable(): void {}\n\n getCollisionElement(): playcanvas.Entity {\n return this.entity;\n }\n\n setColor(color: MMLColor): void {\n this.material.diffuse.set(color.r, color.g, color.b);\n this.material.update();\n }\n\n private updateSize(mPlaneProps: MPlaneProps): void {\n this.entity.setLocalScale(mPlaneProps.width, 1, mPlaneProps.height);\n if (this.entity.collision) {\n this.entity.collision.halfExtents.set(mPlaneProps.width / 2, 0, mPlaneProps.height / 2);\n // @ts-expect-error - accessing onSetHalfExtents private method\n this.entity.collision.onSetHalfExtents();\n }\n }\n\n setWidth(width: number, mPlaneProps: MPlaneProps): void {\n this.updateSize(mPlaneProps);\n }\n\n setHeight(height: number, mPlaneProps: MPlaneProps): void {\n this.updateSize(mPlaneProps);\n }\n\n setCastShadows(castShadows: boolean): void {\n // TODO - not casting shadows?\n this.renderComponent.castShadows = castShadows;\n }\n\n setOpacity(opacity: number): void {\n if (opacity === 1) {\n this.material.blendType = playcanvas.BLEND_NONE;\n } else {\n this.material.blendType = playcanvas.BLEND_NORMAL;\n }\n this.material.opacity = opacity;\n this.material.update();\n }\n\n dispose() {\n this.entity.destroy();\n }\n}\n", "import { PositionProbe } from \"@mml-io/mml-web\";\nimport { PositionProbeGraphics } from \"@mml-io/mml-web\";\nimport * as playcanvas from \"playcanvas\";\n\nimport { PlayCanvasGraphicsAdapter } from \"../PlayCanvasGraphicsAdapter\";\n\nexport class PlayCanvasPositionProbe extends PositionProbeGraphics {\n private entity: playcanvas.Entity | null = null;\n private debugMaterial: playcanvas.BasicMaterial | null = null;\n\n constructor(private positionProbe: PositionProbe) {\n super(positionProbe);\n this.updateDebugVisualisation();\n }\n\n disable(): void {}\n\n enable(): void {}\n\n setRange(): void {\n this.updateDebugVisualisation();\n }\n\n setDebug() {\n this.updateDebugVisualisation();\n }\n\n private clearDebugVisualisation() {\n if (this.entity) {\n this.entity.destroy();\n this.entity = null;\n }\n if (this.debugMaterial) {\n this.debugMaterial.destroy();\n this.debugMaterial = null;\n }\n }\n\n private updateDebugVisualisation() {\n if (!this.positionProbe.props.debug) {\n this.clearDebugVisualisation();\n } else {\n if (this.positionProbe.isConnected && !this.entity) {\n this.entity = new playcanvas.Entity(\n \"position-probe-internal\",\n this.positionProbe.getScene().getGraphicsAdapter().getPlayCanvasApp(),\n );\n if (!this.debugMaterial) {\n this.debugMaterial = new playcanvas.BasicMaterial();\n this.debugMaterial.color = new playcanvas.Color(0, 1, 0);\n }\n this.entity.addComponent(\"model\", {\n type: \"sphere\",\n material: this.debugMaterial,\n });\n this.entity.model?.model.meshInstances.forEach((mi) => {\n mi.renderStyle = playcanvas.RENDERSTYLE_WIREFRAME;\n mi.castShadow = false;\n });\n\n this.positionProbe.getContainer().addChild(this.entity);\n }\n\n if (this.entity) {\n this.entity.setLocalScale(\n this.positionProbe.props.range * 2,\n this.positionProbe.props.range * 2,\n this.positionProbe.props.range * 2,\n );\n }\n }\n }\n\n dispose() {\n this.clearDebugVisualisation();\n }\n}\n", "import { Prompt } from \"@mml-io/mml-web\";\nimport { PromptGraphics } from \"@mml-io/mml-web\";\n\nimport { PlayCanvasGraphicsAdapter } from \"../PlayCanvasGraphicsAdapter\";\n\nexport class PlayCanvasPrompt extends PromptGraphics {\n constructor(private prompt: Prompt) {\n super(prompt);\n }\n\n disable(): void {}\n\n enable(): void {}\n\n setMessage(): void {\n // no-op\n }\n\n setPlaceholder(): void {\n // no-op\n }\n\n setPrefill(): void {\n // no-op\n }\n\n setDebug(): void {\n // no-op\n }\n\n dispose() {}\n}\n", "import { RemoteDocument, RemoteDocumentGraphics } from \"@mml-io/mml-web\";\nimport * as playcanvas from \"playcanvas\";\n\nimport { PlayCanvasGraphicsAdapter } from \"../PlayCanvasGraphicsAdapter\";\nimport { getPlayCanvasReconnectingStatus } from \"../PlayCanvasReconnectingStatus\";\n\nexport class PlayCanvasRemoteDocument extends RemoteDocumentGraphics {\n private statusUI: playcanvas.Entity | null = null;\n\n constructor(private element: RemoteDocument) {\n super(element);\n }\n\n public showError(showError: boolean): void {\n if (!showError) {\n if (this.statusUI !== null) {\n this.element.getContainer().removeChild(this.statusUI);\n this.statusUI = null;\n }\n } else {\n if (this.statusUI === null) {\n const playCanvasApp = this.element.getScene().getGraphicsAdapter().getPlayCanvasApp();\n this.statusUI = new playcanvas.Entity(\"label-internal\", playCanvasApp);\n this.statusUI.rotate(90, 0, 0);\n\n const { material, width, height } = getPlayCanvasReconnectingStatus(playCanvasApp);\n\n this.statusUI.addComponent(\"render\", {\n type: \"plane\",\n material,\n }) as playcanvas.RenderComponent;\n\n this.statusUI.setLocalScale(width, 1, height);\n\n this.statusUI.setPosition(0, height / 2, 0);\n this.element.getContainer().addChild(this.statusUI);\n }\n }\n }\n\n public dispose() {}\n}\n", "import { CanvasText } from \"@mml-io/mml-web\";\nimport * as playcanvas from \"playcanvas\";\n\nfunction createReconnectingStatus(playCanvasApp: playcanvas.AppBase): PlayCanvasReconnectingStatus {\n const canvas = new CanvasText().renderText(\"Reconnecting\", {\n bold: true,\n fontSize: 32,\n paddingPx: 10,\n textColorRGB255A1: {\n r: 255,\n g: 0,\n b: 0,\n a: 1.0,\n },\n backgroundColorRGB255A1: {\n r: 255,\n g: 255,\n b: 255,\n a: 1.0,\n },\n alignment: \"center\",\n });\n\n const texture = new playcanvas.Texture(playCanvasApp.graphicsDevice, {\n width: canvas.width,\n height: canvas.height,\n });\n texture.setSource(canvas);\n\n const material = new playcanvas.StandardMaterial();\n material.useLighting = false;\n material.emissiveMap = texture;\n material.update();\n\n texture.destroy();\n\n const width = canvas.width;\n const height = canvas.height;\n\n return { material, width: width / 100, height: height / 100 };\n}\n\nexport type PlayCanvasReconnectingStatus = {\n material: playcanvas.StandardMaterial;\n width: number;\n height: number;\n};\n\nlet reconnectingStatus: PlayCanvasReconnectingStatus | null = null;\n\nexport function getPlayCanvasReconnectingStatus(\n playCanvasApp: playcanvas.AppBase,\n): PlayCanvasReconnectingStatus {\n if (!reconnectingStatus) {\n reconnectingStatus = createReconnectingStatus(playCanvasApp);\n }\n return reconnectingStatus;\n}\n", "import { MELEMENT_PROPERTY_NAME, MSphereProps, Sphere } from \"@mml-io/mml-web\";\nimport { MMLColor } from \"@mml-io/mml-web\";\nimport { SphereGraphics } from \"@mml-io/mml-web\";\nimport * as playcanvas from \"playcanvas\";\n\nimport { PlayCanvasGraphicsAdapter } from \"../PlayCanvasGraphicsAdapter\";\n\nexport class PlayCanvasSphere extends SphereGraphics {\n private entity: playcanvas.Entity;\n private renderComponent: playcanvas.RenderComponent;\n private material: playcanvas.StandardMaterial = new playcanvas.StandardMaterial();\n\n constructor(private sphere: Sphere) {\n super(sphere);\n\n /*\n The primitive must be in an internal entity to allow using setLocalScale\n without affecting children.\n */\n this.entity = new playcanvas.Entity(\n \"sphere-internal\",\n sphere.getScene().getGraphicsAdapter().getPlayCanvasApp(),\n );\n (this.entity as any)[MELEMENT_PROPERTY_NAME] = sphere;\n this.renderComponent = this.entity.addComponent(\"render\", {\n type: \"sphere\",\n material: this.material,\n }) as playcanvas.RenderComponent;\n this.entity.addComponent(\"collision\", {\n type: \"sphere\",\n });\n if (this.entity.collision) {\n this.entity.collision.radius = 1;\n }\n sphere.getContainer().addChild(this.entity);\n }\n\n disable(): void {}\n\n enable(): void {}\n\n getCollisionElement(): playcanvas.Entity {\n return this.entity;\n }\n\n setColor(color: MMLColor): void {\n this.material.diffuse.set(color.r, color.g, color.b);\n this.material.metalness = 0;\n this.material.useMetalness = true;\n this.material.update();\n }\n\n private updateSize(mSphereProps: MSphereProps): void {\n this.entity.setLocalScale(\n mSphereProps.radius * 2,\n mSphereProps.radius * 2,\n mSphereProps.radius * 2,\n );\n if (this.entity.collision) {\n this.entity.collision.radius = mSphereProps.radius;\n // @ts-expect-error - accessing onSetRadius private method\n this.entity.collision.onSetRadius();\n }\n }\n\n setRadius(radius: number, mSphereProps: MSphereProps): void {\n this.updateSize(mSphereProps);\n }\n\n setCastShadows(castShadows: boolean): void {\n this.renderComponent.castShadows = castShadows;\n }\n\n setOpacity(opacity: number): void {\n if (opacity === 1) {\n this.material.blendType = playcanvas.BLEND_NONE;\n } else {\n this.material.blendType = playcanvas.BLEND_NORMAL;\n }\n this.material.opacity = opacity;\n this.material.update();\n }\n\n dispose() {\n this.entity.destroy();\n }\n}\n", "import {\n Matr4,\n Model,\n TransformableElement,\n TransformableElementProps,\n TransformableGraphics,\n} from \"@mml-io/mml-web\";\nimport * as playcanvas from \"playcanvas\";\n\nimport { PlayCanvasGraphicsAdapter } from \"../PlayCanvasGraphicsAdapter\";\nimport { PlayCanvasModel } from \"./PlayCanvasModel\";\n\nconst halfToRad = 0.5 * playcanvas.math.DEG_TO_RAD;\n\n// An implementation of XYZ ordered Euler angles in degrees to quaternion\nfunction xyzDegreesToQuaternion(x: number, y: number, z: number): [number, number, number, number] {\n x *= halfToRad;\n y *= halfToRad;\n z *= halfToRad;\n const cx = Math.cos(x);\n const cy = Math.cos(y);\n const cz = Math.cos(z);\n\n const sx = Math.sin(x);\n const sy = Math.sin(y);\n const sz = Math.sin(z);\n\n return [\n sx * cy * cz + cx * sy * sz, // x\n cx * sy * cz - sx * cy * sz, // y\n cx * cy * sz + sx * sy * cz, // z\n cx * cy * cz - sx * sy * sz, // w\n ];\n}\n\nexport class PlayCanvasTransformable extends TransformableGraphics {\n private socketName: string | null = null;\n private registeredSocketParent: PlayCanvasModel | null = null;\n\n constructor(private transformableElement: TransformableElement) {\n super(transformableElement);\n }\n\n getWorldMatrix(): Matr4 {\n return new Matr4(this.getPlayCanvasEntity().getWorldTransform().data);\n }\n\n setSocket(socketName: string | null): void {\n if (this.socketName !== socketName) {\n if (this.socketName !== null && this.registeredSocketParent) {\n this.registeredSocketParent.unregisterSocketChild(\n this.transformableElement,\n this.socketName,\n );\n }\n this.socketName = socketName;\n if (socketName !== null) {\n this.registerWithParentModel(socketName);\n }\n } else {\n this.socketName = socketName;\n }\n }\n\n private registerWithParentModel(socketName: string): void {\n if (\n (this.transformableElement.parentElement as Model | undefined)\n ?.isModel\n ) {\n const parentModel = this.transformableElement\n .parentElement as Model;\n this.registeredSocketParent = parentModel.modelGraphics as PlayCanvasModel;\n this.registeredSocketParent.registerSocketChild(this.transformableElement, socketName);\n }\n }\n\n setVisible(visible: boolean): void {\n this.getPlayCanvasEntity().enabled = visible;\n }\n\n private updatePosition(x: number, y: number, z: number): void {\n this.getPlayCanvasEntity().setLocalPosition(x, y, z);\n }\n\n setX(x: number, transformableElementProps: TransformableElementProps): void {\n this.updatePosition(\n transformableElementProps.x,\n transformableElementProps.y,\n transformableElementProps.z,\n );\n }\n\n setY(y: number, transformableElementProps: TransformableElementProps): void {\n this.updatePosition(\n transformableElementProps.x,\n transformableElementProps.y,\n transformableElementProps.z,\n );\n }\n\n setZ(z: number, transformableElementProps: TransformableElementProps): void {\n this.updatePosition(\n transformableElementProps.x,\n transformableElementProps.y,\n transformableElementProps.z,\n );\n }\n\n private getPlayCanvasEntity(): playcanvas.Entity {\n return this.transformableElement.getContainer() as playcanvas.Entity;\n }\n\n private updateRotation(rx: number, ry: number, rz: number): void {\n this.getPlayCanvasEntity().setLocalRotation(...xyzDegreesToQuaternion(rx, ry, rz));\n }\n\n setRotationX(rotationX: number, transformableElementProps: TransformableElementProps): void {\n this.updateRotation(\n transformableElementProps.rx,\n transformableElementProps.ry,\n transformableElementProps.rz,\n );\n }\n\n setRotationY(rotationY: number, transformableElementProps: TransformableElementProps): void {\n this.updateRotation(\n transformableElementProps.rx,\n transformableElementProps.ry,\n transformableElementProps.rz,\n );\n }\n\n setRotationZ(rotationZ: number, transformableElementProps: TransformableElementProps): void {\n this.updateRotation(\n transformableElementProps.rx,\n transformableElementProps.ry,\n transformableElementProps.rz,\n );\n }\n\n private updateScale(sx: number, sy: number, sz: number): void {\n this.getPlayCanvasEntity().setLocalScale(sx, sy, sz);\n }\n\n setScaleX(scaleX: number, transformableElementProps: TransformableElementProps): void {\n this.updateScale(\n transformableElementProps.sx,\n transformableElementProps.sy,\n transformableElementProps.sz,\n );\n }\n\n setScaleY(scaleY: number, transformableElementProps: TransformableElementProps): void {\n this.updateScale(\n transformableElementProps.sx,\n transformableElementProps.sy,\n transformableElementProps.sz,\n );\n }\n\n setScaleZ(scaleZ: number, transformableElementProps: TransformableElementProps): void {\n this.updateScale(\n transformableElementProps.sx,\n transformableElementProps.sy,\n transformableElementProps.sz,\n );\n }\n\n dispose() {\n if (this.socketName && this.registeredSocketParent !== null) {\n this.registeredSocketParent.unregisterSocketChild(\n this.transformableElement,\n this.socketName,\n false,\n );\n }\n }\n}\n", "import {\n calculateContentSize,\n EventHandlerCollection,\n MELEMENT_PROPERTY_NAME,\n StaticFileVideoSource,\n Video,\n VideoGraphics,\n VideoSource,\n WHEPVideoSource,\n} from \"@mml-io/mml-web\";\nimport * as playcanvas from \"playcanvas\";\n\nimport { createPlaneModel } from \"../plane/plane\";\nimport { PlayCanvasGraphicsAdapter } from \"../PlayCanvasGraphicsAdapter\";\n\nconst audioRefDistance = 1;\nconst audioRolloffFactor = 1;\n\nexport class PlayCanvasVideo extends VideoGraphics {\n private videoSource: VideoSource | null = null;\n private videoMaterial: playcanvas.StandardMaterial = new playcanvas.StandardMaterial();\n private disabledVideoMaterial = new playcanvas.StandardMaterial();\n\n private entity: playcanvas.Entity;\n private modelComponent: playcanvas.ModelComponent;\n private meshInstance: playcanvas.MeshInstance;\n\n private loadedVideoState: {\n video: HTMLVideoElement;\n videoLoadEventCollection: EventHandlerCollection;\n videoTexture: playcanvas.Texture | null;\n audio: {\n gainNode: GainNode;\n audioNode: AudioNode;\n panner: PannerNode;\n } | null;\n } | null = null;\n private documentTimeTickListener: { remove: () => void };\n\n private eventCollection = new EventHandlerCollection();\n\n constructor(\n private video: Video,\n private updateMeshCallback: () => void,\n ) {\n super(video, updateMeshCallback);\n this.disabledVideoMaterial.diffuse = new playcanvas.Color(0, 0, 0);\n\n this.documentTimeTickListener = this.video.addDocumentTimeTickListener(() => {\n this.tick();\n });\n\n this.eventCollection.add(this.getAudioContext(), \"statechange\", () => {\n this.syncVideoTime();\n });\n\n /*\n The primitive must be in an internal entity to allow using setLocalScale\n without affecting children.\n */\n this.entity = new playcanvas.Entity(\n \"video-internal\",\n video.getScene().getGraphicsAdapter().getPlayCanvasApp(),\n );\n (this.entity as any)[MELEMENT_PROPERTY_NAME] = video;\n\n const { model, meshInstance } = createPlaneModel(\n this.video.getScene().getGraphicsAdapter().getPlayCanvasApp(),\n this.disabledVideoMaterial,\n );\n this.modelComponent = this.entity.addComponent(\"model\", {}) as playcanvas.ModelComponent;\n this.modelComponent.model = model;\n this.meshInstance = meshInstance;\n\n this.entity.addComponent(\"collision\", {\n type: \"box\",\n halfExtents: new playcanvas.Vec3(0.5, 0, 0.5),\n });\n video.getContainer().addChild(this.entity);\n }\n\n private getPlayCanvasApp(): playcanvas.AppBase {\n return this.video.getScene().getGraphicsAdapter().getPlayCanvasApp();\n }\n\n getWidthAndHeight(): { width: number; height: number } {\n return {\n width: this.entity.getLocalScale().x,\n height: this.entity.getLocalScale().y,\n };\n }\n\n private getAudioContext(): AudioContext {\n const playcanvasApp = this.getPlayCanvasApp();\n const soundSystem = playcanvasApp.systems.sound;\n if (!soundSystem) {\n throw new Error(\"Playcanvas sound system not enabled\");\n }\n return soundSystem.context;\n }\n\n public syncVideoTime() {\n if (this.loadedVideoState) {\n const videoTag = this.loadedVideoState.video;\n if (videoTag.readyState === 0) {\n return;\n }\n\n const audioContext = this.getAudioContext();\n if (audioContext.state === \"running\") {\n videoTag.muted = false;\n }\n\n if (this.video.isDisabled()) {\n videoTag.muted = true;\n }\n\n if (this.videoSource) {\n this.videoSource.syncVideoSource(this.video.props);\n }\n }\n }\n\n public enable(): void {\n this.updateVideo();\n }\n\n public disable(): void {\n this.updateVideo();\n }\n\n public setSrc(): void {\n this.updateVideo();\n }\n\n public setWidth(): void {\n this.updateWidthAndHeight();\n }\n\n public setHeight(): void {\n this.updateWidthAndHeight();\n }\n\n public setEnabled(): void {\n this.updateVideo();\n }\n\n public setCastShadows(): void {\n this.updateVideo();\n }\n\n public setLoop(): void {\n this.updateVideo();\n }\n\n public setVolume(): void {\n if (this.loadedVideoState?.audio) {\n this.loadedVideoState.audio.gainNode.gain.value = this.video.props.volume;\n }\n }\n\n public setEmissive(): void {\n this.updateMaterialEmissiveIntensity();\n }\n\n public setStartTime(): void {\n this.updateVideo();\n }\n\n public setPauseTime(): void {\n this.updateVideo();\n }\n\n private updateVideo() {\n if (!this.video.isConnected) {\n return;\n }\n\n if (!this.video.props.enabled) {\n this.clearSource();\n return;\n }\n\n if (!this.video.props.src) {\n this.clearSource();\n } else {\n const contentAddress = this.video.contentSrcToContentAddress(this.video.props.src);\n if (this.videoSource === null || this.videoSource.getContentAddress() !== contentAddress) {\n this.clearSource();\n\n const video = document.createElement(\"video\");\n video.playsInline = true;\n // Muted allows autoplay immediately without the user needing to interact with the document\n // Video will be unmuted when the audiocontext is available\n video.muted = true;\n video.autoplay = true;\n video.crossOrigin = \"anonymous\";\n const videoLoadEventCollection = new EventHandlerCollection();\n this.loadedVideoState = {\n video,\n videoLoadEventCollection,\n videoTexture: null,\n audio: null,\n };\n video.loop = this.video.props.loop;\n\n const url = new URL(contentAddress);\n if (WHEPVideoSource.isWHEPURL(url)) {\n this.videoSource = new WHEPVideoSource(url, video);\n } else {\n this.videoSource = new StaticFileVideoSource(url, video, this.video.props, () => {\n return this.video.getDocumentTime();\n });\n }\n\n videoLoadEventCollection.add(video, \"loadeddata\", () => {\n if (!this.loadedVideoState || this.loadedVideoState.video !== video) {\n // Video was changed before it loaded\n return;\n }\n\n // Create a texture to hold the video frame data\n this.loadedVideoState.videoTexture = new playcanvas.Texture(\n this.getPlayCanvasApp().graphicsDevice,\n {\n format: playcanvas.PIXELFORMAT_R8_G8_B8,\n mipmaps: false,\n width: video.videoWidth,\n height: video.videoHeight,\n },\n );\n this.loadedVideoState.videoTexture.setSource(this.loadedVideoState.video);\n this.videoMaterial.diffuseMap = this.loadedVideoState.videoTexture;\n this.videoMaterial.update();\n this.meshInstance.material = this.videoMaterial;\n this.syncVideoTime();\n this.updateWidthAndHeight();\n this.updateMaterialEmissiveIntensity();\n\n // playcanvas doesn't support positional audio for video elements so use the audio context directly\n const audioContext = this.getAudioContext();\n\n const pos = this.entity.getPosition();\n // TODO - initial orientation\n const orientationX = 1.0;\n const orientationY = 0.0;\n const orientationZ = 0.0;\n\n const panner = new PannerNode(audioContext, {\n panningModel: \"HRTF\",\n distanceModel: \"inverse\",\n positionX: pos.x,\n positionY: pos.y,\n positionZ: pos.z,\n orientationX,\n orientationY,\n orientationZ,\n refDistance: audioRefDistance,\n rolloffFactor: audioRolloffFactor,\n });\n\n const gainNode = audioContext.createGain();\n gainNode.gain.value = this.video.props.volume;\n const stereoPanner = new StereoPannerNode(audioContext, { pan: 0 });\n const audioNode = audioContext.createMediaElementSource(video);\n audioNode\n .connect(gainNode)\n .connect(stereoPanner)\n .connect(panner)\n .connect(audioContext.destination);\n\n this.loadedVideoState.audio = { gainNode, audioNode, panner };\n });\n }\n }\n\n if (this.videoSource) {\n this.syncVideoTime();\n }\n }\n\n private tick() {\n const videoTexture = this.loadedVideoState?.videoTexture;\n if (videoTexture) {\n videoTexture.upload();\n }\n const audio = this.loadedVideoState?.audio;\n if (audio) {\n /// Update the position\n const pos = this.entity.getPosition();\n const rotation = this.entity.getEulerAngles();\n audio.panner.positionX.value = pos.x;\n audio.panner.positionY.value = pos.y;\n audio.panner.positionZ.value = pos.z;\n audio.panner.orientationX.value = Math.cos(rotation.y);\n audio.panner.orientationY.value = 0;\n audio.panner.orientationZ.value = Math.sin(rotation.y);\n }\n }\n\n private clearSource() {\n if (this.videoSource) {\n this.videoSource.dispose();\n this.videoSource = null;\n }\n if (this.loadedVideoState) {\n const tag = this.loadedVideoState.video;\n // There is an existing src - stop playing to allow changing it\n tag.pause();\n tag.src = \"\";\n tag.load();\n if (this.loadedVideoState.audio) {\n this.loadedVideoState.audio.audioNode.disconnect();\n this.loadedVideoState.audio = null;\n }\n if (this.loadedVideoState.videoTexture) {\n this.loadedVideoState.videoTexture.destroy();\n this.loadedVideoState.videoTexture = null;\n }\n this.loadedVideoState.videoLoadEventCollection.clear();\n this.loadedVideoState = null;\n this.meshInstance.material = this.disabledVideoMaterial;\n this.updateWidthAndHeight();\n }\n }\n\n private updateMaterialEmissiveIntensity() {\n if (this.loadedVideoState?.videoTexture && this.video.props.emissive) {\n this.videoMaterial.emissiveMap = this.loadedVideoState.videoTexture;\n this.videoMaterial.emissiveIntensity = this.video.props.emissive;\n } else {\n this.videoMaterial.emissiveMap = null;\n this.videoMaterial.emissiveIntensity = 0;\n }\n this.videoMaterial.update();\n }\n\n dispose() {\n this.clearSource();\n this.documentTimeTickListener.remove();\n this.eventCollection.clear();\n this.entity.destroy();\n }\n\n getCollisionElement(): playcanvas.Entity {\n return this.entity;\n }\n\n private updateWidthAndHeight() {\n const { width, height } = calculateContentSize({\n content: this.loadedVideoState\n ? {\n width: this.loadedVideoState.video.videoWidth,\n height: this.loadedVideoState.video.videoHeight,\n }\n : undefined,\n width: this.video.props.width,\n height: this.video.props.height,\n });\n\n this.entity.setLocalScale(width, height, 1);\n if (this.entity.collision) {\n this.entity.collision.halfExtents.set(width / 2, height / 2, 0);\n // @ts-expect-error - accessing onSetHalfExtents private method\n this.entity.collision.onSetHalfExtents();\n }\n\n this.updateMeshCallback();\n }\n}\n", "import { MMLGraphicsInterface } from \"@mml-io/mml-web\";\n\nimport * as PlayCanvasElements from \"./elements\";\nimport { PlayCanvasGraphicsAdapter } from \"./PlayCanvasGraphicsAdapter\";\n\nexport const PlayCanvasGraphicsInterface: MMLGraphicsInterface = {\n MElementGraphicsInterface: (element) => new PlayCanvasElements.PlayCanvasMElement(element),\n MMLDebugHelperGraphicsInterface: (debugHelper) =>\n new PlayCanvasElements.PlayCanvasDebugHelper(debugHelper),\n MMLAudioGraphicsInterface: (element) => new PlayCanvasElements.PlayCanvasAudio(element),\n MMLChatProbeGraphicsInterface: (element) => new PlayCanvasElements.PlayCanvasChatProbe(element),\n MMLCubeGraphicsInterface: (element) => new PlayCanvasElements.PlayCanvasCube(element),\n MMLCylinderGraphicsInterface: (element) => new PlayCanvasElements.PlayCanvasCylinder(element),\n MMLFrameGraphicsInterface: (element) => new PlayCanvasElements.PlayCanvasFrame(element),\n MMLImageGraphicsInterface: (element, updateMeshCallback: () => void) =>\n new PlayCanvasElements.PlayCanvasImage(element, updateMeshCallback),\n MMLInteractionGraphicsInterface: (element) =>\n new PlayCanvasElements.PlayCanvasInteraction(element),\n MMLLabelGraphicsInterface: (element) => new PlayCanvasElements.PlayCanvasLabel(element),\n MMLLightGraphicsInterface: (element) => new PlayCanvasElements.PlayCanvasLight(element),\n MMLLinkGraphicsInterface: (element) => new PlayCanvasElements.PlayCanvasLink(element),\n MMLModelGraphicsInterface: (element, updateMeshCallback: () => void) =>\n new PlayCanvasElements.PlayCanvasModel(element, updateMeshCallback),\n MMLPlaneGraphicsInterface: (element) => new PlayCanvasElements.PlayCanvasPlane(element),\n MMLPositionProbeGraphicsInterface: (element) =>\n new PlayCanvasElements.PlayCanvasPositionProbe(element),\n MMLPromptGraphicsInterface: (element) => new PlayCanvasElements.PlayCanvasPrompt(element),\n MMLSphereGraphicsInterface: (element) => new PlayCanvasElements.PlayCanvasSphere(element),\n MMLTransformableGraphicsInterface: (element) =>\n new PlayCanvasElements.PlayCanvasTransformable(element),\n MMLVideoGraphicsInterface: (element, updateMeshCallback: () => void) =>\n new PlayCanvasElements.PlayCanvasVideo(element, updateMeshCallback),\n RemoteDocumentGraphicsInterface: (element) =>\n new PlayCanvasElements.PlayCanvasRemoteDocument(element),\n};\n", "import { Interaction } from \"@mml-io/mml-web\";\nimport * as playcanvas from \"playcanvas\";\n\nimport { PlayCanvasGraphicsAdapter } from \"./PlayCanvasGraphicsAdapter\";\n\nexport class PlayCanvasInteractionAdapter {\n static interactionShouldShowDistance(\n interaction: Interaction,\n cameraEntity: playcanvas.Entity,\n cameraComponent: playcanvas.CameraComponent,\n app: playcanvas.AppBase,\n ): number | null {\n const worldPos = interaction.getContainer().getPosition();\n\n const cameraPos = cameraEntity.getPosition();\n const distance = cameraPos.distance(worldPos);\n if (distance > interaction.props.range) {\n return null;\n }\n\n if (interaction.props.inFocus) {\n if (!cameraComponent.frustum.containsPoint(worldPos)) {\n return null;\n }\n }\n\n if (interaction.props.lineOfSight) {\n const rigidbodySystem = app.systems.rigidbody;\n if (!rigidbodySystem) {\n console.warn(\"Rigidbody system not found. Line of sight check will not work.\");\n } else {\n const raycastResults = rigidbodySystem.raycastAll(cameraPos, worldPos);\n if (raycastResults.length > 0) {\n for (const result of raycastResults) {\n if (\n !PlayCanvasInteractionAdapter.hasAncestor(result.entity, interaction.getContainer())\n ) {\n return null;\n }\n }\n }\n }\n }\n\n return distance;\n }\n\n static hasAncestor(object: playcanvas.Entity, ancestor: playcanvas.Entity): boolean {\n let parent = object.parent;\n while (parent !== null) {\n if (parent === ancestor) {\n return true;\n }\n parent = parent.parent;\n }\n return false;\n }\n}\n", "import { EventHandlerCollection, IVect3, Matr4, Quat } from \"@mml-io/mml-web\";\nimport * as playcanvas from \"playcanvas\";\n\nconst up = { x: 0, y: 1, z: 0 };\nconst right = { x: 1, y: 0, z: 0 };\nconst quaternion = new Quat();\nconst qPitch = new Quat();\nconst qYaw = new Quat();\n\n// Creates a set of 5DOF flight controls that requires dragging the mouse to move the rotation and position of the camera\nexport class PlayCanvasDragFlyCameraControls {\n public readonly type = \"drag-fly\";\n\n private enabled = false;\n\n private camera: playcanvas.Entity;\n private domElement: HTMLElement;\n\n private speed: number;\n private yaw = 0;\n private pitch = 0;\n\n private forward = false;\n private backward = false;\n private left = false;\n private right = false;\n private up = false;\n private down = false;\n\n // Set to constrain the pitch of the camera\n private minPolarAngle = 0 * (Math.PI / 180);\n private maxPolarAngle = 180 * (Math.PI / 180);\n\n private invertedMouseY = false;\n\n private eventHandlerCollection: EventHandlerCollection = new EventHandlerCollection();\n private mouseDown = false;\n\n constructor(camera: playcanvas.Entity, domElement: HTMLElement, speed = 15.0) {\n this.camera = camera;\n this.domElement = domElement;\n this.domElement.style.userSelect = \"none\";\n this.speed = speed;\n }\n\n public fitContent(boundingBox: { min: IVect3; max: IVect3 }) {\n const center = {\n x: (boundingBox.min.x + boundingBox.max.x) / 2,\n y: (boundingBox.min.y + boundingBox.max.y) / 2,\n z: (boundingBox.min.z + boundingBox.max.z) / 2,\n };\n const size = {\n x: boundingBox.max.x - boundingBox.min.x,\n y: boundingBox.max.y - boundingBox.min.y,\n z: boundingBox.max.z - boundingBox.min.z,\n };\n const fov = this.camera?.camera?.fov || 1;\n const maximumDimension = Math.max(size.x, size.y, size.z);\n const distance = Math.abs(maximumDimension / 4 / Math.tan(fov / 2));\n const currentCameraRay = this.camera.forward.clone().normalize();\n currentCameraRay.mulScalar(-distance);\n this.camera.setLocalPosition(\n center.x + currentCameraRay.x,\n center.y + currentCameraRay.y,\n center.z + currentCameraRay.z,\n );\n this.setLookAt(center.x, center.y, center.z);\n }\n\n public enable() {\n if (this.enabled) {\n return;\n }\n this.enabled = true;\n this.eventHandlerCollection.add(document, \"keydown\", this.onKeyDown.bind(this));\n this.eventHandlerCollection.add(document, \"keyup\", this.onKeyUp.bind(this));\n this.eventHandlerCollection.add(window, \"blur\", this.onBlur.bind(this));\n this.eventHandlerCollection.add(document, \"mousemove\", this.onMouseMove.bind(this));\n this.eventHandlerCollection.add(this.domElement, \"mousedown\", this.onMouseDown.bind(this));\n this.eventHandlerCollection.add(document, \"mouseup\", this.onMouseUp.bind(this));\n this.eventHandlerCollection.add(document, \"wheel\", this.onMouseWheel.bind(this));\n }\n\n public disable() {\n if (!this.enabled) {\n return;\n }\n this.eventHandlerCollection.clear();\n this.enabled = false;\n }\n\n public setInvert(invert: boolean) {\n this.invertedMouseY = invert;\n }\n\n public dispose() {\n this.disable();\n }\n\n public setCameraPosition(x: number, y: number, z: number) {\n this.camera.setLocalPosition(x, y, z);\n }\n\n public setLookAt(x: number, y: number, z: number) {\n this.camera.lookAt(x, y, z);\n const { yaw, pitch } = getYawPitchFromQuaternion(this.camera.getRotation());\n this.yaw = yaw;\n this.pitch = pitch;\n this.updateCameraFromYawAndPitch();\n }\n\n public update(dt: number) {\n if (!this.mouseDown) {\n return;\n }\n\n this.camera.translateLocal(\n (Number(this.right) - Number(this.left)) * dt * 30,\n (Number(this.up) - Number(this.down)) * dt * 30,\n (Number(this.backward) - Number(this.forward)) * dt * 30,\n );\n }\n\n private onKeyDown(event: KeyboardEvent) {\n if (!this.mouseDown) {\n return;\n }\n switch (event.code) {\n case \"ArrowUp\":\n case \"KeyW\":\n this.forward = true;\n break;\n case \"ArrowLeft\":\n case \"KeyA\":\n this.left = true;\n break;\n case \"ArrowDown\":\n case \"KeyS\":\n this.backward = true;\n break;\n case \"ArrowRight\":\n case \"KeyD\":\n this.right = true;\n break;\n case \"Space\":\n this.up = true;\n break;\n case \"ShiftLeft\":\n this.down = true;\n break;\n }\n event.preventDefault();\n }\n\n private onKeyUp(event: KeyboardEvent) {\n switch (event.code) {\n case \"ArrowUp\":\n case \"KeyW\":\n this.forward = false;\n break;\n case \"ArrowLeft\":\n case \"KeyA\":\n this.left = false;\n break;\n case \"ArrowDown\":\n case \"KeyS\":\n this.backward = false;\n break;\n case \"ArrowRight\":\n case \"KeyD\":\n this.right = false;\n break;\n case \"Space\":\n this.up = false;\n break;\n case \"ShiftLeft\":\n this.down = false;\n break;\n }\n }\n\n private onBlur() {\n this.mouseDown = false;\n this.forward = false;\n this.left = false;\n this.backward = false;\n this.right = false;\n this.up = false;\n this.down = false;\n }\n\n private onMouseDown() {\n this.mouseDown = true;\n }\n\n private onMouseMove(event: MouseEvent) {\n if (!this.mouseDown) {\n return;\n }\n const movementX = event.movementX;\n let movementY = event.movementY;\n\n if (this.invertedMouseY) {\n movementY *= -1;\n }\n\n this.yaw += movementX * -0.002;\n this.pitch += movementY * -0.002;\n this.updateCameraFromYawAndPitch();\n }\n\n private updateCameraFromYawAndPitch() {\n this.yaw = this.yaw % (Math.PI * 2);\n this.pitch = this.pitch % (Math.PI * 2);\n this.pitch = Math.max(\n Math.PI / 2 - this.maxPolarAngle,\n Math.min(Math.PI / 2 - this.minPolarAngle, this.pitch),\n );\n\n qPitch.setFromAxisAngle(right, this.pitch);\n qYaw.setFromAxisAngle(up, this.yaw);\n\n quaternion.set(0, 0, 0, 1);\n quaternion.multiply(qYaw);\n quaternion.multiply(qPitch);\n\n this.camera.setLocalRotation(quaternion.x, quaternion.y, quaternion.z, quaternion.w);\n }\n\n private onMouseUp() {\n this.mouseDown = false;\n }\n\n private onMouseWheel(event: WheelEvent) {\n if (!this.mouseDown) {\n return;\n }\n this.speed -= event.deltaY * 0.1;\n\n // restrict to a reasonable min and max\n this.speed = Math.max(5, Math.min(this.speed, 1000));\n }\n}\n\nfunction clamp(value: number, min: number, max: number) {\n return Math.max(min, Math.min(max, value));\n}\n\nfunction getYawPitchFromQuaternion(quaternion: { x: number; y: number; z: number; w: number }) {\n const matr4 = new Matr4();\n matr4.setRotationFromQuaternion(quaternion);\n\n const d = matr4.data;\n const m11 = d[0];\n const m13 = d[8];\n const m23 = d[9];\n const m31 = d[2];\n const m33 = d[10];\n\n const yaw = Math.abs(m23) < 0.9999999 ? Math.atan2(m13, m33) : Math.atan2(-m31, m11);\n const pitch = Math.asin(-clamp(m23, -1, 1));\n return { yaw, pitch };\n}\n", "import { EventHandlerCollection, IVect3, Vect3 } from \"@mml-io/mml-web\";\nimport * as playcanvas from \"playcanvas\";\n\nimport { PlayCanvasControls } from \"./PlayCanvasControls\";\n\nexport class PlayCanvasOrbitCameraControls implements PlayCanvasControls {\n public readonly type = \"orbit\";\n\n private enabled = false;\n\n private degreesPerSecond = 10;\n private yaw = 0;\n private pitch = Math.PI * 0.4;\n\n // Set to constrain the pitch of the camera\n private minPolarAngle = -89.9999 * (Math.PI / 180);\n private maxPolarAngle = 89.9999 * (Math.PI / 180);\n\n private invertedMouseY = false;\n\n private eventHandlerCollection: EventHandlerCollection = new EventHandlerCollection();\n private mouseDown = false;\n private cameraLookAt: Vect3 = new Vect3();\n\n constructor(\n private camera: playcanvas.Entity,\n private domElement: HTMLElement,\n private distance = 15.0,\n ) {\n this.domElement.style.userSelect = \"none\";\n }\n\n public fitContent(boundingBox: { min: IVect3; max: IVect3 }) {\n const center = {\n x: (boundingBox.min.x + boundingBox.max.x) / 2,\n y: (boundingBox.min.y + boundingBox.max.y) / 2,\n z: (boundingBox.min.z + boundingBox.max.z) / 2,\n };\n const size = {\n x: boundingBox.max.x - boundingBox.min.x,\n y: boundingBox.max.y - boundingBox.min.y,\n z: boundingBox.max.z - boundingBox.min.z,\n };\n const fov = this.camera?.camera?.fov || 1;\n const maximumDimension = Math.max(size.x, size.y, size.z);\n this.distance = Math.abs(maximumDimension / 4 / Math.tan(fov / 2));\n this.setLookAt(center.x, center.y, center.z);\n this.update();\n }\n\n public enable() {\n if (this.enabled) {\n return;\n }\n this.enabled = true;\n this.eventHandlerCollection.add(window, \"blur\", this.onBlur.bind(this));\n this.eventHandlerCollection.add(document, \"mousemove\", this.onMouseMove.bind(this));\n this.eventHandlerCollection.add(this.domElement, \"mousedown\", this.onMouseDown.bind(this));\n this.eventHandlerCollection.add(document, \"mouseup\", this.onMouseUp.bind(this));\n this.eventHandlerCollection.add(document, \"wheel\", this.onMouseWheel.bind(this));\n }\n\n public disable() {\n if (!this.enabled) {\n return;\n }\n this.eventHandlerCollection.clear();\n this.enabled = false;\n }\n\n public setInvert(invert: boolean) {\n this.invertedMouseY = invert;\n }\n\n public dispose() {\n this.disable();\n }\n\n private getBaseYaw(): number {\n return (-((Date.now() / 1000) * this.degreesPerSecond) % 360) * (Math.PI / 180);\n }\n\n public update() {\n const baseYaw = this.getBaseYaw();\n const yaw = baseYaw + this.yaw;\n const sinPhiRadius = Math.sin(this.pitch) * this.distance;\n const x = sinPhiRadius * Math.sin(yaw);\n const y = Math.cos(this.pitch) * this.distance;\n const z = sinPhiRadius * Math.cos(yaw);\n\n this.camera.setPosition(x, y, z);\n this.camera.translate(this.cameraLookAt.x, this.cameraLookAt.y, this.cameraLookAt.z);\n\n this.camera.lookAt(this.cameraLookAt.x, this.cameraLookAt.y, this.cameraLookAt.z);\n }\n\n private onBlur() {\n this.mouseDown = false;\n }\n\n private onMouseDown() {\n this.mouseDown = true;\n }\n\n public setDegreesPerSecond(degreesPerSecond: number) {\n this.degreesPerSecond = degreesPerSecond;\n }\n\n public setLookAt(x: number, y: number, z: number) {\n this.cameraLookAt.set(x, y, z);\n }\n\n public setDistance(distance: number) {\n this.distance = distance;\n }\n\n public setPitchDegrees(pitch: number) {\n this.pitch = pitch * (Math.PI / 180);\n this.pitch = this.pitch % (Math.PI * 2);\n }\n\n private onMouseMove(event: MouseEvent) {\n if (!this.mouseDown) {\n return;\n }\n const movementX = event.movementX;\n let movementY = event.movementY;\n\n if (this.invertedMouseY) {\n movementY *= -1;\n }\n\n this.yaw += movementX * -0.002;\n this.pitch += movementY * -0.002;\n this.yaw = this.yaw % (Math.PI * 2);\n this.pitch = this.pitch % (Math.PI * 2);\n this.pitch = Math.max(\n Math.PI / 2 - this.maxPolarAngle,\n Math.min(Math.PI / 2 - this.minPolarAngle, this.pitch),\n );\n }\n private onMouseUp() {\n this.mouseDown = false;\n }\n\n private onMouseWheel(event: WheelEvent) {\n this.distance += event.deltaY * 0.1;\n this.distance = Math.max(0.01, Math.min(this.distance, 1000));\n }\n}\n", "import {\n Interaction,\n Matr4,\n MMLGraphicsInterface,\n TransformableElement,\n Vect3,\n} from \"@mml-io/mml-web\";\nimport {\n PlayCanvasClickTrigger,\n PlayCanvasGraphicsAdapter,\n PlayCanvasGraphicsInterface,\n PlayCanvasInteractionAdapter,\n} from \"@mml-io/mml-web-playcanvas\";\nimport ammoWasmJs from \"base64:./wasm/ammo.wasm.js\";\nimport ammoWasmWasm from \"base64:./wasm/ammo.wasm.wasm\";\nimport dracoWasmJs from \"base64:./wasm/draco.wasm.js\";\nimport dracoWasmWasm from \"base64:./wasm/draco.wasm.wasm\";\nimport glslangWasmJs from \"base64:./wasm/glslang.js\";\nimport twgslWasmJs from \"base64:./wasm/twgsl.js\";\nimport * as playcanvas from \"playcanvas\";\n\nimport { PlayCanvasOrbitCameraControls } from \"./controls\";\nimport { PlayCanvasControls } from \"./controls/PlayCanvasControls\";\nimport { PlayCanvasDragFlyCameraControls } from \"./controls/PlayCanvasDragFlyCameraControls\";\n\nexport enum StandalonePlayCanvasAdapterControlsType {\n None,\n DragFly,\n Orbit,\n}\n\nexport type StandalonePlayCanvasAdapterOptions = {\n controlsType?: StandalonePlayCanvasAdapterControlsType;\n};\n\nexport class StandalonePlayCanvasAdapter implements PlayCanvasGraphicsAdapter {\n containerType: playcanvas.Entity;\n collisionType: playcanvas.Entity;\n\n private playcanvasApp: playcanvas.AppBase;\n\n public controls: PlayCanvasControls | null = null;\n private camera: playcanvas.Entity;\n private canvas: HTMLCanvasElement | null = null;\n\n private clickTrigger: PlayCanvasClickTrigger;\n\n private constructor(\n private element: HTMLElement,\n private options: StandalonePlayCanvasAdapterOptions,\n ) {}\n\n getPlayCanvasApp(): playcanvas.AppBase {\n return this.playcanvasApp;\n }\n\n getCamera(): playcanvas.Entity {\n return this.camera;\n }\n\n public getGraphicsAdapterFactory(): MMLGraphicsInterface {\n return PlayCanvasGraphicsInterface as MMLGraphicsInterface;\n }\n\n public static async create(\n element: HTMLElement,\n options: StandalonePlayCanvasAdapterOptions,\n ): Promise {\n const adapter = new StandalonePlayCanvasAdapter(element, options);\n await adapter.init();\n return adapter;\n }\n\n public interactionShouldShowDistance(interaction: Interaction): number | null {\n const cameraComponent = this.camera.camera;\n if (!cameraComponent) {\n console.error(\"Camera component not found\");\n return null;\n }\n return PlayCanvasInteractionAdapter.interactionShouldShowDistance(\n interaction,\n this.camera,\n cameraComponent,\n this.playcanvasApp,\n );\n }\n\n async init() {\n playcanvas.WasmModule.setConfig(\"Ammo\", {\n glueUrl: \"data:text/javascript;base64,\" + ammoWasmJs,\n wasmUrl: \"data:application/octet-stream;base64,\" + ammoWasmWasm,\n });\n await new Promise((resolve) => {\n playcanvas.WasmModule.getInstance(\"Ammo\", () => resolve());\n });\n\n playcanvas.WasmModule.setConfig(\"DracoDecoderModule\", {\n glueUrl: \"data:text/javascript;base64,\" + dracoWasmJs,\n wasmUrl: \"data:application/wasm;base64,\" + dracoWasmWasm,\n });\n\n this.canvas = document.createElement(\"canvas\");\n this.canvas.style.pointerEvents = \"none\";\n this.element.appendChild(this.canvas);\n\n this.playcanvasApp = new playcanvas.AppBase(this.canvas);\n\n const gfxOptions = {\n deviceTypes: [\"webgpu\", \"webgl2\"],\n glslangUrl: \"data:text/javascript;base64,\" + glslangWasmJs,\n twgslUrl: \"data:text/javascript;base64,\" + twgslWasmJs,\n };\n\n const soundManager = new playcanvas.SoundManager();\n const device = await playcanvas.createGraphicsDevice(this.canvas, gfxOptions);\n device.maxPixelRatio = window.devicePixelRatio;\n const createOptions = new playcanvas.AppOptions();\n createOptions.soundManager = soundManager;\n createOptions.graphicsDevice = device;\n createOptions.componentSystems = [\n playcanvas.RenderComponentSystem,\n playcanvas.CollisionComponentSystem,\n playcanvas.RigidBodyComponentSystem,\n playcanvas.CameraComponentSystem,\n playcanvas.LightComponentSystem,\n playcanvas.ModelComponentSystem,\n playcanvas.AnimComponentSystem,\n playcanvas.SoundComponentSystem,\n playcanvas.AudioListenerComponentSystem,\n ];\n createOptions.resourceHandlers = [\n playcanvas.AudioHandler,\n playcanvas.TextureHandler,\n playcanvas.ContainerHandler,\n playcanvas.ModelHandler,\n playcanvas.AnimationHandler,\n ];\n this.playcanvasApp.init(createOptions);\n this.playcanvasApp.scene.physicalUnits = true;\n this.playcanvasApp.setCanvasFillMode(playcanvas.FILLMODE_NONE);\n this.playcanvasApp.setCanvasResolution(playcanvas.RESOLUTION_FIXED);\n\n // Set the canvas size to non-zero to avoid errors on startup\n device.resizeCanvas(128, 128);\n\n this.camera = new playcanvas.Entity(\"camera\", this.playcanvasApp);\n this.camera.addComponent(\"audiolistener\");\n this.camera.addComponent(\"camera\", {\n fov: 75,\n clearColor: new playcanvas.Color(1, 1, 1, 1),\n } as playcanvas.CameraComponent);\n this.camera.setPosition(0, 5, 10);\n this.playcanvasApp.root.addChild(this.camera);\n\n this.setControlsType(this.options.controlsType);\n\n this.clickTrigger = PlayCanvasClickTrigger.init(this.playcanvasApp, this.element, this.camera);\n\n this.playcanvasApp.on(\"update\", (delta) => {\n if (this.controls) {\n this.controls.update(delta);\n }\n });\n\n this.playcanvasApp.start();\n }\n\n public setControlsType(type?: StandalonePlayCanvasAdapterControlsType) {\n if (this.controls) {\n this.controls.dispose();\n this.controls = null;\n }\n switch (type) {\n case StandalonePlayCanvasAdapterControlsType.None:\n break;\n case StandalonePlayCanvasAdapterControlsType.Orbit:\n this.controls = new PlayCanvasOrbitCameraControls(this.camera, this.element);\n break;\n case StandalonePlayCanvasAdapterControlsType.DragFly:\n default:\n this.controls = new PlayCanvasDragFlyCameraControls(this.camera, this.element);\n break;\n }\n if (this.controls) {\n this.controls.enable();\n }\n }\n\n public setCameraFOV(fov: number) {\n const cameraComponent = this.camera.camera;\n if (!cameraComponent) {\n console.error(\"Camera component not found\");\n return null;\n }\n cameraComponent.fov = fov;\n }\n\n start() {}\n\n getUserPositionAndRotation() {\n const position = this.camera.getPosition();\n const rotation = this.camera.getEulerAngles();\n return {\n position: {\n x: position.x,\n y: position.y,\n z: position.z,\n },\n rotation: {\n x: rotation.x,\n y: rotation.y,\n z: rotation.z,\n },\n };\n }\n\n resize(width: number, height: number) {\n this.playcanvasApp.resizeCanvas(width, height);\n this.playcanvasApp.graphicsDevice.resizeCanvas(width, height);\n }\n\n dispose() {\n this.playcanvasApp.destroy();\n if (this.canvas) {\n this.canvas.remove();\n this.canvas = null;\n }\n if (this.controls) {\n this.controls.dispose();\n }\n this.clickTrigger.dispose();\n }\n\n getRootContainer() {\n return this.playcanvasApp.root;\n }\n\n public getBoundingBoxForElement(element: HTMLElement): {\n x: number;\n y: number;\n width: number;\n height: number;\n } | null {\n if (!(element instanceof TransformableElement)) {\n return null;\n }\n\n const bounds = element.getContentBounds();\n if (!bounds) {\n return null;\n }\n\n const camera = this.camera;\n const cameraComponent = camera.camera;\n if (!cameraComponent) {\n throw new Error(\"Camera component not found\");\n }\n\n const renderer = this.playcanvasApp.graphicsDevice;\n const clientWidth = renderer.canvas.clientWidth;\n const clientHeight = renderer.canvas.clientHeight;\n\n // Custom function to convert 3D Vector3 to 2D canvas coordinates\n const toCanvasCoords = (point: Vect3) => {\n const vec = point\n .clone()\n .applyMatrix4(new Matr4(camera.getWorldTransform().clone().invert().data))\n .applyMatrix4(new Matr4(cameraComponent.projectionMatrix.data));\n vec.x = ((vec.x + 1) / 2) * clientWidth;\n vec.y = ((1 - vec.y) / 2) * clientHeight;\n return vec;\n };\n\n // Project the 3D bounding box corners into 2D canvas coordinates\n const corners3D = bounds.getCorners();\n const corners2D = corners3D.map(toCanvasCoords);\n\n // Calculate the 2D bounding box from the projected canvas coordinates\n const minX = Math.min(...corners2D.map((corner) => corner.x));\n const maxX = Math.max(...corners2D.map((corner) => corner.x));\n const minY = Math.min(...corners2D.map((corner) => corner.y));\n const maxY = Math.max(...corners2D.map((corner) => corner.y));\n\n return {\n x: minX,\n y: minY,\n width: maxX - minX,\n height: maxY - minY,\n };\n }\n}\n", "// This is ammo.js, a port of Bullet Physics to JavaScript. zlib licensed.

var Ammo = (function() {
    var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined;
    if (typeof __filename !== 'undefined')
      _scriptDir = _scriptDir || __filename;
    return (function(Ammo) {
        Ammo = Ammo || {};

        var b;
        b || (b = typeof Ammo !== 'undefined' ? Ammo : {});
        var aa = {}, ba;
        for (ba in b)
          b.hasOwnProperty(ba) && (aa[ba] = b[ba]);
        var ca = !1
          , da = !1
          , ea = !1
          , fa = !1;
        ca = "object" === typeof window;
        da = "function" === typeof importScripts;
        ea = "object" === typeof process && "object" === typeof process.versions && "string" === typeof process.versions.node;
        fa = !ca && !ea && !da;
        var ha = "", ja, ka, la, ma;
        if (ea)
          ha = da ? require("path").dirname(ha) + "/" : __dirname + "/",
            ja = function(a, c) {
              la || (la = require("fs"));
              ma || (ma = require("path"));
              a = ma.normalize(a);
              return la.readFileSync(a, c ? null : "utf8")
            }
            ,
            ka = function(a) {
              a = ja(a, !0);
              a.buffer || (a = new Uint8Array(a));
              assert(a.buffer);
              return a
            }
            ,
          1 < process.argv.length && process.argv[1].replace(/\\/g, "/"),
            process.argv.slice(2),
            process.on("uncaughtException", function(a) {
              throw a;
            }),
            process.on("unhandledRejection", na),
            b.inspect = function() {
              return "[Emscripten Module object]"
            }
          ;
        else if (fa)
          "undefined" != typeof read && (ja = function(a) {
              return read(a)
            }
          ),
            ka = function(a) {
              if ("function" === typeof readbuffer)
                return new Uint8Array(readbuffer(a));
              a = read(a, "binary");
              assert("object" === typeof a);
              return a
            }
            ,
          "undefined" !== typeof print && ("undefined" === typeof console && (console = {}),
            console.log = print,
            console.warn = console.error = "undefined" !== typeof printErr ? printErr : print);
        else if (ca || da)
          da ? ha = self.location.href : document.currentScript && (ha = document.currentScript.src),
          _scriptDir && (ha = _scriptDir),
            ha = 0 !== ha.indexOf("blob:") ? ha.substr(0, ha.lastIndexOf("/") + 1) : "",
            ja = function(a) {
              var c = new XMLHttpRequest;
              c.open("GET", a, !1);
              c.send(null);
              return c.responseText
            }
            ,
          da && (ka = function(a) {
              var c = new XMLHttpRequest;
              c.open("GET", a, !1);
              c.responseType = "arraybuffer";
              c.send(null);
              return new Uint8Array(c.response)
            }
          );
        var oa = b.print || console.log.bind(console)
          , pa = b.printErr || console.warn.bind(console);
        for (ba in aa)
          aa.hasOwnProperty(ba) && (b[ba] = aa[ba]);
        aa = null;
        var qa = [], ra, sa;
        b.wasmBinary && (sa = b.wasmBinary);
        var noExitRuntime;
        b.noExitRuntime && (noExitRuntime = b.noExitRuntime);
        "object" !== typeof WebAssembly && pa("no native wasm support detected");
        var ta, ua = new WebAssembly.Table({
          initial: 935,
          maximum: 955,
          element: "anyfunc"
        }), va = !1;
        function assert(a, c) {
          a || na("Assertion failed: " + c)
        }
        var wa = "undefined" !== typeof TextDecoder ? new TextDecoder("utf8") : void 0;
        function xa(a, c, d) {
          var e = c + d;
          for (d = c; a[d] && !(d >= e); )
            ++d;
          if (16 < d - c && a.subarray && wa)
            return wa.decode(a.subarray(c, d));
          for (e = ""; c < d; ) {
            var f = a[c++];
            if (f & 128) {
              var m = a[c++] & 63;
              if (192 == (f & 224))
                e += String.fromCharCode((f & 31) << 6 | m);
              else {
                var C = a[c++] & 63;
                f = 224 == (f & 240) ? (f & 15) << 12 | m << 6 | C : (f & 7) << 18 | m << 12 | C << 6 | a[c++] & 63;
                65536 > f ? e += String.fromCharCode(f) : (f -= 65536,
                  e += String.fromCharCode(55296 | f >> 10, 56320 | f & 1023))
              }
            } else
              e += String.fromCharCode(f)
          }
          return e
        }
        "undefined" !== typeof TextDecoder && new TextDecoder("utf-16le");
        var ya, za, Aa, Ba, Ca, Da, Ea = b.INITIAL_MEMORY || 67108864;
        if (ta = b.wasmMemory ? b.wasmMemory : new WebAssembly.Memory({
          initial: Ea / 65536,
          maximum: Ea / 65536
        }))
          ya = ta.buffer;
        Ea = ya.byteLength;
        var Fa = ya;
        ya = Fa;
        b.HEAP8 = za = new Int8Array(Fa);
        b.HEAP16 = new Int16Array(Fa);
        b.HEAP32 = Ba = new Int32Array(Fa);
        b.HEAPU8 = Aa = new Uint8Array(Fa);
        b.HEAPU16 = new Uint16Array(Fa);
        b.HEAPU32 = new Uint32Array(Fa);
        b.HEAPF32 = Ca = new Float32Array(Fa);
        b.HEAPF64 = Da = new Float64Array(Fa);
        Ba[8080] = 5275360;
        function Ga(a) {
          for (; 0 < a.length; ) {
            var c = a.shift();
            if ("function" == typeof c)
              c(b);
            else {
              var d = c.Ky;
              "number" === typeof d ? void 0 === c.vy ? b.dynCall_v(d) : b.dynCall_vi(d, c.vy) : d(void 0 === c.vy ? null : c.vy)
            }
          }
        }
        var Ha = []
          , Ia = []
          , Ja = []
          , Ka = []
          , La = !1;
        function Ma() {
          var a = b.preRun.shift();
          Ha.unshift(a)
        }
        var Na = 0
          , Oa = null
          , Pa = null;
        b.preloadedImages = {};
        b.preloadedAudios = {};
        function na(a) {
          if (b.onAbort)
            b.onAbort(a);
          a += "";
          oa(a);
          pa(a);
          va = !0;
          throw new WebAssembly.RuntimeError("abort(" + a + "). Build with -s ASSERTIONS=1 for more info.");
        }
        function Qa() {
          var a = Ra;
          return String.prototype.startsWith ? a.startsWith("data:application/octet-stream;base64,") : 0 === a.indexOf("data:application/octet-stream;base64,")
        }
        var Ra = "ammo.wasm.wasm";
        if (!Qa()) {
          var Sa = Ra;
          Ra = b.locateFile ? b.locateFile(Sa, ha) : ha + Sa
        }
        function Ta() {
          try {
            if (sa)
              return new Uint8Array(sa);
            if (ka)
              return ka(Ra);
            throw "both async and sync fetching of the wasm failed";
          } catch (a) {
            na(a)
          }
        }
        function Ua() {
          return sa || !ca && !da || "function" !== typeof fetch ? new Promise(function(a) {
              a(Ta())
            }
          ) : fetch(Ra, {
            credentials: "same-origin"
          }).then(function(a) {
            if (!a.ok)
              throw "failed to load wasm binary file at '" + Ra + "'";
            return a.arrayBuffer()
          }).catch(function() {
            return Ta()
          })
        }
        var Va = {
          1864: function(a, c, d, e, f, m, C, P) {
            a = b.getCache(b.ConcreteContactResultCallback)[a];
            if (!a.hasOwnProperty("addSingleResult"))
              throw "a JSImplementation must implement all functions, you forgot ConcreteContactResultCallback::addSingleResult.";
            return a.addSingleResult(c, d, e, f, m, C, P)
          },
          2424: function(a, c, d, e) {
            a = b.getCache(b.DebugDrawer)[a];
            if (!a.hasOwnProperty("drawLine"))
              throw "a JSImplementation must implement all functions, you forgot DebugDrawer::drawLine.";
            a.drawLine(c, d, e)
          },
          2649: function(a, c, d, e, f, m) {
            a = b.getCache(b.DebugDrawer)[a];
            if (!a.hasOwnProperty("drawContactPoint"))
              throw "a JSImplementation must implement all functions, you forgot DebugDrawer::drawContactPoint.";
            a.drawContactPoint(c, d, e, f, m)
          },
          2906: function(a, c) {
            a = b.getCache(b.DebugDrawer)[a];
            if (!a.hasOwnProperty("reportErrorWarning"))
              throw "a JSImplementation must implement all functions, you forgot DebugDrawer::reportErrorWarning.";
            a.reportErrorWarning(c)
          },
          3153: function(a, c, d) {
            a = b.getCache(b.DebugDrawer)[a];
            if (!a.hasOwnProperty("draw3dText"))
              throw "a JSImplementation must implement all functions, you forgot DebugDrawer::draw3dText.";
            a.draw3dText(c, d)
          },
          3380: function(a, c) {
            a = b.getCache(b.DebugDrawer)[a];
            if (!a.hasOwnProperty("setDebugMode"))
              throw "a JSImplementation must implement all functions, you forgot DebugDrawer::setDebugMode.";
            a.setDebugMode(c)
          },
          3606: function(a) {
            a = b.getCache(b.DebugDrawer)[a];
            if (!a.hasOwnProperty("getDebugMode"))
              throw "a JSImplementation must implement all functions, you forgot DebugDrawer::getDebugMode.";
            return a.getDebugMode()
          }
        };
        Ia.push({
          Ky: function() {
            Wa()
          }
        });
        var Xa = [null, [], []];
        function Ya(a, c) {
          Za || (Za = []);
          var d = Za;
          d.length = 0;
          for (var e; e = Aa[a++]; )
            100 === e || 102 === e ? (c = c + 7 & -8,
              d.push(Da[c >> 3]),
              c += 8) : (c = c + 3 & -4,
              d.push(Ba[c >> 2]),
              c += 4);
          return d
        }
        var Za, $a = {
          i: function() {
            na()
          },
          d: function(a, c, d) {
            c = Ya(c, d);
            return Va[a].apply(null, c)
          },
          a: function(a, c, d) {
            c = Ya(c, d);
            return Va[a].apply(null, c)
          },
          f: function(a, c, d) {
            Aa.copyWithin(a, c, c + d)
          },
          g: function() {
            na("OOM")
          },
          h: function() {
            return 0
          },
          e: function() {},
          c: function(a, c, d, e) {
            for (var f = 0, m = 0; m < d; m++) {
              for (var C = Ba[c + 8 * m >> 2], P = Ba[c + (8 * m + 4) >> 2], ia = 0; ia < P; ia++) {
                var nb = Aa[C + ia]
                  , Wb = Xa[a];
                0 === nb || 10 === nb ? ((1 === a ? oa : pa)(xa(Wb, 0)),
                  Wb.length = 0) : Wb.push(nb)
              }
              f += P
            }
            Ba[e >> 2] = f;
            return 0
          },
          b: function(a) {
            var c = Date.now();
            Ba[a >> 2] = c / 1E3 | 0;
            Ba[a + 4 >> 2] = c % 1E3 * 1E3 | 0;
            return 0
          },
          memory: ta,
          table: ua
        }, ab = function() {
          function a(f) {
            b.asm = f.exports;
            Na--;
            b.monitorRunDependencies && b.monitorRunDependencies(Na);
            0 == Na && (null !== Oa && (clearInterval(Oa),
              Oa = null),
            Pa && (f = Pa,
              Pa = null,
              f()))
          }
          function c(f) {
            a(f.instance)
          }
          function d(f) {
            return Ua().then(function(m) {
              return WebAssembly.instantiate(m, e)
            }).then(f, function(m) {
              pa("failed to asynchronously prepare wasm: " + m);
              na(m)
            })
          }
          var e = {
            a: $a
          };
          Na++;
          b.monitorRunDependencies && b.monitorRunDependencies(Na);
          if (b.instantiateWasm)
            try {
              return b.instantiateWasm(e, a)
            } catch (f) {
              return pa("Module.instantiateWasm callback failed with error: " + f),
                !1
            }
          (function() {
              if (sa || "function" !== typeof WebAssembly.instantiateStreaming || Qa() || "function" !== typeof fetch)
                return d(c);
              fetch(Ra, {
                credentials: "same-origin"
              }).then(function(f) {
                return WebAssembly.instantiateStreaming(f, e).then(c, function(m) {
                  pa("wasm streaming compile failed: " + m);
                  pa("falling back to ArrayBuffer instantiation");
                  d(c)
                })
              })
            }
          )();
          return {}
        }();
        b.asm = ab;
        var Wa = b.___wasm_call_ctors = function() {
            return (Wa = b.___wasm_call_ctors = b.asm.j).apply(null, arguments)
          }
          , bb = b._emscripten_bind_btCollisionWorld_getDispatcher_0 = function() {
            return (bb = b._emscripten_bind_btCollisionWorld_getDispatcher_0 = b.asm.k).apply(null, arguments)
          }
          , cb = b._emscripten_bind_btCollisionWorld_rayTest_3 = function() {
            return (cb = b._emscripten_bind_btCollisionWorld_rayTest_3 = b.asm.l).apply(null, arguments)
          }
          , db = b._emscripten_bind_btCollisionWorld_getPairCache_0 = function() {
            return (db = b._emscripten_bind_btCollisionWorld_getPairCache_0 = b.asm.m).apply(null, arguments)
          }
          , eb = b._emscripten_bind_btCollisionWorld_getDispatchInfo_0 = function() {
            return (eb = b._emscripten_bind_btCollisionWorld_getDispatchInfo_0 = b.asm.n).apply(null, arguments)
          }
          , fb = b._emscripten_bind_btCollisionWorld_addCollisionObject_1 = function() {
            return (fb = b._emscripten_bind_btCollisionWorld_addCollisionObject_1 = b.asm.o).apply(null, arguments)
          }
          , gb = b._emscripten_bind_btCollisionWorld_addCollisionObject_2 = function() {
            return (gb = b._emscripten_bind_btCollisionWorld_addCollisionObject_2 = b.asm.p).apply(null, arguments)
          }
          , hb = b._emscripten_bind_btCollisionWorld_addCollisionObject_3 = function() {
            return (hb = b._emscripten_bind_btCollisionWorld_addCollisionObject_3 = b.asm.q).apply(null, arguments)
          }
          , ib = b._emscripten_bind_btCollisionWorld_removeCollisionObject_1 = function() {
            return (ib = b._emscripten_bind_btCollisionWorld_removeCollisionObject_1 = b.asm.r).apply(null, arguments)
          }
          , jb = b._emscripten_bind_btCollisionWorld_getBroadphase_0 = function() {
            return (jb = b._emscripten_bind_btCollisionWorld_getBroadphase_0 = b.asm.s).apply(null, arguments)
          }
          , kb = b._emscripten_bind_btCollisionWorld_convexSweepTest_5 = function() {
            return (kb = b._emscripten_bind_btCollisionWorld_convexSweepTest_5 = b.asm.t).apply(null, arguments)
          }
          , lb = b._emscripten_bind_btCollisionWorld_contactPairTest_3 = function() {
            return (lb = b._emscripten_bind_btCollisionWorld_contactPairTest_3 = b.asm.u).apply(null, arguments)
          }
          , mb = b._emscripten_bind_btCollisionWorld_contactTest_2 = function() {
            return (mb = b._emscripten_bind_btCollisionWorld_contactTest_2 = b.asm.v).apply(null, arguments)
          }
          , ob = b._emscripten_bind_btCollisionWorld_updateSingleAabb_1 = function() {
            return (ob = b._emscripten_bind_btCollisionWorld_updateSingleAabb_1 = b.asm.w).apply(null, arguments)
          }
          , pb = b._emscripten_bind_btCollisionWorld_setDebugDrawer_1 = function() {
            return (pb = b._emscripten_bind_btCollisionWorld_setDebugDrawer_1 = b.asm.x).apply(null, arguments)
          }
          , qb = b._emscripten_bind_btCollisionWorld_getDebugDrawer_0 = function() {
            return (qb = b._emscripten_bind_btCollisionWorld_getDebugDrawer_0 = b.asm.y).apply(null, arguments)
          }
          , rb = b._emscripten_bind_btCollisionWorld_debugDrawWorld_0 = function() {
            return (rb = b._emscripten_bind_btCollisionWorld_debugDrawWorld_0 = b.asm.z).apply(null, arguments)
          }
          , sb = b._emscripten_bind_btCollisionWorld_debugDrawObject_3 = function() {
            return (sb = b._emscripten_bind_btCollisionWorld_debugDrawObject_3 = b.asm.A).apply(null, arguments)
          }
          , tb = b._emscripten_bind_btCollisionWorld___destroy___0 = function() {
            return (tb = b._emscripten_bind_btCollisionWorld___destroy___0 = b.asm.B).apply(null, arguments)
          }
          , ub = b._emscripten_bind_btCollisionShape_setLocalScaling_1 = function() {
            return (ub = b._emscripten_bind_btCollisionShape_setLocalScaling_1 = b.asm.C).apply(null, arguments)
          }
          , vb = b._emscripten_bind_btCollisionShape_getLocalScaling_0 = function() {
            return (vb = b._emscripten_bind_btCollisionShape_getLocalScaling_0 = b.asm.D).apply(null, arguments)
          }
          , wb = b._emscripten_bind_btCollisionShape_calculateLocalInertia_2 = function() {
            return (wb = b._emscripten_bind_btCollisionShape_calculateLocalInertia_2 = b.asm.E).apply(null, arguments)
          }
          , xb = b._emscripten_bind_btCollisionShape_setMargin_1 = function() {
            return (xb = b._emscripten_bind_btCollisionShape_setMargin_1 = b.asm.F).apply(null, arguments)
          }
          , yb = b._emscripten_bind_btCollisionShape_getMargin_0 = function() {
            return (yb = b._emscripten_bind_btCollisionShape_getMargin_0 = b.asm.G).apply(null, arguments)
          }
          , zb = b._emscripten_bind_btCollisionShape___destroy___0 = function() {
            return (zb = b._emscripten_bind_btCollisionShape___destroy___0 = b.asm.H).apply(null, arguments)
          }
          , Ab = b._emscripten_bind_btCollisionObject_setAnisotropicFriction_2 = function() {
            return (Ab = b._emscripten_bind_btCollisionObject_setAnisotropicFriction_2 = b.asm.I).apply(null, arguments)
          }
          , Bb = b._emscripten_bind_btCollisionObject_getCollisionShape_0 = function() {
            return (Bb = b._emscripten_bind_btCollisionObject_getCollisionShape_0 = b.asm.J).apply(null, arguments)
          }
          , Cb = b._emscripten_bind_btCollisionObject_setContactProcessingThreshold_1 = function() {
            return (Cb = b._emscripten_bind_btCollisionObject_setContactProcessingThreshold_1 = b.asm.K).apply(null, arguments)
          }
          , Db = b._emscripten_bind_btCollisionObject_setActivationState_1 = function() {
            return (Db = b._emscripten_bind_btCollisionObject_setActivationState_1 = b.asm.L).apply(null, arguments)
          }
          , Eb = b._emscripten_bind_btCollisionObject_forceActivationState_1 = function() {
            return (Eb = b._emscripten_bind_btCollisionObject_forceActivationState_1 = b.asm.M).apply(null, arguments)
          }
          , Fb = b._emscripten_bind_btCollisionObject_activate_0 = function() {
            return (Fb = b._emscripten_bind_btCollisionObject_activate_0 = b.asm.N).apply(null, arguments)
          }
          , Gb = b._emscripten_bind_btCollisionObject_activate_1 = function() {
            return (Gb = b._emscripten_bind_btCollisionObject_activate_1 = b.asm.O).apply(null, arguments)
          }
          , Hb = b._emscripten_bind_btCollisionObject_isActive_0 = function() {
            return (Hb = b._emscripten_bind_btCollisionObject_isActive_0 = b.asm.P).apply(null, arguments)
          }
          , Ib = b._emscripten_bind_btCollisionObject_isKinematicObject_0 = function() {
            return (Ib = b._emscripten_bind_btCollisionObject_isKinematicObject_0 = b.asm.Q).apply(null, arguments)
          }
          , Jb = b._emscripten_bind_btCollisionObject_isStaticObject_0 = function() {
            return (Jb = b._emscripten_bind_btCollisionObject_isStaticObject_0 = b.asm.R).apply(null, arguments)
          }
          , Kb = b._emscripten_bind_btCollisionObject_isStaticOrKinematicObject_0 = function() {
            return (Kb = b._emscripten_bind_btCollisionObject_isStaticOrKinematicObject_0 = b.asm.S).apply(null, arguments)
          }
          , Lb = b._emscripten_bind_btCollisionObject_getRestitution_0 = function() {
            return (Lb = b._emscripten_bind_btCollisionObject_getRestitution_0 = b.asm.T).apply(null, arguments)
          }
          , Mb = b._emscripten_bind_btCollisionObject_getFriction_0 = function() {
            return (Mb = b._emscripten_bind_btCollisionObject_getFriction_0 = b.asm.U).apply(null, arguments)
          }
          , Nb = b._emscripten_bind_btCollisionObject_getRollingFriction_0 = function() {
            return (Nb = b._emscripten_bind_btCollisionObject_getRollingFriction_0 = b.asm.V).apply(null, arguments)
          }
          , Ob = b._emscripten_bind_btCollisionObject_setRestitution_1 = function() {
            return (Ob = b._emscripten_bind_btCollisionObject_setRestitution_1 = b.asm.W).apply(null, arguments)
          }
          , Pb = b._emscripten_bind_btCollisionObject_setFriction_1 = function() {
            return (Pb = b._emscripten_bind_btCollisionObject_setFriction_1 = b.asm.X).apply(null, arguments)
          }
          , Qb = b._emscripten_bind_btCollisionObject_setRollingFriction_1 = function() {
            return (Qb = b._emscripten_bind_btCollisionObject_setRollingFriction_1 = b.asm.Y).apply(null, arguments)
          }
          , Rb = b._emscripten_bind_btCollisionObject_getWorldTransform_0 = function() {
            return (Rb = b._emscripten_bind_btCollisionObject_getWorldTransform_0 = b.asm.Z).apply(null, arguments)
          }
          , Sb = b._emscripten_bind_btCollisionObject_getCollisionFlags_0 = function() {
            return (Sb = b._emscripten_bind_btCollisionObject_getCollisionFlags_0 = b.asm._).apply(null, arguments)
          }
          , Tb = b._emscripten_bind_btCollisionObject_setCollisionFlags_1 = function() {
            return (Tb = b._emscripten_bind_btCollisionObject_setCollisionFlags_1 = b.asm.$).apply(null, arguments)
          }
          , Ub = b._emscripten_bind_btCollisionObject_setWorldTransform_1 = function() {
            return (Ub = b._emscripten_bind_btCollisionObject_setWorldTransform_1 = b.asm.aa).apply(null, arguments)
          }
          , Vb = b._emscripten_bind_btCollisionObject_setCollisionShape_1 = function() {
            return (Vb = b._emscripten_bind_btCollisionObject_setCollisionShape_1 = b.asm.ba).apply(null, arguments)
          }
          , Xb = b._emscripten_bind_btCollisionObject_setCcdMotionThreshold_1 = function() {
            return (Xb = b._emscripten_bind_btCollisionObject_setCcdMotionThreshold_1 = b.asm.ca).apply(null, arguments)
          }
          , Yb = b._emscripten_bind_btCollisionObject_setCcdSweptSphereRadius_1 = function() {
            return (Yb = b._emscripten_bind_btCollisionObject_setCcdSweptSphereRadius_1 = b.asm.da).apply(null, arguments)
          }
          , Zb = b._emscripten_bind_btCollisionObject_getUserIndex_0 = function() {
            return (Zb = b._emscripten_bind_btCollisionObject_getUserIndex_0 = b.asm.ea).apply(null, arguments)
          }
          , $b = b._emscripten_bind_btCollisionObject_setUserIndex_1 = function() {
            return ($b = b._emscripten_bind_btCollisionObject_setUserIndex_1 = b.asm.fa).apply(null, arguments)
          }
          , ac = b._emscripten_bind_btCollisionObject_getUserPointer_0 = function() {
            return (ac = b._emscripten_bind_btCollisionObject_getUserPointer_0 = b.asm.ga).apply(null, arguments)
          }
          , bc = b._emscripten_bind_btCollisionObject_setUserPointer_1 = function() {
            return (bc = b._emscripten_bind_btCollisionObject_setUserPointer_1 = b.asm.ha).apply(null, arguments)
          }
          , cc = b._emscripten_bind_btCollisionObject_getBroadphaseHandle_0 = function() {
            return (cc = b._emscripten_bind_btCollisionObject_getBroadphaseHandle_0 = b.asm.ia).apply(null, arguments)
          }
          , dc = b._emscripten_bind_btCollisionObject___destroy___0 = function() {
            return (dc = b._emscripten_bind_btCollisionObject___destroy___0 = b.asm.ja).apply(null, arguments)
          }
          , ec = b._emscripten_bind_btDynamicsWorld_addAction_1 = function() {
            return (ec = b._emscripten_bind_btDynamicsWorld_addAction_1 = b.asm.ka).apply(null, arguments)
          }
          , fc = b._emscripten_bind_btDynamicsWorld_removeAction_1 = function() {
            return (fc = b._emscripten_bind_btDynamicsWorld_removeAction_1 = b.asm.la).apply(null, arguments)
          }
          , hc = b._emscripten_bind_btDynamicsWorld_getSolverInfo_0 = function() {
            return (hc = b._emscripten_bind_btDynamicsWorld_getSolverInfo_0 = b.asm.ma).apply(null, arguments)
          }
          , ic = b._emscripten_bind_btDynamicsWorld_setInternalTickCallback_1 = function() {
            return (ic = b._emscripten_bind_btDynamicsWorld_setInternalTickCallback_1 = b.asm.na).apply(null, arguments)
          }
          , jc = b._emscripten_bind_btDynamicsWorld_setInternalTickCallback_2 = function() {
            return (jc = b._emscripten_bind_btDynamicsWorld_setInternalTickCallback_2 = b.asm.oa).apply(null, arguments)
          }
          , kc = b._emscripten_bind_btDynamicsWorld_setInternalTickCallback_3 = function() {
            return (kc = b._emscripten_bind_btDynamicsWorld_setInternalTickCallback_3 = b.asm.pa).apply(null, arguments)
          }
          , lc = b._emscripten_bind_btDynamicsWorld_getDispatcher_0 = function() {
            return (lc = b._emscripten_bind_btDynamicsWorld_getDispatcher_0 = b.asm.qa).apply(null, arguments)
          }
          , mc = b._emscripten_bind_btDynamicsWorld_rayTest_3 = function() {
            return (mc = b._emscripten_bind_btDynamicsWorld_rayTest_3 = b.asm.ra).apply(null, arguments)
          }
          , nc = b._emscripten_bind_btDynamicsWorld_getPairCache_0 = function() {
            return (nc = b._emscripten_bind_btDynamicsWorld_getPairCache_0 = b.asm.sa).apply(null, arguments)
          }
          , oc = b._emscripten_bind_btDynamicsWorld_getDispatchInfo_0 = function() {
            return (oc = b._emscripten_bind_btDynamicsWorld_getDispatchInfo_0 = b.asm.ta).apply(null, arguments)
          }
          , pc = b._emscripten_bind_btDynamicsWorld_addCollisionObject_1 = function() {
            return (pc = b._emscripten_bind_btDynamicsWorld_addCollisionObject_1 = b.asm.ua).apply(null, arguments)
          }
          , qc = b._emscripten_bind_btDynamicsWorld_addCollisionObject_2 = function() {
            return (qc = b._emscripten_bind_btDynamicsWorld_addCollisionObject_2 = b.asm.va).apply(null, arguments)
          }
          , rc = b._emscripten_bind_btDynamicsWorld_addCollisionObject_3 = function() {
            return (rc = b._emscripten_bind_btDynamicsWorld_addCollisionObject_3 = b.asm.wa).apply(null, arguments)
          }
          , sc = b._emscripten_bind_btDynamicsWorld_removeCollisionObject_1 = function() {
            return (sc = b._emscripten_bind_btDynamicsWorld_removeCollisionObject_1 = b.asm.xa).apply(null, arguments)
          }
          , tc = b._emscripten_bind_btDynamicsWorld_getBroadphase_0 = function() {
            return (tc = b._emscripten_bind_btDynamicsWorld_getBroadphase_0 = b.asm.ya).apply(null, arguments)
          }
          , uc = b._emscripten_bind_btDynamicsWorld_convexSweepTest_5 = function() {
            return (uc = b._emscripten_bind_btDynamicsWorld_convexSweepTest_5 = b.asm.za).apply(null, arguments)
          }
          , vc = b._emscripten_bind_btDynamicsWorld_contactPairTest_3 = function() {
            return (vc = b._emscripten_bind_btDynamicsWorld_contactPairTest_3 = b.asm.Aa).apply(null, arguments)
          }
          , wc = b._emscripten_bind_btDynamicsWorld_contactTest_2 = function() {
            return (wc = b._emscripten_bind_btDynamicsWorld_contactTest_2 = b.asm.Ba).apply(null, arguments)
          }
          , xc = b._emscripten_bind_btDynamicsWorld_updateSingleAabb_1 = function() {
            return (xc = b._emscripten_bind_btDynamicsWorld_updateSingleAabb_1 = b.asm.Ca).apply(null, arguments)
          }
          , yc = b._emscripten_bind_btDynamicsWorld_setDebugDrawer_1 = function() {
            return (yc = b._emscripten_bind_btDynamicsWorld_setDebugDrawer_1 = b.asm.Da).apply(null, arguments)
          }
          , zc = b._emscripten_bind_btDynamicsWorld_getDebugDrawer_0 = function() {
            return (zc = b._emscripten_bind_btDynamicsWorld_getDebugDrawer_0 = b.asm.Ea).apply(null, arguments)
          }
          , Ac = b._emscripten_bind_btDynamicsWorld_debugDrawWorld_0 = function() {
            return (Ac = b._emscripten_bind_btDynamicsWorld_debugDrawWorld_0 = b.asm.Fa).apply(null, arguments)
          }
          , Bc = b._emscripten_bind_btDynamicsWorld_debugDrawObject_3 = function() {
            return (Bc = b._emscripten_bind_btDynamicsWorld_debugDrawObject_3 = b.asm.Ga).apply(null, arguments)
          }
          , Cc = b._emscripten_bind_btDynamicsWorld___destroy___0 = function() {
            return (Cc = b._emscripten_bind_btDynamicsWorld___destroy___0 = b.asm.Ha).apply(null, arguments)
          }
          , Dc = b._emscripten_bind_btTypedConstraint_enableFeedback_1 = function() {
            return (Dc = b._emscripten_bind_btTypedConstraint_enableFeedback_1 = b.asm.Ia).apply(null, arguments)
          }
          , Ec = b._emscripten_bind_btTypedConstraint_getBreakingImpulseThreshold_0 = function() {
            return (Ec = b._emscripten_bind_btTypedConstraint_getBreakingImpulseThreshold_0 = b.asm.Ja).apply(null, arguments)
          }
          , Fc = b._emscripten_bind_btTypedConstraint_setBreakingImpulseThreshold_1 = function() {
            return (Fc = b._emscripten_bind_btTypedConstraint_setBreakingImpulseThreshold_1 = b.asm.Ka).apply(null, arguments)
          }
          , Gc = b._emscripten_bind_btTypedConstraint_getParam_2 = function() {
            return (Gc = b._emscripten_bind_btTypedConstraint_getParam_2 = b.asm.La).apply(null, arguments)
          }
          , Hc = b._emscripten_bind_btTypedConstraint_setParam_3 = function() {
            return (Hc = b._emscripten_bind_btTypedConstraint_setParam_3 = b.asm.Ma).apply(null, arguments)
          }
          , Ic = b._emscripten_bind_btTypedConstraint___destroy___0 = function() {
            return (Ic = b._emscripten_bind_btTypedConstraint___destroy___0 = b.asm.Na).apply(null, arguments)
          }
          , Jc = b._emscripten_bind_btConcaveShape_setLocalScaling_1 = function() {
            return (Jc = b._emscripten_bind_btConcaveShape_setLocalScaling_1 = b.asm.Oa).apply(null, arguments)
          }
          , Kc = b._emscripten_bind_btConcaveShape_getLocalScaling_0 = function() {
            return (Kc = b._emscripten_bind_btConcaveShape_getLocalScaling_0 = b.asm.Pa).apply(null, arguments)
          }
          , Lc = b._emscripten_bind_btConcaveShape_calculateLocalInertia_2 = function() {
            return (Lc = b._emscripten_bind_btConcaveShape_calculateLocalInertia_2 = b.asm.Qa).apply(null, arguments)
          }
          , Mc = b._emscripten_bind_btConcaveShape___destroy___0 = function() {
            return (Mc = b._emscripten_bind_btConcaveShape___destroy___0 = b.asm.Ra).apply(null, arguments)
          }
          , Nc = b._emscripten_bind_btCapsuleShape_btCapsuleShape_2 = function() {
            return (Nc = b._emscripten_bind_btCapsuleShape_btCapsuleShape_2 = b.asm.Sa).apply(null, arguments)
          }
          , Oc = b._emscripten_bind_btCapsuleShape_setMargin_1 = function() {
            return (Oc = b._emscripten_bind_btCapsuleShape_setMargin_1 = b.asm.Ta).apply(null, arguments)
          }
          , Pc = b._emscripten_bind_btCapsuleShape_getMargin_0 = function() {
            return (Pc = b._emscripten_bind_btCapsuleShape_getMargin_0 = b.asm.Ua).apply(null, arguments)
          }
          , Qc = b._emscripten_bind_btCapsuleShape_getUpAxis_0 = function() {
            return (Qc = b._emscripten_bind_btCapsuleShape_getUpAxis_0 = b.asm.Va).apply(null, arguments)
          }
          , Rc = b._emscripten_bind_btCapsuleShape_getRadius_0 = function() {
            return (Rc = b._emscripten_bind_btCapsuleShape_getRadius_0 = b.asm.Wa).apply(null, arguments)
          }
          , Sc = b._emscripten_bind_btCapsuleShape_getHalfHeight_0 = function() {
            return (Sc = b._emscripten_bind_btCapsuleShape_getHalfHeight_0 = b.asm.Xa).apply(null, arguments)
          }
          , Tc = b._emscripten_bind_btCapsuleShape_setLocalScaling_1 = function() {
            return (Tc = b._emscripten_bind_btCapsuleShape_setLocalScaling_1 = b.asm.Ya).apply(null, arguments)
          }
          , Uc = b._emscripten_bind_btCapsuleShape_getLocalScaling_0 = function() {
            return (Uc = b._emscripten_bind_btCapsuleShape_getLocalScaling_0 = b.asm.Za).apply(null, arguments)
          }
          , Vc = b._emscripten_bind_btCapsuleShape_calculateLocalInertia_2 = function() {
            return (Vc = b._emscripten_bind_btCapsuleShape_calculateLocalInertia_2 = b.asm._a).apply(null, arguments)
          }
          , Wc = b._emscripten_bind_btCapsuleShape___destroy___0 = function() {
            return (Wc = b._emscripten_bind_btCapsuleShape___destroy___0 = b.asm.$a).apply(null, arguments)
          }
          , Xc = b._emscripten_bind_btIDebugDraw_drawLine_3 = function() {
            return (Xc = b._emscripten_bind_btIDebugDraw_drawLine_3 = b.asm.ab).apply(null, arguments)
          }
          , Yc = b._emscripten_bind_btIDebugDraw_drawContactPoint_5 = function() {
            return (Yc = b._emscripten_bind_btIDebugDraw_drawContactPoint_5 = b.asm.bb).apply(null, arguments)
          }
          , Zc = b._emscripten_bind_btIDebugDraw_reportErrorWarning_1 = function() {
            return (Zc = b._emscripten_bind_btIDebugDraw_reportErrorWarning_1 = b.asm.cb).apply(null, arguments)
          }
          , $c = b._emscripten_bind_btIDebugDraw_draw3dText_2 = function() {
            return ($c = b._emscripten_bind_btIDebugDraw_draw3dText_2 = b.asm.db).apply(null, arguments)
          }
          , ad = b._emscripten_bind_btIDebugDraw_setDebugMode_1 = function() {
            return (ad = b._emscripten_bind_btIDebugDraw_setDebugMode_1 = b.asm.eb).apply(null, arguments)
          }
          , bd = b._emscripten_bind_btIDebugDraw_getDebugMode_0 = function() {
            return (bd = b._emscripten_bind_btIDebugDraw_getDebugMode_0 = b.asm.fb).apply(null, arguments)
          }
          , cd = b._emscripten_bind_btIDebugDraw___destroy___0 = function() {
            return (cd = b._emscripten_bind_btIDebugDraw___destroy___0 = b.asm.gb).apply(null, arguments)
          }
          , dd = b._emscripten_bind_btDefaultCollisionConfiguration_btDefaultCollisionConfiguration_0 = function() {
            return (dd = b._emscripten_bind_btDefaultCollisionConfiguration_btDefaultCollisionConfiguration_0 = b.asm.hb).apply(null, arguments)
          }
          , ed = b._emscripten_bind_btDefaultCollisionConfiguration_btDefaultCollisionConfiguration_1 = function() {
            return (ed = b._emscripten_bind_btDefaultCollisionConfiguration_btDefaultCollisionConfiguration_1 = b.asm.ib).apply(null, arguments)
          }
          , fd = b._emscripten_bind_btDefaultCollisionConfiguration___destroy___0 = function() {
            return (fd = b._emscripten_bind_btDefaultCollisionConfiguration___destroy___0 = b.asm.jb).apply(null, arguments)
          }
          , gd = b._emscripten_bind_btTriangleMeshShape_setLocalScaling_1 = function() {
            return (gd = b._emscripten_bind_btTriangleMeshShape_setLocalScaling_1 = b.asm.kb).apply(null, arguments)
          }
          , hd = b._emscripten_bind_btTriangleMeshShape_getLocalScaling_0 = function() {
            return (hd = b._emscripten_bind_btTriangleMeshShape_getLocalScaling_0 = b.asm.lb).apply(null, arguments)
          }
          , id = b._emscripten_bind_btTriangleMeshShape_calculateLocalInertia_2 = function() {
            return (id = b._emscripten_bind_btTriangleMeshShape_calculateLocalInertia_2 = b.asm.mb).apply(null, arguments)
          }
          , jd = b._emscripten_bind_btTriangleMeshShape___destroy___0 = function() {
            return (jd = b._emscripten_bind_btTriangleMeshShape___destroy___0 = b.asm.nb).apply(null, arguments)
          }
          , kd = b._emscripten_bind_btGhostObject_btGhostObject_0 = function() {
            return (kd = b._emscripten_bind_btGhostObject_btGhostObject_0 = b.asm.ob).apply(null, arguments)
          }
          , ld = b._emscripten_bind_btGhostObject_getNumOverlappingObjects_0 = function() {
            return (ld = b._emscripten_bind_btGhostObject_getNumOverlappingObjects_0 = b.asm.pb).apply(null, arguments)
          }
          , md = b._emscripten_bind_btGhostObject_getOverlappingObject_1 = function() {
            return (md = b._emscripten_bind_btGhostObject_getOverlappingObject_1 = b.asm.qb).apply(null, arguments)
          }
          , nd = b._emscripten_bind_btGhostObject_setAnisotropicFriction_2 = function() {
            return (nd = b._emscripten_bind_btGhostObject_setAnisotropicFriction_2 = b.asm.rb).apply(null, arguments)
          }
          , od = b._emscripten_bind_btGhostObject_getCollisionShape_0 = function() {
            return (od = b._emscripten_bind_btGhostObject_getCollisionShape_0 = b.asm.sb).apply(null, arguments)
          }
          , pd = b._emscripten_bind_btGhostObject_setContactProcessingThreshold_1 = function() {
            return (pd = b._emscripten_bind_btGhostObject_setContactProcessingThreshold_1 = b.asm.tb).apply(null, arguments)
          }
          , qd = b._emscripten_bind_btGhostObject_setActivationState_1 = function() {
            return (qd = b._emscripten_bind_btGhostObject_setActivationState_1 = b.asm.ub).apply(null, arguments)
          }
          , rd = b._emscripten_bind_btGhostObject_forceActivationState_1 = function() {
            return (rd = b._emscripten_bind_btGhostObject_forceActivationState_1 = b.asm.vb).apply(null, arguments)
          }
          , sd = b._emscripten_bind_btGhostObject_activate_0 = function() {
            return (sd = b._emscripten_bind_btGhostObject_activate_0 = b.asm.wb).apply(null, arguments)
          }
          , td = b._emscripten_bind_btGhostObject_activate_1 = function() {
            return (td = b._emscripten_bind_btGhostObject_activate_1 = b.asm.xb).apply(null, arguments)
          }
          , ud = b._emscripten_bind_btGhostObject_isActive_0 = function() {
            return (ud = b._emscripten_bind_btGhostObject_isActive_0 = b.asm.yb).apply(null, arguments)
          }
          , vd = b._emscripten_bind_btGhostObject_isKinematicObject_0 = function() {
            return (vd = b._emscripten_bind_btGhostObject_isKinematicObject_0 = b.asm.zb).apply(null, arguments)
          }
          , wd = b._emscripten_bind_btGhostObject_isStaticObject_0 = function() {
            return (wd = b._emscripten_bind_btGhostObject_isStaticObject_0 = b.asm.Ab).apply(null, arguments)
          }
          , xd = b._emscripten_bind_btGhostObject_isStaticOrKinematicObject_0 = function() {
            return (xd = b._emscripten_bind_btGhostObject_isStaticOrKinematicObject_0 = b.asm.Bb).apply(null, arguments)
          }
          , yd = b._emscripten_bind_btGhostObject_getRestitution_0 = function() {
            return (yd = b._emscripten_bind_btGhostObject_getRestitution_0 = b.asm.Cb).apply(null, arguments)
          }
          , zd = b._emscripten_bind_btGhostObject_getFriction_0 = function() {
            return (zd = b._emscripten_bind_btGhostObject_getFriction_0 = b.asm.Db).apply(null, arguments)
          }
          , Ad = b._emscripten_bind_btGhostObject_getRollingFriction_0 = function() {
            return (Ad = b._emscripten_bind_btGhostObject_getRollingFriction_0 = b.asm.Eb).apply(null, arguments)
          }
          , Bd = b._emscripten_bind_btGhostObject_setRestitution_1 = function() {
            return (Bd = b._emscripten_bind_btGhostObject_setRestitution_1 = b.asm.Fb).apply(null, arguments)
          }
          , Cd = b._emscripten_bind_btGhostObject_setFriction_1 = function() {
            return (Cd = b._emscripten_bind_btGhostObject_setFriction_1 = b.asm.Gb).apply(null, arguments)
          }
          , Dd = b._emscripten_bind_btGhostObject_setRollingFriction_1 = function() {
            return (Dd = b._emscripten_bind_btGhostObject_setRollingFriction_1 = b.asm.Hb).apply(null, arguments)
          }
          , Ed = b._emscripten_bind_btGhostObject_getWorldTransform_0 = function() {
            return (Ed = b._emscripten_bind_btGhostObject_getWorldTransform_0 = b.asm.Ib).apply(null, arguments)
          }
          , Fd = b._emscripten_bind_btGhostObject_getCollisionFlags_0 = function() {
            return (Fd = b._emscripten_bind_btGhostObject_getCollisionFlags_0 = b.asm.Jb).apply(null, arguments)
          }
          , Gd = b._emscripten_bind_btGhostObject_setCollisionFlags_1 = function() {
            return (Gd = b._emscripten_bind_btGhostObject_setCollisionFlags_1 = b.asm.Kb).apply(null, arguments)
          }
          , Hd = b._emscripten_bind_btGhostObject_setWorldTransform_1 = function() {
            return (Hd = b._emscripten_bind_btGhostObject_setWorldTransform_1 = b.asm.Lb).apply(null, arguments)
          }
          , Id = b._emscripten_bind_btGhostObject_setCollisionShape_1 = function() {
            return (Id = b._emscripten_bind_btGhostObject_setCollisionShape_1 = b.asm.Mb).apply(null, arguments)
          }
          , Jd = b._emscripten_bind_btGhostObject_setCcdMotionThreshold_1 = function() {
            return (Jd = b._emscripten_bind_btGhostObject_setCcdMotionThreshold_1 = b.asm.Nb).apply(null, arguments)
          }
          , Kd = b._emscripten_bind_btGhostObject_setCcdSweptSphereRadius_1 = function() {
            return (Kd = b._emscripten_bind_btGhostObject_setCcdSweptSphereRadius_1 = b.asm.Ob).apply(null, arguments)
          }
          , Ld = b._emscripten_bind_btGhostObject_getUserIndex_0 = function() {
            return (Ld = b._emscripten_bind_btGhostObject_getUserIndex_0 = b.asm.Pb).apply(null, arguments)
          }
          , Md = b._emscripten_bind_btGhostObject_setUserIndex_1 = function() {
            return (Md = b._emscripten_bind_btGhostObject_setUserIndex_1 = b.asm.Qb).apply(null, arguments)
          }
          , Nd = b._emscripten_bind_btGhostObject_getUserPointer_0 = function() {
            return (Nd = b._emscripten_bind_btGhostObject_getUserPointer_0 = b.asm.Rb).apply(null, arguments)
          }
          , Od = b._emscripten_bind_btGhostObject_setUserPointer_1 = function() {
            return (Od = b._emscripten_bind_btGhostObject_setUserPointer_1 = b.asm.Sb).apply(null, arguments)
          }
          , Pd = b._emscripten_bind_btGhostObject_getBroadphaseHandle_0 = function() {
            return (Pd = b._emscripten_bind_btGhostObject_getBroadphaseHandle_0 = b.asm.Tb).apply(null, arguments)
          }
          , Qd = b._emscripten_bind_btGhostObject___destroy___0 = function() {
            return (Qd = b._emscripten_bind_btGhostObject___destroy___0 = b.asm.Ub).apply(null, arguments)
          }
          , Rd = b._emscripten_bind_btConeShape_btConeShape_2 = function() {
            return (Rd = b._emscripten_bind_btConeShape_btConeShape_2 = b.asm.Vb).apply(null, arguments)
          }
          , Sd = b._emscripten_bind_btConeShape_setLocalScaling_1 = function() {
            return (Sd = b._emscripten_bind_btConeShape_setLocalScaling_1 = b.asm.Wb).apply(null, arguments)
          }
          , Td = b._emscripten_bind_btConeShape_getLocalScaling_0 = function() {
            return (Td = b._emscripten_bind_btConeShape_getLocalScaling_0 = b.asm.Xb).apply(null, arguments)
          }
          , Ud = b._emscripten_bind_btConeShape_calculateLocalInertia_2 = function() {
            return (Ud = b._emscripten_bind_btConeShape_calculateLocalInertia_2 = b.asm.Yb).apply(null, arguments)
          }
          , Vd = b._emscripten_bind_btConeShape___destroy___0 = function() {
            return (Vd = b._emscripten_bind_btConeShape___destroy___0 = b.asm.Zb).apply(null, arguments)
          }
          , Wd = b._emscripten_bind_btActionInterface_updateAction_2 = function() {
            return (Wd = b._emscripten_bind_btActionInterface_updateAction_2 = b.asm._b).apply(null, arguments)
          }
          , Xd = b._emscripten_bind_btActionInterface___destroy___0 = function() {
            return (Xd = b._emscripten_bind_btActionInterface___destroy___0 = b.asm.$b).apply(null, arguments)
          }
          , Yd = b._emscripten_bind_btVector3_btVector3_0 = function() {
            return (Yd = b._emscripten_bind_btVector3_btVector3_0 = b.asm.ac).apply(null, arguments)
          }
          , Zd = b._emscripten_bind_btVector3_btVector3_3 = function() {
            return (Zd = b._emscripten_bind_btVector3_btVector3_3 = b.asm.bc).apply(null, arguments)
          }
          , $d = b._emscripten_bind_btVector3_length_0 = function() {
            return ($d = b._emscripten_bind_btVector3_length_0 = b.asm.cc).apply(null, arguments)
          }
          , ae = b._emscripten_bind_btVector3_x_0 = function() {
            return (ae = b._emscripten_bind_btVector3_x_0 = b.asm.dc).apply(null, arguments)
          }
          , be = b._emscripten_bind_btVector3_y_0 = function() {
            return (be = b._emscripten_bind_btVector3_y_0 = b.asm.ec).apply(null, arguments)
          }
          , ce = b._emscripten_bind_btVector3_z_0 = function() {
            return (ce = b._emscripten_bind_btVector3_z_0 = b.asm.fc).apply(null, arguments)
          }
          , de = b._emscripten_bind_btVector3_setX_1 = function() {
            return (de = b._emscripten_bind_btVector3_setX_1 = b.asm.gc).apply(null, arguments)
          }
          , ee = b._emscripten_bind_btVector3_setY_1 = function() {
            return (ee = b._emscripten_bind_btVector3_setY_1 = b.asm.hc).apply(null, arguments)
          }
          , fe = b._emscripten_bind_btVector3_setZ_1 = function() {
            return (fe = b._emscripten_bind_btVector3_setZ_1 = b.asm.ic).apply(null, arguments)
          }
          , ge = b._emscripten_bind_btVector3_setValue_3 = function() {
            return (ge = b._emscripten_bind_btVector3_setValue_3 = b.asm.jc).apply(null, arguments)
          }
          , he = b._emscripten_bind_btVector3_normalize_0 = function() {
            return (he = b._emscripten_bind_btVector3_normalize_0 = b.asm.kc).apply(null, arguments)
          }
          , ie = b._emscripten_bind_btVector3_rotate_2 = function() {
            return (ie = b._emscripten_bind_btVector3_rotate_2 = b.asm.lc).apply(null, arguments)
          }
          , je = b._emscripten_bind_btVector3_dot_1 = function() {
            return (je = b._emscripten_bind_btVector3_dot_1 = b.asm.mc).apply(null, arguments)
          }
          , ke = b._emscripten_bind_btVector3_op_mul_1 = function() {
            return (ke = b._emscripten_bind_btVector3_op_mul_1 = b.asm.nc).apply(null, arguments)
          }
          , le = b._emscripten_bind_btVector3_op_add_1 = function() {
            return (le = b._emscripten_bind_btVector3_op_add_1 = b.asm.oc).apply(null, arguments)
          }
          , me = b._emscripten_bind_btVector3_op_sub_1 = function() {
            return (me = b._emscripten_bind_btVector3_op_sub_1 = b.asm.pc).apply(null, arguments)
          }
          , ne = b._emscripten_bind_btVector3___destroy___0 = function() {
            return (ne = b._emscripten_bind_btVector3___destroy___0 = b.asm.qc).apply(null, arguments)
          }
          , oe = b._emscripten_bind_btVehicleRaycaster_castRay_3 = function() {
            return (oe = b._emscripten_bind_btVehicleRaycaster_castRay_3 = b.asm.rc).apply(null, arguments)
          }
          , pe = b._emscripten_bind_btVehicleRaycaster___destroy___0 = function() {
            return (pe = b._emscripten_bind_btVehicleRaycaster___destroy___0 = b.asm.sc).apply(null, arguments)
          }
          , qe = b._emscripten_bind_btQuadWord_x_0 = function() {
            return (qe = b._emscripten_bind_btQuadWord_x_0 = b.asm.tc).apply(null, arguments)
          }
          , re = b._emscripten_bind_btQuadWord_y_0 = function() {
            return (re = b._emscripten_bind_btQuadWord_y_0 = b.asm.uc).apply(null, arguments)
          }
          , se = b._emscripten_bind_btQuadWord_z_0 = function() {
            return (se = b._emscripten_bind_btQuadWord_z_0 = b.asm.vc).apply(null, arguments)
          }
          , te = b._emscripten_bind_btQuadWord_w_0 = function() {
            return (te = b._emscripten_bind_btQuadWord_w_0 = b.asm.wc).apply(null, arguments)
          }
          , ue = b._emscripten_bind_btQuadWord_setX_1 = function() {
            return (ue = b._emscripten_bind_btQuadWord_setX_1 = b.asm.xc).apply(null, arguments)
          }
          , ve = b._emscripten_bind_btQuadWord_setY_1 = function() {
            return (ve = b._emscripten_bind_btQuadWord_setY_1 = b.asm.yc).apply(null, arguments)
          }
          , we = b._emscripten_bind_btQuadWord_setZ_1 = function() {
            return (we = b._emscripten_bind_btQuadWord_setZ_1 = b.asm.zc).apply(null, arguments)
          }
          , xe = b._emscripten_bind_btQuadWord_setW_1 = function() {
            return (xe = b._emscripten_bind_btQuadWord_setW_1 = b.asm.Ac).apply(null, arguments)
          }
          , ye = b._emscripten_bind_btQuadWord___destroy___0 = function() {
            return (ye = b._emscripten_bind_btQuadWord___destroy___0 = b.asm.Bc).apply(null, arguments)
          }
          , ze = b._emscripten_bind_btCylinderShape_btCylinderShape_1 = function() {
            return (ze = b._emscripten_bind_btCylinderShape_btCylinderShape_1 = b.asm.Cc).apply(null, arguments)
          }
          , Ae = b._emscripten_bind_btCylinderShape_setMargin_1 = function() {
            return (Ae = b._emscripten_bind_btCylinderShape_setMargin_1 = b.asm.Dc).apply(null, arguments)
          }
          , Be = b._emscripten_bind_btCylinderShape_getMargin_0 = function() {
            return (Be = b._emscripten_bind_btCylinderShape_getMargin_0 = b.asm.Ec).apply(null, arguments)
          }
          , Ce = b._emscripten_bind_btCylinderShape_setLocalScaling_1 = function() {
            return (Ce = b._emscripten_bind_btCylinderShape_setLocalScaling_1 = b.asm.Fc).apply(null, arguments)
          }
          , De = b._emscripten_bind_btCylinderShape_getLocalScaling_0 = function() {
            return (De = b._emscripten_bind_btCylinderShape_getLocalScaling_0 = b.asm.Gc).apply(null, arguments)
          }
          , Ee = b._emscripten_bind_btCylinderShape_calculateLocalInertia_2 = function() {
            return (Ee = b._emscripten_bind_btCylinderShape_calculateLocalInertia_2 = b.asm.Hc).apply(null, arguments)
          }
          , Fe = b._emscripten_bind_btCylinderShape___destroy___0 = function() {
            return (Fe = b._emscripten_bind_btCylinderShape___destroy___0 = b.asm.Ic).apply(null, arguments)
          }
          , Ge = b._emscripten_bind_btDiscreteDynamicsWorld_btDiscreteDynamicsWorld_4 = function() {
            return (Ge = b._emscripten_bind_btDiscreteDynamicsWorld_btDiscreteDynamicsWorld_4 = b.asm.Jc).apply(null, arguments)
          }
          , He = b._emscripten_bind_btDiscreteDynamicsWorld_setGravity_1 = function() {
            return (He = b._emscripten_bind_btDiscreteDynamicsWorld_setGravity_1 = b.asm.Kc).apply(null, arguments)
          }
          , Ie = b._emscripten_bind_btDiscreteDynamicsWorld_getGravity_0 = function() {
            return (Ie = b._emscripten_bind_btDiscreteDynamicsWorld_getGravity_0 = b.asm.Lc).apply(null, arguments)
          }
          , Je = b._emscripten_bind_btDiscreteDynamicsWorld_addRigidBody_1 = function() {
            return (Je = b._emscripten_bind_btDiscreteDynamicsWorld_addRigidBody_1 = b.asm.Mc).apply(null, arguments)
          }
          , Ke = b._emscripten_bind_btDiscreteDynamicsWorld_addRigidBody_3 = function() {
            return (Ke = b._emscripten_bind_btDiscreteDynamicsWorld_addRigidBody_3 = b.asm.Nc).apply(null, arguments)
          }
          , Le = b._emscripten_bind_btDiscreteDynamicsWorld_removeRigidBody_1 = function() {
            return (Le = b._emscripten_bind_btDiscreteDynamicsWorld_removeRigidBody_1 = b.asm.Oc).apply(null, arguments)
          }
          , Me = b._emscripten_bind_btDiscreteDynamicsWorld_addConstraint_1 = function() {
            return (Me = b._emscripten_bind_btDiscreteDynamicsWorld_addConstraint_1 = b.asm.Pc).apply(null, arguments)
          }
          , Ne = b._emscripten_bind_btDiscreteDynamicsWorld_addConstraint_2 = function() {
            return (Ne = b._emscripten_bind_btDiscreteDynamicsWorld_addConstraint_2 = b.asm.Qc).apply(null, arguments)
          }
          , Oe = b._emscripten_bind_btDiscreteDynamicsWorld_removeConstraint_1 = function() {
            return (Oe = b._emscripten_bind_btDiscreteDynamicsWorld_removeConstraint_1 = b.asm.Rc).apply(null, arguments)
          }
          , Pe = b._emscripten_bind_btDiscreteDynamicsWorld_stepSimulation_1 = function() {
            return (Pe = b._emscripten_bind_btDiscreteDynamicsWorld_stepSimulation_1 = b.asm.Sc).apply(null, arguments)
          }
          , Qe = b._emscripten_bind_btDiscreteDynamicsWorld_stepSimulation_2 = function() {
            return (Qe = b._emscripten_bind_btDiscreteDynamicsWorld_stepSimulation_2 = b.asm.Tc).apply(null, arguments)
          }
          , Re = b._emscripten_bind_btDiscreteDynamicsWorld_stepSimulation_3 = function() {
            return (Re = b._emscripten_bind_btDiscreteDynamicsWorld_stepSimulation_3 = b.asm.Uc).apply(null, arguments)
          }
          , Se = b._emscripten_bind_btDiscreteDynamicsWorld_setContactAddedCallback_1 = function() {
            return (Se = b._emscripten_bind_btDiscreteDynamicsWorld_setContactAddedCallback_1 = b.asm.Vc).apply(null, arguments)
          }
          , Te = b._emscripten_bind_btDiscreteDynamicsWorld_setContactProcessedCallback_1 = function() {
            return (Te = b._emscripten_bind_btDiscreteDynamicsWorld_setContactProcessedCallback_1 = b.asm.Wc).apply(null, arguments)
          }
          , Ue = b._emscripten_bind_btDiscreteDynamicsWorld_setContactDestroyedCallback_1 = function() {
            return (Ue = b._emscripten_bind_btDiscreteDynamicsWorld_setContactDestroyedCallback_1 = b.asm.Xc).apply(null, arguments)
          }
          , Ve = b._emscripten_bind_btDiscreteDynamicsWorld_getDispatcher_0 = function() {
            return (Ve = b._emscripten_bind_btDiscreteDynamicsWorld_getDispatcher_0 = b.asm.Yc).apply(null, arguments)
          }
          , We = b._emscripten_bind_btDiscreteDynamicsWorld_rayTest_3 = function() {
            return (We = b._emscripten_bind_btDiscreteDynamicsWorld_rayTest_3 = b.asm.Zc).apply(null, arguments)
          }
          , Xe = b._emscripten_bind_btDiscreteDynamicsWorld_getPairCache_0 = function() {
            return (Xe = b._emscripten_bind_btDiscreteDynamicsWorld_getPairCache_0 = b.asm._c).apply(null, arguments)
          }
          , Ye = b._emscripten_bind_btDiscreteDynamicsWorld_getDispatchInfo_0 = function() {
            return (Ye = b._emscripten_bind_btDiscreteDynamicsWorld_getDispatchInfo_0 = b.asm.$c).apply(null, arguments)
          }
          , Ze = b._emscripten_bind_btDiscreteDynamicsWorld_addCollisionObject_1 = function() {
            return (Ze = b._emscripten_bind_btDiscreteDynamicsWorld_addCollisionObject_1 = b.asm.ad).apply(null, arguments)
          }
          , $e = b._emscripten_bind_btDiscreteDynamicsWorld_addCollisionObject_2 = function() {
            return ($e = b._emscripten_bind_btDiscreteDynamicsWorld_addCollisionObject_2 = b.asm.bd).apply(null, arguments)
          }
          , af = b._emscripten_bind_btDiscreteDynamicsWorld_addCollisionObject_3 = function() {
            return (af = b._emscripten_bind_btDiscreteDynamicsWorld_addCollisionObject_3 = b.asm.cd).apply(null, arguments)
          }
          , bf = b._emscripten_bind_btDiscreteDynamicsWorld_removeCollisionObject_1 = function() {
            return (bf = b._emscripten_bind_btDiscreteDynamicsWorld_removeCollisionObject_1 = b.asm.dd).apply(null, arguments)
          }
          , cf = b._emscripten_bind_btDiscreteDynamicsWorld_getBroadphase_0 = function() {
            return (cf = b._emscripten_bind_btDiscreteDynamicsWorld_getBroadphase_0 = b.asm.ed).apply(null, arguments)
          }
          , df = b._emscripten_bind_btDiscreteDynamicsWorld_convexSweepTest_5 = function() {
            return (df = b._emscripten_bind_btDiscreteDynamicsWorld_convexSweepTest_5 = b.asm.fd).apply(null, arguments)
          }
          , ef = b._emscripten_bind_btDiscreteDynamicsWorld_contactPairTest_3 = function() {
            return (ef = b._emscripten_bind_btDiscreteDynamicsWorld_contactPairTest_3 = b.asm.gd).apply(null, arguments)
          }
          , ff = b._emscripten_bind_btDiscreteDynamicsWorld_contactTest_2 = function() {
            return (ff = b._emscripten_bind_btDiscreteDynamicsWorld_contactTest_2 = b.asm.hd).apply(null, arguments)
          }
          , gf = b._emscripten_bind_btDiscreteDynamicsWorld_updateSingleAabb_1 = function() {
            return (gf = b._emscripten_bind_btDiscreteDynamicsWorld_updateSingleAabb_1 = b.asm.id).apply(null, arguments)
          }
          , hf = b._emscripten_bind_btDiscreteDynamicsWorld_setDebugDrawer_1 = function() {
            return (hf = b._emscripten_bind_btDiscreteDynamicsWorld_setDebugDrawer_1 = b.asm.jd).apply(null, arguments)
          }
          , jf = b._emscripten_bind_btDiscreteDynamicsWorld_getDebugDrawer_0 = function() {
            return (jf = b._emscripten_bind_btDiscreteDynamicsWorld_getDebugDrawer_0 = b.asm.kd).apply(null, arguments)
          }
          , kf = b._emscripten_bind_btDiscreteDynamicsWorld_debugDrawWorld_0 = function() {
            return (kf = b._emscripten_bind_btDiscreteDynamicsWorld_debugDrawWorld_0 = b.asm.ld).apply(null, arguments)
          }
          , lf = b._emscripten_bind_btDiscreteDynamicsWorld_debugDrawObject_3 = function() {
            return (lf = b._emscripten_bind_btDiscreteDynamicsWorld_debugDrawObject_3 = b.asm.md).apply(null, arguments)
          }
          , mf = b._emscripten_bind_btDiscreteDynamicsWorld_addAction_1 = function() {
            return (mf = b._emscripten_bind_btDiscreteDynamicsWorld_addAction_1 = b.asm.nd).apply(null, arguments)
          }
          , nf = b._emscripten_bind_btDiscreteDynamicsWorld_removeAction_1 = function() {
            return (nf = b._emscripten_bind_btDiscreteDynamicsWorld_removeAction_1 = b.asm.od).apply(null, arguments)
          }
          , of = b._emscripten_bind_btDiscreteDynamicsWorld_getSolverInfo_0 = function() {
            return (of = b._emscripten_bind_btDiscreteDynamicsWorld_getSolverInfo_0 = b.asm.pd).apply(null, arguments)
          }
          , pf = b._emscripten_bind_btDiscreteDynamicsWorld_setInternalTickCallback_1 = function() {
            return (pf = b._emscripten_bind_btDiscreteDynamicsWorld_setInternalTickCallback_1 = b.asm.qd).apply(null, arguments)
          }
          , qf = b._emscripten_bind_btDiscreteDynamicsWorld_setInternalTickCallback_2 = function() {
            return (qf = b._emscripten_bind_btDiscreteDynamicsWorld_setInternalTickCallback_2 = b.asm.rd).apply(null, arguments)
          }
          , rf = b._emscripten_bind_btDiscreteDynamicsWorld_setInternalTickCallback_3 = function() {
            return (rf = b._emscripten_bind_btDiscreteDynamicsWorld_setInternalTickCallback_3 = b.asm.sd).apply(null, arguments)
          }
          , sf = b._emscripten_bind_btDiscreteDynamicsWorld___destroy___0 = function() {
            return (sf = b._emscripten_bind_btDiscreteDynamicsWorld___destroy___0 = b.asm.td).apply(null, arguments)
          }
          , tf = b._emscripten_bind_btConvexShape_setLocalScaling_1 = function() {
            return (tf = b._emscripten_bind_btConvexShape_setLocalScaling_1 = b.asm.ud).apply(null, arguments)
          }
          , uf = b._emscripten_bind_btConvexShape_getLocalScaling_0 = function() {
            return (uf = b._emscripten_bind_btConvexShape_getLocalScaling_0 = b.asm.vd).apply(null, arguments)
          }
          , vf = b._emscripten_bind_btConvexShape_calculateLocalInertia_2 = function() {
            return (vf = b._emscripten_bind_btConvexShape_calculateLocalInertia_2 = b.asm.wd).apply(null, arguments)
          }
          , wf = b._emscripten_bind_btConvexShape_setMargin_1 = function() {
            return (wf = b._emscripten_bind_btConvexShape_setMargin_1 = b.asm.xd).apply(null, arguments)
          }
          , xf = b._emscripten_bind_btConvexShape_getMargin_0 = function() {
            return (xf = b._emscripten_bind_btConvexShape_getMargin_0 = b.asm.yd).apply(null, arguments)
          }
          , yf = b._emscripten_bind_btConvexShape___destroy___0 = function() {
            return (yf = b._emscripten_bind_btConvexShape___destroy___0 = b.asm.zd).apply(null, arguments)
          }
          , zf = b._emscripten_bind_btDispatcher_getNumManifolds_0 = function() {
            return (zf = b._emscripten_bind_btDispatcher_getNumManifolds_0 = b.asm.Ad).apply(null, arguments)
          }
          , Af = b._emscripten_bind_btDispatcher_getManifoldByIndexInternal_1 = function() {
            return (Af = b._emscripten_bind_btDispatcher_getManifoldByIndexInternal_1 = b.asm.Bd).apply(null, arguments)
          }
          , Bf = b._emscripten_bind_btDispatcher___destroy___0 = function() {
            return (Bf = b._emscripten_bind_btDispatcher___destroy___0 = b.asm.Cd).apply(null, arguments)
          }
          , Cf = b._emscripten_bind_btGeneric6DofConstraint_btGeneric6DofConstraint_3 = function() {
            return (Cf = b._emscripten_bind_btGeneric6DofConstraint_btGeneric6DofConstraint_3 = b.asm.Dd).apply(null, arguments)
          }
          , Df = b._emscripten_bind_btGeneric6DofConstraint_btGeneric6DofConstraint_5 = function() {
            return (Df = b._emscripten_bind_btGeneric6DofConstraint_btGeneric6DofConstraint_5 = b.asm.Ed).apply(null, arguments)
          }
          , Ef = b._emscripten_bind_btGeneric6DofConstraint_setLinearLowerLimit_1 = function() {
            return (Ef = b._emscripten_bind_btGeneric6DofConstraint_setLinearLowerLimit_1 = b.asm.Fd).apply(null, arguments)
          }
          , Ff = b._emscripten_bind_btGeneric6DofConstraint_setLinearUpperLimit_1 = function() {
            return (Ff = b._emscripten_bind_btGeneric6DofConstraint_setLinearUpperLimit_1 = b.asm.Gd).apply(null, arguments)
          }
          , Gf = b._emscripten_bind_btGeneric6DofConstraint_setAngularLowerLimit_1 = function() {
            return (Gf = b._emscripten_bind_btGeneric6DofConstraint_setAngularLowerLimit_1 = b.asm.Hd).apply(null, arguments)
          }
          , Hf = b._emscripten_bind_btGeneric6DofConstraint_setAngularUpperLimit_1 = function() {
            return (Hf = b._emscripten_bind_btGeneric6DofConstraint_setAngularUpperLimit_1 = b.asm.Id).apply(null, arguments)
          }
          , If = b._emscripten_bind_btGeneric6DofConstraint_getFrameOffsetA_0 = function() {
            return (If = b._emscripten_bind_btGeneric6DofConstraint_getFrameOffsetA_0 = b.asm.Jd).apply(null, arguments)
          }
          , Jf = b._emscripten_bind_btGeneric6DofConstraint_enableFeedback_1 = function() {
            return (Jf = b._emscripten_bind_btGeneric6DofConstraint_enableFeedback_1 = b.asm.Kd).apply(null, arguments)
          }
          , Kf = b._emscripten_bind_btGeneric6DofConstraint_getBreakingImpulseThreshold_0 = function() {
            return (Kf = b._emscripten_bind_btGeneric6DofConstraint_getBreakingImpulseThreshold_0 = b.asm.Ld).apply(null, arguments)
          }
          , Lf = b._emscripten_bind_btGeneric6DofConstraint_setBreakingImpulseThreshold_1 = function() {
            return (Lf = b._emscripten_bind_btGeneric6DofConstraint_setBreakingImpulseThreshold_1 = b.asm.Md).apply(null, arguments)
          }
          , Mf = b._emscripten_bind_btGeneric6DofConstraint_getParam_2 = function() {
            return (Mf = b._emscripten_bind_btGeneric6DofConstraint_getParam_2 = b.asm.Nd).apply(null, arguments)
          }
          , Nf = b._emscripten_bind_btGeneric6DofConstraint_setParam_3 = function() {
            return (Nf = b._emscripten_bind_btGeneric6DofConstraint_setParam_3 = b.asm.Od).apply(null, arguments)
          }
          , Of = b._emscripten_bind_btGeneric6DofConstraint___destroy___0 = function() {
            return (Of = b._emscripten_bind_btGeneric6DofConstraint___destroy___0 = b.asm.Pd).apply(null, arguments)
          }
          , Pf = b._emscripten_bind_btStridingMeshInterface_setScaling_1 = function() {
            return (Pf = b._emscripten_bind_btStridingMeshInterface_setScaling_1 = b.asm.Qd).apply(null, arguments)
          }
          , Qf = b._emscripten_bind_btStridingMeshInterface___destroy___0 = function() {
            return (Qf = b._emscripten_bind_btStridingMeshInterface___destroy___0 = b.asm.Rd).apply(null, arguments)
          }
          , Rf = b._emscripten_bind_btMotionState_getWorldTransform_1 = function() {
            return (Rf = b._emscripten_bind_btMotionState_getWorldTransform_1 = b.asm.Sd).apply(null, arguments)
          }
          , Sf = b._emscripten_bind_btMotionState_setWorldTransform_1 = function() {
            return (Sf = b._emscripten_bind_btMotionState_setWorldTransform_1 = b.asm.Td).apply(null, arguments)
          }
          , Tf = b._emscripten_bind_btMotionState___destroy___0 = function() {
            return (Tf = b._emscripten_bind_btMotionState___destroy___0 = b.asm.Ud).apply(null, arguments)
          }
          , Uf = b._emscripten_bind_ConvexResultCallback_hasHit_0 = function() {
            return (Uf = b._emscripten_bind_ConvexResultCallback_hasHit_0 = b.asm.Vd).apply(null, arguments)
          }
          , Vf = b._emscripten_bind_ConvexResultCallback_get_m_collisionFilterGroup_0 = function() {
            return (Vf = b._emscripten_bind_ConvexResultCallback_get_m_collisionFilterGroup_0 = b.asm.Wd).apply(null, arguments)
          }
          , Wf = b._emscripten_bind_ConvexResultCallback_set_m_collisionFilterGroup_1 = function() {
            return (Wf = b._emscripten_bind_ConvexResultCallback_set_m_collisionFilterGroup_1 = b.asm.Xd).apply(null, arguments)
          }
          , Xf = b._emscripten_bind_ConvexResultCallback_get_m_collisionFilterMask_0 = function() {
            return (Xf = b._emscripten_bind_ConvexResultCallback_get_m_collisionFilterMask_0 = b.asm.Yd).apply(null, arguments)
          }
          , Yf = b._emscripten_bind_ConvexResultCallback_set_m_collisionFilterMask_1 = function() {
            return (Yf = b._emscripten_bind_ConvexResultCallback_set_m_collisionFilterMask_1 = b.asm.Zd).apply(null, arguments)
          }
          , Zf = b._emscripten_bind_ConvexResultCallback_get_m_closestHitFraction_0 = function() {
            return (Zf = b._emscripten_bind_ConvexResultCallback_get_m_closestHitFraction_0 = b.asm._d).apply(null, arguments)
          }
          , $f = b._emscripten_bind_ConvexResultCallback_set_m_closestHitFraction_1 = function() {
            return ($f = b._emscripten_bind_ConvexResultCallback_set_m_closestHitFraction_1 = b.asm.$d).apply(null, arguments)
          }
          , ag = b._emscripten_bind_ConvexResultCallback___destroy___0 = function() {
            return (ag = b._emscripten_bind_ConvexResultCallback___destroy___0 = b.asm.ae).apply(null, arguments)
          }
          , bg = b._emscripten_bind_ContactResultCallback_addSingleResult_7 = function() {
            return (bg = b._emscripten_bind_ContactResultCallback_addSingleResult_7 = b.asm.be).apply(null, arguments)
          }
          , cg = b._emscripten_bind_ContactResultCallback___destroy___0 = function() {
            return (cg = b._emscripten_bind_ContactResultCallback___destroy___0 = b.asm.ce).apply(null, arguments)
          }
          , dg = b._emscripten_bind_btSoftBodySolver___destroy___0 = function() {
            return (dg = b._emscripten_bind_btSoftBodySolver___destroy___0 = b.asm.de).apply(null, arguments)
          }
          , eg = b._emscripten_bind_RayResultCallback_hasHit_0 = function() {
            return (eg = b._emscripten_bind_RayResultCallback_hasHit_0 = b.asm.ee).apply(null, arguments)
          }
          , fg = b._emscripten_bind_RayResultCallback_get_m_collisionFilterGroup_0 = function() {
            return (fg = b._emscripten_bind_RayResultCallback_get_m_collisionFilterGroup_0 = b.asm.fe).apply(null, arguments)
          }
          , gg = b._emscripten_bind_RayResultCallback_set_m_collisionFilterGroup_1 = function() {
            return (gg = b._emscripten_bind_RayResultCallback_set_m_collisionFilterGroup_1 = b.asm.ge).apply(null, arguments)
          }
          , hg = b._emscripten_bind_RayResultCallback_get_m_collisionFilterMask_0 = function() {
            return (hg = b._emscripten_bind_RayResultCallback_get_m_collisionFilterMask_0 = b.asm.he).apply(null, arguments)
          }
          , ig = b._emscripten_bind_RayResultCallback_set_m_collisionFilterMask_1 = function() {
            return (ig = b._emscripten_bind_RayResultCallback_set_m_collisionFilterMask_1 = b.asm.ie).apply(null, arguments)
          }
          , jg = b._emscripten_bind_RayResultCallback_get_m_closestHitFraction_0 = function() {
            return (jg = b._emscripten_bind_RayResultCallback_get_m_closestHitFraction_0 = b.asm.je).apply(null, arguments)
          }
          , kg = b._emscripten_bind_RayResultCallback_set_m_closestHitFraction_1 = function() {
            return (kg = b._emscripten_bind_RayResultCallback_set_m_closestHitFraction_1 = b.asm.ke).apply(null, arguments)
          }
          , lg = b._emscripten_bind_RayResultCallback_get_m_collisionObject_0 = function() {
            return (lg = b._emscripten_bind_RayResultCallback_get_m_collisionObject_0 = b.asm.le).apply(null, arguments)
          }
          , mg = b._emscripten_bind_RayResultCallback_set_m_collisionObject_1 = function() {
            return (mg = b._emscripten_bind_RayResultCallback_set_m_collisionObject_1 = b.asm.me).apply(null, arguments)
          }
          , ng = b._emscripten_bind_RayResultCallback___destroy___0 = function() {
            return (ng = b._emscripten_bind_RayResultCallback___destroy___0 = b.asm.ne).apply(null, arguments)
          }
          , og = b._emscripten_bind_btMatrix3x3_setEulerZYX_3 = function() {
            return (og = b._emscripten_bind_btMatrix3x3_setEulerZYX_3 = b.asm.oe).apply(null, arguments)
          }
          , pg = b._emscripten_bind_btMatrix3x3_getRotation_1 = function() {
            return (pg = b._emscripten_bind_btMatrix3x3_getRotation_1 = b.asm.pe).apply(null, arguments)
          }
          , qg = b._emscripten_bind_btMatrix3x3_getRow_1 = function() {
            return (qg = b._emscripten_bind_btMatrix3x3_getRow_1 = b.asm.qe).apply(null, arguments)
          }
          , rg = b._emscripten_bind_btMatrix3x3___destroy___0 = function() {
            return (rg = b._emscripten_bind_btMatrix3x3___destroy___0 = b.asm.re).apply(null, arguments)
          }
          , sg = b._emscripten_bind_btScalarArray_size_0 = function() {
            return (sg = b._emscripten_bind_btScalarArray_size_0 = b.asm.se).apply(null, arguments)
          }
          , tg = b._emscripten_bind_btScalarArray_at_1 = function() {
            return (tg = b._emscripten_bind_btScalarArray_at_1 = b.asm.te).apply(null, arguments)
          }
          , ug = b._emscripten_bind_btScalarArray___destroy___0 = function() {
            return (ug = b._emscripten_bind_btScalarArray___destroy___0 = b.asm.ue).apply(null, arguments)
          }
          , vg = b._emscripten_bind_Material_get_m_kLST_0 = function() {
            return (vg = b._emscripten_bind_Material_get_m_kLST_0 = b.asm.ve).apply(null, arguments)
          }
          , wg = b._emscripten_bind_Material_set_m_kLST_1 = function() {
            return (wg = b._emscripten_bind_Material_set_m_kLST_1 = b.asm.we).apply(null, arguments)
          }
          , xg = b._emscripten_bind_Material_get_m_kAST_0 = function() {
            return (xg = b._emscripten_bind_Material_get_m_kAST_0 = b.asm.xe).apply(null, arguments)
          }
          , yg = b._emscripten_bind_Material_set_m_kAST_1 = function() {
            return (yg = b._emscripten_bind_Material_set_m_kAST_1 = b.asm.ye).apply(null, arguments)
          }
          , zg = b._emscripten_bind_Material_get_m_kVST_0 = function() {
            return (zg = b._emscripten_bind_Material_get_m_kVST_0 = b.asm.ze).apply(null, arguments)
          }
          , Ag = b._emscripten_bind_Material_set_m_kVST_1 = function() {
            return (Ag = b._emscripten_bind_Material_set_m_kVST_1 = b.asm.Ae).apply(null, arguments)
          }
          , Bg = b._emscripten_bind_Material_get_m_flags_0 = function() {
            return (Bg = b._emscripten_bind_Material_get_m_flags_0 = b.asm.Be).apply(null, arguments)
          }
          , Cg = b._emscripten_bind_Material_set_m_flags_1 = function() {
            return (Cg = b._emscripten_bind_Material_set_m_flags_1 = b.asm.Ce).apply(null, arguments)
          }
          , Dg = b._emscripten_bind_Material___destroy___0 = function() {
            return (Dg = b._emscripten_bind_Material___destroy___0 = b.asm.De).apply(null, arguments)
          }
          , Eg = b._emscripten_bind_btDispatcherInfo_get_m_timeStep_0 = function() {
            return (Eg = b._emscripten_bind_btDispatcherInfo_get_m_timeStep_0 = b.asm.Ee).apply(null, arguments)
          }
          , Fg = b._emscripten_bind_btDispatcherInfo_set_m_timeStep_1 = function() {
            return (Fg = b._emscripten_bind_btDispatcherInfo_set_m_timeStep_1 = b.asm.Fe).apply(null, arguments)
          }
          , Gg = b._emscripten_bind_btDispatcherInfo_get_m_stepCount_0 = function() {
            return (Gg = b._emscripten_bind_btDispatcherInfo_get_m_stepCount_0 = b.asm.Ge).apply(null, arguments)
          }
          , Hg = b._emscripten_bind_btDispatcherInfo_set_m_stepCount_1 = function() {
            return (Hg = b._emscripten_bind_btDispatcherInfo_set_m_stepCount_1 = b.asm.He).apply(null, arguments)
          }
          , Ig = b._emscripten_bind_btDispatcherInfo_get_m_dispatchFunc_0 = function() {
            return (Ig = b._emscripten_bind_btDispatcherInfo_get_m_dispatchFunc_0 = b.asm.Ie).apply(null, arguments)
          }
          , Jg = b._emscripten_bind_btDispatcherInfo_set_m_dispatchFunc_1 = function() {
            return (Jg = b._emscripten_bind_btDispatcherInfo_set_m_dispatchFunc_1 = b.asm.Je).apply(null, arguments)
          }
          , Kg = b._emscripten_bind_btDispatcherInfo_get_m_timeOfImpact_0 = function() {
            return (Kg = b._emscripten_bind_btDispatcherInfo_get_m_timeOfImpact_0 = b.asm.Ke).apply(null, arguments)
          }
          , Lg = b._emscripten_bind_btDispatcherInfo_set_m_timeOfImpact_1 = function() {
            return (Lg = b._emscripten_bind_btDispatcherInfo_set_m_timeOfImpact_1 = b.asm.Le).apply(null, arguments)
          }
          , Mg = b._emscripten_bind_btDispatcherInfo_get_m_useContinuous_0 = function() {
            return (Mg = b._emscripten_bind_btDispatcherInfo_get_m_useContinuous_0 = b.asm.Me).apply(null, arguments)
          }
          , Ng = b._emscripten_bind_btDispatcherInfo_set_m_useContinuous_1 = function() {
            return (Ng = b._emscripten_bind_btDispatcherInfo_set_m_useContinuous_1 = b.asm.Ne).apply(null, arguments)
          }
          , Og = b._emscripten_bind_btDispatcherInfo_get_m_enableSatConvex_0 = function() {
            return (Og = b._emscripten_bind_btDispatcherInfo_get_m_enableSatConvex_0 = b.asm.Oe).apply(null, arguments)
          }
          , Pg = b._emscripten_bind_btDispatcherInfo_set_m_enableSatConvex_1 = function() {
            return (Pg = b._emscripten_bind_btDispatcherInfo_set_m_enableSatConvex_1 = b.asm.Pe).apply(null, arguments)
          }
          , Qg = b._emscripten_bind_btDispatcherInfo_get_m_enableSPU_0 = function() {
            return (Qg = b._emscripten_bind_btDispatcherInfo_get_m_enableSPU_0 = b.asm.Qe).apply(null, arguments)
          }
          , Rg = b._emscripten_bind_btDispatcherInfo_set_m_enableSPU_1 = function() {
            return (Rg = b._emscripten_bind_btDispatcherInfo_set_m_enableSPU_1 = b.asm.Re).apply(null, arguments)
          }
          , Sg = b._emscripten_bind_btDispatcherInfo_get_m_useEpa_0 = function() {
            return (Sg = b._emscripten_bind_btDispatcherInfo_get_m_useEpa_0 = b.asm.Se).apply(null, arguments)
          }
          , Tg = b._emscripten_bind_btDispatcherInfo_set_m_useEpa_1 = function() {
            return (Tg = b._emscripten_bind_btDispatcherInfo_set_m_useEpa_1 = b.asm.Te).apply(null, arguments)
          }
          , Ug = b._emscripten_bind_btDispatcherInfo_get_m_allowedCcdPenetration_0 = function() {
            return (Ug = b._emscripten_bind_btDispatcherInfo_get_m_allowedCcdPenetration_0 = b.asm.Ue).apply(null, arguments)
          }
          , Vg = b._emscripten_bind_btDispatcherInfo_set_m_allowedCcdPenetration_1 = function() {
            return (Vg = b._emscripten_bind_btDispatcherInfo_set_m_allowedCcdPenetration_1 = b.asm.Ve).apply(null, arguments)
          }
          , Wg = b._emscripten_bind_btDispatcherInfo_get_m_useConvexConservativeDistanceUtil_0 = function() {
            return (Wg = b._emscripten_bind_btDispatcherInfo_get_m_useConvexConservativeDistanceUtil_0 = b.asm.We).apply(null, arguments)
          }
          , Xg = b._emscripten_bind_btDispatcherInfo_set_m_useConvexConservativeDistanceUtil_1 = function() {
            return (Xg = b._emscripten_bind_btDispatcherInfo_set_m_useConvexConservativeDistanceUtil_1 = b.asm.Xe).apply(null, arguments)
          }
          , Yg = b._emscripten_bind_btDispatcherInfo_get_m_convexConservativeDistanceThreshold_0 = function() {
            return (Yg = b._emscripten_bind_btDispatcherInfo_get_m_convexConservativeDistanceThreshold_0 = b.asm.Ye).apply(null, arguments)
          }
          , Zg = b._emscripten_bind_btDispatcherInfo_set_m_convexConservativeDistanceThreshold_1 = function() {
            return (Zg = b._emscripten_bind_btDispatcherInfo_set_m_convexConservativeDistanceThreshold_1 = b.asm.Ze).apply(null, arguments)
          }
          , $g = b._emscripten_bind_btDispatcherInfo___destroy___0 = function() {
            return ($g = b._emscripten_bind_btDispatcherInfo___destroy___0 = b.asm._e).apply(null, arguments)
          }
          , ah = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_chassisConnectionCS_0 = function() {
            return (ah = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_chassisConnectionCS_0 = b.asm.$e).apply(null, arguments)
          }
          , bh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_chassisConnectionCS_1 = function() {
            return (bh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_chassisConnectionCS_1 = b.asm.af).apply(null, arguments)
          }
          , ch = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_wheelDirectionCS_0 = function() {
            return (ch = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_wheelDirectionCS_0 = b.asm.bf).apply(null, arguments)
          }
          , dh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_wheelDirectionCS_1 = function() {
            return (dh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_wheelDirectionCS_1 = b.asm.cf).apply(null, arguments)
          }
          , eh = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_wheelAxleCS_0 = function() {
            return (eh = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_wheelAxleCS_0 = b.asm.df).apply(null, arguments)
          }
          , fh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_wheelAxleCS_1 = function() {
            return (fh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_wheelAxleCS_1 = b.asm.ef).apply(null, arguments)
          }
          , gh = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_suspensionRestLength_0 = function() {
            return (gh = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_suspensionRestLength_0 = b.asm.ff).apply(null, arguments)
          }
          , hh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_suspensionRestLength_1 = function() {
            return (hh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_suspensionRestLength_1 = b.asm.gf).apply(null, arguments)
          }
          , ih = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_maxSuspensionTravelCm_0 = function() {
            return (ih = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_maxSuspensionTravelCm_0 = b.asm.hf).apply(null, arguments)
          }
          , jh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_maxSuspensionTravelCm_1 = function() {
            return (jh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_maxSuspensionTravelCm_1 = b.asm.jf).apply(null, arguments)
          }
          , kh = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_wheelRadius_0 = function() {
            return (kh = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_wheelRadius_0 = b.asm.kf).apply(null, arguments)
          }
          , lh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_wheelRadius_1 = function() {
            return (lh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_wheelRadius_1 = b.asm.lf).apply(null, arguments)
          }
          , mh = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_suspensionStiffness_0 = function() {
            return (mh = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_suspensionStiffness_0 = b.asm.mf).apply(null, arguments)
          }
          , nh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_suspensionStiffness_1 = function() {
            return (nh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_suspensionStiffness_1 = b.asm.nf).apply(null, arguments)
          }
          , oh = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_wheelsDampingCompression_0 = function() {
            return (oh = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_wheelsDampingCompression_0 = b.asm.of).apply(null, arguments)
          }
          , ph = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_wheelsDampingCompression_1 = function() {
            return (ph = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_wheelsDampingCompression_1 = b.asm.pf).apply(null, arguments)
          }
          , qh = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_wheelsDampingRelaxation_0 = function() {
            return (qh = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_wheelsDampingRelaxation_0 = b.asm.qf).apply(null, arguments)
          }
          , rh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_wheelsDampingRelaxation_1 = function() {
            return (rh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_wheelsDampingRelaxation_1 = b.asm.rf).apply(null, arguments)
          }
          , sh = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_frictionSlip_0 = function() {
            return (sh = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_frictionSlip_0 = b.asm.sf).apply(null, arguments)
          }
          , th = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_frictionSlip_1 = function() {
            return (th = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_frictionSlip_1 = b.asm.tf).apply(null, arguments)
          }
          , uh = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_maxSuspensionForce_0 = function() {
            return (uh = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_maxSuspensionForce_0 = b.asm.uf).apply(null, arguments)
          }
          , vh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_maxSuspensionForce_1 = function() {
            return (vh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_maxSuspensionForce_1 = b.asm.vf).apply(null, arguments)
          }
          , wh = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_bIsFrontWheel_0 = function() {
            return (wh = b._emscripten_bind_btWheelInfoConstructionInfo_get_m_bIsFrontWheel_0 = b.asm.wf).apply(null, arguments)
          }
          , xh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_bIsFrontWheel_1 = function() {
            return (xh = b._emscripten_bind_btWheelInfoConstructionInfo_set_m_bIsFrontWheel_1 = b.asm.xf).apply(null, arguments)
          }
          , yh = b._emscripten_bind_btWheelInfoConstructionInfo___destroy___0 = function() {
            return (yh = b._emscripten_bind_btWheelInfoConstructionInfo___destroy___0 = b.asm.yf).apply(null, arguments)
          }
          , zh = b._emscripten_bind_btConvexTriangleMeshShape_btConvexTriangleMeshShape_1 = function() {
            return (zh = b._emscripten_bind_btConvexTriangleMeshShape_btConvexTriangleMeshShape_1 = b.asm.zf).apply(null, arguments)
          }
          , Ah = b._emscripten_bind_btConvexTriangleMeshShape_btConvexTriangleMeshShape_2 = function() {
            return (Ah = b._emscripten_bind_btConvexTriangleMeshShape_btConvexTriangleMeshShape_2 = b.asm.Af).apply(null, arguments)
          }
          , Bh = b._emscripten_bind_btConvexTriangleMeshShape_setLocalScaling_1 = function() {
            return (Bh = b._emscripten_bind_btConvexTriangleMeshShape_setLocalScaling_1 = b.asm.Bf).apply(null, arguments)
          }
          , Ch = b._emscripten_bind_btConvexTriangleMeshShape_getLocalScaling_0 = function() {
            return (Ch = b._emscripten_bind_btConvexTriangleMeshShape_getLocalScaling_0 = b.asm.Cf).apply(null, arguments)
          }
          , Dh = b._emscripten_bind_btConvexTriangleMeshShape_calculateLocalInertia_2 = function() {
            return (Dh = b._emscripten_bind_btConvexTriangleMeshShape_calculateLocalInertia_2 = b.asm.Df).apply(null, arguments)
          }
          , Eh = b._emscripten_bind_btConvexTriangleMeshShape_setMargin_1 = function() {
            return (Eh = b._emscripten_bind_btConvexTriangleMeshShape_setMargin_1 = b.asm.Ef).apply(null, arguments)
          }
          , Fh = b._emscripten_bind_btConvexTriangleMeshShape_getMargin_0 = function() {
            return (Fh = b._emscripten_bind_btConvexTriangleMeshShape_getMargin_0 = b.asm.Ff).apply(null, arguments)
          }
          , Gh = b._emscripten_bind_btConvexTriangleMeshShape___destroy___0 = function() {
            return (Gh = b._emscripten_bind_btConvexTriangleMeshShape___destroy___0 = b.asm.Gf).apply(null, arguments)
          }
          , Hh = b._emscripten_bind_btBroadphaseInterface_getOverlappingPairCache_0 = function() {
            return (Hh = b._emscripten_bind_btBroadphaseInterface_getOverlappingPairCache_0 = b.asm.Hf).apply(null, arguments)
          }
          , Ih = b._emscripten_bind_btBroadphaseInterface___destroy___0 = function() {
            return (Ih = b._emscripten_bind_btBroadphaseInterface___destroy___0 = b.asm.If).apply(null, arguments)
          }
          , Jh = b._emscripten_bind_btRigidBodyConstructionInfo_btRigidBodyConstructionInfo_3 = function() {
            return (Jh = b._emscripten_bind_btRigidBodyConstructionInfo_btRigidBodyConstructionInfo_3 = b.asm.Jf).apply(null, arguments)
          }
          , Kh = b._emscripten_bind_btRigidBodyConstructionInfo_btRigidBodyConstructionInfo_4 = function() {
            return (Kh = b._emscripten_bind_btRigidBodyConstructionInfo_btRigidBodyConstructionInfo_4 = b.asm.Kf).apply(null, arguments)
          }
          , Lh = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_linearDamping_0 = function() {
            return (Lh = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_linearDamping_0 = b.asm.Lf).apply(null, arguments)
          }
          , Mh = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_linearDamping_1 = function() {
            return (Mh = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_linearDamping_1 = b.asm.Mf).apply(null, arguments)
          }
          , Nh = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_angularDamping_0 = function() {
            return (Nh = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_angularDamping_0 = b.asm.Nf).apply(null, arguments)
          }
          , Oh = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_angularDamping_1 = function() {
            return (Oh = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_angularDamping_1 = b.asm.Of).apply(null, arguments)
          }
          , Ph = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_friction_0 = function() {
            return (Ph = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_friction_0 = b.asm.Pf).apply(null, arguments)
          }
          , Qh = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_friction_1 = function() {
            return (Qh = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_friction_1 = b.asm.Qf).apply(null, arguments)
          }
          , Rh = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_rollingFriction_0 = function() {
            return (Rh = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_rollingFriction_0 = b.asm.Rf).apply(null, arguments)
          }
          , Sh = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_rollingFriction_1 = function() {
            return (Sh = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_rollingFriction_1 = b.asm.Sf).apply(null, arguments)
          }
          , Th = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_restitution_0 = function() {
            return (Th = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_restitution_0 = b.asm.Tf).apply(null, arguments)
          }
          , Uh = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_restitution_1 = function() {
            return (Uh = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_restitution_1 = b.asm.Uf).apply(null, arguments)
          }
          , Vh = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_linearSleepingThreshold_0 = function() {
            return (Vh = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_linearSleepingThreshold_0 = b.asm.Vf).apply(null, arguments)
          }
          , Wh = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_linearSleepingThreshold_1 = function() {
            return (Wh = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_linearSleepingThreshold_1 = b.asm.Wf).apply(null, arguments)
          }
          , Xh = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_angularSleepingThreshold_0 = function() {
            return (Xh = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_angularSleepingThreshold_0 = b.asm.Xf).apply(null, arguments)
          }
          , Yh = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_angularSleepingThreshold_1 = function() {
            return (Yh = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_angularSleepingThreshold_1 = b.asm.Yf).apply(null, arguments)
          }
          , Zh = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_additionalDamping_0 = function() {
            return (Zh = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_additionalDamping_0 = b.asm.Zf).apply(null, arguments)
          }
          , $h = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_additionalDamping_1 = function() {
            return ($h = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_additionalDamping_1 = b.asm._f).apply(null, arguments)
          }
          , ai = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_additionalDampingFactor_0 = function() {
            return (ai = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_additionalDampingFactor_0 = b.asm.$f).apply(null, arguments)
          }
          , bi = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_additionalDampingFactor_1 = function() {
            return (bi = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_additionalDampingFactor_1 = b.asm.ag).apply(null, arguments)
          }
          , ci = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_additionalLinearDampingThresholdSqr_0 = function() {
            return (ci = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_additionalLinearDampingThresholdSqr_0 = b.asm.bg).apply(null, arguments)
          }
          , di = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_additionalLinearDampingThresholdSqr_1 = function() {
            return (di = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_additionalLinearDampingThresholdSqr_1 = b.asm.cg).apply(null, arguments)
          }
          , ei = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_additionalAngularDampingThresholdSqr_0 = function() {
            return (ei = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_additionalAngularDampingThresholdSqr_0 = b.asm.dg).apply(null, arguments)
          }
          , fi = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_additionalAngularDampingThresholdSqr_1 = function() {
            return (fi = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_additionalAngularDampingThresholdSqr_1 = b.asm.eg).apply(null, arguments)
          }
          , gi = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_additionalAngularDampingFactor_0 = function() {
            return (gi = b._emscripten_bind_btRigidBodyConstructionInfo_get_m_additionalAngularDampingFactor_0 = b.asm.fg).apply(null, arguments)
          }
          , hi = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_additionalAngularDampingFactor_1 = function() {
            return (hi = b._emscripten_bind_btRigidBodyConstructionInfo_set_m_additionalAngularDampingFactor_1 = b.asm.gg).apply(null, arguments)
          }
          , ii = b._emscripten_bind_btRigidBodyConstructionInfo___destroy___0 = function() {
            return (ii = b._emscripten_bind_btRigidBodyConstructionInfo___destroy___0 = b.asm.hg).apply(null, arguments)
          }
          , ji = b._emscripten_bind_btCollisionConfiguration___destroy___0 = function() {
            return (ji = b._emscripten_bind_btCollisionConfiguration___destroy___0 = b.asm.ig).apply(null, arguments)
          }
          , ki = b._emscripten_bind_btPersistentManifold_btPersistentManifold_0 = function() {
            return (ki = b._emscripten_bind_btPersistentManifold_btPersistentManifold_0 = b.asm.jg).apply(null, arguments)
          }
          , li = b._emscripten_bind_btPersistentManifold_getBody0_0 = function() {
            return (li = b._emscripten_bind_btPersistentManifold_getBody0_0 = b.asm.kg).apply(null, arguments)
          }
          , mi = b._emscripten_bind_btPersistentManifold_getBody1_0 = function() {
            return (mi = b._emscripten_bind_btPersistentManifold_getBody1_0 = b.asm.lg).apply(null, arguments)
          }
          , ni = b._emscripten_bind_btPersistentManifold_getNumContacts_0 = function() {
            return (ni = b._emscripten_bind_btPersistentManifold_getNumContacts_0 = b.asm.mg).apply(null, arguments)
          }
          , oi = b._emscripten_bind_btPersistentManifold_getContactPoint_1 = function() {
            return (oi = b._emscripten_bind_btPersistentManifold_getContactPoint_1 = b.asm.ng).apply(null, arguments)
          }
          , pi = b._emscripten_bind_btPersistentManifold___destroy___0 = function() {
            return (pi = b._emscripten_bind_btPersistentManifold___destroy___0 = b.asm.og).apply(null, arguments)
          }
          , qi = b._emscripten_bind_btCompoundShape_btCompoundShape_0 = function() {
            return (qi = b._emscripten_bind_btCompoundShape_btCompoundShape_0 = b.asm.pg).apply(null, arguments)
          }
          , ri = b._emscripten_bind_btCompoundShape_btCompoundShape_1 = function() {
            return (ri = b._emscripten_bind_btCompoundShape_btCompoundShape_1 = b.asm.qg).apply(null, arguments)
          }
          , si = b._emscripten_bind_btCompoundShape_addChildShape_2 = function() {
            return (si = b._emscripten_bind_btCompoundShape_addChildShape_2 = b.asm.rg).apply(null, arguments)
          }
          , ti = b._emscripten_bind_btCompoundShape_removeChildShape_1 = function() {
            return (ti = b._emscripten_bind_btCompoundShape_removeChildShape_1 = b.asm.sg).apply(null, arguments)
          }
          , ui = b._emscripten_bind_btCompoundShape_removeChildShapeByIndex_1 = function() {
            return (ui = b._emscripten_bind_btCompoundShape_removeChildShapeByIndex_1 = b.asm.tg).apply(null, arguments)
          }
          , vi = b._emscripten_bind_btCompoundShape_getNumChildShapes_0 = function() {
            return (vi = b._emscripten_bind_btCompoundShape_getNumChildShapes_0 = b.asm.ug).apply(null, arguments)
          }
          , wi = b._emscripten_bind_btCompoundShape_getChildShape_1 = function() {
            return (wi = b._emscripten_bind_btCompoundShape_getChildShape_1 = b.asm.vg).apply(null, arguments)
          }
          , xi = b._emscripten_bind_btCompoundShape_updateChildTransform_2 = function() {
            return (xi = b._emscripten_bind_btCompoundShape_updateChildTransform_2 = b.asm.wg).apply(null, arguments)
          }
          , yi = b._emscripten_bind_btCompoundShape_updateChildTransform_3 = function() {
            return (yi = b._emscripten_bind_btCompoundShape_updateChildTransform_3 = b.asm.xg).apply(null, arguments)
          }
          , zi = b._emscripten_bind_btCompoundShape_setMargin_1 = function() {
            return (zi = b._emscripten_bind_btCompoundShape_setMargin_1 = b.asm.yg).apply(null, arguments)
          }
          , Ai = b._emscripten_bind_btCompoundShape_getMargin_0 = function() {
            return (Ai = b._emscripten_bind_btCompoundShape_getMargin_0 = b.asm.zg).apply(null, arguments)
          }
          , Bi = b._emscripten_bind_btCompoundShape_setLocalScaling_1 = function() {
            return (Bi = b._emscripten_bind_btCompoundShape_setLocalScaling_1 = b.asm.Ag).apply(null, arguments)
          }
          , Ci = b._emscripten_bind_btCompoundShape_getLocalScaling_0 = function() {
            return (Ci = b._emscripten_bind_btCompoundShape_getLocalScaling_0 = b.asm.Bg).apply(null, arguments)
          }
          , Di = b._emscripten_bind_btCompoundShape_calculateLocalInertia_2 = function() {
            return (Di = b._emscripten_bind_btCompoundShape_calculateLocalInertia_2 = b.asm.Cg).apply(null, arguments)
          }
          , Ei = b._emscripten_bind_btCompoundShape___destroy___0 = function() {
            return (Ei = b._emscripten_bind_btCompoundShape___destroy___0 = b.asm.Dg).apply(null, arguments)
          }
          , Fi = b._emscripten_bind_ClosestConvexResultCallback_ClosestConvexResultCallback_2 = function() {
            return (Fi = b._emscripten_bind_ClosestConvexResultCallback_ClosestConvexResultCallback_2 = b.asm.Eg).apply(null, arguments)
          }
          , Gi = b._emscripten_bind_ClosestConvexResultCallback_hasHit_0 = function() {
            return (Gi = b._emscripten_bind_ClosestConvexResultCallback_hasHit_0 = b.asm.Fg).apply(null, arguments)
          }
          , Hi = b._emscripten_bind_ClosestConvexResultCallback_get_m_convexFromWorld_0 = function() {
            return (Hi = b._emscripten_bind_ClosestConvexResultCallback_get_m_convexFromWorld_0 = b.asm.Gg).apply(null, arguments)
          }
          , Ii = b._emscripten_bind_ClosestConvexResultCallback_set_m_convexFromWorld_1 = function() {
            return (Ii = b._emscripten_bind_ClosestConvexResultCallback_set_m_convexFromWorld_1 = b.asm.Hg).apply(null, arguments)
          }
          , Ji = b._emscripten_bind_ClosestConvexResultCallback_get_m_convexToWorld_0 = function() {
            return (Ji = b._emscripten_bind_ClosestConvexResultCallback_get_m_convexToWorld_0 = b.asm.Ig).apply(null, arguments)
          }
          , Ki = b._emscripten_bind_ClosestConvexResultCallback_set_m_convexToWorld_1 = function() {
            return (Ki = b._emscripten_bind_ClosestConvexResultCallback_set_m_convexToWorld_1 = b.asm.Jg).apply(null, arguments)
          }
          , Li = b._emscripten_bind_ClosestConvexResultCallback_get_m_hitNormalWorld_0 = function() {
            return (Li = b._emscripten_bind_ClosestConvexResultCallback_get_m_hitNormalWorld_0 = b.asm.Kg).apply(null, arguments)
          }
          , Mi = b._emscripten_bind_ClosestConvexResultCallback_set_m_hitNormalWorld_1 = function() {
            return (Mi = b._emscripten_bind_ClosestConvexResultCallback_set_m_hitNormalWorld_1 = b.asm.Lg).apply(null, arguments)
          }
          , Ni = b._emscripten_bind_ClosestConvexResultCallback_get_m_hitPointWorld_0 = function() {
            return (Ni = b._emscripten_bind_ClosestConvexResultCallback_get_m_hitPointWorld_0 = b.asm.Mg).apply(null, arguments)
          }
          , Oi = b._emscripten_bind_ClosestConvexResultCallback_set_m_hitPointWorld_1 = function() {
            return (Oi = b._emscripten_bind_ClosestConvexResultCallback_set_m_hitPointWorld_1 = b.asm.Ng).apply(null, arguments)
          }
          , Pi = b._emscripten_bind_ClosestConvexResultCallback_get_m_collisionFilterGroup_0 = function() {
            return (Pi = b._emscripten_bind_ClosestConvexResultCallback_get_m_collisionFilterGroup_0 = b.asm.Og).apply(null, arguments)
          }
          , Qi = b._emscripten_bind_ClosestConvexResultCallback_set_m_collisionFilterGroup_1 = function() {
            return (Qi = b._emscripten_bind_ClosestConvexResultCallback_set_m_collisionFilterGroup_1 = b.asm.Pg).apply(null, arguments)
          }
          , Ri = b._emscripten_bind_ClosestConvexResultCallback_get_m_collisionFilterMask_0 = function() {
            return (Ri = b._emscripten_bind_ClosestConvexResultCallback_get_m_collisionFilterMask_0 = b.asm.Qg).apply(null, arguments)
          }
          , Si = b._emscripten_bind_ClosestConvexResultCallback_set_m_collisionFilterMask_1 = function() {
            return (Si = b._emscripten_bind_ClosestConvexResultCallback_set_m_collisionFilterMask_1 = b.asm.Rg).apply(null, arguments)
          }
          , Ti = b._emscripten_bind_ClosestConvexResultCallback_get_m_closestHitFraction_0 = function() {
            return (Ti = b._emscripten_bind_ClosestConvexResultCallback_get_m_closestHitFraction_0 = b.asm.Sg).apply(null, arguments)
          }
          , Ui = b._emscripten_bind_ClosestConvexResultCallback_set_m_closestHitFraction_1 = function() {
            return (Ui = b._emscripten_bind_ClosestConvexResultCallback_set_m_closestHitFraction_1 = b.asm.Tg).apply(null, arguments)
          }
          , Vi = b._emscripten_bind_ClosestConvexResultCallback___destroy___0 = function() {
            return (Vi = b._emscripten_bind_ClosestConvexResultCallback___destroy___0 = b.asm.Ug).apply(null, arguments)
          }
          , Wi = b._emscripten_bind_AllHitsRayResultCallback_AllHitsRayResultCallback_2 = function() {
            return (Wi = b._emscripten_bind_AllHitsRayResultCallback_AllHitsRayResultCallback_2 = b.asm.Vg).apply(null, arguments)
          }
          , Xi = b._emscripten_bind_AllHitsRayResultCallback_hasHit_0 = function() {
            return (Xi = b._emscripten_bind_AllHitsRayResultCallback_hasHit_0 = b.asm.Wg).apply(null, arguments)
          }
          , Yi = b._emscripten_bind_AllHitsRayResultCallback_get_m_collisionObjects_0 = function() {
            return (Yi = b._emscripten_bind_AllHitsRayResultCallback_get_m_collisionObjects_0 = b.asm.Xg).apply(null, arguments)
          }
          , Zi = b._emscripten_bind_AllHitsRayResultCallback_set_m_collisionObjects_1 = function() {
            return (Zi = b._emscripten_bind_AllHitsRayResultCallback_set_m_collisionObjects_1 = b.asm.Yg).apply(null, arguments)
          }
          , $i = b._emscripten_bind_AllHitsRayResultCallback_get_m_rayFromWorld_0 = function() {
            return ($i = b._emscripten_bind_AllHitsRayResultCallback_get_m_rayFromWorld_0 = b.asm.Zg).apply(null, arguments)
          }
          , aj = b._emscripten_bind_AllHitsRayResultCallback_set_m_rayFromWorld_1 = function() {
            return (aj = b._emscripten_bind_AllHitsRayResultCallback_set_m_rayFromWorld_1 = b.asm._g).apply(null, arguments)
          }
          , bj = b._emscripten_bind_AllHitsRayResultCallback_get_m_rayToWorld_0 = function() {
            return (bj = b._emscripten_bind_AllHitsRayResultCallback_get_m_rayToWorld_0 = b.asm.$g).apply(null, arguments)
          }
          , cj = b._emscripten_bind_AllHitsRayResultCallback_set_m_rayToWorld_1 = function() {
            return (cj = b._emscripten_bind_AllHitsRayResultCallback_set_m_rayToWorld_1 = b.asm.ah).apply(null, arguments)
          }
          , dj = b._emscripten_bind_AllHitsRayResultCallback_get_m_hitNormalWorld_0 = function() {
            return (dj = b._emscripten_bind_AllHitsRayResultCallback_get_m_hitNormalWorld_0 = b.asm.bh).apply(null, arguments)
          }
          , ej = b._emscripten_bind_AllHitsRayResultCallback_set_m_hitNormalWorld_1 = function() {
            return (ej = b._emscripten_bind_AllHitsRayResultCallback_set_m_hitNormalWorld_1 = b.asm.ch).apply(null, arguments)
          }
          , fj = b._emscripten_bind_AllHitsRayResultCallback_get_m_hitPointWorld_0 = function() {
            return (fj = b._emscripten_bind_AllHitsRayResultCallback_get_m_hitPointWorld_0 = b.asm.dh).apply(null, arguments)
          }
          , gj = b._emscripten_bind_AllHitsRayResultCallback_set_m_hitPointWorld_1 = function() {
            return (gj = b._emscripten_bind_AllHitsRayResultCallback_set_m_hitPointWorld_1 = b.asm.eh).apply(null, arguments)
          }
          , hj = b._emscripten_bind_AllHitsRayResultCallback_get_m_hitFractions_0 = function() {
            return (hj = b._emscripten_bind_AllHitsRayResultCallback_get_m_hitFractions_0 = b.asm.fh).apply(null, arguments)
          }
          , ij = b._emscripten_bind_AllHitsRayResultCallback_set_m_hitFractions_1 = function() {
            return (ij = b._emscripten_bind_AllHitsRayResultCallback_set_m_hitFractions_1 = b.asm.gh).apply(null, arguments)
          }
          , jj = b._emscripten_bind_AllHitsRayResultCallback_get_m_collisionFilterGroup_0 = function() {
            return (jj = b._emscripten_bind_AllHitsRayResultCallback_get_m_collisionFilterGroup_0 = b.asm.hh).apply(null, arguments)
          }
          , kj = b._emscripten_bind_AllHitsRayResultCallback_set_m_collisionFilterGroup_1 = function() {
            return (kj = b._emscripten_bind_AllHitsRayResultCallback_set_m_collisionFilterGroup_1 = b.asm.ih).apply(null, arguments)
          }
          , lj = b._emscripten_bind_AllHitsRayResultCallback_get_m_collisionFilterMask_0 = function() {
            return (lj = b._emscripten_bind_AllHitsRayResultCallback_get_m_collisionFilterMask_0 = b.asm.jh).apply(null, arguments)
          }
          , mj = b._emscripten_bind_AllHitsRayResultCallback_set_m_collisionFilterMask_1 = function() {
            return (mj = b._emscripten_bind_AllHitsRayResultCallback_set_m_collisionFilterMask_1 = b.asm.kh).apply(null, arguments)
          }
          , nj = b._emscripten_bind_AllHitsRayResultCallback_get_m_closestHitFraction_0 = function() {
            return (nj = b._emscripten_bind_AllHitsRayResultCallback_get_m_closestHitFraction_0 = b.asm.lh).apply(null, arguments)
          }
          , oj = b._emscripten_bind_AllHitsRayResultCallback_set_m_closestHitFraction_1 = function() {
            return (oj = b._emscripten_bind_AllHitsRayResultCallback_set_m_closestHitFraction_1 = b.asm.mh).apply(null, arguments)
          }
          , pj = b._emscripten_bind_AllHitsRayResultCallback_get_m_collisionObject_0 = function() {
            return (pj = b._emscripten_bind_AllHitsRayResultCallback_get_m_collisionObject_0 = b.asm.nh).apply(null, arguments)
          }
          , qj = b._emscripten_bind_AllHitsRayResultCallback_set_m_collisionObject_1 = function() {
            return (qj = b._emscripten_bind_AllHitsRayResultCallback_set_m_collisionObject_1 = b.asm.oh).apply(null, arguments)
          }
          , rj = b._emscripten_bind_AllHitsRayResultCallback___destroy___0 = function() {
            return (rj = b._emscripten_bind_AllHitsRayResultCallback___destroy___0 = b.asm.ph).apply(null, arguments)
          }
          , sj = b._emscripten_bind_tMaterialArray_size_0 = function() {
            return (sj = b._emscripten_bind_tMaterialArray_size_0 = b.asm.qh).apply(null, arguments)
          }
          , tj = b._emscripten_bind_tMaterialArray_at_1 = function() {
            return (tj = b._emscripten_bind_tMaterialArray_at_1 = b.asm.rh).apply(null, arguments)
          }
          , uj = b._emscripten_bind_tMaterialArray___destroy___0 = function() {
            return (uj = b._emscripten_bind_tMaterialArray___destroy___0 = b.asm.sh).apply(null, arguments)
          }
          , vj = b._emscripten_bind_btDefaultVehicleRaycaster_btDefaultVehicleRaycaster_1 = function() {
            return (vj = b._emscripten_bind_btDefaultVehicleRaycaster_btDefaultVehicleRaycaster_1 = b.asm.th).apply(null, arguments)
          }
          , wj = b._emscripten_bind_btDefaultVehicleRaycaster_castRay_3 = function() {
            return (wj = b._emscripten_bind_btDefaultVehicleRaycaster_castRay_3 = b.asm.uh).apply(null, arguments)
          }
          , xj = b._emscripten_bind_btDefaultVehicleRaycaster___destroy___0 = function() {
            return (xj = b._emscripten_bind_btDefaultVehicleRaycaster___destroy___0 = b.asm.vh).apply(null, arguments)
          }
          , yj = b._emscripten_bind_btEmptyShape_btEmptyShape_0 = function() {
            return (yj = b._emscripten_bind_btEmptyShape_btEmptyShape_0 = b.asm.wh).apply(null, arguments)
          }
          , zj = b._emscripten_bind_btEmptyShape_setLocalScaling_1 = function() {
            return (zj = b._emscripten_bind_btEmptyShape_setLocalScaling_1 = b.asm.xh).apply(null, arguments)
          }
          , Aj = b._emscripten_bind_btEmptyShape_getLocalScaling_0 = function() {
            return (Aj = b._emscripten_bind_btEmptyShape_getLocalScaling_0 = b.asm.yh).apply(null, arguments)
          }
          , Bj = b._emscripten_bind_btEmptyShape_calculateLocalInertia_2 = function() {
            return (Bj = b._emscripten_bind_btEmptyShape_calculateLocalInertia_2 = b.asm.zh).apply(null, arguments)
          }
          , Cj = b._emscripten_bind_btEmptyShape___destroy___0 = function() {
            return (Cj = b._emscripten_bind_btEmptyShape___destroy___0 = b.asm.Ah).apply(null, arguments)
          }
          , Dj = b._emscripten_bind_btConstraintSetting_btConstraintSetting_0 = function() {
            return (Dj = b._emscripten_bind_btConstraintSetting_btConstraintSetting_0 = b.asm.Bh).apply(null, arguments)
          }
          , Ej = b._emscripten_bind_btConstraintSetting_get_m_tau_0 = function() {
            return (Ej = b._emscripten_bind_btConstraintSetting_get_m_tau_0 = b.asm.Ch).apply(null, arguments)
          }
          , Fj = b._emscripten_bind_btConstraintSetting_set_m_tau_1 = function() {
            return (Fj = b._emscripten_bind_btConstraintSetting_set_m_tau_1 = b.asm.Dh).apply(null, arguments)
          }
          , Gj = b._emscripten_bind_btConstraintSetting_get_m_damping_0 = function() {
            return (Gj = b._emscripten_bind_btConstraintSetting_get_m_damping_0 = b.asm.Eh).apply(null, arguments)
          }
          , Hj = b._emscripten_bind_btConstraintSetting_set_m_damping_1 = function() {
            return (Hj = b._emscripten_bind_btConstraintSetting_set_m_damping_1 = b.asm.Fh).apply(null, arguments)
          }
          , Ij = b._emscripten_bind_btConstraintSetting_get_m_impulseClamp_0 = function() {
            return (Ij = b._emscripten_bind_btConstraintSetting_get_m_impulseClamp_0 = b.asm.Gh).apply(null, arguments)
          }
          , Jj = b._emscripten_bind_btConstraintSetting_set_m_impulseClamp_1 = function() {
            return (Jj = b._emscripten_bind_btConstraintSetting_set_m_impulseClamp_1 = b.asm.Hh).apply(null, arguments)
          }
          , Kj = b._emscripten_bind_btConstraintSetting___destroy___0 = function() {
            return (Kj = b._emscripten_bind_btConstraintSetting___destroy___0 = b.asm.Ih).apply(null, arguments)
          }
          , Lj = b._emscripten_bind_LocalShapeInfo_get_m_shapePart_0 = function() {
            return (Lj = b._emscripten_bind_LocalShapeInfo_get_m_shapePart_0 = b.asm.Jh).apply(null, arguments)
          }
          , Mj = b._emscripten_bind_LocalShapeInfo_set_m_shapePart_1 = function() {
            return (Mj = b._emscripten_bind_LocalShapeInfo_set_m_shapePart_1 = b.asm.Kh).apply(null, arguments)
          }
          , Nj = b._emscripten_bind_LocalShapeInfo_get_m_triangleIndex_0 = function() {
            return (Nj = b._emscripten_bind_LocalShapeInfo_get_m_triangleIndex_0 = b.asm.Lh).apply(null, arguments)
          }
          , Oj = b._emscripten_bind_LocalShapeInfo_set_m_triangleIndex_1 = function() {
            return (Oj = b._emscripten_bind_LocalShapeInfo_set_m_triangleIndex_1 = b.asm.Mh).apply(null, arguments)
          }
          , Pj = b._emscripten_bind_LocalShapeInfo___destroy___0 = function() {
            return (Pj = b._emscripten_bind_LocalShapeInfo___destroy___0 = b.asm.Nh).apply(null, arguments)
          }
          , Qj = b._emscripten_bind_btRigidBody_btRigidBody_1 = function() {
            return (Qj = b._emscripten_bind_btRigidBody_btRigidBody_1 = b.asm.Oh).apply(null, arguments)
          }
          , Rj = b._emscripten_bind_btRigidBody_getCenterOfMassTransform_0 = function() {
            return (Rj = b._emscripten_bind_btRigidBody_getCenterOfMassTransform_0 = b.asm.Ph).apply(null, arguments)
          }
          , Sj = b._emscripten_bind_btRigidBody_setCenterOfMassTransform_1 = function() {
            return (Sj = b._emscripten_bind_btRigidBody_setCenterOfMassTransform_1 = b.asm.Qh).apply(null, arguments)
          }
          , Tj = b._emscripten_bind_btRigidBody_setSleepingThresholds_2 = function() {
            return (Tj = b._emscripten_bind_btRigidBody_setSleepingThresholds_2 = b.asm.Rh).apply(null, arguments)
          }
          , Uj = b._emscripten_bind_btRigidBody_getLinearDamping_0 = function() {
            return (Uj = b._emscripten_bind_btRigidBody_getLinearDamping_0 = b.asm.Sh).apply(null, arguments)
          }
          , Vj = b._emscripten_bind_btRigidBody_getAngularDamping_0 = function() {
            return (Vj = b._emscripten_bind_btRigidBody_getAngularDamping_0 = b.asm.Th).apply(null, arguments)
          }
          , Wj = b._emscripten_bind_btRigidBody_setDamping_2 = function() {
            return (Wj = b._emscripten_bind_btRigidBody_setDamping_2 = b.asm.Uh).apply(null, arguments)
          }
          , Xj = b._emscripten_bind_btRigidBody_setMassProps_2 = function() {
            return (Xj = b._emscripten_bind_btRigidBody_setMassProps_2 = b.asm.Vh).apply(null, arguments)
          }
          , Yj = b._emscripten_bind_btRigidBody_getLinearFactor_0 = function() {
            return (Yj = b._emscripten_bind_btRigidBody_getLinearFactor_0 = b.asm.Wh).apply(null, arguments)
          }
          , Zj = b._emscripten_bind_btRigidBody_setLinearFactor_1 = function() {
            return (Zj = b._emscripten_bind_btRigidBody_setLinearFactor_1 = b.asm.Xh).apply(null, arguments)
          }
          , ak = b._emscripten_bind_btRigidBody_applyTorque_1 = function() {
            return (ak = b._emscripten_bind_btRigidBody_applyTorque_1 = b.asm.Yh).apply(null, arguments)
          }
          , bk = b._emscripten_bind_btRigidBody_applyLocalTorque_1 = function() {
            return (bk = b._emscripten_bind_btRigidBody_applyLocalTorque_1 = b.asm.Zh).apply(null, arguments)
          }
          , ck = b._emscripten_bind_btRigidBody_applyForce_2 = function() {
            return (ck = b._emscripten_bind_btRigidBody_applyForce_2 = b.asm._h).apply(null, arguments)
          }
          , dk = b._emscripten_bind_btRigidBody_applyCentralForce_1 = function() {
            return (dk = b._emscripten_bind_btRigidBody_applyCentralForce_1 = b.asm.$h).apply(null, arguments)
          }
          , ek = b._emscripten_bind_btRigidBody_applyCentralLocalForce_1 = function() {
            return (ek = b._emscripten_bind_btRigidBody_applyCentralLocalForce_1 = b.asm.ai).apply(null, arguments)
          }
          , fk = b._emscripten_bind_btRigidBody_applyTorqueImpulse_1 = function() {
            return (fk = b._emscripten_bind_btRigidBody_applyTorqueImpulse_1 = b.asm.bi).apply(null, arguments)
          }
          , gk = b._emscripten_bind_btRigidBody_applyImpulse_2 = function() {
            return (gk = b._emscripten_bind_btRigidBody_applyImpulse_2 = b.asm.ci).apply(null, arguments)
          }
          , hk = b._emscripten_bind_btRigidBody_applyCentralImpulse_1 = function() {
            return (hk = b._emscripten_bind_btRigidBody_applyCentralImpulse_1 = b.asm.di).apply(null, arguments)
          }
          , ik = b._emscripten_bind_btRigidBody_updateInertiaTensor_0 = function() {
            return (ik = b._emscripten_bind_btRigidBody_updateInertiaTensor_0 = b.asm.ei).apply(null, arguments)
          }
          , jk = b._emscripten_bind_btRigidBody_getLinearVelocity_0 = function() {
            return (jk = b._emscripten_bind_btRigidBody_getLinearVelocity_0 = b.asm.fi).apply(null, arguments)
          }
          , kk = b._emscripten_bind_btRigidBody_getAngularVelocity_0 = function() {
            return (kk = b._emscripten_bind_btRigidBody_getAngularVelocity_0 = b.asm.gi).apply(null, arguments)
          }
          , lk = b._emscripten_bind_btRigidBody_setLinearVelocity_1 = function() {
            return (lk = b._emscripten_bind_btRigidBody_setLinearVelocity_1 = b.asm.hi).apply(null, arguments)
          }
          , mk = b._emscripten_bind_btRigidBody_setAngularVelocity_1 = function() {
            return (mk = b._emscripten_bind_btRigidBody_setAngularVelocity_1 = b.asm.ii).apply(null, arguments)
          }
          , nk = b._emscripten_bind_btRigidBody_getMotionState_0 = function() {
            return (nk = b._emscripten_bind_btRigidBody_getMotionState_0 = b.asm.ji).apply(null, arguments)
          }
          , ok = b._emscripten_bind_btRigidBody_setMotionState_1 = function() {
            return (ok = b._emscripten_bind_btRigidBody_setMotionState_1 = b.asm.ki).apply(null, arguments)
          }
          , pk = b._emscripten_bind_btRigidBody_getAngularFactor_0 = function() {
            return (pk = b._emscripten_bind_btRigidBody_getAngularFactor_0 = b.asm.li).apply(null, arguments)
          }
          , qk = b._emscripten_bind_btRigidBody_setAngularFactor_1 = function() {
            return (qk = b._emscripten_bind_btRigidBody_setAngularFactor_1 = b.asm.mi).apply(null, arguments)
          }
          , rk = b._emscripten_bind_btRigidBody_upcast_1 = function() {
            return (rk = b._emscripten_bind_btRigidBody_upcast_1 = b.asm.ni).apply(null, arguments)
          }
          , sk = b._emscripten_bind_btRigidBody_getAabb_2 = function() {
            return (sk = b._emscripten_bind_btRigidBody_getAabb_2 = b.asm.oi).apply(null, arguments)
          }
          , tk = b._emscripten_bind_btRigidBody_applyGravity_0 = function() {
            return (tk = b._emscripten_bind_btRigidBody_applyGravity_0 = b.asm.pi).apply(null, arguments)
          }
          , uk = b._emscripten_bind_btRigidBody_getGravity_0 = function() {
            return (uk = b._emscripten_bind_btRigidBody_getGravity_0 = b.asm.qi).apply(null, arguments)
          }
          , vk = b._emscripten_bind_btRigidBody_setGravity_1 = function() {
            return (vk = b._emscripten_bind_btRigidBody_setGravity_1 = b.asm.ri).apply(null, arguments)
          }
          , wk = b._emscripten_bind_btRigidBody_getBroadphaseProxy_0 = function() {
            return (wk = b._emscripten_bind_btRigidBody_getBroadphaseProxy_0 = b.asm.si).apply(null, arguments)
          }
          , xk = b._emscripten_bind_btRigidBody_clearForces_0 = function() {
            return (xk = b._emscripten_bind_btRigidBody_clearForces_0 = b.asm.ti).apply(null, arguments)
          }
          , yk = b._emscripten_bind_btRigidBody_setAnisotropicFriction_2 = function() {
            return (yk = b._emscripten_bind_btRigidBody_setAnisotropicFriction_2 = b.asm.ui).apply(null, arguments)
          }
          , zk = b._emscripten_bind_btRigidBody_getCollisionShape_0 = function() {
            return (zk = b._emscripten_bind_btRigidBody_getCollisionShape_0 = b.asm.vi).apply(null, arguments)
          }
          , Ak = b._emscripten_bind_btRigidBody_setContactProcessingThreshold_1 = function() {
            return (Ak = b._emscripten_bind_btRigidBody_setContactProcessingThreshold_1 = b.asm.wi).apply(null, arguments)
          }
          , Bk = b._emscripten_bind_btRigidBody_setActivationState_1 = function() {
            return (Bk = b._emscripten_bind_btRigidBody_setActivationState_1 = b.asm.xi).apply(null, arguments)
          }
          , Ck = b._emscripten_bind_btRigidBody_forceActivationState_1 = function() {
            return (Ck = b._emscripten_bind_btRigidBody_forceActivationState_1 = b.asm.yi).apply(null, arguments)
          }
          , Dk = b._emscripten_bind_btRigidBody_activate_0 = function() {
            return (Dk = b._emscripten_bind_btRigidBody_activate_0 = b.asm.zi).apply(null, arguments)
          }
          , Ek = b._emscripten_bind_btRigidBody_activate_1 = function() {
            return (Ek = b._emscripten_bind_btRigidBody_activate_1 = b.asm.Ai).apply(null, arguments)
          }
          , Fk = b._emscripten_bind_btRigidBody_isActive_0 = function() {
            return (Fk = b._emscripten_bind_btRigidBody_isActive_0 = b.asm.Bi).apply(null, arguments)
          }
          , Gk = b._emscripten_bind_btRigidBody_isKinematicObject_0 = function() {
            return (Gk = b._emscripten_bind_btRigidBody_isKinematicObject_0 = b.asm.Ci).apply(null, arguments)
          }
          , Hk = b._emscripten_bind_btRigidBody_isStaticObject_0 = function() {
            return (Hk = b._emscripten_bind_btRigidBody_isStaticObject_0 = b.asm.Di).apply(null, arguments)
          }
          , Ik = b._emscripten_bind_btRigidBody_isStaticOrKinematicObject_0 = function() {
            return (Ik = b._emscripten_bind_btRigidBody_isStaticOrKinematicObject_0 = b.asm.Ei).apply(null, arguments)
          }
          , Jk = b._emscripten_bind_btRigidBody_getRestitution_0 = function() {
            return (Jk = b._emscripten_bind_btRigidBody_getRestitution_0 = b.asm.Fi).apply(null, arguments)
          }
          , Kk = b._emscripten_bind_btRigidBody_getFriction_0 = function() {
            return (Kk = b._emscripten_bind_btRigidBody_getFriction_0 = b.asm.Gi).apply(null, arguments)
          }
          , Lk = b._emscripten_bind_btRigidBody_getRollingFriction_0 = function() {
            return (Lk = b._emscripten_bind_btRigidBody_getRollingFriction_0 = b.asm.Hi).apply(null, arguments)
          }
          , Mk = b._emscripten_bind_btRigidBody_setRestitution_1 = function() {
            return (Mk = b._emscripten_bind_btRigidBody_setRestitution_1 = b.asm.Ii).apply(null, arguments)
          }
          , Nk = b._emscripten_bind_btRigidBody_setFriction_1 = function() {
            return (Nk = b._emscripten_bind_btRigidBody_setFriction_1 = b.asm.Ji).apply(null, arguments)
          }
          , Ok = b._emscripten_bind_btRigidBody_setRollingFriction_1 = function() {
            return (Ok = b._emscripten_bind_btRigidBody_setRollingFriction_1 = b.asm.Ki).apply(null, arguments)
          }
          , Pk = b._emscripten_bind_btRigidBody_getWorldTransform_0 = function() {
            return (Pk = b._emscripten_bind_btRigidBody_getWorldTransform_0 = b.asm.Li).apply(null, arguments)
          }
          , Qk = b._emscripten_bind_btRigidBody_getCollisionFlags_0 = function() {
            return (Qk = b._emscripten_bind_btRigidBody_getCollisionFlags_0 = b.asm.Mi).apply(null, arguments)
          }
          , Rk = b._emscripten_bind_btRigidBody_setCollisionFlags_1 = function() {
            return (Rk = b._emscripten_bind_btRigidBody_setCollisionFlags_1 = b.asm.Ni).apply(null, arguments)
          }
          , Sk = b._emscripten_bind_btRigidBody_setWorldTransform_1 = function() {
            return (Sk = b._emscripten_bind_btRigidBody_setWorldTransform_1 = b.asm.Oi).apply(null, arguments)
          }
          , Tk = b._emscripten_bind_btRigidBody_setCollisionShape_1 = function() {
            return (Tk = b._emscripten_bind_btRigidBody_setCollisionShape_1 = b.asm.Pi).apply(null, arguments)
          }
          , Uk = b._emscripten_bind_btRigidBody_setCcdMotionThreshold_1 = function() {
            return (Uk = b._emscripten_bind_btRigidBody_setCcdMotionThreshold_1 = b.asm.Qi).apply(null, arguments)
          }
          , Vk = b._emscripten_bind_btRigidBody_setCcdSweptSphereRadius_1 = function() {
            return (Vk = b._emscripten_bind_btRigidBody_setCcdSweptSphereRadius_1 = b.asm.Ri).apply(null, arguments)
          }
          , Wk = b._emscripten_bind_btRigidBody_getUserIndex_0 = function() {
            return (Wk = b._emscripten_bind_btRigidBody_getUserIndex_0 = b.asm.Si).apply(null, arguments)
          }
          , Xk = b._emscripten_bind_btRigidBody_setUserIndex_1 = function() {
            return (Xk = b._emscripten_bind_btRigidBody_setUserIndex_1 = b.asm.Ti).apply(null, arguments)
          }
          , Yk = b._emscripten_bind_btRigidBody_getUserPointer_0 = function() {
            return (Yk = b._emscripten_bind_btRigidBody_getUserPointer_0 = b.asm.Ui).apply(null, arguments)
          }
          , Zk = b._emscripten_bind_btRigidBody_setUserPointer_1 = function() {
            return (Zk = b._emscripten_bind_btRigidBody_setUserPointer_1 = b.asm.Vi).apply(null, arguments)
          }
          , $k = b._emscripten_bind_btRigidBody_getBroadphaseHandle_0 = function() {
            return ($k = b._emscripten_bind_btRigidBody_getBroadphaseHandle_0 = b.asm.Wi).apply(null, arguments)
          }
          , al = b._emscripten_bind_btRigidBody___destroy___0 = function() {
            return (al = b._emscripten_bind_btRigidBody___destroy___0 = b.asm.Xi).apply(null, arguments)
          }
          , bl = b._emscripten_bind_btIndexedMeshArray_size_0 = function() {
            return (bl = b._emscripten_bind_btIndexedMeshArray_size_0 = b.asm.Yi).apply(null, arguments)
          }
          , cl = b._emscripten_bind_btIndexedMeshArray_at_1 = function() {
            return (cl = b._emscripten_bind_btIndexedMeshArray_at_1 = b.asm.Zi).apply(null, arguments)
          }
          , dl = b._emscripten_bind_btIndexedMeshArray___destroy___0 = function() {
            return (dl = b._emscripten_bind_btIndexedMeshArray___destroy___0 = b.asm._i).apply(null, arguments)
          }
          , el = b._emscripten_bind_btDbvtBroadphase_btDbvtBroadphase_0 = function() {
            return (el = b._emscripten_bind_btDbvtBroadphase_btDbvtBroadphase_0 = b.asm.$i).apply(null, arguments)
          }
          , fl = b._emscripten_bind_btDbvtBroadphase___destroy___0 = function() {
            return (fl = b._emscripten_bind_btDbvtBroadphase___destroy___0 = b.asm.aj).apply(null, arguments)
          }
          , gl = b._emscripten_bind_btHeightfieldTerrainShape_btHeightfieldTerrainShape_9 = function() {
            return (gl = b._emscripten_bind_btHeightfieldTerrainShape_btHeightfieldTerrainShape_9 = b.asm.bj).apply(null, arguments)
          }
          , hl = b._emscripten_bind_btHeightfieldTerrainShape_setMargin_1 = function() {
            return (hl = b._emscripten_bind_btHeightfieldTerrainShape_setMargin_1 = b.asm.cj).apply(null, arguments)
          }
          , il = b._emscripten_bind_btHeightfieldTerrainShape_getMargin_0 = function() {
            return (il = b._emscripten_bind_btHeightfieldTerrainShape_getMargin_0 = b.asm.dj).apply(null, arguments)
          }
          , jl = b._emscripten_bind_btHeightfieldTerrainShape_setLocalScaling_1 = function() {
            return (jl = b._emscripten_bind_btHeightfieldTerrainShape_setLocalScaling_1 = b.asm.ej).apply(null, arguments)
          }
          , kl = b._emscripten_bind_btHeightfieldTerrainShape_getLocalScaling_0 = function() {
            return (kl = b._emscripten_bind_btHeightfieldTerrainShape_getLocalScaling_0 = b.asm.fj).apply(null, arguments)
          }
          , ll = b._emscripten_bind_btHeightfieldTerrainShape_calculateLocalInertia_2 = function() {
            return (ll = b._emscripten_bind_btHeightfieldTerrainShape_calculateLocalInertia_2 = b.asm.gj).apply(null, arguments)
          }
          , ml = b._emscripten_bind_btHeightfieldTerrainShape___destroy___0 = function() {
            return (ml = b._emscripten_bind_btHeightfieldTerrainShape___destroy___0 = b.asm.hj).apply(null, arguments)
          }
          , nl = b._emscripten_bind_btDefaultSoftBodySolver_btDefaultSoftBodySolver_0 = function() {
            return (nl = b._emscripten_bind_btDefaultSoftBodySolver_btDefaultSoftBodySolver_0 = b.asm.ij).apply(null, arguments)
          }
          , ol = b._emscripten_bind_btDefaultSoftBodySolver___destroy___0 = function() {
            return (ol = b._emscripten_bind_btDefaultSoftBodySolver___destroy___0 = b.asm.jj).apply(null, arguments)
          }
          , pl = b._emscripten_bind_btCollisionDispatcher_btCollisionDispatcher_1 = function() {
            return (pl = b._emscripten_bind_btCollisionDispatcher_btCollisionDispatcher_1 = b.asm.kj).apply(null, arguments)
          }
          , ql = b._emscripten_bind_btCollisionDispatcher_getNumManifolds_0 = function() {
            return (ql = b._emscripten_bind_btCollisionDispatcher_getNumManifolds_0 = b.asm.lj).apply(null, arguments)
          }
          , rl = b._emscripten_bind_btCollisionDispatcher_getManifoldByIndexInternal_1 = function() {
            return (rl = b._emscripten_bind_btCollisionDispatcher_getManifoldByIndexInternal_1 = b.asm.mj).apply(null, arguments)
          }
          , sl = b._emscripten_bind_btCollisionDispatcher___destroy___0 = function() {
            return (sl = b._emscripten_bind_btCollisionDispatcher___destroy___0 = b.asm.nj).apply(null, arguments)
          }
          , tl = b._emscripten_bind_btAxisSweep3_btAxisSweep3_2 = function() {
            return (tl = b._emscripten_bind_btAxisSweep3_btAxisSweep3_2 = b.asm.oj).apply(null, arguments)
          }
          , ul = b._emscripten_bind_btAxisSweep3_btAxisSweep3_3 = function() {
            return (ul = b._emscripten_bind_btAxisSweep3_btAxisSweep3_3 = b.asm.pj).apply(null, arguments)
          }
          , vl = b._emscripten_bind_btAxisSweep3_btAxisSweep3_4 = function() {
            return (vl = b._emscripten_bind_btAxisSweep3_btAxisSweep3_4 = b.asm.qj).apply(null, arguments)
          }
          , wl = b._emscripten_bind_btAxisSweep3_btAxisSweep3_5 = function() {
            return (wl = b._emscripten_bind_btAxisSweep3_btAxisSweep3_5 = b.asm.rj).apply(null, arguments)
          }
          , xl = b._emscripten_bind_btAxisSweep3___destroy___0 = function() {
            return (xl = b._emscripten_bind_btAxisSweep3___destroy___0 = b.asm.sj).apply(null, arguments)
          }
          , yl = b._emscripten_bind_VoidPtr___destroy___0 = function() {
            return (yl = b._emscripten_bind_VoidPtr___destroy___0 = b.asm.tj).apply(null, arguments)
          }
          , zl = b._emscripten_bind_btSoftBodyWorldInfo_btSoftBodyWorldInfo_0 = function() {
            return (zl = b._emscripten_bind_btSoftBodyWorldInfo_btSoftBodyWorldInfo_0 = b.asm.uj).apply(null, arguments)
          }
          , Al = b._emscripten_bind_btSoftBodyWorldInfo_get_air_density_0 = function() {
            return (Al = b._emscripten_bind_btSoftBodyWorldInfo_get_air_density_0 = b.asm.vj).apply(null, arguments)
          }
          , Bl = b._emscripten_bind_btSoftBodyWorldInfo_set_air_density_1 = function() {
            return (Bl = b._emscripten_bind_btSoftBodyWorldInfo_set_air_density_1 = b.asm.wj).apply(null, arguments)
          }
          , Cl = b._emscripten_bind_btSoftBodyWorldInfo_get_water_density_0 = function() {
            return (Cl = b._emscripten_bind_btSoftBodyWorldInfo_get_water_density_0 = b.asm.xj).apply(null, arguments)
          }
          , Dl = b._emscripten_bind_btSoftBodyWorldInfo_set_water_density_1 = function() {
            return (Dl = b._emscripten_bind_btSoftBodyWorldInfo_set_water_density_1 = b.asm.yj).apply(null, arguments)
          }
          , El = b._emscripten_bind_btSoftBodyWorldInfo_get_water_offset_0 = function() {
            return (El = b._emscripten_bind_btSoftBodyWorldInfo_get_water_offset_0 = b.asm.zj).apply(null, arguments)
          }
          , Fl = b._emscripten_bind_btSoftBodyWorldInfo_set_water_offset_1 = function() {
            return (Fl = b._emscripten_bind_btSoftBodyWorldInfo_set_water_offset_1 = b.asm.Aj).apply(null, arguments)
          }
          , Gl = b._emscripten_bind_btSoftBodyWorldInfo_get_m_maxDisplacement_0 = function() {
            return (Gl = b._emscripten_bind_btSoftBodyWorldInfo_get_m_maxDisplacement_0 = b.asm.Bj).apply(null, arguments)
          }
          , Hl = b._emscripten_bind_btSoftBodyWorldInfo_set_m_maxDisplacement_1 = function() {
            return (Hl = b._emscripten_bind_btSoftBodyWorldInfo_set_m_maxDisplacement_1 = b.asm.Cj).apply(null, arguments)
          }
          , Il = b._emscripten_bind_btSoftBodyWorldInfo_get_water_normal_0 = function() {
            return (Il = b._emscripten_bind_btSoftBodyWorldInfo_get_water_normal_0 = b.asm.Dj).apply(null, arguments)
          }
          , Jl = b._emscripten_bind_btSoftBodyWorldInfo_set_water_normal_1 = function() {
            return (Jl = b._emscripten_bind_btSoftBodyWorldInfo_set_water_normal_1 = b.asm.Ej).apply(null, arguments)
          }
          , Kl = b._emscripten_bind_btSoftBodyWorldInfo_get_m_broadphase_0 = function() {
            return (Kl = b._emscripten_bind_btSoftBodyWorldInfo_get_m_broadphase_0 = b.asm.Fj).apply(null, arguments)
          }
          , Ll = b._emscripten_bind_btSoftBodyWorldInfo_set_m_broadphase_1 = function() {
            return (Ll = b._emscripten_bind_btSoftBodyWorldInfo_set_m_broadphase_1 = b.asm.Gj).apply(null, arguments)
          }
          , Ml = b._emscripten_bind_btSoftBodyWorldInfo_get_m_dispatcher_0 = function() {
            return (Ml = b._emscripten_bind_btSoftBodyWorldInfo_get_m_dispatcher_0 = b.asm.Hj).apply(null, arguments)
          }
          , Nl = b._emscripten_bind_btSoftBodyWorldInfo_set_m_dispatcher_1 = function() {
            return (Nl = b._emscripten_bind_btSoftBodyWorldInfo_set_m_dispatcher_1 = b.asm.Ij).apply(null, arguments)
          }
          , Ol = b._emscripten_bind_btSoftBodyWorldInfo_get_m_gravity_0 = function() {
            return (Ol = b._emscripten_bind_btSoftBodyWorldInfo_get_m_gravity_0 = b.asm.Jj).apply(null, arguments)
          }
          , Pl = b._emscripten_bind_btSoftBodyWorldInfo_set_m_gravity_1 = function() {
            return (Pl = b._emscripten_bind_btSoftBodyWorldInfo_set_m_gravity_1 = b.asm.Kj).apply(null, arguments)
          }
          , Ql = b._emscripten_bind_btSoftBodyWorldInfo___destroy___0 = function() {
            return (Ql = b._emscripten_bind_btSoftBodyWorldInfo___destroy___0 = b.asm.Lj).apply(null, arguments)
          }
          , Rl = b._emscripten_bind_btConeTwistConstraint_btConeTwistConstraint_2 = function() {
            return (Rl = b._emscripten_bind_btConeTwistConstraint_btConeTwistConstraint_2 = b.asm.Mj).apply(null, arguments)
          }
          , Sl = b._emscripten_bind_btConeTwistConstraint_btConeTwistConstraint_4 = function() {
            return (Sl = b._emscripten_bind_btConeTwistConstraint_btConeTwistConstraint_4 = b.asm.Nj).apply(null, arguments)
          }
          , Tl = b._emscripten_bind_btConeTwistConstraint_setLimit_2 = function() {
            return (Tl = b._emscripten_bind_btConeTwistConstraint_setLimit_2 = b.asm.Oj).apply(null, arguments)
          }
          , Ul = b._emscripten_bind_btConeTwistConstraint_setAngularOnly_1 = function() {
            return (Ul = b._emscripten_bind_btConeTwistConstraint_setAngularOnly_1 = b.asm.Pj).apply(null, arguments)
          }
          , Vl = b._emscripten_bind_btConeTwistConstraint_setDamping_1 = function() {
            return (Vl = b._emscripten_bind_btConeTwistConstraint_setDamping_1 = b.asm.Qj).apply(null, arguments)
          }
          , Wl = b._emscripten_bind_btConeTwistConstraint_enableMotor_1 = function() {
            return (Wl = b._emscripten_bind_btConeTwistConstraint_enableMotor_1 = b.asm.Rj).apply(null, arguments)
          }
          , Xl = b._emscripten_bind_btConeTwistConstraint_setMaxMotorImpulse_1 = function() {
            return (Xl = b._emscripten_bind_btConeTwistConstraint_setMaxMotorImpulse_1 = b.asm.Sj).apply(null, arguments)
          }
          , Yl = b._emscripten_bind_btConeTwistConstraint_setMaxMotorImpulseNormalized_1 = function() {
            return (Yl = b._emscripten_bind_btConeTwistConstraint_setMaxMotorImpulseNormalized_1 = b.asm.Tj).apply(null, arguments)
          }
          , Zl = b._emscripten_bind_btConeTwistConstraint_setMotorTarget_1 = function() {
            return (Zl = b._emscripten_bind_btConeTwistConstraint_setMotorTarget_1 = b.asm.Uj).apply(null, arguments)
          }
          , $l = b._emscripten_bind_btConeTwistConstraint_setMotorTargetInConstraintSpace_1 = function() {
            return ($l = b._emscripten_bind_btConeTwistConstraint_setMotorTargetInConstraintSpace_1 = b.asm.Vj).apply(null, arguments)
          }
          , am = b._emscripten_bind_btConeTwistConstraint_enableFeedback_1 = function() {
            return (am = b._emscripten_bind_btConeTwistConstraint_enableFeedback_1 = b.asm.Wj).apply(null, arguments)
          }
          , bm = b._emscripten_bind_btConeTwistConstraint_getBreakingImpulseThreshold_0 = function() {
            return (bm = b._emscripten_bind_btConeTwistConstraint_getBreakingImpulseThreshold_0 = b.asm.Xj).apply(null, arguments)
          }
          , cm = b._emscripten_bind_btConeTwistConstraint_setBreakingImpulseThreshold_1 = function() {
            return (cm = b._emscripten_bind_btConeTwistConstraint_setBreakingImpulseThreshold_1 = b.asm.Yj).apply(null, arguments)
          }
          , dm = b._emscripten_bind_btConeTwistConstraint_getParam_2 = function() {
            return (dm = b._emscripten_bind_btConeTwistConstraint_getParam_2 = b.asm.Zj).apply(null, arguments)
          }
          , em = b._emscripten_bind_btConeTwistConstraint_setParam_3 = function() {
            return (em = b._emscripten_bind_btConeTwistConstraint_setParam_3 = b.asm._j).apply(null, arguments)
          }
          , fm = b._emscripten_bind_btConeTwistConstraint___destroy___0 = function() {
            return (fm = b._emscripten_bind_btConeTwistConstraint___destroy___0 = b.asm.$j).apply(null, arguments)
          }
          , gm = b._emscripten_bind_btHingeConstraint_btHingeConstraint_2 = function() {
            return (gm = b._emscripten_bind_btHingeConstraint_btHingeConstraint_2 = b.asm.ak).apply(null, arguments)
          }
          , hm = b._emscripten_bind_btHingeConstraint_btHingeConstraint_3 = function() {
            return (hm = b._emscripten_bind_btHingeConstraint_btHingeConstraint_3 = b.asm.bk).apply(null, arguments)
          }
          , im = b._emscripten_bind_btHingeConstraint_btHingeConstraint_4 = function() {
            return (im = b._emscripten_bind_btHingeConstraint_btHingeConstraint_4 = b.asm.ck).apply(null, arguments)
          }
          , jm = b._emscripten_bind_btHingeConstraint_btHingeConstraint_5 = function() {
            return (jm = b._emscripten_bind_btHingeConstraint_btHingeConstraint_5 = b.asm.dk).apply(null, arguments)
          }
          , km = b._emscripten_bind_btHingeConstraint_btHingeConstraint_6 = function() {
            return (km = b._emscripten_bind_btHingeConstraint_btHingeConstraint_6 = b.asm.ek).apply(null, arguments)
          }
          , lm = b._emscripten_bind_btHingeConstraint_btHingeConstraint_7 = function() {
            return (lm = b._emscripten_bind_btHingeConstraint_btHingeConstraint_7 = b.asm.fk).apply(null, arguments)
          }
          , mm = b._emscripten_bind_btHingeConstraint_setLimit_4 = function() {
            return (mm = b._emscripten_bind_btHingeConstraint_setLimit_4 = b.asm.gk).apply(null, arguments)
          }
          , nm = b._emscripten_bind_btHingeConstraint_setLimit_5 = function() {
            return (nm = b._emscripten_bind_btHingeConstraint_setLimit_5 = b.asm.hk).apply(null, arguments)
          }
          , om = b._emscripten_bind_btHingeConstraint_enableAngularMotor_3 = function() {
            return (om = b._emscripten_bind_btHingeConstraint_enableAngularMotor_3 = b.asm.ik).apply(null, arguments)
          }
          , pm = b._emscripten_bind_btHingeConstraint_setAngularOnly_1 = function() {
            return (pm = b._emscripten_bind_btHingeConstraint_setAngularOnly_1 = b.asm.jk).apply(null, arguments)
          }
          , qm = b._emscripten_bind_btHingeConstraint_enableMotor_1 = function() {
            return (qm = b._emscripten_bind_btHingeConstraint_enableMotor_1 = b.asm.kk).apply(null, arguments)
          }
          , rm = b._emscripten_bind_btHingeConstraint_setMaxMotorImpulse_1 = function() {
            return (rm = b._emscripten_bind_btHingeConstraint_setMaxMotorImpulse_1 = b.asm.lk).apply(null, arguments)
          }
          , sm = b._emscripten_bind_btHingeConstraint_setMotorTarget_2 = function() {
            return (sm = b._emscripten_bind_btHingeConstraint_setMotorTarget_2 = b.asm.mk).apply(null, arguments)
          }
          , tm = b._emscripten_bind_btHingeConstraint_enableFeedback_1 = function() {
            return (tm = b._emscripten_bind_btHingeConstraint_enableFeedback_1 = b.asm.nk).apply(null, arguments)
          }
          , um = b._emscripten_bind_btHingeConstraint_getBreakingImpulseThreshold_0 = function() {
            return (um = b._emscripten_bind_btHingeConstraint_getBreakingImpulseThreshold_0 = b.asm.ok).apply(null, arguments)
          }
          , wm = b._emscripten_bind_btHingeConstraint_setBreakingImpulseThreshold_1 = function() {
            return (wm = b._emscripten_bind_btHingeConstraint_setBreakingImpulseThreshold_1 = b.asm.pk).apply(null, arguments)
          }
          , xm = b._emscripten_bind_btHingeConstraint_getParam_2 = function() {
            return (xm = b._emscripten_bind_btHingeConstraint_getParam_2 = b.asm.qk).apply(null, arguments)
          }
          , ym = b._emscripten_bind_btHingeConstraint_setParam_3 = function() {
            return (ym = b._emscripten_bind_btHingeConstraint_setParam_3 = b.asm.rk).apply(null, arguments)
          }
          , zm = b._emscripten_bind_btHingeConstraint___destroy___0 = function() {
            return (zm = b._emscripten_bind_btHingeConstraint___destroy___0 = b.asm.sk).apply(null, arguments)
          }
          , Am = b._emscripten_bind_btConeShapeZ_btConeShapeZ_2 = function() {
            return (Am = b._emscripten_bind_btConeShapeZ_btConeShapeZ_2 = b.asm.tk).apply(null, arguments)
          }
          , Bm = b._emscripten_bind_btConeShapeZ_setLocalScaling_1 = function() {
            return (Bm = b._emscripten_bind_btConeShapeZ_setLocalScaling_1 = b.asm.uk).apply(null, arguments)
          }
          , Cm = b._emscripten_bind_btConeShapeZ_getLocalScaling_0 = function() {
            return (Cm = b._emscripten_bind_btConeShapeZ_getLocalScaling_0 = b.asm.vk).apply(null, arguments)
          }
          , Dm = b._emscripten_bind_btConeShapeZ_calculateLocalInertia_2 = function() {
            return (Dm = b._emscripten_bind_btConeShapeZ_calculateLocalInertia_2 = b.asm.wk).apply(null, arguments)
          }
          , Em = b._emscripten_bind_btConeShapeZ___destroy___0 = function() {
            return (Em = b._emscripten_bind_btConeShapeZ___destroy___0 = b.asm.xk).apply(null, arguments)
          }
          , Fm = b._emscripten_bind_btConeShapeX_btConeShapeX_2 = function() {
            return (Fm = b._emscripten_bind_btConeShapeX_btConeShapeX_2 = b.asm.yk).apply(null, arguments)
          }
          , Gm = b._emscripten_bind_btConeShapeX_setLocalScaling_1 = function() {
            return (Gm = b._emscripten_bind_btConeShapeX_setLocalScaling_1 = b.asm.zk).apply(null, arguments)
          }
          , Hm = b._emscripten_bind_btConeShapeX_getLocalScaling_0 = function() {
            return (Hm = b._emscripten_bind_btConeShapeX_getLocalScaling_0 = b.asm.Ak).apply(null, arguments)
          }
          , Im = b._emscripten_bind_btConeShapeX_calculateLocalInertia_2 = function() {
            return (Im = b._emscripten_bind_btConeShapeX_calculateLocalInertia_2 = b.asm.Bk).apply(null, arguments)
          }
          , Jm = b._emscripten_bind_btConeShapeX___destroy___0 = function() {
            return (Jm = b._emscripten_bind_btConeShapeX___destroy___0 = b.asm.Ck).apply(null, arguments)
          }
          , Km = b._emscripten_bind_btTriangleMesh_btTriangleMesh_0 = function() {
            return (Km = b._emscripten_bind_btTriangleMesh_btTriangleMesh_0 = b.asm.Dk).apply(null, arguments)
          }
          , Lm = b._emscripten_bind_btTriangleMesh_btTriangleMesh_1 = function() {
            return (Lm = b._emscripten_bind_btTriangleMesh_btTriangleMesh_1 = b.asm.Ek).apply(null, arguments)
          }
          , Mm = b._emscripten_bind_btTriangleMesh_btTriangleMesh_2 = function() {
            return (Mm = b._emscripten_bind_btTriangleMesh_btTriangleMesh_2 = b.asm.Fk).apply(null, arguments)
          }
          , Nm = b._emscripten_bind_btTriangleMesh_addTriangle_3 = function() {
            return (Nm = b._emscripten_bind_btTriangleMesh_addTriangle_3 = b.asm.Gk).apply(null, arguments)
          }
          , Om = b._emscripten_bind_btTriangleMesh_addTriangle_4 = function() {
            return (Om = b._emscripten_bind_btTriangleMesh_addTriangle_4 = b.asm.Hk).apply(null, arguments)
          }
          , Pm = b._emscripten_bind_btTriangleMesh_findOrAddVertex_2 = function() {
            return (Pm = b._emscripten_bind_btTriangleMesh_findOrAddVertex_2 = b.asm.Ik).apply(null, arguments)
          }
          , Qm = b._emscripten_bind_btTriangleMesh_addIndex_1 = function() {
            return (Qm = b._emscripten_bind_btTriangleMesh_addIndex_1 = b.asm.Jk).apply(null, arguments)
          }
          , Rm = b._emscripten_bind_btTriangleMesh_getIndexedMeshArray_0 = function() {
            return (Rm = b._emscripten_bind_btTriangleMesh_getIndexedMeshArray_0 = b.asm.Kk).apply(null, arguments)
          }
          , Sm = b._emscripten_bind_btTriangleMesh_setScaling_1 = function() {
            return (Sm = b._emscripten_bind_btTriangleMesh_setScaling_1 = b.asm.Lk).apply(null, arguments)
          }
          , Tm = b._emscripten_bind_btTriangleMesh___destroy___0 = function() {
            return (Tm = b._emscripten_bind_btTriangleMesh___destroy___0 = b.asm.Mk).apply(null, arguments)
          }
          , Um = b._emscripten_bind_btConvexHullShape_btConvexHullShape_0 = function() {
            return (Um = b._emscripten_bind_btConvexHullShape_btConvexHullShape_0 = b.asm.Nk).apply(null, arguments)
          }
          , Vm = b._emscripten_bind_btConvexHullShape_btConvexHullShape_1 = function() {
            return (Vm = b._emscripten_bind_btConvexHullShape_btConvexHullShape_1 = b.asm.Ok).apply(null, arguments)
          }
          , Wm = b._emscripten_bind_btConvexHullShape_btConvexHullShape_2 = function() {
            return (Wm = b._emscripten_bind_btConvexHullShape_btConvexHullShape_2 = b.asm.Pk).apply(null, arguments)
          }
          , Xm = b._emscripten_bind_btConvexHullShape_addPoint_1 = function() {
            return (Xm = b._emscripten_bind_btConvexHullShape_addPoint_1 = b.asm.Qk).apply(null, arguments)
          }
          , Ym = b._emscripten_bind_btConvexHullShape_addPoint_2 = function() {
            return (Ym = b._emscripten_bind_btConvexHullShape_addPoint_2 = b.asm.Rk).apply(null, arguments)
          }
          , Zm = b._emscripten_bind_btConvexHullShape_setMargin_1 = function() {
            return (Zm = b._emscripten_bind_btConvexHullShape_setMargin_1 = b.asm.Sk).apply(null, arguments)
          }
          , $m = b._emscripten_bind_btConvexHullShape_getMargin_0 = function() {
            return ($m = b._emscripten_bind_btConvexHullShape_getMargin_0 = b.asm.Tk).apply(null, arguments)
          }
          , an = b._emscripten_bind_btConvexHullShape_getNumVertices_0 = function() {
            return (an = b._emscripten_bind_btConvexHullShape_getNumVertices_0 = b.asm.Uk).apply(null, arguments)
          }
          , bn = b._emscripten_bind_btConvexHullShape_initializePolyhedralFeatures_1 = function() {
            return (bn = b._emscripten_bind_btConvexHullShape_initializePolyhedralFeatures_1 = b.asm.Vk).apply(null, arguments)
          }
          , cn = b._emscripten_bind_btConvexHullShape_recalcLocalAabb_0 = function() {
            return (cn = b._emscripten_bind_btConvexHullShape_recalcLocalAabb_0 = b.asm.Wk).apply(null, arguments)
          }
          , dn = b._emscripten_bind_btConvexHullShape_getConvexPolyhedron_0 = function() {
            return (dn = b._emscripten_bind_btConvexHullShape_getConvexPolyhedron_0 = b.asm.Xk).apply(null, arguments)
          }
          , en = b._emscripten_bind_btConvexHullShape_setLocalScaling_1 = function() {
            return (en = b._emscripten_bind_btConvexHullShape_setLocalScaling_1 = b.asm.Yk).apply(null, arguments)
          }
          , fn = b._emscripten_bind_btConvexHullShape_getLocalScaling_0 = function() {
            return (fn = b._emscripten_bind_btConvexHullShape_getLocalScaling_0 = b.asm.Zk).apply(null, arguments)
          }
          , gn = b._emscripten_bind_btConvexHullShape_calculateLocalInertia_2 = function() {
            return (gn = b._emscripten_bind_btConvexHullShape_calculateLocalInertia_2 = b.asm._k).apply(null, arguments)
          }
          , hn = b._emscripten_bind_btConvexHullShape___destroy___0 = function() {
            return (hn = b._emscripten_bind_btConvexHullShape___destroy___0 = b.asm.$k).apply(null, arguments)
          }
          , jn = b._emscripten_bind_btVehicleTuning_btVehicleTuning_0 = function() {
            return (jn = b._emscripten_bind_btVehicleTuning_btVehicleTuning_0 = b.asm.al).apply(null, arguments)
          }
          , kn = b._emscripten_bind_btVehicleTuning_get_m_suspensionStiffness_0 = function() {
            return (kn = b._emscripten_bind_btVehicleTuning_get_m_suspensionStiffness_0 = b.asm.bl).apply(null, arguments)
          }
          , ln = b._emscripten_bind_btVehicleTuning_set_m_suspensionStiffness_1 = function() {
            return (ln = b._emscripten_bind_btVehicleTuning_set_m_suspensionStiffness_1 = b.asm.cl).apply(null, arguments)
          }
          , mn = b._emscripten_bind_btVehicleTuning_get_m_suspensionCompression_0 = function() {
            return (mn = b._emscripten_bind_btVehicleTuning_get_m_suspensionCompression_0 = b.asm.dl).apply(null, arguments)
          }
          , nn = b._emscripten_bind_btVehicleTuning_set_m_suspensionCompression_1 = function() {
            return (nn = b._emscripten_bind_btVehicleTuning_set_m_suspensionCompression_1 = b.asm.el).apply(null, arguments)
          }
          , on = b._emscripten_bind_btVehicleTuning_get_m_suspensionDamping_0 = function() {
            return (on = b._emscripten_bind_btVehicleTuning_get_m_suspensionDamping_0 = b.asm.fl).apply(null, arguments)
          }
          , pn = b._emscripten_bind_btVehicleTuning_set_m_suspensionDamping_1 = function() {
            return (pn = b._emscripten_bind_btVehicleTuning_set_m_suspensionDamping_1 = b.asm.gl).apply(null, arguments)
          }
          , qn = b._emscripten_bind_btVehicleTuning_get_m_maxSuspensionTravelCm_0 = function() {
            return (qn = b._emscripten_bind_btVehicleTuning_get_m_maxSuspensionTravelCm_0 = b.asm.hl).apply(null, arguments)
          }
          , rn = b._emscripten_bind_btVehicleTuning_set_m_maxSuspensionTravelCm_1 = function() {
            return (rn = b._emscripten_bind_btVehicleTuning_set_m_maxSuspensionTravelCm_1 = b.asm.il).apply(null, arguments)
          }
          , sn = b._emscripten_bind_btVehicleTuning_get_m_frictionSlip_0 = function() {
            return (sn = b._emscripten_bind_btVehicleTuning_get_m_frictionSlip_0 = b.asm.jl).apply(null, arguments)
          }
          , tn = b._emscripten_bind_btVehicleTuning_set_m_frictionSlip_1 = function() {
            return (tn = b._emscripten_bind_btVehicleTuning_set_m_frictionSlip_1 = b.asm.kl).apply(null, arguments)
          }
          , un = b._emscripten_bind_btVehicleTuning_get_m_maxSuspensionForce_0 = function() {
            return (un = b._emscripten_bind_btVehicleTuning_get_m_maxSuspensionForce_0 = b.asm.ll).apply(null, arguments)
          }
          , vn = b._emscripten_bind_btVehicleTuning_set_m_maxSuspensionForce_1 = function() {
            return (vn = b._emscripten_bind_btVehicleTuning_set_m_maxSuspensionForce_1 = b.asm.ml).apply(null, arguments)
          }
          , wn = b._emscripten_bind_btCollisionObjectWrapper_getWorldTransform_0 = function() {
            return (wn = b._emscripten_bind_btCollisionObjectWrapper_getWorldTransform_0 = b.asm.nl).apply(null, arguments)
          }
          , xn = b._emscripten_bind_btCollisionObjectWrapper_getCollisionObject_0 = function() {
            return (xn = b._emscripten_bind_btCollisionObjectWrapper_getCollisionObject_0 = b.asm.ol).apply(null, arguments)
          }
          , yn = b._emscripten_bind_btCollisionObjectWrapper_getCollisionShape_0 = function() {
            return (yn = b._emscripten_bind_btCollisionObjectWrapper_getCollisionShape_0 = b.asm.pl).apply(null, arguments)
          }
          , zn = b._emscripten_bind_btShapeHull_btShapeHull_1 = function() {
            return (zn = b._emscripten_bind_btShapeHull_btShapeHull_1 = b.asm.ql).apply(null, arguments)
          }
          , An = b._emscripten_bind_btShapeHull_buildHull_1 = function() {
            return (An = b._emscripten_bind_btShapeHull_buildHull_1 = b.asm.rl).apply(null, arguments)
          }
          , Bn = b._emscripten_bind_btShapeHull_numVertices_0 = function() {
            return (Bn = b._emscripten_bind_btShapeHull_numVertices_0 = b.asm.sl).apply(null, arguments)
          }
          , Cn = b._emscripten_bind_btShapeHull_getVertexPointer_0 = function() {
            return (Cn = b._emscripten_bind_btShapeHull_getVertexPointer_0 = b.asm.tl).apply(null, arguments)
          }
          , Dn = b._emscripten_bind_btShapeHull___destroy___0 = function() {
            return (Dn = b._emscripten_bind_btShapeHull___destroy___0 = b.asm.ul).apply(null, arguments)
          }
          , En = b._emscripten_bind_btDefaultMotionState_btDefaultMotionState_0 = function() {
            return (En = b._emscripten_bind_btDefaultMotionState_btDefaultMotionState_0 = b.asm.vl).apply(null, arguments)
          }
          , Fn = b._emscripten_bind_btDefaultMotionState_btDefaultMotionState_1 = function() {
            return (Fn = b._emscripten_bind_btDefaultMotionState_btDefaultMotionState_1 = b.asm.wl).apply(null, arguments)
          }
          , Gn = b._emscripten_bind_btDefaultMotionState_btDefaultMotionState_2 = function() {
            return (Gn = b._emscripten_bind_btDefaultMotionState_btDefaultMotionState_2 = b.asm.xl).apply(null, arguments)
          }
          , Hn = b._emscripten_bind_btDefaultMotionState_getWorldTransform_1 = function() {
            return (Hn = b._emscripten_bind_btDefaultMotionState_getWorldTransform_1 = b.asm.yl).apply(null, arguments)
          }
          , In = b._emscripten_bind_btDefaultMotionState_setWorldTransform_1 = function() {
            return (In = b._emscripten_bind_btDefaultMotionState_setWorldTransform_1 = b.asm.zl).apply(null, arguments)
          }
          , Jn = b._emscripten_bind_btDefaultMotionState_get_m_graphicsWorldTrans_0 = function() {
            return (Jn = b._emscripten_bind_btDefaultMotionState_get_m_graphicsWorldTrans_0 = b.asm.Al).apply(null, arguments)
          }
          , Kn = b._emscripten_bind_btDefaultMotionState_set_m_graphicsWorldTrans_1 = function() {
            return (Kn = b._emscripten_bind_btDefaultMotionState_set_m_graphicsWorldTrans_1 = b.asm.Bl).apply(null, arguments)
          }
          , Ln = b._emscripten_bind_btDefaultMotionState___destroy___0 = function() {
            return (Ln = b._emscripten_bind_btDefaultMotionState___destroy___0 = b.asm.Cl).apply(null, arguments)
          }
          , Mn = b._emscripten_bind_btWheelInfo_btWheelInfo_1 = function() {
            return (Mn = b._emscripten_bind_btWheelInfo_btWheelInfo_1 = b.asm.Dl).apply(null, arguments)
          }
          , Nn = b._emscripten_bind_btWheelInfo_getSuspensionRestLength_0 = function() {
            return (Nn = b._emscripten_bind_btWheelInfo_getSuspensionRestLength_0 = b.asm.El).apply(null, arguments)
          }
          , On = b._emscripten_bind_btWheelInfo_updateWheel_2 = function() {
            return (On = b._emscripten_bind_btWheelInfo_updateWheel_2 = b.asm.Fl).apply(null, arguments)
          }
          , Pn = b._emscripten_bind_btWheelInfo_get_m_suspensionStiffness_0 = function() {
            return (Pn = b._emscripten_bind_btWheelInfo_get_m_suspensionStiffness_0 = b.asm.Gl).apply(null, arguments)
          }
          , Qn = b._emscripten_bind_btWheelInfo_set_m_suspensionStiffness_1 = function() {
            return (Qn = b._emscripten_bind_btWheelInfo_set_m_suspensionStiffness_1 = b.asm.Hl).apply(null, arguments)
          }
          , Rn = b._emscripten_bind_btWheelInfo_get_m_frictionSlip_0 = function() {
            return (Rn = b._emscripten_bind_btWheelInfo_get_m_frictionSlip_0 = b.asm.Il).apply(null, arguments)
          }
          , Sn = b._emscripten_bind_btWheelInfo_set_m_frictionSlip_1 = function() {
            return (Sn = b._emscripten_bind_btWheelInfo_set_m_frictionSlip_1 = b.asm.Jl).apply(null, arguments)
          }
          , Tn = b._emscripten_bind_btWheelInfo_get_m_engineForce_0 = function() {
            return (Tn = b._emscripten_bind_btWheelInfo_get_m_engineForce_0 = b.asm.Kl).apply(null, arguments)
          }
          , Un = b._emscripten_bind_btWheelInfo_set_m_engineForce_1 = function() {
            return (Un = b._emscripten_bind_btWheelInfo_set_m_engineForce_1 = b.asm.Ll).apply(null, arguments)
          }
          , Vn = b._emscripten_bind_btWheelInfo_get_m_rollInfluence_0 = function() {
            return (Vn = b._emscripten_bind_btWheelInfo_get_m_rollInfluence_0 = b.asm.Ml).apply(null, arguments)
          }
          , Wn = b._emscripten_bind_btWheelInfo_set_m_rollInfluence_1 = function() {
            return (Wn = b._emscripten_bind_btWheelInfo_set_m_rollInfluence_1 = b.asm.Nl).apply(null, arguments)
          }
          , Xn = b._emscripten_bind_btWheelInfo_get_m_suspensionRestLength1_0 = function() {
            return (Xn = b._emscripten_bind_btWheelInfo_get_m_suspensionRestLength1_0 = b.asm.Ol).apply(null, arguments)
          }
          , Yn = b._emscripten_bind_btWheelInfo_set_m_suspensionRestLength1_1 = function() {
            return (Yn = b._emscripten_bind_btWheelInfo_set_m_suspensionRestLength1_1 = b.asm.Pl).apply(null, arguments)
          }
          , Zn = b._emscripten_bind_btWheelInfo_get_m_wheelsRadius_0 = function() {
            return (Zn = b._emscripten_bind_btWheelInfo_get_m_wheelsRadius_0 = b.asm.Ql).apply(null, arguments)
          }
          , $n = b._emscripten_bind_btWheelInfo_set_m_wheelsRadius_1 = function() {
            return ($n = b._emscripten_bind_btWheelInfo_set_m_wheelsRadius_1 = b.asm.Rl).apply(null, arguments)
          }
          , ao = b._emscripten_bind_btWheelInfo_get_m_wheelsDampingCompression_0 = function() {
            return (ao = b._emscripten_bind_btWheelInfo_get_m_wheelsDampingCompression_0 = b.asm.Sl).apply(null, arguments)
          }
          , bo = b._emscripten_bind_btWheelInfo_set_m_wheelsDampingCompression_1 = function() {
            return (bo = b._emscripten_bind_btWheelInfo_set_m_wheelsDampingCompression_1 = b.asm.Tl).apply(null, arguments)
          }
          , co = b._emscripten_bind_btWheelInfo_get_m_wheelsDampingRelaxation_0 = function() {
            return (co = b._emscripten_bind_btWheelInfo_get_m_wheelsDampingRelaxation_0 = b.asm.Ul).apply(null, arguments)
          }
          , eo = b._emscripten_bind_btWheelInfo_set_m_wheelsDampingRelaxation_1 = function() {
            return (eo = b._emscripten_bind_btWheelInfo_set_m_wheelsDampingRelaxation_1 = b.asm.Vl).apply(null, arguments)
          }
          , fo = b._emscripten_bind_btWheelInfo_get_m_steering_0 = function() {
            return (fo = b._emscripten_bind_btWheelInfo_get_m_steering_0 = b.asm.Wl).apply(null, arguments)
          }
          , go = b._emscripten_bind_btWheelInfo_set_m_steering_1 = function() {
            return (go = b._emscripten_bind_btWheelInfo_set_m_steering_1 = b.asm.Xl).apply(null, arguments)
          }
          , ho = b._emscripten_bind_btWheelInfo_get_m_maxSuspensionForce_0 = function() {
            return (ho = b._emscripten_bind_btWheelInfo_get_m_maxSuspensionForce_0 = b.asm.Yl).apply(null, arguments)
          }
          , io = b._emscripten_bind_btWheelInfo_set_m_maxSuspensionForce_1 = function() {
            return (io = b._emscripten_bind_btWheelInfo_set_m_maxSuspensionForce_1 = b.asm.Zl).apply(null, arguments)
          }
          , jo = b._emscripten_bind_btWheelInfo_get_m_maxSuspensionTravelCm_0 = function() {
            return (jo = b._emscripten_bind_btWheelInfo_get_m_maxSuspensionTravelCm_0 = b.asm._l).apply(null, arguments)
          }
          , ko = b._emscripten_bind_btWheelInfo_set_m_maxSuspensionTravelCm_1 = function() {
            return (ko = b._emscripten_bind_btWheelInfo_set_m_maxSuspensionTravelCm_1 = b.asm.$l).apply(null, arguments)
          }
          , lo = b._emscripten_bind_btWheelInfo_get_m_wheelsSuspensionForce_0 = function() {
            return (lo = b._emscripten_bind_btWheelInfo_get_m_wheelsSuspensionForce_0 = b.asm.am).apply(null, arguments)
          }
          , mo = b._emscripten_bind_btWheelInfo_set_m_wheelsSuspensionForce_1 = function() {
            return (mo = b._emscripten_bind_btWheelInfo_set_m_wheelsSuspensionForce_1 = b.asm.bm).apply(null, arguments)
          }
          , no = b._emscripten_bind_btWheelInfo_get_m_bIsFrontWheel_0 = function() {
            return (no = b._emscripten_bind_btWheelInfo_get_m_bIsFrontWheel_0 = b.asm.cm).apply(null, arguments)
          }
          , oo = b._emscripten_bind_btWheelInfo_set_m_bIsFrontWheel_1 = function() {
            return (oo = b._emscripten_bind_btWheelInfo_set_m_bIsFrontWheel_1 = b.asm.dm).apply(null, arguments)
          }
          , po = b._emscripten_bind_btWheelInfo_get_m_raycastInfo_0 = function() {
            return (po = b._emscripten_bind_btWheelInfo_get_m_raycastInfo_0 = b.asm.em).apply(null, arguments)
          }
          , qo = b._emscripten_bind_btWheelInfo_set_m_raycastInfo_1 = function() {
            return (qo = b._emscripten_bind_btWheelInfo_set_m_raycastInfo_1 = b.asm.fm).apply(null, arguments)
          }
          , ro = b._emscripten_bind_btWheelInfo_get_m_chassisConnectionPointCS_0 = function() {
            return (ro = b._emscripten_bind_btWheelInfo_get_m_chassisConnectionPointCS_0 = b.asm.gm).apply(null, arguments)
          }
          , so = b._emscripten_bind_btWheelInfo_set_m_chassisConnectionPointCS_1 = function() {
            return (so = b._emscripten_bind_btWheelInfo_set_m_chassisConnectionPointCS_1 = b.asm.hm).apply(null, arguments)
          }
          , to = b._emscripten_bind_btWheelInfo_get_m_worldTransform_0 = function() {
            return (to = b._emscripten_bind_btWheelInfo_get_m_worldTransform_0 = b.asm.im).apply(null, arguments)
          }
          , uo = b._emscripten_bind_btWheelInfo_set_m_worldTransform_1 = function() {
            return (uo = b._emscripten_bind_btWheelInfo_set_m_worldTransform_1 = b.asm.jm).apply(null, arguments)
          }
          , vo = b._emscripten_bind_btWheelInfo_get_m_wheelDirectionCS_0 = function() {
            return (vo = b._emscripten_bind_btWheelInfo_get_m_wheelDirectionCS_0 = b.asm.km).apply(null, arguments)
          }
          , wo = b._emscripten_bind_btWheelInfo_set_m_wheelDirectionCS_1 = function() {
            return (wo = b._emscripten_bind_btWheelInfo_set_m_wheelDirectionCS_1 = b.asm.lm).apply(null, arguments)
          }
          , xo = b._emscripten_bind_btWheelInfo_get_m_wheelAxleCS_0 = function() {
            return (xo = b._emscripten_bind_btWheelInfo_get_m_wheelAxleCS_0 = b.asm.mm).apply(null, arguments)
          }
          , yo = b._emscripten_bind_btWheelInfo_set_m_wheelAxleCS_1 = function() {
            return (yo = b._emscripten_bind_btWheelInfo_set_m_wheelAxleCS_1 = b.asm.nm).apply(null, arguments)
          }
          , zo = b._emscripten_bind_btWheelInfo_get_m_rotation_0 = function() {
            return (zo = b._emscripten_bind_btWheelInfo_get_m_rotation_0 = b.asm.om).apply(null, arguments)
          }
          , Ao = b._emscripten_bind_btWheelInfo_set_m_rotation_1 = function() {
            return (Ao = b._emscripten_bind_btWheelInfo_set_m_rotation_1 = b.asm.pm).apply(null, arguments)
          }
          , Bo = b._emscripten_bind_btWheelInfo_get_m_deltaRotation_0 = function() {
            return (Bo = b._emscripten_bind_btWheelInfo_get_m_deltaRotation_0 = b.asm.qm).apply(null, arguments)
          }
          , Co = b._emscripten_bind_btWheelInfo_set_m_deltaRotation_1 = function() {
            return (Co = b._emscripten_bind_btWheelInfo_set_m_deltaRotation_1 = b.asm.rm).apply(null, arguments)
          }
          , Do = b._emscripten_bind_btWheelInfo_get_m_brake_0 = function() {
            return (Do = b._emscripten_bind_btWheelInfo_get_m_brake_0 = b.asm.sm).apply(null, arguments)
          }
          , Eo = b._emscripten_bind_btWheelInfo_set_m_brake_1 = function() {
            return (Eo = b._emscripten_bind_btWheelInfo_set_m_brake_1 = b.asm.tm).apply(null, arguments)
          }
          , Fo = b._emscripten_bind_btWheelInfo_get_m_clippedInvContactDotSuspension_0 = function() {
            return (Fo = b._emscripten_bind_btWheelInfo_get_m_clippedInvContactDotSuspension_0 = b.asm.um).apply(null, arguments)
          }
          , Go = b._emscripten_bind_btWheelInfo_set_m_clippedInvContactDotSuspension_1 = function() {
            return (Go = b._emscripten_bind_btWheelInfo_set_m_clippedInvContactDotSuspension_1 = b.asm.vm).apply(null, arguments)
          }
          , Ho = b._emscripten_bind_btWheelInfo_get_m_suspensionRelativeVelocity_0 = function() {
            return (Ho = b._emscripten_bind_btWheelInfo_get_m_suspensionRelativeVelocity_0 = b.asm.wm).apply(null, arguments)
          }
          , Io = b._emscripten_bind_btWheelInfo_set_m_suspensionRelativeVelocity_1 = function() {
            return (Io = b._emscripten_bind_btWheelInfo_set_m_suspensionRelativeVelocity_1 = b.asm.xm).apply(null, arguments)
          }
          , Jo = b._emscripten_bind_btWheelInfo_get_m_skidInfo_0 = function() {
            return (Jo = b._emscripten_bind_btWheelInfo_get_m_skidInfo_0 = b.asm.ym).apply(null, arguments)
          }
          , Ko = b._emscripten_bind_btWheelInfo_set_m_skidInfo_1 = function() {
            return (Ko = b._emscripten_bind_btWheelInfo_set_m_skidInfo_1 = b.asm.zm).apply(null, arguments)
          }
          , Lo = b._emscripten_bind_btWheelInfo___destroy___0 = function() {
            return (Lo = b._emscripten_bind_btWheelInfo___destroy___0 = b.asm.Am).apply(null, arguments)
          }
          , Mo = b._emscripten_bind_btVector4_btVector4_0 = function() {
            return (Mo = b._emscripten_bind_btVector4_btVector4_0 = b.asm.Bm).apply(null, arguments)
          }
          , No = b._emscripten_bind_btVector4_btVector4_4 = function() {
            return (No = b._emscripten_bind_btVector4_btVector4_4 = b.asm.Cm).apply(null, arguments)
          }
          , Oo = b._emscripten_bind_btVector4_w_0 = function() {
            return (Oo = b._emscripten_bind_btVector4_w_0 = b.asm.Dm).apply(null, arguments)
          }
          , Po = b._emscripten_bind_btVector4_setValue_4 = function() {
            return (Po = b._emscripten_bind_btVector4_setValue_4 = b.asm.Em).apply(null, arguments)
          }
          , Qo = b._emscripten_bind_btVector4_length_0 = function() {
            return (Qo = b._emscripten_bind_btVector4_length_0 = b.asm.Fm).apply(null, arguments)
          }
          , Ro = b._emscripten_bind_btVector4_x_0 = function() {
            return (Ro = b._emscripten_bind_btVector4_x_0 = b.asm.Gm).apply(null, arguments)
          }
          , So = b._emscripten_bind_btVector4_y_0 = function() {
            return (So = b._emscripten_bind_btVector4_y_0 = b.asm.Hm).apply(null, arguments)
          }
          , To = b._emscripten_bind_btVector4_z_0 = function() {
            return (To = b._emscripten_bind_btVector4_z_0 = b.asm.Im).apply(null, arguments)
          }
          , Uo = b._emscripten_bind_btVector4_setX_1 = function() {
            return (Uo = b._emscripten_bind_btVector4_setX_1 = b.asm.Jm).apply(null, arguments)
          }
          , Vo = b._emscripten_bind_btVector4_setY_1 = function() {
            return (Vo = b._emscripten_bind_btVector4_setY_1 = b.asm.Km).apply(null, arguments)
          }
          , Wo = b._emscripten_bind_btVector4_setZ_1 = function() {
            return (Wo = b._emscripten_bind_btVector4_setZ_1 = b.asm.Lm).apply(null, arguments)
          }
          , Xo = b._emscripten_bind_btVector4_normalize_0 = function() {
            return (Xo = b._emscripten_bind_btVector4_normalize_0 = b.asm.Mm).apply(null, arguments)
          }
          , Yo = b._emscripten_bind_btVector4_rotate_2 = function() {
            return (Yo = b._emscripten_bind_btVector4_rotate_2 = b.asm.Nm).apply(null, arguments)
          }
          , Zo = b._emscripten_bind_btVector4_dot_1 = function() {
            return (Zo = b._emscripten_bind_btVector4_dot_1 = b.asm.Om).apply(null, arguments)
          }
          , $o = b._emscripten_bind_btVector4_op_mul_1 = function() {
            return ($o = b._emscripten_bind_btVector4_op_mul_1 = b.asm.Pm).apply(null, arguments)
          }
          , ap = b._emscripten_bind_btVector4_op_add_1 = function() {
            return (ap = b._emscripten_bind_btVector4_op_add_1 = b.asm.Qm).apply(null, arguments)
          }
          , bp = b._emscripten_bind_btVector4_op_sub_1 = function() {
            return (bp = b._emscripten_bind_btVector4_op_sub_1 = b.asm.Rm).apply(null, arguments)
          }
          , cp = b._emscripten_bind_btVector4___destroy___0 = function() {
            return (cp = b._emscripten_bind_btVector4___destroy___0 = b.asm.Sm).apply(null, arguments)
          }
          , dp = b._emscripten_bind_btDefaultCollisionConstructionInfo_btDefaultCollisionConstructionInfo_0 = function() {
            return (dp = b._emscripten_bind_btDefaultCollisionConstructionInfo_btDefaultCollisionConstructionInfo_0 = b.asm.Tm).apply(null, arguments)
          }
          , ep = b._emscripten_bind_btDefaultCollisionConstructionInfo___destroy___0 = function() {
            return (ep = b._emscripten_bind_btDefaultCollisionConstructionInfo___destroy___0 = b.asm.Um).apply(null, arguments)
          }
          , fp = b._emscripten_bind_Anchor_get_m_node_0 = function() {
            return (fp = b._emscripten_bind_Anchor_get_m_node_0 = b.asm.Vm).apply(null, arguments)
          }
          , gp = b._emscripten_bind_Anchor_set_m_node_1 = function() {
            return (gp = b._emscripten_bind_Anchor_set_m_node_1 = b.asm.Wm).apply(null, arguments)
          }
          , hp = b._emscripten_bind_Anchor_get_m_local_0 = function() {
            return (hp = b._emscripten_bind_Anchor_get_m_local_0 = b.asm.Xm).apply(null, arguments)
          }
          , ip = b._emscripten_bind_Anchor_set_m_local_1 = function() {
            return (ip = b._emscripten_bind_Anchor_set_m_local_1 = b.asm.Ym).apply(null, arguments)
          }
          , jp = b._emscripten_bind_Anchor_get_m_body_0 = function() {
            return (jp = b._emscripten_bind_Anchor_get_m_body_0 = b.asm.Zm).apply(null, arguments)
          }
          , kp = b._emscripten_bind_Anchor_set_m_body_1 = function() {
            return (kp = b._emscripten_bind_Anchor_set_m_body_1 = b.asm._m).apply(null, arguments)
          }
          , lp = b._emscripten_bind_Anchor_get_m_influence_0 = function() {
            return (lp = b._emscripten_bind_Anchor_get_m_influence_0 = b.asm.$m).apply(null, arguments)
          }
          , mp = b._emscripten_bind_Anchor_set_m_influence_1 = function() {
            return (mp = b._emscripten_bind_Anchor_set_m_influence_1 = b.asm.an).apply(null, arguments)
          }
          , np = b._emscripten_bind_Anchor_get_m_c0_0 = function() {
            return (np = b._emscripten_bind_Anchor_get_m_c0_0 = b.asm.bn).apply(null, arguments)
          }
          , op = b._emscripten_bind_Anchor_set_m_c0_1 = function() {
            return (op = b._emscripten_bind_Anchor_set_m_c0_1 = b.asm.cn).apply(null, arguments)
          }
          , pp = b._emscripten_bind_Anchor_get_m_c1_0 = function() {
            return (pp = b._emscripten_bind_Anchor_get_m_c1_0 = b.asm.dn).apply(null, arguments)
          }
          , qp = b._emscripten_bind_Anchor_set_m_c1_1 = function() {
            return (qp = b._emscripten_bind_Anchor_set_m_c1_1 = b.asm.en).apply(null, arguments)
          }
          , rp = b._emscripten_bind_Anchor_get_m_c2_0 = function() {
            return (rp = b._emscripten_bind_Anchor_get_m_c2_0 = b.asm.fn).apply(null, arguments)
          }
          , sp = b._emscripten_bind_Anchor_set_m_c2_1 = function() {
            return (sp = b._emscripten_bind_Anchor_set_m_c2_1 = b.asm.gn).apply(null, arguments)
          }
          , tp = b._emscripten_bind_Anchor___destroy___0 = function() {
            return (tp = b._emscripten_bind_Anchor___destroy___0 = b.asm.hn).apply(null, arguments)
          }
          , up = b._emscripten_bind_btVehicleRaycasterResult_get_m_hitPointInWorld_0 = function() {
            return (up = b._emscripten_bind_btVehicleRaycasterResult_get_m_hitPointInWorld_0 = b.asm.jn).apply(null, arguments)
          }
          , vp = b._emscripten_bind_btVehicleRaycasterResult_set_m_hitPointInWorld_1 = function() {
            return (vp = b._emscripten_bind_btVehicleRaycasterResult_set_m_hitPointInWorld_1 = b.asm.kn).apply(null, arguments)
          }
          , wp = b._emscripten_bind_btVehicleRaycasterResult_get_m_hitNormalInWorld_0 = function() {
            return (wp = b._emscripten_bind_btVehicleRaycasterResult_get_m_hitNormalInWorld_0 = b.asm.ln).apply(null, arguments)
          }
          , xp = b._emscripten_bind_btVehicleRaycasterResult_set_m_hitNormalInWorld_1 = function() {
            return (xp = b._emscripten_bind_btVehicleRaycasterResult_set_m_hitNormalInWorld_1 = b.asm.mn).apply(null, arguments)
          }
          , yp = b._emscripten_bind_btVehicleRaycasterResult_get_m_distFraction_0 = function() {
            return (yp = b._emscripten_bind_btVehicleRaycasterResult_get_m_distFraction_0 = b.asm.nn).apply(null, arguments)
          }
          , zp = b._emscripten_bind_btVehicleRaycasterResult_set_m_distFraction_1 = function() {
            return (zp = b._emscripten_bind_btVehicleRaycasterResult_set_m_distFraction_1 = b.asm.on).apply(null, arguments)
          }
          , Ap = b._emscripten_bind_btVehicleRaycasterResult___destroy___0 = function() {
            return (Ap = b._emscripten_bind_btVehicleRaycasterResult___destroy___0 = b.asm.pn).apply(null, arguments)
          }
          , Bp = b._emscripten_bind_btVector3Array_size_0 = function() {
            return (Bp = b._emscripten_bind_btVector3Array_size_0 = b.asm.qn).apply(null, arguments)
          }
          , Cp = b._emscripten_bind_btVector3Array_at_1 = function() {
            return (Cp = b._emscripten_bind_btVector3Array_at_1 = b.asm.rn).apply(null, arguments)
          }
          , Dp = b._emscripten_bind_btVector3Array___destroy___0 = function() {
            return (Dp = b._emscripten_bind_btVector3Array___destroy___0 = b.asm.sn).apply(null, arguments)
          }
          , Ep = b._emscripten_bind_btConstraintSolver___destroy___0 = function() {
            return (Ep = b._emscripten_bind_btConstraintSolver___destroy___0 = b.asm.tn).apply(null, arguments)
          }
          , Fp = b._emscripten_bind_btRaycastVehicle_btRaycastVehicle_3 = function() {
            return (Fp = b._emscripten_bind_btRaycastVehicle_btRaycastVehicle_3 = b.asm.un).apply(null, arguments)
          }
          , Gp = b._emscripten_bind_btRaycastVehicle_applyEngineForce_2 = function() {
            return (Gp = b._emscripten_bind_btRaycastVehicle_applyEngineForce_2 = b.asm.vn).apply(null, arguments)
          }
          , Hp = b._emscripten_bind_btRaycastVehicle_setSteeringValue_2 = function() {
            return (Hp = b._emscripten_bind_btRaycastVehicle_setSteeringValue_2 = b.asm.wn).apply(null, arguments)
          }
          , Ip = b._emscripten_bind_btRaycastVehicle_getWheelTransformWS_1 = function() {
            return (Ip = b._emscripten_bind_btRaycastVehicle_getWheelTransformWS_1 = b.asm.xn).apply(null, arguments)
          }
          , Jp = b._emscripten_bind_btRaycastVehicle_updateWheelTransform_2 = function() {
            return (Jp = b._emscripten_bind_btRaycastVehicle_updateWheelTransform_2 = b.asm.yn).apply(null, arguments)
          }
          , Kp = b._emscripten_bind_btRaycastVehicle_addWheel_7 = function() {
            return (Kp = b._emscripten_bind_btRaycastVehicle_addWheel_7 = b.asm.zn).apply(null, arguments)
          }
          , Lp = b._emscripten_bind_btRaycastVehicle_getNumWheels_0 = function() {
            return (Lp = b._emscripten_bind_btRaycastVehicle_getNumWheels_0 = b.asm.An).apply(null, arguments)
          }
          , Mp = b._emscripten_bind_btRaycastVehicle_getRigidBody_0 = function() {
            return (Mp = b._emscripten_bind_btRaycastVehicle_getRigidBody_0 = b.asm.Bn).apply(null, arguments)
          }
          , Np = b._emscripten_bind_btRaycastVehicle_getWheelInfo_1 = function() {
            return (Np = b._emscripten_bind_btRaycastVehicle_getWheelInfo_1 = b.asm.Cn).apply(null, arguments)
          }
          , Op = b._emscripten_bind_btRaycastVehicle_setBrake_2 = function() {
            return (Op = b._emscripten_bind_btRaycastVehicle_setBrake_2 = b.asm.Dn).apply(null, arguments)
          }
          , Pp = b._emscripten_bind_btRaycastVehicle_setCoordinateSystem_3 = function() {
            return (Pp = b._emscripten_bind_btRaycastVehicle_setCoordinateSystem_3 = b.asm.En).apply(null, arguments)
          }
          , Qp = b._emscripten_bind_btRaycastVehicle_getCurrentSpeedKmHour_0 = function() {
            return (Qp = b._emscripten_bind_btRaycastVehicle_getCurrentSpeedKmHour_0 = b.asm.Fn).apply(null, arguments)
          }
          , Rp = b._emscripten_bind_btRaycastVehicle_getChassisWorldTransform_0 = function() {
            return (Rp = b._emscripten_bind_btRaycastVehicle_getChassisWorldTransform_0 = b.asm.Gn).apply(null, arguments)
          }
          , Sp = b._emscripten_bind_btRaycastVehicle_rayCast_1 = function() {
            return (Sp = b._emscripten_bind_btRaycastVehicle_rayCast_1 = b.asm.Hn).apply(null, arguments)
          }
          , Tp = b._emscripten_bind_btRaycastVehicle_updateVehicle_1 = function() {
            return (Tp = b._emscripten_bind_btRaycastVehicle_updateVehicle_1 = b.asm.In).apply(null, arguments)
          }
          , Up = b._emscripten_bind_btRaycastVehicle_resetSuspension_0 = function() {
            return (Up = b._emscripten_bind_btRaycastVehicle_resetSuspension_0 = b.asm.Jn).apply(null, arguments)
          }
          , Vp = b._emscripten_bind_btRaycastVehicle_getSteeringValue_1 = function() {
            return (Vp = b._emscripten_bind_btRaycastVehicle_getSteeringValue_1 = b.asm.Kn).apply(null, arguments)
          }
          , Wp = b._emscripten_bind_btRaycastVehicle_updateWheelTransformsWS_1 = function() {
            return (Wp = b._emscripten_bind_btRaycastVehicle_updateWheelTransformsWS_1 = b.asm.Ln).apply(null, arguments)
          }
          , Xp = b._emscripten_bind_btRaycastVehicle_updateWheelTransformsWS_2 = function() {
            return (Xp = b._emscripten_bind_btRaycastVehicle_updateWheelTransformsWS_2 = b.asm.Mn).apply(null, arguments)
          }
          , Yp = b._emscripten_bind_btRaycastVehicle_setPitchControl_1 = function() {
            return (Yp = b._emscripten_bind_btRaycastVehicle_setPitchControl_1 = b.asm.Nn).apply(null, arguments)
          }
          , Zp = b._emscripten_bind_btRaycastVehicle_updateSuspension_1 = function() {
            return (Zp = b._emscripten_bind_btRaycastVehicle_updateSuspension_1 = b.asm.On).apply(null, arguments)
          }
          , $p = b._emscripten_bind_btRaycastVehicle_updateFriction_1 = function() {
            return ($p = b._emscripten_bind_btRaycastVehicle_updateFriction_1 = b.asm.Pn).apply(null, arguments)
          }
          , aq = b._emscripten_bind_btRaycastVehicle_getRightAxis_0 = function() {
            return (aq = b._emscripten_bind_btRaycastVehicle_getRightAxis_0 = b.asm.Qn).apply(null, arguments)
          }
          , bq = b._emscripten_bind_btRaycastVehicle_getUpAxis_0 = function() {
            return (bq = b._emscripten_bind_btRaycastVehicle_getUpAxis_0 = b.asm.Rn).apply(null, arguments)
          }
          , cq = b._emscripten_bind_btRaycastVehicle_getForwardAxis_0 = function() {
            return (cq = b._emscripten_bind_btRaycastVehicle_getForwardAxis_0 = b.asm.Sn).apply(null, arguments)
          }
          , dq = b._emscripten_bind_btRaycastVehicle_getForwardVector_0 = function() {
            return (dq = b._emscripten_bind_btRaycastVehicle_getForwardVector_0 = b.asm.Tn).apply(null, arguments)
          }
          , eq = b._emscripten_bind_btRaycastVehicle_getUserConstraintType_0 = function() {
            return (eq = b._emscripten_bind_btRaycastVehicle_getUserConstraintType_0 = b.asm.Un).apply(null, arguments)
          }
          , fq = b._emscripten_bind_btRaycastVehicle_setUserConstraintType_1 = function() {
            return (fq = b._emscripten_bind_btRaycastVehicle_setUserConstraintType_1 = b.asm.Vn).apply(null, arguments)
          }
          , gq = b._emscripten_bind_btRaycastVehicle_setUserConstraintId_1 = function() {
            return (gq = b._emscripten_bind_btRaycastVehicle_setUserConstraintId_1 = b.asm.Wn).apply(null, arguments)
          }
          , hq = b._emscripten_bind_btRaycastVehicle_getUserConstraintId_0 = function() {
            return (hq = b._emscripten_bind_btRaycastVehicle_getUserConstraintId_0 = b.asm.Xn).apply(null, arguments)
          }
          , iq = b._emscripten_bind_btRaycastVehicle_updateAction_2 = function() {
            return (iq = b._emscripten_bind_btRaycastVehicle_updateAction_2 = b.asm.Yn).apply(null, arguments)
          }
          , jq = b._emscripten_bind_btRaycastVehicle___destroy___0 = function() {
            return (jq = b._emscripten_bind_btRaycastVehicle___destroy___0 = b.asm.Zn).apply(null, arguments)
          }
          , kq = b._emscripten_bind_btCylinderShapeX_btCylinderShapeX_1 = function() {
            return (kq = b._emscripten_bind_btCylinderShapeX_btCylinderShapeX_1 = b.asm._n).apply(null, arguments)
          }
          , lq = b._emscripten_bind_btCylinderShapeX_setMargin_1 = function() {
            return (lq = b._emscripten_bind_btCylinderShapeX_setMargin_1 = b.asm.$n).apply(null, arguments)
          }
          , mq = b._emscripten_bind_btCylinderShapeX_getMargin_0 = function() {
            return (mq = b._emscripten_bind_btCylinderShapeX_getMargin_0 = b.asm.ao).apply(null, arguments)
          }
          , nq = b._emscripten_bind_btCylinderShapeX_setLocalScaling_1 = function() {
            return (nq = b._emscripten_bind_btCylinderShapeX_setLocalScaling_1 = b.asm.bo).apply(null, arguments)
          }
          , oq = b._emscripten_bind_btCylinderShapeX_getLocalScaling_0 = function() {
            return (oq = b._emscripten_bind_btCylinderShapeX_getLocalScaling_0 = b.asm.co).apply(null, arguments)
          }
          , pq = b._emscripten_bind_btCylinderShapeX_calculateLocalInertia_2 = function() {
            return (pq = b._emscripten_bind_btCylinderShapeX_calculateLocalInertia_2 = b.asm.eo).apply(null, arguments)
          }
          , qq = b._emscripten_bind_btCylinderShapeX___destroy___0 = function() {
            return (qq = b._emscripten_bind_btCylinderShapeX___destroy___0 = b.asm.fo).apply(null, arguments)
          }
          , rq = b._emscripten_bind_btCylinderShapeZ_btCylinderShapeZ_1 = function() {
            return (rq = b._emscripten_bind_btCylinderShapeZ_btCylinderShapeZ_1 = b.asm.go).apply(null, arguments)
          }
          , sq = b._emscripten_bind_btCylinderShapeZ_setMargin_1 = function() {
            return (sq = b._emscripten_bind_btCylinderShapeZ_setMargin_1 = b.asm.ho).apply(null, arguments)
          }
          , tq = b._emscripten_bind_btCylinderShapeZ_getMargin_0 = function() {
            return (tq = b._emscripten_bind_btCylinderShapeZ_getMargin_0 = b.asm.io).apply(null, arguments)
          }
          , uq = b._emscripten_bind_btCylinderShapeZ_setLocalScaling_1 = function() {
            return (uq = b._emscripten_bind_btCylinderShapeZ_setLocalScaling_1 = b.asm.jo).apply(null, arguments)
          }
          , vq = b._emscripten_bind_btCylinderShapeZ_getLocalScaling_0 = function() {
            return (vq = b._emscripten_bind_btCylinderShapeZ_getLocalScaling_0 = b.asm.ko).apply(null, arguments)
          }
          , wq = b._emscripten_bind_btCylinderShapeZ_calculateLocalInertia_2 = function() {
            return (wq = b._emscripten_bind_btCylinderShapeZ_calculateLocalInertia_2 = b.asm.lo).apply(null, arguments)
          }
          , xq = b._emscripten_bind_btCylinderShapeZ___destroy___0 = function() {
            return (xq = b._emscripten_bind_btCylinderShapeZ___destroy___0 = b.asm.mo).apply(null, arguments)
          }
          , yq = b._emscripten_bind_btConvexPolyhedron_get_m_vertices_0 = function() {
            return (yq = b._emscripten_bind_btConvexPolyhedron_get_m_vertices_0 = b.asm.no).apply(null, arguments)
          }
          , zq = b._emscripten_bind_btConvexPolyhedron_set_m_vertices_1 = function() {
            return (zq = b._emscripten_bind_btConvexPolyhedron_set_m_vertices_1 = b.asm.oo).apply(null, arguments)
          }
          , Aq = b._emscripten_bind_btConvexPolyhedron_get_m_faces_0 = function() {
            return (Aq = b._emscripten_bind_btConvexPolyhedron_get_m_faces_0 = b.asm.po).apply(null, arguments)
          }
          , Bq = b._emscripten_bind_btConvexPolyhedron_set_m_faces_1 = function() {
            return (Bq = b._emscripten_bind_btConvexPolyhedron_set_m_faces_1 = b.asm.qo).apply(null, arguments)
          }
          , Cq = b._emscripten_bind_btConvexPolyhedron___destroy___0 = function() {
            return (Cq = b._emscripten_bind_btConvexPolyhedron___destroy___0 = b.asm.ro).apply(null, arguments)
          }
          , Dq = b._emscripten_bind_btSequentialImpulseConstraintSolver_btSequentialImpulseConstraintSolver_0 = function() {
            return (Dq = b._emscripten_bind_btSequentialImpulseConstraintSolver_btSequentialImpulseConstraintSolver_0 = b.asm.so).apply(null, arguments)
          }
          , Eq = b._emscripten_bind_btSequentialImpulseConstraintSolver___destroy___0 = function() {
            return (Eq = b._emscripten_bind_btSequentialImpulseConstraintSolver___destroy___0 = b.asm.to).apply(null, arguments)
          }
          , Fq = b._emscripten_bind_tAnchorArray_size_0 = function() {
            return (Fq = b._emscripten_bind_tAnchorArray_size_0 = b.asm.uo).apply(null, arguments)
          }
          , Gq = b._emscripten_bind_tAnchorArray_at_1 = function() {
            return (Gq = b._emscripten_bind_tAnchorArray_at_1 = b.asm.vo).apply(null, arguments)
          }
          , Hq = b._emscripten_bind_tAnchorArray_clear_0 = function() {
            return (Hq = b._emscripten_bind_tAnchorArray_clear_0 = b.asm.wo).apply(null, arguments)
          }
          , Iq = b._emscripten_bind_tAnchorArray_push_back_1 = function() {
            return (Iq = b._emscripten_bind_tAnchorArray_push_back_1 = b.asm.xo).apply(null, arguments)
          }
          , Jq = b._emscripten_bind_tAnchorArray_pop_back_0 = function() {
            return (Jq = b._emscripten_bind_tAnchorArray_pop_back_0 = b.asm.yo).apply(null, arguments)
          }
          , Kq = b._emscripten_bind_tAnchorArray___destroy___0 = function() {
            return (Kq = b._emscripten_bind_tAnchorArray___destroy___0 = b.asm.zo).apply(null, arguments)
          }
          , Lq = b._emscripten_bind_RaycastInfo_get_m_contactNormalWS_0 = function() {
            return (Lq = b._emscripten_bind_RaycastInfo_get_m_contactNormalWS_0 = b.asm.Ao).apply(null, arguments)
          }
          , Mq = b._emscripten_bind_RaycastInfo_set_m_contactNormalWS_1 = function() {
            return (Mq = b._emscripten_bind_RaycastInfo_set_m_contactNormalWS_1 = b.asm.Bo).apply(null, arguments)
          }
          , Nq = b._emscripten_bind_RaycastInfo_get_m_contactPointWS_0 = function() {
            return (Nq = b._emscripten_bind_RaycastInfo_get_m_contactPointWS_0 = b.asm.Co).apply(null, arguments)
          }
          , Oq = b._emscripten_bind_RaycastInfo_set_m_contactPointWS_1 = function() {
            return (Oq = b._emscripten_bind_RaycastInfo_set_m_contactPointWS_1 = b.asm.Do).apply(null, arguments)
          }
          , Pq = b._emscripten_bind_RaycastInfo_get_m_suspensionLength_0 = function() {
            return (Pq = b._emscripten_bind_RaycastInfo_get_m_suspensionLength_0 = b.asm.Eo).apply(null, arguments)
          }
          , Qq = b._emscripten_bind_RaycastInfo_set_m_suspensionLength_1 = function() {
            return (Qq = b._emscripten_bind_RaycastInfo_set_m_suspensionLength_1 = b.asm.Fo).apply(null, arguments)
          }
          , Rq = b._emscripten_bind_RaycastInfo_get_m_hardPointWS_0 = function() {
            return (Rq = b._emscripten_bind_RaycastInfo_get_m_hardPointWS_0 = b.asm.Go).apply(null, arguments)
          }
          , Sq = b._emscripten_bind_RaycastInfo_set_m_hardPointWS_1 = function() {
            return (Sq = b._emscripten_bind_RaycastInfo_set_m_hardPointWS_1 = b.asm.Ho).apply(null, arguments)
          }
          , Tq = b._emscripten_bind_RaycastInfo_get_m_wheelDirectionWS_0 = function() {
            return (Tq = b._emscripten_bind_RaycastInfo_get_m_wheelDirectionWS_0 = b.asm.Io).apply(null, arguments)
          }
          , Uq = b._emscripten_bind_RaycastInfo_set_m_wheelDirectionWS_1 = function() {
            return (Uq = b._emscripten_bind_RaycastInfo_set_m_wheelDirectionWS_1 = b.asm.Jo).apply(null, arguments)
          }
          , Vq = b._emscripten_bind_RaycastInfo_get_m_wheelAxleWS_0 = function() {
            return (Vq = b._emscripten_bind_RaycastInfo_get_m_wheelAxleWS_0 = b.asm.Ko).apply(null, arguments)
          }
          , Wq = b._emscripten_bind_RaycastInfo_set_m_wheelAxleWS_1 = function() {
            return (Wq = b._emscripten_bind_RaycastInfo_set_m_wheelAxleWS_1 = b.asm.Lo).apply(null, arguments)
          }
          , Xq = b._emscripten_bind_RaycastInfo_get_m_isInContact_0 = function() {
            return (Xq = b._emscripten_bind_RaycastInfo_get_m_isInContact_0 = b.asm.Mo).apply(null, arguments)
          }
          , Yq = b._emscripten_bind_RaycastInfo_set_m_isInContact_1 = function() {
            return (Yq = b._emscripten_bind_RaycastInfo_set_m_isInContact_1 = b.asm.No).apply(null, arguments)
          }
          , Zq = b._emscripten_bind_RaycastInfo_get_m_groundObject_0 = function() {
            return (Zq = b._emscripten_bind_RaycastInfo_get_m_groundObject_0 = b.asm.Oo).apply(null, arguments)
          }
          , $q = b._emscripten_bind_RaycastInfo_set_m_groundObject_1 = function() {
            return ($q = b._emscripten_bind_RaycastInfo_set_m_groundObject_1 = b.asm.Po).apply(null, arguments)
          }
          , ar = b._emscripten_bind_RaycastInfo___destroy___0 = function() {
            return (ar = b._emscripten_bind_RaycastInfo___destroy___0 = b.asm.Qo).apply(null, arguments)
          }
          , br = b._emscripten_bind_btMultiSphereShape_btMultiSphereShape_3 = function() {
            return (br = b._emscripten_bind_btMultiSphereShape_btMultiSphereShape_3 = b.asm.Ro).apply(null, arguments)
          }
          , cr = b._emscripten_bind_btMultiSphereShape_setLocalScaling_1 = function() {
            return (cr = b._emscripten_bind_btMultiSphereShape_setLocalScaling_1 = b.asm.So).apply(null, arguments)
          }
          , dr = b._emscripten_bind_btMultiSphereShape_getLocalScaling_0 = function() {
            return (dr = b._emscripten_bind_btMultiSphereShape_getLocalScaling_0 = b.asm.To).apply(null, arguments)
          }
          , er = b._emscripten_bind_btMultiSphereShape_calculateLocalInertia_2 = function() {
            return (er = b._emscripten_bind_btMultiSphereShape_calculateLocalInertia_2 = b.asm.Uo).apply(null, arguments)
          }
          , fr = b._emscripten_bind_btMultiSphereShape___destroy___0 = function() {
            return (fr = b._emscripten_bind_btMultiSphereShape___destroy___0 = b.asm.Vo).apply(null, arguments)
          }
          , gr = b._emscripten_bind_btSoftBody_btSoftBody_4 = function() {
            return (gr = b._emscripten_bind_btSoftBody_btSoftBody_4 = b.asm.Wo).apply(null, arguments)
          }
          , hr = b._emscripten_bind_btSoftBody_checkLink_2 = function() {
            return (hr = b._emscripten_bind_btSoftBody_checkLink_2 = b.asm.Xo).apply(null, arguments)
          }
          , ir = b._emscripten_bind_btSoftBody_checkFace_3 = function() {
            return (ir = b._emscripten_bind_btSoftBody_checkFace_3 = b.asm.Yo).apply(null, arguments)
          }
          , jr = b._emscripten_bind_btSoftBody_appendMaterial_0 = function() {
            return (jr = b._emscripten_bind_btSoftBody_appendMaterial_0 = b.asm.Zo).apply(null, arguments)
          }
          , kr = b._emscripten_bind_btSoftBody_appendNode_2 = function() {
            return (kr = b._emscripten_bind_btSoftBody_appendNode_2 = b.asm._o).apply(null, arguments)
          }
          , lr = b._emscripten_bind_btSoftBody_appendLink_4 = function() {
            return (lr = b._emscripten_bind_btSoftBody_appendLink_4 = b.asm.$o).apply(null, arguments)
          }
          , mr = b._emscripten_bind_btSoftBody_appendFace_4 = function() {
            return (mr = b._emscripten_bind_btSoftBody_appendFace_4 = b.asm.ap).apply(null, arguments)
          }
          , nr = b._emscripten_bind_btSoftBody_appendTetra_5 = function() {
            return (nr = b._emscripten_bind_btSoftBody_appendTetra_5 = b.asm.bp).apply(null, arguments)
          }
          , or = b._emscripten_bind_btSoftBody_appendAnchor_4 = function() {
            return (or = b._emscripten_bind_btSoftBody_appendAnchor_4 = b.asm.cp).apply(null, arguments)
          }
          , pr = b._emscripten_bind_btSoftBody_addForce_1 = function() {
            return (pr = b._emscripten_bind_btSoftBody_addForce_1 = b.asm.dp).apply(null, arguments)
          }
          , qr = b._emscripten_bind_btSoftBody_addForce_2 = function() {
            return (qr = b._emscripten_bind_btSoftBody_addForce_2 = b.asm.ep).apply(null, arguments)
          }
          , rr = b._emscripten_bind_btSoftBody_addAeroForceToNode_2 = function() {
            return (rr = b._emscripten_bind_btSoftBody_addAeroForceToNode_2 = b.asm.fp).apply(null, arguments)
          }
          , sr = b._emscripten_bind_btSoftBody_getTotalMass_0 = function() {
            return (sr = b._emscripten_bind_btSoftBody_getTotalMass_0 = b.asm.gp).apply(null, arguments)
          }
          , tr = b._emscripten_bind_btSoftBody_setTotalMass_2 = function() {
            return (tr = b._emscripten_bind_btSoftBody_setTotalMass_2 = b.asm.hp).apply(null, arguments)
          }
          , ur = b._emscripten_bind_btSoftBody_setMass_2 = function() {
            return (ur = b._emscripten_bind_btSoftBody_setMass_2 = b.asm.ip).apply(null, arguments)
          }
          , vr = b._emscripten_bind_btSoftBody_transform_1 = function() {
            return (vr = b._emscripten_bind_btSoftBody_transform_1 = b.asm.jp).apply(null, arguments)
          }
          , wr = b._emscripten_bind_btSoftBody_translate_1 = function() {
            return (wr = b._emscripten_bind_btSoftBody_translate_1 = b.asm.kp).apply(null, arguments)
          }
          , xr = b._emscripten_bind_btSoftBody_rotate_1 = function() {
            return (xr = b._emscripten_bind_btSoftBody_rotate_1 = b.asm.lp).apply(null, arguments)
          }
          , yr = b._emscripten_bind_btSoftBody_scale_1 = function() {
            return (yr = b._emscripten_bind_btSoftBody_scale_1 = b.asm.mp).apply(null, arguments)
          }
          , zr = b._emscripten_bind_btSoftBody_generateClusters_1 = function() {
            return (zr = b._emscripten_bind_btSoftBody_generateClusters_1 = b.asm.np).apply(null, arguments)
          }
          , Ar = b._emscripten_bind_btSoftBody_generateClusters_2 = function() {
            return (Ar = b._emscripten_bind_btSoftBody_generateClusters_2 = b.asm.op).apply(null, arguments)
          }
          , Br = b._emscripten_bind_btSoftBody_generateBendingConstraints_2 = function() {
            return (Br = b._emscripten_bind_btSoftBody_generateBendingConstraints_2 = b.asm.pp).apply(null, arguments)
          }
          , Cr = b._emscripten_bind_btSoftBody_upcast_1 = function() {
            return (Cr = b._emscripten_bind_btSoftBody_upcast_1 = b.asm.qp).apply(null, arguments)
          }
          , Dr = b._emscripten_bind_btSoftBody_setAnisotropicFriction_2 = function() {
            return (Dr = b._emscripten_bind_btSoftBody_setAnisotropicFriction_2 = b.asm.rp).apply(null, arguments)
          }
          , Er = b._emscripten_bind_btSoftBody_getCollisionShape_0 = function() {
            return (Er = b._emscripten_bind_btSoftBody_getCollisionShape_0 = b.asm.sp).apply(null, arguments)
          }
          , Fr = b._emscripten_bind_btSoftBody_setContactProcessingThreshold_1 = function() {
            return (Fr = b._emscripten_bind_btSoftBody_setContactProcessingThreshold_1 = b.asm.tp).apply(null, arguments)
          }
          , Gr = b._emscripten_bind_btSoftBody_setActivationState_1 = function() {
            return (Gr = b._emscripten_bind_btSoftBody_setActivationState_1 = b.asm.up).apply(null, arguments)
          }
          , Hr = b._emscripten_bind_btSoftBody_forceActivationState_1 = function() {
            return (Hr = b._emscripten_bind_btSoftBody_forceActivationState_1 = b.asm.vp).apply(null, arguments)
          }
          , Ir = b._emscripten_bind_btSoftBody_activate_0 = function() {
            return (Ir = b._emscripten_bind_btSoftBody_activate_0 = b.asm.wp).apply(null, arguments)
          }
          , Jr = b._emscripten_bind_btSoftBody_activate_1 = function() {
            return (Jr = b._emscripten_bind_btSoftBody_activate_1 = b.asm.xp).apply(null, arguments)
          }
          , Kr = b._emscripten_bind_btSoftBody_isActive_0 = function() {
            return (Kr = b._emscripten_bind_btSoftBody_isActive_0 = b.asm.yp).apply(null, arguments)
          }
          , Lr = b._emscripten_bind_btSoftBody_isKinematicObject_0 = function() {
            return (Lr = b._emscripten_bind_btSoftBody_isKinematicObject_0 = b.asm.zp).apply(null, arguments)
          }
          , Mr = b._emscripten_bind_btSoftBody_isStaticObject_0 = function() {
            return (Mr = b._emscripten_bind_btSoftBody_isStaticObject_0 = b.asm.Ap).apply(null, arguments)
          }
          , Nr = b._emscripten_bind_btSoftBody_isStaticOrKinematicObject_0 = function() {
            return (Nr = b._emscripten_bind_btSoftBody_isStaticOrKinematicObject_0 = b.asm.Bp).apply(null, arguments)
          }
          , Or = b._emscripten_bind_btSoftBody_getRestitution_0 = function() {
            return (Or = b._emscripten_bind_btSoftBody_getRestitution_0 = b.asm.Cp).apply(null, arguments)
          }
          , Pr = b._emscripten_bind_btSoftBody_getFriction_0 = function() {
            return (Pr = b._emscripten_bind_btSoftBody_getFriction_0 = b.asm.Dp).apply(null, arguments)
          }
          , Qr = b._emscripten_bind_btSoftBody_getRollingFriction_0 = function() {
            return (Qr = b._emscripten_bind_btSoftBody_getRollingFriction_0 = b.asm.Ep).apply(null, arguments)
          }
          , Rr = b._emscripten_bind_btSoftBody_setRestitution_1 = function() {
            return (Rr = b._emscripten_bind_btSoftBody_setRestitution_1 = b.asm.Fp).apply(null, arguments)
          }
          , Sr = b._emscripten_bind_btSoftBody_setFriction_1 = function() {
            return (Sr = b._emscripten_bind_btSoftBody_setFriction_1 = b.asm.Gp).apply(null, arguments)
          }
          , Tr = b._emscripten_bind_btSoftBody_setRollingFriction_1 = function() {
            return (Tr = b._emscripten_bind_btSoftBody_setRollingFriction_1 = b.asm.Hp).apply(null, arguments)
          }
          , Ur = b._emscripten_bind_btSoftBody_getWorldTransform_0 = function() {
            return (Ur = b._emscripten_bind_btSoftBody_getWorldTransform_0 = b.asm.Ip).apply(null, arguments)
          }
          , Vr = b._emscripten_bind_btSoftBody_getCollisionFlags_0 = function() {
            return (Vr = b._emscripten_bind_btSoftBody_getCollisionFlags_0 = b.asm.Jp).apply(null, arguments)
          }
          , Wr = b._emscripten_bind_btSoftBody_setCollisionFlags_1 = function() {
            return (Wr = b._emscripten_bind_btSoftBody_setCollisionFlags_1 = b.asm.Kp).apply(null, arguments)
          }
          , Xr = b._emscripten_bind_btSoftBody_setWorldTransform_1 = function() {
            return (Xr = b._emscripten_bind_btSoftBody_setWorldTransform_1 = b.asm.Lp).apply(null, arguments)
          }
          , Yr = b._emscripten_bind_btSoftBody_setCollisionShape_1 = function() {
            return (Yr = b._emscripten_bind_btSoftBody_setCollisionShape_1 = b.asm.Mp).apply(null, arguments)
          }
          , Zr = b._emscripten_bind_btSoftBody_setCcdMotionThreshold_1 = function() {
            return (Zr = b._emscripten_bind_btSoftBody_setCcdMotionThreshold_1 = b.asm.Np).apply(null, arguments)
          }
          , $r = b._emscripten_bind_btSoftBody_setCcdSweptSphereRadius_1 = function() {
            return ($r = b._emscripten_bind_btSoftBody_setCcdSweptSphereRadius_1 = b.asm.Op).apply(null, arguments)
          }
          , as = b._emscripten_bind_btSoftBody_getUserIndex_0 = function() {
            return (as = b._emscripten_bind_btSoftBody_getUserIndex_0 = b.asm.Pp).apply(null, arguments)
          }
          , bs = b._emscripten_bind_btSoftBody_setUserIndex_1 = function() {
            return (bs = b._emscripten_bind_btSoftBody_setUserIndex_1 = b.asm.Qp).apply(null, arguments)
          }
          , cs = b._emscripten_bind_btSoftBody_getUserPointer_0 = function() {
            return (cs = b._emscripten_bind_btSoftBody_getUserPointer_0 = b.asm.Rp).apply(null, arguments)
          }
          , ds = b._emscripten_bind_btSoftBody_setUserPointer_1 = function() {
            return (ds = b._emscripten_bind_btSoftBody_setUserPointer_1 = b.asm.Sp).apply(null, arguments)
          }
          , es = b._emscripten_bind_btSoftBody_getBroadphaseHandle_0 = function() {
            return (es = b._emscripten_bind_btSoftBody_getBroadphaseHandle_0 = b.asm.Tp).apply(null, arguments)
          }
          , gs = b._emscripten_bind_btSoftBody_get_m_cfg_0 = function() {
            return (gs = b._emscripten_bind_btSoftBody_get_m_cfg_0 = b.asm.Up).apply(null, arguments)
          }
          , hs = b._emscripten_bind_btSoftBody_set_m_cfg_1 = function() {
            return (hs = b._emscripten_bind_btSoftBody_set_m_cfg_1 = b.asm.Vp).apply(null, arguments)
          }
          , is = b._emscripten_bind_btSoftBody_get_m_nodes_0 = function() {
            return (is = b._emscripten_bind_btSoftBody_get_m_nodes_0 = b.asm.Wp).apply(null, arguments)
          }
          , js = b._emscripten_bind_btSoftBody_set_m_nodes_1 = function() {
            return (js = b._emscripten_bind_btSoftBody_set_m_nodes_1 = b.asm.Xp).apply(null, arguments)
          }
          , ks = b._emscripten_bind_btSoftBody_get_m_materials_0 = function() {
            return (ks = b._emscripten_bind_btSoftBody_get_m_materials_0 = b.asm.Yp).apply(null, arguments)
          }
          , ls = b._emscripten_bind_btSoftBody_set_m_materials_1 = function() {
            return (ls = b._emscripten_bind_btSoftBody_set_m_materials_1 = b.asm.Zp).apply(null, arguments)
          }
          , ms = b._emscripten_bind_btSoftBody_get_m_anchors_0 = function() {
            return (ms = b._emscripten_bind_btSoftBody_get_m_anchors_0 = b.asm._p).apply(null, arguments)
          }
          , ns = b._emscripten_bind_btSoftBody_set_m_anchors_1 = function() {
            return (ns = b._emscripten_bind_btSoftBody_set_m_anchors_1 = b.asm.$p).apply(null, arguments)
          }
          , ps = b._emscripten_bind_btSoftBody___destroy___0 = function() {
            return (ps = b._emscripten_bind_btSoftBody___destroy___0 = b.asm.aq).apply(null, arguments)
          }
          , qs = b._emscripten_bind_btIntArray_size_0 = function() {
            return (qs = b._emscripten_bind_btIntArray_size_0 = b.asm.bq).apply(null, arguments)
          }
          , rs = b._emscripten_bind_btIntArray_at_1 = function() {
            return (rs = b._emscripten_bind_btIntArray_at_1 = b.asm.cq).apply(null, arguments)
          }
          , ss = b._emscripten_bind_btIntArray___destroy___0 = function() {
            return (ss = b._emscripten_bind_btIntArray___destroy___0 = b.asm.dq).apply(null, arguments)
          }
          , ts = b._emscripten_bind_Config_get_kVCF_0 = function() {
            return (ts = b._emscripten_bind_Config_get_kVCF_0 = b.asm.eq).apply(null, arguments)
          }
          , us = b._emscripten_bind_Config_set_kVCF_1 = function() {
            return (us = b._emscripten_bind_Config_set_kVCF_1 = b.asm.fq).apply(null, arguments)
          }
          , vs = b._emscripten_bind_Config_get_kDP_0 = function() {
            return (vs = b._emscripten_bind_Config_get_kDP_0 = b.asm.gq).apply(null, arguments)
          }
          , xs = b._emscripten_bind_Config_set_kDP_1 = function() {
            return (xs = b._emscripten_bind_Config_set_kDP_1 = b.asm.hq).apply(null, arguments)
          }
          , ys = b._emscripten_bind_Config_get_kDG_0 = function() {
            return (ys = b._emscripten_bind_Config_get_kDG_0 = b.asm.iq).apply(null, arguments)
          }
          , zs = b._emscripten_bind_Config_set_kDG_1 = function() {
            return (zs = b._emscripten_bind_Config_set_kDG_1 = b.asm.jq).apply(null, arguments)
          }
          , As = b._emscripten_bind_Config_get_kLF_0 = function() {
            return (As = b._emscripten_bind_Config_get_kLF_0 = b.asm.kq).apply(null, arguments)
          }
          , Bs = b._emscripten_bind_Config_set_kLF_1 = function() {
            return (Bs = b._emscripten_bind_Config_set_kLF_1 = b.asm.lq).apply(null, arguments)
          }
          , Cs = b._emscripten_bind_Config_get_kPR_0 = function() {
            return (Cs = b._emscripten_bind_Config_get_kPR_0 = b.asm.mq).apply(null, arguments)
          }
          , Ds = b._emscripten_bind_Config_set_kPR_1 = function() {
            return (Ds = b._emscripten_bind_Config_set_kPR_1 = b.asm.nq).apply(null, arguments)
          }
          , Es = b._emscripten_bind_Config_get_kVC_0 = function() {
            return (Es = b._emscripten_bind_Config_get_kVC_0 = b.asm.oq).apply(null, arguments)
          }
          , Fs = b._emscripten_bind_Config_set_kVC_1 = function() {
            return (Fs = b._emscripten_bind_Config_set_kVC_1 = b.asm.pq).apply(null, arguments)
          }
          , Gs = b._emscripten_bind_Config_get_kDF_0 = function() {
            return (Gs = b._emscripten_bind_Config_get_kDF_0 = b.asm.qq).apply(null, arguments)
          }
          , Hs = b._emscripten_bind_Config_set_kDF_1 = function() {
            return (Hs = b._emscripten_bind_Config_set_kDF_1 = b.asm.rq).apply(null, arguments)
          }
          , Is = b._emscripten_bind_Config_get_kMT_0 = function() {
            return (Is = b._emscripten_bind_Config_get_kMT_0 = b.asm.sq).apply(null, arguments)
          }
          , Js = b._emscripten_bind_Config_set_kMT_1 = function() {
            return (Js = b._emscripten_bind_Config_set_kMT_1 = b.asm.tq).apply(null, arguments)
          }
          , Ks = b._emscripten_bind_Config_get_kCHR_0 = function() {
            return (Ks = b._emscripten_bind_Config_get_kCHR_0 = b.asm.uq).apply(null, arguments)
          }
          , Ls = b._emscripten_bind_Config_set_kCHR_1 = function() {
            return (Ls = b._emscripten_bind_Config_set_kCHR_1 = b.asm.vq).apply(null, arguments)
          }
          , Ms = b._emscripten_bind_Config_get_kKHR_0 = function() {
            return (Ms = b._emscripten_bind_Config_get_kKHR_0 = b.asm.wq).apply(null, arguments)
          }
          , Ns = b._emscripten_bind_Config_set_kKHR_1 = function() {
            return (Ns = b._emscripten_bind_Config_set_kKHR_1 = b.asm.xq).apply(null, arguments)
          }
          , Os = b._emscripten_bind_Config_get_kSHR_0 = function() {
            return (Os = b._emscripten_bind_Config_get_kSHR_0 = b.asm.yq).apply(null, arguments)
          }
          , Ps = b._emscripten_bind_Config_set_kSHR_1 = function() {
            return (Ps = b._emscripten_bind_Config_set_kSHR_1 = b.asm.zq).apply(null, arguments)
          }
          , Qs = b._emscripten_bind_Config_get_kAHR_0 = function() {
            return (Qs = b._emscripten_bind_Config_get_kAHR_0 = b.asm.Aq).apply(null, arguments)
          }
          , Rs = b._emscripten_bind_Config_set_kAHR_1 = function() {
            return (Rs = b._emscripten_bind_Config_set_kAHR_1 = b.asm.Bq).apply(null, arguments)
          }
          , Ss = b._emscripten_bind_Config_get_kSRHR_CL_0 = function() {
            return (Ss = b._emscripten_bind_Config_get_kSRHR_CL_0 = b.asm.Cq).apply(null, arguments)
          }
          , Ts = b._emscripten_bind_Config_set_kSRHR_CL_1 = function() {
            return (Ts = b._emscripten_bind_Config_set_kSRHR_CL_1 = b.asm.Dq).apply(null, arguments)
          }
          , Us = b._emscripten_bind_Config_get_kSKHR_CL_0 = function() {
            return (Us = b._emscripten_bind_Config_get_kSKHR_CL_0 = b.asm.Eq).apply(null, arguments)
          }
          , Vs = b._emscripten_bind_Config_set_kSKHR_CL_1 = function() {
            return (Vs = b._emscripten_bind_Config_set_kSKHR_CL_1 = b.asm.Fq).apply(null, arguments)
          }
          , Ws = b._emscripten_bind_Config_get_kSSHR_CL_0 = function() {
            return (Ws = b._emscripten_bind_Config_get_kSSHR_CL_0 = b.asm.Gq).apply(null, arguments)
          }
          , Xs = b._emscripten_bind_Config_set_kSSHR_CL_1 = function() {
            return (Xs = b._emscripten_bind_Config_set_kSSHR_CL_1 = b.asm.Hq).apply(null, arguments)
          }
          , Ys = b._emscripten_bind_Config_get_kSR_SPLT_CL_0 = function() {
            return (Ys = b._emscripten_bind_Config_get_kSR_SPLT_CL_0 = b.asm.Iq).apply(null, arguments)
          }
          , Zs = b._emscripten_bind_Config_set_kSR_SPLT_CL_1 = function() {
            return (Zs = b._emscripten_bind_Config_set_kSR_SPLT_CL_1 = b.asm.Jq).apply(null, arguments)
          }
          , $s = b._emscripten_bind_Config_get_kSK_SPLT_CL_0 = function() {
            return ($s = b._emscripten_bind_Config_get_kSK_SPLT_CL_0 = b.asm.Kq).apply(null, arguments)
          }
          , at = b._emscripten_bind_Config_set_kSK_SPLT_CL_1 = function() {
            return (at = b._emscripten_bind_Config_set_kSK_SPLT_CL_1 = b.asm.Lq).apply(null, arguments)
          }
          , bt = b._emscripten_bind_Config_get_kSS_SPLT_CL_0 = function() {
            return (bt = b._emscripten_bind_Config_get_kSS_SPLT_CL_0 = b.asm.Mq).apply(null, arguments)
          }
          , ct = b._emscripten_bind_Config_set_kSS_SPLT_CL_1 = function() {
            return (ct = b._emscripten_bind_Config_set_kSS_SPLT_CL_1 = b.asm.Nq).apply(null, arguments)
          }
          , dt = b._emscripten_bind_Config_get_maxvolume_0 = function() {
            return (dt = b._emscripten_bind_Config_get_maxvolume_0 = b.asm.Oq).apply(null, arguments)
          }
          , et = b._emscripten_bind_Config_set_maxvolume_1 = function() {
            return (et = b._emscripten_bind_Config_set_maxvolume_1 = b.asm.Pq).apply(null, arguments)
          }
          , ft = b._emscripten_bind_Config_get_timescale_0 = function() {
            return (ft = b._emscripten_bind_Config_get_timescale_0 = b.asm.Qq).apply(null, arguments)
          }
          , gt = b._emscripten_bind_Config_set_timescale_1 = function() {
            return (gt = b._emscripten_bind_Config_set_timescale_1 = b.asm.Rq).apply(null, arguments)
          }
          , ht = b._emscripten_bind_Config_get_viterations_0 = function() {
            return (ht = b._emscripten_bind_Config_get_viterations_0 = b.asm.Sq).apply(null, arguments)
          }
          , it = b._emscripten_bind_Config_set_viterations_1 = function() {
            return (it = b._emscripten_bind_Config_set_viterations_1 = b.asm.Tq).apply(null, arguments)
          }
          , jt = b._emscripten_bind_Config_get_piterations_0 = function() {
            return (jt = b._emscripten_bind_Config_get_piterations_0 = b.asm.Uq).apply(null, arguments)
          }
          , kt = b._emscripten_bind_Config_set_piterations_1 = function() {
            return (kt = b._emscripten_bind_Config_set_piterations_1 = b.asm.Vq).apply(null, arguments)
          }
          , lt = b._emscripten_bind_Config_get_diterations_0 = function() {
            return (lt = b._emscripten_bind_Config_get_diterations_0 = b.asm.Wq).apply(null, arguments)
          }
          , mt = b._emscripten_bind_Config_set_diterations_1 = function() {
            return (mt = b._emscripten_bind_Config_set_diterations_1 = b.asm.Xq).apply(null, arguments)
          }
          , nt = b._emscripten_bind_Config_get_citerations_0 = function() {
            return (nt = b._emscripten_bind_Config_get_citerations_0 = b.asm.Yq).apply(null, arguments)
          }
          , ot = b._emscripten_bind_Config_set_citerations_1 = function() {
            return (ot = b._emscripten_bind_Config_set_citerations_1 = b.asm.Zq).apply(null, arguments)
          }
          , pt = b._emscripten_bind_Config_get_collisions_0 = function() {
            return (pt = b._emscripten_bind_Config_get_collisions_0 = b.asm._q).apply(null, arguments)
          }
          , qt = b._emscripten_bind_Config_set_collisions_1 = function() {
            return (qt = b._emscripten_bind_Config_set_collisions_1 = b.asm.$q).apply(null, arguments)
          }
          , rt = b._emscripten_bind_Config___destroy___0 = function() {
            return (rt = b._emscripten_bind_Config___destroy___0 = b.asm.ar).apply(null, arguments)
          }
          , st = b._emscripten_bind_Node_get_m_x_0 = function() {
            return (st = b._emscripten_bind_Node_get_m_x_0 = b.asm.br).apply(null, arguments)
          }
          , tt = b._emscripten_bind_Node_set_m_x_1 = function() {
            return (tt = b._emscripten_bind_Node_set_m_x_1 = b.asm.cr).apply(null, arguments)
          }
          , ut = b._emscripten_bind_Node_get_m_q_0 = function() {
            return (ut = b._emscripten_bind_Node_get_m_q_0 = b.asm.dr).apply(null, arguments)
          }
          , vt = b._emscripten_bind_Node_set_m_q_1 = function() {
            return (vt = b._emscripten_bind_Node_set_m_q_1 = b.asm.er).apply(null, arguments)
          }
          , wt = b._emscripten_bind_Node_get_m_v_0 = function() {
            return (wt = b._emscripten_bind_Node_get_m_v_0 = b.asm.fr).apply(null, arguments)
          }
          , xt = b._emscripten_bind_Node_set_m_v_1 = function() {
            return (xt = b._emscripten_bind_Node_set_m_v_1 = b.asm.gr).apply(null, arguments)
          }
          , yt = b._emscripten_bind_Node_get_m_f_0 = function() {
            return (yt = b._emscripten_bind_Node_get_m_f_0 = b.asm.hr).apply(null, arguments)
          }
          , zt = b._emscripten_bind_Node_set_m_f_1 = function() {
            return (zt = b._emscripten_bind_Node_set_m_f_1 = b.asm.ir).apply(null, arguments)
          }
          , At = b._emscripten_bind_Node_get_m_n_0 = function() {
            return (At = b._emscripten_bind_Node_get_m_n_0 = b.asm.jr).apply(null, arguments)
          }
          , Bt = b._emscripten_bind_Node_set_m_n_1 = function() {
            return (Bt = b._emscripten_bind_Node_set_m_n_1 = b.asm.kr).apply(null, arguments)
          }
          , Ct = b._emscripten_bind_Node_get_m_im_0 = function() {
            return (Ct = b._emscripten_bind_Node_get_m_im_0 = b.asm.lr).apply(null, arguments)
          }
          , Dt = b._emscripten_bind_Node_set_m_im_1 = function() {
            return (Dt = b._emscripten_bind_Node_set_m_im_1 = b.asm.mr).apply(null, arguments)
          }
          , Et = b._emscripten_bind_Node_get_m_area_0 = function() {
            return (Et = b._emscripten_bind_Node_get_m_area_0 = b.asm.nr).apply(null, arguments)
          }
          , Ft = b._emscripten_bind_Node_set_m_area_1 = function() {
            return (Ft = b._emscripten_bind_Node_set_m_area_1 = b.asm.or).apply(null, arguments)
          }
          , Gt = b._emscripten_bind_Node___destroy___0 = function() {
            return (Gt = b._emscripten_bind_Node___destroy___0 = b.asm.pr).apply(null, arguments)
          }
          , Ht = b._emscripten_bind_btGhostPairCallback_btGhostPairCallback_0 = function() {
            return (Ht = b._emscripten_bind_btGhostPairCallback_btGhostPairCallback_0 = b.asm.qr).apply(null, arguments)
          }
          , It = b._emscripten_bind_btGhostPairCallback___destroy___0 = function() {
            return (It = b._emscripten_bind_btGhostPairCallback___destroy___0 = b.asm.rr).apply(null, arguments)
          }
          , Jt = b._emscripten_bind_btOverlappingPairCallback___destroy___0 = function() {
            return (Jt = b._emscripten_bind_btOverlappingPairCallback___destroy___0 = b.asm.sr).apply(null, arguments)
          }
          , Kt = b._emscripten_bind_btKinematicCharacterController_btKinematicCharacterController_3 = function() {
            return (Kt = b._emscripten_bind_btKinematicCharacterController_btKinematicCharacterController_3 = b.asm.tr).apply(null, arguments)
          }
          , Lt = b._emscripten_bind_btKinematicCharacterController_btKinematicCharacterController_4 = function() {
            return (Lt = b._emscripten_bind_btKinematicCharacterController_btKinematicCharacterController_4 = b.asm.ur).apply(null, arguments)
          }
          , Mt = b._emscripten_bind_btKinematicCharacterController_setUpAxis_1 = function() {
            return (Mt = b._emscripten_bind_btKinematicCharacterController_setUpAxis_1 = b.asm.vr).apply(null, arguments)
          }
          , Nt = b._emscripten_bind_btKinematicCharacterController_setWalkDirection_1 = function() {
            return (Nt = b._emscripten_bind_btKinematicCharacterController_setWalkDirection_1 = b.asm.wr).apply(null, arguments)
          }
          , Ot = b._emscripten_bind_btKinematicCharacterController_setVelocityForTimeInterval_2 = function() {
            return (Ot = b._emscripten_bind_btKinematicCharacterController_setVelocityForTimeInterval_2 = b.asm.xr).apply(null, arguments)
          }
          , Pt = b._emscripten_bind_btKinematicCharacterController_warp_1 = function() {
            return (Pt = b._emscripten_bind_btKinematicCharacterController_warp_1 = b.asm.yr).apply(null, arguments)
          }
          , Qt = b._emscripten_bind_btKinematicCharacterController_preStep_1 = function() {
            return (Qt = b._emscripten_bind_btKinematicCharacterController_preStep_1 = b.asm.zr).apply(null, arguments)
          }
          , Rt = b._emscripten_bind_btKinematicCharacterController_playerStep_2 = function() {
            return (Rt = b._emscripten_bind_btKinematicCharacterController_playerStep_2 = b.asm.Ar).apply(null, arguments)
          }
          , St = b._emscripten_bind_btKinematicCharacterController_setFallSpeed_1 = function() {
            return (St = b._emscripten_bind_btKinematicCharacterController_setFallSpeed_1 = b.asm.Br).apply(null, arguments)
          }
          , Tt = b._emscripten_bind_btKinematicCharacterController_setJumpSpeed_1 = function() {
            return (Tt = b._emscripten_bind_btKinematicCharacterController_setJumpSpeed_1 = b.asm.Cr).apply(null, arguments)
          }
          , Ut = b._emscripten_bind_btKinematicCharacterController_setMaxJumpHeight_1 = function() {
            return (Ut = b._emscripten_bind_btKinematicCharacterController_setMaxJumpHeight_1 = b.asm.Dr).apply(null, arguments)
          }
          , Vt = b._emscripten_bind_btKinematicCharacterController_canJump_0 = function() {
            return (Vt = b._emscripten_bind_btKinematicCharacterController_canJump_0 = b.asm.Er).apply(null, arguments)
          }
          , Wt = b._emscripten_bind_btKinematicCharacterController_jump_0 = function() {
            return (Wt = b._emscripten_bind_btKinematicCharacterController_jump_0 = b.asm.Fr).apply(null, arguments)
          }
          , Xt = b._emscripten_bind_btKinematicCharacterController_setGravity_1 = function() {
            return (Xt = b._emscripten_bind_btKinematicCharacterController_setGravity_1 = b.asm.Gr).apply(null, arguments)
          }
          , Yt = b._emscripten_bind_btKinematicCharacterController_getGravity_0 = function() {
            return (Yt = b._emscripten_bind_btKinematicCharacterController_getGravity_0 = b.asm.Hr).apply(null, arguments)
          }
          , Zt = b._emscripten_bind_btKinematicCharacterController_setMaxSlope_1 = function() {
            return (Zt = b._emscripten_bind_btKinematicCharacterController_setMaxSlope_1 = b.asm.Ir).apply(null, arguments)
          }
          , $t = b._emscripten_bind_btKinematicCharacterController_getMaxSlope_0 = function() {
            return ($t = b._emscripten_bind_btKinematicCharacterController_getMaxSlope_0 = b.asm.Jr).apply(null, arguments)
          }
          , au = b._emscripten_bind_btKinematicCharacterController_getGhostObject_0 = function() {
            return (au = b._emscripten_bind_btKinematicCharacterController_getGhostObject_0 = b.asm.Kr).apply(null, arguments)
          }
          , bu = b._emscripten_bind_btKinematicCharacterController_setUseGhostSweepTest_1 = function() {
            return (bu = b._emscripten_bind_btKinematicCharacterController_setUseGhostSweepTest_1 = b.asm.Lr).apply(null, arguments)
          }
          , cu = b._emscripten_bind_btKinematicCharacterController_onGround_0 = function() {
            return (cu = b._emscripten_bind_btKinematicCharacterController_onGround_0 = b.asm.Mr).apply(null, arguments)
          }
          , du = b._emscripten_bind_btKinematicCharacterController_setUpInterpolate_1 = function() {
            return (du = b._emscripten_bind_btKinematicCharacterController_setUpInterpolate_1 = b.asm.Nr).apply(null, arguments)
          }
          , eu = b._emscripten_bind_btKinematicCharacterController_updateAction_2 = function() {
            return (eu = b._emscripten_bind_btKinematicCharacterController_updateAction_2 = b.asm.Or).apply(null, arguments)
          }
          , fu = b._emscripten_bind_btKinematicCharacterController___destroy___0 = function() {
            return (fu = b._emscripten_bind_btKinematicCharacterController___destroy___0 = b.asm.Pr).apply(null, arguments)
          }
          , gu = b._emscripten_bind_btSoftBodyArray_size_0 = function() {
            return (gu = b._emscripten_bind_btSoftBodyArray_size_0 = b.asm.Qr).apply(null, arguments)
          }
          , hu = b._emscripten_bind_btSoftBodyArray_at_1 = function() {
            return (hu = b._emscripten_bind_btSoftBodyArray_at_1 = b.asm.Rr).apply(null, arguments)
          }
          , iu = b._emscripten_bind_btSoftBodyArray___destroy___0 = function() {
            return (iu = b._emscripten_bind_btSoftBodyArray___destroy___0 = b.asm.Sr).apply(null, arguments)
          }
          , ju = b._emscripten_bind_btFaceArray_size_0 = function() {
            return (ju = b._emscripten_bind_btFaceArray_size_0 = b.asm.Tr).apply(null, arguments)
          }
          , ku = b._emscripten_bind_btFaceArray_at_1 = function() {
            return (ku = b._emscripten_bind_btFaceArray_at_1 = b.asm.Ur).apply(null, arguments)
          }
          , lu = b._emscripten_bind_btFaceArray___destroy___0 = function() {
            return (lu = b._emscripten_bind_btFaceArray___destroy___0 = b.asm.Vr).apply(null, arguments)
          }
          , mu = b._emscripten_bind_btStaticPlaneShape_btStaticPlaneShape_2 = function() {
            return (mu = b._emscripten_bind_btStaticPlaneShape_btStaticPlaneShape_2 = b.asm.Wr).apply(null, arguments)
          }
          , nu = b._emscripten_bind_btStaticPlaneShape_setLocalScaling_1 = function() {
            return (nu = b._emscripten_bind_btStaticPlaneShape_setLocalScaling_1 = b.asm.Xr).apply(null, arguments)
          }
          , ou = b._emscripten_bind_btStaticPlaneShape_getLocalScaling_0 = function() {
            return (ou = b._emscripten_bind_btStaticPlaneShape_getLocalScaling_0 = b.asm.Yr).apply(null, arguments)
          }
          , pu = b._emscripten_bind_btStaticPlaneShape_calculateLocalInertia_2 = function() {
            return (pu = b._emscripten_bind_btStaticPlaneShape_calculateLocalInertia_2 = b.asm.Zr).apply(null, arguments)
          }
          , qu = b._emscripten_bind_btStaticPlaneShape___destroy___0 = function() {
            return (qu = b._emscripten_bind_btStaticPlaneShape___destroy___0 = b.asm._r).apply(null, arguments)
          }
          , ru = b._emscripten_bind_btOverlappingPairCache_setInternalGhostPairCallback_1 = function() {
            return (ru = b._emscripten_bind_btOverlappingPairCache_setInternalGhostPairCallback_1 = b.asm.$r).apply(null, arguments)
          }
          , su = b._emscripten_bind_btOverlappingPairCache_getNumOverlappingPairs_0 = function() {
            return (su = b._emscripten_bind_btOverlappingPairCache_getNumOverlappingPairs_0 = b.asm.as).apply(null, arguments)
          }
          , tu = b._emscripten_bind_btOverlappingPairCache___destroy___0 = function() {
            return (tu = b._emscripten_bind_btOverlappingPairCache___destroy___0 = b.asm.bs).apply(null, arguments)
          }
          , uu = b._emscripten_bind_btIndexedMesh_get_m_numTriangles_0 = function() {
            return (uu = b._emscripten_bind_btIndexedMesh_get_m_numTriangles_0 = b.asm.cs).apply(null, arguments)
          }
          , vu = b._emscripten_bind_btIndexedMesh_set_m_numTriangles_1 = function() {
            return (vu = b._emscripten_bind_btIndexedMesh_set_m_numTriangles_1 = b.asm.ds).apply(null, arguments)
          }
          , wu = b._emscripten_bind_btIndexedMesh___destroy___0 = function() {
            return (wu = b._emscripten_bind_btIndexedMesh___destroy___0 = b.asm.es).apply(null, arguments)
          }
          , xu = b._emscripten_bind_btSoftRigidDynamicsWorld_btSoftRigidDynamicsWorld_5 = function() {
            return (xu = b._emscripten_bind_btSoftRigidDynamicsWorld_btSoftRigidDynamicsWorld_5 = b.asm.fs).apply(null, arguments)
          }
          , yu = b._emscripten_bind_btSoftRigidDynamicsWorld_addSoftBody_3 = function() {
            return (yu = b._emscripten_bind_btSoftRigidDynamicsWorld_addSoftBody_3 = b.asm.gs).apply(null, arguments)
          }
          , zu = b._emscripten_bind_btSoftRigidDynamicsWorld_removeSoftBody_1 = function() {
            return (zu = b._emscripten_bind_btSoftRigidDynamicsWorld_removeSoftBody_1 = b.asm.hs).apply(null, arguments)
          }
          , Au = b._emscripten_bind_btSoftRigidDynamicsWorld_removeCollisionObject_1 = function() {
            return (Au = b._emscripten_bind_btSoftRigidDynamicsWorld_removeCollisionObject_1 = b.asm.is).apply(null, arguments)
          }
          , Bu = b._emscripten_bind_btSoftRigidDynamicsWorld_getWorldInfo_0 = function() {
            return (Bu = b._emscripten_bind_btSoftRigidDynamicsWorld_getWorldInfo_0 = b.asm.js).apply(null, arguments)
          }
          , Cu = b._emscripten_bind_btSoftRigidDynamicsWorld_getSoftBodyArray_0 = function() {
            return (Cu = b._emscripten_bind_btSoftRigidDynamicsWorld_getSoftBodyArray_0 = b.asm.ks).apply(null, arguments)
          }
          , Du = b._emscripten_bind_btSoftRigidDynamicsWorld_getDispatcher_0 = function() {
            return (Du = b._emscripten_bind_btSoftRigidDynamicsWorld_getDispatcher_0 = b.asm.ls).apply(null, arguments)
          }
          , Eu = b._emscripten_bind_btSoftRigidDynamicsWorld_rayTest_3 = function() {
            return (Eu = b._emscripten_bind_btSoftRigidDynamicsWorld_rayTest_3 = b.asm.ms).apply(null, arguments)
          }
          , Fu = b._emscripten_bind_btSoftRigidDynamicsWorld_getPairCache_0 = function() {
            return (Fu = b._emscripten_bind_btSoftRigidDynamicsWorld_getPairCache_0 = b.asm.ns).apply(null, arguments)
          }
          , Gu = b._emscripten_bind_btSoftRigidDynamicsWorld_getDispatchInfo_0 = function() {
            return (Gu = b._emscripten_bind_btSoftRigidDynamicsWorld_getDispatchInfo_0 = b.asm.os).apply(null, arguments)
          }
          , Hu = b._emscripten_bind_btSoftRigidDynamicsWorld_addCollisionObject_1 = function() {
            return (Hu = b._emscripten_bind_btSoftRigidDynamicsWorld_addCollisionObject_1 = b.asm.ps).apply(null, arguments)
          }
          , Iu = b._emscripten_bind_btSoftRigidDynamicsWorld_addCollisionObject_2 = function() {
            return (Iu = b._emscripten_bind_btSoftRigidDynamicsWorld_addCollisionObject_2 = b.asm.qs).apply(null, arguments)
          }
          , Ju = b._emscripten_bind_btSoftRigidDynamicsWorld_addCollisionObject_3 = function() {
            return (Ju = b._emscripten_bind_btSoftRigidDynamicsWorld_addCollisionObject_3 = b.asm.rs).apply(null, arguments)
          }
          , Ku = b._emscripten_bind_btSoftRigidDynamicsWorld_getBroadphase_0 = function() {
            return (Ku = b._emscripten_bind_btSoftRigidDynamicsWorld_getBroadphase_0 = b.asm.ss).apply(null, arguments)
          }
          , Lu = b._emscripten_bind_btSoftRigidDynamicsWorld_convexSweepTest_5 = function() {
            return (Lu = b._emscripten_bind_btSoftRigidDynamicsWorld_convexSweepTest_5 = b.asm.ts).apply(null, arguments)
          }
          , Mu = b._emscripten_bind_btSoftRigidDynamicsWorld_contactPairTest_3 = function() {
            return (Mu = b._emscripten_bind_btSoftRigidDynamicsWorld_contactPairTest_3 = b.asm.us).apply(null, arguments)
          }
          , Nu = b._emscripten_bind_btSoftRigidDynamicsWorld_contactTest_2 = function() {
            return (Nu = b._emscripten_bind_btSoftRigidDynamicsWorld_contactTest_2 = b.asm.vs).apply(null, arguments)
          }
          , Ou = b._emscripten_bind_btSoftRigidDynamicsWorld_updateSingleAabb_1 = function() {
            return (Ou = b._emscripten_bind_btSoftRigidDynamicsWorld_updateSingleAabb_1 = b.asm.ws).apply(null, arguments)
          }
          , Pu = b._emscripten_bind_btSoftRigidDynamicsWorld_setDebugDrawer_1 = function() {
            return (Pu = b._emscripten_bind_btSoftRigidDynamicsWorld_setDebugDrawer_1 = b.asm.xs).apply(null, arguments)
          }
          , Qu = b._emscripten_bind_btSoftRigidDynamicsWorld_getDebugDrawer_0 = function() {
            return (Qu = b._emscripten_bind_btSoftRigidDynamicsWorld_getDebugDrawer_0 = b.asm.ys).apply(null, arguments)
          }
          , Ru = b._emscripten_bind_btSoftRigidDynamicsWorld_debugDrawWorld_0 = function() {
            return (Ru = b._emscripten_bind_btSoftRigidDynamicsWorld_debugDrawWorld_0 = b.asm.zs).apply(null, arguments)
          }
          , Su = b._emscripten_bind_btSoftRigidDynamicsWorld_debugDrawObject_3 = function() {
            return (Su = b._emscripten_bind_btSoftRigidDynamicsWorld_debugDrawObject_3 = b.asm.As).apply(null, arguments)
          }
          , Tu = b._emscripten_bind_btSoftRigidDynamicsWorld_setGravity_1 = function() {
            return (Tu = b._emscripten_bind_btSoftRigidDynamicsWorld_setGravity_1 = b.asm.Bs).apply(null, arguments)
          }
          , Uu = b._emscripten_bind_btSoftRigidDynamicsWorld_getGravity_0 = function() {
            return (Uu = b._emscripten_bind_btSoftRigidDynamicsWorld_getGravity_0 = b.asm.Cs).apply(null, arguments)
          }
          , Vu = b._emscripten_bind_btSoftRigidDynamicsWorld_addRigidBody_1 = function() {
            return (Vu = b._emscripten_bind_btSoftRigidDynamicsWorld_addRigidBody_1 = b.asm.Ds).apply(null, arguments)
          }
          , Wu = b._emscripten_bind_btSoftRigidDynamicsWorld_addRigidBody_3 = function() {
            return (Wu = b._emscripten_bind_btSoftRigidDynamicsWorld_addRigidBody_3 = b.asm.Es).apply(null, arguments)
          }
          , Xu = b._emscripten_bind_btSoftRigidDynamicsWorld_removeRigidBody_1 = function() {
            return (Xu = b._emscripten_bind_btSoftRigidDynamicsWorld_removeRigidBody_1 = b.asm.Fs).apply(null, arguments)
          }
          , Yu = b._emscripten_bind_btSoftRigidDynamicsWorld_addConstraint_1 = function() {
            return (Yu = b._emscripten_bind_btSoftRigidDynamicsWorld_addConstraint_1 = b.asm.Gs).apply(null, arguments)
          }
          , Zu = b._emscripten_bind_btSoftRigidDynamicsWorld_addConstraint_2 = function() {
            return (Zu = b._emscripten_bind_btSoftRigidDynamicsWorld_addConstraint_2 = b.asm.Hs).apply(null, arguments)
          }
          , $u = b._emscripten_bind_btSoftRigidDynamicsWorld_removeConstraint_1 = function() {
            return ($u = b._emscripten_bind_btSoftRigidDynamicsWorld_removeConstraint_1 = b.asm.Is).apply(null, arguments)
          }
          , av = b._emscripten_bind_btSoftRigidDynamicsWorld_stepSimulation_1 = function() {
            return (av = b._emscripten_bind_btSoftRigidDynamicsWorld_stepSimulation_1 = b.asm.Js).apply(null, arguments)
          }
          , bv = b._emscripten_bind_btSoftRigidDynamicsWorld_stepSimulation_2 = function() {
            return (bv = b._emscripten_bind_btSoftRigidDynamicsWorld_stepSimulation_2 = b.asm.Ks).apply(null, arguments)
          }
          , cv = b._emscripten_bind_btSoftRigidDynamicsWorld_stepSimulation_3 = function() {
            return (cv = b._emscripten_bind_btSoftRigidDynamicsWorld_stepSimulation_3 = b.asm.Ls).apply(null, arguments)
          }
          , dv = b._emscripten_bind_btSoftRigidDynamicsWorld_setContactAddedCallback_1 = function() {
            return (dv = b._emscripten_bind_btSoftRigidDynamicsWorld_setContactAddedCallback_1 = b.asm.Ms).apply(null, arguments)
          }
          , ev = b._emscripten_bind_btSoftRigidDynamicsWorld_setContactProcessedCallback_1 = function() {
            return (ev = b._emscripten_bind_btSoftRigidDynamicsWorld_setContactProcessedCallback_1 = b.asm.Ns).apply(null, arguments)
          }
          , fv = b._emscripten_bind_btSoftRigidDynamicsWorld_setContactDestroyedCallback_1 = function() {
            return (fv = b._emscripten_bind_btSoftRigidDynamicsWorld_setContactDestroyedCallback_1 = b.asm.Os).apply(null, arguments)
          }
          , gv = b._emscripten_bind_btSoftRigidDynamicsWorld_addAction_1 = function() {
            return (gv = b._emscripten_bind_btSoftRigidDynamicsWorld_addAction_1 = b.asm.Ps).apply(null, arguments)
          }
          , hv = b._emscripten_bind_btSoftRigidDynamicsWorld_removeAction_1 = function() {
            return (hv = b._emscripten_bind_btSoftRigidDynamicsWorld_removeAction_1 = b.asm.Qs).apply(null, arguments)
          }
          , iv = b._emscripten_bind_btSoftRigidDynamicsWorld_getSolverInfo_0 = function() {
            return (iv = b._emscripten_bind_btSoftRigidDynamicsWorld_getSolverInfo_0 = b.asm.Rs).apply(null, arguments)
          }
          , jv = b._emscripten_bind_btSoftRigidDynamicsWorld_setInternalTickCallback_1 = function() {
            return (jv = b._emscripten_bind_btSoftRigidDynamicsWorld_setInternalTickCallback_1 = b.asm.Ss).apply(null, arguments)
          }
          , kv = b._emscripten_bind_btSoftRigidDynamicsWorld_setInternalTickCallback_2 = function() {
            return (kv = b._emscripten_bind_btSoftRigidDynamicsWorld_setInternalTickCallback_2 = b.asm.Ts).apply(null, arguments)
          }
          , lv = b._emscripten_bind_btSoftRigidDynamicsWorld_setInternalTickCallback_3 = function() {
            return (lv = b._emscripten_bind_btSoftRigidDynamicsWorld_setInternalTickCallback_3 = b.asm.Us).apply(null, arguments)
          }
          , mv = b._emscripten_bind_btSoftRigidDynamicsWorld___destroy___0 = function() {
            return (mv = b._emscripten_bind_btSoftRigidDynamicsWorld___destroy___0 = b.asm.Vs).apply(null, arguments)
          }
          , nv = b._emscripten_bind_btFixedConstraint_btFixedConstraint_4 = function() {
            return (nv = b._emscripten_bind_btFixedConstraint_btFixedConstraint_4 = b.asm.Ws).apply(null, arguments)
          }
          , ov = b._emscripten_bind_btFixedConstraint_enableFeedback_1 = function() {
            return (ov = b._emscripten_bind_btFixedConstraint_enableFeedback_1 = b.asm.Xs).apply(null, arguments)
          }
          , pv = b._emscripten_bind_btFixedConstraint_getBreakingImpulseThreshold_0 = function() {
            return (pv = b._emscripten_bind_btFixedConstraint_getBreakingImpulseThreshold_0 = b.asm.Ys).apply(null, arguments)
          }
          , qv = b._emscripten_bind_btFixedConstraint_setBreakingImpulseThreshold_1 = function() {
            return (qv = b._emscripten_bind_btFixedConstraint_setBreakingImpulseThreshold_1 = b.asm.Zs).apply(null, arguments)
          }
          , rv = b._emscripten_bind_btFixedConstraint_getParam_2 = function() {
            return (rv = b._emscripten_bind_btFixedConstraint_getParam_2 = b.asm._s).apply(null, arguments)
          }
          , sv = b._emscripten_bind_btFixedConstraint_setParam_3 = function() {
            return (sv = b._emscripten_bind_btFixedConstraint_setParam_3 = b.asm.$s).apply(null, arguments)
          }
          , tv = b._emscripten_bind_btFixedConstraint___destroy___0 = function() {
            return (tv = b._emscripten_bind_btFixedConstraint___destroy___0 = b.asm.at).apply(null, arguments)
          }
          , uv = b._emscripten_bind_btTransform_btTransform_0 = function() {
            return (uv = b._emscripten_bind_btTransform_btTransform_0 = b.asm.bt).apply(null, arguments)
          }
          , vv = b._emscripten_bind_btTransform_btTransform_2 = function() {
            return (vv = b._emscripten_bind_btTransform_btTransform_2 = b.asm.ct).apply(null, arguments)
          }
          , wv = b._emscripten_bind_btTransform_setIdentity_0 = function() {
            return (wv = b._emscripten_bind_btTransform_setIdentity_0 = b.asm.dt).apply(null, arguments)
          }
          , xv = b._emscripten_bind_btTransform_setOrigin_1 = function() {
            return (xv = b._emscripten_bind_btTransform_setOrigin_1 = b.asm.et).apply(null, arguments)
          }
          , yv = b._emscripten_bind_btTransform_setRotation_1 = function() {
            return (yv = b._emscripten_bind_btTransform_setRotation_1 = b.asm.ft).apply(null, arguments)
          }
          , zv = b._emscripten_bind_btTransform_getOrigin_0 = function() {
            return (zv = b._emscripten_bind_btTransform_getOrigin_0 = b.asm.gt).apply(null, arguments)
          }
          , Av = b._emscripten_bind_btTransform_getRotation_0 = function() {
            return (Av = b._emscripten_bind_btTransform_getRotation_0 = b.asm.ht).apply(null, arguments)
          }
          , Bv = b._emscripten_bind_btTransform_getBasis_0 = function() {
            return (Bv = b._emscripten_bind_btTransform_getBasis_0 = b.asm.it).apply(null, arguments)
          }
          , Cv = b._emscripten_bind_btTransform_setFromOpenGLMatrix_1 = function() {
            return (Cv = b._emscripten_bind_btTransform_setFromOpenGLMatrix_1 = b.asm.jt).apply(null, arguments)
          }
          , Dv = b._emscripten_bind_btTransform_inverse_0 = function() {
            return (Dv = b._emscripten_bind_btTransform_inverse_0 = b.asm.kt).apply(null, arguments)
          }
          , Ev = b._emscripten_bind_btTransform_op_mul_1 = function() {
            return (Ev = b._emscripten_bind_btTransform_op_mul_1 = b.asm.lt).apply(null, arguments)
          }
          , Fv = b._emscripten_bind_btTransform___destroy___0 = function() {
            return (Fv = b._emscripten_bind_btTransform___destroy___0 = b.asm.mt).apply(null, arguments)
          }
          , Gv = b._emscripten_bind_ClosestRayResultCallback_ClosestRayResultCallback_2 = function() {
            return (Gv = b._emscripten_bind_ClosestRayResultCallback_ClosestRayResultCallback_2 = b.asm.nt).apply(null, arguments)
          }
          , Hv = b._emscripten_bind_ClosestRayResultCallback_hasHit_0 = function() {
            return (Hv = b._emscripten_bind_ClosestRayResultCallback_hasHit_0 = b.asm.ot).apply(null, arguments)
          }
          , Iv = b._emscripten_bind_ClosestRayResultCallback_get_m_rayFromWorld_0 = function() {
            return (Iv = b._emscripten_bind_ClosestRayResultCallback_get_m_rayFromWorld_0 = b.asm.pt).apply(null, arguments)
          }
          , Jv = b._emscripten_bind_ClosestRayResultCallback_set_m_rayFromWorld_1 = function() {
            return (Jv = b._emscripten_bind_ClosestRayResultCallback_set_m_rayFromWorld_1 = b.asm.qt).apply(null, arguments)
          }
          , Kv = b._emscripten_bind_ClosestRayResultCallback_get_m_rayToWorld_0 = function() {
            return (Kv = b._emscripten_bind_ClosestRayResultCallback_get_m_rayToWorld_0 = b.asm.rt).apply(null, arguments)
          }
          , Lv = b._emscripten_bind_ClosestRayResultCallback_set_m_rayToWorld_1 = function() {
            return (Lv = b._emscripten_bind_ClosestRayResultCallback_set_m_rayToWorld_1 = b.asm.st).apply(null, arguments)
          }
          , Mv = b._emscripten_bind_ClosestRayResultCallback_get_m_hitNormalWorld_0 = function() {
            return (Mv = b._emscripten_bind_ClosestRayResultCallback_get_m_hitNormalWorld_0 = b.asm.tt).apply(null, arguments)
          }
          , Nv = b._emscripten_bind_ClosestRayResultCallback_set_m_hitNormalWorld_1 = function() {
            return (Nv = b._emscripten_bind_ClosestRayResultCallback_set_m_hitNormalWorld_1 = b.asm.ut).apply(null, arguments)
          }
          , Ov = b._emscripten_bind_ClosestRayResultCallback_get_m_hitPointWorld_0 = function() {
            return (Ov = b._emscripten_bind_ClosestRayResultCallback_get_m_hitPointWorld_0 = b.asm.vt).apply(null, arguments)
          }
          , Pv = b._emscripten_bind_ClosestRayResultCallback_set_m_hitPointWorld_1 = function() {
            return (Pv = b._emscripten_bind_ClosestRayResultCallback_set_m_hitPointWorld_1 = b.asm.wt).apply(null, arguments)
          }
          , Qv = b._emscripten_bind_ClosestRayResultCallback_get_m_collisionFilterGroup_0 = function() {
            return (Qv = b._emscripten_bind_ClosestRayResultCallback_get_m_collisionFilterGroup_0 = b.asm.xt).apply(null, arguments)
          }
          , Rv = b._emscripten_bind_ClosestRayResultCallback_set_m_collisionFilterGroup_1 = function() {
            return (Rv = b._emscripten_bind_ClosestRayResultCallback_set_m_collisionFilterGroup_1 = b.asm.yt).apply(null, arguments)
          }
          , Sv = b._emscripten_bind_ClosestRayResultCallback_get_m_collisionFilterMask_0 = function() {
            return (Sv = b._emscripten_bind_ClosestRayResultCallback_get_m_collisionFilterMask_0 = b.asm.zt).apply(null, arguments)
          }
          , Tv = b._emscripten_bind_ClosestRayResultCallback_set_m_collisionFilterMask_1 = function() {
            return (Tv = b._emscripten_bind_ClosestRayResultCallback_set_m_collisionFilterMask_1 = b.asm.At).apply(null, arguments)
          }
          , Uv = b._emscripten_bind_ClosestRayResultCallback_get_m_closestHitFraction_0 = function() {
            return (Uv = b._emscripten_bind_ClosestRayResultCallback_get_m_closestHitFraction_0 = b.asm.Bt).apply(null, arguments)
          }
          , Vv = b._emscripten_bind_ClosestRayResultCallback_set_m_closestHitFraction_1 = function() {
            return (Vv = b._emscripten_bind_ClosestRayResultCallback_set_m_closestHitFraction_1 = b.asm.Ct).apply(null, arguments)
          }
          , Wv = b._emscripten_bind_ClosestRayResultCallback_get_m_collisionObject_0 = function() {
            return (Wv = b._emscripten_bind_ClosestRayResultCallback_get_m_collisionObject_0 = b.asm.Dt).apply(null, arguments)
          }
          , Xv = b._emscripten_bind_ClosestRayResultCallback_set_m_collisionObject_1 = function() {
            return (Xv = b._emscripten_bind_ClosestRayResultCallback_set_m_collisionObject_1 = b.asm.Et).apply(null, arguments)
          }
          , Yv = b._emscripten_bind_ClosestRayResultCallback___destroy___0 = function() {
            return (Yv = b._emscripten_bind_ClosestRayResultCallback___destroy___0 = b.asm.Ft).apply(null, arguments)
          }
          , Zv = b._emscripten_bind_btSoftBodyRigidBodyCollisionConfiguration_btSoftBodyRigidBodyCollisionConfiguration_0 = function() {
            return (Zv = b._emscripten_bind_btSoftBodyRigidBodyCollisionConfiguration_btSoftBodyRigidBodyCollisionConfiguration_0 = b.asm.Gt).apply(null, arguments)
          }
          , $v = b._emscripten_bind_btSoftBodyRigidBodyCollisionConfiguration_btSoftBodyRigidBodyCollisionConfiguration_1 = function() {
            return ($v = b._emscripten_bind_btSoftBodyRigidBodyCollisionConfiguration_btSoftBodyRigidBodyCollisionConfiguration_1 = b.asm.Ht).apply(null, arguments)
          }
          , aw = b._emscripten_bind_btSoftBodyRigidBodyCollisionConfiguration___destroy___0 = function() {
            return (aw = b._emscripten_bind_btSoftBodyRigidBodyCollisionConfiguration___destroy___0 = b.asm.It).apply(null, arguments)
          }
          , bw = b._emscripten_bind_ConcreteContactResultCallback_ConcreteContactResultCallback_0 = function() {
            return (bw = b._emscripten_bind_ConcreteContactResultCallback_ConcreteContactResultCallback_0 = b.asm.Jt).apply(null, arguments)
          }
          , cw = b._emscripten_bind_ConcreteContactResultCallback_addSingleResult_7 = function() {
            return (cw = b._emscripten_bind_ConcreteContactResultCallback_addSingleResult_7 = b.asm.Kt).apply(null, arguments)
          }
          , dw = b._emscripten_bind_ConcreteContactResultCallback___destroy___0 = function() {
            return (dw = b._emscripten_bind_ConcreteContactResultCallback___destroy___0 = b.asm.Lt).apply(null, arguments)
          }
          , ew = b._emscripten_bind_btBvhTriangleMeshShape_btBvhTriangleMeshShape_2 = function() {
            return (ew = b._emscripten_bind_btBvhTriangleMeshShape_btBvhTriangleMeshShape_2 = b.asm.Mt).apply(null, arguments)
          }
          , fw = b._emscripten_bind_btBvhTriangleMeshShape_btBvhTriangleMeshShape_3 = function() {
            return (fw = b._emscripten_bind_btBvhTriangleMeshShape_btBvhTriangleMeshShape_3 = b.asm.Nt).apply(null, arguments)
          }
          , gw = b._emscripten_bind_btBvhTriangleMeshShape_setLocalScaling_1 = function() {
            return (gw = b._emscripten_bind_btBvhTriangleMeshShape_setLocalScaling_1 = b.asm.Ot).apply(null, arguments)
          }
          , hw = b._emscripten_bind_btBvhTriangleMeshShape_getLocalScaling_0 = function() {
            return (hw = b._emscripten_bind_btBvhTriangleMeshShape_getLocalScaling_0 = b.asm.Pt).apply(null, arguments)
          }
          , iw = b._emscripten_bind_btBvhTriangleMeshShape_calculateLocalInertia_2 = function() {
            return (iw = b._emscripten_bind_btBvhTriangleMeshShape_calculateLocalInertia_2 = b.asm.Qt).apply(null, arguments)
          }
          , jw = b._emscripten_bind_btBvhTriangleMeshShape___destroy___0 = function() {
            return (jw = b._emscripten_bind_btBvhTriangleMeshShape___destroy___0 = b.asm.Rt).apply(null, arguments)
          }
          , kw = b._emscripten_bind_btConstCollisionObjectArray_size_0 = function() {
            return (kw = b._emscripten_bind_btConstCollisionObjectArray_size_0 = b.asm.St).apply(null, arguments)
          }
          , lw = b._emscripten_bind_btConstCollisionObjectArray_at_1 = function() {
            return (lw = b._emscripten_bind_btConstCollisionObjectArray_at_1 = b.asm.Tt).apply(null, arguments)
          }
          , mw = b._emscripten_bind_btConstCollisionObjectArray___destroy___0 = function() {
            return (mw = b._emscripten_bind_btConstCollisionObjectArray___destroy___0 = b.asm.Ut).apply(null, arguments)
          }
          , nw = b._emscripten_bind_btSliderConstraint_btSliderConstraint_3 = function() {
            return (nw = b._emscripten_bind_btSliderConstraint_btSliderConstraint_3 = b.asm.Vt).apply(null, arguments)
          }
          , ow = b._emscripten_bind_btSliderConstraint_btSliderConstraint_5 = function() {
            return (ow = b._emscripten_bind_btSliderConstraint_btSliderConstraint_5 = b.asm.Wt).apply(null, arguments)
          }
          , pw = b._emscripten_bind_btSliderConstraint_setLowerLinLimit_1 = function() {
            return (pw = b._emscripten_bind_btSliderConstraint_setLowerLinLimit_1 = b.asm.Xt).apply(null, arguments)
          }
          , qw = b._emscripten_bind_btSliderConstraint_setUpperLinLimit_1 = function() {
            return (qw = b._emscripten_bind_btSliderConstraint_setUpperLinLimit_1 = b.asm.Yt).apply(null, arguments)
          }
          , rw = b._emscripten_bind_btSliderConstraint_setLowerAngLimit_1 = function() {
            return (rw = b._emscripten_bind_btSliderConstraint_setLowerAngLimit_1 = b.asm.Zt).apply(null, arguments)
          }
          , sw = b._emscripten_bind_btSliderConstraint_setUpperAngLimit_1 = function() {
            return (sw = b._emscripten_bind_btSliderConstraint_setUpperAngLimit_1 = b.asm._t).apply(null, arguments)
          }
          , tw = b._emscripten_bind_btSliderConstraint_enableFeedback_1 = function() {
            return (tw = b._emscripten_bind_btSliderConstraint_enableFeedback_1 = b.asm.$t).apply(null, arguments)
          }
          , uw = b._emscripten_bind_btSliderConstraint_getBreakingImpulseThreshold_0 = function() {
            return (uw = b._emscripten_bind_btSliderConstraint_getBreakingImpulseThreshold_0 = b.asm.au).apply(null, arguments)
          }
          , vw = b._emscripten_bind_btSliderConstraint_setBreakingImpulseThreshold_1 = function() {
            return (vw = b._emscripten_bind_btSliderConstraint_setBreakingImpulseThreshold_1 = b.asm.bu).apply(null, arguments)
          }
          , ww = b._emscripten_bind_btSliderConstraint_getParam_2 = function() {
            return (ww = b._emscripten_bind_btSliderConstraint_getParam_2 = b.asm.cu).apply(null, arguments)
          }
          , xw = b._emscripten_bind_btSliderConstraint_setParam_3 = function() {
            return (xw = b._emscripten_bind_btSliderConstraint_setParam_3 = b.asm.du).apply(null, arguments)
          }
          , yw = b._emscripten_bind_btSliderConstraint___destroy___0 = function() {
            return (yw = b._emscripten_bind_btSliderConstraint___destroy___0 = b.asm.eu).apply(null, arguments)
          }
          , zw = b._emscripten_bind_btPairCachingGhostObject_btPairCachingGhostObject_0 = function() {
            return (zw = b._emscripten_bind_btPairCachingGhostObject_btPairCachingGhostObject_0 = b.asm.fu).apply(null, arguments)
          }
          , Aw = b._emscripten_bind_btPairCachingGhostObject_setAnisotropicFriction_2 = function() {
            return (Aw = b._emscripten_bind_btPairCachingGhostObject_setAnisotropicFriction_2 = b.asm.gu).apply(null, arguments)
          }
          , Bw = b._emscripten_bind_btPairCachingGhostObject_getCollisionShape_0 = function() {
            return (Bw = b._emscripten_bind_btPairCachingGhostObject_getCollisionShape_0 = b.asm.hu).apply(null, arguments)
          }
          , Cw = b._emscripten_bind_btPairCachingGhostObject_setContactProcessingThreshold_1 = function() {
            return (Cw = b._emscripten_bind_btPairCachingGhostObject_setContactProcessingThreshold_1 = b.asm.iu).apply(null, arguments)
          }
          , Dw = b._emscripten_bind_btPairCachingGhostObject_setActivationState_1 = function() {
            return (Dw = b._emscripten_bind_btPairCachingGhostObject_setActivationState_1 = b.asm.ju).apply(null, arguments)
          }
          , Ew = b._emscripten_bind_btPairCachingGhostObject_forceActivationState_1 = function() {
            return (Ew = b._emscripten_bind_btPairCachingGhostObject_forceActivationState_1 = b.asm.ku).apply(null, arguments)
          }
          , Fw = b._emscripten_bind_btPairCachingGhostObject_activate_0 = function() {
            return (Fw = b._emscripten_bind_btPairCachingGhostObject_activate_0 = b.asm.lu).apply(null, arguments)
          }
          , Gw = b._emscripten_bind_btPairCachingGhostObject_activate_1 = function() {
            return (Gw = b._emscripten_bind_btPairCachingGhostObject_activate_1 = b.asm.mu).apply(null, arguments)
          }
          , Hw = b._emscripten_bind_btPairCachingGhostObject_isActive_0 = function() {
            return (Hw = b._emscripten_bind_btPairCachingGhostObject_isActive_0 = b.asm.nu).apply(null, arguments)
          }
          , Iw = b._emscripten_bind_btPairCachingGhostObject_isKinematicObject_0 = function() {
            return (Iw = b._emscripten_bind_btPairCachingGhostObject_isKinematicObject_0 = b.asm.ou).apply(null, arguments)
          }
          , Jw = b._emscripten_bind_btPairCachingGhostObject_isStaticObject_0 = function() {
            return (Jw = b._emscripten_bind_btPairCachingGhostObject_isStaticObject_0 = b.asm.pu).apply(null, arguments)
          }
          , Kw = b._emscripten_bind_btPairCachingGhostObject_isStaticOrKinematicObject_0 = function() {
            return (Kw = b._emscripten_bind_btPairCachingGhostObject_isStaticOrKinematicObject_0 = b.asm.qu).apply(null, arguments)
          }
          , Lw = b._emscripten_bind_btPairCachingGhostObject_getRestitution_0 = function() {
            return (Lw = b._emscripten_bind_btPairCachingGhostObject_getRestitution_0 = b.asm.ru).apply(null, arguments)
          }
          , Mw = b._emscripten_bind_btPairCachingGhostObject_getFriction_0 = function() {
            return (Mw = b._emscripten_bind_btPairCachingGhostObject_getFriction_0 = b.asm.su).apply(null, arguments)
          }
          , Nw = b._emscripten_bind_btPairCachingGhostObject_getRollingFriction_0 = function() {
            return (Nw = b._emscripten_bind_btPairCachingGhostObject_getRollingFriction_0 = b.asm.tu).apply(null, arguments)
          }
          , Ow = b._emscripten_bind_btPairCachingGhostObject_setRestitution_1 = function() {
            return (Ow = b._emscripten_bind_btPairCachingGhostObject_setRestitution_1 = b.asm.uu).apply(null, arguments)
          }
          , Pw = b._emscripten_bind_btPairCachingGhostObject_setFriction_1 = function() {
            return (Pw = b._emscripten_bind_btPairCachingGhostObject_setFriction_1 = b.asm.vu).apply(null, arguments)
          }
          , Qw = b._emscripten_bind_btPairCachingGhostObject_setRollingFriction_1 = function() {
            return (Qw = b._emscripten_bind_btPairCachingGhostObject_setRollingFriction_1 = b.asm.wu).apply(null, arguments)
          }
          , Rw = b._emscripten_bind_btPairCachingGhostObject_getWorldTransform_0 = function() {
            return (Rw = b._emscripten_bind_btPairCachingGhostObject_getWorldTransform_0 = b.asm.xu).apply(null, arguments)
          }
          , Sw = b._emscripten_bind_btPairCachingGhostObject_getCollisionFlags_0 = function() {
            return (Sw = b._emscripten_bind_btPairCachingGhostObject_getCollisionFlags_0 = b.asm.yu).apply(null, arguments)
          }
          , Tw = b._emscripten_bind_btPairCachingGhostObject_setCollisionFlags_1 = function() {
            return (Tw = b._emscripten_bind_btPairCachingGhostObject_setCollisionFlags_1 = b.asm.zu).apply(null, arguments)
          }
          , Uw = b._emscripten_bind_btPairCachingGhostObject_setWorldTransform_1 = function() {
            return (Uw = b._emscripten_bind_btPairCachingGhostObject_setWorldTransform_1 = b.asm.Au).apply(null, arguments)
          }
          , Vw = b._emscripten_bind_btPairCachingGhostObject_setCollisionShape_1 = function() {
            return (Vw = b._emscripten_bind_btPairCachingGhostObject_setCollisionShape_1 = b.asm.Bu).apply(null, arguments)
          }
          , Ww = b._emscripten_bind_btPairCachingGhostObject_setCcdMotionThreshold_1 = function() {
            return (Ww = b._emscripten_bind_btPairCachingGhostObject_setCcdMotionThreshold_1 = b.asm.Cu).apply(null, arguments)
          }
          , Xw = b._emscripten_bind_btPairCachingGhostObject_setCcdSweptSphereRadius_1 = function() {
            return (Xw = b._emscripten_bind_btPairCachingGhostObject_setCcdSweptSphereRadius_1 = b.asm.Du).apply(null, arguments)
          }
          , Yw = b._emscripten_bind_btPairCachingGhostObject_getUserIndex_0 = function() {
            return (Yw = b._emscripten_bind_btPairCachingGhostObject_getUserIndex_0 = b.asm.Eu).apply(null, arguments)
          }
          , Zw = b._emscripten_bind_btPairCachingGhostObject_setUserIndex_1 = function() {
            return (Zw = b._emscripten_bind_btPairCachingGhostObject_setUserIndex_1 = b.asm.Fu).apply(null, arguments)
          }
          , $w = b._emscripten_bind_btPairCachingGhostObject_getUserPointer_0 = function() {
            return ($w = b._emscripten_bind_btPairCachingGhostObject_getUserPointer_0 = b.asm.Gu).apply(null, arguments)
          }
          , ax = b._emscripten_bind_btPairCachingGhostObject_setUserPointer_1 = function() {
            return (ax = b._emscripten_bind_btPairCachingGhostObject_setUserPointer_1 = b.asm.Hu).apply(null, arguments)
          }
          , bx = b._emscripten_bind_btPairCachingGhostObject_getBroadphaseHandle_0 = function() {
            return (bx = b._emscripten_bind_btPairCachingGhostObject_getBroadphaseHandle_0 = b.asm.Iu).apply(null, arguments)
          }
          , cx = b._emscripten_bind_btPairCachingGhostObject_getNumOverlappingObjects_0 = function() {
            return (cx = b._emscripten_bind_btPairCachingGhostObject_getNumOverlappingObjects_0 = b.asm.Ju).apply(null, arguments)
          }
          , dx = b._emscripten_bind_btPairCachingGhostObject_getOverlappingObject_1 = function() {
            return (dx = b._emscripten_bind_btPairCachingGhostObject_getOverlappingObject_1 = b.asm.Ku).apply(null, arguments)
          }
          , ex = b._emscripten_bind_btPairCachingGhostObject___destroy___0 = function() {
            return (ex = b._emscripten_bind_btPairCachingGhostObject___destroy___0 = b.asm.Lu).apply(null, arguments)
          }
          , fx = b._emscripten_bind_btManifoldPoint_getPositionWorldOnA_0 = function() {
            return (fx = b._emscripten_bind_btManifoldPoint_getPositionWorldOnA_0 = b.asm.Mu).apply(null, arguments)
          }
          , gx = b._emscripten_bind_btManifoldPoint_getPositionWorldOnB_0 = function() {
            return (gx = b._emscripten_bind_btManifoldPoint_getPositionWorldOnB_0 = b.asm.Nu).apply(null, arguments)
          }
          , hx = b._emscripten_bind_btManifoldPoint_getAppliedImpulse_0 = function() {
            return (hx = b._emscripten_bind_btManifoldPoint_getAppliedImpulse_0 = b.asm.Ou).apply(null, arguments)
          }
          , ix = b._emscripten_bind_btManifoldPoint_getDistance_0 = function() {
            return (ix = b._emscripten_bind_btManifoldPoint_getDistance_0 = b.asm.Pu).apply(null, arguments)
          }
          , jx = b._emscripten_bind_btManifoldPoint_get_m_localPointA_0 = function() {
            return (jx = b._emscripten_bind_btManifoldPoint_get_m_localPointA_0 = b.asm.Qu).apply(null, arguments)
          }
          , kx = b._emscripten_bind_btManifoldPoint_set_m_localPointA_1 = function() {
            return (kx = b._emscripten_bind_btManifoldPoint_set_m_localPointA_1 = b.asm.Ru).apply(null, arguments)
          }
          , lx = b._emscripten_bind_btManifoldPoint_get_m_localPointB_0 = function() {
            return (lx = b._emscripten_bind_btManifoldPoint_get_m_localPointB_0 = b.asm.Su).apply(null, arguments)
          }
          , mx = b._emscripten_bind_btManifoldPoint_set_m_localPointB_1 = function() {
            return (mx = b._emscripten_bind_btManifoldPoint_set_m_localPointB_1 = b.asm.Tu).apply(null, arguments)
          }
          , nx = b._emscripten_bind_btManifoldPoint_get_m_positionWorldOnB_0 = function() {
            return (nx = b._emscripten_bind_btManifoldPoint_get_m_positionWorldOnB_0 = b.asm.Uu).apply(null, arguments)
          }
          , ox = b._emscripten_bind_btManifoldPoint_set_m_positionWorldOnB_1 = function() {
            return (ox = b._emscripten_bind_btManifoldPoint_set_m_positionWorldOnB_1 = b.asm.Vu).apply(null, arguments)
          }
          , px = b._emscripten_bind_btManifoldPoint_get_m_positionWorldOnA_0 = function() {
            return (px = b._emscripten_bind_btManifoldPoint_get_m_positionWorldOnA_0 = b.asm.Wu).apply(null, arguments)
          }
          , qx = b._emscripten_bind_btManifoldPoint_set_m_positionWorldOnA_1 = function() {
            return (qx = b._emscripten_bind_btManifoldPoint_set_m_positionWorldOnA_1 = b.asm.Xu).apply(null, arguments)
          }
          , rx = b._emscripten_bind_btManifoldPoint_get_m_normalWorldOnB_0 = function() {
            return (rx = b._emscripten_bind_btManifoldPoint_get_m_normalWorldOnB_0 = b.asm.Yu).apply(null, arguments)
          }
          , sx = b._emscripten_bind_btManifoldPoint_set_m_normalWorldOnB_1 = function() {
            return (sx = b._emscripten_bind_btManifoldPoint_set_m_normalWorldOnB_1 = b.asm.Zu).apply(null, arguments)
          }
          , tx = b._emscripten_bind_btManifoldPoint_get_m_userPersistentData_0 = function() {
            return (tx = b._emscripten_bind_btManifoldPoint_get_m_userPersistentData_0 = b.asm._u).apply(null, arguments)
          }
          , ux = b._emscripten_bind_btManifoldPoint_set_m_userPersistentData_1 = function() {
            return (ux = b._emscripten_bind_btManifoldPoint_set_m_userPersistentData_1 = b.asm.$u).apply(null, arguments)
          }
          , vx = b._emscripten_bind_btManifoldPoint___destroy___0 = function() {
            return (vx = b._emscripten_bind_btManifoldPoint___destroy___0 = b.asm.av).apply(null, arguments)
          }
          , wx = b._emscripten_bind_btPoint2PointConstraint_btPoint2PointConstraint_2 = function() {
            return (wx = b._emscripten_bind_btPoint2PointConstraint_btPoint2PointConstraint_2 = b.asm.bv).apply(null, arguments)
          }
          , xx = b._emscripten_bind_btPoint2PointConstraint_btPoint2PointConstraint_4 = function() {
            return (xx = b._emscripten_bind_btPoint2PointConstraint_btPoint2PointConstraint_4 = b.asm.cv).apply(null, arguments)
          }
          , yx = b._emscripten_bind_btPoint2PointConstraint_setPivotA_1 = function() {
            return (yx = b._emscripten_bind_btPoint2PointConstraint_setPivotA_1 = b.asm.dv).apply(null, arguments)
          }
          , zx = b._emscripten_bind_btPoint2PointConstraint_setPivotB_1 = function() {
            return (zx = b._emscripten_bind_btPoint2PointConstraint_setPivotB_1 = b.asm.ev).apply(null, arguments)
          }
          , Ax = b._emscripten_bind_btPoint2PointConstraint_getPivotInA_0 = function() {
            return (Ax = b._emscripten_bind_btPoint2PointConstraint_getPivotInA_0 = b.asm.fv).apply(null, arguments)
          }
          , Bx = b._emscripten_bind_btPoint2PointConstraint_getPivotInB_0 = function() {
            return (Bx = b._emscripten_bind_btPoint2PointConstraint_getPivotInB_0 = b.asm.gv).apply(null, arguments)
          }
          , Cx = b._emscripten_bind_btPoint2PointConstraint_enableFeedback_1 = function() {
            return (Cx = b._emscripten_bind_btPoint2PointConstraint_enableFeedback_1 = b.asm.hv).apply(null, arguments)
          }
          , Dx = b._emscripten_bind_btPoint2PointConstraint_getBreakingImpulseThreshold_0 = function() {
            return (Dx = b._emscripten_bind_btPoint2PointConstraint_getBreakingImpulseThreshold_0 = b.asm.iv).apply(null, arguments)
          }
          , Ex = b._emscripten_bind_btPoint2PointConstraint_setBreakingImpulseThreshold_1 = function() {
            return (Ex = b._emscripten_bind_btPoint2PointConstraint_setBreakingImpulseThreshold_1 = b.asm.jv).apply(null, arguments)
          }
          , Fx = b._emscripten_bind_btPoint2PointConstraint_getParam_2 = function() {
            return (Fx = b._emscripten_bind_btPoint2PointConstraint_getParam_2 = b.asm.kv).apply(null, arguments)
          }
          , Gx = b._emscripten_bind_btPoint2PointConstraint_setParam_3 = function() {
            return (Gx = b._emscripten_bind_btPoint2PointConstraint_setParam_3 = b.asm.lv).apply(null, arguments)
          }
          , Hx = b._emscripten_bind_btPoint2PointConstraint_get_m_setting_0 = function() {
            return (Hx = b._emscripten_bind_btPoint2PointConstraint_get_m_setting_0 = b.asm.mv).apply(null, arguments)
          }
          , Ix = b._emscripten_bind_btPoint2PointConstraint_set_m_setting_1 = function() {
            return (Ix = b._emscripten_bind_btPoint2PointConstraint_set_m_setting_1 = b.asm.nv).apply(null, arguments)
          }
          , Jx = b._emscripten_bind_btPoint2PointConstraint___destroy___0 = function() {
            return (Jx = b._emscripten_bind_btPoint2PointConstraint___destroy___0 = b.asm.ov).apply(null, arguments)
          }
          , Kx = b._emscripten_bind_btSoftBodyHelpers_btSoftBodyHelpers_0 = function() {
            return (Kx = b._emscripten_bind_btSoftBodyHelpers_btSoftBodyHelpers_0 = b.asm.pv).apply(null, arguments)
          }
          , Lx = b._emscripten_bind_btSoftBodyHelpers_CreateRope_5 = function() {
            return (Lx = b._emscripten_bind_btSoftBodyHelpers_CreateRope_5 = b.asm.qv).apply(null, arguments)
          }
          , Mx = b._emscripten_bind_btSoftBodyHelpers_CreatePatch_9 = function() {
            return (Mx = b._emscripten_bind_btSoftBodyHelpers_CreatePatch_9 = b.asm.rv).apply(null, arguments)
          }
          , Nx = b._emscripten_bind_btSoftBodyHelpers_CreatePatchUV_10 = function() {
            return (Nx = b._emscripten_bind_btSoftBodyHelpers_CreatePatchUV_10 = b.asm.sv).apply(null, arguments)
          }
          , Ox = b._emscripten_bind_btSoftBodyHelpers_CreateEllipsoid_4 = function() {
            return (Ox = b._emscripten_bind_btSoftBodyHelpers_CreateEllipsoid_4 = b.asm.tv).apply(null, arguments)
          }
          , Px = b._emscripten_bind_btSoftBodyHelpers_CreateFromTriMesh_5 = function() {
            return (Px = b._emscripten_bind_btSoftBodyHelpers_CreateFromTriMesh_5 = b.asm.uv).apply(null, arguments)
          }
          , Qx = b._emscripten_bind_btSoftBodyHelpers_CreateFromConvexHull_4 = function() {
            return (Qx = b._emscripten_bind_btSoftBodyHelpers_CreateFromConvexHull_4 = b.asm.vv).apply(null, arguments)
          }
          , Rx = b._emscripten_bind_btSoftBodyHelpers___destroy___0 = function() {
            return (Rx = b._emscripten_bind_btSoftBodyHelpers___destroy___0 = b.asm.wv).apply(null, arguments)
          }
          , Sx = b._emscripten_bind_btBroadphaseProxy_get_m_collisionFilterGroup_0 = function() {
            return (Sx = b._emscripten_bind_btBroadphaseProxy_get_m_collisionFilterGroup_0 = b.asm.xv).apply(null, arguments)
          }
          , Tx = b._emscripten_bind_btBroadphaseProxy_set_m_collisionFilterGroup_1 = function() {
            return (Tx = b._emscripten_bind_btBroadphaseProxy_set_m_collisionFilterGroup_1 = b.asm.yv).apply(null, arguments)
          }
          , Ux = b._emscripten_bind_btBroadphaseProxy_get_m_collisionFilterMask_0 = function() {
            return (Ux = b._emscripten_bind_btBroadphaseProxy_get_m_collisionFilterMask_0 = b.asm.zv).apply(null, arguments)
          }
          , Vx = b._emscripten_bind_btBroadphaseProxy_set_m_collisionFilterMask_1 = function() {
            return (Vx = b._emscripten_bind_btBroadphaseProxy_set_m_collisionFilterMask_1 = b.asm.Av).apply(null, arguments)
          }
          , Wx = b._emscripten_bind_btBroadphaseProxy___destroy___0 = function() {
            return (Wx = b._emscripten_bind_btBroadphaseProxy___destroy___0 = b.asm.Bv).apply(null, arguments)
          }
          , Xx = b._emscripten_bind_tNodeArray_size_0 = function() {
            return (Xx = b._emscripten_bind_tNodeArray_size_0 = b.asm.Cv).apply(null, arguments)
          }
          , Yx = b._emscripten_bind_tNodeArray_at_1 = function() {
            return (Yx = b._emscripten_bind_tNodeArray_at_1 = b.asm.Dv).apply(null, arguments)
          }
          , Zx = b._emscripten_bind_tNodeArray___destroy___0 = function() {
            return (Zx = b._emscripten_bind_tNodeArray___destroy___0 = b.asm.Ev).apply(null, arguments)
          }
          , $x = b._emscripten_bind_btBoxShape_btBoxShape_1 = function() {
            return ($x = b._emscripten_bind_btBoxShape_btBoxShape_1 = b.asm.Fv).apply(null, arguments)
          }
          , ay = b._emscripten_bind_btBoxShape_setMargin_1 = function() {
            return (ay = b._emscripten_bind_btBoxShape_setMargin_1 = b.asm.Gv).apply(null, arguments)
          }
          , by = b._emscripten_bind_btBoxShape_getMargin_0 = function() {
            return (by = b._emscripten_bind_btBoxShape_getMargin_0 = b.asm.Hv).apply(null, arguments)
          }
          , cy = b._emscripten_bind_btBoxShape_setLocalScaling_1 = function() {
            return (cy = b._emscripten_bind_btBoxShape_setLocalScaling_1 = b.asm.Iv).apply(null, arguments)
          }
          , dy = b._emscripten_bind_btBoxShape_getLocalScaling_0 = function() {
            return (dy = b._emscripten_bind_btBoxShape_getLocalScaling_0 = b.asm.Jv).apply(null, arguments)
          }
          , ey = b._emscripten_bind_btBoxShape_calculateLocalInertia_2 = function() {
            return (ey = b._emscripten_bind_btBoxShape_calculateLocalInertia_2 = b.asm.Kv).apply(null, arguments)
          }
          , fy = b._emscripten_bind_btBoxShape___destroy___0 = function() {
            return (fy = b._emscripten_bind_btBoxShape___destroy___0 = b.asm.Lv).apply(null, arguments)
          }
          , gy = b._emscripten_bind_btFace_get_m_indices_0 = function() {
            return (gy = b._emscripten_bind_btFace_get_m_indices_0 = b.asm.Mv).apply(null, arguments)
          }
          , hy = b._emscripten_bind_btFace_set_m_indices_1 = function() {
            return (hy = b._emscripten_bind_btFace_set_m_indices_1 = b.asm.Nv).apply(null, arguments)
          }
          , iy = b._emscripten_bind_btFace_get_m_plane_1 = function() {
            return (iy = b._emscripten_bind_btFace_get_m_plane_1 = b.asm.Ov).apply(null, arguments)
          }
          , jy = b._emscripten_bind_btFace_set_m_plane_2 = function() {
            return (jy = b._emscripten_bind_btFace_set_m_plane_2 = b.asm.Pv).apply(null, arguments)
          }
          , ky = b._emscripten_bind_btFace___destroy___0 = function() {
            return (ky = b._emscripten_bind_btFace___destroy___0 = b.asm.Qv).apply(null, arguments)
          }
          , ly = b._emscripten_bind_DebugDrawer_DebugDrawer_0 = function() {
            return (ly = b._emscripten_bind_DebugDrawer_DebugDrawer_0 = b.asm.Rv).apply(null, arguments)
          }
          , my = b._emscripten_bind_DebugDrawer_drawLine_3 = function() {
            return (my = b._emscripten_bind_DebugDrawer_drawLine_3 = b.asm.Sv).apply(null, arguments)
          }
          , ny = b._emscripten_bind_DebugDrawer_drawContactPoint_5 = function() {
            return (ny = b._emscripten_bind_DebugDrawer_drawContactPoint_5 = b.asm.Tv).apply(null, arguments)
          }
          , oy = b._emscripten_bind_DebugDrawer_reportErrorWarning_1 = function() {
            return (oy = b._emscripten_bind_DebugDrawer_reportErrorWarning_1 = b.asm.Uv).apply(null, arguments)
          }
          , py = b._emscripten_bind_DebugDrawer_draw3dText_2 = function() {
            return (py = b._emscripten_bind_DebugDrawer_draw3dText_2 = b.asm.Vv).apply(null, arguments)
          }
          , qy = b._emscripten_bind_DebugDrawer_setDebugMode_1 = function() {
            return (qy = b._emscripten_bind_DebugDrawer_setDebugMode_1 = b.asm.Wv).apply(null, arguments)
          }
          , ry = b._emscripten_bind_DebugDrawer_getDebugMode_0 = function() {
            return (ry = b._emscripten_bind_DebugDrawer_getDebugMode_0 = b.asm.Xv).apply(null, arguments)
          }
          , sy = b._emscripten_bind_DebugDrawer___destroy___0 = function() {
            return (sy = b._emscripten_bind_DebugDrawer___destroy___0 = b.asm.Yv).apply(null, arguments)
          }
          , ty = b._emscripten_bind_btCapsuleShapeX_btCapsuleShapeX_2 = function() {
            return (ty = b._emscripten_bind_btCapsuleShapeX_btCapsuleShapeX_2 = b.asm.Zv).apply(null, arguments)
          }
          , uy = b._emscripten_bind_btCapsuleShapeX_setMargin_1 = function() {
            return (uy = b._emscripten_bind_btCapsuleShapeX_setMargin_1 = b.asm._v).apply(null, arguments)
          }
          , vy = b._emscripten_bind_btCapsuleShapeX_getMargin_0 = function() {
            return (vy = b._emscripten_bind_btCapsuleShapeX_getMargin_0 = b.asm.$v).apply(null, arguments)
          }
          , wy = b._emscripten_bind_btCapsuleShapeX_getUpAxis_0 = function() {
            return (wy = b._emscripten_bind_btCapsuleShapeX_getUpAxis_0 = b.asm.aw).apply(null, arguments)
          }
          , xy = b._emscripten_bind_btCapsuleShapeX_getRadius_0 = function() {
            return (xy = b._emscripten_bind_btCapsuleShapeX_getRadius_0 = b.asm.bw).apply(null, arguments)
          }
          , yy = b._emscripten_bind_btCapsuleShapeX_getHalfHeight_0 = function() {
            return (yy = b._emscripten_bind_btCapsuleShapeX_getHalfHeight_0 = b.asm.cw).apply(null, arguments)
          }
          , zy = b._emscripten_bind_btCapsuleShapeX_setLocalScaling_1 = function() {
            return (zy = b._emscripten_bind_btCapsuleShapeX_setLocalScaling_1 = b.asm.dw).apply(null, arguments)
          }
          , Ay = b._emscripten_bind_btCapsuleShapeX_getLocalScaling_0 = function() {
            return (Ay = b._emscripten_bind_btCapsuleShapeX_getLocalScaling_0 = b.asm.ew).apply(null, arguments)
          }
          , By = b._emscripten_bind_btCapsuleShapeX_calculateLocalInertia_2 = function() {
            return (By = b._emscripten_bind_btCapsuleShapeX_calculateLocalInertia_2 = b.asm.fw).apply(null, arguments)
          }
          , Cy = b._emscripten_bind_btCapsuleShapeX___destroy___0 = function() {
            return (Cy = b._emscripten_bind_btCapsuleShapeX___destroy___0 = b.asm.gw).apply(null, arguments)
          }
          , Dy = b._emscripten_bind_btQuaternion_btQuaternion_4 = function() {
            return (Dy = b._emscripten_bind_btQuaternion_btQuaternion_4 = b.asm.hw).apply(null, arguments)
          }
          , Ey = b._emscripten_bind_btQuaternion_setValue_4 = function() {
            return (Ey = b._emscripten_bind_btQuaternion_setValue_4 = b.asm.iw).apply(null, arguments)
          }
          , Fy = b._emscripten_bind_btQuaternion_setEulerZYX_3 = function() {
            return (Fy = b._emscripten_bind_btQuaternion_setEulerZYX_3 = b.asm.jw).apply(null, arguments)
          }
          , Gy = b._emscripten_bind_btQuaternion_setRotation_2 = function() {
            return (Gy = b._emscripten_bind_btQuaternion_setRotation_2 = b.asm.kw).apply(null, arguments)
          }
          , Hy = b._emscripten_bind_btQuaternion_normalize_0 = function() {
            return (Hy = b._emscripten_bind_btQuaternion_normalize_0 = b.asm.lw).apply(null, arguments)
          }
          , Iy = b._emscripten_bind_btQuaternion_length2_0 = function() {
            return (Iy = b._emscripten_bind_btQuaternion_length2_0 = b.asm.mw).apply(null, arguments)
          }
          , Jy = b._emscripten_bind_btQuaternion_length_0 = function() {
            return (Jy = b._emscripten_bind_btQuaternion_length_0 = b.asm.nw).apply(null, arguments)
          }
          , Ky = b._emscripten_bind_btQuaternion_dot_1 = function() {
            return (Ky = b._emscripten_bind_btQuaternion_dot_1 = b.asm.ow).apply(null, arguments)
          }
          , Ly = b._emscripten_bind_btQuaternion_normalized_0 = function() {
            return (Ly = b._emscripten_bind_btQuaternion_normalized_0 = b.asm.pw).apply(null, arguments)
          }
          , My = b._emscripten_bind_btQuaternion_getAxis_0 = function() {
            return (My = b._emscripten_bind_btQuaternion_getAxis_0 = b.asm.qw).apply(null, arguments)
          }
          , Ny = b._emscripten_bind_btQuaternion_inverse_0 = function() {
            return (Ny = b._emscripten_bind_btQuaternion_inverse_0 = b.asm.rw).apply(null, arguments)
          }
          , Oy = b._emscripten_bind_btQuaternion_getAngle_0 = function() {
            return (Oy = b._emscripten_bind_btQuaternion_getAngle_0 = b.asm.sw).apply(null, arguments)
          }
          , Py = b._emscripten_bind_btQuaternion_getAngleShortestPath_0 = function() {
            return (Py = b._emscripten_bind_btQuaternion_getAngleShortestPath_0 = b.asm.tw).apply(null, arguments)
          }
          , Qy = b._emscripten_bind_btQuaternion_angle_1 = function() {
            return (Qy = b._emscripten_bind_btQuaternion_angle_1 = b.asm.uw).apply(null, arguments)
          }
          , Ry = b._emscripten_bind_btQuaternion_angleShortestPath_1 = function() {
            return (Ry = b._emscripten_bind_btQuaternion_angleShortestPath_1 = b.asm.vw).apply(null, arguments)
          }
          , Sy = b._emscripten_bind_btQuaternion_op_add_1 = function() {
            return (Sy = b._emscripten_bind_btQuaternion_op_add_1 = b.asm.ww).apply(null, arguments)
          }
          , Ty = b._emscripten_bind_btQuaternion_op_sub_1 = function() {
            return (Ty = b._emscripten_bind_btQuaternion_op_sub_1 = b.asm.xw).apply(null, arguments)
          }
          , Uy = b._emscripten_bind_btQuaternion_op_mul_1 = function() {
            return (Uy = b._emscripten_bind_btQuaternion_op_mul_1 = b.asm.yw).apply(null, arguments)
          }
          , Vy = b._emscripten_bind_btQuaternion_op_mulq_1 = function() {
            return (Vy = b._emscripten_bind_btQuaternion_op_mulq_1 = b.asm.zw).apply(null, arguments)
          }
          , Wy = b._emscripten_bind_btQuaternion_op_div_1 = function() {
            return (Wy = b._emscripten_bind_btQuaternion_op_div_1 = b.asm.Aw).apply(null, arguments)
          }
          , Xy = b._emscripten_bind_btQuaternion_x_0 = function() {
            return (Xy = b._emscripten_bind_btQuaternion_x_0 = b.asm.Bw).apply(null, arguments)
          }
          , Yy = b._emscripten_bind_btQuaternion_y_0 = function() {
            return (Yy = b._emscripten_bind_btQuaternion_y_0 = b.asm.Cw).apply(null, arguments)
          }
          , Zy = b._emscripten_bind_btQuaternion_z_0 = function() {
            return (Zy = b._emscripten_bind_btQuaternion_z_0 = b.asm.Dw).apply(null, arguments)
          }
          , $y = b._emscripten_bind_btQuaternion_w_0 = function() {
            return ($y = b._emscripten_bind_btQuaternion_w_0 = b.asm.Ew).apply(null, arguments)
          }
          , az = b._emscripten_bind_btQuaternion_setX_1 = function() {
            return (az = b._emscripten_bind_btQuaternion_setX_1 = b.asm.Fw).apply(null, arguments)
          }
          , bz = b._emscripten_bind_btQuaternion_setY_1 = function() {
            return (bz = b._emscripten_bind_btQuaternion_setY_1 = b.asm.Gw).apply(null, arguments)
          }
          , cz = b._emscripten_bind_btQuaternion_setZ_1 = function() {
            return (cz = b._emscripten_bind_btQuaternion_setZ_1 = b.asm.Hw).apply(null, arguments)
          }
          , dz = b._emscripten_bind_btQuaternion_setW_1 = function() {
            return (dz = b._emscripten_bind_btQuaternion_setW_1 = b.asm.Iw).apply(null, arguments)
          }
          , ez = b._emscripten_bind_btQuaternion___destroy___0 = function() {
            return (ez = b._emscripten_bind_btQuaternion___destroy___0 = b.asm.Jw).apply(null, arguments)
          }
          , fz = b._emscripten_bind_btCapsuleShapeZ_btCapsuleShapeZ_2 = function() {
            return (fz = b._emscripten_bind_btCapsuleShapeZ_btCapsuleShapeZ_2 = b.asm.Kw).apply(null, arguments)
          }
          , gz = b._emscripten_bind_btCapsuleShapeZ_setMargin_1 = function() {
            return (gz = b._emscripten_bind_btCapsuleShapeZ_setMargin_1 = b.asm.Lw).apply(null, arguments)
          }
          , hz = b._emscripten_bind_btCapsuleShapeZ_getMargin_0 = function() {
            return (hz = b._emscripten_bind_btCapsuleShapeZ_getMargin_0 = b.asm.Mw).apply(null, arguments)
          }
          , iz = b._emscripten_bind_btCapsuleShapeZ_getUpAxis_0 = function() {
            return (iz = b._emscripten_bind_btCapsuleShapeZ_getUpAxis_0 = b.asm.Nw).apply(null, arguments)
          }
          , jz = b._emscripten_bind_btCapsuleShapeZ_getRadius_0 = function() {
            return (jz = b._emscripten_bind_btCapsuleShapeZ_getRadius_0 = b.asm.Ow).apply(null, arguments)
          }
          , kz = b._emscripten_bind_btCapsuleShapeZ_getHalfHeight_0 = function() {
            return (kz = b._emscripten_bind_btCapsuleShapeZ_getHalfHeight_0 = b.asm.Pw).apply(null, arguments)
          }
          , lz = b._emscripten_bind_btCapsuleShapeZ_setLocalScaling_1 = function() {
            return (lz = b._emscripten_bind_btCapsuleShapeZ_setLocalScaling_1 = b.asm.Qw).apply(null, arguments)
          }
          , mz = b._emscripten_bind_btCapsuleShapeZ_getLocalScaling_0 = function() {
            return (mz = b._emscripten_bind_btCapsuleShapeZ_getLocalScaling_0 = b.asm.Rw).apply(null, arguments)
          }
          , nz = b._emscripten_bind_btCapsuleShapeZ_calculateLocalInertia_2 = function() {
            return (nz = b._emscripten_bind_btCapsuleShapeZ_calculateLocalInertia_2 = b.asm.Sw).apply(null, arguments)
          }
          , oz = b._emscripten_bind_btCapsuleShapeZ___destroy___0 = function() {
            return (oz = b._emscripten_bind_btCapsuleShapeZ___destroy___0 = b.asm.Tw).apply(null, arguments)
          }
          , pz = b._emscripten_bind_btContactSolverInfo_get_m_splitImpulse_0 = function() {
            return (pz = b._emscripten_bind_btContactSolverInfo_get_m_splitImpulse_0 = b.asm.Uw).apply(null, arguments)
          }
          , qz = b._emscripten_bind_btContactSolverInfo_set_m_splitImpulse_1 = function() {
            return (qz = b._emscripten_bind_btContactSolverInfo_set_m_splitImpulse_1 = b.asm.Vw).apply(null, arguments)
          }
          , rz = b._emscripten_bind_btContactSolverInfo_get_m_splitImpulsePenetrationThreshold_0 = function() {
            return (rz = b._emscripten_bind_btContactSolverInfo_get_m_splitImpulsePenetrationThreshold_0 = b.asm.Ww).apply(null, arguments)
          }
          , sz = b._emscripten_bind_btContactSolverInfo_set_m_splitImpulsePenetrationThreshold_1 = function() {
            return (sz = b._emscripten_bind_btContactSolverInfo_set_m_splitImpulsePenetrationThreshold_1 = b.asm.Xw).apply(null, arguments)
          }
          , tz = b._emscripten_bind_btContactSolverInfo_get_m_numIterations_0 = function() {
            return (tz = b._emscripten_bind_btContactSolverInfo_get_m_numIterations_0 = b.asm.Yw).apply(null, arguments)
          }
          , uz = b._emscripten_bind_btContactSolverInfo_set_m_numIterations_1 = function() {
            return (uz = b._emscripten_bind_btContactSolverInfo_set_m_numIterations_1 = b.asm.Zw).apply(null, arguments)
          }
          , vz = b._emscripten_bind_btContactSolverInfo___destroy___0 = function() {
            return (vz = b._emscripten_bind_btContactSolverInfo___destroy___0 = b.asm._w).apply(null, arguments)
          }
          , wz = b._emscripten_bind_btGeneric6DofSpringConstraint_btGeneric6DofSpringConstraint_3 = function() {
            return (wz = b._emscripten_bind_btGeneric6DofSpringConstraint_btGeneric6DofSpringConstraint_3 = b.asm.$w).apply(null, arguments)
          }
          , xz = b._emscripten_bind_btGeneric6DofSpringConstraint_btGeneric6DofSpringConstraint_5 = function() {
            return (xz = b._emscripten_bind_btGeneric6DofSpringConstraint_btGeneric6DofSpringConstraint_5 = b.asm.ax).apply(null, arguments)
          }
          , yz = b._emscripten_bind_btGeneric6DofSpringConstraint_enableSpring_2 = function() {
            return (yz = b._emscripten_bind_btGeneric6DofSpringConstraint_enableSpring_2 = b.asm.bx).apply(null, arguments)
          }
          , zz = b._emscripten_bind_btGeneric6DofSpringConstraint_setStiffness_2 = function() {
            return (zz = b._emscripten_bind_btGeneric6DofSpringConstraint_setStiffness_2 = b.asm.cx).apply(null, arguments)
          }
          , Az = b._emscripten_bind_btGeneric6DofSpringConstraint_setDamping_2 = function() {
            return (Az = b._emscripten_bind_btGeneric6DofSpringConstraint_setDamping_2 = b.asm.dx).apply(null, arguments)
          }
          , Bz = b._emscripten_bind_btGeneric6DofSpringConstraint_setEquilibriumPoint_0 = function() {
            return (Bz = b._emscripten_bind_btGeneric6DofSpringConstraint_setEquilibriumPoint_0 = b.asm.ex).apply(null, arguments)
          }
          , Cz = b._emscripten_bind_btGeneric6DofSpringConstraint_setEquilibriumPoint_1 = function() {
            return (Cz = b._emscripten_bind_btGeneric6DofSpringConstraint_setEquilibriumPoint_1 = b.asm.fx).apply(null, arguments)
          }
          , Dz = b._emscripten_bind_btGeneric6DofSpringConstraint_setEquilibriumPoint_2 = function() {
            return (Dz = b._emscripten_bind_btGeneric6DofSpringConstraint_setEquilibriumPoint_2 = b.asm.gx).apply(null, arguments)
          }
          , Ez = b._emscripten_bind_btGeneric6DofSpringConstraint_setLinearLowerLimit_1 = function() {
            return (Ez = b._emscripten_bind_btGeneric6DofSpringConstraint_setLinearLowerLimit_1 = b.asm.hx).apply(null, arguments)
          }
          , Fz = b._emscripten_bind_btGeneric6DofSpringConstraint_setLinearUpperLimit_1 = function() {
            return (Fz = b._emscripten_bind_btGeneric6DofSpringConstraint_setLinearUpperLimit_1 = b.asm.ix).apply(null, arguments)
          }
          , Gz = b._emscripten_bind_btGeneric6DofSpringConstraint_setAngularLowerLimit_1 = function() {
            return (Gz = b._emscripten_bind_btGeneric6DofSpringConstraint_setAngularLowerLimit_1 = b.asm.jx).apply(null, arguments)
          }
          , Hz = b._emscripten_bind_btGeneric6DofSpringConstraint_setAngularUpperLimit_1 = function() {
            return (Hz = b._emscripten_bind_btGeneric6DofSpringConstraint_setAngularUpperLimit_1 = b.asm.kx).apply(null, arguments)
          }
          , Iz = b._emscripten_bind_btGeneric6DofSpringConstraint_getFrameOffsetA_0 = function() {
            return (Iz = b._emscripten_bind_btGeneric6DofSpringConstraint_getFrameOffsetA_0 = b.asm.lx).apply(null, arguments)
          }
          , Jz = b._emscripten_bind_btGeneric6DofSpringConstraint_enableFeedback_1 = function() {
            return (Jz = b._emscripten_bind_btGeneric6DofSpringConstraint_enableFeedback_1 = b.asm.mx).apply(null, arguments)
          }
          , Kz = b._emscripten_bind_btGeneric6DofSpringConstraint_getBreakingImpulseThreshold_0 = function() {
            return (Kz = b._emscripten_bind_btGeneric6DofSpringConstraint_getBreakingImpulseThreshold_0 = b.asm.nx).apply(null, arguments)
          }
          , Lz = b._emscripten_bind_btGeneric6DofSpringConstraint_setBreakingImpulseThreshold_1 = function() {
            return (Lz = b._emscripten_bind_btGeneric6DofSpringConstraint_setBreakingImpulseThreshold_1 = b.asm.ox).apply(null, arguments)
          }
          , Mz = b._emscripten_bind_btGeneric6DofSpringConstraint_getParam_2 = function() {
            return (Mz = b._emscripten_bind_btGeneric6DofSpringConstraint_getParam_2 = b.asm.px).apply(null, arguments)
          }
          , Nz = b._emscripten_bind_btGeneric6DofSpringConstraint_setParam_3 = function() {
            return (Nz = b._emscripten_bind_btGeneric6DofSpringConstraint_setParam_3 = b.asm.qx).apply(null, arguments)
          }
          , Oz = b._emscripten_bind_btGeneric6DofSpringConstraint___destroy___0 = function() {
            return (Oz = b._emscripten_bind_btGeneric6DofSpringConstraint___destroy___0 = b.asm.rx).apply(null, arguments)
          }
          , Pz = b._emscripten_bind_btSphereShape_btSphereShape_1 = function() {
            return (Pz = b._emscripten_bind_btSphereShape_btSphereShape_1 = b.asm.sx).apply(null, arguments)
          }
          , Qz = b._emscripten_bind_btSphereShape_setMargin_1 = function() {
            return (Qz = b._emscripten_bind_btSphereShape_setMargin_1 = b.asm.tx).apply(null, arguments)
          }
          , Rz = b._emscripten_bind_btSphereShape_getMargin_0 = function() {
            return (Rz = b._emscripten_bind_btSphereShape_getMargin_0 = b.asm.ux).apply(null, arguments)
          }
          , Sz = b._emscripten_bind_btSphereShape_setLocalScaling_1 = function() {
            return (Sz = b._emscripten_bind_btSphereShape_setLocalScaling_1 = b.asm.vx).apply(null, arguments)
          }
          , Tz = b._emscripten_bind_btSphereShape_getLocalScaling_0 = function() {
            return (Tz = b._emscripten_bind_btSphereShape_getLocalScaling_0 = b.asm.wx).apply(null, arguments)
          }
          , Uz = b._emscripten_bind_btSphereShape_calculateLocalInertia_2 = function() {
            return (Uz = b._emscripten_bind_btSphereShape_calculateLocalInertia_2 = b.asm.xx).apply(null, arguments)
          }
          , Vz = b._emscripten_bind_btSphereShape___destroy___0 = function() {
            return (Vz = b._emscripten_bind_btSphereShape___destroy___0 = b.asm.yx).apply(null, arguments)
          }
          , Wz = b._emscripten_bind_LocalConvexResult_LocalConvexResult_5 = function() {
            return (Wz = b._emscripten_bind_LocalConvexResult_LocalConvexResult_5 = b.asm.zx).apply(null, arguments)
          }
          , Xz = b._emscripten_bind_LocalConvexResult_get_m_hitCollisionObject_0 = function() {
            return (Xz = b._emscripten_bind_LocalConvexResult_get_m_hitCollisionObject_0 = b.asm.Ax).apply(null, arguments)
          }
          , Yz = b._emscripten_bind_LocalConvexResult_set_m_hitCollisionObject_1 = function() {
            return (Yz = b._emscripten_bind_LocalConvexResult_set_m_hitCollisionObject_1 = b.asm.Bx).apply(null, arguments)
          }
          , Zz = b._emscripten_bind_LocalConvexResult_get_m_localShapeInfo_0 = function() {
            return (Zz = b._emscripten_bind_LocalConvexResult_get_m_localShapeInfo_0 = b.asm.Cx).apply(null, arguments)
          }
          , $z = b._emscripten_bind_LocalConvexResult_set_m_localShapeInfo_1 = function() {
            return ($z = b._emscripten_bind_LocalConvexResult_set_m_localShapeInfo_1 = b.asm.Dx).apply(null, arguments)
          }
          , aA = b._emscripten_bind_LocalConvexResult_get_m_hitNormalLocal_0 = function() {
            return (aA = b._emscripten_bind_LocalConvexResult_get_m_hitNormalLocal_0 = b.asm.Ex).apply(null, arguments)
          }
          , bA = b._emscripten_bind_LocalConvexResult_set_m_hitNormalLocal_1 = function() {
            return (bA = b._emscripten_bind_LocalConvexResult_set_m_hitNormalLocal_1 = b.asm.Fx).apply(null, arguments)
          }
          , cA = b._emscripten_bind_LocalConvexResult_get_m_hitPointLocal_0 = function() {
            return (cA = b._emscripten_bind_LocalConvexResult_get_m_hitPointLocal_0 = b.asm.Gx).apply(null, arguments)
          }
          , dA = b._emscripten_bind_LocalConvexResult_set_m_hitPointLocal_1 = function() {
            return (dA = b._emscripten_bind_LocalConvexResult_set_m_hitPointLocal_1 = b.asm.Hx).apply(null, arguments)
          }
          , eA = b._emscripten_bind_LocalConvexResult_get_m_hitFraction_0 = function() {
            return (eA = b._emscripten_bind_LocalConvexResult_get_m_hitFraction_0 = b.asm.Ix).apply(null, arguments)
          }
          , fA = b._emscripten_bind_LocalConvexResult_set_m_hitFraction_1 = function() {
            return (fA = b._emscripten_bind_LocalConvexResult_set_m_hitFraction_1 = b.asm.Jx).apply(null, arguments)
          }
          , gA = b._emscripten_bind_LocalConvexResult___destroy___0 = function() {
            return (gA = b._emscripten_bind_LocalConvexResult___destroy___0 = b.asm.Kx).apply(null, arguments)
          }
          , hA = b._emscripten_enum_btConstraintParams_BT_CONSTRAINT_ERP = function() {
            return (hA = b._emscripten_enum_btConstraintParams_BT_CONSTRAINT_ERP = b.asm.Lx).apply(null, arguments)
          }
          , iA = b._emscripten_enum_btConstraintParams_BT_CONSTRAINT_STOP_ERP = function() {
            return (iA = b._emscripten_enum_btConstraintParams_BT_CONSTRAINT_STOP_ERP = b.asm.Mx).apply(null, arguments)
          }
          , jA = b._emscripten_enum_btConstraintParams_BT_CONSTRAINT_CFM = function() {
            return (jA = b._emscripten_enum_btConstraintParams_BT_CONSTRAINT_CFM = b.asm.Nx).apply(null, arguments)
          }
          , kA = b._emscripten_enum_btConstraintParams_BT_CONSTRAINT_STOP_CFM = function() {
            return (kA = b._emscripten_enum_btConstraintParams_BT_CONSTRAINT_STOP_CFM = b.asm.Ox).apply(null, arguments)
          }
          , lA = b._emscripten_enum_PHY_ScalarType_PHY_FLOAT = function() {
            return (lA = b._emscripten_enum_PHY_ScalarType_PHY_FLOAT = b.asm.Px).apply(null, arguments)
          }
          , mA = b._emscripten_enum_PHY_ScalarType_PHY_DOUBLE = function() {
            return (mA = b._emscripten_enum_PHY_ScalarType_PHY_DOUBLE = b.asm.Qx).apply(null, arguments)
          }
          , nA = b._emscripten_enum_PHY_ScalarType_PHY_INTEGER = function() {
            return (nA = b._emscripten_enum_PHY_ScalarType_PHY_INTEGER = b.asm.Rx).apply(null, arguments)
          }
          , oA = b._emscripten_enum_PHY_ScalarType_PHY_SHORT = function() {
            return (oA = b._emscripten_enum_PHY_ScalarType_PHY_SHORT = b.asm.Sx).apply(null, arguments)
          }
          , pA = b._emscripten_enum_PHY_ScalarType_PHY_FIXEDPOINT88 = function() {
            return (pA = b._emscripten_enum_PHY_ScalarType_PHY_FIXEDPOINT88 = b.asm.Tx).apply(null, arguments)
          }
          , qA = b._emscripten_enum_PHY_ScalarType_PHY_UCHAR = function() {
            return (qA = b._emscripten_enum_PHY_ScalarType_PHY_UCHAR = b.asm.Ux).apply(null, arguments)
          }
        ;
        b._malloc = function() {
          return (b._malloc = b.asm.Vx).apply(null, arguments)
        }
        ;
        b._free = function() {
          return (b._free = b.asm.Wx).apply(null, arguments)
        }
        ;
        b.dynCall_vi = function() {
          return (b.dynCall_vi = b.asm.Xx).apply(null, arguments)
        }
        ;
        b.dynCall_v = function() {
          return (b.dynCall_v = b.asm.Yx).apply(null, arguments)
        }
        ;
        b.asm = ab;
        b.UTF8ToString = function(a, c) {
          return a ? xa(Aa, a, c) : ""
        }
        ;
        b.addFunction = function(a, c) {
          if (!ra) {
            ra = new WeakMap;
            for (var d = 0; d < ua.length; d++) {
              var e = ua.get(d);
              e && ra.set(e, d)
            }
          }
          if (ra.has(a))
            a = ra.get(a);
          else {
            if (qa.length)
              d = qa.pop();
            else {
              d = ua.length;
              try {
                ua.grow(1)
              } catch (P) {
                if (!(P instanceof RangeError))
                  throw P;
                throw "Unable to grow wasm table. Set ALLOW_TABLE_GROWTH.";
              }
            }
            try {
              ua.set(d, a)
            } catch (P) {
              if (!(P instanceof TypeError))
                throw P;
              assert("undefined" !== typeof c, "Missing signature argument to addFunction");
              if ("function" === typeof WebAssembly.Function) {
                var f = {
                  i: "i32",
                  j: "i64",
                  f: "f32",
                  d: "f64"
                }
                  , m = {
                  parameters: [],
                  results: "v" == c[0] ? [] : [f[c[0]]]
                };
                for (e = 1; e < c.length; ++e)
                  m.parameters.push(f[c[e]]);
                c = new WebAssembly.Function(m,a)
              } else {
                f = [1, 0, 1, 96];
                m = c.slice(0, 1);
                c = c.slice(1);
                var C = {
                  i: 127,
                  j: 126,
                  f: 125,
                  d: 124
                };
                f.push(c.length);
                for (e = 0; e < c.length; ++e)
                  f.push(C[c[e]]);
                "v" == m ? f.push(0) : f = f.concat([1, C[m]]);
                f[1] = f.length - 2;
                c = new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0].concat(f, [2, 7, 1, 1, 101, 1, 102, 0, 0, 7, 5, 1, 1, 102, 0, 0]));
                c = new WebAssembly.Module(c);
                c = (new WebAssembly.Instance(c,{
                  e: {
                    f: a
                  }
                })).exports.f
              }
              ua.set(d, c)
            }
            a = ra[a] = d
          }
          return a
        }
        ;
        var rA;
        b.then = function(a) {
          if (rA)
            a(b);
          else {
            var c = b.onRuntimeInitialized;
            b.onRuntimeInitialized = function() {
              c && c();
              a(b)
            }
          }
          return b
        }
        ;
        Pa = function sA() {
          rA || tA();
          rA || (Pa = sA)
        }
        ;
        function tA() {
          function a() {
            if (!rA && (rA = !0,
              b.calledRun = !0,
              !va)) {
              La = !0;
              Ga(Ia);
              Ga(Ja);
              if (b.onRuntimeInitialized)
                b.onRuntimeInitialized();
              if (b.postRun)
                for ("function" == typeof b.postRun && (b.postRun = [b.postRun]); b.postRun.length; ) {
                  var c = b.postRun.shift();
                  Ka.unshift(c)
                }
              Ga(Ka)
            }
          }
          if (!(0 < Na)) {
            if (b.preRun)
              for ("function" == typeof b.preRun && (b.preRun = [b.preRun]); b.preRun.length; )
                Ma();
            Ga(Ha);
            0 < Na || (b.setStatus ? (b.setStatus("Running..."),
              setTimeout(function() {
                setTimeout(function() {
                  b.setStatus("")
                }, 1);
                a()
              }, 1)) : a())
          }
        }
        b.run = tA;
        if (b.preInit)
          for ("function" == typeof b.preInit && (b.preInit = [b.preInit]); 0 < b.preInit.length; )
            b.preInit.pop()();
        noExitRuntime = !0;
        tA();
        function g() {}
        g.prototype = Object.create(g.prototype);
        g.prototype.constructor = g;
        g.prototype.$x = g;
        g.ay = {};
        b.WrapperObject = g;
        function h(a) {
          return (a || g).ay
        }
        b.getCache = h;
        function k(a, c) {
          var d = h(c)
            , e = d[a];
          if (e)
            return e;
          e = Object.create((c || g).prototype);
          e.Zx = a;
          return d[a] = e
        }
        b.wrapPointer = k;
        b.castObject = function(a, c) {
          return k(a.Zx, c)
        }
        ;
        b.NULL = k(0);
        b.destroy = function(a) {
          if (!a.__destroy__)
            throw "Error: Cannot destroy object. (Did you create it yourself?)";
          a.__destroy__();
          delete h(a.$x)[a.Zx]
        }
        ;
        b.compare = function(a, c) {
          return a.Zx === c.Zx
        }
        ;
        b.getPointer = function(a) {
          return a.Zx
        }
        ;
        b.getClass = function(a) {
          return a.$x
        }
        ;
        var uA = 0
          , vA = 0
          , wA = 0
          , xA = []
          , yA = 0;
        function zA() {
          if (yA) {
            for (var a = 0; a < xA.length; a++)
              b._free(xA[a]);
            xA.length = 0;
            b._free(uA);
            uA = 0;
            vA += yA;
            yA = 0
          }
          uA || (vA += 128,
            uA = b._malloc(vA),
            assert(uA));
          wA = 0
        }
        function AA(a, c) {
          assert(uA);
          a = a.length * c.BYTES_PER_ELEMENT;
          a = a + 7 & -8;
          wA + a >= vA ? (assert(0 < a),
            yA += a,
            c = b._malloc(a),
            xA.push(c)) : (c = uA + wA,
            wA += a);
          return c
        }
        function BA(a, c, d) {
          d >>>= 0;
          switch (c.BYTES_PER_ELEMENT) {
            case 2:
              d >>>= 1;
              break;
            case 4:
              d >>>= 2;
              break;
            case 8:
              d >>>= 3
          }
          for (var e = 0; e < a.length; e++)
            c[d + e] = a[e]
        }
        function CA(a) {
          if ("string" === typeof a) {
            for (var c = 0, d = 0; d < a.length; ++d) {
              var e = a.charCodeAt(d);
              55296 <= e && 57343 >= e && (e = 65536 + ((e & 1023) << 10) | a.charCodeAt(++d) & 1023);
              127 >= e ? ++c : c = 2047 >= e ? c + 2 : 65535 >= e ? c + 3 : c + 4
            }
            c = Array(c + 1);
            e = c.length;
            d = 0;
            if (0 < e) {
              e = d + e - 1;
              for (var f = 0; f < a.length; ++f) {
                var m = a.charCodeAt(f);
                if (55296 <= m && 57343 >= m) {
                  var C = a.charCodeAt(++f);
                  m = 65536 + ((m & 1023) << 10) | C & 1023
                }
                if (127 >= m) {
                  if (d >= e)
                    break;
                  c[d++] = m
                } else {
                  if (2047 >= m) {
                    if (d + 1 >= e)
                      break;
                    c[d++] = 192 | m >> 6
                  } else {
                    if (65535 >= m) {
                      if (d + 2 >= e)
                        break;
                      c[d++] = 224 | m >> 12
                    } else {
                      if (d + 3 >= e)
                        break;
                      c[d++] = 240 | m >> 18;
                      c[d++] = 128 | m >> 12 & 63
                    }
                    c[d++] = 128 | m >> 6 & 63
                  }
                  c[d++] = 128 | m & 63
                }
              }
              c[d] = 0
            }
            a = AA(c, za);
            BA(c, za, a)
          }
          return a
        }
        function DA(a) {
          if ("object" === typeof a) {
            var c = AA(a, Ca);
            BA(a, Ca, c);
            return c
          }
          return a
        }
        function EA() {
          throw "cannot construct a btCollisionWorld, no constructor in IDL";
        }
        EA.prototype = Object.create(g.prototype);
        EA.prototype.constructor = EA;
        EA.prototype.$x = EA;
        EA.ay = {};
        b.btCollisionWorld = EA;
        EA.prototype.getDispatcher = function() {
          return k(bb(this.Zx), FA)
        }
        ;
        EA.prototype.rayTest = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          cb(e, a, c, d)
        }
        ;
        EA.prototype.getPairCache = function() {
          return k(db(this.Zx), GA)
        }
        ;
        EA.prototype.getDispatchInfo = function() {
          return k(eb(this.Zx), l)
        }
        ;
        EA.prototype.addCollisionObject = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          void 0 === c ? fb(e, a) : void 0 === d ? gb(e, a, c) : hb(e, a, c, d)
        }
        ;
        EA.prototype.removeCollisionObject = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ib(c, a)
        }
        ;
        EA.prototype.getBroadphase = function() {
          return k(jb(this.Zx), HA)
        }
        ;
        EA.prototype.convexSweepTest = function(a, c, d, e, f) {
          var m = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          kb(m, a, c, d, e, f)
        }
        ;
        EA.prototype.contactPairTest = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          lb(e, a, c, d)
        }
        ;
        EA.prototype.contactTest = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          mb(d, a, c)
        }
        ;
        EA.prototype.updateSingleAabb = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ob(c, a)
        }
        ;
        EA.prototype.setDebugDrawer = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          pb(c, a)
        }
        ;
        EA.prototype.getDebugDrawer = function() {
          return k(qb(this.Zx), IA)
        }
        ;
        EA.prototype.debugDrawWorld = function() {
          rb(this.Zx)
        }
        ;
        EA.prototype.debugDrawObject = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          sb(e, a, c, d)
        }
        ;
        EA.prototype.__destroy__ = function() {
          tb(this.Zx)
        }
        ;
        function n() {
          throw "cannot construct a btCollisionShape, no constructor in IDL";
        }
        n.prototype = Object.create(g.prototype);
        n.prototype.constructor = n;
        n.prototype.$x = n;
        n.ay = {};
        b.btCollisionShape = n;
        n.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ub(c, a)
        }
        ;
        n.prototype.getLocalScaling = function() {
          return k(vb(this.Zx), p)
        }
        ;
        n.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          wb(d, a, c)
        }
        ;
        n.prototype.setMargin = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          xb(c, a)
        }
        ;
        n.prototype.getMargin = function() {
          return yb(this.Zx)
        }
        ;
        n.prototype.__destroy__ = function() {
          zb(this.Zx)
        }
        ;
        function q() {
          throw "cannot construct a btCollisionObject, no constructor in IDL";
        }
        q.prototype = Object.create(g.prototype);
        q.prototype.constructor = q;
        q.prototype.$x = q;
        q.ay = {};
        b.btCollisionObject = q;
        q.prototype.setAnisotropicFriction = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Ab(d, a, c)
        }
        ;
        q.prototype.getCollisionShape = function() {
          return k(Bb(this.Zx), n)
        }
        ;
        q.prototype.setContactProcessingThreshold = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Cb(c, a)
        }
        ;
        q.prototype.setActivationState = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Db(c, a)
        }
        ;
        q.prototype.forceActivationState = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Eb(c, a)
        }
        ;
        q.prototype.activate = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          void 0 === a ? Fb(c) : Gb(c, a)
        }
        ;
        q.prototype.isActive = function() {
          return !!Hb(this.Zx)
        }
        ;
        q.prototype.isKinematicObject = function() {
          return !!Ib(this.Zx)
        }
        ;
        q.prototype.isStaticObject = function() {
          return !!Jb(this.Zx)
        }
        ;
        q.prototype.isStaticOrKinematicObject = function() {
          return !!Kb(this.Zx)
        }
        ;
        q.prototype.getRestitution = function() {
          return Lb(this.Zx)
        }
        ;
        q.prototype.getFriction = function() {
          return Mb(this.Zx)
        }
        ;
        q.prototype.getRollingFriction = function() {
          return Nb(this.Zx)
        }
        ;
        q.prototype.setRestitution = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ob(c, a)
        }
        ;
        q.prototype.setFriction = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Pb(c, a)
        }
        ;
        q.prototype.setRollingFriction = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Qb(c, a)
        }
        ;
        q.prototype.getWorldTransform = function() {
          return k(Rb(this.Zx), r)
        }
        ;
        q.prototype.getCollisionFlags = function() {
          return Sb(this.Zx)
        }
        ;
        q.prototype.setCollisionFlags = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Tb(c, a)
        }
        ;
        q.prototype.setWorldTransform = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ub(c, a)
        }
        ;
        q.prototype.setCollisionShape = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Vb(c, a)
        }
        ;
        q.prototype.setCcdMotionThreshold = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Xb(c, a)
        }
        ;
        q.prototype.setCcdSweptSphereRadius = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Yb(c, a)
        }
        ;
        q.prototype.getUserIndex = function() {
          return Zb(this.Zx)
        }
        ;
        q.prototype.setUserIndex = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          $b(c, a)
        }
        ;
        q.prototype.getUserPointer = function() {
          return k(ac(this.Zx), JA)
        }
        ;
        q.prototype.setUserPointer = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          bc(c, a)
        }
        ;
        q.prototype.getBroadphaseHandle = function() {
          return k(cc(this.Zx), t)
        }
        ;
        q.prototype.__destroy__ = function() {
          dc(this.Zx)
        }
        ;
        function u() {
          throw "cannot construct a btDynamicsWorld, no constructor in IDL";
        }
        u.prototype = Object.create(EA.prototype);
        u.prototype.constructor = u;
        u.prototype.$x = u;
        u.ay = {};
        b.btDynamicsWorld = u;
        u.prototype.addAction = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ec(c, a)
        }
        ;
        u.prototype.removeAction = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          fc(c, a)
        }
        ;
        u.prototype.getSolverInfo = function() {
          return k(hc(this.Zx), v)
        }
        ;
        u.prototype.setInternalTickCallback = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          void 0 === c ? ic(e, a) : void 0 === d ? jc(e, a, c) : kc(e, a, c, d)
        }
        ;
        u.prototype.getDispatcher = function() {
          return k(lc(this.Zx), FA)
        }
        ;
        u.prototype.rayTest = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          mc(e, a, c, d)
        }
        ;
        u.prototype.getPairCache = function() {
          return k(nc(this.Zx), GA)
        }
        ;
        u.prototype.getDispatchInfo = function() {
          return k(oc(this.Zx), l)
        }
        ;
        u.prototype.addCollisionObject = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          void 0 === c ? pc(e, a) : void 0 === d ? qc(e, a, c) : rc(e, a, c, d)
        }
        ;
        u.prototype.removeCollisionObject = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          sc(c, a)
        }
        ;
        u.prototype.getBroadphase = function() {
          return k(tc(this.Zx), HA)
        }
        ;
        u.prototype.convexSweepTest = function(a, c, d, e, f) {
          var m = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          uc(m, a, c, d, e, f)
        }
        ;
        u.prototype.contactPairTest = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          vc(e, a, c, d)
        }
        ;
        u.prototype.contactTest = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          wc(d, a, c)
        }
        ;
        u.prototype.updateSingleAabb = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          xc(c, a)
        }
        ;
        u.prototype.setDebugDrawer = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          yc(c, a)
        }
        ;
        u.prototype.getDebugDrawer = function() {
          return k(zc(this.Zx), IA)
        }
        ;
        u.prototype.debugDrawWorld = function() {
          Ac(this.Zx)
        }
        ;
        u.prototype.debugDrawObject = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          Bc(e, a, c, d)
        }
        ;
        u.prototype.__destroy__ = function() {
          Cc(this.Zx)
        }
        ;
        function KA() {
          throw "cannot construct a btTypedConstraint, no constructor in IDL";
        }
        KA.prototype = Object.create(g.prototype);
        KA.prototype.constructor = KA;
        KA.prototype.$x = KA;
        KA.ay = {};
        b.btTypedConstraint = KA;
        KA.prototype.enableFeedback = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Dc(c, a)
        }
        ;
        KA.prototype.getBreakingImpulseThreshold = function() {
          return Ec(this.Zx)
        }
        ;
        KA.prototype.setBreakingImpulseThreshold = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Fc(c, a)
        }
        ;
        KA.prototype.getParam = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          return Gc(d, a, c)
        }
        ;
        KA.prototype.setParam = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          Hc(e, a, c, d)
        }
        ;
        KA.prototype.__destroy__ = function() {
          Ic(this.Zx)
        }
        ;
        function LA() {
          throw "cannot construct a btConcaveShape, no constructor in IDL";
        }
        LA.prototype = Object.create(n.prototype);
        LA.prototype.constructor = LA;
        LA.prototype.$x = LA;
        LA.ay = {};
        b.btConcaveShape = LA;
        LA.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Jc(c, a)
        }
        ;
        LA.prototype.getLocalScaling = function() {
          return k(Kc(this.Zx), p)
        }
        ;
        LA.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Lc(d, a, c)
        }
        ;
        LA.prototype.__destroy__ = function() {
          Mc(this.Zx)
        }
        ;
        function MA(a, c) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          this.Zx = Nc(a, c);
          h(MA)[this.Zx] = this
        }
        MA.prototype = Object.create(n.prototype);
        MA.prototype.constructor = MA;
        MA.prototype.$x = MA;
        MA.ay = {};
        b.btCapsuleShape = MA;
        MA.prototype.setMargin = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Oc(c, a)
        }
        ;
        MA.prototype.getMargin = function() {
          return Pc(this.Zx)
        }
        ;
        MA.prototype.getUpAxis = function() {
          return Qc(this.Zx)
        }
        ;
        MA.prototype.getRadius = function() {
          return Rc(this.Zx)
        }
        ;
        MA.prototype.getHalfHeight = function() {
          return Sc(this.Zx)
        }
        ;
        MA.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Tc(c, a)
        }
        ;
        MA.prototype.getLocalScaling = function() {
          return k(Uc(this.Zx), p)
        }
        ;
        MA.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Vc(d, a, c)
        }
        ;
        MA.prototype.__destroy__ = function() {
          Wc(this.Zx)
        }
        ;
        function IA() {
          throw "cannot construct a btIDebugDraw, no constructor in IDL";
        }
        IA.prototype = Object.create(g.prototype);
        IA.prototype.constructor = IA;
        IA.prototype.$x = IA;
        IA.ay = {};
        b.btIDebugDraw = IA;
        IA.prototype.drawLine = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          Xc(e, a, c, d)
        }
        ;
        IA.prototype.drawContactPoint = function(a, c, d, e, f) {
          var m = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          Yc(m, a, c, d, e, f)
        }
        ;
        IA.prototype.reportErrorWarning = function(a) {
          var c = this.Zx;
          zA();
          a = a && "object" === typeof a ? a.Zx : CA(a);
          Zc(c, a)
        }
        ;
        IA.prototype.draw3dText = function(a, c) {
          var d = this.Zx;
          zA();
          a && "object" === typeof a && (a = a.Zx);
          c = c && "object" === typeof c ? c.Zx : CA(c);
          $c(d, a, c)
        }
        ;
        IA.prototype.setDebugMode = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ad(c, a)
        }
        ;
        IA.prototype.getDebugMode = function() {
          return bd(this.Zx)
        }
        ;
        IA.prototype.__destroy__ = function() {
          cd(this.Zx)
        }
        ;
        function NA(a) {
          a && "object" === typeof a && (a = a.Zx);
          this.Zx = void 0 === a ? dd() : ed(a);
          h(NA)[this.Zx] = this
        }
        NA.prototype = Object.create(g.prototype);
        NA.prototype.constructor = NA;
        NA.prototype.$x = NA;
        NA.ay = {};
        b.btDefaultCollisionConfiguration = NA;
        NA.prototype.__destroy__ = function() {
          fd(this.Zx)
        }
        ;
        function OA() {
          throw "cannot construct a btTriangleMeshShape, no constructor in IDL";
        }
        OA.prototype = Object.create(LA.prototype);
        OA.prototype.constructor = OA;
        OA.prototype.$x = OA;
        OA.ay = {};
        b.btTriangleMeshShape = OA;
        OA.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          gd(c, a)
        }
        ;
        OA.prototype.getLocalScaling = function() {
          return k(hd(this.Zx), p)
        }
        ;
        OA.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          id(d, a, c)
        }
        ;
        OA.prototype.__destroy__ = function() {
          jd(this.Zx)
        }
        ;
        function w() {
          this.Zx = kd();
          h(w)[this.Zx] = this
        }
        w.prototype = Object.create(q.prototype);
        w.prototype.constructor = w;
        w.prototype.$x = w;
        w.ay = {};
        b.btGhostObject = w;
        w.prototype.getNumOverlappingObjects = function() {
          return ld(this.Zx)
        }
        ;
        w.prototype.getOverlappingObject = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(md(c, a), q)
        }
        ;
        w.prototype.setAnisotropicFriction = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          nd(d, a, c)
        }
        ;
        w.prototype.getCollisionShape = function() {
          return k(od(this.Zx), n)
        }
        ;
        w.prototype.setContactProcessingThreshold = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          pd(c, a)
        }
        ;
        w.prototype.setActivationState = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          qd(c, a)
        }
        ;
        w.prototype.forceActivationState = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          rd(c, a)
        }
        ;
        w.prototype.activate = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          void 0 === a ? sd(c) : td(c, a)
        }
        ;
        w.prototype.isActive = function() {
          return !!ud(this.Zx)
        }
        ;
        w.prototype.isKinematicObject = function() {
          return !!vd(this.Zx)
        }
        ;
        w.prototype.isStaticObject = function() {
          return !!wd(this.Zx)
        }
        ;
        w.prototype.isStaticOrKinematicObject = function() {
          return !!xd(this.Zx)
        }
        ;
        w.prototype.getRestitution = function() {
          return yd(this.Zx)
        }
        ;
        w.prototype.getFriction = function() {
          return zd(this.Zx)
        }
        ;
        w.prototype.getRollingFriction = function() {
          return Ad(this.Zx)
        }
        ;
        w.prototype.setRestitution = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Bd(c, a)
        }
        ;
        w.prototype.setFriction = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Cd(c, a)
        }
        ;
        w.prototype.setRollingFriction = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Dd(c, a)
        }
        ;
        w.prototype.getWorldTransform = function() {
          return k(Ed(this.Zx), r)
        }
        ;
        w.prototype.getCollisionFlags = function() {
          return Fd(this.Zx)
        }
        ;
        w.prototype.setCollisionFlags = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Gd(c, a)
        }
        ;
        w.prototype.setWorldTransform = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Hd(c, a)
        }
        ;
        w.prototype.setCollisionShape = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Id(c, a)
        }
        ;
        w.prototype.setCcdMotionThreshold = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Jd(c, a)
        }
        ;
        w.prototype.setCcdSweptSphereRadius = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Kd(c, a)
        }
        ;
        w.prototype.getUserIndex = function() {
          return Ld(this.Zx)
        }
        ;
        w.prototype.setUserIndex = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Md(c, a)
        }
        ;
        w.prototype.getUserPointer = function() {
          return k(Nd(this.Zx), JA)
        }
        ;
        w.prototype.setUserPointer = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Od(c, a)
        }
        ;
        w.prototype.getBroadphaseHandle = function() {
          return k(Pd(this.Zx), t)
        }
        ;
        w.prototype.__destroy__ = function() {
          Qd(this.Zx)
        }
        ;
        function PA(a, c) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          this.Zx = Rd(a, c);
          h(PA)[this.Zx] = this
        }
        PA.prototype = Object.create(n.prototype);
        PA.prototype.constructor = PA;
        PA.prototype.$x = PA;
        PA.ay = {};
        b.btConeShape = PA;
        PA.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Sd(c, a)
        }
        ;
        PA.prototype.getLocalScaling = function() {
          return k(Td(this.Zx), p)
        }
        ;
        PA.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Ud(d, a, c)
        }
        ;
        PA.prototype.__destroy__ = function() {
          Vd(this.Zx)
        }
        ;
        function QA() {
          throw "cannot construct a btActionInterface, no constructor in IDL";
        }
        QA.prototype = Object.create(g.prototype);
        QA.prototype.constructor = QA;
        QA.prototype.$x = QA;
        QA.ay = {};
        b.btActionInterface = QA;
        QA.prototype.updateAction = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Wd(d, a, c)
        }
        ;
        QA.prototype.__destroy__ = function() {
          Xd(this.Zx)
        }
        ;
        function p(a, c, d) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          this.Zx = void 0 === a ? Yd() : void 0 === c ? _emscripten_bind_btVector3_btVector3_1(a) : void 0 === d ? _emscripten_bind_btVector3_btVector3_2(a, c) : Zd(a, c, d);
          h(p)[this.Zx] = this
        }
        p.prototype = Object.create(g.prototype);
        p.prototype.constructor = p;
        p.prototype.$x = p;
        p.ay = {};
        b.btVector3 = p;
        p.prototype.length = p.prototype.length = function() {
          return $d(this.Zx)
        }
        ;
        p.prototype.x = p.prototype.x = function() {
          return ae(this.Zx)
        }
        ;
        p.prototype.y = p.prototype.y = function() {
          return be(this.Zx)
        }
        ;
        p.prototype.z = p.prototype.z = function() {
          return ce(this.Zx)
        }
        ;
        p.prototype.setX = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          de(c, a)
        }
        ;
        p.prototype.setY = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ee(c, a)
        }
        ;
        p.prototype.setZ = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          fe(c, a)
        }
        ;
        p.prototype.setValue = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          ge(e, a, c, d)
        }
        ;
        p.prototype.normalize = p.prototype.normalize = function() {
          he(this.Zx)
        }
        ;
        p.prototype.rotate = p.prototype.rotate = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          return k(ie(d, a, c), p)
        }
        ;
        p.prototype.dot = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return je(c, a)
        }
        ;
        p.prototype.op_mul = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(ke(c, a), p)
        }
        ;
        p.prototype.op_add = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(le(c, a), p)
        }
        ;
        p.prototype.op_sub = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(me(c, a), p)
        }
        ;
        p.prototype.__destroy__ = function() {
          ne(this.Zx)
        }
        ;
        function RA() {
          throw "cannot construct a btVehicleRaycaster, no constructor in IDL";
        }
        RA.prototype = Object.create(g.prototype);
        RA.prototype.constructor = RA;
        RA.prototype.$x = RA;
        RA.ay = {};
        b.btVehicleRaycaster = RA;
        RA.prototype.castRay = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          oe(e, a, c, d)
        }
        ;
        RA.prototype.__destroy__ = function() {
          pe(this.Zx)
        }
        ;
        function SA() {
          throw "cannot construct a btQuadWord, no constructor in IDL";
        }
        SA.prototype = Object.create(g.prototype);
        SA.prototype.constructor = SA;
        SA.prototype.$x = SA;
        SA.ay = {};
        b.btQuadWord = SA;
        SA.prototype.x = SA.prototype.x = function() {
          return qe(this.Zx)
        }
        ;
        SA.prototype.y = SA.prototype.y = function() {
          return re(this.Zx)
        }
        ;
        SA.prototype.z = SA.prototype.z = function() {
          return se(this.Zx)
        }
        ;
        SA.prototype.w = function() {
          return te(this.Zx)
        }
        ;
        SA.prototype.setX = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ue(c, a)
        }
        ;
        SA.prototype.setY = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ve(c, a)
        }
        ;
        SA.prototype.setZ = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          we(c, a)
        }
        ;
        SA.prototype.setW = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          xe(c, a)
        }
        ;
        SA.prototype.__destroy__ = function() {
          ye(this.Zx)
        }
        ;
        function TA(a) {
          a && "object" === typeof a && (a = a.Zx);
          this.Zx = ze(a);
          h(TA)[this.Zx] = this
        }
        TA.prototype = Object.create(n.prototype);
        TA.prototype.constructor = TA;
        TA.prototype.$x = TA;
        TA.ay = {};
        b.btCylinderShape = TA;
        TA.prototype.setMargin = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ae(c, a)
        }
        ;
        TA.prototype.getMargin = function() {
          return Be(this.Zx)
        }
        ;
        TA.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ce(c, a)
        }
        ;
        TA.prototype.getLocalScaling = function() {
          return k(De(this.Zx), p)
        }
        ;
        TA.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Ee(d, a, c)
        }
        ;
        TA.prototype.__destroy__ = function() {
          Fe(this.Zx)
        }
        ;
        function x(a, c, d, e) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          this.Zx = Ge(a, c, d, e);
          h(x)[this.Zx] = this
        }
        x.prototype = Object.create(u.prototype);
        x.prototype.constructor = x;
        x.prototype.$x = x;
        x.ay = {};
        b.btDiscreteDynamicsWorld = x;
        x.prototype.setGravity = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          He(c, a)
        }
        ;
        x.prototype.getGravity = function() {
          return k(Ie(this.Zx), p)
        }
        ;
        x.prototype.addRigidBody = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          void 0 === c ? Je(e, a) : void 0 === d ? _emscripten_bind_btDiscreteDynamicsWorld_addRigidBody_2(e, a, c) : Ke(e, a, c, d)
        }
        ;
        x.prototype.removeRigidBody = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Le(c, a)
        }
        ;
        x.prototype.addConstraint = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          void 0 === c ? Me(d, a) : Ne(d, a, c)
        }
        ;
        x.prototype.removeConstraint = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Oe(c, a)
        }
        ;
        x.prototype.stepSimulation = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          return void 0 === c ? Pe(e, a) : void 0 === d ? Qe(e, a, c) : Re(e, a, c, d)
        }
        ;
        x.prototype.setContactAddedCallback = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Se(c, a)
        }
        ;
        x.prototype.setContactProcessedCallback = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Te(c, a)
        }
        ;
        x.prototype.setContactDestroyedCallback = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ue(c, a)
        }
        ;
        x.prototype.getDispatcher = function() {
          return k(Ve(this.Zx), FA)
        }
        ;
        x.prototype.rayTest = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          We(e, a, c, d)
        }
        ;
        x.prototype.getPairCache = function() {
          return k(Xe(this.Zx), GA)
        }
        ;
        x.prototype.getDispatchInfo = function() {
          return k(Ye(this.Zx), l)
        }
        ;
        x.prototype.addCollisionObject = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          void 0 === c ? Ze(e, a) : void 0 === d ? $e(e, a, c) : af(e, a, c, d)
        }
        ;
        x.prototype.removeCollisionObject = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          bf(c, a)
        }
        ;
        x.prototype.getBroadphase = function() {
          return k(cf(this.Zx), HA)
        }
        ;
        x.prototype.convexSweepTest = function(a, c, d, e, f) {
          var m = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          df(m, a, c, d, e, f)
        }
        ;
        x.prototype.contactPairTest = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          ef(e, a, c, d)
        }
        ;
        x.prototype.contactTest = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          ff(d, a, c)
        }
        ;
        x.prototype.updateSingleAabb = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          gf(c, a)
        }
        ;
        x.prototype.setDebugDrawer = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          hf(c, a)
        }
        ;
        x.prototype.getDebugDrawer = function() {
          return k(jf(this.Zx), IA)
        }
        ;
        x.prototype.debugDrawWorld = function() {
          kf(this.Zx)
        }
        ;
        x.prototype.debugDrawObject = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          lf(e, a, c, d)
        }
        ;
        x.prototype.addAction = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          mf(c, a)
        }
        ;
        x.prototype.removeAction = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          nf(c, a)
        }
        ;
        x.prototype.getSolverInfo = function() {
          return k(of(this.Zx), v)
        }
        ;
        x.prototype.setInternalTickCallback = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          void 0 === c ? pf(e, a) : void 0 === d ? qf(e, a, c) : rf(e, a, c, d)
        }
        ;
        x.prototype.__destroy__ = function() {
          sf(this.Zx)
        }
        ;
        function UA() {
          throw "cannot construct a btConvexShape, no constructor in IDL";
        }
        UA.prototype = Object.create(n.prototype);
        UA.prototype.constructor = UA;
        UA.prototype.$x = UA;
        UA.ay = {};
        b.btConvexShape = UA;
        UA.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          tf(c, a)
        }
        ;
        UA.prototype.getLocalScaling = function() {
          return k(uf(this.Zx), p)
        }
        ;
        UA.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          vf(d, a, c)
        }
        ;
        UA.prototype.setMargin = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          wf(c, a)
        }
        ;
        UA.prototype.getMargin = function() {
          return xf(this.Zx)
        }
        ;
        UA.prototype.__destroy__ = function() {
          yf(this.Zx)
        }
        ;
        function FA() {
          throw "cannot construct a btDispatcher, no constructor in IDL";
        }
        FA.prototype = Object.create(g.prototype);
        FA.prototype.constructor = FA;
        FA.prototype.$x = FA;
        FA.ay = {};
        b.btDispatcher = FA;
        FA.prototype.getNumManifolds = function() {
          return zf(this.Zx)
        }
        ;
        FA.prototype.getManifoldByIndexInternal = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(Af(c, a), VA)
        }
        ;
        FA.prototype.__destroy__ = function() {
          Bf(this.Zx)
        }
        ;
        function WA(a, c, d, e, f) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          this.Zx = void 0 === e ? Cf(a, c, d) : void 0 === f ? _emscripten_bind_btGeneric6DofConstraint_btGeneric6DofConstraint_4(a, c, d, e) : Df(a, c, d, e, f);
          h(WA)[this.Zx] = this
        }
        WA.prototype = Object.create(KA.prototype);
        WA.prototype.constructor = WA;
        WA.prototype.$x = WA;
        WA.ay = {};
        b.btGeneric6DofConstraint = WA;
        WA.prototype.setLinearLowerLimit = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ef(c, a)
        }
        ;
        WA.prototype.setLinearUpperLimit = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ff(c, a)
        }
        ;
        WA.prototype.setAngularLowerLimit = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Gf(c, a)
        }
        ;
        WA.prototype.setAngularUpperLimit = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Hf(c, a)
        }
        ;
        WA.prototype.getFrameOffsetA = function() {
          return k(If(this.Zx), r)
        }
        ;
        WA.prototype.enableFeedback = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Jf(c, a)
        }
        ;
        WA.prototype.getBreakingImpulseThreshold = function() {
          return Kf(this.Zx)
        }
        ;
        WA.prototype.setBreakingImpulseThreshold = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Lf(c, a)
        }
        ;
        WA.prototype.getParam = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          return Mf(d, a, c)
        }
        ;
        WA.prototype.setParam = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          Nf(e, a, c, d)
        }
        ;
        WA.prototype.__destroy__ = function() {
          Of(this.Zx)
        }
        ;
        function XA() {
          throw "cannot construct a btStridingMeshInterface, no constructor in IDL";
        }
        XA.prototype = Object.create(g.prototype);
        XA.prototype.constructor = XA;
        XA.prototype.$x = XA;
        XA.ay = {};
        b.btStridingMeshInterface = XA;
        XA.prototype.setScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Pf(c, a)
        }
        ;
        XA.prototype.__destroy__ = function() {
          Qf(this.Zx)
        }
        ;
        function YA() {
          throw "cannot construct a btMotionState, no constructor in IDL";
        }
        YA.prototype = Object.create(g.prototype);
        YA.prototype.constructor = YA;
        YA.prototype.$x = YA;
        YA.ay = {};
        b.btMotionState = YA;
        YA.prototype.getWorldTransform = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Rf(c, a)
        }
        ;
        YA.prototype.setWorldTransform = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Sf(c, a)
        }
        ;
        YA.prototype.__destroy__ = function() {
          Tf(this.Zx)
        }
        ;
        function y() {
          throw "cannot construct a ConvexResultCallback, no constructor in IDL";
        }
        y.prototype = Object.create(g.prototype);
        y.prototype.constructor = y;
        y.prototype.$x = y;
        y.ay = {};
        b.ConvexResultCallback = y;
        y.prototype.hasHit = function() {
          return !!Uf(this.Zx)
        }
        ;
        y.prototype.get_m_collisionFilterGroup = y.prototype.by = function() {
          return Vf(this.Zx)
        }
        ;
        y.prototype.set_m_collisionFilterGroup = y.prototype.dy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Wf(c, a)
        }
        ;
        Object.defineProperty(y.prototype, "m_collisionFilterGroup", {
          get: y.prototype.by,
          set: y.prototype.dy
        });
        y.prototype.get_m_collisionFilterMask = y.prototype.cy = function() {
          return Xf(this.Zx)
        }
        ;
        y.prototype.set_m_collisionFilterMask = y.prototype.ey = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Yf(c, a)
        }
        ;
        Object.defineProperty(y.prototype, "m_collisionFilterMask", {
          get: y.prototype.cy,
          set: y.prototype.ey
        });
        y.prototype.get_m_closestHitFraction = y.prototype.fy = function() {
          return Zf(this.Zx)
        }
        ;
        y.prototype.set_m_closestHitFraction = y.prototype.gy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          $f(c, a)
        }
        ;
        Object.defineProperty(y.prototype, "m_closestHitFraction", {
          get: y.prototype.fy,
          set: y.prototype.gy
        });
        y.prototype.__destroy__ = function() {
          ag(this.Zx)
        }
        ;
        function ZA() {
          throw "cannot construct a ContactResultCallback, no constructor in IDL";
        }
        ZA.prototype = Object.create(g.prototype);
        ZA.prototype.constructor = ZA;
        ZA.prototype.$x = ZA;
        ZA.ay = {};
        b.ContactResultCallback = ZA;
        ZA.prototype.addSingleResult = function(a, c, d, e, f, m, C) {
          var P = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          m && "object" === typeof m && (m = m.Zx);
          C && "object" === typeof C && (C = C.Zx);
          return bg(P, a, c, d, e, f, m, C)
        }
        ;
        ZA.prototype.__destroy__ = function() {
          cg(this.Zx)
        }
        ;
        function $A() {
          throw "cannot construct a btSoftBodySolver, no constructor in IDL";
        }
        $A.prototype = Object.create(g.prototype);
        $A.prototype.constructor = $A;
        $A.prototype.$x = $A;
        $A.ay = {};
        b.btSoftBodySolver = $A;
        $A.prototype.__destroy__ = function() {
          dg(this.Zx)
        }
        ;
        function z() {
          throw "cannot construct a RayResultCallback, no constructor in IDL";
        }
        z.prototype = Object.create(g.prototype);
        z.prototype.constructor = z;
        z.prototype.$x = z;
        z.ay = {};
        b.RayResultCallback = z;
        z.prototype.hasHit = function() {
          return !!eg(this.Zx)
        }
        ;
        z.prototype.get_m_collisionFilterGroup = z.prototype.by = function() {
          return fg(this.Zx)
        }
        ;
        z.prototype.set_m_collisionFilterGroup = z.prototype.dy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          gg(c, a)
        }
        ;
        Object.defineProperty(z.prototype, "m_collisionFilterGroup", {
          get: z.prototype.by,
          set: z.prototype.dy
        });
        z.prototype.get_m_collisionFilterMask = z.prototype.cy = function() {
          return hg(this.Zx)
        }
        ;
        z.prototype.set_m_collisionFilterMask = z.prototype.ey = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ig(c, a)
        }
        ;
        Object.defineProperty(z.prototype, "m_collisionFilterMask", {
          get: z.prototype.cy,
          set: z.prototype.ey
        });
        z.prototype.get_m_closestHitFraction = z.prototype.fy = function() {
          return jg(this.Zx)
        }
        ;
        z.prototype.set_m_closestHitFraction = z.prototype.gy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          kg(c, a)
        }
        ;
        Object.defineProperty(z.prototype, "m_closestHitFraction", {
          get: z.prototype.fy,
          set: z.prototype.gy
        });
        z.prototype.get_m_collisionObject = z.prototype.hy = function() {
          return k(lg(this.Zx), q)
        }
        ;
        z.prototype.set_m_collisionObject = z.prototype.oy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          mg(c, a)
        }
        ;
        Object.defineProperty(z.prototype, "m_collisionObject", {
          get: z.prototype.hy,
          set: z.prototype.oy
        });
        z.prototype.__destroy__ = function() {
          ng(this.Zx)
        }
        ;
        function aB() {
          throw "cannot construct a btMatrix3x3, no constructor in IDL";
        }
        aB.prototype = Object.create(g.prototype);
        aB.prototype.constructor = aB;
        aB.prototype.$x = aB;
        aB.ay = {};
        b.btMatrix3x3 = aB;
        aB.prototype.setEulerZYX = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          og(e, a, c, d)
        }
        ;
        aB.prototype.getRotation = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          pg(c, a)
        }
        ;
        aB.prototype.getRow = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(qg(c, a), p)
        }
        ;
        aB.prototype.__destroy__ = function() {
          rg(this.Zx)
        }
        ;
        function bB() {
          throw "cannot construct a btScalarArray, no constructor in IDL";
        }
        bB.prototype = Object.create(g.prototype);
        bB.prototype.constructor = bB;
        bB.prototype.$x = bB;
        bB.ay = {};
        b.btScalarArray = bB;
        bB.prototype.size = bB.prototype.size = function() {
          return sg(this.Zx)
        }
        ;
        bB.prototype.at = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return tg(c, a)
        }
        ;
        bB.prototype.__destroy__ = function() {
          ug(this.Zx)
        }
        ;
        function A() {
          throw "cannot construct a Material, no constructor in IDL";
        }
        A.prototype = Object.create(g.prototype);
        A.prototype.constructor = A;
        A.prototype.$x = A;
        A.ay = {};
        b.Material = A;
        A.prototype.get_m_kLST = A.prototype.jA = function() {
          return vg(this.Zx)
        }
        ;
        A.prototype.set_m_kLST = A.prototype.QC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          wg(c, a)
        }
        ;
        Object.defineProperty(A.prototype, "m_kLST", {
          get: A.prototype.jA,
          set: A.prototype.QC
        });
        A.prototype.get_m_kAST = A.prototype.iA = function() {
          return xg(this.Zx)
        }
        ;
        A.prototype.set_m_kAST = A.prototype.PC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          yg(c, a)
        }
        ;
        Object.defineProperty(A.prototype, "m_kAST", {
          get: A.prototype.iA,
          set: A.prototype.PC
        });
        A.prototype.get_m_kVST = A.prototype.kA = function() {
          return zg(this.Zx)
        }
        ;
        A.prototype.set_m_kVST = A.prototype.RC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ag(c, a)
        }
        ;
        Object.defineProperty(A.prototype, "m_kVST", {
          get: A.prototype.kA,
          set: A.prototype.RC
        });
        A.prototype.get_m_flags = A.prototype.Rz = function() {
          return Bg(this.Zx)
        }
        ;
        A.prototype.set_m_flags = A.prototype.xC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Cg(c, a)
        }
        ;
        Object.defineProperty(A.prototype, "m_flags", {
          get: A.prototype.Rz,
          set: A.prototype.xC
        });
        A.prototype.__destroy__ = function() {
          Dg(this.Zx)
        }
        ;
        function l() {
          throw "cannot construct a btDispatcherInfo, no constructor in IDL";
        }
        l.prototype = Object.create(g.prototype);
        l.prototype.constructor = l;
        l.prototype.$x = l;
        l.ay = {};
        b.btDispatcherInfo = l;
        l.prototype.get_m_timeStep = l.prototype.XA = function() {
          return Eg(this.Zx)
        }
        ;
        l.prototype.set_m_timeStep = l.prototype.DD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Fg(c, a)
        }
        ;
        Object.defineProperty(l.prototype, "m_timeStep", {
          get: l.prototype.XA,
          set: l.prototype.DD
        });
        l.prototype.get_m_stepCount = l.prototype.OA = function() {
          return Gg(this.Zx)
        }
        ;
        l.prototype.set_m_stepCount = l.prototype.uD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Hg(c, a)
        }
        ;
        Object.defineProperty(l.prototype, "m_stepCount", {
          get: l.prototype.OA,
          set: l.prototype.uD
        });
        l.prototype.get_m_dispatchFunc = l.prototype.Jz = function() {
          return Ig(this.Zx)
        }
        ;
        l.prototype.set_m_dispatchFunc = l.prototype.pC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Jg(c, a)
        }
        ;
        Object.defineProperty(l.prototype, "m_dispatchFunc", {
          get: l.prototype.Jz,
          set: l.prototype.pC
        });
        l.prototype.get_m_timeOfImpact = l.prototype.WA = function() {
          return Kg(this.Zx)
        }
        ;
        l.prototype.set_m_timeOfImpact = l.prototype.CD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Lg(c, a)
        }
        ;
        Object.defineProperty(l.prototype, "m_timeOfImpact", {
          get: l.prototype.WA,
          set: l.prototype.CD
        });
        l.prototype.get_m_useContinuous = l.prototype.ZA = function() {
          return !!Mg(this.Zx)
        }
        ;
        l.prototype.set_m_useContinuous = l.prototype.FD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ng(c, a)
        }
        ;
        Object.defineProperty(l.prototype, "m_useContinuous", {
          get: l.prototype.ZA,
          set: l.prototype.FD
        });
        l.prototype.get_m_enableSatConvex = l.prototype.Nz = function() {
          return !!Og(this.Zx)
        }
        ;
        l.prototype.set_m_enableSatConvex = l.prototype.tC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Pg(c, a)
        }
        ;
        Object.defineProperty(l.prototype, "m_enableSatConvex", {
          get: l.prototype.Nz,
          set: l.prototype.tC
        });
        l.prototype.get_m_enableSPU = l.prototype.Mz = function() {
          return !!Qg(this.Zx)
        }
        ;
        l.prototype.set_m_enableSPU = l.prototype.sC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Rg(c, a)
        }
        ;
        Object.defineProperty(l.prototype, "m_enableSPU", {
          get: l.prototype.Mz,
          set: l.prototype.sC
        });
        l.prototype.get_m_useEpa = l.prototype.aB = function() {
          return !!Sg(this.Zx)
        }
        ;
        l.prototype.set_m_useEpa = l.prototype.HD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Tg(c, a)
        }
        ;
        Object.defineProperty(l.prototype, "m_useEpa", {
          get: l.prototype.aB,
          set: l.prototype.HD
        });
        l.prototype.get_m_allowedCcdPenetration = l.prototype.lz = function() {
          return Ug(this.Zx)
        }
        ;
        l.prototype.set_m_allowedCcdPenetration = l.prototype.TB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Vg(c, a)
        }
        ;
        Object.defineProperty(l.prototype, "m_allowedCcdPenetration", {
          get: l.prototype.lz,
          set: l.prototype.TB
        });
        l.prototype.get_m_useConvexConservativeDistanceUtil = l.prototype.$A = function() {
          return !!Wg(this.Zx)
        }
        ;
        l.prototype.set_m_useConvexConservativeDistanceUtil = l.prototype.GD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Xg(c, a)
        }
        ;
        Object.defineProperty(l.prototype, "m_useConvexConservativeDistanceUtil", {
          get: l.prototype.$A,
          set: l.prototype.GD
        });
        l.prototype.get_m_convexConservativeDistanceThreshold = l.prototype.Ez = function() {
          return Yg(this.Zx)
        }
        ;
        l.prototype.set_m_convexConservativeDistanceThreshold = l.prototype.kC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Zg(c, a)
        }
        ;
        Object.defineProperty(l.prototype, "m_convexConservativeDistanceThreshold", {
          get: l.prototype.Ez,
          set: l.prototype.kC
        });
        l.prototype.__destroy__ = function() {
          $g(this.Zx)
        }
        ;
        function B() {
          throw "cannot construct a btWheelInfoConstructionInfo, no constructor in IDL";
        }
        B.prototype = Object.create(g.prototype);
        B.prototype.constructor = B;
        B.prototype.$x = B;
        B.ay = {};
        b.btWheelInfoConstructionInfo = B;
        B.prototype.get_m_chassisConnectionCS = B.prototype.yz = function() {
          return k(ah(this.Zx), p)
        }
        ;
        B.prototype.set_m_chassisConnectionCS = B.prototype.eC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          bh(c, a)
        }
        ;
        Object.defineProperty(B.prototype, "m_chassisConnectionCS", {
          get: B.prototype.yz,
          set: B.prototype.eC
        });
        B.prototype.get_m_wheelDirectionCS = B.prototype.Ay = function() {
          return k(ch(this.Zx), p)
        }
        ;
        B.prototype.set_m_wheelDirectionCS = B.prototype.Hy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          dh(c, a)
        }
        ;
        Object.defineProperty(B.prototype, "m_wheelDirectionCS", {
          get: B.prototype.Ay,
          set: B.prototype.Hy
        });
        B.prototype.get_m_wheelAxleCS = B.prototype.zy = function() {
          return k(eh(this.Zx), p)
        }
        ;
        B.prototype.set_m_wheelAxleCS = B.prototype.Gy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          fh(c, a)
        }
        ;
        Object.defineProperty(B.prototype, "m_wheelAxleCS", {
          get: B.prototype.zy,
          set: B.prototype.Gy
        });
        B.prototype.get_m_suspensionRestLength = B.prototype.TA = function() {
          return gh(this.Zx)
        }
        ;
        B.prototype.set_m_suspensionRestLength = B.prototype.zD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          hh(c, a)
        }
        ;
        Object.defineProperty(B.prototype, "m_suspensionRestLength", {
          get: B.prototype.TA,
          set: B.prototype.zD
        });
        B.prototype.get_m_maxSuspensionTravelCm = B.prototype.my = function() {
          return ih(this.Zx)
        }
        ;
        B.prototype.set_m_maxSuspensionTravelCm = B.prototype.ty = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          jh(c, a)
        }
        ;
        Object.defineProperty(B.prototype, "m_maxSuspensionTravelCm", {
          get: B.prototype.my,
          set: B.prototype.ty
        });
        B.prototype.get_m_wheelRadius = B.prototype.gB = function() {
          return kh(this.Zx)
        }
        ;
        B.prototype.set_m_wheelRadius = B.prototype.ND = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          lh(c, a)
        }
        ;
        Object.defineProperty(B.prototype, "m_wheelRadius", {
          get: B.prototype.gB,
          set: B.prototype.ND
        });
        B.prototype.get_m_suspensionStiffness = B.prototype.ny = function() {
          return mh(this.Zx)
        }
        ;
        B.prototype.set_m_suspensionStiffness = B.prototype.uy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          nh(c, a)
        }
        ;
        Object.defineProperty(B.prototype, "m_suspensionStiffness", {
          get: B.prototype.ny,
          set: B.prototype.uy
        });
        B.prototype.get_m_wheelsDampingCompression = B.prototype.By = function() {
          return oh(this.Zx)
        }
        ;
        B.prototype.set_m_wheelsDampingCompression = B.prototype.Iy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ph(c, a)
        }
        ;
        Object.defineProperty(B.prototype, "m_wheelsDampingCompression", {
          get: B.prototype.By,
          set: B.prototype.Iy
        });
        B.prototype.get_m_wheelsDampingRelaxation = B.prototype.Cy = function() {
          return qh(this.Zx)
        }
        ;
        B.prototype.set_m_wheelsDampingRelaxation = B.prototype.Jy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          rh(c, a)
        }
        ;
        Object.defineProperty(B.prototype, "m_wheelsDampingRelaxation", {
          get: B.prototype.Cy,
          set: B.prototype.Jy
        });
        B.prototype.get_m_frictionSlip = B.prototype.iy = function() {
          return sh(this.Zx)
        }
        ;
        B.prototype.set_m_frictionSlip = B.prototype.py = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          th(c, a)
        }
        ;
        Object.defineProperty(B.prototype, "m_frictionSlip", {
          get: B.prototype.iy,
          set: B.prototype.py
        });
        B.prototype.get_m_maxSuspensionForce = B.prototype.ly = function() {
          return uh(this.Zx)
        }
        ;
        B.prototype.set_m_maxSuspensionForce = B.prototype.sy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          vh(c, a)
        }
        ;
        Object.defineProperty(B.prototype, "m_maxSuspensionForce", {
          get: B.prototype.ly,
          set: B.prototype.sy
        });
        B.prototype.get_m_bIsFrontWheel = B.prototype.wy = function() {
          return !!wh(this.Zx)
        }
        ;
        B.prototype.set_m_bIsFrontWheel = B.prototype.Dy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          xh(c, a)
        }
        ;
        Object.defineProperty(B.prototype, "m_bIsFrontWheel", {
          get: B.prototype.wy,
          set: B.prototype.Dy
        });
        B.prototype.__destroy__ = function() {
          yh(this.Zx)
        }
        ;
        function cB(a, c) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          this.Zx = void 0 === c ? zh(a) : Ah(a, c);
          h(cB)[this.Zx] = this
        }
        cB.prototype = Object.create(UA.prototype);
        cB.prototype.constructor = cB;
        cB.prototype.$x = cB;
        cB.ay = {};
        b.btConvexTriangleMeshShape = cB;
        cB.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Bh(c, a)
        }
        ;
        cB.prototype.getLocalScaling = function() {
          return k(Ch(this.Zx), p)
        }
        ;
        cB.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Dh(d, a, c)
        }
        ;
        cB.prototype.setMargin = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Eh(c, a)
        }
        ;
        cB.prototype.getMargin = function() {
          return Fh(this.Zx)
        }
        ;
        cB.prototype.__destroy__ = function() {
          Gh(this.Zx)
        }
        ;
        function HA() {
          throw "cannot construct a btBroadphaseInterface, no constructor in IDL";
        }
        HA.prototype = Object.create(g.prototype);
        HA.prototype.constructor = HA;
        HA.prototype.$x = HA;
        HA.ay = {};
        b.btBroadphaseInterface = HA;
        HA.prototype.getOverlappingPairCache = function() {
          return k(Hh(this.Zx), GA)
        }
        ;
        HA.prototype.__destroy__ = function() {
          Ih(this.Zx)
        }
        ;
        function D(a, c, d, e) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          this.Zx = void 0 === e ? Jh(a, c, d) : Kh(a, c, d, e);
          h(D)[this.Zx] = this
        }
        D.prototype = Object.create(g.prototype);
        D.prototype.constructor = D;
        D.prototype.$x = D;
        D.ay = {};
        b.btRigidBodyConstructionInfo = D;
        D.prototype.get_m_linearDamping = D.prototype.lA = function() {
          return Lh(this.Zx)
        }
        ;
        D.prototype.set_m_linearDamping = D.prototype.SC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Mh(c, a)
        }
        ;
        Object.defineProperty(D.prototype, "m_linearDamping", {
          get: D.prototype.lA,
          set: D.prototype.SC
        });
        D.prototype.get_m_angularDamping = D.prototype.nz = function() {
          return Nh(this.Zx)
        }
        ;
        D.prototype.set_m_angularDamping = D.prototype.VB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Oh(c, a)
        }
        ;
        Object.defineProperty(D.prototype, "m_angularDamping", {
          get: D.prototype.nz,
          set: D.prototype.VB
        });
        D.prototype.get_m_friction = D.prototype.Sz = function() {
          return Ph(this.Zx)
        }
        ;
        D.prototype.set_m_friction = D.prototype.yC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Qh(c, a)
        }
        ;
        Object.defineProperty(D.prototype, "m_friction", {
          get: D.prototype.Sz,
          set: D.prototype.yC
        });
        D.prototype.get_m_rollingFriction = D.prototype.GA = function() {
          return Rh(this.Zx)
        }
        ;
        D.prototype.set_m_rollingFriction = D.prototype.mD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Sh(c, a)
        }
        ;
        Object.defineProperty(D.prototype, "m_rollingFriction", {
          get: D.prototype.GA,
          set: D.prototype.mD
        });
        D.prototype.get_m_restitution = D.prototype.EA = function() {
          return Th(this.Zx)
        }
        ;
        D.prototype.set_m_restitution = D.prototype.kD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Uh(c, a)
        }
        ;
        Object.defineProperty(D.prototype, "m_restitution", {
          get: D.prototype.EA,
          set: D.prototype.kD
        });
        D.prototype.get_m_linearSleepingThreshold = D.prototype.mA = function() {
          return Vh(this.Zx)
        }
        ;
        D.prototype.set_m_linearSleepingThreshold = D.prototype.TC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Wh(c, a)
        }
        ;
        Object.defineProperty(D.prototype, "m_linearSleepingThreshold", {
          get: D.prototype.mA,
          set: D.prototype.TC
        });
        D.prototype.get_m_angularSleepingThreshold = D.prototype.oz = function() {
          return Xh(this.Zx)
        }
        ;
        D.prototype.set_m_angularSleepingThreshold = D.prototype.WB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Yh(c, a)
        }
        ;
        Object.defineProperty(D.prototype, "m_angularSleepingThreshold", {
          get: D.prototype.oz,
          set: D.prototype.WB
        });
        D.prototype.get_m_additionalDamping = D.prototype.iz = function() {
          return !!Zh(this.Zx)
        }
        ;
        D.prototype.set_m_additionalDamping = D.prototype.QB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          $h(c, a)
        }
        ;
        Object.defineProperty(D.prototype, "m_additionalDamping", {
          get: D.prototype.iz,
          set: D.prototype.QB
        });
        D.prototype.get_m_additionalDampingFactor = D.prototype.jz = function() {
          return ai(this.Zx)
        }
        ;
        D.prototype.set_m_additionalDampingFactor = D.prototype.RB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          bi(c, a)
        }
        ;
        Object.defineProperty(D.prototype, "m_additionalDampingFactor", {
          get: D.prototype.jz,
          set: D.prototype.RB
        });
        D.prototype.get_m_additionalLinearDampingThresholdSqr = D.prototype.kz = function() {
          return ci(this.Zx)
        }
        ;
        D.prototype.set_m_additionalLinearDampingThresholdSqr = D.prototype.SB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          di(c, a)
        }
        ;
        Object.defineProperty(D.prototype, "m_additionalLinearDampingThresholdSqr", {
          get: D.prototype.kz,
          set: D.prototype.SB
        });
        D.prototype.get_m_additionalAngularDampingThresholdSqr = D.prototype.hz = function() {
          return ei(this.Zx)
        }
        ;
        D.prototype.set_m_additionalAngularDampingThresholdSqr = D.prototype.PB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          fi(c, a)
        }
        ;
        Object.defineProperty(D.prototype, "m_additionalAngularDampingThresholdSqr", {
          get: D.prototype.hz,
          set: D.prototype.PB
        });
        D.prototype.get_m_additionalAngularDampingFactor = D.prototype.gz = function() {
          return gi(this.Zx)
        }
        ;
        D.prototype.set_m_additionalAngularDampingFactor = D.prototype.OB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          hi(c, a)
        }
        ;
        Object.defineProperty(D.prototype, "m_additionalAngularDampingFactor", {
          get: D.prototype.gz,
          set: D.prototype.OB
        });
        D.prototype.__destroy__ = function() {
          ii(this.Zx)
        }
        ;
        function dB() {
          throw "cannot construct a btCollisionConfiguration, no constructor in IDL";
        }
        dB.prototype = Object.create(g.prototype);
        dB.prototype.constructor = dB;
        dB.prototype.$x = dB;
        dB.ay = {};
        b.btCollisionConfiguration = dB;
        dB.prototype.__destroy__ = function() {
          ji(this.Zx)
        }
        ;
        function VA() {
          this.Zx = ki();
          h(VA)[this.Zx] = this
        }
        VA.prototype = Object.create(g.prototype);
        VA.prototype.constructor = VA;
        VA.prototype.$x = VA;
        VA.ay = {};
        b.btPersistentManifold = VA;
        VA.prototype.getBody0 = function() {
          return k(li(this.Zx), q)
        }
        ;
        VA.prototype.getBody1 = function() {
          return k(mi(this.Zx), q)
        }
        ;
        VA.prototype.getNumContacts = function() {
          return ni(this.Zx)
        }
        ;
        VA.prototype.getContactPoint = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(oi(c, a), E)
        }
        ;
        VA.prototype.__destroy__ = function() {
          pi(this.Zx)
        }
        ;
        function eB(a) {
          a && "object" === typeof a && (a = a.Zx);
          this.Zx = void 0 === a ? qi() : ri(a);
          h(eB)[this.Zx] = this
        }
        eB.prototype = Object.create(n.prototype);
        eB.prototype.constructor = eB;
        eB.prototype.$x = eB;
        eB.ay = {};
        b.btCompoundShape = eB;
        eB.prototype.addChildShape = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          si(d, a, c)
        }
        ;
        eB.prototype.removeChildShape = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ti(c, a)
        }
        ;
        eB.prototype.removeChildShapeByIndex = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ui(c, a)
        }
        ;
        eB.prototype.getNumChildShapes = function() {
          return vi(this.Zx)
        }
        ;
        eB.prototype.getChildShape = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(wi(c, a), n)
        }
        ;
        eB.prototype.updateChildTransform = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          void 0 === d ? xi(e, a, c) : yi(e, a, c, d)
        }
        ;
        eB.prototype.setMargin = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          zi(c, a)
        }
        ;
        eB.prototype.getMargin = function() {
          return Ai(this.Zx)
        }
        ;
        eB.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Bi(c, a)
        }
        ;
        eB.prototype.getLocalScaling = function() {
          return k(Ci(this.Zx), p)
        }
        ;
        eB.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Di(d, a, c)
        }
        ;
        eB.prototype.__destroy__ = function() {
          Ei(this.Zx)
        }
        ;
        function F(a, c) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          this.Zx = Fi(a, c);
          h(F)[this.Zx] = this
        }
        F.prototype = Object.create(y.prototype);
        F.prototype.constructor = F;
        F.prototype.$x = F;
        F.ay = {};
        b.ClosestConvexResultCallback = F;
        F.prototype.hasHit = function() {
          return !!Gi(this.Zx)
        }
        ;
        F.prototype.get_m_convexFromWorld = F.prototype.Fz = function() {
          return k(Hi(this.Zx), p)
        }
        ;
        F.prototype.set_m_convexFromWorld = F.prototype.lC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ii(c, a)
        }
        ;
        Object.defineProperty(F.prototype, "m_convexFromWorld", {
          get: F.prototype.Fz,
          set: F.prototype.lC
        });
        F.prototype.get_m_convexToWorld = F.prototype.Gz = function() {
          return k(Ji(this.Zx), p)
        }
        ;
        F.prototype.set_m_convexToWorld = F.prototype.mC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ki(c, a)
        }
        ;
        Object.defineProperty(F.prototype, "m_convexToWorld", {
          get: F.prototype.Gz,
          set: F.prototype.mC
        });
        F.prototype.get_m_hitNormalWorld = F.prototype.jy = function() {
          return k(Li(this.Zx), p)
        }
        ;
        F.prototype.set_m_hitNormalWorld = F.prototype.qy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Mi(c, a)
        }
        ;
        Object.defineProperty(F.prototype, "m_hitNormalWorld", {
          get: F.prototype.jy,
          set: F.prototype.qy
        });
        F.prototype.get_m_hitPointWorld = F.prototype.ky = function() {
          return k(Ni(this.Zx), p)
        }
        ;
        F.prototype.set_m_hitPointWorld = F.prototype.ry = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Oi(c, a)
        }
        ;
        Object.defineProperty(F.prototype, "m_hitPointWorld", {
          get: F.prototype.ky,
          set: F.prototype.ry
        });
        F.prototype.get_m_collisionFilterGroup = F.prototype.by = function() {
          return Pi(this.Zx)
        }
        ;
        F.prototype.set_m_collisionFilterGroup = F.prototype.dy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Qi(c, a)
        }
        ;
        Object.defineProperty(F.prototype, "m_collisionFilterGroup", {
          get: F.prototype.by,
          set: F.prototype.dy
        });
        F.prototype.get_m_collisionFilterMask = F.prototype.cy = function() {
          return Ri(this.Zx)
        }
        ;
        F.prototype.set_m_collisionFilterMask = F.prototype.ey = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Si(c, a)
        }
        ;
        Object.defineProperty(F.prototype, "m_collisionFilterMask", {
          get: F.prototype.cy,
          set: F.prototype.ey
        });
        F.prototype.get_m_closestHitFraction = F.prototype.fy = function() {
          return Ti(this.Zx)
        }
        ;
        F.prototype.set_m_closestHitFraction = F.prototype.gy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ui(c, a)
        }
        ;
        Object.defineProperty(F.prototype, "m_closestHitFraction", {
          get: F.prototype.fy,
          set: F.prototype.gy
        });
        F.prototype.__destroy__ = function() {
          Vi(this.Zx)
        }
        ;
        function G(a, c) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          this.Zx = Wi(a, c);
          h(G)[this.Zx] = this
        }
        G.prototype = Object.create(z.prototype);
        G.prototype.constructor = G;
        G.prototype.$x = G;
        G.ay = {};
        b.AllHitsRayResultCallback = G;
        G.prototype.hasHit = function() {
          return !!Xi(this.Zx)
        }
        ;
        G.prototype.get_m_collisionObjects = G.prototype.Bz = function() {
          return k(Yi(this.Zx), fB)
        }
        ;
        G.prototype.set_m_collisionObjects = G.prototype.hC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Zi(c, a)
        }
        ;
        Object.defineProperty(G.prototype, "m_collisionObjects", {
          get: G.prototype.Bz,
          set: G.prototype.hC
        });
        G.prototype.get_m_rayFromWorld = G.prototype.xy = function() {
          return k($i(this.Zx), p)
        }
        ;
        G.prototype.set_m_rayFromWorld = G.prototype.Ey = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          aj(c, a)
        }
        ;
        Object.defineProperty(G.prototype, "m_rayFromWorld", {
          get: G.prototype.xy,
          set: G.prototype.Ey
        });
        G.prototype.get_m_rayToWorld = G.prototype.yy = function() {
          return k(bj(this.Zx), p)
        }
        ;
        G.prototype.set_m_rayToWorld = G.prototype.Fy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          cj(c, a)
        }
        ;
        Object.defineProperty(G.prototype, "m_rayToWorld", {
          get: G.prototype.yy,
          set: G.prototype.Fy
        });
        G.prototype.get_m_hitNormalWorld = G.prototype.jy = function() {
          return k(dj(this.Zx), gB)
        }
        ;
        G.prototype.set_m_hitNormalWorld = G.prototype.qy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ej(c, a)
        }
        ;
        Object.defineProperty(G.prototype, "m_hitNormalWorld", {
          get: G.prototype.jy,
          set: G.prototype.qy
        });
        G.prototype.get_m_hitPointWorld = G.prototype.ky = function() {
          return k(fj(this.Zx), gB)
        }
        ;
        G.prototype.set_m_hitPointWorld = G.prototype.ry = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          gj(c, a)
        }
        ;
        Object.defineProperty(G.prototype, "m_hitPointWorld", {
          get: G.prototype.ky,
          set: G.prototype.ry
        });
        G.prototype.get_m_hitFractions = G.prototype.Zz = function() {
          return k(hj(this.Zx), bB)
        }
        ;
        G.prototype.set_m_hitFractions = G.prototype.FC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ij(c, a)
        }
        ;
        Object.defineProperty(G.prototype, "m_hitFractions", {
          get: G.prototype.Zz,
          set: G.prototype.FC
        });
        G.prototype.get_m_collisionFilterGroup = G.prototype.by = function() {
          return jj(this.Zx)
        }
        ;
        G.prototype.set_m_collisionFilterGroup = G.prototype.dy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          kj(c, a)
        }
        ;
        Object.defineProperty(G.prototype, "m_collisionFilterGroup", {
          get: G.prototype.by,
          set: G.prototype.dy
        });
        G.prototype.get_m_collisionFilterMask = G.prototype.cy = function() {
          return lj(this.Zx)
        }
        ;
        G.prototype.set_m_collisionFilterMask = G.prototype.ey = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          mj(c, a)
        }
        ;
        Object.defineProperty(G.prototype, "m_collisionFilterMask", {
          get: G.prototype.cy,
          set: G.prototype.ey
        });
        G.prototype.get_m_closestHitFraction = G.prototype.fy = function() {
          return nj(this.Zx)
        }
        ;
        G.prototype.set_m_closestHitFraction = G.prototype.gy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          oj(c, a)
        }
        ;
        Object.defineProperty(G.prototype, "m_closestHitFraction", {
          get: G.prototype.fy,
          set: G.prototype.gy
        });
        G.prototype.get_m_collisionObject = G.prototype.hy = function() {
          return k(pj(this.Zx), q)
        }
        ;
        G.prototype.set_m_collisionObject = G.prototype.oy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          qj(c, a)
        }
        ;
        Object.defineProperty(G.prototype, "m_collisionObject", {
          get: G.prototype.hy,
          set: G.prototype.oy
        });
        G.prototype.__destroy__ = function() {
          rj(this.Zx)
        }
        ;
        function hB() {
          throw "cannot construct a tMaterialArray, no constructor in IDL";
        }
        hB.prototype = Object.create(g.prototype);
        hB.prototype.constructor = hB;
        hB.prototype.$x = hB;
        hB.ay = {};
        b.tMaterialArray = hB;
        hB.prototype.size = hB.prototype.size = function() {
          return sj(this.Zx)
        }
        ;
        hB.prototype.at = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(tj(c, a), A)
        }
        ;
        hB.prototype.__destroy__ = function() {
          uj(this.Zx)
        }
        ;
        function iB(a) {
          a && "object" === typeof a && (a = a.Zx);
          this.Zx = vj(a);
          h(iB)[this.Zx] = this
        }
        iB.prototype = Object.create(RA.prototype);
        iB.prototype.constructor = iB;
        iB.prototype.$x = iB;
        iB.ay = {};
        b.btDefaultVehicleRaycaster = iB;
        iB.prototype.castRay = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          wj(e, a, c, d)
        }
        ;
        iB.prototype.__destroy__ = function() {
          xj(this.Zx)
        }
        ;
        function jB() {
          this.Zx = yj();
          h(jB)[this.Zx] = this
        }
        jB.prototype = Object.create(LA.prototype);
        jB.prototype.constructor = jB;
        jB.prototype.$x = jB;
        jB.ay = {};
        b.btEmptyShape = jB;
        jB.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          zj(c, a)
        }
        ;
        jB.prototype.getLocalScaling = function() {
          return k(Aj(this.Zx), p)
        }
        ;
        jB.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Bj(d, a, c)
        }
        ;
        jB.prototype.__destroy__ = function() {
          Cj(this.Zx)
        }
        ;
        function H() {
          this.Zx = Dj();
          h(H)[this.Zx] = this
        }
        H.prototype = Object.create(g.prototype);
        H.prototype.constructor = H;
        H.prototype.$x = H;
        H.ay = {};
        b.btConstraintSetting = H;
        H.prototype.get_m_tau = H.prototype.VA = function() {
          return Ej(this.Zx)
        }
        ;
        H.prototype.set_m_tau = H.prototype.BD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Fj(c, a)
        }
        ;
        Object.defineProperty(H.prototype, "m_tau", {
          get: H.prototype.VA,
          set: H.prototype.BD
        });
        H.prototype.get_m_damping = H.prototype.Hz = function() {
          return Gj(this.Zx)
        }
        ;
        H.prototype.set_m_damping = H.prototype.nC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Hj(c, a)
        }
        ;
        Object.defineProperty(H.prototype, "m_damping", {
          get: H.prototype.Hz,
          set: H.prototype.nC
        });
        H.prototype.get_m_impulseClamp = H.prototype.eA = function() {
          return Ij(this.Zx)
        }
        ;
        H.prototype.set_m_impulseClamp = H.prototype.LC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Jj(c, a)
        }
        ;
        Object.defineProperty(H.prototype, "m_impulseClamp", {
          get: H.prototype.eA,
          set: H.prototype.LC
        });
        H.prototype.__destroy__ = function() {
          Kj(this.Zx)
        }
        ;
        function kB() {
          throw "cannot construct a LocalShapeInfo, no constructor in IDL";
        }
        kB.prototype = Object.create(g.prototype);
        kB.prototype.constructor = kB;
        kB.prototype.$x = kB;
        kB.ay = {};
        b.LocalShapeInfo = kB;
        kB.prototype.get_m_shapePart = kB.prototype.JA = function() {
          return Lj(this.Zx)
        }
        ;
        kB.prototype.set_m_shapePart = kB.prototype.pD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Mj(c, a)
        }
        ;
        Object.defineProperty(kB.prototype, "m_shapePart", {
          get: kB.prototype.JA,
          set: kB.prototype.pD
        });
        kB.prototype.get_m_triangleIndex = kB.prototype.YA = function() {
          return Nj(this.Zx)
        }
        ;
        kB.prototype.set_m_triangleIndex = kB.prototype.ED = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Oj(c, a)
        }
        ;
        Object.defineProperty(kB.prototype, "m_triangleIndex", {
          get: kB.prototype.YA,
          set: kB.prototype.ED
        });
        kB.prototype.__destroy__ = function() {
          Pj(this.Zx)
        }
        ;
        function I(a) {
          a && "object" === typeof a && (a = a.Zx);
          this.Zx = Qj(a);
          h(I)[this.Zx] = this
        }
        I.prototype = Object.create(q.prototype);
        I.prototype.constructor = I;
        I.prototype.$x = I;
        I.ay = {};
        b.btRigidBody = I;
        I.prototype.getCenterOfMassTransform = function() {
          return k(Rj(this.Zx), r)
        }
        ;
        I.prototype.setCenterOfMassTransform = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Sj(c, a)
        }
        ;
        I.prototype.setSleepingThresholds = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Tj(d, a, c)
        }
        ;
        I.prototype.getLinearDamping = function() {
          return Uj(this.Zx)
        }
        ;
        I.prototype.getAngularDamping = function() {
          return Vj(this.Zx)
        }
        ;
        I.prototype.setDamping = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Wj(d, a, c)
        }
        ;
        I.prototype.setMassProps = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Xj(d, a, c)
        }
        ;
        I.prototype.getLinearFactor = function() {
          return k(Yj(this.Zx), p)
        }
        ;
        I.prototype.setLinearFactor = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Zj(c, a)
        }
        ;
        I.prototype.applyTorque = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ak(c, a)
        }
        ;
        I.prototype.applyLocalTorque = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          bk(c, a)
        }
        ;
        I.prototype.applyForce = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          ck(d, a, c)
        }
        ;
        I.prototype.applyCentralForce = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          dk(c, a)
        }
        ;
        I.prototype.applyCentralLocalForce = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ek(c, a)
        }
        ;
        I.prototype.applyTorqueImpulse = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          fk(c, a)
        }
        ;
        I.prototype.applyImpulse = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          gk(d, a, c)
        }
        ;
        I.prototype.applyCentralImpulse = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          hk(c, a)
        }
        ;
        I.prototype.updateInertiaTensor = function() {
          ik(this.Zx)
        }
        ;
        I.prototype.getLinearVelocity = function() {
          return k(jk(this.Zx), p)
        }
        ;
        I.prototype.getAngularVelocity = function() {
          return k(kk(this.Zx), p)
        }
        ;
        I.prototype.setLinearVelocity = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          lk(c, a)
        }
        ;
        I.prototype.setAngularVelocity = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          mk(c, a)
        }
        ;
        I.prototype.getMotionState = function() {
          return k(nk(this.Zx), YA)
        }
        ;
        I.prototype.setMotionState = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ok(c, a)
        }
        ;
        I.prototype.getAngularFactor = function() {
          return k(pk(this.Zx), p)
        }
        ;
        I.prototype.setAngularFactor = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          qk(c, a)
        }
        ;
        I.prototype.upcast = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(rk(c, a), I)
        }
        ;
        I.prototype.getAabb = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          sk(d, a, c)
        }
        ;
        I.prototype.applyGravity = function() {
          tk(this.Zx)
        }
        ;
        I.prototype.getGravity = function() {
          return k(uk(this.Zx), p)
        }
        ;
        I.prototype.setGravity = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          vk(c, a)
        }
        ;
        I.prototype.getBroadphaseProxy = function() {
          return k(wk(this.Zx), t)
        }
        ;
        I.prototype.clearForces = function() {
          xk(this.Zx)
        }
        ;
        I.prototype.setAnisotropicFriction = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          yk(d, a, c)
        }
        ;
        I.prototype.getCollisionShape = function() {
          return k(zk(this.Zx), n)
        }
        ;
        I.prototype.setContactProcessingThreshold = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ak(c, a)
        }
        ;
        I.prototype.setActivationState = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Bk(c, a)
        }
        ;
        I.prototype.forceActivationState = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ck(c, a)
        }
        ;
        I.prototype.activate = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          void 0 === a ? Dk(c) : Ek(c, a)
        }
        ;
        I.prototype.isActive = function() {
          return !!Fk(this.Zx)
        }
        ;
        I.prototype.isKinematicObject = function() {
          return !!Gk(this.Zx)
        }
        ;
        I.prototype.isStaticObject = function() {
          return !!Hk(this.Zx)
        }
        ;
        I.prototype.isStaticOrKinematicObject = function() {
          return !!Ik(this.Zx)
        }
        ;
        I.prototype.getRestitution = function() {
          return Jk(this.Zx)
        }
        ;
        I.prototype.getFriction = function() {
          return Kk(this.Zx)
        }
        ;
        I.prototype.getRollingFriction = function() {
          return Lk(this.Zx)
        }
        ;
        I.prototype.setRestitution = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Mk(c, a)
        }
        ;
        I.prototype.setFriction = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Nk(c, a)
        }
        ;
        I.prototype.setRollingFriction = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ok(c, a)
        }
        ;
        I.prototype.getWorldTransform = function() {
          return k(Pk(this.Zx), r)
        }
        ;
        I.prototype.getCollisionFlags = function() {
          return Qk(this.Zx)
        }
        ;
        I.prototype.setCollisionFlags = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Rk(c, a)
        }
        ;
        I.prototype.setWorldTransform = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Sk(c, a)
        }
        ;
        I.prototype.setCollisionShape = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Tk(c, a)
        }
        ;
        I.prototype.setCcdMotionThreshold = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Uk(c, a)
        }
        ;
        I.prototype.setCcdSweptSphereRadius = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Vk(c, a)
        }
        ;
        I.prototype.getUserIndex = function() {
          return Wk(this.Zx)
        }
        ;
        I.prototype.setUserIndex = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Xk(c, a)
        }
        ;
        I.prototype.getUserPointer = function() {
          return k(Yk(this.Zx), JA)
        }
        ;
        I.prototype.setUserPointer = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Zk(c, a)
        }
        ;
        I.prototype.getBroadphaseHandle = function() {
          return k($k(this.Zx), t)
        }
        ;
        I.prototype.__destroy__ = function() {
          al(this.Zx)
        }
        ;
        function lB() {
          throw "cannot construct a btIndexedMeshArray, no constructor in IDL";
        }
        lB.prototype = Object.create(g.prototype);
        lB.prototype.constructor = lB;
        lB.prototype.$x = lB;
        lB.ay = {};
        b.btIndexedMeshArray = lB;
        lB.prototype.size = lB.prototype.size = function() {
          return bl(this.Zx)
        }
        ;
        lB.prototype.at = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(cl(c, a), mB)
        }
        ;
        lB.prototype.__destroy__ = function() {
          dl(this.Zx)
        }
        ;
        function nB() {
          this.Zx = el();
          h(nB)[this.Zx] = this
        }
        nB.prototype = Object.create(g.prototype);
        nB.prototype.constructor = nB;
        nB.prototype.$x = nB;
        nB.ay = {};
        b.btDbvtBroadphase = nB;
        nB.prototype.__destroy__ = function() {
          fl(this.Zx)
        }
        ;
        function oB(a, c, d, e, f, m, C, P, ia) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          m && "object" === typeof m && (m = m.Zx);
          C && "object" === typeof C && (C = C.Zx);
          P && "object" === typeof P && (P = P.Zx);
          ia && "object" === typeof ia && (ia = ia.Zx);
          this.Zx = gl(a, c, d, e, f, m, C, P, ia);
          h(oB)[this.Zx] = this
        }
        oB.prototype = Object.create(LA.prototype);
        oB.prototype.constructor = oB;
        oB.prototype.$x = oB;
        oB.ay = {};
        b.btHeightfieldTerrainShape = oB;
        oB.prototype.setMargin = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          hl(c, a)
        }
        ;
        oB.prototype.getMargin = function() {
          return il(this.Zx)
        }
        ;
        oB.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          jl(c, a)
        }
        ;
        oB.prototype.getLocalScaling = function() {
          return k(kl(this.Zx), p)
        }
        ;
        oB.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          ll(d, a, c)
        }
        ;
        oB.prototype.__destroy__ = function() {
          ml(this.Zx)
        }
        ;
        function pB() {
          this.Zx = nl();
          h(pB)[this.Zx] = this
        }
        pB.prototype = Object.create($A.prototype);
        pB.prototype.constructor = pB;
        pB.prototype.$x = pB;
        pB.ay = {};
        b.btDefaultSoftBodySolver = pB;
        pB.prototype.__destroy__ = function() {
          ol(this.Zx)
        }
        ;
        function qB(a) {
          a && "object" === typeof a && (a = a.Zx);
          this.Zx = pl(a);
          h(qB)[this.Zx] = this
        }
        qB.prototype = Object.create(FA.prototype);
        qB.prototype.constructor = qB;
        qB.prototype.$x = qB;
        qB.ay = {};
        b.btCollisionDispatcher = qB;
        qB.prototype.getNumManifolds = function() {
          return ql(this.Zx)
        }
        ;
        qB.prototype.getManifoldByIndexInternal = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(rl(c, a), VA)
        }
        ;
        qB.prototype.__destroy__ = function() {
          sl(this.Zx)
        }
        ;
        function rB(a, c, d, e, f) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          this.Zx = void 0 === d ? tl(a, c) : void 0 === e ? ul(a, c, d) : void 0 === f ? vl(a, c, d, e) : wl(a, c, d, e, f);
          h(rB)[this.Zx] = this
        }
        rB.prototype = Object.create(g.prototype);
        rB.prototype.constructor = rB;
        rB.prototype.$x = rB;
        rB.ay = {};
        b.btAxisSweep3 = rB;
        rB.prototype.__destroy__ = function() {
          xl(this.Zx)
        }
        ;
        function JA() {
          throw "cannot construct a VoidPtr, no constructor in IDL";
        }
        JA.prototype = Object.create(g.prototype);
        JA.prototype.constructor = JA;
        JA.prototype.$x = JA;
        JA.ay = {};
        b.VoidPtr = JA;
        JA.prototype.__destroy__ = function() {
          yl(this.Zx)
        }
        ;
        function J() {
          this.Zx = zl();
          h(J)[this.Zx] = this
        }
        J.prototype = Object.create(g.prototype);
        J.prototype.constructor = J;
        J.prototype.$x = J;
        J.ay = {};
        b.btSoftBodyWorldInfo = J;
        J.prototype.get_air_density = J.prototype.Ly = function() {
          return Al(this.Zx)
        }
        ;
        J.prototype.set_air_density = J.prototype.sB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Bl(c, a)
        }
        ;
        Object.defineProperty(J.prototype, "air_density", {
          get: J.prototype.Ly,
          set: J.prototype.sB
        });
        J.prototype.get_water_density = J.prototype.pB = function() {
          return Cl(this.Zx)
        }
        ;
        J.prototype.set_water_density = J.prototype.WD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Dl(c, a)
        }
        ;
        Object.defineProperty(J.prototype, "water_density", {
          get: J.prototype.pB,
          set: J.prototype.WD
        });
        J.prototype.get_water_offset = J.prototype.rB = function() {
          return El(this.Zx)
        }
        ;
        J.prototype.set_water_offset = J.prototype.YD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Fl(c, a)
        }
        ;
        Object.defineProperty(J.prototype, "water_offset", {
          get: J.prototype.rB,
          set: J.prototype.YD
        });
        J.prototype.get_m_maxDisplacement = J.prototype.sA = function() {
          return Gl(this.Zx)
        }
        ;
        J.prototype.set_m_maxDisplacement = J.prototype.ZC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Hl(c, a)
        }
        ;
        Object.defineProperty(J.prototype, "m_maxDisplacement", {
          get: J.prototype.sA,
          set: J.prototype.ZC
        });
        J.prototype.get_water_normal = J.prototype.qB = function() {
          return k(Il(this.Zx), p)
        }
        ;
        J.prototype.set_water_normal = J.prototype.XD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Jl(c, a)
        }
        ;
        Object.defineProperty(J.prototype, "water_normal", {
          get: J.prototype.qB,
          set: J.prototype.XD
        });
        J.prototype.get_m_broadphase = J.prototype.sz = function() {
          return k(Kl(this.Zx), HA)
        }
        ;
        J.prototype.set_m_broadphase = J.prototype.$B = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ll(c, a)
        }
        ;
        Object.defineProperty(J.prototype, "m_broadphase", {
          get: J.prototype.sz,
          set: J.prototype.$B
        });
        J.prototype.get_m_dispatcher = J.prototype.Kz = function() {
          return k(Ml(this.Zx), FA)
        }
        ;
        J.prototype.set_m_dispatcher = J.prototype.qC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Nl(c, a)
        }
        ;
        Object.defineProperty(J.prototype, "m_dispatcher", {
          get: J.prototype.Kz,
          set: J.prototype.qC
        });
        J.prototype.get_m_gravity = J.prototype.Uz = function() {
          return k(Ol(this.Zx), p)
        }
        ;
        J.prototype.set_m_gravity = J.prototype.AC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Pl(c, a)
        }
        ;
        Object.defineProperty(J.prototype, "m_gravity", {
          get: J.prototype.Uz,
          set: J.prototype.AC
        });
        J.prototype.__destroy__ = function() {
          Ql(this.Zx)
        }
        ;
        function sB(a, c, d, e) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          this.Zx = void 0 === d ? Rl(a, c) : void 0 === e ? _emscripten_bind_btConeTwistConstraint_btConeTwistConstraint_3(a, c, d) : Sl(a, c, d, e);
          h(sB)[this.Zx] = this
        }
        sB.prototype = Object.create(KA.prototype);
        sB.prototype.constructor = sB;
        sB.prototype.$x = sB;
        sB.ay = {};
        b.btConeTwistConstraint = sB;
        sB.prototype.setLimit = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Tl(d, a, c)
        }
        ;
        sB.prototype.setAngularOnly = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ul(c, a)
        }
        ;
        sB.prototype.setDamping = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Vl(c, a)
        }
        ;
        sB.prototype.enableMotor = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Wl(c, a)
        }
        ;
        sB.prototype.setMaxMotorImpulse = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Xl(c, a)
        }
        ;
        sB.prototype.setMaxMotorImpulseNormalized = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Yl(c, a)
        }
        ;
        sB.prototype.setMotorTarget = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Zl(c, a)
        }
        ;
        sB.prototype.setMotorTargetInConstraintSpace = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          $l(c, a)
        }
        ;
        sB.prototype.enableFeedback = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          am(c, a)
        }
        ;
        sB.prototype.getBreakingImpulseThreshold = function() {
          return bm(this.Zx)
        }
        ;
        sB.prototype.setBreakingImpulseThreshold = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          cm(c, a)
        }
        ;
        sB.prototype.getParam = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          return dm(d, a, c)
        }
        ;
        sB.prototype.setParam = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          em(e, a, c, d)
        }
        ;
        sB.prototype.__destroy__ = function() {
          fm(this.Zx)
        }
        ;
        function tB(a, c, d, e, f, m, C) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          m && "object" === typeof m && (m = m.Zx);
          C && "object" === typeof C && (C = C.Zx);
          this.Zx = void 0 === d ? gm(a, c) : void 0 === e ? hm(a, c, d) : void 0 === f ? im(a, c, d, e) : void 0 === m ? jm(a, c, d, e, f) : void 0 === C ? km(a, c, d, e, f, m) : lm(a, c, d, e, f, m, C);
          h(tB)[this.Zx] = this
        }
        tB.prototype = Object.create(KA.prototype);
        tB.prototype.constructor = tB;
        tB.prototype.$x = tB;
        tB.ay = {};
        b.btHingeConstraint = tB;
        tB.prototype.setLimit = function(a, c, d, e, f) {
          var m = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          void 0 === f ? mm(m, a, c, d, e) : nm(m, a, c, d, e, f)
        }
        ;
        tB.prototype.enableAngularMotor = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          om(e, a, c, d)
        }
        ;
        tB.prototype.setAngularOnly = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          pm(c, a)
        }
        ;
        tB.prototype.enableMotor = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          qm(c, a)
        }
        ;
        tB.prototype.setMaxMotorImpulse = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          rm(c, a)
        }
        ;
        tB.prototype.setMotorTarget = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          sm(d, a, c)
        }
        ;
        tB.prototype.enableFeedback = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          tm(c, a)
        }
        ;
        tB.prototype.getBreakingImpulseThreshold = function() {
          return um(this.Zx)
        }
        ;
        tB.prototype.setBreakingImpulseThreshold = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          wm(c, a)
        }
        ;
        tB.prototype.getParam = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          return xm(d, a, c)
        }
        ;
        tB.prototype.setParam = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          ym(e, a, c, d)
        }
        ;
        tB.prototype.__destroy__ = function() {
          zm(this.Zx)
        }
        ;
        function uB(a, c) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          this.Zx = Am(a, c);
          h(uB)[this.Zx] = this
        }
        uB.prototype = Object.create(PA.prototype);
        uB.prototype.constructor = uB;
        uB.prototype.$x = uB;
        uB.ay = {};
        b.btConeShapeZ = uB;
        uB.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Bm(c, a)
        }
        ;
        uB.prototype.getLocalScaling = function() {
          return k(Cm(this.Zx), p)
        }
        ;
        uB.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Dm(d, a, c)
        }
        ;
        uB.prototype.__destroy__ = function() {
          Em(this.Zx)
        }
        ;
        function vB(a, c) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          this.Zx = Fm(a, c);
          h(vB)[this.Zx] = this
        }
        vB.prototype = Object.create(PA.prototype);
        vB.prototype.constructor = vB;
        vB.prototype.$x = vB;
        vB.ay = {};
        b.btConeShapeX = vB;
        vB.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Gm(c, a)
        }
        ;
        vB.prototype.getLocalScaling = function() {
          return k(Hm(this.Zx), p)
        }
        ;
        vB.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Im(d, a, c)
        }
        ;
        vB.prototype.__destroy__ = function() {
          Jm(this.Zx)
        }
        ;
        function wB(a, c) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          this.Zx = void 0 === a ? Km() : void 0 === c ? Lm(a) : Mm(a, c);
          h(wB)[this.Zx] = this
        }
        wB.prototype = Object.create(XA.prototype);
        wB.prototype.constructor = wB;
        wB.prototype.$x = wB;
        wB.ay = {};
        b.btTriangleMesh = wB;
        wB.prototype.addTriangle = function(a, c, d, e) {
          var f = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          void 0 === e ? Nm(f, a, c, d) : Om(f, a, c, d, e)
        }
        ;
        wB.prototype.findOrAddVertex = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          return Pm(d, a, c)
        }
        ;
        wB.prototype.addIndex = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Qm(c, a)
        }
        ;
        wB.prototype.getIndexedMeshArray = function() {
          return k(Rm(this.Zx), lB)
        }
        ;
        wB.prototype.setScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Sm(c, a)
        }
        ;
        wB.prototype.__destroy__ = function() {
          Tm(this.Zx)
        }
        ;
        function xB(a, c) {
          zA();
          "object" == typeof a && (a = DA(a));
          c && "object" === typeof c && (c = c.Zx);
          this.Zx = void 0 === a ? Um() : void 0 === c ? Vm(a) : Wm(a, c);
          h(xB)[this.Zx] = this
        }
        xB.prototype = Object.create(n.prototype);
        xB.prototype.constructor = xB;
        xB.prototype.$x = xB;
        xB.ay = {};
        b.btConvexHullShape = xB;
        xB.prototype.addPoint = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          void 0 === c ? Xm(d, a) : Ym(d, a, c)
        }
        ;
        xB.prototype.setMargin = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Zm(c, a)
        }
        ;
        xB.prototype.getMargin = function() {
          return $m(this.Zx)
        }
        ;
        xB.prototype.getNumVertices = function() {
          return an(this.Zx)
        }
        ;
        xB.prototype.initializePolyhedralFeatures = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return !!bn(c, a)
        }
        ;
        xB.prototype.recalcLocalAabb = function() {
          cn(this.Zx)
        }
        ;
        xB.prototype.getConvexPolyhedron = function() {
          return k(dn(this.Zx), yB)
        }
        ;
        xB.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          en(c, a)
        }
        ;
        xB.prototype.getLocalScaling = function() {
          return k(fn(this.Zx), p)
        }
        ;
        xB.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          gn(d, a, c)
        }
        ;
        xB.prototype.__destroy__ = function() {
          hn(this.Zx)
        }
        ;
        function K() {
          this.Zx = jn();
          h(K)[this.Zx] = this
        }
        K.prototype = Object.create(g.prototype);
        K.prototype.constructor = K;
        K.prototype.$x = K;
        K.ay = {};
        b.btVehicleTuning = K;
        K.prototype.get_m_suspensionStiffness = K.prototype.ny = function() {
          return kn(this.Zx)
        }
        ;
        K.prototype.set_m_suspensionStiffness = K.prototype.uy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ln(c, a)
        }
        ;
        Object.defineProperty(K.prototype, "m_suspensionStiffness", {
          get: K.prototype.ny,
          set: K.prototype.uy
        });
        K.prototype.get_m_suspensionCompression = K.prototype.PA = function() {
          return mn(this.Zx)
        }
        ;
        K.prototype.set_m_suspensionCompression = K.prototype.vD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          nn(c, a)
        }
        ;
        Object.defineProperty(K.prototype, "m_suspensionCompression", {
          get: K.prototype.PA,
          set: K.prototype.vD
        });
        K.prototype.get_m_suspensionDamping = K.prototype.QA = function() {
          return on(this.Zx)
        }
        ;
        K.prototype.set_m_suspensionDamping = K.prototype.wD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          pn(c, a)
        }
        ;
        Object.defineProperty(K.prototype, "m_suspensionDamping", {
          get: K.prototype.QA,
          set: K.prototype.wD
        });
        K.prototype.get_m_maxSuspensionTravelCm = K.prototype.my = function() {
          return qn(this.Zx)
        }
        ;
        K.prototype.set_m_maxSuspensionTravelCm = K.prototype.ty = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          rn(c, a)
        }
        ;
        Object.defineProperty(K.prototype, "m_maxSuspensionTravelCm", {
          get: K.prototype.my,
          set: K.prototype.ty
        });
        K.prototype.get_m_frictionSlip = K.prototype.iy = function() {
          return sn(this.Zx)
        }
        ;
        K.prototype.set_m_frictionSlip = K.prototype.py = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          tn(c, a)
        }
        ;
        Object.defineProperty(K.prototype, "m_frictionSlip", {
          get: K.prototype.iy,
          set: K.prototype.py
        });
        K.prototype.get_m_maxSuspensionForce = K.prototype.ly = function() {
          return un(this.Zx)
        }
        ;
        K.prototype.set_m_maxSuspensionForce = K.prototype.sy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          vn(c, a)
        }
        ;
        Object.defineProperty(K.prototype, "m_maxSuspensionForce", {
          get: K.prototype.ly,
          set: K.prototype.sy
        });
        function zB() {
          throw "cannot construct a btCollisionObjectWrapper, no constructor in IDL";
        }
        zB.prototype = Object.create(g.prototype);
        zB.prototype.constructor = zB;
        zB.prototype.$x = zB;
        zB.ay = {};
        b.btCollisionObjectWrapper = zB;
        zB.prototype.getWorldTransform = function() {
          return k(wn(this.Zx), r)
        }
        ;
        zB.prototype.getCollisionObject = function() {
          return k(xn(this.Zx), q)
        }
        ;
        zB.prototype.getCollisionShape = function() {
          return k(yn(this.Zx), n)
        }
        ;
        function AB(a) {
          a && "object" === typeof a && (a = a.Zx);
          this.Zx = zn(a);
          h(AB)[this.Zx] = this
        }
        AB.prototype = Object.create(g.prototype);
        AB.prototype.constructor = AB;
        AB.prototype.$x = AB;
        AB.ay = {};
        b.btShapeHull = AB;
        AB.prototype.buildHull = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return !!An(c, a)
        }
        ;
        AB.prototype.numVertices = function() {
          return Bn(this.Zx)
        }
        ;
        AB.prototype.getVertexPointer = function() {
          return k(Cn(this.Zx), p)
        }
        ;
        AB.prototype.__destroy__ = function() {
          Dn(this.Zx)
        }
        ;
        function BB(a, c) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          this.Zx = void 0 === a ? En() : void 0 === c ? Fn(a) : Gn(a, c);
          h(BB)[this.Zx] = this
        }
        BB.prototype = Object.create(YA.prototype);
        BB.prototype.constructor = BB;
        BB.prototype.$x = BB;
        BB.ay = {};
        b.btDefaultMotionState = BB;
        BB.prototype.getWorldTransform = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Hn(c, a)
        }
        ;
        BB.prototype.setWorldTransform = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          In(c, a)
        }
        ;
        BB.prototype.get_m_graphicsWorldTrans = BB.prototype.Tz = function() {
          return k(Jn(this.Zx), r)
        }
        ;
        BB.prototype.set_m_graphicsWorldTrans = BB.prototype.zC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Kn(c, a)
        }
        ;
        Object.defineProperty(BB.prototype, "m_graphicsWorldTrans", {
          get: BB.prototype.Tz,
          set: BB.prototype.zC
        });
        BB.prototype.__destroy__ = function() {
          Ln(this.Zx)
        }
        ;
        function L(a) {
          a && "object" === typeof a && (a = a.Zx);
          this.Zx = Mn(a);
          h(L)[this.Zx] = this
        }
        L.prototype = Object.create(g.prototype);
        L.prototype.constructor = L;
        L.prototype.$x = L;
        L.ay = {};
        b.btWheelInfo = L;
        L.prototype.getSuspensionRestLength = function() {
          return Nn(this.Zx)
        }
        ;
        L.prototype.updateWheel = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          On(d, a, c)
        }
        ;
        L.prototype.get_m_suspensionStiffness = L.prototype.ny = function() {
          return Pn(this.Zx)
        }
        ;
        L.prototype.set_m_suspensionStiffness = L.prototype.uy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Qn(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_suspensionStiffness", {
          get: L.prototype.ny,
          set: L.prototype.uy
        });
        L.prototype.get_m_frictionSlip = L.prototype.iy = function() {
          return Rn(this.Zx)
        }
        ;
        L.prototype.set_m_frictionSlip = L.prototype.py = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Sn(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_frictionSlip", {
          get: L.prototype.iy,
          set: L.prototype.py
        });
        L.prototype.get_m_engineForce = L.prototype.Oz = function() {
          return Tn(this.Zx)
        }
        ;
        L.prototype.set_m_engineForce = L.prototype.uC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Un(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_engineForce", {
          get: L.prototype.Oz,
          set: L.prototype.uC
        });
        L.prototype.get_m_rollInfluence = L.prototype.FA = function() {
          return Vn(this.Zx)
        }
        ;
        L.prototype.set_m_rollInfluence = L.prototype.lD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Wn(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_rollInfluence", {
          get: L.prototype.FA,
          set: L.prototype.lD
        });
        L.prototype.get_m_suspensionRestLength1 = L.prototype.UA = function() {
          return Xn(this.Zx)
        }
        ;
        L.prototype.set_m_suspensionRestLength1 = L.prototype.AD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Yn(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_suspensionRestLength1", {
          get: L.prototype.UA,
          set: L.prototype.AD
        });
        L.prototype.get_m_wheelsRadius = L.prototype.hB = function() {
          return Zn(this.Zx)
        }
        ;
        L.prototype.set_m_wheelsRadius = L.prototype.OD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          $n(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_wheelsRadius", {
          get: L.prototype.hB,
          set: L.prototype.OD
        });
        L.prototype.get_m_wheelsDampingCompression = L.prototype.By = function() {
          return ao(this.Zx)
        }
        ;
        L.prototype.set_m_wheelsDampingCompression = L.prototype.Iy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          bo(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_wheelsDampingCompression", {
          get: L.prototype.By,
          set: L.prototype.Iy
        });
        L.prototype.get_m_wheelsDampingRelaxation = L.prototype.Cy = function() {
          return co(this.Zx)
        }
        ;
        L.prototype.set_m_wheelsDampingRelaxation = L.prototype.Jy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          eo(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_wheelsDampingRelaxation", {
          get: L.prototype.Cy,
          set: L.prototype.Jy
        });
        L.prototype.get_m_steering = L.prototype.NA = function() {
          return fo(this.Zx)
        }
        ;
        L.prototype.set_m_steering = L.prototype.tD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          go(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_steering", {
          get: L.prototype.NA,
          set: L.prototype.tD
        });
        L.prototype.get_m_maxSuspensionForce = L.prototype.ly = function() {
          return ho(this.Zx)
        }
        ;
        L.prototype.set_m_maxSuspensionForce = L.prototype.sy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          io(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_maxSuspensionForce", {
          get: L.prototype.ly,
          set: L.prototype.sy
        });
        L.prototype.get_m_maxSuspensionTravelCm = L.prototype.my = function() {
          return jo(this.Zx)
        }
        ;
        L.prototype.set_m_maxSuspensionTravelCm = L.prototype.ty = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ko(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_maxSuspensionTravelCm", {
          get: L.prototype.my,
          set: L.prototype.ty
        });
        L.prototype.get_m_wheelsSuspensionForce = L.prototype.iB = function() {
          return lo(this.Zx)
        }
        ;
        L.prototype.set_m_wheelsSuspensionForce = L.prototype.PD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          mo(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_wheelsSuspensionForce", {
          get: L.prototype.iB,
          set: L.prototype.PD
        });
        L.prototype.get_m_bIsFrontWheel = L.prototype.wy = function() {
          return !!no(this.Zx)
        }
        ;
        L.prototype.set_m_bIsFrontWheel = L.prototype.Dy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          oo(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_bIsFrontWheel", {
          get: L.prototype.wy,
          set: L.prototype.Dy
        });
        L.prototype.get_m_raycastInfo = L.prototype.DA = function() {
          return k(po(this.Zx), M)
        }
        ;
        L.prototype.set_m_raycastInfo = L.prototype.jD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          qo(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_raycastInfo", {
          get: L.prototype.DA,
          set: L.prototype.jD
        });
        L.prototype.get_m_chassisConnectionPointCS = L.prototype.zz = function() {
          return k(ro(this.Zx), p)
        }
        ;
        L.prototype.set_m_chassisConnectionPointCS = L.prototype.fC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          so(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_chassisConnectionPointCS", {
          get: L.prototype.zz,
          set: L.prototype.fC
        });
        L.prototype.get_m_worldTransform = L.prototype.jB = function() {
          return k(to(this.Zx), r)
        }
        ;
        L.prototype.set_m_worldTransform = L.prototype.QD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          uo(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_worldTransform", {
          get: L.prototype.jB,
          set: L.prototype.QD
        });
        L.prototype.get_m_wheelDirectionCS = L.prototype.Ay = function() {
          return k(vo(this.Zx), p)
        }
        ;
        L.prototype.set_m_wheelDirectionCS = L.prototype.Hy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          wo(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_wheelDirectionCS", {
          get: L.prototype.Ay,
          set: L.prototype.Hy
        });
        L.prototype.get_m_wheelAxleCS = L.prototype.zy = function() {
          return k(xo(this.Zx), p)
        }
        ;
        L.prototype.set_m_wheelAxleCS = L.prototype.Gy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          yo(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_wheelAxleCS", {
          get: L.prototype.zy,
          set: L.prototype.Gy
        });
        L.prototype.get_m_rotation = L.prototype.HA = function() {
          return zo(this.Zx)
        }
        ;
        L.prototype.set_m_rotation = L.prototype.nD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ao(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_rotation", {
          get: L.prototype.HA,
          set: L.prototype.nD
        });
        L.prototype.get_m_deltaRotation = L.prototype.Iz = function() {
          return Bo(this.Zx)
        }
        ;
        L.prototype.set_m_deltaRotation = L.prototype.oC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Co(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_deltaRotation", {
          get: L.prototype.Iz,
          set: L.prototype.oC
        });
        L.prototype.get_m_brake = L.prototype.rz = function() {
          return Do(this.Zx)
        }
        ;
        L.prototype.set_m_brake = L.prototype.ZB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Eo(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_brake", {
          get: L.prototype.rz,
          set: L.prototype.ZB
        });
        L.prototype.get_m_clippedInvContactDotSuspension = L.prototype.Az = function() {
          return Fo(this.Zx)
        }
        ;
        L.prototype.set_m_clippedInvContactDotSuspension = L.prototype.gC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Go(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_clippedInvContactDotSuspension", {
          get: L.prototype.Az,
          set: L.prototype.gC
        });
        L.prototype.get_m_suspensionRelativeVelocity = L.prototype.SA = function() {
          return Ho(this.Zx)
        }
        ;
        L.prototype.set_m_suspensionRelativeVelocity = L.prototype.yD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Io(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_suspensionRelativeVelocity", {
          get: L.prototype.SA,
          set: L.prototype.yD
        });
        L.prototype.get_m_skidInfo = L.prototype.KA = function() {
          return Jo(this.Zx)
        }
        ;
        L.prototype.set_m_skidInfo = L.prototype.qD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ko(c, a)
        }
        ;
        Object.defineProperty(L.prototype, "m_skidInfo", {
          get: L.prototype.KA,
          set: L.prototype.qD
        });
        L.prototype.__destroy__ = function() {
          Lo(this.Zx)
        }
        ;
        function N(a, c, d, e) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          this.Zx = void 0 === a ? Mo() : void 0 === c ? _emscripten_bind_btVector4_btVector4_1(a) : void 0 === d ? _emscripten_bind_btVector4_btVector4_2(a, c) : void 0 === e ? _emscripten_bind_btVector4_btVector4_3(a, c, d) : No(a, c, d, e);
          h(N)[this.Zx] = this
        }
        N.prototype = Object.create(p.prototype);
        N.prototype.constructor = N;
        N.prototype.$x = N;
        N.ay = {};
        b.btVector4 = N;
        N.prototype.w = function() {
          return Oo(this.Zx)
        }
        ;
        N.prototype.setValue = function(a, c, d, e) {
          var f = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          Po(f, a, c, d, e)
        }
        ;
        N.prototype.length = N.prototype.length = function() {
          return Qo(this.Zx)
        }
        ;
        N.prototype.x = N.prototype.x = function() {
          return Ro(this.Zx)
        }
        ;
        N.prototype.y = N.prototype.y = function() {
          return So(this.Zx)
        }
        ;
        N.prototype.z = N.prototype.z = function() {
          return To(this.Zx)
        }
        ;
        N.prototype.setX = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Uo(c, a)
        }
        ;
        N.prototype.setY = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Vo(c, a)
        }
        ;
        N.prototype.setZ = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Wo(c, a)
        }
        ;
        N.prototype.normalize = N.prototype.normalize = function() {
          Xo(this.Zx)
        }
        ;
        N.prototype.rotate = N.prototype.rotate = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          return k(Yo(d, a, c), p)
        }
        ;
        N.prototype.dot = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return Zo(c, a)
        }
        ;
        N.prototype.op_mul = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k($o(c, a), p)
        }
        ;
        N.prototype.op_add = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(ap(c, a), p)
        }
        ;
        N.prototype.op_sub = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(bp(c, a), p)
        }
        ;
        N.prototype.__destroy__ = function() {
          cp(this.Zx)
        }
        ;
        function CB() {
          this.Zx = dp();
          h(CB)[this.Zx] = this
        }
        CB.prototype = Object.create(g.prototype);
        CB.prototype.constructor = CB;
        CB.prototype.$x = CB;
        CB.ay = {};
        b.btDefaultCollisionConstructionInfo = CB;
        CB.prototype.__destroy__ = function() {
          ep(this.Zx)
        }
        ;
        function O() {
          throw "cannot construct a Anchor, no constructor in IDL";
        }
        O.prototype = Object.create(g.prototype);
        O.prototype.constructor = O;
        O.prototype.$x = O;
        O.ay = {};
        b.Anchor = O;
        O.prototype.get_m_node = O.prototype.uA = function() {
          return k(fp(this.Zx), Node)
        }
        ;
        O.prototype.set_m_node = O.prototype.aD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          gp(c, a)
        }
        ;
        Object.defineProperty(O.prototype, "m_node", {
          get: O.prototype.uA,
          set: O.prototype.aD
        });
        O.prototype.get_m_local = O.prototype.nA = function() {
          return k(hp(this.Zx), p)
        }
        ;
        O.prototype.set_m_local = O.prototype.UC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ip(c, a)
        }
        ;
        Object.defineProperty(O.prototype, "m_local", {
          get: O.prototype.nA,
          set: O.prototype.UC
        });
        O.prototype.get_m_body = O.prototype.qz = function() {
          return k(jp(this.Zx), I)
        }
        ;
        O.prototype.set_m_body = O.prototype.YB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          kp(c, a)
        }
        ;
        Object.defineProperty(O.prototype, "m_body", {
          get: O.prototype.qz,
          set: O.prototype.YB
        });
        O.prototype.get_m_influence = O.prototype.gA = function() {
          return lp(this.Zx)
        }
        ;
        O.prototype.set_m_influence = O.prototype.NC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          mp(c, a)
        }
        ;
        Object.defineProperty(O.prototype, "m_influence", {
          get: O.prototype.gA,
          set: O.prototype.NC
        });
        O.prototype.get_m_c0 = O.prototype.uz = function() {
          return k(np(this.Zx), aB)
        }
        ;
        O.prototype.set_m_c0 = O.prototype.aC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          op(c, a)
        }
        ;
        Object.defineProperty(O.prototype, "m_c0", {
          get: O.prototype.uz,
          set: O.prototype.aC
        });
        O.prototype.get_m_c1 = O.prototype.vz = function() {
          return k(pp(this.Zx), p)
        }
        ;
        O.prototype.set_m_c1 = O.prototype.bC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          qp(c, a)
        }
        ;
        Object.defineProperty(O.prototype, "m_c1", {
          get: O.prototype.vz,
          set: O.prototype.bC
        });
        O.prototype.get_m_c2 = O.prototype.wz = function() {
          return rp(this.Zx)
        }
        ;
        O.prototype.set_m_c2 = O.prototype.cC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          sp(c, a)
        }
        ;
        Object.defineProperty(O.prototype, "m_c2", {
          get: O.prototype.wz,
          set: O.prototype.cC
        });
        O.prototype.__destroy__ = function() {
          tp(this.Zx)
        }
        ;
        function Q() {
          throw "cannot construct a btVehicleRaycasterResult, no constructor in IDL";
        }
        Q.prototype = Object.create(g.prototype);
        Q.prototype.constructor = Q;
        Q.prototype.$x = Q;
        Q.ay = {};
        b.btVehicleRaycasterResult = Q;
        Q.prototype.get_m_hitPointInWorld = Q.prototype.bA = function() {
          return k(up(this.Zx), p)
        }
        ;
        Q.prototype.set_m_hitPointInWorld = Q.prototype.IC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          vp(c, a)
        }
        ;
        Object.defineProperty(Q.prototype, "m_hitPointInWorld", {
          get: Q.prototype.bA,
          set: Q.prototype.IC
        });
        Q.prototype.get_m_hitNormalInWorld = Q.prototype.$z = function() {
          return k(wp(this.Zx), p)
        }
        ;
        Q.prototype.set_m_hitNormalInWorld = Q.prototype.GC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          xp(c, a)
        }
        ;
        Object.defineProperty(Q.prototype, "m_hitNormalInWorld", {
          get: Q.prototype.$z,
          set: Q.prototype.GC
        });
        Q.prototype.get_m_distFraction = Q.prototype.Lz = function() {
          return yp(this.Zx)
        }
        ;
        Q.prototype.set_m_distFraction = Q.prototype.rC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          zp(c, a)
        }
        ;
        Object.defineProperty(Q.prototype, "m_distFraction", {
          get: Q.prototype.Lz,
          set: Q.prototype.rC
        });
        Q.prototype.__destroy__ = function() {
          Ap(this.Zx)
        }
        ;
        function gB() {
          throw "cannot construct a btVector3Array, no constructor in IDL";
        }
        gB.prototype = Object.create(g.prototype);
        gB.prototype.constructor = gB;
        gB.prototype.$x = gB;
        gB.ay = {};
        b.btVector3Array = gB;
        gB.prototype.size = gB.prototype.size = function() {
          return Bp(this.Zx)
        }
        ;
        gB.prototype.at = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(Cp(c, a), p)
        }
        ;
        gB.prototype.__destroy__ = function() {
          Dp(this.Zx)
        }
        ;
        function DB() {
          throw "cannot construct a btConstraintSolver, no constructor in IDL";
        }
        DB.prototype = Object.create(g.prototype);
        DB.prototype.constructor = DB;
        DB.prototype.$x = DB;
        DB.ay = {};
        b.btConstraintSolver = DB;
        DB.prototype.__destroy__ = function() {
          Ep(this.Zx)
        }
        ;
        function R(a, c, d) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          this.Zx = Fp(a, c, d);
          h(R)[this.Zx] = this
        }
        R.prototype = Object.create(QA.prototype);
        R.prototype.constructor = R;
        R.prototype.$x = R;
        R.ay = {};
        b.btRaycastVehicle = R;
        R.prototype.applyEngineForce = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Gp(d, a, c)
        }
        ;
        R.prototype.setSteeringValue = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Hp(d, a, c)
        }
        ;
        R.prototype.getWheelTransformWS = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(Ip(c, a), r)
        }
        ;
        R.prototype.updateWheelTransform = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Jp(d, a, c)
        }
        ;
        R.prototype.addWheel = function(a, c, d, e, f, m, C) {
          var P = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          m && "object" === typeof m && (m = m.Zx);
          C && "object" === typeof C && (C = C.Zx);
          return k(Kp(P, a, c, d, e, f, m, C), L)
        }
        ;
        R.prototype.getNumWheels = function() {
          return Lp(this.Zx)
        }
        ;
        R.prototype.getRigidBody = function() {
          return k(Mp(this.Zx), I)
        }
        ;
        R.prototype.getWheelInfo = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(Np(c, a), L)
        }
        ;
        R.prototype.setBrake = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Op(d, a, c)
        }
        ;
        R.prototype.setCoordinateSystem = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          Pp(e, a, c, d)
        }
        ;
        R.prototype.getCurrentSpeedKmHour = function() {
          return Qp(this.Zx)
        }
        ;
        R.prototype.getChassisWorldTransform = function() {
          return k(Rp(this.Zx), r)
        }
        ;
        R.prototype.rayCast = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return Sp(c, a)
        }
        ;
        R.prototype.updateVehicle = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Tp(c, a)
        }
        ;
        R.prototype.resetSuspension = function() {
          Up(this.Zx)
        }
        ;
        R.prototype.getSteeringValue = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return Vp(c, a)
        }
        ;
        R.prototype.updateWheelTransformsWS = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          void 0 === c ? Wp(d, a) : Xp(d, a, c)
        }
        ;
        R.prototype.setPitchControl = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Yp(c, a)
        }
        ;
        R.prototype.updateSuspension = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Zp(c, a)
        }
        ;
        R.prototype.updateFriction = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          $p(c, a)
        }
        ;
        R.prototype.getRightAxis = function() {
          return aq(this.Zx)
        }
        ;
        R.prototype.getUpAxis = function() {
          return bq(this.Zx)
        }
        ;
        R.prototype.getForwardAxis = function() {
          return cq(this.Zx)
        }
        ;
        R.prototype.getForwardVector = function() {
          return k(dq(this.Zx), p)
        }
        ;
        R.prototype.getUserConstraintType = function() {
          return eq(this.Zx)
        }
        ;
        R.prototype.setUserConstraintType = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          fq(c, a)
        }
        ;
        R.prototype.setUserConstraintId = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          gq(c, a)
        }
        ;
        R.prototype.getUserConstraintId = function() {
          return hq(this.Zx)
        }
        ;
        R.prototype.updateAction = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          iq(d, a, c)
        }
        ;
        R.prototype.__destroy__ = function() {
          jq(this.Zx)
        }
        ;
        function EB(a) {
          a && "object" === typeof a && (a = a.Zx);
          this.Zx = kq(a);
          h(EB)[this.Zx] = this
        }
        EB.prototype = Object.create(TA.prototype);
        EB.prototype.constructor = EB;
        EB.prototype.$x = EB;
        EB.ay = {};
        b.btCylinderShapeX = EB;
        EB.prototype.setMargin = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          lq(c, a)
        }
        ;
        EB.prototype.getMargin = function() {
          return mq(this.Zx)
        }
        ;
        EB.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          nq(c, a)
        }
        ;
        EB.prototype.getLocalScaling = function() {
          return k(oq(this.Zx), p)
        }
        ;
        EB.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          pq(d, a, c)
        }
        ;
        EB.prototype.__destroy__ = function() {
          qq(this.Zx)
        }
        ;
        function FB(a) {
          a && "object" === typeof a && (a = a.Zx);
          this.Zx = rq(a);
          h(FB)[this.Zx] = this
        }
        FB.prototype = Object.create(TA.prototype);
        FB.prototype.constructor = FB;
        FB.prototype.$x = FB;
        FB.ay = {};
        b.btCylinderShapeZ = FB;
        FB.prototype.setMargin = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          sq(c, a)
        }
        ;
        FB.prototype.getMargin = function() {
          return tq(this.Zx)
        }
        ;
        FB.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          uq(c, a)
        }
        ;
        FB.prototype.getLocalScaling = function() {
          return k(vq(this.Zx), p)
        }
        ;
        FB.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          wq(d, a, c)
        }
        ;
        FB.prototype.__destroy__ = function() {
          xq(this.Zx)
        }
        ;
        function yB() {
          throw "cannot construct a btConvexPolyhedron, no constructor in IDL";
        }
        yB.prototype = Object.create(g.prototype);
        yB.prototype.constructor = yB;
        yB.prototype.$x = yB;
        yB.ay = {};
        b.btConvexPolyhedron = yB;
        yB.prototype.get_m_vertices = yB.prototype.dB = function() {
          return k(yq(this.Zx), gB)
        }
        ;
        yB.prototype.set_m_vertices = yB.prototype.KD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          zq(c, a)
        }
        ;
        Object.defineProperty(yB.prototype, "m_vertices", {
          get: yB.prototype.dB,
          set: yB.prototype.KD
        });
        yB.prototype.get_m_faces = yB.prototype.Qz = function() {
          return k(Aq(this.Zx), GB)
        }
        ;
        yB.prototype.set_m_faces = yB.prototype.wC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Bq(c, a)
        }
        ;
        Object.defineProperty(yB.prototype, "m_faces", {
          get: yB.prototype.Qz,
          set: yB.prototype.wC
        });
        yB.prototype.__destroy__ = function() {
          Cq(this.Zx)
        }
        ;
        function HB() {
          this.Zx = Dq();
          h(HB)[this.Zx] = this
        }
        HB.prototype = Object.create(g.prototype);
        HB.prototype.constructor = HB;
        HB.prototype.$x = HB;
        HB.ay = {};
        b.btSequentialImpulseConstraintSolver = HB;
        HB.prototype.__destroy__ = function() {
          Eq(this.Zx)
        }
        ;
        function IB() {
          throw "cannot construct a tAnchorArray, no constructor in IDL";
        }
        IB.prototype = Object.create(g.prototype);
        IB.prototype.constructor = IB;
        IB.prototype.$x = IB;
        IB.ay = {};
        b.tAnchorArray = IB;
        IB.prototype.size = IB.prototype.size = function() {
          return Fq(this.Zx)
        }
        ;
        IB.prototype.at = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(Gq(c, a), O)
        }
        ;
        IB.prototype.clear = IB.prototype.clear = function() {
          Hq(this.Zx)
        }
        ;
        IB.prototype.push_back = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Iq(c, a)
        }
        ;
        IB.prototype.pop_back = function() {
          Jq(this.Zx)
        }
        ;
        IB.prototype.__destroy__ = function() {
          Kq(this.Zx)
        }
        ;
        function M() {
          throw "cannot construct a RaycastInfo, no constructor in IDL";
        }
        M.prototype = Object.create(g.prototype);
        M.prototype.constructor = M;
        M.prototype.$x = M;
        M.ay = {};
        b.RaycastInfo = M;
        M.prototype.get_m_contactNormalWS = M.prototype.Cz = function() {
          return k(Lq(this.Zx), p)
        }
        ;
        M.prototype.set_m_contactNormalWS = M.prototype.iC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Mq(c, a)
        }
        ;
        Object.defineProperty(M.prototype, "m_contactNormalWS", {
          get: M.prototype.Cz,
          set: M.prototype.iC
        });
        M.prototype.get_m_contactPointWS = M.prototype.Dz = function() {
          return k(Nq(this.Zx), p)
        }
        ;
        M.prototype.set_m_contactPointWS = M.prototype.jC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Oq(c, a)
        }
        ;
        Object.defineProperty(M.prototype, "m_contactPointWS", {
          get: M.prototype.Dz,
          set: M.prototype.jC
        });
        M.prototype.get_m_suspensionLength = M.prototype.RA = function() {
          return Pq(this.Zx)
        }
        ;
        M.prototype.set_m_suspensionLength = M.prototype.xD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Qq(c, a)
        }
        ;
        Object.defineProperty(M.prototype, "m_suspensionLength", {
          get: M.prototype.RA,
          set: M.prototype.xD
        });
        M.prototype.get_m_hardPointWS = M.prototype.Wz = function() {
          return k(Rq(this.Zx), p)
        }
        ;
        M.prototype.set_m_hardPointWS = M.prototype.CC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Sq(c, a)
        }
        ;
        Object.defineProperty(M.prototype, "m_hardPointWS", {
          get: M.prototype.Wz,
          set: M.prototype.CC
        });
        M.prototype.get_m_wheelDirectionWS = M.prototype.fB = function() {
          return k(Tq(this.Zx), p)
        }
        ;
        M.prototype.set_m_wheelDirectionWS = M.prototype.MD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Uq(c, a)
        }
        ;
        Object.defineProperty(M.prototype, "m_wheelDirectionWS", {
          get: M.prototype.fB,
          set: M.prototype.MD
        });
        M.prototype.get_m_wheelAxleWS = M.prototype.eB = function() {
          return k(Vq(this.Zx), p)
        }
        ;
        M.prototype.set_m_wheelAxleWS = M.prototype.LD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Wq(c, a)
        }
        ;
        Object.defineProperty(M.prototype, "m_wheelAxleWS", {
          get: M.prototype.eB,
          set: M.prototype.LD
        });
        M.prototype.get_m_isInContact = M.prototype.hA = function() {
          return !!Xq(this.Zx)
        }
        ;
        M.prototype.set_m_isInContact = M.prototype.OC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Yq(c, a)
        }
        ;
        Object.defineProperty(M.prototype, "m_isInContact", {
          get: M.prototype.hA,
          set: M.prototype.OC
        });
        M.prototype.get_m_groundObject = M.prototype.Vz = function() {
          return Zq(this.Zx)
        }
        ;
        M.prototype.set_m_groundObject = M.prototype.BC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          $q(c, a)
        }
        ;
        Object.defineProperty(M.prototype, "m_groundObject", {
          get: M.prototype.Vz,
          set: M.prototype.BC
        });
        M.prototype.__destroy__ = function() {
          ar(this.Zx)
        }
        ;
        function JB(a, c, d) {
          zA();
          a && "object" === typeof a && (a = a.Zx);
          "object" == typeof c && (c = DA(c));
          d && "object" === typeof d && (d = d.Zx);
          this.Zx = br(a, c, d);
          h(JB)[this.Zx] = this
        }
        JB.prototype = Object.create(n.prototype);
        JB.prototype.constructor = JB;
        JB.prototype.$x = JB;
        JB.ay = {};
        b.btMultiSphereShape = JB;
        JB.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          cr(c, a)
        }
        ;
        JB.prototype.getLocalScaling = function() {
          return k(dr(this.Zx), p)
        }
        ;
        JB.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          er(d, a, c)
        }
        ;
        JB.prototype.__destroy__ = function() {
          fr(this.Zx)
        }
        ;
        function S(a, c, d, e) {
          zA();
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          "object" == typeof e && (e = DA(e));
          this.Zx = gr(a, c, d, e);
          h(S)[this.Zx] = this
        }
        S.prototype = Object.create(q.prototype);
        S.prototype.constructor = S;
        S.prototype.$x = S;
        S.ay = {};
        b.btSoftBody = S;
        S.prototype.checkLink = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          return !!hr(d, a, c)
        }
        ;
        S.prototype.checkFace = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          return !!ir(e, a, c, d)
        }
        ;
        S.prototype.appendMaterial = function() {
          return k(jr(this.Zx), A)
        }
        ;
        S.prototype.appendNode = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          kr(d, a, c)
        }
        ;
        S.prototype.appendLink = function(a, c, d, e) {
          var f = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          lr(f, a, c, d, e)
        }
        ;
        S.prototype.appendFace = function(a, c, d, e) {
          var f = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          mr(f, a, c, d, e)
        }
        ;
        S.prototype.appendTetra = function(a, c, d, e, f) {
          var m = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          nr(m, a, c, d, e, f)
        }
        ;
        S.prototype.appendAnchor = function(a, c, d, e) {
          var f = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          or(f, a, c, d, e)
        }
        ;
        S.prototype.addForce = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          void 0 === c ? pr(d, a) : qr(d, a, c)
        }
        ;
        S.prototype.addAeroForceToNode = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          rr(d, a, c)
        }
        ;
        S.prototype.getTotalMass = function() {
          return sr(this.Zx)
        }
        ;
        S.prototype.setTotalMass = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          tr(d, a, c)
        }
        ;
        S.prototype.setMass = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          ur(d, a, c)
        }
        ;
        S.prototype.transform = S.prototype.transform = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          vr(c, a)
        }
        ;
        S.prototype.translate = S.prototype.translate = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          wr(c, a)
        }
        ;
        S.prototype.rotate = S.prototype.rotate = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          xr(c, a)
        }
        ;
        S.prototype.scale = S.prototype.scale = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          yr(c, a)
        }
        ;
        S.prototype.generateClusters = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          return void 0 === c ? zr(d, a) : Ar(d, a, c)
        }
        ;
        S.prototype.generateBendingConstraints = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          return Br(d, a, c)
        }
        ;
        S.prototype.upcast = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(Cr(c, a), S)
        }
        ;
        S.prototype.setAnisotropicFriction = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Dr(d, a, c)
        }
        ;
        S.prototype.getCollisionShape = function() {
          return k(Er(this.Zx), n)
        }
        ;
        S.prototype.setContactProcessingThreshold = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Fr(c, a)
        }
        ;
        S.prototype.setActivationState = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Gr(c, a)
        }
        ;
        S.prototype.forceActivationState = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Hr(c, a)
        }
        ;
        S.prototype.activate = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          void 0 === a ? Ir(c) : Jr(c, a)
        }
        ;
        S.prototype.isActive = function() {
          return !!Kr(this.Zx)
        }
        ;
        S.prototype.isKinematicObject = function() {
          return !!Lr(this.Zx)
        }
        ;
        S.prototype.isStaticObject = function() {
          return !!Mr(this.Zx)
        }
        ;
        S.prototype.isStaticOrKinematicObject = function() {
          return !!Nr(this.Zx)
        }
        ;
        S.prototype.getRestitution = function() {
          return Or(this.Zx)
        }
        ;
        S.prototype.getFriction = function() {
          return Pr(this.Zx)
        }
        ;
        S.prototype.getRollingFriction = function() {
          return Qr(this.Zx)
        }
        ;
        S.prototype.setRestitution = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Rr(c, a)
        }
        ;
        S.prototype.setFriction = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Sr(c, a)
        }
        ;
        S.prototype.setRollingFriction = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Tr(c, a)
        }
        ;
        S.prototype.getWorldTransform = function() {
          return k(Ur(this.Zx), r)
        }
        ;
        S.prototype.getCollisionFlags = function() {
          return Vr(this.Zx)
        }
        ;
        S.prototype.setCollisionFlags = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Wr(c, a)
        }
        ;
        S.prototype.setWorldTransform = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Xr(c, a)
        }
        ;
        S.prototype.setCollisionShape = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Yr(c, a)
        }
        ;
        S.prototype.setCcdMotionThreshold = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Zr(c, a)
        }
        ;
        S.prototype.setCcdSweptSphereRadius = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          $r(c, a)
        }
        ;
        S.prototype.getUserIndex = function() {
          return as(this.Zx)
        }
        ;
        S.prototype.setUserIndex = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          bs(c, a)
        }
        ;
        S.prototype.getUserPointer = function() {
          return k(cs(this.Zx), JA)
        }
        ;
        S.prototype.setUserPointer = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ds(c, a)
        }
        ;
        S.prototype.getBroadphaseHandle = function() {
          return k(es(this.Zx), t)
        }
        ;
        S.prototype.get_m_cfg = S.prototype.xz = function() {
          return k(gs(this.Zx), T)
        }
        ;
        S.prototype.set_m_cfg = S.prototype.dC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          hs(c, a)
        }
        ;
        Object.defineProperty(S.prototype, "m_cfg", {
          get: S.prototype.xz,
          set: S.prototype.dC
        });
        S.prototype.get_m_nodes = S.prototype.vA = function() {
          return k(is(this.Zx), KB)
        }
        ;
        S.prototype.set_m_nodes = S.prototype.bD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          js(c, a)
        }
        ;
        Object.defineProperty(S.prototype, "m_nodes", {
          get: S.prototype.vA,
          set: S.prototype.bD
        });
        S.prototype.get_m_materials = S.prototype.rA = function() {
          return k(ks(this.Zx), hB)
        }
        ;
        S.prototype.set_m_materials = S.prototype.YC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ls(c, a)
        }
        ;
        Object.defineProperty(S.prototype, "m_materials", {
          get: S.prototype.rA,
          set: S.prototype.YC
        });
        S.prototype.get_m_anchors = S.prototype.mz = function() {
          return k(ms(this.Zx), IB)
        }
        ;
        S.prototype.set_m_anchors = S.prototype.UB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ns(c, a)
        }
        ;
        Object.defineProperty(S.prototype, "m_anchors", {
          get: S.prototype.mz,
          set: S.prototype.UB
        });
        S.prototype.__destroy__ = function() {
          ps(this.Zx)
        }
        ;
        function LB() {
          throw "cannot construct a btIntArray, no constructor in IDL";
        }
        LB.prototype = Object.create(g.prototype);
        LB.prototype.constructor = LB;
        LB.prototype.$x = LB;
        LB.ay = {};
        b.btIntArray = LB;
        LB.prototype.size = LB.prototype.size = function() {
          return qs(this.Zx)
        }
        ;
        LB.prototype.at = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return rs(c, a)
        }
        ;
        LB.prototype.__destroy__ = function() {
          ss(this.Zx)
        }
        ;
        function T() {
          throw "cannot construct a Config, no constructor in IDL";
        }
        T.prototype = Object.create(g.prototype);
        T.prototype.constructor = T;
        T.prototype.$x = T;
        T.ay = {};
        b.Config = T;
        T.prototype.get_kVCF = T.prototype.fz = function() {
          return ts(this.Zx)
        }
        ;
        T.prototype.set_kVCF = T.prototype.NB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          us(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "kVCF", {
          get: T.prototype.fz,
          set: T.prototype.NB
        });
        T.prototype.get_kDP = T.prototype.Ty = function() {
          return vs(this.Zx)
        }
        ;
        T.prototype.set_kDP = T.prototype.AB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          xs(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "kDP", {
          get: T.prototype.Ty,
          set: T.prototype.AB
        });
        T.prototype.get_kDG = T.prototype.Sy = function() {
          return ys(this.Zx)
        }
        ;
        T.prototype.set_kDG = T.prototype.zB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          zs(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "kDG", {
          get: T.prototype.Sy,
          set: T.prototype.zB
        });
        T.prototype.get_kLF = T.prototype.Vy = function() {
          return As(this.Zx)
        }
        ;
        T.prototype.set_kLF = T.prototype.CB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Bs(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "kLF", {
          get: T.prototype.Vy,
          set: T.prototype.CB
        });
        T.prototype.get_kPR = T.prototype.Xy = function() {
          return Cs(this.Zx)
        }
        ;
        T.prototype.set_kPR = T.prototype.EB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ds(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "kPR", {
          get: T.prototype.Xy,
          set: T.prototype.EB
        });
        T.prototype.get_kVC = T.prototype.ez = function() {
          return Es(this.Zx)
        }
        ;
        T.prototype.set_kVC = T.prototype.MB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Fs(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "kVC", {
          get: T.prototype.ez,
          set: T.prototype.MB
        });
        T.prototype.get_kDF = T.prototype.Ry = function() {
          return Gs(this.Zx)
        }
        ;
        T.prototype.set_kDF = T.prototype.yB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Hs(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "kDF", {
          get: T.prototype.Ry,
          set: T.prototype.yB
        });
        T.prototype.get_kMT = T.prototype.Wy = function() {
          return Is(this.Zx)
        }
        ;
        T.prototype.set_kMT = T.prototype.DB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Js(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "kMT", {
          get: T.prototype.Wy,
          set: T.prototype.DB
        });
        T.prototype.get_kCHR = T.prototype.Qy = function() {
          return Ks(this.Zx)
        }
        ;
        T.prototype.set_kCHR = T.prototype.xB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ls(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "kCHR", {
          get: T.prototype.Qy,
          set: T.prototype.xB
        });
        T.prototype.get_kKHR = T.prototype.Uy = function() {
          return Ms(this.Zx)
        }
        ;
        T.prototype.set_kKHR = T.prototype.BB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ns(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "kKHR", {
          get: T.prototype.Uy,
          set: T.prototype.BB
        });
        T.prototype.get_kSHR = T.prototype.Yy = function() {
          return Os(this.Zx)
        }
        ;
        T.prototype.set_kSHR = T.prototype.FB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ps(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "kSHR", {
          get: T.prototype.Yy,
          set: T.prototype.FB
        });
        T.prototype.get_kAHR = T.prototype.Py = function() {
          return Qs(this.Zx)
        }
        ;
        T.prototype.set_kAHR = T.prototype.wB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Rs(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "kAHR", {
          get: T.prototype.Py,
          set: T.prototype.wB
        });
        T.prototype.get_kSRHR_CL = T.prototype.az = function() {
          return Ss(this.Zx)
        }
        ;
        T.prototype.set_kSRHR_CL = T.prototype.IB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ts(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "kSRHR_CL", {
          get: T.prototype.az,
          set: T.prototype.IB
        });
        T.prototype.get_kSKHR_CL = T.prototype.Zy = function() {
          return Us(this.Zx)
        }
        ;
        T.prototype.set_kSKHR_CL = T.prototype.GB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Vs(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "kSKHR_CL", {
          get: T.prototype.Zy,
          set: T.prototype.GB
        });
        T.prototype.get_kSSHR_CL = T.prototype.cz = function() {
          return Ws(this.Zx)
        }
        ;
        T.prototype.set_kSSHR_CL = T.prototype.KB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Xs(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "kSSHR_CL", {
          get: T.prototype.cz,
          set: T.prototype.KB
        });
        T.prototype.get_kSR_SPLT_CL = T.prototype.bz = function() {
          return Ys(this.Zx)
        }
        ;
        T.prototype.set_kSR_SPLT_CL = T.prototype.JB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Zs(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "kSR_SPLT_CL", {
          get: T.prototype.bz,
          set: T.prototype.JB
        });
        T.prototype.get_kSK_SPLT_CL = T.prototype.$y = function() {
          return $s(this.Zx)
        }
        ;
        T.prototype.set_kSK_SPLT_CL = T.prototype.HB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          at(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "kSK_SPLT_CL", {
          get: T.prototype.$y,
          set: T.prototype.HB
        });
        T.prototype.get_kSS_SPLT_CL = T.prototype.dz = function() {
          return bt(this.Zx)
        }
        ;
        T.prototype.set_kSS_SPLT_CL = T.prototype.LB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ct(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "kSS_SPLT_CL", {
          get: T.prototype.dz,
          set: T.prototype.LB
        });
        T.prototype.get_maxvolume = T.prototype.lB = function() {
          return dt(this.Zx)
        }
        ;
        T.prototype.set_maxvolume = T.prototype.SD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          et(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "maxvolume", {
          get: T.prototype.lB,
          set: T.prototype.SD
        });
        T.prototype.get_timescale = T.prototype.nB = function() {
          return ft(this.Zx)
        }
        ;
        T.prototype.set_timescale = T.prototype.UD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          gt(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "timescale", {
          get: T.prototype.nB,
          set: T.prototype.UD
        });
        T.prototype.get_viterations = T.prototype.oB = function() {
          return ht(this.Zx)
        }
        ;
        T.prototype.set_viterations = T.prototype.VD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          it(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "viterations", {
          get: T.prototype.oB,
          set: T.prototype.VD
        });
        T.prototype.get_piterations = T.prototype.mB = function() {
          return jt(this.Zx)
        }
        ;
        T.prototype.set_piterations = T.prototype.TD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          kt(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "piterations", {
          get: T.prototype.mB,
          set: T.prototype.TD
        });
        T.prototype.get_diterations = T.prototype.Oy = function() {
          return lt(this.Zx)
        }
        ;
        T.prototype.set_diterations = T.prototype.vB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          mt(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "diterations", {
          get: T.prototype.Oy,
          set: T.prototype.vB
        });
        T.prototype.get_citerations = T.prototype.My = function() {
          return nt(this.Zx)
        }
        ;
        T.prototype.set_citerations = T.prototype.tB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ot(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "citerations", {
          get: T.prototype.My,
          set: T.prototype.tB
        });
        T.prototype.get_collisions = T.prototype.Ny = function() {
          return pt(this.Zx)
        }
        ;
        T.prototype.set_collisions = T.prototype.uB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          qt(c, a)
        }
        ;
        Object.defineProperty(T.prototype, "collisions", {
          get: T.prototype.Ny,
          set: T.prototype.uB
        });
        T.prototype.__destroy__ = function() {
          rt(this.Zx)
        }
        ;
        function Node() {
          throw "cannot construct a Node, no constructor in IDL";
        }
        Node.prototype = Object.create(g.prototype);
        Node.prototype.constructor = Node;
        Node.prototype.$x = Node;
        Node.ay = {};
        b.Node = Node;
        Node.prototype.get_m_x = Node.prototype.kB = function() {
          return k(st(this.Zx), p)
        }
        ;
        Node.prototype.set_m_x = Node.prototype.RD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          tt(c, a)
        }
        ;
        Object.defineProperty(Node.prototype, "m_x", {
          get: Node.prototype.kB,
          set: Node.prototype.RD
        });
        Node.prototype.get_m_q = Node.prototype.CA = function() {
          return k(ut(this.Zx), p)
        }
        ;
        Node.prototype.set_m_q = Node.prototype.iD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          vt(c, a)
        }
        ;
        Object.defineProperty(Node.prototype, "m_q", {
          get: Node.prototype.CA,
          set: Node.prototype.iD
        });
        Node.prototype.get_m_v = Node.prototype.cB = function() {
          return k(wt(this.Zx), p)
        }
        ;
        Node.prototype.set_m_v = Node.prototype.JD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          xt(c, a)
        }
        ;
        Object.defineProperty(Node.prototype, "m_v", {
          get: Node.prototype.cB,
          set: Node.prototype.JD
        });
        Node.prototype.get_m_f = Node.prototype.Pz = function() {
          return k(yt(this.Zx), p)
        }
        ;
        Node.prototype.set_m_f = Node.prototype.vC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          zt(c, a)
        }
        ;
        Object.defineProperty(Node.prototype, "m_f", {
          get: Node.prototype.Pz,
          set: Node.prototype.vC
        });
        Node.prototype.get_m_n = Node.prototype.tA = function() {
          return k(At(this.Zx), p)
        }
        ;
        Node.prototype.set_m_n = Node.prototype.$C = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Bt(c, a)
        }
        ;
        Object.defineProperty(Node.prototype, "m_n", {
          get: Node.prototype.tA,
          set: Node.prototype.$C
        });
        Node.prototype.get_m_im = Node.prototype.dA = function() {
          return Ct(this.Zx)
        }
        ;
        Node.prototype.set_m_im = Node.prototype.KC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Dt(c, a)
        }
        ;
        Object.defineProperty(Node.prototype, "m_im", {
          get: Node.prototype.dA,
          set: Node.prototype.KC
        });
        Node.prototype.get_m_area = Node.prototype.pz = function() {
          return Et(this.Zx)
        }
        ;
        Node.prototype.set_m_area = Node.prototype.XB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ft(c, a)
        }
        ;
        Object.defineProperty(Node.prototype, "m_area", {
          get: Node.prototype.pz,
          set: Node.prototype.XB
        });
        Node.prototype.__destroy__ = function() {
          Gt(this.Zx)
        }
        ;
        function MB() {
          this.Zx = Ht();
          h(MB)[this.Zx] = this
        }
        MB.prototype = Object.create(g.prototype);
        MB.prototype.constructor = MB;
        MB.prototype.$x = MB;
        MB.ay = {};
        b.btGhostPairCallback = MB;
        MB.prototype.__destroy__ = function() {
          It(this.Zx)
        }
        ;
        function NB() {
          throw "cannot construct a btOverlappingPairCallback, no constructor in IDL";
        }
        NB.prototype = Object.create(g.prototype);
        NB.prototype.constructor = NB;
        NB.prototype.$x = NB;
        NB.ay = {};
        b.btOverlappingPairCallback = NB;
        NB.prototype.__destroy__ = function() {
          Jt(this.Zx)
        }
        ;
        function U(a, c, d, e) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          this.Zx = void 0 === e ? Kt(a, c, d) : Lt(a, c, d, e);
          h(U)[this.Zx] = this
        }
        U.prototype = Object.create(QA.prototype);
        U.prototype.constructor = U;
        U.prototype.$x = U;
        U.ay = {};
        b.btKinematicCharacterController = U;
        U.prototype.setUpAxis = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Mt(c, a)
        }
        ;
        U.prototype.setWalkDirection = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Nt(c, a)
        }
        ;
        U.prototype.setVelocityForTimeInterval = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Ot(d, a, c)
        }
        ;
        U.prototype.warp = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Pt(c, a)
        }
        ;
        U.prototype.preStep = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Qt(c, a)
        }
        ;
        U.prototype.playerStep = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Rt(d, a, c)
        }
        ;
        U.prototype.setFallSpeed = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          St(c, a)
        }
        ;
        U.prototype.setJumpSpeed = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Tt(c, a)
        }
        ;
        U.prototype.setMaxJumpHeight = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ut(c, a)
        }
        ;
        U.prototype.canJump = function() {
          return !!Vt(this.Zx)
        }
        ;
        U.prototype.jump = function() {
          Wt(this.Zx)
        }
        ;
        U.prototype.setGravity = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Xt(c, a)
        }
        ;
        U.prototype.getGravity = function() {
          return Yt(this.Zx)
        }
        ;
        U.prototype.setMaxSlope = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Zt(c, a)
        }
        ;
        U.prototype.getMaxSlope = function() {
          return $t(this.Zx)
        }
        ;
        U.prototype.getGhostObject = function() {
          return k(au(this.Zx), V)
        }
        ;
        U.prototype.setUseGhostSweepTest = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          bu(c, a)
        }
        ;
        U.prototype.onGround = function() {
          return !!cu(this.Zx)
        }
        ;
        U.prototype.setUpInterpolate = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          du(c, a)
        }
        ;
        U.prototype.updateAction = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          eu(d, a, c)
        }
        ;
        U.prototype.__destroy__ = function() {
          fu(this.Zx)
        }
        ;
        function OB() {
          throw "cannot construct a btSoftBodyArray, no constructor in IDL";
        }
        OB.prototype = Object.create(g.prototype);
        OB.prototype.constructor = OB;
        OB.prototype.$x = OB;
        OB.ay = {};
        b.btSoftBodyArray = OB;
        OB.prototype.size = OB.prototype.size = function() {
          return gu(this.Zx)
        }
        ;
        OB.prototype.at = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(hu(c, a), S)
        }
        ;
        OB.prototype.__destroy__ = function() {
          iu(this.Zx)
        }
        ;
        function GB() {
          throw "cannot construct a btFaceArray, no constructor in IDL";
        }
        GB.prototype = Object.create(g.prototype);
        GB.prototype.constructor = GB;
        GB.prototype.$x = GB;
        GB.ay = {};
        b.btFaceArray = GB;
        GB.prototype.size = GB.prototype.size = function() {
          return ju(this.Zx)
        }
        ;
        GB.prototype.at = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(ku(c, a), PB)
        }
        ;
        GB.prototype.__destroy__ = function() {
          lu(this.Zx)
        }
        ;
        function QB(a, c) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          this.Zx = mu(a, c);
          h(QB)[this.Zx] = this
        }
        QB.prototype = Object.create(LA.prototype);
        QB.prototype.constructor = QB;
        QB.prototype.$x = QB;
        QB.ay = {};
        b.btStaticPlaneShape = QB;
        QB.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          nu(c, a)
        }
        ;
        QB.prototype.getLocalScaling = function() {
          return k(ou(this.Zx), p)
        }
        ;
        QB.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          pu(d, a, c)
        }
        ;
        QB.prototype.__destroy__ = function() {
          qu(this.Zx)
        }
        ;
        function GA() {
          throw "cannot construct a btOverlappingPairCache, no constructor in IDL";
        }
        GA.prototype = Object.create(g.prototype);
        GA.prototype.constructor = GA;
        GA.prototype.$x = GA;
        GA.ay = {};
        b.btOverlappingPairCache = GA;
        GA.prototype.setInternalGhostPairCallback = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ru(c, a)
        }
        ;
        GA.prototype.getNumOverlappingPairs = function() {
          return su(this.Zx)
        }
        ;
        GA.prototype.__destroy__ = function() {
          tu(this.Zx)
        }
        ;
        function mB() {
          throw "cannot construct a btIndexedMesh, no constructor in IDL";
        }
        mB.prototype = Object.create(g.prototype);
        mB.prototype.constructor = mB;
        mB.prototype.$x = mB;
        mB.ay = {};
        b.btIndexedMesh = mB;
        mB.prototype.get_m_numTriangles = mB.prototype.yA = function() {
          return uu(this.Zx)
        }
        ;
        mB.prototype.set_m_numTriangles = mB.prototype.eD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          vu(c, a)
        }
        ;
        Object.defineProperty(mB.prototype, "m_numTriangles", {
          get: mB.prototype.yA,
          set: mB.prototype.eD
        });
        mB.prototype.__destroy__ = function() {
          wu(this.Zx)
        }
        ;
        function W(a, c, d, e, f) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          this.Zx = xu(a, c, d, e, f);
          h(W)[this.Zx] = this
        }
        W.prototype = Object.create(x.prototype);
        W.prototype.constructor = W;
        W.prototype.$x = W;
        W.ay = {};
        b.btSoftRigidDynamicsWorld = W;
        W.prototype.addSoftBody = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          yu(e, a, c, d)
        }
        ;
        W.prototype.removeSoftBody = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          zu(c, a)
        }
        ;
        W.prototype.removeCollisionObject = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Au(c, a)
        }
        ;
        W.prototype.getWorldInfo = function() {
          return k(Bu(this.Zx), J)
        }
        ;
        W.prototype.getSoftBodyArray = function() {
          return k(Cu(this.Zx), OB)
        }
        ;
        W.prototype.getDispatcher = function() {
          return k(Du(this.Zx), FA)
        }
        ;
        W.prototype.rayTest = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          Eu(e, a, c, d)
        }
        ;
        W.prototype.getPairCache = function() {
          return k(Fu(this.Zx), GA)
        }
        ;
        W.prototype.getDispatchInfo = function() {
          return k(Gu(this.Zx), l)
        }
        ;
        W.prototype.addCollisionObject = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          void 0 === c ? Hu(e, a) : void 0 === d ? Iu(e, a, c) : Ju(e, a, c, d)
        }
        ;
        W.prototype.getBroadphase = function() {
          return k(Ku(this.Zx), HA)
        }
        ;
        W.prototype.convexSweepTest = function(a, c, d, e, f) {
          var m = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          Lu(m, a, c, d, e, f)
        }
        ;
        W.prototype.contactPairTest = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          Mu(e, a, c, d)
        }
        ;
        W.prototype.contactTest = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Nu(d, a, c)
        }
        ;
        W.prototype.updateSingleAabb = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ou(c, a)
        }
        ;
        W.prototype.setDebugDrawer = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Pu(c, a)
        }
        ;
        W.prototype.getDebugDrawer = function() {
          return k(Qu(this.Zx), IA)
        }
        ;
        W.prototype.debugDrawWorld = function() {
          Ru(this.Zx)
        }
        ;
        W.prototype.debugDrawObject = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          Su(e, a, c, d)
        }
        ;
        W.prototype.setGravity = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Tu(c, a)
        }
        ;
        W.prototype.getGravity = function() {
          return k(Uu(this.Zx), p)
        }
        ;
        W.prototype.addRigidBody = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          void 0 === c ? Vu(e, a) : void 0 === d ? _emscripten_bind_btSoftRigidDynamicsWorld_addRigidBody_2(e, a, c) : Wu(e, a, c, d)
        }
        ;
        W.prototype.removeRigidBody = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Xu(c, a)
        }
        ;
        W.prototype.addConstraint = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          void 0 === c ? Yu(d, a) : Zu(d, a, c)
        }
        ;
        W.prototype.removeConstraint = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          $u(c, a)
        }
        ;
        W.prototype.stepSimulation = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          return void 0 === c ? av(e, a) : void 0 === d ? bv(e, a, c) : cv(e, a, c, d)
        }
        ;
        W.prototype.setContactAddedCallback = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          dv(c, a)
        }
        ;
        W.prototype.setContactProcessedCallback = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ev(c, a)
        }
        ;
        W.prototype.setContactDestroyedCallback = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          fv(c, a)
        }
        ;
        W.prototype.addAction = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          gv(c, a)
        }
        ;
        W.prototype.removeAction = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          hv(c, a)
        }
        ;
        W.prototype.getSolverInfo = function() {
          return k(iv(this.Zx), v)
        }
        ;
        W.prototype.setInternalTickCallback = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          void 0 === c ? jv(e, a) : void 0 === d ? kv(e, a, c) : lv(e, a, c, d)
        }
        ;
        W.prototype.__destroy__ = function() {
          mv(this.Zx)
        }
        ;
        function RB(a, c, d, e) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          this.Zx = nv(a, c, d, e);
          h(RB)[this.Zx] = this
        }
        RB.prototype = Object.create(KA.prototype);
        RB.prototype.constructor = RB;
        RB.prototype.$x = RB;
        RB.ay = {};
        b.btFixedConstraint = RB;
        RB.prototype.enableFeedback = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ov(c, a)
        }
        ;
        RB.prototype.getBreakingImpulseThreshold = function() {
          return pv(this.Zx)
        }
        ;
        RB.prototype.setBreakingImpulseThreshold = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          qv(c, a)
        }
        ;
        RB.prototype.getParam = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          return rv(d, a, c)
        }
        ;
        RB.prototype.setParam = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          sv(e, a, c, d)
        }
        ;
        RB.prototype.__destroy__ = function() {
          tv(this.Zx)
        }
        ;
        function r(a, c) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          this.Zx = void 0 === a ? uv() : void 0 === c ? _emscripten_bind_btTransform_btTransform_1(a) : vv(a, c);
          h(r)[this.Zx] = this
        }
        r.prototype = Object.create(g.prototype);
        r.prototype.constructor = r;
        r.prototype.$x = r;
        r.ay = {};
        b.btTransform = r;
        r.prototype.setIdentity = function() {
          wv(this.Zx)
        }
        ;
        r.prototype.setOrigin = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          xv(c, a)
        }
        ;
        r.prototype.setRotation = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          yv(c, a)
        }
        ;
        r.prototype.getOrigin = function() {
          return k(zv(this.Zx), p)
        }
        ;
        r.prototype.getRotation = function() {
          return k(Av(this.Zx), X)
        }
        ;
        r.prototype.getBasis = function() {
          return k(Bv(this.Zx), aB)
        }
        ;
        r.prototype.setFromOpenGLMatrix = function(a) {
          var c = this.Zx;
          zA();
          "object" == typeof a && (a = DA(a));
          Cv(c, a)
        }
        ;
        r.prototype.inverse = r.prototype.inverse = function() {
          return k(Dv(this.Zx), r)
        }
        ;
        r.prototype.op_mul = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(Ev(c, a), r)
        }
        ;
        r.prototype.__destroy__ = function() {
          Fv(this.Zx)
        }
        ;
        function Y(a, c) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          this.Zx = Gv(a, c);
          h(Y)[this.Zx] = this
        }
        Y.prototype = Object.create(z.prototype);
        Y.prototype.constructor = Y;
        Y.prototype.$x = Y;
        Y.ay = {};
        b.ClosestRayResultCallback = Y;
        Y.prototype.hasHit = function() {
          return !!Hv(this.Zx)
        }
        ;
        Y.prototype.get_m_rayFromWorld = Y.prototype.xy = function() {
          return k(Iv(this.Zx), p)
        }
        ;
        Y.prototype.set_m_rayFromWorld = Y.prototype.Ey = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Jv(c, a)
        }
        ;
        Object.defineProperty(Y.prototype, "m_rayFromWorld", {
          get: Y.prototype.xy,
          set: Y.prototype.Ey
        });
        Y.prototype.get_m_rayToWorld = Y.prototype.yy = function() {
          return k(Kv(this.Zx), p)
        }
        ;
        Y.prototype.set_m_rayToWorld = Y.prototype.Fy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Lv(c, a)
        }
        ;
        Object.defineProperty(Y.prototype, "m_rayToWorld", {
          get: Y.prototype.yy,
          set: Y.prototype.Fy
        });
        Y.prototype.get_m_hitNormalWorld = Y.prototype.jy = function() {
          return k(Mv(this.Zx), p)
        }
        ;
        Y.prototype.set_m_hitNormalWorld = Y.prototype.qy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Nv(c, a)
        }
        ;
        Object.defineProperty(Y.prototype, "m_hitNormalWorld", {
          get: Y.prototype.jy,
          set: Y.prototype.qy
        });
        Y.prototype.get_m_hitPointWorld = Y.prototype.ky = function() {
          return k(Ov(this.Zx), p)
        }
        ;
        Y.prototype.set_m_hitPointWorld = Y.prototype.ry = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Pv(c, a)
        }
        ;
        Object.defineProperty(Y.prototype, "m_hitPointWorld", {
          get: Y.prototype.ky,
          set: Y.prototype.ry
        });
        Y.prototype.get_m_collisionFilterGroup = Y.prototype.by = function() {
          return Qv(this.Zx)
        }
        ;
        Y.prototype.set_m_collisionFilterGroup = Y.prototype.dy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Rv(c, a)
        }
        ;
        Object.defineProperty(Y.prototype, "m_collisionFilterGroup", {
          get: Y.prototype.by,
          set: Y.prototype.dy
        });
        Y.prototype.get_m_collisionFilterMask = Y.prototype.cy = function() {
          return Sv(this.Zx)
        }
        ;
        Y.prototype.set_m_collisionFilterMask = Y.prototype.ey = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Tv(c, a)
        }
        ;
        Object.defineProperty(Y.prototype, "m_collisionFilterMask", {
          get: Y.prototype.cy,
          set: Y.prototype.ey
        });
        Y.prototype.get_m_closestHitFraction = Y.prototype.fy = function() {
          return Uv(this.Zx)
        }
        ;
        Y.prototype.set_m_closestHitFraction = Y.prototype.gy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Vv(c, a)
        }
        ;
        Object.defineProperty(Y.prototype, "m_closestHitFraction", {
          get: Y.prototype.fy,
          set: Y.prototype.gy
        });
        Y.prototype.get_m_collisionObject = Y.prototype.hy = function() {
          return k(Wv(this.Zx), q)
        }
        ;
        Y.prototype.set_m_collisionObject = Y.prototype.oy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Xv(c, a)
        }
        ;
        Object.defineProperty(Y.prototype, "m_collisionObject", {
          get: Y.prototype.hy,
          set: Y.prototype.oy
        });
        Y.prototype.__destroy__ = function() {
          Yv(this.Zx)
        }
        ;
        function SB(a) {
          a && "object" === typeof a && (a = a.Zx);
          this.Zx = void 0 === a ? Zv() : $v(a);
          h(SB)[this.Zx] = this
        }
        SB.prototype = Object.create(NA.prototype);
        SB.prototype.constructor = SB;
        SB.prototype.$x = SB;
        SB.ay = {};
        b.btSoftBodyRigidBodyCollisionConfiguration = SB;
        SB.prototype.__destroy__ = function() {
          aw(this.Zx)
        }
        ;
        function TB() {
          this.Zx = bw();
          h(TB)[this.Zx] = this
        }
        TB.prototype = Object.create(ZA.prototype);
        TB.prototype.constructor = TB;
        TB.prototype.$x = TB;
        TB.ay = {};
        b.ConcreteContactResultCallback = TB;
        TB.prototype.addSingleResult = function(a, c, d, e, f, m, C) {
          var P = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          m && "object" === typeof m && (m = m.Zx);
          C && "object" === typeof C && (C = C.Zx);
          return cw(P, a, c, d, e, f, m, C)
        }
        ;
        TB.prototype.__destroy__ = function() {
          dw(this.Zx)
        }
        ;
        function UB(a, c, d) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          this.Zx = void 0 === d ? ew(a, c) : fw(a, c, d);
          h(UB)[this.Zx] = this
        }
        UB.prototype = Object.create(OA.prototype);
        UB.prototype.constructor = UB;
        UB.prototype.$x = UB;
        UB.ay = {};
        b.btBvhTriangleMeshShape = UB;
        UB.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          gw(c, a)
        }
        ;
        UB.prototype.getLocalScaling = function() {
          return k(hw(this.Zx), p)
        }
        ;
        UB.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          iw(d, a, c)
        }
        ;
        UB.prototype.__destroy__ = function() {
          jw(this.Zx)
        }
        ;
        function fB() {
          throw "cannot construct a btConstCollisionObjectArray, no constructor in IDL";
        }
        fB.prototype = Object.create(g.prototype);
        fB.prototype.constructor = fB;
        fB.prototype.$x = fB;
        fB.ay = {};
        b.btConstCollisionObjectArray = fB;
        fB.prototype.size = fB.prototype.size = function() {
          return kw(this.Zx)
        }
        ;
        fB.prototype.at = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(lw(c, a), q)
        }
        ;
        fB.prototype.__destroy__ = function() {
          mw(this.Zx)
        }
        ;
        function VB(a, c, d, e, f) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          this.Zx = void 0 === e ? nw(a, c, d) : void 0 === f ? _emscripten_bind_btSliderConstraint_btSliderConstraint_4(a, c, d, e) : ow(a, c, d, e, f);
          h(VB)[this.Zx] = this
        }
        VB.prototype = Object.create(KA.prototype);
        VB.prototype.constructor = VB;
        VB.prototype.$x = VB;
        VB.ay = {};
        b.btSliderConstraint = VB;
        VB.prototype.setLowerLinLimit = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          pw(c, a)
        }
        ;
        VB.prototype.setUpperLinLimit = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          qw(c, a)
        }
        ;
        VB.prototype.setLowerAngLimit = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          rw(c, a)
        }
        ;
        VB.prototype.setUpperAngLimit = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          sw(c, a)
        }
        ;
        VB.prototype.enableFeedback = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          tw(c, a)
        }
        ;
        VB.prototype.getBreakingImpulseThreshold = function() {
          return uw(this.Zx)
        }
        ;
        VB.prototype.setBreakingImpulseThreshold = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          vw(c, a)
        }
        ;
        VB.prototype.getParam = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          return ww(d, a, c)
        }
        ;
        VB.prototype.setParam = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          xw(e, a, c, d)
        }
        ;
        VB.prototype.__destroy__ = function() {
          yw(this.Zx)
        }
        ;
        function V() {
          this.Zx = zw();
          h(V)[this.Zx] = this
        }
        V.prototype = Object.create(w.prototype);
        V.prototype.constructor = V;
        V.prototype.$x = V;
        V.ay = {};
        b.btPairCachingGhostObject = V;
        V.prototype.setAnisotropicFriction = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Aw(d, a, c)
        }
        ;
        V.prototype.getCollisionShape = function() {
          return k(Bw(this.Zx), n)
        }
        ;
        V.prototype.setContactProcessingThreshold = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Cw(c, a)
        }
        ;
        V.prototype.setActivationState = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Dw(c, a)
        }
        ;
        V.prototype.forceActivationState = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ew(c, a)
        }
        ;
        V.prototype.activate = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          void 0 === a ? Fw(c) : Gw(c, a)
        }
        ;
        V.prototype.isActive = function() {
          return !!Hw(this.Zx)
        }
        ;
        V.prototype.isKinematicObject = function() {
          return !!Iw(this.Zx)
        }
        ;
        V.prototype.isStaticObject = function() {
          return !!Jw(this.Zx)
        }
        ;
        V.prototype.isStaticOrKinematicObject = function() {
          return !!Kw(this.Zx)
        }
        ;
        V.prototype.getRestitution = function() {
          return Lw(this.Zx)
        }
        ;
        V.prototype.getFriction = function() {
          return Mw(this.Zx)
        }
        ;
        V.prototype.getRollingFriction = function() {
          return Nw(this.Zx)
        }
        ;
        V.prototype.setRestitution = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ow(c, a)
        }
        ;
        V.prototype.setFriction = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Pw(c, a)
        }
        ;
        V.prototype.setRollingFriction = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Qw(c, a)
        }
        ;
        V.prototype.getWorldTransform = function() {
          return k(Rw(this.Zx), r)
        }
        ;
        V.prototype.getCollisionFlags = function() {
          return Sw(this.Zx)
        }
        ;
        V.prototype.setCollisionFlags = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Tw(c, a)
        }
        ;
        V.prototype.setWorldTransform = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Uw(c, a)
        }
        ;
        V.prototype.setCollisionShape = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Vw(c, a)
        }
        ;
        V.prototype.setCcdMotionThreshold = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ww(c, a)
        }
        ;
        V.prototype.setCcdSweptSphereRadius = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Xw(c, a)
        }
        ;
        V.prototype.getUserIndex = function() {
          return Yw(this.Zx)
        }
        ;
        V.prototype.setUserIndex = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Zw(c, a)
        }
        ;
        V.prototype.getUserPointer = function() {
          return k($w(this.Zx), JA)
        }
        ;
        V.prototype.setUserPointer = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ax(c, a)
        }
        ;
        V.prototype.getBroadphaseHandle = function() {
          return k(bx(this.Zx), t)
        }
        ;
        V.prototype.getNumOverlappingObjects = function() {
          return cx(this.Zx)
        }
        ;
        V.prototype.getOverlappingObject = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(dx(c, a), q)
        }
        ;
        V.prototype.__destroy__ = function() {
          ex(this.Zx)
        }
        ;
        function E() {
          throw "cannot construct a btManifoldPoint, no constructor in IDL";
        }
        E.prototype = Object.create(g.prototype);
        E.prototype.constructor = E;
        E.prototype.$x = E;
        E.ay = {};
        b.btManifoldPoint = E;
        E.prototype.getPositionWorldOnA = function() {
          return k(fx(this.Zx), p)
        }
        ;
        E.prototype.getPositionWorldOnB = function() {
          return k(gx(this.Zx), p)
        }
        ;
        E.prototype.getAppliedImpulse = function() {
          return hx(this.Zx)
        }
        ;
        E.prototype.getDistance = function() {
          return ix(this.Zx)
        }
        ;
        E.prototype.get_m_localPointA = E.prototype.oA = function() {
          return k(jx(this.Zx), p)
        }
        ;
        E.prototype.set_m_localPointA = E.prototype.VC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          kx(c, a)
        }
        ;
        Object.defineProperty(E.prototype, "m_localPointA", {
          get: E.prototype.oA,
          set: E.prototype.VC
        });
        E.prototype.get_m_localPointB = E.prototype.pA = function() {
          return k(lx(this.Zx), p)
        }
        ;
        E.prototype.set_m_localPointB = E.prototype.WC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          mx(c, a)
        }
        ;
        Object.defineProperty(E.prototype, "m_localPointB", {
          get: E.prototype.pA,
          set: E.prototype.WC
        });
        E.prototype.get_m_positionWorldOnB = E.prototype.BA = function() {
          return k(nx(this.Zx), p)
        }
        ;
        E.prototype.set_m_positionWorldOnB = E.prototype.hD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ox(c, a)
        }
        ;
        Object.defineProperty(E.prototype, "m_positionWorldOnB", {
          get: E.prototype.BA,
          set: E.prototype.hD
        });
        E.prototype.get_m_positionWorldOnA = E.prototype.AA = function() {
          return k(px(this.Zx), p)
        }
        ;
        E.prototype.set_m_positionWorldOnA = E.prototype.gD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          qx(c, a)
        }
        ;
        Object.defineProperty(E.prototype, "m_positionWorldOnA", {
          get: E.prototype.AA,
          set: E.prototype.gD
        });
        E.prototype.get_m_normalWorldOnB = E.prototype.wA = function() {
          return k(rx(this.Zx), p)
        }
        ;
        E.prototype.set_m_normalWorldOnB = E.prototype.cD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          sx(c, a)
        }
        ;
        Object.defineProperty(E.prototype, "m_normalWorldOnB", {
          get: E.prototype.wA,
          set: E.prototype.cD
        });
        E.prototype.get_m_userPersistentData = E.prototype.bB = function() {
          return tx(this.Zx)
        }
        ;
        E.prototype.set_m_userPersistentData = E.prototype.ID = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ux(c, a)
        }
        ;
        Object.defineProperty(E.prototype, "m_userPersistentData", {
          get: E.prototype.bB,
          set: E.prototype.ID
        });
        E.prototype.__destroy__ = function() {
          vx(this.Zx)
        }
        ;
        function WB(a, c, d, e) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          this.Zx = void 0 === d ? wx(a, c) : void 0 === e ? _emscripten_bind_btPoint2PointConstraint_btPoint2PointConstraint_3(a, c, d) : xx(a, c, d, e);
          h(WB)[this.Zx] = this
        }
        WB.prototype = Object.create(KA.prototype);
        WB.prototype.constructor = WB;
        WB.prototype.$x = WB;
        WB.ay = {};
        b.btPoint2PointConstraint = WB;
        WB.prototype.setPivotA = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          yx(c, a)
        }
        ;
        WB.prototype.setPivotB = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          zx(c, a)
        }
        ;
        WB.prototype.getPivotInA = function() {
          return k(Ax(this.Zx), p)
        }
        ;
        WB.prototype.getPivotInB = function() {
          return k(Bx(this.Zx), p)
        }
        ;
        WB.prototype.enableFeedback = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Cx(c, a)
        }
        ;
        WB.prototype.getBreakingImpulseThreshold = function() {
          return Dx(this.Zx)
        }
        ;
        WB.prototype.setBreakingImpulseThreshold = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ex(c, a)
        }
        ;
        WB.prototype.getParam = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          return Fx(d, a, c)
        }
        ;
        WB.prototype.setParam = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          Gx(e, a, c, d)
        }
        ;
        WB.prototype.get_m_setting = WB.prototype.IA = function() {
          return k(Hx(this.Zx), H)
        }
        ;
        WB.prototype.set_m_setting = WB.prototype.oD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ix(c, a)
        }
        ;
        Object.defineProperty(WB.prototype, "m_setting", {
          get: WB.prototype.IA,
          set: WB.prototype.oD
        });
        WB.prototype.__destroy__ = function() {
          Jx(this.Zx)
        }
        ;
        function XB() {
          this.Zx = Kx();
          h(XB)[this.Zx] = this
        }
        XB.prototype = Object.create(g.prototype);
        XB.prototype.constructor = XB;
        XB.prototype.$x = XB;
        XB.ay = {};
        b.btSoftBodyHelpers = XB;
        XB.prototype.CreateRope = function(a, c, d, e, f) {
          var m = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          return k(Lx(m, a, c, d, e, f), S)
        }
        ;
        XB.prototype.CreatePatch = function(a, c, d, e, f, m, C, P, ia) {
          var nb = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          m && "object" === typeof m && (m = m.Zx);
          C && "object" === typeof C && (C = C.Zx);
          P && "object" === typeof P && (P = P.Zx);
          ia && "object" === typeof ia && (ia = ia.Zx);
          return k(Mx(nb, a, c, d, e, f, m, C, P, ia), S)
        }
        ;
        XB.prototype.CreatePatchUV = function(a, c, d, e, f, m, C, P, ia, nb) {
          var Wb = this.Zx;
          zA();
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          m && "object" === typeof m && (m = m.Zx);
          C && "object" === typeof C && (C = C.Zx);
          P && "object" === typeof P && (P = P.Zx);
          ia && "object" === typeof ia && (ia = ia.Zx);
          "object" == typeof nb && (nb = DA(nb));
          return k(Nx(Wb, a, c, d, e, f, m, C, P, ia, nb), S)
        }
        ;
        XB.prototype.CreateEllipsoid = function(a, c, d, e) {
          var f = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          return k(Ox(f, a, c, d, e), S)
        }
        ;
        XB.prototype.CreateFromTriMesh = function(a, c, d, e, f) {
          var m = this.Zx;
          zA();
          a && "object" === typeof a && (a = a.Zx);
          "object" == typeof c && (c = DA(c));
          if ("object" == typeof d && "object" === typeof d) {
            var C = AA(d, Ba);
            BA(d, Ba, C);
            d = C
          }
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          return k(Px(m, a, c, d, e, f), S)
        }
        ;
        XB.prototype.CreateFromConvexHull = function(a, c, d, e) {
          var f = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          return k(Qx(f, a, c, d, e), S)
        }
        ;
        XB.prototype.__destroy__ = function() {
          Rx(this.Zx)
        }
        ;
        function t() {
          throw "cannot construct a btBroadphaseProxy, no constructor in IDL";
        }
        t.prototype = Object.create(g.prototype);
        t.prototype.constructor = t;
        t.prototype.$x = t;
        t.ay = {};
        b.btBroadphaseProxy = t;
        t.prototype.get_m_collisionFilterGroup = t.prototype.by = function() {
          return Sx(this.Zx)
        }
        ;
        t.prototype.set_m_collisionFilterGroup = t.prototype.dy = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Tx(c, a)
        }
        ;
        Object.defineProperty(t.prototype, "m_collisionFilterGroup", {
          get: t.prototype.by,
          set: t.prototype.dy
        });
        t.prototype.get_m_collisionFilterMask = t.prototype.cy = function() {
          return Ux(this.Zx)
        }
        ;
        t.prototype.set_m_collisionFilterMask = t.prototype.ey = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Vx(c, a)
        }
        ;
        Object.defineProperty(t.prototype, "m_collisionFilterMask", {
          get: t.prototype.cy,
          set: t.prototype.ey
        });
        t.prototype.__destroy__ = function() {
          Wx(this.Zx)
        }
        ;
        function KB() {
          throw "cannot construct a tNodeArray, no constructor in IDL";
        }
        KB.prototype = Object.create(g.prototype);
        KB.prototype.constructor = KB;
        KB.prototype.$x = KB;
        KB.ay = {};
        b.tNodeArray = KB;
        KB.prototype.size = KB.prototype.size = function() {
          return Xx(this.Zx)
        }
        ;
        KB.prototype.at = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(Yx(c, a), Node)
        }
        ;
        KB.prototype.__destroy__ = function() {
          Zx(this.Zx)
        }
        ;
        function YB(a) {
          a && "object" === typeof a && (a = a.Zx);
          this.Zx = $x(a);
          h(YB)[this.Zx] = this
        }
        YB.prototype = Object.create(n.prototype);
        YB.prototype.constructor = YB;
        YB.prototype.$x = YB;
        YB.ay = {};
        b.btBoxShape = YB;
        YB.prototype.setMargin = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          ay(c, a)
        }
        ;
        YB.prototype.getMargin = function() {
          return by(this.Zx)
        }
        ;
        YB.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          cy(c, a)
        }
        ;
        YB.prototype.getLocalScaling = function() {
          return k(dy(this.Zx), p)
        }
        ;
        YB.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          ey(d, a, c)
        }
        ;
        YB.prototype.__destroy__ = function() {
          fy(this.Zx)
        }
        ;
        function PB() {
          throw "cannot construct a btFace, no constructor in IDL";
        }
        PB.prototype = Object.create(g.prototype);
        PB.prototype.constructor = PB;
        PB.prototype.$x = PB;
        PB.ay = {};
        b.btFace = PB;
        PB.prototype.get_m_indices = PB.prototype.fA = function() {
          return k(gy(this.Zx), LB)
        }
        ;
        PB.prototype.set_m_indices = PB.prototype.MC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          hy(c, a)
        }
        ;
        Object.defineProperty(PB.prototype, "m_indices", {
          get: PB.prototype.fA,
          set: PB.prototype.MC
        });
        PB.prototype.get_m_plane = PB.prototype.zA = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return iy(c, a)
        }
        ;
        PB.prototype.set_m_plane = PB.prototype.fD = function(a, c) {
          var d = this.Zx;
          zA();
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          jy(d, a, c)
        }
        ;
        Object.defineProperty(PB.prototype, "m_plane", {
          get: PB.prototype.zA,
          set: PB.prototype.fD
        });
        PB.prototype.__destroy__ = function() {
          ky(this.Zx)
        }
        ;
        function ZB() {
          this.Zx = ly();
          h(ZB)[this.Zx] = this
        }
        ZB.prototype = Object.create(IA.prototype);
        ZB.prototype.constructor = ZB;
        ZB.prototype.$x = ZB;
        ZB.ay = {};
        b.DebugDrawer = ZB;
        ZB.prototype.drawLine = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          my(e, a, c, d)
        }
        ;
        ZB.prototype.drawContactPoint = function(a, c, d, e, f) {
          var m = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          ny(m, a, c, d, e, f)
        }
        ;
        ZB.prototype.reportErrorWarning = function(a) {
          var c = this.Zx;
          zA();
          a = a && "object" === typeof a ? a.Zx : CA(a);
          oy(c, a)
        }
        ;
        ZB.prototype.draw3dText = function(a, c) {
          var d = this.Zx;
          zA();
          a && "object" === typeof a && (a = a.Zx);
          c = c && "object" === typeof c ? c.Zx : CA(c);
          py(d, a, c)
        }
        ;
        ZB.prototype.setDebugMode = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          qy(c, a)
        }
        ;
        ZB.prototype.getDebugMode = function() {
          return ry(this.Zx)
        }
        ;
        ZB.prototype.__destroy__ = function() {
          sy(this.Zx)
        }
        ;
        function $B(a, c) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          this.Zx = ty(a, c);
          h($B)[this.Zx] = this
        }
        $B.prototype = Object.create(MA.prototype);
        $B.prototype.constructor = $B;
        $B.prototype.$x = $B;
        $B.ay = {};
        b.btCapsuleShapeX = $B;
        $B.prototype.setMargin = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          uy(c, a)
        }
        ;
        $B.prototype.getMargin = function() {
          return vy(this.Zx)
        }
        ;
        $B.prototype.getUpAxis = function() {
          return wy(this.Zx)
        }
        ;
        $B.prototype.getRadius = function() {
          return xy(this.Zx)
        }
        ;
        $B.prototype.getHalfHeight = function() {
          return yy(this.Zx)
        }
        ;
        $B.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          zy(c, a)
        }
        ;
        $B.prototype.getLocalScaling = function() {
          return k(Ay(this.Zx), p)
        }
        ;
        $B.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          By(d, a, c)
        }
        ;
        $B.prototype.__destroy__ = function() {
          Cy(this.Zx)
        }
        ;
        function X(a, c, d, e) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          this.Zx = Dy(a, c, d, e);
          h(X)[this.Zx] = this
        }
        X.prototype = Object.create(SA.prototype);
        X.prototype.constructor = X;
        X.prototype.$x = X;
        X.ay = {};
        b.btQuaternion = X;
        X.prototype.setValue = function(a, c, d, e) {
          var f = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          Ey(f, a, c, d, e)
        }
        ;
        X.prototype.setEulerZYX = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          Fy(e, a, c, d)
        }
        ;
        X.prototype.setRotation = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Gy(d, a, c)
        }
        ;
        X.prototype.normalize = X.prototype.normalize = function() {
          Hy(this.Zx)
        }
        ;
        X.prototype.length2 = function() {
          return Iy(this.Zx)
        }
        ;
        X.prototype.length = X.prototype.length = function() {
          return Jy(this.Zx)
        }
        ;
        X.prototype.dot = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return Ky(c, a)
        }
        ;
        X.prototype.normalized = function() {
          return k(Ly(this.Zx), X)
        }
        ;
        X.prototype.getAxis = function() {
          return k(My(this.Zx), p)
        }
        ;
        X.prototype.inverse = X.prototype.inverse = function() {
          return k(Ny(this.Zx), X)
        }
        ;
        X.prototype.getAngle = function() {
          return Oy(this.Zx)
        }
        ;
        X.prototype.getAngleShortestPath = function() {
          return Py(this.Zx)
        }
        ;
        X.prototype.angle = X.prototype.angle = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return Qy(c, a)
        }
        ;
        X.prototype.angleShortestPath = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return Ry(c, a)
        }
        ;
        X.prototype.op_add = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(Sy(c, a), X)
        }
        ;
        X.prototype.op_sub = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(Ty(c, a), X)
        }
        ;
        X.prototype.op_mul = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(Uy(c, a), X)
        }
        ;
        X.prototype.op_mulq = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(Vy(c, a), X)
        }
        ;
        X.prototype.op_div = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          return k(Wy(c, a), X)
        }
        ;
        X.prototype.x = X.prototype.x = function() {
          return Xy(this.Zx)
        }
        ;
        X.prototype.y = X.prototype.y = function() {
          return Yy(this.Zx)
        }
        ;
        X.prototype.z = X.prototype.z = function() {
          return Zy(this.Zx)
        }
        ;
        X.prototype.w = function() {
          return $y(this.Zx)
        }
        ;
        X.prototype.setX = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          az(c, a)
        }
        ;
        X.prototype.setY = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          bz(c, a)
        }
        ;
        X.prototype.setZ = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          cz(c, a)
        }
        ;
        X.prototype.setW = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          dz(c, a)
        }
        ;
        X.prototype.__destroy__ = function() {
          ez(this.Zx)
        }
        ;
        function aC(a, c) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          this.Zx = fz(a, c);
          h(aC)[this.Zx] = this
        }
        aC.prototype = Object.create(MA.prototype);
        aC.prototype.constructor = aC;
        aC.prototype.$x = aC;
        aC.ay = {};
        b.btCapsuleShapeZ = aC;
        aC.prototype.setMargin = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          gz(c, a)
        }
        ;
        aC.prototype.getMargin = function() {
          return hz(this.Zx)
        }
        ;
        aC.prototype.getUpAxis = function() {
          return iz(this.Zx)
        }
        ;
        aC.prototype.getRadius = function() {
          return jz(this.Zx)
        }
        ;
        aC.prototype.getHalfHeight = function() {
          return kz(this.Zx)
        }
        ;
        aC.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          lz(c, a)
        }
        ;
        aC.prototype.getLocalScaling = function() {
          return k(mz(this.Zx), p)
        }
        ;
        aC.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          nz(d, a, c)
        }
        ;
        aC.prototype.__destroy__ = function() {
          oz(this.Zx)
        }
        ;
        function v() {
          throw "cannot construct a btContactSolverInfo, no constructor in IDL";
        }
        v.prototype = Object.create(g.prototype);
        v.prototype.constructor = v;
        v.prototype.$x = v;
        v.ay = {};
        b.btContactSolverInfo = v;
        v.prototype.get_m_splitImpulse = v.prototype.LA = function() {
          return !!pz(this.Zx)
        }
        ;
        v.prototype.set_m_splitImpulse = v.prototype.rD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          qz(c, a)
        }
        ;
        Object.defineProperty(v.prototype, "m_splitImpulse", {
          get: v.prototype.LA,
          set: v.prototype.rD
        });
        v.prototype.get_m_splitImpulsePenetrationThreshold = v.prototype.MA = function() {
          return rz(this.Zx)
        }
        ;
        v.prototype.set_m_splitImpulsePenetrationThreshold = v.prototype.sD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          sz(c, a)
        }
        ;
        Object.defineProperty(v.prototype, "m_splitImpulsePenetrationThreshold", {
          get: v.prototype.MA,
          set: v.prototype.sD
        });
        v.prototype.get_m_numIterations = v.prototype.xA = function() {
          return tz(this.Zx)
        }
        ;
        v.prototype.set_m_numIterations = v.prototype.dD = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          uz(c, a)
        }
        ;
        Object.defineProperty(v.prototype, "m_numIterations", {
          get: v.prototype.xA,
          set: v.prototype.dD
        });
        v.prototype.__destroy__ = function() {
          vz(this.Zx)
        }
        ;
        function bC(a, c, d, e, f) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          this.Zx = void 0 === e ? wz(a, c, d) : void 0 === f ? _emscripten_bind_btGeneric6DofSpringConstraint_btGeneric6DofSpringConstraint_4(a, c, d, e) : xz(a, c, d, e, f);
          h(bC)[this.Zx] = this
        }
        bC.prototype = Object.create(WA.prototype);
        bC.prototype.constructor = bC;
        bC.prototype.$x = bC;
        bC.ay = {};
        b.btGeneric6DofSpringConstraint = bC;
        bC.prototype.enableSpring = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          yz(d, a, c)
        }
        ;
        bC.prototype.setStiffness = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          zz(d, a, c)
        }
        ;
        bC.prototype.setDamping = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Az(d, a, c)
        }
        ;
        bC.prototype.setEquilibriumPoint = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          void 0 === a ? Bz(d) : void 0 === c ? Cz(d, a) : Dz(d, a, c)
        }
        ;
        bC.prototype.setLinearLowerLimit = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Ez(c, a)
        }
        ;
        bC.prototype.setLinearUpperLimit = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Fz(c, a)
        }
        ;
        bC.prototype.setAngularLowerLimit = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Gz(c, a)
        }
        ;
        bC.prototype.setAngularUpperLimit = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Hz(c, a)
        }
        ;
        bC.prototype.getFrameOffsetA = function() {
          return k(Iz(this.Zx), r)
        }
        ;
        bC.prototype.enableFeedback = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Jz(c, a)
        }
        ;
        bC.prototype.getBreakingImpulseThreshold = function() {
          return Kz(this.Zx)
        }
        ;
        bC.prototype.setBreakingImpulseThreshold = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Lz(c, a)
        }
        ;
        bC.prototype.getParam = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          return Mz(d, a, c)
        }
        ;
        bC.prototype.setParam = function(a, c, d) {
          var e = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          Nz(e, a, c, d)
        }
        ;
        bC.prototype.__destroy__ = function() {
          Oz(this.Zx)
        }
        ;
        function cC(a) {
          a && "object" === typeof a && (a = a.Zx);
          this.Zx = Pz(a);
          h(cC)[this.Zx] = this
        }
        cC.prototype = Object.create(n.prototype);
        cC.prototype.constructor = cC;
        cC.prototype.$x = cC;
        cC.ay = {};
        b.btSphereShape = cC;
        cC.prototype.setMargin = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Qz(c, a)
        }
        ;
        cC.prototype.getMargin = function() {
          return Rz(this.Zx)
        }
        ;
        cC.prototype.setLocalScaling = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Sz(c, a)
        }
        ;
        cC.prototype.getLocalScaling = function() {
          return k(Tz(this.Zx), p)
        }
        ;
        cC.prototype.calculateLocalInertia = function(a, c) {
          var d = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          Uz(d, a, c)
        }
        ;
        cC.prototype.__destroy__ = function() {
          Vz(this.Zx)
        }
        ;
        function Z(a, c, d, e, f) {
          a && "object" === typeof a && (a = a.Zx);
          c && "object" === typeof c && (c = c.Zx);
          d && "object" === typeof d && (d = d.Zx);
          e && "object" === typeof e && (e = e.Zx);
          f && "object" === typeof f && (f = f.Zx);
          this.Zx = Wz(a, c, d, e, f);
          h(Z)[this.Zx] = this
        }
        Z.prototype = Object.create(g.prototype);
        Z.prototype.constructor = Z;
        Z.prototype.$x = Z;
        Z.ay = {};
        b.LocalConvexResult = Z;
        Z.prototype.get_m_hitCollisionObject = Z.prototype.Xz = function() {
          return k(Xz(this.Zx), q)
        }
        ;
        Z.prototype.set_m_hitCollisionObject = Z.prototype.DC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          Yz(c, a)
        }
        ;
        Object.defineProperty(Z.prototype, "m_hitCollisionObject", {
          get: Z.prototype.Xz,
          set: Z.prototype.DC
        });
        Z.prototype.get_m_localShapeInfo = Z.prototype.qA = function() {
          return k(Zz(this.Zx), kB)
        }
        ;
        Z.prototype.set_m_localShapeInfo = Z.prototype.XC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          $z(c, a)
        }
        ;
        Object.defineProperty(Z.prototype, "m_localShapeInfo", {
          get: Z.prototype.qA,
          set: Z.prototype.XC
        });
        Z.prototype.get_m_hitNormalLocal = Z.prototype.aA = function() {
          return k(aA(this.Zx), p)
        }
        ;
        Z.prototype.set_m_hitNormalLocal = Z.prototype.HC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          bA(c, a)
        }
        ;
        Object.defineProperty(Z.prototype, "m_hitNormalLocal", {
          get: Z.prototype.aA,
          set: Z.prototype.HC
        });
        Z.prototype.get_m_hitPointLocal = Z.prototype.cA = function() {
          return k(cA(this.Zx), p)
        }
        ;
        Z.prototype.set_m_hitPointLocal = Z.prototype.JC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          dA(c, a)
        }
        ;
        Object.defineProperty(Z.prototype, "m_hitPointLocal", {
          get: Z.prototype.cA,
          set: Z.prototype.JC
        });
        Z.prototype.get_m_hitFraction = Z.prototype.Yz = function() {
          return eA(this.Zx)
        }
        ;
        Z.prototype.set_m_hitFraction = Z.prototype.EC = function(a) {
          var c = this.Zx;
          a && "object" === typeof a && (a = a.Zx);
          fA(c, a)
        }
        ;
        Object.defineProperty(Z.prototype, "m_hitFraction", {
          get: Z.prototype.Yz,
          set: Z.prototype.EC
        });
        Z.prototype.__destroy__ = function() {
          gA(this.Zx)
        }
        ;
        (function() {
            function a() {
              b.BT_CONSTRAINT_ERP = hA();
              b.BT_CONSTRAINT_STOP_ERP = iA();
              b.BT_CONSTRAINT_CFM = jA();
              b.BT_CONSTRAINT_STOP_CFM = kA();
              b.PHY_FLOAT = lA();
              b.PHY_DOUBLE = mA();
              b.PHY_INTEGER = nA();
              b.PHY_SHORT = oA();
              b.PHY_FIXEDPOINT88 = pA();
              b.PHY_UCHAR = qA()
            }
            La ? a() : Ja.unshift(a)
          }
        )();
        this.Ammo = b;

        return Ammo
      }
    );
  }
)();
if (typeof exports === 'object' && typeof module === 'object')
  module.exports = Ammo;
else if (typeof define === 'function' && define['amd'])
  define([], function() {
    return Ammo;
  });
else if (typeof exports === 'object')
  exports["Ammo"] = Ammo;
", "AGFzbQEAAAABlgdpYAF/AGABfwF/YAJ/fwBgAn9/AX9gBH9/f38AYAN/f38AYAF/AX1gA39/fwF/YAJ/fQBgBX9/f39/AGAEf39/fwF/YAN/f30AYAZ/f39/f38AYAN/f38BfWAAAX9gBH9/f30AYAN/fX8AYAN/fX0AYAV/f39/fwF/YAZ/f39/f30AYAZ/f39/f38Bf2ACf38BfWAAAGAEf399fwBgAX0BfWALf39/f319fX1/f30AYAV/f39/fwF9YAp/f39/f39/f39/AGADf399AX9gB39/f39/f38AYAx/f39/fX19fX1/fX8AYAZ/fX1/f38AYAl/f39/f39/f38Bf2ACf30Bf2ACfX0Bf2AKf39/f39/f39/fwF9YAp/f39/f39/f39/AX9gBH99f30Bf2AGf39/fX9/AGAEf31/fwBgBH99fX0AYAd/f39/f39/AX9gCH9/f39/f39/AX1gCX9/f39/f39/fwF9YAl/f39/f39/f38AYAV/f39/fQBgBH9/fX0AYAZ/fX19fX0AYAR/f39/AX1gBn9/f31/fwF9YAV/f31/fwF9YAJ/fQF9YAJ9fQF9YAt/f39/f39/f319fQBgCn9/f399fX1/f38AYAV/f399fwBgBX9/fX9/AGAEf35+fwBgBX99f39/AGAFf319fX0AYAV/f39/fQF/YAh/f39/fX1/fwF/YAZ/fH9/f38Bf2ACfn8Bf2AEfX19fQF/YAF8AX1gAX8BfGACfH8BfGAIf39/f39/f38AYAl/f39/f39/f30AYAh/f39/f39/fQBgCn9/f39/f399f30AYAh/f39/f399fQBgCX9/f39/fX9/fwBgCH9/f39/fX1/AGAHf39/f319fwBgBn99f39/fwBgB399f399f38AYAZ/fX19f38AYAh/f39/f39/fwF/YAt/f39/f39/f39/fwF/YA1/f39/f39/f39/f39/AX9gB39/f39/f30Bf2AIf39/f39/fX8Bf2AGf39/f399AX9gCX9/f39/fX1/fwF/YAR/f399AX9gBX9/f31/AX9gCX9/f319fX9/fwF/YAR/f31/AX9gA399fwF/YAN+f38Bf2ABfQF/YAJ9fwF/YAN9f38Bf2AEfX9/fwF/YAN9fX0Bf2ADf35/AX5gBn9/f39/fwF9YAZ/f39/f30BfWAFf39/f30BfWACfX8BfWAFfX19fX0BfWADf39/AXxgAn5+AXwCUwsBYQFhAAcBYQFiAAMBYQFjAAoBYQFkAGcBYQFlABIBYQFmAAcBYQFnAAEBYQFoAAEBYQFpABYBYQZtZW1vcnkCAYAIgAgBYQV0YWJsZQFwAKcHA/AP7g8EAAcAAQAAAQUBFgUHAAUBEAECGBgABQUFBQkCNAIJGBgABQYIBwEBAQFBQQAJAgEAGAgGBwIDADQHAAkFHAQFFQEXDQgGAgAFCgIFNx0FABUGAgIBBgoBABMBBwAEGgQEEgEFFRUVGAECAgECCAk/AwEEBh01AwUAAAgIAgIBCAgCCAYGAAYBAQEBAgACAAIBBQACAQgGCAYbAgUCAAgCAgAJEgADBQVmBQACAAUBBAEBCQIAAQIBAwECCAZDCQQCAQA8BQMCBAEEBAwHAgABBRgCBQEBAQQCARYTBQAwDAQGBkcTCAgCCBAGBgYBEAACAQEAAAICAQACAhsFBgYGBAUEAgIBAgIBCAYBAgUFDgICAQgGAAIBDAQFNBIFBAoEBwUBAgECAQUBAAEFAgIFBAEFAQBSAgITBAEEFAISBwYCChQpBwAFBQ0JBQ4FUQUJAAECEAAKAAYBCBADAQULYwsABwAFAQIBAQECAAUBBQICAgUFAiYFBAUFBQUDAgICDwIBDg4ODgMFAwYCAgIBAgIIBgIBAgECAQIBAgIAAAEIBgIBOwgGCC8AAgICAgECAQEAOggGCAYIBggGCAYIBggGCAYCAQgGCAYAAQQAGF0FAUMDKQkFAAcFVgodDAkCAUkqAgEABAUBBwIBBAEBAgkbAQEGAQICCQECAQQFAhwCAQUADAECAgICAAUCBAQAAQMFAgQCAhYBAgABAgUFCQQCACVLWgkhMgAFAgITFAQCCQQJAgQCBwEIBQMDAQQSBBoUAxQFNwMVAQMDAwUhAQAVBAxEAi4IASACDwQMDwECAwgABAICAAIIAAQCAgACAgECAQABBAQJBhIBAAJOAgQDAAIFBwICAgAGEAYFAQUCEy0MAgIJAAALCgcADgAACgoKCgEHAAECAQIIBQUFCAAFDgABBQMDAAIFAAMDAwIDBQUFBQU4Hx8fCQQeGQsEAQIFAiYTRRcnCQQqAw0FCgcJBQICAAYDAwIDAgINAwAGDQMYDg4TPAhcCwIACwsFEgcCAQIBIiEDAyEDAwMDAhUVFSIVBgYGBgIBAgEFAgEVBgYAAAULBChAIgAOAAsVAgEDAgECARIUElAkFA4CAQECAgICCgMCAQIBQkIBDggICAgIEgcHAwAOAQ4CBQMCAwMCAQICAgECAQICAgAAAgUDDgoBAQECBBIGIQAAAAMCAQIBBggGCAABCAgICwICCwICWRwADggGAgAAAgECAQIBAggGCAYCAgIBAgECAgIBAgIBAQMHBwMCAgICCxAGBQUCLQwJCQsBCgcKBwIBAAIAAw4CAgICAQEBAgICAQECAQEBAQgICAUCFQAIFQEGBBADAQEBPQUDEBAHAwIBAg4cCUAOCAYIBggGCAYIBggIBgIBAgECAgECAgEIBggGCAYICAgIBggGCAYIBggGCAgGBQYAAgECAwgBDg4AAQEBIQEBAQAOBgADAQUCAwEOAQIHCQQDAQ4iIhEIBgICLi4vOykUEgoHAwICCAgCCAIGCwsKAwAAAgECAQEADhIKBwMBDlgOAwAAAgEABQEDAgIBAgIBAgICAgEBAAIFAgECAgIFBQICAgICAQEQEQYGERECAQ4OAgECAgIBAgICAgIFAwIBAgECAgAFAwQFAwMBAQIFAQ4DAQEBDggGCAYIBggGAgEIBggGBQgGCAYIBggGX14DAQIBAgECAQIBAgECAQIBAAACFQUMDAwJCQkDBAQEAQcDFgABAWEBZRgHAmg5OQcCPls/AgMoAwAFBSgFCh1TFAoEAQMAAgIWFgAABwICDAQEBAQABQUECgcAAgUCBQICAgkEDAUgAAEDAwIHAgUKBwcFBQUABAUKAAEAAgUCBAwJCQUFTyAADAEAAgIFBQEABwQBBgEFBwEEBAQFBQUQAQECBA0EAAE2NgQECgABBRwEBQQBBQQFBQEQAQIEAQECBAUBAQcBBBEREAQCBREBAQABHQcFBAQFAgIEAQQFCQICBjMFAQECBAIQBAUFAwIHAQECBAQLBAQBBQQBBAIFBQIBAgIHAgQMBAABBgEQBQQFAQESAAEHEAQFBAAFBwAAAgECAQcCARACBQQFERERAQYIAQEHAhAEAAICBQABAQACBRoJAgAEBwcHBwAAAgIaCQABAAIPDwIKGgkAAUoUDwkAAQwHVAQAAQQEDwMDAw0DMTENAwICBQQEBQRGDAAAAAAFBAQPBQUPCQABBBsJGglMBAABAgABCQkAAR0EBQIFAQIAAQAKCgoKCgoKCgoKAAkACgEECQ8kBFUBJAMBAwECAwQHBwoCAgcAAQUCFAQFAAEABAUAAQEAAQIAARQFB2IDAwANCwIBAAELAgICCwILAwICAAEECwoCEwgACAA9AAUAFgwCACMRMCssIysEBQwsDDULAAcBDRcRDAwCAgAHAQUNFwIPAAwCAgUJBwENF0gCAAIEDAIvAAcNFwQCAgAFCQcBBQICAgAFBAwHAQ0XAAIAAAACDRccLQQCAgkNAwIMAAECAgEBAgAIAAkCAgICBQgEAgIEAigCCAglAAAAAggAAgABAgcBAwsICBECCRIKJCASAgICAgUDCAEBAgwEAAICBAgIAAkEHAQFBAUEBQYGAQgaCToABQQAAQAAAQkFBQEFBQcGAQECAgICYAYIAgEBBAsOBQUHAQIRERERCBEQTSICZFcCAAAACAMAAgAACBQKFgYJAX8BQcD8wQILB987twoBagD2DwFrAPoBAWwAyAEBbQDCAQFuAL4BAW8AlwMBcACSAwFxALgBAXIA+QEBcwD2AQF0AO0BAXUA6QEBdgDlAQF3AOEBAXgAqAEBeQDdAQF6ANcBAUEA0AEBQgAMAUMAGwFEABoBRQAZAUYALQFHACwBSAAMAUkAmgEBSgCZAQFLAHYBTACYAQFNAJYBAU4AlQEBTwCUAQFQAJMBAVEAkgEBUgCRAQFTAJABAVQAjwEBVQCNAQFWAIwBAVcAiwEBWACJAQFZAIgBAVoAdAFfAIcBASQAhgECYWEAhQECYmEAXAJjYQCEAQJkYQCDAQJlYQA4AmZhADcCZ2EAOAJoYQA3AmlhAHECamEAggECa2EAvAECbGEAjwICbWEAjgICbmEAjQICb2EAigICcGEAiQICcWEA+gECcmEAyAECc2EAwgECdGEAvgECdWEAlwMCdmEAkgMCd2EAuAECeGEA+QECeWEA9gECemEA7QECQWEA6QECQmEA5QECQ2EA4QECRGEAqAECRWEA3QECRmEA1wECR2EA0AECSGEADAJJYQBPAkphAE4CS2EATQJMYQBMAk1hAEsCTmEADAJPYQAbAlBhABoCUWEAGQJSYQAMAlNhAJ0GAlRhAC0CVWEALAJWYQC6AQJXYQCHAgJYYQCGAgJZYQAbAlphABoCX2EAGQIkYQAMAmFiAIEDAmJiAP8CAmNiAP4CAmRiAP0CAmViAPsCAmZiAPcCAmdiAAwCaGIAvAUCaWIArgUCamIADAJrYgAbAmxiABoCbWIAGQJuYgAMAm9iAKcFAnBiAO8CAnFiAIsFAnJiAJoBAnNiAJkBAnRiAHYCdWIAmAECdmIAlgECd2IAlQECeGIAlAECeWIAkwECemIAkgECQWIAkQECQmIAkAECQ2IAjwECRGIAjQECRWIAjAECRmIAiwECR2IAiQECSGIAiAECSWIAdAJKYgCHAQJLYgCGAQJMYgCFAQJNYgBcAk5iAIQBAk9iAIMBAlBiADgCUWIANwJSYgA4AlNiADcCVGIAcQJVYgCCAQJWYgDlDwJXYgAbAlhiABoCWWIAGQJaYgAMAl9iAOgCAiRiAAwCYWMA1w8CYmMAzw8CY2MAgwUCZGMA9QECZWMA9AECZmMA8wECZ2MA8QECaGMA7wECaWMA7gECamMA+Q4Ca2MA8QQCbGMA2Q4CbWMA2wQCbmMA2AQCb2MA1AQCcGMA0QQCcWMArQECcmMAygQCc2MADAJ0YwD1AQJ1YwD0AQJ2YwDzAQJ3YwDJAgJ4YwDxAQJ5YwDvAQJ6YwDuAQJBYwDDBAJCYwAeAkNjALoNAkRjAC0CRWMALAJGYwAbAkdjABoCSGMAGQJJYwAMAkpjALINAktjAMAEAkxjAKANAk1jAL4EAk5jALwEAk9jALoEAlBjALYEAlFjALQEAlJjAL8CAlNjALEEAlRjAK8EAlVjAK0EAlZjAKsEAldjAKYEAlhjAKMEAlljAPoBAlpjAMgBAl9jAMIBAiRjAL4BAmFkAKAEAmJkAJwEAmNkALgBAmRkAPkBAmVkAPYBAmZkAO0BAmdkAOkBAmhkAOUBAmlkAOEBAmpkAKgBAmtkAN0BAmxkANcBAm1kANABAm5kALwBAm9kAI8CAnBkAI4CAnFkAI0CAnJkAIoCAnNkAIkCAnRkAAwCdWQAGwJ2ZAAaAndkABkCeGQALQJ5ZAAsAnpkAAwCQWQAvAICQmQAmwQCQ2QADAJEZACcDAJFZACSDAJGZACWBAJHZACSBAJIZACQBAJJZACKBAJKZADYAQJLZABPAkxkAE4CTWQATQJOZABMAk9kAEsCUGQADAJRZACEBAJSZAAMAlNkAIAEAlRkAFwCVWQADAJWZAD/AwJXZAD8AwJYZAD5AwJZZAD3AwJaZAD0AwJfZAA8AiRkADsCYWUADAJiZQDsAwJjZQAMAmRlAAwCZWUAsgICZmUAsAICZ2UArwICaGUArgICaWUArQICamUAPAJrZQA7AmxlAMoBAm1lAMkBAm5lAAwCb2UAuQoCcGUAqQoCcWUAmQoCcmUAHgJzZQAyAnRlAJEKAnVlAEACdmUAPAJ3ZQA7AnhlAKEBAnllAKABAnplAJ8BAkFlAJ4BAkJlAI0KAkNlAIwKAkRlAB4CRWUAxQECRmUAxAECR2UA+wECSGUAnwICSWUAygECSmUAyQECS2UAnwECTGUAngECTWUAiwoCTmUAigoCT2UAiQoCUGUAiAoCUWUAhwoCUmUAhgoCU2UAhQoCVGUAhAoCVWUA0wMCVmUA0gMCV2UAgwoCWGUAggoCWWUA0QMCWmUA0AMCX2UAHgIkZQAwAmFmAMMBAmJmAJ0BAmNmAJwBAmRmAM8DAmVmAM4DAmZmAM0DAmdmAMwDAmhmAMsDAmpmAMoDAmtmAMkDAmxmAMgDAm1mAMcDAm5mAMYDAm9mAMUDAnBmAMQDAnFmAMMDAnJmAMIDAnNmAMEDAnRmAMADAnVmAL8DAnZmAL4DAndmAIEKAnhmAIAKAnlmAB4CemYA/wkCQWYA/gkCQmYAGwJDZgAaAkRmABkCRWYALQJGZgAsAkdmAAwCSGYAvAICSWYADAJKZgD9CQJLZgD8CQJMZgCdAgJNZgCcAgJOZgD7CQJPZgD6CQJQZgD5CQJRZgD4CQJSZgD3CQJTZgD2CQJUZgD1CQJVZgD0CQJWZgDyCQJXZgDxCQJYZgDwCQJZZgDvCQJaZgDuCQJfZgDtCQIkZgDsCQJhZwDrCQJiZwDqCQJjZwDpCQJkZwDoCQJlZwDnCQJmZwDmCQJnZwDlCQJoZwAeAmlnAAwCamcA5AkCa2cA4wkCbGcA4gkCbWcA4QkCbmcA4AkCb2cArQECcGcA3wkCcWcA3gkCcmcA3QkCc2cAvAECdGcA3AkCdWcA2wkCdmcA2QkCd2cA1wkCeGcA1gkCeWcALQJ6ZwAsAkFnABsCQmcAGgJDZwAZAkRnAAwCRWcA1QkCRmcA/wMCR2cA1w0CSGcA0gkCSWcAngMCSmcA0QkCS2cA0AkCTGcAzwkCTWcAzgkCTmcAzQkCT2cA/AMCUGcA+QMCUWcA9wMCUmcA9AMCU2cAPAJUZwA7AlVnAAwCVmcAzAkCV2cAsgICWGcAuwMCWWcAygkCWmcAmwICX2cAmgICJGcAugMCYWgAuQMCYmgAuAMCY2gAyAkCZGgAmAMCZWgAxgkCZmgAxQkCZ2gAxAkCaGgAsAICaWgArwICamgArgICa2gArQICbGgAPAJtaAA7Am5oAMoBAm9oAMkBAnBoAAwCcWgAMgJyaADBAQJzaABAAnRoAMEJAnVoAMoEAnZoAAwCd2gAvwkCeGgAGwJ5aAAaAnpoABkCQWgADAJCaAC+CQJDaADFAQJEaADEAQJFaAA8AkZoADsCR2gAoQECSGgAoAECSWgAHgJKaADAAQJLaAC/AQJMaAD7AQJNaACfAgJOaAAeAk9oAL0JAlBoAHQCUWgAvAkCUmgAuwkCU2gAuQkCVGgAuAkCVWgAtwkCVmgAtgkCV2gAtQkCWGgAswkCWWgAsQkCWmgAsAkCX2gArgkCJGgArAkCYWkAqwkCYmkAqAkCY2kApwkCZGkApgkCZWkApQkCZmkApAkCZ2kAowkCaGkAogkCaWkAoAkCamkAngkCa2kAnQkCbGkAmwkCbWkAmgkCbmkAmAkCb2kAlgkCcGkAlQkCcWkAlAkCcmkAkwkCc2kAcQJ0aQCSCQJ1aQCaAQJ2aQCZAQJ3aQB2AnhpAJgBAnlpAJYBAnppAJUBAkFpAJQBAkJpAJMBAkNpAJIBAkRpAJEBAkVpAJABAkZpAI8BAkdpAI0BAkhpAIwBAklpAIsBAkppAIkBAktpAIgBAkxpAHQCTWkAhwECTmkAhgECT2kAhQECUGkAXAJRaQCEAQJSaQCDAQJTaQA4AlRpADcCVWkAOAJWaQA3AldpAHECWGkAggECWWkAMgJaaQCQCQJfaQBAAiRpAI8JAmFqAAwCYmoAjgkCY2oALQJkagAsAmVqABsCZmoAGgJnagAZAmhqAAwCaWoAjQkCamoADAJragCMCQJsagC8AgJtagCbBAJuagAMAm9qAIsJAnBqAIoJAnFqAIkJAnJqAIgJAnNqAAwCdGoAHgJ1agCHCQJ2agDFAQJ3agDEAQJ4agA8AnlqADsCemoAoQECQWoAoAECQmoAnwECQ2oAngECRGoAnQECRWoAnAECRmoAhQkCR2oAgwkCSGoAggkCSWoAgQkCSmoAmwICS2oAmgICTGoAgAkCTWoA/ggCTmoA/QgCT2oA/AgCUGoA+QgCUWoA+AgCUmoA9wgCU2oA9ggCVGoA9QgCVWoA9AgCVmoA8wgCV2oATwJYagBOAllqAE0CWmoATAJfagBLAiRqAAwCYWsA8ggCYmsA8QgCY2sA8AgCZGsA7wgCZWsA7ggCZmsA7QgCZ2sA7AgCaGsA6wgCaWsA6ggCamsA6AgCa2sA5wgCbGsA5QgCbWsA5AgCbmsATwJvawBOAnBrAE0CcWsATAJyawBLAnNrAAwCdGsA4wgCdWsAGwJ2awAaAndrABkCeGsADAJ5awDiCAJ6awAbAkFrABoCQmsAGQJDawAMAkRrAOEIAkVrAOAIAkZrAN8IAkdrAN4IAkhrAN0IAklrANwIAkprANsIAktrANoIAkxrAIQEAk1rAAwCTmsA2QgCT2sA2AgCUGsA1wgCUWsA1ggCUmsA1QgCU2sALQJUawAsAlVrANQIAlZrANMIAldrANIIAlhrALoBAllrABsCWmsAGgJfawAZAiRrAAwCYWwA0AgCYmwAxQECY2wAxAECZGwAPAJlbAA7AmZsAKEBAmdsAKABAmhsAJ8BAmlsAJ4BAmpsAJQDAmtsALEDAmxsALADAm1sAK8DAm5sAM4IAm9sAM0IAnBsADICcWwAzAgCcmwAywgCc2wAyggCdGwAyQgCdWwAxwgCdmwAxggCd2wAxAgCeGwAwggCeWwAgAQCemwAXAJBbACUAgJCbADBCAJDbAAMAkRsAMAIAkVsAL0IAkZsALwIAkdsALsIAkhsALoIAklsAPoIAkpsALkIAktsALgIAkxsALcIAk1sALYIAk5sALUIAk9sALQIAlBsALMIAlFsALIIAlJsALEIAlNsALAIAlRsAK4IAlVsAOYIAlZsAK0IAldsANEIAlhsAKwIAllsAKsIAlpsAKoIAl9sAKkIAiRsAKgIAmFtAKcIAmJtAKYIAmNtAKUIAmRtAKQIAmVtADACZm0AowgCZ20AoggCaG0AoQgCaW0AmAMCam0AoAgCa20AnwgCbG0AnggCbW0AnQgCbm0AnAgCb20AmwgCcG0AmQgCcW0AmAgCcm0AlwgCc20AlggCdG0AlQgCdW0AlAgCdm0AkwgCd20AkggCeG0AkQgCeW0AkAgCem0AjwgCQW0AHgJCbQCOCAJDbQCNCAJEbQDJAgJFbQCuAwJGbQCDBQJHbQD1AQJIbQD0AQJJbQDzAQJKbQDxAQJLbQDvAQJMbQDuAQJNbQDxBAJObQCLCAJPbQDbBAJQbQDYBAJRbQDUBAJSbQDRBAJTbQCtAQJUbQCKCAJVbQAeAlZtAMABAldtAL8BAlhtAJQCAlltAIEEAlptAK0DAl9tAKwDAiRtAKsDAmFuAKoDAmJuAJ4DAmNuAIkIAmRuAIgIAmVuAIcIAmZuAJ0CAmduAJwCAmhuAB4Cam4AMAJrbgDDAQJsbgCdAQJtbgCcAQJubgCTAgJvbgCSAgJwbgAeAnFuADICcm4AhggCc24AQAJ0bgAMAnVuAIUIAnZuAIQIAnduAIMIAnhuAIIIAnluAIEIAnpuAIAIAkFuAP8HAkJuAP0HAkNuAPwHAkRuAPsHAkVuAPoHAkZuAPkHAkduAPgHAkhuAPcHAkluAPYHAkpuAPUHAktuAPQHAkxuAPMHAk1uAPIHAk5uAPEHAk9uAPAHAlBuAO8HAlFuAO4HAlJuAO0HAlNuAOwHAlRuAOsHAlVuAOkHAlZuAOcHAlduAOYHAlhuAOQHAlluAOgCAlpuAAwCX24A4wcCJG4ALQJhbwAsAmJvABsCY28AGgJlbwAZAmZvAAwCZ28A4gcCaG8ALQJpbwAsAmpvABsCa28AGgJsbwAZAm1vAAwCbm8AlAICb28A4QcCcG8AkQICcW8A4AcCcm8ADAJzbwDdBwJ0bwAMAnVvADICdm8A3AcCd28AOQJ4bwDaBwJ5bwDZBwJ6bwBAAkFvADACQm8AwwECQ28AnQECRG8AnAECRW8AkwICRm8AkgICR28ApAMCSG8AowMCSW8AogMCSm8AoQMCS28AoAMCTG8AnwMCTW8A2AcCTm8A1wcCT28AqQMCUG8AnQMCUW8AHgJSbwDWBwJTbwAbAlRvABoCVW8AGQJWbwAMAldvANUHAlhvANQHAllvANMHAlpvANIHAl9vANEHAiRvANAHAmFwAM8HAmJwAM4HAmNwAM0HAmRwAMwHAmVwAMsHAmZwAMoHAmdwAMkHAmhwAMgHAmlwAMcHAmpwAMYHAmtwAMUHAmxwAMQHAm1wAMMHAm5wAMIHAm9wAMEHAnBwAMAHAnFwAL8HAnJwAJoBAnNwAJkBAnRwAHYCdXAAmAECdnAAlgECd3AAlQECeHAAlAECeXAAkwECenAAkgECQXAAkQECQnAAkAECQ3AAjwECRHAAjQECRXAAjAECRnAAiwECR3AAiQECSHAAiAECSXAAdAJKcACHAQJLcACGAQJMcACFAQJNcABcAk5wAIQBAk9wAIMBAlBwADgCUXAANwJScAA4AlNwADcCVHAAcQJVcAC9BwJWcAC8BwJXcAC6BwJYcAC5BwJZcAC2BwJacAC1BwJfcAC0BwIkcACzBwJhcQCCAQJicQAyAmNxAMEBAmRxAEACZXEAPAJmcQA7AmdxAKEBAmhxAKABAmlxAJ8BAmpxAJ4BAmtxAJQDAmxxALEDAm1xALADAm5xAK8DAm9xAKsDAnBxAKoDAnFxANMDAnJxANIDAnNxAJMCAnRxAJICAnVxANEDAnZxANADAndxAJwDAnhxAJsDAnlxALAHAnpxAK8HAkFxAM0DAkJxAMwDAkNxAMsDAkRxAMoDAkVxAMkDAkZxAMgDAkdxAMcDAkhxAMYDAklxAMUDAkpxAMQDAktxAMMDAkxxAMIDAk1xAMEDAk5xAMADAk9xAL8DAlBxAL4DAlFxAK4HAlJxAK0HAlNxAOgHAlRxAKwHAlVxAKkDAlZxAJ0DAldxAKsHAlhxAKoHAllxAKkHAlpxAKgHAl9xAKcHAiRxAKYHAmFyAKUHAmJyAPsEAmNyAJoDAmRyAJECAmVyAJkDAmZyAJsCAmdyAJoCAmhyALoDAmlyALkDAmpyALgDAmtyAKMHAmxyAKIHAm1yAKEHAm5yAJ0CAm9yAJwCAnByAB4CcXIAoAcCcnIADAJzcgAMAnRyAJ4HAnVyAJ0HAnZyAJwHAndyAKgBAnhyAJoHAnlyAJkHAnpyAJgHAkFyAJcHAkJyAJYHAkNyAJUHAkRyAJQHAkVyAJMHAkZyAJIHAkdyAJEHAkhyAJAHAklyAI8HAkpyAI4HAktyAI0HAkxyAIwHAk1yAIsHAk5yAIoHAk9yAOgCAlByAAwCUXIAMgJScgDBAQJTcgBAAlRyADICVXIAiQcCVnIAiAcCV3IAhQcCWHIAGwJZcgAaAlpyABkCX3IADAIkcgC/AgJhcwCEBwJicwAMAmNzAMABAmRzAL8BAmVzAK0BAmZzAIMHAmdzAIIHAmhzAIEHAmlzAPkBAmpzAIAHAmtzAP8GAmxzAPoBAm1zAMgBAm5zAMIBAm9zAL4BAnBzAKAEAnFzAJwEAnJzALgBAnNzAPYBAnRzAO0BAnVzAOkBAnZzAOUBAndzAOEBAnhzAKgBAnlzAN0BAnpzANcBAkFzANABAkJzAMAEAkNzAP4GAkRzAL4EAkVzALwEAkZzALoEAkdzALYEAkhzALQEAklzAL8CAkpzALEEAktzAK8EAkxzAK0EAk1zAKsEAk5zAKYEAk9zAKMEAlBzALwBAlFzAI8CAlJzAI4CAlNzAI0CAlRzAIoCAlVzAIkCAlZzAAwCV3MA/QYCWHMATwJZcwBOAlpzAE0CX3MATAIkcwBLAmF0AAwCYnQA/AYCY3QA+wYCZHQA+AYCZXQA9gYCZnQA9QYCZ3QA2AECaHQA8wYCaXQA8QYCanQA8AYCa3QA7QYCbHQA6wYCbXQAHgJudADoBgJvdACyAgJwdAC7AwJxdADmBgJydACkAwJzdACjAwJ0dACiAwJ1dAChAwJ2dACgAwJ3dACfAwJ4dACwAgJ5dACvAgJ6dACuAgJBdACtAgJCdAA8AkN0ADsCRHQAygECRXQAyQECRnQADAJHdADlBgJIdADkBgJJdAAMAkp0AOMGAkt0AOwDAkx0AAwCTXQA4QYCTnQA4AYCT3QAGwJQdAAaAlF0ABkCUnQADAJTdAAyAlR0AMEBAlV0AEACVnQA3wYCV3QA3gYCWHQAdgJZdADdBgJadADcBgJfdADaBgIkdABPAmF1AE4CYnUATQJjdQBMAmR1AEsCZXUADAJmdQDYBgJndQCaAQJodQCZAQJpdQB2Amp1AJgBAmt1AJYBAmx1AJUBAm11AJQBAm51AJMBAm91AJIBAnB1AJEBAnF1AJABAnJ1AI8BAnN1AI0BAnR1AIwBAnV1AIsBAnZ1AIkBAnd1AIgBAnh1AHQCeXUAhwECenUAhgECQXUAhQECQnUAXAJDdQCEAQJEdQCDAQJFdQA4AkZ1ADcCR3UAOAJIdQA3Akl1AHECSnUA7wICS3UAiwUCTHUAggECTXUA2AECTnUA1wYCT3UA1gYCUHUA1QYCUXUAMAJSdQDDAQJTdQCdAQJUdQCcAQJVdQDPAwJWdQDOAwJXdQC5CwJYdQCMAgJZdQDUBgJadQDTBgJfdQDSBgIkdQDRBgJhdgAeAmJ2ANAGAmN2AM8GAmR2AM4GAmV2AMwGAmZ2AMoGAmd2AMkGAmh2AE8CaXYATgJqdgBNAmt2AEwCbHYASwJtdgC0CQJudgDIBgJvdgAMAnB2AMcGAnF2AMYGAnJ2AMUGAnN2AMQGAnR2AMMGAnV2AMIGAnZ2AMEGAnd2AB4CeHYAwAYCeXYAvwYCenYAvgYCQXYAvQYCQnYArQECQ3YAMgJEdgC8BgJFdgBAAkZ2ALsGAkd2AC0CSHYALAJJdgAbAkp2ABoCS3YAGQJMdgAMAk12ADACTnYAugYCT3YAuQYCUHYAuAYCUXYAtwYCUnYAtgYCU3YAgQMCVHYA/wICVXYA/gICVnYA/QICV3YA+wICWHYA9wICWXYADAJadgC0BgJfdgAtAiR2ACwCYXcAugECYncAhwICY3cAhgICZHcAGwJldwAaAmZ3ABkCZ3cADAJodwCzBgJpdwCuAwJqdwCyBgJrdwCwBgJsdwCuBgJtdwCsBgJudwCrBgJvdwCqBgJwdwCpBgJxdwCmBgJydwCkBgJzdwCiBgJ0dwCgBgJ1dwCeBgJ2dwCbBgJ3dwCYBgJ4dwCWBgJ5dwCUBgJ6dwCTBgJBdwCRBgJCdwD1AQJDdwD0AQJEdwDzAQJFdwDJAgJGdwDxAQJHdwDvAQJIdwDuAQJJdwDDBAJKdwAeAkt3AJAGAkx3AC0CTXcALAJOdwC6AQJPdwCHAgJQdwCGAgJRdwAbAlJ3ABoCU3cAGQJUdwAMAlV3AI8GAlZ3AI4GAld3AI0GAlh3AIwGAll3AK0DAlp3AKwDAl93AB4CJHcAiwYCYXgAigYCYngAiQYCY3gAiAYCZHgAhwYCZXgAhgYCZngAhQYCZ3gAhAYCaHgAlgQCaXgAkgQCangAkAQCa3gAigQCbHgA2AECbXgATwJueABOAm94AE0CcHgATAJxeABLAnJ4AAwCc3gAgwYCdHgALQJ1eAAsAnZ4ABsCd3gAGgJ4eAAZAnl4AAwCengAgQYCQXgAwAECQngAvwECQ3gA+wECRHgAnwICRXgA+wQCRngAmgMCR3gAkQICSHgAmQMCSXgAnAMCSngAmwMCS3gAHgJMeACQAwJNeACPAwJOeACOAwJPeACNAwJQeAD/BQJReACQAwJSeACPAwJTeACOAwJUeACNAwJVeAD+BQJWeACgAgJXeAAOAlh4AJAKAll4AI8KCfUMAQBBAQumBy+BAfwF+wUwWKAKjAP5BfgF9wUwWDBYL+8F7gXtBTBYL4EB6gXpBegFMFgvgQHnBS+BAeYF5QUwWC+BAeQF4wXiBeEF4AXfBd4F3QXcBdsF2gXZBdgF1wXWBdUF1AXTBdIF0QXQBTBYvgW9BUq3AbsFJLUFuQW6BbYFtwW0BbMFsgWAArgFsQWwBYACa68F8wIYCq0FCqwFCqsFCqoF7Q/lAvECpgUk2w/aD9oN2A8YCiLpD9YP5QLlAhgK4w/iD+EP5gIYKtUP4gvgC+ELJNQP5ALTD9IP0Q/QD4UFPd4LaArODwrLDxgqaNsByg/kAskP4wLID+ICxw/GD8UP3Qto2wtKIsQPCsMPJArCD90P4A/fD94PGArBD2ckwA+/D7cPtg8kvQ+8D7sPGAqBBbUPJCIYCmDgAoAF9wG0D+MCsg+4ArEPsA/mAq8P7Av/BP8Erg+tD7cBrA+rD6oP/QSoD/8M/gz8BJ4Pog/3DKEP9w6jD/0Mnw/9DvIO8Q7wDu8O+g74Dv4O9Q70DvYO6Q7oDucO6wTrBJ0PgA/wBO8E8ATvBKcP6w7sDu4O8w6mD4IP/w4knA8YCpsPGAqQD2e0AYoPhg+FD4QPiQ+ID4cP2wKDD/QE+gzyBOUO5gLsBPME5A7jDuIOCuAO3w7pBGWzAdoO3Q7cDugE2A7XDuICZOkEZdMO0g7kBNAOzw7ODs0O0Q5lxg7EDsMOxQ5lwA6/Dr4OvA67DuIEug65DjVltA6yDrAOrw6uDq0OZacOqg6pDqYOpA6jDqEOoA6iDmWfDp4OnQ6ZDpgOlw6WDtkElQ4ihw4ihg63AY4Oiw6JDowOjQ6KDoIO0wSADvcN+Q39DfsN9g0K+A31DfQN5Q0k7w3uDe0N7A3rDeoN6Q3oDecN5g0K5A0YCs4E3AHcC9wN2w3ZDcgC1g3VDdQN0w3RDdANzw3ODcsNyg3JDcUNyA3GDccNww3EDcINvw2+Db0NwgTCBMENwA0YCrwNGAq7DRgKRAq3DRgKIiK2DRgKtQ1nJBg1sw2xDbANZ7QB4gGvDcEECq4NCq0NCqwNCqsNCqoNCqkNCqgNCqcNCqYNCqUNow2iDZ8Nng2aDZkNlw1ntAGWDZUNjw2ODZQNkw2SDZENCoEFCrsEig2JDYgNZ7QBCoYNhQ2HDQrFAgoiIoQNCrgENYMNNYINwwKADbMEwgKpAfUMCrIECrIECvQMCvMM8gwK8QwK8AwK7wzuDArtDArsDArrDArqDBgK6QzoDOcM5gzlDAqwBOEM4AzfDGe0ARgK1wzbDNoM2QzYDNYMCiIi6AQKIiLVDArUDNEM0AzPDM4MzQwKzAylBMoMxwzGDGuiBMQMwgzBDMMMCsAMvAy7DLYMtAyyDLUMsQywDK8MrgyzDLgMtwwqgAWnDKYMpQykDN8BowyoDKoMqQwqogyhDCqgDJ8MmgSdDJQMkwzZC9gLlgyRDJAMlQyYDJcMKpgEjAyLDOMCigyNDI8MjgyJDIgM+wuEDPoL9wGADN8BgwyFDPgL/guCDIEMGAqVBAqVBAr9CxgqkwT3C/kLGAr2Cwr1Cxgq8wvxC/AL9wHvC+IC7gvyCzXoC+oL6Qs15gvnCxgqmATlC+QL5ALjC2g1NTXQC88L1wvOC80L0gu4AtYL1QuLBIsE1AvTC0poiQTRCyrFC7cCyAvEC4gEpwHfAcMLywvJCyrCCyrBC+ACvgu9C7wLuALAC78LSkpoIkpoiQQKuws14AKGBLcCuAu3C6cBtgu1C7QLhQSzC7ILhQWxC7ALhQSvC64LrQusC6sL5QPiBMoKzArLCqoLCqkLCqgLpQukC6MLoAufC/cBnguhC6ILKoYEtwKdC5YLiASnAd8BlQuUC5oLmQv+AyqTC5wLlwuSCyqRC5sLmAv+A/0DjguQC/sD+wMkJPMCJCSNC4wLiwuHC48L+AOIC4oLiQu0AoULhAuCC4AL9gP+Cv0K/Ar1A/UD+wr6CrMB+Qr4CvcK8wP2CiJra/IDIkoiJCLzA7cBJCTuA/MK6grtCvAKa2vyA/IKgALxCukK7ArvCkr8BOsKCugKCucK5grlCuQK4wrgCvYD4grhCt8K6gPqA9wK2wqzAQraCtkKCukDCukD0QHSCjXJCsgKwgrDCsEKCq8KrgqlCq0KpAoYCrMBswGeCpMKlgqcCgqUCpcKmwoKlQqYCpoKCvL1Je4PWwEBfyMAQRBrIgQgADYCDCAEIAE2AgggBCACNgIEIAQgAzYCACAEKAIMIgAgBCgCCCoCADgCACAAIAQoAgQqAgA4AgQgACAEKAIAKgIAOAIIIABDAAAAADgCDAsGACAAEA4L8wICAn8BfgJAIAJFDQAgACACaiIDQX9qIAE6AAAgACABOgAAIAJBA0kNACADQX5qIAE6AAAgACABOgABIANBfWogAToAACAAIAE6AAIgAkEHSQ0AIANBfGogAToAACAAIAE6AAMgAkEJSQ0AIABBACAAa0EDcSIEaiIDIAFB/wFxQYGChAhsIgE2AgAgAyACIARrQXxxIgRqIgJBfGogATYCACAEQQlJDQAgAyABNgIIIAMgATYCBCACQXhqIAE2AgAgAkF0aiABNgIAIARBGUkNACADIAE2AhggAyABNgIUIAMgATYCECADIAE2AgwgAkFwaiABNgIAIAJBbGogATYCACACQWhqIAE2AgAgAkFkaiABNgIAIAQgA0EEcUEYciIEayICQSBJDQAgAa0iBUIghiAFhCEFIAMgBGohAQNAIAEgBTcDGCABIAU3AxAgASAFNwMIIAEgBTcDACABQSBqIQEgAkFgaiICQR9LDQALCyAACzIBAX8jAEEQayIBJAAgASAANgIMIAEoAgwiAARAIAAgACgCACgCBBEAAAsgAUEQaiQAC0UBAX8jAEEQayIBJAAgASAANgIMIAEoAgwhAEHo9wFB6PcBKAIAQQFqNgIAIABBEEGM0gEoAgARAwAhACABQRBqJAAgAAvtDAEHfwJAIABFDQAgAEF4aiIDIABBfGooAgAiAUF4cSIAaiEFAkAgAUEBcQ0AIAFBA3FFDQEgAyADKAIAIgFrIgNB2PgBKAIASQ0BIAAgAWohACADQdz4ASgCAEcEQCABQf8BTQRAIAMoAggiAiABQQN2IgRBA3RB8PgBakcaIAIgAygCDCIBRgRAQcj4AUHI+AEoAgBBfiAEd3E2AgAMAwsgAiABNgIMIAEgAjYCCAwCCyADKAIYIQYCQCADIAMoAgwiAUcEQCADKAIIIQIgAiABNgIMIAEgAjYCCAwBCwJAIANBFGoiAigCACIEDQAgA0EQaiICKAIAIgQNAEEAIQEMAQsDQCACIQcgBCIBQRRqIgIoAgAiBA0AIAFBEGohAiABKAIQIgQNAAsgB0EANgIACyAGRQ0BAkAgAyADKAIcIgJBAnRB+PoBaiIEKAIARgRAIAQgATYCACABDQFBzPgBQcz4ASgCAEF+IAJ3cTYCAAwDCyAGQRBBFCAGKAIQIANGG2ogATYCACABRQ0CCyABIAY2AhggAygCECICBEAgASACNgIQIAIgATYCGAsgAygCFCICRQ0BIAEgAjYCFCACIAE2AhgMAQsgBSgCBCIBQQNxQQNHDQBB0PgBIAA2AgAgBSABQX5xNgIEIAMgAEEBcjYCBCAAIANqIAA2AgAPCyAFIANNDQAgBSgCBCIBQQFxRQ0AAkAgAUECcUUEQCAFQeD4ASgCAEYEQEHg+AEgAzYCAEHU+AFB1PgBKAIAIABqIgA2AgAgAyAAQQFyNgIEIANB3PgBKAIARw0DQdD4AUEANgIAQdz4AUEANgIADwsgBUHc+AEoAgBGBEBB3PgBIAM2AgBB0PgBQdD4ASgCACAAaiIANgIAIAMgAEEBcjYCBCAAIANqIAA2AgAPCyABQXhxIABqIQACQCABQf8BTQRAIAUoAggiAiABQQN2IgRBA3RB8PgBakcaIAIgBSgCDCIBRgRAQcj4AUHI+AEoAgBBfiAEd3E2AgAMAgsgAiABNgIMIAEgAjYCCAwBCyAFKAIYIQYCQCAFIAUoAgwiAUcEQCAFKAIIIQIgAiABNgIMIAEgAjYCCAwBCwJAIAVBFGoiAigCACIEDQAgBUEQaiICKAIAIgQNAEEAIQEMAQsDQCACIQcgBCIBQRRqIgIoAgAiBA0AIAFBEGohAiABKAIQIgQNAAsgB0EANgIACyAGRQ0AAkAgBSAFKAIcIgJBAnRB+PoBaiIEKAIARgRAIAQgATYCACABDQFBzPgBQcz4ASgCAEF+IAJ3cTYCAAwCCyAGQRBBFCAGKAIQIAVGG2ogATYCACABRQ0BCyABIAY2AhggBSgCECICBEAgASACNgIQIAIgATYCGAsgBSgCFCICRQ0AIAEgAjYCFCACIAE2AhgLIAMgAEEBcjYCBCAAIANqIAA2AgAgA0Hc+AEoAgBHDQFB0PgBIAA2AgAPCyAFIAFBfnE2AgQgAyAAQQFyNgIEIAAgA2ogADYCAAsgAEH/AU0EQCAAQQN2IgFBA3RB8PgBaiEAAn9ByPgBKAIAIgJBASABdCIBcUUEQEHI+AEgASACcjYCACAADAELIAAoAggLIQIgACADNgIIIAIgAzYCDCADIAA2AgwgAyACNgIIDwsgA0IANwIQIAMCf0EAIABBCHYiAUUNABpBHyAAQf///wdLDQAaIAEgAUGA/j9qQRB2QQhxIgF0IgIgAkGA4B9qQRB2QQRxIgJ0IgQgBEGAgA9qQRB2QQJxIgR0QQ92IAEgAnIgBHJrIgFBAXQgACABQRVqdkEBcXJBHGoLIgI2AhwgAkECdEH4+gFqIQECQAJAAkBBzPgBKAIAIgRBASACdCIHcUUEQEHM+AEgBCAHcjYCACABIAM2AgAgAyABNgIYDAELIABBAEEZIAJBAXZrIAJBH0YbdCECIAEoAgAhAQNAIAEiBCgCBEF4cSAARg0CIAJBHXYhASACQQF0IQIgBCABQQRxaiIHQRBqKAIAIgENAAsgByADNgIQIAMgBDYCGAsgAyADNgIMIAMgAzYCCAwBCyAEKAIIIgAgAzYCDCAEIAM2AgggA0EANgIYIAMgBDYCDCADIAA2AggLQej4AUHo+AEoAgBBf2oiADYCACAADQBBkPwBIQMDQCADKAIAIgBBCGohAyAADQALQej4AUF/NgIACws7AQF/IwBBEGsiASQAAn8gAUEANgIMIAEgADYCBCABIAA2AgAgASAAQQFqNgIIIAELEKEKIAFBEGokAAs/AQF/IwBBEGsiASQAAn8gAUEANgIMIAEgADYCBCABIAA2AgAgASAAQQFqNgIIIAELEKMKIQAgAUEQaiQAIAALzgEBAX8jAEEgayIDJAAgAyABNgIcIAMgAjYCGCADAn8jAEEQayIBIAMoAhw2AgwgAUEANgIIIAEoAgwgASgCCEEEdGoLIAMoAhgQSTgCFCADAn8jAEEQayIBIAMoAhw2AgwgAUEBNgIIIAEoAgwgASgCCEEEdGoLIAMoAhgQSTgCECADAn8jAEEQayIBIAMoAhw2AgwgAUECNgIIIAEoAgwgASgCCEEEdGoLIAMoAhgQSTgCDCAAIANBFGogA0EQaiADQQxqEAkgA0EgaiQACzEBAn8gAEEBIAAbIQADQAJAIAAQoAIiAQ0AQcT4ASgCACICRQ0AIAIRFgAMAQsLIAELoQEBA38jAEEQayIBJABBiNIBKAIAIgAgACgCEEF/aiICNgIQAkACQCACBH8gAgUgACgCBEUNASABQQhqQQAQARogACAAKgIIIAEoAgxBuPcBKAIAIgIoAgRrIAEoAgggAigCAGtBwIQ9bGogACgCDGuzQwAAekSVkjgCCCAAKAIQCw0BQYjSASgCACEAC0GI0gEgACgCFDYCAAsgAUEQaiQAC3cBAX8jAEEgayIDJAAgAyABNgIcIAMgAjYCGCADIAMoAhwqAgAgAygCGCoCAJI4AhQgAyADKAIcKgIEIAMoAhgqAgSSOAIQIAMgAygCHCoCCCADKAIYKgIIkjgCDCAAIANBFGogA0EQaiADQQxqEAkgA0EgaiQAC4IEAQN/IAJBgARPBEAgACABIAIQBRogAA8LIAAgAmohAwJAIAAgAXNBA3FFBEACQCACQQFIBEAgACECDAELIABBA3FFBEAgACECDAELIAAhAgNAIAIgAS0AADoAACABQQFqIQEgAkEBaiICIANPDQEgAkEDcQ0ACwsCQCADQXxxIgRBwABJDQAgAiAEQUBqIgVLDQADQCACIAEoAgA2AgAgAiABKAIENgIEIAIgASgCCDYCCCACIAEoAgw2AgwgAiABKAIQNgIQIAIgASgCFDYCFCACIAEoAhg2AhggAiABKAIcNgIcIAIgASgCIDYCICACIAEoAiQ2AiQgAiABKAIoNgIoIAIgASgCLDYCLCACIAEoAjA2AjAgAiABKAI0NgI0IAIgASgCODYCOCACIAEoAjw2AjwgAUFAayEBIAJBQGsiAiAFTQ0ACwsgAiAETw0BA0AgAiABKAIANgIAIAFBBGohASACQQRqIgIgBEkNAAsMAQsgA0EESQRAIAAhAgwBCyADQXxqIgQgAEkEQCAAIQIMAQsgACECA0AgAiABLQAAOgAAIAIgAS0AAToAASACIAEtAAI6AAIgAiABLQADOgADIAFBBGohASACQQRqIgIgBE0NAAsLIAIgA0kEQANAIAIgAS0AADoAACABQQFqIQEgAkEBaiICIANHDQALCyAAC/MBAQN/IwBBEGsiAyQAAkAgAEGI0gEoAgAiAigCAEYEQCACIQEMAQsCQCACKAIYIgEEQANAIAEoAgAgAEYNAiABKAIcIgENAAsLQSQQEiIBQgA3AgQgASAANgIAIAFBADYCICABQgA3AhggASACNgIUIAFCADcCDCABEMsBIAEgAigCGDYCHCACIAE2AhgLQYjSASABNgIACyABIAEoAgRBAWo2AgQgASABKAIQIgBBAWo2AhAgAEUEQCADQQhqQQAQARogASADKAIMQbj3ASgCACIAKAIEayADKAIIIAAoAgBrQcCEPWxqNgIMCyADQRBqJAALMQEBfyMAQRBrIgMkACADIAE2AgwgAyACNgIIIAAgAygCDCADKAIIEIIDIANBEGokAAsEACAAC0UBAX8jAEEQayIDJAAgAyAANgIMIAMgATgCCCADIAI2AgQgAygCDCIAIAMqAgggAygCBCAAKAIAKAIgERAAIANBEGokAAsxAQF/IwBBEGsiASQAIAEgADYCDCABKAIMIgAgACgCACgCHBEBACEAIAFBEGokACAACzkBAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIgAgAigCCCAAKAIAKAIYEQIAIAJBEGokAAuHAwIDfwF8IwBBEGsiAiQAAkAgALwiA0H/////B3EiAUHan6T6A00EQCABQYCAgMwDSQ0BIAC7EDMhAAwBCyABQdGn7YMETQRAIAC7IQQgAUHjl9uABE0EQCADQX9MBEAgBEQYLURU+yH5P6AQNIwhAAwDCyAERBgtRFT7Ifm/oBA0IQAMAgtEGC1EVPshCUBEGC1EVPshCcAgA0EASBsgBKCaEDMhAAwBCyABQdXjiIcETQRAIAC7IQQgAUHf27+FBE0EQCADQX9MBEAgBETSITN/fNkSQKAQNCEADAMLIARE0iEzf3zZEsCgEDSMIQAMAgtEGC1EVPshGUBEGC1EVPshGcAgA0EASBsgBKAQMyEADAELIAFBgICA/AdPBEAgACAAkyEADAELIAAgAkEIahDZA0EDcSIBQQJNBEACQAJAAkAgAUEBaw4CAQIACyACKwMIEDMhAAwDCyACKwMIEDQhAAwCCyACKwMImhAzIQAMAQsgAisDCBA0jCEACyACQRBqJAAgAAvxAgIDfwF8IwBBEGsiAiQAAn0gALwiA0H/////B3EiAUHan6T6A00EQEMAAIA/IAFBgICAzANJDQEaIAC7EDQMAQsgAUHRp+2DBE0EQCAAuyEEIAFB5JfbgARPBEBEGC1EVPshCUBEGC1EVPshCcAgA0EASBsgBKAQNIwMAgsgA0F/TARAIAREGC1EVPsh+T+gEDMMAgtEGC1EVPsh+T8gBKEQMwwBCyABQdXjiIcETQRAIAFB4Nu/hQRPBEBEGC1EVPshGUBEGC1EVPshGcAgA0EASBsgALugEDQMAgsgA0F/TARARNIhM3982RLAIAC7oRAzDAILIAC7RNIhM3982RLAoBAzDAELIAAgAJMgAUGAgID8B08NABogACACQQhqENkDQQNxIgFBAk0EQAJAAkACQCABQQFrDgIBAgALIAIrAwgQNAwDCyACKwMImhAzDAILIAIrAwgQNIwMAQsgAisDCBAzCyEAIAJBEGokACAACykBAX8jAEEQayIBJAAgASAANgIMIAEoAgwiAARAIAAQDgsgAUEQaiQAC70HAgR/D30CQCAAKALsBSIDQQFIDQADQCABKgIwIQsgASoCCCEMIAEqAgAhDSABKgIEIQ4gASoCNCEPIAEqAhghECABKgIQIQogASoCFCERIAEqAjghByABKgIoIQggASoCICEJIAEqAiQhEiAAIANBf2oiBUG4AWxqIgRBQGtBADYCACAEIAcgCSAEKgIEIgeUIBIgBCoCCCIJlJIgCCAEKgIMIgiUkpIiEjgCPCAEIA8gByAKlCAJIBGUkiAIIBCUkpIiDzgCOCAEIAsgByANlCAJIA6UkiAIIAyUkpIiCzgCNCACKgI4IQwgAioCKCENIAIqAiAhDiACKgIkIRAgAioCNCEKIAIqAhghESACKgIQIRQgAioCFCEVIAIqAjAhByACKgIIIQggAioCACEJIAIqAgQhEyAEQQA2AjAgBCAHIAkgBCoCFCIHlCATIAQqAhgiCZSSIAggBCoCHCIIlJKSIhM4AiQgBCAKIAcgFJQgCSAVlJIgCCARlJKSIgo4AiggBCAMIAcgDpQgCSAQlJIgCCANlJKSIgc4AiwgBCALIBOTIAQqAkSUIA8gCpMgBCoCSJSSIBIgB5MgBCoCTJSSOAJUIAQgBCgCmAFBAWo2ApgBIANBAUohBCAFIQMgBA0ACyAAKALsBSICQQFIDQADQCAAIAIiAUF/aiICQbgBbGoiA0EEaiEFAkAgAyoCVCIHIAAqAvAFIglfRQRAAkAgAygCdCIERQ0AQbTlASgCACIGRQ0AIAQgBhEBABogA0EANgJ0CyAAKALsBSIEQX9qIQMgACABIARHBH8gBSAAIANBuAFsaiIDQQRqQbgBEBUaIANBADYCfCADQQA2AnQgA0EANgKYASADQgA3AoABIANBADoAeCAAKALsBUF/agUgAws2AuwFDAELIAMqAiQgAyoCNCADKgJEIAeUk5MiCCAIlCADKgIoIAMqAjggByADKgJIlJOTIgggCJSSIAMqAiwgAyoCPCAHIAMqAkyUk5MiByAHlJIgCSAJlF5BAXNFBEACQCADKAJ0IgRFDQBBtOUBKAIAIgZFDQAgBCAGEQEAGiADQQA2AnQLIAAoAuwFIgRBf2ohAyAAIAEgBEcEfyAFIAAgA0G4AWxqIgNBBGpBuAEQFRogA0EANgJ8IANBADYCdCADQQA2ApgBIANCADcCgAEgA0EAOgB4IAAoAuwFQX9qBSADCzYC7AUMAQtBuOUBKAIAIgNFDQAgBSAAKALkBSAAKALoBSADEQcAGgsgAUEBSg0ACwsLFwAgAC0AAEEgcUUEQCABIAIgABCSCgsLdwEBfyMAQSBrIgMkACADIAE2AhwgAyACNgIYIAMgAygCHCoCACADKAIYKgIAlDgCFCADIAMoAhwqAgQgAygCGCoCAJQ4AhAgAyADKAIcKgIIIAMoAhgqAgCUOAIMIAAgA0EUaiADQRBqIANBDGoQCSADQSBqJAALAwABCyMAIAAgACgC0AUiACABQegAbGogACACQegAbGogAyAEEKAFCwMAAQvNAwEHfwJAAkAgAbwiBUEBdCICRQ0AIAVB/////wdxQYCAgPwHSw0AIAC8IgdBF3ZB/wFxIgNB/wFHDQELIAAgAZQiACAAlQ8LIAdBAXQiBCACSwRAIAVBF3ZB/wFxIQYCfyADRQRAQQAhAyAHQQl0IgJBAE4EQANAIANBf2ohAyACQQF0IgJBf0oNAAsLIAdBASADa3QMAQsgB0H///8DcUGAgIAEcgsiAgJ/IAZFBEBBACEGIAVBCXQiBEEATgRAA0AgBkF/aiEGIARBAXQiBEF/Sg0ACwsgBUEBIAZrdAwBCyAFQf///wNxQYCAgARyCyIIayIFQX9KIQQgAyAGSgRAA0ACQCAEQQFxRQ0AIAUiAg0AIABDAAAAAJQPCyACQQF0IgIgCGsiBUF/SiEEIANBf2oiAyAGSg0ACyAGIQMLAkAgBEUNACAFIgINACAAQwAAAACUDwsCQCACQf///wNLBEAgAiEEDAELA0AgA0F/aiEDIAJBgICAAkkhBSACQQF0IgQhAiAFDQALCyAHQYCAgIB4cSECIANBAU4EfyAEQYCAgHxqIANBF3RyBSAEQQEgA2t2CyACcr4PCyAAQwAAAACUIAAgAiAERhsL9wgCAn8BfSMAQUBqIgIkACACIAA2AjwgAiABNgI4IwBBEGsiASACKAI8IgA2AgwgAiABKAIMKgIAAn0jAEEQayIBIABBEGo2AgwgASgCDEEEaioCAAuSAn0jAEEQayIBIABBIGo2AgwgASgCDEEIaioCAAuSOAI0AkAgAioCNEMAAAAAXgRAIwBBEGsiASACKgI0QwAAgD+SOAIMIAIgASoCDJE4AhwgAiACKgIcQwAAAD+UOAIsIAJDAAAAPyACKgIclTgCHCMAQRBrIgEgAEEgajYCDCACIAEoAgxBBGoqAgACfSMAQRBrIgEgAEEQajYCDCABKAIMQQhqKgIAC5MgAioCHJQ4AiAjAEEQayIBIAA2AgwgAiABKAIMQQhqKgIAAn0jAEEQayIBIABBIGo2AgwgASgCDCoCAAuTIAIqAhyUOAIkIwBBEGsiASAAQRBqNgIMIAIgASgCDCoCAAJ9IwBBEGsiASAANgIMIAEoAgxBBGoqAgALkyACKgIclDgCKAwBCyACAn8CfyMAQRBrIgEgADYCDCABKAIMKgIAAn0jAEEQayIBIABBEGo2AgwgASgCDEEEaioCAAtdCwRAQQJBAQJ/IwBBEGsiASAAQRBqNgIMIAEoAgxBBGoqAgACfSMAQRBrIgEgAEEgajYCDCABKAIMQQhqKgIAC10LGwwBC0ECQQACfyMAQRBrIgEgADYCDCABKAIMKgIAAn0jAEEQayIBIABBIGo2AgwgASgCDEEIaioCAAtdCxsLNgIYIAIgAigCGEEBakEDbzYCFCACIAIoAhhBAmpBA282AhAjAEEQayIDIAIoAhhBBHQgAGo2AgwjAEEQayIBIAMoAgwgAigCGEECdGoqAgACfSMAQRBrIgMgAigCFEEEdCAAajYCDCADKAIMIAIoAhRBAnRqKgIAC5MCfSMAQRBrIgMgAigCEEEEdCAAajYCDCADKAIMIAIoAhBBAnRqKgIAC5NDAACAP5I4AgwgAiABKgIMkTgCDCACQSBqIgEgAigCGEECdGogAioCDEMAAAA/lDgCACACQwAAAD8gAioCDJU4AgwjAEEQayIDIAIoAhBBBHQgAGo2AgwgAiADKAIMIAIoAhRBAnRqKgIAAn0jAEEQayIDIAIoAhRBBHQgAGo2AgwgAygCDCACKAIQQQJ0aioCAAuTIAIqAgyUOAIsIwBBEGsiAyACKAIUQQR0IABqNgIMIAMoAgwgAigCGEECdGoqAgAhBCMAQRBrIgMgAigCGEEEdCAAajYCDCADKAIMIQMgAigCFEECdCABaiAEIAIoAhRBAnQgA2oqAgCSIAIqAgyUOAIAIwBBEGsiAyACKAIQQQR0IABqNgIMIAMoAgwgAigCGEECdGoqAgAhBCMAQRBrIgMgAigCGEEEdCAAajYCDCADKAIMIQAgAigCEEECdCABaiAEIAIoAhBBAnQgAGoqAgCSIAIqAgyUOAIACyACKAI4IAJBIGoiACAAQQRqIABBCGogAEEMahB3IAJBQGskAAtrAQF/IwBBgAJrIgUkAAJAIAIgA0wNACAEQYDABHENACAFIAEgAiADayICQYACIAJBgAJJIgEbEAsaIAFFBEADQCAAIAVBgAIQICACQYB+aiICQf8BSw0ACwsgACAFIAIQIAsgBUGAAmokAAsmAQF/IwBBEGsiASQAIAEgADgCDCABKgIMEBwhACABQRBqJAAgAAsmAQF/IwBBEGsiASQAIAEgADgCDCABKgIMEB0hACABQRBqJAAgAAskACAABEBB7PcBQez3ASgCAEEBajYCACAAQZDSASgCABEAAAsLjQEBAX8jAEEwayIDJAAgAyAANgIsIAMgATYCKCADIAI2AiQgAygCLCIAKgLYAkMAAAAAXARAIAAgAygCKBC0AwJ/IwBBEGsiASAAQaAEajYCDCABKAIMCwRAIAMoAiQhASADIAMoAiggAEHcAmoQUSADQRBqIgIgASADELABIAAgAhC1AwsLIANBMGokAAszAgF/AX0jAEEQayIBJAAgASAANgIMIAEoAgwiACAAKAIAKAIwEQYAIQIgAUEQaiQAIAILOQEBfyMAQRBrIgIkACACIAA2AgwgAiABOAIIIAIoAgwiACACKgIIIAAoAgAoAiwRCAAgAkEQaiQACy0AIAJFBEAgACgCBCABKAIERg8LIAAgAUYEQEEBDwsgACgCBCABKAIEEJ8KRQssAQF/IwBBEGsiASQAIAEgADYCDCMAQRBrIAEoAgwiADYCDCABQRBqJAAgAAsVAQF/IwBBEGsiASAANgIMIAEoAgwLoAMBAX8CQEHc2QEtAABBAXENAEHc2QEQEEUNAAJAQdDYAS0AAEEBcQ0AQdDYARAQRQ0AAkBBhNkBLQAAQQFxDQBBhNkBEBBFDQBB2NgBQgA3AgBB1NgBQYCAgPwDNgIAQeDYAUIANwIAQezYAUIANwIAQejYAUGAgID8AzYCAEH02AFCADcCAEH82AFCgICA/AM3AgBBhNkBEA8LQcDYAUIANwIAQcjYAUIANwIAQZjYAUHc2AEpAgA3AgBBkNgBQdTYASkCADcCAEGg2AFB5NgBKQIANwIAQajYAUHs2AEpAgA3AgBBsNgBQfTYASkCADcCAEG42AFB/NgBKQIANwIAQdDYARAPC0Gk2QFBmNgBKQIANwIAQZzZAUGQ2AEpAgA3AgBBrNkBQaDYASkCADcCAEG02QFBqNgBKQIANwIAQbzZAUGw2AEpAgA3AgBBxNkBQbjYASkCADcCAEHM2QFBwNgBKQIANwIAQdTZAUHI2AEpAgA3AgBB3NkBEA8LIAAoAggiAQRAIAFBBGoPCyAAKAIAIgBBPGpBnNkBIAAbCzYBAX8jAEEQayIBJAAgASAANgIMIwBBEGsiACABKAIMNgIMIAAoAgwoAgQhACABQRBqJAAgAAtLAQJ8IAAgAKIiASAAoiICIAEgAaKiIAFEp0Y7jIfNxj6iRHTnyuL5ACq/oKIgAiABRLL7bokQEYE/okR3rMtUVVXFv6CiIACgoLYLTwEBfCAAIACiIgBEgV4M/f//37+iRAAAAAAAAPA/oCAAIACiIgFEQjoF4VNVpT+ioCAAIAGiIABEaVDu4EKT+T6iRCceD+iHwFa/oKKgtgsDAAAL+gEBBX0CQCABIANGDQAgASACRg0AIAIgA0YNACAAIAQQnwUgACgC+AUgACgC8AVBLGxqIgRBXGogACgC0AUgAUHoAGxqIgE2AgAgBEFgaiAAKALQBSACQegAbGoiAjYCACAEQWRqIAAoAtAFIANB6ABsaiIDNgIAIARBeGogAioCCCABKgIIIgaTIgkgAyoCDCABKgIMIgWTIgeUIAIqAgwgBZMiBSADKgIIIAaTIgaUkyIIIAiUIAUgAyoCECABKgIQIgWTIgiUIAIqAhAgBZMiBSAHlJMiByAHlCAFIAaUIAkgCJSTIgYgBpSSkpE4AgAgAEEBOgCcBwsLTQEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAgghASMAQRBrIgAgAigCDDYCDCAAIAE2AgggACgCDCAAKAIINgLwASACQRBqJAALNwEBfyMAQRBrIgEkACABIAA2AgwjAEEQayIAIAEoAgw2AgwgACgCDCgC8AEhACABQRBqJAAgAAsjAQF/IwBBEGsiASQAIAEgADYCDCABKAIMEI4KIAFBEGokAAveAgICfwF9IAC8IgJB/////wdxIgFBgICA/ANPBEAgAUGAgID8A0YEQEPaD0lAQwAAAAAgAkEASBsPC0MAAAAAIAAgAJOVDwsCfSABQf////cDTQRAQ9oPyT8gAUGBgICUA0kNARpDaCGiMyAAIACUIgMgAyADQ2vTDbyUQ7oTL72SlEN1qio+kpQgA0Ou5TS/lEMAAIA/kpUgAJSTIACTQ9oPyT+SDwsgAkF/TARAQ9oPyT8gAEMAAIA/kkMAAAA/lCIAkSIDIAMgACAAIABDa9MNvJRDuhMvvZKUQ3WqKj6SlCAAQ67lNL+UQwAAgD+SlZRDaCGis5KSkyIAIACSDwtDAACAPyAAk0MAAAA/lCIAIAAgAENr0w28lEO6Ey+9kpRDdaoqPpKUIABDruU0v5RDAACAP5KVIACRIgOUIAAgA7xBgGBxviIAIACUkyADIACSlZIgAJIiACAAkgsLJAEBfyMAQRBrIgIgADYCDCACIAE4AgggAigCDCACKgIIOAIECxgBAX8jAEEQayIBIAA2AgwgASgCDCoCBAtLAQJ/IAEgAiACIAAgAigCACgCKBEDACIDIAIoAgAoAhwRAwAiBDYCACAEBEAgAiADIAIoAgAoAjARAgALIAEgACgCBDYCBEHqjwELNAAgAUVBACAALQDMAUEDcRtFBEAgACgC2AFBfnFBBEcEQCAAQQE2AtgBCyAAQQA2AtwBCwtXAQF/IwBBEGsiAiAANgIMIAIgATYCCCACKAIMIgAgACoCACACKAIIKgIAkjgCACAAIAAqAgQgAigCCCoCBJI4AgQgACAAKgIIIAIoAggqAgiSOAIIIAALLQEBfyMAQRBrIgEkACABIAA2AgwgASgCDCIABEAgABA5IAAQDgsgAUEQaiQAC9MCAQR/AkAgAbwiBEH/////B3EiBUGAgID8B00EQCAAvCICQf////8HcSIDQYGAgPwHSQ0BCyAAIAGSDwsgBEGAgID8A0YEQCAAENgDDwsgBEEedkECcSIEIAJBH3ZyIQICQAJAAkAgA0UEQAJAIAJBAmsOAgIAAwtD2w9JwA8LIAVBgICA/AdHBEAgBUUEQEPbD8k/IACYDwsgA0GAgID8B0dBACAFQYCAgOgAaiADTxtFBEBD2w/JPyAAmA8LAn0gA0GAgIDoAGogBUkEQEMAAAAAIAQNARoLIAAgAZWLENgDCyEAIAJBAk0EQAJAAkAgAkEBaw4CAAEFCyAAjA8LQ9sPSUAgAEMuvbszkpMPCyAAQy69uzOSQ9sPScCSDwsgA0GAgID8B0YNAiACQQJ0QaDOAWoqAgAPC0PbD0lAIQALIAAPCyACQQJ0QZDOAWoqAgALuwEBAX8CQCAAKAIEIgMEQCAAQQA2AgQMAQtB6PcBQej3ASgCAEEBajYCAEEsQRBBjNIBKAIAEQMAIgNCADcCACADQQA2AiggA0IANwIgIANCADcCGCADQgA3AhAgA0IANwIICyADIAI2AiQgA0EANgIgIANBADYCKCADIAEpAgA3AgAgAyABKQIINwIIIAMgASkCEDcCECADIAEpAhg3AhggACAAKAIAIAMQzQEgACAAKAIMQQFqNgIMIAMLxAIBAn8gACgCACIBBEAgACABEM8BCyAAKAIEIgEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACyAAQoCAgIBwNwIEIAAoAiAiAQRAIAAtACQEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYCIAsgAEEANgIgIABCADcCGCAAQQA2AhAgAEEBOgAkQQAhASAAKAI0IgIEQCAALQA4BEAgAgRAQez3AUHs9wEoAgBBAWo2AgAgAkGQ0gEoAgARAAALIAAoAiAhAQsgAEEANgI0CyAAQQA2AjQgAEIANwIsIABBAToAOCABBEAgAC0AJARAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgIgCyAAQQA2AiAgAEEBOgAkIABCADcCGAsNACAAIAEgAiADELgNC60CAgN/Bn0jAEEwayIDJAAgASoCCCEGIAEqAgAhByABKgIEIQggAkEANgIMIAIgBkMAAIA/IAcgB5QgCCAIlJIgBiAGlJKRlSIGlDgCCCACIAggBpQ4AgQgAiAHIAaUOAIAIAAoAnghASADQSBqIAAoAgAgACgCfCIEQQF1aiIFIAIgBSgCACABaigCACABIARBAXEbEQUAIAIqAgAhBiACKgIEIQcgAioCCCEIIANBADYCDCADIAiMOAIIIAMgB4w4AgQgAyAGjDgCACADQRBqIAAgAxDeDSADKgIQIQYgAyoCICEHIAMqAhQhCCADKgIkIQkgAyoCGCEKIAMqAighCyACQQA2AhwgAiALIAqTOAIYIAIgCSAIkzgCFCACIAcgBpM4AhAgA0EwaiQAC+QDAQJ/IwBBgAJrIgQkAAJAIAEoAtQBIgNBf0oNAAJAIAEoAuwBIgNBAnFFDQBBACADQR50QR91IAFxIgMqAtgCQwAAAABbIAMtAMwBQQJxGw0AIAAoAgghAyAEQQhqQQBB9AEQCxogAEEEaiAEQQhqENUEIAEgAhCUDiABIAM2AtQBDAELIAAoArwBIgNBf0oNACAAIAAoAgg2ArwBIARBCGpBAEH0ARALGiAAQQRqIARBCGoQ1QQiAUIANwJYIAFCADcCUCABQgA3AkggAUIANwJAIAFCADcCkAEgAUIANwKYASABQgA3AqABIAFCADcCqAEgAUIANwIEIAFBgICA/AM2AgAgAUIANwIMIAFCADcCGCABQYCAgPwDNgIUIAFCADcCICABQgA3AiwgAUGAgID8AzYCKCABQgA3AjQgAUEANgI8IAFCADcCiAEgAUEANgLwASABQgA3AoABIAFCgICA/AM3AnggAUKAgID8g4CAwD83AnAgAUKAgID8AzcCaCABQoCAgPyDgIDAPzcCYCABQgA3AugBIAFCADcC4AEgAUIANwLYASABQgA3AtABIAFCADcCyAEgAUIANwLAASABQgA3ArgBIAFCADcCsAEgACgCvAEhAwsgBEGAAmokACADC1YAIABBADYCLCAAQoCAgICgs+bMPjcCJCAAIAM2AiAgACACNgIcIABBfzYCGCAAQQE7ARQgAEH////7BzYCECAAQn83AgggAEGQwQA2AgAgACABNgIEC3cBAX8jAEEgayIDJAAgAyABNgIcIAMgAjYCGCADIAMoAhwqAgAgAygCGCoCAJM4AhQgAyADKAIcKgIEIAMoAhgqAgSTOAIQIAMgAygCHCoCCCADKAIYKgIIkzgCDCAAIANBFGogA0EQaiADQQxqEAkgA0EgaiQAC0gBAX8jAEEQayICIAA2AgwgAiABNgIIIAIoAgwiACoCACACKAIIKgIAlCAAKgIEIAIoAggqAgSUkiAAKgIIIAIoAggqAgiUkgsEAEEAC1EBAX8jAEEQayIEJAAgBCAANgIMIAQgATYCCCAEIAI4AgQgBCADNgIAIAQoAgwiACAEKAIIIAQqAgQgBCgCACAAKAIAKAIcERcAIARBEGokAAtLAgF/AX0jAEEQayIDJAAgAyAANgIMIAMgATYCCCADIAI2AgQgAygCDCIAIAMoAgggAygCBCAAKAIAKAIgEQ0AIQQgA0EQaiQAIAQLTAEBfyMAQRBrIgIkACACIAA2AgwgAiABOAIIIAIqAgghASMAQRBrIgAgAigCDDYCDCAAIAE4AgggACgCDCAAKgIIOAIQIAJBEGokAAs4AgF/AX0jAEEQayIBJAAgASAANgIMIwBBEGsiACABKAIMNgIMIAAoAgwqAhAhAiABQRBqJAAgAgtSAQF/IwBBEGsiAiQAIAIgADYCDCACIAE6AAsgAi0AC0EBcSEBIwBBEGsiACACKAIMNgIMIAAgAToACyAAKAIMIAAtAAtBAXE6ABUgAkEQaiQAC0QBAX8jAEEQayIBJAAgASAANgIMIAEoAgwiACgCDARAIAAtABBBAXEEQCAAIAAoAgwQ8wULIABBADYCDAsgAUEQaiQAC3cBAX8jAEEgayIDJAAgAyABNgIcIAMgAjYCGCADIAMoAhwqAgAgAygCGCoCAJQ4AhQgAyADKAIcKgIEIAMoAhgqAgSUOAIQIAMgAygCHCoCCCADKAIYKgIIlDgCDCAAIANBFGogA0EQaiADQQxqEAkgA0EgaiQAC9QHAgl/D30gAioCBCIVIBUgAioCCCIWQwAAAACUIhOTIhBDAACAPyAQIBCUIBMgAioCACIQkyIUIBSUkiAQQwAAAACUIg8gFUMAAAAAlCIRkyISIBKUkpEiGJUiDpQgESAWkyINQwAAgD8gECARkyIRIBGUIA0gDZQgEyAPkyINIA2UkpKRIhOVIg+UIBggE14iBBsiE5QgECAUIA6UIA0gD5QgBBsiFJSTIRggECASIA6UIBEgD5QgBBsiEZQgFiATlJMhGSAWIBSUIBUgEZSTIRogAygCDCEJIAFBAUghCgJAA0BBfyEFIApFBEAgAioCCCESIAIqAgQhDiACKgIAIQ1BACEEA0ACQCAJIARBAnRqKAIARQ0AIAVBf0cEQCANIAAgBEEEdGoiAyoCAJQgDiADKgIElJIgEiADKgIIlJIgDSAAIAVBBHRqIgMqAgCUIA4gAyoCBJSSIBIgAyoCCJSSXkEBcw0BCyAEIQULIARBAWoiBCABRw0ACwtBfyEGQQAhBCAJIAVBAnRqIgsoAgBBA0YNAQJAA0AgBiEHIAQiDLIiEkM1+o48lCINEB0hDiANEBwhDUF/IQYgCkUEQCAWIBEgDZQgGCAOlJJDzczMPJSSIQ8gFSAUIA2UIBkgDpSSQ83MzDyUkiEXIBAgEyANlCAaIA6UkkPNzMw8lJIhDkEAIQQDQAJAIAkgBEECdGooAgBFDQAgBkF/RwRAIA4gACAEQQR0aiIDKgIAlCAXIAMqAgSUkiAPIAMqAgiUkiAOIAAgBkEEdGoiAyoCAJQgFyADKgIElJIgDyADKgIIlJJeQQFzDQELIAQhBgsgBEEBaiIEIAFHDQALCyAFIAdGQQAgBSAGRhsNAQJAIAdBf0YNACAGIAdGDQAgEkMAACDCkiIOIBJfQQFzDQADQCAOQzX6jjyUIg8QHSENIA8QHCEPQX8hAyAKRQRAIBYgESAPlCAYIA2UkkPNzMw8lJIhFyAVIBQgD5QgGSANlJJDzczMPJSSIRsgECATIA+UIBogDZSSQ83MzDyUkiENQQAhBANAAkAgCSAEQQJ0aigCAEUNACADQX9HBEAgDSAAIARBBHRqIggqAgCUIBsgCCoCBJSSIBcgCCoCCJSSIA0gACADQQR0aiIIKgIAlCAbIAgqAgSUkiAXIAgqAgiUkl5BAXMNAQsgBCEDCyAEQQFqIgQgAUcNAAsLIAUgB0ZBACADIAVGGw0DIAMhByAOQwAAoECSIg4gEl8NAAsLIAxBLWohBCAMQbwCSQ0ACyALQQA2AgAMAQsLIAtBAzYCAAsgBQuDAgEOfQJAIABFDQAgACgCtAFBAXFFDQAgACoCrAEhDiAAKgIsIQIgACoCDCEGIAAqAhwhByAAKgIkIQMgACoCFCEIIAAqAqgBIQ8gACoCKCEEIAAqAgghCSAAKgIYIQogACoCpAEhBSAAKgIEIQsgAUEANgIMIAEgAyAFIAsgASoCACIFlCAIIAEqAgQiDJSSIAMgASoCCCIDlJKUIg2UIAQgDyAFIAmUIAwgCpSSIAMgBJSSlCIElJIgAiAOIAUgBpQgDCAHlJIgAyAClJKUIgKUkjgCCCABIAggDZQgCiAElJIgByAClJI4AgQgASALIA2UIAkgBJSSIAYgApSSOAIACwv+BAEHfQJAIAIqAmQiBiACKgJwIAYgAioCdJSTIAIqAhAiByAAKgJAlCACKgIUIgggACoCRJSSIAIqAhgiCSAAKgJIlJIgAioCACAAKgJQlCACKgIEIAAqAlSUkiACKgIIIAAqAliUkpIgAioCbCIElJMgBCACKgIwIAEqAkCUIAIqAjQgASoCRJSSIAIqAjggASoCSJSSIAIqAiAgASoCUJQgAioCJCABKgJUlJIgAioCKCABKgJYlJKSlJMiA5IiBCACKgJ4IgVdQQFzRQRAIAUgBpMhAyAFIQQMAQsgBCACKgJ8IgVeQQFzDQAgBSAGkyEDIAUhBAsgAiAEOAJkIAAoAvABBEAgACAAKgJwIAMgByAAKgKAAZSUlCAAKgJAkjgCQCAAIAMgCCAAKgKEAZSUIAAqAnSUIAAqAkSSOAJEIAAgAyAJIAAqAogBlJQgACoCeJQgACoCSJI4AkggAioCSCEEIAIqAkQhBSAAIAMgACoCYJQgAioCQJQgACoCUJI4AlAgACoCaCEGIAAgBSADIAAqAmSUlCAAKgJUkjgCVCAAIAQgAyAGlJQgACoCWJI4AlgLIAEoAvABBEAgAioCOCEEIAIqAjQhBSABIAEqAnAgAyACKgIwIAEqAoABlJSUIAEqAkCSOAJAIAEgAyAFIAEqAoQBlJQgASoCdJQgASoCRJI4AkQgASADIAQgASoCiAGUlCABKgJ4lCABKgJIkjgCSCACKgJYIQQgAioCVCEFIAEgAyABKgJglCACKgJQlCABKgJQkjgCUCABKgJoIQYgASAFIAMgASoCZJSUIAEqAlSSOAJUIAEgBCADIAaUlCABKgJYkjgCWAsLjgUCAX8KfSMAQRBrIgUkACAAKgI0IQYgACoCOCEHIAAqAjAhCiABKgIAIQggASoCBCEJIAEqAgghCyAEQQA2AjwgBCAHIAsgA5SSOAI4IAQgBiAJIAOUkjgCNCAEIAogCCADlJI4AjACfUPbD0k/IAOVIAIqAgAiDiAOlCACKgIEIgwgDJSSIAIqAggiDSANlJKRIgYgBiADlEPbD0k/XhsiBkNvEoM6XUEBc0UEQCADQwAAAD+UIAYgAyADlCADlEOrqqq8lCAGlJSSDAELIAZDAAAAP5QgA5QQHCAGlQshByAAIAUQJiAFKgIIIQogBSoCACEIIAUqAgQhCSAFKgIMIQsgBEEANgIsIARBADYCHCAEQQA2AgwgBCAIIA0gB5QiDZQgCyAMIAeUIgyUIAkgBiADlEMAAAA/lBAdIgOUkpIgCiAOIAeUIgaUkyIHQwAAgD8gAyALlCAGIAiUkyAMIAmUkyANIAqUkyIOIA6UIA0gC5QgAyAKlJIgBiAJlJIgDCAIlJMiDyAPlCADIAiUIAYgC5SSIAwgCpSSIA0gCZSTIgggCJQgByAHlJKSkpGVIgOUIgYgDyADlCIKQwAAAEAgDiADlCIHIAeUIAogCpQgCCADlCIDIAOUIAYgBpSSkpKVIgmUIgiUIgsgByADIAmUIg2UIgySOAIkIAQgAyAIlCIOIAcgBiAJlCIJlCIPkzgCICAEIAsgDJM4AhggBCADIAmUIgsgByAIlCIHkjgCECAEIA4gD5I4AgggBCALIAeTOAIEIARDAACAPyADIA2UIgMgBiAJlCIGkpM4AiggBEMAAIA/IAMgCiAIlCIDkpM4AhQgBEMAAIA/IAYgA5KTOAIAIAVBEGokAAvuBQIDfwh9IwBBgAFrIgckAAJAIAFFDQACQCABKAIoRQ0AIAIgBk5BACAGQX9KGw0AIAAgASgCJCACQQFqIgggAyAEIAUgBhBWIAAgASgCKCAIIAMgBCAFIAYQVgsgAiAFSA0AIAEqAhQhCiABKgIYIQsgASgCKCEFIAEqAhAhDCABKgIAIQ8gASoCBCENIAEqAgghDiAHQQA2AnwgB0EANgJsIAdBADYCXCAHQQA2AkwgB0EANgI8IAdBADYCLCAHQQA2AhwgByAOIAuSQwAAAD+UIhAgCyAOk0MAAAA/lCIOkiILOAJ4IAcgDSAKkkMAAAA/lCIRIAogDZNDAAAAP5QiDZIiCjgCdCAHIAs4AmggByAKOAJkIAcgCzgCWCAHIBEgDZMiDTgCVCAHIAs4AkggByANOAJEIAcgECAOkyILOAI4IAcgCjgCNCAHIAs4AiggByAKOAIkIAcgCzgCGCAHIA04AhQgB0EANgIMIAcgDyAMkkMAAAA/lCIOIAwgD5NDAAAAP5QiDJMiCjgCcCAHIA4gDJIiDDgCYCAHIAw4AlAgByAKOAJAIAcgCjgCMCAHIAw4AiAgByAMOAIQIAcgCjgCACAHIAs4AgggByANOAIEIAAgByAHQRBqIgIgAyAEIAUbIgEgACgCACgCCBEEACAAIAIgB0EgaiIDIAEgACgCACgCCBEEACAAIAMgB0EwaiIEIAEgACgCACgCCBEEACAAIAQgByABIAAoAgAoAggRBAAgACAHQUBrIgUgB0HQAGoiBiABIAAoAgAoAggRBAAgACAGIAdB4ABqIgggASAAKAIAKAIIEQQAIAAgCCAHQfAAaiIJIAEgACgCACgCCBEEACAAIAkgBSABIAAoAgAoAggRBAAgACAHIAUgASAAKAIAKAIIEQQAIAAgAiAGIAEgACgCACgCCBEEACAAIAMgCCABIAAoAgAoAggRBAAgACAEIAkgASAAKAIAKAIIEQQACyAHQYABaiQACzABAX8jAEEQayIDJAAgAyABNgIMIAMgAjYCCCAAIAMoAgggAygCDBAhIANBEGokAAsNACMAQRBrIAA2AgwAC6QBAgF/AX0jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIgAqAgACfSMAQRBrIgEgAigCCDYCDCABKAIMKgIAC5QgACoCBAJ9IwBBEGsiASACKAIINgIMIAEoAgxBBGoqAgALlJIgACoCCAJ9IwBBEGsiASACKAIINgIMIAEoAgxBCGoqAgALlJIhAyACQRBqJAAgAyAAKgIMIAIoAggqAgyUkgssAgF/AX0jAEEQayIBJAAgASAANgIMIAEoAgwiACAAEFkhAiABQRBqJAAgAgtVAQF/IwBBEGsiAiQAIAIgATYCDCACIAIoAgwqAgCMOAIIIAIgAigCDCoCBIw4AgQgAiACKAIMKgIIjDgCACAAIAJBCGogAkEEaiACEAkgAkEQaiQACzkBAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIgAgAigCCCAAKAIAKAIMEQIAIAJBEGokAAtEAQJ/PwAhAQJAQcD8ASgCACICIABBA2pBfHFqIgAgAUEQdE0NACAAEAYNAEH49wFBMDYCAEF/DwtBwPwBIAA2AgAgAgthAwF/An4BfSMAQRBrIgEkAAJ9IAApAwgiAkIAWQRAIAK1QwAAgF+UIAApAwC1kgwBCyABQgAgACkDACIDfTcDACABIANQrSACQn+FfDcDCCABEF6MCyEEIAFBEGokACAEC9QCAQN/Qej3AUHo9wEoAgBBAWo2AgBBJEEQQYzSASgCABEDACIEQv////8PNwIcIARBfzYCFCAEQn83AgwgBCADNgIIIAQgAjYCBCAEIAE2AgAgBCAAKAIEIgI2AhgCQCACIAAoAghHDQAgAiACQQF0QQEgAhsiA04NAAJ/IAMEQEHo9wFB6PcBKAIAQQFqNgIAIANBAnRBEEGM0gEoAgARAwAhBSAAKAIEIQILIAJBAU4LBEBBACEBA0AgBSABQQJ0IgZqIAAoAgwgBmooAgA2AgAgAUEBaiIBIAJHDQALCyAAKAIMIgEEQCAALQAQBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALIAAoAgQhAgsgAEEANgIMCyAAIAU2AgwgAEEBOgAQIAAgAzYCCAsgACgCDCACQQJ0aiAENgIAIAAgAkEBajYCBCAEC04BAX8gAEGgjAE2AgAgACgCNCIBBEAgASABKAIAKAIAEQEAGiAAKAI0IgEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAAvHAgIBfwF9IwBB4ABrIgEkACAAQQE6AFgCQEGw9gEtAABBAXENAEGw9gEQEEUNAEHU9QFCADcCAEHQ9QFBgICA/AM2AgBB3PUBQgA3AgBB6PUBQgA3AwBB5PUBQYCAgPwDNgIAQfD1AUIANwMAQYT2AUIANwIAQYD2AUGAgID8ezYCAEH49QFCgICA/AM3AwBBjPYBQgA3AgBBmPYBQgA3AwBBlPYBQYCAgPx7NgIAQaD2AUIANwMAQaj2AUKAgID8CzcDAEGw9gEQDwsgAEHQ9QEgAUEAQeAAEAsiAUEGIAAoAgAoAkwRBAAgACABKgIAIAAqAiwiApI4AkggACABKgIwIAKTOAI4IAAgAiABKgIUkjgCTCAAIAEqAkQgApM4AjwgACACIAEqAiiSOAJQIABBQGsgASoCWCACkzgCACABQeAAaiQAC8AIAgF/CX0jAEGQA2siBiQAQY3mABAWIAYgAikCCDcD2AIgBiACKQIANwPQAiAGIAIpAhg3A+gCIAYgAikCEDcD4AIgBiACKQIoNwP4AiAGIAIpAiA3A/ACIAYgAikCODcDiAMgBiACKQIwNwOAAyAGIAMpAgg3A5gCIAYgAykCADcDkAIgBiADKQIYNwOoAiAGIAMpAhA3A6ACIAYgAykCKDcDuAIgBiADKQIgNwOwAiAGIAMpAjg3A8gCIAYgAykCMDcDwAIgBkHQAmogBkGQAmogBkEIaiAGQYACahBmIAZBADYC7AEgBiAGKgKAAiIHIAYqAhCUOALoASAGIAcgBioCDJQ4AuQBIAYgByAGKgIIlDgC4AEgBkIANwPYASAGQgA3A9ABIAZBQGtCADcDACAGQgA3AzggBkHQAmogBkGAAmoQJiAGQQA2AjQgBkEANgIkIAYgBioChAIiCCAGKgKIAiIJQwAAAEAgBioCgAIiByAHlCAIIAiUkiAJIAmUkiAGKgKMAiIKIAqUkpUiDJQiDZQiCyAKIAcgDJQiDpQiD5I4AiwgBiALIA+TOAIgIAZDAACAPyAHIA6UIgsgCCAIIAyUIgiUIgySkzgCMCAGQwAAgD8gCyAJIA2UIgmSkzgCHCAGQQA2AhQgBiAHIA2UIgsgCiAIlCIOkzgCKCAGIAcgCJQiByAKIA2UIgiSOAIYIAYgCyAOkjgCECAGIAcgCJM4AgwgBkMAAIA/IAwgCZKTOAIIIAEgBkEIaiAGQdABaiAGQeABaiAGQYACaiAGQfABahCOBCAGQbjxADYCCCAGIAIpAgg3AjQgBiACKQIANwIsIAYgAikCGDcCRCAGIAIpAhA3AjwgBiACKQIoNwJUIAYgAikCIDcCTCAGIAIpAjg3AmQgBiACKQIwNwJcIAYgAykCCDcCdCAGIAMpAgA3AmwgBiADKQIQNwJ8IAYgAykCGDcChAEgBiADKQIoNwKUASAGIAMpAiA3AowBIAYgAykCMDcCnAEgBiADKQI4NwKkASAGIAQ2AsABIAYgBTgCxAEgBiABNgLIASAGIAA2ArwBIAZDawteXUMAAIA/IAYqAqQBIAYqAmSTIgVDAACAPyAGKgKcASAGKgJckyIHIAeUIAYqAqABIAYqAmCTIgggCJSSIAUgBZSSkZUiCpQiCZUgCUMAAAAAWxsiDDgCFCAGQ2sLXl1DAACAPyAIIAqUIg2VIA1DAAAAAFsbIgs4AhAgBiAMQwAAAABdNgIkIAYgC0MAAAAAXTYCICAGIAUgCZQgByAHIAqUIgWUIAggDZSSkjgCKCAGQ2sLXl1DAACAPyAFlSAFQwAAAABbGyIFOAIMIAYgBUMAAAAAXTYCHCAAKAJEIgAgBkGAA2ogBkHAAmogBkEIaiAGQYACaiAGQfABaiAAKAIAKAIYEQwAEBMgBkGQA2okAAuEDQIHfwl9IwBBMGsiAyQAAn8CQAJAIAAoAvQCIgIoAiBBf2oiAUEDSw0AAkACQAJAAkAgAUEBaw4DAQIDAAsgACgC7AIhBUEBIQEDQCADQgA3AyggA0IANwMgIANBIGogBEECdGpBgICA/AM2AgAgAiABQQJ0aiIGQQA2AhAgACAFQX9qIgU2AuwCIAYgACAFQQJ0aigC3AIiBTYCACACIAFBAWo2AiAgACADQSBqIAUQRSAAEGMNBSAAKAL0AiICIAIoAiBBf2oiATYCICAAIAAoAuwCIgVBAnRqIAIgAUECdGooAgAiATYC3AIgACgC9AIhAiADQQA2AhwgAyADKgIojDgCGCADIAMqAiSMOAIUIAMgAyoCIIw4AhAgAiACKAIgIgZBAnRqIgdBADYCECAAIAU2AuwCIAcgATYCACACIAZBAWo2AiAgACADQRBqIAEQRSAAEGMNBSAAKAL0AiICIAIoAiBBf2oiATYCICACIAFBAnRqKAIAIQIgACAAKALsAiIBQQFqIgU2AuwCIAAgAUECdGogAjYC3AIgBEEBaiIEQQNGDQQgACgC9AIiAigCICEBDAAACwALIAIoAgQiASoCGCACKAIAIgIqAhiTIQggASoCFCACKgIUkyEKIAEqAhAgAioCEJMhCUEAIQIDQCADQgA3AyggA0IANwMgIANBIGogAkECdGpBgICA/AM2AgAgA0EANgIcIAMgCCADKgIgIguUIAkgAyoCKCIMlJMiDTgCFCADIAogDJQgCCADKgIkIg6UkyIMOAIQIAMgCSAOlCAKIAuUkyILOAIYIAsgC5QgDCAMlCANIA2UkpJDAAAAAF5BAXNFBEAgACgC9AIiASABKAIgIgRBAnRqIgVBADYCECAAIAAoAuwCQX9qIgY2AuwCIAUgACAGQQJ0aigC3AIiBTYCACABIARBAWo2AiAgACADQRBqIAUQRSAAEGMNBSAAKAL0AiIBIAEoAiBBf2oiBDYCICAAIAAoAuwCIgVBAnRqIAEgBEECdGooAgAiBDYC3AIgACgC9AIhASADQQA2AgwgAyADKgIYjDgCCCADIAMqAhSMOAIEIAMgAyoCEIw4AgAgASABKAIgIgZBAnRqIgdBADYCECAAIAU2AuwCIAcgBDYCACABIAZBAWo2AiAgACADIAQQRSAAEGMNBSAAKAL0AiIBIAEoAiBBf2oiBDYCICABIARBAnRqKAIAIQEgACAAKALsAiIEQQFqNgLsAiAAIARBAnRqIAE2AtwCCyACQQFqIgJBA0cNAAsMAgsgAigCBCIBKgIUIQ0gAigCCCIEKgIYIQwgAigCACIFKgIYIQggASoCGCELIAQqAhQhDiAFKgIUIQogBCoCECEPIAUqAhAhCSABKgIQIRAgA0EANgIsIAMgDSAKkyINIAwgCJMiDJQgCyAIkyILIA4gCpMiDpSTIgg4AiAgAyALIA8gCZMiC5QgECAJkyIJIAyUkyIKOAIkIAMgCSAOlCANIAuUkyIJOAIoIAkgCZQgCCAIlCAKIAqUkpJDAAAAAF5BAXMNASACQQA2AhwgACAAKALsAkF/aiIBNgLsAiAAIAFBAnRqKALcAiEBIAJBBDYCICACIAE2AgwgACADQSBqIAEQRSAAEGMNAiAAKAL0AiICIAIoAiBBf2oiATYCICAAIAAoAuwCIgVBAnRqIAIgAUECdGooAgAiBDYC3AIgACgC9AIhAiADQQA2AhwgAyADKgIojDgCGCADIAMqAiSMOAIUIAMgAyoCIIw4AhAgAiACKAIgIgZBAnRqIgFBADYCECAAIAU2AuwCIAEgBDYCACACIAZBAWo2AiAgACADQRBqIAQQRUEBIAAQYw0DGiAAKAL0AiICIAIoAiBBf2oiATYCICACIAFBAnRqKAIAIQIgACAAKALsAiIBQQFqNgLsAiAAIAFBAnRqIAI2AtwCQQAMAwtBASACKAIAIgAqAhAgAigCDCIEKgIQIgiTIg0gAigCBCIFKgIUIAQqAhQiCpMiDJQgAigCCCICKgIYIAQqAhgiCZMiC5QgACoCFCAKkyIOIAUqAhggCZMiD5QgAioCECAIkyIQlCAAKgIYIAmTIgkgBSoCECAIkyIIlCACKgIUIAqTIgqUkiANIA+UIAqUkyAOIAiUIAuUk5IgCSAMlCAQlJMiCEMAAAAAXCAIIAhbcQ0CGgtBAAwBC0EBCyEBIANBMGokACABC+ACAQJ/IAEgAiAAKAIcIAIoAgAoAhwRAwA2AgAgASACIAAoAiAgAigCACgCHBEDADYCBCABIAIgAiAAIAIoAgAoAigRAwAiAyACKAIAKAIcEQMAIgQ2AgggBARAIAIgAyACKAIAKAIwEQIACyABIAAoAgQ2AgwgASAALQAVNgIYIAEgACgCGDYCKCABIAAoAhA2AiwgASAALQAUNgIwIAEgACgCDDYCFCABIAAoAgg2AhAgASAAKAIkNgIcIAAoAighA0EAIQIgAUEANgIkIAEgAzYCICAAKAIcIgMoAugDIgRBAU4EQCADKALwAyEDA0AgACADIAJBAnRqKAIARgRAIAFBATYCJAsgAkEBaiICIARHDQALCyAAKAIgIgIoAugDIgNBAU4EQCACKALwAyEEQQAhAgNAIAAgBCACQQJ0aigCAEYEQCABQQE2AiQLIAJBAWoiAiADRw0ACwtBvMEACy0AIABBkMEANgIAIAAEQEHs9wFB7PcBKAIAQQFqNgIAIABBkNIBKAIAEQAACwuJBgIBfxd9IwBBQGoiBCQAIAEqAhghDyABKgIUIRAgASoCKCERIAEqAiQhEiAAKgIoIQkgACoCFCEKIAAqAiQhDSAAKgIYIQsgASoCCCETIAEqAgAhFCABKgIEIRUgASoCECEWIAEqAiAhFyAAKgIIIQcgACoCBCEIIAAqAiAhDiAAKgIQIQwgACoCACEGIARBADYCPCAEQQA2AiwgBCAXIAsgCJQgCiAHlJNDAACAPyAGIAogCZQgCyANlJMiGZQgCCALIA6UIAkgDJSTIhqUkiAHIA0gDJQgCiAOlJMiG5SSlSIFlCIYlCASIAwgB5QgCyAGlJMgBZQiC5SSIBEgCiAGlCAMIAiUkyAFlCIKlJI4AjggBCAXIA0gB5QgCSAIlJMgBZQiDJQgEiAJIAaUIA4gB5STIAWUIgeUkiARIA4gCJQgDSAGlJMgBZQiCJSSOAI0IAQgGCAWlCALIBCUkiAKIA+UkjgCKCAEIAwgFpQgByAQlJIgCCAPlJI4AiQgBEEANgIcIAQgFyAZIAWUIgaUIBIgGiAFlCIJlJIgESAbIAWUIgWUkjgCMCAEIAYgFpQgCSAQlJIgBSAPlJI4AiAgBCATIAqUIBQgGJQgFSALlJKSOAIYIAQgEyAIlCAUIAyUIBUgB5SSkjgCFCAEIBMgBZQgFCAGlCAVIAmUkpI4AhAgBEEQaiAEECYgBCAEKgIIIgVDAACAPyAEKgIAIgggCJQgBCoCBCIHIAeUkiAFIAWUkiAEKgIMIgkgCZSSkZUiBpQiBTgCCCAEIAcgBpQiBzgCBCAEIAggBpQiCDgCACAEIAkgBpQiBjgCDCADIAZDAACAv5dDAACAP5YQOiIGIAaSOAIAIAJBADYCDCACIAU4AgggAiAHOAIEIAIgCDgCAAJAIAggCJQgByAHlJIgBSAFlJIiBkMAAIAoXUEBc0UEQCACQgA3AgggAkKAgID8AzcCAAwBCyACIAVDAACAPyAGkZUiBZQ4AgggAiAHIAWUOAIEIAIgCCAFlDgCAAsgBEFAayQACwcAQwAAgD8LAwABC78FAgV/Bn0CQCABRQ0AIAIqAhghCSACKgIUIQogAioCECELIAIqAgghDCACKgIEIQ0gAioCACEOQej3AUHo9wEoAgBBAWo2AgBBgAJBEEGM0gEoAgARAwAiBCABNgIAQcAAIQBBASECA0ACfwJAAkACQCAEIAJBf2oiAUECdGooAgAiByoCACALX0EBcw0AIAcqAhAgDmBBAXMNACAHKgIEIApfQQFzDQAgByoCFCANYEEBcw0AIAcqAgggCV9BAXMNACAHKgIYIAxgQQFzDQAgBygCKARAIAAgAUcEQCAAIQUgBCEGDAQLIAIgAEEBdEEBIAAbIgVKBEAgBCEGIAAiBSEBDAQLQQAhAUEAIQYgBQRAQej3AUHo9wEoAgBBAWo2AgAgBUECdEEQQYzSASgCABEDACEGCyACQQJOBEADQCAGIAFBAnQiAmogAiAEaigCADYCACABQQFqIgEgAEcNAAwEAAsACyAEDQIMAwsgAyAHIAMoAgAoAgwRAgALIAEMAgsgBARAQez3AUHs9wEoAgBBAWo2AgAgBEGQ0gEoAgARAAALIAAhAQsgBiABQQJ0aiAHKAIkNgIAAkACQCABQQFqIgggBUcNACAFIAVBAXRBASAFGyIATg0AQQAhAkEAIQQgAARAQej3AUHo9wEoAgBBAWo2AgAgAEECdEEQQYzSASgCABEDACEECwJAIAFBAE4EQANAIAQgAkECdCIFaiAFIAZqKAIANgIAIAEgAkYhBSACQQFqIQIgBUUNAAwCAAsACyAGRQ0CCyAGBEBB7PcBQez3ASgCAEEBajYCACAGQZDSASgCABEAAAsMAQsgBSEAIAYhBAsgBCAIQQJ0aiAHKAIoNgIAIAFBAmoLIgJBAEoNAAsgBEUNACAEBEBB7PcBQez3ASgCAEEBajYCACAEQZDSASgCABEAAAsLC9QLAgd/BX0jAEHwAGsiBiQAIAAQqgEgAEEBOgCYAiAAQeQiNgIAIABBADYClAIgAEEBOgCYAyAAQQA2ApwCIABCADcCjAIgAEEANgKUAyAAQQE6AKwDIABCADcCjAMgAEEANgKoAyAAQQE6AMADIABCADcCoAMgAEEANgK8AyAAQQE6APADIABCADcCtAMgAEEANgLsAyAAQgA3AuQDIABBAToAhAQgAEEANgKABCAAQQE6AMAFIAAgATYCrAUgAEIANwL4AyAAQQA2ArwFIABCADcCtAUgAEEBOgDUBSAAQQA2AtAFIABCADcCyAUgAEEBOgDoBSAAQQA2AuQFIABCADcC3AUgAEEBOgD8BSAAQQA2AvgFIABCADcC8AUgAEEBOgCQBiAAQQA2AowGIABCADcChAYgAEEBOgCkBiAAQQE6ALgGIABBADYCoAYgAEIANwKYBiAAQQE6AMwGIABBADYCtAYgAEIANwKsBiAAQQE6AOAGIABBADYCyAYgAEIANwLABiAAQQE6APQGIABBADYC3AYgAEIANwLUBiAAQQA2AvAGIABCADcC6AYgAEGgB2oQeiEKIABB3AdqEHoaIABBmAhqEHoaIABB4AhqQQA2AgAgAEHkCGpBAToAACAAQfgIakEBOgAAIABB2AhqQgA3AgAgAEH0CGpBADYCACAAQeAJakEBOgAAIABB7AhqQgA3AgAgAEHcCWpBADYCACAAQdQJakIANwIAIAAQqQUgABDyAiIIQoCAgPwTNwIMIAhCgICA/IOAgMA/NwIEIAAoAsABIgEgASgCACgCMBEGACEMIAZBCGpBAEHkABALGiAAKALIBSIBIAJIBEAgACgCzAUgAkgEQCABIQUCfyACBEBB6PcBQej3ASgCAEEBajYCACACQegAbEEQQYzSASgCABEDACEJIAAoAsgFIQULIAVBAU4LBEADQCAJIAdB6ABsIgtqIAAoAtAFIAtqQegAEBUaIAdBAWoiByAFRw0ACwsgACgC0AUiBQRAIAAtANQFBEAgBQRAQez3AUHs9wEoAgBBAWo2AgAgBUGQ0gEoAgARAAALCyAAQQA2AtAFCyAAIAk2AtAFIABBAToA1AUgACACNgLMBQsDQCAAKALQBSABQegAbGoiBUEANgIAIAVBBGogBkEIakHkABAVGiABQQFqIgEgAkcNAAsLIAAgAjYCyAUgAkEBTgRAQQAhBwNAIAAoAtAFIAdB6ABsakEAQegAEAshBUMAAAAAIQ5DAAAAACEPQwAAAAAhEEMAAAAAIQ1BACEBIAMEQCADKgIMIQ0gAyoCCCEQIAMqAgQhDiADKgIAIQ8gA0EQaiEBCyAFIA84AgggBSAOOAIMIAUgDTgCFCAFIBA4AhAgBSAFKQIINwIYIAUgBSkCEDcCIAJ/IARFBEBDAACAPyENQQAMAQsgBCoCACENIARBBGoLIQQgBUMAAIA/IA2VQwAAAAAgDUMAAAAAXhs4AlggBkEANgIkIAYgDCAQkjgCICAGIAwgDpI4AhwgBiAMIA+SOAIYIAZBADYCFCAGIBAgDJM4AhAgBiAOIAyTOAIMIAYgDyAMkzgCCCAFIAogBkEIaiAFEEI2AmAgBSAINgIEIAEhAyAHQQFqIgcgAkcNAAsLIABB/AZqIQICQCAAKAKgByIBBEAgACgCwAEiAyADKAIAKAIwEQYAIQwgASoCACENIAEqAgQhDiABKgIIIQ8gAEEANgKIByAAIA8gDJM4AoQHIAAgDiAMkzgCgAcgACANIAyTOAL8BiABKgIUIQ0gASoCGCEOIAEqAhAhDyAAQQA2ApgHIAAgDCAOkjgClAcgACAMIA2SOAKQByAAQYwHaiIBIAwgD5I4AgAgACgCvAEiA0UNASAAKAKsBSIEKAIgIgUgAyACIAEgBCgCJCAFKAIAKAIQEQkADAELIAJCADcCACACQgA3AhggAkIANwIQIAJCADcCCAsgBkHwAGokACAACwcAIAAoAhALiAEBAX8jAEEQayIDJAAgAyABNgIMIAMgAjYCCCAAAn8jAEEQayIBIAMoAgwiADYCDCABKAIMIAMoAghBAnRqCwJ/IwBBEGsiASAAQRBqNgIMIAEoAgwgAygCCEECdGoLAn8jAEEQayIBIABBIGo2AgwgASgCDCADKAIIQQJ0agsQCSADQRBqJAAL1wECAX8BfSMAQRBrIgIkACACIAA2AgwgAiABNgIIIwBBEGsiASACKAIMIgA2AgwgASgCDEEIaioCAAJ9IwBBEGsiASACKAIINgIMIAEoAgwqAgALlAJ9IwBBEGsiASAAQRBqNgIMIAEoAgxBCGoqAgACfSMAQRBrIgEgAigCCDYCDCABKAIMQQRqKgIAC5QLkgJ9IwBBEGsiASAAQSBqNgIMIAEoAgxBCGoqAgACfSMAQRBrIgAgAigCCDYCDCAAKAIMQQhqKgIAC5QLkiEDIAJBEGokACADC9cBAgF/AX0jAEEQayICJAAgAiAANgIMIAIgATYCCCMAQRBrIgEgAigCDCIANgIMIAEoAgxBBGoqAgACfSMAQRBrIgEgAigCCDYCDCABKAIMKgIAC5QCfSMAQRBrIgEgAEEQajYCDCABKAIMQQRqKgIAAn0jAEEQayIBIAIoAgg2AgwgASgCDEEEaioCAAuUC5ICfSMAQRBrIgEgAEEgajYCDCABKAIMQQRqKgIAAn0jAEEQayIAIAIoAgg2AgwgACgCDEEIaioCAAuUC5IhAyACQRBqJAAgAwvOAQIBfwF9IwBBEGsiAiQAIAIgADYCDCACIAE2AggjAEEQayIBIAIoAgwiADYCDCABKAIMKgIAAn0jAEEQayIBIAIoAgg2AgwgASgCDCoCAAuUAn0jAEEQayIBIABBEGo2AgwgASgCDCoCAAJ9IwBBEGsiASACKAIINgIMIAEoAgxBBGoqAgALlAuSAn0jAEEQayIBIABBIGo2AgwgASgCDCoCAAJ9IwBBEGsiACACKAIINgIMIAAoAgxBCGoqAgALlAuSIQMgAkEQaiQAIAMLVgEBfyMAQRBrIgEkACABIAA4AgwgASoCDEMAAIC/XQRAIAFDAACAvzgCDAsgASoCDEMAAIA/XgRAIAFDAACAPzgCDAsgASoCDBA6IQAgAUEQaiQAIAALNwEBfyMAQRBrIgEkACABIAA2AgwjAEEQayIAIAEoAgw2AgwgACgCDCgCvAEhACABQRBqJAAgAAtIAQF/IwBBEGsiAiAANgIMIAJBADYCCCACIAE2AgQgAiACKAIINgIAA0AgAigCACACKAIESARAIAIgAigCAEEBajYCAAwBCwsLSgEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAgwiACACKAIIEJUCIAAgAigCCCIBKQIwNwIwIAAgASkCODcCOCACQRBqJAALNgEBfyMAQRBrIgEkACABIAA2AgwjAEEQayIAIAEoAgw2AgwgACgCDEEEaiEAIAFBEGokACAACy8BAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIAIoAggQyQkgAkEQaiQAC00BAX8jAEEQayICJAAgAiAANgIMIAIgATgCCCACKgIIIQEjAEEQayIAIAIoAgw2AgwgACABOAIIIAAoAgwgACoCCDgCuAEgAkEQaiQAC2UBAX8jAEEgayIFIAA2AhwgBSABNgIYIAUgAjYCFCAFIAM2AhAgBSAENgIMIAUoAhwiACAFKAIYKgIAOAIAIAAgBSgCFCoCADgCBCAAIAUoAhAqAgA4AgggACAFKAIMKgIAOAIMC4MBAgN/AX4CQCAAQoCAgIAQVARAIAAhBQwBCwNAIAFBf2oiASAAIABCCoAiBUIKfn2nQTByOgAAIABC/////58BViECIAUhACACDQALCyAFpyICBEADQCABQX9qIgEgAiACQQpuIgNBCmxrQTByOgAAIAJBCUshBCADIQIgBA0ACwsgAQusAgICfwd+IAAoAhAiAiABKAIQIgNHBEAgAiADaw8LIAJFBEBBAA8LAn9BfyABKQMIIgZCIIgiBCAAKQMAIgdC/////w+DIgV+IghCIIggBCAHQiCIIgd+fCAGQv////8PgyIGIAd+IgRCIIh8IAhC/////w+DIARC/////w+DfCIEQiCIfCAEQiCGIgQgBSAGfnwiBiAEVK18IgcgASkDACIEQiCIIgUgACkDCCIIQv////8PgyIJfiIKQiCIIAUgCEIgiCIIfnwgBEL/////D4MiBCAIfiIFQiCIfCAKQv////8PgyAFQv////8Pg3wiBUIgiHwgBUIghiIFIAQgCX58IgQgBVStfCIFVA0AGkEBIAcgBVYNABpBfyAGIARUDQAaIAYgBFYLIAJsC0cAIABBADYCECAAQv////8PNwIIIABCADcCACAAQQA2AiAgAEEBOgAkIABBAToAOCAAQgA3AhggAEEANgI0IABCADcCLCAAC/ADAhF/AX4DQCAAKAIMIg4gAiIRIANqQQJtQQR0aiIEKAIIIRIgBCgCBCEKIAQoAgAhByADIQQDQEF/IQZBfyEJIA4gAkEEdGoiCygCACIMBEAgDCgCDCEJCyAHKAIMQX8gBxshBkF/IQhBfyEFIAsoAgQiDwRAIA8oAgwhBQsgCigCDEF/IAobIQgCQAJAIAkgBkoNAAJAIAUgCEoNACAHIAxHDQAgCiAPRw0CIAsoAgggEksNAQwCCyAHIAxHDQEgBSAITA0BCyACQQFqIQIMAQsDQCAOIARBBHQiFGohBkF/IQlBfyEIIAcoAgxBfyAHGyEIIAYoAgAiEARAIBAoAgwhCQtBfyEFQX8hDSAKKAIMQX8gChshDSAGKAIEIhMEQCATKAIMIQULAkACQCAIIAlKDQACQCANIAVKDQAgByAQRw0AIAogE0cNAiAGKAIIIBJJDQEMAgsgByAQRw0BIA0gBUwNAQsgBEF/aiEEDAELCwJ/IAIgBEwEQCALKQIIIRUgCyAGKQIANwIAIAsgBikCCDcCCCAAKAIMIBRqIgUgDzYCBCAFIBU3AgggBSAMNgIAIARBf2ohBCACQQFqIQILIAIgBEwLBEAgACgCDCEODAELCyAEIBFKBEAgACABIBEgBBB7CyACIANIDQALC1gBAX8CQAJAIAAoAgQiAUENSw0AAkACQAJAIAFBAWsODQQDAwICAwMAAwQEAwQECyAAKgIcIAAqAgyUDwALAAALDAELIAAgACgCACgCMBEGAA8LIAAqAiwLrgMCBH8FfSMAQRBrIQggA0H////7BzYCAEH///97IQcgBEH///97NgIAAkAgACgCCCIKQQFIBEBD//9//yELDAELQQAhBwNAIAAoAhAgB0EEdGoiCSoCACILIAEqAgCUIAkqAgQiDCABKgIElJIgCSoCCCINIAEqAgiUkiABKgIwkiIOIAIqAgCUIAsgASoCEJQgDCABKgIUlJIgDSABKgIYlJIgASoCNJIiDyACKgIElJIgCyABKgIglCAMIAEqAiSUkiANIAEqAiiUkiABKgI4kiIMIAIqAgiUkiILIAMqAgBdQQFzRQRAIAMgCzgCACAFQQA2AgwgBSAMOAIIIAUgDzgCBCAFIA44AgALIAsgBCoCAF5BAXNFBEAgBCALOAIAIAZBADYCDCAGIAw4AgggBiAPOAIEIAYgDjgCAAsgB0EBaiIHIApHDQALIAQqAgAiC7whBwsgAyoCACIMIAteBEAgAyAHNgIAIAQgDDgCACAIIAUpAgg3AwggCCAFKQIANwMAIAUgBikCCDcCCCAFIAYpAgA3AgAgBiAIKQMINwIIIAYgCCkDADcCAAsLowIBBn8gACgCRCIMIQsCQCAMIAAoAkhHDQAgDCELIAwgDEEBdEEBIAwbIg1ODQAgDQR/Qej3AUHo9wEoAgBBAWo2AgAgDUGYAWxBEEGM0gEoAgARAwAhDiAAKAJEBSAMCyIPQQFOBEBBACELA0AgDiALQZgBbCIQaiAAKAJMIBBqQZgBEBUaIAtBAWoiCyAPRw0ACwsgACgCTCILBEAgAC0AUARAIAsEQEHs9wFB7PcBKAIAQQFqNgIAIAtBkNIBKAIAEQAACwsgAEEANgJMCyAAIA42AkwgACANNgJIIABBAToAUCAAKAJEIQsLIAAgC0EBajYCRCAAKAJMIAxBmAFsaiIMIAQ2AowBIAAgDCABIAIgAyAFIAYgByAIIAkgChCTDgugBQIDfwV9IAAgAUECdGpBqAlqKgIAIQYCQCAAIAFBBnRqIgIqAuQGIgcgAioC6AYiCGANACAGIAddQQFzRQRAAkAgByAGk0PbD8lAECUiBUPbD0nAXUEBc0UEQCAFQ9sPyUCSIQUMAQsgBUPbD0lAXkEBcw0AIAVD2w/JwJIhBQsgBYshCQJAIAggBpND2w/JQBAlIgVD2w9JwF1BAXNFBEAgBUPbD8lAkiEFDAELIAVD2w9JQF5BAXMNACAFQ9sPycCSIQULIAYgBkPbD8lAkiAJIAWLXRshBgwBCyAGIAheQQFzDQACQCAGIAiTQ9sPyUAQJSIFQ9sPScBdQQFzRQRAIAVD2w/JQJIhBQwBCyAFQ9sPSUBeQQFzDQAgBUPbD8nAkiEFCyAFiyEJAkAgBiAHk0PbD8lAECUiBUPbD0nAXUEBc0UEQCAFQ9sPyUCSIQUMAQsgBUPbD0lAXkEBcw0AIAVD2w/JwJIhBQsgBkPbD8nAkiAGIAWLIAldGyEGCyACIAY4ApgHAn8CQAJAIAcgCF5BAXNFBEAgACABQQZ0akGcB2ohAwwBCyAHIAZeQQFzRQRAIAAgAUEGdGoiASIAQZQHaiAGIAeTIgU4AgAgAUEBNgKcByAFQ9sPSUBeQQFzRQRAIAAgBUPbD8nAkjgClAcMAwsgBUPbD0nAXUEBcw0CIAAgBUPbD8lAkjgClAcMAgsgACABQQZ0aiICIgRBnAdqIQMgCCAGXUEBcw0AIARBAjYCnAcgAiAGIAiTIgU4ApQHIAVD2w9JQF5BAXNFBEAgAiAFQ9sPycCSOAKUBwwCCyAFQ9sPScBdQQFzDQEgAiAFQ9sPyUCSOAKUBwwBCyADQQA2AgBBACAAIAFBBnRqLQCQB0UNARoLQQELC9gCAgF/EH0gACgCBCIDBEAgAyABIAIQKwsgACgCACIABEAgACoC3AEhCyAAKgLUASEMIAAqAtgBIQ0gACoCzAEhDiAAKgLEASEPIAAqAsgBIRAgACoCvAEhESAAKgK4ASESIAAqArQBIRMgAioCBCEHIAIqAgghCCACKgIAIQkgASoCCCEEIAEqAgQhBSAAIAEqAgAiCiAAKgKAASIGlCAAKgKUApI4ApQCIAAgBiAFlCAAKgKYApI4ApgCIAAgBiAElCAAKgKcApI4ApwCIAAgACgCuAJBAWo2ArgCIAAgEyAEIAeUIAUgCJSTIgaUIBIgCiAIlCAEIAmUkyIElJIgESAFIAmUIAogB5STIgWUkiAAKgKkApI4AqQCIAAgBiAPlCAEIBCUkiAFIA6UkiAAKgKoApI4AqgCIAAgBiAMlCAEIA2UkiAFIAuUkiAAKgKsApI4AqwCCwspAQF/IwBBEGsiASQAIAEgADYCDCABKAIMIgAQLxogABAOIAFBEGokAAsyAQF/IwBBEGsiASQAIAEgADYCDCABKAIMIgAEQCAAIAAoAgAoAggRAAALIAFBEGokAAtNAQF/IwBBEGsiAiQAIAIgADYCDCACIAE4AgggAioCCCEBIwBBEGsiACACKAIMNgIMIAAgATgCCCAAKAIMIAAqAgg4AvgBIAJBEGokAAtNAQF/IwBBEGsiAiQAIAIgADYCDCACIAE4AgggAioCCCEBIwBBEGsiACACKAIMNgIMIAAgATgCCCAAKAIMIAAqAgg4AvwBIAJBEGokAAsvAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDCACKAIIEOUHIAJBEGokAAtNAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCCCEBIwBBEGsiACACKAIMNgIMIAAgATYCCCAAKAIMIAAoAgg2AswBIAJBEGokAAs3AQF/IwBBEGsiASQAIAEgADYCDCMAQRBrIgAgASgCDDYCDCAAKAIMKALMASEAIAFBEGokACAACy8BAX8jAEEQayICJAAgAiAANgIMIAIgATgCCCACKAIMIAIqAggQmgggAkEQaiQACy8BAX8jAEEQayICJAAgAiAANgIMIAIgATgCCCACKAIMIAIqAggQrwggAkEQaiQAC0oBAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIgAgAigCCBCDAiAAIAIoAggiASkCMDcCMCAAIAEpAjg3AjggAkEQaiQACy8BAX8jAEEQayICJAAgAiAANgIMIAIgATgCCCACKAIMIAIqAggQwwggAkEQaiQACzkCAX8BfSMAQRBrIgEkACABIAA2AgwjAEEQayIAIAEoAgw2AgwgACgCDCoC6AEhAiABQRBqJAAgAgs5AgF/AX0jAEEQayIBJAAgASAANgIMIwBBEGsiACABKAIMNgIMIAAoAgwqAuABIQIgAUEQaiQAIAILIgEBfyMAQRBrIgEkACABIAA2AgwgASgCDBA5IAFBEGokAAs5AgF/AX0jAEEQayIBJAAgASAANgIMIwBBEGsiACABKAIMNgIMIAAoAgwqAuQBIQIgAUEQaiQAIAILPQEBfyMAQRBrIgEkACABIAA2AgwjAEEQayIAIAEoAgw2AgwgACgCDCgCzAFBA3FBAEchACABQRBqJAAgAAs9AQF/IwBBEGsiASQAIAEgADYCDCMAQRBrIgAgASgCDDYCDCAAKAIMKALMAUEBcUEARyEAIAFBEGokACAACz0BAX8jAEEQayIBJAAgASAANgIMIwBBEGsiACABKAIMNgIMIAAoAgwoAswBQQJxQQBHIQAgAUEQaiQAIAALKgEBfyMAQRBrIgEkACABIAA2AgwgASgCDBCpCUEBcSEAIAFBEGokACAACzEBAX8jAEEQayICJAAgAiAANgIMIAIgAToACyACKAIMIAItAAtBAXEQPiACQRBqJAALJAEBfyMAQRBrIgEkACABIAA2AgwgASgCDEEAED4gAUEQaiQACzABAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIAIoAgg2AtgBIAJBEGokAAsvAQF/IwBBEGsiASQAIAEgADYCDCMAQRBrIAEoAgwiADYCDCAAEL0BIAFBEGokAAtFAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCCCEAIAIoAgwiASgC2AFBfnFBBEcEQCABIAA2AtgBCyACQRBqJAALNwEBfyMAQRBrIgEkACABIAA2AgwjAEEQayIAIAEoAgw2AgwgACgCDCgCwAEhACABQRBqJAAgAAs7AQF/IwBBEGsiAyQAIAMgADYCDCADIAE2AgggAyACNgIEIAMoAgwgAygCCCADKAIEEPMJIANBEGokAAsyAQF/IwBBEGsiASQAIAEgADYCDCABKAIMIgAQpwMjAEEQayAAQTBqNgIMIAFBEGokAAs1AQF/IwBBEGsiAiAANgIMIAIgATYCCCACKAIMIgAgAigCCCIBKQIANwIQIAAgASkCCDcCGAsYAQF/IwBBEGsiASAANgIMIAEoAgxBEGoLJAEBfyMAQRBrIgIgADYCDCACIAE4AgggAigCDCACKgIIOAIMCxgBAX8jAEEQayIBIAA2AgwgASgCDCoCDAskAQF/IwBBEGsiAiAANgIMIAIgATgCCCACKAIMIAIqAgg4AggLGAEBfyMAQRBrIgEgADYCDCABKAIMKgIIC54BAQF/IwBBMGsiCiQAIAogADYCLCAKIAE2AiggCiACNgIkIAogAzYCICAKIAQ2AhwgCiAFNgIYIAogBjYCFCAKIAc2AhAgCiAINgIMIAogCTYCCCAKKAIsIgAgCigCKCAKKAIkIAooAiAQCSAAQRBqIAooAhwgCigCGCAKKAIUEAkgAEEgaiAKKAIQIAooAgwgCigCCBAJIApBMGokAAtHAQF/IAAgARDOARogACgCBCICBEBB7PcBQez3ASgCAEEBajYCACACQZDSASgCABEAAAsgACABNgIEIAAgACgCDEF/ajYCDAuDAQEEfwJAIAAgARDOASIDRQRAQQAhAwwBCyAAKAIIIgVBAE4EQCAFRQ0BA0AgAygCICIGRQ0CIAYhAyAFIARBAWoiBEcNAAsMAQsgACgCACEDCyABIAIpAgA3AgAgASACKQIYNwIYIAEgAikCEDcCECABIAIpAgg3AgggACADIAEQzQEL9QMBCX8jAEEgayIEJAACQCAAKAIMIAEgAUF/TBsiAUEBSA0AIAAoAgAiAkUNAANAQQAhBiACQShqIgcoAgAEQANAAkAgAigCICIDIAJNBEAgAiEDDAELIAMoAigiBSACRiEJIAMgAiAFR0ECdCIKaigCJCEIAn8gACADKAIgIgVFDQAaIAUgBSgCKCADRkECdGpBJGoLIAI2AgAgCCACNgIgIAMgAjYCICACIAU2AiAgAyACKAIkNgIkIAMgBygCADYCKCACKAIkIAM2AiAgBygCACADNgIgIAJBJGoiBSAJQQJ0aiADNgIAIAUgCmogCDYCACAEIANBGGopAgA3AxggBCADQRBqKQIANwMQIAQgA0EIaikCADcDCCAEIAMpAgA3AwAgAyACQRhqKQIANwIYIAMgAkEQaikCADcCECADIAJBCGopAgA3AgggAyACKQIANwIAIAIgBCkDGDcCGCACIAQpAxA3AhAgAiAEKQMINwIIIAIgBCkDADcCAAsgACgCECAGdiECIAZBAWpBH3EhBiADIAJBAXFBAnRqKAIkIgJBKGoiBygCAA0ACwsgAAJ/QQAgACACEM4BRQ0AGiAAKAIACyACEM0BIAAgACgCEEEBajYCECABQX9qIgFFDQEgACgCACECDAAACwALIARBIGokAAueAQEBfyAAKAIAIgEEQCAAIAEQzwELIAAoAgQiAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALIABCgICAgHA3AgQgACgCICIBBEAgAC0AJARAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgIgCyAAQQA2AiAgAEIANwIYIABBADYCECAAQQE6ACQLqAEBCH0gACAAKAIAKAIwEQYAIQIgACAAKAIAKAIwEQYAIQMgACAAKAIAKAIwEQYAIQQgACABOAIsIAAqAiQhASAAKgIgIQUgACoCHCEGIAAgACgCACgCMBEGACEHIAAgACgCACgCMBEGACEIIAAgACgCACgCMBEGACEJIABBADYCKCAAIAMgBZIgCJM4AiAgACACIAaSIAeTOAIcIAAgBCABkiAJkzgCJAs5AQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDCIAIAIoAgggACgCACgCEBECACACQRBqJAALxgEBBH8gASgCvAEiAwRAIAAoAkQiAiACKAIAKAIkEQEAIgIgAyAAKAIYIAIoAgAoAigRBQAgACgCRCICIAMgACgCGCACKAIAKAIMEQUAIAFBADYCvAELAkAgACgCCCICQQFIDQAgACgCECEEQQAhAwNAIAEgBCADQQJ0aiIFKAIARwRAIANBAWoiAyACRw0BDAILCyADIAJODQAgBSAEIAJBf2oiA0ECdCICaigCADYCACAAKAIQIAJqIAE2AgAgACADNgIICwvxAQAgAEIANwK8ASAAQoCAgICw7YKv3QA3ArQBIABCgICA/IOAgMA/NwKkASAAQeTKADYCACAAQYCAgPwDNgL0ASAAQgE3AuwBIABCADcC5AEgAEKAgICAgICAgD83AtwBIABC/////x83AtQBIABCgYCAgHA3AswBIABCADcC+AEgAEGAgID8AzYCBCAAQoCAgPwDNwKsASAAQgA3AsQBIABCADcCgAIgAEIANwIIIABCADcCECAAQgA3AiQgAEGAgID8AzYCGCAAQgA3AhwgAEFAa0EANgIAIABBgICA/AM2AiwgAEIANwI4IABCADcCMAulCAIBfxh9IAQgBC0AEEFwcSIFOgAQIAMqAgAiGyABKgIAIgyTIhAgACoCACILIAyTIgaUIAMqAgQiHCABKgIEIg2TIhEgACoCBCIJIA2TIgeUkiADKgIIIh0gASoCCCIOkyISIAAqAggiEyAOkyIIlJIhCiAEAn0CQCACKgIAIhggDJMiFCAGlCACKgIEIhkgDZMiFSAHlJIgAioCCCIaIA6TIhYgCJSSIgdDAAAAAF9BAXMNACAKQwAAAABfQQFzDQAgBCABKQIANwIAIAQgASkCCDcCCCAEIAVBAXI6ABBDAAAAACEHQwAAAAAhBkMAAIA/DAELIBAgCyAYkyIGlCARIAkgGZMiCJSSIBIgEyAakyIPlJIhFwJAIBQgBpQgFSAIlJIgFiAPlJIiCEMAAAAAYEEBcw0AIBcgCF9BAXMNACAEIAIpAgA3AgAgBCACKQIINwIIIAQgBUECcjoAEEMAAIA/IQdDAAAAACEGQwAAAAAMAQsgByAXlCAIIAqUkyEPAkAgCEMAAAAAX0EBcw0AIAdDAAAAAGBBAXMNAEMAAAAAIQYgD0MAAAAAX0EBcw0AIARBADYCDCAEIAVBA3I6ABAgBCAOIBYgByAHIAiTlSIHlJI4AgggBCANIBUgB5SSOAIEIAQgDCAUIAeUkjgCAEMAAIA/IAeTDAELIBQgCyAbkyIGlCAVIAkgHJMiCZSSIBYgEyAdkyITlJIhCwJAIBAgBpQgESAJlJIgEiATlJIiBkMAAAAAYEEBcw0AIAsgBl9BAXMNACAEIAMpAgA3AgAgBCADKQIINwIIIAQgBUEEcjoAEEMAAIA/IQZDAAAAACEHQwAAAAAMAQsgCyAKlCAHIAaUkyEJAkAgBkMAAAAAX0EBcw0AIApDAAAAAGBBAXMNAEMAAAAAIQcgCUMAAAAAX0EBcw0AIARBADYCDCAEIAVBBXI6ABAgBCAOIBIgCiAKIAaTlSIGlJI4AgggBCANIBEgBpSSOAIEIAQgDCAQIAaUkjgCAEMAAIA/IAaTDAELAkAgCCAGlCALIBeUkyIKQwAAAABfQQFzDQAgFyAIkyIHQwAAAABgQQFzDQAgCyAGkyIGQwAAAABgQQFzDQAgBEEANgIMIAQgBUEGcjoAECAEIBogHSAakyAHIAcgBpKVIgaUkjgCCCAEIBkgHCAZkyAGlJI4AgQgBCAYIBsgGJMgBpSSOAIAQwAAgD8gBpMhB0MAAAAADAELIARBADYCDCAEIAVBB3I6ABAgBCASIA9DAACAPyAPIAogCZKSlSIHlCIGlCAOIBYgCSAHlCIHlJKSOAIIIAQgESAGlCANIBUgB5SSkjgCBCAEIBAgBpQgDCAUIAeUkpI4AgBDAACAPyAHkyAGkws4AhQgBEEANgIgIAQgBjgCHCAEIAc4AhgLwgUCA38JfSAAKALISCIFBEAgBSgCMCIGBEAgBiAFKAIsNgIsCyAFKAIsIgYEQCAGIAUoAjA2AjALIAUgACgCyEhGBEAgACAFKAIwNgLISAsgAEHMyABqIgYgBigCAEF/ajYCACAFQQA2AiwgBSAAKALASDYCMCAAKALASCIGBEAgBiAFNgIsCyAAIAU2AsBIIABBxMgAaiIGIAYoAgBBAWo2AgAgBSADNgIcIAUgAjYCGCAFIAE2AhQgBUEAOgA3IAIqAhghCyADKgIYIQ8gASoCGCEIIAMqAhQhDCABKgIUIQogAioCFCENIAIqAhAhDiADKgIQIRAgASoCECEJIAVBADYCDCAFIA4gCZMiDiAMIAqTIgyUIA0gCpMiDSAQIAmTIgmUkyIKOAIIIAUgCyAIkyILIAmUIA4gDyAIkyIJlJMiCDgCBCAFIA0gCZQgCyAMlJMiCTgCAEECIQcCQCAJIAmUIAggCJSSIAogCpSSkSIIQxe30TheQQFzDQACQCAFIAEgAiAFQRBqIgYQywINACAFIAIgAyAGEMsCDQAgBSADIAEgBhDLAg0AIAUgASoCECAFKgIAlCABKgIUIAUqAgSUkiABKgIYIAUqAgiUkiAIlTgCEAsgBUMAAIA/IAiVIgggBSoCAJQ4AgAgBSAIIAUqAgSUOAIEIAUgCCAFKgIIlDgCCCAEBEAgBQ8LQQMhByAGKgIAQ6zFJ7dgRQ0AIAUPCyAAIAc2AgAgBSgCMCIBBEAgASAFKAIsNgIsCyAFKAIsIgEEQCABIAUoAjA2AjALIAUgACgCwEhGBEAgACAFKAIwNgLASAsgACAAKALESEF/ajYCxEggBUEANgIsIAUgACgCyEg2AjAgACgCyEgiAQRAIAEgBTYCLAsgACAFNgLISCAAIAAoAsxIQQFqNgLMSEEADwsgAEEFNgIAQQALKgEBfyMAQRBrIgEkACABIAA2AgwgASgCDCIABEAgABDPAgsgAUEQaiQAC+gHAgt/BX0jAEHgAGsiAiQAIAAoAgwiAyAAKAIIQQRqIAJB0ABqIAJBQGsgAygCACgCCBEEACABKAJEIgMgACgCCCgCvAEgAkHQAGogAkFAayABKAIYIAMoAgAoAhARCQAgASgCGCIDIAAoAggoApwCIAFBHGogAyADKAIAKAIgEQQAIAAgACgCCCIBKQI0NwJcIAAgASkCPDcCZCABKAKcAiIBIAEoAgAoAiQRAQBBAU4EQCAAQYABaiEJA0AgACgChAEiAUF/TARAIAAoAogBQX9MBEAgACgCjAEiAwRAIAAtAJABBEAgAwRAQez3AUHs9wEoAgBBAWo2AgAgA0GQ0gEoAgARAAALCyAAQQA2AowBCyAAQQE6AJABIABCADcCiAELA0AgACgCjAEgAUECdGpBADYCACABQQFqIgMgAU8hBCADIQEgBA0ACwsgAEEANgKEASAAKAIIKAKcAiIBIAEoAgAoAhwRAQAoAgwgBkEEdGoiASgCBCgCACEDAkAgASgCACgCACIEQQAgBC0AzAFBBHEbDQAgA0EAIAMtAMwBQQRxGw0AIAEoAggiAQRAIAEgCSABKAIAKAIQEQIACyAAKAKEASIKQQFIDQAgACgCCCELIAAoAowBIQxBACEDA0AgDCADQQJ0aigCACIEKALsBSIHQQBKBEBDAACAv0MAAIA/IAQoAuQFIAtGGyENQQAhBQNAIAQgBUG4AWxqIgEqAlQiDkMAAAAAXUEBc0UEQCAOIA9dQQFzRQRAIAEqAkQhDyABKgJIIRAgASoCTCERIABBADYCpAEgACANIBGUOAKgASAAIA0gEJQ4ApwBIAAgDSAPlDgCmAEgBCgC7AUhByAOIQ8LIAEqAkwhECABKgJIIREgACAOIA0gASoCRJSUQ83MTD6UIAAqAlySOAJcIAAgDiANIBGUlEPNzEw+lCAAKgJgkjgCYCAAIA4gDSAQlJRDzcxMPpQgACoCZJI4AmRBASEICyAFQQFqIgUgB0gNAAsLIANBAWoiAyAKRw0ACwsgBkEBaiIGIAAoAggoApwCIgEgASgCACgCJBEBAEgNAAsLIAIgACgCCCIBIgMpAgw3AwggAiABKQIENwMAIAIgASkCHDcDGCACIAEpAhQ3AxAgAiABKQIsNwMoIAIgASkCJDcDICACIAApAmQ3AzggAiAAKQJcNwMwIAEgASgChAJBAWo2AoQCIAMgAikDCDcCDCABIAIpAwA3AgQgASACKQMYNwIcIAEgAikDEDcCFCABIAIpAyA3AiQgASACKQMoNwIsIAEgAikDMDcCNCABIAIpAzg3AjwgAkHgAGokACAIC4sEAgF/Dn0jAEFAaiIDJAAgAUEAOgBUIAMgACgCdCIAKQIMNwMIIAMgACkCBDcDACADIAApAhw3AxggAyAAKQIUNwMQIAMgACkCLDcDKCADIAApAiQ3AyAgAyAAKQI8NwM4IAMgACkCNDcDMAJAIAJFDQAgACgC4AMiAEUNACAAIAMgACgCACgCCBECAAsgAyoCNCEQIAMqAhghByADKgIUIQggAyoCOCEEIAMqAighCSADKgIkIQogAyoCMCERIAMqAgghCyADKgIEIQwgAyoCACENIAMqAhAhDiADKgIgIQ8gAUEANgIwIAEgBCAPIAEqApwBIgSUIAogASoCoAEiBZSSIAkgASoCpAEiBpSSkjgCLCABIBAgBCAOlCAFIAiUkiAGIAeUkpI4AiggASARIAQgDZQgBSAMlJIgBiALlJKSOAIkIAFBQGtBADYCACABIA8gASoCrAEiBJQgCiABKgKwASIFlJIgCSABKgK0ASIGlJI4AjwgASAEIA6UIAUgCJSSIAYgB5SSOAI4IAEgDSAElCAMIAWUkiALIAaUkjgCNCABKgLEASEEIAEqAsABIQUgASoCvAEhBiABQQA2AlAgASAPIAaUIAogBZSSIAkgBJSSOAJMIAEgDiAGlCAIIAWUkiAHIASUkjgCSCABIA0gBpQgDCAFlJIgCyAElJI4AkQgA0FAayQAC6ABAQF/IwBBIGsiAyQAIAMgATYCHCADIAI2AhggAyADKAIcIgEqAgQgAygCGCoCCJQgASoCCCADKAIYKgIElJM4AhQgAyABKgIIIAMoAhgqAgCUIAEqAgAgAygCGCoCCJSTOAIQIAMgASoCACADKAIYKgIElCABKgIEIAMoAhgqAgCUkzgCDCAAIANBFGogA0EQaiADQQxqEAkgA0EgaiQAC68BAQF9QwAAgD8hBQJAIAEgAl4NAEMAAAAAIQUgASACWw0AIAMgBJUiA0MAAAAAXUEBc0UEQAJAIAAgAWBBAXMNACABIAOTIABeQQFzDQAgASAAkyADlQ8LQwAAAABDAACAPyAAIAFdGw8LIANDAAAAAF5BAXMNAAJAIAAgAl9BAXMNACACIAOTIABdQQFzDQAgAiAAkyADlQ8LQwAAAABDAACAPyAAIAJeGyEFCyAFC54JARh9IAEqAjQhGCABKgI4IRkgACoCYCEMIAAqAmQhDSAAKgJoIQ4gASoCFCEDIAEqAhghBCAAQUBrKgIAIQ8gACoCUCEQIAAqAjQhESAAKgJEIRIgACoCVCETIAAqAjghFCABKgIkIQUgACoCSCEVIAEqAighBiAAKgJYIRYgASoCMCEaIAEqAgghByABKgIAIQggASoCBCEJIAEqAhAhCiAAKgIwIRcgASoCICELIABB5AhqQQA2AgAgAEHUCGpBADYCACAAQcQIakEANgIAIABBtAhqQQA2AgAgAEHQCGogFCALlCAVIAWUkiAWIAaUkjgCACAAQcwIaiARIAuUIBIgBZSSIBMgBpSSOAIAIABByAhqIBcgC5QgDyAFlJIgECAGlJI4AgAgAEHACGogFCAKlCAVIAOUkiAWIASUkjgCACAAQbwIaiARIAqUIBIgA5SSIBMgBJSSOAIAIABBuAhqIBcgCpQgDyADlJIgECAElJI4AgAgAEGwCGogCCAUlCAJIBWUkiAHIBaUkjgCACAAQawIaiAIIBGUIAkgEpSSIAcgE5SSOAIAIAAgFyAIlCAPIAmUkiAQIAeUkjgCqAggAEHgCGogGSALIAyUIAUgDZSSIAYgDpSSkjgCACAAQdwIaiAYIAogDJQgAyANlJIgBCAOlJKSOAIAIABB2AhqIBogCCAMlCAJIA2UkiAHIA6UkpI4AgAgAioCNCEYIAIqAjghGSAAKgKgASEMIAAqAqQBIQ0gACoCqAEhDiACKgIUIQMgAioCGCEEIAAqAoABIQ8gACoCkAEhECAAKgJ0IREgACoChAEhEiAAKgKUASETIAAqAnghFCAAKgKIASEVIAIqAiQhBSAAKgKYASEWIAIqAighBiACKgIwIRogAioCCCEHIAIqAgAhCCACKgIEIQkgAioCECEKIAAqAnAhFyACKgIgIQsgAEGkCWpBADYCACAAQZQJakEANgIAIABBhAlqQQA2AgAgAEH0CGpBADYCACAAQZAJaiAUIAuUIBUgBZSSIBYgBpSSOAIAIABBjAlqIBEgC5QgEiAFlJIgEyAGlJI4AgAgAEGICWogFyALlCAPIAWUkiAQIAaUkjgCACAAQYAJaiAUIAqUIBUgA5SSIBYgBJSSOAIAIABB/AhqIBEgCpQgEiADlJIgEyAElJI4AgAgAEH4CGogFyAKlCAPIAOUkiAQIASUkjgCACAAQfAIaiAIIBSUIAkgFZSSIAcgFpSSOAIAIABB7AhqIAggEZQgCSASlJIgByATlJI4AgAgACAXIAiUIA8gCZSSIBAgB5SSOALoCCAAQaAJaiAZIAsgDJQgBSANlJIgBiAOlJKSOAIAIABBnAlqIBggCiAMlCADIA2UkiAEIA6UkpI4AgAgAEGYCWogGiAIIAyUIAkgDZSSIAcgDpSSkjgCACAAENQOIAAQ1Q4gAC0AlQoEQCAAIAAoAhwqAtgCIgRDAAAANF0gACgCICoC2AIiA0MAAAA0XXI6AIAKIAAgAyAEIAOSIgOVQwAAAD8gA0MAAAAAXhsiAzgC+AkgAEMAAIA/IAOTOAL8CQsLAwABC5oCAQV/AkAgACgCDCIDRQ0AIAAtAAhFDQACQCABKAIEIgIgASgCCEcNACACIAJBAXRBASACGyIETg0AAn8gBARAQej3AUHo9wEoAgBBAWo2AgAgBEECdEEQQYzSASgCABEDACEFIAEoAgQhAgsgAkEBTgsEQEEAIQMDQCAFIANBAnQiBmogASgCDCAGaigCADYCACADQQFqIgMgAkcNAAsLIAEoAgwiAwRAIAEtABAEQCADBEBB7PcBQez3ASgCAEEBajYCACADQZDSASgCABEAAAsgASgCBCECCyABQQA2AgwLIAEgBTYCDCABQQE6ABAgASAENgIIIAAoAgwhAwsgASgCDCACQQJ0aiADNgIAIAEgAkEBajYCBAsL2gEBCX8gACgCaEEBTgRAA0AgACgCcCAGQQN0aiIIKAIEIQICfyAAKAIEKAKsBSIHKAI8IgFBAU4EQEEAIQQDQEEAIQUgBygCRCAEQQJ0aiIJKAIAIgMEQANAIAMoApgCIQECQCACIAMoApQCRwRAIAMhBQwBCyAFQZgCaiAJIAUbIAE2AgAgAxAOCyABIgMNAAsgBygCPCEBCyAEQQFqIgQgAUgNAAsgCCgCBCECCyACCwRAIAIgAigCACgCBBEAAAsgBkEBaiIGIAAoAmhIDQALCyAAQTxqEL4PC6ADARJ9IAAqAtwBIQogACoC1AEhCyAAKgLYASEMIAAqAswBIQ0gACoCxAEhDiAAKgLIASEPIAAqArwBIRAgACoCuAEhESAAKgK0ASESIAEqAgQhBiABKgIIIQcgASoCACEIIAIqAgghAyACKgIEIQUgACACKgIAIgkgACoCgAEiBJQiEyAAKgL0AZI4AvQBIAAgBCAFlCIUIAAqAvgBkjgC+AEgACAEIAOUIgQgACoC/AGSOAL8ASAAIBMgACoCvAKSOAK8AiAAIBQgACoCwAKSOALAAiAAIAQgACoCxAKSOALEAiAAIBIgAyAGlCAFIAeUkyIElCARIAkgB5QgAyAIlJMiA5SSIBAgBSAIlCAJIAaUkyIFlJIiBiAAKgKEApI4AoQCIAAgBCAOlCADIA+UkiAFIA2UkiIHIAAqAogCkjgCiAIgACAEIAuUIAMgDJSSIAUgCpSSIgMgACoCjAKSOAKMAiAAIAYgACoCzAKSOALMAiAAIAcgACoC0AKSOALQAiAAIAMgACoC1AKSOALUAiAAIAAoArQCQQFqNgK0AgsEAEEBC1EBAX8jAEEQayIEJAAgBCAANgIMIAQgATYCCCAEIAI7AQYgBCADOwEEIAQoAgwiACAEKAIIIAQuAQYgBC4BBCAAKAIAKAIkEQQAIARBEGokAAtXAQF/IwBBEGsiASQAIAEgADYCCAJAAn8jAEEQayIAIAEoAgg2AgwgACgCDCgC7AFBBEYLBEAgASABKAIINgIMDAELIAFBADYCDAsgAUEQaiQAIAEoAgwLNgEBfyMAQRBrIgEkACABIAA2AgwjAEEQayIAIAEoAgw2AgwgACgCDCgCNCEAIAFBEGokACAAC1IBAX8jAEEgayIFJAAgBSAANgIcIAUgATYCGCAFIAI2AhQgBSADNgIQIAUgBDYCDCAFKAIcIAUoAhggBSgCFCAFKAIQIAUoAgwQdyAFQSBqJAALOQEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAgwiACACKAIIIAAoAgAoAkARAgAgAkEQaiQACzEBAX8jAEEQayIBIAA2AgwgASgCDCIAQQE6ABAgAEEANgIMIABBADYCBCAAQQA2AggLNgEBfyMAQRBrIgEkACABIAA2AgwjAEEQayIAIAEoAgw2AgwgACgCDEEcaiEAIAFBEGokACAACyQBAX8jAEEQayICIAA2AgwgAiABNgIIIAIoAgwgAigCCDYCAAsYAQF/IwBBEGsiASAANgIMIAEoAgwoAgALVwEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAgghASMAQRBrIgAgAigCDDYCDCAAIAE2AgggACgCDCgCDCAAKAIIQQJ0aigCACEAIAJBEGokACAACycBAX8jAEEQayIBJAAgASAANgIMIAEoAgwQhAkhACABQRBqJAAgAAs1AQF/IwBBEGsiAiAANgIMIAIgATYCCCACKAIMIgAgAigCCCIBKQIANwIAIAAgASkCCDcCCAskAQF/IwBBEGsiAiAANgIMIAIgATgCCCACKAIMIAIqAgg4AgALGAEBfyMAQRBrIgEgADYCDCABKAIMKgIAC6gBAAJAIAFBgAhOBEAgAEQAAAAAAADgf6IhACABQf8PSARAIAFBgXhqIQEMAgsgAEQAAAAAAADgf6IhACABQf0XIAFB/RdIG0GCcGohAQwBCyABQYF4Sg0AIABEAAAAAAAAEACiIQAgAUGDcEoEQCABQf4HaiEBDAELIABEAAAAAAAAEACiIQAgAUGGaCABQYZoShtB/A9qIQELIAAgAUH/B2qtQjSGv6ILRgECfyAAKAIEIgVBCHUhBiAAKAIAIgAgASACKAIAIAZqKAIAIAYgBUEBcRsgAmogA0ECIAVBAnEbIAQgACgCACgCGBEJAAtRAQF/IwBBEGsiBCQAIAQgADYCDCAEIAE2AgggBCACNgIEIAQgAzYCACAEKAIMIgAgBCgCCCAEKAIEIAQoAgAgACgCACgCIBEEACAEQRBqJAALJAEBfyMAQRBrIgIgADYCDCACIAE2AgggAigCDCACKAIINgIICxgBAX8jAEEQayIBIAA2AgwgASgCDCgCCAsmAQF/A0AgAEIANwIEIAAoAhgiAQRAIAEQywELIAAoAhwiAA0ACwu3AwIDfwZ9An8CQCABKgIAIAIqAgAiCV9FBEAgAioCBCEIDAELIAEqAgQgAioCBCIIX0EBcw0AIAEqAgggAioCCF9BAXMNACABKgIQIAIqAhBgQQFzDQAgASoCFCACKgIUYEEBcw0AQQAgASoCGCACKgIYYA0BGgsgAiAIIASTIgg4AgQgAiAJIASTIgk4AgAgAiACKgIIIASTIgo4AgggAiACKgIQIASSIgs4AhAgAiACKgIUIASSIgw4AhQgAiACKgIYIASSIgQ4AhggAiADKgIAIg1DAAAAAF4iBUEEdGogCyAJIAUbIA2SOAIAIAJBFEEEIAMqAgQiCUMAAAAAXiIFG2ogDCAIIAUbIAmSOAIAIAJBGEEIIAMqAggiCEMAAAAAXiIDG2ogBCAKIAMbIAiSOAIAAkAgACABEM4BIgNFBEBBACEDDAELIAAoAggiB0EATgRAIAdFDQEDQCADKAIgIgVFDQIgBSEDIAcgBkEBaiIGRw0ACwwBCyAAKAIAIQMLIAEgAikCADcCACABIAIpAhg3AhggASACKQIQNwIQIAEgAikCCDcCCCAAIAMgARDNAUEBCwvPBgICfwN9IAAoAgBFBEAgACACNgIAIAJBADYCIA8LIAEoAigiAwRAIAIqAgAgAioCEJIhBiACKgIIIAIqAhiSIQUgAioCBCACKgIUkiEHA0AgAUEkaiAGIAEoAiQiASoCACABKgIQkpOLIAcgASoCBCABKgIUkpOLkiAFIAEqAgggASoCGJKTi5IgBiADKgIAIAMqAhCSk4sgByADKgIEIAMqAhSSk4uSIAUgAyoCCCADKgIYkpOLkl1BAXNBAnRqKAIAIgEoAigiAw0ACwsgASgCICEEAkAgACgCBCIDBEAgAEEANgIEDAELQej3AUHo9wEoAgBBAWo2AgBBLEEQQYzSASgCABEDACIDQgA3AgAgA0EANgIoIANCADcCICADQgA3AhggA0IANwIQIANCADcCCAsgA0IANwIkIAMgBDYCICADIAIqAgAiBiABKgIAIgUgBiAFXRs4AgAgAyACKgIQIgYgASoCECIFIAYgBV4bOAIQIAMgAioCBCIGIAEqAgQiBSAGIAVdGzgCBCADIAIqAhQiBiABKgIUIgUgBiAFXhs4AhQgAyACKgIIIgYgASoCCCIFIAYgBV0bOAIIIAMgAioCGCIGIAEqAhgiBSAGIAVeGzgCGAJAIAQEQCAEIAEoAiAoAiggAUZBAnRqIAM2AiQgAyABNgIkIAEgAzYCICADIAI2AiggAiADNgIgIAMqAgAhBgNAIAMhAAJAIAQiAyoCACAGX0EBcw0AIAMqAgQgACoCBF9BAXMNACADKgIIIAAqAghfQQFzDQAgAyoCECAAKgIQYEEBcw0AIAMqAhQgACoCFGBBAXMNACADKgIYIAAqAhhgDQMLIAMgAygCJCIAKgIAIgYgAygCKCIBKgIAIgUgBiAFXRsiBjgCACADIAAqAhAiBSABKgIQIgcgBSAHXhs4AhAgAyAAKgIEIgUgASoCBCIHIAUgB10bOAIEIAMgACoCFCIFIAEqAhQiByAFIAdeGzgCFCADIAAqAggiBSABKgIIIgcgBSAHXRs4AgggAyAAKgIYIgUgASoCGCIHIAUgB14bOAIYIAMoAiAiBA0ACwwBCyADIAE2AiQgASADNgIgIAMgAjYCKCACIAM2AiAgACADNgIACwvhAwICfw19IAEgACgCAEYEQCAAQQA2AgBBAA8LIAEoAiAiAyADKAIoIAFHQQJ0aigCJCECAkACQCADKAIgIgEEQCABIAEoAiggA0ZBAnRqIAI2AiQgAiABNgIgIAAoAgQiAgRAQez3AUHs9wEoAgBBAWo2AgAgAkGQ0gEoAgARAAALIAAgAzYCBANAIAEqAgAhDyABIAEoAiQiAyoCACIEIAEoAigiAioCACIFIAQgBV0bIgQ4AgAgASoCECEFIAEgAyoCECIGIAIqAhAiByAGIAdeGyIGOAIQIAEqAgQhByABIAMqAgQiCCACKgIEIgkgCCAJXRsiCDgCBCABKgIUIQkgASADKgIUIgogAioCFCILIAogC14bIgo4AhQgASoCCCELIAEgAyoCCCIMIAIqAggiDSAMIA1dGyIMOAIIIAEqAhghDSABIAMqAhgiDiACKgIYIhAgDiAQXhsiDjgCGAJAIAkgClwNACAFIAZcDQAgDyAEXA0AIAcgCFwNACALIAxcDQAgDSAOWw0ECyABKAIgIgENAAsMAQsgACACNgIAIAJBADYCICAAKAIEIgEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACyAAIAM2AgQLIAAoAgAhAQsgAQtgAQF/IAEoAigEQCAAIAEoAiQQzwEgACABKAIoEM8BCyABIAAoAgBGBEAgAEEANgIACyAAKAIEIgIEQEHs9wFB7PcBKAIAQQFqNgIAIAJBkNIBKAIAEQAACyAAIAE2AgQLUQEBfyMAQRBrIgQkACAEIAA2AgwgBCABNgIIIAQgAjYCBCAEIAM2AgAgBCgCDCIAIAQoAgggBCgCBCAEKAIAIAAoAgAoAhwRBAAgBEEQaiQAC6sDAQF/IABB7LEBNgIAIAAoAqABIgEEQCAALQCkAQRAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgKgAQsgAEEANgKgASAAQgA3ApgBIABBAToApAEgACgCiAEiAQRAIAAtAIwBBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AogBCyAAQQA2AogBIABCADcCgAEgAEEBOgCMASAAKAJ0IgEEQCAALQB4BEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AnQLIABBADYCdCAAQgA3AmwgAEEBOgB4IAAoAmAiAQRAIAAtAGQEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYCYAsgAEEANgJgIABCADcCWCAAQQE6AGQgACgCTCIBBEAgAC0AUARAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgJMCyAAQQA2AkwgAEIANwJEIABBAToAUCAAC/4HAQh/AkAgAUUNACACRQ0AAkAgACgCGEH/AEoNACAAKAIcQf8ASg0AQej3AUHo9wEoAgBBAWo2AgBBgAhBEEGM0gEoAgARAwAhCCAAKAIYIgRBAU4EQANAIAggB0EDdCIFaiAAKAIgIAVqKQIANwIAIAdBAWoiByAERw0ACwsgACgCICIEBEAgAC0AJARAIAQEQEHs9wFB7PcBKAIAQQFqNgIAIARBkNIBKAIAEQAACwsgAEEANgIgCyAAIAg2AiAgAEGAATYCHCAAQQE6ACQLIABBgAE2AhggACgCICIEIAI2AgQgBCABNgIAQfwAIQFBASEEA0AgACgCICICIAQiCEF/aiIEQQN0IglqIgUoAgQhBiAFKAIAIQUgBCABSgRAAkAgACgCGCIBIAFBAXQiCk4NACAAKAIcIApODQACQCABRQRAQQAhAgwBC0Ho9wFB6PcBKAIAQQFqNgIAIAFBBHRBEEGM0gEoAgARAwAhAkEAIQcgACgCGCIBQQFIDQADQCACIAdBA3QiC2ogACgCICALaikCADcCACAHQQFqIgcgAUcNAAsLIAAoAiAiAQRAIAAtACQEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYCIAsgACACNgIgIABBAToAJCAAIAo2AhwLIAAgCjYCGCAKQXxqIQELAkAgBSAGRgRAIAUoAihFDQEgAiAJaiICIAUoAiQiBDYCBCACIAQ2AgAgCEEDdCICIAAoAiBqIgQgBSgCKCIGNgIEIAQgBjYCACACIAAoAiBqIAUpAiQ3AgggCEECaiEEDAELIAUqAgAgBioCEF9BAXMNACAFKgIQIAYqAgBgQQFzDQAgBSoCBCAGKgIUX0EBcw0AIAUqAhQgBioCBGBBAXMNACAFKgIIIAYqAhhfQQFzDQAgBSoCGCAGKgIIYEEBcw0AIAYoAighByAFKAIoBEAgBSgCJCEEIAcEQCACIAlqIgIgBigCJDYCBCACIAQ2AgAgBSgCKCEEIAhBA3QiAiAAKAIgaiIHIAYoAiQ2AgQgByAENgIAIAUoAiQhBCACIAAoAiBqIgcgBigCKDYCDCAHIAQ2AgggBSgCKCEEIAIgACgCIGoiAiAGKAIoNgIUIAIgBDYCECAIQQNqIQQMAgsgAiAJaiICIAY2AgQgAiAENgIAIAUoAighAiAAKAIgIAhBA3RqIgQgBjYCBCAEIAI2AgAgCEEBaiEEDAELIAcEQCACIAlqIgIgBigCJDYCBCACIAU2AgAgACgCICAIQQN0aiICIAYoAig2AgQgAiAFNgIAIAhBAWohBAwBCyADIAUgBiADKAIAKAIIEQUACyAEDQALCwvZAgEEfSACKgIIIAAqAhCTIQYgACoCMCEHIAIqAgQgACoCDJMgACoCLJQhBQJ/IAMgAioCACAAKgIIkyAAKgIolCIEQwAAAABfQQFzRQ0AGiAEIAAvAQYiArNgQQFzRQRAIAAvAQQgAnEgA3IMAQsgBEMAAIBPXSAEQwAAAABgcQR/IASpBUEACyAALwEEcSADcgshAiAGIAeUIQQgASACOwEAIAECfyADIAVDAAAAAF9BAXNFDQAaIAUgAC8BBiICs2BBAXNFBEAgAC8BBCACcSADcgwBCyAFQwAAgE9dIAVDAAAAAGBxBH8gBakFQQALIAAvAQRxIANyCzsBAiABIARDAAAAAF9BAXMEfyAEIAAvAQYiArNgQQFzRQRAIAEgAC8BBCACcSADcjsBBA8LIARDAACAT10gBEMAAAAAYHEEfyAEqQVBAAsgAC8BBHEgA3IFIAMLOwEECxoAIAAgASACIAMgBCAFEIYLIABB/KgBNgIAC7QLAgV/BX0CQCAALQClAQRAAkAgACgCWCIDQQFIDQAgAkUNACAAKAJgIQUgACoCqAEhCSABKgIIIQogASoCBCELIAEqAgAhDEEAIQIDQCAFIAJBBHRqIgQqAgAgDJMiCCAIlCAEKgIEIAuTIgggCJSSIAQqAgggCpMiCCAIlJIgCV8NAyACQQFqIgIgA0gNAAsLIAAoAiAiAiACKAIMQQFqNgIMAkAgAyAAKAJcRw0AIAMgA0EBdEEBIAMbIgRODQACfyAEBEBB6PcBQej3ASgCAEEBajYCACAEQQR0QRBBjNIBKAIAEQMAIQYgACgCWCEDCyADQQFOCwRAQQAhAgNAIAYgAkEEdCIFaiIHIAAoAmAgBWoiBSkCADcCACAHIAUpAgg3AgggAkEBaiICIANHDQALCyAAKAJgIgIEQCAALQBkBEAgAgRAQez3AUHs9wEoAgBBAWo2AgAgAkGQ0gEoAgARAAALCyAAQQA2AmALIAAgBjYCYCAAIAQ2AlwgAEEBOgBkIAAoAlghAwsgACgCYCADQQR0aiICIAEpAgA3AgAgAiABKQIINwIIIAAgACgCWCIBQQFqNgJYIAAoAiAgACgCYDYCECABDwsCQCAAKAJsIgNBAUgNACACRQ0AIAAoAnQhBSAAKgKoASEJIAEqAgghCiABKgIEIQsgASoCACEMQQAhAgNAIAUgAkECdGoiBCoCACAMkyIIIAiUIAQqAgQgC5MiCCAIlJIgBCoCCCAKkyIIIAiUkiAJX0EBcwRAIAJBA2oiAiADSA0BDAILCyACQQNuDwsCQCADIAAoAnAiBEcNACADIANBAXRBASADGyIETgRAIAMhBAwBC0EAIQIgBARAQej3AUHo9wEoAgBBAWo2AgAgBEECdEEQQYzSASgCABEDACEGIAAoAmwhAwsgACgCdCEFAkACQCADQQFOBEADQCAGIAJBAnQiB2ogBSAHaigCADYCACACQQFqIgIgA0cNAAwCAAsACyAFRQ0BCyAALQB4BEAgBQRAQez3AUHs9wEoAgBBAWo2AgAgBUGQ0gEoAgARAAALIAAoAmwhAwsgAEEANgJ0CyAAIAY2AnQgACAENgJwIABBAToAeAsgACgCdCIGIANBAnRqIAEoAgA2AgAgACADQQFqIgI2AmwCQCACIARHBEAgBiEDIAQhBSACIQQMAQsgBCAEQQF0QQEgBBsiBU4EQCAGIQMgBCEFDAELQQAhAkEAIQMCQAJAAn8gBQRAQej3AUHo9wEoAgBBAWo2AgAgBUECdEEQQYzSASgCABEDACEDIAAoAmwhBCAAKAJ0IQYLIARBAU4LBEADQCADIAJBAnQiB2ogBiAHaigCADYCACACQQFqIgIgBEcNAAwCAAsACyAGRQ0BCyAALQB4BEAgBgRAQez3AUHs9wEoAgBBAWo2AgAgBkGQ0gEoAgARAAALIAAoAmwhBAsgAEEANgJ0CyAAIAM2AnQgACAFNgJwIABBAToAeAsgAyAEQQJ0aiABKAIENgIAIAAgBEEBaiICNgJsAkAgAiAFRwRAIAMhBiACIQUMAQsgBSAFQQF0QQEgBRsiBE4EQCADIQYMAQtBACECQQAhBiAEBEBB6PcBQej3ASgCAEEBajYCACAEQQJ0QRBBjNIBKAIAEQMAIQYgACgCbCEFIAAoAnQhAwsCQAJAIAVBAU4EQANAIAYgAkECdCIHaiADIAdqKAIANgIAIAJBAWoiAiAFRw0ADAIACwALIANFDQELIAAtAHgEQCADBEBB7PcBQez3ASgCAEEBajYCACADQZDSASgCABEAAAsgACgCbCEFCyAAQQA2AnQLIAAgBjYCdCAAIAQ2AnAgAEEBOgB4CyAGIAVBAnRqIAEoAgg2AgAgACAFQQFqIgE2AmwgACgCICIAIAY2AhAgACAAKAIMQQFqNgIMIAFBA21Bf2ohAgsgAgu6BAEGfyAALQCkAQRAAkAgACgCgAEiAiAAKAKEAUcNACACIAJBAXRBASACGyIETg0AIAQEQEHo9wFB6PcBKAIAQQFqNgIAIARBAnRBEEGM0gEoAgARAwAhBSAAKAKAASECCyAAKAKIASEDAkACQCACQQFOBEADQCAFIAZBAnQiB2ogAyAHaigCADYCACAGQQFqIgYgAkcNAAwCAAsACyADRQ0BCyAALQCMAQRAIAMEQEHs9wFB7PcBKAIAQQFqNgIAIANBkNIBKAIAEQAACwsgAEEANgKIASAAKAKAASECCyAAIAU2AogBIAAgBDYChAEgAEEBOgCMAQsgACgCiAEiAyACQQJ0aiABNgIAIAAgACgCgAFBAWo2AoABIAAoAiAgAzYCBA8LAkAgACgClAEiAiAAKAKYAUcNACACIAJBAXRBASACGyIETg0AIAQEQEHo9wFB6PcBKAIAQQFqNgIAIARBAXRBEEGM0gEoAgARAwAhBSAAKAKUASECCyAAKAKcASEDAkACQCACQQFOBEADQCAFIAZBAXQiB2ogAyAHai8BADsBACAGQQFqIgYgAkcNAAwCAAsACyADRQ0BCyAALQCgAQRAIAMEQEHs9wFB7PcBKAIAQQFqNgIAIANBkNIBKAIAEQAACyAAKAKUASECCyAAQQA2ApwBCyAAIAU2ApwBIAAgBDYCmAEgAEEBOgCgAQsgACgCnAEiAyACQQF0aiABOwEAIAAgAkEBajYClAEgACgCICADNgIECy0BAX8jAEEQayIBJAAgASAANgIMIAEoAgwiACAAKAIAKAIYEQAAIAFBEGokAAs2AQF/IwBBEGsiASQAIAEgADYCDCMAQRBrIgAgASgCDDYCDCAAKAIMQTBqIQAgAUEQaiQAIAALrQMCB38BfiMAQRBrIgUkACAAEI8EIQggAEEBOgBsIABBwJMBNgIAIABBADYCaCAAQgA3AmAgAEEENgIEAkAgAkEATARAIAAgAjYCYAwBC0Ho9wFB6PcBKAIAQQFqNgIAIAJBBHRBEEGM0gEoAgARAwAhBCAAKAJgIgZBAU4EQANAIAQgA0EEdCIHaiIJIAAoAmggB2oiBykCADcCACAJIAcpAgg3AgggA0EBaiIDIAZHDQALCyAAKAJoIgMEQCAALQBsBEAgAwRAQez3AUHs9wEoAgBBAWo2AgAgA0GQ0gEoAgARAAALCyAAQQA2AmgLIAAgBDYCaEEBIQMgAEEBOgBsIAAgAjYCZCAEIAUpAgg3AgggBCAFKQIANwIAIAJBAUcEQANAIAAoAmggA0EEdGoiBCAFKQIANwIAIAQgBSkCCDcCCCADQQFqIgMgAkcNAAsLIAAgAjYCYEEAIQMDQCABKQIAIQogASgCCCEGIAAoAmggA0EEdGoiBEEANgIMIAQgBjYCCCAEIAo3AgAgAUEQaiEBIANBAWoiAyACRw0ACwsgCBBhIAVBEGokAAt6AQF/IwBBEGsiASQAIAEgADgCCCABIAEqAggQ/QU4AggCQCABKgIIQ9sPScBdBEAgASABKgIIQ9sPyUCSOAIMDAELIAEqAghD2w9JQF4EQCABIAEqAghD2w/JQJM4AgwMAQsgASABKgIIOAIMCyABQRBqJAAgASoCDAs4AQN9IAEqAgAhAiABKgIEIQMgASoCCCEEIABBADYCGCAAIASLOAIUIAAgA4s4AhAgACACizgCDAumDQMEfwF+D30jAEEwayIDJAACQAJAIAEoAgQiBEENSw0AAkACQAJAAkACQAJAAkAgBEEBaw4NAgcHBgUHBwAHBAcHAwELIABCADcCACAAQgA3AggMBwsgASoCHCELIAEqAiAhCSABKgIkIQggAioCACEKIAIqAgQhDCACKgIIIQ0gAEEANgIMIAAgCCAIjCANQwAAAABgGzgCCCAAIAkgCYwgDEMAAAAAYBs4AgQgACALIAuMIApDAAAAAGAbOAIADAYLIAFBOGpBAkEBIAIqAgAiCyABKgJIlCACKgIEIgkgASoCTJSSIAIqAggiCCABKgJQlJIiCiALIAEqAliUIAkgASoCXJSSIAggASoCYJSSIgxdGyALIAEqAjiUIAkgASoCPJSSIAggAUFAayoCAJSSIgsgDF1BAXQgCyAKXRtBBHRqIgEpAgAhByABKAIIIQEgAEEANgIMIAAgATYCCCAAIAc3AgAMBQsgAyABKQIkNwMoIAMgASkCHDcDICADIAIoAgA2AhAgAyACKAIEIgY2AhQgAigCCCEEIANBADYCHCADIAQ2AhhBASECIAS+IQgCf0ECIAEoAjQiAUF/aiIEQQFLDQAaIARBAWsEQEEAIQJBASEFQQIMAQsgBr4hCEEAIQJBAiEFQQELIQQgA0EgaiABQQJ0aioCACELIAJBAnQiASADQSBqcioCACEJAn8gA0EQaiABcioCACIKIAqUIAggCJSSkSIMQwAAAABcBEAgAyACQQJ0ciAKIAkgDJUiCZQ4AgAgAyAFQQJ0IgFqIAuMIAsgA0EQaiABaioCAEMAAAAAXRs4AgAgAyAEQQJ0aiAIIAmUOAIAIANBBHIhAiADQQhqDAELIAMgAkECdHIgCTgCACADIAVBAnQiAWogC4wgCyADQRBqIAFqKgIAQwAAAABdGzgCACADIARBAnRqQQA2AgAgA0EEciECIANBCGoLIQEgACADKAIANgIAIAAgAigCADYCBCABKAIAIQEgAEEANgIMIAAgATYCCAwECyABQRxqIgUgASgCNCIEQQJ0IgZqKgIAIQ0gBSAEQQJqQQNvQQJ0aioCACEJAn0gAioCACILIAuUIAIqAgQiCCAIlJIgAioCCCIKIAqUkiIMQxe30ThdBEBDAAAAACEIQwAAAAAhDEMAAIA/DAELIApDAACAPyAMkZUiCpQhDCAIIAqUIQggCyAKlAshCiADQgA3AyggA0IANwMgIANBIGogBmogDTgCAENrC17dIQtBACECQQAhBUEAIQYgDCAJIAyUIg8gAyoCKJIgDCABKgIsIg6UIhGTIhCUIAogCSAKlCISIAMqAiCSIAogDpQiE5MiFJQgCCAJIAiUIhUgAyoCJJIgCCAOlCIOkyIWlJKSIglDawte3V5BAXNFBEAgELwhBiAWvCEFIAkhCyAUvCECCyADQgA3AyggA0IANwMgIANBIGogBEECdGogDYw4AgAgAyoCKCEJIAMqAiAhDSADKgIkIRAgAEEANgIMIAAgDyAJkiARkyIJvCAGIAogEiANkiATkyIKlCAIIBUgEJIgDpMiCJSSIAwgCZSSIAteIgEbNgIIIAAgCLwgBSABGzYCBCAAIAq8IAIgARs2AgAMAwsgASoCDCELIAEqAhQhCSABKgIQIQogASgCXCEFQX8hBCABKAJgIgZBAU4EQCACKgIAIAuUIQwgAioCCCAJlCENIAIqAgQgCpQhDkEAIQFD//9//yEIA0AgDCAFIAFBBHRqIgIqAgCUIA4gAioCBJSSIA0gAioCCJSSIg8gCCAPIAheIgIbIQggASAEIAIbIQQgAUEBaiIBIAZHDQALCyAFIARBBHRqIgEqAgAhCCABKgIEIQwgASoCCCENIABBADYCDCAAIAkgDZQ4AgggACAKIAyUOAIEIAAgCyAIlDgCAAwCCyABKgIMIQsgASoCFCEJIAEqAhAhCiABKAJoIQVBfyEEIAEoAmAiBkEBTgRAIAIqAgAgC5QhDCACKgIIIAmUIQ0gAioCBCAKlCEOQQAhAUP//3//IQgDQCAMIAUgAUEEdGoiAioCAJQgDiACKgIElJIgDSACKgIIlJIiDyAIIA8gCF4iAhshCCABIAQgAhshBCABQQFqIgEgBkcNAAsLIAUgBEEEdGoiASoCACEIIAEqAgQhDCABKgIIIQ0gAEEANgIMIAAgCSANlDgCCCAAIAogDJQ4AgQgACALIAiUOAIADAELIAAgASACIAEoAgAoAkQRBQALIANBMGokAAsxAQF/IwBBEGsiASQAIAEgADYCDCABKAIMIgAgACgCACgCFBEBACEAIAFBEGokACAAC1IAIABCIzcCBCAAQaSQATYCACAAQYquj+kDNgIsIABCgICA/AM3AhQgAEKAgID8g4CAwD83AgwgAEGkkQE2AgAgAEEANgI0IABBoIwBNgIAIAALBABBPAvqFgIFfxh9IwBBwAVrIgQkACAEQfAEaiIFQiM3AgQgBUGkkAE2AgAgBUGKro/pAzYCLCAFQoCAgPwDNwIUIAVCgICA/IOAgMA/NwIMIAVBpJEBNgIAIARBADYCnAUgBEEANgKMBSAEQQg2AvQEIARBxIIBNgLwBCACKAIMIQUCQCACKAIEIgYoAgQiB0ETTARAIARCADcD6AQgBEG4MDYCwAMgBCADKAIENgLkBCAEQQA6AKQDIARBl+7GxgM2AowDIARBqAVqIgcgBjYCDCAHIARB8ARqNgIIIAcgBEHYAGo2AgQgB0HgyQA2AgACQAJ/IARByABqIgggBjYCDCAIIARB8ARqNgIIIAggBEHYAGo2AgQgCEHw4AA2AgAgCAsgByADKAIQQQhxGyIGIAAgASAFIAUgBEHAA2ogBigCACgCCBEUAEUNACAEKgLEBCILIAuUIAQqAsgEIgwgDJSSIAQqAswEIgkgCZSSIgpDF7fROF5BAXMNACAEKgLkBCISIAMqAgRdQQFzDQAgBCAJQwAAgD8gCpGVIgmUOALMBCAEIAwgCZQ4AsgEIAQgCyAJlDgCxAQgAigCCCEAIARBADYCLCAEIAA2AiggBCAEKQLMBDcDOCAEIAQpAsQENwMwIAQgEjgCQCADIARBKGpBASADKAIAKAIMEQ0AGgsMAQsgB0FrakEITQRAIAUqAhQhCyAFKgIkIQwgBSoCGCEJIAUqAjQhDSAFKgI4IQogBSoCKCESIAUqAiAhFCAFKgIQIRUgBSoCACEWIAUqAgQhFyAFKgIwIQ8gBSoCCCETIAAqAjQhECAAKgI4IQ4gACoCMCERIARBADYCzAMgBCAJIA2MIg2UIBMgD5STIBIgCpSTIhggEyARlCAJIBCUkiASIA6UkpIiGTgCyAMgBCALIA2UIBcgD5STIAwgCpSTIhogFyARlCALIBCUkiAMIA6UkpIiGzgCxAMgBCAVIA2UIBYgD5STIBQgCpSTIg0gFiARlCAVIBCUkiAUIA6UkpIiDjgCwAMgASoCNCEKIAEqAjghDyABKgIwIRAgBEEANgI0IAQgGCATIBCUIAkgCpSSIBIgD5SSkiIJOAIwIAQgGiAXIBCUIAsgCpSSIAwgD5SSkiILOAIsIAQgDSAWIBCUIBUgCpSSIBQgD5SSkiIMOAIoAkAgBigCBEFraiIAQQRLDQACQAJAIABBAWsOBAICAgEACyACKAIIIQAgBEHYAGogBEHAA2ogBEEoaiADKAIQEMQCIAQgBjYCjAEgBCAANgKIASAEIAM2AoQBIARBwOYANgJYIAQgBSkCCDcDmAEgBCAFKQIANwOQASAEIAUpAhg3A6gBIAQgBSkCEDcDoAEgBCAFKQIoNwO4ASAEIAUpAiA3A7ABIAQgBSkCODcDyAEgBCAFKQIwNwPAASAEIAMoAgQ2AoABIAYgBEHYAGogBEHAA2ogBEEoahCHDAwDCyACKAIIIQAgBEHYAGogBEHAA2ogBEEoaiADKAIQEMQCIAQgBjYCjAEgBCAANgKIASAEIAM2AoQBIARBwOYANgJYIAQgBSkCCDcDmAEgBCAFKQIANwOQASAEIAUpAhg3A6gBIAQgBSkCEDcDoAEgBCAFKQIoNwO4ASAEIAUpAiA3A7ABIAQgBSkCODcDyAEgBCAFKQIwNwPAASAEIAMoAgQ2AoABIAYgBEHYAGogBEHAA2ogBEEoaiAGKAIAKAKQAREEAAwCCyAEQQA2ArQFIAQgGTgCsAUgBCAbOAKsBSAEIA44AqgFIARBADYCVCAEIAk4AlAgBCALOAJMIAQgDDgCSCACKAIIIQAgBEHYAGogBEGoBWogBEHIAGogAygCEBDEAiAEIAY2AowBIAQgADYCiAEgBCADNgKEASAEQfjnADYCWCAEIAUpAgg3A5gBIAQgBSkCADcDkAEgBCAFKQIYNwOoASAEIAUpAhA3A6ABIAQgBSkCKDcDuAEgBCAFKQIgNwOwASAEIAUpAjg3A8gBIAQgBSkCMDcDwAEgBCADKAIENgKAASAEIAQpA7AFNwMgIAQgBCkDqAU3AxggBCoCSCILIAQqAhhdQQFzRQRAIAQgCzgCGAsgBCoCTCIMIAQqAhxdQQFzRQRAIAQgDDgCHAsgBCoCUCIJIAQqAiBdQQFzRQRAIAQgCTgCIAsgBCoCVCIKIAQqAiRdQQFzRQRAIAQgCjgCJAsgBCAEKQOwBTcDECAEIAQpA6gFNwMIIAQqAgggC11BAXNFBEAgBCALOAIICyAEKgIMIAxdQQFzRQRAIAQgDDgCDAsgBCoCECAJXUEBc0UEQCAEIAk4AhALIAQqAhQgCl1BAXNFBEAgBCAKOAIUCyAGIARB2ABqIARBGGogBEEIaiAGKAIAKAJAEQQADAELIAdBH0cNACAGQUBrKAIAIQcgAigCCCECIAQgAzYCQCAEIAE2AjwgBCAANgI4IAQgBTYCNCAEIAY2AjAgBCACNgIsIARBtOkANgIoIAcEQCAFKgIUIQsgBSoCJCEMIAUqAhghCSAFKgI0IQogACoCNCERIAUqAighEiAFKgI4IRQgACoCOCENIAUqAgAhFSAFKgIQIRYgBSoCICEXIAUqAgQhDyAFKgIIIRMgBSoCMCEQIAAqAjAhDiAEQQA2AmQgBCATIA4gEJMiDpQgCSARIAqTIhGUkiASIA0gFJMiDZSSOAJgIAQgDiAPlCARIAuUkiANIAyUkjgCXCAEIA4gFZQgESAWlJIgDSAXlJI4AlggASoCNCEOIAEqAjghESABKgIwIQ0gBEEANgLMAyAEIBMgDSAQkyITlCAJIA4gCpMiCZSSIBIgESAUkyIKlJI4AsgDIAQgDyATlCALIAmUkiAMIAqUkjgCxAMgBCAVIBOUIBYgCZSSIBcgCpSSOALAAyAHKAIAIARB2ABqIARBwANqIARBKGoQigUMAQsgBigCECIBQQFIDQBBACECA0AgBigCGCACQdAAbGoiACgCQCEDIAAqAjghDyAAKgIwIRMgACoCNCEQIAAqAiAhDiAAKgIAIREgACoCECENIAAqAiQhGCAAKgIEIRkgACoCFCEaIAAqAighGyAAKgIIIRwgACoCGCEdIAUqAjQhHiAFKgI4IR8gBSoCGCELIAUqAhQhDCAFKgIoIQkgBSoCJCEKIAUqAjAhICAFKgIIIRIgBSoCACEUIAUqAgQhFSAFKgIQIRYgBSoCICEXIARBADYClAEgBEEANgKEASAEQQA2AnQgBEEANgJkIAQgHCAXlCAdIAqUkiAbIAmUkjgCgAEgBCAZIBeUIBogCpSSIBggCZSSOAJ8IAQgESAXlCANIAqUkiAOIAmUkjgCeCAEIBwgFpQgHSAMlJIgGyALlJI4AnAgBCAZIBaUIBogDJSSIBggC5SSOAJsIAQgESAWlCANIAyUkiAOIAuUkjgCaCAEIBQgHJQgFSAdlJIgEiAblJI4AmAgBCAUIBmUIBUgGpSSIBIgGJSSOAJcIAQgESAUlCANIBWUkiAOIBKUkjgCWCAEIB8gFyATlCAKIBCUkiAJIA+UkpI4ApABIAQgHiAWIBOUIAwgEJSSIAsgD5SSkjgCjAEgBCAgIBQgE5QgFSAQlJIgEiAPlJKSOAKIASAEIAI2ArwFIARBfzYCuAUgBCAEKAIsNgKwBSAEIAM2AqwFIARBADYCqAUgBCAEQdgAajYCtAUgBEKBgPz/DzcCzAMgBEKAgID8AzcCxAMgBCACNgLYAyAEQeTqADYCwAMgBCAEKAJAIgA2AtQDIAQgACgCBDYCxAMgBCAAKAIQNgLQAyAEKAI4IAQoAjwgBEGoBWogBEHAA2oQ4AEgAkEBaiICIAFGDQEgBCgCNCEFIAQoAjAhBgwAAAsACyAEQcAFaiQACy8BAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIAIoAggQtQQgAkEQaiQAC5QIAQF/IABBlNQANgIAIAAtABQEQCAAKAIQKAIQIgEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACyAAKAIQIgEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAC0ADARAIAAoAggoAhAiAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALIAAoAggiAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAKAIgIgEgASgCACgCABEBABogACgCICIBBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsgACgCJCIBIAEoAgAoAgARAQAaIAAoAiQiAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALIAAoAigiASABKAIAKAIAEQEAGiAAKAIoIgEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACyAAKAIsIgEgASgCACgCABEBABogACgCLCIBBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsgACgCMCIBIAEoAgAoAgARAQAaIAAoAjAiAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALIAAoAjQiASABKAIAKAIAEQEAGiAAKAI0IgEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACyAAKAI4IgEgASgCACgCABEBABogACgCOCIBBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsgACgCPCIBIAEoAgAoAgARAQAaIAAoAjwiAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALIAAoAkwiASABKAIAKAIAEQEAGiAAKAJMIgEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACyAAKAJQIgEgASgCACgCABEBABogACgCUCIBBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsgACgCSCIBIAEoAgAoAgARAQAaIAAoAkgiAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALIAAoAlgiASABKAIAKAIAEQEAGiAAKAJYIgEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACyAAKAJUIgEgASgCACgCABEBABogACgCVCIBBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsgACgCGCIBBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsgACgCHCIBIAEoAgAoAgARAQAaIAAoAhwiAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALIAAL/QkAAkBBsO0BLQAAQQFxDQBBsO0BEBBFDQBB6OoBQvaI5/oDNwMAQeDqAULetZnxg+v//z43AwBB2OoBQvaI5/oDNwMAQdDqAULwh+f2m9aNzz43AwBByOoBQvaI5/oDNwMAQcDqAULwh+f2m9aNz75/NwMAQbjqAUL2iOf6AzcDAEGw6gFC3rWZ8YPr//++fzcDAEGo6gFC1Ijn+gM3AwBBoOoBQr6smvgDNwMAQZjqAUKirZr4AzcDAEGQ6gFCuNrA+bPz//8+NwMAQYjqAULErZr4AzcDAEGA6gFCxK2a9Jvtxqc/NwMAQfjpAUKirZr4AzcDAEHw6QFCkYjn+gs3AwBB6OkBQsStmvgDNwMAQeDpAULErZr0m+3Gp79/NwMAQdjpAUKirZr4AzcDAEHQ6QFCuNrA+bPz//++fzcDAEHI6QFCgICAgAg3AwBBwOkBQqXy2fjT98anPzcDAEG46QFCgICAgAg3AwBBsOkBQoCAgICIgIDAPzcDAEGo6QFCgICAgAg3AwBBoOkBQqXy2fjb98anPzcDAEGY6QFCgICAgAg3AwBBkOkBQonxzfvL3o3PPjcDAEGI6QFCgICAgAg3AwBBgOkBQonxzfvL3o3Pvn83AwBB+OgBQgA3AwBB8OgBQqXy2fjb98anv383AwBB6OgBQgA3AwBB4OgBQoCAgICAgIDAv383AwBB2OgBQgA3AwBB0OgBQqXy2fjT98anv383AwBByOgBQgA3AwBBwOgBQonxzfvD3o3Pvn83AwBBuOgBQgA3AwBBsOgBQonxzfvD3o3PPjcDAEGo6AFCxK2a+As3AwBBoOgBQsStmvST7canPzcDAEGY6AFCoq2a+As3AwBBkOgBQrjawPm78///PjcDAEGI6AFC9ojn+gs3AwBBgOgBQt61mfGL6///PjcDAEH45wFCoq2a+As3AwBB8OcBQrjawPm78///vn83AwBB6OcBQtSI5/oLNwMAQeDnAUK+rJr4i4CAgIB/NwMAQdjnAUKirZr4CzcDAEHQ5wFCkYjn+oOAgICAfzcDAEHI5wFC9ojn+gs3AwBBwOcBQvCH5/aT1o3PPjcDAEG45wFCxK2a+As3AwBBsOcBQsStmvST7canv383AwBBqOcBQvaI5/oLNwMAQaDnAULetZnxi+v//75/NwMAQZjnAUL2iOf6CzcDAEGQ5wFC8Ifn9pPWjc++fzcDAEGI5wFCgICA/AM3AwBBgOcBQoCAgIAINwMAQfjmAUL/8pP3AzcDAEHw5gFCmvKT+wM3AwBB6OYBQuTzk/cDNwMAQeDmAUK6hbb0o4TxrD83AwBB2OYBQuTzk/cDNwMAQdDmAULg/OT5q72lgz83AwBByOYBQuTzk/cDNwMAQcDmAULg/OT5q72lg79/NwMAQbjmAUKF9JP3AzcDAEGw5gFCuoW29KOE8ay/fzcDAEGo5gFC5POT9ws3AwBBoOYBQuD85PmjvaWDPzcDAEGY5gFChfST9ws3AwBBkOYBQrqFtvSrhPGsPzcDAEGI5gFC//KT9ws3AwBBgOYBQpryk/uLgICAgH83AwBB+OUBQuTzk/cLNwMAQfDlAUK6hbb0q4TxrL9/NwMAQejlAULk85P3CzcDAEHg5QFC4Pzk+aO9pYO/fzcDAEHY5QFCgICA/As3AwBB0OUBQoCAgICAgICAgH83AwBBsO0BEA8LC74HAgV/CX0jAEGQAmsiBiQAIAYgAikCCDcD2AEgBiACKQIANwPQASAGIAIpAhg3A+gBIAYgAikCEDcD4AEgBiACKQIoNwP4ASAGIAIpAiA3A/ABIAYgAikCODcDiAIgBiACKQIwNwOAAiAGIAMpAgg3A5gBIAYgAykCADcDkAEgBiADKQIYNwOoASAGIAMpAhA3A6ABIAYgAykCKDcDuAEgBiADKQIgNwOwASAGIAMpAjg3A8gBIAYgAykCMDcDwAEgBkEANgJsIAYgBioCyAEgBioCiAKTOAJoIAYgBioCxAEgBioChAKTOAJkIAYgBioCwAEgBioCgAKTOAJgIAZB0AFqIAZBkAFqIAZBEGogBkGAAWoQZiAGQQA2AlwgBiAGKgKAASILIAYqAhiUOAJYIAYgCyAGKgIUlDgCVCAGIAsgBioCEJQ4AlAgBkIANwNIIAZBQGtCADcDACAGQdABaiAGQYABahAmIAZBADYCPCAGQQA2AiwgBiAGKgKEASIMIAYqAogBIg1DAAAAQCAGKgKAASILIAuUIAwgDJSSIA0gDZSSIAYqAowBIg8gD5SSlSIQlCIRlCIOIA8gCyAQlCISlCITkjgCNCAGIA4gE5M4AiggBkMAAIA/IAsgEpQiDiAMIAwgEJQiDJQiEJKTOAI4IAZDAACAPyAOIA0gEZQiDZKTOAIkIAZBADYCHCAGIAsgEZQiDiAPIAyUIhKTOAIwIAYgCyAMlCILIA8gEZQiDJI4AiAgBiAOIBKSOAIYIAYgCyAMkzgCFCAGQwAAgD8gECANkpM4AhAgASAGQRBqIAZB4ABqIAZB0ABqIAZBgAFqIAZB8ABqEI4EIAAoAowCQQFOBEAgA0EwaiEHIAJBMGohCEEAIQMDQAJAIAQgACgClAIgA0ECdGooAgAiAigCvAEgBCgCACgCCBEDAEUNACACKALAASIJIAJBBGoiCiAGQRBqIAZB4ABqIAkoAgAoAggRBAAgBkEANgIcIAZBADYCbCAGIAYqAhggBioCiAGSOAIYIAYgBioCFCAGKgKEAZI4AhQgBiAGKgIQIAYqAoABkjgCECAGIAYqAmAgBioCcJI4AmAgBiAGKgJkIAYqAnSSOAJkIAYgBioCaCAGKgJ4kjgCaCAGQYCAgPwDNgIMIAggByAGQRBqIAZB4ABqIAZBDGogBkHQAGoQzQ1FDQAgASAGQdABaiAGQZABaiACIAIoAsABIAogBCAFEPsMCyADQQFqIgMgACgCjAJIDQALCyAGQZACaiQACzsBAX8jAEEQayIDJAAgAyAANgIMIAMgATYCCCADIAI2AgQgAygCDCADKAIIIAMoAgQQ+QwgA0EQaiQAC14AIABBAToA5AIgAEEANgIAIABBADoAuAIgAELrlvjqte2Cr90ANwKkAiAAQgA3AtACIABC65b46gU3AqwCIABCADcC2AIgAEEAOgDgAiAAIAAtAMwCQfABcToAzAILmBECBX8VfSMAQaAFayIEJAAgBEHIA2oiBUIjNwIEIAVBpJABNgIAIAVBiq6P6QM2AiwgBUKAgID8AzcCFCAFQoCAgPyDgIDAPzcCDCAFQaSRATYCACAEQwAAAAA4AvQDIARDAAAAADgC5AMgBEHEggE2AsgDIARBCDYCzAMgBEIANwKUAyAEQgA3A6ADIARBgICA/AM2ApwDIARCgICA/AM3A7ADIARCADcCjAMgBEGAgID8AzYCiAMgBEIANwOoAyAEIAApAgg3A8ADIAQgACkCADcDuAMgA0EANgIgIANCADcCGCADQgA3AhAgA0IANwIIIANCADcCACAEIAE2AoAEIAQgBEHIA2o2AoQEIAIqAiQhCSACKgIUIQsgAioCKCEKIAIqAhghDCACKgIgIRAgAioCACERIAIqAhAhDiACKgIEIRIgAioCCCENIARBADYCtAQgBEEANgKkBCAEQQA2ApQEIAQgCiANQwAAAACUIg8gDEMAAAAAlCIWkpIiGDgCsAQgBCAJIBJDAAAAAJQiEyALQwAAAACUIhSSkiIZOAKsBCAEIBAgEUMAAAAAlCIVIA5DAAAAAJQiF5KSIho4AqgEIAQgDyAMkiAKQwAAAACUIg+SIhs4AqAEIAQgEyALkiAJQwAAAACUIhOSIhw4ApwEIAQgFSAOkiAQQwAAAACUIhWSIh04ApgEIAQgDSAWkiAPkiIPOAKQBCAEIBIgFJIgE5IiFjgCjAQgBCARIBeSIBWSIhM4AogEIAIqAjQhFCACKgI4IRUgAioCMCEXIARBADYC/AQgBEEANgL0BCAEQQA2AuQEIAQgGDgC4AQgBCAbOALcBCAEIA84AtgEIARBADYC1AQgBCAZOALQBCAEIBw4AswEIAQgFjgCyAQgBEEANgLEBCAEIBo4AsAEIAQgHTgCvAQgBCANIAQqArgDIBeTIg2UIAwgBCoCvAMgFJMiDJSSIAogBCoCwAMgFZMiCpSSOALwBCAEIA0gEpQgDCALlJIgCiAJlJI4AuwEIAQgDSARlCAMIA6UkiAKIBCUkjgC6AQgBEGBAzYC+AQgBCATOAK4BCAEQgA3A5ABIARCADcDiAEgBEIANwL0AiAEQQI2AoADIARBADYCmAEgBEKAgID8AzcDmAUgBEKAgID8g4CAwD83A5AFQ///f38hCQJAIARBCGogBEGABGogBEGQBWoQzgIiAEEBSw0AAkAgAEEBawRAIAQoAvwCIgUoAiBFBEBDAAAAACEJQwAAAAAhC0MAAAAAIQpDAAAAACEMQwAAAAAhEEMAAAAAIREMAgtDAAAAACERQQAhAEMAAAAAIRBDAAAAACEMQwAAAAAhCkMAAAAAIQtDAAAAACEJA0AgBSAAQQJ0IgZqIgUqAhAhDiAEQZAFaiAEKAKABCAEKAL8BCIHQQF1aiIIIAUoAgAgBCgC+AQiBSAIKAIAaigCACAFIAdBAXEbEQUAIAQoAvwCIAZqKAIAIgUqAgghEiAEKAL4BCIGIAQoAoQEIAQoAvwEIgdBAXVqIggoAgBqKAIAIAYgB0EBcRshBiAFKgIAIQ0gBSoCBIwhDyARIA4gBCoCmAWUkiERIBAgDiAEKgKUBZSSIRAgDCAOIAQqApAFlJIhDCAEQQA2AowFIAQgBCoCrAQgD5QgDSAEKgKoBJSTIBIgBCoCsASUkzgCiAUgBCAEKgKcBCAPlCANIAQqApgElJMgEiAEKgKgBJSTOAKEBSAEIAQqAowEIA+UIA0gBCoCiASUkyASIAQqApAElJM4AoAFIARBkAVqIAggBEGABWogBhEFACAKIA4gBCoCkAUiEiAEKgLYBJQgBCoClAUiDSAEKgLcBJSSIAQqApgFIg8gBCoC4ASUkiAEKgLwBJKUkiEKIAsgDiASIAQqAsgElCANIAQqAswElJIgDyAEKgLQBJSSIAQqAuwEkpSSIQsgCSAOIBIgBCoCuASUIA0gBCoCvASUkiAPIAQqAsAElJIgBCoC6ASSlJIhCSAAQQFqIgAgBCgC/AIiBSgCIEkNAAsMAQsgASACIARByANqIARBiANqIARBiAFqIANBARDNAkUNASADKgIEIAMqAhSTIgkgCZQgAyoCCCADKgIYkyILIAuUkiADKgIMIAMqAhyTIgogCpSSkSIMQwAAADRgQQFzRQRAIANBADYCMCADIApDAACAPyAMlSIKlDgCLCADIAsgCpQ4AiggAyAJIAqUOAIkCyAMjCEJDAELIAIqAjAhDiACKgIIIRIgAioCACENIAIqAgQhDyACKgI0IRYgAioCGCEYIAIqAhAhEyACKgIUIRQgAioCOCEZIAIqAighFSACKgIgIRcgAioCJCEaIANBADYCECADIBkgDCAXlCAQIBqUkiARIBWUkpIiGTgCDCADIBYgDCATlCAQIBSUkiARIBiUkpIiFjgCCCADIA4gDCANlCAQIA+UkiARIBKUkpIiDDgCBCACKgIwIRAgAioCCCERIAIqAgAhDiACKgIEIRIgAioCNCENIAIqAhghDyACKgIQIRggAioCFCETIAIqAjghFCACKgIoIRUgAioCICEXIAIqAiQhGiADQQA2AiAgAyAUIAkgF5QgCyAalJIgCiAVlJKSIhQ4AhwgAyANIAkgGJQgCyATlJIgCiAPlJKSIg04AhggAyAQIAkgDpQgCyASlJIgCiARlJKSIgs4AhQgARB8IRAgBEHIA2oQfCERIANBADYCMCADIBQgGZMiCUMAAIA/IAsgDJMiCyALlCANIBaTIgogCpSSIAkgCZSSkSIMlSIJlCIOOAIsIAMgCiAJlCIKOAIoIAMgCyAJlCILOAIkIAMgECARkiIJIAuUIAMqAgSSOAIEIAMgCSAKlCADKgIIkjgCCCADIAkgDpQgAyoCDJI4AgwgDCAJkyEJCyAEQaAFaiQAIAkLmQIBBn8gACgCWCIHIQYCQCAHIAAoAlxHDQAgByEGIAcgB0EBdEEBIAcbIghODQAgCAR/Qej3AUHo9wEoAgBBAWo2AgAgCEGYAWxBEEGM0gEoAgARAwAhCSAAKAJYBSAHCyIKQQFOBEBBACEGA0AgCSAGQZgBbCILaiAAKAJgIAtqQZgBEBUaIAZBAWoiBiAKRw0ACwsgACgCYCIGBEAgAC0AZARAIAYEQEHs9wFB7PcBKAIAQQFqNgIAIAZBkNIBKAIAEQAACwsgAEEANgJgCyAAIAk2AmAgACAINgJcIABBAToAZCAAKAJYIQYLIAAgBkEBajYCWCAAKAJgIAdBmAFsaiIHIAQ2AowBIAAgByABIAIgAyAFEJIOC0cBAX8jAEEQayIEJAAgBCAANgIMIAQgATYCCCAEIAI2AgQgBCADNgIAIAQoAgwgBCgCCCAEKAIEIAQoAgAQ+AwgBEEQaiQAC0QBAX0gACoCACAAKgIEk0PbD8lAECUiAUPbD0nAXUEBc0UEQCABQ9sPyUCSDwsgASABQ9sPycCSIAFD2w9JQF5BAXMbC0QBAX0gACoCACAAKgIEkkPbD8lAECUiAUPbD0nAXUEBc0UEQCABQ9sPyUCSDwsgASABQ9sPycCSIAFD2w9JQF5BAXMbC90EARJ9IAAgBSkCADcCACAAIAUpAgg3AgggASoCGCEVIAEqAhQhDyABKgIoIQwgASoCJCEKIAEqAgghEiABKgIAIRMgASoCBCEWIAEqAhAhFyABKgIgIQsgAyoCBCEQIAMqAgghDiADKgIAIRQgAEEANgIcIAAgCyAQIAAqAggiC5QgDiAAKgIEIg2UkyIRlCAKIA4gACoCACIOlCALIBSUkyIKlJIgDCANIBSUIBAgDpSTIhCUkiIUOAIYIAAgESAXlCAKIA+UkiAQIBWUkiIVOAIUIAAgESATlCAWIAqUkiAQIBKUkiIQOAIQIAIqAhghEiACKgIUIRMgAioCKCEWIAIqAiQhFyACKgIIIRggAioCACEZIAIqAgQhGiACKgIQIRsgAioCICEMIAQqAgQhESAEKgIAIQogBCoCCCEPIABBADYCLCAAIAwgDSAPlCALIBGUkyIMlCAXIAsgCpQgDiAPlJMiC5SSIBYgDiARlCANIAqUkyINlJIiDjgCKCAAIAwgG5QgCyATlJIgDSASlJIiETgCJCAAIBkgDJQgGiALlJIgDSAYlJIiCzgCICAGKgIIIQ0gBioCBCEKIAYqAgAhDyAAQQA2AjwgACAPIBCUIg84AjAgACAKIBWUIgo4AjQgACANIBSUIg04AjggCCoCCCEMIAgqAgQhEiAIKgIAIRMgAEEANgJMIAAgEyALlCITOAJAIAAgEiARlCISOAJEIAAgDCAOlCIMOAJIIAAgECAPlCAVIAqUkiAUIA2UkiAHkiAJkiALIBOUIBEgEpSSIA4gDJSSkjgCUAteAQF/IwBBIGsiBiQAIAYgADYCHCAGIAE2AhggBiACNgIUIAYgAzYCECAGIAQ2AgwgBiAFOAIIIAYoAhwgBigCGCAGKAIUIAYoAhAgBigCDCAGKgIIEGIgBkEgaiQAC0wBAX8jAEEQayICJAAgAiAANgIMIAIgATgCCCACKgIIIQEjAEEQayIAIAIoAgw2AgwgACABOAIIIAAoAgwgACoCCDgCCCACQRBqJAALTAEBfyMAQRBrIgIkACACIAA2AgwgAiABOAIIIAIqAgghASMAQRBrIgAgAigCDDYCDCAAIAE4AgggACgCDCAAKgIIOAIEIAJBEGokAAtxAQR9IAAqAtgCIgJDAAAAAFwEQCABKgIAIQMgASoCBCEEIAEqAgghBSAAQQA2AvgCIAAgBUMAAIA/IAKVIgKUOAL0AiAAIAIgBJQ4AvACIAAgAiADlDgC7AILIAAgASkCADcC/AIgACABKQIINwKEAwtMAQF/IwBBEGsiAiQAIAIgADYCDCACIAE4AgggAioCCCEBIwBBEGsiACACKAIMNgIMIAAgATgCCCAAKAIMIAAqAgg4AgAgAkEQaiQACxkAIABBBGogAEG4AmogAEHIAmogASACEFULOwIBfwF9IwBBEGsiASQAIAEgADYCDCMAQRBrIgAgASgCDDYCDCAAKAIMQQhqKgIAIQIgAUEQaiQAIAILOwIBfwF9IwBBEGsiASQAIAEgADYCDCMAQRBrIgAgASgCDDYCDCAAKAIMQQRqKgIAIQIgAUEQaiQAIAILOAIBfwF9IwBBEGsiASQAIAEgADYCDCMAQRBrIgAgASgCDDYCDCAAKAIMKgIAIQIgAUEQaiQAIAILNgEBfyMAQRBrIgEkACABIAA2AgwjAEEQayIAIAEoAgw2AgwgACgCDCgCRCEAIAFBEGokACAACxAAIAJCADcCACACQgA3AggLxAIBAX8gACgCSCIBBEAgAC0ATARAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgJICyAAQQA2AkggAEIANwJAIABBAToATCAAKAI0IgEEQCAALQA4BEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AjQLIABBADYCNCAAQgA3AiwgAEEBOgA4IAAoAiAiAQRAIAAtACQEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYCIAsgAEEANgIgIABCADcCGCAAQQE6ACQgACgCDCIBBEAgAC0AEARAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgIMCyAAQQA2AgwgAEEBOgAQIABCADcCBAs5AQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDCIAIAIoAgggACgCACgCKBECACACQRBqJAALNgEBfyMAQRBrIgEkACABIAA2AgwjAEEQayIAIAEoAgw2AgwgACgCDCgCGCEAIAFBEGokACAACxgBAX8jAEEQayIBIAA2AgwgASgCDCgCBAu8AQIHfwF9IAAoAtwFIgRBAU4EQCAAKALkBSEFA0AgBSABQTRsaiIDIAMoAggiBioCCCADKAIMIgcqAgiTIgggCJQgBioCDCAHKgIMkyIIIAiUkiAGKgIQIAcqAhCTIgggCJSSkSIIOAIQIAMgCCAIlDgCHCABQQFqIgEgBEcNAAsDQCAFIAJBNGxqIgEgASgCCCoCWCABKAIMKgJYkiABKAIEKgIElTgCGCACQQFqIgIgBEcNAAsLIAAQkwULrgQCBn8JfSAAKALIBSICQQFOBEADQCAAKALQBSABQegAbGoiA0IANwJIIANCADcCUCABQQFqIgEgAkcNAAsLIAAoAvAFIgZBAU4EQANAIAAoAvgFIAVBLGxqIgQoAgwiASoCDCEKIAQoAggiAioCDCEHIAQoAhAiAyoCDCELIAEqAhAhDCADKgIIIQ4gAioCECEJIAMqAhAhDyACKgIIIQggASoCCCENIARBADYCICAEIA0gCJMiDSALIAeTIguUIAogB5MiCiAOIAiTIgiUkyIHQwAAgD8gByAHlCAKIA8gCZMiCpQgDCAJkyIMIAuUkyIJIAmUIAwgCJQgDSAKlJMiCCAIlJKSkZUiCpQ4AhwgBCAIIAqUOAIYIAQgCSAKlDgCFCACIAcgAioCUJI4AlAgAiAIIAIqAkySOAJMIAIgCSACKgJIkjgCSCABIAkgASoCSJI4AkggASAIIAEqAkySOAJMIAEgByABKgJQkjgCUCADIAkgAyoCSJI4AkggAyAIIAMqAkySOAJMIAMgByADKgJQkjgCUCAFQQFqIgUgBkcNAAsLIAAoAsgFIgJBAU4EQCAAKALQBSEDQQAhAQNAIAMgAUHoAGxqIgAqAkgiByAHlCAAKgJMIgkgCZSSIAAqAlAiCCAIlJKRIgpDAAAANF5BAXNFBEAgACAHQwAAgD8gCpUiB5Q4AkggACAJIAeUOAJMIAAgCCAHlDgCUAsgAUEBaiIBIAJHDQALCwuvCAIFfxB9IwBBIGsiAyQAIAAoAsABIgIgAigCACgCMBEGACEKIAAoAsgFIgVBAU4EQCAAQaAHaiEGA0AgASoCMCERIAEqAgghCyABKgIEIQwgASoCACENIAEqAjQhEiABKgIYIQ4gASoCFCEPIAEqAhAhECABKgI4IQcgASoCKCEIIAEqAiQhCSABKgIgIRMgACgC0AUgBEHoAGxqIgJBADYCFCACIAcgEyACKgIIIgeUIAkgAioCDCIJlJIgCCACKgIQIgiUkpIiEzgCECACIBIgByAQlCAJIA+UkiAIIA6UkpIiEjgCDCACIBEgByANlCAJIAyUkiAIIAuUkpIiETgCCCABKgIwIQsgASoCCCEMIAEqAgAhDSABKgIEIQ4gASoCNCEPIAEqAhghECABKgIQIRQgASoCFCEVIAEqAjghByABKgIoIQggASoCICEJIAEqAiQhFiACQQA2AiQgAiAHIAkgAioCGCIHlCAWIAIqAhwiCZSSIAggAioCICIIlJKSOAIgIAIgDyAHIBSUIAkgFZSSIAggEJSSkjgCHCACIAsgByANlCAJIA6UkiAIIAyUkpI4AhggAioCUCEHIAIqAkghCSACKgJMIQggASoCCCELIAEqAgAhDCABKgIEIQ0gASoCGCEOIAEqAhAhDyABKgIUIRAgASoCKCEUIAEqAiAhFSABKgIkIRYgAkEANgJUIAIgCSAVlCAIIBaUkiAHIBSUkjgCUCACIAkgD5QgCCAQlJIgByAOlJI4AkwgAiAMIAmUIA0gCJSSIAsgB5SSOAJIIANBADYCHCADIAogE5I4AhggAyAKIBKSOAIUIAMgCiARkjgCECADQQA2AgwgAyATIAqTOAIIIAMgEiAKkzgCBCADIBEgCpM4AgAgBiACKAJgIAMQpAEgBEEBaiIEIAVHDQALCyAAEP0BAkAgACgCoAciAgRAIAAoAsABIgQgBCgCACgCMBEGACEKIAIqAgAhByACKgIEIQkgAioCCCEIIABBADYCiAcgACAIIAqTOAKEByAAIAkgCpM4AoAHIAAgByAKkzgC/AYgAioCFCEHIAIqAhghCSACKgIQIQggAEEANgKYByAAIAogCZI4ApQHIAAgCiAHkjgCkAcgAEGMB2oiAiAKIAiSOAIAIAAoArwBIgRFDQEgACgCrAUiBSgCICIGIAQgAEH8BmogAiAFKAIkIAYoAgAoAhARCQAMAQsgAEIANwL8BiAAQgA3ApQHIABCADcCjAcgAEIANwKEBwsgABD8ASAAQYQJaiABKQIINwIAIAAgASkCADcC/AggAEGUCWogASkCGDcCACAAQYwJaiABKQIQNwIAIABBnAlqIAEpAiA3AgAgAEGkCWogASkCKDcCACAAQbQJaiABKQI4NwIAIABBrAlqIAEpAjA3AgAgA0EgaiQAC7UDAQR/IABB4AhqKAIAIAFBAnRqKAIAIgIoAtwCIgEEQCAAQZgIaiABEKMBCyACKAI0IgEEQCACLQA4BEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyACQQA2AjQLIAJBADYCNCACQgA3AiwgAkEBOgA4IAIoAiAiAQRAIAItACQEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIAJBADYCIAsgAkEANgIgIAJCADcCGCACQQE6ACQgAigCDCIBBEAgAi0AEARAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAkEANgIMC0EAIQEgAkEANgIMIAJBAToAECACQgA3AgQgAgRAQez3AUHs9wEoAgBBAWo2AgAgAkGQ0gEoAgARAAALAkAgAEHYCGooAgAiA0EBSA0AIAAoAuAIIQUDQCACIAUgAUECdGoiBCgCAEcEQCABQQFqIgEgA0cNAQwCCwsgASADTg0AIAQgBSADQX9qIgRBAnQiAWooAgA2AgAgACgC4AggAWogAjYCACAAIAQ2AtgICwsHACAAKAIIC0EBAX8jAEEQayIBIAA2AgwgASgCDCIAQQA2AgAgAEEANgIEIABBgCA2AgggAEGAIDYCDCAAQQA2AhAgAEEBNgIUC7IBAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AggCfyMAQRBrIgEgAigCDCIANgIMIAEoAgwoAgggAigCCEgLBEAgAiAAIAIoAggQygU2AgQgAAJ/IwBBEGsiASAANgIMIAEoAgwoAgQLIAIoAgQQ/AIgAAJ/IwBBEGsiASAANgIMIAEoAgwoAgQLEPkCIAAQUCAAQQE6ABAgACACKAIENgIMIAAgAigCCDYCCAsgAkEQaiQAC6EBAQN/IwBBEGsiAiQAIAIgADYCCCACIAE2AgQgAiACKAIIIgA2AgwgAEEwaiEDIAAhAQNAIwBBEGsgATYCDCABQRBqIgQhASADIARHDQALIAAgAigCBCIBKQIANwIAIAAgASkCCDcCCCAAIAIoAgQiASkCEDcCECAAIAEpAhg3AhggACACKAIEIgEpAiA3AiAgACABKQIoNwIoIAJBEGokAAvAAQEBfyMAQTBrIgokACAKIAA2AiggCiABNgIkIAogAjYCICAKIAM2AhwgCiAENgIYIAogBTYCFCAKIAY2AhAgCiAHNgIMIAogCDYCCCAKIAk2AgQgCiAKKAIoIgA2AiwgAEEwaiECIAAhAQNAIwBBEGsgATYCDCABQRBqIgMhASACIANHDQALIAAgCigCJCAKKAIgIAooAhwgCigCGCAKKAIUIAooAhAgCigCDCAKKAIIIAooAgQQogEgCkEwaiQAC3gBAX8jAEEgayIDIAA2AhwgA0EANgIYIAMgATYCFCADIAI2AhAgAygCHCEAIAMgAygCGDYCDANAIAMoAgwgAygCFEgEQCADKAIQIAMoAgxBAnRqIAAoAgwgAygCDEECdGooAgA2AgAgAyADKAIMQQFqNgIMDAELCwspAgF/AX0jAEEQayIBJAAgASAANgIMIAEoAgwQ8AUhAiABQRBqJAAgAgspAgF/AX0jAEEQayIBJAAgASAANgIMIAEoAgwQ+gUhAiABQRBqJAAgAgs8AgF/AX0jAEEQayIBJAAgASAANgIMIAEoAgwQWiECIwBBEGsiACACOAIMIAAqAgyRIQIgAUEQaiQAIAILSgEBfyMAQRBrIgQkACAEIAA2AgwgBCABNgIIIAQgAjYCBCAEIAM6AAMgBCgCDCAEKAIIIAQoAgQgBC0AA0EBcRCLAiAEQRBqJAALPQEBfyMAQRBrIgMkACADIAA2AgwgAyABNgIIIAMgAjYCBCADKAIMIAMoAgggAygCBEEAEIsCIANBEGokAAtaAQF/IwBBEGsiBCAANgIMIAQgATYCCCAEIAI2AgQgBCADOgADIAQoAgwhAAJAIAQtAANBAXEEQCAAIAQoAgg2AlQMAQsgACAEKAIINgJQCyAAIAQoAgQ2AlgLNQEBfyMAQRBrIgIgADYCDCACIAE2AgggAigCDCIAIAIoAggiASkCADcCMCAAIAEpAgg3AjgLMwEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAgwgAigCCEEAQQAQiwIgAkEQaiQACzcBAX8jAEEQayIBJAAgASAANgIMIwBBEGsiACABKAIMNgIMIAAoAgxB3ABqIQAgAUEQaiQAIAALOQEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAgwiACACKAIIIAAoAgAoAkQRAgAgAkEQaiQAC4cBAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDCIAIAIoAggiASkCADcCACAAIAEoAhg2AhggACABKQIQNwIQIAAgASkCCDcCCCAAQRxqIAIoAghBHGoQgwIgACACKAIIIgEpAkw3AkwgACABKAJcNgJcIAAgASkCVDcCVCACQRBqJAALGAEBfyMAQRBrIgEgADYCDCABKAIMQRhqCyQBAX8jAEEQayICIAA2AgwgAiABOAIIIAIoAgwgAioCCDgCIAsYAQF/IwBBEGsiASAANgIMIAEoAgwqAiALGAEBfyMAQRBrIgEgADYCDCABKAIMQQRqC2cBAX8jAEEQayICIAA2AgwgAiABNgIIIAIoAgwiACACKAIIIgEpAgA3AgAgACABKQIINwIIIAAgAigCCCIBKQIQNwIQIAAgASkCGDcCGCAAIAIoAggiASkCIDcCICAAIAEpAig3AigLUQEBfyMAQRBrIgMkACADIAA2AgwgAyABNgIIIAMgAjYCBCADKAIMIgAgAygCCBCDAiAAIAMoAgQiASkCADcCMCAAIAEpAgg3AjggA0EQaiQAC34BAX8jAEEQayIDJAAgAyAANgIMIAMgATYCCCADIAI2AgQjAEEQayIBIAMoAgwiADYCDCABKAIMQdQLNgIAIABBgAs2AgAgAEEEaiADKAIIEIoBIABBxABqIAMoAgQQigEgAEGEAWogAygCCBCKASAAQQA2AsQBIANBEGokAAt8AQN/IwBBIGsiACQAAkBB0NgBLQAAQQFxDQBB0NgBEBBFDQAQxQghASAAQwAAAAA4AgwgAEMAAAAAOAIIIABDAAAAADgCBCAAQRBqIgIgAEEMaiAAQQhqIABBBGoQCUGQ2AEgASACEJYCQdDYARAPCyAAQSBqJABBkNgBCy8BAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIAIoAggQxwkgAkEQaiQACzUBAX8jAEEQayICIAA2AgwgAiABNgIIIAIoAgwiACACKAIIIgEpAgA3AiggACABKQIINwIwCxgBAX8jAEEQayIBIAA2AgwgASgCDEEoagskAQF/IwBBEGsiAiAANgIMIAIgATgCCCACKAIMIAIqAgg4AlwLGAEBfyMAQRBrIgEgADYCDCABKAIMKgJcC1YBAX8jAEEQayIBJAAgASAANgIMIAEoAgwiABD3BiABQwAAAAA4AgggAUMAAAAAOAIEIAFDAAAAADgCACAAQTBqIAFBCGogAUEEaiABEAkgAUEQaiQACyQBAX8jAEEQayICIAA2AgwgAiABNgIIIAIoAgwgAigCCDYCBAuHLgELfyMAQRBrIgskAAJAAkACQAJAAkACQAJAAkACQAJAAkAgAEH0AU0EQEHI+AEoAgAiBkEQIABBC2pBeHEgAEELSRsiBUEDdiIAdiIBQQNxBEAgAUF/c0EBcSAAaiICQQN0IgVB+PgBaigCACIBQQhqIQACQCABKAIIIgMgBUHw+AFqIgVGBEBByPgBIAZBfiACd3E2AgAMAQsgAyAFNgIMIAUgAzYCCAsgASACQQN0IgJBA3I2AgQgASACaiIBIAEoAgRBAXI2AgQMDAsgBUHQ+AEoAgAiB00NASABBEACQEECIAB0IgJBACACa3IgASAAdHEiAEEAIABrcUF/aiIAIABBDHZBEHEiAHYiAUEFdkEIcSICIAByIAEgAnYiAEECdkEEcSIBciAAIAF2IgBBAXZBAnEiAXIgACABdiIAQQF2QQFxIgFyIAAgAXZqIgJBA3QiA0H4+AFqKAIAIgEoAggiACADQfD4AWoiA0YEQEHI+AEgBkF+IAJ3cSIGNgIADAELIAAgAzYCDCADIAA2AggLIAFBCGohACABIAVBA3I2AgQgASAFaiIEIAJBA3QiAiAFayIDQQFyNgIEIAEgAmogAzYCACAHBEAgB0EDdiIFQQN0QfD4AWohAUHc+AEoAgAhAgJ/IAZBASAFdCIFcUUEQEHI+AEgBSAGcjYCACABDAELIAEoAggLIQUgASACNgIIIAUgAjYCDCACIAE2AgwgAiAFNgIIC0Hc+AEgBDYCAEHQ+AEgAzYCAAwMC0HM+AEoAgAiCkUNASAKQQAgCmtxQX9qIgAgAEEMdkEQcSIAdiIBQQV2QQhxIgIgAHIgASACdiIAQQJ2QQRxIgFyIAAgAXYiAEEBdkECcSIBciAAIAF2IgBBAXZBAXEiAXIgACABdmpBAnRB+PoBaigCACIBKAIEQXhxIAVrIQMgASECA0ACQCACKAIQIgBFBEAgAigCFCIARQ0BCyAAKAIEQXhxIAVrIgIgAyACIANJIgIbIQMgACABIAIbIQEgACECDAELCyABKAIYIQkgASABKAIMIgRHBEAgASgCCCIAIAQ2AgwgBCAANgIIDAsLIAFBFGoiAigCACIARQRAIAEoAhAiAEUNAyABQRBqIQILA0AgAiEIIAAiBEEUaiICKAIAIgANACAEQRBqIQIgBCgCECIADQALIAhBADYCAAwKC0F/IQUgAEG/f0sNACAAQQtqIgBBeHEhBUHM+AEoAgAiCEUNAEEAIAVrIQICQAJAAkACf0EAIABBCHYiAEUNABpBHyAFQf///wdLDQAaIAAgAEGA/j9qQRB2QQhxIgB0IgEgAUGA4B9qQRB2QQRxIgF0IgMgA0GAgA9qQRB2QQJxIgN0QQ92IAAgAXIgA3JrIgBBAXQgBSAAQRVqdkEBcXJBHGoLIgdBAnRB+PoBaigCACIDRQRAQQAhAAwBCyAFQQBBGSAHQQF2ayAHQR9GG3QhAUEAIQADQAJAIAMoAgRBeHEgBWsiBiACTw0AIAMhBCAGIgINAEEAIQIgAyEADAMLIAAgAygCFCIGIAYgAyABQR12QQRxaigCECIDRhsgACAGGyEAIAEgA0EAR3QhASADDQALCyAAIARyRQRAQQIgB3QiAEEAIABrciAIcSIARQ0DIABBACAAa3FBf2oiACAAQQx2QRBxIgB2IgFBBXZBCHEiAyAAciABIAN2IgBBAnZBBHEiAXIgACABdiIAQQF2QQJxIgFyIAAgAXYiAEEBdkEBcSIBciAAIAF2akECdEH4+gFqKAIAIQALIABFDQELA0AgACgCBEF4cSAFayIDIAJJIQEgAyACIAEbIQIgACAEIAEbIQQgACgCECIBBH8gAQUgACgCFAsiAA0ACwsgBEUNACACQdD4ASgCACAFa08NACAEKAIYIQcgBCAEKAIMIgFHBEAgBCgCCCIAIAE2AgwgASAANgIIDAkLIARBFGoiAygCACIARQRAIAQoAhAiAEUNAyAEQRBqIQMLA0AgAyEGIAAiAUEUaiIDKAIAIgANACABQRBqIQMgASgCECIADQALIAZBADYCAAwIC0HQ+AEoAgAiASAFTwRAQdz4ASgCACEAAkAgASAFayICQRBPBEBB0PgBIAI2AgBB3PgBIAAgBWoiAzYCACADIAJBAXI2AgQgACABaiACNgIAIAAgBUEDcjYCBAwBC0Hc+AFBADYCAEHQ+AFBADYCACAAIAFBA3I2AgQgACABaiIBIAEoAgRBAXI2AgQLIABBCGohAAwKC0HU+AEoAgAiASAFSwRAQdT4ASABIAVrIgE2AgBB4PgBQeD4ASgCACIAIAVqIgI2AgAgAiABQQFyNgIEIAAgBUEDcjYCBCAAQQhqIQAMCgtBACEAIAVBL2oiBEGg/AEoAgAEf0Go/AEoAgAFQaz8AUJ/NwIAQaT8AUKAoICAgIAENwIAQaD8ASALQQxqQXBxQdiq1aoFczYCAEG0/AFBADYCAEGE/AFBADYCAEGAIAsiAmoiBkEAIAJrIghxIgIgBU0NCUGA/AEoAgAiAwRAQfj7ASgCACIHIAJqIgkgB00NCiAJIANLDQoLQYT8AS0AAEEEcQ0EAkACQEHg+AEoAgAiAwRAQYj8ASEAA0AgACgCACIHIANNQQAgByAAKAIEaiADSxsNAiAAKAIIIgANAAsLQQAQXSIBQX9GDQUgAiEGQaT8ASgCACIAQX9qIgMgAXEEQCACIAFrIAEgA2pBACAAa3FqIQYLIAYgBU0NBSAGQf7///8HSw0FQYD8ASgCACIABEBB+PsBKAIAIgMgBmoiCCADTQ0GIAggAEsNBgsgBhBdIgAgAUcNAQwHCyAGIAFrIAhxIgZB/v///wdLDQQgBhBdIgEgACgCACAAKAIEakYNAyABIQALAkAgBUEwaiAGTQ0AIABBf0YNAEGo/AEoAgAiASAEIAZrakEAIAFrcSIBQf7///8HSwRAIAAhAQwHCyABEF1Bf0cEQCABIAZqIQYgACEBDAcLQQAgBmsQXRoMBAsgACIBQX9HDQUMAwtBACEEDAcLQQAhAQwFCyABQX9HDQILQYT8AUGE/AEoAgBBBHI2AgALIAJB/v///wdLDQEgAhBdIgFBABBdIgBPDQEgAUF/Rg0BIABBf0YNASAAIAFrIgYgBUEoak0NAQtB+PsBQfj7ASgCACAGaiIANgIAIABB/PsBKAIASwRAQfz7ASAANgIACwJAAkACQEHg+AEoAgAiAwRAQYj8ASEAA0AgASAAKAIAIgIgACgCBCIEakYNAiAAKAIIIgANAAsMAgtB2PgBKAIAIgBBACABIABPG0UEQEHY+AEgATYCAAtBACEAQYz8ASAGNgIAQYj8ASABNgIAQej4AUF/NgIAQez4AUGg/AEoAgA2AgBBlPwBQQA2AgADQCAAQQN0IgJB+PgBaiACQfD4AWoiAzYCACACQfz4AWogAzYCACAAQQFqIgBBIEcNAAtB1PgBIAZBWGoiAEF4IAFrQQdxQQAgAUEIakEHcRsiAmsiAzYCAEHg+AEgASACaiICNgIAIAIgA0EBcjYCBCAAIAFqQSg2AgRB5PgBQbD8ASgCADYCAAwCCyAALQAMQQhxDQAgASADTQ0AIAIgA0sNACAAIAQgBmo2AgRB4PgBIANBeCADa0EHcUEAIANBCGpBB3EbIgBqIgE2AgBB1PgBQdT4ASgCACAGaiICIABrIgA2AgAgASAAQQFyNgIEIAIgA2pBKDYCBEHk+AFBsPwBKAIANgIADAELIAFB2PgBKAIAIgBJBH9B2PgBIAE2AgBBAAUgAAsaIAEgBmohAkGI/AEhAAJAAkACQAJAAkACQANAIAIgACgCAEcEQCAAKAIIIgANAQwCCwsgAC0ADEEIcUUNAQtBiPwBIQADQCAAKAIAIgIgA00EQCACIAAoAgRqIgQgA0sNAwsgACgCCCEADAAACwALIAAgATYCACAAIAAoAgQgBmo2AgQgAUF4IAFrQQdxQQAgAUEIakEHcRtqIgcgBUEDcjYCBCACQXggAmtBB3FBACACQQhqQQdxG2oiASAHayAFayEAIAUgB2ohBCABIANGBEBB4PgBIAQ2AgBB1PgBQdT4ASgCACAAaiIANgIAIAQgAEEBcjYCBAwDCyABQdz4ASgCAEYEQEHc+AEgBDYCAEHQ+AFB0PgBKAIAIABqIgA2AgAgBCAAQQFyNgIEIAAgBGogADYCAAwDCyABKAIEIgJBA3FBAUYEQCACQXhxIQkCQCACQf8BTQRAIAEoAggiAyACQQN2IgVBA3RB8PgBakcaIAMgASgCDCICRgRAQcj4AUHI+AEoAgBBfiAFd3E2AgAMAgsgAyACNgIMIAIgAzYCCAwBCyABKAIYIQgCQCABIAEoAgwiBkcEQCABKAIIIgIgBjYCDCAGIAI2AggMAQsCQCABQRRqIgMoAgAiBQ0AIAFBEGoiAygCACIFDQBBACEGDAELA0AgAyECIAUiBkEUaiIDKAIAIgUNACAGQRBqIQMgBigCECIFDQALIAJBADYCAAsgCEUNAAJAIAEgASgCHCICQQJ0Qfj6AWoiAygCAEYEQCADIAY2AgAgBg0BQcz4AUHM+AEoAgBBfiACd3E2AgAMAgsgCEEQQRQgCCgCECABRhtqIAY2AgAgBkUNAQsgBiAINgIYIAEoAhAiAgRAIAYgAjYCECACIAY2AhgLIAEoAhQiAkUNACAGIAI2AhQgAiAGNgIYCyABIAlqIQEgACAJaiEACyABIAEoAgRBfnE2AgQgBCAAQQFyNgIEIAAgBGogADYCACAAQf8BTQRAIABBA3YiAUEDdEHw+AFqIQACf0HI+AEoAgAiAkEBIAF0IgFxRQRAQcj4ASABIAJyNgIAIAAMAQsgACgCCAshASAAIAQ2AgggASAENgIMIAQgADYCDCAEIAE2AggMAwsgBAJ/QQAgAEEIdiIBRQ0AGkEfIABB////B0sNABogASABQYD+P2pBEHZBCHEiAXQiAiACQYDgH2pBEHZBBHEiAnQiAyADQYCAD2pBEHZBAnEiA3RBD3YgASACciADcmsiAUEBdCAAIAFBFWp2QQFxckEcagsiATYCHCAEQgA3AhAgAUECdEH4+gFqIQICQEHM+AEoAgAiA0EBIAF0IgVxRQRAQcz4ASADIAVyNgIAIAIgBDYCAAwBCyAAQQBBGSABQQF2ayABQR9GG3QhAyACKAIAIQEDQCABIgIoAgRBeHEgAEYNAyADQR12IQEgA0EBdCEDIAIgAUEEcWoiBSgCECIBDQALIAUgBDYCEAsgBCACNgIYIAQgBDYCDCAEIAQ2AggMAgtB1PgBIAZBWGoiAEF4IAFrQQdxQQAgAUEIakEHcRsiAmsiCDYCAEHg+AEgASACaiICNgIAIAIgCEEBcjYCBCAAIAFqQSg2AgRB5PgBQbD8ASgCADYCACADIARBJyAEa0EHcUEAIARBWWpBB3EbakFRaiIAIAAgA0EQakkbIgJBGzYCBCACQZD8ASkCADcCECACQYj8ASkCADcCCEGQ/AEgAkEIajYCAEGM/AEgBjYCAEGI/AEgATYCAEGU/AFBADYCACACQRhqIQADQCAAQQc2AgQgAEEIaiEBIABBBGohACAEIAFLDQALIAIgA0YNAyACIAIoAgRBfnE2AgQgAyACIANrIgZBAXI2AgQgAiAGNgIAIAZB/wFNBEAgBkEDdiIBQQN0QfD4AWohAAJ/Qcj4ASgCACICQQEgAXQiAXFFBEBByPgBIAEgAnI2AgAgAAwBCyAAKAIICyEBIAAgAzYCCCABIAM2AgwgAyAANgIMIAMgATYCCAwECyADQgA3AhAgAwJ/QQAgBkEIdiIARQ0AGkEfIAZB////B0sNABogACAAQYD+P2pBEHZBCHEiAHQiASABQYDgH2pBEHZBBHEiAXQiAiACQYCAD2pBEHZBAnEiAnRBD3YgACABciACcmsiAEEBdCAGIABBFWp2QQFxckEcagsiADYCHCAAQQJ0Qfj6AWohAQJAQcz4ASgCACICQQEgAHQiBHFFBEBBzPgBIAIgBHI2AgAgASADNgIAIAMgATYCGAwBCyAGQQBBGSAAQQF2ayAAQR9GG3QhACABKAIAIQEDQCABIgIoAgRBeHEgBkYNBCAAQR12IQEgAEEBdCEAIAIgAUEEcWoiBCgCECIBDQALIAQgAzYCECADIAI2AhgLIAMgAzYCDCADIAM2AggMAwsgAigCCCIAIAQ2AgwgAiAENgIIIARBADYCGCAEIAI2AgwgBCAANgIICyAHQQhqIQAMBQsgAigCCCIAIAM2AgwgAiADNgIIIANBADYCGCADIAI2AgwgAyAANgIIC0HU+AEoAgAiACAFTQ0AQdT4ASAAIAVrIgE2AgBB4PgBQeD4ASgCACIAIAVqIgI2AgAgAiABQQFyNgIEIAAgBUEDcjYCBCAAQQhqIQAMAwtB+PcBQTA2AgBBACEADAILAkAgB0UNAAJAIAQoAhwiAEECdEH4+gFqIgMoAgAgBEYEQCADIAE2AgAgAQ0BQcz4ASAIQX4gAHdxIgg2AgAMAgsgB0EQQRQgBygCECAERhtqIAE2AgAgAUUNAQsgASAHNgIYIAQoAhAiAARAIAEgADYCECAAIAE2AhgLIAQoAhQiAEUNACABIAA2AhQgACABNgIYCwJAIAJBD00EQCAEIAIgBWoiAEEDcjYCBCAAIARqIgAgACgCBEEBcjYCBAwBCyAEIAVBA3I2AgQgBCAFaiIDIAJBAXI2AgQgAiADaiACNgIAIAJB/wFNBEAgAkEDdiIBQQN0QfD4AWohAAJ/Qcj4ASgCACICQQEgAXQiAXFFBEBByPgBIAEgAnI2AgAgAAwBCyAAKAIICyEBIAAgAzYCCCABIAM2AgwgAyAANgIMIAMgATYCCAwBCyADAn9BACACQQh2IgBFDQAaQR8gAkH///8HSw0AGiAAIABBgP4/akEQdkEIcSIAdCIBIAFBgOAfakEQdkEEcSIBdCIFIAVBgIAPakEQdkECcSIFdEEPdiAAIAFyIAVyayIAQQF0IAIgAEEVanZBAXFyQRxqCyIANgIcIANCADcCECAAQQJ0Qfj6AWohAQJAAkAgCEEBIAB0IgVxRQRAQcz4ASAFIAhyNgIAIAEgAzYCAAwBCyACQQBBGSAAQQF2ayAAQR9GG3QhACABKAIAIQUDQCAFIgEoAgRBeHEgAkYNAiAAQR12IQUgAEEBdCEAIAEgBUEEcWoiBigCECIFDQALIAYgAzYCEAsgAyABNgIYIAMgAzYCDCADIAM2AggMAQsgASgCCCIAIAM2AgwgASADNgIIIANBADYCGCADIAE2AgwgAyAANgIICyAEQQhqIQAMAQsCQCAJRQ0AAkAgASgCHCIAQQJ0Qfj6AWoiAigCACABRgRAIAIgBDYCACAEDQFBzPgBIApBfiAAd3E2AgAMAgsgCUEQQRQgCSgCECABRhtqIAQ2AgAgBEUNAQsgBCAJNgIYIAEoAhAiAARAIAQgADYCECAAIAQ2AhgLIAEoAhQiAEUNACAEIAA2AhQgACAENgIYCwJAIANBD00EQCABIAMgBWoiAEEDcjYCBCAAIAFqIgAgACgCBEEBcjYCBAwBCyABIAVBA3I2AgQgASAFaiIFIANBAXI2AgQgAyAFaiADNgIAIAcEQCAHQQN2IgRBA3RB8PgBaiEAQdz4ASgCACECAn9BASAEdCIEIAZxRQRAQcj4ASAEIAZyNgIAIAAMAQsgACgCCAshBiAAIAI2AgggBiACNgIMIAIgADYCDCACIAY2AggLQdz4ASAFNgIAQdD4ASADNgIACyABQQhqIQALIAtBEGokACAAC0gBAn8gACgCBCIGQQh1IQcgACgCACIAIAEgAiADKAIAIAdqKAIAIAcgBkEBcRsgA2ogBEECIAZBAnEbIAUgACgCACgCFBEMAAujAQAgAEEBOgA1AkAgACgCBCACRw0AIABBAToANCAAKAIQIgJFBEAgAEEBNgIkIAAgAzYCGCAAIAE2AhAgA0EBRw0BIAAoAjBBAUcNASAAQQE6ADYPCyABIAJGBEAgACgCGCICQQJGBEAgACADNgIYIAMhAgsgACgCMEEBRw0BIAJBAUcNASAAQQE6ADYPCyAAQQE6ADYgACAAKAIkQQFqNgIkCwtdAQF/IAAoAhAiA0UEQCAAQQE2AiQgACACNgIYIAAgATYCEA8LAkAgASADRgRAIAAoAhhBAkcNASAAIAI2AhgPCyAAQQE6ADYgAEECNgIYIAAgACgCJEEBajYCJAsL7QsCBn8IfUMAAIA/IQkCQAJAAkAgALwiBEGAgID8A0YNACABvCIFQf////8HcSICRQ0AIARB/////wdxIgNBgICA/AdNQQAgAkGBgID8B0kbRQRAIAAgAZIPCwJ/QQAgBEF/Sg0AGkECIAJB////2wRLDQAaQQAgAkGAgID8A0kNABpBACACQZYBIAJBF3ZrIgZ2IgcgBnQgAkcNABpBAiAHQQFxawshBgJAIAJBgICA/ANHBEAgAkGAgID8B0cNASADQYCAgPwDRg0CIANBgYCA/ANPBEAgAUMAAAAAIAVBf0obDwtDAAAAACABjCAFQX9KGw8LIABDAACAPyAAlSAFQX9KGw8LIAVBgICAgARGBEAgACAAlA8LAkAgBEEASA0AIAVBgICA+ANHDQAgAJEPCyAAiyEIIANBACADQYCAgIAEckGAgID8B0cbRQRAQwAAgD8gCJUgCCAFQQBIGyEJIARBf0oNASAGIANBgICAhHxqckUEQCAJIAmTIgAgAJUPCyAJjCAJIAZBAUYbDwsCQCAEQX9KDQAgBkEBSw0AIAZBAWsEQCAAIACTIgAgAJUPC0MAAIC/IQkLAn0gAkGBgIDoBE8EQCADQff///sDTQRAIAlDyvJJcZRDyvJJcZQgCUNgQqINlENgQqINlCAFQQBIGw8LIANBiICA/ANPBEAgCUPK8klxlEPK8klxlCAJQ2BCog2UQ2BCog2UIAVBAEobDwsgCEMAAIC/kiIAQwCquD+UIgggAENwpew2lCAAIACUQwAAAD8gACAAQwAAgL6UQ6uqqj6SlJOUQzuquL+UkiILkrxBgGBxviIAIAiTDAELIAhDAACAS5S8IAMgA0GAgIAESSIDGyIEQf///wNxIgZBgICA/ANyIQIgBEEXdUHpfkGBfyADG2ohA0EAIQQCQCAGQfKI8wBJDQAgBkHX5/YCSQRAQQEhBAwBCyACQYCAgHxqIQIgA0EBaiEDCyAEQQJ0IgZBwM4BaioCACINIAK+IgsgBkGwzgFqKgIAIgqTIgxDAACAPyAKIAuSlSIOlCIIvEGAYHG+IgAgACAAlCIPQwAAQECSIAggAJIgDiAMIAAgAkEBdUGA4P//fXFBgICAgAJyIARBFXRqQYCAgAJqviIMlJMgACALIAwgCpOTlJOUIguUIAggCJQiACAAlCAAIAAgACAAIABDQvFTPpRDVTJsPpKUQwWjiz6SlEOrqqo+kpRDt23bPpKUQ5qZGT+SlJIiCpK8QYBgcb4iAJQiDCALIACUIAggCiAAQwAAQMCSIA+Tk5SSIgiSvEGAYHG+IgBDAEB2P5QiCiAGQbjOAWoqAgAgCCAAIAyTk0NPOHY/lCAAQ8Yj9riUkpIiC5KSIAOyIgiSvEGAYHG+IgAgCJMgDZMgCpMLIQogACAFQYBgcb4iDZQiCCALIAqTIAGUIAEgDZMgAJSSIgCSIgG8IgJBgYCAmARODQFBgICAmAQhBAJAAkAgAkGAgICYBEYEQCAAQzyqODOSIAEgCJNeQQFzDQEMBAsgAkH/////B3EiBEGBgNiYBE8NBAJAIAJBgIDYmHxHDQAgACABIAiTX0EBcw0ADAULQQAhAyAEQYGAgPgDSQ0BC0EAQYCAgAQgBEEXdkGCf2p2IAJqIgVB////A3FBgICABHJBlgEgBUEXdkH/AXEiBGt2IgNrIAMgAkEASBshAyAAIAhBgICAfCAEQYF/anUgBXG+kyIIkrwhAgsgCQJ9IAJBgIB+cb4iAUMAcjE/lCIJIAFDjL6/NZQgACABIAiTk0MYcjE/lJIiCJIiACAAIAAgACAAlCIBIAEgASABIAFDTLsxM5RDDurdtZKUQ1WzijiSlENhCza7kpRDq6oqPpKUkyIBlCABQwAAAMCSlSAIIAAgCZOTIgEgACABlJKTk0MAAIA/kiIAvCADQRd0aiICQf///wNMBEAgACADEKYKDAELIAK+C5QhCQsgCQ8LIAlDyvJJcZRDyvJJcZQPCyAJQ2BCog2UQ2BCog2UC8sRAg9/AX4jAEHQAGsiBSQAIAUgATYCTCAFQTdqIRMgBUE4aiEQQQAhAQJAAkADQAJAIA1BAEgNACABQf////8HIA1rSgRAQfj3AUE9NgIAQX8hDQwBCyABIA1qIQ0LIAUoAkwiCSEBAkACQAJAAn8CQAJAAkACQAJAAkACQAJAAkAgCS0AACIGBEADQAJAAkACQCAGQf8BcSIHRQRAIAEhBgwBCyAHQSVHDQEgASEGA0AgAS0AAUElRw0BIAUgAUECaiIHNgJMIAZBAWohBiABLQACIQogByEBIApBJUYNAAsLIAYgCWshASAABEAgACAJIAEQIAsgAQ0RQX8hD0EBIQYgBSgCTCEBAkAgBSgCTCwAAUFQakEKTw0AIAEtAAJBJEcNACABLAABQVBqIQ9BASERQQMhBgsgBSABIAZqIgE2AkxBACEGAkAgASwAACIOQWBqIgpBH0sEQCABIQcMAQsgASEHQQEgCnQiCkGJ0QRxRQ0AA0AgBSABQQFqIgc2AkwgBiAKciEGIAEsAAEiDkFgaiIKQR9LDQEgByEBQQEgCnQiCkGJ0QRxDQALCwJAIA5BKkYEQCAFAn8CQCAHLAABQVBqQQpPDQAgBSgCTCIBLQACQSRHDQAgASwAAUECdCAEakHAfmpBCjYCACABLAABQQN0IANqQYB9aigCACELQQEhESABQQNqDAELIBENFUEAIRFBACELIAAEQCACIAIoAgAiAUEEajYCACABKAIAIQsLIAUoAkxBAWoLIgE2AkwgC0F/Sg0BQQAgC2shCyAGQYDAAHIhBgwBCyAFQcwAahDbAyILQQBIDRMgBSgCTCEBC0F/IQgCQCABLQAAQS5HDQAgAS0AAUEqRgRAAkAgASwAAkFQakEKTw0AIAUoAkwiAS0AA0EkRw0AIAEsAAJBAnQgBGpBwH5qQQo2AgAgASwAAkEDdCADakGAfWooAgAhCCAFIAFBBGoiATYCTAwCCyARDRQgAAR/IAIgAigCACIBQQRqNgIAIAEoAgAFQQALIQggBSAFKAJMQQJqIgE2AkwMAQsgBSABQQFqNgJMIAVBzABqENsDIQggBSgCTCEBC0EAIQcDQCAHIRJBfyEMIAEsAABBv39qQTlLDRQgBSABQQFqIg42AkwgASwAACEHIA4hASAHIBJBOmxqQf+yAWotAAAiB0F/akEISQ0ACyAHRQ0TAkACQAJAIAdBE0YEQCAPQX9MDQEMFwsgD0EASA0BIAQgD0ECdGogBzYCACAFIAMgD0EDdGopAwA3A0ALQQAhASAARQ0TDAELIABFDREgBUFAayAHIAIQ2gMgBSgCTCEOCyAGQf//e3EiCiAGIAZBgMAAcRshBkEAIQxBqLMBIQ8gECEHIA5Bf2osAAAiAUFfcSABIAFBD3FBA0YbIAEgEhsiAUGof2oiDkEgTQ0BAkACfwJAAkAgAUG/f2oiCkEGSwRAIAFB0wBHDRQgCEUNASAFKAJADAMLIApBAWsOAxMBEwgLQQAhASAAQSAgC0EAIAYQJwwCCyAFQQA2AgwgBSAFKQNAPgIIIAUgBUEIajYCQEF/IQggBUEIagshB0EAIQECQANAIAcoAgAiCUUNAQJAIAVBBGogCRDdAyIJQQBIIgoNACAJIAggAWtLDQAgB0EEaiEHIAggASAJaiIBSw0BDAILC0F/IQwgCg0VCyAAQSAgCyABIAYQJyABRQRAQQAhAQwBC0EAIQogBSgCQCEHA0AgBygCACIJRQ0BIAVBBGogCRDdAyIJIApqIgogAUoNASAAIAVBBGogCRAgIAdBBGohByAKIAFJDQALCyAAQSAgCyABIAZBgMAAcxAnIAsgASALIAFKGyEBDBELIAUgAUEBaiIHNgJMIAEtAAEhBiAHIQEMAQsLIA5BAWsOHwwMDAwMDAwMAQwDBAEBAQwEDAwMDAgFBgwMAgwJDAwHCyANIQwgAA0PIBFFDQxBASEBA0AgBCABQQJ0aigCACIABEAgAyABQQN0aiAAIAIQ2gNBASEMIAFBAWoiAUEKRw0BDBELC0EBIQwgAUEJSw0PA0BBACABIgBBAWoiAUEKRyAEIAFBAnRqKAIAGw0AC0F/QQEgAEEJSRshDAwPCyAAIAUrA0AgCyAIIAYgAUGSBxE+ACEBDAwLIAUoAkAiAUGyswEgARsiCSAIELUKIgEgCCAJaiABGyEHIAohBiABIAlrIAggARshCAwJCyAFIAUpA0A8ADdBASEIIBMhCSAKIQYMCAsgBSkDQCIUQn9XBEAgBUIAIBR9IhQ3A0BBASEMQaizAQwGCyAGQYAQcQRAQQEhDEGpswEMBgtBqrMBQaizASAGQQFxIgwbDAULIAUpA0AgEBCxCiEJIAZBCHFFDQUgCCAQIAlrIgFBAWogCCABShshCAwFCyAIQQggCEEISxshCCAGQQhyIQZB+AAhAQsgBSkDQCAQIAFBIHEQsAohCSAGQQhxRQ0DIAUpA0BQDQMgAUEEdkGoswFqIQ9BAiEMDAMLQQAhASASQf8BcSIHQQdLDQUCQAJAAkACQAJAAkACQCAHQQFrDgcBAgMEDAUGAAsgBSgCQCANNgIADAsLIAUoAkAgDTYCAAwKCyAFKAJAIA2sNwMADAkLIAUoAkAgDTsBAAwICyAFKAJAIA06AAAMBwsgBSgCQCANNgIADAYLIAUoAkAgDaw3AwAMBQsgBSkDQCEUQaizAQshDyAUIBAQeCEJCyAGQf//e3EgBiAIQX9KGyEGIAUpA0AhFAJ/AkAgCA0AIBRQRQ0AIBAhCUEADAELIAggFFAgECAJa2oiASAIIAFKGwshCAsgAEEgIAwgByAJayIKIAggCCAKSBsiDmoiByALIAsgB0gbIgEgByAGECcgACAPIAwQICAAQTAgASAHIAZBgIAEcxAnIABBMCAOIApBABAnIAAgCSAKECAgAEEgIAEgByAGQYDAAHMQJwwBCwtBACEMDAELQX8hDAsgBUHQAGokACAMC/MXAQ9/IwBBkAFrIgMkAAJAIAJBAEwEQCAAKAIMIgEEQCAALQAQBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AgwLIABBADYCDCAAQQE6ABAgAEIANwIEIAAoAiAiAQRAIAAtACQEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYCIAsgAEEANgIgIABCADcCGCAAQQE6ACQgACgCNCIBBEAgAC0AOARAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgI0CyAAQQA2AjQgAEIANwIsIABBAToAOAwBCyADQQE6AHAgA0KAgICAgCA3A1ggA0KAgICAgCA3A0ggA0KAgICAgCA3AzggA0EANgJsIANCADcCZCADQgA3A1AgA0IANwNAIANCADcDMCADQRBqIAEgAhC4CiAAKAIEIgJBf0wEQCAAKAIIQX9MBEAgACgCDCIBBEAgAC0AEARAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgIMCyAAQQE6ABAgAEIANwIICwNAIAAoAgwgAkEEdGoiASADKQIANwIAIAEgAykCCDcCCCACQQFqIgEgAk8hBCABIQIgBA0ACwsgAEEANgIEIANBADYCCCADQgA3AwAgACgCGCICQX9MBEAgACgCHEF/TARAIAAoAiAiAQRAIAAtACQEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYCIAsgAEIANwIcIABBAToAJAsDQCAAKAIgIAJBDGxqIgEgAykDADcCACABIAMoAgg2AgggAkEBaiIBIAJPIQQgASECIAQNAAsLIABBADYCGCAAKAIsIgJBf0wEQCAAKAI0IQEgACgCMEF/TAR/AkAgAUUNACAALQA4RQ0AIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEBOgA4IABCADcCMEEABSABCyACQQJ0IgFqQQBBACABaxALGgsgAEEANgIsAkAgAygCjAEiASgCaEF/Sg0AIAFBADYCaEHo9wFB6PcBKAIAQQFqNgIAQQRBEEGM0gEoAgARAwAiCSABNgIAQQAhAkEBIQdBASEKA0AgAyADQRBqIAkgAiIPQQJ0aigCACIGELcKAkAgACgCBCIFIAAoAghHDQAgBSAFQQF0QQEgBRsiCE4NAEEAIQJBACEEAn8gCARAQej3AUHo9wEoAgBBAWo2AgAgCEEEdEEQQYzSASgCABEDACEEIAAoAgQhBQsgBUEBTgsEQANAIAQgAkEEdCIBaiILIAAoAgwgAWoiASkCADcCACALIAEpAgg3AgggAkEBaiICIAVHDQALCyAAKAIMIgEEQCAALQAQBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AgwLIAAgBDYCDCAAQQE6ABAgACAINgIIIAAoAgQhBQsgACgCDCAFQQR0aiIBIAMpAwA3AgAgASADKQMINwIIIAAgACgCBEEBajYCBEF/IQggBigCCCIQIQFBfyELIBAEQANAIAEoAhQiAkF/TARAIAAoAhghBSADQQA2AgggA0IANwMAAkAgBSICIAAoAhxHDQAgBSACQQF0QQEgAhsiDE4NAEEAIQIgBSEEQQAhBgJ/IAwEQEHo9wFB6PcBKAIAQQFqNgIAIAxBDGxBEEGM0gEoAgARAwAhBiAAKAIYIQQLIARBAU4LBEADQCAGIAJBDGwiDWoiDiAAKAIgIA1qIg0pAgA3AgAgDiANKAIINgIIIAJBAWoiAiAERw0ACwsgACgCICICBEAgAC0AJARAIAIEQEHs9wFB7PcBKAIAQQFqNgIAIAJBkNIBKAIAEQAACwsgAEEANgIgCyAAIAY2AiAgAEEBOgAkIAAgDDYCHCAAKAIYIQILIAAoAiAgAkEMbGoiAiADKQMANwIAIAIgAygCCDYCCCAAIAAoAhhBAWoiBDYCGCADQQA2AgggA0IANwMAAkAgBCAAKAIcRw0AIAQgBEEBdEEBIAQbIgxODQBBACECQQAhBgJ/IAwEQEHo9wFB6PcBKAIAQQFqNgIAIAxBDGxBEEGM0gEoAgARAwAhBiAAKAIYIQQLIARBAU4LBEADQCAGIAJBDGwiDWoiDiAAKAIgIA1qIg0pAgA3AgAgDiANKAIINgIIIAJBAWoiAiAERw0ACwsgACgCICICBEAgAC0AJARAIAIEQEHs9wFB7PcBKAIAQQFqNgIAIAJBkNIBKAIAEQAACwsgAEEANgIgCyAAIAY2AiAgAEEBOgAkIAAgDDYCHCAAKAIYIQQLIAAoAiAgBEEMbGoiAiADKQMANwIAIAIgAygCCDYCCCAAIAAoAhhBAWo2AhggACgCICERIAEgBTYCFCABKAIIIAVBAWoiDTYCFCARIAVBDGxqIgxBfzYCECAMQQE2AgQCQCABKAIMIg4oAmgiAkF/SgRAIAchBCACIQcMAQsgDiAHNgJoAkACQCAHIApHDQAgCiAKQQF0QQEgChsiBk4NAEEAIQJBACEFIAYEQEHo9wFB6PcBKAIAQQFqNgIAIAZBAnRBEEGM0gEoAgARAwAhBQsCQCAKQQFOBEADQCAFIAJBAnQiBGogBCAJaigCADYCACACQQFqIgIgCkcNAAwCAAsACyAJRQ0CCyAJBEBB7PcBQez3ASgCAEEBajYCACAJQZDSASgCABEAAAsMAQsgCSEFIAohBgsgBSAHQQJ0aiAONgIAIAdBAWohBCAFIQkgBiEKCyAMIAc2AgggESANQQxsaiAPNgIIIAQhByABKAIUIQILIAIhBCAIQQBOBEAgACgCICACQQxsaiAIIAJrNgIAIAshBAsgAiEIIAQhCyABKAIAIgEgEEcNAAsgACgCICALQQxsaiAIIAtrNgIACyAPQQFqIgIgB0gNAAtBACEHA0AgCSAHQQJ0aigCACgCCCIGIQEgBgRAA0AgASgCFCICQQBOBEACQCAAKAIsIgUgACgCMEcNACAFIAVBAXRBASAFGyIITg0AQQAhAkEAIQQgCARAQej3AUHo9wEoAgBBAWo2AgAgCEECdEEQQYzSASgCABEDACEEIAAoAiwhBQsgACgCNCELAkACQCAFQQFOBEADQCAEIAJBAnQiCmogCiALaigCADYCACACQQFqIgIgBUcNAAwCAAsACyALRQ0BCyAALQA4BEAgCyICBEBB7PcBQez3ASgCAEEBajYCACACQZDSASgCABEAAAsLIABBADYCNCAAKAIsIQULIAAgBDYCNCAAQQE6ADggACAINgIwIAEoAhQhAgsgACgCNCAFQQJ0aiACNgIAIAAgACgCLEEBajYCLCABIQIDQCACQX82AhQgAigCCCgCBCICIAFHDQALCyABKAIAIgEgBkcNAAsLIAcgD0YhASAHQQFqIQcgAUUNAAsgCUUNACAJBEBB7PcBQez3ASgCAEEBajYCACAJQZDSASgCABEAAAsLIAMoAmwiAARAIAMtAHAEQCAABEBB7PcBQez3ASgCAEEBajYCACAAQZDSASgCABEAAAsLIANBADYCbAsgA0EANgJsIANBAToAcCADQgA3AmQDQCADKAJQIgAEQCADIAAoAgg2AlAgACgCACIBBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsgAARAQez3AUHs9wEoAgBBAWo2AgAgAEGQ0gEoAgARAAALDAELCwNAIAMoAkAiAARAIAMgACgCCDYCQCAAKAIAIgEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACyAABEBB7PcBQez3ASgCAEEBajYCACAAQZDSASgCABEAAAsMAQsLA0AgAygCMCIARQ0BIAMgACgCCDYCMCAAKAIAIgEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACyAABEBB7PcBQez3ASgCAEEBajYCACAAQZDSASgCABEAAAsMAAALAAsgA0GQAWokAAvuAgELfyMAQRBrIggkACAAKAIMIgsgAiADakECbUEEdGoiBCgCCCENIAQoAgQhCSAEKAIAIQogAiEEIAMhBQNAAkACQCALIARBBHRqIgYoAgQiByAJSA0AIAcgCUcNASAGKAIAIgcgCkgNACAHIApHDQEgBigCCCANTg0BCyAEQQFqIQQMAQsDQAJAAkAgCSALIAVBBHQiDmoiBygCBCIMSA0AIAkgDEcNASAKIAcoAgAiDEgNACAKIAxHDQEgDSAHKAIITg0BCyAFQX9qIQUMAQsLAn8gBCAFTARAIAggBikCCDcDCCAIIAYpAgA3AwAgBiAHKQIANwIAIAYgBykCCDcCCCAAKAIMIA5qIgYgCCkDADcCACAGIAgpAwg3AgggBUF/aiEFIARBAWohBAsgBCAFTAsEQCAAKAIMIQsMAQsLIAUgAkoEQCAAIAEgAiAFEKcCCyAEIANIBEAgACABIAQgAxCnAgsgCEEQaiQAC+0BAQl/IAAoAgQhBAJ/IAEgACgCAEYEQEECIAEgBEcNARpBAkEBIAEoAgwiBCgCYCABKAIIKAIMIgEoAmAiBWsiByAAKAIMIgAoAlwgASgCXCIGayIIbCAEKAJcIAZrIgYgACgCYCAFayIFbGusIAIoAggiCSADKAIEIgpsIAIoAgQiCyADKAIIIgxsa6x+IAYgACgCWCABKAJYIgBrIgFsIAQoAlggAGsiACAIbGusIAMoAgAiAyALbCACKAIAIgIgCmxrrH58IAAgBWwgASAHbGusIAIgDGwgAyAJbGusfnxCAFUbDwsgASAERgsLlgUBCH8jAEEQayIGJAACQCACIAFrIgRBAk0EQAJAAkACQAJAIARBAWsOAgIBAAsgA0IANwIAIANCADcCCAwECyAAKAJcIAFBAnRqKAIAIgQoAswBIQEgBCgCXCEFAkAgBCgCWCIJIAQoAsgBIgdHDQAgASAFRw0AIAUhASAEKAJgIAQoAtABRg0CCyAEQfAAaiECAkAgBSABayIIIAkgB2siAXJFBEAgAiAEIAQoAmAgBCgC0AFKIgUbIgEgATYCBCABIAE2AgAgAyABNgIIIAMgATYCBCADIAE2AgAgBCACIAUbIQIgASEEDAELIAQgAjYCBCAEIAI2AgAgBCAENgJ0IAQgBDYCcCADIAIgBCABQQBIIgcgCEEASCIFIAFFcXIiARs2AgQgAyAEIAIgARs2AgBBACAFRSAHIAhFcRtFBEAgAyAENgIIIAIhAQwBCyADIAI2AgggBCEBCyADIAE2AgwgACAEIAIQqgIiACAANgIEIAAgADYCACAEIAA2AgggACgCCCIAIAA2AgQgACAANgIAIAIgADYCCAwDCyAAKAJcIAFBAnRqKAIAIQQLIARBADYCCCAEIAQ2AgQgBCAENgIAIAMgBDYCDCADIAQ2AgggAyAENgIEIAMgBDYCAAwBCyAEQQJtIAFqIgUhBAJAIAUgAk4NACAAKAJcIgsgBUECdGpBfGooAgAiBCgCWCEIIAQoAmAhCSAEKAJcIQcgBSEEA0AgCyAEQQJ0aigCACIKKAJYIAhHDQEgCigCXCAHRw0BIAooAmAgCUcNASAEQQFqIgQgAkgNAAsgAiEECyAAIAEgBSADEKkCIAZCADcDCCAGQgA3AwAgACAEIAIgBhCpAiAAIAMgBhC6CgsgBkEQaiQAC7gEAQV/AkAgACgCOCIFDQACQCAAKAI0IgMEQCAAIAMoAgg2AjQMAQtB6PcBQej3ASgCAEEBajYCAEEMQRBBjNIBKAIAEQMAIQMgACgCPCEEIANBADYCCCADIAQ2AgRB6PcBQej3ASgCAEEBajYCACADIARBGGxBEEGM0gEoAgARAwA2AgAgAyAAKAIwNgIIIAAgAzYCMAsgAygCACEFIAMoAgQiBkEBSA0AQQAhAyAFIQQDQCAEIARBGGoiBEEAIANBAWoiAyAGSBs2AgAgAyAGRw0ACwsgACAFKAIANgI4IAVCADcCECAFQgA3AgggBUIANwIAAkAgACgCOCIGDQACQCAAKAI0IgMEQCAAIAMoAgg2AjQMAQtB6PcBQej3ASgCAEEBajYCAEEMQRBBjNIBKAIAEQMAIQMgACgCPCEEIANBADYCCCADIAQ2AgRB6PcBQej3ASgCAEEBajYCACADIARBGGxBEEGM0gEoAgARAwA2AgAgAyAAKAIwNgIIIAAgAzYCMAsgAygCACEGIAMoAgQiB0EBSA0AQQAhAyAGIQQDQCAEIARBGGoiBEEAIANBAWoiAyAHSBs2AgAgAyAHRw0ACwsgACAGKAIANgI4IAZCADcCACAFIAY2AgggBiAFNgIIIAUgACgCZCIENgIUIAYgBDYCFCAFIAI2AgwgBiABNgIMIAVBADYCECAGQQA2AhAgACAAKAJ0IgFBAWoiAjYCdCABIAAoAnhOBEAgACACNgJ4CyAFC4cJAQt/IAFBDGohCSACQQxqIQogACgCDCENA0AgC0ECaiEAIAEgC0EBaiILQf8BcUEDcEECdGooAgAhAyACKAIEIQcCQAJAIAIoAgAiCCABIABB/wFxQQNwQQJ0aigCACIERgRAQQIhACADIAdGDQELAkAgAyAIRgRAQQIhBSAEIAdGDQELIAIoAgghBiAEIAdGBEBBACEAIAMgBkYNAgsgAyAHRgRAQQAhBSAEIAZGDQELIAQgBkYEQEEBIQAgAyAIRg0CC0Gc0gEhACADIAZHDQJBASEFIAQgCEcNAgsgCiAFQQJ0aiEADAELIAogAEECdGohAAsgASgCBCEFIAAoAgAhDAJAAkAgAyABKAIAIghGBEBBAiEAIAQgBUYNAQsCQCAEIAhGBEBBAiEAIAMgBUYNAQsgASgCCCEGIAMgBUYEQEEAIQAgBCAGRg0CCyAEIAVGBEBBACEAIAMgBkYNAQsgAyAGRgRAQQEhACAEIAhGDQILQZzSASEHIAQgBkcNAkEBIQAgAyAIRw0CCyAJIABBAnRqIQcMAQsgCSAAQQJ0aiEHC0ECIQUgDSAHKAIAQQJ0aigCACIHKAIEIQACQAJAIAQgBygCACIIRkEAIAAgA0YbDQACQCADIAhGBEAgACAERg0BCyAHKAIIIQYgACAERgRAQQAhBSADIAZGDQILIAAgA0YEQEEAIQUgBCAGRg0BCyAEIAZGBEBBASEFIAMgCEYNAgtBnNIBIQAgAyAGRw0CQQEhBSAEIAhHDQILIAcgBUECdGpBDGohAAwBCyAHIAVBAnRqQQxqIQALIAAgDDYCACABKAIEIQcCQAJAIAMgASgCACIIRgRAQQIhACAEIAdGDQELAkAgBCAIRgRAQQIhBSADIAdGDQELIAEoAgghBiADIAdGBEBBACEAIAQgBkYNAgsgBCAHRgRAQQAhBSADIAZGDQELIAMgBkYEQEEBIQAgBCAIRg0CC0Gc0gEhACAEIAZHDQJBASEFIAMgCEcNAgsgCSAFQQJ0aiEADAELIAkgAEECdGohAAsgAigCBCEFIAAoAgAhDAJAAkAgBCACKAIAIghGBEBBAiEAIAMgBUYNAQsCQCADIAhGBEBBAiEAIAQgBUYNAQsgAigCCCEGIAQgBUYEQEEAIQAgAyAGRg0CCyADIAVGBEBBACEAIAQgBkYNAQsgBCAGRgRAQQEhACADIAhGDQILQZzSASEHIAMgBkcNAkEBIQAgBCAIRw0CCyAKIABBAnRqIQcMAQsgCiAAQQJ0aiEHC0ECIQUgDSAHKAIAQQJ0aigCACIHKAIEIQACQAJAIAMgBygCACIIRkEAIAAgBEYbDQACQCAEIAhGBEAgACADRg0BCyAHKAIIIQYgACADRgRAQQAhBSAEIAZGDQILIAAgBEYEQEEAIQUgAyAGRg0BCyADIAZGBEBBASEFIAQgCEYNAgtBnNIBIQAgBCAGRw0CQQEhBSADIAhHDQILIAcgBUECdGpBDGohAAwBCyAHIAVBAnRqQQxqIQALIAAgDDYCACALQQNHDQALCygBAX8gACgCGCIBBEAgARCsAhAOCyAAKAIcIgEEQCABEKwCEA4LIAALJAEBfyMAQRBrIgIgADYCDCACIAE7AQogAigCDCACLwEKOwEOCxgBAX8jAEEQayIBIAA2AgwgASgCDC4BDgskAQF/IwBBEGsiAiAANgIMIAIgATsBCiACKAIMIAIvAQo7AQwLGAEBfyMAQRBrIgEgADYCDCABKAIMLgEMC5gJAgp/B30jAEEgayIEJAAgACgCOCEIAkAgAiABa0EBRgRAAkAgAC0APARAIAAoAogBIAhBBHRqIgIgACgCdCABQQR0aiIBKQIANwIADAELIAAoAmAgCEEGdGoiAiAAKAJMIAFBBnRqIgEpAgA3AgAgAiABKQI4NwI4IAIgASkCMDcCMCACIAEpAig3AiggAiABKQIgNwIgIAIgASkCGDcCGCACIAEpAhA3AhALIAIgASkCCDcCCCAAIAAoAjhBAWo2AjgMAQsgACABIAIgACABIAIQ1woQ1gohCyAAKAI4IQcCQCAALQA8BEAgACoCKCEOIAAqAgghDyAAKgIYIRAgACoCLCERIAAqAgwhEiAAKgIcIRMgACgCiAEgB0EEdGoiBgJ/IAAqAhQgACoCBJMgACoCJJQiDUMAAIBPXSANQwAAAABgcQRAIA2pDAELQQALQf7/A3E7AQAgBgJ/IBMgEpMgEZQiDUMAAIBPXSANQwAAAABgcQRAIA2pDAELQQALQf7/A3E7AQQgBgJ/IBAgD5MgDpQiDUMAAIBPXSANQwAAAABgcQRAIA2pDAELQQALQf7/A3E7AQIMAQsgACgCYCAHQQZ0aiIFIAApAhQ3AgAgBSAAKQIcNwIICyAAKAI4IQUCQCAALQA8BEAgACoCKCEQIAAqAgghDSAAKgIsIREgACoCDCEOIAAoAogBIAVBBHRqIgMCfyAAKgIEIg8gD5MgACoCJJRDAACAP5IiD0MAAIBPXSAPQwAAAABgcQRAIA+pDAELQQALQQFyOwEGIAMCfyAOIA6TIBGUQwAAgD+SIg5DAACAT10gDkMAAAAAYHEEQCAOqQwBC0EAC0EBcjsBCiADAn8gDSANkyAQlEMAAIA/kiINQwAAgE9dIA1DAAAAAGBxBEAgDakMAQtBAAtBAXI7AQgMAQsgACgCYCAFQQZ0aiIFIAApAgQ3AhAgBSAAKQIMNwIYCyAAKAI4IQYgAiABSgRAIAEhBQNAAkAgAC0APARAIAAoAnQgBUEEdGoiAy8BBCEJIAMvAQIhCiADLwEAIQwgACoCLCENIAAqAighDiAAKgIkIQ8gBEEANgIcIAQgDLMgD5UgACoCBCIQkjgCECAEIAqzIA6VIAAqAggiEZI4AhQgBCAJsyANlSAAKgIMIhKSOAIYIAMvAQYhCSADLwEIIQogAy8BCiEDIARBADYCDCAEIBIgA7MgDZWSOAIIIAQgESAKsyAOlZI4AgQgBCAQIAmzIA+VkjgCAAwBCyAEIAAoAkwgBUEGdGoiAykCCDcDGCAEIAMpAgA3AxAgBCADKQIYNwMIIAQgAykCEDcDAAsgACAGIARBEGogBBDVCiAAKAI4IQYgBUEBaiIFIAJHDQALCyAAIAZBAWoiBjYCOCAAIAEgCxCxAiAAKAI4IQMgACALIAIQsQIgACgCOCAIayEBAkAgAC0APCIFRQ0AIAFBgQFIDQAgACAGIAMQ1AogAC0APCEFCyAFQf8BcQRAIAAoAogBIAdBBHRqQQAgAWs2AgwMAQsgACgCYCAHQQZ0aiABNgIgCyAEQSBqJAALOQEBfyMAQRBrIgEkACABIAA2AgwjAEEQayIAIAEoAgw2AgwgACgCDCgCCEEARyEAIAFBEGokACAAC7ACAQV/IABB8KsBNgIAIABBADoAHCAAQQA2AhggAEEANgJIIABBAToAFCAAQQA2AhAgAEEBOgAwIABCADcCCCAAQQA2AiwgAEEBOgBEIABCADcCJCAAQUBrQQA2AgAgAEIANwI4Qej3AUHo9wEoAgBBAWo2AgBBIEEQQYzSASgCABEDACEDIAAoAggiBUEBTgRAA0AgAyAEQQR0IgJqIgEgACgCECACaiICKAIANgIAIAEgAigCBDYCBCABIAIoAgg2AgggASACKAIMNgIMIARBAWoiBCAFRw0ACwsgACgCECIBBEAgAC0AFARAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgIQCyAAIAM2AhAgAEEBOgAUIABBAjYCDCAAEO8DC+4CAQF/IABBoKoBNgIAIAAoAmwEQCAAKAJwIgEgASgCACgCABEBABogACgCcCIBBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsgACgCbCIBIAEoAgAoAgARAQAaIAAoAmwiAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAKAJYIgEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACyAAKAJUIgEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACyAAKAJQIgEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACyAAKAI8IgEEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIAAtAGQEQCAAKAJcIgEgASgCACgCABEBABogACgCXCIBBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIAALtAQBA38gAEKAgID8g4CAwD83AgQgAEEANgIwIABBmKgBNgIAIABBAToAJCAAQoCAgPwDNwIMIABBADYCICAAQgA3AhggAEEBOgBkIABBADYCYCAAQQE6AHggAEIANwJYIABBADYCdCAAQQE6AIwBIABCADcCbCAAQQA2AogBIABBAToAoAEgAEIANwKAASAAQQA2AqgBIAAgAToApAEgAEIANwKUASAAQQA2ApwBIAAgAjoApQFB6PcBQej3ASgCAEEBajYCAEEgQRBBjNIBKAIAEQMAIQIgACgCGCIFQQFOBEADQCACIARBBXQiA2oiASAAKAIgIANqIgMpAgA3AgAgASADKQIYNwIYIAEgAykCEDcCECABIAMpAgg3AgggBEEBaiIEIAVHDQALCyAAKAIgIgEEQCAALQAkBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AiALIAAgAjYCICAAQQE6ACQgAEEBNgIcIAIgACgCGEEFdGoiAUICNwIYIAFCgICAgIACNwIQIAFCDDcCCCABQgA3AgAgACAAKAIYQQFqNgIYIABBgAFBlAEgAC0ApAEiAhtqKAIAIQMgACgCICIBQQJBAyACGzYCGCABQQA2AgRBDCEEIAFBDEEGIAIbNgIIIAEgA0EDbTYCAAJ/IAAtAKUBBEBBECEEIAAoAlgMAQsgACgCbEEDbQshACABIAQ2AhQgAUEANgIQIAEgADYCDAurAgIBfwZ9IABCIzcCBCAAQaSQATYCACAAQYquj+kDNgIsIABCgICA/AM3AhQgAEKAgID8g4CAwD83AgwgAEGkkQE2AgAgACECIABBATYCNCAAQaiiATYCACACIAEgASoCACIDIAEqAggiBF1BAXNBAXRBAUECIAEqAgQiBSAEXRsgAyAFXRtBAnRqKgIAQ83MzD2UIgMgACoCLF1BAXMEf0GoogEFIAAgAxCnASAAKAIACygCMBEGACEDIAIgACgCACgCMBEGACEEIAIgACgCACgCMBEGACEFIAEqAgAhBiABKgIEIQcgASoCCCEIIABBADYCKCAAQQ02AgQgACAIIAAqAhSUIAWTOAIkIAAgByAAKgIQlCAEkzgCICAAIAYgACoCDJQgA5M4AhwLqwEBCX0gACAAKAIAKAIwEQYAIQIgACAAKAIAKAIwEQYAIQMgACAAKAIAKAIwEQYAIQQgACoCECEFIAAqAiAhBiAAKgIUIQcgACoCJCEIIAAqAgwhCSAAKgIcIQogACABENsBIABBADYCKCAAIAQgCJIgB5UgACoCFJQgBJM4AiQgACADIAaSIAWVIAAqAhCUIAOTOAIgIAAgAiAKkiAJlSAAKgIMlCACkzgCHAvVAQEEfSAAIAEgAiABKAIAKAJEEQUAIAEgASgCACgCMBEGAEMAAAAAXARAIAIqAgQhBCACKgIAIQMgAioCCCEFIAEgASgCACgCMBEGACEGIAAgACoCACAGQwAAgL8gAyADIAOUIAQgBJSSIAUgBZSSQwAAgChdIgEbIgNDAACAP0MAAIC/IAUgARsiBSAFlCADIAOUQwAAgL8gBCABGyIEIASUkpKRlSIDlJSSOAIAIAAgACoCBCAGIAQgA5SUkjgCBCAAIAAqAgggBiAFIAOUlJI4AggLC54EAgh/CX0jAEEgayIHJAAgACgCDCIJIAIgA2pBAm1BGGxqIgQoAhQhCiAEKgIQIQ4gBCoCCCESIAQqAgQhEyAEKgIAIRQgAiEEIAMhBgNAIBQgASoCACIPkyINIA2UIBMgASoCBCIQkyINIA2UkiASIAEqAggiEZMiDSANlJIhDQNAAkACQCAJIARBGGxqIgUqAhAiDCAOXARAIAwgDl0NAQwCCyAFKgIAIA+TIgwgDJQgBSoCBCAQkyIMIAyUkiAFKgIIIBGTIgwgDJSSIgwgDV0gBSgCFCAKSCAMIA1cG0EBRw0BCyAEQQFqIQQMAQsLA0ACQAJAIA4gCSAGQRhsIgtqIggqAhAiDFwEQCAOIAxdDQEMAgsgDSAIKgIAIA+TIgwgDJQgCCoCBCAQkyIMIAyUkiAIKgIIIBGTIgwgDJSSIgxdIAogCCgCFEggDSAMXBtBAUcNAQsgBkF/aiEGDAELCwJ/IAQgBkwEQCAHIAUpAhA3AxggByAFKQIINwMQIAcgBSkCADcDCCAFIAgpAgA3AgAgBSAIKQIINwIIIAUgCCkCEDcCECAAKAIMIAtqIgUgBykDCDcCACAFIAcpAxg3AhAgBSAHKQMQNwIIIAZBf2ohBiAEQQFqIQQLIAQgBkwLBEAgACgCDCEJDAELCyAGIAJKBEAgACABIAIgBhC5AgsgBCADSARAIAAgASAEIAMQuQILIAdBIGokAAv5AwIHfwN9IAAoAhwiBUEBSCEGA0ACQCABQQdLDQACQAJAAkACQAJAAkACQAJAIAFBAWsOBwECAwQFBgcACyAAKgJYIAAqAkiSIQggACoCVCAAKgJEkiEJIAAqAlAgACoCQJIhCgwHCyAAKgJIIAAqAliTIQggACoCVCAAKgJEkiEJIAAqAlAgACoCQJIhCgwGCyAAKgJYIAAqAkiSIQggACoCRCAAKgJUkyEJIAAqAlAgACoCQJIhCgwFCyAAKgJIIAAqAliTIQggACoCRCAAKgJUkyEJIAAqAlAgACoCQJIhCgwECyAAKgJYIAAqAkiSIQggACoCVCAAKgJEkiEJIAAqAkAgACoCUJMhCgwDCyAAKgJIIAAqAliTIQggACoCVCAAKgJEkiEJIAAqAkAgACoCUJMhCgwCCyAAKgJYIAAqAkiSIQggACoCRCAAKgJUkyEJIAAqAkAgACoCUJMhCgwBCyAAKgJIIAAqAliTIQggACoCRCAAKgJUkyEJIAAqAkAgACoCUJMhCgsCQCAGRQRAIAAoAiQhB0EAIQRBACECA0AgByACQSRsaiIDKgIgIAogAyoCFJQgCSADKgIYlJIgCCADKgIclJKSQwAAAABeQQFzRQ0CIAJBAWoiAiAFSA0ACwtBASEEIAFBAWoiAUEIRw0BCwsgBAuTAgIDfwR9IAEqAjxDAAAAP5QhByABKAJAIQMCfQJAIAIgASgCRCIFQQJ0IgRqKgIAIAEqAjQgAioCACIGIAaUIAIqAgQiBiAGlJIgAioCCCIGIAaUkpGUXkEBc0UEQCAAIANBAnRqQQA2AgAgACAEaiAHOAIAIAEoAkghBAwBCyACIANBAnRqKgIAIgYgBpQgAiABKAJIIgRBAnRqKgIAIgggCJSSkSIJQwAAADReQQFzRQRAIAAgA0ECdGogBiABKgI4IAmVIgaUOAIAIAAgBUECdGogB4w4AgAgCCAGlAwCCyAAIANBAnRqQQA2AgAgACAFQQJ0aiAHjDgCAAtDAAAAAAshByAAIARBAnRqIAc4AgALMQEBfyMAQRBrIgEkACABIAA2AgwgASgCDCIAIAAoAgAoAiQRAQAhACABQRBqJAAgAAvnBQEJfwJAIAAoAiAiByAAKAIMIgFODQACQCAAKAIkIAFOBEAgACgCKCEDDAELIAchAiABBEBB6PcBQej3ASgCAEEBajYCACABQQJ0QRBBjNIBKAIAEQMAIQMgACgCICECCyAAKAIoIQUCQCACQQFOBEADQCADIARBAnQiBmogBSAGaigCADYCACAEQQFqIgQgAkcNAAwCAAsACyAFDQAgACADNgIoIAAgATYCJCAAQQE6ACwMAQsgAC0ALARAIAUEQEHs9wFB7PcBKAIAQQFqNgIAIAVBkNIBKAIAEQAACwsgACADNgIoIABBAToALCAAIAE2AiQLIAMgB0ECdCICakEAIAFBAnQiCCACaxALGiAAIAE2AiAgACgCNCIGIAFIBEACQCAAKAI4IAFOBEAgACgCPCEDDAELQQAhBCAGIQJBACEDIAEEQEHo9wFB6PcBKAIAQQFqNgIAIAhBEEGM0gEoAgARAwAhAyAAKAI0IQILIAAoAjwhBQJAIAJBAU4EQANAIAMgBEECdCIJaiAFIAlqKAIANgIAIARBAWoiBCACRw0ADAIACwALIAUNACAAIAM2AjwgACABNgI4IABBQGtBAToAAAwBCyAAQUBrLQAABEAgBQRAQez3AUHs9wEoAgBBAWo2AgAgBUGQ0gEoAgARAAALCyAAIAM2AjwgAEEBOgBAIAAgATYCOAsgAyAGQQJ0IgJqQQAgCCACaxALGgsgACABNgI0IAFBAU4EQCAAKAIoQf8BIAgQCxogACgCPEH/ASAIEAsaCyAHQQFIDQAgACgCPCECIAAoAhAhBSAAKAIoIQZBACEEA0AgAiAEQQJ0aiAGIAAoAgxBf2ogBSAEQQxsaiIBKAIEQRB0IAEoAgByIgEgAUEPdEF/c2oiAUEKdSABc0EJbCIBQQZ1IAFzIgEgAUELdEF/c2oiAUEQdSABc3FBAnRqIgEoAgA2AgAgASAENgIAIARBAWoiBCAHRw0ACwsLigMBBn0gAioCACADKgIAIgeUIAIqAgQgAyoCBCIIlJIgAioCCCADKgIIIguUkiIMIAcgACoCAJQgCCAAKgIQlJIgCyAAKgIglJIiCSAEKgJQIgqMIAogCUMAAAAAXRuUIAcgACoCBJQgCCAAKgIUlJIgCyAAKgIklJIiCSAEKgJUIgqMIAogCUMAAAAAXRuUkiAHIAAqAgiUIAggACoCGJSSIAsgACoCKJSSIgkgBCoCWCIKjCAKIAlDAAAAAF0blJIiCSAEKgJgIgogCSAKXhsgByABKgIAlCAIIAEqAhCUkiALIAEqAiCUkiIJIAUqAlAiCowgCiAJQwAAAABdG5QgByABKgIElCAIIAEqAhSUkiALIAEqAiSUkiIJIAUqAlQiCowgCiAJQwAAAABdG5SSIAcgASoCCJQgCCABKgIYlJIgCyABKgIolJIiByAFKgJYIgiMIAggB0MAAAAAXRuUkiIHIAUqAmAiCCAHIAheG5IiB5IiCCAHIAyTIgcgCCAHXRsgBl5BAXMLOQEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAgwiACACKAIIIAAoAgAoAjwRAgAgAkEQaiQAC+8FAQd/IwBB4ABrIgIkACAAKAIIIgZBAU4EQANAIAAoAhAgBEECdGooAgAiBSgC7AFBAUYEQCAFIAEgBSgCACgCGBECACAAKAIIIQYLIARBAWoiBCAGSA0ACwsgAkEBOgA0IAJBADYCMCACQQE6AEggAkIANwMoIAJBADYCRCACQQE6AFwgAkIANwI8IAJBADYCWCACQgA3A1AgAkEANgIcIAJBAToAICACQgA3AhQCQCAGQQFIDQBBACEEA0AgAiAAKAIQIAdBAnRqKAIAKALAASIFNgIMAkACQCADQX9qIAUgBUEPdEF/c2oiA0EKdSADc0EJbCIDQQZ1IANzIgMgA0ELdEF/c2oiA0EQdSADc3EiAyAETw0AIAIoAhwgA0ECdGooAgAiBEF/Rg0AIAIoAjAhAyACKAJYIQgDQCAFIAggBEEDdGooAgBHBEAgAyAEQQJ0aigCACIEQX9HDQEMAgsLIAIoAkQNAQsgAiAFNgIAIAJBEGogAiACQQxqEPYMIAIoAgwiBCABIAQoAgAoAjwRAgAgACgCCCEGCyAHQQFqIgcgBkgEQCACKAIUIQQgAigCQCEDDAELCyACKAJYIgBFDQAgAi0AXARAIAAEQEHs9wFB7PcBKAIAQQFqNgIAIABBkNIBKAIAEQAACwsgAkEANgJYCyACQQA2AlggAkEBOgBcIAJCADcDUCACKAJEIgAEQCACLQBIBEAgAARAQez3AUHs9wEoAgBBAWo2AgAgAEGQ0gEoAgARAAALCyACQQA2AkQLIAJBADYCRCACQQE6AEggAkIANwI8IAIoAjAiAARAIAItADQEQCAABEBB7PcBQez3ASgCAEEBajYCACAAQZDSASgCABEAAAsLIAJBADYCMAsgAkEANgIwIAJBAToANCACQgA3AyggAigCHCIABEAgAi0AIARAIAAEQEHs9wFB7PcBKAIAQQFqNgIAIABBkNIBKAIAEQAACwsgAkEANgIcCyACQeAAaiQAC/QZAwZ/AX4bfSMAQYAFayIGJAAgAygCDCEHAkAgAygCBCIJKAIEIghBE0wEQCAGIAU4AvwEIAZBADYC+AQgBkG4MDYC0AMgBiAEKAIENgL0BCAGQQA6ALQDIAZBl+7GxgM2ApwDIAZBoM4ANgIQAkACfyAGQdAAaiIIQQA2AhQgCCAJNgIQIAggADYCDCAIIAZBEGo2AgggCCAGQegAajYCBCAIQeDhADYCACAIIgALIAEgAiAHIAcgBkHQA2ogACgCACgCCBEUAEUNACAGKgLUBCIFIAWUIAYqAtgEIg4gDpSSIAYqAtwEIg0gDZSSIg9DF7fROF5BAXMNACAGKgL0BCIQIAQqAgRdQQFzDQAgBiANQwAAgD8gD5GVIg2UOALcBCAGIA4gDZQ4AtgEIAYgBSANlDgC1AQgAygCCCEAIAZBADYCJCAGIAA2AiAgBiAGKQLcBDcDMCAGKQLUBCEMIAZBQGsgBikC7AQ3AwAgBiAMNwMoIAYgBikC5AQ3AzggBiAQOAJIIAQgBkEgakEBIAQoAgAoAgwRDQAaCwwBCyAIQWtqIgpBCE0EQAJAIApBB0sNAAJAAkAgCkEBaw4HAgICAgICAQALIAcqAhQhDiAHKgIkIQ0gByoCGCEPIAcqAjQhGCAHKgI4IRIgByoCKCEQIAcqAiAhESAHKgIQIRcgByoCACETIAcqAgQhFCAHKgIwIRUgByoCCCEZIAEqAjQhFiABKgI4IRogASoCMCEbIAZBADYCLCAGIA8gGIwiGJQgGSAVlJMgECASlJMiHSAZIBuUIA8gFpSSIBAgGpSSkjgCKCAGIA4gGJQgFCAVlJMgDSASlJMiHCAUIBuUIA4gFpSSIA0gGpSSkjgCJCAGIBcgGJQgEyAVlJMgESASlJMiGCATIBuUIBcgFpSSIBEgGpSSkjgCICACKgI0IRIgAioCOCEVIAIqAjAhFiAGQQA2AlwgBiAdIBkgFpQgDyASlJIgECAVlJKSOAJYIAYgHCAUIBaUIA4gEpSSIA0gFZSSkjgCVCAGIBggEyAWlCAXIBKUkiARIBWUkpI4AlAgAioCFCESIAIqAiQhFSACKgIYIRYgAioCKCEaIAIqAiAhGyACKgIAIRggAioCECEdIAIqAgQhHCACKgIIIR4gBkIANwL8AyAGQQA2AuwDIAZCADcChAQgBkEANgKMBCAGIBkgHpQgDyAWlJIgECAalJI4AvgDIAYgGSAclCAPIBKUkiAQIBWUkjgC9AMgBiAUIB6UIA4gFpSSIA0gGpSSOALoAyAGIBQgHJQgDiASlJIgDSAVlJI4AuQDIAZBADYC3AMgBiAZIBiUIA8gHZSSIBAgG5SSOALwAyAGIBQgGJQgDiAdlJIgDSAblJI4AuADIAYgEyAelCAXIBaUkiARIBqUkjgC2AMgBiATIByUIBcgEpSSIBEgFZSSOALUAyAGIBMgGJQgFyAdlJIgESAblJI4AtADIAMoAgghAyAGQegAaiAAIAEgAiAHIAkgCSgCACgCMBEGABC3BCAGIAk2AsQCIAYgAzYCwAIgBkGQ7AA2AmggBiAENgK8AiAEKAIEIQEgBiAFOAK4AiAGIAE2ArACIAAgBkHQA2ogBkEQaiAGIAAoAgAoAggRBAAgCSAGQegAaiAGQSBqIAZB0ABqIAZBEGogBhCGDAwDCyAGIAU4ApQCIAZBADYCkAIgBkG4MDYCaCAGIAQoAgQ2AowCAkACfyAGQSBqIgggCTYCFCAIQQA2AhAgCCAANgIMIAhCADcCBCAIQeDhADYCACAIIgALIAEgAiAHIAcgBkHoAGogACgCACgCCBEUAEUNACAGKgLsASIFIAWUIAYqAvABIg4gDpSSIAYqAvQBIg0gDZSSIg9DF7fROF5BAXMNACAGKgKMAiIQIAQqAgRdQQFzDQAgBiANQwAAgD8gD5GVIg2UOAL0ASAGIA4gDZQ4AvABIAYgBSANlDgC7AEgAygCCCEAIAZBADYC1AMgBiAANgLQAyAGIAYpAvQBNwPgAyAGKQLsASEMIAYgBikChAI3A/ADIAYgDDcD2AMgBiAGKQL8ATcD6AMgBiAQOAL4AyAEIAZB0ANqQQEgBCgCACgCDBENABoLDAILIAIqAjQhGiACKgI4IRsgByoCNCEnIAcqAjghDSABKgI0IRcgASoCOCEYIAcqAhQhECAHKgIkIREgByoCGCEUIAcqAighGSACKgIwIR0gByoCMCEcIAEqAjAhHiAHKgIgIQ8gByoCACETIAcqAhAhEiAHKgIEIRUgByoCCCEWIAIqAhQhDiACKgIkIR8gAioCGCEgIAIqAighISACKgIgISIgAioCACEjIAIqAhAhJCACKgIEISUgAioCCCEmIAZCADcC/AMgBkEANgLsAyAGQgA3AoQEIAZBADYCjAQgBiAWICaUIBQgIJSSIBkgIZSSOAL4AyAGIBYgJZQgFCAOlJIgGSAflJI4AvQDIAYgFSAmlCAQICCUkiARICGUkjgC6AMgBiAVICWUIBAgDpSSIBEgH5SSOALkAyAGQQA2AtwDIAYgFiAjlCAUICSUkiAZICKUkjgC8AMgBiAVICOUIBAgJJSSIBEgIpSSOALgAyAGIBMgJpQgEiAglJIgDyAhlJI4AtgDIAYgEyAllCASIA6UkiAPIB+UkjgC1AMgBiATICOUIBIgJJSSIA8gIpSSOALQAyADKAIIIQMgBkHoAGogACABIAIgByAJIAkoAgAoAjARBgAQtwQgBiAJNgLEAiAGIAM2AsACIAZB5O0ANgJoIAYgBDYCvAIgBCgCBCEBIAYgBTgCuAIgBiABNgKwAiAAIAZB0ANqIAZBIGogBkHQAGogACgCACgCCBEEACAGQQA2AhwgBiAUICeMIh+UIBYgHJSTIBkgDZSTIiAgFiAelCAUIBeUkiAZIBiUkpIiBTgCGCAGIBAgH5QgFSAclJMgESANlJMiISAVIB6UIBAgF5SSIBEgGJSSkiIOOAIUIAYgEiAflCATIByUkyAPIA2UkyIcIBMgHpQgEiAXlJIgDyAYlJKSIg04AhAgDSEXIBwgEyAdlCASIBqUkiAPIBuUkpIiDyANXUEBc0UEQCAGIA84AhAgDyEXCyAOIRMgISAVIB2UIBAgGpSSIBEgG5SSkiIQIA5dQQFzRQRAIAYgEDgCFCAQIRMLICAgFiAdlCAUIBqUkiAZIBuUkpIiESAFIhRdQQFzRQRAIAYgETgCGCARIRQLIAZBADYCDCAGIAU4AgggBiAOOAIEIAYgDTgCACANIA9dQQFzRQRAIAYgDzgCACAPIQ0LIA4gEF1BAXNFBEAgBiAQOAIEIBAhDgsgBSARXUEBc0UEQCAGIBE4AgggESEFCyAGIAYqAiAgF5I4AhAgBiAGKgIkIBOSOAIUIAYgBioCKCAUkjgCGCAGIAYqAlAgDZI4AgAgBiAGKgJUIA6SOAIEIAYgBioCWCAFkjgCCCAJIAZB6ABqIAZBEGogBiAJKAIAKAJAEQQADAELIAhBH0cNAEH55QAQFiAJKAIQQQFOBEBBACEKA0AgCSgCGCAKQdAAbGoiCCgCQCELIAgqAjghEiAIKgIwIRUgCCoCNCEWIAgqAiAhGiAIKgIAIRsgCCoCECEYIAgqAiQhHSAIKgIEIRwgCCoCFCEeIAgqAighHyAIKgIIISAgCCoCGCEhIAcqAjAhIiAHKgI0ISMgByoCOCEkIAcqAgghDiAHKgIAIQ0gByoCBCEPIAcqAhghECAHKgIQIREgByoCFCEXIAcqAighEyAHKgIgIRQgByoCJCEZIAZBADYCpAEgBkEANgKUASAGQQA2AoQBIAZBADYCdCAGICAgFJQgISAZlJIgHyATlJI4ApABIAYgHCAUlCAeIBmUkiAdIBOUkjgCjAEgBiAbIBSUIBggGZSSIBogE5SSOAKIASAGICAgEZQgISAXlJIgHyAQlJI4AoABIAYgHCARlCAeIBeUkiAdIBCUkjgCfCAGIBsgEZQgGCAXlJIgGiAQlJI4AnggBiAgIA2UICEgD5SSIB8gDpSSOAJwIAYgHCANlCAeIA+UkiAdIA6UkjgCbCAGIBsgDZQgGCAPlJIgGiAOlJI4AmggBiAkIBUgFJQgFiAZlJIgEiATlJKSOAKgASAGICMgFSARlCAWIBeUkiASIBCUkpI4ApwBIAYgIiAVIA2UIBYgD5SSIBIgDpSSkjgCmAEgBkGBgHw2AiggBiAKNgIwIAZBvO8ANgIgIAYgBDYCLCAGIAQoAgQ2AiQgAygCCCEIIAYgCjYC5AMgBkF/NgLgAyAGIAg2AtgDIAYgCzYC1AMgBiADNgLQAyAGIAZB6ABqNgLcAyAAIAEgAiAGQdADaiAGQSBqIAUQwQIgCkEBaiIKIAkoAhBIDQALCxATCyAGQYAFaiQAC7ADAQZ/IwBB4ABrIgQkAAJAIAAoAggiBSAAKAIMRw0AIAUgBUEBdEEBIAUbIgdODQACfyAHBEBB6PcBQej3ASgCAEEBajYCACAHQQJ0QRBBjNIBKAIAEQMAIQggACgCCCEFCyAFQQFOCwRAA0AgCCAGQQJ0IglqIAAoAhAgCWooAgA2AgAgBkEBaiIGIAVHDQALCyAAKAIQIgYEQCAALQAUBEAgBgRAQez3AUHs9wEoAgBBAWo2AgAgBkGQ0gEoAgARAAALIAAoAgghBQsgAEEANgIQCyAAIAg2AhAgACAHNgIMIABBAToAFAsgACgCECAFQQJ0aiABNgIAIAAgBUEBajYCCCAEIAEpAgw3AyggBCABKQIENwMgIAQgASkCHDcDOCAEIAEpAhQ3AzAgBCABKQIsNwNIIAQgASkCJDcDQCAEIAEpAjw3A1ggBCABKQI0NwNQIAEoAsABIgYgBEEgaiAEQRBqIAQgBigCACgCCBEEACABIAAoAkQiBiAEQRBqIAQgASgCwAEoAgQgASACIAMgACgCGEEAIAYoAgAoAggRIAA2ArwBIARB4ABqJAAL6AEBBX8gAEGk4wA2AgAgACgCECEBIAAoAggiAkEBTgRAA0AgASADQQJ0aigCACIFKAK8ASIEBEAgACgCRCIBIAEoAgAoAiQRAQAiASAEIAAoAhggASgCACgCKBEFACAAKAJEIgEgBCAAKAIYIAEoAgAoAgwRBQAgBUEANgK8ASAAKAIIIQIgACgCECEBCyADQQFqIgMgAkgNAAsLIAEEQCAALQAUBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AhALIABBADYCECAAQgA3AgggAEEBOgAUIAALRQAgAEGg4gA2AgAgACABKQIANwIEIAAgASkCCDcCDCAAIAIpAgA3AhQgACACKQIINwIcIABBgICA/AM2AiggACADNgIkC5oIAwV/AX4MfSMAQaACayIGJAAgACgCBBDmASABKgI0IQwgAioCNCENIAMqAjQhDiAEKgI0IQ8gASoCOCEQIAIqAjghESADKgI4IRIgBCoCOCETIAEqAjAhFCACKgIwIRUgAyoCMCEWIAQqAjAhFyAGQQA6AIgCIAZB65b46gU2AoQCIAZBpOEANgLgASAGQZABaiAAKAIIIAAoAgwgACgCBEEAEMcCIQogBkHrlvjqBTYCiAEgBiABKQIINwMQIAYgASkCADcDCCAGIAEpAhg3AyAgBiABKQIQNwMYIAYgASkCKDcDMCAGIAEpAiA3AyggBkFAayABKQI4NwMAIAYgASkCMDcDOCAGIAMpAgg3A1AgBiADKQIANwNIIAYgAykCEDcDWCAGIAMpAhg3A2AgBiADKQIoNwNwIAYgAykCIDcDaCAGIAMpAjA3A3ggBiADKQI4NwOAASAKIAZBCGogBkHgAWpBAEEAEEQgBiAGKQL8ATcDmAIgBiAGKQL0ATcDkAICf0EAIAYtAIgCRQ0AGiARIBCTIBMgEpOTIRAgDSAMkyAPIA6TkyEPIBUgFJMgFyAWk5MhESAGKALoASEHIAYoAuwBIQggBigC5AEhCQJAAn0gBioChAIiDkNvEoM6XkEBcwRAQwAAAAAhDCAGKgLwAQwBC0EAIQBDAAAAACENA0BBACAAQSBGDQMaQQAgDSAOIBAgCL6UIA8gB76UIBEgCb6UkpKVkyIMIA1fDQMaQQAgDEMAAIA/Xg0DGkEAIAxDAAAAAF0NAxogBSAMIAUoAgAoAgARCAAgBkMAAIA/IAyTIg0gASoCMJQgDCACKgIwlJI4AjggBiANIAEqAjSUIAwgAioCNJSSOAI8IAYgDSABKgI4lCAMIAIqAjiUkjgCQCAGIA0gAyoCMJQgDCAEKgIwlJI4AnggBiANIAMqAjSUIAwgBCoCNJSSOAJ8IAYgDSADKgI4lCAMIAQqAjiUkjgCgAEgCiAGQQhqIAZB4AFqQQBBABBEQQAgBi0AiAJFDQMaIAYqAoQCIg5DAAAAAF1BAXNFBEAgBSAMOAKkASAGKQLkASELIAUgBikC7AE3AowBIAUgCzcChAEgBSAGKQL8ATcCnAEgBSAGKQL0ATcClAEMAwsgAEEBaiEAIAYgBikC/AE3A5gCIAYgBikC9AE3A5ACIAYoAuQBIQkgBigC6AEhByAGKALsASEIIAwhDSAOQ28SgzpeDQALIAYqAvABCyEOQQAgECAIvpQgDyAHvpQgESAJvpSSkiAFKgKsAYxgDQEaIAUgCTYChAEgBSAMOAKkASAFIA44ApABIAUgCDYCjAEgBSAHNgKIASAFIAYpA5ACNwKUASAFIAYpA5gCNwKcAQtBAQshACAGQaACaiQAIAALwwoBBn8gAEGU1AA2AgBB6PcBQej3ASgCAEEBajYCAEHoAkEQQYzSASgCABEDACICQZfuxsYDNgK0AiACIAItAMwCQfABcToAzAIgACACNgIYIAEoAhQhA0Ho9wFB6PcBKAIAQQFqNgIAQQRBEEGM0gEoAgARAwAiAkGgzgBB8M8AIAMbNgIAIAAgAjYCHEHo9wFB6PcBKAIAQQFqNgIAQRhBEEGM0gEoAgARAwAiBCEFIAAoAhghAyAAKAIcIQIgBUKAgICAMDcCECAFQdz0ADYCACAFQQA6AAQgBSADNgIMIAUgAjYCCCAAIAQ2AiBB6PcBQej3ASgCAEEBajYCAEEIQRBBjNIBKAIAEQMAIgJBiNUANgIAIAJBADoABCAAIAI2AiRB6PcBQej3ASgCAEEBajYCAEEIQRBBjNIBKAIAEQMAIgJB3NUANgIAIAJBADoABCAAIAI2AihB6PcBQej3ASgCAEEBajYCAEEIQRBBjNIBKAIAEQMAIgJBuNYANgIAIAJBADoABCAAIAI2AixB6PcBQej3ASgCAEEBajYCAEEIQRBBjNIBKAIAEQMAIgJBiNcANgIAIAJBADoABCAAIAI2AjBB6PcBQej3ASgCAEEBajYCAEEIQRBBjNIBKAIAEQMAIgJB4NcANgIAIAJBADoABCAAIAI2AjRB6PcBQej3ASgCAEEBajYCAEEIQRBBjNIBKAIAEQMAIgJBtNgANgIAIAJBADoABCAAIAI2AjhB6PcBQej3ASgCAEEBajYCAEEIQRBBjNIBKAIAEQMAIgJB+NgANgIAIAJBADoABCAAIAI2AjxB6PcBQej3ASgCAEEBajYCAEEIQRBBjNIBKAIAEQMAIgJBzNkANgIAIAJBADoABCAAIAI2AkxB6PcBQej3ASgCAEEBajYCAEEIQRBBjNIBKAIAEQMAIgJBzNkANgIAIAAgAjYCUCACQQE6AARB6PcBQej3ASgCAEEBajYCAEEIQRBBjNIBKAIAEQMAIgJBoNoANgIAIAJBADoABCAAIAI2AkhB6PcBQej3ASgCAEEBajYCAEEQQRBBjNIBKAIAEQMAIgJCATcCCCACQezaADYCACACQQA6AAQgACACNgJYQej3AUHo9wEoAgBBAWo2AgBBEEEQQYzSASgCABEDACICQgE3AgggAkHs2gA2AgAgACACNgJUIAJBAToABCABKAIQIQUCQCABKAIAIgIEQCAAIAI2AgggAEEAOgAMDAELIABBAToADEHo9wFB6PcBKAIAQQFqNgIAQRRBEEGM0gEoAgARAwAiBiABKAIIIgI2AgQgBkGEBjYCAEHo9wFB6PcBKAIAQQFqNgIAIAYgAkGEBmxBEEGM0gEoAgARAwAiAzYCDCAGIAM2AhAgBiAGKAIEIgI2AggCQCACQX9qIgdFBEAgAyECDAELIAYoAgAhBANAIAMgAyAEaiICNgIAIAIhAyAHQX9qIgcNAAsLIAJBADYCACAAIAY2AggLIAEoAgQiAgRAIAAgAjYCECAAQQA6ABQPCyAAQQE6ABRB6PcBQej3ASgCAEEBajYCAEEUQRBBjNIBKAIAEQMAIgQgASgCDCICNgIEIAQgBUHQACAFQdAAShsiATYCAEHo9wFB6PcBKAIAQQFqNgIAIAQgASACbEEQQYzSASgCABEDACIDNgIMIAQgAzYCECAEIAQoAgQiATYCCAJAIAFBf2oiB0UEQCADIQIMAQsgBCgCACEBA0AgAyABIANqIgI2AgAgAiEDIAdBf2oiBw0ACwsgAkEANgIAIAAgBDYCEAuWAQEBfSAAIAI2AiAgACABNgIcIAAgAzYCGCAAIAQ2AhQgAEKAgICAgICAwD83AgQgAEGMzwA2AgAgAEIANwIMIAAgASgCBDYCJCAAIAIoAgQ2AiggACABIAEoAgAoAjARBgA4AiwgAiACKAIAKAIwEQYAIQUgAEKBgICAEDcCSCAAQX82AjwgAEEAOgA0IAAgBTgCMCAAC/sFAQJ/IAEgACgCBDYCECABIAAoAgg2AhQgASAAKAIMNgIYIAEgACgCEDYCHCABIAAoAhQ2AiAgASAAKAIYNgIkIAEgACgCHDYCKCABIAAoAiA2AiwgASAAKAIkNgIwIAEgACgCKDYCNCABIAAoAiw2AjggASAAKAIwNgI8IAEgACgCNDYCQCABIAAoAjg2AkQgASAAKAI8NgJIIAEgAEFAaygCADYCTCABIAAoAkQ2AlAgASAAKAJINgJUIAEgACgCTDYCWCABIAAoAlA2AlwgASAAKAJUNgJgIAEgACgCWDYCZCABIAAoAlw2AmggASAAKAJgNgJsIAEgACgCZDYCcCABIAAoAmg2AnQgASAAKAJsNgJ4IAEgACgCcDYCfCABIAAoAnQ2AoABIAEgACgCeDYChAEgASAAKAJ8NgKIASABIAAoAoABNgKMASABIAAoAoQBNgKQASABIAAoAogBNgKUASABIAAoAowBNgKYASABIAAoApABNgKcASABIAAoApQBNgKgASABIAAoApgBNgKkASABIAAoApwBNgKoASABIAAoAqABNgKsASABIAAoAqQBNgKwASABIAAoAqgBNgK0ASABIAAoAqwBNgK4ASABIAAoArABNgK8ASABIAAoArQBNgLgASAAKAK4ASEDIAFBADYCACABIAM2AsABIAIgACgCwAEgAigCACgCHBEDACEDIAFBADYCCCABIAM2AgQgASAAKALMATYC5AEgASAAKALQATYC6AEgASAAKALUATYC7AEgASAAKALYATYC8AEgASAAKALcATYCxAEgASAAKALgATYCyAEgASAAKALoATYCzAEgASAAKALkATYC0AEgASAAKALsATYC9AEgASACIAIgACACKAIAKAIoEQMAIgMgAigCACgCHBEDACIENgIMIAQEQCACIAMgAigCACgCMBECAAsgASAAKAL0ATYC1AEgASAAKAL4ATYC2AEgASAAKAL8ATYC3AEgASAAKAKAAjYC+AFBgMsACzsCAX8BfSMAQRBrIgEkACABIAA2AgwjAEEQayIAIAEoAgw2AgwgACgCDEEMaioCACECIAFBEGokACACC+ADAQJ/AkACQAJAAkACQAJAIAAoAgAiAkEETgRAIAEtAABBCHEEQCACIQMMAgsgACACQX9qIgM2AgAgACAAIANBBHRqIgIpAgw3AjwgACACKQIENwI0IAAgAikCVDcChAEgACACKQJcNwKMASAAIAIpAqwBNwLcASAAIAIpAqQBNwLUAQwBC0EDIQMgAkEDRw0BCyABLQAAQQRxDQEgACADQX9qIgM2AgAgACAAIANBBHRqIgIpAgw3AiwgACACKQIENwIkIAAgAikCVDcCdCAAIAIpAlw3AnwgACACKQKsATcCzAEgACACKQKkATcCxAEMAQtBAiEDIAJBAkgNAQsgAS0AAEECcQ0BIAAgA0F/aiIDNgIAIAAgACADQQR0aiICKQIMNwIcIAAgAikCBDcCFCAAIAIpAlQ3AmQgACACKQJcNwJsIAAgAikCrAE3ArwBIAAgAikCpAE3ArQBDAELQQEhAyACQQFHDQELIAEtAABBAXENACAAIANBf2oiATYCACAAIAFBBHQiAiAAQQRqaiIBKQIANwIEIAAgASkCCDcCDCAAIABB1ABqIAJqIgEpAgA3AlQgACABKQIINwJcIAAgAEGkAWogAmoiASkCCDcCrAEgACABKQIANwKkAQsLwAIBDH0gASoCGCIEIAIqAhAiByABKgIQIgWTIgogACoCBCINlCACKgIUIgggASoCFCIGkyILIAAqAgAiDpSTlCAFIAsgACoCCCIPlCACKgIYIgkgBJMiDCANlJOUIAYgDCAOlCAKIA+Uk5SSkkMAAAAAXUEBcwR/QQAFIAMCfSAFIAWUIAYgBpSSIAQgBJSSIAUgCpQgBiALlJIgBCAMlJJDAAAAAF5BAXNFDQAaIAcgB5QgCCAIlJIgCSAJlJIgByAKlCAIIAuUkiAJIAyUkkMAAAAAXUEBc0UNABogByAHlCAIIAiUkiAJIAmUkiAFIAWUIAYgBpSSIAQgBJSSlCAHIAWUIAggBpSSIAkgBJSSIgQgBJSTIAogCpQgCyALlJIgDCAMlJKVIgRDAAAAACAEQwAAAABeGwuROAIAQQELC9gDAQN/AkAgAy0ANyABRg0AIARBAnQiCEHEygBqKAIAIQcgAyoCACACKgIQlCADKgIEIAIqAhSUkiADKgIIIAIqAhiUkiADKgIQk0OsxSe3XUEBc0UEQCAAIANBFGoiACAHQQJ0aigCACAAIAhqKAIAIAJBABCsASIARQ0BIAAgAzYCICAAIAQ6ADQgAyAEakEAOgA0IAMgBEECdGogADYCIAJAIAUoAgAiAQRAIAEgADYCJCABQQI6ADUgACABNgIoIABBAToANgwBCyAFIAA2AgQLIAUgADYCACAFIAUoAghBAWo2AghBAQ8LIAMgAToANyAAIAEgAiADIAdBAnRqKAIgIAMgB2otADQgBRDMAkUNACAAIAEgAiADIAhB0MoAaigCACIBQQJ0aigCICABIANqLQA0IAUQzAJFDQAgAygCMCIBBEAgASADKAIsNgIsCyADKAIsIgEEQCABIAMoAjA2AjALIAMgACgCwEhGBEAgACADKAIwNgLASAsgAEHEyABqIgEgASgCAEF/ajYCACADQQA2AiwgAyAAKALISDYCMCAAKALISCIBBEAgASADNgIsCyAAIAM2AshIQQEhBiAAQczIAGoiACAAKAIAQQFqNgIACyAGC+4OAgJ/GH0jAEHgzABrIgckACAFQgA3AgAgBUEANgIgIAVCADcCGCAFQgA3AhAgBUIANwIIIAcgAjYC5EsgByAANgLgSyADKgIUIQkgAyoCJCEKIAEqAhQhCyABKgIkIQwgAyoCGCENIAEqAhghDiADKgIoIQ8gASoCKCEQIAMqAiAhESADKgIAIRIgAyoCECETIAMqAgQhFCABKgIgIRUgASoCACEWIAEqAhAhFyABKgIEIRggAyoCCCEZIAEqAgghGiAHQZTMAGpBADYCACAHQYTMAGpBADYCACAHQfTLAGpBADYCACAHQZDMAGogGiAZlCAOIA2UkiAQIA+UkiIbOAIAIAdBjMwAaiAYIBmUIAsgDZSSIAwgD5SSIhw4AgAgB0GIzABqIBYgGZQgFyANlJIgFSAPlJIiDTgCACAHQYDMAGogGiAUlCAOIAmUkiAQIAqUkiIPOAIAIAdB/MsAaiAYIBSUIAsgCZSSIAwgCpSSIhk4AgAgB0H4ywBqIBYgFJQgFyAJlJIgFSAKlJIiCTgCACAHQfDLAGogEiAalCATIA6UkiARIBCUkiIKOAIAIAdB7MsAaiASIBiUIBMgC5SSIBEgDJSSIgs4AgAgByASIBaUIBMgF5SSIBEgFZSSIgw4AuhLIAEqAhQhDiABKgIkIRAgASoCGCERIAEqAjQhEiADKgI0IRMgASoCKCEUIAEqAjghFSADKgI4IRYgASoCACEXIAEqAhAhGCABKgIgIRogASoCBCEdIAEqAgghHiABKgIwIR8gAyoCMCEgIAdB3MwAakEANgIAIAdB1MwAakEANgIAIAdBxMwAakEANgIAIAdBwMwAaiAbOAIAIAdBvMwAaiAPOAIAIAdBuMwAaiAKOAIAIAdBtMwAakEANgIAIAdBsMwAaiAcOAIAIAdBrMwAaiAZOAIAIAdBqMwAaiALOAIAIAdBpMwAakEANgIAIAdBoMwAaiANOAIAIAdBnMwAaiAJOAIAIAdB0MwAaiAeICAgH5MiCZQgESATIBKTIgqUkiAUIBYgFZMiC5SSOAIAIAdBzMwAaiAJIB2UIAogDpSSIAsgEJSSOAIAIAdByMwAaiAJIBeUIAogGJSSIAsgGpSSOAIAIAdBggNBgQMgBhs2AthMIAcgDDgCmEwgB0HoyQBqQgA3AwAgB0IANwPgSSAHQgA3AsxLIAdBAjYC2EsgB0EANgLwSSAEKgIAIQkgBCoCBCEKIAQqAgghCyAHQQA2AhwgByALjDgCGCAHIAqMOAIUIAcgCYw4AhACQCAHQeDIAGogB0HgywBqIAdBEGoQzgJBf2oiAEEBSw0AAkAgAEEBawRAIAdB2MgAakIANwMAIAdBQGtCADcDACAHQQA2AkggB0IANwPQSCAHQQA2AsxIIAdBCTYCECAHQgA3AzhBACEDA0BBACADa0E4bCAHakHYN2oiAEHoEGpBADYCACAAQewQaiAHKALYSCICNgIAIABBvBBqIQAgAgRAIAIgADYCLAsgByAANgLYSCADQQFqIgNBgAFHDQALIAdB3MgAakGAATYCACAEKgIAIQkgBCoCBCEKIAQqAgghCyAHQQA2AgwgByALjDgCCCAHIAqMOAIEIAcgCYw4AgAgB0EQaiAHQeDIAGogBxDfDUEJRwRAIAcoAjRFBEBDAAAAACEJQwAAAAAhCkMAAAAAIQsMAwtDAAAAACELQQAhA0MAAAAAIQpDAAAAACEJA0AgBygC2EwhCCAHIAcoAuBLIAcoAtxMIgJBAXVqIgAgB0EQaiADQQJ0aiIEKAIEIAAoAgAgCGooAgAgCCACQQFxGxEFACALIAQqAhQiDCAHKgIIlJIhCyAKIAwgByoCBJSSIQogCSAHKgIAIAyUkiEJIANBAWoiAyAHKAI0SQ0ACwwCCyAFQQM2AgAMAgsgBUECNgIADAELQQEhCCAFQQE2AgAgASoCMCEMIAEqAgghDSABKgIAIQ4gASoCBCEPIAEqAjQhECABKgIYIREgASoCECESIAEqAhQhEyABKgI4IRQgASoCKCEVIAEqAiAhFiABKgIkIRcgBUEANgIQIAUgFCAJIBaUIAogF5SSIAsgFZSSkjgCDCAFIBAgCSASlCAKIBOUkiALIBGUkpI4AgggBSAMIAkgDpQgCiAPlJIgCyANlJKSOAIEIAEqAjAhECABKgIIIREgASoCACESIAEqAgQhEyABKgI0IRQgASoCGCEVIAEqAhAhFiABKgIUIRcgASoCOCEYIAEqAighGSABKgIgIRogASoCJCEbIAcqAjwhDSAHQUBrKgIAIQ4gByoCOCEPIAcqAkghDCAFQQA2AjAgBUEANgIgIAUgDIw4AjQgBSAOjDgCLCAFIA2MOAIoIAUgD4w4AiQgBSAYIBogCSAPIAyUkyIJlCAbIAogDCANlJMiCpSSIBkgCyAMIA6UkyILlJKSOAIcIAUgFCAJIBaUIAogF5SSIAsgFZSSkjgCGCAFIBAgCSASlCAKIBOUkiALIBGUkpI4AhQLIAdB4MwAaiQAIAgLjRIDDn8Bfgt9IwBB4ABrIgMkACAAQQA2AvgCIABCBDcC7AIgACAAQbwCaiIFNgLoAiAAIABBnAJqNgLkAiAAIABB/AFqNgLgAiAAIABB3AFqNgLcAiAAIAEpAgA3AgAgACABKQIQNwIQIAAgASkCCDcCCCAAIAEpAiA3AiAgACABKQIYNwIYIAAgASkCMDcCMCAAIAEpAig3AiggAEFAayABQUBrKQIANwIAIAAgASkCODcCOCAAIAEpAlA3AlAgACABKQJINwJIIAAgASkCYDcCYCAAIAEpAlg3AlggACABKQJoNwJoIAAgASkCcDcCcCABKQJ4IREgAEEANgK0ASAAQQA2ApABIAAgETcCeCAAIAIpAgg3AogBIAAgAikCADcCgAEgAEGAAWohCQJAIAAqAoABIhIgEpQgACoChAEiFSAVlJIgACoCiAEiFiAWlJIiE0MAAAAAXkEBc0UEQCADIBaMOAIoIAMgFYw4AiQgAyASjDgCIAwBCyADQQA2AiggA0KAgID8AzcDIAsgA0EANgIsIABBAzYC7AIgAEEANgKkASAAQQE2ArQBIAAgBTYClAEgACADQSBqIAUQRSAAQYCAgPwDNgKkASAJIAAoApQBIgEpAhA3AgAgCSABKQIYNwIIIAMgASkCGDcDWCADIAEpAhA3A1AgAyABKQIYNwNIIAMgASkCEDcDQCADIAEpAhg3AzggAyABKQIQNwMwIAMgASkCGDcDKCADIAEpAhA3AyAgACoCiAEhEiAAKgKEASEVIAAqAoABIRYgACgC8AIhBQJAAkACQANAIBYgFpQgFSAVlJIgEiASlJKRIhdDF7fROF1BAXNFBEAgAEEBNgL4AgwCCyADQQA2AhwgAyASjDgCGCADIBWMOAIUIAMgFow4AhAgACAFQSRsaiICQZQBaiIBIAIoArQBIgRBAnRqIgdBADYCECAAIAAoAuwCQX9qIgY2AuwCIAcgACAGQQJ0aigC3AIiBzYCACACIARBAWo2ArQBIAAgA0EQaiAHEEUCQCACKAK0ASIHQQJ0IAFqQXxqKAIAIgQqAhAiEiADKgIgkyIVIBWUIAQqAhQiFSADKgIkkyIWIBaUkiAEKgIYIhYgAyoCKJMiFCAUlJJDF7fROF0NACASIAMqAjCTIhQgFJQgFSADKgI0kyIUIBSUkiAWIAMqAjiTIhQgFJSSQxe30ThdQQFzRQ0AIBIgAyoCQJMiFCAUlCAVIAMqAkSTIhQgFJSSIBYgAyoCSJMiFCAUlJJDF7fROF0NACASIAMqAlCTIhQgFJQgFSADKgJUkyIUIBSUkiAWIAMqAliTIhQgFJSSQxe30ThdDQAgA0EgaiALQQFqQQNxIgtBBHRqIgYgBCkCGDcCCCAGIAQpAhA3AgAgFyAAKgKAASASlCAAKgKEASAVlJIgACoCiAEgFpSSIBeVIhIgGCASIBheGyIYkyAXQxe30biUkkMAAAAAX0EBc0UEQCAAIAAoAvACIgVBJGxqIgEiAkG0AWogAigCtAFBf2oiAjYCACABIAJBAnRqKAKUASEBIAAgACgC7AIiAkEBajYC7AIgACACQQJ0aiABNgLcAgwDCyADQQA2AgwCQAJAAkAgB0F+aiIEQQJLDQACQAJAAkAgBEEBaw4CAQIACyACKAKYASIEKgIQIhogASgCACIBKgIQIhKTIhcgF5QgBCoCFCIbIAEqAhQiFZMiFCAUlJIgBCoCGCIcIAEqAhgiFpMiGSAZlJIiE0MAAAAAXkEBcw0DIBIgF5QgFSAUlJIgFiAZlJKMIBOVIhNDAACAP2BBAXNFBEAgA0KAgICAgICAwD83AxAgA0ECNgIMIBogGpQgGyAblJIgHCAclJIhEwwDCyATQwAAAABfQQFzRQRAIANCgICA/AM3AxAgA0EBNgIMIBIgEpQgFSAVlJIgFiAWlJIhEwwDCyADQQM2AgwgAyATOAIUIANDAACAPyATkzgCECAWIBkgE5SSIhYgFpQgEiAXIBOUkiISIBKUIBUgFCATlJIiEyATlJKSIRMMAgsgASgCAEEQaiACKAKYAUEQaiACKAKcAUEQaiADQRBqIANBDGoQywQhEwwBCyABKAIAQRBqIAIoApgBQRBqIAIoApwBQRBqIAIoAqABQRBqIANBEGogA0EMahDgDSETCyATQwAAAABgQQFzDQBBACEBIABBASAFayIFQSRsaiIMIgRBtAFqQQA2AgAgCUIANwIIIAlCADcCACAAIAU2AvACQwAAAAAhEiADKAIMIQdDAAAAACEVQwAAAAAhFiACKAK0ASINRQ0BA0AgAiABQQJ0IghqIg5BlAFqKAIAIQYCQCAHIAF2QQFxBEAgDCAEKAK0ASIPQQJ0aiIQIAY2ApQBIANBEGogCGooAgAhBiAEIA9BAWo2ArQBIBAgBjYCpAEgDigClAEiCCoCGCEXIAgqAhQhFSAAIAgqAhAgBr4iEpQgACoCgAGSIhY4AoABIAAgFSASlCAAKgKEAZIiFTgChAEgACAXIBKUIAAqAogBkiISOAKIAQwBCyAAIAAoAuwCIghBAWo2AuwCIAAgCEECdGogBjYC3AILIA0gAUEBaiIBRw0ACwwBCyAAIAAoAvACIgVBJGxqIgEiAkG0AWogAigCtAFBf2oiAjYCACABIAJBAnRqKAKUASEBIAAgACgC7AIiAkEBajYC7AIgACACQQJ0aiABNgLcAgwDCyAHQQ9GBEAgAEEBNgL4AgsgCkH/AEYEQEECIQEgAEECNgL4AiAAIAAgBUEkbGpBlAFqNgL0AgwFCyAKQQFqIQogACgC+AIiAUUNAQwDCwsgACAAKALwAiIFQSRsaiIBIgJBtAFqIAIoArQBQX9qIgI2AgAgASACQQJ0aigClAEhASAAIAAoAuwCIgJBAWo2AuwCIAAgAkECdGogATYC3AILIAAoAvgCIQELIAAgACAFQSRsakGUAWo2AvQCIAFBAUsNACABQQFrBEAgACAAKgKAASITIBOUIAAqAoQBIhMgE5SSIAAqAogBIhMgE5SSkTgCkAFBACEBDAELIABBADYCkAFBASEBCyADQeAAaiQAIAELQgEBfyMAQRBrIgEkACABIAA2AgwgASgCDCIABEBB7PcBQez3ASgCAEEBajYCACAAQZDSASgCABEAAAsgAUEQaiQAC+oHASZ9IAAgACgCkAEgAUGcAmxqIgAgAhCvASAAQQA2AogBIABBADYCeCAAQQA2AmggACoCRCEOIAAqAkghDyAAKgJMIRAgACoC7AFDAAAAv5QiCRAcIQMgCRAdIQogACoCOCEVIAAqAjQhCSAAKgI8IQYgACAPIAMgECAQlCAPIA+UIA4gDpSSkpGVIgOUIhIgECADlCIMQwAAAEAgCiAKlCAMIAyUIA4gA5QiAyADlCASIBKUkpKSlSIRlCIHlCILIAogAyARlCIWlCITkiIdQwAAgD8gACoC6AFDAAAAP5QiCBAcIAkgCZQgFSAVlJIgBiAGlJKRlSIFIAmMlCIEIARDAAAAQCAIEB0iCCAIlCAFIAaMlCIXIBeUIAQgBJQgBSAVjCIclCIFIAWUkpKSlSINlCIYlCIfIAUgBSANlCIblCIgkpMiGpQgBCAXIA2UIg2UIiEgCCAblCIikyIUIAMgEiARlCIRlCIZIAogB5QiI5MiHpQgBSANlCIkIAggGJQiJZIiBUMAAIA/IAMgFpQiGCAMIAeUIiaSkyIMlJKSIhYgHJQgCSADIAeUIicgCiARlCIokyIKIBqUIAUgGSAjkiIDlCAUQwAAgD8gEiARlCIZICaSkyISlJKSIgeUkyAGIBQgJyAokiIRlCAFIAsgE5MiBZSSIBpDAACAPyAYIBmSkyIalJIiFJSTOAKEASAAIBUgDpQgCSAPlJMiC0MAAIA/IAsgC5QgBiAPlCAVIBCUkyILIAuUIAkgEJQgBiAOlJMiEyATlJKSkZUiGJQiGSAUlCALIBiUIgsgB5QgEyAYlCITIBaUkpI4AoABIAAgECAUlCAOIAeUIA8gFpSSkjgCfCAAICQgJZMiByAdlCAEIBuUIhsgCCANlCIUkiIEIB6UQwAAgD8gHyAXIA2UIhaSkyIIIAyUkpIiFyAclCAJIAcgCpQgAyAIlCAEIBKUkpIiDZSTIAYgBCARlCAFIAiUkiAHIBqUkiIElJM4AnQgACAZIASUIAsgDZQgEyAXlJKSOAJwIAAgECAElCAOIA2UIA8gF5SSkjgCbCAAICEgIpIiBCAdlEMAAIA/ICAgFpKTIgggHpQgGyAUkyIHIAyUkpIiDCAclCAJIAQgCpQgByADlCAIIBKUkpIiCpSTIAYgCCARlCAHIAWUkiAEIBqUkiIDlJM4AmQgACAZIAOUIAsgCpQgEyAMlJKSOAJgIAAgECADlCAOIAqUIA8gDJSSkjgCXCAAQQA2ApgBIAAgBiAAKgIgIgaUIAAqAiySOAKUASAAIBUgBpQgACoCKJI4ApABIAAgACoCJCAJIAaUkjgCjAEL4AQCAX8HfSACIAIqAngiBCACKgJkIgUgAioCcCAFIAIqAnSUkyACKgIQIgYgACoCQJQgAioCFCIHIAAqAkSUkiACKgIYIgkgACoCSJSSIAIqAgAgACoCUJQgAioCBCAAKgJUlJIgAioCCCAAKgJYlJKSIAIqAmwiCJSTIAggAioCMCABKgJAlCACKgI0IAEqAkSUkiACKgI4IAEqAkiUkiACKgIgIAEqAlCUIAIqAiQgASoCVJSSIAIqAiggASoCWJSSkpSTIgiSIgogCiAEXSIDGzgCZCAEIAWTIAggAxshBCAAKALwAQRAIAAgACoCcCAEIAYgACoCgAGUlJQgACoCQJI4AkAgACAEIAcgACoChAGUlCAAKgJ0lCAAKgJEkjgCRCAAIAQgCSAAKgKIAZSUIAAqAniUIAAqAkiSOAJIIAIqAkghBSACKgJEIQYgACAEIAAqAmCUIAIqAkCUIAAqAlCSOAJQIAAqAmghByAAIAYgBCAAKgJklJQgACoCVJI4AlQgACAFIAQgB5SUIAAqAliSOAJYCyABKALwAQRAIAIqAjghBSACKgI0IQYgASABKgJwIAQgAioCMCABKgKAAZSUlCABKgJAkjgCQCABIAQgBiABKgKEAZSUIAEqAnSUIAEqAkSSOAJEIAEgBCAFIAEqAogBlJQgASoCeJQgASoCSJI4AkggAioCWCEFIAIqAlQhBiABIAQgASoCYJQgAioCUJQgASoCUJI4AlAgASoCaCEHIAEgBiAEIAEqAmSUlCABKgJUkjgCVCABIAUgBCAHlJQgASoCWJI4AlgLC7oCAQ59IAAqAqgEIgMgASoCACIElCAAKgK4BCIFIAEqAgQiBpSSIAAqAsgEIgcgASoCCCIIlJIgACoC7AQiCiACKgIAlCAAKgL8BCILIAIqAgSUkiAAKgKMBSIJIAIqAgiUkiIMlCADIAEqAhAiDZQgBSABKgIUIg6UkiAHIAEqAhgiD5SSIAogAioCEJQgCyACKgIUlJIgCSACKgIYlJIiEJSSIAMgASoCICIDlCAFIAEqAiQiBZSSIAcgASoCKCIHlJIgCiACKgIglCALIAIqAiSUkiAJIAIqAiiUkiIJlJIgBCAAKgKsBCIElCAGIAAqArwEIgaUkiAIIAAqAswEIgiUkiAMlCANIASUIA4gBpSSIA8gCJSSIBCUkiADIASUIAUgBpSSIAcgCJSSIAmUkhBBIAAqAtwFlAvbKAICf0t9IwBB0ABrIgUkACAAQQA7AI0EIABCADcC9AMCQAJAIAAtAKgERQ0AIAAtAI8EDQAgAioCNCFMIAIqAjghTSAAKgKcAyEfIAAqAqADIRIgACoCpAMhHCABKgI0IU4gASoCOCFPIAAqAtwCIRYgACoC4AIhGyAAKgLkAiEiIAIqAhQhDCACKgIYIQ8gASoCFCETIAEqAhghDiAAKgK0AiEkIAAqAsQCISYgACoC1AIhJyAAKgK8AiEoIAAqAswCISkgACoCsAIhKiABKgIkIQogACoCwAIhKyABKgIoIQsgACoC0AIhLCAAKgL0AiEtIAAqAoQDIS4gACoClAMhLyAAKgLwAiEwIAAqAoADITggACoCkAMhOSAAKgK4BCEIIAAqArQEIRcgACoCsAQhCSACKgIkISAgACoC/AIhOiACKgIoISEgACoCjAMhOyACKgIwIVAgAioCCCEaIAIqAgQhFCACKgIAIRUgASoCMCFRIAEqAgghESABKgIAIRggASoCBCEdIAIqAhAhHiABKgIQIRkgACoCrAIhPCABKgIgIQ0gACoCrAQhByACKgIgIRAgACoC7AIhPSAFQQA2AkwgBUEANgI8IAVBADYCLCAFICQgDZQgJiAKlJIgJyALlJIiPkMAAIA/IAcgB0MAAABAIAcgB5QgCSAJlJIgFyAXlJIgCCAIlJKVIiOUIjGUIjIgCSAJICOUIiWUIjOSkyJDIC0gEJQgLiAglJIgLyAhlJIiP5QgByAXICOUIiOUIjQgCCAllCI1kiJEID0gEJQgOiAglJIgOyAhlJIiQJQgCSAjlCI2IAggMZQiN5MiRSAwIBCUIDggIJSSIDkgIZSSIgmUkpIiMZQgPCANlCAoIAqUkiApIAuUkiJBIDQgNZMiRiA/lEMAAIA/IDMgFyAjlCIXkpMiRyBAlCAHICWUIiUgCCAjlCIjkiJIIAmUkpIiB5QgKiANlCArIAqUkiAsIAuUkiIIIDYgN5IiSSA/lCAlICOTIkogQJRDAACAPyAyIBeSkyJLIAmUkpIiF5SSkjgCOCAFICQgGZQgJiATlJIgJyAOlJIiIyAxlCA8IBmUICggE5SSICkgDpSSIiUgB5QgKiAZlCArIBOUkiAsIA6UkiIyIBeUkpI4AjQgBSA+IEMgLSAelCAuIAyUkiAvIA+UkiIzlCBEID0gHpQgOiAMlJIgOyAPlJIiNJQgRSAwIB6UIDggDJSSIDkgD5SSIjWUkpIiNpQgQSBGIDOUIEcgNJQgSCA1lJKSIjeUIAggSSAzlCBKIDSUIEsgNZSSkiJClJKSOAIoIAUgIyA2lCAlIDeUIDIgQpSSkjgCJCAFICMgTiAZIBaUIBMgG5SSIA4gIpSSkowiGZQgGCAklCAdICaUkiARICeUkiITIFEgGCAWlCAdIBuUkiARICKUkpIiJJSTID4gTyANIBaUIAogG5SSIAsgIpSSkiILlJMiDSAxlCAlIBmUIDwgGJQgKCAdlJIgKSARlJIiDiAklJMgQSALlJMiFiAHlCAyIBmUIBggKpQgHSArlJIgESAslJIiCiAklJMgCCALlJMiESAXlJKSID9DAAAAAJQgQEMAAAAAlCAJQwAAAACUkpIgTSAQIB+UICAgEpSSICEgHJSSkpKSOAJIIAUgDSA2lCAWIDeUIBEgQpSSkiAzQwAAAACUIDRDAAAAAJQgNUMAAAAAlJKSIEwgHiAflCAMIBKUkiAPIByUkpKSkjgCRCAFQQA2AhwgBSATIDGUIA4gB5QgCiAXlJKSOAIwIAUgEyA2lCAOIDeUIAogQpSSkjgCICAFID4gRCA9IBWUIDogFJSSIDsgGpSSIgeUIEUgFSAwlCAUIDiUkiAaIDmUkiIJlJIgQyAVIC2UIBQgLpSSIBogL5SSIgyUkiIPlCBBIEcgB5QgSCAJlJIgRiAMlJIiC5QgCCBKIAeUIEsgCZSSIEkgDJSSIgiUkpI4AhggBSAjIA+UICUgC5QgMiAIlJKSOAIUIAUgEyAPlCAOIAuUIAogCJSSkjgCECAFIA0gD5QgFiALlCARIAiUkpIgB0MAAAAAlCAJQwAAAACUkiAMQwAAAACUkiBQIBUgH5QgFCASlJIgGiAclJKSkpI4AkAgBUEQaiAFECYgBSoCACIHIAeUIAUqAgQiCCAIlJIgBSoCCCIJIAmUkiIMi0MAAAA0XQ0BIABBADYC2AMgAEMAAIA/IAyRlSIMIAmUOALUAyAAIAwgCJQ4AtADIAAgDCAHlDgCzAMgACAFKgIMQwAAgL+XQwAAgD+WEDoiByAHkiIHOAL4AyAHi0MAAAA0XQ0BIABBAToAjgQMAQsgASAFQRBqECYgAEGsAmogBRAmIAUqAhghByAFKgIIIQggBSoCBCEOIAUqAhQhCiAFKgIMIQsgBSoCHCEaIAUqAhAhFCAFKgIAIRUgAiAFQRBqECYgAEHsAmogBRAmQwAAAIAhGUMAAIA/IR0gFSAHlCALIAqUIBogDpSSkiAUIAiUkyIXIAUqAhwiESAFKgIIIhiUIAUqAgwiDSAFKgIYIhCUkiAFKgIQIh8gBSoCBCISlJIgBSoCACIcIAUqAhQiFpSTIgyUIBogFZQgFCALlJIgCiAIlJIgByAOlJMiICARIA2UIBwgH5STIBYgEpSTIBggEJSTIg+UIBogC5QgFSAUlJMgCiAOlJMgCCAHlJMiISARIByUIB8gDZSSIBYgGJSSIBAgEpSTIhOUkyAaIAiUIAsgB5SSIBQgDpSSIBUgCpSTIhogHCAQlCANIBaUIBEgEpSSkiAfIBiUkyIOlJOSIhQgICAOlCAaIA+UICEgDJSTIBcgE5STkiIVIBogDJQgICATlCAhIA+UkiAXIA6UkpIiEUMAAAAAlCIIkiAUQwAAAACUIgqTIgeUIBEgCCAKkiAaIBOUIBcgD5QgISAOlJMgICAMlJOSIhiTIgiUIBUgFIwgGEMAAAAAlCILkyAVQwAAAACUIg2TIgqUkyAYIBEgC5IgDZMiC5STkiINQwAAgD8gDSANlCAYIAiUIBEgC5QgFCAKlJMgFSAHlJOSIg0gDZQgFSALlCARIAeUIBggCpSTIBQgCJSTkiIHIAeUkpKRlSIIlCIKQwAAAACUIhAgByAIlCIHQwAAAACUIh8gDSAIlCILkpIiCEP+/3+/XUUEQCAHIAtDAAAAAJQiC5NDAACAPyAIQwAAgD+SIgcgB5KRIgiVIgeUIQkgECAfkyAHlCEZIAhDAAAAP5QhHiALIAqTIAeUIR0LIB1DAACAPyAZIBmUIB0gHZSSIAkgCZSSIB4gHpSSkZUiB5QhHSAeIAeUIR8gCSAHlCEeIBkgB5QhGQJAAkAgACoCvAMiCCAAKgLIAyISYCIGQQFzDQAgACoCwAMiDSASYEEBcw0AAn1DAAAAACAfQwAAgL+XQwAAgD+WEDoiCiAKkiIQQwAAADReQQFzDQAaIB5DAACAPyAeIB6UIBkgGZQgHSAdlJKSkZUiB5QhCyAZIAeUIQkgCCAdIAeUIgqLQwAAADReQQFzDQAaIAsgC5QgCiAKlJUiB0MAAIA/kiAHIAggCJSVQwAAgD8gDSANlJWSlZELIQcgECAHIAAqAqwDIhuUIhJeQQFzDQEgAEEBOgCOBCAQIBKTIRxDAACAPyEWAkAgECAHXUEBcw0AIBtD/v9/P11BAXMNACAcIAcgEpOVIRYLIAAgHDgC+AMgACAWOAKQBCAKi0MAAAA0XkEBc0UEQEMAAIA/IAkgCZQgCiAKlJIgCiANIAiVIAuMIAqVlJSLIgcgB4wgC0MAAAAAXRsiByAHlJKRlSIIIAeMlCELIAogCJQhCiAJIAiUIQkLIABCADcCmAQgAEEANgLYAyAAQgA3AqAEIAAgEyAPIAqMIgeUIAwgCZSTIBMgC5SSIg2UIA8gDiAJlCATIAeUIA8gC5STkiIQlCAMIBMgCZQgDiAKlJIgDCALlJIiEpSTIA4gDCAKlCAOIAuMlCAPIAmUk5IiCZSTkiIHOALUAyAAIAwgCZQgDyANlCAOIBKUkyATIBCUk5IiCDgC0AMgACAOIBCUIA8gCZQgEyASlJMgDCANlJOSIgk4AswDIABDAACAPyAJIAkgAyoCAJQgAyoCECAIlJIgAyoCICAHlJKUIAggCSADKgIElCAIIAMqAhSUkiAHIAMqAiSUkpSSIAcgCSADKgIIlCAIIAMqAhiUkiAHIAMqAiiUkpSSIAkgCSAEKgIAlCAIIAQqAhCUkiAHIAQqAiCUkpQgCCAJIAQqAgSUIAggBCoCFJSSIAcgBCoCJJSSlJIgByAJIAQqAgiUIAggBCoCGJSSIAcgBCoCKJSSlJKSlTgC7AMMAQsgASoCACIKIAAqArQCIgeUIAEqAgQiHCAAKgLEAiIJlJIgASoCCCIWIAAqAtQCIhCUkiIsIAAqAuwCIhsgAioCAJQgACoC/AIiIiACKgIElJIgACoCjAMiJCACKgIIlJIiC5QgASoCECImIAeUIAEqAhQiJyAJlJIgASoCGCIoIBCUkiItIBsgAioCEJQgIiACKgIUlJIgJCACKgIYlJIiDZSSIAEqAiAiKSAHlCABKgIkIiogCZSSIAEqAigiKyAQlJIiLiAbIAIqAiCUICIgAioCJJSSICQgAioCKJSSIhCUkiEHIAogACoCsAIiCZQgHCAAKgLAAiIblJIgFiAAKgLQAiIilJIiJCALlCAmIAmUICcgG5SSICggIpSSIi8gDZSSICkgCZQgKiAblJIgKyAilJIiMCAQlJIhCSAAKgKsAiIbIAqUIAAqArwCIgogHJSSIAAqAswCIiIgFpSSIhwgC5QgGyAmlCAKICeUkiAiICiUkiIWIA2UkiAbICmUIAogKpSSICIgK5SSIhsgEJSSIQoCQCAIIBJdQQFzRQRAIAAqAsADIgggEl1BAXNFBEAgCYtDAAAANF1BAXNFQQAgB4tDAAAANF0bDQMgAEEBOgCOBCAAQQA2AtgDIAAgFiALlCAcIA2Uk4w4AtQDIAAgHCAQlCAbIAuUk4w4AtADIAAgGyANlCAWIBCUk4w4AswDDAMLIAqLQwAAADRdQQFzRUEAIAeLQwAAADRdGw0BIABBAToAjgQgCCASYEEBcw0BIAcgChBBIhIgCF5BAXNFBEBDAAAAACEJIAgQHCEHIAgQHSEKDAILQwAAAAAhCSASIAiMXUEBcw0BIAgQHIwhByAIEB0hCgwBCyAKi0MAAAA0XUEBc0VBACAJi0MAAAA0XRsNACAAQQE6AI4EIAZBAXMNAAJ9IAkgChBBIhIgCF5BAXNFBEBDAAAAACEHIAgQHAwBC0MAAAAAIQcgEiAIjF1BAXMNASAIEByMCyEJIAgQHSEKCyAAQQA2AtgDIAAgDSAuIAeUIDAgCZQgGyAKlJKSIghDAACAPyAIIAiUICwgB5QgJCAJlCAcIAqUkpIiCCAIlCAtIAeUIC8gCZQgFiAKlJKSIgcgB5SSkpGVIgmUIgqUIBAgByAJlCISlJMiByAHlCAQIAggCZQiCZQgCyAKlJMiCCAIlJIgCyASlCANIAmUkyIJIAmUkpEiCjgC+AMgAEMAAIA/IAqVIgogCYyUOALUAyAAIAogCIyUOALQAyAAIAogB4yUOALMAwsgACoCxAMiDUMAAAAAYEEBc0UEQCAUIB2UIBUgH5QgESAelJMgGCAZlJOSIgdDAACAPyAVIB6UIBggHZQgESAflCAUIBmUkpKSIgsgC5QgByAHlCAYIB6UIBQgH5QgESAZlJMgFSAdlJOSIgggCJQgFSAZlCAYIB+UIBEgHZSTIBQgHpSTkiIKIAqUkpKSkZUiCZQhByAKIAmUIQogCCAJlCEIIAsgCZQiCUMAAIC/l0MAAIA/lhA6IgsgC5IiC0PbD0lAXkEBc0UEQCAJjEMAAIC/l0MAAIA/lhA6IgkgCZIhCyAKjCEKIAiMIQggB4whBwsgACALOAKABCALQwAAADReQQFzRQRAIAdDAACAPyAIIAiUIAogCpSSIAcgB5SSkZUiCZQhByAKIAmUIQogCCAJlCEICyALIA0gACoCrAMiEZQiFF5BAXNFBEAgAEEBOgCNBCAAIAsgFJMiFTgC/AMgAAJ9QwAAgD8gCyANXUEBcw0AGkMAAIA/IBFD/v9/P11BAXMNABogFSANIBSTlQs4ApQEIABBADYC6AMgACATIA8gCowiCZQgDCAIlJMgEyAHlJIiFJQgDyAOIAiUIBMgCZQgDyAHlJOSIhWUIAwgEyAIlCAOIAqUkiAMIAeUkiIRlJMgDiAMIAqUIA4gB4yUIA8gCJSTkiIYlJOSIgk4AuQDIAAgDCAYlCAPIBSUIA4gEZSTIBMgFZSTkiILOALgAyAAIA4gFZQgDyAYlCATIBGUkyAMIBSUk5IiDDgC3AMgAEMAAIA/IAwgDCADKgIAlCADKgIQIAuUkiADKgIgIAmUkpQgCyAMIAMqAgSUIAsgAyoCFJSSIAkgAyoCJJSSlJIgCSAMIAMqAgiUIAsgAyoCGJSSIAkgAyoCKJSSlJIgDCAMIAQqAgCUIAsgBCoCEJSSIAkgBCoCIJSSlCALIAwgBCoCBJQgCyAEKgIUlJIgCSAEKgIklJKUkiAJIAwgBCoCCJQgCyAEKgIYlJIgCSAEKgIolJKUkpKVOALwAwsgAC0AjgRFDQEgAEEANgKkBCAAICAgISAKjCIMlCAaIAiUkyAgIAeUkiIJlCAhIBcgCJQgICAMlCAhIAeUk5IiDJQgGiAgIAiUIBcgCpSSIBogB5SSIg+UkyAXIBogCpQgFyAHjJQgISAIlJOSIgeUk5I4AqAEIAAgGiAHlCAhIAmUIBcgD5STICAgDJSTkjgCnAQgACAXIAyUICEgB5QgICAPlJMgGiAJlJOSOAKYBAwBCyAAQQA2AoAECyAFQdAAaiQAC+ERAgJ/GH0CfSAALQC0ASIERUEAIAAtADAbRQRAIAEqAjQhFiABKgI4IRQgACoCZCELIAAqAmghDCAAKgJsIQ0gASoCFCEOIAEqAhghDyAAKgJEIQcgACoCVCEFIAAqAjghESAAKgJIIQkgACoCWCEKIAAqAjwhCCABKgIkIQYgACoCTCEQIAEqAighFyAAKgJcIRIgASoCMCEVIAEqAgghGCABKgIAIRkgASoCBCEaIAEqAhAhGyAAKgI0IRMgASoCICEcIABBADYC9AYgAEEANgLkBiAAQQA2AtQGIABBADYCxAYgACAIIByUIBAgBpSSIBIgF5SSOALgBiAAIBEgHJQgCSAGlJIgCiAXlJI4AtwGIAAgEyAclCAHIAaUkiAFIBeUkjgC2AYgACAIIBuUIBAgDpSSIBIgD5SSOALQBiAAIBEgG5QgCSAOlJIgCiAPlJI4AswGIAAgEyAblCAHIA6UkiAFIA+UkjgCyAYgACAZIAiUIBogEJSSIBggEpSSOALABiAAIBkgEZQgGiAJlJIgGCAKlJI4ArwGIAAgEyAZlCAHIBqUkiAFIBiUkjgCuAYgACAUIBwgC5QgBiAMlJIgFyANlJKSOALwBiAAIBYgGyALlCAOIAyUkiAPIA2UkpI4AuwGIAAgFSAZIAuUIBogDJSSIBggDZSSkjgC6AYgAioCECIOIAAqAqQBIgeUIAIqAhQiCyAAKgKoASIFlJIgAioCGCIMIAAqAqwBIhGUkiEXIAAqAnwiCSACKgIgIg+UIAAqAowBIgogAioCJCIGlJIgACoCnAEiCCACKgIoIg2UkiEYIAAqAngiECAPlCAAKgKIASISIAaUkiAAKgKYASITIA2UkiEZIAAqAnQiFiAPlCAAKgKEASIUIAaUkiAAKgKUASIVIA2UkiEaIAkgDpQgCiALlJIgCCAMlJIhGyAQIA6UIBIgC5SSIBMgDJSSIRwgFiAOlCAUIAuUkiAVIAyUkiELIA0gEZQhDCAPIAeUIAYgBZSSIQ0gAioCACIGIAeUIAIqAgQiByAFlJIgAioCCCIFIBGUkiERIAYgCZQgByAKlJIgBSAIlJIhCCAGIBCUIAcgEpSSIAUgE5SSIQkgFiAGlCAUIAeUkiAVIAWUkgwBCyACKgI0IRYgAioCOCEUIAAqAqQBIQsgACoCqAEhDCAAKgKsASENIAIqAhQhDiACKgIYIQ8gACoChAEhByAAKgKUASEFIAAqAnghESAAKgKIASEJIAAqApgBIQogACoCfCEIIAIqAiQhBiAAKgKMASEQIAIqAighFyAAKgKcASESIAIqAjAhFSACKgIIIRggAioCACEZIAIqAgQhGiACKgIQIRsgACoCdCETIAIqAiAhHCAAQQA2AvQGIABBADYC5AYgAEEANgLUBiAAQQA2AsQGIAAgCCAclCAQIAaUkiASIBeUkjgC4AYgACARIByUIAkgBpSSIAogF5SSOALcBiAAIBMgHJQgByAGlJIgBSAXlJI4AtgGIAAgCCAblCAQIA6UkiASIA+UkjgC0AYgACARIBuUIAkgDpSSIAogD5SSOALMBiAAIBMgG5QgByAOlJIgBSAPlJI4AsgGIAAgGSAIlCAaIBCUkiAYIBKUkjgCwAYgACAZIBGUIBogCZSSIBggCpSSOAK8BiAAIBMgGZQgByAalJIgBSAYlJI4ArgGIAAgFCAcIAuUIAYgDJSSIBcgDZSSkjgC8AYgACAWIBsgC5QgDiAMlJIgDyANlJKSOALsBiAAIBUgGSALlCAaIAyUkiAYIA2UkpI4AugGIAEqAhAiDiAAKgJkIgeUIAEqAhQiCyAAKgJoIgWUkiABKgIYIgwgACoCbCIRlJIhFyAAKgI8IgkgASoCICIPlCAAKgJMIgogASoCJCIGlJIgACoCXCIIIAEqAigiDZSSIRggACoCOCIQIA+UIAAqAkgiEiAGlJIgACoCWCITIA2UkiEZIAAqAjQiFiAPlCAAKgJEIhQgBpSSIAAqAlQiFSANlJIhGiAJIA6UIAogC5SSIAggDJSSIRsgECAOlCASIAuUkiATIAyUkiEcIBYgDpQgFCALlJIgFSAMlJIhCyANIBGUIQwgDyAHlCAGIAWUkiENIAEqAgAiBiAHlCABKgIEIgcgBZSSIAEqAggiBSARlJIhESAGIAmUIAcgCpSSIAUgCJSSIQggBiAQlCAHIBKUkiAFIBOUkiEJIAEhAiAWIAaUIBQgB5SSIBUgBZSSCyEFIAIqAjghFCACKgI0IRUgACACKgIwIBGSOAKoByAAQQA2AqQHIAAgGDgCoAcgACAZOAKcByAAIBo4ApgHIABBADYClAcgACAbOAKQByAAIBw4AowHIAAgCzgCiAcgAEEANgKEByAAIAg4AoAHIAAgCTgC/AYgACAFOAL4BiAAQQA2ArQHIAAgFyAVkjgCrAcgACAUIA0gDJKSOAKwByAAIAApAugGNwLIByAAIAApAvAGNwLQByAAIAApArAHNwLgByAAIAApAqgHNwLYByAAKALIBiEDIAAoAtgGIQIgACgCuAYhASAAQQA2AsQHIAAgAjYCwAcgACADNgK8ByAAIAE2ArgHIAK+IRIgA74hEyABviEWIAACfUEAIARFIAAtADAbRQRAIAAqAuAHIAAqAtAHIgmTIQUgACoC3AcgACoCzAciFJMhCiAAKgLYByAAKgLIByIVkwwBCyAAKgLQByIJIAAqAuAHkyEFIAAqAswHIhQgACoC3AeTIQogACoCyAciFSAAKgLYB5MLIgg4AvgHIABBhAhqQQA2AgAgAEGACGogBTgCACAAIAo4AvwHIABBADYC9AcgACAIIBaUIAogE5SSIAUgEpSSIhA4AogIIAAgCSAQIBKUkjgC8AcgACAUIBAgE5SSOALsByAAIBUgECAWlJI4AugHIABBjAhqIAggACoCvAaUIAogACoCzAaUkiAFIAAqAtwGlJI4AgAgAEGQCGogCCAAKgLABpQgCiAAKgLQBpSSIAUgACoC4AaUkjgCAAtpAQF/IwBBEGsiACQAAkBBiOABLQAAQQFxDQBBiOABEBBFDQAgAEIANwMIIABCADcDAEGg2wEgABD5BEGI4AEQDwsgAEIANwMIIABCADcDAEGg2wFDAAAAACAAEN0CIABBEGokAEGg2wELXAAgACACNgIcIABBfzYCGCAAQQE7ARQgAEH////7BzYCECAAQn83AgggAEGQwQA2AgAgACABNgIEENUCGiAAQQA2AiwgAEKAgICAoLPmzD43AiQgAEGg2wE2AiALzQ0CCn8TfSMAQRBrIg4kACAIKAIYIQ8gASgCOCEQAkAgAS0ALCIVRQRAIBBFDQELIAhBFEEQIAsbaigCACENIAhBDEEIIAsbaigCACIRIAkgD2wiCUECdCITaiAKKAIANgIAIBEgCUEBaiIPQQJ0IhRqIAooAgQ2AgAgESAJQQJqIhJBAnQiFmogCigCCDYCACANIBNqIAoqAgCMOAIAIA0gFGogCioCBIw4AgAgDSAWaiAKKgIIjDgCAAJAIAsNACAALQCVCgRAIABB2AhqKgIAIRkgAioCNCEbIABB3AhqKgIAIR4gAioCOCEfIABB4AhqKgIAISAgAEGYCWoqAgAhISADKgI0ISUgAEGcCWoqAgAhJiADKgI4IScgAEGgCWoqAgAhIiAAKgL8CSEdIAAqAvgJIRwgASoCMCEjIAEqAjQhKCACKgIwISQgCioCACEXIAMqAjAhKSAKKgIEIRggCioCCCEaIA5BADYCDCAOIBggGSAkkyIZIBcgFyAZlCAYIB4gG5MiJJSSIBogICAfkyIflJIiGZQiG5MgHCAbIBcgKCAjkyIblJIgFyAXICEgKZMiIJQgGCAmICWTIiGUkiAaICIgJ5MiJZSSIh6UIiaTIieUkiIilCAXICQgGCAZlCIjkyAcICMgGCAblJIgGCAelCIjkyIolJIiJJSTIik4AgggDiAXIB8gGiAZlCIZkyAcIBkgGiAblJIgGiAelCIbkyIelJIiGZQgGiAilJMiHzgCBCAOIBogJJQgGCAZlJMiIjgCACAYICAgJpMgHSAnlJMiIJQgFyAhICOTIB0gKJSTIiGUkyEZIBcgJSAbkyAdIB6UkyIblCAaICCUkyEXIBogIZQgGCAblJMhGAJAIAwNACAALQCACkUNACAOIBwgKZQ4AgggDiAcIB+UOAIEIA4gHCAilDgCACAdIBmUIRkgHSAXlCEXIB0gGJQhGAsgCUECdCICIAgoAgxqIgMgDikDADcCACADIA4oAgg2AgggAiAIKAIUIgJqIBiMOAIAIAIgD0ECdGogF4w4AgAgAiASQQJ0aiAZjDgCAAwBCyAAQZgJaiINKgIAIRggAioCMCEaIAoqAgAhFyAIKAIMIgwgCUECdCIRaiAAQZwJaiITKgIAIAIqAjSTIh0gCioCCCIclCAAQaAJaiIUKgIAIAIqAjiTIhkgCioCBCIblJM4AgAgDCAPQQJ0Ig9qIBkgF5QgHCAYIBqTIhiUkzgCACAMIBJBAnQiEmogGCAblCAdIBeUkzgCACANKgIAIRggAyoCMCEaIAoqAgAhFyAIKAIUIgIgEWogEyoCACADKgI0kyIdIAoqAggiHJQgFCoCACADKgI4kyIZIAoqAgQiG5STjDgCACACIA9qIBkgF5QgHCAYIBqTIhiUk4w4AgAgAiASaiAYIBuUIB0gF5STjDgCAAsCfQJAIBAEQCABKgIEIRcgASoCACEYIAgoAhwgCUECdGoiAEEANgIAAkAgFUUNACAYIBdbDQAgCCgCICAJQQJ0aiABKAIcNgIACyAIKgIAIAEqAiCUIRcgASoCMCEYIAsNASAXIBiUIAAqAgCSDAILIAlBAnQiAiAIKAIcakEANgIAQQEhDSAVRQ0CIAgoAiAgAmogASgCHDYCACABKgI0IAEqAgAgASoCBCABKgIIIhcgF4wgCxsgCCoCACABKgIglBCxASEXIAgoAhwgAmoiACAXIAEqAgiUIAAqAgCSOAIAIAgoAiQgAmogASoCDIw4AgAgCCgCKCACaiABKAIMNgIADAILIAAqAgAgFyAYlJMLIRcgACAXOAIAIAlBAnQiAiAIKAIgaiABKAIkNgIAIAEqAgAgASoCBFsEQCAIKAIkIAJqQf///3s2AgAgCCgCKCACakH////7BzYCAEEBIQ0MAQtBASENIAgoAiQgAmpDAAAAAEP//3//IBBBAUYiAxs4AgAgCCgCKCACakP//39/QwAAAAAgAxs4AgAgASoCKCIaQwAAAABeQQFzDQACfSALBEAgBioCCCAKKgIIIhyUIRkgBioCACAKKgIAIhiUIAYqAgQgCioCBCIXlJIMAQsgBCoCCCAKKgIIIhyUIRkgBSEHIAQqAgAgCioCACIYlCAEKgIEIAoqAgQiF5SSCyAZkiAYIAcqAgCUIBcgByoCBJSSIBwgByoCCJSSkyEXIBBBAUYEQCAXQwAAAABdQQFzDQEgFyAajJQiFyAAKgIAXkEBcw0BIAAgFzgCAAwBCyAXQwAAAABeQQFzDQAgFyAajJQiFyAAKgIAXUEBcw0AIAAgFzgCAAsgDkEQaiQAIA0LlQQCAX8VfSAAKAIgIgMqAiQhCCADKgIUIQkgAyoCKCEMIAMqAhghCiADKgIIIQsgAyoCLCENIAMqAhwhBiADKgIMIREgACgCHCIAKgIkIRAgACoCFCESIAAqAighDiAAKgIIIRMgACoCGCEUIAAqAiwhDyAAKgIMIRUgACoCHCEWIAMqAgQhFyAAKgIEIRggAUIANwIIIAFCADcCACACKgIIIQUgAioCACEEIAIqAgQhByABQQA2AhwgASAVIASUIBYgB5SSIA8gBZSSIg84AhggASATIASUIBQgB5SSIA4gBZSSIg44AhQgASAYIASUIBIgB5SSIBAgBZSSIgc4AhAgAioCCCEFIAIqAgQhECACKgIAIQQgAUEANgIsIAEgBiAQjCIGlCARIASUkyANIAWUkyINOAIoIAEgCiAGlCALIASUkyAMIAWUkyIMOAIkIAEgCSAGlCAXIASUkyAIIAWUkyIFOAIgIAAqApADIQQgACoClAMhBiAAKgKMAyEIIAFBADYCPCABIA8gBpQiBjgCOCABIA4gBJQiBDgCNCABIAcgCJQiCDgCMCADKgKQAyEJIAMqApQDIQogAyoCjAMhCyABQQA2AkwgASANIAqUIgo4AkggASAMIAmUIgk4AkQgASAFIAuUIgs4AkAgASAHIAiUIA4gBJSSIA8gBpSSIAUgC5QgDCAJlJIgDSAKlJKSOAJQC+cDAgN/Bn0jAEGAAWsiBSQAIAUgACgCHCIGKAIENgJQIAUgBigCFDYCVCAGKAIkIQcgBUEANgJcIAUgBzYCWCAFIAYoAgg2AmAgBSAGKAIYNgJkIAYoAighByAFQQA2AmwgBSAHNgJoIAUgBigCDDYCcCAFIAYoAhw2AnQgBigCLCEHIAVBADYCfCAFIAc2AnggBSAAKAIgIgAoAgQ2AiAgBSAAKAIUNgIkIAAoAiQhByAFQQA2AiwgBSAHNgIoIAUgACgCCDYCMCAFIAAoAhg2AjQgACgCKCEHIAVBADYCPCAFIAc2AjggBSAAKAIMNgJAIAUgACgCHDYCRCAAKAIsIQcgBUEANgJMIAUgBzYCSCAGKgI0IQggBioCOCEJIAYqAjwhCiADKgIAIQsgAyoCBCEMIAMqAgghDSAFQQA2AhwgBSANIAqTOAIYIAUgDCAJkzgCFCAFIAsgCJM4AhAgACoCNCEIIAAqAjghCSAAKgI8IQogBCoCACELIAQqAgQhDCAEKgIIIQ0gBUEANgIMIAUgDSAKkzgCCCAFIAwgCZM4AgQgBSALIAiTOAIAIAEgBUHQAGogBUEgaiAFQRBqIAUgAiAGQYwDaiAGKgLYAiAAQYwDaiAAKgLYAhDsASAFQYABaiQACxcAIAAgACgCHEEEaiAAKAIgQQRqELIBC40FAQF/IABB9DY2AgAgAC0AkAIEQCAAKALMASIBIAEoAgAoAgARAQAaIAAoAswBIgEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgACgCxAEiAQRAIAEgASgCACgCABEBABogACgCxAEiAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAALQCRAgRAIAAoAsgBIgEgASgCACgCABEBABogACgCyAEiAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAKAK8AiIBBEAgAC0AwAIEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYCvAILIABBADYCvAIgAEIANwK0AiAAQQE6AMACIAAoAqACIgEEQCAALQCkAgRAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgKgAgsgAEEANgKgAiAAQgA3ApgCIABBAToApAIgACgC8AEiAQRAIAAtAPQBBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AvABCyAAQQA2AvABIABCADcC6AEgAEEBOgD0ASAAKALcASIBBEAgAC0A4AEEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYC3AELIABBADYC3AEgAEIANwLUASAAQQE6AOABIAAoArwBIgEEQCAALQDAAQRAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgK8AQsgAEEANgK8ASAAQgA3ArQBIABBAToAwAEgABDDAhogAAu4AgACQCAALQDMAUECcQRAIAAgACkCBDcCRCAAIAApAgw3AkwgACAAKQIUNwJUIAAgACkCHDcCXCAAIAApAiQ3AmQgACAAKQIsNwJsIAAgACkCNDcCdCAAIAApAjw3AnwMAQsgACABKQIANwJEIAAgASkCCDcCTCAAIAEpAhg3AlwgACABKQIQNwJUIAAgASkCIDcCZCAAIAEpAig3AmwgACABKQI4NwJ8IAAgASkCMDcCdAsgACAAKQLIAjcClAEgACAAKQK4AjcChAEgACAAKQLQAjcCnAEgACAAKQLAAjcCjAEgACABKQIINwIMIAAgASkCADcCBCAAIAEpAhg3AhwgACABKQIQNwIUIAAgASkCKDcCLCAAIAEpAiA3AiQgACABKQI4NwI8IAAgASkCMDcCNCAAEN4CC6ECAgF/A30gACgCzAEhAwJAIAFDAAAAAFsEQCAAIANBAXI2AswBDAELIAAgA0F+cTYCzAFDAACAPyABlSEECyAAIAQ4AtgCIABBADYC+AIgACAAKgL8AiABlDgC7AIgACAAKgKEAyABlDgC9AIgACAAKgKAAyABlDgC8AIgAioCCCEBIAIqAgQhBSACKgIAIQYgACAAKgLcAiAElDgCsAQgACAEIAAqAuAClDgCtAQgACAEIAAqAuQClDgCuAQgAEEANgK8BCAAQQA2ApgDIABDAACAPyAGlUMAAAAAIAZDAAAAAFwbOAKMAyAAQwAAgD8gBZVDAAAAACAFQwAAAABcGzgCkAMgAEMAAIA/IAGVQwAAAAAgAUMAAAAAXBs4ApQDC9cCAQ99IABBADYCtAIgAEEANgKkAiAAQQA2ApQCIAAgACoCjAMiCiAAKgIkIgGUIgIgAZQgACoCkAMiCyAAKgIoIgOUIgQgA5SSIAAqApQDIgwgACoCLCIFlCIGIAWUkjgCsAIgACACIAAqAhQiB5QgBCAAKgIYIgiUkiAGIAAqAhwiCZSSOAKsAiAAIAIgACoCBCIClCAEIAAqAggiBJSSIAYgACoCDCIGlJI4AqgCIAAgASAKIAeUIg2UIAMgCyAIlCIOlJIgBSAMIAmUIg+UkjgCoAIgACANIAeUIA4gCJSSIA8gCZSSOAKcAiAAIA0gApQgDiAElJIgDyAGlJI4ApgCIAAgASACIAqUIgGUIAMgBCALlCIDlJIgBSAGIAyUIgWUkjgCkAIgACABIAeUIAMgCJSSIAUgCZSSOAKMAiAAIAEgApQgAyAElJIgBSAGlJI4AogCC54FAQN/IwBBgAFrIgQkACAEQpCAgIDwzcTBOjcCbCAEIAE2AmggBCACNgJkIARBATYCYCAEQQA2AjwgBEFAa0EBOgAAIARBAToAXCAEQgA3AjQgBEEANgJYIARCADcDUCAEQgA3AkQgBEEANgIsIARBAToAKCAEQQE6ACQgBEEANgIgIARCADcDGCAEQQA2AgwgBEEBOgAQIARCADcCBCAEIAI2AnQgBCAEQeAAaiAEQShqEOIDGgJ/Qej3AUHo9wEoAgBBAWo2AgBB5AlBEEGM0gEoAgARAwALIAAgBCgCLCAEKAI8QQAQaiEBIAQoAkRBAEoEQANAIAQoAlggBkEMbGoiBSgCCCEAIAUoAgAiAiAFKAIEIgVIBEAgASACIAVBAEEAECMLIAUgAEgEQCABIAUgAEEAQQAQIwsgACACSARAIAEgACACQQBBABAjCyABIAIgBSAAQQAQNiAGQQFqIgYgBCgCREgNAAsLIARBKGoQ4QMgAwRAIAEQ7QILIAQoAiAiAARAIAQtACQEQCAABEBB7PcBQez3ASgCAEEBajYCACAAQZDSASgCABEAAAsLIARBADYCIAsgBEEANgIgIARBAToAJCAEQgA3AxggBCgCDCIABEAgBC0AEARAIAAEQEHs9wFB7PcBKAIAQQFqNgIAIABBkNIBKAIAEQAACwsgBEEANgIMCyAEKAJYIgAEQCAELQBcBEAgAARAQez3AUHs9wEoAgBBAWo2AgAgAEGQ0gEoAgARAAALCyAEQQA2AlgLIARBADYCWCAEQQE6AFwgBEIANwNQIAQoAjwiAARAIAQtAEAEQCAABEBB7PcBQez3ASgCAEEBajYCACAAQZDSASgCABEAAAsLIARBADYCPAsgBEGAAWokACABCykAIAAQYBogAARAQez3AUHs9wEoAgBBAWo2AgAgAEGQ0gEoAgARAAALCz0CAX8BfSMAQRBrIgEkACABIAA2AgwgASgCDBCzDyECIwBBEGsiACACOAIMIAAqAgyRIQIgAUEQaiQAIAILBABBNAsJACAAIAE4AiwLAwABCwQAQQELBABBAgu4BgEJfwJAIABFDQAgAUUNAEHo9wFB6PcBKAIAQQFqNgIAQYAIQRBBjNIBKAIAEQMAIgUgATYCBCAFIAA2AgBB/AAhAUGAASEJQYABIQBBASEEA0AgBSAEIghBf2oiBEEDdCIKaiIDKAIEIQcgAygCACEGIAQgAUoEQAJAIAkgCUEBdCIBTgRAIAUhAwwBCyAAIAFOBEAgBSEDDAELAkACQCAJRQRAQQAhAwwBC0EAIQBB6PcBQej3ASgCAEEBajYCACAJQQR0QRBBjNIBKAIAEQMAIQMgCUEBSA0AA0AgAyAAQQN0IgtqIAUgC2opAgA3AgAgAEEBaiIAIAlHDQALDAELIAEhACAFRQ0BCyAFBEBB7PcBQez3ASgCAEEBajYCACAFQZDSASgCABEAAAsgASEACyADIQUgASIJQXxqIQELAkAgBiAHRgRAIAYoAihFDQEgBSAKaiIEIAYoAiQiAzYCBCAEIAM2AgAgBSAIQQN0aiIEIAYoAigiAzYCBCAEIAM2AgAgBCAGKQIkNwIIIAhBAmohBAwBCyAGKgIAIAcqAhBfQQFzDQAgBioCECAHKgIAYEEBcw0AIAYqAgQgByoCFF9BAXMNACAGKgIUIAcqAgRgQQFzDQAgBioCCCAHKgIYX0EBcw0AIAYqAhggByoCCGBBAXMNACAHKAIoIQMgBigCKARAIAYoAiQhBCADBEAgBSAKaiIDIAcoAiQ2AgQgAyAENgIAIAYoAighAyAFIAhBA3RqIgQgBygCJDYCBCAEIAM2AgAgBigCJCEDIAQgBygCKDYCDCAEIAM2AgggBigCKCEDIAQgBygCKDYCFCAEIAM2AhAgCEEDaiEEDAILIAUgCmoiAyAHNgIEIAMgBDYCACAGKAIoIQQgBSAIQQN0aiIDIAc2AgQgAyAENgIAIAhBAWohBAwBCyADBEAgBSAKaiIDIAcoAiQ2AgQgAyAGNgIAIAUgCEEDdGoiAyAHKAIoNgIEIAMgBjYCACAIQQFqIQQMAQsgAiAGIAcgAigCACgCCBEFAAsgBA0ACyAFRQ0AIAUEQEHs9wFB7PcBKAIAQQFqNgIAIAVBkNIBKAIAEQAACwsLRQEBfyMAQRBrIgMkACADIAA2AgwgAyABNgIIIAMgAjgCBCADKAIMIgAgAygCCCADKgIEIAAoAgAoAggRCwAgA0EQaiQAC+UDARR9QwAAgL8hCQJAIAMqAgAiDiACKgIAIgqTIgsgBCoCBCIUIAIqAgQiDJMiDZQgAyoCBCIPIAyTIgcgBCoCACIVIAqTIgaUkyIQIAEqAggiEZQgASoCACIIIAcgBCoCCCIWIAIqAggiB5MiEpQgAyoCCCIXIAeTIhMgDZSTIg2UIAEqAgQiGCATIAaUIAsgEpSTIguUkpIiBotDAAAANF0NAAJAIA0gACoCACISlCALIAAqAgQiE5SSIBAgACoCCCIZlJIgByAQlCAKIA2UIAwgC5SSkpOMIAaVIglDAACgNV5BAXMNACAJIAVdQQFzDQAgECAPIBMgGCAJlJIiBpMiBSAKIBIgCCAJlJIiCJMiCpQgDCAGkyIMIA4gCJMiDpSTlCANIAwgFyAZIBEgCZSSIhGTIg+UIAcgEZMiByAFlJOUIAsgByAOlCAPIAqUk5SSkkMAAKC1XkEBcw0AIBAgFCAGkyIGIA6UIAUgFSAIkyIIlJOUIA0gBSAWIBGTIgWUIA8gBpSTlCALIA8gCJQgBSAOlJOUkpJDAACgtV5BAXMNACAQIAwgCJQgBiAKlJOUIA0gBiAHlCAFIAyUk5QgCyAFIAqUIAcgCJSTlJKSQwAAoLVeDQELQwAAgL8hCQsgCQuUBAIDfwl9IwBBEGsiAyQAIAEoAhAhBCABKAIMIQUgACABKAIIIgEpAgg3AhAgACABKQIQNwIYIAAgASkCEDcCCCAAIAEpAgg3AgAgBSoCCCIGIAAqAgAiCl1BAXNFBEAgACAGOAIAIAYhCgsgBSoCDCIHIAAqAgQiC11BAXNFBEAgACAHOAIEIAchCwsgBSoCECIIIAAqAggiDF1BAXNFBEAgACAIOAIIIAghDAsgBSoCFCIJIAAqAgwiDV1BAXNFBEAgACAJOAIMIAkhDQsgACoCECIOIAZdQQFzRQRAIAAgBjgCECAGIQ4LIAAqAhQiBiAHXUEBc0UEQCAAIAc4AhQgByEGCyAAKgIYIgcgCF1BAXNFBEAgACAIOAIYIAghBwsgACoCHCIIIAldQQFzRQRAIAAgCTgCHCAJIQgLIAQqAggiCSAKXUEBc0UEQCAAIAk4AgALIAQqAgwiCiALXUEBc0UEQCAAIAo4AgQLIAQqAhAiCyAMXUEBc0UEQCAAIAs4AggLIAQqAhQiDCANXUEBc0UEQCAAIAw4AgwLIA4gCV1BAXNFBEAgACAJOAIQCyAGIApdQQFzRQRAIAAgCjgCFAsgByALXUEBc0UEQCAAIAs4AhgLIAggDF1BAXNFBEAgACAMOAIcCyADQQA2AgwgAyACOAIIIAMgAjgCBCADIAI4AgAgACADEPAPIANBEGokAAulFQIPfxt9IwBBwAFrIgIkAEHgIxAWIABB2AhqKAIAIgRBAU4EQCAAQZgIaiELQaSzASgCACENQaCzASoCACElIAJBkAFqQQRyIgchDgNAIAAoAuAIIAxBAnRqKAIAIgEoAhgiCQRAIA5BADYCKCAHQgA3AiAgB0IANwIYIAdCADcCECAHQgA3AgggB0IANwIAIAJB0ZL1zAM2ArgBIAJBl+7GygM2AqQBIAJBl+7GxgM2ApABAkAgASgCGCIFQQFIIgYEQEMAAAAAIRFDAAAAACETQwAAAAAhEAwBCyABKAIgIQggASgCDCEKQwAAAAAhEEEAIQRDAAAAACETQwAAAAAhEQNAIBEgCCAEQQJ0Ig9qKAIAIgMqAgggCiAPaioCACIUlJIhESAQIBQgAyoCEJSSIRAgEyAUIAMqAgyUkiETIARBAWoiBCAFRw0ACwsgAUEANgLwASABIBAgASoCgAEiEJQiFTgC7AEgASATIBCUIhc4AugBIAEgESAQlCIYOALkASAGRQRAIAEoAjQhCCABKAIgIQpBACEEQxe30TghEUMXt1E5IRNDAAAAACEQQ1FJnTkhFEMAAAAAIRYDQCAKIARBAnRqKAIAIgYqAhAhGiAGKgIMIRkgCCAEQQR0aiIDKgIIIRsgAyoCBCEcIAIgBioCCCAYkyISIAMqAgCUIBGSIhE4ApABIAIgEiAclCACKgKUAZI4ApQBIAIgEiAblCACKgKYAZI4ApgBIAMqAgghGyADKgIAIRwgAiAZIBeTIhIgAyoCBJQgE5IiEzgCpAEgAiASIByUIAIqAqABkjgCoAEgAiASIBuUIAIqAqgBkjgCqAEgAyoCACEZIAMqAgQhGyACIBogFZMiEiADKgIIlCAUkiIUOAK4ASACIBIgG5QgEJIiEDgCtAEgAiASIBmUIBaSIhY4ArABIARBAWoiBCAFRw0ACwsCQEHo2QEtAABBAXENAEHo2QEQEEUNAEHk2QEgDTYCAEHg2QEgJTgCAEHo2QEQDwsgAkGQAWogAkHgAGogAkEwahDgAyABIAEpAuwBNwJ0IAEgASkC5AE3AmwgASACKQNoNwJEIAEgAikDYDcCPCABIAIpAng3AlQgASACKQJwNwJMIAEgAikCgAE3AlwgASACKQKIATcCZCABKgJEIRAgAUFAayoCACERIAEqAlQhEyABKgJMIRQgASoCUCEWIAEqAqwBIRogASoCjAEhGSABKgKcASEbIAEqApQBIRwgASoCpAEhHyABKgJkIRIgASoCqAEhICABKgJcIRUgASoCiAEhHSABKgJgIRcgASoCmAEhISABKgI8IRggASoChAEhIiABQgA3ArwCIAFBADYC4AEgAUEANgLQASABQQA2AsABIAFCADcCxAIgAUIANwLMAiABQgA3AtQCIAEgFSAiIBWUIBwgF5SSIB8gEpSSIh6UIBcgHSAVlCAhIBeUkiAgIBKUkiIjlJIgEiAZIBWUIBsgF5SSIBogEpSSIiSUkiImOALcASABIBQgHpQgIyAWlJIgJCATlJIiJzgC2AEgASAYIB6UICMgEZSSICQgEJSSIig4AtQBIAEgFSAiIBSUIBwgFpSSIB8gE5SSIh6UIBcgHSAUlCAhIBaUkiAgIBOUkiIjlJIgEiAZIBSUIBsgFpSSIBogE5SSIiSUkiIpOALMASABIB4gFJQgIyAWlJIgJCATlJIiKjgCyAEgASAeIBiUICMgEZSSICQgEJSSIh44AsQBIAEgFSAiIBiUIBwgEZSSIB8gEJSSIhWUIBcgGCAdlCARICGUkiAQICCUkiIXlJIgEiAYIBmUIBEgG5SSIBAgGpSSIhKUkiIaOAK8ASABIBUgFJQgFyAWlJIgEiATlJIiGTgCuAEgASAVIBiUIBcgEZSSIBIgEJSSIhs4ArQBAkAgCUEBSARAQwAAAAAhEEMAAAAAIRRDAAAAACEWQwAAAAAhEUMAAAAAIRNDAAAAACESDAELIAEoAiAhBSABKgLsASEcIAEqAugBIR8gASoC5AEhICABKAIMIQZBACEEQwAAAAAhEEMAAAAAIRRDAAAAACEWQwAAAAAhEUMAAAAAIRNDAAAAACESA0AgBSAEQQJ0IghqKAIAIgMqAiwhHSADKgIwIRggASADKgIoIAYgCGoqAgAiFZQiFyASkiISOAK8AiABIBUgGJQiGCARkiIROALEAiABIBUgHZQiFSATkiITOALAAiADKgIQIR0gASAVIAMqAgggIJMiIZQgFyADKgIMIB+TIiKUkyAQkiIQOALUAiABIBcgHSAckyIXlCAYICGUkyAUkiIUOALQAiABIBYgGCAilCAVIBeUk5IiFjgCzAIgBEEBaiIEIAlHDQALCyABQQA2AsgCIAFBADYC2AIgASABKgKAASIVIBGUQwAAgD8gASoC5AKTIhGUOALEAiABIBUgE5QgEZQ4AsACIAEgEiAVlCARlDgCvAIgAUMAAIA/IAEqAugCkyIRIBYgKJQgFCAnlJIgECAmlJKUOALUAiABIBYgHpQgFCAqlJIgECAplJIgEZQ4AtACIAEgGyAWlCAZIBSUkiAaIBCUkiARlDgCzAIgAUH0AWpBAEHIABALGgJAIAEqAuwCIhBDAAAAAF5BAXMNACABKAIYQQFIDQBBACEEA0AgASgCICAEQQJ0aigCACIDKgIIIRYgAyoCDCESIAMqAhAhFSABKAI0IARBBHRqIgUqAgghESAFKgIAIRMgBSoCBCEUIAEqAmwhFyABKgJEIRggASoCPCEaIAEqAkAhGSABKgJwIRsgASoCVCEcIAEqAkwhHyABKgJQISAgASoCdCEdIAEqAmQhISABKgJcISIgASoCYCEeIANBADYCFCADIBUgECAdIBMgIpQgFCAelJIgESAhlJKSIBWTlJI4AhAgAyASIBAgGyATIB+UIBQgIJSSIBEgHJSSkiASk5SSOAIMIAMgFiAQIBcgEyAalCAUIBmUkiARIBiUkpIgFpOUkjgCCCAEQQFqIgQgASgCGE4NASABKgLsAiEQDAAACwALAkAgAS0A+QJFDQBBASEEIAEoAiAiBSgCACIDKgIIIhAhFCADKgIMIhYhESADKgIQIhMhEiADKgIUIhUhFyAJQQFKBEADQCAFIARBAnRqKAIAIgMqAggiGCAQIBAgGF0bIRAgGCAUIBggFF0bIRQgAyoCFCIYIBUgFSAYXRshFSADKgIQIhogEyATIBpdGyETIAMqAgwiGSAWIBYgGV0bIRYgGCAXIBggF10bIRcgGiASIBogEl0bIRIgGSARIBkgEV0bIREgBEEBaiIEIAlHDQALCyACIBU4AiwgAiATOAIoIAIgFjgCJCACIBA4AiAgAiAXOAIcIAIgEjgCGCACIBE4AhQgAiAUOAIQIAEoAtwCIgQEQCABKgK8AiERIAEqAsACIRMgASoCxAIhFCAAKgLEAyEQIAJBADYCDCACIBAgFJRDAABAQJQ4AgggAiAQIBOUQwAAQECUOAIEIAIgESAQlEMAAEBAlDgCACALIAQgAkEQaiACIAAqAtADEMwBGgwBCyABIAsgAkEQaiABEEI2AtwCCyAAKALYCCEECyAMQQFqIgwgBEgNAAsLEBMgAkHAAWokAAvtMAIMfwh9IwBBEGsiDiQAIABB2AhqKAIAIgNBAU4EQANAIABBABD/ASAAKALYCCIDQQBKDQALCyADIAEgACgCyAUiBCAEIAFKGyIHSARAIABB3AhqKAIAIAdIBEACQCAHRQRAQQAhBAwBC0Ho9wFB6PcBKAIAQQFqNgIAIAdBAnRBEEGM0gEoAgARAwAhBCAAKALYCCIFQQFIDQBBACEBA0AgBCABQQJ0IghqIAAoAuAIIAhqKAIANgIAIAFBAWoiASAFRw0ACwsgAEHgCGooAgAiAQRAIABB5AhqLQAABEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AuAICyAAIAQ2AuAIIAAgBzYC3AggAEHkCGpBAToAAAsDQCAAKALgCCADQQJ0akEANgIAIANBAWoiAyAHRw0ACwsgACAHNgLYCAJAAkACfwJAAkAgB0EBSA0AQQAhAQNAQej3AUHo9wEoAgBBAWo2AgBBgANBEEGM0gEoAgARAwAiA0EBOgAkIANCADcCBCADQQA2AgwgA0EBOgAQIANBADYCICADQQE6ADggA0IANwIYIANBADYCNCADQgA3AtwCIANCADcCLCADQQA6APgCIANCgICglqTh9ZE8NwLwAiADQgA3AuQCIANBADYC7AIgAUECdCIEIAAoAuAIaiADNgIAIAAoAuAIIARqKAIAQQE6APkCIAFBAWoiASAAKALYCCIHSA0ACyAHQQFIDQAgACgCyAUiBEEATARAQwAAgD8gBLKVQwAAAACUIg8hECAPIRIMAgsgByEDA0AgACgC0AUgBkHoAGxqIgoqAgghEiAKKgIQIRMgCioCDCEUAkAgACgC4AggBkGx6QFsIANvQQJ0aigCACIIKAIYIgUgCCgCHEcNACAFIAVBAXRBASAFGyILTg0AAkAgC0UEQEEAIQkMAQtB6PcBQej3ASgCAEEBajYCACALQQJ0QRBBjNIBKAIAEQMAIQkgCCgCGCEFCyAFQQFOBEBBACEDA0AgCSADQQJ0IgFqIAgoAiAgAWooAgA2AgAgA0EBaiIDIAVHDQALCyAIKAIgIgEEQCAILQAkBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALIAgoAhghBQsgCEEANgIgCyAIIAk2AiAgCCALNgIcIAhBAToAJCAAKALIBSEECyARIBKSIREgDyATkiEPIBAgFJIhECAIKAIgIAVBAnRqIAo2AgAgCCAFQQFqNgIYIAZBAWoiBiAESARAIAAoAtgIIQMMAQsLQQAhCiAHQQBIDQMgD0MAAIA/IASylSIPlCESIBAgD5QhECARIA+UIQ8gBw0BQQAhB0EADAILIAAoAoQGIgIEQCAHIAJIBEAgAEHcCGooAgAgAkgEQEHo9wFB6PcBKAIAQQFqNgIAIAJBAnRBEEGM0gEoAgARAwAhAyAAKALYCCIEQQFOBEBBACEBA0AgAyABQQJ0IgVqIAAoAuAIIAVqKAIANgIAIAFBAWoiASAERw0ACwsgAEHgCGooAgAiAQRAIABB5AhqLQAABEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AuAICyAAIAM2AuAIIAAgAjYC3AggAEHkCGpBAToAAAsDQCAAKALgCCAHQQJ0akEANgIAIAdBAWoiByACRw0ACwsgACACNgLYCCACQQFOBEBBACEBA0BB6PcBQej3ASgCAEEBajYCAEGAA0EQQYzSASgCABEDACICQQE6ACQgAkIANwIEIAJBADYCDCACQQE6ABAgAkEANgIgIAJBAToAOCACQgA3AhggAkEANgI0IAJCADcC3AIgAkIANwIsIAJBADoA+AIgAkKAgKCWpOH1kTw3AvACIAJCADcC5AIgAkEANgLsAiABQQJ0IgMgACgC4AhqIAI2AgAgACgC4AggA2ooAgBBAToA+QIgAUEBaiIBIAAoAtgISA0ACwsgACgChAZBAUgNBANAQQAhCQNAIAAoAowGIAZB6ABsaiAJQQJ0aiEIAkAgACgC4AggBkECdGooAgAiAigCGCIFIAIoAhxHDQAgBSAFQQF0QQEgBRsiBE4NAAJAIARFBEBBACEHDAELQej3AUHo9wEoAgBBAWo2AgAgBEECdEEQQYzSASgCABEDACEHIAIoAhghBQsgBUEBTgRAQQAhAwNAIAcgA0ECdCIBaiACKAIgIAFqKAIANgIAIANBAWoiAyAFRw0ACwsgAigCICIBBEAgAi0AJARAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACyACKAIYIQULIAJBADYCIAsgAiAHNgIgIAIgBDYCHCACQQE6ACQLIAIoAiAgBUECdGogCCgCCDYCACACIAVBAWo2AhggCUEBaiIJQQRHDQALIAZBAWoiBiAAKAKEBkgNAAsMBAsgByAAKALwBSICSARAIABB3AhqKAIAIAJIBEACQCACRQRAQQAhBAwBC0Ho9wFB6PcBKAIAQQFqNgIAIAJBAnRBEEGM0gEoAgARAwAhBCAAKALYCCIDQQFIDQBBACEBA0AgBCABQQJ0IgVqIAAoAuAIIAVqKAIANgIAIAFBAWoiASADRw0ACwsgAEHgCGooAgAiAQRAIABB5AhqLQAABEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AuAICyAAIAQ2AuAIIAAgAjYC3AggAEHkCGpBAToAAAsDQCAAKALgCCAHQQJ0akEANgIAIAdBAWoiByACRw0ACwsgACACNgLYCCACQQFOBEBBACEBA0BB6PcBQej3ASgCAEEBajYCAEGAA0EQQYzSASgCABEDACICQQE6ACQgAkIANwIEIAJBADYCDCACQQE6ABAgAkEANgIgIAJBAToAOCACQgA3AhggAkEANgI0IAJCADcC3AIgAkIANwIsIAJBADoA+AIgAkKAgKCWpOH1kTw3AvACIAJCADcC5AIgAkEANgLsAiABQQJ0IgMgACgC4AhqIAI2AgAgACgC4AggA2ooAgBBAToA+QIgAUEBaiIBIAAoAtgISA0ACwsgACgC8AVBAUgNAwNAQQAhCQNAIAAoAvgFIAZBLGxqIAlBAnRqIQgCQCAAKALgCCAGQQJ0aigCACICKAIYIgUgAigCHEcNACAFIAVBAXRBASAFGyIETg0AAkAgBEUEQEEAIQcMAQtB6PcBQej3ASgCAEEBajYCACAEQQJ0QRBBjNIBKAIAEQMAIQcgAigCGCEFCyAFQQFOBEBBACEDA0AgByADQQJ0IgFqIAIoAiAgAWooAgA2AgAgA0EBaiIDIAVHDQALCyACKAIgIgEEQCACLQAkBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALIAIoAhghBQsgAkEANgIgCyACIAc2AiAgAiAENgIcIAJBAToAJAsgAigCICAFQQJ0aiAIKAIINgIAIAIgBUEBajYCGCAJQQFqIglBA0cNAAsgBkEBaiIGIAAoAvAFSA0ACwwDC0Ho9wFB6PcBKAIAQQFqNgIAIAdBBHRBEEGM0gEoAgARAwALIQpBACEBA0AgCiABQQR0aiIDQQA2AgwgAyASOAIIIAMgEDgCBCADIA84AgAgAUEBaiIBIAdHDQALC0EAIQEDQCABIgNBAWohAUMAAABAIAOyQwAAgD2UQwAAgD+WkyESQQAhC0EAIQkDQAJAIAlBAnQiCCAAKALgCGooAgAiAygCGCIEQQFIBEBDAAAAACEPQwAAAAAhEEMAAAAAIREMAQsgAygCICEGQwAAAAAhEUEAIQNDAAAAACEQQwAAAAAhDwNAIA8gBiADQQJ0aigCACIFKgIIkiEPIBEgBSoCEJIhESAQIAUqAgySIRAgA0EBaiIDIARHDQALCyAEBEAgCiAJQQR0aiIDQQA2AgwgAyADKgIIIhMgEiARQwAAgD8gBLKVIhGUIBOTlJIiFTgCCCADIAMqAgQiFCASIBAgEZQgFJOUkiIWOAIEIAMgAyoCACIQIBIgDyARlCAQk5SSIg84AgAgDyAQkyIPIA+UIBYgFJMiDyAPlJIgFSATkyIPIA+UkkMAAAA0XiEGIAAoAuAIIAhqKAIAIgUoAhgiA0F/TARAIAUoAhxBf0wEQCAFKAIgIgQEQCAFLQAkBEAgBARAQez3AUHs9wEoAgBBAWo2AgAgBEGQ0gEoAgARAAALCyAFQQA2AiALIAVCADcCHCAFQQE6ACQLA0AgBSgCICADQQJ0akEANgIAIANBAWoiBCADTyEIIAQhAyAIDQALCyAFQQA2AhggBiALciELCyAJQQFqIgkgB0cNAAtBACEIIAAoAsgFIgRBAEoEQANAIAAoAtAFIAhB6ABsaiEMQQAhBSAHQQJOBEAgCioCACAMKgIIIhKTiyAKKgIEIAwqAgwiEJOLkiAKKgIIIAwqAhAiEZOLkiEPQQEhAwNAIAogA0EEdGoiBioCACASk4sgBioCBCAQk4uSIAYqAgggEZOLkiITIA8gEyAPXSIGGyEPIAMgBSAGGyEFIANBAWoiAyAHRw0ACwsCQCAAKALgCCAFQQJ0aigCACIGKAIYIgUgBigCHEcNACAFIAVBAXRBASAFGyINTg0AAkAgDUUEQEEAIQkMAQtB6PcBQej3ASgCAEEBajYCACANQQJ0QRBBjNIBKAIAEQMAIQkgBigCGCEFCyAFQQFOBEBBACEDA0AgCSADQQJ0IgRqIAYoAiAgBGooAgA2AgAgA0EBaiIDIAVHDQALCyAGKAIgIgMEQCAGLQAkBEAgAwRAQez3AUHs9wEoAgBBAWo2AgAgA0GQ0gEoAgARAAALIAYoAhghBQsgBkEANgIgCyAGIAk2AiAgBiANNgIcIAZBAToAJCAAKALIBSEECyAGKAIgIAVBAnRqIAw2AgAgBiAFQQFqNgIYIAhBAWoiCCAESA0ACwsgASACSCALcQ0ACwJAIARBAUgEQEEAIQgMAQsCf0Ho9wFB6PcBKAIAQQFqNgIAIARBAnQiAUEQQYzSASgCABEDACIIC0H/ASABEAsaCyAAKALYCCIEQQFOBEAgACgC4AghBUEAIQEDQCAFIAFBAnRqKAIAIgIoAhhBAU4EQCACKAIgIQQgACgC0AUhB0EAIQMDQCAIIAQgA0ECdGooAgAgB2tB6ABtQQJ0aiABNgIAIANBAWoiAyACKAIYSA0ACyAAKALYCCEECyABQQFqIgEgBEgNAAsLAn8gACgC8AVBAU4EQEEAIQIDQCAOIAAoAvgFIAJBLGxqIgEoAgggACgC0AUiBGtB6ABtIgM2AgQgDiABKAIMIARrQegAbTYCCCAOIAEoAhAgBGtB6ABtNgIMQQAhCwNAIAggA0ECdGooAgAhB0EBIQkDQAJAIAggDkEEaiAJIAtqQQNwQQJ0aigCACIBQQJ0aigCACAHRg0AIAAoAtAFIAFB6ABsaiEMAkAgACgC4AggB0ECdGooAgAiBCgCGCIBQQFIDQAgBCgCICEFQQAhAwNAIAwgBSADQQJ0aigCAEcEQCADQQFqIgMgAUcNAQwCCwsgASADRw0BCwJAIAEgBCgCHEcNACABIAFBAXRBASABGyIFTg0AAkAgBUUEQEEAIQYMAQtB6PcBQej3ASgCAEEBajYCACAFQQJ0QRBBjNIBKAIAEQMAIQYgBCgCGCEBCyABQQFOBEBBACEDA0AgBiADQQJ0Ig1qIAQoAiAgDWooAgA2AgAgA0EBaiIDIAFHDQALCyAEKAIgIgMEQCAELQAkBEAgAwRAQez3AUHs9wEoAgBBAWo2AgAgA0GQ0gEoAgARAAALIAQoAhghAQsgBEEANgIgCyAEIAY2AiAgBCAFNgIcIARBAToAJAsgBCgCICABQQJ0aiAMNgIAIAQgAUEBajYCGAsgCUEBaiIJQQNHDQALIAtBAWoiC0EDRwRAIA5BBGogC0ECdGooAgAhAwwBCwsgAkEBaiICIAAoAvAFSA0ACyAAKALYCCEECyAEQQJOCwRAQQAhA0Ho9wFB6PcBKAIAQQFqNgIAQYADQRBBjNIBKAIAEQMAIgZBADsB+AIgBkKAgKCWpOH1kTw3AvACIAZCADcC3AIgBkEANgIMIAZBAToAECAGQQE6ACQgBkIANwIEIAZBADYCICAGQQE6ADggBkIANwIYIAZBADYCNCAGQgA3AiwgBkEANgLsAiAGQgA3AuQCAkAgACgCyAUiBEEBSA0AQej3AUHo9wEoAgBBAWo2AgAgBEECdEEQQYzSASgCABEDACECIAYoAhgiAUEBTgRAA0AgAiADQQJ0IgVqIAYoAiAgBWooAgA2AgAgA0EBaiIDIAFHDQALCyAGKAIgIgEEQCAGLQAkBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAGQQA2AiALIAYgAjYCICAGQQE6ACQgBiAENgIcIAAoAsgFIgVBAUgNACAGKAIYIQNBACEJA0AgACgC0AUgCUHoAGxqIQsCQCADIARHDQAgBCAEQQF0QQEgBBsiAU4EQCAEIQMMAQtBACEDQQAhBwJ/IAEEQEHo9wFB6PcBKAIAQQFqNgIAIAFBAnRBEEGM0gEoAgARAwAhByAGKAIYIQQLIARBAU4LBEADQCAHIANBAnQiAmogBigCICACaigCADYCACADQQFqIgMgBEcNAAsLIAYoAiAiAgRAIAYtACQEQCACBEBB7PcBQez3ASgCAEEBajYCACACQZDSASgCABEAAAsgBigCGCEECyAGQQA2AiALIAQhAyAGIAc2AiAgBkEBOgAkIAYgATYCHCAAKALIBSEFIAEhBAsgBigCICADQQJ0aiALNgIAIAYgA0EBaiIDNgIYIAlBAWoiCSAFSA0ACwsCQCAAKALYCCIEIABB3AhqKAIARw0AIAQgBEEBdEEBIAQbIgJODQBBACEDQQAhBwJ/IAIEQEHo9wFB6PcBKAIAQQFqNgIAIAJBAnRBEEGM0gEoAgARAwAhByAAKALYCCEECyAEQQFOCwRAA0AgByADQQJ0IgFqIAAoAuAIIAFqKAIANgIAIANBAWoiAyAERw0ACwsgACgC4AgiAQRAIABB5AhqLQAABEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALIAAoAtgIIQQLIABBADYC4AgLIAAgBzYC4AggACACNgLcCCAAQeQIakEBOgAACyAEQQJ0IgIgACgC4AhqIAY2AgAgACAEQQFqIgQ2AtgIIAAoAuAIIgEoAgAhAyABIAEgAmoiASgCADYCACABIAM2AgALIARBAU4EQEEAIQMDQCAAKALgCCADQQJ0aigCACgCGAR/IAMFIAAgAxD/ASAAKALYCCEEIANBf2oLQQFqIgMgBEgNAAsLIAgEQCAIBEBB7PcBQez3ASgCAEEBajYCACAIQZDSASgCABEAAAsLIApFDQAgCgRAQez3AUHs9wEoAgBBAWo2AgAgCkGQ0gEoAgARAAALCwJAIAAoAtgIRQRAQQAhCAwBCyAAEIwFIAAQ6wIgACgC2AgiCCAIbCIHIABB7AhqKAIAIgJKBEACQCAAQfAIaigCACAHTgRAIABB9AhqKAIAIQEMAQtBACEDIAIhBUEAIQEgBwRAQej3AUHo9wEoAgBBAWo2AgAgB0EQQYzSASgCABEDACEBIAAoAuwIIQULIABB9AhqKAIAIQQCQCAFQQFOBEADQCABIANqIAMgBGotAAA6AAAgA0EBaiIDIAVHDQAMAgALAAsgBA0AIAAgATYC9AggACAHNgLwCCAAQfgIakEBOgAADAELIABB+AhqLQAABEAgBARAQez3AUHs9wEoAgBBAWo2AgAgBEGQ0gEoAgARAAALCyAAIAE2AvQIIABBAToA+AggACAHNgLwCAsgASACakEAIAcgAmsQCxogACgC2AghCAsgACAHNgLsCCAIQQFIDQAgAEH0CGooAgAhBSAAQeAIaigCACEAQQAhCgNAIAAgCkECdGooAgAiASAKNgL8AiABKAIYIgJBACACQQBKGyEHQQAhBgNAIAUgBiAIbCAKamoCfyACQQFOBEAgACAGQQJ0aigCACILKAIYIQRBACEJA0AgBEEBTgRAIAEoAiAgCUECdGooAgAhDCALKAIgIQ1BACEDA0BBASAMIA0gA0ECdGooAgBGDQQaIANBAWoiAyAESA0ACwsgCUEBaiIJIAdHDQALC0EACzoAACAGQQFqIgYgCEcNAAsgCkEBaiIKIAhHDQALCyAOQRBqJAAgCAuvBAEHfyMAQUBqIQJB9+8OIQYgACgC3AUiBUEBTgRAA0AgAiAAKALkBSIBIARBNGxqIgMiB0EwaigCADYCOCACIAMpAig3AzAgAiADKQIgNwMoIAIgAykCGDcDICACIAMpAhA3AxggAiADKQIINwMQIAIgAykCADcDCCADIAEgBkGNzOUAbEHf5rvjA2oiBiAFcEE0bGoiASkCADcCACAHIAEoAjA2AjAgAyABKQIoNwIoIAMgASkCIDcCICADIAEpAhg3AhggAyABKQIQNwIQIAMgASkCCDcCCCABIAIoAjg2AjAgASACKQMwNwIoIAEgAikDKDcCICABIAIpAyA3AhggASACKQMYNwIQIAEgAikDEDcCCCABIAIpAwg3AgAgBEEBaiIEIAVHDQALCyAAKALwBSIFQQFOBEBBACEEA0AgAiAAKAL4BSIBIARBLGxqIgMiB0EoaigCADYCMCACIAMpAiA3AyggAiADKQIYNwMgIAIgAykCEDcDGCACIAMpAgg3AxAgAiADKQIANwMIIAMgASAGQY3M5QBsQd/mu+MDaiIGIAVwQSxsaiIBKQIANwIAIAcgASgCKDYCKCADIAEpAiA3AiAgAyABKQIYNwIYIAMgASkCEDcCECADIAEpAgg3AgggASACKAIwNgIoIAEgAikDKDcCICABIAIpAyA3AhggASACKQMYNwIQIAEgAikDEDcCCCABIAIpAwg3AgAgBEEBaiIEIAVHDQALCwuHCQIDfxZ9IAAqAqwCIREgACoCxAMhDwJ/IAAqArACIhdDAAAAAF5FBEBBACARQwAAAABeQQFzDQEaCyAAKAKgAkEESAshAwJAIAAoAtAFIgQgAkHoAGxqKgJYIhVDAAAAAF5BAXMNACADRQ0AIAQgAkHoAGxqIgMqAigiEiABKgIAkyIHIAeUIAMqAiwiEyABKgIEkyIJIAmUkiADKgIwIhAgASoCCJMiCiAKlJIiFEMAAAA0XkEBcw0AIAAoAqACIgVBA0sNACAAKAKsBSgCACEBIApDAACAPyAUkSIblSIIlCEGIAkgCJQhCyAHIAiUIQggAyoCSCEMIAMqAlAhDSADKgJMIQ4gBUECa0UEQCAGIA1DAACAv0MAAIA/IAcgDJQgCSAOlJIgCiANlJJDAAAAAF0bIgeUIhiUIAggDCAHlCIZlCALIA4gB5QiGpSSkiIHIBFDAAAAP5QgAb4iEZQgFJQgBCACQegAbGoqAlxDAAAAP5QiFJSUIgwgBoyUIQkgDCALjJQhCiAMIAiMlCEMAkAgB0MAAAAAXkEBcwRAQwAAAAAhDUMAAAAAIQ4MAQtDAAAAACENQwAAAAAhDiAHQ9obfD9dQQFzDQAgCyAGIBqUIAsgGJSTIg2UIAggCCAYlCAGIBmUkyIWlJNDAACAPyAHIAeUk5EgF0MAAAA/lCARlCAblCAUlJQiB5QhDiAIIAsgGZQgCCAalJMiCJQgBiANlJMgB5QhDSAGIBaUIAsgCJSTIAeUIRYLAkAgDyAVIAmUlCIGIAaUIA8gFSAMlJQiBiAGlCAPIBUgCpSUIgYgBpSSkiIGIBIgEpQgEyATlJIgECAQlJIiC2BBAXMNACAGQwAAAABeQQFzDQAgCSALkSAGkZVDzcxMP5QiBpQhCSAKIAaUIQogDCAGlCEMCyAEIAJB6ABsaiIAIBYgDCAAKgI4kpI4AjggAEFAayIBIA4gCSABKgIAkpI4AgAgACANIAogACoCPJKSOAI8DwsgCiANQwAAgL9DAACAPyAHIAyUIAkgDpSSIAogDZSSQwAAAABdGyIKlCINlCAHIAwgCpQiDJQgCSAOIAqUIg6UkpIiCUMAAAAAXkEBcw0AIA8gFZQiByAGIBEgFCAJIAQgAkHoAGxqIgAqAlyUlEMAAAC/lCABvpQiBpQiCZQgDSAXIAaUIgqUQwAAAACSkiIGlCIPIA+UIAcgCCAJlCAMIAqUQwAAAACSkiIIlCIPIA+UIAcgCyAJlCAOIAqUQwAAAACSkiILlCIJIAmUkpIgEiASlCATIBOUkiAQIBCUkl5BAXNFBEAgACAAKgI4QwAAgD8gB5UiByAIQwAAgD8gBiAGlCAIIAiUIAsgC5SSkpGVIgiUIgkgECAGIAiUIhCUIBIgCZQgEyALIAiUIguUkpIiBpSUkzgCOCAAIAAqAjwgByALIAaUlJM4AjwgAEFAayIAIAAqAgAgByAQIAaUlJM4AgAPCyAAIAggACoCOJI4AjggACALIAAqAjySOAI8IABBQGsiACAGIAAqAgCSOAIACwsnAQF/IwBBEGsiASQAIAEgADYCDCABKAIMEJgFIQAgAUEQaiQAIAAL2gMBB38jAEEwayIDJAAgA0EANgIoIANCADcDICADQgA3AxggA0IANwMQIANCADcDCCADQgA3AwAgASAAKALwBigCACABGyEBAkAgACgC3AUiAiAAKALgBUcNACACIAJBAXRBASACGyIGTg0AAn8gBgRAQej3AUHo9wEoAgBBAWo2AgAgBkE0bEEQQYzSASgCABEDACEHIAAoAtwFIQILIAJBAU4LBEADQCAHIAhBNGwiBGoiBSAAKALkBSAEaiIEKQIANwIAIAUgBCgCMDYCMCAFIAQpAig3AiggBSAEKQIgNwIgIAUgBCkCGDcCGCAFIAQpAhA3AhAgBSAEKQIINwIIIAhBAWoiCCACRw0ACwsgACgC5AUiAgRAIAAtAOgFBEAgAgRAQez3AUHs9wEoAgBBAWo2AgAgAkGQ0gEoAgARAAALCyAAQQA2AuQFCyAAIAc2AuQFIAAgBjYC4AUgAEEBOgDoBSAAKALcBSECCyAAKALkBSACQTRsaiICIAE2AgQgAkEANgIAIAIgAykDADcCCCACIAMpAwg3AhAgAiADKQMQNwIYIAIgAykDGDcCICACIAMpAyA3AiggAiADKAIoNgIwIAAgACgC3AVBAWo2AtwFIANBMGokAAuQDwECfyAAQeQiNgIAIAAoAsABIgEEQCABIAEoAgAoAgQRAAALIABB2AhqKAIAQQFOBEADQCAAQQAQ/wEgACgC2AhBAEoNAAsLIAAoAugGQQFOBEBBACEBA0AgACgC8AYgAUECdGooAgAiAgRAQez3AUHs9wEoAgBBAWo2AgAgAkGQ0gEoAgARAAALIAFBAWoiASAAKALoBkgNAAsLIAAoAtQGQQFOBEBBACEBA0AgACgC3AYgAUECdGooAgAiAgRAQez3AUHs9wEoAgBBAWo2AgAgAkGQ0gEoAgARAAALIAFBAWoiASAAKALUBkgNAAsLIABB3AlqKAIAIgEEQCAAQeAJai0AAARAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgLcCQsgAEEANgLcCSAAQgA3AtQJIABB4AlqQQE6AAAgAEH0CGooAgAiAQRAIABB+AhqLQAABEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AvQICyAAQQA2AvQIIABCADcC7AggAEH4CGpBAToAACAAQeAIaigCACIBBEAgAEHkCGotAAAEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYC4AgLIABBADYC4AggAEIANwLYCCAAQeQIakEBOgAAIABBmAhqEEMgAEHcB2oQQyAAQaAHahBDIAAoAvAGIgEEQCAALQD0BgRAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgLwBgsgAEEANgLwBiAAQgA3AugGIABBAToA9AYgACgC3AYiAQRAIAAtAOAGBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AtwGCyAAQQA2AtwGIABCADcC1AYgAEEBOgDgBiAAKALIBiIBBEAgAC0AzAYEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYCyAYLIABBADYCyAYgAEIANwLABiAAQQE6AMwGIAAoArQGIgEEQCAALQC4BgRAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgK0BgsgAEEANgK0BiAAQgA3AqwGIABBAToAuAYgACgCoAYiAQRAIAAtAKQGBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AqAGCyAAQQA2AqAGIABCADcCmAYgAEEBOgCkBiAAKAKMBiIBBEAgAC0AkAYEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYCjAYLIABBADYCjAYgAEIANwKEBiAAQQE6AJAGIAAoAvgFIgEEQCAALQD8BQRAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgL4BQsgAEEANgL4BSAAQgA3AvAFIABBAToA/AUgACgC5AUiAQRAIAAtAOgFBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AuQFCyAAQQA2AuQFIABCADcC3AUgAEEBOgDoBSAAKALQBSIBBEAgAC0A1AUEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYC0AULIABBADYC0AUgAEIANwLIBSAAQQE6ANQFIAAoArwFIgEEQCAALQDABQRAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgK8BQsgAEEANgK8BSAAQgA3ArQFIABBAToAwAUgACgCgAQiAQRAIAAtAIQEBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AoAECyAAQQA2AoAEIABCADcC+AMgAEEBOgCEBCAAKALsAyIBBEAgAC0A8AMEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYC7AMLIABBADYC7AMgAEIANwLkAyAAQQE6APADIAAoArwDIgEEQCAALQDAAwRAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgK8AwsgAEEANgK8AyAAQgA3ArQDIABBAToAwAMgACgCqAMiAQRAIAAtAKwDBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AqgDCyAAQQA2AqgDIABCADcCoAMgAEEBOgCsAyAAKAKUAyIBBEAgAC0AmAMEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYClAMLIABBADYClAMgAEIANwKMAyAAQQE6AJgDIAAoApQCIgEEQCAALQCYAgRAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgKUAgsgAEEANgKUAiAAQgA3AowCIABBAToAmAIgAEHkygA2AgAgAAuKAwEGf0Ho9wFB6PcBKAIAQQFqNgIAQRRBEEGM0gEoAgARAwAiAUIANwIAIAFBADYCECABQgA3AggCQCAAKALoBkEBTgRAIAEgACgC8AYoAgAiAykCADcCACABIAMoAhA2AhAgASADKQIINwIIDAELIAFCADcCACABQQA2AhAgAUIANwIICwJAIAAoAugGIgIgACgC7AZHDQAgAiACQQF0QQEgAhsiBE4NAAJ/IAQEQEHo9wFB6PcBKAIAQQFqNgIAIARBAnRBEEGM0gEoAgARAwAhBSAAKALoBiECCyACQQFOCwRAA0AgBSAGQQJ0IgNqIAAoAvAGIANqKAIANgIAIAZBAWoiBiACRw0ACwsgACgC8AYiAwRAIAAtAPQGBEAgAwRAQez3AUHs9wEoAgBBAWo2AgAgA0GQ0gEoAgARAAALIAAoAugGIQILIABBADYC8AYLIAAgBTYC8AYgACAENgLsBiAAQQE6APQGCyAAKALwBiACQQJ0aiABNgIAIAAgAkEBajYC6AYgAQsHACAAKAIYC78EAQR/IAAgARDGAiAAQZQfNgIAQej3AUHo9wEoAgBBAWo2AgBBCEEQQYzSASgCABEDACICQewfNgIAIAJBADoABCAAIAI2AlxB6PcBQej3ASgCAEEBajYCAEEIQRBBjNIBKAIAEQMAIgJB5CA2AgAgAkEAOgAEIAAgAjYCYEHo9wFB6PcBKAIAQQFqNgIAQQhBEEGM0gEoAgARAwAiAkHkIDYCACAAIAI2AmQgAkEBOgAEQej3AUHo9wEoAgBBAWo2AgBBCEEQQYzSASgCABEDACICQbQhNgIAIAJBADoABCAAIAI2AmhB6PcBQej3ASgCAEEBajYCAEEIQRBBjNIBKAIAEQMAIgJBiCI2AgAgACACNgJsIAJBAToABAJAIAAtABRFDQAgACgCECICRQ0AIAIoAgBBmwFKDQAgAigCECICBEBB7PcBQez3ASgCAEEBajYCACACQZDSASgCABEAAAsgACgCECICBEBB7PcBQez3ASgCAEEBajYCACACQZDSASgCABEAAAtB6PcBQej3ASgCAEEBajYCAEEUQRBBjNIBKAIAEQMAIgMgASgCDCIBNgIEIANBnAE2AgBB6PcBQej3ASgCAEEBajYCACADIAFBnAFsQRBBjNIBKAIAEQMAIgI2AgwgAyACNgIQIAMgAygCBCIBNgIIAkAgAUF/aiIERQRAIAIhAQwBCyADKAIAIQUDQCACIAIgBWoiATYCACABIQIgBEF/aiIEDQALCyABQQA2AgAgACADNgIQCws4ACAAQYCAgPwDNgIMIABCBTcCBCAAQYgeNgIAIABBAToAECAAQQE6ACQgAEEANgIgIABCADcCGAuFAQEBfyMAQSBrIgMkACADIAA2AhwgA0EANgIYIAMgATYCFCADIAI2AhAgAygCHCEAIAMgAygCGDYCDANAIAMoAgwgAygCFEgEQCADKAIQIAMoAgxB6ABsaiAAKAIMIAMoAgxB6ABsakHoABAVGiADIAMoAgxBAWo2AgwMAQsLIANBIGokAAsxAQF/IwBBEGsiASQAIAEgADYCDCABKAIMIgAgACgCACgCMBEBACEAIAFBEGokACAAC4IBAQF/IwBBIGsiAyQAIAMgADYCHCADQQA2AhggAyABNgIUIAMgAjYCECADKAIcIQAgAyADKAIYNgIMA0AgAygCDCADKAIUSARAIAMoAhAgAygCDEHgAGxqIAAoAgwgAygCDEHgAGxqEJACIAMgAygCDEEBajYCDAwBCwsgA0EgaiQAC2sBAX8jAEEQayICJAAgAiAANgIMIAJBADYCCCACIAE2AgQgAigCDCEAIAIgAigCCDYCAANAIAIoAgAgAigCBEgEQCAAKAIMIAIoAgBBJGxqEI4BIAIgAigCAEEBajYCAAwBCwsgAkEQaiQAC0oBAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIgAgAigCCBDJBSAAIAIoAggiASkCFDcCFCAAIAEpAhw3AhwgAkEQaiQACzkBAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIgAgAigCCCAAKAIAKAIsEQIAIAJBEGokAAuAAQEBfyMAQSBrIgMkACADIAA2AhwgA0EANgIYIAMgATYCFCADIAI2AhAgAygCHCEAIAMgAygCGDYCDANAIAMoAgwgAygCFEgEQCADKAIQIAMoAgxBJGxqIAAoAgwgAygCDEEkbGoQ+gIgAyADKAIMQQFqNgIMDAELCyADQSBqJAALRQEBfyMAQRBrIgMkACADIAA2AgwgAyABNgIIIAMgAjYCBCADKAIMIgAgAygCCCADKAIEIAAoAgAoAigRBQAgA0EQaiQACzkBAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIgAgAigCCCAAKAIAKAIkEQIAIAJBEGokAAtpAQF/IwBBIGsiBiQAIAYgADYCHCAGIAE2AhggBiACNgIUIAYgAzgCECAGIAQ2AgwgBiAFNgIIIAYoAhwiACAGKAIYIAYoAhQgBioCECAGKAIMIAYoAgggACgCACgCIBEmACAGQSBqJAAL+wEBAX8jAEEgayIDJAAgAyAANgIcIAMgATYCGCADIAI2AhQjAEEQayIBIAMoAhwiADYCDCADIAEoAgwoAgQ2AhACQCADKAIYIAMoAhBIBEAgAyADKAIYNgIMA0AgAygCDCADKAIQSARAIAMgAygCDEEBajYCDAwBCwsMAQsgAygCGAJ/IwBBEGsiASAANgIMIAEoAgwoAgQLSgRAIAAgAygCGBCJAwsgAyADKAIQNgIIA0AgAygCCCADKAIYSARAIAAoAgwgAygCCEECdGogAygCFCgCADYCACADIAMoAghBAWo2AggMAQsLCyAAIAMoAhg2AgQgA0EgaiQAC1EBAX8jAEEQayIEJAAgBCAANgIMIAQgATYCCCAEIAI2AgQgBCADNgIAIAQoAgwiACAEKAIIIAQoAgQgBCgCACAAKAIAKAIIEQQAIARBEGokAAutAQECfyMAQSBrIgMkACADIAE2AhwgAyACNgIYIANBCGoiBCADKAIYAn8jAEEQayIBIAMoAhwiAjYCDCABQQA2AgggASgCDCABKAIIQQR0agsCfyMAQRBrIgEgAjYCDCABQQE2AgggASgCDCABKAIIQQR0agsCfyMAQRBrIgEgAjYCDCABQQI2AgggASgCDCABKAIIQQR0agsQ6wUgACAEIAJBMGoQFCADQSBqJAALWQEBfyMAQdAAayIDJAAgAyAANgJMIAMgATYCSCADIAI2AkQgA0EQaiIBIAMoAkgiAiADKAJEEOwFIAMgAiADKAJEQTBqEIIDIAAgASADEJYCIANB0ABqJAALeAEBfyMAQSBrIgMgADYCHCADQQA2AhggAyABNgIUIAMgAjYCECADKAIcIQAgAyADKAIYNgIMA0AgAygCDCADKAIUSARAIAMoAhAgAygCDEECdGogACgCDCADKAIMQQJ0aioCADgCACADIAMoAgxBAWo2AgwMAQsLC6sBAQF/IwBBIGsiAyQAIAMgADYCHCADQQA2AhggAyABNgIUIAMgAjYCECADKAIcIQEgAyADKAIYNgIMA0AgAygCDCADKAIUSARAIAMoAhAgAygCDEEEdGohAiMAQRBrIgBBEDYCDCAAIAI2AgggACgCCCIAIAEoAgwgAygCDEEEdGoiAikCADcCACAAIAIpAgg3AgggAyADKAIMQQFqNgIMDAELCyADQSBqJAALUQEBfyMAQRBrIgIkACACIAA2AgggAiABNgIEIAIoAgghAAJAIAIoAgQEQCACIAAgAigCBBD0BTYCDAwBCyACQQA2AgwLIAJBEGokACACKAIMC7EBAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AggCfyMAQRBrIgEgAigCDCIANgIMIAEoAgwoAgggAigCCEgLBEAgAiAAIAIoAggQhgM2AgQgAAJ/IwBBEGsiASAANgIMIAEoAgwoAgQLIAIoAgQQhAMgAAJ/IwBBEGsiASAANgIMIAEoAgwoAgQLEHIgABBQIABBAToAECAAIAIoAgQ2AgwgACACKAIINgIICyACQRBqJAALsQEBAX8jAEEQayICJAAgAiAANgIMIAIgATYCCAJ/IwBBEGsiASACKAIMIgA2AgwgASgCDCgCCCACKAIISAsEQCACIAAgAigCCBDyBTYCBCAAAn8jAEEQayIBIAA2AgwgASgCDCgCBAsgAigCBBCFAyAAAn8jAEEQayIBIAA2AgwgASgCDCgCBAsQciAAEFAgAEEBOgAQIAAgAigCBDYCDCAAIAIoAgg2AggLIAJBEGokAAuxAQEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIAn8jAEEQayIBIAIoAgwiADYCDCABKAIMKAIIIAIoAghICwRAIAIgACACKAIIEIYDNgIEIAACfyMAQRBrIgEgADYCDCABKAIMKAIECyACKAIEEIUCIAACfyMAQRBrIgEgADYCDCABKAIMKAIECxByIAAQUCAAQQE6ABAgACACKAIENgIMIAAgAigCCDYCCAsgAkEQaiQAC6IBAQF/IwBBIGsiBCAANgIcIAQgATYCGCAEIAI2AhQgBCADOAIQIAQoAhwhACAEQwAAgD8gBCoCEJM4AgwgACAEKgIMIAQoAhgqAgCUIAQqAhAgBCgCFCoCAJSSOAIAIAAgBCoCDCAEKAIYKgIElCAEKgIQIAQoAhQqAgSUkjgCBCAAIAQqAgwgBCgCGCoCCJQgBCoCECAEKAIUKgIIlJI4AggL7wEBAn8jAEEQayICJAAgAiAANgIMIAIgATYCCCMAQRBrIgEgAigCDCIANgIMIAIgASgCDCgCBDYCBCACKAIEAn8jAEEQayIBIAA2AgwgASgCDCgCCAtGBEAgAAJ/IwBBEGsiASAANgIMIAEoAgwoAgQhAyMAQRBrIgEgADYCDCABIAM2AgggASgCCEEBdEEBIAEoAggbCxCIAwsgACgCDCAAKAIEQQR0aiEDIwBBEGsiAUEQNgIMIAEgAzYCCCABKAIIIgEgAigCCCIDKQIANwIAIAEgAykCCDcCCCAAIAAoAgRBAWo2AgQgAkEQaiQAC1MBAX8jAEEQayIBJAAgASAANgIMIAEoAgwiAEGwCTYCACAAQfAAahA5IABB3ABqEDkgAEHIAGoQOSAAQRRqEDkjAEEQayAANgIMIAFBEGokACAACwQAQQQLBABBAwsEAEECCwQAQQELagEBfyMAQRBrIgIgADYCDCACIAE2AgggAigCDCIAIAAqAgAgAigCCCoCAJQ4AgAgACAAKgIEIAIoAggqAgCUOAIEIAAgACoCCCACKAIIKgIAlDgCCCAAIAAqAgwgAigCCCoCAJQ4AgwgAAtHAQF/IwBBEGsiAyQAIAMgADYCDCADIAE2AgggAyACOwEGIAMoAgwiACADKAIIIAMuAQZBfyAAKAIAKAIkEQQAIANBEGokAAtKAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDCEAIAJDAACAPyACKAIIKgIAlTgCBCAAIAJBBGoQkQMhACACQRBqJAAgAAsYAQF/IwBBEGsiASAANgIMIAEoAgwqAhALWQEDfyMAQeAAayICJAAgAiAANgJcIAIgATYCWCACQShqIgEgAigCWCIDEOwGIAJBCGoiBCADQTBqEFsgAkEYaiIDIAEgBBARIAAgASADEJYCIAJB4ABqJAALywUBAX8jAEHwAGsiAiQAIAIgADYCbCACIAE2AmggAigCbCEAIAIgAigCaBBaOAJkIAJDAAAAQCACKgJklTgCYCMAQRBrIgEgAigCaDYCDCACIAEoAgwqAgAgAioCYJQ4AlwjAEEQayIBIAIoAmg2AgwgAiABKAIMQQRqKgIAIAIqAmCUOAJYIwBBEGsiASACKAJoNgIMIAIgASgCDEEIaioCACACKgJglDgCVCMAQRBrIgEgAigCaDYCDCACIAEoAgxBDGoqAgAgAioCXJQ4AlAjAEEQayIBIAIoAmg2AgwgAiABKAIMQQxqKgIAIAIqAliUOAJMIwBBEGsiASACKAJoNgIMIAIgASgCDEEMaioCACACKgJUlDgCSCMAQRBrIgEgAigCaDYCDCACIAEoAgwqAgAgAioCXJQ4AkQjAEEQayIBIAIoAmg2AgwgAiABKAIMKgIAIAIqAliUOAJAIwBBEGsiASACKAJoNgIMIAIgASgCDCoCACACKgJUlDgCPCMAQRBrIgEgAigCaDYCDCACIAEoAgxBBGoqAgAgAioCWJQ4AjgjAEEQayIBIAIoAmg2AgwgAiABKAIMQQRqKgIAIAIqAlSUOAI0IwBBEGsiASACKAJoNgIMIAIgASgCDEEIaioCACACKgJUlDgCMCACQwAAgD8gAioCOCACKgIwkpM4AiwgAiACKgJAIAIqAkiTOAIoIAIgAioCPCACKgJMkjgCJCACIAIqAkAgAioCSJI4AiAgAkMAAIA/IAIqAkQgAioCMJKTOAIcIAIgAioCNCACKgJQkzgCGCACIAIqAjwgAioCTJM4AhQgAiACKgI0IAIqAlCSOAIQIAJDAACAPyACKgJEIAIqAjiSkzgCDCAAIAJBLGogAkEoaiACQSRqIAJBIGogAkEcaiACQRhqIAJBFGogAkEQaiACQQxqEKIBIAJB8ABqJAALPQEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAgwiACACKAIIQQFBfyAAKAIAKAIkEQQAIAJBEGokAAsZAQF/IwBBEGsiASAANgIMIAEoAgxB3ABqCzUBAX8jAEEQayICIAA2AgwgAiABNgIIIAIoAgwiACACKAIIIgEpAgA3AhggACABKQIINwIgCzUBAX8jAEEQayICIAA2AgwgAiABNgIIIAIoAgwiACACKAIIIgEpAgA3AgggACABKQIINwIQCyQBAX8jAEEQayICIAA2AgwgAiABOAIIIAIoAgwgAioCCDgCKAsYAQF/IwBBEGsiASAANgIMIAEoAgwqAigLJAEBfyMAQRBrIgIgADYCDCACIAE2AgggAigCDCACKAIINgJYCxgBAX8jAEEQayIBIAA2AgwgASgCDEEcags1AQF/IwBBEGsiAiAANgIMIAIgATYCCCACKAIMIgAgAigCCCIBKQIANwJEIAAgASkCCDcCTAsZAQF/IwBBEGsiASAANgIMIAEoAgxBxABqCzUBAX8jAEEQayICIAA2AgwgAiABNgIIIAIoAgwiACACKAIIIgEpAgA3AjQgACABKQIINwI8CxgBAX8jAEEQayIBIAA2AgwgASgCDEE0ags1AQF/IwBBEGsiAiAANgIMIAIgATYCCCACKAIMIgAgAigCCCIBKQIANwIkIAAgASkCCDcCLAsYAQF/IwBBEGsiASAANgIMIAEoAgxBJGoLsQEBAX8jAEEQayICJAAgAiAANgIMIAIgATYCCAJ/IwBBEGsiASACKAIMIgA2AgwgASgCDCgCCCACKAIISAsEQCACIAAgAigCCBDHBTYCBCAAAn8jAEEQayIBIAA2AgwgASgCDCgCBAsgAigCBBD4AiAAAn8jAEEQayIBIAA2AgwgASgCDCgCBAsQciAAEFAgAEEBOgAQIAAgAigCBDYCDCAAIAIoAgg2AggLIAJBEGokAAvFAQECfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIwBBEGsiASACKAIMIgA2AgwgAiABKAIMKAIENgIEIAIoAgQCfyMAQRBrIgEgADYCDCABKAIMKAIIC0YEQCAAAn8jAEEQayIBIAA2AgwgASgCDCgCBCEDIwBBEGsiASAANgIMIAEgAzYCCCABKAIIQQF0QQEgASgCCBsLEKUDCyAAKAIMIAAoAgRB4ABsaiACKAIIEJACIAAgACgCBEEBajYCBCACQRBqJAALSwEDfyMAQRBrIgEkACABIAA2AgggASABKAIIIgA2AgwgAEEwaiECA0AjAEEQayAANgIMIABBEGoiAyEAIAIgA0cNAAsgAUEQaiQAC0MBAX8jAEEQayIBJAAgASAANgIMIwBBEGsgASgCDCIAQQRqNgIMIABBHGoQpwMjAEEQayAAQcwAajYCDCABQRBqJAALGAEBfyMAQRBrIgEgADYCDCABKAIMKAJYCyQBAX8jAEEQayICIAA2AgwgAiABOAIIIAIoAgwgAioCCDgCGAsYAQF/IwBBEGsiASAANgIMIAEoAgwqAhgLJAEBfyMAQRBrIgIgADYCDCACIAE2AgggAigCDCACKAIINgIUCxgBAX8jAEEQayIBIAA2AgwgASgCDCgCFAtSAQF/IwBBIGsiBSQAIAUgADYCHCAFIAE4AhggBSACOAIUIAUgAzgCECAFIAQ4AgwgBSgCHCAFQRhqIAVBFGogBUEQaiAFQQxqEHcgBUEgaiQACyQBAX8jAEEQayICIAA2AgwgAiABOAIIIAIoAgwgAioCCDgCFAsYAQF/IwBBEGsiASAANgIMIAEoAgwqAhQLJAEBfyMAQRBrIgIgADYCDCACIAE4AgggAigCDCACKgIIOAIQC2MBAX8jAEEgayIGJAAgBiAANgIcIAYgATgCGCAGIAI4AhQgBiADOAIQIAYgBDgCDCAGIAU4AgggBigCHEGwBWogBioCGCAGKgIUIAYqAhAgBioCDCAGKgIIELgOIAZBIGokAAsjAQF/IwBBEGsiASQAIAEgADYCDCABKAIMEJcBIAFBEGokAAtXAQJ/IwBBMGsiAiQAIAIgADYCLCACIAE2AiggAkEIaiIBIAIoAiggAigCLCIAQdwCahBRIAJBGGoiAyABIABB2AJqECEgAEG4AmogAxA/GiACQTBqJAALVwECfyMAQTBrIgIkACACIAA2AiwgAiABNgIoIAJBCGoiASACKAIsIgBBiAJqIAIoAigQESACQRhqIgMgASAAQaAEahBRIABByAJqIAMQPxogAkEwaiQAC0YBAX8jAEEgayICJAAgAiAANgIcIAIgATYCGCACQQhqIgAgAigCGCACKAIcIgFB3AJqEFEgAUGcA2ogABA/GiACQSBqJAALRgEBfyMAQSBrIgIkACACIAA2AhwgAiABNgIYIAJBCGoiACACKAIYIAIoAhwiAUGgBGoQUSABQawDaiAAED8aIAJBIGokAAsZAQF/IwBBEGsiASAANgIMIAEoAgxByABqCzUBAX8jAEEQayICIAA2AgwgAiABNgIIIAIoAgwiACACKAIIIgEpAgA3AjggACABKQIINwJACxgBAX8jAEEQayIBIAA2AgwgASgCDEE4agsYAQF/IwBBEGsiASAANgIMIAEoAgxBFGoLRQEBfyMAQRBrIgEgADYCDCABKAIMIgBBtAo2AgAgAEMAAIA/OAIEIABBADYCCCAAQQE7AQwgAEH//wM7AQ4gAEEANgIQC/sBAQF/IwBBIGsiBSQAIAUgADYCHCAFIAE4AhggBSACNgIUIAUgAzYCECAFIAQ2AgwgBSgCHCIAIAUqAhg4AgAgACAFKAIUNgIEIABBCGoQmwEgACAFKAIQNgJIIAAgBSgCDCICKQIANwJMIAAgAikCCDcCVCAAQwAAAAA4AlwgAEMAAAAAOAJgIABDAAAAPzgCZCAAQwAAAAA4AmggAEMAAAAAOAJsIABDzcxMPzgCcCAAQwAAgD84AnQgAEEAOgB4IABDCtejOzgCfCAAQwrXIzw4AoABIABDCtcjPDgChAEgAEMK1yM8OAKIASAAQQhqEJ4CIAVBIGokAAskAQF/IwBBEGsiAiAANgIMIAIgATgCCCACKAIMIAIqAgg4AkwLGAEBfyMAQRBrIgEgADYCDCABKAIMKgJMCyQBAX8jAEEQayICIAA2AgwgAiABOAIIIAIoAgwgAioCCDgCSAsYAQF/IwBBEGsiASAANgIMIAEoAgwqAkgLJAEBfyMAQRBrIgIgADYCDCACIAE4AgggAigCDCACKgIIOAJECxgBAX8jAEEQayIBIAA2AgwgASgCDCoCRAskAQF/IwBBEGsiAiAANgIMIAIgATgCCCACKAIMIAIqAgg4AkALGAEBfyMAQRBrIgEgADYCDCABKAIMKgJACyQBAX8jAEEQayICIAA2AgwgAiABOAIIIAIoAgwgAioCCDgCPAsYAQF/IwBBEGsiASAANgIMIAEoAgwqAjwLJAEBfyMAQRBrIgIgADYCDCACIAE4AgggAigCDCACKgIIOAI4CxgBAX8jAEEQayIBIAA2AgwgASgCDCoCOAskAQF/IwBBEGsiAiAANgIMIAIgATgCCCACKAIMIAIqAgg4AjQLGAEBfyMAQRBrIgEgADYCDCABKAIMKgI0CyQBAX8jAEEQayICIAA2AgwgAiABOAIIIAIoAgwgAioCCDgCMAsYAQF/IwBBEGsiASAANgIMIAEoAgwqAjALNQEBfyMAQRBrIgIgADYCDCACIAE2AgggAigCDCIAIAIoAggiASkCADcCICAAIAEpAgg3AigLGAEBfyMAQRBrIgEgADYCDCABKAIMQSBqCyQBAX8jAEEQayICIAA2AgwgAiABOAIIIAIoAgwgAioCCDgCJAsYAQF/IwBBEGsiASAANgIMIAEoAgwqAiQLJAEBfyMAQRBrIgIgADYCDCACIAE4AgggAigCDCACKgIIOAIcCxgBAX8jAEEQayIBIAA2AgwgASgCDCoCHAt5AQN/IwBBEGsiASQAIAFBCjoADwJAIAAoAhAiAkUEQCAAENUDDQEgACgCECECCwJAIAAoAhQiAyACTw0AIAAsAEtBCkYNACAAIANBAWo2AhQgA0EKOgAADAELIAAgAUEPakEBIAAoAiQRBwBBAUcNAAsgAUEQaiQAC1kBAX8gACAALQBKIgFBf2ogAXI6AEogACgCACIBQQhxBEAgACABQSByNgIAQX8PCyAAQgA3AgQgACAAKAIsIgE2AhwgACABNgIUIAAgASAAKAIwajYCEEEAC1IBAX8gACgCBCEEIAAoAgAiACABAn9BACACRQ0AGiAEQQh1IgEgBEEBcUUNABogAigCACABaigCAAsgAmogA0ECIARBAnEbIAAoAgAoAhwRBAALKgEBfyMAQRBrIgEkACABQQA2AgxByM4BKAIAIgEgABCyCiABELYKEAgAC9wCAgJ/A30gALwiAkH/////B3EiAUGAgIDkBEkEQAJAAn8gAUH////2A00EQEF/IAFBgICAzANPDQEaDAILIACLIQAgAUH//9/8A00EQCABQf//v/kDTQRAIAAgAJJDAACAv5IgAEMAAABAkpUhAEEADAILIABDAACAv5IgAEMAAIA/kpUhAEEBDAELIAFB///vgARNBEAgAEMAAMC/kiAAQwAAwD+UQwAAgD+SlSEAQQIMAQtDAACAvyAAlSEAQQMLIQEgACAAlCIEIASUIgMgA0NHEtq9lEOYyky+kpQhBSAEIAMgA0MlrHw9lEMN9RE+kpRDqaqqPpKUIQMgAUF/TARAIAAgACAFIAOSlJMPCyABQQJ0IgFB8M0BaioCACAAIAUgA5KUIAFBgM4BaioCAJMgAJOTIgCMIAAgAkEASBshAAsgAA8LIABD2g/JPyAAmCABQYCAgPwHSxsLggICA38BfCMAQRBrIgMkAAJAIAC8IgRB/////wdxIgJB2p+k7gRNBEAgASAAuyIFIAVEg8jJbTBf5D+iRAAAAAAAADhDoEQAAAAAAAA4w6AiBUQAAABQ+yH5v6KgIAVEY2IaYbQQUb6ioDkDACAFmUQAAAAAAADgQWMEQCAFqiECDAILQYCAgIB4IQIMAQsgAkGAgID8B08EQCABIAAgAJO7OQMAQQAhAgwBCyADIAIgAkEXdkHqfmoiAkEXdGu+uzkDCCADQQhqIAMgAhCoCiECIAMrAwAhBSAEQX9MBEAgASAFmjkDAEEAIAJrIQIMAQsgASAFOQMACyADQRBqJAAgAgukAgACQAJAIAFBFEsNACABQXdqIgFBCUsNAAJAAkACQAJAAkACQAJAAkAgAUEBaw4JAQIJAwQFBgkHAAsgAiACKAIAIgFBBGo2AgAgACABKAIANgIADwsgAiACKAIAIgFBBGo2AgAgACABNAIANwMADwsgAiACKAIAIgFBBGo2AgAgACABNQIANwMADwsgAiACKAIAIgFBBGo2AgAgACABMgEANwMADwsgAiACKAIAIgFBBGo2AgAgACABMwEANwMADwsgAiACKAIAIgFBBGo2AgAgACABMAAANwMADwsgAiACKAIAIgFBBGo2AgAgACABMQAANwMADwsgACACQZMHEQIACw8LIAIgAigCAEEHakF4cSIBQQhqNgIAIAAgASkDADcDAAtKAQN/IAAoAgAsAABBUGpBCkkEQANAIAAoAgAiASwAACEDIAAgAUEBajYCACADIAJBCmxqQVBqIQIgASwAAUFQakEKSQ0ACwsgAgt/AgF/AX4gAL0iA0I0iKdB/w9xIgJB/w9HBHwgAkUEQCABIABEAAAAAAAAAABhBH9BAAUgAEQAAAAAAADwQ6IgARDcAyEAIAEoAgBBQGoLNgIAIAAPCyABIAJBgnhqNgIAIANC/////////4eAf4NCgICAgICAgPA/hL8FIAALCxIAIABFBEBBAA8LIAAgARCzCgv5AwIJfwR+IwBBMGsiByQAAkAgAigCCCIIRQRADAELIAghCgNAIAooAhQgACgCZEoEQCAKKAIMIggoAlwhCyAIKAJgIQwgAigCWCENIAgoAlghCCACKAJcIQ4gAigCYCEPIAdBfzYCLCAHIAwgD2siDDYCKCAHIAsgDmsiCzYCJCAHIAggDWsiCDYCICALrCIQIAQpAwh+IAisIhIgBCkDAH58IAysIhMgBCkDEH58IRECfyAFKQMIIBB+IAUpAwAgEn58IAUpAxAgE358IhBCAVkEQCAHIBA3AwggB0EBNgIYQX8hC0F/DAELIBBCf1cEQCAHQX82AhggB0IAIBB9NwMIQQEhC0F/DAELIAdCADcDCCAHQQA2AhhBACELQQALIQgCQAJAAkAgByARQgBXBH4gEUJ/VQ0BIAcgCzYCGEIAIBF9BSARCzcDEAwBCyAHQgA3AxAgCEUNAQsgCUUEQCAGIAcpAwg3AwAgBiAHKAIYNgIQIAYgBykDEDcDCCAKIQkMAQsgB0EIaiAGEHkiCEF/TARAIAYgBykDCDcDACAGIAcoAhg2AhAgBiAHKQMQNwMIIAohCQwBCyAIDQAgCiAJIAkgCiADIAdBIGoQqAJBAkcgAXMbIQkLIAIoAgghCAsgCigCACIKIAhHDQALCyAHQTBqJAAgCQv3FAITfwx+IwBBMGsiBSQAIAEhCCADKAIAIgoEQCAKKAIMIQgLIAgoAmAhDiAIKAJcIQ8gCCgCWCEIIAIhBiAEKAIAIhAEQCAQKAIMIQYLIAogECAKGygCDCIJKAJcIAEoAlwiC2siByACKAJgIAEoAmAiDGsiEWwgCSgCYCAMayINIAIoAlwgC2siEmxrrCIgIBGsIhh+IAkoAlggASgCWCIBayIJIBJsIAcgAigCWCABayITbGusIiEgE6wiGX59Ih0gD6x+ICEgEqwiG34gDSATbCAJIBFsa6wiIiAYfn0iHiAIrH58IBkgIn4gGyAgfn0iHyAOrH58IRggICABrH4gISAMrH58ICIgC6x+fCEcIAYoAmAhCSAGKAJcIQsgBigCWCEMAn8gECAKRQ0AGiAQIAooAgxFDQAaAkAgCigCCCgCBCIBKAIMIgI0AlwiGSAifiACNAJYIhsgIH58IAI0AmAiGiAhfnwgHFMNACABQQxqIQYgACgCZCEHA0AgASgCFCAHRg0BIBkgHX4gGyAefnwgGiAffnwiGSAYVw0BIAMgATYCACAGKAIAIgIoAmAhDiACKAJcIQ8gAigCWCEIIAIEQCABKAIIKAIEIgFBDGohBiAZIRggASgCDCICNAJcIhkgIn4gAjQCWCIbICB+fCACNAJgIhogIX58IBxTDQIMAQsLIBkhGAsgBCgCAAshASAdIAusfiAeIAysfnwgHyAJrH58IRkCQCABRQRAQQAhAQwBCyABKAIMRQ0AIAEoAggoAgAiBigCDCICNAJcIhsgIn4gAjQCWCIaICB+fCACNAJgIiMgIX58IBxTDQAgBkEMaiEHIAAoAmQhDQNAIAYiAigCFCANRg0BIBsgHX4gGiAefnwgHyAjfnwiGyAZVw0BIAQgAjYCACAHKAIAIgEoAmAhCSABKAJcIQsgASgCWCEMIAEEQCACKAIIKAIAIgZBDGohByAbIRkgAiEBIAYoAgwiAjQCXCIbICJ+IAI0AlgiGiAgfnwgAjQCYCIjICF+fCAcUw0CDAELCyACIQEgGyEZCwJAIBkgGH0iGEIBWQRAA0AgCyAPayASbCAMIAhrIBNsaiAJIA5rIBFsaiIQrCEbAkAgAygCACINRQ0AIA0oAgxFDQAgDSgCACgCCCIUKAIUIAAoAmRMDQAgFCgCDCIGKAJcIgEgD2siFSASbCAGKAJYIgIgCGsiFiATbGogBigCYCIGIA5rIhcgEWxqIQcCQCAdIBWsfiAeIBasfnwgHyAXrH58IhlQBEAgB0EASA0BDAILIBlCf1UNASAHrCEaIAUCfyAHQQFOBEAgBSAaNwMYIAVBATYCKEF/DAELIAdBf0wEQCAFQX82AiggBUIAIBp9NwMYQQEMAQsgBUIANwMYIAVBADYCKEEACzYCKCAFQgAgGX03AyACfyAQQQFOBEAgBSAbNwMAIAVBATYCEEF/DAELIBBBf0wEQCAFQX82AhAgBUIAIBt9NwMAQQEMAQsgBUIANwMAIAVBADYCEEEACyEHIAUCfiAYIBhCAFUNABpCACAYQn9VDQAaIAUgBzYCEEIAIBh9CzcDCCAFQRhqIAUQeUF/TA0BCyADQQAgFCAKIA1GGzYCACAdIAsgAWusfiAeIAwgAmusfnwgHyAJIAZrrH58IRggAiEIIAEhDyAGIQ4MAQsgBCgCACIBRQ0CIAEoAgxFDQIgASgCCCgCACICKAIUIAAoAmRMDQIgAigCDCIBKAJcIgYgC2siC6wiGiAifiABKAJYIgcgDGsiDKwiHCAgfnxCACAhIAEoAmAiASAJayIJrCIjfn1SDQIgHSAGIA9rrH4gHiAHIAhrrH58IB8gASAOa6x+fCIZQgFTDQIgCyASbCAMIBNsaiAJIBFsaiEBAkAgGiAdfiAcIB5+fCAfICN+fCIaUARAIAFBAEgNAQwECyAaQn9VDQMgAawhHCAFAn8gAUEBTgRAIAUgHDcDGCAFQQE2AihBfwwBCyABQX9MBEAgBUF/NgIoIAVCACAcfTcDGEEBDAELIAVCADcDGCAFQQA2AihBAAs2AiggBUIAIBp9NwMgAn8gEEEBTgRAIAUgGzcDACAFQQE2AhBBfwwBCyAQQX9MBEAgBUF/NgIQIAVCACAbfTcDAEEBDAELIAVCADcDACAFQQA2AhBBAAshASAFAn4gGCAYQgBVDQAaQgAgGEJ/VQ0AGiAFIAE2AhBCACAYfQs3AwggBUEYaiAFEHlBAEwNAwsgBCACNgIAIAIoAgwiASgCYCEJIAEoAlwhCyABKAJYIQwgGSEYDAAACwALIBhCf1UNAANAIAsgD2sgEmwgDCAIayATbGogCSAOayARbGoiB6whGwJAIAFFDQAgASgCDEUNACABKAIEKAIIIhQoAhQgACgCZEwNACAUKAIMIgooAlwiAiALayIVIBJsIAooAlgiBiAMayIWIBNsaiAKKAJgIgogCWsiFyARbGohDQJAIB0gFax+IB4gFqx+fCAfIBesfnwiGVAEQCANQQBKDQEMAgsgGUJ/VQ0BIA2sIRogBQJ/IA1BAU4EQCAFIBo3AxggBUEBNgIoQX8MAQsgDUF/TARAIAVBfzYCKCAFQgAgGn03AxhBAQwBCyAFQgA3AxggBUEANgIoQQALNgIoIAVCACAZfTcDIAJ/IAdBAU4EQCAFIBs3AwAgBUEBNgIQQX8MAQsgB0F/TARAIAVBfzYCECAFQgAgG303AwBBAQwBCyAFQgA3AwAgBUEANgIQQQALIQ0gBQJ+IBggGEIAVQ0AGkIAIBhCf1UNABogBSANNgIQQgAgGH0LNwMIIAVBGGogBRB5QQFODQELIARBACAUIAEgEEYbIgE2AgAgHSACIA9rrH4gHiAGIAhrrH58IB8gCiAOa6x+fCEYIAYhDCACIQsgCiEJDAELIAMoAgAiAUUNASABKAIMRQ0BIAEoAggoAgQiAigCFCAAKAJkTA0BIAIoAgwiASgCXCIGIA9rIg+sIhogIn4gASgCWCIKIAhrIgisIhwgIH58QgAgISABKAJgIgEgDmsiDqwiI359Ug0BIB0gCyAGa6x+IB4gDCAKa6x+fCAfIAkgAWusfnwiGUJ/VQ0BIA8gEmwgCCATbGogDiARbGohAQJAIBogHX4gHCAefnwgHyAjfnwiGlAEQCABQQBMDQMMAQsgGkJ/VQ0CIAGsIRwgBQJ/IAFBAU4EQCAFIBw3AxggBUEBNgIoQX8MAQsgAUF/TARAIAVBfzYCKCAFQgAgHH03AxhBAQwBCyAFQgA3AxggBUEANgIoQQALNgIoIAVCACAafTcDIAJ/IAdBAU4EQCAFIBs3AwAgBUEBNgIQQX8MAQsgB0F/TARAIAVBfzYCECAFQgAgG303AwBBAQwBCyAFQgA3AwAgBUEANgIQQQALIQEgBQJ+IBggGEIAVQ0AGkIAIBhCf1UNABogBSABNgIQQgAgGH0LNwMIIAVBGGogBRB5QQBODQILIAMgAjYCACACKAIMIgIoAmAhDiACKAJcIQ8gBCgCACEBIAIoAlghCCAZIRgMAAALAAsgBUEwaiQAC94QAgF/Hn0gASAAKQIANwIAIAEgACkCCDcCCCABIAApAhg3AhggASAAKQIQNwIQIAEgACkCIDcCICABIAApAig3AiggACoCCCEFIAAqAhQhByAAKgIoIQsgACoCGCEIIAAqAiQhCSAAKgIEIQogACoCICEMIAAqAhAhDSAAKgIAIQYgAkEANgIsIAJBADYCHCACQQA2AgwgAiAJIAWUIAsgCpSTQwAAgD8gBiAHIAuUIAggCZSTIg6UIAogCCAMlCALIA2UkyIPlJIgBSAJIA2UIAcgDJSTIhCUkpUiBJQiETgCBCACIAggCpQgByAFlJMgBJQiEjgCCCACIA8gBJQiDzgCECACIAsgBpQgDCAFlJMgBJQiEzgCFCACIA0gBZQgCCAGlJMgBJQiFDgCGCACIBAgBJQiEDgCICACIAwgCpQgCSAGlJMgBJQiFTgCJCACIAcgBpQgDSAKlJMgBJQiFjgCKCACIA4gBJQiDjgCAAJAAkBB5NkBKAIARQ0AA0AgDosiBCAPiyIFkiAQiyIKkiIGIBGLIgcgE4siC5IgFYsiCJIiCSAGIAleGyIGIBKLIgkgFIsiDJIgFosiDZIiFyAGIBdeGyAEIAeSIAmSIgQgBSALkiAMkiIFIAQgBV4bIgQgCiAIkiANkiIFIAQgBV4blCIFQwAAADRdDQEgASoCACIXiyIHIAEqAhAiCosiCJIgASoCICIGiyINkiIEIAEqAgQiGIsiGiABKgIUIgyLIhuSIAEqAiQiC4siHJIiCSAEIAleGyIdIAEqAggiGYsiHiABKgIYIgmLIh+SIAEqAigiBIsiIJIiISAdICFeGyIdIAcgGpIgHpIiByAIIBuSIB+SIgggByAIXhsiByANIBySICCSIgggByAIXhuUIgdDAAAANF0NASABQQA2AiwgAUEANgIcIAFBADYCDCABIAQgBCAFIAeVQwAAgD4QpAIiBUMAAADAkiIElEMAAIA/IAWVIgUgFpSSQwAAAD+UIhqSIgc4AiggASALIAsgBJQgBSAUlJJDAAAAP5QiG5IiCzgCJCABIAYgBiAElCAFIBKUkkMAAAA/lCIckiIIOAIgIAEgCSAJIASUIAUgFZSSQwAAAD+UIh6SIgk4AhggASAMIAwgBJQgBSATlJJDAAAAP5QiH5IiDDgCFCABIAogCiAElCAFIBGUkkMAAAA/lCIgkiINOAIQIAEgGSAZIASUIAUgEJSSQwAAAD+UIhmSIgo4AgggASAYIBggBJQgBSAPlJJDAAAAP5QiGJIiBjgCBCABIBcgFyAElCAFIA6UkkMAAAA/lCIXkiIFOAIAIAJBADYCLCACQQA2AhwgAkEANgIMIAIgBSAMlCAGIA2Uk0MAAIA/IAogDSALlCAMIAiUkyIRlCAFIAwgB5QgCSALlJMiDpQgBiAJIAiUIA0gB5STIhKUkpKVIgSUIhY4AiggAiAGIAiUIAUgC5STIASUIhU4AiQgAiARIASUIhA4AiAgAiAKIA2UIAUgCZSTIASUIhQ4AhggAiAFIAeUIAogCJSTIASUIhM4AhQgAiASIASUIg84AhAgAiAGIAmUIAogDJSTIASUIhI4AgggAiAKIAuUIAYgB5STIASUIhE4AgQgAiAOIASUIg44AgAgF4sgIIuSIByLkiIEIBiLIB+LkiAbi5IiBSAEIAVeGyIEIBmLIB6LkiAai5IiBSAEIAVeGyAdQeDZASoCAJRfDQIgA0EBaiIDQeTZASgCAEkNAAsLIAEqAiQhBCABKgIUIQUgASoCKCEKIAEqAhghBiABKgIEIQcgACoCJCELIAAqAhQhCCAAKgIEIQkgACoCKCEMIAAqAhghDSAAKgIIIREgASoCCCESIAAqAiAhDyABKgIgIRMgACoCACEUIAEqAgAhECAAKgIQIRUgASoCECEWIAJBADYCLCACQQA2AhwgAkEANgIMIAIgECAUlCAWIBWUkiATIA+UkiIOIA6SQwAAAD+UOAIAIAIgEiARlCAGIA2UkiAKIAyUkiIOIA6SQwAAAD+UOAIoIAIgByARlCAFIA2UkiAEIAyUkiASIAmUIAYgCJSSIAogC5SSkkMAAAA/lCIOOAIkIAIgECARlCAWIA2UkiATIAyUkiASIBSUIAYgFZSSIAogD5SSkkMAAAA/lCIKOAIgIAIgDjgCGCACIAcgCZQgBSAIlJIgBCALlJIiBiAGkkMAAAA/lDgCFCACIBAgCZQgFiAIlJIgEyALlJIgByAUlCAFIBWUkiAEIA+UkpJDAAAAP5QiBDgCECACIAo4AgggAiAEOAIEDwsgASoCICEEIAEqAgAhBSABKgIQIQogACoCICEGIAAqAgAhByAAKgIQIQsgASoCJCEIIAEqAgQhCSABKgIUIQwgACoCJCENIAAqAgQhESAAKgIUIRIgACoCKCEPIAEqAighEyAAKgIIIRQgASoCCCEQIAAqAhghFSABKgIYIRYgAkEANgIsIAJBADYCHCACQQA2AgwgAiAQIBSUIBYgFZSSIBMgD5SSIg4gDpJDAAAAP5Q4AiggAiAJIBSUIAwgFZSSIAggD5SSIBAgEZQgFiASlJIgEyANlJKSQwAAAD+UIg44AiQgAiAFIBSUIAogFZSSIAQgD5SSIBAgB5QgFiALlJIgEyAGlJKSQwAAAD+UIg84AiAgAiAOOAIYIAIgCSARlCAMIBKUkiAIIA2UkiITIBOSQwAAAD+UOAIUIAIgBSARlCAKIBKUkiAEIA2UkiAJIAeUIAwgC5SSIAggBpSSkkMAAAA/lCIIOAIQIAIgDzgCCCACIAg4AgQgAiAFIAeUIAogC5SSIAQgBpSSIgQgBJJDAAAAP5Q4AgALwgEBAX8gACgCDARAIABBADYCBCAAKAIUIgEEQCAALQAYBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AhQLIABBADYCFCAAQgA3AgwgAEEBOgAYCyAAKAIoBEAgAEEANgIgIAAoAjAiAQRAIAAtADQEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYCMAsgAEEANgIwIABCADcCKCAAQQE6ADQLC5ERAgx/A30jAEHQAGsiAyQAIANBADYCREEBIQYgA0EBOgBIIANCADcCPCADQgA3AzAgA0IANwMoAkAgACABKAIEIgRBCCAEQQhLGyIHQQFOBH9B6PcBQej3ASgCAEEBajYCACAHQQR0QRBBjNIBKAIAEQMAIQsDQCALIAhBBHRqIgQgAykCGDcCACAEIAMpAiA3AgggCEEBaiIIIAdHDQALIAEoAgQFIAQLIAEoAgggASgCDCADQRRqIAsgASoCECADQRhqEL0KRQ0AIAMoAhQiBARAIAMqAiAhDyADKgIcIRAgAyoCGCERA0AgCyAFQQR0aiIHIBEgByoCAJQ4AgAgByAQIAcqAgSUOAIEIAcgDyAHKgIIlDgCCCAFQQFqIgUgBEcNAAsLIAAgCyAEIANBOGogA0EEaiABKAIUEL4KRQ0AIAMgCzYCNCADIAMoAgQiCjYCMCADIApBA2wiCTYCLCADIAQ2AiggBEEBTgRAQQAhCEHo9wFB6PcBKAIAQQFqNgIAIARBBHRBEEGM0gEoAgARAwAhDQNAIA0gCEEEdGoiBiADKQIENwIAIAYgAykCDDcCCCAIQQFqIgggBEcNAAsLIAAgCyAEIA0gA0EUaiADKAJEIgggCRC8CgJAAkACQAJAIAEtAABBAXEEQCACQQA6AAAgAiADKAIUIgQ2AgQgAigCDCIFIARIBEAgAigCECAESARAAn8gBEUEQEEAIQAgBQwBC0Ho9wFB6PcBKAIAQQFqNgIAIARBBHRBEEGM0gEoAgARAwAhACACKAIMCyIHQQFOBEBBACEGA0AgACAGQQR0IgxqIg4gAigCFCAMaiIMKQIANwIAIA4gDCkCCDcCCCAGQQFqIgYgB0cNAAsLIAIoAhQiBgRAIAItABgEQCAGBEBB7PcBQez3ASgCAEEBajYCACAGQZDSASgCABEAAAsLIAJBADYCFAsgAiAANgIUIAIgBDYCECACQQE6ABgLA0AgAigCFCAFQQR0aiIAIAMpAgQ3AgAgACADKQIMNwIIIAVBAWoiBSAERw0ACwsgAiAENgIMIAIgCTYCICACIAo2AhwgAigCKCIHIAlODQMgAigCLCAJTgRAIAIoAjAhAAwDC0EAIQUgByEGQQAhACAKBEBB6PcBQej3ASgCAEEBajYCACAKQQxsQRBBjNIBKAIAEQMAIQAgAigCKCEGCyACKAIwIQQgBkEBTgRAA0AgACAFQQJ0IgxqIAQgDGooAgA2AgAgBUEBaiIFIAZHDQAMAwALAAsgBA0BIAIgADYCMCACIAk2AiwgAkEBOgA0DAILIAJBAToAACACIAMoAhQiBDYCBCACKAIMIgUgBEgEQCACKAIQIARIBEACfyAERQRAQQAhByAFDAELQej3AUHo9wEoAgBBAWo2AgAgBEEEdEEQQYzSASgCABEDACEHIAIoAgwLIgBBAU4EQEEAIQYDQCAHIAZBBHQiCWoiDCACKAIUIAlqIgkpAgA3AgAgDCAJKQIINwIIIAZBAWoiBiAARw0ACwsgAigCFCIABEAgAi0AGARAIAAEQEHs9wFB7PcBKAIAQQFqNgIAIABBkNIBKAIAEQAACwsgAkEANgIUCyACIAc2AhQgAiAENgIQIAJBAToAGAsDQCACKAIUIAVBBHRqIgAgAykCBDcCACAAIAMpAgw3AgggBUEBaiIFIARHDQALCyACIAQ2AgwgAiAKQQJ0Igk2AiAgAiAKNgIcIAkgAigCKCIESgRAAkAgAigCLCAJTgRAIAIoAjAhAAwBC0EAIQUgBCEGQQAhACAJBEBB6PcBQej3ASgCAEEBajYCACAKQQR0QRBBjNIBKAIAEQMAIQAgAigCKCEGCyACKAIwIQcCQCAGQQFOBEADQCAAIAVBAnQiDGogByAMaigCADYCACAFQQFqIgUgBkcNAAwCAAsACyAHDQAgAiAANgIwIAIgCTYCLCACQQE6ADQMAQsgAi0ANARAIAcEQEHs9wFB7PcBKAIAQQFqNgIAIAdBkNIBKAIAEQAACwsgAiAANgIwIAJBAToANCACIAk2AiwLIAAgBEECdGpBACAJIARrQQJ0EAsaCyACIAk2AiggAigCFCANIAMoAhRBBHQQFRogCkUNAyACKAIwIQVBACEGA0AgBUEDNgIAIAUCfyABLQAAQQJxBEAgBSAIKAIINgIEIAUgCCgCBDYCCCAIDAELIAUgCCgCADYCBCAFIAgoAgQ2AgggCEEIagsoAgA2AgwgCEEMaiEIIAVBEGohBSAGQQFqIgYgAygCMEkNAAsMAwsgAi0ANARAIAQEQEHs9wFB7PcBKAIAQQFqNgIAIARBkNIBKAIAEQAACwsgAiAANgIwIAJBAToANCACIAk2AiwLIAAgB0ECdCIGakEAIApBDGwgBmsQCxoLIAIgCTYCKCACKAIUIA0gAygCFEEEdBAVGiABLQAAQQJxBEAgCkUNASACKAIwIQVBACEGA0AgBSAIKAIINgIAIAUgCCgCBDYCBCAFIAgoAgA2AgggCEEMaiEIIAVBDGohBSAGQQFqIgYgAygCMEkNAAsMAQsgAigCMCAIIApBDGwQFRoLIAMoAjwEQCADKAJEIgAEQCADLQBIBEAgAARAQez3AUHs9wEoAgBBAWo2AgAgAEGQ0gEoAgARAAALCyADQQA2AkQLIANBADYCRCADQQE6AEggA0IANwI8C0EAIQYgA0EANgI0IANCADcDKCANRQ0AIA0EQEHs9wFB7PcBKAIAQQFqNgIAIA1BkNIBKAIAEQAACwsgCwRAIAsEQEHs9wFB7PcBKAIAQQFqNgIAIAtBkNIBKAIAEQAACwsgAygCRCIABEAgAy0ASARAIAAEQEHs9wFB7PcBKAIAQQFqNgIAIABBkNIBKAIAEQAACwsgA0EANgJECyADQdAAaiQAIAYLnwoBDX8gASgCACEJIAAoAgQhDCAAIAIgASgCBCIKIAEoAggiBRBfIQZBAiEDIAEoAgwhCCAGIAxBAmoiDjYCFCAGIAxBAWoiDzYCECAGIAg2AgwgACgCDCABKAIMQQJ0aigCACIIKAIEIQQCQAJAIAgoAgAiCyAKRkEAIAQgBUYbDQACQCAFIAtGQQAgBCAKRhsNACAIKAIIIQcgBCAKRgRAQQAhAyAFIAdGDQILIAQgBUYEQEEAIQMgByAKRg0BCyAHIApGBEBBASEDIAUgC0YNAgtBnNIBIQQgBSAHRw0CQQEhAyAKIAtHDQILIAggA0ECdGpBDGohBAwBCyAIIANBAnRqQQxqIQQLIAQgDDYCACAAIAIgBSAJEF8hCCABKAIQIQMgCCAMNgIUIAggDjYCECAIIAM2AgxBAiEEIAAoAgwgASgCEEECdGooAgAiBygCBCEDAkACQCAFIAcoAgAiDUZBACADIAlGGw0AAkAgCSANRkEAIAMgBUYbDQAgBygCCCELIAMgBUYEQEEAIQQgCSALRg0CCyADIAlGBEBBACEEIAUgC0YNAQsgBSALRgRAQQEhBCAJIA1GDQILQZzSASEDIAkgC0cNAkEBIQQgBSANRw0CCyAHIARBAnRqQQxqIQMMAQsgByAEQQJ0akEMaiEDCyADIA82AgAgACACIAkgChBfIQUgASgCFCEDIAUgDzYCFCAFIAw2AhAgBSADNgIMQQIhAyAAKAIMIgQgASgCFEECdGooAgAiDCgCBCEHAkACQCAJIAwoAgAiDUZBACAHIApGGw0AAkAgCiANRkEAIAcgCUYbDQAgDCgCCCELIAcgCUYEQEEAIQMgCiALRg0CCyAHIApGBEBBACEDIAkgC0YNAQsgCSALRgRAQQEhAyAKIA1GDQILQZzSASEHIAogC0cNAkEBIQMgCSANRw0CCyAMIANBAnRqQQxqIQcMAQsgDCADQQJ0akEMaiEHCyAHIA42AgACQAJAIAQgBigCDEECdGooAgAiAygCACACRg0AIAMoAgQgAkYNACADKAIIIAJHDQELIAAgBiADEKsCIAAoAgwgBigCGEECdGpBADYCACAGBEBB7PcBQez3ASgCAEEBajYCACAGQZDSASgCABEAAAsgACgCDCADKAIYQQJ0akEANgIAIAMEQEHs9wFB7PcBKAIAQQFqNgIAIANBkNIBKAIAEQAACyAAKAIMIQQLAkACQCAEIAgoAgxBAnRqKAIAIgYoAgAgAkYNACAGKAIEIAJGDQAgBigCCCACRw0BCyAAIAggBhCrAiAAKAIMIAgoAhhBAnRqQQA2AgAgCARAQez3AUHs9wEoAgBBAWo2AgAgCEGQ0gEoAgARAAALIAAoAgwgBigCGEECdGpBADYCACAGBEBB7PcBQez3ASgCAEEBajYCACAGQZDSASgCABEAAAsgACgCDCEECwJAAkAgBCAFKAIMQQJ0aigCACIGKAIAIAJGDQAgBigCBCACRg0AIAYoAgggAkcNAQsgACAFIAYQqwIgACgCDCAFKAIYQQJ0akEANgIAIAUEQEHs9wFB7PcBKAIAQQFqNgIAIAVBkNIBKAIAEQAACyAAKAIMIAYoAhhBAnRqQQA2AgAgBgRAQez3AUHs9wEoAgBBAWo2AgAgBkGQ0gEoAgARAAALIAAoAgwhBAsgBCABKAIYQQJ0akEANgIAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwv2AQICfwx9QwAAgD8hDSAAIAEoAgRBBHRqIgQqAgAiCSAAIAEoAgBBBHRqIgUqAgAiDpMiDyAAIAEoAghBBHRqIgAqAgQgBCoCBCIGkyIHlCAGIAUqAgQiEJMiBiAAKgIAIAmTIhGUkyIMIAyUIAYgACoCCCAEKgIIIgaTIgiUIAYgBSoCCCIJkyIGIAeUkyIHIAeUIAYgEZQgDyAIlJMiCCAIlJKSkSIGQwAAAABcBH0gDEMAAIA/IAaVIgaUIQsgCCAGlCEKIAcgBpQFQwAAgD8LIAIqAgAgDpOUIAogAioCBCAQk5SSIAsgAioCCCAJk5SSIANeC6gXAQh/IAAgACgCmAE2AqgBIAFBAToAUCABQQA6ADwgAUGaAjYCNCABQeyxATYCACABQQA2AkwgAUEBOgBkIAFCADcCRCABQQA2AmAgAUEBOgB4IAFCADcCWCABQQA2AnQgAUEBOgCMASABQgA3AmwgAUEANgKIASABQQE6AKQBIAFBADYCkAEgAUIANwKAASABQQA2AqABIAFCADcCmAEgAUEANgKoASABQv////sHNwIcIAFC////+/f//7//ADcCFCABQv////sPNwIMIAFC////+////79/NwIEIAAoAjghAiABAn8gAwRAIAEgAkEIdEGAgPwHcSACQRh0ciACQQh2QYD+A3EgAkEYdnJyNgI4IAEgAC0ABzoABCABIAAtAAY6AAUgASAALQAFOgAGIAEgAC0ABDoAByABIAAtAAs6AAggASAALQAKOgAJIAEgAC0ACToACiABIAAtAAg6AAsgASAALQAPOgAMIAEgAC0ADjoADSABIAAtAA06AA4gASAALQAMOgAPIAEgAC0AEzoAECABIAAtABI6ABEgASAALQAROgASIAEgAC0AEDoAEyABIAAtABc6ABQgASAALQAWOgAVIAEgAC0AFToAFiABIAAtABQ6ABcgASAALQAbOgAYIAEgAC0AGjoAGSABIAAtABk6ABogASAALQAYOgAbIAEgAC0AHzoAHCABIAAtAB46AB0gASAALQAdOgAeIAEgAC0AHDoAHyABIAAtACM6ACAgASAALQAiOgAhIAEgAC0AIToAIiABIAAtACA6ACMgASAALQAnOgAkIAEgAC0AJjoAJSABIAAtACU6ACYgASAALQAkOgAnIAEgAC0AKzoAKCABIAAtACo6ACkgASAALQApOgAqIAEgAC0AKDoAKyABIAAtAC86ACwgASAALQAuOgAtIAEgAC0ALToALiABIAAtACw6AC8gASAALQAzOgAwIAEgAC0AMjoAMSABIAAtADE6ADIgASAALQAwOgAzIAEgACgCkAEiAkEYdCACQQh0QYCA/AdxciACQQh2QYD+A3EgAkEYdnJyNgKQASAAKAKoASICQRh0IAJBCHRBgID8B3FyIAJBCHZBgP4DcSACQRh2cnIMAQsgASACNgI4IAEgACkCDDcCDCABIAApAgQ3AgQgASAAKQIcNwIcIAEgACkCFDcCFCABIAApAiw3AiwgASAAKQIkNwIkIAEgACgCkAE2ApABIAAoAqgBCzYCqAEgASAALQA8OgA8IAFBrAFqIQcgACgCOCEFAkAgAC0APARAIAEoAogBIgIEQCABLQCMAQRAIAIEQEHs9wFB7PcBKAIAQQFqNgIAIAJBkNIBKAIAEQAACwsgAUEANgKIAQsgASAHNgKIASABQQA6AIwBIAEgBTYChAEgASAFNgKAAQJAIANFBEAgBUEBSA0BIAAoAogBIQgDQCAHIARBBHQiBmoiAiAGIAhqIgYvAQA7AQAgAiAGLwECOwECIAIgBi8BBDsBBCACIAYvAQY7AQYgAiAGLwEIOwEIIAIgBi8BCjsBCiACIAYoAgw2AgwgBEEBaiIEIAVHDQALDAELIAVBAUgNACAAKAKIASEIA0AgByAEQQR0IgZqIgIgBiAIaiIGLwEAIglBGHQgCUEIdEGAgPwHcXJBEHY7AQAgAiAGLwECIglBGHQgCUEIdEGAgPwHcXJBEHY7AQIgAiAGLwEEIglBGHQgCUEIdEGAgPwHcXJBEHY7AQQgAiAGLwEGIglBGHQgCUEIdEGAgPwHcXJBEHY7AQYgAiAGLwEIIglBGHQgCUEIdEGAgPwHcXJBEHY7AQggAiAGLwEKIglBGHQgCUEIdEGAgPwHcXJBEHY7AQogAiAGKAIMIgJBGHQgAkEIdEGAgPwHcXIgAkEIdkGA/gNxIAJBGHZycjYCDCAEQQFqIgQgBUcNAAsLIAFBgAFqIQkgBUEEdCEFDAELIAEoAmAiAgRAIAEtAGQEQCACBEBB7PcBQez3ASgCAEEBajYCACACQZDSASgCABEAAAsLIAFBADYCYAsgAUHYAGohCSABIAc2AmAgAUEAOgBkIAEgBTYCXCABIAU2AlgCfwJAAkAgA0UEQCAFQQFIDQIgACgCYCEGIAchAgNAIAIgBEEGdCIIaiICIAYgCGoiBikCADcCACACIAYpAgg3AgggASgCYCAIaiICIAAoAmAgCGoiBikCEDcCECACIAYpAhg3AhggASgCYCICIAhqIgogACgCYCIGIAhqIggoAiA2AiAgCiAIKAIkNgIkIAogCCgCKDYCKCAEQQFqIgQgBUcNAAsMAQsgBUEBSA0BIAAoAmAhCiAHIQIDQCACIAZBBnQiCGoiAiAIIApqIgQtAAM6AAAgAiAELQACOgABIAIgBC0AAToAAiACIAQtAAA6AAMgAiAELQAHOgAEIAIgBC0ABjoABSACIAQtAAU6AAYgAiAELQAEOgAHIAIgBC0ACzoACCACIAQtAAo6AAkgAiAELQAJOgAKIAIgBC0ACDoACyACIAQtAA86AAwgAiAELQAOOgANIAIgBC0ADToADiACIAQtAAw6AA8gASgCYCAIaiICIAAoAmAgCGoiBC0AEzoAECACIAQtABI6ABEgAiAELQAROgASIAIgBC0AEDoAEyACIAQtABc6ABQgAiAELQAWOgAVIAIgBC0AFToAFiACIAQtABQ6ABcgAiAELQAbOgAYIAIgBC0AGjoAGSACIAQtABk6ABogAiAELQAYOgAbIAIgBC0AHzoAHCACIAQtAB46AB0gAiAELQAdOgAeIAIgBC0AHDoAHyABKAJgIgIgCGoiCyAAKAJgIgogCGoiCCgCICIEQRh0IARBCHRBgID8B3FyIARBCHZBgP4DcSAEQRh2cnI2AiAgCyAIKAIkIgRBGHQgBEEIdEGAgPwHcXIgBEEIdkGA/gNxIARBGHZycjYCJCALIAgoAigiBEEYdCAEQQh0QYCA/AdxciAEQQh2QYD+A3EgBEEYdnJyNgIoIAZBAWoiBiAFRw0ACwsgBUEGdCIFIAINARoMAgsgByECIAVBBnQLIQUgAS0AZARAIAIEQEHs9wFB7PcBKAIAQQFqNgIAIAJBkNIBKAIAEQAACwsgAUEANgJgCyAJQgA3AgAgCUIANwAFIAAoAqgBIQQgASgCoAEiAgRAIAEtAKQBBEAgAgRAQez3AUHs9wEoAgBBAWo2AgAgAkGQ0gEoAgARAAALCyABQQA2AqABCyABIAUgB2oiBjYCoAEgAUEAOgCkASABIAQ2ApwBIAEgBDYCmAEgACgCqAEhBwJAIANFBEAgB0EBSA0BIAAoAqABIQVBACEDA0AgBiADQQV0IgdqIgIgBSAHaiIHLwEAOwEAIAIgBy8BAjsBAiACIAcvAQQ7AQQgAiAHLwEGOwEGIAIgBy8BCDsBCCACIAcvAQo7AQogAiAHKAIMNgIMIAcoAhAhByACQQA2AhwgAkIANwIUIAIgBzYCECADQQFqIgMgACgCqAFIDQALDAELIAdBAUgNACAAKAKgASEEQQAhAwNAIAYgA0EFdCICaiIAIAIgBGoiAi8BACIFQRh0IAVBCHRBgID8B3FyQRB2OwEAIAAgAi8BAiIFQRh0IAVBCHRBgID8B3FyQRB2OwECIAAgAi8BBCIFQRh0IAVBCHRBgID8B3FyQRB2OwEEIAAgAi8BBiIFQRh0IAVBCHRBgID8B3FyQRB2OwEGIAAgAi8BCCIFQRh0IAVBCHRBgID8B3FyQRB2OwEIIAAgAi8BCiIFQRh0IAVBCHRBgID8B3FyQRB2OwEKIAAgAigCDCIFQRh0IAVBCHRBgID8B3FyIAVBCHZBgP4DcSAFQRh2cnI2AgwgACACKAIQIgBBGHQgAEEIdEGAgPwHcXIgAEEIdkGA/gNxIABBGHZycjYCECADQQFqIgMgB0cNAAsLIAFBADYCACABQgA3AJ0BIAFCADcCmAFBAQu5CwIWfxB9IwBBIGsiByQAIAIqAgQhISADKgIEISMgAioCACEiIAMqAgAhIAJ/IAAqAhwiJyAAKgIMIh0gAyoCCCIkIAIqAggiJiAkICZdGyAEKgIIkiIeIB4gHV0bIh4gJyAeXRsgHZMgACoCLCIqlCIeQwAAgE9dIB5DAAAAAGBxBEAgHqkMAQtBAAshAwJ/IAAqAhgiKCAAKgIIIh4gIyAhICMgIV0bIAQqAgSSIh8gHyAeXRsiHyAoIB9dGyAekyAAKgIoIiuUIh9DAACAT10gH0MAAAAAYHEEQCAfqQwBC0EACyEIAn8gACoCFCIpIAAqAgQiHyAgICIgICAiXRsgBCoCAJIiJSAlIB9dGyIlICkgJV0bIB+TIAAqAiQiLJQiJUMAAIBPXSAlQwAAAABgcQRAICWpDAELQQALIQsCfyAnIB0gJCAmICYgJF0bIAUqAgiSIiUgJSAdXRsiJSAnICVdGyAdkyAqlEMAAIA/kiIdQwAAgE9dIB1DAAAAAGBxBEAgHakMAQtBAAshDAJ/ICggHiAjICEgISAjXRsgBSoCBJIiHSAdIB5dGyIdICggHV0bIB6TICuUQwAAgD+SIh1DAACAT10gHUMAAAAAYHEEQCAdqQwBC0EACyENAn8gKSAfICAgIiAiICBdGyAFKgIAkiIdIB0gH10bIh0gKSAdXRsgH5MgLJRDAACAP5IiHUMAAIBPXSAdQwAAAABgcQRAIB2pDAELQQALIQ5BACAGSARAICQgJpMiHSAdQwAAgD8gICAikyIiICKUICMgIZMiISAhlJIgHSAdlJKRlSIjlCIglCAiICIgI5QiIpQgISAhICOUIiGUkpIhJyADQf7/A3EhDyAIQf7/A3EhECALQf7/A3EhESAMQQFyIQwgDUEBciENIA5BAXIhDiAAKAKIASEDIAdDawteXUMAAIA/ICCVICBDAAAAAFsbIiNDAAAAAF0iCUEEdGpBCHIhEiAHQ2sLXl1DAACAPyAhlSAhQwAAAABbGyIhQwAAAABdIghBBHRqQQRyIRMgByAJQQFzQQR0akEIciEUIAcgCEEBc0EEdGpBBHIhFSAHQ2sLXl1DAACAPyAilSAiQwAAAABbGyIiQwAAAABdIglBBHRqIRYgByAJQQFzQQR0aiEXQQAhCQNAIAMoAgwhC0EAIQgCfwJAAkACQCARIAMvAQZLDQAgDiADLwEAIhhJDQAgDyADLwEKSw0AIAwgAy8BBCIZSQ0AIBAgAy8BCEsNACANIAMvAQIiGkkNACAAKgIMISAgACoCLCEdIAAqAgghHiAAKgIoIR8gACoCBCEkIAAqAiQhJiAHQQA2AgwgAy8BCiEIIAMvAQghGyADLwEGIRwgB0EANgIcIAcgJCAYsyAmlZIgBSoCAJM4AgAgByAeIBqzIB+VkiAFKgIEkzgCBCAHICAgGbMgHZWSIAUqAgiTOAIIIAcgJCAcsyAmlZIgBCoCAJM4AhAgByAeIBuzIB+VkiAEKgIEkzgCFCAHICAgCLMgHZWSIAQqAgiTOAIYAkAgISATKgIAIAIqAgQiH5OUIiAgIiAXKgIAIAIqAgAiHpOUIh1eDQAgIiAWKgIAIB6TlCIeICEgFSoCACAfk5QiH14NACAjIBIqAgAgAioCCCImk5QiJCAfIB0gHyAdXRsiHV4NACAgIB4gICAeXhsiICAjIBQqAgAgJpOUIh5eDQAgJCAgICQgIF4bICddIB4gHSAeIB1dG0MAAAAAXnEhCCALQQBIDQEgCEUNASABIAMoAgwiCEEVdSAIQf///wBxIAEoAgAoAggRBQAMAgtBACEICyALQX9KDQAgCEUNAQsgCkEBaiEKIANBEGoMAQsgCiADKAIMIghrIQogAyAIQQR0awshAyAJQQFqIQkgCiAGSA0ACwtBtPcBKAIAIAlIBEBBtPcBIAk2AgALIAdBIGokAAv5BwIMfxN9IwBBIGsiBiQAAkAgACgCOEEBSA0AIAMqAggiFCACKgIIIhWTIhMgE0MAAIA/IAMqAgAiEiACKgIAIhiTIhYgFpQgAyoCBCIZIAIqAgQiGpMiFyAXlJIgEyATlJKRlSITlCIblCAWIBYgE5QiFpQgFyAXIBOUIhOUkpIhHiAUIBUgFSAUXRsgBSoCCCIXkiEfIBkgGiAaIBldGyAFKgIEIhySISAgEiAYIBggEl0bIAUqAgAiHZIhISAUIBUgFCAVXRsgBCoCCCIUkiEiIBkgGiAZIBpdGyAEKgIEIhWSISMgEiAYIBIgGF0bIAQqAgAiEpIhJCAAKAJgIQMgBkNrC15dQwAAgD8gG5UgG0MAAAAAWxsiGEMAAAAAXSIHQQR0akEIciELIAZDawteXUMAAIA/IBOVIBNDAAAAAFsbIhlDAAAAAF0iCEEEdGpBBHIhDCAGIAdBAXNBBHRqQQhyIQ0gBiAIQQFzQQR0akEEciEOIAZDawteXUMAAIA/IBaVIBZDAAAAAFsbIhpDAAAAAF0iB0EEdGohDyAGIAdBAXNBBHRqIRADQCAGIAMpAgA3AwAgBiADKQIINwMIIAYgAykCGDcCGCAGIAMpAhA3AhAgBiAGKgIAIB2TOAIAIAYgBioCBCAckzgCBCAGIAYqAhAgEpM4AhAgBiAGKgIUIBWTOAIUIAYgBioCCCAXkzgCCCAGIAYqAhggFJM4AhgCf0EAICQgAyoCEF4NABpBACAhIAMqAgBdDQAaQQELIQhBACEHAkAgIiADKgIYXg0AIB8gAyoCCF0NACAIIQcLAn8CQAJAAkACQCAjIAMqAhReDQAgICADKgIEXQ0AIAdBAXMNACAZIAwqAgAgAioCBCITk5QiFCAaIBAqAgAgAioCACISk5QiFV4NACAaIA8qAgAgEpOUIhIgGSAOKgIAIBOTlCITXg0AIBggCyoCACACKgIIIheTlCIWIBMgFSATIBVdGyIVXg0AIBQgEiAUIBJeGyIUIBggDSoCACAXk5QiEl4NACADKAIgIhFBf0YhByAWIBQgFiAUXhsgHl0gEiAVIBIgFV0bQwAAAABecSIIQQFHDQEgEUF/Rw0BIAEgAygCJCADKAIoIAEoAgAoAggRBQAMAgsgAygCIEF/RiEHQQAhCAsgBw0AIAhFDQELIAlBAWohCSADQUBrDAELIAMoAiAiByAJaiEJIAMgB0EGdGoLIQMgCkEBaiEKIAkgACgCOE4NASAEKgIIIRQgBCoCBCEVIAQqAgAhEiAFKgIIIRcgBSoCBCEcIAUqAgAhHQwAAAsAC0G09wEoAgAgCkgEQEG09wEgCjYCAAsgBkEgaiQAC7IBAQF/A0ACQAJAIAMvAQAgAS8BBksNACAELwEAIAEvAQBJDQAgAy8BBCABLwEKSw0AIAQvAQQgAS8BBEkNACADLwECIAEvAQhLDQAgBC8BAiABLwECSQ0AIAEoAgwiBUEASA0BIAIgBUEVdiAFQf///wBxIAIoAgAoAggRBQALDwsgACABQRBqIgUgAiADIAQQ6AMgAUEgaiAFIAEoAhwiAUEEdGsgAUF/ShshAQwAAAsACxoAIAAoAgQiACABKAIkIAAoAgAoAggRAwAaCwgAIAAoAogBC5wIAgl/B30jAEEgayIJJAAgAQRAIAAoAiwiCkH/AEwEQCAAKAIwQf8ATARAQej3AUHo9wEoAgBBAWo2AgBBgARBEEGM0gEoAgARAwAhDSAAKAIsIgtBAU4EQANAIA0gDkECdCIMaiAAKAI0IAxqKAIANgIAIA5BAWoiDiALRw0ACwsgACgCNCILBEAgAC0AOARAIAsEQEHs9wFB7PcBKAIAQQFqNgIAIAtBkNIBKAIAEQAACwsgAEEANgI0CyAAIA02AjQgAEGAATYCMCAAQQE6ADgLA0AgACgCNCAKQQJ0akEANgIAIApBAWoiCkGAAUcNAAsLIABBgAE2AiwgACgCNCABNgIAQf4AIQpBASEOA0AgACgCNCINIA5Bf2oiAUECdCIQaigCACILKgIAIRMgCyoCBCEUIAsqAgghEiAHKgIAIRUgByoCBCEWIAcqAgghFyAJQQA2AgwgCSASIBeTOAIIIAkgFCAWkzgCBCAJIBMgFZM4AgAgCyoCECETIAsqAhQhFCALKgIYIRIgBioCACEVIAYqAgQhFiAGKgIIIRcgCUEANgIcIAkgEiAXkzgCGCAJIBQgFpM4AhQgCSATIBWTOAIQAn8CQCAJIAQoAgQiDEEEdGoqAgQgAioCBCIVkyADKgIEIhaUIhMgAyoCACISIAlBASAEKAIAIg9rQQR0aioCACACKgIAIheTlCIUXg0AIAkgD0EEdGoqAgAgF5MgEpQiEiAWIAlBASAMa0EEdGoqAgQgFZOUIhVeDQAgCSAEKAIIIgxBBHRqKgIIIAIqAggiF5MgAyoCCCIYlCIWIBUgFCAVIBRdGyIUXg0AIBMgEiATIBJeGyITIBggCUEBIAxrQQR0aioCCCAXk5QiEl4NACAWIBMgFiATXhsgBV1BAXMNACASIBQgEiAUXRtDAAAAAF5BAXMNACALKAIoBEAgASAKSgRAIAAoAiwiCiAKQQF0IgxIBEAgACgCMCAMSARAAkAgCkUEQEEAIQ0MAQtB6PcBQej3ASgCAEEBajYCACAKQQN0QRBBjNIBKAIAEQMAIQ1BACEBIAAoAiwiD0EBSA0AA0AgDSABQQJ0IhFqIAAoAjQgEWooAgA2AgAgAUEBaiIBIA9HDQALCyAAKAI0IgEEQCAALQA4BEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AjQLIAAgDTYCNCAAQQE6ADggACAMNgIwCwNAIA0gCkECdGpBADYCACAAKAI0IQ0gCkEBaiIKIAxHDQALCyAAIAw2AiwgDEF+aiEKCyANIBBqIAsoAiQ2AgAgACgCNCAOQQJ0aiALKAIoNgIAIA5BAWoMAgsgCCALIAgoAgAoAgwRAgALIAELIg4NAAsLIAlBIGokAAuHAQIBfwF9IwBBIGsiCCQAIAggADYCHCAIIAE2AhggCCACNgIUIAggAzYCECAIIAQ2AgwgCCAFNgIIIAggBjYCBCAIIAc2AgAgCCgCHCIAIAgoAhggCCgCFCAIKAIQIAgoAgwgCCgCCCAIKAIEIAgoAgAgACgCACgCDBEqACEJIAhBIGokACAJC7YBACAAQZyvATYCACAAQQRqEHoaIABBQGsQehogAEGAAjsAwQEgACABRToAwAEgAEEANgKkASAAQgA3AowBIABBADYCsAEgAEIANwKoASAAQoqAgIAQNwKcASAAQgE3ApQBIAFFBEACf0Ho9wFB6PcBKAIAQQFqNgIAQcwAQRBBjNIBKAIAEQMAIgELELMCCyAAQQA2ArwBIAAgATYCiAEgAEIANwK0ASAAQgA3AnwgAEEANgKEAQuCAgEBfyAAQfCrATYCACAAQUBrKAIAIgEEQCAALQBEBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AkALIABBADYCQCAAQgA3AjggAEEBOgBEIAAoAiwiAQRAIAAtADAEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYCLAsgAEEANgIsIABCADcCJCAAQQE6ADAgACgCECIBBEAgAC0AFARAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgIQCyAAQQA2AhAgAEIANwIIIABBAToAFCAAC/MFAQl/AkAgACgCJCIHIAAoAgwiAU4NAAJAIAAoAiggAU4EQCAAKAIsIQMMAQsgByECIAEEQEHo9wFB6PcBKAIAQQFqNgIAIAFBAnRBEEGM0gEoAgARAwAhAyAAKAIkIQILIAAoAiwhBQJAIAJBAU4EQANAIAMgBEECdCIGaiAFIAZqKAIANgIAIARBAWoiBCACRw0ADAIACwALIAUNACAAIAM2AiwgACABNgIoIABBAToAMAwBCyAALQAwBEAgBQRAQez3AUHs9wEoAgBBAWo2AgAgBUGQ0gEoAgARAAALCyAAIAM2AiwgAEEBOgAwIAAgATYCKAsgAyAHQQJ0IgJqQQAgAUECdCIIIAJrEAsaIAAgATYCJCAAKAI4IgYgAUgEQAJAIAAoAjwgAU4EQCAAQUBrKAIAIQMMAQtBACEEIAYhAkEAIQMgAQRAQej3AUHo9wEoAgBBAWo2AgAgCEEQQYzSASgCABEDACEDIAAoAjghAgsgAEFAaygCACEFAkAgAkEBTgRAA0AgAyAEQQJ0IglqIAUgCWooAgA2AgAgBEEBaiIEIAJHDQAMAgALAAsgBQ0AIAAgAzYCQCAAIAE2AjwgAEEBOgBEDAELIAAtAEQEQCAFBEBB7PcBQez3ASgCAEEBajYCACAFQZDSASgCABEAAAsLIAAgAzYCQCAAQQE6AEQgACABNgI8CyADIAZBAnQiAmpBACAIIAJrEAsaCyAAIAE2AjggAUEBTgRAIAAoAixB/wEgCBALGiAAQUBrKAIAQf8BIAgQCxoLIAdBAUgNACAAQUBrKAIAIQIgACgCECEFIAAoAiwhBkEAIQQDQCACIARBAnRqIAYgACgCDEF/aiAFIARBBHRqIgEoAgQoAgxBEHQgASgCACgCDHIiASABQQ90QX9zaiIBQQp1IAFzQQlsIgFBBnUgAXMiASABQQt0QX9zaiIBQRB1IAFzcUECdGoiASgCADYCACABIAQ2AgAgBEEBaiIEIAdHDQALCwuLAwEKfwJAIAAgAUECdGooAkQiBiACQQJ0IghqIgIvAQAgAkF8aiIJLwEAIgVPDQAgAUEBdCILIAAoAjwiByAGIAhqLwECQQZ0amohCEEBQQEgAXRBA3EiDHRBA3EhDQNAIAJBfmovAQAhAQJ/IAVBAXFFBEACQCAHIAIvAQJBBnRqIgUgDEEBdCIEaiIKLwE2IAQgByABQQZ0aiIGaiIELwEwSQ0AIAQvATYgCi8BMEkNACAFIA1BAXQiBGoiCi8BNiAEIAZqIgQvATBJDQAgBC8BNiAKLwEwSQ0AIAAoAlwiBCAFIAYgAyAEKAIAKAIMEQoAGiAAKAJgIgRFDQAgBCAFIAYgAyAEKAIAKAIMEQoAGgsgByABQQZ0aiALakEwagwBCyAHIAFBBnRqIAtqQTZqCyIBIAEvAQBBAWo7AQAgCCAILwE2QX9qOwE2IAIoAQAhASACIAkoAQA2AQAgCSABNgEAIAJBfGoiAi8BACAJQXxqIgkvAQAiBU8NASAAKAI8IQcMAAALAAsLjgMBDX8CQCAAIAFBAnRqKAJEIAJBAnRqIgIvAQAgAkF8aiIFLwEAIgRPDQAgACgCPCIGIAIvAQJBBnRqIgdBMGoiAyABQQF0IglqIQogA0EBIAF0QQNxIgFBAXQiC2ohDSAHQTZqIgggC2ohDiADQQEgAXRBA3FBAXQiDGohDyAIIAxqIQgDQCACQX5qLwEAIQECfyAEQQFxBEACQCAOLwEAIAYgAUEGdGoiBCALaiIDLwEwSQ0AIAMvATYgDS8BAEkNACAILwEAIAQgDGoiAy8BMEkNACADLwE2IA8vAQBJDQAgACgCXCIDIAcgBCADKAIAKAIIEQcAGiAAKAJgIgNFDQAgAyAHIAQgAygCACgCCBEHABoLIAYgAUEGdGogCWpBNmoMAQsgBiABQQZ0aiAJakEwagsiASABLwEAQQFqOwEAIAogCi8BAEF/ajsBACACKAEAIQEgAiAFKAEANgEAIAUgATYBACACQXxqIgIvAQAgBUF8aiIFLwEAIgRPDQEgACgCPCEGDAAACwALCwcAIABBBGoLBABBAAskAQF/IwBBEGsiAiAANgIMIAIgATsBCiACKAIMIAIvAQo7AQoLBwAgACgCXAsqACACIAEpAhA3AgAgAiABKQIYNwIIIAMgASkCKDcCCCADIAEpAiA3AgALGAEBfyMAQRBrIgEgADYCDCABKAIMLgEKC+ECAQF/IABBmKgBNgIAIAAoApwBIgEEQCAALQCgAQRAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgKcAQsgAEEANgKcASAAQgA3ApQBIABBAToAoAEgACgCiAEiAQRAIAAtAIwBBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AogBCyAAQQA2AogBIABCADcCgAEgAEEBOgCMASAAKAJ0IgEEQCAALQB4BEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AnQLIABBADYCdCAAQgA3AmwgAEEBOgB4IAAoAmAiAQRAIAAtAGQEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYCYAsgAEEANgJgIABCADcCWCAAQQE6AGQgABD9AxogAAskAQF/IwBBEGsiAiAANgIMIAIgATsBCiACKAIMIAIvAQo7AQgLQAEBfyAAKAIgIgUgBSgCAEEBajYCACAAIAAgASAEENUBENYBIAAgACACIAQQ1QEQ1gEgACAAIAMgBBDVARDWAQtdACACIAAoAiAgCUEFdGoiACgCDDYCACABIAAoAhA2AgAgAyAAKAIcNgIAIAQgACgCFDYCACAHIAAoAgA2AgAgBSAAKAIENgIAIAYgACgCCDYCACAIIAAoAhg2AgALGAEBfyMAQRBrIgEgADYCDCABKAIMLgEIC18BAX8gAEGopwE2AgAgACgCICIBBEAgAC0AJARAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgIgCyAAQQA2AiAgAEIANwIYIABBAToAJCAACzsBAn0gACoCHCEBIAAgACgCACgCMBEGACECIAAgACgCACgCMBEGABogACAAKAIAKAIwEQYAGiABIAKSCzwBAX8jAEEQayIBJAAgASAANgIMIwBBEGsiACABKAIMNgIMIAAoAgwqAgRDAACAP10hACABQRBqJAAgAAs5AQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDCIAIAIoAgggACgCACgCCBECACACQRBqJAALNQEBfyMAQRBrIgIgADYCDCACIAE2AgggAigCDCIAIAIoAggiASkCADcCBCAAIAEpAgg3AgwLrAwBBX8jAEHwAGsiBSQAIAAgAjoAPAJAIAIEQCAAIAMgBBDTCiAFIAA2AmAgBSAAQegAajYCXCAFQaSfATYCWCABIAVB2ABqIABBBGogAEEUaiABKAIAKAIIEQQAIAAoAmwhBCAFQgA3AxAgBUIANwMIIAAoAoABIgIgBEEBdCIGSARAIAAoAoQBIAZIBEAgBAR/Qej3AUHo9wEoAgBBAWo2AgAgBEEFdEEQQYzSASgCABEDACEIIAAoAoABBSACCyIDQQFOBEBBACEBA0AgCCABQQR0IgdqIgkgACgCiAEgB2oiBykCADcCACAJIAcpAgg3AgggAUEBaiIBIANHDQALCyAAKAKIASIBBEAgAC0AjAEEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYCiAELIAAgCDYCiAEgACAGNgKEASAAQQE6AIwBCwNAIAAoAogBIAJBBHRqIgEgBSkDCDcCACABIAUpAxA3AgggAkEBaiICIAZHDQALCyAAIAY2AoABDAELIAVBqKABNgJoIAUgAEFAazYCbCAFQuuW+OoNNwNgIAVC65b46r3tgq9dNwNYIAVC65b46gU3A1AgBULrlvjqte2Cr90ANwNIIAEgBUHoAGogBUHYAGogBUHIAGogASgCACgCCBEEACAAKAJEIQQgBUFAa0IANwMAIAVCADcDOCAFQgA3AzAgBUIANwMoIAVCADcDICAFQgA3AxggBUIANwMQIAVCADcDCCAAKAJYIgEgBEEBdCIHSARAIAAoAlwgB0gEQCAEBH9B6PcBQej3ASgCAEEBajYCACAEQQd0QRBBjNIBKAIAEQMAIQggACgCWAUgAQsiAkEBTgRAA0AgCCAJQQZ0IgZqIgMgACgCYCAGaiIGKQIANwIAIAMgBikCODcCOCADIAYpAjA3AjAgAyAGKQIoNwIoIAMgBikCIDcCICADIAYpAhg3AhggAyAGKQIQNwIQIAMgBikCCDcCCCAJQQFqIgkgAkcNAAsLIAAoAmAiAgRAIAAtAGQEQCACBEBB7PcBQez3ASgCAEEBajYCACACQZDSASgCABEAAAsLIABBADYCYAsgACAINgJgIAAgBzYCXCAAQQE6AGQLA0AgACgCYCABQQZ0aiICIAUpAwg3AgAgAiAFQUBrKQMANwI4IAIgBSkDODcCMCACIAUpAzA3AiggAiAFKQMoNwIgIAIgBSkDIDcCGCACIAUpAxg3AhAgAiAFKQMQNwIIIAFBAWoiASAHRw0ACwsgACAHNgJYCyAAQQA2AjggAEEAIAQQsQICQCAALQA8RQ0AIAAoApgBDQAgAAJ/IAAoApwBBEAgACgCoAEhBEEBDAELQej3AUHo9wEoAgBBAWo2AgBBIEEQQYzSASgCABEDACEEIAAoApgBIgZBAU4EQEEAIQMDQCAEIANBBXQiAmoiASAAKAKgASACaiICKQIANwIAIAEgAikCGDcCGCABIAIpAhA3AhAgASACKQIINwIIIANBAWoiAyAGRw0ACwsgACgCoAEiAQRAIAAtAKQBBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AqABCyAAIAQ2AqABIABBATYCnAEgAEEBOgCkASAAKAKYAUEBags2ApgBIAQgBSkDIDcCGCAEIAUpAxg3AhAgBCAFKQMQNwIIIAQgBSkDCDcCACAAKAKgASIBIAAoAogBIgIvAQA7AQAgASACLwECOwECIAEgAi8BBDsBBCABIAIvAQY7AQYgASACLwEIOwEIIAIvAQohAyABQQA2AgwgASADOwEKIAFBAUEAIAIoAgwiAWsgAUF/Shs2AhALIAAgACgCmAE2AqgBIAAoAnQiAQRAIAAtAHgEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYCdAsgAEEANgJ0IABCADcCbCAAQQE6AHggACgCTCIBBEAgAC0AUARAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgJMCyAAQQA2AkwgAEIANwJEIABBAToAUCAFQfAAaiQACxIAIAAQ2AogAEHcngE2AgAgAAsvAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDCACKAIIEIEEIAJBEGokAAsEAEEGC5ECARB9IAAgACgCACgCMBEGACEEIAEqAjQhCSABKgIUIQcgASoCGCEMIAEqAjghCiABKgIkIQggACoCICEFIAEqAighDSAAKgIkIQ4gASoCMCELIAEqAgAhDyABKgIEIRAgASoCCCERIAEqAhAhEiABKgIgIRMgACoCHCEGIAJBADYCDCACIAogBCAGkiIGIBOLlCAEIAWSIgUgCIuUkiAEIA6SIgQgDYuUkiIIkzgCCCACIAkgBiASi5QgBSAHi5SSIAQgDIuUkiIHkzgCBCACIAsgBiAPi5QgBSAQi5SSIAQgEYuUkiIEkzgCACADQQA2AgwgAyAKIAiSOAIIIAMgByAJkjgCBCADIAQgC5I4AgALKwEBfyAAEI8EIQMgACABNgJcIABBpJkBNgIAIABBAzYCBCACBEAgAxBhCwskACAAQgA3AgAgAEIANwIIIAAgASgCNEECdGpBgICA/AM2AgALBABBAAsvAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDCACKAIIEMoLIAJBEGokAAsHACAAKAJgC6MCAQZ/AkAgACgCYCIDIAAoAmRHDQAgAyADQQF0QQEgAxsiBE4NAAJ/IAQEQEHo9wFB6PcBKAIAQQFqNgIAIARBBHRBEEGM0gEoAgARAwAhBiAAKAJgIQMLIANBAU4LBEADQCAGIAdBBHQiBWoiCCAAKAJoIAVqIgUpAgA3AgAgCCAFKQIINwIIIAdBAWoiByADRw0ACwsgACgCaCIDBEAgAC0AbARAIAMEQEHs9wFB7PcBKAIAQQFqNgIAIANBkNIBKAIAEQAACwsgAEEANgJoCyAAIAY2AmggACAENgJkIABBAToAbCAAKAJgIQMLIAAoAmggA0EEdGoiAyABKQIANwIAIAMgASkCCDcCCCAAIAAoAmBBAWo2AmAgAgRAIAAQYQsLxAICAX8BfSMAQeAAayIBJAAgAEEBOgBUAkBBoPcBLQAAQQFxDQBBoPcBEBBFDQBBxPYBQgA3AgBBwPYBQYCAgPwDNgIAQcz2AUIANwIAQdj2AUIANwMAQdT2AUGAgID8AzYCAEHg9gFCADcDAEH09gFCADcCAEHw9gFBgICA/Hs2AgBB6PYBQoCAgPwDNwMAQfz2AUIANwIAQYj3AUIANwMAQYT3AUGAgID8ezYCAEGQ9wFCADcDAEGY9wFCgICA/As3AwBBoPcBEA8LIABBwPYBIAFBAEHgABALIgFBBiAAKAIAKAJMEQQAIAAgASoCACAAKgIsIgKSOAJEIAAgASoCMCACkzgCNCAAIAIgASoCFJI4AkggACABKgJEIAKTOAI4IAAgAiABKgIokjgCTCAAIAEqAlggApM4AjwgAUHgAGokAAuHAwIFfwR9IAAgASAEIAUgACgCACgCCBEEACACKgIIIQsgAioCBCEMIAQoAgghASAEKAIEIQYgBCgCACEHIAUoAgghCCAFKAIEIQkgBSgCACEKAkAgAioCACINQwAAAABeQQFzRQRAIA0gCr6SvCEKDAELIA0gB76SvCEHCwJAIAxDAAAAAF5BAXNFBEAgDCAJvpK8IQkMAQsgDCAGvpK8IQYLAkAgC0MAAAAAXkEBc0UEQCALIAi+krwhCAwBCyALIAG+krwhAQsgAyoCCCELIAMqAgAhDCADKgIEIQ0gACAAKAIAKAIQEQYAIQ4gBEEANgIMIAQgATYCCCAEIAY2AgQgBCAHNgIAIAVBADYCDCAFIAg2AgggBSAJNgIEIAUgCjYCACAEIAQqAgAgDiAMIAyUIA0gDZSSIAsgC5SSkZQiC5M4AgAgBCAEKgIEIAuTOAIEIAQgBCoCCCALkzgCCCAFIAsgBSoCAJI4AgAgBSALIAUqAgSSOAIEIAUgCyAFKgIIkjgCCAuXAQAgAEIjNwIEIABBpJABNgIAIABBiq6P6QM2AiwgAEKAgID8AzcCFCAAQoCAgPyDgIDAPzcCDCAAQaSRATYCACAAQQA6AFggAEEANgJUIABCgICA/IuAgMC/fzcCTCAAQoCAgICAgIDAv383AkQgAEKAgID8g4CAwD83AjwgAEGkjQE2AgAgAEKAgICAgICAwD83AjQgAAsvAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDCACKAIIEN8LIAJBEGokAAuAAwEKfyAAKAIEIgQgACgCCEYEQCAAIARBAXRBASAEGxCCAiAAKAIEIQQLIAAoAgwiCCAEQSRsaiICQQA2AgwgAkEBOgAQIAJCADcCBAJAIAEoAgQiBkEBTgRAQej3AUHo9wEoAgBBAWo2AgAgBkECdCIJQRBBjNIBKAIAEQMAIQcgAigCDCEDAkACQCACKAIEIgpBAU4EQANAIAcgBUECdCILaiADIAtqKAIANgIAIAVBAWoiBSAKRw0ADAIACwALIANFDQELIAItABBFDQAgAwRAQez3AUHs9wEoAgBBAWo2AgAgA0GQ0gEoAgARAAALCyACQQE6ABAgAiAHNgIMIAIgBjYCCEEAIQUgB0EAIAkQCxogAiAGNgIEIAEoAgwhAyACKAIMIQIDQCACIAVBAnQiB2ogAyAHaigCADYCACAFQQFqIgUgBkcNAAsMAQsgAiAGNgIECyAIIARBJGxqIgMgASkCFDcCFCADIAEpAhw3AhwgACAAKAIEQQFqNgIECy8BAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIAIoAggQ7QsgAkEQaiQACyIBAX8gACgCMCICIAEpAgA3AgQgAiABKQIINwIMIAAQlAQLnQMBAX8jAEEwayIBJAAgAUEANgIsIAFCADcCJCABQYCAgPwDNgIgIAFBEGogACABQSBqIAAoAgAoAkQRBQAgACABKgIQIAAqAgySOAIgIAFBgICA/Hs2AiAgASAAIAFBIGogACgCACgCRBEFACABIAEpAwg3AxggASABKQMANwMQIAAgASoCECAAKgIMkzgCECABQgA3AyAgAUIANwMoIAFBgICA/AM2AiQgAUEQaiAAIAFBIGogACgCACgCRBEFACAAIAEqAhQgACoCDJI4AiQgAUGAgID8ezYCJCABIAAgAUEgaiAAKAIAKAJEEQUAIAEgASkDCDcDGCABIAEpAwA3AxAgACABKgIUIAAqAgyTOAIUIAFCADcDKCABQgA3AyAgAUGAgID8AzYCKCABQRBqIAAgAUEgaiAAKAIAKAJEEQUAIAAgASoCGCAAKgIMkjgCKCABQYCAgPx7NgIoIAEgACABQSBqIAAoAgAoAkQRBQAgASABKQMINwMYIAEgASkDADcDECAAIAEqAhggACoCDJM4AhggAUEwaiQAC/gEAgl/BH0jAEHQAGsiAyQAIAAoAgQiBCADQRxqIANBGGogA0EUaiADQRBqIANBDGogA0EIaiADQQRqIAMgASAEKAIAKAIQERsAIAMoAgwgAygCCCACbGohBiADKAIQIQggAygCHCEJIAMoAhQhCiAAKAIEIgVBDGohByAJAn8gBi8BBCADKAIAIgtBA0YNABogBigCCAsgCGxqIQQCfyAKRQRAIAQqAgQgBSoCCJQhDiAEKgIAIAUqAgSUIQwgBSoCDCENIARBCGoMAQsgBSoCCCAEKwMItpQhDiAFKgIEIAQrAwC2lCEMIAQrAxC2IQ0gBwsqAgAhDyADQQA2AkwgAyAOOAJEIAMgDyANlDgCSCADIAw4AkAgCSALQQNHBH8gBigCBAUgBi8BAgsgCGxqIQQCfyAKBEAgBSoCCCAEKwMItpQhDiAFKgIEIAQrAwC2lCEMIAQrAxC2IQ0gBwwBCyAEKgIEIAUqAgiUIQ4gBCoCACAFKgIElCEMIAUqAgwhDSAEQQhqCyoCACEPIANBADYCPCADIA44AjQgAyAPIA2UOAI4IAMgDDgCMCAJIAtBA0cEfyAGKAIABSAGLwEACyAIbGohBAJ9IAoEQCAFKgIEIAQrAwC2lCEMIAQrAxC2IQ0gBSoCCCAEKwMItpQMAQsgBEEIaiEHIAQqAgAgBSoCBJQhDCAFKgIMIQ0gBCoCBCAFKgIIlAshDiAHKgIAIQ8gA0EANgIsIAMgDjgCJCADIAw4AiAgAyAPIA2UOAIoIAAoAggiBCADQSBqIAEgAiAEKAIAKAIIEQQAIAAoAgQiACABIAAoAgAoAhgRAgAgA0HQAGokAAsvAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDCACKAIIEP8LIAJBEGokAAuEAQAgACABEPwLIABBADoAPSAAIAI6ADwgAEIANwI0IABBzIMBNgIAIABBFTYCBCADBEACf0Ho9wFB6PcBKAIAQQFqNgIAQawBQRBBjNIBKAIAEQMAIgELEIMEIQIgACABNgI0IAIgACgCMCAALQA8IABBEGogAEEgahCCBCAAQQE6AD0LC6UBAQZ9IAAgACgCACgCMBEGACEHIAAgACgCACgCMBEGACEIIAAgACgCACgCMBEGACEJIAEqAjQhBCABKgI4IQUgASoCMCEGIAJBADYCDCACIAUgCZM4AgggAiAEIAiTOAIEIAIgBiAHkzgCACABKgI0IQQgASoCOCEFIAEqAjAhBiADQQA2AgwgAyAJIAWSOAIIIAMgCCAEkjgCBCADIAcgBpI4AgALvxQCD38RfSMAQeAAayICJAAgAkEBOgA0IAJBADYCMCACQQE6AEggAkIANwMoIAJBADYCRCACQQE6AFwgAkIANwI8IAJBADYCWCACQgA3A1AgAkEANgIcIAJBAToAICACQgA3AhQgAEIANwJIIABCADcCQAJAIAAoAhwiA0EBSA0AA0AgACgCJCIBIAZBJGwiC2ooAgQiDEEBTgRAQQAhBwNAIAEgC2ooAgwiAyAHQQJ0aigCACEBIAIgA0EAIAdBAWoiByAHIAxGIg0bQQJ0aigCACIFOwEKIAIgATsBCEEAIQkgBUEQdEEQdSIEIAFBEHRBEHUiA0oEQCACIAE7AQogAiAFOwEIIAEhBCAFIQMLAkAgBEEQdCIFIANBEHRBEHUiCGogAigCQEF/anEiASACKAIUTw0AIAIoAhwgAUECdGooAgAiAUF/Rg0AIAIoAjAhCiACKAJYIQ4DQCAOIAFBAnQiAWoiDy8BACADQf//A3FGQQAgDy8BAiAEQf//A3FGG0UEQCABIApqKAIAIgFBf0cNAQwCCwsgAigCRCABaiEJCyAAKAIQIgQgBUEQdUEEdGoiAyoCCCAEIAhBBHRqIgQqAgiTIhBDAACAPyADKgIAIAQqAgCTIhEgEZQgAyoCBCAEKgIEkyISIBKUkiAQIBCUkpGVIhSUIRAgEiAUlCESIBEgFJQhEQJAIAAoAjAiA0EBTgRAIAAoAjghBUEAIQEDQCAFIAFBBHRqIgQqAgghFCAEKgIEIRUCQCAEKgIAIhYgEZOLu0SN7bWg98awPmQNACAVIBKTi7tEje21oPfGsD5kDQAgFCAQk4u7RI3ttaD3xrA+ZEEBcw0DCwJAIBEgFpKLu0SN7bWg98awPmQNACASIBWSi7tEje21oPfGsD5kDQAgECAUkou7RI3ttaD3xrA+ZEEBcw0DCyABQQFqIgEgA0gNAAsLAkAgAyAAKAI0Rw0AIAMgA0EBdEEBIAMbIgRODQBBACEBQQAhBQJ/IAQEQEHo9wFB6PcBKAIAQQFqNgIAIARBBHRBEEGM0gEoAgARAwAhBSAAKAIwIQMLIANBAU4LBEADQCAFIAFBBHQiCGoiCiAAKAI4IAhqIggpAgA3AgAgCiAIKQIINwIIIAFBAWoiASADRw0ACwsgACgCOCIDBEAgAC0APARAIAMEQEHs9wFB7PcBKAIAQQFqNgIAIANBkNIBKAIAEQAACwsgAEEANgI4CyAAIAU2AjggAEEBOgA8IAAgBDYCNCAAKAIwIQMLIAAoAjggA0EEdGoiA0EANgIMIAMgEDgCCCADIBI4AgQgAyAROAIAIAAgACgCMEEBajYCMAsCQCAJBEAgCSAGOwECDAELIAIgBjsBACACQf//AzsBAiACQRBqIAJBCGogAhCbDAsgDUUEQCAAKAIkIQEMAQsLIAAoAhwhAwsgBkEBaiIGIANIDQALIANBAUgEQEEAIQEMAQsgACgCECEEIAAoAiQhDUEAIQYDQCANIAZBJGxqIgEoAgQiBUEDTgRAIAVBf2ohCCAEIAEoAgwiBygCAEEEdGoiCSEKIAAqAkghESAAKgJEIRQgACoCQCEVQQEhAQNAIAAgESAKKgIIIhAgBCAHIAFBAnRqKAIAQQR0aiILKgIIIhGSIAQgByABQQFqIgEgBW9BAnRqKAIAQQR0aiIMKgIIIhOSQ6uqqj6UIAkqAgAiEiALKgIAIhiTIhkgCSoCBCIWIAwqAgQiGpMiG5QgFiALKgIEIhyTIh0gEiAMKgIAIh6TIh+UkyIgICCUIB0gECATkyITlCAQIBGTIhAgG5STIhEgEZQgECAflCAZIBOUkyIQIBCUkpKRQwAAAD+UIhCUkiIROAJIIAAgFCAaIBYgHJKSQ6uqqj6UIBCUkiIUOAJEIAAgFSAeIBIgGJKSQ6uqqj6UIBCUkiIVOAJAIBcgEJIhFyABIAhHDQALC0EBIQEgBkEBaiIGIANHDQALCyAAQf////sHNgJgIABDAACAPyAXlSIQIAAqAkCUIhQ4AkAgACAQIAAqAkSUIhU4AkQgACAQIAAqAkiUIhc4AkhD//9/fyEQQ///f38hEiABBEAgACgCJCEFQQAhBANAIAUgBEEkbGoiASoCICAUIAEqAhSUIBUgASoCGJSSIBcgASoCHJSSkosiESASXUEBc0UEQCAAIBE4AmAgESESCyAEQQFqIgQgA0cNAAsLAkAgACgCCCIEQQFIBEBD//9//yEWQ///f38hEUP//3//IRRD//9//yEVQ///f38hFwwBCyAAKAIQIQVD//9//yEVQQAhAUP//39/IRdD//9//yEUQ///f/8hFkP//39/IREDQCAFIAFBBHRqIgMqAggiEyAVIBMgFV4bIRUgEyARIBMgEV0bIREgAyoCBCITIBQgEyAUXhshFCATIBAgEyAQXRshECADKgIAIhMgFiATIBZeGyEWIBMgFyATIBddGyEXIAFBAWoiASAERw0ACwtBACEBIABBADYCgAEgACAVIBGTIhM4AnwgACAUIBCTIhg4AnggACAWIBeTIhk4AnQgAEEANgJwIAAgESAVkjgCbCAAIBAgFJI4AmggACAWIBeSOAJkQQJBASAYIBNdGyAZIBNdQQF0IBkgGF0bIgNBAnQiBCAAQfQAamoiBSoCACERIAAgEkPXs90/lSIQOAJUIAAgEDgCWCAAIBA4AlAgAEHQAGogBGoiBCAFKgIAQwAAAD+UIhI4AgAgEUMAAAA/lCAQk0MAAIA6lCERAkACQANAIAAQugINASAEIBIgEZMiEjgCACABQQFqIgFBgAhHDQALIAAgEDgCVCAAIBA4AlggACAQOAJQDAELIABB0ABqIgRBAUEBIAN0QQNxIgN0QQNxQQJ0aiIBKAIAIQUgBCADQQJ0aiIGIAAqAmAgEJNDAACAOpQiESAGKAIAIgS+kjgCACABIBEgASoCAJIiEDgCACAAELoCBEBBACEDA0AgECESIANBAWoiA0GACEYNAiAGIBEgBigCACIEvpI4AgAgASARIAEqAgCSIhA4AgAgABC6Ag0ACyASvCEFCyAGIAQ2AgAgASAFNgIACyACKAJYIgAEQCACLQBcBEAgAARAQez3AUHs9wEoAgBBAWo2AgAgAEGQ0gEoAgARAAALCyACQQA2AlgLIAJBADYCWCACQQE6AFwgAkIANwNQIAIoAkQiAARAIAItAEgEQCAABEBB7PcBQez3ASgCAEEBajYCACAAQZDSASgCABEAAAsLIAJBADYCRAsgAkEANgJEIAJBAToASCACQgA3AjwgAigCMCIABEAgAi0ANARAIAAEQEHs9wFB7PcBKAIAQQFqNgIAIABBkNIBKAIAEQAACwsgAkEANgIwCyACQQA2AjAgAkEBOgA0IAJCADcDKCACKAIcIgAEQCACLQAgBEAgAARAQez3AUHs9wEoAgBBAWo2AgAgAEGQ0gEoAgARAAALCyACQQA2AhwLIAJB4ABqJAALgQMBBX8gAEHYgAE2AgAgACgCOCIBBEAgAC0APARAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgI4CyAAQQA2AjggAEIANwIwIABBAToAPCAAKAIcIgVBAU4EQANAIAAoAiQgA0EkbGoiAiEEIAIoAgwiAQRAIAItABAEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIARBADYCDAsgAkEBOgAQIARBADYCDCACQQA2AgQgAkEANgIIIANBAWoiAyAFRw0ACwsgACgCJCIBBEAgAC0AKARAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgIkCyAAQQA2AiQgAEIANwIcIABBAToAKCAAKAIQIgEEQCAALQAUBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AhALIABBADYCECAAQgA3AgggAEEBOgAUIAALPQEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAgwiACACKAIIIAAoAgAoAigRAwAhACACQRBqJAAgAAtHAQF/IwBBEGsiAyQAIAMgADYCDCADIAE2AgggAyACOwEGIAMoAgwiACADKAIIIAMuAQZBfSAAKAIAKAIkEQQAIANBEGokAAvFAwEGfyMAQdAAayICJAAgACAAKAJEQQFqNgJEIAAoAkAiBARAIAQgACgCGCABQdAAbGooAkwQowELIAAoAhAhBCACIAAoAhgiBSABQdAAbCIGaiIDIgdBCGopAgA3AwggAiADKQIANwMAIAIgAykCGDcDGCACIAMpAhA3AxAgAiADKQIoNwMoIAIgAykCIDcDICACIAMpAjg3AzggAiADKQIwNwMwIAIgAykCSDcDSCACIAMpAkA3A0AgAyAFIARB0ABsQbB/aiIEaiIFKQIANwIAIAcgBSkCCDcCCCADIAUpAhA3AhAgAyAFKQIYNwIYIAMgBSkCKDcCKCADIAUpAiA3AiAgAyAFKQIwNwIwIAMgBSkCODcCOCADIAUpAkg3AkggAyAFKQJANwJAIAAoAhggBGoiBCACKQMANwIAIAQgAikDCDcCCCAEIAIpAxA3AhAgBCACKQMYNwIYIAQgAikDIDcCICAEIAIpAyg3AiggBCACKQMwNwIwIAQgAikDODcCOCAEIAIpA0A3AkAgBCACKQNINwJIIAAoAkAEQCAAKAIYIAZqKAJMIAE2AiQLIAAgACgCEEF/ajYCECACQdAAaiQAC+0BAQJ/IwBBQGoiBCQAIAFB0ABsIgUgACgCGGoiASACKQIANwIAIAEgAikCCDcCCCABIAIpAhg3AhggASACKQIQNwIQIAEgAikCKDcCKCABIAIpAiA3AiAgASACKQI4NwI4IAEgAikCMDcCMCAAKAJABEAgACgCGCAFaigCQCIBIAIgBEEwaiAEQSBqIAEoAgAoAggRBAAgBCAEKQM4NwMIIAQgBCkDKDcDGCAEIAQpAyA3AxAgBCAEKQMwNwMAIAAoAkAgACgCGCAFaigCTCAEEKQBCyADBEAgACAAKAIAKAJEEQAACyAEQUBrJAALvwEAIABBjPwANgIAIABCHzcCBCAAQoCAgICAgIDAPzcCSCAAQoCAgIAQNwJAIABC65b46r3tgq9dNwIwIABC65b46rXtgq/dADcCICAAQQE6ABwgAEEANgIYIABBADYCWCAAQoCAgPyDgIDAPzcCUCAAQuuW+OoNNwI4IABC65b46gU3AiggAEIANwIQIAEEQAJ/Qej3AUHo9wEoAgBBAWo2AgBBPEEQQYzSASgCABEDACIBCxB6GiAAIAE2AkALCz0BAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIgAgAigCCEECQX0gACgCACgCJBEEACACQRBqJAAL/QkAAkBBwPUBLQAAQQFxDQBBwPUBEBBFDQBB+PIBQvaI5/oDNwMAQfDyAULetZnxg+v//z43AwBB6PIBQvaI5/oDNwMAQeDyAULwh+f2m9aNzz43AwBB2PIBQvaI5/oDNwMAQdDyAULwh+f2m9aNz75/NwMAQcjyAUL2iOf6AzcDAEHA8gFC3rWZ8YPr//++fzcDAEG48gFC1Ijn+gM3AwBBsPIBQr6smvgDNwMAQajyAUKirZr4AzcDAEGg8gFCuNrA+bPz//8+NwMAQZjyAULErZr4AzcDAEGQ8gFCxK2a9Jvtxqc/NwMAQYjyAUKirZr4AzcDAEGA8gFCkYjn+gs3AwBB+PEBQsStmvgDNwMAQfDxAULErZr0m+3Gp79/NwMAQejxAUKirZr4AzcDAEHg8QFCuNrA+bPz//++fzcDAEHY8QFCgICAgAg3AwBB0PEBQqXy2fjT98anPzcDAEHI8QFCgICAgAg3AwBBwPEBQoCAgICIgIDAPzcDAEG48QFCgICAgAg3AwBBsPEBQqXy2fjb98anPzcDAEGo8QFCgICAgAg3AwBBoPEBQonxzfvL3o3PPjcDAEGY8QFCgICAgAg3AwBBkPEBQonxzfvL3o3Pvn83AwBBiPEBQgA3AwBBgPEBQqXy2fjb98anv383AwBB+PABQgA3AwBB8PABQoCAgICAgIDAv383AwBB6PABQgA3AwBB4PABQqXy2fjT98anv383AwBB2PABQgA3AwBB0PABQonxzfvD3o3Pvn83AwBByPABQgA3AwBBwPABQonxzfvD3o3PPjcDAEG48AFCxK2a+As3AwBBsPABQsStmvST7canPzcDAEGo8AFCoq2a+As3AwBBoPABQrjawPm78///PjcDAEGY8AFC9ojn+gs3AwBBkPABQt61mfGL6///PjcDAEGI8AFCoq2a+As3AwBBgPABQrjawPm78///vn83AwBB+O8BQtSI5/oLNwMAQfDvAUK+rJr4i4CAgIB/NwMAQejvAUKirZr4CzcDAEHg7wFCkYjn+oOAgICAfzcDAEHY7wFC9ojn+gs3AwBB0O8BQvCH5/aT1o3PPjcDAEHI7wFCxK2a+As3AwBBwO8BQsStmvST7canv383AwBBuO8BQvaI5/oLNwMAQbDvAULetZnxi+v//75/NwMAQajvAUL2iOf6CzcDAEGg7wFC8Ifn9pPWjc++fzcDAEGY7wFCgICA/AM3AwBBkO8BQoCAgIAINwMAQYjvAUL/8pP3AzcDAEGA7wFCmvKT+wM3AwBB+O4BQuTzk/cDNwMAQfDuAUK6hbb0o4TxrD83AwBB6O4BQuTzk/cDNwMAQeDuAULg/OT5q72lgz83AwBB2O4BQuTzk/cDNwMAQdDuAULg/OT5q72lg79/NwMAQcjuAUKF9JP3AzcDAEHA7gFCuoW29KOE8ay/fzcDAEG47gFC5POT9ws3AwBBsO4BQuD85PmjvaWDPzcDAEGo7gFChfST9ws3AwBBoO4BQrqFtvSrhPGsPzcDAEGY7gFC//KT9ws3AwBBkO4BQpryk/uLgICAgH83AwBBiO4BQuTzk/cLNwMAQYDuAUK6hbb0q4TxrL9/NwMAQfjtAULk85P3CzcDAEHw7QFC4Pzk+aO9pYO/fzcDAEHo7QFCgICA/As3AwBB4O0BQoCAgICAgICAgH83AwBBwPUBEA8LC/oBAQV/IABB6PoANgIAIAAoAggiAigCCCIEQQFOBH8DQCACKAIQIANBDGxqKAIIIgEEQCABIAEoAgAoAgARAQAaIAAoAgQiBSABIAUoAgAoAjwRAgALIANBAWoiAyAERw0ACyAAKAIIBSACCxCkBCAAKAIIIgEgASgCACgCABEBABogACgCCCIBBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsgACgCGCIBBEAgAC0AHARAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgIYCyAAQQA2AhggAEIANwIQIABBAToAHCAAC0sBAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIIIQEjAEEQayIAIAIoAgw2AgwgACABNgIIQbTlASAAKAIINgIAIAJBEGokAAvBAwEFfyAAKAIQIgEEQCAALQAUBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AhALIABBADYCECAAQgA3AgggAEEBOgAUIAAoAigiAQRAIAAtACwEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYCKAsgAEEANgIoIABCADcCICAAQQE6ACwgACgCPCIBBEAgAEFAay0AAARAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgI8C0EAIQEgAEEANgI8IABCADcCNCAAQUBrQQE6AAAgACgCDEEBTARAQej3AUHo9wEoAgBBAWo2AgBBGEEQQYzSASgCABEDACEDIAAoAggiBEEBTgRAA0AgAyABQQxsIgJqIgUgACgCECACaiICKQIANwIAIAUgAigCCDYCCCABQQFqIgEgBEcNAAsLIAAoAhAiAQRAIAAtABQEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYCEAsgACADNgIQIABBAToAFCAAQQI2AgwLIAAQvQILhQIBAX8gAEGo+gA2AgAgACgCPCIBBEAgAEFAay0AAARAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgI8CyAAQQA2AjwgAEIANwI0IABBQGtBAToAACAAKAIoIgEEQCAALQAsBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AigLIABBADYCKCAAQgA3AiAgAEEBOgAsIAAoAhAiAQRAIAAtABQEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYCEAsgAEEANgIQIABCADcCCCAAQQE6ABQgAAtLAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCCCEBIwBBEGsiACACKAIMNgIMIAAgATYCCEG45QEgACgCCDYCACACQRBqJAALjwgCBH8YfSMAQaABayIDJAAgACgCBCIFKAIMIgQqAjQhHCAEKgI4IR0gBCoCGCEHIAQqAhQhCCAEKgIoIQkgBCoCJCEKIAQqAjAhHiAEKgIIIQsgBCoCACEMIAQqAgQhDSAEKgIQIQ4gBCoCICEPIAUoAgQoAhggAkHQAGxqIgQqAiAhECAEKgIAIREgBCoCECESIAQqAjghEyAEKgI0IRQgBCoCMCEVIAQqAiQhFiAEKgIUIRcgBCoCBCEYIAQqAighGSAEKgIYIRogBCoCCCEbQQAhBCADQQA2ApwBIANBADYCjAEgA0EANgJ8IAMgDyAblCAKIBqUkiAJIBmUkjgCiAEgAyAPIBiUIAogF5SSIAkgFpSSOAKEASADIA4gG5QgCCAalJIgByAZlJI4AnggAyAOIBiUIAggF5SSIAcgFpSSOAJ0IAMgHSAPIBWUIAogFJSSIAkgE5SSkjgCmAEgAyAcIA4gFZQgCCAUlJIgByATlJKSOAKUASADQQA2AmwgAyAPIBGUIAogEpSSIAkgEJSSOAKAASADIA4gEZQgCCASlJIgByAQlJI4AnAgAyAMIBGUIA0gEpSSIAsgEJSSOAJgIAMgDCAblCANIBqUkiALIBmUkjgCaCADIAwgGJQgDSAXlJIgCyAWlJI4AmQgAyAeIAwgFZQgDSAUlJIgCyATlJKSOAKQASABIANB4ABqIANB0ABqIANBQGsgASgCACgCCBEEACAAKAIIIgUoAgQiBiAFKAIMIANBMGogA0EgaiAGKAIAKAIIEQQAAkBBzO0BKAIAIgUEQCAAKAIIKAIEIAEgBREDAEUNAQsCQCADKgJQIAMqAiBeDQAgAyoCQCADKgIwXQ0AQQEhBAtBACEFAkAgAyoCWCADKgIoXg0AIAMqAkggAyoCOF0NACAEIQULIAMqAlQgAyoCJF4NACADKgJEIAMqAjRdDQAgBUEBcw0AIAAoAgQiBSgCCCEEIANBfzYCGCADIAQ2AhAgAyABNgIMIAMgBTYCCCADIAI2AhwgAyADQeAAajYCFCACQQJ0IgEgACgCGGooAgBFBEAgACgCDCIEIANBCGogACgCCCAAKAIcIAQoAgAoAggRCgAhBCAAKAIYIAFqIAQ2AgAgACgCBCEFCwJAIAAoAhQiBCgCCCIBKAIIIAUoAghGBEAgBCADQQhqNgIIIARBfyACIAQoAgAoAggRBQAMAQsgBCgCDCEBIAQgA0EIajYCDCAEQX8gAiAEKAIAKAIMEQUACyAAKAIYIAJBAnRqKAIAIgIgA0EIaiAAKAIIIAAoAhAgACgCFCACKAIAKAIIEQkAIAAoAhQiAkEIQQwgAigCCCgCCCAAKAIEKAIIRhtqIAE2AgALIANBoAFqJAALwgMCCn8BfiMAQSBrIgUkACAAKAIMIgMgAiABIAAtABwiCxsiBygCBCIIKAIQIgRIBEAgACgCECAESARAIAQEf0Ho9wFB6PcBKAIAQQFqNgIAIARBAnRBEEGM0gEoAgARAwAhCSAAKAIMBSADCyIGQQFOBEADQCAJIApBAnQiDGogACgCFCAMaigCADYCACAKQQFqIgogBkcNAAsLIAAoAhQiBgRAIAAtABgEQCAGBEBB7PcBQez3ASgCAEEBajYCACAGQZDSASgCABEAAAsLIABBADYCFAsgACAJNgIUIAAgBDYCECAAQQE6ABgLA0AgACgCFCADQQJ0akEANgIAIANBAWoiAyAERw0ACwsgACAENgIMIARBAU4EQCABIAIgCxshAUEAIQMDQAJAIAgoAkAEQCAAKAIUIANBAnRqQQA2AgAMAQsgBykCCCENIAUgCCgCGCADQdAAbGooAkA2AgwgBSANNwMQIAUgAzYCHCAFQX82AhggBSAHNgIIIAAoAgQiAiAFQQhqIAEgACgCICACKAIAKAIIEQoAIQIgACgCFCADQQJ0aiACNgIACyADQQFqIgMgBEcNAAsLIAVBIGokAAtzACAAQYSzATYCACAAIAEoAgA2AgQgAEH80gA2AgAgAEEBOgAYIABBlPkANgIAIABBADYCFCAAIAQ6ABwgAEIANwIMIAEoAgQhASAAQQA6ACQgACABNgIgIAAgAyACIAQbKAIEKAJENgIoIAAgAiADEKgEC80BAgl/AX4DQCAAKAIMIgYgAiIIIANqQQJtQQN0aigCACEJIAIhBSADIQQDQCAFIgJBAWohBSAGIAJBA3RqIgooAgAgCUgNACAEIQcDQCAHIgRBf2ohByAGIARBA3QiC2oiDCgCACAJSg0ACwJ/IAIgBEwEQCAKKQIAIQ0gCiAMKQIANwIAIAAoAgwgC2ogDTcCACAHIQQgBSECCyACIARMCwRAIAAoAgwhBiACIQUMAQsLIAQgCEoEQCAAIAEgCCAEEKoECyACIANIDQALC0sBAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIIIQEjAEEQayIAIAIoAgw2AgwgACABNgIIQbTtASAAKAIINgIAIAJBEGokAAtUAQF/IAAoAgwiAQRAIAAtABAEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYCDAsgAEEANgIMIABBAToAECAAQgA3AgQLVQEBfyMAQRBrIgQkACAEIAA2AgwgBCABOAIIIAQgAjYCBCAEIAM4AgAgBCgCDCIAIAQqAgggBCgCBCAEKgIAIAAoAgAoAjQRJQAhACAEQRBqJAAgAAvoCwIKfxp9IwBBQGoiCCQAIAhBADYCNCAIQgA3AiwgCEEBOgA4IAMoAgQiB0EBTgRAQej3AUHo9wEoAgBBAWo2AgAgB0EEdEEQQYzSASgCABEDACEMIAgoAiwiCUEBTgRAA0AgDCAKQQR0IgtqIg0gCCgCNCALaiILKQIANwIAIA0gCykCCDcCCCAKQQFqIgogCUcNAAsLIAgoAjQiCQRAIAgtADgEQCAJBEBB7PcBQez3ASgCAEEBajYCACAJQZDSASgCABEAAAsLIAhBADYCNAsgCCAMNgI0IAhBAToAOCAIIAc2AjALAkAgASgCHCIMQQFIDQAgAioCKCEWIAIqAiQhGiACKgIYIRQgAioCFCEbIAEoAiQhCyAAKgIIIRcgACoCBCEcIAAqAgAhGCACKgIgIR0gAioCECEeIAIqAgghHyACKgIEISAgAioCACEZQQAhCkP//39/IRNBfyEHA0AgCyAKQSRsaiIJKgIUIhEgGZQgCSoCGCISICCUkiAJKgIcIhUgH5SSIBiUIBEgHpQgEiAblJIgFSAUlJIgHJSSIBEgHZQgEiAalJIgFSAWlJIgF5SSIhEgEyARIBNdIgkbIRMgCiAHIAkbIQcgCkEBaiIKIAxHDQALIAdBAEgNAAJAIAEoAiQgB0EkbGoiCygCBCINQQFIBEAgAyEJDAELIAhBKGohB0EAIQoDQCAHIQkgASgCECIOIAsoAgwiD0EAIApBAWoiDCAMIA1GIhAbQQJ0aigCAEEEdGoiByoCCCEhIAcqAgAhGSAHKgIEISIgDiAPIApBAnRqKAIAQQR0aiIHKgIIIRMgByoCACERIAcqAgQhEiACKgI4ISMgAioCNCEkIAIqAjAhJSACKgIoIRUgAioCICEWIAIqAiQhGiALKgIcIRQgAioCCCEbIAsqAhQhFyACKgIAIRwgCyoCGCEYIAIqAgQhHSACKgIYIR4gAioCECEfIAIqAhQhICAIQQA2AiQgCCAcIBEgGZMiGZQgHSASICKTIiKUkiAbIBMgIZMiIZSSIiYgHyAXlCAgIBiUkiAeIBSUkiInlCAZIB+UICIgIJSSICEgHpSSIiggHCAXlCAdIBiUkiAbIBSUkiIplJMiKow4AiAgCCAoIBYgF5QgGiAYlJIgFSAUlJIiFJQgGSAWlCAiIBqUkiAhIBWUkiIXICeUkyIYjDgCGCAIIBcgKZQgJiAUlJOMIhQ4AhwgAyIHIAkgCEEYaiAkIBEgH5QgEiAglJIgEyAelJKSIBSUIBggJSARIByUIBIgHZSSIBMgG5SSkpSTICogIyARIBaUIBIgGpSSIBMgFZSSkpSTjBDeDCAHKAIEIgpBf0wEQCAHKAIIQX9MBEAgBygCDCIDBEAgBy0AEARAIAMEQEHs9wFB7PcBKAIAQQFqNgIAIANBkNIBKAIAEQAACwsgB0EANgIMCyAHQQE6ABAgB0IANwIICwNAIAcoAgwgCkEEdGoiAyAIKQIINwIAIAMgCCkCEDcCCCAKQQFqIgMgCk8hDiADIQogDg0ACwsgB0EANgIEIAwhCiAJIQMgEEUNAAsLIAkoAgQiB0EBSA0AIAsqAiAgCyoCFCITIAIqAgCUIAsqAhgiESACKgIElJIgCyoCHCISIAIqAgiUkiIVIAIqAjCUIBMgAioCEJQgESACKgIUlJIgEiACKgIYlJIiFiACKgI0lJIgEyACKgIglCARIAIqAiSUkiASIAIqAiiUkiITIAIqAjiUkpMhEUEAIQIDQCAEIBEgFSAJKAIMIAJBBHRqIgEqAgCUIBYgASoCBJSSIBMgASoCCJSSkiISIBIgBF8bIhIgBV9BAXNFBEAgCCABKQIINwMgIAggASkCADcDGCAGIAAgCEEYaiASIAYoAgAoAhARDwAgCSgCBCEHCyACQQFqIgIgB0gNAAsLIAgoAjQiAARAIAgtADgEQCAABEBB7PcBQez3ASgCAEEBajYCACAAQZDSASgCABEAAAsLIAhBADYCNAsgCEFAayQAC04BAX8jAEEQayIDJAAgAyAANgIMIAMgATgCCCADIAI2AgQgAygCDCIAIAMqAgggAygCBEOJiIg8IAAoAgAoAjQRJQAhACADQRBqJAAgAAulCQEYfSMAQZABayIDJAAgA0EANgJsIAEqAlAhBSABKgJgIQYgASoCeCEWIAEqAjghGiABKgJwIRcgASoCdCEYIAEqAjQhGyABKgJEIQcgASoCVCEOIAEqAmQhDyABKgIUIQggASoCJCEMIAEqAkghECABKgJYIQkgASoCGCENIAEqAmghCiABKgIoIREgASoCQCELIAEqAiAhEiABKgIAIRMgASoCECEUIAEqAjAhHCABKgIEIRUgASoCCCEZIANBADYCZCADQQA2AlQgA0EANgJEIAMgGSAQlCANIAmUkiARIAqUkjgCUCADIBUgEJQgCCAJlJIgDCAKlJI4AkwgA0FAayAZIAeUIA0gDpSSIBEgD5SSOAIAIAMgFSAHlCAIIA6UkiAMIA+UkjgCPCADIBAgHCAXkyIXlCAJIBsgGJMiGJSSIAogGiAWkyIWlJI4AmAgAyAXIAeUIBggDpSSIBYgD5SSOAJcIANBADYCNCADIBMgEJQgFCAJlJIgEiAKlJI4AkggAyATIAeUIBQgDpSSIBIgD5SSOAI4IAMgCyAZlCAFIA2UkiAGIBGUkjgCMCADIAsgFZQgBSAIlJIgBiAMlJI4AiwgAyALIBOUIAUgFJSSIAYgEpSSOAIoIAMgFyALlCAYIAWUkiAWIAaUkjgCWAJAIAAgA0HYAGogA0GAAWogA0HwAGogA0HsAGogACoCDBDkDEUNACAEBEAgASoCSCEOIAEqAkAhDyABKgJEIRAgASoCWCEJIAEqAlAhCiABKgJUIQsgASoCaCEIIAEqAmAhDCABKgJkIQ0gAyoCeCEFIAMqAnAhBiADKgJ0IQcgA0EANgIkIAMgBiAMlCAHIA2UkiAFIAiUkiIRjDgCICADIAYgCpQgByALlJIgBSAJlJIiEow4AhwgAyAPIAaUIBAgB5SSIA4gBZSSIhOMOAIYIAEqAnAhFCABKgJ0IRUgASoCeCEFIANBADYCFCADIAUgDCADKgKAASIGlCANIAMqAoQBIgeUkiAIIAMqAogBIgiUkpIgESADKgJsIgWUkjgCECADIBUgBiAKlCAHIAuUkiAIIAmUkpIgEiAFlJI4AgwgAyAUIAYgD5QgByAQlJIgCCAOlJKSIBMgBZSSOAIIIAIgA0EYaiADQQhqIAUgAigCACgCEBEPAAwBCyABKgJIIQUgASoCQCEGIAEqAkQhByABKgJYIQ4gASoCUCEPIAEqAlQhECABKgJoIQkgASoCYCEKIAEqAmQhCyADQQA2AiQgAyAKIAMqAnAiCJQgCyADKgJ0IgyUkiAJIAMqAngiDZSSOAIgIAMgCCAPlCAMIBCUkiANIA6UkjgCHCADIAYgCJQgByAMlJIgBSANlJI4AhggASoCcCEIIAEqAnQhDCABKgJ4IQ0gA0EANgIUIAMgDSAKIAMqAoABIgqUIAsgAyoChAEiC5SSIAkgAyoCiAEiCZSSkjgCECADIAwgCiAPlCALIBCUkiAJIA6UkpI4AgwgAyAIIAogBpQgCyAHlJIgCSAFlJKSOAIIIAIgA0EYaiADQQhqIAMqAmwgAigCACgCEBEPAAsgA0GQAWokAAtEAQF/IwBBEGsiAiQAIAIgADYCDCACIAE4AgggAigCDCIAIAIqAghBAUOJiIg8IAAoAgAoAjQRJQAhACACQRBqJAAgAAuAAgIBfwx9IwBBMGsiBSQAIAUgBDYCLCAFIAM2AiggAEFAayoCACEJIAAqAjwhCiAAKgJQIQsgACoCSCEMIAAqAkwhDSAAKgJgIQ4gACoCWCEPIAAqAlwhECAAKgI4IREgASoCCCEGIAEqAgAhByABKgIEIQggACgCMCEBIAVBADYCHCAFIAcgD5QgCCAQlJIgBiAOlJI4AhggBSAHIAyUIAggDZSSIAYgC5SSOAIUIAUgAjgCICAFIAE2AgggBSARIAeUIAogCJSSIAkgBpSSOAIQIAUgBUEoajYCDCAAKAIsIgAgBUEIakEBIAAoAgAoAgwRDQAhAiAFQTBqJAAgAgumCQIIfwZ9IwBB0ABrIgEkAAJAIAAgACgCACgCFBEBAEUNACAAIAAoAgAoAhQRAQAiAiACKAIAKAIwEQEAQQhxRQ0AIAAoAhgiAiACKAIAKAIkEQEAIQUgAUIANwNIIAFCgICA/IOAgMA/NwNAQQAhAiAFQQBMDQADQEEAIQMgACgCGCIEIAIgBCgCACgCKBEDACIGKALsBSIHQQBKBEADQCAAIAAoAgAoAhQRAQAiCCAGIANBuAFsaiIEQSRqIARBxABqIAQqAlQgBCgCmAEgAUFAayAIKAIAKAIgESYAIANBAWoiAyAHRw0ACwsgAkEBaiICIAVHDQALCwJAIAAgACgCACgCFBEBAEUNACAAIAAoAgAoAhQRAQAiAiACKAIAKAIwEQEAQQNxRQ0AIAAoAghBAUgNAEEAIQUDQAJAIAAoAhAgBUECdGooAgAiAi0AzAFBIHENAAJAIAAgACgCACgCFBEBAEUNACAAIAAoAgAoAhQRAQAiAyADKAIAKAIwEQEAQQFxRQ0AIAFCgICA/AM3A0ggAUKAgID8g4CAwD83A0ACfwJ/AkAgAigC2AFBf2oiA0EESw0AAkACQAJAAkAgA0EBaw4EAQIEAwALQYCAgPwDIQMgAUGAgID8AzYCQEGAgID8AwwFCyABQQA2AkBBgICA/AMhA0EADAQLIAFBADYCQEGAgID8AyEDQYCAgPwDDAMLIAFBgICA/AM2AkBBgICA/AMMAQsgAUGAgID8AzYCQEEACyEDQQALIQQgAUEANgJMIAEgBDYCSCABIAM2AkQgACACQQRqIAIoAsABIAFBQGsgACgCACgCHBEEAAsgACgCSCIDRQ0AIAMgAygCACgCMBEBAEECcUUNACABQgA3AyggAUKAgID8AzcDICACKALAASIDIAJBBGogAUFAayABQTBqIAMoAgAoAggRBAAgASABKgJAQYDSASoCACIJkzgCQCABIAEqAkQgCZM4AkQgASABKgJIIAmTOAJIIAEgCSABKgIwkjgCMCABIAkgASoCNJI4AjQgASAJIAEqAjiSOAI4AkAgAC0ALEUNACACKALsAUECRw0AIAItAMwBQQNxDQAgAigCwAEiAyACQcQAaiABQRBqIAEgAygCACgCCBEEACABIAEqAhAgCZMiCjgCECABIAEqAhQgCZMiCzgCFCABIAEqAhggCZMiDDgCGCABIAkgASoCAJIiDTgCACABIAkgASoCBJIiDjgCBCABIAkgASoCCJIiCTgCCCAKIAEqAkBdQQFzRQRAIAEgCjgCQAsgCyABKgJEXUEBc0UEQCABIAs4AkQLIAwgASoCSF1BAXNFBEAgASAMOAJICyABKgIcIgogASoCTF1BAXNFBEAgASAKOAJMCyABKgIwIA1dQQFzRQRAIAEgDTgCMAsgASoCNCAOXUEBc0UEQCABIA44AjQLIAEqAjggCV1BAXNFBEAgASAJOAI4CyABKgI8IAEqAgwiCV1BAXMNACABIAk4AjwLIAAoAkgiAiABQUBrIAFBMGogAUEgaiACKAIAKAI0EQQACyAFQQFqIgUgACgCCEgNAAsLIAFB0ABqJAALSAEBfyMAQRBrIgMkACADIAA2AgwgAyABNgIIIAMgAjoAByADKAIMIgAgAygCCCADLQAHQQFxIAAoAgAoAjgRBQAgA0EQaiQAC/8FAgJ/B30jAEFAaiICJAAgASgCwAEiAyABQQRqIAJBMGogAkEgaiADKAIAKAIIEQQAIAIgAioCMEGA0gEqAgAiBJMiBTgCMCACIAIqAjQgBJMiBzgCNCACIAIqAjggBJMiCDgCOCACIAQgAioCIJIiBjgCICACIAQgAioCJJIiCTgCJCACIAQgAioCKJIiCjgCKAJAIAAtACxFDQAgASgC7AFBAkcNACABLQDMAUEDcQ0AIAEoAsABIgMgAUHEAGogAkEQaiACIAMoAgAoAggRBAAgAiACKgIQIASTIgc4AhAgAiACKgIUIASTIgg4AhQgAiACKgIYIASTIgY4AhggAiAEIAIqAgCSIgk4AgAgAiAEIAIqAgSSIgo4AgQgAiAEIAIqAgiSIgQ4AgggByACKgIwIgVdQQFzRQRAIAIgBzgCMCAHIQULIAggAioCNCIHXUEBc0UEQCACIAg4AjQgCCEHCyAGIAIqAjgiCF1BAXNFBEAgAiAGOAI4IAYhCAsgAioCHCIGIAIqAjxdQQFzRQRAIAIgBjgCPAsgAioCICIGIAldQQFzRQRAIAIgCTgCICAJIQYLIAIqAiQiCSAKXUEBc0UEQCACIAo4AiQgCiEJCyACKgIoIgogBF1BAXNFBEAgAiAEOAIoIAQhCgsgAioCLCACKgIMIgRdQQFzDQAgAiAEOAIsCyAAKAJEIQMCQAJAIAEtAMwBQQFxRQRAIAYgBZMiBSAFlCAJIAeTIgUgBZSSIAogCJMiBSAFlJJDpdRoU11BAXMNAQsgAyABKAK8ASACQTBqIAJBIGogACgCGCADKAIAKAIQEQkADAELIAEoAtgBQX5xQQRHBEAgAUEFNgLYAQtBuO0BLQAADQAgACgCSCIBRQ0AQbjtAUEBOgAAIAFB2OMAIAEoAgAoAiQRAgAgACgCSCIBQYnkACABKAIAKAIkEQIAIAAoAkgiAUHN5AAgASgCACgCJBECACAAKAJIIgBBjuUAIAAoAgAoAiQRAgALIAJBQGskAAs7AQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDCIAIAIoAghBACAAKAIAKAI4EQUAIAJBEGokAAuqAgAgACABNgIEIABBuOIANgIAIAAgAikCCDcCECAAIAIpAgA3AgggACACKQIYNwIgIAAgAikCEDcCGCAAIAIpAig3AjAgACACKQIgNwIoIABBQGsgAikCODcCACAAIAIpAjA3AjggACADKQIINwJQIAAgAykCADcCSCAAIAMpAhg3AmAgACADKQIQNwJYIAAgAykCKDcCcCAAIAMpAiA3AmggACADKQI4NwKAASAAIAMpAjA3AnggACAEKQIINwKQASAAIAQpAgA3AogBIAAgBCkCGDcCoAEgACAEKQIQNwKYASAAIAQpAig3ArABIAAgBCkCIDcCqAEgACAEKQI4NwLAASAAIAQpAjA3ArgBIABBADYC0AEgACAFOALMASAAQYCAgPwDNgLIAQu3CgIHfw59IwBBsAJrIgYkACABKgI0IQ8gAioCNCEQIAEqAjghESACKgI4IRIgASoCMCEOIAIqAjAhDSAGQQA2AqwCIAYgEiARkyIUOAKoAiAGIBAgD5MiGTgCpAIgBiANIA6TIhM4AqACIAEgAiAGQfAAaiAGQTBqEGYgBkEANgKcAiAGIAYqAjAiDSAGKgJ4lCIVOAKYAiAGIA0gBioCdJQiFjgClAIgBiANIAYqAnCUIhc4ApACIAMqAjQhDyAEKgI0IRAgAyoCOCERIAQqAjghEiADKgIwIQ4gBCoCMCENIAZBADYCjAIgBiASIBGTIho4AogCIAYgECAPkyIPOAKEAiAGIA0gDpMiEDgCgAIgAyAEIAZB8ABqIAZBMGoQZiAGQQA2AvwBIAYgBioCMCINIAYqAniUIhg4AvgBIAYgDSAGKgJ0lCIROAL0ASAGIA0gBioCcJQiDTgC8AEgACgCDCICIAIoAgAoAhARBgAhDkMAAAAAIRIgACgCECICBEAgAiACKAIAKAIQEQYAIRIgBioCqAIhFCAGKgKIAiEaIAYqAqQCIRkgBioChAIhDyAGKgKgAiETIAYqAoACIRAgBioC+AEhGCAGKgL0ASERIAYqApgCIRUgBioClAIhFiAGKgKQAiEXIAYqAvABIQ0LAkAgDiAXIBeUIBYgFpSSIBUgFZSSkZQgEiANIA2UIBEgEZSSIBggGJSSkZSSIhEgECATkyITIBOUIA8gGZMiDyAPlJIgGiAUkyIQIBCUkpGSQwAAAABbDQAgBkEAOgDYASAGQeuW+OoFNgLUASAGQaThADYCsAEgACABIAMgBkGwAWoQuQQgBiAGKQLMATcD6AEgBiAGKQLEATcD4AEgBi0A2AFFDQAgESATIAYoArQBIgK+lCAPIAYoArgBIgm+lJIgECAGKAK8ASIKvpSSkkMAAAA0Xw0AQQEhB0MAAAAAIQ0CQAJ9IAYqAsABIAYqAtQBIAUqAqwBkiIUQ28SgzpeQQFzDQAaIAZBFGohCyAGQaABaiEMQQAhBANAIAUoAqgBIggEQCAGQoCAgPwDNwN4IAZCgICA/IOAgMA/NwNwIAggBkHgAWpDzcxMPiAGQfAAaiAIKAIAKAIUERcACyARIBMgAr6UIA8gCb6UkiAQIAq+lJKSIg5DAAAANF8EQEEAIQcMBAsgDSAUIA6VkiIOIA1fBEBBACEHDAQLIA5DAACAP14EQEEAIQcMBAsgDkMAAAAAXQRAQQAhBwwECyABIAZBoAJqIAZBkAJqIA4gBkHwAGoQVSADIAZBgAJqIAZB8AFqIA4gBkEwahBVIAUoAqgBIgIEQCAGQgA3AwggBkKAgID8AzcDACACIAxDzcxMPiAGIAIoAgAoAhQRFwALIAUgDiAFKAIAKAIAEQgAIAZBADoAKCAGQeuW+OoFNgIkIAZBpOEANgIAIAAgBkHwAGogBkEwaiAGELkEIAYtAChFDQIgBSoCrAEhEiAGIAspAgg3A+gBIAYgCykCADcD4AEgBEEBaiEIIARBP0sEQCAFQX4gCCAFKAIAKAIIEQUAQQAhBwwECyAGKAIEIQIgBigCCCEJIAYoAgwhCiAIIQQgDiENIAYqAiQgEpIiFENvEoM6Xg0ACyAGKgIQCyEVIAUgAjYChAEgBSANOAKkASAFIBU4ApABIAUgCjYCjAEgBSAJNgKIASAFIAYpA+ABNwKUASAFIAYpA+gBNwKcAQwBCyAFQX8gBCAFKAIAKAIIEQUAQQAhBwsgBkGwAmokACAHC5UKAgN/K30jAEHwAWsiBCQAAkAgACgCEARAIAAoAgQQ5gEgBEGgAWogACgCDCIFIAAoAhAiBiAFKAIEIAYoAgQgBSAFKAIAKAIwEQYAIAAoAhAiBSAFKAIAKAIwEQYAIAAoAgQgACgCCBC5DSEAIARB65b46gU2ApgBIAQgASkCCDcDICAEIAEpAgA3AxggBCABKQIYNwMwIAQgASkCEDcDKCAEQUBrIAEpAig3AwAgBCABKQIgNwM4IAQgASkCODcDUCAEIAEpAjA3A0ggBCACKQIINwNgIAQgAikCADcDWCAEIAIpAhA3A2ggBCACKQIYNwNwIAQgAikCKDcDgAEgBCACKQIgNwN4IAQgAikCMDcDiAEgBCACKQI4NwOQASAAIARBGGogA0EAQQAQRAwBCyACKgI0ISQgAioCOCEcIAEqAjQhHSABKgI4IR4gASoCFCEJIAEqAiQhCiACKgIUIQsgAioCJCENIAIqAhghByABKgIYIQwgAioCKCEIIAEqAighDyACKgIwIR8gASoCMCEgIAAoAgwhBSABKgIgIRAgASoCACERIAEqAhAhFCABKgIEIRUgAioCICESIAIqAhAhDiACKgIAIRkgAioCBCEaIAIqAgghGyABKgIIIRYgACgCFCIAIgFBNGoqAgAhEyAAKgI4IRcgACoCMCEYIARBADYCrAEgBCAWIBqUIAwgC5SSIA8gDZSSIiUgE4wiE5QgGCAWIBmUIAwgDpSSIA8gEpSSIiaUkyAXIBYgG5QgDCAHlJIgDyAIlJIiJ5STOAKoASAEIBUgGpQgCSALlJIgCiANlJIiKCATlCAYIBUgGZQgCSAOlJIgCiASlJIiKZSTIBcgFSAblCAJIAeUkiAKIAiUkiIqlJM4AqQBIAQgESAalCAUIAuUkiAQIA2UkiIrIBOUIBggESAZlCAUIA6UkiAQIBKUkiIslJMgFyARIBuUIBQgB5SSIBAgCJSSIi2UkzgCoAEgBEEYaiAFIARBoAFqIAUoAgAoAkARBQAgASoCNCEJIAAqAjghCiAAKgJAIS4gACoCMCEMIAQqAhghDyAEKgIcIRAgBCoCICERIAIqAjQhLyACKgIYIRQgAioCFCEVIAIqAjghMCACKgIoIRYgAioCJCEXIAIqAjAhMSACKgIIIRggAioCACETIAIqAgQhISACKgIQISIgAioCICEjIARBADYCrAEgBCAwICMgICAZlCAdIA6UkiAeIBKUkiAOICSMIg6UIBkgH5STIBIgHJSTkiAsIA+UICkgEJSSICYgEZSSkiISIAwgCiAgIBuUIB0gB5SSIB4gCJSSIAcgDpQgGyAflJMgCCAclJOSIC0gD5QgKiAQlJIgJyARlJKSIgiUIAwgEpQgCSAgIBqUIB0gC5SSIB4gDZSSIAsgDpQgGiAflJMgDSAclJOSICsgD5QgKCAQlJIgJSARlJKSIgeUkpIgLpMiC5STIg2UIBcgByAJIAuUkyIHlJIgFiAIIAogC5STIgiUkpI4AqgBIAQgLyANICKUIAcgFZSSIAggFJSSkjgCpAEgBCAxIBggCJQgEyANlCAhIAeUkpKSOAKgASAEQQA2AhQgBCAMICOUIAkgF5SSIAogFpSSOAIQIAQgDCAilCAJIBWUkiAKIBSUkjgCDCAEIBMgDJQgISAJlJIgGCAKlJI4AgggAyAEQQhqIARBoAFqIAsgAygCACgCEBEPAAsgBEHwAWokAAs5AQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDCIAIAIoAgggACgCACgCXBECACACQRBqJAAL+gMBBn0jAEGgAWsiAyQAIAMgASgCADYCcCADIAEoAkA2AkAgAyABKAIENgJ0IAMgASgCRDYCRCADIAEoAgg2AnggAyABKAJINgJIIAMgASgCEDYCgAEgAyABKAJQNgJQIAMgASgCFDYChAEgAyABKAJUNgJUIAMgASgCGDYCiAEgAyABKAJYNgJYIAMgASgCIDYCkAEgAyABKAJgNgJgIAMgASgCJDYClAEgAyABKAJkNgJkIAMgASgCKDYCmAEgAyABKAJoNgJoIAAoAgQiBCoCJCEGIAQqAiAhBSAEKgIcIQcgBCAEKAIAKAIwEQYAIQggBCAEKAIAKAIwEQYAIQkgBCAEKAIAKAIwEQYAIQogA0EANgIkIAMgBSAJkiIFIAWSOAIcIAMgByAIkiIFIAWSOAIYIAMgBiAKkiIGIAaSOAIgIAAoAggiACoCJCEGIAAqAiAhBSAAKgIcIQcgACAAKAIAKAIwEQYAIQggACAAKAIAKAIwEQYAIQkgACAAKAIAKAIwEQYAIQogA0EANgIUIAMgBSAJkiIFIAWSOAIMIAMgByAIkiIFIAWSOAIIIAMgBiAKkiIGIAaSOAIQIAFBMGogA0HwAGogA0EYaiABQfAAaiADQUBrIANBCGogA0EwaiADQSxqIANBKGogAhCMDSADQaABaiQAC1EBAX8jAEEQayIEJAAgBCAANgIMIAQgATYCCCAEIAI7AQYgBCADOwEEIAQoAgwiACAEKAIIIAQuAQYgBC4BBCAAKAIAKAJYEQQAIARBEGokAAufAQEBfyAAQYSzATYCACAAIAEoAgA2AgQgAEH80gA2AgAgACAEOgAIIABB8NwANgIAIAEoAgAhASAAQUBrQQA2AgAgACABNgI8IABBjN0ANgIMIAAgAiADIAQbIgU2AhQgACADIAIgBBsiAjYCECAAIAEgAigCCCAFKAIIIAEoAgAoAgwRBwAiATYCTCAAKAI8IgAgASAAKAIAKAIUEQIACzkBAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIgAgAigCCCAAKAIAKAJUEQIAIAJBEGokAAu5AgENfwNAIAAoAgwiCCACIgwgA2pBAm1BAnRqKAIAIQkgAyEGIAIhBwNAIAkoAuQFKALQASEKA0AgCCAHIgJBAnRqIg4oAgAiDSgC5AUoAtABIgRBf0wEQCANKALoBSgC0AEhBAsgCiEFIAJBAWohByAEIApBf0oiDwR/IAUFIAkoAugFKALQAQtIDQALA0AgCCAGIgRBAnQiEGooAgAhCyAKIQUgBEF/aiEGIAUgCSgC6AUoAtABIA8bIAsoAuQFKALQASIFQX9MBH8gCygC6AUoAtABBSAFC0gNAAsCfyACIARMBEAgDiALNgIAIAAoAgwgEGogDTYCACAGIQQgByECCyACIARMCwRAIAAoAgwhCCAEIQYgAiEHDAELCyAEIAxKBEAgACABIAwgBBC/BAsgAiADSA0ACws5AQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDCIAIAIoAgggACgCACgCSBECACACQRBqJAAL9gEBAX8CQCABQQhHIgMNACACQQhHDQAgACgCPA8LAkAgAw0AIAJBAUcNACAAKAJMDwsCQCABQQFHDQAgAkEIRw0AIAAoAlAPCyABIAJyRQRAIAAoAkgPCwJAIAFBE0oNACACQRxHDQAgACgCWA8LAkAgAUEcRw0AIAJBE0oNACAAKAJUDwsCQCABQRNMBEAgAkETTARAIAAoAiAPCyACQWtqQQhLDQEgACgCJA8LAkAgAkETSg0AIAFBa2pBCEsNACAAKAIoDwsgAUEfRw0AIAJBH0YEQCAAKAIwDwsgACgCLA8LIAJBH0YEQCAAKAI0DwsgACgCOAsHACAAKAJEC0wBAX8jAEEQayICJAAgAiAANgIMIAIgATgCCCACKgIIIQEjAEEQayIAIAIoAgw2AgwgACABOAIIIAAoAgwgACoCCDgCDCACQRBqJAALNAAgABDHBBogASAAKQL0ATcCACABIAApAvwBNwIIIAIgACkCjAI3AgggAiAAKQKEAjcCAAvBAQIEfwV9AkAgACgCACIFQQFIBEAMAQsgACoCtAIhByABKgIIIQggASoCBCEJIAEqAgAhCgNAIAIgCiAAIANBBHRqIgQqAgSTIgYgBpQgCSAEKgIIkyIGIAaUkiAIIAQqAgyTIgYgBpSSIAdfciECIANBAWoiAyAFRw0ACwsCQCABKgIMIAAqArACXA0AIAEqAgggACoCrAJcDQAgASoCBCAAKgKoAlwNACABKgIAIAAqAqQCXA0AQQEhAgsgAkEBcQsjAQF/IAAQxwQhAiABIAApApwCNwIIIAEgACkClAI3AgAgAgv7DQIEfw99IwBBEGsiAiQAAkAgAC0A5AJFBEAgAC0AuAIhAQwBCyAAQQA6AOQCIABBADoA4AIgAEIANwLYAiAAQgA3AtACIAAgAC0AzAJBcHEiAzoAzAICQCAAKAIAIgRBBEsNACAAQbwCaiEBAkACQAJAAkACQAJAIARBAWsOBAUAAQIDCwJ/QQFDAAAAACAAKgIEIgaTIAAqAhQgBpMiBpRDAAAAACAAKgIIIgeTIAAqAhggB5MiB5SSQwAAAAAgACoCDCIIkyAAKgIcIAiTIgiUkiIJQwAAAABeQQFzDQAaIAkgBiAGlCAHIAeUkiAIIAiUkiIFXUEBcwRAQwAAgD8hBUECDAELIAkgBZUhBUEDCyEBIABCADcC2AIgACAFOALUAiAAQwAAgD8gBZM4AtACIAAgASADcjoAzAJBACEBIABBADYCgAIgACAAKgJcIgYgBSAAKgJsIAaTlJIiCTgC/AEgACAAKgJYIgYgBSAAKgJoIAaTlJIiCjgC+AEgACAAKgJUIgYgBSAAKgJkIAaTlJIiCzgC9AEgACoCtAEhDCAAKgK4ASENIAAqAqgBIQYgACoCvAEhDiAAKgKsASEHIAAqAqQBIQggAEEANgKgAiAAIAkgByAFIA4gB5OUkiIHkzgCnAIgACAKIAYgBSANIAaTlJIiBpM4ApgCIAAgCyAIIAUgDCAIk5SSIgWTOAKUAiAAQQA2ApACIAAgBzgCjAIgACAGOAKIAiAAIAU4AoQCIAAgAEHMAmoQygIgACoC0AJDAAAAAGBBAXMNBSAAKgLUAkMAAAAAYEEBcw0FIAAqAtgCQwAAAABgQQFzDQUgACoC3AJDAAAAAGAhAQwFCyACQgA3AwggAkIANwMAIAIgAEEEaiAAQRRqIABBJGogARCrAUEAIQEgAEEANgKAAiAAIAAqAtACIgUgACoCXJQgACoC1AIiBiAAKgJslJIgACoC2AIiByAAKgJ8lJIiCDgC/AEgACAFIAAqAliUIAYgACoCaJSSIAcgACoCeJSSIgk4AvgBIAAgBSAAKgJUlCAGIAAqAmSUkiAHIAAqAnSUkiIKOAL0ASAAKgK0ASELIAAqAsQBIQwgACoCqAEhDSAAKgK4ASEOIAAqAsgBIQ8gACoCrAEhECAAKgK8ASERIAAqAswBIRIgACoCpAEhEyAAQQA2AqACIAAgCCAFIBCUIAYgEZSSIAcgEpSSIgiTOAKcAiAAIAkgBSANlCAGIA6UkiAHIA+UkiIJkzgCmAIgACAKIAUgE5QgBiALlJIgByAMlJIiBZM4ApQCIABBADYCkAIgACAIOAKMAiAAIAk4AogCIAAgBTgChAIgACAAQcwCahDKAiAAKgLQAkMAAAAAYEEBcw0EIAAqAtQCQwAAAABgQQFzDQQgACoC2AJDAAAAAGBBAXMNBCAAKgLcAkMAAAAAYCEBDAQLIAJCADcDCCACQgA3AwAgAiAAQQRqIABBFGogAEEkaiAAQTRqIAEQ3Q0EQEEAIQEgAEEANgKAAiAAIAAqAtACIgUgACoCXJQgACoC1AIiBiAAKgJslJIgACoC2AIiByAAKgJ8lJIgACoC3AIiCCAAKgKMAZSSIgk4AvwBIAAgBSAAKgJYlCAGIAAqAmiUkiAHIAAqAniUkiAIIAAqAogBlJIiCjgC+AEgACAFIAAqAlSUIAYgACoCZJSSIAcgACoCdJSSIAggACoChAGUkiILOAL0ASAAQQA2AqACIABBADYCkAIgACAFIAAqAqQBlCAGIAAqArQBlJIgByAAKgLEAZSSIAggACoC1AGUkiIMOAKEAiAAIAUgACoCqAGUIAYgACoCuAGUkiAHIAAqAsgBlJIgCCAAKgLYAZSSIg04AogCIAAgBSAAKgKsAZQgBiAAKgK8AZSSIAcgACoCzAGUkiAIIAAqAtwBlJIiBTgCjAIgACALIAyTOAKUAiAAIAogDZM4ApgCIAAgCSAFkzgCnAIgACAAQcwCahDKAiAAKgLQAkMAAAAAYEEBcw0EIAAqAtQCQwAAAABgQQFzDQQgACoC2AJDAAAAAGBBAXMNBCAAKgLcAkMAAAAAYCEBDAQLIAAtAOACRQ0BC0EAIQEMAgsgAEIANwKUAkEBIQEgAEEBOgC4AiAAQgA3ApwCDAILIAAgACkCpAE3AoQCIAAgACkCVDcC9AEgACAAKQKsATcCjAIgACAAKQJcNwL8ASAAQQA6AOACIABBADYCoAIgACAAKgL4ASAAKgKIApM4ApgCIAAgACoC9AEgACoChAKTOAKUAiAAIAAqAvwBIAAqAowCkzgCnAIgAEIANwLYAiAAQoCAgPwDNwLQAiAAIAM6AMwCQQEhAQsgACABOgC4AgsgAkEQaiQAIAFBAEcLjgEBAX8gACABKQIANwKkAiAAIAEpAgg3AqwCIABBAToA5AIgACAAKAIAQQR0aiIEIAEpAgA3AgQgBCABKQIINwIMIAAgACgCAEEEdGoiASACKQIINwJcIAEgAikCADcCVCAAIAAoAgBBBHRqIgEgAykCCDcCrAEgASADKQIANwKkASAAIAAoAgBBAWo2AgALLAAgAEGQ2AEgASACIAMgBBDMBAR/QQEFIABBkNgBIAEgAiADIARBABDNAgsLUgEBfyMAQRBrIgQkACAEIAA2AgwgBCABNgIIIAQgAjYCBCAEIAM2AgAgBCgCDCIAIAQoAgggBCgCBCAEKAIAIAAoAgAoAggRCgAaIARBEGokAAviCAIJfxV9IwBBQGoiBSACNgI8IAUgATYCOCAFIAA2AjQgASoCACEOIAAqAgAhESABKgIEIRIgACoCBCEQIAEqAgghFiAAKgIIIRMgBUEANgIMIAUgEyAWkyIPOAIIIAUgECASkyIVOAIEIAUgESAOkyIUOAIAIAIqAgAhFyACKgIEIRggAioCCCEZIAVBADYCLCAFQQA2AhwgBSAZIBOTIhw4AiggBSAYIBCTIh04AiQgBSAWIBmTIhk4AhggBSASIBiTIho4AhQgBSAXIBGTIh44AiAgBSAOIBeTIhs4AhBDAACAvyESIBQgGpQgFSAblJMiFiAWlCAVIBmUIA8gGpSTIhcgF5QgDyAblCAUIBmUkyIYIBiUkpIiH0MAAAAAXkUEQEMAAIC/DwsDQAJAIBEgFiAVlCAYIA+Uk5QgECAXIA+UIBYgFJSTlJIgGCAUlCAXIBWUkyATlJJDAAAAAF5BAXMEQCASIQ4MAQsCfUMAAIC/IAdBAnQiDEGsygBqKAIAIg1BAnQiBiAFQTRqaigCACILKgIAIiAgEZMiFSAVlCALKgIEIiEgEJMiFCAUlJIgCyoCCCIiIBOTIg4gDpSSIg9DAAAAAF5BAXMNABogESAVlCAQIBSUkiATIA6UkowgD5UiD0MAAIA/YEEBc0UEQEGAgID8AyEJQQAhCkECIQggICAglCAhICGUkiAiICKUkgwBCyAPQwAAAABfQQFzRQRAQQAhCUGAgID8AyEKQQEhCCARIBGUIBAgEJSSIBMgE5SSDAELQwAAgD8gD5O8IQogD7whCUEDIQggEyAOIA+UkiIOIA6UIBEgFSAPlJIiDiAOlCAQIBQgD5SSIg4gDpSSkgshDgJAIBJDAAAAAF0NACAOIBJdQQFzRQ0AIBIhDgwBCyAEQQAgCEEBcWtBASAHdHFBASANdCAIQR50QR91cWo2AgAgAyAMaiAKNgIAIAMgBmogCTYCACADIAZBrMoAaigCAEECdGpBADYCAAsgB0EBaiIHQQNHBEAgBSAHQQR0aiIGKgIAIRQgBioCCCEPIAYqAgQhFSAFQTRqIAdBAnRqKAIAIgYqAgghEyAGKgIEIRAgBioCACERIA4hEgwBCwsgDkMAAAAAXQR9IAAqAgghDiAAKgIAIRIgACoCBCERIARBBzYCACADIBsgASoCBCAYIBcgEpQgGCARlJIgFiAOlJIgH5UiEZQiDpMiEJQgGiABKgIAIBcgEZQiEpMiE5STIg8gD5QgGiABKgIIIBYgEZQiEZMiD5QgGSAQlJMiECAQlCAZIBOUIBsgD5STIhAgEJSSkpEgH5EiEJUiEzgCACADIB4gAioCBCAOkyIPlCAdIAIqAgAgEpMiFZSTIhQgFJQgHSACKgIIIBGTIhSUIBwgD5STIg8gD5QgHCAVlCAeIBSUkyIPIA+UkpKRIBCVIhA4AgQgA0MAAIA/IBMgEJKTOAIIIBEgEZQgEiASlCAOIA6UkpIFIA4LC+cOAgN/GH0jAEGgBGsiBiQAIAVCADcCACAFQQA2AiAgBUIANwIYIAVCADcCECAFQgA3AgggBiACNgKEAyAGIAA2AoADIAMqAhQhCyADKgIkIQwgASoCFCENIAEqAiQhDiADKgIYIQ8gASoCGCEJIAMqAighCiABKgIoIRAgAyoCICERIAMqAgAhEiADKgIQIRMgAyoCBCEUIAEqAiAhFSABKgIAIRYgASoCECEXIAEqAgQhGCADKgIIIRkgASoCCCEaIAZBADYCtAMgBkEANgKkAyAGQQA2ApQDIAYgGiAZlCAJIA+UkiAQIAqUkiIbOAKwAyAGIBggGZQgDSAPlJIgDiAKlJIiHDgCrAMgBiAWIBmUIBcgD5SSIBUgCpSSIg84AqgDIAYgGiAUlCAJIAuUkiAQIAyUkiIKOAKgAyAGIBggFJQgDSALlJIgDiAMlJIiGTgCnAMgBiAWIBSUIBcgC5SSIBUgDJSSIgs4ApgDIAYgEiAalCATIAmUkiARIBCUkiIMOAKQAyAGIBIgGJQgEyANlJIgESAOlJIiDTgCjAMgBiASIBaUIBMgF5SSIBEgFZSSIg44AogDIAEqAhQhCSABKgIkIRAgASoCGCERIAEqAjQhEiADKgI0IRMgASoCKCEUIAEqAjghFSADKgI4IRYgASoCACEXIAEqAhAhGCABKgIgIRogASoCBCEdIAEqAgghHiABKgIwIR8gAyoCMCEgIAZBADYC/AMgBkEANgL0AyAGQQA2AuQDIAYgGzgC4AMgBiAKOALcAyAGIAw4AtgDIAZBADYC1AMgBiAcOALQAyAGIBk4AswDIAYgDTgCyAMgBkEANgLEAyAGIA84AsADIAYgCzgCvAMgBiAeICAgH5MiC5QgESATIBKTIgyUkiAUIBYgFZMiDZSSOALwAyAGIAsgHZQgDCAJlJIgDSAQlJI4AuwDIAYgCyAXlCAMIBiUkiANIBqUkjgC6AMgBkGBAzYC+AMgBiAOOAK4AyAGQgA3A4gBIAZCADcDgAEgBkIANwLsAiAGQQI2AvgCIAZBADYCkAECQAJAIAYgBkGAA2ogBBDOAiIARQRAIAYoAvQCIgcoAiBFBEBDAAAAACELQwAAAAAhDEMAAAAAIQ1DAAAAACEOQwAAAAAhD0MAAAAAIQkMAgtDAAAAACEJQQAhA0MAAAAAIQ9DAAAAACEOQwAAAAAhDUMAAAAAIQxDAAAAACELA0AgByADQQJ0IgRqIggqAhAhCiAGKAL4AyEHIAZBkARqIAYoAoADIAYoAvwDIgJBAXVqIgAgCCgCACAAKAIAIAdqKAIAIAcgAkEBcRsRBQAgBigChAMgBigC/AMiCEEBdWohACAGKAL0AiAEaigCACICKgIIIRAgBigC+AMhByAAKAIAIAdqKAIAIAcgCEEBcRshByACKgIAIREgAioCBIwhEiAJIAogBioCmASUkiEJIA8gCiAGKgKUBJSSIQ8gDiAKIAYqApAElJIhDiAGQQA2AowEIAYgBioCrAMgEpQgESAGKgKoA5STIBAgBioCsAOUkzgCiAQgBiAGKgKcAyASlCARIAYqApgDlJMgECAGKgKgA5STOAKEBCAGIAYqAowDIBKUIBEgBioCiAOUkyAQIAYqApADlJM4AoAEIAZBkARqIAAgBkGABGogBxEFACANIAogBioCkAQiECAGKgLYA5QgBioClAQiESAGKgLcA5SSIAYqApgEIhIgBioC4AOUkiAGKgLwA5KUkiENIAwgCiAQIAYqAsgDlCARIAYqAswDlJIgEiAGKgLQA5SSIAYqAuwDkpSSIQwgCyAKIBAgBioCuAOUIBEgBioCvAOUkiASIAYqAsADlJIgBioC6AOSlJIhCyADQQFqIgMgBigC9AIiBygCIEkNAAsMAQsgBUEBQQIgAEEBRhs2AgAMAQsgASoCMCEKIAEqAgghECABKgIAIREgASoCBCESIAEqAjQhEyABKgIYIRQgASoCECEVIAEqAhQhFiABKgI4IRcgASoCKCEYIAEqAiAhGSABKgIkIRogBUEANgIQIAUgFyAOIBmUIA8gGpSSIAkgGJSSkjgCDCAFIBMgDiAVlCAPIBaUkiAJIBSUkpI4AgggBSAKIA4gEZQgDyASlJIgCSAQlJKSOAIEIAEqAjAhECABKgIIIREgASoCACESIAEqAgQhEyABKgI0IRQgASoCGCEVIAEqAhAhFiABKgIUIRcgASoCOCEYIAEqAighGSABKgIgIRogASoCJCEbIAUgDiALkyIOIA6UIA8gDJMiDyAPlJIgCSANkyIJIAmUkpEiCjgCNCAFQQA2AjAgBUEANgIgIAUgCUMAAIA/IAqVQwAAgD8gCkMXt9E4XhsiCZQ4AiwgBSAPIAmUOAIoIAUgDiAJlDgCJCAFIBggCyAalCAMIBuUkiANIBmUkpI4AhwgBSAUIAsgFpQgDCAXlJIgDSAVlJKSOAIYIAUgECALIBKUIAwgE5SSIA0gEZSSkjgCFEEBIQcLIAZBoARqJAAgBwt3AQR/AkAgACgC7AUiAkEERgRAIAAgACABEOINIgJBuAFsaiIDKAJ0IgRFDQFBtOUBKAIAIgVFDQEgBCAFEQEAGiADQQA2AnQMAQsgACACQQFqNgLsBQsgACACQQAgAkEAShsiAkG4AWxqQQRqIAFBuAEQFRogAgviEAIFfyp9IwBB4ABrIgYkACAAKAIEEOYBIAMqAighKSADKgIkISogAyoCGCErIAMqAhQhLCABKgIUISAgASoCJCEhIAEqAhghIiABKgI0IRggAioCNCELIAMqAjQhGSAEKgI0IQ8gASoCKCEjIAEqAjghGiACKgI4IRAgAyoCOCEbIAQqAjghDCADKgIgIS0gAyoCECEuIAMqAgghLyADKgIEITAgAyoCACExIAEqAgAhJCABKgIQISUgASoCICEmIAEqAgQhJyABKgIIISggASoCMCEcIAIqAjAhDSADKgIwIR0gBCoCMCEOIAAoAgghByAGQQA2AjwgBiAiIAsgGJMgDyAZk5MiHowiC5QgKCANIByTIA4gHZOTIhSUkyAjIBAgGpMgDCAbk5MiFZSTOAI4IAYgICALlCAUICeUkyAVICGUkzgCNCAGICUgC5QgFCAklJMgFSAmlJM4AjAgBkHQAGogByAGQTBqIAcoAgAoAkARBQAgASoCNCEMIAEqAhghDSABKgIUIQ4gASoCOCELIAEqAighECABKgIkIQ8gASoCMCERIAEqAgghEiABKgIAIRMgASoCBCEXIAEqAhAhHyABKgIgIRYgBkEANgJMIAYgCyAWIAYqAlAiC5QgDyAGKgJUIg+UkiAQIAYqAlgiEJSSkjgCSCAGIAwgCyAflCAPIA6UkiAQIA2UkpI4AkQgBiARIAsgE5QgDyAXlJIgECASlJKSOAJAIAAoAgwhByADKgIUIQsgAyoCJCEPIAMqAhghECADKgIoIQwgAyoCACENIAMqAhAhDiADKgIgIREgAyoCBCESIAMqAgghEyAGQQA2AhwgBiAUIBOUIB4gEJSSIBUgDJSSOAIYIAYgFCASlCAeIAuUkiAVIA+UkjgCFCAGIBQgDZQgHiAOlJIgFSARlJI4AhAgBkEgaiAHIAZBEGogBygCACgCQBEFACADKgI0IQwgAyoCGCENIAMqAhQhDiADKgI4IQsgAyoCKCEQIAMqAiQhDyADKgIQIREgAyoCMCESIAMqAgghEyADKgIAIRcgAyoCBCEfIAMqAiAhFiAGQQA2AjwgBkEANgJcIAYgCyAWIAYqAiAiC5QgDyAGKgIkIg+UkiAQIAYqAigiEJSSkiIWOAI4IAYgEiALIBeUIA8gH5SSIBAgE5SSkiISOAIwIAYgDCALIBGUIA8gDpSSIBAgDZSSkiILOAI0IAYgBioCRCALkyIMOAJUIAYgBioCQCASkyINOAJQIAYgBioCSCAWkyIOOAJYQwAAAAAhC0MAAAAAIQ9DAAAAACEQQwAAAAAhEQJAAkAgDSANlCAMIAyUkiAOIA6UkkMXt9E4XkEBcw0AQSAhBwNAIAdFDQEgACgCCCEIIAZBADYCDCAGICIgBioCVIwiDJQgKCAGKgJQIg2UkyAjIAYqAlgiDpSTOAIIIAYgICAMlCAnIA2UkyAhIA6UkzgCBCAGICUgDJQgJCANlJMgJiAOlJM4AgAgBkEQaiAIIAYgCCgCACgCQBEFACAGQQA2AkwgBiAaICYgBioCECIMlCAhIAYqAhQiDZSSICMgBioCGCIOlJKSOAJIIAYgGCAlIAyUICAgDZSSICIgDpSSkjgCRCAGIBwgJCAMlCAnIA2UkiAoIA6UkpI4AkAgACgCDCEIIAZBADYCDCAGIC8gBioCUCIMlCArIAYqAlQiDZSSICkgBioCWCIOlJI4AgggBiAwIAyUICwgDZSSICogDpSSOAIEIAYgMSAMlCAuIA2UkiAtIA6UkjgCACAGQRBqIAggBiAIKAIAKAJAEQUAIAZBADYCPCAGQQA2AiwgBiAbIC0gBioCECIMlCAqIAYqAhQiDZSSICkgBioCGCIOlJKSIhI4AjggBiAGKgJIIBKTIhI4AiggBiAZIC4gDJQgLCANlJIgKyAOlJKSIhM4AjQgBiAGKgJEIBOTIhM4AiQgBiAdIDEgDJQgMCANlJIgLyAOlJKSIgw4AjAgBiAGKgJAIAyTIhc4AiAgEUMAAIA/Xg0CIBcgBioCUCIMlCATIAYqAlQiDZSSIBIgBioCWCIOlJIiH0MAAAAAXkEBc0UEQCAUIAyUIB4gDZSSIBUgDpSSIgtDAACAqGANAyABKgIwIQ8gAioCMCEQIAEqAjQhGCACKgI0IRwgASoCOCEaIAIqAjghFiADKgIwIR0gBCoCMCEyIAMqAjQhGSAEKgI0ITMgAyoCOCEbIAQqAjghNCAGQQA2AiwgBiASOAIoIAYgEzgCJCAGIBc4AiAgG0MAAIA/IBEgHyALlZMiEZMiC5QgESA0lJIhGyALIBmUIBEgM5SSIRkgCyAdlCARIDKUkiEdIAsgGpQgESAWlJIhGiALIBiUIBEgHJSSIRggCyAPlCARIBCUkiEcIAYoAlwhCSANIQ8gDiEQIAwhCwsgACgCBCAGQSBqEMUERQRAIAAoAgQgBkEgaiAGQUBrIAZBMGoQyAQLIAAoAgQgBkHQAGoQxgRFDQEgB0F/aiEHIAYqAlAiDCAMlCAGKgJUIgwgDJSSIAYqAlgiDCAMlJJDF7fROF4NAAsLIAUgETgCpAECQCALIAuUIA8gD5SSIBAgEJSSIgxDAACAKGBBAXNFBEAgBSAJNgKQASAFIBBDAACAPyAMkZUiEJQiETgCjAEgBSAPIBCUIg84AogBIAUgCyAQlCILOAKEAQwBCyAFQgA3AoQBIAVCADcCjAFDAAAAACERQwAAAAAhD0MAAAAAIQsLIBQgC5QgHiAPlJIgFSARlJIgBSoCrAGMYA0AIAAoAgQgBkEQaiAGEMQEIAUgBikDCDcCnAEgBSAGKQMANwKUAUEBIQoLIAZB4ABqJAAgCgvZBgIDfwd9IwBB8AFrIgMkACACKgIAIQggAioCBCEGIAIqAgghByAAQQA2AnwgACAHIAAqAmSSOAJ4IAAgBiAAKgJgkjgCdCAAIAggACoCXJI4AnAgA0GAgID8AzYChAEgA0IANwOIASADQgA3AnwgA0GAgID8AzYCmAEgA0EANgLsASADQgA3AuQBIANBgICA/AM2AtgBIANCADcC3AEgA0EANgKsASADQgA3AqQBIANCADcCnAEgA0GAgID8AzYCxAEgA0IANwPIASADQgA3ArwBIANCADcDkAEgA0GAgID8AzYCcCADQgA3AnQgA0IANwPQASADQgA3ArQBIANBgICA/AM2ArABIANBNGohBUEKIQJDAACAPyEIA0ACQCACRQ0AIAMgACkCXDcC4AEgAyAAKQJkNwLoASADIAApAng3AqgBIAMgACkCcDcCoAEgACoCXCEGIAAqAnAhByAAKgJgIQkgACoCdCEKIAAqAmQhCyAAKgJ4IQwgACgCCCEEIANBADYCVCADQYCAgPwDNgIMIANCADcCLCADQgA3AiQgA0IANwIcIANCADcCFCADQgA3A2ggAyALIAyTOAJkIAMgCSAKkzgCYCADIAYgB5M4AlwgAyAENgJYIANBjMkANgIIIAMgBCgCvAEiBC8BBDsBECADIAQvAQY7ARIgACgCDCIEIAQoAgAoAjARBgAhBiAAKAIMIgQgBiAAKgI4kiAEKAIAKAIsEQgAAkAgAC0AqgEEQCAAKAIIIAAoAgwgA0GwAWogA0HwAGogA0EIaiABKgI4EOQBDAELIAEgACgCDCADQbABaiADQfAAaiADQQhqIAEqAjgQYgsgACgCDCIEIAYgBCgCACgCLBEIAAJAIAMqAgwiBkMAAIA/XUEBc0UEQCAAIAUQ8g0gACoCcCAAKgJckyIHIAeUIAAqAnQgACoCYJMiCSAJlJIgACoCeCAAKgJkkyIKIAqUkiILQwAAADReQQFzDQIgB0MAAIA/IAuRlSIHlCAAKgJMlCAJIAeUIAAqAlCUkiAKIAeUIAAqAlSUkkMAAAAAX0EBcw0BDAILIAAgACkCcDcCXCAAIAApAng3AmQLIAJBf2ohAiAIIAaTIghDCtcjPF4NAQsLIANB8AFqJAALrAEAIABB8McANgIAIAAgBDYCsAEgAEIANwI8IABBiq6P5QM2AjggACADOAI0IAAgATYCCCAAQoCAhAg3AqgBIAAgAjYCDCAAQrPmrI8ENwIsIABCADcCECAAQQE6ALQBIABCgIDwkoSAgJDBADcCGCAAQQA7ALUBIABC25+k+rOewZo/NwIkIABBADYCbCAAQQE6AJABIABBADYCjAEgAEIANwKEASAAQgA3AkQLMwEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAgwgAigCCBDxDSEAIAJBEGokACAAC4gFAgJ/CH0jAEEwayICJAAgACABQQAQrwEgASoCzAEhBCABQQA2AhwgASAEIAEqAtQBkiIEIAEqAjyUIAEqAiySOAIYIAEgBCABKgI4lCABKgIokjgCFCABIAEqAjQgBJQgASoCJJI4AhAgAkGAgID8ezYCKCAAKAJkIgMgAUEkaiABQRBqIAJBCGogAygCACgCCBEKACEDIAFBADYCWAJAIAMEQCACKgIoIQYgASACKQMYNwIAIAEgAikDIDcCCCABQQE6AFQQgw4gAUGQ4AE2AlggASAEIAaUIgYgASoC1AGTOAIgIAEqAswBIAEqAtABQwrXIzyUkyIEIAEqAiAiBSAFIARdIgMbIQQgA0VBACAEIAEqAswBIAEqAtABQwrXIzyUkiIFXkEBcxtFBEAgASAFIAQgBCAFXhs4AiALIAEgAikDCDcCECABIAIpAxA3AhggASoCACIFIAEqAjSUIAEqAgQiByABKgI4lJIgASoCCCIJIAEqAjyUkiIEQ83MzL1gQQFzRQRAIAFBADYCkAJDAAAgQSEEDAILIAFDAACAvyAElSIEIAUgACgCdCIAKgLMAiIFIAEqAhggACoCPJMiCJQgASoCFCAAKgI4kyIKIAAqAtACIguUkyAAKgK4ApKUIAcgASoCECAAKgI0kyIHIAuUIAggACoCyAIiCJSTIAAqArwCkpSSIAkgCiAIlCAHIAWUkyAAKgLAApKUkpQ4ApACDAELIAEqAswBIQQgAUEANgKQAiABIAQ4AiAgAUEANgIMIAEgASoCPIw4AgggASABKgI4jDgCBCABIAEqAjSMOAIAQwAAgL8hBkMAAIA/IQQLIAEgBDgCjAIgAkEwaiQAIAYLpQMBAX8gAEHUxgA2AgAgACgCkAEiAQRAIAAtAJQBBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2ApABCyAAQQA2ApABIABCADcCiAEgAEEBOgCUASAAKAJMIgEEQCAALQBQBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AkwLIABBADYCTCAAQgA3AkQgAEEBOgBQIAAoAjgiAQRAIAAtADwEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYCOAsgAEEANgI4IABCADcCMCAAQQE6ADwgACgCJCIBBEAgAC0AKARAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgIkCyAAQQA2AiQgAEIANwIcIABBAToAKCAAKAIQIgEEQCAALQAUBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AhALIABBADYCECAAQgA3AgggAEEBOgAUIAALMgEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAgwgAigCCBA/IQAgAkEQaiQAIAALwgMBB38gACgCBCICIQMCQCACIAAoAghHDQAgAiEDIAIgAkEBdEEBIAIbIgZODQAgBgR/Qej3AUHo9wEoAgBBAWo2AgAgBkH0AWxBEEGM0gEoAgARAwAhByAAKAIEBSACCyIDQQFOBEADQCAHIAhB9AFsIgRqIgUgACgCDCAEaiIEKQIANwIAIAUgBCkCCDcCCCAFIAQpAhg3AhggBSAEKQIQNwIQIAUgBCkCKDcCKCAFIAQpAiA3AiAgBSAEKQIwNwIwIAUgBCkCODcCOCAFQUBrIARBQGtBtAEQFRogCEEBaiIIIANHDQALCyAAKAIMIgMEQCAALQAQBEAgAwRAQez3AUHs9wEoAgBBAWo2AgAgA0GQ0gEoAgARAAALCyAAQQA2AgwLIAAgBzYCDCAAQQE6ABAgACAGNgIIIAAoAgQhAwsgACADQQFqNgIEIAJB9AFsIgMgACgCDGoiAiABKQIINwIIIAIgASkCADcCACACIAEpAhg3AhggAiABKQIQNwIQIAIgASkCIDcCICACIAEpAig3AiggAiABKQIwNwIwIAIgASkCODcCOCACQUBrIAFBQGtBtAEQFRogACgCDCADagtXAQF/IwBBEGsiAiAANgIMIAIgATYCCCACKAIMIgAgACoCACACKAIIKgIAlDgCACAAIAAqAgQgAigCCCoCAJQ4AgQgACAAKgIIIAIoAggqAgCUOAIIIAALpQUCAX8HfQJAIAIqAoABIgVDAAAAAFsNAEGM4AFBjOABKAIAQQFqNgIAIAIgAioCeCIEIAIqAmAiBiAFIAYgAioCdJSTIAIqAhAiBSAAKgKQAZQgAioCFCIHIAAqApQBlJIgAioCGCIJIAAqApgBlJIgAioCACAAKgKgAZQgAioCBCAAKgKkAZSSIAIqAgggACoCqAGUkpIgAioCbCIIlJMgCCACKgIwIAEqApABlCACKgI0IAEqApQBlJIgAioCOCABKgKYAZSSIAIqAiAgASoCoAGUIAIqAiQgASoCpAGUkiACKgIoIAEqAqgBlJKSlJMiCJIiCiAKIARdIgMbOAJgIAQgBpMgCCADGyEEIAAoAvABBEAgACAAKgJwIAQgBSAAKgKAAZSUlCAAKgKQAZI4ApABIAAgBCAHIAAqAoQBlJQgACoCdJQgACoClAGSOAKUASAAIAQgCSAAKgKIAZSUIAAqAniUIAAqApgBkjgCmAEgAioCSCEGIAIqAkQhBSAAIAQgACoCYJQgAioCQJQgACoCoAGSOAKgASAAKgJoIQcgACAFIAQgACoCZJSUIAAqAqQBkjgCpAEgACAGIAQgB5SUIAAqAqgBkjgCqAELIAEoAvABRQ0AIAIqAjghBiACKgI0IQUgASABKgJwIAQgAioCMCABKgKAAZSUlCABKgKQAZI4ApABIAEgBCAFIAEqAoQBlJQgASoCdJQgASoClAGSOAKUASABIAQgBiABKgKIAZSUIAEqAniUIAEqApgBkjgCmAEgAioCWCEGIAIqAlQhBSABIAQgASoCYJQgAioCUJQgASoCoAGSOAKgASABKgJoIQcgASAFIAQgASoCZJSUIAEqAqQBkjgCpAEgASAGIAQgB5SUIAEqAqgBkjgCqAELCzMBAX8jAEEQayICJAAgAiAANgIMIAIgATgCCCACKAIMIAJBCGoQ1gQhACACQRBqJAAgAAvxBQEBfyAAQfzEADYCACAAKAKwASIBBEAgAC0AtAEEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYCsAELIABBADYCsAEgAEIANwKoASAAQQE6ALQBIAAoApwBIgEEQCAALQCgAQRAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgKcAQsgAEEANgKcASAAQgA3ApQBIABBAToAoAEgACgCiAEiAQRAIAAtAIwBBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AogBCyAAQQA2AogBIABCADcCgAEgAEEBOgCMASAAKAJ0IgEEQCAALQB4BEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AnQLIABBADYCdCAAQgA3AmwgAEEBOgB4IAAoAmAiAQRAIAAtAGQEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYCYAsgAEEANgJgIABCADcCWCAAQQE6AGQgACgCTCIBBEAgAC0AUARAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgJMCyAAQQA2AkwgAEIANwJEIABBAToAUCAAKAI4IgEEQCAALQA8BEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AjgLIABBADYCOCAAQgA3AjAgAEEBOgA8IAAoAiQiAQRAIAAtACgEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYCJAsgAEEANgIkIABCADcCHCAAQQE6ACggACgCECIBBEAgAC0AFARAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgIQCyAAQQA2AhAgAEIANwIIIABBAToAFCAAC9kBACAAQfzEADYCACAAQQE6ABQgAEEANgIQIABBAToAKCAAQgA3AgggAEEANgIkIABBAToAPCAAQgA3AhwgAEEANgI4IABBAToAUCAAQgA3AjAgAEEANgJMIABBAToAZCAAQgA3AkQgAEEANgJgIABBAToAeCAAQgA3AlggAEEANgJ0IABBAToAjAEgAEIANwJsIABBADYCiAEgAEIANwKAASAAQQE6AKABIABBADYCnAEgAEIANwKUASAAQQE6ALQBIABBADYCwAEgAEEANgKwASAAQgA3AqgBCzQCAX8BfSMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAgwgAigCCBBJIQMgAkEQaiQAIAML+AMBD30gAEEEIAEQ1gIgAEGMxAA2AgAgACACKQIINwKwBCAAIAIpAgA3AqgEIAAgAikCGDcCwAQgACACKQIQNwK4BCAAIAIpAig3AtAEIAAgAikCIDcCyAQgACACKQI4NwLgBCAAIAIpAjA3AtgEIAAgAikCCDcC8AQgACACKQIANwLoBCAAIAIpAhA3AvgEIAAgAikCGDcCgAUgACACKQIgNwKIBSAAIAIpAig3ApAFIAAgAikCMDcCmAUgACACKQI4NwKgBSAAQoCAgICAgIDAv383ArAFIABC5syZ+6Oz5sw+NwK4BSAAQYCAgPwDNgLABSAAQgA3AsQFIABBADoAzAUgACADOgDkBSAAQQA2AuwFIABBgICACDYC4AUgACgCHCIBKgI0IQcgASoCCCEIIAEqAgwhCSABKgI4IQogASoCHCELIAEqAhQhDCABKgIYIQ0gASoCPCEOIAAqAuAEIQQgASoCLCEPIAAqAtgEIQUgASoCJCEQIAAqAtwEIQYgASoCKCERIAEqAgQhEiAAQwAAgL9DAACAPyADGzgC3AUgAEEANgKkBSAAIA4gBSAQlCAGIBGUkiAEIA+UkpI4AqAFIAAgCiAFIAyUIAYgDZSSIAQgC5SSkjgCnAUgACAHIAUgEpQgBiAIlJIgBCAJlJKSOAKYBQuwAgAgAEEEIAEgAhBHIABBjMQANgIAIAAgAykCCDcCsAQgACADKQIANwKoBCAAIAMpAhg3AsAEIAAgAykCEDcCuAQgACADKQIoNwLQBCAAIAMpAiA3AsgEIAAgAykCODcC4AQgACADKQIwNwLYBCAAIAQpAgg3AvAEIAAgBCkCADcC6AQgACAEKQIQNwL4BCAAIAQpAhg3AoAFIAAgBCkCIDcCiAUgACAEKQIoNwKQBSAAIAQpAjA3ApgFIAAgBCkCODcCoAUgAEKAgICAgICAwL9/NwKwBSAAQubMmfujs+bMPjcCuAUgAEGAgID8AzYCwAUgAEIANwLEBSAAQQA6AMwFIAAgBToA5AUgAEEANgLsBSAAQYCAgAg2AuAFIABDAACAv0MAAIA/IAUbOALcBQu6CAENfSAAQQQgASACEEcgAEEANgLsBSAAIAc6AOQFIABBgICACDYC4AUgAEEAOgDMBSAAQgA3AsQFIABBgICA/AM2AsAFIABC5syZ+6Oz5sw+NwK4BSAAQoCAgICAgIDAv383ArAFIABBjMQANgIAIAAgAykCCDcC4AQgACADKQIANwLYBAJ/IAEqAgQiDCAFKgIAIgiUIAEqAhQiDSAFKgIEIgmUkiABKgIkIg4gBSoCCCIKlJIiC0P+/38/YEEBc0UEQCABKAIoIQMgASgCCCECIAEqAiyMIQ4gASoCHIwhDCABKgIMjCENIAEoAhgMAQsgC0P+/3+/X0EBc0UEQCABKAIoIQMgASgCCCECIAEqAiwhDiABKgIcIQwgASoCDCENIAEoAhgMAQsgCSAOIAmUIA0gCpSTIguUIAggDCAKlCAOIAiUkyIPlJMhDiAIIA0gCJQgDCAJlJMiCJQgCiALlJMhDCAKIA+UIAkgCJSTIQ0gCLwhAyALvCECIA+8CyEBIAAgDTgCqAQgACACNgKsBCAFKAIAIQIgACABNgK8BCAAIAw4ArgEIABBADYCtAQgACACNgKwBCAFKAIEIQEgACADNgLMBCAAIA44AsgEIABBADYCxAQgACABNgLABCAFKAIIIQEgAEEANgLUBCAAIAE2AtAEAn0gBioCCCIPIAUqAggiC5QgBSoCBCIIIAYqAgQiEZQgBioCACISIAUqAgAiCpSSkiIJQ/7/f79dQQFzRQRAIAuLQ/MENT9eQQFzRQRAIAhDAACAPyAIIAiUIAsgC5SSkZUiCJQhCSAIIAuMlCEKQwAAAAAhCEMAAAAADAILIApDAACAPyAIIAiUIAogCpSSkZUiCZQhCiAJIAiMlCEIQwAAAAAhCUMAAAAADAELIBEgCpQgCCASlJNDAACAPyAJQwAAgD+SIgkgCZKRIhOVIhCUIQkgCyASlCAPIAqUkyAQlCEKIAggD5QgCyARlJMgEJQhCCATQwAAAD+UCyELIAAgBCkCADcCmAUgACAEKQIINwKgBSAAIAogDiALlCAMIAiUkiANIAqUkyIQlCALIA0gC5QgDiAKlJIgDCAJlJMiE5QgCCANIAiMlCAMIAqUkyAOIAmUkyIUlJMgCSAMIAuUIA0gCZSSIA4gCJSTIg6Uk5IiDDgC6AQgACARIAggDpQgCyAQlCAJIBSUkyAKIBOUk5IiDZQgDyAJIBOUIAsgDpQgCiAUlJMgCCAQlJOSIgiUkzgC7AQgBigCACEBIAAgCDgC+AQgACAPIAyUIBIgDZSTOAL8BCAAQQA2AvQEIAAgATYC8AQgBigCBCEBIAAgEiAIlCARIAyUkzgCjAUgACANOAKIBSAAQQA2AoQFIAAgATYCgAUgBigCCCEBIABDAACAv0MAAIA/IAcbOALcBSAAQQA2ApQFIAAgATYCkAULoAkBEH0gACABKQIINwK0BCAAIAEpAgA3AqwEQwAAAIAhCEMAAIA/IQsgACoCrAQiAyAAKgK0BCICIAAqArgEIgRDAAAAAJQiBpIgA0MAAAAAlCIFkyIHlCAEIAYgBZIgACoCsAQiBZMiDZQgAiADjCAFQwAAAACUIgaTIAJDAAAAAJQiCZMiD5STIAUgBCAGkiAJkyIGlJOSIglDAAAAAJQiDiACIAaUIAQgB5QgBSAPlJMgAyANlJOSIhBDAAAAAJQiESAFIA2UIAQgBpQgAyAPlJMgAiAHlJOSIgeSkiINQ/7/f79dRQRAIBAgB0MAAAAAlCIIk0MAAIA/IA1DAACAP5IiByAHkpEiDZUiB5QhCiAIIAmTIAeUIQsgDUMAAAA/lCEMIA4gEZMgB5QhCAtDAACAPyACIApDAACAPyAIIAiUIAsgC5SSIAogCpSSIAwgDJSSkZUiB5QiCpQgBSALIAeUIguUIAQgDCAHlCIMlCADIAggB5QiCJSSkpIiByAHlCADIAuUIAIgDJQgBCAKlJMgBSAIlJOSIg0gDZQgBSAKlCADIAyUIAQgCJSTIAIgC5STkiIPIA+UIAIgCJQgBSAMlCAEIAuUkyADIAqUk5IiECAQlJKSkpGVIQUCQCAAKgK8AyIEQ83MTD1gQQFzDQAgACoCwAMiAkPNzEw9YEEBcw0AAkAgDEMAAIC/l0MAAIA/lhA6IgMgA5IiA0MAAAA0XkEBcw0AIApDAACAPyAKIAqUIAggCJQgCyALlJKSkZUiBpQhCSAIIAaUIQ4gCyAGlCIGi0MAAAA0XkEBcw0AIAkgCZQgBiAGlJUiEUMAAIA/kiARIAQgBJSVQwAAgD8gAiAClJWSlZEhBAsgA4tDAAAANF5BAXMNAAJAIAMgBF4EQCAEIQMMAQsgAyAEjCICXUEBcw0AIAIhAwsgCSADQwAAAD+UIgIQHCAOIA6UIAYgBpSSIAkgCZSSkZUiA5QhCiAGIAOUIQsgDiADlCEIIAIQHSEMCyAHIAWUIQQgDSAFlCEDIBAgBZQhDiAPIAWUIQcCQCAAKgLEAyINQ83MTD1gQQFzDQAgByEFIA4hCSADIQYCfyAEQwAAgL+XQwAAgD+WEDoiAiACkiICQ9sPSUBeQQFzRQRAIAOMIQYgDowhCSAHjCEFIASMQwAAgL+XQwAAgD+WEDoiAiACkiECCyACQwAAADReQQFzRQsEQCAGQwAAgD8gBSAFlCAJIAmUkiAGIAaUkpGVIg+UIQYgCSAPlCEJIAUgD5QhBQsgAotDAAAANF5BAXMNAAJAIAIgDV4EQCANIQIMAQsgAiANjCIDXUEBcw0AIAMhAgsgBiACQwAAAD+UIgQQHCAGIAaUIAkgCZQgBSAFlJKSkZUiApQhAyAJIAKUIQ4gBSAClCEHIAQQHSEECyAAIAwgBJQgCCAHlJMgCyAOlJMgCiADlJM4ArgEIAAgCCAOlCAMIAOUIAogBJSSkiALIAeUkzgCtAQgACAKIAeUIAwgDpQgCyAElJKSIAggA5STOAKwBCAAIAsgA5QgDCAHlCAIIASUkpIgCiAOlJM4AqwEC8oCAQh9IAIQHSEEIAEqArwDIQUgAhAcIQICQCAEi0MAAAA0XkUEQCACIAKUIQYgBCAElCEHDAELIAIgApQiBiAEIASUIgeVIglDAACAP5JDAACAPyABKgLAAyIIIAiUlSAJIAUgBZSVkpWRIQULIABBADYCDCAAIAVDAAAAP5QiBRAcIAYgB0MAAAAAkpKRlSIGQwAAAACUIgcgBRAdIgVDAAAAAJQiCCAGIAKMlCICIAOUkiAHQwAAAACUIgqTIgmUIAUgCCAKkiAEIAaUIgQgA5STIgiUIAIgBkMAAACAlCADlCAEQwAAAACUIgqTIAJDAAAAAJQiC5MiBpSTIAQgBSADlCAKkiALkyIDlJOSOAIIIAAgAiADlCAFIAmUIAQgBpSTIAcgCJSTkjgCBCAAIAQgCJQgBSADlCAHIAaUkyACIAmUk5I4AgALvAEBAX0gAEIANwIUIABBADoAHAJAIAAqAgQiAkMAAAAAYEEBcw0AAkAgASAAKgIAk0PbD8lAECUiAUPbD0nAXUEBc0UEQCABQ9sPyUCSIQEMAQsgAUPbD0lAXkEBcw0AIAFD2w/JwJIhAQsgASACjF1BAXNFBEAgAEGAgID8AzYCGCAAQQE6ABwgACACIAGSjDgCFA8LIAEgAl5BAXMNACAAQYCAgPx7NgIYIABBAToAHCAAIAIgAZM4AhQLCwUAQdQAC78EAQh/IwBB0ABrIgkkACAJQYCA2JwENgIgIAlCgICAgNCZs+Y9NwMYIAlCADcDSCAJQgA3AjQgCUKAgICA0Jmzpj43AiwgCUKAgID8g4CAwL9/NwMQIAlCgICA/IOAgIA/NwIkIAlBADYCQCAJQQA6ADwgAUEEaiEPIABBqAVqIQ4DQCALIA5qLQBsIQwCQCAOIAtBAnQiDWooArABIhBFBEAgDCEKQQEhDCAKRQ0BCyAJIBA2AkggCUEANgI4IAkgACANaiIKKALIBjYCRCAJIAooArgGNgJAIAAoAtwFIQ0gCSAMOgA8IAkgDTYCJCAJIAooArgFNgIUIAkgACgC2AU2AiggCigCqAUhDCAJQQA2AiAgCSAMNgIQIAkgCigCqAY2AhwgCSAKKAKYBjYCGCAJIApBqAhqKAIANgIAIAkgCkG4CGooAgA2AgQgCkHICGooAgAhDCAJQQA2AgwgCSAMNgIIIAkCfyAKQeQFaiAAKAKYCiALQQNsdSINQQFxDQAaIAEoAiALKAIANgIsIAkgDUECcQR/IApBhAZqBSABKAIgCygCADYCNCAJIApB9AVqIA8gDUEEcRsoAgA2AjAgACAJQRBqIAMgBCAFIAYgByAIIAEgAiAJQQACf0EAIAAtAJUKRQ0AGkEBIAAgC0EBakH/AXFBA3BBBnRqKAKcB0UNABogACALQQJqQf8BcUEDcEEGdGooApwHRQsQ1wIgAmohAgsgC0EBaiILQQNHDQALIAlB0ABqJAAgAgufBAELfyMAQRBrIgYkACAAKAIgIgJByAJqIQcgACgCHCIDQcgCaiEIIAJBuAJqIQkgA0G4AmohCiACQQRqIQsgA0EEaiEMAkAgAC0AlQoEQEEAIQNBACECA0BBACAAIAJBBnRqIgQoApwHRSAELQCQBxtFBEAgBiAAIAJBBHRqIgVBwAlqKQIANwMIIAYgBUG4CWopAgA3AwAgACgCmAogAkEDbEEJanUiBUEBcUUEQCAEIAEoAiAoAgA2AoAHCyAFQQJxRQRAIAQgASgCICgCADYCiAcLIAVBBHFFBEAgBCABKAIENgKEBwsgACAEQeQGaiAMIAsgCiAJIAggByABIAMgBkEBQQAQ1wIgA2ohAwsgAkEBaiICQQNHDQALIAAgASADIAwgCyAKIAkgCCAHEOMEGgwBCyAAIAFBACAMIAsgCiAJIAggBxDjBCEDQQAhAgNAQQAgACACQQZ0aiIEKAKcB0UgBC0AkAcbRQRAIAYgACACQQR0aiIFQcAJaikCADcDCCAGIAVBuAlqKQIANwMAIAAoApgKIAJBA2xBCWp1IgVBAXFFBEAgBCABKAIgKAIANgKABwsgBUECcUUEQCAEIAEoAiAoAgA2AogHCyAFQQRxRQRAIAQgASgCBDYChAcLIAAgBEHkBmogDCALIAogCSAIIAcgASADIAZBAUEAENcCIANqIQMLIAJBAWoiAkEDRw0ACwsgBkEQaiQAC+8BAQN/IwBBoAFrIgQkACAEIAE2ApwBIAQgAjYCmAEgBCADOAKUASAEKAKYASEBIAQgBCgCmAEgBCgCnAEiAhBJOAJ8IARBgAFqIgYgASAEQfwAahAhIARB6ABqIgUgAiAGEEgjAEEQayAEQdgAaiIBNgIMIARByABqIAQoApgBIAIQsAEgASAEKQJINwIAIAEgBCkCUDcCCCAEIAQqApQBECk4AiQgBEEoaiICIAUgBEEkahAhIARBOGoiBSAGIAIQFCAEIAQqApQBECg4AgwgBEEQaiICIAEgBEEMahAhIAAgBSACEBQgBEGgAWokAAurCQICfhh9IABBBhDVAiABEEcgAEGIPjYCACAAIAIpAgg3AnggACACKQIANwJwIAAgAikCGDcCiAEgACACKQIQNwKAASAAIAIpAig3ApgBIAAgAikCIDcCkAEgAikCOCEEIAIpAjAhBSAAQQA2ApAGIABCADcCiAYgAEIANwKABiAAQs2Zs/LTmbOmPjcC9AUgAEHNmbPyAzYC/AUgAEIANwLkBSAAQgA3AuwFIABCADcC0AUgAEIANwLIBSAAQgA3AsAFIABCADcCuAUgAEIANwKwBSAAQgA3AqgFIAAgBDcCqAEgACAFNwKgASAAQrPmzPmDgIDAPzcC2AUgAEGAgID4AzYC4AUgAEEAOgCWBiAAQQA7AJQGIABCADcCmAYgAEEANgKgBiAAQgA3AqgGIABBADYCsAYgAEKAgICA0Jmz5j03AuwGIABBgIDYnAQ2AvQGIABCgICA/IOAgMC/fzcC5AYgAEKAgICA0Jmzpj43AoAHIABCADcCiAcgAEIANwKcByAAQoCAgPyDgICAPzcC+AYgAEEANgKUByAAQQA2AuAHIABBADoAkAcgAEKAgICA0Jmz5j03AqwHIABBgIDYnAQ2ArQHIABCADcCyAcgAEKAgICA0Jmzpj43AsAHIABCgICA/IOAgMC/fzcCpAcgAEKAgID8g4CAgD83ArgHIABBADYC3AcgAEEANgLUByAAQQA6ANAHIABCgICAgNCZs+Y9NwLsByAAQYCA2JwENgL0ByAAQYgIakIANwIAIABBgAhqQoCAgIDQmbOmPjcCACAAQoCAgPyDgIDAv383AuQHIABCgICA/IOAgIA/NwL4ByAAQZwIakIANwIAIABBlAhqQQA2AgAgAEGQCGpBADoAACAAQQE6AJUKIABBADoAnAogACADOgCUCiAAQQA2ApgKIAEqAjQhGyABKgI4IRwgASoCPCEdIAAqAqgBIQ8gACoCoAEhECAAKgKkASERIAEqAgghBiABKgIMIQcgASoCHCEIIAEqAhQhCSABKgIYIQogACoCgAEhEiAAKgKQASETIAAqApQBIRQgACoCdCEVIAAqAoQBIRYgASoCLCELIAAqApgBIRcgASoCJCEMIAAqAnghGCABKgIoIQ0gACoCiAEhGSABKgIEIQ4gACoCcCEaIABBADYCbCAAQQA2AlwgAEEANgJMIABBADYCPCAAIBggDJQgGSANlJIgFyALlJI4AlggACAVIAyUIBYgDZSSIBQgC5SSOAJUIAAgGiAMlCASIA2UkiATIAuUkjgCUCAAIBggCZQgGSAKlJIgFyAIlJI4AkggACAVIAmUIBYgCpSSIBQgCJSSOAJEIABBQGsgGiAJlCASIAqUkiATIAiUkjgCACAAIA4gGJQgBiAZlJIgByAXlJI4AjggACAOIBWUIAYgFpSSIAcgFJSSOAI0IAAgGiAOlCASIAaUkiATIAeUkjgCMCAAIB0gDCAQlCANIBGUkiALIA+UkpI4AmggACAcIAkgEJQgCiARlJIgCCAPlJKSOAJkIAAgGyAOIBCUIAYgEZSSIAcgD5SSkjgCYCAAIAAoAhxBBGogACgCIEEEahCyAQujBgAgAEEGIAEgAhBHIABBiD42AgAgACADKQIINwI4IAAgAykCADcCMCAAIAMpAhg3AkggAEFAayADKQIQNwIAIAAgAykCKDcCWCAAIAMpAiA3AlAgACADKQI4NwJoIAAgAykCMDcCYCAAIAQpAgg3AnggACAEKQIANwJwIAAgBCkCEDcCgAEgACAEKQIYNwKIASAAIAQpAiA3ApABIAAgBCkCKDcCmAEgACAEKQIwNwKgASAAIAQpAjg3AqgBIABCADcCqAUgAEIANwKwBSAAQgA3ArgFIABCADcCwAUgAEIANwLIBSAAQgA3AtAFIABCADcC5AUgAEIANwLsBSAAQs2Zs/LTmbOmPjcC9AUgAEHNmbPyAzYC/AUgAEEANgKQBiAAQgA3AogGIABCADcCgAYgAEGAgID4AzYC4AUgAEKz5sz5g4CAwD83AtgFIABBADoAlgYgAEEAOwCUBiAAQQA2AqAGIABCADcCmAYgAEEANgKwBiAAQgA3AqgGIABBADYCoAcgAEGAgNicBDYC9AYgAEKAgICA0Jmz5j03AuwGIABCADcCiAcgAEKAgICA0Jmzpj43AoAHIABCgICA/IOAgMC/fzcC5AYgAEEANgKcByAAQoCAgPyDgICAPzcC+AYgAEEANgKUByAAQQA2AuAHIABBADoAkAcgAEGAgNicBDYCtAcgAEKAgICA0Jmz5j03AqwHIABCADcCyAcgAEKAgICA0Jmzpj43AsAHIABCgICA/IOAgMC/fzcCpAcgAEEANgLcByAAQoCAgPyDgICAPzcCuAcgAEEANgLUByAAQaAIakEANgIAIABBADoA0AcgAEGAgNicBDYC9AcgAEKAgICA0Jmz5j03AuwHIABBiAhqQgA3AgAgAEGACGpCgICAgNCZs6Y+NwIAIABCgICA/IOAgMC/fzcC5AcgAEGcCGpBADYCACAAQoCAgPyDgICAPzcC+AcgAEGUCGpBADYCACAAQQA6AJwKIABBADYCmAogAEEBOgCVCiAAIAU6AJQKIABBkAhqQQA6AAAgACAAKAIcQQRqIAAoAiBBBGoQsgELAwABCw0AIABBkMEANgIAIAALgQIBA38gACgCCCIDQQFOBEADQCAAKAIQIARBAnRqKAIAIgItAOwBQQJxBEAgASABIAIgAigCACgCEBEBAEEBIAEoAgAoAhARBwAiAyACIAMoAgggASACKAIAKAIUEQcAQdKEkcoFIAIgASgCACgCFBEJACAAKAIIIQMLIARBAWoiBCADSA0ACwsgACgC1AFBAU4EQEEAIQQDQCABIAEgACgC3AEgBEECdGooAgAiAiACKAIAKAIkEQEAQQEgASgCACgCEBEHACIDIAIgAygCCCABIAIoAgAoAigRBwBBw565mgUgAiABKAIAKAIUEQkAIARBAWoiBCAAKALUAUgNAAsLCxEAIAAoAtwBIAFBAnRqKAIAC2ABA39B8joQFiAAKALoASICQQFOBEADQCAAKALwASADQQJ0aigCACIELQDMAUEDcUUEQCAEIAEQjA8gBCABIARBxABqEPIBIAAoAugBIQILIANBAWoiAyACSA0ACwsQEwuYBAEDfyAAKAIIIgIgACgCICIBBH8gACgCKAVBAAsgASAAKAI0IgEEfyAAKAI8BUEACyABAn9BACAAKAJIIgFFDQAaIAAoAlALIAEgACgCBCAAKAIUIAAoAhggAigCACgCDBEjABogACgCICICQX9MBEAgACgCJEF/TARAIAAoAigiAQRAIAAtACwEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYCKAsgAEIANwIkIABBAToALAsDQCAAKAIoIAJBAnRqQQA2AgAgAkEBaiIBIAJPIQMgASECIAMNAAsLIABBADYCICAAKAI0IgJBf0wEQCAAKAI4QX9MBEAgACgCPCIBBEAgAEFAay0AAARAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgI8CyAAQgA3AjggAEFAa0EBOgAACwNAIAAoAjwgAkECdGpBADYCACACQQFqIgEgAk8hAyABIQIgAw0ACwsgAEEANgI0IAAoAkgiAkF/TARAIAAoAkxBf0wEQCAAKAJQIgEEQCAALQBUBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AlALIABCADcCTCAAQQE6AFQLA0AgACgCUCACQQJ0akEANgIAIAJBAWoiASACTyEDIAEhAiADDQALCyAAQQA2AkgLkgIBDH8DQCAAKAIMIgcgAiIIIANqQQJtQQJ0aigCACEJIAMhBSACIQYDQCAJKAIcKALQASICIAkoAiAoAtABIAJBf0obIQoDQCAGIgJBAWohBiAHIAJBAnRqIg0oAgAiCygCHCgC0AEiBCALKAIgKALQASAEQX9KGyAKSA0ACwNAIAUiBEF/aiEFIAogByAEQQJ0Ig5qKAIAIgwoAhwoAtABIg8gDCgCICgC0AEgD0F/ShtIDQALAn8gAiAETARAIA0gDDYCACAAKAIMIA5qIAs2AgAgBSEEIAYhAgsgAiAETAsEQCAAKAIMIQcgBCEFIAIhBgwBCwsgBCAISgRAIAAgASAIIAQQ7gQLIAIgA0gNAAsLEQAgACABIAAoAgAoAkQRAgALEQAgACABIAAoAgAoAkARAgALIwEBfyMAQRBrIgEkACABIAA2AgwgASgCDBDqDiABQRBqJAALLQACQCABRQ0AIAEoAuwBQQJxRQ0AIAAgASAAKAIAKAJcEQIADwsgACABEKkBC4gCAQJ/Qd44EBYgACgCVCICBEAgACABIAIRCAALIAAgASAAKAIAKAKMAREIAEEAIQIgAEEANgIgIAAgATgCHCAAIAAgACgCACgCFBEBADYCMCAAIAEQ/A4gACAAKAIAKAIsEQAAIAAgACgCACgClAERAAAgACABOAJoIAAgAEHcAGogACgCACgCmAERAgAgACABIAAoAgAoApABEQgAQfs4EBYgACgCmAJBAU4EQANAIAAoAqACIAJBAnRqKAIAIgMgACABIAMoAgAoAggRCwAgAkEBaiICIAAoApgCSA0ACwsQEyAAIAEgACgCACgCnAERCAAgACgCUCICBEAgACABIAIRCAALEBMLqAIBA39BqDgQFiAAELMEAkAgACAAKAIAKAIUEQEARQ0AIAAgACgCACgCFBEBACIBIAEoAgAoAjARAQBBgDBxRQ0AIAAgACgCACgCaBEBACICQQFIDQADQCAAIAAgAkF/aiIBIAAoAgAoAmwRAwAQgQ8gAkEBSiEDIAEhAiADDQALCwJAIAAgACgCACgCFBEBAEUNACAAIAAoAgAoAhQRAQAiASABKAIAKAIwEQEAQYOAAXFFDQAgACAAKAIAKAIUEQEARQ0AIAAgACgCACgCFBEBACIBIAEoAgAoAjARAQBFDQAgACgCmAJBAUgNAEEAIQIDQCAAKAKgAiACQQJ0aigCACIBIAAoAkggASgCACgCDBECACACQQFqIgIgACgCmAJIDQALCxATC48FACAAIAEgAhCBDSAAQpqz5vSTkaLEPDcCZCAAQpqz5viDgIDAPzcCXCAAQQA2AlggAEIANwJQIABCzZmz8tOZs6Y/NwJ8IABCgICAgKABNwJsIABCgICglqTZ/KTxADcCqAEgAEGAATYCpAEgAEKEgoCAIDcCnAEgAEKAgICAoLPmrD83ApQBIABCiq6P6duZs+Y9NwKMASAAQoCAgIAQNwKEASAAQoCAgI2EgIDAPzcCdCAAQQE6AMABIABB9DY2AgAgAEEANgK8ASAAQgA3ArQBIABBAToA4AEgACADNgLIASAAQQA2AsQBIABCADcC1AEgAEEANgLcASAAQQE6APQBIABBADsBkgIgAEEANgLwASAAQgA3AugBIABCgICAgICAgJBBNwL4ASAAQgA3AoACIABCADcCiAIgAEEBOgCkAiAAQQA2AqgCIABBADYCoAIgAEIANwKYAiAAQQE6AMACIABBAToArAIgAEEANgK8AiAAQgA3ArQCIAAgAwR/QQAFAn9B6PcBQej3ASgCAEEBajYCAEHEAUEQQYzSASgCABEDACICCxDaBCAAIAI2AsgBQQELOgCRAgJ/Qej3AUHo9wEoAgBBAWo2AgBBxABBEEGM0gEoAgARAwAiAgsQpA0gAEEBOgCQAiAAIAI2AswBQej3AUHo9wEoAgBBAWo2AgBB2ABBEEGM0gEoAgARAwAhAiAAKALIASEDIAJBAToALCACIAE2AhggAkEANgIUIAJCADcCDCACIAM2AgggAkEANgIEIAJB9Ds2AgAgAkEANgIoIAJBAToAQCACQgA3AiAgAkEANgI8IAJBAToAVCACQgA3AjQgAkEANgJQIAJCADcCSCAAIAI2AsQBC38BBH8CQCAAKALoAyICQQFIDQAgACgC8AMhBANAIAEgBCADQQJ0aiIFKAIARwRAIANBAWoiAyACRw0BDAILCyADIAJODQAgBSAEIAJBf2oiAkECdCIDaigCADYCACAAKALwAyADaiABNgIAIAAgAjYC6AMLIAAgAkEASjYCgAIL0QIBBX8CQAJAIAAoAugDIgJBAUgNACAAKALwAyEEA0AgASAEIANBAnRqKAIARwRAIANBAWoiAyACRw0BDAILCyACIANHDQELAkAgAiAAKALsA0cNACACIAJBAXRBASACGyIETg0AAn8gBARAQej3AUHo9wEoAgBBAWo2AgAgBEECdEEQQYzSASgCABEDACEFIAAoAugDIQILIAJBAU4LBEBBACEDA0AgBSADQQJ0IgZqIAAoAvADIAZqKAIANgIAIANBAWoiAyACRw0ACwsgACgC8AMiAwRAIAAtAPQDBEAgAwRAQez3AUHs9wEoAgBBAWo2AgAgA0GQ0gEoAgARAAALIAAoAugDIQILIABBADYC8AMLIAAgBTYC8AMgACAENgLsAyAAQQE6APQDCyAAKALwAyACQQJ0aiABNgIAIAAgAkEBajYC6AMLIABBATYCgAILXQAgAC0AzAFBA3FFBEAgACAAKgLsAiAAKgLcApQgACoCnAOSOAKcAyAAIAAqAvACIAAqAuAClCAAKgKgA5I4AqADIAAgACoC9AIgACoC5AKUIAAqAqQDkjgCpAMLC5gCAgF/AX4jAEGQAWsiAiQAIAAQqgEgAEEBOgD0AyAAQaA2NgIAIABBADYC8AMgAEIANwLoAyACQQA2AkggAkEANgIEIAJDAAAAADgCACACIAEpAgg3AlQgASkCACEDIAJCADcCDCACQgA3AhQgAkGAgID8AzYCHCACQgA3AyggAkIANwMgIAJBgICA/AM2AjAgAkEANgJEIAJCADcCPCACQgA3AjQgAiADNwJMIAJCiq6P4aPh9ZE8NwKEASACQoquj92j4fWRPDcCfCACQQA6AHggAkGAgID8AzYCdCACQoCAgIDQmbOmPzcCbCACQoCAgPgDNwJkIAJCADcCXCACQYCAgPwDNgIIIAAgAhD6BCACQZABaiQAC5YJAgN/BH0jAEEQayICJAAgAEIANwK4AiAAQQI2AuwBIABCgICA/IOAgMA/NwKgBCAAQoCAgPyDgIDAPzcC3AIgAEIANwKcAyAAQgA3AsACIABCADcCyAIgAEIANwLQAiAAQoCAgPwDNwKoBCAAQgA3AugCIABBgICA/AM2AuQCIABCADcC8AIgAEIANwL4AiAAQgA3AoADIABBADYCiAMgAEIANwKkAyAAQgA3AqwDIABCADcCtAMgASoCYCEFIAIgASoCXCIGOAIMIAIgBTgCCCACQQA2AgQgAkGAgID8AzYCACAAIAJBBGogAiACQQxqIAZDAACAP14bIAZDAAAAAF0bKAIANgK8AyACQQA2AgQgAkGAgID8AzYCACAAIAJBBGogAiACQQhqIAVDAACAP14bIAVDAAAAAF0bKAIANgLAAyAAIAEoAnA2AtgDIAAgASgCdDYC3AMgASgCBCEDIABCADcC4AQgACADNgLgAyAAIAEtAHg6AMQDIAAgASgCfDYCyAMgACABKAKAATYCzAMgACABKAKEATYC0AMgACABKAKIATYC1AMCQCADBEAgAyAAQQRqIgQgAygCACgCCBECAAwBCyAAIAEpAgg3AgQgACABKQIQNwIMIAAgASkCIDcCHCAAIAEpAhg3AhQgACABKQIoNwIkIAAgASkCMDcCLCAAIAFBQGspAgA3AjwgACABKQI4NwI0IABBBGohBAsgACAEKQIANwJEIAAgBCkCCDcCTCAAIAApAhw3AlwgACAAKQIUNwJUIAAgACkCJDcCZCAAIAApAiw3AmwgACAAKQI0NwJ0IAAgACkCPDcCfCAAQgA3AoQBIABCADcCjAEgAEIANwKUASAAQgA3ApwBIAAgASgCZDYC4AEgACABKAJoNgLoASAAIAEoAmw2AuQBIAAgASgCSCAAKAIAKAIMEQIAQZjbAUGY2wEoAgAiA0EBajYCACAAIAM2AvwDQwAAAAAhBSAAKALMASEDAkAgASoCACIGQwAAAABbBEAgACADQQFyNgLMAQwBCyAAIANBfnE2AswBQwAAgD8gBpUhBQsgAEEANgL4AiAAIAU4AtgCIAAgBiAAKgKEA5Q4AvQCIAAgBiAAKgKAA5Q4AvACIAAgBiAAKgL8ApQ4AuwCIAEqAlQhBiABKgJQIQcgASoCTCEIIAAgBSAAKgLcApQ4ArAEIAAgBSAAKgLgApQ4ArQEIAAgBSAAKgLkApQ4ArgEIABBADYCvAQgAEEANgKYAyAAQwAAgD8gCJVDAAAAACAIQwAAAABcGzgCjAMgAEMAAIA/IAeVQwAAAAAgB0MAAAAAXBs4ApADIABDAACAPyAGlUMAAAAAIAZDAAAAAFwbOAKUAyAAEN4CIABCADcCgAQgAEEANgL4AyAAQgA3AogEIABCADcCkAQgAEIANwKYBCAAQgA3ArwEIABCADcCxAQgAEIANwLMBCAAQgA3AtQEIABBADYC3AQgACAAKgLYAiIFIAAqAuQClDgCuAQgACAFIAAqAuAClDgCtAQgACAFIAAqAtwClDgCsAQgAkEQaiQACxgBAX8jAEEQayIBIAA2AgwgASgCDEEIagsJACAAIAE2AkgLhQIBAX8gAEGwMjYCACAALQDIAwRAIAAoAsQDIgEgASgCACgCABEBABogACgCxAMiAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAKAKkAyIBBEAgAC0AqAMEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYCpAMLIABBADYCpAMgAEIANwKcAyAAQQE6AKgDIAAoAtACIgEEQCAALQDUAgRAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgLQAgsgAEEANgLQAiAAQgA3AsgCIABBAToA1AIgABDbAhogAAveAgEFfyAAQYCAEDYCICAAKAIEIgFBzxJIBEAgACgCCEHPEkgEQAJ/Qej3AUHo9wEoAgBBAWo2AgBBvMoAQRBBjNIBKAIAEQMAIQQgACgCBCIDQQFOCwRAA0AgBCAFQQJ0IgJqIAAoAgwgAmooAgA2AgAgBUEBaiIFIANHDQALCyAAKAIMIgIEQCAALQAQBEAgAgRAQez3AUHs9wEoAgBBAWo2AgAgAkGQ0gEoAgARAAALCyAAQQA2AgwLIAAgBDYCDCAAQQE6ABAgAEHPEjYCCAsDQCAAKAIMIAFBAnRqQQA2AgAgAUEBaiIBQc8SRw0ACwsgAEHPEjYCBEEAIQMDQCAAKAIMIANBAnRqIgIoAgAhASACQQA2AgAgAQRAA0AgASgCmAIhAiABEA4gAiIBDQALCyADQQFqIgNBzxJHDQALIABCgYCAgBA3AiQgAEEANgIcIABCgICA9AM3AhQLBABBAwsVACAAIAEgAiADIAAoAgAoAlARBAAL6wMCAX8BfSMAQZAGayICJAAgAkIANwLcBSACQgA3A+gFIAJBgICA/AM2AuQFIAJCADcC/AUgAkGAgID8AzYC+AUgAkIANwKEBiACQQA2AowGIAJCADcC1AUgAkGAgID8AzYC0AUgAkIANwPwBSACQgA3A8gFIAJBuDA2AqAEIAIgACgCyAE2AsQFIAAoAsQBIQQgAkHoA2oiA0IjNwIEIANBpJABNgIAIANBiq6P6QM2AiwgA0KAgID8AzcCFCADQoCAgPyDgIDAPzcCDCADQaSRATYCACACIAQ2ApQEIAIgBDYChAQgAkHEggE2AugDIAJBCDYC7AMgAkGAA2oQ3gEhAyACQQE2AoQDIAJB/DA2AoADIAIgASkCCDcDwAMgAiABKQIANwO4AyACIAEpAhA3A8gDIAIgASkCGDcD0AMgAiABKQIgNwPYAyACIAEpAig3A+ADIAJBADoA5AIgAkGX7sbGAzYCzAICQAJ/IAJBCGoiASACQYADajYCDCABIAJB6ANqNgIIIAEgAkEYajYCBCABQeDJADYCACABCyAAQQRqIABBxABqIAJB0AVqIAJB0AVqIAJBoARqEM4ERQ0AIAAqAsgBIAIqAsQFIgVeQQFzDQAgACAFOALIAQsgAxBgGiACQZAGaiQAC8IBACAAQYSzATYCACAAIAEoAgA2AgQgACAEOgAIIABB6C02AgAgASgCACEBIABBAToAWCAAQUBrQQA2AgAgACABNgI8IABBhC42AgwgAEEANgJUIABBAToAbCAAQgA3AkwgAEEANgJoIABBAToAgAEgAEIANwJgIABBADYCfCAAQQE6AJQBIABCADcCdCAAQQA2ApABIABCADcCiAEgACADIAIgBBsoAgg2AhAgACACIAMgBBsoAgg2AhQgAEEMahC1AQspAgF/AX0jAEEQayIBJAAgASAANgIMIAEoAgwQ4QIhAiABQRBqJAAgAgu5DQIDfx19IwBBMGsiBiQAIAEqAjQgACoCDF1BAXNFBEAgASgCMCEHIAEqAiwhCiABKgIoIQsgASoCJCEOIAIQMSEFIAEqAgwgBSoCOJMhCCABKgIIIAUqAjSTIQwgBSoCMCEJIAEqAgQhDSADEDEhBSANIAmTIQkgCkMAAIA/IA4gDpQgCyALlJIgCiAKlJKRlSITlCEVIAsgE5QhFiAOIBOUIRMgASoCHCAFKgI4kyEKIAEqAhggBSoCNJMhCyABKgIUIAUqAjCTIQ4CfQJAIAIoAgQiBUUEQCACKAIAIgUNAUMAAAAADAILIAwgBSoCyAIiDZQgCSAFKgLMAiIPlJMhFCAJIAUqAtACIhCUIAggDZSTIREgCCAPlCAMIBCUkyESIAUqArwCIQ8gBSoCuAIhECAFKgLAAgwBCyAMIAUqAswCIg2UIAkgBSoC0AIiD5STIRQgCSAFKgLUAiIQlCAIIA2UkyERIAggD5QgDCAQlJMhEiAFKgLAAiEPIAUqArwCIRAgBSoCxAILIBSSISAgDyARkiEhIBAgEpIhIgJ9AkAgAygCBCIFRQRAIAMoAgAiBQ0BQwAAAAAhEUMAAAAAIRRDAAAAACENQwAAAAAhD0MAAAAAIRBDAAAAAAwCCyALIAUqAsgCIg2UIA4gBSoCzAIiEpSTIRAgDiAFKgLQAiIRlCAKIA2UkyEPIAogEpQgCyARlJMhDSAFKgK8AiERIAUqArgCIRQgBSoCwAIMAQsgCyAFKgLMAiINlCAOIAUqAtACIhKUkyEQIA4gBSoC1AIiEZQgCiANlJMhDyAKIBKUIAsgEZSTIQ0gBSoCwAIhESAFKgK8AiEUIAUqAsQCCyESIAAqAgwhIyABKgI0ISQgBCACKQIANwIEIAQgAigCCDYCDCAEIAMpAgA3AhAgBCADKAIINgIYIAIQMSIBKgIkIRcgASoCFCEYIAEqAighGSABKgIYIRogASoCBCEbIAEqAgghHCABKgIgIR0gASoCACEeIAEqAhAhHyAEQQA2AiggBCAJIB6UIAwgH5SSIAggHZSSOAIcIAQgCSAclCAMIBqUkiAIIBmUkjgCJCAEIAkgG5QgDCAYlJIgCCAXlJI4AiAgAxAxIgEqAiQhFyABKgIUIRggASoCKCEZIAEqAhghGiABKgIEIRsgASoCCCEcIAEqAiAhHSABKgIAIR4gASoCECEfIARBADYCwAEgBCAKOAK8ASAEIAs4ArgBIARBtAFqIgEgDjgCACAEQQA2ArABIAQgCDgCrAEgBCAMOAKoASAEIAk4AqQBIARBADYCOCAEQgA3ApwBIARCgICA/IOAgMA/NwI8IAQgBzYC0AEgBCAVOALMASAEIBY4AsgBIAQgEzgCxAEgBEEANgJUIAQgFSAkICOTIgiUOAJQIAQgFiAIlDgCTCAEIBMgCJQ4AkggBEGAgID8AzYCRCAEIA4gHpQgCyAflJIgCiAdlJI4AiwgBCAOIByUIAsgGpSSIAogGZSSOAI0IAQgDiAblCALIBiUkiAKIBeUkjgCMCAEQQA6AJgBIARDAACAPyAAKgIQIgwgICASIBCSkyIIIBUgEyAiIBQgDZKTIgmUIBYgISARIA+SkyIKlJIgFSAIlJIiCJSTIgsgC5QgCSATIAiUkyIJIAmUIAogFiAIlJMiCSAJlJKSIAwgCCAIIAyUlJRdGzgC1AECfQJ/IAIoAgQiAARAIABB2AJqDAELQwAAAAAgAigCACIARQ0BGiAAQYABagsqAgALIQgCQEGc2gEtAABBAXENAEGc2gEQEEUNAEGU2gFCADcCAEGM2gFCADcCAEGE2gFCADcCAEH82QFCADcCAEH02QFCADcCAEHs2QFCADcCAEGc2gEQDwsgAigCACIAQbQBakHs2QEgABshBSACKAIEIgJBiAJqIQcCfQJ/IAMoAgQiAARAIABB2AJqDAELQwAAAAAgAygCACIARQ0BGiAAQYABagsqAgALIQwgBEGkAWohACAHIAUgAhshAkEBIQUCQEGc2gEtAABBAXENAEGc2gEQEEUNAEGU2gFCADcCAEGM2gFCADcCAEGE2gFCADcCAEH82QFCADcCAEH02QFCADcCAEHs2QFCADcCAEGc2gEQDwsgBiAIIAIgACAMIAMoAgQiAEGIAmogAygCACICQbQBakHs2QEgAhsgABsgARDkDyAEIAYpAwg3AnAgBCAGKQMANwJoIAQgBikDEDcCeCAEIAYpAxg3AoABIAQgBikDIDcCiAEgBCAGKQMoNwKQAQsgBkEwaiQAIAULBABBDAvEBQEJfwJAIAAoAgQiByAAKAIwIgFODQACQCAAKAIIIAFOBEAgACgCDCEEDAELIAchAiABBEBB6PcBQej3ASgCAEEBajYCACABQQJ0QRBBjNIBKAIAEQMAIQQgACgCBCECCyAAKAIMIQUCQAJAIAJBAU4EQANAIAQgA0ECdCIGaiAFIAZqKAIANgIAIANBAWoiAyACRw0ADAIACwALIAUNAAwBCyAALQAQBEAgBQRAQez3AUHs9wEoAgBBAWo2AgAgBUGQ0gEoAgARAAALCwsgACAENgIMIABBAToAECAAIAE2AggLIAQgB0ECdCICakEAIAFBAnQiCCACaxALGiAAIAE2AgQgACgCGCIGIAFIBEACQCAAKAIcIAFOBEAgACgCICEEDAELQQAhAyAGIQJBACEEIAEEQEHo9wFB6PcBKAIAQQFqNgIAIAhBEEGM0gEoAgARAwAhBCAAKAIYIQILIAAoAiAhBQJAIAJBAU4EQANAIAQgA0ECdCIJaiAFIAlqKAIANgIAIANBAWoiAyACRw0ADAIACwALIAUNACAAIAQ2AiAgACABNgIcIABBAToAJAwBCyAALQAkBEAgBQRAQez3AUHs9wEoAgBBAWo2AgAgBUGQ0gEoAgARAAALCyAAIAQ2AiAgAEEBOgAkIAAgATYCHAsgBCAGQQJ0IgJqQQAgCCACaxALGgsgACABNgIYIAFBAU4EQCAAKAIMQf8BIAgQCxogACgCIEH/ASAIEAsaCyAHQQFIDQAgACgCICECIAAoAkghBSAAKAIMIQZBACEDA0AgAiADQQJ0aiAGIAAoAjBBf2ogBSADQQN0aigCACIBIAFBD3RBf3NqIgFBCnUgAXNBCWwiAUEGdSABcyIBIAFBC3RBf3NqIgFBEHUgAXNxQQJ0aiIBKAIANgIAIAEgAzYCACADQQFqIgMgB0cNAAsLC/UCAgN/An0jAEEgayICJAACQCABKAKEAyIDIAAoAoQDcUEwcUFwaiIEQRBLDQACQAJAIARBAWsOEAICAgICAgICAgICAgICAgABC0EAIAAgAUYgA0HAAHEbDQEgAkEANgIUIAJBgICA/AM2AgQgAkHIKzYCACACIAAoAsgDNgIIIAIgACgCwAEiAyADKAIAKAIwEQYAIAEoAsABIgMgAygCACgCMBEGAJI4AgwgASoCvAIhBSAAKgK8AiEGIAIgATYCHCACIAA2AhggAiAGIAUgBiAFXRs4AhAgACgCmAggASgCmAggAhDnAgwBCyAAIAFGDQAgAkGcLDYCACAAKALAASIDIAMoAgAoAjARBgAhBSABKALAASIDIAMoAgAoAjARBgAhBiACIAE2AgggAiAANgIEIAIgBSAGkjgCDCAAKAKgByABKALcByACEOcCIAIgADYCCCACIAE2AgQgASgCoAcgACgC3AcgAhDnAgsgAkEgaiQAC54HARZ9IAQqAighCyAEKgIYIQkgBCoCJCEKIAQqAhQhDSAFKgIEIQYgBCoCCCEQIAQqAgQhESAEKgIgIRIgBSoCACEIIAQqAgAhEyAFKgIIIQcgBCoCECEUIABBADYCLCAAQQA2AhwgAEEANgIMIABDAACAPyABlSIBIAMgByARlCANQwAAAACUkiAIIAqUkyIXQwAAAACUIAcgByATlCAUQwAAAACUkiAIIBKUkyIYlJMgCCAHIBCUIAlDAAAAAJSSIAggC5STIhmUkpMgApIiFSADIBNDAAAAAJQgByAUlJMgBiASlJIiDEMAAAAAlCAHIBFDAAAAAJQgByANlJMgBiAKlJIiGpSSIAYgEEMAAAAAlCAHIAmUkyAGIAuUkiIblJOTIAKSIg6UIAYgGZQgGEMAAAAAlCAHIBeUkpNDAAAAAJIiFkMAAAAAIBpDAAAAAJQgByAMlJMgCCAblJKTQwAAAACSIg+Uk0MAAIA/QwAAAAAgBiAMlCAIIBqUkyAbQwAAAACUkpNDAAAAAJIiDCAWQwAAAAAgCCANlCAGIBGUkyAKQwAAAACUkiIKQwAAAACUIAcgCCAUlCAGIBOUkyASQwAAAACUkiINlJMgCCAIIAmUIAYgEJSTIAtDAAAAAJSSIgmUkpNDAAAAAJIiC5QgBiAJlCANQwAAAACUIAcgCpSSk0MAAAAAkiIHIBWUkyIQlCAOIBUgAyAGIA2UIAggCpSTIAlDAAAAAJSSkyACkiIDlEMAAAAAIAYgGJQgCCAXlJMgGUMAAAAAlJKTQwAAAACSIgYgC5STIgiUIA8gByAGlCAWIAOUkyIJlJKSlSIClCIKlCAGIA+UIBUgDJSTIAKUIg1DAAAAAJQiESAWIAyUIAYgDpSTIAKUIgZDAAAAAJQiEpKSOAIoIAAgASAHIA+UIAsgDpSTIAKUIhOUIAsgDJQgAyAPlJMgApQiD0MAAAAAlCILIAMgDpQgByAMlJMgApQiA0MAAAAAlCIHkpI4AiQgACABIBAgApQiDpQgCCAClCIIQwAAAACUIgwgCSAClCICQwAAAACUIgmSkjgCICAAIApDAAAAAJQiCiARIAEgBpSSkjgCGCAAIBNDAAAAAJQiBiALIAEgA5SSkjgCFCAAIA5DAAAAAJQiAyAMIAEgApSSkjgCECAAIAogASANlCASkpI4AgggACAGIAEgD5QgB5KSOAIEIAAgAyABIAiUIAmSkjgCAAu7BwIRfwt9Qe8jEBYCQCAAKALIBSIJQQFIDQACf0Ho9wFB6PcBKAIAQQFqNgIAIAlBBHQiAkEQQYzSASgCABEDACIEC0EAIAIQCxogACgCyAUiAkEBSA0AAn9B6PcBQej3ASgCAEEBajYCACACQQJ0IgJBEEGM0gEoAgARAwAiBQtBACACEAsaCyAAQdgIaigCACEIAkAgAQRAIAhBAUgNASAAQeAIaigCACEGA0AgBiADQQJ0aigCACICKAK4AiIHBEAgAkMAAIA/IAeylSITIAIqApQClDgClAIgAiATIAIqApgClDgCmAIgAiATIAIqApwClDgCnAIgAiATIAIqAqQClDgCpAIgAiATIAIqAqgClDgCqAIgAiATIAIqAqwClDgCrAILIANBAWoiAyAIRw0ACwsgCEEBSA0AIABB4AhqKAIAIQtBACEGQbgCQbQCIAEbIQwDQAJAIAsgBkECdGooAgAiAiAMaigCAEEBSA0AIAIoAhgiDUEBSA0AIAAqAsQDIhMgAkGkAmogAkGEAmogARsiAyoCCJQhFCATIAMqAgSUIRUgEyADKgIAlCEXIBMgAkGUAmogAkH0AWogARsiAyoCCJQhGCATIAMqAgSUIRkgAyoCACATlCEaIAIoAiAhDiACKAIMIQ8gACgC0AUhEEEAIQcDQCAOIAdBAnQiEWooAgAiCioCCCEWIAIqAuQBIRsgBCAKIBBrQegAbSISQQR0aiIDIAMqAgAgDyARaioCACITIBogFSAKKgIQIAIqAuwBkyIclCAUIAoqAgwgAioC6AGTIh2Uk5KUkjgCACADIAMqAgQgEyAZIBQgFiAbkyIWlCAXIByUk5KUkjgCBCADIBMgGCAXIB2UIBUgFpSTkpQgAyoCCJI4AgggBSASQQJ0aiIDIBMgAyoCAJI4AgAgB0EBaiIHIA1HDQALCyAGQQFqIgYgCEcNAAsLAkACQCAJQQFOBEBBACEBA0AgBSABQQJ0aioCACITQwAAAABeQQFzRQRAIAQgAUEEdGoiAyoCCCEUIAMqAgQhFSAAKALQBSABQegAbGoiAkMAAIA/IBOVIhMgAyoCAJQgAioCCJI4AgggAiATIBWUIAIqAgySOAIMIAIgEyAUlCACKgIQkjgCEAsgAUEBaiIBIAlHDQALDAELIAVFDQELIAUEQEHs9wFB7PcBKAIAQQFqNgIAIAVBkNIBKAIAEQAACwsgBARAIAQEQEHs9wFB7PcBKAIAQQFqNgIAIARBkNIBKAIAEQAACwsQEwvHBwIOfwp9IwBBIGsiBSQAAkAgAEUNACABKgIIIRIgAioCCCETIAEqAgAhFiACKgIAIRQgASoCBCEXIAIqAgQhFQJ/Qej3AUHo9wEoAgBBAWo2AgBBgARBEEGM0gEoAgARAwAiAkEEagtBAEH8AxALGiACIAA2AgAgEyASkyISIBJDAACAPyAUIBaTIhMgE5QgFSAXkyIWIBaUkiASIBKUkpGVIhKUIhSUIBMgEyASlCITlCAWIBYgEpQiEpSSkiEaIAVDawteXUMAAIA/IBSVIBRDAAAAAFsbIhZDAAAAAF0iAEEEdGpBCHIhCyAFQ2sLXl1DAACAPyASlSASQwAAAABbGyISQwAAAABdIgRBBHRqQQRyIQwgBSAAQQFzQQR0akEIciENIAUgBEEBc0EEdGpBBHIhDiAFQ2sLXl1DAACAPyATlSATQwAAAABbGyITQwAAAABdIgBBBHRqIQ8gBSAAQQFzQQR0aiEQQf4AIQhBgAEhCUGAASEGQQEhAANAIAUgAiAAQX9qIgRBAnQiEWooAgAiBykCADcDACAFIAcpAgg3AwggBSAHKQIYNwIYIAUgBykCEDcCEAJ/AkACQAJAAkACQAJAIBIgDCoCACABKgIEIhiTlCIUIBMgECoCACABKgIAIhWTlCIXXg0AIBMgDyoCACAVk5QiFSASIA4qAgAgGJOUIhheDQAgFiALKgIAIAEqAggiG5OUIhkgGCAXIBggF10bIhdeDQAgFCAVIBQgFV4bIhQgFiANKgIAIBuTlCIVXg0AIBkgFCAZIBReGyAaXUEBcw0AIBUgFyAVIBddG0MAAAAAXkEBcw0AIAcoAigEQCAEIAhMBEAgAiEEDAcLIAYgBkEBdCIKTgRAIAIhBAwGCyAJIApOBEAgAiEEDAULIAZFBEBBACEEDAMLQQAhCEHo9wFB6PcBKAIAQQFqNgIAIAZBA3RBEEGM0gEoAgARAwAhBCAGQQFIDQIDQCAEIAhBAnQiCWogAiAJaigCADYCACAIQQFqIgggBkcNAAsMAwsgAyAHIAMoAgAoAgwRAgALIAQMBQsgCiEJIAJFDQELIAIEQEHs9wFB7PcBKAIAQQFqNgIAIAJBkNIBKAIAEQAACyAKIQkLIAQgBkECdCICakEAIAIQCxoLIApBfmohCCAEIQIgCiEGCyAEIBFqIAcoAiQ2AgAgBCAAQQJ0aiAHKAIoNgIAIABBAWoLIgANAAsgAkUNACACBEBB7PcBQez3ASgCAEEBajYCACACQZDSASgCABEAAAsLIAVBIGokAAszAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDCACKAIIEO4PIQAgAkEQaiQAIAALjg4CCn8OfSMAQRBrIgkkACAAQdgIaigCAEEBTgRAA0AgACgC4AggCkECdGooAgAiAUEANgKAASABKAIYIgUhAyAFIAEoAgQiAkoEQAJAIAEoAgggBU4EQCABKAIMIQYMAQtBACEDIAIhBEEAIQYgBQRAQej3AUHo9wEoAgBBAWo2AgAgBUECdEEQQYzSASgCABEDACEGIAEoAgQhBAsgASgCDCEHAkACQCAEQQFOBEADQCAGIANBAnQiCGogByAIaigCADYCACADQQFqIgMgBEcNAAwCAAsACyAHRQ0BCyABLQAQRQ0AIAcEQEHs9wFB7PcBKAIAQQFqNgIAIAdBkNIBKAIAEQAACwsgASAGNgIMIAFBAToAECABIAU2AggLIAYgAkECdGpBACAFIAJrQQJ0EAsaIAEoAhghAwsgASAFNgIEAkAgA0EASiIHRQRAIAFDAACAPyABKgKAAZUiCzgCgAFDAAAAACEMQwAAAAAhDUMAAAAAIQ8MAQsgASgCICECIAEoAgwhBkEAIQQDQAJ9IAIgBEECdCIFaigCACoCWCILQwAAAABbBEAgAUEBOgD4AkNrC15dDAELQwAAgD8gC5ULIQsgBSAGaiALOAIAIAEgCyABKgKAAZIiCzgCgAEgBEEBaiIEIANHDQALIAFDAACAPyALlSILOAKAASABKAIMIQYgASgCICEFQwAAAAAhD0EAIQRDAAAAACENQwAAAAAhDANAIAwgBSAEQQJ0IghqKAIAIgIqAgggBiAIaioCACIOlJIhDCAPIA4gAioCEJSSIQ8gDSAOIAIqAgyUkiENIARBAWoiBCADRw0ACwsgAUIANwK8AiABQgA3AoQBIAFBADYC8AEgASALIA+UIhU4AuwBIAEgCyANlCIWOALoASABIAsgDJQiFzgC5AEgAUIANwLEAiABQgA3AswCIAFCADcC1AIgAUEANgLcAiABQgA3AowBIAFCADcClAEgAUIANwKcASABQgA3AqQBIAFCADcCrAECQCAHRQRAIAEqApgBIQ4gASoCnAEhDSABKgKMASELIAEqAogBIQwgASoChAEhD0MAAAAAIREMAQsgASoCnAEhDSABKgKMASELIAEqAogBIQwgASoCmAEhDiABKAIgIQcgASoChAEhDyABKAIMIQZBACEEQwAAAAAhEQNAIAcgBEECdCIFaigCACICKgIMIRAgASALIAIqAhAgFZMiEiACKgIIIBeTIhQgBSAGaioCACITlCIYlJMiCzgCjAEgASAMIBAgFpMiECAYlJMiDDgCiAEgASANIBIgECATlJSTIg04ApwBIAEgEyAUIBSUIhQgECAQlCIQkpQgEZIiETgCrAEgASATIBQgEiASlCISkpQgDpIiDjgCmAEgASAPIBMgECASkpSSIg84AoQBIARBAWoiBCADRw0ACwsgAUEANgKwASABQYCAgPwDNgI8IAFBADYCoAEgAUEANgKQASABQUBrQgA3AgAgAUIANwJIIAFCADcCVCABQYCAgPwDNgJQIAFCADcCXCABIA4gD5QgDCAMlJNDAACAPyAOIBGUIA0gDZSTIhMgD5QgDCANIAuUIBEgDJSTIhKUkiANIAyUIA4gC5STIhAgC5SSlSIOlDgCrAEgASAMIAuUIA0gD5STIA6UIgw4AqgBIAEgECAOlCINOAKkASABIAw4ApwBIAEgESAPlCALIAuUkyAOlDgCmAEgASASIA6UIgs4ApQBIAEgDTgCjAEgASALOAKIASABIBMgDpQ4AoQBIAFCgICA/AM3AmQgASABKQLkATcCbCABIAEpAuwBNwJ0IAEoAiwiBCADSARAIAEoAjAgA0gEQAJ/IANFBEBBACEHIAQMAQtB6PcBQej3ASgCAEEBajYCACADQQR0QRBBjNIBKAIAEQMAIQcgASgCLAsiAkEBTgRAQQAhBgNAIAcgBkEEdCIFaiIIIAEoAjQgBWoiBSkCADcCACAIIAUpAgg3AgggBkEBaiIGIAJHDQALCyABKAI0IgIEQCABLQA4BEAgAgRAQez3AUHs9wEoAgBBAWo2AgAgAkGQ0gEoAgARAAALCyABQQA2AjQLIAEgBzYCNCABIAM2AjAgAUEBOgA4CwNAIAEoAjQgBEEEdGoiAiAJKQIANwIAIAIgCSkCCDcCCCAEQQFqIgQgA0cNAAsLIAEgAzYCLCADQQFOBEBBACEDA0AgASgCICADQQJ0aigCACICKgIMIQsgAioCECEMIAIqAgghDSABKgLoASEPIAEqAuwBIQ4gASoC5AEhESABKAI0IANBBHRqIgJBADYCDCACIA0gEZM4AgAgAiAMIA6TOAIIIAIgCyAPkzgCBCADQQFqIgMgASgCLEgNAAsLIApBAWoiCiAAKALYCEgNAAsLIAlBEGokAAvoBAEMfyAAKAIIIAFIBEAgAQR/Qej3AUHo9wEoAgBBAWo2AgAgAUEUbEEQQYzSASgCABEDAAVBAAshBwJAIAAoAgQiCUEBSA0AA0AgACgCDCEDIAcgCEEUbCIEaiICQQA2AgwgAkEBOgAQIAJCADcCBAJAIAMgBGoiCigCBCIFQQBMBEAgAiAFNgIEDAELQej3AUHo9wEoAgBBAWo2AgAgBUECdCILQRBBjNIBKAIAEQMAIQYgAigCDCEDQQAhBAJAAkAgAigCBCIMQQFOBEADQCAGIARBAnQiDWogAyANaigCADYCACAEQQFqIgQgDEcNAAwCAAsACyADRQ0BCyACLQAQRQ0AIAMEQEHs9wFB7PcBKAIAQQFqNgIAIANBkNIBKAIAEQAACwsgAkEBOgAQIAIgBjYCDCACIAU2AghBACEEIAZBACALEAsaIAIoAgwhAyACIAU2AgQgCigCDCECA0AgAyAEQQJ0IgZqIAIgBmooAgA2AgAgBEEBaiIEIAVHDQALCyAIQQFqIgggCUcNAAsgACgCBCIGQQFIDQBBACEEA0AgACgCDCAEQRRsaiICIQUgAigCDCIDBEAgAi0AEARAIAMEQEHs9wFB7PcBKAIAQQFqNgIAIANBkNIBKAIAEQAACwsgBUEANgIMCyACQQE6ABAgBUEANgIMIAJBADYCBCACQQA2AgggBEEBaiIEIAZHDQALCyAAKAIMIgMEQCAALQAQBEAgAwRAQez3AUHs9wEoAgBBAWo2AgAgA0GQ0gEoAgARAAALCyAAQQA2AgwLIAAgBzYCDCAAQQE6ABAgACABNgIICwviAwEJfwJAIAAoAgQiBiABSgRAIAEhAgNAIAAoAgwgAkEUbGoiAyEEIAMoAgwiBQRAIAMtABAEQCAFBEBB7PcBQez3ASgCAEEBajYCACAFQZDSASgCABEAAAsLIARBADYCDAsgA0EBOgAQIARBADYCDCADQQA2AgQgA0EANgIIIAJBAWoiAiAGRw0ACwwBCyAGIAFODQAgACABEI0FA0AgACgCDCAGQRRsaiIDQQA2AgwgA0EBOgAQIANCADcCBAJAIAIoAgQiB0EATARAIAMgBzYCBAwBC0Ho9wFB6PcBKAIAQQFqNgIAIAdBAnQiCUEQQYzSASgCABEDACEIIAMoAgwhBUEAIQQCQAJAIAMoAgQiCkEBTgRAA0AgCCAEQQJ0IgtqIAUgC2ooAgA2AgAgBEEBaiIEIApHDQAMAgALAAsgBUUNAQsgAy0AEEUNACAFBEBB7PcBQez3ASgCAEEBajYCACAFQZDSASgCABEAAAsLIANBAToAECADIAg2AgwgAyAHNgIIQQAhBCAIQQAgCRALGiADKAIMIQUgAyAHNgIEIAIoAgwhAwNAIAUgBEECdCIIaiADIAhqKAIANgIAIARBAWoiBCAHRw0ACwsgBkEBaiIGIAFHDQALCyAAIAE2AgQLrRACE38BfSMAQTBrIgkkACABQQJOBEBBfyAAKALIBSIHIAdsIgNBAnQgA0H/////A3EgA0cbEBIhCyAHQQFOBEBBACEDA0AgCyADIAMgB2wiCmpBAnRqIQZBACEEA0AgCyAEIAdsIANqQQJ0aiEFAkAgAyAERwRAIAVB/////wc2AgAgCyAEIApqQQJ0akH/////BzYCAAwBCyAFQQA2AgAgBkEANgIACyAEQQFqIgQgB0cNAAsgA0EBaiIDIAdHDQALCyAAKALcBSIFQQFOBEAgACgC0AUhAyAAKALkBSEKQQAhBANAIAsgCiAEQTRsaiIGKAIMIANrQegAbSIIIAdsIAYoAgggA2tB6ABtIgZqQQJ0akEBNgIAIAsgBiAHbCAIakECdGpBATYCACAEQQFqIgQgBUcNAAsLAkACQCABQQJHBEBBACEKIAdBAEwNAgNAIAcgCmwhCEEAIQMDQCADIgVBAWoiAyAHSARAIAsgBSAHbCIMIApqQQJ0aiENIAMhBANAIAsgBCAMakECdGoiDigCACANKAIAIAsgBCAIakECdGooAgBqIgZLBEAgCyAEIAdsIAVqQQJ0aiAGNgIAIA4gBjYCAAsgBEEBaiIEIAdHDQALCyADIAdHDQALIApBAWoiCiAHRw0ACwwBCyAJQQA2AiQgCUEBOgAoIAlCADcCHCAJQQA2AhAgCUIANwMIIAlBAToAECAJQgA3AwAgCUEANgIEIAlBGGogByAJEI4FIAkoAgwiAwRAIAktABAEQCADBEBB7PcBQez3ASgCAEEBajYCACADQZDSASgCABEAAAsLIAlBADYCDAsgACgC3AVBAU4EQEEAIQoDQCAAKALkBSAKQTRsaiIDKAIMIAAoAtAFIgRrQegAbSEMAkACQCAJKAIkIgYgAygCCCAEa0HoAG0iDkEUbGoiBSgCBCIDQQFIDQAgBSgCDCEIQQAhBANAIAwgCCAEQQJ0aigCAEcEQCAEQQFqIgQgA0cNAQwCCwsgAyAERw0BCwJAIAMgBSgCCEcNACADIANBAXRBASADGyINTg0AQQAhBEEAIQYgDQRAQej3AUHo9wEoAgBBAWo2AgAgDUECdEEQQYzSASgCABEDACEGIAUoAgQhAwsgBSgCDCEIAkACQCADQQFOBEADQCAGIARBAnQiD2ogCCAPaigCADYCACAEQQFqIgQgA0cNAAwCAAsACyAIRQ0BCyAFLQAQBEAgCARAQez3AUHs9wEoAgBBAWo2AgAgCEGQ0gEoAgARAAALCyAFQQA2AgwgBSgCBCEDCyAFQQE6ABAgBSAGNgIMIAUgDTYCCCAJKAIkIQYLIAUoAgwgA0ECdGogDDYCACAFIAUoAgRBAWo2AgQLAkACQCAGIAxBFGxqIgUoAgQiA0EBSA0AIAUoAgwhBkEAIQQDQCAOIAYgBEECdGooAgBHBEAgBEEBaiIEIANHDQEMAgsLIAMgBEcNAQsCQCADIAUoAghHDQAgAyADQQF0QQEgAxsiCE4NAEEAIQRBACEMIAgEQEHo9wFB6PcBKAIAQQFqNgIAIAhBAnRBEEGM0gEoAgARAwAhDCAFKAIEIQMLIAUoAgwhBgJAAkAgA0EBTgRAA0AgDCAEQQJ0Ig1qIAYgDWooAgA2AgAgBEEBaiIEIANHDQAMAgALAAsgBkUNAQsgBS0AEARAIAYEQEHs9wFB7PcBKAIAQQFqNgIAIAZBkNIBKAIAEQAACwsgBUEANgIMIAUoAgQhAwsgBUEBOgAQIAUgDDYCDCAFIAg2AggLIAUoAgwgA0ECdGogDjYCACAFIAUoAgRBAWo2AgQLIApBAWoiCiAAKALcBUgNAAsLIAkoAhwiCkEBTgRAQQAhAyAJKAIkIQYDQCAGIANBFGxqIggoAgRBAU4EQCADIAdsIREgCCgCDCESQQAhBQNAIAYgEiAFQQJ0aigCACIMQRRsaiINKAIEIg5BAU4EQCALIAcgDGwgA2pBAnRqIRMgDSgCDCEUQQAhBANAAkAgAyAUIARBAnRqKAIAIg9GDQAgCyAHIA9sIhAgA2pBAnRqIhUoAgAgCyAMIBBqQQJ0aigCACATKAIAaiIQTQ0AIAsgDyARakECdGogEDYCACAVIBA2AgAgDSgCBCEOCyAEQQFqIgQgDkgNAAsLIAVBAWoiBSAIKAIESA0ACwsgA0EBaiIDIApHDQALQQAhAwNAIAkoAiQgA0EUbGoiBCEFIAQoAgwiBgRAIAQtABAEQCAGBEBB7PcBQez3ASgCAEEBajYCACAGQZDSASgCABEAAAsLIAVBADYCDAsgBEEBOgAQIAVBADYCDCAEQQA2AgQgBEEANgIIIANBAWoiAyAKRw0ACwsgCSgCJCIDRQ0AIAktACgEQCADBEBB7PcBQez3ASgCAEEBajYCACADQZDSASgCABEAAAsLIAlBADYCJAtBACEKIAdBAUgNAEEAIQMDQCADIgVBAWoiAyAHSARAIAUgB2whDSADIQQDQCABIAsgBCANakECdGooAgBGBEAgACgC0AUhCCAAIAIQ8AIgACgC3AVBNGxBTGoiDiAAKALkBWoiDCAIIARB6ABsaiIGNgIIIAwgCCAFQegAbGoiCDYCDCAMIAYqAgggCCoCCJMiFiAWlCAGKgIMIAgqAgyTIhYgFpSSIAYqAhAgCCoCEJMiFiAWlJKROAIQIABBAToAnAcgACgC5AUgDmoiBiAGLQAUQQFyOgAUIApBAWohCgsgBEEBaiIEIAdHDQALCyADIAdHDQALCyALEA4LIAlBMGokACAKC5sEAgV/BH0jAEEgayIDJAAgACgCwAEiAiACKAIAKAIwEQYAIQcgACgCyAUiBUEBTgRAIABBoAdqIQYDQCAAKALQBSAEQegAbGoiAiABKgIAIAIqAgiUIgg4AgggAiABKgIEIAIqAgyUIgk4AgwgAiABKgIIIAIqAhCUIgo4AhAgAiABKgIAIAIqAhiUOAIYIAIgASoCBCACKgIclDgCHCACIAEqAgggAioCIJQ4AiAgA0EANgIcIAMgByAKkjgCGCADIAcgCZI4AhQgAyAHIAiSOAIQIANBADYCDCADIAogB5M4AgggAyAJIAeTOAIEIAMgCCAHkzgCACAGIAIoAmAgAxCkASAEQQFqIgQgBUcNAAsLIAAQ/QECQCAAKAKgByIBBEAgACgCwAEiAiACKAIAKAIwEQYAIQcgASoCACEIIAEqAgQhCSABKgIIIQogAEEANgKIByAAIAogB5M4AoQHIAAgCSAHkzgCgAcgACAIIAeTOAL8BiABKgIUIQggASoCGCEJIAEqAhAhCiAAQQA2ApgHIAAgByAJkjgClAcgACAHIAiSOAKQByAAQYwHaiIBIAcgCpI4AgAgACgCvAEiAkUNASAAKAKsBSIEKAIgIgUgAiAAQfwGaiABIAQoAiQgBSgCACgCEBEJAAwBCyAAQgA3AvwGIABCADcClAcgAEIANwKMByAAQgA3AoQHCyAAEPwBIANBIGokAAuhAgIBfwl9IwBBQGoiAiQAIAJCADcDOCACQgA3AzAgASoCDCEFIAEqAgghBiABKgIAIQMgASoCBCEEIAJBADYCLCACQQA2AhwgAiAEIAZDAAAAQCADIAOUIAQgBJSSIAYgBpSSIAUgBZSSlSIIlCIJlCIHIAUgAyAIlCIKlCILkjgCJCACIAcgC5M4AhggAkMAAIA/IAMgCpQiByAEIAQgCJQiBJQiCJKTOAIoIAJDAACAPyAHIAYgCZQiBpKTOAIUIAJBADYCDCACIAMgCZQiByAFIASUIgqTOAIgIAIgAyAElCIDIAUgCZQiBZI4AhAgAiAHIAqSOAIIIAIgAyAFkzgCBCACQwAAgD8gCCAGkpM4AgAgACACEP4BIAJBQGskAAtsAQF/IwBBQGoiAiQAIAJCADcCDCACQgA3AxggAkGAgID8AzYCFCACQoCAgPwDNwMoIAJCADcCBCACQYCAgPwDNgIAIAJCADcDICACIAEpAgg3AzggAiABKQIANwMwIAAgAhD+ASACQUBrJAALnQUCCH8FfSAAKALwBSIFQQFOBEAgACgC+AUhBgNAIAYgAUEsbGoiAiACKAIMIgMqAgggAigCCCIEKgIIIgmTIg0gAigCECICKgIMIAQqAgwiCpMiC5QgAyoCDCAKkyIKIAIqAgggCZMiCZSTIgwgDJQgCiACKgIQIAQqAhAiCpMiDJQgAyoCECAKkyIKIAuUkyILIAuUIAogCZQgDSAMlJMiCSAJlJKSkTgCJCABQQFqIgEgBUcNAAsLAkAgACgCyAUiA0EBSARAQQAhAgwBCwJ/Qej3AUHo9wEoAgBBAWo2AgAgA0ECdCIBQRBBjNIBKAIAEQMAIgILQQAgARALGiAAKALIBSIDQQFIDQAgACgC0AUhBEEAIQEDQCAEIAFB6ABsakEANgJcIAFBAWoiASADRw0ACwsCQAJAAn8gACgC8AUiBkEBTgRAIAAoAtAFIQEgACgC+AUhCEEAIQMDQCAIIANBLGxqIgQqAiQhCSACIAQoAggiBSABa0HoAG1BAnRqIgcgBygCAEEBajYCACAFIAmLIgkgBSoCXJI4AlwgAiAEKAIMIgUgAWtB6ABtQQJ0aiIHIAcoAgBBAWo2AgAgBSAJIAUqAlySOAJcIAIgBCgCECIEIAFrQegAbUECdGoiBSAFKAIAQQFqNgIAIAQgCSAEKgJckjgCXCADQQFqIgMgBkcNAAsgACgCyAUhAwsgA0EBTgsEQEEAIQEDQAJAIAIgAUECdGooAgAiBEEBTgRAIAAoAtAFIAFB6ABsaiIFIAUqAlwgBLKVOAJcDAELIAAoAtAFIAFB6ABsakEANgJcCyABQQFqIgEgA0cNAAsMAQsgAkUNAQsgAgRAQez3AUHs9wEoAgBBAWo2AgAgAkGQ0gEoAgARAAALCwvzAQIFfwh9IAAoAsgFQQFIBEBDAAAAAA8LAkAgACgC8AUiBEEBSARADAELIAAoAtAFIgEqAgghByABKgIQIQggASoCDCEJIAAoAvgFIQVBACEAA0AgBiAFIABBLGxqIgEoAggiAioCECAIkyABKAIMIgMqAgggB5MiBiABKAIQIgEqAgwgCZMiC5QgAyoCDCAJkyIKIAEqAgggB5MiDJSTlCACKgIIIAeTIAogASoCECAIkyIKlCADKgIQIAiTIg0gC5STlCACKgIMIAmTIA0gDJQgBiAKlJOUkpKSIQYgAEEBaiIAIARHDQALCyAGQwAAwECVC+0DAgZ/BX0gACgCyAUhBQJAIAIEQCAFQQFOBEAgACgC0AUhA0EAIQIDQCADIAJB6ABsakEANgJYIAJBAWoiAiAFRw0ACwsgACgC8AUiB0EBTgRAIAAoAvgFIQgDQCAIIAZBLGxqIgQoAggiAiAEKAIMIgMqAgggAioCCCIJkyINIAQoAhAiBCoCDCACKgIMIgqTIguUIAMqAgwgCpMiCiAEKgIIIAmTIgmUkyIMIAyUIAogBCoCECACKgIQIgqTIgyUIAMqAhAgCpMiCiALlJMiCyALlCAKIAmUIA0gDJSTIgkgCZSSkpEiCSACKgJYkjgCWCADIAkgAyoCWJI4AlggBCAJIAQqAliSOAJYIAZBAWoiBiAHRw0ACwsgBUEBSA0BIAAoAtAFIQNBACECA0AgAyACQegAbGoiBEMAAIA/IAQqAliVOAJYIAJBAWoiAiAFRw0ACwsgBUEBSA0AIAAoAtAFIQNBACECQwAAAAAhCQNAIAlDAACAPyADIAJB6ABsaioCWCIJlUMAAAAAIAlDAAAAAF4bkiEJIAJBAWoiAiAFRw0AC0MAAIA/IAmVIAGUIQEgACgC0AUhA0EAIQIDQCADIAJB6ABsaiIEIAQqAlggAZU4AlggAkEBaiICIAVHDQALCyAAQQE6AJwHC10CAn8BfQJAIAAoAsgFIgFBAUgEQAwBCyAAKALQBSECQQAhAANAIANDAACAPyACIABB6ABsaioCWCIDlUMAAAAAIANDAAAAAF4bkiEDIABBAWoiACABRw0ACwsgAwvuCgIGfxF9IAAqAsQDIRcCQCAAKgKwAiIYQwAAAABeRUEAIAAqAqwCIhZDAAAAAF5BAXMbDQAgACgCoAIiCEEESA0AIAAoAvgFIgYgAkEsbGoiBCgCCCIDKgIoIhMgBCgCDCIFKgIokiAEKAIQIgcqAiiSQ6uqqj6UIAEqAgCTIgogCpQgAyoCLCIMIAUqAiySIAcqAiySQ6uqqj6UIAEqAgSTIg8gD5SSIAMqAjAiECAFKgIwkiAHKgIwkkOrqqo+lCABKgIIkyIOIA6UkiIVQwAAADReQQFzDQAgCEF8aiIFQQJLDQAgACgCrAUoAgAhASAOQwAAgD8gFZEiGZUiCZQhDSAPIAmUIQsgCiAJlCEJIAQqAhQhEiAEKgIcIREgBCoCGCEUIAVBAWtFBEAgDSARQwAAgL9DAACAPyAKIBKUIA8gFJSSIA4gEZSSQwAAAABdGyIMlCIQlCAJIBIgDJQiE5QgCyAUIAyUIhKUkpIiDCAVIBZDAAAAP5QgAb4iEZSUIAYgAkEsbGoiAioCJEMAAAA/lCIUlJQiCiANjJQhFiAKIAuMlCEVIAogCYyUIRdDAAAAACEPQwAAAAAhDgJ9QwAAAAAgDEMAAAAAXkEBcw0AGkMAAAAAIAxD2ht8P11BAXMNABogCyANIBKUIAsgEJSTIgqUIAkgCSAQlCANIBOUkyIQlJNDAACAPyAMIAyUk5EgGEMAAAA/lCARlCAZlCAUlJQiDJRDq6qqPpQhDiAJIAsgE5QgCSASlJMiCZQgDSAKlJMgDJRDq6qqPpQhDyANIBCUIAsgCZSTIAyUQ6uqqj6UCyEKIBZDq6qqPpQhDCAVQ6uqqj6UIRAgF0Orqqo+lCENQQAhAQNAIAMqAlgiC0MAAAAAXkEBc0UEQAJAIAwgC5QgACoCxAMiCZQiEyATlCANIAuUIAmUIhMgE5QgECALlCAJlCILIAuUkpIiC0MAAAAAXkEBcw0AIAsgAyoCKCIJIAmUIAMqAiwiCSAJlJIgAyoCMCIJIAmUkiIJYEEBcw0AIAwgCZEgC5GVQ83MTD+UIguUIQwgECALlCEQIA0gC5QhDQsgAyAKIA0gAyoCOJKSOAI4IANBQGsiBCAOIAwgBCoCAJKSOAIAIANBPGogDyAQIAMqAjySkjgCAAsgAUEBaiIBQQNGDQIgAiABQQJ0aigCCCEDDAAACwALIA4gEUMAAIC/QwAAgD8gCiASlCAPIBSUkiAOIBGUkkMAAAAAXRsiDpQiEZQgCiASIA6UIhKUIA8gFCAOlCIOlJKSIgpDAAAAAF5BAXMNACANIBYgFSAKIAYgAkEsbGoiAioCJIyUlCABvpQiDZQiCpQgESAYIA2UIg+UQwAAAACSkkOrqqo+lCINQwAAgD8gDSANlCAJIAqUIBIgD5RDAAAAAJKSQ6uqqj6UIgkgCZQgCyAKlCAOIA+UQwAAAACSkkOrqqo+lCILIAuUkpKRlSIKlCEPIAsgCpQhDiAJIAqUIRJBACEAA0ACQCANIBcgAyoCWJQiCpQiESARlCAJIAqUIhEgEZQgCyAKlCIRIBGUkpIgEyATlCAMIAyUkiAQIBCUkl5BAXNFBEAgAyADKgI4QwAAgD8gCpUiCiASIA8gEJQgEiATlCAOIAyUkpIiDJSUkzgCOCADQTxqIAMqAjwgCiAOIAyUlJM4AgAgA0FAayIBIAEqAgAgCiAPIAyUlJM4AgAMAQsgAyAJIAMqAjiSOAI4IANBPGogCyADKgI8kjgCACADQUBrIgEgDSABKgIAkjgCAAsgAEEBaiIAQQNGDQEgAiAAQQJ0aigCCCIDKgIoIRMgAyoCMCEQIAMqAiwhDAwAAAsACws6AQF/IwBBEGsiASQAIAEgADYCDCMAQRBrIgAgASgCDEGIAmo2AgwgACgCDCgCBCEAIAFBEGokACAAC1YAIAAoAtAFIAJB6ABsaiIAKgJYQwAAAABeQQFzRQRAIAAgASoCACAAKgI4kjgCOCAAIAEqAgQgACoCPJI4AjwgAEFAayIAIAEqAgggACoCAJI4AgALC30BA38gACgCyAUiA0EBTgRAIAAoAtAFIQRBACEAA0AgBCAAQegAbGoiAioCWEMAAAAAXkEBc0UEQCACIAEqAgAgAioCOJI4AjggAiABKgIEIAIqAjySOAI8IAJBQGsiAiABKgIIIAIqAgCSOAIACyAAQQFqIgAgA0cNAAsLC7YDAQV/IwBB4ABrIgckAAJAIARFDQACQCAAKAKMAiIGQQFIDQAgACgClAIhCEEAIQQDQCACIAggBEECdGooAgBHBEAgBEEBaiIEIAZHDQEMAgsLIAQgBkcNAQsCQCAGIAAoApACRw0AIAYgBkEBdEEBIAYbIghODQACfyAIBEBB6PcBQej3ASgCAEEBajYCACAIQQJ0QRBBjNIBKAIAEQMAIQkgACgCjAIhBgsgBkEBTgsEQEEAIQQDQCAJIARBAnQiCmogACgClAIgCmooAgA2AgAgBEEBaiIEIAZHDQALCyAAKAKUAiIEBEAgAC0AmAIEQCAEBEBB7PcBQez3ASgCAEEBajYCACAEQZDSASgCABEAAAsgACgCjAIhBgsgAEEANgKUAgsgACAJNgKUAiAAIAg2ApACIABBAToAmAILIAAoApQCIAZBAnRqIAI2AgAgACAGQQFqNgKMAgsgACgC0AUhBCAHIAI2AhQgByAEIAFB6ABsaiIBNgIAIAcgAykCCDcCDCAHIAMpAgA3AgQgASABLQBkQQFyOgBkIAcgBTgCGCAAQZQGaiAHEKYDIAdB4ABqJAALnQICAn8PfSMAQRBrIgUkACAAKALQBSABQegAbGoiBioCECEIIAYqAgwhCSAGKgIIIQogAioCFCENIAIqAiQhDiACKgIoIQ8gAioCGCEQIAIqAgghESACKgI8IQsgAioCLCESIAIqAhwhEyACKgI4IQcgAioCNCEMIAIqAgwhFCACKgIEIRUgBUEANgIMIAUgEyAHjCIHlCAUIAyUkyASIAuUkyAUIAqUIBMgCZSSIBIgCJSSkjgCCCAFIBAgB5QgESAMlJMgDyALlJMgESAKlCAQIAmUkiAPIAiUkpI4AgQgBSANIAeUIBUgDJSTIA4gC5STIBUgCpQgDSAJlJIgDiAIlJKSOAIAIAAgASACIAUgAyAEEJsFIAVBEGokAAuKAgEHfSAAIAUQngUgACgCjAYgACgChAZB6ABsaiIFQaB/aiAAKALQBSABQegAbGoiATYCACAFQaR/aiAAKALQBSACQegAbGoiAjYCACAFQah/aiAAKALQBSADQegAbGoiAzYCACAFQax/aiAAKALQBSAEQegAbGoiBDYCACAFQbB/aiACKgIQIAEqAhAiBpMgAyoCCCABKgIIIgeTIgkgBCoCDCABKgIMIgiTIgqUIAMqAgwgCJMiCyAEKgIIIAeTIgyUk5QgAioCCCAHkyALIAQqAhAgBpMiB5QgAyoCECAGkyIGIAqUk5QgAioCDCAIkyAGIAyUIAkgB5STlJKSOAIAIABBAToAnAcL0AIBBn8jAEHgAGsiAyQAIANBAEHgABALGiABIAAoAvAGKAIAIAEbIQECQCAAKAKEBiICIAAoAogGRw0AIAIgAkEBdEEBIAIbIgRODQACfyAEBEBB6PcBQej3ASgCAEEBajYCACAEQegAbEEQQYzSASgCABEDACEFIAAoAoQGIQILIAJBAU4LBEADQCAFIAZB6ABsIgdqIAAoAowGIAdqQegAEBUaIAZBAWoiBiACRw0ACwsgACgCjAYiAgRAIAAtAJAGBEAgAgRAQez3AUHs9wEoAgBBAWo2AgAgAkGQ0gEoAgARAAALCyAAQQA2AowGCyAAIAU2AowGIAAgBDYCiAYgAEEBOgCQBiAAKAKEBiECCyAAKAKMBiACQegAbGoiAiABNgIEIAJBADYCACACQQhqIANB4AAQFRogACAAKAKEBkEBajYChAYgA0HgAGokAAu/AwEHfyMAQTBrIgMkACADQQA2AiggA0IANwMgIANCADcDGCADQgA3AxAgA0IANwMIIAEgACgC8AYoAgAgARshAQJAIAAoAvAFIgIgACgC9AVHDQAgAiACQQF0QQEgAhsiBk4NAAJ/IAYEQEHo9wFB6PcBKAIAQQFqNgIAIAZBLGxBEEGM0gEoAgARAwAhByAAKALwBSECCyACQQFOCwRAA0AgByAIQSxsIgRqIgUgACgC+AUgBGoiBCkCADcCACAFIAQoAig2AiggBSAEKQIgNwIgIAUgBCkCGDcCGCAFIAQpAhA3AhAgBSAEKQIINwIIIAhBAWoiCCACRw0ACwsgACgC+AUiAgRAIAAtAPwFBEAgAgRAQez3AUHs9wEoAgBBAWo2AgAgAkGQ0gEoAgARAAALCyAAQQA2AvgFCyAAIAc2AvgFIAAgBjYC9AUgAEEBOgD8BSAAKALwBSECCyAAKAL4BSACQSxsaiICIAE2AgQgAkEANgIAIAIgAykDCDcCCCACIAMpAxA3AhAgAiADKQMYNwIYIAIgAykDIDcCICACIAMoAig2AiggACAAKALwBUEBajYC8AUgA0EwaiQAC9gBAgR/AX0CQAJAIARFDQAgACgC3AUiBkEBSA0AIAAoAuQFIQdBACEEA0AgASAHIARBNGxqIgUoAggiCEZBACAFKAIMIAJGGw0CIAIgCEZBACAFKAIMIAFGGw0CIARBAWoiBCAGRw0ACwsgACADEPACIAAoAuQFIAAoAtwFQTRsaiIDQVhqIAI2AgAgA0FUaiABNgIAIANBXGogASoCCCACKgIIkyIJIAmUIAEqAgwgAioCDJMiCSAJlJIgASoCECACKgIQkyIJIAmUkpE4AgAgAEEBOgCcBwsL/AMBBn8CQCAAKALIBSICRQ0AIAAoAtAFIQUgAkEBSA0AA0AgACgC0AUgAUHoAGxqIgQoAmAiAwRAIAMgBDYCJAsgAUEBaiIBIAJHDQALCyAAKALcBSICQQFOBEBBACEBA0AgAUE0bCIEIAAoAuQFaiIDIAUgAygCCEHoAGxqNgIIIAAoAuQFIARqIgRBDGogBSAEKAIMQegAbGo2AgAgAUEBaiIBIAJHDQALCyAAKALwBSIEQQFOBEBBACECA0AgAkEsbCIBIAAoAvgFaiIDIAUgAygCCEHoAGxqNgIIIAAoAvgFIAFqIgNBDGogBSADKAIMQegAbGo2AgAgACgC+AUgAWoiA0EQaiAFIAMoAhBB6ABsajYCACAAKAL4BSABaiIBKAIoIgMEQCADIAE2AiQLIAJBAWoiAiAERw0ACwsgACgCmAYiAkEBTgRAIAAoAqAGIQRBACEBA0AgBCABQeAAbGoiAyAFIAMoAgBB6ABsajYCACABQQFqIgEgAkcNAAsLIAAoArQFIgZBAU4EQCAAKAK8BSECQQAhBANAQQAhASACIARBPGwiA2ooAhhBAEoEQANAIAIgA2ogAUECdGoiAkEcaiAFIAIoAhxB6ABsajYCACABQQFqIgEgACgCvAUiAiADaigCGEgNAAsLIARBAWoiBCAGRw0ACwsL+wMBBn8CQCAAKALIBSICRQRADAELIAAoAtAFIQUgAkEBSA0AA0AgACgC0AUgAUHoAGxqKAJgIgMEQCADIAE2AiQLIAFBAWoiASACRw0ACwsgACgC3AUiAkEBTgRAQQAhAQNAIAFBNGwiAyAAKALkBWoiBCAEKAIIIAVrQegAbTYCCCAAKALkBSADaiIDQQxqIAMoAgwgBWtB6ABtNgIAIAFBAWoiASACRw0ACwsgACgC8AUiA0EBTgRAQQAhAgNAIAJBLGwiASAAKAL4BWoiBCAEKAIIIAVrQegAbTYCCCAAKAL4BSABaiIEQQxqIAQoAgwgBWtB6ABtNgIAIAAoAvgFIAFqIgRBEGogBCgCECAFa0HoAG02AgAgACgC+AUgAWooAigiAQRAIAEgAjYCJAsgAkEBaiICIANHDQALCyAAKAKYBiICQQFOBEAgACgCoAYhA0EAIQEDQCADIAFB4ABsaiIEIAQoAgAgBWtB6ABtNgIAIAFBAWoiASACRw0ACwsgACgCtAUiBkEBTgRAIAAoArwFIQJBACEDA0BBACEBIAIgA0E8bCIEaigCGEEASgRAA0AgAiAEaiABQQJ0aiICQRxqIAIoAhwgBWtB6ABtNgIAIAFBAWoiASAAKAK8BSICIARqKAIYSA0ACwsgA0EBaiIDIAZHDQALCwunBgMGfwF+A30jAEHwAGsiBCQAIAAoAswFIAAoAsgFRgRAIAAQogUgACgCzAUgACgCyAVBAXRBAXIiBkgEQEHo9wFB6PcBKAIAQQFqNgIAIAZB6ABsQRBBjNIBKAIAEQMAIQcgACgCyAUiA0EBTgRAA0AgByAFQegAbCIIaiAAKALQBSAIakHoABAVGiAFQQFqIgUgA0cNAAsLIAAoAtAFIgMEQCAALQDUBQRAIAMEQEHs9wFB7PcBKAIAQQFqNgIAIANBkNIBKAIAEQAACwsgAEEANgLQBQsgACAHNgLQBSAAIAY2AswFIABBAToA1AULIAAQoQULIAAoAsABIgMgAygCACgCMBEGACEKIARBCGpBAEHkABALGgJAIAAoAsgFIgMgACgCzAVHDQAgAyADQQF0QQEgAxsiBk4NAAJAIAZFBEBBACEHDAELQej3AUHo9wEoAgBBAWo2AgAgBkHoAGxBEEGM0gEoAgARAwAhByAAKALIBSEDCyADQQFOBEBBACEFA0AgByAFQegAbCIIaiAAKALQBSAIakHoABAVGiAFQQFqIgUgA0cNAAsLIAAoAtAFIgMEQCAALQDUBQRAIAMEQEHs9wFB7PcBKAIAQQFqNgIAIANBkNIBKAIAEQAACwsgAEEANgLQBQsgACAHNgLQBSAAIAY2AswFIABBAToA1AUgACgCyAUhAwsgACgC0AUgA0HoAGxqIgNBADYCACADQQRqIARBCGpB5AAQFRogACAAKALIBSIDQQFqNgLIBSAAKALQBSADQegAbGpBAEHoABALIgMiBSABKQIINwIQIAMgASkCADcCCCABKQIAIQkgAyABKQIINwIgIAMgCTcCGCADQwAAgD8gApVDAAAAACACQwAAAABeGzgCWCADIAAoAvAGKAIANgIEIAMqAgghAiADKgIMIQsgBSoCECEMIARBADYCJCAEIAogDJI4AiAgBCAKIAuSOAIcIARBADYCFCAEIAogApI4AhggBCAMIAqTOAIQIAQgCyAKkzgCDCAEIAIgCpM4AgggAyAAQaAHaiAEQQhqIAMQQjYCYCAEQfAAaiQAC74BAQR/IAAoAvAFIgZBAUgEQEEADwsgACgC0AUiBCADQegAbGohAyAEIAJB6ABsaiECIAQgAUHoAGxqIQEgACgC+AUhB0EAIQACQANAAkACQCAHIABBLGxqIgQoAggiBSADRg0AIAEgBUYNACACIAVHDQELAkAgBCgCDCIFIANGDQAgASAFRg0AIAIgBUcNAQsgBCgCECIEIANGDQIgASAERg0CIAIgBEYNAgsgAEEBaiIAIAZHDQALQQAPC0EBC4YBAQR/IAAoAtwFIgRBAU4EQCAAKALQBSIDIAJB6ABsaiECIAMgAUHoAGxqIQEgACgC5AUhBUEAIQADQAJAIAUgAEE0bGoiAygCCCIGIAFHDQAgAygCDCACRw0AQQEPCwJAIAIgBkcNACADKAIMIAFHDQBBAQ8LIABBAWoiACAERw0ACwtBAAspACAAEPECIgAEQEHs9wFB7PcBKAIAQQFqNgIAIABBkNIBKAIAEQAACwsQAQF/QZwCEA0iABDYDSAAC/cKAQd/IAAoApQDIgEEQCAALQCYAwRAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgKUAwsgAEEANgKUAyAAQgA3AowDIABBAToAmAMgACgCqAMiAQRAIAAtAKwDBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AqgDCyAAQQA2AqgDIABCADcCoAMgAEEBOgCsAyAAKAK8AyIBBEAgAC0AwAMEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYCvAMLIABBADYCvAMgAEIANwK0AyAAQQE6AMADIAAiAiEHAkAgACgCoAMiACACKAKkAyIDRw0AIAAgAEEBdEEBIAAbIgNOBEAgACEDDAELIAMEQEHo9wFB6PcBKAIAQQFqNgIAIANBAnRBEEGM0gEoAgARAwAhBCACKAKgAyEACyACKAKoAyEBAkACQCAAQQFOBEADQCAEIAVBAnQiBmogASAGaigCADYCACAFQQFqIgUgAEcNAAwCAAsACyABRQ0BCyACLQCsAwRAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACyACKAKgAyEACyACQQA2AqgDCyACIAQ2AqgDIAJBAToArAMgAiADNgKkAwsgAigCqAMiASAAQQJ0akEBNgIAIAIgAEEBaiIFNgKgAwJAIAMgBUcEQCABIQAgAyEEIAUhAwwBCyADIANBAXRBASADGyIETgRAIAEhACADIQQMAQtBACEFQQAhAAJAAkACfyAEBEBB6PcBQej3ASgCAEEBajYCACAEQQJ0QRBBjNIBKAIAEQMAIQAgAigCoAMhAyACKAKoAyEBCyADQQFOCwRAA0AgACAFQQJ0IgZqIAEgBmooAgA2AgAgBUEBaiIFIANHDQAMAgALAAsgAUUNAQsgAi0ArAMEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsgAigCoAMhAwsgAkEANgKoAwsgAiAANgKoAyACQQE6AKwDIAIgBDYCpAMLIAAgA0ECdGpBAjYCACACIANBAWoiAzYCoAMCQCADIARHBEAgACEBIAQhBSADIQQMAQsgBCAEQQF0QQEgBBsiBU4EQCAAIQEgBCEFDAELQQAhA0EAIQEgBQRAQej3AUHo9wEoAgBBAWo2AgAgBUECdEEQQYzSASgCABEDACEBIAIoAqADIQQgAigCqAMhAAsCQAJAIARBAU4EQANAIAEgA0ECdCIGaiAAIAZqKAIANgIAIANBAWoiAyAERw0ADAIACwALIABFDQELIAItAKwDBEAgAARAQez3AUHs9wEoAgBBAWo2AgAgAEGQ0gEoAgARAAALIAIoAqADIQQLIAJBADYCqAMLIAIgATYCqAMgAkEBOgCsAyACIAU2AqQDCyABIARBAnRqQQM2AgAgAiAEQQFqIgA2AqADAkAgACAFRwRAIAEhBCAAIQUMAQsgBSAFQQF0QQEgBRsiAE4EQCABIQQMAQtBACEDQQAhBAJAAkACfyAABEBB6PcBQej3ASgCAEEBajYCACAAQQJ0QRBBjNIBKAIAEQMAIQQgAigCoAMhBSACKAKoAyEBCyAFQQFOCwRAA0AgBCADQQJ0IgZqIAEgBmooAgA2AgAgA0EBaiIDIAVHDQAMAgALAAsgAUUNAQsgAi0ArAMEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsgAigCoAMhBQsgAkEANgKoAwsgAiAENgKoAyACQQE6AKwDIAIgADYCpAMLIAQgBUECdGpBADYCACAHIAVBAWo2AqADC/EFAQJ/IABCgICAgICAgMA/NwKgAiAAQQg2AuwBIABBADsB2AMgAEIANwKoAiAAQgA3ArACIABBADYCuAIgAEEANgLcAyAAQQE2AoQDIABCgICAgMAANwL8AiAAQoCAgIAQNwL0AiAAQoCAgPyDgIDAPzcC7AIgAEKAgID4g4CAgD83AuQCIABCgICA+IOAgIA/NwLcAiAAQs2Zs+6DgIDAPzcC1AIgAEKAgID8s+bMmT83AswCIABCgICA/NOZs+Y9NwLEAiAAQs2Zs/IDNwK8AiAAQgA3ApAEIABCADcCiAQgAEIANwKcBCAAQYCAgPwDNgKYBCAAQgA3AqQEIABCADcCsAQgAEGAgID8AzYCrAQgAEIANwK4BCAAQYCAgPwDNgLIBCAAQoCAgPwDNwLABCAAQgA3AswEIABCADcC1AQgAEIANwLgBCAAQYCAgPwDNgLcBCAAQgA3AugEIABBAToAnAcgAEKAgID8AzcC8AQgAEEANgL4BiAAQQA2AqgFIABCADcClAcgAEIANwKMByAAQgA3AoQHIABCADcC/AYgAEIANwIQIABBgICA/AM2AgQgAEIANwIIIABCADcCJCAAQYCAgPwDNgIYIABCADcCHCAAQUBrQQA2AgAgAEGAgID8AzYCLCAAQgA3AjggAEIANwIwIAAQqAVB6PcBQej3ASgCAEEBajYCAEEUQRBBjNIBKAIAEQMAIgEiAkIjNwIEIAJBADYCDCACQaCbATYCACABIAA2AhAgAUEgNgIEIAFBuCc2AgAgACABNgLAASABQYCAgPQDNgIMIABBgAlqQgA3AgAgAEGAgID8AzYC/AggAEGICWpCADcCACAAQZQJakIANwIAIABBkAlqQYCAgPwDNgIAIABBnAlqQgA3AgAgAEGoCWpCADcCACAAQaQJakGAgID8AzYCACAAQbAJakIANwIAIABBuAlqQgA3AgAgAEHACWpCADcCACAAQcgJakKAgICAgICAwD83AgALJgAgASgCACIAQZwBIAAoAgAoAjgRAwAiACABIAIgA0EBEIIFIAALJgAgASgCACIAQZwBIAAoAgAoAjgRAwAiACABIAIgA0EAEIIFIAALRQAgASgCACICQRQgAigCACgCOBEDACIDIQIgAC0ABCEAIAJBhLMBNgIAIAIgASgCADYCBCACIAA6ABAgAkGALTYCACADCzcAIAEoAgAiAEEYIAAoAgAoAjgRAwAiACICIgNBhLMBNgIAIAMgASgCADYCBCACQdg1NgIAIAALLAEBfyMAQRBrIgEkACABIAA2AgxB3AAQEiIAIAEoAgwQxgIgAUEQaiQAIAALfQEBfwJAIAFBIEciAw0AIAJBIEcNACAAKAJcDwsCQAJAAkAgA0UEQCACQRNKDQEgACgCYA8LIAFBE0oNASACQSBHDQEgACgCZA8LIAJBa2pBCEsNASAAKAJoDwsgAUFrakEISw0AIAJBIEcNACAAKAJsDwsgACABIAIQwQQLuAIBAX8gAEGUHzYCACAAKAJcIgEgASgCACgCABEBABogACgCXCIBBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsgACgCYCIBIAEoAgAoAgARAQAaIAAoAmAiAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALIAAoAmQiASABKAIAKAIAEQEAGiAAKAJkIgEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACyAAKAJoIgEgASgCACgCABEBABogACgCaCIBBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsgACgCbCIBIAEoAgAoAgARAQAaIAAoAmwiAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALIAAQ4gEaIAAQDgu2AgEBfyAAQZQfNgIAIAAoAlwiASABKAIAKAIAEQEAGiAAKAJcIgEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACyAAKAJgIgEgASgCACgCABEBABogACgCYCIBBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsgACgCZCIBIAEoAgAoAgARAQAaIAAoAmQiAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALIAAoAmgiASABKAIAKAIAEQEAGiAAKAJoIgEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACyAAKAJsIgEgASgCACgCABEBABogACgCbCIBBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsgABDiARogAAsJACAAIAE2AggLBwAgACgCBAsJACAAIAE2AgQLXAEEfyAAKAIYIgNBAU4EQANAAkACQCAAKAIgIAJBAnRqKAIAIgQoAtgBQX5qIgVBA0sNACAFQQFrDgIAAAELIAQgARDzDyAAKAIYIQMLIAJBAWoiAiADSA0ACwsLCQAgASACENwPCwkAIAEgAhCHBQvAAgIGfwF+AkAgAiACKAIAKAIQEQEADQAgASgCyAUhBCACIAIoAgAoAiQRAQAhBQJAIAIgAigCACgCCBEBAEUNACACIAIoAgAoAhQRAQAhACACIAIoAgAoAhgRAQAhBiAEQQFIDQAgBSAAQQJ0aiEAIAEoAtAFIQcgBkECdCEGA0AgByADQegAbGoiCCkCCCEJIAAgCCgCEDYCCCAAIAk3AgAgACAGaiEAIANBAWoiAyAERw0ACwsgAiACKAIAKAIMEQEARQ0AIAIgAigCACgCHBEBACEAIAIgAigCACgCIBEBACECIARBAUgNACAFIABBAnRqIQAgASgC0AUhAUEAIQMgAkECdCECA0AgASADQegAbGoiBSkCSCEJIAAgBSgCUDYCCCAAIAk3AgAgACACaiEAIANBAWoiAyAERw0ACwsLWgEEfyAAKAIYIgNBAU4EQANAAkACQCAAKAIgIAJBAnRqKAIAIgQoAtgBQX5qIgVBA0sNACAFQQFrDgIAAAELIAQQ7w8gACgCGCEDCyACQQFqIgIgA0gNAAsLC1oBBH8gACgCGCIBQQFOBEADQAJAAkAgACgCICACQQJ0aigCACIDKALYAUF+aiIEQQNLDQAgBEEBaw4CAAABCyADEP0BIAAoAhghAQsgAkEBaiICIAFIDQALCwuxAgEFfyAAKAIYIgIgASgCBCIDSARAIAAoAhwgA0gEQCADBH9B6PcBQej3ASgCAEEBajYCACADQQJ0QRBBjNIBKAIAEQMAIQUgACgCGAUgAgsiBEEBTgRAA0AgBSAGQQJ0IgdqIAAoAiAgB2ooAgA2AgAgBkEBaiIGIARHDQALCyAAKAIgIgQEQCAALQAkBEAgBARAQez3AUHs9wEoAgBBAWo2AgAgBEGQ0gEoAgARAAALCyAAQQA2AiALIAAgBTYCICAAIAM2AhwgAEEBOgAkCwNAIAAoAiAgAkECdGpBADYCACACQQFqIgIgA0cNAAsLIAAgAzYCGCADQQFOBEAgACgCICEAQQAhAgNAIAAgAkECdCIEaiABKAIMIARqKAIANgIAIAJBAWoiAiADRw0ACwsLLgEDfyMAQSBrIgAkAEHcABASIQEgAEEIaiICEIECIAEgAhDGAiAAQSBqJAAgAQtHAQF/IABBiB42AgACQCAAKAIgIgFFDQAgAC0AJEUNACABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIAAQDgteAQF/IABBiB42AgAgACgCICIBBEAgAC0AJARAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgIgCyAAQQA2AiAgAEIANwIYIABBAToAJCAAC/kBAQF/IwBBIGsiAyQAIAMgADYCHCADIAE2AhggAyACNgIUIwBBEGsiASADKAIcIgA2AgwgAyABKAIMKAIENgIQAkAgAygCGCADKAIQSARAIAMgAygCGDYCDANAIAMoAgwgAygCEEgEQCADIAMoAgxBAWo2AgwMAQsLDAELIAMoAhgCfyMAQRBrIgEgADYCDCABKAIMKAIEC0oEQCAAIAMoAhgQpQMLIAMgAygCEDYCCANAIAMoAgggAygCGEgEQCAAKAIMIAMoAghB4ABsaiADKAIUEJACIAMgAygCCEEBajYCCAwBCwsLIAAgAygCGDYCBCADQSBqJAALVwEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAJBADYCBCACKAIIQegAbCEAQej3AUHo9wEoAgBBAWo2AgAgAEEQQYzSASgCABEDACEAIAJBEGokACAAC1EBAX8jAEEQayICJAAgAiAANgIIIAIgATYCBCACKAIIIQACQCACKAIEBEAgAiAAIAIoAgQQwAU2AgwMAQsgAkEANgIMCyACQRBqJAAgAigCDAs0AQF/IwBBEGsiASQAIAEgADYCDCMAQRBrIgAgASgCDDYCDCAAKAIMQQA2AgAgAUEQaiQAC7EBAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AggCfyMAQRBrIgEgAigCDCIANgIMIAEoAgwoAgggAigCCEgLBEAgAiAAIAIoAggQwQU2AgQgAAJ/IwBBEGsiASAANgIMIAEoAgwoAgQLIAIoAgQQ9gIgAAJ/IwBBEGsiASAANgIMIAEoAgwoAgQLEHIgABBQIABBAToAECAAIAIoAgQ2AgwgACACKAIINgIICyACQRBqJAAL/AEBAX8jAEEgayIDJAAgAyAANgIcIAMgATYCGCADIAI2AhQjAEEQayIBIAMoAhwiADYCDCADIAEoAgwoAgQ2AhACQCADKAIYIAMoAhBIBEAgAyADKAIYNgIMA0AgAygCDCADKAIQSARAIAMgAygCDEEBajYCDAwBCwsMAQsgAygCGAJ/IwBBEGsiASAANgIMIAEoAgwoAgQLSgRAIAAgAygCGBDDBQsgAyADKAIQNgIIA0AgAygCCCADKAIYSARAIAAoAgwgAygCCEHoAGxqIAMoAhRB6AAQFRogAyADKAIIQQFqNgIIDAELCwsgACADKAIYNgIEIANBIGokAAtnAQF/IwBBEGsiASQAIAEgADYCDCABKAIMIgAQwgUjAEEQayAAQQhqNgIMIwBBEGsgAEEYajYCDCMAQRBrIABBKGo2AgwjAEEQayAAQThqNgIMIwBBEGsgAEHIAGo2AgwgAUEQaiQAC1cBAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACQQA2AgQgAigCCEHgAGwhAEHo9wFB6PcBKAIAQQFqNgIAIABBEEGM0gEoAgARAwAhACACQRBqJAAgAAtRAQF/IwBBEGsiAiQAIAIgADYCCCACIAE2AgQgAigCCCEAAkAgAigCBARAIAIgACACKAIEEMYFNgIMDAELIAJBADYCDAsgAkEQaiQAIAIoAgwLVgEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAJBADYCBCACKAIIQSRsIQBB6PcBQej3ASgCAEEBajYCACAAQRBBjNIBKAIAEQMAIQAgAkEQaiQAIAALewEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIwBBEGsgAigCDCIANgIMIAAQvQEjAEEQayIBIAIoAgg2AgwgAiABKAIMKAIENgIEIAIoAgQhASACQQA2AgAgACABIAIQgAMgAigCCCACKAIEIAAoAgwQhQIgAkEQaiQAC1EBAX8jAEEQayICJAAgAiAANgIIIAIgATYCBCACKAIIIQACQCACKAIEBEAgAiAAIAIoAgQQyAU2AgwMAQsgAkEANgIMCyACQRBqJAAgAigCDAuJAgEBfyMAQSBrIgMkACADIAA2AhwgAyABNgIYIAMgAjYCFCMAQRBrIgEgAygCHCIANgIMIAMgASgCDCgCBDYCEAJAIAMoAhggAygCEEgEQCADIAMoAhg2AgwDQCADKAIMIAMoAhBIBEAgACgCDCADKAIMQSRsahCOASADIAMoAgxBAWo2AgwMAQsLDAELIAMoAhgCfyMAQRBrIgEgADYCDCABKAIMKAIEC0oEQCAAIAMoAhgQggILIAMgAygCEDYCCANAIAMoAgggAygCGEgEQCAAKAIMIAMoAghBJGxqIAMoAhQQ+gIgAyADKAIIQQFqNgIIDAELCwsgACADKAIYNgIEIANBIGokAAv7AQEBfyMAQSBrIgMkACADIAA2AhwgAyABNgIYIAMgAjYCFCMAQRBrIgEgAygCHCIANgIMIAMgASgCDCgCBDYCEAJAIAMoAhggAygCEEgEQCADIAMoAhg2AgwDQCADKAIMIAMoAhBIBEAgAyADKAIMQQFqNgIMDAELCwwBCyADKAIYAn8jAEEQayIBIAA2AgwgASgCDCgCBAtKBEAgACADKAIYEIcDCyADIAMoAhA2AggDQCADKAIIIAMoAhhIBEAgACgCDCADKAIIQQJ0aiADKAIUKgIAOAIAIAMgAygCCEEBajYCCAwBCwsLIAAgAygCGDYCBCADQSBqJAALowIBAX8jAEEgayIDJAAgAyAANgIcIAMgATYCGCADIAI2AhQjAEEQayIBIAMoAhwiADYCDCADIAEoAgwoAgQ2AhACQCADKAIYIAMoAhBIBEAgAyADKAIYNgIMA0AgAygCDCADKAIQSARAIAMgAygCDEEBajYCDAwBCwsMAQsgAygCGAJ/IwBBEGsiASAANgIMIAEoAgwoAgQLSgRAIAAgAygCGBCIAwsgAyADKAIQNgIIA0AgAygCCCADKAIYSARAIAAoAgwgAygCCEEEdGohAiMAQRBrIgFBEDYCDCABIAI2AgggASgCCCIBIAMoAhQiAikCADcCACABIAIpAgg3AgggAyADKAIIQQFqNgIIDAELCwsgACADKAIYNgIEIANBIGokAAu/AQEBfyMAQSBrIgMkACADIAE2AhwgAyACNgIYIwBBEGsiAiADKAIcIgE2AgwgAyACKAIMKgIAIAMoAhgqAgCUOAIUIwBBEGsiAiABNgIMIAMgAigCDEEEaioCACADKAIYKgIAlDgCECMAQRBrIgIgATYCDCADIAIoAgxBCGoqAgAgAygCGCoCAJQ4AgwgAyABKgIMIAMoAhgqAgCUOAIIIAAgA0EUaiADQRBqIANBDGogA0EIahC7ASADQSBqJAAL/gcCAX8BfSMAQSBrIgMkACADIAA2AhwgAyABNgIYIAMgAjYCFAJ9An8jAEEQayIBIAMoAhw2AgwjAEEQayIAIAEoAgwqAgg4AgwgACoCDItD8wQ1P14LBEAjAEEQayIAIAMoAhw2AgwgAyAAKAIMKgIEAn0jAEEQayIAIAMoAhw2AgwgACgCDCoCBAuUAn0jAEEQayIAIAMoAhw2AgwgACgCDCoCCAJ9IwBBEGsiACADKAIcNgIMIAAoAgwqAggLlAuSOAIQIwBBEGsiACADKgIQOAIMIANDAACAPyAAKgIMkZU4AgwjAEEQayIAIAMoAhg2AgwgACgCDEMAAAAAOAIAIwBBEGsiACADKAIcNgIMIAAoAgwqAgiMIAMqAgyUIQQjAEEQayIAIAMoAhg2AgwgACgCDCAEOAIEIwBBEGsiACADKAIcNgIMIAAoAgwqAgQgAyoCDJQhBCMAQRBrIgAgAygCGDYCDCAAKAIMIAQ4AgggAyoCECADKgIMlCEEIwBBEGsiACADKAIUNgIMIAAoAgwgBDgCACMAQRBrIgAgAygCHDYCDCAAKAIMKgIAjAJ9IwBBEGsiACADKAIYNgIMIAAoAgwqAggLlCEEIwBBEGsiACADKAIUNgIMIAAoAgwgBDgCBCMAQRBrIgAgAygCHDYCDCAAKAIMKgIAAn0jAEEQayIAIAMoAhg2AgwgACgCDCoCBAuUDAELIwBBEGsiACADKAIcNgIMIAMgACgCDCoCAAJ9IwBBEGsiACADKAIcNgIMIAAoAgwqAgALlAJ9IwBBEGsiACADKAIcNgIMIAAoAgwqAgQCfSMAQRBrIgAgAygCHDYCDCAAKAIMKgIEC5QLkjgCCCMAQRBrIgAgAyoCCDgCDCADQwAAgD8gACoCDJGVOAIEIwBBEGsiACADKAIcNgIMIAAoAgwqAgSMIAMqAgSUIQQjAEEQayIAIAMoAhg2AgwgACgCDCAEOAIAIwBBEGsiACADKAIcNgIMIAAoAgwqAgAgAyoCBJQhBCMAQRBrIgAgAygCGDYCDCAAKAIMIAQ4AgQjAEEQayIAIAMoAhg2AgwgACgCDEMAAAAAOAIIIwBBEGsiACADKAIcNgIMIAAoAgwqAgiMAn0jAEEQayIAIAMoAhg2AgwgACgCDCoCBAuUIQQjAEEQayIAIAMoAhQ2AgwgACgCDCAEOAIAIwBBEGsiACADKAIcNgIMIAAoAgwqAggCfSMAQRBrIgAgAygCGDYCDCAAKAIMKgIAC5QhBCMAQRBrIgAgAygCFDYCDCAAKAIMIAQ4AgQgAyoCCCADKgIElAshBCMAQRBrIgAgAygCFDYCDCAAKAIMIAQ4AgggA0EgaiQAC/YCAQV/IwBBkAJrIgUkACAFIAA2AowCIAUgATYCiAIgBSACOAKEAiAFIAM2AoACIAUgBDYC/AEgBSgCjAIhACAFQegBaiIBIAUoAogCIAVBhAJqECEjAEEQayAFQdgBaiIDNgIMIwBBEGsgBUHIAWoiBDYCDCAFKAKIAiADIAQQzwUgBUMAAMhCOALEASAFQaABaiIGIAMgBUHEAWoiBxAhIAVBsAFqIgggASAGEBQgBUGAAWoiBiADIAcQISAFQZABaiIDIAEgBhBIIAVB4ABqIgYgBCAHECEgBUHwAGoiCSABIAYQFCAFQUBrIgYgBCAHECEgBUHQAGoiBCABIAYQSCAFQTBqIgEgBSgCgAIgCBAXIAVBIGoiByAFKAKAAiADEBcgACABIAcgBSgC/AEgACgCACgCCBEEACAFQRBqIgEgBSgCgAIgCRAXIAUgBSgCgAIgBBAXIAAgASAFIAUoAvwBIAAoAgAoAggRBAAgBUGQAmokAAvCDgEFfyMAQfAFayIGJAAgBiAANgLsBSAGIAE4AugFIAYgAjgC5AUgBiADNgLgBSAGIAQ2AtwFIAYgBTYC2AUgBigC7AUhACAGQR42AtQFIwBBEGsiAyAGKALcBTYCDCAGIAMoAgxBMGoiAykCADcCwAUgBiADKQIINwLIBSAGQwAAAAA4AqwFIAZDAAAAADgCqAUgBkMAAAAAOAKkBSAGQbAFaiIDIAZBrAVqIAZBqAVqIAZBpAVqEAkgBiAGKgLkBUMAAAA/lDgCoAUgBioCoAUhASMAQRBrIgQgAzYCDCAEKAIMIAYoAuAFQQJ0aiABOAIAIAZDAAAAADgCjAUgBkMAAAAAOAKIBSAGQwAAAAA4AoQFIAZBkAVqIgMgBkGMBWogBkGIBWogBkGEBWoQCSAGKgLoBSEBIwBBEGsiBCADNgIMIAQoAgwgBigC4AVBAWpBA29BAnRqIAE4AgAgBkMAAAAAOALsBCAGQwAAAAA4AugEIAZDAAAAADgC5AQgBkHwBGoiAyAGQewEaiAGQegEaiAGQeQEahAJIAYqAugFIQEjAEEQayIEIAM2AgwgBCgCDCAGKALgBUECakEDb0ECdGogATgCACAGQwAAAAA4AswEIAZDAAAAADgCyAQgBkMAAAAAOALEBCAGQdAEaiIDIAZBzARqIAZByARqIAZBxARqEAkgBioCoAWMIQEjAEEQayIEIAM2AgwgBCgCDCAGKALgBUECdGogATgCACAGQQA2AsAEA0AgBigCwARB6AJIBEAgBigCwASyQzX6jjyUECggBioC6AWUIQEjAEEQayIEIAZB0ARqIgM2AgwgBCgCDCAGKALgBUEBakEDb0ECdGogATgCACAGKALABLJDNfqOPJQQKSAGKgLoBZQhASMAQRBrIgQgAzYCDCAEKAIMIAYoAuAFQQJqQQNvQQJ0aiABOAIAIAZBoARqIgQCfyMAQRBrIgUgBigC3AU2AgwgBSgCDAsgBkGwBWoQESAGQbAEaiIFIAZBwAVqIgcgBBAUIAZBgARqIgQCfyMAQRBrIgggBigC3AU2AgwgCCgCDAsgAxARIAZBkARqIgMgByAEEBQgACAFIAMgBigC2AUgACgCACgCCBEEACAGIAYoAtQFIAYoAsAEajYCwAQMAQsLIAZB4ANqIgUCfyMAQRBrIgMgBigC3AU2AgwgAygCDAsgBkGwBWoiAxARIAZB8ANqIgcgBkHABWoiBCAFEBQjAEEQayIFIAYoAtwFNgIMIAUoAgwhBSAGQaADaiIIIAMQWyAGQbADaiIJIAggBkGQBWoiCBAUIAZBwANqIgogBSAJEBEgBkHQA2oiBSAEIAoQFCAAIAcgBSAGKALYBSAAKAIAKAIIEQQAIAZBgANqIgUCfyMAQRBrIgcgBigC3AU2AgwgBygCDAsgAxARIAZBkANqIgcgBCAFEBQjAEEQayIFIAYoAtwFNgIMIAUoAgwhBSAGQcACaiIJIAMQWyAGQdACaiIKIAkgCBBIIAZB4AJqIgggBSAKEBEgBkHwAmoiBSAEIAgQFCAAIAcgBSAGKALYBSAAKAIAKAIIEQQAIAZBoAJqIgUCfyMAQRBrIgcgBigC3AU2AgwgBygCDAsgAxARIAZBsAJqIgcgBCAFEBQjAEEQayIFIAYoAtwFNgIMIAUoAgwhBSAGQeABaiIIIAMQWyAGQfABaiIJIAggBkHwBGoiCBAUIAZBgAJqIgogBSAJEBEgBkGQAmoiBSAEIAoQFCAAIAcgBSAGKALYBSAAKAIAKAIIEQQAIAZBwAFqIgUCfyMAQRBrIgcgBigC3AU2AgwgBygCDAsgAxARIAZB0AFqIgcgBCAFEBQjAEEQayIFIAYoAtwFNgIMIAUoAgwhBSAGQYABaiIJIAMQWyAGQZABaiIKIAkgCBBIIAZBoAFqIgggBSAKEBEgBkGwAWoiBSAEIAgQFCAAIAcgBSAGKALYBSAAKAIAKAIIEQQAIAZDAAAAADgCbCAGQwAAAAA4AmggBkMAAAAAOAJkIAZB8ABqIgUgBkHsAGogBkHoAGogBkHkAGoQCSMAQRBrIgcgBTYCDCAHKAIMIAYoAuAFQQJ0akMAAIA/OAIAIAZDAAAAADgCTCAGQwAAAAA4AkggBkMAAAAAOAJEIAZB0ABqIgcgBkHMAGogBkHIAGogBkHEAGoQCSMAQRBrIgggBzYCDCAIKAIMIAYoAuAFQQFqQQNvQQJ0akMAAIA/OAIAIAZBIGoiCAJ/IwBBEGsiCSAGKALcBTYCDCAJKAIMCyADEBEgBkEwaiIDIAQgCBBIIAZBEGoiBAJ/IwBBEGsiCCAGKALcBTYCDCAIKAIMCyAFEBEgBgJ/IwBBEGsiBSAGKALcBTYCDCAFKAIMCyAHEBEgACADIAQgBiAGKgLoBSAGKgLoBUMAAAAAQ9sPyUAgBigC2AVBAEMAACBBIAAoAgAoAjwRGQAgBkHwBWokAAvkCgEGfyMAQZADayIGJAAgBiAANgKMAyAGIAE4AogDIAYgAjgChAMgBiADNgKAAyAGIAQ2AvwCIAYgBTYC+AIgBigCjAMhACMAQRBrIgMgBigC/AI2AgwgBiADKAIMQTBqIgMpAgA3AugCIAYgAykCCDcC8AIgBkMAAAAAOALUAiAGQwAAAAA4AtACIAZDAAAAADgCzAIgBkHYAmoiAyAGQdQCaiAGQdACaiAGQcwCahAJIAYqAoQDIQEjAEEQayIEIAM2AgwgBCgCDCAGKAKAA0ECdGogATgCACAGQR42AsgCIAZDAAAAADgCtAIgBkMAAAAAOAKwAiAGQwAAAAA4AqwCIAZBuAJqIgMgBkG0AmogBkGwAmogBkGsAmoQCSAGKgKEA4whASMAQRBrIgQgAzYCDCAEKAIMIAYoAoADQQJ0aiABOAIAIAZDAAAAADgClAIgBkMAAAAAOAKQAiAGQwAAAAA4AowCIAZBmAJqIgMgBkGUAmogBkGQAmogBkGMAmoQCSAGKgKEAyEBIwBBEGsiBCADNgIMIAQoAgwgBigCgANBAnRqIAE4AgAgBkEANgKIAgNAIAYoAogCQegCSARAIAYoAogCskM1+o48lBAoIAYqAogDlCEBIwBBEGsiBCAGQbgCaiIDNgIMIAQoAgwgBigCgANBAWpBA29BAnRqIAE4AgAjAEEQayIFIAZBmAJqIgQ2AgwgBSgCDCAGKAKAA0EBakEDb0ECdGogATgCACAGKAKIArJDNfqOPJQQKSAGKgKIA5QhASMAQRBrIgUgAzYCDCAFKAIMIAYoAoADQQJqQQNvQQJ0aiABOAIAIwBBEGsiBSAENgIMIAUoAgwgBigCgANBAmpBA29BAnRqIAE4AgAgBkHoAWoiBQJ/IwBBEGsiByAGKAL8AjYCDCAHKAIMCyADEBEgBkH4AWoiAyAGQegCaiIHIAUQFCAGQcgBaiIFAn8jAEEQayIIIAYoAvwCNgIMIAgoAgwLIAQQESAGQdgBaiIEIAcgBRAUIAAgAyAEIAYoAvgCIAAoAgAoAggRBAAgBiAGKALIAiAGKAKIAmo2AogCDAELCyAGQwAAAAA4ArQBIAZDAAAAADgCsAEgBkMAAAAAOAKsASAGQbgBaiIDIAZBtAFqIAZBsAFqIAZBrAFqEAkjAEEQayIEIAM2AgwgBCgCDCAGKAKAA0ECdGpDAACAPzgCACAGQwAAAAA4ApQBIAZDAAAAADgCkAEgBkMAAAAAOAKMASAGQZgBaiIEIAZBlAFqIAZBkAFqIAZBjAFqEAkjAEEQayIFIAQ2AgwgBSgCDCAGKAKAA0EBakEDb0ECdGpDAACAPzgCACAGQegAaiIFAn8jAEEQayIHIAYoAvwCNgIMIAcoAgwLIAZB2AJqIgcQESAGQfgAaiIIIAZB6AJqIgogBRBIIAZB2ABqIgUCfyMAQRBrIgkgBigC/AI2AgwgCSgCDAsgAxARIAZByABqIgkCfyMAQRBrIgsgBigC/AI2AgwgCygCDAsgBBARIAAgCCAFIAkgBioCiAMgBioCiANDAAAAAEPbD8lAIAYoAvgCQQBDAAAgQSAAKAIAKAI8ERkAIAZBKGoiBQJ/IwBBEGsiCCAGKAL8AjYCDCAIKAIMCyAHEBEgBkE4aiIHIAogBRAUIAZBGGoiBQJ/IwBBEGsiCCAGKAL8AjYCDCAIKAIMCyADEBEgBkEIaiIDAn8jAEEQayIIIAYoAvwCNgIMIAgoAgwLIAQQESAAIAcgBSADIAYqAogDIAYqAogDQwAAAABD2w/JQCAGKAL4AkEAQwAAIEEgACgCACgCPBEZACAGQZADaiQAC68KAQR/IwBB8ANrIgYkACAGIAA2AuwDIAYgATgC6AMgBiACOALkAyAGIAM2AuADIAYgBDYC3AMgBiAFNgLYAyAGKALsAyEAIAZBHjYC1AMgBkMAAAAAOAK8AyAGQwAAAAA4ArgDIAZDAAAAADgCtAMgBkHAA2oiBCAGQbwDaiAGQbgDaiAGQbQDahAJIAYqAuQDjCEBIwBBEGsiAyAENgIMIAMoAgwgBigC4ANBAnRqIAE4AgAgBkMAAAAAOAKcAyAGQwAAAAA4ApgDIAZDAAAAADgClAMgBkGgA2oiBSAGQZwDaiAGQZgDaiAGQZQDahAJIAYqAuQDIQEjAEEQayIDIAU2AgwgAygCDCAGKALgA0ECdGogATgCACAGQdACaiIDIAYoAtwDEIoBIAZBwAJqIAYoAtwDIAQQFyMAQRBrIgQgAzYCDCAEKAIMQTBqIgQgBikCwAI3AgAgBCAGKQLIAjcCCCMAQRBrIgcgAzYCDCAGQbACaiIEIAcoAgxBMGoiBykCADcCACAEIAcpAgg3AgggBkGgAmoiBwJ/IwBBEGsiCCADNgIMIAgoAgwLIAYoAuADQQFqQQNvEGwgBkGAAmoiCAJ/IwBBEGsiCSADNgIMIAkoAgwLIAYoAuADEGwgBkGQAmoiAyAIEFsgBkPbD8m/OAL8ASAGQ9sPyT84AvgBIAZD2w/JvzgC9AEgBkPbD8k/OALwASAAIAQgByADIAYqAugDIAYqAvwBIAYqAvgBIAYqAvQBIAYqAvABIAYoAtgDIAYoAtQDskEAIAAoAgAoAkARHgAgBkGwAWoiAyAGKALcAxCKASAGQaABaiAGKALcAyAFEBcjAEEQayIEIAM2AgwgBCgCDEEwaiIEIAYpAqABNwIAIAQgBikCqAE3AggjAEEQayIFIAM2AgwgBkGQAWoiBCAFKAIMQTBqIgUpAgA3AgAgBCAFKQIINwIIIAZBgAFqIgUCfyMAQRBrIgcgAzYCDCAHKAIMCyAGKALgA0EBakEDbxBsIAZB8ABqIgcCfyMAQRBrIgggAzYCDCAIKAIMCyAGKALgAxBsIAZD2w/JvzgCbCAGQ9sPyT84AmggBkPbD8m/OAJkIAZD2w/JPzgCYCAAIAQgBSAHIAYqAugDIAYqAmwgBioCaCAGKgJkIAYqAmAgBigC2AMgBigC1AOyQQAgACgCACgCQBEeACMAQRBrIgMgBigC3AM2AgwgBiADKAIMQTBqIgMpAgA3AlAgBiADKQIINwJYIAZBADYCTANAIAYoAkxB6AJIBEAgBigCTLJDNfqOPJQQKCAGKgLoA5QhASMAQRBrIgQgBkHAA2oiAzYCDCAEKAIMIAYoAuADQQFqQQNvQQJ0aiABOAIAIwBBEGsiBSAGQaADaiIENgIMIAUoAgwgBigC4ANBAWpBA29BAnRqIAE4AgAgBigCTLJDNfqOPJQQKSAGKgLoA5QhASMAQRBrIgUgAzYCDCAFKAIMIAYoAuADQQJqQQNvQQJ0aiABOAIAIwBBEGsiBSAENgIMIAUoAgwgBigC4ANBAmpBA29BAnRqIAE4AgAgBkEoaiIFAn8jAEEQayIHIAYoAtwDNgIMIAcoAgwLIAMQESAGQThqIgMgBkHQAGoiByAFEBQgBkEIaiIFAn8jAEEQayIIIAYoAtwDNgIMIAgoAgwLIAQQESAGQRhqIgQgByAFEBQgACADIAQgBigC2AMgACgCACgCCBEEACAGIAYoAtQDIAYoAkxqNgJMDAELCyAGQfADaiQAC6YXAQF/IwBBoAZrIgUkACAFIAA2ApwGIAUgATYCmAYgBSACNgKUBiAFIAM2ApAGIAUgBDYCjAYgBSgCnAYhACAFKAKQBiEBIAVB6AVqIgICfyMAQRBrIgMgBSgCmAY2AgwgAygCDAsCfyMAQRBrIgMgBSgCmAY2AgwgAygCDEEEagsCfyMAQRBrIgMgBSgCmAY2AgwgAygCDEEIagsQCSAFQfgFaiIDIAEgAhAXIAUoApAGIQEgBUHIBWoiAgJ/IwBBEGsiBCAFKAKUBjYCDCAEKAIMCwJ/IwBBEGsiBCAFKAKYBjYCDCAEKAIMQQRqCwJ/IwBBEGsiBCAFKAKYBjYCDCAEKAIMQQhqCxAJIAVB2AVqIgQgASACEBcgACADIAQgBSgCjAYgACgCACgCCBEEACAFKAKQBiEBIAVBqAVqIgICfyMAQRBrIgMgBSgClAY2AgwgAygCDAsCfyMAQRBrIgMgBSgCmAY2AgwgAygCDEEEagsCfyMAQRBrIgMgBSgCmAY2AgwgAygCDEEIagsQCSAFQbgFaiIDIAEgAhAXIAUoApAGIQEgBUGIBWoiAgJ/IwBBEGsiBCAFKAKUBjYCDCAEKAIMCwJ/IwBBEGsiBCAFKAKUBjYCDCAEKAIMQQRqCwJ/IwBBEGsiBCAFKAKYBjYCDCAEKAIMQQhqCxAJIAVBmAVqIgQgASACEBcgACADIAQgBSgCjAYgACgCACgCCBEEACAFKAKQBiEBIAVB6ARqIgICfyMAQRBrIgMgBSgClAY2AgwgAygCDAsCfyMAQRBrIgMgBSgClAY2AgwgAygCDEEEagsCfyMAQRBrIgMgBSgCmAY2AgwgAygCDEEIagsQCSAFQfgEaiIDIAEgAhAXIAUoApAGIQEgBUHIBGoiAgJ/IwBBEGsiBCAFKAKYBjYCDCAEKAIMCwJ/IwBBEGsiBCAFKAKUBjYCDCAEKAIMQQRqCwJ/IwBBEGsiBCAFKAKYBjYCDCAEKAIMQQhqCxAJIAVB2ARqIgQgASACEBcgACADIAQgBSgCjAYgACgCACgCCBEEACAFKAKQBiEBIAVBqARqIgICfyMAQRBrIgMgBSgCmAY2AgwgAygCDAsCfyMAQRBrIgMgBSgClAY2AgwgAygCDEEEagsCfyMAQRBrIgMgBSgCmAY2AgwgAygCDEEIagsQCSAFQbgEaiIDIAEgAhAXIAUoApAGIQEgBUGIBGoiAgJ/IwBBEGsiBCAFKAKYBjYCDCAEKAIMCwJ/IwBBEGsiBCAFKAKYBjYCDCAEKAIMQQRqCwJ/IwBBEGsiBCAFKAKYBjYCDCAEKAIMQQhqCxAJIAVBmARqIgQgASACEBcgACADIAQgBSgCjAYgACgCACgCCBEEACAFKAKQBiEBIAVB6ANqIgICfyMAQRBrIgMgBSgCmAY2AgwgAygCDAsCfyMAQRBrIgMgBSgCmAY2AgwgAygCDEEEagsCfyMAQRBrIgMgBSgCmAY2AgwgAygCDEEIagsQCSAFQfgDaiIDIAEgAhAXIAUoApAGIQEgBUHIA2oiAgJ/IwBBEGsiBCAFKAKYBjYCDCAEKAIMCwJ/IwBBEGsiBCAFKAKYBjYCDCAEKAIMQQRqCwJ/IwBBEGsiBCAFKAKUBjYCDCAEKAIMQQhqCxAJIAVB2ANqIgQgASACEBcgACADIAQgBSgCjAYgACgCACgCCBEEACAFKAKQBiEBIAVBqANqIgICfyMAQRBrIgMgBSgClAY2AgwgAygCDAsCfyMAQRBrIgMgBSgCmAY2AgwgAygCDEEEagsCfyMAQRBrIgMgBSgCmAY2AgwgAygCDEEIagsQCSAFQbgDaiIDIAEgAhAXIAUoApAGIQEgBUGIA2oiAgJ/IwBBEGsiBCAFKAKUBjYCDCAEKAIMCwJ/IwBBEGsiBCAFKAKYBjYCDCAEKAIMQQRqCwJ/IwBBEGsiBCAFKAKUBjYCDCAEKAIMQQhqCxAJIAVBmANqIgQgASACEBcgACADIAQgBSgCjAYgACgCACgCCBEEACAFKAKQBiEBIAVB6AJqIgICfyMAQRBrIgMgBSgClAY2AgwgAygCDAsCfyMAQRBrIgMgBSgClAY2AgwgAygCDEEEagsCfyMAQRBrIgMgBSgCmAY2AgwgAygCDEEIagsQCSAFQfgCaiIDIAEgAhAXIAUoApAGIQEgBUHIAmoiAgJ/IwBBEGsiBCAFKAKUBjYCDCAEKAIMCwJ/IwBBEGsiBCAFKAKUBjYCDCAEKAIMQQRqCwJ/IwBBEGsiBCAFKAKUBjYCDCAEKAIMQQhqCxAJIAVB2AJqIgQgASACEBcgACADIAQgBSgCjAYgACgCACgCCBEEACAFKAKQBiEBIAVBqAJqIgICfyMAQRBrIgMgBSgCmAY2AgwgAygCDAsCfyMAQRBrIgMgBSgClAY2AgwgAygCDEEEagsCfyMAQRBrIgMgBSgCmAY2AgwgAygCDEEIagsQCSAFQbgCaiIDIAEgAhAXIAUoApAGIQEgBUGIAmoiAgJ/IwBBEGsiBCAFKAKYBjYCDCAEKAIMCwJ/IwBBEGsiBCAFKAKUBjYCDCAEKAIMQQRqCwJ/IwBBEGsiBCAFKAKUBjYCDCAEKAIMQQhqCxAJIAVBmAJqIgQgASACEBcgACADIAQgBSgCjAYgACgCACgCCBEEACAFKAKQBiEBIAVB6AFqIgICfyMAQRBrIgMgBSgCmAY2AgwgAygCDAsCfyMAQRBrIgMgBSgCmAY2AgwgAygCDEEEagsCfyMAQRBrIgMgBSgClAY2AgwgAygCDEEIagsQCSAFQfgBaiIDIAEgAhAXIAUoApAGIQEgBUHIAWoiAgJ/IwBBEGsiBCAFKAKUBjYCDCAEKAIMCwJ/IwBBEGsiBCAFKAKYBjYCDCAEKAIMQQRqCwJ/IwBBEGsiBCAFKAKUBjYCDCAEKAIMQQhqCxAJIAVB2AFqIgQgASACEBcgACADIAQgBSgCjAYgACgCACgCCBEEACAFKAKQBiEBIAVBqAFqIgICfyMAQRBrIgMgBSgClAY2AgwgAygCDAsCfyMAQRBrIgMgBSgCmAY2AgwgAygCDEEEagsCfyMAQRBrIgMgBSgClAY2AgwgAygCDEEIagsQCSAFQbgBaiIDIAEgAhAXIAUoApAGIQEgBUGIAWoiAgJ/IwBBEGsiBCAFKAKUBjYCDCAEKAIMCwJ/IwBBEGsiBCAFKAKUBjYCDCAEKAIMQQRqCwJ/IwBBEGsiBCAFKAKUBjYCDCAEKAIMQQhqCxAJIAVBmAFqIgQgASACEBcgACADIAQgBSgCjAYgACgCACgCCBEEACAFKAKQBiEBIAVB6ABqIgICfyMAQRBrIgMgBSgClAY2AgwgAygCDAsCfyMAQRBrIgMgBSgClAY2AgwgAygCDEEEagsCfyMAQRBrIgMgBSgClAY2AgwgAygCDEEIagsQCSAFQfgAaiIDIAEgAhAXIAUoApAGIQEgBUHIAGoiAgJ/IwBBEGsiBCAFKAKYBjYCDCAEKAIMCwJ/IwBBEGsiBCAFKAKUBjYCDCAEKAIMQQRqCwJ/IwBBEGsiBCAFKAKUBjYCDCAEKAIMQQhqCxAJIAVB2ABqIgQgASACEBcgACADIAQgBSgCjAYgACgCACgCCBEEACAFKAKQBiEBIAVBKGoiAgJ/IwBBEGsiAyAFKAKYBjYCDCADKAIMCwJ/IwBBEGsiAyAFKAKUBjYCDCADKAIMQQRqCwJ/IwBBEGsiAyAFKAKUBjYCDCADKAIMQQhqCxAJIAVBOGoiAyABIAIQFyAFKAKQBiEBIAVBCGoiAgJ/IwBBEGsiBCAFKAKYBjYCDCAEKAIMCwJ/IwBBEGsiBCAFKAKYBjYCDCAEKAIMQQRqCwJ/IwBBEGsiBCAFKAKUBjYCDCAEKAIMQQhqCxAJIAVBGGoiBCABIAIQFyAAIAMgBCAFKAKMBiAAKAIAKAIIEQQAIAVBoAZqJAALiBMBAX8jAEGQA2siBCQAIAQgADYCjAMgBCABNgKIAyAEIAI2AoQDIAQgAzYCgAMgBCgCjAMhACAEQfACaiIBAn8jAEEQayICIAQoAogDNgIMIAIoAgwLAn8jAEEQayICIAQoAogDNgIMIAIoAgxBBGoLAn8jAEEQayICIAQoAogDNgIMIAIoAgxBCGoLEAkgBEHgAmoiAgJ/IwBBEGsiAyAEKAKEAzYCDCADKAIMCwJ/IwBBEGsiAyAEKAKIAzYCDCADKAIMQQRqCwJ/IwBBEGsiAyAEKAKIAzYCDCADKAIMQQhqCxAJIAAgASACIAQoAoADIAAoAgAoAggRBAAgBEHQAmoiAQJ/IwBBEGsiAiAEKAKEAzYCDCACKAIMCwJ/IwBBEGsiAiAEKAKIAzYCDCACKAIMQQRqCwJ/IwBBEGsiAiAEKAKIAzYCDCACKAIMQQhqCxAJIARBwAJqIgICfyMAQRBrIgMgBCgChAM2AgwgAygCDAsCfyMAQRBrIgMgBCgChAM2AgwgAygCDEEEagsCfyMAQRBrIgMgBCgCiAM2AgwgAygCDEEIagsQCSAAIAEgAiAEKAKAAyAAKAIAKAIIEQQAIARBsAJqIgECfyMAQRBrIgIgBCgChAM2AgwgAigCDAsCfyMAQRBrIgIgBCgChAM2AgwgAigCDEEEagsCfyMAQRBrIgIgBCgCiAM2AgwgAigCDEEIagsQCSAEQaACaiICAn8jAEEQayIDIAQoAogDNgIMIAMoAgwLAn8jAEEQayIDIAQoAoQDNgIMIAMoAgxBBGoLAn8jAEEQayIDIAQoAogDNgIMIAMoAgxBCGoLEAkgACABIAIgBCgCgAMgACgCACgCCBEEACAEQZACaiIBAn8jAEEQayICIAQoAogDNgIMIAIoAgwLAn8jAEEQayICIAQoAoQDNgIMIAIoAgxBBGoLAn8jAEEQayICIAQoAogDNgIMIAIoAgxBCGoLEAkgBEGAAmoiAgJ/IwBBEGsiAyAEKAKIAzYCDCADKAIMCwJ/IwBBEGsiAyAEKAKIAzYCDCADKAIMQQRqCwJ/IwBBEGsiAyAEKAKIAzYCDCADKAIMQQhqCxAJIAAgASACIAQoAoADIAAoAgAoAggRBAAgBEHwAWoiAQJ/IwBBEGsiAiAEKAKIAzYCDCACKAIMCwJ/IwBBEGsiAiAEKAKIAzYCDCACKAIMQQRqCwJ/IwBBEGsiAiAEKAKIAzYCDCACKAIMQQhqCxAJIARB4AFqIgICfyMAQRBrIgMgBCgCiAM2AgwgAygCDAsCfyMAQRBrIgMgBCgCiAM2AgwgAygCDEEEagsCfyMAQRBrIgMgBCgChAM2AgwgAygCDEEIagsQCSAAIAEgAiAEKAKAAyAAKAIAKAIIEQQAIARB0AFqIgECfyMAQRBrIgIgBCgChAM2AgwgAigCDAsCfyMAQRBrIgIgBCgCiAM2AgwgAigCDEEEagsCfyMAQRBrIgIgBCgCiAM2AgwgAigCDEEIagsQCSAEQcABaiICAn8jAEEQayIDIAQoAoQDNgIMIAMoAgwLAn8jAEEQayIDIAQoAogDNgIMIAMoAgxBBGoLAn8jAEEQayIDIAQoAoQDNgIMIAMoAgxBCGoLEAkgACABIAIgBCgCgAMgACgCACgCCBEEACAEQbABaiIBAn8jAEEQayICIAQoAoQDNgIMIAIoAgwLAn8jAEEQayICIAQoAoQDNgIMIAIoAgxBBGoLAn8jAEEQayICIAQoAogDNgIMIAIoAgxBCGoLEAkgBEGgAWoiAgJ/IwBBEGsiAyAEKAKEAzYCDCADKAIMCwJ/IwBBEGsiAyAEKAKEAzYCDCADKAIMQQRqCwJ/IwBBEGsiAyAEKAKEAzYCDCADKAIMQQhqCxAJIAAgASACIAQoAoADIAAoAgAoAggRBAAgBEGQAWoiAQJ/IwBBEGsiAiAEKAKIAzYCDCACKAIMCwJ/IwBBEGsiAiAEKAKEAzYCDCACKAIMQQRqCwJ/IwBBEGsiAiAEKAKIAzYCDCACKAIMQQhqCxAJIARBgAFqIgICfyMAQRBrIgMgBCgCiAM2AgwgAygCDAsCfyMAQRBrIgMgBCgChAM2AgwgAygCDEEEagsCfyMAQRBrIgMgBCgChAM2AgwgAygCDEEIagsQCSAAIAEgAiAEKAKAAyAAKAIAKAIIEQQAIARB8ABqIgECfyMAQRBrIgIgBCgCiAM2AgwgAigCDAsCfyMAQRBrIgIgBCgCiAM2AgwgAigCDEEEagsCfyMAQRBrIgIgBCgChAM2AgwgAigCDEEIagsQCSAEQeAAaiICAn8jAEEQayIDIAQoAoQDNgIMIAMoAgwLAn8jAEEQayIDIAQoAogDNgIMIAMoAgxBBGoLAn8jAEEQayIDIAQoAoQDNgIMIAMoAgxBCGoLEAkgACABIAIgBCgCgAMgACgCACgCCBEEACAEQdAAaiIBAn8jAEEQayICIAQoAoQDNgIMIAIoAgwLAn8jAEEQayICIAQoAogDNgIMIAIoAgxBBGoLAn8jAEEQayICIAQoAoQDNgIMIAIoAgxBCGoLEAkgBEFAayICAn8jAEEQayIDIAQoAoQDNgIMIAMoAgwLAn8jAEEQayIDIAQoAoQDNgIMIAMoAgxBBGoLAn8jAEEQayIDIAQoAoQDNgIMIAMoAgxBCGoLEAkgACABIAIgBCgCgAMgACgCACgCCBEEACAEQTBqIgECfyMAQRBrIgIgBCgChAM2AgwgAigCDAsCfyMAQRBrIgIgBCgChAM2AgwgAigCDEEEagsCfyMAQRBrIgIgBCgChAM2AgwgAigCDEEIagsQCSAEQSBqIgICfyMAQRBrIgMgBCgCiAM2AgwgAygCDAsCfyMAQRBrIgMgBCgChAM2AgwgAygCDEEEagsCfyMAQRBrIgMgBCgChAM2AgwgAygCDEEIagsQCSAAIAEgAiAEKAKAAyAAKAIAKAIIEQQAIARBEGoiAQJ/IwBBEGsiAiAEKAKIAzYCDCACKAIMCwJ/IwBBEGsiAiAEKAKEAzYCDCACKAIMQQRqCwJ/IwBBEGsiAiAEKAKEAzYCDCACKAIMQQhqCxAJIAQCfyMAQRBrIgIgBCgCiAM2AgwgAigCDAsCfyMAQRBrIgIgBCgCiAM2AgwgAigCDEEEagsCfyMAQRBrIgIgBCgChAM2AgwgAigCDEEIagsQCSAAIAEgBCAEKAKAAyAAKAIAKAIIEQQAIARBkANqJAAL/g0BAX8jAEGgFWsiDCQAIAwgADYCnBUgDCABNgKYFSAMIAI2ApQVIAwgAzYCkBUgDCAEOAKMFSAMIAU4AogVIAwgBjgChBUgDCAHOAKAFSAMIAg4AvwUIAwgCTYC+BQgDCAKOAL0FCAMIAs6APMUIAwoApwVIQEgDEHQC2oiAEGgCWohAgNAIwBBEGsgADYCDCAAQRBqIgMhACACIANHDQALIAxBsAJqIgBBoAlqIQIDQCMAQRBrIAA2AgwgAEEQaiIDIQAgAiADRw0ACyAMIAxB0AtqNgKsAiAMIAxBsAJqNgKoAiAMKAKYFSEAIAxBgAJqIgIgDCgClBUgDEGMFWoiAxAhIAxBkAJqIAAgAhAUIAwoApgVIQAgDEHgAWoiAiAMKAKUFSADECEgDEHwAWogACACEEgjAEEQayAMQdABajYCDCAMIAwqAvQUQzX6jjyUOALMASAMIAwoApQVNgLIASAMIAwoApAVNgLEASAMQbABaiAMKALIASAMKALEARCwASAMQQA6AK8BIAxBADoArgEgDCoCiBVD2w/Jv18EQCAMQ9sPyb8gDCoCzAGSOAKIFSAMQQE6AK8BCyAMKgKEFUPbD8k/YARAIAxD2w/JPyAMKgLMAZM4AoQVIAxBAToArgELIAwqAogVIAwqAoQVXgRAIAxD2w/JvyAMKgLMAZI4AogVIAxD2w/JPyAMKgLMAZM4AoQVIAxBAToArgEgDEEBOgCvAQsgDAJ/IAwqAoQVIAwqAogVkyAMKgLMAZUiBItDAAAAT10EQCAEqAwBC0GAgICAeAtBAWo2AqgBIAwoAqgBQQJIBEAgDEECNgKoAQsgDCAMKgKEFSAMKgKIFZMgDCgCqAFBAWuylTgCpAEgDEEAOgCjAQJAIAwqAoAVIAwqAvwUXgRAIAxD2w9JwCAMKgLMAZI4AoAVIAxD2w9JQDgC/BQgDEEBOgCjAQwBCwJAIAwqAvwUIAwqAoAVk0PbD8lAYARAIAxBAToAowEMAQsgDEEAOgCjAQsLIAwCfyAMKgL8FCAMKgKAFZMgDCoCzAGVIgSLQwAAAE9dBEAgBKgMAQtBgICAgHgLQQFqNgKcASAMKAKcAUECSARAIAxBAjYCnAELIAwgDCoC/BQgDCoCgBWTIAwoApwBQQFrspU4ApgBIAxBADYClAEDQCAMKAKUASAMKAKoAUgEQCAMIAwqAogVIAwoApQBsiAMKgKkAZSSOAKQASAMIAwqAowVIAwqApABECiUOAKMASAMIAwqAowVIAwqApABECmUOAKIASAMQQA2AoQBA0AgDCgChAEgDCgCnAFIBEAgDCAMKgKAFSAMKAKEAbIgDCoCmAGUkjgCgAEgDCAMKgKAARAoOAJ8IAwgDCoCgAEQKTgCeCAMKAKYFSEAIAwgDCoCiAEgDCoCeJQ4AjQgDEE4aiICIAxBNGogDCgCxAEQVyAMQcgAaiIDIAAgAhAUIAwgDCoCiAEgDCoCfJQ4AhwgDEEgaiIAIAxBHGogDEGwAWoQVyAMQdgAaiICIAMgABAUIAxBCGoiACAMQYwBaiAMKALIARBXIAxB6ABqIAIgABAUIAwoAqgCIAwoAoQBQQR0aiIAIAwpAmg3AgAgACAMKQJwNwIIAkAgDCgClAEEQCABIAwoAqwCIAwoAoQBQQR0aiAMKAKoAiAMKAKEAUEEdGogDCgC+BQgASgCACgCCBEEAAwBCyAMLQCuAUEBcQRAIAEgDEHwAWogDCgCqAIgDCgChAFBBHRqIAwoAvgUIAEoAgAoAggRBAALCwJAIAwoAoQBBEAgASAMKAKoAiAMKAKEAUEBa0EEdGogDCgCqAIgDCgChAFBBHRqIAwoAvgUIAEoAgAoAggRBAAMAQsgDCAMKAKoAiAMKAKEAUEEdGoiACkCADcC0AEgDCAAKQIINwLYAQsCQCAMKAKUASAMKAKoAUEBa0cNACAMLQCvAUEBcUUNACABIAxBkAJqIAwoAqgCIAwoAoQBQQR0aiAMKAL4FCABKAIAKAIIEQQACyAMLQDzFEEBcQRAAkAgDC0AowFBAXEEQCAMKAKEASAMKAKcAUEBa0YEQCABIAxB0AFqIAwoAqgCIAwoAoQBQQR0aiAMKAL4FCABKAIAKAIIEQQACwwBCwJAIAwoApQBQQAgDCgClAEgDCgCqAFBAWtHGw0AIAwoAoQBQQAgDCgChAEgDCgCnAFBAWtHGw0AIAEgDCgCmBUgDCgCqAIgDCgChAFBBHRqIAwoAvgUIAEoAgAoAggRBAALCwsgDCAMKAKEAUEBajYChAEMAQsLIAwgDCgCrAI2AqQCIAwgDCgCqAI2AqwCIAwgDCgCpAI2AqgCIAwgDCgClAFBAWo2ApQBDAELCyAMQaAVaiQAC9oFAQF/IwBBsAJrIgskACALIAA2AqwCIAsgATYCqAIgCyACNgKkAiALIAM2AqACIAsgBDgCnAIgCyAFOAKYAiALIAY4ApQCIAsgBzgCkAIgCyAINgKMAiALIAk6AIsCIAsgCjgChAIgCygCrAIhACALIAsoAqACNgKAAiALQfABaiALKAKkAiALKAKgAhCwASALIAsqAoQCQzX6jjyUOALsASALAn8gCyoCkAIgCyoClAKTIAsqAuwBlSIEi0MAAABPXQRAIASoDAELQYCAgIB4CzYC6AEgCygC6AFFBEAgC0EBNgLoAQsgCygCqAIhASALQagBaiICIAtBnAJqIAsoAoACEFcgCyALKgKUAhApOAKkASALQbgBaiIDIAIgC0GkAWoQISALQcgBaiICIAEgAxAUIAtBgAFqIgEgC0GYAmogC0HwAWoQVyALIAsqApQCECg4AnwgC0GQAWoiAyABIAtB/ABqECEgC0HYAWogAiADEBQgCy0AiwJBAXEEQCAAIAsoAqgCIAtB2AFqIAsoAowCIAAoAgAoAggRBAALIAtBATYCeANAIAsoAnggCygC6AFKRQRAIAsgCyoClAIgCyoCkAIgCyoClAKTIAsoAniylCALKALoAbKVkjgCdCALKAKoAiEBIAtBMGoiAiALQZwCaiALKAKAAhBXIAsgCyoCdBApOAIsIAtBQGsiAyACIAtBLGoQISALQdAAaiICIAEgAxAUIAtBCGoiASALQZgCaiALQfABahBXIAsgCyoCdBAoOAIEIAtBGGoiAyABIAtBBGoQISALQeAAaiIBIAIgAxAUIAAgC0HYAWoiAiABIAsoAowCIAAoAgAoAggRBAAgAiABKQIANwIAIAIgASkCCDcCCCALIAsoAnhBAWo2AngMAQsLIAstAIsCQQFxBEAgACALKAKoAiALQdgBaiALKAKMAiAAKAIAKAIIEQQACyALQbACaiQAC/EEAQV/IwBBsAJrIgMkACADIAA2AqwCIAMgATYCqAIgAyACOAKkAiADKAKsAiEBIwBBEGsiBSADKAKoAjYCDCADQZACaiIAIAUoAgxBMGoiBSkCADcCACAAIAUpAgg3AggjAEEQayIFIAMoAqgCNgIMIAUoAgwhBCADQwAAAAA4AtwBIANDAAAAADgC2AEgA0HgAWoiBiADQaQCaiIFIANB3AFqIANB2AFqEAkgA0HwAWoiByAEIAYQESADQYACaiIEIAAgBxAUIANDMzMzPzgCxAEgA0MAAAAAOALAASADQwAAAAA4ArwBIANByAFqIgYgA0HEAWogA0HAAWogA0G8AWoQCSABIAAgBCAGIAEoAgAoAggRBAAjAEEQayIEIAMoAqgCNgIMIAQoAgwhBCADQwAAAAA4AoQBIANDAAAAADgCgAEgA0GIAWoiBiADQYQBaiAFIANBgAFqEAkgA0GYAWoiByAEIAYQESADQagBaiIEIAAgBxAUIANDAAAAADgCbCADQzMzMz84AmggA0MAAAAAOAJkIANB8ABqIgYgA0HsAGogA0HoAGogA0HkAGoQCSABIAAgBCAGIAEoAgAoAggRBAAjAEEQayIEIAMoAqgCNgIMIAQoAgwhBCADQwAAAAA4AiwgA0MAAAAAOAIoIANBMGoiBiADQSxqIANBKGogBRAJIANBQGsiBSAEIAYQESADQdAAaiIEIAAgBRAUIANDAAAAADgCFCADQwAAAAA4AhAgA0MzMzM/OAIMIANBGGoiBSADQRRqIANBEGogA0EMahAJIAEgACAEIAUgASgCACgCCBEEACADQbACaiQAC8UHAQN/IwBBkAJrIgQkACAEIAA2AowCIAQgATYCiAIgBCACNgKEAiAEIAM2AoACIAQoAowCIQMgBEHgAWoiACAEKAKEAiAEKAKIAhBIIARDAAAAPzgC3AEgBEHwAWogACAEQdwBahAhIARBuAFqIgAgBCgChAIgBCgCiAIQFCAEQwAAAD84ArQBIARByAFqIAAgBEG0AWoQISAEQwAAgD84ApQBIARDAACAPzgCkAEgBEMAAIA/OAKMASAEQZgBaiAEQZQBaiAEQZABaiAEQYwBahAJIwBBEGsgBEH4AGo2AgwjAEEQayAEQegAajYCDCAEQQA2ArABA0AgBCgCsAFBBEgEQCAEQQA2AqwBA0AgBCgCrAFBA0gEQCMAQRBrIgEgBEGYAWoiADYCDCAEIAEoAgwqAgACfSMAQRBrIgIgBEHwAWoiATYCDCACKAIMKgIAC5Q4AlQjAEEQayICIAA2AgwgBCACKAIMKgIEAn0jAEEQayICIAE2AgwgAigCDCoCBAuUOAJQIwBBEGsiAiAANgIMIAQgAigCDCoCCAJ9IwBBEGsiAiABNgIMIAIoAgwqAggLlDgCTCAEQdgAaiAEQdQAaiAEQdAAaiAEQcwAahAJIARB+ABqIgIgBCkCWDcCACACIAQpAmA3AgggAiAEQcgBaiIGED8aIAQgBCgCrAFBA282AkgjAEEQayIFIAA2AgwgBSgCDCAEKAJIQQJ0aiIFIAUqAgBDAACAv5Q4AgAjAEEQayIFIAA2AgwgBCAFKAIMKgIAAn0jAEEQayIFIAE2AgwgBSgCDCoCAAuUOAI0IwBBEGsiBSAANgIMIAQgBSgCDCoCBAJ9IwBBEGsiBSABNgIMIAUoAgwqAgQLlDgCMCMAQRBrIgUgADYCDCAEIAUoAgwqAggCfSMAQRBrIgAgATYCDCAAKAIMKgIIC5Q4AiwgBEE4aiAEQTRqIARBMGogBEEsahAJIARB6ABqIgAgBCkCODcCACAAIAQpAkA3AgggACAGED8aIAMgAiAAIAQoAoACIAMoAgAoAggRBAAgBCAEKAKsAUEBajYCrAEMAQsLIARDAACAvzgCFCAEQwAAgL84AhAgBEMAAIC/OAIMIARBGGogBEEUaiAEQRBqIARBDGoQCSAEIAQpAhg3ApgBIAQgBCkCIDcCoAEgBCgCsAFBA0gEQCMAQRBrIgAgBEGYAWo2AgwgACgCDCAEKAKwAUECdGoiACAAKgIAQwAAgL+UOAIACyAEIAQoArABQQFqNgKwAQwBCwsgBEGQAmokAAszAQF/IwBBEGsiASQAIAEgADYCDCABIAEoAgw2AgBBlhxB/R0gARAAIQAgAUEQaiQAIAALRQEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAgwhACACIAIoAgg2AgQgAiAANgIAQbQaQYAIIAIQABogAkEQaiQAC1oBAX8jAEEgayIDJAAgAyAANgIcIAMgATYCGCADIAI2AhQgAygCHCEAIAMoAhghASADIAMoAhQ2AgggAyABNgIEIAMgADYCAEHRGEGwGiADEAAaIANBIGokAAtFAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDCEAIAIgAigCCDYCBCACIAA2AgBB2hZBzhggAhAAGiACQRBqJAALnAECAX8BfCMAQUBqIgYkACAGIAA2AjwgBiABNgI4IAYgAjYCNCAGIAM4AjAgBiAENgIsIAYgBTYCKCAGKAI8IQAgBigCOCEBIAYoAjQhAiAGKgIwuyEHIAYoAiwhBCAGIAYoAig2AhwgBiAENgIYIAYgBzkDECAGIAI2AgggBiABNgIEIAYgADYCAEHZFEHTFiAGEAAaIAZBQGskAAuXAQEBfyMAQSBrIgYkACAGIAA2AhwgBiABNgIYIAYgAjYCFCAGIAM2AhAgBiAENgIMIAYgBTgCCCAGKAIcIgAgBigCGCAGKAIUIAYoAgwgACgCACgCCBEEACAAIAYoAhQgBigCECAGKAIMIAAoAgAoAggRBAAgACAGKAIQIAYoAhggBigCDCAAKAIAKAIIEQQAIAZBIGokAAt+AQF/IwBBMGsiCSQAIAkgADYCLCAJIAE2AiggCSACNgIkIAkgAzYCICAJIAQ2AhwgCSAFNgIYIAkgBjYCFCAJIAc2AhAgCSAIOAIMIAkoAiwiACAJKAIoIAkoAiQgCSgCICAJKAIQIAkqAgwgACgCACgCHBETACAJQTBqJAALZgEBfyMAQdAAayIEJAAgBCAANgJMIAQgATYCSCAEIAI4AkQgBCADNgJAIAQoAkwhACAEEJsBIAQQngIgBCAEKAJIEIwCIAAgBCoCRCAEIAQoAkAgACgCACgCEBEnACAEQdAAaiQAC9sCAQN/IwBB8ABrIgQkACAEIAA2AmwgBCABOAJoIAQgAjYCZCAEIAM2AmAgBCgCbCEAIwBBEGsiAyAEKAJkNgIMIARB0ABqIgIgAygCDEEwaiIDKQIANwIAIAIgAykCCDcCCCAEQUBrIgMCfyMAQRBrIgUgBCgCZDYCDCAFKAIMC0EBEGwgBEEwaiIFAn8jAEEQayIGIAQoAmQ2AgwgBigCDAtBABBsIARD2w/JvzgCLCAEQ9sPyT84AiggBEPbD8m/OAIkIARD2w/JPzgCICAEQwAA8EE4AhwgACACIAMgBSAEKgJoIAQqAiwgBCoCKCAEKgIkIAQqAiAgBCgCYCAEKgIcQQAgACgCACgCQBEeACAEQQhqIgYgBRBbIAAgAiADIAYgBCoCaCAEKgIsIAQqAiggBCoCJCAEKgIgIAQoAmAgBCoCHEEAIAAoAgAoAkARHgAgBEHwAGokAAtYAQF/IwBBIGsiBSQAIAUgADYCHCAFIAE2AhggBSACNgIUIAUgAzYCECAFIAQ2AgwgBSgCHCIAIAUoAhggBSgCFCAFKAIQIAAoAgAoAggRBAAgBUEgaiQAC28BAX8jAEEgayIEJAAgBCAANgIcIAQgATYCGCAEIAI2AhQgBCADNgIQIAQoAhwhACAEKAIYIQEgBCgCFCECIAQgBCgCEDYCDCAEIAI2AgggBCABNgIEIAQgADYCAEH4EkHUFCAEEAAaIARBIGokAAvJAQIBfwF9IwBBQGoiCCQAIAggADYCPCAIIAE2AjggCCACNgI0IAggAzYCMCAIIAQ2AiwgCCAFNgIoIAggBjYCJCAIIAc2AiAgCCgCPCEAIAgoAjghASAIKAI0IQIgCCgCMCEDIAgoAiwhBCAIKAIoIQUgCCgCJCEGIAggCCgCIDYCHCAIIAY2AhggCCAFNgIUIAggBDYCECAIIAM2AgwgCCACNgIIIAggATYCBCAIIAA2AgBByA5B8BAgCBADtiEJIAhBQGskACAJC2UBAX8jAEEQayICIAA2AgwgAiABNgIIIAIgAigCCC4BBCACKAIMIgEuAQZxQQBHOgAHQQAhACACIAItAAdBAXEEfyABLgEEIAIoAgguAQZxQQBHBUEAC0EBcToAByACLQAHQQFxC90BAQF/IwBBIGsiAyQAIAMgADYCHCADIAE2AhggAyACOgAXIAMoAhwiACADKAIYKgIYOAIEIAAgAygCGCgCADYCCAJAIAMtABdBAXEEQCAAIAMoAhgiASkCCDcCNCAAIAEpAhA3AjwMAQsgAwJ/IwBBEGsiAiAAKAIINgIMIwBBEGsiASACKAIMQQRqNgIMIAEoAgwLIAMoAhhBCGoQESAAIAMpAgA3AjQgACADKQIINwI8CyAAQcQAaiAAQRRqIABBJGogAygCGCoCGBCKAyADQSBqJAAgAygCGCoCGAseAQF/IwBBEGsiAyAANgIMIAMgATYCCCADIAI2AgQLuAEBAX8jAEEgayIEJAAgBCAANgIcIAQgATYCGCAEIAI2AhQgBCADNgIQIAQgBCgCGCgCADYCDCAEIAQoAhQoAgA2AgggBCAEKAIMELkBNgIEIAQgBCgCCBC5ATYCACAEKAIEBEAgBCgCBCIAIAQoAhQgBCgCECAEKAIYIAAoAgAoAiARBAALIAQoAgAEQCAEKAIAIgAgBCgCGCAEKAIQIAQoAhQgACgCACgCIBEEAAsgBEEgaiQAQQALpwEBAX8jAEEgayIDJAAgAyAANgIcIAMgATYCGCADIAI2AhQgAyADKAIYKAIANgIQIAMgAygCFCgCADYCDCADIAMoAhAQuQE2AgggAyADKAIMELkBNgIEIAMoAggEQCADKAIIIgAgAygCFCADKAIYIAAoAgAoAhwRBQALIAMoAgQEQCADKAIEIgAgAygCGCADKAIUIAAoAgAoAhwRBQALIANBIGokAEEAC3IBAX8jAEEgayIFJAAgBSABNgIcIAUgAjYCGCAFIAM2AhQgBSAENgIQIAUgBSgCHCIBIAUoAhgQSTgCDCAFIAEgBSgCFBBJOAIIIAUgASAFKAIQEEk4AgQgACAFQQxqIAVBCGogBUEEahAJIAVBIGokAAujBAEBfyMAQTBrIgMkACADIAA2AiwgAyABNgIoIAMgAjYCJCADIAMoAiQCfyMAQRBrIgEgAygCKDYCDCABQQA2AgggASgCDCABKAIIQQR0agsQbzgCICADIAMoAiQCfyMAQRBrIgEgAygCKDYCDCABQQA2AgggASgCDCABKAIIQQR0agsQbjgCHCADIAMoAiQCfyMAQRBrIgEgAygCKDYCDCABQQA2AgggASgCDCABKAIIQQR0agsQbTgCGCADIAMoAiQCfyMAQRBrIgEgAygCKDYCDCABQQE2AgggASgCDCABKAIIQQR0agsQbzgCFCADIAMoAiQCfyMAQRBrIgEgAygCKDYCDCABQQE2AgggASgCDCABKAIIQQR0agsQbjgCECADIAMoAiQCfyMAQRBrIgEgAygCKDYCDCABQQE2AgggASgCDCABKAIIQQR0agsQbTgCDCADIAMoAiQCfyMAQRBrIgEgAygCKDYCDCABQQI2AgggASgCDCABKAIIQQR0agsQbzgCCCADIAMoAiQCfyMAQRBrIgEgAygCKDYCDCABQQI2AgggASgCDCABKAIIQQR0agsQbjgCBCADIAMoAiQCfyMAQRBrIgEgAygCKDYCDCABQQI2AgggASgCDCABKAIIQQR0agsQbTgCACAAIANBIGogA0EcaiADQRhqIANBFGogA0EQaiADQQxqIANBCGogA0EEaiADEIQCIANBMGokAAtHAQF/IwBB0ABrIgIkACACIAA2AkwgAiABNgJIIAJBCGoiACACKAJIIAIoAkwiAUHEAGoQgwMgAUEEaiAAEHMgAkHQAGokAAtYAQJ/IwBBkAFrIgIkACACIAA2AowBIAIgATYCiAEgAkEIaiIAIAIoAowBIgFBxABqEJUDIAJByABqIgMgACABQQRqEIMDIAIoAogBIAMQcyACQZABaiQACyoBAX8jAEEQayIBJAAgASAANgIMIAEoAgwiABAvGiAAEM8CIAFBEGokAAtEAQJ/IwBBEGsiASQAIAEgADYCDCMAQRBrIgAgASgCDCICQRxqNgIMIAAoAgwhACABQRBqJAAgAigCNEECdCAAaioCAAtWAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAkEANgIEIAIoAghBBHQhAEHo9wFB6PcBKAIAQQFqNgIAIABBEEGM0gEoAgARAwAhACACQRBqJAAgAAtRAQF/IwBBEGsiAiQAIAIgADYCCCACIAE2AgQgAigCCCEAAkAgAigCBARAIAIgACACKAIEEPEFNgIMDAELIAJBADYCDAsgAkEQaiQAIAIoAgwLSQEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAggiAARAQez3AUHs9wEoAgBBAWo2AgAgAEGQ0gEoAgARAAALIAJBEGokAAtWAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAkEANgIEIAIoAghBAnQhAEHo9wFB6PcBKAIAQQFqNgIAIABBEEGM0gEoAgARAwAhACACQRBqJAAgAAvHAQECfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIwBBEGsiASACKAIMIgA2AgwgAiABKAIMKAIENgIEIAIoAgQCfyMAQRBrIgEgADYCDCABKAIMKAIIC0YEQCAAAn8jAEEQayIBIAA2AgwgASgCDCgCBCEDIwBBEGsiASAANgIMIAEgAzYCCCABKAIIQQF0QQEgASgCCBsLEIcDCyAAKAIMIAAoAgRBAnRqIAIoAggqAgA4AgAgACAAKAIEQQFqNgIEIAJBEGokAAvHAQECfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIwBBEGsiASACKAIMIgA2AgwgAiABKAIMKAIENgIEIAIoAgQCfyMAQRBrIgEgADYCDCABKAIMKAIIC0YEQCAAAn8jAEEQayIBIAA2AgwgASgCDCgCBCEDIwBBEGsiASAANgIMIAEgAzYCCCABKAIIQQF0QQEgASgCCBsLEIkDCyAAKAIMIAAoAgRBAnRqIAIoAggoAgA2AgAgACAAKAIEQQFqNgIEIAJBEGokAAuaAgEBfyMAQUBqIgMkACADIAA2AjwgAyABNgI4IAMgAjoANyADKAI8IgAgAygCOCgCADYCCCAAQRRqIAMoAjgQ9gUjAEEQayADQSBqNgIMAkAgAy0AN0EBcQRAIAMgAygCOCIBKQIINwIgIAMgASkCEDcCKAwBCyADQRBqAn8jAEEQayICIAAoAgg2AgwjAEEQayIBIAIoAgxBBGo2AgwgASgCDAsgAygCOEEIahARIAMgAykCEDcCICADIAMpAhg3AigLIABByABqIANBIGoQiwMjAEEQayADNgIMIAMgAEEoaiAAQThqIAMoAjgqAhgQigMgAEHcAGogAxCLAyAAQfAAaiADKAI4QRhqEPUFIANBQGskACAAKgIEC2UBAX8jAEEQayICIAA2AgwgAiABNgIIIAIgAigCCC4BBCACKAIMIgEuAQ5xQQBHOgAHQQAhACACIAItAAdBAXEEfyABLgEMIAIoAgguAQZxQQBHBUEAC0EBcToAByACLQAHQQFxCyoBAX8jAEEQayIBJAAgASAANgIMIAEoAgwiABCMAxogABAOIAFBEGokAAtUAQJ/IwBBEGsiASQAIAEgADYCDCABIAEoAgwiACgCNEECakEDbzYCCCMAQRBrIgIgAEEcajYCDCACKAIMIQAgAUEQaiQAIAEoAghBAnQgAGoqAgAL2wEBAX8jAEEgayIDJAAgAyAANgIcIAMgATYCGCADIAI6ABcgAygCHCIAIAMoAhgqAig4AgQgACADKAIYKAIANgJMAkAgAy0AF0EBcQRAIAAgAygCGCIBKQIINwIsIAAgASkCEDcCNAwBCyADAn8jAEEQayICIAAoAkw2AgwjAEEQayIBIAIoAgxBBGo2AgwgASgCDAsgAygCGEEIahARIAAgAykCADcCLCAAIAMpAgg3AjQLIAAgAygCGCIBKQIYNwI8IAAgASkCIDcCRCADQSBqJAAgAygCGCoCKAtlAQF/IwBBEGsiAiAANgIMIAIgATYCCCACIAIoAgguAQQgAigCDCIBLgEKcUEARzoAB0EAIQAgAiACLQAHQQFxBH8gAS4BCCACKAIILgEGcUEARwVBAAtBAXE6AAcgAi0AB0EBcQs1AQF/IwBBEGsiASQAIAEgADgCDCABQ9sPyUA4AgggASoCDCABKgIIECUhACABQRBqJAAgAAsEAEEFCwQAQQALiAEBAX8jAEEgayIGIAA2AhwgBiABNgIYIAYgAjYCFCAGIAM2AhAgBiAENgIMIAYgBTgCCCAGKAIcIgAgBigCGDYCACAAIAYoAhQ2AgQgACAGKAIQIgEpAgA3AgggACABKQIINwIQIAAgBigCDCIBKQIANwIYIAAgASkCCDcCICAAIAYqAgg4AigLWwEBfyMAQSBrIgUkACAFIAA2AhwgBSABNgIYIAUgAjYCFCAFIAM2AhAgBSAEOAIMQSwQEiIAIAUoAhwgBSgCGCAFKAIUIAUoAhAgBSoCDBCABiAFQSBqJAAgAAurAQECfyMAQRBrIgIkACACIAA2AgwgAiABOAIIIAIoAgwiAyIAQiM3AgQgAEGkkAE2AgAgAEGKro/pAzYCLCAAQoCAgPwDNwIUIABCgICA/IOAgMA/NwIMIABBpJEBNgIAIANBxIIBNgIAIANBCDYCBCACKgIIIQEjAEEQayIAIANBHGo2AgwgACABOAIIIAAoAgwgACoCCDgCACADIAIqAgg4AiwgAkEQaiQACysBAn8jAEEQayIBJAAgASAAOAIMQTQQDSICIAEqAgwQggYgAUEQaiQAIAILQwEBfyMAQRBrIgMkACADIAA2AgwgAyABNgIIIAMgAjgCBCADKAIMIAMoAghBAnRqQaQKaiADKgIEOAIAIANBEGokAAsvAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDCACKAIIEMgOIAJBEGokAAsjAQF/IwBBEGsiASQAIAEgADYCDCABKAIMEMkOIAFBEGokAAtDAQF/IwBBEGsiAyQAIAMgADYCDCADIAE2AgggAyACOAIEIAMoAgwgAygCCEECdGpB1ApqIAMqAgQ4AgAgA0EQaiQAC0MBAX8jAEEQayIDJAAgAyAANgIMIAMgATYCCCADIAI4AgQgAygCDCADKAIIQQJ0akG8CmogAyoCBDgCACADQRBqJAALPgEBfyMAQRBrIgMkACADIAA2AgwgAyABNgIIIAMgAjoAByADKAIMIAMoAgggAy0AB0EBcRDKDiADQRBqJAALXwEBfyMAQSBrIgUkACAFIAA2AhwgBSABNgIYIAUgAjYCFCAFIAM2AhAgBSAEOgAPQewKEA0iACAFKAIcIAUoAhggBSgCFCAFKAIQIAUtAA9BAXEQzA4gBUEgaiQAIAALRwEBfyMAQRBrIgMkACADIAA2AgwgAyABNgIIIAMgAjoAB0HsChANIgAgAygCDCADKAIIIAMtAAdBAXEQyw4gA0EQaiQAIAALJQEBfyMAQRBrIgIgADYCDCACIAE2AgggAigCDCACKAIIsjgCMAs0AgF/AX0jAEEQayIBIAA2AgwCfyABKAIMKgIwIgKLQwAAAE9dBEAgAqgMAQtBgICAgHgLCycBAX8jAEEQayICIAA2AgwgAiABOgALIAIoAgwgAi0AC0EBcTYCLAsbAQF/IwBBEGsiASAANgIMIAEoAgwoAixBAEcLNwECfyMAQRBrIgIkACACIAA4AgwgAiABOAIIQTgQDSIDIAIqAgwgAioCCBDGCyACQRBqJAAgAwszAQF/IwBBEGsiAiQAIAIgADYCDCACIAE4AgggAigCDCACQQhqEJMDIQAgAkEQaiQAIAALsQQBAX8jAEEgayICJAAgAiAANgIcIAIgATYCGCACIAIoAhwiACoCDAJ9IwBBEGsiASACKAIYNgIMIAEoAgwqAgALlCAAKgIAIAIoAhgqAgyUkiAAKgIEAn0jAEEQayIBIAIoAhg2AgwgASgCDEEIaioCAAuUkiAAKgIIAn0jAEEQayIBIAIoAhg2AgwgASgCDEEEaioCAAuUkzgCFCACIAAqAgwCfSMAQRBrIgEgAigCGDYCDCABKAIMQQRqKgIAC5QgACoCBCACKAIYKgIMlJIgACoCCAJ9IwBBEGsiASACKAIYNgIMIAEoAgwqAgALlJIgACoCAAJ9IwBBEGsiASACKAIYNgIMIAEoAgxBCGoqAgALlJM4AhAgAiAAKgIMAn0jAEEQayIBIAIoAhg2AgwgASgCDEEIaioCAAuUIAAqAgggAigCGCoCDJSSIAAqAgACfSMAQRBrIgEgAigCGDYCDCABKAIMQQRqKgIAC5SSIAAqAgQCfSMAQRBrIgEgAigCGDYCDCABKAIMKgIAC5STOAIMIAIgACoCDCACKAIYKgIMlCAAKgIAAn0jAEEQayIBIAIoAhg2AgwgASgCDCoCAAuUkyAAKgIEAn0jAEEQayIBIAIoAhg2AgwgASgCDEEEaioCAAuUkyAAKgIIAn0jAEEQayIBIAIoAhg2AgwgASgCDEEIaioCAAuUkzgCCCAAIAJBFGogAkEQaiACQQxqIAJBCGoQdyACQSBqJAAgAAszAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDCACKAIIEJIGIQAgAkEQaiQAIAALMwEBfyMAQRBrIgIkACACIAA2AgwgAiABOAIIIAIoAgwgAkEIahCRAyEAIAJBEGokACAAC7gBAgF/AX0jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIQAjAEEQayIBIAIoAgg2AgwgASgCDCoCACEDIAAgACoCACADkzgCACMAQRBrIgEgAigCCDYCDCABKAIMQQRqKgIAIQMgACAAKgIEIAOTOAIEIwBBEGsiASACKAIINgIMIAEoAgxBCGoqAgAhAyAAIAAqAgggA5M4AgggACAAKgIMIAIoAggqAgyTOAIMIAJBEGokACAACzMBAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIAIoAggQlQYhACACQRBqJAAgAAu4AQIBfwF9IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDCEAIwBBEGsiASACKAIINgIMIAEoAgwqAgAhAyAAIAAqAgAgA5I4AgAjAEEQayIBIAIoAgg2AgwgASgCDEEEaioCACEDIAAgACoCBCADkjgCBCMAQRBrIgEgAigCCDYCDCABKAIMQQhqKgIAIQMgACAAKgIIIAOSOAIIIAAgACoCDCACKAIIKgIMkjgCDCACQRBqJAAgAAszAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDCACKAIIEJcGIQAgAkEQaiQAIAALqQEBAX8jAEEgayICJAAgAiABNgIcIAIgAigCHDYCGCMAQRBrIgEgAigCGDYCDCACIAEoAgwqAgCMOAIUIwBBEGsiASACKAIYNgIMIAIgASgCDEEEaioCAIw4AhAjAEEQayIBIAIoAhg2AgwgAiABKAIMQQhqKgIAjDgCDCACIAIoAhgqAgyMOAIIIAAgAkEUaiACQRBqIAJBDGogAkEIahC7ASACQSBqJAALqQECAX8BfSMAQSBrIgIkACACIAA2AhggAiABNgIUIAIoAhgiABBaIAIoAhQQWpQhAyMAQRBrIgEgAzgCDCACIAEqAgyROAIQAkAgACACKAIUEFlDAAAAAF0EQCACIAIoAhQQmQYgAiAAIAIQWSACKgIQlRBwQwAAAECUOAIcDAELIAIgACACKAIUEFkgAioCEJUQcEMAAABAlDgCHAsgAkEgaiQAIAIqAhwLNQIBfwF9IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDCACKAIIEJoGIQMgAkEQaiQAIAMLYwIBfwF9IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDCIAEFogAigCCBBalCEDIwBBEGsiASADOAIMIAIgASoCDJE4AgQgACACKAIIEFkgAioCBJUQcCEDIAJBEGokACADCzcBAn8jAEEQayICJAAgAiAAOAIMIAIgATgCCEE4EA0iAyACKgIMIAIqAggQzAsgAkEQaiQAIAMLNQIBfwF9IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDCACKAIIEJwGIQMgAkEQaiQAIAMLXgEBfyMAQRBrIgEkACABIAA2AgwCQCABKAIMIgAgABBZQwAAAABdBEAgAUMAAABAIAAqAgwQcJQ4AggMAQsgAUMAAABAIAAqAgyMEHCUOAIICyABQRBqJAAgASoCCAspAgF/AX0jAEEQayIBJAAgASAANgIMIAEoAgwQnwYhAiABQRBqJAAgAgs1AQF/IwBBEGsiASQAIAEgADYCDCABQwAAAEAgASgCDCoCDBBwlDgCCCABQRBqJAAgASoCCAspAgF/AX0jAEEQayIBJAAgASAANgIMIAEoAgwQoQYhAiABQRBqJAAgAgtXAQF/IwBBEGsiAiQAIAIgATYCDCACIAIoAgwiASoCAIw4AgggAiABKgIEjDgCBCACIAEqAgiMOAIAIAAgAkEIaiACQQRqIAIgAUEMahC7ASACQRBqJAALawEBfyMAQSBrIgEkACABIAA2AhwCQEGM2AEtAABBAXENAEGM2AEQEEUNAEH81wEQLxpBjNgBEA8LIAFBCGoiACABKAIcEKMGQfzXASAAKQIANwIAQYTYASAAKQIINwIAIAFBIGokAEH81wEL3QEBAn8jAEEwayICJAAgAiABNgIsIAJDAACAPyACKAIsIgEqAgwgASoCDJSTOAIoAkAgAioCKEMAAKA1XQRAIAJDAACAPzgCJCACQwAAAAA4AiAgAkMAAAAAOAIcIAAgAkEkaiACQSBqIAJBHGoQCQwBCyMAQRBrIgMgAioCKDgCDCACQwAAgD8gAyoCDJGVOAIYIAIgASoCACACKgIYlDgCFCACIAEqAgQgAioCGJQ4AhAgAiABKgIIIAIqAhiUOAIMIAAgAkEUaiACQRBqIAJBDGoQCQsgAkEwaiQAC24BAX8jAEEgayIBJAAgASAANgIcAkBB+NcBLQAAQQFxDQBB+NcBEBBFDQAjAEEQa0Ho1wE2AgxB+NcBEA8LIAFBCGogASgCHBClBkHo1wEgASkCCDcCAEHw1wEgASkCEDcCACABQSBqJABB6NcBC0gBAX8jAEEQayIDJAAgAyABNgIMIAMgAjYCCCADKAIMIQEgA0MAAIA/IAMoAggqAgCVOAIEIAAgASADQQRqEM4FIANBEGokAAs2AQF/IwBBEGsiAiQAIAIgATYCDCACIAIoAgwiARCIAjgCCCAAIAEgAkEIahCnBiACQRBqJAALawEBfyMAQSBrIgEkACABIAA2AhwCQEHk1wEtAABBAXENAEHk1wEQEEUNAEHU1wEQLxpB5NcBEA8LIAFBCGoiACABKAIcEKgGQdTXASAAKQIANwIAQdzXASAAKQIINwIAIAFBIGokAEHU1wELNAIBfwF9IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDCACKAIIEFkhAyACQRBqJAAgAwspAgF/AX0jAEEQayIBJAAgASAANgIMIAEoAgwQiAIhAiABQRBqJAAgAgsoAgF/AX0jAEEQayIBJAAgASAANgIMIAEoAgwQWiECIAFBEGokACACCzUBAX8jAEEQayIBJAAgASAANgIMIAEgASgCDCIAEIgCOAIIIAAgAUEIahCTAxogAUEQaiQACyMBAX8jAEEQayIBJAAgASAANgIMIAEoAgwQrQYgAUEQaiQAC/EBAQF/IwBBMGsiAyQAIAMgADYCLCADIAE2AiggAyACNgIkIAMoAiwhACADIAMoAigQ4QI4AiAgAyADKAIkKgIAQwAAAD+UECggAyoCIJU4AhwjAEEQayIBIAMoAig2AgwgAyABKAIMKgIAIAMqAhyUOAIYIwBBEGsiASADKAIoNgIMIAMgASgCDEEEaioCACADKgIclDgCFCMAQRBrIgEgAygCKDYCDCADIAEoAgxBCGoqAgAgAyoCHJQ4AhAgAyADKAIkKgIAQwAAAD+UECk4AgwgACADQRhqIANBFGogA0EQaiADQQxqEHcgA0EwaiQACzsBAX8jAEEQayIDJAAgAyAANgIMIAMgATYCCCADIAI4AgQgAygCDCADKAIIIANBBGoQrwYgA0EQaiQAC/ICAQF/IwBB0ABrIgQkACAEIAA2AkwgBCABNgJIIAQgAjYCRCAEIAM2AkAgBCgCTCEAIAQgBCgCSCoCAEMAAAA/lDgCPCAEIAQoAkQqAgBDAAAAP5Q4AjggBCAEKAJAKgIAQwAAAD+UOAI0IAQgBCoCPBApOAIwIAQgBCoCPBAoOAIsIAQgBCoCOBApOAIoIAQgBCoCOBAoOAIkIAQgBCoCNBApOAIgIAQgBCoCNBAoOAIcIAQgBCoCHCAEKgIolCAEKgIwlCAEKgIgIAQqAiSUIAQqAiyUkzgCGCAEIAQqAiAgBCoCJJQgBCoCMJQgBCoCHCAEKgIolCAEKgIslJI4AhQgBCAEKgIgIAQqAiiUIAQqAiyUIAQqAhwgBCoCJJQgBCoCMJSTOAIQIAQgBCoCICAEKgIolCAEKgIwlCAEKgIcIAQqAiSUIAQqAiyUkjgCDCAAIARBGGogBEEUaiAEQRBqIARBDGoQdyAEQdAAaiQAC0QBAX8jAEEQayIEJAAgBCAANgIMIAQgATgCCCAEIAI4AgQgBCADOAIAIAQoAgwgBEEIaiAEQQRqIAQQsQYgBEEQaiQAC0wBAn8jAEEQayIEJAAgBCAAOAIMIAQgATgCCCAEIAI4AgQgBCADOAIAQRAQEiIFIARBDGogBEEIaiAEQQRqIAQQuwEgBEEQaiQAIAULNwECfyMAQRBrIgIkACACIAA4AgwgAiABOAIIQTgQDSIDIAIqAgwgAioCCBDHCyACQRBqJAAgAws/AQJ/IwBBEGsiASQAIAEgADYCDCMAQRBrIgAgASgCDCICNgIMIAAoAgxBnBI2AgAgAkGEETYCACABQRBqJAALFgEBf0EEEBIiAEEANgIAIAAQtQYgAAsuAQF/IwBBEGsiASQAIAEgADYCDCABKAIMIgAEQCAAEI4BIAAQDgsgAUEQaiQACzcBAX8jAEEQayIDIAA2AgwgAyABNgIIIAMgAjgCBCADKAIMQRRqIAMoAghBAnRqIAMqAgQ4AgALKwEBfyMAQRBrIgIgADYCDCACIAE2AgggAigCDEEUaiACKAIIQQJ0aioCAAsuAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDCACKAIIEHUgAkEQaiQACysBAX8jAEEQayIBJAAgASAANgIMQTgQDSIAIAEoAgwQugsgAUEQaiQAIAALVQEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAgghASMAQRBrIgAgAigCDDYCDCAAIAE2AgggACgCDCgCDCAAKAIIQegAbGohACACQRBqJAAgAAskAQF/IwBBEGsiAiAANgIMIAIgATYCCCACKAIMIAIoAgg7AQYLGAEBfyMAQRBrIgEgADYCDCABKAIMLgEGCyQBAX8jAEEQayICIAA2AgwgAiABNgIIIAIoAgwgAigCCDsBBAsYAQF/IwBBEGsiASAANgIMIAEoAgwuAQQLVQEBfyMAQSBrIgUkACAFIAA2AhwgBSABNgIYIAUgAjYCFCAFIAM2AhAgBSAEOgAPIAUoAhggBSgCFCAFKAIQIAUtAA9BAXEQ3wIhACAFQSBqJAAgAAthAQF/IwBBIGsiBiQAIAYgADYCHCAGIAE2AhggBiACNgIUIAYgAzYCECAGIAQ2AgwgBiAFOgALIAYoAhggBigCFCAGKAIQIAYoAgwgBi0AC0EBcRCRDyEAIAZBIGokACAAC1IBAX8jAEEgayIFJAAgBSAANgIcIAUgATYCGCAFIAI2AhQgBSADNgIQIAUgBDYCDCAFKAIYIAUoAhQgBSgCECAFKAIMEJIPIQAgBUEgaiQAIAALnQEBAX8jAEEwayILJAAgCyAANgIsIAsgATYCKCALIAI2AiQgCyADNgIgIAsgBDYCHCALIAU2AhggCyAGNgIUIAsgBzYCECALIAg2AgwgCyAJOgALIAsgCjYCBCALKAIoIAsoAiQgCygCICALKAIcIAsoAhggCygCFCALKAIQIAsoAgwgCy0AC0EBcSALKAIEEJMPIQAgC0EwaiQAIAALkQEBAX8jAEEwayIKJAAgCiAANgIsIAogATYCKCAKIAI2AiQgCiADNgIgIAogBDYCHCAKIAU2AhggCiAGNgIUIAogBzYCECAKIAg2AgwgCiAJOgALIAooAiggCigCJCAKKAIgIAooAhwgCigCGCAKKAIUIAooAhAgCigCDCAKLQALQQFxEJQPIQAgCkEwaiQAIAALXgEBfyMAQSBrIgYkACAGIAA2AhwgBiABNgIYIAYgAjYCFCAGIAM2AhAgBiAENgIMIAYgBTYCCCAGKAIYIAYoAhQgBigCECAGKAIMIAYoAggQlQ8hACAGQSBqJAAgAAsGAEEBEBILNwEBfyMAQRBrIgIgADYCDCACIAE2AgggAigCDCIAIAIoAggiASkCADcC3AIgACABKAIINgLkAgs3AQF/IwBBEGsiASQAIAEgADYCDCMAQRBrIgAgASgCDDYCDCAAKAIMQbwCaiEAIAFBEGokACAACzcBAX8jAEEQayIBJAAgASAANgIMIwBBEGsiACABKAIMNgIMIAAoAgxBrAJqIQAgAUEQaiQAIAALNwEBfyMAQRBrIgIgADYCDCACIAE2AgggAigCDCIAIAIoAggiASkCADcCvAIgACABKQIINwLEAgsvAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDCACKAIIEMsGIAJBEGokAAs3AQF/IwBBEGsiAiAANgIMIAIgATYCCCACKAIMIgAgAigCCCIBKQIANwKsAiAAIAEpAgg3ArQCCy8BAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIAIoAggQzQYgAkEQaiQAC1ABAX8jAEEQayIEJAAgBCAANgIMIAQgATYCCCAEIAI2AgQgBCADNgIAQegCEA0iACAEKAIMIAQoAgggBCgCBCAEKAIAEMIOIARBEGokACAACzgBAX8jAEEQayICJAAgAiAANgIMIAIgATYCCEHoAhANIgAgAigCDCACKAIIEMEOIAJBEGokACAACyQBAX8jAEEQayICIAA2AgwgAiABNgIIIAIoAgwgAigCCDYCcAsYAQF/IwBBEGsiASAANgIMIAEoAgwoAnALNQEBfyMAQRBrIgIgADYCDCACIAE2AgggAigCDCIAIAIoAggiASkCADcCQCAAIAEpAgg3AkgLGAEBfyMAQRBrIgEgADYCDCABKAIMQUBrCzkCAX8BfCMAQRBrIgEkACABIAA2AgwjAEEQayIAIAEoAgw2AgwgACgCDCoCULshAiABQRBqJAAgAgs5AgF/AXwjAEEQayIBJAAgASAANgIMIwBBEGsiACABKAIMNgIMIAAoAgwqAni7IQIgAUEQaiQAIAILNgEBfyMAQRBrIgEkACABIAA2AgwjAEEQayIAIAEoAgw2AgwgACgCDEEgaiEAIAFBEGokACAACxABAX9BoAIQDSIAENINIAALMwEBfyMAQRBrIgIkACACIAA2AgwgAiABOAIIIAIoAgwgAioCCBDaATgCxAEgAkEQaiQACy8BAX8jAEEQayICJAAgAiAANgIMIAIgATgCCCACKAIMIAIqAggQ2QYgAkEQaiQACzMBAX8jAEEQayICJAAgAiAANgIMIAIgATgCCCACKAIMIAIqAggQ2gE4AsABIAJBEGokAAsvAQF/IwBBEGsiAiQAIAIgADYCDCACIAE4AgggAigCDCACKgIIENsGIAJBEGokAAtNAQF/IwBBEGsiAiQAIAIgADYCDCACIAE4AgggAioCCCEBIwBBEGsiACACKAIMNgIMIAAgATgCCCAAKAIMIAAqAgg4ArwBIAJBEGokAAtfAQF/IwBBIGsiBSQAIAUgADYCHCAFIAE2AhggBSACNgIUIAUgAzYCECAFIAQ6AA9B6AgQDSIAIAUoAhwgBSgCGCAFKAIUIAUoAhAgBS0AD0EBcRC2DiAFQSBqJAAgAAtHAQF/IwBBEGsiAyQAIAMgADYCDCADIAE2AgggAyACOgAHQegIEA0iACADKAIMIAMoAgggAy0AB0EBcRC1DiADQRBqJAAgAAtKAQF/IwBBEGsiAyQAIAMgADYCDCADIAE6AAsgAyACOgAKQcwAEA0iACADKAIMIAMtAAtBAXEgAy0ACkEBcRCXBCADQRBqJAAgAAs9AQF/IwBBEGsiAiQAIAIgADYCDCACIAE6AAtBzAAQDSIAIAIoAgwgAi0AC0EBcUEBEJcEIAJBEGokACAAC1EBAn8jAEEQayIBJAAgASAANgIMIwBBEGsiACABKAIMIgI2AgwgACgCDCIAQbgONgIAIABBATsBBCAAQf//AzsBBiACQcANNgIAIAFBEGokAAsWAQF/QQgQEiIAQgA3AwAgABDiBiAACywBAX8jAEEQayIBJAAgASAANgIMQfAAEBIiACABKAIMEPQCIAFBEGokACAACy4BA38jAEEgayIAJABB8AAQEiEBIABBCGoiAhCBAiABIAIQ9AIgAEEgaiQAIAELNQEBfyMAQRBrIgIgADYCDCACIAE2AgggAigCDCIAIAIoAggiASkCADcCFCAAIAEpAgg3AhwLiAEBAX8jAEEQayIDJAAgAyAANgIMIAMgATYCCCADIAI2AgQgAygCDCIAELwDIABB7Aw2AgAgACADKAIIIgEpAgA3AhQgACABKQIINwIcIAAgAygCBCIBKQIANwIkIAAgASkCCDcCLCMAQRBrIABBNGo2AgwjAEEQayAAQcQAajYCDCADQRBqJAALOAEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIQdQAEBIiACACKAIMIAIoAggQ5wYgAkEQaiQAIAAL6QEBAX8jAEEwayICJAAgAiAANgIsIAIgATYCKCACIAIoAiggAigCLCIAEG84AiQgAiACKAIoIAAQbjgCICACIAIoAiggABBtOAIcIAIgAigCKCAAQRBqEG84AhggAiACKAIoIABBEGoQbjgCFCACIAIoAiggAEEQahBtOAIQIAIgAigCKCAAQSBqEG84AgwgAiACKAIoIABBIGoQbjgCCCACIAIoAiggAEEgahBtOAIEIAAgAkEkaiACQSBqIAJBHGogAkEYaiACQRRqIAJBEGogAkEMaiACQQhqIAJBBGoQogEgAkEwaiQAC1ABAX8jAEEgayICJAAgAiAANgIcIAIgATYCGCACQQhqIgEgAigCHCIAIAIoAhhBMGoQESAAQTBqIAEQPxogACACKAIYEOkGIAJBIGokACAACzMBAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIAIoAggQ6gYhACACQRBqJAAgAAuEAgEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAACfyMAQRBrIgEgAigCCCIANgIMIAEoAgwLAn8jAEEQayIBIABBEGo2AgwgASgCDAsCfyMAQRBrIgEgAEEgajYCDCABKAIMCwJ/IwBBEGsiASAANgIMIAEoAgxBBGoLAn8jAEEQayIBIABBEGo2AgwgASgCDEEEagsCfyMAQRBrIgEgAEEgajYCDCABKAIMQQRqCwJ/IwBBEGsiASAANgIMIAEoAgxBCGoLAn8jAEEQayIBIABBEGo2AgwgASgCDEEIagsCfyMAQRBrIgEgAEEgajYCDCABKAIMQQhqCxCEAiACQRBqJAALXQEBfyMAQdAAayIBJAAgASAANgJMAkBB0NcBLQAAQQFxDQBB0NcBEBBFDQBBkNcBEJsBQdDXARAPCyABQQhqIgAgASgCTBCVA0GQ1wEgABBzIAFB0ABqJABBkNcBC34BAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIgAgAigCCCACKAIIQRBqIAIoAghBIGoQCSAAQRBqIAIoAghBBGogAigCCEEUaiACKAIIQSRqEAkgAEEgaiACKAIIQQhqIAIoAghBGGogAigCCEEoahAJIAJBEGokAAtQAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDCIAIAIoAggQ7gYgAEEwaiACKAIIQTBqIAIoAghBNGogAigCCEE4ahAJIAJBEGokAAsvAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDCACKAIIEO8GIAJBEGokAAszAQF/IwBBEGsiASQAIAEgADYCDCMAQRBrIgAgASgCDDYCDCAAKAIMIQAgAUEQaiQAIAALLQEBfyMAQRBrIgIkACACIAE2AgwgAigCDCEBIAAQLxogASAAECYgAkEQaiQAC2sBAX8jAEEgayIBJAAgASAANgIcAkBBjNcBLQAAQQFxDQBBjNcBEBBFDQBB/NYBEC8aQYzXARAPCyABQQhqIgAgASgCHBDyBkH81gEgACkCADcCAEGE1wEgACkCCDcCACABQSBqJABB/NYBCy8BAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIAIoAggQlgMgAkEQaiQACy8BAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIAIoAggQ9AYgAkEQaiQACy8BAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIAIoAggQjAIgAkEQaiQAC64BAQF/IwBBMGsiASQAIAEgADYCLCABKAIsIQAgAUMAAIA/OAIoIAFDAAAAADgCJCABQwAAAAA4AiAgAUMAAAAAOAIcIAFDAACAPzgCGCABQwAAAAA4AhQgAUMAAAAAOAIQIAFDAAAAADgCDCABQwAAgD84AgggACABQShqIAFBJGogAUEgaiABQRxqIAFBGGogAUEUaiABQRBqIAFBDGogAUEIahCiASABQTBqJAALIwEBfyMAQRBrIgEkACABIAA2AgwgASgCDBCeAiABQRBqJAALYAEDfyMAQRBrIgIkACACIAA2AgggAiABNgIEIAIgAigCCCIANgIMIABBMGohAyAAIQEDQCMAQRBrIAE2AgwgAUEQaiIEIQEgAyAERw0ACyAAIAIoAgQQlgMgAkEQaiQAC1EBAX8jAEEQayIDJAAgAyAANgIMIAMgATYCCCADIAI2AgQgAygCDCIAIAMoAggQ+QYgACADKAIEIgEpAgA3AjAgACABKQIINwI4IANBEGokAAs4AQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AghBwAAQEiIAIAIoAgwgAigCCBD6BiACQRBqJAAgAAsQAQF/QcAAEBIiABCbASAAC1ABAX8jAEEQayIEJAAgBCAANgIMIAQgATYCCCAEIAI2AgQgBCADNgIAQeAAEA0iACAEKAIMIAQoAgggBCgCBCAEKAIAEN4OIARBEGokACAAC3gBAX8jAEEgayIBJAAgASAANgIcAkBB+NYBLQAAQQFxDQBB+NYBEBBFDQAjAEEQa0Ho1gE2AgxB+NYBEA8LIAFBCGogASgCHCIAIAAoAgAoAkwRAgBB6NYBIAEpAgg3AgBB8NYBIAEpAhA3AgAgAUEgaiQAQejWAQs3AQF/IwBBEGsiASQAIAEgADYCDCMAQRBrIgAgASgCDDYCDCAAKAIMQcQCaiEAIAFBEGokACAACzcBAX8jAEEQayIBJAAgASAANgIMIwBBEGsiACABKAIMNgIMIAAoAgxB4AJqIQAgAUEQaiQAIAALLwEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAgwgAigCCBCkDyACQRBqJAALRwEBfyMAQRBrIgQkACAEIAA2AgwgBCABNgIIIAQgAjsBBiAEIAM7AQQgBCgCDCAEKAIIIAQuAQYgBC4BBBClDyAEQRBqJAALVwEBfyMAQSBrIgUkACAFIAA2AhwgBSABNgIYIAUgAjYCFCAFIAM2AhAgBSAENgIMQcwDEA0iACAFKAIcIAUoAhggBSgCFCAFKAIMEKkPIAVBIGokACAACzQCAX8BfSMAQRBrIgEkACABIAA2AgwgASgCDCIAIAAoAgAoAiQRAQCyIQIgAUEQaiQAIAILOAEBfyMAQRBrIgIkACACIAA2AgwgAiABOAIIQdQAEA0iACACKAIMIAIqAggQ9AsgAkEQaiQAIAALRQECfyMAQRBrIgEkACABIAA2AgwgASgCDCIAAn8jAEEQayICIAA2AgwgAigCDCgCBAsQ+QIgABBQIAAQvQEgAUEQaiQACyMBAX8jAEEQayIBJAAgASAANgIMIAEoAgwQhgcgAUEQaiQACy4BAX8jAEEQayIBJAAgASAANgIMIAEoAgwiAARAIAAQhwcgABAOCyABQRBqJAALVAEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAgghASMAQRBrIgAgAigCDDYCDCAAIAE2AgggACgCDCgCDCAAKAIIQSRsaiEAIAJBEGokACAACzwBAX8jAEEQayICJAAgAiAANgIMIAIgAToACyACKAIMIgAgAi0AC0EBcSAAKAIAKAI0EQIAIAJBEGokAAs0AQF/IwBBEGsiASQAIAEgADYCDCABKAIMIgAgACgCACgCMBEBAEEBcSEAIAFBEGokACAAC1MBAX8jAEEQayICJAAgAiAANgIMIAIgAToACyACLQALQQFxIQEjAEEQayIAIAIoAgw2AgwgACABOgALIAAoAgwgAC0AC0EBcToAqgEgAkEQaiQACyMBAX8jAEEQayIBJAAgASAANgIMIAFBEGokACABKAIMKAIICyMBAX8jAEEQayIBJAAgASAANgIMIAFBEGokACABKAIMKgIkCzwBAX8jAEEQayICJAAgAiAANgIMIAIgATgCCCACKAIMIgAgAioCCCIBOAIkIAAgARAdOAIoIAJBEGokAAsjAQF/IwBBEGsiASQAIAEgADYCDCABQRBqJAAgASgCDCoCLAsvAQF/IwBBEGsiAiQAIAIgADYCDCACIAE4AgggAigCDCACKgIIOAIsIAJBEGokAAstAQF/IwBBEGsiASQAIAEgADYCDCABKAIMIgAgACgCACgCLBEAACABQRBqJAALNAEBfyMAQRBrIgEkACABIAA2AgwgASgCDCIAIAAoAgAoAigRAQBBAXEhACABQRBqJAAgAAsvAQF/IwBBEGsiAiQAIAIgADYCDCACIAE4AgggAigCDCACKgIIOAIgIAJBEGokAAsvAQF/IwBBEGsiAiQAIAIgADYCDCACIAE4AgggAigCDCACKgIIOAIcIAJBEGokAAsvAQF/IwBBEGsiAiQAIAIgADYCDCACIAE4AgggAigCDCACKgIIOAIYIAJBEGokAAtFAQF/IwBBEGsiAyQAIAMgADYCDCADIAE2AgggAyACOAIEIAMoAgwiACADKAIIIAMqAgQgACgCACgCJBELACADQRBqJAALOQEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAgwiACACKAIIIAAoAgAoAiARAgAgAkEQaiQACzkBAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIgAgAigCCCAAKAIAKAIcEQIAIAJBEGokAAtFAQF/IwBBEGsiAyQAIAMgADYCDCADIAE2AgggAyACOAIEIAMoAgwiACADKAIIIAMqAgQgACgCACgCFBELACADQRBqJAALTQEBfyMAQRBrIgIgADYCDCACIAE2AgggAigCDCEAIAIoAghBAEgEQCACQQA2AggLIAIoAghBAkoEQCACQQI2AggLIAAgAigCCDYCsAELLwEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAgwgAigCCBCbByACQRBqJAALUAEBfyMAQRBrIgQkACAEIAA2AgwgBCABNgIIIAQgAjgCBCAEIAM2AgBBuAEQDSIAIAQoAgwgBCgCCCAEKgIEIAQoAgAQ0AQgBEEQaiQAIAALRgEBfyMAQRBrIgMkACADIAA2AgwgAyABNgIIIAMgAjgCBEG4ARANIgAgAygCDCADKAIIIAMqAgRBARDQBCADQRBqJAAgAAs/AQJ/IwBBEGsiASQAIAEgADYCDCMAQRBrIgAgASgCDCICNgIMIAAoAgxB0Aw2AgAgAkHsCzYCACABQRBqJAALDwEBf0EEEBIiABCfByAACyQBAX8jAEEQayICIAA2AgwgAiABOAIIIAIoAgwgAioCCDgCWAsYAQF/IwBBEGsiASAANgIMIAEoAgwqAlgLNQEBfyMAQRBrIgIgADYCDCACIAE2AgggAigCDCIAIAIoAggiASkCADcCSCAAIAEpAgg3AlALOAEBfyMAQRBrIgEkACABIAA2AgwgASgCDCIAQZABahA5IABB/ABqEDkgAEHoAGoQOSABQRBqJAALLgEBfyMAQRBrIgEkACABIAA2AgwgASgCDCIABEAgABCkByAAEA4LIAFBEGokAAskAQF/IwBBEGsiAiAANgIMIAIgATYCCCACKAIMIAIoAgg2AmQLGAEBfyMAQRBrIgEgADYCDCABKAIMKAJkCyQBAX8jAEEQayICIAA2AgwgAiABNgIIIAIoAgwgAigCCDYCYAsYAQF/IwBBEGsiASAANgIMIAEoAgwoAmALJAEBfyMAQRBrIgIgADYCDCACIAE2AgggAigCDCACKAIINgJcCxgBAX8jAEEQayIBIAA2AgwgASgCDCgCXAskAQF/IwBBEGsiAiAANgIMIAIgATYCCCACKAIMIAIoAgg2AlQLJAEBfyMAQRBrIgIgADYCDCACIAE4AgggAigCDCACKgIIOAJQCxgBAX8jAEEQayIBIAA2AgwgASgCDCoCUAskAQF/IwBBEGsiAiAANgIMIAIgATgCCCACKAIMIAIqAgg4AiwLGAEBfyMAQRBrIgEgADYCDCABKAIMKgIsC3gBAX8jAEHwAGsiAiQAIAIgADYCbCACIAE2AmggAigCbCEAIwBBEGsiASACKAJoNgIMIAIgASgCDCgCBDYCZCACKAJkIQEgAkEAQeAAEAsaIAIQqAMgACABIAIQvwUgAigCaCACKAJkIAAoAgwQ+AIgAkHwAGokAAsvAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDCACKAIIELEHIAJBEGokAAszAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDEGUBmogAigCCBCyByACQRBqJAALGQEBfyMAQRBrIgEgADYCDCABKAIMQZQGagsyAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDEHkBmogAigCCBB1IAJBEGokAAsZAQF/IwBBEGsiASAANgIMIAEoAgxB5AZqC30BAn8jAEGAAWsiAiQAIAIgADYCfCACIAE2AnggAigCfCEAIwBBEGsiASACKAJ4NgIMIAIgASgCDCgCBDYCdCACKAJ0IQMgAkEIaiIBQQBB6AAQCxogARDFBSAAIAMgARDEBSACKAJ4IAIoAnQgACgCDBD2AiACQYABaiQACy8BAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIAIoAggQtwcgAkEQaiQACzMBAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMQcQFaiACKAIIELgHIAJBEGokAAsZAQF/IwBBEGsiASAANgIMIAEoAgxBxAVqC2cBAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIgAgAigCCEHoABAVGiAAQegAaiACKAIIQegAahB1IABB/ABqIAIoAghB/ABqEHUgAEGQAWogAigCCEGQAWoQdSACQRBqJAALMwEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAgxBoAJqIAIoAggQuwcgAkEQaiQACxkBAX8jAEEQayIBIAA2AgwgASgCDEGgAmoLVwEBfyMAQRBrIgEkACABIAA2AggCQAJ/IwBBEGsiACABKAIINgIMIAAoAgwoAuwBQQhGCwRAIAEgASgCCDYCDAwBCyABQQA2AgwLIAFBEGokACABKAIMCy4BAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIIEL4HIQAgAkEQaiQAIAALPwEBfyMAQRBrIgMkACADIAA2AgwgAyABNgIIIAMgAjYCBCADKAIMIAMoAgggAygCBBCPBSEAIANBEGokACAACz8BAX8jAEEQayIDJAAgAyAANgIMIAMgATYCCCADIAI2AgQgAygCDCADKAIIIAMoAgQQ7AIhACADQRBqJAAgAAs3AQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDCACKAIIQYDAABDsAiEAIAJBEGokACAACy8BAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIAIoAggQkAUgAkEQaiQACy8BAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIAIoAggQkQUgAkEQaiQACy8BAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIAIoAggQkgUgAkEQaiQACy8BAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIAIoAggQ/gEgAkEQaiQAC2QBAX8jAEEQayIDJAAgAyAANgIMIAMgATYCCCADIAI4AgQgAygCDCIAKALQBSADKAIIQegAbGpDAACAPyADKgIEIgKVQwAAAAAgAkMAAAAAXhs4AlggAEEBOgCcByADQRBqJAALPgEBfyMAQRBrIgMkACADIAA2AgwgAyABOAIIIAMgAjoAByADKAIMIAMqAgggAy0AB0EBcRCVBSADQRBqJAALKQIBfwF9IwBBEGsiASQAIAEgADYCDCABKAIMEJYFIQIgAUEQaiQAIAILOwEBfyMAQRBrIgMkACADIAA2AgwgAyABNgIIIAMgAjYCBCADKAIMIAMoAgggAygCBBDuAiADQRBqJAALOwEBfyMAQRBrIgMkACADIAA2AgwgAyABNgIIIAMgAjYCBCADKAIMIAMoAgggAygCBBCZBSADQRBqJAALLwEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAgwgAigCCBCaBSACQRBqJAALVgEBfyMAQSBrIgUkACAFIAA2AhwgBSABNgIYIAUgAjYCFCAFIAM6ABMgBSAEOAIMIAUoAhwgBSgCGCAFKAIUIAUtABNBAXEgBSoCDBCcBSAFQSBqJAALXwEBfyMAQSBrIgYkACAGIAA2AhwgBiABNgIYIAYgAjYCFCAGIAM2AhAgBiAENgIMIAYgBTYCCCAGKAIcIAYoAhggBigCFCAGKAIQIAYoAgwgBigCCBCdBSAGQSBqJAALUgEBfyMAQSBrIgUkACAFIAA2AhwgBSABNgIYIAUgAjYCFCAFIAM2AhAgBSAENgIMIAUoAhwgBSgCGCAFKAIUIAUoAhAgBSgCDBA2IAVBIGokAAtVAQF/IwBBIGsiBSQAIAUgADYCHCAFIAE2AhggBSACNgIUIAUgAzYCECAFIAQ6AA8gBSgCHCAFKAIYIAUoAhQgBSgCECAFLQAPQQFxECMgBUEgaiQACzsBAX8jAEEQayIDJAAgAyAANgIMIAMgATYCCCADIAI4AgQgAygCDCADKAIIIAMqAgQQowUgA0EQaiQACycBAX8jAEEQayIBJAAgASAANgIMIAEoAgwQ8gIhACABQRBqJAAgAAtOAQF/IwBBEGsiBCQAIAQgADYCDCAEIAE2AgggBCACNgIEIAQgAzYCACAEKAIMIAQoAgggBCgCBCAEKAIAEKQFQQFxIQAgBEEQaiQAIAALQgEBfyMAQRBrIgMkACADIAA2AgwgAyABNgIIIAMgAjYCBCADKAIMIAMoAgggAygCBBClBUEBcSEAIANBEGokACAAC1ABAX8jAEEQayIEJAAgBCAANgIMIAQgATYCCCAEIAI2AgQgBCADNgIAQeQJEA0iACAEKAIMIAQoAgggBCgCBCAEKAIAEGoaIARBEGokACAAC0QBAX8jAEEQayIDJAAgAyAANgIMIAMgATYCCCADIAI2AgRBgAEQDSIAIAMoAgwgAygCCCADKAIEEJkMIANBEGokACAACycBAX8jAEEQayICIAA2AgwgAiABOgALIAIoAgwgAi0AC0EBcToAVAsbAQF/IwBBEGsiASAANgIMIAEoAgwtAFRBAXELPAEBfyMAQRBrIgEkACABIAA2AgwjAEEQayIAIAEoAgw2AgwgACgCDCIAIAAoAgRBf2o2AgQgAUEQaiQACy8BAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIAIoAggQpgMgAkEQaiQAC4kBAQJ/IwBBEGsiASQAIAFBhNYBNgIMIAEgADYCCCABKAIMIgAgASgCCCICKQIANwIAIAAgAigCGDYCGCAAIAIpAhA3AhAgACACKQIINwIIIABBHGogASgCCEEcahCVAiAAIAEoAggiAikCTDcCTCAAIAIoAlw2AlwgACACKQJUNwJUIAFBEGokAAuAAQEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIAkBB5NYBLQAAQQFxDQBB5NYBEBBFDQBBhNYBEKgDQeTWARAPCwJ/IAIoAgghASMAQRBrIgAgAigCDDYCDCAAIAE2AgggACgCDCgCDCAAKAIIQeAAbGoLENsHIAJBEGokAEGE1gELEAEBf0HEARANIgAQ2gQgAAuUAQEBfyMAQTBrIgIkACACIAA2AiwgAiABNgIoIAIoAiwhACMAQRBrIgEgAigCKDYCDCACIAEoAgwoAgQ2AiQgAigCJCEBIAJCADcCACACQQA2AiAgAkIANwIYIAJCADcCECACQgA3AgggAhCzAyAAIAEgAhDLBSACEI4BIAIoAiggAigCJCAAKAIMEPwCIAJBMGokAAsvAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDCACKAIIEN4HIAJBEGokAAsyAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDEEYaiACKAIIEN8HIAJBEGokAAsyAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDEEEaiACKAIIEJkCIAJBEGokAAs9AQJ/IwBBEGsiASQAIAEgADYCDEE4EA0iAiIAIAEoAgwQtgIgAEECNgI0IABB+KMBNgIAIAFBEGokACACCz0BAn8jAEEQayIBJAAgASAANgIMQTgQDSICIgAgASgCDBC2AiAAQQA2AjQgAEGQowE2AgAgAUEQaiQAIAILNgEBfyMAQRBrIgEkACABIAA2AgwjAEEQayIAIAEoAgw2AgwgACgCDCgCWCEAIAFBEGokACAAC0IBAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIgAgACgChAJBAWo2AoQCIABBBGogAigCCBBzIAJBEGokAAtMAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCCCEBIwBBEGsiACACKAIMNgIMIAAgATYCCCAAKAIMIAAoAgg2AlggAkEQaiQAC0wBAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIIIQEjAEEQayIAIAIoAgw2AgwgACABNgIIIAAoAgwgACgCCDYCVCACQRBqJAALGAEBfyMAQRBrIgEgADYCDCABKAIMKAJUCzYBAX8jAEEQayIBJAAgASAANgIMIwBBEGsiACABKAIMNgIMIAAoAgwoAlQhACABQRBqJAAgAAueAgEDfyMAQRBrIgIkACACIAE2AgwgAiACKAIMIgEoAnRBBGo2AgggAAJ/IwBBEGsiBCACKAIINgIMIwBBEGsiACAEKAIMNgIMIABBADYCCCMAQRBrIgMgACgCDCAAKAIIQQR0ajYCDCADKAIMIAEoAoABQQJ0agsCfyMAQRBrIgQgAigCCDYCDCMAQRBrIgAgBCgCDDYCDCAAQQE2AggjAEEQayIDIAAoAgwgACgCCEEEdGo2AgwgAygCDCABKAKAAUECdGoLAn8jAEEQayIEIAIoAgg2AgwjAEEQayIAIAQoAgw2AgwgAEECNgIIIwBBEGsiAyAAKAIMIAAoAghBBHRqNgIMIAMoAgwgASgCgAFBAnRqCxAJIAJBEGokAAtuAQF/IwBBIGsiASQAIAEgADYCHAJAQYDWAS0AAEEBcQ0AQYDWARAQRQ0AIwBBEGtB8NUBNgIMQYDWARAPCyABQQhqIAEoAhwQ6gdB8NUBIAEpAgg3AgBB+NUBIAEpAhA3AgAgAUEgaiQAQfDVAQs3AQF/IwBBEGsiASQAIAEgADYCDCMAQRBrIgAgASgCDDYCDCAAKAIMKAKAASEAIAFBEGokACAACzYBAX8jAEEQayIBJAAgASAANgIMIwBBEGsiACABKAIMNgIMIAAoAgwoAnwhACABQRBqJAAgAAs2AQF/IwBBEGsiASQAIAEgADYCDCMAQRBrIgAgASgCDDYCDCAAKAIMKAJ4IQAgAUEQaiQAIAALOQEBfyMAQRBrIgIkACACIAA2AgwgAiABOAIIIAIoAgwiACACKgIIIAAoAgAoAhQRCAAgAkEQaiQACyoBAX8jAEEQayICJAAgAiAANgIMIAIgATgCCCACKAIMEPwNIAJBEGokAAtMAQF/IwBBEGsiAiQAIAIgADYCDCACIAE4AgggAioCCCEBIwBBEGsiACACKAIMNgIMIAAgATgCCCAAKAIMIAAqAgg4AmggAkEQaiQACz4BAX8jAEEQayIDJAAgAyAANgIMIAMgATYCCCADIAI6AAcgAygCDCADKAIIIAMtAAdBAXEQrwEgA0EQaiQACzEBAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIAIoAghBARCvASACQRBqJAALOQEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAJBEGokACACKAIMKAKQASACKAIIQZwCbGoqAugBCyMBAX8jAEEQayIBJAAgASAANgIMIAEoAgwQ/g0gAUEQaiQACzkBAX8jAEEQayICJAAgAiAANgIMIAIgATgCCCACKAIMIgAgAioCCCAAKAIAKAIQEQgAIAJBEGokAAs1AgF/AX0jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIAIoAggQ0gQhAyACQRBqJAAgAwsmAQF/IwBBEGsiASQAIAEgADYCDCABQRBqJAAgASgCDCgCdEEEags4AgF/AX0jAEEQayIBJAAgASAANgIMIwBBEGsiACABKAIMNgIMIAAoAgwqAnAhAiABQRBqJAAgAgtRAQF/IwBBEGsiBCQAIAQgADYCDCAEIAE2AgggBCACNgIEIAQgAzYCACAEKAIMIgAgBCgCCCAEKAIEIAQoAgAgACgCACgCGBEEACAEQRBqJAALRQEBfyMAQRBrIgMkACADIAA2AgwgAyABOAIIIAMgAjYCBCADKAIMKAKQASADKAIEQZwCbGogAyoCCDgCgAIgA0EQaiQACzUBAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACQRBqJAAgAigCDCgCkAEgAigCCEGcAmxqCzYBAX8jAEEQayIBJAAgASAANgIMIwBBEGsiACABKAIMNgIMIAAoAgwoAnQhACABQRBqJAAgAAs6AQF/IwBBEGsiASQAIAEgADYCDCMAQRBrIgAgASgCDEGEAWo2AgwgACgCDCgCBCEAIAFBEGokACAACycBAX8jAEEQayIBJAAgASAANgIMIAEoAgwQ/gchACABQRBqJAAgAAt+AQF/IwBBIGsiCCQAIAggADYCHCAIIAE2AhggCCACNgIUIAggAzYCECAIIAQ4AgwgCCAFOAIIIAggBjYCBCAIIAc6AAMgCCgCHCAIKAIYIAgoAhQgCCgCECAIKgIMIAgqAgggCCgCBCAILQADQQFxEP8NIQAgCEEgaiQAIAALPgEBfyMAQRBrIgMkACADIAA2AgwgAyABNgIIIAMgAjoAByADKAIMIAMoAgggAy0AB0EBcRDQAiADQRBqJAALOQEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAJBEGokACACKAIMKAKQASACKAIIQZwCbGpB3ABqC0UBAX8jAEEQayIDJAAgAyAANgIMIAMgATgCCCADIAI2AgQgAygCDCgCkAEgAygCBEGcAmxqIAMqAgg4AugBIANBEGokAAtFAQF/IwBBEGsiAyQAIAMgADYCDCADIAE4AgggAyACNgIEIAMoAgwoApABIAMoAgRBnAJsaiADKgIIOAL8ASADQRBqJAALPwEBfyMAQRBrIgMkACADIAA2AgwgAyABNgIIIAMgAjYCBEGYARASIgAgAygCCCADKAIEEIEOIANBEGokACAAC1QBAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIIIQEjAEEQayIAIAIoAgw2AgwgACABNgIIIAAoAgwoAgwgACgCCEEEdGohACACQRBqJAAgAAs1AQF/IwBBEGsiAiAANgIMIAIgATYCCCACKAIMIgAgAigCCCIBKQIANwJMIAAgASkCCDcCVAsZAQF/IwBBEGsiASAANgIMIAEoAgxBzABqCzIBAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMQRxqIAIoAggQlQIgAkEQaiQACw8BAX9BGBASIgAQgQIgAAuDAQEBfyMAQSBrIgMkACADIAA2AhwgAyABNgIYIAMgAjgCFAJAQezVAS0AAEEBcQ0AQezVARAQRQ0AIwBBEGtB3NUBNgIMQezVARAPCyADIAMoAhwgAygCGCADKgIUEOUEQdzVASADKQIANwIAQeTVASADKQIINwIAIANBIGokAEHc1QELXAEBfyMAQSBrIgUkACAFIAA2AhwgBSABNgIYIAUgAjYCFCAFIAM2AhAgBSAENgIMIAUoAhwiACAFKAIYIAUoAhQgBSgCEBAJIAAgBSgCDCoCADgCDCAFQSBqJAALTAECfyMAQRBrIgQkACAEIAA4AgwgBCABOAIIIAQgAjgCBCAEIAM4AgBBEBANIgUgBEEMaiAEQQhqIARBBGogBBCMCCAEQRBqJAAgBQsPAQF/QRAQDSIAEC8aIAALJQEBfyMAQRBrIgIgADYCDCACIAE4AgggAigCDCACKgIIOAKYAgsZAQF/IwBBEGsiASAANgIMIAEoAgwqApgCCyUBAX8jAEEQayICIAA2AgwgAiABOAIIIAIoAgwgAioCCDgCkAILGQEBfyMAQRBrIgEgADYCDCABKAIMKgKQAgslAQF/IwBBEGsiAiAANgIMIAIgATgCCCACKAIMIAIqAgg4AowCCxkBAX8jAEEQayIBIAA2AgwgASgCDCoCjAILJQEBfyMAQRBrIgIgADYCDCACIAE4AgggAigCDCACKgIIOAKAAgsZAQF/IwBBEGsiASAANgIMIAEoAgwqAoACCyUBAX8jAEEQayICIAA2AgwgAiABOAIIIAIoAgwgAioCCDgC8AELGQEBfyMAQRBrIgEgADYCDCABKAIMKgLwAQslAQF/IwBBEGsiAiAANgIMIAIgATgCCCACKAIMIAIqAgg4AuwBCzYBAX8jAEEQayICIAA2AgwgAiABOAIIIAIoAgwiACAAKAKEAkEBajYChAIgACACKgIIOALoAQsZAQF/IwBBEGsiASAANgIMIAEoAgwqAuwBCzcBAX8jAEEQayICIAA2AgwgAiABNgIIIAIoAgwiACACKAIIIgEpAgA3ArwBIAAgASkCCDcCxAELGQEBfyMAQRBrIgEgADYCDCABKAIMQbwBags3AQF/IwBBEGsiAiAANgIMIAIgATYCCCACKAIMIgAgAigCCCIBKQIANwKsASAAIAEpAgg3ArQBCxkBAX8jAEEQayIBIAA2AgwgASgCDEGsAWoLMgEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAgxB3ABqIAIoAggQcyACQRBqJAALNwEBfyMAQRBrIgIgADYCDCACIAE2AgggAigCDCIAIAIoAggiASkCADcCnAEgACABKQIINwKkAQsZAQF/IwBBEGsiASAANgIMIAEoAgxBnAFqCzIBAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIAIoAghB3AAQFRogAkEQaiQACygBAX8jAEEQayICIAA2AgwgAiABOgALIAIoAgwgAi0AC0EBcToAhAILHAEBfyMAQRBrIgEgADYCDCABKAIMLQCEAkEBcQslAQF/IwBBEGsiAiAANgIMIAIgATgCCCACKAIMIAIqAgg4ApQCCxkBAX8jAEEQayIBIAA2AgwgASgCDCoClAILJQEBfyMAQRBrIgIgADYCDCACIAE4AgggAigCDCACKgIIOALQAQsZAQF/IwBBEGsiASAANgIMIAEoAgwqAtABCyUBAX8jAEEQayICIAA2AgwgAiABOAIIIAIoAgwgAioCCDgC+AELGQEBfyMAQRBrIgEgADYCDCABKAIMKgL4AQslAQF/IwBBEGsiAiAANgIMIAIgATgCCCACKAIMIAIqAgg4AugBCyUBAX8jAEEQayICIAA2AgwgAiABOAIIIAIoAgwgAioCCDgC4AELJQEBfyMAQRBrIgIgADYCDCACIAE4AgggAigCDCACKgIIOALcAQs2AQF/IwBBEGsiAiAANgIMIAIgATgCCCACKAIMIgAgACgChAJBAWo2AoQCIAAgAioCCDgC4AELGQEBfyMAQRBrIgEgADYCDCABKAIMKgLcAQslAQF/IwBBEGsiAiAANgIMIAIgATgCCCACKAIMIAIqAgg4AtQBCxkBAX8jAEEQayIBIAA2AgwgASgCDCoC1AELJQEBfyMAQRBrIgIgADYCDCACIAE4AgggAigCDCACKgIIOALMAQsZAQF/IwBBEGsiASAANgIMIAEoAgwqAswBCyUBAX8jAEEQayICIAA2AgwgAiABOAIIIAIoAgwgAioCCDgC9AELGQEBfyMAQRBrIgEgADYCDCABKAIMKgL0AQslAQF/IwBBEGsiAiAANgIMIAIgATgCCCACKAIMIAIqAgg4AvwBCxkBAX8jAEEQayIBIAA2AgwgASgCDCoC/AELJQEBfyMAQRBrIgIgADYCDCACIAE4AgggAigCDCACKgIIOALkAQslAQF/IwBBEGsiAiAANgIMIAIgATgCCCACKAIMIAIqAgg4AtgBCxkBAX8jAEEQayIBIAA2AgwgASgCDCoC2AELNgEBfyMAQRBrIgMkACADIAA2AgwgAyABNgIIIAMgAjYCBCADKAIMIAMoAggQhQ4gA0EQaiQACyQBAX8jAEEQayIBJAAgASAANgIMIAFBEGokACABKAIMKgLMAQtfAQF/IwBBEGsiASQAIAEgADYCDCMAQRBrIAEoAgwiADYCDCMAQRBrIABBEGo2AgwjAEEQayAAQSRqNgIMIwBBEGsgAEE0ajYCDCMAQRBrIABBxABqNgIMIAFBEGokAAvzAgEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAgwiABC+CCAAQdwAahCbASMAQRBrIABBnAFqNgIMIwBBEGsgAEGsAWo2AgwjAEEQayAAQbwBajYCDCAAIAIoAggqAjA4AswBIAAgAigCCCoCNDgC0AEgACACKAIIKgI4OALUASAAIAIoAggqAjw4AtgBIAAgAigCCCoCQDgC3AEgACACKAIIKgJEOALgASAAIAIoAggiASkCADcCnAEgACABKQIINwKkASAAIAIoAggiASkCEDcCrAEgACABKQIYNwK0ASAAIAIoAggiASkCIDcCvAEgACABKQIoNwLEASAAIAIoAggqAkg4AuQBIABDAAAAADgC6AEgAEMAAAAAOAL8ASAAQwAAAAA4AuwBIABDAAAAADgC8AEgAEMAAAAAOAKAAiAAQ83MzD04AvQBIAAgAigCCC0AUEEBcToAhAIgACACKAIIKgJMOAL4ASACQRBqJAALLAEBfyMAQRBrIgEkACABIAA2AgxBnAIQEiIAIAEoAgwQvwggAUEQaiQAIAALMQEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAgxBBGogAigCCBBzIAJBEGokAAs4AQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AghByAEQDSIAIAIoAgwgAigCCBCXAiACQRBqJAAgAAs2AQF/IwBBEGsiAiAANgIMIAIgATgCCCACKAIMIgAgACgChAJBAWo2AoQCIAAgAioCCDgC5AELLwEBfyMAQRBrIgEkACABIAA2AgxByAEQDSIAIAEoAgwQmAIQlwIgAUEQaiQAIAALxAEBAX8jAEEwayIAJAACQEGE2QEtAABBAXENAEGE2QEQEEUNACAAQwAAgD84AiwgAEMAAAAAOAIoIABDAAAAADgCJCAAQwAAAAA4AiAgAEMAAIA/OAIcIABDAAAAADgCGCAAQwAAAAA4AhQgAEMAAAAAOAIQIABDAACAPzgCDEHU2AEgAEEsaiAAQShqIABBJGogAEEgaiAAQRxqIABBGGogAEEUaiAAQRBqIABBDGoQhAJBhNkBEA8LIABBMGokAEHU2AELFgEBf0HIARANIgAQmAIQmAIQlwIgAAsvAQF/IwBBEGsiASQAIAEgADYCDCABKAIMIgAEQCAAEL4MIAAQzwILIAFBEGokAAtGAQF/IwBBEGsiASQAIAEgADYCDCMAQRBrIgAgASgCDDYCDCAAQQA2AgggACgCDCgCDCAAKAIIQQR0aiEAIAFBEGokACAACycBAX8jAEEQayIBJAAgASAANgIMIAEoAgwQyAghACABQRBqJAAgAAsjAQF/IwBBEGsiASQAIAEgADYCDCABQRBqJAAgASgCDCgCBAsxAQF/IwBBEGsiAiQAIAIgADYCDCACIAE4AgggAigCDBC9DEEBcSEAIAJBEGokACAACysBAX8jAEEQayIBJAAgASAANgIMQTAQDSIAIAEoAgwQvwwgAUEQaiQAIAALNgEBfyMAQRBrIgEkACABIAA2AgwjAEEQayIAIAEoAgw2AgwgACgCDCgCCCEAIAFBEGokACAACzYBAX8jAEEQayIBJAAgASAANgIMIwBBEGsiACABKAIMNgIMIAAoAgwoAgwhACABQRBqJAAgAAtRAQF/IwBBEGsiASAANgIMIAEoAgwiAEP2KLxAOAIAIABD4XpUPzgCBCAAQ65HYT84AgggAEMAAPpDOAIMIABDAAAoQTgCECAAQwCAu0U4AhQLDwEBf0EYEBIiABDPCCAACxkBAX8jAEEQayIBIAA2AgwgASgCDCoC6AELIgEBfyMAQRBrIgEkACABIAA2AgwgASgCDBBhIAFBEGokAAtAAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDCIAIAIoAgggACgCACgCXBEDAEEBcSEAIAJBEGokACAACzEBAX8jAEEQayIBJAAgASAANgIMIAEoAgwiACAAKAIAKAJgEQEAIQAgAUEQaiQAIAALPgEBfyMAQRBrIgMkACADIAA2AgwgAyABNgIIIAMgAjoAByADKAIMIAMoAgggAy0AB0EBcRCMBCADQRBqJAALMQEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAgwgAigCCEEBEIwEIAJBEGokAAs4AQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AghB8AAQDSIAIAIoAgwgAigCCBDZASACQRBqJAAgAAsuAQF/IwBBEGsiASQAIAEgADYCDEHwABANIgAgASgCDEEAENkBIAFBEGokACAACxQBAX9B8AAQDSIAQQBBABDZASAACzYBAX8jAEEQayIBJAAgASAANgIMIwBBEGsiACABKAIMNgIMIAAoAgxBFGohACABQRBqJAAgAAsvAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDCACKAIIENYBIAJBEGokAAtCAQF/IwBBEGsiAyQAIAMgADYCDCADIAE2AgggAyACOgAHIAMoAgwgAygCCCADLQAHQQFxENUBIQAgA0EQaiQAIAALVgEBfyMAQSBrIgUkACAFIAA2AhwgBSABNgIYIAUgAjYCFCAFIAM2AhAgBSAEOgAPIAUoAhwgBSgCGCAFKAIUIAUoAhAgBS0AD0EBcRD6AyAFQSBqJAALSQEBfyMAQRBrIgQkACAEIAA2AgwgBCABNgIIIAQgAjYCBCAEIAM2AgAgBCgCDCAEKAIIIAQoAgQgBCgCAEEAEPoDIARBEGokAAs+AQF/IwBBEGsiAiQAIAIgADoADyACIAE6AA5BrAEQDSIAIAItAA9BAXEgAi0ADkEBcRC1AiACQRBqJAAgAAsxAQF/IwBBEGsiASQAIAEgADoAD0GsARANIgAgAS0AD0EBcUEBELUCIAFBEGokACAACxQBAX9BrAEQDSIAQQFBARC1AiAACzgBAn8jAEEQayICJAAgAiAAOAIMIAIgATgCCEHMABANIgMgAioCDCACKgIIEKsMIAJBEGokACADCzgBAn8jAEEQayICJAAgAiAAOAIMIAIgATgCCEHMABANIgMgAioCDCACKgIIEKwMIAJBEGokACADCzsBAX8jAEEQayIDJAAgAyAANgIMIAMgATgCCCADIAI4AgQgAygCDCADKgIIIAMqAgQQmg4gA0EQaiQAC00BAX8jAEEQayICJAAgAiAANgIMIAIgATgCCCACKgIIIQEjAEEQayIAIAIoAgw2AgwgACABOAIIIAAoAgwgACoCCDgCrAUgAkEQaiQACxkBAX8jAEEQayIBIAA2AgwgASgCDCoC4AELUwEBfyMAQRBrIgIkACACIAA2AgwgAiABOgALIAItAAtBAXEhASMAQRBrIgAgAigCDDYCDCAAIAE6AAsgACgCDCAALQALQQFxOgDhBSACQRBqJAALUwEBfyMAQRBrIgIkACACIAA2AgwgAiABOgALIAItAAtBAXEhASMAQRBrIgAgAigCDDYCDCAAIAE6AAsgACgCDCAALQALQQFxOgDgBSACQRBqJAALTgEBfyMAQRBrIgQgADYCDCAEIAE6AAsgBCACOAIEIAQgAzgCACAEKAIMIgAgBC0AC0EBcToA4QUgACAEKgIEOAKoBSAAIAQqAgA4AqwFC0oBAX8jAEEQayIEJAAgBCAANgIMIAQgAToACyAEIAI4AgQgBCADOAIAIAQoAgwgBC0AC0EBcSAEKgIEIAQqAgAQ6QggBEEQaiQAC18BAX8jAEEgayIGJAAgBiAANgIcIAYgATgCGCAGIAI4AhQgBiADOAIQIAYgBDgCDCAGIAU4AgggBigCHCAGKgIYIAYqAhQgBioCECAGKgIMIAYqAggQsgMgBkEgaiQAC1gBAX8jAEEgayIFJAAgBSAANgIcIAUgATgCGCAFIAI4AhQgBSADOAIQIAUgBDgCDCAFKAIcIAUqAhggBSoCFCAFKgIQIAUqAgxDAACAPxCyAyAFQSBqJAALdwEBfyMAQSBrIgckACAHIAA2AhwgByABNgIYIAcgAjYCFCAHIAM2AhAgByAENgIMIAcgBTYCCCAHIAY6AAdB/AUQDSIAIAcoAhwgBygCGCAHKAIUIAcoAhAgBygCDCAHKAIIIActAAdBAXEQ3gQgB0EgaiQAIAALagEBfyMAQSBrIgYkACAGIAA2AhwgBiABNgIYIAYgAjYCFCAGIAM2AhAgBiAENgIMIAYgBTYCCEH8BRANIgAgBigCHCAGKAIYIAYoAhQgBigCECAGKAIMIAYoAghBABDeBCAGQSBqJAAgAAtfAQF/IwBBIGsiBSQAIAUgADYCHCAFIAE2AhggBSACNgIUIAUgAzYCECAFIAQ6AA9B/AUQDSIAIAUoAhwgBSgCGCAFKAIUIAUoAhAgBS0AD0EBcRDdBCAFQSBqJAAgAAtSAQF/IwBBEGsiBCQAIAQgADYCDCAEIAE2AgggBCACNgIEIAQgAzYCAEH8BRANIgAgBCgCDCAEKAIIIAQoAgQgBCgCAEEAEN0EIARBEGokACAAC0cBAX8jAEEQayIDJAAgAyAANgIMIAMgATYCCCADIAI6AAdB/AUQDSIAIAMoAgwgAygCCCADLQAHQQFxENwEIANBEGokACAACzoBAX8jAEEQayICJAAgAiAANgIMIAIgATYCCEH8BRANIgAgAigCDCACKAIIQQAQ3AQgAkEQaiQAIAALLwEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAgwgAigCCBDfBCACQRBqJAALLwEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAgwgAigCCBClDiACQRBqJAALVwECfyMAQRBrIgIkACACIAA2AgwgAiABOAIIIAIqAgghASMAQRBrIgAgAigCDDYCDCAAIAE4AgggACgCDCIDIAAqAgg4ArwEIANBAToAqQQgAkEQaiQAC1cBAn8jAEEQayICJAAgAiAANgIMIAIgATgCCCACKgIIIQEjAEEQayIAIAIoAgw2AgwgACABOAIIIAAoAgwiAyAAKgIIOAK8BCADQQA6AKkEIAJBEGokAAtTAQF/IwBBEGsiAiQAIAIgADYCDCACIAE6AAsgAi0AC0EBcSEBIwBBEGsiACACKAIMNgIMIAAgAToACyAAKAIMIAAtAAtBAXE6AKgEIAJBEGokAAtNAQF/IwBBEGsiAiQAIAIgADYCDCACIAE4AgggAioCCCEBIwBBEGsiACACKAIMNgIMIAAgATgCCCAAKAIMIAAqAgg4ArgDIAJBEGokAAtTAQF/IwBBEGsiAiQAIAIgADYCDCACIAE6AAsgAi0AC0EBcSEBIwBBEGsiACACKAIMNgIMIAAgAToACyAAKAIMIAAtAAtBAXE6AIwEIAJBEGokAAsZAQF/IwBBEGsiASAANgIMIAEoAgwqAuQBC28BAX8jAEEQayIDIAA2AgwgAyABNgIIIAMgAjgCBCADKAIMIQACQCADKAIIQX1qIgFBAksNAAJAAkACQCABQQFrDgIBAgALIAAgAyoCBDgCxAMMAgsgACADKgIEOALAAwwBCyAAIAMqAgQ4ArwDCws7AQF/IwBBEGsiAyQAIAMgADYCDCADIAE2AgggAyACOAIEIAMoAgwgAygCCCADKgIEEPsIIANBEGokAAtQAQF/IwBBEGsiBCQAIAQgADYCDCAEIAE2AgggBCACNgIEIAQgAzYCAEHgBBANIgAgBCgCDCAEKAIIIAQoAgQgBCgCABCsDiAEQRBqJAAgAAs4AQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AghB4AQQDSIAIAIoAgwgAigCCBCrDiACQRBqJAAgAAsmAQF/IwBBEGsiASQAIAEgADYCDCABKAIMQThqEI4BIAFBEGokAAsuAQF/IwBBEGsiASQAIAEgADYCDCABKAIMIgAEQCAAEP8IIAAQDgsgAUEQaiQACyQBAX8jAEEQayICIAA2AgwgAiABNgIIIAIoAgwgAigCCDYCJAsYAQF/IwBBEGsiASAANgIMIAEoAgwoAiQLJAEBfyMAQRBrIgIgADYCDCACIAE2AgggAigCDCACKAIINgIgCzQBAX8jAEEQayIBJAAgASAANgIMIAEoAgwoAkQiACAAKAIAKAIkEQEAIQAgAUEQaiQAIAALGAEBfyMAQRBrIgEgADYCDCABKAIMKAIgC8YBAQF/IwBBIGsiASQAIAEgADYCHCABKAIcIgBDmpmZPzgCACAAQwAAAAA4AgQgAEMAAAAAOAIIIABDAAB6RDgCDCABQwAAAAA4AhggAUMAAAAAOAIUIAFDAAAAADgCECAAQRBqIAFBGGogAUEUaiABQRBqEAkgAEEANgIgIABBADYCJCABQwAAAAA4AgwgAUMAACDBOAIIIAFDAAAAADgCBCAAQShqIAFBDGogAUEIaiABQQRqEAkgAEE4ahCzAyABQSBqJAALEAEBf0HkABASIgAQhgkgAAtkAQF/IwBBIGsiBSQAIAUgADYCHCAFIAE2AhggBSACNgIUIAUgAzYCECAFIAQ6AA9B9AAQDSIAIAUoAhwgBSgCGCAFKAIUQf//A3EgBSgCECAFLQAPQQFxENQBIAVBIGokACAAC1cBAX8jAEEQayIEJAAgBCAANgIMIAQgATYCCCAEIAI2AgQgBCADNgIAQfQAEA0iACAEKAIMIAQoAgggBCgCBEH//wNxIAQoAgBBABDUASAEQRBqJAAgAAtNAQF/IwBBEGsiAyQAIAMgADYCDCADIAE2AgggAyACNgIEQfQAEA0iACADKAIMIAMoAgggAygCBEH//wNxQQBBABDUASADQRBqJAAgAAtAAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AghB9AAQDSIAIAIoAgwgAigCCEGAgAFBAEEAENQBIAJBEGokACAACywBAX8jAEEQayIBJAAgASAANgIMQYwpEBIiACABKAIMEMwNIAFBEGokACAACw8BAX9BKBASIgAQ9QIgAAuPAQEBfyMAQTBrIgkkACAJIAA2AiwgCSABNgIoIAkgAjYCJCAJIAM4AiAgCSAEOAIcIAkgBTgCGCAJIAY2AhQgCSAHNgIQIAkgCDoAD0H8ABANIgAgCSgCLCAJKAIoIAkoAiQgCSoCICAJKgIcIAkqAhggCSgCFCAJKAIQIAktAA9BAXEQpwsgCUEwaiQAIAALEgEBf0HEARASIgBBABDtAyAAC1QBAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIIIQEjAEEQayIAIAIoAgw2AgwgACABNgIIIAAoAgwoAgwgACgCCEEFdGohACACQRBqJAAgAAuMAQEBfyMAQSBrIgEkACABIAA2AhwgASgCHCEAIAFDAAAAADgCGCABQwAAAAA4AhQgAUMAAAAAOAIQIABBnANqIAFBGGogAUEUaiABQRBqEAkgAUMAAAAAOAIMIAFDAAAAADgCCCABQwAAAAA4AgQgAEGsA2ogAUEMaiABQQhqIAFBBGoQCSABQSBqJAALIwEBfyMAQRBrIgEkACABIAA2AgwgASgCDBCRCSABQRBqJAALLwEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAgwgAigCCBDwASACQRBqJAALNwEBfyMAQRBrIgEkACABIAA2AgwjAEEQayIAIAEoAgw2AgwgACgCDEH8AmohACABQRBqJAAgAAsjAQF/IwBBEGsiASQAIAEgADYCDCABKAIMEPgEIAFBEGokAAtQAQF/IwBBEGsiAyQAIAMgADYCDCADIAE2AgggAyACNgIEIAMoAgwiACgCwAEiASAAQQRqIAMoAgggAygCBCABKAIAKAIIEQQAIANBEGokAAtXAQF/IwBBEGsiASQAIAEgADYCCAJAAn8jAEEQayIAIAEoAgg2AgwgACgCDCgC7AFBAnELBEAgASABKAIINgIMDAELIAFBADYCDAsgAUEQaiQAIAEoAgwLLgEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAggQlwkhACACQRBqJAAgAAtGAQF/IwBBEGsiAiAANgIMIAIgATYCCCACKAIMIgAgACgChAJBAWo2AoQCIAAgAigCCCIBKQIANwKgBCAAIAEpAgg3AqgECy8BAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIAIoAggQmQkgAkEQaiQACzcBAX8jAEEQayIBJAAgASAANgIMIwBBEGsiACABKAIMNgIMIAAoAgxBoARqIQAgAUEQaiQAIAALUgEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAgwiACACKAIINgLgAyAAKALgAwRAIAIoAggiASAAQQRqIAEoAgAoAggRAgALIAJBEGokAAsvAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDCACKAIIEJwJIAJBEGokAAs3AQF/IwBBEGsiASQAIAEgADYCDCMAQRBrIgAgASgCDDYCDCAAKAIMKALgAyEAIAFBEGokACAAC0YBAX8jAEEQayICIAA2AgwgAiABNgIIIAIoAgwiACAAKAKEAkEBajYChAIgACACKAIIIgEpAgA3AsgCIAAgASkCCDcC0AILLwEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAgwgAigCCBCfCSACQRBqJAALRgEBfyMAQRBrIgIgADYCDCACIAE2AgggAigCDCIAIAAoAoQCQQFqNgKEAiAAIAIoAggiASkCADcCuAIgACABKQIINwLAAgsvAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDCACKAIIEKEJIAJBEGokAAs3AQF/IwBBEGsiASQAIAEgADYCDCMAQRBrIgAgASgCDDYCDCAAKAIMQcgCaiEAIAFBEGokACAACzcBAX8jAEEQayIBJAAgASAANgIMIwBBEGsiACABKAIMNgIMIAAoAgxBuAJqIQAgAUEQaiQAIAALIwEBfyMAQRBrIgEkACABIAA2AgwgASgCDBDeAiABQRBqJAALLwEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAgwgAigCCBC0AyACQRBqJAALOgEBfyMAQRBrIgMkACADIAA2AgwgAyABNgIIIAMgAjYCBCADKAIMIAMoAgggAygCBBArIANBEGokAAsvAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDCACKAIIELUDIAJBEGokAAthAQN/IwBBEGsiASQAIAEgADYCDEEAIQACfyMAQRBrIgIgASgCDCIDNgIMIAIoAgwoAtgBQQJHCwRAIwBBEGsiACADNgIMIAAoAgwoAtgBQQVHIQALIAFBEGokACAAQQFxC2gBAn8jAEEwayICJAAgAiAANgIsIAIgATYCKCACQQhqIgECfyMAQRBrIgMgAigCLCIAQQRqNgIMIAMoAgwLIAIoAigQESACQRhqIgMgASAAQdwCahBRIABBnANqIAMQPxogAkEwaiQACy8BAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIAIoAggQqgkgAkEQaiQACy8BAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIAIoAggQtgMgAkEQaiQAC2MBAX8jAEEwayIDJAAgAyAANgIsIAMgATYCKCADIAI2AiQgAygCLCIAIAMoAigQtgMgAygCJCEBIAMgAygCKCAAQdwCahBRIANBEGoiAiABIAMQsAEgACACELcDIANBMGokAAs7AQF/IwBBEGsiAyQAIAMgADYCDCADIAE2AgggAyACNgIEIAMoAgwgAygCCCADKAIEEK0JIANBEGokAAtoAQJ/IwBBMGsiAiQAIAIgADYCLCACIAE2AiggAkEIaiIBAn8jAEEQayIDIAIoAiwiAEEEajYCDCADKAIMCyACKAIoEBEgAkEYaiIDIAEgAEGgBGoQUSAAQawDaiADED8aIAJBMGokAAsvAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDCACKAIIEK8JIAJBEGokAAsvAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDCACKAIIELcDIAJBEGokAAttAQF/IwBBIGsiAiQAIAIgADYCHCACIAE2AhggAigCHCIAIAIoAhgiASkCADcC3AIgACABKQIINwLkAiACQQhqIgEgAEHcAmogAEHYAmoQISAAIAEpAgA3ArAEIAAgASkCCDcCuAQgAkEgaiQACy8BAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIAIoAggQsgkgAkEQaiQACxkBAX8jAEEQayIBIAA2AgwgASgCDEHcAmoLNwEBfyMAQRBrIgEkACABIAA2AgwjAEEQayIAIAEoAgw2AgwgACgCDEHcAmohACABQRBqJAAgAAs7AQF/IwBBEGsiAyQAIAMgADYCDCADIAE4AgggAyACNgIEIAMoAgwgAyoCCCADKAIEEN0CIANBEGokAAs7AQF/IwBBEGsiAyQAIAMgADYCDCADIAE4AgggAyACOAIEIAMoAgwgAyoCCCADKgIEEI4PIANBEGokAAs5AgF/AX0jAEEQayIBJAAgASAANgIMIwBBEGsiACABKAIMNgIMIAAoAgwqAsADIQIgAUEQaiQAIAILOQIBfwF9IwBBEGsiASQAIAEgADYCDCMAQRBrIgAgASgCDDYCDCAAKAIMKgK8AyECIAFBEGokACACCzkBAX8jAEEQayIDIAA2AgwgAyABOAIIIAMgAjgCBCADKAIMIgAgAyoCCDgC2AMgACADKgIEOALcAws7AQF/IwBBEGsiAyQAIAMgADYCDCADIAE4AgggAyACOAIEIAMoAgwgAyoCCCADKgIEELoJIANBEGokAAsvAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDCACKAIIENwCIAJBEGokAAssAQF/IwBBEGsiASQAIAEgADYCDEHoBBANIgAgASgCDBCPDyABQRBqJAAgAAs9AQN/QQwQEiIBIQAjAEEQayICIAA2AgwgAigCDCIAQ5qZmT44AgAgAEMAAIA/OAIEIABDAAAAADgCCCABCzUBA39BIBANIgIiACIBQiM3AgQgAUEANgIMIAFBoJsBNgIAIABBGzYCBCAAQYSPATYCACACC1EBAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCMAQRBrIgEgAigCDCIANgIMIAEoAgxBzAo2AgAgAEH4xgA2AgAgACACKAIINgIEIAJBEGokAAsrAQF/IwBBEGsiASQAIAEgADYCDEEIEBIiACABKAIMEMAJIAFBEGokACAAC3EBAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIQAjAEEQayIBIAIoAgg2AgwgAiABKAIMKAIENgIEIAIoAgQhASACQwAAAAA4AgAgACABIAIQzAUgAigCCCACKAIEIAAoAgwQhAMgAkEQaiQACy8BAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMIAIoAggQwgkgAkEQaiQACzMBAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMQfAAaiACKAIIEMMJIAJBEGokAAsZAQF/IwBBEGsiASAANgIMIAEoAgxB8ABqCzMBAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIMQdwAaiACKAIIEJkCIAJBEGokAAtxAQF/IwBBIGsiAiQAIAIgADYCHCACIAE2AhggAigCHCEAIwBBEGsiASACKAIYNgIMIAIgASgCDCgCBDYCFCACKAIUIQEjAEEQayACNgIMIAAgASACEM0FIAIoAhggAigCFCAAKAIMEIUDIAJBIGokAAszAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDEHIAGogAigCCBCZAiACQRBqJAALbgEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAgwhACMAQRBrIgEgAigCCDYCDCACIAEoAgwoAgQ2AgQgAigCBCEBIAJBADYCACAAIAEgAhCAAyACKAIIIAIoAgQgACgCDBCFAiACQRBqJAALMQEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAgxBFGogAigCCBB1IAJBEGokAAuQAQEBfyMAQRBrIgMkACADIAA2AgwgAyABNgIIIAMgAjYCBCADKAIMIgAQvAMgAEGwCTYCACAAQRRqEJcBIAAgAygCCCIBKQIANwIoIAAgASkCCDcCMCAAIAMoAgQiASkCADcCOCAAIAEpAgg3AkAgAEHIAGoQlwEgAEHcAGoQlwEgAEHwAGoQlwEgA0EQaiQACzgBAX8jAEEQayICJAAgAiAANgIMIAIgATYCCEGEARASIgAgAigCDCACKAIIEMsJIAJBEGokACAACzUBAX8jAEEQayICIAA2AgwgAiABNgIIIAIoAgwiACACKAIIIgEpAgA3AjwgACABKQIINwJECxgBAX8jAEEQayIBIAA2AgwgASgCDEE8ags1AQF/IwBBEGsiAiAANgIMIAIgATYCCCACKAIMIgAgAigCCCIBKQIANwIsIAAgASkCCDcCNAsYAQF/IwBBEGsiASAANgIMIAEoAgxBLGoLNQEBfyMAQRBrIgIgADYCDCACIAE2AgggAigCDCIAIAIoAggiASkCADcCHCAAIAEpAgg3AiQLNQEBfyMAQRBrIgIgADYCDCACIAE2AgggAigCDCIAIAIoAggiASkCADcCDCAAIAEpAgg3AhQLNwEBfyMAQRBrIgEgADYCDCABKAIMIgBBmAk2AgAgAEMAAIA/OAIEIABBATsBCCAAQf//AzsBCguOAQEBfyMAQRBrIgMkACADIAA2AgwgAyABNgIIIAMgAjYCBCADKAIMIgAQ0wkgAEGMCDYCACAAIAMoAggiASkCADcCDCAAIAEpAgg3AhQgACADKAIEIgEpAgA3AhwgACABKQIINwIkIwBBEGsgAEEsajYCDCMAQRBrIABBPGo2AgwgAEEANgJMIANBEGokAAs4AQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AghB0AAQEiIAIAIoAgwgAigCCBDUCSACQRBqJAAgAAtKAQF/IwBBEGsiBCQAIAQgADYCDCAEIAE2AgggBCACNgIEIAQgAzoAAyAEKAIMIAQoAgggBCgCBCAELQADQQFxEJ4EIARBEGokAAs9AQF/IwBBEGsiAyQAIAMgADYCDCADIAE2AgggAyACNgIEIAMoAgwgAygCCCADKAIEQQEQngQgA0EQaiQAC1sBAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIIIQEjAEEQayIAIAIoAgxBDGo2AgwgACABNgIIIAAoAgwoAgwgACgCCEHQAGxqKAJAIQAgAkEQaiQAIAALMwEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAgwgAigCCBDYCSEAIAJBEGokACAACzkBAX8jAEEQayIBJAAgASAANgIMIwBBEGsiACABKAIMQQxqNgIMIAAoAgwoAgQhACABQRBqJAAgAAsnAQF/IwBBEGsiASQAIAEgADYCDCABKAIMENoJIQAgAUEQaiQAIAALLwEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAgwgAigCCBCdBCACQRBqJAALOwEBfyMAQRBrIgMkACADIAA2AgwgAyABNgIIIAMgAjYCBCADKAIMIAMoAgggAygCBBC6DCADQRBqJAALLwEBfyMAQRBrIgEkACABIAA6AA9B3AAQDSIAIAEtAA9BAXEQnwQgAUEQaiQAIAALEgEBf0HcABANIgBBARCfBCAAC1UBAX8jAEEQayICJAAgAiAANgIMIAIgATYCCCACKAIIIQEjAEEQayIAIAIoAgw2AgwgACABNgIIIAAoAgxBBGogACgCCEG4AWxqIQAgAkEQaiQAIAALNwEBfyMAQRBrIgEkACABIAA2AgwjAEEQayIAIAEoAgw2AgwgACgCDCgC7AUhACABQRBqJAAgAAs3AQF/IwBBEGsiASQAIAEgADYCDCMAQRBrIgAgASgCDDYCDCAAKAIMKALoBSEAIAFBEGokACAACzcBAX8jAEEQayIBJAAgASAANgIMIwBBEGsiACABKAIMNgIMIAAoAgwoAuQFIQAgAUEQaiQAIAALEAEBf0GEBhANIgAQ4w0gAAslAQF/IwBBEGsiAiAANgIMIAIgATgCCCACKAIMIAIqAgg4AogBCxkBAX8jAEEQayIBIAA2AgwgASgCDCoCiAELJQEBfyMAQRBrIgIgADYCDCACIAE4AgggAigCDCACKgIIOAKEAQsZAQF/IwBBEGsiASAANgIMIAEoAgwqAoQBCyUBAX8jAEEQayICIAA2AgwgAiABOAIIIAIoAgwgAioCCDgCgAELGQEBfyMAQRBrIgEgADYCDCABKAIMKgKAAQskAQF/IwBBEGsiAiAANgIMIAIgATgCCCACKAIMIAIqAgg4AnwLGAEBfyMAQRBrIgEgADYCDCABKAIMKgJ8CycBAX8jAEEQayICIAA2AgwgAiABOgALIAIoAgwgAi0AC0EBcToAeAsbAQF/IwBBEGsiASAANgIMIAEoAgwtAHhBAXELJAEBfyMAQRBrIgIgADYCDCACIAE4AgggAigCDCACKgIIOAJ0CxgBAX8jAEEQayIBIAA2AgwgASgCDCoCdAskAQF/IwBBEGsiAiAANgIMIAIgATgCCCACKAIMIAIqAgg4AnALGAEBfyMAQRBrIgEgADYCDCABKAIMKgJwC8sBAQF/IwBBEGsiAyQAIAMgADYCDCADIAE2AgggAyACNgIEIAMoAgwiACADKAIIIgEpAgA3AqQBIAAgASkCCDcCrAEgAwJ/IwBBEGsiASADKAIINgIMQQEgASgCDCoCAEMAAIA/XA0AGiMAQRBrIgEgAygCCDYCDEEBIAEoAgwqAgRDAACAP1wNABojAEEQayIBIAMoAgg2AgwgASgCDCoCCEMAAIA/XAtBAXE6AAMgACADKAIEQQAgAy0AA0EBcRs2ArQBIANBEGokAAskAQF/IwBBEGsiAiAANgIMIAIgATgCCCACKAIMIAIqAgg4AmwLGAEBfyMAQRBrIgEgADYCDCABKAIMKgJsCyQBAX8jAEEQayICIAA2AgwgAiABOAIIIAIoAgwgAioCCDgCaAsYAQF/IwBBEGsiASAANgIMIAEoAgwqAmgLJAEBfyMAQRBrIgIgADYCDCACIAE4AgggAigCDCACKgIIOAJkCxgBAX8jAEEQayIBIAA2AgwgASgCDCoCZAskAQF/IwBBEGsiAiAANgIMIAIgATgCCCACKAIMIAIqAgg4AmALGAEBfyMAQRBrIgEgADYCDCABKAIMKgJgC1ABAX8jAEEQayIEJAAgBCAAOAIMIAQgATYCCCAEIAI2AgQgBCADNgIAQYwBEBIiASAEKgIMIAQoAgggBCgCBCAEKAIAEL0DIARBEGokACABC4oBAQN/IwBBMGsiAyQAIAMgADgCLCADIAE2AiggAyACNgIkQYwBEBIhASADKgIsIQAgAygCKCECIAMoAiQhBCADQwAAAAA4AgwgA0MAAAAAOAIIIANDAAAAADgCBCADQRBqIgUgA0EMaiADQQhqIANBBGoQCSABIAAgAiAEIAUQvQMgA0EwaiQAIAELOwEBfyMAQRBrIgIkACACIAA2AgwgAiABOgALQeAAEA0iACACKAIMIAItAAtBAXEQhwQgAkEQaiQAIAALLgEBfyMAQRBrIgEkACABIAA2AgxB4AAQDSIAIAEoAgxBARCHBCABQRBqJAAgAAsnAQF/IwBBEGsiAiAANgIMIAIgAToACyACKAIMIAItAAtBAXE6AFALGwEBfyMAQRBrIgEgADYCDCABKAIMLQBQQQFxCycBAX8jAEEQayICIAA2AgwgAiABOgALIAIoAgwgAi0AC0EBcToAIAsbAQF/IwBBEGsiASAANgIMIAEoAgwtACBBAXELJwEBfyMAQRBrIgIgADYCDCACIAE6AAsgAigCDCACLQALQQFxOgAaCxsBAX8jAEEQayIBIAA2AgwgASgCDC0AGkEBcQsnAQF/IwBBEGsiAiAANgIMIAIgAToACyACKAIMIAItAAtBAXE6ABkLGwEBfyMAQRBrIgEgADYCDCABKAIMLQAZQQFxCycBAX8jAEEQayICIAA2AgwgAiABOgALIAIoAgwgAi0AC0EBcToAGAsbAQF/IwBBEGsiASAANgIMIAEoAgwtABhBAXELJwEBfyMAQRBrIgIgADYCDCACIAE6AAsgAigCDCACLQALQQFxOgAQCxsBAX8jAEEQayIBIAA2AgwgASgCDC0AEEEBcQskAQF/IwBBEGsiAiAANgIMIAIgATYCCCACKAIMIAIoAgg2AhALGAEBfyMAQRBrIgEgADYCDCABKAIMKAIQC0QBAn8jAEEQayIBJAAgASAANgIMIAEoAgwiAAJ/IwBBEGsiAiAANgIMIAIoAgwoAgQLEHIgABBQIAAQvQEgAUEQaiQACwcAIAARFgALCQAgASAAEQAAC1kCAX8BfSMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAgghASMAQRBrIgAgAigCDDYCDCAAIAE2AgggACgCDCgCDCAAKAIIQQJ0aioCACEDIAJBEGokACADC6kBAQN/AkAgAigCECIEBH8gBAUgAhDVAw0BIAIoAhALIAIoAhQiBWsgAUkEQCACIAAgASACKAIkEQcAGg8LAkAgAiwAS0EASA0AIAEhBANAIAQiA0UNASAAIANBf2oiBGotAABBCkcNAAsgAiAAIAMgAigCJBEHACADSQ0BIAEgA2shASAAIANqIQAgAigCFCEFCyAFIAAgARAVGiACIAIoAhQgAWo2AhQLCxsAIAAgASgCCCAFEC4EQCABIAIgAyAEEKICCws4ACAAIAEoAgggBRAuBEAgASACIAMgBBCiAg8LIAAoAggiACABIAIgAyAEIAUgACgCACgCFBEMAAuWAgEGfyAAIAEoAgggBRAuBEAgASACIAMgBBCiAg8LIAEtADUhByAAKAIMIQYgAUEAOgA1IAEtADQhCCABQQA6ADQgAEEQaiIJIAEgAiADIAQgBRChAiAHIAEtADUiCnIhByAIIAEtADQiC3IhCAJAIAZBAkgNACAJIAZBA3RqIQkgAEEYaiEGA0AgAS0ANg0BAkAgCwRAIAEoAhhBAUYNAyAALQAIQQJxDQEMAwsgCkUNACAALQAIQQFxRQ0CCyABQQA7ATQgBiABIAIgAyAEIAUQoQIgAS0ANSIKIAdyIQcgAS0ANCILIAhyIQggBkEIaiIGIAlJDQALCyABIAdB/wFxQQBHOgA1IAEgCEH/AXFBAEc6ADQLpgEAIAAgASgCCCAEEC4EQAJAIAEoAgQgAkcNACABKAIcQQFGDQAgASADNgIcCw8LAkAgACABKAIAIAQQLkUNACACIAEoAhBHQQAgASgCFCACRxtFBEAgA0EBRw0BIAFBATYCIA8LIAEgAjYCFCABIAM2AiAgASABKAIoQQFqNgIoAkAgASgCJEEBRw0AIAEoAhhBAkcNACABQQE6ADYLIAFBBDYCLAsLhwIAIAAgASgCCCAEEC4EQAJAIAEoAgQgAkcNACABKAIcQQFGDQAgASADNgIcCw8LAkAgACABKAIAIAQQLgRAIAIgASgCEEdBACABKAIUIAJHG0UEQCADQQFHDQIgAUEBNgIgDwsgASADNgIgAkAgASgCLEEERg0AIAFBADsBNCAAKAIIIgAgASACIAJBASAEIAAoAgAoAhQRDAAgAS0ANQRAIAFBAzYCLCABLQA0RQ0BDAMLIAFBBDYCLAsgASACNgIUIAEgASgCKEEBajYCKCABKAIkQQFHDQEgASgCGEECRw0BIAFBAToANg8LIAAoAggiACABIAIgAyAEIAAoAgAoAhgRCQALC7sEAQR/IAAgASgCCCAEEC4EQAJAIAEoAgQgAkcNACABKAIcQQFGDQAgASADNgIcCw8LAkAgACABKAIAIAQQLgRAIAIgASgCEEdBACABKAIUIAJHG0UEQCADQQFHDQIgAUEBNgIgDwsgASADNgIgIAEoAixBBEcEQCAAQRBqIgUgACgCDEEDdGohCCABAn8CQANAAkAgBSAITw0AIAFBADsBNCAFIAEgAiACQQEgBBChAiABLQA2DQACQCABLQA1RQ0AIAEtADQEQEEBIQMgASgCGEEBRg0EQQEhB0EBIQYgAC0ACEECcQ0BDAQLQQEhByAGIQMgAC0ACEEBcUUNAwsgBUEIaiEFDAELCyAGIQNBBCAHRQ0BGgtBAws2AiwgA0EBcQ0CCyABIAI2AhQgASABKAIoQQFqNgIoIAEoAiRBAUcNASABKAIYQQJHDQEgAUEBOgA2DwsgACgCDCEGIABBEGoiBSABIAIgAyAEEMcBIAZBAkgNACAFIAZBA3RqIQYgAEEYaiEFIAAoAggiAEECcUVBACABKAIkQQFHG0UEQANAIAEtADYNAiAFIAEgAiADIAQQxwEgBUEIaiIFIAZJDQAMAgALAAsgAEEBcUUEQANAIAEtADYNAiABKAIkQQFGDQIgBSABIAIgAyAEEMcBIAVBCGoiBSAGSQ0ADAIACwALA0AgAS0ANg0BIAEoAiRBAUZBACABKAIYQQFGGw0BIAUgASACIAMgBBDHASAFQQhqIgUgBkkNAAsLC5MBAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AggCQEHY1QEtAABBAXENAEHY1QEQEEUNACMAQRBrQcjVATYCDEHY1QEQDwsgAigCCCEBIwBBEGsiACACKAIMNgIMIAAgATYCCEHI1QEgACgCDCAAKAIIQQR0aiIAKQIANwIAQdDVASAAKQIINwIAIAJBEGokAEHI1QELbwECfyAAIAEoAghBABAuBEAgASACIAMQowIPCyAAKAIMIQQgAEEQaiIFIAEgAiADENYDAkAgBEECSA0AIAUgBEEDdGohBCAAQRhqIQADQCAAIAEgAiADENYDIAEtADYNASAAQQhqIgAgBEkNAAsLCzIAIAAgASgCCEEAEC4EQCABIAIgAxCjAg8LIAAoAggiACABIAIgAyAAKAIAKAIcEQQACxkAIAAgASgCCEEAEC4EQCABIAIgAxCjAgsLqwIBBH8jAEFAaiIBJAAgACgCACICQXxqKAIAIQMgAkF4aigCACEEIAFBADYCFCABQdzPATYCECABIAA2AgwgAUGM0AE2AghBACECIAFBGGpBAEEnEAsaIAAgBGohAAJAIANBjNABQQAQLgRAIAFBATYCOCADIAFBCGogACAAQQFBACADKAIAKAIUEQwAIABBACABKAIgQQFGGyECDAELIAMgAUEIaiAAQQFBACADKAIAKAIYEQkAIAEoAiwiAEEBSw0AIABBAWsEQCABKAIcQQAgASgCKEEBRhtBACABKAIkQQFGG0EAIAEoAjBBAUYbIQIMAQsgASgCIEEBRwRAIAEoAjANASABKAIkQQFHDQEgASgCKEEBRw0BCyABKAIYIQILIAFBQGskACACC54BAQF/IwBBQGoiAyQAAn9BASAAIAFBABAuDQAaQQAgAUUNABpBACABEJ0KIgFFDQAaIANBfzYCFCADIAA2AhAgA0EANgIMIAMgATYCCCADQRhqQQBBJxALGiADQQE2AjggASADQQhqIAIoAgBBASABKAIAKAIcEQQAQQAgAygCIEEBRw0AGiACIAMoAhg2AgBBAQshACADQUBrJAAgAAtNAQJ/IAEtAAAhAgJAIAAtAAAiA0UNACACIANHDQADQCABLQABIQIgAC0AASIDRQ0BIAFBAWohASAAQQFqIQAgAiADRg0ACwsgAyACawsKAEGCzwEQ1wMACzIBAX8jAEEQayIBJAAgASAAKAIENgIIIAEoAghBAToAACAAKAIIQQE6AAAgAUEQaiQACzUBAn8CQCAAKAIIIgAtAAAiAkEBRwR/IAJBAnENASAAQQI6AABBAQVBAAsPC0HMzgEQ1wMACzgBAn8jAEEQayIBJAACfyABIAAoAgQ2AgggASgCCC0AAEEBRwsEQCAAEKIKIQILIAFBEGokACACC0IBAX8jAEEQayIDJAAgACgCPCABpyABQiCIpyACQf8BcSADQQhqEAQiAARAQfj3ASAANgIACyADQRBqJAAgAykDCAsJACAAKAI8EAcLmgEAAkAgAUGAAU4EQCAAQwAAAH+UIQAgAUH/AUgEQCABQYF/aiEBDAILIABDAAAAf5QhACABQf0CIAFB/QJIG0GCfmohAQwBCyABQYF/Sg0AIABDAACAAJQhACABQYN+SgRAIAFB/gBqIQEMAQsgAEMAAIAAlCEAIAFBhn0gAUGGfUobQfwBaiEBCyAAIAFBF3RBgICA/ANqvpQLigIDAn8BfQF8AkACQCAAvCICQf////8HcSIBQYCAgPwDTwRAIAFBgICA/ANHDQEgALtEGC1EVPsh+T+iRAAAAAAAAHA4oLYPCyABQf////cDTQRAIAFBgICAfGpBgICAyANJDQIgACAAlCIDIAMgA0Nr0w28lEO6Ey+9kpRDdaoqPpKUIANDruU0v5RDAACAP5KVIACUIACSDwtEGC1EVPsh+T9DAACAPyAAi5NDAAAAP5QiALufIgQgBCAAIAAgAENr0w28lEO6Ey+9kpRDdaoqPpKUIABDruU0v5RDAACAP5KVu6KgIgQgBKChtiIAjCAAIAJBAEgbDwtDAAAAACAAIACTlSEACyAAC54NAhB/AnwjAEGwBGsiBSQAIAIgAkF9akEYbSIDQQAgA0EAShsiDUFobGohCEHQtwEoAgAiB0EATgRAIAdBAWohAyANIQIDQCAFQcACaiAEQQN0aiACQQBIBHxEAAAAAAAAAAAFIAJBAnRB4LcBaigCALcLOQMAIAJBAWohAiAEQQFqIgQgA0cNAAsLIAhBaGohBkEAIQMgB0EAIAdBAEobIQwDQEEAIQJEAAAAAAAAAAAhEwNAIBMgACACQQN0aisDACAFQcACaiADIAJrQQN0aisDAKKgIRMgAkEBaiICQQFHDQALIAUgA0EDdGogEzkDACADIAxGIQIgA0EBaiEDIAJFDQALQRcgBmshEEEYIAZrIQ4gByEDAkADQCAFIANBA3RqKwMAIRNBACECIAMhBCADQQFIIgtFBEADQCAFQeADaiACQQJ0agJ/IBMCfyATRAAAAAAAAHA+oiITmUQAAAAAAADgQWMEQCATqgwBC0GAgICAeAu3IhNEAAAAAAAAcMGioCIUmUQAAAAAAADgQWMEQCAUqgwBC0GAgICAeAs2AgAgBSAEQX9qIgRBA3RqKwMAIBOgIRMgAkEBaiICIANHDQALCwJ/IBMgBhDGASITIBNEAAAAAAAAwD+inEQAAAAAAAAgwKKgIhOZRAAAAAAAAOBBYwRAIBOqDAELQYCAgIB4CyEJIBMgCbehIRMCQAJAAkACfyAGQQFIIhFFBEAgA0ECdCAFaiICIAIoAtwDIgIgAiAOdSICIA50ayIENgLcAyACIAlqIQkgBCAQdQwBCyAGDQEgA0ECdCAFaigC3ANBF3ULIgpBAUgNAgwBC0ECIQogE0QAAAAAAADgP2ZBAXNFDQBBACEKDAELQQAhAkEAIQQgC0UEQANAIAVB4ANqIAJBAnRqIhIoAgAhC0H///8HIQ8CQAJAIARFBEAgC0UNAUGAgIAIIQ9BASEECyASIA8gC2s2AgAMAQtBACEECyACQQFqIgIgA0cNAAsLAkAgEQ0AIAZBf2oiAkEBSw0AIAJBAWsEQCADQQJ0IAVqIgIgAigC3ANB////A3E2AtwDDAELIANBAnQgBWoiAiACKALcA0H///8BcTYC3AMLIAlBAWohCSAKQQJHDQBEAAAAAAAA8D8gE6EhE0ECIQogBEUNACATRAAAAAAAAPA/IAYQxgGhIRMLIBNEAAAAAAAAAABhBEBBACEEAkAgAyICIAdMDQADQCAFQeADaiACQX9qIgJBAnRqKAIAIARyIQQgAiAHSg0ACyAERQ0AIAYhCANAIAhBaGohCCAFQeADaiADQX9qIgNBAnRqKAIARQ0ACwwDC0EBIQIDQCACIgRBAWohAiAFQeADaiAHIARrQQJ0aigCAEUNAAsgAyAEaiEEA0AgBUHAAmogA0EBaiIJQQN0aiADQQFqIgMgDWpBAnRB4LcBaigCALc5AwBBACECRAAAAAAAAAAAIRMDQCATIAAgAkEDdGorAwAgBUHAAmogCSACa0EDdGorAwCioCETIAJBAWoiAkEBRw0ACyAFIANBA3RqIBM5AwAgAyAESA0ACyAEIQMMAQsLAkAgE0EAIAZrEMYBIhNEAAAAAAAAcEFmQQFzRQRAIAVB4ANqIANBAnRqAn8gEwJ/IBNEAAAAAAAAcD6iIhOZRAAAAAAAAOBBYwRAIBOqDAELQYCAgIB4CyICt0QAAAAAAABwwaKgIhOZRAAAAAAAAOBBYwRAIBOqDAELQYCAgIB4CzYCACADQQFqIQMMAQsgE6pBgICAgHggE5lEAAAAAAAA4EFjGyECIAYhCAsgBUHgA2ogA0ECdGogAjYCAAtEAAAAAAAA8D8gCBDGASETIANBAE4EQCADIQIDQCAFIAJBA3RqIBMgBUHgA2ogAkECdGooAgC3ojkDACATRAAAAAAAAHA+oiETQQAhACACQQBKIQQgAkF/aiECIAQNAAsgAyEEA0AgDCAAIAwgAEkbIQYgAyAEayEIQQAhAkQAAAAAAAAAACETA0AgEyACQQN0QbDNAWorAwAgBSACIARqQQN0aisDAKKgIRMgAiAGRyEHIAJBAWohAiAHDQALIAVBoAFqIAhBA3RqIBM5AwAgBEF/aiEEIAAgA0chAiAAQQFqIQAgAg0ACwtEAAAAAAAAAAAhEyADQQBOBEADQCATIAVBoAFqIANBA3RqKwMAoCETIANBAEohACADQX9qIQMgAA0ACwsgASATmiATIAobOQMAIAVBsARqJAAgCUEHcQsuAQF/IwBBEGsiAiQAIAIgADYCDCACIAE2AgggAigCDCACKAIIECYgAkEQaiQAC9kDAgJ/An4jAEEgayICJAACQCABQv///////////wCDIgVCgICAgICAwP9DfCAFQoCAgICAgMCAvH98VARAIAFCBIYgAEI8iIQhBCAAQv//////////D4MiAEKBgICAgICAgAhaBEAgBEKBgICAgICAgMAAfCEEDAILIARCgICAgICAgIBAfSEEIABCgICAgICAgIAIhUIAUg0BIARCAYMgBHwhBAwBCyAAUCAFQoCAgICAgMD//wBUIAVCgICAgICAwP//AFEbRQRAIAFCBIYgAEI8iIRC/////////wODQoCAgICAgID8/wCEIQQMAQtCgICAgICAgPj/ACEEIAVC////////v//DAFYNAEIAIQQgBUIwiKciA0GR9wBJDQAgAkEQaiAAIAFC////////P4NCgICAgICAwACEIgQgA0H/iH9qEKwKIAIgACAEQYH4ACADaxCrCiACKQMIQgSGIAIpAwAiAEI8iIQhBCACKQMQIAIpAxiEQgBSrSAAQv//////////D4OEIgBCgYCAgICAgIAIWgRAIARCAXwhBAwBCyAAQoCAgICAgICACIVCAFINACAEQgGDIAR8IQQLIAJBIGokACAEIAFCgICAgICAgICAf4OEvwtQAQF+AkAgA0HAAHEEQCACIANBQGqtiCEBQgAhAgwBCyADRQ0AIAJBwAAgA2uthiABIAOtIgSIhCEBIAIgBIghAgsgACABNwMAIAAgAjcDCAtQAQF+AkAgA0HAAHEEQCABIANBQGqthiECQgAhAQwBCyADRQ0AIAIgA60iBIYgAUHAACADa62IhCECIAEgBIYhAQsgACABNwMAIAAgAjcDCAvvAgEGfyMAQSBrIgMkACADIAAoAhwiBTYCECAAKAIUIQQgAyACNgIcIAMgATYCGCADIAQgBWsiATYCFCABIAJqIQVBAiEGIANBEGohAQJ/AkACQAJ/QQAgACgCPCADQRBqQQIgA0EMahACIgRFDQAaQfj3ASAENgIAQX8LRQRAA0AgBSADKAIMIgRGDQIgBEF/TA0DIAFBCGogASAEIAEoAgQiB0siCBsiASAEIAdBACAIG2siByABKAIAajYCACABIAEoAgQgB2s2AgQgBSAEayEFAn9BACAAKAI8IAEgBiAIayIGIANBDGoQAiIERQ0AGkH49wEgBDYCAEF/C0UNAAsLIANBfzYCDCAFQX9HDQELIAAgACgCLCIBNgIcIAAgATYCFCAAIAEgACgCMGo2AhAgAgwBCyAAQQA2AhwgAEIANwMQIAAgACgCAEEgcjYCAEEAIAZBAkYNABogAiABKAIEawshACADQSBqJAAgAAspACABIAEoAgBBD2pBcHEiAUEQajYCACAAIAEpAwAgASkDCBCqCjkDAAvYFgMRfwJ+AXwjAEGwBGsiCSQAIAlBADYCLAJ/IAG9IhdCf1cEQEEBIRIgAZoiAb0hF0GgtwEMAQsgBEGAEHEEQEEBIRJBo7cBDAELQaa3AUGhtwEgBEEBcSISGwshFgJAIBdCgICAgICAgPj/AINCgICAgICAgPj/AFEEQCAAQSAgAiASQQNqIgwgBEH//3txECcgACAWIBIQICAAQbu3AUG/twEgBUEFdkEBcSIDG0GztwFBt7cBIAMbIAEgAWIbQQMQIAwBCyAJQRBqIRECQAJ/AkAgASAJQSxqENwDIgEgAaAiAUQAAAAAAAAAAGIEQCAJIAkoAiwiBkF/ajYCLCAFQSByIhBB4QBHDQEMAwsgBUEgciIQQeEARg0CIAkoAiwhCkEGIAMgA0EASBsMAQsgCSAGQWNqIgo2AiwgAUQAAAAAAACwQaIhAUEGIAMgA0EASBsLIQsgCUEwaiAJQdACaiAKQQBIGyIOIQgDQCAIIAGrQQAgAUQAAAAAAADwQWMgAUQAAAAAAAAAAGZxGyIDNgIAIAhBBGohCCABIAO4oUQAAAAAZc3NQaIiAUQAAAAAAAAAAGINAAsCQCAKQQFIBEAgCCEGIA4hBwwBCyAOIQcDQCAKQR0gCkEdSBshDQJAIAhBfGoiBiAHSQ0AIA2tIRhCACEXA0AgBiAXQv////8PgyAGNQIAIBiGfCIXIBdCgJTr3AOAIhdCgJTr3AN+fT4CACAGQXxqIgYgB08NAAsgF6ciA0UNACAHQXxqIgcgAzYCAAsDQCAIIgYgB0sEQCAGQXxqIggoAgBFDQELCyAJIAkoAiwgDWsiCjYCLCAGIQggCkEASg0ACwsgCkF/TARAIAtBGWpBCW1BAWohEyAQQeYARiEUA0BBCUEAIAprIApBd0gbIRUCQCAHIAZPBEAgByAHQQRqIAcoAgAbIQcMAQtBgJTr3AMgFXYhD0F/IBV0QX9zIQ1BACEKIAchCANAIAggCCgCACIDIBV2IApqNgIAIAMgDXEgD2whCiAIQQRqIgggBkkNAAsgByAHQQRqIAcoAgAbIQcgCkUNACAGIAo2AgAgBkEEaiEGCyAJIAkoAiwgFWoiCjYCLCAOIAcgFBsiAyATQQJ0aiAGIAYgA2tBAnUgE0obIQYgCkEASA0ACwtBACEIAkAgByAGTw0AIA4gB2tBAnVBCWwhCEEKIQogBygCACIDQQpJDQADQCAIQQFqIQggAyAKQQpsIgpPDQALCyALQQAgCCAQQeYARhtrIBBB5wBGIAtBAEdxayIDIAYgDmtBAnVBCWxBd2pIBEAgA0GAyABqIg1BCW0iA0ECdCAOakGEYGohDEEKIQogDSADQQlsayIDQQdMBEADQCAKQQpsIQogA0EBaiIDQQhHDQALCwJAQQAgBiAMQQRqIhNGIAwoAgAiDyAPIApuIg0gCmxrIhQbDQBEAAAAAAAA4D9EAAAAAAAA8D9EAAAAAAAA+D8gFCAKQQF2IgNGG0QAAAAAAAD4PyAGIBNGGyAUIANJGyEZRAEAAAAAAEBDRAAAAAAAAEBDIA1BAXEbIQECQCASRQ0AIBYtAABBLUcNACAZmiEZIAGaIQELIAwgDyAUayIDNgIAIAEgGaAgAWENACAMIAMgCmoiAzYCACADQYCU69wDTwRAA0AgDEEANgIAIAxBfGoiDCAHSQRAIAdBfGoiB0EANgIACyAMIAwoAgBBAWoiAzYCACADQf+T69wDSw0ACwsgDiAHa0ECdUEJbCEIQQohCiAHKAIAIgNBCkkNAANAIAhBAWohCCADIApBCmwiCk8NAAsLIAxBBGoiAyAGIAYgA0sbIQYLAn8DQEEAIAYiDSAHTQ0BGiANQXxqIgYoAgBFDQALQQELIQoCQCAQQecARwRAIARBCHEhEAwBCyAIQX9zQX8gC0EBIAsbIgYgCEogCEF7SnEiAxsgBmohC0F/QX4gAxsgBWohBSAEQQhxIhANAEEJIQYCQCAKRQ0AIA1BfGooAgAiD0UNAEEKIQNBACEGIA9BCnANAANAIAZBAWohBiAPIANBCmwiA3BFDQALCyANIA5rQQJ1QQlsQXdqIQMgBUEgckHmAEYEQEEAIRAgCyADIAZrIgNBACADQQBKGyIDIAsgA0gbIQsMAQtBACEQIAsgAyAIaiAGayIDQQAgA0EAShsiAyALIANIGyELCyALIBByIhVBAEchFCAAQSAgAgJ/IAhBACAIQQBKGyAFQSByIg9B5gBGDQAaIBEgCCAIQR91IgNqIANzrSAREHgiBmtBAUwEQANAIAZBf2oiBkEwOgAAIBEgBmtBAkgNAAsLIAZBfmoiEyAFOgAAIAZBf2pBLUErIAhBAEgbOgAAIBEgE2sLIAsgEmogFGpqQQFqIgwgBBAnIAAgFiASECAgAEEwIAIgDCAEQYCABHMQJwJAAkACQCAPQeYARgRAIAlBEGpBCHIhAyAJQRBqQQlyIQggDiAHIAcgDksbIgUhBwNAIAc1AgAgCBB4IQYCQCAFIAdHBEAgBiAJQRBqTQ0BA0AgBkF/aiIGQTA6AAAgBiAJQRBqSw0ACwwBCyAGIAhHDQAgCUEwOgAYIAMhBgsgACAGIAggBmsQICAHQQRqIgcgDk0NAAsgFQRAIABBw7cBQQEQIAsgByANTw0BIAtBAUgNAQNAIAc1AgAgCBB4IgYgCUEQaksEQANAIAZBf2oiBkEwOgAAIAYgCUEQaksNAAsLIAAgBiALQQkgC0EJSBsQICALQXdqIQYgB0EEaiIHIA1PDQMgC0EJSiEDIAYhCyADDQALDAILAkAgC0EASA0AIA0gB0EEaiAKGyEFIAlBEGpBCHIhAyAJQRBqQQlyIQ4gByEIA0AgDiAINQIAIA4QeCIGRgRAIAlBMDoAGCADIQYLAkAgByAIRwRAIAYgCUEQak0NAQNAIAZBf2oiBkEwOgAAIAYgCUEQaksNAAsMAQsgACAGQQEQICAGQQFqIQYgEEVBACALQQFIGw0AIABBw7cBQQEQIAsgACAGIA4gBmsiBiALIAsgBkobECAgCyAGayELIAhBBGoiCCAFTw0BIAtBf0oNAAsLIABBMCALQRJqQRJBABAnIAAgEyARIBNrECAMAgsgCyEGCyAAQTAgBkEJakEJQQAQJwsMAQsgFkEJaiAWIAVBIHEiDhshDQJAIANBC0sNAEEMIANrIgZFDQBEAAAAAAAAIEAhGQNAIBlEAAAAAAAAMECiIRkgBkF/aiIGDQALIA0tAABBLUYEQCAZIAGaIBmhoJohAQwBCyABIBmgIBmhIQELIBEgCSgCLCIGIAZBH3UiBmogBnOtIBEQeCIGRgRAIAlBMDoADyAJQQ9qIQYLIBJBAnIhCyAJKAIsIQggBkF+aiIPIAVBD2o6AAAgBkF/akEtQSsgCEEASBs6AAAgBEEIcSEIIAlBEGohBwNAIAciBSABqkGAgICAeCABmUQAAAAAAADgQWMbIgZBkLcBai0AACAOcjoAACABIAa3oUQAAAAAAAAwQKIhAQJAIAdBAWoiByAJQRBqa0EBRw0AAkAgCA0AIANBAEoNACABRAAAAAAAAAAAYQ0BCyAFQS46AAEgBUECaiEHCyABRAAAAAAAAAAAYg0ACyAAQSAgAiALAn8CQCADRQ0AIAcgCWtBbmogA04NACADIBFqIA9rQQJqDAELIBEgCUEQamsgD2sgB2oLIgNqIgwgBBAnIAAgDSALECAgAEEwIAIgDCAEQYCABHMQJyAAIAlBEGogByAJQRBqayIFECAgAEEwIAMgBSARIA9rIgNqa0EAQQAQJyAAIA8gAxAgCyAAQSAgAiAMIARBgMAAcxAnIAlBsARqJAAgAiAMIAwgAkgbCzUAIABQRQRAA0AgAUF/aiIBIACnQQ9xQZC3AWotAAAgAnI6AAAgAEIEiCIAQgBSDQALCyABCy0AIABQRQRAA0AgAUF/aiIBIACnQQdxQTByOgAAIABCA4giAEIAUg0ACwsgAQvFAgEEfyMAQdABayICJAAgAkEANgLMASACQaABakEAQSgQCxogAiACKALMATYCyAECQEEAIAEgAkHIAWogAkHQAGogAkGgAWoQpQJBAEgNAEEBQQAgACgCTEEAThshBCAAKAIAIQMgACwASkEATARAIAAgA0FfcTYCAAsgA0EgcSEFAn8gACgCMARAIAAgASACQcgBaiACQdAAaiACQaABahClAgwBCyAAQdAANgIwIAAgAkHQAGo2AhAgACACNgIcIAAgAjYCFCAAKAIsIQMgACACNgIsIAAgASACQcgBaiACQdAAaiACQaABahClAiADRQ0AGiAAQQBBACAAKAIkEQcAGiAAQQA2AjAgACADNgIsIABBADYCHCAAQQA2AhAgAEEANgIUQQALGiAAIAAoAgAgBXI2AgAgBEUNAAsgAkHQAWokAAuLAgACQCAABH8gAUH/AE0NAQJAQdDTASgCACgCAEUEQCABQYB/cUGAvwNGDQMMAQsgAUH/D00EQCAAIAFBP3FBgAFyOgABIAAgAUEGdkHAAXI6AABBAg8LIAFBgLADT0EAIAFBgEBxQYDAA0cbRQRAIAAgAUE/cUGAAXI6AAIgACABQQx2QeABcjoAACAAIAFBBnZBP3FBgAFyOgABQQMPCyABQYCAfGpB//8/TQRAIAAgAUE/cUGAAXI6AAMgACABQRJ2QfABcjoAACAAIAFBBnZBP3FBgAFyOgACIAAgAUEMdkE/cUGAAXI6AAFBBA8LC0H49wFBGTYCAEF/BUEBCw8LIAAgAToAAEEBC5YDAQF/IwBB4ABrIgQkACAEIAA2AlwgBCABOAJYIAQgAjgCVCAEIAM4AlAgBCgCXCEAIAQgBCoCWBApOAJMIAQgBCoCVBApOAJIIAQgBCoCUBApOAJEIAQgBCoCWBAoOAJAIAQgBCoCVBAoOAI8IAQgBCoCUBAoOAI4IAQgBCoCTCAEKgJElDgCNCAEIAQqAkwgBCoCOJQ4AjAgBCAEKgJAIAQqAkSUOAIsIAQgBCoCQCAEKgI4lDgCKCAEIAQqAkggBCoCRJQ4AiQgBCAEKgI8IAQqAiyUIAQqAjCTOAIgIAQgBCoCPCAEKgI0lCAEKgIokjgCHCAEIAQqAkggBCoCOJQ4AhggBCAEKgI8IAQqAiiUIAQqAjSSOAIUIAQgBCoCPCAEKgIwlCAEKgIskzgCECAEIAQqAjyMOAIMIAQgBCoCSCAEKgJAlDgCCCAEIAQqAkggBCoCTJQ4AgQgACAEQSRqIARBIGogBEEcaiAEQRhqIARBFGogBEEQaiAEQQxqIARBCGogBEEEahCiASAEQeAAaiQAC70BAQF/IAFBAEchAgJAAkACQAJAIAFFDQAgAEEDcUUNAANAIAAtAABFDQIgAEEBaiEAIAFBf2oiAUEARyECIAFFDQEgAEEDcQ0ACwsgAkUNAQsgAC0AAEUNAQJAIAFBBE8EQANAIAAoAgAiAkF/cyACQf/9+3dqcUGAgYKEeHENAiAAQQRqIQAgAUF8aiIBQQNLDQALCyABRQ0BCwNAIAAtAABFDQIgAEEBaiEAIAFBf2oiAQ0ACwtBAA8LIAALegEBfyAAKAJMQQBIBEACQCAALABLQQpGDQAgACgCFCIBIAAoAhBPDQAgACABQQFqNgIUIAFBCjoAAA8LIAAQ1AMPCwJAAkAgACwAS0EKRg0AIAAoAhQiASAAKAIQTw0AIAAgAUEBajYCFCABQQo6AAAMAQsgABDUAwsL1QICA38JfSMAQRBrIgMkAAJ9AkACQAJAAkAgAigCZEEATgRAIAMgASgCbEECdGogAigCWLI4AgAMAQsgAkEYahBeIQYgAkHIAGoiBRBeIQcgAigCZCEEIAMgASgCbEECdGogBiAHlTgCACAEQQBIDQELIAMgASgCcEECdGogAigCXLI4AgAMAQsgAkEoahBeIQYgBRBeIQcgAigCZCEEIAMgASgCcEECdGogBiAHlTgCACAEQQBIDQELIAIoAmCyDAELIAJBOGoQXiAFEF6VCyEGIAMgASgCaEECdGogBjgCACABKgIUIQYgASoCGCEHIAEqAhAhCCABKgIAIQkgASoCBCEKIAEqAgghCyADKgIAIQwgAyoCBCENIAMqAgghDiAAQQA2AgwgACAHIA4gC5SSOAIIIAAgBiANIAqUkjgCBCAAIAggDCAJlJI4AgAgA0EQaiQAC/kOAgx/CX0jAEEwayIDJABByuWnin8hB0HK5aeKByEFAkAgAkEASgRAIAEhBEHK5aeKByEKQcrlp4oHIQhByuWnin8hBkHK5aeKfyEJA0AgBCgCCCILIAcgB74gC74iD10bIQcgBCgCBCIMIAYgBr4gDL4iEF0bIQYgBCgCACINIAkgCb4gDb4iEV0bIQkgCyAFIA8gBb5dGyEFIAwgCiAQIAq+XRshCiANIAggESAIvl0bIQggBEEQaiEEIA5BAWoiDiACRw0ACwwBC0HK5aeKfyEJQcrlp4p/IQZByuWnigchCEHK5aeKByEKCyAAQQJBASAGviISIAq+IhOTIg8gB74iFCAFviIVkyIQXSIFGyAJviIWIAi+IheTIhEgEF0iBkEBdCARIA9dIgcbIgQ2AnAgBCAGQQFzQQF0QQFBAiAFGyAHGyIFRgRAIARBAWpBA3AhBQsgACAFNgJoIABBADYCDCAAQQA2AhwgACAEQQNzIAVrIgU2AmwgACAUIBWSQwAAAD+UOAIYIAAgEiATkkMAAAA/lDgCFCAAIBYgF5JDAAAAP5Q4AhAgACAQQ/hHzTiUIBBD+EfNuJQgBUEBakEDbyAERiIEGyIQOAIIIAAgD0P4R804lCAPQ/hHzbiUIAQbIg84AgQgACARQ/hHzTiUIBFD+EfNuJQgBBsiETgCACADQQA2AiQgA0EBOgAoIANCADcCHAJAAkAgAkEBTgRAQej3AUHo9wEoAgBBAWo2AgAgAyACQQR0QRBBjNIBKAIAEQMAIgQ2AiRBASEHIANBAToAKCADIAI2AiAgBCADKQMQNwIIIAQgAykDCDcCACACQQFHBEADQCADKAIkIAdBBHRqIgQgAykDCDcCACAEIAMpAxA3AgggB0EBaiIHIAJHDQALC0MAAIA/IBCVIBAgEEMAAAAAXBshEEMAAIA/IA+VIA8gD0MAAAAAXBshEkMAAIA/IBGVIBEgEUMAAAAAXBshESADIAI2AhwgA0EIaiAAKAJoQQJ0aiEGIANBCGogACgCcEECdGohByADQQhqIAAoAmxBAnRqIQggACoCGCETIAAqAhQhFCAAKgIQIRUgAygCJCEJQQAhBQNAIAEqAgAhDyABKgIEIRYgASoCCCEXIANBADYCFCADIBAgFyATk5Q4AhAgAyASIBYgFJOUOAIMIAMgESAPIBWTlDgCCCAJIAVBBHRqIgQCfyAIKgIAIg+LQwAAAE9dBEAgD6gMAQtBgICAgHgLNgIAIAQCfyAHKgIAIg+LQwAAAE9dBEAgD6gMAQtBgICAgHgLNgIEIAYqAgAhDyAEIAU2AgwgBCAPqEGAgICAeCAPi0MAAABPXRs2AgggAUEQaiEBIAVBAWoiBSACRw0ACwwBCyADIAI2AhwMAQsgAkECSA0AIANBGGogA0EIakEAIAJBf2oQpwILIAAgAjYCLCAAQQA2AiggACAAKAIgNgIkIAAoAlQiASACSARAIAAoAlggAkgEQAJ/IAJFBEBBACEJIAEMAQtB6PcBQej3ASgCAEEBajYCACACQQJ0QRBBjNIBKAIAEQMAIQkgACgCVAsiBEEBTgRAQQAhBwNAIAkgB0ECdCIFaiAAKAJcIAVqKAIANgIAIAdBAWoiByAERw0ACwsgACgCXCIEBEAgAC0AYARAIAQEQEHs9wFB7PcBKAIAQQFqNgIAIARBkNIBKAIAEQAACwsgAEEANgJcCyAAIAk2AlwgACACNgJYIABBAToAYAsDQCAAKAJcIAFBAnRqQQA2AgAgAUEBaiIBIAJHDQALCyAAIAI2AlQgAkEBTgRAQQAhCANAAkAgACgCKCIGDQACQCAAKAIkIgUEQCAAIAUoAgg2AiQMAQtB6PcBQej3ASgCAEEBajYCAEEMQRBBjNIBKAIAEQMAIQUgACgCLCEBIAVBADYCCCAFIAE2AgRB6PcBQej3ASgCAEEBajYCACAFIAFB8ABsQRBBjNIBKAIAEQMANgIAIAUgACgCIDYCCCAAIAU2AiALQQAhASAFKAIAIgYhByAFKAIEIgRBAUgNAANAIAcgB0HwAGoiB0EAIAFBAWoiASAESBs2AgAgASAERw0ACwsgACAGKAIANgIoIAZCADcDCCAGQQA2AhAgBkIANwMAIAZBfzYCaCAGQQA2AgggBiADKAIkIAhBBHRqIgEpAgA3AlggBiABKQIINwJgIAZBfzYCaCAAKAJcIAhBAnRqIAY2AgAgCEEBaiIIIAJHDQALCyADKAIkIgEEQCADLQAoBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyADQQA2AiQLIANBADYCJCADQQE6ACggA0IANwIcIABBfTYCZCAAQQA2AjggACACQQZsNgI8IABCADcCdCAAIAAoAjA2AjQgA0IANwMQIANCADcDCCAAQQAgAiADQQhqEKkCIAAgAygCCDYCfCADKAIkIgAEQCADLQAoBEAgAARAQez3AUHs9wEoAgBBAWo2AgAgAEGQ0gEoAgARAAALCyADQQA2AiQLIANBMGokAAtHAQF/IwBBEGsiBCQAIAQgADYCDCAEIAE4AgggBCACOAIEIAQgAzgCACAEKAIMIAQqAgggBCoCBCAEKgIAELQKIARBEGokAAv6FQIXfwd+IwBBgAFrIgMkAAJAIAIoAgRFDQAgASgCBEUEQCABIAIpAgA3AgAgASACKQIINwIIDAELIAAgACgCZEF/ajYCZCADQQA2AnwgA0EANgJ4An8gASACIANB/ABqIANB+ABqELsKBEAgAygCfCISKAJcIQ0gAygCeCIPKAJcIQogEigCYCEGIA8oAmAhBCASKAJYIQsgDygCWCEHIANBfzYCXCADIAQgBmsiBTYCWCADIAogDWsiAjYCVCADIAcgC2siCTYCUCASKAIIIQEgA0EANgIgIAWsIhogAqwiH34hHEEAIAlrrCIbIAmsfiAfIB9+fSEdQgAgGiAbfn0hICABBEAgASECA0ACQCACKAIMIgUoAlwgDWusIh4gG35CACAfIAUoAlggC2usIhp+fVINACAcIB5+IBogIH58IB0gBSgCYCAGa6x+fEIBUw0AIAgEQCADQn83A0AgA0IANwM4IAggAiADQdAAaiADQThqEKgCQQFHDQELIAIhCAsgAigCACICIAFHDQALIAMgCDYCIAsgDygCCCEFQQAhASADQQA2AgggBQRAIAUhAgNAAkAgAigCDCIJKAJcIAprrCIeIBt+QgAgHyAJKAJYIAdrrCIafn1SDQAgHCAefiAaICB+fCAdIAkoAmAgBGusfnxCAVMNACABBEAgA0J/NwNAIANCADcDOCABIAIgA0HQAGogA0E4ahCoAkECRw0BCyACIQELIAIoAgAiAiAFRw0ACyADIAE2AggLAkAgASAIckUNACAAIBIgDyADQSBqIANBCGoQ3wMgAygCICIBBEAgAyABKAIMIhI2AnwLIAMoAggiAUUNACADIAEoAgwiDzYCeAsgDygCYEEBaiEVIA8oAlghFiAPKAJcDAELIAMoAngiDygCWEEBaiEWIA8oAmAhFSADKAJ8IRIgDygCXAshFyAPIQIgEiEBQQAhC0EAIQhBASEZQQAhBEEAIQcDQCACKAJgIQYgASgCYCEMIAEoAlwhDSACKAJcIQkgASgCWCEKIAIoAlghBSADQX82AnQgAyAJIA1rIhg2AmwgAyAGIAxrIg42AnAgAyAFIAprIgY2AmggAyAXIA1rIgkgDmwgFSAMayIFIBhsa6wiGzcDUCADIAUgBmwgFiAKayIFIA5sa6wiHDcDWCADIAUgGGwgBiAJbGusIh03A2AgAyAcIAasIiB+IBsgGKwiHn59NwNIIAMgGyAOrCIafiAdICB+fTcDQCADIB0gHn4gGiAcfn03AzggA0EANgIwIANCADcDKCADQgA3AyAgAEEAIAEgA0HoAGogA0HQAGogA0E4aiADQSBqEN4DIQ4gA0EANgIYIANCADcDECADQgA3AwgCQCAOIABBASACIANB6ABqIANB0ABqIANBOGogA0EIahDeAyIMckUEQCAAIAEgAhCqAiIFIAU2AgQgBSAFNgIAIAEgBTYCCCAFKAIIIgEgATYCBCABIAE2AgAgAiABNgIIQQAhAgwBC0F/QQEgDhshDQJAIA5FDQAgDEUNACADQSBqIANBCGoQeSENCwJAAkAgGQ0AAkAgDUEATgRAIAMoAhhBf0oNAiADKQMQUA0BDAILIAMoAjBBf0oNASADKQMoUEUNAQsgCyEGIAghBSAEIQogByEJDAELIAAgASACEKoCIgohCSAEBEAgBCAKNgIEIAchCQsgCiAENgIAIAooAggiBiEFIAsEQCALIAY2AgAgCCEFCyAGIAs2AgQLIAMgDjYCBCADIAw2AgAgDCELIA1FBEAgACADKAJ8IAMoAnggA0EEaiADEN8DIAMoAgAhCwsCfyAGIA1BAEgNABogBiALRQ0AGgJAAkACQCAQBEAgDCAQKAIAIgJHBEADQCACKAIIIQRBACEHQQAhASACIAIoAgAiCEcEQCAIIAIoAgQ2AgQgAigCBCAINgIAIAghAQsgBCgCDCABNgIIIAQgBCgCACIBRwRAIAEgBCgCBDYCBCAEKAIEIAE2AgAgASEHCyACKAIMIAc2AgggAkIANwIMIAJCADcCBCACIAAoAjg2AgAgACACNgI4IARCADcCDCAEQgA3AgQgBCAAKAI4NgIAIAAgBDYCOCAAIAAoAnRBf2o2AnQgCCICIAxHDQALCyAGDQEMAgsgBkUNASAMKAIEIRAgBSETCyAQIAU2AgAgBSAQNgIEIAYgDDYCACAMIAY2AgRBACEFIAMoAgAhCwwBCyATIAwgEBshEwsgAygCeCIBKAJgIRUgASgCXCEXIAEoAlghFiADIAsoAgw2AnggCygCCCEQQQALIQsCQAJAIA1BAEwEQCADKAIEIgYNAQsgAygCfCEBDAELAkACfwJAAkAgEQRAIA4gESgCBCIBRwRAA0AgAUEEaiEEIAEoAgghDCABKAIEIQhBACECQQAhDSABIAEoAgAiB0cEQCAHIAg2AgQgBCgCACAHNgIAIAchDQsgDCgCDCANNgIIIAwgDCgCACIHRwRAIAcgDCgCBDYCBCAMKAIEIAc2AgAgByECCyABKAIMIAI2AgggBEIANwIIIARCADcCACABIAAoAjg2AgAgACABNgI4IAxCADcCDCAMQgA3AgQgDCAAKAI4NgIAIAAgDDYCOCAAIAAoAnRBf2o2AnQgCCIBIA5HDQALCyAKRQ0BIAkgETYCACARQQRqDAMLIAoNAQsgFCAOIBEbIRQMAgsgCSAOKAIAIgE2AgAgCSEUIAFBBGoLIAk2AgAgDiAKNgIAIAogDjYCBEEAIQkgAygCBCEGCyADKAJ8IgEoAmAhFSABKAJcIRcgASgCWCEWIAMgBigCDCIBNgJ8IAYoAgghEUEAIQoLQQEhAgJ/AkAgASASRw0AIAMoAnggD0cNAAJAIBFFBEAgCSAKNgIAIAogCTYCBCADKAJ8IAo2AggMAQsgFCARKAIEIgFHBEADQCABQQRqIQQgASgCCCEGIAEoAgQhCEEAIQJBACENIAEgASgCACIHRwRAIAcgCDYCBCAEKAIAIAc2AgAgByENCyAGKAIMIA02AgggBiAGKAIAIgdHBEAgByAGKAIENgIEIAYoAgQgBzYCACAHIQILIAEoAgwgAjYCCCAEQgA3AgggBEIANwIAIAEgACgCODYCACAAIAE2AjggBkIANwIMIAZCADcCBCAGIAAoAjg2AgAgACAGNgI4IAAgACgCdEF/ajYCdCAIIgEgFEcNAAsLIApFDQAgCSARNgIAIBEgCTYCBCAUIAo2AgAgCiAUNgIECyAQRQRAIAsgBTYCACAFIAs2AgQgAygCeCALNgIIQQAhECAFIQggCiEEIAkhB0EAIQIMAwsgEyAQKAIAIgJHBEADQCACKAIIIQRBACEHQQAhASACIAIoAgAiCEcEQCAIIAIoAgQ2AgQgAigCBCAINgIAIAghAQsgBCgCDCABNgIIIAQgBCgCACIBRwRAIAEgBCgCBDYCBCAEKAIEIAE2AgAgASEHCyACKAIMIAc2AgggAkIANwIMIAJCADcCBCACIAAoAjg2AgAgACACNgI4IARCADcCDCAEQgA3AgQgBCAAKAI4NgIAIAAgBDYCOCAAIAAoAnRBf2o2AnQgCCICIBNHDQALC0EAIQICQCALRQRAQQAhCwwBCyAQIAU2AgAgBSAQNgIEIAsgEzYCACATIAs2AgQLIAUMAQtBACEZIAULIQggCiEEIAkhBwsgAkUNASADKAJ8IQEgAygCeCECDAAACwALIANBgAFqJAALtwgBE38CfwJAIAAoAgwiBSgCWCABKAIIIgsoAlhHDQAgBSgCXCALKAJcRw0AIAsgCygCBCIERgRAIAIgBTYCAEEAIAsoAggiAEUNAhogAyAAKAIMNgIAQQAPCyAEIAsoAgAiBTYCACAFIAQ2AgQgASgCACALRgRAAkAgBSIHKAJYIgggBCgCWCIGSA0AIAYgCEZBACAFKAJcIAQoAlxIGw0AIAQhBwsgASAHNgIACyALIAEoAgRHDQACQCAFKAJYIgggBCgCWCIGTARAIAYgCEcNASAFKAJcIAQoAlxMDQELIAEgBTYCBAwBCyABIAQ2AgQLIAEoAgAhECAAKAIAIRQgACgCBCIWIQYgASgCBCIVIQRBACEIQQAhBUEBIQcDQCAJIQ8gBSELIAghEQJAIAQoAlggBigCWCIKayAHbCIJQQFOBEAgBiEIA0AgBCIFKAJcIQogCSEGA0ACQCAKIAgoAlwiCWshDCAIIA9FQQJ0Ig5qKAIAIgQgCEYNACAEKAJcIAlrIg1BAEoNACAEKAJYIhIgCCgCWGsgB2wiCQRAIAlBf0oNASAGIA1sIAkgDGxKDQELIAUoAlggEmsgB2whBiAEIQgMAQsLIAUgDmooAgAiBCAFRg0CIAQoAlwgCmsiDkF/Sg0CIAQoAlgiCiAIKAJYayAHbCIJQQFIDQIgCiAFKAJYayAHbCIKRQ0AIApBf0oNAiAGIA5sIAogDGxIDQALDAELIAlBf0wEQANAIAQoAlwhDCAEIA9BAEdBAnQiEmooAgAhBQNAIAkhCiAMIAYiCCgCXCIJayEOAkAgBCAFRg0AIAUoAlwgDGsiDUEASA0AIAUoAlgiEyAEKAJYayAHbCIGBEAgBkF/Sg0BIAogDWwgBiAObEoNAQsgEyAIKAJYayAHbCEJIAUhBCAIIQYMAgsgCCAIIBJqKAIAIgZGBEAgBCEFDAQLIAYoAlwgCWsiE0EBSARAIAQhBQwECyAEKAJYIAYoAlgiDWsgB2wiCUF/SgRAIAQhBQwECyANIAgoAlhrIAdsIg1FDQAgDUF/SgRAIAQhBQwECyAKIBNsIA0gDmxIDQALCyAEIQUMAQsgBigCXCEJIAYhBwNAAkAgByIIIA9FQQJ0aigCACIHIAZGDQAgBygCWCAKRw0AIAcoAlwiBSAJTCEMIAUhCSAMDQELCyAEKAJcIQkgBCEHA0AgByIFIA9BAEdBAnRqKAIAIgcgBEYNASAHKAJYIApHDQEgBygCXCIGIAlOIQwgBiEJIAwNAAsLQQEhCUF/IQcgFCEGIBAhBCAPRQ0ACyAIIAU2AgQgBSAINgIAIBEgCzYCACALIBE2AgQgECgCWCAUKAJYSARAIAAgEDYCAAsgFSgCWCAWKAJYTgRAIAAgFTYCBAsgACABKAIMNgIMIAIgETYCAEEBCyEAIAMgCzYCACAAC6QEAQd/AkAgACgCGCIKQQFIBEBBACEKDAELAn9B6PcBQej3ASgCAEEBajYCACAKQQJ0IglBEEGM0gEoAgARAwAiCgtBACAJEAshCSAAKAIYQQFIDQAgACgCICELA0AgCSAHQQJ0IghqIAggC2ooAgA2AgAgB0EBaiIHIAAoAhhIDQALCyACQQJ0IQcCQAJAAkAgAkEBTgRAAn9B6PcBQej3ASgCAEEBajYCACAHQRBBjNIBKAIAEQMAIgkLQQAgBxALQQAgBxALIQIgBEEANgIAIAZBAEoNASACRQ0DDAILQQAhCSAEQQBBACAHEAs2AgAgBkEBSA0CC0EAIQIDQAJAIAkgBSACQQJ0aiIHKAIAIgtBAnRqIg0oAgAiCARAIAcgCEF/ajYCAAwBCyAHIAQoAgA2AgAgAyAEKAIAIgxBBHRqIgcgASALQQR0aiIIKAIANgIAIAcgCCgCBDYCBCAHIAgoAgg2AghBACEHIAQgACgCGCIIQQBKBH8DQCALIAogB0ECdCIMaigCAEYEQCAAKAIgIAxqIAQoAgA2AgAgACgCGCEICyAHQQFqIgcgCEgNAAsgBCgCAAUgDAtBAWoiBzYCACANIAc2AgALIAJBAWoiAiAGRw0ACwsgCQRAQez3AUHs9wEoAgBBAWo2AgAgCUGQ0gEoAgARAAALCyAKBEAgCgRAQez3AUHs9wEoAgBBAWo2AgAgCkGQ0gEoAgARAAALCwvGEQIHfw19IAFFBEBBAA8LIAAoAhgiCUF/TARAIAAoAiAhCCAAKAIcQX9MBH8CQCAIRQ0AIAAtACRFDQAgCARAQez3AUHs9wEoAgBBAWo2AgAgCEGQ0gEoAgARAAALCyAAQQE6ACQgAEIANwIcQQAFIAgLIAlBAnQiCGpBAEEAIAhrEAsaCyAAQQA2AhggBEEANgIAIAdBgICA/AM2AgggB0KAgID8g4CAwD83AgAgAUEBIAFBAUsbIQlD//9/fyEVQ///f/8hEUP//3//IRND//9/fyEPQ///f/8hEkP//39/IRAgAiEIA0AgCCoCCCIUIBEgFCARXhshESAUIBUgFCAVXRshFSAIKgIEIhQgEyAUIBNeGyETIBQgDyAUIA9dGyEPIAgqAgAiFCASIBQgEl4bIRIgFCAQIBQgEF0bIRAgAyAIaiEIIApBAWoiCiAJRw0ACyAVIBEgFZMiEUMAAAA/lJIhFSAPIBMgD5MiD0MAAAA/lJIhFyAQIBIgEJMiEEMAAAA/lJIhFgJAAkAgAUEDSQ0AIBBDvTeGNV0NACAPQ703hjVdDQAgEUO9N4Y1XUUNAQtDCtcjPCETQwrXIzwhEkMK1yM8IRQCQCARIA8gEEP//39/IBBD//9/f10bQ///f38gEEO9N4Y1XhsiBiAPIAZdGyAGIA9DvTeGNV4bIgYgESAGXRsgBiARQ703hjVeGyIGQ///f39bDQAgBkPNzEw9lCITIA8gD0O9N4Y1XRshEiATIBAgEEO9N4Y1XRshFCARQ703hjVdQQFzRQ0AIBEhEwsgBSAVIBOSIgY4AnggBSAXIBKSIhE4AnQgBSAWIBSTIg84AnAgBSAGOAJoIAUgETgCZCAFIBYgFJIiEDgCYCAFIAY4AlggBSAXIBKTIhI4AlQgBSAQOAJQIAUgBjgCSCAFIBI4AkQgBSAPOAJAIAUgFSATkyIGOAI4IAUgETgCNCAFIA84AjAgBSAGOAIoIAUgETgCJCAFIBA4AiAgBSAGOAIYIAUgEjgCFCAFIBA4AhAgBSAGOAIIIAUgEjgCBCAFIA84AgAgBEEINgIAQQEPCyAHIBE4AgggByAPOAIEIAcgEDgCAEMAAIA/IBGVIhQgFZQhEkMAAIA/IA+VIhggF5QhFUMAAIA/IBCVIhcgFpQhEEEAIQcDQCAUIAIqAgiUIREgGCACKgIElCETIBcgAioCAJQhD0EAIQgCQCAHBEAgBCgCACIJQQEgCUEBSxshCgJAA0ACQCAFIAhBBHRqIgsqAgAiFiAPk4sgBl1BAXMNACALKgIEIhkgE5OLIAZdQQFzDQAgCyoCCCIaIBGTiyAGXUEBcw0AIA8gEJMiGyAblCATIBWTIhsgG5SSIBEgEpMiGyAblJIgFiAQkyIWIBaUIBkgFZMiFiAWlJIgGiASkyIWIBaUkl5BAXMNAiALIA84AgAgCyATOAIEIAsgETgCCAwCCyAJIQcgCEEBaiIIIApHDQALIAohCAsgByAIRw0BCyAFIAhBBHRqIgcgETgCCCAHIBM4AgQgByAPOAIAIAQgCEEBajYCAAsCQCAAKAIYIgcgACgCHEcNACAHIAdBAXRBASAHGyILTg0AQQAhCkEAIQwgCwRAQej3AUHo9wEoAgBBAWo2AgAgC0ECdEEQQYzSASgCABEDACEMIAAoAhghBwsgACgCICEJAkACQCAHQQFOBEADQCAMIApBAnQiDWogCSANaigCADYCACAKQQFqIgogB0cNAAwCAAsACyAJRQ0BCyAALQAkBEAgCQRAQez3AUHs9wEoAgBBAWo2AgAgCUGQ0gEoAgARAAALCyAAQQA2AiAgACgCGCEHCyAAIAw2AiAgAEEBOgAkIAAgCzYCHAsgAiADaiECIAAoAiAgB0ECdGogCDYCACAAIAAoAhhBAWo2AhggBCgCACEHIA5BAWoiDiABRw0AC0P//3//IRlD//9/fyESAn8gB0UEQEP//39/IRdD//9//yEWQ///f38hFEP//3//IRhBAQwBC0EAIQhD//9/fyEXQ///f/8hFkP//39/IRRD//9//yEYQ///f/8hGkP//39/IRVD//9//yEPQ///f38hEEP//3//IRFD//9/fyETA0AgBSAIQQR0aiIAKgIIIgYgGiAGIBpeIgEbIRogBiAZIAEbIRkgBiAVIAYgFV0iARshFSAGIBIgARshEiAAKgIEIgYgDyAGIA9eIgEbIQ8gBiAWIAEbIRYgBiAQIAYgEF0iARshECAGIBcgARshFyAAKgIAIgYgESAGIBFeIgAbIREgBiAYIAAbIRggBiATIAYgE10iABshEyAGIBQgABshFCAIQQFqIgggB0cNAAsgB0EDSQshACAZIBKTIQYgFiAXkyETIBggFJMhFQJAAkAgAA0AIBVDvTeGNV0NACATQ703hjVdDQAgBkO9N4Y1XUEBcw0BCyASIAZDAAAAP5SSIRYgFyATQwAAAD+UkiEXIBQgFUMAAAA/lJIhFEMK1yM8IQ9DCtcjPCEQQwrXIzwhEQJAIAYgEyAVQ///f38gFUP//39/XRtD//9/fyAVQ703hjVgGyISIBMgEl0bIBIgE0O9N4Y1YBsiEiAGIBJdGyASIAZDvTeGNWAbIhJD//9/f1sNACASQ83MTD2UIhEgEyATQ703hjVdGyEQIBEgFSAVQ703hjVdGyEPIAZDvTeGNV1BAXNFDQAgBiERCyAFIBYgEZIiBjgCeCAFIBcgEJIiEzgCdCAFIBQgD5MiEjgCcCAFIAY4AmggBSATOAJkIAUgFCAPkiIPOAJgIAUgBjgCWCAFIBcgEJMiEDgCVCAFIA84AlAgBSAGOAJIIAUgEDgCRCAFIBI4AkAgBSAWIBGTIgY4AjggBSATOAI0IAUgEjgCMCAFIAY4AiggBSATOAIkIAUgDzgCICAFIAY4AhggBSAQOAIUIAUgDzgCECAFIAY4AgggBSAQOAIEIAUgEjgCACAEQQg2AgALQQEL/wkBCH8gACABIAIgBRC/CkUEQEEADwsCQCAAKAIEIgFBAUgEQEEAIQIMAQtBACECA0AgDUECdCILIAAoAgxqKAIAIgYEQAJAAkAgByAIRw0AIAcgB0EBdEEBIAcbIglODQBBACEBQQAhBSAJBEBB6PcBQej3ASgCAEEBajYCACAJQQJ0QRBBjNIBKAIAEQMAIQULAkAgB0EBTgRAA0AgBSABQQJ0IgpqIAIgCmooAgA2AgAgAUEBaiIBIAdHDQAMAgALAAsgAkUNAgsgAgRAQez3AUHs9wEoAgBBAWo2AgAgAkGQ0gEoAgARAAALDAELIAchCSACIQULIAUgCEECdGogBigCADYCACAAKAIMIAtqKAIAIQICQAJAIAhBAWoiByAJRw0AIAkgCUEBdEEBIAkbIgpODQBBACEBQQAhBiAKBEBB6PcBQej3ASgCAEEBajYCACAKQQJ0QRBBjNIBKAIAEQMAIQYLAkAgCUEATARAIAUNAQwDCwNAIAYgAUECdCIMaiAFIAxqKAIANgIAIAFBAWoiASAJRw0ACwsgBQRAQez3AUHs9wEoAgBBAWo2AgAgBUGQ0gEoAgARAAALDAELIAkhCiAFIQYLIAYgB0ECdGogAigCBDYCACAAKAIMIAtqKAIAIQUCQAJAIAhBAmoiCSAKRw0AIAogCkEBdEEBIAobIgdODQBBACEBQQAhAiAHBEBB6PcBQej3ASgCAEEBajYCACAHQQJ0QRBBjNIBKAIAEQMAIQILAkAgCkEATARAIAYNAQwDCwNAIAIgAUECdCIMaiAGIAxqKAIANgIAIAFBAWoiASAKRw0ACwsgBgRAQez3AUHs9wEoAgBBAWo2AgAgBkGQ0gEoAgARAAALDAELIAohByAGIQILIAIgCUECdGogBSgCCDYCACAAKAIMIgEgASALaigCACIBKAIYQQJ0akEANgIAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACyAIQQNqIQggACgCBCEBCyANQQFqIg0gAUgNAAsLIAQgCEEDbTYCACAIIAMoAgQiBEoEQAJAIAMoAgggCE4EQCADKAIMIQYMAQtBACEBIAQhB0EAIQYgCARAQej3AUHo9wEoAgBBAWo2AgAgCEECdEEQQYzSASgCABEDACEGIAMoAgQhBwsgAygCDCEFAkACQCAHQQFOBEADQCAGIAFBAnQiCWogBSAJaigCADYCACABQQFqIgEgB0cNAAwCAAsACyAFDQAMAQsgAy0AEARAIAUEQEHs9wFB7PcBKAIAQQFqNgIAIAVBkNIBKAIAEQAACwsLIAMgBjYCDCADQQE6ABAgAyAINgIICyAGIARBAnRqQQAgCCAEa0ECdBALGgsgAyAINgIEIAhBAU4EQCADKAIMIQNBACEBA0AgAyABQQJ0IgRqIAIgBGooAgA2AgAgAUEBaiIBIAhHDQALCyAAKAIEIgFBf0wEQCAAKAIIQX9MBEAgACgCDCIDBEAgAC0AEARAIAMEQEHs9wFB7PcBKAIAQQFqNgIAIANBkNIBKAIAEQAACwsgAEEANgIMCyAAQQE6ABAgAEIANwIICwNAIAAoAgwgAUECdGpBADYCACABQQFqIgMgAU8hBCADIQEgBA0ACwsgAEEANgIEIAIEQCACBEBB7PcBQez3ASgCAEEBajYCACACQZDSASgCABEAAAsLQQEL/hQCC38SfSMAQdAAayIEJAACQCACQQRIDQAgASoCCCEVIAEqAgQhFiABKgIAIQ9B6PcBQej3ASgCAEEBajYCACACQQJ0IgdBEEGM0gEoAgARAwAhCyAEQQA2AjxB6PcBQej3ASgCAEEBajYCACAEIAdBEEGM0gEoAgARAwAiBzYCRCAEQQE6AEggBCACNgJAIAshCSAVIRMgFiESIA8hGCACIgghDANAAkAgBiAIRwRAIAchBSAGIQgMAQsgCCAIQQF0QQEgCBsiDU4EQCAHIQUMAQtBACEGQQAhBSANBEBB6PcBQej3ASgCAEEBajYCACANQQJ0QRBBjNIBKAIAEQMAIQULAkACQCAIQQFOBEADQCAFIAZBAnQiDmogByAOaigCADYCACAGQQFqIgYgCEcNAAwCAAsACyAHRQ0BCyAHBEBB7PcBQez3ASgCAEEBajYCACAHQZDSASgCABEAAAsgBEEANgJEIAQoAjwhCAsgBCAFNgJEIARBAToASCAEIA02AkALIAUgCEECdGpBATYCACAEIAQoAjxBAWo2AjwCQCAKIAxHDQAgCiAKQQF0QQEgChsiDE8EQCAKIQwMAQtBACEGQej3AUHo9wEoAgBBAWo2AgAgDEECdEEQQYzSASgCABEDACELAkACQCAKBEADQCALIAZBAnQiB2ogByAJaigCADYCACAGQQFqIgYgCkcNAAwCAAsACyAJDQBBASEMDAELIAkEQEHs9wFB7PcBKAIAQQFqNgIAIAlBkNIBKAIAEQAACwsgCyEJCyAJIApBAnRqQQA2AgAgASAKQQR0aiIHKgIIIhAgEyATIBBdGyETIAcqAgQiESASIBIgEV0bIRIgByoCACIUIBggGCAUXRshGCAQIBUgECAVXRshFSARIBYgESAWXRshFiAUIA8gFCAPXRshDyACIApBAWoiCkcEQCAEKAJAIQggBCgCPCEGIAUhBwwBCwsgBEEoaiABIAIgBEE4ahDACgJ/QQAgBCgCKCIHQX9GDQAaIAEgBCgCNCIFQQR0aiIGKgIAIRAgASAEKAIwIglBBHRqIgoqAgAhESABIAQoAiwiCEEEdGoiDCoCACEUIAEgB0EEdGoiDSoCACEXIAYqAgQhGSAKKgIEIRogDCoCBCEbIA0qAgQhHCAGKgIIIR0gCioCCCEeIAwqAgghHyANKgIIISAgBEEANgIkIAQgHSAeICAgH5KSkkMAAIA+lDgCICAEIBkgGiAcIBuSkpJDAACAPpQ4AhwgBCAQIBEgFyAUkpKSQwAAgD6UOAIYIAAgCSAFIAgQXyIGQoKAgIAwNwIMIAZBATYCFCAAIAUgCSAHEF8iBkKDgICAIDcCDCAGQQA2AhQgACAHIAggBRBfIgZCgICAgBA3AgwgBkEDNgIUIAAgCCAHIAkQXyIHQgE3AgwgB0ECNgIUIAsgBUECdGpBATYCACALIAQoAjBBAnRqQQE2AgAgCyAEKAIsQQJ0akEBNgIAIAsgBCgCKEECdGpBATYCACAAKAIEIgZBAU4EQEEAIQoDQAJAIAEgACgCDCAKQQJ0aigCACIHKAIEQQR0aiIFKgIAIhAgASAHKAIAQQR0aiIJKgIAkyIUIAEgBygCCEEEdGoiCCoCBCAFKgIEIhGTIheUIBEgCSoCBJMiESAIKgIAIBCTIhmUkyIQIBCUIBEgCCoCCCAFKgIIIhGTIhqUIBEgCSoCCJMiGyAXlJMiESARlCAbIBmUIBQgGpSTIhQgFJSSkpEiF0MAAAAAWwRAIARBADYCECAEQoCAgPwDNwMIDAELIAQgEEMAAIA/IBeVIhCUOAIQIAQgFCAQlDgCDCAEIBEgEJQ4AggLIARBADYCFCAHIAEgAiAEQQhqIARBOGoQUiIFNgIcIAcgASAFQQR0aiIFKgIAIAEgBygCAEEEdGoiByoCAJMgBCoCCJQgBSoCBCAHKgIEkyAEKgIMlJIgBSoCCCAHKgIIkyAEKgIQlJI4AiAgCkEBaiIKIAAoAgQiBkgNAAsLAkAgA0F8akH8k+vcAyADGyIHQQFIDQAgGCAPkyIPIA+UIBIgFpMiFiAWlJIgEyAVkyIVIBWUkpFDbxKDOpQiFUMK1yM8lCEWIBUgFZRDzczMPZQhGANAIAZBASAGQQFKGyEJIAAoAgwhCEEAIQNBACEGA0AgCCAGQQJ0aigCACEFAkAgAwRAIAVFDQEgAyoCICAFKgIgXUEBcw0BCyAFIQMLIAZBAWoiBiAJRw0ACyADRQ0BIAMqAiAgFV5BAXMNASALIAMoAhwiA0ECdGpBATYCAAJAIAAoAgQiBkUNACABIANBBHRqIQkDQAJAIAggBkF/aiIGQQJ0aigCACIFRQ0AIAQgBSgCCDYCECAEIAUpAgA3AwggASAEQQhqIAkgFhDkA0UNACAAIAUgAxDjAwsgBgRAIAAoAgwhCAwBCwsgACgCBCIIIQogCEUNAANAAkACQCAAKAIMIg0gCkF/aiIKQQJ0aigCACIFRQ0AAkAgBSgCACADRg0AIAUoAgQgA0YNACAFKAIIIANHDQILIAQgBSgCCDYCECAEIAUpAgA3AwggASAEQQhqIARBGGogFhDkA0UEQCABIAQoAgxBBHRqIgkqAgAiDyABIAQoAghBBHRqIgYqAgCTIhMgASAEKAIQQQR0aiIMKgIEIAkqAgQiEpMiEJQgEiAGKgIEkyISIAwqAgAgD5MiD5STIhEgEZQgEiAMKgIIIAkqAggiEpMiEZQgEiAGKgIIkyISIBCUkyIQIBCUIBIgD5QgEyARlJMiDyAPlJKSkSAYXUEBcw0BCyAAIA0gBSgCDEECdGooAgAgAxDjAyAAKAIEIgghCgsgCg0BCwsgCEUNAANAAkAgACgCDCAIQX9qIghBAnRqKAIAIgNFDQAgAygCHEF/Sg0CAkAgASADKAIEQQR0aiIFKgIAIg8gASADKAIAQQR0aiIJKgIAkyISIAEgAygCCEEEdGoiBioCBCAFKgIEIhOTIhCUIBMgCSoCBJMiEyAGKgIAIA+TIhGUkyIPIA+UIBMgBioCCCAFKgIIIhOTIhSUIBMgCSoCCJMiFyAQlJMiEyATlCAXIBGUIBIgFJSTIhIgEpSSkpEiEEMAAAAAWwRAIARBADYCECAEQoCAgPwDNwMIDAELIAQgD0MAAIA/IBCVIg+UOAIQIAQgEiAPlDgCDCAEIBMgD5Q4AggLIARBADYCFCADIAEgAiAEQQhqIARBOGoQUiIFNgIcIAsgBUECdGooAgAEQCADQX82AhwMAQsgAyABIAVBBHRqIgUqAgAgASADKAIAQQR0aiIDKgIAkyAEKgIIlCAFKgIEIAMqAgSTIAQqAgyUkiAFKgIIIAMqAgiTIAQqAhCUkjgCIAsgCA0ACwsgB0ECSA0BIAdBf2ohByAAKAIEIQYMAAALAAtBAQshBiAEKAJEIgAEQCAELQBIBEAgAARAQez3AUHs9wEoAgBBAWo2AgAgAEGQ0gEoAgARAAALCyAEQQA2AkQLIAtFDQAgCwRAQez3AUHs9wEoAgBBAWo2AgAgC0GQ0gEoAgARAAALCyAEQdAAaiQAIAYL6wkCCH8MfSMAQUBqIgQkACAEQoCAgPwDNwMYIARCiq6P4aPh9dE8NwMQIAEgAiAEQRBqIAMQUiEIIARBADYCDCAEIAQqAhiMOAIIIAQgBCoCFIw4AgQgBCAEKgIQjDgCACABIAIgBCADEFIhCSABIAhBBHRqIgcqAgAhDiABIAlBBHRqIgoqAgAhDyAHKgIEIQ0gCioCBCERIAcqAgghDCAKKgIIIRIgBEEANgIcIAQgDCASkyIMOAIYIAQgDSARkyINOAIUIAQgDiAPkyIOOAIQAkACQCAIIAlHBEAgDEMAAAAAXA0BIA1DAAAAAFwNASAOQwAAAABcDQELIABCfzcCACAAQn83AggMAQsgBEEANgI8IARBADYCLCAEIA1DCtejvJQgDpMiETgCOCAEIA5DAAAAAJQiDyAMQwrXozyUIhCSIhI4AjQgBCANIA5DCtejvJSSIg44AiggBCAPIAyTIg84AiQgBCAQIA1DAAAAAJQiEJMiDTgCICAEIAwgEJMiDDgCMCAEQTBqIQUgBEEgaiEGIAQCfSANIA2UIA8gD5SSIA4gDpSSkSIQIAwgDJQgEiASlJIgESARlJKRXkEBc0UEQCAEIA9DAACAPyAQlSIMlDgCJCAEIA0gDJQ4AiAgDiAMlAwBCyAGIAUpAwA3AwAgBiAFKQMINwMIIAQgBCoCJCIMQwAAgD8gBCoCICINIA2UIAwgDJSSIAQqAigiDCAMlJKRlSIOlDgCJCAEIA0gDpQ4AiAgDCAOlAs4AigCfyAIIAEgAiAGIAMQUiIGR0EAIAYgCUcbRQRAIARBADYCDCAEIAQqAiiMOAIIIAQgBCoCJIw4AgQgBCAEKgIgjDgCACABIAIgBCADEFIhBgsgBiAIRwtBACAGIAlHG0UEQCAAQn83AgAgAEJ/NwIIDAELIAEgBkEEdGoiCyoCBCESIAsqAgghDiALKgIAIQwgByoCBCEQIAcqAgghDyAHKgIAIQ0gBEEANgIsIARBADYCPCAEIAwgDZMiDDgCICAEKgIYIQ0gBCAOIA+TIg44AiggBCoCECEPIAQqAhQhESAEIBIgEJMiEjgCJCAEIBEgDJQgEiAPlJMiEEMAAIA/IBAgEJQgEiANlCAOIBGUkyIRIBGUIA4gD5QgDSAMlJMiDCAMlJKSkZUiDZQ4AjggBCAMIA2UOAI0IAQgESANlDgCMAJAAkAgASACIAUgAxBSIgUgBkYNACAFIAhGDQAgBSAJRw0BCyAEQQA2AgwgBCAEKgI4jDgCCCAEIAQqAjSMOAIEIAQgBCoCMIw4AgAgASACIAQgAxBSIQULAkACQCAFIAZGDQAgBSAIRg0AIAUgCUcNAQsgAEJ/NwIAIABCfzcCCAwBCyABIAVBBHRqIgEqAgghDyABKgIAIREgASoCBCESIAoqAgQhECALKgIEIRMgByoCBCEMIAoqAgghFSALKgIAIRQgCioCACEWIAcqAgAhDSALKgIIIRcgByoCCCEOIAAgCTYCBCAAIAg2AgAgACAGIAUgDyAOkyAWIA2TIg8gEyAMkyITlCAQIAyTIhAgFCANkyIUlJOUIBEgDZMgECAXIA6TIg2UIBUgDpMiDiATlJOUIBIgDJMgDiAUlCAPIA2Uk5SSkkMAAAAAXSIBGzYCDCAAIAUgBiABGzYCCAsgBEFAayQACwcAIAAQoAILNQEBfyAAIAFqQQNqQZTSASgCABEBACIABEAgACABakEDakEAIAFrcSICQXxqIAA2AgALIAILGQAgAARAIABBfGooAgBBmNIBKAIAEQAACwv8BgIOfw19IAAoAgQiBUEBTgRAA0ACQCAHIgJBAWoiByAFTg0AIAAoAgwiAyACQQR0aiIIIQ0gByECA0ACQCACQQFqIgkgBU4NACADIAJBBHRqIgohDiAJIQsDQAJAIAMgC0EEdGoiAioCBCIRIAoqAgAiEpQgCioCBCIVIAIqAgAiFpSTIhcgF5QgFSACKgIIIhOUIAoqAggiGCARlJMiGSAZlCAYIBaUIBMgEpSTIhogGpSSkkMXt9E4XkEBcw0AIBYgCCoCBCIQlCARIAgqAgAiFJSTIhsgG5QgESAIKgIIIhGUIBMgEJSTIhwgHJQgEyAUlCAWIBGUkyIWIBaUkpJDF7fROF5BAXMNACAVIBSUIBIgEJSTIhMgE5QgGCAQlCAVIBGUkyIVIBWUIBIgEZQgGCAUlJMiEiASlJKSQxe30TheQQFzDQAgESAXlCAQIBqUIBkgFJSSkiIQi0O9N4Y1XkEBcw0AQwAAgL8gEJUiECATIAIqAgwiFJQgFyANKgIMIhGUIBsgDioCDCIXlJKSlCETIBAgEiAUlCAaIBGUIBYgF5SSkpQhEiAQIBUgFJQgGSARlCAcIBeUkpKUIRBBACECIAAoAgQiBkEASgRAA0AgAyACQQR0aiIEKgIMIBAgBCoCAJQgEiAEKgIElJIgEyAEKgIIlJKSQwrXI7ySQwAAAABeQQFzRQ0CIAJBAWoiAiAGRw0ACwsCQCABKAIEIgMgASgCCEcNACADIANBAXRBASADGyIETg0AQQAhAkEAIQYCfyAEBEBB6PcBQej3ASgCAEEBajYCACAEQQR0QRBBjNIBKAIAEQMAIQYgASgCBCEDCyADQQFOCwRAA0AgBiACQQR0IgxqIg8gASgCDCAMaiIMKQIANwIAIA8gDCkCCDcCCCACQQFqIgIgA0cNAAsLIAEoAgwiAgRAIAEtABAEQCACBEBB7PcBQez3ASgCAEEBajYCACACQZDSASgCABEAAAsLIAFBADYCDAsgASAGNgIMIAFBAToAECABIAQ2AgggASgCBCEDCyABKAIMIANBBHRqIgJBADYCDCACIBM4AgggAiASOAIEIAIgEDgCACABIAEoAgRBAWo2AgQLIAtBAWoiCyAFTg0BIAAoAgwhAwwAAAsACyAFIAlGDQEgACgCDCEDIAkhAgwAAAsACyAFIAdHDQALCwvoBgIPfwh9IAAoAgQiBkEBTgRAA0ACQCAJIgJBAWoiCSAGTg0AIAAoAgwiAyACQQR0aiIIIQwgCSECA0ACQCACQQFqIgogBk4NACADIAJBBHRqIg0hDiAKIQsDQCANKgIAIAgqAgAiEZMiEyADIAtBBHRqIgIqAgQgCCoCBCISkyIUlCANKgIEIBKTIhIgAioCACARkyIRlJMhFyAOKgIIIAwqAggiFZMiFiARlCATIAIqAgggFZMiEZSTIRggEiARlCAWIBSUkyEWQwAAgD8hEUEAIQMDQCADIQ8CQCAXIBGUIhMgE5QgFiARlCISIBKUIBggEZQiFCAUlJKSIhFDF7fROF5BAXMNACATQwAAgD8gEZGVIhWUIREgFCAVlCETIBIgFZQhEiABKAIEIgRBAU4EQCABKAIMIQVBACECA0AgEiAFIAJBBHRqIgMqAgCUIBMgAyoCBJSSIBEgAyoCCJSSQ3e+fz9eQQFzRQ0CIAJBAWoiAiAERw0ACwsgEiAIKgIAlCATIAgqAgSUkiARIAwqAgiUkiEUIAAoAgQiBUEBTgRAIAAoAgwhB0EAIQIDQCASIAcgAkEEdGoiAyoCAJQgEyADKgIElJIgESADKgIIlJIgFJNDCtcjvJJDAAAAAF5BAXNFDQIgAkEBaiICIAVHDQALCyAUjCEUAkAgBCABKAIIRw0AIAQgBEEBdEEBIAQbIgVODQBBACEDQQAhBwJ/IAUEQEHo9wFB6PcBKAIAQQFqNgIAIAVBBHRBEEGM0gEoAgARAwAhByABKAIEIQQLIARBAU4LBEADQCAHIANBBHQiAmoiECABKAIMIAJqIgIpAgA3AgAgECACKQIINwIIIANBAWoiAyAERw0ACwsgASgCDCICBEAgAS0AEARAIAIEQEHs9wFB7PcBKAIAQQFqNgIAIAJBkNIBKAIAEQAACwsgAUEANgIMCyABIAc2AgwgAUEBOgAQIAEgBTYCCCABKAIEIQQLIAEoAgwgBEEEdGoiAiAUOAIMIAIgETgCCCACIBM4AgQgAiASOAIAIAEgASgCBEEBajYCBAtDAACAvyERQQEhAyAPRQ0ACyALQQFqIgsgBk4NASAAKAIMIQMMAAALAAsgBiAKRg0BIAAoAgwhAyAKIQIMAAALAAsgBiAJRw0ACwsLTgEBf0G49wFBCBASIgA2AgAgAEEAEAEaQcD3AUIANwIAQbz3AUGYswE2AgBByPcBQgA3AgBB0PcBQgA3AgBB2PcBQgA3AgBBvPcBEMsBC8IBAQJ/IwBBEGsiACQAQbj3ASgCAEEAEAEaQbz3ARDLAUHA9wFBwPcBKAIAQQFqNgIAQcz3AUHM9wEoAgAiAUEBajYCACABRQRAIABBCGpBABABGkHI9wEgACgCDEG49wEoAgAiASgCBGsgACgCCCABKAIAa0HAhD1sajYCAAtB4PcBQQA2AgAgAEEIakEAEAEaQeT3ASAAKAIMQbj3ASgCACIBKAIEayAAKAIIIAEoAgBrQcCEPWxqNgIAIABBEGokAAsKAEG89wEQrAIaCxIAQbj3ASgCACIABEAgABAOCwucBwEGfyABIAAoAhQ2AhAgASAAKAIYNgIUIAEgACgCHDYCGCABIAAoAiA2AhwgASAAKAIENgIAIAEgACgCCDYCBCABIAAoAgw2AgggASAAKAIQNgIMIAEgACgCJDYCICABIAAoAig2AiQgASAAKAIsNgIoIAEgACgCMDYCLCABIAAoAjg2AjAgASAALQA8NgI0IAEgACgCWCIDNgI4AkAgA0UEQCABQQA2AkAMAQsgASACIAAoAmAgAigCACgCHBEDACIDNgJAIANFDQAgAkEwIAAoAlgiBiACKAIAKAIQEQcAIQcgACgCYCEIIAZBAU4EQCAHKAIIIQMDQCADIAggBUEGdGoiBCgCEDYCECADIAQoAhQ2AhQgAyAEKAIYNgIYIAMgBCgCHDYCHCADIAQoAgA2AgAgAyAEKAIENgIEIAMgBCgCCDYCCCADIAQoAgw2AgwgAyAEKAIgNgIgIAMgBCgCJDYCJCADIAQoAig2AiggA0EwaiEDIAVBAWoiBSAGRw0ACwsgAiAHQYiyAUHBpIXKBSAIIAIoAgAoAhQRCQALIAEgACgCgAEiAzYCPAJAIANFBEAgAUEANgJEDAELIAEgAiAAKAKIASACKAIAKAIcEQMAIgM2AkQgA0UNACACQRAgACgCgAEiBiACKAIAKAIQEQcAIQcgACgCiAEhCCAGQQFOBEAgBygCCCEDQQAhBQNAIAMgCCAFQQR0aiIEKAIMNgIMIAMgBC8BBjsBBiADIAQvAQg7AQggAyAELwEKOwEKIAMgBC8BADsBACADIAQvAQI7AQIgAyAELwEEOwEEIANBEGohAyAFQQFqIgUgBkcNAAsLIAIgB0GfsgFBwaSFygUgCCACKAIAKAIUEQkACyABIAAoApABNgJMIAEgACgCmAEiAzYCUCADRQRAIAFBADYCSEHLsgEPCyABIAIgACgCoAEgAigCACgCHBEDACIBNgJIIAEEQCACQRQgACgCmAEiASACKAIAKAIQEQcAIQQgACgCoAEhBiABQQFOBEAgBCgCCCEDQQAhBQNAIAMgBiAFQQV0aiIALwEGOwEOIAMgAC8BCDsBECADIAAvAQo7ARIgAyAALwEAOwEIIAMgAC8BAjsBCiADIAAvAQQ7AQwgAyAAKAIMNgIAIAMgACgCEDYCBCADQRRqIQMgBUEBaiIFIAFHDQALCyACIARBtrIBQcGkhcoFIAYgAigCACgCFBEJAAtBy7IBC74NAQh/IwBBQGoiBSQAIAAgASsDILY4AhQgACABKwMotjgCGCAAIAErAzC2OAIcIAAgASsDOLY4AiAgACABKwMAtjgCBCAAIAErAwi2OAIIIAAgASsDELY4AgwgACABKwMYtjgCECAAIAErA0C2OAIkIAAgASsDSLY4AiggACABKwNQtjgCLCAAIAErA1i2OAIwIAAgASgCYDYCOCAAIAEoAmRBAEc6ADwgASgCaCEGIAVCADcDOCAFQgA3AzAgBUIANwMoIAVCADcDICAFQgA3AxggBUIANwMQIAVCADcDCCAFQgA3AwAgACgCWCIEIAZIBEAgACgCXCAGSARAIAYEf0Ho9wFB6PcBKAIAQQFqNgIAIAZBBnRBEEGM0gEoAgARAwAhByAAKAJYBSAECyIDQQFOBEADQCAHIAJBBnQiCWoiCCAAKAJgIAlqIgkpAgA3AgAgCCAJKQI4NwI4IAggCSkCMDcCMCAIIAkpAig3AiggCCAJKQIgNwIgIAggCSkCGDcCGCAIIAkpAhA3AhAgCCAJKQIINwIIIAJBAWoiAiADRw0ACwsgACgCYCIDBEAgAC0AZARAIAMEQEHs9wFB7PcBKAIAQQFqNgIAIANBkNIBKAIAEQAACwsgAEEANgJgCyAAIAc2AmAgACAGNgJcIABBAToAZAsDQCAAKAJgIARBBnRqIgMgBSkDADcCACADIAUpAzg3AjggAyAFKQMwNwIwIAMgBSkDKDcCKCADIAUpAyA3AiAgAyAFKQMYNwIYIAMgBSkDEDcCECADIAUpAwg3AgggBEEBaiIEIAZHDQALCyAAIAY2AlggBkEBTgRAIAAoAmAhByABKAJwIQJBACEEA0AgByAEQQZ0aiIDIAIrAyC2OAIQIAMgAisDKLY4AhQgAyACKwMwtjgCGCADIAIrAzi2OAIcIAMgAisDALY4AgAgAyACKwMItjgCBCADIAIrAxC2OAIIIAMgAisDGLY4AgwgAyACKAJANgIgIAMgAigCRDYCJCADIAIoAkg2AiggAkHQAGohAiAEQQFqIgQgBkcNAAsLIAEoAmwhAyAFQgA3AwggBUIANwMAIAAoAoABIgIgA0gEQCAAKAKEASADSARAAn8gA0UEQEEAIQcgAgwBC0Ho9wFB6PcBKAIAQQFqNgIAIANBBHRBEEGM0gEoAgARAwAhByAAKAKAAQsiBkEBTgRAQQAhBANAIAcgBEEEdCIIaiIJIAAoAogBIAhqIggpAgA3AgAgCSAIKQIINwIIIARBAWoiBCAGRw0ACwsgACgCiAEiBARAIAAtAIwBBEAgBARAQez3AUHs9wEoAgBBAWo2AgAgBEGQ0gEoAgARAAALCyAAQQA2AogBCyAAIAc2AogBIAAgAzYChAEgAEEBOgCMAQsDQCAAKAKIASACQQR0aiIEIAUpAwA3AgAgBCAFKQMINwIIIAJBAWoiAiADRw0ACwsgACADNgKAASADQQFOBEAgACgCiAEhBiABKAJ0IQJBACEEA0AgBiAEQQR0aiIHIAIoAgw2AgwgByACLwEGOwEGIAcgAi8BCDsBCCAHIAIvAQo7AQogByACLwEAOwEAIAcgAi8BAjsBAiAHIAIvAQQ7AQQgAkEQaiECIARBAWoiBCADRw0ACwsgACABKAJ4NgKQASAAKAKYASIEIAEoAnwiBkgEQCAAKAKcASAGSARAAn8gBkUEQEEAIQcgBAwBC0Ho9wFB6PcBKAIAQQFqNgIAIAZBBXRBEEGM0gEoAgARAwAhByAAKAKYAQsiCUEBTgRAQQAhAgNAIAcgAkEFdCIIaiIDIAAoAqABIAhqIggpAgA3AgAgAyAIKQIYNwIYIAMgCCkCEDcCECADIAgpAgg3AgggAkEBaiICIAlHDQALCyAAKAKgASIDBEAgAC0ApAEEQCADBEBB7PcBQez3ASgCAEEBajYCACADQZDSASgCABEAAAsLIABBADYCoAELIAAgBzYCoAEgACAGNgKcASAAQQE6AKQBCwNAIAAoAqABIARBBXRqIgMgBSkDADcCACADIAUpAxg3AhggAyAFKQMQNwIQIAMgBSkDCDcCCCAEQQFqIgQgBkcNAAsLIAAgBjYCmAEgBkEBTgRAIAAoAqABIQQgASgCgAEhAkEAIQADQCAEIABBBXRqIgEgAi8BDjsBBiABIAIvARA7AQggASACLwESOwEKIAEgAi8BCDsBACABIAIvAQo7AQIgASACLwEMOwEEIAEgAigCADYCDCABIAIoAgQ2AhAgAkEUaiECIABBAWoiACAGRw0ACwsgBUFAayQAC6gNAQh/IwBBQGoiBSQAIAAgASgCEDYCFCAAIAEoAhQ2AhggACABKAIYNgIcIAAgASgCHDYCICAAIAEoAgA2AgQgACABKAIENgIIIAAgASgCCDYCDCAAIAEoAgw2AhAgACABKAIgNgIkIAAgASgCJDYCKCAAIAEoAig2AiwgACABKAIsNgIwIAAgASgCMDYCOCAAIAEoAjRBAEc6ADwgASgCOCEGIAVCADcDOCAFQgA3AzAgBUIANwMoIAVCADcDICAFQgA3AxggBUIANwMQIAVCADcDCCAFQgA3AwAgACgCWCIEIAZIBEAgACgCXCAGSARAIAYEf0Ho9wFB6PcBKAIAQQFqNgIAIAZBBnRBEEGM0gEoAgARAwAhByAAKAJYBSAECyIDQQFOBEADQCAHIAJBBnQiCWoiCCAAKAJgIAlqIgkpAgA3AgAgCCAJKQI4NwI4IAggCSkCMDcCMCAIIAkpAig3AiggCCAJKQIgNwIgIAggCSkCGDcCGCAIIAkpAhA3AhAgCCAJKQIINwIIIAJBAWoiAiADRw0ACwsgACgCYCIDBEAgAC0AZARAIAMEQEHs9wFB7PcBKAIAQQFqNgIAIANBkNIBKAIAEQAACwsgAEEANgJgCyAAIAc2AmAgACAGNgJcIABBAToAZAsDQCAAKAJgIARBBnRqIgMgBSkDADcCACADIAUpAzg3AjggAyAFKQMwNwIwIAMgBSkDKDcCKCADIAUpAyA3AiAgAyAFKQMYNwIYIAMgBSkDEDcCECADIAUpAwg3AgggBEEBaiIEIAZHDQALCyAAIAY2AlggBkEBTgRAIAAoAmAhByABKAJAIQJBACEEA0AgByAEQQZ0aiIDIAIoAhA2AhAgAyACKAIUNgIUIAMgAigCGDYCGCADIAIoAhw2AhwgAyACKAIANgIAIAMgAigCBDYCBCADIAIoAgg2AgggAyACKAIMNgIMIAMgAigCIDYCICADIAIoAiQ2AiQgAyACKAIoNgIoIAJBMGohAiAEQQFqIgQgBkcNAAsLIAEoAjwhAyAFQgA3AwggBUIANwMAIAAoAoABIgIgA0gEQCAAKAKEASADSARAAn8gA0UEQEEAIQcgAgwBC0Ho9wFB6PcBKAIAQQFqNgIAIANBBHRBEEGM0gEoAgARAwAhByAAKAKAAQsiBkEBTgRAQQAhBANAIAcgBEEEdCIIaiIJIAAoAogBIAhqIggpAgA3AgAgCSAIKQIINwIIIARBAWoiBCAGRw0ACwsgACgCiAEiBARAIAAtAIwBBEAgBARAQez3AUHs9wEoAgBBAWo2AgAgBEGQ0gEoAgARAAALCyAAQQA2AogBCyAAIAc2AogBIAAgAzYChAEgAEEBOgCMAQsDQCAAKAKIASACQQR0aiIEIAUpAwA3AgAgBCAFKQMINwIIIAJBAWoiAiADRw0ACwsgACADNgKAASADQQFOBEAgACgCiAEhBiABKAJEIQJBACEEA0AgBiAEQQR0aiIHIAIoAgw2AgwgByACLwEGOwEGIAcgAi8BCDsBCCAHIAIvAQo7AQogByACLwEAOwEAIAcgAi8BAjsBAiAHIAIvAQQ7AQQgAkEQaiECIARBAWoiBCADRw0ACwsgACABKAJMNgKQASAAKAKYASIEIAEoAlAiBkgEQCAAKAKcASAGSARAAn8gBkUEQEEAIQcgBAwBC0Ho9wFB6PcBKAIAQQFqNgIAIAZBBXRBEEGM0gEoAgARAwAhByAAKAKYAQsiCUEBTgRAQQAhAgNAIAcgAkEFdCIIaiIDIAAoAqABIAhqIggpAgA3AgAgAyAIKQIYNwIYIAMgCCkCEDcCECADIAgpAgg3AgggAkEBaiICIAlHDQALCyAAKAKgASIDBEAgAC0ApAEEQCADBEBB7PcBQez3ASgCAEEBajYCACADQZDSASgCABEAAAsLIABBADYCoAELIAAgBzYCoAEgACAGNgKcASAAQQE6AKQBCwNAIAAoAqABIARBBXRqIgMgBSkDADcCACADIAUpAxg3AhggAyAFKQMQNwIQIAMgBSkDCDcCCCAEQQFqIgQgBkcNAAsLIAAgBjYCmAEgBkEBTgRAIAAoAqABIQQgASgCSCECQQAhAANAIAQgAEEFdGoiASACLwEOOwEGIAEgAi8BEDsBCCABIAIvARI7AQogASACLwEIOwEAIAEgAi8BCjsBAiABIAIvAQw7AQQgASACKAIANgIMIAEgAigCBDYCECACQRRqIQIgAEEBaiIAIAZHDQALCyAFQUBrJAALLgAgAC0APARAIAAgASACIAMgBCAFIAAoAjgQ5gMPCyAAIAEgAiADIAQgBRDnAwtmAQF/IwBBIGsiBCQAIARCADcDGCAEQgA3AxAgBEIANwMIIARCADcDAAJAIAAtADwEQCAAIAEgAiADIARBEGogBCAAKAI4EOYDDAELIAAgASACIAMgBEEQaiAEEOcDCyAEQSBqJAALnQIBBX8gACgCOEEBTgRAIAAoAmAhBANAAn9BACACKgIAIAQqAhBeDQAaQQAgAyoCACAEKgIAXQ0AGkEBCyEFQQAhCAJAIAIqAgggBCoCGF4NACADKgIIIAQqAghdDQAgBSEICwJ/AkACQCACKgIEIAQqAhReRUEAIAMqAgQgBCoCBF1BAXMbRQRAIAQoAiBBf0YhBUEAIQgMAQsgCCAEKAIgQX9GIgVxQQFHDQAgASAEKAIkIAQoAiggASgCACgCCBEFAAwBCyAFDQAgCA0AIAQoAiAiBSAHaiEHIAQgBUEGdGoMAQsgB0EBaiEHIARBQGsLIQQgBkEBaiEGIAcgACgCOEgNAAsLQbT3ASgCACAGSARAQbT3ASAGNgIACwuuAwELfyAAKAKYAUEBTgRAA0ACQCACLwEAIgUgACgCoAEgCkEFdGoiBC8BBksNACADLwEAIgggBC8BAEkNACACLwEEIgkgBC8BCksNACADLwEEIgsgBC8BBEkNACACLwECIgwgBC8BCEsNACADLwECIg0gBC8BAkkNAAJAIAQoAhAiBkEBSARAQQAhBgwBCyAGIAQoAgwiB2ohDiAAKAKIASAHQQR0aiEEQQAhBgNAIAUgBC8BBk0gCCAELwEAT3EgCSAELwEKTXEgCyAELwEET3EgDCAELwEITXEgDSAELwECT3EhBQJAIAQoAgwiCEEASCIJDQAgBUUNACABIAhBFXYgCEH///8AcSABKAIAKAIIEQUACwJ/IAVBf3MgCXFFBEAgB0EBaiEHIARBEGoMAQsgByAEKAIMIgVrIQcgBCAFQQR0awshBCAGQQFqIQYgByAOTg0BIAMvAQIhDSACLwECIQwgAy8BBCELIAIvAQQhCSADLwEAIQggAi8BACEFDAAACwALQbT3ASgCACAGTg0AQbT3ASAGNgIACyAKQQFqIgogACgCmAFIDQALCwviBgILfwt9IwBBEGsiBCQAAkAgAC0APARAAn8gACoCHCISIAAqAgwiECACKgIIIg8gDyAQXRsiDyASIA9dGyAQkyAAKgIsIhmUIg9DAACAT10gD0MAAAAAYHEEQCAPqQwBC0EACyEFIAAqAighFyAAKgIYIRUgACoCCCEPIAAqAiQhGCAAKgIUIRYgACoCBCEUIAIqAgAhESACKgIEIRMgBCAFQf7/A3EiBzsBDiAEAn8gFyAVIA8gEyATIA9dGyITIBUgE10bIA+TlCITQwAAgE9dIBNDAAAAAGBxBEAgE6kMAQtBAAtB/v8DcSIIOwEMIAQCfyAWIBQgESARIBRdGyIRIBYgEV0bIBSTIBiUIhFDAACAT10gEUMAAAAAYHEEQCARqQwBC0EAC0H+/wNxIgk7AQoCfyAZIBIgECADKgIIIhEgESAQXRsiESASIBFdGyAQk5RDAACAP5IiEEMAAIBPXSAQQwAAAABgcQRAIBCpDAELQQALIQIgAyoCACEQIAMqAgQhEiAEIAJBAXIiCjsBCCAEAn8gFyAVIA8gEiASIA9dGyISIBUgEl0bIA+TlEMAAIA/kiIPQwAAgE9dIA9DAAAAAGBxBEAgD6kMAQtBAAtBAXIiCzsBBiAEAn8gGCAWIBQgECAQIBRdGyIPIBYgD10bIBSTlEMAAIA/kiIPQwAAgE9dIA9DAAAAAGBxBEAgD6kMAQtBAAtBAXIiDDsBBCAAKAKQASICQQJLDQECQAJAAkAgAkEBaw4CAQIAC0EAIQUgACgCOCINQQFOBEAgACgCiAEhAEEAIQIDQCAJIAAvAQZNIAwgAC8BAE9xIAcgAC8BCk1xIAogAC8BBE9xIAggAC8BCE1xIAsgAC8BAk9xIQMCQCAAKAIMIgZBAEgiDg0AIANFDQAgASAGQRV2IAZB////AHEgASgCACgCCBEFAAsCfyADQX9zIA5xRQRAIAJBAWohAiAAQRBqDAELIAIgACgCDCIDayECIAAgA0EEdGsLIQAgBUEBaiEFIAIgDUgNAAsLQbT3ASgCACAFTg0DQbT3ASAFNgIADAMLIAAgASAEQQpqIARBBGoQ0AoMAgsgACAAKAKIASABIARBCmogBEEEahDoAwwBCyAAIAEgAiADEM8KCyAEQRBqJAALKQAgABDRASIABEBB7PcBQez3ASgCAEEBajYCACAAQZDSASgCABEAAAsLigYBDH0gASoCACEEIAEqAgQhBSABKgIIIQYgAEEANgIQIAAgBkMAAIA/kyIGOAIMIAAgBUMAAIA/kyIFOAIIIAAgBEMAAIA/kyIEOAIEIAIqAgAhByACKgIEIQggAioCCCEJIABBAToAPCAAQQA2AjAgAEEANgIgIAAgCUMAAIA/kiIJOAIcIAAgCEMAAIA/kiIIOAIYIAAgB0MAAIA/kiIHOAIUIABDAP1/RyAJIAaTlSILOAIsIABDAP1/RyAIIAWTlSIKOAIoIABDAP1/RyAHIASTlSIMOAIkAn8gBiAGkyALlCIDQwAAgE9dIANDAAAAAGBxBEAgA6kMAQtBAAtB/v8DcbMhDSAFAn8gBSAFkyAKlCIDQwAAgE9dIANDAAAAAGBxBEAgA6kMAQtBAAtB/v8DcbMgCpWSIQ4gBAJ/IAQgBJMgDJQiA0MAAIBPXSADQwAAAABgcQRAIAOpDAELQQALQf7/A3GzIAyVkkMAAIA/kyIDIARdQQFzRQRAIAAgAzgCBCADIQQLIA5DAACAP5MiAyAFXUEBc0UEQCAAIAM4AgggAyEFCwJ/An8gBiANIAuVkkMAAIA/kyIDIAZdQQFzRQRAIAAgAzgCDCADIQYLIAsgCSAGk5RDAACAP5IiA0MAAIBPXSADQwAAAABgcQsEQCADqQwBC0EAC0EBcrMhDSAFAn8gCiAIIAWTlEMAAIA/kiIDQwAAgE9dIANDAAAAAGBxBEAgA6kMAQtBAAtBAXKzIAqVkiEKIAcgBAJ/IAwgByAEk5RDAACAP5IiA0MAAIBPXSADQwAAAABgcQRAIAOpDAELQQALQQFysyAMlZJDAACAP5IiA11BAXNFBEAgACADOAIUIAMhBwsgCCAKQwAAgD+SIgNdQQFzRQRAIAAgAzgCGCADIQgLIAkgBiANIAuVkkMAAIA/kiIDXUEBc0UEQCAAIAM4AhwgAyEJCyAAQQA2AjAgAEMA/X9HIAkgBpOVOAIsIABDAP1/RyAIIAWTlTgCKCAAQwD9f0cgByAEk5U4AiQL2gcBC38jAEEgayIFJABBAUEAIAAoAogBIgogAkEEdGooAgwiA2sgA0F/ShshC0EBQQAgCiABQQR0aigCDCIDayADQX9KGyIMQYABTARAIAAoApgBIgQhAwJAIAQgACgCnAFHDQAgBCIDIANBAXRBASADGyIITg0AAn8gCEUEQEEAIQMgBAwBC0Ho9wFB6PcBKAIAQQFqNgIAIAhBBXRBEEGM0gEoAgARAwAhAyAAKAKYAQsiDUEBTgRAA0AgAyAGQQV0IglqIgcgACgCoAEgCWoiCSkCADcCACAHIAkpAhg3AhggByAJKQIQNwIQIAcgCSkCCDcCCCAGQQFqIgYgDUcNAAsLIAAoAqABIgYEQCAALQCkAQRAIAYEQEHs9wFB7PcBKAIAQQFqNgIAIAZBkNIBKAIAEQAACwsgAEEANgKgAQsgACADNgKgASAAIAg2ApwBIABBAToApAEgACgCmAEhAwsgACADQQFqNgKYASAEQQV0IgQgACgCoAFqIgMgBSkDADcCACADIAUpAxg3AhggAyAFKQMQNwIQIAMgBSkDCDcCCCAAKAKgASAEaiIDIAogAUEEdGoiBC8BADsBACADIAQvAQI7AQIgAyAELwEEOwEEIAMgBC8BBjsBBiADIAQvAQg7AQggBC8BCiEEIAMgDDYCECADIAE2AgwgAyAEOwEKCyALQYABTARAIAAoApgBIgQhAwJAIAQgACgCnAFHDQAgBCIDIANBAXRBASADGyIITg0AAn8gCEUEQEEAIQEgBAwBC0Ho9wFB6PcBKAIAQQFqNgIAIAhBBXRBEEGM0gEoAgARAwAhASAAKAKYAQsiCUEBTgRAQQAhBgNAIAEgBkEFdCIHaiIDIAAoAqABIAdqIgcpAgA3AgAgAyAHKQIYNwIYIAMgBykCEDcCECADIAcpAgg3AgggBkEBaiIGIAlHDQALCyAAKAKgASIDBEAgAC0ApAEEQCADBEBB7PcBQez3ASgCAEEBajYCACADQZDSASgCABEAAAsLIABBADYCoAELIAAgATYCoAEgACAINgKcASAAQQE6AKQBIAAoApgBIQMLIAAgA0EBajYCmAEgBEEFdCIDIAAoAqABaiIBIAUpAwA3AgAgASAFKQMYNwIYIAEgBSkDEDcCECABIAUpAwg3AgggACgCoAEgA2oiASAKIAJBBHRqIgMvAQA7AQAgASADLwECOwECIAEgAy8BBDsBBCABIAMvAQY7AQYgASADLwEIOwEIIAMvAQohAyABIAs2AhAgASACNgIMIAEgAzsBCgsgACAAKAKYATYCqAEgBUEgaiQAC4IGAgd/BX0CQCAALQA8BEACfyACKgIIIAAqAgwiDJMgACoCLCINlCILQwAAgE9dIAtDAAAAAGBxBEAgC6kMAQtBAAshBQJ/IAIqAgQgACoCCCIOkyAAKgIoIg+UIgtDAACAT10gC0MAAAAAYHEEQCALqQwBC0EACyEGAn8gDSADKgIIIAyTlEMAAIA/kiILQwAAgE9dIAtDAAAAAGBxBEAgC6kMAQtBAAshBwJ/IA8gAyoCBCAOk5RDAACAP5IiC0MAAIBPXSALQwAAAABgcQRAIAupDAELQQALIQggACgCiAEiBCABQQR0aiIJLwEAAn8gAioCACAAKgIEIgyTIAAqAiQiDZQiC0MAAIBPXSALQwAAAABgcQRAIAupDAELQQALQf7/A3EiAE0hCgJ/IA0gAyoCACAMk5RDAACAP5IiC0MAAIBPXSALQwAAAABgcQRAIAupDAELQQALIQIgCkUEQCAJIAA7AQALIAQgAUEEdGoiAC8BBiACQQFyIgJJBEAgACACOwEGCyAALwECIAZB/v8DcSICSwRAIAAgAjsBAgsgBCABQQR0aiIAIgJBCGovAQAgCEEBciIDSQRAIAIgAzsBCAsgAC8BBCAFQf7/A3EiAksEQCAAIAI7AQQLIAQgAUEEdGoiAEEKai8BACAHQQFyIgFPDQEgACABOwEKDwsgAioCACILIAAoAmAiACABQQZ0aiIEKgIAXUEBc0UEQCAEIAs4AgALIAIqAgQiCyAEKgIEXUEBc0UEQCAEIAs4AgQLIAIqAggiCyAAIAFBBnRqIgQqAghdQQFzRQRAIAQgCzgCCAsgAioCDCILIAQqAgxdQQFzRQRAIAQgCzgCDAsgACABQQZ0aiICKgIQIAMqAgAiC11BAXNFBEAgAiALOAIQCyACKgIUIAMqAgQiC11BAXNFBEAgAiALOAIUCyAAIAFBBnRqIgAiAUEYaioCACADKgIIIgtdQQFzRQRAIAEgCzgCGAsgACoCHCADKgIMIgtdQQFzDQAgACALOAIcCwvZCAIJfwx9IwBB4ABrIgRCADcDGCAEQgA3AxAgAiABTCIGRQRAIAAtADwhCCABIQcDQAJ9IAgEQCAAKAJ0IAdBBHRqIgUvAQSzIAAqAiwiE5UgACoCDCIUkiENIAUvAQKzIAAqAigiFpUgACoCCCIXkiERIAUvAQCzIAAqAiQiFZUgACoCBCIYkiESIAUvAQqzIBOVIBSSIRMgBS8BCLMgFpUgF5IhFCAFLwEGsyAVlSAYkgwBCyAAKAJMIAdBBnRqIgUqAgghDSAFKgIEIREgBSoCACESIAUqAhghEyAFKgIUIRQgBSoCEAshFSATIA2SQwAAAD+UIA6SIQ4gFCARkkMAAAA/lCAPkiEPIBUgEpJDAAAAP5QgEJIhECAHQQFqIgcgAkcNAAsgBCAOOAIYIAQgDzgCFCAEIBA4AhALIARDAACAPyACIAFrIgiylSINIA6UOAIYIAQgDSAPlDgCFCAEIA0gEJQ4AhAgASEFIAZFBEAgA0ECdCIDIARBEGpqKgIAIRUgAyAEaiEKIAEiByEFA0ACfSAALQA8IgYEQCAAKAJ0IAdBBHRqIgMvAQSzIAAqAiwiEZUgACoCDCISkiEOIAMvAQKzIAAqAigiE5UgACoCCCIUkiEPIAMvAQCzIAAqAiQiDZUgACoCBCIWkiEQIAMvAQqzIBGVIBKSIREgAy8BCLMgE5UgFJIhEiADLwEGsyANlSAWkgwBCyAAKAJMIAdBBnRqIgMqAgghDiADKgIEIQ8gAyoCACEQIAMqAhghESADKgIUIRIgAyoCEAshDSAEQQA2AgwgBCARIA6SQwAAAD+UOAIIIAQgEiAPkkMAAAA/lDgCBCAEIA0gEJJDAAAAP5Q4AgAgCioCACAVXkEBc0UEQAJAIAYEQCAEIAAoAnQiBiAHQQR0aiIDIglBCGopAgA3AyggBCADKQIANwMgIAMgBiAFQQR0IgNqIgYpAgA3AgAgCSAGKQIINwIIIAAoAnQgA2oiAyAEKQMgNwIAIAMgBCkDKDcCCAwBCyAEIAAoAkwiBiAHQQZ0aiIDIglBOGopAgA3A1ggBCADKQIwNwNQIAQgAykCKDcDSCAEQUBrIgsgAykCIDcDACAEIAMpAhg3AzggBCADKQIQNwMwIAQgAykCCDcDKCAEIAMpAgA3AyAgAyAGIAVBBnQiDGoiBikCADcCACADIAYpAgg3AgggAyAGKQIQNwIQIAMgBikCGDcCGCADIAYpAiA3AiAgAyAGKQIoNwIoIAMgBikCMDcCMCAJIAYpAjg3AjggACgCTCAMaiIDIAQpAyA3AgAgAyAEKQMoNwIIIAMgBCkDMDcCECADIAQpAzg3AhggAyALKQMANwIgIAMgBCkDSDcCKCADIAQpA1A3AjAgAyAEKQNYNwI4CyAFQQFqIQULIAdBAWoiByACRw0ACwsgCEEBdSABaiIAIAAgBSAFIAhBA20iAEF/cyACak4bIAUgACABakwbC6UFAgR/EH0gAiABayEFAkAgAiABTARAIAWyIRAMAQsgAC0APCEGIAEhAwNAAn0gBgRAIAAoAnQgA0EEdGoiBC8BBLMgACoCLCILlSAAKgIMIgySIQogBC8BArMgACoCKCIQlSAAKgIIIhGSIQ4gBC8BALMgACoCJCINlSAAKgIEIhKSIQ8gBC8BCrMgC5UgDJIhCyAELwEIsyAQlSARkiEMIAQvAQazIA2VIBKSDAELIAAoAkwgA0EGdGoiBCoCCCEKIAQqAgQhDiAEKgIAIQ8gBCoCGCELIAQqAhQhDCAEKgIQCyENIAcgCyAKkkMAAAA/lJIhByAIIAwgDpJDAAAAP5SSIQggCSANIA+SQwAAAD+UkiEJIANBAWoiAyACRw0AC0MAAIA/IAWyIhCVIgogB5QhESAKIAiUIRIgCiAJlCETQwAAAAAhCSAALQA8IQRDAAAAACEIQwAAAAAhBwNAAn0gBARAIAAoAnQgAUEEdGoiAy8BBLMgACoCLCILlSAAKgIMIgySIQogAy8BArMgACoCKCIUlSAAKgIIIhWSIQ4gAy8BALMgACoCJCINlSAAKgIEIhaSIQ8gAy8BCrMgC5UgDJIhCyADLwEIsyAUlSAVkiEMIAMvAQazIA2VIBaSDAELIAAoAkwgAUEGdGoiAyoCCCEKIAMqAgQhDiADKgIAIQ8gAyoCGCELIAMqAhQhDCADKgIQCyENIAkgCyAKkkMAAAA/lCARkyIJIAmUkiEJIAggDCAOkkMAAAA/lCASkyIIIAiUkiEIIAcgDSAPkkMAAAA/lCATkyIHIAeUkiEHIAFBAWoiASACRw0ACwtBAkEBQwAAgD8gEEMAAIC/kpUiCiAIlCIIIAogCZQiCV0bIAogB5QiByAJXUEBdCAHIAhdGwvOAQAgAEEAOgA8IABBmgI2AjQgAEHssQE2AgAgAEEANgKQASAAQQE6AFAgAEEANgJMIABBAToAZCAAQgA3AkQgAEEANgJgIABBAToAeCAAQgA3AlggAEEANgJ0IABBAToAjAEgAEIANwJsIABBADYCiAEgAEEBOgCkASAAQgA3AoABIABBADYCoAEgAEEANgKoASAAQgA3ApgBIABC////+////79/NwIEIABC////+w83AgwgAEL////79///v/8ANwIUIABC////+wc3AhwLGQAgACABIAAoAggoAjAgACgCACgCCBEFAAtBAQF/IAEgAkcEQCAAKAIEKAKIASIDIAEoAiQgAigCJCADKAIAKAIIEQcAGiAAKAIEIgAgACgCoAFBAWo2AqABCwt3ACAAKAIQQQAgACgCTGtGBEAgAEEEahCmASAAQUBrEKYBIABBgAI7AMEBIABBADYCpAEgAEEANgKQASAAQoqAgIAQNwKcASAAQgE3ApQBIABCADcCfCAAQQA2AoQBIABCADcCqAEgAEIANwKwASAAQgA3ArgBCwvaAgIBfwh9IABBQGsoAgAhAwJAIAAoAgQiAARAIAAqAgAhBiADBEAgACoCFCIEIAMqAhQiBSAEIAVeGyEHIAAqAggiBCADKgIIIgUgBCAFXRshCCAAKgIEIgQgAyoCBCIFIAQgBV0bIQkgACoCECIEIAMqAhAiBSAEIAVeGyEKIAYgAyoCACIEIAYgBF0bIQYgACoCGCIEIAMqAhgiBV5BAXMEQCAFIQQMAwsMAgsgACoCHCEFIAAqAhghBCAAKgIUIQcgACoCECEKIAAqAgwhCyAAKgIIIQggACoCBCEJDAELIANFBEAMAQsgAyoCHCEFIAMqAhghBCADKgIUIQcgAyoCECEKIAMqAgwhCyADKgIIIQggAyoCBCEJIAMqAgAhBgsgASALOAIMIAEgCDgCCCABIAk4AgQgASAGOAIAIAIgBTgCDCACIAQ4AgggAiAHOAIEIAIgCjgCAAuSBQEKfyMAQRBrIgokACAAKAKIASICIAIoAgAoAjgRAQAEQAJ/IAAoAogBIgIgAigCACgCHBEBACIDKAIEIgJBAk4EQCADIApBCGpBACACQX9qEHsgAygCBCECCyACQQFOCwRAA0AgAygCDCALQQR0aiIJKAIEIQYCQAJAIAQgCSgCACIFRkEAIAYgB0YbDQAgBSgCMCIEKgIAIAYoAjAiByoCEF9BAXMNACAEKgIQIAcqAgBgQQFzDQAgBCoCBCAHKgIUX0EBcw0AIAQqAhQgByoCBGBBAXMNACAEKgIIIAcqAhhfQQFzDQAgBCoCGCAHKgIIYA0BCyAAKAKIASICIAkgASACKAIAKAIgEQUAIAlBADYCACAJQQA2AgQgCEEBaiEIIAMoAgQhAgsgBSEEIAYhByALQQFqIgsgAkgNAAsgAkECTgRAIAMgCkEAIAJBf2oQeyADKAIEIQILIAIgCGshACAIQX9MBEAgAygCCCAASARAQQAhASACIQhBACEEAn8gAARAQej3AUHo9wEoAgBBAWo2AgAgAEEEdEEQQYzSASgCABEDACEEIAMoAgQhCAsgCEEBTgsEQANAIAQgAUEEdCIFaiIGIAMoAgwgBWoiBSgCADYCACAGIAUoAgQ2AgQgBiAFKAIINgIIIAYgBSgCDDYCDCABQQFqIgEgCEcNAAsLIAMoAgwiAQRAIAMtABAEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIANBADYCDAsgAyAENgIMIANBAToAECADIAA2AggLA0AgAygCDCACQQR0aiIBQgA3AgAgAUIANwIIIAJBAWoiAiAARw0ACwsgACECCyADIAI2AgQLIApBEGokAAvlBgEIfyMAQSBrIgUkACAAQQRqIgYgACgCmAEgACgCEGxB5ABtQQFqEKUBIAAoAqQBBEAgAEFAayAAKAKUASAAKAJMbEHkAG1BAWoiAhClASAAIAAoAqQBIAJrIgJBACACQQBKGzYCpAELIAAgACgCkAFBAWpBAm8iAjYCkAEgACACQQJ0aigCfCIDBEAgAEFAayEJIAVBEGohBwNAIAMoAjghAgJ/IAMoAjQiBARAIARBOGoMAQsgACADKAI8QQJ0akH8AGoLIAI2AgAgAygCOCIEBEAgBCADKAI0NgI0CyADQQA2AjQgAyAAKAKEATYCOCAAKAKEASIEBEAgBCADNgI0CyAAIAM2AoQBIAYgAygCMBCjASAFIAMpAhg3AwggBSADKQIQNwMAIAcgAykCKDcCCCAHIAMpAiA3AgAgCSAFIAMQQiEEIANBAjYCPCADIAQ2AjAgAiIDDQALIABBAToAwgEgACAAKAJMNgKkAQsgBUH8rwE2AgAgBSAANgIEAkAgAC0AwQFFDQAgBiAAKAIEIABBQGsoAgAgBRDSASAALQDBAUUNACAGIAYoAgAiAiACIAUQ0gELAkAgAC0AwgFFDQAgACgCiAEiAiACKAIAKAIcEQEAIgcoAgQiBEEBSA0AIAACfyAEIAAoAqABIgMgACgCnAEgBGxB5ABtIgIgAyACShsiAiAEIAJIGyIGQQFOBEBBACEDA0ACQAJAIAcoAgwgACgCuAEgA2ogBG9BBHRqIgIoAgAiCSgCMCIIKgIAIAIoAgQiBCgCMCICKgIQX0EBcw0AIAgqAhAgAioCAGBBAXMNACAIKgIEIAIqAhRfQQFzDQAgCCoCFCACKgIEYEEBcw0AIAgqAgggAioCGF9BAXMNACAIKgIYIAIqAghgDQELIAAoAogBIgIgCSAEIAEgAigCACgCDBEKABogA0F/aiEDIAZBf2ohBgsgBygCBCEEIANBAWoiAyAGSA0AC0EAIARBAEwNARoLIAAoArgBIAZqIARvCzYCuAELIABBADoAwgEgAEEBNgKgASAAIAAoArQBQQFqNgK0ASAAKAKsASECIAACfUMAAAAAIAAoAqgBIgFFDQAaIAKzIAGzlQs4ArABIAAgAkEBdjYCrAEgACABQQF2NgKoASAFQSBqJAALEAAgACABEN4KIAAgARDdCguXBgIDfwp9IwBBMGsiBCQAIAQgAikCCDcDGCAEIAIpAgA3AxAgBCADKQIINwMoIAQgAykCADcDIAJAIAEoAjxBAkYEQCAAQUBrIAEoAjAQowEgASAAQQRqIARBEGogARBCNgIwQQEhBgwBC0EBIQYgACAAKAKoAUEBajYCqAECQCABKAIwIgUqAgAgBCoCIF9BAXMNACAFKgIQIAQqAhBgQQFzDQAgBSoCBCAEKgIkX0EBcw0AIAUqAhQgBCoCFGBBAXMNACAFKgIIIAQqAihfQQFzDQAgBSoCGCAEKgIYYEEBcw0AIAEqAhQhCyABKgIYIQwgAioCACEOIAIqAgQhDyACKgIIIRAgASoCECENIAEqAiQhCSABKgIoIQogASoCICERIAAqAowBIQggBEEANgIMIAQgCCAKIAyTQwAAAD+UlCIKOAIIIAQgCCAJIAuTQwAAAD+UlCIJOAIEIAQgCCARIA2TQwAAAD+UlCIIOAIAIA4gDZNDAAAAAF1BAXNFBEAgBCAIjDgCAAsgDyALk0MAAAAAXUEBc0UEQCAEIAmMOAIECyAQIAyTQwAAAABdQQFzRQRAIAQgCow4AggLQQAhBiAAQQRqIAUgBEEQaiAEQ83MTD0QzAFFDQFBASEGIAAgACgCrAFBAWo2AqwBDAELIABBBGogBSAEQRBqEKQBIAAgACgCrAFBAWo2AqwBCyABKAI4IQcCfyABKAI0IgUEQCAFQThqDAELIAAgASgCPEECdGpB/ABqCyAHNgIAIAEoAjgiBQRAIAUgASgCNDYCNAsgASACKQIANwIQIAEgAikCCDcCGCABIAMpAgA3AiAgASADKQIINwIoIAEgACgCkAEiAjYCPCABQQA2AjQgASAAIAJBAnRqIgJB/ABqKAIANgI4IAIoAnwiAwRAIAMgATYCNAsgAiABNgJ8AkAgBkUNACAAQQE6AMIBIAAtAMEBDQAgBEH8rwE2AgAgBCAANgIEIABBQGsiAiACKAIAIAEoAjAgBBDSASAAQQRqIAAoAgQgASgCMCAEENIBCyAEQTBqJAALegEBfyMAQTBrIgQkACAEIAM2AiwgBEGMsQE2AiggBCABKQIINwMQIAQgASkCADcDCCAEIAIpAgg3AyAgBCACKQIANwMYIABBBGogACgCBCAEQQhqIARBKGoQaSAAQUBrIgAgACgCACAEQQhqIARBKGoQaSAEQTBqJAALcgEDfyMAQRBrIgYkACAGQcSwATYCCCAGIAM2AgwgAEEEaiAAKAIEIAEgA0EEaiIHIANBFGoiCCADKgIgIAQgBSAGQQhqEOsDIABBQGsiACAAKAIAIAEgByAIIAMqAiAgBCAFIAZBCGoQ6wMgBkEQaiQAC6MBAQJ/IABBQGsgAEEEaiABKAI8QQJGGyABKAIwEKMBIAEoAjghAwJ/IAEoAjQiBARAIARBOGoMAQsgACABKAI8QQJ0akH8AGoLIAM2AgAgASgCOCIDBEAgAyABKAI0NgI0CyAAKAKIASIDIAEgAiADKAIAKAIQEQUAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACyAAQQE6AMIBC94CACMAQTBrIgckAEHo9wFB6PcBKAIAQQFqNgIAQcAAQRBBjNIBKAIAEQMAIgMgBjsBBiADIAU7AQQgAyAENgIAIAMgASkCADcCECADIAEpAgg3AhggAyACKQIANwIgIAMgAikCCDcCKCADQQA2AgggA0IANwI0IAcgASkCCDcDGCAHIAEpAgA3AxAgByACKQIINwMoIAcgAikCADcDICADIAAoApABNgI8IAAgACgCvAFBAWoiATYCvAEgAyABNgIMIAMgAEEEaiICIAdBEGogAxBCNgIwIAAoApABIQEgA0EANgI0IAMgACABQQJ0aiIBKAJ8NgI4IAEoAnwiBARAIAQgAzYCNAsgASADNgJ8IAAtAMEBRQRAIAcgAzYCCCAHQfyvATYCACAHIAA2AgQgAiAAKAIEIAdBEGogBxBpIABBQGsiACAAKAIAIAdBEGogBxBpCyAHQTBqJAAgAwtkAQF/IABBnK8BNgIAIAAtAMABBEAgACgCiAEiASABKAIAKAIAEQEAGiAAKAKIASIBBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBQGsQQyAAQQRqEEMgABAOC2IBAX8gAEGcrwE2AgAgAC0AwAEEQCAAKAKIASIBIAEoAgAoAgARAQAaIAAoAogBIgEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEFAaxBDIABBBGoQQyAACxgAIAAoAgQiACABKAIARiABKAIEIABGcgs7AQF/IAAoAgQiAiABKAIAR0EAIAEoAgQgAkcbRQRAIAAoAggiAiABIAAoAgwgAigCACgCIBEFAAtBAAsJACAAIAE2AhgLYwECf0Gs9wFBrPcBKAIAQQFqNgIAAkACQCAAKAIYIgQEQCAEIAEgAiAEKAIAKAIIEQcADQEMAgsgAi8BBiABLwEEcUUNASABLwEGIAIvAQRxRQ0BCyAAIAEgAhDuCiEDCyADC8sFAQl/IwBBIGsiAiQAIAJBADYCFCACQgA3AgwgAkEBOgAYAkAgACgCCEEBSA0AA0AgACgCECAKQQR0aiEGAkAgAyAERw0AIAMgA0EBdEEBIAMbIgROBEAgAyEEDAELQQAhB0EAIQUgBARAQej3AUHo9wEoAgBBAWo2AgAgBEEEdEEQQYzSASgCABEDACEFCyADQQFOBEADQCAFIAdBBHQiCGoiCSACKAIUIAhqIggoAgA2AgAgCSAIKAIENgIEIAkgCCgCCDYCCCAJIAgoAgw2AgwgB0EBaiIHIANHDQALCyACKAIUIgMEQCACLQAYBEAgAwRAQez3AUHs9wEoAgBBAWo2AgAgA0GQ0gEoAgARAAALCyACQQA2AhQLIAIgBTYCFCACQQE6ABggAiAENgIQIAIoAgwhBAsgAigCFCAEQQR0aiIDIAYoAgA2AgAgAyAGKAIENgIEIAMgBigCCDYCCCADIAYoAgw2AgwgAiACKAIMIgZBAWoiBDYCDCAKQQFqIgogACgCCEgEQCACKAIQIQMMAQsLQQAhAyAGQQBIDQAgAigCFCEHA0AgACAHIANBBHRqIgUoAgAgBSgCBCABIAAoAgAoAgwRCgAaIAMgBkYhBSADQQFqIQMgBUUNAAsLAn8gACgCOEEBTgRAIABBQGsoAgAhAUEAIQQDQCABIARBAnRqQX82AgAgBEEBaiIEIAAoAjhIDQALIAIoAgwhBAsgBEECTgsEQCACQQhqIAJBACAEQX9qEHsgAigCDCEECyACKAIUIQMgBEEBTgRAQQAhBANAIAAgAyAEQQR0aiIBKAIAIAEoAgQgACgCACgCCBEHABogAigCFCEDIARBAWoiBCACKAIMSA0ACwsgAwRAIAItABgEQCADBEBB7PcBQez3ASgCAEEBajYCACADQZDSASgCABEAAAsLIAJBADYCFAsgAkEgaiQAC3ABAn8gACgCCEEBTgRAA0ACQCABIAAoAhAgA0EEdGoiBCABKAIAKAIIEQMABEAgACAEKAIAIAQoAgQgAiAAKAIAKAIMEQoAGkGk9wFBpPcBKAIAQX9qNgIADAELIANBAWohAwsgAyAAKAIISA0ACwsLzgUBCH9BqPcBQaj3ASgCAEEBajYCAAJAIAAoAiwgACgCDEF/aiABIAIgASgCDCACKAIMSiIEGyIGKAIMIgVBEHQgAiABIAQbIgooAgwiB3IiASABQQ90QX9zaiIBQQp1IAFzQQlsIgFBBnUgAXMiASABQQt0QX9zaiIBQRB1IAFzcSIIQQJ0aigCACIBQX9GDQAgACgCECEEA0AgByAEIAFBBHRqIgIoAgAoAgxGQQAgAigCBCgCDCAFRhtFBEAgACgCQCABQQJ0aigCACIBQX9HDQEMAgsLIAAgAiADIAAoAgAoAiARBQAgBCABQQR0aigCDCEJIAAoAkAhBQJAAkAgACgCLCAIQQJ0aiIHKAIAIgEgAiAAKAIQa0EEdSIERgRAIAUgBEECdGooAgAhAQwBCwNAIAUgASICQQJ0aiIIKAIAIgEgBEcNAAsgBSAEQQJ0aigCACEBIAJBf0YNACAIIAE2AgAMAQsgByABNgIACyAAKAIIQX9qIQUgACgCSCIBBEAgASAKIAYgAyABKAIAKAIMEQoAGgsgBCAFRgRAIAAgACgCCEF/ajYCCCAJDwsgACgCQCEDAkACQCAFIAAoAiwgACgCDEF/aiAAKAIQIgogBUEEdGoiBigCBCgCDEEQdCAGKAIAKAIMciIBIAFBD3RBf3NqIgFBCnUgAXNBCWwiAUEGdSABcyIBIAFBC3RBf3NqIgFBEHUgAXNxIgdBAnRqIggoAgAiAUYEQCADIAVBAnRqKAIAIQEMAQsDQCADIAEiAkECdGoiCygCACIBIAVHDQALIAMgBUECdGooAgAhASACQX9GDQAgCyABNgIADAELIAggATYCAAsgCiAEQQR0aiIBIAYpAgA3AgAgASAGKQIINwIIIAAoAkAgBEECdGogACgCLCAHQQJ0aiIBKAIANgIAIAEgBDYCACAAIAAoAghBf2o2AggLIAkLlQUBCn8CQCAAKAIsIAEgAiABKAIMIAIoAgxKIgQbIggoAgwiBUEQdCACIAEgBBsiCSgCDCIHciIBIAFBD3RBf3NqIgFBCnUgAXNBCWwiAUEGdSABcyIBIAFBC3RBf3NqIgFBEHUgAXMiCyAAKAIMIgRBf2pxIgpBAnRqKAIAIgFBf0cEQCAAKAIQIQMDQCAHIAMgAUEEdCIGaiICKAIAKAIMRkEAIAMgBmooAgQoAgwgBUYbDQIgACgCQCABQQJ0aigCACIBQX9HDQALCyAAKAIIIgUhAgJAIAUgBCIBRw0AIAQhAiABIAFBAXRBASABGyIDTg0AAn8gA0UEQEEAIQIgBAwBC0Ho9wFB6PcBKAIAQQFqNgIAIANBBHRBEEGM0gEoAgARAwAhAiAAKAIICyIMQQFOBEBBACEBA0AgAiABQQR0IgZqIgcgACgCECAGaiIGKAIANgIAIAcgBigCBDYCBCAHIAYoAgg2AgggByAGKAIMNgIMIAFBAWoiASAMRw0ACwsgACgCECIBBEAgAC0AFARAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgIQCyAAIAI2AhAgACADNgIMIABBAToAFCAAKAIIIQIgAyEBCyAAIAJBAWo2AgggACgCECEDIAAoAkgiAgRAIAIgCSAIIAIoAgAoAggRBwAaIAAoAgwhAQsgAyAFQQR0aiECIAQgAUgEQCAAEO8DIAAoAgxBf2ogC3EhCgsgAiAJIAggCSgCDCAIKAIMSCIBGzYCACADIAVBBHRqIgRCADcCCCAEIAggCSABGzYCBCAAQUBrKAIAIAVBAnRqIAAoAiwgCkECdGoiACgCADYCACAAIAU2AgALIAIL6AEBBH9BsPcBQbD3ASgCAEEBajYCAAJAAkAgACgCDEF/aiABIAIgASgCDCACKAIMSiIDGygCDCIEQRB0IAIgASADGygCDCIFciIBIAFBD3RBf3NqIgFBCnUgAXNBCWwiAUEGdSABcyIBIAFBC3RBf3NqIgFBEHUgAXNxIgEgACgCJE4NACAAKAIsIAFBAnRqKAIAIgFBf0YNACAAKAIQIQIDQCAFIAIgAUEEdCIGaiIDKAIAKAIMRkEAIAIgBmooAgQoAgwgBEYbDQIgACgCQCABQQJ0aigCACIBQX9HDQALC0EAIQMLIAMLOAEBfyMAQRBrIgMkACADIAE2AgwgA0H4rQE2AgggACADQQhqIAIgACgCACgCMBEFACADQRBqJAALQwEBfyMAQRBrIgMkACADIAI2AgwgAyAANgIIIAMgATYCBCADQeisATYCACAAIAMgAiAAKAIAKAIwEQUAIANBEGokAAs7AAJAIAJFDQAgASgCCCIARQ0AIAAgACgCACgCABEBABogAiABKAIIIAIoAgAoAjwRAgAgAUEANgIICwsJACAAEO4DEA4L/AIBCX8CQCAAIAFBAnRqKAJEIAJBAnRqIgIvAQYiBEUNACABQQF0IgkgACgCPCACLwECQQZ0amohCkEBQQEgAXRBA3EiC3RBA3EhDCACLwEAIQEDQCABQf//A3EgAi8BBCIBSQ0BIAAoAjwhBQJ/IAFBAXEEQAJAIAUgAi8BAkEGdGoiBiALQQF0IgFqIgcvATYgASAFIARBBnRqIghqIgEvATBJDQAgAS8BNiAHLwEwSQ0AIAYgDEEBdCIBaiIHLwE2IAEgCGoiAS8BMEkNACABLwE2IAcvATBJDQAgACgCXCIBIAYgCCADIAEoAgAoAgwRCgAaIAAoAmAiAUUNACABIAYgCCADIAEoAgAoAgwRCgAaCyAFIARBBnRqIAlqQTZqDAELIAUgBEEGdGogCWpBMGoLIgEgAS8BAEF/ajsBACAKIAovATBBAWo7ATAgAigBBCEEIAIgAigBACIBNgEEIAIgBDYBACACIgRBBGohAiAELwEKIgQNAAsLC5MDAQx/AkAgACABQQJ0aigCRCACQQJ0aiICLwEGIgNFDQAgACgCPCACLwECQQZ0aiIEQTZqIgUgAUEBdCIIaiEJIARBMGoiBEEBIAF0QQNxIgFBAXQiCmohDCAFIApqIQ0gBEEBIAF0QQNxQQF0IgtqIQ4gBSALaiEFIAIvAQAhAQNAIAFB//8DcSACLwEEIgFJDQEgACgCPCEGAn8gAUEBcUUEQAJAIA0vAQAgBiADQQZ0aiIHIApqIgEvATBJDQAgAS8BNiAMLwEASQ0AIAUvAQAgByALaiIBLwEwSQ0AIAEvATYgDi8BAEkNACAAKAJcIgQgBiACLwECQQZ0aiIBIAcgBCgCACgCCBEHABogACgCYCIERQ0AIAQgASAHIAQoAgAoAggRBwAaCyAGIANBBnRqIAhqQTBqDAELIAYgA0EGdGogCGpBNmoLIgEgAS8BAEF/ajsBACAJIAkvAQBBAWo7AQAgAigBBCEDIAIgAigBACIBNgEEIAIgAzYBACACIgNBBGohAiADLwEKIgMNAAsLCwQAQQALSAEBfyAAQeCqATYCAAJAIAAoAhAiAUUNACAALQAURQ0AIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgABAOC18BAX8gAEHgqgE2AgAgACgCECIBBEAgAC0AFARAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgIQCyAAQQA2AhAgAEIANwIIIABBAToAFCAACykAIAAQtAIiAARAQez3AUHs9wEoAgBBAWo2AgAgAEGQ0gEoAgARAAALC10BAn8gAC8BOEUEQEEBIQEgAEEBOwFAIAAoAjwhAiAALwE6IgNBAUsEQANAIAIgAUEGdGogAUEBaiIBOwEwIAEgAC8BOiIDSQ0ACwsgA0EGdCACakFwakEAOwEACwsqACABIAApAgg3AgAgASAAKQIQNwIIIAIgACkCIDcCCCACIAApAhg3AgAL1QcBCn8jAEEQayIKJAAgACgCXCIDIAMoAgAoAjgRAQAEQCAAKAJcIgMgAygCACgCHBEBACICKAIEIghBAk4EQCACIApBCGpBACAIQX9qEHsgAigCBCEICyAIIAAoAmgiA2shBSADQX9MBEAgAigCCCAFSARAAn8gBUUEQEEAIQMgCAwBC0Ho9wFB6PcBKAIAQQFqNgIAIAVBBHRBEEGM0gEoAgARAwAhAyACKAIECyIHQQFOBEADQCADIAlBBHQiBmoiBCACKAIMIAZqIgYoAgA2AgAgBCAGKAIENgIEIAQgBigCCDYCCCAEIAYoAgw2AgwgCUEBaiIJIAdHDQALCyACKAIMIgYEQCACLQAQBEAgBgRAQez3AUHs9wEoAgBBAWo2AgAgBkGQ0gEoAgARAAALCyACQQA2AgwLIAIgAzYCDCACQQE6ABAgAiAFNgIICwNAIAIoAgwgCEEEdGoiA0IANwIAIANCADcCCCAIQQFqIgggBUcNAAsLIAIgBTYCBCAAQQA2AmggAiAFQQFOBH9BACEIQQAhA0EAIQYDQCACKAIMIAtBBHRqIgkoAgQhBAJAAkAgAyAJKAIAIgdGQQAgBCAGRhsNACAHLwE2IAQvATBJDQAgBC8BNiAHLwEwSQ0AIAcvATggBC8BMkkNACAELwE4IAcvATJJDQAgBy8BOiAELwE0SQ0AIAQvATogBy8BNE8NAQsgACgCXCIDIAkgASADKAIAKAIgEQUAIAlBADYCACAJQQA2AgQgACAAKAJoQQFqIgg2AmhBpPcBQaT3ASgCAEF/ajYCACACKAIEIQULIAchAyAEIQYgC0EBaiILIAVIDQALIAVBAk4EQCACIApBACAFQX9qEHsgACgCaCEIIAIoAgQhBQsgBSAIayEEIAhBf0wEQCACKAIIIARIBEBBACEJIAUhA0EAIQYCfyAEBEBB6PcBQej3ASgCAEEBajYCACAEQQR0QRBBjNIBKAIAEQMAIQYgAigCBCEDCyADQQFOCwRAA0AgBiAJQQR0IgFqIgcgAigCDCABaiIBKAIANgIAIAcgASgCBDYCBCAHIAEoAgg2AgggByABKAIMNgIMIAlBAWoiCSADRw0ACwsgAigCDCIBBEAgAi0AEARAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAkEANgIMCyACIAY2AgwgAkEBOgAQIAIgBDYCCAsDQCACKAIMIAVBBHRqIgFCADcCACABQgA3AgggBUEBaiIFIARHDQALCyAEBSAFCzYCBCAAQQA2AmgLIApBEGokAAv8AQEFfyAAKAJsIgVFBEAgAC8BOCIGBEBBASEFQQEhBwNAAkAgACgCRCAFQQJ0aiIELQAAQQFxRQ0AQQAhCAJ/QQAgASoCACAAKAI8IAQvAQJBBnRqIgQqAiBeDQAaQQAgAioCACAEKgIQXQ0AGkEBCyEFAkAgASoCCCAEKgIoXg0AIAIqAgggBCoCGF0NACAFIQgLIAEqAgQgBCoCJF4NACACKgIEIAQqAhRdDQAgCEEBcw0AIAMgBCADKAIAKAIIEQMAGiAALwE4IQYLIAZBAXRBAXIgB0EBaiIHQf//A3EiBUsNAAsLDwsgBSABIAIgAyAFKAIAKAIcEQQAC5MBAQF/IAAoAmwiBkUEQCAALwE4IgIEQEEBIQRBASEBA0AgACgCRCAEQQJ0aiIELQAAQQFxBEAgAyAAKAI8IAQvAQJBBnRqIAMoAgAoAggRAwAaIAAvATghAgsgAkH//wNxQQF0QQFyIAFBAWoiAUH//wNxIgRLDQALCw8LIAYgASACIAMgBCAFIAYoAgAoAhgRDAALigIBCX8jAEEQayIGJAAgACgCPCEIIAAgBkEKaiACQQAQ0wEgACAGQQRqIANBARDTASAIIAFBBnRqIQgDQCAAIAVBAnRqKAJEIgcgCCAFQQF0IgFqIgMvATAiAkECdGoiCS8BACEKIAcgAy8BNiIDQQJ0aiIHLwEAIQsgBkEEaiABaiIMLwEAIQ0gCSAGQQpqIAFqLwEAIgE7AQAgByAMLwEAOwEAIAEgCmsiAUF/TARAIAAgBSACEPEDCyANIAtrIgdBAU4EQCAAIAUgAxD1CgsgAUEBTgRAIAAgBSACIAQQ9AoLIAdBf0wEQCAAIAUgAyAEEPADCyAFQQFqIgVBA0cNAAsgBkEQaiQAC1wAIAEgAikCADcCECABIAIpAgg3AhggASADKQIANwIgIAEgAykCCDcCKCAAIAEvAQwgAiADIAQQ/wogACgCbCIABEAgACABKAI8IAIgAyAEIAAoAgAoAhARCQALC/QEAQp/IAAoAjwhCSAAKAJcIgMgAygCACgCOBEBAEUEQCAAKAJcIgMgCSABQQZ0aiACIAMoAgAoAhARBQALIAAvATghAyAAKAI8IgIgAi8BNkF+ajsBNiACIAIvAThBfmo7ATggAiACLwE6QX5qOwE6IAAvAQYhAiADQQF0QX9qQQJ0IQoDQCAAIAZBAnRqIgtBxABqKAIAIgcgBkEBdCIIIAkgAUEGdGpqIgwvATZBAnQiBWoiAyACOwEAAn8gByADLwEGIgRFDQAaIAAoAjwgBSAHai8BAkEGdGogCGohBQNAIAJB//8DcSADLwEEIgJPBEAgACgCPCAEQf//A3FBBnRqIAhqIgRBNmogBEEwaiACQQFxGyICIAIvAQBBf2o7AQAgBSAFLwE2QQFqOwE2IAMoAQQhBCADIAMoAQAiAjYBBCADIAQ2AQAgAyIEQQRqIQMgBC8BCiIEDQELCyAALwEGIQIgCygCRAshBCAHIAwvATBBAnQiA2ogAjsBACADIARqIgMvAQYiBARAIAAoAjwgAy8BAkEGdGogCGohBSADLwEAIQIDQCACQf//A3EgAy8BBCICTwRAIAAoAjwgBEH//wNxQQZ0aiAIaiIEQTZqIARBMGogAkEBcRsiAiACLwEAQX9qOwEAIAUgBS8BMEEBajsBMCADKAEEIQQgAyADKAEAIgI2AQQgAyAENgEAIAMiBEEEaiEDIAQvAQoiBA0BCwsgAC8BBiECCyAHIApqIgMgAjsBACADQQA7AQIgBkEBaiIGQQNHDQALIAAoAjwgAUEGdGogAC8BQDsBMCAAIAE7AUAgACAALwE4QX9qOwE4Cy4BAX8gACgCbCIDBEAgAyABKAI8IAIgAygCACgCDBEFAAsgACABLwEMIAIQgQsL4wkBBX8jAEEQayIJJAAgACAJQQpqIAFBABDTASAAIAlBBGogAkEBENMBIAAgACgCPCIBIAAvAUAiCkEGdGoiCC8BMDsBQCAAIAAvAThBAWoiAjsBOCAIIAc2AgggCCAFOwEGIAggBDsBBCAIIAM2AgAgCCAKNgIMIAEgAS8BNkECajsBNiAAKAJEIgcgAkEBdCICQf7/A3EiAUECdCIDQQRyIgVqIAcgAUF/aiIEQQJ0IgFqKAEANgEAIAkvAQohByAAKAJEIgsgAWoiDCAKOwECIAwgBzsBACAJLwEEIQcgAyALaiILIAo7AQIgCyAHOwEAIAggAjsBNiAIIAQ7ATAgACgCPCIHQThqIAcvAThBAmo7AQAgACgCSCIHIAVqIAEgB2ooAQA2AQAgCS8BDCEHIAAoAkgiCyABaiIMIAo7AQIgDCAHOwEAIAkvAQYhByADIAtqIgsgCjsBAiALIAc7AQAgCCACOwE4IAggBDsBMiAAKAI8IgdBOmogBy8BOkECajsBACAFIAAoAkwiBWogASAFaigBADYBACAJLwEOIQUgASAAKAJMIgFqIgcgCjsBAiAHIAU7AQAgCS8BCCEFIAEgA2oiASAKOwECIAEgBTsBACAIIAI7ATogCCAEOwE0IAAoAkQiAyAILwEwQQJ0IgVqIgIvAQAgAkF8aiIBLwEAIgRJBEAgACgCPCIHIAMgBWovAQJBBnRqIQUDQCAHIAJBfGoiAy8BAkEGdGoiB0E2aiAHQTBqIARBAXEbIgQgBC8BAEEBajsBACAFIAUvATBBf2o7ATAgAigBACEEIAIgASgBADYBACABIAQ2AQAgAy8BACABQXxqIgEvAQAiBE9FBEAgACgCPCEHIAMhAgwBCwsgACgCRCEDCwJAIAMgCC8BNiIFQQJ0aiICLwEAIAJBfGoiAS8BACIETw0AIAAoAjwiByADIAVBAnRqLwECQQZ0aiEFA0AgByACQXxqIgMvAQJBBnRqIgdBNmogB0EwaiAEQQFxGyIEIAQvAQBBAWo7AQAgBSAFLwE2QX9qOwE2IAIoAQAhBCACIAEoAQA2AQAgASAENgEAIAMvAQAgAUF8aiIBLwEAIgRPDQEgACgCPCEHIAMhAgwAAAsACyAAKAJIIgMgCC8BMkECdCIFaiICLwEAIAJBfGoiAS8BACIESQRAIAAoAjwiByADIAVqLwECQQZ0aiEFA0AgByACQXxqIgMvAQJBBnRqIgdBOGogB0EyaiAEQQFxGyIEIAQvAQBBAWo7AQAgBSAFLwEyQX9qOwEyIAIoAQAhBCACIAEoAQA2AQAgASAENgEAIAMvAQAgAUF8aiIBLwEAIgRPRQRAIAAoAjwhByADIQIMAQsLIAAoAkghAwsCQCADIAgvATgiBUECdGoiAi8BACACQXxqIgEvAQAiBE8NACAAKAI8IgcgAyAFQQJ0ai8BAkEGdGohBQNAIAcgAkF8aiIDLwECQQZ0aiIHQThqIAdBMmogBEEBcRsiBCAELwEAQQFqOwEAIAUgBS8BOEF/ajsBOCACKAEAIQQgAiABKAEANgEAIAEgBDYBACADLwEAIAFBfGoiAS8BACIETw0BIAAoAjwhByADIQIMAAALAAsgAEECIAgvATQQ8QMgAEECIAgvATogBhDwAyAJQRBqJAAgCgtaAQF/IAAgASACIAQgBSAGIAcgCBCDCyEIIAAoAjwhCSAAKAJsIgAEQCAJIAhBBnRqIAAgASACIAMgBCAFIAYgB0EAIAAoAgAoAggRIAA2AjwLIAkgCEEGdGoLKgAgABC0AhogAARAQez3AUHs9wEoAgBBAWo2AgAgAEGQ0gEoAgARAAALC9EGAQF9IABCADcCaCAAQQA6AGQgAEEANgJgIAAgBDYCXCAAQf//AzsBBiAAQf7/AzsBBCAAQaCqATYCACAERQRAAn9B6PcBQej3ASgCAEEBajYCAEHMAEEQQYzSASgCABEDACIECxCzAiAAQQE6AGQgACAENgJcCyAFRQRAQej3AUHo9wEoAgBBAWo2AgBBGEEQQYzSASgCABEDACIEQQA2AhQgBEIANwIEIARB4KoBNgIAIARCADcCDCAEQQE6ABQgBEEANgIIIAAgBDYCcAJ/Qej3AUHo9wEoAgBBAWo2AgBBxAFBEEGM0gEoAgARAwAiBAsgACgCcBDtAyAAIAQ2AmwgBEEBOgDBAQsgACABKQIANwIIIAAgASkCCDcCECAAIAIpAgg3AiAgACACKQIANwIYIABBADYCNCAAIAAvAQazIgYgACoCICAAKgIQk5U4AjAgACAGIAAqAhwgACoCDJOVOAIsIAAgBiAAKgIYIAAqAgiTlTgCKEHo9wFB6PcBKAIAQQFqNgIAIANBAWoiA0H//wNxIgJBBnQiBEEQQYzSASgCABEDACEBIAIEQCABIARqIQUgASEEA0AgBEEANgIIIARBADYCACAEQUBrIgQgBUcNAAsLIAAgAzsBOiAAIAE2AjxBASEEIABBATsBQCAAQQA7ATggAkEBSwRAA0AgASAEQQZ0aiAEQQFqIgQ7ATAgAiAERw0ACwsgAkEGdCABakFwakEAOwEAQej3AUHo9wEoAgBBAWo2AgAgACACQQN0IgFBEEGM0gEoAgARAwAiAjYCRCAAIAI2AlBB6PcBQej3ASgCAEEBajYCACAAIAFBEEGM0gEoAgARAwAiAjYCSCAAIAI2AlRB6PcBQej3ASgCAEEBajYCACAAIAFBEEGM0gEoAgARAwAiATYCTCAAIAE2AlggACgCPCIBQQA7ATAgAUEANgIAIAFBATsBNiAAKAJEIgJBADYBACAALwEGIQMgAkEAOwEGIAIgAzsBBCABQQE7ATggAUEAOwEyIAAoAkgiAkEANgEAIAAvAQYhAyACQQA7AQYgAiADOwEEIAFBATsBOiABQQA7ATQgACgCTCIBQQA2AQAgAC8BBiEAIAFBADsBBiABIAA7AQQLBABBHAspACAAEPgDIgAEQEHs9wFB7PcBKAIAQQFqNgIAIABBkNIBKAIAEQAACwuhAwEFfwJAIAAtAKQBBEAgACgChAEgAU4NASABBEBB6PcBQej3ASgCAEEBajYCACABQQJ0QRBBjNIBKAIAEQMAIQMLIAAoAogBIQICQAJAIAAoAoABIgVBAU4EQANAIAMgBEECdCIGaiACIAZqKAIANgIAIARBAWoiBCAFRw0ADAIACwALIAJFDQELIAAtAIwBBEAgAgRAQez3AUHs9wEoAgBBAWo2AgAgAkGQ0gEoAgARAAALCyAAQQA2AogBCyAAIAM2AogBIAAgATYChAEgAEEBOgCMAQ8LIAAoApgBIAFODQAgAQRAQej3AUHo9wEoAgBBAWo2AgAgAUEBdEEQQYzSASgCABEDACEDCyAAKAKcASECAkACQCAAKAKUASIFQQFOBEADQCADIARBAXQiBmogAiAGai8BADsBACAEQQFqIgQgBUcNAAwCAAsACyACRQ0BCyAALQCgAQRAIAIEQEHs9wFB7PcBKAIAQQFqNgIAIAJBkNIBKAIAEQAACwsgAEEANgKcAQsgACADNgKcASAAIAE2ApgBIABBAToAoAELC5kDAQV/AkAgAC0ApQEEQCAAKAJcIAFODQEgAQR/Qej3AUHo9wEoAgBBAWo2AgAgAUEEdEEQQYzSASgCABEDAAVBAAshAyAAKAJYIgJBAU4EQANAIAMgBEEEdCIFaiIGIAAoAmAgBWoiBSkCADcCACAGIAUpAgg3AgggBEEBaiIEIAJHDQALCyAAKAJgIgIEQCAALQBkBEAgAgRAQez3AUHs9wEoAgBBAWo2AgAgAkGQ0gEoAgARAAALCyAAQQA2AmALIAAgAzYCYCAAIAE2AlwgAEEBOgBkDwsgACgCcCABTg0AIAEEQEHo9wFB6PcBKAIAQQFqNgIAIAFBAnRBEEGM0gEoAgARAwAhAwsgACgCdCECAkACQCAAKAJsIgVBAU4EQANAIAMgBEECdCIGaiACIAZqKAIANgIAIARBAWoiBCAFRw0ADAIACwALIAJFDQELIAAtAHgEQCACBEBB7PcBQez3ASgCAEEBajYCACACQZDSASgCABEAAAsLIABBADYCdAsgACADNgJ0IAAgATYCcCAAQQE6AHgLCyoAIAEgACkCNDcCACABIAApAjw3AgggAiAAKQJMNwIIIAIgACkCRDcCAAsxACAAIAEpAgA3AjQgACABKQIINwI8IAAgAikCADcCRCAAIAIpAgg3AkwgAEEBNgIwCwoAIAAoAjBBAUYLfwEBfyAAQainATYCACAAKAIgIgEEQCAALQAkBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AiALIABBADYCICAAQgA3AhggAEEBOgAkIAAEQEHs9wFB7PcBKAIAQQFqNgIAIABBkNIBKAIAEQAACwvaCQENfyMAQSBrIgQkACAAIAAoAgAoAhwRAQAhAyABQQA2AgAgASADNgIUIAMEQCABIAIgAkEgIAMgAigCACgCEBEHACIOKAIIIgggAigCACgCHBEDADYCACAAIAAoAgAoAhwRAQAiD0EASgRAA0AgACAEQRxqIARBBGogBEEQaiAEQQhqIARBGGogBEEUaiAEIARBDGogDSAAKAIAKAIQERsAIAggBCgCACIDNgIYIAQoAgQhBSAIQgA3AgAgCCAFNgIcIAhCADcCCCAIQgA3AhACQCAEKAIMQX5qIgVBA0sNAAJAAkACQCAFQQFrDgMBAwIACyADRQ0CIAggAiACQQQgA0EDbCACKAIAKAIQEQcAIgUoAggiCSACKAIAKAIcEQMANgIIIAQoAgBBAU4EQEEAIQMgBCgCGCEKA0AgCSADQQxsaiIGIAogBCgCFCADbGoiBygCADYCACAGIAcoAgQ2AgQgBiAHKAIINgIIIANBAWoiAyAEKAIASA0ACwsgAiAFQeqlAUHBpIXKBSAFKAIIIAIoAgAoAhQRCQAMAgsgA0UNASAIIAIgAkEIIAMgAigCACgCEBEHACIFKAIIIgkgAigCACgCHBEDADYCDCAEKAIAIgpBAU4EQEEAIQMgBCgCFCELIAQoAhghDANAIAkgA0EDdGoiBiAMIAMgC2xqIgcvAQA7AQAgBiAHLwECOwECIAYgBy8BBDsBBCADQQFqIgMgCkcNAAsLIAIgBUH5pQFBwaSFygUgBSgCCCACKAIAKAIUEQkADAELIANFDQAgCCACIAJBBCADIAIoAgAoAhARBwAiBSgCCCIJIAIoAgAoAhwRAwA2AhBBACEDIAQoAgBBAU4EQANAIAkgA0ECdGoiBiAEKAIYIAQoAhQgA2xqIgctAAA6AAAgBiAHLQABOgABIAYgBy0AAjoAAiADQQFqIgMgBCgCAEgNAAsLIAIgBUGUpgFBwaSFygUgBSgCCCACKAIAKAIUEQkACwJAIAQoAhAiA0EBSw0AIANBAWsEQCAEKAIEIgNFDQEgCCACIAJBECADIAIoAgAoAhARBwAiBSgCCCIJIAIoAgAoAhwRAwA2AgAgBCgCBCIKQQFOBEBBACEDIAQoAgghCyAEKAIcIQwDQCAJIANBBHRqIgYgDCADIAtsaiIHKAIANgIAIAYgBygCBDYCBCAGIAcoAgg2AgggA0EBaiIDIApHDQALCyACIAVBq6YBQcGkhcoFIAUoAgggAigCACgCFBEJAAwBCyAEKAIEIgNFDQAgCCACIAJBICADIAIoAgAoAhARBwAiBSgCCCIJIAIoAgAoAhwRAwA2AgQgBCgCBCIKQQFOBEBBACEDIAQoAgghCyAEKAIcIQwDQCAJIANBBXRqIgYgDCADIAtsaiIHKQMANwMAIAYgBykDCDcDCCAGIAcpAxA3AxAgA0EBaiIDIApHDQALCyACIAVBvqYBQcGkhcoFIAUoAgggAigCACgCFBEJAAsgACANIAAoAgAoAhgRAgAgCEEgaiEIIA1BAWoiDSAPRw0ACwsgAiAOQdKmAUHBpIXKBSAOKAIIIAIoAgAoAhQRCQALIAEgACgCBDYCBCABIAAoAgg2AgggASAAKAIMNgIMIAEgACgCEDYCECAEQSBqJABB4aYBC7oPAwZ/Bn0DfCMAQdAAayICJAAgACAAKAIAKAIcEQEAIglBAU4EQCAAKgIMIQogACoCCCELIAAqAgQhDANAIAAgAkHMAGogAkE0aiACQUBrIAJBOGogAkHIAGogAkHEAGogAkEwaiACQTxqIAggACgCACgCEBEbAAJAIAIoAkAiA0EBSw0AIANBAWsEQCACKAI8QX5qIgNBA0sNAQJAAkACQCADQQFrDgMBBAIAC0EAIQMgAigCMEEBSA0DA0AgAigCTCIEIAIoAjgiBiACKAJIIAIoAkQgA2xqIgcoAgBsaiIFKgIAIQ0gBSoCBCEOIAUqAgghDyACQQA2AgwgAiAKIA+UOAIIIAIgCyAOlDgCBCACIAwgDZQ4AgAgBCAGIAcoAgRsaiIFKgIAIQ0gBSoCBCEOIAUqAgghDyACQQA2AhwgAiAKIA+UOAIYIAIgCyAOlDgCFCACIAwgDZQ4AhAgBCAGIAcoAghsaiIEKgIAIQ0gBCoCBCEOIAQqAgghDyACQQA2AiwgAiAKIA+UOAIoIAIgCyAOlDgCJCACIAwgDZQ4AiAgASACIAggAyABKAIAKAIIEQQAIANBAWoiAyACKAIwSA0ACwwDC0EAIQMgAigCMEEATA0CA0AgAigCTCIEIAIoAjgiBiACKAJIIAIoAkQgA2xqIgcvAQBsaiIFKgIAIQ0gBSoCBCEOIAUqAgghDyACQQA2AgwgAiAKIA+UOAIIIAIgCyAOlDgCBCACIAwgDZQ4AgAgBCAGIAcvAQJsaiIFKgIAIQ0gBSoCBCEOIAUqAgghDyACQQA2AhwgAiAKIA+UOAIYIAIgCyAOlDgCFCACIAwgDZQ4AhAgBCAGIAcvAQRsaiIEKgIAIQ0gBCoCBCEOIAQqAgghDyACQQA2AiwgAiAKIA+UOAIoIAIgCyAOlDgCJCACIAwgDZQ4AiAgASACIAggAyABKAIAKAIIEQQAIANBAWoiAyACKAIwSA0ACwwCC0EAIQMgAigCMEEATA0BA0AgAigCTCIEIAIoAjgiBiACKAJIIAIoAkQgA2xqIgctAABsaiIFKgIAIQ0gBSoCBCEOIAUqAgghDyACQQA2AgwgAiAKIA+UOAIIIAIgCyAOlDgCBCACIAwgDZQ4AgAgBCAGIActAAFsaiIFKgIAIQ0gBSoCBCEOIAUqAgghDyACQQA2AhwgAiAKIA+UOAIYIAIgCyAOlDgCFCACIAwgDZQ4AhAgBCAGIActAAJsaiIEKgIAIQ0gBCoCBCEOIAQqAgghDyACQQA2AiwgAiAKIA+UOAIoIAIgCyAOlDgCJCACIAwgDZQ4AiAgASACIAggAyABKAIAKAIIEQQAIANBAWoiAyACKAIwSA0ACwwBCyACKAI8QX5qIgNBA0sNAAJAAkACQCADQQFrDgMBAwIAC0EAIQMgAigCMEEBSA0CA0AgAigCTCIEIAIoAjgiBiACKAJIIAIoAkQgA2xqIgcoAgBsaiIFKwMAIRAgBSsDCCERIAUrAxAhEiACQQA2AgwgAiAKIBK2lDgCCCACIAsgEbaUOAIEIAIgDCAQtpQ4AgAgBCAGIAcoAgRsaiIFKwMAIRAgBSsDCCERIAUrAxAhEiACQQA2AhwgAiAKIBK2lDgCGCACIAsgEbaUOAIUIAIgDCAQtpQ4AhAgBCAGIAcoAghsaiIEKwMAIRAgBCsDCCERIAQrAxAhEiACQQA2AiwgAiAKIBK2lDgCKCACIAsgEbaUOAIkIAIgDCAQtpQ4AiAgASACIAggAyABKAIAKAIIEQQAIANBAWoiAyACKAIwSA0ACwwCC0EAIQMgAigCMEEATA0BA0AgAigCTCIEIAIoAjgiBiACKAJIIAIoAkQgA2xqIgcvAQBsaiIFKwMAIRAgBSsDCCERIAUrAxAhEiACQQA2AgwgAiAKIBK2lDgCCCACIAsgEbaUOAIEIAIgDCAQtpQ4AgAgBCAGIAcvAQJsaiIFKwMAIRAgBSsDCCERIAUrAxAhEiACQQA2AhwgAiAKIBK2lDgCGCACIAsgEbaUOAIUIAIgDCAQtpQ4AhAgBCAGIAcvAQRsaiIEKwMAIRAgBCsDCCERIAQrAxAhEiACQQA2AiwgAiAKIBK2lDgCKCACIAsgEbaUOAIkIAIgDCAQtpQ4AiAgASACIAggAyABKAIAKAIIEQQAIANBAWoiAyACKAIwSA0ACwwBC0EAIQMgAigCMEEATA0AA0AgAigCTCIEIAIoAjgiBiACKAJIIAIoAkQgA2xqIgctAABsaiIFKwMAIRAgBSsDCCERIAUrAxAhEiACQQA2AgwgAiAKIBK2lDgCCCACIAsgEbaUOAIEIAIgDCAQtpQ4AgAgBCAGIActAAFsaiIFKwMAIRAgBSsDCCERIAUrAxAhEiACQQA2AhwgAiAKIBK2lDgCGCACIAsgEbaUOAIUIAIgDCAQtpQ4AhAgBCAGIActAAJsaiIEKwMAIRAgBCsDCCERIAQrAxAhEiACQQA2AiwgAiAKIBK2lDgCKCACIAsgEbaUOAIkIAIgDCAQtpQ4AiAgASACIAggAyABKAIAKAIIEQQAIANBAWoiAyACKAIwSA0ACwsgACAIIAAoAgAoAhgRAgAgCEEBaiIIIAlHDQALCyACQdAAaiQACwYAQeClAQs7AQJ9IAAqAiAhASAAIAAoAgAoAjARBgAaIAAgACgCACgCMBEGACECIAAgACgCACgCMBEGABogASACkgsGAEHWpQEL+wECAX8EfSMAQRBrIgMkACADIAEgAiABKAIAKAJEEQUAIAAgAykDCDcCCCAAIAMpAwA3AgAgASABKAIAKAIwEQYAQwAAAABcBEAgAioCBCEFIAIqAgAhBCACKgIIIQYgASABKAIAKAIwEQYAIQcgACAAKgIAIAdDAACAvyAEIAQgBJQgBSAFlJIgBiAGlJJDAACAKF0iARsiBEMAAIA/QwAAgL8gBiABGyIGIAaUIAQgBJRDAACAvyAFIAEbIgUgBZSSkpGVIgSUlJI4AgAgACAAKgIEIAcgBSAElJSSOAIEIAAgACoCCCAHIAYgBJSUkjgCCAsgA0EQaiQAC3MAIAAgASACED0aIAEgACgCHDYCHCABIAAoAiA2AiAgASAAKAIkNgIkIAEgACgCKDYCKCABIAAoAgw2AgwgASAAKAIQNgIQIAEgACgCFDYCFCABIAAoAhg2AhggASAAKAIsNgIsIAEgACgCNDYCNEHCpQELBgBBuKUBC7MBAgN/BX0gA0EBTgRAA0AgACoCHCEHIAAqAiAhCAJ9IAEgBUEEdCIGaiIEKgIEIgogCpQgBCoCCCIJIAmUkpEiC0MAAAAAXARAIAkgCCALlSIIlCEJIAogCJQhCCAHjCAHIAQqAgBDAAAAAF0bDAELQwAAAAAhCSAHjCAHIAQqAgBDAAAAAF0bCyEHIAIgBmoiBCAJOAIIIAQgCDgCBCAEIAc4AgAgBUEBaiIFIANHDQALCwuzAQIDfwV9IANBAU4EQANAIAAqAiQhByAAKgIcIQgCfSABIAVBBHQiBmoiBCoCACIKIAqUIAQqAgQiCSAJlJKRIgtDAAAAAFwEQCAJIAggC5UiCJQhCSAKIAiUIQggB4wgByAEKgIIQwAAAABdGwwBC0MAAAAAIQkgB4wgByAEKgIIQwAAAABdGwshByACIAZqIgQgBzgCCCAEIAk4AgQgBCAIOAIAIAVBAWoiBSADRw0ACwsLswECA38FfSADQQFOBEADQCAAKgIgIQcgACoCHCEIAn0gASAFQQR0IgZqIgQqAgAiCiAKlCAEKgIIIgkgCZSSkSILQwAAAABcBEAgCSAIIAuVIgiUIQkgCiAIlCEIIAeMIAcgBCoCBEMAAAAAXRsMAQtDAAAAACEJIAeMIAcgBCoCBEMAAAAAXRsLIQcgAiAGaiIEIAk4AgggBCAHOAIEIAQgCDgCACAFQQFqIgUgA0cNAAsLC4QBAQZ9IAEqAiAhAyABKgIcIQQCfSACKgIAIgYgBpQgAioCCCIHIAeUkpEiCEMAAAAAXARAIAcgBCAIlSIElCEFIAYgBJQhBCADjCADIAIqAgRDAAAAAF0bDAELIAOMIAMgAioCBEMAAAAAXRsLIQMgACAFOAIIIAAgAzgCBCAAIAQ4AgALgAEBBn0gASoCJCEEIAEqAhwhAyAAAn0gAioCACIGIAaUIAIqAgQiByAHlJKRIghDAAAAAFwEQCAHIAMgCJUiA5QhBSAGIAOUIQMgBIwgBCACKgIIQwAAAABdGwwBCyAEjCAEIAIqAghDAAAAAF0bCzgCCCAAIAM4AgAgACAFOAIEC4QBAQZ9IAEqAiAhBCABKgIcIQMCfSACKgIEIgYgBpQgAioCCCIHIAeUkpEiCEMAAAAAXARAIAcgBCAIlSIElCEFIAYgBJQhBCADjCADIAIqAgBDAAAAAF0bDAELIAOMIAMgAioCAEMAAAAAXRsLIQMgACAFOAIIIAAgAzgCACAAIAQ4AgQL4QICAX8EfSMAQRBrIgMkACADIAApAiQ3AwggAyAAKQIcNwMAIAAgACgCACgCMBEGACEEIAAgACgCACgCMBEGACEGIAMgACAAKAIAKAIwEQYAIAMqAgiSIgU4AgggAyAEIAMqAgCSOAIAIAMgBiADKgIEkjgCBCABQwAAAD+UIQQgAUMAAIA+lCEGIAFDAABAQZUhAQJAAkAgACgCNCIAQQJLDQACQAJAIABBAWsOAgIBAAsgBCADKgIEIgQgBJQiBZQhBCAGIAWUIAEgAyoCACIBIAFDAACAQJSUlJIiBSEHDAILIAQgAyoCACIEIASUIgSUIQcgBiAElCABIAUgBUMAAIBAlJSUkiIEIQUMAQsgBCADKgIAIgQgBJQiBJQhBSAGIASUIAEgAyoCBCIBIAFDAACAQJSUlJIiBCEHCyACQQA2AgwgAiAHOAIIIAIgBTgCBCACIAQ4AgAgA0EQaiQACwYAQZSiAQsIACAAQewAagsWACAAIAEpAgA3AmwgACABKQIINwJ0C7MjAwh/Bn0BfCMAQTBrIgQkAAJ/RAAAAAAAAOC/RAAAAAAAAOA/IAAqAigiDiAAKgIYIgxDAACAPyAAKgJ0lSINIAMqAgiUIAAqAjgiEZIiECAQIAxdGyIQIA4gEF0bIhBDAAAAAF0bIBC7oCISmUQAAAAAAADgQWMEQCASqgwBC0GAgICAeAshBQJ/RAAAAAAAAOC/RAAAAAAAAOA/IA4gDCANIAIqAgiUIBGSIg0gDSAMXRsiDCAOIAxdGyIOQwAAAABdGyAOu6AiEplEAAAAAAAA4EFjBEAgEqoMAQtBgICAgHgLIQcCf0QAAAAAAADgv0QAAAAAAADgPyAAKgIkIg4gACoCFCIMQwAAgD8gACoCcJUiDSADKgIElCAAKgI0IhGSIhAgECAMXRsiECAOIBBdGyIQQwAAAABdGyAQu6AiEplEAAAAAAAA4EFjBEAgEqoMAQtBgICAgHgLIQgCf0QAAAAAAADgv0QAAAAAAADgPyAOIAwgDSACKgIElCARkiINIA0gDF0bIgwgDiAMXRsiDkMAAAAAXRsgDrugIhKZRAAAAAAAAOBBYwRAIBKqDAELQYCAgIB4CyELAn9EAAAAAAAA4L9EAAAAAAAA4D8gACoCICIOIAAqAhAiDEMAAIA/IAAqAmyVIg0gAyoCAJQgACoCMCIRkiIQIBAgDF0bIhAgDiAQXRsiEEMAAAAAXRsgELugIhKZRAAAAAAAAOBBYwRAIBKqDAELQYCAgIB4CyEDAn9EAAAAAAAA4L9EAAAAAAAA4D8gDiAMIA0gAioCAJQgEZIiDSANIAxdGyIMIA4gDF0bIg5DAAAAAF0bIA67oCISmUQAAAAAAADgQWMEQCASqgwBC0GAgICAeAshAiAAKAJEQX9qIQkgACgCQEF/aiEKAn8gACgCaCIGQQJLBEBBACEIQQAMAQsgBUEBaiEFIAdBf2ohByAIQQFqIQggC0F/aiELIANBAWohAyACQX9qIQICQAJAAkAgBkEBaw4CAQIACyAFIAkgBSAJSBshCSAIIAogCCAKSBshCiALQQAgC0EAShshCCAHQQAgB0EAShsMAgsgBSAJIAUgCUgbIQkgAyAKIAMgCkgbIQogAkEAIAJBAEobIQggB0EAIAdBAEobDAELIAggCSAIIAlIGyEJIAMgCiADIApIGyEKIAJBACACQQBKGyEIIAtBACALQQBKGwsiBSAJSARAA0AgCSAIIApOBH8gBUEBagUgBUEBcSELIAVBAWoiB7IhESAFsiEQIAghAgNAAkACQAJAIAAtAGQNAEEAIAAtAGUgAiAFakEBcRsNACALDQEgAC0AZkUNAQsgACACIAUgACgCACgCRBENACEOAkAgBAJ9AkACQAJAIAAoAmgiA0ECTQRAIANBAWsOAgIDAQsgBCoCCCEMIAQqAgQhDSAEKgIAIQ4MBAsgACoCUCENIAAqAlQhDCAAKgIwIQ8gBEEANgIMIAQgDiAPkyIOOAIAIAQgECAMQwAAAD+UkyIMOAIIIAQgArIgDUMAAAA/lJMiDTgCBAwDCyAAKgJQIQ8gACoCVCEMIAAqAjQhDSAEQQA2AgwgBCAOIA2TIg04AgQgBCAQIAxDAAAAP5STIgw4AgggArIgD0MAAAA/lJMMAQsgACoCUCEPIAAqAlQhDSAAKgI4IQwgBEEANgIMIAQgDiAMkyIMOAIIIAQgECANQwAAAD+UkyINOAIEIAKyIA9DAAAAP5STCyIOOAIACyAEIA4gACoCbJQ4AgAgBCANIAAqAnCUOAIEIAQgDCAAKgJ0lDgCCCAAIAJBAWoiAyAFIAAoAgAoAkQRDQAhDgJAIAQCfQJAAkACQCAAKAJoIgZBAk0EQCAGQQFrDgICAwELIAQqAhghDCAEKgIUIQ0gBCoCECEODAQLIAAqAlAhDSAAKgJUIQwgACoCMCEPIARBADYCHCAEIA4gD5MiDjgCECAEIBAgDEMAAAA/lJMiDDgCGCAEIAOyIA1DAAAAP5STIg04AhQMAwsgACoCUCEPIAAqAlQhDCAAKgI0IQ0gBEEANgIcIAQgDiANkyINOAIUIAQgECAMQwAAAD+UkyIMOAIYIAOyIA9DAAAAP5STDAELIAAqAlAhDyAAKgJUIQ0gACoCOCEMIARBADYCHCAEIA4gDJMiDDgCGCAEIBAgDUMAAAA/lJMiDTgCFCADsiAPQwAAAD+UkwsiDjgCEAsgBCAOIAAqAmyUOAIQIAQgDSAAKgJwlDgCFCAEIAwgACoCdJQ4AhggACADIAcgACgCACgCRBENACEOAkAgBAJ9AkACQAJAIAAoAmgiBkECTQRAIAZBAWsOAgIDAQsgBCoCKCEMIAQqAiQhDSAEKgIgIQ4MBAsgACoCUCENIAAqAlQhDCAAKgIwIQ8gBEEANgIsIAQgDiAPkyIOOAIgIAQgESAMQwAAAD+UkyIMOAIoIAQgA7IgDUMAAAA/lJMiDTgCJAwDCyAAKgJQIQ8gACoCVCEMIAAqAjQhDSAEQQA2AiwgBCAOIA2TIg04AiQgBCARIAxDAAAAP5STIgw4AiggA7IgD0MAAAA/lJMMAQsgACoCUCEPIAAqAlQhDSAAKgI4IQwgBEEANgIsIAQgDiAMkyIMOAIoIAQgESANQwAAAD+UkyINOAIkIAOyIA9DAAAAP5STCyIOOAIgCyAEIA4gACoCbJQ4AiAgBCANIAAqAnCUOAIkIAQgDCAAKgJ0lDgCKCABIAQgAiAFIAEoAgAoAggRBAAgACADIAcgACgCACgCRBENACEOAkAgBAJ9AkACQAJAIAAoAmgiBkECTQRAIAZBAWsOAgIDAQsgBCoCGCEMIAQqAhQhDSAEKgIQIQ4MBAsgACoCUCENIAAqAlQhDCAAKgIwIQ8gBEEANgIcIAQgDiAPkyIOOAIQIAQgESAMQwAAAD+UkyIMOAIYIAQgA7IgDUMAAAA/lJMiDTgCFAwDCyAAKgJQIQ8gACoCVCEMIAAqAjQhDSAEQQA2AhwgBCAOIA2TIg04AhQgBCARIAxDAAAAP5STIgw4AhggA7IgD0MAAAA/lJMMAQsgACoCUCEPIAAqAlQhDSAAKgI4IQwgBEEANgIcIAQgDiAMkyIMOAIYIAQgESANQwAAAD+UkyINOAIUIAOyIA9DAAAAP5STCyIOOAIQCyAEIA4gACoCbJQ4AhAgBCANIAAqAnCUOAIUIAQgDCAAKgJ0lDgCGCAAIAIgByAAKAIAKAJEEQ0AIQ4CQCAEAn0CQAJAAkAgACgCaCIGQQJNBEAgBkEBaw4CAgMBCyAEKgIoIQwgBCoCJCENIAQqAiAhDgwECyAAKgJQIQ0gACoCVCEMIAAqAjAhDyAEQQA2AiwgBCAOIA+TIg44AiAgBCARIAxDAAAAP5STIgw4AiggBCACsiANQwAAAD+UkyINOAIkDAMLIAAqAlAhDyAAKgJUIQwgACoCNCENIARBADYCLCAEIA4gDZMiDTgCJCAEIBEgDEMAAAA/lJMiDDgCKCACsiAPQwAAAD+UkwwBCyAAKgJQIQ8gACoCVCENIAAqAjghDCAEQQA2AiwgBCAOIAyTIgw4AiggBCARIA1DAAAAP5STIg04AiQgArIgD0MAAAA/lJMLIg44AiALDAELIAAgAiAFIAAoAgAoAkQRDQAhDgJAIAQCfQJAAkACQCAAKAJoIgNBAk0EQCADQQFrDgICAwELIAQqAgghDCAEKgIEIQ0gBCoCACEODAQLIAAqAlAhDSAAKgJUIQwgACoCMCEPIARBADYCDCAEIA4gD5MiDjgCACAEIBAgDEMAAAA/lJMiDDgCCCAEIAKyIA1DAAAAP5STIg04AgQMAwsgACoCUCEPIAAqAlQhDCAAKgI0IQ0gBEEANgIMIAQgDiANkyINOAIEIAQgECAMQwAAAD+UkyIMOAIIIAKyIA9DAAAAP5STDAELIAAqAlAhDyAAKgJUIQ0gACoCOCEMIARBADYCDCAEIA4gDJMiDDgCCCAEIBAgDUMAAAA/lJMiDTgCBCACsiAPQwAAAD+UkwsiDjgCAAsgBCAOIAAqAmyUOAIAIAQgDSAAKgJwlDgCBCAEIAwgACoCdJQ4AgggACACIAcgACgCACgCRBENACEOAkAgBAJ9AkACQAJAIAAoAmgiA0ECTQRAIANBAWsOAgIDAQsgBCoCGCEMIAQqAhQhDSAEKgIQIQ4MBAsgACoCUCENIAAqAlQhDCAAKgIwIQ8gBEEANgIcIAQgDiAPkyIOOAIQIAQgESAMQwAAAD+UkyIMOAIYIAQgArIgDUMAAAA/lJMiDTgCFAwDCyAAKgJQIQ8gACoCVCEMIAAqAjQhDSAEQQA2AhwgBCAOIA2TIg04AhQgBCARIAxDAAAAP5STIgw4AhggArIgD0MAAAA/lJMMAQsgACoCUCEPIAAqAlQhDSAAKgI4IQwgBEEANgIcIAQgDiAMkyIMOAIYIAQgESANQwAAAD+UkyINOAIUIAKyIA9DAAAAP5STCyIOOAIQCyAEIA4gACoCbJQ4AhAgBCANIAAqAnCUOAIUIAQgDCAAKgJ0lDgCGCAAIAJBAWoiAyAFIAAoAgAoAkQRDQAhDgJAIAQCfQJAAkACQCAAKAJoIgZBAk0EQCAGQQFrDgICAwELIAQqAighDCAEKgIkIQ0gBCoCICEODAQLIAAqAlAhDSAAKgJUIQwgACoCMCEPIARBADYCLCAEIA4gD5MiDjgCICAEIBAgDEMAAAA/lJMiDDgCKCAEIAOyIA1DAAAAP5STIg04AiQMAwsgACoCUCEPIAAqAlQhDCAAKgI0IQ0gBEEANgIsIAQgDiANkyINOAIkIAQgECAMQwAAAD+UkyIMOAIoIAOyIA9DAAAAP5STDAELIAAqAlAhDyAAKgJUIQ0gACoCOCEMIARBADYCLCAEIA4gDJMiDDgCKCAEIBAgDUMAAAA/lJMiDTgCJCADsiAPQwAAAD+UkwsiDjgCIAsgBCAOIAAqAmyUOAIgIAQgDSAAKgJwlDgCJCAEIAwgACoCdJQ4AiggASAEIAIgBSABKAIAKAIIEQQAIAAgAyAFIAAoAgAoAkQRDQAhDgJAIAQCfQJAAkACQCAAKAJoIgZBAk0EQCAGQQFrDgICAwELIAQqAgghDCAEKgIEIQ0gBCoCACEODAQLIAAqAlAhDSAAKgJUIQwgACoCMCEPIARBADYCDCAEIA4gD5MiDjgCACAEIBAgDEMAAAA/lJMiDDgCCCAEIAOyIA1DAAAAP5STIg04AgQMAwsgACoCUCEPIAAqAlQhDCAAKgI0IQ0gBEEANgIMIAQgDiANkyINOAIEIAQgECAMQwAAAD+UkyIMOAIIIAOyIA9DAAAAP5STDAELIAAqAlAhDyAAKgJUIQ0gACoCOCEMIARBADYCDCAEIA4gDJMiDDgCCCAEIBAgDUMAAAA/lJMiDTgCBCADsiAPQwAAAD+UkwsiDjgCAAsgBCAOIAAqAmyUOAIAIAQgDSAAKgJwlDgCBCAEIAwgACoCdJQ4AgggACADIAcgACgCACgCRBENACEOAkAgBAJ9AkACQAJAIAAoAmgiBkECTQRAIAZBAWsOAgIDAQsgBCoCKCEMIAQqAiQhDSAEKgIgIQ4MBAsgACoCUCENIAAqAlQhDCAAKgIwIQ8gBEEANgIsIAQgDiAPkyIOOAIgIAQgESAMQwAAAD+UkyIMOAIoIAQgA7IgDUMAAAA/lJMiDTgCJAwDCyAAKgJQIQ8gACoCVCEMIAAqAjQhDSAEQQA2AiwgBCAOIA2TIg04AiQgBCARIAxDAAAAP5STIgw4AiggA7IgD0MAAAA/lJMMAQsgACoCUCEPIAAqAlQhDSAAKgI4IQwgBEEANgIsIAQgDiAMkyIMOAIoIAQgESANQwAAAD+UkyINOAIkIAOyIA9DAAAAP5STCyIOOAIgCwsgBCAOIAAqAmyUOAIgIAQgDSAAKgJwlDgCJCAEIAwgACoCdJQ4AiggASAEIAIgBSABKAIAKAIIEQQAIAogAyICRw0ACyAHCyIFRw0ACwsgBEEwaiQAC4EBAgF/AX0CQCAAKAJgIgNBBUsNAAJAAkACQCADQQFrDgUDAwIDAQALIAAoAlwgACgCQCACbCABakECdGoqAgAPCyAAKgJYIAAoAlwgACgCQCACbCABamotAACzlA8LIAAqAlggACgCXCAAKAJAIAJsIAFqQQF0ai4BALKUIQQLIAQL/QIBGH0gASoCOCEJIAEqAiQhDCABKgIoIQ0gASoCNCEKIAEqAhQhBSAAKgJwIQYgACoCFCEHIAAqAiQhCCABKgIYIQ4gACoCdCEPIAAqAhghECAAKgIoIREgASoCICESIAEqAjAhCyABKgIAIRMgASoCBCEUIAEqAgghFSABKgIQIRYgACoCbCEEIAAqAhAhFyAAKgIgIRggACAAKAIAKAIwEQYAIRkgACAAKAIAKAIwEQYAIRogACAAKAIAKAIwEQYAIRsgAkEANgIMIAIgCiAaIAQgGCAXk5RDAAAAP5QiBCAWi5QgBiAIIAeTlEMAAAA/lCIGIAWLlJIgDyARIBCTlEMAAAA/lCIFIA6LlJKSIgeTOAIEIAIgCyAZIAQgE4uUIAYgFIuUkiAFIBWLlJKSIgiTOAIAIAIgCSAbIAQgEouUIAYgDIuUkiAFIA2LlJKSIgSTOAIIIANBADYCDCADIAkgBJI4AgggAyAKIAeSOAIEIAMgCyAIkjgCAAstACAAQaShATYCACAABEBB7PcBQez3ASgCAEEBajYCACAAQZDSASgCABEAAAsLDQAgAEGkoQE2AgAgAAvMAwEEfSAAQoCAgPyDgIDAPzcCbCAAIAc2AmggAEEAOwBlIAAgCToAZCAAIAg2AmAgACADNgJcIAAgBDgCWCAAIAY4AkwgACAFOAJIIAAgAjYCRCAAIAE2AkAgAEEYNgIEIABCgICA/AM3AnQgACACQX9qsiIEOAJUIAAgAUF/arIiCjgCUAJAAn0CQAJAAkAgB0ECTQRAIAdBAWsOAgIDAQsgACoCKCELIAAqAhghDSAAKgIkIQQgACoCFCEMIAAqAiAhBiAAKgIQIQUMBAsgACAGOAIgIAAgBTgCECAAQQA2AiwgACAEOAIoIAAgCjgCJCAAQQA2AhwgAEIANwIUIAQhCyAKIQQMAwsgACAKOAIgIABBADYCECAAQQA2AiwgACAEOAIoIAAgBjgCJCAAQgA3AhggACAFOAIUIAQhCyAGIQQgBSEMQwAAAAAMAQsgACAKOAIgIABCADcCECAAQQA2AiwgACAGOAIoIAAgBDgCJCAAQQA2AhwgACAFOAIYIAYhCyAFCyENIAohBkMAAAAAIQULIABBADYCPCAAIA0gC5JDAAAAP5Q4AjggACAMIASSQwAAAD+UOAI0IAAgBSAGkkMAAAA/lDgCMAs5ACAAQiM3AgQgAEEANgIMIABBoJsBNgIAIABBpKEBNgIAIAAgASACIAMgBCAFIAYgByAIIAkQpgsL6AYCDX8LfSMAQSBrIgskACABKgIsIhMgASoCHCIRIAEqAgwiEkMAAAAAIBJDAAAAAF4bIhQgFCARXRsiFCAUIBNdGyEaIBMgESASQwAAAAAgEkMAAAAAXRsiEiARIBJdGyIRIBMgEV0bIRsgASoCKCITvCIEIAEqAhgiEbwiBSABKgIIIhK8IgdB65b46n0gEkNrC17dXhsiBiARIAa+XhsiBiATIAa+XhshDiABKgIkIhS8IgYgASoCFCIVvCIIIAEqAgQiFrwiDEHrlvjqfSAWQ2sLXt1eGyIJIBUgCb5eGyIJIBQgCb5eGyEJIAEqAiAiF7wiDSABKgIQIhi8Ig8gASoCACIZvCIBQeuW+Op9IBlDawte3V4bIgogGCAKvl4bIgogFyAKvl4bIQogBCAFIAdB65b46gUgEkNrC15dXRsiBCARIAS+XRsiBCATIAS+XRshECAGIAggDEHrlvjqBSAWQ2sLXl1dGyIEIBUgBL5dGyIEIBQgBL5dGyEMIA0gDyABQeuW+OoFIBlDawteXV0bIgEgGCABvl0bIgEgFyABvl0bIQ0CQCAAKAIEIgQoAgQiASAEKAIIRw0AIAEgAUEBdEEBIAEbIgdODQACQCAHRQRAQQAhBgwBC0Ho9wFB6PcBKAIAQQFqNgIAIAdBBnRBEEGM0gEoAgARAwAhBiAEKAIEIQELIAFBAU4EQEEAIQgDQCAGIAhBBnQiBWoiACAEKAIMIAVqIgUpAgA3AgAgACAFKQI4NwI4IAAgBSkCMDcCMCAAIAUpAig3AiggACAFKQIgNwIgIAAgBSkCGDcCGCAAIAUpAhA3AhAgACAFKQIINwIIIAhBAWoiCCABRw0ACwsgBCgCDCIABEAgBC0AEARAIAAEQEHs9wFB7PcBKAIAQQFqNgIAIABBkNIBKAIAEQAACwsgBEEANgIMCyAEIAY2AgwgBEEBOgAQIAQgBzYCCCAEKAIEIQELIAQoAgwgAUEGdGoiACADNgIoIAAgAjYCJCAAQX82AiAgACAKNgIQIAAgGzgCDCAAIBA2AgggACAMNgIEIAAgDTYCACAAIBo4AhwgACAONgIYIAAgCTYCFCAAIAspAgw3AiwgACALKQIUNwI0IAAgCygCHDYCPCAEIAQoAgRBAWo2AgQgC0EgaiQAC6sIAgp/Cn0CfyABKgIoIg68IgQgASoCGCIQvCIGIAEqAggiD7wiCkHrlvjqBSAPQ2sLXl1dGyIFIBAgBb5dGyIFIA4gBb5dG74iEUNvEoO6kiARIAQgBiAKQeuW+Op9IA9Dawte3V4bIgQgECAEvl4bIgQgDiAEvl4bviIOIBGTQ28SAztdIgYbIAAoAggiBCoCDCIUkyAEKgIsIhWUIhBDAACAT10gEEMAAAAAYHEEQCAQqQwBC0EAC0H+/wNxIQoCfyABKgIkIhC8IgUgASoCFCIPvCILIAEqAgQiEbwiCEHrlvjqBSARQ2sLXl1dGyIHIA8gB75dGyIHIBAgB75dG74iEkNvEoO6kiASIAUgCyAIQeuW+Op9IBFDawte3V4bIgUgDyAFvl4bIgUgECAFvl4bviIQIBKTQ28SAztdIgUbIAQqAggiFpMgBCoCKCIXlCIPQwAAgE9dIA9DAAAAAGBxBEAgD6kMAQtBAAtB/v8DcSELAn8gASoCICIPvCIIIAEqAhAiEbwiByABKgIAIhK8IgFB65b46gUgEkNrC15dXRsiCSARIAm+XRsiCSAPIAm+XRu+IhNDbxKDupIgEyAIIAcgAUHrlvjqfSASQ2sLXt1eGyIBIBEgAb5eGyIBIA8gAb5eG74iDyATk0NvEgM7XSIBGyAEKgIEIhKTIAQqAiQiE5QiEUMAAIBPXSARQwAAAABgcQRAIBGpDAELQQALQf7/A3EhCAJ/IA5DbxKDOpIgDiAGGyAUkyAVlEMAAIA/kiIOQwAAgE9dIA5DAAAAAGBxBEAgDqkMAQtBAAtBAXIhBwJ/IBBDbxKDOpIgECAFGyAWkyAXlEMAAIA/kiIOQwAAgE9dIA5DAAAAAGBxBEAgDqkMAQtBAAtBAXIhBQJ/IA9DbxKDOpIgDyABGyASkyATlEMAAIA/kiIOQwAAgE9dIA5DAAAAAGBxBEAgDqkMAQtBAAtBAXIhCSACQRV0IANyIQwCQCAAKAIEIgMoAgQiAiADKAIIRw0AIAIgAkEBdEEBIAIbIgRODQACQCAERQRAQQAhBgwBC0Ho9wFB6PcBKAIAQQFqNgIAIARBBHRBEEGM0gEoAgARAwAhBiADKAIEIQILIAJBAU4EQEEAIQEDQCAGIAFBBHQiAGoiDSADKAIMIABqIgApAgA3AgAgDSAAKQIINwIIIAFBAWoiASACRw0ACwsgAygCDCIABEAgAy0AEARAIAAEQEHs9wFB7PcBKAIAQQFqNgIAIABBkNIBKAIAEQAACwsgA0EANgIMCyADIAY2AgwgA0EBOgAQIAMgBDYCCCADKAIEIQILIAMoAgwgAkEEdGoiACAMNgIMIAAgCTsBBiAAIAo7AQQgACALOwECIAAgCDsBACAAIAc7AQogACAFOwEIIAMgAygCBEEBajYCBAsNACAAIAEgAiADEOUDCyoAIAAQ0QEaIAAEQEHs9wFB7PcBKAIAQQFqNgIAIABBkNIBKAIAEQAACwsKACAAENEBGiAAC8EBAgF/A30gAkEFTQRAIAAqAiQhBSAAKgIgIQYgACoCHCEEQYCAgPwDIQAgAiEDAkACQAJ/AkACQAJAAkACQCACQQFrDgUAAQIDBAcLQQAhAkGAgID8eyEAQQAhAwwGC0GAgID8AyECDAQLQYCAgPx7IQIMAwtBgICA/AMMAQtBgICA/HsLIQNBACEAIAUhBEEAIQIMAQtBACEAIAYhBEEAIQMLIAEgAzYCCCABIAI2AgQgASAANgIAIAEgBIw4AgwLC3cCAX8CfQJAIAEqAgAiBCAAKgIcIgUgApJfQQFzDQAgBCAFjCACk2BBAXMNACABKgIEIgQgACoCICIFIAKSX0EBcw0AIAQgBYwgApNgQQFzDQAgASoCCCIEIAAqAiQiBSACkl9BAXMNACAEIAWMIAKTYCEDCyADC7IBAQN/IwBBMGsiBCQAIAAgBEEgaiADIAAoAgAoAnwRBQAgBCgCICEDIAQoAiQhBSAEKAIoIQYgAUEANgIMIAEgBjYCCCABIAU2AgQgASADNgIAIARBADYCDCAEIAZBgICAgHhzNgIIIAQgBUGAgICAeHM2AgQgBCADQYCAgIB4czYCACAEQRBqIAAgBCAAKAIAKAJAEQUAIAIgBCkDGDcCCCACIAQpAxA3AgAgBEEwaiQAC7ABAQZ9IAAqAiQhBCAAKgIgIQMgACoCHCEFIAAgACgCACgCMBEGACEGIAAgACgCACgCMBEGACEHIAAgACgCACgCMBEGACEIIAJBADYCDCACIAMgB5IiAyABQQF2QQFxIgBBAXOylCADIACylJM4AgQgAiAFIAaSIgMgAUEBcSIAQQFzspQgAyAAspSTOAIAIAIgBCAIkiIEIAFBAnZBAXEiAEEBc7KUIAQgALKUkzgCCAtKAQJ/IAAgAUELTQR/IAFBAnQiAUGkngFqKAIAIQQgAUH0nQFqKAIABUEACyACIAAoAgAoAmwRBQAgACAEIAMgACgCACgCbBEFAAsEAEEIC0MAIAFBBU0EQCACQQA2AgwgAiABQQJ0IgBB3J0BaigCADYCCCACIABBxJ0BaigCADYCBCACIABBrJ0BaigCADYCAAsLlgECA38GfSADQQFOBEADQCABIAVBBHQiBmoiBCoCACEKIAQqAgQhCyAEKgIIIQwgACoCHCEHIAAqAiAhCCAAKgIkIQkgAiAGaiIEQQA2AgwgBCAJIAmMIAxDAAAAAGAbOAIIIAQgCCAIjCALQwAAAABgGzgCBCAEIAcgB4wgCkMAAAAAYBs4AgAgBUEBaiIFIANHDQALCwtuAQZ9IAEqAiAhAyABKgIkIQQgAioCBCEGIAIqAgghByABKgIcIQUgAioCACEIIABBADYCDCAAIAUgBYwgCEMAAAAAYBs4AgAgACAEIASMIAdDAAAAAGAbOAIIIAAgAyADjCAGQwAAAABgGzgCBAuqAQEJfSABKgIgIQMgASoCJCEEIAEqAhwhBSABIAEoAgAoAjARBgAhBiABIAEoAgAoAjARBgAhByABIAEoAgAoAjARBgAhCCACKgIAIQkgAioCBCEKIAIqAgghCyAAQQA2AgwgACAEIAiSIgQgBIwgC0MAAAAAYBs4AgggACADIAeSIgMgA4wgCkMAAAAAYBs4AgQgACAFIAaSIgMgA4wgCUMAAAAAYBs4AgALBgBBqJ0BC6kBAQZ9IAAqAiQhAyAAKgIgIQQgACoCHCEFIAAgACgCACgCMBEGACEGIAAgACgCACgCMBEGACEHIAAgACgCACgCMBEGACEIIAJBADYCDCACIAFDAABAQZUiASAFIAaSIgUgBZIiBSAFlCIFIAQgB5IiBCAEkiIEIASUIgSSlDgCCCACIAEgBSADIAiSIgMgA5IiAyADlCIDkpQ4AgQgAiABIAQgA5KUOAIACxgBAX8jAEEQayIBIAA2AgwgASgCDEEwagvmAQEGfSAAEN4BGiAAQQA2AgQgAEGMnAE2AgAgACABIAEqAgAiAiABKgIIIgNdQQFzQQF0QQFBAiABKgIEIgQgA10bIAIgBF0bQQJ0aioCAEPNzMw9lCICIAAqAixdQQFzBH9BjJwBBSAAIAIQpwEgACgCAAsoAjARBgAhAiAAIAAoAgAoAjARBgAhAyAAIAAoAgAoAjARBgAhBCABKgIAIQUgASoCBCEGIAEqAgghByAAQQA2AiggACAHIAAqAhSUIASTOAIkIAAgBiAAKgIQlCADkzgCICAAIAUgACoCDJQgApM4AhwL4wEBBX0gACoCGCIGIAEqAgCUIAAqAhwiByABKgIElJIgACoCICIIIAEqAgiUkiIEIAAqAhQiBV5BAXNFBEAgACAEOAIUIAAgASkCCDcCDCAAIAEpAgA3AgQgBCEFCyAGIAEqAhCUIAcgASoCFJSSIAggASoCGJSSIgQgBV5BAXNFBEAgACAEOAIUIAAgASkCGDcCDCAAIAEpAhA3AgQgBCEFCyAGIAEqAiCUIAcgASoCJJSSIAggASoCKJSSIgQgBV5BAXNFBEAgACAEOAIUIAAgASkCKDcCDCAAIAEpAiA3AgQLCwYAQYibAQsKACAAKAJcQQRqCyEBAX8gACgCXCICIAEpAgA3AgQgAiABKQIINwIMIAAQYQuPAgEGfyMAQdAAayIEJAAgA0EASgRAA0AgAiAFQQR0akHrlvjqfTYCDCAFQQFqIgUgA0cNAAsgBEFAayEHIARBKGpBBHIhBQNAIARB0JoBNgIoIAVCADcCCCAFQgA3AgAgBEHrlvjqfTYCPCAHIAEgCEEEdCIJaiIGKQIINwIIIAcgBikCADcCACAEQuuW+OoFNwMgIARC65b46rXtgq/dADcDGCAAKAJcIQYgBELrlvjqDTcDECAEQuuW+Oq97YKvXTcDCCAGIARBKGogBEEIaiAEQRhqIAYoAgAoAggRBAAgAiAJaiIGIAUpAgg3AgggBiAFKQIANwIAIAhBAWoiCCADRw0ACwsgBEHQAGokAAu1AgIEfwR9IwBB0ABrIgMkACAAQgA3AgAgAEIANwIIAn0gAioCACIIIAiUIAIqAgQiCSAJlJIgAioCCCIHIAeUkiIKQxe30ThdBEBBgICA/AMhBEMAAAAADAELIAdDAACAPyAKkZUiB5S8IQUgCSAHlLwhBiAIIAeUvCEEIAIqAgwLIQggA0IANwI0IAMgCDgCTCADIAU2AkggAyAGNgJEIANCADcCLCADQdCaATYCKCADIAQ2AkAgA0HrlvjqfTYCPCADQuuW+OoFNwMgIANC65b46rXtgq/dADcDGCABKAJcIQEgA0LrlvjqDTcDECADQuuW+Oq97YKvXTcDCCABIANBKGogA0EIaiADQRhqIAEoAgAoAggRBAAgACADKQI0NwIIIAAgAykCLDcCACADQdAAaiQACwYAQZGZAQsGAEGImQELcwAgACABIAIQPRogASAAKAIcNgIcIAEgACgCIDYCICABIAAoAiQ2AiQgASAAKAIoNgIoIAEgACgCDDYCDCABIAAoAhA2AhAgASAAKAIUNgIUIAEgACgCGDYCGCABIAAoAiw2AiwgASAAKAI0NgI0QfWYAQsGAEHomAELmAMCA38QfSMAQRBrIgQkACAAQRxqIgYgACgCNCIFQQJqQQNvQQJ0aioCACEHIARBADYCDCAEIAc4AgggBCAHOAIEIAQgBzgCACAEIAVBAnQiBWogByAFIAZqKgIAkjgCACAAIAAoAgAoAjARBgAhByAAIAAoAgAoAjARBgAhCCAAIAAoAgAoAjARBgAhCSAEIAcgBCoCAJIiBzgCACAEIAggBCoCBJIiCDgCBCABKgI0IQwgASoCFCEKIAEqAhghDyABKgI4IQ0gASoCJCELIAEqAighECABKgIwIQ4gASoCCCERIAEqAgAhEiABKgIEIRMgASoCECEUIAEqAiAhFSAEKgIIIRYgAkEANgIMIAIgDSAHIBWLlCAIIAuLlJIgCSAWkiIJIBCLlJIiC5M4AgggAiAMIAcgFIuUIAggCouUkiAJIA+LlJIiCpM4AgQgAiAOIAcgEouUIAggE4uUkiAJIBGLlJIiB5M4AgAgA0EANgIMIAMgDSALkjgCCCADIAogDJI4AgQgAyAHIA6SOAIAIARBEGokAAt5ACAAQiM3AgQgAEGkkAE2AgAgAEGKro/pAzYCLCAAQoCAgPwDNwIUIABCgICA/IOAgMA/NwIMIABBpJEBNgIAIABBAjYCNCAAQayXATYCACAAQQo2AgQgAEEANgIoIAAgAkMAAAA/lDgCJCAAIAE4AiAgACABOAIcC3kAIABCIzcCBCAAQaSQATYCACAAQYquj+kDNgIsIABCgICA/AM3AhQgAEKAgID8g4CAwD83AgwgAEGkkQE2AgAgAEEANgI0IABByJYBNgIAIABBCjYCBCAAQQA2AiggACABOAIkIAAgATgCICAAIAJDAAAAP5Q4AhwL0wECA38DfSAAQRxqIgUgACgCNCIEQQJqQQNvQQJ0aigCACEDIwBBEGsiAEEANgIMIAAgAzYCCCAAIAM2AgQgACADNgIAIAAgBEECdCIDaiIEIAMgBWoqAgAgBCoCAJI4AgAgACoCCCEGIAIgAUOqqqo9lCIBIAAqAgBDCtcjPZIiByAHkiIHIAeUIgcgACoCBEMK1yM9kiIIIAiSIgggCJQiCJKUOAIIIAIgASAHIAZDCtcjPZIiBiAGkiIGIAaUIgaSlDgCBCACIAEgCCAGkpQ4AgALmgQCBX8KfSMAQRBrIgUkACAAKAI0IgRBAmpBA28hBgJAIANBAUgNACAAIAZBAnRqKgIcIQ1BACEGA0AgBUIANwMIIAVCADcDACAFIARBAnQiBGogACAEaigCHDYCACABIAZBBHQiCGoiBCoCCCEKIAQqAgAhCyAEKgIEIQ4gBSoCCCERIAUqAgAhDCAFKgIEIQ8gACAAKAIAKAIwEQYAIQlDawte3SESIAQqAgAiECAMIA0gC5SSIAkgEJSTIgyUIAQqAgQiCyAPIA0gDpSSIAkgC5STIg+UkiAEKgIIIg4gESANIAqUkiAJIA6UkyIKlJIiCUNrC17dXkEBc0UEQCACIAhqIgdBADYCDCAHIAo4AgggByAPOAIEIAcgDDgCACAEKgIIIQ4gBCoCBCELIAQqAgAhECAJIRILIAVCADcDCCAFQgA3AwAgBSAAKAI0QQJ0IgdqIAAgB2oqAhyMOAIAIAUqAgQhCiAFKgIIIREgBSoCACEMIAAgACgCACgCMBEGACEJIAQqAgAiDyAMIA0gEJSSIAkgD5STIhCUIAQqAgQiDCAKIA0gC5SSIAkgDJSTIguUkiAEKgIIIgogESANIA6UkiAJIAqUkyIJlJIgEl5BAXNFBEAgAiAIaiIEQQA2AgwgBCAJOAIIIAQgCzgCBCAEIBA4AgALIAZBAWoiBiADRg0BIAAoAjQhBAwAAAsACyAFQRBqJAALiwECAX8BfSMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAgwhACACQQA2AgQDQCACKAIEQQNIBEACfSMAQRBrIgEgAigCCDYCDCABKAIMIAIoAgRBAnRqKgIACxDaASEDIABB5AZqIAIoAgRBBnRqIAM4AgQgAiACKAIEQQFqNgIEDAELCyACQRBqJAAL8AMCAn8LfSMAQRBrIgMkACAAQgA3AgAgAEIANwIIAn0gAioCACIJIAmUIAIqAgQiBSAFlJIgAioCCCIHIAeUkiIGQxe30ThdBEBDAAAAACEHQwAAgD8MAQsgB0MAAIA/IAaRlSIGlCEIIAUgBpQhByAJIAaUCyEGIAFBHGoiAiABKAI0IgRBAmpBA29BAnRqKgIAIQUgA0IANwMIIANCADcDACADIARBAnQiBGogAiAEaigCADYCACADKgIEIQsgAyoCACEMQ2sLXt0hCSAIIAggBZQiDiADKgIIkiAIIAEgASgCACgCMBEGACIKlJMiDZQgBiAMIAYgBZQiDJIgBiAKlJMiD5QgByALIAcgBZQiC5IgByAKlJMiCpSSkiIFQ2sLXt1eQQFzRQRAIABBADYCDCAAIA04AgggACAKOAIEIAAgDzgCACAFIQkLIANCADcDCCADQgA3AwAgAyABKAI0QQJ0IgJqIAEgAmoqAhyMOAIAIAMqAgQhCiADKgIAIQ0gCCAOIAMqAgiSIAggASABKAIAKAIwEQYAIgWUkyIIlCAGIAwgDZIgBiAFlJMiBpQgByALIAqSIAcgBZSTIgWUkpIgCV5BAXNFBEAgAEEANgIMIAAgCDgCCCAAIAU4AgQgACAGOAIACyADQRBqJAALeQAgAEIjNwIEIABBpJABNgIAIABBiq6P6QM2AiwgAEKAgID8AzcCFCAAQoCAgPyDgIDAPzcCDCAAQaSRATYCACAAQQE2AjQgAEEKNgIEIABB5JUBNgIAIABBADYCKCAAIAE4AiQgACACQwAAAD+UOAIgIAAgATgCHAsFAEHEAAsGAEGMlQELhAEBAX8gAEHAkwE2AgAgACgCaCIBBEAgAC0AbARAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgJoCyAAQQA2AmggAEIANwJgIABBAToAbCAAEGAaIAAEQEHs9wFB7PcBKAIAQQFqNgIAIABBkNIBKAIAEQAACwtkAQF/IABBwJMBNgIAIAAoAmgiAQRAIAAtAGwEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYCaAsgAEEANgJoIABCADcCYCAAQQE6AGwgABBgGiAAC8ADAgR/BX0jAEEQayEIIANB////+wc2AgBB////eyEHIARB////ezYCAAJAIAAoAmAiCkEBSARAQ///f/8hCwwBC0EAIQcDQCAAKAJoIAdBBHRqIgkqAgAgACoCDJQiCyABKgIAlCAJKgIEIAAqAhCUIgwgASoCBJSSIAkqAgggACoCFJQiDSABKgIIlJIgASoCMJIiDiACKgIAlCALIAEqAhCUIAwgASoCFJSSIA0gASoCGJSSIAEqAjSSIg8gAioCBJSSIAsgASoCIJQgDCABKgIklJIgDSABKgIolJIgASoCOJIiDCACKgIIlJIiCyADKgIAXUEBc0UEQCADIAs4AgAgBUEANgIMIAUgDDgCCCAFIA84AgQgBSAOOAIACyALIAQqAgBeQQFzRQRAIAQgCzgCACAGQQA2AgwgBiAMOAIIIAYgDzgCBCAGIA44AgALIAdBAWoiByAKRw0ACyAEKgIAIgu8IQcLIAMqAgAiDCALXgRAIAMgBzYCACAEIAw4AgAgCCAFKQIINwMIIAggBSkCADcDACAFIAYpAgg3AgggBSAGKQIANwIAIAYgCCkDCDcCCCAGIAgpAwA3AgALC7QCAQR/IAAgASACED0aIAEgACgCHDYCHCABIAAoAiA2AiAgASAAKAIkNgIkIAEgACgCKDYCKCABIAAoAgw2AgwgASAAKAIQNgIQIAEgACgCFDYCFCABIAAoAhg2AhggASAAKAIsNgIsIAEgACgCYCIDNgI8IAMEQCACIAAoAmggAigCACgCHBEDACEEIAFBADYCOCABIAQ2AjQgAkEQIAMgAigCACgCEBEHACEEIAAoAmghBiADQQFOBEAgBCgCCCEBA0AgASAGIAVBBHRqIgAoAgA2AgAgASAAKAIENgIEIAEgACgCCDYCCCABIAAoAgw2AgwgAUEQaiEBIAVBAWoiBSADRw0ACwsgAiAEQcCUAUHBpIXKBSAGIAIoAgAoAhQRCQBB05QBDwsgAUIANwI0QdOUAQteAQZ9IAAoAmggAUEEdGoiASoCACEDIAEqAgQhBCABKgIIIQUgACoCECEGIAAqAhQhByAAKgIMIQggAkEANgIMIAIgBSAHlDgCCCACIAQgBpQ4AgQgAiADIAiUOAIAC8gBAgJ/Bn0gACgCaCABIAAoAmAiBW9BBHRqIgQqAgAhBiAEKgIEIQcgBCoCCCEIIAAqAhAhCSAAKgIUIQogACoCDCELIAJBADYCDCACIAggCpQ4AgggAiAHIAmUOAIEIAIgBiALlDgCACAAKAJoIAFBAWogBW9BBHRqIgEqAgAhBiABKgIEIQcgASoCCCEIIAAqAhAhCSAAKgIUIQogACoCDCELIANBADYCDCADIAggCpQ4AgggAyAHIAmUOAIEIAMgBiALlDgCAAuzAgIHfwh9IANBAEoEQANAIAIgBEEEdGpB65b46n02AgwgBEEBaiIEIANHDQALA0AgB0EEdCEIAkAgACgCYCIKQQFIBEBDawte3SELDAELIAEgCGoiBCoCCCAAKgIUIg6UIQwgBCoCBCAAKgIQIg+UIQ0gBCoCACAAKgIMIhCUIREgACgCaCEJQQAhBEF/IQVD//9//yELA0AgESAJIARBBHRqIgYqAgCUIA0gBioCBJSSIAwgBioCCJSSIhIgCyASIAteIgYbIQsgBCAFIAYbIQUgBEEBaiIEIApHDQALIAkgBUEEdGoiBCoCACEMIAQqAgQhDSACIAhqIgUgBCoCCCAOlDgCCCAFIA0gD5Q4AgQgBSAMIBCUOAIACyACIAhqIAs4AgwgB0EBaiIHIANHDQALCwvvAQIDfwh9IAEoAmAiBUEBTgRAIAIqAgAgASoCDCIJlCEHIAIqAgggASoCFCIKlCEIIAIqAgQgASoCECILlCEMIAEoAmghBEEAIQFBfyECQ///f/8hBgNAIAcgBCABQQR0aiIDKgIAlCAMIAMqAgSUkiAIIAMqAgiUkiINIAYgDSAGXiIDGyEGIAEgAiADGyECIAFBAWoiASAFRw0ACyAEIAJBBHRqIgEqAgAhBiABKgIEIQcgASoCCCEIIABBADYCDCAAIAogCJQ4AgggACALIAeUOAIEIAAgCSAGlDgCAA8LIABCADcCACAAQgA3AggLGgAgACABKQIANwIMIAAgASkCCDcCFCAAEGELPQEDfSABKgIAIQIgASoCBCEDIAEqAgghBCAAQQA2AhggACAEizgCFCAAIAOLOAIQIAAgAos4AgwgABCNBAueAwEWfSAAIAAoAgAoAjARBgAhBCABKgI0IRcgASoCGCEHIAEqAhQhCCABKgI4IQkgASoCKCEKIAAqAjwhCyAAKgJMIQwgASoCJCENIAAqAjghBSAAKgJIIQ4gASoCMCEYIAEqAgghDyABKgIAIRAgASoCBCERIAEqAhAhEiABKgIgIRMgACoCNCEGIAAqAkQhFCACQQA2AgwgAiAJIBMgFCAGkkMAAAA/lCIJlCANIA4gBZJDAAAAP5QiFZSSIAogDCALkkMAAAA/lCIWlJKSIhkgBCAUIAaTQwAAAD+UkiIGIBOLlCAEIA4gBZNDAAAAP5SSIgUgDYuUkiAEIAwgC5NDAAAAP5SSIgQgCouUkiIKkzgCCCACIBcgCSASlCAVIAiUkiAWIAeUkpIiCyAGIBKLlCAFIAiLlJIgBCAHi5SSIgeTOAIEIAIgGCAJIBCUIBUgEZSSIBYgD5SSkiIIIAYgEIuUIAUgEYuUkiAEIA+LlJIiBJM4AgAgA0EANgIMIAMgCiAZkjgCCCADIAcgC5I4AgQgAyAEIAiSOAIAC34AIABCIzcCBCAAQaSQATYCACAAQYquj+kDNgIsIABCgICA/AM3AhQgAEKAgID8g4CAwD83AgwgAEEAOgBUIABCgICA/As3AkwgAEKAgID8i4CAwL9/NwJEIABCgICA/AM3AjwgAEKAgID8g4CAwD83AjQgAEGIkgE2AgAgAAvSBgIFfw19IwBB0ABrIgQkACAAIAAoAgAoAjARBgAhFQNAIARCADcDSCAEQgA3A0AgBUECdCIGIARBQGtqIgdBgICA/AM2AgAgASoCICEMIAEqAgAhDSABKgIQIQ4gASoCJCEPIAEqAgQhECABKgIUIREgASoCKCEJIAEqAgghCiABKgIYIQsgBEEANgIsIAQgCiAEKgJAIgqUIAsgBCoCRCILlJIgCSAEKgJIIgmUkjgCKCAEIAogEJQgCyARlJIgCSAPlJI4AiQgBCANIAqUIA4gC5SSIAwgCZSSOAIgIARBMGogACAEQSBqIAAoAgAoAkARBQAgASoCMCEMIAEqAgghDSABKgIAIQ4gASoCBCEPIAEqAjQhECABKgIYIREgASoCECESIAEqAhQhEyABKgI4IQogASoCKCEJIAEqAiAhCyABKgIkIRQgBEEANgIsIAQgCiALIAQqAjAiCpQgFCAEKgI0IguUkiAJIAQqAjgiCZSSkjgCKCAEIBAgCiASlCALIBOUkiAJIBGUkpI4AiQgBCAMIAogDpQgCyAPlJIgCSANlJKSOAIgIAMgBmogFSAEQSBqIAZqIggqAgCSOAIAIAdBgICA/Hs2AgAgASoCICEMIAEqAgAhDSABKgIQIQ4gASoCJCEPIAEqAgQhECABKgIUIREgASoCKCEJIAEqAgghCiABKgIYIQsgBEEANgIMIAQgCiAEKgJAIgqUIAsgBCoCRCILlJIgCSAEKgJIIgmUkjgCCCAEIAogEJQgCyARlJIgCSAPlJI4AgQgBCANIAqUIA4gC5SSIAwgCZSSOAIAIARBEGogACAEIAAoAgAoAkARBQAgASoCMCEMIAEqAgghDSABKgIAIQ4gASoCBCEPIAEqAjQhECABKgIYIREgASoCECESIAEqAhQhEyABKgI4IQogASoCKCEJIAEqAiAhCyABKgIkIRQgBEEANgIsIAQgCiALIAQqAhAiCpQgFCAEKgIUIguUkiAJIAQqAhgiCZSSkjgCKCAEIBAgCiASlCALIBOUkiAJIBGUkpI4AiQgBCAMIAogDpQgCyAPlJIgCSANlJKSOAIgIAIgBmogCCoCACAVkzgCACAFQQFqIgVBA0cNAAsgBEHQAGokAAujAwIBfwd9IwBBIGsiAyQAIAMgAikCCDcDGCADIAIpAgA3AxAgAyoCECIEIASUIAMqAhQiBiAGlJIgAyoCGCIFIAWUkkMAAIAoXUEBc0UEQCADQoCAgPwLNwMYIANCgICA/IuAgMC/fzcDEEMAAIC/IQVDAACAvyEGQwAAgL8hBAsgAyAFQwAAgD8gBCAElCAGIAaUkiAFIAWUkpGVIgWUOAIYIAMgBiAFlDgCFCADIAQgBZQ4AhAgAyABIANBEGoQ3AECfQJAIAEoAgQiAkENSw0AAkACQAJAAkACQAJAAkAgAkEBaw4NAgcHBgYHBwAHBQQHAwELIAEqAhwgASoCDJQMBwsgASoCLAwGCyABKgIsDAULIAEqAiwMBAsgASoCLAwDCyABKgIsDAILIAEqAiwMAQsgASABKAIAKAIwEQYACyEEIAMqAgAhBiADKgIQIQUgAyoCBCEHIAMqAhQhCCADKgIIIQkgAyoCGCEKIABBADYCDCAAIAkgBCAKlJI4AgggACAHIAQgCJSSOAIEIAAgBiAEIAWUkjgCACADQSBqJAALowUCAX8efSMAQTBrIgUkACABKgIkIQkgASoCFCEKIAEqAighCyABKgIYIQwgASoCBCENIAEqAgghDiACKgIIIQYgASoCICEPIAIqAgAhByABKgIAIRAgAioCBCEIIAEqAhAhESAFQQA2AiwgBSAQIAeUIBEgCJSSIA8gBpSSOAIgIAUgByAOlCAIIAyUkiAGIAuUkjgCKCAFIAcgDZQgCCAKlJIgBiAJlJI4AiQgBUEQaiAAIAVBIGogACgCACgCQBEFACABKgI4IQwgASoCKCENIAEqAiQhDiABKgI0IQ8gASoCGCEQIAEqAhQhESABKgIgIRIgASoCMCETIAEqAgghFCABKgIAIRUgASoCBCEWIAEqAhAhFyAFKgIYIQYgBSoCECEHIAUqAhQhCCAFQQA2AgwgBSAFKgIojDgCCCAFIAUqAiSMOAIEIAUgBSoCIIw4AgAgBUEQaiAAIAUgACgCACgCQBEFACABKgI4IRggASoCKCEZIAEqAiQhGiABKgI0IRsgASoCGCEcIAEqAhQhHSABKgIgIR4gASoCMCEfIAEqAgghICABKgIAISEgASoCBCEiIAEqAhAhIyAFKgIYIQkgBSoCECEKIAUqAhQhCyADIBMgByAVlCAIIBaUkiAGIBSUkpIgAioCAJQgDyAHIBeUIAggEZSSIAYgEJSSkiACKgIElJIgDCAHIBKUIAggDpSSIAYgDZSSkiACKgIIlJI4AgAgBCAfIAogIZQgCyAilJIgCSAglJKSIAIqAgCUIBsgCiAjlCALIB2UkiAJIByUkpIgAioCBJSSIBggCiAelCALIBqUkiAJIBmUkpIgAioCCJSSIgY4AgAgAyoCACIHIAZeQQFzRQRAIAMgBjgCACAEIAc4AgALIAVBMGokAAtLAQF/IAEgASAAIAAoAgAoAjQRAQBBASABKAIAKAIQEQcAIgIgACACKAIIIAEgACgCACgCOBEHAEHTkIWCBSAAIAEoAgAoAhQRCQALiwECAX8BfSMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAgwhACACQQA2AgQDQCACKAIEQQNIBEACfSMAQRBrIgEgAigCCDYCDCABKAIMIAIoAgRBAnRqKgIACxDaASEDIABB5AZqIAIoAgRBBnRqIAM4AgAgAiACKAIEQQFqNgIEDAELCyACQRBqJAALVAIBfwF9IwBBIGsiASQAIAAgAUEQaiABQQxqIAAoAgAoAgwRBQAgAUEgaiQAIAEqAgwgASoCECICIAKUIAEqAhQiAiAClJIgASoCGCICIAKUkpGSCxIAIAAgACgCACgCEBEGACABlAuEAgIBfwd9IwBB4ABrIgMkACADQgA3AiwgA0IANwM4IANBgICA/AM2AjQgA0IANwJMIANBgICA/AM2AkggA0IANwJUIANBADYCXCADQgA3AiQgA0GAgID8AzYCICADQgA3A0AgACADQSBqIANBEGogAyAAKAIAKAIIEQQAIAIgAyoCACIGIAMqAhAiB5MiBCAElCADKgIEIgQgAyoCFCIIkyIFIAWUkiADKgIIIgUgAyoCGCIJkyIKIAqUkpFDAAAAP5Q4AgAgAUEANgIMIAEgBSAJkkMAAAA/lDgCCCABIAQgCJJDAAAAP5Q4AgQgASAGIAeSQwAAAD+UOAIAIANB4ABqJAALBgBB5I8BCwcAIABBEGoLFgAgACABKQIANwIQIAAgASkCCDcCGAuhAwEWfSAAIAAoAgAoAjARBgAhBCABKgI0IRcgASoCGCEHIAEqAhQhCCABKgI4IQkgASoCKCEKIABBQGsqAgAhCyAAKgJQIQwgASoCJCENIAAqAjwhBSAAKgJMIQ4gASoCMCEYIAEqAgghDyABKgIAIRAgASoCBCERIAEqAhAhEiABKgIgIRMgACoCOCEGIAAqAkghFCACQQA2AgwgAiAJIBMgFCAGkkMAAAA/lCIJlCANIA4gBZJDAAAAP5QiFZSSIAogDCALkkMAAAA/lCIWlJKSIhkgBCAUIAaTQwAAAD+UkiIGIBOLlCAEIA4gBZNDAAAAP5SSIgUgDYuUkiAEIAwgC5NDAAAAP5SSIgQgCouUkiIKkzgCCCACIBcgCSASlCAVIAiUkiAWIAeUkpIiCyAGIBKLlCAFIAiLlJIgBCAHi5SSIgeTOAIEIAIgGCAJIBCUIBUgEZSSIBYgD5SSkiIIIAYgEIuUIAUgEYuUkiAEIA+LlJIiBJM4AgAgA0EANgIMIAMgCiAZkjgCCCADIAcgC5I4AgQgAyAEIAiSOAIACw0AIAAgARDbASAAEGELugICAX8HfSMAQeAAayIDJAAgACAAKAIAKAIwEQYAIQQgA0IANwIsIANCADcDOCADQYCAgPwDNgI0IANCADcCTCADQYCAgPwDNgJIIANCADcCVCADQQA2AlwgA0IANwIkIANBgICA/AM2AiAgA0IANwNAIAAgA0EgaiADQRBqIAMgACgCACgCCBEEACADKgIYIQcgAyoCCCEIIAMqAhAhBSADKgIAIQYgAyoCFCEJIAMqAgQhCiACQQA2AgwgAiABQ6qqqj2UIgEgBCAGIAWTQwAAAD+UkiIFIAWSIgUgBZQiBSAEIAogCZNDAAAAP5SSIgYgBpIiBiAGlCIGkpQ4AgggAiABIAUgBCAIIAeTQwAAAD+UkiIEIASSIgQgBJQiBJKUOAIEIAIgASAGIASSlDgCACADQeAAaiQAC6UDAgt/BX0jAEGAEGsiBSQAIANBAEoEQANAIAIgBEEEdGpB65b46n02AgwgBEEBaiIEIANHDQALA0AgACAAKAIAKAJgEQEAQQFOBEAgAiAJQQR0IgRqIgshDCABIARqIg0hDkEAIQYDQEGAASEKAkACQCAAIAAoAgAoAmARAQAgBmtB/wBKDQAgACAAKAIAKAJgEQEAIAZrIgpBAU4NAEP//3//IQ9BfyEHDAELQQAhBANAIAAgBCAFIARBBHRqIAAoAgAoAmwRBQAgBEEBaiIEIApHDQALIA4qAgghECANKgIEIREgDSoCACESQQAhBEF/IQdD//9//yEPA0AgEiAFIARBBHRqIggqAgCUIBEgCCoCBJSSIBAgCCoCCJSSIhMgDyATIA9eIggbIQ8gBCAHIAgbIQcgBEEBaiIEIApHDQALCyAPIAwqAgxeQQFzRQRAIAsgBSAHQQR0aiIEKQIINwIIIAsgBCkCADcCACAMIA84AgwLIAZBgAFqIgYgACAAKAIAKAJgEQEASA0ACwsgCUEBaiIJIANHDQALCyAFQYAQaiQAC6ADAgV/Bn0jAEGAEGsiBCQAIABCADcCACAAQgA3AggCfSACKgIAIgogCpQgAioCBCILIAuUkiACKgIIIgggCJSSIglDF7fROF0EQEMAAIA/DAELIAhDAACAPyAJkZUiCZQhDSALIAmUIQwgCiAJlAshCiABIAEoAgAoAmARAQBBAU4EQENrC17dIQkDQEGAASEHAkACQCABIAEoAgAoAmARAQAgBWtB/wBKDQAgASABKAIAKAJgEQEAIAVrIgdBAU4NAEP//3//IQhBfyEGDAELQQAhAkEAIQMDQCABIAMgBCADQQR0aiABKAIAKAJsEQUAIANBAWoiAyAHRw0AC0F/IQZD//9//yEIA0AgCiAEIAJBBHRqIgMqAgCUIAwgAyoCBJSSIA0gAyoCCJSSIgsgCCALIAheIgMbIQggAiAGIAMbIQYgAkEBaiICIAdHDQALCyAIIAleQQFzRQRAIAAgBCAGQQR0aiICKQIINwIIIAAgAikCADcCACAIIQkLIAVBgAFqIgUgASABKAIAKAJgEQEASA0ACwsgBEGAEGokAAufEAIJfwt9IwBBIGsiCiQAAn0gAioCCCINi0PzBDU/XkEBc0UEQCACKgIEIgxDAACAPyANIA2UIAwgDJSSkZUiDJQhDyAMIA2MlCEOQwAAAAAMAQsgAioCACIMQwAAgD8gDCAMlCACKgIEIg0gDZSSkZUiDJQhDiAMIA2MlAshEAJAIAAoAgQiBUECTgRAIAAoAgwhBANAIBAgBCAHQRhsIgNqIgYqAgCUIA4gBioCBJSSIA8gBioCCJSSIBAgBCoCAJQgDiAEKgIElJIgDyAEKgIIlJJdQQFzRQRAIAogBCkCEDcDGCAKIAQpAgg3AxAgCiAEKQIANwMIIAQgBikCADcCACAEIAYpAgg3AgggBCAGKQIQNwIQIAAoAgwgA2oiAyAKKQMINwIAIAMgCikDGDcCECADIAopAxA3AgggACgCBCEFIAAoAgwhBAsgB0EBaiIHIAVIDQALIARByuWnin82AhAgBUECTgRAIAQqAgghFCAEKgIEIQ0gBCoCACEMQQEhBwNAIAQgB0EYbGoiAyAQIAMqAgQgDZMiEZQgDiADKgIAIAyTIhKUkyACKgIIlCACKgIAIA4gAyoCCCAUkyITlCAPIBGUk5QgAioCBCAPIBKUIBAgE5STlJKSIBIgEpQgESARlJIgEyATlJKRlTgCECAHQQFqIgcgBUcNAAsLIAogBCkCCDcDECAKIAQpAgA3AwggACAKQQhqQQEgBUF/ahC5AiAAKAIMIQgCQCABKAIEIgUgASgCCEcNACAFIAVBAXRBASAFGyIJTg0AQQAhBAJ/IAkEQEHo9wFB6PcBKAIAQQFqNgIAIAlBGGxBEEGM0gEoAgARAwAhCyABKAIEIQULIAVBAU4LBEADQCALIARBGGwiA2oiBiABKAIMIANqIgMpAgA3AgAgBiADKQIQNwIQIAYgAykCCDcCCCAEQQFqIgQgBUcNAAsLIAEoAgwiAwRAIAEtABAEQCADBEBB7PcBQez3ASgCAEEBajYCACADQZDSASgCABEAAAsLIAFBADYCDAsgASALNgIMIAFBAToAECABIAk2AgggASgCBCEFCyABKAIMIAVBGGxqIgMgCCkCADcCACADIAgpAhA3AhAgAyAIKQIINwIIIAEgASgCBEEBaiIFNgIEIAAoAgwhCAJAIAUgASgCCEcNACAFIAVBAXRBASAFGyIJTg0AQQAhBEEAIQsCfyAJBEBB6PcBQej3ASgCAEEBajYCACAJQRhsQRBBjNIBKAIAEQMAIQsgASgCBCEFCyAFQQFOCwRAA0AgCyAEQRhsIgNqIgYgASgCDCADaiIDKQIANwIAIAYgAykCEDcCECAGIAMpAgg3AgggBEEBaiIEIAVHDQALCyABKAIMIgMEQCABLQAQBEAgAwRAQez3AUHs9wEoAgBBAWo2AgAgA0GQ0gEoAgARAAALCyABQQA2AgwLIAEgCzYCDCABQQE6ABAgASAJNgIIIAEoAgQhBQsgASgCDCAFQRhsaiIDIAgpAhg3AgAgAyAIKQIoNwIQIAMgCCkCIDcCCCABIAEoAgRBAWoiAzYCBCAAKAIEIgRBAkYNAUECIQsDQCADQQJOBEAgACgCDCALQRhsaiIHKgIIIRUgByoCBCEWIAcqAgAhDiACKgIIIQ8gAioCBCEQIAIqAgAhESABKAIMIQUgAyEEA0ACQCAEQRhsIAVqIgNBUGoiBioCACINIANBaGoiAyoCAJMiEiAGKgIEIgwgFpMiE5QgDCADKgIEkyIMIA0gDpMiFJSTIA+UIBEgDCAGKgIIIgwgFZMiDZQgDCADKgIIkyIMIBOUk5QgECAMIBSUIBIgDZSTlJKSQwAAAABeQQFzRQRAAkAgBCABKAIIRw0AIAQgBEEBdCIJTg0AQej3AUHo9wEoAgBBAWo2AgAgBEEwbEEQQYzSASgCABEDACEFQQAhBCABKAIEIgZBAU4EQANAIAUgBEEYbCIDaiIIIAEoAgwgA2oiAykCADcCACAIIAMpAhA3AhAgCCADKQIINwIIIARBAWoiBCAGRw0ACwsgASgCDCIDBEAgAS0AEARAIAMEQEHs9wFB7PcBKAIAQQFqNgIAIANBkNIBKAIAEQAACwsgAUEANgIMCyABIAU2AgwgAUEBOgAQIAEgCTYCCCABKAIEIQQLIAUgBEEYbGoiAyAHKQIANwIAIAMgBykCEDcCECADIAcpAgg3AgggASABKAIEQQFqIgM2AgQMAQsgASAEQX9qIgM2AgQgBEECSiEGIAMhBCAGDQELCyAAKAIEIQQLIAtBAWoiCyAERw0ACwwBCyAFQQFHDQAgASgCBCEFA0AgACgCDCEIAkAgBSABKAIIRw0AIAUgBUEBdEEBIAUbIglODQBBACEEQQAhAgJ/IAkEQEHo9wFB6PcBKAIAQQFqNgIAIAlBGGxBEEGM0gEoAgARAwAhAiABKAIEIQULIAVBAU4LBEADQCACIARBGGwiA2oiBiABKAIMIANqIgMpAgA3AgAgBiADKQIQNwIQIAYgAykCCDcCCCAEQQFqIgQgBUcNAAsLIAEoAgwiAwRAIAEtABAEQCADBEBB7PcBQez3ASgCAEEBajYCACADQZDSASgCABEAAAsLIAFBADYCDAsgASACNgIMIAFBAToAECABIAk2AgggASgCBCEFCyABKAIMIAVBGGxqIgIgCCkCADcCACACIAgpAhA3AhAgAiAIKQIINwIIIAEgASgCBEEBaiIFNgIEIAdBAWoiByAAKAIESA0ACwsgCkEgaiQAC8s0AxB/AX4HfSMAQfABayICJAAgACgCNCIDBEAgAyADKAIAKAIAEQEAGiAAKAI0IgMEQEHs9wFB7PcBKAIAQQFqNgIAIANBkNIBKAIAEQAACwsCf0Ho9wFB6PcBKAIAQQFqNgIAQYQBQRBBjNIBKAIAEQMAIgMLEJ4MIAAgAzYCNCACQQA2AuQBIAJCADcC3AEgAkEBOgDoAQJAIAAgACgCACgCYBEBAEEBSA0AA0ACQCAHIAhHBEAgBiEDDAELIAggCEEBdEEBIAgbIgROBEAgBiEDDAELQQAhBUEAIQMgBARAQej3AUHo9wEoAgBBAWo2AgAgBEEEdEEQQYzSASgCABEDACEDCwJAAkAgCEEBTgRAA0AgAyAFQQR0IglqIgogBiAJaiIJKQIANwIAIAogCSkCCDcCCCAFQQFqIgUgCEcNAAwCAAsACyAGRQ0BCyACLQDoAQRAIAYEQEHs9wFB7PcBKAIAQQFqNgIAIAZBkNIBKAIAEQAACwsgAkEANgLkAQsgAiADNgLkASACQQE6AOgBIAIgBDYC4AELIAIgB0EBajYC3AEgAyAHQQR0IgRqIgMgAikCmAE3AgAgAyACKQKgATcCCCAAIAsgAigC5AEiBiAEaiAAKAIAKAJsEQUAIAtBAWoiCyAAIAAoAgAoAmARAQBODQEgAigC4AEhCCACKALcASEHDAAACwALIAJBAToAvAEgAkEANgK4ASACQQE6ANABIAJCADcDsAEgAkEANgLMASACQgA3AsQBIAJBADYCpAEgAkEBOgCoASACQgA3ApwBAkAgAUUEQCACQZgBaiAGIAIoAtwBEKYCDAELIAJBADYCPCACQQE6AEAgAkIANwI0IAJB2AFqIAJBMGoQxQogAkEANgKMASACQQE6AJABIAJCADcChAEgAigCNEEBTgRAQQAhBgNAIAIgAigCPCAGQQR0aiIBKAIINgJwIAIgASkCADcDaCABKgIMIAAgACgCACgCMBEGAJMhEwJAIAIoAoQBIgggAigCiAFHDQAgCCAIQQF0QQEgCBsiBE4NAEEAIQVBACEDAn8gBARAQej3AUHo9wEoAgBBAWo2AgAgBEEEdEEQQYzSASgCABEDACEDIAIoAoQBIQgLIAhBAU4LBEADQCADIAVBBHQiAWoiByACKAKMASABaiIBKQIANwIAIAcgASkCCDcCCCAFQQFqIgUgCEcNAAsLIAIoAowBIgEEQCACLQCQAQRAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAkEANgKMAQsgAiADNgKMASACQQE6AJABIAIgBDYCiAEgAigChAEhCAsgAigCjAEgCEEEdGoiASACKQNoNwIAIAIoAnAhAyABIBM4AgwgASADNgIIIAIgAigChAFBAWo2AoQBIAZBAWoiBiACKAI0SA0ACwsgAkEANgJ0IAJBAToAeCACQgA3AmwgAkGAAWogAkHoAGoQxAogAkGYAWogAigCdCACKAJsEKYCIAIoAnQiAQRAIAItAHgEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIAJBADYCdAsgAigCjAEiAQRAIAItAJABBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyACQQA2AowBCyACKAI8IgFFDQAgAi0AQARAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAkEANgI8C0EAIQQgAigCxAEiCUEBTgRAQQAhBUHo9wFB6PcBKAIAQQFqNgIAIAlBBHRBEEGM0gEoAgARAwAhDwNAIA8gBUEEdGoiASACKQIwNwIAIAEgAikCODcCCCAFQQFqIgUgCUcNAAsLIAJBADYCjAEgAkEBOgCQASACQgA3AoQBIAJBADYAPyACQgA3AzggAkIANwMwAkAgCUF/TARAIAkhAwNAIAQgA0EkbGoiBCEHIAQoAgwiAQRAIAQtABAEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIAdBADYCDAsgBEEBOgAQIAdBADYCDCAEQQA2AgQgBEEANgIIIANBAWoiASADSQ0CIAIoAowBIQQgASEDDAAACwALIAlFDQAgAkGAAWogCRCCAiACQTBqQQNyIgQhB0EAIQMDQCACKAKMASADQSRsaiIBQgA3AgQgAUEBOgAQIAFBADYCDCABIAQpAAA3ABQgASAHKQAINwAcIANBAWoiAyAJRw0ACwsgAiAJNgKEASAAKAI0IgMoAggiBSACKAKcASIGSARAIAMoAgwgBkgEQAJ/IAZFBEBBACEHIAUMAQtB6PcBQej3ASgCAEEBajYCACAGQQR0QRBBjNIBKAIAEQMAIQcgAygCCAsiAUEBTgRAQQAhBANAIAcgBEEEdCIKaiIIIAMoAhAgCmoiCikCADcCACAIIAopAgg3AgggBEEBaiIEIAFHDQALCyADKAIQIgEEQCADLQAUBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyADQQA2AhALIAMgBzYCECADIAY2AgwgA0EBOgAUCwNAIAMoAhAgBUEEdGoiASACKQIwNwIAIAEgAikCODcCCCAFQQFqIgUgBkcNAAsLIAMgBjYCCEEAIQUgBkEASgRAA0AgBUEEdCIBIAAoAjQoAhBqIgMgAigCpAEgAWoiASkCADcCACADIAEpAgg3AgggBUEBaiIFIAZHDQALCyAJQQFOBEBBACEBA0BBACEGIAIoArgBIAIoAswBIAFBAnRqKAIAQQxsaiIQIQMDQCABQSRsIg0gAigCjAFqIgohCyADIAMoAgRBDGxqKAIIIQ4CQCAKKAIEIgQgCigCCEcNACAEIARBAXRBASAEGyIMTg0AQQAhBUEAIQggDARAQej3AUHo9wEoAgBBAWo2AgAgDEECdEEQQYzSASgCABEDACEIIAsoAgQhBAsgCigCDCEHAkACQCAEQQFOBEADQCAIIAVBAnQiEWogByARaigCADYCACAFQQFqIgUgBEcNAAwCAAsACyAHRQ0BCyAKLQAQBEAgBwRAQez3AUHs9wEoAgBBAWo2AgAgB0GQ0gEoAgARAAALCyAKQQA2AgwgCygCBCEECyAKQQE6ABAgCiAINgIMIAogDDYCCAsgCigCDCAEQQJ0aiAONgIAIAsgCygCBEEBajYCBCAGQQFMBEAgAigCpAEiByAOQQR0aiIEKgIEIRQgByADKAIIQQR0aiIHKgIEIRYgBCoCACEVIAcqAgAhFyAEKgIIIRMgByoCCCEYIAJBMGogBkEEdGoiBEEANgIMIAQgGCATkyITQwAAgD8gFyAVkyIVIBWUIBYgFJMiFCAUlJIgEyATlJKRlSITlDgCCCAEIBQgE5Q4AgQgBCAVIBOUOAIAIAZBAWohBgsgAyADKAIEQQxsaiIDIAMoAgBBDGxqIgMgEEcNAAsCQCAGQQJGBEAgAioCNCETIAIqAkQhFSACKgJAIRQgAioCOCEWIAIqAjAhFyACKgJIIRggDyABQQR0aiIEQQA2AgwgBCAVIBeUIBMgFJSTIhlDAACAPyAZIBmUIBMgGJQgFiAVlJMiEyATlCAWIBSUIBggF5STIhUgFZSSkpGVIhSUOAIIIAQgFSAUlDgCBCAEIBMgFJQiEzgCACACKAKMASIDIA1qIgcgEzgCFCAHIAQoAgQ2AhggBCgCCCEEIAdByuWnigc2AiAgByAENgIcDAELIA8gAUEEdGoiA0IANwIAIANCADcCCCACKAKMASEDCwJAIAMgDWoiAygCBCIHQQFIBEBDyvJJcSETDAELIAMoAgwhBiAPIAFBBHRqIgQqAgghFSAEKgIEIRQgBCoCACEWIAAoAjQoAhAhCkPK8klxIRNBACEFA0AgCiAGIAVBAnRqKAIAQQR0aiIEKgIAIBaUIAQqAgQgFJSSIAQqAgggFZSSIhcgEyATIBdeGyETIAVBAWoiBSAHRw0ACwsgAyATjDgCICABQQFqIgEgCUcNAAsLQQAhCQJAIAIoAoQBQQBKBEBBACEKQQAhCANAAkAgCCAJRw0AIAkgCUEBdEEBIAkbIghPBEAgCSEIDAELQQAhBUHo9wFB6PcBKAIAQQFqNgIAIAhBAnRBEEGM0gEoAgARAwAhAQJAAkAgCQRAA0AgASAFQQJ0IgNqIAMgCmooAgA2AgAgBUEBaiIFIAlHDQAMAgALAAsgCg0AQQEhCAwBCyAKBEBB7PcBQez3ASgCAEEBajYCACAKQZDSASgCABEAAAsLIAEhCgsgCiAJQQJ0aiAJNgIAIAlBAWoiCSACKAKEAUgNAAsDQCAKIAlBf2oiB0ECdGooAgAhAUHo9wFB6PcBKAIAQQFqNgIAQQRBEEGM0gEoAgARAwAiAyABNgIAAkACQCAJQQJIBEBBASEIIAMhASAHIQkMAQsgAigCjAEiBSABQSRsaiIBKgIUIRMgASoCHCEVIAEqAhghFCAJQX5qIQZBASEEIAchCUEBIQgDQAJAIBMgBSAKIAZBAnRqKAIAIgtBJGxqIgEqAhSUIBQgASoCGJSSIBUgASoCHJSSQ3e+fz9eQQFzBEAgBCEHIAMhAQwBCwJAAkAgBCAIRw0AIAQgBEEBdEEBIAQbIgdODQBBACEFQQAhASAHBEBB6PcBQej3ASgCAEEBajYCACAHQQJ0QRBBjNIBKAIAEQMAIQELAkAgBEEBTgRAA0AgASAFQQJ0IgxqIAMgDGooAgA2AgAgBUEBaiIFIARHDQAMAgALAAsgA0UNAgsgAwRAQez3AUHs9wEoAgBBAWo2AgAgA0GQ0gEoAgARAAALDAELIAQhByADIQELIAEgCEECdGogCzYCACAIQQFqIQhBACEFIAlBAUgNAANAIAsgCiAFQQJ0aiIDKAIARwRAIAVBAWoiBSAJRw0BDAILCyAFIAlODQAgAyAKIAlBf2oiCUECdGoiAygCADYCACADIAs2AgALIAZBAU4EQCAGQX9qIQYgAigCjAEhBSABIQMgByEEDAELCwJAIAhBAUwNAEEAIQMgAkEANgJ0IAJBAToAeCACQgA3AmwgAkIANwMoIAJCADcDIEMAAAAAIRNDAAAAACEVQwAAAAAhFEEAIQcDQCACKAKMASABIAdBAnRqKAIAQSRsaiIMKgIYIRYgDCoCHCEXIAIgDCoCFCAUkjgCICACIBcgE5I4AiggAiAWIBWSOAIkIAwoAgQiBkEBTgRAQQAhCwNAIAIgACgCNCgCECAMKAIMIAtBAnRqKAIAIg5BBHRqIgQpAgg3AxAgAiAEKQIANwMIAkAgA0EBTgRAIANBASADQQFKGyEEQQAhBSACKAJ0IQ0DQCANIAVBGGxqKAIUIA5GDQIgBUEBaiIFIARHDQALCyACIAIpAxA3AzggAiACKQMINwMwAkAgAyACKAJwRw0AIAMgA0EBdEEBIAMbIg1ODQBBACEFQQAhBiANBEBB6PcBQej3ASgCAEEBajYCACANQRhsQRBBjNIBKAIAEQMAIQYgAigCbCEDCyACKAJ0IQQCQAJAIANBAU4EQANAIAYgBUEYbCIRaiIQIAQgEWoiESkCADcCACAQIBEpAhA3AhAgECARKQIINwIIIAVBAWoiBSADRw0ADAIACwALIARFDQELIAItAHgEQCAEBEBB7PcBQez3ASgCAEEBajYCACAEQZDSASgCABEAAAsgAigCbCEDCyACQQA2AnQLIAIgBjYCdCACQQE6AHggAiANNgJwCyACKAJ0IANBGGxqIgMgAikDMDcCACACKQM4IRIgAkFAaygCACEEIAMgDjYCFCADIAQ2AhAgAyASNwIIIAIgAigCbEEBaiIDNgJsIAwoAgQhBgsgC0EBaiILIAZIDQALCyACKgIoIRMgAioCJCEVIAIqAiAhFCAHQQFqIgcgCEcNAAsgAkEANgI8IAJBAToAQCACQgA3AjQgAiACKAKMASABKAIAQSRsaiIDKAIUNgJEIAIgAygCGDYCSCACIAMoAhw2AkwgAiADKAIgNgJQIAIgFEMAAIA/IBQgFJQgFSAVlJIgEyATlJKRlSIUlDgCICACIBUgFJQ4AiQgAiATIBSUOAIoIAJBADYCFCACQQE6ABggAkIANwIMIAJB6ABqIAJBCGogAkEgahDrCwJAIAIoAgxBAEwEQCACKAJsIQMMAQtBACEHIAIoAjQhBgNAIAdBGGwiDCACKAIUaiENAkAgBiACKAI4Rw0AIAYgBkEBdEEBIAYbIgtODQBBACEFQQAhBCALBEBB6PcBQej3ASgCAEEBajYCACALQQJ0QRBBjNIBKAIAEQMAIQQgAigCNCEGCyACKAI8IQMCQAJAIAZBAU4EQANAIAQgBUECdCIOaiADIA5qKAIANgIAIAVBAWoiBSAGRw0ADAIACwALIANFDQELIAItAEAEQCADBEBB7PcBQez3ASgCAEEBajYCACADQZDSASgCABEAAAsLIAJBADYCPCACKAI0IQYLIAIgBDYCPCACQQE6AEAgAiALNgI4CyACKAI8IAZBAnRqIA0oAhQ2AgAgAiACKAI0QQFqIgY2AjQCQCACKAJsIgNBAUgNACACKAIUIAxqKAIUIQRBACEFIAIoAnQhCwNAIAQgCyAFQRhsaiIMKAIURwRAIAMgBUEBaiIFRw0BDAILCyAMQX82AhQLIAdBAWoiByACKAIMSA0ACwsgA0EBTgRAQQAhCyACKAKMASEGIAIoAoQBIQcgAigCdCEMA0ACQCAMIAtBGGxqKAIUIg1Bf0YNAEEAIQQgB0EBSA0AA0BBACEFAkAgCEEASgRAA0AgASAFQQJ0aigCACAERg0CIAVBAWoiBSAIRw0ACwsgBiAEQSRsaiIFKAIEIg5BAUgNACAFKAIMIRBBACEFA0AgDSAQIAVBAnRqKAIARwRAIAVBAWoiBSAOSA0BDAILCyACKAIUIgMEQCACLQAYBEAgAwRAQez3AUHs9wEoAgBBAWo2AgAgA0GQ0gEoAgARAAALCyACQQA2AhQLIAIoAjwiAwRAIAItAEAEQCADBEBB7PcBQez3ASgCAEEBajYCACADQZDSASgCABEAAAsLIAJBADYCPAsgAigCdCIDRQ0FIAItAHgEQCADBEBB7PcBQez3ASgCAEEBajYCACADQZDSASgCABEAAAsLIAJBADYCdAwFCyAEQQFqIgQgB0cNAAsLIAtBAWoiCyADRw0ACwsgACgCNEEYaiACQTBqEJEEIAIoAhQiAwRAIAItABgEQCADBEBB7PcBQez3ASgCAEEBajYCACADQZDSASgCABEAAAsLIAJBADYCFAsgAigCPCIDBEAgAi0AQARAIAMEQEHs9wFB7PcBKAIAQQFqNgIAIANBkNIBKAIAEQAACwsgAkEANgI8CyACKAJ0IgNFDQIgAi0AeARAIAMEQEHs9wFB7PcBKAIAQQFqNgIAIANBkNIBKAIAEQAACwsgAkEANgJ0DAILIAhBAUgNAQtBACELA0AgASALQQJ0aigCACEDIAJBADYCPCACQgA3AjQgAigCjAEhBCACQQE6AEACQCAEIANBJGxqIgcoAgQiBEEBTgRAQej3AUHo9wEoAgBBAWo2AgAgBEECdCIMQRBBjNIBKAIAEQMAIQZBACEFIAIoAjwhAwJAAkAgAigCNCINQQFOBEADQCAGIAVBAnQiDmogAyAOaigCADYCACAFQQFqIgUgDUcNAAwCAAsACyADRQ0BCyACLQBARQ0AIAMEQEHs9wFB7PcBKAIAQQFqNgIAIANBkNIBKAIAEQAACwsgAiAGNgI8IAJBAToAQCACIAQ2AjhBACEFIAZBACAMEAsaIAIgBDYCNCAHKAIMIQMgAigCPCEGA0AgBiAFQQJ0IgxqIAMgDGooAgA2AgAgBUEBaiIFIARHDQALDAELIAIgBDYCNAsgAiAHKQIUNwJEIAIgBykCHDcCTCAAKAI0QRhqIAJBMGoQkQQgAigCPCIDBEAgAi0AQARAIAMEQEHs9wFB7PcBKAIAQQFqNgIAIANBkNIBKAIAEQAACwsgAkEANgI8CyALQQFqIgsgCEcNAAsLIAEEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIAkNAAsgACgCNBCZBCAKRQ0BIAoEQEHs9wFB7PcBKAIAQQFqNgIAIApBkNIBKAIAEQAACwwBCyAAKAI0EJkECyACKAKEASIHQQFOBEBBACEDA0AgAigCjAEgA0EkbGoiASEEIAEoAgwiAARAIAEtABAEQCAABEBB7PcBQez3ASgCAEEBajYCACAAQZDSASgCABEAAAsLIARBADYCDAsgAUEBOgAQIARBADYCDCABQQA2AgQgAUEANgIIIANBAWoiAyAHRw0ACwsgAigCjAEiAARAIAItAJABBEAgAARAQez3AUHs9wEoAgBBAWo2AgAgAEGQ0gEoAgARAAALCyACQQA2AowBCyAPBEAgDwRAQez3AUHs9wEoAgBBAWo2AgAgD0GQ0gEoAgARAAALCyACKALMASIABEAgAi0A0AEEQCAABEBB7PcBQez3ASgCAEEBajYCACAAQZDSASgCABEAAAsLIAJBADYCzAELIAJBADYCzAEgAkEBOgDQASACQgA3AsQBIAIoArgBIgAEQCACLQC8AQRAIAAEQEHs9wFB7PcBKAIAQQFqNgIAIABBkNIBKAIAEQAACwsgAkEANgK4AQsgAkEANgK4ASACQQE6ALwBIAJCADcDsAEgAigCpAEiAARAIAItAKgBBEAgAARAQez3AUHs9wEoAgBBAWo2AgAgAEGQ0gEoAgARAAALCyACQQA2AqQBCyACKALkASIABEAgAi0A6AEEQCAABEBB7PcBQez3ASgCAEEBajYCACAAQZDSASgCABEAAAsLIAJBADYC5AELIAJB8AFqJABBAQs3AQF/IwBBEGsiAiAANgIMIAIgATYCCCACKAIMIgAgAigCCCIBKQIANwK4BSAAIAEpAgg3AsAFC2kAIAAgASACED0aIAEgACgCRDYCDCABIAAoAkg2AhAgASAAKAJMNgIUIAEgACgCUDYCGCABIAAoAjA2AhwgASAAKAI0NgIgIAEgACgCODYCJCABIAAoAjw2AiggASAAKAJANgIsQYCMAQsGAEH0iwELCAAgAEHEAGoLFgAgACABKQIANwJEIAAgASkCCDcCTAuVBQIBfxB9IwBBMGsiBCQAIAMqAgAiCCACKgIAIgmTQwAAAD+UIgUgBZQgAyoCBCIGIAIqAgQiC5NDAAAAP5QiBSAFlJIgAyoCCCIKIAIqAggiDJNDAAAAP5QiBSAFlJKRIQUgCiAMkkMAAAA/lCEKIAYgC5JDAAAAP5QhCyAIIAmSQwAAAD+UIQwCQCAAKgI4IgiLQ/MENT9eQQFzRQRAIAggCJQgACoCNCIJIAmUkiIGQwAAgD8gBpGVIgeUIREgCSAHlCINIAAqAjAiBoyUIQ4gBiAHIAiMlCIHlCEPDAELIAAqAjAiBiAGlCAAKgI0IgkgCZSSIgdDAACAPyAHkZUiB5QhDyAIIAcgCYyUIhKUIQ4gBiAHlCIHIAiMlCERCyAAKgJAIRAgBEEANgIsIARBADYCHCAEIAogCCAIIAqUIAwgBpQgCyAJlJKSIBCTIgqUkyIQIAUgDZQiDZMiEyAFIA+UIgiTIg84AiggBCALIAkgCpSTIgsgBSAHlCIHkyIUIAUgDpQiCZMiDjgCJCAEIA0gEJIiDSAIkzgCGCAEIAcgC5IiCyAJkzgCFCAEQQA2AgwgBCAMIAYgCpSTIgYgBSASlCIKkyIMIAUgEZQiBZMiBzgCICAEIAogBpIiBiAFkzgCECAEIAggDZIiCjgCCCAEIAkgC5IiCzgCBCAEIAUgBpIiBjgCACABIARBAEEAIAEoAgAoAggRBAAgBEEANgIsIAQgCjgCKCAEIAs4AiQgBEEANgIcIAQgCCATkjgCGCAEIAkgFJI4AhQgBCAGOAIgIAQgBSAMkjgCECAEQQA2AgwgBCAPOAIIIAQgDjgCBCAEIAc4AgAgASAEQQBBASABKAIAKAIIEQQAIARBMGokAAs3ACACQuuW+OoNNwIIIAJC65b46r3tgq9dNwIAIANC65b46gU3AgggA0Lrlvjqte2Cr90ANwIAC5kBAQN9IABCIzcCBCAAQQA2AgwgAEGgmwE2AgAgAEGMiwE2AgAgASoCCCEDIAEqAgAhBCABKgIEIQUgASgCDCEBIABCADcCRCAAIAI4AkAgACABNgI8IABCADcCTCAAQRw2AgQgACADQwAAgD8gBCAElCAFIAWUkiADIAOUkpGVIgKUOAI4IAAgBSAClDgCNCAAIAQgApQ4AjAL4wEBBX0gACoCWCIGIAEqAgCUIAAqAlwiByABKgIElJIgACoCYCIIIAEqAgiUkiIEIAAqAlQiBV5BAXNFBEAgACAEOAJUIAAgASkCCDcCDCAAIAEpAgA3AgQgBCEFCyAGIAEqAhCUIAcgASoCFJSSIAggASoCGJSSIgQgBV5BAXNFBEAgACAEOAJUIAAgASkCGDcCDCAAIAEpAhA3AgQgBCEFCyAGIAEqAiCUIAcgASoCJJSSIAggASoCKJSSIgQgBV5BAXNFBEAgACAEOAJUIAAgASkCKDcCDCAAIAEpAiA3AgQLC6kCAgJ/BH0CQCABKgIAIgYgASoCECIHIAYgB10bIgkgASoCICIIIAkgCF0bIAAqAhheDQAgASAGIAdeQQFzQQR0IgRBICABIARqKgIAIAheG2oqAgAgACoCCF0NACABKgIIIgYgAUEYaiIEKgIAIgcgBiAHXRsiCSABQShqIgUqAgAiCCAJIAhdGyAAKgIgXg0AIAFBCGogBCAGIAdeGyIEIAUgBCoCACAIXhsqAgAgACoCEF0NACABKgIEIgYgAUEUaiIEKgIAIgcgBiAHXRsiCSABQSRqIgUqAgAiCCAJIAhdGyAAKgIcXg0AIAFBBGogBCAGIAdeGyIEIAUgBCoCACAIXhsqAgAgACoCDF0NACAAKAIEIgAgASACIAMgACgCACgCCBEEAAsLBgBB9IoBC+sCAgF/BH0jAEGgAWsiAyQAIANBADYCmAEgA0IANwOQASADQgA3A4gBIANCADcCLCADQgA3AzggA0FAa0IANwMAIANCADcCTCADQYCAgPwDNgJIIANCADcCVCADQoCAgPwDNwJcIAMgAykCjAE3AmQgAyADKQKUATcCbCADQgA3AiQgA0HEigE2AiAgA0GAgID8AzYCNCADQeuW+Op9NgJ0IAIqAgQhBCACKgIAIQUgAioCCCEGIANBADYChAEgAyAEIAUgAyoCOJSSIAZDAAAAAJQiB5I4AnwgAyAGIAUgAyoCPJQgBEMAAAAAlCIEkpI4AoABIAMgBSAEkiAHkjgCeCADQuuW+OoFNwMYIANC65b46rXtgq/dADcDECADQuuW+OoNNwMIIANC65b46r3tgq9dNwMAIAEgA0EgaiADIANBEGogASgCACgCQBEEACAAIAMpAiw3AgggACADKQIkNwIAIANBoAFqJAALZwEBfyMAQTBrIgQkACAEIAE2AgwgBEG8iQE2AgggBCACKQIINwMYIAQgAikCADcDECAEIAMpAgg3AyggBCADKQIANwMgIAAoAjAiACAEQQhqIAIgAyAAKAIAKAIIEQQAIARBMGokAAsKACAAKAIwQQRqC+YDARt9IAAqAhghDSAAKgIoIRMgACoCFCEUIAAqAiQhFSAAKgIQIQYgACoCICEWIAAgACgCACgCMBEGACEXIAAgACgCACgCMBEGACEYIAAgACgCACgCMBEGACEZIAEqAjQhGiABKgIYIQcgASoCFCEIIAEqAjghCSAAKgIUIQogACoCJCELIAAqAhghDiAAKgIoIRsgASoCKCEMIAEqAiQhBCABKgIwIRwgASoCCCEPIAEqAgAhECABKgIEIREgASoCECESIAAqAhAhHSAAKgIgIR4gASoCICEFIAJBADYCDCACIAkgBSAeIB2SQwAAAD+UIgmUIAQgCyAKkkMAAAA/lCIKlJIgDCAbIA6SQwAAAD+UIguUkpIiDiAXIBYgBpNDAAAAP5SSIgYgBYuUIBggFSAUk0MAAAA/lJIiBSAEi5SSIBkgEyANk0MAAAA/lJIiBCAMi5SSIgyTOAIIIAIgGiAJIBKUIAogCJSSIAsgB5SSkiINIAYgEouUIAUgCIuUkiAEIAeLlJIiB5M4AgQgAiAcIAkgEJQgCiARlJIgCyAPlJKSIgggBiAQi5QgBSARi5SSIAQgD4uUkiIEkzgCACADQQA2AgwgAyAMIA6SOAIIIAMgByANkjgCBCADIAQgCJI4AgALXQAgAEIjNwIEIABBADYCDCAAQaCbATYCACAAIAE2AjAgAEHEiAE2AgAgAEEVNgIEIAEgASgCACgCKBEBAARAIAEgAEEQaiAAQSBqIAEoAgAoAjARBQAPCyAAEJQEC7cFAgl/BH0jAEEgayIEJAAgACgCBCIDIARBHGogBEEYaiAEQRRqIARBEGogBEEMaiAEQQhqIARBBGogBCABIAMoAgAoAhARGwAgBCgCDCAEKAIIIAJsaiEGIAQoAhAhCCAEKAIcIQkgBCgCFCEKIAAoAgQiBUEMaiEHIAkCfyAEKAIAIgtBfmoiA0EBTQRAIAYvAQQgA0EBa0UNARogBigCCAwBCyAGLQACCyAIbGohAwJ/IApFBEAgAyoCBCAFKgIIlCEOIAMqAgAgBSoCBJQhDCAFKgIMIQ0gA0EIagwBCyAFKgIIIAMrAwi2lCEOIAUqAgQgAysDALaUIQwgAysDELYhDSAHCyoCACEPIABBADYCOCAAIA44AjAgACAMOAIsIAAgDyANlDgCNCAJAn8gC0F+aiIDQQFNBEAgBigCBCADQQFrDQEaIAYvAQIMAQsgBi0AAQsgCGxqIQMCfyAKBEAgBSoCCCADKwMItpQhDiAFKgIEIAMrAwC2lCEMIAMrAxC2IQ0gBwwBCyADKgIEIAUqAgiUIQ4gAyoCACAFKgIElCEMIAUqAgwhDSADQQhqCyoCACEPIABBADYCKCAAIA44AiAgACAMOAIcIAAgDyANlDgCJCAJAn8gC0F+aiIDQQFNBEAgBigCACADQQFrDQEaIAYvAQAMAQsgBi0AAAsgCGxqIQMCfSAKBEAgBSoCBCADKwMAtpQhDCADKwMQtiENIAUqAgggAysDCLaUDAELIANBCGohByADKgIAIAUqAgSUIQwgBSoCDCENIAMqAgQgBSoCCJQLIQ4gByoCACEPIABBADYCGCAAIA44AhAgACAMOAIMIAAgDyANlDgCFCAAKAIIIgMgAEEMaiABIAIgAygCACgCCBEEACAAKAIEIgAgASAAKAIAKAIYEQIAIARBIGokAAsTACAAIAEgAiABKAIAKAJEEQUACzcBAX8jAEEQayICIAA2AgwgAiABNgIIIAIoAgwiACACKAIIIgEpAgA3AqgFIAAgASkCCDcCsAULBgBBrIgBC10BAn8gACgCOCICBEAgASABIAIgAigCACgCCBEBAEEBIAEoAgAoAhARBwAiAiAAKAI4IgMgAigCCCABIAMoAgAoAgwRBwBB1JqFggUgACgCOCABKAIAKAIUEQkACwtdAQJ/IAAoAjQiAgRAIAEgASACIAIoAgAoAgwRAQBBASABKAIAKAIQEQcAIgIgACgCNCIDIAIoAgggASADKAIAKAIQEQcAQdGE2cIEIAAoAjQgASgCACgCFBEJAAsLsgMBAn8gACABIAIQPRogACgCMCIDIAFBDGogAiADKAIAKAI4EQcAGiABIAAoAgw2AjQCQAJAIAAoAjRFDQAgAiACKAIAKAI0EQEAQQFxDQAgAiAAKAI0IAIoAgAoAhgRAwAiAwRAIAFBADYCLCABIAM2AigMAgsgAiAAKAI0IAIoAgAoAhwRAwAhAyABQQA2AiwgASADNgIoIAIgAiAAKAI0IgMgAygCACgCDBEBAEEBIAIoAgAoAhARBwAiAyAAKAI0IgQgAygCCCACIAQoAgAoAhARBwBB0YTZwgQgACgCNCACKAIAKAIUEQkADAELIAFCADcCKAsCQCAAKAI4RQ0AIAIgAigCACgCNBEBAEECcQ0AIAIgACgCOCACKAIAKAIYEQMAIgMEQCABIAM2AjBBoIQBDwsgASACIAAoAjggAigCACgCHBEDADYCMCACIAIgACgCOCIBIAEoAgAoAggRAQBBASACKAIAKAIQEQcAIgEgACgCOCIDIAEoAgggAiADKAIAKAIMEQcAQdSahYIFIAAoAjggAigCACgCFBEJAEGghAEPCyABQQA2AjBBoIQBC+wBAgF/AX0gACAAKAIAKAIcEQEAIgIqAgAgASoCAJMiAyADlCACKgIEIAEqAgSTIgMgA5SSIAIqAgggASoCCJMiAyADlJJDAAAANF5BAXNFBEAgACABEJMEIAAtAD0EQCAAKAI0IgEgASgCACgCABEBABogACgCNCIBBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLAn9B6PcBQej3ASgCAEEBajYCAEGsAUEQQYzSASgCABEDACIBCxCDBCECIAAgATYCNCACIAAoAjAgAC0APCAAQRBqIABBIGoQggQgAEEBOgA9CwtAAQJ/IwBBQGoiBCQAIAAoAjAhBSAEIAE2AgggBCAFNgIEIARBpIcBNgIAIAAoAjQgBCACIAMQ0QogBEFAayQAC0QBAn8jAEEQayIGJAAgACgCMCEHIAYgATYCCCAGIAc2AgQgBkGQhgE2AgAgACgCNCAGIAIgAyAEIAUQzQogBkEQaiQAC0ABAn8jAEEQayIEJAAgACgCMCEFIAQgATYCCCAEIAU2AgQgBEHohAE2AgAgACgCNCAEIAIgAxDOCiAEQRBqJAALcQEBfyAAQcyDATYCACAALQA9BEAgACgCNCIBIAEoAgAoAgARAQAaIAAoAjQiAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAABEBB7PcBQez3ASgCAEEBajYCACAAQZDSASgCABEAAAsLUQEBfyAAQcyDATYCACAALQA9BEAgACgCNCIBIAEoAgAoAgARAQAaIAAoAjQiAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAACw0AIAAqAhwgACoCDJQLBgBBvIMBC0wBAn0gACAAKAIAKAIwEQYAIQMgACAAKAIAKAIwEQYAIQQgAkEANgIMIAIgBCADIAFDzczMPpSUlCIBOAIIIAIgATgCBCACIAE4AgAL5QECAX8EfSMAQRBrIgMkACADIAEgAiABKAIAKAJEEQUAIAAgAykDCDcCCCAAIAMpAwA3AgAgAioCBCEFIAIqAgAhBCACKgIIIQYgASABKAIAKAIwEQYAIQcgACAAKgIAIAdDAACAvyAEIAQgBJQgBSAFlJIgBiAGlJJDAACAKF0iARsiBEMAAIA/QwAAgL8gBiABGyIGIAaUIAQgBJRDAACAvyAFIAEbIgUgBZSSkpGVIgSUlJI4AgAgACAAKgIEIAcgBSAElJSSOAIEIAAgACoCCCAHIAYgBJSUkjgCCCADQRBqJAALFgAgA0EBTgRAIAJBACADQQR0EAsaCwsQACAAQgA3AgAgAEIANwIICwUAQcAACwYAQbCCAQtfAQF/IwBBIGsiBSQAIAUgADYCHCAFIAE2AhggBSACNgIUIAUgAzYCECAFIAQ6AA9BoAoQDSIAIAUoAhwgBSgCGCAFKAIUIAUoAhAgBS0AD0EBcRDnBCAFQSBqJAAgAAvPAQEBfyAAQYiBATYCACAAKAJ4IgEEQCAALQB8BEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AngLIABBADYCeCAAQgA3AnAgAEEBOgB8IAAoAmQiAQRAIAAtAGgEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYCZAsgAEEANgJkIABCADcCXCAAQQE6AGggAARAQez3AUHs9wEoAgBBAWo2AgAgAEGQ0gEoAgARAAALC68BAQF/IABBiIEBNgIAIAAoAngiAQRAIAAtAHwEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYCeAsgAEEANgJ4IABCADcCcCAAQQE6AHwgACgCZCIBBEAgAC0AaARAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgJkCyAAQQA2AmQgAEIANwJcIABBAToAaCAAC8wCAQV/IAAgASACED0aIAEgACgCHDYCHCABIAAoAiA2AiAgASAAKAIkNgIkIAEgACgCKDYCKCABIAAoAgw2AgwgASAAKAIQNgIQIAEgACgCFDYCFCABIAAoAhg2AhggASAAKAIsNgIsIAAoAlwiBARAIAIgAEHkAGooAgAgAigCACgCHBEDACEDIAEgBDYCOCABIAM2AjQgAkEUIAQgAigCACgCEBEHACEFIAAoAmQhBiAEQQFOBEAgACgCeCEHIAUoAgghAEEAIQEDQCAAIAYgAUEEdGoiAygCADYCACAAIAMoAgQ2AgQgACADKAIINgIIIAAgAygCDDYCDCAAIAcgAUECdGooAgA2AhAgAEEUaiEAIAFBAWoiASAERw0ACwsgAiAFQeSBAUHBpIXKBSAGIAIoAgAoAhQRCQBB+IEBDwsgAUIANwI0QfiBAQujAQEGfSAAKgJMIQMgACoCPCEGIAAqAkghBCAAKgI4IQcgACoCRCEFIAAqAjQhCCACQQA2AgwgAiABQwAAQEGVIgEgBSAIk0MAAAA/lCIFIAWSIgUgBZQiBSAEIAeTQwAAAD+UIgQgBJIiBCAElCIEkpQ4AgggAiABIAUgAyAGk0MAAAA/lCIDIAOSIgMgA5QiA5KUOAIEIAIgASAEIAOSlDgCAAvFBAIOfw99IwBBgBBrIgokACADQQFOBEADQCAAKAJcIgxBAU4EQCACIAtBBHQiB2ohECABIAdqIgghDSAAKAJkIQkgACgCeCEOQ2sLXt0hF0EAIQ8gDCEHA0ACQCAMIA9rIgRBAUgEQEP//3//IRJBfyEFDAELIARBgAEgBEGAAUgbIREgB0GAASAHQYABSBsiBEEBIARBAUobIQQgDSoCCCEaIAgqAgQhEyAIKgIAIRRBACEFA0AgCSoCACEbIAAqAgwhHCAJKgIEIR0gACoCECEeIAkqAgghHyAOKgIAIRggACoCFCEgIAAgACgCACgCMBEGACEZIAgqAgAhFSAIKgIEIRYgDSoCCCESIAogBUEEdGoiBkEANgIMIAYgHyAYIBogIJSUkiAZIBKUkzgCCCAGIB0gGCATIB6UlJIgGSAWlJM4AgQgBiAbIBggFCAclJSSIBkgFZSTOAIAIA5BBGohDiAJQRBqIQkgEiEaIBYhEyAVIRQgBUEBaiIFIARHDQALIA0qAgghEyAIKgIEIRQgCCoCACEVQQAhBkF/IQVD//9//yESA0AgFSAKIAZBBHRqIgQqAgCUIBQgBCoCBJSSIBMgBCoCCJSSIhYgEiAWIBJeIgQbIRIgBiAFIAQbIQUgBkEBaiIGIBFHDQALCyASIBdeBEAgECAKIAVBBHRqIgQpAgg3AgggECAEKQIANwIAIBIhFwsgB0GAf2ohByAMIA9BgAFqIg9KDQALCyALQQFqIgsgA0cNAAsLIApBgBBqJAALsgQCCn8MfSMAQYAQayIFJAAgAEIANwIAIABCADcCCAJ9IAIqAgAiDSANlCACKgIEIhAgEJSSIAIqAggiDyAPlJIiDkMAAIAoXQRAQwAAAAAhD0MAAIA/DAELIA9DAACAPyAOkZUiDpQhEiAQIA6UIQ8gDSAOlAshDiABKAJcIghBAU4EQCABKAJkIQIgASgCeCEJQ2sLXt0hECAIIQYDQAJAIAggCmsiA0EASgRAIANBgAEgA0GAAUgbIQsgBkGAASAGQYABSBsiA0EBIANBAUobIQxBACEDA0AgAioCACETIAEqAgwhFCACKgIEIRUgASoCECEWIAIqAgghFyAJKgIAIQ0gASoCFCEYQQAhByABIAEoAgAoAjARBgAhESAFIANBBHRqIgRBADYCDCAEIBcgDSASIBiUlJIgEiARlJM4AgggBCAVIA0gDyAWlJSSIA8gEZSTOAIEIAQgEyANIA4gFJSUkiAOIBGUkzgCACAJQQRqIQkgAkEQaiECIANBAWoiAyAMRw0AC0F/IQND//9//yENA0AgDiAFIAdBBHRqIgQqAgCUIA8gBCoCBJSSIBIgBCoCCJSSIhEgDSARIA1eIgQbIQ0gByADIAQbIQMgB0EBaiIHIAtHDQALDAELQ///f/8hDUF/IQMLIA0gEF4EQCAAIAUgA0EEdGoiAykCCDcCCCAAIAMpAgA3AgAgDSEQCyAGQYB/aiEGIAggCkGAAWoiCkoNAAsLIAVBgBBqJAALxgUBCH8jAEEQayIJJAAgABDaCyEKIABBAToAaCAAQYiBATYCACAAQQA2AmQgAEEBOgB8IABCADcCXCAAQQA2AnggAEIANwJwIABBCTYCBCADQQFOBEBB6PcBQej3ASgCAEEBajYCACADQQR0QRBBjNIBKAIAEQMAIQYgACgCXCIEQQFOBEADQCAGIAVBBHQiB2oiCCAAKAJkIAdqIgcpAgA3AgAgCCAHKQIINwIIIAVBAWoiBSAERw0ACwsgACgCZCIEBEAgAC0AaARAIAQEQEHs9wFB7PcBKAIAQQFqNgIAIARBkNIBKAIAEQAACwsgAEEANgJkCyAAIAY2AmRBASEFIABBAToAaCAAIAM2AmAgBiAJKQIINwIIIAYgCSkCADcCACADQQFHBEADQCAAKAJkIAVBBHRqIgQgCSkCADcCACAEIAkpAgg3AgggBUEBaiIFIANHDQALCyAAKAJwIQQLIAAgAzYCXCAEIANIBEACQCAAKAJ0IANOBEAgACgCeCEIDAELQQAhBSAEIQZBACEIIAMEQEHo9wFB6PcBKAIAQQFqNgIAIANBAnRBEEGM0gEoAgARAwAhCCAAKAJwIQYLIAAoAnghBwJAAkAgBkEBTgRAA0AgCCAFQQJ0IgtqIAcgC2ooAgA2AgAgBUEBaiIFIAZHDQAMAgALAAsgBw0ADAELIAAtAHwEQCAHBEBB7PcBQez3ASgCAEEBajYCACAHQZDSASgCABEAAAsLCyAAIAg2AnggAEEBOgB8IAAgAzYCdAsgCCAEQQJ0akEAIAMgBGtBAnQQCxoLIAAgAzYCcEEAIQUgA0EASgRAA0AgBUEEdCIEIAAoAmRqIgYgASAEaiIEKQIANwIAIAYgBCkCCDcCCCAFQQJ0IgQgACgCeGogAiAEaigCADYCACAFQQFqIgUgA0cNAAsLIAoQjQQgCUEQaiQAC50FAQl/AkAgACgCBCIHIAAoAjAiAU4NAAJAIAAoAgggAU4EQCAAKAIMIQMMAQsgByECIAEEQEHo9wFB6PcBKAIAQQFqNgIAIAFBAnRBEEGM0gEoAgARAwAhAyAAKAIEIQILIAAoAgwhBAJAAkAgAkEBTgRAA0AgAyAFQQJ0IgZqIAQgBmooAgA2AgAgBUEBaiIFIAJHDQAMAgALAAsgBA0ADAELIAAtABAEQCAEBEBB7PcBQez3ASgCAEEBajYCACAEQZDSASgCABEAAAsLCyAAIAM2AgwgAEEBOgAQIAAgATYCCAsgAyAHQQJ0IgJqQQAgAUECdCIIIAJrEAsaIAAgATYCBCAAKAIYIgYgAUgEQAJAIAAoAhwgAU4EQCAAKAIgIQMMAQtBACEFIAYhAkEAIQMgAQRAQej3AUHo9wEoAgBBAWo2AgAgCEEQQYzSASgCABEDACEDIAAoAhghAgsgACgCICEEAkAgAkEBTgRAA0AgAyAFQQJ0IglqIAQgCWooAgA2AgAgBUEBaiIFIAJHDQAMAgALAAsgBA0AIAAgAzYCICAAIAE2AhwgAEEBOgAkDAELIAAtACQEQCAEBEBB7PcBQez3ASgCAEEBajYCACAEQZDSASgCABEAAAsLIAAgAzYCICAAQQE6ACQgACABNgIcCyADIAZBAnQiAmpBACAIIAJrEAsaCyAAIAE2AhggAUEBTgRAIAAoAgxB/wEgCBALGiAAKAIgQf8BIAgQCxoLIAdBAUgNACAAKAIgIQIgACgCSCEEIAAoAgwhBkEAIQUDQCACIAVBAnQiAWogBiABIARqIgEvAQJBEHQgAS4BAGogACgCMEF/anFBAnRqIgEoAgA2AgAgASAFNgIAIAVBAWoiBSAHRw0ACwsLgAYBCH8CQAJAIAEuAQAiBCABLwECIgdBEHRqIAAoAjAiCEF/anEiCSAAKAIETw0AIAAoAgwgCUECdGooAgAiA0F/Rg0AIAAoAkghBSAEQf//A3EhBANAIAUgA0ECdCIGaiIKLwEAIARGQQAgByAKLwECRhsNAiAAKAIgIAZqKAIAIgNBf0cNAAsLIAAoAiwiByEDAkAgByAIRw0AIAgiAyADQQF0QQEgAxsiBU4NAAJ/IAVFBEBBACEEIAgMAQtB6PcBQej3ASgCAEEBajYCACAFQQJ0QRBBjNIBKAIAEQMAIQQgACgCLAsiBkEBTgRAQQAhAwNAIAQgA0ECdCIKaiAAKAI0IApqKAEANgEAIANBAWoiAyAGRw0ACwsgACgCNCIDBEAgAC0AOARAIAMEQEHs9wFB7PcBKAIAQQFqNgIAIANBkNIBKAIAEQAACwsgAEEANgI0CyAAIAQ2AjQgACAFNgIwIABBAToAOCAAKAIsIQMLIAAoAjQgA0ECdGogAigBADYBACAAIAAoAixBAWo2AiwCQCAAQUBrKAIAIgQgACgCREcNACAEIARBAXRBASAEGyIFTg0AAkAgBUUEQEEAIQYMAQtB6PcBQej3ASgCAEEBajYCACAFQQJ0QRBBjNIBKAIAEQMAIQYgACgCQCEECyAEQQFOBEBBACEDA0AgBiADQQJ0IgJqIAAoAkggAmooAQA2AQAgA0EBaiIDIARHDQALCyAAKAJIIgIEQCAALQBMBEAgAgRAQez3AUHs9wEoAgBBAWo2AgAgAkGQ0gEoAgARAAALCyAAQQA2AkgLIAAgBjYCSCAAIAU2AkQgAEEBOgBMIAAoAkAhBAsgACgCSCAEQQJ0aiABKAEANgEAIAAgACgCQEEBajYCQCAIIAAoAjBIBEAgABCaDCABLgEAIAEvAQJBEHRqIAAoAjBBf2pxIQkLIAAoAiAgB0ECdGogACgCDCAJQQJ0aiIAKAIANgIAIAAgBzYCAA8LIAAoAjQgA0ECdGogAigBADYBAAtHAQF/IwBBEGsiAyQAIAMgADYCDCADIAE2AgggAyACOgAHQaAKEA0iACADKAIMIAMoAgggAy0AB0EBcRDmBCADQRBqJAAgAAspACAAEJoEIgAEQEHs9wFB7PcBKAIAQQFqNgIAIABBkNIBKAIAEQAACwtKACAAQdiAATYCACAAQQE6ABQgAEEANgIQIABBAToAKCAAQgA3AgggAEEANgIkIABBAToAPCAAQgA3AhwgAEEANgI4IABCADcCMAsUACAAQgA3AgggAEKAgID8AzcCAAsGAEHHgAELFAAgAEKAgID8AzcCCCAAQgA3AgALBgBBwYABC3MAIAAgASACED0aIAEgACgCHDYCHCABIAAoAiA2AiAgASAAKAIkNgIkIAEgACgCKDYCKCABIAAoAgw2AgwgASAAKAIQNgIQIAEgACgCFDYCFCABIAAoAhg2AhggASAAKAIsNgIsIAEgACgCRDYCNEGxgAELGAAgAEIANwIIIABCgICAgICAgMA/NwIACwYAQayAAQu6AgIBfwd9IwBB4ABrIgMkACADQgA3AiwgA0IANwM4IANBgICA/AM2AjQgA0IANwJMIANBgICA/AM2AkggA0IANwJUIANBADYCXCADQgA3AiQgA0GAgID8AzYCICADQgA3A0AgACADQSBqIANBEGogAyAAKAIAKAIIEQQAIAMqAhghByADKgIIIQggAyoCECEFIAMqAgAhBiADKgIUIQkgAyoCBCEKIAAgACgCACgCMBEGACEEIAJBADYCDCACIAFDqqqqPZQiASAEIAYgBZNDAAAAP5SSIgUgBZIiBSAFlCIFIAQgCiAJk0MAAAA/lJIiBiAGkiIGIAaUIgaSlDgCCCACIAEgBSAEIAggB5NDAAAAP5SSIgQgBJIiBCAElCIEkpQ4AgQgAiABIAYgBJKUOAIAIANB4ABqJAALkgECAn8CfSAAIAAqAjwgASAAKAJEQQJ0IgJqKgIAIAIgAEEMaiICaioCAJWUIgU4AjwgACAAKgI4IAEgACgCQEECdCIDaioCACACIANqKgIAlSABIAAoAkhBAnQiA2oqAgAgAiADaioCAJWSQwAAAD+UlCIEOAI4IAAgBCAFIAWUIAQgBJSSkZU4AjQgACABENsBC80BAQR9IAAgASACELsCIAEgASgCACgCMBEGAEMAAAAAXARAIAIqAgQhBCACKgIAIQMgAioCCCEFIAEgASgCACgCMBEGACEGIAAgACoCACAGQwAAgL8gAyADIAOUIAQgBJSSIAUgBZSSQwAAgChdIgEbIgNDAACAP0MAAIC/IAUgARsiBSAFlCADIAOUQwAAgL8gBCABGyIEIASUkpKRlSIDlJSSOAIAIAAgACoCBCAGIAQgA5SUkjgCBCAAIAAqAgggBiAFIAOUlJI4AggLC1UBA38jAEEQayIEJAAgA0EBTgRAA0AgBCAAIAEgBUEEdCIGahC7AiACIAZqIgYgBCkDCDcCCCAGIAQpAwA3AgAgBUEBaiIFIANHDQALCyAEQRBqJAALCwAgACABIAIQuwILlQEAIABCIzcCBCAAQaSQATYCACAAQYquj+kDNgIsIABCgICA/AM3AhQgAEKAgID8g4CAwD83AgwgAEGkkQE2AgAgACACOAI8IAAgATgCOCAAQQs2AgQgAEECNgJIIABCATcCQCAAQfz+ADYCACAAIAE4AiAgACABOAIkIAAgAjgCHCAAIAEgASABlCACIAKUkpGVOAI0C5kBACAAQiM3AgQgAEGkkAE2AgAgAEGKro/pAzYCLCAAQoCAgPwDNwIUIABCgICA/IOAgMA/NwIMIABBpJEBNgIAIAAgAjgCPCAAIAE4AjggAEELNgIEIABBATYCSCAAQoCAgIAgNwJAIABBmP4ANgIAIAAgAjgCJCAAIAE4AhwgACABOAIgIAAgASABIAGUIAIgApSSkZU4AjQLmQEAIABCIzcCBCAAQaSQATYCACAAQYquj+kDNgIsIABCgICA/AM3AhQgAEKAgID8g4CAwD83AgwgAEGkkQE2AgAgACACOAI8IAAgATgCOCAAQbT9ADYCACAAQQI2AkggAEKAgICAEDcCQCAAQQs2AgQgACABOAIkIAAgAjgCICAAIAE4AhwgACABIAEgAZQgAiAClJKRlTgCNAsEAEEYCwcAIAAqAkgLCQAgACABOAJICwYAQaD9AAsIACAAQcwAaguGBAEGfyAAIAEgAhA9GiABIAAoAkg2AhQgACgCECEDIAFBADYCDCABIAM2AhAgAwRAIAEgAiACQcwAIAMgAigCACgCEBEHACIHKAIIIgMgAigCACgCHBEDADYCDCABKAIQQQBKBEADQCADIAZB0ABsIgQgACgCGGoiBSgCSDYCSCADIAIgBSgCQCACKAIAKAIcEQMANgJAIAIgACgCGCAEaigCQCACKAIAKAIYEQMARQRAIAIgAiAAKAIYIARqKAJAIgUgBSgCACgCNBEBAEEBIAIoAgAoAhARBwAiBSAAKAIYIARqKAJAIgggBSgCCCACIAgoAgAoAjgRBwBB05CFggUgACgCGCAEaigCQCACKAIAKAIUEQkACyADIAAoAhggBGoiBCgCRDYCRCADIAQoAgA2AgAgAyAEKAIENgIEIAMgBCgCCDYCCCADIAQoAgw2AgwgAyAEKAIQNgIQIAMgBCgCFDYCFCADIAQoAhg2AhggAyAEKAIcNgIcIAMgBCgCIDYCICADIAQoAiQ2AiQgAyAEKAIoNgIoIAMgBCgCLDYCLCADIAQoAjA2AjAgAyAEKAI0NgI0IAMgBCgCODYCOCADIAQoAjw2AjwgA0HMAGohAyAGQQFqIgYgASgCEEgNAAsLIAIgB0HU/ABBwaSFygUgBygCCCACKAIAKAIUEQkAC0Ht/AALgQUCBX8GfSMAQZABayICJAAgACgCEEEBTgRAIAJBQGshBANAIAIgBkHQAGwiBSAAKAIYaiIDKQIINwMYIAIgAykCADcDECACIAMpAhg3AiggAiADKQIQNwIgIAIgAykCKDcCOCACIAMpAiA3AjAgBCADKQI4NwIIIAQgAykCMDcCACACIAMoAkAiAyADKAIAKAIcEQEAIgMoAgg2AgggAiADKQIANwMAIAAqAlAhByABKgIEIQggACoCTCEJIAEqAgAhCiACIAIqAgggASoCCJQgACoCVJU4AgggAkEANgIMIAIgCiACKgIAlCAJlTgCACACIAggAioCBJQgB5U4AgQgACgCGCAFaigCQCIDIAIgAygCACgCGBECACAAKgJMIQcgASoCACEIIAAqAlAhCSABKgIEIQogACoCVCELIAEqAgghDCACQQA2AkwgAiAMIAIqAkiUIAuVOAJIIAIgCiACKgJElCAJlTgCRCACIAggAioCQJQgB5U4AkAgACgCGCAFaiIDIAIpAxA3AgAgAyACKQMYNwIIIAMgAikCKDcCGCADIAIpAiA3AhAgAyACKQI4NwIoIAMgAikCMDcCICADIAQpAgg3AjggAyAEKQIANwIwIAAoAkAEQCAAKAIYIAVqKAJAIgMgAkEQaiACQYABaiACQfAAaiADKAIAKAIIEQQAIAIgAikDiAE3A1ggAiACKQOAATcDUCACIAIpA3g3AmggAiACKQNwNwJgIAAoAkAgACgCGCAFaigCTCACQdAAahCkAQsgBkEBaiIGIAAoAhBIDQALCyAAIAEpAgA3AkwgACABKQIINwJUIAAgACgCACgCRBEAACACQZABaiQAC4sCAgF/BH0jAEHgAGsiAyQAIANCADcCLCADQgA3AzggA0GAgID8AzYCNCADQgA3AkwgA0GAgID8AzYCSCADQgA3AlQgA0EANgJcIANCADcCJCADQYCAgPwDNgIgIANCADcDQCAAIANBIGogA0EQaiADIAAoAgAoAggRBAAgAyoCGCEEIAMqAgghByACIAFDAABAQZUiASADKgIAIAMqAhCTQwAAAD+UIgUgBZIiBSAFlCIFIAMqAgQgAyoCFJNDAAAAP5QiBiAGkiIGIAaUIgaSlDgCCCACIAEgBSAHIASTQwAAAD+UIgQgBJIiBCAElCIEkpQ4AgQgAiABIAYgBJKUOAIAIANB4ABqJAAL9QMCAX8YfSAAKgIoIQUgACoCOCEIIAAoAhAhBCAAKgIkIQYgACoCNCEJIAAqAiAhByAAKgIwIQogACAAKAIAKAIwEQYAIRcgACAAKAIAKAIwEQYAIRggACAAKAIAKAIwEQYAIRkgASoCNCEaIAEqAhghCyABKgIUIQ0gASoCOCEMIAEqAighDiABKgIkIQ8gASoCMCEbIAEqAgghECABKgIAIREgASoCBCESIAEqAhAhEyABKgIgIRQgAkEANgIMIAIgDCAUIAogB5JDAAAAP5RDAAAAACAEGyIMlCAPIAkgBpJDAAAAP5RDAAAAACAEGyIVlJIgDiAIIAWSQwAAAD+UQwAAAAAgBBsiFpSSkiIcIBcgCiAHk0MAAAA/lEMAAAAAIAQbkiIHIBSLlCAYIAkgBpNDAAAAP5RDAAAAACAEG5IiBiAPi5SSIBkgCCAFk0MAAAA/lEMAAAAAIAQbkiIFIA6LlJIiCJM4AgggAiAaIAwgE5QgFSANlJIgFiALlJKSIgkgByATi5QgBiANi5SSIAUgC4uUkiIKkzgCBCACIBsgDCARlCAVIBKUkiAWIBCUkpIiCyAHIBGLlCAGIBKLlJIgBSAQi5SSIgWTOAIAIANBADYCDCADIAggHJI4AgggAyAKIAmSOAIEIAMgBSALkjgCAAuxAgIEfwF9IwBBIGsiASQAIABC65b46r3tgq9dNwIwIABC65b46rXtgq/dADcCICAAQuuW+OoNNwI4IABC65b46gU3AiggACgCEEEBTgRAA0AgACgCGCACQdAAbGoiAygCQCIEIAMgAUEQaiABIAQoAgAoAggRBAAgACoCICABKgIQIgVeQQFzRQRAIAAgBTgCIAsgACoCMCABKgIAIgVdQQFzRQRAIAAgBTgCMAsgACoCJCABKgIUIgVeQQFzRQRAIAAgBTgCJAsgACoCNCABKgIEIgVdQQFzRQRAIAAgBTgCNAsgACoCKCABKgIYIgVeQQFzRQRAIAAgBTgCKAsgACoCOCABKgIIIgVdQQFzRQRAIAAgBTgCOAsgAkEBaiICIAAoAhBIDQALCyABQSBqJAALXgEDfyAAIAAoAkRBAWo2AkQgACgCECICQQFOBEADQCABIAAoAhggAkF/aiIDQdAAbGooAkBGBEAgACADEJ0ECyACQQFKIQQgAyECIAQNAAsLIAAgACgCACgCRBEAAAu9AwEGfwJAIAAoAgQiBCAAKAIIRw0AIAQgBEEBdEEBIAQbIgVODQACfyAFBEBB6PcBQej3ASgCAEEBajYCACAFQdAAbEEQQYzSASgCABEDACEGIAAoAgQhBAsgBEEBTgsEQANAIAYgB0HQAGwiA2oiAiAAKAIMIANqIgMpAgA3AgAgAiADKQIINwIIIAIgAykCGDcCGCACIAMpAhA3AhAgAiADKQIoNwIoIAIgAykCIDcCICACIAMpAjg3AjggAiADKQIwNwIwIAIgAykCQDcCQCACIAMpAkg3AkggB0EBaiIHIARHDQALCyAAKAIMIgIEQCAALQAQBEAgAgRAQez3AUHs9wEoAgBBAWo2AgAgAkGQ0gEoAgARAAALCyAAQQA2AgwLIAAgBjYCDCAAQQE6ABAgACAFNgIIIAAoAgQhBAsgACgCDCAEQdAAbGoiAiABKQIANwIAIAIgASkCCDcCCCACIAEpAhg3AhggAiABKQIQNwIQIAIgASkCKDcCKCACIAEpAiA3AiAgAiABKQI4NwI4IAIgASkCMDcCMCACIAEpAkg3AkggAiABKQJANwJAIAAgACgCBEEBajYCBAuwAwMBfwF+AX0jAEGQAWsiAyQAIAAgACgCREEBajYCRCADQQA2AowBIAMgASkCCDcDSCADIAEpAgA3A0AgAyABKQIYNwNYIAMgASkCEDcDUCADIAEpAig3A2ggAyABKQIgNwNgIAMgASkCODcDeCABKQIwIQQgAyACNgKAASADIAQ3A3AgAyACKAIENgKEASADIAIgAigCACgCMBEGADgCiAEgAiABIANBMGogA0EgaiACKAIAKAIIEQQAIAAqAiAgAyoCMCIFXkEBc0UEQCAAIAU4AiALIAAqAjAgAyoCICIFXUEBc0UEQCAAIAU4AjALIAAqAiQgAyoCNCIFXgRAIAAgBTgCJAsgACoCNCADKgIkIgVdQQFzRQRAIAAgBTgCNAsgACoCKCADKgI4IgVeQQFzRQRAIAAgBTgCKAsgACoCOCADKgIoIgVdQQFzRQRAIAAgBTgCOAsgACgCQCIBBEAgAyADKQM4NwMIIAMgAykDKDcDGCADIAMpAyA3AxAgAyADKQMwNwMAIAMgASADIAAoAhAQQjYCjAELIABBDGogA0FAaxC5DCADQZABaiQAC7QBAQF/IABBjPwANgIAIAAoAkAiAQRAIAEQQyAAKAJAIgEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgACgCGCIBBEAgAC0AHARAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgIYCyAAQQA2AhggAEIANwIQIABBAToAHCAABEBB7PcBQez3ASgCAEEBajYCACAAQZDSASgCABEAAAsLlAEBAX8gAEGM/AA2AgAgACgCQCIBBEAgARBDIAAoAkAiAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAKAIYIgEEQCAALQAcBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AhgLIABBADYCGCAAQgA3AhAgAEEBOgAcIAALoQsBCH8jAEHwCGsiASQAQSohBSAAKAIsIgMgAygCACgCVBEBACICQQFOBEBBACEDA0AgACgCLCIEIAMgAUGQAWogBCgCACgCWBEFABChBCAFQQR0IgRB6O0BaiABKQOYATcCACAEQeDtAWogASkDkAE3AgAgBUEBaiEFIANBAWoiAyACRw0ACwtBACEDA0AgACgCLCECEKEEIAFBEGogAiADQQR0IgRB4O0BaiACKAIAKAJAEQUAIAFBkAFqIARqIgIgASkDGDcCCCACIAEpAxA3AgAgA0EBaiIDIAVHDQALIAFCgKCAgICABDcChAEgAUKQgICA8M3EwTo3AnwgASAFNgJ0IAFBATYCcCABIAFBkAFqNgJ4IAFBAToAbEEAIQIgAUEANgJoIAFCADcDYCABQQA2AlQgAUEBOgBYIAFCADcCTCABQQA2AiQgAUEBOgAoIAFBAToARCABQgA3AhwgAUFAa0EANgIAIAFCADcDOCABQgA3AiwgAUEANgIUIAFBAToAECABQcgAaiABQfAAaiABQRBqEOIDQQFHBEAgASgCFCIEIQIgACgCBCIDIARIBEAgACgCCCAESARAAn8gBEUEQEEAIQUgAwwBC0Ho9wFB6PcBKAIAQQFqNgIAIARBBHRBEEGM0gEoAgARAwAhBSAAKAIECyIHQQFOBEBBACECA0AgBSACQQR0IgZqIgggACgCDCAGaiIGKQIANwIAIAggBikCCDcCCCACQQFqIgIgB0cNAAsLIAAoAgwiAgRAIAAtABAEQCACBEBB7PcBQez3ASgCAEEBajYCACACQZDSASgCABEAAAsLIABBADYCDAsgACAFNgIMIABBAToAECAAIAQ2AggLA0AgACgCDCADQQR0aiICIAEpAgA3AgAgAiABKQIINwIIIANBAWoiAyAERw0ACyABKAIUIQILIAAgBDYCBCACQQFOBEBBACEDA0AgA0EEdCICIAAoAgxqIgQgASgCJCACaiICKQIANwIAIAQgAikCCDcCCCADQQFqIgMgASgCFEgNAAsLIAAgASgCMCIENgIoIAQiAyAAKAIYIgdKBEACQCAAKAIcIAROBEAgACgCICEFDAELQQAhAyAHIQJBACEFIAQEQEHo9wFB6PcBKAIAQQFqNgIAIARBAnRBEEGM0gEoAgARAwAhBSAAKAIYIQILIAAoAiAhBgJAIAJBAU4EQANAIAUgA0ECdCIIaiAGIAhqKAIANgIAIANBAWoiAyACRw0ADAIACwALIAYNACAAIAU2AiAgACAENgIcIABBAToAJAwBCyAALQAkBEAgBgRAQez3AUHs9wEoAgBBAWo2AgAgBkGQ0gEoAgARAAALCyAAIAU2AiAgAEEBOgAkIAAgBDYCHAsgBSAHQQJ0akEAIAQgB2tBAnQQCxogACgCKCEDCyAAIAQ2AhhBASECIANBAU4EQCAAKAIgIQRBACEDIAEoAkAhBwNAIAQgA0ECdCIGaiAGIAdqKAIANgIAIANBAWoiAyAAKAIoSA0ACwsgAUEQahDhAwsgASgCQCIABEAgAS0ARARAIAAEQEHs9wFB7PcBKAIAQQFqNgIAIABBkNIBKAIAEQAACwsgAUEANgJACyABQQA2AkAgAUEBOgBEIAFCADcDOCABKAIkIgAEQCABLQAoBEAgAARAQez3AUHs9wEoAgBBAWo2AgAgAEGQ0gEoAgARAAALCyABQQA2AiQLIAEoAmgiAARAIAEtAGwEQCAABEBB7PcBQez3ASgCAEEBajYCACAAQZDSASgCABEAAAsLIAFBADYCaAsgAUEANgJoIAFBAToAbCABQgA3A2AgASgCVCIABEAgAS0AWARAIAAEQEHs9wFB7PcBKAIAQQFqNgIAIABBkNIBKAIAEQAACwsgAUEANgJUCyABQfAIaiQAIAIL9gIBAn8gACgCICIBBEAgAC0AJARAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgIgCyAAQQA2AiAgAEIANwIYIABBAToAJEEAIQEgACgCDCICBEAgAC0AEARAIAIEQEHs9wFB7PcBKAIAQQFqNgIAIAJBkNIBKAIAEQAACyAAKAIgIQELIABBADYCDAsgAEEANgIMIABBAToAECAAQgA3AgQCQCABRQRAIABBADYCICAAQQE6ACQgAEIANwIYDAELIAAtACRFBEAgAEEANgIgIABBAToAJCAAQgA3AhgMAQsgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALIABBAToAJCAAQQA2AiAgAEIANwIYIAAoAgwiAUUNACAALQAQBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AgwLIABBADYCDCAAQQE6ABAgAEIANwIECzoAIABBAToAECAAIAE2AiwgAEEANgIMIABCADcCBCAAQQA2AiggAEEBOgAkIABBADYCICAAQgA3AhgLvgwDCH8Bfhh9IwBB8AFrIgMkACAAIAAoAgRBAWo2AgQgAigCJCIEQdAAbCIIIAAoAgwiCSgCBCIKQRhqKAIAaigCQCEFIAAoAggiAigCBCgCGCABKAIkIgZB0ABsaiIBKAJAIQcgAigCDCICKgI0ISEgAioCOCEiIAIqAhghDCACKgIUIQ0gAioCKCEOIAIqAiQhDyACKgIwISMgAioCCCEQIAIqAgAhESACKgIEIRIgAioCECETIAIqAiAhFCABKgIgIRUgASoCACEWIAEqAhAhFyABKgI4IRggASoCMCEZIAEqAjQhGiABKgIkIRsgASoCBCEcIAEqAhQhHSABKgIoIR4gASoCCCEfIAEqAhghIEEAIQIgA0EANgLsASADQQA2AtwBIANBADYCzAEgAyAUIB+UIA8gIJSSIA4gHpSSOALYASADIBQgHJQgDyAdlJIgDiAblJI4AtQBIAMgEyAflCANICCUkiAMIB6UkjgCyAEgAyATIByUIA0gHZSSIAwgG5SSOALEASADICIgFCAZlCAPIBqUkiAOIBiUkpI4AugBIAMgISATIBmUIA0gGpSSIAwgGJSSkjgC5AEgA0EANgK8ASADIBQgFpQgDyAXlJIgDiAVlJI4AtABIAMgEyAWlCANIBeUkiAMIBWUkjgCwAEgAyARIB+UIBIgIJSSIBAgHpSSOAK4ASADIBEgHJQgEiAdlJIgECAblJI4ArQBIAMgESAWlCASIBeUkiAQIBWUkjgCsAEgAyAjIBEgGZQgEiAalJIgECAYlJKSOALgASAJKAIMIgEqAjQhISABKgI4ISIgASoCGCEMIAEqAhQhDSABKgIoIQ4gASoCJCEPIAEqAjAhIyABKgIIIRAgASoCACERIAEqAgQhEiABKgIQIRMgASoCICEUIAooAhggCGoiASoCICEVIAEqAgAhFiABKgIQIRcgASoCOCEYIAEqAjAhGSABKgI0IRogASoCJCEbIAEqAgQhHCABKgIUIR0gASoCKCEeIAEqAgghHyABKgIYISAgA0EANgKsASADQQA2ApwBIANBADYCjAEgAyAUIB+UIA8gIJSSIA4gHpSSOAKYASADIBQgHJQgDyAdlJIgDiAblJI4ApQBIAMgEyAflCANICCUkiAMIB6UkjgCiAEgAyATIByUIA0gHZSSIAwgG5SSOAKEASADICIgFCAZlCAPIBqUkiAOIBiUkpI4AqgBIAMgISATIBmUIA0gGpSSIAwgGJSSkjgCpAEgA0EANgJ8IAMgFCAWlCAPIBeUkiAOIBWUkjgCkAEgAyATIBaUIA0gF5SSIAwgFZSSOAKAASADIBEgH5QgEiAglJIgECAelJI4AnggAyARIByUIBIgHZSSIBAgG5SSOAJ0IAMgESAWlCASIBeUkiAQIBWUkjgCcCADICMgESAZlCASIBqUkiAQIBiUkpI4AqABIAcgA0GwAWogA0HgAGogA0HQAGogBygCACgCCBEEACAFIANB8ABqIANBQGsgA0EwaiAFKAIAKAIIEQQAAkBB3O0BKAIAIgEEQCAHIAUgAREDAEUNAQsCQCADKgJgIAMqAjBeDQAgAyoCUCADKgJAXQ0AQQEhAgtBACEBAkAgAyoCaCADKgI4Xg0AIAMqAlggAyoCSF0NACACIQELIAMqAmQgAyoCNF4NACADKgJUIAMqAkRdDQAgAUEBcw0AIAAoAggiASgCCCECIAMgBjYCLCADQX82AiggAyACNgIgIAMgBzYCHCADIAE2AhggAyADQbABajYCJCAAKAIMIgEoAgghAiADIAQ2AhQgA0F/NgIQIAMgAjYCCCADIAU2AgQgAyABNgIAIAMgA0HwAGo2AgwCQCAAKAIcIAYgBBDJDCIBBEAgASgCCCECDAELIAAoAhAiASADQRhqIAMgACgCICABKAIAKAIIEQoAIQIgACgCHCIBIAYgBCABKAIAKAIMEQcAIAI2AggLIAAoAhgiASkCCCELIAEgAzYCDCABIANBGGo2AgggAUF/IAYgASgCACgCCBEFACAAKAIYIgFBfyAEIAEoAgAoAgwRBQAgAiADQRhqIAMgACgCFCAAKAIYIAIoAgAoAggRCQAgACgCGCALNwIICyADQfABaiQACwcAQwAAAAALpB4CDH8ffSMAQbABayIFJAAgASgCBCIPKAJEIAAoAihGQQAgAigCBCIQKAJEIAAoAixGG0UEQCAAKAIIIgkoAggiB0EBTgR/A0AgCSgCECAIQQxsaigCCCIKBEAgCiAKKAIAKAIAEQEAGiAAKAIEIgYgCiAGKAIAKAI8EQIACyAIQQFqIgggB0cNAAsgACgCCAUgCQsQpAQLIAVBADYCFCAFQgA3AgwgBUEBOgAYAkAgACgCCCIJKAIIIgpBAUgNAANAIAkoAhAgDUEMbGooAggiBgRAIAYgBUEIaiAGKAIAKAIQEQIAQQAhCiAFKAIMIghBAEoEQANAIAUoAhQgCkECdGooAgAiBigC7AUEQCAEIAY2AgQgBiAGKALkBSIGIAQoAgwoAggiCCAGIAQoAggoAggiB0YiBhtBBGogCCAHIAYbQQRqEB8gBEEANgIEIAUoAgwhCAsgCkEBaiIKIAhIDQALCyAIQX9MBEAgBSgCEEF/TARAIAUoAhQiBgRAIAUtABgEQCAGBEBB7PcBQez3ASgCAEEBajYCACAGQZDSASgCABEAAAsLIAVBADYCFAsgBUEBOgAYIAVCADcDEAsDQCAFKAIUIAhBAnRqQQA2AgAgCEEBaiIGIAhPIQcgBiEIIAcNAAsLIAVBADYCDCAJKAIIIQoLIA1BAWoiDSAKSA0ACyAFKAIUIgZFDQAgBS0AGARAIAYEQEHs9wFB7PcBKAIAQQFqNgIAIAZBkNIBKAIAEQAACwsgBUEANgIUCyAPKAJAIQkgECgCQCEIIAAoAgQhByAAKAIIIQYgBSAAKAIgNgKoASAFIAY2AqQBIAUgBDYCoAEgBSADNgKcASAFIAc2ApgBIAVBADYCjAEgBUG4+wA2AogBIAUgATYCkAEgBSACNgKUAQJAIAkoAgAiBEUNACAIKAIAIgNFDQAgASgCDCIHKgIYIhQgByoCNIwiEZQgByoCCCIVIAcqAjAiE5STIAcqAigiFiAHKgI4IhiUkyAVIAIoAgwiBioCMCIZlCAUIAYqAjQiF5SSIBYgBioCOCISlJKSISwgByoCFCIaIBGUIAcqAgQiGyATlJMgByoCJCIcIBiUkyAbIBmUIBogF5SSIBwgEpSSkiEtIAYqAighHSAGKgIYIR4gBioCCCEfIAYqAiQhICAGKgIUISEgBioCBCEiIAcqAhAiKSARlCAHKgIAIhEgE5STIAcqAiAiEyAYlJMgESAZlCApIBeUkiATIBKUkpIhLiAGKgIQIRkgBioCACEXIAYqAiAhEkHo9wFB6PcBKAIAQQFqNgIAQYAIQRBBjNIBKAIAEQMAIgYgAzYCBCAGIAQ2AgAgFSAflCAUIB6UkiAWIB2UkiIviyEjIBUgIpQgFCAhlJIgFiAglJIiJIshJSAVIBeUIBQgGZSSIBYgEpSSIiaLIScgGyAflCAaIB6UkiAcIB2UkiIoiyEUIBsgIpQgGiAhlJIgHCAglJIiFYshFiAbIBeUIBogGZSSIBwgEpSSIhqLIRsgESAflCApIB6UkiATIB2UkiIciyEdIBEgIpQgKSAhlJIgEyAglJIiHoshHyARIBeUICkgGZSSIBMgEpSSIiCLISFB/AAhDUGAASEHQYABIQhBASEKA0ACQAJ/AkACQCAGIApBf2oiCUEDdCIOaiIDKAIAIgsqAgAgISADKAIEIgwqAhAiIiAMKgIAIhGTQwAAAD+UQwAAAACSIiqUIB8gDCoCFCITIAwqAgQiGJNDAAAAP5RDAAAAAJIiK5SSIB0gDCoCGCIZIAwqAggiEpNDAAAAP5RDAAAAAJIiKZSSIhcgLiAgICIgEZJDAAAAP5QiEZQgHiATIBiSQwAAAD+UIhiUkiAcIBkgEpJDAAAAP5QiGZSSkiISkl9BAXMNACALKgIQIBIgF5NgQQFzDQAgCyoCBCAbICqUIBYgK5SSIBQgKZSSIhcgLSAaIBGUIBUgGJSSICggGZSSkiISkl9BAXMNACALKgIUIBIgF5NgQQFzDQAgCyoCCCAnICqUICUgK5SSICMgKZSSIhcgLCAmIBGUICQgGJSSIC8gGZSSkiISkl9BAXMNACALKgIYIBIgF5NgQQFzDQACQCAJIA1MBEAgByEEIAYhAwwBCwJAIAcgB0EBdCIETgRAIAYhAwwBCyAIIAROBEAgBiEDDAELAkACQCAHRQRAQQAhAwwBC0EAIQ1B6PcBQej3ASgCAEEBajYCACAHQQR0QRBBjNIBKAIAEQMAIQMgB0EBSA0AA0AgAyANQQN0IghqIAYgCGopAgA3AgAgDUEBaiINIAdHDQALDAELIAQhCCAGRQ0BCyAGBEBB7PcBQez3ASgCAEEBajYCACAGQZDSASgCABEAAAsgBCEICyAEQXxqIQ0LIAwoAighBiALKAIoBEAgCygCJCEHIAYEQCADIA5qIgYgDCgCJDYCBCAGIAc2AgAgCygCKCEGIAMgCkEDdGoiByAMKAIkNgIEIAcgBjYCACALKAIkIQYgByAMKAIoNgIMIAcgBjYCCCALKAIoIQYgByAMKAIoNgIUIAcgBjYCECAKQQNqDAQLIAMgDmoiBiAMNgIEIAYgBzYCACALKAIoIQcgAyAKQQN0aiIGIAw2AgQgBiAHNgIADAILIAYEQCADIA5qIgYgDCgCJDYCBCAGIAs2AgAgAyAKQQN0aiIGIAwoAig2AgQgBiALNgIADAILIAVBiAFqIAsgDCAFKAKIASgCCBEFACAEIQcgAyEGCyAJIQoMAgsgCkEBagshCiAEIQcgAyEGCyAKDQALIAZFDQAgBgRAQez3AUHs9wEoAgBBAWo2AgAgBkGQ0gEoAgARAAALCyAAKAIIIgsoAghBAU4EQEEAIQ4DQAJAIA5BDGwiBCALKAIQaiIDKAIIIgZFDQAgDygCGCADKAIAQdAAbGoiCCgCQCEDIAEoAgwiByoCNCEZIAcqAjghFyAIKgIwIRogCCoCNCEbIAgqAjghHCAIKgIEIR0gCCoCFCEeIAgqAiQhHyAIKgIIISAgCCoCGCEhIAgqAighIiAHKgIUISMgByoCGCEkIAgqAgAhESAHKgIkISUgCCoCECETIAcqAighJiAIKgIgIRggByoCMCESIAcqAgghJyAHKgIAISggByoCBCEUIAcqAhAhFSAHKgIgIRZBACEHIAVBADYCRCAFQQA2AjQgBUEANgIkIAVBADYCFCAFIBYgEZQgJSATlJIgJiAYlJI4AiggBSAVIBGUICMgE5SSICQgGJSSOAIYIAUgKCARlCAUIBOUkiAnIBiUkjgCCCAFIBYgIJQgJSAhlJIgJiAilJI4AjAgBSAWIB2UICUgHpSSICYgH5SSOAIsIAUgFSAglCAjICGUkiAkICKUkjgCICAFIBUgHZQgIyAelJIgJCAflJI4AhwgBSAoICCUIBQgIZSSICcgIpSSOAIQIAUgKCAdlCAUIB6UkiAnIB+UkjgCDCAFIBcgFiAalCAlIBuUkiAmIByUkpI4AkAgBSAZIBUgGpQgIyAblJIgJCAclJKSOAI8IAUgEiAoIBqUIBQgG5SSICcgHJSSkjgCOCADIAVBCGogBUH4AGogBUHoAGogAygCACgCCBEEACAQKAIYIAsoAhAgBGooAgRB0ABsaiIJKAJAIQMgAigCDCIIKgI0IRkgCCoCOCEXIAkqAjAhGiAJKgI0IRsgCSoCOCEcIAkqAgQhHSAJKgIUIR4gCSoCJCEfIAkqAgghICAJKgIYISEgCSoCKCEiIAgqAhQhIyAIKgIYISQgCSoCACERIAgqAiQhJSAJKgIQIRMgCCoCKCEmIAkqAiAhGCAIKgIwIRIgCCoCCCEnIAgqAgAhKCAIKgIEIRQgCCoCECEVIAgqAiAhFiAFQQA2AkQgBUEANgI0IAVBADYCJCAFQQA2AhQgBSAWIBGUICUgE5SSICYgGJSSOAIoIAUgFSARlCAjIBOUkiAkIBiUkjgCGCAFICggEZQgFCATlJIgJyAYlJI4AgggBSAWICCUICUgIZSSICYgIpSSOAIwIAUgFiAdlCAlIB6UkiAmIB+UkjgCLCAFIBUgIJQgIyAhlJIgJCAilJI4AiAgBSAVIB2UICMgHpSSICQgH5SSOAIcIAUgKCAglCAUICGUkiAnICKUkjgCECAFICggHZQgFCAelJIgJyAflJI4AgwgBSAXIBYgGpQgJSAblJIgJiAclJKSOAJAIAUgGSAVIBqUICMgG5SSICQgHJSSkjgCPCAFIBIgKCAalCAUIBuUkiAnIByUkpI4AjggAyAFQQhqIAVB2ABqIAVByABqIAMoAgAoAggRBAACf0EAIAUqAnggBSoCSF4NABpBACAFKgJoIAUqAlhdDQAaQQELIQMCQCAFKgKAASAFKgJQXg0AIAUqAnAgBSoCYF0NACADIQcLAkAgBSoCfCAFKgJMXg0AIAUqAmwgBSoCXF0NACAHQQFzRQ0BCyAGIAYoAgAoAgARAQAaIAAoAgQiAyAGIAMoAgAoAjwRAgAgCygCECAEaiIDKAIEIQkgAygCACEHAkAgACgCECIEIAAoAhRHDQAgBCAEQQF0QQEgBBsiCk4NAEEAIQhBACENAn8gCgRAQej3AUHo9wEoAgBBAWo2AgAgCkEMbEEQQYzSASgCABEDACENIAAoAhAhBAsgBEEBTgsEQANAIA0gCEEMbCIDaiIGIAAoAhggA2oiAykCADcCACAGIAMoAgg2AgggCEEBaiIIIARHDQALCyAAKAIYIgMEQCAALQAcBEAgAwRAQez3AUHs9wEoAgBBAWo2AgAgA0GQ0gEoAgARAAALCyAAQQA2AhgLIAAgDTYCGCAAQQE6ABwgACAKNgIUIAAoAhAhBAsgACgCGCAEQQxsaiIDQQA2AgggAyAJNgIEIAMgBzYCACAAIAAoAhBBAWo2AhALIA5BAWoiDiALKAIISA0ACwsgACgCEEEBTgRAQQAhCANAIAAoAggiAiAAKAIYIAhBDGxqIgEoAgAgASgCBCACKAIAKAIIEQcAGiAIQQFqIgggACgCEEgNAAsLIAAoAhgiAQRAIAAtABwEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYCGAsgAEEANgIYIABCADcCECAAQQE6ABwgBUGwAWokAAtSAQN/IAAoAggiAygCCCICQQFOBEBBACEAA0AgAygCECAAQQxsaigCCCIEBEAgBCABIAQoAgAoAhARAgAgAygCCCECCyAAQQFqIgAgAkgNAAsLCwkAIAAQogQQDguaAQAgAEGEswE2AgAgACABKAIANgIEIABB/NIANgIAIABBAToAHCAAQej6ADYCACAAQQA2AhggAEIANwIQIAEoAgQhASAAQQA6ACQgACABNgIgAn9B6PcBQej3ASgCAEEBajYCAEHEAEEQQYzSASgCABEDACIBCxDLDCAAIAE2AgggACACKAIEKAJENgIoIAAgAygCBCgCRDYCLAscAEHU7QFB1O0BKAIAQQFqNgIAIAAgASACEMgMC7cEAQl/QdDtAUHQ7QEoAgBBAWo2AgACQCAAKAIoIgggACgCDEF/aiACQRB0IAFyIgMgA0EPdEF/c2oiA0EKdSADc0EJbCIDQQZ1IANzIgMgA0ELdEF/c2oiA0EQdSADc3FBAnRqIgkoAgAiA0F/Rg0AIAAoAhAhBSADIQQDQCABIAUgBEEMbGoiCigCAEZBACAKKAIEIAJGG0UEQCAAKAI8IARBAnRqKAIAIgRBf0cNAQwCCwsgBSAEQQxsaigCCCEHIAAoAjwhBgJAIAkCfyADIARHBEADQCAGIAMiAUECdGoiAigCACIDIARHDQALIAYgBEECdGooAgAiAyABQX9GDQEaIAIgAzYCAAwCCyAGIARBAnRqKAIACzYCAAsgBCAAKAIIQX9qIgFGBEAgACAENgIIIAcPCwJAAkAgASAIIAAoAgxBf2ogBSABQQxsaiIFKAIEQRB0IAUoAgByIgIgAkEPdEF/c2oiAkEKdSACc0EJbCICQQZ1IAJzIgIgAkELdEF/c2oiAkEQdSACc3EiCUECdGoiCCgCACIDRgRAIAYgAUECdGooAgAhAQwBCwNAIAYgAyICQQJ0aiILKAIAIgMgAUcNAAsgBiABQQJ0aigCACEBIAJBf0YNACALIAE2AgAMAQsgCCABNgIACyAKIAUpAgA3AgAgCiAFKAIINgIIIAAoAjwgBEECdGogACgCKCAJQQJ0aiIBKAIANgIAIAEgBDYCACAAIAAoAghBf2o2AggLIAcLhAQBCH8CQCAAKAIoIAJBEHQgAXIiAyADQQ90QX9zaiIDQQp1IANzQQlsIgNBBnUgA3MiAyADQQt0QX9zaiIDQRB1IANzIgkgACgCDCIDQX9qcSIGQQJ0aigCACIEQX9HBEAgACgCECEHA0AgASAHIARBDGxqIgUoAgBGQQAgBSgCBCACRhsNAiAAKAI8IARBAnRqKAIAIgRBf0cNAAsLIAAoAggiByEEAkACQCAAIAMgB0YEfyADIANBAXRBASADGyIFSA0BIAMFIAQLQQFqNgIIIAAoAhAhCAwBCwJ/IAUEQEHo9wFB6PcBKAIAQQFqNgIAIAVBDGxBEEGM0gEoAgARAwAhCCAAKAIIIQMLIANBAU4LBEBBACEEA0AgCCAEQQxsIgZqIgogACgCECAGaiIGKQIANwIAIAogBigCCDYCCCAEQQFqIgQgA0cNAAsLIAAoAhAiAwRAIAAtABQEQCADBEBB7PcBQez3ASgCAEEBajYCACADQZDSASgCABEAAAsLIABBADYCEAsgACAINgIQIAAgBTYCDCAAQQE6ABQgACAAKAIIQQFqNgIIIAAQvQIgACgCDEF/aiAJcSEGCyAIIAdBDGxqIgVBADYCCCAFIAI2AgQgBSABNgIAIAAoAjwgB0ECdGogACgCKCAGQQJ0aiIAKAIANgIAIAAgBzYCAAsgBQu+AQEDf0HY7QFB2O0BKAIAQQFqNgIAAkACQCAAKAIMQX9qIAJBEHQgAXIiAyADQQ90QX9zaiIDQQp1IANzQQlsIgNBBnUgA3MiAyADQQt0QX9zaiIDQRB1IANzcSIDIAAoAiBODQAgACgCKCADQQJ0aigCACIDQX9GDQAgACgCECEFA0AgASAFIANBDGxqIgQoAgBGQQAgBCgCBCACRhsNAiAAKAI8IANBAnRqKAIAIgNBf0cNAAsLQQAhBAsgBAsJACAAEKUEEA4LjgIBBX8gAEGo+gA2AgAgAEEAOgAYIABBAToAFCAAQQA2AhAgAEEBOgAsIABCADcCCCAAQQA2AiggAEFAa0EBOgAAIABCADcCICAAQQA2AjwgAEIANwI0Qej3AUHo9wEoAgBBAWo2AgBBGEEQQYzSASgCABEDACEDIAAoAggiBEEBTgRAA0AgAyABQQxsIgJqIgUgACgCECACaiICKQIANwIAIAUgAigCCDYCCCABQQFqIgEgBEcNAAsLIAAoAhAiAQRAIAAtABQEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYCEAsgACADNgIQIABBAToAFCAAQQI2AgwgABC9AgsjACAAIAAoAgQoAgQoAhggASgCJCIAQdAAbGooAkAgABCnBAtJAQN/IAAoAgwiAkEBTgRAA0AgACgCFCADQQJ0aigCACIEBEAgBCABIAQoAgAoAhARAgAgACgCDCECCyADQQFqIgMgAkgNAAsLC5cGAgl/GX0gACgCDCIHQQFIBEBDAACAPw8LIAEgAiAALQAcIgUbIQggAiABIAUbIgFBQGsoAgAhCSABKgI8ISQgASoCOCElIAEqAjQhJiABKAIwIQogASoCLCEPIAEqAighECABKgIkIREgASgCICELIAEqAhwhEiABKgIYIRMgASoCFCEUIAEoAhAhDCABKgIMIRUgASoCCCEWIAEoAoQCIQYgASoCBCEXIAEoAsABIQ1DAACAPyEYQQAhBQNAIA0oAhggBUHQAGxqIgIqAjghDiACKgI0IRkgAioCMCEaIAIqAiQhGyACKgIUIRwgAioCBCEdIAIqAighHiACKgIYIR8gAioCCCEgIAIqAiAhISACKgIAISIgAioCECEjIAFBADYCQCABQQA2AjAgAUEANgIgIAFBADYCECABIAZBAWo2AoQCIAEgESAilCAQICOUkiAPICGUkjgCJCABIBQgIpQgEyAjlJIgEiAhlJI4AhQgASAXICKUIBYgI5SSIBUgIZSSOAIEIAEgESAglCAQIB+UkiAPIB6UkjgCLCABIBEgHZQgECAclJIgDyAblJI4AiggASAUICCUIBMgH5SSIBIgHpSSOAIcIAEgFCAdlCATIByUkiASIBuUkjgCGCABIBcgIJQgFiAflJIgFSAelJI4AgwgASAXIB2UIBYgHJSSIBUgG5SSOAIIIAEgJCARIBqUIBAgGZSSIA8gDpSSkjgCPCABICUgFCAalCATIBmUkiASIA6UkpI4AjggASAmIBcgGpQgFiAZlJIgFSAOlJKSOAI0IAAoAhQgBUECdGooAgAiAiABIAggAyAEIAIoAgAoAgwRGgAhDiABIAk2AkAgASAkOAI8IAEgJTgCOCABICY4AjQgASAKNgIwIAEgDzgCLCABIBA4AiggASAROAIkIAEgCzYCICABIBI4AhwgASATOAIYIAEgFDgCFCABIAw2AhAgASAVOAIMIAEgFjgCCCABIBc4AgQgASABKAKEAkEBaiIGNgKEAiAOIBggDiAYXRshGCAFQQFqIgUgB0cNAAsgGAv/EAIIfxh9IwBBsAFrIgUkACABIAIgAC0AHCIGGyEIIAIgASAGGyIJKAIEIgooAkQgACgCKEcEQCAAKAIMIgtBAU4EQEEAIQYDQCAGQQJ0IgwgACgCFGooAgAiBwRAIAcgBygCACgCABEBABogACgCBCIHIAAoAhQgDGooAgAgBygCACgCPBECAAsgBkEBaiIGIAtHDQALCyAAIAEgAhCoBAsgCigCQCEHIAAoAhQhBiAAKAIEIQEgBSAAKAIgNgKsASAFIAY2AqgBIAUgBDYCpAEgBSADNgKgASAFIAE2ApwBIAUgCDYCmAEgBSAJNgKUASAFQdz5ADYCkAEgBUEANgI8IAVCADcCNCAFQQE6AEACQCAAKAIMIgNBAUgNAEEAIQIDQCAGIAJBAnRqKAIAIgEEQCABIAVBMGogASgCACgCEBECAEEAIQMgBSgCNCIGQQBKBEADQCAFKAI8IANBAnRqKAIAIgEoAuwFBEAgBCABNgIEIAEgASgC5AUiASAEKAIMKAIIIgYgASAEKAIIKAIIIgtGIgEbQQRqIAYgCyABG0EEahAfIARBADYCBCAFKAI0IQYLIANBAWoiAyAGSA0ACwsgBkF/TARAIAUoAjhBf0wEQCAFKAI8IgEEQCAFLQBABEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAFQQA2AjwLIAVBAToAQCAFQgA3AzgLA0AgBSgCPCAGQQJ0akEANgIAIAZBAWoiASAGTyEDIAEhBiADDQALCyAFQQA2AjQgACgCDCEDCyACQQFqIgIgA0gEQCAAKAIUIQYMAQsLIAUoAjwiAUUNACAFLQBABEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAFQQA2AjwLAkACQCAHBEAgCSgCDCIBKgI0ISIgASoCOCEWIAgoAgwiAioCNCEXIAIqAjghGCABKgIUIQ0gASoCJCEOIAIqAhQhGSACKgIkIRogAioCGCEbIAEqAhghDyACKgIoIRwgASoCKCEQIAIqAiAhHSABKgIgIREgAioCACEeIAEqAgAhEiACKgIQIR8gASoCECETIAEqAjAhICACKgIwISEgASoCBCEUIAIqAgQhIyACKgIIISQgASoCCCEVIAVBADYCbCAFQQA2AlwgBUEANgJMIAUgFSAklCAPIBuUkiAQIByUkjgCWCAFIBUgI5QgDyAZlJIgECAalJI4AlQgBSAUICSUIA0gG5SSIA4gHJSSOAJIIAUgFCAjlCANIBmUkiAOIBqUkjgCRCAFIA8gIowiIpQgFSAglJMgECAWlJMgFSAhlCAPIBeUkiAQIBiUkpI4AmggBSANICKUIBQgIJSTIA4gFpSTIBQgIZQgDSAXlJIgDiAYlJKSOAJkIAVBADYCPCAFIBIgHpQgEyAflJIgESAdlJI4AjAgBSAVIB6UIA8gH5SSIBAgHZSSOAJQIAUgFCAelCANIB+UkiAOIB2UkjgCQCAFIBIgJJQgEyAblJIgESAclJI4AjggBSASICOUIBMgGZSSIBEgGpSSOAI0IAUgEyAilCASICCUkyARIBaUkyASICGUIBMgF5SSIBEgGJSSkjgCYCAIKAIEIgEgBUEwaiAFQYABaiAFQfAAaiABKAIAKAIIEQQAIAUgBSkDiAE3AxggBSAFKQN4NwMoIAUgBSkDcDcDICAFIAUpA4ABNwMQIAcgBygCACAFQRBqIAVBkAFqEGkMAQsgACgCDCIBQQFIDQFBACEGA0AgBUGQAWogCigCGCAGQdAAbGooAkAgBhCnBCAGQQFqIgYgAUcNAAsLIAAoAgwhAQsgAUEBTgRAQQAhBANAAkAgBEECdCIGIAAoAhRqKAIARQ0AIAooAhggBEHQAGxqIgIoAkAhByAJKAIMIgMqAjQhIyADKgI4ISQgAioCMCEWIAIqAjQhFyACKgI4IRggAioCBCEZIAIqAhQhGiACKgIkIRsgAioCCCEcIAIqAhghHSACKgIoIR4gAyoCFCENIAMqAhghDiACKgIAIR8gAioCECEgIAMqAiQhDyACKgIgISEgAyoCKCEQIAMqAjAhIiADKgIIIREgAyoCACESIAMqAgQhEyADKgIQIRQgAyoCICEVQQAhAyAFQQA2AmwgBUEANgJcIAVBADYCTCAFQQA2AjwgBSAVIB+UIA8gIJSSIBAgIZSSOAJQIAUgFCAflCANICCUkiAOICGUkjgCQCAFIBIgH5QgEyAglJIgESAhlJI4AjAgBSAVIByUIA8gHZSSIBAgHpSSOAJYIAUgFSAZlCAPIBqUkiAQIBuUkjgCVCAFIBQgHJQgDSAdlJIgDiAelJI4AkggBSAUIBmUIA0gGpSSIA4gG5SSOAJEIAUgEiAclCATIB2UkiARIB6UkjgCOCAFIBIgGZQgEyAalJIgESAblJI4AjQgBSAkIBUgFpQgDyAXlJIgECAYlJKSOAJoIAUgIyAUIBaUIA0gF5SSIA4gGJSSkjgCZCAFICIgEiAWlCATIBeUkiARIBiUkpI4AmAgByAFQTBqIAVBEGogBUGAAWogBygCACgCCBEEACAIKAIEIgIgCCgCDCAFQfAAaiAFIAIoAgAoAggRBAACf0EAIAUqAhAgBSoCAF4NABpBACAFKgKAASAFKgJwXQ0AGkEBCyECAkAgBSoCGCAFKgIIXg0AIAUqAogBIAUqAnhdDQAgAiEDCwJAIAUqAhQgBSoCBF4NACAFKgKEASAFKgJ0XQ0AIANBAXNFDQELIAAoAhQgBmooAgAiAiACKAIAKAIAEQEAGiAAKAIEIgIgACgCFCAGaigCACACKAIAKAI8EQIAIAAoAhQgBmpBADYCAAsgBEEBaiIEIAFHDQALCyAFQbABaiQAC70BAQR/IABBlPkANgIAIAAoAgwiA0EBTgRAA0AgAUECdCIEIAAoAhRqKAIAIgIEQCACIAIoAgAoAgARAQAaIAAoAgQiAiAAKAIUIARqKAIAIAIoAgAoAjwRAgALIAFBAWoiASADRw0ACwsgACgCFCIBBEAgAC0AGARAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgIUCyAAQQA2AhQgAEIANwIMIABBAToAGCAAEA4LuwEBBH8gAEGU+QA2AgAgACgCDCIDQQFOBEADQCABQQJ0IgQgACgCFGooAgAiAgRAIAIgAigCACgCABEBABogACgCBCICIAAoAhQgBGooAgAgAigCACgCPBECAAsgAUEBaiIBIANHDQALCyAAKAIUIgEEQCAALQAYBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AhQLIABBADYCFCAAQgA3AgwgAEEBOgAYIAALowEBCH8jAEEQayIFJAACQCAAKAIEIgNBAEwNACAAKAIMIQQDQCAEIAFBA3RqIgYhByABIQIgASAGKAIAIghHBEADQCAHIAQgCEEDdGoiAigCADYCACACKAIAIgIgBCACQQN0aiIHKAIAIghHDQALCyAGIAI2AgAgAUEBaiIBIANHDQALIANBAkgNACAAIAVBCGpBACADQX9qEKoECyAFQRBqJAALqgIBBX8gACgCBCICIAFIBEAgACgCCCABSARAIAEEf0Ho9wFB6PcBKAIAQQFqNgIAIAFBA3RBEEGM0gEoAgARAwAhBCAAKAIEBSACCyIDQQFOBEADQCAEIAVBA3QiBmogACgCDCAGaikCADcCACAFQQFqIgUgA0cNAAsLIAAoAgwiAwRAIAAtABAEQCADBEBB7PcBQez3ASgCAEEBajYCACADQZDSASgCABEAAAsLIABBADYCDAsgACAENgIMIABBAToAECAAIAE2AggLA0AgACgCDCACQQN0akIANwIAIAJBAWoiAiABRw0ACwsgACABNgIEIAFBAU4EQCAAKAIMIQBBACECA0AgACACQQN0aiIDQQE2AgQgAyACNgIAIAJBAWoiAiABRw0ACwsL4QgCAX8gfSMAQRBrIgQkACABKgIIIhogA5QgAioCCCIWkiEKIAEqAgQiGyADlCACKgIEIheSIRggASoCACIcIAOUIAIqAgAiA5IhGQJAIAAtAOQBBEAgBCAAKgI0IgwgACoCWIwiCJQgACoCJCINIAAqAlQiC5STIAAqAkQiCSAAKgJcIgWUkyISIAAqAsQBIgaUIAAqAjgiDiAIlCAAKgIoIg8gC5STIAAqAkgiECAFlJMiEyAAKgLIASIHlJIgACoCPCIRIAiUIAAqAiwiCCALlJMgACoCTCILIAWUkyIUIAAqAswBIgWUkiAAKgLcAZIgCiAJIAaUIBAgB5SSIAsgBZSSlCAZIA0gBpQgDyAHlJIgCCAFlJKUIBggDCAGlCAOIAeUkiARIAWUkpSSkpIiFSAaIBwgCiAJIAAqAqQBIgaUIBAgACoCqAEiB5SSIAsgACoCrAEiBZSSlCAZIA0gBpQgDyAHlJIgCCAFlJKUIBggDCAGlCAOIAeUkiARIAWUkpSSkiAGIBKUIBMgB5SSIBQgBZSSIAAqAtQBkpIiBiADk5QgGyAKIAkgACoCtAEiA5QgECAAKgK4ASIKlJIgCyAAKgK8ASIJlJKUIBkgDSADlCAPIAqUkiAIIAmUkpQgGCAMIAOUIA4gCpSSIBEgCZSSlJKSIBIgA5QgEyAKlJIgFCAJlJIgACoC2AGSkiIKIBeTlJIgGiAVIBaTlJIiA5SSOAIIIAQgCiAbIAOUkjgCBCAEIAYgHCADlJI4AgAMAQsgACoC3AEhIyAAKgLMASEMIAAqAsQBIQ0gACoCyAEhCSAAKgLUASEkIAAqAqgBIQYgACoCrAEhDiAAKgKkASEPIAQgFiAAKgKEASIQIAAqArQBIgeUIAAqAogBIhEgACoCuAEiCJSSIAAqAowBIgsgACoCvAEiBZSSlCADIAAqAmQiEiAHlCAAKgJoIhMgCJSSIAAqAmwiFCAFlJKUIBcgACoCdCIVIAeUIAAqAngiHSAIlJIgACoCfCIeIAWUkpSSkiAVIAAqApgBjCIflCASIAAqApQBIiCUkyAQIAAqApwBIiGUkyIiIAeUIB0gH5QgEyAglJMgESAhlJMiByAIlJIgHiAflCAUICCUkyALICGUkyIIIAWUkiAAKgLYAZKSIgU4AgQgBCAWIBAgD5QgESAGlJIgCyAOlJKUIAMgEiAPlCATIAaUkiAUIA6UkpQgFyAVIA+UIB0gBpSSIB4gDpSSlJKSICQgDyAilCAHIAaUkiAIIA6UkpKSIgY4AgAgBCAjICIgDZQgByAJlJIgCCAMlJKSIBYgECANlCARIAmUkiALIAyUkpQgAyASIA2UIBMgCZSSIBQgDJSSlCAXIBUgDZQgHSAJlJIgHiAMlJKUkpKSIgM4AgggHCAZIAaTlCAbIBggBZOUkiAaIAogA5OUkiEDCyAEQQA2AgwgACgCICIAIAEgBCADIAAoAgAoAhARDwAgBEEQaiQAC9ABAgF/B30jAEEQayIEJAAgACADOAIgIAAgASkCADcCCCAAIAEpAgg3AhAgASoCCCEGIAIqAgAhByABKgIAIQggAioCBCEJIAEqAgQhCiACKgIIIQsgACoCHCEFIARBADYCDCAEIAsgBSAGlJM4AgggBCAJIAUgCpSTOAIEIAQgByAIIAWUkzgCACAAIAUgACoCGJIgA5IiAzgCICADQwAAAABdQQFzRQRAIABBAToAJAsgACgCBCIAIAEgBCADIAAoAgAoAhARDwAgBEEQaiQAC5oCAQV/AkAgACgCFCIDRQ0AIAAtABBFDQACQCABKAIEIgIgASgCCEcNACACIAJBAXRBASACGyIETg0AAn8gBARAQej3AUHo9wEoAgBBAWo2AgAgBEECdEEQQYzSASgCABEDACEFIAEoAgQhAgsgAkEBTgsEQEEAIQMDQCAFIANBAnQiBmogASgCDCAGaigCADYCACADQQFqIgMgAkcNAAsLIAEoAgwiAwRAIAEtABAEQCADBEBB7PcBQez3ASgCAEEBajYCACADQZDSASgCABEAAAsgASgCBCECCyABQQA2AgwLIAEgBTYCDCABQQE6ABAgASAENgIIIAAoAhQhAwsgASgCDCACQQJ0aiADNgIAIAEgAkEBajYCBAsLiQECAn8BfiABKAIAIgJBJCACKAIAKAI4EQMAIQIgACgCDCEDIAAoAgghBCABKAIEIQUgACkCECEGIAJBhLMBNgIAIAIgASgCADYCBCACQfzSADYCACACIAY3AhwgAkEAOgAYIAIgBTYCFCACQQA6ABAgAiAENgIMIAIgAzYCCCACQfD0ADYCACACC7YGAgV/An0jAEHgBGsiACQAAkAgASoCdCABKgI0kyIKIAqUIAEqAnggASoCOJMiCiAKlJIgASoCfCABKgI8kyIKIAqUkiABKgL8ASIKIAqUXUEBc0UEQEMAAIA/IQsgAioCdCACKgI0kyIKIAqUIAIqAnggAioCOJMiCiAKlJIgAioCfCACKgI8kyIKIAqUkiACKgL8ASIKIAqUXQ0BC0MAAIA/IQtByO0BLQAADQAgASgCwAEhAyACKAL4ASEEIABBqARqIgVCIzcCBCAFQaSQATYCACAFQYquj+kDNgIsIAVCgICA/AM3AhQgBUKAgID8g4CAwD83AgwgBUGkkQE2AgAgACAENgLUBCAAIAQ2AsQEIABBCDYCrAQgAEHEggE2AqgEIABBADYCpAQgAELrlvjqBTcCnAQgAEG4MDYC+AIgAEEAOgDcAiAAQZfuxsYDNgLEAgJ9QwAAgD8CfyAAIABBqARqNgIMIAAgAzYCCCAAIABBEGo2AgQgAEHw4AA2AgAgAAsgAUEEaiIIIAFBxABqIgkgAkEEaiIFIAJBxABqIgQgAEH4AmoQxQJFDQAaIAEqAvQBIAAqApwEIgpeQQFzRQRAIAEgCjgC9AELIAIqAvQBIApeQQFzRQRAIAIgCjgC9AELQwAAgD8gCkMAAIA/XUEBcw0AGiAKCyELIAIoAsABIQMgASgC+AEhByAAQagEaiIGQiM3AgQgBkGkkAE2AgAgBkGKro/pAzYCLCAGQoCAgPwDNwIUIAZCgICA/IOAgMA/NwIMIAZBpJEBNgIAIAAgBzYC1AQgACAHNgLEBCAAQQg2AqwEIABBxIIBNgKoBCAAQQA2AqQEIABC65b46gU3ApwEIABBuDA2AvgCIABBADoA3AIgAEGX7sbGAzYCxAICQAJ/IAAgAzYCDCAAIABBqARqNgIIIAAgAEEQajYCBCAAQfDgADYCACAACyAIIAkgBSAEIABB+AJqEMUCRQ0AIAEqAvQBIAAqApwEIgpeQQFzRQRAIAEgCjgC9AELIAIqAvQBIApeQQFzRQRAIAIgCjgC9AELIAsgCl5BAXMNACAKIQsLCyAAQeAEaiQAIAsLuiwCDn8gfSMAQaAEayIFJAAgACgCFCIKRQRAIAAoAgQiBiABKAIIIAIoAgggBigCACgCDBEHACEKIABBAToAECAAIAo2AhQLIAQgCjYCBCACKAIEIQcCQAJAIAEoAgQiCSgCBEEKRw0AIAcoAgRBCkcNACAKKgLwBSEmIAIoAgwiAiAHKAI0IgZBAnQiA2oiACoCACInIAIqAjAiMiABKAIMIgEqAjCTIh6UIAAqAhAiHyACKgI0IhogASoCNJMiIJSSIAAqAiAiHCACKgI4IhsgASoCOJMiKJSSIRYgASAJKAI0IgJBAnQiAGoiASoCACIiIB6UIAEqAhAiHSAglJIgASoCICIhICiUkiEYIAdBHGoiASADaioCACEXIAAgCUEcaiIAaioCACEVIAEgBkECakEDb0ECdGoqAgAhJCAAIAJBAmpBA29BAnRqKgIAIRkCQEMAAIA/ICIgJ5QgHSAflJIgISAclJIiIyAjlJMiFEMAAAAAWw0AIBggIyAWlJMgFJUiFCAVjCITXQ0AIBQiEyAVXkEBcw0AIBUhEwsCQAJ9ICMgE5QgFpMiFCAXjCIWXUEBc0UEQCAYIBcgI5STIhcgFYwiE10EQCAWIRQMAwsgFyAVXkEBcwRAIBYhFCAXIRMMAwsgFgwBCyAUIBdeQQFzDQEgFyAjlCAYkiIWIBWMIhNdBEAgFyEUDAILIBYgFV5BAXMEQCAXIRQgFiETDAILIBcLIRQgFSETCyAcIBSUIhUgKCAhIBOUk5IiGCAYlCAnIBSUIhcgHiAiIBOUk5IiHCAclCAfIBSUIhYgICAdIBOUk5IiKCAolJKSIhSRIhMgGZMgJJMiGSAmXkUEQAJAIBRDAACAKF9BAXNFBEAgIYtD8wQ1P15BAXNFBEAgBUEANgIAIAUgHUMAAIA/IB0gHZQgISAhlJKRlSITlCIYOAIIIAUgEyAhjJQiFDgCBEMAAAAAIRMMAgsgBUEANgIIIAUgIkMAAIA/ICIgIpQgHSAdlJKRlSITlCIUOAIEIAUgEyAdjJQiEzgCAEMAAAAAIRgMAQsgBUEANgIMIAUgGEMAAIC/IBOVIhOUIhg4AgggBSAoIBOUIhQ4AgQgBSAcIBOUIhM4AgALIAVBADYCpAMgBSAbIBWSICQgGJSSOAKgAyAFIBogFpIgJCAUlJI4ApwDIAUgMiAXkiAkIBOUkjgCmAMLIBkgJl1BAXNFBEAgBCAFIAVBmANqIBkgBCgCACgCEBEPAAsgBCgCBCICKALsBUUNASACKALkBSIBIAQoAggoAggiAEcEQCACIAQoAgwoAghBBGogAEEEahAfDAILIAIgAUEEaiAEKAIMKAIIQQRqEB8MAQsgBUHrlvjqBTYCmAQgBUHIAmogCSAHIAAoAgggACgCDBDHAiIMIAc2AiAgDCAJNgIcIAUgCSAJKAIAKAIwEQYAIAcgBygCACgCMBEGAJIgACgCFCoC8AWSIhQgFJQ4ApgEIAUgASgCDCIGKQIINwOgAyAFIAYpAgA3A5gDIAUgBikCGDcDsAMgBSAGKQIQNwOoAyAFIAYpAig3A8ADIAUgBikCIDcDuAMgBSAGKQI4NwPQAyAFIAYpAjA3A8gDIAUgAigCDCIGKQIINwPgAyAFIAYpAgA3A9gDIAVB6ANqIg8gBikCEDcDACAFIAYpAhg3A/ADIAVB+ANqIhAgBikCIDcDACAFIAYpAig3A4AEIAVBiARqIhEgBikCMDcDACAFIAYpAjg3A5AEAkAgCSgCBCINQQZKDQAgBygCBCIGQQZKDQAgBUHo9QA2AsACQwAAAAAhFCANBH8gCSAJKAIAKAIwEQYAIRQgBygCBAUgBgsEQCAHIAcoAgAoAjARBgAhEwsgBUEAOgAkIAUgEzgCHCAFIBQ4AhggBSAENgIEIAVBmPcANgIAIAkoAjRFDQAgBygCNARAIAAoAhQqAvAFIRMCQAJAIAMtABgEQEPK8knxIRQgCSgCNCAHKAI0IAEoAgwgAigCDCAFQfABaiAEEN0MDQEMAgsgDCAFQZgDaiAFIAMoAhRBABBEIAUgBSkDEDcD+AEgBSAFKQMINwPwASAFKgIgIhRDAAAAAF1BAXMNASAFLQAkRQ0BCyAFQfABaiAJKAI0IAcoAjQgASgCDCACKAIMIBQgE5MgEyAEENwMCyAALQAQRQ0CIAQoAgQiAigC7AVFDQIgAigC5AUiASAEKAIIKAIIIgBHBEAgAiAEKAIMKAIIQQRqIABBBGoQHwwDCyACIAFBBGogBCgCDCgCCEEEahAfDAILIAcoAgRBAUcNACAFQQA2AvQBIAIoAgwiBioCNCEYIAYqAhQhHCAGKgIYISggBioCOCEyIAYqAiQhGiAGKgIoIRsgB0FAayoCACEeIAcqAjghHyAHKgI8ISAgBioCECEZIAYqAiAhFSAGKgIwIRcgBioCCCEWIAYqAgAhFCAGKgIEIRNB6PcBQej3ASgCAEEBajYCACAFQRBBEEGM0gEoAgARAwAiBjYC/AEgBUEBOgCAAiAFQQE2AvgBIAZBADYCDCAGIBcgHyAUlCAgIBOUkiAeIBaUkpI4AgAgBiAyIB8gFZQgICAalJIgHiAblJKSOAIIIAYgGCAfIBmUICAgHJSSIB4gKJSSkjgCBCAFIAUoAvQBQQFqIgg2AvQBIAcqAkgiFSACKAIMIgYqAiCUIAcqAkwiFyAGKgIklJIgByoCUCITIAYqAiiUkiAGKgI4kiEWIBUgBioCEJQgFyAGKgIUlJIgEyAGKgIYlJIgBioCNJIhFCAVIAYqAgCUIBcgBioCBJSSIBMgBioCCJSSIAYqAjCSIRMCQCAIIAUoAvgBRw0AIAggCEEBdEEBIAgbIg5ODQBBACEKAn8gDgRAQej3AUHo9wEoAgBBAWo2AgAgDkEEdEEQQYzSASgCABEDACELIAUoAvQBIQgLIAhBAU4LBEADQCALIApBBHQiBmoiDSAFKAL8ASAGaiIGKQIANwIAIA0gBikCCDcCCCAKQQFqIgogCEcNAAsLIAUoAvwBIgYEQCAFLQCAAgRAIAYEQEHs9wFB7PcBKAIAQQFqNgIAIAZBkNIBKAIAEQAACwsgBUEANgL8AQsgBSALNgL8ASAFQQE6AIACIAUgDjYC+AEgBSgC9AEhCAsgBSgC/AEgCEEEdGoiBkEANgIMIAYgFjgCCCAGIBQ4AgQgBiATOAIAIAUgBSgC9AFBAWoiCDYC9AEgByoCWCIVIAIoAgwiAioCAJQgByoCXCIXIAIqAgSUkiAHKgJgIhMgAioCCJSSIAIqAjCSIRYgFSACKgIglCAXIAIqAiSUkiATIAIqAiiUkiACKgI4kiEUIBUgAioCEJQgFyACKgIUlJIgEyACKgIYlJIgAioCNJIhEwJAIAggBSgC+AFHDQAgCCAIQQF0QQEgCBsiDU4NAEEAIQpBACELAn8gDQRAQej3AUHo9wEoAgBBAWo2AgAgDUEEdEEQQYzSASgCABEDACELIAUoAvQBIQgLIAhBAU4LBEADQCALIApBBHQiAmoiBiAFKAL8ASACaiICKQIANwIAIAYgAikCCDcCCCAKQQFqIgogCEcNAAsLIAUoAvwBIgIEQCAFLQCAAgRAIAIEQEHs9wFB7PcBKAIAQQFqNgIAIAJBkNIBKAIAEQAACwsgBUEANgL8AQsgBSALNgL8ASAFQQE6AIACIAUgDTYC+AEgBSgC9AEhCAsgBSgC/AEgCEEEdGoiAkEANgIMIAIgFDgCCCACIBM4AgQgAiAWOAIAIAUgBSgC9AFBAWo2AvQBIAAoAhQqAvAFIRUgDCAFQZgDaiAFQcACaiADKAIUQQAQRCAMKgIEIhcgF5QgDCoCCCIWIBaUkiAMKgIMIhQgFJSSIhNDAAAANF5BAXNFBEAgBUEANgK8AiAFIBRDAACAPyATlSITlDgCuAIgBSAWIBOUOAK0AiAFIBcgE5Q4ArACIAwqAjghFiAJIAkoAgAoAjARBgAhFCAHIAcoAgAoAjARBgAhEyAFQbACaiAJKAI0IAEoAgwgBUHwAWogFiAUkyATkyAVkyAVIAQQrgQLAkAgAC0AEEUNACAEKAIEIgIoAuwFRQ0AIAIoAuQFIgEgBCgCCCgCCCIARwRAIAIgBCgCDCgCCEEEaiAAQQRqEB8MAQsgAiABQQRqIAQoAgwoAghBBGoQHwsgBSgC/AEiAEUNASAFLQCAAgRAIAAEQEHs9wFB7PcBKAIAQQFqNgIAIABBkNIBKAIAEQAACwsgBUEANgL8AQwBCyAMIAVBmANqIAQgAygCFEEAEEQCQCAAKAIcRQ0AIAQoAgQoAuwFIAAoAiBODQAgDCoCBCIXIBeUIAwqAggiFiAWlJIgDCoCDCIUIBSUkiITQwAAADReQQFzDQAgBUHYA2ohEiAFQcgDaiEIIAVBuANqIQsgBUGoA2ohDiAWQwAAgD8gE5UiE5QhKSAXIBOUITACQCAUIBOUIjGLQ/MENT9eQQFzRQRAIClDAACAPyAxIDGUICkgKZSSkZUiFJQhEyAUIDGMlCEUDAELIDBDAACAPyAwIDCUICkgKZSSkZUiE5QhFCATICmMlCEYQwAAAAAhEwsgCSAJKAIAKAIQEQYAIRUgByAHKAIAKAIQEQYAIRdBgNIBKgIAIRYgBSAFQZgDaiASIBUgF10iCRsiBikCCDcD+AEgBSAGKQIANwPwASAFIA4gDyAJGyIGKQIINwOIAiAFIAYpAgA3A4ACIAUgCyAQIAkbIgYpAgg3A5gCIAUgBikCADcDkAIgBSAIIBEgCRsiBikCCDcDqAIgBSAGKQIANwOgAiAAKAIcIgpBAUgNACATIBYgFSAXIAkblUPbD8k+lkMAAAA/lCIWEBwgGCAYlCAUIBSUkiATIBOUkiIokZUiE5QhKyAUIBOUISwgGCATlCEtIDEgMZQgMCAwlCApICmUkpKRITIgFhAdIS5BACENA0AgKEMAAAA0XkEBc0UEQCAxQ9sPyUAgCrKVIA2ylEMAAAA/lCITEBwgMpUiFJQhGiApIBSUIRsgMCAUlCEZIBMQHSEVAkAgCUEBc0UEQCABKAIMIgYqAiQhLyAGKgIUIR0gBioCKCEhIAYqAhghIiAGKgIgISMgBioCACEkIAYqAhAhJiAGKgIEIScgBioCCCEeIAVBADYCxAMgBUEANgK0AyAFQQA2AqQDIAUgHiAaICsgGZQgLCAVlCAuIBuUkyAtIBqUk5IiF5QgGSArIBqUICwgG5QgLiAVlCAtIBmUkpKSIhaUIBUgLCAalCAtIBWUIC4gGZSTICsgG5STkiIUlJKSIBsgLSAblCArIBWUIC4gGpSTICwgGZSTkiITlJMiJSAbIBSUIBogFpQgFSATlJKSIBkgF5STIh9DAAAAQCAVIBaUIBkgFJSTIBsgF5STIBogE5STIiogKpQgHyAflCAlICWUIBkgE5QgFSAXlCAbIBaUkpIgGiAUlJMiFCAUlJKSkpUiE5QiIJQiGiAqIBQgE5QiGJQiG5MiHJQgIiAUICCUIhkgKiAlIBOUIhOUIhWSIhaUkiAhQwAAgD8gJSATlCITIBQgGJQiF5KTIhSUkjgCwAMgBSAcICeUIBYgHZSSIBQgL5SSOAK8AyAFIBwgJJQgFiAmlJIgFCAjlJI4ArgDIAUgHiAlIBiUIhYgKiAglCIUkiIYlCAiQwAAgD8gEyAfICCUIhOSkyIclJIgISAZIBWTIhWUkjgCsAMgBSAYICeUIBwgHZSSIBUgL5SSOAKsAyAFIBggJJQgHCAmlJIgFSAjlJI4AqgDIAUgHkMAAIA/IBcgE5KTIheUICIgFiAUkyIUlJIgISAaIBuSIhOUkjgCoAMgBSAXICeUIBQgHZSSIBMgL5SSOAKcAyAFIBcgJJQgFCAmlJIgEyAjlJI4ApgDIBIgAigCDCIGKQIANwIAIBIgBikCCDcCCCAPIAYpAhg3AgggDyAGKQIQNwIAIBAgBikCKDcCCCAQIAYpAiA3AgAgESAGKQI4NwIIIBEgBikCMDcCAAwBCyAFIAEoAgwiBikCCDcDoAMgBSAGKQIANwOYAyAOIAYpAhg3AgggDiAGKQIQNwIAIAsgBikCKDcCCCALIAYpAiA3AgAgCCAGKQI4NwIIIAggBikCMDcCACACKAIMIgYqAiQhLyAGKgIUIR0gBioCKCEhIAYqAhghIiAGKgIgISMgBioCACEkIAYqAhAhJiAGKgIEIScgBioCCCEeIAVBADYChAQgBUEANgL0AyAFQQA2AuQDIAUgHiAaICsgGZQgLCAVlCAuIBuUkyAtIBqUk5IiF5QgGSArIBqUICwgG5QgLiAVlCAtIBmUkpKSIhaUIBUgLCAalCAtIBWUIC4gGZSTICsgG5STkiIUlJKSIBsgLSAblCArIBWUIC4gGpSTICwgGZSTkiITlJMiJSAbIBSUIBogFpQgFSATlJKSIBkgF5STIh9DAAAAQCAVIBaUIBkgFJSTIBsgF5STIBogE5STIiogKpQgHyAflCAlICWUIBkgE5QgFSAXlCAbIBaUkpIgGiAUlJMiFCAUlJKSkpUiE5QiIJQiGiAqIBQgE5QiGJQiG5MiHJQgIiAUICCUIhkgKiAlIBOUIhOUIhWSIhaUkiAhQwAAgD8gJSATlCITIBQgGJQiF5KTIhSUkjgCgAQgBSAcICeUIBYgHZSSIBQgL5SSOAL8AyAFIBwgJJQgFiAmlJIgFCAjlJI4AvgDIAUgHiAlIBiUIhYgKiAglCIUkiIYlCAiQwAAgD8gEyAfICCUIhOSkyIclJIgISAZIBWTIhWUkjgC8AMgBSAYICeUIBwgHZSSIBUgL5SSOALsAyAFIBggJJQgHCAmlJIgFSAjlJI4AugDIAUgHkMAAIA/IBcgE5KTIheUICIgFiAUkyIUlJIgISAaIBuSIhOUkjgC4AMgBSAXICeUIBQgHZSSIBMgL5SSOALcAyAFIBcgJJQgFCAmlJIgEyAjlJI4AtgDCyADKAIUIQYgBSAENgIgIAVB0PgANgIAIAUgBSkDoAM3AiwgBSAFKQOYAzcCJCAFIA4pAgg3AjwgBSAOKQIANwI0IAUgCykCCDcCTCAFIAspAgA3AkQgBSAIKQIINwJcIAUgCCkCADcCVCAFIBIpAgg3AmwgBSASKQIANwJkIAUgDykCCDcCfCAFIA8pAgA3AnQgBSAQKQIINwKMASAFIBApAgA3AoQBIAUgESkCCDcCnAEgBSARKQIANwKUASAFIAUpA/gBNwKsASAFIAUpA/ABNwKkASAFIAUpAogCNwK8ASAFIAUpAoACNwK0ASAFIAUpApgCNwLMASAFIAUpApACNwLEASAFIAUpAqACNwLUASAFIAUpAqgCNwLcASAFIAY2AugBIAUgCToA5AEgDCAFQZgDaiAFIAZBABBEIAAoAhwhCgsgDUEBaiINIApIDQALCyAALQAQRQ0AIAQoAgQiAigC7AVFDQAgAigC5AUiASAEKAIIKAIIIgBHBEAgAiAEKAIMKAIIQQRqIABBBGoQHwwBCyACIAFBBGogBCgCDCgCCEEEahAfCyAFQaAEaiQACzoBAn8gAEHw9AA2AgACQCAALQAQRQ0AIAAoAhQiAUUNACAAKAIEIgIgASACKAIAKAIQEQIACyAAEA4LOAECfyAAQfD0ADYCAAJAIAAtABBFDQAgACgCFCIBRQ0AIAAoAgQiAiABIAIoAgAoAhARAgALIAALqwcCDH8QfSMAQTBrIggkACAAKgIIIRQgACoCACEVIAAqAgQhFiAIIAAoAgw2AiwgCCAUQwAAgD8gFSAVlCAWIBaUkiAUIBSUkpGVIhSUIhg4AiggCCAWIBSUIhk4AiQgCCAVIBSUIho4AiAgAigCJCEKAkAgAigCHCIMQQFIBEBBfyELDAELIAQqAighGyAEKgIkIRwgBCoCGCEdIAQqAhQhHiAEKgIgIR8gBCoCECEgIAQqAgghISAEKgIEISIgBCoCACEjQQAhAEP//3//IRRBfyELA0AgGiAKIABBJGxqIgkqAhQiFSAjlCAJKgIYIhYgIpSSIAkqAhwiFyAhlJKUIBkgFSAglCAWIB6UkiAXIB2UkpSSIBggFSAflCAWIByUkiAXIBuUkpSSIhUgFCAVIBReIgkbIRQgACALIAkbIQsgAEEBaiIAIAxHDQALCyAIQQA2AhQgCEIANwIMIAhBAToAGAJAIAogC0EkbGooAgQiEUEBSA0AIAogC0EkbGohEkEAIQlBACEMA0AgAigCECASKAIMIA5BAnRqKAIAQQR0aiIAKgIAIhQgBCoCIJQgACoCBCIVIAQqAiSUkiAAKgIIIhYgBCoCKJSSIAQqAjiSIRcgFCAEKgIQlCAVIAQqAhSUkiAWIAQqAhiUkiAEKgI0kiEYIBQgBCoCAJQgFSAEKgIElJIgFiAEKgIIlJIgBCoCMJIhFAJAIAkgDEcNACAJIAlBAXRBASAJGyIPTg0AQQAhAEEAIQ0gDwRAQej3AUHo9wEoAgBBAWo2AgAgD0EEdEEQQYzSASgCABEDACENCyAIKAIUIQoCQAJAIAlBAU4EQANAIA0gAEEEdCIQaiITIAogEGoiECkCADcCACATIBApAgg3AgggAEEBaiIAIAlHDQAMAgALAAsgCkUNAQsgCC0AGARAIAoEQEHs9wFB7PcBKAIAQQFqNgIAIApBkNIBKAIAEQAACwsgCEEANgIUCyAIIA02AhQgCEEBOgAYIAggDzYCEAsgCCgCFCAMQQR0aiIAQQA2AgwgACAXOAIIIAAgGDgCBCAAIBQ4AgAgCCAIKAIMQQFqIgw2AgwgDkEBaiIOIBFGDQEgCCgCECEJDAAACwALIAtBf0oEQCAIQSBqIAEgAyAIQQhqIAUgBiAHEK4ECyAIKAIUIgAEQCAILQAYBEAgAARAQez3AUHs9wEoAgBBAWo2AgAgAEGQ0gEoAgARAAALCyAIQQA2AhQLIAhBMGokAAuTGAIGfyZ9IwBB8ABrIgYkAEHE7QFBxO0BKAIAQQFqNgIAIAIqAjQhHyACKgIUIRAgAioCGCESIAMqAjQhICADKgIUIQ0gAyoCGCEoIAIqAjghISACKgIkIREgACoCRCEMIAIqAighEyAAKgJIIRQgAyoCOCEpIAMqAiQhDiABKgJEIQ8gAyoCKCEXIAEqAkghGyACKgIwIRogAioCCCEVIAIqAgAhIiACKgIEISMgAyoCMCEkIAMqAgghJyADKgIAIR4gAyoCBCEcIAIqAhAhFiADKgIQISUgAioCICEYIAAqAkAhGSADKgIgISYgASoCQCEdIAZBADYCHCAGICEgGSAYlCAMIBGUkiAUIBOUkpIgKSAdICaUIA8gDpSSIBsgF5SSkpMiITgCGCAGIB8gGSAWlCAMIBCUkiAUIBKUkpIgICAdICWUIA8gDZSSIBsgKJSSkpMiHzgCFCAGIBogGSAilCAMICOUkiAUIBWUkpIgJCAdIB6UIA8gHJSSIBsgJ5SSkpMiGzgCEEP//39/IQwCQAJAAkACQAJAAkAgACgCHCIKQQFIDQADQCAAKAIkIAdBJGxqIgkqAhwhFCAJKgIYIQ8gCSoCFCEZIAIqAgAhHSACKgIEISAgBkEANgIMIAYgGSAYlCAPIBGUkiAUIBOUkiIROAIIIAYgGSAWlCAPIBCUkiAUIBKUkiIQOAIEIAYgGSAdlCAPICCUkiAUIBWUkiISOAIAIBIgG5QgECAflJIgESAhlJJDAAAAAF1BAXNFBEAgBiARjDgCCCAGIBCMOAIEIAYgEow4AgALQbztAUG87QEoAgBBAWo2AgACQEGF0gEtAAAEQCACIAMgBkEQaiAGIAAgASAMEL4CRQ0BC0EAIQhBwO0BQcDtASgCAEEBajYCACAAIAIgBiAGQewAaiAGQegAaiAGQdAAaiAGQUBrEH0gASADIAYgBkHkAGogBkHgAGogBkEwaiAGQSBqEH0CQCAGKgJoIhAgBioCZCISXQ0AIAYqAmAiESAGKgJsIhNdDQAgECASkyINIBEgE5MiECANIBBdGyENQQEhCAsgCEUNAyANIAxdQQFzDQAgBCAGKQMANwIAIAQgBikDCDcCCCANIQwLIAdBAWoiByAKRg0BIAIqAighEyACKgIkIREgAioCICEYIAIqAhghEiACKgIUIRAgAioCECEWIAIqAgghFQwAAAsACyABKAIcIgpBAU4EQEEAIQcDQCABKAIkIAdBJGxqIgkqAhwhECAJKgIUIRIgCSoCGCERIAMqAgghDyADKgIAIRUgAyoCBCEWIAMqAhghFCADKgIQIRggAyoCFCEZIAMqAighEyADKgIgIR0gAyoCJCEgIAZBADYCDCAGIBIgHZQgESAglJIgECATlJIiEzgCCCAGIBIgGJQgESAZlJIgECAUlJIiFDgCBCAGIBIgFZQgESAWlJIgECAPlJIiEDgCACAQIBuUIBQgH5SSIBMgIZSSQwAAAABdQQFzRQRAIAYgE4w4AgggBiAUjDgCBCAGIBCMOAIAC0G87QFBvO0BKAIAQQFqNgIAAkBBhdIBLQAABEAgAiADIAZBEGogBiAAIAEgDBC+AkUNAQtBACEIQcDtAUHA7QEoAgBBAWo2AgAgACACIAYgBkHsAGogBkHoAGogBkHQAGogBkFAaxB9IAEgAyAGIAZB5ABqIAZB4ABqIAZBMGogBkEgahB9AkAgBioCaCIQIAYqAmQiEl0NACAGKgJgIhEgBioCbCITXQ0AIBAgEpMiDSARIBOTIhAgDSAQXRshDUEBIQgLIAhFDQMgDSAMXUEBcw0AIAQgBikDADcCACAEIAYpAwg3AgggDSEMCyAHQQFqIgcgCkcNAAsLIAAoAjAiB0EBTg0BQX8hCkF/IQsMAgtBACEDDAMLIAEoAjAhCEF/IQtBACEJQX8hCgNAIAhBAU4EQCAAKAI4IAlBBHRqIgcqAgAiEiACKgIglCAHKgIEIhEgAioCJJSSIAcqAggiEyACKgIolJIhDSASIAIqAhCUIBEgAioCFJSSIBMgAioCGJSSIRAgEiACKgIAlCARIAIqAgSUkiATIAIqAgiUkiESQQAhBwNAIAEoAjggB0EEdGoiCCoCCCEUIAgqAgAhFSAIKgIEIRYgAyoCKCEYIAMqAiAhGSADKgIkIR0gAyoCGCERIAMqAhAhEyADKgIUIQ8gAyoCCCEgIAMqAgAhKCADKgIEISkgBkEANgIMIAYgEiAVIBOUIBYgD5SSIBQgEZSSIhGUIBAgFSAolCAWICmUkiAUICCUkiITlJMiDzgCCCAGIA0gE5QgEiAVIBmUIBYgHZSSIBQgGJSSIhSUkyIVOAIEIAYgECAUlCANIBGUkyIWOAIAAkACQCAWi7tEje21oPfGsD5kDQAgFYu7RI3ttaD3xrA+ZA0AIA+Lu0SN7bWg98awPmRBAXMNAQsgBiAPQwAAgD8gDyAPlCAWIBaUIBUgFZSSkpGVIg+UIhg4AgggBiAVIA+UIhU4AgQgBiAWIA+UIg84AgAgDyAblCAVIB+UkiAhIBiUkkMAAAAAXUEBc0UEQCAGIBiMOAIIIAYgFYw4AgQgBiAPjDgCAAtBvO0BQbztASgCAEEBajYCAEGF0gEtAAAEQCACIAMgBkEQaiAGIAAgASAMEL4CRQ0BC0EAIQhBwO0BQcDtASgCAEEBajYCACAAIAIgBiAGQewAaiAGQegAaiAGQdAAaiAGQUBrEH0gASADIAYgBkHkAGogBkHgAGogBkEwaiAGQSBqEH0CQCAGKgJoIg8gBioCZCIVXQ0AIAYqAmAiFiAGKgJsIhhdDQAgDyAVkyIOIBYgGJMiD11BAXNFBEBBASEIIAYqAjghIyAGKgI0ISQgBioCMCEnIAYqAkghFyAGKgJEIRogBioCQCEiDAELQQEhCCAGKgIoISMgBioCJCEkIAYqAiAhJyAGKgJYIRcgBioCVCEaIAYqAlAhIiAPIQ4LIAhFDQUgDiAMXUEBcw0AIAQgBikDADcCACAEIAYpAwg3AgggJyEsICQhLSAjIS4gIiEvIBohMCAXITEgEyEeIBEhHCAUISUgEiEmIBAhKiANISsgCSEKIAchCyAOIQwLIAdBAWoiByABKAIwIghIDQALIAAoAjAhBwsgCUEBaiIJIAdIDQALCwJAIAogC3JBAEgNACAsIC+TIiIgHpQgLSAwkyIjIByUkiAuIDGTIiQgJZSSIQ4gIiAmlCAjICqUkiAkICuUkiEaQwAAAAAhDAJAQwAAgD8gHiAmlCAcICqUkiAlICuUkiIXIBeUkyINQwAAAABbDQBDyvJJ8SEMIBogDiAXlJMgDZUiDUPK8knxXQ0AIA0iDEPK8klxXkEBcw0AQ8rySXEhDAsCQCAXIAyUIA6TIg5DyvJJ8V1BAXNFBEAgGiAXQ8rySfGUkiINQ8rySfFdBEBDyvJJ8SEOQ8rySfEhDAwCC0PK8klxIQwgDUPK8klxXkEBcwRAQ8rySfEhDiANIQwMAgtDyvJJ8SEODAELIA5DyvJJcV5BAXMNAEPK8knxIQxDyvJJcSEOIBogF0PK8klxlJIiDUPK8knxXQ0AIA0iDEPK8klxXkEBcw0AQ8rySXEhDAsgBkEANgJcIAYgJSAOlCIlICQgKyAMlJOSIg04AlggBiAcIA6UIhcgIyAqIAyUk5IiHDgCVCAGIB4gDpQiGiAiICYgDJSTkiIMOAJQIA0gDZQgDCAMlCAcIByUkpIiDkMAAAA0XkEBcw0AIAYgDUMAAIA/IA6RIiaVIg2UIg44AlggBiAcIA2UIh44AlQgBiAMIA2UIgw4AlAgDCAblCAeIB+UkiAOICGUkkMAAAAAXUEBc0UEQCAGIA6MOAJYIAYgHow4AlQgBiAMjDgCUAsgBkEANgJMIAYgLiAlkjgCSCAGIC0gF5I4AkQgBiAsIBqSOAJAIAUgBkHQAGogBkFAayAmjCAFKAIAKAIQEQ8AC0EBIQMgGyAEKgIAIgyUIB8gBCoCBCINlJIgISAEKgIIIg6UkkMAAAAAXUEBcw0BIARBADYCDCAEIA6MOAIIIAQgDYw4AgQgBCAMjDgCAAwBC0EAIQMLIAZB8ABqJAAgAwvaCwIJfwt9AkAgACgCBCILQQJIDQAgACgCDCIFIAtBBHRqQXBqIgQqAgAiECACKgIAIhWUIAQqAgQiDiACKgIEIhaUkiAEKgIIIg8gAioCCCIXlJIgA5IhDQNAIAUgDEEEdGoiBCoCACIRIBWUIAQqAgQiEiAWlJIgBCoCCCITIBeUkiADkiEUIAQoAgwhCQJAAkAgDUMAAAAAXUEBc0UEQCAUQwAAAABdQQFzRQRAAkAgASgCBCIEIAEoAghHDQAgBCAEQQF0QQEgBBsiBk4NAEEAIQVBACEHAn8gBgRAQej3AUHo9wEoAgBBAWo2AgAgBkEEdEEQQYzSASgCABEDACEHIAEoAgQhBAsgBEEBTgsEQANAIAcgBUEEdCIIaiIKIAEoAgwgCGoiCCkCADcCACAKIAgpAgg3AgggBUEBaiIFIARHDQALCyABKAIMIgQEQCABLQAQBEAgBARAQez3AUHs9wEoAgBBAWo2AgAgBEGQ0gEoAgARAAALCyABQQA2AgwLIAEgBzYCDCABQQE6ABAgASAGNgIIIAEoAgQhBAsgASgCDCAEQQR0aiIEIAk2AgwgBCATOAIIIAQgEjgCBCAEIBE4AgAMAgsgDyATIA+TIA0gDSAUk5UiDZSSIQ8gDiASIA6TIA2UkiEOIBAgESAQkyANlJIhDQJAIAEoAgQiBCABKAIIRw0AIAQgBEEBdEEBIAQbIgdODQBBACEFQQAhBgJ/IAcEQEHo9wFB6PcBKAIAQQFqNgIAIAdBBHRBEEGM0gEoAgARAwAhBiABKAIEIQQLIARBAU4LBEADQCAGIAVBBHQiCWoiCCABKAIMIAlqIgkpAgA3AgAgCCAJKQIINwIIIAVBAWoiBSAERw0ACwsgASgCDCIEBEAgAS0AEARAIAQEQEHs9wFB7PcBKAIAQQFqNgIAIARBkNIBKAIAEQAACwsgAUEANgIMCyABIAY2AgwgAUEBOgAQIAEgBzYCCCABKAIEIQQLIAEoAgwgBEEEdGoiBEEANgIMIAQgDzgCCCAEIA44AgQgBCANOAIADAELIBRDAAAAAF1BAXMNASAPIBMgD5MgDSANIBSTlSINlJIhDyAOIBIgDpMgDZSSIQ4gECARIBCTIA2UkiENAkAgASgCBCIEIAEoAghHDQAgBCAEQQF0QQEgBBsiBk4NAEEAIQVBACEHAn8gBgRAQej3AUHo9wEoAgBBAWo2AgAgBkEEdEEQQYzSASgCABEDACEHIAEoAgQhBAsgBEEBTgsEQANAIAcgBUEEdCIIaiIKIAEoAgwgCGoiCCkCADcCACAKIAgpAgg3AgggBUEBaiIFIARHDQALCyABKAIMIgQEQCABLQAQBEAgBARAQez3AUHs9wEoAgBBAWo2AgAgBEGQ0gEoAgARAAALCyABQQA2AgwLIAEgBzYCDCABQQE6ABAgASAGNgIIIAEoAgQhBAsgASgCDCAEQQR0aiIEQQA2AgwgBCAPOAIIIAQgDjgCBCAEIA04AgAgASABKAIEQQFqIgQ2AgQCQCAEIAEoAghHDQAgBCAEQQF0QQEgBBsiBk4NAEEAIQVBACEHAn8gBgRAQej3AUHo9wEoAgBBAWo2AgAgBkEEdEEQQYzSASgCABEDACEHIAEoAgQhBAsgBEEBTgsEQANAIAcgBUEEdCIIaiIKIAEoAgwgCGoiCCkCADcCACAKIAgpAgg3AgggBUEBaiIFIARHDQALCyABKAIMIgQEQCABLQAQBEAgBARAQez3AUHs9wEoAgBBAWo2AgAgBEGQ0gEoAgARAAALCyABQQA2AgwLIAEgBzYCDCABQQE6ABAgASAGNgIIIAEoAgQhBAsgASgCDCAEQQR0aiIEIAk2AgwgBCATOAIIIAQgEjgCBCAEIBE4AgALIAEgASgCBEEBajYCBAsgDEEBaiIMIAtGDQEgAioCCCEXIAIqAgQhFiACKgIAIRUgACgCDCEFIBQhDSATIQ8gEiEOIBEhEAwAAAsACwudAwEFfyMAQaABayIFJAACQCAAKAIMIgZFDQAgASACIAAtABAiBxsiCCgCBCEJIAIgASAHGyICKAIEIQcgBCAGNgIEIAVBkAFqIgEgBioC8AU4AgwgASAJNgIIIAEgBzYCBCABQdDzADYCACABIQYgBUHrlvjqBTYCiAEgBSACKAIMIgEpAgg3AxAgBSABKQIANwMIIAUgASkCGDcDICAFIAEpAhA3AxggBSABKQIoNwMwIAUgASkCIDcDKCAFQUBrIAEpAjg3AwAgBSABKQIwNwM4IAUgCCgCDCIBKQIINwNQIAUgASkCADcDSCAFIAEpAhA3A1ggBSABKQIYNwNgIAUgASkCIDcDaCAFIAEpAig3A3AgBSABKQIwNwN4IAUgASkCODcDgAEgBiAFQQhqIAQgAygCFCAALQAQELAEIAAtAAhFDQAgBCgCBCIAKALsBUUNACAAKALkBSIBIAQoAggoAggiAkcEQCAAIAQoAgwoAghBBGogAkEEahAfDAELIAAgAUEEaiAEKAIMKAIIQQRqEB8LIAVBoAFqJAALOgECfyAAQYz0ADYCAAJAIAAtAAhFDQAgACgCDCIBRQ0AIAAoAgQiAiABIAIoAgAoAhARAgALIAAQDgs4AQJ/IABBjPQANgIAAkAgAC0ACEUNACAAKAIMIgFFDQAgACgCBCICIAEgAigCACgCEBECAAsgAAtuACAAQYSzATYCACAAIAIoAgA2AgQgAEH80gA2AgAgACAFOgAQIAAgATYCDCAAQQA6AAggAEGM9AA2AgAgAUUEQCAAKAIEIgEgAygCCCAEKAIIIAEoAgAoAgwRBwAhASAAQQE6AAggACABNgIMCwvrAgEQfSACKgIIIgkgACoCGCIDkyAAKgIgIgogACoCECIEkyILIAEqAgQiBZQgACoCJCINIAAqAhQiB5MiBiABKgIAIgiUk5QgAioCACIOIASTIAYgASoCCCIGlCAAKgIoIg8gA5MiDCAFlJOUIAIqAgQiECAHkyAMIAiUIAsgBpSTlJKSIQsgCSAAKgIIIgyTIAQgACoCACIEkyIRIAWUIAcgACoCBCIHkyISIAiUk5QgDiAEkyASIAaUIAMgDJMiAyAFlJOUIBAgB5MgAyAIlCARIAaUk5SSkiEDQQEhAAJAAkAgCSAPkyAEIAqTIgkgBZQgByANkyIEIAiUk5QgDiAKkyAEIAaUIAwgD5MiCiAFlJOUIBAgDZMgCiAIlCAJIAaUk5SSkiIFQwAAAABeQQFzDQAgA0MAAAAAXkEBcw0AIAtDAAAAAF4NAQsgA0MAAAAAXyALQwAAAABfcSAFQwAAAABfcSEACyAAC7MHAgR/En0jAEEgayIGJAAgACgCBCIHKgIcIAcqAgyUIhQgBZIhCiABKgIIIgsgACgCCCIHQUBrKgIAIgWTIAcqAkggByoCOCIMkyISIAcqAlwgByoCPCIRkyIOlCAHKgJMIBGTIg0gByoCWCAMkyIPlJMiEEMAAIA/IBAgEJQgDSAHKgJgIAWTIhCUIAcqAlAgBZMiDSAOlJMiBSAFlCANIA+UIBIgEJSTIg0gDZSSkpGVIg+UIhCUIAEqAgAiDiAMkyAFIA+UIhKUIAEqAgQiDCARkyANIA+UIhGUkpIiBUMAAAAAXUEBc0UEQCAQjCEQIBGMIREgEowhEiAFjCEFCwJAIAUgCl1BAXMNACAGIAEpAgg3AxggBiABKQIANwMQIAZBADYCDCAGIBA4AgggBiAROAIEIAYgEjgCAAJAIAdBOGogBiAGQRBqEOMMBEAgCyAFIBCUkyETIAwgBSARlJMhFSAOIAUgEpSTIRYgCiAKlCEXDAELIAcgBygCACgCZBEBAEEBSA0BIAogCpQhF0EAIQcDQCAAKAIIIgggByAGQRBqIAYgCCgCACgCaBEEAEMAAAAAIQoCQCABKgIAIAYqAhAiGJMiBSAGKgIAIBiTIg6UIAEqAgQgBioCFCIZkyIMIAYqAgQgGZMiDZSSIAEqAgggBioCGCIakyILIAYqAgggGpMiD5SSIhtDAAAAAF5BAXMNACAbIA4gDpQgDSANlJIgDyAPlJIiCl1BAXNFBEAgCyAPIBsgCpUiCpSTIQsgDCANIAqUkyEMIAUgDiAKlJMhBQwBCyALIA+TIQsgDCANkyEMIAUgDpMhBUMAAIA/IQoLIAUgBZQgDCAMlJIgCyALlJIgF11BAXNFBEAgGCAOIAqUkiEWIBkgDSAKlJIhFUEBIQkgGiAPIAqUkiETCyAHQQFqIgcgACgCCCIIIAgoAgAoAmQRAQBIDQALQQAhCCAJRQ0BIAEqAgghCyABKgIEIQwgASoCACEOCyAOIBaTIgUgBZQgDCAVkyIMIAyUkiALIBOTIgsgC5SSIgogF11BAXMNAAJAIApDAAAANF5BAXNFBEAgA0EANgIMIAMgC0MAAIA/IAqRIgqVIguUOAIIIAMgDCALlDgCBCADIAUgC5Q4AgAgFCAKkyEUDAELIANBADYCDCADIBA4AgggAyAROAIEIAMgEjgCAAsgAkEANgIMIAIgEzgCCCACIBU4AgQgAiAWOAIAIAQgFIw4AgBBASEICyAGQSBqJAAgCAsaACAAQXxqIgAgASACIAMgACgCACgCCBEEAAsJACAAQXxqEA4LBwAgAEF8agsVACAAIAEgAiADIAAoAgAoAggRBAALtwYBFX0jAEHgAGsiAiQAIAAqAkwhBCAAKgIkIQUgACoCICEJIAAqAlAhCiAAKgI0IQ0gACoCLCEOIAAqAjAhDyAAKgJUIQsgACoCRCEMIAAqAjwhECAAQUBrKgIAIREgACoCHCESIAEqAgghBiABKgIAIQcgASoCBCEIIAJBADYCXCACIAsgByAQlCAIIBGUkiAGIAyUkpIiEzgCWCACIAogByAOlCAIIA+UkiAGIA2UkpIiFDgCVCACIAQgByASlCAIIAmUkiAGIAWUkpIiGDgCUCABKgIUIQYgASoCGCEHIAEqAhAhCCACQQA2AkwgAiALIBAgCJQgESAGlJIgDCAHlJKSIhU4AkggAiAKIA4gCJQgDyAGlJIgDSAHlJKSIhY4AkQgAiAEIBIgCJQgCSAGlJIgBSAHlJKSIhc4AkAgASoCJCEGIAEqAighByABKgIgIQggAkEANgI8IAIgCyAQIAiUIBEgBpSSIAwgB5SSkiILOAI4IAIgCiAOIAiUIA8gBpSSIA0gB5SSkiIKOAI0IAIgBCASIAiUIAkgBpSSIAUgB5SSkiIEOAIwIAJBADYCLCACIBMgFZIgC5JDq6qqPpQiDTgCKCACIBQgFpIgCpJDq6qqPpQiDjgCJCACIBggF5IgBJJDq6qqPpQiDzgCICAAKAIIIgEgASgCACgCMBEBAEGAgAFxBEAgAioCUCEFIAJCADcDGCACQoCAgPyDgIDAPzcDECAAKAIIIQEgAkEANgIMIAIgFyAFkyIJIAogFJMiCpQgFiAUkyIMIAQgBZMiBZSTIgRDAACAPyAEIASUIAwgCyATkyILlCAVIBOTIgwgCpSTIgQgBJQgDCAFlCAJIAuUkyIFIAWUkpKRlSIJlCANkjgCCCACIA4gBSAJlJI4AgQgAiAPIAQgCZSSOAIAIAEgAkEgaiACIAJBEGogASgCACgCCBEEAAsgACgCCCIDIAJB0ABqIAJBQGsgAEEMaiIBIAMoAgAoAggRBAAgACgCCCIDIAJBQGsgAkEwaiABIAMoAgAoAggRBAAgACgCCCIAIAJBMGogAkHQAGogASAAKAIAKAIIEQQAIAJB4ABqJAAL5wYDBn8BfhV9IwBBwAFrIgQkACABKgIIIAOUIAIqAggiDpIhDyABKgIEIAOUIAIqAgQiFJIhECABKgIAIAOUIAIqAgAiFZIhEQJ/IAAoAgQoAuQFIgYgACgCCCgCCCIIRiIHRQRAIBEgACgCDCgCCCIFKgI0kyINIAUqAgyUIBAgBSoCOJMiCyAFKgIclJIgDyAFKgI8kyIMIAUqAiyUkiESIA0gBSoCCJQgCyAFKgIYlJIgDCAFKgIolJIhEyANIAUqAgSUIAsgBSoCFJSSIAwgBSoCJJSSIQ0gCAwBCyARIAYqAjSTIg0gBioCDJQgECAGKgI4kyILIAYqAhyUkiAPIAYqAjyTIgwgBioCLJSSIRIgDSAGKgIIlCALIAYqAhiUkiAMIAYqAiiUkiETIA0gBioCBJQgCyAGKgIUlJIgDCAGKgIklJIhDSAAKAIMKAIICyIFKgIUIRYgBSoCJCEXIAUqAighGCAFKgIIIRkgBSoCGCEaIAUqAiwhGyAFKgI8IRwgBSoCDCELIAUqAjQhDCAFKgIcIR0gBSoCOCEeIAUqAgQhHyAEQQA2AiQgBCALIBUgDJMiC5QgHSAUIB6TIgyUkiAbIA4gHJMiDpSSOAIgIAQgCyAZlCAMIBqUkiAOIBiUkjgCHCAEQQA2AhQgBCASOAIQIAQgEzgCDCAEIA04AgggBCALIB+UIAwgFpSSIA4gF5SSOAIYIAQgASkCCDcDUCABKQIAIQogBEIANwOIASAEQgA3A5ABIARCADcDmAEgBCAQOAI8IARBQGsgDzgCACAEQQA2AkQgBCAKNwNIIARCADcDgAEgBEEAOgB8IARBADYCeCAEQQA2AmQgBEIANwJcIAQgAzgCWCAEIBE4AjggBCACKQIINwMwIAQgAikCADcDKAJ/IAdFBEAgAEEYaiEHIABBEGohAiAAQRRqIQUgAEEcagwBCyAAQRxqIQcgAEEUaiECIABBEGohBSAAQRhqCyEBIAUoAgAhBSACKAIAIQIgASgCACEBIAQgBygCACIHNgJ0IAQgATYCcCAEIAI2AmwgBCAFNgJoIAAoAiAiCSAEQQhqIABBDEEIIAYgCEciCBtqKAIAIAUgASAAQQhBDCAIG2ooAgAgAiAHIAkoAgAoAgwRKgAaIARBwAFqJAAL1QIBA38jAEHgAGsiAiQAAkAgASgCACIBIAAoAgRGDQAgACgCDCIDIAEoArwBIAMoAgAoAggRAwBFDQAgACgCBCIDKALAASEEIAJCfzcDWCACIANBBGo2AlQgAiADNgJQIAIgBDYCTCACQQA2AkggASgCwAEhAyACQn83A0AgAiABQQRqNgI8IAIgATYCOCACIAM2AjQgAkEANgIwIAAoAggoAhgiASACQcgAaiACQTBqQQAgASgCACgCCBEKACIBRQ0AIAAoAgwhBCACQQhqIgMgAkEwajYCDCADIAJByABqNgIIIANBADYCBCADQbTgADYCACACIAQ2AiggAkGs8gA2AgggASACQcgAaiACQTBqIAAoAghBHGogAyABKAIAKAIIEQkAIAEgASgCACgCABEBABogACgCCCgCGCIAIAEgACgCACgCPBECAAsgAkHgAGokAEEBC6wBAgV/AX0jAEEgayICJAACQCAAKAK4ASIDKgIEQwAAAABbDQBBASEEIAMgASgCACIBKAK8ASADKAIAKAIIEQMARQ0AIAAqArwBIQcgACgCuAEhAyAAKALAASEFIAEoAsABIQYgAkJ/NwMYIAIgAUEEajYCFCACIAE2AhAgAiAGNgIMIAJBADYCCCAFIABBJGogAEHkAGogAkEIaiADIAcQwQILIAJBIGokACAEC5cBAQR/IwBBIGsiAiQAAkAgACgC2AEiAyoCBEMAAAAAWw0AQQEhBCADIAEoAgAiASgCvAEgAygCACgCCBEDAEUNACAAKALYASEDIAEoAsABIQUgAkJ/NwMYIAIgAUEEajYCFCACIAE2AhAgAiAFNgIMIAJBADYCCCAAQcQAaiAAQYQBaiACQQhqIAMQ4AELIAJBIGokACAEC2ECAn8BfSMAQRBrIgMkACADQX82AgggAyAAKAIQNgIMIAEoAgRFBEAgASADQQhqNgIECyAAKAIMIgQgASACIAQoAgAoAgwRDQAhBSAAIAAoAgwoAgQ2AgQgA0EQaiQAIAULFgAgACgCDCIAIAEgACgCACgCCBEDAAuTAQEBfyMAQUBqIgYkACAGIAU2AjwgBiAENgI4IAAoAtQBIgQqAgQgA2BBAXNFBEAgBiAAKALYATYCCCAGIAZBOGo2AgwgBiABKQIINwMYIAYgASkCADcDECAGIAIpAgg3AyggBiACKQIANwMgIAYgAzgCMCAEIAZBCGpBACAEKAIAKAIMEQ0AIQMLIAZBQGskACADC5MBAQF/IwBBQGoiBiQAIAYgBTYCPCAGIAQ2AjggACgC1AEiBCoCBCADYEEBc0UEQCAGIAAoAtgBNgIIIAYgBkE4ajYCDCAGIAEpAgg3AxggBiABKQIANwMQIAYgAikCCDcDKCAGIAIpAgA3AyAgBiADOAIwIAQgBkEIakEBIAQoAgAoAgwRDQAhAwsgBkFAayQAIAMLYQICfwF9IwBBEGsiAyQAIANBfzYCCCADIAAoAhg2AgwgASgCBEUEQCABIANBCGo2AgQLIAAoAhQiBCABIAIgBCgCACgCDBENACEFIAAgACgCFCgCBDYCBCADQRBqJAAgBQsWACAAKAIUIgAgASAAKAIAKAIIEQMAC6AFAgN/GH0jAEGAAWsiAiQAIAAoAggoAhggASgCJCIDQdAAbGoiASgCQCEEIAEqAiAhDiABKgIAIQ8gASoCECEQIAEqAjghESABKgI0IRIgASoCMCETIAEqAiQhFCABKgIUIRUgASoCBCEWIAEqAighFyABKgIYIRggASoCCCEZIAAoAgwiASoCNCEaIAEqAjghGyABKgIYIQUgASoCFCEGIAEqAighByABKgIkIQggASoCMCEcIAEqAgghCSABKgIAIQogASoCBCELIAEqAhAhDCABKgIgIQ0gAkEANgJ8IAJBADYCbCACQQA2AlwgAiAZIA2UIBggCJSSIBcgB5SSOAJoIAIgFiANlCAVIAiUkiAUIAeUkjgCZCACIBkgDJQgGCAGlJIgFyAFlJI4AlggAiAWIAyUIBUgBpSSIBQgBZSSOAJUIAIgGyANIBOUIAggEpSSIAcgEZSSkjgCeCACIBogDCATlCAGIBKUkiAFIBGUkpI4AnQgAkEANgJMIAIgCiAZlCALIBiUkiAJIBeUkjgCSCACIAogFpQgCyAVlJIgCSAUlJI4AkQgAiAPIAqUIBAgC5SSIA4gCZSSOAJAIAIgHCAKIBOUIAsgEpSSIAkgEZSSkjgCcCACIA8gDZQgECAIlJIgDiAHlJI4AmAgAiAPIAyUIBAgBpSSIA4gBZSSOAJQIAAoAgQhASACIAM2AjwgAkF/NgI4IAIgATYCMCACIAQ2AiwgAkEANgIoIAIgAkFAazYCNCAAKAIYIQEgAkKBgPz/DzcCFCACQoCAgPwDNwIMIAIgAzYCICACIAE2AhwgAkHk6gA2AgggAiABKAIENgIMIAIgASgCEDYCGCAAKAIQIAAoAhQgAkEoaiACQQhqEOABIAJBgAFqJAALIwAgASABKAIAKAIgEQAAIAAgARDAAiABIAEoAgAoAiQRAAALrQYBCH8CQAJAIAAoAjAiB0F/aiABKAIAIgUgBUEPdEF/c2oiA0EKdSADc0EJbCIDQQZ1IANzIgMgA0ELdEF/c2oiA0EQdSADc3EiCCAAKAIETw0AIAAoAgwgCEECdGooAgAiBEF/Rg0AIAAoAkghAwNAIAMgBEEDdGooAgAgBUYNAiAAKAIgIARBAnRqKAIAIgRBf0cNAAsLIAAoAiwiCSEDAkAgByAJRw0AIAciAyADQQF0QQEgAxsiCk4NACAKBH9B6PcBQej3ASgCAEEBajYCACAKQQJ0QRBBjNIBKAIAEQMAIQYgACgCLAUgBwsiA0EBTgRAQQAhBANAIAYgBEECdCIFaiAAKAI0IAVqKAIANgIAIARBAWoiBCADRw0ACwsgACgCNCIFBEAgAC0AOARAIAUiAwRAQez3AUHs9wEoAgBBAWo2AgAgA0GQ0gEoAgARAAALIAAoAiwhAwsgAEEANgI0CyAAIAY2AjQgACAKNgIwIABBAToAOAsgACgCNCADQQJ0aiACKAIANgIAIAAgA0EBajYCLAJAIABBQGsoAgAiAyAAKAJERw0AIAMgA0EBdEEBIAMbIgVODQACQCAFRQRAQQAhBgwBC0Ho9wFB6PcBKAIAQQFqNgIAIAVBA3RBEEGM0gEoAgARAwAhBiAAKAJAIQMLIANBAU4EQEEAIQQDQCAGIARBA3QiAmogACgCSCACaikCADcCACAEQQFqIgQgA0cNAAsLIAAoAkgiAgRAIAAtAEwEQCACBEBB7PcBQez3ASgCAEEBajYCACACQZDSASgCABEAAAsLIABBADYCSAsgACAGNgJIIAAgBTYCRCAAQQE6AEwgACgCQCEDCyAAKAJIIANBA3RqIAEpAgA3AgAgACAAKAJAQQFqNgJAIAcgACgCMEgEQCAAEIYFIAAoAjBBf2ogASgCACIBIAFBD3RBf3NqIgFBCnUgAXNBCWwiAUEGdSABcyIBIAFBC3RBf3NqIgFBEHUgAXNxIQgLIAAoAiAgCUECdGogACgCDCAIQQJ0aiIAKAIANgIAIAAgCTYCAA8LIAAoAjQgBEECdGogAigCADYCAAvIHAILfxh9IwBBkAFrIgQkACAAIAAoAgAoAhQRAQAiBSABQwAAgD8gBSgCACgCOBELAAJAAkAgAigCBCIFQR9LDQACQAJAAkACQAJAAkACQAJAIAVBAWsOHwgICAgICAgCAwQFCAYICAgICAgICAgICAgICAcICAABCyACKAIQIgdBAUgNCANAIAIoAhggB0F/aiIFQdAAbGoiBigCQCEIIAYqAjghFyAGKgIwIRggBioCNCEbIAYqAiAhHCAGKgIAIR0gBioCECEeIAYqAiQhICAGKgIEIRUgBioCFCEfIAYqAighISAGKgIIISIgBioCGCEjIAEqAjAhJCABKgI0ISUgASoCOCEmIAEqAgghDyABKgIAIRAgASoCBCERIAEqAhghEiABKgIQIRMgASoCFCEUIAEqAighGSABKgIgIRogASoCJCEWIARBADYCPCAEQQA2AiwgBEEANgIcIARBADYCDCAEICIgGpQgIyAWlJIgISAZlJI4AiggBCAVIBqUIB8gFpSSICAgGZSSOAIkIAQgHSAalCAeIBaUkiAcIBmUkjgCICAEICIgE5QgIyAUlJIgISASlJI4AhggBCAVIBOUIB8gFJSSICAgEpSSOAIUIAQgHSATlCAeIBSUkiAcIBKUkjgCECAEICIgEJQgIyARlJIgISAPlJI4AgggBCAVIBCUIB8gEZSSICAgD5SSOAIEIAQgHSAQlCAeIBGUkiAcIA+UkjgCACAEICYgGCAalCAbIBaUkiAXIBmUkpI4AjggBCAlIBggE5QgGyAUlJIgFyASlJKSOAI0IAQgJCAYIBCUIBsgEZSSIBcgD5SSkjgCMCAAIAQgCCADIAAoAgAoAhwRBAAgB0EBSiEGIAUhByAGDQALDAgLIAQgAikCJDcDCCAEIAIpAhw3AwAgAiACKAIAKAIwEQYAIQ8gAiACKAIAKAIwEQYAIRAgBCACIAIoAgAoAjARBgAgBCoCCJIiETgCCCAEIA8gBCoCAJIiDzgCACAEIBAgBCoCBJIiEDgCBCAAIAAoAgAoAhQRAQAhACAEQQA2AowBIAQgEYw4AogBIAQgEIw4AoQBIAQgD4w4AoABIAAgBEGAAWogBCABIAMgACgCACgCSBEJAAwHCyACIAIoAgAoAjARBgAhDyAAIAAoAgAoAhQRAQAiACAPIAEgAyAAKAIAKAIQEScADAYLIAIoAlwiBUEBSA0FA0AgAigCZCAFQX9qIgZBBHRqIgcqAgghDyAHKgIAIRAgByoCBCERIAAgACgCACgCFBEBACEHIAIoAnggBkECdGoqAgAhHCABKgIwIR0gASoCNCEeIAEqAjghICABKgIIIRIgASoCACETIAEqAgQhFCABKgIYIRkgASoCECEaIAEqAhQhFiABKgIoIRcgASoCICEYIAEqAiQhGyAEQQA2AjwgBEEANgIsIARBADYCHCAEQQA2AgwgBCAXIBhDAAAAAJQiFSAbQwAAAACUIh+SkjgCKCAEIBUgG5IgF0MAAAAAlCIVkjgCJCAEIBggH5IgFZI4AiAgBCAZIBpDAAAAAJQiFSAWQwAAAACUIh+SkjgCGCAEIBUgFpIgGUMAAAAAlCIVkjgCFCAEIBogH5IgFZI4AhAgBCASIBNDAAAAAJQiFSAUQwAAAACUIh+SkjgCCCAEIBUgFJIgEkMAAAAAlCIVkjgCBCAEIBMgH5IgFZI4AgAgBCAgIBAgGJQgESAblJIgDyAXlJKSOAI4IAQgHiAQIBqUIBEgFpSSIA8gGZSSkjgCNCAEIB0gECATlCARIBSUkiAPIBKUkpI4AjAgByAcIAQgAyAHKAIAKAIQEScAIAVBAUohByAGIQUgBw0ACwwFCyACQRxqIgUgAigCNCICQQJ0aioCACEPIAUgAkECakEDb0ECdGoqAgAhECAAIAAoAgAoAhQRAQAiACAQIA8gAiABIAMgACgCACgCTBEfAAwECyACKAJEIQUgAioCOCEPIAIqAjwhECAAIAAoAgAoAhQRAQAiACAPIBAgBSABIAMgACgCACgCVBEfAAwDCyACKAI0IQUgAiACKAIAKAJcEQYAIQ8gBCACKQIkNwMIIAQgAikCHDcDACACIAIoAgAoAjARBgAhECACIAIoAgAoAjARBgAhESAEIAIgAigCACgCMBEGACAEKgIIkjgCCCAEIBAgBCoCAJI4AgAgBCARIAQqAgSSOAIEIAQgBUECdGoqAgAhECAAIAAoAgAoAhQRAQAiACAPIBAgBSABIAMgACgCACgCUBEfAAwCCyACQUBrKgIAIQ8gACAAKAIAKAIUEQEAIgAgAkEwaiAPIAEgAyAAKAIAKAJYETgADAELAkAgBUEGSg0AIAIoAjQiCARAIAgoAhxBAUgNAQNAQwAAAAAhEQJAIAtBJGwiDCAIKAIkaiIFKAIEIgpFBEBDAAAAACEPQwAAAAAhEAwBC0MAAAAAIQ9DAAAAACEQIApBAUgNACAFKAIMIgkgCkECdGpBfGooAgAhBUEAIQcDQCAJIAdBAnRqKAIAIgZBBHQiDSAIKAIQaiIJKgIAISEgCSoCBCEiIAkqAgghIyAAIAAoAgAoAhQRAQAhCSAIKAIQIg4gBUEEdGoiBSoCCCESIAUqAgAhEyAFKgIEIRQgASoCMCEZIAEqAgghGiABKgIAIRYgASoCBCEXIAEqAjQhGCABKgIYIRsgASoCECEcIAEqAhQhHSABKgI4IR4gASoCKCEgIAEqAiAhFSABKgIkIR8gBEEANgIMIAQgHiATIBWUIBQgH5SSIBIgIJSSkjgCCCAEIBggEyAclCAUIB2UkiASIBuUkpI4AgQgBCAZIBMgFpQgFCAXlJIgEiAalJKSOAIAIA0gDmoiBSoCCCESIAUqAgAhEyAFKgIEIRQgBEEANgKMASAEIB4gFSATlCAfIBSUkiAgIBKUkpI4AogBIAQgGCAcIBOUIB0gFJSSIBsgEpSSkjgChAEgBCAZIBYgE5QgFyAUlJIgGiASlJKSOAKAASAJIAQgBEGAAWogAyAJKAIAKAIIEQQAIBAgI5IhECAPICKSIQ8gESAhkiERIAdBAWoiByAIKAIkIAxqIgUoAgRODQEgBSgCDCEJIAYhBQwAAAsACyAAIAAoAgAoAhQRAQAiBSAFKAIAKAIwEQEAQYCAAXEEQCAEQgA3AwggBEKAgID8g4CAwD83AwAgCCgCJCAMaiIFKgIcIRUgBSoCFCEfIAUqAhghISAAIAAoAgAoAhQRAQAhBSABKgIwIRIgASoCCCETIAEqAgAhFCABKgIEIRkgASoCNCEaIAEqAhghFiABKgIQIRcgASoCFCEYIAEqAjghGyABKgIoIRwgASoCICEdIAEqAiQhHiAEQQA2AowBIAQgGyAdQwAAgD8gCrKVIiAgEZQiEZQgHiAgIA+UIg+UkiAcICAgEJQiEJSSkjgCiAEgBCAaIBEgF5QgDyAYlJIgECAWlJKSOAKEASAEIBIgESAUlCAPIBmUkiAQIBOUkpI4AoABIARBADYCfCAEIBsgHSARIB+SIhGUIB4gDyAhkiIPlJIgHCAQIBWSIhCUkpI4AnggBCAaIBEgF5QgDyAYlJIgECAWlJKSOAJ0IAQgEiARIBSUIA8gGZSSIBAgE5SSkjgCcCAFIARBgAFqIARB8ABqIAQgBSgCACgCCBEEAAsgC0EBaiILIAgoAhxIDQALDAELIAIgAigCACgCZBEBAEEBSA0AQQAhBQNAIAIgBSAEIARBgAFqIAIoAgAoAmgRBAAgASoCMCEPIAEqAgghECABKgIAIREgASoCBCESIAEqAjQhEyABKgIYIRQgASoCECEZIAEqAhQhGiABKgI4IRYgASoCKCEXIAEqAiAhGCABKgIkIRsgBEEANgJ8IAQgFiAYIAQqAgAiHJQgGyAEKgIEIh2UkiAXIAQqAggiHpSSkjgCeCAEIBMgHCAZlCAdIBqUkiAeIBSUkpI4AnQgBCAPIBwgEZQgHSASlJIgHiAQlJKSOAJwIARBADYCbCAEIBYgGCAEKgKAASIWlCAbIAQqAoQBIhiUkiAXIAQqAogBIheUkpI4AmggBCATIBkgFpQgGiAYlJIgFCAXlJKSOAJkIAQgDyARIBaUIBIgGJSSIBAgF5SSkjgCYCAAIAAoAgAoAhQRAQAiBiAEQfAAaiAEQeAAaiADIAYoAgAoAggRBAAgBUEBaiIFIAIgAigCACgCZBEBAEgNAAsLIAIoAgQiBUFrakEITQR/IARC65b46gU3A4gBIARC65b46rXtgq/dADcDgAEgBELrlvjqDTcDeCAEQuuW+Oq97YKvXTcDcCAEIAAgACgCACgCFBEBADYCCCAEQYjzADYCBCAEQfDyADYCACAEIAMpAgg3AhQgBCADKQIANwIMIAQgASkCCDcCJCAEIAEpAgA3AhwgBCABKQIQNwIsIAQgASkCGDcCNCAEIAEpAig3AkQgBCABKQIgNwI8IAQgASkCMDcCTCAEIAEpAjg3AlQgAiAEIARB8ABqIARBgAFqIAIoAgAoAkARBAAgAigCBAUgBQtBA0cNACAEQuuW+OoFNwOIASAEQuuW+Oq17YKv3QA3A4ABIARC65b46g03A3ggBELrlvjqve2Cr103A3AgBCAAIAAoAgAoAhQRAQA2AgggBEGI8wA2AgQgBEHw8gA2AgAgBCADKQIINwIUIAQgAykCADcCDCAEIAEpAgg3AiQgBCABKQIANwIcIAQgASkCEDcCLCAEIAEpAhg3AjQgBCABKQIoNwJEIAQgASkCIDcCPCAEIAEpAjA3AkwgBCABKQI4NwJUIAIoAlwiACAEQQRyIARB8ABqIARBgAFqIAAoAgAoAggRBAALIARBkAFqJAALkQIBAn8jAEHgAGsiBCQAIAEoAsABIQUgBEJ/NwNYIAQgAUEEajYCVCAEIAE2AlAgBCAFNgJMIARBADYCSCACKALAASEBIARCfzcDQCAEIAJBBGo2AjwgBCACNgI4IAQgATYCNCAEQQA2AjAgACgCGCIBIARByABqIARBMGpBACABKAIAKAIIEQoAIgEEQCAEQQhqIgIgBEEwajYCDCACIARByABqNgIIIAJBADYCBCACQbTgADYCACAEIAM2AiggBEGs8gA2AgggASAEQcgAaiAEQTBqIABBHGogAiABKAIAKAIIEQkAIAEgASgCACgCABEBABogACgCGCIAIAEgACgCACgCPBECAAsgBEHgAGokAAtyAQJ/IwBBMGsiAyQAIAEoAsABIgQgAUEEaiADQSBqIANBEGogBCgCACgCCBEEACADIAI2AgwgAyABNgIEIANB8PEANgIAIAMgADYCCCAAKAJEIgAgA0EgaiADQRBqIAMgACgCACgCHBEEACADQTBqJAALxQQDAX8BfgZ9IwBBgAJrIgQkACAEQYDxADYCICAEIAEpAgg3AkwgBCABKQIANwJEIAQgAikCCDcCXCACKQIAIQUgBEIANwNoIARCADcDcCAEQgA3AnwgBEGAgID8AzYCeCAEQgA3AoQBIARCgICA/AM3AowBIAQgBTcCVCAEIAM2AvgBIARBgICA/AM2AmQgBCAANgL0ASAEIAQpAkQ3ApQBIAQgBCkCTDcCnAEgBEGAgID8AzYCpAEgBEIANwOwASAEQgA3A6gBIARBgICA/AM2ArgBIARCADcCxAEgBEIANwK8ASAEQoCAgPwDNwLMASAEIAIpAgg3AtwBIAQgAikCADcC1AEgBENrC15dQwAAgD8gAioCCCABKgIIkyIGQwAAgD8gAioCACABKgIAkyIIIAiUIAIqAgQgASoCBJMiByAHlJIgBiAGlJKRlSIGlCIJlSAJQwAAAABbGyIKOAIsIARDawteXUMAAIA/IAcgBpQiB5UgB0MAAAAAWxsiCzgCKCAEIApDAAAAAF02AjwgBCALQwAAAABdNgI4IARDawteXUMAAIA/IAggBpQiBpUgBkMAAAAAWxsiCDgCJCAEIAhDAAAAAF02AjQgBCAGIAQqAlQgBCoCRJOUIAcgBCoCWCAEKgJIk5SSIAkgBCoCXCAEKgJMk5SSOAJAIAAoAkQhACAEQgA3AxggBEIANwMQIARCADcDCCAEQgA3AwAgACABIAIgBEEgaiAEQRBqIAQgACgCACgCGBEMACAEQYACaiQAC0kBAX8jAEEgayIIJAAgCEJ/NwMYIAggBTYCFCAIIAM2AhAgCCAENgIMIAhBADYCCCAAIAEgAiAIQQhqIAYgBxDBAiAIQSBqJAALRQEBfyMAQSBrIgYkACAGQn83AxggBiAENgIUIAYgAjYCECAGIAM2AgwgBkEANgIIIAAgASAGQQhqIAUQ4AEgBkEgaiQAC2MBAn9BveUAEBYgACAAKAIAKAIIEQAAIAAgACgCACgCDBEAACAAKAIYIQFB3+UAEBYgAQRAIAEgACgCRCICIAIoAgAoAiQRAQAgAEEcaiAAKAIYIAEoAgAoAiARBAALEBMQEwsjAQF/QaPlABAWIAAoAkQiASAAKAIYIAEoAgAoAiARAgAQEwttAQR/QZflABAWIAAoAggiAkEBTgRAA0AgACgCECABQQJ0aigCACEDAkACQCAALQBMDQAgAygC2AFBfmoiBEEDSw0AIARBAWsOAgAAAQsgACADELUEIAAoAgghAgsgAUEBaiIBIAJIDQALCxATCwkAIAAQwwIQDguLAQAgAEGk4wA2AgAgAEEBOgBMIABBADYCSCAAIAI2AkQgAEIANwIcIAAgATYCGCAAQQE6ABQgAEEANgIQIABBQGtBADYCACAAQQA6ADwgAEGKro/pAzYCOCAAQQE6ADYgAEGAAjsBNCAAQQA2AjAgAEEBOgAsIABCgYCAgICAgMA/NwIkIABCADcCCAu6AwIDfwV9IwBBoAVrIgQkACAEQbgEahDeASEFIARBATYCvAQgBEH8MDYCuAQgBCABKQIINwP4BCAEIAEpAgA3A/AEIAQgASkCGDcDiAUgBCABKQIQNwOABSAEIAEpAig3A5gFIAQgASkCIDcDkAUgBCAAKALMATYC5AQgBEEAOgCcBCAEQZfuxsYDNgKEBCAEQaDOADYCyAEgACgCBCEGIARBsAFqIgFBADYCFCABIARBuARqNgIQIAEgBjYCDCABIARByAFqNgIIIAEgBEHQAWo2AgQgAUHg4QA2AgAgBEG4MDYCACAEQoCAgPwDNwKkASAEIAAoAtABNgKsAQJAIAEgAEEIaiAAQcgAaiAAQYgBaiIBIAEgBBC4BEUNACAEKgKEASIIIAiUIAQqAogBIgkgCZSSIAQqAowBIgcgB5SSIgpDF7fROF5BAXMNACAEKgKkASILIAAqAsgBXUEBcw0AIAQgB0MAAIA/IAqRlSIHlDgCjAEgBCAJIAeUOAKIASAEIAggB5Q4AoQBIAAgBEGEAWogBEGUAWogCyACIAMgACgCACgCDBExABoLIAUQYBogBEGgBWokAAvuBQIBfxR9IwBBIGsiBCQAIAEqAhghDyABKgIoIRcgASoCJCEQIAEqAhQhCSABKgIIIQogASoCECERIAEqAgQhDCABKgIgIRIgASoCACENIARBADYCHCAEIBEgDZMiBiAQIAyTIgiUIAkgDJMiByASIA2TIg6UkyIFOAIYIAQgDyAKkyILIA6UIAYgFyAKkyIOlJMiBjgCFCAEIAcgDpQgCyAIlJMiCDgCEAJAIAggACoCBCITlCAGIAAqAggiC5SSIAUgACoCDCIUlJIgCiAFlCANIAiUIAwgBpSSkiIHkyIOIAggACoCFCIWlCAGIAAqAhgiFZSSIAUgACoCHCIYlJIgB5MiB5RDAAAAAGANACAOQwAAAABfQQFzRUEAIAAoAiQiAUEBcRsNACAOIA4gB5OVIgcgACoCKF1BAXMNACAFIAkgFSAHlCALQwAAgD8gB5MiC5SSIhWTIgkgDSAWIAeUIBMgC5SSIhOTIg2UIAwgFZMiDCARIBOTIhGUk5QgCCAMIA8gGCAHlCAUIAuUkiILkyIPlCAKIAuTIgogCZSTlCAGIAogEZQgDyANlJOUkpIgBSAFlCAIIAiUIAYgBpSSkiIWQxe30biUIhRgQQFzDQAgBSAQIBWTIhAgEZQgCSASIBOTIhKUk5QgCCAJIBcgC5MiCZQgDyAQlJOUIAYgDyASlCAJIBGUk5SSkiAUYEEBcw0AIAUgDCASlCAQIA2Uk5QgCCAQIAqUIAkgDJSTlCAGIAkgDZQgCiASlJOUkpIgFGBBAXMNACAEIAVDAACAPyAWkZUiBZQiCjgCGCAEIAYgBZQiBjgCFCAEIAggBZQiBTgCEAJAIA5DAAAAAF9BAXMNACABQQJxDQAgBEEANgIMIAQgCow4AgggBCAGjDgCBCAEIAWMOAIAIAAgACAEIAcgAiADIAAoAgAoAgwRMgA4AigMAQsgACAAIARBEGogByACIAMgACgCACgCDBEyADgCKAsgBEEgaiQAC0cAIAAqAiQgA15BAXNFBEAgAEEBOgAoIAAgASkCADcCBCAAIAEpAgg3AgwgACACKQIANwIUIAAgAikCCDcCHCAAIAM4AiQLCxAAIAAgAjYCHCAAIAE2AhQLEAAgACACNgIYIAAgATYCEAvpCgMHfwF+FX0jAEHAAWsiBCQAAkAgACgCBCoC8AUgA10NACABKgIIIAOUIAIqAggiEpIhDiABKgIEIAOUIAIqAgQiFZIhECABKgIAIAOUIAIqAgAiFpIhEQJ/IAAoAgQiBygC5AUiBiAAKAIIKAIIIglGIghFBEAgESAAKAIMKAIIIgUqAjSTIgwgBSoCDJQgECAFKgI4kyINIAUqAhyUkiAOIAUqAjyTIg8gBSoCLJSSIRMgDCAFKgIIlCANIAUqAhiUkiAPIAUqAiiUkiEUIAwgBSoCBJQgDSAFKgIUlJIgDyAFKgIklJIhDCAJDAELIBEgBioCNJMiDCAGKgIMlCAQIAYqAjiTIg0gBioCHJSSIA4gBioCPJMiDyAGKgIslJIhEyAMIAYqAgiUIA0gBioCGJSSIA8gBioCKJSSIRQgDCAGKgIElCANIAYqAhSUkiAPIAYqAiSUkiEMIAAoAgwoAggLIgUqAhQhFyAFKgIkIRggBSoCKCEZIAUqAgghGiAFKgIYIRsgBSoCLCEcIAUqAjwhHSAFKgIMIQ0gBSoCNCEPIAUqAhwhHiAFKgI4IR8gBSoCBCEgIARBADYCJCAEIA0gFiAPkyINlCAeIBUgH5MiD5SSIBwgEiAdkyISlJI4AiAgBCANIBqUIA8gG5SSIBIgGZSSOAIcIARBADYCFCAEIBM4AhAgBCAUOAIMIAQgDDgCCCAEIA0gIJQgDyAXlJIgEiAYlJI4AhggBCABKQIINwNQIAEpAgAhCyAEQgA3A4gBIARCADcDkAEgBEIANwOYASAEIBA4AjwgBEFAayAOOAIAIARBADYCRCAEIAs3A0ggBEIANwOAASAEQQA6AHwgBEEANgJ4IARBADYCZCAEQgA3AlwgBCADOAJYIAQgETgCOCAEIAIpAgg3AzAgBCACKQIANwMoIAcgBEEIahDhDSEFIAQgACgCCCgCCCIBKgLgASAAKAIMKAIIIgIqAuABlEMAACDBl0MAACBBljgCXCAEIAEqAuQBIAIqAuQBlDgCZCAEIAEqAugBIAIqAugBlEMAACDBl0MAACBBljgCYAJAIAQqAlAiA4tD8wQ1P15BAXNFBEAgAyADlCAEKgJMIg4gDpSSIgxDAACAPyAMkZUiEJQhESAEKgJIIg8gECADjJQiDJQhDSAOIBCUIgMgD4yUIQ5DAAAAACEQDAELIAQqAkgiDCAMlCAEKgJMIg4gDpSSIhBDAACAPyAQkZUiEZQhDSADIBEgDoyUIhCUIQ4gDCARlCIMIAOMlCERQwAAAAAhAwsgBCANOAK4ASAEIA44ArQBIAQgAzgCqAEgBCAMOAKkASAEIBE4ArABIAQgEDgCoAECfyAIRQRAIABBHGohAiAAQRBqIQEgAEEUaiEHIABBGGoMAQsgAEEYaiECIABBFGohASAAQRBqIQcgAEEcagshCCAHKAIAIQcgASgCACEBIAIoAgAhAiAEIAgoAgA2AnQgBCACNgJwIAQgATYCbCAEIAc2AmggACgCBCEBAkAgBUEATgRAIAEgBUG4AWxqIgEiAigCdCEHIAEpAnwhCyABKAKEASEIIAEoApgBIQogAUEEaiAEQQhqQbgBEBUaIAEgCjYCmAEgASAINgKEASABIAs3AnwgAiAHNgJ0DAELIAEgBEEIahDNBCEFC0G07QEoAgAiAUUNACAAKAIIKAIILQDMAUEIcUUEQCAAKAIMKAIILQDMAUEIcUUNAQsgACgCBCAFQbgBbGpBBGogAEEMQQggBiAJRyICG2ooAgAgBCgCaCAEKAJwIABBCEEMIAIbaigCACAEKAJsIAQoAnQgAREpABoLIARBwAFqJAAL/AIBBH8jAEGgAWsiBSQAAkAgACgCDCIGRQ0AIAIoAgQhByABKAIEIQggBCAGNgIEIAVB65b46gU2ApgBIAUgASgCDCIBKQIINwMgIAUgASkCADcDGCAFIAEpAhg3AzAgBSABKQIQNwMoIAVBQGsgASkCKDcDACAFIAEpAiA3AzggBSABKQI4NwNQIAUgASkCMDcDSCAFIAIoAgwiASkCCDcDYCAFIAEpAgA3A1ggBSABKQIQNwNoIAUgASkCGDcDcCAFIAEpAiA3A3ggBSABKQIoNwOAASAFIAEpAjA3A4gBIAUgASkCODcDkAECfyAFQQhqIgEgBzYCCCABIAg2AgQgAUG43wA2AgAgAQsgBUEYaiAEIAMoAhRBABC7BCAALQAIRQ0AIAQoAgQiACgC7AVFDQAgACgC5AUiASAEKAIIKAIIIgJHBEAgACAEKAIMKAIIQQRqIAJBBGoQHwwBCyAAIAFBBGogBCgCDCgCCEEEahAfCyAFQaABaiQACzoBAn8gAEHs3wA2AgACQCAALQAIRQ0AIAAoAgwiAUUNACAAKAIEIgIgASACKAIAKAIQEQIACyAAEA4LOAECfyAAQezfADYCAAJAIAAtAAhFDQAgACgCDCIBRQ0AIAAoAgQiAiABIAIoAgAoAhARAgALIAALgAEAIABBhLMBNgIAIAAgASgCADYCBCAAQfzSADYCACAAQQA2AgwgAEEAOgAIIABB7N8ANgIAIAAoAgQiASACKAIIIAMoAgggASgCACgCGBEHAARAIAAoAgQiASACKAIIIAMoAgggASgCACgCDBEHACEBIABBAToACCAAIAE2AgwLC4gyAhF/LX0jAEGAA2siCiQAIAEqAiQhMCABKgIEIUQgASoCFCEkIAEqAighJiABKgIIIUUgASoCGCEuIAAqAgghHyADKgIIISAgACoCACEeIAMqAgAhHCAAKgIEIR0gAyoCBCEbIAEqAiAhJSABKgIAIUYgASoCECEhIAogAioCAEMAAAA/lCI2OAL0AiAKIAIqAgRDAAAAP5QiNzgC+AIgCiACKgIIQwAAAD+UIjQ4AvwCIAogBSoCAEMAAAA/lCI1OALoAiAKIAUqAgRDAAAAP5QiODgC7AIgCiAFKgIIQwAAAD+UIjk4AvACAkAgRiAcIB6TIkeUICEgGyAdkyIilJIgJSAgIB+TIiOUkiI6iyA2IDUgRiAEKgIAIjGUICEgBCoCECIylJIgJSAEKgIgIhyUkiI8iyIflJIgOCBGIAQqAgQiM5QgISAEKgIUIieUkiAlIAQqAiQiLZSSIj2LIiCUkiA5IEYgBCoCCCIrlCAhIAQqAhgiLJSSICUgBCoCKCIolJIiPosiHpSSkyIdQwAAAABeDQAgRCArlCAkICyUkiAwICiUkiI/iyEvIEQgM5QgJCAnlJIgMCAtlJIiQIshKSBEIDGUICQgMpSSIDAgHJSSIkGLISpD//9//yEbQQAhAiAdQ///f/9eQQFzRQRAIDpDAAAAAF0hDSAdIRsgASELQQEhAgsgRyBElCAiICSUkiAjIDCUkiI7iyA3IDUgKpSSIDggKZSSIDkgL5SSkyIdQwAAAABeDQAgRSArlCAuICyUkiAmICiUkiJCiyEkIEUgM5QgLiAnlJIgJiAtlJIiQ4shJSBFIDGUIC4gMpSSICYgHJSSIjCLISEgHSAbXkEBc0UEQCABQQRqIQsgO0MAAAAAXSENIB0hG0ECIQILIEcgRZQgIiAulJIgIyAmlJIiLosgNCA1ICGUkiA4ICWUkiA5ICSUkpMiHUMAAAAAXg0AIB0gG15BAXNFBEAgAUEIaiELIC5DAAAAAF0hDSAdIRtBAyECCyBHIDGUICIgMpSSICMgHJSSIhyLIDUgNCAhlCA2IB+UIDcgKpSSkpKTIh1DAAAAAF4NACAdIBteQQFzRQRAIBxDAAAAAF0hDSAdIRsgBCELQQQhAgsgRyAzlCAiICeUkiAjIC2UkiIciyA4IDQgJZQgNiAglCA3ICmUkpKSkyIdQwAAAABeDQAgHSAbXkEBc0UEQCAEQQRqIQsgHEMAAAAAXSENIB0hG0EFIQILIEcgK5QgIiAslJIgIyAolJIiHIsgOSA0ICSUIDYgHpQgNyAvlJKSkpMiHUMAAAAAXg0AIB0gG15BAXNFBEAgBEEIaiELIBxDAAAAAF0hDSAdIRtBBiECCyAuIEGUIDsgMJSTIhyLIDkgIEOsxSc3kiItlCA3ICFDrMUnN5IiK5QgNCAqQ6zFJzeSIiyUkiA4IB5DrMUnN5IiKJSSkpMiHUMAAAA0Xg0AICVDrMUnN5IhMSApQ6zFJzeSITIgH0OsxSc3kiEzQwAAAAAhJgJ9IEEgQZQiKiAwIDCUQwAAAACSIiCSkSIeQwAAADReQQFzBEBDAAAAACEiQwAAAAAMAQtDAAAAACEiQwAAAAAgHSAelSIdQ2Zmhj+UIBteQQFzDQAaIBxDAAAAAF0hDSAwjCAelSEiQwAAAAAgHpUhJkEAIQtBByECIB0hGyBBIB6VCyEjIC4gQJQgOyBDlJMiHIsgOSAzlCA3IDGUIDQgMpSSIDUgKJSSkpMiHUMAAAA0Xg0AICRDrMUnN5IhJyAvQ6zFJzeSISkCQCBAIECUIiQgQyBDlEMAAAAAkiIekpEiH0MAAAA0XkEBcw0AIB0gH5UiHUNmZoY/lCAbXkEBcw0AIBxDAAAAAF0hDSBAIB+VISMgQ4wgH5UhIkMAAAAAIB+VISZBACELQQghAiAdIRsLIC4gP5QgOyBClJMiHIsgOCAzlCA1IC2UIDcgJ5QgNCAplJKSkpMiHUMAAAA0Xg0AAkAgPyA/lCIlIEIgQpRDAAAAAJIiIZKRIh9DAAAANF5BAXMNACAdIB+VIh1DZmaGP5QgG15BAXMNACAcQwAAAABdIQ0gPyAflSEjIEKMIB+VISJDAAAAACAflSEmQQAhC0EJIQIgHSEbCyA6IDCUIC4gPJSTIhyLIDkgMpQgNiArlCA0IDOUkiA4ICmUkpKTIh1DAAAANF4NAAJAIDwgPJQiHyAgkpEiIEMAAAA0XkEBcw0AIB0gIJUiHUNmZoY/lCAbXkEBcw0AIBxDAAAAAF0hDSA8jCAglSEjQwAAAAAgIJUhIiAwICCVISZBACELQQohAiAdIRsLIDogQ5QgLiA9lJMiHIsgOSAslCA2IDGUIDQgLZSSIDUgKZSSkpMiHUMAAAA0Xg0AAkAgPSA9lCIgIB6SkSIeQwAAADReQQFzDQAgHSAelSIdQ2Zmhj+UIBteQQFzDQAgHEMAAAAAXSENID2MIB6VISNDAAAAACAelSEiIEMgHpUhJkEAIQtBCyECIB0hGwsgOiBClCAuID6UkyIciyA4ICyUIDUgMpQgNiAnlCA0ICiUkpKSkyIdQwAAADReDQACQCA+ID6UIh4gIZKRIiFDAAAANF5BAXMNACAdICGVIh1DZmaGP5QgG15BAXMNACAcQwAAAABdIQ0gPowgIZUhI0MAAAAAICGVISIgQiAhlSEmQQAhC0EMIQIgHSEbCyA7IDyUIDogQZSTIhyLIDkgMZQgNiAslCA3IDOUkiA4ICeUkpKTIh1DAAAANF4NAAJAICogH5JDAAAAAJKRIh9DAAAANF5BAXMNACAdIB+VIh1DZmaGP5QgG15BAXMNACAcQwAAAABdIQ1DAAAAACAflSEjIDwgH5UhIiBBjCAflSEmQQAhC0ENIQIgHSEbCyA7ID2UIDogQJSTIhyLIDkgK5QgNiAylCA3IC2UkiA1ICeUkpKTIh1DAAAANF4NAAJAICQgIJJDAAAAAJKRIiBDAAAANF5BAXMNACAdICCVIh1DZmaGP5QgG15BAXMNACAcQwAAAABdIQ1DAAAAACAglSEjID0gIJUhIiBAjCAglSEmQQAhC0EOIQIgHSEbCyA7ID6UIDogP5STIhyLIDggK5QgNSAxlCA2ICmUIDcgKJSSkpKTIh1DAAAANF4NAAJAAkACQAJAICUgHpJDAAAAAJKRIh5DAAAANF5BAXMNACAdIB6VIh1DZmaGP5QgG15BAXMNACAcQwAAAABdIQ1DAAAAACAelSEjID4gHpUhIiA/jCAelSEmQQ8hAgwBCyACRQ0DIAsNASAbIR0LIAYgRiAmlCBEICKUkiBFICOUkiIfOAIAIAYgJiABKgIQlCAiIAEqAhSUkiAjIAEqAhiUkiIeOAIEIAYgJiABKgIglCAiIAEqAiSUkiAjIAEqAiiUkiIcOAIIDAELIAYgCygCACIONgIAIAYgCygCECIMNgIEIAYgCygCICIFNgIIIA6+IR8gDL4hHiAFviEcIBshHQsgDQRAIAYgHIw4AgggBiAejDgCBCAGIB+MOAIACyAHIB2MOAIAIAJBB04EQCAKIAAoAgg2AnggCiAAKQIANwNwQwAAAAAhLSAKKgJwISogCioCdCEkIAogCioCeCAKKgL0AiIbIBuMIAYqAgAiJyABKgIAIiWUIAYqAgQiLyABKgIQIiGUkiAGKgIIIikgASoCICIblJJDAAAAAF4bIisgG5SSIAoqAvgCIhsgG4wgJyABKgIEIh+UIC8gASoCFCIglJIgKSABKgIkIhuUkkMAAAAAXhsiLCAblJIgNCA0jCAnIAEqAggiHpQgLyABKgIYIhyUkiApIAEqAigiG5SSQwAAAABeGyIoIBuUkjgCeCAKICQgKyAhlJIgLCAglJIgKCAclJI4AnQgCiAqICsgJZSSICwgH5SSICggHpSSOAJwIAogAygCCDYC2AEgCiADKQIANwPQASAKIAoqAtgBIDWMIDUgJyAEKgIAIiWUIC8gBCoCECIhlJIgKSAEKgIgIhuUkkMAAAAAXhsiKCAblJIgCioC7AIiG4wgGyAnIAQqAgQiH5QgLyAEKgIUIiCUkiApIAQqAiQiG5SSQwAAAABeGyIqIBuUkiAKKgLwAiIbjCAbICcgBCoCCCIelCAvIAQqAhgiHJSSICkgBCoCKCIblJJDAAAAAF4bIiQgG5SSIis4AtgBIAogCioC1AEgKCAhlJIgKiAglJIgJCAclJIiLDgC1AEgCiAKKgLQASAoICWUkiAqIB+UkiAkIB6UkiIoOALQAUMAAIA/IAEgAkF5aiIDQQNtIgBBAnRqIgEqAgAiHCAEIAMgAEEDbGtBAnRqIgAqAgAiKpQgASoCECIbIAAqAhAiJJSSIAEqAiAiHyAAKgIgIiWUkiIhICGUkyIgQxe30ThfRQRAICggCioCcJMiHiAclCAsIAoqAnSTIhwgG5SSICsgCioCeJMiGyAflJIgIZQgHiAqlCAcICSUkiAbICWUkpNDAACAPyAglZQhLQsgCiArIC0gJZSSOALYASAKICwgLSAklJI4AtQBIAogKCAtICqUkjgC0AEgBioCACEeIAYqAgQhHCAGKgIIIRsgCkEANgKsAiAKIBuMOAKoAiAKIByMOAKkAiAKIB6MOAKgAiAJIApBoAJqIApB0AFqIB0gCSgCACgCEBEPACAIIAI2AgAMAQsgBioCACEiAn8gAkEDTARAIAYqAgghHSAGKgIEISMgCkH0AmohEiAEIQwgCkHoAmoMAQsgIowhIiAGKgIIjCEdIAYqAgSMISMgAyEFIApB6AJqIRIgACEDIAUhACABIQwgBCEBIApB9AJqCyELIAogIiAMKgIAlCAjIAwqAhCUkiAdIAwqAiCUkiIeOALYAiAKICIgDCoCBJQgIyAMKgIUlJIgHSAMKgIklJIiHDgC3AIgCiAiIAwqAgiUICMgDCoCGJSSIB0gDCoCKJSSIhs4AuACIBuLISACfyAciyIcIB6LIhteQQFzRQRAQQFBAiAcICBeIgcbIQRBAAwBCyAbICBeIgdBAXNBAXQhBCAHCyEXIAsgBEECdCIEaioCACIeIAQgDGoqAgCUIRwgAyoCACAAKgIAkyEbQQJBASAHGyEYIAoCfSAKQdgCaiAEaioCAEMAAAAAXUUEQCAKIBsgHJMiMTgCyAIgCiADKgIEIAAqAgSTIB4gDCAEQRByaioCAJSTIjI4AswCIAMqAgggACoCCJMgHiAMIARBIHJqKgIAlJMMAQsgCiAbIBySIjE4AsgCIAogAyoCBCAAKgIEkyAeIAwgBEEQcmoqAgCUkiIyOALMAiADKgIIIAAqAgiTIB4gDCAEQSByaioCAJSSCyItOALQAkEBIQQCQAJAQX9BfCACQQRIGyACaiIZQQFNBEBBAiEDIBlBAWsNAgwBC0EBIQMLQQAhBAsgASAEQQJ0IgRqIgUqAiAhMyAFKgIAIScgBSoCECEvIAogMSABIANBAnQiA2oiASoCACIflCAyIAEqAhAiIJSSIC0gASoCICIclJIiMCAfIAwgF0ECdCIBaiITKgIAIiiUICAgEyoCECIqlJIgHCATKgIgIh6UkiIrIAEgC2oqAgAiG5QiJJIiJSAfIAwgGEECdCIBaiIUKgIAIiGUICAgFCoCECIflJIgHCAUKgIgIiCUkiIsIAEgC2oqAgAiHJQiKZM4ArwCIAogMSAnlCAyIC+UkiAtIDOUkiImIBsgJyAolCAvICqUkiAzIB6UkiIqlCIekiIbIBwgJyAhlCAvIB+UkiAzICCUkiIglCIfkzgCuAIgCiAlICmSOAK0AiAKIBsgH5I4ArACIAogMCAkkyIcICmSOAKsAiAKICYgHpMiGyAfkjgCqAIgCiAcICmTOAKkAiAKIBsgH5M4AqACIAogBCASaigCADYCmAIgCiADIBJqKAIANgKcAkEEIQEgCkHQAWohBSAKQaACaiELQQAhBAJAA0ACQCAEIQ0CQCABQQBKBEAgDUEBcyEaIA1BAnQiDyAKQZgCamohECAFIQMgCyEEQQAhBwNAIBAqAgAiHyAEIA9qIg4qAgAiHowiHF5BAXNFBEAgAyAEKAIANgIAIAMgBCgCBDYCBCAHQQFqIgdBCHENBCAQKgIAIR8gDioCACIejCEcIANBCGohAwsgHCAfXSAfIARBCGoiDiALIAFBAUoiFRsiFiAPaioCACIcjF5HBEAgAyAaQQJ0IhFqIAQgEWoqAgAiGyAfjCAekyARIBZqKgIAIBuTIBwgHpOVlJI4AgAgAyAPaiAQKgIAjDgCACAHQQFqIgdBCHENBCADQQhqIQMLIAFBf2ohASAOIQQgFQ0AC0EAIQEgCkHwAGogCkHQAWogBSAKQdABakYbIQsgB0EATA0BIAshAyAFIQQDQCAEIA9qIg4qAgAiHiAQKgIAIh9dQQFzRQRAIAMgBCgCADYCACADIAQoAgQ2AgQgAUEBaiIBQQhxDQYgECoCACEfIA4qAgAhHiADQQhqIQMLIB4gH10gBEEIaiIOIAUgB0EBSiIVGyIWIA9qKgIAIhwgH11HBEAgAyAaQQJ0IhFqIAQgEWoqAgAiGyAfIB6TIBEgFmoqAgAgG5MgHCAek5WUkjgCACADIA9qIBAoAgA2AgAgAUEBaiIBQQhxDQYgA0EIaiEDCyAHQX9qIQcgDiEEIBUNAAsMAQsgCkHwAGogCkHQAWogBSAKQdABakYbIQtBACEBCyAKQfAAaiAKQdABaiALIApB0AFqRhshBUEBIQQgDUUNAQwCCwsgBSELIAchAQsgCkHQAWogC0cEQCAKQdABaiALIAFBA3QQFRoLIAFBAUgNAEMAAIA/ICogLJQgKyAglJOVIhsgK4yUITEgLCAblCEyICAgG5QhMyAqIBuUIScgEiAZQQJ0aioCACEvIAwgGEECdCIEQSByaioCACEpIAwgF0ECdCIDQSByaioCACEtIAwgBEEQcmoqAgAhKyAMIANBEHJqKgIAISwgFCoCACEoIBMqAgAhKkEAIQQgCioC0AIhJCAKKgLMAiElIAoqAsgCISFBACEDA0AgCkHwAGogBEEMbGoiByAhIDIgA0EDdCIFIApB0AFqaioCACIfICaTIhyUIDMgCkHQAWogBUEEcmoqAgAiICAwkyIblJMiLiAqlJIgMSAclCAnIBuUkiIbICiUkiIeOAIAIAcgJSAuICyUkiAbICuUkiIcOAIEIAcgJCAuIC2UkiAbICmUkiIbOAIIIApB0ABqIARBAnRqIC8gIiAelCAjIByUkiAdIBuUkpMiGzgCACAbQwAAAABgQQFzRQRAIARBA3QiBSAKQdABamogHzgCACAKQdABaiAFQQRyaiAgOAIAIARBAWohBAsgA0EBaiIDIAFHDQALIARBAUgNAAJAIAQgBEEEIARBBEgbIgFBASABQQFKGyIFTARAIAJBBE4EQEEAIQEDQCAKIApB8ABqIAFBDGxqIgMqAgAgACoCAJIgBioCACIcIApB0ABqIAFBAnRqKgIAIh6UkzgCICAKIAMqAgQgACoCBJIgHiAGKgIEIh2UkzgCJCAKIAMqAgggACoCCJIgHiAGKgIIIhuUkzgCKCAKQQA2AkwgCiAbjDgCSCAKIB2MOAJEIAogHIw4AkAgCSAKQUBrIApBIGogHowgCSgCACgCEBEPACABQQFqIgEgBEcNAAsMAgtBACEBA0AgCiAKQfAAaiABQQxsaiIDKgIAIAAqAgCSOAIgIAogAyoCBCAAKgIEkjgCJCAKIAMqAgggACoCCJI4AiggBioCACEcIAYqAgQhHSAGKgIIIRsgCkEANgJMIAogG4w4AkggCiAdjDgCRCAKIByMOAJAIAkgCkFAayAKQSBqIApB0ABqIAFBAnRqKgIAjCAJKAIAKAIQEQ8AIAFBAWoiASAERw0ACwwBC0EAIQMgBEECTgRAIAoqAlAhH0EBIQEDQCAKQdAAaiABQQJ0aioCACIbIB8gGyAfXiIHGyEfIAEgAyAHGyEDIAFBAWoiASAERw0ACwsgBCAKQdABaiAFIAMgCkEgahCNDSACQQNKIQNBACEBA0AgCiAKQfAAaiAKQSBqIAFBAnRqKAIAIgdBDGxqIgQqAgAgACoCAJIiHDgCQCAKIAQqAgQgACoCBJIiHTgCRCAKIAQqAgggACoCCJIiGzgCSAJAIANFBEAgBioCACEcIAYqAgQhHSAGKgIIIRsgCkEANgIcIAogG4w4AhggCiAdjDgCFCAKIByMOAIQIAkgCkEQaiAKQUBrIApB0ABqIAdBAnRqKgIAjCAJKAIAKAIQEQ8ADAELIAYqAgAhHyAGKgIEISAgBioCCCEeIApBADYCHCAKIB6MOAIYIAogIIw4AhQgCiAfjDgCECAKQQA2AgwgCiAbIB4gCkHQAGogB0ECdGoqAgAiG5STOAIIIAogHSAgIBuUkzgCBCAKIBwgHyAblJM4AgAgCSAKQRBqIAogG4wgCSgCACgCEBEPAAsgAUEBaiIBIAVHDQALCyAIIAI2AgALIApBgANqJAALugUCBX8JfSMAQUBqIgYkAAJAAn0CQAJAIABBf2oiBUEBTQRAIAVBAWsNAQwCCyAAQQJOBEAgAEF/aiEIQQAhBQNAIAogASAFQQN0IglqIgcqAgAiDiAHKgIMIg+UIAcqAggiECABIAlBBHJqKgIAIhGUkyINkiEKIAsgDyARkiANlJIhCyAMIA4gEJIgDZSSIQwgBUEBaiIFIAhHDQALC0NrC15dIQ0gCiAAQQN0IAFqIgVBeGoqAgAiDiABKgIEIg+UIAEqAgAiECAFQXxqKgIAIhGUkyIKkiISi0MAAAA0XkEBc0UEQEMAAIA/IBJDAABAQJSVIQ0LQQAhCCAAQQBMDQMgCyAPIBGSIAqUkiANlCELIAwgDiAQkiAKlJIgDZQMAgsgASoCBCELIAEqAgAMAQsgASoCBCABKgIMkkMAAAA/lCELIAEqAgAgASoCCJJDAAAAP5QLIQpBACEFA0AgBkEgaiAFQQJ0aiABIAVBA3QiB0EEcmoqAgAgC5MgASAHaioCACAKkxBBOAIAIAVBAWoiBSAARw0AC0EAIQUDQEEBIQggBiAFQQJ0akEBNgIAIAVBAWoiBSAARw0ACwsgBiADQQJ0IgFqQQA2AgAgBCADNgIAIAJBAk4EQEPbD8lAIAKylSELIAZBIGogAWoqAgAhDUEBIQcDQCAEIAM2AgQgBEEEaiEEIAMhASAIBEAgCyAHspQgDZIiCkPbD8nAkiAKIApD2w9JQF4bIQ5BACEFQyhrbk4hCgNAAkAgBiAFQQJ0IglqKAIARQ0AQ9sPyUAgBkEgaiAJaioCACAOk4siDJMgDCAMQ9sPSUBeGyIMIApdQQFzDQAgBCAFNgIAIAUhASAMIQoLIAVBAWoiBSAARw0ACwsgBiABQQJ0akEANgIAIAdBAWoiByACRw0ACwsgBkFAayQAC4YLASp9IwBB8AFrIgMkAEMAAIA/ISwCQCACIAEgAC0ACCIEGyIAKgJ0IgcgACoCNCIIkyIFIAWUIAAqAngiCSAAKgI4IhWTIgUgBZSSIAAqAnwiFiAAKgI8IgaTIgUgBZSSIAAqAvwBIgUgBZRdDQAgASACIAQbIgEoAsABIgIoAgRBa2pBCEsNACAAKgJcIRogACoCTCEbIAAqAmwhHCAAKgJYIR0gACoCSCEeIAAqAmghHyAAKgJkISAgACoCVCEhIAAqAkQhIiABKgIkIQogASoCFCELIAEqAgQhDCAAKgIcISMgACoCDCEkIAAqAiwhJSAAKgIYISYgACoCCCEnIAAqAighKCAAKgIkISkgACoCFCEqIAAqAgQhKyABKgIMIg0gB5QgASoCHCIOIAmUkiABKgIsIg8gFpSSIS0gASoCGCIQIAEqAjiMIhGUIAEqAggiEiABKgI0IheUkyABKgIoIhMgASoCPCIYlJMiFCASIAeUIBAgCZSSIBMgFpSSkiEFIANBADYC7AEgAyAOIBGUIA0gF5STIA8gGJSTIi4gDSAIlCAOIBWUkiAPIAaUkpIiGTgC6AEgAyAUIBIgCJQgECAVlJIgEyAGlJKSIhQ4AuQBIAMgCyARlCAMIBeUkyAKIBiUkyIRIAwgCJQgCyAVlJIgCiAGlJKSIgg4AuABIAghFSARIAwgB5QgCyAJlJIgCiAWlJKSIgcgCF1BAXNFBEAgAyAHOALgASAHIRULIBQhFiAFIBRdQQFzRQRAIAMgBTgC5AEgBSEWCyAuIC2SIgkgGSIGXUEBc0UEQCADIAk4AugBIAkhBgsgA0EANgLcASADIBk4AtgBIAMgFDgC1AEgAyAIOALQASAIIREgCCAHXUEBc0UEQCADIAc4AtABIAchEQsgFCEXIBQgBV1BAXNFBEAgAyAFOALUASAFIRcLIBkhGCAZIAldQQFzRQRAIAMgCTgC2AEgCSEYCyADIAYgACoC+AEiBpM4AugBIAMgFiAGkzgC5AEgAyAVIAaTOALgASADIAYgGJI4AtgBIAMgBiAXkjgC1AEgAyAGIBGSOALQASADQQA2AoABIAMgCTgCfCADIAU4AnggAyAHOAJ0IANBADYCcCADIA0gG5QgDiAalJIgDyAclJI4AmwgAyANIB6UIA4gHZSSIA8gH5SSOAJoIAMgDSAilCAOICGUkiAPICCUkjgCZCADQQA2AmAgAyASIBuUIBAgGpSSIBMgHJSSOAJcIAMgEiAelCAQIB2UkiATIB+UkjgCWCADIBIgIpQgECAhlJIgEyAglJI4AlQgA0EANgJQIAMgDCAblCALIBqUkiAKIByUkjgCTCADIAwgHpQgCyAdlJIgCiAflJI4AkggA0FAa0EANgIAIAMgGTgCPCADIBQ4AjggAyAIOAI0IANBADYCMCADIA0gJJQgDiAjlJIgDyAllJI4AiwgAyANICeUIA4gJpSSIA8gKJSSOAIoIAMgDSArlCAOICqUkiAPICmUkjgCJCADQQA2AiAgAyASICSUIBAgI5SSIBMgJZSSOAIcIAMgEiAnlCAQICaUkiATICiUkjgCGCADIBIgK5QgECAqlJIgEyAplJI4AhQgA0EANgIQIAMgDCAklCALICOUkiAKICWUkjgCDCADIAwgJ5QgCyAmlJIgCiAolJI4AgggAyAGOALEASADIAwgIpQgCyAhlJIgCiAglJI4AkQgAyAMICuUIAsgKpSSIAogKZSSOAIEIANB+N0ANgIAIAMgACgC9AE2AsgBAkAgAkUNACACIAMgA0HgAWogA0HQAWogAigCACgCQBEEACADKgLIASIFIAAqAvQBXUEBcw0AIAAgBTgC9AEgBSEsCwsgA0HwAWokACAsC+gBAgN/AX0CQCABIAIgAC0ACCIHGyIGKAIEIgUoAgRBa2pBCEsNACACIAEgBxsiASgCBCgCBEETSg0AIAUgBSgCACgCMBEGACEIIAQgACgCTDYCBCAAQQxqIgIgCCADIAEgBiAEEJANIAEoAgghASAAKAJMIgMgBigCCDYC6AUgAyABNgLkBSAFIAIgAEEYaiAAQShqIAUoAgAoAkARBAAgBCgCBCIBKALsBQRAIAEgASgC5AUiASAEKAIMKAIIIgIgASAEKAIIKAIIIgNGIgEbQQRqIAIgAyABG0EEahAfCyAAQgA3AhALC7QFAgF/GH0jAEFAaiIGJAAgACABOAI4IAAgAjYCNCAAIAQ2AgggACADNgIEIAAgBTYCLCAEKAIMIgIqAjQhECACKgI4IREgAygCDCIEKgI0IRIgBCoCOCETIAIqAhQhByACKgIkIQggBCoCFCEUIAQqAiQhFSAEKgIYIRYgAioCGCEJIAQqAighFyACKgIoIQogBCoCICEYIAIqAiAhCyAEKgIAIRkgAioCACEMIAQqAhAhGiACKgIQIQ0gAioCMCEbIAQqAjAhHCACKgIEIQ4gBCoCBCEdIAQqAgghHiACKgIIIQ8gBkEANgI8IAZBADYCLCAGQQA2AhwgBiAPIB6UIAkgFpSSIAogF5SSOAIoIAYgDyAdlCAJIBSUkiAKIBWUkjgCJCAGIA4gHpQgByAWlJIgCCAXlJI4AhggBiAOIB2UIAcgFJSSIAggFZSSOAIUIAYgCSAQjCIQlCAPIBuUkyAKIBGUkyAPIByUIAkgEpSSIAogE5SSkjgCOCAGIAcgEJQgDiAblJMgCCARlJMgDiAclCAHIBKUkiAIIBOUkpI4AjQgBkEANgIMIAYgDCAZlCANIBqUkiALIBiUkjgCACAGIA8gGZQgCSAalJIgCiAYlJI4AiAgBiAOIBmUIAcgGpSSIAggGJSSOAIQIAYgDCAelCANIBaUkiALIBeUkjgCCCAGIAwgHZQgDSAUlJIgCyAVlJI4AgQgBiANIBCUIAwgG5STIAsgEZSTIAwgHJQgDSASlJIgCyATlJKSOAIwIAMoAgQiAiAGIABBDGogAEEcaiACKAIAKAIIEQQAIAAgACoCHCABkjgCHCAAIAAqAiAgAZI4AiAgACAAKgIkIAGSOAIkIAAgACoCDCABkzgCDCAAIAAqAhAgAZM4AhAgACAAKgIUIAGTOAIUIAZBQGskAAucBQIFfwR9IwBBgAFrIgQkAAJAIAEqAgAiCSABKgIQIgogCSAKXRsiDCABKgIgIgsgDCALXRsgACoCHF4NACABIAkgCl5BAXNBBHQiBUEgIAEgBWoqAgAgC14baioCACAAKgIMXQ0AIAEqAggiCSABQRhqIgUqAgAiCiAJIApdGyIMIAFBKGoiBioCACILIAwgC10bIAAqAiReDQAgAUEIaiAFIAkgCl4bIgUgBiAFKgIAIAteGyoCACAAKgIUXQ0AIAEqAgQiCSABQRRqIgUqAgAiCiAJIApdGyIMIAFBJGoiBioCACILIAwgC10bIAAqAiBeDQAgAUEEaiAFIAkgCl4bIgUgBiAFKgIAIAteGyoCACAAKgIQXQ0AIAAoAgQoAgQoAgRBE0oNACAAKAIwIQYgBEEYahDeASEIIARBATYCHCAEQfwwNgIYIAQgASkCCDcDWCAEIAEpAgA3A1AgBCABKQIYNwNoIAQgASkCEDcDYCAEIAEpAig3A3ggBCABKQIgNwNwIAQgACgCODYCRCAEIAAoAggiASkCCDcDCCAEIAM2AhQgBCACNgIQIAQgATYCACAEIARBGGo2AgQgBiAAKAIEIAQgACgCQCAGKAIAKAIIEQoAIQUCQCAAKAIsIgEoAggiBygCCCAAKAIIKAIIRgRAIAEgBDYCCCABIAIgAyABKAIAKAIIEQUADAELIAEoAgwhByABIAQ2AgwgASACIAMgASgCACgCDBEFAAsgBSAAKAIEIAQgACgCNCAAKAIsIAUoAgAoAggRCQAgACgCLCIBQQhBDCABKAIIKAIIIAAoAggoAghGG2ogBzYCACAFIAUoAgAoAgARAQAaIAYgBSAGKAIAKAI8EQIAIAgQYBoLIARBgAFqJAALPwEBfyAAQYzdADYCACAAKAIwIgEgACgCQCABKAIAKAIUEQIAIAAoAjAiASAAKAJAIAEoAgAoAhARAgAgABAOCz0BAX8gAEGM3QA2AgAgACgCMCIBIAAoAkAgASgCACgCFBECACAAKAIwIgEgACgCQCABKAIAKAIQEQIAIAALjwIBBX8gACgCTCIDBEACQCABKAIEIgIgASgCCEcNACACIAJBAXRBASACGyIETg0AAn8gBARAQej3AUHo9wEoAgBBAWo2AgAgBEECdEEQQYzSASgCABEDACEFIAEoAgQhAgsgAkEBTgsEQEEAIQMDQCAFIANBAnQiBmogASgCDCAGaigCADYCACADQQFqIgMgAkcNAAsLIAEoAgwiAwRAIAEtABAEQCADBEBB7PcBQez3ASgCAEEBajYCACADQZDSASgCABEAAAsgASgCBCECCyABQQA2AgwLIAEgBTYCDCABQQE6ABAgASAENgIIIAAoAkwhAwsgASgCDCACQQJ0aiADNgIAIAEgAkEBajYCBAsLSAEBfyAAQYzdADYCDCAAQfDcADYCACAAKAI8IgEgACgCTCABKAIAKAIUEQIAIAAoAjwiASAAKAJMIAEoAgAoAhARAgAgABAOC0YBAX8gAEGM3QA2AgwgAEHw3AA2AgAgACgCPCIBIAAoAkwgASgCACgCFBECACAAKAI8IgEgACgCTCABKAIAKAIQEQIAIAALtA4CBX8sfSMAQTBrIgMkAAJAIAAoAgxFDQAgASACIAAtABAiBRsiCCgCDCIGKgI4IRMgBioCNCEkIAYqAjAhFCACIAEgBRsiBygCDCIFKgI4IRUgBSoCNCEeIAUqAjAhHyAHKAIEIQcgBSoCICEWIAUqAgAhFyAFKgIQIRggBSoCJCEaIAUqAhQhGyAFKgIEIRwgBioCKCEKIAYqAhghCyAGKgIIIQwgBioCJCENIAYqAhQhECAGKgIEIQ8gBioCICERIAUqAighGSAGKgIQIRIgBSoCGCEgIAYqAgAhDiAFKgIIISEgCCgCBCIGIgkqAjghIiAGKgI0IR0gBioCMCEjIANBADYCHCADICEgD5QgICAQlJIgGSANlJIiJSAdjCIdlCAjICEgDpQgICASlJIgGSARlJIiJpSTICIgISAMlCAgIAuUkiAZIAqUkiIZlJM4AhggAyAcIA+UIBsgEJSSIBogDZSSIiAgHZQgIyAcIA6UIBsgEpSSIBogEZSSIiGUkyAiIBwgDJQgGyALlJIgGiAKlJIiJ5STOAIUIAMgFyAPlCAYIBCUkiAWIA2UkiIoIB2UICMgFyAOlCAYIBKUkiAWIBGUkiIjlJMgIiAXIAyUIBggC5SSIBYgCpSSIiKUkzgCECADQSBqIAcgA0EQaiAHKAIAKAJAEQUAIAgoAgwiBSoCMCEdIAUqAiAhKSAFKgIQISogBSoCCCErIAUqAgQhLCAFKgIAIS0gBSoCOCEuIAUqAjQhLyAFKgIoITAgBSoCJCExIAUqAhghMiAFKgIUITMgBioCQCE0IAkqAjghGiAGKgIwIRsgBioCNCEcIAMqAighFiADKgIgIRcgAyoCJCEYIAAoAgwqAvAFITUgBCAAKAIMNgIEIBogHyAMlCAeIAuUkiAVIAqUkiALICSMIguUIBQgDJSTIBMgCpSTkiAiIBeUICcgGJSSIBkgFpSSkiIZlCAbIB8gDpQgHiASlJIgFSARlJIgEiALlCAUIA6UkyATIBGUk5IgIyAXlCAhIBiUkiAmIBaUkpIiEZQgHCAfIA+UIB4gEJSSIBUgDZSSIBAgC5QgFCAPlJMgEyANlJOSICggF5QgICAYlJIgJSAWlJKSIhCUkpIgNJMiCiA1XUEBc0UEQCAIKAIMIgUqAhghDyAFKgIUIRIgBSoCKCEOIAUqAiQhEyAFKgIQIRQgBSoCICEVIAYqAjghCyAFKgIIIR4gBioCMCEMIAUqAgAhHyAGKgI0IQ0gBSoCBCEWIANBADYCHCADIB8gDJQgFiANlJIgHiALlJI4AhAgAyAMIBWUIA0gE5SSIAsgDpSSOAIYIAMgDCAUlCANIBKUkiALIA+UkjgCFCADQQA2AgwgAyARIBsgCpSTIgsgKZQgECAcIAqUkyIMIDGUkiAZIBogCpSTIg0gMJSSIC6SOAIIIAMgCyAqlCAMIDOUkiANIDKUkiAvkjgCBCADICsgDZQgLSALlCAsIAyUkpIgHZI4AgAgBCADQRBqIAMgCiAEKAIAKAIQEQ8ACwJAIAcoAgRBBkoNACAEKAIEKALsBSAAKAIYTg0AAkAgBioCOCILi0PzBDU/XkEBc0UEQCAGKgI0IgpDAACAPyALIAuUIAogCpSSkZUiDJQhCiAMIAuMlCELQwAAAAAhDAwBCyAGKgIwIgpDAACAPyAKIAqUIAYqAjQiCiAKlJKRlSIMlCELIAwgCoyUIQxDAAAAACEKC0EAIQUgByAHKAIAKAIQEQYAIQ1BgNIBKgIAIA2VQ9sPyT6WQwAAAD+UIg0QHCEPIAAoAhQhByANEB0hECAHQQFIDQAgCiAPIAwgDJQgCyALlJIgCiAKlJKRlSIKlCEPIAsgCpQhESAMIAqUIRIDQCAGKgI0IQwgBioCMCENIAYqAjghC0PbD8lAIAeylSAFspRDAAAAP5QiChAcIQ4gAyAKEB0iCiAPIAsgDiANIA2UIAwgDJSSIAsgC5SSkZUiDpQiC5QgESAMIA6UIgyUIBAgCpQgEiANIA6UIg2UkpKSIg6UIA0gESALlCASIAqUIBAgDZSTIA8gDJSTkiITlJMgDCAPIA2UIBEgCpQgECAMlJMgEiALlJOSIhSUkyALIBIgDJQgDyAKlCAQIAuUkyARIA2Uk5IiFZSTOAIcIAMgDCATlCALIA6UIAogFZSSkiANIBSUkzgCGCADIA0gFZQgCiAUlCAMIA6UkpIgCyATlJM4AhQgAyALIBSUIA0gDpQgCiATlJKSIAwgFZSTOAIQIAAgA0EQaiABIAIgBBCYDSAFQQFqIgUgACgCFCIHSA0ACwsgAC0ACEUNACAAKAIMKALsBUUNACAEKAIEIgAoAuwFRQ0AIAAoAuQFIgEgBCgCCCgCCCICRwRAIAAgBCgCDCgCCEEEaiACQQRqEB8MAQsgACABQQRqIAQoAgwoAghBBGoQHwsgA0EwaiQAC78MAgR/LX0jAEEwayIFJAAgAiADIAAtABAiCBsiBygCDCIGKgI4IScgBioCNCEoIAYqAjAhKSADIAIgCBsiAygCDCICKgI4ISogAioCNCErIAIqAjAhLCADKAIEIQMgBioCKCEPIAYqAgghCyAGKgIYIQwgBioCJCENIAYqAgQhEiAGKgIUIRMgBioCICEUIAIqAighGCACKgIgIRkgAioCJCEaIAYqAgAhFSACKgIIIRsgAioCACEcIAIqAgQhHSAGKgIQIRYgAioCGCEfIAIqAhAhICACKgIUISEgASoCDCEOIAEqAgghECABKgIAIQkgASoCBCEKIAcoAgQiAiIGKgI4ISIgAioCNCEtIAIqAjAhIyAFQQA2AhwgBSANIBkgCSAQQwAAAEAgCSAJlCAKIAqUkiAQIBCUkiAOIA6UkpUiF5QiEZQiLiAOIAogF5QiJJQiL5IiJZQgGiAKIBGUIjAgDiAJIBeUIh6UIjGTIheUkiAYQwAAgD8gCSAelCIyIAogJJQiM5KTIgqUkiIelCASIBwgJZQgHSAXlJIgGyAKlJIiJpQgEyAgICWUICEgF5SSIB8gCpSSIgqUkpIgLYwiF5QgIyAUIB6UIBUgJpQgFiAKlJKSlJMgIiAPIB6UIAsgJpQgDCAKlJKSlJM4AhggBSANIBggMCAxkiIKlCAZIAkgJJQiJCAOIBGUIiWTIgmUIBpDAACAPyAyIBAgEZQiHpKTIg6UkpIiEJQgEiAbIAqUIBwgCZQgHSAOlJKSIhGUIBMgHyAKlCAgIAmUICEgDpSSkiIJlJKSIBeUICMgFCAQlCAVIBGUIBYgCZSSkpSTICIgDyAQlCALIBGUIAwgCZSSkpSTOAIUIAUgDSAYIC4gL5MiCZQgGiAkICWSIg6UIBlDAACAPyAzIB6SkyIKlJKSIhCUIBIgGyAJlCAdIA6UIBwgCpSSkiIRlCATIB8gCZQgISAOlCAgIAqUkpIiCZSSkiAXlCAjIBQgEJQgFSARlCAWIAmUkpKUkyAiIA8gEJQgCyARlCAMIAmUkpKUkzgCECAFQSBqIAMgBUEQaiADKAIAKAJAEQUAIAcoAgwiASoCMCEXIAEqAiAhJCABKgIQISUgASoCCCEeIAEqAgQhJiABKgIAIS0gASoCOCEuIAEqAjQhLyABKgIoITAgASoCJCExIAEqAhghMiABKgIUITMgAioCQCE0IAYqAjghECACKgIwISIgAioCNCEjIAUqAighCSAFKgIgIQ4gBSoCJCEKIAAoAgwqAvAFITUgBCAAKAIMNgIEIBAgLCALlCArIAyUkiAqIA+UkiAMICiMIhGUIAsgKZSTIA8gJ5STkiAOIBwgC5QgICAMlJIgGSAPlJKUIAogHSALlCAhIAyUkiAaIA+UkpSSIAkgGyALlCAfIAyUkiAYIA+UkpSSkiIolCAiICwgFZQgKyAWlJIgKiAUlJIgFiARlCAVICmUkyAUICeUk5IgDiAcIBWUICAgFpSSIBkgFJSSlCAKIB0gFZQgISAWlJIgGiAUlJKUkiAJIBsgFZQgHyAWlJIgGCAUlJKUkpIiFJQgIyAsIBKUICsgE5SSICogDZSSIBMgEZQgEiAplJMgDSAnlJOSIA4gHCASlCAgIBOUkiAZIA2UkpQgCiAdIBKUICEgE5SSIBogDZSSlJIgCSAbIBKUIB8gE5SSIBggDZSSlJKSIhKUkpIgNJMiDyA1XUEBc0UEQCAHKAIMIgAqAhghEyAAKgIUIRUgACoCKCEWIAAqAiQhGCAAKgIQIRkgACoCICEaIAIqAjghCyAAKgIIIRsgAioCMCEMIAAqAgAhHCACKgI0IQ0gACoCBCEdIAVBADYCHCAFIBwgDJQgHSANlJIgGyALlJI4AhAgBSAMIBqUIA0gGJSSIAsgFpSSOAIYIAUgDCAZlCANIBWUkiALIBOUkjgCFCAFQQA2AgwgBSAUICIgD5STIgsgJJQgEiAjIA+UkyIMIDGUkiAoIBAgD5STIg0gMJSSIC6SOAIIIAUgCyAllCAMIDOUkiANIDKUkiAvkjgCBCAFIB4gDZQgLSALlCAmIAyUkpIgF5I4AgAgBCAFQRBqIAUgDyAEKAIAKAIQEQ8ACyAFQTBqJAALOgECfyAAQaTcADYCAAJAIAAtAAhFDQAgACgCDCIBRQ0AIAAoAgQiAiABIAIoAgAoAhARAgALIAAQDgs4AQJ/IABBpNwANgIAAkAgAC0ACEUNACAAKAIMIgFFDQAgACgCBCICIAEgAigCACgCEBECAAsgAAuaAQAgAEGEswE2AgAgACABKAIANgIEIAAgBjYCGCAAIAU2AhQgACAEOgAQIABBADYCDCAAQQA6AAggAEGk3AA2AgAgACgCBCIBIAMgAiAEGyIFKAIIIAIgAyAEGyICKAIIIAEoAgAoAhgRBwAEQCAAKAIEIgEgBSgCCCACKAIIIAEoAgAoAgwRBwAhASAAQQE6AAggACABNgIMCwuQBwEOfyMAQRBrIhAkACAAIAEgAhCdDSAAKAIIIQtB6NsAEBYCQCAALQBARQRAIAEgASgCACgCLBEBACEFIAEgASgCACgCJBEBACEAIAMgAigCECACKAIIIAUgAEF/IAMoAgAoAggRDAAMAQsgACgCHCIMQQJOBEAgAEEYaiAQQQhqQQAgDEF/ahC/BAsgC0EBSA0AQQEhBQNAIAAoAhAiASAHQQN0aigCACEOQQEhDwJAIAcgC04NAANAIAIoAhAgASAHQQN0aigCBEECdGooAgAhCQJAIAAoAjAiBCAAKAI0Rw0AIAQgBEEBdEEBIAQbIg1ODQBBACEBQQAhCAJ/IA0EQEHo9wFB6PcBKAIAQQFqNgIAIA1BAnRBEEGM0gEoAgARAwAhCCAAKAIwIQQLIARBAU4LBEADQCAIIAFBAnQiBmogACgCOCAGaigCADYCACABQQFqIgEgBEcNAAsLIAAoAjgiAQRAIAAtADwEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsgACgCMCEECyAAQQA2AjgLIAAgCDYCOCAAQQE6ADwgACANNgI0CyAAKAI4IARBAnRqIAk2AgAgACAEQQFqNgIwIA8gCSgC2AEiAUECRiABQQVGcnEhDyALIAdBAWoiB0YEQCALIQcMAgsgACgCECIBIAdBA3RqKAIAIA5GDQALC0EAIQgCf0EAIAogDE4NABpBACAAKAIkIhEgCkECdGoiDSgCACIBKALkBSgC0AEiBEF/TAR/IAEoAugFKALQAQUgBAsgDkcNABogDCAKQQFqIgEgDCABShshASAKIQUDQAJAIAVBAWoiBSAMTgRAIAEhBQwBCyARIAVBAnRqKAIAIgkoAuQFKALQASIGQX9MBH8gCSgC6AUoAtABBSAGCyAORg0BCwsgBSAKayEIIA0LIQEgD0UEQCADIAAoAjggACgCMCABIAggDiADKAIAKAIIEQwACyAAKAIwIgFBf0wEQCAAKAI0QX9MBEAgACgCOCIGBEAgAC0APARAIAYEQEHs9wFB7PcBKAIAQQFqNgIAIAZBkNIBKAIAEQAACwsgAEEANgI4CyAAQQE6ADwgAEIANwI0CwNAIAAoAjggAUECdGpBADYCACABQQFqIgYgAU8hCSAGIQEgCQ0ACwsgBSAKIAgbIQogAEEANgIwIAcgC0gNAAsLEBMgEEEQaiQAC6UIAQp/QczbABAWIAAoAhwiA0F/TARAIAAoAiBBf0wEQCAAKAIkIgUEQCAALQAoBEAgBQRAQez3AUHs9wEoAgBBAWo2AgAgBUGQ0gEoAgARAAALCyAAQQA2AiQLIABCADcCICAAQQE6ACgLA0AgACgCJCADQQJ0akEANgIAIANBAWoiBSADTyEEIAUhAyAEDQALCyAAQQA2AhwgAEEEahDSDCAAKAIIIgtBAU4EQEEAIQUDQCALIAUiA0EBaiIEIAsgBEobIglBf2ohBiAAKAIQIgogA0EDdGooAgAhDANAAkAgBSIEQQFqIgUgC04EQCAGIQQgCSEFDAELIAogBUEDdGooAgAgDEYNAQsLAkAgAyAESg0AIAQgAyAEIANKGyEIIAIoAhAhCUEBIQcgAyEEA0AgDCAJIAogBEEDdGooAgRBAnRqKAIAIgYoAtABRgRAIAYoAtgBIgZBBEcgByAGQQFHcXEhBwsgBCAIRyEGIARBAWohBCAGDQALIAcEQANAIAwgAigCECAKIANBA3RqKAIEQQJ0aigCACIEKALQAUYEQCAEKALYAUF+cUEERwRAIARBAjYC2AELCyADIAhGDQIgA0EBaiEDIAAoAhAhCgwAAAsACwNAAkAgAigCECAKIANBA3RqKAIEQQJ0aigCACIEKALQASAMRw0AIAQoAtgBQQJHDQAgBCgC2AFBfnFBBEcEQCAEQQM2AtgBCyAEQQA2AtwBCyADIAhGDQEgA0EBaiEDIAAoAhAhCgwAAAsACyAFIAtIDQALCyABIAEoAgAoAiQRAQAiBkEBTgRAQQAhBANAIAEgBCABKAIAKAIoEQMAIgkoAugFIQMCQCAJKALkBSIFQQAgBSgC2AFBAkcbRQRAIANFDQEgAygC2AFBAkYNAQsCQCAFKALMASICQQJxRQ0AIAJBBHENACAFKALYAUECRg0AIANBABA+CwJAIAMoAswBIgJBAnFFDQAgAkEEcQ0AIAMoAtgBQQJGDQAgBUEAED4LIAAtAEBFDQAgASAFIAMgASgCACgCHBEHAEUNAAJAIAAoAhwiAiAAKAIgRw0AIAIgAkEBdEEBIAIbIghODQBBACEDQQAhBwJ/IAgEQEHo9wFB6PcBKAIAQQFqNgIAIAhBAnRBEEGM0gEoAgARAwAhByAAKAIcIQILIAJBAU4LBEADQCAHIANBAnQiBWogACgCJCAFaigCADYCACADQQFqIgMgAkcNAAsLIAAoAiQiBQRAIAAtACgEQCAFIgIEQEHs9wFB7PcBKAIAQQFqNgIAIAJBkNIBKAIAEQAACyAAKAIcIQILIABBADYCJAsgACAHNgIkIABBAToAKCAAIAg2AiALIAAoAiQgAkECdGogCTYCACAAIAJBAWo2AhwLIARBAWoiBCAGRw0ACwsQEwvDAQEJfyABKAIIIghBAU4EQCABKAIQIQlBACEBA0ACQCAJIANBAnRqKAIAIgQtAMwBQQNxRQRAIAEhAiABIAAoAhAiBSABQQN0IgpqIgYoAgAiB0cEQANAIAYgBSAHQQN0aiICKAIANgIAIAIoAgAiAiAFIAJBA3RqIgYoAgAiB0cNAAsLIAQgAjYC0AEgBSAKaiADNgIEIARBfzYC1AEgAUEBaiEBDAELIARC/////283AtABCyADQQFqIgMgCEcNAAsLC4ABAQR/AkAgASgCCCIFQQFIBEBBACECDAELIAEoAhAhBkEAIQIDQCAGIARBAnRqKAIAIgMtAMwBQQNxRQRAIAMgAjYC0AEgAkEBaiECCyADQYCAgPwDNgL0ASADQX82AtQBIARBAWoiBCAFRw0ACwsgAEEEaiACENMMIAAgARChDQt4AQF/IwBBIGsiASQAIAEgADYCHAJAQcTVAS0AAEEBcQ0AQcTVARAQRQ0AIwBBEGtBtNUBNgIMQcTVARAPCyABQQhqIAEoAhwiACAAKAIAKAJMEQIAQbTVASABKQIINwIAQbzVASABKQIQNwIAIAFBIGokAEG01QEL0gIBB38CQCABKAJEIgEgASgCACgCJBEBACIBIAEoAgAoAiQRAQAiBkUNACABIAEoAgAoAhQRAQAhCCAGQQFIDQADQAJAIAggB0EEdGoiASgCACgCACICRQ0AIAEoAgQoAgAiAUUNACACKALMAUEHcQ0AIAEtAMwBQQdxDQAgASgC0AEhASAAKAIQIgMgAigC0AEiAkEDdGoiBCgCACIFIAJHBEADQCAEIAMgBUEDdGoiAigCADYCACACKAIAIgIgAyACQQN0aiIEKAIAIgVHDQALCyABIAMgAUEDdGoiBCgCACIFRwRAA0AgBCADIAVBA3RqIgEoAgA2AgAgASgCACIBIAMgAUEDdGoiBCgCACIFRw0ACwsgASACRg0AIAMgAkEDdGoiAiABNgIAIAMgAUEDdGoiASABKAIEIAIoAgRqNgIECyAHQQFqIgcgBkcNAAsLC7kBAQF/IABBvNsANgIAIAAoAjgiAQRAIAAtADwEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYCOAsgAEEANgI4IABCADcCMCAAQQE6ADwgACgCJCIBBEAgAC0AKARAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgIkCyAAQQA2AiQgAEIANwIcIABBAToAKCAAQQRqEKwEIAAQDgu3AQEBfyAAQbzbADYCACAAKAI4IgEEQCAALQA8BEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AjgLIABBADYCOCAAQgA3AjAgAEEBOgA8IAAoAiQiAQRAIAAtACgEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYCJAsgAEEANgIkIABCADcCHCAAQQE6ACggAEEEahCsBCAAC1EAIABBvNsANgIAIABBADYCECAAQQE6ABQgAEIANwIIIABBADYCJCAAQQE6ACggAEEBOgA8IABCADcCHCAAQQA2AjggAEEBOgBAIABCADcCMAs0AQF/IAEoAgAiBEEcIAQoAgAoAjgRAwAiBCABIAIgAyAALQAEIAAoAgggACgCDBCbDSAECyMAIAEoAgAiAEEQIAAoAgAoAjgRAwAiACABIAIgAxCLDSAACy8BAX8gASgCACIEQRQgBCgCACgCOBEDACIEIAEoAgQgASACIAMgAC0ABBDiDCAECyMAIAEoAgAiAEEQIAAoAgAoAjgRAwAiACABIAIgAxC0DSAACzYAIAEoAgAiAEEIIAAoAgAoAjgRAwAiAiIAQYSzATYCACAAIAEoAgA2AgQgAEHA0gA2AgAgAgslACABKAIAIgBBLCAAKAIAKAI4EQMAIgAgASACIANBARCpBCAACyMAIAEoAgAiAEEwIAAoAgAoAjgRAwAiACABIAIgAxDFDCAACyUAIAEoAgAiAEEsIAAoAgAoAjgRAwAiACABIAIgA0EAEKkEIAALJgAgASgCACIAQdAAIAAoAgAoAjgRAwAiACABIAIgA0EBEL0EIAALJgAgASgCACIAQdAAIAAoAgAoAjgRAwAiACABIAIgA0EAEL0EIAALCQAgABDiARAOC+ADAgJ/CX0jAEEgayIDJAACQCAAKAIMIgBFDQAgBCAANgIEIAEoAgwiBSoCMCACKAIMIgYqAjAiDZMiDCAMlCAFKgI0IAYqAjQiDpMiCCAIlJIgBSoCOCAGKgI4Ig+TIgkgCZSSkSIHIAEoAgQiASoCHCABKgIMlCACKAIEIgEqAhwgASoCDJQiCpIiC15BAXNFBEAgACgC7AVFDQEgACgC5AUiASAEKAIIKAIIIgJHBEAgACAEKAIMKAIIQQRqIAJBBGoQHwwCCyAAIAFBBGogBCgCDCgCCEEEahAfDAELIANCADcDGCADQoCAgPwDNwMQIAcgC5MhCwJAIAdDAAAANF5BAXMEQEMAAIA/IQdDAAAAACEJQwAAAAAhCAwBCyADQQA2AhwgAyAJQwAAgD8gB5UiB5QiCTgCGCADIAggB5QiCDgCFCADIAwgB5QiBzgCEAsgA0EANgIMIAMgDyAKIAmUkjgCCCADIA4gCiAIlJI4AgQgAyANIAogB5SSOAIAIAQgA0EQaiADIAsgBCgCACgCEBEPACAEKAIEIgAoAuwFRQ0AIAAgACgC5AUiACAEKAIMKAIIIgEgACAEKAIIKAIIIgJGIgAbQQRqIAEgAiAAG0EEahAfCyADQSBqJAALOgECfyAAQcjTADYCAAJAIAAtAAhFDQAgACgCDCIBRQ0AIAAoAgQiAiABIAIoAgAoAhARAgALIAAQDgtLAQF/IwBBEGsiBCQAIAQgADYCDCAEIAE2AgggBCACNgIEIAQgAzYCAEHEAhANIgAgBCgCDCAEKAIIIAQoAgQQ9QQgBEEQaiQAIAALOAECfyAAQcjTADYCAAJAIAAtAAhFDQAgACgCDCIBRQ0AIAAoAgQiAiABIAIoAgAoAhARAgALIAALYQAgAEGEswE2AgAgACABKAIANgIEIABB/NIANgIAIABBADYCDCAAQQA6AAggAEHI0wA2AgAgACgCBCIBIAIoAgggAygCCCABKAIAKAIMEQcAIQEgAEEBOgAIIAAgATYCDAsDAAELOAAgACABKQIANwIEIAAgASkCCDcCDCAAIAIpAgA3AhQgACACKQIINwIcIABBAToAKCAAIAM4AiQLthQDBn8Cfg59IwBBkCFrIgAkACADKAIEQW9qQQJJQQAgAigCBEFvakEBTRshDgNAEOMBIAQqAiAhFyAEKgIQIRggBCoCACEZIAQqAiQhFiAEKgIUIRogBCoCBCEbIAQqAighEiAEKgIYIRMgBCoCCCEcIAxBBHQiCyAAQfAJamoiCkEANgIMIAogEyALQdTlAWoqAgAiFYwiFJQgHCALQdDlAWoqAgAiE5STIBIgC0HY5QFqKgIAIhKUkzgCCCAKIBogFJQgEyAblJMgEiAWlJM4AgQgCiAYIBSUIBMgGZSTIBIgF5STOAIAIAUqAighFCAFKgIIIRcgBSoCGCEYIAUqAiQhGSAFKgIEIRYgBSoCFCEaIAUqAiAhGyAFKgIAIRwgBSoCECEdIABBkAJqIAtqIgtBADYCDCALIBMgHJQgFSAdlJIgEiAblJI4AgAgCyATIBaUIBUgGpSSIBIgGZSSOAIEIAsgEyAXlCAVIBiUkiASIBSUkjgCCCAMQQFqIgxBKkcNAAtBKiELIAIgAigCACgCVBEBACIPQQFOBEBBACEMA0AgAiAMIABBsBlqIAIoAgAoAlgRBQAgBCoCCCEUIAQqAgAhFyAEKgIEIRggBCoCGCEZIAQqAhAhFiAEKgIUIRogBCoCKCEVIAQqAiAhEyAEKgIkIRIgAEEANgK8GSAAIBMgACoCsBkiE5QgEiAAKgK0GSISlJIgFSAAKgK4GSIVlJI4ArgZIAAgEyAWlCASIBqUkiAVIBmUkjgCtBkgACAXIBOUIBggEpSSIBQgFZSSOAKwGRDjASALQQR0IgpB2OUBaiAAKQO4GTcCACAKQdDlAWogACkDsBk3AgAgBCoCKCEXIAQqAhghGCAEKgIIIRkgBCoCJCEWIAQqAhQhGiAEKgIEIRsgBCoCICESIAQqAhAhEyAEKgIAIRwgAEHwCWogCmoiDUEANgIMIA0gEyAAKgK0GSIVjCIUlCAcIAAqArAZIhOUkyASIAAqArgZIhKUkzgCACANIBogFJQgEyAblJMgEiAWlJM4AgQgDSAYIBSUIBMgGZSTIBIgF5STOAIIIAUqAiAhFCAFKgIAIRcgBSoCECEYIAUqAiQhGSAFKgIEIRYgBSoCFCEaIAUqAighGyAFKgIIIRwgBSoCGCEdIABBkAJqIApqIgpBADYCDCAKIBMgHJQgFSAdlJIgEiAblJI4AgggCiATIBaUIBUgGpSSIBIgGZSSOAIEIAogEyAXlCAVIBiUkiASIBSUkjgCACALQQFqIQsgDEEBaiIMIA9HDQALCyADIAMoAgAoAlQRAQAiD0EBTgRAQQAhDANAIAMgDCAAQbAZaiADKAIAKAJYEQUAIAUqAgghFCAFKgIAIRcgBSoCBCEYIAUqAhghGSAFKgIQIRYgBSoCFCEaIAUqAighFSAFKgIgIRMgBSoCJCESIABBADYCvBkgACATIAAqArAZIhOUIBIgACoCtBkiEpSSIBUgACoCuBkiFZSSOAK4GSAAIBMgFpQgEiAalJIgFSAZlJI4ArQZIAAgFyATlCAYIBKUkiAUIBWUkjgCsBkQ4wEgC0EEdCIKQdjlAWogACkDuBk3AgAgCkHQ5QFqIAApA7AZNwIAIAQqAighFyAEKgIYIRggBCoCCCEZIAQqAiQhFiAEKgIUIRogBCoCBCEbIAQqAiAhEiAEKgIQIRMgBCoCACEcIABB8AlqIApqIg1BADYCDCANIBMgACoCtBkiFYwiFJQgHCAAKgKwGSITlJMgEiAAKgK4GSISlJM4AgAgDSAaIBSUIBMgG5STIBIgFpSTOAIEIA0gGCAUlCATIBmUkyASIBeUkzgCCCAFKgIgIRQgBSoCACEXIAUqAhAhGCAFKgIkIRkgBSoCBCEWIAUqAhQhGiAFKgIoIRsgBSoCCCEcIAUqAhghHSAAQZACaiAKaiIKQQA2AgwgCiATIByUIBUgHZSSIBIgG5SSOAIIIAogEyAWlCAVIBqUkiASIBmUkjgCBCAKIBMgF5QgFSAYlJIgEiAUlJI4AgAgC0EBaiELIAxBAWoiDCAPRw0ACwsgAiAAQfAJaiAAQbAZaiALIAIoAgAoAkwRBAAgAyAAQZACaiAAQdARaiALIAMoAgAoAkwRBAACQCALQQFIBEBDawteXSEUQwAAAAAhE0MAAAAAIRJDAAAAACEVQwAAAAAhGgwBC0EAIQxDawteXSEUQwAAAAAhGkMAAAAAIRVDAAAAACESQwAAAAAhEwNAEOMBAkAgDEEEdCIKQdDlAWoqAgAiFyAXlCAKQdTlAWoqAgAiGCAYlJJDAAAAACAKQdjlAWoqAgAgDhsiGSAZlJK7RHsUrkfheoQ/ZEEBcw0AIBcgAEHQEWogCmoiDSoCACIWIAUqAgCUIA0qAgQiGyAFKgIElJIgDSoCCCIcIAUqAgiUkiAFKgIwkiAAQbAZaiAKaiINKgIAIh0gBCoCAJQgDSoCBCIeIAQqAgSUkiANKgIIIh8gBCoCCJSSIAQqAjCSk5QgGCAWIAUqAhCUIBsgBSoCFJSSIBwgBSoCGJSSIAUqAjSSIB0gBCoCEJQgHiAEKgIUlJIgHyAEKgIYlJIgBCoCNJKTlJIgGUMAAAAAIBYgBSoCIJQgGyAFKgIklJIgHCAFKgIolJIgBSoCOJIgHSAEKgIglCAeIAQqAiSUkiAfIAQqAiiUkiAEKgI4kpMgDhuUkiIWIBRdQQFzDQAgCkHc5QFqKgIAIRogFyETIBghEiAZIRUgFiEUCyAMQQFqIgwgC0cNAAsLIAIQfBogAxB8GkEAIQsgFEMAAAAAXUUEQCACEHwhFyADEHwhGCAAQcABaiACIAMgAUEAEMcCIQEgBCoCNCEZIAQqAjghFiAEKgIwIRsgAEFAayAEKQIINwMAIAAgBCkCADcDOCAAIAQpAhg3A1AgACAEKQIQNwNIIAQpAighECAEKQIgIREgAEEANgJ0IAAgFiAVIBQgFyAYkkMAAAA/kpIiFJSSOAJwIAAgGSASIBSUkjgCbCAAIBA3A2AgACAbIBMgFJSSOAJoIAAgETcDWCAAIAUpAgg3A4ABIAAgBSkCADcDeCAAIAUpAhg3A5ABIAAgBSkCEDcDiAEgACAFKQIoNwOgASAAIAUpAiA3A5gBIAAgBSkCODcDsAEgACAFKQIwNwOoASAAQeuW+OoFNgK4ASAAQQA6ADAgAEG00AA2AgggAUEANgIQIAEgFYw4AgwgASASjDgCCCABIBOMOAIEIAEgAEE4aiAAQQhqIAlBABBEIAAtADAiAQRAIAAqAiwhFyAAKgIgIRggACoCJCEZIAAqAhwhFiAHQQA2AgwgByAWIBMgFCAXkyIUlJM4AgAgByAZIBUgFJSTOAIIIAcgGCASIBSUkzgCBCAIIAApAiQ3AgggCCAAKQIcNwIAIAYgGjgCDCAGIBU4AgggBiASOAIEIAYgEzgCAAsgAUEARyELCyAAQZAhaiQAIAsL3RkCB38SfSMAQZACayIEJAAgAEEANgI4IARCADcDiAIgBEIANwOAAiAEIAEpAgg3A6gBIAQgASkCADcDoAEgBCABKQIYNwO4ASAEIAEpAhA3A7ABIAQgASkCKDcDyAEgBCABKQIgNwPAASAEIAEpAjg3A9gBIAQgASkCMDcD0AEgBCABKQJINwNoIAQgASkCQDcDYCAEIAEpAlg3A3ggBCABKQJQNwNwIAQgASkCaDcDiAEgBCABKQJgNwOAASAEIAEpAng3A5gBIAQgASkCcDcDkAEgBCAEKgLUASILIAsgBCoClAEiC5JDAAAAP5QiGpM4AtQBIAQgBCoC2AEiDCAMIAQqApgBIgySQwAAAD+UIhuTOALYASAEIAsgGpM4ApQBIAQgDCAbkzgCmAEgBCAEKgLQASILIAsgBCoCkAEiC5JDAAAAP5QiHJM4AtABIAQgCyAckzgCkAEgACgCICgCBEFvakECSUEAIAAoAhwoAgRBb2pBAU0bIQYgACoCLCERIAAqAjAhC0HE5QFBxOUBKAIAQQFqNgIAIABBADYCRCAAQgA3AgwgAEKAgICAgICAwD83AgQgAEL/////DzcCPCAALQA0IQkgACgCGBDmAUMAAAAAIAsgCRshEiAAQQRqIQVDawteXSEMA0AgASoCICEQIAEqAhAhEyABKgIAIRQgASoCJCEVIAEqAhQhFiABKgIEIRcgASoCKCEYIAAqAgwhCyABKgIYIQ0gACoCCCEOIAEqAgghGSAAKgIEIQ8gBEEANgL8ASAEIA0gDowiDZQgDyAZlJMgCyAYlJM4AvgBIAQgFiANlCAPIBeUkyALIBWUkzgC9AEgBCATIA2UIA8gFJSTIAsgEJSTOALwASABKgJgIQ0gASoCQCEQIAEqAlAhEyABKgJkIRQgASoCRCEVIAEqAlQhFiABKgJoIRcgASoCSCEYIAEqAlghGSAEQQA2AuwBIAQgDyAYlCAOIBmUkiALIBeUkjgC6AEgBCAPIBWUIA4gFpSSIAsgFJSSOALkASAEIA8gEJQgDiATlJIgCyANlJI4AuABIARB0ABqIAAoAhwgBEHwAWoQ3AEgBEFAayAAKAIgIARB4AFqENwBIARBADYCPCAEIAQqAlAiCyAEKgLAAZQgBCoCVCIOIAQqAsQBlJIgBCoCWCINIAQqAsgBlJIgBCoC2AGSIg84AjggBCALIAQqArABlCAOIAQqArQBlJIgDSAEKgK4AZSSIAQqAtQBkiITOAI0IAQgCyAEKgKgAZQgDiAEKgKkAZSSIA0gBCoCqAGUkiAEKgLQAZIiFDgCMCAEQQA2AiwgBCAEKgJAIgsgBCoCgAGUIAQqAkQiDSAEKgKEAZSSIAQqAkgiECAEKgKIAZSSIAQqApgBkiIOOAIoIAQgCyAEKgJwlCANIAQqAnSUkiAQIAQqAniUkiAEKgKUAZIiFTgCJCAEIAsgBCoCYJQgDSAEKgJklJIgECAEKgJolJIgBCoCkAGSIgs4AiAgBgRAIARBADYCKCAEQQA2AjhDAAAAACEOQwAAAAAhDwsgBEEANgIcIAQgDyAOkyIPOAIYIAQgFCALkyILOAIQIAQgEyAVkyIOOAIUAkACQAJAIAsgACoCBJQgDiAAKgIIlJIgDyAAKgIMlJIiC0MAAAAAXkEBcw0AIAsgC5QgDCABKgKAAZReQQFzDQAgAEEKNgJEDAELIAAoAhggBEEQahDFBARAQQEhCCAAQQE2AkRBAiEHDAILIAwgC5MiCyAMQ703hjWUX0EBc0UEQEECIQcgAEECQQsgC0MAAAAAXxs2AkRBASEIDAILIAAoAhggBEEQaiAEQTBqIARBIGoQyAQgACgCGCAEEMYERQRAIABBAzYCRAwBCyAEKgIAIgsgC5QgBCoCBCILIAuUkiAEKgIIIgsgC5SSIgtDvTeGNV1BAXNFBEAgBSAEKQMANwIAIAUgBCkDCDcCCCAAQQY2AkQMAQsCQCAMIAuTIAxDAAAANJRfQQFzRQRAIABBDDYCREEBIQhBAiEHDAELIAUgBCkDADcCACAFIAQpAwg3AgggACAAKAJAIgpBAWo2AkBBAiEHIApB6AdKDQAgACgCGCgCAEEERwRAQQAhBwwBCyAAQQ02AkQLIAshDAwBC0EBIQhBAiEHCyAHRQ0AC0MAAAAAIQtDAAAAACARIAkbIg8gEpIhDkEAIQZBACEHIAhBAXEEQCAAKAIYIARB8AFqIARB4AFqEMQEIAQgBSkCCDcDiAIgBCAFKQIANwOAAiAAKgIEIgsgC5QgACoCCCINIA2UkiAAKgIMIhAgEJSSIhG7RC1DHOviNho/Y0EBc0UEQCAAQQU2AkQLQQEhCAJ9IBFDAACAKF5BAXMEQEECIQhDAAAAAAwBCyAEQwAAgD8gEZGVIhEgBCoCgAKUOAKAAiAEIBEgBCoChAKUOAKEAiAEIBEgBCoCiAKUOAKIAiAEIAQqAvABIA8gDJEiE5UiDCALlJM4AvABIAQgBCoC9AEgDCANlJM4AvQBIAQgBCoC+AEgDCAQlJM4AvgBIAQgEiATlSIMIAuUIAQqAuABkjgC4AEgBCAMIA2UIAQqAuQBkjgC5AEgBCAMIBCUIAQqAugBkjgC6AFBASEHQwAAgD8gEZUgDpMLIQsgACAINgI8CwJAIAAoAkhFDQAgACgCFEUNACAAKAJERQ0AIA4gC5K7RHsUrkfheoQ/YyEGCwJAAkACQEEAIAZFIAdBAXMiCBsNACAAKAIUIgZFDQBBwOUBQcDlASgCAEEBajYCACAFQgA3AgggBUIANwIAIAYgACgCGCAAKAIcIAAoAiAgBEGgAWogBEHgAGogBSAEQdAAaiAEQUBrIAMgBigCACgCCBEkAARAQwAAAAAhEEEJIQYgBCoCQCIMIAQqAlAiEZMiEiASlCAEKgJEIhMgBCoCVCIUkyINIA2UkiAEKgJIIhUgBCoCWCIWkyIPIA+UkiIOQwAAgChfQQFzRQRAIAAqAhAhECAAKgIEIhIgEpQgACoCCCINIA2UkiAAKgIMIg8gD5SSIQ4LAkAgDkMAAIAoXkEBcw0AQQghBiALIBEgDJMiDCAMlCAUIBOTIgwgDJSSIBYgFZMiDCAMlJKRjCIMXkF/cyAIQQFzcQ0AIAQgBCkDWDcD+AEgBCAEKQNINwPoASAEIAQpA1A3A/ABIAQgBCkDQDcD4AEgBCAQOAKMAiAEIA9DAACAPyAOkZUiC5Q4AogCIAQgDSALlDgChAIgBCASIAuUOAKAAiAAQQM2AjwgDCELDAMLIAAgBjYCPCAHDQIMAwsgACoCBCINIA2UIAAqAggiECAQlJIgACoCDCIRIBGUkkMAAAAAXkEBcw0AIAQqAlAgBCoCQJMiDCAMlCAEKgJUIAQqAkSTIgwgDJSSIAQqAlggBCoCSJMiDCAMlJKRIA6TIgwgC11Bf3MgCEEBc3FFBEAgBCAEKQNYNwP4ASAEIAQpA0g3A+gBIAQgBCoC+AEgDyARlJM4AvgBIAQgEiARlCAEKgLoAZI4AugBIAQgBCkDQDcD4AEgBCAEKQNQNwPwASAEIBIgDZQgBCoC4AGSOALgASAEIBIgEJQgBCoC5AGSOALkASAEIAQqAvABIA8gDZSTOALwASAEIAQqAvQBIA8gEJSTOAL0ASAEIAUpAgg3A4gCIAQgBSkCADcDgAIgBCAEKgKIAiILQwAAgD8gBCoCgAIiDyAPlCAEKgKEAiIOIA6UkiALIAuUkpGVIguUOAKIAiAEIA4gC5Q4AoQCIAQgDyALlDgCgAIgAEEGNgI8IAwhCwwCCyAAQQU2AjwLIAdFDQELIAtDAAAAAF1FBEAgCyALlCABKgKAAV1BAXMNAQsCQCAAKAJMRQ0AIAAoAhwiASAEQaABaiAEQdAAaiAEQUBrIAEoAgAoAggRBAAgBCoCWCEMIAQqAkghDyAEKgJQIQ4gBCoCQCESIAQqAlQhDSAEKgJEIRAgACgCICIBIARB4ABqIARB0ABqIARBQGsgASgCACgCCBEEACASIA6SQwAAAD+UIAQqAlAgBCoCQJJDAAAAP5STIAQqAoACIg6UIBAgDZJDAAAAP5QgBCoCVCAEKgJEkkMAAAA/lJMgBCoChAIiEpSSIA8gDJJDAAAAP5QgBCoCWCAEKgJIkkMAAAA/lJMgBCoCiAIiDJSSQwAAAABdQQFzDQAgBCAMjDgCiAIgBCASjDgChAIgBCAOjDgCgAILIAUgBCkDgAI3AgAgBSAEKQOIAjcCCCAAIAs4AjggBEEANgJcIAQgGyAEKgLoAZI4AlggBCAaIAQqAuQBkjgCVCAEIBwgBCoC4AGSOAJQIAIgBEGAAmogBEHQAGogCyACKAIAKAIQEQ8ACyAEQZACaiQAC3QAIABCgYCAgBA3AkggAEF/NgI8IABBADoANCAAIAY4AjAgACAFOAIsIAAgBDYCKCAAIAM2AiQgACACNgIgIAAgATYCHCAAIAc2AhggACAINgIUIABCgICAgICAgMA/NwIEIABBjM8ANgIAIABCADcCDCAACysBAX8jAEEQayIBJAAgASAANgIMQTgQDSIAIAEoAgwQtgIgAUEQaiQAIAAL6QEBBn0jAEHQAGsiCSQAIAQqAjQhCiAFKgI0IQsgBCoCOCEMIAUqAjghDSAEKgIwIQ4gBSoCMCEPQQAhACAJQQA2AkwgCSAPIA6TOAJAIAkgDSAMkzgCSCAJIAsgCpM4AkRBASEBAkAgAiAEIAMgBSAJQUBrIAlBCGpBARDNAkUEQEEAIQEgAiAEIAMgBSAJQUBrIAlBCGoQzARFDQELIAcgCSkCDDcCACAHIAkpAhQ3AgggCCAJKQIkNwIIIAggCSkCHDcCACAGIAkpAjQ3AgggBiAJKQIsNwIAIAEhAAsgCUHQAGokACAACxoAIAEgACgCCCIBIAAoAgQgASgCPBEFAEEACxMAIAAoAgxFBEBBAA8LIAAoAhQLEAAgACgCFCABQQJ0aigCAAsHACAAKAIMC3EBAX8CQCABRQ0AIAAoAkAiACgCECICIAFLDQAgAiAAKAIAIAAoAgRsaiABTQ0AIAEgACgCDDYCACAAIAE2AgwgACAAKAIIQQFqNgIIDwsgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALC1IBAn8gACgCQCIAKAIIIgIEQCAAKAIMIgEoAgAhAyAAIAJBf2o2AgggACADNgIMIAEPC0Ho9wFB6PcBKAIAQQFqNgIAIAFBEEGM0gEoAgARAwALPAEBfyMAQRBrIgQkACAEIAA2AgggBCACNgIEIARByM0ANgIAIAEgBCADIAEoAgAoAjARBQAgBEEQaiQAC2UBAX8CQAJAIAEoAtgBQX5qIgBBA0sNAAJAIABBAWsOAgEBAAsgAigC2AFBfmoiA0EDSw0AQQAhACADQQFrDgIAAAELIAEoAoACRQRAQQEPCyABIAIgASgCACgCABEDACEACyAACzkAQQAhAAJAIAEoAswBIgFBBHENACACKALMASICQQRxDQAgAUEDcUUEQEEBDwsgAkEDcUUhAAsgAAtaAQF/IwBBEGsiBCQAIAQgAzYCDCAEIAA2AgggACABKAIEKAIEQZABbGogAigCBCgCBEECdGooAkgiACAEQQhqIAEgAiAAKAIAKAIIEQoAIQAgBEEQaiQAIAAL7AEBBn9BvOUBQbzlASgCAEF/ajYCACAAIAEgACgCACgCFBECACAAKAIUIgIgASgCgAYiBEECdCIFaiIDKAIAIQYgAyACIAAoAgxBf2oiA0ECdCIHaigCADYCACAAKAIUIAdqIAY2AgAgACgCFCAFaigCACAENgKABiAAIAM2AgwCQCABRQ0AIAAoAkQiACgCECICIAFLDQAgAiAAKAIAIAAoAgRsaiABTQ0AIAEgACgCDDYCACAAIAE2AgwgACAAKAIIQQFqNgIIDwsgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALC2ABA38gASgC7AVBAU4EQEEAIQADQAJAIAEgAEG4AWxqIgIoAnQiA0UNAEG05QEoAgAiBEUNACADIAQRAQAaIAJBADYCdAsgAEEBaiIAIAEoAuwFSA0ACwsgAUEANgLsBQuCBgIGfwJ9IwBBEGsiBSQAQbzlAUG85QEoAgBBAWo2AgAgACgCBEECcQR/IAUgASgCwAEiA0GA0gEqAgAgAygCACgCFBEzACIJOAIMIAUgAigCwAEiA0GA0gEqAgAgAygCACgCFBEzACIKOAIIIAVBDGogBUEIaiAJIApdGwVBgNIBCygCACEGIAIqArgBIQkgASoCuAEhCgJAAkAgACgCRCIEKAIIIgcEQCAEKAIMIgMoAgAhCCAEIAdBf2o2AgggBCAINgIMDAELQQAhAyAALQAEQQRxDQFB6PcBQej3ASgCAEEBajYCAEGEBkEQQYzSASgCABEDACEDCyADQYEINgIAIANCADcCfCADQQA6AHggA0EANgJ0IANCADcChAEgA0IANwKMASADQgA3ApQBIANCADcCtAIgA0EAOgCwAiADQQA2AqwCIANCADcCvAIgA0IANwLEAiADQgA3AswCIANCADcC7AMgA0EAOgDoAyADQQA2AuQDIANCADcC9AMgA0IANwL8AyADQgA3AoQEIANBADoAoAUgA0EANgKcBSADQgA3ArwFIANCADcCtAUgA0IANwKsBSADQgA3AqQFIAMgATYC5AUgAyACNgLoBSADQQA2AuwFIAMgBjYC8AUgAyAKIAkgCiAJXRs4AvQFIAMgACgCDCICNgKABgJAIAIgACgCEEcNACACIAJBAXRBASACGyIETg0AAkAgBEUEQEEAIQYMAQtB6PcBQej3ASgCAEEBajYCACAEQQJ0QRBBjNIBKAIAEQMAIQYgACgCDCECCyACQQFOBEBBACEBA0AgBiABQQJ0IgdqIAAoAhQgB2ooAgA2AgAgAUEBaiIBIAJHDQALCyAAKAIUIgEEQCAALQAYBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALIAAoAgwhAgsgAEEANgIUCyAAIAY2AhQgACAENgIQIABBAToAGAsgACgCFCACQQJ0aiADNgIAIAAgAkEBajYCDAsgBUEQaiQAIAMLYQEBfyAAQdzMADYCACAAKAIUIgEEQCAALQAYBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AhQLIABBADYCFCAAQgA3AgwgAEEBOgAYIAAQDgtfAQF/IABB3MwANgIAIAAoAhQiAQRAIAAtABgEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYCFAsgAEEANgIUIABCADcCDCAAQQE6ABggAAvLAgIEfwF9IwBB0ABrIgMkAAJAIAEgACgCACgCACIEIAAoAgQoAgAiBSABKAIAKAIYEQcARQ0AIAQoAsABIQYgA0J/NwNIIAMgBEEEajYCRCADIAQ2AkAgAyAGNgI8IANBADYCOCAFKALAASEGIANCfzcDMCADIAVBBGo2AiwgAyAFNgIoIAMgBjYCJCADQQA2AiAgACgCCEUEQCAAIAEgA0E4aiADQSBqQQAgASgCACgCCBEKACIBNgIIIAFFDQELIAMgA0EgajYCDCADIANBOGo2AgggA0EANgIEIANBtOAANgIAIAMhASAAKAIIIQAgAigCCEEBRgRAIAAgA0E4aiADQSBqIAIgASAAKAIAKAIIEQkADAELIAAgBCAFIAIgASAAKAIAKAIMERoAIQcgAioCDCAHXkEBcw0AIAIgBzgCDAsgA0HQAGokAAuxAQECfyAAQQI2AgQgAEHczAA2AgAgACABNgKIKSAAQbTgADYCHCAAQY8DNgI8IABBAToAGCAAQQA2AhQgAEIANwIMIAAgASABKAIAKAIMEQEANgJAIAAgASABKAIAKAIIEQEANgJEA0BBACEBA0AgACACQZABbGogAUECdGogACgCiCkiAyACIAEgAygCACgCEBEHADYCSCABQQFqIgFBJEcNAAsgAkEBaiICQSRHDQALC98HAgp/DX0jAEEQayEGIAEqAgAgAyoCACISIAIqAgAiEJJDAAAAP5QiE5MiESASIBCTIhJDAAAAP5QiG14iB0EDdCARIBJDAAAAv5QiEl0iCHIgASoCBCADKgIEIhAgAioCBCIUkkMAAAA/lCIVkyIWIBAgFJMiEEMAAAC/lCIXXSIJQQF0ciAWIBBDAAAAP5QiFF4iCkEEdHIgASoCCCADKgIIIhAgAioCCCIYkkMAAAA/lCIakyIZIBAgGJMiEEMAAAC/lCIcXSIBQQJ0ciAZIBBDAAAAP5QiGF5BBXRyIgIgACoCACATkyITIBteIgNBA3QgEyASXSILciAAKgIEIBWTIhUgF10iDEEBdHIgFSAUXiINQQR0ciAAKgIIIBqTIhcgHF0iDkECdHIgFyAYXkEFdHIiD3FFBEAgBCoCACESIAZCADcDCCAGQgA3AwAgESATkyEaIBOMIRAgBkEEciEAAkAgC0EBc0UEQCAQIBuTIBqVIhFDAAAAAGBBAXMEQEMAAAAAIREMAgsgAEIANwIAIABBADYCCCAGQYCAgPwDNgIADAELQwAAAAAhESAIQQFzDQAgECAbkyAalSIQIBJdQQFzDQAgECESCyAWIBWTIRYgFYwhEAJAAkAgDARAIBEgECAUkyAWlSIQX0EBcw0BIAZCADcDCCAGQgA3AwAgBkGAgID8AzYCBAwCCyAJQQFzDQAgECAUkyAWlSIQIBJdQQFzDQAgECESCyARIRALIBkgF5MhGSAXjCERAkACQCAOQQFzRQRAIBAgESAYkyAZlSIRX0EBcw0BIAZCADcDCCAGQYCAgPwDNgIIIAZCADcDAAwCCyABQQFzDQAgESAYkyAZlSIRIBJdQQFzDQAgESESCyAQIRELAkACQCADQQFzRQRAIBEgGyATkyAalSIQX0EBcw0BIABCADcCACAAQQA2AgggBkGAgID8ezYCAAwCCyAHQQFzDQAgGyATkyAalSIQIBJdQQFzDQAgECESCyARIRALAkACQCANQQFzRQRAIBAgFCAVkyAWlSIRX0EBcw0BIAZCADcDCCAGQgA3AwAgBkGAgID8ezYCBAwCCyAKQQFzDQAgFCAVkyAWlSIRIBJdQQFzDQAgESESCyAQIRELAkACQCAPQSBxBEAgESAYIBeTIBmVIhBfQQFzDQEgBkIANwMIIAZBgICA/Hs2AgggBkIANwMADAILIAJBIHFFDQAgGCAXkyAZlSIQIBJdQQFzDQAgECESCyARIRALIBAgEl9BAXNFBEAgBCAQOAIAIAUgBikDCDcCCCAFIAYpAwA3AgBBAQ8LC0EAC5IBAQV/IAMgACgCvAEgAxshAyABKAIAIQcCQCAAKAKMAiIFQQFIDQAgACgClAIhBgNAIAcgBiAEQQJ0aiIIKAIARwRAIARBAWoiBCAFRw0BDAILCyAEIAVODQAgCCAGIAVBf2oiBEECdGooAgA2AgAgACAENgKMAiAAKAKcAiIAIAMgASACIAAoAgAoAgwRCgAaCwv1AgEGfyACIAAoArwBIAIbIQggASgCACEGAkACQCAAKAKMAiIDQQFIDQAgACgClAIhAgNAIAYgAiAEQQJ0aigCAEcEQCAEQQFqIgQgA0cNAQwCCwsgAyAERw0BCwJAIAMgACgCkAJHDQAgAyADQQF0QQEgAxsiBU4NAAJ/IAUEQEHo9wFB6PcBKAIAQQFqNgIAIAVBAnRBEEGM0gEoAgARAwAhByAAKAKMAiEDCyADQQFOCwRAQQAhBANAIAcgBEECdCICaiAAKAKUAiACaigCADYCACAEQQFqIgQgA0cNAAsLIAAoApQCIgIEQCAALQCYAgRAIAIEQEHs9wFB7PcBKAIAQQFqNgIAIAJBkNIBKAIAEQAACyAAKAKMAiEDCyAAQQA2ApQCCyAAIAc2ApQCIAAgBTYCkAIgAEEBOgCYAgsgACgClAIgA0ECdGogBjYCACAAIANBAWo2AowCIAAoApwCIgAgCCABIAAoAgAoAggRBwAaCwvTAQEBfyAAQezLADYCACAAKAKcAiIBIAEoAgAoAgARAQAaIAAoApwCIgEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACyAAQcDLADYCACAAKAKUAiIBBEAgAC0AmAIEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYClAILIABBADYClAIgAEIANwKMAiAAQQE6AJgCIABB5MoANgIAIAAEQEHs9wFB7PcBKAIAQQFqNgIAIABBkNIBKAIAEQAACwuzAQEBfyAAQezLADYCACAAKAKcAiIBIAEoAgAoAgARAQAaIAAoApwCIgEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACyAAQcDLADYCACAAKAKUAiIBBEAgAC0AmAIEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYClAILIABBADYClAIgAEIANwKMAiAAQQE6AJgCIABB5MoANgIAIAALYgEBfyAAEKoBIABBADYClAIgAEEBOgCYAiAAQgA3AowCIABBBDYC7AEgAEHsywA2AgACf0Ho9wFB6PcBKAIAQQFqNgIAQcwAQRBBjNIBKAIAEQMAIgELELMCIAAgATYCnAILbwECfwJAIAAoAowCIgJBAUgNACAAKAKUAiEDIAEoAgAhBEEAIQEDQCAEIAMgAUECdGoiBSgCAEcEQCABQQFqIgEgAkcNAQwCCwsgASACTg0AIAUgAyACQX9qIgFBAnRqKAIANgIAIAAgATYCjAILC9QCAQR/IAEoAgAhBAJAAkAgACgCjAIiAkEBSA0AIAAoApQCIQNBACEBA0AgBCADIAFBAnRqKAIARwRAIAFBAWoiASACRw0BDAILCyABIAJHDQELAkAgAiAAKAKQAkcNACACIAJBAXRBASACGyIDTg0AAn8gAwRAQej3AUHo9wEoAgBBAWo2AgAgA0ECdEEQQYzSASgCABEDACEFIAAoAowCIQILIAJBAU4LBEBBACEBA0AgBSABQQJ0IgZqIAAoApQCIAZqKAIANgIAIAFBAWoiASACRw0ACwsgACgClAIiAQRAIAAtAJgCBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALIAAoAowCIQILIABBADYClAILIAAgBTYClAIgACADNgKQAiAAQQE6AJgCCyAAKAKUAiACQQJ0aiAENgIAIAAgAkEBajYCjAILC44BAQF/IABBwMsANgIAIAAoApQCIgEEQCAALQCYAgRAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgKUAgsgAEEANgKUAiAAQgA3AowCIABBAToAmAIgAEHkygA2AgAgAARAQez3AUHs9wEoAgBBAWo2AgAgAEGQ0gEoAgARAAALC24BAX8gAEHAywA2AgAgACgClAIiAQRAIAAtAJgCBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2ApQCCyAAQQA2ApQCIABCADcCjAIgAEEBOgCYAiAAQeTKADYCACAACxgBAX8jAEEQayIBIAA2AgwgASgCDEEMagswACAAEKoBIABBAToAmAIgAEHAywA2AgAgAEEANgKUAiAAQgA3AowCIABBBDYC7AELBQBBgAILSwEBfyABIAEgACAAKAIAKAIQEQEAQQEgASgCACgCEBEHACICIAAgAigCCCABIAAoAgAoAhQRBwBBw56J0gQgACABKAIAKAIUEQkACy0AIABB5MoANgIAIAAEQEHs9wFB7PcBKAIAQQFqNgIAIABBkNIBKAIAEQAACwsNACAAQeTKADYCACAAC88LAwd/AX4efSMAQTBrIgYkACAGQQA6ABggBSAAKQIINwIIIAUgACkCADcCACAFIAUtABBBD3I6ABACQEF/IAAqAggiISABKgIIIhGTIhogAyoCACIiIAEqAgAiDpMiDyAEKgIEIiMgASoCBCIQkyISlCADKgIEIiQgEJMiFSAEKgIAIiUgDpMiE5STIhaUIAAqAgAiJiAOkyIfIBUgBCoCCCInIBGTIheUIAMqAggiKCARkyIYIBKUkyIZlCAAKgIEIikgEJMiICAYIBOUIA8gF5STIhSUkpIgAioCCCIbIBGTIhwgFpQgAioCACIWIA6TIh0gGZQgAioCBCIZIBCTIh4gFJSSkiIUlEMAAAAAXSAUIBSUQ3bMKzJdGyIIQX8gHyAeIBiUIBwgFZSTIhSUICAgHCAPlCAdIBiUkyIqlJIgHSAVlCAeIA+UkyIrIBqUkiAUIBOUICogEpSSICsgF5SSIhSUQwAAAABdIBQgFJRDdswrMl0bIglyQX8gGiAeIBOUIB0gEpSTIhqUIB8gHCASlCAeIBeUkyISlCAgIB0gF5QgHCATlJMiE5SSkiAYIBqUIA8gEpQgFSATlJKSIg+UQwAAAABdIA8gD5RDdswrMl0bIgpyQX8gISAbkyAkIBmTIg8gJSAWkyISlCAiIBaTIhUgIyAZkyITlJMiF5QgJiAWkyAoIBuTIhggE5QgDyAnIBuTIg+UkyITlCApIBmTIBUgD5QgGCASlJMiD5SSkiARIBuTIBeUIA4gFpMgE5QgECAZkyAPlJKSIhGUQwAAAABdIBEgEZRDdswrMl0bIgtyIgxBf0wEQCAFQQE6ACQMAQsgDEUNAAJ9Q///f38gCUUNABogACABIAIgAyAGQQhqEKsBQ///f38gBioCCCIRIAAqAgCTIg4gDpQgBioCDCIOIAAqAgSTIg8gD5SSIAYqAhAiDyAAKgIIkyIQIBCUkiIQQ///f39dQQFzDQAaIAUgBigCFDYCDCAFIA84AgggBSAOOAIEIAUgETgCACAFIAYtABgiB0EBcSAFLQAQQfABcXIgB0ECcXIgB0EEcXI6ABAgBigCJCEHIAYpAhwhDSAFQQA2AiAgBSAHNgIcIAUgDTcCFCAQCyERAkAgCEUNACAAIAEgAyAEIAZBCGoQqwEgBioCCCIPIAAqAgCTIg4gDpQgBioCDCIQIAAqAgSTIg4gDpSSIAYqAhAiEiAAKgIIkyIOIA6UkiIOIBFdQQFzDQAgBSAGKAIUNgIMIAUgEjgCCCAFIBA4AgQgBSAPOAIAIAUgBi0AGCIHQQFxIAUtABBB8AFxciAHQQF0IgdBBHFyIAdBCHFyOgAQIAYpAyAhDSAGKAIcIQcgBUEANgIYIAUgDTcCHCAFIAc2AhQgDiERCwJAIApFDQAgACABIAQgAiAGQQhqEKsBIAYqAggiDyAAKgIAkyIOIA6UIAYqAgwiECAAKgIEkyIOIA6UkiAGKgIQIhIgACoCCJMiDiAOlJIiDiARXUEBcw0AIAUgBigCFDYCDCAFIBI4AgggBSAQOAIEIAUgDzgCACAFIAYtABgiAUEBcSAFLQAQQfABcXIgAUEBdkECcXIgAUECdEEIcXI6ABAgBigCJCEBIAYoAhwhByAFIAYoAiA2AiAgBUEANgIcIAUgATYCGCAFIAc2AhQgDiERCyALRQRAQQEhBwwBCyAAIAIgBCADIAZBCGoQqwFBASEHIAYqAggiDiAAKgIAkyIPIA+UIAYqAgwiDyAAKgIEkyIQIBCUkiAGKgIQIhAgACoCCJMiEiASlJIgEV1BAXMNACAFIAYoAhQ2AgwgBSAQOAIIIAUgDzgCBCAFIA44AgAgBSAGLQAYIgBBBHEgBS0AEEHwAXFyIABBAXRBAnFyIABBAnRBCHFyOgAQIAYoAiQhACAGKAIcIQEgBSAGKAIgNgIgIAUgADYCHCAFIAE2AhggBUEANgIUCyAGQTBqJAAgBwutAwIEfw99IwBBIGsiAyQAIAEoAgQgASgCfCIGQQF1aiEFIAEoAnghBCAFKAIAIARqKAIAIAQgBkEBcRshBCABKgIQIQogASoCDCELIAEqAiAhDCABKgIYIQ0gASoCHCEOIAEqAjAhDyABKgIoIRAgASoCLCERIAEqAgghEiACKgIIIQcgAioCACEIIAIqAgQhCSADQQA2AgwgAyAIIBCUIAkgEZSSIAcgD5SSOAIIIAMgCCANlCAJIA6UkiAHIAyUkjgCBCADIBIgCJQgCyAJlJIgCiAHlJI4AgAgA0EQaiAFIAMgBBEFACABKgJoIQogAUFAayoCACELIAEqAjwhDCABKgJsIQ0gASoCUCEOIAEqAkghDyABKgJMIRAgASoCcCERIAEqAmAhEiABKgJYIRMgASoCXCEUIAEqAjghFSADKgIYIQcgAyoCECEIIAMqAhQhCSAAQQA2AgwgACARIAggE5QgCSAUlJIgByASlJKSOAIIIAAgDSAIIA+UIAkgEJSSIAcgDpSSkjgCBCAAIAogCCAVlCAJIAyUkiAHIAuUkpI4AgAgA0EgaiQAC6oQAgl/CX0jAEEQayILJAACfwJAIAEoAvQCIgUoAiBBAkkNACABEGNFDQAgACgCwEgiBARAIABBzMgAaigCACEDIABBxMgAaigCACEHA0AgBCgCMCIGBEAgBiAEKAIsNgIsCyAEKAIsIgYEQCAGIAQoAjA2AjALIAQgACgCwEhGBEAgACAEKAIwNgLASAsgBEEANgIsIAQgACgCyEg2AjAgACgCyEgiBgRAIAYgBDYCLAsgB0F/aiEHIAAgBDYCyEggA0EBaiEDIAAoAsBIIgQNAAsgACADNgLMSCAAIAc2AsRICyAAQQA2ArxIIABBADYCAAJAIAUoAgAiAyoCECAFKAIMIgcqAhAiDJMiECAFKAIEIgQqAhQgByoCFCINkyIPlCAFKAIIIgYqAhggByoCGCIOkyIRlCADKgIUIA2TIhIgBCoCGCAOkyITlCAGKgIQIAyTIhSUIAMqAhggDpMiDiAEKgIQIAyTIgyUIAYqAhQgDZMiDZSSIBAgE5QgDZSTIBIgDJQgEZSTkiAOIA+UIBSUk0MAAAAAXUEBcwRAIAQhByADIQQMAQsgBSADNgIEIAUgBDYCACAFKAIQIQcgBSAFKAIUNgIQIAUgBzYCFCADIQcLIAAgBCAHIAZBARCsASEHIAAgBSgCBCAFKAIAIAUoAgxBARCsASEGIAAgBSgCCCAFKAIEIAUoAgxBARCsASEJIAAgBSgCACAFKAIIIAUoAgxBARCsASEIIABBxMgAaigCAEEERw0AIAAoAsBIIgMqAhAhDCADKAIwIgQEQCAMIAyUIQwDQCAEIAMgBCoCECINIA2UIg0gDF0iAhshAyANIAwgAhshDCAEKAIwIgQNAAsgAyoCECEMCyADKAIcIQIgAygCGCEFIAMoAhQhCiADKgIMIQ8gAyoCCCEQIAMqAgQhDiADKgIAIQ0gByAGNgIgIAdBADoANCAGIAc2AiAgBkEAOgA0IAcgCTYCJCAHQQA6ADUgCSAHNgIgIAlBAToANCAHIAg2AiggB0EAOgA2IAggBzYCICAIQQI6ADQgBiAINgIkIAZBAjoANSAIIAY2AiggCEEBOgA2IAYgCTYCKCAGQQE6ADYgCSAGNgIkIAlBggI7ADUgCSAINgIoIAggCTYCJCAIQQI6ADUgAEEANgIAQQAhBwNAAkACQCAAKAK8SCIGQT9NBEBBACEEIAtBADYCCCALQgA3AwAgACAGQQFqNgK8SCADIAdBAWoiBzoANyABIAMgACAGQQV0aiIGQTxqIggQRSADKgIAIAYqAkyUIAMqAgQgBioCUJSSIAMqAgggBioCVJSSIAMqAhCTQxe30TheRQRAIABBBzYCAAwDCwNAIAAgByAIIAMgBEECdGooAiAgAyAEai0ANCALEMwCIgZFDQIgBEECSSEJIARBAWohBCAJDQALDAELIABBBjYCAAwBCyAGIAsoAghBAktxRQRAIABBBDYCAAwBCyALKAIAIgIgCygCBCIENgIkIAJBAjoANSAEIAI2AiggBEEBOgA2IAMoAjAiAgRAIAIgAygCLDYCLAsgAygCLCICBEAgAiADKAIwNgIwCyADIAAoAsBIRgRAIAAgAygCMDYCwEgLIAAgACgCxEhBf2o2AsRIIANBADYCLCADIAAoAshINgIwIAAoAshIIgIEQCACIAM2AiwLIAAgAzYCyEggACAAKALMSEEBajYCzEggACgCwEgiAyoCECEMIAMoAjAiBARAIAwgDJQhDANAIAQgAyAEKgIQIg0gDZQiDSAMXSICGyEDIA0gDCACGyEMIAQoAjAiBA0ACyADKgIQIQwLIAMoAhwhAiADKAIYIQUgAygCFCEKIAMqAgwhDyADKgIIIRAgAyoCBCEOIAMqAgAhDSAHQf8BRw0BCwsgACAMOAI4IAAgDTgCKCAAIAo2AgQgACAPOAI0IAAgEDgCMCAAIA44AiwgAEEDNgIkIAAgAjYCDCAAIAU2AgggACAFKgIQIA0gDJQiDZMiDyACQRRqKgIAIA4gDJQiDpMiEZQgBUEUaioCACAOkyISIAIqAhAgDZMiE5STIhQgFJQgEiACQRhqKgIAIBAgDJQiDJMiEJQgBUEYaioCACAMkyISIBGUkyIRIBGUIBIgE5QgDyAQlJMiECAQlJKSkSIQOAIUIAAgAioCECANkyIPIApBFGoqAgAgDpMiEZQgAioCFCAOkyISIAoqAhAgDZMiE5STIhQgFJQgEiAKQRhqKgIAIAyTIhKUIAIqAhggDJMiFCARlJMiESARlCAUIBOUIA8gEpSTIg8gD5SSkpEiDzgCGCAAIAoqAhAgDZMiESAFKgIUIA6TIhKUIAoqAhQgDpMiDiAFKgIQIA2TIg2UkyITIBOUIA4gBSoCGCAMkyIOlCAKKgIYIAyTIgwgEpSTIhIgEpQgDCANlCARIA6UkyIMIAyUkpKRIgwgDCAQIA+SkiIMlTgCHCAAIA8gDJU4AhggACAQIAyVOAIUIAAoAgAMAQsgAEEINgIAIAIqAgAhDCACKgIEIQ0gAioCCCEOIABBADYCNCAAIA6MIhA4AjAgACANjCIPOAIsIAAgDIwiETgCKAJAIAwgDJQgDSANlJIgDiAOlJKRIgxDAAAAAF5BAXNFBEAgAEMAAIA/IAyVIgwgEJQ4AjAgACAMIA+UOAIsIAAgDCARlDgCKAwBCyAAQQA2AjAgAEKAgID8AzcCKAsgAEIANwI0IABBATYCJCAFKAIAIQEgAEGAgID8AzYCFCAAIAE2AgRBCAshBCALQRBqJAAgBAuTCQIFfxZ9IwBB4ABrIgYkACAGIAM2AlwgBiACNgJYIAYgATYCVCAGIAA2AlAgAyoCACELIAAqAgAhEiADKgIEIQwgACoCBCEUIAMqAgghDiAAKgIIIRUgBkEANgIsIAYgFSAOkyIQOAIoIAYgFCAMkyIROAIkIAYgEiALkyITOAIgIAEqAgAhFiABKgIEIRcgASoCCCEaIAZBADYCPCAGIBogDpMiDzgCOCAGIBcgDJMiGDgCNCAGIBYgC5MiGTgCMCACKgIAIRsgAioCBCEcIAIqAgghHSAGQQA2AkwgBiAdIA6TIh44AkggBiAcIAyTIh84AkQgBiAbIAuTIiA4AkBDAACAvyENAkAgEyAYlCAelCARIA+UICCUIBAgGZQgH5SSIBMgD5QgH5STIBEgGZQgHpSTkiAQIBiUICCUkyIPQwAAAABbIA8gD1xyDQAgDyAVIBQgF5MiGCAWIBuTIhmUIBIgFpMiFiAXIByTIheUk5QgEiAVIBqTIhIgF5QgGCAaIB2TIhWUk5QgFCAWIBWUIBIgGZSTlJKSlEMAAAAAX0EBcw0AIAZBADYCGCAGQgA3AxAgBkEANgIMA0ACQCAPIBEgBkEgaiAHQQJ0IghBuMoAaigCACIJQQR0aiIKKgIIIhKUIBAgCioCBCIUlJMgC5QgDCAQIAoqAgAiC5QgEiATlJOUkiAUIBOUIBEgC5STIA6UkpRDAAAAAF5BAXMNACANQwAAAABdRUEAIAZB0ABqIAhqKAIAIAlBAnQiCiAGQdAAamooAgAgAyAGQRBqIAZBDGoQywQiCyANXUEBcxsNACAFQQEgCXQgBigCDCIJQR50QR91cSAJQQF0QQhxakEAIAlBAXFrQQEgB3RxajYCACAEIAhqIAYoAhA2AgAgBCAKaiAGKAIUNgIAIAQgCkG4ygBqKAIAQQJ0akEANgIAIAQgBigCGDYCDCALIQ0LIAdBAWoiB0EDRwRAIAZBIGogB0EEdGoiCCoCACETIAgqAgghECAIKgIEIREgAyoCCCEOIAMqAgQhDCADKgIAIQsMAQsLIA1DAAAAAF1FDQAgBUEPNgIAIAQgAioCBCINIAEqAggiC5QgAyoCACIMlCACKgIIIg4gASoCACIQlCADKgIEIhGUkiARIAsgAioCACILlJSTIA0gEJQgAyoCCCINlJMgDSALIAEqAgQiDZSUkiAMIA4gDZSUkyAPlSINOAIAIAQgACoCBCILIAIqAggiDJQgAyoCACIOlCAAKgIIIhAgAioCACIRlCADKgIEIhOUkiATIAwgACoCACIMlJSTIAsgEZQgAyoCCCILlJMgCyAMIAIqAgQiC5SUkiAOIBAgC5SUkyAPlSILOAIEIAQgASoCBCIMIAAqAggiDpQgAyoCACIQlCABKgIIIhEgACoCACITlCADKgIEIhKUkiASIA4gASoCACIOlJSTIAwgE5QgAyoCCCIMlJMgDCAOIAAqAgQiDJSUkiAQIBEgDJSUkyAPlSIPOAIIIARDAACAPyANIAuSIA+SkzgCDEMAAAAAIQ0LIAZB4ABqJAAgDQuhAQIDfwV9AkAgACgC7AUiBEEBSARAQX8hAgwBCyABKgIIIQcgASoCBCEIIAEqAgAhCSAAKgLwBSIGIAaUIQZBACEBQX8hAgNAIAAgAUG4AWxqIgMqAgQgCZMiBSAFlCADKgIIIAiTIgUgBZSSIAMqAgwgB5MiBSAFlJIiBSAGIAUgBl0iAxshBiABIAIgAxshAiABQQFqIgEgBEcNAAsLIAIL2Q8CAn8lfUEDQQJBAUEAQX8gACoCVCIEIAEqAlAiBV0iAhsgACoCjAIiBiAEIAUgAhsiBF0iAhsgACoCxAMiBSAGIAQgAhsiBF0iAhsgACoC/AQgBSAEIAIbXSIDGyECIAEqAgAhCAJ9AkACQAJAQYTSAS0AAARAIAJFBEAgACoCtAQiFiAAKgL8AiITkyEGIAAqArAEIhcgACoC+AIiFJMhCiAAKgKsBCIHIAAqAvQCIhiTIQsgASoCCCEEIAEqAgQhBQwCCyAIIAAqArwBIgmTIgwgACoCsAQiFyAAKgL4AiIUkyIKlCABKgIEIgUgACoCwAEiDZMiBCAAKgKsBCIHIAAqAvQCIhiTIguUkyIGIAaUIAQgACoCtAQiFiAAKgL8AiITkyIGlCABKgIIIgQgACoCxAEiEpMiDyAKlJMiECAQlCAPIAuUIAwgBpSTIgwgDJSSkiEjIAJBAUcNASAIIAAqAgSTIQggBCAAKgIMkyEEIAUgACoCCJMhBUMAAAAAIQsMAgsCQAJAAkAgAkUEQCAAKgL8AiISIAAqArQEIgyTIQsgACoC+AIiDSAAKgKwBCIPkyEZIAAqAvQCIgkgACoCrAQiEJMhGiABKgIIIhMgDJMhCiABKgIEIhQgD5MhHyAIIBCTISAgEyASkyEFIBQgDZMhBCAIIAmTIQYMAQsgCCAAKgK8ASIdkyIXIAAqAvgCIg0gACoCsAQiD5MiGZQgASoCBCIUIAAqAsABIh6TIhYgACoC9AIiCSAAKgKsBCIQkyIalJMiBCAElCAWIAAqAvwCIhIgACoCtAQiDJMiC5QgASoCCCITIAAqAsQBIgeTIhggGZSTIgQgBJQgGCAalCAXIAuUkyIEIASUkpIiCiAIIAmTIgYgHiAPkyIblCAUIA2TIgQgHSAQkyIklJMiBSAFlCAEIAcgDJMiJZQgEyASkyIFIBuUkyIOIA6UIAUgJJQgBiAllJMiDiAOlJKSIg4gCiAOXhsiDiAeIA2TIgogCCAQkyIglCAdIAmTIhEgFCAPkyIflJMiFSAVlCAHIBKTIhUgH5QgCiATIAyTIgqUkyIcIByUIBEgCpQgFSAglJMiESARlJKSIhEgDiARXhshIyACQQFHDQAgACoCBCIOIBCTISYgCCAOkyEcIAAqAgwiESAMkyEnIAAqAggiFSAPkyEoIBMgEZMhISAUIBWTISJDAAAAACELDAELIAggACoCBCIOkyIcIBmUIBQgACoCCCIVkyIiIBqUkyIHIAeUICIgC5QgEyAAKgIMIhGTIiEgGZSTIgcgB5QgISAalCAcIAuUkyILIAuUkpIiCyAGIBUgD5MiKJQgBCAOIBCTIiaUkyIHIAeUIAQgESAMkyInlCAFICiUkyIHIAeUIAUgJpQgBiAnlJMiByAHlJKSIgcgCyAHXhsiCyAVIA2TIhkgIJQgDiAJkyIaIB+UkyIHIAeUIBEgEpMiGyAflCAZIAqUkyIHIAeUIBogCpQgGyAglJMiByAHlJKSIgcgCyAHXhshCyATIAAqAsQBIgeTIRggFCAAKgLAASIekyEWIAggACoCvAEiHZMhFyACQQJGBEAgESAHkyEMIBUgHpMhDyAOIB2TIRBDAAAAACEKDAILIAcgDJMhJSAeIA+TIRsgHSAQkyEkCyAcIBuUICIgJJSTIgQgBJQgIiAllCAhIBuUkyIEIASUICEgJJQgHCAllJMiBCAElJKSIgQgFyAolCAWICaUkyIFIAWUIBYgJ5QgGCAolJMiBSAFlCAYICaUIBcgJ5STIgUgBZSSkiIFIAQgBV4bIgQgFSAekyIPICCUIA4gHZMiECAflJMiBSAFlCARIAeTIgwgH5QgDyAKlJMiBSAFlCAQIAqUIAwgIJSTIgUgBZSSkiIFIAQgBV4bIQpDAAAAACADDQQaIBEgEpMhGyAVIA2TIRkgDiAJkyEaIBMgEpMhBSAUIA2TIQQgCCAJkyEGCyAcIB4gDZMiCJQgIiAdIAmTIgmUkyINIA2UICIgByASkyINlCAhIAiUkyIIIAiUICEgCZQgHCANlJMiCCAIlJKSIgggFyAZlCAWIBqUkyIJIAmUIBYgG5QgGCAZlJMiCSAJlCAYIBqUIBcgG5STIgkgCZSSkiIJIAggCV4bIgggDyAGlCAQIASUkyIJIAmUIAwgBJQgDyAFlJMiBCAElCAQIAWUIAwgBpSTIgQgBJSSkiIEIAggBF4bDAMLIAggACoCBJMiCCAKlCAFIAAqAgiTIgUgC5STIgkgCZQgBSAGlCAEIAAqAgyTIgQgCpSTIgogCpQgBCALlCAIIAaUkyIGIAaUkpIhCyAAKgLEASESIAAqAsABIQ0gACoCvAEhCUMAAAAAIQogAkECRg0BCyAIIBcgDZMiBpQgBSAHIAmTIgqUkyIMIAyUIAUgFiASkyIMlCAEIAaUkyIGIAaUIAQgCpQgCCAMlJMiBiAGlJKSIQpDAAAAACADDQEaCyAIIBQgDZMiBpQgBSAYIAmTIgmUkyINIA2UIAUgEyASkyIFlCAEIAaUkyIGIAaUIAQgCZQgCCAFlJMiBCAElJKSCyEGQQNBAkEBQQBBfyAjiyIEQ2sLXt1eIgAbIAuLIgUgBENrC17dIAAbIgReIgAbIAqLIgogBSAEIAAbIgReIgAbIAaLIAogBCAAG14bC98BACAAQYEINgIAIABCADcCfCAAQQA6AHggAEEANgJ0IABCADcChAEgAEIANwKMASAAQgA3ApQBIABCADcCtAIgAEEAOgCwAiAAQQA2AqwCIABCADcCvAIgAEIANwLEAiAAQgA3AswCIABCADcC7AMgAEEAOgDoAyAAQQA2AuQDIABCADcC9AMgAEIANwL8AyAAQgA3AoQEIABBADoAoAUgAEEANgKcBSAAQgA3AqQFIABCADcCrAUgAEIANwK0BSAAQgA3ArwFIABBADYC7AUgAEEANgKABiAAQgA3AuQFC7UDAgJ/DH1DAACAPyEFAkAgASgCACIDIAAoAlBGDQAgAy0AzAFBBHENAAJ9IAIEQCABKgIQIQYgASoCDCEHIAEqAggMAQsgASoCCCIIIAMqAiSUIAEqAgwiCSADKgIolJIgASoCECIKIAMqAiyUkiEGIAggAyoCFJQgCSADKgIYlJIgCiADKgIclJIhByADKgIEIAiUIAMqAgggCZSSIAMqAgwgCpSSCyAAKgJUlCAHIAAqAliUkiAGIAAqAlyUkiAAKgJkXQ0AIAEoAighBCAAIAM2AkwgACAENgIEAkAgAgRAIAAgASkCCDcCLCAAIAEpAhA3AjQMAQsgAyoCCCEIIAMqAgwhCSADKgIUIQogAyoCGCELIAMqAhwhDCADKgIkIQ0gAyoCKCEOIAEqAgwhBSADKgIsIQ8gASoCECEGIAMqAgQhECABKgIIIQcgAEEANgI4IAAgByANlCAFIA6UkiAGIA+UkjgCNCAAIAcgCpQgBSALlJIgBiAMlJI4AjAgACAQIAeUIAggBZSSIAkgBpSSOAIsCyAAIAEpAhg3AjwgACABKQIgNwJEIAEqAighBQsgBQsiACAAIAEgACgCACgCIBECACAAIAEgAiAAKAIAKAIkEQsACwoAIAAgAToAtAELHgAgACoCEEMAAAAAXARAQQAPCyAAKgIUQwAAAABbCyQAIAAgACgCACgCKBEBAARAIABBAToAqQEgACAAKAIcNgIQCwsPACAAIAAoAgAoAjARAQALmAQCAn8EfSMAQdAAayIDJAAgAC0AqwFFQQAgACoCrAFDAAAAAF8bRQRAIAAgACAAKAIAKAIwEQEAOgCoASAAIAAqAhAgACoCLCAClJMiBTgCEAJAIAVDAAAAAF5BAXMNACAFIAAqAhwiBl5BAXMNACAAIAY4AhAgBiEFCwJAIAVDAAAAAF1BAXMNACAFiyAAKgIYiyIGXkEBcw0AIAAgBowiBTgCEAsgACAFIAKUOAIUIAMgACgCCCIEKQIMNwMYIAMgBCkCBDcDECADIAQpAhw3AyggAyAEKQIUNwMgIAMgBCkCLDcDOCADIAQpAiQ3AzAgAyAEKQI8NwNIIAMgBCkCNDcDQCAAIAEQ8w0gA0FAayEEAkAgAC0AqwEEQCAAIAEgAEE8ahDPBAwBCyAAIAAqAqwBIgUgApM4AqwBIABBQGsqAgAhBiAAKgJEIQcgACoCPCEIIANBADYCDCADIAcgAiAFIAUgAl4bIgWUOAIIIAMgBSAGlDgCBCADIAUgCJQ4AgAgACABIAMQzwQLIAAgASACEPANIAQgACkCZDcCCCAEIAApAlw3AgAgACgCCCIAIAAoAoQCQQFqNgKEAiAAIAMpAxg3AgwgACADKQMQNwIEIAAgAykCKDcCHCAAIAMpAiA3AhQgACADKQIwNwIkIAAgAykCODcCLCAAIAQpAgA3AjQgACAEKQIINwI8CyADQdAAaiQAC6EBAgF/AX4gAEEAOgCUAQJAIAAgARCuAUUNACAAQQE6AJQBIAAgARCuAUUNACAAQQE6AJQBIAAgARCuAUUNACAAQQE6AJQBIAAgARCuAUUNACAAQQE6AJQBIAAgARCuAUUNACAAQQE6AJQBCyAAIAAoAggiASICQTRqKQIANwJcIAAgASkCPDcCZCACKQI0IQMgACABKQI8NwJ4IAAgAzcCcAuJAQEBfyMAQSBrIgJBADYCDCACIAEpAgg3AhggAiABKQIANwIQIAAoAggiAEGAgID8AzYCBCAAQoCAgPwDNwIsIABCADcCJCAAQgA3AhwgAEGAgID8AzYCGCAAQgA3AhAgAEIANwIIIAAgACgChAJBAWo2AoQCIAAgAikCEDcCNCAAIAIpAhg3AjwLlwEAIABBADYCrAEgAEEAOwGoASAAQgA3AhAgAEIANwI8IABCADcCRCAAKAIIKAKcAiIAIAAoAgAoAhwRAQAoAgRBAU4EQANAIAAgACAAKAIAKAIcEQEAKAIMKAIAIAAgACgCACgCHBEBACgCDCgCBCABKAIYIAAoAgAoAgwRCgAaIAAgACgCACgCHBEBACgCBEEASg0ACwsLxQECAX8EfSAAQQA6AKsBIAAgASkCADcCPCAAIAEpAgg3AkQCQCAAKgJEIgRDAACAPyAAKgI8IgUgBZQgAEFAayoCACIGIAaUkiAEIASUkpGVIgeUIgQgBJQgBSAHlCIFIAWUIAYgB5QiBiAGlJKSkUMAAAA0XUEBcwRAIAAoAkghAwwBC0MAAAAAIQVDAAAAACEGQwAAAAAhBAsgACAFOAJMIAAgAzYCWCAAIAQ4AlQgACAGOAJQIAAgACoCrAEgApI4AqwBC7QBAQR9IABBAToAqwEgACABKQIANwI8IAAgASkCCDcCRAJ/IAAoAkggACoCRCICQwAAgD8gACoCPCIDIAOUIABBQGsqAgAiBCAElJIgAiAClJKRlSIFlCICIAKUIAMgBZQiAyADlCAEIAWUIgQgBJSSkpFDAAAANF1BAXMNABpDAAAAACEDQwAAAAAhBEMAAAAAIQJBAAshASAAIAM4AkwgACABNgJYIAAgAjgCVCAAIAQ4AlALshECB38IfSMAQaADayIDJAAgAyAAKQJ4NwPYASADIAApAnA3A9ABAkAgACoCECIKjEMAAAAAIApDAAAAAF0bIAKUIgpDAAAAAF5BAXMNACAKIAAqAhgiC15BAXMNACAALQCoAUVBACAALQCpARsNACALIQoLAkBBsOUBLQAAQQFxDQBBsOUBEBBFDQBBhOUBQgA3AgBBgOUBQYCAgPwDNgIAQYzlAUIANwIAQZjlAUIANwMAQZTlAUGAgID8AzYCAEGg5QFCADcDAEGo5QFCgICA/AM3AwBBsOUBEA8LIAAoArABQQR0IgRBiOUBaioCACELIARBhOUBaioCACEMIAAgACoCcCAEQYDlAWoqAgAgCiAAKgJskiIKlCINkzgCcCAAIAAqAnQgCiAMlCIMkzgCdCAAIAAqAnggCiALlCIOkzgCeCAAKAIIIQQCQEGw5QEtAABBAXENAEGw5QEQEEUNAEGE5QFCADcCAEGA5QFBgICA/AM2AgBBjOUBQgA3AgBBmOUBQgA3AwBBlOUBQYCAgPwDNgIAQaDlAUIANwMAQajlAUKAgID8AzcDAEGw5QEQDwsgACgCKCEGIAAoArABIQUgA0IANwJ8IANCADcChAEgA0IANwKMASADIAVBBHQiBUGI5QFqKQIANwLEASADQYCAgPwDNgJsIANCADcCdCADIAQ2ArgBIANBjMkANgJoIAMgBjYCzAEgAyAFQYDlAWopAgA3ArwBIANBADYCtAEgAyAAKAIIIgQoArwBIgYvAQQ7AXAgAyAGLwEGOwFyAkBBsOUBLQAAQQFxDQBBsOUBEBBFDQBBhOUBQgA3AgBBgOUBQYCAgPwDNgIAQYzlAUIANwIAQZjlAUIANwMAQZTlAUGAgID8AzYCAEGg5QFCADcDAEGo5QFCgICA/AM3AwBBsOUBEA8LIAAoAighBiAAKAKwASEFIANCADcCFCADQgA3AhwgA0IANwIkIAMgBUEEdCIFQYjlAWopAgA3AlwgA0EANgJMIANBgICA/AM2AgQgA0IANwIMIAMgBDYCUCADQYzJADYCACADIAY2AmQgAyAFQYDlAWopAgA3AlQgAyAAKAIIKAK8ASIELwEEOwEIIAMgBC8BBjsBCiADQeABakEEciEFIANBoAJqQQRyIQcgA0HgAmpBBHIhCCAAKgJ4IQogACoCdCELIAAqAnAhD0EAIQQCQANAIANBgICA/AM2AuACIAhCADcCCCAIQgA3AgAgA0GAgID8AzYC9AIgA0IANwKAAyADQgA3AvgCIANCgICA/AM3A4gDIANBgICA/AM2AqACIAdCADcCCCAHQgA3AgAgA0GAgID8AzYCtAIgA0IANwLAAiADQgA3ArgCIANCgICA/AM3A8gCIANBgICA/AM2AuABIAVCADcCCCAFQgA3AgAgA0GAgID8AzYC9AEgA0IANwKAAiADQgA3AvgBIANCgICA/AM3A4gCIAMgACkCZDcCmAMgAyAAKQJcNwKQAyADIAApAng3AtgCIAMgACkCcDcC0AIgAyALIAyTOAKUAiADIAogDpM4ApgCIANBADYCnAIgAyAPIA2TOAKQAgJAIAAtAKoBBEAgACgCCCAAKAIMIANB4AJqIANBoAJqIANB6ABqIAEqAjgQ5AEgAyoCbEMAAIA/XQ0BIAAoAgggACgCDCADQeACaiADQeABaiADIAEqAjgQ5AEMAQsgASAAKAIMIANB4AJqIANBoAJqIANB6ABqIAEqAjgQYiADKgJsQwAAgD9dDQAgASAAKAIMIANB4AJqIANB4AFqIAMgASoCOBBiCyAAKgIQIgqMQwAAAAAgCkMAAAAAXRsgApQhCgJ/IAAtALYBIgkEQEEBIAMqAmxDAACAP10NARogAyoCBEMAAIA/XQwBCyADKgIEQwAAgD9dCyEGAkACQAJAIApDAAAAAF5BAXMNACAEIAogACoCNCILXUF/cyAGQX9zcnJBAXENACAALQCoAQ0BIAAtAKkBRQ0BQQAhBAsgBEVBACADKgJsIgtDAACAP11BAXMbDQEgACoCYCECIAkEQCALIAIgAyoCqAGTQwAAAD+UIAAtALUBGyELCyAAQQA6ALUBIABBADoAqQEgAEIANwIQIABDAACAPyALkyIKIAAqAlyUIAsgACoCcJSSOAJcIAAgAiAKlCALIAAqAnSUkjgCYCAAIAogACoCZJQgCyAAKgJ4lJI4AmQMAwsgACADKQPQATcCcCAAIAMpA9gBNwJ4AkBBsOUBLQAAQQFxDQBBsOUBEBBFDQBBhOUBQgA3AgBBgOUBQYCAgPwDNgIAQYzlAUIANwIAQZjlAUIANwMAQZTlAUGAgID8AzYCAEGg5QFCADcDAEGo5QFCgICA/AM3AwBBsOUBEA8LIAAoArABQQR0IgRBiOUBaioCACEQIARBhOUBaioCACERIAAgACoCcCAEQYDlAWoqAgAgCyAAKgJskiIKlJMiDzgCcCAAIAAqAnQgCiARlJMiCzgCdCAAIAAqAnggCiAQlJMiCjgCeEEBIQQMAQsLIABBAToAtQECQCAJRQ0AIAogACoCGCICXkEBcw0AIAAtAKgBRUEAIAAtAKkBGw0AIAAgDSAAKgJwkjgCcCAAIAwgACoCdJI4AnQgACAOIAAqAniSOAJ4AkBBsOUBLQAAQQFxDQBBsOUBEBBFDQBBhOUBQgA3AgBBgOUBQYCAgPwDNgIAQYzlAUIANwIAQZjlAUIANwMAQZTlAUGAgID8AzYCAEGg5QFCADcDAEGo5QFCgICA/AM3AwBBsOUBEA8LIAAoArABQQR0IgFBiOUBaioCACEKIAFBhOUBaioCACELIAAgACoCcCABQYDlAWoqAgAgAiAAKgJskiIClJM4AnAgACAAKgJ0IAIgC5STOAJ0IAAgACoCeCACIAqUkzgCeAsgACAAKQJwNwJcIAAgACkCeDcCZAsgA0GgA2okAAtXAQF/IwBBEGsiAiAANgIMIAIgATYCCCACKAIMIgAgACoCACACKAIIKgIAkzgCACAAIAAqAgQgAigCCCoCBJM4AgQgACAAKgIIIAIoAggqAgiTOAIIIAALrgIBCH0gACoCcCAAKgJckyICIAKUIAAqAnQgACoCYJMiBCAElJIgACoCeCAAKgJkkyIDIAOUkpEiB0MAAAA0XkEBc0UEQCABKgIIIQggASoCACEFIAEqAgQhCSAAIAApAlw3AnAgACAAKQJkNwJ4IAAgByACQwAAgD8gB5UiApQiBiAFIAYgBZQgBCAClCIGIAmUkiADIAKUIgMgCJSSIgIgApIiApSTIgRDAACAPyADIAggApSTIgMgA5QgBCAElCAGIAkgApSTIgIgApSSkpGVIgSUIgYgBSAIIAMgBJQiA5QgBSAGlCAJIAIgBJQiApSSkiIFlJOUIAAqAnCSOAJwIAAgByACIAkgBZSTlCAAKgJ0kjgCdCAAIAcgAyAIIAWUk5QgACoCeJI4AngLC48LAgN/BX0jAEHwAWsiAiQAAkBBsOUBLQAAQQFxDQBBsOUBEBBFDQBBhOUBQgA3AgBBgOUBQYCAgPwDNgIAQYzlAUIANwIAQZjlAUIANwMAQZTlAUGAgID8AzYCAEGg5QFCADcDAEGo5QFCgICA/AM3AwBBsOUBEA8LIAAoArABQQR0IgNBgOUBaioCACEGIANBhOUBaioCACEHIANBiOUBaioCACEFIABBADYCfCAAIAUgACoCNCAAKgIUIgVDAAAAACAFQwAAAABeG5IiBZQgACoCZJI4AnggACAHIAWUIAAqAmCSOAJ0IAAgACoCXCAGIAWUkjgCcCACQYCAgPwDNgKEASACQgA3A4gBIAJCADcCfCACQYCAgPwDNgKYASACQQA2AuwBIAJCADcC5AEgAkGAgID8AzYC2AEgAkIANwLcASACQQA2AqwBIAJCADcCpAEgAkIANwKcASACQYCAgPwDNgLEASACQgA3A8gBIAJCADcCvAEgAkIANwOQASACQYCAgPwDNgJwIAJCADcCdCACQgA3A9ABIAJCADcCtAEgAkGAgID8AzYCsAECQEGw5QEtAABBAXENAEGw5QEQEEUNAEGE5QFCADcCAEGA5QFBgICA/AM2AgBBjOUBQgA3AgBBmOUBQgA3AwBBlOUBQYCAgPwDNgIAQaDlAUIANwMAQajlAUKAgID8AzcDAEGw5QEQDwsgACgCsAEhAyAAKAIMIgQgBCgCACgCMBEGACEFIAAqAlwhBiAAKgJgIQcgACoCZCEIIAAqAjghCSACQQA2AuwBIAIgCCAFIAmSIgUgA0EEdCIDQYjlAWoqAgCUkjgC6AEgAiAHIAUgA0GE5QFqKgIAlJI4AuQBIAIgBiADQYDlAWoqAgAgBZSSOALgASACIAApAng3A6gBIAIgACkCcDcDoAEgACgCCCEEAkBBsOUBLQAAQQFxDQBBsOUBEBBFDQBBhOUBQgA3AgBBgOUBQYCAgPwDNgIAQYzlAUIANwIAQZjlAUIANwMAQZTlAUGAgID8AzYCAEGg5QFCADcDAEGo5QFCgICA/AM3AwBBsOUBEA8LIAAoArABIQMgAkIANwIcIAJCADcCJCACQgA3AiwgAkKAgICAkJDBmj83A2ggAiADQQR0IgNBiOUBaioCAIw4AmQgAiADQYTlAWoqAgCMOAJgIAJBADYCVCACQYCAgPwDNgIMIAJCADcCFCACIAQ2AlggAkGMyQA2AgggAiADQYDlAWoqAgCMOAJcIAIgACgCCCIDKAK8ASIELwEEOwEQIAIgBC8BBjsBEgJAIAAtAKoBBEAgAyAAKAIMIAJBsAFqIAJB8ABqIAJBCGogASoCOBDkAQwBCyABIAAoAgwgAkGwAWogAkHwAGogAkEIakMAAAAAEGILAkAgAioCDEMAAIA/XUEBc0UEQAJAQbDlAS0AAEEBcQ0AQbDlARAQRQ0AQYTlAUIANwIAQYDlAUGAgID8AzYCAEGM5QFCADcCAEGY5QFCADcDAEGU5QFBgICA/AM2AgBBoOUBQgA3AwBBqOUBQoCAgPwDNwMAQbDlARAPCwJAIAIqAjQgACgCsAFBBHQiAUGA5QFqKgIAlCACKgI4IAFBhOUBaioCAJSSIAIqAjwgAUGI5QFqKgIAlJJDAAAAAF5BAXMNACAAIAAqAjQgAioCDCIFlDgCbCAALQC0AQRAIABDAACAPyAFkyIGIAAqAlyUIAUgACoCcJSSOAJcIAAgBiAAKgJglCAFIAAqAnSUkjgCYCAAIAYgACoCZJQgBSAAKgJ4lJI4AmQMAQsgACAAKQJwNwJcIAAgACkCeDcCZAsgAEIANwIQDAELIAAgACgCNDYCbCAAIAApAng3AmQgACAAKQJwNwJcCyACQfABaiQAC4UBAQF/IABB8McANgIAIAAoAowBIgEEQCAALQCQAQRAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgKMAQsgAEEANgKMASAAQgA3AoQBIABBAToAkAEgAARAQez3AUHs9wEoAgBBAWo2AgAgAEGQ0gEoAgARAAALC2UBAX8gAEHwxwA2AgAgACgCjAEiAQRAIAAtAJABBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AowBCyAAQQA2AowBIABCADcChAEgAEEBOgCQASAACxgAIAAgAzYCgAEgACACNgJ8IAAgATYCeAsRACAAIAIgACgCACgCEBEIAAueAgIBfwN9IwBB4ABrIgQkACAEQoGA/P8PNwIUIARCgICA/AM3AgwgBEHsDDYCCCAEIAEpAgg3AiQgBCABKQIANwIcIAQgAikCCDcCNCAEIAIpAgA3AiwgACgCBCIAIAEgAiAEQQhqIAAoAgAoAiARBABBACECAkAgBCgCECIARQ0AIAAtAOwBQQJxRQ0AIAAtAMwBQQRxDQAgAyAEKQJMNwIAIAMgBCkCVDcCCCADIAQpAjw3AhAgAyAEKQJENwIYIAMgAyoCECIFQwAAgD8gBSAFlCADKgIUIgUgBZSSIAMqAhgiBiAGlJKRlSIHlDgCECADIAYgB5Q4AhggAyAFIAeUOAIUIAMgBCgCDDYCICAAIQILIARB4ABqJAAgAguRAgIFfwN9IwBBMGsiAiQAIAAoAogBQQFOBEADQCAEQZwCbCIFIAAoApABaiIDLQBUIQYgAkEANgIsIAJCgICAgICAgMA/NwIkIAJBAEGAgID8AyAGGzYCICACIAMpApQBNwMYIAIgAykCjAE3AxAgAyAAKAJ4QQJ0aiIDKgJcIQcgAyoCbCEIIAMqAnwhCSACQQA2AgwgAiAJIAIqAhiSOAIIIAIgCCACKgIUkjgCBCACIAcgAioCEJI4AgAgASACQRBqIAIgAkEgaiABKAIAKAIIEQQAIAEgAkEQaiAAKAKQASAFakEQaiACQSBqIAEoAgAoAggRBAAgBEEBaiIEIAAoAogBSA0ACwsgAkEwaiQAC/EDAQ19IAAgAjYCBCAAIAE2AgAgACADKQIANwIIIAAgAykCCDcCECAAIAQpAgA3AhggACAEKQIINwIgIAAgBTgCLCAAQwAAgD8gASoC2AIgBCoCCCIFIAMqAgQiDiABKgI4kyIGIAEqAogCIAYgBZQgAyoCCCIPIAEqAjyTIgcgBCoCBCIJlJMiCpQgASoCmAIgByAEKgIAIguUIAUgAyoCACIQIAEqAjSTIgiUkyIMlJIgCCAJlCAGIAuUkyINIAEqAqgClJIiEZQgCCAKIAEqAowClCAMIAEqApwClJIgDSABKgKsApSSIhKUk5QgCyAHIBKUIAYgCiABKgKQApQgDCABKgKgApSSIA0gASoCsAKUkiIGlJOUIAkgCCAGlCAHIBGUk5SSkpIgAioC2AIgBSAOIAIqAjiTIgYgCSAQIAIqAjSTIgeUIAsgBpSTIgogAioCqAKUIAIqAogCIAUgBpQgCSAPIAIqAjyTIgiUkyIMlCACKgKYAiALIAiUIAUgB5STIgWUkpIiDZQgByAMIAIqAowClCAFIAIqApwClJIgCiACKgKsApSSIg6Uk5QgCyAIIA6UIAYgDCACKgKQApQgBSACKgKgApSSIAogAioCsAKUkiIFlJOUIAkgByAFlCAIIA2Uk5SSkpKSlTgCKAv5FwIKfwx9IwBB4ABrIgQkAAJAIAAoAogBIgVFDQAgACgCCCIGIAVIBEAgACgCDCAFSARAQej3AUHo9wEoAgBBAWo2AgAgBUEEdEEQQYzSASgCABEDACEHIAAoAggiAkEBTgRAA0AgByADQQR0IghqIgkgACgCECAIaiIIKQIANwIAIAkgCCkCCDcCCCADQQFqIgMgAkcNAAsLIAAoAhAiAgRAIAAtABQEQCACBEBB7PcBQez3ASgCAEEBajYCACACQZDSASgCABEAAAsLIABBADYCEAsgACAHNgIQIAAgBTYCDCAAQQE6ABQLA0AgACgCECAGQQR0aiICIAQpAjA3AgAgAiAEKQI4NwIIIAZBAWoiBiAFRw0ACwsgACAFNgIIIAAoAhwiBiAFSARAIAAoAiAgBUgEQEHo9wFB6PcBKAIAQQFqNgIAIAVBBHRBEEGM0gEoAgARAwAhByAAKAIcIgJBAU4EQEEAIQMDQCAHIANBBHQiCGoiCSAAKAIkIAhqIggpAgA3AgAgCSAIKQIINwIIIANBAWoiAyACRw0ACwsgACgCJCICBEAgAC0AKARAIAIEQEHs9wFB7PcBKAIAQQFqNgIAIAJBkNIBKAIAEQAACwsgAEEANgIkCyAAIAc2AiQgACAFNgIgIABBAToAKAsDQCAAKAIkIAZBBHRqIgIgBCkCMDcCACACIAQpAjg3AgggBkEBaiIGIAVHDQALCyAAIAU2AhwgACgCMCIIIAVIBEACQCAAKAI0IAVOBEAgBUECdCEHIAAoAjghAwwBC0Ho9wFB6PcBKAIAQQFqNgIAIAVBAnQiB0EQQYzSASgCABEDACEDIAAoAjghAgJAIAAoAjAiCUEBTgRAQQAhBgNAIAMgBkECdCIKaiACIApqKAIANgIAIAZBAWoiBiAJRw0ACwwBCyACDQAgACADNgI4IAAgBTYCNCAAQQE6ADwMAQsgAC0APARAIAIEQEHs9wFB7PcBKAIAQQFqNgIAIAJBkNIBKAIAEQAACwsgACADNgI4IABBAToAPCAAIAU2AjQLIAMgCEECdCICakEAIAcgAmsQCxoLIAAgBTYCMCAAKAJEIgggBUgEQAJAIAAoAkggBU4EQCAFQQJ0IQcgACgCTCEDDAELQej3AUHo9wEoAgBBAWo2AgAgBUECdCIHQRBBjNIBKAIAEQMAIQMgACgCTCECAkAgACgCRCIJQQFOBEBBACEGA0AgAyAGQQJ0IgpqIAIgCmooAgA2AgAgBkEBaiIGIAlHDQALDAELIAINACAAIAM2AkwgACAFNgJIIABBAToAUAwBCyAALQBQBEAgAgRAQez3AUHs9wEoAgBBAWo2AgAgAkGQ0gEoAgARAAALCyAAIAM2AkwgAEEBOgBQIAAgBTYCSAsgAyAIQQJ0IgJqQQAgByACaxALGgsgACAFNgJEIAAoAogBIgNBAUgNACAAKAI4IQIgACgCTCEFQQAhBgNAIAUgBkECdCIHakEANgIAIAIgB2pBADYCACAGQQFqIgYgA0cNAAsgBEFAayEHQQAhBgNAIAAoApABIAZBnAJsaiICKAJYIggEQCAEIAIpAmQ3AzggBCACKQJcNwMwIAcgAikCdDcCCCAHIAIpAmw3AgAgBCACKQKEATcCWCAEIAIpAnw3AlAgBEEwaiAAKAJ4QQJ0aiIDKAIAIQkgAygCECEKIAMoAiAhCyAGQQR0IgUgACgCJGoiA0EANgIMIAMgCzYCCCADIAo2AgQgAyAJNgIAIAAoAiQgBWoiAyADKgIIIgwgAioCCCIOIAMqAgAiDSACKgIAIg+UIAMqAgQiECACKgIEIhGUkiAMIA6UkiIMlJMiDkMAAIA/IA4gDpQgDSAPIAyUkyIOIA6UIBAgESAMlJMiDCAMlJKSkZUiDZQiDzgCCCADIAwgDZQiDDgCBCADIA4gDZQiDjgCACACKgIIIQ0gAioCACEQIAIqAgQhESAAKAIQIAVqIgNBADYCDCADIAwgEJQgESAOlJM4AgggAyANIA6UIA8gEJSTOAIEIAMgESAPlCANIAyUkzgCACAAKAIQIAVqIgMgAyoCCCIMQwAAgD8gAyoCACIOIA6UIAMqAgQiDSANlJIgDCAMlJKRlSIMlDgCCCADIA0gDJQ4AgQgAyAOIAyUOAIAIAAoAnQgAkEQaiICIAggAiAAKAIkIAVqIAZBAnQiAiAAKAJMahCEDiAAKAJMIAJqIgJB/NEBKgIAIAIqAgCUOAIAIAAoAogBIQMLIAZBAWoiBiADSA0ACyADQQFIDQAgACgCkAEhA0EAIQdBACEGA0ACQAJAAkAgAyAGQZwCbCIIaiIFKAJYIgIEQCAFKgL8ASIMQwAAAABbDQEgDCABlCEMDAILIAAoAjggBkECdGpBADYCACAFQYCAgPwDNgKYAgwCCyAEQTBqIAAoAnQgAiAFQRBqIAAoAhAgBkEEdGpDAAAAACAFKgKAAiIMIAxDAAAAAFsbEPoNIAQqAlwiDIwiDiAMIAQqAlggBCoCQCINIAQoAjAiAioCPJMiDyACKgLMAiIQlCAEKgI8IhEgAioCOJMiEyACKgLQAiISlJMgAioCuAKSIA0gBCgCNCIDKgI8kyINIAMqAswCIhSUIBEgAyoCOJMiESADKgLQAiIVlJMgAyoCuAKSkyAEKgJIlCACKgK8AiAEKgI4IhYgAioCNJMiFyASlCAPIAIqAsgCIg+Uk5IgAyoCvAIgFiADKgI0kyISIBWUIA0gAyoCyAIiDZSTkpMgBCoCTJSSIBMgD5QgFyAQlJMgAioCwAKSIBEgDZQgEiAUlJMgAyoCwAKSkyAEKgJQlJKMlCINIAwgDV0bIgwgDCAOXRshDCAAKAKQASEDCyAGQQJ0IgkgACgCOGoiCkEANgIAIAMgCGoiAkGAgID8AzYCmAIgBSoC5AEhDiAFKgKUAiENIAogDDgCACAMQwAAAD+UIgwgDJQgACgCTCAJaioCACIMIAyUkiIPIA4gDSABlJQiDCAMlF5BAXMNACACIAwgD5GVIAIqApgClDgCmAJBASEHCyAGQQFqIgYgACgCiAEiAkgNAAsgAkEBSCIFIAdBf3NyQQFxRQRAIAAoAkwhB0EAIQYDQAJAIAcgBkECdCIIaiIDKgIAQwAAAABbDQAgACgCkAEgBkGcAmxqIgkqApgCIgFDAACAP11BAXMNACAAKAI4IAhqIgggASAIKgIAlDgCACADIAkqApgCIAMqAgCUOAIACyAGQQFqIgYgAkcNAAsLIAUNAEEAIQYDQCAGQZwCbCIHIAAoApABaiICKgIQIQEgACgCdCIDKgI0IQwgAioCFCEOIAMqAjghDSACKgIYIQ8gAyoCPCEQIARBADYCPCAEIA8gEJM4AjggBCAOIA2TOAI0IAQgASAMkzgCMCAGQQJ0IgggACgCOGoqAgAiAUMAAAAAXARAIAAoAhAgBkEEdGoiBSoCACEMIAUqAgQhDiAFKgIIIQ0gBEEANgIsIAQgASANlDgCKCAEIAEgDpQ4AiQgBCAMIAGUOAIgIAMgBEEgaiAEQTBqECsLIAAoAkwgCGoiCCoCAEMAAAAAXARAIAAoApABIAdqKAJYIgMqAjQhASADKgI4IQwgAyoCPCEOIAIqAhAhDSACKgIUIQ8gAioCGCEQIARBADYCLCAEIBAgDpM4AiggBCAPIAyTOAIkIAQgDSABkzgCICAAKAIkIAZBBHRqIgUqAgAhDCAFKgIEIQ4gBSoCCCENIAgqAgAhASAEQQA2AhwgBCABIA2UOAIYIAQgASAOlDgCFCAEIAwgAZQ4AhAgBCAEKgI4IgEgACgCdCIHIAAoAnxBAnRqIgUqAiQiDCAFKgIEIg4gBCoCMCINlCAFKgIUIg8gBCoCNCIQlJIgDCABlJJDAACAPyACKgL0AZOUIgGUkzgCOCAEIBAgDyABlJM4AjQgBCANIA4gAZSTOAIwIAcgBEEQaiAEQTBqECsgBEEANgIMIAQgBCoCGIw4AgggBCAEKgIUjDgCBCAEIAQqAhCMOAIAIAMgBCAEQSBqECsLIAZBAWoiBiAAKAKIAUgNAAsLIARB4ABqJAALoQECAn8CfSAAKAKIAUEBTgRAQwAAgD8gACgCdCoC2AKVIQQDQEMAAAAAIQMgACgCkAEgAkGcAmxqIgEtAFQEQCAEIAEqAtgBIAEqAswBIAEqAiCTlCABKgKMApQgASoCkAIiAyABQdwBaiABQeABaiADQwAAAABdGyoCAJSTlEMAAAAAlyEDCyABIAM4ApQCIAJBAWoiAiAAKAKIAUgNAAsLC+AHAgd/Cn0jAEEgayIEJAAgACgCiAEiA0EASgRAA0AgACACQQAQ0AIgAkEBaiICIAAoAogBIgNIDQALCyAAIAAoAnQiAioCuAIiCSAJlCACKgK8AiIJIAmUkiACKgLAAiIJIAmUkpFDZmZmQJQiCTgCcCACIAAoAoABQQJ0aiIFKgIEIAIqArgClCAFKgIUIAIqArwClJIgBSoCJCACKgLAApSSQwAAAABdBEAgACAJjDgCcAsCQCADQQFIDQBBACECA0AgACAAKAKQASACQZwCbGoQ0gQaIAJBAWoiAiAAKAKIASIDSA0ACyADQQFIDQBDAACAPyAAKAJ0KgLYApUhCkEAIQMDQEMAAAAAIQkgACgCkAEgA0GcAmxqIgItAFQEQCAKIAIqAtgBIAIqAswBIAIqAiCTlCACKgKMApQgAioCkAIiCSACQdwBaiACQeABaiAJQwAAAABdGyoCAJSTlEMAAAAAlyEJCyACIAk4ApQCIANBAWoiAyAAKAKIASICSA0ACyACQQFIDQBBACEFA0AgACgCkAEgBUGcAmxqIgIqAvgBIQkgAioClAIhCiACKgIAIQsgAioCBCENIAIqAgghDCAEQQA2AhwgBCAMIAkgCiAKIAleGyIJlCABlDgCGCAEIAkgDZQgAZQ4AhQgBCALIAmUIAGUOAIQIAIqAhAhCSAAKAJ0IgMqAjQhCiACKgIUIQsgAyoCOCENIAIqAhghDCADKgI8IQ4gBEEANgIMIAQgDCAOkzgCCCAEIAsgDZM4AgQgBCAJIAqTOAIAIAMgBEEQaiAEECsgBUEBaiIFIAAoAogBSA0ACwsgACABIAAoAgAoAhQRCAAgACgCiAEiB0EBTgRAIAAoApABIQggACgCdCEDQQAhBQNAAn0gCCAFQZwCbGoiAi0AVARAIAIgAioCKCADKgI4kyIKIAMqAsgCIguUIAIqAiQgAyoCNJMiDSADKgLMAiIMlJMgAyoCwAKSIAMgACgCgAFBAnRqIgYqAiQiCSACKgIIIg4gBioCBCIPIAIqAgAiEJQgBioCFCIRIAIqAgQiEpSSIAkgDpSSIgmUk5QgDCACKgIsIAMqAjyTIgyUIAogAyoC0AIiCpSTIAMqArgCkiAPIBAgCZSTlCANIAqUIAwgC5STIAMqArwCkiARIBIgCZSTlJKSIAGUIAIqAtQBlSIJOALwASACQewBaiEGIAIqAuwBIQogCQwBCyACQewBaiEGIAIqAuwBIQkgAioC8AEiCgshCyAGIAogCZI4AgAgAiALQ6RwfT+UOALwASAFQQFqIgUgB0cNAAsLIARBIGokAAt1AgJ/AX0gACgCiAFBAU4EQANAIAAoApABIAJBnAJsaiIBKgLMASEDIAFBADYCDCABQoCAgPwDNwKMAiABIAM4AiAgASABKgI8jDgCCCABIAEqAjiMOAIEIAEgASoCNIw4AgAgAkEBaiICIAAoAogBSA0ACwsLtQcCCX8GfiMAQaACayIIJAAgCCABKQIINwP4ASAIIAEpAgA3A/ABIAggAikCCDcDiAIgCCACKQIANwOAAiAIIAMpAgg3A5gCIAggAykCADcDkAIgBigCACELIAYoAgQhDCAGKAIIIQ0gBigCECEOIAYoAgwhDyAGKAIUIRAgCCAIKQP4ATcCxAEgCCAIKQPwATcCvAEgCCAIKQOIAjcC1AEgCCAIKQOAAjcCzAEgCCAIKQOYAjcC5AEgCCAIKQOQAjcC3AECQCAAKAKIASIBIAAoAowBRw0AIAEgAUEBdEEBIAEbIglODQACfyAJBEBB6PcBQej3ASgCAEEBajYCACAJQZwCbEEQQYzSASgCABEDACEKIAAoAogBIQELIAFBAU4LBEBBACECA0AgCiACQZwCbCIDaiAAKAKQASADaiIDQdwAEBUiBiADKQJkNwJkIAYgAykCXDcCXCAGIAMpAnQ3AnQgBiADKQJsNwJsIAYgAykChAE3AoQBIAYgAykCfDcCfCAGIAMpAowBNwKMASAGIAMpApQBNwKUASAGQZwBaiADQZwBakGAARAVGiACQQFqIgIgAUcNAAsLIAAoApABIgEEQCAALQCUAQRAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgKQAQsgACAKNgKQASAAIAk2AowBIABBAToAlAEgACgCiAEhAQsgACgCkAEgAUGcAmxqIAhBIGpB3AAQFSIBIAgpAoQBNwJkIAEgCCkCfDcCXCABIAgpApQBNwJ0IAEgCCkCjAE3AmwgASAIKQKkATcChAEgASAIKQKcATcCfCABIAgpArQBNwKUASABIAgpAqwBNwKMASAIKQLkASERIAgpAtwBIRIgCCkC1AEhEyAIKQLMASEUIAgpAsQBIRUgCCkCvAEhFiABIA82AtABIAEgBTgC1AEgASALNgLYASABIAw2AtwBIAEgDTYC4AEgASAONgLkASABIBA2AvgBIAEgBzoAhAIgAUIANwLoASABQoCAgIDQmbPmPTcC8AEgAUIANwL8ASABIBY3ApwBIAEgFTcCpAEgASAUNwKsASABIBM3ArQBIAEgEjcCvAEgASARNwLEASABIAQ4AswBIAEgCCkAGDcAlAIgASAIKQARNwCNAiABIAgpAAk3AIUCIAAgACgCiAEiAUEBajYCiAEgACAAKAKQASABQZwCbGoiAUEAEK8BIAAgACgCiAFBf2pBABDQAiAIQaACaiQAIAELCQAgABDTBBAOC6YBACAAQdTGADYCACAAQQA2AmggACACNgJkIABBAToAFCAAQQA2AhAgAEEBOgAoIABCADcCCCAAQQA2AiQgAEEBOgA8IABCADcCHCAAQQA2AjggAEEBOgBQIABCADcCMCAAQQA2AkwgAEEBOgCUASAAQgA3AkQgAEEANgKQASAAQgA3AogBIABBATYCgAEgAEKAgICAIDcCeCAAIAE2AnQgAEIANwJsC3MAQZDgAUGgNjYCAEGA5AEoAgAiAARAQYTkAS0AAARAIAAEQEHs9wFB7PcBKAIAQQFqNgIAIABBkNIBKAIAEQAACwtBgOQBQQA2AgALQYTkAUEBOgAAQfjjAUIANwIAQYDkAUEANgIAQZDgAUHkygA2AgALZQEBfyMAQRBrIgAkAAJAQfjkAS0AAEEBcQ0AQfjkARAQRQ0AIABCADcDCCAAQgA3AwBBkOABIAAQ+QRB+OQBEA8LIABCADcDCCAAQgA3AwBBkOABQwAAAAAgABDdAiAAQRBqJAAL3gQBDX0gBSAEKgIAIgYgBpQgBCoCBCIIIAiUkiAEKgIIIgkgCZSSQ83MjD9eBH1DAAAAAAUgBiABKgIIIAAqAjyTIgcgACoCzAIiDZQgASoCBCAAKgI4kyILIAAqAtACIgyUkyAAKgK4ApIgAyoCCCACKgI8kyIOIAIqAswCIhGUIAMqAgQgAioCOJMiDyACKgLQAiIQlJMgAioCuAKSk5QgCCAAKgK8AiABKgIAIAAqAjSTIgogDJQgByAAKgLIAiISlJOSIAIqArwCIAMqAgAgAioCNJMiDCAQlCAOIAIqAsgCIhCUk5KTlJIgCSALIBKUIAogDZSTIAAqAsACkiAPIBCUIAwgEZSTIAIqAsACkpOUkkPNzEy+lEMAAIA/IAIqAtgCIAAqAtgCIAkgC5QgCCAHlJMiDSAAKgIElCAGIAeUIAkgCpSTIgcgACoCFJSSIAggCpQgBiALlJMiCyAAKgIklJIiCiAKIAAqAowDlJQgDSAAKgIIlCAHIAAqAhiUkiALIAAqAiiUkiIKIAogACoCkAOUlJIgDSAAKgIMlCAHIAAqAhyUkiALIAAqAiyUkiIHIAcgACoClAOUlJKSkiAIIA6UIAkgD5STIgcgAioCBJQgCSAMlCAGIA6UkyIJIAIqAhSUkiAGIA+UIAggDJSTIgYgAioCJJSSIgggCCACKgKMA5SUIAcgAioCCJQgCSACKgIYlJIgBiACKgIolJIiCCAIIAIqApADlJSSIAcgAioCDJQgCSACKgIclJIgBiACKgIslJIiBiAGIAIqApQDlJSSkpWUCzgCAAusAgEHfSAALQBUBEAgACoCACICIAAqAjSUIAAqAgQiAyAAKgI4lJIgACoCCCIGIAAqAjyUkiIEQ83MzL1gQQFzRQRAIABBADYCkAIgAEMAACBBOAKMAg8LIABDAACAvyAElSIEIAIgASoCzAIiAiAAKgIYIAEqAjyTIgWUIAAqAhQgASoCOJMiByABKgLQAiIIlJMgASoCuAKSlCADIAAqAhAgASoCNJMiAyAIlCAFIAEqAsgCIgWUkyABKgK8ApKUkiAGIAcgBZQgAyAClJMgASoCwAKSlJKUOAKQAiAAIAQ4AowCDwsgAEEANgKQAiAAQQA2AgwgACAAKALMATYCICAAIAAqAjSMOAIAIAAgACoCPIw4AgggACAAKgI4jDgCBCAAQwAAgD84AowCCwoAIABBADYCwAELXwBB78UAEBYgACABIAIgAyAEIAUgBiAHIAggACgCACgCLBErABogACABIAIgAyAEIAUgBiAHIAggACgCACgCMBErABogACABIAIgByAAKAIAKAIkETAAGhATQwAAAAALhwMCAX8DfSMAQdAAayIDJAACQCAAKALwAUUNACAAIAAqAkAgACoCsAGSOAKwASAAIAAqAlAgACoCwAGSOALAASAAIAAqAkQgACoCtAGSOAK0ASAAIAAqAkggACoCuAGSOAK4ASAAIAAqAlQgACoCxAGSOALEASAAIAAqAlggACoCyAGSOALIAQJAIAAqApABQwAAAABcDQAgACoClAFDAAAAAFwNACAAKgKYAUMAAAAAXA0AIAAqAqABQwAAAABcDQAgACoCpAFDAAAAAFwNACAAKgKoAUMAAAAAWw0BCyAAKgKkASEEIAAqAqgBIQUgACoCoAEhBiADQQA2AgwgAyAGIAKUOAIAIAMgBSAClDgCCCADIAQgApQ4AgQgACAAQZABaiADIAEgA0EQahBVIAAgAykDGDcCCCAAIAMpAxA3AgAgACADKQMoNwIYIAAgAykDIDcCECAAIAMpAzA3AiAgACADKQM4NwIoIAAgAykDQDcCMCAAIAMpA0g3AjgLIANB0ABqJAALrA4CBn8GfQJAIAMoAkAiAUEEcUUNACAAKAIcIgRBAUgNACABQRBxIQUgACgCTCEGIAAoAiQhCEEAIQIDQCAIIAJBmAFsaiIBKAKEASIHIAEoAmQ2AnggByAGIAEoAowBQZgBbGoiASgCZDYCfCAFBEAgByABKAL8ATYCgAELIAJBAWoiAiAERw0ACwsgACgCMCIIQQFOBEAgACgCOCEJQQAhBwNAIAkgB0GYAWxqIgIoAoQBIgQoAiwiAQRAIAQoAhwiBSoC5AIhDCACKgIYIQ0gBSoC4AIhDiACKgIUIQ8gASABKgIAIAIqAhAgAioCZCIKlCAFKgLcApRDAACAPyADKgIMlSILlJI4AgAgASAOIAogD5SUIAuUIAEqAgSSOAIEIAEgDCAKIA2UlCALlCABKgIIkjgCCCAEKAIgIgYqAuQCIQwgAioCOCENIAYqAuACIQ4gAioCNCEPIAEgASoCICACKgIwIAIqAmQiCpQgBioC3AKUQwAAgD8gAyoCDJUiC5SSOAIgIAEgDiAKIA+UlCALlCABKgIkkjgCJCABIAwgCiANlJQgC5QgASoCKJI4AiggBSoCqAQhDCACKgIIIQ0gBSoCpAQhDiACKgIEIQ8gASABKgIQIAIqAgAgBSoCoASUIAIqAmQiCpRDAACAPyADKgIMlSILlJI4AhAgASAKIA8gDpSUIAuUIAEqAhSSOAIUIAEgCiANIAyUlCALlCABKgIYkjgCGCAGKgKoBCEMIAIqAighDSAGKgKkBCEOIAIqAiQhDyABIAEqAjAgAioCICAGKgKgBJQgAioCZCIKlEMAAIA/IAMqAgyVIguUkjgCMCABIAogDyAOlJQgC5QgASoCNJI4AjQgASAKIA0gDJSUIAuUIAEqAjiSOAI4CyAEIAIqAmQiCjgCJCAKiyAEKgIQYEEBc0UEQCAEQQA6ABQLIAdBAWoiByAIRw0ACwsgACgCCCIHQQFOBEAgACgCECEFQQAhBgNAIAUgBkH0AWwiBGoiASgC8AEiAgRAAkAgAygCLARAIAEgAyoCDCADKgI0EIgOIAAoAhAiBSAEaiIBKgKwASEKIAEoAvABIQIgASoCuAEhCyABKgK0ASEMDAELIAEgASoCQCABKgKwAZIiCjgCsAEgASABKgJQIAEqAsABkjgCwAEgASABKgJEIAEqArQBkiIMOAK0ASABIAEqAkggASoCuAGSIgs4ArgBIAEgASoCVCABKgLEAZI4AsQBIAEgASoCWCABKgLIAZI4AsgBCyAEIAVqIgEqAtQBIQ0gASoC2AEhDiABKgLQASEPIAJBADYCxAIgAiAKIA+SOAK4AiACIAIoAoQCQQFqNgKEAiACIAsgDpI4AsACIAIgDCANkjgCvAIgACgCECAEaiIBKgLkASEKIAEqAsQBIQsgASoC6AEhDCABKgLIASENIAEqAuABIQ4gASoCwAEhDyABKALwASIBQQA2AtQCIAEgDyAOkjgCyAIgASANIAySOALQAiABIAsgCpI4AswCIAEgASgChAJBAWo2AoQCIAMoAiwEQCAAKAIQIARqIgIoAvABIgEgASgChAJBAWo2AoQCIAEgAikCCDcCDCABIAIpAgA3AgQgASACKQIYNwIcIAEgAikCEDcCFCABIAIpAiA3AiQgASACKQIoNwIsIAEgAikCODcCPCABIAIpAjA3AjQLIAAoAhAiBSAEaigC8AFBfzYC1AEgACgCCCEHCyAGQQFqIgYgB0gNAAsLAkAgACgCHEF/Sg0AIAAoAiBBf0oNACAAKAIkIgEEQCAALQAoBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AiQLIABCADcCICAAQQE6ACgLIABBADYCHAJAIAAoAjBBf0oNACAAKAI0QX9KDQAgACgCOCIBBEAgAC0APARAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgI4CyAAQgA3AjQgAEEBOgA8CyAAQQA2AjACQCAAKAJEQX9KDQAgACgCSEF/Sg0AIAAoAkwiAQRAIAAtAFAEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYCTAsgAEIANwJIIABBAToAUAsgAEEANgJEAkAgACgCWEF/Sg0AIAAoAlxBf0oNACAAKAJgIgEEQCAALQBkBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AmALIABCADcCXCAAQQE6AGQLIABBADYCWAJAIAAoAghBf0oNACAAKAIMQX9KDQAgACgCECIBBEAgAC0AFARAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgIQCyAAQgA3AgwgAEEBOgAUCyAAQQA2AghDAAAAAAt+AQJ/Qc3FABAWIAAgASACIAMgBCAFIAYgByAIIAAoAgAoAiARLAAgACgCuAEiCSAHKAIUIgogCSAKShsiCkEBTgRAQQAhCQNAIAAgCSABIAIgAyAEIAUgBiAHIAggACgCACgCKBEjABogCUEBaiIJIApHDQALCxATQwAAAAALmwIAAkAgBygCLEUNACAHKAIUIQIgBy0AQUEBcQRAIAJBAUgNAUEAIQMDQEEAIQEgACgCHCIEQQFOBEADQCAAKAIQIgUgACgCJCAAKAJ0IAFBAnRqKAIAQZgBbGoiAigCkAFB9AFsaiAFIAIoApQBQfQBbGogAhDXBCABQQFqIgEgBEcNAAsgBygCFCECCyADQQFqIgMgAkgNAAsMAQsgAkEBSA0AQQAhAwNAQQAhASAAKAIcIgRBAU4EQANAIAAoAhAiBSAAKAIkIAAoAnQgAUECdGooAgBBmAFsaiICKAKQAUH0AWxqIAUgAigClAFB9AFsaiACENcEIAFBAWoiASAERw0ACyAHKAIUIQILIANBAWoiAyACSA0ACwsLpBQCBX8CfQJAIAgtAEBBAXFFDQAgACgCRCEJIAAoAhwhCyAAKAIwIgxBAU4EQCAAKALAAUGNzOUAbEHf5rvjA2ohBQJAIAxBAUYNAEECIQIgACgCiAEiCigCBCEDIAogCiAFQY3M5QBsQd/mu+MDaiIFQRB2IAVzIgRBCHYgBHMiBEEEdiAEcyIEQQJ2IARzIgRBAXYgBHNBAXFBAnRqIgQoAgA2AgQgBCADNgIAIAxBAkYNAANAIAIiA0EBaiECIAogA0ECdGoiDSgCACEOIA0gCgJ/IAVBjczlAGxB3+a74wNqIgUgA0H//wNLDQAaIAVBEHYgBXMiBCADQf8BSw0AGiAEQQh2IARzIgQgA0EPSw0AGiAEQQR2IARzIgQgA0EDSw0AGiAEQQJ2IARzCyACcEECdGoiAygCADYCACADIA42AgAgAiAMRw0ACwsgACAFNgLAAQsgCCgCFCABTA0AIAtBAU4EQCAAKALAAUGNzOUAbEHf5rvjA2ohBQJAIAtBAUYNAEECIQIgACgCdCIKKAIEIQMgCiAKIAVBjczlAGxB3+a74wNqIgVBEHYgBXMiBEEIdiAEcyIEQQR2IARzIgRBAnYgBHMiBEEBdiAEc0EBcUECdGoiBCgCADYCBCAEIAM2AgAgC0ECRg0AA0AgAiIDQQFqIQIgCiADQQJ0aiIMKAIAIQ0gDCAKAn8gBUGNzOUAbEHf5rvjA2oiBSADQf//A0sNABogBUEQdiAFcyIEIANB/wFLDQAaIARBCHYgBHMiBCADQQ9LDQAaIARBBHYgBHMiBCADQQNLDQAaIARBAnYgBHMLIAJwQQJ0aiIDKAIANgIAIAMgDTYCACACIAtHDQALCyAAIAU2AsABCyAJQQFIDQAgACgCwAFBjczlAGxB3+a74wNqIQUCQCAJQQFGDQBBAiECIAAoApwBIgsoAgQhAyALIAsgBUGNzOUAbEHf5rvjA2oiBUEQdiAFcyIEQQh2IARzIgRBBHYgBHMiBEECdiAEcyIEQQF2IARzQQFxQQJ0aiIEKAIANgIEIAQgAzYCACAJQQJGDQADQCACIgNBAWohAiALIANBAnRqIgooAgAhDCAKIAsCfyAFQY3M5QBsQd/mu+MDaiIFIANB//8DSw0AGiAFQRB2IAVzIgQgA0H/AUsNABogBEEIdiAEcyIEIANBD0sNABogBEEEdiAEcyIEIANBA0sNABogBEECdiAEcwsgAnBBAnRqIgMoAgA2AgAgAyAMNgIAIAIgCUcNAAsLIAAgBTYCwAELIAAoAjAhAgJAAkAgCC0AQUEBcQRAIAJBAU4EQEEAIQMDQCAAKAI4IAAoAogBIANBAnRqKAIAQZgBbGoiBCgCiAEgAUoEQCAAKAIQIgIgBCgCkAFB9AFsaiACIAQoApQBQfQBbGogBBBUIAAoAjAhAgsgA0EBaiIDIAJIDQALCyAIKAIUIAFMDQIgB0EBTgRAQQAhAgNAIAYgAkECdGoiASgCACIDLQAUBEAgACADKAIcIAgqAgwQRiEDIAAgASgCACgCICAIKgIMEEYhBCABKAIAIgEgACgCECIFIANB9AFsaiAFIARB9AFsaiAIKgIMIAEoAgAoAhgRDwALIAJBAWoiAiAHRw0ACwsgACgCHCEDIAgoAkAiAUGABHENASADQQFOBEBBACECA0AgACgCECIEIAAoAiQgACgCdCACQQJ0aigCAEGYAWxqIgEoApABQfQBbGogBCABKAKUAUH0AWxqIAEQ0QIgAkEBaiICIANHDQALCyAAKAJEIgJBAU4EQEEAIQMDQCAAKAIkIAAoAkwgACgCnAEgA0ECdGooAgBBmAFsaiIBKAKMAUGYAWxqKgJkIg9DAAAAAF5BAXNFBEAgASAPIAEqAmgiEJQ4AnwgASAPIBCMlDgCeCAAKAIQIgQgASgCkAFB9AFsaiAEIAEoApQBQfQBbGogARBUCyADQQFqIgMgAkcNAAsLIAAoAlgiAkEBSA0CQQAhAwNAIAAoAiQgACgCYCADQZgBbGoiASgCjAFBmAFsaioCZCIQQwAAAABeQQFzRQRAIAEgASoCaCIPIBAgD5QiECAQIA9eGyIPOAJ8IAEgD4w4AnggACgCECIEIAEoApABQfQBbGogBCABKAKUAUH0AWxqIAEQVAsgA0EBaiIDIAJHDQALDAILIAJBAU4EQEEAIQMDQCAAKAI4IAAoAogBIANBAnRqKAIAQZgBbGoiBCgCiAEgAUoEQCAAKAIQIgIgBCgCkAFB9AFsaiACIAQoApQBQfQBbGogBBBUIAAoAjAhAgsgA0EBaiIDIAJIDQALCyAIKAIUIAFMDQEgB0EBTgRAQQAhAgNAIAYgAkECdGoiASgCACIDLQAUBEAgACADKAIcIAgqAgwQRiEDIAAgASgCACgCICAIKgIMEEYhBCABKAIAIgEgACgCECIFIANB9AFsaiAFIARB9AFsaiAIKgIMIAEoAgAoAhgRDwALIAJBAWoiAiAHRw0ACwsgACgCHCIDQQFOBEBBACECA0AgACgCECIEIAAoAiQgACgCdCACQQJ0aigCAEGYAWxqIgEoApABQfQBbGogBCABKAKUAUH0AWxqIAEQ0QIgAkEBaiICIANHDQALCyAAKAJEIgJBAU4EQEEAIQMDQCAAKAIkIAAoAkwgACgCnAEgA0ECdGooAgBBmAFsaiIBKAKMAUGYAWxqKgJkIg9DAAAAAF5BAXNFBEAgASAPIAEqAmgiEJQ4AnwgASAPIBCMlDgCeCAAKAIQIgQgASgCkAFB9AFsaiAEIAEoApQBQfQBbGogARBUCyADQQFqIgMgAkcNAAsLIAAoAlgiAkEBSA0BQQAhAwNAIAAoAiQgACgCYCADQZgBbGoiASgCjAFBmAFsaioCZCIQQwAAAABeQQFzRQRAIAEgASoCaCIPIBAgD5QiECAQIA9eGyIPOAJ8IAEgD4w4AnggACgCECIEIAEoApABQfQBbGogBCABKAKUAUH0AWxqIAEQVAsgA0EBaiIDIAJHDQALDAELIANBAUgNAEECQQEgAUEQcRshBUEAIQIDQCAAKAIQIgQgACgCJCAAKAJ0IAJBAnRqKAIAQZgBbGoiASgCkAFB9AFsaiAEIAEoApQBQfQBbGogARDRAiACIAVsQQJ0IQQgASoCZCIPQwAAAABeQQFzIgZFBEAgACgCTCAAKAKcASAEaigCAEGYAWxqIgEgDyABKgJoIhCUOAJ8IAEgDyAQjJQ4AnggACgCECIHIAEoApABQfQBbGogByABKAKUAUH0AWxqIAEQVAsCQCAILQBAQRBxRQ0AIAYNACAAKAJMIAQgACgCnAFqKAIEQZgBbGoiASAPIAEqAmgiEJQ4AnwgASAPIBCMlDgCeCAAKAIQIgQgASgCkAFB9AFsaiAEIAEoApQBQfQBbGogARBUCyACQQFqIgIgA0cNAAsLQwAAAAALliQCDX8mfSMAQYACayILJAAgAEF/NgK8AUGwxQAQFkEAIQggAEEANgK4ASACQQBKBEADQCABIAhBAnRqKAIAQX82AtQBIAhBAWoiCCACRw0ACwsgACgCDCIPIAJMBEACf0EAIAJBAWoiD0UNABpB6PcBQej3ASgCAEEBajYCACAPQfQBbEEQQYzSASgCABEDAAshDCAAKAIIIg5BAU4EQANAIAwgCkH0AWwiCWoiCCAAKAIQIAlqIgkpAgA3AgAgCCAJKQIINwIIIAggCSkCGDcCGCAIIAkpAhA3AhAgCCAJKQIoNwIoIAggCSkCIDcCICAIIAkpAjA3AjAgCCAJKQI4NwI4IAhBQGsgCUFAa0G0ARAVGiAKQQFqIgogDkcNAAsLIAAoAhAiCARAIAAtABQEQCAIBEBB7PcBQez3ASgCAEEBajYCACAIQZDSASgCABEAAAsLIABBADYCEAsgACAMNgIQIAAgDzYCDCAAQQE6ABQLIAtBCGpBAEH0ARALGiAAKAIIIghBf0wEQCAPQX9MBEAgACgCECIJBEAgAC0AFARAIAkEQEHs9wFB7PcBKAIAQQFqNgIAIAlBkNIBKAIAEQAACwsgAEEANgIQCyAAQgA3AgwgAEEBOgAUCyALQcgAaiEKA0AgACgCECAIQfQBbGoiCSALKQMINwIAIAkgCykDEDcCCCAJIAspAiA3AhggCSALKQIYNwIQIAkgCykCMDcCKCAJIAspAig3AiAgCSALKQI4NwIwIAkgCykCQDcCOCAJQUBrIApBtAEQFRogCEEBaiIJIAhPIQwgCSEIIAwNAAsLIABBADYCCCACQQFOBEBBACEIA0AgACABIAhBAnRqIgkoAgAgByoCDBBGIQoCQCAJKAIAIglFDQAgCSgC7AFBAnFFDQAgCSoC2AJDAAAAAFsNACAJLQD4A0ECcUUNACAAKAIQIQwgC0EIaiAJIAcqAkwQiw8gCSoCsAIhGCAJKgKQAiEZIAkqAqACIR4gCSoCrAIhHyAJKgKMAiEcIAkqApwCISAgDCAKQfQBbGoiCiAKKgLgASALKgIIIhYgCSoCiAKUIAsqAgwiGiAJKgKYApSSIAsqAhAiGyAJKgKoApSSIAcqAgwiF5STOALgASAKIAoqAuQBIBcgFiAclCAaICCUkiAbIB+UkpSTOALkASAKIAoqAugBIBcgFiAZlCAaIB6UkiAbIBiUkpSTOALoAQsgCEEBaiIIIAJHDQALC0EAIQggBkEASgRAA0AgBSAIQQJ0aigCACIBIAEoAgAoAggRAAAgAUEANgIkIAhBAWoiCCAGRw0ACwsCQCAAKAKoASICIAZODQAgACgCrAEgBk4NAAJAIAZFBEBBACEBDAELQej3AUHo9wEoAgBBAWo2AgAgBkEDdEEQQYzSASgCABEDACEBIAAoAqgBIQILIAJBAU4EQEEAIQgDQCABIAhBA3QiCWogACgCsAEgCWopAgA3AgAgCEEBaiIIIAJHDQALCyAAKAKwASICBEAgAC0AtAEEQCACBEBB7PcBQez3ASgCAEEBajYCACACQZDSASgCABEAAAsLIABBADYCsAELIAAgATYCsAEgACAGNgKsASAAQQE6ALQBCyAAIAY2AqgBQQAhASAGQQFOBEBBACEIA0AgACgCsAEhCiAFIAhBAnRqIgwoAgAiAigCLCIJBEAgCUIANwIAIAlCADcCOCAJQgA3AjAgCUIANwIoIAlCADcCICAJQgA3AhggCUIANwIQIAlCADcCCCAMKAIAIQILIAogCEEDdGohCQJ/IAItABQEQCACIAkgAigCACgCEBECACAJKAIADAELIAlBADYCACAJQQA2AgRBAAsgAWohASAIQQFqIgggBkcNAAsLAkAgACgCMCICIAFODQAgACgCNCABTg0AAkAgAUUEQEEAIQoMAQtB6PcBQej3ASgCAEEBajYCACABQZgBbEEQQYzSASgCABEDACEKIAAoAjAhAgsgAkEBTgRAQQAhCANAIAogCEGYAWwiCWogACgCOCAJakGYARAVGiAIQQFqIgggAkcNAAsLIAAoAjgiAgRAIAAtADwEQCACBEBB7PcBQez3ASgCAEEBajYCACACQZDSASgCABEAAAsLIABBADYCOAsgACAKNgI4IAAgATYCNCAAQQE6ADwLIAAgATYCMCAGQQFOBEAgACgCsAEhCEEAIQ8DQCAIIBJBA3QiFWoiESgCAARAIAUgEkECdGoiEygCACIQKAIgIQIgACgCOCEBIAAgECgCHCIIIAcqAgwQRiEKIAAgAiAHKgIMEEYhDCAAKAIQIQ0gECgCGCIJIAcoAhQgCUEAShsiFCAAKAK4AUoEQCAAIBQ2ArgBCyAPQZgBbCABaiEOQQAhASARKAIAQQFOBEADQCAOIAFBmAFsakEAQZgBEAsiCUL////7////v/8ANwJ4IAkgDDYClAEgCSAKNgKQASAJQgA3AmAgCSAUNgKIASABQQFqIgEgESgCAEgNAAsLIA0gCkH0AWxqIgpCADcCQCAKQgA3ApABIApCADcCWCAKQgA3AlAgCkIANwJIIApCADcCmAEgCkIANwKgASAKQgA3AqgBIA0gDEH0AWxqIgxCADcCWCAMQgA3AlAgDEIANwJIIAxCADcCQCAMQgA3ApABIAxCADcCmAEgDEIANwKgASAMQgA3AqgBIAtDAACAPyAHKgIMlTgCCCAHKAIgIQEgCyAOQfAAajYCJCALQSY2AiAgCyAOQSBqNgIcIAsgDkEwajYCGCALIA42AhQgCyAOQRBqNgIQIAsgATYCDCAOIAcoAig2AnQgBygCBCEBIAsgDkH8AGo2AjAgCyAOQfgAajYCLCALIA5B9ABqNgIoIAsgATYCPCALIAcoAhQ2AjggEygCACIBIAtBCGogASgCACgCFBECACARKAIAQQFOBEBBACEJA0AgDiAJQZgBbGoiASoCfCATKAIAKgIQIhZgQQFzRQRAIAEgFjgCfAsgASoCeCAWjCIWX0EBc0UEQCABIBY4AngLIAEgEDYChAEgECgCHCINKgKMAiEXIA0qApACIRggDSoCpAQhGSANKgKgAiEeIA0qApgCIR8gDSoCnAIhHCANKgKoBCEWIA0qArACIRsgDSoCqAIhGiANKgKsAiEgIA0qAqAEISEgDSoCiAIhHSABQQA2AkwgASAWIBogASoCACIWlCAgIAEqAgQiGpSSIBsgASoCCCIblJKUOAJIIAEgGSAWIB+UIBogHJSSIBsgHpSSlDgCRCABICEgHSAWlCAXIBqUkiAYIBuUkpQ4AkAgECgCICINKgKMAiEeIA0qApACIR8gDSoCpAQhHCANKgKgAiEgIA0qApgCISEgDSoCnAIhHSANKgKoBCEXIA0qArACIRkgDSoCqAIhGCANKgKsAiEjIA0qAqAEISQgDSoCiAIhIiABQQA2AlwgASAXIBggASoCICIXlCAjIAEqAiQiGJSSIBkgASoCKCIZlJKUOAJYIAEgHCAXICGUIBggHZSSIBkgIJSSlDgCVCABICQgIiAXlCAeIBiUkiAfIBmUkpQ4AlBDAAAAACEeIAFDAACAPyABKgIQIh8gHyAIKgLYAiIclJQgASoCFCIgIBwgIJSUkiABKgIYIiEgHCAhlJSSIBYgFiAIKgKIApQgGiAIKgKMApSSIBsgCCoCkAKUkpQgGiAWIAgqApgClCAaIAgqApwClJIgGyAIKgKgApSSlJIgGyAWIAgqAqgClCAaIAgqAqwClJIgGyAIKgKwApSSlJKSIAEqAjAiHCAcIAIqAtgCIh2UlCABKgI0IiMgHSAjlJSSIAEqAjgiJCAdICSUlJKSIBcgFyACKgKIApQgGCACKgKMApSSIBkgAioCkAKUkpQgGCAXIAIqApgClCAYIAIqApwClJIgGSACKgKgApSSlJIgGSAXIAIqAqgClCAYIAIqAqwClJIgGSACKgKwApSSlJKSIh2VQwAAAAAgHYtDAAAANF4bIh04AmxDAAAAACEiQwAAAAAhJUMAAAAAISZDAAAAACEnQwAAAAAhKEMAAAAAISkgCigC8AEEQCAKKgLoASEpIAoqAuQBISggCioC4AEhJyAKKgLUASElIAoqAtABISYgCioC2AEhIgtDAAAAACEqQwAAAAAhK0MAAAAAISxDAAAAACEtQwAAAAAhLiAMKALwAQRAIAwqAugBIS4gDCoC5AEhLSAMKgLgASEsIAwqAtQBISogDCoC0AEhKyAMKgLYASEeCyAIKgLAAiEvIAgqArgCITAgCCoCvAIhMSAIKgLQAiEyIAgqAsgCITMgCCoCzAIhNCACKgLAAiE1IAIqArgCITYgAioCvAIhNyACKgLQAiE4IAIqAsgCITkgAioCzAIhOiALKgI8ITsgAUEANgJkIAEgHSABKgJwlCAdQwAAAAAgOyAfICYgMJKUICAgJSAxkpSSICEgIiAvkpSSIBYgJyAzkpQgGiAoIDSSlJIgGyApIDKSlJKSIBwgKyA2kpQgIyAqIDeSlJIgJCAeIDWSlJIgFyAsIDmSlCAYIC0gOpKUkiAZIC4gOJKUkpKSlJOUkjgCcCAJQQFqIgkgESgCAEgNAAsLIAAoArABIQgLIA8gCCAVaigCAGohDyASQQFqIhIgBkcNAAsLIAAgAyAEIAcgACgCACgCHBEEACAAKAJEIQQgACgCHCEDAkAgACgCgAEiCSAAKAIwIgVODQAgACgChAEgBU4NAEEAIQhBACEBIAUEQEHo9wFB6PcBKAIAQQFqNgIAIAVBAnRBEEGM0gEoAgARAwAhASAAKAKAASEJCyAAKAKIASECAkACQCAJQQFOBEADQCABIAhBAnQiBmogAiAGaigCADYCACAIQQFqIgggCUcNAAwCAAsACyACRQ0BCyAALQCMAQRAIAIEQEHs9wFB7PcBKAIAQQFqNgIAIAJBkNIBKAIAEQAACwsgAEEANgKIAQsgACABNgKIASAAIAU2AoQBIABBAToAjAELIAAgBTYCgAECQCAHLQBAQRBxBEACQCAAKAJsIgkgA0EBdCIGTg0AIAAoAnAgBk4NAEEAIQhBACEBIAMEQEHo9wFB6PcBKAIAQQFqNgIAIANBA3RBEEGM0gEoAgARAwAhASAAKAJsIQkLIAAoAnQhAgJAAkAgCUEBTgRAA0AgASAIQQJ0IgdqIAIgB2ooAgA2AgAgCEEBaiIIIAlHDQAMAgALAAsgAkUNAQsgAC0AeARAIAIEQEHs9wFB7PcBKAIAQQFqNgIAIAJBkNIBKAIAEQAACwsgAEEANgJ0CyAAIAE2AnQgACAGNgJwIABBAToAeAsgACAGNgJsDAELAkAgACgCbCIJIANODQAgACgCcCADTg0AQQAhCEEAIQEgAwRAQej3AUHo9wEoAgBBAWo2AgAgA0ECdEEQQYzSASgCABEDACEBIAAoAmwhCQsgACgCdCECAkACQCAJQQFOBEADQCABIAhBAnQiBmogAiAGaigCADYCACAIQQFqIgggCUcNAAwCAAsACyACRQ0BCyAALQB4BEAgAgRAQez3AUHs9wEoAgBBAWo2AgAgAkGQ0gEoAgARAAALCyAAQQA2AnQLIAAgATYCdCAAIAM2AnAgAEEBOgB4CyAAIAM2AmwLAkAgACgClAEiCSAETg0AIAAoApgBIARODQBBACEIQQAhASAEBEBB6PcBQej3ASgCAEEBajYCACAEQQJ0QRBBjNIBKAIAEQMAIQEgACgClAEhCQsgACgCnAEhAgJAAkAgCUEBTgRAA0AgASAIQQJ0IgZqIAIgBmooAgA2AgAgCEEBaiIIIAlHDQAMAgALAAsgAkUNAQsgAC0AoAEEQCACBEBB7PcBQez3ASgCAEEBajYCACACQZDSASgCABEAAAsLIABBADYCnAELIAAgATYCnAEgACAENgKYASAAQQE6AKABCyAAIAQ2ApQBIAVBAU4EQCAAKAKIASEBQQAhCANAIAEgCEECdGogCDYCACAIQQFqIgggBUcNAAsLIANBAU4EQCAAKAJ0IQFBACEIA0AgASAIQQJ0aiAINgIAIAhBAWoiCCADRw0ACwsgBEEBTgRAIAAoApwBIQBBACEIA0AgACAIQQJ0aiAINgIAIAhBAWoiCCAERw0ACwsQEyALQYACaiQAQwAAAAALLQEBfyACQQFOBEADQCAAIAEgBEECdGooAgAgAxCPDiAEQQFqIgQgAkcNAAsLC9wgAhN/G30jAEHgAGsiAyQAIAEoAugFIQQgACABKALkBSIGIAIqAgwQRiEJIAAgBCACKgIMEEYhCgJAAkAgACgCECIIIAlB9AFsaiIFKgKAAUMAAAAAXA0AIAUqAoQBQwAAAABcDQAgCCAJQfQBbGoqAogBQwAAAABcDQAgCCAKQfQBbGoqAoABQwAAAABcDQAgCCAKQfQBbGoiBSoChAFDAAAAAFwNACAFKgKIAUMAAAAAWw0BCyABKALsBSIFQQFIDQAgCCAKQfQBbGoiDSETIAggCUH0AWxqIg4hFEEBIREDQCABIBJBuAFsaiIHKgJUIAEqAvQFX0EBc0UEQCAHQQRqIQsgACgCHCIIIQUCQCAIIAAoAiBHDQAgCCIFIAVBAXRBASAFGyIMTg0AQQAhBSAIIQ9BACEQAn8gDARAQej3AUHo9wEoAgBBAWo2AgAgDEGYAWxBEEGM0gEoAgARAwAhECAAKAIcIQ8LIA9BAU4LBEADQCAQIAVBmAFsIhVqIAAoAiQgFWpBmAEQFRogBUEBaiIFIA9HDQALCyAAKAIkIgUEQCAALQAoBEAgBQRAQez3AUHs9wEoAgBBAWo2AgAgBUGQ0gEoAgARAAALCyAAQQA2AiQLIAAgEDYCJCAAQQE6ACggACAMNgIgIAAoAhwhBQsgACAFQQFqNgIcIAYoAuwBIQUgBCgC7AEhECAAKAIkIAhBmAFsaiIPIAo2ApQBIA8gCTYCkAEgDyALNgKEASAHKgI0IRcgByoCOCEZIAcqAjwhFiAGKgI0IRggBioCOCEaIAYqAjwhGyADQQA2AlwgAyAWIBuTIhY4AlggAyAZIBqTIhk4AlQgAyAXIBiTIhc4AlAgByoCJCEbIAcqAighGiAHKgIsIRggBCoCNCEjIAQqAjghJiAEKgI8ISogA0EANgJMIAMgGCAqkyIYOAJIIAMgGiAmkyIaOAJEIAMgGyAjkyIbOAJAQwAAAAAhI0MAAAAAISZDAAAAACEqQwAAAAAhLCAOKALwAQRAIA4qArgBIA4qAtgBkiAZIA4qAsABIA4qAuABkiImlCAXIA4qAsQBIA4qAuQBkiIrlJOSISwgDioCtAEgDioC1AGSIBcgDioCyAEgFCoC6AGSIheUIBYgJpSTkiEqIA4qArABIA4qAtABkiAWICuUIBkgF5STkiEmC0MAAAAAIStDAAAAACEtIA0oAvABBEAgDSoCuAEgDSoC2AGSIBogDSoCwAEgDSoC4AGSIhaUIBsgDSoCxAEgDSoC5AGSIhmUk5IhLSANKgK0ASANKgLUAZIgGyANKgLIASATKgLoAZIiF5QgGCAWlJOSISsgDSoCsAEgDSoC0AGSIBggGZQgGiAXlJOSISMLIAcqAkwhLiAHQcQAaiIMKgIAIS8gByoCSCEwIAAgDyAJIAogCyACIANBPGogA0HQAGogA0FAaxCRDiAPIAAoAkQ2AowBQwAAAAAhF0MAAAAAIRZDAAAAACEZQwAAAAAhGCAFQQJxBEAgBUEedEEfdSAGcSIFKgLQAiEYIAUqAswCIRkgBSoCyAIhFgtDAAAAACEaQwAAAAAhGyAQQQJxBEAgEEEedEEfdSAEcSIFKgLQAiEbIAUqAswCIRogBSoCyAIhFwsgA0EANgI0IAMgGyAYkyIYOAIwIAMgGiAZkyIZOAIsIAMgFyAWkyIXOAIoAkAgEUEBSA0AIAcqAlxDAAAAAF5BAXMNACAXIBeUIBkgGZSSIBggGJSSkSIWIAIqAlBeQQFzRQRAIAMgGEMAAIA/IBaVIhiUIhY4AjAgAyAZIBiUIhk4AiwgAyAXIBiUIhc4AiggBi0AtAFBAnEEQCAGKgKsASEdIAYqAiwhGCAGKgIMIRogBioCHCEbIAYqAqQBISQgBioCJCEeIAYqAgQhHyAGKgIUISAgBioCqAEhJSAGKgIoIRwgBioCCCEhIAYqAhghIiADQQA2AjQgAyAeICQgFyAflCAZICCUkiAWIB6UkpQiHpQgHCAlIBcgIZQgGSAilJIgFiAclJKUIhyUkiAYIB0gFyAalCAZIBuUkiAWIBiUkpQiF5SSIhY4AjAgAyAgIB6UICIgHJSSIBsgF5SSIhk4AiwgAyAfIB6UICEgHJSSIBogF5SSIhc4AigLIAQtALQBQQJxBEAgBCoCrAEhHSAEKgIsIRggBCoCDCEaIAQqAhwhGyAEKgKkASEkIAQqAiQhHiAEKgIEIR8gBCoCFCEgIAQqAqgBISUgBCoCKCEcIAQqAgghISAEKgIYISIgA0EANgI0IAMgHiAkIB8gF5QgICAZlJIgHiAWlJKUIh6UIBwgJSAXICGUIBkgIpSSIBYgHJSSlCIclJIgGCAdIBcgGpQgGSAblJIgFiAYlJKUIheUkiIWOAIwIAMgICAelCAiIByUkiAbIBeUkiIZOAIsIAMgHyAelCAhIByUkiAaIBeUkiIXOAIoC0EAIREgFyAXlCAZIBmUkiAWIBaUkpG7RPyp8dJNYlA/ZEEBcw0BIAAgA0EoaiAJIAogCCALEOgBDAELIAAgDCAJIAogCCALEOgBIAMCfSAHKgJMIheLQ/MENT9eQQFzRQRAIAcqAkghFiADQQA2AhggAyAWQwAAgD8gFyAXlCAWIBaUkiIakZUiGJQiGTgCICADIBggF4yUIhY4AhwgAyAaIBiUIho4AgggAyAZIAwqAgAiF4yUIhs4AgxDAAAAACEYIBcgFpQMAQsgDCoCACEWIAcqAkghGSADQQA2AiAgAyAWQwAAgD8gFiAWlCAZIBmUkiIfkZUiHpQiFjgCHCADIB4gGYyUIhg4AhggAyAXIBiUIhs4AgwgAyAWIBeMlCIaOAIIQwAAAAAhGSAfIB6UCyIXOAIQIAYoArQBQQJxIgUEQCAGKgKsASEnIAYqAiwhHiAGKgIMIR8gBioCHCEgIAYqAqQBISggBioCJCEcIAYqAgQhISAGKgIUISIgBioCqAEhKSAGKgIoIR0gBioCCCEkIAYqAhghJSADQQA2AiQgAyAcICggISAYlCAiIBaUkiAcIBmUkpQiHJQgHSApIBggJJQgFiAllJIgGSAdlJKUIh2UkiAeICcgGCAflCAWICCUkiAZIB6UkpQiGJSSIhk4AiAgAyAiIByUICUgHZSSICAgGJSSIhY4AhwgAyAhIByUICQgHZSSIB8gGJSSIhg4AhgLIAQoArQBQQJxIhEEQCAEKgKsASEnIAQqAiwhHiAEKgIMIR8gBCoCHCEgIAQqAqQBISggBCoCJCEcIAQqAgQhISAEKgIUISIgBCoCqAEhKSAEKgIoIR0gBCoCCCEkIAQqAhghJSADQQA2AiQgAyAcICggISAYlCAiIBaUkiAcIBmUkpQiHJQgHSApIBggJJQgFiAllJIgGSAdlJKUIh2UkiAeICcgGCAflCAWICCUkiAZIB6UkpQiGJSSIhk4AiAgAyAiIByUICUgHZSSICAgGJSSIhY4AhwgAyAhIByUICQgHZSSIB8gGJSSIhg4AhgLIAUEQCAGKgKsASEnIAYqAiwhHiAGKgIMIR8gBioCHCEgIAYqAqQBISggBioCJCEcIAYqAgQhISAGKgIUISIgBioCqAEhKSAGKgIoIR0gBioCCCEkIAYqAhghJSADQQA2AhQgAyAcICggISAalCAiIBuUkiAXIByUkpQiHJQgHSApIBogJJQgGyAllJIgFyAdlJKUIh2UkiAeICcgGiAflCAbICCUkiAXIB6UkpQiGpSSIhc4AhAgAyAiIByUICUgHZSSICAgGpSSIhs4AgwgAyAhIByUICQgHZSSIB8gGpSSIho4AggLIBEEQCAEKgKsASEnIAQqAiwhHiAEKgIMIR8gBCoCHCEgIAQqAqQBISggBCoCJCEcIAQqAgQhISAEKgIUISIgBCoCqAEhKSAEKgIoIR0gBCoCCCEkIAQqAhghJSADQQA2AhQgAyAcICggISAalCAiIBuUkiAcIBeUkpQiHJQgHSApIBogJJQgGyAllJIgFyAdlJKUIh2UkiAeICcgGiAflCAbICCUkiAXIB6UkpQiGpSSIhc4AhAgAyAiIByUICUgHZSSICAgGpSSIhs4AgwgAyAhIByUICQgHZSSIB8gGpSSIho4AggLIBggGJQgFiAWlJIgGSAZlJKRu0T8qfHSTWJQP2RBAXNFBEAgACADQRhqIAkgCiAIIAsQ6AELIBogGpQgGyAblJIgFyAXlJKRu0T8qfHSTWJQP2RBAXNFBEAgACADQQhqIAkgCiAIIAsQ6AELQQAhEQsCQCACLQBAQSBxQQAgBy0AeBtFBEAgDCoCACEZIAcqAkghFiAHKgJMIRcgB0EANgKoASAHICwgLZMiGCAXICYgI5MiIyAvlCAqICuTIhogMJSSIBggLpSSIhuUkyIYOAKkASAHIBogGyAWlJMiGjgCoAEgB0GcAWoiBSAjIBsgGZSTIhs4AgACQCACLQBAQcAAcQ0AIBsgG5QgGiAalJIgGCAYlJIiI0MAAAA0XkEBcw0AIAUgG0MAAIA/ICORlSIWlDgCACAHIBogFpQ4AqABIAcgGCAWlDgCpAEgBiAFEFMgBCAFEFMgACAFIAkgCiAIIAsgA0HQAGogA0FAayADKgI8IiZDAAAAAEMAAAAAEH4gAi0AQEEQcUUNAiAHKgKgASEWIAcqAkghGSAMKgIAIRcgByoCpAEhGCAFKgIAIRogByoCTCEbIAdBADYCuAEgByAZIBqUIBYgF5STIiNDAACAPyAWIBuUIBggGZSTIhYgFpQgGCAXlCAbIBqUkyIZIBmUkiAjICOUkpGVIheUOAK0ASAHIBkgF5Q4ArABIAdBrAFqIgUgFiAXlDgCACAGIAUQUyAEIAUQUyAAIAUgCSAKIAggCyADQdAAaiADQUBrICZDAAAAAEMAAAAAEH4MAgsgB0GsAWoiDAJ9IBeLQ/MENT9eQQFzRQRAIAVBADYCACAHQwAAgD8gFiAWlCAXIBeUkiIakZUiGCAXjJQiGzgCoAEgByAWIBiUIiM4AqQBIBkgG5QhFiAjIBmMlCEZIBogGJQMAQsgBUMAAIA/IBkgGZQgFiAWlJIiGpGVIhggFoyUIhs4AgAgByAZIBiUIiM4AqABIAdBADYCpAEgGiAYlCEWIBcgG5QhGSAjIBeMlAs4AgAgByAWOAK0ASAHIBk4ArABIAYgBRBTIAQgBRBTIAAgBSAJIAogCCALIANB0ABqIANBQGsgAyoCPCIWQwAAAABDAAAAABB+IAIoAkAiBUEQcQR/IAYgDBBTIAQgDBBTIAAgDCAJIAogCCALIANB0ABqIANBQGsgFkMAAAAAQwAAAAAQfiACKAJABSAFC0HQAHFB0ABHDQEgB0EBOgB4DAELIAAgB0GcAWogCSAKIAggCyADQdAAaiADQUBrIAMqAjwiFiAHKgKIASAHKgKQARB+IAItAEBBEHFFDQAgACAHQawBaiAJIAogCCALIANB0ABqIANBQGsgFiAHKgKMASAHKgKUARB+CyAAIA8gCSAKIAsgAhCQDiABKALsBSEFCyASQQFqIhIgBUgNAAsLIANB4ABqJAALqQgCB38JfSAAKAJMIQkgASgCjAEhCwJAIAUoAkAiDEEEcQRAIAAoAhAiCiADQfQBbGooAvABIQEgCiACQfQBbGooAvABIQcgCSALQZgBbGoiBiAEKgJ8IAUqAjyUIg04AmQgBwRAIAcqAuQCIQ8gBioCGCEQIAcqAuACIREgBioCFCESIAogAkH0AWxqIgAgDSAHKgLYAiIOIAYqAhCUIAcqAtwClJQgACoCcJQgACoCQJI4AkAgACANIBEgDiASlJSUIAAqAnSUIAAqAkSSOAJEIAAgDSAPIA4gEJSUlCAAKgJ4lCAAKgJIkjgCSCAGKgJIIQ4gBioCRCEPIAAgDSAAKgJglCAGKgJAlCAAKgJQkjgCUCAAKgJoIRAgACAPIA0gACoCZJSUIAAqAlSSOAJUIAAgDiANIBCUlCAAKgJYkjgCWAsgAQRAIAkgC0GYAWxqIggqAlghDyAIKgJUIRAgCCoCUCERIAEqAuQCIRIgCCoCOCETIAEqAuACIRQgCCoCNCEVIAogA0H0AWxqIgAgACoCQCABKgLYAiIOIAgqAjCUIAEqAtwClCAGKgJkIg2UIAAqAnCUkjgCQCAAIAAqAkQgDSAUIA4gFZSUlCAAKgJ0lJI4AkQgACAAKgJIIA0gEiAOIBOUlJQgACoCeJSSOAJIIAAgACoCUCARIA0gACoCYJSUkjgCUCAAKgJoIQ4gACAAKgJUIBAgDSAAKgJklJSSOAJUIAAgACoCWCAPIA4gDZSUkjgCWAsgDEEQcUUNASAJIAtBAWoiCEGYAWxqIgYgBCoCgAEgBSoCPJQiDTgCZCAHBEAgBioCGCEPIAYqAhQhECAKIAJB9AFsaiIAIA0gByoC2AIiDiAGKgIQlJQgACoCcJQgACoCQJI4AkAgACANIA4gEJSUIAAqAnSUIAAqAkSSOAJEIAAgDSAOIA+UlCAAKgJ4lCAAKgJIkjgCSCAGKgJIIQ4gBioCRCEPIAAgDSAAKgJglCAGKgJAlCAAKgJQkjgCUCAAKgJoIRAgACAPIA0gACoCZJSUIAAqAlSSOAJUIAAgDiANIBCUlCAAKgJYkjgCWAsgAUUNASAJIAhBmAFsaiICKgJYIQ8gAioCVCEQIAIqAjghESACKgI0IRIgAioCMCETIAEqAtgCIQ4gCiADQfQBbGoiACAAKgJQIAIqAlAgACoCYCAGKgJkIg2UlJI4AlAgACAAKgJAIA0gDiATlJQgACoCcJSSOAJAIAAgACoCRCANIA4gEpSUIAAqAnSUkjgCRCAAIAAqAkggDSAOIBGUlCAAKgJ4lJI4AkggACoCaCEOIAAgACoCVCAQIA0gACoCZJSUkjgCVCAAIAAqAlggDyAOIA2UlJI4AlgPCyAJIAtBmAFsaiIAQQA2AmQgDEEQcUUNACAAQQA2AvwBCwuTEwIEfxB9IAAoAhAiCiADQfQBbGoiCygC8AEhACAKIAJB9AFsaiIMKALwASEJIAZBgICA/AM2AgAgBCoCRCINIAcqAgAiDpQgByoCBCIQIAQqAkAiD5STIRUgByoCCCISIA+UIAQqAkgiDyAOlJMhFyAQIA+UIBIgDZSTIRhDAAAAACENQwAAAAAhDkMAAAAAIRAgCQRAIBggCSoCqAKUIBcgCSoCrAKUkiAVIAkqArAClJIgCSoCqASUIRAgGCAJKgKYApQgFyAJKgKcApSSIBUgCSoCoAKUkiAJKgKkBJQhDiAYIAkqAogClCAXIAkqAowClJIgFSAJKgKQApSSIAkqAqAElCENCyABIA04AkAgAUEANgJMIAEgEDgCSCABIA44AkQgBCoCRCIPIAgqAgAiEpQgCCoCBCIUIAQqAkAiE5STIRkgCCoCCCIWIBOUIAQqAkgiEyASlJMhGiAUIBOUIBYgD5STIRZDAAAAACEPQwAAAAAhEiAABEAgACoCrAIgGowiEZQgFiAAKgKoApSTIBkgACoCsAKUkyAAKgKoBJQhEiAAKgKcAiARlCAWIAAqApgClJMgGSAAKgKgApSTIAAqAqQElCEPIAAqAowCIBGUIBYgACoCiAKUkyAZIAAqApAClJMgACoCoASUIRELIAEgETgCUCABQQA2AlwgASASOAJYIAEgDzgCVEMAAAAAIRRDAAAAACETIAEgBioCACAJBH0gCSoC2AIgDiAHKgIIIhOUIBAgByoCBCIblJMgBCoCQJQgECAHKgIAIhCUIBMgDZSTIAQqAkSUkiAbIA2UIA4gEJSTIAQqAkiUkpIFQwAAAAALIAAEfSAAKgLYAiASIAgqAgQiDZQgDyAIKgIIIg6UkyAEKgJAlCARIA6UIBIgCCoCACIOlJMgBCoCRJSSIA8gDpQgESANlJMgBCoCSJSSkgVDAAAAAAuSlTgCbAJAIAkEQCABIARBQGsiBikCADcCECABIAYpAgg3AhggAUEANgIMIAEgFTgCCCABIBc4AgQgASAYOAIADAELIAFCADcCACABQgA3AhggAUIANwIQIAFCADcCCAsCQCAABEAgBCoCQCENIAQqAkQhDiAEKgJIIRAgAUEANgI8IAFBADYCLCABIBmMOAIoIAEgGow4AiQgASAWjDgCICABIBCMOAI4IAEgDow4AjQgASANjDgCMAwBCyABQgA3AiAgAUIANwI4IAFCADcCMCABQgA3AigLQwAAAAAhEUMAAAAAIQ1DAAAAACEOQwAAAAAhECAJBEAgByoCBCINIAkqAsgCIg6UIAkqAswCIg8gByoCACISlJMgCSoCwAKSIRAgCSoCvAIgCSoC0AIiFCASlCAHKgIIIhIgDpSTkiEOIA8gEpQgFCANlJMgCSoCuAKSIQ0LQwAAAAAhD0MAAAAAIRIgAARAIAgqAgQiESAAKgLIAiIPlCAAKgLMAiIUIAgqAgAiE5STIAAqAsACkiESIAAqArwCIAAqAtACIhUgE5QgCCoCCCITIA+Uk5IhDyAUIBOUIBUgEZSTIAAqArgCkiERCyAFKgI4IRogBCoCUCEbIAQqAkghFCAEKgJAIRMgBCoCRCEVIAEgBCgCVDYCaCATIA0gEZOUIBUgDiAPk5SSIBQgECASk5SSjCERIAQqAlwhHAJAIAUtAEBBBHEEQCABIAQqAnggBSoCPJQiDTgCZAJAIAlFDQAgDCgC8AFFDQAgCSoC5AIhDiABKgIYIRAgCSoC4AIhDyABKgIUIRIgCiACQfQBbGoiBCAEKgJwIA0gASoCECAEKgKAAZQgCSoC3AKUlJQgBCoCQJI4AkAgBCANIA8gEiAEKgKEAZSUlCAEKgJ0lCAEKgJEkjgCRCAEIA0gDiAQIAQqAogBlJSUIAQqAniUIAQqAkiSOAJIIAEqAkghDiABKgJEIRAgBCANIAQqAmCUIAEqAkCUIAQqAlCSOAJQIAQqAmghDyAEIBAgDSAEKgJklJQgBCoCVJI4AlQgBCAOIA0gD5SUIAQqAliSOAJYCyAARQ0BIAsoAvABRQ0BIAAqAuQCIQ4gASoCOCEQIAAqAuACIQ8gASoCNCESIAEqAlghFCABKgJUIRMgASoCUCEVIAogA0H0AWxqIgQgBCoCQCAEKgJwIAQqAoABIAEqAjCUIAAqAtwClCABKgJkjCINlJSTOAJAIAQgBCoCRCAPIBIgBCoChAGUlCANlCAEKgJ0lJM4AkQgBCAEKgJIIA4gECAEKgKIAZSUIA2UIAQqAniUkzgCSCAEIAQqAlAgFSAEKgJgIA2UlJM4AlAgBCoCaCEOIAQgBCoCVCATIAQqAmQgDZSUkzgCVCAEIAQqAlggFCAOIA2UlJM4AlgMAQsgAUEANgJkCyABQQA2AmBDAAAAACENQwAAAAAhDkMAAAAAIRBDAAAAACEPQwAAAAAhEkMAAAAAIRVDAAAAACEXIAwoAvABBEAgCiACQfQBbGoiACoC4AEhFyAAKgLQASEPIAAqAugBIRIgACoC5AEhFSAAKgLUASEQIAAqAtgBIQ4LQwAAAAAhGEMAAAAAIRlDAAAAACEWQwAAAAAhFEMAAAAAIRMgCygC8AEEQCAKIANB9AFsaiIAKgLgASETIAAqAugBIRYgACoC5AEhFCAAKgLYASEZIAAqAtQBIRggACoC0AEhDQtDAAAAACAcIBGUIhEgEUMAAAAAXxshHCAbIBqSIREgDyAKIAJB9AFsaiIAKgKwAZIgASoCEJQgECAAKgK0AZIgASoCFJSSIA4gACoCuAGSIAEqAhiUkiAXIAAqAsABkiABKgIAlCAVIAAqAsQBkiABKgIElJIgEiAAKgLIAZIgASoCCJSSkiANIAogA0H0AWxqIgAqArABkiABKgIwlCAYIAAqArQBkiABKgI0lJIgGSAAKgK4AZIgASoCOJSSIBMgACoCwAGSIAEqAiCUIBQgACoCxAGSIAEqAiSUkiAWIAAqAsgBkiABKgIolJKSkiENAn8CQCAFKAIsIgJFDQAgESAFKgIwXkEBc0UNACAFQSRqDAELIAVBIGoLIQAgHCANkyENQwAAAAAhDgJAIBFDAAAAAF5BAXNFBEAgDSARIAUqAgyVkyENDAELIAAqAgAgEYyUIAUqAgyVIQ4LIA0gASoCbCIQlCENIA4gEJQhDiABIAJBACARIAUqAjBeQQFzGwR9IA4FIA4gDZIhDUMAAAAACzgCgAEgASANOAJwIAFB+YXUgAU2AnwgAUIANwJ0C+cIAgZ/D30gAUKAgICAiICAgIB/NwIwIAFCADcCECABQoCAgIAINwI4IAFCADcCGCAAKAIQIgcgA0H0AWxqKALwASEAIAcgBEH0AWxqKALwASEGIAEgBDYClAEgASADNgKQASAFKAJYIQggAUEANgKEASABIAg2AmggAUIANwJgIAIqAgAhDCACKgIEIRUgAioCCCEOIAFBADYCDCABIA6MOAIIIAEgFYwiDTgCBCABIAyMIhY4AgBBACEFIAEgAAR/IAAqAqwCIA2UIAwgACoCqAKUkyAOIAAqArAClJMgACoCqASUvCEJIAAqApwCIA2UIAwgACoCmAKUkyAOIAAqAqAClJMgACoCpASUvCEKIAAqAowCIA2UIAwgACoCiAKUkyAOIAAqApAClJMgACoCoASUvAVBAAs2AkAgAUEANgJMIAEgCTYCSCABIAo2AkQgAioCACEPIAIqAgQhECACKgIIIREgASACKAIMNgIsIAEgETgCKCABIBA4AiQgASAPOAIgQQAhAiAGBEAgDyAGKgKoApQgECAGKgKsApSSIBEgBioCsAKUkiAGKgKoBJS8IQUgDyAGKgKIApQgECAGKgKMApSSIBEgBioCkAKUkiAGKgKgBJS8IQsgDyAGKgKYApQgECAGKgKcApSSIBEgBioCoAKUkiAGKgKkBJS8IQILIAEgCzYCUCABQQA2AlwgASAFNgJYIAEgAjYCVCAABEAgACoCrAIgDZQgDCAAKgKoApSTIA4gACoCsAKUkyETIAAqApwCIA2UIAwgACoCmAKUkyAOIAAqAqAClJMhFCAAKgKMAiANlCAMIAAqAogClJMgDiAAKgKQApSTIRILIAFDAACAPyAUIA2UIAwgEpSTIA4gE5STQwAAAACSIAYEfSAPIAYqAqgClCAQIAYqAqwClJIgESAGKgKwApSSIRcgDyAGKgKYApQgECAGKgKcApSSIBEgBioCoAKUkiEYIAYqAogCIA+UIAYqAowCIBCUkiAGKgKQAiARlJIFQwAAAAALIA+UIBggEJSSIBcgEZSSkpUiEzgCbEMAAAAAIQxDAAAAACENQwAAAAAhEiAABEAgByADQfQBbGoiACoCsAEgACoC0AGSQwAAAACUIAAqArQBIAAqAtQBkkMAAAAAlJIgACoCuAEgACoC2AGSQwAAAACUkiEMIAAqAsABIRIgACoCxAEhGSAAKgLIASENCyAIviEUIAwgEiAWlCAVIBmUkyAOIA2Uk5IhDgJ9IAZFBEBDAAAAgCEMQwAAAAAhDUMAAAAADAELIAcgBEH0AWxqIgAqArABIAAqAtABkkMAAACAlCAAKgK0ASAAKgLUAZJDAAAAgJSSIAAqArgBIAAqAtgBkkMAAACAlJIhDCAAKgLIASEaIAAqAsQBIQ0gACoCwAELIRIgASAINgJ8IAFDAAAAADgCdCABIBSMOAJ4IAEgE0MAAAAAIA4gDCARIBqUIBAgDZQgDyASlJKSkpKTlDgCcAuPCwICfxt9IAAoAhAiDCAEQfQBbGooAvABIQAgDCADQfQBbGooAvABIQsgASAENgKUASABIAM2ApABIAUoAlQhBSABQQA2AoQBIAEgBTYCaCABQgA3AmACQCALBEAgASACKQIANwIQIAEgAikCCDcCGCAGKgIIIREgBioCACESIAYqAgQhEyABQQA2AgwgASASIAEqAhQiFJQgEyABKgIQIhWUkyIeOAIIIAEgESAVlCASIAEqAhgiGJSTIhI4AgQgASATIBiUIBEgFJSTIhE4AgAgCyoCqAQhEyALKgKwAiEPIAsqAqgCIRAgCyoCrAIhDSALKgKkBCEbIAsqAqACIRwgCyoCmAIhHSALKgKcAiEOIAsqApACIRkgCyoCjAIhHyALKgKgBCEaIAsqAogCIRYgAUEANgJMIAEgGiARIBaUIBIgH5SSIB4gGZSSlCIZOAJAIAEgGyARIB2UIBIgDpSSIB4gHJSSlCIfOAJEIAEgEyARIBCUIBIgDZSSIB4gD5SSlCIaOAJIDAELIAFCADcCQCABQgA3AgAgAUIANwJIIAFCADcCCCABQgA3AhAgAUIANwIYCwJAIAAEQCACKgIAIQ8gAioCBCEQIAIqAgghDSABQQA2AjwgASANjCIbOAI4IAEgEIwiHDgCNCABIA+MIh04AjAgByoCCCEOIAcqAgQhFyAHKgIAIRYgAUEANgIsIAEgDyAXlCAQIBaUkyITOAIoIAEgDSAWlCAPIA6UkyIPOAIkIAEgECAOlCANIBeUkyIQOAIgIAAqApACIRcgACoCjAIhFiAAKgKkBCEOIAAqAqACISAgACoCmAIhISAAKgKcAiEiIAAqAqgEIQ0gACoCsAIhIyAAKgKoAiEkIAAqAqwCISUgACoCoAQhJiAAKgKIAiEnIAFBADYCXCABIA0gECAklCAPICWUkiATICOUkpQiDTgCWCABIA4gECAhlCAPICKUkiATICCUkpQiDjgCVCABICYgECAnlCAPIBaUkiATIBeUkpQiFzgCUAwBCyABQgA3AlAgAUIANwIgIAFCADcCWCABQgA3AiggAUIANwIwIAFCADcCOEMAAAAAIRNDAAAAACEPQwAAAAAhEEMAAAAAIRtDAAAAACEcQwAAAAAhHUMAAAAAIQ1DAAAAACEOCyABIAggCwR9IAsqAtgCIB8gBioCCCIIlCAaIAYqAgQiFpSTIAIqAgCUIBogBioCACIalCAIIBmUkyACKgIElJIgFiAZlCAfIBqUkyACKgIIlJKSBUMAAAAACyAABH0gACoC2AIgDSAHKgIEIgiUIA4gByoCCCIZlJMgAioCAJQgFyAZlCANIAcqAgAiDZSTIAIqAgSUkiAOIA2UIBcgCJSTIAIqAgiUkpIFQwAAAAALkpUiDTgCbAJ9IAtFBEBDAAAAACEIIBVDAAAAAJQgFEMAAAAAlJIgGEMAAAAAlJIhFEMAAAAAIRhDAAAAAAwBCyAMIANB9AFsaiICKgKwASACKgLQAZIgFZQgAioCtAEgAioC1AGSIBSUkiACKgK4ASACKgLYAZIgGJSSIRQgAioCwAEhGCACKgLIASEIIAIqAsQBCyEVIAW+IQ4gFCAYIBGUIBUgEpSSIAggHpSSkiEIAn0gAEUEQEMAAAAAIRIgHUMAAAAAlCAcQwAAAACUkiAbQwAAAACUkiERQwAAAAAhFUMAAAAADAELIAwgBEH0AWxqIgAqArABIAAqAtABkiAdlCAAKgK0ASAAKgLUAZIgHJSSIAAqArgBIAAqAtgBkiAblJIhESAAKgLAASEVIAAqAsgBIRIgACoCxAELIRQgASAFNgJ8IAEgCjgCdCABIA6MOAJ4IAEgDSAJIAggESAVIBCUIBQgD5SSIBIgE5SSkpKTlDgCcAu0BgEJfSABBH8gASgC7AFBHnRBH3UgAXEFQQALIQEgAEIANwJAIABCADcCkAEgAEIANwJYIABCADcCUCAAQgA3AkggAEIANwKYASAAQgA3AqABIABCADcCqAECQCABBEAgACABKQIENwIAIAAgASkCDDcCCCAAIAEpAhw3AhggACABKQIUNwIQIAAgASkCLDcCKCAAIAEpAiQ3AiAgACABKQI8NwI4IAAgASkCNDcCMCABKgLgAiEEIAEqAuQCIQUgASoC3AIhBiABKgLYAiEDIAAgATYC8AEgAEEANgKMASAAIAMgBZQ4AogBIAAgAyAElDgChAEgACADIAaUOAKAASAAIAEpAqgENwJoIAAgASkCoAQ3AmAgACABKQLkAjcCeCAAIAEpAtwCNwJwIAAgASkCwAI3ArgBIAAgASkCuAI3ArABIAAgASkC0AI3AsgBIAAgASkCyAI3AsABIAEqAqADIQQgASoCpAMhBSABKgKcAyEGIAEqAtgCIQMgAEEANgLcASAAIAMgBZQgApQ4AtgBIAAgAyAElCAClDgC1AEgACADIAaUIAKUOALQASABKgKYAiEGIAEqAqgCIQcgASoCjAIhCCABKgKcAiEJIAEqAqwCIQogASoCiAIhCyAAIAEqAqwDIgMgASoCkAKUIAEqArADIgQgASoCoAKUkiABKgK0AyIFIAEqArAClJIgApQ4AugBIAAgAyAIlCAEIAmUkiAFIAqUkiAClDgC5AEgACALIAOUIAYgBJSSIAcgBZSSIAKUOALgAQwBCyAAQgA3AgQgAEGAgID8AzYCACAAQgA3AiAgAEEANgLwASAAQgA3AoABIABCgICA/IOAgMA/NwJwIABCgICA/IOAgMA/NwJgIABCADcCsAEgAEIANwIMIABCADcCGCAAQYCAgPwDNgIUIABCADcCLCAAQYCAgPwDNgIoIABCADcCNCAAQQA2AjwgAEIANwKIASAAQoCAgPwDNwJ4IABCgICA/AM3AmggAEEANgLoASAAQgA3AuABIABCADcC2AEgAEIANwLQASAAQgA3AsgBIABCADcCwAEgAEIANwK4AQsgAEEANgLsAQspACAAENkEIgAEQEHs9wFB7PcBKAIAQQFqNgIAIABBkNIBKAIAEQAACwv4AwAgACABIAIQZBogASAAKAKoBDYCNCABIAAoAqwENgI4IAEgACgCsAQ2AjwgASAAKAK0BDYCQCABIAAoArgENgJEIAEgACgCvAQ2AkggASAAKALABDYCTCABIAAoAsQENgJQIAEgACgCyAQ2AlQgASAAKALMBDYCWCABIAAoAtAENgJcIAEgACgC1AQ2AmAgASAAKALYBDYCZCABIAAoAtwENgJoIAEgACgC4AQ2AmwgASAAKALkBDYCcCABIAAoAugENgJ0IAEgACgC7AQ2AnggASAAKALwBDYCfCABIAAoAvQENgKAASABIAAoAvgENgKEASABIAAoAvwENgKIASABIAAoAoAFNgKMASABIAAoAoQFNgKQASABIAAoAogFNgKUASABIAAoAowFNgKYASABIAAoApAFNgKcASABIAAoApQFNgKgASABIAAoApgFNgKkASABIAAoApwFNgKoASABIAAoAqAFNgKsASABIAAoAqQFNgKwASABIAAtAOAFNgK4ASABIAAtAOEFNgK8ASABIAAoAqwFNgLEASABIAAoAqgFNgLAASABIAAtAOQFNgK0ASABIABBsAVqIgIQ6gE4AsgBIAEgAhDrATgCzAEgASAAKAK4BTYC0AEgASAAKAK8BTYC1AEgASAAKALABTYC2AFB2MQACwUAQdwBC1oBAX0CQCACQQFqIgJBBksNAAJAIAJBAWsOBQEBAQEBAAsgAUF+aiIBQQJLDQACQAJAAkAgAUEBaw4CAgEACyAAKgL4BQ8LIAAqAvQFDwsgACoC8AUhAwsgAwuHAQACQCADQQFqIgNBBksNAAJAIANBAWsOBQEBAQEBAAsgAUF+aiIBQQJLDQACQAJAAkAgAUEBaw4CAgEACyAAIAI4AvgFIAAgACgC7AVBAnI2AuwFDwsgACACOAL0BSAAIAAoAuwFQQFyNgLsBQ8LIAAgAjgC8AUgACAAKALsBUEEcjYC7AULC00BAX8jAEEQayIDJAAgAyABOAIMIABBsAVqIANBDGoQtw4gACADKgIMIAAgACgCHEEEaiAAKAIgQQRqENICkyAClTgCqAUgA0EQaiQAC58QAgl/LH0gACoCkAUiFiADKgIoIhyUISwgACoC8AQiECADKgIgIheUIAAqAoAFIhEgAyoCJCIdlJIhLSAWIAMqAhgiHpQhLiAQIAMqAhAiH5QgESADKgIUIiCUkiEvIAAqAtAEIhIgAioCKCIPlCEwIAAqArAEIhogAioCICITlCAAKgLABCIbIAIqAiQiFJSSITEgACoCzAQiISAPlCEyIAAqAqwEIiIgE5QgACoCvAQiIyAUlJIhMyAAKgLIBCIkIA+UITQgACoCqAQiJSATlCAAKgK4BCImIBSUkiE1IBIgAioCGCIYlCE2IBogAioCECIVlCAbIAIqAhQiGZSSITcgFyAAKgKYBSIXlCAdIAAqApwFIh2UkiAcIAAqAqAFIhyUkiADKgI4kiEnIB8gF5QgICAdlJIgHiAclJIgAyoCNJIhHiATIAAqAtgEIh+UIBQgACoC3AQiIJSSIA8gACoC4AQiKJSSIAIqAjgiKZIhKiAVIB+UIBkgIJSSIBggKJSSIAIqAjQiD5IhKyADKgIAIjggEJQgAyoCBCIQIBGUkiE5IAMqAggiESAWlCE6IAIqAgAiEyAalCACKgIEIhQgG5SSIRogAioCCCIWIBKUIRsgAyoCMCA4IBeUIBAgHZSSIBEgHJSSkiEQIAIqAjAgEyAflCAUICCUkiAWICiUkpIhESABKAIYIQcCfyAHQQF0IAAtAOAFIgsNABogASgCCCIIQYCAgPwDNgIAIAggB0ECdEEEaiIGakGAgID8AzYCACAIIAdBA3RBCGoiCWpBgICA/AM2AgAgASgCECIIQYCAgPx7NgIAIAYgCGpBgICA/Hs2AgAgCCAJakGAgID8ezYCACACKgI4ISkgAioCNCEPIAdBAXQLIQkgAioCMCESQQAhCCABKAIMIgJBADYCDCACICogKZMiFzgCBCACQQA2AgAgAiArIA+TIg+MOAIIIAIgB0ECdCIKaiIGQQA2AgwgBiARIBKTIhI4AgggBkEANgIEIAYgF4w4AgAgAiAJQQJ0IglqIgZCADcCCCAGIBKMOAIEIAYgDzgCACADKgIwIQ8gAyoCOCESIAMqAjQhFyABKAIUIgNBADYCDCADQQA2AgAgAyAeIBeTIhc4AgggAyAnIBKTIhKMOAIEIAMgCmoiBkEANgIMIAYgECAPkyIPjDgCCCAGQQA2AgQgBiASOAIAIAMgCWoiBkIANwIIIAYgDzgCBCAGIBeMOAIAIAEqAgAgASoCBJQhDyABKAIcIQYgC0UEQCAGIA8gECARk5Q4AgAgBiAKaiAPIB4gK5OUOAIAIAYgB0EDdGogDyAnICqTlDgCAAsgAiAHQQxsIglqICUgE5QgJiAUlJIgJCAWlJIiEDgCACACIAlBCGoiC2ogNSA0kiIROAIAIAIgCUEEaiIMaiAlIBWUICYgGZSSICQgGJSSIhI4AgAgAiAHQQR0IgpqIBMgIpQgFCAjlJIgFiAhlJIiFjgCACACIApBBHIiDWogIiAVlCAjIBmUkiAhIBiUkiIVOAIAIAIgCkEIciIOaiAzIDKSIhk4AgAgAyAJaiAQjDgCACADIAtqIBGMOAIAIAMgDGogEow4AgAgAyAKaiAWjDgCACADIA1qIBWMOAIAIAMgDmogGYw4AgAgBiAJaiARIBogG5IiEyAvIC6SIhGUIDcgNpIiFCA5IDqSIhqUkyIblCAQIBQgLSAskiIQlCAxIDCSIhggEZSTIhGUIBIgGCAalCATIBCUkyIQlJKSIA+UOAIAIAYgCmogGSAblCAWIBGUIBUgEJSSkiAPlDgCAAJAIAAtAMwFRQRAQwAAAAAhGQwBC0EBQQIgACoCxAUgACoC3AWUIhlDAAAAAF4bIQgLAkAgCCAALQDhBSIJckUNACACIAdBBWwiB0ECdCIGaiATOAIAIAIgBkEIaiIKaiAYOAIAIAIgBkEEaiILaiAUOAIAIAMgCmogGIw4AgAgAyALaiAUjDgCACADIAZqIBOMOAIAIABBsAVqIgIQ6gEhDyACEOsBIRUgASgCHCIDIAZqQQA2AgAgAEH4BWogAUEEaiAAKALsBSICQQJxGyoCACEWAkAgCUUNACAIQQBHIA8gFVtxDQAgAkEEcQRAIAEoAiAgB0ECdGogACgC8AU2AgALIAAqAtgFIA8gFSAAKgKoBSAWIAEqAgCUELEBIRAgASgCHCIDIAdBAnQiAmoiBiAQIAAqAqgFlCAAKgLcBZQgBioCAJI4AgAgASgCJCACaiAAKgKsBYw4AgAgASgCKCACaiAAKAKsBTYCAAsgCEUNACADIAdBAnQiBmoiAiACKgIAIBkgFiABKgIAlJSSOAIAIAAtAOwFQQFxBEAgASgCICAGaiAAKAL0BTYCAAsCfSAPIBVbBEAgASgCJCAHQQJ0akH///97NgIAQ///f38MAQsgASgCJCAHQQJ0aiEDIAhBAUYEQCADQQA2AgBD//9/fwwBCyADQf///3s2AgBDAAAAAAshDyABKAIoIAdBAnRqIA84AgACQCAAKgLABSIVQwAAAABeQQFzDQAgEyAEKgIAlCAUIAQqAgSUkiAYIAQqAgiUkiATIAUqAgCUIBQgBSoCBJSSIBggBSoCCJSSkyEPIAhBAUYEQCAPQwAAAABdQQFzDQEgDyAVjJQiDyACKgIAXkEBcw0BIAIgDzgCAAwBCyAPQwAAAABeQQFzDQAgDyAVjJQiDyACKgIAXUEBcw0AIAIgDzgCAAsgAiAAKgK8BSACKgIAlDgCAAsLiBkCCX8yfSMAQUBqIgYkACAAKgLMBCETIAAqArwEIR4gACoCrAQhHyADKgI4ISkgAyoCNCEqIAAqApgFIRQgACoCnAUhFSAAKgKgBSEaIAIqAjghKyACKgI0ISwgACoC2AQhFyAAKgLcBCEdIAAqAuAEIRggAyoCJCEtIAMqAighLiACKgIkISAgAioCKCEiIAAqAvAEIRkgAyoCFCEhIAAqAoAFIRIgAyoCGCEvIAAqApAFIRYgACoCsAQhESACKgIUISMgACoCwAQhGyACKgIYISQgACoC0AQhHCABKAIYIQcgAyoCMCEwIAIqAjAhMSADKgIgITIgAioCICElIAMqAgghMyADKgIAITQgAyoCBCE4IAIqAgghJiACKgIAITUgAioCBCE2IAMqAhAhOSAAKAIgKgLYAiEnIAAoAhwqAtgCITogAioCECE3IAZBADYCPCAGIBEgJZQgGyAglJIgHCAilJIiOyAnIDogJ5IiD5VDAAAAPyAPQwAAAABeGyIPlCAZIDKUIBIgLZSSIBYgLpSSIjxDAACAPyAPkyIQlJIiKEMAAIA/ICggKJQgNSARlCA2IBuUkiAmIByUkiIoIA+UIDQgGZQgOCASlJIgMyAWlJIiPSAQlJIiPiA+lCARIDeUIBsgI5SSIBwgJJSSIj8gD5QgGSA5lCASICGUkiAWIC+UkiJAIBCUkiISIBKUkpKRlSIWlCIZOAI4IAYgEiAWlCISOAI0IAYgPiAWlCIWOAIwIAZBADYCHCAGIA8gKSAyIBSUIC0gFZSSIC4gGpSSkiItICmTIhEgGSARIBmUIDAgNCAUlCA4IBWUkiAzIBqUkpIiKSAwkyIRIBaUICogOSAUlCAhIBWUkiAvIBqUkpIiLiAqkyIVIBKUkpIiGpQiG5MiHJQgECArICUgF5QgICAdlJIgIiAYlJKSIiogK5MiFCAZIBQgGZQgMSA1IBeUIDYgHZSSICYgGJSSkiIrIDGTIiEgFpQgLCA3IBeUICMgHZSSICQgGJSSkiIvICyTIh0gEpSSkiIXlCIYkyIslJIiFDgCGCAGIA8gFSASIBqUIjCTIjGUIBAgHSASIBeUIh2TIjKUkiIVOAIUIAYgDyARIBYgGpQiEZMiM5QgECAhIBYgF5QiIZMiNJSSIho4AhAgHCAQIBggG5MiG5STIRcgMSAQIB0gMJMiHJSTIR0gMyAQICEgEZMiIZSTIRggLCAPIBuUkiERIDIgDyAclJIhGyA0IA8gIZSSIRwgOkMAAAA0XSAnQwAAADRdciECIAYCfSAUIBSUIBogGpQgFSAVlJKSIidDAAAANF5BAXNFBEAgBiAUQwAAgD8gJ5GVIhOUIhQ4AhggBiAVIBOUIhU4AhQgGiATlAwBCyAGQQA2AhwgBiAfICWUIB4gIJSSIBMgIpSSIhQ4AhggBiAfIDeUIB4gI5SSIBMgJJSSIhU4AhQgNSAflCA2IB6UkiAmIBOUkgsiEzgCECAGQQA2AgwgBiAWIBWUIBIgE5STIh44AgggBiAZIBOUIBYgFJSTIh84AgQgBiASIBSUIBkgFZSTIho4AgAgBiAcIBWUIBsgE5STOAIoIAYgESATlCAcIBSUkzgCJCAGIBsgFJQgESAVlJM4AiAgASgCDCIDIAYpAyA3AgAgAyAGKAIoNgIIIAEoAhQiAyAYIBWUIB0gE5STjDgCCCADIBcgE5QgGCAUlJOMOAIEIAMgHSAUlCAXIBWUk4w4AgAgBkEANgIsIAYgHCAflCAbIBqUkyIkOAIoIAYgESAalCAcIB6UkyIlOAIkIAYgGyAelCARIB+UkyImOAIgIBggH5QgHSAalJMhICAXIBqUIBggHpSTISIgHSAelCAXIB+UkyEjAkAgAkUNACAALQDMBUUNACAGIA8gJJQ4AiggBiAPICWUOAIkIAYgDyAmlDgCICAQICCUISAgECAilCEiIBAgI5QhIwsgB0ECdCIDIAEoAgxqIgggBikDIDcCACAIIAYoAig2AgggAyABKAIUIgNqICOMOAIAIAMgB0EBaiIIQQJ0aiAijDgCACADIAdBAmoiCkECdGogIIw4AgAgBiAcIBKUIBsgFpSTIiA4AiggBkEANgIsIAYgESAWlCAcIBmUkyIcOAIkIAYgGyAZlCARIBKUkyIbOAIgIBggEpQgHSAWlJMhESAXIBaUIBggGZSTIRggHSAZlCAXIBKUkyEXIAIEQCAGIA8gIJQ4AiggBiAPIByUOAIkIAYgDyAblDgCICAQIBGUIREgECAYlCEYIBAgF5QhFwsgB0EBdCIDQQJ0IgIgASgCDGoiCSAGKQMgNwIAIAkgBigCKDYCCCACIAEoAhQiAmogF4w4AgAgAiADQQFyIgtBAnRqIBiMOAIAIAIgA0ECaiIMQQJ0aiARjDgCAAJAIAAtAOAFBEAgHowhECAfjCEXIBqMIR0gE4whDyABKAIcIQgMAQsgASoCBCEYIAEqAgAhESABKAIIIgIgBikDEDcCACACIAYoAhg2AgggB0ECdCIJIAEoAghqIgIgBikDADcCACACIAYoAgg2AgggA0ECdCIDIAEoAghqIgIgBikDMDcCACACIAYoAjg2AgggASgCECICIBOMIg84AgAgAiAVjDgCBCACIBSMOAIIIAIgCWogGowiHTgCACACIAhBAnRqIB+MIhc4AgAgAiAKQQJ0aiAejCIQOAIAIAIgA2ogFow4AgAgAiALQQJ0aiASjDgCACACIAxBAnRqIBmMOAIAIAEoAhwiCCARIBiUIhggKSArkyIRIBOUIC4gL5MiGyAVlJIgLSAqkyIcIBSUkpQ4AgAgCCAJaiAYIBEgGpQgGyAflJIgHCAelJKUOAIAIAMgCGogGCARIBaUIBsgEpSSIBwgGZSSlDgCACABKAIUIQILIAEoAgwiAyAHQQxsIglqIBM4AgAgAyAJQQhqIgpqIBQ4AgAgAyAJQQRqIgtqIBU4AgAgAyAHQQR0IgdqIBo4AgAgAyAHQQRyIgxqIB84AgAgAyAHQQhyIg1qIB44AgAgAiAJaiAPOAIAIAIgC2ogBioCFCIPjDgCACACIApqIAYqAhgiGYw4AgAgAiAHaiAdOAIAIAIgDGogFzgCACACIA1qIBA4AgAgCCAJaiABKgIAIAEqAgSUIhAgPyA8lCA7IECUkyISIBOUIA8gOyA9lCAoIDyUkyIPlJIgGSAoIECUID8gPZSTIhOUkpQ4AgAgByAIaiAQIBIgGpQgDyAflJIgEyAelJKUOAIAAkAgAC0A4QUiCgJ/IAAtAMwFRQRAQwAAAAAhE0EADAELQQFBAiAAKgLEBSAAKgLcBZQiE0MAAAAAXhsLIgdyRQ0AIAMgASgCGEEFbCIIQQJ0IglqIAYoAjAiCzYCACADIAlBBGoiDGogBigCNCINNgIAIAMgCUEIaiIOaiAGKAI4IgM2AgAgAiAMaiANviIZjDgCACACIAlqIAu+IhKMOAIAIAIgDmogA74iFow4AgAgAEGwBWoiAhDqASEPIAIQ6wEhECABKAIcIgIgCWpBADYCACAAQfgFaiABQQRqIAAoAuwFIgNBAnEbKgIAIRQCQCAKRQ0AIAdBAEcgDyAQW3ENACADQQRxBEAgASgCICAIQQJ0aiAAKALwBTYCAAsgACoC2AUgDyAQIAAqAqgFIBQgASoCAJQQsQEhFSABKAIcIgIgCEECdCIDaiIJIBUgACoCqAWUIAAqAtwFlCAJKgIAkjgCACABKAIkIANqIAAqAqwFjDgCACABKAIoIANqIAAoAqwFNgIACyAHRQ0AIAIgCEECdCIDaiICIAIqAgAgEyAUIAEqAgCUlJI4AgAgAC0A7AVBAXEEQCABKAIgIANqIAAoAvQFNgIACwJ9IA8gEFsEQCABKAIkIAhBAnRqQf///3s2AgBD//9/fwwBCyABKAIkIAhBAnRqIQMgB0EBRgRAIANBADYCAEP//39/DAELIANB////ezYCAEMAAAAACyEPIAEoAiggCEECdGogDzgCAAJAIAAqAsAFIhBDAAAAAF5BAXMNACAEKgIAIBKUIAQqAgQgGZSSIAQqAgggFpSSIAUqAgAgEpQgBSoCBCAZlJIgBSoCCCAWlJKTIQ8gB0EBRgRAIA9DAAAAAF1BAXMNASAPIBCMlCIPIAIqAgBeQQFzDQEgAiAPOAIADAELIA9DAAAAAF5BAXMNACAPIBCMlCIPIAIqAgBdQQFzDQAgAiAPOAIACyACIAAqArwFIAIqAgCUOAIACyAGQUBrJAALVAEEfyAAKAIgIgJByAJqIQQgACgCHCIDQcgCaiEFIAJBBGohAiADQQRqIQMgAC0A4wUEQCAAIAEgAyACIAUgBBCcDg8LIAAgASADIAIgBSAEEJsOC3YBAX0gAC0A4gUEQCABQgA3AgAPCyABQoWAgIAQNwIAIAAgACAAKAIcQQRqIAAoAiBBBGoQ0gIiAjgC2AUgAEGwBWogAhDhBEEAIAAtAMwFRSAALQDhBRtFBEAgASABKAIAQQFqNgIAIAEgASgCBEF/ajYCBAsL0hkCBX8jfSMAQbABayIDJAAgAC0A4gUEQCAAQQA2AugFIABBADYCJAJAIAAtAOAFDQACQCAAKgKYBSIHIAAoAiAiASoCBJQgACoCnAUiCiABKgIIlJIgACoCoAUiCSABKgIMlJIgASoCNJIiECAAKgLYBCIGIAAoAhwiAioCBJQgACoC3AQiCCACKgIIlJIgACoC4AQiDSACKgIMlJIgAioCNJIiDJMiDiAOlCAHIAEqAhSUIAogASoCGJSSIAkgASoCHJSSIAEqAjiSIhQgBiACKgIUlCAIIAIqAhiUkiANIAIqAhyUkiACKgI4kiIVkyILIAuUkiAHIAEqAiSUIAogASoCKJSSIAkgASoCLJSSIAEqAjySIhogBiACKgIklCAIIAIqAiiUkiANIAIqAiyUkiACKgI8kiIbkyIHIAeUkiIKQwAAADReQQFzRQRAIANBADYCjAEgAyAHQwAAgD8gCpGVIgmUIgo4AogBIAMgCyAJlCIHOAKEASADIA4gCZQiCTgCgAEMAQsgA0IANwOIASADQoCAgPwDNwOAAUMAAIA/IQlDAAAAACEHQwAAAAAhCgsCQCAKi0PzBDU/XkEBc0UEQCAKIAqUIAcgB5SSIgZDAACAPyAGkZUiBpQhCCAJIAYgCoyUIg2UIQ4gByAGlCIKIAmMlCEHQwAAAAAhBgwBCyAJIAmUIAcgB5SSIgZDAACAPyAGkZUiCJQhDiAKIAggB4yUIgaUIQcgCSAIlCINIAqMlCEIQwAAAAAhCgsgAyAOOAKoASADIAc4AqQBIAMgCjgCmAEgAyANOAKUASADIAg4AqABIAMgBjgCkAEDQCADIAAoAhwiAigCBDYCUCADIAIoAhQ2AlQgAigCJCEEIANBADYCXCADIAQ2AlggAyACKAIINgJgIAMgAigCGDYCZCACKAIoIQQgA0EANgJsIAMgBDYCaCADIAIoAgw2AnAgAyACKAIcNgJ0IAIoAiwhBCADQQA2AnwgAyAENgJ4IAMgASgCBDYCICADIAEoAhQ2AiQgASgCJCEEIANBADYCLCADIAQ2AiggAyABKAIINgIwIAMgASgCGDYCNCABKAIoIQQgA0EANgI8IAMgBDYCOCADIAEoAgw2AkAgAyABKAIcNgJEIAEoAiwhBCADQQA2AkwgAyAENgJIIAIqAjQhByACKgI4IQogAioCPCEJIANBADYCHCADIBsgCZM4AhggAyAVIAqTOAIUIAMgDCAHkzgCECABKgI0IQcgASoCOCEKIAEqAjwhCSADQQA2AgwgAyAaIAmTOAIIIAMgFCAKkzgCBCADIBAgB5M4AgAgACAFQdQAbGpBMGogA0HQAGogA0EgaiADQRBqIAMgA0GAAWogBUEEdGogAkGMA2ogAioC2AIgAUGMA2ogASoC2AIQ7AEgBUEBaiIFQQNGDQEgACgCICEBDAAACwALIAAoAsAEIQEgACgCsAQhAgJ9IAAqAtAEIgqLQ/MENT9eQQFzRQRAIAogCpQgAb4iByAHlJIiCUMAAIA/IAmRlSIGlCENIAYgCoyUIgggAr4iCZQhDkMAAAAAIQwgBiAHlCILIAmMlAwBCyACviIJIAmUIAG+IgcgB5SSIgZDAACAPyAGkZUiBpQhDiAGIAmUIgggCoyUIQ1DAAAAACELIAogBiAHjJQiDJQLIRAgACgCICIBIgVBJGoqAgAhESABKgIUIRcgASoCKCESIAEqAhghGCABKgIIIRkgASoCLCETIAEqAhwhHCABKgIMIR0gACgCHCICIgRBLGoqAgAhFCACKgIkIRUgAioCKCEaIAIqAgwhGyACKgIIIR8gAioCHCEgIAIqAhQhISACKgIYISIgASoCBCEeIAIqAgQhIyAAQQA2AtgCIABBADYCyAIgAEIANwK0AiAAQgA3AqwCIAAgGyAMICOUIAggH5SSIAsgG5SSIgaUICAgDCAhlCAIICKUkiALICCUkiIPlJIgFCAMIBWUIAggGpSSIAsgFJSSIgiUkiILOALEAiAAIAYgH5QgDyAilJIgCCAalJIiDDgCwAIgACAGICOUIA8gIZSSIAggFZSSIhY4ArwCIAAgHCAPjCIPlCAGIB2UkyAIIBOUkyITOALUAiAAIBggD5QgBiAZlJMgCCASlJMiEjgC0AIgACAXIA+UIAYgHpSTIAggEZSTIgY4AswCIAIqApADIQggAioClAMhDyACKgKMAyERIABBADYC6AIgACALIA+UIg84AuQCIAAgDCAIlCIIOALgAiAAIBYgEZQiETgC3AIgASoCkAMhFyABKgKUAyEYIAEqAowDIRkgAEEANgL4AiAAIBMgGJQiGDgC9AIgACASIBeUIhc4AvACIAAgBiAZlCIZOALsAiAAIBYgEZQgDCAIlJIgCyAPlJIgBiAZlCASIBeUkiATIBiUkpI4AvwCIAIqAiQhFiACKgIUIRMgAioCKCEPIAIqAgghEiACKgIYIREgBCoCLCEXIAIqAgwhGCACKgIcIRkgBSoCJCEcIAEqAhQhHSABKgIoIR4gASoCGCEkIAEqAgghJSABKgIsIQggASoCHCEGIAEqAgwhJiACKgIEIScgASoCBCEoIABBADYCrAMgAEEANgKcAyAAQgA3AogDIABCADcCgAMgACAGIA0gIZQgECAilJIgDiAglJIiC4wiDJQgJiANICOUIBAgH5SSIA4gG5SSIgaUkyAIIA0gFZQgECAalJIgDiAUlJIiCJSTIg04AqgDIAAgJCAMlCAGICWUkyAIIB6UkyIOOAKkAyAAIB0gDJQgBiAolJMgCCAclJMiEDgCoAMgACAGIBiUIAsgGZSSIAggF5SSIgw4ApgDIAAgBiASlCALIBGUkiAIIA+UkiIPOAKUAyAAIAYgJ5QgCyATlJIgCCAWlJIiBjgCkAMgAioCkAMhCCACKgKUAyELIAIqAowDIRYgAEEANgK8AyAAIAwgC5QiCzgCuAMgACAPIAiUIgg4ArQDIAAgBiAWlCIWOAKwAyABKgKQAyETIAEqApQDIRIgASoCjAMhESAAQQA2AswDIAAgDSASlCISOALIAyAAIA4gE5QiEzgCxAMgACAQIBGUIhE4AsADIAAgBiAWlCAPIAiUkiAMIAuUkiAQIBGUIA4gE5SSIA0gEpSSkjgC0AMgAioCJCEQIAIqAhQhDCACKgIoIQsgAioCCCEPIAIqAhghFiAEKgIsIQ4gAioCDCETIAIqAhwhEiAFKgIkIREgASoCFCEXIAEqAighGCABKgIYIRkgASoCCCEcIAEqAiwhHSABKgIcIQYgASoCDCEeIAIqAgQhJCABKgIEISUgAEEANgKABCAAQQA2AvADIABCADcC3AMgAEIANwLUAyAAIAYgISAJlCAiIAeUkiAKICCUkiIIjCINlCAeICMgCZQgHyAHlJIgCiAblJIiBpSTIB0gFSAJlCAaIAeUkiAKIBSUkiIHlJMiCjgC/AMgACAZIA2UIAYgHJSTIAcgGJSTIgk4AvgDIAAgFyANlCAGICWUkyAHIBGUkyINOAL0AyAAIAYgE5QgCCASlJIgByAOlJIiDjgC7AMgACAGIA+UIAggFpSSIAcgC5SSIgs4AugDIAAgBiAklCAIIAyUkiAHIBCUkiIHOALkAyACKgKQAyEGIAIqApQDIQggAioCjAMhECAAQQA2ApAEIAAgDiAIlCIIOAKMBCAAIAsgBpQiBjgCiAQgACAHIBCUIhA4AoQEIAEqApADIQwgASoClAMhFCABKgKMAyEVIABBADYC1AUgAEEANgKgBCAAIAogFJQiFDgCnAQgACAJIAyUIgw4ApgEIAAgDSAVlCIVOAKUBCAAIAcgEJQgCyAGlJIgDiAIlJIgDSAVlCAJIAyUkiAKIBSUkpI4AqQEIAAgACACQQRqIAFBBGoQ0gIiBzgC2AUgAEGwBWogBxDhBCAAQwAAgD8gACoCsAQiCSAAKAIcIgEqAgSUIAAqAsAEIgYgASoCCJSSIAAqAtAEIgggASoCDJSSIgcgByABKgKIApQgCSABKgIUlCAGIAEqAhiUkiAIIAEqAhyUkiIKIAEqApgClJIgCSABKgIklCAGIAEqAiiUkiAIIAEqAiyUkiIJIAEqAqgClJKUIAogByABKgKMApQgCiABKgKcApSSIAkgASoCrAKUkpSSIAkgByABKgKQApQgCiABKgKgApSSIAkgASoCsAKUkpSSIAcgByAAKAIgIgAqAogClCAKIAAqApgClJIgCSAAKgKoApSSlCAKIAcgACoCjAKUIAogACoCnAKUkiAJIAAqAqwClJKUkiAJIAcgACoCkAKUIAogACoCoAKUkiAJIAAqArAClJKUkpKVOALQBQsgA0GwAWokAAvQAwAgACABIAIQZBogASAAKAKsAjYCNCABIAAoArACNgI4IAEgACgCtAI2AjwgASAAKAK4AjYCQCABIAAoArwCNgJEIAEgACgCwAI2AkggASAAKALEAjYCTCABIAAoAsgCNgJQIAEgACgCzAI2AlQgASAAKALQAjYCWCABIAAoAtQCNgJcIAEgACgC2AI2AmAgASAAKALcAjYCZCABIAAoAuACNgJoIAEgACgC5AI2AmwgASAAKALoAjYCcCABIAAoAuwCNgJ0IAEgACgC8AI2AnggASAAKAL0AjYCfCABIAAoAvgCNgKAASABIAAoAvwCNgKEASABIAAoAoADNgKIASABIAAoAoQDNgKMASABIAAoAogDNgKQASABIAAoAowDNgKUASABIAAoApADNgKYASABIAAoApQDNgKcASABIAAoApgDNgKgASABIAAoApwDNgKkASABIAAoAqADNgKoASABIAAoAqQDNgKsASABIAAoAqgDNgKwASABIAAoArwDNgK0ASABIAAoAsADNgK4ASABIAAoAsQDNgK8ASABIAAoAqwDNgLAASABIAAoArADNgLEASABIAAoArQDNgLIASABIAAoArgDNgLMAUHowwALBQBB1AELvwEAIAAgASkCADcCrAIgACABKQIINwK0AiAAIAEpAhg3AsQCIAAgASkCEDcCvAIgACABKQIoNwLUAiAAIAEpAiA3AswCIAAgASkCODcC5AIgACABKQIwNwLcAiAAIAIpAgg3AvQCIAAgAikCADcC7AIgACACKQIQNwL8AiAAIAIpAhg3AoQDIAAgAikCIDcCjAMgACACKQIoNwKUAyAAIAIpAjg3AqQDIAAgAikCMDcCnAMgACAAKAIAKAIIEQAAC2YBAX0CQCABQX9qIgFBA0sNAAJAAkAgAUECaw4CAQEACyACQQJNBEAgACoC2AQPCyACQX1qQQJLDQEgACoCsAMPCyACQQJNBEAgACoC1AQPCyACQX1qQQJLDQAgACoC3AQhAwsgAwt/ACABQX9qIgFBA00EQAJAAkAgAUECaw4CAQEACyADQQJNBEAgACACOALYBCAAIAAoAtAEQQJyNgLQBA8LIAAgAjgCsAMPCyADQQJNBEAgACACOALUBCAAIAAoAtAEQQFyNgLQBA8LIAAgAjgC3AQgACAAKALQBEEEcjYC0AQLC88CAgF/Dn0jAEEwayICJAAgAEHsAmogAkEQahAmIAEqAgQhAyABKgIIIQQgASoCACEFIAEqAgwhBiACKgIYIQcgAioCFCEIIAIqAhwhCSACKgIQIQogAEGsAmogAhAmIAIgByAElCAKIAWUIAkgBpSSIAggA5SSkiILIAIqAgwiDJQgCSAFlCAKIAaUkyAIIASUkyAHIAOUkiINIAIqAgAiDpSTIAogBJQgCSADlCAIIAaUkyAHIAWUk5IiDyACKgIEIhCUkyAIIAWUIAkgBJQgByAGlJMgCiADlJOSIgMgAioCCCIElJM4AiwgAiADIAyUIAsgBJSSIA0gEJSSIA4gD5STOAIoIAIgDiADlCAMIA+UIAsgEJSSkiANIASUkzgCJCACIAsgDpQgDSAMlJIgDyAElJIgAyAQlJM4AiAgACACQSBqEN8EIAJBMGokAAuxPgIHfy59IwBB0ANrIgQkAAJAIAAtAI8ERQ0AIAAoAiAhBSAAKAIcIQYgAC0AjARFBEAgASoCuAEgASoCSJIgACoC3AIiCyAGKgIUlCAAKgLgAiIMIAYqAhiUkiAAKgLkAiINIAYqAhyUkiAGKgI4Ig6SIhMgDpMiDyABKgLAASABKgJQkiIWlCALIAYqAgSUIAwgBioCCJSSIA0gBioCDJSSIAYqAjQiDpIiGCAOkyIRIAEqAsQBIAEqAlSSIhmUk5IgAioCuAEgAioCSJIgACoCnAMiDiAFKgIUlCAAKgKgAyIVIAUqAhiUkiAAKgKkAyIQIAUqAhyUkiAFKgI4IhKSIhogEpMiEiACKgLAASACKgJQkiIblCAOIAUqAgSUIBUgBSoCCJSSIBAgBSoCDJSSIAUqAjQiFJIiHCAUkyIUIAIqAsQBIAIqAlSSIh6Uk5KTIR8gASoCtAEgASoCRJIgESABKgLIASABKgJYkiIglCALIAYqAiSUIAwgBioCKJSSIA0gBioCLJSSIAYqAjwiC5IiDCALkyIXIBaUk5IgAioCtAEgAioCRJIgFCACKgLIASACKgJYkiILlCAOIAUqAiSUIBUgBSoCKJSSIBAgBSoCLJSSIAUqAjwiDZIiDiANkyIVIBuUk5KTIRsgASoCsAEgASoCQJIgFyAZlCAPICCUk5IgAioCsAEgAioCQJIgFSAelCASIAuUk5KTIRkgDCAOkyEeIBMgGpMhGiAYIByTIRggAigC8AEhCSABKALwASEKA0AgACAAKgIkQwAAgD8gACAIQdQAbGoiByoCgAGVIgsgGCAHKgIwIgyUIBogByoCNCINlJIgHiAHKgI4Ig6UkkOamZm+lCADlZQgCyAZIAyUIBsgDZSSIB8gDpSSlJMiC5I4AiQgByoCMCEMIAcqAjQhDSAHKgI4IQ4gCgRAIAYqArACIRwgBioCqAIhICAGKgKsAiEhIAYqAqACISIgBioCmAIhJCAGKgKcAiEdIAYqApACIRYgBioCiAIhEyAGKgKMAiEjIAEgCyAMIAYqAtgCIhCUlCABKgJwlCABKgJAkjgCQCABIAsgDSAQlJQgASoCdJQgASoCRJI4AkQgASALIA4gEJSUIAEqAniUIAEqAkiSOAJIIAEgEyAPIA6UIBcgDZSTIhCUICMgFyAMlCARIA6UkyITlJIgFiARIA2UIA8gDJSTIhaUkiALIAEqAmCUlCABKgJQkjgCUCABKgJoISMgASAQICSUIBMgHZSSIBYgIpSSIAsgASoCZJSUIAEqAlSSOAJUIAEgECAglCATICGUkiAWIByUkiALICOUlCABKgJYkjgCWAsgCQRAIAUqArACIRMgBSoCqAIhFiAFKgKsAiEcIAUqAqACISAgBSoCmAIhISAFKgKcAiEiIAUqApACISQgBSoCiAIhHSAFKgKMAiEjIAcqAjghKSAHKgI0ISogAiACKgJwIAUqAtgCIhAgByoCMJQgC4wiC5SUIAIqAkCSOAJAIAIgECAqlCALlCACKgJ0lCACKgJEkjgCRCACIBAgKZQgC5QgAioCeJQgAioCSJI4AkggAiAdIBIgDpQgFSANlJMiEJQgIyAVIAyUIBQgDpSTIg6UkiAkIBQgDZQgEiAMlJMiDJSSIAIqAmAgC5SUIAIqAlCSOAJQIAIqAmghDSACIBAgIZQgDiAilJIgDCAglJIgAioCZCALlJQgAioCVJI4AlQgAiAQIBaUIA4gHJSSIAwgE5SSIA0gC5SUIAIqAliSOAJYCyAIQQFqIghBA0cNAAsLAkAgAC0AqAQEQCAEIAYpAgw3A4ADIAQgBikCBDcD+AIgBCAGKQIcNwOQAyAEIAYpAhQ3A4gDIAQgBikCLDcDoAMgBCAGKQIkNwOYAyAEIAYpAjw3A7ADIAQgBikCNDcDqAMgBCAFKQIMNwPAAiAEIAUpAgQ3A7gCIAQgBSkCHDcD0AIgBCAFKQIUNwPIAiAEIAUpAiw3A+ACIAQgBSkCJDcD2AIgBCAFKQI8NwPwAiAEIAUpAjQ3A+gCIAEqAlQhCyABKgLEASEMIAEqAlghDSABKgLIASEOIAEqAlAhDyABKgLAASERIARBADYCtAIgBCAOIA2SOAKwAiAEIAwgC5I4AqwCIAQgESAPkjgCqAIgAioCVCELIAIqAsQBIQwgAioCWCENIAIqAsgBIQ4gAioCUCEPIAIqAsABIREgBEEANgKkAiAEIA4gDZI4AqACIAQgDCALkjgCnAIgBCARIA+SOAKYAiAEQgA3AuQBIARCADcD8AEgBEGAgID8AzYC7AEgBEIANwKEAiAEQYCAgPwDNgKAAiAEQgA3AowCIARBADYClAIgBEIANwLcASAEQYCAgPwDNgLYASAEQgA3A/gBIARCADcD0AEgBEIANwPIASAEQfgCaiAEQcgBaiAEQagCaiADIARB2AFqEFUgBEIANwKUASAEQgA3A6ABIARBgICA/AM2ApwBIARCADcCtAEgBEGAgID8AzYCsAEgBEIANwK8ASAEQQA2AsQBIARCADcCjAEgBEGAgID8AzYCiAEgBEIANwOoASAEQbgCaiAEQcgBaiAEQZgCaiADIARBiAFqEFUgACoCtAIhFyAAKgKwAiETIAAqAsQCIQ4gACoCvAIhDyAAKgLAAiEVIAAqApQDIRAgACoCkAMhFiAAKgKMAyEYIAAqAvQCIRkgACoC8AIhGiAAKgLUAiEbIAAqAswCIRwgACoC0AIhHiAAKgKEAyEfIAAqAoADISAgACoC/AIhISAAKgK4BCEMIAAqArQEIREgACoCsAQhDSAAKgKkAyE1IAAqApwDITYgACoCoAMhNyAAKgKsAiEiIAAqAuQCISMgACoC4AIhOCAAKgLcAiEpIAAqAuwCISQgACoCrAQhCyAEQQA2AoQBIARBADYCdCAEQQA2AmQgBCAcIBkgCyARQwAAAEAgCyALlCANIA2UkiARIBGUkiAMIAyUkpUiFJQiEpQiKyAMIA0gFJQiHZQiLJMiJZQgGiALIB2UIi0gDCASlCIukiImlCAkQwAAgD8gDSAdlCIvIBEgEpQiHZKTIhGUkpIiKpQgHiAZIA0gEpQiMCAMIAsgFJQiDJQiMZIiDZQgJCAtIC6TIhKUIBpDAACAPyALIAyUIgsgHZKTIhSUkpIiLZSSIBsgJCArICySIh2UIBogMCAxkyInlJIgGUMAAIA/IAsgL5KTIiiUkiIrlJIiCyAEKgKoASIslCAcICUgH5QgICAmlCAhIBGUkpIiLpQgHiANIB+UICEgEpQgICAUlJKSIi+UkiAbICEgHZQgICAnlJIgHyAolJIiMJSSIgwgBCoCrAEiMZSSIBwgESAYlCAmIBaUkiAlIBCUkiIllCAeIBIgGJQgFCAWlJIgDSAQlJIiJpSSIBsgHSAYlCAnIBaUkiAoIBCUkiInlJIiDSAEKgKwASIolJI4AnAgBCAsICogD5QgLSAVlJIgKyAOlJIiEZQgMSAuIA+UIC8gFZSSIDAgDpSSIhSUkiAoICUgD5QgJiAVlJIgJyAOlJIiEpSSOAJsIAQgCyAEKgKYASIylCAMIAQqApwBIjOUkiANIAQqAqABIjSUkjgCYCAEIBEgMpQgFCAzlJIgEiA0lJI4AlxDAAAAACEdIAQgLCA2ICRDAAAAAJQgGkMAAAAAlJIgGUMAAAAAlJKSICsgDiA4jCIOlCAXICmUkyAbICOUkyIalCAqIA8gDpQgIiAplJMgHCAjlJMiD5QgLSAVIA6UIBMgKZSTIB4gI5STIg6UkpKSIhWUIDEgNyAhQwAAAACUICBDAAAAAJSSIB9DAAAAAJSSkiAwIBqUIC4gD5QgLyAOlJKSkiIZlJIgKCA1IBhDAAAAAJQgFkMAAAAAlJIgEEMAAAAAlJKSICcgGpQgJSAPlCAmIA6UkpKSIhCUkiAEKgLAAZIiIDgCgAEgBCAyIBWUIBkgM5SSIBAgNJSSIAQqArwBkiIhOAJ8IARBADYCVCAEICwgKiAilCAtIBOUkiArIBeUkiIPlCAxIC4gIpQgLyATlJIgMCAXlJIiDpSSICggJSAilCAmIBOUkiAnIBeUkiIXlJI4AmggBCAPIDKUIA4gM5SSIBcgNJSSOAJYIAQgCyAEKgKIASITlCAMIAQqAowBIhaUkiANIAQqApABIhiUkjgCUCAEIBEgE5QgFCAWlJIgEiAYlJI4AkwgBCAPIBOUIA4gFpSSIBcgGJSSOAJIIAQgGCAQlCATIBWUIBYgGZSSkiAEKgK4AZIiIjgCeCAEQQA2AkQgBEEANgI0IARBADYCJCAEIBcgBCoC+AEiE5QgEiAEKgL8ASIWlJIgDSAEKgKAAiIYlJI4AjAgBCAOIBOUIBQgFpSSIAwgGJSSOAIsIAQgFyAEKgLoASIalCASIAQqAuwBIhuUkiANIAQqAvABIhyUkjgCICAEIA4gGpQgFCAblJIgDCAclJI4AhwgBEFAayATIA4gGYwiGZQgDyAVlJMgFyAQlJMiHpQgFiAUIBmUIBEgFZSTIBIgEJSTIh+UkiAYIAwgGZQgCyAVlJMgDSAQlJMiFZSSIAQqApACkiIQOAIAIAQgHiAalCAfIBuUkiAVIByUkiAEKgKMApIiGTgCPCAEQQA2AhQgBCAPIBOUIBEgFpSSIAsgGJSSOAIoIAQgDyAalCARIBuUkiALIByUkjgCGCAEIBcgBCoC2AEiF5QgEiAEKgLcASISlJIgDSAEKgLgASINlJI4AhAgBCAOIBeUIBQgEpSSIAwgDZSSOAIMIAQgDyAXlCARIBKUkiALIA2UkjgCCCAEIB4gF5QgHyASlJIgFSANlJIgBCoCiAKSIgs4AjggBEEANgLUASAEQwAAgD8gA5UiESAgIAQqArADk5Q4AtABIAQgESAiIAQqAqgDk5Q4AsgBIAQgESAhIAQqAqwDk5Q4AswBIARB+AJqIARByABqIARBwANqIARBvANqEGYgBEEANgLUASAEIBEgECAEKgLwApOUOALQASAEIBEgGSAEKgLsApOUOALMASAEIBEgCyAEKgLoApOUOALIASAEKgLEAyEUIAQqArwDIQwgBCoCyAMhCyAEKgLAAyEVIARBuAJqIARBCGogBEHAA2ogBEG8A2oQZiARIAQqArwDIhggBCoCyAOUlCAEKgKgApMhF0MAAAAAIQ0gESAVIAyUlCAEKgKoApMiFSAVlCARIAwgFJSUIAQqAqwCkyIQIBCUkiARIAwgC5SUIAQqArACkyITIBOUkiILQwAAADReQQFzRQRAIBVDAACAPyALkZUiC5QiDyAPIAAoAhwiBSoCiAKUIBAgC5QiDiAFKgKYApSSIBMgC5QiEiAFKgKoApSSlCAOIA8gBSoCjAKUIA4gBSoCnAKUkiASIAUqAqwClJKUkiASIA8gBSoCkAKUIA4gBSoCoAKUkiASIAUqArAClJKUkiENCyARIAQqAsADIBiUlCAEKgKYApMiFiAWlCARIBggBCoCxAOUlCAEKgKcApMiESARlJIgFyAXlJIiGEMAAAA0XkEBc0UEQCAWQwAAgD8gGJGVIhSUIgsgCyAAKAIgIgUqAogClCARIBSUIgwgBSoCmAKUkiAXIBSUIhQgBSoCqAKUkpQgDCALIAUqAowClCAMIAUqApwClJIgFCAFKgKsApSSlJIgFCALIAUqApAClCAMIAUqAqAClJIgFCAFKgKwApSSlJIhHQsgDSAPlCAdIAuUkiILIAuUIA0gDpQgHSAMlJIiDCAMlJIgDSASlCAdIBSUkiINIA2UkiIOQwAAADReQQFzDQEgEyALQwAAgD8gDpGVIg6UIgsgCyAAKAIcIgUqAogClCAMIA6UIgwgBSoCmAKUkiANIA6UIg0gBSoCqAKUkpQgDCALIAUqAowClCAMIAUqApwClJIgDSAFKgKsApSSlJIgDSALIAUqApAClCAMIAUqAqAClJIgDSAFKgKwApSSlJIiD5QgFyALIAsgACgCICIGKgKIApQgDCAGKgKYApSSIA0gBioCqAKUkpQgDCALIAYqAowClCAMIAYqApwClJIgDSAGKgKsApSSlJIgDSALIAYqApAClCAMIAYqAqAClJIgDSAGKgKwApSSlJIiDJSTQwAAgD8gDyAMkiILIAuUlSIOlCELIBAgD5QgESAMlJMgDpQhDSAVIA+UIBYgDJSTIA6UIQwgACoCvAQiFEMAAAAAYEEBc0UEQCAMIAAqAsAEIheSIhEgEZQgDSAAKgLEBCIVkiISIBKUkiALIAAqAsgEIhCSIg4gDpSSkSITIBQgD5UgFCAALQCpBBsiD15BAXNFBEAgECAPIA5DAACAPyATlSIMlJQgEJMiC5IhDiAVIA8gEiAMlJQgFZMiDZIhEiAXIA8gESAMlJQgF5MiDJIhEQsgACAOOALIBCAAIBI4AsQEIAAgETgCwAQLIAtDAACAPyAMIAyUIA0gDZSSIAsgC5SSkSILlSIPlCEOIA0gD5QhDSAMIA+UIQwgASgC8AEEQCAFKgKwAiERIAUqAqgCIRIgBSoCrAIhFCAFKgKgAiEXIAUqApgCIRUgBSoCnAIhECAFKgKQAiETIAUqAogCIRYgBSoCjAIhGCABIAtDAAAAAJQiDyABKgJwlCABKgJAkjgCQCABIA8gASoCdJQgASoCRJI4AkQgASAPIAEqAniUIAEqAkiSOAJIIAEgDCAWlCANIBiUkiAOIBOUkiALIAEqAmCUlCABKgJQkjgCUCABKgJoIQ8gASAMIBWUIA0gEJSSIA4gF5SSIAsgASoCZJSUIAEqAlSSOAJUIAEgDCASlCANIBSUkiAOIBGUkiALIA+UlCABKgJYkjgCWAsgAigC8AFFDQEgBioCsAIhESAGKgKoAiESIAYqAqwCIRQgBioCoAIhFyAGKgKYAiEVIAYqApwCIRAgBioCkAIhEyAGKgKIAiEWIAYqAowCIRggAiALQwAAAICUIg8gAioCcJQgAioCQJI4AkAgAiAPIAIqAnSUIAIqAkSSOAJEIAIgDyACKgJ4lCACKgJIkjgCSCACIAwgFpQgDSAYlJIgDiATlJIgAioCYCALjCILlJQgAioCUJI4AlAgAioCaCEPIAIgDCAVlCANIBCUkiAOIBeUkiACKgJkIAuUlCACKgJUkjgCVCACIAwgEpQgDSAUlJIgDiARlJIgDyALlJQgAioCWJI4AlgMAQsgACoCuAMiC0MAAAA0XkEBcw0AIAIqAsABIAIqAlCSIAEqAsABIAEqAlAiEpKTIg4gDpQgAioCxAEgAioCVJIgASoCxAEgASoCVCIUkpMiDyAPlJIgAioCyAEgAioCWJIgASoCyAEgASoCWCIXkpMiDSANlJIiDEMAAAA0XkEBcw0AIA0gC0MAAIA/IA5DAACAPyAMkZUiEZQiCyALIAYqAogCIhWUIA8gEZQiDCAGKgKYAiIQlJIgDSARlCINIAYqAqgCIhGUkpQgDCALIAYqAowCIhOUIAwgBioCnAIiFpSSIA0gBioCrAIiGJSSlJIgDSALIAYqApACIhmUIAwgBioCoAIiGpSSIA0gBioCsAIiG5SSlJIgCyALIAUqAogClCAMIAUqApgClJIgDSAFKgKoApSSlCAMIAsgBSoCjAKUIAwgBSoCnAKUkiANIAUqAqwClJKUkiANIAsgBSoCkAKUIAwgBSoCoAKUkiANIAUqArAClJKUkpKVlCILlCIMQwAAgD8gDCAMlCAOIAuUIg4gDpQgDyALlCINIA2UkpKRIguVIg+UIQwgDSAPlCENIA4gD5QhDiABKALwAQRAIAEgC0MAAAAAlCIPIAEqAnCUIAEqAkCSOAJAIAEgDyABKgJ0lCABKgJEkjgCRCABIA8gASoCeJQgASoCSJI4AkggASAXIA4gEZQgDSAYlJIgDCAblJIgCyABKgJolJSSOAJYIAEgFCAOIBCUIA0gFpSSIAwgGpSSIAsgASoCZJSUkjgCVCABIBIgDiAVlCANIBOUkiAMIBmUkiALIAEqAmCUlJI4AlALIAIoAvABRQ0AIAUqArACIREgBSoCqAIhEiAFKgKsAiEUIAUqAqACIRcgBSoCmAIhFSAFKgKcAiEQIAUqApACIRMgBSoCiAIhFiAFKgKMAiEYIAIgC0MAAACAlCIPIAIqAnCUIAIqAkCSOAJAIAIgDyACKgJ0lCACKgJEkjgCRCACIA8gAioCeJQgAioCSJI4AkggAiAOIBaUIA0gGJSSIAwgE5SSIAIqAmAgC4wiC5SUIAIqAlCSOAJQIAIqAmghDyACIA4gFZQgDSAQlJIgDCAXlJIgAioCZCALlJQgAioCVJI4AlQgAiAOIBKUIA0gFJSSIAwgEZSSIA8gC5SUIAIqAliSOAJYCyACKgLIASACKgJYkiEPIAIqAsQBIAIqAlSSIREgASoCyAEgASoCWJIhEiABKgLEASABKgJUkiEUIAIqAsABIAIqAlCSIRcgASoCwAEgASoCUJIhFQJAIAAtAI4ERQ0AIAAqApAEIgwgACoC+AOUIAAqArADlCADlSELIBcgFZMgACoCzAMiDZQgESAUkyAAKgLQAyIOlJIgDyASkyAAKgLUAyIQlJIiE0MAAAAAXkEBc0UEQCALIAwgE5QgACoCtAOUkiELCyAEIAAqAoQEIgwgCyAAKgLsA5SSIgs4AvgCIARBADYCuAIgACAEQfgCaiAEQbgCaiALQwAAAABeGygCACIFNgKEBCAQIAW+IAyTIguUIgwgACoCoAQiECANIAuUIg0gACoCmAQiE5QgDiALlCIWIAAqApwEIhiUkiAMIBCUkiILlJMiDEMAAIA/IAwgDJQgDSATIAuUkyIOIA6UIBYgGCALlJMiDSANlJKSkSILlSIQlCEMIA0gEJQhDSAOIBCUIQ4gASgC8AEEQCAAKAIcIgUqArACIRMgBSoCqAIhFiAFKgKsAiEYIAUqAqACIRkgBSoCmAIhGiAFKgKcAiEbIAUqApACIRwgBSoCjAIhHiAFKgKIAiEfIAEgC0MAAAAAlCIQIAEqAnCUIAEqAkCSOAJAIAEgECABKgJ0lCABKgJEkjgCRCABIBAgASoCeJQgASoCSJI4AkggASAOIB+UIA0gHpSSIAwgHJSSIAsgASoCYJSUIAEqAlCSOAJQIAEqAmghECABIA4gGpQgDSAblJIgDCAZlJIgCyABKgJklJQgASoCVJI4AlQgASAOIBaUIA0gGJSSIAwgE5SSIAsgEJSUIAEqAliSOAJYCyACKALwAUUNACAAKAIgIgUqArACIRMgBSoCqAIhFiAFKgKsAiEYIAUqAqACIRkgBSoCmAIhGiAFKgKcAiEbIAUqApACIRwgBSoCjAIhHiAFKgKIAiEfIAIgC0MAAACAlCIQIAIqAnCUIAIqAkCSOAJAIAIgECACKgJ0lCACKgJEkjgCRCACIBAgAioCeJQgAioCSJI4AkggAiAOIB+UIA0gHpSSIAwgHJSSIAIqAmAgC4wiC5SUIAIqAlCSOAJQIAIqAmghECACIA4gGpQgDSAblJIgDCAZlJIgAioCZCALlJQgAioCVJI4AlQgAiAOIBaUIA0gGJSSIAwgE5SSIBAgC5SUIAIqAliSOAJYCyAALQCNBEUNACAAKgKUBCIOIAAqAvwDlCAAKgKwA5QgA5UhAyAXIBWTIAAqAtwDIguUIBEgFJMgACoC4AMiDZSSIA8gEpMgACoC5AMiDJSSIg9DAAAAAF5BAXNFBEAgAyAOIA+UIAAqArQDlJIhAwsgBCAAKgKIBCIOIAMgACoC8AOUkiIDOAL4AiAEQQA2ArgCIAAgBEH4AmogBEG4AmogA0MAAAAAXhsoAgAiBTYCiAQgBb4gDpMhAyABKALwAQRAIAAoAhwiBSoCsAIhDyAFKgKoAiERIAUqAqwCIRIgBSoCoAIhFCAFKgKYAiEXIAUqApwCIRUgBSoCkAIhECAFKgKMAiETIAUqAogCIRYgASADQwAAAACUIg4gASoCcJQgASoCQJI4AkAgASAOIAEqAnSUIAEqAkSSOAJEIAEgDiABKgJ4lCABKgJIkjgCSCABIAsgFpQgDSATlJIgDCAQlJIgAyABKgJglJQgASoCUJI4AlAgASoCaCEOIAEgCyAXlCANIBWUkiAMIBSUkiADIAEqAmSUlCABKgJUkjgCVCABIAsgEZQgDSASlJIgDCAPlJIgAyAOlJQgASoCWJI4AlggACoC5AMhDCAAKgLgAyENIAAqAtwDIQsLIAIoAvABRQ0AIAAoAiAiACoCsAIhDyAAKgKoAiERIAAqAqwCIRIgACoCoAIhFCAAKgKYAiEXIAAqApwCIRUgACoCkAIhECAAKgKMAiETIAAqAogCIRYgAiADQwAAAICUIg4gAioCcJQgAioCQJI4AkAgAiAOIAIqAnSUIAIqAkSSOAJEIAIgDiACKgJ4lCACKgJIkjgCSCACIAsgFpQgDSATlJIgDCAQlJIgAioCYCADjCIDlJQgAioCUJI4AlAgAioCaCEOIAIgCyAXlCANIBWUkiAMIBSUkiACKgJkIAOUlCACKgJUkjgCVCACIAsgEZQgDSASlJIgDCAPlJIgDiADlJQgAioCWJI4AlgLIARB0ANqJAAL9wgCBX8NfSMAQbABayIBJAAgAC0AjwQEQCAAQQA2AiQgAEIANwLABCAAQgA3AoQEIABCADcCyAQCQCAALQCMBA0AAkAgACoCnAMiCCAAKAIgIgIqAgSUIAAqAqADIgogAioCCJSSIAAqAqQDIg0gAioCDJSSIAIqAjSSIg8gACoC3AIiDiAAKAIcIgMqAgSUIAAqAuACIgcgAyoCCJSSIAAqAuQCIgYgAyoCDJSSIAMqAjSSIhCTIgwgDJQgCCACKgIUlCAKIAIqAhiUkiANIAIqAhyUkiACKgI4kiIRIA4gAyoCFJQgByADKgIYlJIgBiADKgIclJIgAyoCOJIiEpMiCyALlJIgCCACKgIklCAKIAIqAiiUkiANIAIqAiyUkiACKgI8kiINIA4gAyoCJJQgByADKgIolJIgBiADKgIslJIgAyoCPJIiDpMiByAHlJIiBkMAAAA0XkEBc0UEQCABQQA2AowBIAEgB0MAAIA/IAaRlSIGlCIJOAKIASABIAsgBpQiCDgChAEgASAMIAaUIgo4AoABDAELIAFCADcDiAEgAUKAgID8AzcDgAFDAACAPyEKQwAAAAAhCAsCQCAJi0PzBDU/XkEBc0UEQCAJIAmUIAggCJSSIgZDAACAPyAGkZUiB5QhDCAKIAcgCYyUIgaUIQsgCCAHlCIJIAqMlCEIQwAAAAAhBwwBCyAKIAqUIAggCJSSIgZDAACAPyAGkZUiBpQhCyAJIAYgCIyUIgeUIQggCiAGlCIGIAmMlCEMQwAAAAAhCQsgASALOAKoASABIAg4AqQBIAEgCTgCmAEgASAGOAKUASABIAw4AqABIAEgBzgCkAEDQCABIAAoAhwiBCgCBDYCUCABIAQoAhQ2AlQgBCgCJCEDIAFBADYCXCABIAM2AlggASAEKAIINgJgIAEgBCgCGDYCZCAEKAIoIQMgAUEANgJsIAEgAzYCaCABIAQoAgw2AnAgASAEKAIcNgJ0IAQoAiwhAyABQQA2AnwgASADNgJ4IAEgAigCBDYCICABIAIoAhQ2AiQgAigCJCEDIAFBADYCLCABIAM2AiggASACKAIINgIwIAEgAigCGDYCNCACKAIoIQMgAUEANgI8IAEgAzYCOCABIAIoAgw2AkAgASACKAIcNgJEIAIoAiwhAyABQQA2AkwgASADNgJIIAQqAjQhCyAEKgI4IQcgBCoCPCEGIAFBADYCHCABIA4gBpM4AhggASASIAeTOAIUIAEgECALkzgCECACKgI0IQsgAioCOCEHIAIqAjwhBiABQQA2AgwgASANIAaTOAIIIAEgESAHkzgCBCABIA8gC5M4AgAgACAFQdQAbGpBMGogAUHQAGogAUEgaiABQRBqIAEgAUGAAWogBUEEdGogBEGMA2ogBCoC2AIgAkGMA2ogAioC2AIQ7AEgBUEBaiIFQQNGDQEgACgCICECDAAACwALIAAgACgCHCIDQQRqIAAoAiAiAEEEaiADQYgCaiAAQYgCahDTAgsgAUGwAWokAAvsDwIIfxF9IwBBEGsiCyQAIAAgAiADIAQgBRDTAiABKAIIIgRBgICA/AM2AgAgBCABKAIYIgpBAnQiB0EEaiIGakGAgID8AzYCACAEIApBA3QiCEEIaiIJakGAgID8AzYCACACKgIUIRIgAioCGCEUIAAqAtwCIQ4gAioCJCEQIAAqAuACIQ8gAioCKCEVIAAqAuQCIREgAioCCCEWIAIqAgAhFyACKgIEIRMgAioCECEYIAIqAiAhGSALQQA2AgwgCyAOIBmUIA8gEJSSIBEgFZSSIhA4AgggCyAOIBiUIA8gEpSSIBEgFJSSIhI4AgQgCyAXIA6UIBMgD5SSIBYgEZSSIg44AgAgASgCDCIEQQA2AgwgBCASjDgCCCAEIBA4AgQgBEEANgIAIAQgB2oiBUEANgIMIAUgDjgCCCAFQQA2AgQgBSAQjDgCACAEIAhqIgVCADcCCCAFIA6MOAIEIAUgEjgCACABKAIQIgVBgICA/Hs2AgAgBSAGakGAgID8ezYCACAFIAlqQYCAgPx7NgIAIAMqAiQhEiADKgIoIRQgACoCnAMhDiADKgIUIRAgACoCoAMhDyADKgIYIRUgACoCpAMhESADKgIIIRYgAyoCACEXIAMqAgQhEyADKgIgIRggAyoCECEZIAEoAhQiBUEANgIMIAVBADYCACAFIA4gGZQgDyAQlJIgESAVlJIiEDgCCCAFIA4gGJQgDyASlJIgESAUlJIiEow4AgQgBSAHaiIGQQA2AgwgBiAXIA6UIBMgD5SSIBYgEZSSIg6MOAIIIAZBADYCBCAGIBI4AgAgBSAIaiIGQgA3AgggBiAOOAIEIAYgEIw4AgAgASgCKCEIIAEoAiQhBiABKAIcIgkgAEHYBGogAUEEaiAAKALQBCIMQQJxGyoCACABKgIAlCIPIA4gAyoCMJIgCyoCAJMgAioCMJOUOAIAIAZB////ezYCACAIQf////sHNgIAIAxBAXEiDQRAIAEoAiAgACgC1AQ2AgALIAcgCWogDyAQIAMqAjSSIAsqAgSTIAIqAjSTlDgCACAGIAdqQf///3s2AgAgByAIakH////7BzYCACANBEAgASgCICAKQQJ0aiAAKALUBDYCAAsgCSAKQQN0IgdqIA8gEiADKgI4kiALKgIIkyACKgI4k5Q4AgAgBiAHakH///97NgIAIAcgCGpB////+wc2AgAgDQRAIAEoAiAgB2ogACgC1AQ2AgALAn8gCkEDbCIDIAAtAI4ERQ0AGgJAIAAqArwDIAAqAsgDIg5dQQFzDQAgACoCwAMgDl1BAXMNACAAKgLUAiEOIAAqArQCIQ8gACoCxAIhESACKgIIIRAgAioCACESIAIqAgQhFCACKgIYIRUgAioCECEWIAIqAhQhFyAEIANBAnQiA0EIaiIGaiAAKgKwAiITIAIqAiAiHJQgACoCwAIiGCACKgIkIh2UkiAAKgLQAiIZIAIqAigiHpSSIho4AgAgBCADQQRqIghqIBMgFpQgGCAXlJIgGSAVlJIiGzgCACADIARqIBIgE5QgFCAYlJIgECAZlJIiEzgCACAEIApBBHQiAmogEiAPlCAUIBGUkiAQIA6UkiIQOAIAIAQgAkEEciIJaiAPIBaUIBEgF5SSIA4gFZSSIhI4AgAgBCACQQhyIgdqIA8gHJQgESAdlJIgDiAelJIiDjgCACAFIAZqIBqMOAIAIAUgCGogG4w4AgAgAyAFaiATjDgCACACIAVqIBCMOAIAIAUgCWogEow4AgAgBSAHaiAOjDgCACABKAIcIgkgA2ogASoCACAAKgK0A5QiDyATIAAqAswDlCAbIAAqAtADlJIgGiAAKgLUA5SSlDgCACACIAlqIA8gECAAKgLMA5QgEiAAKgLQA5SSIA4gACoC1AOUkpQ4AgAgASgCJCIGIANqQf///3s2AgAgASgCKCIIIANqQf////sHNgIAIAIgBmpB////ezYCACACIAhqQf////sHNgIAIApBBWwMAQsgACoC0AMhDyAAKgLUAyERIAQgA0ECdCICaiAAKgK0AyIOIA4gACoCzAOUlCIQOAIAIAQgAkEIaiIDaiAOIA4gEZSUIhE4AgAgBCACQQRqIgdqIA4gDiAPlJQiDjgCACADIAVqIBGMOAIAIAUgB2ogDow4AgAgAiAFaiAQjDgCACACIAlqIAEqAgAgACoCsAOUIAAqAvgDlDgCACAMQQRxBEAgASgCICACaiAAKALcBDYCAAsgAiAGakEANgIAIAIgCGpB////+wc2AgAgCkECdAshAyAALQCNBARAIAAqAuADIQ8gACoC5AMhESAEIANBAnQiAmogACoCtAMiDiAOIAAqAtwDlJQiEDgCACAEIAJBCGoiCmogDiAOIBGUlCIROAIAIAQgAkEEaiIHaiAOIA4gD5SUIg44AgAgBSAKaiARjDgCACAFIAdqIA6MOAIAIAIgBWogEIw4AgAgAiAJaiABKgIAIAAqArADlCAAKgL8A5Q4AgAgDEEEcQRAIAEoAiAgAmogACgC3AQ2AgALIAggA0ECdGoCfQJAIAAqAsQDQwAAAABeQQFzRQRAIAYgA0ECdGohASAAKgL8A0MAAAAAXkEBc0UEQCABQQA2AgAMAgsgAUH///97NgIAQwAAAAAMAgsgBiADQQJ0akH///97NgIAC0P//39/CzgCAAsgC0EQaiQACykAIAAgASAAKAIcIgFBBGogACgCICIAQQRqIAFBiAJqIABBiAJqEKgOC8oBAgJ/AX0gAC0AjwQEQCABQgA3AgAPCyABQoOAgIAwNwIAIAAgACgCHCICQQRqIAAoAiAiA0EEaiACQYgCaiADQYgCahDTAgJAIAAtAI4ERQ0AIAEgASgCACICQQFqNgIAIAEgASgCBCIDQX9qNgIEIAAqArwDIAAqAsgDIgRdQQFzDQAgACoCwAMgBF1BAXMNACABIANBfmo2AgQgASACQQJqNgIACyAALQCNBARAIAEgASgCAEEBajYCACABIAEoAgRBf2o2AgQLC+MCAQJ+IABBBSABENYCIABBlMMANgIAIAAgAikCCDcCtAIgACACKQIANwKsAiAAIAIpAhg3AsQCIAAgAikCEDcCvAIgACACKQIgNwLMAiAAIAIpAig3AtQCIAIpAjghAyACKQIwIQQgAEEAOgCPBCAAIAM3AuQCIAAgBDcC3AIgACAAKQKsAjcC7AIgACAAKQK0AjcC9AIgACAAKQK8AjcC/AIgACAAKQLEAjcChAMgACAAKQLUAjcClAMgACAAKQLMAjcCjAMgAEEAOgCoBCAAQQA6AI4EIABBADsBjAQgAEIANwKkAyAAQgA3ApwDIABBgICA/Hs2ArwEIABB65b46gU2AsQDIABC65b46rXtgq/dADcCvAMgAEEANgLcBCAAQoCAgICw5syZPzcC1AQgAEEANgLQBCAAQc2Zs+oDNgLIAyAAQoCAgPyj4fWRPDcCtAMgAEKAgID8o7PmzD43AqwDC8ICACAAQQUgASACEEcgAEGUwwA2AgAgACADKQIINwK0AiAAIAMpAgA3AqwCIAAgAykCGDcCxAIgACADKQIQNwK8AiAAIAMpAig3AtQCIAAgAykCIDcCzAIgACADKQI4NwLkAiAAIAMpAjA3AtwCIAAgBCkCCDcC9AIgACAEKQIANwLsAiAAIAQpAhA3AvwCIAAgBCkCGDcChAMgACAEKQIgNwKMAyAAIAQpAig3ApQDIAAgBCkCMDcCnAMgACAEKQI4NwKkAyAAQQA6AKgEIABBgICA/Hs2ArwEIABBADYCjAQgAELrlvjqte2Cr90ANwK8AyAAQQA2AtAEIABCgICA/KOz5sw+NwKsAyAAQoCAgPyj4fWRPDcCtAMgAEKAgICAsObMmT83AtQEIABBADYC3AQgAELrlvjq1Zmzpj03AsQDC7MDACAAIAEgAhBkGiABIAAoAjQ2AjQgASAAKAI4NgI4IAEgACgCPDYCPCABIABBQGsoAgA2AkAgASAAKAJENgJEIAEgACgCSDYCSCABIAAoAkw2AkwgASAAKAJQNgJQIAEgACgCVDYCVCABIAAoAlg2AlggASAAKAJcNgJcIAEgACgCYDYCYCABIAAoAmQ2AmQgASAAKAJoNgJoIAEgACgCbDYCbCABIAAoAnA2AnAgASAAKAJ0NgJ0IAEgACgCeDYCeCABIAAoAnw2AnwgASAAKAKAATYCgAEgASAAKAKEATYChAEgASAAKAKIATYCiAEgASAAKAKMATYCjAEgASAAKAKQATYCkAEgASAAKAKUATYClAEgASAAKAKYATYCmAEgASAAKAKcATYCnAEgASAAKAKgATYCoAEgASAAKAKkATYCpAEgASAAKAKoATYCqAEgASAAKAKsATYCrAEgASAAKAKwATYCsAEgASAAKAK8ATYCtAEgASAAKAK4ATYCuAEgASAAKALEATYCvAEgASAAKALAATYCwAEgASAALQC0ATYCxAEgASAALQAxNgLIAUH0wgALBQBBzAELwwEBAX1D//9/fyEDAkAgAUF+aiIBQQJLDQACQAJAAkAgAUEBaw4CAQIACyACQQBMBEAgACoC6AEPCyACQQJMBEAgACoCiAIPCyACQQNGBEAgACoC+AEPCyACQQVKDQIgACoCmAIPCyACQQBMBEAgACoC1AEPCyACQQNHDQEgACoC5AEPCyACQQBMBEAgACoC9AEPCyACQQJMBEAgACoClAIPCyACQQNGBEAgACoChAIPCyACQQVKDQAgACoCpAIhAwsgAwvmAgACQCABQX5qIgFBAksNAAJAAkACQCABQQFrDgIBAgALIANBAEwEQCAAIAI4AugBIAAgACgCrAJBgARyNgKsAg8LIANBAkwEQCAAIAI4AogCIAAgACgCrAJBIHI2AqwCDwsgA0EDRgRAIAAgAjgC+AEgACAAKAKsAkGAEHI2AqwCDwsgA0EFSg0CIAAgAjgCmAIgACAAKAKsAkGAAXI2AqwCDwsgA0EATARAIAAgAjgC1AEgACAAKAKsAkEBcjYCrAIPCyADQQNHDQEgACACOALkASAAIAAoAqwCQQRyNgKsAg8LIANBAEwEQCAAIAI4AvQBIAAgACgCrAJBgAJyNgKsAg8LIANBAkwEQCAAIAI4ApQCIAAgACgCrAJBEHI2AqwCDwsgA0EDRgRAIAAgAjgChAIgACAAKAKsAkGACHI2AqwCDwsgA0EFSg0AIAAgAjgCpAIgACAAKAKsAkHAAHI2AqwCCwuYJQISfx19IwBBMGsiCCQAIAAtALQBIRYgACoC8AYhLSAAKgKwByEuIAAqAuwGISogACoCrAchLyAAKgLoBiErIAAqAqgHITBDAACAPyAHIAYgB5IiGpVDAAAAPyAaQwAAAABeGyIdkyEgIAEoAhghDiAAKAKYByEQIAAoAogHIRUgACgC2AYhCiAAKALIBiELIAAoAvgGIRQgACgCuAYhDAJ/IAAtADEiFwRAIB0gC76UICAgFb6UkiIaQwAAgD8gHSAMvpQgICAUvpSSIhsgG5QgGiAalJIgHSAKvpQgICAQvpSSIhogGpSSkZUiHpQhHCAbIB6UIR8CQCAaIB6UIiKLQ/MENT9eQQFzRQRAICIgIpQgHCAclJIiGkMAAIA/IBqRlSIjlCEbIB8gIyAijJQiGpQhHiAcICOUIiMgH4yUISQMAQsgHyAflCAcIByUkiIaQwAAgD8gGpGVIhqUIR4gIiAaIByMlCIhlCEkIB8gGpQiGiAijJQhGwsgHLwhESAfvCETIAggIzgCKCAIIBo4AiQgCCAeOAIYIAggJDgCFCAIIBs4AhAgCCAhOAIgICG8IQkgIrwMAQsgACgCvAYhCSAAKALMBiESIAAoAtwGIREgCEEANgIsIAggETYCKCAIIBI2AiQgCCAJNgIgIAAoAsAGIRIgACgC0AYhESAAKALgBiETIAhBADYCHCAIIBM2AhggCCARNgIUIAggEjYCECAMIRMgCyERIAoLIRIgASgCDCINIAk2AgAgDSAIKAIkNgIEIA0gCCgCKDYCCCANIA5BAnQiD2ogCCgCEDYCACANIA9BBGoiGGogCCgCFDYCACANIA9BCGoiGWogCCgCGDYCACABKAIUIgkgCCoCICIajCIoOAIAIAkgCCoCJCIbjDgCBCAJIAgqAigiI4w4AgggCSAPaiAIKgIQIiSMOAIAIAkgGGogCCoCFCIhjDgCACAJIBlqIAgqAhgiH4w4AgAgACoCmAIhHiABKAIcIhkgACgCrAIiGEGAAXEEfSAeBSAeIAEqAgSUCyABKgIAlCIeIAu+IhwgEL4iIpQgCr4iJyAVviIllJMiJiAalCAnIBS+IieUIAy+IikgIpSTIiIgG5SSICkgJZQgHCAnlJMiHCAjlJKUOAIAIA8gGWogHiAmICSUICIgIZSSIBwgH5SSlDgCACAYQcAAcQRAIAEoAiAiCiAAKAKkAjYCACAKIA5BAnRqIAAoAqQCNgIACyAGQwAAADRdIAdDAAAANF1yIRUgAyoCOCEGIAMqAjQhByACKgI4IR4gAioCNCEcIAMqAjAhIiACKgIwIScgCEIANwMIIAhCADcDACAOQQNsIQ8gDkEBdCECAn0gFwRAIAAqAogIISMgACoCuAghJCAAKgKwByEaIAAqAqgHIRsgACoCrAchHyAAKgLwBiEoIAAqAugGISkgACoC7AYhLCAIQQA2AiwgCCAdIBogBpMiBiAbICKTIiIgE74iIZQgHyAHkyIaIBG+IiWUkiAGIBK+IiaUkiIGICaUIjGTIjKUICAgKCAekyIHICkgJ5MiHiAhlCAsIByTIhwgJZSSIAcgJpSSIhsgJpQiJ5MiKJSSIgc4AiggCCAdIBogBiAllCIpkyIslCAgIBwgGyAllCIckyIzlJIiGjgCJCAIIB0gIiAGICGUIiKTIjSUICAgHiAbICGUIjWTIjaUkiIfOAIgIDIgICAnICQgI5MiGyAmlJIgMZMiJJSTIQYgLCAgIBwgGyAllJIgKZMiHJSTIR4gNCAgIDUgGyAhlJIgIpMiG5STISMgKCAdICSUkiEkIDMgHSAclJIhIiA2IB0gG5SSIScCQCAHIAeUIB8gH5QgGiAalJKSIhtDAAAANF5BAXNFBEAgCCAHQwAAgD8gG5GVIgeUIhs4AiggCCAaIAeUIhw4AiQgCCAfIAeUIho4AiAgG7whCyAcvCEKDAELIAAoArwGIQMgACgCzAYhCiAAKALcBiELIAhBADYCLCAIIAs2AiggCCAKNgIkIAggAzYCICADviEaIAq+IRwgC74hGwsgCCAnIByUICIgGpSTOAIIIAhBADYCHCAIICQgGpQgJyAblJM4AgQgCCAiIBuUICQgHJSTOAIAIAggHCAhlCAaICWUkyIHOAIYIAggGiAmlCAbICGUkyIfOAIUIAggGyAllCAcICaUkzgCECANIAJBAnQiA2oiDCAIKAIINgIIIAwgCCkDADcCACADIAlqIB4gG5QgBiAclJOMOAIAIAkgAkEBckECdCINaiAGIBqUICMgG5STjDgCACAJIAJBAmpBAnQiDmogIyAclCAeIBqUk4w4AgAgCEEANgIMIAggIiAHlCAkIB+UkyIlOAIAIAggJyAflCAiIAgqAhAiGpSTIiY4AgggCCAkIBqUICcgB5STIig4AgQgHiAHlCAGIB+UkyEcICMgH5QgHiAalJMhISAGIBqUICMgB5STIRsCQCAVRQ0AIAAtAKkCRQ0AIAggHSAmlDgCCCAIIB0gKJQ4AgQgCCAdICWUOAIAICAgIZQhISAgIBuUIRsgICAclCEcCyAPQQJ0IgwgASgCDGoiCSAIKQMANwIAIAkgCCgCCDYCCCABKAIUIgkgDEEEaiIQaiAbjDgCACAJIAxqIByMOAIAIAkgDEEIaiIUaiAhjDgCACABKAIIIgkgA2ogCCgCIDYCACAJIA1qIAo2AgAgCSAOaiALNgIAIAgoAhAhFyAJIBRqIAc4AgAgCSAQaiAfOAIAIAkgDGogFzYCACADIAEoAhAiA2ogCCoCIIw4AgAgAyANaiAKviIhjDgCACADIA5qIAu+IiiMOAIAIAgqAhAhGiADIBBqIB+MOAIAIAMgDGogGow4AgAgAyAUaiEMQwAAAAAhHEMAAAAAISVDAAAAACEmIAeMDAELIA0gAkECdCIDaiAdIAcgHJMiJSAjlCAGIB6TIiYgG5STIgaUOAIAIA0gA0EEciILaiAdICYgGpQgIiAnkyIcICOUkyIHlDgCACANIANBCGoiDGogHSAcIBuUICUgGpSTIh6UOAIAIAMgCWogICAGlDgCACAJIAtqICAgB5Q4AgAgCSAMaiAgIB6UOAIAIA0gD0ECdCIKQQhqIg5qIB0gHCAhlCAlICSUkyIGlDgCACANIApBBGoiEGogHSAmICSUIBwgH5STIgeUOAIAIAogDWogHSAlIB+UICYgIZSTIh6UOAIAIAkgDmogICAGlDgCACAJIBBqICAgB5Q4AgAgCSAKaiAgIB6UOAIAIAEoAggiCSADaiAaOAIAIAkgC2ogGzgCACAJIAxqICM4AgAgCSAOaiAfOAIAIAkgEGogITgCACAJIApqICQ4AgAgAyABKAIQIgNqICg4AgAgAyALaiAIKgIkIiGMOAIAIAMgDGogCCoCKCIojDgCACADIApqIAgqAhAiGow4AgAgAyAQaiAIKgIUIh+MOAIAIAMgDmohDEMAAAAAISNDAAAAACEeQwAAAAAhBkMAAAAAISdDAAAAACEiQwAAAAAhJCAIKgIYIgeMCyEbIAwgGzgCACAAKgKIAiEbIAEoAhwiDCACQQJ0IgJqIAAoAqwCIg1BIHEEfSAbBSAbIAEqAgSUCyABKgIAlCIbIDAgK5MiKyAIKgIglCAvICqTIiogIZSSIC4gLZMiISAolJKUOAIAIAwgD0ECdCIKaiAbICsgGpQgKiAflJIgISAHlJKUOAIAIA1BEHEEQCACIAEoAiAiAmogACgClAI2AgAgAiAKaiAAKAKUAjYCAAtDAACAP0MAAIC/IBYbIR8CQCAALQDICCIQAn8gAC0AqAJFBEBDAAAAACEhQQAMAQtBAkEBIB8gACoCiAiUIiFDAAAAAF4bCyICckUEQEEEIQMMAQsgCSABKAIYIgpBBHQiFGogEzYCACAJIApBAnQiCkEBciIWQQJ0IgtqIBE2AgAgCSAKQQJyIg5BAnQiD2ogEjYCACADIBRqIBO+IgeMOAIAIAMgC2ogEb4iGow4AgAgAyAPaiASviIbjDgCAAJAAn0gAC0AMQRAIBUNAiAIQQA2AgwgCCAnIBqUICIgB5STIh04AgggCCAkIAeUICcgG5STIiA4AgQgCCAiIBuUICQgGpSTIhw4AgAgASgCDCIDIApBAnQiC2ogHDgCACADIBZBAnQiD2ogIDgCACADIA5BAnRqIB04AgAgASgCFCIJIAtqIB4gG5QgBiAalJOMOAIAIAkgD2ogBiAHlCAjIBuUk4w4AgAgIyAalCAeIAeUk4wMAQsgASgCDCIDIApBAnQiCWogHSAlIBuUICYgGpSTIgaUOAIAIAMgC2ogHSAmIAeUIBwgG5STIh6UOAIAIAMgD2ogHSAcIBqUICUgB5STIh2UOAIAIAkgASgCFCIJaiAgIAaUOAIAIAkgC2ogICAelDgCACAgIB2UCyEGIAkgDkECdGogBjgCAAsgACoCvAEhBiAAKgK4ASEdIAwgCkECdCIDakEANgIAIAEoAiQiCyADakEANgIAIAEoAigiDiADakEANgIAIABB6AFqIAFBBGogDUGABHEbKgIAISACQCAQRQ0AIAJBAEcgHSAGW3ENACANQQFxBEAgASgCICAKQQJ0aiAAKALUATYCAAsgACoCuAggACoCuAEgACoCvAEgACoCzAggICABKgIAlBCxASEeIAEoAhwiDCAKQQJ0IgNqIgsgCyoCACAfIB6UIAAqAswIlJM4AgAgASgCJCILIANqIgkgCSoCACAAKgLQCCABKgIAlJM4AgAgASgCKCIOIANqIgMgACoC0AggASoCAJQgAyoCAJI4AgALQQUhAyACRQ0AIAwgCkECdCINaiIJIAkqAgAgISAgIAEqAgCUlJI4AgAgAC0ArQJBAXEEQCABKAIgIA1qIAAoAvQBNgIACyAOIApBAnRqAn0CQCAdIAZbBEAgCyAKQQJ0akH///97NgIADAELIAsgCkECdGohCyACQQFGBEAgC0H///97NgIAQwAAAAAMAgsgC0EANgIAC0P//39/CzgCAAJAQwAAgD8gACoC8AGTIgZDAAAAAFsgBiAGXHINACAGiyEdIB8gBCoCACAHlCAEKgIEIBqUkiAEKgIIIBuUkiAFKgIAIAeUIAUqAgQgGpSSIAUqAgggG5SSk5QhBiACQQFGBEAgBkMAAAAAXUEBcw0BIAYgHYyUIgYgCSoCAF5BAXMNASAJIAY4AgAMAQsgBkMAAAAAXkEBcw0AIAYgHYyUIgYgCSoCAF1BAXMNACAJIAY4AgALIAkgACoC6AEgCSoCAJQ4AgALAkAgAC0A2AgiBQJ/IAAtAKkCRQRAQwAAAAAhB0EADAELQQFBAiAAKgLACCIHQwAAAABeGwsiCXJFDQAgASgCDCIEIAEoAhggA2wiA0ECdCICaiATNgIAIAQgAkEIaiIKaiASNgIAIAQgAkEEaiILaiARNgIAIAEoAhQiBCAKaiASviIgjDgCACAEIAtqIBG+Ih6MOAIAIAIgBGogE74iHIw4AgAgAEH4AWogAUEEaiAAKAKsAiICQYAQcRsqAgAhIyAAKgLEASEGIAAqAsABIR0CQCAFRQ0AIAlBAEcgHSAGW3ENACAGIRsgHSEaIAJBBHEEQCABKAIgIANBAnRqIAAoAuQBNgIAIAAqAsQBIRsgACoCwAEhGgsgACoCvAggGiAbIAAqAtwIICMgASoCAJQQsQEhGiABKAIcIgwgA0ECdCICaiAaIAAqAtwIlDgCACABKAIkIAJqIAEqAgAgACoC4AiMlDgCACABKAIoIAJqIAAqAuAIIAEqAgCUOAIACyAJRQ0AIAwgA0ECdCIEaiICIAIqAgAgByAjIAEqAgCUlJI4AgAgAC0ArQJBBHEEQCABKAIgIARqIAAoAoQCNgIACwJ9IB0gBlsEQCABKAIkIANBAnRqQf///3s2AgBD//9/fwwBCyABKAIkIANBAnRqIQQgCUEBRgRAIARBADYCAEP//39/DAELIARB////ezYCAEMAAAAACyEGIAEoAiggA0ECdGogBjgCAAJAQwAAgD8gACoCgAKTIgZDAAAAAFsgBiAGXHINACAGiyEHIAAoAhwiASoCyAIgHJQgASoCzAIgHpSSIAEqAtACICCUkiAAKAIgIgEqAsgCIByUIAEqAswCIB6UkiABKgLQAiAglJKTIQYgCUEBRgRAIAZDAAAAAF1BAXMNASAGIAeMlCIGIAIqAgBeQQFzDQEgAiAGOAIADAELIAZDAAAAAF5BAXMNACAGIAeMlCIGIAIqAgBdQQFzDQAgAiAGOAIACyACIAAqAvgBIAIqAgCUOAIACyAIQTBqJAALNQAgACABIAAoAhwiAUEEaiAAKAIgIgBBBGogAUG4AmogAEG4AmogASoC2AIgACoC2AIQsQ4LmAQBBX0gAEEAOgCpAiAAQQA2AsAIAkAgACoCwAEiAyAAKgLEASIEX0EBcw0AIAAqAsAGIAAqAvwGIgGUIAAqAtAGIAAqAowHIgKUkiAAKgLgBiAAKgKcByIFlJIgACoCvAYgAZQgACoCzAYgApSSIAAqAtwGIAWUkhBBIQICQCADIARgDQAgAiADXUEBc0UEQAJAIAMgApND2w/JQBAlIgFD2w9JwF1BAXNFBEAgAUPbD8lAkiEBDAELIAFD2w9JQF5BAXMNACABQ9sPycCSIQELIAGLIQUCQCAEIAKTQ9sPyUAQJSIBQ9sPScBdQQFzRQRAIAFD2w/JQJIhAQwBCyABQ9sPSUBeQQFzDQAgAUPbD8nAkiEBCyACIAJD2w/JQJIgBSABi10bIQIMAQsgAiAEXkEBcw0AAkAgAiAEk0PbD8lAECUiAUPbD0nAXUEBc0UEQCABQ9sPyUCSIQEMAQsgAUPbD0lAXkEBcw0AIAFD2w/JwJIhAQsgAYshBQJAIAIgA5ND2w/JQBAlIgFD2w9JwF1BAXNFBEAgAUPbD8lAkiEBDAELIAFD2w9JQF5BAXMNACABQ9sPycCSIQELIAJD2w/JwJIgAiABiyAFXRshAgsgACACOAK8CCACIANdQQFzRQRAIABBAToAqQIgACACIAOTOALACA8LIAIgBF5BAXMNACAAQQE6AKkCIAAgAiAEkzgCwAgLC/IBAgF/A30gAC0AMARAIAFCADcCAA8LIAFChICAgCA3AgAgACAAKAIcQQRqIAAoAiBBBGoQ1AIgABCzDiAAQQA6AKgCIAAgACgCiAgiAjYCuAgCQAJAAkAgACoCuAEiBSAAKgK8ASIDX0EBc0UEQCADIAK+IgRdDQEgBSIDIAReDQELIABBADYCiAggAC0AyAgNAQwCCyAAQQE6AKgCIAAgBCADkzgCiAgLIAEgASgCAEEBajYCACABIAEoAgRBf2o2AgQLQQAgAC0AqQJFIAAtANgIG0UEQCABIAEoAgBBAWo2AgAgASABKAIEQX9qNgIECwvwBgICfhh9IABBBxDVAiABEEcgAEEAOgAwIABBpMIANgIAIAAgAikCCDcCfCAAIAIpAgA3AnQgACACKQIYNwKMASAAIAIpAhA3AoQBIAAgAikCIDcClAEgACACKQIoNwKcASACKQI4IQQgAikCMCEFIAAgAzoAtAEgACAFNwKkASAAIAQ3AqwBIAEqAjQhGyABKgI4IRwgASoCPCEdIAAqAqwBIQ8gACoCpAEhECAAKgKoASERIAEqAgghBiABKgIMIQcgASoCHCEIIAEqAhQhCSABKgIYIQogACoChAEhEiAAKgKUASETIAAqApgBIRQgACoCeCEVIAAqAogBIRYgASoCLCELIAAqApwBIRcgASoCJCEMIAAqAnwhGCABKgIoIQ0gACoCjAEhGSABKgIEIQ4gACoCdCEaIABCgICA/AM3AqACIABCgICA/LPmzJk/NwKYAiAAQoCAgPwDNwKQAiAAQoCAgPyz5syZPzcCiAIgAEIANwLgASAAQoCAgPyz5syZPzcC2AEgAEIANwLQASAAQoCAgPyz5syZPzcCyAEgAEIANwLAASAAQoCAgPyDgIDAv383ArgBIABBADYCcCAAQQA2AmAgAEEANgJQIABBQGtBADYCACAAIBggDJQgGSANlJIgFyALlJI4AlwgACAVIAyUIBYgDZSSIBQgC5SSOAJYIAAgGiAMlCASIA2UkiATIAuUkjgCVCAAIBggCZQgGSAKlJIgFyAIlJI4AkwgACAVIAmUIBYgCpSSIBQgCJSSOAJIIAAgGiAJlCASIAqUkiATIAiUkjgCRCAAIA4gGJQgBiAZlJIgByAXlJI4AjwgACAOIBWUIAYgFpSSIAcgFJSSOAI4IAAgGiAOlCASIAaUkiATIAeUkjgCNCAAIB0gDCAQlCANIBGUkiALIA+UkpI4AmwgACAcIAkgEJQgCiARlJIgCCAPlJKSOAJoIAAgGyAOIBCUIAYgEZSSIAcgD5SSkjgCZCAAQQA2AuQIIABCADcC3AggAEEAOgDICCAAQoCAgPwDNwKAAiAAQoCAgPyz5syZPzcC+AEgAEKAgID8AzcC8AEgAEKAgID8s+bMmT83AugBIABCADcCzAggAEEANgKsAiAAQdEIakIANwAAIABBAToAMSAAIAAoAhxBBGogACgCIEEEahDUAgvSAwAgAEEHIAEgAhBHIABBADoAMCAAQaTCADYCACAAIAMpAgg3AjwgACADKQIANwI0IAAgAykCGDcCTCAAIAMpAhA3AkQgACADKQIoNwJcIAAgAykCIDcCVCAAIAMpAjg3AmwgACADKQIwNwJkIAAgBCkCCDcCfCAAIAQpAgA3AnQgACAEKQIYNwKMASAAIAQpAhA3AoQBIAAgBCkCKDcCnAEgACAEKQIgNwKUASAAIAQpAjg3AqwBIAAgBCkCMDcCpAEgAEKAgID8AzcCoAIgAEKAgID8s+bMmT83ApgCIABCgICA/AM3ApACIABCgICA/LPmzJk/NwKIAiAAQgA3AuABIABCgICA/LPmzJk/NwLYASAAQgA3AtABIABCgICA/LPmzJk/NwLIASAAQgA3AsABIABCgICA/IOAgMC/fzcCuAEgACAFOgC0ASAAQQA2AuQIIABCADcC3AggAEEAOgDICCAAQoCAgPwDNwKAAiAAQoCAgPyz5syZPzcC+AEgAEKAgID8AzcC8AEgAEKAgID8s+bMmT83AugBIABBADYCrAIgAEHRCGpCADcAACAAQgA3AswIIABBAToAMSAAIAAoAhxBBGogACgCIEEEahDUAguVAgEDfQJAIAAqAgQiA0MAAAAAXkEBcw0AAkAgASoCACAAKgIAIgSTQ9sPyUAQJSICQ9sPScBdQQFzRQRAIAJD2w/JQJIhAgwBCyACQ9sPSUBeQQFzDQAgAkPbD8nAkiECCyACIANfQQFzRUEAIAIgA4xdQQFzGw0AIAJDAAAAAF5BAXNFBEAgAyAEkkPbD8lAECUiAkPbD0nAXUEBc0UEQCABIAJD2w/JQJI4AgAPCyABIAIgAkPbD8nAkiACQ9sPSUBeQQFzGzgCAA8LAkAgBCADk0PbD8lAECUiAkPbD0nAXUEBc0UEQCACQ9sPyUCSIQIMAQsgAkPbD0lAXkEBcw0AIAJD2w/JwJIhAgsgASACOAIACwtxACAAIAIgAZNDAAAAP5QiAjgCBAJAIAIgAZJD2w/JQBAlIgFD2w9JwF1BAXNFBEAgAUPbD8lAkiEBDAELIAFD2w9JQF5BAXMNACABQ9sPycCSIQELIAAgBTgCECAAIAQ4AgwgACADOAIIIAAgATgCAAtzAEGg2wFBoDY2AgBBkN8BKAIAIgAEQEGU3wEtAAAEQCAABEBB7PcBQez3ASgCAEEBajYCACAAQZDSASgCABEAAAsLQZDfAUEANgIAC0GU3wFBAToAAEGI3wFCADcCAEGQ3wFBADYCAEGg2wFB5MoANgIAC2cAIAAgASACEGQaIAEgACgCrAI2AjQgASAAKAKwAjYCOCABIAAoArQCNgI8IAEgACgCuAI2AkAgASAAKAK8AjYCRCABIAAoAsACNgJIIAEgACgCxAI2AkwgASAAKALIAjYCUEHkwAALQgEBfUP//39/IQMCQCACQX9HDQAgAUF/aiIBQQNLDQACQAJAIAFBAmsOAgEBAAsgACoC0AIPCyAAKgLUAiEDCyADC1cAAkAgA0F/Rw0AIAFBf2oiAUEDSw0AAkACQCABQQJrDgIBAQALIAAgAjgC0AIgACAAKALMAkEBcjYCzAIPCyAAIAI4AtQCIAAgACgCzAJBAnI2AswCCwvSBwIIfwx9IAEoAggiBUGAgID8AzYCACAFIAEoAhgiCEECdCIHQQRqIgpqQYCAgPwDNgIAIAUgCEEDdCIJQQhqIgtqQYCAgPwDNgIAIAIqAhQhDyACKgIYIREgAioCJCEQIAAqArACIQwgAioCKCESIAAqArQCIQ0gAioCCCETIAIqAgAhFCACKgIEIRUgAioCECEWIAIqAiAhFyAAKgKsAiEOIwBBEGsiBUEANgIMIAUgDiAXlCAMIBCUkiANIBKUkiIQOAIIIAUgDiAWlCAMIA+UkiANIBGUkiIPOAIEIAUgFCAOlCAVIAyUkiATIA2UkiIMOAIAIAEoAgwiBEEANgIMIAQgD4w4AgggBCAQOAIEIARBADYCACAEIAdqIgZBADYCDCAGIAw4AgggBkEANgIEIAYgEIw4AgAgBCAJaiIEQgA3AgggBCAMjDgCBCAEIA84AgAgASgCECIEQYCAgPx7NgIAIAQgCmpBgICA/Hs2AgAgBCALakGAgID8ezYCACADKgIkIQ8gAyoCKCERIAMqAhQhECAAKgLAAiEMIAMqAhghEiAAKgLEAiENIAMqAgghEyADKgIAIRQgAyoCBCEVIAMqAiAhFiADKgIQIRcgACoCvAIhDiABKAIUIgRBADYCDCAEQQA2AgAgBCAOIBeUIAwgEJSSIA0gEpSSIhA4AgggBCAOIBaUIAwgD5SSIA0gEZSSIg+MOAIEIAQgB2oiBkEANgIMIAYgFCAOlCAVIAyUkiATIA2UkiIMjDgCCCAGQQA2AgQgBiAPOAIAIAQgCWoiBEIANwIIIAQgDDgCBCAEIBCMOAIAIAEoAhwiBCAAQdACaiABQQRqIAAoAswCIgZBAXEbKgIAIAEqAgCUIg0gDCADKgIwkiAFKgIAkyACKgIwk5Q4AgAgBCAHaiANIBAgAyoCNJIgBSoCBJMgAioCNJOUOAIAIAQgCWogDSAPIAMqAjiSIAUqAgiTIAIqAjiTlDgCACAIQQF0IQIgBkECcQRAIAEoAiAiAyAAKALUAjYCACADIAdqIAAoAtQCNgIAIAMgAkECdGogACgC1AI2AgALIAAqAuQCIgyMIQ4gDCENAn8gDEMAAAAAXkEBc0UEQCABKAIkIA44AgAgASgCKCAMOAIAIAAqAuQCIQ0LIA1DAAAAAF5BAXNFCwR9IAhBAnQiAyABKAIkaiAOOAIAIAEoAiggA2ogDDgCACAAKgLkAgUgDQtDAAAAAF5BAXNFBEAgAkECdCICIAEoAiRqIA44AgAgASgCKCACaiAMOAIACyABIAAoAuACNgI0CxkAIAAgASAAKAIcQQRqIAAoAiBBBGoQvQ4LGwAgAUEAQQMgAC0A2AIbIgA2AgQgASAANgIAC6kGAgZ/D30jAEGQAWsiASQAIABBADYCJCABQgA3A4gBIAFCADcDgAEDQCABQYABaiAFQQJ0aiIGQYCAgPwDNgIAIAEgACgCHCIDKAIENgJQIAEgAygCFDYCVCADKAIkIQIgAUEANgJcIAEgAjYCWCABIAMoAgg2AmAgASADKAIYNgJkIAMoAighAiABQQA2AmwgASACNgJoIAEgAygCDDYCcCABIAMoAhw2AnQgAygCLCECIAFBADYCfCABIAI2AnggASAAKAIgIgIoAgQ2AiAgASACKAIUNgIkIAIoAiQhBCABQQA2AiwgASAENgIoIAEgAigCCDYCMCABIAIoAhg2AjQgAigCKCEEIAFBADYCPCABIAQ2AjggASACKAIMNgJAIAEgAigCHDYCRCACKAIsIQQgAUEANgJMIAEgBDYCSCADKgI0IQogAyoCDCENIAMqAgghDiADKgI4IQsgAyoCHCEPIAMqAhQhECADKgIYIREgAyoCPCEMIAMqAiwhEiADKgIkIRMgAyoCKCEUIAMqAgQhFSAAKgK0AiEHIAAqAqwCIQggACoCsAIhCSABQQA2AhwgASAMIAggE5QgCSAUlJIgByASlJKSIAyTOAIYIAEgCyAIIBCUIAkgEZSSIAcgD5SSkiALkzgCFCABIAogCCAVlCAJIA6UkiAHIA2UkpIgCpM4AhAgAioCNCEKIAIqAgwhDSACKgIIIQ4gAioCOCELIAIqAhwhDyACKgIUIRAgAioCGCERIAIqAjwhDCACKgIsIRIgAioCJCETIAIqAighFCACKgIEIRUgACoCxAIhByAAKgK8AiEIIAAqAsACIQkgAUEANgIMIAEgDCAIIBOUIAkgFJSSIAcgEpSSkiAMkzgCCCABIAsgCCAQlCAJIBGUkiAHIA+UkpIgC5M4AgQgASAKIAggFZQgCSAOlJIgByANlJKSIAqTOAIAIAAgBUHUAGxqQTBqIAFB0ABqIAFBIGogAUEQaiABIAFBgAFqIANBjANqIAMqAtgCIAJBjANqIAIqAtgCEOwBIAZBADYCACAFQQFqIgVBA0cNAAsgAUGQAWokAAuLAgEPfSAAQQMgARDWAiAAQZDAADYCACAAIAIpAgA3AqwCIAAgAikCCDcCtAIgASoCNCEGIAEqAgghByABKgIMIQggASoCOCEJIAEqAhQhCiABKgIYIQsgASoCHCEMIAEqAjwhDSABKgIkIQ4gASoCKCEPIAIqAgghAyABKgIsIRAgASoCBCERIAIqAgAhBCACKgIEIQUgAEEANgLkAiAAQpqz5vSDgIDAPzcC3AIgAEEAOgDYAiAAQgA3AsgCIAAgDSAEIA6UIAUgD5SSIAMgEJSSkjgCxAIgACAJIAQgCpQgBSALlJIgAyAMlJKSOALAAiAAIAYgBCARlCAFIAeUkiADIAiUkpI4ArwCC2kAIABBAyABIAIQRyAAQZDAADYCACAAIAMpAgA3AqwCIAAgAykCCDcCtAIgACAEKQIANwK8AiAAIAQpAgg3AsQCIABBADYC5AIgAEKas+b0g4CAwD83AtwCIABBADoA2AIgAEEANgLMAgvuBgAgACABIAIQZBogASAAKAIwNgI0IAEgACgCNDYCOCABIAAoAjg2AjwgASAAKAI8NgJAIAEgAEFAaygCADYCRCABIAAoAkQ2AkggASAAKAJINgJMIAEgACgCTDYCUCABIAAoAlA2AlQgASAAKAJUNgJYIAEgACgCWDYCXCABIAAoAlw2AmAgASAAKAJgNgJkIAEgACgCZDYCaCABIAAoAmg2AmwgASAAKAJsNgJwIAEgACgCcDYCdCABIAAoAnQ2AnggASAAKAJ4NgJ8IAEgACgCfDYCgAEgASAAKAKAATYChAEgASAAKAKEATYCiAEgASAAKAKIATYCjAEgASAAKAKMATYCkAEgASAAKAKQATYClAEgASAAKAKUATYCmAEgASAAKAKYATYCnAEgASAAKAKcATYCoAEgASAAKAKgATYCpAEgASAAKAKkATYCqAEgASAAKAKoATYCrAEgASAAKAKsATYCsAEgASAAKALkBjYC5AEgASAAKALoBjYC1AEgASAAKAKoBTYCxAEgASAAKAK4BTYCtAEgASAAKAKkBzYC6AEgASAAKAKoBzYC2AEgASAAKAKsBTYCyAEgASAAKAK8BTYCuAEgASAAKALkBzYC7AEgASAAKALoBzYC3AEgASAAKAKwBTYCzAEgASAAKALABTYCvAEgASAALQCUCjYC9AEgASAALQCVCjYC+AEgASAAKAKkCjYClAIgASAAKALUCjYCxAIgASAALQCdCjYC/AEgASAAKAK8CjYCrAIgASAAQagKaigCADYCmAIgASAAQdgKaigCADYCyAIgASAAQZ4Kai0AADYCgAIgASAAQcAKaigCADYCsAIgASAAQawKaigCADYCnAIgASAAQdwKaigCADYCzAIgASAAQZ8Kai0AADYChAIgASAAQcQKaigCADYCtAIgASAAQbAKaigCADYCoAIgASAAQeAKaigCADYC0AIgASAAQaAKai0AADYCiAIgASAAQcgKaigCADYCuAIgASAAQbQKaigCADYCpAIgASAAQeQKaigCADYC1AIgASAAQaEKai0AADYCjAIgASAAQcwKaigCADYCvAIgASAAQbgKaigCADYCqAIgASAAQegKaigCADYC2AIgASAAQaIKai0AADYCkAIgASAAQdAKaigCADYCwAJB5D8LBQBB3AIL1QgCAX8VfSAAKAIcIgMqAhQhBiADKgIkIQcgAyoCKCEIIAMqAhghCSADKgIIIQogAyoCPCEFIAMqAiwhCyADKgIcIQwgAyoCOCEUIAMqAjQhDSADKgIMIQ4gAioCCCEPIAIqAgAhECACKgIEIREgASoCCCESIAEqAgAhBCABKgIEIRUgAyoCBCETIABBADYCbCAAQQA2AlwgAEEANgJMIABBADYCPCAAIA5DAAAAAJQgDEMAAAAAlJIgC0MAAAAAlJIgDCAUjCIUlCAOIA2UkyALIAWUk5I4AmggACAKQwAAAACUIAlDAAAAAJSSIAhDAAAAAJSSIAkgFJQgCiANlJMgCCAFlJOSOAJkIAAgE0MAAAAAlCAGQwAAAACUkiAHQwAAAACUkiAGIBSUIBMgDZSTIAcgBZSTkjgCYCAAIA4gBEMAAIA/IAQgBJQgFSAVlJIgEiASlJKRlSIElCIFlCAMIBUgBJQiDZSSIAsgEiAElCISlJI4AlggACAOIBBDAACAPyAQIBCUIBEgEZSSIA8gD5SSkZUiBJQiEJQgDCARIASUIhGUkiALIA8gBJQiD5SSOAJUIAAgBSAKlCANIAmUkiASIAiUkjgCSCAAIBAgCpQgESAJlJIgDyAIlJI4AkQgACATIAWUIA0gBpSSIBIgB5SSOAI4IAAgByAPlCATIBCUIAYgEZSSkjgCNCAAIA4gEiARlCANIA+UkyIOlCAMIAUgD5QgEiAQlJMiDJSSIAsgDSAQlCAFIBGUkyILlJI4AlAgAEFAayALIAiUIAogDpQgCSAMlJKSOAIAIAAgByALlCATIA6UIAYgDJSSkjgCMCAAKAIgIgEqAjwhFiABKgI4IRggASoCNCEXIAEqAhQhBiABKgIkIQcgASoCKCEIIAEqAgghCSABKgIYIQogASoCLCETIAEqAgwhBCABKgIcIRUgASoCBCEUIABBADYCrAEgAEEANgKcASAAQQA2AowBIABBADYCfCAAIAUgBJQgDSAVlJIgEiATlJI4ApgBIAAgECAElCARIBWUkiAPIBOUkjgClAEgACAOIASUIAwgFZSSIAsgE5SSOAKQASAAIAUgCZQgDSAKlJIgEiAIlJI4AogBIAAgECAJlCARIAqUkiAPIAiUkjgChAEgACAOIAmUIAwgCpSSIAsgCJSSOAKAASAAIAUgFJQgDSAGlJIgEiAHlJI4AnggACAQIBSUIBEgBpSSIA8gB5SSOAJ0IAAgDiAUlCAMIAaUkiALIAeUkjgCcCAAIARDAAAAAJQgFUMAAAAAlJIgE0MAAAAAlJIgFSAYjCIFlCAEIBeUkyATIBaUk5I4AqgBIAAgCUMAAAAAlCAKQwAAAACUkiAIQwAAAACUkiAKIAWUIAkgF5STIAggFpSTkjgCpAEgACAUQwAAAACUIAZDAAAAAJSSIAdDAAAAAJSSIAYgBZQgFCAXlJMgByAWlJOSOAKgASAAENoCCxAAIAAgARDHDiAAIAEQ5AQL/AMBAn0gAC0AnQoEQCAAIAAqAugJIAAqAqQKkyAAKgK8CpQiAiABKgIAIAAqAtQKlCABKAIwspWUOAKYBiAAIAKLIAEqAgCVOAKoBgsgAEGeCmotAAAEQCAAIABB7AlqKgIAIABBqApqKgIAkyAAQcAKaioCAJQiAiABKgIAIABB2ApqKgIAlCABKAIwspWUOAKcBiAAIAKLIAEqAgCVOAKsBgsgAEGfCmotAAAEQCAAIABB8AlqKgIAIABBrApqKgIAkyAAQcQKaioCAJQiAiABKgIAIABB3ApqKgIAlCABKAIwspWUOAKgBiAAIAKLIAEqAgCVOAKwBgsgAEGgCmotAAAEQCAAIABByApqKgIAIAAqAqgJIABBsApqKgIAk4yUIgIgASoCACIDIABB4ApqKgIAlCABKAIwspWUOALsBiAAIAKLIAOVOALwBgsgAEGhCmotAAAEQCAAIABBzApqKgIAIABBrAlqKgIAIABBtApqKgIAk4yUIgIgASoCACIDIABB5ApqKgIAlCABKAIwspWUOAKsByAAIAKLIAOVOAKwBwsgAEGiCmotAAAEQCAAIABB0ApqKgIAIABBsAlqKgIAIABBuApqKgIAk4yUIgIgASoCACIDIABB6ApqKgIAlCABKAIwspWUOALsByAAIAKLIAOVOALwBwsLLQAgABDaAiAAIAFBAnRqIgBBpApqIABB6AlqIABBnAlqIAFBA0gbKAIANgIAC0YAIAAQ2gIgACAAKALoCTYCpAogAEGoCmogAEHsCWopAgA3AgAgAEGwCmogACgCqAk2AgAgAEG0CmogAEGsCWopAgA3AgALMwEBfyAAIAFqIgNBnQpqIAI6AAAgAUECTARAIAMgAjoAlAYPCyABQQZ0IABqIAI6ANAFC6oBACAAIAEgAiADEOYEIABBnQpqQQA2AAAgAEEJNgIEIABBhD82AgAgAEGhCmpBADsAACAAQaQKakIANwIAIABBrApqQgA3AgAgAEG0CmpCADcCACAAQbwKakIANwIAIABBxApqQgA3AgAgAEHMCmpCADcCACAAQeQKakKAgID8g4CAwD83AgAgAEHcCmpCgICA/IOAgMA/NwIAIABCgICA/IOAgMA/NwLUCguuAQAgACABIAIgAyAEIAUQ5wQgAEGdCmpBADYAACAAQQk2AgQgAEGEPzYCACAAQaEKakEAOwAAIABBpApqQgA3AgAgAEGsCmpCADcCACAAQbQKakIANwIAIABBvApqQgA3AgAgAEHECmpCADcCACAAQcwKakIANwIAIABB5ApqQoCAgPyDgIDAPzcCACAAQdwKakKAgID8g4CAwD83AgAgAEKAgID8g4CAwD83AtQKC5IEACAAIAEgAhBkGiABIAAoAjA2AjQgASAAKAI0NgI4IAEgACgCODYCPCABIAAoAjw2AkAgASAAQUBrKAIANgJEIAEgACgCRDYCSCABIAAoAkg2AkwgASAAKAJMNgJQIAEgACgCUDYCVCABIAAoAlQ2AlggASAAKAJYNgJcIAEgACgCXDYCYCABIAAoAmA2AmQgASAAKAJkNgJoIAEgACgCaDYCbCABIAAoAmw2AnAgASAAKAJwNgJ0IAEgACgCdDYCeCABIAAoAng2AnwgASAAKAJ8NgKAASABIAAoAoABNgKEASABIAAoAoQBNgKIASABIAAoAogBNgKMASABIAAoAowBNgKQASABIAAoApABNgKUASABIAAoApQBNgKYASABIAAoApgBNgKcASABIAAoApwBNgKgASABIAAoAqABNgKkASABIAAoAqQBNgKoASABIAAoAqgBNgKsASABIAAoAqwBNgKwASABIAAoAuQGNgLkASABIAAoAugGNgLUASABIAAoAqgFNgLEASABIAAoArgFNgK0ASABIAAoAqQHNgLoASABIAAoAqgHNgLYASABIAAoAqwFNgLIASABIAAoArwFNgK4ASABIAAoAuQHNgLsASABIAAoAugHNgLcASABIAAoArAFNgLMASABIAAoAsAFNgK8ASABIAAtAJQKNgL0ASABIAAtAJUKNgL4AUHgPgsFAEH8AQuxAQEBfSACQQJNBEAgAUF+aiIBQQJLBEBDAAAAAA8LAkACQAJAIAFBAWsOAgIBAAsgACACQQJ0aioC9AUPCyAAIAJBAnRqKgKEBg8LIAAgAkECdGoqAuQFDwsCQCACQX1qIgJBAksNACABQX5qIgFBAksNAAJAAkACQCABQQFrDgICAQALIAAgAkEGdGoqAoQHDwsgACACQQZ0aioCiAcPCyAAIAJBBnRqKgKAByEDCyADC5ICAQF/AkACQAJAIANBAk0EQCABQX5qIgFBAksNAQJAAkACQCABQQFrDgICAQALIAAgA0ECdGogAjgC9AUMBAsgACADQQJ0aiACOAKEBgwECyAAIANBAnRqIAI4AuQFIAAgACgCmApBASADQQNsdHI2ApgKDwsgA0F9aiIEQQJLDQAgAUF+aiIBQQJLDQACQAJAAkAgAUEBaw4CAgEACyAAIARBBnRqIAI4AoQHDAMLIAAgBEEGdGogAjgCiAcMAwsgACAEQQZ0aiACOAKAByAAIAAoApgKQQEgA0EDbHRyNgKYCgsPCyAAIAAoApgKQQQgA0EDbHRyNgKYCg8LIAAgACgCmApBAiADQQNsdHI2ApgKC6gBAQJ9QwAAgD8hASAAKAIgKgLYAiICQwAAAABcBEAgACgCHCoC2AIiASABIAKSlSEBCyAAQZAKakEANgIAIABBjApqIAEgAEHgCGoqAgCUQwAAgD8gAZMiAiAAQaAJaioCAJSSOAIAIABBiApqIAEgAEHcCGoqAgCUIAIgAEGcCWoqAgCUkjgCACAAIAEgAEHYCGoqAgCUIAIgAEGYCWoqAgCUkjgChAoLqQIBAn8CQCAALQCcCgRAIAFCADcCAAwBCyAAIAAoAhxBBGogACgCIEEEahCyASABQoCAgIDgADcCAAJ/AkAgACgC2AYNACAALQCUBg0AQQYhAkEADAELIAFCgYCAgNAANwIAQQUhAkEBCyEDQQAgACgC3AZFIAAtAJUGG0UEQCABIAJBf2oiAjYCBCABIANBAWoiAzYCAAtBACAAKALgBkUgAC0AlgYbRQRAIAEgAkF/ajYCBCABIANBAWo2AgALIABBABB/BEAgASABKAIAQQFqNgIAIAEgASgCBEF/ajYCBAsgAEEBEH8EQCABIAEoAgBBAWo2AgAgASABKAIEQX9qNgIECyAAQQIQf0UNACABIAEoAgBBAWo2AgAgASABKAIEQX9qNgIECwvLBQEEfyMAQTBrIgEkAAJAIAAtAJwKRQ0AIABBoAhqQQA2AgAgAEEANgLgByAAQQA2AqAHIABCADcCyAUgAEIANwLQBSAAIAAoAhxBBGogACgCIEEEahCyASAAIAAoAgAoAiwRAAAgASAAQYwKaiICKQIANwMoIAEgACkChAo3AyAgASACKQIANwMYIAEgACkChAo3AxAgACoCuAUgACoCqAVgQQFzRQRAIABBqAhqIABB6AhqIAAtAJQKIgIbKAIAIQMgAEG4CGogAEH4CGogAhsoAgAhBCAAQcgIaiAAQYgJaiACGygCACECIAFBADYCDCABIAI2AgggASAENgIEIAEgAzYCACAAIABBsAFqIAEgAUEgaiABQRBqENkCCyAAKgK8BSAAKgKsBWBBAXNFBEAgAEGsCGogAEHsCGogAC0AlAoiAhsoAgAhAyAAQbwIaiAAQfwIaiACGygCACEEIABBzAhqIABBjAlqIAIbKAIAIQIgAUEANgIMIAEgAjYCCCABIAQ2AgQgASADNgIAIAAgAEGEAmogASABQSBqIAFBEGoQ2QILIAAqAsAFIAAqArAFYEEBc0UEQCAAQbAIaiAAQfAIaiAALQCUCiICGygCACEDIABBwAhqIABBgAlqIAIbKAIAIQQgAEHQCGogAEGQCWogAhsoAgAhAiABQQA2AgwgASACNgIIIAEgBDYCBCABIAM2AgAgACAAQdgCaiABIAFBIGogAUEQahDZAgsgAEEAEH8EQCABIABBwAlqKQIANwMIIAEgACkCuAk3AwAgACAAQawDaiABENgCCyAAQQEQfwRAIAEgAEHQCWopAgA3AwggASAAQcgJaikCADcDACAAIABBgARqIAEQ2AILIABBAhB/RQ0AIAEgAEHgCWopAgA3AwggASAAQdgJaikCADcDACAAIABB1ARqIAEQ2AILIAFBMGokAAu5BQEQfSAAQfQJakEANgIAIABB8AlqIABBoAlqKgIAIABB4AhqKgIAkyIMIABBvAhqKgIAIgYgACoCqAgiApQgAEG4CGoqAgAiByAAQawIaioCACIDlJNDAACAPyAGIABB0AhqKgIAIgiUIABBwAhqKgIAIgkgAEHMCGoqAgAiCpSTIg8gApQgAyAJIABByAhqKgIAIguUIAggB5STIhCUkiAKIAeUIAYgC5STIgQgAEGwCGoqAgAiBZSSlSIBlJQgAEGYCWoqAgAgAEHYCGoqAgCTIg0gBCABlJQgAEGcCWoqAgAgAEHcCGoqAgCTIg4gCyADlCAKIAKUkyABlJSSkiIEOAIAIABB7AlqIAwgByAFlCAJIAKUkyABlJQgDSAQIAGUlCAOIAggApQgCyAFlJMgAZSUkpIiAjgCACAAIAwgCSADlCAGIAWUkyABlJQgDSAPIAGUlCAOIAogBZQgCCADlJMgAZSUkpIiATgC6AkgACABOALIBgJ9AkAgACoCqAUiAyAAKgK4BSIFXkEBc0UEQAwBCyADIAFeQQFzRQRAIABBAjYC2AYgASADkwwCCyAFIAFdQQFzRQRAIABBATYC2AYgASAFkwwCCwsgAEEANgLYBkMAAAAACyEBIAAgAjgCzAYgACABOAK4BgJ9IAAqAqwFIgEgACoCvAUiA15FBEACQCABIAJeRQRAIAMgAl1FBEAMAgsgAEEBNgLcBiACIAOTDAMLIABBAjYC3AYgAiABkwwCCwsgAEEANgLcBkMAAAAACyEBIAAgBDgC0AYgACABOAK8BiAAAn0gACoCsAUiASAAKgLABSICXkUEQAJAIAEgBF5FBEAgAiAEXUUEQAwCCyAAQQE2AuAGIAQgApMMAwsgAEECNgLgBiAEIAGTDAILCyAAQQA2AuAGQwAAAAALOALABgvHBwIGfxh9IwBBMGsiASQAIABBiAlqIgIqAgAhEiAAQfgIaiIDKgIAIRMgAEGMCWoqAgAhFCAAQewIaioCACEVIABB/AhqKgIAIRYgAEGQCWoqAgAhFyAAQfAIaioCACEYIABBgAlqKgIAIRkgAEGwCGoiBCoCACEJIABBvAhqKgIAIQ8gAEHMCGoqAgAhCyAAQawIaioCACEKIABByAhqKgIAIQwgAEHACGoiBSoCACEQIABBuAhqKgIAIQ0gAEHQCGoiBioCACEOIAAqAugIIRogACoCqAghCCABQQA2AiwgAUEANgIcIAEgGCALIA2UIA8gDJSTIgdDAACAPyAIIA8gDpQgECALlJMiHpQgCiAQIAyUIA4gDZSTIhGUkiAHIAmUkpUiB5QiG5QgGSAMIAqUIAsgCJSTIAeUIhyUkiAXIA8gCJQgDSAKlJMgB5QiHZSSOAIoIAEgFSAblCAcIBaUkiAdIBSUkjgCJCABIBggESAHlCIRlCAZIA4gCJQgDCAJlJMgB5QiDJSSIBcgDSAJlCAQIAiUkyAHlCIIlJI4AhggASAVIBGUIAwgFpSSIAggFJSSOAIUIAFBADYCDCABIBIgHZQgGiAblCATIByUkpI4AiAgASASIAiUIBogEZQgEyAMlJKSOAIQIAEgGCAeIAeUIgiUIBkgCyAJlCAOIAqUkyAHlCILlJIgFyAQIAqUIA8gCZSTIAeUIgeUkjgCCCABIAggFZQgCyAWlJIgByAUlJI4AgQgASASIAeUIBogCJQgEyALlJKSOAIAIAEgAEGoCWoQ1g4gAEHUCWpBADYCACAAQeQJakEANgIAIABBxAlqQQA2AgAgAEHQCWogAyoCACIIIAQqAgAiD5QgACoC6AgiCyAFKgIAIgyUkyIHQwAAgD8gByAHlCALIAYqAgAiEJQgAioCACINIA+UkyIJIAmUIA0gDJQgCCAQlJMiCiAKlJKSkZUiDpQ4AgAgAEHMCWogCSAOlDgCACAAQcgJaiAKIA6UOAIAIABB4AlqIAsgCZQgCCAKlJMiDkMAAIA/IAggB5QgDSAJlJMiCCAIlCANIAqUIAsgB5STIgsgC5SSIA4gDpSSkZUiDZQ4AgAgAEHcCWogCyANlDgCACAAQdgJaiAIIA2UOAIAIABBwAlqIAwgCpQgDyAJlJMiCEMAAIA/IBAgCZQgDCAHlJMiCSAJlCAPIAeUIBAgCpSTIgcgB5SSIAggCJSSkZUiCpQ4AgAgAEG8CWogByAKlDgCACAAIAkgCpQ4ArgJIAFBMGokAAu9AQECfQJAIAAqAiAiAkMAAIA/XUEBc0UEQCACQwAAgL9eQQFzRQRAIAEgACoCJIwgACoCKBBBOAIAIAEgACoCIEMAAIC/l0MAAIA/lhCnCjgCBCABIAAqAhCMIAAqAgAQQTgCCA8LIAAqAhQhAiAAKgIEIQMgAUHbn6T+ezYCBCABIAMgAhBBjDgCAAwBCyAAKgIUIQIgACoCBCEDIAFB25+k/gM2AgQgASADIAIQQTgCAAsgAUMAAAAAOAIICwcAQwAAAAALAwABC4MBAQF/IwBBIGsiAyQAIAMgADYCHCADIAE2AhggAyACOAIUAkBBsNUBLQAAQQFxDQBBsNUBEBBFDQAjAEEQa0Gg1QE2AgxBsNUBEA8LIAMgAygCHCADKAIYIAMqAhQQ5QRBoNUBIAMpAgA3AgBBqNUBIAMpAgg3AgAgA0EgaiQAQaDVAQsDAAELhQMBCn0gACoCACIJIAEqAgAiBpMiBSAFlCAAKgIEIgogASoCBCIFkyIHIAeUkiAAKgIIIgsgASoCCCIHkyIIIAiUkiAAKgIMIgwgASoCDCIIkyIEIASUkiAJIAaSIgQgBJQgCiAFkiIEIASUkiALIAeSIgQgBJSSIAwgCJIiBCAElJJdRQRAIAiMIQggB4whByAFjCEFIAaMIQYLIAMgCyAHlCAKIAWUIAkgBpQgCCAMlJKSkkMAAIC/l0MAAIA/lhA6IgQgBJI4AgAgAkEANgIMIAIgCSAFlCAHIAyUIAsgCJSTIAogBpSTkiIEOAIIIAIgCyAGlCAFIAyUIAogCJSTIAkgB5STkiINOAIEIAIgCiAHlCAGIAyUIAkgCJSTIAsgBZSTkiIGOAIAIAYgBpQgDSANlJIgBCAElJIiBUMAAIAoXUEBc0UEQCACQgA3AgggAkKAgID8AzcCAA8LIAIgBEMAAIA/IAWRlSIFlDgCCCACIA0gBZQ4AgQgAiAGIAWUOAIAC/ALAgp/GH0jAEHgAGsiAiQAIAAoAiAhBCAAKAIcIQUgASgCCCIDQYCAgPwDNgIAIAMgASgCGCIIQQFqQQJ0IgZqQYCAgPwDNgIAIAMgCEEBdCIKQQJqQQJ0IgtqQYCAgPwDNgIAIAUqAgghFCAFKgIMIQ4gBSoCFCEPIAUqAhghFSAFKgIcIRAgBSoCJCERIAUqAighEiAAKgI0IQwgBSoCLCEWIAAqAjghEyAFKgIEIRcgACoCMCENIAEoAgwiB0EANgIMIAdBADYCACAHIA0gEZQgDCASlJIgEyAWlJIiETgCBCAHIA0gD5QgDCAVlJIgEyAQlJIiD4w4AgggByAIQQJ0IglqIgNBADYCDCADIBcgDZQgFCAMlJIgDiATlJIiFDgCCCADQQA2AgQgAyARjDgCACAHIAhBA3RqIgNCADcCCCADIBSMOAIEIAMgDzgCACABKAIQIgMEQCADQYCAgPx7NgIAIAMgBmpBgICA/Hs2AgAgAyALakGAgID8ezYCAAsgBCoCCCEQIAQqAgwhEiAEKgIkIRUgBCoCKCEWIAQqAiwhFyAEKgIUIQ4gBCoCGCEYIAAqAkQhDCAEKgIcIRkgACoCSCETIAQqAgQhGiAAKgJAIQ0gASgCFCIDQQA2AgwgA0EANgIAIAMgDSAOlCAMIBiUkiATIBmUkiIOOAIIIAMgDSAVlCAMIBaUkiATIBeUkiIVjDgCBCADIAlqIgZBADYCDCAGIBogDZQgECAMlJIgEiATlJIiDIw4AgggBkEANgIEIAYgFTgCACADIApBAnQiCmoiBkIANwIIIAYgDDgCBCAGIA6MOAIAIAUqAjwhDSAEKgI8IRAgBSoCOCESIAQqAjghFiABKAIcIgYgASoCACABKgIElCITIAwgBCoCNJIgFJMgBSoCNJOUOAIAIAYgCWogEyAOIBaSIA+TIBKTlDgCACAGIApqIBMgFSAQkiARkyANk5Q4AgAgByAIQQNsIgZBAnRqQYCAgPwDNgIAIAcgCUEBciIJQQJ0akGAgID8AzYCACAHIAhBBWxBAmoiCEECdGpBgICA/AM2AgAgAwRAIAMgBkECdGpBgICA/Hs2AgAgAyAJQQJ0akGAgID8ezYCACADIAhBAnRqQYCAgPx7NgIACyAFKgIMIRcgBSoCBCEYIAUqAgghGSAFKgIcIRogBSoCFCEbIAUqAhghHCAFKgIsIR0gBSoCJCEeIAUqAighHyAEKgIMIQ0gBCoCBCERIAQqAhghFCAEKgIoIQ4gBCoCCCEPIAQqAiQhFSAEKgIcIRAgBCoCFCESIAQqAiwhFiACQQA2AkQgAkEANgI0IAJBQGsgHiAQIA+UIBQgDZSTQwAAgD8gESAUIBaUIBAgDpSTIiGUIA8gECAVlCAWIBKUkyIilJIgDSAOIBKUIBQgFZSTIiOUkpUiDJQiIJQgHyASIA2UIBAgEZSTIAyUIhCUkiAdIBQgEZQgEiAPlJMgDJQiFJSSOAIAIAIgHiAOIA2UIBYgD5STIAyUIhKUIB8gFiARlCAVIA2UkyAMlCINlJIgHSAVIA+UIA4gEZSTIAyUIhGUkjgCPCACICAgG5QgECAclJIgFCAalJI4AjAgAiASIBuUIA0gHJSSIBEgGpSSOAIsIAJBADYCJCACIB4gISAMlCIPlCAfICIgDJQiDpSSIB0gIyAMlCIMlJI4AjggAiAPIBuUIA4gHJSSIAwgGpSSOAIoIAIgFyAUlCAYICCUIBkgEJSSkjgCICACIBcgEZQgGCASlCAZIA2UkpI4AhwgAiAXIAyUIBggD5QgGSAOlJKSOAIYIAJBGGogAkEIahAmIABB0ABqIAJBCGogAkHQAGogAkHMAGoQ2w4gAiACKgJUIAIqAkyMIgyUOAJUIAIgAioCWCAMlDgCWCACIAIqAlAgDJQiDDgCUCABKAIcIgAgASgCGCIBQQxsaiATIAyUOAIAIAAgAUEEdGogEyACKgJUlDgCACAAIAFBFGxqIBMgAioCWJQ4AgAgAkHgAGokAAsOACABQoaAgIDgADcCAAv3AQIBfwh9IwBBIGsiBSQAIABBCyABIAIQRyAAQbQ9NgIAIAAgAykCMDcCMCAAIAMpAjg3AjggACAEKQIwNwJAIAAgBCkCODcCSCADIAVBEGoQJiAEIAUQJiAAIAUqAgwiBiAFKgIcIgeUIAUqAgAiCCAFKgIQIgmUkiAFKgIEIgogBSoCFCILlJIgBSoCCCIMIAUqAhgiDZSSOAJcIAAgCCALlCAGIA2UIAwgB5STIAogCZSTkjgCWCAAIAwgCZQgBiALlCAKIAeUkyAIIA2Uk5I4AlQgACAGIAmUIAggB5STIAwgC5STIAogDZSSOAJQIAVBIGokAAvaAgICfwx9QwAAgD8hBQJAIAEoAgAiAyAAKAJQRg0AIAMtAMwBQQRxDQAgACoCHCAAKgIMkyABKgIIlCAAKgIgIAAqAhCTIAEqAgyUkiAAKgIkIAAqAhSTIAEqAhCUkiAAKgJUjGANACABKAIoIQQgACADNgJMIAAgBDYCBAJAIAIEQCAAIAFBCGoiAikCADcCLCAAIAIpAgg3AjQMAQsgAyoCDCEIIAMqAgghCSADKgIcIQogAyoCFCELIAMqAhghDCADKgIsIQ0gAyoCJCEOIAMqAighDyADKgIEIRAgASoCECEFIAEqAgghBiABKgIMIQcgAEEANgI4IAAgBiAOlCAHIA+UkiAFIA2UkjgCNCAAIAYgC5QgByAMlJIgBSAKlJI4AjAgACAQIAaUIAkgB5SSIAggBZSSOAIsCyAAIAEpAhg3AjwgACABKQIgNwJEIAEqAighBQsgBQtOAQN/AkAgASgCACIDIAAoAlAiBEYNACAALwEKIAEvAQRxRQ0AIAEvAQYgAC8BCHFFDQAgACgCXCIAIAQgAyAAKAIAKAIcEQcAIQILIAILRwEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAgwhACACQwAAgD8gAigCCCoCAJU4AgQgACACQQRqENYEGiACQRBqJAALggoBCH8CQAJAIAVBAE4EQAJAIAAoAhAiBkEBTgRAIAAoAgwhCQNAIAkgB0ECdGoiCygCACIIKAIcKALQASIKIAgoAiAoAtABIApBf0obIAVGDQIgB0EBaiIHIAZIDQALC0EAIQsLQQAhCiAHIAZIBEAgACgCDCEJA0AgCiAJIAdBAnRqKAIAIggoAhwoAtABIgwgCCgCICgC0AEgDEF/ShsgBUZqIQogB0EBaiIHIAZHDQALCyAAKAIEIgUoAkhBAkgNAiACQQFIDQEgACgCJCEGIAAoAiAhB0EAIQgDQCABIAhBAnRqIQwCQCAGIAdHDQAgBiAGQQF0QQEgBhsiCU4EQCAGIQcMAQtBACEHQQAhBQJ/IAkEQEHo9wFB6PcBKAIAQQFqNgIAIAlBAnRBEEGM0gEoAgARAwAhBSAAKAIgIQYLIAZBAU4LBEADQCAFIAdBAnQiDWogACgCKCANaigCADYCACAHQQFqIgcgBkcNAAsLIAAoAigiBwRAIAAtACwEQCAHBEBB7PcBQez3ASgCAEEBajYCACAHQZDSASgCABEAAAsgACgCICEGCyAAQQA2AigLIAYhByAAIAU2AiggAEEBOgAsIAAgCTYCJCAJIQYLIAAoAiggB0ECdGogDCgCADYCACAAIAdBAWoiBzYCICAIQQFqIgggAkcNAAsMAQsgACgCCCIFIAEgAiADIAQgACgCDCAAKAIQIAAoAgQgACgCFCAAKAIYIAUoAgAoAgwRIwAaDwsgBEEBTgRAIAAoAjghBiAAKAI0IQdBACEIA0AgAyAIQQJ0aiEJAkAgBiAHRw0AIAYgBkEBdEEBIAYbIgFOBEAgBiEHDAELQQAhB0EAIQUCfyABBEBB6PcBQej3ASgCAEEBajYCACABQQJ0QRBBjNIBKAIAEQMAIQUgACgCNCEGCyAGQQFOCwRAA0AgBSAHQQJ0IgJqIAAoAjwgAmooAgA2AgAgB0EBaiIHIAZHDQALCyAAKAI8IgIEQCAALQBABEAgAgRAQez3AUHs9wEoAgBBAWo2AgAgAkGQ0gEoAgARAAALIAAoAjQhBgsgAEEANgI8CyAGIQcgACAFNgI8IABBAToAQCAAIAE2AjggASEGCyAAKAI8IAdBAnRqIAkoAgA2AgAgACAHQQFqIgc2AjQgCEEBaiIIIARHDQALCwJAIApFBEAgACgCSCEHDAELIAAoAkwhBiAAKAJIIQdBACEIA0AgCyAIQQJ0aiEDAkAgBiAHRw0AIAYgBkEBdEEBIAYbIgFOBEAgBiEHDAELQQAhB0EAIQUCfyABBEBB6PcBQej3ASgCAEEBajYCACABQQJ0QRBBjNIBKAIAEQMAIQUgACgCSCEGCyAGQQFOCwRAA0AgBSAHQQJ0IgJqIAAoAlAgAmooAgA2AgAgB0EBaiIHIAZHDQALCyAAKAJQIgIEQCAALQBUBEAgAgRAQez3AUHs9wEoAgBBAWo2AgAgAkGQ0gEoAgARAAALIAAoAkghBgsgAEEANgJQCyAGIQcgACAFNgJQIABBAToAVCAAIAE2AkwgASEGCyAAKAJQIAdBAnRqIAMoAgA2AgAgACAHQQFqIgc2AkggCEEBaiIIIApHDQALCyAAKAI0IAdqIAAoAgQoAkhKBEAgABDtBAsPCyAAKAIIIgYgASACIAMgBCALIAogBSAAKAIUIAAoAhggBigCACgCDBEjABoL7QEBAX8gAEH0OzYCACAAKAJQIgEEQCAALQBUBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AlALIABBADYCUCAAQgA3AkggAEEBOgBUIAAoAjwiAQRAIABBQGstAAAEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYCPAsgAEEANgI8IABCADcCNCAAQUBrQQE6AAACQCAAKAIoIgFFDQAgAC0ALEUNACABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIAAQDguEAgEBfyAAQfQ7NgIAIAAoAlAiAQRAIAAtAFQEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYCUAsgAEEANgJQIABCADcCSCAAQQE6AFQgACgCPCIBBEAgAEFAay0AAARAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgI8CyAAQQA2AjwgAEIANwI0IABBQGtBAToAACAAKAIoIgEEQCAALQAsBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AigLIABBADYCKCAAQgA3AiAgAEEBOgAsIAAL7gIBAn8gASABKAIAKAIgEQAAIAFB6ABBASABKAIAKAIQEQcAIgMoAghBAEHoABALIgIgACgC+AE2AlggAiAAKAL8ATYCXCACIAAoAoACNgJgIAIgACgChAI2AmQgAiAAKAJcNgIAIAIgACgCYDYCBCACIAAoAmQ2AgggAiAAKAJoNgIMIAIgACgCbDYCECACIAAoAnQ2AhQgAiAAKAJ4NgIYIAIgACgCfDYCHCACIAAoAoABNgIgIAIgACgChAE2AiQgAiAAKAKMATYCKCACIAAoApABNgIsIAIgACgClAE2AjAgAiAAKAKYATYCNCACIAAoAqgBNgI4IAIgACgCrAE2AjwgAiAAKAJwNgJAIAIgACgCnAE2AkQgAiAAKAKgATYCSCACIAAoAqQBNgJMIAIgACgCiAE2AlAgASADQYw7QcSusaIEIAIgASgCACgCFBEJACAAIAEQ6gQgACABEMACIAEgASgCACgCJBEAAAvGAgECfyABQegAQQEgASgCACgCEBEHACIDKAIIQQBB6AAQCyICIAAoAvgBNgJYIAIgACgC/AE2AlwgAiAAKAKAAjYCYCACIAAoAoQCNgJkIAIgACgCXDYCACACIAAoAmA2AgQgAiAAKAJkNgIIIAIgACgCaDYCDCACIAAoAmw2AhAgAiAAKAJ0NgIUIAIgACgCeDYCGCACIAAoAnw2AhwgAiAAKAKAATYCICACIAAoAoQBNgIkIAIgACgCjAE2AiggAiAAKAKQATYCLCACIAAoApQBNgIwIAIgACgCmAE2AjQgAiAAKAKoATYCOCACIAAoAqwBNgI8IAIgACgCcDYCQCACIAAoApwBNgJEIAIgACgCoAE2AkggAiAAKAKkATYCTCACIAAoAogBNgJQIAEgA0GMO0HErrGiBCACIAEoAgAoAhQRCQALCAAgACgC1AELCAAgACgCyAELUAEBfyAALQCRAgRAIAAoAsgBIgIEQEHs9wFB7PcBKAIAQQFqNgIAIAJBkNIBKAIAEQAACwsgACABNgLIASAAQQA6AJECIAAoAsQBIAE2AggLNAEBfyMAQRBrIgEkACABIAA2AgwgASABKAIMIgAQ4QI4AgggACABQQhqEOEOIAFBEGokAAvFCgIHfwh9IwBBsAJrIgIkAEGkOhAWIAAoAugBQQFOBEADQCAAKALwASAGQQJ0aigCACIDQYCAgPwDNgL0AQJAAkAgAygC2AFBfmoiBEEDSw0AIARBAWsOAgAAAQsgAy0AzAFBA3ENACADIAEgAkHwAWoQ8gECQCAALQAsRQ0AIAMqAvwBIgkgCZQiCUMAAAAAWw0AIAkgAioCoAIgAyoCNJMiCSAJlCACKgKkAiADKgI4kyIJIAmUkiACKgKoAiADKgI8kyIJIAmUkl1BAXMNAEG4OhAWIAMoAsABKAIEQRNMBEBBnNsBQZzbASgCAEEBajYCACAAKAJEIgQgBCgCACgCJBEBACEEIAAoAhghBSACQoCAgPyTgEA3ApQBIAIgAykCPDcCpAEgAiADKQI0NwKcASACIAIpAqgCNwK0ASACIAIpAqACNwKsASACQQA2AtwBIAJB6Dw2ApABIAIgBDYC6AEgAiAFNgLsASACQQA2AuQBIAIgAzYC4AEgAygC+AEhBSACQdgAaiIEQiM3AgQgBEGkkAE2AgAgBEGKro/pAzYCLCAEQoCAgPwDNwIUIARCgICA/IOAgMA/NwIMIARBpJEBNgIAIAIgBTYChAEgAiAFNgJ0IAJBCDYCXCACQcSCATYCWCACIAAoAjg2AuQBIAIgAygCvAEiBC8BBDsBmAEgAiAELwEGOwGaASACIAIpA/gBNwMgIAIgAikD8AE3AxggAiACKQKIAjcCMCACIAIpAoACNwIoIAIgAikCmAI3AkAgAiACKQKQAjcCOCACIAIpAqgCNwJQIAIgAikCoAI3AkggAiADQQRqIgQpAgg3AyAgAiAEKQIANwMYIAIgAykCHDcCMCACIAMpAhQ3AiggAiADKQIsNwJAIAIgAykCJDcCOCAAIAJB2ABqIAQgAkEYaiACQZABakMAAAAAEGIgAioClAEiCUMAAIA/XUEBc0UEQCADIAk4AvQBIAMgCSABlCACQfABahDyASADQQA2AvQBIAMgAkHwAWoQ3AIQEwwDCwsQEwsgAyACQfABahDcAgsgBkEBaiIGIAAoAugBSA0ACwsgAC0AkwIEQEHMOhAWIAAoArQCIgNBAU4EQANAIAAoArwCIAhBAnRqKAIAIgcoAuwFQQFOBEAgBygC6AUiAygC7AFBHnRBH3UgA3EhBSAHKALkBSIDKALsAUEedEEfdSADcSEEQQAhBgNAAkAgBCoC5AEgBSoC5AGUIgFDAAAAAF5BAXMNACAHIAZBuAFsaiIDKgJ8IglDAAAAAFsNACADKgJEIQogAyoCSCELIAMqAkwhDCACQQA2ApwBIAIgASAJIAyMlJQiDDgCmAEgAiABIAkgC4yUlCILOAKUASACIAEgCSAKjJSUIgE4ApABIAMqAjQhCSADKgI4IQogAyoCPCENIAQqAjQhDiAEKgI4IQ8gBCoCPCEQIAJBADYCJCACIA0gEJM4AiAgAiAKIA+TOAIcIAIgCSAOkzgCGCADKgIkIQkgAyoCKCEKIAMqAiwhDSAFKgI0IQ4gBSoCOCEPIAUqAjwhECACQQA2AmQgAiANIBCTOAJgIAIgCiAPkzgCXCACIAkgDpM4AlggBARAIAQgAkGQAWogAkEYahArIAIqApgBIQwgAioClAEhCyACKgKQASEBCyACQQA2AhQgAiAMjDgCECACIAuMOAIMIAIgAYw4AgggBSACQQhqIAJB2ABqECsLIAZBAWoiBiAHKALsBUgNAAsgACgCtAIhAwsgCEEBaiIIIANIDQALCxATCxATIAJBsAJqJAALjgUBCH9BsDkQFiAAKALMASIBIAAgACgCGCABKAIAKAIIEQUAIAAoArQCIgdBAU4EQCAAKAK8AiEIA0ACQCAIIAVBAnRqKAIAIgEoAuQFIgJFDQAgASgC6AUiAUUNACACKALMAUEDcQ0AIAEtAMwBQQNxDQAgASgC0AEhASAAKALMASgCECIDIAIoAtABIgJBA3RqIgYoAgAiBCACRwRAA0AgBiADIARBA3RqIgIoAgA2AgAgAigCACICIAMgAkEDdGoiBigCACIERw0ACwsgASADIAFBA3RqIgYoAgAiBEcEQANAIAYgAyAEQQN0aiIBKAIANgIAIAEoAgAiASADIAFBA3RqIgYoAgAiBEcNAAsLIAEgAkYNACADIAJBA3RqIgIgATYCACADIAFBA3RqIgEgASgCBCACKAIEajYCBAsgBUEBaiIFIAdHDQALCyAAKALUASIHQQFOBEAgACgC3AEhCEEAIQYDQAJAIAggBkECdGooAgAiAS0AFEUNACABKAIcIgItAMwBQQNxDQAgASgCICIBLQDMAUEDcQ0AIAEoAtABIQEgACgCzAEoAhAiAyACKALQASICQQN0aiIEKAIAIgUgAkcEQANAIAQgAyAFQQN0aiICKAIANgIAIAIoAgAiAiADIAJBA3RqIgQoAgAiBUcNAAsLIAEgAyABQQN0aiIEKAIAIgVHBEADQCAEIAMgBUEDdGoiASgCADYCACABKAIAIgEgAyABQQN0aiIEKAIAIgVHDQALCyABIAJGDQAgAyACQQN0aiICIAE2AgAgAyABQQN0aiIBIAEoAgQgAigCBGo2AgQLIAZBAWoiBiAHRw0ACwsgACgCzAEiASAAIAEoAgAoAgwRAgAQEwvRAwAgACAENgIUIAAgAzYCECAAIAI2AgwgACABNgIEIAAoAiAiAUF/TARAIAAoAiRBf0wEQCAAKAIoIgIEQCAALQAsBEAgAgRAQez3AUHs9wEoAgBBAWo2AgAgAkGQ0gEoAgARAAALCyAAQQA2AigLIABCADcCJCAAQQE6ACwLA0AgACgCKCABQQJ0akEANgIAIAFBAWoiAiABTyEDIAIhASADDQALCyAAQQA2AiAgACgCNCIBQX9MBEAgACgCOEF/TARAIAAoAjwiAgRAIABBQGstAAAEQCACBEBB7PcBQez3ASgCAEEBajYCACACQZDSASgCABEAAAsLIABBADYCPAsgAEIANwI4IABBQGtBAToAAAsDQCAAKAI8IAFBAnRqQQA2AgAgAUEBaiICIAFPIQMgAiEBIAMNAAsLIABBADYCNCAAKAJIIgFBf0wEQCAAKAJMQX9MBEAgACgCUCICBEAgAC0AVARAIAIEQEHs9wFB7PcBKAIAQQFqNgIAIAJBkNIBKAIAEQAACwsgAEEANgJQCyAAQgA3AkwgAEEBOgBUCwNAIAAoAlAgAUECdGpBADYCACABQQFqIgIgAU8hAyACIQEgAw0ACwsgAEEANgJIC60EAQd/IwBBEGsiBSQAQZ85EBYgACgCtAEiAiAAKALUASIESARAIAAoArgBIARIBEAgBAR/Qej3AUHo9wEoAgBBAWo2AgAgBEECdEEQQYzSASgCABEDACEGIAAoArQBBSACCyIDQQFOBEADQCAGIAdBAnQiCGogACgCvAEgCGooAgA2AgAgB0EBaiIHIANHDQALCyAAKAK8ASIDBEAgAC0AwAEEQCADBEBB7PcBQez3ASgCAEEBajYCACADQZDSASgCABEAAAsLIABBADYCvAELIAAgBjYCvAEgACAENgK4ASAAQQE6AMABCwNAIAAoArwBIAJBAnRqQQA2AgAgAkEBaiICIARHDQALCyAAIAQ2ArQBIAAgACgCACgCaBEBAEEBTgRAQQAhAgNAIAJBAnQiAyAAKAK8AWogACgC3AEgA2ooAgA2AgAgAkEBaiICIAAgACgCACgCaBEBAEgNAAsLIAAoArQBIgJBAk4EQCAAQbABaiAFQQhqQQAgAkF/ahDuBAsCf0EAIAAgACgCACgCaBEBAEUNABogACgCvAELIQIgACgCxAEgASACIAAoArQBIAAgACgCACgCFBEBABDtDiAAKALIASICIAAoAgggACgCGCIDIAMoAgAoAiQRAQAgAigCACgCCBEFACAAKALMASAAKAIYIAAgACgCxAEQnA0gACgCxAEQ7QQgACgCyAEiAiABIAAoAkggAigCACgCEBEFABATIAVBEGokAAt0AQR/AkAgACgCmAIiA0EBSA0AIAAoAqACIQQDQCABIAQgAkECdGoiBSgCAEcEQCACQQFqIgIgA0cNAQwCCwsgAiADTg0AIAUgBCADQX9qIgJBAnQiA2ooAgA2AgAgACgCoAIgA2ogATYCACAAIAI2ApgCCwuHAgEFfwJAIAAoApgCIgIgACgCnAJHDQAgAiACQQF0QQEgAhsiBE4NAAJ/IAQEQEHo9wFB6PcBKAIAQQFqNgIAIARBAnRBEEGM0gEoAgARAwAhBSAAKAKYAiECCyACQQFOCwRAA0AgBSADQQJ0IgZqIAAoAqACIAZqKAIANgIAIANBAWoiAyACRw0ACwsgACgCoAIiAwRAIAAtAKQCBEAgAwRAQez3AUHs9wEoAgBBAWo2AgAgA0GQ0gEoAgARAAALIAAoApgCIQILIABBADYCoAILIAAgBTYCoAIgACAENgKcAiAAQQE6AKQCCyAAKAKgAiACQQJ0aiABNgIAIAAgAkEBajYCmAILiAEBBH8CQCAAKALUASIDQQFIDQAgACgC3AEhBANAIAEgBCACQQJ0aiIFKAIARwRAIAJBAWoiAiADRw0BDAILCyACIANODQAgBSAEIANBf2oiAkECdCIDaigCADYCACAAKALcASADaiABNgIAIAAgAjYC1AELIAEoAhwgARD2BCABKAIgIAEQ9gQLoAIBBX8CQCAAKALUASIDIAAoAtgBRw0AIAMgA0EBdEEBIAMbIgVODQACfyAFBEBB6PcBQej3ASgCAEEBajYCACAFQQJ0QRBBjNIBKAIAEQMAIQYgACgC1AEhAwsgA0EBTgsEQANAIAYgBEECdCIHaiAAKALcASAHaigCADYCACAEQQFqIgQgA0cNAAsLIAAoAtwBIgQEQCAALQDgAQRAIAQEQEHs9wFB7PcBKAIAQQFqNgIAIARBkNIBKAIAEQAACyAAKALUASEDCyAAQQA2AtwBCyAAIAY2AtwBIAAgBTYC2AEgAEEBOgDgAQsgACgC3AEgA0ECdGogATYCACAAIANBAWo2AtQBIAIEQCABKAIcIAEQ9wQgASgCICABEPcECwvcAwIEfwF9QYk5EBYgACgC6AFBAU4EQANAAkAgACgC8AEgBEECdGooAgAiAkUNAAJAIAIoAtgBIgNBfmoiBUECTUEAIAVBAWsbRQRAAkAgAioCuAIiBiAGlCACKgK8AiIGIAaUkiACKgLAAiIGIAaUkiACKgLYAyIGIAaUXUEBcw0AIAIqAsgCIgYgBpQgAioCzAIiBiAGlJIgAioC0AIiBiAGlJIgAioC3AMiBiAGlF1BAXMNACACIAIqAtwBIAGSOALcAQwCCyACQQA2AtwBIAIoAtgBQX5xQQRHBEAgAkEANgLYAQsgAigC2AEhAwsgA0EERg0BCwJAQZTbAS0AAA0AQfjRASoCACIGQwAAAABbDQAgA0F+cUECR0EAIAIqAtwBIAZeQQFzGw0AIAItAMwBQQNxBEAgAigC2AFBfnFBBEcEQCACQQI2AtgBCwwCCyADQQFGBH8gAigC2AFBfnFBBEcEQCACQQM2AtgBCyACKALYAQUgAwtBAkcNASACQgA3AsgCIAJCADcCuAIgAkIANwLQAiACQgA3AsACIAIgAigChAJBAmo2AoQCDAELIAIoAtgBQX5xQQRHBEAgAkEBNgLYAQsLIARBAWoiBCAAKALoAUgNAAsLEBML8AIBBX8CQCABLQDMAUEDcQ0AIAEtAPgDQQFxDQAgASAAQfgBahDwAQsgASgCwAEEQAJAIAEtAMwBQQFxRQRAAkAgACgC6AEiBCAAKALsAUcNACAEIARBAXRBASAEGyIGTg0AAn8gBgRAQej3AUHo9wEoAgBBAWo2AgAgBkECdEEQQYzSASgCABEDACEHIAAoAugBIQQLIARBAU4LBEADQCAHIAVBAnQiCGogACgC8AEgCGooAgA2AgAgBUEBaiIFIARHDQALCyAAKALwASIFBEAgAC0A9AEEQCAFBEBB7PcBQez3ASgCAEEBajYCACAFQZDSASgCABEAAAsgACgC6AEhBAsgAEEANgLwAQsgACAHNgLwASAAIAY2AuwBIABBAToA9AELIAAoAvABIARBAnRqIAE2AgAgACAEQQFqNgLoAQwBCyABKALYAUF+cUEERwRAIAFBAjYC2AELCyAAIAEgAiADIAAoAgAoAiQRBAALC4MDAQV/AkAgAS0AzAFBA3ENACABLQD4A0EBcQ0AIAEgAEH4AWoQ8AELIAEoAsABBEACQCABLQDMAUEBcUUEQAJAIAAoAugBIgIgACgC7AFHDQAgAiACQQF0QQEgAhsiBE4NAAJ/IAQEQEHo9wFB6PcBKAIAQQFqNgIAIARBAnRBEEGM0gEoAgARAwAhBSAAKALoASECCyACQQFOCwRAA0AgBSADQQJ0IgZqIAAoAvABIAZqKAIANgIAIANBAWoiAyACRw0ACwsgACgC8AEiAwRAIAAtAPQBBEAgAwRAQez3AUHs9wEoAgBBAWo2AgAgA0GQ0gEoAgARAAALIAAoAugBIQILIABBADYC8AELIAAgBTYC8AEgACAENgLsASAAQQE6APQBCyAAKALwASACQQJ0aiABNgIAIAAgAkEBajYC6AEMAQsgASgC2AFBfnFBBEcEQCABQQI2AtgBCwsgACABQQJBASABKALMAUEDcSIBG0F9QX8gARsgACgCACgCJBEEAAsLewEEfwJAIAAoAugBIgNBAUgNACAAKALwASEEA0AgASAEIAJBAnRqIgUoAgBHBEAgAkEBaiICIANHDQEMAgsLIAIgA04NACAFIAQgA0F/aiICQQJ0IgNqKAIANgIAIAAoAvABIANqIAE2AgAgACACNgLoAQsgACABEKkBCw0AIAAgASACIAMQwgILGAAgACABKQL4ATcCACAAIAEpAoACNwIIC0MBAX8jAEEQayIEJAAgBCAANgIMIAQgATgCCCAEIAI4AgQgBCADOAIAIAQoAgwgBEEIaiAEQQRqIAQQCSAEQRBqJAALgAEBBH8gACABKQIANwL4ASAAIAEpAgg3AoACIAAoAugBIgNBAU4EQANAAkACQCAAKALwASACQQJ0aigCACIEKALYAUF+aiIFQQNLDQAgBUEBaw4CAAABCyAELQD4A0EBcQ0AIAQgARDwASAAKALoASEDCyACQQFqIgIgA0gNAAsLC0oBAn9B+zgQFiAAKAKYAkEBTgRAA0AgACgCoAIgAkECdGooAgAiAyAAIAEgAygCACgCCBELACACQQFqIgIgACgCmAJIDQALCxATC/cNAgp/E30jAEHQA2siAiQAQcs5EBZB5DkQFiAAKAK8AiEDIAAoArQCQQFOBEADQCAAKAIYIgQgAyAGQQJ0aigCACAEKAIAKAIQEQIAIAAoArwCIQMgBkEBaiIGIAAoArQCSA0ACwsgAwRAIAAtAMACBEAgAwRAQez3AUHs9wEoAgBBAWo2AgAgA0GQ0gEoAgARAAALCyAAQQA2ArwCCyAAQQA2ArwCIABCADcCtAIgAEEBOgDAAhATIAAoAugBQQFOBEAgAkFAayEKQQAhBgNAIAAoAvABIAZBAnRqKAIAIgRBgICA/AM2AvQBAkACQCAEKALYAUF+aiIDQQNLDQAgA0EBaw4CAAABCyAELQDMAUEDcQ0AIAQgASACQZADahDyASAALQAsRQ0AIAQqAvwBIgwgDJQiDEMAAAAAWw0AIAwgAioCwAMgBCoCNJMiDCAMlCACKgLEAyAEKgI4kyIMIAyUkiACKgLIAyAEKgI8kyIMIAyUkl1BAXMNAEGJOhAWIAQoAsABKAIEQRNMBEBBnNsBQZzbASgCAEEBajYCACAAKAJEIgMgAygCACgCJBEBACEDIAAoAhghBSACQoCAgPyTgEA3ArQCIAIgBCkCPDcCxAIgAiAEKQI0NwK8AiACIAIpAsgDNwLUAiACIAIpAsADNwLMAiACQQA2AvwCIAJB6Dw2ArACIAIgAzYCiAMgAiAFNgKMAyACQQA2AoQDIAIgBDYCgAMgBCgC+AEhBSACQfgBaiIDQiM3AgQgA0GkkAE2AgAgA0GKro/pAzYCLCADQoCAgPwDNwIUIANCgICA/IOAgMA/NwIMIANBpJEBNgIAIAIgBTYCpAIgAiAFNgKUAiACQQg2AvwBIAJBxIIBNgL4ASACIAAoAjg2AoQDIAIgBCgCvAEiAy8BBDsBuAIgAiADLwEGOwG6AiACIAIpA5gDNwPAASACIAIpA5ADNwO4ASACIAIpAqgDNwLQASACIAIpAqADNwLIASACIAIpArgDNwLgASACIAIpArADNwLYASACIAIpAsgDNwLwASACIAIpAsADNwLoASACIARBBGoiAykCCDcDwAEgAiADKQIANwO4ASACIAQpAhw3AtABIAIgBCkCFDcCyAEgAiAEKQIsNwLgASACIAQpAiQ3AtgBIAAgAkH4AWogAyACQbgBaiACQbACakMAAAAAEGIgAioCtAIiDEMAAIA/XUEBc0UEQCAMIAIqAsQDIAQqAjiTlCINIAIqAuACjJQgDCACKgLAAyAEKgI0k5QiDiACKgLcApSTIAwgAioCyAMgBCoCPJOUIg8gAioC5AKUkyEaIAAoAhgiAyAEIAIoAvwCIAMoAgAoAgwRBwAhBwJAIAAoArQCIgUgACgCuAJHDQAgBSAFQQF0QQEgBRsiCE4NAEEAIQNBACEJAn8gCARAQej3AUHo9wEoAgBBAWo2AgAgCEECdEEQQYzSASgCABEDACEJIAAoArQCIQULIAVBAU4LBEADQCAJIANBAnQiC2ogACgCvAIgC2ooAgA2AgAgA0EBaiIDIAVHDQALCyAAKAK8AiIDBEAgAC0AwAIEQCADBEBB7PcBQez3ASgCAEEBajYCACADQZDSASgCABEAAAsgACgCtAIhBQsgAEEANgK8AgsgACAJNgK8AiAAQQE6AMACIAAgCDYCuAILIAAoArwCIAVBAnRqIAc2AgAgACAFQQFqNgK0AiACKAL8AiIDKgIUIRIgAyoCJCETIAMqAighFCADKgIIIRUgAyoCGCEWIAMqAjwhDCADKgI4IRsgAyoCNCERIAMqAiwhFyADKgIMIRggAyoCHCEQIAMqAgQhGSAEKgI8IRwgBCoCNCEdIAQqAjghHiACQgA3AwggAkEANgIcIAJCADcDACACIBggDiAdkiIOlCAQIA0gHpIiDZSSIBcgDyAckiIPlJIgECAbjCIQlCAYIBGUkyAXIAyUk5I4AhggAiAOIBWUIA0gFpSSIA8gFJSSIBYgEJQgFSARlJMgFCAMlJOSOAIUIAIgDiAZlCANIBKUkiAPIBOUkiASIBCUIBkgEZSTIBMgDJSTkjgCECAKIAIpAtwCNwIAIAogAikC5AI3AgggAkEAOgB0IAJBADYCcCACQQA2AlwgAkIANwJUIAIgGjgCUCACQgA3ApABIAJCADcCiAEgAkIANwKAASACQgA3AnggByAHIAIQzQRBuAFsaiIDQQA2AmAgAyAEKgLgASACKAL8AioC4AGUQwAAIMGXQwAAIEGWOAJYIAMgBCkCNDcCNCADIAQpAjw3AjwgA0EANgIwIAMgDzgCLCADIA04AiggAyAOOAIkCwsQEwsgBkEBaiIGIAAoAugBSA0ACwsQEyACQdADaiQAC+gCAQJ/EMcKQc84EBYCQCACBEAgACADOAKMAiAAIAAqAogCIAGSIgE4AogCIAEgA2BBAXMNASAAIAECfyABIAOVIgGLQwAAAE9dBEAgAagMAQtBgICAgHgLIgSyIAOUkzgCiAIMAQsgAEEANgKMAiAAQwAAAAAgASAALQCsAhs4AogCIAEiA4tDAAAANF1BAXMiBCECCyAAIAAoAgAoAhQRAQAEQEGU2wEgACAAKAIAKAIUEQEAIgUgBSgCACgCMBEBAEEEdkEBcToAAAsCQCAEBEAgACADIAIgBCAEIAJKGyIFspQgACgCACgCpAERCAAgACAAKAIAKAKoAREAACAFQQFIDQFBACECA0AgACADIAAoAgAoAqABEQgAIAAgACgCACgCUBEAACACQQFqIgIgBUcNAAsMAQsgACAAKAIAKAJQEQAACyAAIAAoAgAoAngRAABB4PcBQeD3ASgCAEEBajYCABATIAQLrgMCBX8BfSMAQUBqIgMkAEG3OBAWAkAgAC0AkgIEQCAAKAIIIgRBAUgNAQNAAkAgACgCECACQQJ0aigCACIBRQ0AIAEoAuwBQQJxRQ0AIAEoAuADRQ0AIAEtAMwBQQNxDQAgAUHEAGogAUGEAWogAUGUAWoCfQJAIAAtAKwCRQ0AIAAqAowCIgZDAAAAAFsNACAAKgKIAiAGkwwBCyAAKgKIAiABKgL0AZQLIAMQVSABKALgAyIBIAMgASgCACgCDBECACAAKAIIIQQLIAJBAWoiAiAESA0ACwwBCyAAKALoASIEQQFIDQADQAJAAkAgACgC8AEgAkECdGooAgAiASgC2AFBfmoiBUEDSw0AIAVBAWsOAgAAAQsgASgC4ANFDQAgAS0AzAFBA3ENACABQcQAaiABQYQBaiABQZQBagJ9AkAgAC0ArAJFDQAgACoCjAIiBkMAAAAAWw0AIAAqAogCIAaTDAELIAAqAogCIAEqAvQBlAsgAxBVIAEoAuADIgEgAyABKAIAKAIMEQIAIAAoAugBIQQLIAJBAWoiAiAESA0ACwsQEyADQUBrJAALXQEEfyAAKALoASICQQFOBEADQAJAAkAgACgC8AEgAUECdGooAgAiAygC2AFBfmoiBEEDSw0AIARBAWsOAgAAAQsgAxD4BCAAKALoASECCyABQQFqIgEgAkgNAAsLC1IBAn8gACgC6AFBAU4EQANAIAAoAvABIAFBAnRqKAIAIgJCADcCnAMgAkIANwK0AyACQgA3AqwDIAJCADcCpAMgAUEBaiIBIAAoAugBSA0ACwsLiT4CCH8cfSMAQbABayICJAAgACAAKAIAKAIUEQEAIgMgAygCACgCMBEBACEDIAAgACgCACgCFBEBACIEIAQoAgAoAjARAQAhBQJAIAEqAigiH0MAAAAAXw0AIAEoAgRBfWoiBkEGSw0AIANBgBBxIQQgBUGAIHEhBQJAAkACQAJAAkAgBkEBaw4GAQIDBAUDAAsgAkIANwJ8IAJCADcDiAEgAkGAgID8AzYChAEgAkKAgID8AzcDmAEgAkIANwJ0IAJBgICA/AM2AnAgAkIANwOQASABKAIcIgMqAjQhDyADKgIIIQ4gAyoCDCERIAMqAjghDSADKgIcIRAgAyoCFCESIAMqAhghEyADKgI8IRUgASoCtAIhCiADKgIsIRYgASoCrAIhCyADKgIkIRcgASoCsAIhDCADKgIoIRQgAyoCBCEZIAJBADYCrAEgAiAVIAsgF5QgDCAUlJIgCiAWlJKSOAKoASACIA0gCyASlCAMIBOUkiAKIBCUkpI4AqQBIAIgDyALIBmUIAwgDpSSIAogEZSSkjgCoAEgACAAKAIAKAIUEQEAIgMgAkHwAGogHyADKAIAKAI4EQsAIAEoAiAiAyoCNCEPIAMqAgghDiADKgIMIREgAyoCOCENIAMqAhwhECADKgIUIRIgAyoCGCETIAMqAjwhFSABKgLEAiEKIAMqAiwhFiABKgK8AiELIAMqAiQhFyABKgLAAiEMIAMqAighFCADKgIEIRkgAkEANgKsASACIBUgCyAXlCAMIBSUkiAKIBaUkpI4AqgBIAIgDSALIBKUIAwgE5SSIAogEJSSkjgCpAEgAiAPIAsgGZQgDCAOlJIgCiARlJKSOAKgASAERQ0EIAAgACgCACgCFBEBACIAIAJB8ABqIB8gACgCACgCOBELAAwECyABKAIcIgMqAjQhICADKgIIIQogAyoCDCELIAEqAsgEIRMgASoCqAQhFSABKgK4BCEWIAMqAjghISADKgI8ISIgASoC4AQhFyABKgLYBCEUIAEqAtwEIRkgAyoCHCEMIAMqAhQhDyADKgIYIQ4gASoCzAQhHSABKgKsBCEYIAEqArwEIRogASoC0AQhGyADKgIsIREgASoCsAQhHiADKgIkIQ0gASoCwAQhHCADKgIoIRAgAyoCBCESIAJBADYCrAEgAkEANgKcASACQQA2AowBIAIgHiANlCAcIBCUkiAbIBGUkjgCmAEgAiAYIA2UIBogEJSSIB0gEZSSOAKUASACIB4gD5QgHCAOlJIgGyAMlJI4AogBIAIgGCAPlCAaIA6UkiAdIAyUkjgChAEgAiAiIA0gFJQgECAZlJIgESAXlJKSOAKoASACICEgDyAUlCAOIBmUkiAMIBeUkpI4AqQBIAJBADYCfCACIBUgDZQgFiAQlJIgEyARlJI4ApABIAIgFSAPlCAWIA6UkiATIAyUkjgCgAEgAiASIB6UIAogHJSSIAsgG5SSOAJ4IAIgEiAYlCAKIBqUkiALIB2UkjgCdCACIBUgEpQgFiAKlJIgEyALlJI4AnAgAiAgIBIgFJQgCiAZlJIgCyAXlJKSOAKgAQJAIAQEQCAAIAAoAgAoAhQRAQAiAyACQfAAaiAfIAMoAgAoAjgRCwAgASgCICIDKgI0ISAgAyoCOCEhIAMqAjwhIiABKgKgBSETIAEqApgFIRUgASoCnAUhFiADKgIIIQogAyoCDCELIAMqAhwhDCADKgIUIQ8gAyoCGCEOIAEqAogFIRcgASoC6AQhFCABKgL4BCEZIAEqAowFIR0gASoC7AQhGCABKgL8BCEaIAEqApAFIRsgAyoCLCERIAEqAvAEIR4gAyoCJCENIAEqAoAFIRwgAyoCKCEQIAMqAgQhEiACQQA2AqwBIAJBADYCnAEgAkEANgKMASACQQA2AnwgAiAeIA2UIBwgEJSSIBsgEZSSOAKYASACIBggDZQgGiAQlJIgHSARlJI4ApQBIAIgFCANlCAZIBCUkiAXIBGUkjgCkAEgAiAeIA+UIBwgDpSSIBsgDJSSOAKIASACIBggD5QgGiAOlJIgHSAMlJI4AoQBIAIgFCAPlCAZIA6UkiAXIAyUkjgCgAEgAiASIB6UIAogHJSSIAsgG5SSOAJ4IAIgEiAYlCAKIBqUkiALIB2UkjgCdCACIBQgEpQgGSAKlJIgFyALlJI4AnAgAiAiIA0gFZQgECAWlJIgESATlJKSOAKoASACICEgDyAVlCAOIBaUkiAMIBOUkpI4AqQBIAIgICASIBWUIAogFpSSIAsgE5SSkjgCoAEgACAAKAIAKAIUEQEAIgMgAkHwAGogHyADKAIAKAI4EQsADAELIAEoAiAiAyoCNCEgIAMqAjghISADKgI8ISIgASoCoAUhEyABKgKYBSEVIAEqApwFIRYgAyoCCCEKIAMqAgwhCyADKgIcIQwgAyoCFCEPIAMqAhghDiABKgKIBSEXIAEqAugEIRQgASoC+AQhGSABKgKMBSEdIAEqAuwEIRggASoC/AQhGiABKgKQBSEbIAMqAiwhESABKgLwBCEeIAMqAiQhDSABKgKABSEcIAMqAighECADKgIEIRIgAkEANgKsASACQQA2ApwBIAJBADYCjAEgAkEANgJ8IAIgHiANlCAcIBCUkiAbIBGUkjgCmAEgAiAYIA2UIBogEJSSIB0gEZSSOAKUASACIBQgDZQgGSAQlJIgFyARlJI4ApABIAIgHiAPlCAcIA6UkiAbIAyUkjgCiAEgAiAYIA+UIBogDpSSIB0gDJSSOAKEASACIBQgD5QgGSAOlJIgFyAMlJI4AoABIAIgEiAelCAKIByUkiALIBuUkjgCeCACIBIgGJQgCiAalJIgCyAdlJI4AnQgAiAUIBKUIBkgCpSSIBcgC5SSOAJwIAIgIiANIBWUIBAgFpSSIBEgE5SSkjgCqAEgAiAhIA8gFZQgDiAWlJIgDCATlJKSOAKkASACICAgEiAVlCAKIBaUkiALIBOUkpI4AqABCyABQbAFaiIBEOoBIgogARDrASILWw0DIAVFDQMgAiACKAJ4NgJgIAIgAigCiAE2AmQgAkEANgJsIAIgAigCmAE2AmggAiACKAJwNgJQIAIgAigCgAE2AlQgAkEANgJcIAIgAigCkAE2AlggACAAKAIAKAIUEQEAIQAgAkIANwNIIAJCADcDQCAAIAJBoAFqIAJB4ABqIAJB0ABqIB8gH0MAAAAAIAogCiALXiIBG0PbD8lAIAsgARsgAkFAayABQQFzQwAAIEEgACgCACgCPBEZAAwDCyABKAIcIgMqAjQhICADKgIIIQogAyoCDCELIAEqAswCIRMgASoCrAIhFSABKgK8AiEWIAMqAjghISADKgI8ISIgASoC5AIhFyABKgLcAiEUIAEqAuACIRkgAyoCHCEMIAMqAhQhDyADKgIYIQ4gASoC0AIhHSABKgKwAiEYIAEqAsACIRogASoC1AIhGyADKgIsIREgASoCtAIhHiADKgIkIQ0gASoCxAIhHCADKgIoIRAgAyoCBCESIAJBADYCrAEgAkEANgKcASACQQA2AowBIAIgHiANlCAcIBCUkiAbIBGUkjgCmAEgAiAYIA2UIBogEJSSIB0gEZSSOAKUASACIB4gD5QgHCAOlJIgGyAMlJI4AogBIAIgGCAPlCAaIA6UkiAdIAyUkjgChAEgAiAiIA0gFJQgECAZlJIgESAXlJKSOAKoASACICEgDyAUlCAOIBmUkiAMIBeUkpI4AqQBIAJBADYCfCACIBUgDZQgFiAQlJIgEyARlJI4ApABIAIgFSAPlCAWIA6UkiATIAyUkjgCgAEgAiASIB6UIAogHJSSIAsgG5SSOAJ4IAIgEiAYlCAKIBqUkiALIB2UkjgCdCACIBUgEpQgFiAKlJIgEyALlJI4AnAgAiAgIBIgFJQgCiAZlJIgCyAXlJKSOAKgAQJAIAQEQCAAIAAoAgAoAhQRAQAiAyACQfAAaiAfIAMoAgAoAjgRCwAgASgCICIDKgI0ISAgAyoCOCEhIAMqAjwhIiABKgKkAyETIAEqApwDIRUgASoCoAMhFiADKgIIIQogAyoCDCELIAMqAhwhDCADKgIUIQ8gAyoCGCEOIAEqAowDIRcgASoC7AIhFCABKgL8AiEZIAEqApADIR0gASoC8AIhGCABKgKAAyEaIAEqApQDIRsgAyoCLCERIAEqAvQCIR4gAyoCJCENIAEqAoQDIRwgAyoCKCEQIAMqAgQhEiACQQA2AqwBIAJBADYCnAEgAkEANgKMASACQQA2AnwgAiAeIA2UIBwgEJSSIBsgEZSSOAKYASACIBggDZQgGiAQlJIgHSARlJI4ApQBIAIgFCANlCAZIBCUkiAXIBGUkjgCkAEgAiAeIA+UIBwgDpSSIBsgDJSSOAKIASACIBggD5QgGiAOlJIgHSAMlJI4AoQBIAIgFCAPlCAZIA6UkiAXIAyUkjgCgAEgAiASIB6UIAogHJSSIAsgG5SSOAJ4IAIgEiAYlCAKIBqUkiALIB2UkjgCdCACIBQgEpQgGSAKlJIgFyALlJI4AnAgAiAiIA0gFZQgECAWlJIgESATlJKSOAKoASACICEgDyAVlCAOIBaUkiAMIBOUkpI4AqQBIAIgICASIBWUIAogFpSSIAsgE5SSkjgCoAEgACAAKAIAKAIUEQEAIgMgAkHwAGogHyADKAIAKAI4EQsADAELIAEoAiAiAyoCNCEgIAMqAjghISADKgI8ISIgASoCpAMhEyABKgKcAyEVIAEqAqADIRYgAyoCCCEKIAMqAgwhCyADKgIcIQwgAyoCFCEPIAMqAhghDiABKgKMAyEXIAEqAuwCIRQgASoC/AIhGSABKgKQAyEdIAEqAvACIRggASoCgAMhGiABKgKUAyEbIAMqAiwhESABKgL0AiEeIAMqAiQhDSABKgKEAyEcIAMqAighECADKgIEIRIgAkEANgKsASACQQA2ApwBIAJBADYCjAEgAkEANgJ8IAIgHiANlCAcIBCUkiAbIBGUkjgCmAEgAiAYIA2UIBogEJSSIB0gEZSSOAKUASACIBQgDZQgGSAQlJIgFyARlJI4ApABIAIgHiAPlCAcIA6UkiAbIAyUkjgCiAEgAiAYIA+UIBogDpSSIB0gDJSSOAKEASACIBQgD5QgGSAOlJIgFyAMlJI4AoABIAIgEiAelCAKIByUkiALIBuUkjgCeCACIBIgGJQgCiAalJIgCyAdlJI4AnQgAiAUIBKUIBkgCpSSIBcgC5SSOAJwIAIgIiANIBWUIBAgFpSSIBEgE5SSkjgCqAEgAiAhIA8gFZQgDiAWlJIgDCATlJKSOAKkASACICAgEiAVlCAKIBaUkiALIBOUkpI4AqABCyAFRQ0CIAJB4ABqIAFDW8fCQCAfEOAEIAJBADYCbCACIAIqAmAiCiACKgKQAZQgAioCZCILIAIqApQBlJIgAioCaCIMIAIqApgBlJIgAioCqAGSOAJoIAIgCiACKgKAAZQgCyACKgKEAZSSIAwgAioCiAGUkiACKgKkAZI4AmQgAiAKIAIqAnCUIAsgAioCdJSSIAwgAioCeJSSIAIqAqABkjgCYCACQaABaiEEQQAhAwNAIAJB0ABqIAEgA7JD2g/JQJRDAAAAPZQgHxDgBCACQQA2AlwgAiACKgJQIgogAioCkAGUIAIqAlQiCyACKgKUAZSSIAIqAlgiDCACKgKYAZSSIAIqAqgBkjgCWCACIAogAioCgAGUIAsgAioChAGUkiAMIAIqAogBlJIgAioCpAGSOAJUIAIgCiACKgJwlCALIAIqAnSUkiAMIAIqAniUkiACKgKgAZI4AlAgACAAKAIAKAIUEQEAIQUgAkIANwNIIAJCADcDQCAFIAJB4ABqIAJB0ABqIAJBQGsgBSgCACgCCBEEACADQQNxRQRAIAAgACgCACgCFBEBACEFIAJCADcDSCACQgA3A0AgBSAEIAJB0ABqIAJBQGsgBSgCACgCCBEEAAsgAiACKQNYNwNoIAIgAikDUDcDYCADQQFqIgNBIEcNAAsgASoCgAQhFSABKgLEAyEWAn0gASgCICIDKgLYAkMAAAAAXgRAIAMqAiQiCiABKgKcAyINlCADKgIoIgsgASoCoAMiEJSSIRcgAyoCFCIMIA2UIAMqAhgiDyAQlJIgAyoCHCIOIAEqAqQDIhSUkiEZIAMqAgQiESANlCADKgIIIg0gEJSSIAMqAgwiECAUlJIhHSABKgL0AiIYIAqUIAEqAoQDIhogC5SSIAEqApQDIhsgAyoCLCISlJIhHiABKgLwAiIcIAqUIAEqAoADIiAgC5SSIAEqApADIiEgEpSSIRMgASoC7AIiIiAKlCABKgL8AiIjIAuUkiABKgKMAyIkIBKUkiEKIBggDJQgGiAPlJIgGyAOlJIhJSAcIAyUICAgD5SSICEgDpSSIQsgIiAMlCAjIA+UkiAkIA6UkiEMIBEgGJQgDSAalJIgECAblJIhGCARIByUIA0gIJSSIBAgIZSSIQ8gIiARlCAjIA2UkiAkIBCUkiEOIBIgFJQMAQsgASgCHCIDKgIkIgogASoC3AIiDZQgAyoCKCILIAEqAuACIhCUkiEXIAMqAhQiDCANlCADKgIYIg8gEJSSIAMqAhwiDiABKgLkAiIUlJIhGSADKgIEIhEgDZQgAyoCCCINIBCUkiADKgIMIhAgFJSSIR0gASoCtAIiGCAKlCABKgLEAiIaIAuUkiABKgLUAiIbIAMqAiwiEpSSIR4gASoCsAIiHCAKlCABKgLAAiIgIAuUkiABKgLQAiIhIBKUkiETIAEqAqwCIiIgCpQgASoCvAIiIyALlJIgASoCzAIiJCASlJIhCiAYIAyUIBogD5SSIBsgDpSSISUgHCAMlCAgIA+UkiAhIA6UkiELICIgDJQgIyAPlJIgJCAOlJIhDCARIBiUIA0gGpSSIBAgG5SSIRggESAclCANICCUkiAQICGUkiEPICIgEZQgIyANlJIgJCAQlJIhDiASIBSUCyERIAMqAjQhDSADKgI4IRAgAyoCPCESIAJBADYCrAEgAkEANgKcASACIB44ApgBIAIgEzgClAEgAiAKOAKQASACQQA2AowBIAIgJTgCiAEgAiALOAKEASACIAw4AoABIAJBADYCfCACIBg4AnggAiAPOAJ0IAIgDjgCcCACIBIgFyARkpI4AqgBIAIgGSAQkjgCpAEgAiANIB2SOAKgASACIAQpAgg3A1ggAiAEKQIANwNQIAJBADYCTCACIAo4AkggAiAMOAJEIAIgDjgCQCACQQA2AjwgAiATOAI4IAIgCzgCNCACIA84AjAgACAAKAIAKAIUEQEAIQAgAkIANwMoIAJCADcDICAAIAJB0ABqIAJBQGsgAkEwaiAfIB8gFYwgFpMgFiAVkyACQSBqQQFDAAAgQSAAKAIAKAI8ERkADAILIAIgAUGwCGopAgA3A3ggAiABQagIaiIDKQIANwNwIAIgAUHACGopAgA3A4gBIAIgAUG4CGoiBikCADcDgAEgAiABQdAIaikCADcDmAEgAiABQcgIaiIIKQIANwOQASACIAFB4AhqKQIANwOoASACIAFB2AhqIgcpAgA3A6ABAkAgBARAIAAgACgCACgCFBEBACIEIAJB8ABqIB8gBCgCACgCOBELACACIAFB8AhqKQIANwN4IAIgAUHoCGopAgA3A3AgAiABQYAJaikCADcCiAEgAiABQfgIaikCADcCgAEgAiABQZAJaikCADcCmAEgAiABQYgJaikCADcCkAEgAiABQaAJaikCADcCqAEgAiABQZgJaikCADcCoAEgACAAKAIAKAIUEQEAIgQgAkHwAGogHyAEKAIAKAI4EQsADAELIAIgAUHwCGopAgA3A3ggAiABQegIaikCADcDcCACIAFBgAlqKQIANwKIASACIAFB+AhqKQIANwKAASACIAFBkAlqKQIANwKYASACIAFBiAlqKQIANwKQASACIAFBoAlqKQIANwKoASACIAFBmAlqKQIANwKgAQsgBUUNASACIAMpAgg3A3ggAiADKQIANwNwIAIgBikCCDcCiAEgAiAGKQIANwKAASACIAgpAgg3ApgBIAIgCCkCADcCkAEgAiAHKQIINwKoASACIAcpAgA3AqABIAIgAigCeDYCYCACIAIoAogBNgJkIAJBADYCbCACIAIoApgBNgJoIAIgAigCcDYCUCACIAIoAoABNgJUIAJBADYCXCACIAIoApABNgJYIAEqAugHIQogASoC5AchCyABKgKoByEMIAEqAqQHIQ8gACAAKAIAKAIUEQEAIQUgAkIANwNIIAJCADcDQCAFIAFBmAlqIgQgAkHgAGogAkHQAGogH0NmZmY/lCAPIAwgCyAKIAJBQGtDAAAgQUEBIAUoAgAoAkARHgAgAkEANgJcIAIgAigClAE2AlggAiACKAKEATYCVCACIAIoAnQ2AlAgAUGsCWoqAgAhDCACKgJQIQogAUGwCWoqAgAiDhAcIQsgAiACKgJUIg8gDhAdIg6UIAsgCpSTOAJEIAIgCiAOIAwQHCIRlJQgDyARIAuUlJIgAioCWCINIAwQHSIMlJI4AkggAiAKIAwgDpSUIA8gDCALlJSSIBEgDZSTOAJAIAIgAUHwCGopAgA3A3ggAiABQegIaikCADcDcCACIAFBgAlqKQIANwKIASACIAFB+AhqKQIANwKAASACIAFBkAlqKQIANwKYASACIAFBiAlqKQIANwKQASACIAQpAgA3AqABIAIgAUGgCWopAgA3AqgBIAJBADYCPCACIAIqApABjDgCOCACIAIqAoABjDgCNCACIAIqAnCMOAIwAkAgASoC5AYiCiABKgLoBiILXkEBc0UEQCAAIAAoAgAoAhQRAQAhBSACQgA3AyggAkIANwMgIAUgBCACQTBqIAJBQGsgHyAfQ9sPScBD2w9JQCACQSBqQQBDAAAgQSAFKAIAKAI8ERkADAELIAogC11BAXMNACAAIAAoAgAoAhQRAQAhBSACQgA3AyggAkIANwMgIAUgBCACQTBqIAJBQGsgHyAfIAogCyACQSBqQQFDAAAgQSAFKAIAKAI8ERkACyACIAMpAgg3A3ggAiADKQIANwNwIAIgBikCCDcCiAEgAiAGKQIANwKAASACIAgpAgg3ApgBIAIgCCkCADcCkAEgAiAHKQIINwKoASACIAcpAgA3AqABIAIgASkCsAU3AyggAiABKQKoBTcDICACIAEpAsAFNwMYIAIgASkCuAU3AxAgACAAKAIAKAIUEQEAIQAgAkIANwMIIAJCADcDACAAIAJBIGogAkEQaiACQfAAaiACIAAoAgAoAkgRCQAMAQsgAiABKQLABjcDeCACIAFBuAZqIgMpAgA3A3AgAiABKQLQBjcDiAEgAiABKQLIBjcDgAEgAiABKQLgBjcDmAEgAiABKQLYBjcDkAEgAiABKQLwBjcDqAEgAiABKQLoBjcDoAECQCAEBEAgACAAKAIAKAIUEQEAIgQgAkHwAGogHyAEKAIAKAI4EQsAIAIgASkCgAc3A3ggAiABKQL4BjcDcCACIAEpApAHNwKIASACIAEpAogHNwKAASACIAEpAqAHNwKYASACIAEpApgHNwKQASACIAEpArAHNwKoASACIAEpAqgHNwKgASAAIAAoAgAoAhQRAQAiBCACQfAAaiAfIAQoAgAoAjgRCwAMAQsgAiABKQKABzcDeCACIAEpAvgGNwNwIAIgASkCkAc3AogBIAIgASkCiAc3AoABIAIgASkCoAc3ApgBIAIgASkCmAc3ApABIAIgASkCsAc3AqgBIAIgASkCqAc3AqABCyAFRQ0AIAMgAUH4BmogAS0AtAEiBxsiAyoCMCELIAMqAgghDiADKAIEIQQgAyoCNCEMIAMqAhghESADKAIQIQUgAygCFCEGIAMqAjghDyADKgIoIQ0gAygCICEIIAMoAiQhAyABQbgGQfgGIAcbaigCACEHIAEqArgBIQogAkEANgJsIAIgDyANQwAAAACUIg0gA75DAAAAAJQiECAKIAi+IhKUkpKSOAJoIAIgDCARQwAAAACUIhEgBr5DAAAAAJQiEyAKIAW+IhWUkpKSOAJkIAIgCyAOQwAAAACUIg4gBL5DAAAAAJQiFiAKIAe+IheUkpKSOAJgIAEqArwBIQogAkEANgJcIAIgDyANIBAgCiASlJKSkjgCWCACIAwgESATIAogFZSSkpI4AlQgAiALIA4gFiAKIBeUkpKSOAJQIAAgACgCACgCFBEBACEJIAJCADcDSCACQgA3A0AgCSACQeAAaiACQdAAaiACQUBrIAkoAgAoAggRBAAgAkEANgJMIAIgCDYCSCACIAU2AkQgAiAHNgJAIAJBADYCPCACIAM2AjggAiAGNgI0IAIgBDYCMCABKgLEASEKIAEqAsABIQsgACAAKAIAKAIUEQEAIQAgAkIANwMoIAJCADcDICAAIAFBqAdqIAJBQGsgAkEwaiAfIB8gCyAKIAJBIGpBAUMAACBBIAAoAgAoAjwRGQALIAJBsAFqJAALZwEDfyAAKAIIIgRBAU4EQANAAkAgACgCECADQQJ0aigCACICRQ0AIAIoAuwBQQJxRQ0AIAIoAtgBQQJGDQAgAi0AzAFBAnFFDQAgAiABEI0PIAAoAgghBAsgA0EBaiIDIARIDQALCwspACAAENsCIgAEQEHs9wFB7PcBKAIAQQFqNgIAIABBkNIBKAIAEQAACwshACAAIAE2AsgBIAAgATYCwAEgACAAKAKEAkEBajYChAILjQEBAX8gAEGgNjYCACAAKALwAyIBBEAgAC0A9AMEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYC8AMLIABBADYC8AMgAEIANwLoAyAAQQE6APQDIABB5MoANgIAIAAEQEHs9wFB7PcBKAIAQQFqNgIAIABBkNIBKAIAEQAACwttAQF/IABBoDY2AgAgACgC8AMiAQRAIAAtAPQDBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AvADCyAAQQA2AvADIABCADcC6AMgAEEBOgD0AyAAQeTKADYCACAAC0sBAX8gASABIAAgACgCACgCEBEBAEEBIAEoAgAoAhARBwAiAiAAIAIoAgggASAAKAIAKAIUEQcAQdKEkcoFIAAgASgCACgCFBEJAAvHBQAgACABIAIQyAIaIAEgACgCiAI2AoACIAEgACgCjAI2AoQCIAEgACgCkAI2AogCIAEgACgClAI2AowCIAEgACgCmAI2ApACIAEgACgCnAI2ApQCIAEgACgCoAI2ApgCIAEgACgCpAI2ApwCIAEgACgCqAI2AqACIAEgACgCrAI2AqQCIAEgACgCsAI2AqgCIAEgACgCtAI2AqwCIAEgACgCuAI2ArACIAEgACgCvAI2ArQCIAEgACgCwAI2ArgCIAEgACgCxAI2ArwCIAEgACgCyAI2AsACIAEgACgCzAI2AsQCIAEgACgC0AI2AsgCIAEgACgC1AI2AswCIAEgACgC2AI2AsADIAEgACgCoAQ2AtACIAEgACgCpAQ2AtQCIAEgACgCqAQ2AtgCIAEgACgCrAQ2AtwCIAEgACgC3AI2AuACIAEgACgC4AI2AuQCIAEgACgC5AI2AugCIAEgACgC6AI2AuwCIAEgACgC7AI2AvACIAEgACgC8AI2AvQCIAEgACgC9AI2AvgCIAEgACgC+AI2AvwCIAEgACgC/AI2AoADIAEgACgCgAM2AoQDIAEgACgChAM2AogDIAEgACgCiAM2AowDIAEgACgCjAM2ApADIAEgACgCkAM2ApQDIAEgACgClAM2ApgDIAEgACgCmAM2ApwDIAEgACgCnAM2AqADIAEgACgCoAM2AqQDIAEgACgCpAM2AqgDIAEgACgCqAM2AqwDIAEgACgCrAM2ArADIAEgACgCsAM2ArQDIAEgACgCtAM2ArgDIAEgACgCuAM2ArwDIAEgACgCvAM2AsQDIAEgACgCwAM2AsgDIAEgAC0AxAM2AuQDIAEgACgCyAM2AswDIAEgACgCzAM2AtADIAEgACgC0AM2AtQDIAEgACgC1AM2AtgDIAEgACgC2AM2AtwDIAEgACgC3AM2AuADQbw2CwUAQegDC3UBBH9BASECAkAgAS0A7AFBAnFFDQAgAUUNACAAKALoAyIEQQFIDQAgACgC8AMhBUEAIQADQCAFIABBAnRqKAIAIgMtABQEQEEAIQIgAygCHCABRg0CIAMoAiAgAUYNAgtBASECIABBAWoiACAESA0ACwsgAgv5AwETfSABKgLQAiEFIAEqAiwhCiABKgIoIQwgASoCJCENIAEqAswCIQYgASoCHCEOIAEqAgwhByABKgKUAyEPIAEqAhghECABKgIIIQggASoCkAMhESABKgIUIRIgASoCyAIhAyABKgIEIRMgASoCjAMhBCAAQQA2AgwgACADIAMgEyASQwAAgD8gBJUiFJQiBJQgCCAQQwAAgD8gEZUiEZQiCZSSIAcgDkMAAIA/IA+VIg+UIguUkpQgBiAEIBKUIAkgEJSSIAsgDpSSlJIgBSAEIA2UIAkgDJSSIAsgCpSSlJIiFZQgBiADIBMgFCATlCIElCAIIBEgCJQiCZSSIAcgDyAHlCILlJKUIAYgBCASlCAJIBCUkiALIA6UkpSSIAUgBCANlCAJIAyUkiALIAqUkpSSIgmUkyIEOAIIIAAgBSAJlCADIAMgEyAUIA2UIgOUIAggESAMlCIIlJIgByAPIAqUIgeUkpQgBiADIBKUIAggEJSSIAcgDpSSlJIgBSADIA2UIAggDJSSIAcgCpSSlJIiCpSTIgM4AgQgACAGIAqUIAUgFZSTIgU4AgAgBCAElCAFIAWUIAMgA5SSkiIGIAIgApReQQFzRQRAIAAgBEMAAIA/IAaRlSAClCIClDgCCCAAIAMgApQ4AgQgACAFIAKUOAIACwuxBAEIfSAAIAAqArgCQwAAgD8gACoCvAMiCJMgARCkAiIClCIDOAK4AiAAIAIgACoCvAKUIgU4ArwCIAAgAiAAKgLAApQiAjgCwAIgACAAKgLIAkMAAIA/IAAqAsADIgmTIAEQpAIiBJQiATgCyAIgACAEIAAqAswClCIGOALMAiAAIAQgACoC0AKUIgQ4AtACAkAgAC0AxANFDQACQCABIAGUIAYgBpSSIAQgBJSSIAAqAtADXUEBcw0AIAMgA5QgBSAFlJIgAiAClJIgACoCzANdQQFzDQAgACAEIAAqAsgDIgeUIgQ4AtACIAAgBiAHlCIGOALMAiAAIAEgB5QiATgCyAIgACACIAeUIgI4AsACIAAgBSAHlCIFOAK8AiAAIAMgB5QiAzgCuAILAkAgAyADlCAFIAWUkiACIAKUkpEiByAIXUEBcw0AIAdDCtejO15BAXNFBEAgACACIAJDAACAPyAHlSIClEMK16M7lJM4AsACIAAgBSAFIAKUQwrXozuUkzgCvAIgACADIAMgApRDCtejO5STOAK4AgwBCyAAQgA3ArgCIABCADcCwAILIAEgAZQgBiAGlJIgBCAElJKRIgMgCV1BAXMNACADQwrXozteQQFzRQRAIAAgBCAEQwAAgD8gA5UiA5RDCtejO5STOALQAiAAIAYgBiADlEMK16M7lJM4AswCIAAgASABIAOUQwrXozuUkzgCyAIPCyAAQgA3AsgCIABCADcC0AILC+8CAgJ/BH0jAEEgayICJAAgAUMAAAAAXARAIAAoAuADIgMEQCADIABBBGogAygCACgCCBECAAsgAEEANgLEAiAAQwAAgD8gAZUiASAAKgI8IAAqAnyTlDgCwAIgACABIAAqAjggACoCeJOUOAK8AiAAIAEgACoCNCAAKgJ0k5Q4ArgCIABBxABqIABBBGogAkEQaiACQQxqEGYgAioCECEFIAIqAhQhBiACKgIYIQcgAioCDCEEIABBADYC1AIgACABIAQgB5SUOALQAiAAIAEgBCAGlJQ4AswCIAAgASAFIASUlDgCyAIgACAAKQLAAjcCjAEgACAAKQK4AjcChAEgACAAKQLIAjcClAEgACAAKQLQAjcCnAEgACAAKQIENwJEIAAgACkCDDcCTCAAIAApAhQ3AlQgACAAKQIcNwJcIAAgACkCLDcCbCAAIAApAiQ3AmQgACAAKQI8NwJ8IAAgACkCNDcCdAsgAkEgaiQAC4kBAQF/IwBBEGsiAyACOAIIIAMgATgCDCADQQA2AgQgA0GAgID8AzYCACAAIANBBGogAyADQQxqIAFDAACAP14bIAFDAAAAAF0bKAIANgK8AyADQQA2AgQgA0GAgID8AzYCACAAIANBBGogAyADQQhqIAJDAACAP14bIAJDAAAAAF0bKAIANgLAAwsuACAAEKoBIABBAToA9AMgAEGgNjYCACAAQQA2AvADIABCADcC6AMgACABEPoECyEAIAEoAggiACgCnAIiASAAIAIoAgggASgCACgCKBEFAAvYBQIKfwF+IwBBEGsiDCQAIANBA2whDSADQQFOBEAgDUEBIA1BAUobIQgDQCACIAVBAnRqKAIAIgkgBiAJIAZKGyEGIAVBAWoiBSAIRw0ACwsgBkEBaiIJIAlsIggEQAJ/Qej3AUHo9wEoAgBBAWo2AgAgCEEQQYzSASgCABEDACIKC0EAIAgQCxoLAkAgBkF/TARAQQAhCAwBC0EAIQVB6PcBQej3ASgCAEEBajYCACAJQQR0QRBBjNIBKAIAEQMAIQgDQCAIIAVBBHRqIgcgDCkCADcCACAHIAwpAgg3AgggBSAGRyEHIAVBAWohBSAHDQALIAZBA2xBA2oiBUEDIAVBA0obQX9qQQNuIQtBACEFQQAhBgNAIAEgBUECdGoiBykCACEPIAcoAgghDiAIIAZBBHRqIgdBADYCDCAHIA42AgggByAPNwIAIAVBA2ohBSAGIAtHIQcgBkEBaiEGIAcNAAsLQQAhBQJ/Qej3AUHo9wEoAgBBAWo2AgBB5AlBEEGM0gEoAgARAwALIAAgCSAIQQAQaiEAIANBAU4EQANAIAIgBUECdGoiAygCBCEBIAogAygCACIGIAlsIgcgAygCCCIDamoiCy0AAEUEQCALQQE6AAAgCiADIAlsIAZqakEBOgAAIAAgAyAGQQBBABAjCyAKIAEgCWwiCyAGamoiDi0AAEUEQCAOQQE6AAAgCiABIAdqakEBOgAAIAAgBiABQQBBABAjCyAKIAMgCWwgAWpqIgctAABFBEAgB0EBOgAAIAogAyALampBAToAACAAIAEgA0EAQQAQIwsgACAGIAEgA0EAEDYgBUEDaiIFIA1IDQALCyAEBEAgABDtAgsgCARAIAgEQEHs9wFB7PcBKAIAQQFqNgIAIAhBkNIBKAIAEQAACwsgCgRAIAoEQEHs9wFB7PcBKAIAQQFqNgIAIApBkNIBKAIAEQAACwsgDEEQaiQAIAAL7gMCBX8GfSMAQRBrIggkACADQQNqIQUCQCADQX5OBEBBACEDQej3AUHo9wEoAgBBAWo2AgAgBUEEdEEQQYzSASgCABEDACEGA0AgBiADQQR0aiIEIAgpAgA3AgAgBCAIKQIINwIIIANBAWoiAyAFRw0ACyAFsiELIAYhBANAQwAAAAAhCUMAAAA/IQogByIDBEADQCAJIAqSIAkgA0EBcRshCSAKQwAAAD+UIQogA0EBdSIDDQALCyAEQQA2AgwgBCAJIAmSQwAAgL+SIgk4AgggBCAHQQF0skPbD0lAlEPbD0lAkiALlSIKEBxDAACAPyAJIAmUk5EiCZQ4AgQgBCAKEB0gCZQ4AgAgBEEQaiEEIAdBAWoiByAFRw0ACyAFQQEgBUEBShshB0EAIQQDQCABKgIAIQkgAioCACEKIAEqAgQhCyACKgIEIQwgASoCCCENIAIqAgghDiAGIARBBHRqIgNBADYCDCADIA0gDiADKgIIlJI4AgggAyALIAwgAyoCBJSSOAIEIAMgCSAKIAMqAgCUkjgCACAEQQFqIgQgB0cNAAsgACAGIAVBARDfAiEDIAYEQEHs9wFB7PcBKAIAQQFqNgIAIAZBkNIBKAIAEQAACwwBCyAAQQAgBUEBEN8CIQMLIAhBEGokACADC80JAgp/CX0CQCAFQQJIDQAgBkECSA0AIAVBf2oiDLIhFyAGQX9qIg6yIRhB6PcBQej3ASgCAEEBajYCAEF/IAUgBmwiDUEEdCANQf////8AcSANRxtBEEGM0gEoAgARAwAhD0F/IA1BAnQgDUH/////A3EgDUcbEBIhEANAIAIqAggiFSAKsiAYlSIUIAQqAgggFZOUkiABKgIIIhUgFCADKgIIIBWTlJIiFZMhGiACKgIEIhYgFCAEKgIEIBaTlJIgASoCBCIWIBQgAyoCBCAWk5SSIhaTIRsgAioCACIZIBQgBCoCACAZk5SSIAEqAgAiGSAUIAMqAgAgGZOUkiIZkyEcIAUgCmwhEkEAIQsDQCAPIAsgEmoiE0EEdGoiEUEANgIMIBEgFSAaIAuyIBeVIhSUkjgCCCARIBYgGyAUlJI4AgQgESAZIBwgFJSSOAIAIBAgE0ECdGpBgICA/AM2AgAgC0EBaiILIAVHDQALIApBAWoiCiAGRw0ACwJ/Qej3AUHo9wEoAgBBAWo2AgBB5AlBEEGM0gEoAgARAwALIAAgDSAPIBAQaiEKIAdBAXEEQCAKKALQBUMAAAAAOAJYIApBAToAnAcLIAdBAnEEQCAKKALQBSAMQegAbGpDAAAAADgCWCAKQQE6AJwHCyAHQQRxBEAgCigC0AUgBSAObEHoAGxqQwAAAAA4AlggCkEBOgCcBwsgB0EIcQRAIAooAtAFIAwgBSAObGpB6ABsakMAAAAAOAJYIApBAToAnAcLIAdBEHEEQCAKKALQBSAMQQJtQegAbGpDAAAAADgCWCAKQQE6AJwHCyAHQSBxBEAgCigC0AUgDkECbSAFbEHoAGxqQwAAAAA4AlggCkEBOgCcBwsgB0HAAHEEQCAKKALQBSAMIA5BAm0gBWxqQegAbGpDAAAAADgCWCAKQQE6AJwHCyAHQYABcQRAIAooAtAFIAUgDmwgDEECbWpB6ABsakMAAAAAOAJYIApBAToAnAcLIAdBgAJxBEAgCigC0AUgDkECbSAFbCAMQQJtakHoAGxqQwAAAAA4AlggCkEBOgCcBwsgDwRAIA8EQEHs9wFB7PcBKAIAQQFqNgIAIA9BkNIBKAIAEQAACwsgEBAOQwAAgD8gGJUhGEMAAIA/IBeVIRVBACELQQAhAwNAIAtBAWohACAFQQFOBEAgACAFbCEMIAUgC2whDSAYIA4gC2uylCEUIBggDiALQX9zarKUIRdBACELA0AgCyIBIAxqIQIgCyANaiEEAkACQAJAIAtBAWoiCyAFSARAIAogBCALIA1qIg9BAEEAECMgACAGTg0DIAogBCACQQBBABAjIAogBCACIAsgDGoiB0EAEDYgCUUNASAJIANBAnRqIgIgFSABspQiGjgCACACIBc4AhQgAiAVIAuylCIWOAIQIAIgFzgCDCACIBo4AgggAiAUOAIEIAogByAPIARBABA2IAIgFDgCLCACIBo4AiggAiAUOAIkIAIgFjgCICACIBc4AhwgAiAWOAIYDAILIAAgBk4NAiAKIAQgAkEAQQAQIwwCCyAKIAcgDyAEQQAQNgsgCARAIAogBCAHQQBBABAjCyADQQxqIQMLIAUgC0cNAAsLIAAiCyAGRw0ACwsgCgv2BgIKfwl9AkAgBUECSA0AIAZBAkgNACAFQX9qIg+yIRcgBkF/aiIQsiEYQej3AUHo9wEoAgBBAWo2AgBBfyAFIAZsIglBBHQgCUH/////AHEgCUcbQRBBjNIBKAIAEQMAIQtBfyAJQQJ0IAlB/////wNxIAlHGxASIQwDQCACKgIIIhQgDbIgGJUiEyAEKgIIIBSTlJIgASoCCCIUIBMgAyoCCCAUk5SSIhSTIRkgAioCBCIVIBMgBCoCBCAVk5SSIAEqAgQiFSATIAMqAgQgFZOUkiIVkyEaIAIqAgAiFiATIAQqAgAgFpOUkiABKgIAIhYgEyADKgIAIBaTlJIiFpMhGyAFIA1sIRFBACEKA0AgCyAKIBFqIhJBBHRqIg5BADYCDCAOIBQgGSAKsiAXlSITlJI4AgggDiAVIBogE5SSOAIEIA4gFiAbIBOUkjgCACAMIBJBAnRqQYCAgPwDNgIAIApBAWoiCiAFRw0ACyANQQFqIg0gBkcNAAsCf0Ho9wFB6PcBKAIAQQFqNgIAQeQJQRBBjNIBKAIAEQMACyAAIAkgCyAMEGohCSAHQQFxBEAgCSgC0AVDAAAAADgCWCAJQQE6AJwHCyAHQQJxBEAgCSgC0AUgD0HoAGxqQwAAAAA4AlggCUEBOgCcBwsgB0EEcQRAIAkoAtAFIAUgEGxB6ABsakMAAAAAOAJYIAlBAToAnAcLIAdBCHEEQCAJKALQBSAPIAUgEGxqQegAbGpDAAAAADgCWCAJQQE6AJwHCyALBEAgCwRAQez3AUHs9wEoAgBBAWo2AgAgC0GQ0gEoAgARAAALCyAMEA4gBUEASiENQQAhAwNAIAYgDQR/IAMgBWwhDCADQQFqIgsgBWwhAkEAIQoDQCAKIgAgDGohAQJAAkAgCkEBaiIKIAVIBEAgCSABIAogDGoiBEEAQQAQIyALIAZODQIgCSABIAAgAmoiB0EAQQAQIyAAIANqQQFxRQ0BIAkgASAEIAIgCmoiAEEAEDYgCSABIAAgB0EAEDYgCEUNAiAJIAEgAEEAQQAQIwwCCyALIAZODQEgCSABIAAgAmpBAEEAECMMAQsgCSAHIAEgBEEAEDYgCSAHIAQgAiAKakEAEDYgCEUNACAJIAQgB0EAQQAQIwsgBSAKRw0ACyALBSADQQFqCyIDRw0ACwsgCQvZAwIGfwh9Qej3AUHo9wEoAgBBAWo2AgBBfyADQQJqIgVBBHQgBUH/////AHEgBUcbQRBBjNIBKAIAEQMAIQdBfyAFQQJ0IAVB/////wNxIAVHGxASIQggA0F/TgRAIAVBASAFQQFKGyEKIANBAWqyIQ8DQCACKgIAIRAgASoCACELIAIqAgQhESABKgIEIQwgAioCCCESIAEqAgghDSAHIAZBBHRqIglBADYCDCAJIA0gBrIgD5UiDiASIA2TlJI4AgggCSAMIA4gESAMk5SSOAIEIAkgCyAOIBAgC5OUkjgCACAIIAZBAnRqQYCAgPwDNgIAIAZBAWoiBiAKRw0ACwsCf0Ho9wFB6PcBKAIAQQFqNgIAQeQJQRBBjNIBKAIAEQMACyAAIAUgByAIEGohACAEQQFxBEAgACgC0AVDAAAAADgCWCAAQQE6AJwHCyAEQQJxBEAgACgC0AUgA0EBakHoAGxqQwAAAAA4AlggAEEBOgCcBwsgBwRAIAcEQEHs9wFB7PcBKAIAQQFqNgIAIAdBkNIBKAIAEQAACwsgCBAOIANBAE4EQCAFQQIgBUECShshAUEBIQYDQCAAIAZBf2ogBkEAQQAQIyAGQQFqIgYgAUcNAAsLIAAL9woCA38YfSMAQUBqIgIkAAJAIAAtANkDRQ0AIAIgACkCkAQ3AxggAiAAKQKIBDcDECAAKgLABCEJIAAqArgEIQsgACoCvAQhBSAAKgKgBCEOIAAqApgEIQwgACoCnAQhByAAKgLwBCETIAAqAtAEIQ8gACoC4AQhBiAAKgLsBCEUIAAqAswEIRUgACoC3AQhFiAAKgLoBCEQIAAqArAEIRcgACoCyAQhESAAKgKoBCESIAAqAtgEIQggACoCrAQhDSACQQA2AjwgAiACKgIYIA8gC5QgBiAFlJIgEyAJlJIiGEMAAAAAlCIKIBEgC5QgCCAFlJIgECAJlJIiGSAVIAuUIBYgBZSSIBQgCZSSIhpDAAAAAJQiCZKSIgVDAACAPyARIAyUIAggB5SSIBAgDpSSIhsgDCAVlCAHIBaUkiAOIBSUkiIcQwAAAACUIguSIAwgD5QgByAGlJIgDiATlJIiDkMAAAAAlCIHkiIMIAyUIA8gEpQgBiANlJIgEyAXlJIiD0MAAAAAlCIGIBEgEpQgCCANlJIgECAXlJIiECAVIBKUIBYgDZSSIBQgF5SSIhFDAAAAAJQiDZKSIgggCJSSIAUgBZSSkZUiBZRDAAAgQZSSOAI4IAIgAioCFCAIIAWUQwAAIEGUkjgCNCACIAIqAhAgDCAFlEMAACBBlJI4AjAgAkIANwMoIAJCgICA/AM3AyAgASACQRBqIAJBMGogAkEgaiABKAIAKAIIEQQAIAJBADYCPCACIAogGiAZQwAAAACUIgWSkiISQwAAgD8gG0MAAAAAlCIKIBySIAeSIgwgDJQgBiARIBBDAAAAAJQiBpKSIgggCJSSIBIgEpSSkZUiB5RDAAAgQZQgAioCGJI4AjggAiAIIAeUQwAAIEGUIAIqAhSSOAI0IAIgDCAHlEMAACBBlCACKgIQkjgCMCACQgA3AyggAkKAgICAgICAwD83AyAgASACQRBqIAJBMGogAkEgaiABKAIAKAIIEQQAIAJBADYCPCACIBggBSAJkpIiB0MAAIA/IAogC5IgDpIiBSAFlCAPIAYgDZKSIgogCpSSIAcgB5SSkZUiBpRDAAAgQZQgAioCGJI4AjggAiAKIAaUQwAAIEGUIAIqAhSSOAI0IAIgBSAGlEMAACBBlCACKgIQkjgCMCACQoCAgPwDNwMoIAJCADcDICABIAJBEGogAkEwaiACQSBqIAEoAgAoAggRBAAgACgC5ANBAUgNAANAIAAoAuwDIANBBHRqIgQqAgghCyAEKgIAIQcgBCoCBCENIAIqAhAhBSACKgIUIQogAioCGCEGIAJCgICA/AM3AwggAkKAgID8AzcDACACQQA2AjwgAiAGIBkgB5QgGiANlJIgGCALlJKSIgg4AjggAiAKIBAgB5QgESANlJIgDyALlJKSIgk4AjQgAiAFIBsgB5QgHCANlJIgDiALlJKSIgVDzczMvZI4AjAgAkEANgIsIAIgCEMAAAAAkiIGOAIoIAIgCUMAAAAAkiIKOAIkIAIgBUPNzMw9kjgCICABIAJBMGogAkEgaiACIAEoAgAoAggRBAAgAkEANgI8IAIgCDgCOCACIAlDzczMvZI4AjQgAiAFOAIwIAJBADYCLCACIAY4AiggAiAJQ83MzD2SOAIkIAIgBUMAAAAAkiIGOAIgIAEgAkEwaiACQSBqIAIgASgCACgCCBEEACACQQA2AjwgAiAIQ83MzL2SOAI4IAIgCTgCNCACIAU4AjAgAkEANgIsIAIgCEPNzMw9kjgCKCACIAo4AiQgAiAGOAIgIAEgAkEwaiACQSBqIAIgASgCACgCCBEEACADQQFqIgMgACgC5ANIDQALCyACQUBrJAALWwEBfyMAQSBrIgIkACAAKAKYCCEAIAJCgICA/AM3AxggAkKAgICAgICAwD83AxAgAkIANwMIIAJCgICA/AM3AwAgASAAQQAgAkEQaiACQQBBfxBWIAJBIGokAAtXAQF/IwBBIGsiAiQAIAAoAtwHIQAgAkIANwMYIAJCgICAgICAgMA/NwMQIAJCADcDCCACQoCAgPwDNwMAIAEgAEEAIAJBEGogAkEAQX8QViACQSBqJAALXwEBfyMAQSBrIgIkACAAKAKgByEAIAJCgICA/AM3AxggAkKAgID8AzcDECACQoCAgPwDNwMIIAJCgICA/IOAgMA/NwMAIAEgAEEAIAJBEGogAkEAQX8QViACQSBqJAAL4UQDCn8Bfhh9IwBBsAFrIgMkACADQgA3A5gBIANCADcDkAEgA0KAgID8AzcDiAEgA0KAgID8g4CAwD83A4ABIANCADcDeCADQoCAgPwDNwNwAkAgAkGAAnEEQEHw9wFCjQ43AwAgAEHYCGooAgAiB0EBSA0BA0AgC0ECdCIFIAAoAuAIaigCAC0A+QIEQEHw9wFB8PcBKQMAQq3+1eTUhf2o2AB+QgF8Ig03AwAgDUIhiKchBEHw9wFB8PcBKQMAQq3+1eTUhf2o2AB+QgF8Ig03AwAgDUIhiKchBkHw9wFB8PcBKQMAQq3+1eTUhf2o2AB+QgF8Ig03AwAgAyANQiGIp7JDAAAAMJQiDkMAAIA/IA4gDpQgBLJDAAAAMJQiDiAOlCAGskMAAAAwlCIPIA+UkpKRlSIQlEMAAEA/lDgCqAEgAyAPIBCUQwAAQD+UOAKkASADIA4gEJRDAABAP5Q4AqABIANBADYCrAECQCAAKALgCCAFaigCACgCGCIEQQBMBEBBACEGDAELQQAhB0Ho9wFB6PcBKAIAQQFqNgIAIARBBHRBEEGM0gEoAgARAwAhBgNAIAYgB0EEdGoiCCADKQIwNwIAIAggAykCODcCCCAHQQFqIgcgBEcNAAtBACEHA0AgBiAHQQR0aiIIIAAoAuAIIAVqKAIAKAIgIAdBAnRqKAIAIgkpAgg3AgAgCCAJKQIQNwIIIAdBAWoiByAERw0ACwtBACEKIANBADYCPCADQQE6AEAgA0EBOgBUIANCADcCNCADQQA2AlAgA0EBOgBoIANCADcDSCADQQA2AmQgA0IANwJcIANBMGogBiAEEKYCIAMoAlwiBUEASgRAA0AgAygCUCADKAJkIApBAnRqKAIAQQxsaiIJIAkoAgRBDGxqIgQgBCgCAEEMbGoiByAJRwRAIAQoAgghBSAJKAIIIQQDQCABIAMoAjwiDCAFQQR0aiAMIARBBHRqIAwgBygCCCIIQQR0aiADQaABakMAAIA/IAEoAgAoAhwREwAgBCEFIAghBCAHIAcoAgRBDGxqIgggCCgCAEEMbGoiByAJRw0ACyADKAJcIQULIApBAWoiCiAFSA0ACwsgAygCZCIEBEAgAy0AaARAIAQEQEHs9wFB7PcBKAIAQQFqNgIAIARBkNIBKAIAEQAACwsgA0EANgJkCyADQQA2AmQgA0EBOgBoIANCADcCXCADKAJQIgQEQCADLQBUBEAgBARAQez3AUHs9wEoAgBBAWo2AgAgBEGQ0gEoAgARAAALCyADQQA2AlALIANBADYCUCADQQE6AFQgA0IANwNIIAMoAjwiBARAIAMtAEAEQCAEBEBB7PcBQez3ASgCAEEBajYCACAEQZDSASgCABEAAAsLIANBADYCPAsgBgRAIAYEQEHs9wFB7PcBKAIAQQFqNgIAIAZBkNIBKAIAEQAACwsgACgC2AghBwsgC0EBaiILIAdIDQALDAELAkAgAkEBcUUNACAAKALIBSIFQQFIDQADQCAAKALQBSAEQegAbGoiBigCBC0AEEEBcQRAIAYqAgghDiADIAYpAgw3AjQgA0EANgI8IAMgDkPNzMy9kjgCMCAGKgIIIQ4gBioCDCEPIAYqAhAhECADQQA2AqwBIAMgEEMAAAAAkjgCqAEgAyAPQwAAAACSOAKkASADIA5DzczMPZI4AqABIANCADcDKCADQoCAgPwDNwMgIAEgA0EwaiADQaABaiADQSBqIAEoAgAoAggRBAAgBioCDCEOIAYoAgghBSAGKAIQIQggA0EANgI8IAMgCDYCOCADIAU2AjAgAyAOQ83MzL2SOAI0IAYqAgghDiAGKgIMIQ8gBioCECEQIANBADYCrAEgAyAQQwAAAACSOAKoASADIA9DzczMPZI4AqQBIAMgDkMAAAAAkjgCoAEgA0IANwMoIANCgICAgICAgMA/NwMgIAEgA0EwaiADQaABaiADQSBqIAEoAgAoAggRBAAgBioCECEOIAYpAgghDSADQQA2AjwgAyANNwMwIAMgDkPNzMy9kjgCOCAGKgIIIQ4gBioCDCEPIAYqAhAhECADQQA2AqwBIAMgEEPNzMw9kjgCqAEgAyAPQwAAAACSOAKkASADIA5DAAAAAJI4AqABIANCgICA/AM3AyggA0IANwMgIAEgA0EwaiADQaABaiADQSBqIAEoAgAoAggRBAAgACgCyAUhBQsgBEEBaiIEIAVIDQALCwJAIAJBAnFFDQAgACgC3AUiBUEBSA0AA0AgACgC5AUgB0E0bGoiBCgCBC0AEEEBcQRAIAEgBCgCCEEIaiAEKAIMQQhqIANBkAFqIAEoAgAoAggRBAAgACgC3AUhBQsgB0EBaiIHIAVIDQALCwJAIAJBEHFFDQAgACgCyAUiBUEBSA0AQQAhBANAIAAoAtAFIARB6ABsaiIGKAIELQAQQQFxBEAgBioCSCEOIAYqAkwhDyAGKgJQIRAgBioCCCERIAYqAgwhEiAGKgIQIRMgA0EANgI8IAMgEyAQQwAAAD+UIhCSOAI4IAMgEiAPQwAAAD+UIg+SOAI0IAMgESAOQwAAAD+UIg6SOAIwIAEgBkEIaiIFIANBMGogA0GAAWogASgCACgCCBEEACAGKgIIIREgBioCDCESIAYqAhAhEyADQQA2AjwgAyATIBCTOAI4IAMgEiAPkzgCNCADIBEgDpM4AjAgA0EANgKsASADIAMqAogBQwAAAD+UOAKoASADIAMqAoQBQwAAAD+UOAKkASADIAMqAoABQwAAAD+UOAKgASABIAUgA0EwaiADQaABaiABKAIAKAIIEQQAIAAoAsgFIQULIARBAWoiBCAFSA0ACwsCQCACQSBxRQ0AAkBBkNsBLQAAQQFxDQBBkNsBEBBFDQBB5NoBQgA3AgBB4NoBQYCAgPwDNgIAQezaAUIANwIAQfjaAUIANwMAQfTaAUGAgID8AzYCAEGA2wFCADcDAEGI2wFCgICA/AM3AwBBkNsBEA8LIAAoAqwGQQFIDQBBACEEA0AgACgCtAYgBEHoAGxqIgUqAhQhFCAFKgIMIQ4gBSgCGCIGKgIQIQ8gBSoCCCEQIAYqAgwhESAFKgIEIRIgBioCCCETIANBADYCPCADIBMgEiAUIBMgEpQgESAQlJIgDyAOlJKSIhKUkyITOAIwIAMgESAQIBKUkyIROAI0IAMgDyAOIBKUkyISOAI4IAUqAgQiDiAFKgIMIg9dQQFzQQF0QQFBAiAFKgIIIhAgD10bIA4gEF0bQQR0IgZB5NoBaioCACEUIAZB4NoBaioCACEXIAZB6NoBaioCACEVIANBADYCrAEgAyASIA4gFJQgECAXlJMiFkMAAIA/IBYgFpQgECAVlCAPIBSUkyIUIBSUIA8gF5QgDiAVlJMiFyAXlJKSkZUiFZQiFkMAAAA/lCIakzgCqAEgAyARIBcgFZQiF0MAAAA/lCIYkzgCpAEgAyATIBQgFZQiFEMAAAA/lCIVkzgCoAEgA0EANgIsIAMgEiAakjgCKCADIBEgGJI4AiQgAyATIBWSOAIgIAEgA0GgAWogA0EgaiADQfAAaiABKAIAKAIIEQQAIANBADYCrAEgAyADKgI4IhIgECAUlCAOIBeUkyIRQwAAgD8gESARlCAPIBeUIBAgFpSTIhAgEJQgDiAWlCAPIBSUkyIOIA6UkpKRlSIPlEMAAAA/lCIRkzgCqAEgAyADKgI0IhMgDiAPlEMAAAA/lCIOkzgCpAEgAyADKgIwIhQgECAPlEMAAAA/lCIPkzgCoAEgA0EANgIsIAMgESASkjgCKCADIA4gE5I4AiQgAyAUIA+SOAIgIAEgA0GgAWogA0EgaiADQfAAaiABKAIAKAIIEQQAIAUqAgQhDiAFKgIIIQ8gBSoCDCEQIANBADYCrAEgAyAQQwAAAD+UQwAAQECUIAMqAjiSOAKoASADIA9DAAAAP5RDAABAQJQgAyoCNJI4AqQBIAMgDkMAAAA/lEMAAEBAlCADKgIwkjgCoAEgA0IANwMoIANCgICA/IOAgMA/NwMgIAEgA0EwaiADQaABaiADQSBqIAEoAgAoAggRBAAgBEEBaiIEIAAoAqwGSA0ACwsCQCACQQRxRQ0AIANCADcDOCADQoCAgICw5syZPzcDMCAAKALwBSIFQQFIDQBBACEHA0AgACgC+AUgB0EsbGoiBCgCBC0AEEEBcQRAIAQoAhAiBSoCDCERIAQoAggiBioCDCESIAQoAgwiBCoCDCETIAUqAhAhFCAGKgIQIRAgBCoCECEXIAUqAgghFSAGKgIIIQ8gBCoCCCEWIANBADYCrAEgAyAVIA8gFpKSQ6uqqj6UIg4gDyAOk0PNzEw/lJI4AqABIAMgFCAQIBeSkkOrqqo+lCIPIBAgD5NDzcxMP5SSOAKoASADIBEgEiATkpJDq6qqPpQiECASIBCTQ83MTD+UkjgCpAEgA0EANgIsIAMgDyAXIA+TQ83MTD+UkjgCKCADIBAgEyAQk0PNzEw/lJI4AiQgAyAOIBYgDpNDzcxMP5SSOAIgIANBADYCHCADIA8gFCAPk0PNzEw/lJI4AhggAyAQIBEgEJNDzcxMP5SSOAIUIAMgDiAVIA6TQ83MTD+UkjgCECABIANBoAFqIANBIGogA0EQaiADQTBqQwAAgD8gASgCACgCHBETACAAKALwBSEFCyAHQQFqIgcgBUgNAAsLIAJBCHFFDQAgA0Kz5sz5AzcDOCADQpqz5vSjs+bMPjcDMCAAKAKEBiIFQQFIDQBBACEHA0AgACgCjAYgB0HoAGxqIgQoAgQtABBBAXEEQCAEKAIUIgUqAgwhESAEKAIQIgYqAgwhEiAEKAIIIggqAgwhEyAEKAIMIgQqAgwhFCAFKgIQIRcgBioCECEVIAgqAhAhECAEKgIQIRYgBSoCCCEaIAYqAgghGCAIKgIIIQ8gBCoCCCEZIANBADYCrAEgAyAaIBggDyAZkpKSQwAAgD6UIg4gDyAOk0PNzEw/lJIiGzgCoAEgAyAXIBUgECAWkpKSQwAAgD6UIg8gECAPk0PNzEw/lJIiHDgCqAEgAyARIBIgEyAUkpKSQwAAgD6UIhAgEyAQk0PNzEw/lJIiEzgCpAEgA0EANgIsIAMgDyAWIA+TQ83MTD+UkiIWOAIoIAMgECAUIBCTQ83MTD+UkiIUOAIkIAMgDiAZIA6TQ83MTD+UkiIZOAIgIANBADYCHCADIA8gFSAPk0PNzEw/lJIiFTgCGCADIBAgEiAQk0PNzEw/lJIiEjgCFCADIA4gGCAOk0PNzEw/lJIiGDgCECABIANBoAFqIANBIGogA0EQaiADQTBqQwAAgD8gASgCACgCHBETACADQQA2AqwBIAMgHDgCqAEgAyATOAKkASADIBs4AqABIANBADYCLCADIBY4AiggAyAUOAIkIAMgGTgCICADQQA2AhwgAyAPIBcgD5NDzcxMP5SSIg84AhggAyAQIBEgEJNDzcxMP5SSIhA4AhQgAyAOIBogDpNDzcxMP5SSIg44AhAgASADQaABaiADQSBqIANBEGogA0EwakMAAIA/IAEoAgAoAhwREwAgA0EANgKsASADIBY4AqgBIAMgFDgCpAEgAyAZOAKgASADQQA2AiwgAyAVOAIoIAMgEjgCJCADIBg4AiAgA0EANgIcIAMgDzgCGCADIBA4AhQgAyAOOAIQIAEgA0GgAWogA0EgaiADQRBqIANBMGpDAACAPyABKAIAKAIcERMAIANBADYCrAEgAyAVOAKoASADIBI4AqQBIAMgGDgCoAEgA0EANgIsIAMgHDgCKCADIBM4AiQgAyAbOAIgIANBADYCHCADIA84AhggAyAQOAIUIAMgDjgCECABIANBoAFqIANBIGogA0EQaiADQTBqQwAAgD8gASgCACgCHBETACAAKAKEBiEFCyAHQQFqIgcgBUgNAAsLAkAgAkHAAHFFDQAgACgCmAZBAU4EQEEAIQUDQCAAKAKgBiAFQeAAbGoiBigCFCIEKgI0IREgBCoCDCESIAQqAgghEyAEKgIEIRQgBCoCOCEXIAQqAhwhFSAEKgIUIRYgBCoCGCEaIAQqAjwhGCAGKgIMIQ4gBCoCLCEZIAYqAgQhDyAEKgIkIRsgBioCCCEQIAQqAighHCADQQA2AiwgAyAYIA8gG5QgECAclJIgDiAZlJKSOAIoIAMgFyAPIBaUIBAgGpSSIA4gFZSSkjgCJCADIBEgDyAUlCAQIBOUkiAOIBKUkpI4AiAgBigCACEEIANCADcDGCADQoCAgPwDNwMQIAQqAgghDiAEKgIMIQ8gBCoCECEQIANBADYCPCADIBA4AjggAyAPOAI0IAMgDkMAAIC+kjgCMCADQQA2AqwBIAMgEEMAAAAAkjgCqAEgAyAPQwAAAACSOAKkASADIA5DAACAPpI4AqABIAEgA0EwaiADQaABaiADQRBqIAEoAgAoAggRBAAgBCoCDCEOIAQqAgghDyAEKgIQIRAgA0EANgI8IAMgEDgCOCADIA84AjAgAyAOQwAAgL6SOAI0IANBADYCrAEgAyAQQwAAAACSOAKoASADIA5DAACAPpI4AqQBIAMgD0MAAAAAkjgCoAEgASADQTBqIANBoAFqIANBEGogASgCACgCCBEEACAEKgIQIQ4gBCoCCCEPIAQqAgwhECADQQA2AjwgAyAQOAI0IAMgDzgCMCADIA5DAACAvpI4AjggA0EANgKsASADIA5DAACAPpI4AqgBIAMgEEMAAAAAkjgCpAEgAyAPQwAAAACSOAKgASABIANBMGogA0GgAWogA0EQaiABKAIAKAIIEQQAIANCADcDGCADQoCAgICAgIDAPzcDECADQQA2AjwgAyADKgIoIg44AjggAyADKgIkIg84AjQgAyADKgIgIhBDAACAvpI4AjAgA0EANgKsASADIA5DAAAAAJI4AqgBIAMgD0MAAAAAkjgCpAEgAyAQQwAAgD6SOAKgASABIANBMGogA0GgAWogA0EQaiABKAIAKAIIEQQAIANBADYCPCADIAMqAigiDjgCOCADIAMqAiQiD0MAAIC+kjgCNCADIAMqAiAiEDgCMCADQQA2AqwBIAMgDkMAAAAAkjgCqAEgAyAPQwAAgD6SOAKkASADIBBDAAAAAJI4AqABIAEgA0EwaiADQaABaiADQRBqIAEoAgAoAggRBAAgA0EANgI8IAMgAyoCKCIOQwAAgL6SOAI4IAMgAyoCJCIPOAI0IAMgAyoCICIQOAIwIANBADYCrAEgAyAOQwAAgD6SOAKoASADIA9DAAAAAJI4AqQBIAMgEEMAAAAAkjgCoAEgASADQTBqIANBoAFqIANBEGogASgCACgCCBEEACAGKAIAIQQgA0KAgID8AzcDOCADQoCAgPyDgIDAPzcDMCABIARBCGogA0EgaiADQTBqIAEoAgAoAggRBAAgBUEBaiIFIAAoApgGSA0ACwsgACgCyAUiBUEBSA0AQQAhBwNAAkAgACgC0AUgB0HoAGxqIgQoAgQtABBBAXFFDQAgBCoCWEMAAAAAX0EBcw0AIANCADcDKCADQoCAgPwDNwMgIAQqAgghDiAEKgIMIQ8gBCoCECEQIANBADYCPCADIBA4AjggAyAPOAI0IAMgDkMAAIC+kjgCMCADQQA2AqwBIAMgEEMAAAAAkjgCqAEgAyAPQwAAAACSOAKkASADIA5DAACAPpI4AqABIAEgA0EwaiADQaABaiADQSBqIAEoAgAoAggRBAAgBCoCDCEOIAQqAgghDyAEKgIQIRAgA0EANgI8IAMgEDgCOCADIA84AjAgAyAOQwAAgL6SOAI0IANBADYCrAEgAyAQQwAAAACSOAKoASADIA5DAACAPpI4AqQBIAMgD0MAAAAAkjgCoAEgASADQTBqIANBoAFqIANBIGogASgCACgCCBEEACAEKgIQIQ4gBCoCCCEPIAQqAgwhECADQQA2AjwgAyAQOAI0IAMgDzgCMCADIA5DAACAvpI4AjggA0EANgKsASADIA5DAACAPpI4AqgBIAMgEEMAAAAAkjgCpAEgAyAPQwAAAACSOAKgASABIANBMGogA0GgAWogA0EgaiABKAIAKAIIEQQAIAAoAsgFIQULIAdBAWoiByAFSA0ACwsCQCACQYABcUUNACAAKAK0BUEBSA0AQQAhBQNAIAMgACgCvAUgBUE8bGoiBCkCEDcDOCADIAQpAgg3AzAgBCgCGCIIQQFOBEBBACEHIAMqAjghDiADKgI0IQ8gAyoCMCEQA0AgBCAHQQJ0aiIJKAIcIgYqAgwhEiAGKgIQIRMgAyAGKgIIIAkqAiwiEZQgEJIiEDgCMCADIBEgE5QgDpIiDjgCOCADIBEgEpQgD5IiDzgCNCAHQQFqIgcgCEcNAAsLIAEgA0EwaiAEKAIEIAEoAgAoAigRBQAgBUEBaiIFIAAoArQFSA0ACwsgAkGABHEEQCAAKAKgByEEIANCgICA/AM3AzggA0KAgID8AzcDMCADQoCAgPwDNwOoASADQoCAgPyDgIDAPzcDoAEgASAEQQAgA0EwaiADQaABakEAQX8QVgsgAkGACHEEQCAAKALcByEEIANCADcDOCADQoCAgICAgIDAPzcDMCADQgA3A6gBIANCgICA/AM3A6ABIAEgBEEAIANBMGogA0GgAWpBAEF/EFYLIAJBgBBxBEAgACgCmAghBCADQoCAgPwDNwM4IANCgICAgICAgMA/NwMwIANCADcDqAEgA0KAgID8AzcDoAEgASAEQQAgA0EwaiADQaABakEAQX8QVgsCQCACQYAgcUUNACAAKALUBkEBSA0AQQAhBQNAAkAgACgC3AYgBUECdGooAgAiAiACKAIAKAIUEQEAIgRBAUsNACAEQQFrBEAgAkEEaiIGEDEiBCoCNCERIAQqAhAhEiAEKgIUIRMgBCoCGCEUIAQqAjghFyAEKgIgIRUgBCoCJCEWIAQqAighGiAEKgIwIRggBCoCACEZIAQqAgQhGyACKgIgIQ4gBCoCCCEcIAIqAiQhDyACKgIcIRAgA0EANgIsIAMgGCAQIBmUIA4gG5SSIA8gHJSSkjgCICADIBcgECAVlCAOIBaUkiAPIBqUkpI4AiggAyARIBAgEpQgDiATlJIgDyAUlJKSOAIkIAJBEGoiCBAxIgQqAjQhESAEKgIYIRIgBCoCFCETIAQqAhAhFCAEKgI4IRcgBCoCKCEVIAQqAiQhFiAEKgIgIRogBCoCMCEYIAQqAgghGSACKgI0IQ4gBCoCACEbIAIqAiwhDyAEKgIEIRwgAioCMCEQIANBADYCHCADIBggDyAblCAQIByUkiAOIBmUkpI4AhAgAyAXIA8gGpQgECAWlJIgDiAVlJKSOAIYIAMgESAPIBSUIBAgE5SSIA4gEpSSkjgCFCAGEDEhAiADQgA3AzggA0KAgID8g4CAwD83AzAgASACQTBqIANBIGogA0EwaiABKAIAKAIIEQQAIAgQMSECIANCgICA/AM3AzggA0KAgICAgICAwD83AzAgASACQTBqIANBEGogA0EwaiABKAIAKAIIEQQAIANCADcDCCADQoCAgPyDgIDAPzcDACADQQA2AjwgAyADKgIoIg44AjggAyADKgIkIg84AjQgAyADKgIgIhBDAACAvpI4AjAgA0EANgKsASADIA5DAAAAAJI4AqgBIAMgD0MAAAAAkjgCpAEgAyAQQwAAgD6SOAKgASABIANBMGogA0GgAWogAyABKAIAKAIIEQQAIANBADYCPCADIAMqAigiDjgCOCADIAMqAiQiD0MAAIC+kjgCNCADIAMqAiAiEDgCMCADQQA2AqwBIAMgDkMAAAAAkjgCqAEgAyAPQwAAgD6SOAKkASADIBBDAAAAAJI4AqABIAEgA0EwaiADQaABaiADIAEoAgAoAggRBAAgA0EANgI8IAMgAyoCKCIOQwAAgL6SOAI4IAMgAyoCJCIPOAI0IAMgAyoCICIQOAIwIANBADYCrAEgAyAOQwAAgD6SOAKoASADIA9DAAAAAJI4AqQBIAMgEEMAAAAAkjgCoAEgASADQTBqIANBoAFqIAMgASgCACgCCBEEACADQoCAgPwDNwMIIANCgICAgICAgMA/NwMAIANBADYCPCADIAMqAhgiDjgCOCADIAMqAhQiDzgCNCADIAMqAhAiEEMAAIC+kjgCMCADQQA2AqwBIAMgDkMAAAAAkjgCqAEgAyAPQwAAAACSOAKkASADIBBDAACAPpI4AqABIAEgA0EwaiADQaABaiADIAEoAgAoAggRBAAgA0EANgI8IAMgAyoCGCIOOAI4IAMgAyoCFCIPQwAAgL6SOAI0IAMgAyoCECIQOAIwIANBADYCrAEgAyAOQwAAAACSOAKoASADIA9DAACAPpI4AqQBIAMgEEMAAAAAkjgCoAEgASADQTBqIANBoAFqIAMgASgCACgCCBEEACADQQA2AjwgAyADKgIYIg5DAACAvpI4AjggAyADKgIUIg84AjQgAyADKgIQIhA4AjAgA0EANgKsASADIA5DAACAPpI4AqgBIAMgD0MAAAAAkjgCpAEgAyAQQwAAAACSOAKgASABIANBMGogA0GgAWogAyABKAIAKAIIEQQADAELIAMgAkEEaiIEEDEiBikCODcDOCADIAYpAjA3AzAgAyACQRBqIgYQMSIIKQI4NwOoASADIAgpAjA3A6ABIAQQMSIEKgIQIRQgBCoCFCEXIAQqAhghFSAEKgIgIRYgBCoCJCEaIAQqAighGCAEKgIAIRkgAioCICEOIAQqAgQhGyACKgIkIQ8gBCoCCCEcIAIqAhwhECAGEDEiBCoCCCEdIAQqAgAhHiAEKgIEIR8gBCoCGCEgIAQqAhQhISAEKgIQISIgAioCNCERIAQqAighIyACKgIwIRIgBCoCJCEkIAQqAiAhJSACKgIsIRMgA0EANgIsIAMgGSAQlCAbIA6UkiAcIA+UkkMAACBBlCIZIAMqAjCSOAIgIAMgECAWlCAOIBqUkiAPIBiUkkMAACBBlCIWIAMqAjiSOAIoIAMgECAUlCAOIBeUkiAPIBWUkkMAACBBlCIOIAMqAjSSOAIkIANCADcDGCADQoCAgPyDgIDAPzcDECABIANBMGogA0EgaiADQRBqIAEoAgAoAggRBAAgA0EANgIsIAMgEyAllCASICSUkiARICOUkkMAACBBlCIPIAMqAjiSOAIoIAMgEyAilCASICGUkiARICCUkkMAACBBlCIQIAMqAjSSOAIkIAMgHiATlCAfIBKUkiAdIBGUkkMAACBBlCIRIAMqAjCSOAIgIANCADcDGCADQoCAgPyDgIDAPzcDECABIANBMGogA0EgaiADQRBqIAEoAgAoAggRBAAgA0EANgIsIAMgFiADKgKoAZI4AiggAyAOIAMqAqQBkjgCJCADIBkgAyoCoAGSOAIgIANCgICA/AM3AxggA0KAgICAgICAwD83AxAgASADQaABaiADQSBqIANBEGogASgCACgCCBEEACADQQA2AiwgAyAPIAMqAqgBkjgCKCADIBAgAyoCpAGSOAIkIAMgESADKgKgAZI4AiAgA0KAgID8AzcDGCADQoCAgICAgIDAPzcDECABIANBoAFqIANBIGogA0EQaiABKAIAKAIIEQQACyAFQQFqIgUgACgC1AZIDQALCyADQbABaiQAC10BAn8CQCAAKALYASIDKgIEQwAAAABbDQBBASECIAMgASgCACIBKAK8ASADKAIAKAIIEQMARQ0AIABBxABqIABBhAFqIAEgASgCwAEgAUEEaiAAKALYARCgDwsgAgsJACAAIAEQ+w4LBABBBAsHACAAKAJIC7cBAQN/IAEgASgCACgCIBEAACAAIAEQ5g4gACgCCCICQQFOBEADQCAAKAIQIARBAnRqKAIAIgMtAOwBQQhxBEAgASABIAMgAygCACgCEBEBAEEBIAEoAgAoAhARBwAiAiADIAIoAgggASADKAIAKAIUEQcAQdOEkcoFIAMgASgCACgCFBEJACAAKAIIIQILIARBAWoiBCACSA0ACwsgACABEOoEIAAgARDAAiABIAEoAgAoAiQRAAALiAMCAX8FfSMAQUBqIgYkAAJAIAMoAgRBIEYEQCACRQ0BIAIoAuwBQQhHDQEgAiAAQTBqIAFBMGogBkEwahD1D0UNASAGKgI8IgsgBSoCBF9BAXMNASAGQQA2AiggBiAGKAI4IgM2AiwgASoCNCAAKgI0kyEHIAEqAjAgACoCMJMhCCABKgI4IAAqAjiTIQkCQCAGKAI0QQNHBEBDAACAPyAIIAiUIAcgB5SSIAkgCZSSkZUiCiAJjJQhCSAKIAeMlCEHIAogCIyUIQhDAAAAACEKDAELIAggAigC+AUgA0EsbGoiACoCFCIIlCAHIAAqAhgiB5SSIAkgACoCHCIJlJJDAAAAAF5BAXMEQCAAKgIgIQoMAQsgCYwhCSAHjCEHIAiMIQgLIAYgCjgCHCAGIAk4AhggBiAHOAIUIAYgCzgCICAGIAg4AhAgBiACNgIIIAYgBkEoajYCDCAFIAZBCGpBASAFKAIAKAIMEQ0AGgwBCyAAIAEgAiADIAQgBRD8DAsgBkFAayQAC8sEAwF/AX4GfSMAQYACayIEJABBmzQQFiAEQdQ0NgIgIAQgASkCCDcCTCAEIAEpAgA3AkQgBCACKQIINwJcIAIpAgAhBSAEQgA3A2ggBEIANwNwIARCADcCfCAEQYCAgPwDNgJ4IARCADcChAEgBEKAgID8AzcCjAEgBCAFNwJUIAQgAzYC+AEgBEGAgID8AzYCZCAEIAA2AvQBIAQgBCkCRDcClAEgBCAEKQJMNwKcASAEQYCAgPwDNgKkASAEQgA3A7ABIARCADcDqAEgBEGAgID8AzYCuAEgBEIANwLEASAEQgA3ArwBIARCgICA/AM3AswBIAQgAikCCDcC3AEgBCACKQIANwLUASAEQ8rySXFDAACAPyACKgIIIAEqAgiTIgZDAACAPyACKgIAIAEqAgCTIgggCJQgAioCBCABKgIEkyIHIAeUkiAGIAaUkpGVIgaUIgmVIAlDAAAAAFsbIgo4AiwgBEPK8klxQwAAgD8gByAGlCIHlSAHQwAAAABbGyILOAIoIAQgCkMAAAAAXTYCPCAEIAtDAAAAAF02AjggBEPK8klxQwAAgD8gCCAGlCIGlSAGQwAAAABbGyIIOAIkIAQgCEMAAAAAXTYCNCAEIAYgBCoCVCAEKgJEk5QgByAEKgJYIAQqAkiTlJIgCSAEKgJcIAQqAkyTlJI4AkAgACgCRCEAIARCADcDGCAEQgA3AxAgBEIANwMIIARCADcDACAAIAEgAiAEQSBqIARBEGogBCAAKAIAKAIYEQwAEBMgBEGAAmokAAvxAQEDfyAAEPQEAkAgACAAKAIAKAIUEQEARQ0AIAAoAsgCQQFIDQADQCAAKALQAiADQQJ0aigCACEBAkAgACAAKAIAKAIUEQEARQ0AIAAgACgCACgCFBEBACICIAIoAgAoAjARAQBBAXFFDQAgASAAKAJIEJYPIAEgACgCSCAAKALYAhCaDwsCQCAAKAJIIgJFDQAgAiACKAIAKAIwEQEAQQJxRQ0AIAAtANwCBEAgASAAKAJIEJkPCyAALQDdAgRAIAEgACgCSBCYDwsgAC0A3gJFDQAgASAAKAJIEJcPCyADQQFqIgMgACgCyAJIDQALCwuWAQEEfwJAIAFFDQAgASgC7AFBCEcNAAJAIAAoAsgCIgNBAUgNACAAKALQAiEEA0AgASAEIAJBAnRqIgUoAgBHBEAgAkEBaiICIANHDQEMAgsLIAIgA04NACAFIAQgA0F/aiICQQJ0IgNqKAIANgIAIAAoAtACIANqIAE2AgAgACACNgLIAgsgACABEKkBDwsgACABEPIEC3sBBH8CQCAAKALIAiIDQQFIDQAgACgC0AIhBANAIAEgBCACQQJ0aiIFKAIARwRAIAJBAWoiAiADRw0BDAILCyACIANODQAgBSAEIANBf2oiAkECdCIDaigCADYCACAAKALQAiADaiABNgIAIAAgAjYCyAILIAAgARCpAQueAgEFfwJAIAAoAsgCIgQgACgCzAJHDQAgBCAEQQF0QQEgBBsiBk4NAAJ/IAYEQEHo9wFB6PcBKAIAQQFqNgIAIAZBAnRBEEGM0gEoAgARAwAhByAAKALIAiEECyAEQQFOCwRAA0AgByAFQQJ0IghqIAAoAtACIAhqKAIANgIAIAVBAWoiBSAERw0ACwsgACgC0AIiBQRAIAAtANQCBEAgBQRAQez3AUHs9wEoAgBBAWo2AgAgBUGQ0gEoAgARAAALIAAoAsgCIQQLIABBADYC0AILIAAgBzYC0AIgACAGNgLMAiAAQQE6ANQCCyAAKALQAiAEQQJ0aiABNgIAIAAgBEEBajYCyAIgASAAKALEAzYCnAIgACABIAIgAxDCAgu4AQECfyAAKALEAyICIABBxAJqIgNBACACKAIAKAIQEQUAIAAoAsQDIgIgAigCACgCDBEBABogACABEPMEQYY0EBYgACgCyAIEQCADEOsPCyAAKALEAyICIAIqAgwgAZQgAigCACgCHBEIABATIAAoAsgCQQFOBEBBACECA0AgACgC0AIgAkECdGooAgAiAyADEIcFIAJBAWoiAiAAKALIAkgNAAsLIAAoAsQDIgAgACgCACgCIBEAAAslACAAIAEQ7ARB5DMQFiAAKALEAyIAIAEgACgCACgCGBEIABATCykAIAAQ/QQiAARAQez3AUHs9wEoAgBBAWo2AgAgAEGQ0gEoAgARAAALC9MDAQF/IAAgASACIAMQ9QQgAEEBOgDUAiAAQbAyNgIAQQAhAyAAQQA2AtACIABCADcC8AIgAEKAgICAgICAvcQANwLoAiAAQpqz5vwDNwLgAiAAQgA3AsgCIABCADcC+AIgAEIANwKAAyAAQQA2AogDIABBAToAqAMgAEEANgKUAyAAQoCAgIkMNwKMAyAAQQA2AqQDIABBADoAyAMgACAENgLEAyAAQgA3ApwDIARFBEACf0Ho9wFB6PcBKAIAQQFqNgIAQShBEEGM0gEoAgARAwAiBAsQ9QIgAEEBOgDIAyAAIAQ2AsQDCyAAQQA6AN4CIABBATsB3AIgAEHOITYC2AIgACABNgKEAyAAIAI2AoADIABBmANqIgIQ/gQgACgCnAMiBUEBTgRAA0AgACgCpAMgA0ECdGoiASgCACEEIAFBADYCACAEBEADQCAEKAKYAiEBIAQQDiABIgQNAAsLIANBAWoiAyAFRw0ACwsgAEEANgLoAiAAQpqz5vwDNwLgAiAAQoGAgIAQNwK8AyAAQQA2ArQDIABCgICA9AM3AqwDIABBADYCiAMgAEIANwL4AiAAQgA3AvACIABBADYClAMgAEKAgICJDDcCjAMgAhD+BAvYAQEJfSAAKgJYIQcgACoCSCEIIAAqAkwhCSAAKgJgIQsgAEFAayIBKgIAIQYgACoCUCEMIAAqAlwhCiAAKgI8IQQgACoCOCEFIAJBADYCDCACIAggBZMiCCAKIASTIgqUIAkgBJMiCSAHIAWTIgWUkyIEQwAAgD8gBCAElCAJIAsgBpMiBJQgDCAGkyIHIAqUkyIGIAaUIAcgBZQgCCAElJMiBCAElJKSkZUiBZQ4AgggAiAEIAWUOAIEIAIgBiAFlDgCACADIAEpAgA3AgggAyAAKQI4NwIAC74DAgN/Cn0jAEEgayIDJAACQCABKgIIIAAqAkggACoCOCIGkyIIIAAqAlwgACoCPCIHkyIJlCAAKgJMIAeTIgsgACoCWCAGkyIMlJMiCkMAAIA/IAogCpQgCyAAKgJgIABBQGsqAgAiC5MiCpQgACoCUCALkyINIAmUkyIJIAmUIA0gDJQgCCAKlJMiCCAIlJKSkZUiDJQiCpQgASoCACAJIAyUIgmUIAEqAgQgCCAMlCIIlJKSIAsgCpQgBiAJlCAHIAiUkpKTIgYgAowiC2BBAXMNACAGIAJfQQFzDQADQAJAIAAgBSADQRBqIAMgACgCACgCaBEEACABKgIIIAggAyoCACADKgIQIgyTIgaUIAkgAyoCBCADKgIUIg2TIgeUkyICQwAAgD8gAiAClCAKIAeUIAggAyoCCCADKgIYIg6TIgeUkyICIAKUIAkgB5QgCiAGlJMiBiAGlJKSkZUiB5QiD5QgASoCACACIAeUIgKUIAEqAgQgBiAHlCIGlJKSIA4gD5QgDCAClCANIAaUkpKTIAtdQQFzRQ0AQQEhBCAFQQFqIgVBA0cNAQwCCwtBACEECyADQSBqJAAgBAsVACAAIAMgASACIAAoAgAoAnwRBAALIQAgAiAAIAFBBHRqIgBBQGspAgA3AgggAiAAKQI4NwIACyoAIAAgASACIAAoAgAoAmwRBQAgACABQQFqQQNvIAMgACgCACgCbBEFAAvlAQEJfSAAKgJYIQYgACoCSCEHIAAqAkwhCCAAKgJgIQogAEFAayoCACEEIAAqAlAhCyAAKgJcIQkgACoCPCEDIAAqAjghBSACQQA2AgwgAiAHIAWTIgcgCSADkyIJlCAIIAOTIgggBiAFkyIFlJMiA0MAAIA/IAMgA5QgCCAKIASTIgOUIAsgBJMiBiAJlJMiBCAElCAGIAWUIAcgA5STIgMgA5SSkpGVIgWUIgY4AgggAiADIAWUIgM4AgQgAiAEIAWUIgQ4AgAgAQRAIAIgBow4AgggAiADjDgCBCACIASMOAIACwvCAQIEfwV9IANBAU4EQCAAQThqIQYDQCACIAVBBHQiBGoiByAGQQJBASABIARqIgQqAgAiCCAAKgJIlCAEKgIEIgkgACoCTJSSIAQqAggiCiAAKgJQlJIiCyAIIAAqAliUIAkgACoCXJSSIAogACoCYJSSIgxdGyAIIAAqAjiUIAkgACoCPJSSIAogACoCQJSSIgggDF1BAXQgCCALXRtBBHRqIgQpAgA3AgAgByAEKQIINwIIIAVBAWoiBSADRw0ACwsLmQEBBX0gACABQThqQQJBASACKgIAIgMgASoCSJQgAioCBCIEIAEqAkyUkiACKgIIIgUgASoCUJSSIgYgAyABKgJYlCAEIAEqAlyUkiAFIAEqAmCUkiIHXRsgAyABKgI4lCAEIAEqAjyUkiAFIAFBQGsqAgCUkiIDIAddQQF0IAMgBl0bQQR0aiIBKQIANwIAIAAgASkCCDcCCAsHACAAKgIsCywCAX8BfSMAQRBrIgEkACABIAA2AgwgASgCDCIAIAAQSSECIAFBEGokACACCwUAQZwyCwMAAQuFCwEqfSMAQfABayIDJABDAACAPyEsAkAgAiABIAAtAAgiBBsiACoCdCIHIAAqAjQiCJMiBSAFlCAAKgJ4IgkgACoCOCIVkyIFIAWUkiAAKgJ8IhYgACoCPCIGkyIFIAWUkiAAKgL8ASIFIAWUXQ0AIAEgAiAEGyIBKALAASICKAIEQWtqQQhLDQAgACoCXCEaIAAqAkwhGyAAKgJsIRwgACoCWCEdIAAqAkghHiAAKgJoIR8gACoCZCEgIAAqAlQhISAAKgJEISIgASoCJCEKIAEqAhQhCyABKgIEIQwgACoCHCEjIAAqAgwhJCAAKgIsISUgACoCGCEmIAAqAgghJyAAKgIoISggACoCJCEpIAAqAhQhKiAAKgIEISsgASoCDCINIAeUIAEqAhwiDiAJlJIgASoCLCIPIBaUkiEtIAEqAhgiECABKgI4jCIRlCABKgIIIhIgASoCNCIXlJMgASoCKCITIAEqAjwiGJSTIhQgEiAHlCAQIAmUkiATIBaUkpIhBSADQQA2AuwBIAMgDiARlCANIBeUkyAPIBiUkyIuIA0gCJQgDiAVlJIgDyAGlJKSIhk4AugBIAMgFCASIAiUIBAgFZSSIBMgBpSSkiIUOALkASADIAsgEZQgDCAXlJMgCiAYlJMiESAMIAiUIAsgFZSSIAogBpSSkiIIOALgASAIIRUgESAMIAeUIAsgCZSSIAogFpSSkiIHIAhdQQFzRQRAIAMgBzgC4AEgByEVCyAUIRYgBSAUXUEBc0UEQCADIAU4AuQBIAUhFgsgLiAtkiIJIBkiBl1BAXNFBEAgAyAJOALoASAJIQYLIANBADYC3AEgAyAZOALYASADIBQ4AtQBIAMgCDgC0AEgCCERIAggB11BAXNFBEAgAyAHOALQASAHIRELIBQhFyAUIAVdQQFzRQRAIAMgBTgC1AEgBSEXCyAZIRggGSAJXUEBc0UEQCADIAk4AtgBIAkhGAsgAyAGIAAqAvgBIgaTOALoASADIBYgBpM4AuQBIAMgFSAGkzgC4AEgAyAGIBiSOALYASADIAYgF5I4AtQBIAMgBiARkjgC0AEgA0EANgKAASADIAk4AnwgAyAFOAJ4IAMgBzgCdCADQQA2AnAgAyANIBuUIA4gGpSSIA8gHJSSOAJsIAMgDSAelCAOIB2UkiAPIB+UkjgCaCADIA0gIpQgDiAhlJIgDyAglJI4AmQgA0EANgJgIAMgEiAblCAQIBqUkiATIByUkjgCXCADIBIgHpQgECAdlJIgEyAflJI4AlggAyASICKUIBAgIZSSIBMgIJSSOAJUIANBADYCUCADIAwgG5QgCyAalJIgCiAclJI4AkwgAyAMIB6UIAsgHZSSIAogH5SSOAJIIANBQGtBADYCACADIBk4AjwgAyAUOAI4IAMgCDgCNCADQQA2AjAgAyANICSUIA4gI5SSIA8gJZSSOAIsIAMgDSAnlCAOICaUkiAPICiUkjgCKCADIA0gK5QgDiAqlJIgDyAplJI4AiQgA0EANgIgIAMgEiAklCAQICOUkiATICWUkjgCHCADIBIgJ5QgECAmlJIgEyAolJI4AhggAyASICuUIBAgKpSSIBMgKZSSOAIUIANBADYCECADIAwgJJQgCyAjlJIgCiAllJI4AgwgAyAMICeUIAsgJpSSIAogKJSSOAIIIAMgBjgCxAEgAyAMICKUIAsgIZSSIAogIJSSOAJEIAMgDCArlCALICqUkiAKICmUkjgCBCADQfguNgIAIAMgACgC9AE2AsgBAkAgAkUNACACIAMgA0HgAWogA0HQAWogAigCACgCQBEEACADKgLIASIFIAAqAvQBXUEBcw0AIAAgBTgC9AEgBSEsCwsgA0HwAWokACAsC14BAX8gASACIAAtAAgbIgIoAgQoAgRBa2pBCE0EQCAAQQxqIgUgAigCCCgCwAEiASABKAIAKAIwEQYAIAIgAyAEELgPIAEgBSAAQRhqIABBKGogASgCACgCQBEEAAsLjwUCAX8YfSMAQSBrIgUkACAAIAM2AjQgACAENgIsIAAgAUOPwnU9kjgCOCAAKAIEIgMgBUEQaiAFIAMoAgAoAhwRBQAgAigCDCICKgIUIQEgAioCJCEKIAIqAhghCyACKgIoIQcgAioCOCENIAIqAjQhECACKgIEIREgAioCCCEMIAAqAjghDiACKgIwIRMgAioCICEJIAIqAgAhBiACKgIQIQggBSoCGCEPIAUqAgghEiAFKgIQIRQgBSoCACEVIAUqAhQhFiAFKgIEIRcgAEEANgIoIABBADYCGCAAIAYgFSAUkkMAAAA/lCIYlCAIIBcgFpJDAAAAP5QiGZSSIAkgEiAPkkMAAAA/lCIalJIgCCAQjCIQlCAGIBOUkyAJIA2Uk5IiGyAJIAZDAAAAAJQiHCAIQwAAAACUIh2SkosgDiASIA+TQwAAAD+UkiIPlCAGIB2SIAlDAAAAAJQiBpKLIA4gFSAUk0MAAAA/lJIiCZQgHCAIkiAGkosgDiAXIBaTQwAAAD+UkiIGlJKSIgiSOAIcIAAgGyAIkzgCDCAAIBggDJQgGSALlJIgGiAHlJIgCyAQlCAMIBOUkyAHIA2Uk5IiCCAHIAxDAAAAAJQiDiALQwAAAACUIhKSkosgD5QgDCASkiAHQwAAAACUIgeSiyAJlCAOIAuSIAeSiyAGlJKSIguSOAIkIAAgGCARlCAZIAGUkiAaIAqUkiABIBCUIBEgE5STIAogDZSTkiIHIAogEUMAAAAAlCIMIAFDAAAAAJQiDZKSiyAPlCARIA2SIApDAAAAAJQiCpKLIAmUIAwgAZIgCpKLIAaUkpIiAZI4AiAgACAIIAuTOAIUIAAgByABkzgCECAFQSBqJAALwwUBCX8CQCAAKAIEIgcgACgCMCIBTg0AAkAgACgCCCABTgRAIAAoAgwhAwwBCyAHIQIgAQRAQej3AUHo9wEoAgBBAWo2AgAgAUECdEEQQYzSASgCABEDACEDIAAoAgQhAgsgACgCDCEEAkACQCACQQFOBEADQCADIAVBAnQiBmogBCAGaigCADYCACAFQQFqIgUgAkcNAAwCAAsACyAEDQAMAQsgAC0AEARAIAQEQEHs9wFB7PcBKAIAQQFqNgIAIARBkNIBKAIAEQAACwsLIAAgAzYCDCAAQQE6ABAgACABNgIICyADIAdBAnQiAmpBACABQQJ0IgggAmsQCxogACABNgIEIAAoAhgiBiABSARAAkAgACgCHCABTgRAIAAoAiAhAwwBC0EAIQUgBiECQQAhAyABBEBB6PcBQej3ASgCAEEBajYCACAIQRBBjNIBKAIAEQMAIQMgACgCGCECCyAAKAIgIQQCQCACQQFOBEADQCADIAVBAnQiCWogBCAJaigCADYCACAFQQFqIgUgAkcNAAwCAAsACyAEDQAgACADNgIgIAAgATYCHCAAQQE6ACQMAQsgAC0AJARAIAQEQEHs9wFB7PcBKAIAQQFqNgIAIARBkNIBKAIAEQAACwsgACADNgIgIABBAToAJCAAIAE2AhwLIAMgBkECdCICakEAIAggAmsQCxoLIAAgATYCGCABQQFOBEAgACgCDEH/ASAIEAsaIAAoAiBB/wEgCBALGgsgB0EBSA0AIAAoAiAhAiAAKAJIIQQgACgCDCEGQQAhBQNAIAIgBUECdCIBaiAGIAAoAjBBf2ogASAEaigCACIBIAFBD3RBf3NqIgFBCnUgAXNBCWwiAUEGdSABcyIBIAFBC3RBf3NqIgFBEHUgAXNxQQJ0aiIBKAIANgIAIAEgBTYCACAFQQFqIgUgB0cNAAsLC7kGAQh/AkACQCAAKAIwIghBf2ogASgCACIEIARBD3RBf3NqIgNBCnUgA3NBCWwiA0EGdSADcyIDIANBC3RBf3NqIgNBEHUgA3NxIgkgACgCBE8NACAAKAIMIAlBAnRqKAIAIgNBf0YNACAAKAJIIQYDQCAEIAYgA0ECdCIFaigCAEYNAiAAKAIgIAVqKAIAIgNBf0cNAAsLIAAoAiwiBiEDAkAgBiAIRw0AIAgiAyADQQF0QQEgAxsiBU4NAAJ/IAVFBEBBACEEIAgMAQtB6PcBQej3ASgCAEEBajYCACAFQQN0QRBBjNIBKAIAEQMAIQQgACgCLAsiB0EBTgRAQQAhAwNAIAQgA0EDdCIKaiAAKAI0IApqKQIANwIAIANBAWoiAyAHRw0ACwsgACgCNCIDBEAgAC0AOARAIAMEQEHs9wFB7PcBKAIAQQFqNgIAIANBkNIBKAIAEQAACwsgAEEANgI0CyAAIAQ2AjQgACAFNgIwIABBAToAOCAAKAIsIQMLIAAoAjQgA0EDdGogAikCADcCACAAIAAoAixBAWo2AiwCQCAAQUBrKAIAIgQgACgCREcNACAEIARBAXRBASAEGyIFTg0AQQAhA0EAIQcgBQRAQej3AUHo9wEoAgBBAWo2AgAgBUECdEEQQYzSASgCABEDACEHIAAoAkAhBAsgACgCSCECAkACQCAEQQFOBEADQCAHIANBAnQiCmogAiAKaigCADYCACADQQFqIgMgBEcNAAwCAAsACyACRQ0BCyAALQBMBEAgAgRAQez3AUHs9wEoAgBBAWo2AgAgAkGQ0gEoAgARAAALCyAAQQA2AkggACgCQCEECyAAIAc2AkggACAFNgJEIABBAToATAsgACgCSCAEQQJ0aiABKAIANgIAIAAgACgCQEEBajYCQCAIIAAoAjBIBEAgABC5DyAAKAIwQX9qIAEoAgAiASABQQ90QX9zaiIBQQp1IAFzQQlsIgFBBnUgAXMiASABQQt0QX9zaiIBQRB1IAFzcSEJCyAAKAIgIAZBAnRqIAAoAgwgCUECdGoiACgCADYCACAAIAY2AgAPCyAAKAI0IANBA3RqIAIpAgA3AgAL2hECBn8PfSMAQbABayIEJAAgACgCMCEHAkAgACgCNCIFRQ0AIAUoAhQiBUUNACAFIAUoAgAoAjARAQBBAXFFDQAgBEIANwMoIARCgICA/IOAgMA/NwMgIAAoAjQoAhQhBiAAKAIIIgUiCCoCNCEOIAUqAgwhDSAFKgIIIQ8gBSoCOCEQIAUqAhwhESAFKgIUIRMgBSoCGCEUIAUqAjwhFSAFKgIsIRYgBSoCJCEXIAUqAighEiAFKgIEIRggASoCCCEKIAEqAgAhCyABKgIEIQwgBEEANgKUASAEIBUgCyAXlCAMIBKUkiAKIBaUkpI4ApABIAQgECALIBOUIAwgFJSSIAogEZSSkjgCjAEgBCAOIAsgGJQgDCAPlJIgCiANlJKSOAKIASAFKgIIIQ0gBSoCDCEPIAEqAhQhCiABKgIYIQsgBSoCBCEYIAEqAhAhDCAEQQA2AhQgBCAVIAwgF5QgCiASlJIgCyAWlJKSOAIQIAQgECAMIBOUIAogFJSSIAsgEZSSkjgCDCAEIA4gDCAYlCAKIA2UkiALIA+UkpI4AgggBiAEQYgBaiAEQQhqIARBIGogBigCACgCCBEEACAAKAI0KAIUIQYgCCoCNCEOIAUqAgghDSAFKgIMIQ8gBSoCOCEQIAUqAhQhESAFKgIYIRMgBSoCHCEUIAUqAjwhFSAFKgIkIRYgBSoCKCEXIAEqAhQhCiAFKgIsIRIgASoCGCELIAUqAgQhGCABKgIQIQwgBEEANgKUASAEIBUgDCAWlCAKIBeUkiALIBKUkpI4ApABIAQgECAMIBGUIAogE5SSIAsgFJSSkjgCjAEgBCAOIAwgGJQgCiANlJIgCyAPlJKSOAKIASAFKgIIIQ0gBSoCDCEPIAEqAiQhCiABKgIoIQsgBSoCBCEYIAEqAiAhDCAEQQA2AhQgBCAVIAwgFpQgCiAXlJIgCyASlJKSOAIQIAQgECAMIBGUIAogE5SSIAsgFJSSkjgCDCAEIA4gDCAYlCAKIA2UkiALIA+UkpI4AgggBiAEQYgBaiAEQQhqIARBIGogBigCACgCCBEEACAAKAI0KAIUIQYgCCoCNCEOIAUqAgghDSAFKgIMIQ8gBSoCOCEQIAUqAhQhESAFKgIYIRMgBSoCHCEUIAUqAjwhFSAFKgIkIRYgBSoCKCEXIAEqAiQhCiAFKgIsIRIgASoCKCELIAUqAgQhGCABKgIgIQwgBEEANgKUASAEIBUgDCAWlCAKIBeUkiALIBKUkpI4ApABIAQgECAMIBGUIAogE5SSIAsgFJSSkjgCjAEgBCAOIAwgGJQgCiANlJIgCyAPlJKSOAKIASAFKgIMIQ0gBSoCCCEPIAUqAgQhGCABKgIIIQogASoCACELIAEqAgQhDCAEQQA2AhQgBCAVIAsgFpQgDCAXlJIgCiASlJKSOAIQIAQgECALIBGUIAwgE5SSIAogFJSSkjgCDCAEIA4gCyAYlCAMIA+UkiAKIA2UkpI4AgggBiAEQYgBaiAEQQhqIARBIGogBigCACgCCBEEAAsgBEEANgKsASAEIAJBFXQgA3IiBTYCqAEgBCAFNgKgAQJAAkAgACgCbEF/aiAFIANBD3RBf3NqIgZBCnUgBnNBCWwiBkEGdSAGcyIGIAZBC3RBf3NqIgZBEHUgBnNxIgYgAEFAaygCAE8NACAAKAJIIAZBAnRqKAIAIgZBf0YNACAAKAKEASEIA0AgCCAGQQJ0IglqKAIAIAVHBEAgACgCXCAJaigCACIGQX9HDQEMAgsLIAAoAnAiBUUNACAFIAZBA3RqKAIEIgYgACgCCCIBKALAASgCCDYCCCAAKAIEIgUoAsABIQggBEJ/NwMwIAQgBUEEajYCLCAEIAU2AiggBCAINgIkIARBADYCICAEIAM2ApwBIAQgAjYCmAEgBCABQQRqNgKUASAEIAE2ApABIAQgBjYCjAEgBEEANgKIASAHIARBIGogBEGIAWpBACAHKAIAKAIIEQoAIgEgBEEgaiAEQYgBaiAAKAI0IAAoAiwgASgCACgCCBEJACABIAEoAgAoAgARAQAaIAcgASAHKAIAKAI8EQIADAELIAEqAhQhDCABKgIkIRMgASoCGCEUIAEqAighFSABKgIEIQ4gASoCICEWIAEqAgghECABKgIAIREgASoCECEXIARBADYCfCAEQQA2AmwgBEEANgJcIARBADYCTCAEQQA2AjwgBCAVIBcgEZMiCyATIA6TIhKUIAwgDpMiDSAWIBGTIg+UkyIKQwAAgD8gCiAKlCANIBUgEJMiCpQgFCAQkyINIBKUkyISIBKUIA0gD5QgCyAKlJMiCyALlJKSkZUiDZRDj8J1PZQiCpM4AnggBCATIAsgDZRDj8J1PZQiC5M4AnQgBCAUIAqTOAJoIAQgDCALkzgCZCAEIBAgCpM4AlggBCAOIAuTOAJUIAQgFSAKkjgCSCAEIBMgC5I4AkQgBCAUIAqSOAI4IAQgDCALkjgCNCAEQQA2AiwgBCAWIBIgDZRDj8J1PZQiDJM4AnAgBCAXIAyTOAJgIAQgESAMkzgCUCAEIBYgDJI4AkAgBCAXIAySOAIwIAQgECAKkjgCKCAEIA4gC5I4AiQgBCARIAySOAIgAn9B6PcBQej3ASgCAEEBajYCAEHwAEEQQYzSASgCABEDACIFCyAEQSBqQQYQ2QEgBSAAKAIIIgEoAsABKAIINgIIIAAoAgQiBigCwAEhCCAEQn83A5gBIAQgBkEEajYClAEgBCAGNgKQASAEIAg2AowBIARBADYCiAEgBCADNgIcIAQgAjYCGCAEIAFBBGo2AhQgBCABNgIQIAQgBTYCDCAEQQA2AgggByAEQYgBaiAEQQhqQQAgBygCACgCCBEKACIBIARBiAFqIARBCGogACgCNCAAKAIsIAEoAgAoAggRCQAgASABKAIAKAIAEQEAGiAHIAEgBygCACgCPBECACAEIAU2AqwBIABBPGogBEGgAWogBEGoAWoQug8LIARBsAFqJAALGwAgAEGELjYCACAAELUBIABBPGoQ+AEgABAOCxkAIABBhC42AgAgABC1ASAAQTxqEPgBIAALxAIBAX8gACgCDCIBBEAgAC0AEARAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgIMCyAAQQA2AgwgAEEBOgAQIABCADcCBCAAKAIgIgEEQCAALQAkBEAgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALCyAAQQA2AiALIABBADYCICAAQgA3AhggAEEBOgAkIAAoAjQiAQRAIAAtADgEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsLIABBADYCNAsgAEEANgI0IABCADcCLCAAQQE6ADggACgCSCIBBEAgAC0ATARAIAEEQEHs9wFB7PcBKAIAQQFqNgIAIAFBkNIBKAIAEQAACwsgAEEANgJICyAAQQA2AkggAEIANwJAIABBAToATAsnACAAQYQuNgIMIABB6C02AgAgAEEMahC1ASAAQcgAahD4ASAAEA4LJQAgAEGELjYCDCAAQegtNgIAIABBDGoQtQEgAEHIAGoQ+AEgAAuCAQEBfyABIAIgAC0AECIAGyEDAkACQCACIAEgABsoAggiACgCjAIiAUEBSA0AIAMoAgghBCAAKAKUAiEFQQAhAgNAIAQgBSACQQJ0aigCAEcEQCACQQFqIgIgAUcNAQwCCwsgASACRw0BCyAAKAKcAiIBIAAgAyABKAIAKAIkEQUACwuHDwIGfyd9AkAgAigCJCIHKAIMIgQqAggiJyABKAIkIgUqAggiKJMiKSAHKAIIIgIqAggiLiAokyIZkyIdIAcoAhAiASoCDCIeIAUqAgwiKpMiHyACKgIMIi8gKpMiGpMiCpQgBCoCDCIQICqTIisgGpMiICABKgIIIhQgKJMiISAZkyIJlJMiIiAilCAgIAEqAhAiFSAFKgIQIiyTIiMgAioCECItICyTIhuTIguUIAQqAhAiFiAskyIRIBuTIiQgCpSTIiUgJZQgJCAJlCAdIAuUkyImICaUkpIiCUMAAAA0XkEBcwRAQ///f38hCwwBC0P//39/IQsgGyAiQwAAgD8gCZGVIgmUIg2UIBkgJSAJlCIMlCAaICYgCZQiCpSSkiIOIA6UIglD//9/f11BAXMNAAJAICIgKyAKIA6UIhKTIgogGSAMIA6UIhOTIheUIBogEpMiGCApIBOTIhyUk5QgJSAYIBEgDSAOlCIPkyILlCAbIA+TIg4gCpSTlCAmIA4gHJQgCyAXlJOUkpJDAAAAAF5BAXMNACAiIB8gEpMiDSAclCAKICEgE5MiDJSTlCAlIAogIyAPkyIKlCALIA2Uk5QgJiALIAyUIAogHJSTlJKSQwAAAABeQQFzDQAgCSELICIgGCAMlCANIBeUk5QgJSANIA6UIAogGJSTlCAmIAogF5QgDiAMlJOUkpJDAAAAAF4NAQsCfUP//39/IB0gHZQgICAglJIgJCAklJIiC0MAAAA0XkEBcw0AGkP//39/IBsgJEMAAAAAIBkgHZQgGiAglJIgGyAklJKMIAuVIgtDAACAP5YgC0MAAAAAXRsiC5SSIg8gD5QgGSAdIAuUkiITIBOUIBogICALlJIiEiASlJKSIgtD//9/f11BAXMNABogCwshCwJAICEgKZMiDCAMlCAfICuTIg4gDpSSICMgEZMiCiAKlJIiCUMAAAA0XkEBcw0AIBEgCkMAAAAAICkgDJQgKyAOlJIgESAKlJKMIAmVIglDAACAP5YgCUMAAAAAXRsiCZSSIg0gDZQgKSAMIAmUkiIMIAyUICsgDiAJlJIiCiAKlJKSIgkgC11BAXMNACAJIQsgDCETIAohEiANIQ8LIBkgIZMiDCAMlCAaIB+TIg4gDpSSIBsgI5MiCiAKlJIiCUMAAAA0XkEBcw0AICMgCkMAAAAAICEgDJQgHyAOlJIgIyAKlJKMIAmVIglDAACAP5YgCUMAAAAAXRsiCZSSIg0gDZQgISAMIAmUkiIMIAyUIB8gDiAJlJIiCiAKlJKSIgkgC11BAXMNACAJIQsgDCETIAohEiANIQ8LAkAgCyAAKgIMICggBSoCGJMiCSAJlCAqIAUqAhyTIgkgCZSSICwgBSoCIJMiCSAJlJKRIgkgCZKSIhwgHJRdQQFzDQAgBSoCWCIOQwAAAABDAAAAAEMAAAAAICcgKCATkiInkyIRIB4gKiASkiINkyIXlCAUICeTIhggECANkyIelJMiCSAJlCAeIBUgLCAPkiIKkyIQlCAXIBYgCpMiFJSTIgkgCZQgGCAUlCARIBCUkyIJIAmUkpKRIgxDAACAPyAYIC8gDZMiFZQgLiAnkyIWIBeUkyIJIAmUIBcgLSAKkyINlCAVIBCUkyIJIAmUIBYgEJQgGCANlJMiCSAJlJKSkSIKIAwgFiAelCARIBWUkyIJIAmUIBUgFJQgHiANlJMiCSAJlCARIA2UIBYgFJSTIgkgCZSSkpEiCZKSlSINlCIUIAIqAlgiDJQgCiANlCIVIAQqAlgiCpSSIAkgDZQiLSABKgJYIgmUkiAJQwAAAABfGyAKQwAAAABfGyAMQwAAAABfGyIWkiIQQwAAAABeQQFzDQAgACgCBCIDKgK8AiIKIAAoAggiACoCvAIiCSAKIAleGyENIA4gEJUgAyoCzAKUIQwgFiAQlSAAKgLMApQhCkMAAIC/IAuRlSILIA+UIQkgCyASlCEPIBMgC5QhCwJAIAMoAsAGIgAgAygCxAZHDQAgACAAQQF0QQEgABsiCE4NAAJAIAhFBEBBACEEDAELQej3AUHo9wEoAgBBAWo2AgAgCEE4bEEQQYzSASgCABEDACEEIAMoAsAGIQALIABBAU4EQEEAIQIDQCAEIAJBOGwiAWoiBiADKALIBiABaiIBKQIANwIAIAYgASkCMDcCMCAGIAEpAig3AiggBiABKQIgNwIgIAYgASkCGDcCGCAGIAEpAhA3AhAgBiABKQIINwIIIAJBAWoiAiAARw0ACwsgAygCyAYiAARAIAMtAMwGBEAgAARAQez3AUHs9wEoAgBBAWo2AgAgAEGQ0gEoAgARAAALCyADQQA2AsgGCyADIAQ2AsgGIAMgCDYCxAYgA0EBOgDMBiADKALABiEACyADKALIBiAAQThsaiIAIAw4AjAgACANOAIsIAAgHDgCKCAAIAs4AhggACAUOAIIIAAgBzYCBCAAIAU2AgAgACAKOAI0IABBADYCJCAAIAk4AiAgACAPOAIcIABBADYCFCAAIC04AhAgACAVOAIMIAMgAygCwAZBAWo2AsAGCwvcDAIGfwZ9IwBBwANrIgMkACACKAIkIQIgASgCJCEBAkACQAJAIAAoAhgiBCAAKAIcRw0AIARB7AhqKAIARQ0AIARB9AhqKAIAIAEoAvwCIAIoAvwCIARB2AhqKAIAbGpqLQAADQELIANBiANqIgRCIzcCBCAEQaSQATYCACAEQYquj+kDNgIsIARCgICA/AM3AhQgBEKAgID8g4CAwD83AgwgBEGkkQE2AgAgAyABNgK8AyADQYwqNgKIAyADQQA2ArQDIANB0AJqIgRCIzcCBCAEQaSQATYCACAEQYquj+kDNgIsIARCgICA/AM3AhQgBEKAgID8g4CAwD83AgwgBEGkkQE2AgAgAyACNgKEAyADQYwqNgLQAiADQQA2AvwCAkBB0NgBLQAAQQFxDQBB0NgBEBBFDQACQEGE2QEtAABBAXENAEGE2QEQEEUNAEHY2AFCADcCAEHU2AFBgICA/AM2AgBB4NgBQgA3AgBB7NgBQgA3AgBB6NgBQYCAgPwDNgIAQfTYAUIANwIAQfzYAUKAgID8AzcCAEGE2QEQDwtBwNgBQgA3AgBByNgBQgA3AgBBmNgBQdzYASkCADcCAEGQ2AFB1NgBKQIANwIAQaDYAUHk2AEpAgA3AgBBqNgBQezYASkCADcCAEGw2AFB9NgBKQIANwIAQbjYAUH82AEpAgA3AgBB0NgBEA8LAkBB0NgBLQAAQQFxDQBB0NgBEBBFDQACQEGE2QEtAABBAXENAEGE2QEQEEUNAEHY2AFCADcCAEHU2AFBgICA/AM2AgBB4NgBQgA3AgBB7NgBQgA3AgBB6NgBQYCAgPwDNgIAQfTYAUIANwIAQfzYAUKAgID8AzcCAEGE2QEQDwtBwNgBQgA3AgBByNgBQgA3AgBBmNgBQdzYASkCADcCAEGQ2AFB1NgBKQIANwIAQaDYAUHk2AEpAgA3AgBBqNgBQezYASkCADcCAEGw2AFB9NgBKQIANwIAQbjYAUH82AEpAgA3AgBB0NgBEA8LIAIqAugBIQkgASoC6AEhCiACKgLsASELIAEqAuwBIQwgAioC5AEhDSABKgLkASEOIANBADYCTCADIA4gDZM4AkAgAyAMIAuTOAJIIAMgCiAJkzgCRAJAIANBiANqIANB0AJqQZDYASADQUBrIANBmAJqEMkERQ0AIANCADcCVCADQgA3AkwgA0EANgIYIANBADYCCCADQgA3AjQgAyABNgIwIANCADcCJCADIAI2AiAgA0IANwJEIANBADoA2AEgA0GQJjYCQCADIAMpAzA3AxAgAyADKQMgNwMAIAAgA0GYAmogA0EQaiADIANBQGsQhAVFDQACf0Ho9wFB6PcBKAIAQQFqNgIAQdgBQRBBjNIBKAIAEQMAIgJBBGoLQQBB1AEQCyEBIAJBkCY2AgAgASADQUBrQQRyQeQAEBUaIAIgAykDsAE3AnAgAiADKQOoATcCaCACIAMpA8ABNwKAASACIAMpA7gBNwJ4IAIgAykDyAE3AogBIAIgAykD0AE3ApABIAIgAy0A2AE6AJgBIAIgAygClAI2AtQBIAIgAykCjAI3AswBIAIgAykChAI3AsQBIAIgAykC/AE3ArwBIAIgAykC9AE3ArQBIAIgAykC7AE3AqwBIAIgAykC5AE3AqQBIAIgAykC3AE3ApwBAkAgACgCGCIEKALUBiIFIAQoAtgGRw0AIAUgBUEBdEEBIAUbIgZODQACfyAGBEBB6PcBQej3ASgCAEEBajYCACAGQQJ0QRBBjNIBKAIAEQMAIQcgBCgC1AYhBQsgBUEBTgsEQEEAIQEDQCAHIAFBAnQiCGogBCgC3AYgCGooAgA2AgAgAUEBaiIBIAVHDQALCyAEKALcBiIBBEAgBC0A4AYEQCABBEBB7PcBQez3ASgCAEEBajYCACABQZDSASgCABEAAAsgBCgC1AYhBQsgBEEANgLcBgsgBCAHNgLcBiAEIAY2AtgGIARBAToA4AYLIAQoAtwGIAVBAnRqIAI2AgAgBCAFQQFqNgLUBiACIAIqAkAgACgCGCIBKgLcAiIJIAAoAhwiACoC3AIiCiAJIApeG5Q4AkAgAiACKgJEIAEqAugCIAAqAugCkkMAAAA/lJQ4AkQLDAELQdTaAUHU2gEoAgBBAWo2AgALIANBwANqJAALBABBIAsTACAAIAEgAiABKAIAKAJAEQUAC8MBAgN/BX0gASgCNCIDKAIgIgQoAgAhASADKAIYIgVBAk4EQCACKgIAIgcgASoCCJQgAioCBCIIIAEqAgyUkiACKgIIIgkgASoCEJSSIQZBACECQQEhAQNAIAcgBCABQQJ0aigCACIDKgIIlCAIIAMqAgyUkiAJIAMqAhCUkiIKIAYgCiAGXiIDGyEGIAEgAiADGyECIAFBAWoiASAFRw0ACyAEIAJBAnRqKAIAIQELIAAgASkCCDcCACAAIAEpAhA3AggLaAAgACABIAIQPRogASAAKAIcNgIcIAEgACgCIDYCICABIAAoAiQ2AiQgASAAKAIoNgIoIAEgACgCDDYCDCABIAAoAhA2AhAgASAAKAIUNgIUIAEgACgCGDYCGCABIAAoAiw2AixBpCsLDwAgACAAKAIAKAIwEQYACwUAQZgrCwcAIABBDGoLwwkBB38jAEGQA2siAiQAIAEoAiQhAyACQdgCaiIBQiM3AgQgAUGkkAE2AgAgAUGKro/pAzYCLCABQoCAgPwDNwIUIAFCgICA/IOAgMA/NwIMIAFBpJEBNgIAIAIgAzYCjAMgAkGMKjYC2AIgAkEANgKEAyAAKAIcIgEoAgQhBAJAIAEoAggtAMwBQQNxQQAgAy0A+AIbDQACQEHQ2AEtAABBAXENAEHQ2AEQEEUNAAJAQYTZAS0AAEEBcQ0AQYTZARAQRQ0AQdjYAUIANwIAQdTYAUGAgID8AzYCAEHg2AFCADcCAEHs2AFCADcCAEHo2AFBgICA/AM2AgBB9NgBQgA3AgBB/NgBQoCAgPwDNwIAQYTZARAPC0HA2AFCADcCAEHI2AFCADcCAEGY2AFB3NgBKQIANwIAQZDYAUHU2AEpAgA3AgBBoNgBQeTYASkCADcCAEGo2AFB7NgBKQIANwIAQbDYAUH02AEpAgA3AgBBuNgBQfzYASkCADcCAEHQ2AEQDwsgACgCHCgCDCEBIAJCADcDUCACQoCAgPwDNwNIIAJB2AJqIAQgASACQcgAaiACQaACahDJBEUNACACQgA3AlwgAkIANwJUIAJCADcCTCACQQA6AOABIAJBkCY2AkggAkIANwI8IAIgAzYCOCACIAAoAhwoAggiATYCMCACQQA2AiggASgC7AEhAyACQQA2AiAgAiABNgIQIAIgASADQR50QR91cTYCLCACIAIpAzg3AxggAiACKQMoNwMIIAAgAkGgAmogAkEYaiACQQhqIAJByABqEIQFRQ0AAn9B6PcBQej3ASgCAEEBajYCAEHYAUEQQYzSASgCABEDACIBQQRqC0EAQdQBEAshAyABQZAmNgIAIAMgAkHIAGpBBHJB5AAQFRogASACKQO4ATcCcCABIAIpA7ABNwJoIAEgAikDyAE3AoABIAEgAikDwAE3AnggASACKQPQATcCiAEgASACKQPYATcCkAEgASACLQDgAToAmAEgASACKAKcAjYC1AEgASACKQKUAjcCzAEgASACKQKMAjcCxAEgASACKQKEAjcCvAEgASACKQL8ATcCtAEgASACKQL0ATcCrAEgASACKQLsATcCpAEgASACKQLkATcCnAECQCAAKAIYIgMoAtQGIgQgAygC2AZHDQAgBCAEQQF0QQEgBBsiBk4NAAJ/IAYEQEHo9wFB6PcBKAIAQQFqNgIAIAZBAnRBEEGM0gEoAgARAwAhByADKALUBiEECyAEQQFOCwRAA0AgByAFQQJ0IghqIAMoAtwGIAhqKAIANgIAIAVBAWoiBSAERw0ACwsgAygC3AYiBQRAIAMtAOAGBEAgBQRAQez3AUHs9wEoAgBBAWo2AgAgBUGQ0gEoAgARAAALIAMoAtQGIQQLIANBADYC3AYLIAMgBzYC3AYgAyAGNgLYBiADQQE6AOAGCyADKALcBiAEQQJ0aiABNgIAIAMgBEEBajYC1AYgACgCGCEDIAECfyAAKAIcKAIILQDMAUEDcQRAIAEgAyoC2AIgASoCQJQ4AkAgA0HkAmoMAQsgASADKgLUAiABKgJAlDgCQCADQeACagsqAgAgASoCRJQ4AkQLIAJBkANqJAALjQQBBn8CQCAAKAIEIgQgACgCCEcNACAEIARBAXRBASAEGyIFTg0AAn8gBQRAQej3AUHo9wEoAgBBAWo2AgAgBUHoAGxBEEGM0gEoAgARAwAhBiAAKAIEIQQLIARBAU4LBEADQCAGIAdB6ABsIgNqIgIgACgCDCADaiIDKQIANwIAIAIgAygCGDYCGCACIAMpAhA3AhAgAiADKQIINwIIIAIgAykCJDcCJCACIAMpAhw3AhwgAiADKQI0NwI0IAIgAykCLDcCLCACIAMpAjw3AjwgAiADKQJENwJEIAIgAykCTDcCTCACIAMpAlQ3AlQgAiADKQJcNwJcIAIgAygCZDYCZCAHQQFqIgcgBEcNAAsLIAAoAgwiAgRAIAAtABAEQCACBEBB7PcBQez3ASgCAEEBajYCACACQZDSASgCABEAAAsLIABBADYCDAsgACAGNgIMIABBAToAECAAIAU2AgggACgCBCEECyAAKAIMIARB6ABsaiICIAEpAgA3AgAgAiABKAIYNgIYIAIgASkCEDcCECACIAEpAgg3AgggAiABKQIkNwIkIAIgASkCHDcCHCACIAEpAjQ3AjQgAiABKQIsNwIsIAIgASkCRDcCRCACIAEpAjw3AjwgAiABKQJMNwJMIAIgASkCVDcCVCACIAEpAlw3AlwgAiABKAJkNgJkIAAgACgCBEEBajYCBAvtBgIEfxF9IwBBsAFrIgIkAAJAIAEtAGRBAXENACAAKAIEIAAoAgggAUEIaiAAQRBBFCABKgJYQwAAAABeG2oqAgAgAkHIAGoQ6A9FDQAgASoCWCEGAn8gACgCDCIDRQRAIAZDAAAAAJJDAAAAAF5FDQIgACgCCCgCCEEEagwBCyAGIAMqAtgCIgiSQwAAAABeQQFzDQEgA0EEagshBAJAQdDaAS0AAEEBcQ0AQdDaARAQRQ0AQcjaAUIANwIAQcDaAUIANwIAQbjaAUIANwIAQbDaAUIANwIAQajaAUIANwIAQaDaAUIANwIAQdDaARAPCyAAKAIMIQMgBCoCNCEHIAEqAgwhDCAEKgI4IQogASoCECENIAQqAjAhCSABKgIIIREgAkEANgJEIAIgDSAKkyIKOAJAIAIgDCAHkyILOAI8IAIgESAJkyIJOAI4IANBiAJqQaDaASADGyEFAn0gA0UEQCAAKAIEIgQqAsQDIQdDAAAAACEJQwAAAAAMAQsgCyADKgLIAiIOlCAJIAMqAswCIg+UkyADKgLAApIgACgCBCIEKgLEAyIHlCESIAMqArwCIAkgAyoC0AIiEJQgCiAOlJOSIAeUIQkgCiAPlCALIBCUkyADKgK4ApIgB5QLIQogBCoCvAIhECABKgIgIRMgASoCHCEUIAAoAggoAggqAuABIRUgASoCGCEWIAIgATYCYCACKgJUIQsgAioCUCEOIAIqAkwhDyACQQhqIAcgBiAIIAUgAkE4ahCIBSACIAIpAxA3AmwgAiACKQMYNwJ0IAIgAikDIDcCfCACIAIpAyg3AoQBIAIgAikDMDcCjAEgAiACQUBrKQMANwKcASACIAIpAwg3AmQgAiACKQM4NwKUASACIAYgACgCBCIBKgLEA5Q4AqQBIAJDAAAAAEMAAIA/IBAgFZQiB5MgDSATkyASkyIGIAsgDyARIBaTIAqTIgiUIA4gDCAUkyAJkyIMlJIgBiALlJIiBpSTIg0gDZQgCCAPIAaUkyIIIAiUIAwgDiAGlJMiCCAIlJKSIAcgBiAGIAeUlJRdGzgCqAEgAiABQcgCaiABQcQCaiAAKAIIKAIIKALMAUEDcRsoAgA2AqwBIAFBqAZqIAJByABqEMwPIAAoAgwiAEUNACAAQQAQPgsgAkGwAWokAAsMACAAIAEoAiQQzQ8LQgECfyMAQRBrIgMkACADIAA4AgwgAyABOAIIIAMgAjgCBEEQEA0iBCADQQxqIANBCGogA0EEahAJIANBEGokACAECwcAIAAqAgwLCQAgACABOAIMCxwAIABCgICA/AM3AgggAEKAgID8g4CAwD83AgALBQBBpCgLQgACQEGY2QEtAABBAXENAEGY2QEQEEUNAEGQ2QFCgICA/AM3AgBBiNkBQoCAgPyDgIDAPzcCAEGY2QEQDwtBiNkBC6IHAgF/Gn0gACgCECIAKgKEByEIIAAqAoAHIQkgACoCjAchCiAAKgKQByELIAAqApQHIRIgACoC/AYhEyABKgI0IQUgASoCFCEOIAEqAhghFCABKgI4IQYgASoCJCEPIAEqAighFSABKgIwIQcgASoCCCEYIAEqAgAhGSABKgIEIRogASoCECEQIAEqAiAhESMAQYABayIBQQA2AnwgAUEANgJsIAFBADYCXCABQQA2AkwgAUEANgI8IAFBADYCLCABQQA2AhwgASAGIBMgEZQiGyALIA+UIhaSIhwgEiAVlCIMkpI4AnggASAFIBMgEJQiHSALIA6UIheSIh4gEiAUlCINkpI4AnQgASAGIAogEZQiESAWkiIWIAySkjgCaCABIAUgCiAQlCIQIBeSIhcgDZKSOAJkIAEgBiARIAkgD5QiD5IiESAMkpI4AlggASAFIBAgCSAOlCIOkiIQIA2SkjgCVCABIAYgGyAPkiIPIAySkjgCSCABIAUgHSAOkiIOIA2SkjgCRCABIAYgHCAIIBWUIgySkjgCOCABIAUgHiAIIBSUIg2SkjgCNCABIAYgFiAMkpI4AiggASAFIBcgDZKSOAIkIAEgBiARIAySkjgCGCABIAUgECANkpI4AhQgAUEANgIMIAEgByATIBmUIhMgCyAalCIUkiIVIBIgGJQiC5KSOAJwIAEgByAKIBmUIgogFJIiEiALkpI4AmAgASAHIAogCSAalCIJkiIKIAuSkjgCUCABIAcgEyAJkiIJIAuSkjgCQCABIAcgFSAIIBiUIgiSkjgCMCABIAcgEiAIkpI4AiAgASAHIAogCJKSOAIQIAEgBiAPIAySkjgCCCABIAUgDiANkpI4AgQgASAHIAkgCJKSOAIAIAMgASkDCDcCCCADIAEpAwA3AgAgAiABKQMINwIIIAIgASkDADcCAEEBIQADQCABIABBBHRqIgQqAgAiBSACKgIAXUEBc0UEQCACIAU4AgALIAQqAgQiBiACKgIEXUEBc0UEQCACIAY4AgQLIAQqAggiByACKgIIXUEBc0UEQCACIAc4AggLIAQqAgwiCCACKgIMXUEBc0UEQCACIAg4AgwLIAMqAgAgBV1BAXNFBEAgAyAFOAIACyADKgIEIAZdQQFzRQRAIAMgBjgCBAsgAyoCCCAHXUEBc0UEQCADIAc4AggLIAMqAgwgCF1BAXNFBEAgAyAIOAIMCyAAQQFqIgBBCEcNAAsLEQAgACABIAAoAgAoAgwRAgALGAECf0EQEA0iACEBIwBBEGsgATYCDCAACy4AIAEgACkC/AY3AgAgASAAKQKEBzcCCCACIAApApQHNwIIIAIgACkCjAc3AgALtgYBCX8CQAJAIAAoAjAiCEF/aiABKAIAIgMgA0EPdEF/c2oiBEEKdSAEc0EJbCIEQQZ1IARzIgQgBEELdEF/c2oiBEEQdSAEc3EiByAAKAIETw0AIAAoAgwgB0ECdGooAgAiBUF/Rg0AIAAoAkghBANAIAQgBUEDdGooAgAgA0YNAiAAKAIgIAVBAnRqKAIAIgVBf0cNAAsLIAAoAiwiCSEDAkAgCCAJRw0AIAgiAyADQQF0QQEgAxsiCk4NAEEAIQUgCgRAQej3AUHo9wEoAgBBAWo2AgAgCkECdEEQQYzSASgCABEDACEGIAAoAiwhAwsgACgCNCEEAkACQCADQQFOBEADQCAGIAVBAnQiC2ogBCALaigCADYCACAFQQFqIgUgA0cNAAwCAAsACyAERQ0BCyAALQA4BEAgBARAQez3AUHs9wEoAgBBAWo2AgAgBEGQ0gEoAgARAAALCyAAQQA2AjQgACgCLCEDCyAAIAY2AjQgACAKNgIwIABBAToAOAsgACgCNCADQQJ0aiACKAIANgIAIAAgACgCLEEBajYCLAJAIABBQGsoAgAiAyAAKAJERw0AIAMgA0EBdEEBIAMbIgRODQACQCAERQRAQQAhBgwBC0Ho9wFB6PcBKAIAQQFqNgIAIARBA3RBEEGM0gEoAgARAwAhBiAAKAJAIQMLIANBAU4EQEEAIQUDQCAGIAVBA3QiAmogACgCSCACaikCADcCACAFQQFqIgUgA0cNAAsLIAAoAkgiAgRAIAAtAEwEQCACBEBB7PcBQez3ASgCAEEBajYCACACQZDSASgCABEAAAsLIABBADYCSAsgACAGNgJIIAAgBDYCRCAAQQE6AEwgACgCQCEDCyAAKAJIIANBA3RqIAEpAgA3AgAgACAAKAJAQQFqNgJAIAggACgCMEgEQCAAEIYFIAAoAjBBf2ogASgCACIBIAFBD3RBf3NqIgFBCnUgAXNBCWwiAUEGdSABcyIBIAFBC3RBf3NqIgFBEHUgAXNxIQcLIAAoAiAgCUECdGogACgCDCAHQQJ0aiIAKAIANgIAIAAgCTYCAA8LIAAoAjQgBUECdGogAigCADYCAAvFNQERfyMAQeAAayIIJAAgACABIAIQyAIaIAhBAToANCAIQQA2AjAgCEEBOgBIIAhCADcDKCAIQQA2AkQgCEEBOgBcIAhCADcCPCAIQQA2AlggCEIANwNQIAhBADYCHCAIQQE6ACAgCEIANwIUIAEgACgC6AYiAzYCpAICQCADRQRAIAFBADYChAIMAQsgASACIABB5AZqIgogAigCACgCHBEDACIDNgKEAiADRQ0AIAJBBCABKAKkAiIHIAIoAgAoAhARBwAhCSAHQQBKBEAgCSgCCCEGA0AgBgJ/QQAgACgC8AYgBUECdGooAgAiA0UNABogAiADIAIoAgAoAhwRAwALNgIAIAIgAyACKAIAKAIYEQMARQRAIAJBEEEBIAIoAgAoAhARBwAiCygCCCIEIAMoAhA2AgwgBCADKAIINgIEIAQgAygCBDYCACAEIAMoAgw2AgggAiALQZIkQdOEtaIFIAMgAigCACgCFBEJAAsgBkEEaiEGIAVBAWoiBSAHRw0ACwsgAiAJQZIkQcGkhcoFIAogAigCACgCFBEJAAsgASAAKALIBSIDNgKoAgJAIANFBEAgAUEANgKIAgwBCyABIAIgAEHEBWoiCiACKAIAKAIcEQMAIgM2AogCIANFDQAgAkHkACABKAKoAiIJIAIoAgAoAhARBwAiCygCCCEDQQAhBiAIQQA2AgwgCUEBTgRAA0AgAyAAKALQBSIHIAZB6ABsaiIFKAI4NgI0IAMgBSgCPDYCOCADIAVBQGsoAgA2AjwgA0FAayAFKAJENgIAIAMgBSgCXDYCWEEAIQQgA0EAIAUtAGRBAXFrNgJcIAMgBSgCWDYCVCAFKAIEIgUEQCACIAUgAigCACgCHBEDACEEIAAoAtAFIQcgCCgCDCEGCyADIAQ2AgAgAyAHIAZB6ABsaiIEKAJINgJEIAMgBCgCTDYCSCADIAQoAlA2AkwgAyAEKAJUNgJQIAMgBCgCCDYCBCADIAQoAgw2AgggAyAEKAIQNgIMIAMgBCgCFDYCECADIAQoAhg2AhQgAyAEKAIcNgIYIAMgBCgCIDYCHCADIAQoAiQ2AiAgAyAEKAIoNgIkIAMgBCgCLDYCKCADIAQoAjA2AiwgAyAEKAI0NgIwIAggBDYCACAIQRBqIAggCEEMahDZDyAIIAgoAgxBAWoiBjYCDCADQeQAaiEDIAYgCUgNAAsLIAIgC0GnJEHThLmiBCAKIAIoAgAoAhQRCQALIAEgACgC3AUiAzYCrAICQCADRQRAIAFBADYCjAIMAQsgASACIAAoAuQFIAIoAgAoAhwRAwAiAzYCjAIgA0UNACACQRQgASgCrAIiBCACKAIAKAIQEQcAIQkgACgC5AUhByAEQQFOBEAgCSgCCCEDQQAhBQNAIANBACAHIAVBNGwiCmoiCy0AFEEBcWs2AhBBACEGIAsoAgQiCwRAIAIgCyACKAIAKAIcEQMAIQYgACgC5AUhBwsgAyAGNgIAIAMgByAKaiIGKAIIIgoEfyAKIAAoAtAFa0HoAG0FQX8LNgIEIAMgBigCDCIKBH8gCiAAKALQBWtB6ABtBUF/CzYCCCADIAYoAhA2AgwgA0EUaiEDIAVBAWoiBSAERw0ACwsgAiAJQbgkQcGkhcoFIAcgAigCACgCFBEJAAsgASAAKALwBSIDNgKwAgJAIANFBEAgAUEANgKQAgwBCyABIAIgACgC+AUgAigCACgCHBEDACIDNgKQAiADRQ0AIAJBJCABKAKwAiIJIAIoAgAoAhARBwAhCiAAKAL4BSEHIAlBAU4EQCAKKAIIIQNBACEGA0BBACEFIAcgBkEsbCIEaigCBCILBEAgAiALIAIoAgAoAhwRAwAhBSAAKAL4BSEHCyADIAU2AhAgAyAEIAdqIgQoAhQ2AgAgAyAEKAIYNgIEIAMgBCgCHDYCCCADIAQoAiA2AgwgAyAEKAIIIgUEfyAFIAAoAtAFa0HoAG0FQX8LNgIUIAMgBCgCDCIFBH8gBSAAKALQBWtB6ABtBUF/CzYCGCADAn9BfyAEKAIQIgVFDQAaIAUgACgC0AVrQegAbQs2AhwgAyAEKAIkNgIgIANBJGohAyAGQQFqIgYgCUcNAAsLIAIgCkHJJEHBpIXKBSAHIAIoAgAoAhQRCQALIAEgACgChAYiAzYCtAICQCADRQRAIAFBADYClAIMAQsgASACIAAoAowGIAIoAgAoAhwRAwAiAzYClAIgA0UNAEEAIQcgAkHkACABKAK0AiIJIAIoAgAoAhARBwAhCgJAIAlBAEwEQCAAKAKMBiEGDAELIAAoAowGIQYgCigCCCEDA0AgAyAGIAdB6ABsIgtqIgQoAiA2AgAgAyAEKAIkNgIEIAMgBCgCKDYCCCADIAQoAiw2AgwgAyAGKAIIIgUEfyAFIAAoAtAFa0HoAG0FQX8LNgJEIAMgBCgCMDYCECADIAQoAjQ2AhQgAyAEKAI4NgIYIAMgBCgCPDYCHCADIAYoAnQiBQR/IAUgACgC0AVrQegAbQVBfws2AkggAyAEQUBrKAIANgIgIAMgBCgCRDYCJCADIAQoAkg2AiggAyAEKAJMNgIsIAMgBigC4AEiBQR/IAUgACgC0AVrQegAbQVBfws2AkwgAyAEKAJQNgIwIAMgBCgCVDYCNCADIAQoAlg2AjggAyAEKAJcNgI8IAMgBigCzAIiBQR/IAUgACgC0AVrQegAbQVBfws2AlAgAyAEKAJgNgJYIAMgBCgCZDYCXAJAIAQoAgQiBARAIAIgBCACKAIAKAIcEQMAIQUgACgCjAYhBgwBC0EAIQULIAMgBTYCQCADIAYgC2ooAhg2AlQgA0HkAGohAyAHQQFqIgcgCUcNAAsLIAIgCkHaJEHBpIXKBSAGIAIoAgAoAhQRCQALIAEgACgCmAYiAzYCuAICQCADRQRAIAFBADYCmAIMAQsgASACIAAoAqAGIAIoAgAoAhwRAwAiAzYCmAIgA0UNACACQdwAIAEoArgCIgcgAigCACgCEBEHACEJIAAoAqAGIQUgB0EBTgRAIAkoAgghA0EAIQYDQCADIAUgBkHgAGxqIgQoAhw2AgAgAyAEKAIgNgIEIAMgBCgCJDYCCCADIAQoAig2AgwgAyAEKAIsNgIQIAMgBCgCMDYCFCADIAQoAjQ2AhggAyAEKAI4NgIcIAMgBCgCPDYCICADIARBQGsoAgA2AiQgAyAEKAJENgIoIAMgBCgCSDYCLCADIAQoAkw2AjAgAyAEKAJQNgI0IAMgBCgCVDYCOCADIAQoAlg2AjwgAyAEKAJcNgJYIAMgBCgCBDYCQCADIAQoAgg2AkQgAyAEKAIMNgJIIAMgBCgCEDYCTCADAn9BfyAEKAIAIgVFDQAaIAUgACgC0AVrQegAbQs2AlQgAwJ/QQAgBCgCFCIERQ0AGiACIAQgAigCACgCHBEDAAs2AlAgA0HcAGohAyAAKAKgBiEFIAZBAWoiBiAHRw0ACwsgAiAJQewkQcGkhcoFIAUgAigCACgCFBEJAAsgASAAKAK8AjYC4AIgASAAKAKkAjYCyAIgASAAKAK0AjYC2AIgASAAKAKgAjYCxAIgASAAKAKwAjYC1AIgASAAKAKsAjYC0AIgASAAKAL4AjYCnAMgASAAKAL8AjYCoAMgASAAKAKAAzYCpAMgASAAKAL0AjYCmAMgACgC7AIhAyABIAAoAqgCNgLMAiABIAAoAsACNgLkAiABIAAoAoQDNgKoAyABIAAoArgCNgLcAiABIAAoAsQCNgLoAiABIAAoAsgCNgLsAiABIAAoAswCNgLwAiABIAAoAtACNgL0AiAAKALwAiEEIAEgAzYCkAMgASAENgKUAyABIAAoAtQCNgL4AiABIAAoAtgCNgL8AiABIAAoAtwCNgKAAyABIAAoAuACNgKEAyABIAAoAuQCNgKIAyABIAAoAugCNgKMAyABIAIgAEHYA2oiCyACKAIAKAIcEQMANgKAAiACQcABQQEgAigCACgCEBEHACIMKAIIIgMgACgC+AQ2AmAgAyAAKAL8BDYCZCADIAAoAoAFNgJoIAMgACgChAU2AmwgAyAAKAKIBTYCcCADIAAoAowFNgJ0IAMgACgCkAU2AnggAyAAKAKUBTYCfCADIAAoApgFNgKAASADIAAoApwFNgKEASADIAAoAqAFNgKIASADIAAoAqQFNgKMASADIAAtANkDNgK0ASADIAAtANgDNgKwASADIAAoAogENgKQASADIAAoAowENgKUASADIAAoApAENgKYASADIAAoApQENgKcASADIAAoAuQDIgQ2AqgBAkAgBEUEQCADQQA2AqABDAELIAMgAiAAKALsAyACKAIAKAIcEQMANgKgASADKAKoASIERQ0AIAJBECAEIAIoAgAoAhARBwAhCSAAKALsAyEKIARBAU4EQCAJKAIIIQVBACEHA0AgBSAKIAdBBHRqIgYoAgA2AgAgBSAGKAIENgIEIAUgBigCCDYCCCAFIAYoAgw2AgwgBUEQaiEFIAdBAWoiByAERw0ACwsgAiAJQYAlQcGkhcoFIAogAigCACgCFBEJAAsgAyAAKALcAzYCuAEgAyAAKAKYBDYCACADIAAoApwENgIEIAMgACgCoAQ2AgggAyAAKAKkBDYCDCADIAAoAqgENgIQIAMgACgCrAQ2AhQgAyAAKAKwBDYCGCADIAAoArQENgIcIAMgACgCuAQ2AiAgAyAAKAK8BDYCJCADIAAoAsAENgIoIAMgACgCxAQ2AiwgAyAAKALIBDYCMCADIAAoAswENgI0IAMgACgC0AQ2AjggAyAAKALUBDYCPCADQUBrIAAoAtgENgIAIAMgACgC3AQ2AkQgAyAAKALgBDYCSCADIAAoAuQENgJMIAMgACgC6AQ2AlAgAyAAKALsBDYCVCADIAAoAvAENgJYIAMgACgC9AQ2AlwgAyAAKAL4AyIENgKsAQJAIARFBEAgA0EANgKkAQwBCyADIAIgACgCgAQgAigCACgCHBEDADYCpAEgAygCrAEiBEUNACACQQQgBCACKAIAKAIQEQcAIQYgACgCgAQhByAEQQFOBEAgBigCCCEDQQAhBQNAIAMgByAFQQJ0aigCADYCACADQQRqIQMgBUEBaiIFIARHDQALCyACIAZBkyVBwaSFygUgByACKAIAKAIUEQkACyACIAxBmSVBwaSFygUgCyACKAIAKAIUEQkAIAEgAEHYCGooAgAiAzYCvAICQCADRQRAIAFBADYCnAIMAQsgASACIABB4AhqKAIAKAIAIAIoAgAoAhwRAwA2ApwCIAEoArwCIglFDQAgAkHcAiAJIAIoAgAoAhARBwAhCyAAKALgCCEDIAlBAU4EQCALKAIIIQRBACEKA0AgBCADIApBAnQiB2ooAgAiAygC6AI2AsACIAQgAygCzAI2AoACIAQgAygC0AI2AoQCIAQgAygC1AI2AogCIAQgAygC2AI2AowCIAQgAygC/AI2AtgCIAQgAy0A+QI2AtQCIAQgAygC5AE2AqABIAQgAygC6AE2AqQBIAQgAygC7AE2AqgBIAQgAygC8AE2AqwBIAQgAy0A+AI2AtACIAQgAygClAI2AtABIAQgAygCmAI2AtQBIAQgAygCnAI2AtgBIAQgAygCoAI2AtwBIAQgAygCpAI2AuABIAQgAygCqAI2AuQBIAQgAygCrAI2AugBIAQgAygCsAI2AuwBIAQgAygCPDYCACAEIANBQGsoAgA2AgQgBCADKAJENgIIIAQgAygCSDYCDCAEIAMoAkw2AhAgBCADKAJQNgIUIAQgAygCVDYCGCAEIAMoAlg2AhwgBCADKAJcNgIgIAQgAygCYDYCJCAEIAMoAmQ2AiggBCADKAJoNgIsIAQgAygCbDYCMCAEIAMoAnA2AjQgBCADKAJ0NgI4IAQgAygCeDYCPCAEIAMoAnw2AqgCIAQgAygCgAE2AqwCIAQgAygCtAE2AnAgBCADKAK4ATYCdCAEIAMoArwBNgJ4IAQgAygCwAE2AnwgBCADKALEATYCgAEgBCADKALIATYChAEgBCADKALMATYCiAEgBCADKALQATYCjAEgBCADKALUATYCkAEgBCADKALYATYClAEgBCADKALcATYCmAEgBCADKALgATYCnAEgBCADKALkAjYCvAIgBCADKAKEATYCQCAEIAMoAogBNgJEIAQgAygCjAE2AkggBCADKAKQATYCTCAEIAMoApQBNgJQIAQgAygCmAE2AlQgBCADKAKcATYCWCAEIAMoAqABNgJcIAQgAygCpAE2AmAgBCADKAKoATYCZCAEIAMoAqwBNgJoIAQgAygCsAE2AmwgBCADKAK8AjYC8AEgBCADKALAAjYC9AEgBCADKALEAjYC+AEgBCADKALIAjYC/AEgBCADKALsAjYCxAIgBCADKALwAjYCyAIgBCADKALgAjYCuAIgBCADKALkAjYCvAIgBCADKALoAjYCwAIgBCADKAL0AjYCzAIgBCADKAIsIgU2ApwCIAQgAygCBDYCpAIgBCADKAIYNgKgAiAEIAMoArQCNgKwAiAEIAMoAvQBNgKwASAEIAMoAvgBNgK0ASAEIAMoAvwBNgK4ASAEIAMoAoACNgK8ASAEIAMoAoQCNgLAASAEIAMoAogCNgLEASAEIAMoAowCNgLIASAEIAMoApACNgLMASAEIAMoArgCNgK0AgJAIAVFBEAgBEEANgKQAgwBCyAEIAIgAygCNCACKAIAKAIcEQMAIgM2ApACIANFDQAgAkEQIAQoApwCIgwgAigCACgCEBEHACENIAAoAuAIIAdqKAIAKAI0IQ4gDEEBTgRAIA0oAgghA0EAIQYDQCADIA4gBkEEdGoiBSgCADYCACADIAUoAgQ2AgQgAyAFKAIINgIIIAMgBSgCDDYCDCADQRBqIQMgBkEBaiIGIAxHDQALCyACIA1BgCVBwaSFygUgDiACKAIAKAIUEQkACwJAIAQoAqQCRQRAIARBADYCmAIMAQsgBCACIAAoAuAIIAdqKAIAKAIMIAIoAgAoAhwRAwAiAzYCmAIgA0UNACACQQQgBCgCpAIiBiACKAIAKAIQEQcAIQwgACgC4AggB2ooAgAoAgwhDSAGQQFOBEAgDCgCCCEDQQAhBQNAIAMgDSAFQQJ0aigCADYCACADQQRqIQMgBUEBaiIFIAZHDQALCyACIAxBkyVBwaSFygUgDSACKAIAKAIUEQkACwJAIAQoAqACRQRAIARBADYClAIMAQsgBCACIAAoAuAIIAdqKAIAQRRqIAIoAgAoAhwRAwAiAzYClAIgA0UNACACQQQgBCgCpAIiDCACKAIAKAIQEQcAIQ0gACgC4AggB2ooAgAhDiAMQQFOBEAgDigCICEQIA0oAgghBkEAIQUgCCgCRCERIAgoAjAhEiAIKAJYIQ8gCCgCHCETA0AgDyATIAgoAkBBf2ogECAFQQJ0aigCACIHQQ90QX9zIAdqIgNBCnUgA3NBCWwiA0EGdSADcyIDIANBC3RBf3NqIgNBEHUgA3NxQQJ0aigCACIDQQN0aigCACAHRwRAA0AgDyASIANBAnRqKAIAIgNBA3RqKAIAIAdHDQALCyAGIBEgA0ECdGooAgA2AgAgBkEEaiEGIAVBAWoiBSAMRw0ACwsgAiANQaolQcGkhcoFIA5BFGogAigCACgCFBEJAAsgBEHcAmohBCAAKALgCCEDIApBAWoiCiAJRw0ACwsgAiALQa4lQcGkhcoFIAMoAgAgAigCACgCFBEJAAsgASAAKALUBiIDNgLAAgJAIANFBEAgAUEANgKgAgwBCyABIAIgACgC3AYgAigCACgCHBEDACIBNgKgAiABRQ0AIAJB6AAgACgC1AYiCSACKAIAKAIQEQcAIQogACgC3AYhByAJQQFOBEAgCigCCCEDQQAhBANAIAMgByAEQQJ0IgZqKAIAIgEgASgCACgCFBEBADYCYCADIAAoAtwGIAZqIgUoAgAiASgCHDYCCCADIAEoAiA2AgwgAyABKAIkNgIQIAMgASgCKDYCFCADIAEoAiw2AhggAyABKAIwNgIcIAMgASgCNDYCICADIAEoAjg2AiQgAyABKAI8NgIoIAMgASgCQDYCLCADIAEoAkQ2AjAgAS0AmAEhASADQgA3AjggA0IANwIAIAMgATYCNCADQUBrQgA3AgAgA0IANwJIIANCADcCUCAFKAIAKAIEIgEEQCADQQE2AlggAyACIAEgAigCACgCHBEDADYCAAsCfwJ/An8gACgC3AYiByAGaigCACIFKAIMIgEEQCADQQM2AlggAyACIAEgAigCACgCHBEDADYCACAAKALcBiIHIAZqKAIAIQULIAUoAggiAQsEQCADQQI2AlggAyACIAEgAigCACgCHBEDADYCACAAKALcBiIHIAZqKAIAIQULIAUoAhAiAQsEQCADQQE2AlwgAyACIAEgAigCACgCHBEDADYCBCAAKALcBiIHIAZqKAIAIQULIAUoAhgiAQsEfyADQQM2AlwgAyACIAEgAigCACgCHBEDADYCBCAAKALcBiIHIAZqKAIABSAFCygCFCIBBEAgA0ECNgJcIAMgAiABIAIoAgAoAhwRAwA2AgQgACgC3AYhBwsgA0HoAGohAyAEQQFqIgQgCUcNAAsLIAIgCkHCJUHBpIXKBSAHIAIoAgAoAhQRCQALIAgoAlgiAARAIAgtAFwEQCAABEBB7PcBQez3ASgCAEEBajYCACAAQZDSASgCABEAAAsLIAhBADYCWAsgCEEANgJYIAhBAToAXCAIQgA3A1AgCCgCRCIABEAgCC0ASARAIAAEQEHs9wFB7PcBKAIAQQFqNgIAIABBkNIBKAIAEQAACwsgCEEANgJECyAIQQA2AkQgCEEBOgBIIAhCADcCPCAIKAIwIgAEQCAILQA0BEAgAARAQez3AUHs9wEoAgBBAWo2AgAgAEGQ0gEoAgARAAALCyAIQQA2AjALIAhBADYCMCAIQQE6ADQgCEIANwMoIAgoAhwiAARAIAgtACAEQCAABEBB7PcBQez3ASgCAEEBajYCACAAQZDSASgCABEAAAsLIAhBADYCHAsgCEHgAGokAEHWJQsFAEGsAwu+BQIEfwR9IwBBoAFrIgIkAAJAIAAoAoQDQQ9xQX9qIgNBAUsNACADQQFrBEAgAkG4KDYCACABKAIMIgMqAjghByADKgI0IQggASgCCCIEKALsASEFIAMqAjAhCSAAKALAASIDIAMoAgAoAjARBgAhBiABKAIEIgMgASgCDCACQZABaiACQYABaiADKAIAKAIIEQQAIAIgAikDmAE3A2ggAiACKQOAATcDcCACIAIpA4gBNwN4IAIgAioCaCAGkzgCaCACIAYgAioCcJI4AnAgAiACKQOQATcDYCACIAIqAmAgBpM4AmAgAiACKgJkIAaTOAJkIAIgBiACKgJ0kjgCdCACIAYgAioCeJI4AnggAiAGOAIUIAIgBiAJIAmTIgYgBpQgCCAIkyIGIAaUkiAHIAeTIgYgBpSSkZI4AhAgAiAEIAVBHnRBH3VxNgIMIAIgATYCCCACIAA2AgQgAEGgB2ogACgCoAcgAkHgAGogAhBpDAELIAJBADYCFCACQYCAgPwDNgIEIAJBjCk2AgAgAiAANgIYIAIgATYCHCACIAAoAsgDNgIIIAIgASgCBCIDIAMoAgAoAjARBgAgACgCwAEiAyADKAIAKAIwEQYAkiIGOAIMIAIgASgCCCoC4AEiBzgCYCACIABBvAJqIAJB4ABqIAAqArwCIAddGygCADYCECABKAIEIgMgASgCDCACQZABaiACQYABaiADKAIAKAIIEQQAIAIgAikDmAE3A2ggAiACKQOAATcDcCACIAIpA4gBNwN4IAIgAioCaCAGkzgCaCACIAYgAioCcJI4AnAgAiAGIAIqAnSSOAJ0IAIgAikDkAE3A2AgAiACKgJgIAaTOAJgIAIgAioCZCAGkzgCZCACIAYgAioCeJI4AnggAEGYCGogACgCmAggAkHgAGogAhBpCyACQaABaiQAC5YCAgR/CX0gACgC3AUiBUEBTgRAIAAoAuQFIQYDQAJAIAYgBEE0bGoiAyoCGCIHQwAAAABeQQFzDQAgAyoCHCIIIAMoAgwiACoCCCADKAIIIgMqAggiC5MiAiAClCAAKgIMIAMqAgwiDJMiCSAJlJIgACoCECADKgIQIg2TIgogCpSSIg6SIg9DAAAANF5BAXMNACADIA0gCiAIIA6TIAcgD5SVIAGUIgggAyoCWJQiB5STOAIQIAMgDCAJIAeUkzgCDCADIAsgAiAHlJM4AgggACAAKgIIIAIgCCAAKgJYlCIClJI4AgggACAKIAKUIAAqAhCSOAIQIAAgCSAClCAAKgIMkjgCDAsgBEEBaiIEIAVHDQALCwvOBQIIfw59IAAoAsAGIglBAU4EQCAAKALIBiEKA0AgCiAIQThsaiIDIQBDAAAAACESQwAAAAAhEUMAAAAAIRMgAygCACIHKgIIIhQgByoCGJMgAygCBCIEKAIIIgUqAgggAyoCCCILlCAEKAIMIgYqAgggAyoCDCIMlJIgBCgCECIEKgIIIAMqAhAiAZSSIhcgCyAFKgIYlCAMIAYqAhiUkiABIAQqAhiUkpOTIhggAyoCGCIPlCAHKgIMIhUgByoCHJMgCyAFKgIMlCAMIAYqAgyUkiABIAQqAgyUkiINIAsgBSoCHJQgDCAGKgIclJIgASAEKgIclJKTkyIOIAMqAhwiEJSSIAcqAhAiFiAHKgIgkyALIAUqAhCUIAwgBioCEJSSIAEgBCoCEJSSIgIgCyAFKgIglCAMIAYqAiCUkiABIAQqAiCUkpOTIgEgAyoCICILlJIiDEMAAAAAXUEBc0UEQCALIAMqAiggFCAPlCAVIBCUkiAWIAuUkiAXIA+UIA0gEJSSIAIgC5SSk5MiApRDAAAAAJIhEyAPIAKUQwAAAACSIRIgECAClEMAAAAAkiERCyAHIBYgAyoCMCICIBMgASALIAyUkyADKgIsIgGUkyINlJI4AhAgByAVIAIgESABIA4gECAMlJOUkyIOlJI4AgwgByAUIAIgEiABIBggDyAMlJOUkyIClJI4AgggBSAFKgIIIAIgAyoCNCAAKgIIlCIBlJM4AgggBSAFKgIMIA4gAZSTOAIMIAUgBSoCECANIAGUkzgCECAGIAYqAgggAiADKgI0IAMqAgyUIgGUkzgCCCAGIAYqAgwgDiABlJM4AgwgBiAGKgIQIA0gAZSTOAIQIAQgBCoCCCACIAMqAjQgAyoCEJQiAZSTOAIIIAQgBCoCDCAOIAGUkzgCDCAEIAQqAhAgDSABlJM4AhAgCEEBaiIIIAlHDQALCwupBQIGfxd9IwBBEGsiBiQAIAAqAsQDIQIgACgCwAEiAyADKAIAKAIwEQYAIQ8gACgCrAYiCEEBTgRAA0ACfSAAKAK0BiAHQegAbGoiAygCACIEKALsAUEedEEfdSAEcSIFRQRAQwAAAAAhCUMAAAAAIQtDAAAAAAwBCyACIAUqAswCIgogAyoCVCIMlCAFKgLQAiIOIAMqAlAiC5STIAUqArgCkpQhCSACIAsgBSoCyAIiDZQgCiADKgJMIgqUkyAFKgLAApKUIQsgAiAFKgK8AiAOIAqUIAwgDZSTkpQLIQoCQCADKAIYIgQqAggiEyAEKgIYkyAJkyINIAMqAgQiCZQgBCoCDCIUIAQqAhyTIAqTIhAgAyoCCCIKlJIgBCoCECIRIAQqAiCTIAuTIhIgAyoCDCILlJIiDEMAAAA0X0EBcw0AIAMqAhQhFSADKgIkIRYgAyoCHCEXIAMqAiAhGCADKgI0IRkgAyoCLCEaIAMqAjAhGyADKgJEIRwgAyoCPCEdIANBQGsqAgAhHiADKgJgIQ4gAyoCZCEfIAZBADYCDCAGIB0gDSAOIA0gCSAMlJOUkyAJIB8gFSATIAmUIBQgCpSSIBEgC5SSkiIJIA8gCSAPXRuUIgmUkiABlCINlCAeIBAgDiAQIAogDJSTlJMgCSAKlJIgAZQiCpSSIBwgEiAOIBIgCyAMlJOUkyAJIAuUkiABlCIJlJIiCzgCCCAGIA0gGpQgCiAblJIgCSAZlJIiDDgCBCAGIBcgDZQgGCAKlJIgFiAJlJIiCTgCACAEIAQqAgggCSADKgJcIgmUkzgCCCAEIAQqAgwgDCAJlJM4AgwgBCARIAsgCZSTOAIQIAVFDQAgBSAGIANBzABqECsLIAdBAWoiByAIRw0ACwsgBkEQaiQAC74EAgZ/FH0jAEEQayIGJAAgACgCmAYiCEEBTgRAIAAqAtACIAGUIQEgACoCxAMhAgNAIAAoAqAGIAdB4ABsaiIEKgIkIRQgBCoCHCEVIAQqAiAhFiAEKgI0IRcgBCoCLCEYIAQqAjAhGSAEKAIAIgUiA0EQaiADKgIQIgkgBCoCXCIOIAQqAhgiDyABIAQqAgQiCiAEKAIUIgMqAgSUIAQqAggiCyADKgIIlJIgBCoCDCIQIAMqAgyUkiADKgI0kiAFKgIIIhGTlCACIAMqAswCIhogBCoCVCIMlCADKgLQAiINIAQqAlAiG5STIAMqArgCkpQgESAFKgIYk5OSIhIgBCoCPJQgASAKIAMqAhSUIAsgAyoCGJSSIBAgAyoCHJSSIAMqAjiSIAUqAgwiE5OUIAIgAyoCvAIgDSAEKgJMIg2UIAwgAyoCyAIiHJSTkpQgEyAFKgIck5OSIgwgBEFAayoCAJSSIAEgCiADKgIklCALIAMqAiiUkiAQIAMqAiyUkiADKgI8kiAJk5QgAiAbIByUIBogDZSTIAMqAsACkpQgCSAFKgIgk5OSIgkgBCoCRJSSlCIKlJI4AgAgBSATIA4gDyASIBiUIAwgGZSSIAkgF5SSlCILlJI4AgwgBSARIA4gDyASIBWUIAwgFpSSIBQgCZSSlCIJlJI4AgggBkEANgIMIAYgCow4AgggBiALjDgCBCAGIAmMOAIAIAMgBiAEQcwAahArIAdBAWoiByAIRw0ACwsgBkEQaiQAC4ABAgF/An0jAEEQayICJAAgACoCREMAAAAAXkEBc0UEQCAAKgJcIQEgACoCYCEDIAAqAlghBCACQQA2AgwgAiAEjDgCACACIAOMOAIIIAIgAYw4AgQgAEEEaiACIABBpAFqEIABIABBEGogAEHYAGogAEG0AWoQgAELIAJBEGokAAulDQIIfwt9IwBB0ABrIgMkACAAQQRqIQYgAEEQaiEJAn0CQCAAKAIIIgVFBEAgBigCACIEDQFDAAAAAAwCCyAFKgLMAiIBIAAqAqwBIguUIAUqAtACIg0gACoCqAEiDpSTIQwgDiAFKgLIAiIPlCABIAAqAqQBIgGUkyEOIA0gAZQgCyAPlJMhDyAFKgK8AiELIAUqArgCIQ0gBSoCwAIMAQsgBCoC0AIiASAAKgKsASILlCAEKgLUAiINIAAqAqgBIg6UkyEMIA4gBCoCzAIiD5QgASAAKgKkASIBlJMhDiANIAGUIAsgD5STIQ8gBCoCwAIhCyAEKgK8AiENIAQqAsQCCyAOkiETIAsgD5IhFCANIAySIRUCfQJAIAAoAhQiBEUEQCAJKAIAIgQNAUMAAAAAIQtDAAAAACEOQwAAAAAhDUMAAAAAIQxDAAAAACEPQwAAAAAMAgsgBCoCzAIiASAAKgK8ASILlCAEKgLQAiIOIAAqArgBIgyUkyENIAwgBCoCyAIiDJQgASAAKgK0ASIBlJMhDyAOIAGUIAsgDJSTIQwgBCoCvAIhCyAEKgK4AiEOIAQqAsACDAELIAQqAtACIgEgACoCvAEiC5QgBCoC1AIiDiAAKgK4ASIMlJMhDSAMIAQqAswCIgyUIAEgACoCtAEiAZSTIQ8gDiABlCALIAyUkyEMIAQqAsACIQsgBCoCvAIhDiAEKgLEAgshASAAKgLIASEQIAAqAswBIREgACoCxAEhEiADQUBrQgA3AwAgA0IANwM4IANBAToASCADIAApAlA3AzAgAyAAKQJINwMoAkAgEiAVIA4gDZKTIg6UIBAgFCALIAySkyILlJIgESATIAEgD5KTIgyUkiIBQwAAAABdRQRAIAMqAjAhASADKgIsIQsgAyoCKCEODAELIAMgAyoCKCASIAGUIg0gDiANkyAAKgLUASINlJKSIg44AiggAyAQIAGUIg8gDSALIA+TlJIgAyoCLJIiCzgCLCADIBEgAZQiASANIAwgAZOUkiADKgIwkiIBOAIwCyAAQaQBaiEHIABBtAFqIQggACoCcCEPIAAqAmwhECAAKgKAASEMIAAqAnghESAAKgJ8IRIgACoCkAEhDSAAKgKIASETIAAqAowBIRQgACoCaCEVIANBADYCNCADIA4gE5QgCyAUlJIgASANlJIgApQiDTgCMCADIA4gEZQgCyASlJIgASAMlJIgApQiDDgCLCADIBUgDpQgECALlJIgDyABlJIgApQiATgCKAJAIAAoAgQiBCAAKAIQRgRAIAEgAVwgDCAMXHINASANIA1cDQEgASABlCAMIAyUkiANIA2UkpEgBCoC8AJdDQEgBCoC9AIhAiADQQA2AhwgAyACQwAAAICUIgs4AhggAyALOAIUIAMgAygCSCIKNgIgIANBADYCDCADIAs4AhAgAyACIA2MlDgCCCADIAIgDIyUOAIEIAMgAiABjJQ4AgACQCAKQQFxRQ0AIAUEQCAFIAMgBxArIAYoAgAiBEUNAQsgBCAHIAMQtgELIAMtACBBAnEEQCAGIANBEGogBxCAAQsgBigCACoC9AIhASADIAMpAzA3AwggAyADKQM4NwMQIAMgAygCSDYCICADIANBQGspAwA3AxggAyABIAMqAgiUOAIIIAMgASADKgIQlDgCECADIAMpAyg3AwAgAyABIAMqAgCUOAIAIAMgASADKgIElDgCBCADIAEgAyoCFJQ4AhQgAyABIAMqAhiUOAIYAkAgAy0AIEEBcUUNACAAKAIUIgAEQCAAIAMgCBArCyAJKAIAIgBFDQAgACAIIAMQtgELIAMtACBBAnFFDQEgCSADQRBqIAgQgAEMAQsgAyADKQMwNwMIIAMgAykDODcDECADIANBQGspAwA3AxggAyADKAJINgIgIAMgAyoCCIw4AgggAyADKgIQjDgCECADIAMpAyg3AwAgAyADKgIAjDgCACADIAMqAgSMOAIEIANBADYCDCADKgIUIQEgAyoCGCECIANBADYCHCADIAKMOAIYIAMgAYw4AhQCQCADLQAgQQFxRQ0AIAUEQCAFIAMgBxArIAYoAgAhBAsgBEUNACAEIAcgAxC2AQsgAy0AIEECcQRAIAYgA0EQaiAHEIABCwJAIAMtAEhBAXFFDQAgACgCFCIABEAgACADQShqIAgQKwsgCSgCACIARQ0AIAAgCCADQShqELYBCyADLQBIQQJxRQ0AIAkgA0E4aiAIEIABCyADQdAAaiQAC8EDAgF/Bn0gACgCCCIDBEAgA0EAED4LIAAoAgwiAwRAIANBABA+CyAAKAIUIgMEQCADQQAQPgsgACgCGCIDBEAgA0EAED4LIAAgACgCnAEiA0EBajYCnAEgACADIAAoAqABTjoAmAEgA0UEQCAAQQA2AlQgAEMAAIA/IAGVIgQgACoCSCAAKgJAIgaUlCIBOAJIIAAgBCAGIAAqAlCUlCIFOAJQIAAgBCAGIAAqAkyUlCIEOAJMAkAgACoCRCIIQwAAAABeQQFzBEAgBSEGIAQhCSABIQcMAQsgAEEANgJkIABDAACAPyAIkyIHIAWUIgY4AlAgACAHIASUIgk4AkwgACAHIAGUIgc4AkggACAIIAGUIgEgACoCiAGUIAggBJQiBCAAKgKMAZSSIAggBZQiBSAAKgKQAZSSOAJgIAAgASAAKgJ4lCAEIAAqAnyUkiAFIAAqAoABlJI4AlwgACABIAAqAmiUIAQgACoCbJSSIAUgACoCcJSSOAJYCyAAQwAAgD8gArKVIgEgBpQ4AlAgACABIAmUOAJMIAAgASAHlDgCSA8LIABCADcCSCAAQgA3AmAgAEIANwJYIABCADcCUAu8CQEofSACKgIoIQ0gAioCGCEPIAIqAiQhECACKgIUIREgBSoCKCESIAUqAhghFyAFKgIkIRMgBSoCFCEUIAMqAgQhByACKgIIIRggAioCBCEZIAIqAiAhGiADKgIAIQkgAioCACEbIAMqAgghCCACKgIQIRwgBioCBCEKIAUqAgghHSAFKgIEIR4gBSoCICEfIAYqAgAhDCAFKgIAISAgBioCCCELIAUqAhAhISAAQQA2AiwgAEEANgIcIABBADYCDCAAIAEgCCAZlCARQwAAAACUkiAJIBCUkyIkQwAAAACUIAggCCAblCAcQwAAAACUkiAJIBqUkyIllJMgCSAIIBiUIA9DAAAAAJSSIAkgDZSTIiaUkpMgBCALIB6UIBRDAAAAAJSSIAwgE5STIidDAAAAAJQgCyALICCUICFDAAAAAJSSIAwgH5STIiiUkyAMIAsgHZQgF0MAAAAAlJIgDCASlJMiKZSSk5IiIiABIBtDAAAAAJQgCCAclJMgByAalJIiDkMAAAAAlCAIIBlDAAAAAJQgCCARlJMgByAQlJIiKpSSIAcgGEMAAAAAlCAIIA+UkyAHIA2UkiIrlJOTIAQgIEMAAAAAlCALICGUkyAKIB+UkiIsQwAAAACUIAsgHkMAAAAAlCALIBSUkyAKIBOUkiItlJIgCiAdQwAAAACUIAsgF5STIAogEpSSIi6Uk5OSIhWUIAcgJpQgJUMAAAAAlCAIICSUkpNDAAAAAJIgCiAplCAoQwAAAACUIAsgJ5SSk0MAAAAAkpIiI0MAAAAAICpDAAAAAJQgCCAOlJMgCSArlJKTQwAAAAAgLUMAAAAAlCALICyUkyAMIC6UkpOSIhaUk0MAAIA/QwAAAAAgByAOlCAJICqUkyArQwAAAACUkpNDAAAAACAKICyUIAwgLZSTIC5DAAAAAJSSk5IiDkMAAAAAIAkgEZQgByAZlJMgEEMAAAAAlJIiEEMAAAAAlCAIIAkgHJQgByAblJMgGkMAAAAAlJIiEZSTIAkgCSAPlCAHIBiUkyANQwAAAACUkiIPlJKTQwAAAAAgDCAUlCAKIB6UkyATQwAAAACUkiITQwAAAACUIAsgDCAhlCAKICCUkyAfQwAAAACUkiIUlJMgDCAMIBeUIAogHZSTIBJDAAAAAJSSIhKUkpOSIg0gI5QgIiAHIA+UIBFDAAAAAJQgCCAQlJKTQwAAAACSIAogEpQgFEMAAAAAlCALIBOUkpNDAAAAAJKSIgiUkyILlCAVICIgASAHIBGUIAkgEJSTIA9DAAAAAJSSkyAEIAogFJQgDCATlJMgEkMAAAAAlJKTkiIElEMAAAAAIAcgJZQgCSAklJMgJkMAAAAAlJKTQwAAAAAgCiAolCAMICeUkyApQwAAAACUkpOSIgcgDZSTIgmUIBYgByAIlCAEICOUkyIKlJKSlSIBlDgCKCAAIAggFpQgDSAVlJMgAZQ4AiQgACALIAGUOAIgIAAgIyAOlCAHIBWUkyABlDgCGCAAIAQgFZQgCCAOlJMgAZQ4AhQgACAKIAGUOAIQIAAgByAWlCAiIA6UkyABlDgCCCAAIA0gDpQgBCAWlJMgAZQ4AgQgACAJIAGUOAIACzgBAn8jAEEQayICJAAgAiAAOAIMIAIgATgCCEHMABANIgMgAioCDCACKgIIEK0MIAJBEGokACADC5oHAgl/B30jAEGQAWsiAiQAIAEoAoACskMAAEBAlCAAKgIUIguUIQwgCyABKAKIArJDAABAQJSUIRAgCyABKAKEArJDAABAQJSUIREgAkHoAGohBCACQdAAakEEciEFIAJB/ABqIgYhBwNAIBAgCyAIspSSIQ1BACEJA0AgAkEANgIUIAIgDTgCECACIAwgC0MAAAAAlJI4AgggAiARIAsgCbKUkiIPOAIMIAEoApQCIQMgAkGAgID8AzYCUCAFQgA3AgggBUIANwIAIAJBgICA/AM2AmQgBEIANwIIIARCADcCACACQYCAgPwDNgJ4IAdBADYCECAGQgA3AgggBkIANwIAAkAgAygCBEETSgRAQwAAAAAhCwwBCyACQQhqIAMgAkHQAGogAkEYahDnASELIAEoApQCIQMLIAEgCUEEdGogCEECdGoiCiALOAIAIAAqAhQhCyACQQA2AhQgAiANOAIQIAIgDzgCDCACIAwgC5I4AgggAkGAgID8AzYCUCAFQgA3AgggBUIANwIAIAJBgICA/AM2AmQgBEIANwIIIARCADcCACACQYCAgPwDNgJ4IAdBADYCECAGQgA3AgggBkIANwIAIAMoAgRBE0wEQCACQQhqIAMgAkHQAGogAkEYahDnASEOIAEoApQCIQMLIApBQGsgDjgCACAAKgIUIQsgAkEANgIUIAIgDTgCECACIA84AgwgAiAMIAsgC5KSOAIIIAJBgICA/AM2AlAgBUIANwIIIAVCADcCACACQYCAgPwDNgJkIARCADcCCCAEQgA3AgAgAkGAgID8AzYCeCAHQQA2AhAgBkIANwIIIAZCADcCAEMAAAAAIQ4CQCADKAIEQRNKBEBDAAAAACELDAELIAJBCGogAyACQdAAaiACQRhqEOcBIQsgASgClAIhAwsgCiALOAKAASAAKgIUIQsgAkEANgIUIAIgDTgCECACIA84AgwgAiAMIAtDAABAQJSSOAIIIAJBgICA/AM2AlAgBUIANwIIIAVCADcCACACQYCAgPwDNgJkIARCADcCCCAEQgA3AgAgAkGAgID8AzYCeCAHQQA2AhAgBkIANwIIIAZCADcCACAKIAMoAgRBE0wEfSACQQhqIAMgAkHQAGogAkEYahDnAQVDAAAAAAs4AsABIAlBAWoiCUEERwRAIAAqAhQhCwwBCwsgCEEBaiIIQQRHBEAgACoCFCELDAELCyACQZABaiQAC6ILAgt/EX0gASoCAEMAAIA/IAAqAhSVIhCUQwAAQECVIhFDAAAAAF0hBQJ/IBECf0MAAIA/IBGTIhGLQwAAAE9dBEAgEagMAQtBgICAgHgLQQAgBRsiBbKSIhGLQwAAAE9dBEAgEagMAQtBgICAgHgLIgkgBWsiCEEFdkGA8P8/cSAIQf//A3FBEGoiBXMgBUEQdHMhBSAQIAEqAgSUQwAAQECVIhJDAAAAAF0hBiAQIAEqAgiUQwAAQECVIhBDAAAAAF0hASAFAn8gEgJ/QwAAgD8gEpMiEotDAAAAT10EQCASqAwBC0GAgICAeAtBACAGGyIGspIiEotDAAAAT10EQCASqAwBC0GAgICAeAsiCyAGayIGQf//A3FqIAVBC3ZqIgUgBkEFdkGA8P8/cXMgBUEQdHMiB0ELdiEKIAAoAgwiBSAKIAcCfyAQAn9DAACAPyAQkyIQi0MAAABPXQRAIBCoDAELQYCAgIB4C0EAIAEbIgGykiIQi0MAAABPXQRAIBCoDAELQYCAgIB4CyIMIAFrIg1B//8DcWpqIgEgDUEFdkGA8P8/cXMgAUEQdHMiASACQf//A3FqIAFBC3ZqIgEgAkEFdkGA8P8/cXMgAUEQdHMiAUELdiABaiIBQQN0IAFzIgFBBXYgAWoiAUEEdCABcyIBQRF2IAFqIgFBGXQgAXMiAUEGdiABaiIKIAAoAgQiDnBBAnRqIg8oAgAhASAAIAAoAihBAWo2AiggACAAKAIkQQFqIgc2AiQCfyAQIAyyk0MAAEBAlCIQi0MAAABPXQRAIBCoDAELQYCAgIB4CyIMsiEUAn8gEiALspNDAABAQJQiF4tDAAAAT10EQCAXqAwBC0GAgICAeAsiC7IhGAJ/IBEgCbKTQwAAQECUIhOLQwAAAE9dBEAgE6gMAQtBgICAgHgLIQkgECAUkyESIBcgGJMhESATIAmykyEQAkAgAQRAA0ACQCABKAKQAiAKRw0AIAEoAoACIAhHDQAgASgChAIgBkcNACABKAKIAiANRw0AIAEoApQCIAJGDQMLIAEoApgCIQEgACAHQQFqIgc2AiQgAQ0ACwsgACAAKAIcIgFBAWo2AhwgASAAKAIgTgRAQQAhB0HY2gFB2NoBKAIAQQFqNgIAAkAgDkEBSA0AA0AgBSAHQQJ0aiIFKAIAIQEgBUEANgIAIAEEQANAIAEoApgCIQUgARAOIAUiAQ0ACwsgB0EBaiIHIA5GDQEgACgCDCEFDAAACwALIABCgYCAgBA3AiQgAEEANgIcIABCgICA9AM3AhQLQZwCEBIiAUEAQZwCEAsiBSAPKAIANgKYAiAPIAU2AgAgBSAKNgKQAiAFIAI2ApQCIAUgDTYCiAIgBSAGNgKEAiAFIAg2AoACIAAgBRDmDwsgASAAKAIYNgKMAiADIAEgCUEGdGoiAiALQQR0IgVqIgggDEECdCIAQQRqIgFqKgIAIhcgACAIaioCACITkyIUIBAgAkFAayIIIAVqIgYgAWoqAgAiGSAAIAZqKgIAIhWTIBSTlJIiFiARIAIgBUEQaiIFaiICIAFqKgIAIhQgACACaioCACIYkyIaIBAgASAFIAhqIgJqKgIAIh0gACACaioCACIbkyAak5SSIBaTlJIiFkMAAIA/IBYgFpQgFSATkyIWIBEgGyAYkyIeIBaTlJIiHCASIBkgF5MiGiARIB0gFJMiHyAak5SSIByTlJIiHCAclCAYIBOTIiAgECAbIBWTICCTlJIiFSASIBQgF5MiGyAQIB0gGZMgG5OUkiAVk5SSIhkgGZSSkpGVIhWUOAIIIAMgGSAVlDgCBCADIBwgFZQ4AgAgEyAQIBaUkiITIBEgGCAQIB6UkiATk5SSIhMgEiAXIBAgGpSSIhIgESAUIBAgH5SSIBKTlJIgE5OUkiAEkwvyAwIEfw99IwBBIGsiBSQAIAEoAgQhByAAKAKsBSEIIAEoAgwiACoCFCEMIAAqAiQhDSAAKgIYIQogACoCNCELIAAqAighDiAAKgI4IQ8gACoCICEQIAAqAgAhESAAKgIQIRIgACoCBCETIAAqAgghCSAAKgIwIRQgAioCACEVIAIqAgQhFiACKgIIIRcgBUEANgIMIAUgCSAVIBSTIgmUIAogFiALkyIKlJIgDiAXIA+TIguUkjgCCCAFIAkgE5QgCiAMlJIgCyANlJI4AgQgBSAJIBGUIAogEpSSIAsgEJSSOAIAIAhBOGogBSAHIAVBEGogAxDnDyIDQwAAAABdQQFzRQRAIAQgASgCCDYCACAAKgIIIQ4gACoCACEPIAAqAgQhECAAKgIYIQ0gACoCECERIAAqAhQhEiAAKgIoIQwgACoCICETIAAqAiQhFCAFKgIYIQkgBSoCECEKIAUqAhQhCyAEQQA2AhAgBCAKIBOUIAsgFJSSIAkgDJSSIgw4AgwgBCAKIBGUIAsgEpSSIAkgDZSSIg04AgggBCAPIAqUIBAgC5SSIA4gCZSSIgk4AgQgBCAJIAIqAgAgAyAJlJOUIA0gAioCBCADIA2Uk5SSIAwgAioCCCADIAyUk5SSjDgCFEEBIQYLIAVBIGokACAGC2sBAX0CQCAAQQRqIABBJGogASgCJCIBKAIIQQhqIAEoAgxBCGogASgCEEEIaiAAKgI0EOkCIgJDAAAAAF5BAXMNACACIAAqAjRdQQFzDQAgACABNgI4IAAgAjgCNAsgACAAKAI8QQFqNgI8C4gCAQZ/IAAoAtQGQQFOBEADQCADQQJ0IgIgACgC3AZqKAIAIgEgACoCxAMgASgCACgCEBEIAAJAIAAoAtwGIAJqKAIAIgEtAJgBRQRAIAAoAtQGIQEMAQsgAQRAQez3AUHs9wEoAgBBAWo2AgAgAUGQ0gEoAgARAAALIANBf2ohAyAAKALUBiIBQQFIDQAgACgC3AYiBCACaigCACEFQQAhAgNAIAUgBCACQQJ0aiIGKAIARwRAIAJBAWoiAiABRw0BDAILCyACIAFODQAgBiAEIAFBf2oiAUECdCICaigCADYCACAAKALcBiACaiAFNgIAIAAgATYC1AYLIANBAWoiAyABSA0ACwsLzgIBCH8gACgCBCIGQQFOBEAgACgCDCECA0AgBCACIAFBAnRqKAIAKAKAAyIFIAQgBUobIQQgAUEBaiIBIAZHDQALA0AgACgCDCADQQJ0aigCACIBKALUBkEBTgRAQQAhAgNAIAEoAtwGIAJBAnRqKAIAIgUgASoCxAMgBCAFKAIAKAIIERAAIAJBAWoiAiABKALUBkgNAAsLIANBAWoiAyAGRw0AC0EAIQIgBEEASgRAA0BBACEDA0AgACgCDCADQQJ0aigCACIFKALUBiIHQQFOBEBBACEBA0AgBSgC3AYgAUECdGooAgAiCCAFKgLEA0MAAIA/IAgoAgAoAgwREQAgAUEBaiIBIAdHDQALCyADQQFqIgMgBkcNAAsgAkEBaiICIARHDQALC0EAIQEDQCAAKAIMIAFBAnRqKAIAEOoPIAFBAWoiASAGRw0ACwsL7QICB38GfSAAQdgIaigCACIEQQFOBEAgAEHgCGooAgAhBQNAAkAgBSACQQJ0aigCACIAKgLgAkMAAAAAXkEBcw0AIAAoAhgiBkEBSA0AIAAoAiAhB0EAIQMDQAJAIAcgA0ECdGooAgAiASoCWEMAAAAAXkEBcw0AIAAqArwCIAAqAtACIgogASoCICAAKgLsAZMiCZQgASoCHCAAKgLoAZMiCCAAKgLUAiILlJOSIg0gDZQgACoCwAIgASoCGCAAKgLkAZMiDCALlCAJIAAqAswCIgmUk5IiCyALlJIgCCAJlCAMIAqUkyAAKgLEApIiDCAMlJIgASoCKCIKIAqUIAEqAiwiCSAJlJIgASoCMCIIIAiUkl9BAXMNACABIAggDCAIkyAAKgLgAiIIlJI4AjAgASAJIAggCyAJk5SSOAIsIAEgCiAIIA0gCpOUkjgCKAsgA0EBaiIDIAZHDQALCyACQQFqIgIgBEcNAAsLC4UCAgV/Bn0gACgC3AUiBUEBTgRAIAAoAuQFIQYDQCAGIARBNGxqIgIoAggiAyIAQTBqIAAqAjAiByACKgIsIgggAyoCWCACKgIgIAMqAigiCSACKAIMIgAqAiiTIAIqAiQiCpQgAyoCLCILIAAqAiyTIAIqAigiDJSSIAggByAAKgIwk5SSjJQgAZQiCJQiB5SSOAIAIAMgCyAMIAeUkjgCLCADIAkgCiAHlJI4AiggAioCLCEJIAIqAighCiAAIAAqAiggAioCJCAIIAAqAliUIgeUkzgCKCAAIAAqAiwgByAKlJM4AiwgACAAKgIwIAcgCZSTOAIwIARBAWoiBCAFRw0ACwsLWwEBfyMAQRBrIgIkACACIAA2AgwgAiABNgIIIAIoAgghASMAQRBrIgAgAigCDEGIAmo2AgwgACABNgIIIAAoAgwoAgwgACgCCEECdGooAgAhACACQRBqJAAgAAuPCwIGfwx9IwBBQGoiBCQAIABBABCJBSAAKALcBSIGQQFOBEADQCAAKALkBSACQTRsaiIBKAIIIgMqAhwhCSABKAIMIgUqAhwhCiADKgIgIQggBSoCICELIAMqAhghByAFKgIYIQwgAUEANgIwIAEgDCAHkyIHOAIkIAEgCyAIkyIIOAIsIAEgCiAJkyIJOAIoIAFDAACAPyABKgIYIAcgB5QgCSAJlJIgCCAIlJKUlTgCICACQQFqIgIgBkcNAAsLIAAoApgGIgVBAU4EQEEAIQMDQCAAKAKgBiADQeAAbGoiAigCFCIBKgIMIQogASoCCCELIAEqAgQhDCABKgIcIQ0gASoCFCEOIAEqAhghDyACKgIMIQcgASoCLCEQIAIqAgQhCCABKgIkIREgAioCCCEJIAEqAighEiAEQQA2AjwgBCAIIBGUIAkgEpSSIAcgEJSSOAI4IAQgCCAOlCAJIA+UkiAHIA2UkjgCNCAEIAwgCJQgCyAJlJIgCiAHlJI4AjAgBCAAKgLEAyACKAIAKgJYIAEqAtgCIAFBiAJqIARBMGoQiAUgAiAEKQMINwIkIAIgBCkDADcCHCACIAQpAhg3AjQgAiAEKQIQNwIsIAIgBCkCKDcCRCACIAQpAiA3AjwgAiAEKQM4NwJUIAIgBCkDMDcCTCACIAAqAsQDIAIoAgAqAliUOAJcIAIoAhRBABA+IANBAWoiAyAFRw0ACwsCQCAAKAL0AiIFQQFIDQAgACgCjAMhAkEAIQMDQEEAIQEgAkEASgRAA0AgAEMAAIA/QQBB3gAgACgClAMgAUECdGooAgAbEQgAIAFBAWoiASAAKAKMAyICSA0ACyAAKAL0AiEFCyADQQFqIgMgBUgNAAsgACgCyAUiA0EBSA0AQQAhAgNAIAAqAsQDIQcgACgC0AUgAkHoAGxqIgFBADYCFCABIAcgASoCKJQgASoCGJI4AgggASAHIAEqAjCUIAEqAiCSOAIQIAEgByABKgIslCABKgIckjgCDCACQQFqIgIgA0cNAAsLAkAgACgC+AIiAUEBSA0AIAAoAqADIQJBACEDA0AgAkEASgRAIAOyIAGylSEHQQAhAQNAIABDAACAPyAHIAAoAqgDIAFBAnRqKAIAQQJ0QegsaigCABERACABQQFqIgEgACgCoAMiAkgNAAsgACgC+AIhAQsgA0EBaiIDIAFIDQALIAAoAsgFIgNBAUgNACAAKgLIA0MAAIA/IAAqAqgCk5QhB0EAIQIDQCAAKALQBSACQegAbGoiAUIANwI0IAFCADcCPCABQQA2AkQgASAHIAEqAgggASoCGJOUOAIoIAEgByABKgIQIAEqAiCTlDgCMCABIAcgASoCDCABKgIck5Q4AiwgAkEBaiICIANHDQALCwJAIAAoAvwCIgVBAUgNACAAKgLIAyEHIAAqAqQCIQgCQCAAKALIBSIDQQFOBEBBACECA0AgACgC0AUgAkHoAGxqIgEgASkCCDcCGCABIAEpAhA3AiAgAkEBaiICIANHDQALIAAoAvwCIgVBAUgNAQsgACgCtAMhAkEAIQMDQEEAIQEgAkEASgRAA0AgAEMAAIA/QwAAAAAgACgCvAMgAUECdGooAgBBAnRB6CxqKAIAEREAIAFBAWoiASAAKAK0AyICSA0ACyAAKAL8AiEFCyADQQFqIgMgBUgNAAsLIAAoAsgFIgNBAUgNACAIIAeUIQcgACgC0AUhBUEAIQIDQCAFIAJB6ABsaiIBIAcgASoCCCABKgIYk5QgASoCKJI4AiggASAHIAEqAgwgASoCHJOUIAEqAiySOAIsIAEgByABKgIQIAEqAiCTlCABKgIwkjgCMCACQQFqIgIgA0cNAAsLIAAQ7A8gAEEBEIkFIARBQGskAAtiACAAIAAqAgAgASoCAJM4AgAgACAAKgIEIAEqAgSTOAIEIAAgACoCCCABKgIIkzgCCCAAIAEqAgAgACoCEJI4AhAgACABKgIEIAAqAhSSOAIUIAAgASoCCCAAKgIYkjgCGAuiDAIIfx19IwBBkAFrIgEkAAJAIAAtANkDRQ0AIAAoAsgFIgdBAUgiBEUEQCAAKAKABCEFIAAoAtAFIQYDQCAJIAYgAkHoAGxqIgMqAgggBSACQQJ0aioCACILlJIhCSAPIAsgAyoCEJSSIQ8gECALIAMqAgyUkiEQIAJBAWoiAiAHRw0ACwsgAEEANgKUBCAAIA84ApAEIAAgEDgCjAQgACAJOAKIBCABQgA3AoQBIAFCADcCdCABQQA2AowBIAFCADcCfCABQgA3AmwgAUGAgICmAzYCiAEgAUGAgICkAzYCdCABQgA3AmQgAUGAgICgAzYCYCAERQRAIAAoAuwDIQUgACgC0AUhBiAAKAKABCEIIAEqAnghC0MAAAA0IRFDAACANCEMQwAAwDQhDSABKgJwIRIgASoCaCEOIAEqAmQhE0EAIQMDQCAGIANB6ABsaiIEKgIQIRUgBCoCDCEWIAUgA0EEdGoiAioCACEXIAIqAgQhGCABIAQqAgggCZMgCCADQQJ0aioCACIUlCIKIAIqAgiUIA6SIg44AmggASAKIBiUIBOSIhM4AmQgASAKIBeUIBGSIhE4AmAgAioCACEXIAIqAgQhGCABIBQgFiAQk5QiCiACKgIIlCALkiILOAJ4IAEgCiAYlCAMkiIMOAJ0IAEgCiAXlCASkiISOAJwIAIqAgAhCiACKgIEIRYgASAUIBUgD5OUIhQgAioCCJQgDZIiDTgCiAEgASAUIBaUIBmSIhk4AoQBIAEgFCAKlCAakiIaOAKAASADQQFqIgMgB0cNAAsLAkBB6NkBLQAAQQFxDQBB6NkBEBBFDQBBoLMBKgIAIQlB5NkBQaSzASgCADYCAEHg2QEgCTgCAEHo2QEQDwsgAUHgAGogAUEwaiABEOADIAAgASkDODcCoAQgACABKQMwNwKYBCAAIAEpA0g3ArAEIAAgASkDQDcCqAQgACABKQNQNwK4BCAAIAEpA1g3AsAEIAAqAoAFIQkgACoC+AQhDyAAKgL8BCEQIAAqApAFIQsgACoCiAUhESAAKgKMBSEMIAAqAqAFIQ0gACoCmAUhEiAAKgKcBSEOIAEqAlghEyABKgJUIRQgASoCOCEKIAEqAnghFSABKgJIIRYgASoCRCEXIAEqAoABIRggASoCYCEZIAEqAnAhGiABKgKEASEdIAEqAmQhHiABKgJ0IR8gASoCiAEhICABKgJQISEgASoCaCEiIAEqAjAhIyABKgI0ISQgASoCQCElIABBADYC9AQgAEEANgLkBCAAQQA2AtQEIAAgIiAjIBKUICQgDpSSIAogDZSSIhuUIBUgJSASlCAXIA6UkiAWIA2UkiIclJIgICAhIBKUIBQgDpSSIBMgDZSSIg6UkiINOALwBCAAIBsgHpQgHCAflJIgDiAdlJIiEjgC7AQgACAZIBuUIBogHJSSIA4gGJSSIg44AugEIAAgIiAjIBGUICQgDJSSIAogC5SSIhuUIBUgJSARlCAXIAyUkiAWIAuUkiIclJIgICAhIBGUIBQgDJSSIBMgC5SSIgyUkiILOALgBCAAIBsgHpQgHCAflJIgDCAdlJIiETgC3AQgACAbIBmUIBwgGpSSIAwgGJSSIgw4AtgEIAAgIiAjIA+UICQgEJSSIAogCZSSIgqUIBUgJSAPlCAXIBCUkiAWIAmUkiIVlJIgICAhIA+UIBQgEJSSIBMgCZSSIgmUkiIPOALQBCAAIAogHpQgFSAflJIgCSAdlJIiEDgCzAQgACAKIBmUIBUgGpSSIAkgGJSSIhM4AsgEIAAqAuwCIglDAACAP15FDQAgAEEANgL0BCAAQQA2AuQEIABBADYC1AQgACANQwAAgD8gCUMAAIA/IA8gEiAMlCARIA6Uk5QgEyARIA2UIAsgEpSTlCAQIAsgDpQgDSAMlJOUkpKVIg0gDSAJXhsgDUMAAIA/XRsiCZQ4AvAEIAAgEiAJlDgC7AQgACAOIAmUOALoBCAAIAsgCZQ4AuAEIAAgESAJlDgC3AQgACAMIAmUOALYBCAAIA8gCZQ4AtAEIAAgECAJlDgCzAQgACATIAmUOALIBAsgAUGQAWokAAurAwIGfwZ9Qf0jEBYgACoCrAIhByAAKgKwAiEMIAAqArgCIQkCfSAAKgK0AiIKQwAAAABbBEBDAAAAACAJQwAAAABeQQFzDQEaCyAAEJQFIQggCSAAKgLcAyAIk5QhCyAKQwAAgD8gCIuVlAshCCAAKALIBSIDQQFOBEAgDEMAAAAAXiAHQwAAAABeciEFIABBvAlqIQYDQAJAIAAoAtAFIAJB6ABsaiIBKgJYQwAAAABeQQFzDQAgBQRAIAAgBiACEO4CCyAKQwAAAABcBEAgASABKgJIIAggASoCXJQiB5QgASoCOJI4AjggASAHIAEqAkyUIAEqAjySOAI8IAFBQGsiBCAHIAEqAlCUIAQqAgCSOAIACyAJQwAAAABeQQFzDQAgASABKgJIIAsgASoCXJQiB5QgASoCOJI4AjggASAHIAEqAkyUIAEqAjySOAI8IAFBQGsiBCAHIAEqAlCUIAQqAgCSOAIACyACQQFqIgIgA0cNAAsLIAAoAvAFIgJBAU4EQCAAQbwJaiEDQQAhAQNAIAAgAyABEJcFIAFBAWoiASACRw0ACwsQEwukEwIHfxB9IwBBkAFrIgIkAAJAIAAtAJwHRQ0AIABBADoAnAcgABD8ASAAQdwHaiIGEKYBIAAtAIQDQRBxRQ0AIAYQpgEgACgC8AVBAUgNAANAIAJBCGogACgC+AUgBEEsbGoiA0MAAAAAEOoCIAMgBiACQQhqIAMQQjYCKCAEQQFqIgQgACgC8AVIDQALCyAAIAAqAvACIAGUIgE4AsQDIAAgAUMAAEBAlDgCzAMgAEMAAIA/IAGVOALIAyAAIAAoAsABIgQgBCgCACgCMBEGACIBOALQAyAAIAFDAACAPpQ4AtQDIAAoAsgFIgZBAU4EQCAAKgLEAyIBIAAoAqwFIgQqAjCUIQogASAEKgIslCELIAQqAiggAZQhASAAKALQBSEDQQAhBANAIAMgBEHoAGxqIgUqAlhDAAAAAF5BAXNFBEAgBSABIAUqAiiSOAIoIAUgCyAFKgIskjgCLCAFIAogBSoCMJI4AjALIARBAWoiBCAGRw0ACwsgABDyDyAAKALIBSIGQQFOBEBBACEEA0AgACgC0AUgBEHoAGxqIgUgBSkCCDcCGCAFIAUpAhA3AiAgBSAAKAKsBSoCDCAAKgLEAyIOlSIMjCINIAwgBSoCOCAFKgJYIgmUIA6UIgEgASAMXhsiASABIA1dGyAFKgIokiIKOAIoIAUgDSAMIA4gCSAFKgI8lJQiASABIAxeGyIBIAEgDV0bIAUqAiySIgs4AiwgBSANIAwgDiAJIAVBQGsiAyoCAJSUIgEgASAMXhsiASABIA1dGyAFKgIwkiIBOAIwIAUgCiAAKgLEAyIKlCAFKgIIkjgCCCAFIAsgCpQgBSoCDJI4AgwgBSABIAqUIAUqAhCSOAIQIANCADcCACAFQgA3AjggBEEBaiIEIAZHDQALCyAAEOsCAkAgACgCoAciAwRAIAAoAsABIgQgBCgCACgCMBEGACEJIAMqAgAhCiADKgIEIQsgAyoCCCEBIABBADYCiAcgACABIAmTOAKEByAAIAsgCZM4AoAHIAAgCiAJkzgC/AYgAyoCFCEKIAMqAhghCyADKgIQIQEgAEEANgKYByAAIAkgC5I4ApQHIAAgCSAKkjgCkAcgAEGMB2oiBSAJIAGSOAIAIAAoArwBIgZFDQEgACgCrAUiAygCICIEIAYgAEH8BmogBSADKAIkIAQoAgAoAhARCQAMAQsgAEIANwL8BiAAQgA3ApQHIABCADcCjAcgAEIANwKEBwsgACgCyAUiBUEBTgRAIABBoAdqIQZBACEEA0AgACgC0AUgBEHoAGxqIgcqAgwhCiAHKgIQIQsgByoCCCEBIAAqAtADIQkgAkEANgKMASACIAkgAZI4AoABIAJBADYCfCACIAEgCZM4AnAgAiAJIAuSOAKIASACIAkgCpI4AoQBIAIgCyAJkzgCeCACIAogCZM4AnQgBygCYCEDIAcqAighCiAHKgIsIQsgByoCMCEBIAAqAswDIQkgAkEANgIUIAIgCSABlDgCECACIAkgC5Q4AgwgAiAKIAmUOAIIIAYgAyACQfAAaiACQQhqIAAqAtQDEMwBGiAEQQFqIgQgBUcNAAsLIABB3AdqIQcCQCAAKALcB0UNACAAKALwBUEBSA0AQQAhBANAIAAoAvgFIARBLGxqIggoAhAiBSoCKCEQIAgoAggiBioCKCERIAgoAgwiAyoCKCEMIAUqAiwhDSAGKgIsIQ4gAyoCLCEJIAUqAjAhCiAGKgIwIQsgAyoCMCEBIAJBCGogCCAAKgLQAxDqAiACIAIpAyA3A4gBIAIgAikDGDcDgAEgAiACKQMQNwN4IAIgAikDCDcDcCAIKAIoIQMgACoCzAMhDyACQQA2AhQgAiAPIAogCyABkpJDq6qqPpSUOAIQIAIgDyANIA4gCZKSQ6uqqj6UlDgCDCACIA8gECARIAySkkOrqqo+lJQ4AgggByADIAJB8ABqIAJBCGogACoC1AMQzAEaIARBAWoiBCAAKALwBUgNAAsLIAAQ8Q8CQCAALQDZA0UNACAAKgLAAkMAAAAAXkEBcw0AIAAoAsgFIgNBAUgNACAAKgLABCEWIAAqArwEIRcgACoCuAQhGCAAKgKwBCEPIAAqAqwEIRAgACoCqAQhESAAKgKgBCEMIAAqApwEIQ0gACoCmAQhDkEAIQQDQCAAKALQBSAEQegAbGoiBSoCWEMAAAAAXkEBc0UEQCAAKALsAyAEQQR0aiIGKgIIIRIgBioCACETIAYqAgQhFCAAKgKIBCEJIAAqAowEIQogACoCwAIhFSAAKgKQBCELIAVBADYCFCAFIAUqAhAiASAVIAsgGCATlCAXIBSUkiAWIBKUkpIgAZOUkjgCECAFIAUqAgwiASAVIAogESATlCAQIBSUkiAPIBKUkpIgAZOUkjgCDCAFIAUqAggiASAVIAkgDiATlCANIBSUkiAMIBKUkpIgAZOUkjgCCAsgBEEBaiIEIANHDQALCyACQQhqQQBB6AAQCxogACgCrAYiBEF/TARAIAAoArAGQX9MBEAgACgCtAYiAwRAIAAtALgGBEAgAwRAQez3AUHs9wEoAgBBAWo2AgAgA0GQ0gEoAgARAAALCyAAQQA2ArQGCyAAQgA3ArAGIABBAToAuAYLA0AgACgCtAYgBEHoAGxqIgMgAikDCDcCACADIAIoAiA2AhggAyACKQMYNwIQIAMgAikDEDcCCCADIAIpAiw3AiQgAyACKQIkNwIcIAMgAikCPDcCNCADIAIpAjQ3AiwgAyACKQJENwI8IAMgAikCTDcCRCADIAIpAlQ3AkwgAyACKQJcNwJUIAMgAikCZDcCXCADIAIoAmw2AmQgBEEBaiIDIARPIQYgAyEEIAYNAAsLIABBADYCrAYgAkIANwM4IAJCADcDMCACQgA3AyggAkIANwMgIAJCADcDGCACQgA3AxAgAkIANwMIIAAoAsAGIgRBf0wEQCAAKALEBkF/TARAIAAoAsgGIgMEQCAALQDMBgRAIAMEQEHs9wFB7PcBKAIAQQFqNgIAIANBkNIBKAIAEQAACwsgAEEANgLIBgsgAEIANwLEBiAAQQE6AMwGCwNAIAAoAsgGIARBOGxqIgMgAikDCDcCACADIAIpAzg3AjAgAyACKQMwNwIoIAMgAikDKDcCICADIAIpAyA3AhggAyACKQMYNwIQIAMgAikDEDcCCCAEQQFqIgMgBE8hBiADIQQgBg0ACwsgAEEANgLABiAAQaAHakEBEKUBIAdBARClASAAQZgIakEBEKUBIAJBkAFqJAALrAUDB38BfgZ9IwBB8ABrIgYkACABKgIAIQ4gAioCACERIAEqAgQhDyACKgIEIRIgASoCCCEQIAIqAgghEyAGQQA2AmwgBiATIBCTIhA4AmggBiASIA+TIg84AmQgBiARIA6TIg44AmACQCAAKALcByIHRQRAIAAoAvAFIghBAUgNAUEAIQIDQCABIAZB4ABqIAAoAvgFIAJBLGxqIgcoAghBCGogBygCDEEIaiAHKAIQQQhqIAMqAgAQ6QIiDkMAAAAAXkEBc0UEQCAEQQM2AgAgBSACNgIAIAMgDjgCACAJQQFqIQkLIAJBAWoiAiAIRw0ACwwBCyADKAIAIQggBkGMIzYCICAGIAEpAgg3AiwgASkCACENIAZBADYCUCAGIBA4AkwgBiAPOAJIIAYgDTcCJCAGIA44AkQgBiACKQIINwI8IAYgAikCADcCNCAGQgA3A1ggBiAINgJUIAcgASACIAZBIGoQigUgBigCWCICRQ0AIAMgBigCVDYCACAEQQM2AgAgBSACIAAoAvgFa0EsbTYCAEEBIQkLIAAoAoQGQQFOBEBBACEHA0AgACgCjAYhDEEAIQIDQCAGIAwgB0HoAGxqQQhqIgggAkEMbCILQbAjaigCAEECdGooAgAiCikCEDcDKCAGIAopAgg3AyAgBiAIIAtBtCNqKAIAQQJ0aigCACIKKQIQNwMYIAYgCikCCDcDECAGIAggC0G4I2ooAgBBAnRqKAIAIggpAhA3AwggBiAIKQIINwMAIAEgBkHgAGogBkEgaiAGQRBqIAYgAyoCABDpAiIOQwAAAABeQQFzRQRAIARBBDYCACAFIAc2AgAgAyAOOAIAIAlBAWohCQsgAkEBaiICQQRHDQALIAdBAWoiByAAKAKEBkgNAAsLIAZB8ABqJAAgCQuyAQEEfyMAQSBrIgQkAAJAIAAoAvAFRQ0AIAAoAtwHDQAgAEHcB2oiBxCmASAAKALwBUEBSA0AA0AgBCAAKAL4BSAFQSxsaiIGQwAAAAAQ6gIgBiAHIAQgBhBCNgIoIAVBAWoiBSAAKALwBUgNAAsLIANBgICA/AM2AgwgAyAANgIAIANCgICAgHA3AgQgACABIAIgA0EMaiADQQRqIANBCGoQ9A8hACAEQSBqJAAgAEEARwsFABDGCgsLockBGQBBgAgLpRtpaQAAAAAAAIQEAAABAAAAAgAAAAMAAAAEAAAATjE2YnRDb2xsaXNpb25Xb3JsZDI3Q2xvc2VzdENvbnZleFJlc3VsdENhbGxiYWNrRQBOMTZidENvbGxpc2lvbldvcmxkMjBDb252ZXhSZXN1bHRDYWxsYmFja0UAAAAAIGgAAE4EAABIaAAAHAQAAHwEAAAAAAAAfAQAAAUAAAAGAAAAAwAAAAcAAAAAAAAAIAUAAAgAAAAJAAAACgAAAAsAAABOMTZidENvbGxpc2lvbldvcmxkMjRBbGxIaXRzUmF5UmVzdWx0Q2FsbGJhY2tFAE4xNmJ0Q29sbGlzaW9uV29ybGQxN1JheVJlc3VsdENhbGxiYWNrRQAAIGgAAO8EAABIaAAAwAQAABgFAAAAAAAAGAUAAAwAAAANAAAACgAAAAcAAAAAAAAAcAUAAA4AAAAPAAAABwAAADE4YnRWZWhpY2xlUmF5Y2FzdGVyAAAAACBoAABYBQAAAAAAAMAFAAAQAAAAEQAAABIAAAATAAAAMjBidERlZmF1bHRNb3Rpb25TdGF0ZQAxM2J0TW90aW9uU3RhdGUAACBoAACnBQAASGgAAJAFAAC4BQAAAAAAALgFAAAUAAAAFQAAAAcAAAAHAAAAAAAAADwGAAAWAAAAFwAAABgAAAAZAAAAGgAAADE5YnRHaG9zdFBhaXJDYWxsYmFjawAyNWJ0T3ZlcmxhcHBpbmdQYWlyQ2FsbGJhY2sAAAAgaAAAFgYAAEhoAAAABgAANAYAAAAAAAA0BgAAGwAAABwAAAAHAAAABwAAAAcAAAAAAAAArAYAAB0AAAAeAAAACgAAAB8AAABOMTZidENvbGxpc2lvbldvcmxkMjRDbG9zZXN0UmF5UmVzdWx0Q2FsbGJhY2tFAABIaAAAfAYAABgFAAAAAAAAJAcAACAAAAAhAAAAIgAAACMAAAAyOUNvbmNyZXRlQ29udGFjdFJlc3VsdENhbGxiYWNrAE4xNmJ0Q29sbGlzaW9uV29ybGQyMUNvbnRhY3RSZXN1bHRDYWxsYmFja0UAIGgAAPAGAABIaAAA0AYAABwHAAAAAAAAHAcAACQAAAAlAAAAIgAAAAcAAAB7IHZhciBzZWxmID0gTW9kdWxlWydnZXRDYWNoZSddKE1vZHVsZVsnQ29uY3JldGVDb250YWN0UmVzdWx0Q2FsbGJhY2snXSlbJDBdOyBpZiAoIXNlbGYuaGFzT3duUHJvcGVydHkoJ2FkZFNpbmdsZVJlc3VsdCcpKSB0aHJvdyAnYSBKU0ltcGxlbWVudGF0aW9uIG11c3QgaW1wbGVtZW50IGFsbCBmdW5jdGlvbnMsIHlvdSBmb3Jnb3QgQ29uY3JldGVDb250YWN0UmVzdWx0Q2FsbGJhY2s6OmFkZFNpbmdsZVJlc3VsdC4nOyByZXR1cm4gc2VsZlsnYWRkU2luZ2xlUmVzdWx0J10oJDEsJDIsJDMsJDQsJDUsJDYsJDcpOyB9AGlpaWlpaWlpAAAAAAAAAAAICQAAJgAAACcAAAAoAAAAKQAAACoAAAArAAAALAAAAC0AAAAuAAAALwAAADAAAAAxAAAAMgAAADMAAAA0AAAANQAAADYAAAA3AAAAOAAAADkAAAA6AAAAOwAAADwAAAAxMURlYnVnRHJhd2VyADEyYnRJRGVidWdEcmF3AAAAACBoAADuCAAASGgAAOAIAAAACQAAAAAAAAAJAAA9AAAAPgAAAAcAAAApAAAAKgAAACsAAAAsAAAALQAAAAcAAAAHAAAABwAAAAcAAAAHAAAAMwAAADQAAAA1AAAANgAAADcAAAA4AAAAOQAAADoAAAA7AAAAPAAAAHsgdmFyIHNlbGYgPSBNb2R1bGVbJ2dldENhY2hlJ10oTW9kdWxlWydEZWJ1Z0RyYXdlciddKVskMF07IGlmICghc2VsZi5oYXNPd25Qcm9wZXJ0eSgnZHJhd0xpbmUnKSkgdGhyb3cgJ2EgSlNJbXBsZW1lbnRhdGlvbiBtdXN0IGltcGxlbWVudCBhbGwgZnVuY3Rpb25zLCB5b3UgZm9yZ290IERlYnVnRHJhd2VyOjpkcmF3TGluZS4nOyBzZWxmWydkcmF3TGluZSddKCQxLCQyLCQzKTsgfQBpaWlpAHsgdmFyIHNlbGYgPSBNb2R1bGVbJ2dldENhY2hlJ10oTW9kdWxlWydEZWJ1Z0RyYXdlciddKVskMF07IGlmICghc2VsZi5oYXNPd25Qcm9wZXJ0eSgnZHJhd0NvbnRhY3RQb2ludCcpKSB0aHJvdyAnYSBKU0ltcGxlbWVudGF0aW9uIG11c3QgaW1wbGVtZW50IGFsbCBmdW5jdGlvbnMsIHlvdSBmb3Jnb3QgRGVidWdEcmF3ZXI6OmRyYXdDb250YWN0UG9pbnQuJzsgc2VsZlsnZHJhd0NvbnRhY3RQb2ludCddKCQxLCQyLCQzLCQ0LCQ1KTsgfQBpaWlkaWkAeyB2YXIgc2VsZiA9IE1vZHVsZVsnZ2V0Q2FjaGUnXShNb2R1bGVbJ0RlYnVnRHJhd2VyJ10pWyQwXTsgaWYgKCFzZWxmLmhhc093blByb3BlcnR5KCdyZXBvcnRFcnJvcldhcm5pbmcnKSkgdGhyb3cgJ2EgSlNJbXBsZW1lbnRhdGlvbiBtdXN0IGltcGxlbWVudCBhbGwgZnVuY3Rpb25zLCB5b3UgZm9yZ290IERlYnVnRHJhd2VyOjpyZXBvcnRFcnJvcldhcm5pbmcuJzsgc2VsZlsncmVwb3J0RXJyb3JXYXJuaW5nJ10oJDEpOyB9AGlpAHsgdmFyIHNlbGYgPSBNb2R1bGVbJ2dldENhY2hlJ10oTW9kdWxlWydEZWJ1Z0RyYXdlciddKVskMF07IGlmICghc2VsZi5oYXNPd25Qcm9wZXJ0eSgnZHJhdzNkVGV4dCcpKSB0aHJvdyAnYSBKU0ltcGxlbWVudGF0aW9uIG11c3QgaW1wbGVtZW50IGFsbCBmdW5jdGlvbnMsIHlvdSBmb3Jnb3QgRGVidWdEcmF3ZXI6OmRyYXczZFRleHQuJzsgc2VsZlsnZHJhdzNkVGV4dCddKCQxLCQyKTsgfQBpaWkAeyB2YXIgc2VsZiA9IE1vZHVsZVsnZ2V0Q2FjaGUnXShNb2R1bGVbJ0RlYnVnRHJhd2VyJ10pWyQwXTsgaWYgKCFzZWxmLmhhc093blByb3BlcnR5KCdzZXREZWJ1Z01vZGUnKSkgdGhyb3cgJ2EgSlNJbXBsZW1lbnRhdGlvbiBtdXN0IGltcGxlbWVudCBhbGwgZnVuY3Rpb25zLCB5b3UgZm9yZ290IERlYnVnRHJhd2VyOjpzZXREZWJ1Z01vZGUuJzsgc2VsZlsnc2V0RGVidWdNb2RlJ10oJDEpOyB9AHsgdmFyIHNlbGYgPSBNb2R1bGVbJ2dldENhY2hlJ10oTW9kdWxlWydEZWJ1Z0RyYXdlciddKVskMF07IGlmICghc2VsZi5oYXNPd25Qcm9wZXJ0eSgnZ2V0RGVidWdNb2RlJykpIHRocm93ICdhIEpTSW1wbGVtZW50YXRpb24gbXVzdCBpbXBsZW1lbnQgYWxsIGZ1bmN0aW9ucywgeW91IGZvcmdvdCBEZWJ1Z0RyYXdlcjo6Z2V0RGVidWdNb2RlLic7IHJldHVybiBzZWxmWydnZXREZWJ1Z01vZGUnXSgpOyB9AGkAAAAAAACADwAAPwAAAEAAAABBAAAAQgAAAEMAAABEAAAARQAAAEYAAABHAAAASAAAAEkAAABKAAAASwAAAEwAAABNAAAATgAAADIzYnREZWZhdWx0U29mdEJvZHlTb2x2ZXIAMTZidFNvZnRCb2R5U29sdmVyAAAAACBoAABiDwAASGgAAEgPAAB4DwAAAAAAANgPAABPAAAAUAAAAFEAAABSAAAAUwAAAFQAAAA0MWJ0U29mdEJvZHlSaWdpZEJvZHlDb2xsaXNpb25Db25maWd1cmF0aW9uAEhoAACsDwAAdCoAAAAAAABQEAAAVQAAAFYAAABXAAAATjI4YnRTb2Z0U29mdENvbGxpc2lvbkFsZ29yaXRobTEwQ3JlYXRlRnVuY0UAMzBidENvbGxpc2lvbkFsZ29yaXRobUNyZWF0ZUZ1bmMAAAAgaAAAJRAAAEhoAAD4DwAASBAAAAAAAACgEAAAVQAAAFgAAABZAAAATjI5YnRTb2Z0UmlnaWRDb2xsaXNpb25BbGdvcml0aG0xMENyZWF0ZUZ1bmNFAAAASGgAAHAQAABIEAAAAAAAAPQQAABVAAAAWgAAAFsAAABOMzVidFNvZnRCb2R5Q29uY2F2ZUNvbGxpc2lvbkFsZ29yaXRobTEwQ3JlYXRlRnVuY0UASGgAAMAQAABIEAAAAAAAAFARAABVAAAAXAAAAF0AAABOMzVidFNvZnRCb2R5Q29uY2F2ZUNvbGxpc2lvbkFsZ29yaXRobTE3U3dhcHBlZENyZWF0ZUZ1bmNFAABIaAAAFBEAAEgQAAAAAAAAXBMAAF8AAABgAAAAYQAAAGIAAABjAAAAZAAAAGUAAABmAAAAAAAAAKQTAABnAAAAaAAAAGkAAABqAAAAawAAAGwAAABtAEG0IwuAegEAAAACAAAAAAAAAAEAAAADAAAAAQAAAAIAAAADAAAAAAAAAAIAAAADAAAAVXBkYXRlQ2x1c3RlcnMAQXBwbHlDbHVzdGVycwBTb2Z0Qm9keSBhcHBseUZvcmNlcwBTb2Z0Qm9keU1hdGVyaWFsRGF0YQBTb2Z0Qm9keU5vZGVEYXRhAFNvZnRCb2R5TGlua0RhdGEAU29mdEJvZHlGYWNlRGF0YQBTb2Z0Qm9keVRldHJhRGF0YQBTb2Z0UmlnaWRBbmNob3JEYXRhAGJ0VmVjdG9yM0Zsb2F0RGF0YQBmbG9hdABTb2Z0Qm9keVBvc2VEYXRhAGludABTb2Z0Qm9keUNsdXN0ZXJEYXRhAGJ0U29mdEJvZHlKb2ludERhdGEAYnRTb2Z0Qm9keUZsb2F0RGF0YQBOMTBidFNvZnRCb2R5NUpvaW50RQAAIGgAAOoSAAAAAAAAQBMAAG4AAABvAAAAcAAAAHEAAAByAAAAcwAAAE4xMGJ0U29mdEJvZHk2Q0pvaW50RQAAAEhoAAAoEwAAABMAADEwYnRTb2Z0Qm9keQAAAABIaAAATBMAALAlAABOMTBidFNvZnRCb2R5MTVSYXlGcm9tVG9DYXN0ZXJFAE42YnREYnZ0OElDb2xsaWRlRQAAIGgAAIgTAABIaAAAaBMAAJwTAAAAAAAAGBQAAHQAAAB1AAAAdgAAAHcAAAB4AAAAeQAAAHoAAAB7AAAAfAAAAH0AAAB+AAAAfwAAAIAAAACBAAAAggAAAIMAAACEAAAAMjRidFNvZnRCb2R5Q29sbGlzaW9uU2hhcGUAAEhoAAD8EwAA+E0AAFNvZnRCb2R5AAAAAAAAAAB4FAAAZwAAAIUAAABpAAAAhgAAAGsAAABsAAAAbQAAAE4xNWJ0U29mdENvbGxpZGVyczEzQ29sbGlkZVNERl9SU0UAAEhoAABUFAAAnBMAAAAAAAD4FAAAZwAAAIcAAABpAAAAiAAAAGsAAABsAAAAbQAAAE4xNWJ0U29mdENvbGxpZGVyczEyQ29sbGlkZUNMX1JTRQBOMTVidFNvZnRDb2xsaWRlcnMxMUNsdXN0ZXJCYXNlRQAASGgAAMoUAACcEwAASGgAAKgUAADsFAAAAAAAAIwVAACJAAAAigAAAIsAAAB3AAAAeAAAAHkAAACMAAAAjQAAAI4AAACPAAAAfgAAAJAAAACRAAAAkgAAAJMAAACDAAAAlAAAAJUAAACWAAAAlwAAAJgAAACZAAAAmgAAAJsAAAAyN2J0U29mdENsdXN0ZXJDb2xsaXNpb25TaGFwZQAAAEhoAABsFQAAfEkAAFNPRlRDTFVTVEVSAGJ0Q29udmV4SW50ZXJuYWxTaGFwZURhdGEAAAAAAAAACBYAAGcAAACcAAAAnQAAAJ4AAABrAAAAbAAAAG0AAABOMTVidFNvZnRDb2xsaWRlcnMxMkNvbGxpZGVDTF9TU0UAAABIaAAA5BUAAOwUAAAAAAAAXBYAAGcAAACfAAAAoAAAAJ4AAABrAAAAbAAAAG0AAABOMTVidFNvZnRDb2xsaWRlcnMxMkNvbGxpZGVWRl9TU0UAAABIaAAAOBYAAJwTAAChAAAAogAAAKMAAACkAAAAAAAAANQWAAClAAAApgAAAKcAAACoAAAAqQAAADI5YnRTb2Z0UmlnaWRDb2xsaXNpb25BbGdvcml0aG0AMjBidENvbGxpc2lvbkFsZ29yaXRobQAAIGgAALQWAABIaAAAlBYAAMwWAAAAAAAAOBcAAKoAAACrAAAArAAAAK0AAACuAAAAAAAAAGQXAACvAAAAsAAAALEAAAAzNWJ0U29mdEJvZHlDb25jYXZlQ29sbGlzaW9uQWxnb3JpdGhtAAAASGgAABAXAADMFgAAMjZidFNvZnRCb2R5VHJpYW5nbGVDYWxsYmFjawAAAABIaAAARBcAAKhKAAAAAAAAJBgAALIAAACzAAAAtAAAAFpOMzVidFNvZnRCb2R5Q29uY2F2ZUNvbGxpc2lvbkFsZ29yaXRobTIxY2FsY3VsYXRlVGltZU9mSW1wYWN0RVAxN2J0Q29sbGlzaW9uT2JqZWN0UzFfUksxNmJ0RGlzcGF0Y2hlckluZm9QMTZidE1hbmlmb2xkUmVzdWx0RTMxTG9jYWxUcmlhbmdsZVNwaGVyZUNhc3RDYWxsYmFjawBIaAAAhBcAAKhKAAAAAAAAbBgAALUAAAC2AAAAtwAAALgAAAC5AAAATjEyYnRDb252ZXhDYXN0MTBDYXN0UmVzdWx0RQAAAAAgaAAATBgAAAAAAAAQGQAAugAAALsAAAC8AAAAdwAAAHgAAAB5AAAAjAAAAI0AAAC9AAAAvgAAAH4AAAC/AAAAwAAAAJIAAACTAAAAgwAAAMEAAADCAAAAlgAAAMMAAACYAAAAxAAAAMUAAADGAAAAxwAAAMgAAADJAAAAygAAAMsAAADMAAAAzQAAAM4AAAAxNWJ0VHJpYW5nbGVTaGFwZQAAAEhoAAD8GAAAPEcAAFRyaWFuZ2xlAAAAAAAAAABAGgAAzwAAANAAAADRAAAA0gAAANMAAADUAAAA1QAAANYAAADXAAAA2AAAANkAAADaAAAA2wAAANwAAADdAAAA3gAAAN8AAADgAAAA4QAAAOIAAADjAAAA5AAAAOUAAADmAAAA5wAAAOgAAADpAAAA6gAAAOsAAADsAAAA7QAAAO4AAADvAAAA8AAAAPEAAADyAAAA8wAAAPQAAAD1AAAA9gAAAPcAAAD4AAAA+QAAAPoAAAD7AAAAcHJlZGljdFVuY29uc3RyYWludE1vdGlvblNvZnRCb2R5AHNvbHZlU29mdENvbnN0cmFpbnRzAHJheVRlc3QAMjRidFNvZnRSaWdpZER5bmFtaWNzV29ybGQAAABIaAAAIxoAAOAdAAAAAAAAxBoAAPwAAAD9AAAA/gAAADIzYnRTb2Z0U2luZ2xlUmF5Q2FsbGJhY2sAMjNidEJyb2FkcGhhc2VSYXlDYWxsYmFjawAyNGJ0QnJvYWRwaGFzZUFhYmJDYWxsYmFjawAAIGgAAJQaAABIaAAAehoAALAaAABIaAAAYBoAALgaAAAAAAAADBsAAP8AAAAAAQAAAQEAAAIBAAADAQAAMjhidFNvZnRTb2Z0Q29sbGlzaW9uQWxnb3JpdGhtAABIaAAA7BoAAMwWAAAAAAAAYBsAAAQBAAAFAQAABgEAAAcBAAAIAQAACQEAAAoBAABidFJpZ2lkQm9keUZsb2F0RGF0YQAxMWJ0UmlnaWRCb2R5AABIaAAAURsAALAlAAAAAAAA4B0AAAsBAAAMAQAA0QAAANIAAADTAAAA1AAAAA0BAADWAAAADgEAANgAAAAPAQAA2gAAABABAADcAAAA3QAAAN4AAADfAAAA4AAAAOEAAADiAAAA4wAAAOQAAADlAAAA5gAAAOcAAADoAAAA6QAAAOoAAADrAAAAEQEAAO0AAADuAAAA7wAAAPAAAADxAAAAEgEAAPMAAAD0AAAA9QAAAPYAAAATAQAA+AAAAPkAAAD6AAAA+wAAAGRlYnVnRHJhd1dvcmxkAHN5bmNocm9uaXplTW90aW9uU3RhdGVzAHN0ZXBTaW11bGF0aW9uAGludGVybmFsU2luZ2xlU3RlcFNpbXVsYXRpb24AdXBkYXRlQWN0aW9ucwB1cGRhdGVBY3RpdmF0aW9uU3RhdGUAc29sdmVDb25zdHJhaW50cwBjYWxjdWxhdGVTaW11bGF0aW9uSXNsYW5kcwBjcmVhdGVQcmVkaWN0aXZlQ29udGFjdHMAcmVsZWFzZSBwcmVkaWN0aXZlIGNvbnRhY3QgbWFuaWZvbGRzAHByZWRpY3RpdmUgY29udmV4U3dlZXBUZXN0AGludGVncmF0ZVRyYW5zZm9ybXMAQ0NEIG1vdGlvbiBjbGFtcGluZwBhcHBseSBzcGVjdWxhdGl2ZSBjb250YWN0IHJlc3RpdHV0aW9uAHByZWRpY3RVbmNvbnN0cmFpbnRNb3Rpb24AYnREeW5hbWljc1dvcmxkRmxvYXREYXRhADIzYnREaXNjcmV0ZUR5bmFtaWNzV29ybGQAMTVidER5bmFtaWNzV29ybGQAAAAASGgAAL8dAAAwMwAASGgAAKUdAADUHQAAAAAAAFQeAAAUAQAAFQEAABYBAAAyN0lucGxhY2VTb2x2ZXJJc2xhbmRDYWxsYmFjawBOMjVidFNpbXVsYXRpb25Jc2xhbmRNYW5hZ2VyMTRJc2xhbmRDYWxsYmFja0UAIGgAAB4eAABIaAAAAB4AAEweAAAAAAAAoB4AAAUAAAAXAQAAGAEAABkBAAAzNGJ0Q2xvc2VzdE5vdE1lQ29udmV4UmVzdWx0Q2FsbGJhY2sAAAAASGgAAHgeAACEBAAAAAAAAPQeAAAaAQAAGwEAABwBAAAdAQAAHgEAAB8BAAAgAQAAIQEAACIBAAAjAQAAJAEAADE3YnRGaXhlZENvbnN0cmFpbnQASGgAAOAeAAAEIQAAAAAAAFQfAAAlAQAAJgEAACcBAAAdAQAAKAEAACkBAAAgAQAAKgEAACsBAAAsAQAALQEAAC4BAAAyM2J0R2VuZXJpYzZEb2ZDb25zdHJhaW50AAAASGgAADgfAAAEIQAAYnRHZW5lcmljNkRvZkNvbnN0cmFpbnREYXRhAAAAAADYHwAAJQEAAC8BAAAnAQAAHQEAACgBAAAwAQAAIAEAACoBAAArAQAAMQEAADIBAAAuAQAAMwEAADI5YnRHZW5lcmljNkRvZlNwcmluZ0NvbnN0cmFpbnQASGgAALgfAABUHwAAYnRHZW5lcmljNkRvZlNwcmluZ0NvbnN0cmFpbnREYXRhAAAAAAAAAFggAAAlAQAANAEAADUBAAAdAQAANgEAADcBAAAgAQAAOAEAADkBAAA6AQAAOwEAADIzYnRQb2ludDJQb2ludENvbnN0cmFpbnQAAABIaAAAPCAAAAQhAABidFBvaW50MlBvaW50Q29uc3RyYWludEZsb2F0RGF0YQAAAAAAAAAABCEAACUBAAA9AQAAHAEAAB0BAAAHAAAABwAAACABAAAHAAAABwAAACMBAAAkAQAAYnRUeXBlZENvbnN0cmFpbnRGbG9hdERhdGEAMTdidFR5cGVkQ29uc3RyYWludAAxM2J0VHlwZWRPYmplY3QAACBoAADrIAAApGgAANcgAAAAAAAAAQAAAPwgAAACBAAAAAAAAGghAAAlAQAAPgEAABwBAAAdAQAAPwEAAEABAAAgAQAAQQEAAEIBAABDAQAARAEAADE4YnRTbGlkZXJDb25zdHJhaW50AAAAAEhoAABQIQAABCEAAGJ0U2xpZGVyQ29uc3RyYWludERhdGEAAAAAAADcIQAAJQEAAEUBAABGAQAAHQEAAEcBAABIAQAASQEAAEoBAABLAQAATAEAAE0BAABOAQAAMjFidENvbmVUd2lzdENvbnN0cmFpbnQASGgAAMQhAAAEIQAAYnRDb25lVHdpc3RDb25zdHJhaW50RGF0YQAAAAAAAABMIgAAJQEAAE8BAABQAQAAHQEAAFEBAABSAQAAIAEAAFMBAABUAQAAVQEAAFYBAAAxN2J0SGluZ2VDb25zdHJhaW50AEhoAAA4IgAABCEAAGJ0SGluZ2VDb25zdHJhaW50RmxvYXREYXRhAAAAAAAAQCMAAFcBAABYAQAAWQEAAFoBAABbAQAAXAEAAF0BAABeAQAAXwEAAGABAABhAQAAYgEAAGMBAABzb2x2ZUdyb3VwQ2FjaGVGcmllbmRseVNldHVwAHNvbHZlR3JvdXBDYWNoZUZyaWVuZGx5SXRlcmF0aW9ucwBzb2x2ZUdyb3VwADM1YnRTZXF1ZW50aWFsSW1wdWxzZUNvbnN0cmFpbnRTb2x2ZXIAMThidENvbnN0cmFpbnRTb2x2ZXIAAAAAIGgAACAjAABIaAAA+iIAADgjAAAAAAAA3CMAAGUBAABmAQAAZwEAAGgBAABpAQAAagEAAGsBAAAAAAAAoCMAAA4AAABsAQAAbQEAADI1YnREZWZhdWx0VmVoaWNsZVJheWNhc3RlcgBIaAAAhCMAAHAFAAAxNmJ0UmF5Y2FzdFZlaGljbGUAMTdidEFjdGlvbkludGVyZmFjZQAAIGgAAL8jAABIaAAArCMAANQjAAAAAAAAeCQAAG4BAABvAQAAcAEAAHEBAAByAQAAcwEAAHQBAAB1AQAAdgEAAHcBAAB4AQAAeQEAAHoBAAB7AQAAMzBidEtpbmVtYXRpY0NoYXJhY3RlckNvbnRyb2xsZXIAMzBidENoYXJhY3RlckNvbnRyb2xsZXJJbnRlcmZhY2UAAABIaAAASSQAANQjAABIaAAAKCQAAGwkAAAAAAAAzCQAAAUAAAB8AQAAAwAAAH0BAAA0M2J0S2luZW1hdGljQ2xvc2VzdE5vdE1lQ29udmV4UmVzdWx0Q2FsbGJhY2sAAABIaAAAnCQAAIQEAAAAAAAACCUAAH4BAAB/AQAAgAEAADIyYnRTdWJzaW1wbGV4Q29udmV4Q2FzdAAAAABIaAAA7CQAACQlAAAxMmJ0Q29udmV4Q2FzdAAAIGgAABQlAAABAAAAAgAAAAAAAAABAAAAAgAAAAAAAAABAAAAAgAAAAAAAAACAAAAAAAAAAEAAAAAAAAAsCUAAF8AAACDAQAAhAEAAAcBAACFAQAAhgEAAGUAAABidENvbGxpc2lvbk9iamVjdEZsb2F0RGF0YQAxN2J0Q29sbGlzaW9uT2JqZWN0AAAgaAAAmyUAAAAAAAAgJgAAXwAAAIcBAACIAQAABwEAAIUBAACGAQAAZQAAAIkBAACKAQAAAAAAAEgmAABfAAAAiwEAAIwBAAAHAQAAhQEAAIYBAABlAAAAjQEAAI4BAAAxM2J0R2hvc3RPYmplY3QASGgAABAmAACwJQAAMjRidFBhaXJDYWNoaW5nR2hvc3RPYmplY3QAAEhoAAAsJgAAICYAAAAAAAC0JgAAkAEAAJEBAACSAQAAkwEAAJQBAACVAQAAlgEAAJcBAACYAQAAmQEAAJoBAACbAQAAnAEAAJ0BAACeAQAAnwEAADIxYnRDb2xsaXNpb25EaXNwYXRjaGVyAEhoAACcJgAA3FgAAAAAAAAMJwAAoAEAAKEBAACiAQAAMjNidENvbGxpc2lvblBhaXJDYWxsYmFjawAxN2J0T3ZlcmxhcENhbGxiYWNrAAAAIGgAAO4mAABIaAAA1CYAAAQnAAAAAAAAeCcAAKMBAACkAQAApQEAADMwYnRHamtFcGFQZW5ldHJhdGlvbkRlcHRoU29sdmVyADMwYnRDb252ZXhQZW5ldHJhdGlvbkRlcHRoU29sdmVyAAAAIGgAAE0nAABIaAAALCcAAHAnAAAAAAAA3CcAAKYBAACnAQAAqAEAADE3YnRHamtQYWlyRGV0ZWN0b3IAMzZidERpc2NyZXRlQ29sbGlzaW9uRGV0ZWN0b3JJbnRlcmZhY2UAACBoAACsJwAASGgAAJgnAADUJwAAAAAAACAoAACjAQAAqQEAAKoBAAAzM2J0TWlua293c2tpUGVuZXRyYXRpb25EZXB0aFNvbHZlcgBIaAAA/CcAAHAnAAAAAAAALCkAAKsBAACsAQAArQEAAK4BAACvAQAAWk4zM2J0TWlua293c2tpUGVuZXRyYXRpb25EZXB0aFNvbHZlcjEyY2FsY1BlbkRlcHRoRVIyMmJ0Vm9yb25vaVNpbXBsZXhTb2x2ZXJQSzEzYnRDb252ZXhTaGFwZVM0X1JLMTFidFRyYW5zZm9ybVM3X1I5YnRWZWN0b3IzUzlfUzlfUDEyYnRJRGVidWdEcmF3RTIwYnRJbnRlcm1lZGlhdGVSZXN1bHQATjM2YnREaXNjcmV0ZUNvbGxpc2lvbkRldGVjdG9ySW50ZXJmYWNlNlJlc3VsdEUAACBoAADzKAAASGgAAEgoAAAkKQAAAAAAAGgpAACwAQAAsQEAALIBAACzAQAAtAEAADE2YnRFbXB0eUFsZ29yaXRobQAASGgAAFQpAADMFgAAAAAAALQpAAC1AQAAtgEAAAcAAAAHAAAABwAAADMwYnRBY3RpdmF0aW5nQ29sbGlzaW9uQWxnb3JpdGhtAAAAAEhoAACQKQAAzBYAAAAAAAAAKgAAtwEAALgBAAC5AQAAugEAALsBAAAzMmJ0U3BoZXJlU3BoZXJlQ29sbGlzaW9uQWxnb3JpdGhtAABIaAAA3CkAALQpAAAAAAAAdCoAALwBAAC9AQAAUQAAAFIAAAC+AQAAVAAAADMxYnREZWZhdWx0Q29sbGlzaW9uQ29uZmlndXJhdGlvbgAyNGJ0Q29sbGlzaW9uQ29uZmlndXJhdGlvbgAAAAAgaAAATioAAEhoAAAsKgAAbCoAAAAAAADIKgAAVQAAAL8BAADAAQAATjMzYnRDb252ZXhDb25jYXZlQ29sbGlzaW9uQWxnb3JpdGhtMTBDcmVhdGVGdW5jRQAAAEhoAACUKgAASBAAAAAAAAAkKwAAVQAAAMEBAADCAQAATjMzYnRDb252ZXhDb25jYXZlQ29sbGlzaW9uQWxnb3JpdGhtMTdTd2FwcGVkQ3JlYXRlRnVuY0UAAAAASGgAAOgqAABIEAAAAAAAAHQrAABVAAAAwwEAAMQBAABOMjhidENvbXBvdW5kQ29sbGlzaW9uQWxnb3JpdGhtMTBDcmVhdGVGdW5jRQAAAABIaAAARCsAAEgQAAAAAAAAzCsAAFUAAADFAQAAxgEAAE4zNmJ0Q29tcG91bmRDb21wb3VuZENvbGxpc2lvbkFsZ29yaXRobTEwQ3JlYXRlRnVuY0UAAAAASGgAAJQrAABIEAAAAAAAACAsAABVAAAAxwEAAMgBAABOMjhidENvbXBvdW5kQ29sbGlzaW9uQWxnb3JpdGhtMTdTd2FwcGVkQ3JlYXRlRnVuY0UASGgAAOwrAABIEAAAAAAAAGQsAABVAAAAyQEAAMoBAABOMTZidEVtcHR5QWxnb3JpdGhtMTBDcmVhdGVGdW5jRQAAAABIaAAAQCwAAEgQAAAAAAAAuCwAAFUAAADLAQAAzAEAAE4zMmJ0U3BoZXJlU3BoZXJlQ29sbGlzaW9uQWxnb3JpdGhtMTBDcmVhdGVGdW5jRQAAAABIaAAAhCwAAEgQAAAAAAAADC0AAFUAAADNAQAAzgEAAE4zNGJ0U3BoZXJlVHJpYW5nbGVDb2xsaXNpb25BbGdvcml0aG0xMENyZWF0ZUZ1bmNFAABIaAAA2CwAAEgQAAAAAAAAWC0AAFUAAADPAQAA0AEAAE4yNmJ0Qm94Qm94Q29sbGlzaW9uQWxnb3JpdGhtMTBDcmVhdGVGdW5jRQAASGgAACwtAABIEAAAAAAAAKgtAABVAAAA0QEAANIBAABOMzFidENvbnZleFBsYW5lQ29sbGlzaW9uQWxnb3JpdGhtMTBDcmVhdGVGdW5jRQBIaAAAeC0AAEgQAAAAAAAAFC4AANMBAADUAQAA1QEAANYBAABpc2xhbmRVbmlvbkZpbmRBbmRRdWlja1NvcnQAcHJvY2Vzc0lzbGFuZHMAMjVidFNpbXVsYXRpb25Jc2xhbmRNYW5hZ2VyAAAgaAAA9y0AAAAAAABcLgAA1wEAANgBAADZAQAA2gEAANsBAAAzMWJ0Q29udmV4UGxhbmVDb2xsaXNpb25BbGdvcml0aG0AAABIaAAAOC4AAMwWAAAAAAAAvC4AANwBAADdAQAA3gEAAN8BAADgAQAAAAAAAOQuAADhAQAA4gEAAOMBAAAzM2J0Q29udmV4Q29uY2F2ZUNvbGxpc2lvbkFsZ29yaXRobQBIaAAAmC4AALQpAAAyNGJ0Q29udmV4VHJpYW5nbGVDYWxsYmFjawAASGgAAMguAACoSgAAAAAAAKQvAACyAAAA5AEAAOUBAABaTjMzYnRDb252ZXhDb25jYXZlQ29sbGlzaW9uQWxnb3JpdGhtMjFjYWxjdWxhdGVUaW1lT2ZJbXBhY3RFUDE3YnRDb2xsaXNpb25PYmplY3RTMV9SSzE2YnREaXNwYXRjaGVySW5mb1AxNmJ0TWFuaWZvbGRSZXN1bHRFMzFMb2NhbFRyaWFuZ2xlU3BoZXJlQ2FzdENhbGxiYWNrAAAASGgAAAQvAACoSgAAAAAAANgvAACmAQAA5gEAAOcBAAAxNmJ0Qm94Qm94RGV0ZWN0b3IAAEhoAADELwAA1CcAAAAAAAAgMAAA6AEAAOkBAADqAQAA6wEAAOwBAAAyNmJ0Qm94Qm94Q29sbGlzaW9uQWxnb3JpdGhtAAAAAEhoAAAAMAAAtCkAAAAAAABcMAAAqwEAAO0BAADuAQAA7wEAAPABAAAxNmJ0TWFuaWZvbGRSZXN1bHQAAEhoAABIMAAAJCkAAAAAAACQMAAAfgEAAPEBAADyAQAAMTVidEdqa0NvbnZleENhc3QAAABIaAAAfDAAACQlAAAAAAAAzDAAAKsBAADzAQAA9AEAAPUBAAD2AQAAMTZidFBvaW50Q29sbGVjdG9yAABIaAAAuDAAACQpAAAAAAAADDEAAH4BAAD3AQAA+AEAADI3YnRDb250aW51b3VzQ29udmV4Q29sbGlzaW9uAAAASGgAAOwwAAAkJQAAAAAAAGQxAACyAAAA+QEAAPoBAAAHAAAAAAAAAJAxAACyAAAA+wEAAPwBAAAHAAAAMjVidFRyaWFuZ2xlUmF5Y2FzdENhbGxiYWNrAEhoAABIMQAAqEoAADI4YnRUcmlhbmdsZUNvbnZleGNhc3RDYWxsYmFjawAASGgAAHAxAACoSgAAAAAAADAzAAD9AQAA/gEAANEAAADSAAAA0wAAANQAAAD/AQAA1gAAAA4BAAAAAgAAAQIAANoAAAACAgAAT3ZlcmZsb3cgaW4gQUFCQiwgb2JqZWN0IHJlbW92ZWQgZnJvbSBzaW11bGF0aW9uAElmIHlvdSBjYW4gcmVwcm9kdWNlIHRoaXMsIHBsZWFzZSBlbWFpbCBidWdzQGNvbnRpbnVvdXNwaHlzaWNzLmNvbQoAUGxlYXNlIGluY2x1ZGUgYWJvdmUgaW5mb3JtYXRpb24sIHlvdXIgUGxhdGZvcm0sIHZlcnNpb24gb2YgT1MuCgBUaGFua3MuCgB1cGRhdGVBYWJicwBjYWxjdWxhdGVPdmVybGFwcGluZ1BhaXJzAHBlcmZvcm1EaXNjcmV0ZUNvbGxpc2lvbkRldGVjdGlvbgBkaXNwYXRjaEFsbENvbGxpc2lvblBhaXJzAGNvbnZleFN3ZWVwQ29tcG91bmQAY29udmV4U3dlZXBUZXN0ADE2YnRDb2xsaXNpb25Xb3JsZAAgaAAAHTMAAAAAAADkMwAAsgAAAAMCAAD6AQAABAIAAFpOMTZidENvbGxpc2lvbldvcmxkMjFyYXlUZXN0U2luZ2xlSW50ZXJuYWxFUksxMWJ0VHJhbnNmb3JtUzJfUEsyNGJ0Q29sbGlzaW9uT2JqZWN0V3JhcHBlclJOU18xN1JheVJlc3VsdENhbGxiYWNrRUUyOUJyaWRnZVRyaWFuZ2xlUmF5Y2FzdENhbGxiYWNrAABIaAAAUDMAAGQxAAAAAAAAoDQAALIAAAAFAgAA+gEAAAYCAABaTjE2YnRDb2xsaXNpb25Xb3JsZDIxcmF5VGVzdFNpbmdsZUludGVybmFsRVJLMTFidFRyYW5zZm9ybVMyX1BLMjRidENvbGxpc2lvbk9iamVjdFdyYXBwZXJSTlNfMTdSYXlSZXN1bHRDYWxsYmFja0VFMjlCcmlkZ2VUcmlhbmdsZVJheWNhc3RDYWxsYmFja18wAAAAAEhoAAAINAAAZDEAAAAAAABQNQAAZwAAAAcCAABpAAAACAIAAGsAAABsAAAAbQAAAFpOMTZidENvbGxpc2lvbldvcmxkMjFyYXlUZXN0U2luZ2xlSW50ZXJuYWxFUksxMWJ0VHJhbnNmb3JtUzJfUEsyNGJ0Q29sbGlzaW9uT2JqZWN0V3JhcHBlclJOU18xN1JheVJlc3VsdENhbGxiYWNrRUU5UmF5VGVzdGVyAAAASGgAANA0AACcEwAAAAAAAPw1AAAMAAAACQIAAAoCAAALAgAAWk4xNmJ0Q29sbGlzaW9uV29ybGQyMXJheVRlc3RTaW5nbGVJbnRlcm5hbEVSSzExYnRUcmFuc2Zvcm1TMl9QSzI0YnRDb2xsaXNpb25PYmplY3RXcmFwcGVyUk5TXzE3UmF5UmVzdWx0Q2FsbGJhY2tFRTE1TG9jYWxJbmZvQWRkZXIyAAAAAEhoAAB0NQAAGAUAAAAAAADQNgAAsgAAAAwCAAD8AQAADQIAAFpOMTZidENvbGxpc2lvbldvcmxkMjVvYmplY3RRdWVyeVNpbmdsZUludGVybmFsRVBLMTNidENvbnZleFNoYXBlUksxMWJ0VHJhbnNmb3JtUzVfUEsyNGJ0Q29sbGlzaW9uT2JqZWN0V3JhcHBlclJOU18yMENvbnZleFJlc3VsdENhbGxiYWNrRWZFMzJCcmlkZ2VUcmlhbmdsZUNvbnZleGNhc3RDYWxsYmFjawAASGgAACA2AACQMQAAAAAAAKg3AACyAAAADgIAAPwBAAAPAgAAWk4xNmJ0Q29sbGlzaW9uV29ybGQyNW9iamVjdFF1ZXJ5U2luZ2xlSW50ZXJuYWxFUEsxM2J0Q29udmV4U2hhcGVSSzExYnRUcmFuc2Zvcm1TNV9QSzI0YnRDb2xsaXNpb25PYmplY3RXcmFwcGVyUk5TXzIwQ29udmV4UmVzdWx0Q2FsbGJhY2tFZkUzMkJyaWRnZVRyaWFuZ2xlQ29udmV4Y2FzdENhbGxiYWNrXzAAAAAASGgAAPQ2AACQMQAAAAAAAGw4AAAFAAAAEAIAABECAAASAgAAWk4xNmJ0Q29sbGlzaW9uV29ybGQyNW9iamVjdFF1ZXJ5U2luZ2xlSW50ZXJuYWxFUEsxM2J0Q29udmV4U2hhcGVSSzExYnRUcmFuc2Zvcm1TNV9QSzI0YnRDb2xsaXNpb25PYmplY3RXcmFwcGVyUk5TXzIwQ29udmV4UmVzdWx0Q2FsbGJhY2tFZkUxNExvY2FsSW5mb0FkZGVyAAAAAEhoAADMNwAAfAQAAAAAAACkOAAA/AAAABMCAAAUAgAAMTlidFNpbmdsZVJheUNhbGxiYWNrAAAASGgAAIw4AAC4GgAAAAAAANw4AAD8AAAAFQIAABYCAAAyMWJ0U2luZ2xlU3dlZXBDYWxsYmFjawBIaAAAxDgAALgaAAAAAAAAGDkAAPwAAAAXAgAAGAIAADIzYnRTaW5nbGVDb250YWN0Q2FsbGJhY2sAAABIaAAA/DgAALAaAAAAAAAAXDkAAKsBAAAZAgAA7gEAAO8BAAAaAgAAMjNidEJyaWRnZWRNYW5pZm9sZFJlc3VsdAAAAEhoAABAOQAAXDAAAAAAAACoOQAAGwIAABwCAAAdAgAAHgIAAPz///+oOQAAHwIAACACAAAhAgAAMTdEZWJ1Z0RyYXdjYWxsYmFjawCkaAAAlDkAAAAAAAACAAAAqEoAAAIAAADUSgAAAgQAAAAAAAD4OQAApgEAACICAAAjAgAAMjJTcGhlcmVUcmlhbmdsZURldGVjdG9yAAAAAEhoAADcOQAA1CcAAAAAAABIOgAAJAIAACUCAAAmAgAAJwIAACgCAAAzNGJ0U3BoZXJlVHJpYW5nbGVDb2xsaXNpb25BbGdvcml0aG0AAAAASGgAACA6AAC0KQAAAAAAAKw6AAApAgAAKgIAACsCAAAAAAAA1DoAACwCAAAtAgAALgIAAC8CAAAwAgAATjIzYnRDb252ZXhDb252ZXhBbGdvcml0aG0xMENyZWF0ZUZ1bmNFAEhoAACEOgAASBAAADIzYnRDb252ZXhDb252ZXhBbGdvcml0aG0AAABIaAAAuDoAALQpAAAAAAAAhDsAAKsBAAAxAgAAMgIAADMCAAA0AgAAWk4yM2J0Q29udmV4Q29udmV4QWxnb3JpdGhtMTZwcm9jZXNzQ29sbGlzaW9uRVBLMjRidENvbGxpc2lvbk9iamVjdFdyYXBwZXJTMl9SSzE2YnREaXNwYXRjaGVySW5mb1AxNmJ0TWFuaWZvbGRSZXN1bHRFMTNidER1bW15UmVzdWx0AAAAAEhoAAD8OgAAJCkAAAAAAAA8PAAAqwEAADUCAAA2AgAANwIAADgCAABaTjIzYnRDb252ZXhDb252ZXhBbGdvcml0aG0xNnByb2Nlc3NDb2xsaXNpb25FUEsyNGJ0Q29sbGlzaW9uT2JqZWN0V3JhcHBlclMyX1JLMTZidERpc3BhdGNoZXJJbmZvUDE2YnRNYW5pZm9sZFJlc3VsdEUyMWJ0V2l0aG91dE1hcmdpblJlc3VsdAAAAABIaAAArDsAACQpAAAAAAAAgDwAAKsBAAA5AgAA7gEAAO8BAAA6AgAAMjRidFBlcnR1cmJlZENvbnRhY3RSZXN1bHQAAEhoAABkPAAAXDAAAAAAAADIPAAAOwIAADwCAAA9AgAAPgIAAD8CAAAyOGJ0Q29tcG91bmRDb2xsaXNpb25BbGdvcml0aG0AAEhoAACoPAAAtCkAAAAAAAAUPQAAZwAAAEACAABpAAAAQQIAAGsAAABsAAAAbQAAADIyYnRDb21wb3VuZExlYWZDYWxsYmFjawAAAABIaAAA+DwAAJwTAAAAAAAAWD0AAEICAABDAgAARAIAAEUCAABGAgAAMjNidEhhc2hlZFNpbXBsZVBhaXJDYWNoZQAAACBoAAA8PQAAAAAAAKQ9AABHAgAASAIAAEkCAABKAgAASwIAADM2YnRDb21wb3VuZENvbXBvdW5kQ29sbGlzaW9uQWxnb3JpdGhtAABIaAAAfD0AALQpAAAAAAAA+D0AAGcAAABMAgAATQIAAJ4AAABrAAAAbAAAAG0AAAAzMGJ0Q29tcG91bmRDb21wb3VuZExlYWZDYWxsYmFjawAAAABIaAAA1D0AAJwTAAAAAAAAlD4AAE4CAABPAgAAUAIAAHcAAAB4AAAAeQAAAFECAABSAgAAUwIAAFQCAAB+AAAAVQIAAFYCAABXAgAAWAIAAIMAAABZAgAAWgIAAGJ0Q29tcG91bmRTaGFwZUNoaWxkRGF0YQBidENvbXBvdW5kU2hhcGVEYXRhADE1YnRDb21wb3VuZFNoYXBlAABIaAAAgT4AABRIAABDb21wb3VuZAAAAAAAAAAA6D8AAIkAAABbAgAAXAIAAHcAAAB4AAAAeQAAAF0CAACNAAAAXgIAAF8CAABgAgAAvwAAAMAAAABhAgAAYgIAAIMAAABjAgAAZAIAAJYAAABlAgAAmAAAAJkAAACaAAAAAAAAAARAAACJAAAAZgIAAFwCAAB3AAAAeAAAAHkAAABdAgAAjQAAAF4CAABnAgAAaAIAAL8AAADAAAAAYQIAAGICAACDAAAAYwIAAGQCAACWAAAAZQIAAJgAAACZAAAAmgAAAAAAAAAgQAAAiQAAAGkCAABcAgAAdwAAAHgAAAB5AAAAXQIAAI0AAABeAgAAagIAAGsCAAC/AAAAwAAAAGECAABiAgAAgwAAAGMCAABkAgAAlgAAAGUCAACYAAAAmQAAAJoAAAAxMWJ0Q29uZVNoYXBlAAAASGgAANg/AAB8SQAAMTJidENvbmVTaGFwZVoAAEhoAAD0PwAA6D8AADEyYnRDb25lU2hhcGVYAABIaAAAEEAAAOg/AABDb25lAGJ0Q29uZVNoYXBlRGF0YQBDb25lWgBDb25lWAAAAAAAAAAAeEAAAGwCAABtAgAAMThidENvbnZleFBvbHloZWRyb24AAAAAIGgAAGBAAAAAAAAAJEEAAG4CAABvAgAAcAIAAHcAAAB4AAAAeQAAAHECAACNAAAAcgIAAHMCAAB+AAAAvwAAAMAAAAB0AgAAdQIAAIMAAADBAAAAdgIAAJYAAAB3AgAAmAAAAJkAAACaAAAAYnRQb3NpdGlvbkFuZFJhZGl1cwBidE11bHRpU3BoZXJlU2hhcGVEYXRhADE4YnRNdWx0aVNwaGVyZVNoYXBlAEhoAAAPQQAArEkAAE11bHRpU3BoZXJlAAAAAACwQQAAiQAAAHgCAAB5AgAAdwAAAHgAAAB5AAAAjAAAAI0AAAB6AgAAewIAAH4AAAB8AgAAfQIAAJIAAACTAAAAgwAAAH4CAAB/AgAAlgAAAIACAACYAAAAmQAAAJoAAAAxM2J0U3BoZXJlU2hhcGUASGgAAKBBAAB8SQAAU1BIRVJFAAAAAAAAVEIAAIECAACCAgAAgwIAAHcAAAB4AAAAeQAAAIQCAACFAgAAhgIAAIcCAAB+AAAAfwAAAIAAAACIAgAAiQIAAIMAAACKAgAAiwIAAIwCAACNAgAAjgIAAGJ0VHJpYW5nbGVNZXNoU2hhcGVEYXRhADIyYnRCdmhUcmlhbmdsZU1lc2hTaGFwZQAAAABIaAAAOEIAAKhEAAAAAAAA/EIAAI8CAACQAgAAkQIAAFpOMjJidEJ2aFRyaWFuZ2xlTWVzaFNoYXBlMTRwZXJmb3JtUmF5Y2FzdEVQMThidFRyaWFuZ2xlQ2FsbGJhY2tSSzlidFZlY3RvcjNTNF9FMjFNeU5vZGVPdmVybGFwQ2FsbGJhY2sAMjFidE5vZGVPdmVybGFwQ2FsbGJhY2sAIGgAANxCAABIaAAAdEIAAPRCAAAAAAAAkEMAAI8CAACSAgAAkwIAAFpOMjJidEJ2aFRyaWFuZ2xlTWVzaFNoYXBlMTdwZXJmb3JtQ29udmV4Y2FzdEVQMThidFRyaWFuZ2xlQ2FsbGJhY2tSSzlidFZlY3RvcjNTNF9TNF9TNF9FMjFNeU5vZGVPdmVybGFwQ2FsbGJhY2sAAAAASGgAABxDAAD0QgAAAAAAACBEAACPAgAAlAIAAJUCAABaTksyMmJ0QnZoVHJpYW5nbGVNZXNoU2hhcGUxOXByb2Nlc3NBbGxUcmlhbmdsZXNFUDE4YnRUcmlhbmdsZUNhbGxiYWNrUks5YnRWZWN0b3IzUzRfRTIxTXlOb2RlT3ZlcmxhcENhbGxiYWNrAAAASGgAALBDAAD0QgAAQlZIVFJJQU5HTEVNRVNIAAAAAACoRAAAlgIAAJcCAACDAgAAdwAAAHgAAAB5AAAAmAIAAIUCAACGAgAAmQIAAH4AAAB/AAAAgAAAAIEAAACCAAAAgwAAAJoCAACLAgAAjAIAADE5YnRUcmlhbmdsZU1lc2hTaGFwZQAAAEhoAACQRAAA+E0AAAAAAAAwRQAAmwIAAJwCAACdAgAAWk5LMTlidFRyaWFuZ2xlTWVzaFNoYXBlMTlwcm9jZXNzQWxsVHJpYW5nbGVzRVAxOGJ0VHJpYW5nbGVDYWxsYmFja1JLOWJ0VmVjdG9yM1M0X0UxNkZpbHRlcmVkQ2FsbGJhY2sAAABIaAAAyEQAANRKAAAAAAAAaEUAALIAAACeAgAAnwIAADIxU3VwcG9ydFZlcnRleENhbGxiYWNrAEhoAABQRQAAqEoAAFRSSUFOR0xFTUVTSAAAAAAAAAAA6EUAAKACAAChAgAAogIAAHcAAAB4AAAAeQAAAKMCAACkAgAApQIAAKYCAAB+AAAAfwAAAIAAAACnAgAAqAIAAIMAAACpAgAAMThidFN0YXRpY1BsYW5lU2hhcGUAAAAASGgAANBFAAD4TQAAU1RBVElDUExBTkUAYnRTdGF0aWNQbGFuZVNoYXBlRGF0YQAAAAAAADxHAAC6AAAAqgIAAFwCAAB3AAAAeAAAAHkAAACMAAAAjQAAAKsCAAAHAAAAfgAAAL8AAADAAAAAkgAAAJMAAACDAAAAwQAAAKwCAACWAAAArQIAAJgAAACZAAAAmgAAAMYAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAAAAAAAHBHAAC6AAAArgIAAK8CAAB3AAAAeAAAAHkAAACwAgAAjQAAAKsCAAAHAAAAfgAAAL8AAADAAAAAkgAAAJMAAACDAAAAwQAAAKwCAACWAAAArQIAAJgAAACZAAAAmgAAAMYAAAAHAAAABwAAAAcAAAAHAAAABwAAAAcAAAAHAAAAMjNidFBvbHloZWRyYWxDb252ZXhTaGFwZQAAAEhoAAAgRwAAfEkAADM0YnRQb2x5aGVkcmFsQ29udmV4QWFiYkNhY2hpbmdTaGFwZQAAAABIaAAASEcAADxHAAAAAAAA2EcAALECAACyAgAAswIAAHcAAAB4AAAAeQAAALQCAAC1AgAAtgIAALcCAAB+AAAAfwAAAIAAAACBAAAAggAAAIMAAAC4AgAAMTJidEVtcHR5U2hhcGUAAEhoAADIRwAA+E0AAEVtcHR5AGJ0Q29sbGlzaW9uU2hhcGVEYXRhADE2YnRDb2xsaXNpb25TaGFwZQAAACBoAAD/RwAAAAAAAJBIAACJAAAAuQIAAAcAAAB3AAAAeAAAAHkAAAAHAAAABwAAAAcAAAAHAAAAfgAAAAcAAAAHAAAAgQAAAIIAAACDAAAABwAAAAcAAACWAAAABwAAAAcAAAAHAAAABwAAADEzYnRDb252ZXhTaGFwZQBIaAAAgEgAABRIAAAAAAAAfEkAAIkAAAC6AgAAXAIAAHcAAAB4AAAAeQAAAIwAAACNAAAABwAAAAcAAAB+AAAAvwAAAMAAAACSAAAAkwAAAIMAAADBAAAABwAAAJYAAAAHAAAAmAAAAJkAAACaAAAAAAAAAKxJAACJAAAAuwIAAHACAAB3AAAAeAAAAHkAAABxAgAAjQAAAAcAAAAHAAAAfgAAAL8AAADAAAAAkgAAAJMAAACDAAAAwQAAAAcAAACWAAAABwAAAJgAAACZAAAAmgAAADIxYnRDb252ZXhJbnRlcm5hbFNoYXBlAEhoAABkSQAAkEgAADMyYnRDb252ZXhJbnRlcm5hbEFhYmJDYWNoaW5nU2hhcGUAAEhoAACISQAAfEkAAAAAAACASgAAvAIAAL0CAACvAgAAdwAAAHgAAAB5AAAAvgIAAI0AAACrAgAAvwIAAH4AAAC/AAAAwAAAAMACAADBAgAAgwAAAMICAADDAgAAlgAAAMQCAACYAAAAmQAAAJoAAADGAAAAxQIAAMYCAADHAgAAyAIAAMkCAADKAgAAywIAAMwCAABidFZlY3RvcjNGbG9hdERhdGEAYnRDb252ZXhIdWxsU2hhcGVEYXRhADE3YnRDb252ZXhIdWxsU2hhcGUAAAAASGgAAGlKAABwRwAAQ29udmV4ADE4YnRUcmlhbmdsZUNhbGxiYWNrACBoAACTSgAAMzFidEludGVybmFsVHJpYW5nbGVJbmRleENhbGxiYWNrAAAAIGgAALBKAAAAAAAAHEwAAIkAAADNAgAAzgIAAHcAAAB4AAAAeQAAAM8CAACNAAAA0AIAANECAADSAgAA0wIAAMAAAADUAgAA1QIAAIMAAADBAAAA1gIAAJYAAADXAgAAmAAAAJkAAACaAAAAAAAAADxMAACJAAAA2AIAAM4CAAB3AAAAeAAAAHkAAADPAgAAjQAAANACAADZAgAA0gIAANMCAADAAAAA1AIAANUCAACDAAAAwQAAANYCAACWAAAA1wIAAJgAAACZAAAAmgAAAAAAAABcTAAAiQAAANoCAADOAgAAdwAAAHgAAAB5AAAAzwIAAI0AAADQAgAA2wIAANICAADTAgAAwAAAANQCAADVAgAAgwAAAMEAAADWAgAAlgAAANcCAACYAAAAmQAAAJoAAAAxNGJ0Q2Fwc3VsZVNoYXBlAAAAAEhoAAAITAAAfEkAADE1YnRDYXBzdWxlU2hhcGVYAAAASGgAAChMAAAcTAAAMTVidENhcHN1bGVTaGFwZVoAAABIaAAASEwAABxMAABDYXBzdWxlU2hhcGUAYnRDYXBzdWxlU2hhcGVEYXRhAENhcHN1bGVYAENhcHN1bGVaAAAAAAAAADxNAAC6AAAA3AIAAK8CAAB3AAAAeAAAAHkAAADdAgAA3gIAAKsCAADfAgAAfgAAAL8AAADAAAAAkgAAAJMAAACDAAAA4AIAAOECAACWAAAA4gIAAJgAAACZAAAAmgAAAMYAAADjAgAA5AIAAOUCAADmAgAA5wIAAOgCAADpAgAAMjVidENvbnZleFRyaWFuZ2xlTWVzaFNoYXBlAEhoAAAgTQAAcEcAAAAAAAB8TQAAmwIAAOoCAADrAgAAMjZMb2NhbFN1cHBvcnRWZXJ0ZXhDYWxsYmFjawAAAABIaAAAXE0AANRKAABDb252ZXhUcmltZXNoAAAAAAAAAPhNAAB0AAAA7AIAAAcAAAB3AAAAeAAAAHkAAAAHAAAABwAAAAcAAAAHAAAAfgAAAH8AAACAAAAAgQAAAIIAAACDAAAABwAAADE0YnRDb25jYXZlU2hhcGUAAAAASGgAAORNAAAUSAAAAAAAAJxOAAC6AAAA7QIAAO4CAAB3AAAAeAAAAHkAAADvAgAAjQAAAPACAADxAgAAfgAAAPICAADAAAAAkgAAAJMAAACDAAAA8wIAAPQCAACWAAAA9QIAAJgAAAD2AgAA9wIAAMYAAAD4AgAA+QIAAPoCAAD7AgAA/AIAAP0CAAD+AgAA/wIAADEwYnRCb3hTaGFwZQAAAABIaAAAjE4AADxHAABCb3gAAACAPwAAgL8AQc6dAQsGgD8AAIC/AEHunQELkxaAPwAAgL8AAAAAAAAAAAEAAAACAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAEAAAABQAAAAYAAAABAAAAAgAAAAMAAAADAAAABAAAAAUAAAAGAAAABwAAAAUAAAAGAAAABwAAAAcAAAAAAAAAkE8AAAADAAABAwAAAgMAAAMDAAAEAwAABQMAAAYDAAAHAwAAMTRidE9wdGltaXplZEJ2aAAAAABIaAAAfE8AAHRZAAAAAAAAFFAAAJsCAAAIAwAACQMAAFpOMTRidE9wdGltaXplZEJ2aDVidWlsZEVQMjNidFN0cmlkaW5nTWVzaEludGVyZmFjZWJSSzlidFZlY3RvcjNTNF9FMjlRdWFudGl6ZWROb2RlVHJpYW5nbGVDYWxsYmFjawBIaAAAsE8AANRKAAAAAAAAkFAAAJsCAAAKAwAACwMAAFpOMTRidE9wdGltaXplZEJ2aDVidWlsZEVQMjNidFN0cmlkaW5nTWVzaEludGVyZmFjZWJSSzlidFZlY3RvcjNTNF9FMjBOb2RlVHJpYW5nbGVDYWxsYmFjawAASGgAADRQAADUSgAAAAAAAAhRAAAMAwAADQMAAA4DAAB3AAAAeAAAAHkAAAAPAwAAEAMAABEDAAASAwAAfgAAAH8AAACAAAAAgQAAAIIAAACDAAAAEwMAABQDAAAyNWJ0SGVpZ2h0ZmllbGRUZXJyYWluU2hhcGUASGgAAOxQAAD4TQAASEVJR0hURklFTEQAAAAAAGxSAACJAAAAFQMAABYDAAB3AAAAeAAAAHkAAAAXAwAAjQAAABgDAAAZAwAAGgMAABsDAADAAAAAHAMAAB0DAACDAAAAHgMAAB8DAACWAAAAIAMAAJgAAACZAAAAmgAAACEDAAAAAAAAjFIAAIkAAAAiAwAAFgMAAHcAAAB4AAAAeQAAABcDAACNAAAAGAMAACMDAAAaAwAAGwMAAMAAAAAcAwAAHQMAAIMAAAAeAwAAJAMAAJYAAAAlAwAAmAAAAJkAAACaAAAAJgMAAAAAAACsUgAAiQAAACcDAAAWAwAAdwAAAHgAAAB5AAAAFwMAAI0AAAAYAwAAKAMAABoDAAAbAwAAwAAAABwDAAAdAwAAgwAAAB4DAAApAwAAlgAAACoDAACYAAAAmQAAAJoAAAArAwAAMTVidEN5bGluZGVyU2hhcGUAAABIaAAAWFIAAHxJAAAxNmJ0Q3lsaW5kZXJTaGFwZVgAAEhoAAB4UgAAbFIAADE2YnRDeWxpbmRlclNoYXBlWgAASGgAAJhSAABsUgAAQ3lsaW5kZXJZAGJ0Q3lsaW5kZXJTaGFwZURhdGEAQ3lsaW5kZXJYAEN5bGluZGVyWgBidEludEluZGV4RGF0YQBidFNob3J0SW50SW5kZXhUcmlwbGV0RGF0YQBidENoYXJJbmRleFRyaXBsZXREYXRhAGJ0VmVjdG9yM0Zsb2F0RGF0YQBidFZlY3RvcjNEb3VibGVEYXRhAGJ0TWVzaFBhcnREYXRhAGJ0U3RyaWRpbmdNZXNoSW50ZXJmYWNlRGF0YQAyM2J0U3RyaWRpbmdNZXNoSW50ZXJmYWNlAAAgaAAAfVMAAAAAAAAEVAAALAMAAC0DAAAuAwAALwMAADADAAAxAwAAMgMAADMDAAA0AwAANQMAADYDAAA3AwAAOAMAADkDAAA6AwAAMjZidFRyaWFuZ2xlSW5kZXhWZXJ0ZXhBcnJheQAAAABIaAAA5FMAAJhTAAAAAAAAaFQAADsDAAA8AwAALgMAAC8DAAAwAwAAMQMAADIDAAAzAwAAPQMAAD4DAAA2AwAANwMAADgDAAA5AwAAOgMAADE0YnRUcmlhbmdsZU1lc2gAAAAASGgAAFRUAAAEVAAAAAAAAAxVAAA/AwAAQAMAAEEDAABCAwAAQwMAAEQDAABFAwAARgMAAEcDAABIAwAASQMAAEoDAABLAwAATAMAADEyYnRBeGlzU3dlZXAzADIwYnRBeGlzU3dlZXAzSW50ZXJuYWxJdEUAMjFidEJyb2FkcGhhc2VJbnRlcmZhY2UAAAAAIGgAAN1UAABIaAAAw1QAAPhUAABIaAAAtFQAAABVAAAAAAAAAFUAAD8DAABNAwAAQQMAAEIDAABDAwAARAMAAEUDAABGAwAARwMAAEgDAABJAwAASgMAAEsDAABMAwAAAAAAANxVAABOAwAATwMAAFADAABRAwAAUgMAAFMDAABUAwAAVQMAAFYDAABXAwAAWAMAAFkDAABaAwAAWwMAAFwDAABdAwAAXgMAADE1YnROdWxsUGFpckNhY2hlADIyYnRPdmVybGFwcGluZ1BhaXJDYWNoZQAASGgAALZVAAA0BgAASGgAAKRVAADQVQAAAAAAAFRWAABfAwAAYAMAAGEDAABiAwAAYwMAAGQDAABlAwAAZgMAAGcDAABoAwAAaQMAAGoDAABrAwAAbAMAAG0DAABuAwAAbwMAADI4YnRIYXNoZWRPdmVybGFwcGluZ1BhaXJDYWNoZQAASGgAADRWAADQVQAAAAAAAORWAACgAQAAcAMAAHEDAABaTjI4YnRIYXNoZWRPdmVybGFwcGluZ1BhaXJDYWNoZTE5Y2xlYW5Qcm94eUZyb21QYWlyc0VQMTdidEJyb2FkcGhhc2VQcm94eVAxMmJ0RGlzcGF0Y2hlckUxN0NsZWFuUGFpckNhbGxiYWNrAAAASGgAAHRWAAAEJwAAAAAAAIhXAACgAQAAcgMAAHMDAABaTjI4YnRIYXNoZWRPdmVybGFwcGluZ1BhaXJDYWNoZTM3cmVtb3ZlT3ZlcmxhcHBpbmdQYWlyc0NvbnRhaW5pbmdQcm94eUVQMTdidEJyb2FkcGhhc2VQcm94eVAxMmJ0RGlzcGF0Y2hlckUxOFJlbW92ZVBhaXJDYWxsYmFjawAAAABIaAAABFcAAAQnAAAAAAAA6FcAAHQDAAB1AwAAdgMAAHcDAAB4AwAAeQMAAHoDAAB7AwAAfAMAAH0DAAB+AwAAfwMAAIADAACBAwAAMTZidERidnRCcm9hZHBoYXNlAABIaAAA1FcAAPhUAAAAAAAAMFgAAGcAAACCAwAAgwMAAIQDAABrAAAAbAAAAG0AAAAxOGJ0RGJ2dFRyZWVDb2xsaWRlcgAAAABIaAAAGFgAAJwTAAAAAAAAeFgAAGcAAACFAwAAaQAAAIYDAABrAAAAbAAAAG0AAAAxOUJyb2FkcGhhc2VSYXlUZXN0ZXIAAABIaAAAYFgAAJwTAAAAAAAAwFgAAGcAAACHAwAAaQAAAIgDAABrAAAAbAAAAG0AAAAyMEJyb2FkcGhhc2VBYWJiVGVzdGVyAABIaAAAqFgAAJwTAAAxMmJ0RGlzcGF0Y2hlcgAAIGgAAMxYAAAAAAAAdFkAAIkDAACKAwAAAgMAAAMDAAAEAwAABQMAAAYDAABidE9wdGltaXplZEJ2aE5vZGVEYXRhAGJ0UXVhbnRpemVkQnZoTm9kZURhdGEAYnRCdmhTdWJ0cmVlSW5mb0RhdGEAYnRRdWFudGl6ZWRCdmhGbG9hdERhdGEAMTRidFF1YW50aXplZEJ2aAAgaAAAY1kAAAAAAADMFgAAsAEAAIsDAAAHAAAABwAAAAcAAABSb290AAAAABe30TgQAAAALSsgICAwWDB4AChudWxsKQAAAAAAAAAAEQAKABEREQAAAAAFAAAAAAAACQAAAAALAAAAAAAAAAARAA8KERERAwoHAAETCQsLAAAJBgsAAAsABhEAAAAREREAQZG0AQshCwAAAAAAAAAAEQAKChEREQAKAAACAAkLAAAACQALAAALAEHLtAELAQwAQde0AQsVDAAAAAAMAAAAAAkMAAAAAAAMAAAMAEGFtQELAQ4AQZG1AQsVDQAAAAQNAAAAAAkOAAAAAAAOAAAOAEG/tQELARAAQcu1AQseDwAAAAAPAAAAAAkQAAAAAAAQAAAQAAASAAAAEhISAEGCtgELDhIAAAASEhIAAAAAAAAJAEGztgELAQsAQb+2AQsVCgAAAAAKAAAAAAkLAAAAAAALAAALAEHttgELAQwAQfm2AQtLDAAAAAAMAAAAAAkMAAAAAAAMAAAMAAAwMTIzNDU2Nzg5QUJDREVGLTBYKzBYIDBYLTB4KzB4IDB4AGluZgBJTkYAbmFuAE5BTgAuAEHQtwEL1xUDAAAABAAAAAQAAAAGAAAAg/miAERObgD8KRUA0VcnAN009QBi28AAPJmVAEGQQwBjUf4Au96rALdhxQA6biQA0k1CAEkG4AAJ6i4AHJLRAOsd/gApsRwA6D6nAPU1ggBEuy4AnOmEALQmcABBfl8A1pE5AFODOQCc9DkAi1+EACj5vQD4HzsA3v+XAA+YBQARL+8AClqLAG0fbQDPfjYACcsnAEZPtwCeZj8ALepfALondQDl68cAPXvxAPc5BwCSUooA+2vqAB+xXwAIXY0AMANWAHv8RgDwq2sAILzPADb0mgDjqR0AXmGRAAgb5gCFmWUAoBRfAI1AaACA2P8AJ3NNAAYGMQDKVhUAyahzAHviYABrjMAAGcRHAM1nwwAJ6NwAWYMqAIt2xACmHJYARK/dABlX0QClPgUABQf/ADN+PwDCMugAmE/eALt9MgAmPcMAHmvvAJ/4XgA1HzoAf/LKAPGHHQB8kCEAaiR8ANVu+gAwLXcAFTtDALUUxgDDGZ0ArcTCACxNQQAMAF0Ahn1GAONxLQCbxpoAM2IAALTSfAC0p5cAN1XVANc+9gCjEBgATXb8AGSdKgBw16sAY3z4AHqwVwAXFecAwElWADvW2QCnhDgAJCPLANaKdwBaVCMAAB+5APEKGwAZzt8AnzH/AGYeagCZV2EArPtHAH5/2AAiZbcAMuiJAOa/YADvxM0AbDYJAF0/1AAW3tcAWDveAN6bkgDSIigAKIboAOJYTQDGyjIACOMWAOB9ywAXwFAA8x2nABjgWwAuEzQAgxJiAINIAQD1jlsArbB/AB7p8gBISkMAEGfTAKrd2ACuX0IAamHOAAoopADTmbQABqbyAFx3fwCjwoMAYTyIAIpzeACvjFoAb9e9AC2mYwD0v8sAjYHvACbBZwBVykUAytk2ACio0gDCYY0AEsl3AAQmFAASRpsAxFnEAMjFRABNspEAABfzANRDrQApSeUA/dUQAAC+/AAelMwAcM7uABM+9QDs8YAAs+fDAMf4KACTBZQAwXE+AC4JswALRfMAiBKcAKsgewAutZ8AR5LCAHsyLwAMVW0AcqeQAGvnHwAxy5YAeRZKAEF54gD034kA6JSXAOLmhACZMZcAiO1rAF9fNgC7/Q4ASJq0AGekbABxckIAjV0yAJ8VuAC85QkAjTElAPd0OQAwBRwADQwBAEsIaAAs7lgAR6qQAHTnAgC91iQA932mAG5IcgCfFu8AjpSmALSR9gDRU1EAzwryACCYMwD1S34AsmNoAN0+XwBAXQMAhYl/AFVSKQA3ZMAAbdgQADJIMgBbTHUATnHUAEVUbgALCcEAKvVpABRm1QAnB50AXQRQALQ72wDqdsUAh/kXAElrfQAdJ7oAlmkpAMbMrACtFFQAkOJqAIjZiQAsclAABKS+AHcHlADzMHAAAPwnAOpxqABmwkkAZOA9AJfdgwCjP5cAQ5T9AA2GjAAxQd4AkjmdAN1wjAAXt+cACN87ABU3KwBcgKAAWoCTABARkgAP6NgAbICvANv/SwA4kA8AWRh2AGKlFQBhy7sAx4m5ABBAvQDS8gQASXUnAOu29gDbIrsAChSqAIkmLwBkg3YACTszAA6UGgBROqoAHaPCAK/trgBcJhIAbcJNAC16nADAVpcAAz+DAAnw9gArQIwAbTGZADm0BwAMIBUA2MNbAPWSxADGrUsATsqlAKc3zQDmqTYAq5KUAN1CaAAZY94AdozvAGiLUgD82zcArqGrAN8VMQAArqEADPvaAGRNZgDtBbcAKWUwAFdWvwBH/zoAavm5AHW+8wAok98Aq4AwAGaM9gAEyxUA+iIGANnkHQA9s6QAVxuPADbNCQBOQukAE76kADMjtQDwqhoAT2WoANLBpQALPw8AW3jNACP5dgB7iwQAiRdyAMamUwBvbuIA7+sAAJtKWADE2rcAqma6AHbPzwDRAh0AsfEtAIyZwQDDrXcAhkjaAPddoADGgPQArPAvAN3smgA/XLwA0N5tAJDHHwAq27YAoyU6AACvmgCtU5MAtlcEACkttABLgH4A2genAHaqDgB7WaEAFhIqANy3LQD65f0Aidv+AIm+/QDkdmwABqn8AD6AcACFbhUA/Yf/ACg+BwBhZzMAKhiGAE296gCz568Aj21uAJVnOQAxv1sAhNdIADDfFgDHLUMAJWE1AMlwzgAwy7gAv2z9AKQAogAFbOQAWt2gACFvRwBiEtIAuVyEAHBhSQBrVuAAmVIBAFBVNwAe1bcAM/HEABNuXwBdMOQAhS6pAB2ywwChMjYACLekAOqx1AAW9yEAj2nkACf/dwAMA4AAjUAtAE/NoAAgpZkAs6LTAC9dCgC0+UIAEdrLAH2+0ACb28EAqxe9AMqigQAIalwALlUXACcAVQB/FPAA4QeGABQLZACWQY0Ah77eANr9KgBrJbYAe4k0AAXz/gC5v54AaGpPAEoqqABPxFoALfi8ANdamAD0x5UADU2NACA6pgCkV18AFD+xAIA4lQDMIAEAcd2GAMnetgC/YPUATWURAAEHawCMsKwAssDQAFFVSAAe+w4AlXLDAKMGOwDAQDUABtx7AOBFzABOKfoA1srIAOjzQQB8ZN4Am2TYANm+MQCkl8MAd1jUAGnjxQDw2hMAujo8AEYYRgBVdV8A0r31AG6SxgCsLl0ADkTtABw+QgBhxIcAKf3pAOfW8wAifMoAb5E1AAjgxQD/140AbmriALD9xgCTCMEAfF10AGutsgDNbp0APnJ7AMYRagD3z6kAKXPfALXJugC3AFEA4rINAHS6JADlfWAAdNiKAA0VLACBGAwAfmaUAAEpFgCfenYA/f2+AFZF7wDZfjYA7NkTAIu6uQDEl/wAMagnAPFuwwCUxTYA2KhWALSotQDPzA4AEoktAG9XNAAsVokAmc7jANYguQBrXqoAPiqcABFfzAD9C0oA4fT7AI47bQDihiwA6dSEAPy0qQDv7tEALjXJAC85YQA4IUQAG9nIAIH8CgD7SmoALxzYAFO0hABOmYwAVCLMACpV3ADAxtYACxmWABpwuABplWQAJlpgAD9S7gB/EQ8A9LURAPzL9QA0vC0ANLzuAOhdzADdXmAAZ46bAJIz7wDJF7gAYVibAOFXvABRg8YA2D4QAN1xSAAtHN0ArxihACEsRgBZ89cA2XqYAJ5UwABPhvoAVgb8AOV5rgCJIjYAOK0iAGeT3ABV6KoAgiY4AMrnmwBRDaQAmTOxAKnXDgBpBUgAZbLwAH+IpwCITJcA+dE2ACGSswB7gkoAmM8hAECf3ADcR1UA4XQ6AGfrQgD+nd8AXtRfAHtnpAC6rHoAVfaiACuIIwBBulUAWW4IACEqhgA5R4MAiePmAOWe1ABJ+0AA/1bpABwPygDFWYoAlPorANPBxQAPxc8A21quAEfFhgCFQ2IAIYY7ACx5lAAQYYcAKkx7AIAsGgBDvxIAiCaQAHg8iQCoxOQA5dt7AMQ6wgAm9OoA92eKAA2SvwBloysAPZOxAL18CwCkUdwAJ91jAGnh3QCalBkAqCmVAGjOKAAJ7bQARJ8gAE6YygBwgmMAfnwjAA+5MgCn9Y4AFFbnACHxCAC1nSoAb35NAKUZUQC1+asAgt/WAJbdYQAWNgIAxDqfAIOioQBy7W0AOY16AIK4qQBrMlwARidbAAA07QDSAHcA/PRVAAFZTQDgcYAAQbPNAQvDBED7Ifk/AAAAAC1EdD4AAACAmEb4PAAAAGBRzHg7AAAAgIMb8DkAAABAICV6OAAAAIAiguM2AAAAAB3zaTU4Y+0+2g9JP16Yez/aD8k/aTesMWghIjO0DxQzaCGiM9sPST/bD0m/5MsWQOTLFsAAAAAAAAAAgNsPSUDbD0nAAACAPwAAwD8AAAAA3M/RNQAAAAAAwBU/CGoAAF9fY3hhX2d1YXJkX2FjcXVpcmUgZGV0ZWN0ZWQgcmVjdXJzaXZlIGluaXRpYWxpemF0aW9uAFB1cmUgdmlydHVhbCBmdW5jdGlvbiBjYWxsZWQhAFN0OXR5cGVfaW5mbwAAAAAgaAAAoGcAAE4xMF9fY3h4YWJpdjExNl9fc2hpbV90eXBlX2luZm9FAAAAAEhoAAC4ZwAAsGcAAE4xMF9fY3h4YWJpdjExN19fY2xhc3NfdHlwZV9pbmZvRQAAAEhoAADoZwAA3GcAAAAAAAAMaAAAlwMAAJgDAACZAwAAmgMAAJsDAACcAwAAnQMAAJ4DAAAAAAAAkGgAAJcDAACfAwAAmQMAAJoDAACbAwAAoAMAAKEDAACiAwAATjEwX19jeHhhYml2MTIwX19zaV9jbGFzc190eXBlX2luZm9FAAAAAEhoAABoaAAADGgAAAAAAADsaAAAlwMAAKMDAACZAwAAmgMAAJsDAACkAwAApQMAAKYDAABOMTBfX2N4eGFiaXYxMjFfX3ZtaV9jbGFzc190eXBlX2luZm9FAAAASGgAAMRoAAAMaABB+9EBCyVAAACAPwrXozwBAQAAvHsAAI4DAACPAwAAkAMAAJEDAAD/////AEHQ0wELAiR8AEGI1AELAQUAQZTUAQsClAMAQazUAQsKlQMAAJYDAABEfABBxNQBCwECAEHT1AELBf//////", "var $jscomp=$jscomp||{};$jscomp.scope={};$jscomp.arrayIteratorImpl=function(k){var n=0;return function(){return n<k.length?{done:!1,value:k[n++]}:{done:!0}}};$jscomp.arrayIterator=function(k){return{next:$jscomp.arrayIteratorImpl(k)}};$jscomp.makeIterator=function(k){var n="undefined"!=typeof Symbol&&Symbol.iterator&&k[Symbol.iterator];return n?n.call(k):$jscomp.arrayIterator(k)};$jscomp.ASSUME_ES5=!1;$jscomp.ASSUME_NO_NATIVE_MAP=!1;$jscomp.ASSUME_NO_NATIVE_SET=!1;$jscomp.SIMPLE_FROUND_POLYFILL=!1;
$jscomp.ISOLATE_POLYFILLS=!1;$jscomp.FORCE_POLYFILL_PROMISE=!1;$jscomp.FORCE_POLYFILL_PROMISE_WHEN_NO_UNHANDLED_REJECTION=!1;$jscomp.getGlobal=function(k){k=["object"==typeof globalThis&&globalThis,k,"object"==typeof window&&window,"object"==typeof self&&self,"object"==typeof global&&global];for(var n=0;n<k.length;++n){var l=k[n];if(l&&l.Math==Math)return l}throw Error("Cannot find global object");};$jscomp.global=$jscomp.getGlobal(this);
$jscomp.defineProperty=$jscomp.ASSUME_ES5||"function"==typeof Object.defineProperties?Object.defineProperty:function(k,n,l){if(k==Array.prototype||k==Object.prototype)return k;k[n]=l.value;return k};$jscomp.IS_SYMBOL_NATIVE="function"===typeof Symbol&&"symbol"===typeof Symbol("x");$jscomp.TRUST_ES6_POLYFILLS=!$jscomp.ISOLATE_POLYFILLS||$jscomp.IS_SYMBOL_NATIVE;$jscomp.polyfills={};$jscomp.propertyToPolyfillSymbol={};$jscomp.POLYFILL_PREFIX="$jscp$";
var $jscomp$lookupPolyfilledValue=function(k,n){var l=$jscomp.propertyToPolyfillSymbol[n];if(null==l)return k[n];l=k[l];return void 0!==l?l:k[n]};$jscomp.polyfill=function(k,n,l,p){n&&($jscomp.ISOLATE_POLYFILLS?$jscomp.polyfillIsolated(k,n,l,p):$jscomp.polyfillUnisolated(k,n,l,p))};
$jscomp.polyfillUnisolated=function(k,n,l,p){l=$jscomp.global;k=k.split(".");for(p=0;p<k.length-1;p++){var h=k[p];if(!(h in l))return;l=l[h]}k=k[k.length-1];p=l[k];n=n(p);n!=p&&null!=n&&$jscomp.defineProperty(l,k,{configurable:!0,writable:!0,value:n})};
$jscomp.polyfillIsolated=function(k,n,l,p){var h=k.split(".");k=1===h.length;p=h[0];p=!k&&p in $jscomp.polyfills?$jscomp.polyfills:$jscomp.global;for(var A=0;A<h.length-1;A++){var f=h[A];if(!(f in p))return;p=p[f]}h=h[h.length-1];l=$jscomp.IS_SYMBOL_NATIVE&&"es6"===l?p[h]:null;n=n(l);null!=n&&(k?$jscomp.defineProperty($jscomp.polyfills,h,{configurable:!0,writable:!0,value:n}):n!==l&&(void 0===$jscomp.propertyToPolyfillSymbol[h]&&(l=1E9*Math.random()>>>0,$jscomp.propertyToPolyfillSymbol[h]=$jscomp.IS_SYMBOL_NATIVE?
$jscomp.global.Symbol(h):$jscomp.POLYFILL_PREFIX+l+"$"+h),$jscomp.defineProperty(p,$jscomp.propertyToPolyfillSymbol[h],{configurable:!0,writable:!0,value:n})))};
$jscomp.polyfill("Promise",function(k){function n(){this.batch_=null}function l(f){return f instanceof h?f:new h(function(q,v){q(f)})}if(k&&(!($jscomp.FORCE_POLYFILL_PROMISE||$jscomp.FORCE_POLYFILL_PROMISE_WHEN_NO_UNHANDLED_REJECTION&&"undefined"===typeof $jscomp.global.PromiseRejectionEvent)||!$jscomp.global.Promise||-1===$jscomp.global.Promise.toString().indexOf("[native code]")))return k;n.prototype.asyncExecute=function(f){if(null==this.batch_){this.batch_=[];var q=this;this.asyncExecuteFunction(function(){q.executeBatch_()})}this.batch_.push(f)};
var p=$jscomp.global.setTimeout;n.prototype.asyncExecuteFunction=function(f){p(f,0)};n.prototype.executeBatch_=function(){for(;this.batch_&&this.batch_.length;){var f=this.batch_;this.batch_=[];for(var q=0;q<f.length;++q){var v=f[q];f[q]=null;try{v()}catch(z){this.asyncThrow_(z)}}}this.batch_=null};n.prototype.asyncThrow_=function(f){this.asyncExecuteFunction(function(){throw f;})};var h=function(f){this.state_=0;this.result_=void 0;this.onSettledCallbacks_=[];this.isRejectionHandled_=!1;var q=this.createResolveAndReject_();
try{f(q.resolve,q.reject)}catch(v){q.reject(v)}};h.prototype.createResolveAndReject_=function(){function f(z){return function(O){v||(v=!0,z.call(q,O))}}var q=this,v=!1;return{resolve:f(this.resolveTo_),reject:f(this.reject_)}};h.prototype.resolveTo_=function(f){if(f===this)this.reject_(new TypeError("A Promise cannot resolve to itself"));else if(f instanceof h)this.settleSameAsPromise_(f);else{a:switch(typeof f){case "object":var q=null!=f;break a;case "function":q=!0;break a;default:q=!1}q?this.resolveToNonPromiseObj_(f):
this.fulfill_(f)}};h.prototype.resolveToNonPromiseObj_=function(f){var q=void 0;try{q=f.then}catch(v){this.reject_(v);return}"function"==typeof q?this.settleSameAsThenable_(q,f):this.fulfill_(f)};h.prototype.reject_=function(f){this.settle_(2,f)};h.prototype.fulfill_=function(f){this.settle_(1,f)};h.prototype.settle_=function(f,q){if(0!=this.state_)throw Error("Cannot settle("+f+", "+q+"): Promise already settled in state"+this.state_);this.state_=f;this.result_=q;2===this.state_&&this.scheduleUnhandledRejectionCheck_();
this.executeOnSettledCallbacks_()};h.prototype.scheduleUnhandledRejectionCheck_=function(){var f=this;p(function(){if(f.notifyUnhandledRejection_()){var q=$jscomp.global.console;"undefined"!==typeof q&&q.error(f.result_)}},1)};h.prototype.notifyUnhandledRejection_=function(){if(this.isRejectionHandled_)return!1;var f=$jscomp.global.CustomEvent,q=$jscomp.global.Event,v=$jscomp.global.dispatchEvent;if("undefined"===typeof v)return!0;"function"===typeof f?f=new f("unhandledrejection",{cancelable:!0}):
"function"===typeof q?f=new q("unhandledrejection",{cancelable:!0}):(f=$jscomp.global.document.createEvent("CustomEvent"),f.initCustomEvent("unhandledrejection",!1,!0,f));f.promise=this;f.reason=this.result_;return v(f)};h.prototype.executeOnSettledCallbacks_=function(){if(null!=this.onSettledCallbacks_){for(var f=0;f<this.onSettledCallbacks_.length;++f)A.asyncExecute(this.onSettledCallbacks_[f]);this.onSettledCallbacks_=null}};var A=new n;h.prototype.settleSameAsPromise_=function(f){var q=this.createResolveAndReject_();
f.callWhenSettled_(q.resolve,q.reject)};h.prototype.settleSameAsThenable_=function(f,q){var v=this.createResolveAndReject_();try{f.call(q,v.resolve,v.reject)}catch(z){v.reject(z)}};h.prototype.then=function(f,q){function v(t,x){return"function"==typeof t?function(D){try{z(t(D))}catch(R){O(R)}}:x}var z,O,ba=new h(function(t,x){z=t;O=x});this.callWhenSettled_(v(f,z),v(q,O));return ba};h.prototype.catch=function(f){return this.then(void 0,f)};h.prototype.callWhenSettled_=function(f,q){function v(){switch(z.state_){case 1:f(z.result_);
break;case 2:q(z.result_);break;default:throw Error("Unexpected state: "+z.state_);}}var z=this;null==this.onSettledCallbacks_?A.asyncExecute(v):this.onSettledCallbacks_.push(v);this.isRejectionHandled_=!0};h.resolve=l;h.reject=function(f){return new h(function(q,v){v(f)})};h.race=function(f){return new h(function(q,v){for(var z=$jscomp.makeIterator(f),O=z.next();!O.done;O=z.next())l(O.value).callWhenSettled_(q,v)})};h.all=function(f){var q=$jscomp.makeIterator(f),v=q.next();return v.done?l([]):new h(function(z,
O){function ba(D){return function(R){t[D]=R;x--;0==x&&z(t)}}var t=[],x=0;do t.push(void 0),x++,l(v.value).callWhenSettled_(ba(t.length-1),O),v=q.next();while(!v.done)})};return h},"es6","es3");$jscomp.owns=function(k,n){return Object.prototype.hasOwnProperty.call(k,n)};$jscomp.assign=$jscomp.TRUST_ES6_POLYFILLS&&"function"==typeof Object.assign?Object.assign:function(k,n){for(var l=1;l<arguments.length;l++){var p=arguments[l];if(p)for(var h in p)$jscomp.owns(p,h)&&(k[h]=p[h])}return k};
$jscomp.polyfill("Object.assign",function(k){return k||$jscomp.assign},"es6","es3");$jscomp.checkStringArgs=function(k,n,l){if(null==k)throw new TypeError("The 'this' value for String.prototype."+l+" must not be null or undefined");if(n instanceof RegExp)throw new TypeError("First argument to String.prototype."+l+" must not be a regular expression");return k+""};
$jscomp.polyfill("String.prototype.startsWith",function(k){return k?k:function(n,l){var p=$jscomp.checkStringArgs(this,n,"startsWith");n+="";var h=p.length,A=n.length;l=Math.max(0,Math.min(l|0,p.length));for(var f=0;f<A&&l<h;)if(p[l++]!=n[f++])return!1;return f>=A}},"es6","es3");
$jscomp.polyfill("Array.prototype.copyWithin",function(k){function n(l){l=Number(l);return Infinity===l||-Infinity===l?l:l|0}return k?k:function(l,p,h){var A=this.length;l=n(l);p=n(p);h=void 0===h?A:n(h);l=0>l?Math.max(A+l,0):Math.min(l,A);p=0>p?Math.max(A+p,0):Math.min(p,A);h=0>h?Math.max(A+h,0):Math.min(h,A);if(l<p)for(;p<h;)p in this?this[l++]=this[p++]:(delete this[l++],p++);else for(h=Math.min(h,A+p-l),l+=h-p;h>p;)--h in this?this[--l]=this[h]:delete this[--l];return this}},"es6","es3");
$jscomp.typedArrayCopyWithin=function(k){return k?k:Array.prototype.copyWithin};$jscomp.polyfill("Int8Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");$jscomp.polyfill("Uint8Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");$jscomp.polyfill("Uint8ClampedArray.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");$jscomp.polyfill("Int16Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");
$jscomp.polyfill("Uint16Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");$jscomp.polyfill("Int32Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");$jscomp.polyfill("Uint32Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");$jscomp.polyfill("Float32Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");$jscomp.polyfill("Float64Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");
var DracoDecoderModule=function(){var k="undefined"!==typeof document&&document.currentScript?document.currentScript.src:void 0;"undefined"!==typeof __filename&&(k=k||__filename);return function(n){function l(e){return a.locateFile?a.locateFile(e,U):U+e}function p(e,b,c){var d=b+c;for(c=b;e[c]&&!(c>=d);)++c;if(16<c-b&&e.buffer&&va)return va.decode(e.subarray(b,c));for(d="";b<c;){var g=e[b++];if(g&128){var u=e[b++]&63;if(192==(g&224))d+=String.fromCharCode((g&31)<<6|u);else{var X=e[b++]&63;g=224==
(g&240)?(g&15)<<12|u<<6|X:(g&7)<<18|u<<12|X<<6|e[b++]&63;65536>g?d+=String.fromCharCode(g):(g-=65536,d+=String.fromCharCode(55296|g>>10,56320|g&1023))}}else d+=String.fromCharCode(g)}return d}function h(e,b){return e?p(ea,e,b):""}function A(){var e=ja.buffer;a.HEAP8=Y=new Int8Array(e);a.HEAP16=new Int16Array(e);a.HEAP32=ca=new Int32Array(e);a.HEAPU8=ea=new Uint8Array(e);a.HEAPU16=new Uint16Array(e);a.HEAPU32=V=new Uint32Array(e);a.HEAPF32=new Float32Array(e);a.HEAPF64=new Float64Array(e)}function f(e){if(a.onAbort)a.onAbort(e);
e="Aborted("+e+")";da(e);wa=!0;e=new WebAssembly.RuntimeError(e+". Build with -sASSERTIONS for more info.");ka(e);throw e;}function q(e){try{if(e==P&&fa)return new Uint8Array(fa);if(ma)return ma(e);throw"both async and sync fetching of the wasm failed";}catch(b){f(b)}}function v(){if(!fa&&(xa||ha)){if("function"==typeof fetch&&!P.startsWith("file://"))return fetch(P,{credentials:"same-origin"}).then(function(e){if(!e.ok)throw"failed to load wasm binary file at '"+P+"'";return e.arrayBuffer()}).catch(function(){return q(P)});
if(na)return new Promise(function(e,b){na(P,function(c){e(new Uint8Array(c))},b)})}return Promise.resolve().then(function(){return q(P)})}function z(e){for(;0<e.length;)e.shift()(a)}function O(e){this.excPtr=e;this.ptr=e-24;this.set_type=function(b){V[this.ptr+4>>2]=b};this.get_type=function(){return V[this.ptr+4>>2]};this.set_destructor=function(b){V[this.ptr+8>>2]=b};this.get_destructor=function(){return V[this.ptr+8>>2]};this.set_refcount=function(b){ca[this.ptr>>2]=b};this.set_caught=function(b){Y[this.ptr+
12>>0]=b?1:0};this.get_caught=function(){return 0!=Y[this.ptr+12>>0]};this.set_rethrown=function(b){Y[this.ptr+13>>0]=b?1:0};this.get_rethrown=function(){return 0!=Y[this.ptr+13>>0]};this.init=function(b,c){this.set_adjusted_ptr(0);this.set_type(b);this.set_destructor(c);this.set_refcount(0);this.set_caught(!1);this.set_rethrown(!1)};this.add_ref=function(){ca[this.ptr>>2]+=1};this.release_ref=function(){var b=ca[this.ptr>>2];ca[this.ptr>>2]=b-1;return 1===b};this.set_adjusted_ptr=function(b){V[this.ptr+
16>>2]=b};this.get_adjusted_ptr=function(){return V[this.ptr+16>>2]};this.get_exception_ptr=function(){if(ya(this.get_type()))return V[this.excPtr>>2];var b=this.get_adjusted_ptr();return 0!==b?b:this.excPtr}}function ba(){function e(){if(!la&&(la=!0,a.calledRun=!0,!wa)){za=!0;z(oa);Aa(a);if(a.onRuntimeInitialized)a.onRuntimeInitialized();if(a.postRun)for("function"==typeof a.postRun&&(a.postRun=[a.postRun]);a.postRun.length;)Ba.unshift(a.postRun.shift());z(Ba)}}if(!(0<aa)){if(a.preRun)for("function"==
typeof a.preRun&&(a.preRun=[a.preRun]);a.preRun.length;)Ca.unshift(a.preRun.shift());z(Ca);0<aa||(a.setStatus?(a.setStatus("Running..."),setTimeout(function(){setTimeout(function(){a.setStatus("")},1);e()},1)):e())}}function t(){}function x(e){return(e||t).__cache__}function D(e,b){var c=x(b),d=c[e];if(d)return d;d=Object.create((b||t).prototype);d.ptr=e;return c[e]=d}function R(e){if("string"===typeof e){for(var b=0,c=0;c<e.length;++c){var d=e.charCodeAt(c);127>=d?b++:2047>=d?b+=2:55296<=d&&57343>=
d?(b+=4,++c):b+=3}b=Array(b+1);c=0;d=b.length;if(0<d){d=c+d-1;for(var g=0;g<e.length;++g){var u=e.charCodeAt(g);if(55296<=u&&57343>=u){var X=e.charCodeAt(++g);u=65536+((u&1023)<<10)|X&1023}if(127>=u){if(c>=d)break;b[c++]=u}else{if(2047>=u){if(c+1>=d)break;b[c++]=192|u>>6}else{if(65535>=u){if(c+2>=d)break;b[c++]=224|u>>12}else{if(c+3>=d)break;b[c++]=240|u>>18;b[c++]=128|u>>12&63}b[c++]=128|u>>6&63}b[c++]=128|u&63}}b[c]=0}e=r.alloc(b,Y);r.copy(b,Y,e);return e}return e}function pa(e){if("object"===typeof e){var b=
r.alloc(e,Y);r.copy(e,Y,b);return b}return e}function Z(){throw"cannot construct a VoidPtr, no constructor in IDL";}function S(){this.ptr=Da();x(S)[this.ptr]=this}function Q(){this.ptr=Ea();x(Q)[this.ptr]=this}function W(){this.ptr=Fa();x(W)[this.ptr]=this}function w(){this.ptr=Ga();x(w)[this.ptr]=this}function C(){this.ptr=Ha();x(C)[this.ptr]=this}function F(){this.ptr=Ia();x(F)[this.ptr]=this}function G(){this.ptr=Ja();x(G)[this.ptr]=this}function E(){this.ptr=Ka();x(E)[this.ptr]=this}function T(){this.ptr=
La();x(T)[this.ptr]=this}function B(){throw"cannot construct a Status, no constructor in IDL";}function H(){this.ptr=Ma();x(H)[this.ptr]=this}function I(){this.ptr=Na();x(I)[this.ptr]=this}function J(){this.ptr=Oa();x(J)[this.ptr]=this}function K(){this.ptr=Pa();x(K)[this.ptr]=this}function L(){this.ptr=Qa();x(L)[this.ptr]=this}function M(){this.ptr=Ra();x(M)[this.ptr]=this}function N(){this.ptr=Sa();x(N)[this.ptr]=this}function y(){this.ptr=Ta();x(y)[this.ptr]=this}function m(){this.ptr=Ua();x(m)[this.ptr]=
this}n=void 0===n?{}:n;var a="undefined"!=typeof n?n:{},Aa,ka;a.ready=new Promise(function(e,b){Aa=e;ka=b});var Va=!1,Wa=!1;a.onRuntimeInitialized=function(){Va=!0;if(Wa&&"function"===typeof a.onModuleLoaded)a.onModuleLoaded(a)};a.onModuleParsed=function(){Wa=!0;if(Va&&"function"===typeof a.onModuleLoaded)a.onModuleLoaded(a)};a.isVersionSupported=function(e){if("string"!==typeof e)return!1;e=e.split(".");return 2>e.length||3<e.length?!1:1==e[0]&&0<=e[1]&&5>=e[1]?!0:0!=e[0]||10<e[1]?!1:!0};var Xa=
Object.assign({},a),xa="object"==typeof window,ha="function"==typeof importScripts,Ya="object"==typeof process&&"object"==typeof process.versions&&"string"==typeof process.versions.node,U="";if(Ya){var Za=require("fs"),qa=require("path");U=ha?qa.dirname(U)+"/":__dirname+"/";var $a=function(e,b){e=e.startsWith("file://")?new URL(e):qa.normalize(e);return Za.readFileSync(e,b?void 0:"utf8")};var ma=function(e){e=$a(e,!0);e.buffer||(e=new Uint8Array(e));return e};var na=function(e,b,c){e=e.startsWith("file://")?
new URL(e):qa.normalize(e);Za.readFile(e,function(d,g){d?c(d):b(g.buffer)})};1<process.argv.length&&process.argv[1].replace(/\\/g,"/");process.argv.slice(2);a.inspect=function(){return"[Emscripten Module object]"}}else if(xa||ha)ha?U=self.location.href:"undefined"!=typeof document&&document.currentScript&&(U=document.currentScript.src),k&&(U=k),U=0!==U.indexOf("blob:")?U.substr(0,U.replace(/[?#].*/,"").lastIndexOf("/")+1):"",$a=function(e){var b=new XMLHttpRequest;b.open("GET",e,!1);b.send(null);
return b.responseText},ha&&(ma=function(e){var b=new XMLHttpRequest;b.open("GET",e,!1);b.responseType="arraybuffer";b.send(null);return new Uint8Array(b.response)}),na=function(e,b,c){var d=new XMLHttpRequest;d.open("GET",e,!0);d.responseType="arraybuffer";d.onload=function(){200==d.status||0==d.status&&d.response?b(d.response):c()};d.onerror=c;d.send(null)};var ud=a.print||console.log.bind(console),da=a.printErr||console.warn.bind(console);Object.assign(a,Xa);Xa=null;var fa;a.wasmBinary&&(fa=a.wasmBinary);
"object"!=typeof WebAssembly&&f("no native wasm support detected");var ja,wa=!1,va="undefined"!=typeof TextDecoder?new TextDecoder("utf8"):void 0,Y,ea,ca,V,Ca=[],oa=[],Ba=[],za=!1,aa=0,ra=null,ia=null;var P="draco_decoder.wasm";P.startsWith("data:application/octet-stream;base64,")||(P=l(P));var vd=0,wd=[null,[],[]],xd={b:function(e,b,c){(new O(e)).init(b,c);vd++;throw e;},a:function(){f("")},g:function(e,b,c){ea.copyWithin(e,b,b+c)},e:function(e){var b=ea.length;e>>>=0;if(2147483648<e)return!1;for(var c=
1;4>=c;c*=2){var d=b*(1+.2/c);d=Math.min(d,e+100663296);var g=Math;d=Math.max(e,d);g=g.min.call(g,2147483648,d+(65536-d%65536)%65536);a:{d=ja.buffer;try{ja.grow(g-d.byteLength+65535>>>16);A();var u=1;break a}catch(X){}u=void 0}if(u)return!0}return!1},f:function(e){return 52},d:function(e,b,c,d,g){return 70},c:function(e,b,c,d){for(var g=0,u=0;u<c;u++){var X=V[b>>2],ab=V[b+4>>2];b+=8;for(var sa=0;sa<ab;sa++){var ta=ea[X+sa],ua=wd[e];0===ta||10===ta?((1===e?ud:da)(p(ua,0)),ua.length=0):ua.push(ta)}g+=
ab}V[d>>2]=g;return 0}};(function(){function e(g,u){a.asm=g.exports;ja=a.asm.h;A();oa.unshift(a.asm.i);aa--;a.monitorRunDependencies&&a.monitorRunDependencies(aa);0==aa&&(null!==ra&&(clearInterval(ra),ra=null),ia&&(g=ia,ia=null,g()))}function b(g){e(g.instance)}function c(g){return v().then(function(u){return WebAssembly.instantiate(u,d)}).then(function(u){return u}).then(g,function(u){da("failed to asynchronously prepare wasm: "+u);f(u)})}var d={a:xd};aa++;a.monitorRunDependencies&&a.monitorRunDependencies(aa);
if(a.instantiateWasm)try{return a.instantiateWasm(d,e)}catch(g){da("Module.instantiateWasm callback failed with error: "+g),ka(g)}(function(){return fa||"function"!=typeof WebAssembly.instantiateStreaming||P.startsWith("data:application/octet-stream;base64,")||P.startsWith("file://")||Ya||"function"!=typeof fetch?c(b):fetch(P,{credentials:"same-origin"}).then(function(g){return WebAssembly.instantiateStreaming(g,d).then(b,function(u){da("wasm streaming compile failed: "+u);da("falling back to ArrayBuffer instantiation");
return c(b)})})})().catch(ka);return{}})();var bb=a._emscripten_bind_VoidPtr___destroy___0=function(){return(bb=a._emscripten_bind_VoidPtr___destroy___0=a.asm.k).apply(null,arguments)},Da=a._emscripten_bind_DecoderBuffer_DecoderBuffer_0=function(){return(Da=a._emscripten_bind_DecoderBuffer_DecoderBuffer_0=a.asm.l).apply(null,arguments)},cb=a._emscripten_bind_DecoderBuffer_Init_2=function(){return(cb=a._emscripten_bind_DecoderBuffer_Init_2=a.asm.m).apply(null,arguments)},db=a._emscripten_bind_DecoderBuffer___destroy___0=
function(){return(db=a._emscripten_bind_DecoderBuffer___destroy___0=a.asm.n).apply(null,arguments)},Ea=a._emscripten_bind_AttributeTransformData_AttributeTransformData_0=function(){return(Ea=a._emscripten_bind_AttributeTransformData_AttributeTransformData_0=a.asm.o).apply(null,arguments)},eb=a._emscripten_bind_AttributeTransformData_transform_type_0=function(){return(eb=a._emscripten_bind_AttributeTransformData_transform_type_0=a.asm.p).apply(null,arguments)},fb=a._emscripten_bind_AttributeTransformData___destroy___0=
function(){return(fb=a._emscripten_bind_AttributeTransformData___destroy___0=a.asm.q).apply(null,arguments)},Fa=a._emscripten_bind_GeometryAttribute_GeometryAttribute_0=function(){return(Fa=a._emscripten_bind_GeometryAttribute_GeometryAttribute_0=a.asm.r).apply(null,arguments)},gb=a._emscripten_bind_GeometryAttribute___destroy___0=function(){return(gb=a._emscripten_bind_GeometryAttribute___destroy___0=a.asm.s).apply(null,arguments)},Ga=a._emscripten_bind_PointAttribute_PointAttribute_0=function(){return(Ga=
a._emscripten_bind_PointAttribute_PointAttribute_0=a.asm.t).apply(null,arguments)},hb=a._emscripten_bind_PointAttribute_size_0=function(){return(hb=a._emscripten_bind_PointAttribute_size_0=a.asm.u).apply(null,arguments)},ib=a._emscripten_bind_PointAttribute_GetAttributeTransformData_0=function(){return(ib=a._emscripten_bind_PointAttribute_GetAttributeTransformData_0=a.asm.v).apply(null,arguments)},jb=a._emscripten_bind_PointAttribute_attribute_type_0=function(){return(jb=a._emscripten_bind_PointAttribute_attribute_type_0=
a.asm.w).apply(null,arguments)},kb=a._emscripten_bind_PointAttribute_data_type_0=function(){return(kb=a._emscripten_bind_PointAttribute_data_type_0=a.asm.x).apply(null,arguments)},lb=a._emscripten_bind_PointAttribute_num_components_0=function(){return(lb=a._emscripten_bind_PointAttribute_num_components_0=a.asm.y).apply(null,arguments)},mb=a._emscripten_bind_PointAttribute_normalized_0=function(){return(mb=a._emscripten_bind_PointAttribute_normalized_0=a.asm.z).apply(null,arguments)},nb=a._emscripten_bind_PointAttribute_byte_stride_0=
function(){return(nb=a._emscripten_bind_PointAttribute_byte_stride_0=a.asm.A).apply(null,arguments)},ob=a._emscripten_bind_PointAttribute_byte_offset_0=function(){return(ob=a._emscripten_bind_PointAttribute_byte_offset_0=a.asm.B).apply(null,arguments)},pb=a._emscripten_bind_PointAttribute_unique_id_0=function(){return(pb=a._emscripten_bind_PointAttribute_unique_id_0=a.asm.C).apply(null,arguments)},qb=a._emscripten_bind_PointAttribute___destroy___0=function(){return(qb=a._emscripten_bind_PointAttribute___destroy___0=
a.asm.D).apply(null,arguments)},Ha=a._emscripten_bind_AttributeQuantizationTransform_AttributeQuantizationTransform_0=function(){return(Ha=a._emscripten_bind_AttributeQuantizationTransform_AttributeQuantizationTransform_0=a.asm.E).apply(null,arguments)},rb=a._emscripten_bind_AttributeQuantizationTransform_InitFromAttribute_1=function(){return(rb=a._emscripten_bind_AttributeQuantizationTransform_InitFromAttribute_1=a.asm.F).apply(null,arguments)},sb=a._emscripten_bind_AttributeQuantizationTransform_quantization_bits_0=
function(){return(sb=a._emscripten_bind_AttributeQuantizationTransform_quantization_bits_0=a.asm.G).apply(null,arguments)},tb=a._emscripten_bind_AttributeQuantizationTransform_min_value_1=function(){return(tb=a._emscripten_bind_AttributeQuantizationTransform_min_value_1=a.asm.H).apply(null,arguments)},ub=a._emscripten_bind_AttributeQuantizationTransform_range_0=function(){return(ub=a._emscripten_bind_AttributeQuantizationTransform_range_0=a.asm.I).apply(null,arguments)},vb=a._emscripten_bind_AttributeQuantizationTransform___destroy___0=
function(){return(vb=a._emscripten_bind_AttributeQuantizationTransform___destroy___0=a.asm.J).apply(null,arguments)},Ia=a._emscripten_bind_AttributeOctahedronTransform_AttributeOctahedronTransform_0=function(){return(Ia=a._emscripten_bind_AttributeOctahedronTransform_AttributeOctahedronTransform_0=a.asm.K).apply(null,arguments)},wb=a._emscripten_bind_AttributeOctahedronTransform_InitFromAttribute_1=function(){return(wb=a._emscripten_bind_AttributeOctahedronTransform_InitFromAttribute_1=a.asm.L).apply(null,
arguments)},xb=a._emscripten_bind_AttributeOctahedronTransform_quantization_bits_0=function(){return(xb=a._emscripten_bind_AttributeOctahedronTransform_quantization_bits_0=a.asm.M).apply(null,arguments)},yb=a._emscripten_bind_AttributeOctahedronTransform___destroy___0=function(){return(yb=a._emscripten_bind_AttributeOctahedronTransform___destroy___0=a.asm.N).apply(null,arguments)},Ja=a._emscripten_bind_PointCloud_PointCloud_0=function(){return(Ja=a._emscripten_bind_PointCloud_PointCloud_0=a.asm.O).apply(null,
arguments)},zb=a._emscripten_bind_PointCloud_num_attributes_0=function(){return(zb=a._emscripten_bind_PointCloud_num_attributes_0=a.asm.P).apply(null,arguments)},Ab=a._emscripten_bind_PointCloud_num_points_0=function(){return(Ab=a._emscripten_bind_PointCloud_num_points_0=a.asm.Q).apply(null,arguments)},Bb=a._emscripten_bind_PointCloud___destroy___0=function(){return(Bb=a._emscripten_bind_PointCloud___destroy___0=a.asm.R).apply(null,arguments)},Ka=a._emscripten_bind_Mesh_Mesh_0=function(){return(Ka=
a._emscripten_bind_Mesh_Mesh_0=a.asm.S).apply(null,arguments)},Cb=a._emscripten_bind_Mesh_num_faces_0=function(){return(Cb=a._emscripten_bind_Mesh_num_faces_0=a.asm.T).apply(null,arguments)},Db=a._emscripten_bind_Mesh_num_attributes_0=function(){return(Db=a._emscripten_bind_Mesh_num_attributes_0=a.asm.U).apply(null,arguments)},Eb=a._emscripten_bind_Mesh_num_points_0=function(){return(Eb=a._emscripten_bind_Mesh_num_points_0=a.asm.V).apply(null,arguments)},Fb=a._emscripten_bind_Mesh___destroy___0=function(){return(Fb=
a._emscripten_bind_Mesh___destroy___0=a.asm.W).apply(null,arguments)},La=a._emscripten_bind_Metadata_Metadata_0=function(){return(La=a._emscripten_bind_Metadata_Metadata_0=a.asm.X).apply(null,arguments)},Gb=a._emscripten_bind_Metadata___destroy___0=function(){return(Gb=a._emscripten_bind_Metadata___destroy___0=a.asm.Y).apply(null,arguments)},Hb=a._emscripten_bind_Status_code_0=function(){return(Hb=a._emscripten_bind_Status_code_0=a.asm.Z).apply(null,arguments)},Ib=a._emscripten_bind_Status_ok_0=function(){return(Ib=
a._emscripten_bind_Status_ok_0=a.asm._).apply(null,arguments)},Jb=a._emscripten_bind_Status_error_msg_0=function(){return(Jb=a._emscripten_bind_Status_error_msg_0=a.asm.$).apply(null,arguments)},Kb=a._emscripten_bind_Status___destroy___0=function(){return(Kb=a._emscripten_bind_Status___destroy___0=a.asm.aa).apply(null,arguments)},Ma=a._emscripten_bind_DracoFloat32Array_DracoFloat32Array_0=function(){return(Ma=a._emscripten_bind_DracoFloat32Array_DracoFloat32Array_0=a.asm.ba).apply(null,arguments)},
Lb=a._emscripten_bind_DracoFloat32Array_GetValue_1=function(){return(Lb=a._emscripten_bind_DracoFloat32Array_GetValue_1=a.asm.ca).apply(null,arguments)},Mb=a._emscripten_bind_DracoFloat32Array_size_0=function(){return(Mb=a._emscripten_bind_DracoFloat32Array_size_0=a.asm.da).apply(null,arguments)},Nb=a._emscripten_bind_DracoFloat32Array___destroy___0=function(){return(Nb=a._emscripten_bind_DracoFloat32Array___destroy___0=a.asm.ea).apply(null,arguments)},Na=a._emscripten_bind_DracoInt8Array_DracoInt8Array_0=
function(){return(Na=a._emscripten_bind_DracoInt8Array_DracoInt8Array_0=a.asm.fa).apply(null,arguments)},Ob=a._emscripten_bind_DracoInt8Array_GetValue_1=function(){return(Ob=a._emscripten_bind_DracoInt8Array_GetValue_1=a.asm.ga).apply(null,arguments)},Pb=a._emscripten_bind_DracoInt8Array_size_0=function(){return(Pb=a._emscripten_bind_DracoInt8Array_size_0=a.asm.ha).apply(null,arguments)},Qb=a._emscripten_bind_DracoInt8Array___destroy___0=function(){return(Qb=a._emscripten_bind_DracoInt8Array___destroy___0=
a.asm.ia).apply(null,arguments)},Oa=a._emscripten_bind_DracoUInt8Array_DracoUInt8Array_0=function(){return(Oa=a._emscripten_bind_DracoUInt8Array_DracoUInt8Array_0=a.asm.ja).apply(null,arguments)},Rb=a._emscripten_bind_DracoUInt8Array_GetValue_1=function(){return(Rb=a._emscripten_bind_DracoUInt8Array_GetValue_1=a.asm.ka).apply(null,arguments)},Sb=a._emscripten_bind_DracoUInt8Array_size_0=function(){return(Sb=a._emscripten_bind_DracoUInt8Array_size_0=a.asm.la).apply(null,arguments)},Tb=a._emscripten_bind_DracoUInt8Array___destroy___0=
function(){return(Tb=a._emscripten_bind_DracoUInt8Array___destroy___0=a.asm.ma).apply(null,arguments)},Pa=a._emscripten_bind_DracoInt16Array_DracoInt16Array_0=function(){return(Pa=a._emscripten_bind_DracoInt16Array_DracoInt16Array_0=a.asm.na).apply(null,arguments)},Ub=a._emscripten_bind_DracoInt16Array_GetValue_1=function(){return(Ub=a._emscripten_bind_DracoInt16Array_GetValue_1=a.asm.oa).apply(null,arguments)},Vb=a._emscripten_bind_DracoInt16Array_size_0=function(){return(Vb=a._emscripten_bind_DracoInt16Array_size_0=
a.asm.pa).apply(null,arguments)},Wb=a._emscripten_bind_DracoInt16Array___destroy___0=function(){return(Wb=a._emscripten_bind_DracoInt16Array___destroy___0=a.asm.qa).apply(null,arguments)},Qa=a._emscripten_bind_DracoUInt16Array_DracoUInt16Array_0=function(){return(Qa=a._emscripten_bind_DracoUInt16Array_DracoUInt16Array_0=a.asm.ra).apply(null,arguments)},Xb=a._emscripten_bind_DracoUInt16Array_GetValue_1=function(){return(Xb=a._emscripten_bind_DracoUInt16Array_GetValue_1=a.asm.sa).apply(null,arguments)},
Yb=a._emscripten_bind_DracoUInt16Array_size_0=function(){return(Yb=a._emscripten_bind_DracoUInt16Array_size_0=a.asm.ta).apply(null,arguments)},Zb=a._emscripten_bind_DracoUInt16Array___destroy___0=function(){return(Zb=a._emscripten_bind_DracoUInt16Array___destroy___0=a.asm.ua).apply(null,arguments)},Ra=a._emscripten_bind_DracoInt32Array_DracoInt32Array_0=function(){return(Ra=a._emscripten_bind_DracoInt32Array_DracoInt32Array_0=a.asm.va).apply(null,arguments)},$b=a._emscripten_bind_DracoInt32Array_GetValue_1=
function(){return($b=a._emscripten_bind_DracoInt32Array_GetValue_1=a.asm.wa).apply(null,arguments)},ac=a._emscripten_bind_DracoInt32Array_size_0=function(){return(ac=a._emscripten_bind_DracoInt32Array_size_0=a.asm.xa).apply(null,arguments)},bc=a._emscripten_bind_DracoInt32Array___destroy___0=function(){return(bc=a._emscripten_bind_DracoInt32Array___destroy___0=a.asm.ya).apply(null,arguments)},Sa=a._emscripten_bind_DracoUInt32Array_DracoUInt32Array_0=function(){return(Sa=a._emscripten_bind_DracoUInt32Array_DracoUInt32Array_0=
a.asm.za).apply(null,arguments)},cc=a._emscripten_bind_DracoUInt32Array_GetValue_1=function(){return(cc=a._emscripten_bind_DracoUInt32Array_GetValue_1=a.asm.Aa).apply(null,arguments)},dc=a._emscripten_bind_DracoUInt32Array_size_0=function(){return(dc=a._emscripten_bind_DracoUInt32Array_size_0=a.asm.Ba).apply(null,arguments)},ec=a._emscripten_bind_DracoUInt32Array___destroy___0=function(){return(ec=a._emscripten_bind_DracoUInt32Array___destroy___0=a.asm.Ca).apply(null,arguments)},Ta=a._emscripten_bind_MetadataQuerier_MetadataQuerier_0=
function(){return(Ta=a._emscripten_bind_MetadataQuerier_MetadataQuerier_0=a.asm.Da).apply(null,arguments)},fc=a._emscripten_bind_MetadataQuerier_HasEntry_2=function(){return(fc=a._emscripten_bind_MetadataQuerier_HasEntry_2=a.asm.Ea).apply(null,arguments)},gc=a._emscripten_bind_MetadataQuerier_GetIntEntry_2=function(){return(gc=a._emscripten_bind_MetadataQuerier_GetIntEntry_2=a.asm.Fa).apply(null,arguments)},hc=a._emscripten_bind_MetadataQuerier_GetIntEntryArray_3=function(){return(hc=a._emscripten_bind_MetadataQuerier_GetIntEntryArray_3=
a.asm.Ga).apply(null,arguments)},ic=a._emscripten_bind_MetadataQuerier_GetDoubleEntry_2=function(){return(ic=a._emscripten_bind_MetadataQuerier_GetDoubleEntry_2=a.asm.Ha).apply(null,arguments)},jc=a._emscripten_bind_MetadataQuerier_GetStringEntry_2=function(){return(jc=a._emscripten_bind_MetadataQuerier_GetStringEntry_2=a.asm.Ia).apply(null,arguments)},kc=a._emscripten_bind_MetadataQuerier_NumEntries_1=function(){return(kc=a._emscripten_bind_MetadataQuerier_NumEntries_1=a.asm.Ja).apply(null,arguments)},
lc=a._emscripten_bind_MetadataQuerier_GetEntryName_2=function(){return(lc=a._emscripten_bind_MetadataQuerier_GetEntryName_2=a.asm.Ka).apply(null,arguments)},mc=a._emscripten_bind_MetadataQuerier___destroy___0=function(){return(mc=a._emscripten_bind_MetadataQuerier___destroy___0=a.asm.La).apply(null,arguments)},Ua=a._emscripten_bind_Decoder_Decoder_0=function(){return(Ua=a._emscripten_bind_Decoder_Decoder_0=a.asm.Ma).apply(null,arguments)},nc=a._emscripten_bind_Decoder_DecodeArrayToPointCloud_3=function(){return(nc=
a._emscripten_bind_Decoder_DecodeArrayToPointCloud_3=a.asm.Na).apply(null,arguments)},oc=a._emscripten_bind_Decoder_DecodeArrayToMesh_3=function(){return(oc=a._emscripten_bind_Decoder_DecodeArrayToMesh_3=a.asm.Oa).apply(null,arguments)},pc=a._emscripten_bind_Decoder_GetAttributeId_2=function(){return(pc=a._emscripten_bind_Decoder_GetAttributeId_2=a.asm.Pa).apply(null,arguments)},qc=a._emscripten_bind_Decoder_GetAttributeIdByName_2=function(){return(qc=a._emscripten_bind_Decoder_GetAttributeIdByName_2=
a.asm.Qa).apply(null,arguments)},rc=a._emscripten_bind_Decoder_GetAttributeIdByMetadataEntry_3=function(){return(rc=a._emscripten_bind_Decoder_GetAttributeIdByMetadataEntry_3=a.asm.Ra).apply(null,arguments)},sc=a._emscripten_bind_Decoder_GetAttribute_2=function(){return(sc=a._emscripten_bind_Decoder_GetAttribute_2=a.asm.Sa).apply(null,arguments)},tc=a._emscripten_bind_Decoder_GetAttributeByUniqueId_2=function(){return(tc=a._emscripten_bind_Decoder_GetAttributeByUniqueId_2=a.asm.Ta).apply(null,arguments)},
uc=a._emscripten_bind_Decoder_GetMetadata_1=function(){return(uc=a._emscripten_bind_Decoder_GetMetadata_1=a.asm.Ua).apply(null,arguments)},vc=a._emscripten_bind_Decoder_GetAttributeMetadata_2=function(){return(vc=a._emscripten_bind_Decoder_GetAttributeMetadata_2=a.asm.Va).apply(null,arguments)},wc=a._emscripten_bind_Decoder_GetFaceFromMesh_3=function(){return(wc=a._emscripten_bind_Decoder_GetFaceFromMesh_3=a.asm.Wa).apply(null,arguments)},xc=a._emscripten_bind_Decoder_GetTriangleStripsFromMesh_2=
function(){return(xc=a._emscripten_bind_Decoder_GetTriangleStripsFromMesh_2=a.asm.Xa).apply(null,arguments)},yc=a._emscripten_bind_Decoder_GetTrianglesUInt16Array_3=function(){return(yc=a._emscripten_bind_Decoder_GetTrianglesUInt16Array_3=a.asm.Ya).apply(null,arguments)},zc=a._emscripten_bind_Decoder_GetTrianglesUInt32Array_3=function(){return(zc=a._emscripten_bind_Decoder_GetTrianglesUInt32Array_3=a.asm.Za).apply(null,arguments)},Ac=a._emscripten_bind_Decoder_GetAttributeFloat_3=function(){return(Ac=
a._emscripten_bind_Decoder_GetAttributeFloat_3=a.asm._a).apply(null,arguments)},Bc=a._emscripten_bind_Decoder_GetAttributeFloatForAllPoints_3=function(){return(Bc=a._emscripten_bind_Decoder_GetAttributeFloatForAllPoints_3=a.asm.$a).apply(null,arguments)},Cc=a._emscripten_bind_Decoder_GetAttributeIntForAllPoints_3=function(){return(Cc=a._emscripten_bind_Decoder_GetAttributeIntForAllPoints_3=a.asm.ab).apply(null,arguments)},Dc=a._emscripten_bind_Decoder_GetAttributeInt8ForAllPoints_3=function(){return(Dc=
a._emscripten_bind_Decoder_GetAttributeInt8ForAllPoints_3=a.asm.bb).apply(null,arguments)},Ec=a._emscripten_bind_Decoder_GetAttributeUInt8ForAllPoints_3=function(){return(Ec=a._emscripten_bind_Decoder_GetAttributeUInt8ForAllPoints_3=a.asm.cb).apply(null,arguments)},Fc=a._emscripten_bind_Decoder_GetAttributeInt16ForAllPoints_3=function(){return(Fc=a._emscripten_bind_Decoder_GetAttributeInt16ForAllPoints_3=a.asm.db).apply(null,arguments)},Gc=a._emscripten_bind_Decoder_GetAttributeUInt16ForAllPoints_3=
function(){return(Gc=a._emscripten_bind_Decoder_GetAttributeUInt16ForAllPoints_3=a.asm.eb).apply(null,arguments)},Hc=a._emscripten_bind_Decoder_GetAttributeInt32ForAllPoints_3=function(){return(Hc=a._emscripten_bind_Decoder_GetAttributeInt32ForAllPoints_3=a.asm.fb).apply(null,arguments)},Ic=a._emscripten_bind_Decoder_GetAttributeUInt32ForAllPoints_3=function(){return(Ic=a._emscripten_bind_Decoder_GetAttributeUInt32ForAllPoints_3=a.asm.gb).apply(null,arguments)},Jc=a._emscripten_bind_Decoder_GetAttributeDataArrayForAllPoints_5=
function(){return(Jc=a._emscripten_bind_Decoder_GetAttributeDataArrayForAllPoints_5=a.asm.hb).apply(null,arguments)},Kc=a._emscripten_bind_Decoder_SkipAttributeTransform_1=function(){return(Kc=a._emscripten_bind_Decoder_SkipAttributeTransform_1=a.asm.ib).apply(null,arguments)},Lc=a._emscripten_bind_Decoder_GetEncodedGeometryType_Deprecated_1=function(){return(Lc=a._emscripten_bind_Decoder_GetEncodedGeometryType_Deprecated_1=a.asm.jb).apply(null,arguments)},Mc=a._emscripten_bind_Decoder_DecodeBufferToPointCloud_2=
function(){return(Mc=a._emscripten_bind_Decoder_DecodeBufferToPointCloud_2=a.asm.kb).apply(null,arguments)},Nc=a._emscripten_bind_Decoder_DecodeBufferToMesh_2=function(){return(Nc=a._emscripten_bind_Decoder_DecodeBufferToMesh_2=a.asm.lb).apply(null,arguments)},Oc=a._emscripten_bind_Decoder___destroy___0=function(){return(Oc=a._emscripten_bind_Decoder___destroy___0=a.asm.mb).apply(null,arguments)},Pc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_INVALID_TRANSFORM=function(){return(Pc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_INVALID_TRANSFORM=
a.asm.nb).apply(null,arguments)},Qc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_NO_TRANSFORM=function(){return(Qc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_NO_TRANSFORM=a.asm.ob).apply(null,arguments)},Rc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_QUANTIZATION_TRANSFORM=function(){return(Rc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_QUANTIZATION_TRANSFORM=a.asm.pb).apply(null,arguments)},Sc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_OCTAHEDRON_TRANSFORM=
function(){return(Sc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_OCTAHEDRON_TRANSFORM=a.asm.qb).apply(null,arguments)},Tc=a._emscripten_enum_draco_GeometryAttribute_Type_INVALID=function(){return(Tc=a._emscripten_enum_draco_GeometryAttribute_Type_INVALID=a.asm.rb).apply(null,arguments)},Uc=a._emscripten_enum_draco_GeometryAttribute_Type_POSITION=function(){return(Uc=a._emscripten_enum_draco_GeometryAttribute_Type_POSITION=a.asm.sb).apply(null,arguments)},Vc=a._emscripten_enum_draco_GeometryAttribute_Type_NORMAL=
function(){return(Vc=a._emscripten_enum_draco_GeometryAttribute_Type_NORMAL=a.asm.tb).apply(null,arguments)},Wc=a._emscripten_enum_draco_GeometryAttribute_Type_COLOR=function(){return(Wc=a._emscripten_enum_draco_GeometryAttribute_Type_COLOR=a.asm.ub).apply(null,arguments)},Xc=a._emscripten_enum_draco_GeometryAttribute_Type_TEX_COORD=function(){return(Xc=a._emscripten_enum_draco_GeometryAttribute_Type_TEX_COORD=a.asm.vb).apply(null,arguments)},Yc=a._emscripten_enum_draco_GeometryAttribute_Type_GENERIC=
function(){return(Yc=a._emscripten_enum_draco_GeometryAttribute_Type_GENERIC=a.asm.wb).apply(null,arguments)},Zc=a._emscripten_enum_draco_EncodedGeometryType_INVALID_GEOMETRY_TYPE=function(){return(Zc=a._emscripten_enum_draco_EncodedGeometryType_INVALID_GEOMETRY_TYPE=a.asm.xb).apply(null,arguments)},$c=a._emscripten_enum_draco_EncodedGeometryType_POINT_CLOUD=function(){return($c=a._emscripten_enum_draco_EncodedGeometryType_POINT_CLOUD=a.asm.yb).apply(null,arguments)},ad=a._emscripten_enum_draco_EncodedGeometryType_TRIANGULAR_MESH=
function(){return(ad=a._emscripten_enum_draco_EncodedGeometryType_TRIANGULAR_MESH=a.asm.zb).apply(null,arguments)},bd=a._emscripten_enum_draco_DataType_DT_INVALID=function(){return(bd=a._emscripten_enum_draco_DataType_DT_INVALID=a.asm.Ab).apply(null,arguments)},cd=a._emscripten_enum_draco_DataType_DT_INT8=function(){return(cd=a._emscripten_enum_draco_DataType_DT_INT8=a.asm.Bb).apply(null,arguments)},dd=a._emscripten_enum_draco_DataType_DT_UINT8=function(){return(dd=a._emscripten_enum_draco_DataType_DT_UINT8=
a.asm.Cb).apply(null,arguments)},ed=a._emscripten_enum_draco_DataType_DT_INT16=function(){return(ed=a._emscripten_enum_draco_DataType_DT_INT16=a.asm.Db).apply(null,arguments)},fd=a._emscripten_enum_draco_DataType_DT_UINT16=function(){return(fd=a._emscripten_enum_draco_DataType_DT_UINT16=a.asm.Eb).apply(null,arguments)},gd=a._emscripten_enum_draco_DataType_DT_INT32=function(){return(gd=a._emscripten_enum_draco_DataType_DT_INT32=a.asm.Fb).apply(null,arguments)},hd=a._emscripten_enum_draco_DataType_DT_UINT32=
function(){return(hd=a._emscripten_enum_draco_DataType_DT_UINT32=a.asm.Gb).apply(null,arguments)},id=a._emscripten_enum_draco_DataType_DT_INT64=function(){return(id=a._emscripten_enum_draco_DataType_DT_INT64=a.asm.Hb).apply(null,arguments)},jd=a._emscripten_enum_draco_DataType_DT_UINT64=function(){return(jd=a._emscripten_enum_draco_DataType_DT_UINT64=a.asm.Ib).apply(null,arguments)},kd=a._emscripten_enum_draco_DataType_DT_FLOAT32=function(){return(kd=a._emscripten_enum_draco_DataType_DT_FLOAT32=a.asm.Jb).apply(null,
arguments)},ld=a._emscripten_enum_draco_DataType_DT_FLOAT64=function(){return(ld=a._emscripten_enum_draco_DataType_DT_FLOAT64=a.asm.Kb).apply(null,arguments)},md=a._emscripten_enum_draco_DataType_DT_BOOL=function(){return(md=a._emscripten_enum_draco_DataType_DT_BOOL=a.asm.Lb).apply(null,arguments)},nd=a._emscripten_enum_draco_DataType_DT_TYPES_COUNT=function(){return(nd=a._emscripten_enum_draco_DataType_DT_TYPES_COUNT=a.asm.Mb).apply(null,arguments)},od=a._emscripten_enum_draco_StatusCode_OK=function(){return(od=
a._emscripten_enum_draco_StatusCode_OK=a.asm.Nb).apply(null,arguments)},pd=a._emscripten_enum_draco_StatusCode_DRACO_ERROR=function(){return(pd=a._emscripten_enum_draco_StatusCode_DRACO_ERROR=a.asm.Ob).apply(null,arguments)},qd=a._emscripten_enum_draco_StatusCode_IO_ERROR=function(){return(qd=a._emscripten_enum_draco_StatusCode_IO_ERROR=a.asm.Pb).apply(null,arguments)},rd=a._emscripten_enum_draco_StatusCode_INVALID_PARAMETER=function(){return(rd=a._emscripten_enum_draco_StatusCode_INVALID_PARAMETER=
a.asm.Qb).apply(null,arguments)},sd=a._emscripten_enum_draco_StatusCode_UNSUPPORTED_VERSION=function(){return(sd=a._emscripten_enum_draco_StatusCode_UNSUPPORTED_VERSION=a.asm.Rb).apply(null,arguments)},td=a._emscripten_enum_draco_StatusCode_UNKNOWN_VERSION=function(){return(td=a._emscripten_enum_draco_StatusCode_UNKNOWN_VERSION=a.asm.Sb).apply(null,arguments)};a._malloc=function(){return(a._malloc=a.asm.Tb).apply(null,arguments)};a._free=function(){return(a._free=a.asm.Ub).apply(null,arguments)};
var ya=function(){return(ya=a.asm.Vb).apply(null,arguments)};a.___start_em_js=15856;a.___stop_em_js=15954;var la;ia=function b(){la||ba();la||(ia=b)};if(a.preInit)for("function"==typeof a.preInit&&(a.preInit=[a.preInit]);0<a.preInit.length;)a.preInit.pop()();ba();t.prototype=Object.create(t.prototype);t.prototype.constructor=t;t.prototype.__class__=t;t.__cache__={};a.WrapperObject=t;a.getCache=x;a.wrapPointer=D;a.castObject=function(b,c){return D(b.ptr,c)};a.NULL=D(0);a.destroy=function(b){if(!b.__destroy__)throw"Error: Cannot destroy object. (Did you create it yourself?)";
b.__destroy__();delete x(b.__class__)[b.ptr]};a.compare=function(b,c){return b.ptr===c.ptr};a.getPointer=function(b){return b.ptr};a.getClass=function(b){return b.__class__};var r={buffer:0,size:0,pos:0,temps:[],needed:0,prepare:function(){if(r.needed){for(var b=0;b<r.temps.length;b++)a._free(r.temps[b]);r.temps.length=0;a._free(r.buffer);r.buffer=0;r.size+=r.needed;r.needed=0}r.buffer||(r.size+=128,r.buffer=a._malloc(r.size),r.buffer||f(void 0));r.pos=0},alloc:function(b,c){r.buffer||f(void 0);b=
b.length*c.BYTES_PER_ELEMENT;b=b+7&-8;r.pos+b>=r.size?(0<b||f(void 0),r.needed+=b,c=a._malloc(b),r.temps.push(c)):(c=r.buffer+r.pos,r.pos+=b);return c},copy:function(b,c,d){d>>>=0;switch(c.BYTES_PER_ELEMENT){case 2:d>>>=1;break;case 4:d>>>=2;break;case 8:d>>>=3}for(var g=0;g<b.length;g++)c[d+g]=b[g]}};Z.prototype=Object.create(t.prototype);Z.prototype.constructor=Z;Z.prototype.__class__=Z;Z.__cache__={};a.VoidPtr=Z;Z.prototype.__destroy__=Z.prototype.__destroy__=function(){bb(this.ptr)};S.prototype=
Object.create(t.prototype);S.prototype.constructor=S;S.prototype.__class__=S;S.__cache__={};a.DecoderBuffer=S;S.prototype.Init=S.prototype.Init=function(b,c){var d=this.ptr;r.prepare();"object"==typeof b&&(b=pa(b));c&&"object"===typeof c&&(c=c.ptr);cb(d,b,c)};S.prototype.__destroy__=S.prototype.__destroy__=function(){db(this.ptr)};Q.prototype=Object.create(t.prototype);Q.prototype.constructor=Q;Q.prototype.__class__=Q;Q.__cache__={};a.AttributeTransformData=Q;Q.prototype.transform_type=Q.prototype.transform_type=
function(){return eb(this.ptr)};Q.prototype.__destroy__=Q.prototype.__destroy__=function(){fb(this.ptr)};W.prototype=Object.create(t.prototype);W.prototype.constructor=W;W.prototype.__class__=W;W.__cache__={};a.GeometryAttribute=W;W.prototype.__destroy__=W.prototype.__destroy__=function(){gb(this.ptr)};w.prototype=Object.create(t.prototype);w.prototype.constructor=w;w.prototype.__class__=w;w.__cache__={};a.PointAttribute=w;w.prototype.size=w.prototype.size=function(){return hb(this.ptr)};w.prototype.GetAttributeTransformData=
w.prototype.GetAttributeTransformData=function(){return D(ib(this.ptr),Q)};w.prototype.attribute_type=w.prototype.attribute_type=function(){return jb(this.ptr)};w.prototype.data_type=w.prototype.data_type=function(){return kb(this.ptr)};w.prototype.num_components=w.prototype.num_components=function(){return lb(this.ptr)};w.prototype.normalized=w.prototype.normalized=function(){return!!mb(this.ptr)};w.prototype.byte_stride=w.prototype.byte_stride=function(){return nb(this.ptr)};w.prototype.byte_offset=
w.prototype.byte_offset=function(){return ob(this.ptr)};w.prototype.unique_id=w.prototype.unique_id=function(){return pb(this.ptr)};w.prototype.__destroy__=w.prototype.__destroy__=function(){qb(this.ptr)};C.prototype=Object.create(t.prototype);C.prototype.constructor=C;C.prototype.__class__=C;C.__cache__={};a.AttributeQuantizationTransform=C;C.prototype.InitFromAttribute=C.prototype.InitFromAttribute=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return!!rb(c,b)};C.prototype.quantization_bits=
C.prototype.quantization_bits=function(){return sb(this.ptr)};C.prototype.min_value=C.prototype.min_value=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return tb(c,b)};C.prototype.range=C.prototype.range=function(){return ub(this.ptr)};C.prototype.__destroy__=C.prototype.__destroy__=function(){vb(this.ptr)};F.prototype=Object.create(t.prototype);F.prototype.constructor=F;F.prototype.__class__=F;F.__cache__={};a.AttributeOctahedronTransform=F;F.prototype.InitFromAttribute=F.prototype.InitFromAttribute=
function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return!!wb(c,b)};F.prototype.quantization_bits=F.prototype.quantization_bits=function(){return xb(this.ptr)};F.prototype.__destroy__=F.prototype.__destroy__=function(){yb(this.ptr)};G.prototype=Object.create(t.prototype);G.prototype.constructor=G;G.prototype.__class__=G;G.__cache__={};a.PointCloud=G;G.prototype.num_attributes=G.prototype.num_attributes=function(){return zb(this.ptr)};G.prototype.num_points=G.prototype.num_points=function(){return Ab(this.ptr)};
G.prototype.__destroy__=G.prototype.__destroy__=function(){Bb(this.ptr)};E.prototype=Object.create(t.prototype);E.prototype.constructor=E;E.prototype.__class__=E;E.__cache__={};a.Mesh=E;E.prototype.num_faces=E.prototype.num_faces=function(){return Cb(this.ptr)};E.prototype.num_attributes=E.prototype.num_attributes=function(){return Db(this.ptr)};E.prototype.num_points=E.prototype.num_points=function(){return Eb(this.ptr)};E.prototype.__destroy__=E.prototype.__destroy__=function(){Fb(this.ptr)};T.prototype=
Object.create(t.prototype);T.prototype.constructor=T;T.prototype.__class__=T;T.__cache__={};a.Metadata=T;T.prototype.__destroy__=T.prototype.__destroy__=function(){Gb(this.ptr)};B.prototype=Object.create(t.prototype);B.prototype.constructor=B;B.prototype.__class__=B;B.__cache__={};a.Status=B;B.prototype.code=B.prototype.code=function(){return Hb(this.ptr)};B.prototype.ok=B.prototype.ok=function(){return!!Ib(this.ptr)};B.prototype.error_msg=B.prototype.error_msg=function(){return h(Jb(this.ptr))};
B.prototype.__destroy__=B.prototype.__destroy__=function(){Kb(this.ptr)};H.prototype=Object.create(t.prototype);H.prototype.constructor=H;H.prototype.__class__=H;H.__cache__={};a.DracoFloat32Array=H;H.prototype.GetValue=H.prototype.GetValue=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return Lb(c,b)};H.prototype.size=H.prototype.size=function(){return Mb(this.ptr)};H.prototype.__destroy__=H.prototype.__destroy__=function(){Nb(this.ptr)};I.prototype=Object.create(t.prototype);I.prototype.constructor=
I;I.prototype.__class__=I;I.__cache__={};a.DracoInt8Array=I;I.prototype.GetValue=I.prototype.GetValue=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return Ob(c,b)};I.prototype.size=I.prototype.size=function(){return Pb(this.ptr)};I.prototype.__destroy__=I.prototype.__destroy__=function(){Qb(this.ptr)};J.prototype=Object.create(t.prototype);J.prototype.constructor=J;J.prototype.__class__=J;J.__cache__={};a.DracoUInt8Array=J;J.prototype.GetValue=J.prototype.GetValue=function(b){var c=
this.ptr;b&&"object"===typeof b&&(b=b.ptr);return Rb(c,b)};J.prototype.size=J.prototype.size=function(){return Sb(this.ptr)};J.prototype.__destroy__=J.prototype.__destroy__=function(){Tb(this.ptr)};K.prototype=Object.create(t.prototype);K.prototype.constructor=K;K.prototype.__class__=K;K.__cache__={};a.DracoInt16Array=K;K.prototype.GetValue=K.prototype.GetValue=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return Ub(c,b)};K.prototype.size=K.prototype.size=function(){return Vb(this.ptr)};
K.prototype.__destroy__=K.prototype.__destroy__=function(){Wb(this.ptr)};L.prototype=Object.create(t.prototype);L.prototype.constructor=L;L.prototype.__class__=L;L.__cache__={};a.DracoUInt16Array=L;L.prototype.GetValue=L.prototype.GetValue=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return Xb(c,b)};L.prototype.size=L.prototype.size=function(){return Yb(this.ptr)};L.prototype.__destroy__=L.prototype.__destroy__=function(){Zb(this.ptr)};M.prototype=Object.create(t.prototype);M.prototype.constructor=
M;M.prototype.__class__=M;M.__cache__={};a.DracoInt32Array=M;M.prototype.GetValue=M.prototype.GetValue=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return $b(c,b)};M.prototype.size=M.prototype.size=function(){return ac(this.ptr)};M.prototype.__destroy__=M.prototype.__destroy__=function(){bc(this.ptr)};N.prototype=Object.create(t.prototype);N.prototype.constructor=N;N.prototype.__class__=N;N.__cache__={};a.DracoUInt32Array=N;N.prototype.GetValue=N.prototype.GetValue=function(b){var c=
this.ptr;b&&"object"===typeof b&&(b=b.ptr);return cc(c,b)};N.prototype.size=N.prototype.size=function(){return dc(this.ptr)};N.prototype.__destroy__=N.prototype.__destroy__=function(){ec(this.ptr)};y.prototype=Object.create(t.prototype);y.prototype.constructor=y;y.prototype.__class__=y;y.__cache__={};a.MetadataQuerier=y;y.prototype.HasEntry=y.prototype.HasEntry=function(b,c){var d=this.ptr;r.prepare();b&&"object"===typeof b&&(b=b.ptr);c=c&&"object"===typeof c?c.ptr:R(c);return!!fc(d,b,c)};y.prototype.GetIntEntry=
y.prototype.GetIntEntry=function(b,c){var d=this.ptr;r.prepare();b&&"object"===typeof b&&(b=b.ptr);c=c&&"object"===typeof c?c.ptr:R(c);return gc(d,b,c)};y.prototype.GetIntEntryArray=y.prototype.GetIntEntryArray=function(b,c,d){var g=this.ptr;r.prepare();b&&"object"===typeof b&&(b=b.ptr);c=c&&"object"===typeof c?c.ptr:R(c);d&&"object"===typeof d&&(d=d.ptr);hc(g,b,c,d)};y.prototype.GetDoubleEntry=y.prototype.GetDoubleEntry=function(b,c){var d=this.ptr;r.prepare();b&&"object"===typeof b&&(b=b.ptr);c=
c&&"object"===typeof c?c.ptr:R(c);return ic(d,b,c)};y.prototype.GetStringEntry=y.prototype.GetStringEntry=function(b,c){var d=this.ptr;r.prepare();b&&"object"===typeof b&&(b=b.ptr);c=c&&"object"===typeof c?c.ptr:R(c);return h(jc(d,b,c))};y.prototype.NumEntries=y.prototype.NumEntries=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return kc(c,b)};y.prototype.GetEntryName=y.prototype.GetEntryName=function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=
c.ptr);return h(lc(d,b,c))};y.prototype.__destroy__=y.prototype.__destroy__=function(){mc(this.ptr)};m.prototype=Object.create(t.prototype);m.prototype.constructor=m;m.prototype.__class__=m;m.__cache__={};a.Decoder=m;m.prototype.DecodeArrayToPointCloud=m.prototype.DecodeArrayToPointCloud=function(b,c,d){var g=this.ptr;r.prepare();"object"==typeof b&&(b=pa(b));c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return D(nc(g,b,c,d),B)};m.prototype.DecodeArrayToMesh=m.prototype.DecodeArrayToMesh=
function(b,c,d){var g=this.ptr;r.prepare();"object"==typeof b&&(b=pa(b));c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return D(oc(g,b,c,d),B)};m.prototype.GetAttributeId=m.prototype.GetAttributeId=function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);return pc(d,b,c)};m.prototype.GetAttributeIdByName=m.prototype.GetAttributeIdByName=function(b,c){var d=this.ptr;r.prepare();b&&"object"===typeof b&&(b=b.ptr);c=c&&"object"===typeof c?
c.ptr:R(c);return qc(d,b,c)};m.prototype.GetAttributeIdByMetadataEntry=m.prototype.GetAttributeIdByMetadataEntry=function(b,c,d){var g=this.ptr;r.prepare();b&&"object"===typeof b&&(b=b.ptr);c=c&&"object"===typeof c?c.ptr:R(c);d=d&&"object"===typeof d?d.ptr:R(d);return rc(g,b,c,d)};m.prototype.GetAttribute=m.prototype.GetAttribute=function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);return D(sc(d,b,c),w)};m.prototype.GetAttributeByUniqueId=m.prototype.GetAttributeByUniqueId=
function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);return D(tc(d,b,c),w)};m.prototype.GetMetadata=m.prototype.GetMetadata=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return D(uc(c,b),T)};m.prototype.GetAttributeMetadata=m.prototype.GetAttributeMetadata=function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);return D(vc(d,b,c),T)};m.prototype.GetFaceFromMesh=m.prototype.GetFaceFromMesh=function(b,
c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!wc(g,b,c,d)};m.prototype.GetTriangleStripsFromMesh=m.prototype.GetTriangleStripsFromMesh=function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);return xc(d,b,c)};m.prototype.GetTrianglesUInt16Array=m.prototype.GetTrianglesUInt16Array=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);
d&&"object"===typeof d&&(d=d.ptr);return!!yc(g,b,c,d)};m.prototype.GetTrianglesUInt32Array=m.prototype.GetTrianglesUInt32Array=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!zc(g,b,c,d)};m.prototype.GetAttributeFloat=m.prototype.GetAttributeFloat=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!Ac(g,b,c,d)};m.prototype.GetAttributeFloatForAllPoints=
m.prototype.GetAttributeFloatForAllPoints=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!Bc(g,b,c,d)};m.prototype.GetAttributeIntForAllPoints=m.prototype.GetAttributeIntForAllPoints=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!Cc(g,b,c,d)};m.prototype.GetAttributeInt8ForAllPoints=m.prototype.GetAttributeInt8ForAllPoints=
function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!Dc(g,b,c,d)};m.prototype.GetAttributeUInt8ForAllPoints=m.prototype.GetAttributeUInt8ForAllPoints=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!Ec(g,b,c,d)};m.prototype.GetAttributeInt16ForAllPoints=m.prototype.GetAttributeInt16ForAllPoints=function(b,c,d){var g=this.ptr;
b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!Fc(g,b,c,d)};m.prototype.GetAttributeUInt16ForAllPoints=m.prototype.GetAttributeUInt16ForAllPoints=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!Gc(g,b,c,d)};m.prototype.GetAttributeInt32ForAllPoints=m.prototype.GetAttributeInt32ForAllPoints=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&
(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!Hc(g,b,c,d)};m.prototype.GetAttributeUInt32ForAllPoints=m.prototype.GetAttributeUInt32ForAllPoints=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!Ic(g,b,c,d)};m.prototype.GetAttributeDataArrayForAllPoints=m.prototype.GetAttributeDataArrayForAllPoints=function(b,c,d,g,u){var X=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&
"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);g&&"object"===typeof g&&(g=g.ptr);u&&"object"===typeof u&&(u=u.ptr);return!!Jc(X,b,c,d,g,u)};m.prototype.SkipAttributeTransform=m.prototype.SkipAttributeTransform=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);Kc(c,b)};m.prototype.GetEncodedGeometryType_Deprecated=m.prototype.GetEncodedGeometryType_Deprecated=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return Lc(c,b)};m.prototype.DecodeBufferToPointCloud=
m.prototype.DecodeBufferToPointCloud=function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);return D(Mc(d,b,c),B)};m.prototype.DecodeBufferToMesh=m.prototype.DecodeBufferToMesh=function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);return D(Nc(d,b,c),B)};m.prototype.__destroy__=m.prototype.__destroy__=function(){Oc(this.ptr)};(function(){function b(){a.ATTRIBUTE_INVALID_TRANSFORM=Pc();a.ATTRIBUTE_NO_TRANSFORM=Qc();
a.ATTRIBUTE_QUANTIZATION_TRANSFORM=Rc();a.ATTRIBUTE_OCTAHEDRON_TRANSFORM=Sc();a.INVALID=Tc();a.POSITION=Uc();a.NORMAL=Vc();a.COLOR=Wc();a.TEX_COORD=Xc();a.GENERIC=Yc();a.INVALID_GEOMETRY_TYPE=Zc();a.POINT_CLOUD=$c();a.TRIANGULAR_MESH=ad();a.DT_INVALID=bd();a.DT_INT8=cd();a.DT_UINT8=dd();a.DT_INT16=ed();a.DT_UINT16=fd();a.DT_INT32=gd();a.DT_UINT32=hd();a.DT_INT64=id();a.DT_UINT64=jd();a.DT_FLOAT32=kd();a.DT_FLOAT64=ld();a.DT_BOOL=md();a.DT_TYPES_COUNT=nd();a.OK=od();a.DRACO_ERROR=pd();a.IO_ERROR=qd();
a.INVALID_PARAMETER=rd();a.UNSUPPORTED_VERSION=sd();a.UNKNOWN_VERSION=td()}za?b():oa.unshift(b)})();if("function"===typeof a.onModuleParsed)a.onModuleParsed();a.Decoder.prototype.GetEncodedGeometryType=function(b){if(b.__class__&&b.__class__===a.DecoderBuffer)return a.Decoder.prototype.GetEncodedGeometryType_Deprecated(b);if(8>b.byteLength)return a.INVALID_GEOMETRY_TYPE;switch(b[7]){case 0:return a.POINT_CLOUD;case 1:return a.TRIANGULAR_MESH;default:return a.INVALID_GEOMETRY_TYPE}};return n.ready}}();
"object"===typeof exports&&"object"===typeof module?module.exports=DracoDecoderModule:"function"===typeof define&&define.amd?define([],function(){return DracoDecoderModule}):"object"===typeof exports&&(exports.DracoDecoderModule=DracoDecoderModule);
", "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", "let Module = (function () {
  let _scriptDir =
    typeof document !== "undefined" && document.currentScript
      ? document.currentScript.src
      : undefined;

  return function (Module) {
    Module = Module || {};

    let c;
    c || (c = typeof Module !== "undefined" ? Module : {});
    c.compileGLSLZeroCopy = function (a, b, d, e) {
      d = !!d;
      switch (b) {
        case "vertex":
          var g = 0;
          break;
        case "fragment":
          g = 4;
          break;
        case "compute":
          g = 5;
          break;
        default:
          throw Error("shader_stage must be 'vertex', 'fragment', or 'compute'.");
      }
      switch (e || "1.0") {
        case "1.0":
          var f = 65536;
          break;
        case "1.1":
          f = 65792;
          break;
        case "1.2":
          f = 66048;
          break;
        case "1.3":
          f = 66304;
          break;
        case "1.4":
          f = 66560;
          break;
        case "1.5":
          f = 66816;
          break;
        default:
          throw Error("spirv_version must be '1.0' ~ '1.5'.");
      }
      e = c._malloc(4);
      b = c._malloc(4);
      let h = aa([a, g, d, f, e, b]);
      d = k(e);
      a = k(b);
      c._free(e);
      c._free(b);
      if (0 === h) throw Error("GLSL compilation failed");
      e = {};
      d /= 4;
      e.data = c.HEAPU32.subarray(d, d + a);
      e.free = function () {
        c._destroy_output_buffer(h);
      };
      return e;
    };
    c.compileGLSL = function (a, b, d, e) {
      a = c.compileGLSLZeroCopy(a, b, d, e);
      b = a.data.slice();
      a.free();
      return b;
    };
    let p = {},
      q;
    for (q in c) c.hasOwnProperty(q) && (p[q] = c[q]);
    let r = "./this.program",
      t = !1,
      u = !1;
    t = "object" === typeof window;
    u = "function" === typeof importScripts;
    let v = "",
      w;
    if (t || u)
      u ? (v = self.location.href) : document.currentScript && (v = document.currentScript.src),
        _scriptDir && (v = _scriptDir),
        0 !== v.indexOf("blob:") ? (v = v.substr(0, v.lastIndexOf("/") + 1)) : (v = ""),
        u &&
          (w = function (a) {
            let b = new XMLHttpRequest();
            b.open("GET", a, !1);
            b.responseType = "arraybuffer";
            b.send(null);
            return new Uint8Array(b.response);
          });
    let x = c.print || console.log.bind(console),
      y = c.printErr || console.warn.bind(console);
    for (q in p) p.hasOwnProperty(q) && (c[q] = p[q]);
    p = null;
    c.thisProgram && (r = c.thisProgram);
    let A;
    c.wasmBinary && (A = c.wasmBinary);
    "object" !== typeof WebAssembly && y("no native wasm support detected");
    function k(a) {
      let b = "i32";
      "*" === b.charAt(b.length - 1) && (b = "i32");
      switch (b) {
        case "i1":
          return B[a >> 0];
        case "i8":
          return B[a >> 0];
        case "i16":
          return ba[a >> 1];
        case "i32":
          return C[a >> 2];
        case "i64":
          return C[a >> 2];
        case "float":
          return ca[a >> 2];
        case "double":
          return da[a >> 3];
        default:
          D("invalid type for getValue: " + b);
      }
      return null;
    }
    let E,
      ea = new WebAssembly.Table({ initial: 859, maximum: 859, element: "anyfunc" }),
      fa = !1;
    function ha() {
      let a = c._convert_glsl_to_spirv;
      a ||
        D(
          "Assertion failed: Cannot call unknown function convert_glsl_to_spirv, make sure it is exported",
        );
      return a;
    }
    function aa(a) {
      let b = "string number boolean number number number".split(" "),
        d = {
          string(a) {
            let b = 0;
            if (null !== a && void 0 !== a && 0 !== a) {
              let d = (a.length << 2) + 1;
              b = G(d);
              ia(a, H, b, d);
            }
            return b;
          },
          array(a) {
            let b = G(a.length);
            B.set(a, b);
            return b;
          },
        },
        e = ha(),
        g = [],
        f = 0;
      if (a)
        for (let h = 0; h < a.length; h++) {
          let n = d[b[h]];
          n ? (0 === f && (f = ja()), (g[h] = n(a[h]))) : (g[h] = a[h]);
        }
      a = e.apply(null, g);
      0 !== f && ka(f);
      return a;
    }
    let la = "undefined" !== typeof TextDecoder ? new TextDecoder("utf8") : void 0;
    function I(a, b, d) {
      let e = b + d;
      for (d = b; a[d] && !(d >= e); ) ++d;
      if (16 < d - b && a.subarray && la) return la.decode(a.subarray(b, d));
      for (e = ""; b < d; ) {
        let g = a[b++];
        if (g & 128) {
          let f = a[b++] & 63;
          if (192 == (g & 224)) e += String.fromCharCode(((g & 31) << 6) | f);
          else {
            let h = a[b++] & 63;
            g =
              224 == (g & 240)
                ? ((g & 15) << 12) | (f << 6) | h
                : ((g & 7) << 18) | (f << 12) | (h << 6) | (a[b++] & 63);
            65536 > g
              ? (e += String.fromCharCode(g))
              : ((g -= 65536), (e += String.fromCharCode(55296 | (g >> 10), 56320 | (g & 1023))));
          }
        } else e += String.fromCharCode(g);
      }
      return e;
    }
    function ia(a, b, d, e) {
      if (0 < e) {
        e = d + e - 1;
        for (let g = 0; g < a.length; ++g) {
          let f = a.charCodeAt(g);
          if (55296 <= f && 57343 >= f) {
            let h = a.charCodeAt(++g);
            f = (65536 + ((f & 1023) << 10)) | (h & 1023);
          }
          if (127 >= f) {
            if (d >= e) break;
            b[d++] = f;
          } else {
            if (2047 >= f) {
              if (d + 1 >= e) break;
              b[d++] = 192 | (f >> 6);
            } else {
              if (65535 >= f) {
                if (d + 2 >= e) break;
                b[d++] = 224 | (f >> 12);
              } else {
                if (d + 3 >= e) break;
                b[d++] = 240 | (f >> 18);
                b[d++] = 128 | ((f >> 12) & 63);
              }
              b[d++] = 128 | ((f >> 6) & 63);
            }
            b[d++] = 128 | (f & 63);
          }
        }
        b[d] = 0;
      }
    }
    "undefined" !== typeof TextDecoder && new TextDecoder("utf-16le");
    let J, B, H, ba, C, ca, da;
    function ma(a) {
      J = a;
      c.HEAP8 = B = new Int8Array(a);
      c.HEAP16 = ba = new Int16Array(a);
      c.HEAP32 = C = new Int32Array(a);
      c.HEAPU8 = H = new Uint8Array(a);
      c.HEAPU16 = new Uint16Array(a);
      c.HEAPU32 = new Uint32Array(a);
      c.HEAPF32 = ca = new Float32Array(a);
      c.HEAPF64 = da = new Float64Array(a);
    }
    let na = c.TOTAL_MEMORY || 16777216;
    c.wasmMemory ? (E = c.wasmMemory) : (E = new WebAssembly.Memory({ initial: na / 65536 }));
    E && (J = E.buffer);
    na = J.byteLength;
    ma(J);
    C[84916] = 5582704;
    function K(a) {
      for (; 0 < a.length; ) {
        let b = a.shift();
        if ("function" === typeof b) b();
        else {
          let d = b.J;
          "number" === typeof d
            ? void 0 === b.H
              ? c.dynCall_v(d)
              : c.dynCall_vi(d, b.H)
            : d(void 0 === b.H ? null : b.H);
        }
      }
    }
    let oa = [],
      pa = [],
      qa = [],
      ra = [];
    function sa() {
      let a = c.preRun.shift();
      oa.unshift(a);
    }
    let L = 0,
      M = null,
      N = null;
    c.preloadedImages = {};
    c.preloadedAudios = {};
    function D(a) {
      if (c.onAbort) c.onAbort(a);
      x(a);
      y(a);
      fa = !0;
      throw new WebAssembly.RuntimeError(
        "abort(" + a + "). Build with -s ASSERTIONS=1 for more info.",
      );
    }
    function ta() {
      let a = O;
      return String.prototype.startsWith
        ? a.startsWith("data:application/octet-stream;base64,")
        : 0 === a.indexOf("data:application/octet-stream;base64,");
    }
    var O = "data:application/octet-stream;base64,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";
    if (!ta()) {
      let ua = O;
      O = c.locateFile ? c.locateFile(ua, v) : v + ua;
    }
    function wa() {
      try {
        if (A) return new Uint8Array(A);
        if (w) return w(O);
        throw "both async and sync fetching of the wasm failed";
      } catch (a) {
        D(a);
      }
    }
    function xa() {
      return A || (!t && !u) || "function" !== typeof fetch
        ? new Promise(function (a) {
            a(wa());
          })
        : fetch(O, { credentials: "same-origin" })
            .then(function (a) {
              if (!a.ok) throw "failed to load wasm binary file at '" + O + "'";
              return a.arrayBuffer();
            })
            .catch(function () {
              return wa();
            });
    }
    pa.push({
      J() {
        ya();
      },
    });
    let za = [null, [], []],
      P = 0;
    function Aa() {
      P += 4;
      return C[(P - 4) >> 2];
    }
    let Q = {},
      Ba = {};
    function Ca() {
      if (!R) {
        let a = {
            USER: "web_user",
            LOGNAME: "web_user",
            PATH: "/",
            PWD: "/",
            HOME: "/home/web_user",
            LANG:
              (
                ("object" === typeof navigator && navigator.languages && navigator.languages[0]) ||
                "C"
              ).replace("-", "_") + ".UTF-8",
            _: r,
          },
          b;
        for (b in Ba) a[b] = Ba[b];
        let d = [];
        for (b in a) d.push(b + "=" + a[b]);
        R = d;
      }
      return R;
    }
    let R;
    function S(a) {
      return 0 === a % 4 && (0 !== a % 100 || 0 === a % 400);
    }
    function T(a, b) {
      for (var d = 0, e = 0; e <= b; d += a[e++]);
      return d;
    }
    let U = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
      W = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
    function X(a, b) {
      for (a = new Date(a.getTime()); 0 < b; ) {
        let d = a.getMonth(),
          e = (S(a.getFullYear()) ? U : W)[d];
        if (b > e - a.getDate())
          (b -= e - a.getDate() + 1),
            a.setDate(1),
            11 > d ? a.setMonth(d + 1) : (a.setMonth(0), a.setFullYear(a.getFullYear() + 1));
        else {
          a.setDate(a.getDate() + b);
          break;
        }
      }
      return a;
    }
    function Da(a, b, d, e) {
      function g(a, b, d) {
        for (a = "number" === typeof a ? a.toString() : a || ""; a.length < b; ) a = d[0] + a;
        return a;
      }
      function f(a, b) {
        return g(a, b, "0");
      }
      function h(a, b) {
        function V(a) {
          return 0 > a ? -1 : 0 < a ? 1 : 0;
        }
        let d;
        0 === (d = V(a.getFullYear() - b.getFullYear())) &&
          0 === (d = V(a.getMonth() - b.getMonth())) &&
          (d = V(a.getDate() - b.getDate()));
        return d;
      }
      function n(a) {
        switch (a.getDay()) {
          case 0:
            return new Date(a.getFullYear() - 1, 11, 29);
          case 1:
            return a;
          case 2:
            return new Date(a.getFullYear(), 0, 3);
          case 3:
            return new Date(a.getFullYear(), 0, 2);
          case 4:
            return new Date(a.getFullYear(), 0, 1);
          case 5:
            return new Date(a.getFullYear() - 1, 11, 31);
          case 6:
            return new Date(a.getFullYear() - 1, 11, 30);
        }
      }
      function z(a) {
        a = X(new Date(a.A + 1900, 0, 1), a.G);
        let b = n(new Date(a.getFullYear() + 1, 0, 4));
        return 0 >= h(n(new Date(a.getFullYear(), 0, 4)), a)
          ? 0 >= h(b, a)
            ? a.getFullYear() + 1
            : a.getFullYear()
          : a.getFullYear() - 1;
      }
      let m = C[(e + 40) >> 2];
      e = {
        N: C[e >> 2],
        M: C[(e + 4) >> 2],
        D: C[(e + 8) >> 2],
        C: C[(e + 12) >> 2],
        B: C[(e + 16) >> 2],
        A: C[(e + 20) >> 2],
        F: C[(e + 24) >> 2],
        G: C[(e + 28) >> 2],
        X: C[(e + 32) >> 2],
        L: C[(e + 36) >> 2],
        O: m ? (m ? I(H, m, void 0) : "") : "",
      };
      d = d ? I(H, d, void 0) : "";
      m = {
        "%c": "%a %b %d %H:%M:%S %Y",
        "%D": "%m/%d/%y",
        "%F": "%Y-%m-%d",
        "%h": "%b",
        "%r": "%I:%M:%S %p",
        "%R": "%H:%M",
        "%T": "%H:%M:%S",
        "%x": "%m/%d/%y",
        "%X": "%H:%M:%S",
        "%Ec": "%c",
        "%EC": "%C",
        "%Ex": "%m/%d/%y",
        "%EX": "%H:%M:%S",
        "%Ey": "%y",
        "%EY": "%Y",
        "%Od": "%d",
        "%Oe": "%e",
        "%OH": "%H",
        "%OI": "%I",
        "%Om": "%m",
        "%OM": "%M",
        "%OS": "%S",
        "%Ou": "%u",
        "%OU": "%U",
        "%OV": "%V",
        "%Ow": "%w",
        "%OW": "%W",
        "%Oy": "%y",
      };
      for (var l in m) d = d.replace(new RegExp(l, "g"), m[l]);
      let F = "Sunday Monday Tuesday Wednesday Thursday Friday Saturday".split(" "),
        va =
          "January February March April May June July August September October November December".split(
            " ",
          );
      m = {
        "%a"(a) {
          return F[a.F].substring(0, 3);
        },
        "%A"(a) {
          return F[a.F];
        },
        "%b"(a) {
          return va[a.B].substring(0, 3);
        },
        "%B"(a) {
          return va[a.B];
        },
        "%C"(a) {
          return f(((a.A + 1900) / 100) | 0, 2);
        },
        "%d"(a) {
          return f(a.C, 2);
        },
        "%e"(a) {
          return g(a.C, 2, " ");
        },
        "%g"(a) {
          return z(a).toString().substring(2);
        },
        "%G"(a) {
          return z(a);
        },
        "%H"(a) {
          return f(a.D, 2);
        },
        "%I"(a) {
          a = a.D;
          0 == a ? (a = 12) : 12 < a && (a -= 12);
          return f(a, 2);
        },
        "%j"(a) {
          return f(a.C + T(S(a.A + 1900) ? U : W, a.B - 1), 3);
        },
        "%m"(a) {
          return f(a.B + 1, 2);
        },
        "%M"(a) {
          return f(a.M, 2);
        },
        "%n"() {
          return "\n";
        },
        "%p"(a) {
          return 0 <= a.D && 12 > a.D ? "AM" : "PM";
        },
        "%S"(a) {
          return f(a.N, 2);
        },
        "%t"() {
          return "\t";
        },
        "%u"(a) {
          return a.F || 7;
        },
        "%U"(a) {
          let b = new Date(a.A + 1900, 0, 1),
            d = 0 === b.getDay() ? b : X(b, 7 - b.getDay());
          a = new Date(a.A + 1900, a.B, a.C);
          return 0 > h(d, a)
            ? f(
                Math.ceil(
                  (31 -
                    d.getDate() +
                    (T(S(a.getFullYear()) ? U : W, a.getMonth() - 1) - 31) +
                    a.getDate()) /
                    7,
                ),
                2,
              )
            : 0 === h(d, b)
              ? "01"
              : "00";
        },
        "%V"(a) {
          let b = n(new Date(a.A + 1900, 0, 4)),
            d = n(new Date(a.A + 1901, 0, 4)),
            e = X(new Date(a.A + 1900, 0, 1), a.G);
          return 0 > h(e, b)
            ? "53"
            : 0 >= h(d, e)
              ? "01"
              : f(
                  Math.ceil(
                    (b.getFullYear() < a.A + 1900
                      ? a.G + 32 - b.getDate()
                      : a.G + 1 - b.getDate()) / 7,
                  ),
                  2,
                );
        },
        "%w"(a) {
          return a.F;
        },
        "%W"(a) {
          let b = new Date(a.A, 0, 1),
            d = 1 === b.getDay() ? b : X(b, 0 === b.getDay() ? 1 : 7 - b.getDay() + 1);
          a = new Date(a.A + 1900, a.B, a.C);
          return 0 > h(d, a)
            ? f(
                Math.ceil(
                  (31 -
                    d.getDate() +
                    (T(S(a.getFullYear()) ? U : W, a.getMonth() - 1) - 31) +
                    a.getDate()) /
                    7,
                ),
                2,
              )
            : 0 === h(d, b)
              ? "01"
              : "00";
        },
        "%y"(a) {
          return (a.A + 1900).toString().substring(2);
        },
        "%Y"(a) {
          return a.A + 1900;
        },
        "%z"(a) {
          a = a.L;
          let b = 0 <= a;
          a = Math.abs(a) / 60;
          return (b ? "+" : "-") + String("0000" + ((a / 60) * 100 + (a % 60))).slice(-4);
        },
        "%Z"(a) {
          return a.O;
        },
        "%%"() {
          return "%";
        },
      };
      for (l in m) 0 <= d.indexOf(l) && (d = d.replace(new RegExp(l, "g"), m[l](e)));
      l = Ea(d);
      if (l.length > b) return 0;
      B.set(l, a);
      return l.length - 1;
    }
    function Ea(a) {
      for (var b = 0, d = 0; d < a.length; ++d) {
        let e = a.charCodeAt(d);
        55296 <= e && 57343 >= e && (e = (65536 + ((e & 1023) << 10)) | (a.charCodeAt(++d) & 1023));
        127 >= e ? ++b : (b = 2047 >= e ? b + 2 : 65535 >= e ? b + 3 : b + 4);
      }
      b = Array(b + 1);
      ia(a, b, 0, b.length);
      return b;
    }
    let Ga = {
        f() {},
        c() {
          c.___errno_location && (C[c.___errno_location() >> 2] = 63);
          return -1;
        },
        n(a, b) {
          P = b;
          try {
            let d = Aa();
            let e = Aa();
            if (-1 === d || 0 === e) var g = -28;
            else {
              let f = Q.K[d];
              if (f && e === f.U) {
                let h = (void 0).T(f.S);
                Q.R(d, h, e, f.flags, f.offset);
                (void 0).W(h);
                Q.K[d] = null;
                f.P && Fa(f.V);
              }
              g = 0;
            }
            return g;
          } catch (n) {
            return D(n), -n.I;
          }
        },
        a() {},
        b() {
          D();
        },
        k(a, b, d) {
          H.set(H.subarray(b, b + d), a);
        },
        l(a) {
          let b = B.length;
          if (2147418112 < a) return !1;
          for (let d = 1; 4 >= d; d *= 2) {
            let e = b * (1 + 0.2 / d);
            e = Math.min(e, a + 100663296);
            e = Math.max(16777216, a, e);
            0 < e % 65536 && (e += 65536 - (e % 65536));
            a: {
              try {
                E.grow((Math.min(2147418112, e) - J.byteLength + 65535) >> 16);
                ma(E.buffer);
                var g = 1;
                break a;
              } catch (f) {}
              g = void 0;
            }
            if (g) return !0;
          }
          return !1;
        },
        d(a, b) {
          let d = 0;
          Ca().forEach(function (e, g) {
            let f = b + d;
            g = C[(a + 4 * g) >> 2] = f;
            for (f = 0; f < e.length; ++f) B[g++ >> 0] = e.charCodeAt(f);
            B[g >> 0] = 0;
            d += e.length + 1;
          });
          return 0;
        },
        e(a, b) {
          let d = Ca();
          C[a >> 2] = d.length;
          let e = 0;
          d.forEach(function (a) {
            e += a.length + 1;
          });
          C[b >> 2] = e;
          return 0;
        },
        h() {
          return 0;
        },
        j() {
          return 0;
        },
        g(a, b, d, e) {
          try {
            for (var g = 0, f = 0; f < d; f++) {
              for (var h = C[(b + 8 * f) >> 2], n = C[(b + (8 * f + 4)) >> 2], z = 0; z < n; z++) {
                let m = H[h + z],
                  l = za[a];
                0 === m || 10 === m ? ((1 === a ? x : y)(I(l, 0)), (l.length = 0)) : l.push(m);
              }
              g += n;
            }
            C[e >> 2] = g;
            return 0;
          } catch (F) {
            return D(F), F.I;
          }
        },
        memory: E,
        o() {},
        i() {},
        m(a, b, d, e) {
          return Da(a, b, d, e);
        },
        table: ea,
      },
      Ha = (function () {
        function a(a) {
          c.asm = a.exports;
          L--;
          c.monitorRunDependencies && c.monitorRunDependencies(L);
          0 == L && (null !== M && (clearInterval(M), (M = null)), N && ((a = N), (N = null), a()));
        }
        function b(b) {
          a(b.instance);
        }
        function d(a) {
          return xa()
            .then(function (a) {
              return WebAssembly.instantiate(a, e);
            })
            .then(a, function (a) {
              y("failed to asynchronously prepare wasm: " + a);
              D(a);
            });
        }
        var e = { env: Ga, wasi_snapshot_preview1: Ga };
        L++;
        c.monitorRunDependencies && c.monitorRunDependencies(L);
        if (c.instantiateWasm)
          try {
            return c.instantiateWasm(e, a);
          } catch (g) {
            return y("Module.instantiateWasm callback failed with error: " + g), !1;
          }
        (function () {
          if (
            A ||
            "function" !== typeof WebAssembly.instantiateStreaming ||
            ta() ||
            "function" !== typeof fetch
          )
            return d(b);
          fetch(O, { credentials: "same-origin" }).then(function (a) {
            return WebAssembly.instantiateStreaming(a, e).then(b, function (a) {
              y("wasm streaming compile failed: " + a);
              y("falling back to ArrayBuffer instantiation");
              d(b);
            });
          });
        })();
        return {};
      })();
    c.asm = Ha;
    var ya = (c.___wasm_call_ctors = function () {
      return (ya = c.___wasm_call_ctors = c.asm.p).apply(null, arguments);
    });
    c._convert_glsl_to_spirv = function () {
      return (c._convert_glsl_to_spirv = c.asm.q).apply(null, arguments);
    };
    c._destroy_output_buffer = function () {
      return (c._destroy_output_buffer = c.asm.r).apply(null, arguments);
    };
    c._malloc = function () {
      return (c._malloc = c.asm.s).apply(null, arguments);
    };
    var Fa = (c._free = function () {
        return (Fa = c._free = c.asm.t).apply(null, arguments);
      }),
      ja = (c.stackSave = function () {
        return (ja = c.stackSave = c.asm.u).apply(null, arguments);
      }),
      G = (c.stackAlloc = function () {
        return (G = c.stackAlloc = c.asm.v).apply(null, arguments);
      }),
      ka = (c.stackRestore = function () {
        return (ka = c.stackRestore = c.asm.w).apply(null, arguments);
      });
    c.dynCall_vi = function () {
      return (c.dynCall_vi = c.asm.x).apply(null, arguments);
    };
    c.dynCall_v = function () {
      return (c.dynCall_v = c.asm.y).apply(null, arguments);
    };
    c.asm = Ha;
    let Y;
    c.then = function (a) {
      if (Y) a(c);
      else {
        let b = c.onRuntimeInitialized;
        c.onRuntimeInitialized = function () {
          b && b();
          a(c);
        };
      }
      return c;
    };
    N = function Ia() {
      Y || Z();
      Y || (N = Ia);
    };
    function Z() {
      function a() {
        if (!Y && ((Y = !0), !fa)) {
          K(pa);
          K(qa);
          if (c.onRuntimeInitialized) c.onRuntimeInitialized();
          if (c.postRun)
            for ("function" === typeof c.postRun && (c.postRun = [c.postRun]); c.postRun.length; ) {
              let a = c.postRun.shift();
              ra.unshift(a);
            }
          K(ra);
        }
      }
      if (!(0 < L)) {
        if (c.preRun)
          for ("function" === typeof c.preRun && (c.preRun = [c.preRun]); c.preRun.length; ) sa();
        K(oa);
        0 < L ||
          (c.setStatus
            ? (c.setStatus("Running..."),
              setTimeout(function () {
                setTimeout(function () {
                  c.setStatus("");
                }, 1);
                a();
              }, 1))
            : a());
      }
    }
    c.run = Z;
    if (c.preInit)
      for ("function" === typeof c.preInit && (c.preInit = [c.preInit]); 0 < c.preInit.length; )
        c.preInit.pop()();
    Z();

    return Module;
  };
})();
if (typeof exports === "object" && typeof module === "object") module.exports = Module;
else if (typeof define === "function" && define["amd"])
  define([], function () {
    return Module;
  });
else if (typeof exports === "object") exports["Module"] = Module;
export default (() => {
  const initialize = () => {
    return new Promise((resolve) => {
      Module({
        locateFile() {
          const i = import.meta.url.lastIndexOf("/");
          return import.meta.url.substring(0, i) + "/glslang.wasm";
        },
        onRuntimeInitialized() {
          resolve({
            compileGLSLZeroCopy: this.compileGLSLZeroCopy,
            compileGLSL: this.compileGLSL,
          });
        },
      });
    });
  };

  let instance;
  return () => {
    if (!instance) {
      instance = initialize();
    }
    return instance;
  };
})();
", "let Module = function (Module) {
  Module = Module || {};
  var Module = typeof Module !== "undefined" ? Module : {};
  let moduleOverrides = Object.assign({}, Module);
  let arguments_ = [];
  let thisProgram = "./this.program";
  let quit_ = (status, toThrow) => {
    throw toThrow;
  };
  let ENVIRONMENT_IS_WEB = typeof window === "object";
  let ENVIRONMENT_IS_WORKER = typeof importScripts === "function";
  let ENVIRONMENT_IS_NODE =
    typeof process === "object" &&
    typeof process.versions === "object" &&
    typeof process.versions.node === "string";
  let scriptDirectory = "";
  function locateFile(path) {
    if (Module["locateFile"]) {
      return Module["locateFile"](path, scriptDirectory);
    }
    return scriptDirectory + path;
  }
  let read_, readAsync, readBinary, setWindowTitle;
  function logExceptionOnExit(e) {
    if (e instanceof ExitStatus) return;
    let toLog = e;
    err("exiting due to exception: " + toLog);
  }
  if (ENVIRONMENT_IS_NODE) {
    if (ENVIRONMENT_IS_WORKER) {
      scriptDirectory = require("path").dirname(scriptDirectory) + "/";
    } else {
      scriptDirectory = __dirname + "/";
    }
    var fs, nodePath;
    if (typeof require === "function") {
      fs = require("fs");
      nodePath = require("path");
    }
    read_ = (filename, binary) => {
      filename = nodePath["normalize"](filename);
      return fs.readFileSync(filename, binary ? undefined : "utf8");
    };
    readBinary = (filename) => {
      let ret = read_(filename, true);
      if (!ret.buffer) {
        ret = new Uint8Array(ret);
      }
      return ret;
    };
    readAsync = (filename, onload, onerror) => {
      filename = nodePath["normalize"](filename);
      fs.readFile(filename, function (err, data) {
        if (err) onerror(err);
        else onload(data.buffer);
      });
    };
    if (process["argv"].length > 1) {
      thisProgram = process["argv"][1].replace(/\\/g, "/");
    }
    arguments_ = process["argv"].slice(2);
    if (typeof module !== "undefined") {
      module["exports"] = Module;
    }
    process["on"]("uncaughtException", function (ex) {
      if (!(ex instanceof ExitStatus)) {
        throw ex;
      }
    });
    process["on"]("unhandledRejection", function (reason) {
      throw reason;
    });
    quit_ = (status, toThrow) => {
      if (keepRuntimeAlive()) {
        process["exitCode"] = status;
        throw toThrow;
      }
      logExceptionOnExit(toThrow);
      process["exit"](status);
    };
    Module["inspect"] = function () {
      return "[Emscripten Module object]";
    };
  } else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
    if (ENVIRONMENT_IS_WORKER) {
      scriptDirectory = self.location.href;
    } else if (typeof document !== "undefined" && document.currentScript) {
      scriptDirectory = document.currentScript.src;
    }
    if (scriptDirectory.indexOf("blob:") !== 0) {
      scriptDirectory = scriptDirectory.substr(
        0,
        scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1,
      );
    } else {
      scriptDirectory = "";
    }
    {
      read_ = (url) => {
        let xhr = new XMLHttpRequest();
        xhr.open("GET", url, false);
        xhr.send(null);
        return xhr.responseText;
      };
      if (ENVIRONMENT_IS_WORKER) {
        readBinary = (url) => {
          let xhr = new XMLHttpRequest();
          xhr.open("GET", url, false);
          xhr.responseType = "arraybuffer";
          xhr.send(null);
          return new Uint8Array(xhr.response);
        };
      }
      readAsync = (url, onload, onerror) => {
        let xhr = new XMLHttpRequest();
        xhr.open("GET", url, true);
        xhr.responseType = "arraybuffer";
        xhr.onload = () => {
          if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) {
            onload(xhr.response);
            return;
          }
          onerror();
        };
        xhr.onerror = onerror;
        xhr.send(null);
      };
    }
    setWindowTitle = (title) => (document.title = title);
  } else {
  }
  let out = Module["print"] || console.log.bind(console);
  var err = Module["printErr"] || console.warn.bind(console);
  Object.assign(Module, moduleOverrides);
  moduleOverrides = null;
  if (Module["arguments"]) arguments_ = Module["arguments"];
  if (Module["thisProgram"]) thisProgram = Module["thisProgram"];
  if (Module["quit"]) quit_ = Module["quit"];
  let wasmBinary;
  if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"];
  let noExitRuntime = Module["noExitRuntime"] || true;
  if (typeof WebAssembly !== "object") {
    abort("no native wasm support detected");
  }
  let wasmMemory;
  let ABORT = false;
  let EXITSTATUS;
  function assert(condition, text) {
    if (!condition) {
      abort(text);
    }
  }
  let UTF8Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf8") : undefined;
  function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) {
    let endIdx = idx + maxBytesToRead;
    let endPtr = idx;
    while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr;
    if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
      return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
    }
    let str = "";
    while (idx < endPtr) {
      let u0 = heapOrArray[idx++];
      if (!(u0 & 128)) {
        str += String.fromCharCode(u0);
        continue;
      }
      let u1 = heapOrArray[idx++] & 63;
      if ((u0 & 224) == 192) {
        str += String.fromCharCode(((u0 & 31) << 6) | u1);
        continue;
      }
      let u2 = heapOrArray[idx++] & 63;
      if ((u0 & 240) == 224) {
        u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
      } else {
        u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63);
      }
      if (u0 < 65536) {
        str += String.fromCharCode(u0);
      } else {
        let ch = u0 - 65536;
        str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023));
      }
    }
    return str;
  }
  function UTF8ToString(ptr, maxBytesToRead) {
    return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
  }
  function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) {
    if (!(maxBytesToWrite > 0)) return 0;
    let startIdx = outIdx;
    let endIdx = outIdx + maxBytesToWrite - 1;
    for (let i = 0; i < str.length; ++i) {
      let u = str.charCodeAt(i);
      if (u >= 55296 && u <= 57343) {
        let u1 = str.charCodeAt(++i);
        u = (65536 + ((u & 1023) << 10)) | (u1 & 1023);
      }
      if (u <= 127) {
        if (outIdx >= endIdx) break;
        heap[outIdx++] = u;
      } else if (u <= 2047) {
        if (outIdx + 1 >= endIdx) break;
        heap[outIdx++] = 192 | (u >> 6);
        heap[outIdx++] = 128 | (u & 63);
      } else if (u <= 65535) {
        if (outIdx + 2 >= endIdx) break;
        heap[outIdx++] = 224 | (u >> 12);
        heap[outIdx++] = 128 | ((u >> 6) & 63);
        heap[outIdx++] = 128 | (u & 63);
      } else {
        if (outIdx + 3 >= endIdx) break;
        heap[outIdx++] = 240 | (u >> 18);
        heap[outIdx++] = 128 | ((u >> 12) & 63);
        heap[outIdx++] = 128 | ((u >> 6) & 63);
        heap[outIdx++] = 128 | (u & 63);
      }
    }
    heap[outIdx] = 0;
    return outIdx - startIdx;
  }
  function lengthBytesUTF8(str) {
    let len = 0;
    for (let i = 0; i < str.length; ++i) {
      let c = str.charCodeAt(i);
      if (c <= 127) {
        len++;
      } else if (c <= 2047) {
        len += 2;
      } else if (c >= 55296 && c <= 57343) {
        len += 4;
        ++i;
      } else {
        len += 3;
      }
    }
    return len;
  }
  let buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
  function updateGlobalBufferAndViews(buf) {
    buffer = buf;
    Module["HEAP8"] = HEAP8 = new Int8Array(buf);
    Module["HEAP16"] = HEAP16 = new Int16Array(buf);
    Module["HEAP32"] = HEAP32 = new Int32Array(buf);
    Module["HEAPU8"] = HEAPU8 = new Uint8Array(buf);
    Module["HEAPU16"] = HEAPU16 = new Uint16Array(buf);
    Module["HEAPU32"] = HEAPU32 = new Uint32Array(buf);
    Module["HEAPF32"] = HEAPF32 = new Float32Array(buf);
    Module["HEAPF64"] = HEAPF64 = new Float64Array(buf);
  }
  let INITIAL_MEMORY = Module["INITIAL_MEMORY"] || 16777216;
  let wasmTable;
  let __ATPRERUN__ = [];
  let __ATINIT__ = [];
  let __ATPOSTRUN__ = [];
  let runtimeInitialized = false;
  function keepRuntimeAlive() {
    return noExitRuntime;
  }
  function preRun() {
    if (Module["preRun"]) {
      if (typeof Module["preRun"] === "function") Module["preRun"] = [Module["preRun"]];
      while (Module["preRun"].length) {
        addOnPreRun(Module["preRun"].shift());
      }
    }
    callRuntimeCallbacks(__ATPRERUN__);
  }
  function initRuntime() {
    runtimeInitialized = true;
    if (!Module["noFSInit"] && !FS.init.initialized) FS.init();
    FS.ignorePermissions = false;
    TTY.init();
    callRuntimeCallbacks(__ATINIT__);
  }
  function postRun() {
    if (Module["postRun"]) {
      if (typeof Module["postRun"] === "function") Module["postRun"] = [Module["postRun"]];
      while (Module["postRun"].length) {
        addOnPostRun(Module["postRun"].shift());
      }
    }
    callRuntimeCallbacks(__ATPOSTRUN__);
  }
  function addOnPreRun(cb) {
    __ATPRERUN__.unshift(cb);
  }
  function addOnInit(cb) {
    __ATINIT__.unshift(cb);
  }
  function addOnPostRun(cb) {
    __ATPOSTRUN__.unshift(cb);
  }
  let runDependencies = 0;
  let runDependencyWatcher = null;
  let dependenciesFulfilled = null;
  function getUniqueRunDependency(id) {
    return id;
  }
  function addRunDependency(id) {
    runDependencies++;
    if (Module["monitorRunDependencies"]) {
      Module["monitorRunDependencies"](runDependencies);
    }
  }
  function removeRunDependency(id) {
    runDependencies--;
    if (Module["monitorRunDependencies"]) {
      Module["monitorRunDependencies"](runDependencies);
    }
    if (runDependencies == 0) {
      if (runDependencyWatcher !== null) {
        clearInterval(runDependencyWatcher);
        runDependencyWatcher = null;
      }
      if (dependenciesFulfilled) {
        let callback = dependenciesFulfilled;
        dependenciesFulfilled = null;
        callback();
      }
    }
  }
  function abort(what) {
    {
      if (Module["onAbort"]) {
        Module["onAbort"](what);
      }
    }
    what = "Aborted(" + what + ")";
    err(what);
    ABORT = true;
    EXITSTATUS = 1;
    what += ". Build with -sASSERTIONS for more info.";
    let e = new WebAssembly.RuntimeError(what);
    throw e;
  }
  let dataURIPrefix = "data:application/octet-stream;base64,";
  function isDataURI(filename) {
    return filename.startsWith(dataURIPrefix);
  }
  function isFileURI(filename) {
    return filename.startsWith("file://");
  }
  let wasmBinaryFile;
  wasmBinaryFile = "data:application/octet-stream;base64,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";
  if (!isDataURI(wasmBinaryFile)) {
    wasmBinaryFile = locateFile(wasmBinaryFile);
  }
  function getBinary(file) {
    try {
      if (file == wasmBinaryFile && wasmBinary) {
        return new Uint8Array(wasmBinary);
      }
      if (readBinary) {
        return readBinary(file);
      }
      throw "both async and sync fetching of the wasm failed";
    } catch (err) {
      abort(err);
    }
  }
  function getBinaryPromise() {
    if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
      if (typeof fetch === "function" && !isFileURI(wasmBinaryFile)) {
        return fetch(wasmBinaryFile, { credentials: "same-origin" })
          .then(function (response) {
            if (!response["ok"]) {
              throw "failed to load wasm binary file at '" + wasmBinaryFile + "'";
            }
            return response["arrayBuffer"]();
          })
          .catch(function () {
            return getBinary(wasmBinaryFile);
          });
      } else {
        if (readAsync) {
          return new Promise(function (resolve, reject) {
            readAsync(
              wasmBinaryFile,
              function (response) {
                resolve(new Uint8Array(response));
              },
              reject,
            );
          });
        }
      }
    }
    return Promise.resolve().then(function () {
      return getBinary(wasmBinaryFile);
    });
  }
  function createWasm() {
    let info = { a: asmLibraryArg };
    function receiveInstance(instance, module) {
      let exports = instance.exports;
      Module["asm"] = exports;
      wasmMemory = Module["asm"]["o"];
      updateGlobalBufferAndViews(wasmMemory.buffer);
      wasmTable = Module["asm"]["s"];
      addOnInit(Module["asm"]["p"]);
      removeRunDependency("wasm-instantiate");
    }
    addRunDependency("wasm-instantiate");
    function receiveInstantiationResult(result) {
      receiveInstance(result["instance"]);
    }
    function instantiateArrayBuffer(receiver) {
      return getBinaryPromise()
        .then(function (binary) {
          return WebAssembly.instantiate(binary, info);
        })
        .then(function (instance) {
          return instance;
        })
        .then(receiver, function (reason) {
          err("failed to asynchronously prepare wasm: " + reason);
          abort(reason);
        });
    }
    function instantiateAsync() {
      if (
        !wasmBinary &&
        typeof WebAssembly.instantiateStreaming === "function" &&
        !isDataURI(wasmBinaryFile) &&
        !isFileURI(wasmBinaryFile) &&
        !ENVIRONMENT_IS_NODE &&
        typeof fetch === "function"
      ) {
        return fetch(wasmBinaryFile, { credentials: "same-origin" }).then(function (response) {
          let result = WebAssembly.instantiateStreaming(response, info);
          return result.then(receiveInstantiationResult, function (reason) {
            err("wasm streaming compile failed: " + reason);
            err("falling back to ArrayBuffer instantiation");
            return instantiateArrayBuffer(receiveInstantiationResult);
          });
        });
      } else {
        return instantiateArrayBuffer(receiveInstantiationResult);
      }
    }
    if (Module["instantiateWasm"]) {
      try {
        let exports = Module["instantiateWasm"](info, receiveInstance);
        return exports;
      } catch (e) {
        err("Module.instantiateWasm callback failed with error: " + e);
        return false;
      }
    }
    instantiateAsync();
    return {};
  }
  let tempDouble;
  let tempI64;
  function ExitStatus(status) {
    this.name = "ExitStatus";
    this.message = "Program terminated with exit(" + status + ")";
    this.status = status;
  }
  function callRuntimeCallbacks(callbacks) {
    while (callbacks.length > 0) {
      callbacks.shift()(Module);
    }
  }
  function ___assert_fail(condition, filename, line, func) {
    abort(
      "Assertion failed: " +
        UTF8ToString(condition) +
        ", at: " +
        [
          filename ? UTF8ToString(filename) : "unknown filename",
          line,
          func ? UTF8ToString(func) : "unknown function",
        ],
    );
  }
  function ___cxa_allocate_exception(size) {
    return _malloc(size + 24) + 24;
  }
  function ExceptionInfo(excPtr) {
    this.excPtr = excPtr;
    this.ptr = excPtr - 24;
    this.set_type = function (type) {
      HEAPU32[(this.ptr + 4) >> 2] = type;
    };
    this.get_type = function () {
      return HEAPU32[(this.ptr + 4) >> 2];
    };
    this.set_destructor = function (destructor) {
      HEAPU32[(this.ptr + 8) >> 2] = destructor;
    };
    this.get_destructor = function () {
      return HEAPU32[(this.ptr + 8) >> 2];
    };
    this.set_refcount = function (refcount) {
      HEAP32[this.ptr >> 2] = refcount;
    };
    this.set_caught = function (caught) {
      caught = caught ? 1 : 0;
      HEAP8[(this.ptr + 12) >> 0] = caught;
    };
    this.get_caught = function () {
      return HEAP8[(this.ptr + 12) >> 0] != 0;
    };
    this.set_rethrown = function (rethrown) {
      rethrown = rethrown ? 1 : 0;
      HEAP8[(this.ptr + 13) >> 0] = rethrown;
    };
    this.get_rethrown = function () {
      return HEAP8[(this.ptr + 13) >> 0] != 0;
    };
    this.init = function (type, destructor) {
      this.set_adjusted_ptr(0);
      this.set_type(type);
      this.set_destructor(destructor);
      this.set_refcount(0);
      this.set_caught(false);
      this.set_rethrown(false);
    };
    this.add_ref = function () {
      let value = HEAP32[this.ptr >> 2];
      HEAP32[this.ptr >> 2] = value + 1;
    };
    this.release_ref = function () {
      let prev = HEAP32[this.ptr >> 2];
      HEAP32[this.ptr >> 2] = prev - 1;
      return prev === 1;
    };
    this.set_adjusted_ptr = function (adjustedPtr) {
      HEAPU32[(this.ptr + 16) >> 2] = adjustedPtr;
    };
    this.get_adjusted_ptr = function () {
      return HEAPU32[(this.ptr + 16) >> 2];
    };
    this.get_exception_ptr = function () {
      let isPointer = ___cxa_is_pointer_type(this.get_type());
      if (isPointer) {
        return HEAPU32[this.excPtr >> 2];
      }
      let adjusted = this.get_adjusted_ptr();
      if (adjusted !== 0) return adjusted;
      return this.excPtr;
    };
  }
  let exceptionLast = 0;
  let uncaughtExceptionCount = 0;
  function ___cxa_throw(ptr, type, destructor) {
    let info = new ExceptionInfo(ptr);
    info.init(type, destructor);
    exceptionLast = ptr;
    uncaughtExceptionCount++;
    throw ptr;
  }
  function _abort() {
    abort("");
  }
  function getHeapMax() {
    return 2147483648;
  }
  function emscripten_realloc_buffer(size) {
    try {
      wasmMemory.grow((size - buffer.byteLength + 65535) >>> 16);
      updateGlobalBufferAndViews(wasmMemory.buffer);
      return 1;
    } catch (e) {}
  }
  function _emscripten_resize_heap(requestedSize) {
    let oldSize = HEAPU8.length;
    requestedSize = requestedSize >>> 0;
    let maxHeapSize = getHeapMax();
    if (requestedSize > maxHeapSize) {
      return false;
    }
    let alignUp = (x, multiple) => x + ((multiple - (x % multiple)) % multiple);
    for (let cutDown = 1; cutDown <= 4; cutDown *= 2) {
      let overGrownHeapSize = oldSize * (1 + 0.2 / cutDown);
      overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
      let newSize = Math.min(
        maxHeapSize,
        alignUp(Math.max(requestedSize, overGrownHeapSize), 65536),
      );
      let replacement = emscripten_realloc_buffer(newSize);
      if (replacement) {
        return true;
      }
    }
    return false;
  }
  let ENV = {};
  function getExecutableName() {
    return thisProgram || "./this.program";
  }
  function getEnvStrings() {
    if (!getEnvStrings.strings) {
      let lang =
        (
          (typeof navigator === "object" && navigator.languages && navigator.languages[0]) ||
          "C"
        ).replace("-", "_") + ".UTF-8";
      let env = {
        USER: "web_user",
        LOGNAME: "web_user",
        PATH: "/",
        PWD: "/",
        HOME: "/home/web_user",
        LANG: lang,
        _: getExecutableName(),
      };
      for (var x in ENV) {
        if (ENV[x] === undefined) delete env[x];
        else env[x] = ENV[x];
      }
      let strings = [];
      for (var x in env) {
        strings.push(x + "=" + env[x]);
      }
      getEnvStrings.strings = strings;
    }
    return getEnvStrings.strings;
  }
  function writeAsciiToMemory(str, buffer, dontAddNull) {
    for (let i = 0; i < str.length; ++i) {
      HEAP8[buffer++ >> 0] = str.charCodeAt(i);
    }
    if (!dontAddNull) HEAP8[buffer >> 0] = 0;
  }
  var PATH = {
    isAbs: (path) => path.charAt(0) === "/",
    splitPath: (filename) => {
      let splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
      return splitPathRe.exec(filename).slice(1);
    },
    normalizeArray: (parts, allowAboveRoot) => {
      let up = 0;
      for (let i = parts.length - 1; i >= 0; i--) {
        let last = parts[i];
        if (last === ".") {
          parts.splice(i, 1);
        } else if (last === "..") {
          parts.splice(i, 1);
          up++;
        } else if (up) {
          parts.splice(i, 1);
          up--;
        }
      }
      if (allowAboveRoot) {
        for (; up; up--) {
          parts.unshift("..");
        }
      }
      return parts;
    },
    normalize: (path) => {
      let isAbsolute = PATH.isAbs(path),
        trailingSlash = path.substr(-1) === "/";
      path = PATH.normalizeArray(
        path.split("/").filter((p) => !!p),
        !isAbsolute,
      ).join("/");
      if (!path && !isAbsolute) {
        path = ".";
      }
      if (path && trailingSlash) {
        path += "/";
      }
      return (isAbsolute ? "/" : "") + path;
    },
    dirname: (path) => {
      let result = PATH.splitPath(path),
        root = result[0],
        dir = result[1];
      if (!root && !dir) {
        return ".";
      }
      if (dir) {
        dir = dir.substr(0, dir.length - 1);
      }
      return root + dir;
    },
    basename: (path) => {
      if (path === "/") return "/";
      path = PATH.normalize(path);
      path = path.replace(/\/$/, "");
      let lastSlash = path.lastIndexOf("/");
      if (lastSlash === -1) return path;
      return path.substr(lastSlash + 1);
    },
    join() {
      let paths = Array.prototype.slice.call(arguments);
      return PATH.normalize(paths.join("/"));
    },
    join2: (l, r) => {
      return PATH.normalize(l + "/" + r);
    },
  };
  function getRandomDevice() {
    if (typeof crypto === "object" && typeof crypto["getRandomValues"] === "function") {
      let randomBuffer = new Uint8Array(1);
      return () => {
        crypto.getRandomValues(randomBuffer);
        return randomBuffer[0];
      };
    } else if (ENVIRONMENT_IS_NODE) {
      try {
        let crypto_module = require("crypto");
        return () => crypto_module["randomBytes"](1)[0];
      } catch (e) {}
    }
    return () => abort("randomDevice");
  }
  var PATH_FS = {
    resolve() {
      let resolvedPath = "",
        resolvedAbsolute = false;
      for (let i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
        let path = i >= 0 ? arguments[i] : FS.cwd();
        if (typeof path !== "string") {
          throw new TypeError("Arguments to path.resolve must be strings");
        } else if (!path) {
          return "";
        }
        resolvedPath = path + "/" + resolvedPath;
        resolvedAbsolute = PATH.isAbs(path);
      }
      resolvedPath = PATH.normalizeArray(
        resolvedPath.split("/").filter((p) => !!p),
        !resolvedAbsolute,
      ).join("/");
      return (resolvedAbsolute ? "/" : "") + resolvedPath || ".";
    },
    relative: (from, to) => {
      from = PATH_FS.resolve(from).substr(1);
      to = PATH_FS.resolve(to).substr(1);
      function trim(arr) {
        let start = 0;
        for (; start < arr.length; start++) {
          if (arr[start] !== "") break;
        }
        let end = arr.length - 1;
        for (; end >= 0; end--) {
          if (arr[end] !== "") break;
        }
        if (start > end) return [];
        return arr.slice(start, end - start + 1);
      }
      let fromParts = trim(from.split("/"));
      let toParts = trim(to.split("/"));
      let length = Math.min(fromParts.length, toParts.length);
      let samePartsLength = length;
      for (var i = 0; i < length; i++) {
        if (fromParts[i] !== toParts[i]) {
          samePartsLength = i;
          break;
        }
      }
      let outputParts = [];
      for (var i = samePartsLength; i < fromParts.length; i++) {
        outputParts.push("..");
      }
      outputParts = outputParts.concat(toParts.slice(samePartsLength));
      return outputParts.join("/");
    },
  };
  function intArrayFromString(stringy, dontAddNull, length) {
    let len = length > 0 ? length : lengthBytesUTF8(stringy) + 1;
    let u8array = new Array(len);
    let numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length);
    if (dontAddNull) u8array.length = numBytesWritten;
    return u8array;
  }
  var TTY = {
    ttys: [],
    init() {},
    shutdown() {},
    register(dev, ops) {
      TTY.ttys[dev] = { input: [], output: [], ops };
      FS.registerDevice(dev, TTY.stream_ops);
    },
    stream_ops: {
      open(stream) {
        let tty = TTY.ttys[stream.node.rdev];
        if (!tty) {
          throw new FS.ErrnoError(43);
        }
        stream.tty = tty;
        stream.seekable = false;
      },
      close(stream) {
        stream.tty.ops.fsync(stream.tty);
      },
      fsync(stream) {
        stream.tty.ops.fsync(stream.tty);
      },
      read(stream, buffer, offset, length, pos) {
        if (!stream.tty || !stream.tty.ops.get_char) {
          throw new FS.ErrnoError(60);
        }
        let bytesRead = 0;
        for (let i = 0; i < length; i++) {
          var result;
          try {
            result = stream.tty.ops.get_char(stream.tty);
          } catch (e) {
            throw new FS.ErrnoError(29);
          }
          if (result === undefined && bytesRead === 0) {
            throw new FS.ErrnoError(6);
          }
          if (result === null || result === undefined) break;
          bytesRead++;
          buffer[offset + i] = result;
        }
        if (bytesRead) {
          stream.node.timestamp = Date.now();
        }
        return bytesRead;
      },
      write(stream, buffer, offset, length, pos) {
        if (!stream.tty || !stream.tty.ops.put_char) {
          throw new FS.ErrnoError(60);
        }
        try {
          for (var i = 0; i < length; i++) {
            stream.tty.ops.put_char(stream.tty, buffer[offset + i]);
          }
        } catch (e) {
          throw new FS.ErrnoError(29);
        }
        if (length) {
          stream.node.timestamp = Date.now();
        }
        return i;
      },
    },
    default_tty_ops: {
      get_char(tty) {
        if (!tty.input.length) {
          let result = null;
          if (ENVIRONMENT_IS_NODE) {
            let BUFSIZE = 256;
            let buf = Buffer.alloc(BUFSIZE);
            let bytesRead = 0;
            try {
              bytesRead = fs.readSync(process.stdin.fd, buf, 0, BUFSIZE, -1);
            } catch (e) {
              if (e.toString().includes("EOF")) bytesRead = 0;
              else throw e;
            }
            if (bytesRead > 0) {
              result = buf.slice(0, bytesRead).toString("utf-8");
            } else {
              result = null;
            }
          } else if (typeof window !== "undefined" && typeof window.prompt === "function") {
            result = window.prompt("Input: ");
            if (result !== null) {
              result += "\n";
            }
          } else if (typeof readline === "function") {
            result = readline();
            if (result !== null) {
              result += "\n";
            }
          }
          if (!result) {
            return null;
          }
          tty.input = intArrayFromString(result, true);
        }
        return tty.input.shift();
      },
      put_char(tty, val) {
        if (val === null || val === 10) {
          out(UTF8ArrayToString(tty.output, 0));
          tty.output = [];
        } else {
          if (val != 0) tty.output.push(val);
        }
      },
      fsync(tty) {
        if (tty.output && tty.output.length > 0) {
          out(UTF8ArrayToString(tty.output, 0));
          tty.output = [];
        }
      },
    },
    default_tty1_ops: {
      put_char(tty, val) {
        if (val === null || val === 10) {
          err(UTF8ArrayToString(tty.output, 0));
          tty.output = [];
        } else {
          if (val != 0) tty.output.push(val);
        }
      },
      fsync(tty) {
        if (tty.output && tty.output.length > 0) {
          err(UTF8ArrayToString(tty.output, 0));
          tty.output = [];
        }
      },
    },
  };
  function mmapAlloc(size) {
    abort();
  }
  var MEMFS = {
    ops_table: null,
    mount(mount) {
      return MEMFS.createNode(null, "/", 16384 | 511, 0);
    },
    createNode(parent, name, mode, dev) {
      if (FS.isBlkdev(mode) || FS.isFIFO(mode)) {
        throw new FS.ErrnoError(63);
      }
      if (!MEMFS.ops_table) {
        MEMFS.ops_table = {
          dir: {
            node: {
              getattr: MEMFS.node_ops.getattr,
              setattr: MEMFS.node_ops.setattr,
              lookup: MEMFS.node_ops.lookup,
              mknod: MEMFS.node_ops.mknod,
              rename: MEMFS.node_ops.rename,
              unlink: MEMFS.node_ops.unlink,
              rmdir: MEMFS.node_ops.rmdir,
              readdir: MEMFS.node_ops.readdir,
              symlink: MEMFS.node_ops.symlink,
            },
            stream: { llseek: MEMFS.stream_ops.llseek },
          },
          file: {
            node: { getattr: MEMFS.node_ops.getattr, setattr: MEMFS.node_ops.setattr },
            stream: {
              llseek: MEMFS.stream_ops.llseek,
              read: MEMFS.stream_ops.read,
              write: MEMFS.stream_ops.write,
              allocate: MEMFS.stream_ops.allocate,
              mmap: MEMFS.stream_ops.mmap,
              msync: MEMFS.stream_ops.msync,
            },
          },
          link: {
            node: {
              getattr: MEMFS.node_ops.getattr,
              setattr: MEMFS.node_ops.setattr,
              readlink: MEMFS.node_ops.readlink,
            },
            stream: {},
          },
          chrdev: {
            node: { getattr: MEMFS.node_ops.getattr, setattr: MEMFS.node_ops.setattr },
            stream: FS.chrdev_stream_ops,
          },
        };
      }
      let node = FS.createNode(parent, name, mode, dev);
      if (FS.isDir(node.mode)) {
        node.node_ops = MEMFS.ops_table.dir.node;
        node.stream_ops = MEMFS.ops_table.dir.stream;
        node.contents = {};
      } else if (FS.isFile(node.mode)) {
        node.node_ops = MEMFS.ops_table.file.node;
        node.stream_ops = MEMFS.ops_table.file.stream;
        node.usedBytes = 0;
        node.contents = null;
      } else if (FS.isLink(node.mode)) {
        node.node_ops = MEMFS.ops_table.link.node;
        node.stream_ops = MEMFS.ops_table.link.stream;
      } else if (FS.isChrdev(node.mode)) {
        node.node_ops = MEMFS.ops_table.chrdev.node;
        node.stream_ops = MEMFS.ops_table.chrdev.stream;
      }
      node.timestamp = Date.now();
      if (parent) {
        parent.contents[name] = node;
        parent.timestamp = node.timestamp;
      }
      return node;
    },
    getFileDataAsTypedArray(node) {
      if (!node.contents) return new Uint8Array(0);
      if (node.contents.subarray) return node.contents.subarray(0, node.usedBytes);
      return new Uint8Array(node.contents);
    },
    expandFileStorage(node, newCapacity) {
      let prevCapacity = node.contents ? node.contents.length : 0;
      if (prevCapacity >= newCapacity) return;
      let CAPACITY_DOUBLING_MAX = 1024 * 1024;
      newCapacity = Math.max(
        newCapacity,
        (prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2 : 1.125)) >>> 0,
      );
      if (prevCapacity != 0) newCapacity = Math.max(newCapacity, 256);
      let oldContents = node.contents;
      node.contents = new Uint8Array(newCapacity);
      if (node.usedBytes > 0) node.contents.set(oldContents.subarray(0, node.usedBytes), 0);
    },
    resizeFileStorage(node, newSize) {
      if (node.usedBytes == newSize) return;
      if (newSize == 0) {
        node.contents = null;
        node.usedBytes = 0;
      } else {
        let oldContents = node.contents;
        node.contents = new Uint8Array(newSize);
        if (oldContents) {
          node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes)));
        }
        node.usedBytes = newSize;
      }
    },
    node_ops: {
      getattr(node) {
        let attr = {};
        attr.dev = FS.isChrdev(node.mode) ? node.id : 1;
        attr.ino = node.id;
        attr.mode = node.mode;
        attr.nlink = 1;
        attr.uid = 0;
        attr.gid = 0;
        attr.rdev = node.rdev;
        if (FS.isDir(node.mode)) {
          attr.size = 4096;
        } else if (FS.isFile(node.mode)) {
          attr.size = node.usedBytes;
        } else if (FS.isLink(node.mode)) {
          attr.size = node.link.length;
        } else {
          attr.size = 0;
        }
        attr.atime = new Date(node.timestamp);
        attr.mtime = new Date(node.timestamp);
        attr.ctime = new Date(node.timestamp);
        attr.blksize = 4096;
        attr.blocks = Math.ceil(attr.size / attr.blksize);
        return attr;
      },
      setattr(node, attr) {
        if (attr.mode !== undefined) {
          node.mode = attr.mode;
        }
        if (attr.timestamp !== undefined) {
          node.timestamp = attr.timestamp;
        }
        if (attr.size !== undefined) {
          MEMFS.resizeFileStorage(node, attr.size);
        }
      },
      lookup(parent, name) {
        throw FS.genericErrors[44];
      },
      mknod(parent, name, mode, dev) {
        return MEMFS.createNode(parent, name, mode, dev);
      },
      rename(old_node, new_dir, new_name) {
        if (FS.isDir(old_node.mode)) {
          let new_node;
          try {
            new_node = FS.lookupNode(new_dir, new_name);
          } catch (e) {}
          if (new_node) {
            for (let i in new_node.contents) {
              throw new FS.ErrnoError(55);
            }
          }
        }
        delete old_node.parent.contents[old_node.name];
        old_node.parent.timestamp = Date.now();
        old_node.name = new_name;
        new_dir.contents[new_name] = old_node;
        new_dir.timestamp = old_node.parent.timestamp;
        old_node.parent = new_dir;
      },
      unlink(parent, name) {
        delete parent.contents[name];
        parent.timestamp = Date.now();
      },
      rmdir(parent, name) {
        let node = FS.lookupNode(parent, name);
        for (let i in node.contents) {
          throw new FS.ErrnoError(55);
        }
        delete parent.contents[name];
        parent.timestamp = Date.now();
      },
      readdir(node) {
        let entries = [".", ".."];
        for (let key in node.contents) {
          if (!node.contents.hasOwnProperty(key)) {
            continue;
          }
          entries.push(key);
        }
        return entries;
      },
      symlink(parent, newname, oldpath) {
        let node = MEMFS.createNode(parent, newname, 511 | 40960, 0);
        node.link = oldpath;
        return node;
      },
      readlink(node) {
        if (!FS.isLink(node.mode)) {
          throw new FS.ErrnoError(28);
        }
        return node.link;
      },
    },
    stream_ops: {
      read(stream, buffer, offset, length, position) {
        let contents = stream.node.contents;
        if (position >= stream.node.usedBytes) return 0;
        let size = Math.min(stream.node.usedBytes - position, length);
        if (size > 8 && contents.subarray) {
          buffer.set(contents.subarray(position, position + size), offset);
        } else {
          for (let i = 0; i < size; i++) buffer[offset + i] = contents[position + i];
        }
        return size;
      },
      write(stream, buffer, offset, length, position, canOwn) {
        if (buffer.buffer === HEAP8.buffer) {
          canOwn = false;
        }
        if (!length) return 0;
        let node = stream.node;
        node.timestamp = Date.now();
        if (buffer.subarray && (!node.contents || node.contents.subarray)) {
          if (canOwn) {
            node.contents = buffer.subarray(offset, offset + length);
            node.usedBytes = length;
            return length;
          } else if (node.usedBytes === 0 && position === 0) {
            node.contents = buffer.slice(offset, offset + length);
            node.usedBytes = length;
            return length;
          } else if (position + length <= node.usedBytes) {
            node.contents.set(buffer.subarray(offset, offset + length), position);
            return length;
          }
        }
        MEMFS.expandFileStorage(node, position + length);
        if (node.contents.subarray && buffer.subarray) {
          node.contents.set(buffer.subarray(offset, offset + length), position);
        } else {
          for (let i = 0; i < length; i++) {
            node.contents[position + i] = buffer[offset + i];
          }
        }
        node.usedBytes = Math.max(node.usedBytes, position + length);
        return length;
      },
      llseek(stream, offset, whence) {
        let position = offset;
        if (whence === 1) {
          position += stream.position;
        } else if (whence === 2) {
          if (FS.isFile(stream.node.mode)) {
            position += stream.node.usedBytes;
          }
        }
        if (position < 0) {
          throw new FS.ErrnoError(28);
        }
        return position;
      },
      allocate(stream, offset, length) {
        MEMFS.expandFileStorage(stream.node, offset + length);
        stream.node.usedBytes = Math.max(stream.node.usedBytes, offset + length);
      },
      mmap(stream, length, position, prot, flags) {
        if (!FS.isFile(stream.node.mode)) {
          throw new FS.ErrnoError(43);
        }
        let ptr;
        let allocated;
        let contents = stream.node.contents;
        if (!(flags & 2) && contents.buffer === buffer) {
          allocated = false;
          ptr = contents.byteOffset;
        } else {
          if (position > 0 || position + length < contents.length) {
            if (contents.subarray) {
              contents = contents.subarray(position, position + length);
            } else {
              contents = Array.prototype.slice.call(contents, position, position + length);
            }
          }
          allocated = true;
          ptr = mmapAlloc(length);
          if (!ptr) {
            throw new FS.ErrnoError(48);
          }
          HEAP8.set(contents, ptr);
        }
        return { ptr, allocated };
      },
      msync(stream, buffer, offset, length, mmapFlags) {
        MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false);
        return 0;
      },
    },
  };
  function asyncLoad(url, onload, onerror, noRunDep) {
    let dep = !noRunDep ? getUniqueRunDependency("al " + url) : "";
    readAsync(
      url,
      (arrayBuffer) => {
        assert(arrayBuffer, 'Loading data file "' + url + '" failed (no arrayBuffer).');
        onload(new Uint8Array(arrayBuffer));
        if (dep) removeRunDependency(dep);
      },
      (event) => {
        if (onerror) {
          onerror();
        } else {
          throw 'Loading data file "' + url + '" failed.';
        }
      },
    );
    if (dep) addRunDependency(dep);
  }
  var FS = {
    root: null,
    mounts: [],
    devices: {},
    streams: [],
    nextInode: 1,
    nameTable: null,
    currentPath: "/",
    initialized: false,
    ignorePermissions: true,
    ErrnoError: null,
    genericErrors: {},
    filesystems: null,
    syncFSRequests: 0,
    lookupPath: (path, opts = {}) => {
      path = PATH_FS.resolve(FS.cwd(), path);
      if (!path) return { path: "", node: null };
      let defaults = { follow_mount: true, recurse_count: 0 };
      opts = Object.assign(defaults, opts);
      if (opts.recurse_count > 8) {
        throw new FS.ErrnoError(32);
      }
      let parts = PATH.normalizeArray(
        path.split("/").filter((p) => !!p),
        false,
      );
      let current = FS.root;
      let current_path = "/";
      for (let i = 0; i < parts.length; i++) {
        let islast = i === parts.length - 1;
        if (islast && opts.parent) {
          break;
        }
        current = FS.lookupNode(current, parts[i]);
        current_path = PATH.join2(current_path, parts[i]);
        if (FS.isMountpoint(current)) {
          if (!islast || (islast && opts.follow_mount)) {
            current = current.mounted.root;
          }
        }
        if (!islast || opts.follow) {
          let count = 0;
          while (FS.isLink(current.mode)) {
            let link = FS.readlink(current_path);
            current_path = PATH_FS.resolve(PATH.dirname(current_path), link);
            let lookup = FS.lookupPath(current_path, { recurse_count: opts.recurse_count + 1 });
            current = lookup.node;
            if (count++ > 40) {
              throw new FS.ErrnoError(32);
            }
          }
        }
      }
      return { path: current_path, node: current };
    },
    getPath: (node) => {
      let path;
      while (true) {
        if (FS.isRoot(node)) {
          let mount = node.mount.mountpoint;
          if (!path) return mount;
          return mount[mount.length - 1] !== "/" ? mount + "/" + path : mount + path;
        }
        path = path ? node.name + "/" + path : node.name;
        node = node.parent;
      }
    },
    hashName: (parentid, name) => {
      let hash = 0;
      for (let i = 0; i < name.length; i++) {
        hash = ((hash << 5) - hash + name.charCodeAt(i)) | 0;
      }
      return ((parentid + hash) >>> 0) % FS.nameTable.length;
    },
    hashAddNode: (node) => {
      let hash = FS.hashName(node.parent.id, node.name);
      node.name_next = FS.nameTable[hash];
      FS.nameTable[hash] = node;
    },
    hashRemoveNode: (node) => {
      let hash = FS.hashName(node.parent.id, node.name);
      if (FS.nameTable[hash] === node) {
        FS.nameTable[hash] = node.name_next;
      } else {
        let current = FS.nameTable[hash];
        while (current) {
          if (current.name_next === node) {
            current.name_next = node.name_next;
            break;
          }
          current = current.name_next;
        }
      }
    },
    lookupNode: (parent, name) => {
      let errCode = FS.mayLookup(parent);
      if (errCode) {
        throw new FS.ErrnoError(errCode, parent);
      }
      let hash = FS.hashName(parent.id, name);
      for (let node = FS.nameTable[hash]; node; node = node.name_next) {
        let nodeName = node.name;
        if (node.parent.id === parent.id && nodeName === name) {
          return node;
        }
      }
      return FS.lookup(parent, name);
    },
    createNode: (parent, name, mode, rdev) => {
      let node = new FS.FSNode(parent, name, mode, rdev);
      FS.hashAddNode(node);
      return node;
    },
    destroyNode: (node) => {
      FS.hashRemoveNode(node);
    },
    isRoot: (node) => {
      return node === node.parent;
    },
    isMountpoint: (node) => {
      return !!node.mounted;
    },
    isFile: (mode) => {
      return (mode & 61440) === 32768;
    },
    isDir: (mode) => {
      return (mode & 61440) === 16384;
    },
    isLink: (mode) => {
      return (mode & 61440) === 40960;
    },
    isChrdev: (mode) => {
      return (mode & 61440) === 8192;
    },
    isBlkdev: (mode) => {
      return (mode & 61440) === 24576;
    },
    isFIFO: (mode) => {
      return (mode & 61440) === 4096;
    },
    isSocket: (mode) => {
      return (mode & 49152) === 49152;
    },
    flagModes: { r: 0, "r+": 2, w: 577, "w+": 578, a: 1089, "a+": 1090 },
    modeStringToFlags: (str) => {
      let flags = FS.flagModes[str];
      if (typeof flags === "undefined") {
        throw new Error("Unknown file open mode: " + str);
      }
      return flags;
    },
    flagsToPermissionString: (flag) => {
      let perms = ["r", "w", "rw"][flag & 3];
      if (flag & 512) {
        perms += "w";
      }
      return perms;
    },
    nodePermissions: (node, perms) => {
      if (FS.ignorePermissions) {
        return 0;
      }
      if (perms.includes("r") && !(node.mode & 292)) {
        return 2;
      } else if (perms.includes("w") && !(node.mode & 146)) {
        return 2;
      } else if (perms.includes("x") && !(node.mode & 73)) {
        return 2;
      }
      return 0;
    },
    mayLookup: (dir) => {
      let errCode = FS.nodePermissions(dir, "x");
      if (errCode) return errCode;
      if (!dir.node_ops.lookup) return 2;
      return 0;
    },
    mayCreate: (dir, name) => {
      try {
        let node = FS.lookupNode(dir, name);
        return 20;
      } catch (e) {}
      return FS.nodePermissions(dir, "wx");
    },
    mayDelete: (dir, name, isdir) => {
      let node;
      try {
        node = FS.lookupNode(dir, name);
      } catch (e) {
        return e.errno;
      }
      let errCode = FS.nodePermissions(dir, "wx");
      if (errCode) {
        return errCode;
      }
      if (isdir) {
        if (!FS.isDir(node.mode)) {
          return 54;
        }
        if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) {
          return 10;
        }
      } else {
        if (FS.isDir(node.mode)) {
          return 31;
        }
      }
      return 0;
    },
    mayOpen: (node, flags) => {
      if (!node) {
        return 44;
      }
      if (FS.isLink(node.mode)) {
        return 32;
      } else if (FS.isDir(node.mode)) {
        if (FS.flagsToPermissionString(flags) !== "r" || flags & 512) {
          return 31;
        }
      }
      return FS.nodePermissions(node, FS.flagsToPermissionString(flags));
    },
    MAX_OPEN_FDS: 4096,
    nextfd: (fd_start = 0, fd_end = FS.MAX_OPEN_FDS) => {
      for (let fd = fd_start; fd <= fd_end; fd++) {
        if (!FS.streams[fd]) {
          return fd;
        }
      }
      throw new FS.ErrnoError(33);
    },
    getStream: (fd) => FS.streams[fd],
    createStream: (stream, fd_start, fd_end) => {
      if (!FS.FSStream) {
        FS.FSStream = function () {
          this.shared = {};
        };
        FS.FSStream.prototype = {};
        Object.defineProperties(FS.FSStream.prototype, {
          object: {
            get() {
              return this.node;
            },
            set(val) {
              this.node = val;
            },
          },
          isRead: {
            get() {
              return (this.flags & 2097155) !== 1;
            },
          },
          isWrite: {
            get() {
              return (this.flags & 2097155) !== 0;
            },
          },
          isAppend: {
            get() {
              return this.flags & 1024;
            },
          },
          flags: {
            get() {
              return this.shared.flags;
            },
            set(val) {
              this.shared.flags = val;
            },
          },
          position: {
            get() {
              return this.shared.position;
            },
            set(val) {
              this.shared.position = val;
            },
          },
        });
      }
      stream = Object.assign(new FS.FSStream(), stream);
      let fd = FS.nextfd(fd_start, fd_end);
      stream.fd = fd;
      FS.streams[fd] = stream;
      return stream;
    },
    closeStream: (fd) => {
      FS.streams[fd] = null;
    },
    chrdev_stream_ops: {
      open: (stream) => {
        let device = FS.getDevice(stream.node.rdev);
        stream.stream_ops = device.stream_ops;
        if (stream.stream_ops.open) {
          stream.stream_ops.open(stream);
        }
      },
      llseek: () => {
        throw new FS.ErrnoError(70);
      },
    },
    major: (dev) => dev >> 8,
    minor: (dev) => dev & 255,
    makedev: (ma, mi) => (ma << 8) | mi,
    registerDevice: (dev, ops) => {
      FS.devices[dev] = { stream_ops: ops };
    },
    getDevice: (dev) => FS.devices[dev],
    getMounts: (mount) => {
      let mounts = [];
      let check = [mount];
      while (check.length) {
        let m = check.pop();
        mounts.push(m);
        check.push.apply(check, m.mounts);
      }
      return mounts;
    },
    syncfs: (populate, callback) => {
      if (typeof populate === "function") {
        callback = populate;
        populate = false;
      }
      FS.syncFSRequests++;
      if (FS.syncFSRequests > 1) {
        err(
          "warning: " +
            FS.syncFSRequests +
            " FS.syncfs operations in flight at once, probably just doing extra work",
        );
      }
      let mounts = FS.getMounts(FS.root.mount);
      let completed = 0;
      function doCallback(errCode) {
        FS.syncFSRequests--;
        return callback(errCode);
      }
      function done(errCode) {
        if (errCode) {
          if (!done.errored) {
            done.errored = true;
            return doCallback(errCode);
          }
          return;
        }
        if (++completed >= mounts.length) {
          doCallback(null);
        }
      }
      mounts.forEach((mount) => {
        if (!mount.type.syncfs) {
          return done(null);
        }
        mount.type.syncfs(mount, populate, done);
      });
    },
    mount: (type, opts, mountpoint) => {
      let root = mountpoint === "/";
      let pseudo = !mountpoint;
      let node;
      if (root && FS.root) {
        throw new FS.ErrnoError(10);
      } else if (!root && !pseudo) {
        let lookup = FS.lookupPath(mountpoint, { follow_mount: false });
        mountpoint = lookup.path;
        node = lookup.node;
        if (FS.isMountpoint(node)) {
          throw new FS.ErrnoError(10);
        }
        if (!FS.isDir(node.mode)) {
          throw new FS.ErrnoError(54);
        }
      }
      let mount = { type, opts, mountpoint, mounts: [] };
      let mountRoot = type.mount(mount);
      mountRoot.mount = mount;
      mount.root = mountRoot;
      if (root) {
        FS.root = mountRoot;
      } else if (node) {
        node.mounted = mount;
        if (node.mount) {
          node.mount.mounts.push(mount);
        }
      }
      return mountRoot;
    },
    unmount: (mountpoint) => {
      let lookup = FS.lookupPath(mountpoint, { follow_mount: false });
      if (!FS.isMountpoint(lookup.node)) {
        throw new FS.ErrnoError(28);
      }
      let node = lookup.node;
      let mount = node.mounted;
      let mounts = FS.getMounts(mount);
      Object.keys(FS.nameTable).forEach((hash) => {
        let current = FS.nameTable[hash];
        while (current) {
          let next = current.name_next;
          if (mounts.includes(current.mount)) {
            FS.destroyNode(current);
          }
          current = next;
        }
      });
      node.mounted = null;
      let idx = node.mount.mounts.indexOf(mount);
      node.mount.mounts.splice(idx, 1);
    },
    lookup: (parent, name) => {
      return parent.node_ops.lookup(parent, name);
    },
    mknod: (path, mode, dev) => {
      let lookup = FS.lookupPath(path, { parent: true });
      let parent = lookup.node;
      let name = PATH.basename(path);
      if (!name || name === "." || name === "..") {
        throw new FS.ErrnoError(28);
      }
      let errCode = FS.mayCreate(parent, name);
      if (errCode) {
        throw new FS.ErrnoError(errCode);
      }
      if (!parent.node_ops.mknod) {
        throw new FS.ErrnoError(63);
      }
      return parent.node_ops.mknod(parent, name, mode, dev);
    },
    create: (path, mode) => {
      mode = mode !== undefined ? mode : 438;
      mode &= 4095;
      mode |= 32768;
      return FS.mknod(path, mode, 0);
    },
    mkdir: (path, mode) => {
      mode = mode !== undefined ? mode : 511;
      mode &= 511 | 512;
      mode |= 16384;
      return FS.mknod(path, mode, 0);
    },
    mkdirTree: (path, mode) => {
      let dirs = path.split("/");
      let d = "";
      for (let i = 0; i < dirs.length; ++i) {
        if (!dirs[i]) continue;
        d += "/" + dirs[i];
        try {
          FS.mkdir(d, mode);
        } catch (e) {
          if (e.errno != 20) throw e;
        }
      }
    },
    mkdev: (path, mode, dev) => {
      if (typeof dev === "undefined") {
        dev = mode;
        mode = 438;
      }
      mode |= 8192;
      return FS.mknod(path, mode, dev);
    },
    symlink: (oldpath, newpath) => {
      if (!PATH_FS.resolve(oldpath)) {
        throw new FS.ErrnoError(44);
      }
      let lookup = FS.lookupPath(newpath, { parent: true });
      let parent = lookup.node;
      if (!parent) {
        throw new FS.ErrnoError(44);
      }
      let newname = PATH.basename(newpath);
      let errCode = FS.mayCreate(parent, newname);
      if (errCode) {
        throw new FS.ErrnoError(errCode);
      }
      if (!parent.node_ops.symlink) {
        throw new FS.ErrnoError(63);
      }
      return parent.node_ops.symlink(parent, newname, oldpath);
    },
    rename: (old_path, new_path) => {
      let old_dirname = PATH.dirname(old_path);
      let new_dirname = PATH.dirname(new_path);
      let old_name = PATH.basename(old_path);
      let new_name = PATH.basename(new_path);
      let lookup, old_dir, new_dir;
      lookup = FS.lookupPath(old_path, { parent: true });
      old_dir = lookup.node;
      lookup = FS.lookupPath(new_path, { parent: true });
      new_dir = lookup.node;
      if (!old_dir || !new_dir) throw new FS.ErrnoError(44);
      if (old_dir.mount !== new_dir.mount) {
        throw new FS.ErrnoError(75);
      }
      let old_node = FS.lookupNode(old_dir, old_name);
      let relative = PATH_FS.relative(old_path, new_dirname);
      if (relative.charAt(0) !== ".") {
        throw new FS.ErrnoError(28);
      }
      relative = PATH_FS.relative(new_path, old_dirname);
      if (relative.charAt(0) !== ".") {
        throw new FS.ErrnoError(55);
      }
      let new_node;
      try {
        new_node = FS.lookupNode(new_dir, new_name);
      } catch (e) {}
      if (old_node === new_node) {
        return;
      }
      let isdir = FS.isDir(old_node.mode);
      let errCode = FS.mayDelete(old_dir, old_name, isdir);
      if (errCode) {
        throw new FS.ErrnoError(errCode);
      }
      errCode = new_node ? FS.mayDelete(new_dir, new_name, isdir) : FS.mayCreate(new_dir, new_name);
      if (errCode) {
        throw new FS.ErrnoError(errCode);
      }
      if (!old_dir.node_ops.rename) {
        throw new FS.ErrnoError(63);
      }
      if (FS.isMountpoint(old_node) || (new_node && FS.isMountpoint(new_node))) {
        throw new FS.ErrnoError(10);
      }
      if (new_dir !== old_dir) {
        errCode = FS.nodePermissions(old_dir, "w");
        if (errCode) {
          throw new FS.ErrnoError(errCode);
        }
      }
      FS.hashRemoveNode(old_node);
      try {
        old_dir.node_ops.rename(old_node, new_dir, new_name);
      } catch (e) {
        throw e;
      } finally {
        FS.hashAddNode(old_node);
      }
    },
    rmdir: (path) => {
      let lookup = FS.lookupPath(path, { parent: true });
      let parent = lookup.node;
      let name = PATH.basename(path);
      let node = FS.lookupNode(parent, name);
      let errCode = FS.mayDelete(parent, name, true);
      if (errCode) {
        throw new FS.ErrnoError(errCode);
      }
      if (!parent.node_ops.rmdir) {
        throw new FS.ErrnoError(63);
      }
      if (FS.isMountpoint(node)) {
        throw new FS.ErrnoError(10);
      }
      parent.node_ops.rmdir(parent, name);
      FS.destroyNode(node);
    },
    readdir: (path) => {
      let lookup = FS.lookupPath(path, { follow: true });
      let node = lookup.node;
      if (!node.node_ops.readdir) {
        throw new FS.ErrnoError(54);
      }
      return node.node_ops.readdir(node);
    },
    unlink: (path) => {
      let lookup = FS.lookupPath(path, { parent: true });
      let parent = lookup.node;
      if (!parent) {
        throw new FS.ErrnoError(44);
      }
      let name = PATH.basename(path);
      let node = FS.lookupNode(parent, name);
      let errCode = FS.mayDelete(parent, name, false);
      if (errCode) {
        throw new FS.ErrnoError(errCode);
      }
      if (!parent.node_ops.unlink) {
        throw new FS.ErrnoError(63);
      }
      if (FS.isMountpoint(node)) {
        throw new FS.ErrnoError(10);
      }
      parent.node_ops.unlink(parent, name);
      FS.destroyNode(node);
    },
    readlink: (path) => {
      let lookup = FS.lookupPath(path);
      let link = lookup.node;
      if (!link) {
        throw new FS.ErrnoError(44);
      }
      if (!link.node_ops.readlink) {
        throw new FS.ErrnoError(28);
      }
      return PATH_FS.resolve(FS.getPath(link.parent), link.node_ops.readlink(link));
    },
    stat: (path, dontFollow) => {
      let lookup = FS.lookupPath(path, { follow: !dontFollow });
      let node = lookup.node;
      if (!node) {
        throw new FS.ErrnoError(44);
      }
      if (!node.node_ops.getattr) {
        throw new FS.ErrnoError(63);
      }
      return node.node_ops.getattr(node);
    },
    lstat: (path) => {
      return FS.stat(path, true);
    },
    chmod: (path, mode, dontFollow) => {
      let node;
      if (typeof path === "string") {
        let lookup = FS.lookupPath(path, { follow: !dontFollow });
        node = lookup.node;
      } else {
        node = path;
      }
      if (!node.node_ops.setattr) {
        throw new FS.ErrnoError(63);
      }
      node.node_ops.setattr(node, {
        mode: (mode & 4095) | (node.mode & ~4095),
        timestamp: Date.now(),
      });
    },
    lchmod: (path, mode) => {
      FS.chmod(path, mode, true);
    },
    fchmod: (fd, mode) => {
      let stream = FS.getStream(fd);
      if (!stream) {
        throw new FS.ErrnoError(8);
      }
      FS.chmod(stream.node, mode);
    },
    chown: (path, uid, gid, dontFollow) => {
      let node;
      if (typeof path === "string") {
        let lookup = FS.lookupPath(path, { follow: !dontFollow });
        node = lookup.node;
      } else {
        node = path;
      }
      if (!node.node_ops.setattr) {
        throw new FS.ErrnoError(63);
      }
      node.node_ops.setattr(node, { timestamp: Date.now() });
    },
    lchown: (path, uid, gid) => {
      FS.chown(path, uid, gid, true);
    },
    fchown: (fd, uid, gid) => {
      let stream = FS.getStream(fd);
      if (!stream) {
        throw new FS.ErrnoError(8);
      }
      FS.chown(stream.node, uid, gid);
    },
    truncate: (path, len) => {
      if (len < 0) {
        throw new FS.ErrnoError(28);
      }
      let node;
      if (typeof path === "string") {
        let lookup = FS.lookupPath(path, { follow: true });
        node = lookup.node;
      } else {
        node = path;
      }
      if (!node.node_ops.setattr) {
        throw new FS.ErrnoError(63);
      }
      if (FS.isDir(node.mode)) {
        throw new FS.ErrnoError(31);
      }
      if (!FS.isFile(node.mode)) {
        throw new FS.ErrnoError(28);
      }
      let errCode = FS.nodePermissions(node, "w");
      if (errCode) {
        throw new FS.ErrnoError(errCode);
      }
      node.node_ops.setattr(node, { size: len, timestamp: Date.now() });
    },
    ftruncate: (fd, len) => {
      let stream = FS.getStream(fd);
      if (!stream) {
        throw new FS.ErrnoError(8);
      }
      if ((stream.flags & 2097155) === 0) {
        throw new FS.ErrnoError(28);
      }
      FS.truncate(stream.node, len);
    },
    utime: (path, atime, mtime) => {
      let lookup = FS.lookupPath(path, { follow: true });
      let node = lookup.node;
      node.node_ops.setattr(node, { timestamp: Math.max(atime, mtime) });
    },
    open: (path, flags, mode) => {
      if (path === "") {
        throw new FS.ErrnoError(44);
      }
      flags = typeof flags === "string" ? FS.modeStringToFlags(flags) : flags;
      mode = typeof mode === "undefined" ? 438 : mode;
      if (flags & 64) {
        mode = (mode & 4095) | 32768;
      } else {
        mode = 0;
      }
      let node;
      if (typeof path === "object") {
        node = path;
      } else {
        path = PATH.normalize(path);
        try {
          let lookup = FS.lookupPath(path, { follow: !(flags & 131072) });
          node = lookup.node;
        } catch (e) {}
      }
      let created = false;
      if (flags & 64) {
        if (node) {
          if (flags & 128) {
            throw new FS.ErrnoError(20);
          }
        } else {
          node = FS.mknod(path, mode, 0);
          created = true;
        }
      }
      if (!node) {
        throw new FS.ErrnoError(44);
      }
      if (FS.isChrdev(node.mode)) {
        flags &= ~512;
      }
      if (flags & 65536 && !FS.isDir(node.mode)) {
        throw new FS.ErrnoError(54);
      }
      if (!created) {
        let errCode = FS.mayOpen(node, flags);
        if (errCode) {
          throw new FS.ErrnoError(errCode);
        }
      }
      if (flags & 512 && !created) {
        FS.truncate(node, 0);
      }
      flags &= ~(128 | 512 | 131072);
      let stream = FS.createStream({
        node,
        path: FS.getPath(node),
        flags,
        seekable: true,
        position: 0,
        stream_ops: node.stream_ops,
        ungotten: [],
        error: false,
      });
      if (stream.stream_ops.open) {
        stream.stream_ops.open(stream);
      }
      if (Module["logReadFiles"] && !(flags & 1)) {
        if (!FS.readFiles) FS.readFiles = {};
        if (!(path in FS.readFiles)) {
          FS.readFiles[path] = 1;
        }
      }
      return stream;
    },
    close: (stream) => {
      if (FS.isClosed(stream)) {
        throw new FS.ErrnoError(8);
      }
      if (stream.getdents) stream.getdents = null;
      try {
        if (stream.stream_ops.close) {
          stream.stream_ops.close(stream);
        }
      } catch (e) {
        throw e;
      } finally {
        FS.closeStream(stream.fd);
      }
      stream.fd = null;
    },
    isClosed: (stream) => {
      return stream.fd === null;
    },
    llseek: (stream, offset, whence) => {
      if (FS.isClosed(stream)) {
        throw new FS.ErrnoError(8);
      }
      if (!stream.seekable || !stream.stream_ops.llseek) {
        throw new FS.ErrnoError(70);
      }
      if (whence != 0 && whence != 1 && whence != 2) {
        throw new FS.ErrnoError(28);
      }
      stream.position = stream.stream_ops.llseek(stream, offset, whence);
      stream.ungotten = [];
      return stream.position;
    },
    read: (stream, buffer, offset, length, position) => {
      if (length < 0 || position < 0) {
        throw new FS.ErrnoError(28);
      }
      if (FS.isClosed(stream)) {
        throw new FS.ErrnoError(8);
      }
      if ((stream.flags & 2097155) === 1) {
        throw new FS.ErrnoError(8);
      }
      if (FS.isDir(stream.node.mode)) {
        throw new FS.ErrnoError(31);
      }
      if (!stream.stream_ops.read) {
        throw new FS.ErrnoError(28);
      }
      let seeking = typeof position !== "undefined";
      if (!seeking) {
        position = stream.position;
      } else if (!stream.seekable) {
        throw new FS.ErrnoError(70);
      }
      let bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position);
      if (!seeking) stream.position += bytesRead;
      return bytesRead;
    },
    write: (stream, buffer, offset, length, position, canOwn) => {
      if (length < 0 || position < 0) {
        throw new FS.ErrnoError(28);
      }
      if (FS.isClosed(stream)) {
        throw new FS.ErrnoError(8);
      }
      if ((stream.flags & 2097155) === 0) {
        throw new FS.ErrnoError(8);
      }
      if (FS.isDir(stream.node.mode)) {
        throw new FS.ErrnoError(31);
      }
      if (!stream.stream_ops.write) {
        throw new FS.ErrnoError(28);
      }
      if (stream.seekable && stream.flags & 1024) {
        FS.llseek(stream, 0, 2);
      }
      let seeking = typeof position !== "undefined";
      if (!seeking) {
        position = stream.position;
      } else if (!stream.seekable) {
        throw new FS.ErrnoError(70);
      }
      let bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn);
      if (!seeking) stream.position += bytesWritten;
      return bytesWritten;
    },
    allocate: (stream, offset, length) => {
      if (FS.isClosed(stream)) {
        throw new FS.ErrnoError(8);
      }
      if (offset < 0 || length <= 0) {
        throw new FS.ErrnoError(28);
      }
      if ((stream.flags & 2097155) === 0) {
        throw new FS.ErrnoError(8);
      }
      if (!FS.isFile(stream.node.mode) && !FS.isDir(stream.node.mode)) {
        throw new FS.ErrnoError(43);
      }
      if (!stream.stream_ops.allocate) {
        throw new FS.ErrnoError(138);
      }
      stream.stream_ops.allocate(stream, offset, length);
    },
    mmap: (stream, length, position, prot, flags) => {
      if ((prot & 2) !== 0 && (flags & 2) === 0 && (stream.flags & 2097155) !== 2) {
        throw new FS.ErrnoError(2);
      }
      if ((stream.flags & 2097155) === 1) {
        throw new FS.ErrnoError(2);
      }
      if (!stream.stream_ops.mmap) {
        throw new FS.ErrnoError(43);
      }
      return stream.stream_ops.mmap(stream, length, position, prot, flags);
    },
    msync: (stream, buffer, offset, length, mmapFlags) => {
      if (!stream.stream_ops.msync) {
        return 0;
      }
      return stream.stream_ops.msync(stream, buffer, offset, length, mmapFlags);
    },
    munmap: (stream) => 0,
    ioctl: (stream, cmd, arg) => {
      if (!stream.stream_ops.ioctl) {
        throw new FS.ErrnoError(59);
      }
      return stream.stream_ops.ioctl(stream, cmd, arg);
    },
    readFile: (path, opts = {}) => {
      opts.flags = opts.flags || 0;
      opts.encoding = opts.encoding || "binary";
      if (opts.encoding !== "utf8" && opts.encoding !== "binary") {
        throw new Error('Invalid encoding type "' + opts.encoding + '"');
      }
      let ret;
      let stream = FS.open(path, opts.flags);
      let stat = FS.stat(path);
      let length = stat.size;
      let buf = new Uint8Array(length);
      FS.read(stream, buf, 0, length, 0);
      if (opts.encoding === "utf8") {
        ret = UTF8ArrayToString(buf, 0);
      } else if (opts.encoding === "binary") {
        ret = buf;
      }
      FS.close(stream);
      return ret;
    },
    writeFile: (path, data, opts = {}) => {
      opts.flags = opts.flags || 577;
      let stream = FS.open(path, opts.flags, opts.mode);
      if (typeof data === "string") {
        let buf = new Uint8Array(lengthBytesUTF8(data) + 1);
        let actualNumBytes = stringToUTF8Array(data, buf, 0, buf.length);
        FS.write(stream, buf, 0, actualNumBytes, undefined, opts.canOwn);
      } else if (ArrayBuffer.isView(data)) {
        FS.write(stream, data, 0, data.byteLength, undefined, opts.canOwn);
      } else {
        throw new Error("Unsupported data type");
      }
      FS.close(stream);
    },
    cwd: () => FS.currentPath,
    chdir: (path) => {
      let lookup = FS.lookupPath(path, { follow: true });
      if (lookup.node === null) {
        throw new FS.ErrnoError(44);
      }
      if (!FS.isDir(lookup.node.mode)) {
        throw new FS.ErrnoError(54);
      }
      let errCode = FS.nodePermissions(lookup.node, "x");
      if (errCode) {
        throw new FS.ErrnoError(errCode);
      }
      FS.currentPath = lookup.path;
    },
    createDefaultDirectories: () => {
      FS.mkdir("/tmp");
      FS.mkdir("/home");
      FS.mkdir("/home/web_user");
    },
    createDefaultDevices: () => {
      FS.mkdir("/dev");
      FS.registerDevice(FS.makedev(1, 3), {
        read: () => 0,
        write: (stream, buffer, offset, length, pos) => length,
      });
      FS.mkdev("/dev/null", FS.makedev(1, 3));
      TTY.register(FS.makedev(5, 0), TTY.default_tty_ops);
      TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops);
      FS.mkdev("/dev/tty", FS.makedev(5, 0));
      FS.mkdev("/dev/tty1", FS.makedev(6, 0));
      let random_device = getRandomDevice();
      FS.createDevice("/dev", "random", random_device);
      FS.createDevice("/dev", "urandom", random_device);
      FS.mkdir("/dev/shm");
      FS.mkdir("/dev/shm/tmp");
    },
    createSpecialDirectories: () => {
      FS.mkdir("/proc");
      let proc_self = FS.mkdir("/proc/self");
      FS.mkdir("/proc/self/fd");
      FS.mount(
        {
          mount: () => {
            let node = FS.createNode(proc_self, "fd", 16384 | 511, 73);
            node.node_ops = {
              lookup: (parent, name) => {
                let fd = +name;
                let stream = FS.getStream(fd);
                if (!stream) throw new FS.ErrnoError(8);
                let ret = {
                  parent: null,
                  mount: { mountpoint: "fake" },
                  node_ops: { readlink: () => stream.path },
                };
                ret.parent = ret;
                return ret;
              },
            };
            return node;
          },
        },
        {},
        "/proc/self/fd",
      );
    },
    createStandardStreams: () => {
      if (Module["stdin"]) {
        FS.createDevice("/dev", "stdin", Module["stdin"]);
      } else {
        FS.symlink("/dev/tty", "/dev/stdin");
      }
      if (Module["stdout"]) {
        FS.createDevice("/dev", "stdout", null, Module["stdout"]);
      } else {
        FS.symlink("/dev/tty", "/dev/stdout");
      }
      if (Module["stderr"]) {
        FS.createDevice("/dev", "stderr", null, Module["stderr"]);
      } else {
        FS.symlink("/dev/tty1", "/dev/stderr");
      }
      let stdin = FS.open("/dev/stdin", 0);
      let stdout = FS.open("/dev/stdout", 1);
      let stderr = FS.open("/dev/stderr", 1);
    },
    ensureErrnoError: () => {
      if (FS.ErrnoError) return;
      FS.ErrnoError = function ErrnoError(errno, node) {
        this.node = node;
        this.setErrno = function (errno) {
          this.errno = errno;
        };
        this.setErrno(errno);
        this.message = "FS error";
      };
      FS.ErrnoError.prototype = new Error();
      FS.ErrnoError.prototype.constructor = FS.ErrnoError;
      [44].forEach((code) => {
        FS.genericErrors[code] = new FS.ErrnoError(code);
        FS.genericErrors[code].stack = "<generic error, no stack>";
      });
    },
    staticInit: () => {
      FS.ensureErrnoError();
      FS.nameTable = new Array(4096);
      FS.mount(MEMFS, {}, "/");
      FS.createDefaultDirectories();
      FS.createDefaultDevices();
      FS.createSpecialDirectories();
      FS.filesystems = { MEMFS };
    },
    init: (input, output, error) => {
      FS.init.initialized = true;
      FS.ensureErrnoError();
      Module["stdin"] = input || Module["stdin"];
      Module["stdout"] = output || Module["stdout"];
      Module["stderr"] = error || Module["stderr"];
      FS.createStandardStreams();
    },
    quit: () => {
      FS.init.initialized = false;
      for (let i = 0; i < FS.streams.length; i++) {
        let stream = FS.streams[i];
        if (!stream) {
          continue;
        }
        FS.close(stream);
      }
    },
    getMode: (canRead, canWrite) => {
      let mode = 0;
      if (canRead) mode |= 292 | 73;
      if (canWrite) mode |= 146;
      return mode;
    },
    findObject: (path, dontResolveLastLink) => {
      let ret = FS.analyzePath(path, dontResolveLastLink);
      if (!ret.exists) {
        return null;
      }
      return ret.object;
    },
    analyzePath: (path, dontResolveLastLink) => {
      try {
        var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
        path = lookup.path;
      } catch (e) {}
      let ret = {
        isRoot: false,
        exists: false,
        error: 0,
        name: null,
        path: null,
        object: null,
        parentExists: false,
        parentPath: null,
        parentObject: null,
      };
      try {
        var lookup = FS.lookupPath(path, { parent: true });
        ret.parentExists = true;
        ret.parentPath = lookup.path;
        ret.parentObject = lookup.node;
        ret.name = PATH.basename(path);
        lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
        ret.exists = true;
        ret.path = lookup.path;
        ret.object = lookup.node;
        ret.name = lookup.node.name;
        ret.isRoot = lookup.path === "/";
      } catch (e) {
        ret.error = e.errno;
      }
      return ret;
    },
    createPath: (parent, path, canRead, canWrite) => {
      parent = typeof parent === "string" ? parent : FS.getPath(parent);
      let parts = path.split("/").reverse();
      while (parts.length) {
        let part = parts.pop();
        if (!part) continue;
        var current = PATH.join2(parent, part);
        try {
          FS.mkdir(current);
        } catch (e) {}
        parent = current;
      }
      return current;
    },
    createFile: (parent, name, properties, canRead, canWrite) => {
      let path = PATH.join2(typeof parent === "string" ? parent : FS.getPath(parent), name);
      let mode = FS.getMode(canRead, canWrite);
      return FS.create(path, mode);
    },
    createDataFile: (parent, name, data, canRead, canWrite, canOwn) => {
      let path = name;
      if (parent) {
        parent = typeof parent === "string" ? parent : FS.getPath(parent);
        path = name ? PATH.join2(parent, name) : parent;
      }
      let mode = FS.getMode(canRead, canWrite);
      let node = FS.create(path, mode);
      if (data) {
        if (typeof data === "string") {
          let arr = new Array(data.length);
          for (let i = 0, len = data.length; i < len; ++i) arr[i] = data.charCodeAt(i);
          data = arr;
        }
        FS.chmod(node, mode | 146);
        let stream = FS.open(node, 577);
        FS.write(stream, data, 0, data.length, 0, canOwn);
        FS.close(stream);
        FS.chmod(node, mode);
      }
      return node;
    },
    createDevice: (parent, name, input, output) => {
      let path = PATH.join2(typeof parent === "string" ? parent : FS.getPath(parent), name);
      let mode = FS.getMode(!!input, !!output);
      if (!FS.createDevice.major) FS.createDevice.major = 64;
      let dev = FS.makedev(FS.createDevice.major++, 0);
      FS.registerDevice(dev, {
        open: (stream) => {
          stream.seekable = false;
        },
        close: (stream) => {
          if (output && output.buffer && output.buffer.length) {
            output(10);
          }
        },
        read: (stream, buffer, offset, length, pos) => {
          let bytesRead = 0;
          for (let i = 0; i < length; i++) {
            var result;
            try {
              result = input();
            } catch (e) {
              throw new FS.ErrnoError(29);
            }
            if (result === undefined && bytesRead === 0) {
              throw new FS.ErrnoError(6);
            }
            if (result === null || result === undefined) break;
            bytesRead++;
            buffer[offset + i] = result;
          }
          if (bytesRead) {
            stream.node.timestamp = Date.now();
          }
          return bytesRead;
        },
        write: (stream, buffer, offset, length, pos) => {
          for (var i = 0; i < length; i++) {
            try {
              output(buffer[offset + i]);
            } catch (e) {
              throw new FS.ErrnoError(29);
            }
          }
          if (length) {
            stream.node.timestamp = Date.now();
          }
          return i;
        },
      });
      return FS.mkdev(path, mode, dev);
    },
    forceLoadFile: (obj) => {
      if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true;
      if (typeof XMLHttpRequest !== "undefined") {
        throw new Error(
          "Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.",
        );
      } else if (read_) {
        try {
          obj.contents = intArrayFromString(read_(obj.url), true);
          obj.usedBytes = obj.contents.length;
        } catch (e) {
          throw new FS.ErrnoError(29);
        }
      } else {
        throw new Error("Cannot load without read() or XMLHttpRequest.");
      }
    },
    createLazyFile: (parent, name, url, canRead, canWrite) => {
      function LazyUint8Array() {
        this.lengthKnown = false;
        this.chunks = [];
      }
      LazyUint8Array.prototype.get = function LazyUint8Array_get(idx) {
        if (idx > this.length - 1 || idx < 0) {
          return undefined;
        }
        let chunkOffset = idx % this.chunkSize;
        let chunkNum = (idx / this.chunkSize) | 0;
        return this.getter(chunkNum)[chunkOffset];
      };
      LazyUint8Array.prototype.setDataGetter = function LazyUint8Array_setDataGetter(getter) {
        this.getter = getter;
      };
      LazyUint8Array.prototype.cacheLength = function LazyUint8Array_cacheLength() {
        let xhr = new XMLHttpRequest();
        xhr.open("HEAD", url, false);
        xhr.send(null);
        if (!((xhr.status >= 200 && xhr.status < 300) || xhr.status === 304))
          throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
        let datalength = Number(xhr.getResponseHeader("Content-length"));
        let header;
        let hasByteServing =
          (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes";
        let usesGzip = (header = xhr.getResponseHeader("Content-Encoding")) && header === "gzip";
        let chunkSize = 1024 * 1024;
        if (!hasByteServing) chunkSize = datalength;
        let doXHR = (from, to) => {
          if (from > to)
            throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!");
          if (to > datalength - 1)
            throw new Error("only " + datalength + " bytes available! programmer error!");
          let xhr = new XMLHttpRequest();
          xhr.open("GET", url, false);
          if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to);
          xhr.responseType = "arraybuffer";
          if (xhr.overrideMimeType) {
            xhr.overrideMimeType("text/plain; charset=x-user-defined");
          }
          xhr.send(null);
          if (!((xhr.status >= 200 && xhr.status < 300) || xhr.status === 304))
            throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
          if (xhr.response !== undefined) {
            return new Uint8Array(xhr.response || []);
          }
          return intArrayFromString(xhr.responseText || "", true);
        };
        let lazyArray = this;
        lazyArray.setDataGetter((chunkNum) => {
          let start = chunkNum * chunkSize;
          let end = (chunkNum + 1) * chunkSize - 1;
          end = Math.min(end, datalength - 1);
          if (typeof lazyArray.chunks[chunkNum] === "undefined") {
            lazyArray.chunks[chunkNum] = doXHR(start, end);
          }
          if (typeof lazyArray.chunks[chunkNum] === "undefined") throw new Error("doXHR failed!");
          return lazyArray.chunks[chunkNum];
        });
        if (usesGzip || !datalength) {
          chunkSize = datalength = 1;
          datalength = this.getter(0).length;
          chunkSize = datalength;
          out("LazyFiles on gzip forces download of the whole file when length is accessed");
        }
        this._length = datalength;
        this._chunkSize = chunkSize;
        this.lengthKnown = true;
      };
      if (typeof XMLHttpRequest !== "undefined") {
        if (!ENVIRONMENT_IS_WORKER)
          throw "Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc";
        let lazyArray = new LazyUint8Array();
        Object.defineProperties(lazyArray, {
          length: {
            get() {
              if (!this.lengthKnown) {
                this.cacheLength();
              }
              return this._length;
            },
          },
          chunkSize: {
            get() {
              if (!this.lengthKnown) {
                this.cacheLength();
              }
              return this._chunkSize;
            },
          },
        });
        var properties = { isDevice: false, contents: lazyArray };
      } else {
        var properties = { isDevice: false, url };
      }
      let node = FS.createFile(parent, name, properties, canRead, canWrite);
      if (properties.contents) {
        node.contents = properties.contents;
      } else if (properties.url) {
        node.contents = null;
        node.url = properties.url;
      }
      Object.defineProperties(node, {
        usedBytes: {
          get() {
            return this.contents.length;
          },
        },
      });
      let stream_ops = {};
      let keys = Object.keys(node.stream_ops);
      keys.forEach((key) => {
        let fn = node.stream_ops[key];
        stream_ops[key] = function forceLoadLazyFile() {
          FS.forceLoadFile(node);
          return fn.apply(null, arguments);
        };
      });
      function writeChunks(stream, buffer, offset, length, position) {
        let contents = stream.node.contents;
        if (position >= contents.length) return 0;
        let size = Math.min(contents.length - position, length);
        if (contents.slice) {
          for (var i = 0; i < size; i++) {
            buffer[offset + i] = contents[position + i];
          }
        } else {
          for (var i = 0; i < size; i++) {
            buffer[offset + i] = contents.get(position + i);
          }
        }
        return size;
      }
      stream_ops.read = (stream, buffer, offset, length, position) => {
        FS.forceLoadFile(node);
        return writeChunks(stream, buffer, offset, length, position);
      };
      stream_ops.mmap = (stream, length, position, prot, flags) => {
        FS.forceLoadFile(node);
        let ptr = mmapAlloc(length);
        if (!ptr) {
          throw new FS.ErrnoError(48);
        }
        writeChunks(stream, HEAP8, ptr, length, position);
        return { ptr, allocated: true };
      };
      node.stream_ops = stream_ops;
      return node;
    },
    createPreloadedFile: (
      parent,
      name,
      url,
      canRead,
      canWrite,
      onload,
      onerror,
      dontCreateFile,
      canOwn,
      preFinish,
    ) => {
      let fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent;
      let dep = getUniqueRunDependency("cp " + fullname);
      function processData(byteArray) {
        function finish(byteArray) {
          if (preFinish) preFinish();
          if (!dontCreateFile) {
            FS.createDataFile(parent, name, byteArray, canRead, canWrite, canOwn);
          }
          if (onload) onload();
          removeRunDependency(dep);
        }
        if (
          Browser.handledByPreloadPlugin(byteArray, fullname, finish, () => {
            if (onerror) onerror();
            removeRunDependency(dep);
          })
        ) {
          return;
        }
        finish(byteArray);
      }
      addRunDependency(dep);
      if (typeof url === "string") {
        asyncLoad(url, (byteArray) => processData(byteArray), onerror);
      } else {
        processData(url);
      }
    },
    indexedDB: () => {
      return (
        window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB
      );
    },
    DB_NAME: () => {
      return "EM_FS_" + window.location.pathname;
    },
    DB_VERSION: 20,
    DB_STORE_NAME: "FILE_DATA",
    saveFilesToDB: (paths, onload, onerror) => {
      onload = onload || (() => {});
      onerror = onerror || (() => {});
      let indexedDB = FS.indexedDB();
      try {
        var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
      } catch (e) {
        return onerror(e);
      }
      openRequest.onupgradeneeded = () => {
        out("creating db");
        let db = openRequest.result;
        db.createObjectStore(FS.DB_STORE_NAME);
      };
      openRequest.onsuccess = () => {
        let db = openRequest.result;
        let transaction = db.transaction([FS.DB_STORE_NAME], "readwrite");
        let files = transaction.objectStore(FS.DB_STORE_NAME);
        let ok = 0,
          fail = 0,
          total = paths.length;
        function finish() {
          if (fail == 0) onload();
          else onerror();
        }
        paths.forEach((path) => {
          let putRequest = files.put(FS.analyzePath(path).object.contents, path);
          putRequest.onsuccess = () => {
            ok++;
            if (ok + fail == total) finish();
          };
          putRequest.onerror = () => {
            fail++;
            if (ok + fail == total) finish();
          };
        });
        transaction.onerror = onerror;
      };
      openRequest.onerror = onerror;
    },
    loadFilesFromDB: (paths, onload, onerror) => {
      onload = onload || (() => {});
      onerror = onerror || (() => {});
      let indexedDB = FS.indexedDB();
      try {
        var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
      } catch (e) {
        return onerror(e);
      }
      openRequest.onupgradeneeded = onerror;
      openRequest.onsuccess = () => {
        let db = openRequest.result;
        try {
          var transaction = db.transaction([FS.DB_STORE_NAME], "readonly");
        } catch (e) {
          onerror(e);
          return;
        }
        let files = transaction.objectStore(FS.DB_STORE_NAME);
        let ok = 0,
          fail = 0,
          total = paths.length;
        function finish() {
          if (fail == 0) onload();
          else onerror();
        }
        paths.forEach((path) => {
          let getRequest = files.get(path);
          getRequest.onsuccess = () => {
            if (FS.analyzePath(path).exists) {
              FS.unlink(path);
            }
            FS.createDataFile(
              PATH.dirname(path),
              PATH.basename(path),
              getRequest.result,
              true,
              true,
              true,
            );
            ok++;
            if (ok + fail == total) finish();
          };
          getRequest.onerror = () => {
            fail++;
            if (ok + fail == total) finish();
          };
        });
        transaction.onerror = onerror;
      };
      openRequest.onerror = onerror;
    },
  };
  var SYSCALLS = {
    DEFAULT_POLLMASK: 5,
    calculateAt(dirfd, path, allowEmpty) {
      if (PATH.isAbs(path)) {
        return path;
      }
      let dir;
      if (dirfd === -100) {
        dir = FS.cwd();
      } else {
        let dirstream = SYSCALLS.getStreamFromFD(dirfd);
        dir = dirstream.path;
      }
      if (path.length == 0) {
        if (!allowEmpty) {
          throw new FS.ErrnoError(44);
        }
        return dir;
      }
      return PATH.join2(dir, path);
    },
    doStat(func, path, buf) {
      try {
        var stat = func(path);
      } catch (e) {
        if (e && e.node && PATH.normalize(path) !== PATH.normalize(FS.getPath(e.node))) {
          return -54;
        }
        throw e;
      }
      HEAP32[buf >> 2] = stat.dev;
      HEAP32[(buf + 8) >> 2] = stat.ino;
      HEAP32[(buf + 12) >> 2] = stat.mode;
      HEAPU32[(buf + 16) >> 2] = stat.nlink;
      HEAP32[(buf + 20) >> 2] = stat.uid;
      HEAP32[(buf + 24) >> 2] = stat.gid;
      HEAP32[(buf + 28) >> 2] = stat.rdev;
      (tempI64 = [
        stat.size >>> 0,
        ((tempDouble = stat.size),
        +Math.abs(tempDouble) >= 1
          ? tempDouble > 0
            ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0
            : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0
          : 0),
      ]),
        (HEAP32[(buf + 40) >> 2] = tempI64[0]),
        (HEAP32[(buf + 44) >> 2] = tempI64[1]);
      HEAP32[(buf + 48) >> 2] = 4096;
      HEAP32[(buf + 52) >> 2] = stat.blocks;
      (tempI64 = [
        Math.floor(stat.atime.getTime() / 1e3) >>> 0,
        ((tempDouble = Math.floor(stat.atime.getTime() / 1e3)),
        +Math.abs(tempDouble) >= 1
          ? tempDouble > 0
            ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0
            : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0
          : 0),
      ]),
        (HEAP32[(buf + 56) >> 2] = tempI64[0]),
        (HEAP32[(buf + 60) >> 2] = tempI64[1]);
      HEAPU32[(buf + 64) >> 2] = 0;
      (tempI64 = [
        Math.floor(stat.mtime.getTime() / 1e3) >>> 0,
        ((tempDouble = Math.floor(stat.mtime.getTime() / 1e3)),
        +Math.abs(tempDouble) >= 1
          ? tempDouble > 0
            ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0
            : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0
          : 0),
      ]),
        (HEAP32[(buf + 72) >> 2] = tempI64[0]),
        (HEAP32[(buf + 76) >> 2] = tempI64[1]);
      HEAPU32[(buf + 80) >> 2] = 0;
      (tempI64 = [
        Math.floor(stat.ctime.getTime() / 1e3) >>> 0,
        ((tempDouble = Math.floor(stat.ctime.getTime() / 1e3)),
        +Math.abs(tempDouble) >= 1
          ? tempDouble > 0
            ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0
            : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0
          : 0),
      ]),
        (HEAP32[(buf + 88) >> 2] = tempI64[0]),
        (HEAP32[(buf + 92) >> 2] = tempI64[1]);
      HEAPU32[(buf + 96) >> 2] = 0;
      (tempI64 = [
        stat.ino >>> 0,
        ((tempDouble = stat.ino),
        +Math.abs(tempDouble) >= 1
          ? tempDouble > 0
            ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0
            : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0
          : 0),
      ]),
        (HEAP32[(buf + 104) >> 2] = tempI64[0]),
        (HEAP32[(buf + 108) >> 2] = tempI64[1]);
      return 0;
    },
    doMsync(addr, stream, len, flags, offset) {
      if (!FS.isFile(stream.node.mode)) {
        throw new FS.ErrnoError(43);
      }
      if (flags & 2) {
        return 0;
      }
      let buffer = HEAPU8.slice(addr, addr + len);
      FS.msync(stream, buffer, offset, len, flags);
    },
    varargs: undefined,
    get() {
      SYSCALLS.varargs += 4;
      let ret = HEAP32[(SYSCALLS.varargs - 4) >> 2];
      return ret;
    },
    getStr(ptr) {
      let ret = UTF8ToString(ptr);
      return ret;
    },
    getStreamFromFD(fd) {
      let stream = FS.getStream(fd);
      if (!stream) throw new FS.ErrnoError(8);
      return stream;
    },
  };
  function _environ_get(__environ, environ_buf) {
    let bufSize = 0;
    getEnvStrings().forEach(function (string, i) {
      let ptr = environ_buf + bufSize;
      HEAPU32[(__environ + i * 4) >> 2] = ptr;
      writeAsciiToMemory(string, ptr);
      bufSize += string.length + 1;
    });
    return 0;
  }
  function _environ_sizes_get(penviron_count, penviron_buf_size) {
    let strings = getEnvStrings();
    HEAPU32[penviron_count >> 2] = strings.length;
    let bufSize = 0;
    strings.forEach(function (string) {
      bufSize += string.length + 1;
    });
    HEAPU32[penviron_buf_size >> 2] = bufSize;
    return 0;
  }
  function _proc_exit(code) {
    EXITSTATUS = code;
    if (!keepRuntimeAlive()) {
      if (Module["onExit"]) Module["onExit"](code);
      ABORT = true;
    }
    quit_(code, new ExitStatus(code));
  }
  function exitJS(status, implicit) {
    EXITSTATUS = status;
    _proc_exit(status);
  }
  let _exit = exitJS;
  function _fd_close(fd) {
    try {
      let stream = SYSCALLS.getStreamFromFD(fd);
      FS.close(stream);
      return 0;
    } catch (e) {
      if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) throw e;
      return e.errno;
    }
  }
  function doReadv(stream, iov, iovcnt, offset) {
    let ret = 0;
    for (let i = 0; i < iovcnt; i++) {
      let ptr = HEAPU32[iov >> 2];
      let len = HEAPU32[(iov + 4) >> 2];
      iov += 8;
      let curr = FS.read(stream, HEAP8, ptr, len, offset);
      if (curr < 0) return -1;
      ret += curr;
      if (curr < len) break;
    }
    return ret;
  }
  function _fd_read(fd, iov, iovcnt, pnum) {
    try {
      let stream = SYSCALLS.getStreamFromFD(fd);
      let num = doReadv(stream, iov, iovcnt);
      HEAPU32[pnum >> 2] = num;
      return 0;
    } catch (e) {
      if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) throw e;
      return e.errno;
    }
  }
  function convertI32PairToI53Checked(lo, hi) {
    return (hi + 2097152) >>> 0 < 4194305 - !!lo ? (lo >>> 0) + hi * 4294967296 : NaN;
  }
  function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {
    try {
      let offset = convertI32PairToI53Checked(offset_low, offset_high);
      if (isNaN(offset)) return 61;
      let stream = SYSCALLS.getStreamFromFD(fd);
      FS.llseek(stream, offset, whence);
      (tempI64 = [
        stream.position >>> 0,
        ((tempDouble = stream.position),
        +Math.abs(tempDouble) >= 1
          ? tempDouble > 0
            ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0
            : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0
          : 0),
      ]),
        (HEAP32[newOffset >> 2] = tempI64[0]),
        (HEAP32[(newOffset + 4) >> 2] = tempI64[1]);
      if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null;
      return 0;
    } catch (e) {
      if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) throw e;
      return e.errno;
    }
  }
  function doWritev(stream, iov, iovcnt, offset) {
    let ret = 0;
    for (let i = 0; i < iovcnt; i++) {
      let ptr = HEAPU32[iov >> 2];
      let len = HEAPU32[(iov + 4) >> 2];
      iov += 8;
      let curr = FS.write(stream, HEAP8, ptr, len, offset);
      if (curr < 0) return -1;
      ret += curr;
    }
    return ret;
  }
  function _fd_write(fd, iov, iovcnt, pnum) {
    try {
      let stream = SYSCALLS.getStreamFromFD(fd);
      let num = doWritev(stream, iov, iovcnt);
      HEAPU32[pnum >> 2] = num;
      return 0;
    } catch (e) {
      if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) throw e;
      return e.errno;
    }
  }
  function _return_string(data, length) {
    Module._return_string_callback(data, length);
  }
  function __isLeapYear(year) {
    return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
  }
  function __arraySum(array, index) {
    let sum = 0;
    for (let i = 0; i <= index; sum += array[i++]) {}
    return sum;
  }
  let __MONTH_DAYS_LEAP = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
  let __MONTH_DAYS_REGULAR = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
  function __addDays(date, days) {
    let newDate = new Date(date.getTime());
    while (days > 0) {
      let leap = __isLeapYear(newDate.getFullYear());
      let currentMonth = newDate.getMonth();
      let daysInCurrentMonth = (leap ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR)[currentMonth];
      if (days > daysInCurrentMonth - newDate.getDate()) {
        days -= daysInCurrentMonth - newDate.getDate() + 1;
        newDate.setDate(1);
        if (currentMonth < 11) {
          newDate.setMonth(currentMonth + 1);
        } else {
          newDate.setMonth(0);
          newDate.setFullYear(newDate.getFullYear() + 1);
        }
      } else {
        newDate.setDate(newDate.getDate() + days);
        return newDate;
      }
    }
    return newDate;
  }
  function writeArrayToMemory(array, buffer) {
    HEAP8.set(array, buffer);
  }
  function _strftime(s, maxsize, format, tm) {
    let tm_zone = HEAP32[(tm + 40) >> 2];
    let date = {
      tm_sec: HEAP32[tm >> 2],
      tm_min: HEAP32[(tm + 4) >> 2],
      tm_hour: HEAP32[(tm + 8) >> 2],
      tm_mday: HEAP32[(tm + 12) >> 2],
      tm_mon: HEAP32[(tm + 16) >> 2],
      tm_year: HEAP32[(tm + 20) >> 2],
      tm_wday: HEAP32[(tm + 24) >> 2],
      tm_yday: HEAP32[(tm + 28) >> 2],
      tm_isdst: HEAP32[(tm + 32) >> 2],
      tm_gmtoff: HEAP32[(tm + 36) >> 2],
      tm_zone: tm_zone ? UTF8ToString(tm_zone) : "",
    };
    let pattern = UTF8ToString(format);
    let EXPANSION_RULES_1 = {
      "%c": "%a %b %d %H:%M:%S %Y",
      "%D": "%m/%d/%y",
      "%F": "%Y-%m-%d",
      "%h": "%b",
      "%r": "%I:%M:%S %p",
      "%R": "%H:%M",
      "%T": "%H:%M:%S",
      "%x": "%m/%d/%y",
      "%X": "%H:%M:%S",
      "%Ec": "%c",
      "%EC": "%C",
      "%Ex": "%m/%d/%y",
      "%EX": "%H:%M:%S",
      "%Ey": "%y",
      "%EY": "%Y",
      "%Od": "%d",
      "%Oe": "%e",
      "%OH": "%H",
      "%OI": "%I",
      "%Om": "%m",
      "%OM": "%M",
      "%OS": "%S",
      "%Ou": "%u",
      "%OU": "%U",
      "%OV": "%V",
      "%Ow": "%w",
      "%OW": "%W",
      "%Oy": "%y",
    };
    for (var rule in EXPANSION_RULES_1) {
      pattern = pattern.replace(new RegExp(rule, "g"), EXPANSION_RULES_1[rule]);
    }
    let WEEKDAYS = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
    let MONTHS = [
      "January",
      "February",
      "March",
      "April",
      "May",
      "June",
      "July",
      "August",
      "September",
      "October",
      "November",
      "December",
    ];
    function leadingSomething(value, digits, character) {
      let str = typeof value === "number" ? value.toString() : value || "";
      while (str.length < digits) {
        str = character[0] + str;
      }
      return str;
    }
    function leadingNulls(value, digits) {
      return leadingSomething(value, digits, "0");
    }
    function compareByDay(date1, date2) {
      function sgn(value) {
        return value < 0 ? -1 : value > 0 ? 1 : 0;
      }
      let compare;
      if ((compare = sgn(date1.getFullYear() - date2.getFullYear())) === 0) {
        if ((compare = sgn(date1.getMonth() - date2.getMonth())) === 0) {
          compare = sgn(date1.getDate() - date2.getDate());
        }
      }
      return compare;
    }
    function getFirstWeekStartDate(janFourth) {
      switch (janFourth.getDay()) {
        case 0:
          return new Date(janFourth.getFullYear() - 1, 11, 29);
        case 1:
          return janFourth;
        case 2:
          return new Date(janFourth.getFullYear(), 0, 3);
        case 3:
          return new Date(janFourth.getFullYear(), 0, 2);
        case 4:
          return new Date(janFourth.getFullYear(), 0, 1);
        case 5:
          return new Date(janFourth.getFullYear() - 1, 11, 31);
        case 6:
          return new Date(janFourth.getFullYear() - 1, 11, 30);
      }
    }
    function getWeekBasedYear(date) {
      let thisDate = __addDays(new Date(date.tm_year + 1900, 0, 1), date.tm_yday);
      let janFourthThisYear = new Date(thisDate.getFullYear(), 0, 4);
      let janFourthNextYear = new Date(thisDate.getFullYear() + 1, 0, 4);
      let firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear);
      let firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear);
      if (compareByDay(firstWeekStartThisYear, thisDate) <= 0) {
        if (compareByDay(firstWeekStartNextYear, thisDate) <= 0) {
          return thisDate.getFullYear() + 1;
        }
        return thisDate.getFullYear();
      }
      return thisDate.getFullYear() - 1;
    }
    let EXPANSION_RULES_2 = {
      "%a"(date) {
        return WEEKDAYS[date.tm_wday].substring(0, 3);
      },
      "%A"(date) {
        return WEEKDAYS[date.tm_wday];
      },
      "%b"(date) {
        return MONTHS[date.tm_mon].substring(0, 3);
      },
      "%B"(date) {
        return MONTHS[date.tm_mon];
      },
      "%C"(date) {
        let year = date.tm_year + 1900;
        return leadingNulls((year / 100) | 0, 2);
      },
      "%d"(date) {
        return leadingNulls(date.tm_mday, 2);
      },
      "%e"(date) {
        return leadingSomething(date.tm_mday, 2, " ");
      },
      "%g"(date) {
        return getWeekBasedYear(date).toString().substring(2);
      },
      "%G"(date) {
        return getWeekBasedYear(date);
      },
      "%H"(date) {
        return leadingNulls(date.tm_hour, 2);
      },
      "%I"(date) {
        let twelveHour = date.tm_hour;
        if (twelveHour == 0) twelveHour = 12;
        else if (twelveHour > 12) twelveHour -= 12;
        return leadingNulls(twelveHour, 2);
      },
      "%j"(date) {
        return leadingNulls(
          date.tm_mday +
            __arraySum(
              __isLeapYear(date.tm_year + 1900) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR,
              date.tm_mon - 1,
            ),
          3,
        );
      },
      "%m"(date) {
        return leadingNulls(date.tm_mon + 1, 2);
      },
      "%M"(date) {
        return leadingNulls(date.tm_min, 2);
      },
      "%n"() {
        return "\n";
      },
      "%p"(date) {
        if (date.tm_hour >= 0 && date.tm_hour < 12) {
          return "AM";
        }
        return "PM";
      },
      "%S"(date) {
        return leadingNulls(date.tm_sec, 2);
      },
      "%t"() {
        return "\t";
      },
      "%u"(date) {
        return date.tm_wday || 7;
      },
      "%U"(date) {
        let days = date.tm_yday + 7 - date.tm_wday;
        return leadingNulls(Math.floor(days / 7), 2);
      },
      "%V"(date) {
        let val = Math.floor((date.tm_yday + 7 - ((date.tm_wday + 6) % 7)) / 7);
        if ((date.tm_wday + 371 - date.tm_yday - 2) % 7 <= 2) {
          val++;
        }
        if (!val) {
          val = 52;
          let dec31 = (date.tm_wday + 7 - date.tm_yday - 1) % 7;
          if (dec31 == 4 || (dec31 == 5 && __isLeapYear((date.tm_year % 400) - 1))) {
            val++;
          }
        } else if (val == 53) {
          let jan1 = (date.tm_wday + 371 - date.tm_yday) % 7;
          if (jan1 != 4 && (jan1 != 3 || !__isLeapYear(date.tm_year))) val = 1;
        }
        return leadingNulls(val, 2);
      },
      "%w"(date) {
        return date.tm_wday;
      },
      "%W"(date) {
        let days = date.tm_yday + 7 - ((date.tm_wday + 6) % 7);
        return leadingNulls(Math.floor(days / 7), 2);
      },
      "%y"(date) {
        return (date.tm_year + 1900).toString().substring(2);
      },
      "%Y"(date) {
        return date.tm_year + 1900;
      },
      "%z"(date) {
        let off = date.tm_gmtoff;
        let ahead = off >= 0;
        off = Math.abs(off) / 60;
        off = (off / 60) * 100 + (off % 60);
        return (ahead ? "+" : "-") + String("0000" + off).slice(-4);
      },
      "%Z"(date) {
        return date.tm_zone;
      },
      "%%"() {
        return "%";
      },
    };
    pattern = pattern.replace(/%%/g, "\0\0");
    for (var rule in EXPANSION_RULES_2) {
      if (pattern.includes(rule)) {
        pattern = pattern.replace(new RegExp(rule, "g"), EXPANSION_RULES_2[rule](date));
      }
    }
    pattern = pattern.replace(/\0\0/g, "%");
    let bytes = intArrayFromString(pattern, false);
    if (bytes.length > maxsize) {
      return 0;
    }
    writeArrayToMemory(bytes, s);
    return bytes.length - 1;
  }
  function _strftime_l(s, maxsize, format, tm, loc) {
    return _strftime(s, maxsize, format, tm);
  }
  let FSNode = function (parent, name, mode, rdev) {
    if (!parent) {
      parent = this;
    }
    this.parent = parent;
    this.mount = parent.mount;
    this.mounted = null;
    this.id = FS.nextInode++;
    this.name = name;
    this.mode = mode;
    this.node_ops = {};
    this.stream_ops = {};
    this.rdev = rdev;
  };
  let readMode = 292 | 73;
  let writeMode = 146;
  Object.defineProperties(FSNode.prototype, {
    read: {
      get() {
        return (this.mode & readMode) === readMode;
      },
      set(val) {
        val ? (this.mode |= readMode) : (this.mode &= ~readMode);
      },
    },
    write: {
      get() {
        return (this.mode & writeMode) === writeMode;
      },
      set(val) {
        val ? (this.mode |= writeMode) : (this.mode &= ~writeMode);
      },
    },
    isFolder: {
      get() {
        return FS.isDir(this.mode);
      },
    },
    isDevice: {
      get() {
        return FS.isChrdev(this.mode);
      },
    },
  });
  FS.FSNode = FSNode;
  FS.staticInit();
  var asmLibraryArg = {
    a: ___assert_fail,
    f: ___cxa_allocate_exception,
    e: ___cxa_throw,
    b: _abort,
    i: _emscripten_resize_heap,
    l: _environ_get,
    m: _environ_sizes_get,
    d: _exit,
    g: _fd_close,
    h: _fd_read,
    k: _fd_seek,
    j: _fd_write,
    n: _return_string,
    c: _strftime_l,
  };
  let asm = createWasm();
  var ___wasm_call_ctors = (Module["___wasm_call_ctors"] = function () {
    return (___wasm_call_ctors = Module["___wasm_call_ctors"] = Module["asm"]["p"]).apply(
      null,
      arguments,
    );
  });
  var _test = (Module["_test"] = function () {
    return (_test = Module["_test"] = Module["asm"]["q"]).apply(null, arguments);
  });
  var _spirv_to_wgsl = (Module["_spirv_to_wgsl"] = function () {
    return (_spirv_to_wgsl = Module["_spirv_to_wgsl"] = Module["asm"]["r"]).apply(null, arguments);
  });
  var _malloc = (Module["_malloc"] = function () {
    return (_malloc = Module["_malloc"] = Module["asm"]["t"]).apply(null, arguments);
  });
  var _free = (Module["_free"] = function () {
    return (_free = Module["_free"] = Module["asm"]["u"]).apply(null, arguments);
  });
  var ___cxa_is_pointer_type = (Module["___cxa_is_pointer_type"] = function () {
    return (___cxa_is_pointer_type = Module["___cxa_is_pointer_type"] = Module["asm"]["v"]).apply(
      null,
      arguments,
    );
  });
  let calledRun;
  dependenciesFulfilled = function runCaller() {
    if (!calledRun) run();
    if (!calledRun) dependenciesFulfilled = runCaller;
  };
  function run(args) {
    args = args || arguments_;
    if (runDependencies > 0) {
      return;
    }
    preRun();
    if (runDependencies > 0) {
      return;
    }
    function doRun() {
      if (calledRun) return;
      calledRun = true;
      Module["calledRun"] = true;
      if (ABORT) return;
      initRuntime();
      if (Module["onRuntimeInitialized"]) Module["onRuntimeInitialized"]();
      postRun();
    }
    if (Module["setStatus"]) {
      Module["setStatus"]("Running...");
      setTimeout(function () {
        setTimeout(function () {
          Module["setStatus"]("");
        }, 1);
        doRun();
      }, 1);
    } else {
      doRun();
    }
  }
  if (Module["preInit"]) {
    if (typeof Module["preInit"] === "function") Module["preInit"] = [Module["preInit"]];
    while (Module["preInit"].length > 0) {
      Module["preInit"].pop()();
    }
  }
  run();
  return Module;
};
(function tryToExport(root, factory) {
  if (typeof exports === "object" && typeof module === "object") module.exports = factory();
  else if (typeof define === "function" && define.amd) define("twgsl", [], factory);
  else if (typeof exports === "object") exports["twgsl"] = factory();
  else root["twgsl"] = factory();
})(typeof self !== "undefined" ? self : typeof global !== "undefined" ? global : this, () => {
  const initialize = (wasmPath) => {
    wasmPath = wasmPath || "twgsl.wasm";
    return new Promise((resolve) => {
      Module({
        locateFile() {
          return wasmPath;
        },
        onRuntimeInitialized() {
          let twgsl = this;
          let wgsl = "";
          let textDecoder = new TextDecoder();
          let convertSpirV2WGSL = (code) => {
            if (!twgsl._return_string_callback) {
              twgsl._return_string_callback = (data, length) => {
                const bytes = new Uint8ClampedArray(twgsl.HEAPU8.subarray(data, data + length));
                wgsl = textDecoder.decode(bytes);
              };
            }
            let addr = twgsl._malloc(code.byteLength);
            twgsl.HEAPU32.set(code, addr / 4);
            twgsl._spirv_to_wgsl(addr, code.byteLength);
            twgsl._free(addr);
            return wgsl;
          };
          resolve({
            convertSpirV2WGSL,
          });
        },
      });
    });
  };
  let instance;
  return (wasmPath) => {
    if (!instance) {
      instance = initialize(wasmPath);
    }
    return instance;
  };
});
", "import {\n FullScreenMMLScene,\n MMLNetworkSource,\n NetworkedDOMWebsocketStatus,\n NetworkedDOMWebsocketStatusToString,\n parseColorAttribute,\n StatusUI,\n} from \"@mml-io/mml-web\";\nimport {\n PlayCanvasDragFlyCameraControls,\n PlayCanvasOrbitCameraControls,\n StandalonePlayCanvasAdapter,\n StandalonePlayCanvasAdapterControlsType,\n} from \"@mml-io/mml-web-playcanvas-standalone\";\nimport * as playcanvas from \"playcanvas\";\n\nimport { calculateContentBounds } from \"./calculateContentBounds\";\nimport { envMaps } from \"./env-maps\";\nimport { FormIteration } from \"./FormIteration\";\nimport { MMLSourceDefinition } from \"./MMLSourceDefinition\";\nimport { parseXYZ } from \"./parseXYZ\";\nimport { setDebugGlobals } from \"./setDebugGlobals\";\nimport {\n ambientLightColorField,\n ambientLightField,\n backgroundColorField,\n cameraFitContents,\n cameraFovField,\n cameraLookAtField,\n cameraModeField,\n cameraOrbitDistanceField,\n cameraOrbitPitchField,\n cameraOrbitSpeedField,\n cameraPositionField,\n environmentMapField,\n} from \"./ui/fields\";\n\nexport class PlayCanvasModeInternal {\n private disposed = false;\n public readonly type = \"playcanvas\";\n private environmentMap: string | null = null;\n\n private loadedState: {\n mmlNetworkSource: MMLNetworkSource;\n graphicsAdapter: StandalonePlayCanvasAdapter;\n fullScreenMMLScene: FullScreenMMLScene;\n statusUI: StatusUI;\n } | null = null;\n\n constructor(\n private windowTarget: Window,\n private targetForWrappers: HTMLElement,\n private mmlSourceDefinition: MMLSourceDefinition,\n private formIteration: FormIteration,\n ) {\n this.init();\n }\n\n private async init() {\n const fullScreenMMLScene = new FullScreenMMLScene();\n document.body.append(fullScreenMMLScene.element);\n const graphicsAdapter = await StandalonePlayCanvasAdapter.create(fullScreenMMLScene.element, {\n controlsType: StandalonePlayCanvasAdapterControlsType.DragFly,\n });\n\n if (this.disposed) {\n graphicsAdapter.dispose();\n return;\n }\n\n fullScreenMMLScene.init(graphicsAdapter);\n const statusUI = new StatusUI();\n const mmlNetworkSource = MMLNetworkSource.create({\n mmlScene: fullScreenMMLScene,\n statusUpdated: (status: NetworkedDOMWebsocketStatus) => {\n if (status === NetworkedDOMWebsocketStatus.Connected) {\n statusUI.setNoStatus();\n } else {\n statusUI.setStatus(NetworkedDOMWebsocketStatusToString(status));\n }\n },\n url: this.mmlSourceDefinition.url,\n windowTarget: this.windowTarget,\n targetForWrappers: this.targetForWrappers,\n });\n setDebugGlobals({\n mmlScene: fullScreenMMLScene,\n remoteDocumentWrapper: mmlNetworkSource.remoteDocumentWrapper,\n });\n const loadingCallback = () => {\n const [, completedLoading] = fullScreenMMLScene.getLoadingProgressManager().toRatio();\n if (completedLoading) {\n fullScreenMMLScene.getLoadingProgressManager().removeProgressCallback(loadingCallback);\n\n const fitContent = this.formIteration.getFieldValue(cameraFitContents);\n if (fitContent === \"true\") {\n graphicsAdapter.controls?.fitContent(calculateContentBounds(this.targetForWrappers));\n }\n }\n };\n fullScreenMMLScene.getLoadingProgressManager().addProgressCallback(loadingCallback);\n this.loadedState = {\n mmlNetworkSource,\n graphicsAdapter,\n fullScreenMMLScene,\n statusUI,\n };\n this.update(this.formIteration);\n }\n\n update(formIteration: FormIteration) {\n this.formIteration = formIteration;\n if (!this.loadedState) {\n return;\n }\n\n const graphicsAdapter = this.loadedState.graphicsAdapter;\n const playcanvasScene = graphicsAdapter.getPlayCanvasApp().scene;\n const cameraEntity = graphicsAdapter.getCamera();\n const cameraComponent = cameraEntity.camera as playcanvas.CameraComponent;\n this.setBackgroundColor(formIteration, cameraComponent);\n this.setAmbientLight(formIteration, playcanvasScene);\n this.setEnvironmentMap(formIteration, graphicsAdapter.getPlayCanvasApp(), playcanvasScene);\n\n this.setCameraMode(formIteration, graphicsAdapter);\n\n formIteration.completed();\n }\n\n private setEnvironmentMap(\n formIteration: FormIteration,\n playCanvasApp: playcanvas.AppBase,\n playcanvasScene: playcanvas.Scene,\n ) {\n let environmentMap = formIteration.getFieldValue(environmentMapField);\n const foundEnvMap = envMaps[environmentMap];\n if (foundEnvMap) {\n environmentMap = foundEnvMap.url;\n }\n if (!environmentMap) {\n // @ts-expect-error - PlayCanvas types don't accept null, but it works\n playcanvasScene.envAtlas = null;\n // @ts-expect-error - PlayCanvas types don't accept null, but it works\n playcanvasScene.skybox = null;\n this.environmentMap = null;\n return;\n }\n if (environmentMap === this.environmentMap) {\n return;\n }\n\n const envMapAsset = new playcanvas.Asset(\"env-atlas\", \"texture\", { url: environmentMap });\n playCanvasApp.assets.add(envMapAsset);\n playCanvasApp.assets.load(envMapAsset);\n\n const onEnvMapAssetLoad = (texture: playcanvas.Texture) => {\n const skybox = playcanvas.EnvLighting.generateSkyboxCubemap(texture);\n const lighting = playcanvas.EnvLighting.generateLightingSource(texture);\n const envAtlas = playcanvas.EnvLighting.generateAtlas(lighting, {});\n lighting.destroy();\n playcanvasScene.envAtlas = envAtlas;\n playcanvasScene.skybox = skybox;\n playcanvasScene.skyboxLuminance = 50000;\n };\n\n if (envMapAsset.loaded) {\n onEnvMapAssetLoad(envMapAsset.resource);\n } else {\n envMapAsset.on(\"load\", (envMapAsset: playcanvas.Asset) => {\n onEnvMapAssetLoad(envMapAsset.resource);\n });\n }\n }\n\n private setAmbientLight(formIteration: FormIteration, playcanvasScene: playcanvas.Scene) {\n const ambientLightIntensityString = formIteration.getFieldValue(ambientLightField) || \"0\";\n const ambientLightColorString = formIteration.getFieldValue(ambientLightColorField);\n let ambientLightIntensity = parseFloat(ambientLightIntensityString);\n if (isNaN(ambientLightIntensity)) {\n ambientLightIntensity = 0;\n }\n if (ambientLightIntensity < 0) {\n playcanvasScene.ambientLuminance = 0;\n playcanvasScene.ambientLight = new playcanvas.Color(0, 0, 0);\n } else {\n const color = parseColorAttribute(ambientLightColorString, {\n r: 1,\n g: 1,\n b: 1,\n });\n playcanvasScene.ambientLuminance = ambientLightIntensity * 20;\n playcanvasScene.ambientLight = new playcanvas.Color(\n color.r * ambientLightIntensity * 20,\n color.g * ambientLightIntensity * 20,\n color.b * ambientLightIntensity * 20,\n );\n }\n }\n\n private setBackgroundColor(\n formIteration: FormIteration,\n cameraComponent: playcanvas.CameraComponent,\n ) {\n const backgroundColor = formIteration.getFieldValue(backgroundColorField);\n if (!backgroundColor) {\n cameraComponent.clearColor = new playcanvas.Color(0, 0, 0, 0);\n return;\n }\n const color = parseColorAttribute(backgroundColor, {\n r: 0,\n g: 0,\n b: 0,\n a: 0,\n });\n cameraComponent.clearColor = new playcanvas.Color(color.r, color.g, color.b, color.a);\n }\n\n private setCameraMode(\n formIteration: FormIteration,\n graphicsAdapter: StandalonePlayCanvasAdapter,\n ) {\n let cameraFOV = parseFloat(formIteration.getFieldValue(cameraFovField));\n if (isNaN(cameraFOV)) {\n cameraFOV = 75;\n }\n graphicsAdapter.setCameraFOV(cameraFOV);\n\n const cameraMode = formIteration.getFieldValue(cameraModeField);\n if (cameraMode === \"orbit\") {\n if (graphicsAdapter.controls?.type !== \"orbit\") {\n graphicsAdapter.setControlsType(StandalonePlayCanvasAdapterControlsType.Orbit);\n }\n const controls = graphicsAdapter.controls as PlayCanvasOrbitCameraControls;\n let orbitSpeed = parseFloat(formIteration.getFieldValue(cameraOrbitSpeedField));\n if (isNaN(orbitSpeed)) {\n orbitSpeed = 0;\n }\n controls.setDegreesPerSecond(orbitSpeed);\n let orbitPitch = parseFloat(formIteration.getFieldValue(cameraOrbitPitchField));\n\n if (isNaN(orbitPitch)) {\n orbitPitch = 0;\n }\n controls.setPitchDegrees(orbitPitch);\n\n const fitContent = formIteration.getFieldValue(cameraFitContents);\n if (fitContent === \"true\") {\n controls.fitContent(calculateContentBounds(this.targetForWrappers));\n } else {\n const lookAt = parseXYZ(formIteration.getFieldValue(cameraLookAtField));\n controls.setLookAt(lookAt[0], lookAt[1], lookAt[2]);\n\n let orbitDistance = parseFloat(formIteration.getFieldValue(cameraOrbitDistanceField));\n if (isNaN(orbitDistance)) {\n orbitDistance = 1;\n }\n controls.setDistance(orbitDistance);\n }\n } else if (cameraMode === \"drag-fly\") {\n if (graphicsAdapter.controls?.type !== \"drag-fly\") {\n graphicsAdapter.setControlsType(StandalonePlayCanvasAdapterControlsType.DragFly);\n }\n const controls = graphicsAdapter.controls as PlayCanvasDragFlyCameraControls;\n\n const cameraPosition = parseXYZ(formIteration.getFieldValue(cameraPositionField));\n controls.setCameraPosition(cameraPosition[0], cameraPosition[1], cameraPosition[2]);\n\n const lookAt = parseXYZ(formIteration.getFieldValue(cameraLookAtField));\n controls.setLookAt(lookAt[0], lookAt[1], lookAt[2]);\n\n const fitContent = formIteration.getFieldValue(cameraFitContents);\n if (fitContent === \"true\") {\n controls.fitContent(calculateContentBounds(this.targetForWrappers));\n }\n } else if (cameraMode === \"none\" && graphicsAdapter.controls !== null) {\n graphicsAdapter.setControlsType(StandalonePlayCanvasAdapterControlsType.None);\n }\n }\n\n public dispose() {\n this.disposed = true;\n if (this.loadedState) {\n this.loadedState.mmlNetworkSource.dispose();\n this.loadedState.graphicsAdapter.dispose();\n this.loadedState.fullScreenMMLScene.dispose();\n this.loadedState.statusUI.dispose();\n this.loadedState = null;\n }\n }\n}\n"], + "mappings": "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AA;AAAA;AAAA;;;ACAvB,IAAI,wBAAwB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACA5B,IAAI,UAAU;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAd,IAAI,cAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAlB,IAAI,YAAY;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAhB,IAAI,cAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAlB,IAAI,mBAAmB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAvB,IAAI,oBAAoB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAxB,IAAI,wBAAwB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACA5B,IAAI,0BAA0B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACA9B,IAAI,0BAA0B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACA9B,IAAI,mBAAmB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAvB,IAAI,YAAY;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAhB,IAAI,WAAW;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAf,IAAI,sBAAsB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACA1B,IAAI,uBAAuB;AAAA;AAAA;AAAA;AAAA;;;ACA3B,IAAI,kBAAkB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAtB,IAAI,gBAAgB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACApB,IAAI,yBAAyB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACA7B,IAAI,WAAW;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAf,IAAI,gBAAgB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACApB,IAAI,YAAY;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAhB,IAAI,qBAAqB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAzB,IAAI,aAAa;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAjB,IAAI,WAAW;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAf,IAAI,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAZ,IAAI,QAAQ;AAAA;;;ACAZ,IAAI,aAAa;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAjB,IAAI,a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AAA;AAAA;AAAA;AAAA;AAAA;;;ACApB,IAAI,mBAAmB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAvB,IAAI,gBAAgB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACApB,IAAI,mBAAmB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAvB,IAAI,0BAA0B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACA9B,IAAI,uBAAuB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACA3B,IAAI,uBAAuB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACA3B,IAAI,eAAe;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAnB,IAAI,mBAAmB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAvB,IAAI,kBAAkB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAtB,IAAI,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAZ,IAAI,cAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAlB,IAAI,SAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAb,IAAI,sBAAsB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACA1B,IAAI,SAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAb,IAAI,WAAW;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAf,IAAI,oBAAoB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAxB,IAAI,oBAAoB;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAxB,IAAI,cAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAlB,IAAI,kBAAkB;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAtB,IAAI,aAAa;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAjB,IAAI,cAAc;AAAA;AAAA;AAAA;AAAA;;;ACAlB,IAAI,YAAY;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAhB,IAAI,kBAAkB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAtB,IAAI,WAAW;AAAA;;;ACAf,IAAI,gBAAgB;AAAA;AAAA;;;ACApB,IAAI,sBAAsB;AAAA;AAAA;;;ACA1B,IAAI,sBAAsB;AAAA;AAAA;AAAA;;;ACA1B,IAAI,gBAAgB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACApB,IAAI,cAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAlB,IAAI,UAAU;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAd,IAAI,eAAe;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAnB,IAAI,aAAa;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAjB,IAAI,aAAa;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAjB,IAAI,aAAa;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAjB,IAAI,2BAA2B;AAAA;AAAA;;;ACA/B,IAAI,0BAA0B;AAAA;AAAA;;;ACA9B,IAAI,oBAAoB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAxB,IAAI,uBAAuB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACA3B,IAAI,uBAAuB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACA3B,IAAI,wBAAwB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACA5B,IAAI,wBAAwB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACA5B,IAAI,wBAAwB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACA5B,IAAI,uBAAuB;AAAA;AAAA;AAAA;;;ACA3B,IAAI,wBAAwB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;A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A;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACvBV,IAAI,qBAAqB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAzB,IAAI,gBAAgB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACApB,IAAI,mBAAmB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAvB,IAAI,eAAe;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAnB,IAAI,gBAAgB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACApB,IAAI,eAAe;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAnB,IAAI,sBAAsB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACA1B,IAAI,mBAAmB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAvB,IAAI,sBAAsB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACA1B,IAAI,eAAe;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAnB,IAAI,qBAAqB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAzB,IAAI,mBAAmB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAvB,IAAI,iBAAiB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACArB,IAAI,cAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAlB,IAAI,YAAY;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAhB,IAAI,cAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAlB,IAAI,cAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAlB,IAAI,WAAW;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAf,IAAI,aAAa;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAjB,IAAI,cAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAlB,IAAI,sBAAsB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACA1B,IAAI,SAAS;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAb,IAAI,UAAU;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAd,IAAI,UAAU;AAAA;AAAA;AAAA;;;ACAd,IAAI,oBAAoB;AAAA;AAAA;AAAA;;;ACAxB,IAAI,yBAAyB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACA7B,IAAI,cAAc;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAlB,IAAI,oBAAoB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAxB,IAAI,QAAQ;AAAA;AAAA;AAAA;AAAA;;;ACAZ,IAAI,kBAAkB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAtB,IAAI,YAAY;AAAA;AAAA;AAAA;AAAA;;;ACAhB,IAAI,mBAAmB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAvB,IAAI,kBAAkB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAtB,IAAI,cAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAlB,IAAI,oBAAoB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAxB,IAAI,qBAAqB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAzB,IAAI,sBAAsB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACA1B,IAAI,oBAAoB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAxB,IAAI,sBAAsB;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACA1B,IAAI,uBAAuB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACA3B,IAAI,oBAAoB;AAAA;AAAA;AAAA;AAAA;;;ACAxB,IAAI,cAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAlB,IAAI,kBAAkB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAtB,IAAI,iBAAiB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACArB,IAAI,qBAAqB;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAzB,IAAI,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAZ,IAAI,QAAQ;AAAA;AAAA;AAAA;AAAA;;;ACAZ,IAAI,YAAY;AAAA;AAAA;AAAA;AAAA;;;ACAhB,IAAI,eAAe;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACgNnB,IAAM,eAAe;AAAA,EACpB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA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", + "names": ["target", "target", "c", "string", "c", "q", "x", "x", "array", "x", "y", "z", "epsilon", "x", "y", "z", "vec", "_Vec", "x", "y", "epsilon", "_Vec", "x", "y", "z", "epsilon", "_Mat", "vec", "x", "y", "z", "position", "target", "up", "right", "c", "data", "scale", "Quat", "x", "y", "z", "epsilon", "vec", "halfToRad", "center", "x", "y", "z", "tmpVecA", "tmpVecB", "center", "c", "matrix", "c", "target", "data", "data", "data", "array", "stringIds", "stringIds", "_ref", "target", "id", "stringIds", "data", "primitive", "stringIds", "target", "type", "id", "type", "data", "size", "KEYWORD", "id", "id", "x", "y", "z", "primitive", "c", "x", "y", "data", "id", "_ref", "data", "target", "type", "samplerTypes", "scale", "target", "type", "options", "vsCode", "target", "data", "x", "y", "z", "ua", "version", "primitive", "c", "target", "x", "y", "primitive", "id", "data", "c", "data", "data", "position", "fallOff", "position", "position", "time", "MAX_DISTANCE", "fallOff", "position", "vsCode", "_scissor", "target", "id", "type", "scene", "data", "scene", "scene", "id", "id", "data", "x", "y", "z", "target", "Quat", "x", "c", "path", "y", "z", "scale", "id", "scene", "data", "_depthUniformNames", "scene", "_halfSize", "viewProjMat", "x", "y", "z", "properties", "scene", "lights", "Quat", "device", "floatOffset", "id", "shape", "tempVec3", "epsilon", "lights", "x", "z", "y", "target", "arraysEqual", "x", "y", "lights", "lights", "c", "type", "lights", "z", "right", "up", "x", "y", "x", "shadowCamView", "type", "scene", "_viewport", "lights", "viewMat", "lights", "scene", "data", "x", "y", "target", "position", "lights", "scene", "scene", "scene", "lights", "id", "id", "c", "type", "target", "usedCount", "blending", "epsilon", "Model", "lights", "_duplicate", "ids", "data", "target", "data", "fShader", "p1", "p2", "v2", "v3", "x", "y", "z", "x", "y", "z", "type", "scene", "type", "scene", "center", "id", "matrix", "x", "y", "z", "center", "y", "array", "data", "x", "y", "deviceCache", "target", "type", "Quat", "type", "c", "decodeTable", "_matTex2D", "scene", "type", "scene", "asset", "setterFunc", "rotation", "getterFunc", "time", "position", "rotation", "scale", "Quat", "primitiveUv1Padding", "primitiveUv1PaddingScale", "x", "y", "z", "x", "y", "z", "x", "y", "z", "lights", "app", "type", "app", "deviceCache", "device", "data", "format", "scale", "type", "data", "app", "asset", "asset", "id", "type", "data", "err", "path", "asset", "id", "data", "id", "data", "data", "app", "asset", "data", "app", "app", "type", "asset", "self", "handleLoad", "data", "err", "onLoad", "data", "app", "id", "asset", "data", "app", "script", "app", "type", "data", "guid", "c", "app", "data", "sceneItem", "scene", "id", "err", "asset", "data", "script", "scene", "now", "center", "matrix", "x", "y", "Quat", "app", "guid", "makeTick", "data", "app", "data", "properties", "type", "time", "input", "data", "p1", "time", "type", "type", "Quat", "path", "target", "type", "c", "input", "events", "time", "escape", "string", "path", "c", "type", "path", "flatten", "findMeshInstances", "func", "type", "target", "type", "path", "time", "time", "path", "Quat", "path", "target", "flatten", "time", "data", "asset", "stateName", "type", "app", "data", "properties", "id", "path", "position", "_schema", "app", "data", "properties", "position", "Quat", "data", "asset", "shape", "Quat", "app", "data", "shape", "Quat", "_schema", "data", "Model", "position", "rotation", "scale", "shape", "x", "y", "z", "vec", "id", "asset", "app", "properties", "type", "type", "Model", "asset", "scene", "id", "events", "path", "app", "_schema", "app", "properties", "data", "asset", "scene", "id", "asset", "app", "_schema", "app", "properties", "data", "_ammoTransform", "_ammoVec1", "_ammoQuat", "Quat", "_vec3", "type", "shape", "x", "y", "z", "q", "_schema", "app", "data", "properties", "shape", "guid", "c", "onLoad", "asset", "data", "position", "_schema", "app", "data", "properties", "id", "position", "app", "scene", "type", "_schema", "app", "data", "properties", "c", "asset", "c", "data", "app", "data", "input", "data", "attributeOrder", "generateNormals", "a", "b", "c", "v2", "data", "workers", "data", "x", "data", "primitive", "type", "texture", "result", "target", "scale", "rotation", "path", "scene", "lights", "options", "asset", "_ref", "_ref2", "array", "version", "buffer", "err", "app", "asset", "err", "data", "anim", "Quat", "ua", "app", "success", "error", "audio", "onReady", "data", "asset", "createAsset", "type", "createMeshInstance", "scene", "model", "skinInstances", "Model", "destroyAsset", "destroyAssets", "asset", "err", "result", "data", "app", "asset", "data", "data", "asset", "data", "Model", "sparseToFull", "app", "data", "asset", "err", "self", "handleMaterial", "id", "path", "deviceDetails", "data", "genB", "queue", "data", "queue", "defaultNumWorkers", "lazyConfig", "asset", "data", "asset", "data", "asset", "data", "IDENTIFIER", "asset", "data", "target", "asset", "data", "asset", "data", "asset", "data", "x", "y", "_completePartialMipmapChain", "isHtmlElement", "downsample", "data", "y", "x", "app", "asset", "id", "Quat", "id", "quat", "Quat", "position", "rotation", "vecA", "vecB", "p1", "p2", "q", "x", "y", "touch", "c", "guid", "target", "scale", "right", "z", "_viewport", "time", "id", "s", "e", "matrix", "position", "type", "x", "y", "_PlayCanvasAudio", "audio", "Audio", "asset", "MELEMENT_PROPERTY_NAME", "app", "Model", "LoadingInstanceManager", "Image", "scene", "anim", "scale", "TransformableElement", "CanvasText", "z", "EventHandlerCollection", "rotation", "calculateContentSize", "up", "center", "x", "y", "z", "quaternion", "EventHandlerCollection", "ammo_wasm_default", "draco_wasm_default", "StandalonePlayCanvasAdapterControlsType", "type", "position", "rotation", "vec", "Matr4", "skybox", "envMapAsset"] +} diff --git a/pull/212/v1/ThreeJSModeInternal-OES4PZ5X.js b/pull/212/v1/ThreeJSModeInternal-OES4PZ5X.js new file mode 100644 index 00000000..0c28371f --- /dev/null +++ b/pull/212/v1/ThreeJSModeInternal-OES4PZ5X.js @@ -0,0 +1,34003 @@ +import { + calculateContentBounds, + envMaps, + parseXYZ +} from "./chunk-CPWJBFSW.js"; +import { + Audio, + AudioGraphics, + CanvasText, + ChatProbeGraphics, + CubeGraphics, + CylinderGraphics, + DebugHelperGraphics, + EventHandlerCollection, + FrameGraphics, + FullScreenMMLScene, + Image as Image2, + ImageGraphics, + InteractionGraphics, + LabelGraphics, + LightGraphics, + LightTypes, + LinkGraphics, + LoadingInstanceManager, + MELEMENT_PROPERTY_NAME, + MElement, + MElementGraphics, + MMLNetworkSource, + Matr4, + Model, + ModelGraphics, + NetworkedDOMWebsocketStatus, + NetworkedDOMWebsocketStatusToString, + PlaneGraphics, + PositionProbeGraphics, + PromptGraphics, + Quat, + RemoteDocumentGraphics, + SphereGraphics, + StaticFileVideoSource, + StatusUI, + TransformableElement, + TransformableGraphics, + VideoGraphics, + WHEPVideoSource, + ambientLightColorField, + ambientLightField, + backgroundColorField, + calculateContentSize, + cameraFitContents, + cameraFovField, + cameraLookAtField, + cameraModeField, + cameraOrbitDistanceField, + cameraOrbitPitchField, + cameraOrbitSpeedField, + cameraPositionField, + environmentMapField, + getRelativePositionAndRotationRelativeToObject, + parseColorAttribute, + radToDeg, + setDebugGlobals +} from "./chunk-OGDCF6KN.js"; + +// ../../node_modules/three/build/three.module.js +var REVISION = "163"; +var CullFaceNone = 0; +var CullFaceBack = 1; +var CullFaceFront = 2; +var PCFShadowMap = 1; +var PCFSoftShadowMap = 2; +var VSMShadowMap = 3; +var FrontSide = 0; +var BackSide = 1; +var DoubleSide = 2; +var NoBlending = 0; +var NormalBlending = 1; +var AdditiveBlending = 2; +var SubtractiveBlending = 3; +var MultiplyBlending = 4; +var CustomBlending = 5; +var AddEquation = 100; +var SubtractEquation = 101; +var ReverseSubtractEquation = 102; +var MinEquation = 103; +var MaxEquation = 104; +var ZeroFactor = 200; +var OneFactor = 201; +var SrcColorFactor = 202; +var OneMinusSrcColorFactor = 203; +var SrcAlphaFactor = 204; +var OneMinusSrcAlphaFactor = 205; +var DstAlphaFactor = 206; +var OneMinusDstAlphaFactor = 207; +var DstColorFactor = 208; +var OneMinusDstColorFactor = 209; +var SrcAlphaSaturateFactor = 210; +var ConstantColorFactor = 211; +var OneMinusConstantColorFactor = 212; +var ConstantAlphaFactor = 213; +var OneMinusConstantAlphaFactor = 214; +var NeverDepth = 0; +var AlwaysDepth = 1; +var LessDepth = 2; +var LessEqualDepth = 3; +var EqualDepth = 4; +var GreaterEqualDepth = 5; +var GreaterDepth = 6; +var NotEqualDepth = 7; +var MultiplyOperation = 0; +var MixOperation = 1; +var AddOperation = 2; +var NoToneMapping = 0; +var LinearToneMapping = 1; +var ReinhardToneMapping = 2; +var CineonToneMapping = 3; +var ACESFilmicToneMapping = 4; +var CustomToneMapping = 5; +var AgXToneMapping = 6; +var NeutralToneMapping = 7; +var AttachedBindMode = "attached"; +var DetachedBindMode = "detached"; +var UVMapping = 300; +var CubeReflectionMapping = 301; +var CubeRefractionMapping = 302; +var EquirectangularReflectionMapping = 303; +var EquirectangularRefractionMapping = 304; +var CubeUVReflectionMapping = 306; +var RepeatWrapping = 1e3; +var ClampToEdgeWrapping = 1001; +var MirroredRepeatWrapping = 1002; +var NearestFilter = 1003; +var NearestMipmapNearestFilter = 1004; +var NearestMipmapLinearFilter = 1005; +var LinearFilter = 1006; +var LinearMipmapNearestFilter = 1007; +var LinearMipmapLinearFilter = 1008; +var LinearMipMapLinearFilter = 1008; +var UnsignedByteType = 1009; +var ByteType = 1010; +var ShortType = 1011; +var UnsignedShortType = 1012; +var IntType = 1013; +var UnsignedIntType = 1014; +var FloatType = 1015; +var HalfFloatType = 1016; +var UnsignedShort4444Type = 1017; +var UnsignedShort5551Type = 1018; +var UnsignedInt248Type = 1020; +var UnsignedInt5999Type = 35902; +var AlphaFormat = 1021; +var RGBFormat = 1022; +var RGBAFormat = 1023; +var LuminanceFormat = 1024; +var LuminanceAlphaFormat = 1025; +var DepthFormat = 1026; +var DepthStencilFormat = 1027; +var RedFormat = 1028; +var RedIntegerFormat = 1029; +var RGFormat = 1030; +var RGIntegerFormat = 1031; +var RGBAIntegerFormat = 1033; +var RGB_S3TC_DXT1_Format = 33776; +var RGBA_S3TC_DXT1_Format = 33777; +var RGBA_S3TC_DXT3_Format = 33778; +var RGBA_S3TC_DXT5_Format = 33779; +var RGB_PVRTC_4BPPV1_Format = 35840; +var RGB_PVRTC_2BPPV1_Format = 35841; +var RGBA_PVRTC_4BPPV1_Format = 35842; +var RGBA_PVRTC_2BPPV1_Format = 35843; +var RGB_ETC1_Format = 36196; +var RGB_ETC2_Format = 37492; +var RGBA_ETC2_EAC_Format = 37496; +var RGBA_ASTC_4x4_Format = 37808; +var RGBA_ASTC_5x4_Format = 37809; +var RGBA_ASTC_5x5_Format = 37810; +var RGBA_ASTC_6x5_Format = 37811; +var RGBA_ASTC_6x6_Format = 37812; +var RGBA_ASTC_8x5_Format = 37813; +var RGBA_ASTC_8x6_Format = 37814; +var RGBA_ASTC_8x8_Format = 37815; +var RGBA_ASTC_10x5_Format = 37816; +var RGBA_ASTC_10x6_Format = 37817; +var RGBA_ASTC_10x8_Format = 37818; +var RGBA_ASTC_10x10_Format = 37819; +var RGBA_ASTC_12x10_Format = 37820; +var RGBA_ASTC_12x12_Format = 37821; +var RGBA_BPTC_Format = 36492; +var RGB_BPTC_SIGNED_Format = 36494; +var RGB_BPTC_UNSIGNED_Format = 36495; +var RED_RGTC1_Format = 36283; +var SIGNED_RED_RGTC1_Format = 36284; +var RED_GREEN_RGTC2_Format = 36285; +var SIGNED_RED_GREEN_RGTC2_Format = 36286; +var LoopOnce = 2200; +var LoopRepeat = 2201; +var LoopPingPong = 2202; +var InterpolateDiscrete = 2300; +var InterpolateLinear = 2301; +var InterpolateSmooth = 2302; +var ZeroCurvatureEnding = 2400; +var ZeroSlopeEnding = 2401; +var WrapAroundEnding = 2402; +var NormalAnimationBlendMode = 2500; +var AdditiveAnimationBlendMode = 2501; +var TrianglesDrawMode = 0; +var TriangleStripDrawMode = 1; +var TriangleFanDrawMode = 2; +var BasicDepthPacking = 3200; +var RGBADepthPacking = 3201; +var TangentSpaceNormalMap = 0; +var ObjectSpaceNormalMap = 1; +var NoColorSpace = ""; +var SRGBColorSpace = "srgb"; +var LinearSRGBColorSpace = "srgb-linear"; +var DisplayP3ColorSpace = "display-p3"; +var LinearDisplayP3ColorSpace = "display-p3-linear"; +var LinearTransfer = "linear"; +var SRGBTransfer = "srgb"; +var Rec709Primaries = "rec709"; +var P3Primaries = "p3"; +var KeepStencilOp = 7680; +var AlwaysStencilFunc = 519; +var NeverCompare = 512; +var LessCompare = 513; +var EqualCompare = 514; +var LessEqualCompare = 515; +var GreaterCompare = 516; +var NotEqualCompare = 517; +var GreaterEqualCompare = 518; +var AlwaysCompare = 519; +var StaticDrawUsage = 35044; +var GLSL3 = "300 es"; +var WebGLCoordinateSystem = 2e3; +var WebGPUCoordinateSystem = 2001; +var EventDispatcher = class { + addEventListener(type, listener) { + if (this._listeners === void 0) this._listeners = {}; + const listeners = this._listeners; + if (listeners[type] === void 0) { + listeners[type] = []; + } + if (listeners[type].indexOf(listener) === -1) { + listeners[type].push(listener); + } + } + hasEventListener(type, listener) { + if (this._listeners === void 0) return false; + const listeners = this._listeners; + return listeners[type] !== void 0 && listeners[type].indexOf(listener) !== -1; + } + removeEventListener(type, listener) { + if (this._listeners === void 0) return; + const listeners = this._listeners; + const listenerArray = listeners[type]; + if (listenerArray !== void 0) { + const index = listenerArray.indexOf(listener); + if (index !== -1) { + listenerArray.splice(index, 1); + } + } + } + dispatchEvent(event) { + if (this._listeners === void 0) return; + const listeners = this._listeners; + const listenerArray = listeners[event.type]; + if (listenerArray !== void 0) { + event.target = this; + const array = listenerArray.slice(0); + for (let i = 0, l = array.length; i < l; i++) { + array[i].call(this, event); + } + event.target = null; + } + } +}; +var _lut = ["00", "01", "02", "03", "04", "05", "06", "07", "08", "09", "0a", "0b", "0c", "0d", "0e", "0f", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "1a", "1b", "1c", "1d", "1e", "1f", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "2a", "2b", "2c", "2d", "2e", "2f", "30", "31", "32", "33", "34", "35", "36", "37", "38", "39", "3a", "3b", "3c", "3d", "3e", "3f", "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "4a", "4b", "4c", "4d", "4e", "4f", "50", "51", "52", "53", "54", "55", "56", "57", "58", "59", "5a", "5b", "5c", "5d", "5e", "5f", "60", "61", "62", "63", "64", "65", "66", "67", "68", "69", "6a", "6b", "6c", "6d", "6e", "6f", "70", "71", "72", "73", "74", "75", "76", "77", "78", "79", "7a", "7b", "7c", "7d", "7e", "7f", "80", "81", "82", "83", "84", "85", "86", "87", "88", "89", "8a", "8b", "8c", "8d", "8e", "8f", "90", "91", "92", "93", "94", "95", "96", "97", "98", "99", "9a", "9b", "9c", "9d", "9e", "9f", "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7", "a8", "a9", "aa", "ab", "ac", "ad", "ae", "af", "b0", "b1", "b2", "b3", "b4", "b5", "b6", "b7", "b8", "b9", "ba", "bb", "bc", "bd", "be", "bf", "c0", "c1", "c2", "c3", "c4", "c5", "c6", "c7", "c8", "c9", "ca", "cb", "cc", "cd", "ce", "cf", "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "d8", "d9", "da", "db", "dc", "dd", "de", "df", "e0", "e1", "e2", "e3", "e4", "e5", "e6", "e7", "e8", "e9", "ea", "eb", "ec", "ed", "ee", "ef", "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", "f9", "fa", "fb", "fc", "fd", "fe", "ff"]; +var _seed = 1234567; +var DEG2RAD = Math.PI / 180; +var RAD2DEG = 180 / Math.PI; +function generateUUID() { + const d0 = Math.random() * 4294967295 | 0; + const d1 = Math.random() * 4294967295 | 0; + const d2 = Math.random() * 4294967295 | 0; + const d3 = Math.random() * 4294967295 | 0; + const uuid = _lut[d0 & 255] + _lut[d0 >> 8 & 255] + _lut[d0 >> 16 & 255] + _lut[d0 >> 24 & 255] + "-" + _lut[d1 & 255] + _lut[d1 >> 8 & 255] + "-" + _lut[d1 >> 16 & 15 | 64] + _lut[d1 >> 24 & 255] + "-" + _lut[d2 & 63 | 128] + _lut[d2 >> 8 & 255] + "-" + _lut[d2 >> 16 & 255] + _lut[d2 >> 24 & 255] + _lut[d3 & 255] + _lut[d3 >> 8 & 255] + _lut[d3 >> 16 & 255] + _lut[d3 >> 24 & 255]; + return uuid.toLowerCase(); +} +function clamp(value, min, max2) { + return Math.max(min, Math.min(max2, value)); +} +function euclideanModulo(n, m) { + return (n % m + m) % m; +} +function mapLinear(x, a1, a2, b1, b2) { + return b1 + (x - a1) * (b2 - b1) / (a2 - a1); +} +function inverseLerp(x, y, value) { + if (x !== y) { + return (value - x) / (y - x); + } else { + return 0; + } +} +function lerp(x, y, t) { + return (1 - t) * x + t * y; +} +function damp(x, y, lambda, dt) { + return lerp(x, y, 1 - Math.exp(-lambda * dt)); +} +function pingpong(x, length = 1) { + return length - Math.abs(euclideanModulo(x, length * 2) - length); +} +function smoothstep(x, min, max2) { + if (x <= min) return 0; + if (x >= max2) return 1; + x = (x - min) / (max2 - min); + return x * x * (3 - 2 * x); +} +function smootherstep(x, min, max2) { + if (x <= min) return 0; + if (x >= max2) return 1; + x = (x - min) / (max2 - min); + return x * x * x * (x * (x * 6 - 15) + 10); +} +function randInt(low, high) { + return low + Math.floor(Math.random() * (high - low + 1)); +} +function randFloat(low, high) { + return low + Math.random() * (high - low); +} +function randFloatSpread(range) { + return range * (0.5 - Math.random()); +} +function seededRandom(s) { + if (s !== void 0) _seed = s; + let t = _seed += 1831565813; + t = Math.imul(t ^ t >>> 15, t | 1); + t ^= t + Math.imul(t ^ t >>> 7, t | 61); + return ((t ^ t >>> 14) >>> 0) / 4294967296; +} +function degToRad(degrees) { + return degrees * DEG2RAD; +} +function radToDeg2(radians) { + return radians * RAD2DEG; +} +function isPowerOfTwo(value) { + return (value & value - 1) === 0 && value !== 0; +} +function ceilPowerOfTwo(value) { + return Math.pow(2, Math.ceil(Math.log(value) / Math.LN2)); +} +function floorPowerOfTwo(value) { + return Math.pow(2, Math.floor(Math.log(value) / Math.LN2)); +} +function setQuaternionFromProperEuler(q, a, b, c, order) { + const cos = Math.cos; + const sin = Math.sin; + const c2 = cos(b / 2); + const s2 = sin(b / 2); + const c13 = cos((a + c) / 2); + const s13 = sin((a + c) / 2); + const c1_3 = cos((a - c) / 2); + const s1_3 = sin((a - c) / 2); + const c3_1 = cos((c - a) / 2); + const s3_1 = sin((c - a) / 2); + switch (order) { + case "XYX": + q.set(c2 * s13, s2 * c1_3, s2 * s1_3, c2 * c13); + break; + case "YZY": + q.set(s2 * s1_3, c2 * s13, s2 * c1_3, c2 * c13); + break; + case "ZXZ": + q.set(s2 * c1_3, s2 * s1_3, c2 * s13, c2 * c13); + break; + case "XZX": + q.set(c2 * s13, s2 * s3_1, s2 * c3_1, c2 * c13); + break; + case "YXY": + q.set(s2 * c3_1, c2 * s13, s2 * s3_1, c2 * c13); + break; + case "ZYZ": + q.set(s2 * s3_1, s2 * c3_1, c2 * s13, c2 * c13); + break; + default: + console.warn("THREE.MathUtils: .setQuaternionFromProperEuler() encountered an unknown order: " + order); + } +} +function denormalize(value, array) { + switch (array.constructor) { + case Float32Array: + return value; + case Uint32Array: + return value / 4294967295; + case Uint16Array: + return value / 65535; + case Uint8Array: + return value / 255; + case Int32Array: + return Math.max(value / 2147483647, -1); + case Int16Array: + return Math.max(value / 32767, -1); + case Int8Array: + return Math.max(value / 127, -1); + default: + throw new Error("Invalid component type."); + } +} +function normalize(value, array) { + switch (array.constructor) { + case Float32Array: + return value; + case Uint32Array: + return Math.round(value * 4294967295); + case Uint16Array: + return Math.round(value * 65535); + case Uint8Array: + return Math.round(value * 255); + case Int32Array: + return Math.round(value * 2147483647); + case Int16Array: + return Math.round(value * 32767); + case Int8Array: + return Math.round(value * 127); + default: + throw new Error("Invalid component type."); + } +} +var MathUtils = { + DEG2RAD, + RAD2DEG, + generateUUID, + clamp, + euclideanModulo, + mapLinear, + inverseLerp, + lerp, + damp, + pingpong, + smoothstep, + smootherstep, + randInt, + randFloat, + randFloatSpread, + seededRandom, + degToRad, + radToDeg: radToDeg2, + isPowerOfTwo, + ceilPowerOfTwo, + floorPowerOfTwo, + setQuaternionFromProperEuler, + normalize, + denormalize +}; +var Vector2 = class _Vector2 { + constructor(x = 0, y = 0) { + _Vector2.prototype.isVector2 = true; + this.x = x; + this.y = y; + } + get width() { + return this.x; + } + set width(value) { + this.x = value; + } + get height() { + return this.y; + } + set height(value) { + this.y = value; + } + set(x, y) { + this.x = x; + this.y = y; + return this; + } + setScalar(scalar) { + this.x = scalar; + this.y = scalar; + return this; + } + setX(x) { + this.x = x; + return this; + } + setY(y) { + this.y = y; + return this; + } + setComponent(index, value) { + switch (index) { + case 0: + this.x = value; + break; + case 1: + this.y = value; + break; + default: + throw new Error("index is out of range: " + index); + } + return this; + } + getComponent(index) { + switch (index) { + case 0: + return this.x; + case 1: + return this.y; + default: + throw new Error("index is out of range: " + index); + } + } + clone() { + return new this.constructor(this.x, this.y); + } + copy(v) { + this.x = v.x; + this.y = v.y; + return this; + } + add(v) { + this.x += v.x; + this.y += v.y; + return this; + } + addScalar(s) { + this.x += s; + this.y += s; + return this; + } + addVectors(a, b) { + this.x = a.x + b.x; + this.y = a.y + b.y; + return this; + } + addScaledVector(v, s) { + this.x += v.x * s; + this.y += v.y * s; + return this; + } + sub(v) { + this.x -= v.x; + this.y -= v.y; + return this; + } + subScalar(s) { + this.x -= s; + this.y -= s; + return this; + } + subVectors(a, b) { + this.x = a.x - b.x; + this.y = a.y - b.y; + return this; + } + multiply(v) { + this.x *= v.x; + this.y *= v.y; + return this; + } + multiplyScalar(scalar) { + this.x *= scalar; + this.y *= scalar; + return this; + } + divide(v) { + this.x /= v.x; + this.y /= v.y; + return this; + } + divideScalar(scalar) { + return this.multiplyScalar(1 / scalar); + } + applyMatrix3(m) { + const x = this.x, y = this.y; + const e = m.elements; + this.x = e[0] * x + e[3] * y + e[6]; + this.y = e[1] * x + e[4] * y + e[7]; + return this; + } + min(v) { + this.x = Math.min(this.x, v.x); + this.y = Math.min(this.y, v.y); + return this; + } + max(v) { + this.x = Math.max(this.x, v.x); + this.y = Math.max(this.y, v.y); + return this; + } + clamp(min, max2) { + this.x = Math.max(min.x, Math.min(max2.x, this.x)); + this.y = Math.max(min.y, Math.min(max2.y, this.y)); + return this; + } + clampScalar(minVal, maxVal) { + this.x = Math.max(minVal, Math.min(maxVal, this.x)); + this.y = Math.max(minVal, Math.min(maxVal, this.y)); + return this; + } + clampLength(min, max2) { + const length = this.length(); + return this.divideScalar(length || 1).multiplyScalar(Math.max(min, Math.min(max2, length))); + } + floor() { + this.x = Math.floor(this.x); + this.y = Math.floor(this.y); + return this; + } + ceil() { + this.x = Math.ceil(this.x); + this.y = Math.ceil(this.y); + return this; + } + round() { + this.x = Math.round(this.x); + this.y = Math.round(this.y); + return this; + } + roundToZero() { + this.x = Math.trunc(this.x); + this.y = Math.trunc(this.y); + return this; + } + negate() { + this.x = -this.x; + this.y = -this.y; + return this; + } + dot(v) { + return this.x * v.x + this.y * v.y; + } + cross(v) { + return this.x * v.y - this.y * v.x; + } + lengthSq() { + return this.x * this.x + this.y * this.y; + } + length() { + return Math.sqrt(this.x * this.x + this.y * this.y); + } + manhattanLength() { + return Math.abs(this.x) + Math.abs(this.y); + } + normalize() { + return this.divideScalar(this.length() || 1); + } + angle() { + const angle = Math.atan2(-this.y, -this.x) + Math.PI; + return angle; + } + angleTo(v) { + const denominator = Math.sqrt(this.lengthSq() * v.lengthSq()); + if (denominator === 0) return Math.PI / 2; + const theta = this.dot(v) / denominator; + return Math.acos(clamp(theta, -1, 1)); + } + distanceTo(v) { + return Math.sqrt(this.distanceToSquared(v)); + } + distanceToSquared(v) { + const dx = this.x - v.x, dy = this.y - v.y; + return dx * dx + dy * dy; + } + manhattanDistanceTo(v) { + return Math.abs(this.x - v.x) + Math.abs(this.y - v.y); + } + setLength(length) { + return this.normalize().multiplyScalar(length); + } + lerp(v, alpha) { + this.x += (v.x - this.x) * alpha; + this.y += (v.y - this.y) * alpha; + return this; + } + lerpVectors(v1, v2, alpha) { + this.x = v1.x + (v2.x - v1.x) * alpha; + this.y = v1.y + (v2.y - v1.y) * alpha; + return this; + } + equals(v) { + return v.x === this.x && v.y === this.y; + } + fromArray(array, offset = 0) { + this.x = array[offset]; + this.y = array[offset + 1]; + return this; + } + toArray(array = [], offset = 0) { + array[offset] = this.x; + array[offset + 1] = this.y; + return array; + } + fromBufferAttribute(attribute, index) { + this.x = attribute.getX(index); + this.y = attribute.getY(index); + return this; + } + rotateAround(center, angle) { + const c = Math.cos(angle), s = Math.sin(angle); + const x = this.x - center.x; + const y = this.y - center.y; + this.x = x * c - y * s + center.x; + this.y = x * s + y * c + center.y; + return this; + } + random() { + this.x = Math.random(); + this.y = Math.random(); + return this; + } + *[Symbol.iterator]() { + yield this.x; + yield this.y; + } +}; +var Matrix3 = class _Matrix3 { + constructor(n11, n12, n13, n21, n22, n23, n31, n32, n33) { + _Matrix3.prototype.isMatrix3 = true; + this.elements = [ + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1 + ]; + if (n11 !== void 0) { + this.set(n11, n12, n13, n21, n22, n23, n31, n32, n33); + } + } + set(n11, n12, n13, n21, n22, n23, n31, n32, n33) { + const te = this.elements; + te[0] = n11; + te[1] = n21; + te[2] = n31; + te[3] = n12; + te[4] = n22; + te[5] = n32; + te[6] = n13; + te[7] = n23; + te[8] = n33; + return this; + } + identity() { + this.set( + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1 + ); + return this; + } + copy(m) { + const te = this.elements; + const me = m.elements; + te[0] = me[0]; + te[1] = me[1]; + te[2] = me[2]; + te[3] = me[3]; + te[4] = me[4]; + te[5] = me[5]; + te[6] = me[6]; + te[7] = me[7]; + te[8] = me[8]; + return this; + } + extractBasis(xAxis, yAxis, zAxis) { + xAxis.setFromMatrix3Column(this, 0); + yAxis.setFromMatrix3Column(this, 1); + zAxis.setFromMatrix3Column(this, 2); + return this; + } + setFromMatrix4(m) { + const me = m.elements; + this.set( + me[0], + me[4], + me[8], + me[1], + me[5], + me[9], + me[2], + me[6], + me[10] + ); + return this; + } + multiply(m) { + return this.multiplyMatrices(this, m); + } + premultiply(m) { + return this.multiplyMatrices(m, this); + } + multiplyMatrices(a, b) { + const ae = a.elements; + const be = b.elements; + const te = this.elements; + const a11 = ae[0], a12 = ae[3], a13 = ae[6]; + const a21 = ae[1], a22 = ae[4], a23 = ae[7]; + const a31 = ae[2], a32 = ae[5], a33 = ae[8]; + const b11 = be[0], b12 = be[3], b13 = be[6]; + const b21 = be[1], b22 = be[4], b23 = be[7]; + const b31 = be[2], b32 = be[5], b33 = be[8]; + te[0] = a11 * b11 + a12 * b21 + a13 * b31; + te[3] = a11 * b12 + a12 * b22 + a13 * b32; + te[6] = a11 * b13 + a12 * b23 + a13 * b33; + te[1] = a21 * b11 + a22 * b21 + a23 * b31; + te[4] = a21 * b12 + a22 * b22 + a23 * b32; + te[7] = a21 * b13 + a22 * b23 + a23 * b33; + te[2] = a31 * b11 + a32 * b21 + a33 * b31; + te[5] = a31 * b12 + a32 * b22 + a33 * b32; + te[8] = a31 * b13 + a32 * b23 + a33 * b33; + return this; + } + multiplyScalar(s) { + const te = this.elements; + te[0] *= s; + te[3] *= s; + te[6] *= s; + te[1] *= s; + te[4] *= s; + te[7] *= s; + te[2] *= s; + te[5] *= s; + te[8] *= s; + return this; + } + determinant() { + const te = this.elements; + const a = te[0], b = te[1], c = te[2], d = te[3], e = te[4], f = te[5], g = te[6], h = te[7], i = te[8]; + return a * e * i - a * f * h - b * d * i + b * f * g + c * d * h - c * e * g; + } + invert() { + const te = this.elements, n11 = te[0], n21 = te[1], n31 = te[2], n12 = te[3], n22 = te[4], n32 = te[5], n13 = te[6], n23 = te[7], n33 = te[8], t11 = n33 * n22 - n32 * n23, t12 = n32 * n13 - n33 * n12, t13 = n23 * n12 - n22 * n13, det = n11 * t11 + n21 * t12 + n31 * t13; + if (det === 0) return this.set(0, 0, 0, 0, 0, 0, 0, 0, 0); + const detInv = 1 / det; + te[0] = t11 * detInv; + te[1] = (n31 * n23 - n33 * n21) * detInv; + te[2] = (n32 * n21 - n31 * n22) * detInv; + te[3] = t12 * detInv; + te[4] = (n33 * n11 - n31 * n13) * detInv; + te[5] = (n31 * n12 - n32 * n11) * detInv; + te[6] = t13 * detInv; + te[7] = (n21 * n13 - n23 * n11) * detInv; + te[8] = (n22 * n11 - n21 * n12) * detInv; + return this; + } + transpose() { + let tmp; + const m = this.elements; + tmp = m[1]; + m[1] = m[3]; + m[3] = tmp; + tmp = m[2]; + m[2] = m[6]; + m[6] = tmp; + tmp = m[5]; + m[5] = m[7]; + m[7] = tmp; + return this; + } + getNormalMatrix(matrix4) { + return this.setFromMatrix4(matrix4).invert().transpose(); + } + transposeIntoArray(r) { + const m = this.elements; + r[0] = m[0]; + r[1] = m[3]; + r[2] = m[6]; + r[3] = m[1]; + r[4] = m[4]; + r[5] = m[7]; + r[6] = m[2]; + r[7] = m[5]; + r[8] = m[8]; + return this; + } + setUvTransform(tx, ty, sx, sy, rotation, cx, cy) { + const c = Math.cos(rotation); + const s = Math.sin(rotation); + this.set( + sx * c, + sx * s, + -sx * (c * cx + s * cy) + cx + tx, + -sy * s, + sy * c, + -sy * (-s * cx + c * cy) + cy + ty, + 0, + 0, + 1 + ); + return this; + } + // + scale(sx, sy) { + this.premultiply(_m3.makeScale(sx, sy)); + return this; + } + rotate(theta) { + this.premultiply(_m3.makeRotation(-theta)); + return this; + } + translate(tx, ty) { + this.premultiply(_m3.makeTranslation(tx, ty)); + return this; + } + // for 2D Transforms + makeTranslation(x, y) { + if (x.isVector2) { + this.set( + 1, + 0, + x.x, + 0, + 1, + x.y, + 0, + 0, + 1 + ); + } else { + this.set( + 1, + 0, + x, + 0, + 1, + y, + 0, + 0, + 1 + ); + } + return this; + } + makeRotation(theta) { + const c = Math.cos(theta); + const s = Math.sin(theta); + this.set( + c, + -s, + 0, + s, + c, + 0, + 0, + 0, + 1 + ); + return this; + } + makeScale(x, y) { + this.set( + x, + 0, + 0, + 0, + y, + 0, + 0, + 0, + 1 + ); + return this; + } + // + equals(matrix) { + const te = this.elements; + const me = matrix.elements; + for (let i = 0; i < 9; i++) { + if (te[i] !== me[i]) return false; + } + return true; + } + fromArray(array, offset = 0) { + for (let i = 0; i < 9; i++) { + this.elements[i] = array[i + offset]; + } + return this; + } + toArray(array = [], offset = 0) { + const te = this.elements; + array[offset] = te[0]; + array[offset + 1] = te[1]; + array[offset + 2] = te[2]; + array[offset + 3] = te[3]; + array[offset + 4] = te[4]; + array[offset + 5] = te[5]; + array[offset + 6] = te[6]; + array[offset + 7] = te[7]; + array[offset + 8] = te[8]; + return array; + } + clone() { + return new this.constructor().fromArray(this.elements); + } +}; +var _m3 = /* @__PURE__ */ new Matrix3(); +function arrayNeedsUint32(array) { + for (let i = array.length - 1; i >= 0; --i) { + if (array[i] >= 65535) return true; + } + return false; +} +function createElementNS(name) { + return document.createElementNS("http://www.w3.org/1999/xhtml", name); +} +function createCanvasElement() { + const canvas = createElementNS("canvas"); + canvas.style.display = "block"; + return canvas; +} +var _cache = {}; +function warnOnce(message) { + if (message in _cache) return; + _cache[message] = true; + console.warn(message); +} +var LINEAR_SRGB_TO_LINEAR_DISPLAY_P3 = /* @__PURE__ */ new Matrix3().set( + 0.8224621, + 0.177538, + 0, + 0.0331941, + 0.9668058, + 0, + 0.0170827, + 0.0723974, + 0.9105199 +); +var LINEAR_DISPLAY_P3_TO_LINEAR_SRGB = /* @__PURE__ */ new Matrix3().set( + 1.2249401, + -0.2249404, + 0, + -0.0420569, + 1.0420571, + 0, + -0.0196376, + -0.0786361, + 1.0982735 +); +var COLOR_SPACES = { + [LinearSRGBColorSpace]: { + transfer: LinearTransfer, + primaries: Rec709Primaries, + toReference: (color) => color, + fromReference: (color) => color + }, + [SRGBColorSpace]: { + transfer: SRGBTransfer, + primaries: Rec709Primaries, + toReference: (color) => color.convertSRGBToLinear(), + fromReference: (color) => color.convertLinearToSRGB() + }, + [LinearDisplayP3ColorSpace]: { + transfer: LinearTransfer, + primaries: P3Primaries, + toReference: (color) => color.applyMatrix3(LINEAR_DISPLAY_P3_TO_LINEAR_SRGB), + fromReference: (color) => color.applyMatrix3(LINEAR_SRGB_TO_LINEAR_DISPLAY_P3) + }, + [DisplayP3ColorSpace]: { + transfer: SRGBTransfer, + primaries: P3Primaries, + toReference: (color) => color.convertSRGBToLinear().applyMatrix3(LINEAR_DISPLAY_P3_TO_LINEAR_SRGB), + fromReference: (color) => color.applyMatrix3(LINEAR_SRGB_TO_LINEAR_DISPLAY_P3).convertLinearToSRGB() + } +}; +var SUPPORTED_WORKING_COLOR_SPACES = /* @__PURE__ */ new Set([LinearSRGBColorSpace, LinearDisplayP3ColorSpace]); +var ColorManagement = { + enabled: true, + _workingColorSpace: LinearSRGBColorSpace, + get workingColorSpace() { + return this._workingColorSpace; + }, + set workingColorSpace(colorSpace) { + if (!SUPPORTED_WORKING_COLOR_SPACES.has(colorSpace)) { + throw new Error(`Unsupported working color space, "${colorSpace}".`); + } + this._workingColorSpace = colorSpace; + }, + convert: function(color, sourceColorSpace, targetColorSpace) { + if (this.enabled === false || sourceColorSpace === targetColorSpace || !sourceColorSpace || !targetColorSpace) { + return color; + } + const sourceToReference = COLOR_SPACES[sourceColorSpace].toReference; + const targetFromReference = COLOR_SPACES[targetColorSpace].fromReference; + return targetFromReference(sourceToReference(color)); + }, + fromWorkingColorSpace: function(color, targetColorSpace) { + return this.convert(color, this._workingColorSpace, targetColorSpace); + }, + toWorkingColorSpace: function(color, sourceColorSpace) { + return this.convert(color, sourceColorSpace, this._workingColorSpace); + }, + getPrimaries: function(colorSpace) { + return COLOR_SPACES[colorSpace].primaries; + }, + getTransfer: function(colorSpace) { + if (colorSpace === NoColorSpace) return LinearTransfer; + return COLOR_SPACES[colorSpace].transfer; + } +}; +function SRGBToLinear(c) { + return c < 0.04045 ? c * 0.0773993808 : Math.pow(c * 0.9478672986 + 0.0521327014, 2.4); +} +function LinearToSRGB(c) { + return c < 31308e-7 ? c * 12.92 : 1.055 * Math.pow(c, 0.41666) - 0.055; +} +var _canvas; +var ImageUtils = class { + static getDataURL(image) { + if (/^data:/i.test(image.src)) { + return image.src; + } + if (typeof HTMLCanvasElement === "undefined") { + return image.src; + } + let canvas; + if (image instanceof HTMLCanvasElement) { + canvas = image; + } else { + if (_canvas === void 0) _canvas = createElementNS("canvas"); + _canvas.width = image.width; + _canvas.height = image.height; + const context = _canvas.getContext("2d"); + if (image instanceof ImageData) { + context.putImageData(image, 0, 0); + } else { + context.drawImage(image, 0, 0, image.width, image.height); + } + canvas = _canvas; + } + if (canvas.width > 2048 || canvas.height > 2048) { + console.warn("THREE.ImageUtils.getDataURL: Image converted to jpg for performance reasons", image); + return canvas.toDataURL("image/jpeg", 0.6); + } else { + return canvas.toDataURL("image/png"); + } + } + static sRGBToLinear(image) { + if (typeof HTMLImageElement !== "undefined" && image instanceof HTMLImageElement || typeof HTMLCanvasElement !== "undefined" && image instanceof HTMLCanvasElement || typeof ImageBitmap !== "undefined" && image instanceof ImageBitmap) { + const canvas = createElementNS("canvas"); + canvas.width = image.width; + canvas.height = image.height; + const context = canvas.getContext("2d"); + context.drawImage(image, 0, 0, image.width, image.height); + const imageData = context.getImageData(0, 0, image.width, image.height); + const data = imageData.data; + for (let i = 0; i < data.length; i++) { + data[i] = SRGBToLinear(data[i] / 255) * 255; + } + context.putImageData(imageData, 0, 0); + return canvas; + } else if (image.data) { + const data = image.data.slice(0); + for (let i = 0; i < data.length; i++) { + if (data instanceof Uint8Array || data instanceof Uint8ClampedArray) { + data[i] = Math.floor(SRGBToLinear(data[i] / 255) * 255); + } else { + data[i] = SRGBToLinear(data[i]); + } + } + return { + data, + width: image.width, + height: image.height + }; + } else { + console.warn("THREE.ImageUtils.sRGBToLinear(): Unsupported image type. No color space conversion applied."); + return image; + } + } +}; +var _sourceId = 0; +var Source = class { + constructor(data = null) { + this.isSource = true; + Object.defineProperty(this, "id", { value: _sourceId++ }); + this.uuid = generateUUID(); + this.data = data; + this.dataReady = true; + this.version = 0; + } + set needsUpdate(value) { + if (value === true) this.version++; + } + toJSON(meta) { + const isRootObject = meta === void 0 || typeof meta === "string"; + if (!isRootObject && meta.images[this.uuid] !== void 0) { + return meta.images[this.uuid]; + } + const output = { + uuid: this.uuid, + url: "" + }; + const data = this.data; + if (data !== null) { + let url; + if (Array.isArray(data)) { + url = []; + for (let i = 0, l = data.length; i < l; i++) { + if (data[i].isDataTexture) { + url.push(serializeImage(data[i].image)); + } else { + url.push(serializeImage(data[i])); + } + } + } else { + url = serializeImage(data); + } + output.url = url; + } + if (!isRootObject) { + meta.images[this.uuid] = output; + } + return output; + } +}; +function serializeImage(image) { + if (typeof HTMLImageElement !== "undefined" && image instanceof HTMLImageElement || typeof HTMLCanvasElement !== "undefined" && image instanceof HTMLCanvasElement || typeof ImageBitmap !== "undefined" && image instanceof ImageBitmap) { + return ImageUtils.getDataURL(image); + } else { + if (image.data) { + return { + data: Array.from(image.data), + width: image.width, + height: image.height, + type: image.data.constructor.name + }; + } else { + console.warn("THREE.Texture: Unable to serialize Texture."); + return {}; + } + } +} +var _textureId = 0; +var Texture = class _Texture extends EventDispatcher { + constructor(image = _Texture.DEFAULT_IMAGE, mapping = _Texture.DEFAULT_MAPPING, wrapS = ClampToEdgeWrapping, wrapT = ClampToEdgeWrapping, magFilter = LinearFilter, minFilter = LinearMipmapLinearFilter, format = RGBAFormat, type = UnsignedByteType, anisotropy = _Texture.DEFAULT_ANISOTROPY, colorSpace = NoColorSpace) { + super(); + this.isTexture = true; + Object.defineProperty(this, "id", { value: _textureId++ }); + this.uuid = generateUUID(); + this.name = ""; + this.source = new Source(image); + this.mipmaps = []; + this.mapping = mapping; + this.channel = 0; + this.wrapS = wrapS; + this.wrapT = wrapT; + this.magFilter = magFilter; + this.minFilter = minFilter; + this.anisotropy = anisotropy; + this.format = format; + this.internalFormat = null; + this.type = type; + this.offset = new Vector2(0, 0); + this.repeat = new Vector2(1, 1); + this.center = new Vector2(0, 0); + this.rotation = 0; + this.matrixAutoUpdate = true; + this.matrix = new Matrix3(); + this.generateMipmaps = true; + this.premultiplyAlpha = false; + this.flipY = true; + this.unpackAlignment = 4; + this.colorSpace = colorSpace; + this.userData = {}; + this.version = 0; + this.onUpdate = null; + this.isRenderTargetTexture = false; + this.pmremVersion = 0; + } + get image() { + return this.source.data; + } + set image(value = null) { + this.source.data = value; + } + updateMatrix() { + this.matrix.setUvTransform(this.offset.x, this.offset.y, this.repeat.x, this.repeat.y, this.rotation, this.center.x, this.center.y); + } + clone() { + return new this.constructor().copy(this); + } + copy(source) { + this.name = source.name; + this.source = source.source; + this.mipmaps = source.mipmaps.slice(0); + this.mapping = source.mapping; + this.channel = source.channel; + this.wrapS = source.wrapS; + this.wrapT = source.wrapT; + this.magFilter = source.magFilter; + this.minFilter = source.minFilter; + this.anisotropy = source.anisotropy; + this.format = source.format; + this.internalFormat = source.internalFormat; + this.type = source.type; + this.offset.copy(source.offset); + this.repeat.copy(source.repeat); + this.center.copy(source.center); + this.rotation = source.rotation; + this.matrixAutoUpdate = source.matrixAutoUpdate; + this.matrix.copy(source.matrix); + this.generateMipmaps = source.generateMipmaps; + this.premultiplyAlpha = source.premultiplyAlpha; + this.flipY = source.flipY; + this.unpackAlignment = source.unpackAlignment; + this.colorSpace = source.colorSpace; + this.userData = JSON.parse(JSON.stringify(source.userData)); + this.needsUpdate = true; + return this; + } + toJSON(meta) { + const isRootObject = meta === void 0 || typeof meta === "string"; + if (!isRootObject && meta.textures[this.uuid] !== void 0) { + return meta.textures[this.uuid]; + } + const output = { + metadata: { + version: 4.6, + type: "Texture", + generator: "Texture.toJSON" + }, + uuid: this.uuid, + name: this.name, + image: this.source.toJSON(meta).uuid, + mapping: this.mapping, + channel: this.channel, + repeat: [this.repeat.x, this.repeat.y], + offset: [this.offset.x, this.offset.y], + center: [this.center.x, this.center.y], + rotation: this.rotation, + wrap: [this.wrapS, this.wrapT], + format: this.format, + internalFormat: this.internalFormat, + type: this.type, + colorSpace: this.colorSpace, + minFilter: this.minFilter, + magFilter: this.magFilter, + anisotropy: this.anisotropy, + flipY: this.flipY, + generateMipmaps: this.generateMipmaps, + premultiplyAlpha: this.premultiplyAlpha, + unpackAlignment: this.unpackAlignment + }; + if (Object.keys(this.userData).length > 0) output.userData = this.userData; + if (!isRootObject) { + meta.textures[this.uuid] = output; + } + return output; + } + dispose() { + this.dispatchEvent({ type: "dispose" }); + } + transformUv(uv) { + if (this.mapping !== UVMapping) return uv; + uv.applyMatrix3(this.matrix); + if (uv.x < 0 || uv.x > 1) { + switch (this.wrapS) { + case RepeatWrapping: + uv.x = uv.x - Math.floor(uv.x); + break; + case ClampToEdgeWrapping: + uv.x = uv.x < 0 ? 0 : 1; + break; + case MirroredRepeatWrapping: + if (Math.abs(Math.floor(uv.x) % 2) === 1) { + uv.x = Math.ceil(uv.x) - uv.x; + } else { + uv.x = uv.x - Math.floor(uv.x); + } + break; + } + } + if (uv.y < 0 || uv.y > 1) { + switch (this.wrapT) { + case RepeatWrapping: + uv.y = uv.y - Math.floor(uv.y); + break; + case ClampToEdgeWrapping: + uv.y = uv.y < 0 ? 0 : 1; + break; + case MirroredRepeatWrapping: + if (Math.abs(Math.floor(uv.y) % 2) === 1) { + uv.y = Math.ceil(uv.y) - uv.y; + } else { + uv.y = uv.y - Math.floor(uv.y); + } + break; + } + } + if (this.flipY) { + uv.y = 1 - uv.y; + } + return uv; + } + set needsUpdate(value) { + if (value === true) { + this.version++; + this.source.needsUpdate = true; + } + } + set needsPMREMUpdate(value) { + if (value === true) { + this.pmremVersion++; + } + } +}; +Texture.DEFAULT_IMAGE = null; +Texture.DEFAULT_MAPPING = UVMapping; +Texture.DEFAULT_ANISOTROPY = 1; +var Vector4 = class _Vector4 { + constructor(x = 0, y = 0, z = 0, w = 1) { + _Vector4.prototype.isVector4 = true; + this.x = x; + this.y = y; + this.z = z; + this.w = w; + } + get width() { + return this.z; + } + set width(value) { + this.z = value; + } + get height() { + return this.w; + } + set height(value) { + this.w = value; + } + set(x, y, z, w) { + this.x = x; + this.y = y; + this.z = z; + this.w = w; + return this; + } + setScalar(scalar) { + this.x = scalar; + this.y = scalar; + this.z = scalar; + this.w = scalar; + return this; + } + setX(x) { + this.x = x; + return this; + } + setY(y) { + this.y = y; + return this; + } + setZ(z) { + this.z = z; + return this; + } + setW(w) { + this.w = w; + return this; + } + setComponent(index, value) { + switch (index) { + case 0: + this.x = value; + break; + case 1: + this.y = value; + break; + case 2: + this.z = value; + break; + case 3: + this.w = value; + break; + default: + throw new Error("index is out of range: " + index); + } + return this; + } + getComponent(index) { + switch (index) { + case 0: + return this.x; + case 1: + return this.y; + case 2: + return this.z; + case 3: + return this.w; + default: + throw new Error("index is out of range: " + index); + } + } + clone() { + return new this.constructor(this.x, this.y, this.z, this.w); + } + copy(v) { + this.x = v.x; + this.y = v.y; + this.z = v.z; + this.w = v.w !== void 0 ? v.w : 1; + return this; + } + add(v) { + this.x += v.x; + this.y += v.y; + this.z += v.z; + this.w += v.w; + return this; + } + addScalar(s) { + this.x += s; + this.y += s; + this.z += s; + this.w += s; + return this; + } + addVectors(a, b) { + this.x = a.x + b.x; + this.y = a.y + b.y; + this.z = a.z + b.z; + this.w = a.w + b.w; + return this; + } + addScaledVector(v, s) { + this.x += v.x * s; + this.y += v.y * s; + this.z += v.z * s; + this.w += v.w * s; + return this; + } + sub(v) { + this.x -= v.x; + this.y -= v.y; + this.z -= v.z; + this.w -= v.w; + return this; + } + subScalar(s) { + this.x -= s; + this.y -= s; + this.z -= s; + this.w -= s; + return this; + } + subVectors(a, b) { + this.x = a.x - b.x; + this.y = a.y - b.y; + this.z = a.z - b.z; + this.w = a.w - b.w; + return this; + } + multiply(v) { + this.x *= v.x; + this.y *= v.y; + this.z *= v.z; + this.w *= v.w; + return this; + } + multiplyScalar(scalar) { + this.x *= scalar; + this.y *= scalar; + this.z *= scalar; + this.w *= scalar; + return this; + } + applyMatrix4(m) { + const x = this.x, y = this.y, z = this.z, w = this.w; + const e = m.elements; + this.x = e[0] * x + e[4] * y + e[8] * z + e[12] * w; + this.y = e[1] * x + e[5] * y + e[9] * z + e[13] * w; + this.z = e[2] * x + e[6] * y + e[10] * z + e[14] * w; + this.w = e[3] * x + e[7] * y + e[11] * z + e[15] * w; + return this; + } + divideScalar(scalar) { + return this.multiplyScalar(1 / scalar); + } + setAxisAngleFromQuaternion(q) { + this.w = 2 * Math.acos(q.w); + const s = Math.sqrt(1 - q.w * q.w); + if (s < 1e-4) { + this.x = 1; + this.y = 0; + this.z = 0; + } else { + this.x = q.x / s; + this.y = q.y / s; + this.z = q.z / s; + } + return this; + } + setAxisAngleFromRotationMatrix(m) { + let angle, x, y, z; + const epsilon = 0.01, epsilon2 = 0.1, te = m.elements, m11 = te[0], m12 = te[4], m13 = te[8], m21 = te[1], m22 = te[5], m23 = te[9], m31 = te[2], m32 = te[6], m33 = te[10]; + if (Math.abs(m12 - m21) < epsilon && Math.abs(m13 - m31) < epsilon && Math.abs(m23 - m32) < epsilon) { + if (Math.abs(m12 + m21) < epsilon2 && Math.abs(m13 + m31) < epsilon2 && Math.abs(m23 + m32) < epsilon2 && Math.abs(m11 + m22 + m33 - 3) < epsilon2) { + this.set(1, 0, 0, 0); + return this; + } + angle = Math.PI; + const xx = (m11 + 1) / 2; + const yy = (m22 + 1) / 2; + const zz = (m33 + 1) / 2; + const xy = (m12 + m21) / 4; + const xz = (m13 + m31) / 4; + const yz = (m23 + m32) / 4; + if (xx > yy && xx > zz) { + if (xx < epsilon) { + x = 0; + y = 0.707106781; + z = 0.707106781; + } else { + x = Math.sqrt(xx); + y = xy / x; + z = xz / x; + } + } else if (yy > zz) { + if (yy < epsilon) { + x = 0.707106781; + y = 0; + z = 0.707106781; + } else { + y = Math.sqrt(yy); + x = xy / y; + z = yz / y; + } + } else { + if (zz < epsilon) { + x = 0.707106781; + y = 0.707106781; + z = 0; + } else { + z = Math.sqrt(zz); + x = xz / z; + y = yz / z; + } + } + this.set(x, y, z, angle); + return this; + } + let s = Math.sqrt((m32 - m23) * (m32 - m23) + (m13 - m31) * (m13 - m31) + (m21 - m12) * (m21 - m12)); + if (Math.abs(s) < 1e-3) s = 1; + this.x = (m32 - m23) / s; + this.y = (m13 - m31) / s; + this.z = (m21 - m12) / s; + this.w = Math.acos((m11 + m22 + m33 - 1) / 2); + return this; + } + min(v) { + this.x = Math.min(this.x, v.x); + this.y = Math.min(this.y, v.y); + this.z = Math.min(this.z, v.z); + this.w = Math.min(this.w, v.w); + return this; + } + max(v) { + this.x = Math.max(this.x, v.x); + this.y = Math.max(this.y, v.y); + this.z = Math.max(this.z, v.z); + this.w = Math.max(this.w, v.w); + return this; + } + clamp(min, max2) { + this.x = Math.max(min.x, Math.min(max2.x, this.x)); + this.y = Math.max(min.y, Math.min(max2.y, this.y)); + this.z = Math.max(min.z, Math.min(max2.z, this.z)); + this.w = Math.max(min.w, Math.min(max2.w, this.w)); + return this; + } + clampScalar(minVal, maxVal) { + this.x = Math.max(minVal, Math.min(maxVal, this.x)); + this.y = Math.max(minVal, Math.min(maxVal, this.y)); + this.z = Math.max(minVal, Math.min(maxVal, this.z)); + this.w = Math.max(minVal, Math.min(maxVal, this.w)); + return this; + } + clampLength(min, max2) { + const length = this.length(); + return this.divideScalar(length || 1).multiplyScalar(Math.max(min, Math.min(max2, length))); + } + floor() { + this.x = Math.floor(this.x); + this.y = Math.floor(this.y); + this.z = Math.floor(this.z); + this.w = Math.floor(this.w); + return this; + } + ceil() { + this.x = Math.ceil(this.x); + this.y = Math.ceil(this.y); + this.z = Math.ceil(this.z); + this.w = Math.ceil(this.w); + return this; + } + round() { + this.x = Math.round(this.x); + this.y = Math.round(this.y); + this.z = Math.round(this.z); + this.w = Math.round(this.w); + return this; + } + roundToZero() { + this.x = Math.trunc(this.x); + this.y = Math.trunc(this.y); + this.z = Math.trunc(this.z); + this.w = Math.trunc(this.w); + return this; + } + negate() { + this.x = -this.x; + this.y = -this.y; + this.z = -this.z; + this.w = -this.w; + return this; + } + dot(v) { + return this.x * v.x + this.y * v.y + this.z * v.z + this.w * v.w; + } + lengthSq() { + return this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w; + } + length() { + return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w); + } + manhattanLength() { + return Math.abs(this.x) + Math.abs(this.y) + Math.abs(this.z) + Math.abs(this.w); + } + normalize() { + return this.divideScalar(this.length() || 1); + } + setLength(length) { + return this.normalize().multiplyScalar(length); + } + lerp(v, alpha) { + this.x += (v.x - this.x) * alpha; + this.y += (v.y - this.y) * alpha; + this.z += (v.z - this.z) * alpha; + this.w += (v.w - this.w) * alpha; + return this; + } + lerpVectors(v1, v2, alpha) { + this.x = v1.x + (v2.x - v1.x) * alpha; + this.y = v1.y + (v2.y - v1.y) * alpha; + this.z = v1.z + (v2.z - v1.z) * alpha; + this.w = v1.w + (v2.w - v1.w) * alpha; + return this; + } + equals(v) { + return v.x === this.x && v.y === this.y && v.z === this.z && v.w === this.w; + } + fromArray(array, offset = 0) { + this.x = array[offset]; + this.y = array[offset + 1]; + this.z = array[offset + 2]; + this.w = array[offset + 3]; + return this; + } + toArray(array = [], offset = 0) { + array[offset] = this.x; + array[offset + 1] = this.y; + array[offset + 2] = this.z; + array[offset + 3] = this.w; + return array; + } + fromBufferAttribute(attribute, index) { + this.x = attribute.getX(index); + this.y = attribute.getY(index); + this.z = attribute.getZ(index); + this.w = attribute.getW(index); + return this; + } + random() { + this.x = Math.random(); + this.y = Math.random(); + this.z = Math.random(); + this.w = Math.random(); + return this; + } + *[Symbol.iterator]() { + yield this.x; + yield this.y; + yield this.z; + yield this.w; + } +}; +var RenderTarget = class extends EventDispatcher { + constructor(width = 1, height = 1, options = {}) { + super(); + this.isRenderTarget = true; + this.width = width; + this.height = height; + this.depth = 1; + this.scissor = new Vector4(0, 0, width, height); + this.scissorTest = false; + this.viewport = new Vector4(0, 0, width, height); + const image = { width, height, depth: 1 }; + options = Object.assign({ + generateMipmaps: false, + internalFormat: null, + minFilter: LinearFilter, + depthBuffer: true, + stencilBuffer: false, + depthTexture: null, + samples: 0, + count: 1 + }, options); + const texture = new Texture(image, options.mapping, options.wrapS, options.wrapT, options.magFilter, options.minFilter, options.format, options.type, options.anisotropy, options.colorSpace); + texture.flipY = false; + texture.generateMipmaps = options.generateMipmaps; + texture.internalFormat = options.internalFormat; + this.textures = []; + const count = options.count; + for (let i = 0; i < count; i++) { + this.textures[i] = texture.clone(); + this.textures[i].isRenderTargetTexture = true; + } + this.depthBuffer = options.depthBuffer; + this.stencilBuffer = options.stencilBuffer; + this.depthTexture = options.depthTexture; + this.samples = options.samples; + } + get texture() { + return this.textures[0]; + } + set texture(value) { + this.textures[0] = value; + } + setSize(width, height, depth = 1) { + if (this.width !== width || this.height !== height || this.depth !== depth) { + this.width = width; + this.height = height; + this.depth = depth; + for (let i = 0, il = this.textures.length; i < il; i++) { + this.textures[i].image.width = width; + this.textures[i].image.height = height; + this.textures[i].image.depth = depth; + } + this.dispose(); + } + this.viewport.set(0, 0, width, height); + this.scissor.set(0, 0, width, height); + } + clone() { + return new this.constructor().copy(this); + } + copy(source) { + this.width = source.width; + this.height = source.height; + this.depth = source.depth; + this.scissor.copy(source.scissor); + this.scissorTest = source.scissorTest; + this.viewport.copy(source.viewport); + this.textures.length = 0; + for (let i = 0, il = source.textures.length; i < il; i++) { + this.textures[i] = source.textures[i].clone(); + this.textures[i].isRenderTargetTexture = true; + } + const image = Object.assign({}, source.texture.image); + this.texture.source = new Source(image); + this.depthBuffer = source.depthBuffer; + this.stencilBuffer = source.stencilBuffer; + if (source.depthTexture !== null) this.depthTexture = source.depthTexture.clone(); + this.samples = source.samples; + return this; + } + dispose() { + this.dispatchEvent({ type: "dispose" }); + } +}; +var WebGLRenderTarget = class extends RenderTarget { + constructor(width = 1, height = 1, options = {}) { + super(width, height, options); + this.isWebGLRenderTarget = true; + } +}; +var DataArrayTexture = class extends Texture { + constructor(data = null, width = 1, height = 1, depth = 1) { + super(null); + this.isDataArrayTexture = true; + this.image = { data, width, height, depth }; + this.magFilter = NearestFilter; + this.minFilter = NearestFilter; + this.wrapR = ClampToEdgeWrapping; + this.generateMipmaps = false; + this.flipY = false; + this.unpackAlignment = 1; + } +}; +var Data3DTexture = class extends Texture { + constructor(data = null, width = 1, height = 1, depth = 1) { + super(null); + this.isData3DTexture = true; + this.image = { data, width, height, depth }; + this.magFilter = NearestFilter; + this.minFilter = NearestFilter; + this.wrapR = ClampToEdgeWrapping; + this.generateMipmaps = false; + this.flipY = false; + this.unpackAlignment = 1; + } +}; +var Quaternion = class { + constructor(x = 0, y = 0, z = 0, w = 1) { + this.isQuaternion = true; + this._x = x; + this._y = y; + this._z = z; + this._w = w; + } + static slerpFlat(dst, dstOffset, src0, srcOffset0, src1, srcOffset1, t) { + let x0 = src0[srcOffset0 + 0], y0 = src0[srcOffset0 + 1], z0 = src0[srcOffset0 + 2], w0 = src0[srcOffset0 + 3]; + const x1 = src1[srcOffset1 + 0], y1 = src1[srcOffset1 + 1], z1 = src1[srcOffset1 + 2], w1 = src1[srcOffset1 + 3]; + if (t === 0) { + dst[dstOffset + 0] = x0; + dst[dstOffset + 1] = y0; + dst[dstOffset + 2] = z0; + dst[dstOffset + 3] = w0; + return; + } + if (t === 1) { + dst[dstOffset + 0] = x1; + dst[dstOffset + 1] = y1; + dst[dstOffset + 2] = z1; + dst[dstOffset + 3] = w1; + return; + } + if (w0 !== w1 || x0 !== x1 || y0 !== y1 || z0 !== z1) { + let s = 1 - t; + const cos = x0 * x1 + y0 * y1 + z0 * z1 + w0 * w1, dir = cos >= 0 ? 1 : -1, sqrSin = 1 - cos * cos; + if (sqrSin > Number.EPSILON) { + const sin = Math.sqrt(sqrSin), len = Math.atan2(sin, cos * dir); + s = Math.sin(s * len) / sin; + t = Math.sin(t * len) / sin; + } + const tDir = t * dir; + x0 = x0 * s + x1 * tDir; + y0 = y0 * s + y1 * tDir; + z0 = z0 * s + z1 * tDir; + w0 = w0 * s + w1 * tDir; + if (s === 1 - t) { + const f = 1 / Math.sqrt(x0 * x0 + y0 * y0 + z0 * z0 + w0 * w0); + x0 *= f; + y0 *= f; + z0 *= f; + w0 *= f; + } + } + dst[dstOffset] = x0; + dst[dstOffset + 1] = y0; + dst[dstOffset + 2] = z0; + dst[dstOffset + 3] = w0; + } + static multiplyQuaternionsFlat(dst, dstOffset, src0, srcOffset0, src1, srcOffset1) { + const x0 = src0[srcOffset0]; + const y0 = src0[srcOffset0 + 1]; + const z0 = src0[srcOffset0 + 2]; + const w0 = src0[srcOffset0 + 3]; + const x1 = src1[srcOffset1]; + const y1 = src1[srcOffset1 + 1]; + const z1 = src1[srcOffset1 + 2]; + const w1 = src1[srcOffset1 + 3]; + dst[dstOffset] = x0 * w1 + w0 * x1 + y0 * z1 - z0 * y1; + dst[dstOffset + 1] = y0 * w1 + w0 * y1 + z0 * x1 - x0 * z1; + dst[dstOffset + 2] = z0 * w1 + w0 * z1 + x0 * y1 - y0 * x1; + dst[dstOffset + 3] = w0 * w1 - x0 * x1 - y0 * y1 - z0 * z1; + return dst; + } + get x() { + return this._x; + } + set x(value) { + this._x = value; + this._onChangeCallback(); + } + get y() { + return this._y; + } + set y(value) { + this._y = value; + this._onChangeCallback(); + } + get z() { + return this._z; + } + set z(value) { + this._z = value; + this._onChangeCallback(); + } + get w() { + return this._w; + } + set w(value) { + this._w = value; + this._onChangeCallback(); + } + set(x, y, z, w) { + this._x = x; + this._y = y; + this._z = z; + this._w = w; + this._onChangeCallback(); + return this; + } + clone() { + return new this.constructor(this._x, this._y, this._z, this._w); + } + copy(quaternion2) { + this._x = quaternion2.x; + this._y = quaternion2.y; + this._z = quaternion2.z; + this._w = quaternion2.w; + this._onChangeCallback(); + return this; + } + setFromEuler(euler, update = true) { + const x = euler._x, y = euler._y, z = euler._z, order = euler._order; + const cos = Math.cos; + const sin = Math.sin; + const c1 = cos(x / 2); + const c2 = cos(y / 2); + const c3 = cos(z / 2); + const s1 = sin(x / 2); + const s2 = sin(y / 2); + const s3 = sin(z / 2); + switch (order) { + case "XYZ": + this._x = s1 * c2 * c3 + c1 * s2 * s3; + this._y = c1 * s2 * c3 - s1 * c2 * s3; + this._z = c1 * c2 * s3 + s1 * s2 * c3; + this._w = c1 * c2 * c3 - s1 * s2 * s3; + break; + case "YXZ": + this._x = s1 * c2 * c3 + c1 * s2 * s3; + this._y = c1 * s2 * c3 - s1 * c2 * s3; + this._z = c1 * c2 * s3 - s1 * s2 * c3; + this._w = c1 * c2 * c3 + s1 * s2 * s3; + break; + case "ZXY": + this._x = s1 * c2 * c3 - c1 * s2 * s3; + this._y = c1 * s2 * c3 + s1 * c2 * s3; + this._z = c1 * c2 * s3 + s1 * s2 * c3; + this._w = c1 * c2 * c3 - s1 * s2 * s3; + break; + case "ZYX": + this._x = s1 * c2 * c3 - c1 * s2 * s3; + this._y = c1 * s2 * c3 + s1 * c2 * s3; + this._z = c1 * c2 * s3 - s1 * s2 * c3; + this._w = c1 * c2 * c3 + s1 * s2 * s3; + break; + case "YZX": + this._x = s1 * c2 * c3 + c1 * s2 * s3; + this._y = c1 * s2 * c3 + s1 * c2 * s3; + this._z = c1 * c2 * s3 - s1 * s2 * c3; + this._w = c1 * c2 * c3 - s1 * s2 * s3; + break; + case "XZY": + this._x = s1 * c2 * c3 - c1 * s2 * s3; + this._y = c1 * s2 * c3 - s1 * c2 * s3; + this._z = c1 * c2 * s3 + s1 * s2 * c3; + this._w = c1 * c2 * c3 + s1 * s2 * s3; + break; + default: + console.warn("THREE.Quaternion: .setFromEuler() encountered an unknown order: " + order); + } + if (update === true) this._onChangeCallback(); + return this; + } + setFromAxisAngle(axis, angle) { + const halfAngle = angle / 2, s = Math.sin(halfAngle); + this._x = axis.x * s; + this._y = axis.y * s; + this._z = axis.z * s; + this._w = Math.cos(halfAngle); + this._onChangeCallback(); + return this; + } + setFromRotationMatrix(m) { + const te = m.elements, m11 = te[0], m12 = te[4], m13 = te[8], m21 = te[1], m22 = te[5], m23 = te[9], m31 = te[2], m32 = te[6], m33 = te[10], trace = m11 + m22 + m33; + if (trace > 0) { + const s = 0.5 / Math.sqrt(trace + 1); + this._w = 0.25 / s; + this._x = (m32 - m23) * s; + this._y = (m13 - m31) * s; + this._z = (m21 - m12) * s; + } else if (m11 > m22 && m11 > m33) { + const s = 2 * Math.sqrt(1 + m11 - m22 - m33); + this._w = (m32 - m23) / s; + this._x = 0.25 * s; + this._y = (m12 + m21) / s; + this._z = (m13 + m31) / s; + } else if (m22 > m33) { + const s = 2 * Math.sqrt(1 + m22 - m11 - m33); + this._w = (m13 - m31) / s; + this._x = (m12 + m21) / s; + this._y = 0.25 * s; + this._z = (m23 + m32) / s; + } else { + const s = 2 * Math.sqrt(1 + m33 - m11 - m22); + this._w = (m21 - m12) / s; + this._x = (m13 + m31) / s; + this._y = (m23 + m32) / s; + this._z = 0.25 * s; + } + this._onChangeCallback(); + return this; + } + setFromUnitVectors(vFrom, vTo) { + let r = vFrom.dot(vTo) + 1; + if (r < Number.EPSILON) { + r = 0; + if (Math.abs(vFrom.x) > Math.abs(vFrom.z)) { + this._x = -vFrom.y; + this._y = vFrom.x; + this._z = 0; + this._w = r; + } else { + this._x = 0; + this._y = -vFrom.z; + this._z = vFrom.y; + this._w = r; + } + } else { + this._x = vFrom.y * vTo.z - vFrom.z * vTo.y; + this._y = vFrom.z * vTo.x - vFrom.x * vTo.z; + this._z = vFrom.x * vTo.y - vFrom.y * vTo.x; + this._w = r; + } + return this.normalize(); + } + angleTo(q) { + return 2 * Math.acos(Math.abs(clamp(this.dot(q), -1, 1))); + } + rotateTowards(q, step) { + const angle = this.angleTo(q); + if (angle === 0) return this; + const t = Math.min(1, step / angle); + this.slerp(q, t); + return this; + } + identity() { + return this.set(0, 0, 0, 1); + } + invert() { + return this.conjugate(); + } + conjugate() { + this._x *= -1; + this._y *= -1; + this._z *= -1; + this._onChangeCallback(); + return this; + } + dot(v) { + return this._x * v._x + this._y * v._y + this._z * v._z + this._w * v._w; + } + lengthSq() { + return this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w; + } + length() { + return Math.sqrt(this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w); + } + normalize() { + let l = this.length(); + if (l === 0) { + this._x = 0; + this._y = 0; + this._z = 0; + this._w = 1; + } else { + l = 1 / l; + this._x = this._x * l; + this._y = this._y * l; + this._z = this._z * l; + this._w = this._w * l; + } + this._onChangeCallback(); + return this; + } + multiply(q) { + return this.multiplyQuaternions(this, q); + } + premultiply(q) { + return this.multiplyQuaternions(q, this); + } + multiplyQuaternions(a, b) { + const qax = a._x, qay = a._y, qaz = a._z, qaw = a._w; + const qbx = b._x, qby = b._y, qbz = b._z, qbw = b._w; + this._x = qax * qbw + qaw * qbx + qay * qbz - qaz * qby; + this._y = qay * qbw + qaw * qby + qaz * qbx - qax * qbz; + this._z = qaz * qbw + qaw * qbz + qax * qby - qay * qbx; + this._w = qaw * qbw - qax * qbx - qay * qby - qaz * qbz; + this._onChangeCallback(); + return this; + } + slerp(qb, t) { + if (t === 0) return this; + if (t === 1) return this.copy(qb); + const x = this._x, y = this._y, z = this._z, w = this._w; + let cosHalfTheta = w * qb._w + x * qb._x + y * qb._y + z * qb._z; + if (cosHalfTheta < 0) { + this._w = -qb._w; + this._x = -qb._x; + this._y = -qb._y; + this._z = -qb._z; + cosHalfTheta = -cosHalfTheta; + } else { + this.copy(qb); + } + if (cosHalfTheta >= 1) { + this._w = w; + this._x = x; + this._y = y; + this._z = z; + return this; + } + const sqrSinHalfTheta = 1 - cosHalfTheta * cosHalfTheta; + if (sqrSinHalfTheta <= Number.EPSILON) { + const s = 1 - t; + this._w = s * w + t * this._w; + this._x = s * x + t * this._x; + this._y = s * y + t * this._y; + this._z = s * z + t * this._z; + this.normalize(); + return this; + } + const sinHalfTheta = Math.sqrt(sqrSinHalfTheta); + const halfTheta = Math.atan2(sinHalfTheta, cosHalfTheta); + const ratioA = Math.sin((1 - t) * halfTheta) / sinHalfTheta, ratioB = Math.sin(t * halfTheta) / sinHalfTheta; + this._w = w * ratioA + this._w * ratioB; + this._x = x * ratioA + this._x * ratioB; + this._y = y * ratioA + this._y * ratioB; + this._z = z * ratioA + this._z * ratioB; + this._onChangeCallback(); + return this; + } + slerpQuaternions(qa, qb, t) { + return this.copy(qa).slerp(qb, t); + } + random() { + const theta1 = 2 * Math.PI * Math.random(); + const theta2 = 2 * Math.PI * Math.random(); + const x0 = Math.random(); + const r1 = Math.sqrt(1 - x0); + const r2 = Math.sqrt(x0); + return this.set( + r1 * Math.sin(theta1), + r1 * Math.cos(theta1), + r2 * Math.sin(theta2), + r2 * Math.cos(theta2) + ); + } + equals(quaternion2) { + return quaternion2._x === this._x && quaternion2._y === this._y && quaternion2._z === this._z && quaternion2._w === this._w; + } + fromArray(array, offset = 0) { + this._x = array[offset]; + this._y = array[offset + 1]; + this._z = array[offset + 2]; + this._w = array[offset + 3]; + this._onChangeCallback(); + return this; + } + toArray(array = [], offset = 0) { + array[offset] = this._x; + array[offset + 1] = this._y; + array[offset + 2] = this._z; + array[offset + 3] = this._w; + return array; + } + fromBufferAttribute(attribute, index) { + this._x = attribute.getX(index); + this._y = attribute.getY(index); + this._z = attribute.getZ(index); + this._w = attribute.getW(index); + this._onChangeCallback(); + return this; + } + toJSON() { + return this.toArray(); + } + _onChange(callback) { + this._onChangeCallback = callback; + return this; + } + _onChangeCallback() { + } + *[Symbol.iterator]() { + yield this._x; + yield this._y; + yield this._z; + yield this._w; + } +}; +var Vector3 = class _Vector3 { + constructor(x = 0, y = 0, z = 0) { + _Vector3.prototype.isVector3 = true; + this.x = x; + this.y = y; + this.z = z; + } + set(x, y, z) { + if (z === void 0) z = this.z; + this.x = x; + this.y = y; + this.z = z; + return this; + } + setScalar(scalar) { + this.x = scalar; + this.y = scalar; + this.z = scalar; + return this; + } + setX(x) { + this.x = x; + return this; + } + setY(y) { + this.y = y; + return this; + } + setZ(z) { + this.z = z; + return this; + } + setComponent(index, value) { + switch (index) { + case 0: + this.x = value; + break; + case 1: + this.y = value; + break; + case 2: + this.z = value; + break; + default: + throw new Error("index is out of range: " + index); + } + return this; + } + getComponent(index) { + switch (index) { + case 0: + return this.x; + case 1: + return this.y; + case 2: + return this.z; + default: + throw new Error("index is out of range: " + index); + } + } + clone() { + return new this.constructor(this.x, this.y, this.z); + } + copy(v) { + this.x = v.x; + this.y = v.y; + this.z = v.z; + return this; + } + add(v) { + this.x += v.x; + this.y += v.y; + this.z += v.z; + return this; + } + addScalar(s) { + this.x += s; + this.y += s; + this.z += s; + return this; + } + addVectors(a, b) { + this.x = a.x + b.x; + this.y = a.y + b.y; + this.z = a.z + b.z; + return this; + } + addScaledVector(v, s) { + this.x += v.x * s; + this.y += v.y * s; + this.z += v.z * s; + return this; + } + sub(v) { + this.x -= v.x; + this.y -= v.y; + this.z -= v.z; + return this; + } + subScalar(s) { + this.x -= s; + this.y -= s; + this.z -= s; + return this; + } + subVectors(a, b) { + this.x = a.x - b.x; + this.y = a.y - b.y; + this.z = a.z - b.z; + return this; + } + multiply(v) { + this.x *= v.x; + this.y *= v.y; + this.z *= v.z; + return this; + } + multiplyScalar(scalar) { + this.x *= scalar; + this.y *= scalar; + this.z *= scalar; + return this; + } + multiplyVectors(a, b) { + this.x = a.x * b.x; + this.y = a.y * b.y; + this.z = a.z * b.z; + return this; + } + applyEuler(euler) { + return this.applyQuaternion(_quaternion$4.setFromEuler(euler)); + } + applyAxisAngle(axis, angle) { + return this.applyQuaternion(_quaternion$4.setFromAxisAngle(axis, angle)); + } + applyMatrix3(m) { + const x = this.x, y = this.y, z = this.z; + const e = m.elements; + this.x = e[0] * x + e[3] * y + e[6] * z; + this.y = e[1] * x + e[4] * y + e[7] * z; + this.z = e[2] * x + e[5] * y + e[8] * z; + return this; + } + applyNormalMatrix(m) { + return this.applyMatrix3(m).normalize(); + } + applyMatrix4(m) { + const x = this.x, y = this.y, z = this.z; + const e = m.elements; + const w = 1 / (e[3] * x + e[7] * y + e[11] * z + e[15]); + this.x = (e[0] * x + e[4] * y + e[8] * z + e[12]) * w; + this.y = (e[1] * x + e[5] * y + e[9] * z + e[13]) * w; + this.z = (e[2] * x + e[6] * y + e[10] * z + e[14]) * w; + return this; + } + applyQuaternion(q) { + const vx = this.x, vy = this.y, vz = this.z; + const qx = q.x, qy = q.y, qz = q.z, qw = q.w; + const tx = 2 * (qy * vz - qz * vy); + const ty = 2 * (qz * vx - qx * vz); + const tz = 2 * (qx * vy - qy * vx); + this.x = vx + qw * tx + qy * tz - qz * ty; + this.y = vy + qw * ty + qz * tx - qx * tz; + this.z = vz + qw * tz + qx * ty - qy * tx; + return this; + } + project(camera) { + return this.applyMatrix4(camera.matrixWorldInverse).applyMatrix4(camera.projectionMatrix); + } + unproject(camera) { + return this.applyMatrix4(camera.projectionMatrixInverse).applyMatrix4(camera.matrixWorld); + } + transformDirection(m) { + const x = this.x, y = this.y, z = this.z; + const e = m.elements; + this.x = e[0] * x + e[4] * y + e[8] * z; + this.y = e[1] * x + e[5] * y + e[9] * z; + this.z = e[2] * x + e[6] * y + e[10] * z; + return this.normalize(); + } + divide(v) { + this.x /= v.x; + this.y /= v.y; + this.z /= v.z; + return this; + } + divideScalar(scalar) { + return this.multiplyScalar(1 / scalar); + } + min(v) { + this.x = Math.min(this.x, v.x); + this.y = Math.min(this.y, v.y); + this.z = Math.min(this.z, v.z); + return this; + } + max(v) { + this.x = Math.max(this.x, v.x); + this.y = Math.max(this.y, v.y); + this.z = Math.max(this.z, v.z); + return this; + } + clamp(min, max2) { + this.x = Math.max(min.x, Math.min(max2.x, this.x)); + this.y = Math.max(min.y, Math.min(max2.y, this.y)); + this.z = Math.max(min.z, Math.min(max2.z, this.z)); + return this; + } + clampScalar(minVal, maxVal) { + this.x = Math.max(minVal, Math.min(maxVal, this.x)); + this.y = Math.max(minVal, Math.min(maxVal, this.y)); + this.z = Math.max(minVal, Math.min(maxVal, this.z)); + return this; + } + clampLength(min, max2) { + const length = this.length(); + return this.divideScalar(length || 1).multiplyScalar(Math.max(min, Math.min(max2, length))); + } + floor() { + this.x = Math.floor(this.x); + this.y = Math.floor(this.y); + this.z = Math.floor(this.z); + return this; + } + ceil() { + this.x = Math.ceil(this.x); + this.y = Math.ceil(this.y); + this.z = Math.ceil(this.z); + return this; + } + round() { + this.x = Math.round(this.x); + this.y = Math.round(this.y); + this.z = Math.round(this.z); + return this; + } + roundToZero() { + this.x = Math.trunc(this.x); + this.y = Math.trunc(this.y); + this.z = Math.trunc(this.z); + return this; + } + negate() { + this.x = -this.x; + this.y = -this.y; + this.z = -this.z; + return this; + } + dot(v) { + return this.x * v.x + this.y * v.y + this.z * v.z; + } + // TODO lengthSquared? + lengthSq() { + return this.x * this.x + this.y * this.y + this.z * this.z; + } + length() { + return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z); + } + manhattanLength() { + return Math.abs(this.x) + Math.abs(this.y) + Math.abs(this.z); + } + normalize() { + return this.divideScalar(this.length() || 1); + } + setLength(length) { + return this.normalize().multiplyScalar(length); + } + lerp(v, alpha) { + this.x += (v.x - this.x) * alpha; + this.y += (v.y - this.y) * alpha; + this.z += (v.z - this.z) * alpha; + return this; + } + lerpVectors(v1, v2, alpha) { + this.x = v1.x + (v2.x - v1.x) * alpha; + this.y = v1.y + (v2.y - v1.y) * alpha; + this.z = v1.z + (v2.z - v1.z) * alpha; + return this; + } + cross(v) { + return this.crossVectors(this, v); + } + crossVectors(a, b) { + const ax = a.x, ay = a.y, az = a.z; + const bx = b.x, by = b.y, bz = b.z; + this.x = ay * bz - az * by; + this.y = az * bx - ax * bz; + this.z = ax * by - ay * bx; + return this; + } + projectOnVector(v) { + const denominator = v.lengthSq(); + if (denominator === 0) return this.set(0, 0, 0); + const scalar = v.dot(this) / denominator; + return this.copy(v).multiplyScalar(scalar); + } + projectOnPlane(planeNormal) { + _vector$c.copy(this).projectOnVector(planeNormal); + return this.sub(_vector$c); + } + reflect(normal) { + return this.sub(_vector$c.copy(normal).multiplyScalar(2 * this.dot(normal))); + } + angleTo(v) { + const denominator = Math.sqrt(this.lengthSq() * v.lengthSq()); + if (denominator === 0) return Math.PI / 2; + const theta = this.dot(v) / denominator; + return Math.acos(clamp(theta, -1, 1)); + } + distanceTo(v) { + return Math.sqrt(this.distanceToSquared(v)); + } + distanceToSquared(v) { + const dx = this.x - v.x, dy = this.y - v.y, dz = this.z - v.z; + return dx * dx + dy * dy + dz * dz; + } + manhattanDistanceTo(v) { + return Math.abs(this.x - v.x) + Math.abs(this.y - v.y) + Math.abs(this.z - v.z); + } + setFromSpherical(s) { + return this.setFromSphericalCoords(s.radius, s.phi, s.theta); + } + setFromSphericalCoords(radius, phi, theta) { + const sinPhiRadius = Math.sin(phi) * radius; + this.x = sinPhiRadius * Math.sin(theta); + this.y = Math.cos(phi) * radius; + this.z = sinPhiRadius * Math.cos(theta); + return this; + } + setFromCylindrical(c) { + return this.setFromCylindricalCoords(c.radius, c.theta, c.y); + } + setFromCylindricalCoords(radius, theta, y) { + this.x = radius * Math.sin(theta); + this.y = y; + this.z = radius * Math.cos(theta); + return this; + } + setFromMatrixPosition(m) { + const e = m.elements; + this.x = e[12]; + this.y = e[13]; + this.z = e[14]; + return this; + } + setFromMatrixScale(m) { + const sx = this.setFromMatrixColumn(m, 0).length(); + const sy = this.setFromMatrixColumn(m, 1).length(); + const sz = this.setFromMatrixColumn(m, 2).length(); + this.x = sx; + this.y = sy; + this.z = sz; + return this; + } + setFromMatrixColumn(m, index) { + return this.fromArray(m.elements, index * 4); + } + setFromMatrix3Column(m, index) { + return this.fromArray(m.elements, index * 3); + } + setFromEuler(e) { + this.x = e._x; + this.y = e._y; + this.z = e._z; + return this; + } + setFromColor(c) { + this.x = c.r; + this.y = c.g; + this.z = c.b; + return this; + } + equals(v) { + return v.x === this.x && v.y === this.y && v.z === this.z; + } + fromArray(array, offset = 0) { + this.x = array[offset]; + this.y = array[offset + 1]; + this.z = array[offset + 2]; + return this; + } + toArray(array = [], offset = 0) { + array[offset] = this.x; + array[offset + 1] = this.y; + array[offset + 2] = this.z; + return array; + } + fromBufferAttribute(attribute, index) { + this.x = attribute.getX(index); + this.y = attribute.getY(index); + this.z = attribute.getZ(index); + return this; + } + random() { + this.x = Math.random(); + this.y = Math.random(); + this.z = Math.random(); + return this; + } + randomDirection() { + const theta = Math.random() * Math.PI * 2; + const u = Math.random() * 2 - 1; + const c = Math.sqrt(1 - u * u); + this.x = c * Math.cos(theta); + this.y = u; + this.z = c * Math.sin(theta); + return this; + } + *[Symbol.iterator]() { + yield this.x; + yield this.y; + yield this.z; + } +}; +var _vector$c = /* @__PURE__ */ new Vector3(); +var _quaternion$4 = /* @__PURE__ */ new Quaternion(); +var Box3 = class { + constructor(min = new Vector3(Infinity, Infinity, Infinity), max2 = new Vector3(-Infinity, -Infinity, -Infinity)) { + this.isBox3 = true; + this.min = min; + this.max = max2; + } + set(min, max2) { + this.min.copy(min); + this.max.copy(max2); + return this; + } + setFromArray(array) { + this.makeEmpty(); + for (let i = 0, il = array.length; i < il; i += 3) { + this.expandByPoint(_vector$b.fromArray(array, i)); + } + return this; + } + setFromBufferAttribute(attribute) { + this.makeEmpty(); + for (let i = 0, il = attribute.count; i < il; i++) { + this.expandByPoint(_vector$b.fromBufferAttribute(attribute, i)); + } + return this; + } + setFromPoints(points) { + this.makeEmpty(); + for (let i = 0, il = points.length; i < il; i++) { + this.expandByPoint(points[i]); + } + return this; + } + setFromCenterAndSize(center, size) { + const halfSize = _vector$b.copy(size).multiplyScalar(0.5); + this.min.copy(center).sub(halfSize); + this.max.copy(center).add(halfSize); + return this; + } + setFromObject(object, precise = false) { + this.makeEmpty(); + return this.expandByObject(object, precise); + } + clone() { + return new this.constructor().copy(this); + } + copy(box) { + this.min.copy(box.min); + this.max.copy(box.max); + return this; + } + makeEmpty() { + this.min.x = this.min.y = this.min.z = Infinity; + this.max.x = this.max.y = this.max.z = -Infinity; + return this; + } + isEmpty() { + return this.max.x < this.min.x || this.max.y < this.min.y || this.max.z < this.min.z; + } + getCenter(target) { + return this.isEmpty() ? target.set(0, 0, 0) : target.addVectors(this.min, this.max).multiplyScalar(0.5); + } + getSize(target) { + return this.isEmpty() ? target.set(0, 0, 0) : target.subVectors(this.max, this.min); + } + expandByPoint(point) { + this.min.min(point); + this.max.max(point); + return this; + } + expandByVector(vector) { + this.min.sub(vector); + this.max.add(vector); + return this; + } + expandByScalar(scalar) { + this.min.addScalar(-scalar); + this.max.addScalar(scalar); + return this; + } + expandByObject(object, precise = false) { + object.updateWorldMatrix(false, false); + const geometry = object.geometry; + if (geometry !== void 0) { + const positionAttribute = geometry.getAttribute("position"); + if (precise === true && positionAttribute !== void 0 && object.isInstancedMesh !== true) { + for (let i = 0, l = positionAttribute.count; i < l; i++) { + if (object.isMesh === true) { + object.getVertexPosition(i, _vector$b); + } else { + _vector$b.fromBufferAttribute(positionAttribute, i); + } + _vector$b.applyMatrix4(object.matrixWorld); + this.expandByPoint(_vector$b); + } + } else { + if (object.boundingBox !== void 0) { + if (object.boundingBox === null) { + object.computeBoundingBox(); + } + _box$4.copy(object.boundingBox); + } else { + if (geometry.boundingBox === null) { + geometry.computeBoundingBox(); + } + _box$4.copy(geometry.boundingBox); + } + _box$4.applyMatrix4(object.matrixWorld); + this.union(_box$4); + } + } + const children = object.children; + for (let i = 0, l = children.length; i < l; i++) { + this.expandByObject(children[i], precise); + } + return this; + } + containsPoint(point) { + return point.x < this.min.x || point.x > this.max.x || point.y < this.min.y || point.y > this.max.y || point.z < this.min.z || point.z > this.max.z ? false : true; + } + containsBox(box) { + return this.min.x <= box.min.x && box.max.x <= this.max.x && this.min.y <= box.min.y && box.max.y <= this.max.y && this.min.z <= box.min.z && box.max.z <= this.max.z; + } + getParameter(point, target) { + return target.set( + (point.x - this.min.x) / (this.max.x - this.min.x), + (point.y - this.min.y) / (this.max.y - this.min.y), + (point.z - this.min.z) / (this.max.z - this.min.z) + ); + } + intersectsBox(box) { + return box.max.x < this.min.x || box.min.x > this.max.x || box.max.y < this.min.y || box.min.y > this.max.y || box.max.z < this.min.z || box.min.z > this.max.z ? false : true; + } + intersectsSphere(sphere) { + this.clampPoint(sphere.center, _vector$b); + return _vector$b.distanceToSquared(sphere.center) <= sphere.radius * sphere.radius; + } + intersectsPlane(plane) { + let min, max2; + if (plane.normal.x > 0) { + min = plane.normal.x * this.min.x; + max2 = plane.normal.x * this.max.x; + } else { + min = plane.normal.x * this.max.x; + max2 = plane.normal.x * this.min.x; + } + if (plane.normal.y > 0) { + min += plane.normal.y * this.min.y; + max2 += plane.normal.y * this.max.y; + } else { + min += plane.normal.y * this.max.y; + max2 += plane.normal.y * this.min.y; + } + if (plane.normal.z > 0) { + min += plane.normal.z * this.min.z; + max2 += plane.normal.z * this.max.z; + } else { + min += plane.normal.z * this.max.z; + max2 += plane.normal.z * this.min.z; + } + return min <= -plane.constant && max2 >= -plane.constant; + } + intersectsTriangle(triangle) { + if (this.isEmpty()) { + return false; + } + this.getCenter(_center); + _extents.subVectors(this.max, _center); + _v0$2.subVectors(triangle.a, _center); + _v1$7.subVectors(triangle.b, _center); + _v2$4.subVectors(triangle.c, _center); + _f0.subVectors(_v1$7, _v0$2); + _f1.subVectors(_v2$4, _v1$7); + _f2.subVectors(_v0$2, _v2$4); + let axes = [ + 0, + -_f0.z, + _f0.y, + 0, + -_f1.z, + _f1.y, + 0, + -_f2.z, + _f2.y, + _f0.z, + 0, + -_f0.x, + _f1.z, + 0, + -_f1.x, + _f2.z, + 0, + -_f2.x, + -_f0.y, + _f0.x, + 0, + -_f1.y, + _f1.x, + 0, + -_f2.y, + _f2.x, + 0 + ]; + if (!satForAxes(axes, _v0$2, _v1$7, _v2$4, _extents)) { + return false; + } + axes = [1, 0, 0, 0, 1, 0, 0, 0, 1]; + if (!satForAxes(axes, _v0$2, _v1$7, _v2$4, _extents)) { + return false; + } + _triangleNormal.crossVectors(_f0, _f1); + axes = [_triangleNormal.x, _triangleNormal.y, _triangleNormal.z]; + return satForAxes(axes, _v0$2, _v1$7, _v2$4, _extents); + } + clampPoint(point, target) { + return target.copy(point).clamp(this.min, this.max); + } + distanceToPoint(point) { + return this.clampPoint(point, _vector$b).distanceTo(point); + } + getBoundingSphere(target) { + if (this.isEmpty()) { + target.makeEmpty(); + } else { + this.getCenter(target.center); + target.radius = this.getSize(_vector$b).length() * 0.5; + } + return target; + } + intersect(box) { + this.min.max(box.min); + this.max.min(box.max); + if (this.isEmpty()) this.makeEmpty(); + return this; + } + union(box) { + this.min.min(box.min); + this.max.max(box.max); + return this; + } + applyMatrix4(matrix) { + if (this.isEmpty()) return this; + _points[0].set(this.min.x, this.min.y, this.min.z).applyMatrix4(matrix); + _points[1].set(this.min.x, this.min.y, this.max.z).applyMatrix4(matrix); + _points[2].set(this.min.x, this.max.y, this.min.z).applyMatrix4(matrix); + _points[3].set(this.min.x, this.max.y, this.max.z).applyMatrix4(matrix); + _points[4].set(this.max.x, this.min.y, this.min.z).applyMatrix4(matrix); + _points[5].set(this.max.x, this.min.y, this.max.z).applyMatrix4(matrix); + _points[6].set(this.max.x, this.max.y, this.min.z).applyMatrix4(matrix); + _points[7].set(this.max.x, this.max.y, this.max.z).applyMatrix4(matrix); + this.setFromPoints(_points); + return this; + } + translate(offset) { + this.min.add(offset); + this.max.add(offset); + return this; + } + equals(box) { + return box.min.equals(this.min) && box.max.equals(this.max); + } +}; +var _points = [ + /* @__PURE__ */ new Vector3(), + /* @__PURE__ */ new Vector3(), + /* @__PURE__ */ new Vector3(), + /* @__PURE__ */ new Vector3(), + /* @__PURE__ */ new Vector3(), + /* @__PURE__ */ new Vector3(), + /* @__PURE__ */ new Vector3(), + /* @__PURE__ */ new Vector3() +]; +var _vector$b = /* @__PURE__ */ new Vector3(); +var _box$4 = /* @__PURE__ */ new Box3(); +var _v0$2 = /* @__PURE__ */ new Vector3(); +var _v1$7 = /* @__PURE__ */ new Vector3(); +var _v2$4 = /* @__PURE__ */ new Vector3(); +var _f0 = /* @__PURE__ */ new Vector3(); +var _f1 = /* @__PURE__ */ new Vector3(); +var _f2 = /* @__PURE__ */ new Vector3(); +var _center = /* @__PURE__ */ new Vector3(); +var _extents = /* @__PURE__ */ new Vector3(); +var _triangleNormal = /* @__PURE__ */ new Vector3(); +var _testAxis = /* @__PURE__ */ new Vector3(); +function satForAxes(axes, v0, v1, v2, extents) { + for (let i = 0, j = axes.length - 3; i <= j; i += 3) { + _testAxis.fromArray(axes, i); + const r = extents.x * Math.abs(_testAxis.x) + extents.y * Math.abs(_testAxis.y) + extents.z * Math.abs(_testAxis.z); + const p0 = v0.dot(_testAxis); + const p1 = v1.dot(_testAxis); + const p2 = v2.dot(_testAxis); + if (Math.max(-Math.max(p0, p1, p2), Math.min(p0, p1, p2)) > r) { + return false; + } + } + return true; +} +var _box$3 = /* @__PURE__ */ new Box3(); +var _v1$6 = /* @__PURE__ */ new Vector3(); +var _v2$3 = /* @__PURE__ */ new Vector3(); +var Sphere = class { + constructor(center = new Vector3(), radius = -1) { + this.isSphere = true; + this.center = center; + this.radius = radius; + } + set(center, radius) { + this.center.copy(center); + this.radius = radius; + return this; + } + setFromPoints(points, optionalCenter) { + const center = this.center; + if (optionalCenter !== void 0) { + center.copy(optionalCenter); + } else { + _box$3.setFromPoints(points).getCenter(center); + } + let maxRadiusSq = 0; + for (let i = 0, il = points.length; i < il; i++) { + maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared(points[i])); + } + this.radius = Math.sqrt(maxRadiusSq); + return this; + } + copy(sphere) { + this.center.copy(sphere.center); + this.radius = sphere.radius; + return this; + } + isEmpty() { + return this.radius < 0; + } + makeEmpty() { + this.center.set(0, 0, 0); + this.radius = -1; + return this; + } + containsPoint(point) { + return point.distanceToSquared(this.center) <= this.radius * this.radius; + } + distanceToPoint(point) { + return point.distanceTo(this.center) - this.radius; + } + intersectsSphere(sphere) { + const radiusSum = this.radius + sphere.radius; + return sphere.center.distanceToSquared(this.center) <= radiusSum * radiusSum; + } + intersectsBox(box) { + return box.intersectsSphere(this); + } + intersectsPlane(plane) { + return Math.abs(plane.distanceToPoint(this.center)) <= this.radius; + } + clampPoint(point, target) { + const deltaLengthSq = this.center.distanceToSquared(point); + target.copy(point); + if (deltaLengthSq > this.radius * this.radius) { + target.sub(this.center).normalize(); + target.multiplyScalar(this.radius).add(this.center); + } + return target; + } + getBoundingBox(target) { + if (this.isEmpty()) { + target.makeEmpty(); + return target; + } + target.set(this.center, this.center); + target.expandByScalar(this.radius); + return target; + } + applyMatrix4(matrix) { + this.center.applyMatrix4(matrix); + this.radius = this.radius * matrix.getMaxScaleOnAxis(); + return this; + } + translate(offset) { + this.center.add(offset); + return this; + } + expandByPoint(point) { + if (this.isEmpty()) { + this.center.copy(point); + this.radius = 0; + return this; + } + _v1$6.subVectors(point, this.center); + const lengthSq = _v1$6.lengthSq(); + if (lengthSq > this.radius * this.radius) { + const length = Math.sqrt(lengthSq); + const delta = (length - this.radius) * 0.5; + this.center.addScaledVector(_v1$6, delta / length); + this.radius += delta; + } + return this; + } + union(sphere) { + if (sphere.isEmpty()) { + return this; + } + if (this.isEmpty()) { + this.copy(sphere); + return this; + } + if (this.center.equals(sphere.center) === true) { + this.radius = Math.max(this.radius, sphere.radius); + } else { + _v2$3.subVectors(sphere.center, this.center).setLength(sphere.radius); + this.expandByPoint(_v1$6.copy(sphere.center).add(_v2$3)); + this.expandByPoint(_v1$6.copy(sphere.center).sub(_v2$3)); + } + return this; + } + equals(sphere) { + return sphere.center.equals(this.center) && sphere.radius === this.radius; + } + clone() { + return new this.constructor().copy(this); + } +}; +var _vector$a = /* @__PURE__ */ new Vector3(); +var _segCenter = /* @__PURE__ */ new Vector3(); +var _segDir = /* @__PURE__ */ new Vector3(); +var _diff = /* @__PURE__ */ new Vector3(); +var _edge1 = /* @__PURE__ */ new Vector3(); +var _edge2 = /* @__PURE__ */ new Vector3(); +var _normal$1 = /* @__PURE__ */ new Vector3(); +var Ray = class { + constructor(origin = new Vector3(), direction = new Vector3(0, 0, -1)) { + this.origin = origin; + this.direction = direction; + } + set(origin, direction) { + this.origin.copy(origin); + this.direction.copy(direction); + return this; + } + copy(ray) { + this.origin.copy(ray.origin); + this.direction.copy(ray.direction); + return this; + } + at(t, target) { + return target.copy(this.origin).addScaledVector(this.direction, t); + } + lookAt(v) { + this.direction.copy(v).sub(this.origin).normalize(); + return this; + } + recast(t) { + this.origin.copy(this.at(t, _vector$a)); + return this; + } + closestPointToPoint(point, target) { + target.subVectors(point, this.origin); + const directionDistance = target.dot(this.direction); + if (directionDistance < 0) { + return target.copy(this.origin); + } + return target.copy(this.origin).addScaledVector(this.direction, directionDistance); + } + distanceToPoint(point) { + return Math.sqrt(this.distanceSqToPoint(point)); + } + distanceSqToPoint(point) { + const directionDistance = _vector$a.subVectors(point, this.origin).dot(this.direction); + if (directionDistance < 0) { + return this.origin.distanceToSquared(point); + } + _vector$a.copy(this.origin).addScaledVector(this.direction, directionDistance); + return _vector$a.distanceToSquared(point); + } + distanceSqToSegment(v0, v1, optionalPointOnRay, optionalPointOnSegment) { + _segCenter.copy(v0).add(v1).multiplyScalar(0.5); + _segDir.copy(v1).sub(v0).normalize(); + _diff.copy(this.origin).sub(_segCenter); + const segExtent = v0.distanceTo(v1) * 0.5; + const a01 = -this.direction.dot(_segDir); + const b0 = _diff.dot(this.direction); + const b1 = -_diff.dot(_segDir); + const c = _diff.lengthSq(); + const det = Math.abs(1 - a01 * a01); + let s0, s1, sqrDist, extDet; + if (det > 0) { + s0 = a01 * b1 - b0; + s1 = a01 * b0 - b1; + extDet = segExtent * det; + if (s0 >= 0) { + if (s1 >= -extDet) { + if (s1 <= extDet) { + const invDet = 1 / det; + s0 *= invDet; + s1 *= invDet; + sqrDist = s0 * (s0 + a01 * s1 + 2 * b0) + s1 * (a01 * s0 + s1 + 2 * b1) + c; + } else { + s1 = segExtent; + s0 = Math.max(0, -(a01 * s1 + b0)); + sqrDist = -s0 * s0 + s1 * (s1 + 2 * b1) + c; + } + } else { + s1 = -segExtent; + s0 = Math.max(0, -(a01 * s1 + b0)); + sqrDist = -s0 * s0 + s1 * (s1 + 2 * b1) + c; + } + } else { + if (s1 <= -extDet) { + s0 = Math.max(0, -(-a01 * segExtent + b0)); + s1 = s0 > 0 ? -segExtent : Math.min(Math.max(-segExtent, -b1), segExtent); + sqrDist = -s0 * s0 + s1 * (s1 + 2 * b1) + c; + } else if (s1 <= extDet) { + s0 = 0; + s1 = Math.min(Math.max(-segExtent, -b1), segExtent); + sqrDist = s1 * (s1 + 2 * b1) + c; + } else { + s0 = Math.max(0, -(a01 * segExtent + b0)); + s1 = s0 > 0 ? segExtent : Math.min(Math.max(-segExtent, -b1), segExtent); + sqrDist = -s0 * s0 + s1 * (s1 + 2 * b1) + c; + } + } + } else { + s1 = a01 > 0 ? -segExtent : segExtent; + s0 = Math.max(0, -(a01 * s1 + b0)); + sqrDist = -s0 * s0 + s1 * (s1 + 2 * b1) + c; + } + if (optionalPointOnRay) { + optionalPointOnRay.copy(this.origin).addScaledVector(this.direction, s0); + } + if (optionalPointOnSegment) { + optionalPointOnSegment.copy(_segCenter).addScaledVector(_segDir, s1); + } + return sqrDist; + } + intersectSphere(sphere, target) { + _vector$a.subVectors(sphere.center, this.origin); + const tca = _vector$a.dot(this.direction); + const d2 = _vector$a.dot(_vector$a) - tca * tca; + const radius2 = sphere.radius * sphere.radius; + if (d2 > radius2) return null; + const thc = Math.sqrt(radius2 - d2); + const t0 = tca - thc; + const t1 = tca + thc; + if (t1 < 0) return null; + if (t0 < 0) return this.at(t1, target); + return this.at(t0, target); + } + intersectsSphere(sphere) { + return this.distanceSqToPoint(sphere.center) <= sphere.radius * sphere.radius; + } + distanceToPlane(plane) { + const denominator = plane.normal.dot(this.direction); + if (denominator === 0) { + if (plane.distanceToPoint(this.origin) === 0) { + return 0; + } + return null; + } + const t = -(this.origin.dot(plane.normal) + plane.constant) / denominator; + return t >= 0 ? t : null; + } + intersectPlane(plane, target) { + const t = this.distanceToPlane(plane); + if (t === null) { + return null; + } + return this.at(t, target); + } + intersectsPlane(plane) { + const distToPoint = plane.distanceToPoint(this.origin); + if (distToPoint === 0) { + return true; + } + const denominator = plane.normal.dot(this.direction); + if (denominator * distToPoint < 0) { + return true; + } + return false; + } + intersectBox(box, target) { + let tmin, tmax, tymin, tymax, tzmin, tzmax; + const invdirx = 1 / this.direction.x, invdiry = 1 / this.direction.y, invdirz = 1 / this.direction.z; + const origin = this.origin; + if (invdirx >= 0) { + tmin = (box.min.x - origin.x) * invdirx; + tmax = (box.max.x - origin.x) * invdirx; + } else { + tmin = (box.max.x - origin.x) * invdirx; + tmax = (box.min.x - origin.x) * invdirx; + } + if (invdiry >= 0) { + tymin = (box.min.y - origin.y) * invdiry; + tymax = (box.max.y - origin.y) * invdiry; + } else { + tymin = (box.max.y - origin.y) * invdiry; + tymax = (box.min.y - origin.y) * invdiry; + } + if (tmin > tymax || tymin > tmax) return null; + if (tymin > tmin || isNaN(tmin)) tmin = tymin; + if (tymax < tmax || isNaN(tmax)) tmax = tymax; + if (invdirz >= 0) { + tzmin = (box.min.z - origin.z) * invdirz; + tzmax = (box.max.z - origin.z) * invdirz; + } else { + tzmin = (box.max.z - origin.z) * invdirz; + tzmax = (box.min.z - origin.z) * invdirz; + } + if (tmin > tzmax || tzmin > tmax) return null; + if (tzmin > tmin || tmin !== tmin) tmin = tzmin; + if (tzmax < tmax || tmax !== tmax) tmax = tzmax; + if (tmax < 0) return null; + return this.at(tmin >= 0 ? tmin : tmax, target); + } + intersectsBox(box) { + return this.intersectBox(box, _vector$a) !== null; + } + intersectTriangle(a, b, c, backfaceCulling, target) { + _edge1.subVectors(b, a); + _edge2.subVectors(c, a); + _normal$1.crossVectors(_edge1, _edge2); + let DdN = this.direction.dot(_normal$1); + let sign2; + if (DdN > 0) { + if (backfaceCulling) return null; + sign2 = 1; + } else if (DdN < 0) { + sign2 = -1; + DdN = -DdN; + } else { + return null; + } + _diff.subVectors(this.origin, a); + const DdQxE2 = sign2 * this.direction.dot(_edge2.crossVectors(_diff, _edge2)); + if (DdQxE2 < 0) { + return null; + } + const DdE1xQ = sign2 * this.direction.dot(_edge1.cross(_diff)); + if (DdE1xQ < 0) { + return null; + } + if (DdQxE2 + DdE1xQ > DdN) { + return null; + } + const QdN = -sign2 * _diff.dot(_normal$1); + if (QdN < 0) { + return null; + } + return this.at(QdN / DdN, target); + } + applyMatrix4(matrix4) { + this.origin.applyMatrix4(matrix4); + this.direction.transformDirection(matrix4); + return this; + } + equals(ray) { + return ray.origin.equals(this.origin) && ray.direction.equals(this.direction); + } + clone() { + return new this.constructor().copy(this); + } +}; +var Matrix4 = class _Matrix4 { + constructor(n11, n12, n13, n14, n21, n22, n23, n24, n31, n32, n33, n34, n41, n42, n43, n44) { + _Matrix4.prototype.isMatrix4 = true; + this.elements = [ + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1 + ]; + if (n11 !== void 0) { + this.set(n11, n12, n13, n14, n21, n22, n23, n24, n31, n32, n33, n34, n41, n42, n43, n44); + } + } + set(n11, n12, n13, n14, n21, n22, n23, n24, n31, n32, n33, n34, n41, n42, n43, n44) { + const te = this.elements; + te[0] = n11; + te[4] = n12; + te[8] = n13; + te[12] = n14; + te[1] = n21; + te[5] = n22; + te[9] = n23; + te[13] = n24; + te[2] = n31; + te[6] = n32; + te[10] = n33; + te[14] = n34; + te[3] = n41; + te[7] = n42; + te[11] = n43; + te[15] = n44; + return this; + } + identity() { + this.set( + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1 + ); + return this; + } + clone() { + return new _Matrix4().fromArray(this.elements); + } + copy(m) { + const te = this.elements; + const me = m.elements; + te[0] = me[0]; + te[1] = me[1]; + te[2] = me[2]; + te[3] = me[3]; + te[4] = me[4]; + te[5] = me[5]; + te[6] = me[6]; + te[7] = me[7]; + te[8] = me[8]; + te[9] = me[9]; + te[10] = me[10]; + te[11] = me[11]; + te[12] = me[12]; + te[13] = me[13]; + te[14] = me[14]; + te[15] = me[15]; + return this; + } + copyPosition(m) { + const te = this.elements, me = m.elements; + te[12] = me[12]; + te[13] = me[13]; + te[14] = me[14]; + return this; + } + setFromMatrix3(m) { + const me = m.elements; + this.set( + me[0], + me[3], + me[6], + 0, + me[1], + me[4], + me[7], + 0, + me[2], + me[5], + me[8], + 0, + 0, + 0, + 0, + 1 + ); + return this; + } + extractBasis(xAxis, yAxis, zAxis) { + xAxis.setFromMatrixColumn(this, 0); + yAxis.setFromMatrixColumn(this, 1); + zAxis.setFromMatrixColumn(this, 2); + return this; + } + makeBasis(xAxis, yAxis, zAxis) { + this.set( + xAxis.x, + yAxis.x, + zAxis.x, + 0, + xAxis.y, + yAxis.y, + zAxis.y, + 0, + xAxis.z, + yAxis.z, + zAxis.z, + 0, + 0, + 0, + 0, + 1 + ); + return this; + } + extractRotation(m) { + const te = this.elements; + const me = m.elements; + const scaleX = 1 / _v1$5.setFromMatrixColumn(m, 0).length(); + const scaleY = 1 / _v1$5.setFromMatrixColumn(m, 1).length(); + const scaleZ = 1 / _v1$5.setFromMatrixColumn(m, 2).length(); + te[0] = me[0] * scaleX; + te[1] = me[1] * scaleX; + te[2] = me[2] * scaleX; + te[3] = 0; + te[4] = me[4] * scaleY; + te[5] = me[5] * scaleY; + te[6] = me[6] * scaleY; + te[7] = 0; + te[8] = me[8] * scaleZ; + te[9] = me[9] * scaleZ; + te[10] = me[10] * scaleZ; + te[11] = 0; + te[12] = 0; + te[13] = 0; + te[14] = 0; + te[15] = 1; + return this; + } + makeRotationFromEuler(euler) { + const te = this.elements; + const x = euler.x, y = euler.y, z = euler.z; + const a = Math.cos(x), b = Math.sin(x); + const c = Math.cos(y), d = Math.sin(y); + const e = Math.cos(z), f = Math.sin(z); + if (euler.order === "XYZ") { + const ae = a * e, af = a * f, be = b * e, bf = b * f; + te[0] = c * e; + te[4] = -c * f; + te[8] = d; + te[1] = af + be * d; + te[5] = ae - bf * d; + te[9] = -b * c; + te[2] = bf - ae * d; + te[6] = be + af * d; + te[10] = a * c; + } else if (euler.order === "YXZ") { + const ce = c * e, cf = c * f, de = d * e, df = d * f; + te[0] = ce + df * b; + te[4] = de * b - cf; + te[8] = a * d; + te[1] = a * f; + te[5] = a * e; + te[9] = -b; + te[2] = cf * b - de; + te[6] = df + ce * b; + te[10] = a * c; + } else if (euler.order === "ZXY") { + const ce = c * e, cf = c * f, de = d * e, df = d * f; + te[0] = ce - df * b; + te[4] = -a * f; + te[8] = de + cf * b; + te[1] = cf + de * b; + te[5] = a * e; + te[9] = df - ce * b; + te[2] = -a * d; + te[6] = b; + te[10] = a * c; + } else if (euler.order === "ZYX") { + const ae = a * e, af = a * f, be = b * e, bf = b * f; + te[0] = c * e; + te[4] = be * d - af; + te[8] = ae * d + bf; + te[1] = c * f; + te[5] = bf * d + ae; + te[9] = af * d - be; + te[2] = -d; + te[6] = b * c; + te[10] = a * c; + } else if (euler.order === "YZX") { + const ac = a * c, ad = a * d, bc = b * c, bd = b * d; + te[0] = c * e; + te[4] = bd - ac * f; + te[8] = bc * f + ad; + te[1] = f; + te[5] = a * e; + te[9] = -b * e; + te[2] = -d * e; + te[6] = ad * f + bc; + te[10] = ac - bd * f; + } else if (euler.order === "XZY") { + const ac = a * c, ad = a * d, bc = b * c, bd = b * d; + te[0] = c * e; + te[4] = -f; + te[8] = d * e; + te[1] = ac * f + bd; + te[5] = a * e; + te[9] = ad * f - bc; + te[2] = bc * f - ad; + te[6] = b * e; + te[10] = bd * f + ac; + } + te[3] = 0; + te[7] = 0; + te[11] = 0; + te[12] = 0; + te[13] = 0; + te[14] = 0; + te[15] = 1; + return this; + } + makeRotationFromQuaternion(q) { + return this.compose(_zero, q, _one); + } + lookAt(eye, target, up2) { + const te = this.elements; + _z.subVectors(eye, target); + if (_z.lengthSq() === 0) { + _z.z = 1; + } + _z.normalize(); + _x.crossVectors(up2, _z); + if (_x.lengthSq() === 0) { + if (Math.abs(up2.z) === 1) { + _z.x += 1e-4; + } else { + _z.z += 1e-4; + } + _z.normalize(); + _x.crossVectors(up2, _z); + } + _x.normalize(); + _y.crossVectors(_z, _x); + te[0] = _x.x; + te[4] = _y.x; + te[8] = _z.x; + te[1] = _x.y; + te[5] = _y.y; + te[9] = _z.y; + te[2] = _x.z; + te[6] = _y.z; + te[10] = _z.z; + return this; + } + multiply(m) { + return this.multiplyMatrices(this, m); + } + premultiply(m) { + return this.multiplyMatrices(m, this); + } + multiplyMatrices(a, b) { + const ae = a.elements; + const be = b.elements; + const te = this.elements; + const a11 = ae[0], a12 = ae[4], a13 = ae[8], a14 = ae[12]; + const a21 = ae[1], a22 = ae[5], a23 = ae[9], a24 = ae[13]; + const a31 = ae[2], a32 = ae[6], a33 = ae[10], a34 = ae[14]; + const a41 = ae[3], a42 = ae[7], a43 = ae[11], a44 = ae[15]; + const b11 = be[0], b12 = be[4], b13 = be[8], b14 = be[12]; + const b21 = be[1], b22 = be[5], b23 = be[9], b24 = be[13]; + const b31 = be[2], b32 = be[6], b33 = be[10], b34 = be[14]; + const b41 = be[3], b42 = be[7], b43 = be[11], b44 = be[15]; + te[0] = a11 * b11 + a12 * b21 + a13 * b31 + a14 * b41; + te[4] = a11 * b12 + a12 * b22 + a13 * b32 + a14 * b42; + te[8] = a11 * b13 + a12 * b23 + a13 * b33 + a14 * b43; + te[12] = a11 * b14 + a12 * b24 + a13 * b34 + a14 * b44; + te[1] = a21 * b11 + a22 * b21 + a23 * b31 + a24 * b41; + te[5] = a21 * b12 + a22 * b22 + a23 * b32 + a24 * b42; + te[9] = a21 * b13 + a22 * b23 + a23 * b33 + a24 * b43; + te[13] = a21 * b14 + a22 * b24 + a23 * b34 + a24 * b44; + te[2] = a31 * b11 + a32 * b21 + a33 * b31 + a34 * b41; + te[6] = a31 * b12 + a32 * b22 + a33 * b32 + a34 * b42; + te[10] = a31 * b13 + a32 * b23 + a33 * b33 + a34 * b43; + te[14] = a31 * b14 + a32 * b24 + a33 * b34 + a34 * b44; + te[3] = a41 * b11 + a42 * b21 + a43 * b31 + a44 * b41; + te[7] = a41 * b12 + a42 * b22 + a43 * b32 + a44 * b42; + te[11] = a41 * b13 + a42 * b23 + a43 * b33 + a44 * b43; + te[15] = a41 * b14 + a42 * b24 + a43 * b34 + a44 * b44; + return this; + } + multiplyScalar(s) { + const te = this.elements; + te[0] *= s; + te[4] *= s; + te[8] *= s; + te[12] *= s; + te[1] *= s; + te[5] *= s; + te[9] *= s; + te[13] *= s; + te[2] *= s; + te[6] *= s; + te[10] *= s; + te[14] *= s; + te[3] *= s; + te[7] *= s; + te[11] *= s; + te[15] *= s; + return this; + } + determinant() { + const te = this.elements; + const n11 = te[0], n12 = te[4], n13 = te[8], n14 = te[12]; + const n21 = te[1], n22 = te[5], n23 = te[9], n24 = te[13]; + const n31 = te[2], n32 = te[6], n33 = te[10], n34 = te[14]; + const n41 = te[3], n42 = te[7], n43 = te[11], n44 = te[15]; + return n41 * (+n14 * n23 * n32 - n13 * n24 * n32 - n14 * n22 * n33 + n12 * n24 * n33 + n13 * n22 * n34 - n12 * n23 * n34) + n42 * (+n11 * n23 * n34 - n11 * n24 * n33 + n14 * n21 * n33 - n13 * n21 * n34 + n13 * n24 * n31 - n14 * n23 * n31) + n43 * (+n11 * n24 * n32 - n11 * n22 * n34 - n14 * n21 * n32 + n12 * n21 * n34 + n14 * n22 * n31 - n12 * n24 * n31) + n44 * (-n13 * n22 * n31 - n11 * n23 * n32 + n11 * n22 * n33 + n13 * n21 * n32 - n12 * n21 * n33 + n12 * n23 * n31); + } + transpose() { + const te = this.elements; + let tmp; + tmp = te[1]; + te[1] = te[4]; + te[4] = tmp; + tmp = te[2]; + te[2] = te[8]; + te[8] = tmp; + tmp = te[6]; + te[6] = te[9]; + te[9] = tmp; + tmp = te[3]; + te[3] = te[12]; + te[12] = tmp; + tmp = te[7]; + te[7] = te[13]; + te[13] = tmp; + tmp = te[11]; + te[11] = te[14]; + te[14] = tmp; + return this; + } + setPosition(x, y, z) { + const te = this.elements; + if (x.isVector3) { + te[12] = x.x; + te[13] = x.y; + te[14] = x.z; + } else { + te[12] = x; + te[13] = y; + te[14] = z; + } + return this; + } + invert() { + const te = this.elements, n11 = te[0], n21 = te[1], n31 = te[2], n41 = te[3], n12 = te[4], n22 = te[5], n32 = te[6], n42 = te[7], n13 = te[8], n23 = te[9], n33 = te[10], n43 = te[11], n14 = te[12], n24 = te[13], n34 = te[14], n44 = te[15], t11 = n23 * n34 * n42 - n24 * n33 * n42 + n24 * n32 * n43 - n22 * n34 * n43 - n23 * n32 * n44 + n22 * n33 * n44, t12 = n14 * n33 * n42 - n13 * n34 * n42 - n14 * n32 * n43 + n12 * n34 * n43 + n13 * n32 * n44 - n12 * n33 * n44, t13 = n13 * n24 * n42 - n14 * n23 * n42 + n14 * n22 * n43 - n12 * n24 * n43 - n13 * n22 * n44 + n12 * n23 * n44, t14 = n14 * n23 * n32 - n13 * n24 * n32 - n14 * n22 * n33 + n12 * n24 * n33 + n13 * n22 * n34 - n12 * n23 * n34; + const det = n11 * t11 + n21 * t12 + n31 * t13 + n41 * t14; + if (det === 0) return this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); + const detInv = 1 / det; + te[0] = t11 * detInv; + te[1] = (n24 * n33 * n41 - n23 * n34 * n41 - n24 * n31 * n43 + n21 * n34 * n43 + n23 * n31 * n44 - n21 * n33 * n44) * detInv; + te[2] = (n22 * n34 * n41 - n24 * n32 * n41 + n24 * n31 * n42 - n21 * n34 * n42 - n22 * n31 * n44 + n21 * n32 * n44) * detInv; + te[3] = (n23 * n32 * n41 - n22 * n33 * n41 - n23 * n31 * n42 + n21 * n33 * n42 + n22 * n31 * n43 - n21 * n32 * n43) * detInv; + te[4] = t12 * detInv; + te[5] = (n13 * n34 * n41 - n14 * n33 * n41 + n14 * n31 * n43 - n11 * n34 * n43 - n13 * n31 * n44 + n11 * n33 * n44) * detInv; + te[6] = (n14 * n32 * n41 - n12 * n34 * n41 - n14 * n31 * n42 + n11 * n34 * n42 + n12 * n31 * n44 - n11 * n32 * n44) * detInv; + te[7] = (n12 * n33 * n41 - n13 * n32 * n41 + n13 * n31 * n42 - n11 * n33 * n42 - n12 * n31 * n43 + n11 * n32 * n43) * detInv; + te[8] = t13 * detInv; + te[9] = (n14 * n23 * n41 - n13 * n24 * n41 - n14 * n21 * n43 + n11 * n24 * n43 + n13 * n21 * n44 - n11 * n23 * n44) * detInv; + te[10] = (n12 * n24 * n41 - n14 * n22 * n41 + n14 * n21 * n42 - n11 * n24 * n42 - n12 * n21 * n44 + n11 * n22 * n44) * detInv; + te[11] = (n13 * n22 * n41 - n12 * n23 * n41 - n13 * n21 * n42 + n11 * n23 * n42 + n12 * n21 * n43 - n11 * n22 * n43) * detInv; + te[12] = t14 * detInv; + te[13] = (n13 * n24 * n31 - n14 * n23 * n31 + n14 * n21 * n33 - n11 * n24 * n33 - n13 * n21 * n34 + n11 * n23 * n34) * detInv; + te[14] = (n14 * n22 * n31 - n12 * n24 * n31 - n14 * n21 * n32 + n11 * n24 * n32 + n12 * n21 * n34 - n11 * n22 * n34) * detInv; + te[15] = (n12 * n23 * n31 - n13 * n22 * n31 + n13 * n21 * n32 - n11 * n23 * n32 - n12 * n21 * n33 + n11 * n22 * n33) * detInv; + return this; + } + scale(v) { + const te = this.elements; + const x = v.x, y = v.y, z = v.z; + te[0] *= x; + te[4] *= y; + te[8] *= z; + te[1] *= x; + te[5] *= y; + te[9] *= z; + te[2] *= x; + te[6] *= y; + te[10] *= z; + te[3] *= x; + te[7] *= y; + te[11] *= z; + return this; + } + getMaxScaleOnAxis() { + const te = this.elements; + const scaleXSq = te[0] * te[0] + te[1] * te[1] + te[2] * te[2]; + const scaleYSq = te[4] * te[4] + te[5] * te[5] + te[6] * te[6]; + const scaleZSq = te[8] * te[8] + te[9] * te[9] + te[10] * te[10]; + return Math.sqrt(Math.max(scaleXSq, scaleYSq, scaleZSq)); + } + makeTranslation(x, y, z) { + if (x.isVector3) { + this.set( + 1, + 0, + 0, + x.x, + 0, + 1, + 0, + x.y, + 0, + 0, + 1, + x.z, + 0, + 0, + 0, + 1 + ); + } else { + this.set( + 1, + 0, + 0, + x, + 0, + 1, + 0, + y, + 0, + 0, + 1, + z, + 0, + 0, + 0, + 1 + ); + } + return this; + } + makeRotationX(theta) { + const c = Math.cos(theta), s = Math.sin(theta); + this.set( + 1, + 0, + 0, + 0, + 0, + c, + -s, + 0, + 0, + s, + c, + 0, + 0, + 0, + 0, + 1 + ); + return this; + } + makeRotationY(theta) { + const c = Math.cos(theta), s = Math.sin(theta); + this.set( + c, + 0, + s, + 0, + 0, + 1, + 0, + 0, + -s, + 0, + c, + 0, + 0, + 0, + 0, + 1 + ); + return this; + } + makeRotationZ(theta) { + const c = Math.cos(theta), s = Math.sin(theta); + this.set( + c, + -s, + 0, + 0, + s, + c, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1 + ); + return this; + } + makeRotationAxis(axis, angle) { + const c = Math.cos(angle); + const s = Math.sin(angle); + const t = 1 - c; + const x = axis.x, y = axis.y, z = axis.z; + const tx = t * x, ty = t * y; + this.set( + tx * x + c, + tx * y - s * z, + tx * z + s * y, + 0, + tx * y + s * z, + ty * y + c, + ty * z - s * x, + 0, + tx * z - s * y, + ty * z + s * x, + t * z * z + c, + 0, + 0, + 0, + 0, + 1 + ); + return this; + } + makeScale(x, y, z) { + this.set( + x, + 0, + 0, + 0, + 0, + y, + 0, + 0, + 0, + 0, + z, + 0, + 0, + 0, + 0, + 1 + ); + return this; + } + makeShear(xy, xz, yx, yz, zx, zy) { + this.set( + 1, + yx, + zx, + 0, + xy, + 1, + zy, + 0, + xz, + yz, + 1, + 0, + 0, + 0, + 0, + 1 + ); + return this; + } + compose(position, quaternion2, scale) { + const te = this.elements; + const x = quaternion2._x, y = quaternion2._y, z = quaternion2._z, w = quaternion2._w; + const x2 = x + x, y2 = y + y, z2 = z + z; + const xx = x * x2, xy = x * y2, xz = x * z2; + const yy = y * y2, yz = y * z2, zz = z * z2; + const wx = w * x2, wy = w * y2, wz = w * z2; + const sx = scale.x, sy = scale.y, sz = scale.z; + te[0] = (1 - (yy + zz)) * sx; + te[1] = (xy + wz) * sx; + te[2] = (xz - wy) * sx; + te[3] = 0; + te[4] = (xy - wz) * sy; + te[5] = (1 - (xx + zz)) * sy; + te[6] = (yz + wx) * sy; + te[7] = 0; + te[8] = (xz + wy) * sz; + te[9] = (yz - wx) * sz; + te[10] = (1 - (xx + yy)) * sz; + te[11] = 0; + te[12] = position.x; + te[13] = position.y; + te[14] = position.z; + te[15] = 1; + return this; + } + decompose(position, quaternion2, scale) { + const te = this.elements; + let sx = _v1$5.set(te[0], te[1], te[2]).length(); + const sy = _v1$5.set(te[4], te[5], te[6]).length(); + const sz = _v1$5.set(te[8], te[9], te[10]).length(); + const det = this.determinant(); + if (det < 0) sx = -sx; + position.x = te[12]; + position.y = te[13]; + position.z = te[14]; + _m1$4.copy(this); + const invSX = 1 / sx; + const invSY = 1 / sy; + const invSZ = 1 / sz; + _m1$4.elements[0] *= invSX; + _m1$4.elements[1] *= invSX; + _m1$4.elements[2] *= invSX; + _m1$4.elements[4] *= invSY; + _m1$4.elements[5] *= invSY; + _m1$4.elements[6] *= invSY; + _m1$4.elements[8] *= invSZ; + _m1$4.elements[9] *= invSZ; + _m1$4.elements[10] *= invSZ; + quaternion2.setFromRotationMatrix(_m1$4); + scale.x = sx; + scale.y = sy; + scale.z = sz; + return this; + } + makePerspective(left, right2, top, bottom, near, far, coordinateSystem = WebGLCoordinateSystem) { + const te = this.elements; + const x = 2 * near / (right2 - left); + const y = 2 * near / (top - bottom); + const a = (right2 + left) / (right2 - left); + const b = (top + bottom) / (top - bottom); + let c, d; + if (coordinateSystem === WebGLCoordinateSystem) { + c = -(far + near) / (far - near); + d = -2 * far * near / (far - near); + } else if (coordinateSystem === WebGPUCoordinateSystem) { + c = -far / (far - near); + d = -far * near / (far - near); + } else { + throw new Error("THREE.Matrix4.makePerspective(): Invalid coordinate system: " + coordinateSystem); + } + te[0] = x; + te[4] = 0; + te[8] = a; + te[12] = 0; + te[1] = 0; + te[5] = y; + te[9] = b; + te[13] = 0; + te[2] = 0; + te[6] = 0; + te[10] = c; + te[14] = d; + te[3] = 0; + te[7] = 0; + te[11] = -1; + te[15] = 0; + return this; + } + makeOrthographic(left, right2, top, bottom, near, far, coordinateSystem = WebGLCoordinateSystem) { + const te = this.elements; + const w = 1 / (right2 - left); + const h = 1 / (top - bottom); + const p = 1 / (far - near); + const x = (right2 + left) * w; + const y = (top + bottom) * h; + let z, zInv; + if (coordinateSystem === WebGLCoordinateSystem) { + z = (far + near) * p; + zInv = -2 * p; + } else if (coordinateSystem === WebGPUCoordinateSystem) { + z = near * p; + zInv = -1 * p; + } else { + throw new Error("THREE.Matrix4.makeOrthographic(): Invalid coordinate system: " + coordinateSystem); + } + te[0] = 2 * w; + te[4] = 0; + te[8] = 0; + te[12] = -x; + te[1] = 0; + te[5] = 2 * h; + te[9] = 0; + te[13] = -y; + te[2] = 0; + te[6] = 0; + te[10] = zInv; + te[14] = -z; + te[3] = 0; + te[7] = 0; + te[11] = 0; + te[15] = 1; + return this; + } + equals(matrix) { + const te = this.elements; + const me = matrix.elements; + for (let i = 0; i < 16; i++) { + if (te[i] !== me[i]) return false; + } + return true; + } + fromArray(array, offset = 0) { + for (let i = 0; i < 16; i++) { + this.elements[i] = array[i + offset]; + } + return this; + } + toArray(array = [], offset = 0) { + const te = this.elements; + array[offset] = te[0]; + array[offset + 1] = te[1]; + array[offset + 2] = te[2]; + array[offset + 3] = te[3]; + array[offset + 4] = te[4]; + array[offset + 5] = te[5]; + array[offset + 6] = te[6]; + array[offset + 7] = te[7]; + array[offset + 8] = te[8]; + array[offset + 9] = te[9]; + array[offset + 10] = te[10]; + array[offset + 11] = te[11]; + array[offset + 12] = te[12]; + array[offset + 13] = te[13]; + array[offset + 14] = te[14]; + array[offset + 15] = te[15]; + return array; + } +}; +var _v1$5 = /* @__PURE__ */ new Vector3(); +var _m1$4 = /* @__PURE__ */ new Matrix4(); +var _zero = /* @__PURE__ */ new Vector3(0, 0, 0); +var _one = /* @__PURE__ */ new Vector3(1, 1, 1); +var _x = /* @__PURE__ */ new Vector3(); +var _y = /* @__PURE__ */ new Vector3(); +var _z = /* @__PURE__ */ new Vector3(); +var _matrix$2 = /* @__PURE__ */ new Matrix4(); +var _quaternion$3 = /* @__PURE__ */ new Quaternion(); +var Euler = class _Euler { + constructor(x = 0, y = 0, z = 0, order = _Euler.DEFAULT_ORDER) { + this.isEuler = true; + this._x = x; + this._y = y; + this._z = z; + this._order = order; + } + get x() { + return this._x; + } + set x(value) { + this._x = value; + this._onChangeCallback(); + } + get y() { + return this._y; + } + set y(value) { + this._y = value; + this._onChangeCallback(); + } + get z() { + return this._z; + } + set z(value) { + this._z = value; + this._onChangeCallback(); + } + get order() { + return this._order; + } + set order(value) { + this._order = value; + this._onChangeCallback(); + } + set(x, y, z, order = this._order) { + this._x = x; + this._y = y; + this._z = z; + this._order = order; + this._onChangeCallback(); + return this; + } + clone() { + return new this.constructor(this._x, this._y, this._z, this._order); + } + copy(euler) { + this._x = euler._x; + this._y = euler._y; + this._z = euler._z; + this._order = euler._order; + this._onChangeCallback(); + return this; + } + setFromRotationMatrix(m, order = this._order, update = true) { + const te = m.elements; + const m11 = te[0], m12 = te[4], m13 = te[8]; + const m21 = te[1], m22 = te[5], m23 = te[9]; + const m31 = te[2], m32 = te[6], m33 = te[10]; + switch (order) { + case "XYZ": + this._y = Math.asin(clamp(m13, -1, 1)); + if (Math.abs(m13) < 0.9999999) { + this._x = Math.atan2(-m23, m33); + this._z = Math.atan2(-m12, m11); + } else { + this._x = Math.atan2(m32, m22); + this._z = 0; + } + break; + case "YXZ": + this._x = Math.asin(-clamp(m23, -1, 1)); + if (Math.abs(m23) < 0.9999999) { + this._y = Math.atan2(m13, m33); + this._z = Math.atan2(m21, m22); + } else { + this._y = Math.atan2(-m31, m11); + this._z = 0; + } + break; + case "ZXY": + this._x = Math.asin(clamp(m32, -1, 1)); + if (Math.abs(m32) < 0.9999999) { + this._y = Math.atan2(-m31, m33); + this._z = Math.atan2(-m12, m22); + } else { + this._y = 0; + this._z = Math.atan2(m21, m11); + } + break; + case "ZYX": + this._y = Math.asin(-clamp(m31, -1, 1)); + if (Math.abs(m31) < 0.9999999) { + this._x = Math.atan2(m32, m33); + this._z = Math.atan2(m21, m11); + } else { + this._x = 0; + this._z = Math.atan2(-m12, m22); + } + break; + case "YZX": + this._z = Math.asin(clamp(m21, -1, 1)); + if (Math.abs(m21) < 0.9999999) { + this._x = Math.atan2(-m23, m22); + this._y = Math.atan2(-m31, m11); + } else { + this._x = 0; + this._y = Math.atan2(m13, m33); + } + break; + case "XZY": + this._z = Math.asin(-clamp(m12, -1, 1)); + if (Math.abs(m12) < 0.9999999) { + this._x = Math.atan2(m32, m22); + this._y = Math.atan2(m13, m11); + } else { + this._x = Math.atan2(-m23, m33); + this._y = 0; + } + break; + default: + console.warn("THREE.Euler: .setFromRotationMatrix() encountered an unknown order: " + order); + } + this._order = order; + if (update === true) this._onChangeCallback(); + return this; + } + setFromQuaternion(q, order, update) { + _matrix$2.makeRotationFromQuaternion(q); + return this.setFromRotationMatrix(_matrix$2, order, update); + } + setFromVector3(v, order = this._order) { + return this.set(v.x, v.y, v.z, order); + } + reorder(newOrder) { + _quaternion$3.setFromEuler(this); + return this.setFromQuaternion(_quaternion$3, newOrder); + } + equals(euler) { + return euler._x === this._x && euler._y === this._y && euler._z === this._z && euler._order === this._order; + } + fromArray(array) { + this._x = array[0]; + this._y = array[1]; + this._z = array[2]; + if (array[3] !== void 0) this._order = array[3]; + this._onChangeCallback(); + return this; + } + toArray(array = [], offset = 0) { + array[offset] = this._x; + array[offset + 1] = this._y; + array[offset + 2] = this._z; + array[offset + 3] = this._order; + return array; + } + _onChange(callback) { + this._onChangeCallback = callback; + return this; + } + _onChangeCallback() { + } + *[Symbol.iterator]() { + yield this._x; + yield this._y; + yield this._z; + yield this._order; + } +}; +Euler.DEFAULT_ORDER = "XYZ"; +var Layers = class { + constructor() { + this.mask = 1 | 0; + } + set(channel) { + this.mask = (1 << channel | 0) >>> 0; + } + enable(channel) { + this.mask |= 1 << channel | 0; + } + enableAll() { + this.mask = 4294967295 | 0; + } + toggle(channel) { + this.mask ^= 1 << channel | 0; + } + disable(channel) { + this.mask &= ~(1 << channel | 0); + } + disableAll() { + this.mask = 0; + } + test(layers) { + return (this.mask & layers.mask) !== 0; + } + isEnabled(channel) { + return (this.mask & (1 << channel | 0)) !== 0; + } +}; +var _object3DId = 0; +var _v1$4 = /* @__PURE__ */ new Vector3(); +var _q1 = /* @__PURE__ */ new Quaternion(); +var _m1$3 = /* @__PURE__ */ new Matrix4(); +var _target = /* @__PURE__ */ new Vector3(); +var _position$3 = /* @__PURE__ */ new Vector3(); +var _scale$2 = /* @__PURE__ */ new Vector3(); +var _quaternion$2 = /* @__PURE__ */ new Quaternion(); +var _xAxis = /* @__PURE__ */ new Vector3(1, 0, 0); +var _yAxis = /* @__PURE__ */ new Vector3(0, 1, 0); +var _zAxis = /* @__PURE__ */ new Vector3(0, 0, 1); +var _addedEvent = { type: "added" }; +var _removedEvent = { type: "removed" }; +var _childaddedEvent = { type: "childadded", child: null }; +var _childremovedEvent = { type: "childremoved", child: null }; +var Object3D = class _Object3D extends EventDispatcher { + constructor() { + super(); + this.isObject3D = true; + Object.defineProperty(this, "id", { value: _object3DId++ }); + this.uuid = generateUUID(); + this.name = ""; + this.type = "Object3D"; + this.parent = null; + this.children = []; + this.up = _Object3D.DEFAULT_UP.clone(); + const position = new Vector3(); + const rotation = new Euler(); + const quaternion2 = new Quaternion(); + const scale = new Vector3(1, 1, 1); + function onRotationChange() { + quaternion2.setFromEuler(rotation, false); + } + function onQuaternionChange() { + rotation.setFromQuaternion(quaternion2, void 0, false); + } + rotation._onChange(onRotationChange); + quaternion2._onChange(onQuaternionChange); + Object.defineProperties(this, { + position: { + configurable: true, + enumerable: true, + value: position + }, + rotation: { + configurable: true, + enumerable: true, + value: rotation + }, + quaternion: { + configurable: true, + enumerable: true, + value: quaternion2 + }, + scale: { + configurable: true, + enumerable: true, + value: scale + }, + modelViewMatrix: { + value: new Matrix4() + }, + normalMatrix: { + value: new Matrix3() + } + }); + this.matrix = new Matrix4(); + this.matrixWorld = new Matrix4(); + this.matrixAutoUpdate = _Object3D.DEFAULT_MATRIX_AUTO_UPDATE; + this.matrixWorldAutoUpdate = _Object3D.DEFAULT_MATRIX_WORLD_AUTO_UPDATE; + this.matrixWorldNeedsUpdate = false; + this.layers = new Layers(); + this.visible = true; + this.castShadow = false; + this.receiveShadow = false; + this.frustumCulled = true; + this.renderOrder = 0; + this.animations = []; + this.userData = {}; + } + onBeforeShadow() { + } + onAfterShadow() { + } + onBeforeRender() { + } + onAfterRender() { + } + applyMatrix4(matrix) { + if (this.matrixAutoUpdate) this.updateMatrix(); + this.matrix.premultiply(matrix); + this.matrix.decompose(this.position, this.quaternion, this.scale); + } + applyQuaternion(q) { + this.quaternion.premultiply(q); + return this; + } + setRotationFromAxisAngle(axis, angle) { + this.quaternion.setFromAxisAngle(axis, angle); + } + setRotationFromEuler(euler) { + this.quaternion.setFromEuler(euler, true); + } + setRotationFromMatrix(m) { + this.quaternion.setFromRotationMatrix(m); + } + setRotationFromQuaternion(q) { + this.quaternion.copy(q); + } + rotateOnAxis(axis, angle) { + _q1.setFromAxisAngle(axis, angle); + this.quaternion.multiply(_q1); + return this; + } + rotateOnWorldAxis(axis, angle) { + _q1.setFromAxisAngle(axis, angle); + this.quaternion.premultiply(_q1); + return this; + } + rotateX(angle) { + return this.rotateOnAxis(_xAxis, angle); + } + rotateY(angle) { + return this.rotateOnAxis(_yAxis, angle); + } + rotateZ(angle) { + return this.rotateOnAxis(_zAxis, angle); + } + translateOnAxis(axis, distance) { + _v1$4.copy(axis).applyQuaternion(this.quaternion); + this.position.add(_v1$4.multiplyScalar(distance)); + return this; + } + translateX(distance) { + return this.translateOnAxis(_xAxis, distance); + } + translateY(distance) { + return this.translateOnAxis(_yAxis, distance); + } + translateZ(distance) { + return this.translateOnAxis(_zAxis, distance); + } + localToWorld(vector) { + this.updateWorldMatrix(true, false); + return vector.applyMatrix4(this.matrixWorld); + } + worldToLocal(vector) { + this.updateWorldMatrix(true, false); + return vector.applyMatrix4(_m1$3.copy(this.matrixWorld).invert()); + } + lookAt(x, y, z) { + if (x.isVector3) { + _target.copy(x); + } else { + _target.set(x, y, z); + } + const parent = this.parent; + this.updateWorldMatrix(true, false); + _position$3.setFromMatrixPosition(this.matrixWorld); + if (this.isCamera || this.isLight) { + _m1$3.lookAt(_position$3, _target, this.up); + } else { + _m1$3.lookAt(_target, _position$3, this.up); + } + this.quaternion.setFromRotationMatrix(_m1$3); + if (parent) { + _m1$3.extractRotation(parent.matrixWorld); + _q1.setFromRotationMatrix(_m1$3); + this.quaternion.premultiply(_q1.invert()); + } + } + add(object) { + if (arguments.length > 1) { + for (let i = 0; i < arguments.length; i++) { + this.add(arguments[i]); + } + return this; + } + if (object === this) { + console.error("THREE.Object3D.add: object can't be added as a child of itself.", object); + return this; + } + if (object && object.isObject3D) { + object.removeFromParent(); + object.parent = this; + this.children.push(object); + object.dispatchEvent(_addedEvent); + _childaddedEvent.child = object; + this.dispatchEvent(_childaddedEvent); + _childaddedEvent.child = null; + } else { + console.error("THREE.Object3D.add: object not an instance of THREE.Object3D.", object); + } + return this; + } + remove(object) { + if (arguments.length > 1) { + for (let i = 0; i < arguments.length; i++) { + this.remove(arguments[i]); + } + return this; + } + const index = this.children.indexOf(object); + if (index !== -1) { + object.parent = null; + this.children.splice(index, 1); + object.dispatchEvent(_removedEvent); + _childremovedEvent.child = object; + this.dispatchEvent(_childremovedEvent); + _childremovedEvent.child = null; + } + return this; + } + removeFromParent() { + const parent = this.parent; + if (parent !== null) { + parent.remove(this); + } + return this; + } + clear() { + return this.remove(...this.children); + } + attach(object) { + this.updateWorldMatrix(true, false); + _m1$3.copy(this.matrixWorld).invert(); + if (object.parent !== null) { + object.parent.updateWorldMatrix(true, false); + _m1$3.multiply(object.parent.matrixWorld); + } + object.applyMatrix4(_m1$3); + object.removeFromParent(); + object.parent = this; + this.children.push(object); + object.updateWorldMatrix(false, true); + object.dispatchEvent(_addedEvent); + _childaddedEvent.child = object; + this.dispatchEvent(_childaddedEvent); + _childaddedEvent.child = null; + return this; + } + getObjectById(id) { + return this.getObjectByProperty("id", id); + } + getObjectByName(name) { + return this.getObjectByProperty("name", name); + } + getObjectByProperty(name, value) { + if (this[name] === value) return this; + for (let i = 0, l = this.children.length; i < l; i++) { + const child = this.children[i]; + const object = child.getObjectByProperty(name, value); + if (object !== void 0) { + return object; + } + } + return void 0; + } + getObjectsByProperty(name, value, result = []) { + if (this[name] === value) result.push(this); + const children = this.children; + for (let i = 0, l = children.length; i < l; i++) { + children[i].getObjectsByProperty(name, value, result); + } + return result; + } + getWorldPosition(target) { + this.updateWorldMatrix(true, false); + return target.setFromMatrixPosition(this.matrixWorld); + } + getWorldQuaternion(target) { + this.updateWorldMatrix(true, false); + this.matrixWorld.decompose(_position$3, target, _scale$2); + return target; + } + getWorldScale(target) { + this.updateWorldMatrix(true, false); + this.matrixWorld.decompose(_position$3, _quaternion$2, target); + return target; + } + getWorldDirection(target) { + this.updateWorldMatrix(true, false); + const e = this.matrixWorld.elements; + return target.set(e[8], e[9], e[10]).normalize(); + } + raycast() { + } + traverse(callback) { + callback(this); + const children = this.children; + for (let i = 0, l = children.length; i < l; i++) { + children[i].traverse(callback); + } + } + traverseVisible(callback) { + if (this.visible === false) return; + callback(this); + const children = this.children; + for (let i = 0, l = children.length; i < l; i++) { + children[i].traverseVisible(callback); + } + } + traverseAncestors(callback) { + const parent = this.parent; + if (parent !== null) { + callback(parent); + parent.traverseAncestors(callback); + } + } + updateMatrix() { + this.matrix.compose(this.position, this.quaternion, this.scale); + this.matrixWorldNeedsUpdate = true; + } + updateMatrixWorld(force) { + if (this.matrixAutoUpdate) this.updateMatrix(); + if (this.matrixWorldNeedsUpdate || force) { + if (this.parent === null) { + this.matrixWorld.copy(this.matrix); + } else { + this.matrixWorld.multiplyMatrices(this.parent.matrixWorld, this.matrix); + } + this.matrixWorldNeedsUpdate = false; + force = true; + } + const children = this.children; + for (let i = 0, l = children.length; i < l; i++) { + const child = children[i]; + if (child.matrixWorldAutoUpdate === true || force === true) { + child.updateMatrixWorld(force); + } + } + } + updateWorldMatrix(updateParents, updateChildren) { + const parent = this.parent; + if (updateParents === true && parent !== null && parent.matrixWorldAutoUpdate === true) { + parent.updateWorldMatrix(true, false); + } + if (this.matrixAutoUpdate) this.updateMatrix(); + if (this.parent === null) { + this.matrixWorld.copy(this.matrix); + } else { + this.matrixWorld.multiplyMatrices(this.parent.matrixWorld, this.matrix); + } + if (updateChildren === true) { + const children = this.children; + for (let i = 0, l = children.length; i < l; i++) { + const child = children[i]; + if (child.matrixWorldAutoUpdate === true) { + child.updateWorldMatrix(false, true); + } + } + } + } + toJSON(meta) { + const isRootObject = meta === void 0 || typeof meta === "string"; + const output = {}; + if (isRootObject) { + meta = { + geometries: {}, + materials: {}, + textures: {}, + images: {}, + shapes: {}, + skeletons: {}, + animations: {}, + nodes: {} + }; + output.metadata = { + version: 4.6, + type: "Object", + generator: "Object3D.toJSON" + }; + } + const object = {}; + object.uuid = this.uuid; + object.type = this.type; + if (this.name !== "") object.name = this.name; + if (this.castShadow === true) object.castShadow = true; + if (this.receiveShadow === true) object.receiveShadow = true; + if (this.visible === false) object.visible = false; + if (this.frustumCulled === false) object.frustumCulled = false; + if (this.renderOrder !== 0) object.renderOrder = this.renderOrder; + if (Object.keys(this.userData).length > 0) object.userData = this.userData; + object.layers = this.layers.mask; + object.matrix = this.matrix.toArray(); + object.up = this.up.toArray(); + if (this.matrixAutoUpdate === false) object.matrixAutoUpdate = false; + if (this.isInstancedMesh) { + object.type = "InstancedMesh"; + object.count = this.count; + object.instanceMatrix = this.instanceMatrix.toJSON(); + if (this.instanceColor !== null) object.instanceColor = this.instanceColor.toJSON(); + } + if (this.isBatchedMesh) { + object.type = "BatchedMesh"; + object.perObjectFrustumCulled = this.perObjectFrustumCulled; + object.sortObjects = this.sortObjects; + object.drawRanges = this._drawRanges; + object.reservedRanges = this._reservedRanges; + object.visibility = this._visibility; + object.active = this._active; + object.bounds = this._bounds.map((bound) => ({ + boxInitialized: bound.boxInitialized, + boxMin: bound.box.min.toArray(), + boxMax: bound.box.max.toArray(), + sphereInitialized: bound.sphereInitialized, + sphereRadius: bound.sphere.radius, + sphereCenter: bound.sphere.center.toArray() + })); + object.maxGeometryCount = this._maxGeometryCount; + object.maxVertexCount = this._maxVertexCount; + object.maxIndexCount = this._maxIndexCount; + object.geometryInitialized = this._geometryInitialized; + object.geometryCount = this._geometryCount; + object.matricesTexture = this._matricesTexture.toJSON(meta); + if (this.boundingSphere !== null) { + object.boundingSphere = { + center: object.boundingSphere.center.toArray(), + radius: object.boundingSphere.radius + }; + } + if (this.boundingBox !== null) { + object.boundingBox = { + min: object.boundingBox.min.toArray(), + max: object.boundingBox.max.toArray() + }; + } + } + function serialize(library, element) { + if (library[element.uuid] === void 0) { + library[element.uuid] = element.toJSON(meta); + } + return element.uuid; + } + if (this.isScene) { + if (this.background) { + if (this.background.isColor) { + object.background = this.background.toJSON(); + } else if (this.background.isTexture) { + object.background = this.background.toJSON(meta).uuid; + } + } + if (this.environment && this.environment.isTexture && this.environment.isRenderTargetTexture !== true) { + object.environment = this.environment.toJSON(meta).uuid; + } + } else if (this.isMesh || this.isLine || this.isPoints) { + object.geometry = serialize(meta.geometries, this.geometry); + const parameters = this.geometry.parameters; + if (parameters !== void 0 && parameters.shapes !== void 0) { + const shapes = parameters.shapes; + if (Array.isArray(shapes)) { + for (let i = 0, l = shapes.length; i < l; i++) { + const shape = shapes[i]; + serialize(meta.shapes, shape); + } + } else { + serialize(meta.shapes, shapes); + } + } + } + if (this.isSkinnedMesh) { + object.bindMode = this.bindMode; + object.bindMatrix = this.bindMatrix.toArray(); + if (this.skeleton !== void 0) { + serialize(meta.skeletons, this.skeleton); + object.skeleton = this.skeleton.uuid; + } + } + if (this.material !== void 0) { + if (Array.isArray(this.material)) { + const uuids = []; + for (let i = 0, l = this.material.length; i < l; i++) { + uuids.push(serialize(meta.materials, this.material[i])); + } + object.material = uuids; + } else { + object.material = serialize(meta.materials, this.material); + } + } + if (this.children.length > 0) { + object.children = []; + for (let i = 0; i < this.children.length; i++) { + object.children.push(this.children[i].toJSON(meta).object); + } + } + if (this.animations.length > 0) { + object.animations = []; + for (let i = 0; i < this.animations.length; i++) { + const animation = this.animations[i]; + object.animations.push(serialize(meta.animations, animation)); + } + } + if (isRootObject) { + const geometries = extractFromCache(meta.geometries); + const materials = extractFromCache(meta.materials); + const textures = extractFromCache(meta.textures); + const images = extractFromCache(meta.images); + const shapes = extractFromCache(meta.shapes); + const skeletons = extractFromCache(meta.skeletons); + const animations = extractFromCache(meta.animations); + const nodes = extractFromCache(meta.nodes); + if (geometries.length > 0) output.geometries = geometries; + if (materials.length > 0) output.materials = materials; + if (textures.length > 0) output.textures = textures; + if (images.length > 0) output.images = images; + if (shapes.length > 0) output.shapes = shapes; + if (skeletons.length > 0) output.skeletons = skeletons; + if (animations.length > 0) output.animations = animations; + if (nodes.length > 0) output.nodes = nodes; + } + output.object = object; + return output; + function extractFromCache(cache) { + const values = []; + for (const key in cache) { + const data = cache[key]; + delete data.metadata; + values.push(data); + } + return values; + } + } + clone(recursive) { + return new this.constructor().copy(this, recursive); + } + copy(source, recursive = true) { + this.name = source.name; + this.up.copy(source.up); + this.position.copy(source.position); + this.rotation.order = source.rotation.order; + this.quaternion.copy(source.quaternion); + this.scale.copy(source.scale); + this.matrix.copy(source.matrix); + this.matrixWorld.copy(source.matrixWorld); + this.matrixAutoUpdate = source.matrixAutoUpdate; + this.matrixWorldAutoUpdate = source.matrixWorldAutoUpdate; + this.matrixWorldNeedsUpdate = source.matrixWorldNeedsUpdate; + this.layers.mask = source.layers.mask; + this.visible = source.visible; + this.castShadow = source.castShadow; + this.receiveShadow = source.receiveShadow; + this.frustumCulled = source.frustumCulled; + this.renderOrder = source.renderOrder; + this.animations = source.animations.slice(); + this.userData = JSON.parse(JSON.stringify(source.userData)); + if (recursive === true) { + for (let i = 0; i < source.children.length; i++) { + const child = source.children[i]; + this.add(child.clone()); + } + } + return this; + } +}; +Object3D.DEFAULT_UP = /* @__PURE__ */ new Vector3(0, 1, 0); +Object3D.DEFAULT_MATRIX_AUTO_UPDATE = true; +Object3D.DEFAULT_MATRIX_WORLD_AUTO_UPDATE = true; +var _v0$1 = /* @__PURE__ */ new Vector3(); +var _v1$3 = /* @__PURE__ */ new Vector3(); +var _v2$2 = /* @__PURE__ */ new Vector3(); +var _v3$2 = /* @__PURE__ */ new Vector3(); +var _vab = /* @__PURE__ */ new Vector3(); +var _vac = /* @__PURE__ */ new Vector3(); +var _vbc = /* @__PURE__ */ new Vector3(); +var _vap = /* @__PURE__ */ new Vector3(); +var _vbp = /* @__PURE__ */ new Vector3(); +var _vcp = /* @__PURE__ */ new Vector3(); +var Triangle = class _Triangle { + constructor(a = new Vector3(), b = new Vector3(), c = new Vector3()) { + this.a = a; + this.b = b; + this.c = c; + } + static getNormal(a, b, c, target) { + target.subVectors(c, b); + _v0$1.subVectors(a, b); + target.cross(_v0$1); + const targetLengthSq = target.lengthSq(); + if (targetLengthSq > 0) { + return target.multiplyScalar(1 / Math.sqrt(targetLengthSq)); + } + return target.set(0, 0, 0); + } + // static/instance method to calculate barycentric coordinates + // based on: http://www.blackpawn.com/texts/pointinpoly/default.html + static getBarycoord(point, a, b, c, target) { + _v0$1.subVectors(c, a); + _v1$3.subVectors(b, a); + _v2$2.subVectors(point, a); + const dot00 = _v0$1.dot(_v0$1); + const dot01 = _v0$1.dot(_v1$3); + const dot02 = _v0$1.dot(_v2$2); + const dot11 = _v1$3.dot(_v1$3); + const dot12 = _v1$3.dot(_v2$2); + const denom = dot00 * dot11 - dot01 * dot01; + if (denom === 0) { + target.set(0, 0, 0); + return null; + } + const invDenom = 1 / denom; + const u = (dot11 * dot02 - dot01 * dot12) * invDenom; + const v = (dot00 * dot12 - dot01 * dot02) * invDenom; + return target.set(1 - u - v, v, u); + } + static containsPoint(point, a, b, c) { + if (this.getBarycoord(point, a, b, c, _v3$2) === null) { + return false; + } + return _v3$2.x >= 0 && _v3$2.y >= 0 && _v3$2.x + _v3$2.y <= 1; + } + static getInterpolation(point, p1, p2, p3, v1, v2, v3, target) { + if (this.getBarycoord(point, p1, p2, p3, _v3$2) === null) { + target.x = 0; + target.y = 0; + if ("z" in target) target.z = 0; + if ("w" in target) target.w = 0; + return null; + } + target.setScalar(0); + target.addScaledVector(v1, _v3$2.x); + target.addScaledVector(v2, _v3$2.y); + target.addScaledVector(v3, _v3$2.z); + return target; + } + static isFrontFacing(a, b, c, direction) { + _v0$1.subVectors(c, b); + _v1$3.subVectors(a, b); + return _v0$1.cross(_v1$3).dot(direction) < 0 ? true : false; + } + set(a, b, c) { + this.a.copy(a); + this.b.copy(b); + this.c.copy(c); + return this; + } + setFromPointsAndIndices(points, i0, i1, i2) { + this.a.copy(points[i0]); + this.b.copy(points[i1]); + this.c.copy(points[i2]); + return this; + } + setFromAttributeAndIndices(attribute, i0, i1, i2) { + this.a.fromBufferAttribute(attribute, i0); + this.b.fromBufferAttribute(attribute, i1); + this.c.fromBufferAttribute(attribute, i2); + return this; + } + clone() { + return new this.constructor().copy(this); + } + copy(triangle) { + this.a.copy(triangle.a); + this.b.copy(triangle.b); + this.c.copy(triangle.c); + return this; + } + getArea() { + _v0$1.subVectors(this.c, this.b); + _v1$3.subVectors(this.a, this.b); + return _v0$1.cross(_v1$3).length() * 0.5; + } + getMidpoint(target) { + return target.addVectors(this.a, this.b).add(this.c).multiplyScalar(1 / 3); + } + getNormal(target) { + return _Triangle.getNormal(this.a, this.b, this.c, target); + } + getPlane(target) { + return target.setFromCoplanarPoints(this.a, this.b, this.c); + } + getBarycoord(point, target) { + return _Triangle.getBarycoord(point, this.a, this.b, this.c, target); + } + getInterpolation(point, v1, v2, v3, target) { + return _Triangle.getInterpolation(point, this.a, this.b, this.c, v1, v2, v3, target); + } + containsPoint(point) { + return _Triangle.containsPoint(point, this.a, this.b, this.c); + } + isFrontFacing(direction) { + return _Triangle.isFrontFacing(this.a, this.b, this.c, direction); + } + intersectsBox(box) { + return box.intersectsTriangle(this); + } + closestPointToPoint(p, target) { + const a = this.a, b = this.b, c = this.c; + let v, w; + _vab.subVectors(b, a); + _vac.subVectors(c, a); + _vap.subVectors(p, a); + const d1 = _vab.dot(_vap); + const d2 = _vac.dot(_vap); + if (d1 <= 0 && d2 <= 0) { + return target.copy(a); + } + _vbp.subVectors(p, b); + const d3 = _vab.dot(_vbp); + const d4 = _vac.dot(_vbp); + if (d3 >= 0 && d4 <= d3) { + return target.copy(b); + } + const vc = d1 * d4 - d3 * d2; + if (vc <= 0 && d1 >= 0 && d3 <= 0) { + v = d1 / (d1 - d3); + return target.copy(a).addScaledVector(_vab, v); + } + _vcp.subVectors(p, c); + const d5 = _vab.dot(_vcp); + const d6 = _vac.dot(_vcp); + if (d6 >= 0 && d5 <= d6) { + return target.copy(c); + } + const vb = d5 * d2 - d1 * d6; + if (vb <= 0 && d2 >= 0 && d6 <= 0) { + w = d2 / (d2 - d6); + return target.copy(a).addScaledVector(_vac, w); + } + const va = d3 * d6 - d5 * d4; + if (va <= 0 && d4 - d3 >= 0 && d5 - d6 >= 0) { + _vbc.subVectors(c, b); + w = (d4 - d3) / (d4 - d3 + (d5 - d6)); + return target.copy(b).addScaledVector(_vbc, w); + } + const denom = 1 / (va + vb + vc); + v = vb * denom; + w = vc * denom; + return target.copy(a).addScaledVector(_vab, v).addScaledVector(_vac, w); + } + equals(triangle) { + return triangle.a.equals(this.a) && triangle.b.equals(this.b) && triangle.c.equals(this.c); + } +}; +var _colorKeywords = { + "aliceblue": 15792383, + "antiquewhite": 16444375, + "aqua": 65535, + "aquamarine": 8388564, + "azure": 15794175, + "beige": 16119260, + "bisque": 16770244, + "black": 0, + "blanchedalmond": 16772045, + "blue": 255, + "blueviolet": 9055202, + "brown": 10824234, + "burlywood": 14596231, + "cadetblue": 6266528, + "chartreuse": 8388352, + "chocolate": 13789470, + "coral": 16744272, + "cornflowerblue": 6591981, + "cornsilk": 16775388, + "crimson": 14423100, + "cyan": 65535, + "darkblue": 139, + "darkcyan": 35723, + "darkgoldenrod": 12092939, + "darkgray": 11119017, + "darkgreen": 25600, + "darkgrey": 11119017, + "darkkhaki": 12433259, + "darkmagenta": 9109643, + "darkolivegreen": 5597999, + "darkorange": 16747520, + "darkorchid": 10040012, + "darkred": 9109504, + "darksalmon": 15308410, + "darkseagreen": 9419919, + "darkslateblue": 4734347, + "darkslategray": 3100495, + "darkslategrey": 3100495, + "darkturquoise": 52945, + "darkviolet": 9699539, + "deeppink": 16716947, + "deepskyblue": 49151, + "dimgray": 6908265, + "dimgrey": 6908265, + "dodgerblue": 2003199, + "firebrick": 11674146, + "floralwhite": 16775920, + "forestgreen": 2263842, + "fuchsia": 16711935, + "gainsboro": 14474460, + "ghostwhite": 16316671, + "gold": 16766720, + "goldenrod": 14329120, + "gray": 8421504, + "green": 32768, + "greenyellow": 11403055, + "grey": 8421504, + "honeydew": 15794160, + "hotpink": 16738740, + "indianred": 13458524, + "indigo": 4915330, + "ivory": 16777200, + "khaki": 15787660, + "lavender": 15132410, + "lavenderblush": 16773365, + "lawngreen": 8190976, + "lemonchiffon": 16775885, + "lightblue": 11393254, + "lightcoral": 15761536, + "lightcyan": 14745599, + "lightgoldenrodyellow": 16448210, + "lightgray": 13882323, + "lightgreen": 9498256, + "lightgrey": 13882323, + "lightpink": 16758465, + "lightsalmon": 16752762, + "lightseagreen": 2142890, + "lightskyblue": 8900346, + "lightslategray": 7833753, + "lightslategrey": 7833753, + "lightsteelblue": 11584734, + "lightyellow": 16777184, + "lime": 65280, + "limegreen": 3329330, + "linen": 16445670, + "magenta": 16711935, + "maroon": 8388608, + "mediumaquamarine": 6737322, + "mediumblue": 205, + "mediumorchid": 12211667, + "mediumpurple": 9662683, + "mediumseagreen": 3978097, + "mediumslateblue": 8087790, + "mediumspringgreen": 64154, + "mediumturquoise": 4772300, + "mediumvioletred": 13047173, + "midnightblue": 1644912, + "mintcream": 16121850, + "mistyrose": 16770273, + "moccasin": 16770229, + "navajowhite": 16768685, + "navy": 128, + "oldlace": 16643558, + "olive": 8421376, + "olivedrab": 7048739, + "orange": 16753920, + "orangered": 16729344, + "orchid": 14315734, + "palegoldenrod": 15657130, + "palegreen": 10025880, + "paleturquoise": 11529966, + "palevioletred": 14381203, + "papayawhip": 16773077, + "peachpuff": 16767673, + "peru": 13468991, + "pink": 16761035, + "plum": 14524637, + "powderblue": 11591910, + "purple": 8388736, + "rebeccapurple": 6697881, + "red": 16711680, + "rosybrown": 12357519, + "royalblue": 4286945, + "saddlebrown": 9127187, + "salmon": 16416882, + "sandybrown": 16032864, + "seagreen": 3050327, + "seashell": 16774638, + "sienna": 10506797, + "silver": 12632256, + "skyblue": 8900331, + "slateblue": 6970061, + "slategray": 7372944, + "slategrey": 7372944, + "snow": 16775930, + "springgreen": 65407, + "steelblue": 4620980, + "tan": 13808780, + "teal": 32896, + "thistle": 14204888, + "tomato": 16737095, + "turquoise": 4251856, + "violet": 15631086, + "wheat": 16113331, + "white": 16777215, + "whitesmoke": 16119285, + "yellow": 16776960, + "yellowgreen": 10145074 +}; +var _hslA = { h: 0, s: 0, l: 0 }; +var _hslB = { h: 0, s: 0, l: 0 }; +function hue2rgb(p, q, t) { + if (t < 0) t += 1; + if (t > 1) t -= 1; + if (t < 1 / 6) return p + (q - p) * 6 * t; + if (t < 1 / 2) return q; + if (t < 2 / 3) return p + (q - p) * 6 * (2 / 3 - t); + return p; +} +var Color = class { + constructor(r, g, b) { + this.isColor = true; + this.r = 1; + this.g = 1; + this.b = 1; + return this.set(r, g, b); + } + set(r, g, b) { + if (g === void 0 && b === void 0) { + const value = r; + if (value && value.isColor) { + this.copy(value); + } else if (typeof value === "number") { + this.setHex(value); + } else if (typeof value === "string") { + this.setStyle(value); + } + } else { + this.setRGB(r, g, b); + } + return this; + } + setScalar(scalar) { + this.r = scalar; + this.g = scalar; + this.b = scalar; + return this; + } + setHex(hex, colorSpace = SRGBColorSpace) { + hex = Math.floor(hex); + this.r = (hex >> 16 & 255) / 255; + this.g = (hex >> 8 & 255) / 255; + this.b = (hex & 255) / 255; + ColorManagement.toWorkingColorSpace(this, colorSpace); + return this; + } + setRGB(r, g, b, colorSpace = ColorManagement.workingColorSpace) { + this.r = r; + this.g = g; + this.b = b; + ColorManagement.toWorkingColorSpace(this, colorSpace); + return this; + } + setHSL(h, s, l, colorSpace = ColorManagement.workingColorSpace) { + h = euclideanModulo(h, 1); + s = clamp(s, 0, 1); + l = clamp(l, 0, 1); + if (s === 0) { + this.r = this.g = this.b = l; + } else { + const p = l <= 0.5 ? l * (1 + s) : l + s - l * s; + const q = 2 * l - p; + this.r = hue2rgb(q, p, h + 1 / 3); + this.g = hue2rgb(q, p, h); + this.b = hue2rgb(q, p, h - 1 / 3); + } + ColorManagement.toWorkingColorSpace(this, colorSpace); + return this; + } + setStyle(style, colorSpace = SRGBColorSpace) { + function handleAlpha(string) { + if (string === void 0) return; + if (parseFloat(string) < 1) { + console.warn("THREE.Color: Alpha component of " + style + " will be ignored."); + } + } + let m; + if (m = /^(\w+)\(([^\)]*)\)/.exec(style)) { + let color; + const name = m[1]; + const components = m[2]; + switch (name) { + case "rgb": + case "rgba": + if (color = /^\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(components)) { + handleAlpha(color[4]); + return this.setRGB( + Math.min(255, parseInt(color[1], 10)) / 255, + Math.min(255, parseInt(color[2], 10)) / 255, + Math.min(255, parseInt(color[3], 10)) / 255, + colorSpace + ); + } + if (color = /^\s*(\d+)\%\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(components)) { + handleAlpha(color[4]); + return this.setRGB( + Math.min(100, parseInt(color[1], 10)) / 100, + Math.min(100, parseInt(color[2], 10)) / 100, + Math.min(100, parseInt(color[3], 10)) / 100, + colorSpace + ); + } + break; + case "hsl": + case "hsla": + if (color = /^\s*(\d*\.?\d+)\s*,\s*(\d*\.?\d+)\%\s*,\s*(\d*\.?\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(components)) { + handleAlpha(color[4]); + return this.setHSL( + parseFloat(color[1]) / 360, + parseFloat(color[2]) / 100, + parseFloat(color[3]) / 100, + colorSpace + ); + } + break; + default: + console.warn("THREE.Color: Unknown color model " + style); + } + } else if (m = /^\#([A-Fa-f\d]+)$/.exec(style)) { + const hex = m[1]; + const size = hex.length; + if (size === 3) { + return this.setRGB( + parseInt(hex.charAt(0), 16) / 15, + parseInt(hex.charAt(1), 16) / 15, + parseInt(hex.charAt(2), 16) / 15, + colorSpace + ); + } else if (size === 6) { + return this.setHex(parseInt(hex, 16), colorSpace); + } else { + console.warn("THREE.Color: Invalid hex color " + style); + } + } else if (style && style.length > 0) { + return this.setColorName(style, colorSpace); + } + return this; + } + setColorName(style, colorSpace = SRGBColorSpace) { + const hex = _colorKeywords[style.toLowerCase()]; + if (hex !== void 0) { + this.setHex(hex, colorSpace); + } else { + console.warn("THREE.Color: Unknown color " + style); + } + return this; + } + clone() { + return new this.constructor(this.r, this.g, this.b); + } + copy(color) { + this.r = color.r; + this.g = color.g; + this.b = color.b; + return this; + } + copySRGBToLinear(color) { + this.r = SRGBToLinear(color.r); + this.g = SRGBToLinear(color.g); + this.b = SRGBToLinear(color.b); + return this; + } + copyLinearToSRGB(color) { + this.r = LinearToSRGB(color.r); + this.g = LinearToSRGB(color.g); + this.b = LinearToSRGB(color.b); + return this; + } + convertSRGBToLinear() { + this.copySRGBToLinear(this); + return this; + } + convertLinearToSRGB() { + this.copyLinearToSRGB(this); + return this; + } + getHex(colorSpace = SRGBColorSpace) { + ColorManagement.fromWorkingColorSpace(_color.copy(this), colorSpace); + return Math.round(clamp(_color.r * 255, 0, 255)) * 65536 + Math.round(clamp(_color.g * 255, 0, 255)) * 256 + Math.round(clamp(_color.b * 255, 0, 255)); + } + getHexString(colorSpace = SRGBColorSpace) { + return ("000000" + this.getHex(colorSpace).toString(16)).slice(-6); + } + getHSL(target, colorSpace = ColorManagement.workingColorSpace) { + ColorManagement.fromWorkingColorSpace(_color.copy(this), colorSpace); + const r = _color.r, g = _color.g, b = _color.b; + const max2 = Math.max(r, g, b); + const min = Math.min(r, g, b); + let hue, saturation; + const lightness = (min + max2) / 2; + if (min === max2) { + hue = 0; + saturation = 0; + } else { + const delta = max2 - min; + saturation = lightness <= 0.5 ? delta / (max2 + min) : delta / (2 - max2 - min); + switch (max2) { + case r: + hue = (g - b) / delta + (g < b ? 6 : 0); + break; + case g: + hue = (b - r) / delta + 2; + break; + case b: + hue = (r - g) / delta + 4; + break; + } + hue /= 6; + } + target.h = hue; + target.s = saturation; + target.l = lightness; + return target; + } + getRGB(target, colorSpace = ColorManagement.workingColorSpace) { + ColorManagement.fromWorkingColorSpace(_color.copy(this), colorSpace); + target.r = _color.r; + target.g = _color.g; + target.b = _color.b; + return target; + } + getStyle(colorSpace = SRGBColorSpace) { + ColorManagement.fromWorkingColorSpace(_color.copy(this), colorSpace); + const r = _color.r, g = _color.g, b = _color.b; + if (colorSpace !== SRGBColorSpace) { + return `color(${colorSpace} ${r.toFixed(3)} ${g.toFixed(3)} ${b.toFixed(3)})`; + } + return `rgb(${Math.round(r * 255)},${Math.round(g * 255)},${Math.round(b * 255)})`; + } + offsetHSL(h, s, l) { + this.getHSL(_hslA); + return this.setHSL(_hslA.h + h, _hslA.s + s, _hslA.l + l); + } + add(color) { + this.r += color.r; + this.g += color.g; + this.b += color.b; + return this; + } + addColors(color1, color2) { + this.r = color1.r + color2.r; + this.g = color1.g + color2.g; + this.b = color1.b + color2.b; + return this; + } + addScalar(s) { + this.r += s; + this.g += s; + this.b += s; + return this; + } + sub(color) { + this.r = Math.max(0, this.r - color.r); + this.g = Math.max(0, this.g - color.g); + this.b = Math.max(0, this.b - color.b); + return this; + } + multiply(color) { + this.r *= color.r; + this.g *= color.g; + this.b *= color.b; + return this; + } + multiplyScalar(s) { + this.r *= s; + this.g *= s; + this.b *= s; + return this; + } + lerp(color, alpha) { + this.r += (color.r - this.r) * alpha; + this.g += (color.g - this.g) * alpha; + this.b += (color.b - this.b) * alpha; + return this; + } + lerpColors(color1, color2, alpha) { + this.r = color1.r + (color2.r - color1.r) * alpha; + this.g = color1.g + (color2.g - color1.g) * alpha; + this.b = color1.b + (color2.b - color1.b) * alpha; + return this; + } + lerpHSL(color, alpha) { + this.getHSL(_hslA); + color.getHSL(_hslB); + const h = lerp(_hslA.h, _hslB.h, alpha); + const s = lerp(_hslA.s, _hslB.s, alpha); + const l = lerp(_hslA.l, _hslB.l, alpha); + this.setHSL(h, s, l); + return this; + } + setFromVector3(v) { + this.r = v.x; + this.g = v.y; + this.b = v.z; + return this; + } + applyMatrix3(m) { + const r = this.r, g = this.g, b = this.b; + const e = m.elements; + this.r = e[0] * r + e[3] * g + e[6] * b; + this.g = e[1] * r + e[4] * g + e[7] * b; + this.b = e[2] * r + e[5] * g + e[8] * b; + return this; + } + equals(c) { + return c.r === this.r && c.g === this.g && c.b === this.b; + } + fromArray(array, offset = 0) { + this.r = array[offset]; + this.g = array[offset + 1]; + this.b = array[offset + 2]; + return this; + } + toArray(array = [], offset = 0) { + array[offset] = this.r; + array[offset + 1] = this.g; + array[offset + 2] = this.b; + return array; + } + fromBufferAttribute(attribute, index) { + this.r = attribute.getX(index); + this.g = attribute.getY(index); + this.b = attribute.getZ(index); + return this; + } + toJSON() { + return this.getHex(); + } + *[Symbol.iterator]() { + yield this.r; + yield this.g; + yield this.b; + } +}; +var _color = /* @__PURE__ */ new Color(); +Color.NAMES = _colorKeywords; +var _materialId = 0; +var Material = class extends EventDispatcher { + constructor() { + super(); + this.isMaterial = true; + Object.defineProperty(this, "id", { value: _materialId++ }); + this.uuid = generateUUID(); + this.name = ""; + this.type = "Material"; + this.blending = NormalBlending; + this.side = FrontSide; + this.vertexColors = false; + this.opacity = 1; + this.transparent = false; + this.alphaHash = false; + this.blendSrc = SrcAlphaFactor; + this.blendDst = OneMinusSrcAlphaFactor; + this.blendEquation = AddEquation; + this.blendSrcAlpha = null; + this.blendDstAlpha = null; + this.blendEquationAlpha = null; + this.blendColor = new Color(0, 0, 0); + this.blendAlpha = 0; + this.depthFunc = LessEqualDepth; + this.depthTest = true; + this.depthWrite = true; + this.stencilWriteMask = 255; + this.stencilFunc = AlwaysStencilFunc; + this.stencilRef = 0; + this.stencilFuncMask = 255; + this.stencilFail = KeepStencilOp; + this.stencilZFail = KeepStencilOp; + this.stencilZPass = KeepStencilOp; + this.stencilWrite = false; + this.clippingPlanes = null; + this.clipIntersection = false; + this.clipShadows = false; + this.shadowSide = null; + this.colorWrite = true; + this.precision = null; + this.polygonOffset = false; + this.polygonOffsetFactor = 0; + this.polygonOffsetUnits = 0; + this.dithering = false; + this.alphaToCoverage = false; + this.premultipliedAlpha = false; + this.forceSinglePass = false; + this.visible = true; + this.toneMapped = true; + this.userData = {}; + this.version = 0; + this._alphaTest = 0; + } + get alphaTest() { + return this._alphaTest; + } + set alphaTest(value) { + if (this._alphaTest > 0 !== value > 0) { + this.version++; + } + this._alphaTest = value; + } + onBuild() { + } + onBeforeRender() { + } + onBeforeCompile() { + } + customProgramCacheKey() { + return this.onBeforeCompile.toString(); + } + setValues(values) { + if (values === void 0) return; + for (const key in values) { + const newValue = values[key]; + if (newValue === void 0) { + console.warn(`THREE.Material: parameter '${key}' has value of undefined.`); + continue; + } + const currentValue = this[key]; + if (currentValue === void 0) { + console.warn(`THREE.Material: '${key}' is not a property of THREE.${this.type}.`); + continue; + } + if (currentValue && currentValue.isColor) { + currentValue.set(newValue); + } else if (currentValue && currentValue.isVector3 && (newValue && newValue.isVector3)) { + currentValue.copy(newValue); + } else { + this[key] = newValue; + } + } + } + toJSON(meta) { + const isRootObject = meta === void 0 || typeof meta === "string"; + if (isRootObject) { + meta = { + textures: {}, + images: {} + }; + } + const data = { + metadata: { + version: 4.6, + type: "Material", + generator: "Material.toJSON" + } + }; + data.uuid = this.uuid; + data.type = this.type; + if (this.name !== "") data.name = this.name; + if (this.color && this.color.isColor) data.color = this.color.getHex(); + if (this.roughness !== void 0) data.roughness = this.roughness; + if (this.metalness !== void 0) data.metalness = this.metalness; + if (this.sheen !== void 0) data.sheen = this.sheen; + if (this.sheenColor && this.sheenColor.isColor) data.sheenColor = this.sheenColor.getHex(); + if (this.sheenRoughness !== void 0) data.sheenRoughness = this.sheenRoughness; + if (this.emissive && this.emissive.isColor) data.emissive = this.emissive.getHex(); + if (this.emissiveIntensity !== void 0 && this.emissiveIntensity !== 1) data.emissiveIntensity = this.emissiveIntensity; + if (this.specular && this.specular.isColor) data.specular = this.specular.getHex(); + if (this.specularIntensity !== void 0) data.specularIntensity = this.specularIntensity; + if (this.specularColor && this.specularColor.isColor) data.specularColor = this.specularColor.getHex(); + if (this.shininess !== void 0) data.shininess = this.shininess; + if (this.clearcoat !== void 0) data.clearcoat = this.clearcoat; + if (this.clearcoatRoughness !== void 0) data.clearcoatRoughness = this.clearcoatRoughness; + if (this.clearcoatMap && this.clearcoatMap.isTexture) { + data.clearcoatMap = this.clearcoatMap.toJSON(meta).uuid; + } + if (this.clearcoatRoughnessMap && this.clearcoatRoughnessMap.isTexture) { + data.clearcoatRoughnessMap = this.clearcoatRoughnessMap.toJSON(meta).uuid; + } + if (this.clearcoatNormalMap && this.clearcoatNormalMap.isTexture) { + data.clearcoatNormalMap = this.clearcoatNormalMap.toJSON(meta).uuid; + data.clearcoatNormalScale = this.clearcoatNormalScale.toArray(); + } + if (this.iridescence !== void 0) data.iridescence = this.iridescence; + if (this.iridescenceIOR !== void 0) data.iridescenceIOR = this.iridescenceIOR; + if (this.iridescenceThicknessRange !== void 0) data.iridescenceThicknessRange = this.iridescenceThicknessRange; + if (this.iridescenceMap && this.iridescenceMap.isTexture) { + data.iridescenceMap = this.iridescenceMap.toJSON(meta).uuid; + } + if (this.iridescenceThicknessMap && this.iridescenceThicknessMap.isTexture) { + data.iridescenceThicknessMap = this.iridescenceThicknessMap.toJSON(meta).uuid; + } + if (this.anisotropy !== void 0) data.anisotropy = this.anisotropy; + if (this.anisotropyRotation !== void 0) data.anisotropyRotation = this.anisotropyRotation; + if (this.anisotropyMap && this.anisotropyMap.isTexture) { + data.anisotropyMap = this.anisotropyMap.toJSON(meta).uuid; + } + if (this.map && this.map.isTexture) data.map = this.map.toJSON(meta).uuid; + if (this.matcap && this.matcap.isTexture) data.matcap = this.matcap.toJSON(meta).uuid; + if (this.alphaMap && this.alphaMap.isTexture) data.alphaMap = this.alphaMap.toJSON(meta).uuid; + if (this.lightMap && this.lightMap.isTexture) { + data.lightMap = this.lightMap.toJSON(meta).uuid; + data.lightMapIntensity = this.lightMapIntensity; + } + if (this.aoMap && this.aoMap.isTexture) { + data.aoMap = this.aoMap.toJSON(meta).uuid; + data.aoMapIntensity = this.aoMapIntensity; + } + if (this.bumpMap && this.bumpMap.isTexture) { + data.bumpMap = this.bumpMap.toJSON(meta).uuid; + data.bumpScale = this.bumpScale; + } + if (this.normalMap && this.normalMap.isTexture) { + data.normalMap = this.normalMap.toJSON(meta).uuid; + data.normalMapType = this.normalMapType; + data.normalScale = this.normalScale.toArray(); + } + if (this.displacementMap && this.displacementMap.isTexture) { + data.displacementMap = this.displacementMap.toJSON(meta).uuid; + data.displacementScale = this.displacementScale; + data.displacementBias = this.displacementBias; + } + if (this.roughnessMap && this.roughnessMap.isTexture) data.roughnessMap = this.roughnessMap.toJSON(meta).uuid; + if (this.metalnessMap && this.metalnessMap.isTexture) data.metalnessMap = this.metalnessMap.toJSON(meta).uuid; + if (this.emissiveMap && this.emissiveMap.isTexture) data.emissiveMap = this.emissiveMap.toJSON(meta).uuid; + if (this.specularMap && this.specularMap.isTexture) data.specularMap = this.specularMap.toJSON(meta).uuid; + if (this.specularIntensityMap && this.specularIntensityMap.isTexture) data.specularIntensityMap = this.specularIntensityMap.toJSON(meta).uuid; + if (this.specularColorMap && this.specularColorMap.isTexture) data.specularColorMap = this.specularColorMap.toJSON(meta).uuid; + if (this.envMap && this.envMap.isTexture) { + data.envMap = this.envMap.toJSON(meta).uuid; + if (this.combine !== void 0) data.combine = this.combine; + } + if (this.envMapRotation !== void 0) data.envMapRotation = this.envMapRotation.toArray(); + if (this.envMapIntensity !== void 0) data.envMapIntensity = this.envMapIntensity; + if (this.reflectivity !== void 0) data.reflectivity = this.reflectivity; + if (this.refractionRatio !== void 0) data.refractionRatio = this.refractionRatio; + if (this.gradientMap && this.gradientMap.isTexture) { + data.gradientMap = this.gradientMap.toJSON(meta).uuid; + } + if (this.transmission !== void 0) data.transmission = this.transmission; + if (this.transmissionMap && this.transmissionMap.isTexture) data.transmissionMap = this.transmissionMap.toJSON(meta).uuid; + if (this.thickness !== void 0) data.thickness = this.thickness; + if (this.thicknessMap && this.thicknessMap.isTexture) data.thicknessMap = this.thicknessMap.toJSON(meta).uuid; + if (this.attenuationDistance !== void 0 && this.attenuationDistance !== Infinity) data.attenuationDistance = this.attenuationDistance; + if (this.attenuationColor !== void 0) data.attenuationColor = this.attenuationColor.getHex(); + if (this.size !== void 0) data.size = this.size; + if (this.shadowSide !== null) data.shadowSide = this.shadowSide; + if (this.sizeAttenuation !== void 0) data.sizeAttenuation = this.sizeAttenuation; + if (this.blending !== NormalBlending) data.blending = this.blending; + if (this.side !== FrontSide) data.side = this.side; + if (this.vertexColors === true) data.vertexColors = true; + if (this.opacity < 1) data.opacity = this.opacity; + if (this.transparent === true) data.transparent = true; + if (this.blendSrc !== SrcAlphaFactor) data.blendSrc = this.blendSrc; + if (this.blendDst !== OneMinusSrcAlphaFactor) data.blendDst = this.blendDst; + if (this.blendEquation !== AddEquation) data.blendEquation = this.blendEquation; + if (this.blendSrcAlpha !== null) data.blendSrcAlpha = this.blendSrcAlpha; + if (this.blendDstAlpha !== null) data.blendDstAlpha = this.blendDstAlpha; + if (this.blendEquationAlpha !== null) data.blendEquationAlpha = this.blendEquationAlpha; + if (this.blendColor && this.blendColor.isColor) data.blendColor = this.blendColor.getHex(); + if (this.blendAlpha !== 0) data.blendAlpha = this.blendAlpha; + if (this.depthFunc !== LessEqualDepth) data.depthFunc = this.depthFunc; + if (this.depthTest === false) data.depthTest = this.depthTest; + if (this.depthWrite === false) data.depthWrite = this.depthWrite; + if (this.colorWrite === false) data.colorWrite = this.colorWrite; + if (this.stencilWriteMask !== 255) data.stencilWriteMask = this.stencilWriteMask; + if (this.stencilFunc !== AlwaysStencilFunc) data.stencilFunc = this.stencilFunc; + if (this.stencilRef !== 0) data.stencilRef = this.stencilRef; + if (this.stencilFuncMask !== 255) data.stencilFuncMask = this.stencilFuncMask; + if (this.stencilFail !== KeepStencilOp) data.stencilFail = this.stencilFail; + if (this.stencilZFail !== KeepStencilOp) data.stencilZFail = this.stencilZFail; + if (this.stencilZPass !== KeepStencilOp) data.stencilZPass = this.stencilZPass; + if (this.stencilWrite === true) data.stencilWrite = this.stencilWrite; + if (this.rotation !== void 0 && this.rotation !== 0) data.rotation = this.rotation; + if (this.polygonOffset === true) data.polygonOffset = true; + if (this.polygonOffsetFactor !== 0) data.polygonOffsetFactor = this.polygonOffsetFactor; + if (this.polygonOffsetUnits !== 0) data.polygonOffsetUnits = this.polygonOffsetUnits; + if (this.linewidth !== void 0 && this.linewidth !== 1) data.linewidth = this.linewidth; + if (this.dashSize !== void 0) data.dashSize = this.dashSize; + if (this.gapSize !== void 0) data.gapSize = this.gapSize; + if (this.scale !== void 0) data.scale = this.scale; + if (this.dithering === true) data.dithering = true; + if (this.alphaTest > 0) data.alphaTest = this.alphaTest; + if (this.alphaHash === true) data.alphaHash = true; + if (this.alphaToCoverage === true) data.alphaToCoverage = true; + if (this.premultipliedAlpha === true) data.premultipliedAlpha = true; + if (this.forceSinglePass === true) data.forceSinglePass = true; + if (this.wireframe === true) data.wireframe = true; + if (this.wireframeLinewidth > 1) data.wireframeLinewidth = this.wireframeLinewidth; + if (this.wireframeLinecap !== "round") data.wireframeLinecap = this.wireframeLinecap; + if (this.wireframeLinejoin !== "round") data.wireframeLinejoin = this.wireframeLinejoin; + if (this.flatShading === true) data.flatShading = true; + if (this.visible === false) data.visible = false; + if (this.toneMapped === false) data.toneMapped = false; + if (this.fog === false) data.fog = false; + if (Object.keys(this.userData).length > 0) data.userData = this.userData; + function extractFromCache(cache) { + const values = []; + for (const key in cache) { + const data2 = cache[key]; + delete data2.metadata; + values.push(data2); + } + return values; + } + if (isRootObject) { + const textures = extractFromCache(meta.textures); + const images = extractFromCache(meta.images); + if (textures.length > 0) data.textures = textures; + if (images.length > 0) data.images = images; + } + return data; + } + clone() { + return new this.constructor().copy(this); + } + copy(source) { + this.name = source.name; + this.blending = source.blending; + this.side = source.side; + this.vertexColors = source.vertexColors; + this.opacity = source.opacity; + this.transparent = source.transparent; + this.blendSrc = source.blendSrc; + this.blendDst = source.blendDst; + this.blendEquation = source.blendEquation; + this.blendSrcAlpha = source.blendSrcAlpha; + this.blendDstAlpha = source.blendDstAlpha; + this.blendEquationAlpha = source.blendEquationAlpha; + this.blendColor.copy(source.blendColor); + this.blendAlpha = source.blendAlpha; + this.depthFunc = source.depthFunc; + this.depthTest = source.depthTest; + this.depthWrite = source.depthWrite; + this.stencilWriteMask = source.stencilWriteMask; + this.stencilFunc = source.stencilFunc; + this.stencilRef = source.stencilRef; + this.stencilFuncMask = source.stencilFuncMask; + this.stencilFail = source.stencilFail; + this.stencilZFail = source.stencilZFail; + this.stencilZPass = source.stencilZPass; + this.stencilWrite = source.stencilWrite; + const srcPlanes = source.clippingPlanes; + let dstPlanes = null; + if (srcPlanes !== null) { + const n = srcPlanes.length; + dstPlanes = new Array(n); + for (let i = 0; i !== n; ++i) { + dstPlanes[i] = srcPlanes[i].clone(); + } + } + this.clippingPlanes = dstPlanes; + this.clipIntersection = source.clipIntersection; + this.clipShadows = source.clipShadows; + this.shadowSide = source.shadowSide; + this.colorWrite = source.colorWrite; + this.precision = source.precision; + this.polygonOffset = source.polygonOffset; + this.polygonOffsetFactor = source.polygonOffsetFactor; + this.polygonOffsetUnits = source.polygonOffsetUnits; + this.dithering = source.dithering; + this.alphaTest = source.alphaTest; + this.alphaHash = source.alphaHash; + this.alphaToCoverage = source.alphaToCoverage; + this.premultipliedAlpha = source.premultipliedAlpha; + this.forceSinglePass = source.forceSinglePass; + this.visible = source.visible; + this.toneMapped = source.toneMapped; + this.userData = JSON.parse(JSON.stringify(source.userData)); + return this; + } + dispose() { + this.dispatchEvent({ type: "dispose" }); + } + set needsUpdate(value) { + if (value === true) this.version++; + } +}; +var MeshBasicMaterial = class extends Material { + constructor(parameters) { + super(); + this.isMeshBasicMaterial = true; + this.type = "MeshBasicMaterial"; + this.color = new Color(16777215); + this.map = null; + this.lightMap = null; + this.lightMapIntensity = 1; + this.aoMap = null; + this.aoMapIntensity = 1; + this.specularMap = null; + this.alphaMap = null; + this.envMap = null; + this.envMapRotation = new Euler(); + this.combine = MultiplyOperation; + this.reflectivity = 1; + this.refractionRatio = 0.98; + this.wireframe = false; + this.wireframeLinewidth = 1; + this.wireframeLinecap = "round"; + this.wireframeLinejoin = "round"; + this.fog = true; + this.setValues(parameters); + } + copy(source) { + super.copy(source); + this.color.copy(source.color); + this.map = source.map; + this.lightMap = source.lightMap; + this.lightMapIntensity = source.lightMapIntensity; + this.aoMap = source.aoMap; + this.aoMapIntensity = source.aoMapIntensity; + this.specularMap = source.specularMap; + this.alphaMap = source.alphaMap; + this.envMap = source.envMap; + this.envMapRotation.copy(source.envMapRotation); + this.combine = source.combine; + this.reflectivity = source.reflectivity; + this.refractionRatio = source.refractionRatio; + this.wireframe = source.wireframe; + this.wireframeLinewidth = source.wireframeLinewidth; + this.wireframeLinecap = source.wireframeLinecap; + this.wireframeLinejoin = source.wireframeLinejoin; + this.fog = source.fog; + return this; + } +}; +var _vector$9 = /* @__PURE__ */ new Vector3(); +var _vector2$1 = /* @__PURE__ */ new Vector2(); +var BufferAttribute = class { + constructor(array, itemSize, normalized = false) { + if (Array.isArray(array)) { + throw new TypeError("THREE.BufferAttribute: array should be a Typed Array."); + } + this.isBufferAttribute = true; + this.name = ""; + this.array = array; + this.itemSize = itemSize; + this.count = array !== void 0 ? array.length / itemSize : 0; + this.normalized = normalized; + this.usage = StaticDrawUsage; + this._updateRange = { offset: 0, count: -1 }; + this.updateRanges = []; + this.gpuType = FloatType; + this.version = 0; + } + onUploadCallback() { + } + set needsUpdate(value) { + if (value === true) this.version++; + } + get updateRange() { + warnOnce("THREE.BufferAttribute: updateRange() is deprecated and will be removed in r169. Use addUpdateRange() instead."); + return this._updateRange; + } + setUsage(value) { + this.usage = value; + return this; + } + addUpdateRange(start, count) { + this.updateRanges.push({ start, count }); + } + clearUpdateRanges() { + this.updateRanges.length = 0; + } + copy(source) { + this.name = source.name; + this.array = new source.array.constructor(source.array); + this.itemSize = source.itemSize; + this.count = source.count; + this.normalized = source.normalized; + this.usage = source.usage; + this.gpuType = source.gpuType; + return this; + } + copyAt(index1, attribute, index2) { + index1 *= this.itemSize; + index2 *= attribute.itemSize; + for (let i = 0, l = this.itemSize; i < l; i++) { + this.array[index1 + i] = attribute.array[index2 + i]; + } + return this; + } + copyArray(array) { + this.array.set(array); + return this; + } + applyMatrix3(m) { + if (this.itemSize === 2) { + for (let i = 0, l = this.count; i < l; i++) { + _vector2$1.fromBufferAttribute(this, i); + _vector2$1.applyMatrix3(m); + this.setXY(i, _vector2$1.x, _vector2$1.y); + } + } else if (this.itemSize === 3) { + for (let i = 0, l = this.count; i < l; i++) { + _vector$9.fromBufferAttribute(this, i); + _vector$9.applyMatrix3(m); + this.setXYZ(i, _vector$9.x, _vector$9.y, _vector$9.z); + } + } + return this; + } + applyMatrix4(m) { + for (let i = 0, l = this.count; i < l; i++) { + _vector$9.fromBufferAttribute(this, i); + _vector$9.applyMatrix4(m); + this.setXYZ(i, _vector$9.x, _vector$9.y, _vector$9.z); + } + return this; + } + applyNormalMatrix(m) { + for (let i = 0, l = this.count; i < l; i++) { + _vector$9.fromBufferAttribute(this, i); + _vector$9.applyNormalMatrix(m); + this.setXYZ(i, _vector$9.x, _vector$9.y, _vector$9.z); + } + return this; + } + transformDirection(m) { + for (let i = 0, l = this.count; i < l; i++) { + _vector$9.fromBufferAttribute(this, i); + _vector$9.transformDirection(m); + this.setXYZ(i, _vector$9.x, _vector$9.y, _vector$9.z); + } + return this; + } + set(value, offset = 0) { + this.array.set(value, offset); + return this; + } + getComponent(index, component) { + let value = this.array[index * this.itemSize + component]; + if (this.normalized) value = denormalize(value, this.array); + return value; + } + setComponent(index, component, value) { + if (this.normalized) value = normalize(value, this.array); + this.array[index * this.itemSize + component] = value; + return this; + } + getX(index) { + let x = this.array[index * this.itemSize]; + if (this.normalized) x = denormalize(x, this.array); + return x; + } + setX(index, x) { + if (this.normalized) x = normalize(x, this.array); + this.array[index * this.itemSize] = x; + return this; + } + getY(index) { + let y = this.array[index * this.itemSize + 1]; + if (this.normalized) y = denormalize(y, this.array); + return y; + } + setY(index, y) { + if (this.normalized) y = normalize(y, this.array); + this.array[index * this.itemSize + 1] = y; + return this; + } + getZ(index) { + let z = this.array[index * this.itemSize + 2]; + if (this.normalized) z = denormalize(z, this.array); + return z; + } + setZ(index, z) { + if (this.normalized) z = normalize(z, this.array); + this.array[index * this.itemSize + 2] = z; + return this; + } + getW(index) { + let w = this.array[index * this.itemSize + 3]; + if (this.normalized) w = denormalize(w, this.array); + return w; + } + setW(index, w) { + if (this.normalized) w = normalize(w, this.array); + this.array[index * this.itemSize + 3] = w; + return this; + } + setXY(index, x, y) { + index *= this.itemSize; + if (this.normalized) { + x = normalize(x, this.array); + y = normalize(y, this.array); + } + this.array[index + 0] = x; + this.array[index + 1] = y; + return this; + } + setXYZ(index, x, y, z) { + index *= this.itemSize; + if (this.normalized) { + x = normalize(x, this.array); + y = normalize(y, this.array); + z = normalize(z, this.array); + } + this.array[index + 0] = x; + this.array[index + 1] = y; + this.array[index + 2] = z; + return this; + } + setXYZW(index, x, y, z, w) { + index *= this.itemSize; + if (this.normalized) { + x = normalize(x, this.array); + y = normalize(y, this.array); + z = normalize(z, this.array); + w = normalize(w, this.array); + } + this.array[index + 0] = x; + this.array[index + 1] = y; + this.array[index + 2] = z; + this.array[index + 3] = w; + return this; + } + onUpload(callback) { + this.onUploadCallback = callback; + return this; + } + clone() { + return new this.constructor(this.array, this.itemSize).copy(this); + } + toJSON() { + const data = { + itemSize: this.itemSize, + type: this.array.constructor.name, + array: Array.from(this.array), + normalized: this.normalized + }; + if (this.name !== "") data.name = this.name; + if (this.usage !== StaticDrawUsage) data.usage = this.usage; + return data; + } +}; +var Uint16BufferAttribute = class extends BufferAttribute { + constructor(array, itemSize, normalized) { + super(new Uint16Array(array), itemSize, normalized); + } +}; +var Uint32BufferAttribute = class extends BufferAttribute { + constructor(array, itemSize, normalized) { + super(new Uint32Array(array), itemSize, normalized); + } +}; +var Float32BufferAttribute = class extends BufferAttribute { + constructor(array, itemSize, normalized) { + super(new Float32Array(array), itemSize, normalized); + } +}; +var _id$2 = 0; +var _m1$2 = /* @__PURE__ */ new Matrix4(); +var _obj = /* @__PURE__ */ new Object3D(); +var _offset = /* @__PURE__ */ new Vector3(); +var _box$2 = /* @__PURE__ */ new Box3(); +var _boxMorphTargets = /* @__PURE__ */ new Box3(); +var _vector$8 = /* @__PURE__ */ new Vector3(); +var BufferGeometry = class _BufferGeometry extends EventDispatcher { + constructor() { + super(); + this.isBufferGeometry = true; + Object.defineProperty(this, "id", { value: _id$2++ }); + this.uuid = generateUUID(); + this.name = ""; + this.type = "BufferGeometry"; + this.index = null; + this.attributes = {}; + this.morphAttributes = {}; + this.morphTargetsRelative = false; + this.groups = []; + this.boundingBox = null; + this.boundingSphere = null; + this.drawRange = { start: 0, count: Infinity }; + this.userData = {}; + } + getIndex() { + return this.index; + } + setIndex(index) { + if (Array.isArray(index)) { + this.index = new (arrayNeedsUint32(index) ? Uint32BufferAttribute : Uint16BufferAttribute)(index, 1); + } else { + this.index = index; + } + return this; + } + getAttribute(name) { + return this.attributes[name]; + } + setAttribute(name, attribute) { + this.attributes[name] = attribute; + return this; + } + deleteAttribute(name) { + delete this.attributes[name]; + return this; + } + hasAttribute(name) { + return this.attributes[name] !== void 0; + } + addGroup(start, count, materialIndex = 0) { + this.groups.push({ + start, + count, + materialIndex + }); + } + clearGroups() { + this.groups = []; + } + setDrawRange(start, count) { + this.drawRange.start = start; + this.drawRange.count = count; + } + applyMatrix4(matrix) { + const position = this.attributes.position; + if (position !== void 0) { + position.applyMatrix4(matrix); + position.needsUpdate = true; + } + const normal = this.attributes.normal; + if (normal !== void 0) { + const normalMatrix = new Matrix3().getNormalMatrix(matrix); + normal.applyNormalMatrix(normalMatrix); + normal.needsUpdate = true; + } + const tangent = this.attributes.tangent; + if (tangent !== void 0) { + tangent.transformDirection(matrix); + tangent.needsUpdate = true; + } + if (this.boundingBox !== null) { + this.computeBoundingBox(); + } + if (this.boundingSphere !== null) { + this.computeBoundingSphere(); + } + return this; + } + applyQuaternion(q) { + _m1$2.makeRotationFromQuaternion(q); + this.applyMatrix4(_m1$2); + return this; + } + rotateX(angle) { + _m1$2.makeRotationX(angle); + this.applyMatrix4(_m1$2); + return this; + } + rotateY(angle) { + _m1$2.makeRotationY(angle); + this.applyMatrix4(_m1$2); + return this; + } + rotateZ(angle) { + _m1$2.makeRotationZ(angle); + this.applyMatrix4(_m1$2); + return this; + } + translate(x, y, z) { + _m1$2.makeTranslation(x, y, z); + this.applyMatrix4(_m1$2); + return this; + } + scale(x, y, z) { + _m1$2.makeScale(x, y, z); + this.applyMatrix4(_m1$2); + return this; + } + lookAt(vector) { + _obj.lookAt(vector); + _obj.updateMatrix(); + this.applyMatrix4(_obj.matrix); + return this; + } + center() { + this.computeBoundingBox(); + this.boundingBox.getCenter(_offset).negate(); + this.translate(_offset.x, _offset.y, _offset.z); + return this; + } + setFromPoints(points) { + const position = []; + for (let i = 0, l = points.length; i < l; i++) { + const point = points[i]; + position.push(point.x, point.y, point.z || 0); + } + this.setAttribute("position", new Float32BufferAttribute(position, 3)); + return this; + } + computeBoundingBox() { + if (this.boundingBox === null) { + this.boundingBox = new Box3(); + } + const position = this.attributes.position; + const morphAttributesPosition = this.morphAttributes.position; + if (position && position.isGLBufferAttribute) { + console.error("THREE.BufferGeometry.computeBoundingBox(): GLBufferAttribute requires a manual bounding box.", this); + this.boundingBox.set( + new Vector3(-Infinity, -Infinity, -Infinity), + new Vector3(Infinity, Infinity, Infinity) + ); + return; + } + if (position !== void 0) { + this.boundingBox.setFromBufferAttribute(position); + if (morphAttributesPosition) { + for (let i = 0, il = morphAttributesPosition.length; i < il; i++) { + const morphAttribute = morphAttributesPosition[i]; + _box$2.setFromBufferAttribute(morphAttribute); + if (this.morphTargetsRelative) { + _vector$8.addVectors(this.boundingBox.min, _box$2.min); + this.boundingBox.expandByPoint(_vector$8); + _vector$8.addVectors(this.boundingBox.max, _box$2.max); + this.boundingBox.expandByPoint(_vector$8); + } else { + this.boundingBox.expandByPoint(_box$2.min); + this.boundingBox.expandByPoint(_box$2.max); + } + } + } + } else { + this.boundingBox.makeEmpty(); + } + if (isNaN(this.boundingBox.min.x) || isNaN(this.boundingBox.min.y) || isNaN(this.boundingBox.min.z)) { + console.error('THREE.BufferGeometry.computeBoundingBox(): Computed min/max have NaN values. The "position" attribute is likely to have NaN values.', this); + } + } + computeBoundingSphere() { + if (this.boundingSphere === null) { + this.boundingSphere = new Sphere(); + } + const position = this.attributes.position; + const morphAttributesPosition = this.morphAttributes.position; + if (position && position.isGLBufferAttribute) { + console.error("THREE.BufferGeometry.computeBoundingSphere(): GLBufferAttribute requires a manual bounding sphere.", this); + this.boundingSphere.set(new Vector3(), Infinity); + return; + } + if (position) { + const center = this.boundingSphere.center; + _box$2.setFromBufferAttribute(position); + if (morphAttributesPosition) { + for (let i = 0, il = morphAttributesPosition.length; i < il; i++) { + const morphAttribute = morphAttributesPosition[i]; + _boxMorphTargets.setFromBufferAttribute(morphAttribute); + if (this.morphTargetsRelative) { + _vector$8.addVectors(_box$2.min, _boxMorphTargets.min); + _box$2.expandByPoint(_vector$8); + _vector$8.addVectors(_box$2.max, _boxMorphTargets.max); + _box$2.expandByPoint(_vector$8); + } else { + _box$2.expandByPoint(_boxMorphTargets.min); + _box$2.expandByPoint(_boxMorphTargets.max); + } + } + } + _box$2.getCenter(center); + let maxRadiusSq = 0; + for (let i = 0, il = position.count; i < il; i++) { + _vector$8.fromBufferAttribute(position, i); + maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared(_vector$8)); + } + if (morphAttributesPosition) { + for (let i = 0, il = morphAttributesPosition.length; i < il; i++) { + const morphAttribute = morphAttributesPosition[i]; + const morphTargetsRelative = this.morphTargetsRelative; + for (let j = 0, jl = morphAttribute.count; j < jl; j++) { + _vector$8.fromBufferAttribute(morphAttribute, j); + if (morphTargetsRelative) { + _offset.fromBufferAttribute(position, j); + _vector$8.add(_offset); + } + maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared(_vector$8)); + } + } + } + this.boundingSphere.radius = Math.sqrt(maxRadiusSq); + if (isNaN(this.boundingSphere.radius)) { + console.error('THREE.BufferGeometry.computeBoundingSphere(): Computed radius is NaN. The "position" attribute is likely to have NaN values.', this); + } + } + } + computeTangents() { + const index = this.index; + const attributes = this.attributes; + if (index === null || attributes.position === void 0 || attributes.normal === void 0 || attributes.uv === void 0) { + console.error("THREE.BufferGeometry: .computeTangents() failed. Missing required attributes (index, position, normal or uv)"); + return; + } + const positionAttribute = attributes.position; + const normalAttribute = attributes.normal; + const uvAttribute = attributes.uv; + if (this.hasAttribute("tangent") === false) { + this.setAttribute("tangent", new BufferAttribute(new Float32Array(4 * positionAttribute.count), 4)); + } + const tangentAttribute = this.getAttribute("tangent"); + const tan1 = [], tan2 = []; + for (let i = 0; i < positionAttribute.count; i++) { + tan1[i] = new Vector3(); + tan2[i] = new Vector3(); + } + const vA = new Vector3(), vB = new Vector3(), vC = new Vector3(), uvA = new Vector2(), uvB = new Vector2(), uvC = new Vector2(), sdir = new Vector3(), tdir = new Vector3(); + function handleTriangle(a, b, c) { + vA.fromBufferAttribute(positionAttribute, a); + vB.fromBufferAttribute(positionAttribute, b); + vC.fromBufferAttribute(positionAttribute, c); + uvA.fromBufferAttribute(uvAttribute, a); + uvB.fromBufferAttribute(uvAttribute, b); + uvC.fromBufferAttribute(uvAttribute, c); + vB.sub(vA); + vC.sub(vA); + uvB.sub(uvA); + uvC.sub(uvA); + const r = 1 / (uvB.x * uvC.y - uvC.x * uvB.y); + if (!isFinite(r)) return; + sdir.copy(vB).multiplyScalar(uvC.y).addScaledVector(vC, -uvB.y).multiplyScalar(r); + tdir.copy(vC).multiplyScalar(uvB.x).addScaledVector(vB, -uvC.x).multiplyScalar(r); + tan1[a].add(sdir); + tan1[b].add(sdir); + tan1[c].add(sdir); + tan2[a].add(tdir); + tan2[b].add(tdir); + tan2[c].add(tdir); + } + let groups = this.groups; + if (groups.length === 0) { + groups = [{ + start: 0, + count: index.count + }]; + } + for (let i = 0, il = groups.length; i < il; ++i) { + const group = groups[i]; + const start = group.start; + const count = group.count; + for (let j = start, jl = start + count; j < jl; j += 3) { + handleTriangle( + index.getX(j + 0), + index.getX(j + 1), + index.getX(j + 2) + ); + } + } + const tmp = new Vector3(), tmp2 = new Vector3(); + const n = new Vector3(), n2 = new Vector3(); + function handleVertex(v) { + n.fromBufferAttribute(normalAttribute, v); + n2.copy(n); + const t = tan1[v]; + tmp.copy(t); + tmp.sub(n.multiplyScalar(n.dot(t))).normalize(); + tmp2.crossVectors(n2, t); + const test = tmp2.dot(tan2[v]); + const w = test < 0 ? -1 : 1; + tangentAttribute.setXYZW(v, tmp.x, tmp.y, tmp.z, w); + } + for (let i = 0, il = groups.length; i < il; ++i) { + const group = groups[i]; + const start = group.start; + const count = group.count; + for (let j = start, jl = start + count; j < jl; j += 3) { + handleVertex(index.getX(j + 0)); + handleVertex(index.getX(j + 1)); + handleVertex(index.getX(j + 2)); + } + } + } + computeVertexNormals() { + const index = this.index; + const positionAttribute = this.getAttribute("position"); + if (positionAttribute !== void 0) { + let normalAttribute = this.getAttribute("normal"); + if (normalAttribute === void 0) { + normalAttribute = new BufferAttribute(new Float32Array(positionAttribute.count * 3), 3); + this.setAttribute("normal", normalAttribute); + } else { + for (let i = 0, il = normalAttribute.count; i < il; i++) { + normalAttribute.setXYZ(i, 0, 0, 0); + } + } + const pA = new Vector3(), pB = new Vector3(), pC = new Vector3(); + const nA = new Vector3(), nB = new Vector3(), nC = new Vector3(); + const cb = new Vector3(), ab = new Vector3(); + if (index) { + for (let i = 0, il = index.count; i < il; i += 3) { + const vA = index.getX(i + 0); + const vB = index.getX(i + 1); + const vC = index.getX(i + 2); + pA.fromBufferAttribute(positionAttribute, vA); + pB.fromBufferAttribute(positionAttribute, vB); + pC.fromBufferAttribute(positionAttribute, vC); + cb.subVectors(pC, pB); + ab.subVectors(pA, pB); + cb.cross(ab); + nA.fromBufferAttribute(normalAttribute, vA); + nB.fromBufferAttribute(normalAttribute, vB); + nC.fromBufferAttribute(normalAttribute, vC); + nA.add(cb); + nB.add(cb); + nC.add(cb); + normalAttribute.setXYZ(vA, nA.x, nA.y, nA.z); + normalAttribute.setXYZ(vB, nB.x, nB.y, nB.z); + normalAttribute.setXYZ(vC, nC.x, nC.y, nC.z); + } + } else { + for (let i = 0, il = positionAttribute.count; i < il; i += 3) { + pA.fromBufferAttribute(positionAttribute, i + 0); + pB.fromBufferAttribute(positionAttribute, i + 1); + pC.fromBufferAttribute(positionAttribute, i + 2); + cb.subVectors(pC, pB); + ab.subVectors(pA, pB); + cb.cross(ab); + normalAttribute.setXYZ(i + 0, cb.x, cb.y, cb.z); + normalAttribute.setXYZ(i + 1, cb.x, cb.y, cb.z); + normalAttribute.setXYZ(i + 2, cb.x, cb.y, cb.z); + } + } + this.normalizeNormals(); + normalAttribute.needsUpdate = true; + } + } + normalizeNormals() { + const normals = this.attributes.normal; + for (let i = 0, il = normals.count; i < il; i++) { + _vector$8.fromBufferAttribute(normals, i); + _vector$8.normalize(); + normals.setXYZ(i, _vector$8.x, _vector$8.y, _vector$8.z); + } + } + toNonIndexed() { + function convertBufferAttribute(attribute, indices2) { + const array = attribute.array; + const itemSize = attribute.itemSize; + const normalized = attribute.normalized; + const array2 = new array.constructor(indices2.length * itemSize); + let index = 0, index2 = 0; + for (let i = 0, l = indices2.length; i < l; i++) { + if (attribute.isInterleavedBufferAttribute) { + index = indices2[i] * attribute.data.stride + attribute.offset; + } else { + index = indices2[i] * itemSize; + } + for (let j = 0; j < itemSize; j++) { + array2[index2++] = array[index++]; + } + } + return new BufferAttribute(array2, itemSize, normalized); + } + if (this.index === null) { + console.warn("THREE.BufferGeometry.toNonIndexed(): BufferGeometry is already non-indexed."); + return this; + } + const geometry2 = new _BufferGeometry(); + const indices = this.index.array; + const attributes = this.attributes; + for (const name in attributes) { + const attribute = attributes[name]; + const newAttribute = convertBufferAttribute(attribute, indices); + geometry2.setAttribute(name, newAttribute); + } + const morphAttributes = this.morphAttributes; + for (const name in morphAttributes) { + const morphArray = []; + const morphAttribute = morphAttributes[name]; + for (let i = 0, il = morphAttribute.length; i < il; i++) { + const attribute = morphAttribute[i]; + const newAttribute = convertBufferAttribute(attribute, indices); + morphArray.push(newAttribute); + } + geometry2.morphAttributes[name] = morphArray; + } + geometry2.morphTargetsRelative = this.morphTargetsRelative; + const groups = this.groups; + for (let i = 0, l = groups.length; i < l; i++) { + const group = groups[i]; + geometry2.addGroup(group.start, group.count, group.materialIndex); + } + return geometry2; + } + toJSON() { + const data = { + metadata: { + version: 4.6, + type: "BufferGeometry", + generator: "BufferGeometry.toJSON" + } + }; + data.uuid = this.uuid; + data.type = this.type; + if (this.name !== "") data.name = this.name; + if (Object.keys(this.userData).length > 0) data.userData = this.userData; + if (this.parameters !== void 0) { + const parameters = this.parameters; + for (const key in parameters) { + if (parameters[key] !== void 0) data[key] = parameters[key]; + } + return data; + } + data.data = { attributes: {} }; + const index = this.index; + if (index !== null) { + data.data.index = { + type: index.array.constructor.name, + array: Array.prototype.slice.call(index.array) + }; + } + const attributes = this.attributes; + for (const key in attributes) { + const attribute = attributes[key]; + data.data.attributes[key] = attribute.toJSON(data.data); + } + const morphAttributes = {}; + let hasMorphAttributes = false; + for (const key in this.morphAttributes) { + const attributeArray = this.morphAttributes[key]; + const array = []; + for (let i = 0, il = attributeArray.length; i < il; i++) { + const attribute = attributeArray[i]; + array.push(attribute.toJSON(data.data)); + } + if (array.length > 0) { + morphAttributes[key] = array; + hasMorphAttributes = true; + } + } + if (hasMorphAttributes) { + data.data.morphAttributes = morphAttributes; + data.data.morphTargetsRelative = this.morphTargetsRelative; + } + const groups = this.groups; + if (groups.length > 0) { + data.data.groups = JSON.parse(JSON.stringify(groups)); + } + const boundingSphere = this.boundingSphere; + if (boundingSphere !== null) { + data.data.boundingSphere = { + center: boundingSphere.center.toArray(), + radius: boundingSphere.radius + }; + } + return data; + } + clone() { + return new this.constructor().copy(this); + } + copy(source) { + this.index = null; + this.attributes = {}; + this.morphAttributes = {}; + this.groups = []; + this.boundingBox = null; + this.boundingSphere = null; + const data = {}; + this.name = source.name; + const index = source.index; + if (index !== null) { + this.setIndex(index.clone(data)); + } + const attributes = source.attributes; + for (const name in attributes) { + const attribute = attributes[name]; + this.setAttribute(name, attribute.clone(data)); + } + const morphAttributes = source.morphAttributes; + for (const name in morphAttributes) { + const array = []; + const morphAttribute = morphAttributes[name]; + for (let i = 0, l = morphAttribute.length; i < l; i++) { + array.push(morphAttribute[i].clone(data)); + } + this.morphAttributes[name] = array; + } + this.morphTargetsRelative = source.morphTargetsRelative; + const groups = source.groups; + for (let i = 0, l = groups.length; i < l; i++) { + const group = groups[i]; + this.addGroup(group.start, group.count, group.materialIndex); + } + const boundingBox = source.boundingBox; + if (boundingBox !== null) { + this.boundingBox = boundingBox.clone(); + } + const boundingSphere = source.boundingSphere; + if (boundingSphere !== null) { + this.boundingSphere = boundingSphere.clone(); + } + this.drawRange.start = source.drawRange.start; + this.drawRange.count = source.drawRange.count; + this.userData = source.userData; + return this; + } + dispose() { + this.dispatchEvent({ type: "dispose" }); + } +}; +var _inverseMatrix$3 = /* @__PURE__ */ new Matrix4(); +var _ray$3 = /* @__PURE__ */ new Ray(); +var _sphere$6 = /* @__PURE__ */ new Sphere(); +var _sphereHitAt = /* @__PURE__ */ new Vector3(); +var _vA$1 = /* @__PURE__ */ new Vector3(); +var _vB$1 = /* @__PURE__ */ new Vector3(); +var _vC$1 = /* @__PURE__ */ new Vector3(); +var _tempA = /* @__PURE__ */ new Vector3(); +var _morphA = /* @__PURE__ */ new Vector3(); +var _uvA$1 = /* @__PURE__ */ new Vector2(); +var _uvB$1 = /* @__PURE__ */ new Vector2(); +var _uvC$1 = /* @__PURE__ */ new Vector2(); +var _normalA = /* @__PURE__ */ new Vector3(); +var _normalB = /* @__PURE__ */ new Vector3(); +var _normalC = /* @__PURE__ */ new Vector3(); +var _intersectionPoint = /* @__PURE__ */ new Vector3(); +var _intersectionPointWorld = /* @__PURE__ */ new Vector3(); +var Mesh = class extends Object3D { + constructor(geometry = new BufferGeometry(), material = new MeshBasicMaterial()) { + super(); + this.isMesh = true; + this.type = "Mesh"; + this.geometry = geometry; + this.material = material; + this.updateMorphTargets(); + } + copy(source, recursive) { + super.copy(source, recursive); + if (source.morphTargetInfluences !== void 0) { + this.morphTargetInfluences = source.morphTargetInfluences.slice(); + } + if (source.morphTargetDictionary !== void 0) { + this.morphTargetDictionary = Object.assign({}, source.morphTargetDictionary); + } + this.material = Array.isArray(source.material) ? source.material.slice() : source.material; + this.geometry = source.geometry; + return this; + } + updateMorphTargets() { + const geometry = this.geometry; + const morphAttributes = geometry.morphAttributes; + const keys = Object.keys(morphAttributes); + if (keys.length > 0) { + const morphAttribute = morphAttributes[keys[0]]; + if (morphAttribute !== void 0) { + this.morphTargetInfluences = []; + this.morphTargetDictionary = {}; + for (let m = 0, ml = morphAttribute.length; m < ml; m++) { + const name = morphAttribute[m].name || String(m); + this.morphTargetInfluences.push(0); + this.morphTargetDictionary[name] = m; + } + } + } + } + getVertexPosition(index, target) { + const geometry = this.geometry; + const position = geometry.attributes.position; + const morphPosition = geometry.morphAttributes.position; + const morphTargetsRelative = geometry.morphTargetsRelative; + target.fromBufferAttribute(position, index); + const morphInfluences = this.morphTargetInfluences; + if (morphPosition && morphInfluences) { + _morphA.set(0, 0, 0); + for (let i = 0, il = morphPosition.length; i < il; i++) { + const influence = morphInfluences[i]; + const morphAttribute = morphPosition[i]; + if (influence === 0) continue; + _tempA.fromBufferAttribute(morphAttribute, index); + if (morphTargetsRelative) { + _morphA.addScaledVector(_tempA, influence); + } else { + _morphA.addScaledVector(_tempA.sub(target), influence); + } + } + target.add(_morphA); + } + return target; + } + raycast(raycaster, intersects2) { + const geometry = this.geometry; + const material = this.material; + const matrixWorld = this.matrixWorld; + if (material === void 0) return; + if (geometry.boundingSphere === null) geometry.computeBoundingSphere(); + _sphere$6.copy(geometry.boundingSphere); + _sphere$6.applyMatrix4(matrixWorld); + _ray$3.copy(raycaster.ray).recast(raycaster.near); + if (_sphere$6.containsPoint(_ray$3.origin) === false) { + if (_ray$3.intersectSphere(_sphere$6, _sphereHitAt) === null) return; + if (_ray$3.origin.distanceToSquared(_sphereHitAt) > (raycaster.far - raycaster.near) ** 2) return; + } + _inverseMatrix$3.copy(matrixWorld).invert(); + _ray$3.copy(raycaster.ray).applyMatrix4(_inverseMatrix$3); + if (geometry.boundingBox !== null) { + if (_ray$3.intersectsBox(geometry.boundingBox) === false) return; + } + this._computeIntersections(raycaster, intersects2, _ray$3); + } + _computeIntersections(raycaster, intersects2, rayLocalSpace) { + let intersection; + const geometry = this.geometry; + const material = this.material; + const index = geometry.index; + const position = geometry.attributes.position; + const uv = geometry.attributes.uv; + const uv1 = geometry.attributes.uv1; + const normal = geometry.attributes.normal; + const groups = geometry.groups; + const drawRange = geometry.drawRange; + if (index !== null) { + if (Array.isArray(material)) { + for (let i = 0, il = groups.length; i < il; i++) { + const group = groups[i]; + const groupMaterial = material[group.materialIndex]; + const start = Math.max(group.start, drawRange.start); + const end = Math.min(index.count, Math.min(group.start + group.count, drawRange.start + drawRange.count)); + for (let j = start, jl = end; j < jl; j += 3) { + const a = index.getX(j); + const b = index.getX(j + 1); + const c = index.getX(j + 2); + intersection = checkGeometryIntersection(this, groupMaterial, raycaster, rayLocalSpace, uv, uv1, normal, a, b, c); + if (intersection) { + intersection.faceIndex = Math.floor(j / 3); + intersection.face.materialIndex = group.materialIndex; + intersects2.push(intersection); + } + } + } + } else { + const start = Math.max(0, drawRange.start); + const end = Math.min(index.count, drawRange.start + drawRange.count); + for (let i = start, il = end; i < il; i += 3) { + const a = index.getX(i); + const b = index.getX(i + 1); + const c = index.getX(i + 2); + intersection = checkGeometryIntersection(this, material, raycaster, rayLocalSpace, uv, uv1, normal, a, b, c); + if (intersection) { + intersection.faceIndex = Math.floor(i / 3); + intersects2.push(intersection); + } + } + } + } else if (position !== void 0) { + if (Array.isArray(material)) { + for (let i = 0, il = groups.length; i < il; i++) { + const group = groups[i]; + const groupMaterial = material[group.materialIndex]; + const start = Math.max(group.start, drawRange.start); + const end = Math.min(position.count, Math.min(group.start + group.count, drawRange.start + drawRange.count)); + for (let j = start, jl = end; j < jl; j += 3) { + const a = j; + const b = j + 1; + const c = j + 2; + intersection = checkGeometryIntersection(this, groupMaterial, raycaster, rayLocalSpace, uv, uv1, normal, a, b, c); + if (intersection) { + intersection.faceIndex = Math.floor(j / 3); + intersection.face.materialIndex = group.materialIndex; + intersects2.push(intersection); + } + } + } + } else { + const start = Math.max(0, drawRange.start); + const end = Math.min(position.count, drawRange.start + drawRange.count); + for (let i = start, il = end; i < il; i += 3) { + const a = i; + const b = i + 1; + const c = i + 2; + intersection = checkGeometryIntersection(this, material, raycaster, rayLocalSpace, uv, uv1, normal, a, b, c); + if (intersection) { + intersection.faceIndex = Math.floor(i / 3); + intersects2.push(intersection); + } + } + } + } + } +}; +function checkIntersection(object, material, raycaster, ray, pA, pB, pC, point) { + let intersect2; + if (material.side === BackSide) { + intersect2 = ray.intersectTriangle(pC, pB, pA, true, point); + } else { + intersect2 = ray.intersectTriangle(pA, pB, pC, material.side === FrontSide, point); + } + if (intersect2 === null) return null; + _intersectionPointWorld.copy(point); + _intersectionPointWorld.applyMatrix4(object.matrixWorld); + const distance = raycaster.ray.origin.distanceTo(_intersectionPointWorld); + if (distance < raycaster.near || distance > raycaster.far) return null; + return { + distance, + point: _intersectionPointWorld.clone(), + object + }; +} +function checkGeometryIntersection(object, material, raycaster, ray, uv, uv1, normal, a, b, c) { + object.getVertexPosition(a, _vA$1); + object.getVertexPosition(b, _vB$1); + object.getVertexPosition(c, _vC$1); + const intersection = checkIntersection(object, material, raycaster, ray, _vA$1, _vB$1, _vC$1, _intersectionPoint); + if (intersection) { + if (uv) { + _uvA$1.fromBufferAttribute(uv, a); + _uvB$1.fromBufferAttribute(uv, b); + _uvC$1.fromBufferAttribute(uv, c); + intersection.uv = Triangle.getInterpolation(_intersectionPoint, _vA$1, _vB$1, _vC$1, _uvA$1, _uvB$1, _uvC$1, new Vector2()); + } + if (uv1) { + _uvA$1.fromBufferAttribute(uv1, a); + _uvB$1.fromBufferAttribute(uv1, b); + _uvC$1.fromBufferAttribute(uv1, c); + intersection.uv1 = Triangle.getInterpolation(_intersectionPoint, _vA$1, _vB$1, _vC$1, _uvA$1, _uvB$1, _uvC$1, new Vector2()); + } + if (normal) { + _normalA.fromBufferAttribute(normal, a); + _normalB.fromBufferAttribute(normal, b); + _normalC.fromBufferAttribute(normal, c); + intersection.normal = Triangle.getInterpolation(_intersectionPoint, _vA$1, _vB$1, _vC$1, _normalA, _normalB, _normalC, new Vector3()); + if (intersection.normal.dot(ray.direction) > 0) { + intersection.normal.multiplyScalar(-1); + } + } + const face = { + a, + b, + c, + normal: new Vector3(), + materialIndex: 0 + }; + Triangle.getNormal(_vA$1, _vB$1, _vC$1, face.normal); + intersection.face = face; + } + return intersection; +} +var BoxGeometry = class _BoxGeometry extends BufferGeometry { + constructor(width = 1, height = 1, depth = 1, widthSegments = 1, heightSegments = 1, depthSegments = 1) { + super(); + this.type = "BoxGeometry"; + this.parameters = { + width, + height, + depth, + widthSegments, + heightSegments, + depthSegments + }; + const scope = this; + widthSegments = Math.floor(widthSegments); + heightSegments = Math.floor(heightSegments); + depthSegments = Math.floor(depthSegments); + const indices = []; + const vertices = []; + const normals = []; + const uvs = []; + let numberOfVertices = 0; + let groupStart = 0; + buildPlane("z", "y", "x", -1, -1, depth, height, width, depthSegments, heightSegments, 0); + buildPlane("z", "y", "x", 1, -1, depth, height, -width, depthSegments, heightSegments, 1); + buildPlane("x", "z", "y", 1, 1, width, depth, height, widthSegments, depthSegments, 2); + buildPlane("x", "z", "y", 1, -1, width, depth, -height, widthSegments, depthSegments, 3); + buildPlane("x", "y", "z", 1, -1, width, height, depth, widthSegments, heightSegments, 4); + buildPlane("x", "y", "z", -1, -1, width, height, -depth, widthSegments, heightSegments, 5); + this.setIndex(indices); + this.setAttribute("position", new Float32BufferAttribute(vertices, 3)); + this.setAttribute("normal", new Float32BufferAttribute(normals, 3)); + this.setAttribute("uv", new Float32BufferAttribute(uvs, 2)); + function buildPlane(u, v, w, udir, vdir, width2, height2, depth2, gridX, gridY, materialIndex) { + const segmentWidth = width2 / gridX; + const segmentHeight = height2 / gridY; + const widthHalf = width2 / 2; + const heightHalf = height2 / 2; + const depthHalf = depth2 / 2; + const gridX1 = gridX + 1; + const gridY1 = gridY + 1; + let vertexCounter = 0; + let groupCount = 0; + const vector = new Vector3(); + for (let iy = 0; iy < gridY1; iy++) { + const y = iy * segmentHeight - heightHalf; + for (let ix = 0; ix < gridX1; ix++) { + const x = ix * segmentWidth - widthHalf; + vector[u] = x * udir; + vector[v] = y * vdir; + vector[w] = depthHalf; + vertices.push(vector.x, vector.y, vector.z); + vector[u] = 0; + vector[v] = 0; + vector[w] = depth2 > 0 ? 1 : -1; + normals.push(vector.x, vector.y, vector.z); + uvs.push(ix / gridX); + uvs.push(1 - iy / gridY); + vertexCounter += 1; + } + } + for (let iy = 0; iy < gridY; iy++) { + for (let ix = 0; ix < gridX; ix++) { + const a = numberOfVertices + ix + gridX1 * iy; + const b = numberOfVertices + ix + gridX1 * (iy + 1); + const c = numberOfVertices + (ix + 1) + gridX1 * (iy + 1); + const d = numberOfVertices + (ix + 1) + gridX1 * iy; + indices.push(a, b, d); + indices.push(b, c, d); + groupCount += 6; + } + } + scope.addGroup(groupStart, groupCount, materialIndex); + groupStart += groupCount; + numberOfVertices += vertexCounter; + } + } + copy(source) { + super.copy(source); + this.parameters = Object.assign({}, source.parameters); + return this; + } + static fromJSON(data) { + return new _BoxGeometry(data.width, data.height, data.depth, data.widthSegments, data.heightSegments, data.depthSegments); + } +}; +function cloneUniforms(src) { + const dst = {}; + for (const u in src) { + dst[u] = {}; + for (const p in src[u]) { + const property = src[u][p]; + if (property && (property.isColor || property.isMatrix3 || property.isMatrix4 || property.isVector2 || property.isVector3 || property.isVector4 || property.isTexture || property.isQuaternion)) { + if (property.isRenderTargetTexture) { + console.warn("UniformsUtils: Textures of render targets cannot be cloned via cloneUniforms() or mergeUniforms()."); + dst[u][p] = null; + } else { + dst[u][p] = property.clone(); + } + } else if (Array.isArray(property)) { + dst[u][p] = property.slice(); + } else { + dst[u][p] = property; + } + } + } + return dst; +} +function mergeUniforms(uniforms) { + const merged = {}; + for (let u = 0; u < uniforms.length; u++) { + const tmp = cloneUniforms(uniforms[u]); + for (const p in tmp) { + merged[p] = tmp[p]; + } + } + return merged; +} +function cloneUniformsGroups(src) { + const dst = []; + for (let u = 0; u < src.length; u++) { + dst.push(src[u].clone()); + } + return dst; +} +function getUnlitUniformColorSpace(renderer) { + const currentRenderTarget = renderer.getRenderTarget(); + if (currentRenderTarget === null) { + return renderer.outputColorSpace; + } + if (currentRenderTarget.isXRRenderTarget === true) { + return currentRenderTarget.texture.colorSpace; + } + return ColorManagement.workingColorSpace; +} +var UniformsUtils = { clone: cloneUniforms, merge: mergeUniforms }; +var default_vertex = "void main() {\n gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n}"; +var default_fragment = "void main() {\n gl_FragColor = vec4( 1.0, 0.0, 0.0, 1.0 );\n}"; +var ShaderMaterial = class extends Material { + constructor(parameters) { + super(); + this.isShaderMaterial = true; + this.type = "ShaderMaterial"; + this.defines = {}; + this.uniforms = {}; + this.uniformsGroups = []; + this.vertexShader = default_vertex; + this.fragmentShader = default_fragment; + this.linewidth = 1; + this.wireframe = false; + this.wireframeLinewidth = 1; + this.fog = false; + this.lights = false; + this.clipping = false; + this.forceSinglePass = true; + this.extensions = { + clipCullDistance: false, + // set to use vertex shader clipping + multiDraw: false + // set to use vertex shader multi_draw / enable gl_DrawID + }; + this.defaultAttributeValues = { + "color": [1, 1, 1], + "uv": [0, 0], + "uv1": [0, 0] + }; + this.index0AttributeName = void 0; + this.uniformsNeedUpdate = false; + this.glslVersion = null; + if (parameters !== void 0) { + this.setValues(parameters); + } + } + copy(source) { + super.copy(source); + this.fragmentShader = source.fragmentShader; + this.vertexShader = source.vertexShader; + this.uniforms = cloneUniforms(source.uniforms); + this.uniformsGroups = cloneUniformsGroups(source.uniformsGroups); + this.defines = Object.assign({}, source.defines); + this.wireframe = source.wireframe; + this.wireframeLinewidth = source.wireframeLinewidth; + this.fog = source.fog; + this.lights = source.lights; + this.clipping = source.clipping; + this.extensions = Object.assign({}, source.extensions); + this.glslVersion = source.glslVersion; + return this; + } + toJSON(meta) { + const data = super.toJSON(meta); + data.glslVersion = this.glslVersion; + data.uniforms = {}; + for (const name in this.uniforms) { + const uniform = this.uniforms[name]; + const value = uniform.value; + if (value && value.isTexture) { + data.uniforms[name] = { + type: "t", + value: value.toJSON(meta).uuid + }; + } else if (value && value.isColor) { + data.uniforms[name] = { + type: "c", + value: value.getHex() + }; + } else if (value && value.isVector2) { + data.uniforms[name] = { + type: "v2", + value: value.toArray() + }; + } else if (value && value.isVector3) { + data.uniforms[name] = { + type: "v3", + value: value.toArray() + }; + } else if (value && value.isVector4) { + data.uniforms[name] = { + type: "v4", + value: value.toArray() + }; + } else if (value && value.isMatrix3) { + data.uniforms[name] = { + type: "m3", + value: value.toArray() + }; + } else if (value && value.isMatrix4) { + data.uniforms[name] = { + type: "m4", + value: value.toArray() + }; + } else { + data.uniforms[name] = { + value + }; + } + } + if (Object.keys(this.defines).length > 0) data.defines = this.defines; + data.vertexShader = this.vertexShader; + data.fragmentShader = this.fragmentShader; + data.lights = this.lights; + data.clipping = this.clipping; + const extensions = {}; + for (const key in this.extensions) { + if (this.extensions[key] === true) extensions[key] = true; + } + if (Object.keys(extensions).length > 0) data.extensions = extensions; + return data; + } +}; +var Camera = class extends Object3D { + constructor() { + super(); + this.isCamera = true; + this.type = "Camera"; + this.matrixWorldInverse = new Matrix4(); + this.projectionMatrix = new Matrix4(); + this.projectionMatrixInverse = new Matrix4(); + this.coordinateSystem = WebGLCoordinateSystem; + } + copy(source, recursive) { + super.copy(source, recursive); + this.matrixWorldInverse.copy(source.matrixWorldInverse); + this.projectionMatrix.copy(source.projectionMatrix); + this.projectionMatrixInverse.copy(source.projectionMatrixInverse); + this.coordinateSystem = source.coordinateSystem; + return this; + } + getWorldDirection(target) { + return super.getWorldDirection(target).negate(); + } + updateMatrixWorld(force) { + super.updateMatrixWorld(force); + this.matrixWorldInverse.copy(this.matrixWorld).invert(); + } + updateWorldMatrix(updateParents, updateChildren) { + super.updateWorldMatrix(updateParents, updateChildren); + this.matrixWorldInverse.copy(this.matrixWorld).invert(); + } + clone() { + return new this.constructor().copy(this); + } +}; +var _v3$1 = /* @__PURE__ */ new Vector3(); +var _minTarget = /* @__PURE__ */ new Vector2(); +var _maxTarget = /* @__PURE__ */ new Vector2(); +var PerspectiveCamera = class extends Camera { + constructor(fov2 = 50, aspect2 = 1, near = 0.1, far = 2e3) { + super(); + this.isPerspectiveCamera = true; + this.type = "PerspectiveCamera"; + this.fov = fov2; + this.zoom = 1; + this.near = near; + this.far = far; + this.focus = 10; + this.aspect = aspect2; + this.view = null; + this.filmGauge = 35; + this.filmOffset = 0; + this.updateProjectionMatrix(); + } + copy(source, recursive) { + super.copy(source, recursive); + this.fov = source.fov; + this.zoom = source.zoom; + this.near = source.near; + this.far = source.far; + this.focus = source.focus; + this.aspect = source.aspect; + this.view = source.view === null ? null : Object.assign({}, source.view); + this.filmGauge = source.filmGauge; + this.filmOffset = source.filmOffset; + return this; + } + /** + * Sets the FOV by focal length in respect to the current .filmGauge. + * + * The default film gauge is 35, so that the focal length can be specified for + * a 35mm (full frame) camera. + * + * Values for focal length and film gauge must have the same unit. + */ + setFocalLength(focalLength) { + const vExtentSlope = 0.5 * this.getFilmHeight() / focalLength; + this.fov = RAD2DEG * 2 * Math.atan(vExtentSlope); + this.updateProjectionMatrix(); + } + /** + * Calculates the focal length from the current .fov and .filmGauge. + */ + getFocalLength() { + const vExtentSlope = Math.tan(DEG2RAD * 0.5 * this.fov); + return 0.5 * this.getFilmHeight() / vExtentSlope; + } + getEffectiveFOV() { + return RAD2DEG * 2 * Math.atan( + Math.tan(DEG2RAD * 0.5 * this.fov) / this.zoom + ); + } + getFilmWidth() { + return this.filmGauge * Math.min(this.aspect, 1); + } + getFilmHeight() { + return this.filmGauge / Math.max(this.aspect, 1); + } + /** + * Computes the 2D bounds of the camera's viewable rectangle at a given distance along the viewing direction. + * Sets minTarget and maxTarget to the coordinates of the lower-left and upper-right corners of the view rectangle. + */ + getViewBounds(distance, minTarget, maxTarget) { + _v3$1.set(-1, -1, 0.5).applyMatrix4(this.projectionMatrixInverse); + minTarget.set(_v3$1.x, _v3$1.y).multiplyScalar(-distance / _v3$1.z); + _v3$1.set(1, 1, 0.5).applyMatrix4(this.projectionMatrixInverse); + maxTarget.set(_v3$1.x, _v3$1.y).multiplyScalar(-distance / _v3$1.z); + } + /** + * Computes the width and height of the camera's viewable rectangle at a given distance along the viewing direction. + * Copies the result into the target Vector2, where x is width and y is height. + */ + getViewSize(distance, target) { + this.getViewBounds(distance, _minTarget, _maxTarget); + return target.subVectors(_maxTarget, _minTarget); + } + /** + * Sets an offset in a larger frustum. This is useful for multi-window or + * multi-monitor/multi-machine setups. + * + * For example, if you have 3x2 monitors and each monitor is 1920x1080 and + * the monitors are in grid like this + * + * +---+---+---+ + * | A | B | C | + * +---+---+---+ + * | D | E | F | + * +---+---+---+ + * + * then for each monitor you would call it like this + * + * const w = 1920; + * const h = 1080; + * const fullWidth = w * 3; + * const fullHeight = h * 2; + * + * --A-- + * camera.setViewOffset( fullWidth, fullHeight, w * 0, h * 0, w, h ); + * --B-- + * camera.setViewOffset( fullWidth, fullHeight, w * 1, h * 0, w, h ); + * --C-- + * camera.setViewOffset( fullWidth, fullHeight, w * 2, h * 0, w, h ); + * --D-- + * camera.setViewOffset( fullWidth, fullHeight, w * 0, h * 1, w, h ); + * --E-- + * camera.setViewOffset( fullWidth, fullHeight, w * 1, h * 1, w, h ); + * --F-- + * camera.setViewOffset( fullWidth, fullHeight, w * 2, h * 1, w, h ); + * + * Note there is no reason monitors have to be the same size or in a grid. + */ + setViewOffset(fullWidth, fullHeight, x, y, width, height) { + this.aspect = fullWidth / fullHeight; + if (this.view === null) { + this.view = { + enabled: true, + fullWidth: 1, + fullHeight: 1, + offsetX: 0, + offsetY: 0, + width: 1, + height: 1 + }; + } + this.view.enabled = true; + this.view.fullWidth = fullWidth; + this.view.fullHeight = fullHeight; + this.view.offsetX = x; + this.view.offsetY = y; + this.view.width = width; + this.view.height = height; + this.updateProjectionMatrix(); + } + clearViewOffset() { + if (this.view !== null) { + this.view.enabled = false; + } + this.updateProjectionMatrix(); + } + updateProjectionMatrix() { + const near = this.near; + let top = near * Math.tan(DEG2RAD * 0.5 * this.fov) / this.zoom; + let height = 2 * top; + let width = this.aspect * height; + let left = -0.5 * width; + const view = this.view; + if (this.view !== null && this.view.enabled) { + const fullWidth = view.fullWidth, fullHeight = view.fullHeight; + left += view.offsetX * width / fullWidth; + top -= view.offsetY * height / fullHeight; + width *= view.width / fullWidth; + height *= view.height / fullHeight; + } + const skew = this.filmOffset; + if (skew !== 0) left += near * skew / this.getFilmWidth(); + this.projectionMatrix.makePerspective(left, left + width, top, top - height, near, this.far, this.coordinateSystem); + this.projectionMatrixInverse.copy(this.projectionMatrix).invert(); + } + toJSON(meta) { + const data = super.toJSON(meta); + data.object.fov = this.fov; + data.object.zoom = this.zoom; + data.object.near = this.near; + data.object.far = this.far; + data.object.focus = this.focus; + data.object.aspect = this.aspect; + if (this.view !== null) data.object.view = Object.assign({}, this.view); + data.object.filmGauge = this.filmGauge; + data.object.filmOffset = this.filmOffset; + return data; + } +}; +var fov = -90; +var aspect = 1; +var CubeCamera = class extends Object3D { + constructor(near, far, renderTarget) { + super(); + this.type = "CubeCamera"; + this.renderTarget = renderTarget; + this.coordinateSystem = null; + this.activeMipmapLevel = 0; + const cameraPX = new PerspectiveCamera(fov, aspect, near, far); + cameraPX.layers = this.layers; + this.add(cameraPX); + const cameraNX = new PerspectiveCamera(fov, aspect, near, far); + cameraNX.layers = this.layers; + this.add(cameraNX); + const cameraPY = new PerspectiveCamera(fov, aspect, near, far); + cameraPY.layers = this.layers; + this.add(cameraPY); + const cameraNY = new PerspectiveCamera(fov, aspect, near, far); + cameraNY.layers = this.layers; + this.add(cameraNY); + const cameraPZ = new PerspectiveCamera(fov, aspect, near, far); + cameraPZ.layers = this.layers; + this.add(cameraPZ); + const cameraNZ = new PerspectiveCamera(fov, aspect, near, far); + cameraNZ.layers = this.layers; + this.add(cameraNZ); + } + updateCoordinateSystem() { + const coordinateSystem = this.coordinateSystem; + const cameras = this.children.concat(); + const [cameraPX, cameraNX, cameraPY, cameraNY, cameraPZ, cameraNZ] = cameras; + for (const camera of cameras) this.remove(camera); + if (coordinateSystem === WebGLCoordinateSystem) { + cameraPX.up.set(0, 1, 0); + cameraPX.lookAt(1, 0, 0); + cameraNX.up.set(0, 1, 0); + cameraNX.lookAt(-1, 0, 0); + cameraPY.up.set(0, 0, -1); + cameraPY.lookAt(0, 1, 0); + cameraNY.up.set(0, 0, 1); + cameraNY.lookAt(0, -1, 0); + cameraPZ.up.set(0, 1, 0); + cameraPZ.lookAt(0, 0, 1); + cameraNZ.up.set(0, 1, 0); + cameraNZ.lookAt(0, 0, -1); + } else if (coordinateSystem === WebGPUCoordinateSystem) { + cameraPX.up.set(0, -1, 0); + cameraPX.lookAt(-1, 0, 0); + cameraNX.up.set(0, -1, 0); + cameraNX.lookAt(1, 0, 0); + cameraPY.up.set(0, 0, 1); + cameraPY.lookAt(0, 1, 0); + cameraNY.up.set(0, 0, -1); + cameraNY.lookAt(0, -1, 0); + cameraPZ.up.set(0, -1, 0); + cameraPZ.lookAt(0, 0, 1); + cameraNZ.up.set(0, -1, 0); + cameraNZ.lookAt(0, 0, -1); + } else { + throw new Error("THREE.CubeCamera.updateCoordinateSystem(): Invalid coordinate system: " + coordinateSystem); + } + for (const camera of cameras) { + this.add(camera); + camera.updateMatrixWorld(); + } + } + update(renderer, scene) { + if (this.parent === null) this.updateMatrixWorld(); + const { renderTarget, activeMipmapLevel } = this; + if (this.coordinateSystem !== renderer.coordinateSystem) { + this.coordinateSystem = renderer.coordinateSystem; + this.updateCoordinateSystem(); + } + const [cameraPX, cameraNX, cameraPY, cameraNY, cameraPZ, cameraNZ] = this.children; + const currentRenderTarget = renderer.getRenderTarget(); + const currentActiveCubeFace = renderer.getActiveCubeFace(); + const currentActiveMipmapLevel = renderer.getActiveMipmapLevel(); + const currentXrEnabled = renderer.xr.enabled; + renderer.xr.enabled = false; + const generateMipmaps = renderTarget.texture.generateMipmaps; + renderTarget.texture.generateMipmaps = false; + renderer.setRenderTarget(renderTarget, 0, activeMipmapLevel); + renderer.render(scene, cameraPX); + renderer.setRenderTarget(renderTarget, 1, activeMipmapLevel); + renderer.render(scene, cameraNX); + renderer.setRenderTarget(renderTarget, 2, activeMipmapLevel); + renderer.render(scene, cameraPY); + renderer.setRenderTarget(renderTarget, 3, activeMipmapLevel); + renderer.render(scene, cameraNY); + renderer.setRenderTarget(renderTarget, 4, activeMipmapLevel); + renderer.render(scene, cameraPZ); + renderTarget.texture.generateMipmaps = generateMipmaps; + renderer.setRenderTarget(renderTarget, 5, activeMipmapLevel); + renderer.render(scene, cameraNZ); + renderer.setRenderTarget(currentRenderTarget, currentActiveCubeFace, currentActiveMipmapLevel); + renderer.xr.enabled = currentXrEnabled; + renderTarget.texture.needsPMREMUpdate = true; + } +}; +var CubeTexture = class extends Texture { + constructor(images, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, colorSpace) { + images = images !== void 0 ? images : []; + mapping = mapping !== void 0 ? mapping : CubeReflectionMapping; + super(images, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, colorSpace); + this.isCubeTexture = true; + this.flipY = false; + } + get images() { + return this.image; + } + set images(value) { + this.image = value; + } +}; +var WebGLCubeRenderTarget = class extends WebGLRenderTarget { + constructor(size = 1, options = {}) { + super(size, size, options); + this.isWebGLCubeRenderTarget = true; + const image = { width: size, height: size, depth: 1 }; + const images = [image, image, image, image, image, image]; + this.texture = new CubeTexture(images, options.mapping, options.wrapS, options.wrapT, options.magFilter, options.minFilter, options.format, options.type, options.anisotropy, options.colorSpace); + this.texture.isRenderTargetTexture = true; + this.texture.generateMipmaps = options.generateMipmaps !== void 0 ? options.generateMipmaps : false; + this.texture.minFilter = options.minFilter !== void 0 ? options.minFilter : LinearFilter; + } + fromEquirectangularTexture(renderer, texture) { + this.texture.type = texture.type; + this.texture.colorSpace = texture.colorSpace; + this.texture.generateMipmaps = texture.generateMipmaps; + this.texture.minFilter = texture.minFilter; + this.texture.magFilter = texture.magFilter; + const shader = { + uniforms: { + tEquirect: { value: null } + }, + vertexShader: ( + /* glsl */ + ` + + varying vec3 vWorldDirection; + + vec3 transformDirection( in vec3 dir, in mat4 matrix ) { + + return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz ); + + } + + void main() { + + vWorldDirection = transformDirection( position, modelMatrix ); + + #include + #include + + } + ` + ), + fragmentShader: ( + /* glsl */ + ` + + uniform sampler2D tEquirect; + + varying vec3 vWorldDirection; + + #include + + void main() { + + vec3 direction = normalize( vWorldDirection ); + + vec2 sampleUV = equirectUv( direction ); + + gl_FragColor = texture2D( tEquirect, sampleUV ); + + } + ` + ) + }; + const geometry = new BoxGeometry(5, 5, 5); + const material = new ShaderMaterial({ + name: "CubemapFromEquirect", + uniforms: cloneUniforms(shader.uniforms), + vertexShader: shader.vertexShader, + fragmentShader: shader.fragmentShader, + side: BackSide, + blending: NoBlending + }); + material.uniforms.tEquirect.value = texture; + const mesh = new Mesh(geometry, material); + const currentMinFilter = texture.minFilter; + if (texture.minFilter === LinearMipmapLinearFilter) texture.minFilter = LinearFilter; + const camera = new CubeCamera(1, 10, this); + camera.update(renderer, mesh); + texture.minFilter = currentMinFilter; + mesh.geometry.dispose(); + mesh.material.dispose(); + return this; + } + clear(renderer, color, depth, stencil) { + const currentRenderTarget = renderer.getRenderTarget(); + for (let i = 0; i < 6; i++) { + renderer.setRenderTarget(this, i); + renderer.clear(color, depth, stencil); + } + renderer.setRenderTarget(currentRenderTarget); + } +}; +var _vector1 = /* @__PURE__ */ new Vector3(); +var _vector2 = /* @__PURE__ */ new Vector3(); +var _normalMatrix = /* @__PURE__ */ new Matrix3(); +var Plane = class { + constructor(normal = new Vector3(1, 0, 0), constant = 0) { + this.isPlane = true; + this.normal = normal; + this.constant = constant; + } + set(normal, constant) { + this.normal.copy(normal); + this.constant = constant; + return this; + } + setComponents(x, y, z, w) { + this.normal.set(x, y, z); + this.constant = w; + return this; + } + setFromNormalAndCoplanarPoint(normal, point) { + this.normal.copy(normal); + this.constant = -point.dot(this.normal); + return this; + } + setFromCoplanarPoints(a, b, c) { + const normal = _vector1.subVectors(c, b).cross(_vector2.subVectors(a, b)).normalize(); + this.setFromNormalAndCoplanarPoint(normal, a); + return this; + } + copy(plane) { + this.normal.copy(plane.normal); + this.constant = plane.constant; + return this; + } + normalize() { + const inverseNormalLength = 1 / this.normal.length(); + this.normal.multiplyScalar(inverseNormalLength); + this.constant *= inverseNormalLength; + return this; + } + negate() { + this.constant *= -1; + this.normal.negate(); + return this; + } + distanceToPoint(point) { + return this.normal.dot(point) + this.constant; + } + distanceToSphere(sphere) { + return this.distanceToPoint(sphere.center) - sphere.radius; + } + projectPoint(point, target) { + return target.copy(point).addScaledVector(this.normal, -this.distanceToPoint(point)); + } + intersectLine(line, target) { + const direction = line.delta(_vector1); + const denominator = this.normal.dot(direction); + if (denominator === 0) { + if (this.distanceToPoint(line.start) === 0) { + return target.copy(line.start); + } + return null; + } + const t = -(line.start.dot(this.normal) + this.constant) / denominator; + if (t < 0 || t > 1) { + return null; + } + return target.copy(line.start).addScaledVector(direction, t); + } + intersectsLine(line) { + const startSign = this.distanceToPoint(line.start); + const endSign = this.distanceToPoint(line.end); + return startSign < 0 && endSign > 0 || endSign < 0 && startSign > 0; + } + intersectsBox(box) { + return box.intersectsPlane(this); + } + intersectsSphere(sphere) { + return sphere.intersectsPlane(this); + } + coplanarPoint(target) { + return target.copy(this.normal).multiplyScalar(-this.constant); + } + applyMatrix4(matrix, optionalNormalMatrix) { + const normalMatrix = optionalNormalMatrix || _normalMatrix.getNormalMatrix(matrix); + const referencePoint = this.coplanarPoint(_vector1).applyMatrix4(matrix); + const normal = this.normal.applyMatrix3(normalMatrix).normalize(); + this.constant = -referencePoint.dot(normal); + return this; + } + translate(offset) { + this.constant -= offset.dot(this.normal); + return this; + } + equals(plane) { + return plane.normal.equals(this.normal) && plane.constant === this.constant; + } + clone() { + return new this.constructor().copy(this); + } +}; +var _sphere$5 = /* @__PURE__ */ new Sphere(); +var _vector$7 = /* @__PURE__ */ new Vector3(); +var Frustum = class { + constructor(p0 = new Plane(), p1 = new Plane(), p2 = new Plane(), p3 = new Plane(), p4 = new Plane(), p5 = new Plane()) { + this.planes = [p0, p1, p2, p3, p4, p5]; + } + set(p0, p1, p2, p3, p4, p5) { + const planes = this.planes; + planes[0].copy(p0); + planes[1].copy(p1); + planes[2].copy(p2); + planes[3].copy(p3); + planes[4].copy(p4); + planes[5].copy(p5); + return this; + } + copy(frustum) { + const planes = this.planes; + for (let i = 0; i < 6; i++) { + planes[i].copy(frustum.planes[i]); + } + return this; + } + setFromProjectionMatrix(m, coordinateSystem = WebGLCoordinateSystem) { + const planes = this.planes; + const me = m.elements; + const me0 = me[0], me1 = me[1], me2 = me[2], me3 = me[3]; + const me4 = me[4], me5 = me[5], me6 = me[6], me7 = me[7]; + const me8 = me[8], me9 = me[9], me10 = me[10], me11 = me[11]; + const me12 = me[12], me13 = me[13], me14 = me[14], me15 = me[15]; + planes[0].setComponents(me3 - me0, me7 - me4, me11 - me8, me15 - me12).normalize(); + planes[1].setComponents(me3 + me0, me7 + me4, me11 + me8, me15 + me12).normalize(); + planes[2].setComponents(me3 + me1, me7 + me5, me11 + me9, me15 + me13).normalize(); + planes[3].setComponents(me3 - me1, me7 - me5, me11 - me9, me15 - me13).normalize(); + planes[4].setComponents(me3 - me2, me7 - me6, me11 - me10, me15 - me14).normalize(); + if (coordinateSystem === WebGLCoordinateSystem) { + planes[5].setComponents(me3 + me2, me7 + me6, me11 + me10, me15 + me14).normalize(); + } else if (coordinateSystem === WebGPUCoordinateSystem) { + planes[5].setComponents(me2, me6, me10, me14).normalize(); + } else { + throw new Error("THREE.Frustum.setFromProjectionMatrix(): Invalid coordinate system: " + coordinateSystem); + } + return this; + } + intersectsObject(object) { + if (object.boundingSphere !== void 0) { + if (object.boundingSphere === null) object.computeBoundingSphere(); + _sphere$5.copy(object.boundingSphere).applyMatrix4(object.matrixWorld); + } else { + const geometry = object.geometry; + if (geometry.boundingSphere === null) geometry.computeBoundingSphere(); + _sphere$5.copy(geometry.boundingSphere).applyMatrix4(object.matrixWorld); + } + return this.intersectsSphere(_sphere$5); + } + intersectsSprite(sprite) { + _sphere$5.center.set(0, 0, 0); + _sphere$5.radius = 0.7071067811865476; + _sphere$5.applyMatrix4(sprite.matrixWorld); + return this.intersectsSphere(_sphere$5); + } + intersectsSphere(sphere) { + const planes = this.planes; + const center = sphere.center; + const negRadius = -sphere.radius; + for (let i = 0; i < 6; i++) { + const distance = planes[i].distanceToPoint(center); + if (distance < negRadius) { + return false; + } + } + return true; + } + intersectsBox(box) { + const planes = this.planes; + for (let i = 0; i < 6; i++) { + const plane = planes[i]; + _vector$7.x = plane.normal.x > 0 ? box.max.x : box.min.x; + _vector$7.y = plane.normal.y > 0 ? box.max.y : box.min.y; + _vector$7.z = plane.normal.z > 0 ? box.max.z : box.min.z; + if (plane.distanceToPoint(_vector$7) < 0) { + return false; + } + } + return true; + } + containsPoint(point) { + const planes = this.planes; + for (let i = 0; i < 6; i++) { + if (planes[i].distanceToPoint(point) < 0) { + return false; + } + } + return true; + } + clone() { + return new this.constructor().copy(this); + } +}; +function WebGLAnimation() { + let context = null; + let isAnimating = false; + let animationLoop = null; + let requestId = null; + function onAnimationFrame(time, frame) { + animationLoop(time, frame); + requestId = context.requestAnimationFrame(onAnimationFrame); + } + return { + start: function() { + if (isAnimating === true) return; + if (animationLoop === null) return; + requestId = context.requestAnimationFrame(onAnimationFrame); + isAnimating = true; + }, + stop: function() { + context.cancelAnimationFrame(requestId); + isAnimating = false; + }, + setAnimationLoop: function(callback) { + animationLoop = callback; + }, + setContext: function(value) { + context = value; + } + }; +} +function WebGLAttributes(gl) { + const buffers = /* @__PURE__ */ new WeakMap(); + function createBuffer(attribute, bufferType) { + const array = attribute.array; + const usage = attribute.usage; + const size = array.byteLength; + const buffer = gl.createBuffer(); + gl.bindBuffer(bufferType, buffer); + gl.bufferData(bufferType, array, usage); + attribute.onUploadCallback(); + let type; + if (array instanceof Float32Array) { + type = gl.FLOAT; + } else if (array instanceof Uint16Array) { + if (attribute.isFloat16BufferAttribute) { + type = gl.HALF_FLOAT; + } else { + type = gl.UNSIGNED_SHORT; + } + } else if (array instanceof Int16Array) { + type = gl.SHORT; + } else if (array instanceof Uint32Array) { + type = gl.UNSIGNED_INT; + } else if (array instanceof Int32Array) { + type = gl.INT; + } else if (array instanceof Int8Array) { + type = gl.BYTE; + } else if (array instanceof Uint8Array) { + type = gl.UNSIGNED_BYTE; + } else if (array instanceof Uint8ClampedArray) { + type = gl.UNSIGNED_BYTE; + } else { + throw new Error("THREE.WebGLAttributes: Unsupported buffer data format: " + array); + } + return { + buffer, + type, + bytesPerElement: array.BYTES_PER_ELEMENT, + version: attribute.version, + size + }; + } + function updateBuffer(buffer, attribute, bufferType) { + const array = attribute.array; + const updateRange = attribute._updateRange; + const updateRanges = attribute.updateRanges; + gl.bindBuffer(bufferType, buffer); + if (updateRange.count === -1 && updateRanges.length === 0) { + gl.bufferSubData(bufferType, 0, array); + } + if (updateRanges.length !== 0) { + for (let i = 0, l = updateRanges.length; i < l; i++) { + const range = updateRanges[i]; + gl.bufferSubData( + bufferType, + range.start * array.BYTES_PER_ELEMENT, + array, + range.start, + range.count + ); + } + attribute.clearUpdateRanges(); + } + if (updateRange.count !== -1) { + gl.bufferSubData( + bufferType, + updateRange.offset * array.BYTES_PER_ELEMENT, + array, + updateRange.offset, + updateRange.count + ); + updateRange.count = -1; + } + attribute.onUploadCallback(); + } + function get(attribute) { + if (attribute.isInterleavedBufferAttribute) attribute = attribute.data; + return buffers.get(attribute); + } + function remove(attribute) { + if (attribute.isInterleavedBufferAttribute) attribute = attribute.data; + const data = buffers.get(attribute); + if (data) { + gl.deleteBuffer(data.buffer); + buffers.delete(attribute); + } + } + function update(attribute, bufferType) { + if (attribute.isGLBufferAttribute) { + const cached = buffers.get(attribute); + if (!cached || cached.version < attribute.version) { + buffers.set(attribute, { + buffer: attribute.buffer, + type: attribute.type, + bytesPerElement: attribute.elementSize, + version: attribute.version + }); + } + return; + } + if (attribute.isInterleavedBufferAttribute) attribute = attribute.data; + const data = buffers.get(attribute); + if (data === void 0) { + buffers.set(attribute, createBuffer(attribute, bufferType)); + } else if (data.version < attribute.version) { + if (data.size !== attribute.array.byteLength) { + throw new Error("THREE.WebGLAttributes: The size of the buffer attribute's array buffer does not match the original size. Resizing buffer attributes is not supported."); + } + updateBuffer(data.buffer, attribute, bufferType); + data.version = attribute.version; + } + } + return { + get, + remove, + update + }; +} +var PlaneGeometry = class _PlaneGeometry extends BufferGeometry { + constructor(width = 1, height = 1, widthSegments = 1, heightSegments = 1) { + super(); + this.type = "PlaneGeometry"; + this.parameters = { + width, + height, + widthSegments, + heightSegments + }; + const width_half = width / 2; + const height_half = height / 2; + const gridX = Math.floor(widthSegments); + const gridY = Math.floor(heightSegments); + const gridX1 = gridX + 1; + const gridY1 = gridY + 1; + const segment_width = width / gridX; + const segment_height = height / gridY; + const indices = []; + const vertices = []; + const normals = []; + const uvs = []; + for (let iy = 0; iy < gridY1; iy++) { + const y = iy * segment_height - height_half; + for (let ix = 0; ix < gridX1; ix++) { + const x = ix * segment_width - width_half; + vertices.push(x, -y, 0); + normals.push(0, 0, 1); + uvs.push(ix / gridX); + uvs.push(1 - iy / gridY); + } + } + for (let iy = 0; iy < gridY; iy++) { + for (let ix = 0; ix < gridX; ix++) { + const a = ix + gridX1 * iy; + const b = ix + gridX1 * (iy + 1); + const c = ix + 1 + gridX1 * (iy + 1); + const d = ix + 1 + gridX1 * iy; + indices.push(a, b, d); + indices.push(b, c, d); + } + } + this.setIndex(indices); + this.setAttribute("position", new Float32BufferAttribute(vertices, 3)); + this.setAttribute("normal", new Float32BufferAttribute(normals, 3)); + this.setAttribute("uv", new Float32BufferAttribute(uvs, 2)); + } + copy(source) { + super.copy(source); + this.parameters = Object.assign({}, source.parameters); + return this; + } + static fromJSON(data) { + return new _PlaneGeometry(data.width, data.height, data.widthSegments, data.heightSegments); + } +}; +var alphahash_fragment = "#ifdef USE_ALPHAHASH\n if ( diffuseColor.a < getAlphaHashThreshold( vPosition ) ) discard;\n#endif"; +var alphahash_pars_fragment = "#ifdef USE_ALPHAHASH\n const float ALPHA_HASH_SCALE = 0.05;\n float hash2D( vec2 value ) {\n return fract( 1.0e4 * sin( 17.0 * value.x + 0.1 * value.y ) * ( 0.1 + abs( sin( 13.0 * value.y + value.x ) ) ) );\n }\n float hash3D( vec3 value ) {\n return hash2D( vec2( hash2D( value.xy ), value.z ) );\n }\n float getAlphaHashThreshold( vec3 position ) {\n float maxDeriv = max(\n length( dFdx( position.xyz ) ),\n length( dFdy( position.xyz ) )\n );\n float pixScale = 1.0 / ( ALPHA_HASH_SCALE * maxDeriv );\n vec2 pixScales = vec2(\n exp2( floor( log2( pixScale ) ) ),\n exp2( ceil( log2( pixScale ) ) )\n );\n vec2 alpha = vec2(\n hash3D( floor( pixScales.x * position.xyz ) ),\n hash3D( floor( pixScales.y * position.xyz ) )\n );\n float lerpFactor = fract( log2( pixScale ) );\n float x = ( 1.0 - lerpFactor ) * alpha.x + lerpFactor * alpha.y;\n float a = min( lerpFactor, 1.0 - lerpFactor );\n vec3 cases = vec3(\n x * x / ( 2.0 * a * ( 1.0 - a ) ),\n ( x - 0.5 * a ) / ( 1.0 - a ),\n 1.0 - ( ( 1.0 - x ) * ( 1.0 - x ) / ( 2.0 * a * ( 1.0 - a ) ) )\n );\n float threshold = ( x < ( 1.0 - a ) )\n ? ( ( x < a ) ? cases.x : cases.y )\n : cases.z;\n return clamp( threshold , 1.0e-6, 1.0 );\n }\n#endif"; +var alphamap_fragment = "#ifdef USE_ALPHAMAP\n diffuseColor.a *= texture2D( alphaMap, vAlphaMapUv ).g;\n#endif"; +var alphamap_pars_fragment = "#ifdef USE_ALPHAMAP\n uniform sampler2D alphaMap;\n#endif"; +var alphatest_fragment = "#ifdef USE_ALPHATEST\n #ifdef ALPHA_TO_COVERAGE\n diffuseColor.a = smoothstep( alphaTest, alphaTest + fwidth( diffuseColor.a ), diffuseColor.a );\n if ( diffuseColor.a == 0.0 ) discard;\n #else\n if ( diffuseColor.a < alphaTest ) discard;\n #endif\n#endif"; +var alphatest_pars_fragment = "#ifdef USE_ALPHATEST\n uniform float alphaTest;\n#endif"; +var aomap_fragment = "#ifdef USE_AOMAP\n float ambientOcclusion = ( texture2D( aoMap, vAoMapUv ).r - 1.0 ) * aoMapIntensity + 1.0;\n reflectedLight.indirectDiffuse *= ambientOcclusion;\n #if defined( USE_CLEARCOAT ) \n clearcoatSpecularIndirect *= ambientOcclusion;\n #endif\n #if defined( USE_SHEEN ) \n sheenSpecularIndirect *= ambientOcclusion;\n #endif\n #if defined( USE_ENVMAP ) && defined( STANDARD )\n float dotNV = saturate( dot( geometryNormal, geometryViewDir ) );\n reflectedLight.indirectSpecular *= computeSpecularOcclusion( dotNV, ambientOcclusion, material.roughness );\n #endif\n#endif"; +var aomap_pars_fragment = "#ifdef USE_AOMAP\n uniform sampler2D aoMap;\n uniform float aoMapIntensity;\n#endif"; +var batching_pars_vertex = "#ifdef USE_BATCHING\n attribute float batchId;\n uniform highp sampler2D batchingTexture;\n mat4 getBatchingMatrix( const in float i ) {\n int size = textureSize( batchingTexture, 0 ).x;\n int j = int( i ) * 4;\n int x = j % size;\n int y = j / size;\n vec4 v1 = texelFetch( batchingTexture, ivec2( x, y ), 0 );\n vec4 v2 = texelFetch( batchingTexture, ivec2( x + 1, y ), 0 );\n vec4 v3 = texelFetch( batchingTexture, ivec2( x + 2, y ), 0 );\n vec4 v4 = texelFetch( batchingTexture, ivec2( x + 3, y ), 0 );\n return mat4( v1, v2, v3, v4 );\n }\n#endif"; +var batching_vertex = "#ifdef USE_BATCHING\n mat4 batchingMatrix = getBatchingMatrix( batchId );\n#endif"; +var begin_vertex = "vec3 transformed = vec3( position );\n#ifdef USE_ALPHAHASH\n vPosition = vec3( position );\n#endif"; +var beginnormal_vertex = "vec3 objectNormal = vec3( normal );\n#ifdef USE_TANGENT\n vec3 objectTangent = vec3( tangent.xyz );\n#endif"; +var bsdfs = "float G_BlinnPhong_Implicit( ) {\n return 0.25;\n}\nfloat D_BlinnPhong( const in float shininess, const in float dotNH ) {\n return RECIPROCAL_PI * ( shininess * 0.5 + 1.0 ) * pow( dotNH, shininess );\n}\nvec3 BRDF_BlinnPhong( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in vec3 specularColor, const in float shininess ) {\n vec3 halfDir = normalize( lightDir + viewDir );\n float dotNH = saturate( dot( normal, halfDir ) );\n float dotVH = saturate( dot( viewDir, halfDir ) );\n vec3 F = F_Schlick( specularColor, 1.0, dotVH );\n float G = G_BlinnPhong_Implicit( );\n float D = D_BlinnPhong( shininess, dotNH );\n return F * ( G * D );\n} // validated"; +var iridescence_fragment = "#ifdef USE_IRIDESCENCE\n const mat3 XYZ_TO_REC709 = mat3(\n 3.2404542, -0.9692660, 0.0556434,\n -1.5371385, 1.8760108, -0.2040259,\n -0.4985314, 0.0415560, 1.0572252\n );\n vec3 Fresnel0ToIor( vec3 fresnel0 ) {\n vec3 sqrtF0 = sqrt( fresnel0 );\n return ( vec3( 1.0 ) + sqrtF0 ) / ( vec3( 1.0 ) - sqrtF0 );\n }\n vec3 IorToFresnel0( vec3 transmittedIor, float incidentIor ) {\n return pow2( ( transmittedIor - vec3( incidentIor ) ) / ( transmittedIor + vec3( incidentIor ) ) );\n }\n float IorToFresnel0( float transmittedIor, float incidentIor ) {\n return pow2( ( transmittedIor - incidentIor ) / ( transmittedIor + incidentIor ));\n }\n vec3 evalSensitivity( float OPD, vec3 shift ) {\n float phase = 2.0 * PI * OPD * 1.0e-9;\n vec3 val = vec3( 5.4856e-13, 4.4201e-13, 5.2481e-13 );\n vec3 pos = vec3( 1.6810e+06, 1.7953e+06, 2.2084e+06 );\n vec3 var = vec3( 4.3278e+09, 9.3046e+09, 6.6121e+09 );\n vec3 xyz = val * sqrt( 2.0 * PI * var ) * cos( pos * phase + shift ) * exp( - pow2( phase ) * var );\n xyz.x += 9.7470e-14 * sqrt( 2.0 * PI * 4.5282e+09 ) * cos( 2.2399e+06 * phase + shift[ 0 ] ) * exp( - 4.5282e+09 * pow2( phase ) );\n xyz /= 1.0685e-7;\n vec3 rgb = XYZ_TO_REC709 * xyz;\n return rgb;\n }\n vec3 evalIridescence( float outsideIOR, float eta2, float cosTheta1, float thinFilmThickness, vec3 baseF0 ) {\n vec3 I;\n float iridescenceIOR = mix( outsideIOR, eta2, smoothstep( 0.0, 0.03, thinFilmThickness ) );\n float sinTheta2Sq = pow2( outsideIOR / iridescenceIOR ) * ( 1.0 - pow2( cosTheta1 ) );\n float cosTheta2Sq = 1.0 - sinTheta2Sq;\n if ( cosTheta2Sq < 0.0 ) {\n return vec3( 1.0 );\n }\n float cosTheta2 = sqrt( cosTheta2Sq );\n float R0 = IorToFresnel0( iridescenceIOR, outsideIOR );\n float R12 = F_Schlick( R0, 1.0, cosTheta1 );\n float T121 = 1.0 - R12;\n float phi12 = 0.0;\n if ( iridescenceIOR < outsideIOR ) phi12 = PI;\n float phi21 = PI - phi12;\n vec3 baseIOR = Fresnel0ToIor( clamp( baseF0, 0.0, 0.9999 ) ); vec3 R1 = IorToFresnel0( baseIOR, iridescenceIOR );\n vec3 R23 = F_Schlick( R1, 1.0, cosTheta2 );\n vec3 phi23 = vec3( 0.0 );\n if ( baseIOR[ 0 ] < iridescenceIOR ) phi23[ 0 ] = PI;\n if ( baseIOR[ 1 ] < iridescenceIOR ) phi23[ 1 ] = PI;\n if ( baseIOR[ 2 ] < iridescenceIOR ) phi23[ 2 ] = PI;\n float OPD = 2.0 * iridescenceIOR * thinFilmThickness * cosTheta2;\n vec3 phi = vec3( phi21 ) + phi23;\n vec3 R123 = clamp( R12 * R23, 1e-5, 0.9999 );\n vec3 r123 = sqrt( R123 );\n vec3 Rs = pow2( T121 ) * R23 / ( vec3( 1.0 ) - R123 );\n vec3 C0 = R12 + Rs;\n I = C0;\n vec3 Cm = Rs - T121;\n for ( int m = 1; m <= 2; ++ m ) {\n Cm *= r123;\n vec3 Sm = 2.0 * evalSensitivity( float( m ) * OPD, float( m ) * phi );\n I += Cm * Sm;\n }\n return max( I, vec3( 0.0 ) );\n }\n#endif"; +var bumpmap_pars_fragment = "#ifdef USE_BUMPMAP\n uniform sampler2D bumpMap;\n uniform float bumpScale;\n vec2 dHdxy_fwd() {\n vec2 dSTdx = dFdx( vBumpMapUv );\n vec2 dSTdy = dFdy( vBumpMapUv );\n float Hll = bumpScale * texture2D( bumpMap, vBumpMapUv ).x;\n float dBx = bumpScale * texture2D( bumpMap, vBumpMapUv + dSTdx ).x - Hll;\n float dBy = bumpScale * texture2D( bumpMap, vBumpMapUv + dSTdy ).x - Hll;\n return vec2( dBx, dBy );\n }\n vec3 perturbNormalArb( vec3 surf_pos, vec3 surf_norm, vec2 dHdxy, float faceDirection ) {\n vec3 vSigmaX = normalize( dFdx( surf_pos.xyz ) );\n vec3 vSigmaY = normalize( dFdy( surf_pos.xyz ) );\n vec3 vN = surf_norm;\n vec3 R1 = cross( vSigmaY, vN );\n vec3 R2 = cross( vN, vSigmaX );\n float fDet = dot( vSigmaX, R1 ) * faceDirection;\n vec3 vGrad = sign( fDet ) * ( dHdxy.x * R1 + dHdxy.y * R2 );\n return normalize( abs( fDet ) * surf_norm - vGrad );\n }\n#endif"; +var clipping_planes_fragment = "#if NUM_CLIPPING_PLANES > 0\n vec4 plane;\n #ifdef ALPHA_TO_COVERAGE\n float distanceToPlane, distanceGradient;\n float clipOpacity = 1.0;\n #pragma unroll_loop_start\n for ( int i = 0; i < UNION_CLIPPING_PLANES; i ++ ) {\n plane = clippingPlanes[ i ];\n distanceToPlane = - dot( vClipPosition, plane.xyz ) + plane.w;\n distanceGradient = fwidth( distanceToPlane ) / 2.0;\n clipOpacity *= smoothstep( - distanceGradient, distanceGradient, distanceToPlane );\n if ( clipOpacity == 0.0 ) discard;\n }\n #pragma unroll_loop_end\n #if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES\n float unionClipOpacity = 1.0;\n #pragma unroll_loop_start\n for ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; i ++ ) {\n plane = clippingPlanes[ i ];\n distanceToPlane = - dot( vClipPosition, plane.xyz ) + plane.w;\n distanceGradient = fwidth( distanceToPlane ) / 2.0;\n unionClipOpacity *= 1.0 - smoothstep( - distanceGradient, distanceGradient, distanceToPlane );\n }\n #pragma unroll_loop_end\n clipOpacity *= 1.0 - unionClipOpacity;\n #endif\n diffuseColor.a *= clipOpacity;\n if ( diffuseColor.a == 0.0 ) discard;\n #else\n #pragma unroll_loop_start\n for ( int i = 0; i < UNION_CLIPPING_PLANES; i ++ ) {\n plane = clippingPlanes[ i ];\n if ( dot( vClipPosition, plane.xyz ) > plane.w ) discard;\n }\n #pragma unroll_loop_end\n #if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES\n bool clipped = true;\n #pragma unroll_loop_start\n for ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; i ++ ) {\n plane = clippingPlanes[ i ];\n clipped = ( dot( vClipPosition, plane.xyz ) > plane.w ) && clipped;\n }\n #pragma unroll_loop_end\n if ( clipped ) discard;\n #endif\n #endif\n#endif"; +var clipping_planes_pars_fragment = "#if NUM_CLIPPING_PLANES > 0\n varying vec3 vClipPosition;\n uniform vec4 clippingPlanes[ NUM_CLIPPING_PLANES ];\n#endif"; +var clipping_planes_pars_vertex = "#if NUM_CLIPPING_PLANES > 0\n varying vec3 vClipPosition;\n#endif"; +var clipping_planes_vertex = "#if NUM_CLIPPING_PLANES > 0\n vClipPosition = - mvPosition.xyz;\n#endif"; +var color_fragment = "#if defined( USE_COLOR_ALPHA )\n diffuseColor *= vColor;\n#elif defined( USE_COLOR )\n diffuseColor.rgb *= vColor;\n#endif"; +var color_pars_fragment = "#if defined( USE_COLOR_ALPHA )\n varying vec4 vColor;\n#elif defined( USE_COLOR )\n varying vec3 vColor;\n#endif"; +var color_pars_vertex = "#if defined( USE_COLOR_ALPHA )\n varying vec4 vColor;\n#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )\n varying vec3 vColor;\n#endif"; +var color_vertex = "#if defined( USE_COLOR_ALPHA )\n vColor = vec4( 1.0 );\n#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )\n vColor = vec3( 1.0 );\n#endif\n#ifdef USE_COLOR\n vColor *= color;\n#endif\n#ifdef USE_INSTANCING_COLOR\n vColor.xyz *= instanceColor.xyz;\n#endif"; +var common = "#define PI 3.141592653589793\n#define PI2 6.283185307179586\n#define PI_HALF 1.5707963267948966\n#define RECIPROCAL_PI 0.3183098861837907\n#define RECIPROCAL_PI2 0.15915494309189535\n#define EPSILON 1e-6\n#ifndef saturate\n#define saturate( a ) clamp( a, 0.0, 1.0 )\n#endif\n#define whiteComplement( a ) ( 1.0 - saturate( a ) )\nfloat pow2( const in float x ) { return x*x; }\nvec3 pow2( const in vec3 x ) { return x*x; }\nfloat pow3( const in float x ) { return x*x*x; }\nfloat pow4( const in float x ) { float x2 = x*x; return x2*x2; }\nfloat max3( const in vec3 v ) { return max( max( v.x, v.y ), v.z ); }\nfloat average( const in vec3 v ) { return dot( v, vec3( 0.3333333 ) ); }\nhighp float rand( const in vec2 uv ) {\n const highp float a = 12.9898, b = 78.233, c = 43758.5453;\n highp float dt = dot( uv.xy, vec2( a,b ) ), sn = mod( dt, PI );\n return fract( sin( sn ) * c );\n}\n#ifdef HIGH_PRECISION\n float precisionSafeLength( vec3 v ) { return length( v ); }\n#else\n float precisionSafeLength( vec3 v ) {\n float maxComponent = max3( abs( v ) );\n return length( v / maxComponent ) * maxComponent;\n }\n#endif\nstruct IncidentLight {\n vec3 color;\n vec3 direction;\n bool visible;\n};\nstruct ReflectedLight {\n vec3 directDiffuse;\n vec3 directSpecular;\n vec3 indirectDiffuse;\n vec3 indirectSpecular;\n};\n#ifdef USE_ALPHAHASH\n varying vec3 vPosition;\n#endif\nvec3 transformDirection( in vec3 dir, in mat4 matrix ) {\n return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );\n}\nvec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {\n return normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );\n}\nmat3 transposeMat3( const in mat3 m ) {\n mat3 tmp;\n tmp[ 0 ] = vec3( m[ 0 ].x, m[ 1 ].x, m[ 2 ].x );\n tmp[ 1 ] = vec3( m[ 0 ].y, m[ 1 ].y, m[ 2 ].y );\n tmp[ 2 ] = vec3( m[ 0 ].z, m[ 1 ].z, m[ 2 ].z );\n return tmp;\n}\nfloat luminance( const in vec3 rgb ) {\n const vec3 weights = vec3( 0.2126729, 0.7151522, 0.0721750 );\n return dot( weights, rgb );\n}\nbool isPerspectiveMatrix( mat4 m ) {\n return m[ 2 ][ 3 ] == - 1.0;\n}\nvec2 equirectUv( in vec3 dir ) {\n float u = atan( dir.z, dir.x ) * RECIPROCAL_PI2 + 0.5;\n float v = asin( clamp( dir.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;\n return vec2( u, v );\n}\nvec3 BRDF_Lambert( const in vec3 diffuseColor ) {\n return RECIPROCAL_PI * diffuseColor;\n}\nvec3 F_Schlick( const in vec3 f0, const in float f90, const in float dotVH ) {\n float fresnel = exp2( ( - 5.55473 * dotVH - 6.98316 ) * dotVH );\n return f0 * ( 1.0 - fresnel ) + ( f90 * fresnel );\n}\nfloat F_Schlick( const in float f0, const in float f90, const in float dotVH ) {\n float fresnel = exp2( ( - 5.55473 * dotVH - 6.98316 ) * dotVH );\n return f0 * ( 1.0 - fresnel ) + ( f90 * fresnel );\n} // validated"; +var cube_uv_reflection_fragment = "#ifdef ENVMAP_TYPE_CUBE_UV\n #define cubeUV_minMipLevel 4.0\n #define cubeUV_minTileSize 16.0\n float getFace( vec3 direction ) {\n vec3 absDirection = abs( direction );\n float face = - 1.0;\n if ( absDirection.x > absDirection.z ) {\n if ( absDirection.x > absDirection.y )\n face = direction.x > 0.0 ? 0.0 : 3.0;\n else\n face = direction.y > 0.0 ? 1.0 : 4.0;\n } else {\n if ( absDirection.z > absDirection.y )\n face = direction.z > 0.0 ? 2.0 : 5.0;\n else\n face = direction.y > 0.0 ? 1.0 : 4.0;\n }\n return face;\n }\n vec2 getUV( vec3 direction, float face ) {\n vec2 uv;\n if ( face == 0.0 ) {\n uv = vec2( direction.z, direction.y ) / abs( direction.x );\n } else if ( face == 1.0 ) {\n uv = vec2( - direction.x, - direction.z ) / abs( direction.y );\n } else if ( face == 2.0 ) {\n uv = vec2( - direction.x, direction.y ) / abs( direction.z );\n } else if ( face == 3.0 ) {\n uv = vec2( - direction.z, direction.y ) / abs( direction.x );\n } else if ( face == 4.0 ) {\n uv = vec2( - direction.x, direction.z ) / abs( direction.y );\n } else {\n uv = vec2( direction.x, direction.y ) / abs( direction.z );\n }\n return 0.5 * ( uv + 1.0 );\n }\n vec3 bilinearCubeUV( sampler2D envMap, vec3 direction, float mipInt ) {\n float face = getFace( direction );\n float filterInt = max( cubeUV_minMipLevel - mipInt, 0.0 );\n mipInt = max( mipInt, cubeUV_minMipLevel );\n float faceSize = exp2( mipInt );\n highp vec2 uv = getUV( direction, face ) * ( faceSize - 2.0 ) + 1.0;\n if ( face > 2.0 ) {\n uv.y += faceSize;\n face -= 3.0;\n }\n uv.x += face * faceSize;\n uv.x += filterInt * 3.0 * cubeUV_minTileSize;\n uv.y += 4.0 * ( exp2( CUBEUV_MAX_MIP ) - faceSize );\n uv.x *= CUBEUV_TEXEL_WIDTH;\n uv.y *= CUBEUV_TEXEL_HEIGHT;\n #ifdef texture2DGradEXT\n return texture2DGradEXT( envMap, uv, vec2( 0.0 ), vec2( 0.0 ) ).rgb;\n #else\n return texture2D( envMap, uv ).rgb;\n #endif\n }\n #define cubeUV_r0 1.0\n #define cubeUV_m0 - 2.0\n #define cubeUV_r1 0.8\n #define cubeUV_m1 - 1.0\n #define cubeUV_r4 0.4\n #define cubeUV_m4 2.0\n #define cubeUV_r5 0.305\n #define cubeUV_m5 3.0\n #define cubeUV_r6 0.21\n #define cubeUV_m6 4.0\n float roughnessToMip( float roughness ) {\n float mip = 0.0;\n if ( roughness >= cubeUV_r1 ) {\n mip = ( cubeUV_r0 - roughness ) * ( cubeUV_m1 - cubeUV_m0 ) / ( cubeUV_r0 - cubeUV_r1 ) + cubeUV_m0;\n } else if ( roughness >= cubeUV_r4 ) {\n mip = ( cubeUV_r1 - roughness ) * ( cubeUV_m4 - cubeUV_m1 ) / ( cubeUV_r1 - cubeUV_r4 ) + cubeUV_m1;\n } else if ( roughness >= cubeUV_r5 ) {\n mip = ( cubeUV_r4 - roughness ) * ( cubeUV_m5 - cubeUV_m4 ) / ( cubeUV_r4 - cubeUV_r5 ) + cubeUV_m4;\n } else if ( roughness >= cubeUV_r6 ) {\n mip = ( cubeUV_r5 - roughness ) * ( cubeUV_m6 - cubeUV_m5 ) / ( cubeUV_r5 - cubeUV_r6 ) + cubeUV_m5;\n } else {\n mip = - 2.0 * log2( 1.16 * roughness ); }\n return mip;\n }\n vec4 textureCubeUV( sampler2D envMap, vec3 sampleDir, float roughness ) {\n float mip = clamp( roughnessToMip( roughness ), cubeUV_m0, CUBEUV_MAX_MIP );\n float mipF = fract( mip );\n float mipInt = floor( mip );\n vec3 color0 = bilinearCubeUV( envMap, sampleDir, mipInt );\n if ( mipF == 0.0 ) {\n return vec4( color0, 1.0 );\n } else {\n vec3 color1 = bilinearCubeUV( envMap, sampleDir, mipInt + 1.0 );\n return vec4( mix( color0, color1, mipF ), 1.0 );\n }\n }\n#endif"; +var defaultnormal_vertex = "vec3 transformedNormal = objectNormal;\n#ifdef USE_TANGENT\n vec3 transformedTangent = objectTangent;\n#endif\n#ifdef USE_BATCHING\n mat3 bm = mat3( batchingMatrix );\n transformedNormal /= vec3( dot( bm[ 0 ], bm[ 0 ] ), dot( bm[ 1 ], bm[ 1 ] ), dot( bm[ 2 ], bm[ 2 ] ) );\n transformedNormal = bm * transformedNormal;\n #ifdef USE_TANGENT\n transformedTangent = bm * transformedTangent;\n #endif\n#endif\n#ifdef USE_INSTANCING\n mat3 im = mat3( instanceMatrix );\n transformedNormal /= vec3( dot( im[ 0 ], im[ 0 ] ), dot( im[ 1 ], im[ 1 ] ), dot( im[ 2 ], im[ 2 ] ) );\n transformedNormal = im * transformedNormal;\n #ifdef USE_TANGENT\n transformedTangent = im * transformedTangent;\n #endif\n#endif\ntransformedNormal = normalMatrix * transformedNormal;\n#ifdef FLIP_SIDED\n transformedNormal = - transformedNormal;\n#endif\n#ifdef USE_TANGENT\n transformedTangent = ( modelViewMatrix * vec4( transformedTangent, 0.0 ) ).xyz;\n #ifdef FLIP_SIDED\n transformedTangent = - transformedTangent;\n #endif\n#endif"; +var displacementmap_pars_vertex = "#ifdef USE_DISPLACEMENTMAP\n uniform sampler2D displacementMap;\n uniform float displacementScale;\n uniform float displacementBias;\n#endif"; +var displacementmap_vertex = "#ifdef USE_DISPLACEMENTMAP\n transformed += normalize( objectNormal ) * ( texture2D( displacementMap, vDisplacementMapUv ).x * displacementScale + displacementBias );\n#endif"; +var emissivemap_fragment = "#ifdef USE_EMISSIVEMAP\n vec4 emissiveColor = texture2D( emissiveMap, vEmissiveMapUv );\n totalEmissiveRadiance *= emissiveColor.rgb;\n#endif"; +var emissivemap_pars_fragment = "#ifdef USE_EMISSIVEMAP\n uniform sampler2D emissiveMap;\n#endif"; +var colorspace_fragment = "gl_FragColor = linearToOutputTexel( gl_FragColor );"; +var colorspace_pars_fragment = "\nconst mat3 LINEAR_SRGB_TO_LINEAR_DISPLAY_P3 = mat3(\n vec3( 0.8224621, 0.177538, 0.0 ),\n vec3( 0.0331941, 0.9668058, 0.0 ),\n vec3( 0.0170827, 0.0723974, 0.9105199 )\n);\nconst mat3 LINEAR_DISPLAY_P3_TO_LINEAR_SRGB = mat3(\n vec3( 1.2249401, - 0.2249404, 0.0 ),\n vec3( - 0.0420569, 1.0420571, 0.0 ),\n vec3( - 0.0196376, - 0.0786361, 1.0982735 )\n);\nvec4 LinearSRGBToLinearDisplayP3( in vec4 value ) {\n return vec4( value.rgb * LINEAR_SRGB_TO_LINEAR_DISPLAY_P3, value.a );\n}\nvec4 LinearDisplayP3ToLinearSRGB( in vec4 value ) {\n return vec4( value.rgb * LINEAR_DISPLAY_P3_TO_LINEAR_SRGB, value.a );\n}\nvec4 LinearTransferOETF( in vec4 value ) {\n return value;\n}\nvec4 sRGBTransferOETF( in vec4 value ) {\n return vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) * 1.055 - vec3( 0.055 ), value.rgb * 12.92, vec3( lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ) ), value.a );\n}\nvec4 LinearToLinear( in vec4 value ) {\n return value;\n}\nvec4 LinearTosRGB( in vec4 value ) {\n return sRGBTransferOETF( value );\n}"; +var envmap_fragment = "#ifdef USE_ENVMAP\n #ifdef ENV_WORLDPOS\n vec3 cameraToFrag;\n if ( isOrthographic ) {\n cameraToFrag = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );\n } else {\n cameraToFrag = normalize( vWorldPosition - cameraPosition );\n }\n vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n #ifdef ENVMAP_MODE_REFLECTION\n vec3 reflectVec = reflect( cameraToFrag, worldNormal );\n #else\n vec3 reflectVec = refract( cameraToFrag, worldNormal, refractionRatio );\n #endif\n #else\n vec3 reflectVec = vReflect;\n #endif\n #ifdef ENVMAP_TYPE_CUBE\n vec4 envColor = textureCube( envMap, envMapRotation * vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );\n #else\n vec4 envColor = vec4( 0.0 );\n #endif\n #ifdef ENVMAP_BLENDING_MULTIPLY\n outgoingLight = mix( outgoingLight, outgoingLight * envColor.xyz, specularStrength * reflectivity );\n #elif defined( ENVMAP_BLENDING_MIX )\n outgoingLight = mix( outgoingLight, envColor.xyz, specularStrength * reflectivity );\n #elif defined( ENVMAP_BLENDING_ADD )\n outgoingLight += envColor.xyz * specularStrength * reflectivity;\n #endif\n#endif"; +var envmap_common_pars_fragment = "#ifdef USE_ENVMAP\n uniform float envMapIntensity;\n uniform float flipEnvMap;\n uniform mat3 envMapRotation;\n #ifdef ENVMAP_TYPE_CUBE\n uniform samplerCube envMap;\n #else\n uniform sampler2D envMap;\n #endif\n \n#endif"; +var envmap_pars_fragment = "#ifdef USE_ENVMAP\n uniform float reflectivity;\n #if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG ) || defined( LAMBERT )\n #define ENV_WORLDPOS\n #endif\n #ifdef ENV_WORLDPOS\n varying vec3 vWorldPosition;\n uniform float refractionRatio;\n #else\n varying vec3 vReflect;\n #endif\n#endif"; +var envmap_pars_vertex = "#ifdef USE_ENVMAP\n #if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG ) || defined( LAMBERT )\n #define ENV_WORLDPOS\n #endif\n #ifdef ENV_WORLDPOS\n \n varying vec3 vWorldPosition;\n #else\n varying vec3 vReflect;\n uniform float refractionRatio;\n #endif\n#endif"; +var envmap_vertex = "#ifdef USE_ENVMAP\n #ifdef ENV_WORLDPOS\n vWorldPosition = worldPosition.xyz;\n #else\n vec3 cameraToVertex;\n if ( isOrthographic ) {\n cameraToVertex = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );\n } else {\n cameraToVertex = normalize( worldPosition.xyz - cameraPosition );\n }\n vec3 worldNormal = inverseTransformDirection( transformedNormal, viewMatrix );\n #ifdef ENVMAP_MODE_REFLECTION\n vReflect = reflect( cameraToVertex, worldNormal );\n #else\n vReflect = refract( cameraToVertex, worldNormal, refractionRatio );\n #endif\n #endif\n#endif"; +var fog_vertex = "#ifdef USE_FOG\n vFogDepth = - mvPosition.z;\n#endif"; +var fog_pars_vertex = "#ifdef USE_FOG\n varying float vFogDepth;\n#endif"; +var fog_fragment = "#ifdef USE_FOG\n #ifdef FOG_EXP2\n float fogFactor = 1.0 - exp( - fogDensity * fogDensity * vFogDepth * vFogDepth );\n #else\n float fogFactor = smoothstep( fogNear, fogFar, vFogDepth );\n #endif\n gl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );\n#endif"; +var fog_pars_fragment = "#ifdef USE_FOG\n uniform vec3 fogColor;\n varying float vFogDepth;\n #ifdef FOG_EXP2\n uniform float fogDensity;\n #else\n uniform float fogNear;\n uniform float fogFar;\n #endif\n#endif"; +var gradientmap_pars_fragment = "#ifdef USE_GRADIENTMAP\n uniform sampler2D gradientMap;\n#endif\nvec3 getGradientIrradiance( vec3 normal, vec3 lightDirection ) {\n float dotNL = dot( normal, lightDirection );\n vec2 coord = vec2( dotNL * 0.5 + 0.5, 0.0 );\n #ifdef USE_GRADIENTMAP\n return vec3( texture2D( gradientMap, coord ).r );\n #else\n vec2 fw = fwidth( coord ) * 0.5;\n return mix( vec3( 0.7 ), vec3( 1.0 ), smoothstep( 0.7 - fw.x, 0.7 + fw.x, coord.x ) );\n #endif\n}"; +var lightmap_fragment = "#ifdef USE_LIGHTMAP\n vec4 lightMapTexel = texture2D( lightMap, vLightMapUv );\n vec3 lightMapIrradiance = lightMapTexel.rgb * lightMapIntensity;\n reflectedLight.indirectDiffuse += lightMapIrradiance;\n#endif"; +var lightmap_pars_fragment = "#ifdef USE_LIGHTMAP\n uniform sampler2D lightMap;\n uniform float lightMapIntensity;\n#endif"; +var lights_lambert_fragment = "LambertMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;\nmaterial.specularStrength = specularStrength;"; +var lights_lambert_pars_fragment = "varying vec3 vViewPosition;\nstruct LambertMaterial {\n vec3 diffuseColor;\n float specularStrength;\n};\nvoid RE_Direct_Lambert( const in IncidentLight directLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in LambertMaterial material, inout ReflectedLight reflectedLight ) {\n float dotNL = saturate( dot( geometryNormal, directLight.direction ) );\n vec3 irradiance = dotNL * directLight.color;\n reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectDiffuse_Lambert( const in vec3 irradiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in LambertMaterial material, inout ReflectedLight reflectedLight ) {\n reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\n#define RE_Direct RE_Direct_Lambert\n#define RE_IndirectDiffuse RE_IndirectDiffuse_Lambert"; +var lights_pars_begin = "uniform bool receiveShadow;\nuniform vec3 ambientLightColor;\n#if defined( USE_LIGHT_PROBES )\n uniform vec3 lightProbe[ 9 ];\n#endif\nvec3 shGetIrradianceAt( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {\n float x = normal.x, y = normal.y, z = normal.z;\n vec3 result = shCoefficients[ 0 ] * 0.886227;\n result += shCoefficients[ 1 ] * 2.0 * 0.511664 * y;\n result += shCoefficients[ 2 ] * 2.0 * 0.511664 * z;\n result += shCoefficients[ 3 ] * 2.0 * 0.511664 * x;\n result += shCoefficients[ 4 ] * 2.0 * 0.429043 * x * y;\n result += shCoefficients[ 5 ] * 2.0 * 0.429043 * y * z;\n result += shCoefficients[ 6 ] * ( 0.743125 * z * z - 0.247708 );\n result += shCoefficients[ 7 ] * 2.0 * 0.429043 * x * z;\n result += shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );\n return result;\n}\nvec3 getLightProbeIrradiance( const in vec3 lightProbe[ 9 ], const in vec3 normal ) {\n vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n vec3 irradiance = shGetIrradianceAt( worldNormal, lightProbe );\n return irradiance;\n}\nvec3 getAmbientLightIrradiance( const in vec3 ambientLightColor ) {\n vec3 irradiance = ambientLightColor;\n return irradiance;\n}\nfloat getDistanceAttenuation( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {\n #if defined ( LEGACY_LIGHTS )\n if ( cutoffDistance > 0.0 && decayExponent > 0.0 ) {\n return pow( saturate( - lightDistance / cutoffDistance + 1.0 ), decayExponent );\n }\n return 1.0;\n #else\n float distanceFalloff = 1.0 / max( pow( lightDistance, decayExponent ), 0.01 );\n if ( cutoffDistance > 0.0 ) {\n distanceFalloff *= pow2( saturate( 1.0 - pow4( lightDistance / cutoffDistance ) ) );\n }\n return distanceFalloff;\n #endif\n}\nfloat getSpotAttenuation( const in float coneCosine, const in float penumbraCosine, const in float angleCosine ) {\n return smoothstep( coneCosine, penumbraCosine, angleCosine );\n}\n#if NUM_DIR_LIGHTS > 0\n struct DirectionalLight {\n vec3 direction;\n vec3 color;\n };\n uniform DirectionalLight directionalLights[ NUM_DIR_LIGHTS ];\n void getDirectionalLightInfo( const in DirectionalLight directionalLight, out IncidentLight light ) {\n light.color = directionalLight.color;\n light.direction = directionalLight.direction;\n light.visible = true;\n }\n#endif\n#if NUM_POINT_LIGHTS > 0\n struct PointLight {\n vec3 position;\n vec3 color;\n float distance;\n float decay;\n };\n uniform PointLight pointLights[ NUM_POINT_LIGHTS ];\n void getPointLightInfo( const in PointLight pointLight, const in vec3 geometryPosition, out IncidentLight light ) {\n vec3 lVector = pointLight.position - geometryPosition;\n light.direction = normalize( lVector );\n float lightDistance = length( lVector );\n light.color = pointLight.color;\n light.color *= getDistanceAttenuation( lightDistance, pointLight.distance, pointLight.decay );\n light.visible = ( light.color != vec3( 0.0 ) );\n }\n#endif\n#if NUM_SPOT_LIGHTS > 0\n struct SpotLight {\n vec3 position;\n vec3 direction;\n vec3 color;\n float distance;\n float decay;\n float coneCos;\n float penumbraCos;\n };\n uniform SpotLight spotLights[ NUM_SPOT_LIGHTS ];\n void getSpotLightInfo( const in SpotLight spotLight, const in vec3 geometryPosition, out IncidentLight light ) {\n vec3 lVector = spotLight.position - geometryPosition;\n light.direction = normalize( lVector );\n float angleCos = dot( light.direction, spotLight.direction );\n float spotAttenuation = getSpotAttenuation( spotLight.coneCos, spotLight.penumbraCos, angleCos );\n if ( spotAttenuation > 0.0 ) {\n float lightDistance = length( lVector );\n light.color = spotLight.color * spotAttenuation;\n light.color *= getDistanceAttenuation( lightDistance, spotLight.distance, spotLight.decay );\n light.visible = ( light.color != vec3( 0.0 ) );\n } else {\n light.color = vec3( 0.0 );\n light.visible = false;\n }\n }\n#endif\n#if NUM_RECT_AREA_LIGHTS > 0\n struct RectAreaLight {\n vec3 color;\n vec3 position;\n vec3 halfWidth;\n vec3 halfHeight;\n };\n uniform sampler2D ltc_1; uniform sampler2D ltc_2;\n uniform RectAreaLight rectAreaLights[ NUM_RECT_AREA_LIGHTS ];\n#endif\n#if NUM_HEMI_LIGHTS > 0\n struct HemisphereLight {\n vec3 direction;\n vec3 skyColor;\n vec3 groundColor;\n };\n uniform HemisphereLight hemisphereLights[ NUM_HEMI_LIGHTS ];\n vec3 getHemisphereLightIrradiance( const in HemisphereLight hemiLight, const in vec3 normal ) {\n float dotNL = dot( normal, hemiLight.direction );\n float hemiDiffuseWeight = 0.5 * dotNL + 0.5;\n vec3 irradiance = mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );\n return irradiance;\n }\n#endif"; +var envmap_physical_pars_fragment = "#ifdef USE_ENVMAP\n vec3 getIBLIrradiance( const in vec3 normal ) {\n #ifdef ENVMAP_TYPE_CUBE_UV\n vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n vec4 envMapColor = textureCubeUV( envMap, envMapRotation * worldNormal, 1.0 );\n return PI * envMapColor.rgb * envMapIntensity;\n #else\n return vec3( 0.0 );\n #endif\n }\n vec3 getIBLRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness ) {\n #ifdef ENVMAP_TYPE_CUBE_UV\n vec3 reflectVec = reflect( - viewDir, normal );\n reflectVec = normalize( mix( reflectVec, normal, roughness * roughness) );\n reflectVec = inverseTransformDirection( reflectVec, viewMatrix );\n vec4 envMapColor = textureCubeUV( envMap, envMapRotation * reflectVec, roughness );\n return envMapColor.rgb * envMapIntensity;\n #else\n return vec3( 0.0 );\n #endif\n }\n #ifdef USE_ANISOTROPY\n vec3 getIBLAnisotropyRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness, const in vec3 bitangent, const in float anisotropy ) {\n #ifdef ENVMAP_TYPE_CUBE_UV\n vec3 bentNormal = cross( bitangent, viewDir );\n bentNormal = normalize( cross( bentNormal, bitangent ) );\n bentNormal = normalize( mix( bentNormal, normal, pow2( pow2( 1.0 - anisotropy * ( 1.0 - roughness ) ) ) ) );\n return getIBLRadiance( viewDir, bentNormal, roughness );\n #else\n return vec3( 0.0 );\n #endif\n }\n #endif\n#endif"; +var lights_toon_fragment = "ToonMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;"; +var lights_toon_pars_fragment = "varying vec3 vViewPosition;\nstruct ToonMaterial {\n vec3 diffuseColor;\n};\nvoid RE_Direct_Toon( const in IncidentLight directLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {\n vec3 irradiance = getGradientIrradiance( geometryNormal, directLight.direction ) * directLight.color;\n reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectDiffuse_Toon( const in vec3 irradiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {\n reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\n#define RE_Direct RE_Direct_Toon\n#define RE_IndirectDiffuse RE_IndirectDiffuse_Toon"; +var lights_phong_fragment = "BlinnPhongMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;\nmaterial.specularColor = specular;\nmaterial.specularShininess = shininess;\nmaterial.specularStrength = specularStrength;"; +var lights_phong_pars_fragment = "varying vec3 vViewPosition;\nstruct BlinnPhongMaterial {\n vec3 diffuseColor;\n vec3 specularColor;\n float specularShininess;\n float specularStrength;\n};\nvoid RE_Direct_BlinnPhong( const in IncidentLight directLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n float dotNL = saturate( dot( geometryNormal, directLight.direction ) );\n vec3 irradiance = dotNL * directLight.color;\n reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n reflectedLight.directSpecular += irradiance * BRDF_BlinnPhong( directLight.direction, geometryViewDir, geometryNormal, material.specularColor, material.specularShininess ) * material.specularStrength;\n}\nvoid RE_IndirectDiffuse_BlinnPhong( const in vec3 irradiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\n#define RE_Direct RE_Direct_BlinnPhong\n#define RE_IndirectDiffuse RE_IndirectDiffuse_BlinnPhong"; +var lights_physical_fragment = "PhysicalMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb * ( 1.0 - metalnessFactor );\nvec3 dxy = max( abs( dFdx( nonPerturbedNormal ) ), abs( dFdy( nonPerturbedNormal ) ) );\nfloat geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );\nmaterial.roughness = max( roughnessFactor, 0.0525 );material.roughness += geometryRoughness;\nmaterial.roughness = min( material.roughness, 1.0 );\n#ifdef IOR\n material.ior = ior;\n #ifdef USE_SPECULAR\n float specularIntensityFactor = specularIntensity;\n vec3 specularColorFactor = specularColor;\n #ifdef USE_SPECULAR_COLORMAP\n specularColorFactor *= texture2D( specularColorMap, vSpecularColorMapUv ).rgb;\n #endif\n #ifdef USE_SPECULAR_INTENSITYMAP\n specularIntensityFactor *= texture2D( specularIntensityMap, vSpecularIntensityMapUv ).a;\n #endif\n material.specularF90 = mix( specularIntensityFactor, 1.0, metalnessFactor );\n #else\n float specularIntensityFactor = 1.0;\n vec3 specularColorFactor = vec3( 1.0 );\n material.specularF90 = 1.0;\n #endif\n material.specularColor = mix( min( pow2( ( material.ior - 1.0 ) / ( material.ior + 1.0 ) ) * specularColorFactor, vec3( 1.0 ) ) * specularIntensityFactor, diffuseColor.rgb, metalnessFactor );\n#else\n material.specularColor = mix( vec3( 0.04 ), diffuseColor.rgb, metalnessFactor );\n material.specularF90 = 1.0;\n#endif\n#ifdef USE_CLEARCOAT\n material.clearcoat = clearcoat;\n material.clearcoatRoughness = clearcoatRoughness;\n material.clearcoatF0 = vec3( 0.04 );\n material.clearcoatF90 = 1.0;\n #ifdef USE_CLEARCOATMAP\n material.clearcoat *= texture2D( clearcoatMap, vClearcoatMapUv ).x;\n #endif\n #ifdef USE_CLEARCOAT_ROUGHNESSMAP\n material.clearcoatRoughness *= texture2D( clearcoatRoughnessMap, vClearcoatRoughnessMapUv ).y;\n #endif\n material.clearcoat = saturate( material.clearcoat ); material.clearcoatRoughness = max( material.clearcoatRoughness, 0.0525 );\n material.clearcoatRoughness += geometryRoughness;\n material.clearcoatRoughness = min( material.clearcoatRoughness, 1.0 );\n#endif\n#ifdef USE_IRIDESCENCE\n material.iridescence = iridescence;\n material.iridescenceIOR = iridescenceIOR;\n #ifdef USE_IRIDESCENCEMAP\n material.iridescence *= texture2D( iridescenceMap, vIridescenceMapUv ).r;\n #endif\n #ifdef USE_IRIDESCENCE_THICKNESSMAP\n material.iridescenceThickness = (iridescenceThicknessMaximum - iridescenceThicknessMinimum) * texture2D( iridescenceThicknessMap, vIridescenceThicknessMapUv ).g + iridescenceThicknessMinimum;\n #else\n material.iridescenceThickness = iridescenceThicknessMaximum;\n #endif\n#endif\n#ifdef USE_SHEEN\n material.sheenColor = sheenColor;\n #ifdef USE_SHEEN_COLORMAP\n material.sheenColor *= texture2D( sheenColorMap, vSheenColorMapUv ).rgb;\n #endif\n material.sheenRoughness = clamp( sheenRoughness, 0.07, 1.0 );\n #ifdef USE_SHEEN_ROUGHNESSMAP\n material.sheenRoughness *= texture2D( sheenRoughnessMap, vSheenRoughnessMapUv ).a;\n #endif\n#endif\n#ifdef USE_ANISOTROPY\n #ifdef USE_ANISOTROPYMAP\n mat2 anisotropyMat = mat2( anisotropyVector.x, anisotropyVector.y, - anisotropyVector.y, anisotropyVector.x );\n vec3 anisotropyPolar = texture2D( anisotropyMap, vAnisotropyMapUv ).rgb;\n vec2 anisotropyV = anisotropyMat * normalize( 2.0 * anisotropyPolar.rg - vec2( 1.0 ) ) * anisotropyPolar.b;\n #else\n vec2 anisotropyV = anisotropyVector;\n #endif\n material.anisotropy = length( anisotropyV );\n if( material.anisotropy == 0.0 ) {\n anisotropyV = vec2( 1.0, 0.0 );\n } else {\n anisotropyV /= material.anisotropy;\n material.anisotropy = saturate( material.anisotropy );\n }\n material.alphaT = mix( pow2( material.roughness ), 1.0, pow2( material.anisotropy ) );\n material.anisotropyT = tbn[ 0 ] * anisotropyV.x + tbn[ 1 ] * anisotropyV.y;\n material.anisotropyB = tbn[ 1 ] * anisotropyV.x - tbn[ 0 ] * anisotropyV.y;\n#endif"; +var lights_physical_pars_fragment = "struct PhysicalMaterial {\n vec3 diffuseColor;\n float roughness;\n vec3 specularColor;\n float specularF90;\n #ifdef USE_CLEARCOAT\n float clearcoat;\n float clearcoatRoughness;\n vec3 clearcoatF0;\n float clearcoatF90;\n #endif\n #ifdef USE_IRIDESCENCE\n float iridescence;\n float iridescenceIOR;\n float iridescenceThickness;\n vec3 iridescenceFresnel;\n vec3 iridescenceF0;\n #endif\n #ifdef USE_SHEEN\n vec3 sheenColor;\n float sheenRoughness;\n #endif\n #ifdef IOR\n float ior;\n #endif\n #ifdef USE_TRANSMISSION\n float transmission;\n float transmissionAlpha;\n float thickness;\n float attenuationDistance;\n vec3 attenuationColor;\n #endif\n #ifdef USE_ANISOTROPY\n float anisotropy;\n float alphaT;\n vec3 anisotropyT;\n vec3 anisotropyB;\n #endif\n};\nvec3 clearcoatSpecularDirect = vec3( 0.0 );\nvec3 clearcoatSpecularIndirect = vec3( 0.0 );\nvec3 sheenSpecularDirect = vec3( 0.0 );\nvec3 sheenSpecularIndirect = vec3(0.0 );\nvec3 Schlick_to_F0( const in vec3 f, const in float f90, const in float dotVH ) {\n float x = clamp( 1.0 - dotVH, 0.0, 1.0 );\n float x2 = x * x;\n float x5 = clamp( x * x2 * x2, 0.0, 0.9999 );\n return ( f - vec3( f90 ) * x5 ) / ( 1.0 - x5 );\n}\nfloat V_GGX_SmithCorrelated( const in float alpha, const in float dotNL, const in float dotNV ) {\n float a2 = pow2( alpha );\n float gv = dotNL * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );\n float gl = dotNV * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );\n return 0.5 / max( gv + gl, EPSILON );\n}\nfloat D_GGX( const in float alpha, const in float dotNH ) {\n float a2 = pow2( alpha );\n float denom = pow2( dotNH ) * ( a2 - 1.0 ) + 1.0;\n return RECIPROCAL_PI * a2 / pow2( denom );\n}\n#ifdef USE_ANISOTROPY\n float V_GGX_SmithCorrelated_Anisotropic( const in float alphaT, const in float alphaB, const in float dotTV, const in float dotBV, const in float dotTL, const in float dotBL, const in float dotNV, const in float dotNL ) {\n float gv = dotNL * length( vec3( alphaT * dotTV, alphaB * dotBV, dotNV ) );\n float gl = dotNV * length( vec3( alphaT * dotTL, alphaB * dotBL, dotNL ) );\n float v = 0.5 / ( gv + gl );\n return saturate(v);\n }\n float D_GGX_Anisotropic( const in float alphaT, const in float alphaB, const in float dotNH, const in float dotTH, const in float dotBH ) {\n float a2 = alphaT * alphaB;\n highp vec3 v = vec3( alphaB * dotTH, alphaT * dotBH, a2 * dotNH );\n highp float v2 = dot( v, v );\n float w2 = a2 / v2;\n return RECIPROCAL_PI * a2 * pow2 ( w2 );\n }\n#endif\n#ifdef USE_CLEARCOAT\n vec3 BRDF_GGX_Clearcoat( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in PhysicalMaterial material) {\n vec3 f0 = material.clearcoatF0;\n float f90 = material.clearcoatF90;\n float roughness = material.clearcoatRoughness;\n float alpha = pow2( roughness );\n vec3 halfDir = normalize( lightDir + viewDir );\n float dotNL = saturate( dot( normal, lightDir ) );\n float dotNV = saturate( dot( normal, viewDir ) );\n float dotNH = saturate( dot( normal, halfDir ) );\n float dotVH = saturate( dot( viewDir, halfDir ) );\n vec3 F = F_Schlick( f0, f90, dotVH );\n float V = V_GGX_SmithCorrelated( alpha, dotNL, dotNV );\n float D = D_GGX( alpha, dotNH );\n return F * ( V * D );\n }\n#endif\nvec3 BRDF_GGX( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in PhysicalMaterial material ) {\n vec3 f0 = material.specularColor;\n float f90 = material.specularF90;\n float roughness = material.roughness;\n float alpha = pow2( roughness );\n vec3 halfDir = normalize( lightDir + viewDir );\n float dotNL = saturate( dot( normal, lightDir ) );\n float dotNV = saturate( dot( normal, viewDir ) );\n float dotNH = saturate( dot( normal, halfDir ) );\n float dotVH = saturate( dot( viewDir, halfDir ) );\n vec3 F = F_Schlick( f0, f90, dotVH );\n #ifdef USE_IRIDESCENCE\n F = mix( F, material.iridescenceFresnel, material.iridescence );\n #endif\n #ifdef USE_ANISOTROPY\n float dotTL = dot( material.anisotropyT, lightDir );\n float dotTV = dot( material.anisotropyT, viewDir );\n float dotTH = dot( material.anisotropyT, halfDir );\n float dotBL = dot( material.anisotropyB, lightDir );\n float dotBV = dot( material.anisotropyB, viewDir );\n float dotBH = dot( material.anisotropyB, halfDir );\n float V = V_GGX_SmithCorrelated_Anisotropic( material.alphaT, alpha, dotTV, dotBV, dotTL, dotBL, dotNV, dotNL );\n float D = D_GGX_Anisotropic( material.alphaT, alpha, dotNH, dotTH, dotBH );\n #else\n float V = V_GGX_SmithCorrelated( alpha, dotNL, dotNV );\n float D = D_GGX( alpha, dotNH );\n #endif\n return F * ( V * D );\n}\nvec2 LTC_Uv( const in vec3 N, const in vec3 V, const in float roughness ) {\n const float LUT_SIZE = 64.0;\n const float LUT_SCALE = ( LUT_SIZE - 1.0 ) / LUT_SIZE;\n const float LUT_BIAS = 0.5 / LUT_SIZE;\n float dotNV = saturate( dot( N, V ) );\n vec2 uv = vec2( roughness, sqrt( 1.0 - dotNV ) );\n uv = uv * LUT_SCALE + LUT_BIAS;\n return uv;\n}\nfloat LTC_ClippedSphereFormFactor( const in vec3 f ) {\n float l = length( f );\n return max( ( l * l + f.z ) / ( l + 1.0 ), 0.0 );\n}\nvec3 LTC_EdgeVectorFormFactor( const in vec3 v1, const in vec3 v2 ) {\n float x = dot( v1, v2 );\n float y = abs( x );\n float a = 0.8543985 + ( 0.4965155 + 0.0145206 * y ) * y;\n float b = 3.4175940 + ( 4.1616724 + y ) * y;\n float v = a / b;\n float theta_sintheta = ( x > 0.0 ) ? v : 0.5 * inversesqrt( max( 1.0 - x * x, 1e-7 ) ) - v;\n return cross( v1, v2 ) * theta_sintheta;\n}\nvec3 LTC_Evaluate( const in vec3 N, const in vec3 V, const in vec3 P, const in mat3 mInv, const in vec3 rectCoords[ 4 ] ) {\n vec3 v1 = rectCoords[ 1 ] - rectCoords[ 0 ];\n vec3 v2 = rectCoords[ 3 ] - rectCoords[ 0 ];\n vec3 lightNormal = cross( v1, v2 );\n if( dot( lightNormal, P - rectCoords[ 0 ] ) < 0.0 ) return vec3( 0.0 );\n vec3 T1, T2;\n T1 = normalize( V - N * dot( V, N ) );\n T2 = - cross( N, T1 );\n mat3 mat = mInv * transposeMat3( mat3( T1, T2, N ) );\n vec3 coords[ 4 ];\n coords[ 0 ] = mat * ( rectCoords[ 0 ] - P );\n coords[ 1 ] = mat * ( rectCoords[ 1 ] - P );\n coords[ 2 ] = mat * ( rectCoords[ 2 ] - P );\n coords[ 3 ] = mat * ( rectCoords[ 3 ] - P );\n coords[ 0 ] = normalize( coords[ 0 ] );\n coords[ 1 ] = normalize( coords[ 1 ] );\n coords[ 2 ] = normalize( coords[ 2 ] );\n coords[ 3 ] = normalize( coords[ 3 ] );\n vec3 vectorFormFactor = vec3( 0.0 );\n vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 0 ], coords[ 1 ] );\n vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 1 ], coords[ 2 ] );\n vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 2 ], coords[ 3 ] );\n vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 3 ], coords[ 0 ] );\n float result = LTC_ClippedSphereFormFactor( vectorFormFactor );\n return vec3( result );\n}\n#if defined( USE_SHEEN )\nfloat D_Charlie( float roughness, float dotNH ) {\n float alpha = pow2( roughness );\n float invAlpha = 1.0 / alpha;\n float cos2h = dotNH * dotNH;\n float sin2h = max( 1.0 - cos2h, 0.0078125 );\n return ( 2.0 + invAlpha ) * pow( sin2h, invAlpha * 0.5 ) / ( 2.0 * PI );\n}\nfloat V_Neubelt( float dotNV, float dotNL ) {\n return saturate( 1.0 / ( 4.0 * ( dotNL + dotNV - dotNL * dotNV ) ) );\n}\nvec3 BRDF_Sheen( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, vec3 sheenColor, const in float sheenRoughness ) {\n vec3 halfDir = normalize( lightDir + viewDir );\n float dotNL = saturate( dot( normal, lightDir ) );\n float dotNV = saturate( dot( normal, viewDir ) );\n float dotNH = saturate( dot( normal, halfDir ) );\n float D = D_Charlie( sheenRoughness, dotNH );\n float V = V_Neubelt( dotNV, dotNL );\n return sheenColor * ( D * V );\n}\n#endif\nfloat IBLSheenBRDF( const in vec3 normal, const in vec3 viewDir, const in float roughness ) {\n float dotNV = saturate( dot( normal, viewDir ) );\n float r2 = roughness * roughness;\n float a = roughness < 0.25 ? -339.2 * r2 + 161.4 * roughness - 25.9 : -8.48 * r2 + 14.3 * roughness - 9.95;\n float b = roughness < 0.25 ? 44.0 * r2 - 23.7 * roughness + 3.26 : 1.97 * r2 - 3.27 * roughness + 0.72;\n float DG = exp( a * dotNV + b ) + ( roughness < 0.25 ? 0.0 : 0.1 * ( roughness - 0.25 ) );\n return saturate( DG * RECIPROCAL_PI );\n}\nvec2 DFGApprox( const in vec3 normal, const in vec3 viewDir, const in float roughness ) {\n float dotNV = saturate( dot( normal, viewDir ) );\n const vec4 c0 = vec4( - 1, - 0.0275, - 0.572, 0.022 );\n const vec4 c1 = vec4( 1, 0.0425, 1.04, - 0.04 );\n vec4 r = roughness * c0 + c1;\n float a004 = min( r.x * r.x, exp2( - 9.28 * dotNV ) ) * r.x + r.y;\n vec2 fab = vec2( - 1.04, 1.04 ) * a004 + r.zw;\n return fab;\n}\nvec3 EnvironmentBRDF( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness ) {\n vec2 fab = DFGApprox( normal, viewDir, roughness );\n return specularColor * fab.x + specularF90 * fab.y;\n}\n#ifdef USE_IRIDESCENCE\nvoid computeMultiscatteringIridescence( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float iridescence, const in vec3 iridescenceF0, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {\n#else\nvoid computeMultiscattering( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {\n#endif\n vec2 fab = DFGApprox( normal, viewDir, roughness );\n #ifdef USE_IRIDESCENCE\n vec3 Fr = mix( specularColor, iridescenceF0, iridescence );\n #else\n vec3 Fr = specularColor;\n #endif\n vec3 FssEss = Fr * fab.x + specularF90 * fab.y;\n float Ess = fab.x + fab.y;\n float Ems = 1.0 - Ess;\n vec3 Favg = Fr + ( 1.0 - Fr ) * 0.047619; vec3 Fms = FssEss * Favg / ( 1.0 - Ems * Favg );\n singleScatter += FssEss;\n multiScatter += Fms * Ems;\n}\n#if NUM_RECT_AREA_LIGHTS > 0\n void RE_Direct_RectArea_Physical( const in RectAreaLight rectAreaLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n vec3 normal = geometryNormal;\n vec3 viewDir = geometryViewDir;\n vec3 position = geometryPosition;\n vec3 lightPos = rectAreaLight.position;\n vec3 halfWidth = rectAreaLight.halfWidth;\n vec3 halfHeight = rectAreaLight.halfHeight;\n vec3 lightColor = rectAreaLight.color;\n float roughness = material.roughness;\n vec3 rectCoords[ 4 ];\n rectCoords[ 0 ] = lightPos + halfWidth - halfHeight; rectCoords[ 1 ] = lightPos - halfWidth - halfHeight;\n rectCoords[ 2 ] = lightPos - halfWidth + halfHeight;\n rectCoords[ 3 ] = lightPos + halfWidth + halfHeight;\n vec2 uv = LTC_Uv( normal, viewDir, roughness );\n vec4 t1 = texture2D( ltc_1, uv );\n vec4 t2 = texture2D( ltc_2, uv );\n mat3 mInv = mat3(\n vec3( t1.x, 0, t1.y ),\n vec3( 0, 1, 0 ),\n vec3( t1.z, 0, t1.w )\n );\n vec3 fresnel = ( material.specularColor * t2.x + ( vec3( 1.0 ) - material.specularColor ) * t2.y );\n reflectedLight.directSpecular += lightColor * fresnel * LTC_Evaluate( normal, viewDir, position, mInv, rectCoords );\n reflectedLight.directDiffuse += lightColor * material.diffuseColor * LTC_Evaluate( normal, viewDir, position, mat3( 1.0 ), rectCoords );\n }\n#endif\nvoid RE_Direct_Physical( const in IncidentLight directLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n float dotNL = saturate( dot( geometryNormal, directLight.direction ) );\n vec3 irradiance = dotNL * directLight.color;\n #ifdef USE_CLEARCOAT\n float dotNLcc = saturate( dot( geometryClearcoatNormal, directLight.direction ) );\n vec3 ccIrradiance = dotNLcc * directLight.color;\n clearcoatSpecularDirect += ccIrradiance * BRDF_GGX_Clearcoat( directLight.direction, geometryViewDir, geometryClearcoatNormal, material );\n #endif\n #ifdef USE_SHEEN\n sheenSpecularDirect += irradiance * BRDF_Sheen( directLight.direction, geometryViewDir, geometryNormal, material.sheenColor, material.sheenRoughness );\n #endif\n reflectedLight.directSpecular += irradiance * BRDF_GGX( directLight.direction, geometryViewDir, geometryNormal, material );\n reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectDiffuse_Physical( const in vec3 irradiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectSpecular_Physical( const in vec3 radiance, const in vec3 irradiance, const in vec3 clearcoatRadiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {\n #ifdef USE_CLEARCOAT\n clearcoatSpecularIndirect += clearcoatRadiance * EnvironmentBRDF( geometryClearcoatNormal, geometryViewDir, material.clearcoatF0, material.clearcoatF90, material.clearcoatRoughness );\n #endif\n #ifdef USE_SHEEN\n sheenSpecularIndirect += irradiance * material.sheenColor * IBLSheenBRDF( geometryNormal, geometryViewDir, material.sheenRoughness );\n #endif\n vec3 singleScattering = vec3( 0.0 );\n vec3 multiScattering = vec3( 0.0 );\n vec3 cosineWeightedIrradiance = irradiance * RECIPROCAL_PI;\n #ifdef USE_IRIDESCENCE\n computeMultiscatteringIridescence( geometryNormal, geometryViewDir, material.specularColor, material.specularF90, material.iridescence, material.iridescenceFresnel, material.roughness, singleScattering, multiScattering );\n #else\n computeMultiscattering( geometryNormal, geometryViewDir, material.specularColor, material.specularF90, material.roughness, singleScattering, multiScattering );\n #endif\n vec3 totalScattering = singleScattering + multiScattering;\n vec3 diffuse = material.diffuseColor * ( 1.0 - max( max( totalScattering.r, totalScattering.g ), totalScattering.b ) );\n reflectedLight.indirectSpecular += radiance * singleScattering;\n reflectedLight.indirectSpecular += multiScattering * cosineWeightedIrradiance;\n reflectedLight.indirectDiffuse += diffuse * cosineWeightedIrradiance;\n}\n#define RE_Direct RE_Direct_Physical\n#define RE_Direct_RectArea RE_Direct_RectArea_Physical\n#define RE_IndirectDiffuse RE_IndirectDiffuse_Physical\n#define RE_IndirectSpecular RE_IndirectSpecular_Physical\nfloat computeSpecularOcclusion( const in float dotNV, const in float ambientOcclusion, const in float roughness ) {\n return saturate( pow( dotNV + ambientOcclusion, exp2( - 16.0 * roughness - 1.0 ) ) - 1.0 + ambientOcclusion );\n}"; +var lights_fragment_begin = "\nvec3 geometryPosition = - vViewPosition;\nvec3 geometryNormal = normal;\nvec3 geometryViewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( vViewPosition );\nvec3 geometryClearcoatNormal = vec3( 0.0 );\n#ifdef USE_CLEARCOAT\n geometryClearcoatNormal = clearcoatNormal;\n#endif\n#ifdef USE_IRIDESCENCE\n float dotNVi = saturate( dot( normal, geometryViewDir ) );\n if ( material.iridescenceThickness == 0.0 ) {\n material.iridescence = 0.0;\n } else {\n material.iridescence = saturate( material.iridescence );\n }\n if ( material.iridescence > 0.0 ) {\n material.iridescenceFresnel = evalIridescence( 1.0, material.iridescenceIOR, dotNVi, material.iridescenceThickness, material.specularColor );\n material.iridescenceF0 = Schlick_to_F0( material.iridescenceFresnel, 1.0, dotNVi );\n }\n#endif\nIncidentLight directLight;\n#if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )\n PointLight pointLight;\n #if defined( USE_SHADOWMAP ) && NUM_POINT_LIGHT_SHADOWS > 0\n PointLightShadow pointLightShadow;\n #endif\n #pragma unroll_loop_start\n for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n pointLight = pointLights[ i ];\n getPointLightInfo( pointLight, geometryPosition, directLight );\n #if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_POINT_LIGHT_SHADOWS )\n pointLightShadow = pointLightShadows[ i ];\n directLight.color *= ( directLight.visible && receiveShadow ) ? getPointShadow( pointShadowMap[ i ], pointLightShadow.shadowMapSize, pointLightShadow.shadowBias, pointLightShadow.shadowRadius, vPointShadowCoord[ i ], pointLightShadow.shadowCameraNear, pointLightShadow.shadowCameraFar ) : 1.0;\n #endif\n RE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\n }\n #pragma unroll_loop_end\n#endif\n#if ( NUM_SPOT_LIGHTS > 0 ) && defined( RE_Direct )\n SpotLight spotLight;\n vec4 spotColor;\n vec3 spotLightCoord;\n bool inSpotLightMap;\n #if defined( USE_SHADOWMAP ) && NUM_SPOT_LIGHT_SHADOWS > 0\n SpotLightShadow spotLightShadow;\n #endif\n #pragma unroll_loop_start\n for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n spotLight = spotLights[ i ];\n getSpotLightInfo( spotLight, geometryPosition, directLight );\n #if ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS_WITH_MAPS )\n #define SPOT_LIGHT_MAP_INDEX UNROLLED_LOOP_INDEX\n #elif ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )\n #define SPOT_LIGHT_MAP_INDEX NUM_SPOT_LIGHT_MAPS\n #else\n #define SPOT_LIGHT_MAP_INDEX ( UNROLLED_LOOP_INDEX - NUM_SPOT_LIGHT_SHADOWS + NUM_SPOT_LIGHT_SHADOWS_WITH_MAPS )\n #endif\n #if ( SPOT_LIGHT_MAP_INDEX < NUM_SPOT_LIGHT_MAPS )\n spotLightCoord = vSpotLightCoord[ i ].xyz / vSpotLightCoord[ i ].w;\n inSpotLightMap = all( lessThan( abs( spotLightCoord * 2. - 1. ), vec3( 1.0 ) ) );\n spotColor = texture2D( spotLightMap[ SPOT_LIGHT_MAP_INDEX ], spotLightCoord.xy );\n directLight.color = inSpotLightMap ? directLight.color * spotColor.rgb : directLight.color;\n #endif\n #undef SPOT_LIGHT_MAP_INDEX\n #if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )\n spotLightShadow = spotLightShadows[ i ];\n directLight.color *= ( directLight.visible && receiveShadow ) ? getShadow( spotShadowMap[ i ], spotLightShadow.shadowMapSize, spotLightShadow.shadowBias, spotLightShadow.shadowRadius, vSpotLightCoord[ i ] ) : 1.0;\n #endif\n RE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\n }\n #pragma unroll_loop_end\n#endif\n#if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct )\n DirectionalLight directionalLight;\n #if defined( USE_SHADOWMAP ) && NUM_DIR_LIGHT_SHADOWS > 0\n DirectionalLightShadow directionalLightShadow;\n #endif\n #pragma unroll_loop_start\n for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n directionalLight = directionalLights[ i ];\n getDirectionalLightInfo( directionalLight, directLight );\n #if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )\n directionalLightShadow = directionalLightShadows[ i ];\n directLight.color *= ( directLight.visible && receiveShadow ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n #endif\n RE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\n }\n #pragma unroll_loop_end\n#endif\n#if ( NUM_RECT_AREA_LIGHTS > 0 ) && defined( RE_Direct_RectArea )\n RectAreaLight rectAreaLight;\n #pragma unroll_loop_start\n for ( int i = 0; i < NUM_RECT_AREA_LIGHTS; i ++ ) {\n rectAreaLight = rectAreaLights[ i ];\n RE_Direct_RectArea( rectAreaLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\n }\n #pragma unroll_loop_end\n#endif\n#if defined( RE_IndirectDiffuse )\n vec3 iblIrradiance = vec3( 0.0 );\n vec3 irradiance = getAmbientLightIrradiance( ambientLightColor );\n #if defined( USE_LIGHT_PROBES )\n irradiance += getLightProbeIrradiance( lightProbe, geometryNormal );\n #endif\n #if ( NUM_HEMI_LIGHTS > 0 )\n #pragma unroll_loop_start\n for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\n irradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometryNormal );\n }\n #pragma unroll_loop_end\n #endif\n#endif\n#if defined( RE_IndirectSpecular )\n vec3 radiance = vec3( 0.0 );\n vec3 clearcoatRadiance = vec3( 0.0 );\n#endif"; +var lights_fragment_maps = "#if defined( RE_IndirectDiffuse )\n #ifdef USE_LIGHTMAP\n vec4 lightMapTexel = texture2D( lightMap, vLightMapUv );\n vec3 lightMapIrradiance = lightMapTexel.rgb * lightMapIntensity;\n irradiance += lightMapIrradiance;\n #endif\n #if defined( USE_ENVMAP ) && defined( STANDARD ) && defined( ENVMAP_TYPE_CUBE_UV )\n iblIrradiance += getIBLIrradiance( geometryNormal );\n #endif\n#endif\n#if defined( USE_ENVMAP ) && defined( RE_IndirectSpecular )\n #ifdef USE_ANISOTROPY\n radiance += getIBLAnisotropyRadiance( geometryViewDir, geometryNormal, material.roughness, material.anisotropyB, material.anisotropy );\n #else\n radiance += getIBLRadiance( geometryViewDir, geometryNormal, material.roughness );\n #endif\n #ifdef USE_CLEARCOAT\n clearcoatRadiance += getIBLRadiance( geometryViewDir, geometryClearcoatNormal, material.clearcoatRoughness );\n #endif\n#endif"; +var lights_fragment_end = "#if defined( RE_IndirectDiffuse )\n RE_IndirectDiffuse( irradiance, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\n#endif\n#if defined( RE_IndirectSpecular )\n RE_IndirectSpecular( radiance, iblIrradiance, clearcoatRadiance, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\n#endif"; +var logdepthbuf_fragment = "#if defined( USE_LOGDEPTHBUF )\n gl_FragDepth = vIsPerspective == 0.0 ? gl_FragCoord.z : log2( vFragDepth ) * logDepthBufFC * 0.5;\n#endif"; +var logdepthbuf_pars_fragment = "#if defined( USE_LOGDEPTHBUF )\n uniform float logDepthBufFC;\n varying float vFragDepth;\n varying float vIsPerspective;\n#endif"; +var logdepthbuf_pars_vertex = "#ifdef USE_LOGDEPTHBUF\n varying float vFragDepth;\n varying float vIsPerspective;\n#endif"; +var logdepthbuf_vertex = "#ifdef USE_LOGDEPTHBUF\n vFragDepth = 1.0 + gl_Position.w;\n vIsPerspective = float( isPerspectiveMatrix( projectionMatrix ) );\n#endif"; +var map_fragment = "#ifdef USE_MAP\n vec4 sampledDiffuseColor = texture2D( map, vMapUv );\n #ifdef DECODE_VIDEO_TEXTURE\n sampledDiffuseColor = vec4( mix( pow( sampledDiffuseColor.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), sampledDiffuseColor.rgb * 0.0773993808, vec3( lessThanEqual( sampledDiffuseColor.rgb, vec3( 0.04045 ) ) ) ), sampledDiffuseColor.w );\n \n #endif\n diffuseColor *= sampledDiffuseColor;\n#endif"; +var map_pars_fragment = "#ifdef USE_MAP\n uniform sampler2D map;\n#endif"; +var map_particle_fragment = "#if defined( USE_MAP ) || defined( USE_ALPHAMAP )\n #if defined( USE_POINTS_UV )\n vec2 uv = vUv;\n #else\n vec2 uv = ( uvTransform * vec3( gl_PointCoord.x, 1.0 - gl_PointCoord.y, 1 ) ).xy;\n #endif\n#endif\n#ifdef USE_MAP\n diffuseColor *= texture2D( map, uv );\n#endif\n#ifdef USE_ALPHAMAP\n diffuseColor.a *= texture2D( alphaMap, uv ).g;\n#endif"; +var map_particle_pars_fragment = "#if defined( USE_POINTS_UV )\n varying vec2 vUv;\n#else\n #if defined( USE_MAP ) || defined( USE_ALPHAMAP )\n uniform mat3 uvTransform;\n #endif\n#endif\n#ifdef USE_MAP\n uniform sampler2D map;\n#endif\n#ifdef USE_ALPHAMAP\n uniform sampler2D alphaMap;\n#endif"; +var metalnessmap_fragment = "float metalnessFactor = metalness;\n#ifdef USE_METALNESSMAP\n vec4 texelMetalness = texture2D( metalnessMap, vMetalnessMapUv );\n metalnessFactor *= texelMetalness.b;\n#endif"; +var metalnessmap_pars_fragment = "#ifdef USE_METALNESSMAP\n uniform sampler2D metalnessMap;\n#endif"; +var morphinstance_vertex = "#ifdef USE_INSTANCING_MORPH\n float morphTargetInfluences[MORPHTARGETS_COUNT];\n float morphTargetBaseInfluence = texelFetch( morphTexture, ivec2( 0, gl_InstanceID ), 0 ).r;\n for ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {\n morphTargetInfluences[i] = texelFetch( morphTexture, ivec2( i + 1, gl_InstanceID ), 0 ).r;\n }\n#endif"; +var morphcolor_vertex = "#if defined( USE_MORPHCOLORS ) && defined( MORPHTARGETS_TEXTURE )\n vColor *= morphTargetBaseInfluence;\n for ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {\n #if defined( USE_COLOR_ALPHA )\n if ( morphTargetInfluences[ i ] != 0.0 ) vColor += getMorph( gl_VertexID, i, 2 ) * morphTargetInfluences[ i ];\n #elif defined( USE_COLOR )\n if ( morphTargetInfluences[ i ] != 0.0 ) vColor += getMorph( gl_VertexID, i, 2 ).rgb * morphTargetInfluences[ i ];\n #endif\n }\n#endif"; +var morphnormal_vertex = "#ifdef USE_MORPHNORMALS\n objectNormal *= morphTargetBaseInfluence;\n #ifdef MORPHTARGETS_TEXTURE\n for ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {\n if ( morphTargetInfluences[ i ] != 0.0 ) objectNormal += getMorph( gl_VertexID, i, 1 ).xyz * morphTargetInfluences[ i ];\n }\n #else\n objectNormal += morphNormal0 * morphTargetInfluences[ 0 ];\n objectNormal += morphNormal1 * morphTargetInfluences[ 1 ];\n objectNormal += morphNormal2 * morphTargetInfluences[ 2 ];\n objectNormal += morphNormal3 * morphTargetInfluences[ 3 ];\n #endif\n#endif"; +var morphtarget_pars_vertex = "#ifdef USE_MORPHTARGETS\n #ifndef USE_INSTANCING_MORPH\n uniform float morphTargetBaseInfluence;\n #endif\n #ifdef MORPHTARGETS_TEXTURE\n #ifndef USE_INSTANCING_MORPH\n uniform float morphTargetInfluences[ MORPHTARGETS_COUNT ];\n #endif\n uniform sampler2DArray morphTargetsTexture;\n uniform ivec2 morphTargetsTextureSize;\n vec4 getMorph( const in int vertexIndex, const in int morphTargetIndex, const in int offset ) {\n int texelIndex = vertexIndex * MORPHTARGETS_TEXTURE_STRIDE + offset;\n int y = texelIndex / morphTargetsTextureSize.x;\n int x = texelIndex - y * morphTargetsTextureSize.x;\n ivec3 morphUV = ivec3( x, y, morphTargetIndex );\n return texelFetch( morphTargetsTexture, morphUV, 0 );\n }\n #else\n #ifndef USE_MORPHNORMALS\n uniform float morphTargetInfluences[ 8 ];\n #else\n uniform float morphTargetInfluences[ 4 ];\n #endif\n #endif\n#endif"; +var morphtarget_vertex = "#ifdef USE_MORPHTARGETS\n transformed *= morphTargetBaseInfluence;\n #ifdef MORPHTARGETS_TEXTURE\n for ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {\n if ( morphTargetInfluences[ i ] != 0.0 ) transformed += getMorph( gl_VertexID, i, 0 ).xyz * morphTargetInfluences[ i ];\n }\n #else\n transformed += morphTarget0 * morphTargetInfluences[ 0 ];\n transformed += morphTarget1 * morphTargetInfluences[ 1 ];\n transformed += morphTarget2 * morphTargetInfluences[ 2 ];\n transformed += morphTarget3 * morphTargetInfluences[ 3 ];\n #ifndef USE_MORPHNORMALS\n transformed += morphTarget4 * morphTargetInfluences[ 4 ];\n transformed += morphTarget5 * morphTargetInfluences[ 5 ];\n transformed += morphTarget6 * morphTargetInfluences[ 6 ];\n transformed += morphTarget7 * morphTargetInfluences[ 7 ];\n #endif\n #endif\n#endif"; +var normal_fragment_begin = "float faceDirection = gl_FrontFacing ? 1.0 : - 1.0;\n#ifdef FLAT_SHADED\n vec3 fdx = dFdx( vViewPosition );\n vec3 fdy = dFdy( vViewPosition );\n vec3 normal = normalize( cross( fdx, fdy ) );\n#else\n vec3 normal = normalize( vNormal );\n #ifdef DOUBLE_SIDED\n normal *= faceDirection;\n #endif\n#endif\n#if defined( USE_NORMALMAP_TANGENTSPACE ) || defined( USE_CLEARCOAT_NORMALMAP ) || defined( USE_ANISOTROPY )\n #ifdef USE_TANGENT\n mat3 tbn = mat3( normalize( vTangent ), normalize( vBitangent ), normal );\n #else\n mat3 tbn = getTangentFrame( - vViewPosition, normal,\n #if defined( USE_NORMALMAP )\n vNormalMapUv\n #elif defined( USE_CLEARCOAT_NORMALMAP )\n vClearcoatNormalMapUv\n #else\n vUv\n #endif\n );\n #endif\n #if defined( DOUBLE_SIDED ) && ! defined( FLAT_SHADED )\n tbn[0] *= faceDirection;\n tbn[1] *= faceDirection;\n #endif\n#endif\n#ifdef USE_CLEARCOAT_NORMALMAP\n #ifdef USE_TANGENT\n mat3 tbn2 = mat3( normalize( vTangent ), normalize( vBitangent ), normal );\n #else\n mat3 tbn2 = getTangentFrame( - vViewPosition, normal, vClearcoatNormalMapUv );\n #endif\n #if defined( DOUBLE_SIDED ) && ! defined( FLAT_SHADED )\n tbn2[0] *= faceDirection;\n tbn2[1] *= faceDirection;\n #endif\n#endif\nvec3 nonPerturbedNormal = normal;"; +var normal_fragment_maps = "#ifdef USE_NORMALMAP_OBJECTSPACE\n normal = texture2D( normalMap, vNormalMapUv ).xyz * 2.0 - 1.0;\n #ifdef FLIP_SIDED\n normal = - normal;\n #endif\n #ifdef DOUBLE_SIDED\n normal = normal * faceDirection;\n #endif\n normal = normalize( normalMatrix * normal );\n#elif defined( USE_NORMALMAP_TANGENTSPACE )\n vec3 mapN = texture2D( normalMap, vNormalMapUv ).xyz * 2.0 - 1.0;\n mapN.xy *= normalScale;\n normal = normalize( tbn * mapN );\n#elif defined( USE_BUMPMAP )\n normal = perturbNormalArb( - vViewPosition, normal, dHdxy_fwd(), faceDirection );\n#endif"; +var normal_pars_fragment = "#ifndef FLAT_SHADED\n varying vec3 vNormal;\n #ifdef USE_TANGENT\n varying vec3 vTangent;\n varying vec3 vBitangent;\n #endif\n#endif"; +var normal_pars_vertex = "#ifndef FLAT_SHADED\n varying vec3 vNormal;\n #ifdef USE_TANGENT\n varying vec3 vTangent;\n varying vec3 vBitangent;\n #endif\n#endif"; +var normal_vertex = "#ifndef FLAT_SHADED\n vNormal = normalize( transformedNormal );\n #ifdef USE_TANGENT\n vTangent = normalize( transformedTangent );\n vBitangent = normalize( cross( vNormal, vTangent ) * tangent.w );\n #endif\n#endif"; +var normalmap_pars_fragment = "#ifdef USE_NORMALMAP\n uniform sampler2D normalMap;\n uniform vec2 normalScale;\n#endif\n#ifdef USE_NORMALMAP_OBJECTSPACE\n uniform mat3 normalMatrix;\n#endif\n#if ! defined ( USE_TANGENT ) && ( defined ( USE_NORMALMAP_TANGENTSPACE ) || defined ( USE_CLEARCOAT_NORMALMAP ) || defined( USE_ANISOTROPY ) )\n mat3 getTangentFrame( vec3 eye_pos, vec3 surf_norm, vec2 uv ) {\n vec3 q0 = dFdx( eye_pos.xyz );\n vec3 q1 = dFdy( eye_pos.xyz );\n vec2 st0 = dFdx( uv.st );\n vec2 st1 = dFdy( uv.st );\n vec3 N = surf_norm;\n vec3 q1perp = cross( q1, N );\n vec3 q0perp = cross( N, q0 );\n vec3 T = q1perp * st0.x + q0perp * st1.x;\n vec3 B = q1perp * st0.y + q0perp * st1.y;\n float det = max( dot( T, T ), dot( B, B ) );\n float scale = ( det == 0.0 ) ? 0.0 : inversesqrt( det );\n return mat3( T * scale, B * scale, N );\n }\n#endif"; +var clearcoat_normal_fragment_begin = "#ifdef USE_CLEARCOAT\n vec3 clearcoatNormal = nonPerturbedNormal;\n#endif"; +var clearcoat_normal_fragment_maps = "#ifdef USE_CLEARCOAT_NORMALMAP\n vec3 clearcoatMapN = texture2D( clearcoatNormalMap, vClearcoatNormalMapUv ).xyz * 2.0 - 1.0;\n clearcoatMapN.xy *= clearcoatNormalScale;\n clearcoatNormal = normalize( tbn2 * clearcoatMapN );\n#endif"; +var clearcoat_pars_fragment = "#ifdef USE_CLEARCOATMAP\n uniform sampler2D clearcoatMap;\n#endif\n#ifdef USE_CLEARCOAT_NORMALMAP\n uniform sampler2D clearcoatNormalMap;\n uniform vec2 clearcoatNormalScale;\n#endif\n#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n uniform sampler2D clearcoatRoughnessMap;\n#endif"; +var iridescence_pars_fragment = "#ifdef USE_IRIDESCENCEMAP\n uniform sampler2D iridescenceMap;\n#endif\n#ifdef USE_IRIDESCENCE_THICKNESSMAP\n uniform sampler2D iridescenceThicknessMap;\n#endif"; +var opaque_fragment = "#ifdef OPAQUE\ndiffuseColor.a = 1.0;\n#endif\n#ifdef USE_TRANSMISSION\ndiffuseColor.a *= material.transmissionAlpha;\n#endif\ngl_FragColor = vec4( outgoingLight, diffuseColor.a );"; +var packing = "vec3 packNormalToRGB( const in vec3 normal ) {\n return normalize( normal ) * 0.5 + 0.5;\n}\nvec3 unpackRGBToNormal( const in vec3 rgb ) {\n return 2.0 * rgb.xyz - 1.0;\n}\nconst float PackUpscale = 256. / 255.;const float UnpackDownscale = 255. / 256.;\nconst vec3 PackFactors = vec3( 256. * 256. * 256., 256. * 256., 256. );\nconst vec4 UnpackFactors = UnpackDownscale / vec4( PackFactors, 1. );\nconst float ShiftRight8 = 1. / 256.;\nvec4 packDepthToRGBA( const in float v ) {\n vec4 r = vec4( fract( v * PackFactors ), v );\n r.yzw -= r.xyz * ShiftRight8; return r * PackUpscale;\n}\nfloat unpackRGBAToDepth( const in vec4 v ) {\n return dot( v, UnpackFactors );\n}\nvec2 packDepthToRG( in highp float v ) {\n return packDepthToRGBA( v ).yx;\n}\nfloat unpackRGToDepth( const in highp vec2 v ) {\n return unpackRGBAToDepth( vec4( v.xy, 0.0, 0.0 ) );\n}\nvec4 pack2HalfToRGBA( vec2 v ) {\n vec4 r = vec4( v.x, fract( v.x * 255.0 ), v.y, fract( v.y * 255.0 ) );\n return vec4( r.x - r.y / 255.0, r.y, r.z - r.w / 255.0, r.w );\n}\nvec2 unpackRGBATo2Half( vec4 v ) {\n return vec2( v.x + ( v.y / 255.0 ), v.z + ( v.w / 255.0 ) );\n}\nfloat viewZToOrthographicDepth( const in float viewZ, const in float near, const in float far ) {\n return ( viewZ + near ) / ( near - far );\n}\nfloat orthographicDepthToViewZ( const in float depth, const in float near, const in float far ) {\n return depth * ( near - far ) - near;\n}\nfloat viewZToPerspectiveDepth( const in float viewZ, const in float near, const in float far ) {\n return ( ( near + viewZ ) * far ) / ( ( far - near ) * viewZ );\n}\nfloat perspectiveDepthToViewZ( const in float depth, const in float near, const in float far ) {\n return ( near * far ) / ( ( far - near ) * depth - far );\n}"; +var premultiplied_alpha_fragment = "#ifdef PREMULTIPLIED_ALPHA\n gl_FragColor.rgb *= gl_FragColor.a;\n#endif"; +var project_vertex = "vec4 mvPosition = vec4( transformed, 1.0 );\n#ifdef USE_BATCHING\n mvPosition = batchingMatrix * mvPosition;\n#endif\n#ifdef USE_INSTANCING\n mvPosition = instanceMatrix * mvPosition;\n#endif\nmvPosition = modelViewMatrix * mvPosition;\ngl_Position = projectionMatrix * mvPosition;"; +var dithering_fragment = "#ifdef DITHERING\n gl_FragColor.rgb = dithering( gl_FragColor.rgb );\n#endif"; +var dithering_pars_fragment = "#ifdef DITHERING\n vec3 dithering( vec3 color ) {\n float grid_position = rand( gl_FragCoord.xy );\n vec3 dither_shift_RGB = vec3( 0.25 / 255.0, -0.25 / 255.0, 0.25 / 255.0 );\n dither_shift_RGB = mix( 2.0 * dither_shift_RGB, -2.0 * dither_shift_RGB, grid_position );\n return color + dither_shift_RGB;\n }\n#endif"; +var roughnessmap_fragment = "float roughnessFactor = roughness;\n#ifdef USE_ROUGHNESSMAP\n vec4 texelRoughness = texture2D( roughnessMap, vRoughnessMapUv );\n roughnessFactor *= texelRoughness.g;\n#endif"; +var roughnessmap_pars_fragment = "#ifdef USE_ROUGHNESSMAP\n uniform sampler2D roughnessMap;\n#endif"; +var shadowmap_pars_fragment = "#if NUM_SPOT_LIGHT_COORDS > 0\n varying vec4 vSpotLightCoord[ NUM_SPOT_LIGHT_COORDS ];\n#endif\n#if NUM_SPOT_LIGHT_MAPS > 0\n uniform sampler2D spotLightMap[ NUM_SPOT_LIGHT_MAPS ];\n#endif\n#ifdef USE_SHADOWMAP\n #if NUM_DIR_LIGHT_SHADOWS > 0\n uniform sampler2D directionalShadowMap[ NUM_DIR_LIGHT_SHADOWS ];\n varying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];\n struct DirectionalLightShadow {\n float shadowBias;\n float shadowNormalBias;\n float shadowRadius;\n vec2 shadowMapSize;\n };\n uniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];\n #endif\n #if NUM_SPOT_LIGHT_SHADOWS > 0\n uniform sampler2D spotShadowMap[ NUM_SPOT_LIGHT_SHADOWS ];\n struct SpotLightShadow {\n float shadowBias;\n float shadowNormalBias;\n float shadowRadius;\n vec2 shadowMapSize;\n };\n uniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];\n #endif\n #if NUM_POINT_LIGHT_SHADOWS > 0\n uniform sampler2D pointShadowMap[ NUM_POINT_LIGHT_SHADOWS ];\n varying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];\n struct PointLightShadow {\n float shadowBias;\n float shadowNormalBias;\n float shadowRadius;\n vec2 shadowMapSize;\n float shadowCameraNear;\n float shadowCameraFar;\n };\n uniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];\n #endif\n float texture2DCompare( sampler2D depths, vec2 uv, float compare ) {\n return step( compare, unpackRGBAToDepth( texture2D( depths, uv ) ) );\n }\n vec2 texture2DDistribution( sampler2D shadow, vec2 uv ) {\n return unpackRGBATo2Half( texture2D( shadow, uv ) );\n }\n float VSMShadow (sampler2D shadow, vec2 uv, float compare ){\n float occlusion = 1.0;\n vec2 distribution = texture2DDistribution( shadow, uv );\n float hard_shadow = step( compare , distribution.x );\n if (hard_shadow != 1.0 ) {\n float distance = compare - distribution.x ;\n float variance = max( 0.00000, distribution.y * distribution.y );\n float softness_probability = variance / (variance + distance * distance ); softness_probability = clamp( ( softness_probability - 0.3 ) / ( 0.95 - 0.3 ), 0.0, 1.0 ); occlusion = clamp( max( hard_shadow, softness_probability ), 0.0, 1.0 );\n }\n return occlusion;\n }\n float getShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord ) {\n float shadow = 1.0;\n shadowCoord.xyz /= shadowCoord.w;\n shadowCoord.z += shadowBias;\n bool inFrustum = shadowCoord.x >= 0.0 && shadowCoord.x <= 1.0 && shadowCoord.y >= 0.0 && shadowCoord.y <= 1.0;\n bool frustumTest = inFrustum && shadowCoord.z <= 1.0;\n if ( frustumTest ) {\n #if defined( SHADOWMAP_TYPE_PCF )\n vec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n float dx0 = - texelSize.x * shadowRadius;\n float dy0 = - texelSize.y * shadowRadius;\n float dx1 = + texelSize.x * shadowRadius;\n float dy1 = + texelSize.y * shadowRadius;\n float dx2 = dx0 / 2.0;\n float dy2 = dy0 / 2.0;\n float dx3 = dx1 / 2.0;\n float dy3 = dy1 / 2.0;\n shadow = (\n texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +\n texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +\n texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +\n texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy2 ), shadowCoord.z ) +\n texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy2 ), shadowCoord.z ) +\n texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy2 ), shadowCoord.z ) +\n texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +\n texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, 0.0 ), shadowCoord.z ) +\n texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z ) +\n texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, 0.0 ), shadowCoord.z ) +\n texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +\n texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy3 ), shadowCoord.z ) +\n texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy3 ), shadowCoord.z ) +\n texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy3 ), shadowCoord.z ) +\n texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +\n texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +\n texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )\n ) * ( 1.0 / 17.0 );\n #elif defined( SHADOWMAP_TYPE_PCF_SOFT )\n vec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n float dx = texelSize.x;\n float dy = texelSize.y;\n vec2 uv = shadowCoord.xy;\n vec2 f = fract( uv * shadowMapSize + 0.5 );\n uv -= f * texelSize;\n shadow = (\n texture2DCompare( shadowMap, uv, shadowCoord.z ) +\n texture2DCompare( shadowMap, uv + vec2( dx, 0.0 ), shadowCoord.z ) +\n texture2DCompare( shadowMap, uv + vec2( 0.0, dy ), shadowCoord.z ) +\n texture2DCompare( shadowMap, uv + texelSize, shadowCoord.z ) +\n mix( texture2DCompare( shadowMap, uv + vec2( -dx, 0.0 ), shadowCoord.z ),\n texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 0.0 ), shadowCoord.z ),\n f.x ) +\n mix( texture2DCompare( shadowMap, uv + vec2( -dx, dy ), shadowCoord.z ),\n texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, dy ), shadowCoord.z ),\n f.x ) +\n mix( texture2DCompare( shadowMap, uv + vec2( 0.0, -dy ), shadowCoord.z ),\n texture2DCompare( shadowMap, uv + vec2( 0.0, 2.0 * dy ), shadowCoord.z ),\n f.y ) +\n mix( texture2DCompare( shadowMap, uv + vec2( dx, -dy ), shadowCoord.z ),\n texture2DCompare( shadowMap, uv + vec2( dx, 2.0 * dy ), shadowCoord.z ),\n f.y ) +\n mix( mix( texture2DCompare( shadowMap, uv + vec2( -dx, -dy ), shadowCoord.z ),\n texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, -dy ), shadowCoord.z ),\n f.x ),\n mix( texture2DCompare( shadowMap, uv + vec2( -dx, 2.0 * dy ), shadowCoord.z ),\n texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 2.0 * dy ), shadowCoord.z ),\n f.x ),\n f.y )\n ) * ( 1.0 / 9.0 );\n #elif defined( SHADOWMAP_TYPE_VSM )\n shadow = VSMShadow( shadowMap, shadowCoord.xy, shadowCoord.z );\n #else\n shadow = texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z );\n #endif\n }\n return shadow;\n }\n vec2 cubeToUV( vec3 v, float texelSizeY ) {\n vec3 absV = abs( v );\n float scaleToCube = 1.0 / max( absV.x, max( absV.y, absV.z ) );\n absV *= scaleToCube;\n v *= scaleToCube * ( 1.0 - 2.0 * texelSizeY );\n vec2 planar = v.xy;\n float almostATexel = 1.5 * texelSizeY;\n float almostOne = 1.0 - almostATexel;\n if ( absV.z >= almostOne ) {\n if ( v.z > 0.0 )\n planar.x = 4.0 - v.x;\n } else if ( absV.x >= almostOne ) {\n float signX = sign( v.x );\n planar.x = v.z * signX + 2.0 * signX;\n } else if ( absV.y >= almostOne ) {\n float signY = sign( v.y );\n planar.x = v.x + 2.0 * signY + 2.0;\n planar.y = v.z * signY - 2.0;\n }\n return vec2( 0.125, 0.25 ) * planar + vec2( 0.375, 0.75 );\n }\n float getPointShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord, float shadowCameraNear, float shadowCameraFar ) {\n float shadow = 1.0;\n vec3 lightToPosition = shadowCoord.xyz;\n \n float lightToPositionLength = length( lightToPosition );\n if ( lightToPositionLength - shadowCameraFar <= 0.0 && lightToPositionLength - shadowCameraNear >= 0.0 ) {\n float dp = ( lightToPositionLength - shadowCameraNear ) / ( shadowCameraFar - shadowCameraNear ); dp += shadowBias;\n vec3 bd3D = normalize( lightToPosition );\n vec2 texelSize = vec2( 1.0 ) / ( shadowMapSize * vec2( 4.0, 2.0 ) );\n #if defined( SHADOWMAP_TYPE_PCF ) || defined( SHADOWMAP_TYPE_PCF_SOFT ) || defined( SHADOWMAP_TYPE_VSM )\n vec2 offset = vec2( - 1, 1 ) * shadowRadius * texelSize.y;\n shadow = (\n texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyy, texelSize.y ), dp ) +\n texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyy, texelSize.y ), dp ) +\n texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyx, texelSize.y ), dp ) +\n texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyx, texelSize.y ), dp ) +\n texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp ) +\n texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxy, texelSize.y ), dp ) +\n texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxy, texelSize.y ), dp ) +\n texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxx, texelSize.y ), dp ) +\n texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxx, texelSize.y ), dp )\n ) * ( 1.0 / 9.0 );\n #else\n shadow = texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp );\n #endif\n }\n return shadow;\n }\n#endif"; +var shadowmap_pars_vertex = "#if NUM_SPOT_LIGHT_COORDS > 0\n uniform mat4 spotLightMatrix[ NUM_SPOT_LIGHT_COORDS ];\n varying vec4 vSpotLightCoord[ NUM_SPOT_LIGHT_COORDS ];\n#endif\n#ifdef USE_SHADOWMAP\n #if NUM_DIR_LIGHT_SHADOWS > 0\n uniform mat4 directionalShadowMatrix[ NUM_DIR_LIGHT_SHADOWS ];\n varying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];\n struct DirectionalLightShadow {\n float shadowBias;\n float shadowNormalBias;\n float shadowRadius;\n vec2 shadowMapSize;\n };\n uniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];\n #endif\n #if NUM_SPOT_LIGHT_SHADOWS > 0\n struct SpotLightShadow {\n float shadowBias;\n float shadowNormalBias;\n float shadowRadius;\n vec2 shadowMapSize;\n };\n uniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];\n #endif\n #if NUM_POINT_LIGHT_SHADOWS > 0\n uniform mat4 pointShadowMatrix[ NUM_POINT_LIGHT_SHADOWS ];\n varying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];\n struct PointLightShadow {\n float shadowBias;\n float shadowNormalBias;\n float shadowRadius;\n vec2 shadowMapSize;\n float shadowCameraNear;\n float shadowCameraFar;\n };\n uniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];\n #endif\n#endif"; +var shadowmap_vertex = "#if ( defined( USE_SHADOWMAP ) && ( NUM_DIR_LIGHT_SHADOWS > 0 || NUM_POINT_LIGHT_SHADOWS > 0 ) ) || ( NUM_SPOT_LIGHT_COORDS > 0 )\n vec3 shadowWorldNormal = inverseTransformDirection( transformedNormal, viewMatrix );\n vec4 shadowWorldPosition;\n#endif\n#if defined( USE_SHADOWMAP )\n #if NUM_DIR_LIGHT_SHADOWS > 0\n #pragma unroll_loop_start\n for ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {\n shadowWorldPosition = worldPosition + vec4( shadowWorldNormal * directionalLightShadows[ i ].shadowNormalBias, 0 );\n vDirectionalShadowCoord[ i ] = directionalShadowMatrix[ i ] * shadowWorldPosition;\n }\n #pragma unroll_loop_end\n #endif\n #if NUM_POINT_LIGHT_SHADOWS > 0\n #pragma unroll_loop_start\n for ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {\n shadowWorldPosition = worldPosition + vec4( shadowWorldNormal * pointLightShadows[ i ].shadowNormalBias, 0 );\n vPointShadowCoord[ i ] = pointShadowMatrix[ i ] * shadowWorldPosition;\n }\n #pragma unroll_loop_end\n #endif\n#endif\n#if NUM_SPOT_LIGHT_COORDS > 0\n #pragma unroll_loop_start\n for ( int i = 0; i < NUM_SPOT_LIGHT_COORDS; i ++ ) {\n shadowWorldPosition = worldPosition;\n #if ( defined( USE_SHADOWMAP ) && UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )\n shadowWorldPosition.xyz += shadowWorldNormal * spotLightShadows[ i ].shadowNormalBias;\n #endif\n vSpotLightCoord[ i ] = spotLightMatrix[ i ] * shadowWorldPosition;\n }\n #pragma unroll_loop_end\n#endif"; +var shadowmask_pars_fragment = "float getShadowMask() {\n float shadow = 1.0;\n #ifdef USE_SHADOWMAP\n #if NUM_DIR_LIGHT_SHADOWS > 0\n DirectionalLightShadow directionalLight;\n #pragma unroll_loop_start\n for ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {\n directionalLight = directionalLightShadows[ i ];\n shadow *= receiveShadow ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n }\n #pragma unroll_loop_end\n #endif\n #if NUM_SPOT_LIGHT_SHADOWS > 0\n SpotLightShadow spotLight;\n #pragma unroll_loop_start\n for ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {\n spotLight = spotLightShadows[ i ];\n shadow *= receiveShadow ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotLightCoord[ i ] ) : 1.0;\n }\n #pragma unroll_loop_end\n #endif\n #if NUM_POINT_LIGHT_SHADOWS > 0\n PointLightShadow pointLight;\n #pragma unroll_loop_start\n for ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {\n pointLight = pointLightShadows[ i ];\n shadow *= receiveShadow ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;\n }\n #pragma unroll_loop_end\n #endif\n #endif\n return shadow;\n}"; +var skinbase_vertex = "#ifdef USE_SKINNING\n mat4 boneMatX = getBoneMatrix( skinIndex.x );\n mat4 boneMatY = getBoneMatrix( skinIndex.y );\n mat4 boneMatZ = getBoneMatrix( skinIndex.z );\n mat4 boneMatW = getBoneMatrix( skinIndex.w );\n#endif"; +var skinning_pars_vertex = "#ifdef USE_SKINNING\n uniform mat4 bindMatrix;\n uniform mat4 bindMatrixInverse;\n uniform highp sampler2D boneTexture;\n mat4 getBoneMatrix( const in float i ) {\n int size = textureSize( boneTexture, 0 ).x;\n int j = int( i ) * 4;\n int x = j % size;\n int y = j / size;\n vec4 v1 = texelFetch( boneTexture, ivec2( x, y ), 0 );\n vec4 v2 = texelFetch( boneTexture, ivec2( x + 1, y ), 0 );\n vec4 v3 = texelFetch( boneTexture, ivec2( x + 2, y ), 0 );\n vec4 v4 = texelFetch( boneTexture, ivec2( x + 3, y ), 0 );\n return mat4( v1, v2, v3, v4 );\n }\n#endif"; +var skinning_vertex = "#ifdef USE_SKINNING\n vec4 skinVertex = bindMatrix * vec4( transformed, 1.0 );\n vec4 skinned = vec4( 0.0 );\n skinned += boneMatX * skinVertex * skinWeight.x;\n skinned += boneMatY * skinVertex * skinWeight.y;\n skinned += boneMatZ * skinVertex * skinWeight.z;\n skinned += boneMatW * skinVertex * skinWeight.w;\n transformed = ( bindMatrixInverse * skinned ).xyz;\n#endif"; +var skinnormal_vertex = "#ifdef USE_SKINNING\n mat4 skinMatrix = mat4( 0.0 );\n skinMatrix += skinWeight.x * boneMatX;\n skinMatrix += skinWeight.y * boneMatY;\n skinMatrix += skinWeight.z * boneMatZ;\n skinMatrix += skinWeight.w * boneMatW;\n skinMatrix = bindMatrixInverse * skinMatrix * bindMatrix;\n objectNormal = vec4( skinMatrix * vec4( objectNormal, 0.0 ) ).xyz;\n #ifdef USE_TANGENT\n objectTangent = vec4( skinMatrix * vec4( objectTangent, 0.0 ) ).xyz;\n #endif\n#endif"; +var specularmap_fragment = "float specularStrength;\n#ifdef USE_SPECULARMAP\n vec4 texelSpecular = texture2D( specularMap, vSpecularMapUv );\n specularStrength = texelSpecular.r;\n#else\n specularStrength = 1.0;\n#endif"; +var specularmap_pars_fragment = "#ifdef USE_SPECULARMAP\n uniform sampler2D specularMap;\n#endif"; +var tonemapping_fragment = "#if defined( TONE_MAPPING )\n gl_FragColor.rgb = toneMapping( gl_FragColor.rgb );\n#endif"; +var tonemapping_pars_fragment = "#ifndef saturate\n#define saturate( a ) clamp( a, 0.0, 1.0 )\n#endif\nuniform float toneMappingExposure;\nvec3 LinearToneMapping( vec3 color ) {\n return saturate( toneMappingExposure * color );\n}\nvec3 ReinhardToneMapping( vec3 color ) {\n color *= toneMappingExposure;\n return saturate( color / ( vec3( 1.0 ) + color ) );\n}\nvec3 OptimizedCineonToneMapping( vec3 color ) {\n color *= toneMappingExposure;\n color = max( vec3( 0.0 ), color - 0.004 );\n return pow( ( color * ( 6.2 * color + 0.5 ) ) / ( color * ( 6.2 * color + 1.7 ) + 0.06 ), vec3( 2.2 ) );\n}\nvec3 RRTAndODTFit( vec3 v ) {\n vec3 a = v * ( v + 0.0245786 ) - 0.000090537;\n vec3 b = v * ( 0.983729 * v + 0.4329510 ) + 0.238081;\n return a / b;\n}\nvec3 ACESFilmicToneMapping( vec3 color ) {\n const mat3 ACESInputMat = mat3(\n vec3( 0.59719, 0.07600, 0.02840 ), vec3( 0.35458, 0.90834, 0.13383 ),\n vec3( 0.04823, 0.01566, 0.83777 )\n );\n const mat3 ACESOutputMat = mat3(\n vec3( 1.60475, -0.10208, -0.00327 ), vec3( -0.53108, 1.10813, -0.07276 ),\n vec3( -0.07367, -0.00605, 1.07602 )\n );\n color *= toneMappingExposure / 0.6;\n color = ACESInputMat * color;\n color = RRTAndODTFit( color );\n color = ACESOutputMat * color;\n return saturate( color );\n}\nconst mat3 LINEAR_REC2020_TO_LINEAR_SRGB = mat3(\n vec3( 1.6605, - 0.1246, - 0.0182 ),\n vec3( - 0.5876, 1.1329, - 0.1006 ),\n vec3( - 0.0728, - 0.0083, 1.1187 )\n);\nconst mat3 LINEAR_SRGB_TO_LINEAR_REC2020 = mat3(\n vec3( 0.6274, 0.0691, 0.0164 ),\n vec3( 0.3293, 0.9195, 0.0880 ),\n vec3( 0.0433, 0.0113, 0.8956 )\n);\nvec3 agxDefaultContrastApprox( vec3 x ) {\n vec3 x2 = x * x;\n vec3 x4 = x2 * x2;\n return + 15.5 * x4 * x2\n - 40.14 * x4 * x\n + 31.96 * x4\n - 6.868 * x2 * x\n + 0.4298 * x2\n + 0.1191 * x\n - 0.00232;\n}\nvec3 AgXToneMapping( vec3 color ) {\n const mat3 AgXInsetMatrix = mat3(\n vec3( 0.856627153315983, 0.137318972929847, 0.11189821299995 ),\n vec3( 0.0951212405381588, 0.761241990602591, 0.0767994186031903 ),\n vec3( 0.0482516061458583, 0.101439036467562, 0.811302368396859 )\n );\n const mat3 AgXOutsetMatrix = mat3(\n vec3( 1.1271005818144368, - 0.1413297634984383, - 0.14132976349843826 ),\n vec3( - 0.11060664309660323, 1.157823702216272, - 0.11060664309660294 ),\n vec3( - 0.016493938717834573, - 0.016493938717834257, 1.2519364065950405 )\n );\n const float AgxMinEv = - 12.47393; const float AgxMaxEv = 4.026069;\n color *= toneMappingExposure;\n color = LINEAR_SRGB_TO_LINEAR_REC2020 * color;\n color = AgXInsetMatrix * color;\n color = max( color, 1e-10 ); color = log2( color );\n color = ( color - AgxMinEv ) / ( AgxMaxEv - AgxMinEv );\n color = clamp( color, 0.0, 1.0 );\n color = agxDefaultContrastApprox( color );\n color = AgXOutsetMatrix * color;\n color = pow( max( vec3( 0.0 ), color ), vec3( 2.2 ) );\n color = LINEAR_REC2020_TO_LINEAR_SRGB * color;\n color = clamp( color, 0.0, 1.0 );\n return color;\n}\nvec3 NeutralToneMapping( vec3 color ) {\n float startCompression = 0.8 - 0.04;\n float desaturation = 0.15;\n color *= toneMappingExposure;\n float x = min(color.r, min(color.g, color.b));\n float offset = x < 0.08 ? x - 6.25 * x * x : 0.04;\n color -= offset;\n float peak = max(color.r, max(color.g, color.b));\n if (peak < startCompression) return color;\n float d = 1. - startCompression;\n float newPeak = 1. - d * d / (peak + d - startCompression);\n color *= newPeak / peak;\n float g = 1. - 1. / (desaturation * (peak - newPeak) + 1.);\n return mix(color, newPeak * vec3(1, 1, 1), g);\n}\nvec3 CustomToneMapping( vec3 color ) { return color; }"; +var transmission_fragment = "#ifdef USE_TRANSMISSION\n material.transmission = transmission;\n material.transmissionAlpha = 1.0;\n material.thickness = thickness;\n material.attenuationDistance = attenuationDistance;\n material.attenuationColor = attenuationColor;\n #ifdef USE_TRANSMISSIONMAP\n material.transmission *= texture2D( transmissionMap, vTransmissionMapUv ).r;\n #endif\n #ifdef USE_THICKNESSMAP\n material.thickness *= texture2D( thicknessMap, vThicknessMapUv ).g;\n #endif\n vec3 pos = vWorldPosition;\n vec3 v = normalize( cameraPosition - pos );\n vec3 n = inverseTransformDirection( normal, viewMatrix );\n vec4 transmitted = getIBLVolumeRefraction(\n n, v, material.roughness, material.diffuseColor, material.specularColor, material.specularF90,\n pos, modelMatrix, viewMatrix, projectionMatrix, material.ior, material.thickness,\n material.attenuationColor, material.attenuationDistance );\n material.transmissionAlpha = mix( material.transmissionAlpha, transmitted.a, material.transmission );\n totalDiffuse = mix( totalDiffuse, transmitted.rgb, material.transmission );\n#endif"; +var transmission_pars_fragment = "#ifdef USE_TRANSMISSION\n uniform float transmission;\n uniform float thickness;\n uniform float attenuationDistance;\n uniform vec3 attenuationColor;\n #ifdef USE_TRANSMISSIONMAP\n uniform sampler2D transmissionMap;\n #endif\n #ifdef USE_THICKNESSMAP\n uniform sampler2D thicknessMap;\n #endif\n uniform vec2 transmissionSamplerSize;\n uniform sampler2D transmissionSamplerMap;\n uniform mat4 modelMatrix;\n uniform mat4 projectionMatrix;\n varying vec3 vWorldPosition;\n float w0( float a ) {\n return ( 1.0 / 6.0 ) * ( a * ( a * ( - a + 3.0 ) - 3.0 ) + 1.0 );\n }\n float w1( float a ) {\n return ( 1.0 / 6.0 ) * ( a * a * ( 3.0 * a - 6.0 ) + 4.0 );\n }\n float w2( float a ){\n return ( 1.0 / 6.0 ) * ( a * ( a * ( - 3.0 * a + 3.0 ) + 3.0 ) + 1.0 );\n }\n float w3( float a ) {\n return ( 1.0 / 6.0 ) * ( a * a * a );\n }\n float g0( float a ) {\n return w0( a ) + w1( a );\n }\n float g1( float a ) {\n return w2( a ) + w3( a );\n }\n float h0( float a ) {\n return - 1.0 + w1( a ) / ( w0( a ) + w1( a ) );\n }\n float h1( float a ) {\n return 1.0 + w3( a ) / ( w2( a ) + w3( a ) );\n }\n vec4 bicubic( sampler2D tex, vec2 uv, vec4 texelSize, float lod ) {\n uv = uv * texelSize.zw + 0.5;\n vec2 iuv = floor( uv );\n vec2 fuv = fract( uv );\n float g0x = g0( fuv.x );\n float g1x = g1( fuv.x );\n float h0x = h0( fuv.x );\n float h1x = h1( fuv.x );\n float h0y = h0( fuv.y );\n float h1y = h1( fuv.y );\n vec2 p0 = ( vec2( iuv.x + h0x, iuv.y + h0y ) - 0.5 ) * texelSize.xy;\n vec2 p1 = ( vec2( iuv.x + h1x, iuv.y + h0y ) - 0.5 ) * texelSize.xy;\n vec2 p2 = ( vec2( iuv.x + h0x, iuv.y + h1y ) - 0.5 ) * texelSize.xy;\n vec2 p3 = ( vec2( iuv.x + h1x, iuv.y + h1y ) - 0.5 ) * texelSize.xy;\n return g0( fuv.y ) * ( g0x * textureLod( tex, p0, lod ) + g1x * textureLod( tex, p1, lod ) ) +\n g1( fuv.y ) * ( g0x * textureLod( tex, p2, lod ) + g1x * textureLod( tex, p3, lod ) );\n }\n vec4 textureBicubic( sampler2D sampler, vec2 uv, float lod ) {\n vec2 fLodSize = vec2( textureSize( sampler, int( lod ) ) );\n vec2 cLodSize = vec2( textureSize( sampler, int( lod + 1.0 ) ) );\n vec2 fLodSizeInv = 1.0 / fLodSize;\n vec2 cLodSizeInv = 1.0 / cLodSize;\n vec4 fSample = bicubic( sampler, uv, vec4( fLodSizeInv, fLodSize ), floor( lod ) );\n vec4 cSample = bicubic( sampler, uv, vec4( cLodSizeInv, cLodSize ), ceil( lod ) );\n return mix( fSample, cSample, fract( lod ) );\n }\n vec3 getVolumeTransmissionRay( const in vec3 n, const in vec3 v, const in float thickness, const in float ior, const in mat4 modelMatrix ) {\n vec3 refractionVector = refract( - v, normalize( n ), 1.0 / ior );\n vec3 modelScale;\n modelScale.x = length( vec3( modelMatrix[ 0 ].xyz ) );\n modelScale.y = length( vec3( modelMatrix[ 1 ].xyz ) );\n modelScale.z = length( vec3( modelMatrix[ 2 ].xyz ) );\n return normalize( refractionVector ) * thickness * modelScale;\n }\n float applyIorToRoughness( const in float roughness, const in float ior ) {\n return roughness * clamp( ior * 2.0 - 2.0, 0.0, 1.0 );\n }\n vec4 getTransmissionSample( const in vec2 fragCoord, const in float roughness, const in float ior ) {\n float lod = log2( transmissionSamplerSize.x ) * applyIorToRoughness( roughness, ior );\n return textureBicubic( transmissionSamplerMap, fragCoord.xy, lod );\n }\n vec3 volumeAttenuation( const in float transmissionDistance, const in vec3 attenuationColor, const in float attenuationDistance ) {\n if ( isinf( attenuationDistance ) ) {\n return vec3( 1.0 );\n } else {\n vec3 attenuationCoefficient = -log( attenuationColor ) / attenuationDistance;\n vec3 transmittance = exp( - attenuationCoefficient * transmissionDistance ); return transmittance;\n }\n }\n vec4 getIBLVolumeRefraction( const in vec3 n, const in vec3 v, const in float roughness, const in vec3 diffuseColor,\n const in vec3 specularColor, const in float specularF90, const in vec3 position, const in mat4 modelMatrix,\n const in mat4 viewMatrix, const in mat4 projMatrix, const in float ior, const in float thickness,\n const in vec3 attenuationColor, const in float attenuationDistance ) {\n vec3 transmissionRay = getVolumeTransmissionRay( n, v, thickness, ior, modelMatrix );\n vec3 refractedRayExit = position + transmissionRay;\n vec4 ndcPos = projMatrix * viewMatrix * vec4( refractedRayExit, 1.0 );\n vec2 refractionCoords = ndcPos.xy / ndcPos.w;\n refractionCoords += 1.0;\n refractionCoords /= 2.0;\n vec4 transmittedLight = getTransmissionSample( refractionCoords, roughness, ior );\n vec3 transmittance = diffuseColor * volumeAttenuation( length( transmissionRay ), attenuationColor, attenuationDistance );\n vec3 attenuatedColor = transmittance * transmittedLight.rgb;\n vec3 F = EnvironmentBRDF( n, v, specularColor, specularF90, roughness );\n float transmittanceFactor = ( transmittance.r + transmittance.g + transmittance.b ) / 3.0;\n return vec4( ( 1.0 - F ) * attenuatedColor, 1.0 - ( 1.0 - transmittedLight.a ) * transmittanceFactor );\n }\n#endif"; +var uv_pars_fragment = "#if defined( USE_UV ) || defined( USE_ANISOTROPY )\n varying vec2 vUv;\n#endif\n#ifdef USE_MAP\n varying vec2 vMapUv;\n#endif\n#ifdef USE_ALPHAMAP\n varying vec2 vAlphaMapUv;\n#endif\n#ifdef USE_LIGHTMAP\n varying vec2 vLightMapUv;\n#endif\n#ifdef USE_AOMAP\n varying vec2 vAoMapUv;\n#endif\n#ifdef USE_BUMPMAP\n varying vec2 vBumpMapUv;\n#endif\n#ifdef USE_NORMALMAP\n varying vec2 vNormalMapUv;\n#endif\n#ifdef USE_EMISSIVEMAP\n varying vec2 vEmissiveMapUv;\n#endif\n#ifdef USE_METALNESSMAP\n varying vec2 vMetalnessMapUv;\n#endif\n#ifdef USE_ROUGHNESSMAP\n varying vec2 vRoughnessMapUv;\n#endif\n#ifdef USE_ANISOTROPYMAP\n varying vec2 vAnisotropyMapUv;\n#endif\n#ifdef USE_CLEARCOATMAP\n varying vec2 vClearcoatMapUv;\n#endif\n#ifdef USE_CLEARCOAT_NORMALMAP\n varying vec2 vClearcoatNormalMapUv;\n#endif\n#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n varying vec2 vClearcoatRoughnessMapUv;\n#endif\n#ifdef USE_IRIDESCENCEMAP\n varying vec2 vIridescenceMapUv;\n#endif\n#ifdef USE_IRIDESCENCE_THICKNESSMAP\n varying vec2 vIridescenceThicknessMapUv;\n#endif\n#ifdef USE_SHEEN_COLORMAP\n varying vec2 vSheenColorMapUv;\n#endif\n#ifdef USE_SHEEN_ROUGHNESSMAP\n varying vec2 vSheenRoughnessMapUv;\n#endif\n#ifdef USE_SPECULARMAP\n varying vec2 vSpecularMapUv;\n#endif\n#ifdef USE_SPECULAR_COLORMAP\n varying vec2 vSpecularColorMapUv;\n#endif\n#ifdef USE_SPECULAR_INTENSITYMAP\n varying vec2 vSpecularIntensityMapUv;\n#endif\n#ifdef USE_TRANSMISSIONMAP\n uniform mat3 transmissionMapTransform;\n varying vec2 vTransmissionMapUv;\n#endif\n#ifdef USE_THICKNESSMAP\n uniform mat3 thicknessMapTransform;\n varying vec2 vThicknessMapUv;\n#endif"; +var uv_pars_vertex = "#if defined( USE_UV ) || defined( USE_ANISOTROPY )\n varying vec2 vUv;\n#endif\n#ifdef USE_MAP\n uniform mat3 mapTransform;\n varying vec2 vMapUv;\n#endif\n#ifdef USE_ALPHAMAP\n uniform mat3 alphaMapTransform;\n varying vec2 vAlphaMapUv;\n#endif\n#ifdef USE_LIGHTMAP\n uniform mat3 lightMapTransform;\n varying vec2 vLightMapUv;\n#endif\n#ifdef USE_AOMAP\n uniform mat3 aoMapTransform;\n varying vec2 vAoMapUv;\n#endif\n#ifdef USE_BUMPMAP\n uniform mat3 bumpMapTransform;\n varying vec2 vBumpMapUv;\n#endif\n#ifdef USE_NORMALMAP\n uniform mat3 normalMapTransform;\n varying vec2 vNormalMapUv;\n#endif\n#ifdef USE_DISPLACEMENTMAP\n uniform mat3 displacementMapTransform;\n varying vec2 vDisplacementMapUv;\n#endif\n#ifdef USE_EMISSIVEMAP\n uniform mat3 emissiveMapTransform;\n varying vec2 vEmissiveMapUv;\n#endif\n#ifdef USE_METALNESSMAP\n uniform mat3 metalnessMapTransform;\n varying vec2 vMetalnessMapUv;\n#endif\n#ifdef USE_ROUGHNESSMAP\n uniform mat3 roughnessMapTransform;\n varying vec2 vRoughnessMapUv;\n#endif\n#ifdef USE_ANISOTROPYMAP\n uniform mat3 anisotropyMapTransform;\n varying vec2 vAnisotropyMapUv;\n#endif\n#ifdef USE_CLEARCOATMAP\n uniform mat3 clearcoatMapTransform;\n varying vec2 vClearcoatMapUv;\n#endif\n#ifdef USE_CLEARCOAT_NORMALMAP\n uniform mat3 clearcoatNormalMapTransform;\n varying vec2 vClearcoatNormalMapUv;\n#endif\n#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n uniform mat3 clearcoatRoughnessMapTransform;\n varying vec2 vClearcoatRoughnessMapUv;\n#endif\n#ifdef USE_SHEEN_COLORMAP\n uniform mat3 sheenColorMapTransform;\n varying vec2 vSheenColorMapUv;\n#endif\n#ifdef USE_SHEEN_ROUGHNESSMAP\n uniform mat3 sheenRoughnessMapTransform;\n varying vec2 vSheenRoughnessMapUv;\n#endif\n#ifdef USE_IRIDESCENCEMAP\n uniform mat3 iridescenceMapTransform;\n varying vec2 vIridescenceMapUv;\n#endif\n#ifdef USE_IRIDESCENCE_THICKNESSMAP\n uniform mat3 iridescenceThicknessMapTransform;\n varying vec2 vIridescenceThicknessMapUv;\n#endif\n#ifdef USE_SPECULARMAP\n uniform mat3 specularMapTransform;\n varying vec2 vSpecularMapUv;\n#endif\n#ifdef USE_SPECULAR_COLORMAP\n uniform mat3 specularColorMapTransform;\n varying vec2 vSpecularColorMapUv;\n#endif\n#ifdef USE_SPECULAR_INTENSITYMAP\n uniform mat3 specularIntensityMapTransform;\n varying vec2 vSpecularIntensityMapUv;\n#endif\n#ifdef USE_TRANSMISSIONMAP\n uniform mat3 transmissionMapTransform;\n varying vec2 vTransmissionMapUv;\n#endif\n#ifdef USE_THICKNESSMAP\n uniform mat3 thicknessMapTransform;\n varying vec2 vThicknessMapUv;\n#endif"; +var uv_vertex = "#if defined( USE_UV ) || defined( USE_ANISOTROPY )\n vUv = vec3( uv, 1 ).xy;\n#endif\n#ifdef USE_MAP\n vMapUv = ( mapTransform * vec3( MAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_ALPHAMAP\n vAlphaMapUv = ( alphaMapTransform * vec3( ALPHAMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_LIGHTMAP\n vLightMapUv = ( lightMapTransform * vec3( LIGHTMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_AOMAP\n vAoMapUv = ( aoMapTransform * vec3( AOMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_BUMPMAP\n vBumpMapUv = ( bumpMapTransform * vec3( BUMPMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_NORMALMAP\n vNormalMapUv = ( normalMapTransform * vec3( NORMALMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_DISPLACEMENTMAP\n vDisplacementMapUv = ( displacementMapTransform * vec3( DISPLACEMENTMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_EMISSIVEMAP\n vEmissiveMapUv = ( emissiveMapTransform * vec3( EMISSIVEMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_METALNESSMAP\n vMetalnessMapUv = ( metalnessMapTransform * vec3( METALNESSMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_ROUGHNESSMAP\n vRoughnessMapUv = ( roughnessMapTransform * vec3( ROUGHNESSMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_ANISOTROPYMAP\n vAnisotropyMapUv = ( anisotropyMapTransform * vec3( ANISOTROPYMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_CLEARCOATMAP\n vClearcoatMapUv = ( clearcoatMapTransform * vec3( CLEARCOATMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_CLEARCOAT_NORMALMAP\n vClearcoatNormalMapUv = ( clearcoatNormalMapTransform * vec3( CLEARCOAT_NORMALMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n vClearcoatRoughnessMapUv = ( clearcoatRoughnessMapTransform * vec3( CLEARCOAT_ROUGHNESSMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_IRIDESCENCEMAP\n vIridescenceMapUv = ( iridescenceMapTransform * vec3( IRIDESCENCEMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_IRIDESCENCE_THICKNESSMAP\n vIridescenceThicknessMapUv = ( iridescenceThicknessMapTransform * vec3( IRIDESCENCE_THICKNESSMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_SHEEN_COLORMAP\n vSheenColorMapUv = ( sheenColorMapTransform * vec3( SHEEN_COLORMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_SHEEN_ROUGHNESSMAP\n vSheenRoughnessMapUv = ( sheenRoughnessMapTransform * vec3( SHEEN_ROUGHNESSMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_SPECULARMAP\n vSpecularMapUv = ( specularMapTransform * vec3( SPECULARMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_SPECULAR_COLORMAP\n vSpecularColorMapUv = ( specularColorMapTransform * vec3( SPECULAR_COLORMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_SPECULAR_INTENSITYMAP\n vSpecularIntensityMapUv = ( specularIntensityMapTransform * vec3( SPECULAR_INTENSITYMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_TRANSMISSIONMAP\n vTransmissionMapUv = ( transmissionMapTransform * vec3( TRANSMISSIONMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_THICKNESSMAP\n vThicknessMapUv = ( thicknessMapTransform * vec3( THICKNESSMAP_UV, 1 ) ).xy;\n#endif"; +var worldpos_vertex = "#if defined( USE_ENVMAP ) || defined( DISTANCE ) || defined ( USE_SHADOWMAP ) || defined ( USE_TRANSMISSION ) || NUM_SPOT_LIGHT_COORDS > 0\n vec4 worldPosition = vec4( transformed, 1.0 );\n #ifdef USE_BATCHING\n worldPosition = batchingMatrix * worldPosition;\n #endif\n #ifdef USE_INSTANCING\n worldPosition = instanceMatrix * worldPosition;\n #endif\n worldPosition = modelMatrix * worldPosition;\n#endif"; +var vertex$h = "varying vec2 vUv;\nuniform mat3 uvTransform;\nvoid main() {\n vUv = ( uvTransform * vec3( uv, 1 ) ).xy;\n gl_Position = vec4( position.xy, 1.0, 1.0 );\n}"; +var fragment$h = "uniform sampler2D t2D;\nuniform float backgroundIntensity;\nvarying vec2 vUv;\nvoid main() {\n vec4 texColor = texture2D( t2D, vUv );\n #ifdef DECODE_VIDEO_TEXTURE\n texColor = vec4( mix( pow( texColor.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), texColor.rgb * 0.0773993808, vec3( lessThanEqual( texColor.rgb, vec3( 0.04045 ) ) ) ), texColor.w );\n #endif\n texColor.rgb *= backgroundIntensity;\n gl_FragColor = texColor;\n #include \n #include \n}"; +var vertex$g = "varying vec3 vWorldDirection;\n#include \nvoid main() {\n vWorldDirection = transformDirection( position, modelMatrix );\n #include \n #include \n gl_Position.z = gl_Position.w;\n}"; +var fragment$g = "#ifdef ENVMAP_TYPE_CUBE\n uniform samplerCube envMap;\n#elif defined( ENVMAP_TYPE_CUBE_UV )\n uniform sampler2D envMap;\n#endif\nuniform float flipEnvMap;\nuniform float backgroundBlurriness;\nuniform float backgroundIntensity;\nuniform mat3 backgroundRotation;\nvarying vec3 vWorldDirection;\n#include \nvoid main() {\n #ifdef ENVMAP_TYPE_CUBE\n vec4 texColor = textureCube( envMap, backgroundRotation * vec3( flipEnvMap * vWorldDirection.x, vWorldDirection.yz ) );\n #elif defined( ENVMAP_TYPE_CUBE_UV )\n vec4 texColor = textureCubeUV( envMap, backgroundRotation * vWorldDirection, backgroundBlurriness );\n #else\n vec4 texColor = vec4( 0.0, 0.0, 0.0, 1.0 );\n #endif\n texColor.rgb *= backgroundIntensity;\n gl_FragColor = texColor;\n #include \n #include \n}"; +var vertex$f = "varying vec3 vWorldDirection;\n#include \nvoid main() {\n vWorldDirection = transformDirection( position, modelMatrix );\n #include \n #include \n gl_Position.z = gl_Position.w;\n}"; +var fragment$f = "uniform samplerCube tCube;\nuniform float tFlip;\nuniform float opacity;\nvarying vec3 vWorldDirection;\nvoid main() {\n vec4 texColor = textureCube( tCube, vec3( tFlip * vWorldDirection.x, vWorldDirection.yz ) );\n gl_FragColor = texColor;\n gl_FragColor.a *= opacity;\n #include \n #include \n}"; +var vertex$e = "#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvarying vec2 vHighPrecisionZW;\nvoid main() {\n #include \n #include \n #include \n #include \n #ifdef USE_DISPLACEMENTMAP\n #include \n #include \n #include \n #endif\n #include \n #include \n #include \n #include \n #include \n #include \n #include \n vHighPrecisionZW = gl_Position.zw;\n}"; +var fragment$e = "#if DEPTH_PACKING == 3200\n uniform float opacity;\n#endif\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvarying vec2 vHighPrecisionZW;\nvoid main() {\n vec4 diffuseColor = vec4( 1.0 );\n #include \n #if DEPTH_PACKING == 3200\n diffuseColor.a = opacity;\n #endif\n #include \n #include \n #include \n #include \n #include \n float fragCoordZ = 0.5 * vHighPrecisionZW[0] / vHighPrecisionZW[1] + 0.5;\n #if DEPTH_PACKING == 3200\n gl_FragColor = vec4( vec3( 1.0 - fragCoordZ ), opacity );\n #elif DEPTH_PACKING == 3201\n gl_FragColor = packDepthToRGBA( fragCoordZ );\n #endif\n}"; +var vertex$d = "#define DISTANCE\nvarying vec3 vWorldPosition;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n #include \n #include \n #include \n #include \n #ifdef USE_DISPLACEMENTMAP\n #include \n #include \n #include \n #endif\n #include \n #include \n #include \n #include \n #include \n #include \n #include \n vWorldPosition = worldPosition.xyz;\n}"; +var fragment$d = "#define DISTANCE\nuniform vec3 referencePosition;\nuniform float nearDistance;\nuniform float farDistance;\nvarying vec3 vWorldPosition;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main () {\n vec4 diffuseColor = vec4( 1.0 );\n #include \n #include \n #include \n #include \n #include \n float dist = length( vWorldPosition - referencePosition );\n dist = ( dist - nearDistance ) / ( farDistance - nearDistance );\n dist = saturate( dist );\n gl_FragColor = packDepthToRGBA( dist );\n}"; +var vertex$c = "varying vec3 vWorldDirection;\n#include \nvoid main() {\n vWorldDirection = transformDirection( position, modelMatrix );\n #include \n #include \n}"; +var fragment$c = "uniform sampler2D tEquirect;\nvarying vec3 vWorldDirection;\n#include \nvoid main() {\n vec3 direction = normalize( vWorldDirection );\n vec2 sampleUV = equirectUv( direction );\n gl_FragColor = texture2D( tEquirect, sampleUV );\n #include \n #include \n}"; +var vertex$b = "uniform float scale;\nattribute float lineDistance;\nvarying float vLineDistance;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n vLineDistance = scale * lineDistance;\n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n}"; +var fragment$b = "uniform vec3 diffuse;\nuniform float opacity;\nuniform float dashSize;\nuniform float totalSize;\nvarying float vLineDistance;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n vec4 diffuseColor = vec4( diffuse, opacity );\n #include \n if ( mod( vLineDistance, totalSize ) > dashSize ) {\n discard;\n }\n vec3 outgoingLight = vec3( 0.0 );\n #include \n #include \n #include \n outgoingLight = diffuseColor.rgb;\n #include \n #include \n #include \n #include \n #include \n}"; +var vertex$a = "#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n #include \n #include \n #include \n #include \n #include \n #if defined ( USE_ENVMAP ) || defined ( USE_SKINNING )\n #include \n #include \n #include \n #include \n #include \n #endif\n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n}"; +var fragment$a = "uniform vec3 diffuse;\nuniform float opacity;\n#ifndef FLAT_SHADED\n varying vec3 vNormal;\n#endif\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n vec4 diffuseColor = vec4( diffuse, opacity );\n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n #ifdef USE_LIGHTMAP\n vec4 lightMapTexel = texture2D( lightMap, vLightMapUv );\n reflectedLight.indirectDiffuse += lightMapTexel.rgb * lightMapIntensity * RECIPROCAL_PI;\n #else\n reflectedLight.indirectDiffuse += vec3( 1.0 );\n #endif\n #include \n reflectedLight.indirectDiffuse *= diffuseColor.rgb;\n vec3 outgoingLight = reflectedLight.indirectDiffuse;\n #include \n #include \n #include \n #include \n #include \n #include \n #include \n}"; +var vertex$9 = "#define LAMBERT\nvarying vec3 vViewPosition;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n vViewPosition = - mvPosition.xyz;\n #include \n #include \n #include \n #include \n}"; +var fragment$9 = "#define LAMBERT\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float opacity;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n vec4 diffuseColor = vec4( diffuse, opacity );\n #include \n ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n vec3 totalEmissiveRadiance = emissive;\n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;\n #include \n #include \n #include \n #include \n #include \n #include \n #include \n}"; +var vertex$8 = "#define MATCAP\nvarying vec3 vViewPosition;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n vViewPosition = - mvPosition.xyz;\n}"; +var fragment$8 = "#define MATCAP\nuniform vec3 diffuse;\nuniform float opacity;\nuniform sampler2D matcap;\nvarying vec3 vViewPosition;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n vec4 diffuseColor = vec4( diffuse, opacity );\n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n vec3 viewDir = normalize( vViewPosition );\n vec3 x = normalize( vec3( viewDir.z, 0.0, - viewDir.x ) );\n vec3 y = cross( viewDir, x );\n vec2 uv = vec2( dot( x, normal ), dot( y, normal ) ) * 0.495 + 0.5;\n #ifdef USE_MATCAP\n vec4 matcapColor = texture2D( matcap, uv );\n #else\n vec4 matcapColor = vec4( vec3( mix( 0.2, 0.8, uv.y ) ), 1.0 );\n #endif\n vec3 outgoingLight = diffuseColor.rgb * matcapColor.rgb;\n #include \n #include \n #include \n #include \n #include \n #include \n}"; +var vertex$7 = "#define NORMAL\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP_TANGENTSPACE )\n varying vec3 vViewPosition;\n#endif\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP_TANGENTSPACE )\n vViewPosition = - mvPosition.xyz;\n#endif\n}"; +var fragment$7 = "#define NORMAL\nuniform float opacity;\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP_TANGENTSPACE )\n varying vec3 vViewPosition;\n#endif\n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n vec4 diffuseColor = vec4( 0.0, 0.0, 0.0, opacity );\n #include \n #include \n #include \n #include \n gl_FragColor = vec4( packNormalToRGB( normal ), diffuseColor.a );\n #ifdef OPAQUE\n gl_FragColor.a = 1.0;\n #endif\n}"; +var vertex$6 = "#define PHONG\nvarying vec3 vViewPosition;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n vViewPosition = - mvPosition.xyz;\n #include \n #include \n #include \n #include \n}"; +var fragment$6 = "#define PHONG\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform vec3 specular;\nuniform float shininess;\nuniform float opacity;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n vec4 diffuseColor = vec4( diffuse, opacity );\n #include \n ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n vec3 totalEmissiveRadiance = emissive;\n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;\n #include \n #include \n #include \n #include \n #include \n #include \n #include \n}"; +var vertex$5 = "#define STANDARD\nvarying vec3 vViewPosition;\n#ifdef USE_TRANSMISSION\n varying vec3 vWorldPosition;\n#endif\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n vViewPosition = - mvPosition.xyz;\n #include \n #include \n #include \n#ifdef USE_TRANSMISSION\n vWorldPosition = worldPosition.xyz;\n#endif\n}"; +var fragment$5 = "#define STANDARD\n#ifdef PHYSICAL\n #define IOR\n #define USE_SPECULAR\n#endif\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float roughness;\nuniform float metalness;\nuniform float opacity;\n#ifdef IOR\n uniform float ior;\n#endif\n#ifdef USE_SPECULAR\n uniform float specularIntensity;\n uniform vec3 specularColor;\n #ifdef USE_SPECULAR_COLORMAP\n uniform sampler2D specularColorMap;\n #endif\n #ifdef USE_SPECULAR_INTENSITYMAP\n uniform sampler2D specularIntensityMap;\n #endif\n#endif\n#ifdef USE_CLEARCOAT\n uniform float clearcoat;\n uniform float clearcoatRoughness;\n#endif\n#ifdef USE_IRIDESCENCE\n uniform float iridescence;\n uniform float iridescenceIOR;\n uniform float iridescenceThicknessMinimum;\n uniform float iridescenceThicknessMaximum;\n#endif\n#ifdef USE_SHEEN\n uniform vec3 sheenColor;\n uniform float sheenRoughness;\n #ifdef USE_SHEEN_COLORMAP\n uniform sampler2D sheenColorMap;\n #endif\n #ifdef USE_SHEEN_ROUGHNESSMAP\n uniform sampler2D sheenRoughnessMap;\n #endif\n#endif\n#ifdef USE_ANISOTROPY\n uniform vec2 anisotropyVector;\n #ifdef USE_ANISOTROPYMAP\n uniform sampler2D anisotropyMap;\n #endif\n#endif\nvarying vec3 vViewPosition;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n vec4 diffuseColor = vec4( diffuse, opacity );\n #include \n ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n vec3 totalEmissiveRadiance = emissive;\n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n vec3 totalDiffuse = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse;\n vec3 totalSpecular = reflectedLight.directSpecular + reflectedLight.indirectSpecular;\n #include \n vec3 outgoingLight = totalDiffuse + totalSpecular + totalEmissiveRadiance;\n #ifdef USE_SHEEN\n float sheenEnergyComp = 1.0 - 0.157 * max3( material.sheenColor );\n outgoingLight = outgoingLight * sheenEnergyComp + sheenSpecularDirect + sheenSpecularIndirect;\n #endif\n #ifdef USE_CLEARCOAT\n float dotNVcc = saturate( dot( geometryClearcoatNormal, geometryViewDir ) );\n vec3 Fcc = F_Schlick( material.clearcoatF0, material.clearcoatF90, dotNVcc );\n outgoingLight = outgoingLight * ( 1.0 - material.clearcoat * Fcc ) + ( clearcoatSpecularDirect + clearcoatSpecularIndirect ) * material.clearcoat;\n #endif\n #include \n #include \n #include \n #include \n #include \n #include \n}"; +var vertex$4 = "#define TOON\nvarying vec3 vViewPosition;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n vViewPosition = - mvPosition.xyz;\n #include \n #include \n #include \n}"; +var fragment$4 = "#define TOON\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float opacity;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n vec4 diffuseColor = vec4( diffuse, opacity );\n #include \n ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n vec3 totalEmissiveRadiance = emissive;\n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;\n #include \n #include \n #include \n #include \n #include \n #include \n}"; +var vertex$3 = "uniform float size;\nuniform float scale;\n#include \n#include \n#include \n#include \n#include \n#include \n#ifdef USE_POINTS_UV\n varying vec2 vUv;\n uniform mat3 uvTransform;\n#endif\nvoid main() {\n #ifdef USE_POINTS_UV\n vUv = ( uvTransform * vec3( uv, 1 ) ).xy;\n #endif\n #include \n #include \n #include \n #include \n #include \n #include \n gl_PointSize = size;\n #ifdef USE_SIZEATTENUATION\n bool isPerspective = isPerspectiveMatrix( projectionMatrix );\n if ( isPerspective ) gl_PointSize *= ( scale / - mvPosition.z );\n #endif\n #include \n #include \n #include \n #include \n}"; +var fragment$3 = "uniform vec3 diffuse;\nuniform float opacity;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n vec4 diffuseColor = vec4( diffuse, opacity );\n #include \n vec3 outgoingLight = vec3( 0.0 );\n #include \n #include \n #include \n #include \n #include \n outgoingLight = diffuseColor.rgb;\n #include \n #include \n #include \n #include \n #include \n}"; +var vertex$2 = "#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n #include \n}"; +var fragment$2 = "uniform vec3 color;\nuniform float opacity;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n #include \n gl_FragColor = vec4( color, opacity * ( 1.0 - getShadowMask() ) );\n #include \n #include \n #include \n}"; +var vertex$1 = "uniform float rotation;\nuniform vec2 center;\n#include \n#include \n#include \n#include \n#include \nvoid main() {\n #include \n vec4 mvPosition = modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );\n vec2 scale;\n scale.x = length( vec3( modelMatrix[ 0 ].x, modelMatrix[ 0 ].y, modelMatrix[ 0 ].z ) );\n scale.y = length( vec3( modelMatrix[ 1 ].x, modelMatrix[ 1 ].y, modelMatrix[ 1 ].z ) );\n #ifndef USE_SIZEATTENUATION\n bool isPerspective = isPerspectiveMatrix( projectionMatrix );\n if ( isPerspective ) scale *= - mvPosition.z;\n #endif\n vec2 alignedPosition = ( position.xy - ( center - vec2( 0.5 ) ) ) * scale;\n vec2 rotatedPosition;\n rotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;\n rotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;\n mvPosition.xy += rotatedPosition;\n gl_Position = projectionMatrix * mvPosition;\n #include \n #include \n #include \n}"; +var fragment$1 = "uniform vec3 diffuse;\nuniform float opacity;\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nvoid main() {\n vec4 diffuseColor = vec4( diffuse, opacity );\n #include \n vec3 outgoingLight = vec3( 0.0 );\n #include \n #include \n #include \n #include \n #include \n outgoingLight = diffuseColor.rgb;\n #include \n #include \n #include \n #include \n}"; +var ShaderChunk = { + alphahash_fragment, + alphahash_pars_fragment, + alphamap_fragment, + alphamap_pars_fragment, + alphatest_fragment, + alphatest_pars_fragment, + aomap_fragment, + aomap_pars_fragment, + batching_pars_vertex, + batching_vertex, + begin_vertex, + beginnormal_vertex, + bsdfs, + iridescence_fragment, + bumpmap_pars_fragment, + clipping_planes_fragment, + clipping_planes_pars_fragment, + clipping_planes_pars_vertex, + clipping_planes_vertex, + color_fragment, + color_pars_fragment, + color_pars_vertex, + color_vertex, + common, + cube_uv_reflection_fragment, + defaultnormal_vertex, + displacementmap_pars_vertex, + displacementmap_vertex, + emissivemap_fragment, + emissivemap_pars_fragment, + colorspace_fragment, + colorspace_pars_fragment, + envmap_fragment, + envmap_common_pars_fragment, + envmap_pars_fragment, + envmap_pars_vertex, + envmap_physical_pars_fragment, + envmap_vertex, + fog_vertex, + fog_pars_vertex, + fog_fragment, + fog_pars_fragment, + gradientmap_pars_fragment, + lightmap_fragment, + lightmap_pars_fragment, + lights_lambert_fragment, + lights_lambert_pars_fragment, + lights_pars_begin, + lights_toon_fragment, + lights_toon_pars_fragment, + lights_phong_fragment, + lights_phong_pars_fragment, + lights_physical_fragment, + lights_physical_pars_fragment, + lights_fragment_begin, + lights_fragment_maps, + lights_fragment_end, + logdepthbuf_fragment, + logdepthbuf_pars_fragment, + logdepthbuf_pars_vertex, + logdepthbuf_vertex, + map_fragment, + map_pars_fragment, + map_particle_fragment, + map_particle_pars_fragment, + metalnessmap_fragment, + metalnessmap_pars_fragment, + morphinstance_vertex, + morphcolor_vertex, + morphnormal_vertex, + morphtarget_pars_vertex, + morphtarget_vertex, + normal_fragment_begin, + normal_fragment_maps, + normal_pars_fragment, + normal_pars_vertex, + normal_vertex, + normalmap_pars_fragment, + clearcoat_normal_fragment_begin, + clearcoat_normal_fragment_maps, + clearcoat_pars_fragment, + iridescence_pars_fragment, + opaque_fragment, + packing, + premultiplied_alpha_fragment, + project_vertex, + dithering_fragment, + dithering_pars_fragment, + roughnessmap_fragment, + roughnessmap_pars_fragment, + shadowmap_pars_fragment, + shadowmap_pars_vertex, + shadowmap_vertex, + shadowmask_pars_fragment, + skinbase_vertex, + skinning_pars_vertex, + skinning_vertex, + skinnormal_vertex, + specularmap_fragment, + specularmap_pars_fragment, + tonemapping_fragment, + tonemapping_pars_fragment, + transmission_fragment, + transmission_pars_fragment, + uv_pars_fragment, + uv_pars_vertex, + uv_vertex, + worldpos_vertex, + background_vert: vertex$h, + background_frag: fragment$h, + backgroundCube_vert: vertex$g, + backgroundCube_frag: fragment$g, + cube_vert: vertex$f, + cube_frag: fragment$f, + depth_vert: vertex$e, + depth_frag: fragment$e, + distanceRGBA_vert: vertex$d, + distanceRGBA_frag: fragment$d, + equirect_vert: vertex$c, + equirect_frag: fragment$c, + linedashed_vert: vertex$b, + linedashed_frag: fragment$b, + meshbasic_vert: vertex$a, + meshbasic_frag: fragment$a, + meshlambert_vert: vertex$9, + meshlambert_frag: fragment$9, + meshmatcap_vert: vertex$8, + meshmatcap_frag: fragment$8, + meshnormal_vert: vertex$7, + meshnormal_frag: fragment$7, + meshphong_vert: vertex$6, + meshphong_frag: fragment$6, + meshphysical_vert: vertex$5, + meshphysical_frag: fragment$5, + meshtoon_vert: vertex$4, + meshtoon_frag: fragment$4, + points_vert: vertex$3, + points_frag: fragment$3, + shadow_vert: vertex$2, + shadow_frag: fragment$2, + sprite_vert: vertex$1, + sprite_frag: fragment$1 +}; +var UniformsLib = { + common: { + diffuse: { value: /* @__PURE__ */ new Color(16777215) }, + opacity: { value: 1 }, + map: { value: null }, + mapTransform: { value: /* @__PURE__ */ new Matrix3() }, + alphaMap: { value: null }, + alphaMapTransform: { value: /* @__PURE__ */ new Matrix3() }, + alphaTest: { value: 0 } + }, + specularmap: { + specularMap: { value: null }, + specularMapTransform: { value: /* @__PURE__ */ new Matrix3() } + }, + envmap: { + envMap: { value: null }, + envMapRotation: { value: /* @__PURE__ */ new Matrix3() }, + flipEnvMap: { value: -1 }, + reflectivity: { value: 1 }, + // basic, lambert, phong + ior: { value: 1.5 }, + // physical + refractionRatio: { value: 0.98 } + // basic, lambert, phong + }, + aomap: { + aoMap: { value: null }, + aoMapIntensity: { value: 1 }, + aoMapTransform: { value: /* @__PURE__ */ new Matrix3() } + }, + lightmap: { + lightMap: { value: null }, + lightMapIntensity: { value: 1 }, + lightMapTransform: { value: /* @__PURE__ */ new Matrix3() } + }, + bumpmap: { + bumpMap: { value: null }, + bumpMapTransform: { value: /* @__PURE__ */ new Matrix3() }, + bumpScale: { value: 1 } + }, + normalmap: { + normalMap: { value: null }, + normalMapTransform: { value: /* @__PURE__ */ new Matrix3() }, + normalScale: { value: /* @__PURE__ */ new Vector2(1, 1) } + }, + displacementmap: { + displacementMap: { value: null }, + displacementMapTransform: { value: /* @__PURE__ */ new Matrix3() }, + displacementScale: { value: 1 }, + displacementBias: { value: 0 } + }, + emissivemap: { + emissiveMap: { value: null }, + emissiveMapTransform: { value: /* @__PURE__ */ new Matrix3() } + }, + metalnessmap: { + metalnessMap: { value: null }, + metalnessMapTransform: { value: /* @__PURE__ */ new Matrix3() } + }, + roughnessmap: { + roughnessMap: { value: null }, + roughnessMapTransform: { value: /* @__PURE__ */ new Matrix3() } + }, + gradientmap: { + gradientMap: { value: null } + }, + fog: { + fogDensity: { value: 25e-5 }, + fogNear: { value: 1 }, + fogFar: { value: 2e3 }, + fogColor: { value: /* @__PURE__ */ new Color(16777215) } + }, + lights: { + ambientLightColor: { value: [] }, + lightProbe: { value: [] }, + directionalLights: { value: [], properties: { + direction: {}, + color: {} + } }, + directionalLightShadows: { value: [], properties: { + shadowBias: {}, + shadowNormalBias: {}, + shadowRadius: {}, + shadowMapSize: {} + } }, + directionalShadowMap: { value: [] }, + directionalShadowMatrix: { value: [] }, + spotLights: { value: [], properties: { + color: {}, + position: {}, + direction: {}, + distance: {}, + coneCos: {}, + penumbraCos: {}, + decay: {} + } }, + spotLightShadows: { value: [], properties: { + shadowBias: {}, + shadowNormalBias: {}, + shadowRadius: {}, + shadowMapSize: {} + } }, + spotLightMap: { value: [] }, + spotShadowMap: { value: [] }, + spotLightMatrix: { value: [] }, + pointLights: { value: [], properties: { + color: {}, + position: {}, + decay: {}, + distance: {} + } }, + pointLightShadows: { value: [], properties: { + shadowBias: {}, + shadowNormalBias: {}, + shadowRadius: {}, + shadowMapSize: {}, + shadowCameraNear: {}, + shadowCameraFar: {} + } }, + pointShadowMap: { value: [] }, + pointShadowMatrix: { value: [] }, + hemisphereLights: { value: [], properties: { + direction: {}, + skyColor: {}, + groundColor: {} + } }, + // TODO (abelnation): RectAreaLight BRDF data needs to be moved from example to main src + rectAreaLights: { value: [], properties: { + color: {}, + position: {}, + width: {}, + height: {} + } }, + ltc_1: { value: null }, + ltc_2: { value: null } + }, + points: { + diffuse: { value: /* @__PURE__ */ new Color(16777215) }, + opacity: { value: 1 }, + size: { value: 1 }, + scale: { value: 1 }, + map: { value: null }, + alphaMap: { value: null }, + alphaMapTransform: { value: /* @__PURE__ */ new Matrix3() }, + alphaTest: { value: 0 }, + uvTransform: { value: /* @__PURE__ */ new Matrix3() } + }, + sprite: { + diffuse: { value: /* @__PURE__ */ new Color(16777215) }, + opacity: { value: 1 }, + center: { value: /* @__PURE__ */ new Vector2(0.5, 0.5) }, + rotation: { value: 0 }, + map: { value: null }, + mapTransform: { value: /* @__PURE__ */ new Matrix3() }, + alphaMap: { value: null }, + alphaMapTransform: { value: /* @__PURE__ */ new Matrix3() }, + alphaTest: { value: 0 } + } +}; +var ShaderLib = { + basic: { + uniforms: /* @__PURE__ */ mergeUniforms([ + UniformsLib.common, + UniformsLib.specularmap, + UniformsLib.envmap, + UniformsLib.aomap, + UniformsLib.lightmap, + UniformsLib.fog + ]), + vertexShader: ShaderChunk.meshbasic_vert, + fragmentShader: ShaderChunk.meshbasic_frag + }, + lambert: { + uniforms: /* @__PURE__ */ mergeUniforms([ + UniformsLib.common, + UniformsLib.specularmap, + UniformsLib.envmap, + UniformsLib.aomap, + UniformsLib.lightmap, + UniformsLib.emissivemap, + UniformsLib.bumpmap, + UniformsLib.normalmap, + UniformsLib.displacementmap, + UniformsLib.fog, + UniformsLib.lights, + { + emissive: { value: /* @__PURE__ */ new Color(0) } + } + ]), + vertexShader: ShaderChunk.meshlambert_vert, + fragmentShader: ShaderChunk.meshlambert_frag + }, + phong: { + uniforms: /* @__PURE__ */ mergeUniforms([ + UniformsLib.common, + UniformsLib.specularmap, + UniformsLib.envmap, + UniformsLib.aomap, + UniformsLib.lightmap, + UniformsLib.emissivemap, + UniformsLib.bumpmap, + UniformsLib.normalmap, + UniformsLib.displacementmap, + UniformsLib.fog, + UniformsLib.lights, + { + emissive: { value: /* @__PURE__ */ new Color(0) }, + specular: { value: /* @__PURE__ */ new Color(1118481) }, + shininess: { value: 30 } + } + ]), + vertexShader: ShaderChunk.meshphong_vert, + fragmentShader: ShaderChunk.meshphong_frag + }, + standard: { + uniforms: /* @__PURE__ */ mergeUniforms([ + UniformsLib.common, + UniformsLib.envmap, + UniformsLib.aomap, + UniformsLib.lightmap, + UniformsLib.emissivemap, + UniformsLib.bumpmap, + UniformsLib.normalmap, + UniformsLib.displacementmap, + UniformsLib.roughnessmap, + UniformsLib.metalnessmap, + UniformsLib.fog, + UniformsLib.lights, + { + emissive: { value: /* @__PURE__ */ new Color(0) }, + roughness: { value: 1 }, + metalness: { value: 0 }, + envMapIntensity: { value: 1 } + } + ]), + vertexShader: ShaderChunk.meshphysical_vert, + fragmentShader: ShaderChunk.meshphysical_frag + }, + toon: { + uniforms: /* @__PURE__ */ mergeUniforms([ + UniformsLib.common, + UniformsLib.aomap, + UniformsLib.lightmap, + UniformsLib.emissivemap, + UniformsLib.bumpmap, + UniformsLib.normalmap, + UniformsLib.displacementmap, + UniformsLib.gradientmap, + UniformsLib.fog, + UniformsLib.lights, + { + emissive: { value: /* @__PURE__ */ new Color(0) } + } + ]), + vertexShader: ShaderChunk.meshtoon_vert, + fragmentShader: ShaderChunk.meshtoon_frag + }, + matcap: { + uniforms: /* @__PURE__ */ mergeUniforms([ + UniformsLib.common, + UniformsLib.bumpmap, + UniformsLib.normalmap, + UniformsLib.displacementmap, + UniformsLib.fog, + { + matcap: { value: null } + } + ]), + vertexShader: ShaderChunk.meshmatcap_vert, + fragmentShader: ShaderChunk.meshmatcap_frag + }, + points: { + uniforms: /* @__PURE__ */ mergeUniforms([ + UniformsLib.points, + UniformsLib.fog + ]), + vertexShader: ShaderChunk.points_vert, + fragmentShader: ShaderChunk.points_frag + }, + dashed: { + uniforms: /* @__PURE__ */ mergeUniforms([ + UniformsLib.common, + UniformsLib.fog, + { + scale: { value: 1 }, + dashSize: { value: 1 }, + totalSize: { value: 2 } + } + ]), + vertexShader: ShaderChunk.linedashed_vert, + fragmentShader: ShaderChunk.linedashed_frag + }, + depth: { + uniforms: /* @__PURE__ */ mergeUniforms([ + UniformsLib.common, + UniformsLib.displacementmap + ]), + vertexShader: ShaderChunk.depth_vert, + fragmentShader: ShaderChunk.depth_frag + }, + normal: { + uniforms: /* @__PURE__ */ mergeUniforms([ + UniformsLib.common, + UniformsLib.bumpmap, + UniformsLib.normalmap, + UniformsLib.displacementmap, + { + opacity: { value: 1 } + } + ]), + vertexShader: ShaderChunk.meshnormal_vert, + fragmentShader: ShaderChunk.meshnormal_frag + }, + sprite: { + uniforms: /* @__PURE__ */ mergeUniforms([ + UniformsLib.sprite, + UniformsLib.fog + ]), + vertexShader: ShaderChunk.sprite_vert, + fragmentShader: ShaderChunk.sprite_frag + }, + background: { + uniforms: { + uvTransform: { value: /* @__PURE__ */ new Matrix3() }, + t2D: { value: null }, + backgroundIntensity: { value: 1 } + }, + vertexShader: ShaderChunk.background_vert, + fragmentShader: ShaderChunk.background_frag + }, + backgroundCube: { + uniforms: { + envMap: { value: null }, + flipEnvMap: { value: -1 }, + backgroundBlurriness: { value: 0 }, + backgroundIntensity: { value: 1 }, + backgroundRotation: { value: /* @__PURE__ */ new Matrix3() } + }, + vertexShader: ShaderChunk.backgroundCube_vert, + fragmentShader: ShaderChunk.backgroundCube_frag + }, + cube: { + uniforms: { + tCube: { value: null }, + tFlip: { value: -1 }, + opacity: { value: 1 } + }, + vertexShader: ShaderChunk.cube_vert, + fragmentShader: ShaderChunk.cube_frag + }, + equirect: { + uniforms: { + tEquirect: { value: null } + }, + vertexShader: ShaderChunk.equirect_vert, + fragmentShader: ShaderChunk.equirect_frag + }, + distanceRGBA: { + uniforms: /* @__PURE__ */ mergeUniforms([ + UniformsLib.common, + UniformsLib.displacementmap, + { + referencePosition: { value: /* @__PURE__ */ new Vector3() }, + nearDistance: { value: 1 }, + farDistance: { value: 1e3 } + } + ]), + vertexShader: ShaderChunk.distanceRGBA_vert, + fragmentShader: ShaderChunk.distanceRGBA_frag + }, + shadow: { + uniforms: /* @__PURE__ */ mergeUniforms([ + UniformsLib.lights, + UniformsLib.fog, + { + color: { value: /* @__PURE__ */ new Color(0) }, + opacity: { value: 1 } + } + ]), + vertexShader: ShaderChunk.shadow_vert, + fragmentShader: ShaderChunk.shadow_frag + } +}; +ShaderLib.physical = { + uniforms: /* @__PURE__ */ mergeUniforms([ + ShaderLib.standard.uniforms, + { + clearcoat: { value: 0 }, + clearcoatMap: { value: null }, + clearcoatMapTransform: { value: /* @__PURE__ */ new Matrix3() }, + clearcoatNormalMap: { value: null }, + clearcoatNormalMapTransform: { value: /* @__PURE__ */ new Matrix3() }, + clearcoatNormalScale: { value: /* @__PURE__ */ new Vector2(1, 1) }, + clearcoatRoughness: { value: 0 }, + clearcoatRoughnessMap: { value: null }, + clearcoatRoughnessMapTransform: { value: /* @__PURE__ */ new Matrix3() }, + iridescence: { value: 0 }, + iridescenceMap: { value: null }, + iridescenceMapTransform: { value: /* @__PURE__ */ new Matrix3() }, + iridescenceIOR: { value: 1.3 }, + iridescenceThicknessMinimum: { value: 100 }, + iridescenceThicknessMaximum: { value: 400 }, + iridescenceThicknessMap: { value: null }, + iridescenceThicknessMapTransform: { value: /* @__PURE__ */ new Matrix3() }, + sheen: { value: 0 }, + sheenColor: { value: /* @__PURE__ */ new Color(0) }, + sheenColorMap: { value: null }, + sheenColorMapTransform: { value: /* @__PURE__ */ new Matrix3() }, + sheenRoughness: { value: 1 }, + sheenRoughnessMap: { value: null }, + sheenRoughnessMapTransform: { value: /* @__PURE__ */ new Matrix3() }, + transmission: { value: 0 }, + transmissionMap: { value: null }, + transmissionMapTransform: { value: /* @__PURE__ */ new Matrix3() }, + transmissionSamplerSize: { value: /* @__PURE__ */ new Vector2() }, + transmissionSamplerMap: { value: null }, + thickness: { value: 0 }, + thicknessMap: { value: null }, + thicknessMapTransform: { value: /* @__PURE__ */ new Matrix3() }, + attenuationDistance: { value: 0 }, + attenuationColor: { value: /* @__PURE__ */ new Color(0) }, + specularColor: { value: /* @__PURE__ */ new Color(1, 1, 1) }, + specularColorMap: { value: null }, + specularColorMapTransform: { value: /* @__PURE__ */ new Matrix3() }, + specularIntensity: { value: 1 }, + specularIntensityMap: { value: null }, + specularIntensityMapTransform: { value: /* @__PURE__ */ new Matrix3() }, + anisotropyVector: { value: /* @__PURE__ */ new Vector2() }, + anisotropyMap: { value: null }, + anisotropyMapTransform: { value: /* @__PURE__ */ new Matrix3() } + } + ]), + vertexShader: ShaderChunk.meshphysical_vert, + fragmentShader: ShaderChunk.meshphysical_frag +}; +var _rgb = { r: 0, b: 0, g: 0 }; +var _e1$1 = /* @__PURE__ */ new Euler(); +var _m1$1 = /* @__PURE__ */ new Matrix4(); +function WebGLBackground(renderer, cubemaps, cubeuvmaps, state, objects, alpha, premultipliedAlpha) { + const clearColor = new Color(0); + let clearAlpha = alpha === true ? 0 : 1; + let planeMesh; + let boxMesh; + let currentBackground = null; + let currentBackgroundVersion = 0; + let currentTonemapping = null; + function render(renderList, scene) { + let forceClear = false; + let background = scene.isScene === true ? scene.background : null; + if (background && background.isTexture) { + const usePMREM = scene.backgroundBlurriness > 0; + background = (usePMREM ? cubeuvmaps : cubemaps).get(background); + } + if (background === null) { + setClear(clearColor, clearAlpha); + } else if (background && background.isColor) { + setClear(background, 1); + forceClear = true; + } + const environmentBlendMode = renderer.xr.getEnvironmentBlendMode(); + if (environmentBlendMode === "additive") { + state.buffers.color.setClear(0, 0, 0, 1, premultipliedAlpha); + } else if (environmentBlendMode === "alpha-blend") { + state.buffers.color.setClear(0, 0, 0, 0, premultipliedAlpha); + } + if (renderer.autoClear || forceClear) { + renderer.clear(renderer.autoClearColor, renderer.autoClearDepth, renderer.autoClearStencil); + } + if (background && (background.isCubeTexture || background.mapping === CubeUVReflectionMapping)) { + if (boxMesh === void 0) { + boxMesh = new Mesh( + new BoxGeometry(1, 1, 1), + new ShaderMaterial({ + name: "BackgroundCubeMaterial", + uniforms: cloneUniforms(ShaderLib.backgroundCube.uniforms), + vertexShader: ShaderLib.backgroundCube.vertexShader, + fragmentShader: ShaderLib.backgroundCube.fragmentShader, + side: BackSide, + depthTest: false, + depthWrite: false, + fog: false + }) + ); + boxMesh.geometry.deleteAttribute("normal"); + boxMesh.geometry.deleteAttribute("uv"); + boxMesh.onBeforeRender = function(renderer2, scene2, camera) { + this.matrixWorld.copyPosition(camera.matrixWorld); + }; + Object.defineProperty(boxMesh.material, "envMap", { + get: function() { + return this.uniforms.envMap.value; + } + }); + objects.update(boxMesh); + } + _e1$1.copy(scene.backgroundRotation); + _e1$1.x *= -1; + _e1$1.y *= -1; + _e1$1.z *= -1; + if (background.isCubeTexture && background.isRenderTargetTexture === false) { + _e1$1.y *= -1; + _e1$1.z *= -1; + } + boxMesh.material.uniforms.envMap.value = background; + boxMesh.material.uniforms.flipEnvMap.value = background.isCubeTexture && background.isRenderTargetTexture === false ? -1 : 1; + boxMesh.material.uniforms.backgroundBlurriness.value = scene.backgroundBlurriness; + boxMesh.material.uniforms.backgroundIntensity.value = scene.backgroundIntensity; + boxMesh.material.uniforms.backgroundRotation.value.setFromMatrix4(_m1$1.makeRotationFromEuler(_e1$1)); + boxMesh.material.toneMapped = ColorManagement.getTransfer(background.colorSpace) !== SRGBTransfer; + if (currentBackground !== background || currentBackgroundVersion !== background.version || currentTonemapping !== renderer.toneMapping) { + boxMesh.material.needsUpdate = true; + currentBackground = background; + currentBackgroundVersion = background.version; + currentTonemapping = renderer.toneMapping; + } + boxMesh.layers.enableAll(); + renderList.unshift(boxMesh, boxMesh.geometry, boxMesh.material, 0, 0, null); + } else if (background && background.isTexture) { + if (planeMesh === void 0) { + planeMesh = new Mesh( + new PlaneGeometry(2, 2), + new ShaderMaterial({ + name: "BackgroundMaterial", + uniforms: cloneUniforms(ShaderLib.background.uniforms), + vertexShader: ShaderLib.background.vertexShader, + fragmentShader: ShaderLib.background.fragmentShader, + side: FrontSide, + depthTest: false, + depthWrite: false, + fog: false + }) + ); + planeMesh.geometry.deleteAttribute("normal"); + Object.defineProperty(planeMesh.material, "map", { + get: function() { + return this.uniforms.t2D.value; + } + }); + objects.update(planeMesh); + } + planeMesh.material.uniforms.t2D.value = background; + planeMesh.material.uniforms.backgroundIntensity.value = scene.backgroundIntensity; + planeMesh.material.toneMapped = ColorManagement.getTransfer(background.colorSpace) !== SRGBTransfer; + if (background.matrixAutoUpdate === true) { + background.updateMatrix(); + } + planeMesh.material.uniforms.uvTransform.value.copy(background.matrix); + if (currentBackground !== background || currentBackgroundVersion !== background.version || currentTonemapping !== renderer.toneMapping) { + planeMesh.material.needsUpdate = true; + currentBackground = background; + currentBackgroundVersion = background.version; + currentTonemapping = renderer.toneMapping; + } + planeMesh.layers.enableAll(); + renderList.unshift(planeMesh, planeMesh.geometry, planeMesh.material, 0, 0, null); + } + } + function setClear(color, alpha2) { + color.getRGB(_rgb, getUnlitUniformColorSpace(renderer)); + state.buffers.color.setClear(_rgb.r, _rgb.g, _rgb.b, alpha2, premultipliedAlpha); + } + return { + getClearColor: function() { + return clearColor; + }, + setClearColor: function(color, alpha2 = 1) { + clearColor.set(color); + clearAlpha = alpha2; + setClear(clearColor, clearAlpha); + }, + getClearAlpha: function() { + return clearAlpha; + }, + setClearAlpha: function(alpha2) { + clearAlpha = alpha2; + setClear(clearColor, clearAlpha); + }, + render + }; +} +function WebGLBindingStates(gl, attributes) { + const maxVertexAttributes = gl.getParameter(gl.MAX_VERTEX_ATTRIBS); + const bindingStates = {}; + const defaultState = createBindingState(null); + let currentState = defaultState; + let forceUpdate = false; + function setup(object, material, program, geometry, index) { + let updateBuffers = false; + const state = getBindingState(geometry, program, material); + if (currentState !== state) { + currentState = state; + bindVertexArrayObject(currentState.object); + } + updateBuffers = needsUpdate(object, geometry, program, index); + if (updateBuffers) saveCache(object, geometry, program, index); + if (index !== null) { + attributes.update(index, gl.ELEMENT_ARRAY_BUFFER); + } + if (updateBuffers || forceUpdate) { + forceUpdate = false; + setupVertexAttributes(object, material, program, geometry); + if (index !== null) { + gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, attributes.get(index).buffer); + } + } + } + function createVertexArrayObject() { + return gl.createVertexArray(); + } + function bindVertexArrayObject(vao) { + return gl.bindVertexArray(vao); + } + function deleteVertexArrayObject(vao) { + return gl.deleteVertexArray(vao); + } + function getBindingState(geometry, program, material) { + const wireframe = material.wireframe === true; + let programMap = bindingStates[geometry.id]; + if (programMap === void 0) { + programMap = {}; + bindingStates[geometry.id] = programMap; + } + let stateMap = programMap[program.id]; + if (stateMap === void 0) { + stateMap = {}; + programMap[program.id] = stateMap; + } + let state = stateMap[wireframe]; + if (state === void 0) { + state = createBindingState(createVertexArrayObject()); + stateMap[wireframe] = state; + } + return state; + } + function createBindingState(vao) { + const newAttributes = []; + const enabledAttributes = []; + const attributeDivisors = []; + for (let i = 0; i < maxVertexAttributes; i++) { + newAttributes[i] = 0; + enabledAttributes[i] = 0; + attributeDivisors[i] = 0; + } + return { + // for backward compatibility on non-VAO support browser + geometry: null, + program: null, + wireframe: false, + newAttributes, + enabledAttributes, + attributeDivisors, + object: vao, + attributes: {}, + index: null + }; + } + function needsUpdate(object, geometry, program, index) { + const cachedAttributes = currentState.attributes; + const geometryAttributes = geometry.attributes; + let attributesNum = 0; + const programAttributes = program.getAttributes(); + for (const name in programAttributes) { + const programAttribute = programAttributes[name]; + if (programAttribute.location >= 0) { + const cachedAttribute = cachedAttributes[name]; + let geometryAttribute = geometryAttributes[name]; + if (geometryAttribute === void 0) { + if (name === "instanceMatrix" && object.instanceMatrix) geometryAttribute = object.instanceMatrix; + if (name === "instanceColor" && object.instanceColor) geometryAttribute = object.instanceColor; + } + if (cachedAttribute === void 0) return true; + if (cachedAttribute.attribute !== geometryAttribute) return true; + if (geometryAttribute && cachedAttribute.data !== geometryAttribute.data) return true; + attributesNum++; + } + } + if (currentState.attributesNum !== attributesNum) return true; + if (currentState.index !== index) return true; + return false; + } + function saveCache(object, geometry, program, index) { + const cache = {}; + const attributes2 = geometry.attributes; + let attributesNum = 0; + const programAttributes = program.getAttributes(); + for (const name in programAttributes) { + const programAttribute = programAttributes[name]; + if (programAttribute.location >= 0) { + let attribute = attributes2[name]; + if (attribute === void 0) { + if (name === "instanceMatrix" && object.instanceMatrix) attribute = object.instanceMatrix; + if (name === "instanceColor" && object.instanceColor) attribute = object.instanceColor; + } + const data = {}; + data.attribute = attribute; + if (attribute && attribute.data) { + data.data = attribute.data; + } + cache[name] = data; + attributesNum++; + } + } + currentState.attributes = cache; + currentState.attributesNum = attributesNum; + currentState.index = index; + } + function initAttributes() { + const newAttributes = currentState.newAttributes; + for (let i = 0, il = newAttributes.length; i < il; i++) { + newAttributes[i] = 0; + } + } + function enableAttribute(attribute) { + enableAttributeAndDivisor(attribute, 0); + } + function enableAttributeAndDivisor(attribute, meshPerAttribute) { + const newAttributes = currentState.newAttributes; + const enabledAttributes = currentState.enabledAttributes; + const attributeDivisors = currentState.attributeDivisors; + newAttributes[attribute] = 1; + if (enabledAttributes[attribute] === 0) { + gl.enableVertexAttribArray(attribute); + enabledAttributes[attribute] = 1; + } + if (attributeDivisors[attribute] !== meshPerAttribute) { + gl.vertexAttribDivisor(attribute, meshPerAttribute); + attributeDivisors[attribute] = meshPerAttribute; + } + } + function disableUnusedAttributes() { + const newAttributes = currentState.newAttributes; + const enabledAttributes = currentState.enabledAttributes; + for (let i = 0, il = enabledAttributes.length; i < il; i++) { + if (enabledAttributes[i] !== newAttributes[i]) { + gl.disableVertexAttribArray(i); + enabledAttributes[i] = 0; + } + } + } + function vertexAttribPointer(index, size, type, normalized, stride, offset, integer) { + if (integer === true) { + gl.vertexAttribIPointer(index, size, type, stride, offset); + } else { + gl.vertexAttribPointer(index, size, type, normalized, stride, offset); + } + } + function setupVertexAttributes(object, material, program, geometry) { + initAttributes(); + const geometryAttributes = geometry.attributes; + const programAttributes = program.getAttributes(); + const materialDefaultAttributeValues = material.defaultAttributeValues; + for (const name in programAttributes) { + const programAttribute = programAttributes[name]; + if (programAttribute.location >= 0) { + let geometryAttribute = geometryAttributes[name]; + if (geometryAttribute === void 0) { + if (name === "instanceMatrix" && object.instanceMatrix) geometryAttribute = object.instanceMatrix; + if (name === "instanceColor" && object.instanceColor) geometryAttribute = object.instanceColor; + } + if (geometryAttribute !== void 0) { + const normalized = geometryAttribute.normalized; + const size = geometryAttribute.itemSize; + const attribute = attributes.get(geometryAttribute); + if (attribute === void 0) continue; + const buffer = attribute.buffer; + const type = attribute.type; + const bytesPerElement = attribute.bytesPerElement; + const integer = type === gl.INT || type === gl.UNSIGNED_INT || geometryAttribute.gpuType === IntType; + if (geometryAttribute.isInterleavedBufferAttribute) { + const data = geometryAttribute.data; + const stride = data.stride; + const offset = geometryAttribute.offset; + if (data.isInstancedInterleavedBuffer) { + for (let i = 0; i < programAttribute.locationSize; i++) { + enableAttributeAndDivisor(programAttribute.location + i, data.meshPerAttribute); + } + if (object.isInstancedMesh !== true && geometry._maxInstanceCount === void 0) { + geometry._maxInstanceCount = data.meshPerAttribute * data.count; + } + } else { + for (let i = 0; i < programAttribute.locationSize; i++) { + enableAttribute(programAttribute.location + i); + } + } + gl.bindBuffer(gl.ARRAY_BUFFER, buffer); + for (let i = 0; i < programAttribute.locationSize; i++) { + vertexAttribPointer( + programAttribute.location + i, + size / programAttribute.locationSize, + type, + normalized, + stride * bytesPerElement, + (offset + size / programAttribute.locationSize * i) * bytesPerElement, + integer + ); + } + } else { + if (geometryAttribute.isInstancedBufferAttribute) { + for (let i = 0; i < programAttribute.locationSize; i++) { + enableAttributeAndDivisor(programAttribute.location + i, geometryAttribute.meshPerAttribute); + } + if (object.isInstancedMesh !== true && geometry._maxInstanceCount === void 0) { + geometry._maxInstanceCount = geometryAttribute.meshPerAttribute * geometryAttribute.count; + } + } else { + for (let i = 0; i < programAttribute.locationSize; i++) { + enableAttribute(programAttribute.location + i); + } + } + gl.bindBuffer(gl.ARRAY_BUFFER, buffer); + for (let i = 0; i < programAttribute.locationSize; i++) { + vertexAttribPointer( + programAttribute.location + i, + size / programAttribute.locationSize, + type, + normalized, + size * bytesPerElement, + size / programAttribute.locationSize * i * bytesPerElement, + integer + ); + } + } + } else if (materialDefaultAttributeValues !== void 0) { + const value = materialDefaultAttributeValues[name]; + if (value !== void 0) { + switch (value.length) { + case 2: + gl.vertexAttrib2fv(programAttribute.location, value); + break; + case 3: + gl.vertexAttrib3fv(programAttribute.location, value); + break; + case 4: + gl.vertexAttrib4fv(programAttribute.location, value); + break; + default: + gl.vertexAttrib1fv(programAttribute.location, value); + } + } + } + } + } + disableUnusedAttributes(); + } + function dispose() { + reset(); + for (const geometryId in bindingStates) { + const programMap = bindingStates[geometryId]; + for (const programId in programMap) { + const stateMap = programMap[programId]; + for (const wireframe in stateMap) { + deleteVertexArrayObject(stateMap[wireframe].object); + delete stateMap[wireframe]; + } + delete programMap[programId]; + } + delete bindingStates[geometryId]; + } + } + function releaseStatesOfGeometry(geometry) { + if (bindingStates[geometry.id] === void 0) return; + const programMap = bindingStates[geometry.id]; + for (const programId in programMap) { + const stateMap = programMap[programId]; + for (const wireframe in stateMap) { + deleteVertexArrayObject(stateMap[wireframe].object); + delete stateMap[wireframe]; + } + delete programMap[programId]; + } + delete bindingStates[geometry.id]; + } + function releaseStatesOfProgram(program) { + for (const geometryId in bindingStates) { + const programMap = bindingStates[geometryId]; + if (programMap[program.id] === void 0) continue; + const stateMap = programMap[program.id]; + for (const wireframe in stateMap) { + deleteVertexArrayObject(stateMap[wireframe].object); + delete stateMap[wireframe]; + } + delete programMap[program.id]; + } + } + function reset() { + resetDefaultState(); + forceUpdate = true; + if (currentState === defaultState) return; + currentState = defaultState; + bindVertexArrayObject(currentState.object); + } + function resetDefaultState() { + defaultState.geometry = null; + defaultState.program = null; + defaultState.wireframe = false; + } + return { + setup, + reset, + resetDefaultState, + dispose, + releaseStatesOfGeometry, + releaseStatesOfProgram, + initAttributes, + enableAttribute, + disableUnusedAttributes + }; +} +function WebGLBufferRenderer(gl, extensions, info) { + let mode; + function setMode(value) { + mode = value; + } + function render(start, count) { + gl.drawArrays(mode, start, count); + info.update(count, mode, 1); + } + function renderInstances(start, count, primcount) { + if (primcount === 0) return; + gl.drawArraysInstanced(mode, start, count, primcount); + info.update(count, mode, primcount); + } + function renderMultiDraw(starts, counts, drawCount) { + if (drawCount === 0) return; + const extension = extensions.get("WEBGL_multi_draw"); + if (extension === null) { + for (let i = 0; i < drawCount; i++) { + this.render(starts[i], counts[i]); + } + } else { + extension.multiDrawArraysWEBGL(mode, starts, 0, counts, 0, drawCount); + let elementCount = 0; + for (let i = 0; i < drawCount; i++) { + elementCount += counts[i]; + } + info.update(elementCount, mode, 1); + } + } + this.setMode = setMode; + this.render = render; + this.renderInstances = renderInstances; + this.renderMultiDraw = renderMultiDraw; +} +function WebGLCapabilities(gl, extensions, parameters) { + let maxAnisotropy; + function getMaxAnisotropy() { + if (maxAnisotropy !== void 0) return maxAnisotropy; + if (extensions.has("EXT_texture_filter_anisotropic") === true) { + const extension = extensions.get("EXT_texture_filter_anisotropic"); + maxAnisotropy = gl.getParameter(extension.MAX_TEXTURE_MAX_ANISOTROPY_EXT); + } else { + maxAnisotropy = 0; + } + return maxAnisotropy; + } + function getMaxPrecision(precision2) { + if (precision2 === "highp") { + if (gl.getShaderPrecisionFormat(gl.VERTEX_SHADER, gl.HIGH_FLOAT).precision > 0 && gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER, gl.HIGH_FLOAT).precision > 0) { + return "highp"; + } + precision2 = "mediump"; + } + if (precision2 === "mediump") { + if (gl.getShaderPrecisionFormat(gl.VERTEX_SHADER, gl.MEDIUM_FLOAT).precision > 0 && gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER, gl.MEDIUM_FLOAT).precision > 0) { + return "mediump"; + } + } + return "lowp"; + } + let precision = parameters.precision !== void 0 ? parameters.precision : "highp"; + const maxPrecision = getMaxPrecision(precision); + if (maxPrecision !== precision) { + console.warn("THREE.WebGLRenderer:", precision, "not supported, using", maxPrecision, "instead."); + precision = maxPrecision; + } + const logarithmicDepthBuffer = parameters.logarithmicDepthBuffer === true; + const maxTextures = gl.getParameter(gl.MAX_TEXTURE_IMAGE_UNITS); + const maxVertexTextures = gl.getParameter(gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS); + const maxTextureSize = gl.getParameter(gl.MAX_TEXTURE_SIZE); + const maxCubemapSize = gl.getParameter(gl.MAX_CUBE_MAP_TEXTURE_SIZE); + const maxAttributes = gl.getParameter(gl.MAX_VERTEX_ATTRIBS); + const maxVertexUniforms = gl.getParameter(gl.MAX_VERTEX_UNIFORM_VECTORS); + const maxVaryings = gl.getParameter(gl.MAX_VARYING_VECTORS); + const maxFragmentUniforms = gl.getParameter(gl.MAX_FRAGMENT_UNIFORM_VECTORS); + const vertexTextures = maxVertexTextures > 0; + const maxSamples = gl.getParameter(gl.MAX_SAMPLES); + return { + isWebGL2: true, + // keeping this for backwards compatibility + getMaxAnisotropy, + getMaxPrecision, + precision, + logarithmicDepthBuffer, + maxTextures, + maxVertexTextures, + maxTextureSize, + maxCubemapSize, + maxAttributes, + maxVertexUniforms, + maxVaryings, + maxFragmentUniforms, + vertexTextures, + maxSamples + }; +} +function WebGLClipping(properties) { + const scope = this; + let globalState = null, numGlobalPlanes = 0, localClippingEnabled = false, renderingShadows = false; + const plane = new Plane(), viewNormalMatrix = new Matrix3(), uniform = { value: null, needsUpdate: false }; + this.uniform = uniform; + this.numPlanes = 0; + this.numIntersection = 0; + this.init = function(planes, enableLocalClipping) { + const enabled = planes.length !== 0 || enableLocalClipping || // enable state of previous frame - the clipping code has to + // run another frame in order to reset the state: + numGlobalPlanes !== 0 || localClippingEnabled; + localClippingEnabled = enableLocalClipping; + numGlobalPlanes = planes.length; + return enabled; + }; + this.beginShadows = function() { + renderingShadows = true; + projectPlanes(null); + }; + this.endShadows = function() { + renderingShadows = false; + }; + this.setGlobalState = function(planes, camera) { + globalState = projectPlanes(planes, camera, 0); + }; + this.setState = function(material, camera, useCache) { + const planes = material.clippingPlanes, clipIntersection = material.clipIntersection, clipShadows = material.clipShadows; + const materialProperties = properties.get(material); + if (!localClippingEnabled || planes === null || planes.length === 0 || renderingShadows && !clipShadows) { + if (renderingShadows) { + projectPlanes(null); + } else { + resetGlobalState(); + } + } else { + const nGlobal = renderingShadows ? 0 : numGlobalPlanes, lGlobal = nGlobal * 4; + let dstArray = materialProperties.clippingState || null; + uniform.value = dstArray; + dstArray = projectPlanes(planes, camera, lGlobal, useCache); + for (let i = 0; i !== lGlobal; ++i) { + dstArray[i] = globalState[i]; + } + materialProperties.clippingState = dstArray; + this.numIntersection = clipIntersection ? this.numPlanes : 0; + this.numPlanes += nGlobal; + } + }; + function resetGlobalState() { + if (uniform.value !== globalState) { + uniform.value = globalState; + uniform.needsUpdate = numGlobalPlanes > 0; + } + scope.numPlanes = numGlobalPlanes; + scope.numIntersection = 0; + } + function projectPlanes(planes, camera, dstOffset, skipTransform) { + const nPlanes = planes !== null ? planes.length : 0; + let dstArray = null; + if (nPlanes !== 0) { + dstArray = uniform.value; + if (skipTransform !== true || dstArray === null) { + const flatSize = dstOffset + nPlanes * 4, viewMatrix = camera.matrixWorldInverse; + viewNormalMatrix.getNormalMatrix(viewMatrix); + if (dstArray === null || dstArray.length < flatSize) { + dstArray = new Float32Array(flatSize); + } + for (let i = 0, i4 = dstOffset; i !== nPlanes; ++i, i4 += 4) { + plane.copy(planes[i]).applyMatrix4(viewMatrix, viewNormalMatrix); + plane.normal.toArray(dstArray, i4); + dstArray[i4 + 3] = plane.constant; + } + } + uniform.value = dstArray; + uniform.needsUpdate = true; + } + scope.numPlanes = nPlanes; + scope.numIntersection = 0; + return dstArray; + } +} +function WebGLCubeMaps(renderer) { + let cubemaps = /* @__PURE__ */ new WeakMap(); + function mapTextureMapping(texture, mapping) { + if (mapping === EquirectangularReflectionMapping) { + texture.mapping = CubeReflectionMapping; + } else if (mapping === EquirectangularRefractionMapping) { + texture.mapping = CubeRefractionMapping; + } + return texture; + } + function get(texture) { + if (texture && texture.isTexture) { + const mapping = texture.mapping; + if (mapping === EquirectangularReflectionMapping || mapping === EquirectangularRefractionMapping) { + if (cubemaps.has(texture)) { + const cubemap = cubemaps.get(texture).texture; + return mapTextureMapping(cubemap, texture.mapping); + } else { + const image = texture.image; + if (image && image.height > 0) { + const renderTarget = new WebGLCubeRenderTarget(image.height); + renderTarget.fromEquirectangularTexture(renderer, texture); + cubemaps.set(texture, renderTarget); + texture.addEventListener("dispose", onTextureDispose); + return mapTextureMapping(renderTarget.texture, texture.mapping); + } else { + return null; + } + } + } + } + return texture; + } + function onTextureDispose(event) { + const texture = event.target; + texture.removeEventListener("dispose", onTextureDispose); + const cubemap = cubemaps.get(texture); + if (cubemap !== void 0) { + cubemaps.delete(texture); + cubemap.dispose(); + } + } + function dispose() { + cubemaps = /* @__PURE__ */ new WeakMap(); + } + return { + get, + dispose + }; +} +var OrthographicCamera = class extends Camera { + constructor(left = -1, right2 = 1, top = 1, bottom = -1, near = 0.1, far = 2e3) { + super(); + this.isOrthographicCamera = true; + this.type = "OrthographicCamera"; + this.zoom = 1; + this.view = null; + this.left = left; + this.right = right2; + this.top = top; + this.bottom = bottom; + this.near = near; + this.far = far; + this.updateProjectionMatrix(); + } + copy(source, recursive) { + super.copy(source, recursive); + this.left = source.left; + this.right = source.right; + this.top = source.top; + this.bottom = source.bottom; + this.near = source.near; + this.far = source.far; + this.zoom = source.zoom; + this.view = source.view === null ? null : Object.assign({}, source.view); + return this; + } + setViewOffset(fullWidth, fullHeight, x, y, width, height) { + if (this.view === null) { + this.view = { + enabled: true, + fullWidth: 1, + fullHeight: 1, + offsetX: 0, + offsetY: 0, + width: 1, + height: 1 + }; + } + this.view.enabled = true; + this.view.fullWidth = fullWidth; + this.view.fullHeight = fullHeight; + this.view.offsetX = x; + this.view.offsetY = y; + this.view.width = width; + this.view.height = height; + this.updateProjectionMatrix(); + } + clearViewOffset() { + if (this.view !== null) { + this.view.enabled = false; + } + this.updateProjectionMatrix(); + } + updateProjectionMatrix() { + const dx = (this.right - this.left) / (2 * this.zoom); + const dy = (this.top - this.bottom) / (2 * this.zoom); + const cx = (this.right + this.left) / 2; + const cy = (this.top + this.bottom) / 2; + let left = cx - dx; + let right2 = cx + dx; + let top = cy + dy; + let bottom = cy - dy; + if (this.view !== null && this.view.enabled) { + const scaleW = (this.right - this.left) / this.view.fullWidth / this.zoom; + const scaleH = (this.top - this.bottom) / this.view.fullHeight / this.zoom; + left += scaleW * this.view.offsetX; + right2 = left + scaleW * this.view.width; + top -= scaleH * this.view.offsetY; + bottom = top - scaleH * this.view.height; + } + this.projectionMatrix.makeOrthographic(left, right2, top, bottom, this.near, this.far, this.coordinateSystem); + this.projectionMatrixInverse.copy(this.projectionMatrix).invert(); + } + toJSON(meta) { + const data = super.toJSON(meta); + data.object.zoom = this.zoom; + data.object.left = this.left; + data.object.right = this.right; + data.object.top = this.top; + data.object.bottom = this.bottom; + data.object.near = this.near; + data.object.far = this.far; + if (this.view !== null) data.object.view = Object.assign({}, this.view); + return data; + } +}; +var LOD_MIN = 4; +var EXTRA_LOD_SIGMA = [0.125, 0.215, 0.35, 0.446, 0.526, 0.582]; +var MAX_SAMPLES = 20; +var _flatCamera = /* @__PURE__ */ new OrthographicCamera(); +var _clearColor = /* @__PURE__ */ new Color(); +var _oldTarget = null; +var _oldActiveCubeFace = 0; +var _oldActiveMipmapLevel = 0; +var _oldXrEnabled = false; +var PHI = (1 + Math.sqrt(5)) / 2; +var INV_PHI = 1 / PHI; +var _axisDirections = [ + /* @__PURE__ */ new Vector3(1, 1, 1), + /* @__PURE__ */ new Vector3(-1, 1, 1), + /* @__PURE__ */ new Vector3(1, 1, -1), + /* @__PURE__ */ new Vector3(-1, 1, -1), + /* @__PURE__ */ new Vector3(0, PHI, INV_PHI), + /* @__PURE__ */ new Vector3(0, PHI, -INV_PHI), + /* @__PURE__ */ new Vector3(INV_PHI, 0, PHI), + /* @__PURE__ */ new Vector3(-INV_PHI, 0, PHI), + /* @__PURE__ */ new Vector3(PHI, INV_PHI, 0), + /* @__PURE__ */ new Vector3(-PHI, INV_PHI, 0) +]; +var PMREMGenerator = class { + constructor(renderer) { + this._renderer = renderer; + this._pingPongRenderTarget = null; + this._lodMax = 0; + this._cubeSize = 0; + this._lodPlanes = []; + this._sizeLods = []; + this._sigmas = []; + this._blurMaterial = null; + this._cubemapMaterial = null; + this._equirectMaterial = null; + this._compileMaterial(this._blurMaterial); + } + /** + * Generates a PMREM from a supplied Scene, which can be faster than using an + * image if networking bandwidth is low. Optional sigma specifies a blur radius + * in radians to be applied to the scene before PMREM generation. Optional near + * and far planes ensure the scene is rendered in its entirety (the cubeCamera + * is placed at the origin). + */ + fromScene(scene, sigma = 0, near = 0.1, far = 100) { + _oldTarget = this._renderer.getRenderTarget(); + _oldActiveCubeFace = this._renderer.getActiveCubeFace(); + _oldActiveMipmapLevel = this._renderer.getActiveMipmapLevel(); + _oldXrEnabled = this._renderer.xr.enabled; + this._renderer.xr.enabled = false; + this._setSize(256); + const cubeUVRenderTarget = this._allocateTargets(); + cubeUVRenderTarget.depthBuffer = true; + this._sceneToCubeUV(scene, near, far, cubeUVRenderTarget); + if (sigma > 0) { + this._blur(cubeUVRenderTarget, 0, 0, sigma); + } + this._applyPMREM(cubeUVRenderTarget); + this._cleanup(cubeUVRenderTarget); + return cubeUVRenderTarget; + } + /** + * Generates a PMREM from an equirectangular texture, which can be either LDR + * or HDR. The ideal input image size is 1k (1024 x 512), + * as this matches best with the 256 x 256 cubemap output. + * The smallest supported equirectangular image size is 64 x 32. + */ + fromEquirectangular(equirectangular, renderTarget = null) { + return this._fromTexture(equirectangular, renderTarget); + } + /** + * Generates a PMREM from an cubemap texture, which can be either LDR + * or HDR. The ideal input cube size is 256 x 256, + * as this matches best with the 256 x 256 cubemap output. + * The smallest supported cube size is 16 x 16. + */ + fromCubemap(cubemap, renderTarget = null) { + return this._fromTexture(cubemap, renderTarget); + } + /** + * Pre-compiles the cubemap shader. You can get faster start-up by invoking this method during + * your texture's network fetch for increased concurrency. + */ + compileCubemapShader() { + if (this._cubemapMaterial === null) { + this._cubemapMaterial = _getCubemapMaterial(); + this._compileMaterial(this._cubemapMaterial); + } + } + /** + * Pre-compiles the equirectangular shader. You can get faster start-up by invoking this method during + * your texture's network fetch for increased concurrency. + */ + compileEquirectangularShader() { + if (this._equirectMaterial === null) { + this._equirectMaterial = _getEquirectMaterial(); + this._compileMaterial(this._equirectMaterial); + } + } + /** + * Disposes of the PMREMGenerator's internal memory. Note that PMREMGenerator is a static class, + * so you should not need more than one PMREMGenerator object. If you do, calling dispose() on + * one of them will cause any others to also become unusable. + */ + dispose() { + this._dispose(); + if (this._cubemapMaterial !== null) this._cubemapMaterial.dispose(); + if (this._equirectMaterial !== null) this._equirectMaterial.dispose(); + } + // private interface + _setSize(cubeSize) { + this._lodMax = Math.floor(Math.log2(cubeSize)); + this._cubeSize = Math.pow(2, this._lodMax); + } + _dispose() { + if (this._blurMaterial !== null) this._blurMaterial.dispose(); + if (this._pingPongRenderTarget !== null) this._pingPongRenderTarget.dispose(); + for (let i = 0; i < this._lodPlanes.length; i++) { + this._lodPlanes[i].dispose(); + } + } + _cleanup(outputTarget) { + this._renderer.setRenderTarget(_oldTarget, _oldActiveCubeFace, _oldActiveMipmapLevel); + this._renderer.xr.enabled = _oldXrEnabled; + outputTarget.scissorTest = false; + _setViewport(outputTarget, 0, 0, outputTarget.width, outputTarget.height); + } + _fromTexture(texture, renderTarget) { + if (texture.mapping === CubeReflectionMapping || texture.mapping === CubeRefractionMapping) { + this._setSize(texture.image.length === 0 ? 16 : texture.image[0].width || texture.image[0].image.width); + } else { + this._setSize(texture.image.width / 4); + } + _oldTarget = this._renderer.getRenderTarget(); + _oldActiveCubeFace = this._renderer.getActiveCubeFace(); + _oldActiveMipmapLevel = this._renderer.getActiveMipmapLevel(); + _oldXrEnabled = this._renderer.xr.enabled; + this._renderer.xr.enabled = false; + const cubeUVRenderTarget = renderTarget || this._allocateTargets(); + this._textureToCubeUV(texture, cubeUVRenderTarget); + this._applyPMREM(cubeUVRenderTarget); + this._cleanup(cubeUVRenderTarget); + return cubeUVRenderTarget; + } + _allocateTargets() { + const width = 3 * Math.max(this._cubeSize, 16 * 7); + const height = 4 * this._cubeSize; + const params = { + magFilter: LinearFilter, + minFilter: LinearFilter, + generateMipmaps: false, + type: HalfFloatType, + format: RGBAFormat, + colorSpace: LinearSRGBColorSpace, + depthBuffer: false + }; + const cubeUVRenderTarget = _createRenderTarget(width, height, params); + if (this._pingPongRenderTarget === null || this._pingPongRenderTarget.width !== width || this._pingPongRenderTarget.height !== height) { + if (this._pingPongRenderTarget !== null) { + this._dispose(); + } + this._pingPongRenderTarget = _createRenderTarget(width, height, params); + const { _lodMax } = this; + ({ sizeLods: this._sizeLods, lodPlanes: this._lodPlanes, sigmas: this._sigmas } = _createPlanes(_lodMax)); + this._blurMaterial = _getBlurShader(_lodMax, width, height); + } + return cubeUVRenderTarget; + } + _compileMaterial(material) { + const tmpMesh = new Mesh(this._lodPlanes[0], material); + this._renderer.compile(tmpMesh, _flatCamera); + } + _sceneToCubeUV(scene, near, far, cubeUVRenderTarget) { + const fov2 = 90; + const aspect2 = 1; + const cubeCamera = new PerspectiveCamera(fov2, aspect2, near, far); + const upSign = [1, -1, 1, 1, 1, 1]; + const forwardSign = [1, 1, 1, -1, -1, -1]; + const renderer = this._renderer; + const originalAutoClear = renderer.autoClear; + const toneMapping = renderer.toneMapping; + renderer.getClearColor(_clearColor); + renderer.toneMapping = NoToneMapping; + renderer.autoClear = false; + const backgroundMaterial = new MeshBasicMaterial({ + name: "PMREM.Background", + side: BackSide, + depthWrite: false, + depthTest: false + }); + const backgroundBox = new Mesh(new BoxGeometry(), backgroundMaterial); + let useSolidColor = false; + const background = scene.background; + if (background) { + if (background.isColor) { + backgroundMaterial.color.copy(background); + scene.background = null; + useSolidColor = true; + } + } else { + backgroundMaterial.color.copy(_clearColor); + useSolidColor = true; + } + for (let i = 0; i < 6; i++) { + const col = i % 3; + if (col === 0) { + cubeCamera.up.set(0, upSign[i], 0); + cubeCamera.lookAt(forwardSign[i], 0, 0); + } else if (col === 1) { + cubeCamera.up.set(0, 0, upSign[i]); + cubeCamera.lookAt(0, forwardSign[i], 0); + } else { + cubeCamera.up.set(0, upSign[i], 0); + cubeCamera.lookAt(0, 0, forwardSign[i]); + } + const size = this._cubeSize; + _setViewport(cubeUVRenderTarget, col * size, i > 2 ? size : 0, size, size); + renderer.setRenderTarget(cubeUVRenderTarget); + if (useSolidColor) { + renderer.render(backgroundBox, cubeCamera); + } + renderer.render(scene, cubeCamera); + } + backgroundBox.geometry.dispose(); + backgroundBox.material.dispose(); + renderer.toneMapping = toneMapping; + renderer.autoClear = originalAutoClear; + scene.background = background; + } + _textureToCubeUV(texture, cubeUVRenderTarget) { + const renderer = this._renderer; + const isCubeTexture = texture.mapping === CubeReflectionMapping || texture.mapping === CubeRefractionMapping; + if (isCubeTexture) { + if (this._cubemapMaterial === null) { + this._cubemapMaterial = _getCubemapMaterial(); + } + this._cubemapMaterial.uniforms.flipEnvMap.value = texture.isRenderTargetTexture === false ? -1 : 1; + } else { + if (this._equirectMaterial === null) { + this._equirectMaterial = _getEquirectMaterial(); + } + } + const material = isCubeTexture ? this._cubemapMaterial : this._equirectMaterial; + const mesh = new Mesh(this._lodPlanes[0], material); + const uniforms = material.uniforms; + uniforms["envMap"].value = texture; + const size = this._cubeSize; + _setViewport(cubeUVRenderTarget, 0, 0, 3 * size, 2 * size); + renderer.setRenderTarget(cubeUVRenderTarget); + renderer.render(mesh, _flatCamera); + } + _applyPMREM(cubeUVRenderTarget) { + const renderer = this._renderer; + const autoClear = renderer.autoClear; + renderer.autoClear = false; + for (let i = 1; i < this._lodPlanes.length; i++) { + const sigma = Math.sqrt(this._sigmas[i] * this._sigmas[i] - this._sigmas[i - 1] * this._sigmas[i - 1]); + const poleAxis = _axisDirections[(i - 1) % _axisDirections.length]; + this._blur(cubeUVRenderTarget, i - 1, i, sigma, poleAxis); + } + renderer.autoClear = autoClear; + } + /** + * This is a two-pass Gaussian blur for a cubemap. Normally this is done + * vertically and horizontally, but this breaks down on a cube. Here we apply + * the blur latitudinally (around the poles), and then longitudinally (towards + * the poles) to approximate the orthogonally-separable blur. It is least + * accurate at the poles, but still does a decent job. + */ + _blur(cubeUVRenderTarget, lodIn, lodOut, sigma, poleAxis) { + const pingPongRenderTarget = this._pingPongRenderTarget; + this._halfBlur( + cubeUVRenderTarget, + pingPongRenderTarget, + lodIn, + lodOut, + sigma, + "latitudinal", + poleAxis + ); + this._halfBlur( + pingPongRenderTarget, + cubeUVRenderTarget, + lodOut, + lodOut, + sigma, + "longitudinal", + poleAxis + ); + } + _halfBlur(targetIn, targetOut, lodIn, lodOut, sigmaRadians, direction, poleAxis) { + const renderer = this._renderer; + const blurMaterial = this._blurMaterial; + if (direction !== "latitudinal" && direction !== "longitudinal") { + console.error( + "blur direction must be either latitudinal or longitudinal!" + ); + } + const STANDARD_DEVIATIONS = 3; + const blurMesh = new Mesh(this._lodPlanes[lodOut], blurMaterial); + const blurUniforms = blurMaterial.uniforms; + const pixels = this._sizeLods[lodIn] - 1; + const radiansPerPixel = isFinite(sigmaRadians) ? Math.PI / (2 * pixels) : 2 * Math.PI / (2 * MAX_SAMPLES - 1); + const sigmaPixels = sigmaRadians / radiansPerPixel; + const samples = isFinite(sigmaRadians) ? 1 + Math.floor(STANDARD_DEVIATIONS * sigmaPixels) : MAX_SAMPLES; + if (samples > MAX_SAMPLES) { + console.warn(`sigmaRadians, ${sigmaRadians}, is too large and will clip, as it requested ${samples} samples when the maximum is set to ${MAX_SAMPLES}`); + } + const weights = []; + let sum = 0; + for (let i = 0; i < MAX_SAMPLES; ++i) { + const x2 = i / sigmaPixels; + const weight = Math.exp(-x2 * x2 / 2); + weights.push(weight); + if (i === 0) { + sum += weight; + } else if (i < samples) { + sum += 2 * weight; + } + } + for (let i = 0; i < weights.length; i++) { + weights[i] = weights[i] / sum; + } + blurUniforms["envMap"].value = targetIn.texture; + blurUniforms["samples"].value = samples; + blurUniforms["weights"].value = weights; + blurUniforms["latitudinal"].value = direction === "latitudinal"; + if (poleAxis) { + blurUniforms["poleAxis"].value = poleAxis; + } + const { _lodMax } = this; + blurUniforms["dTheta"].value = radiansPerPixel; + blurUniforms["mipInt"].value = _lodMax - lodIn; + const outputSize = this._sizeLods[lodOut]; + const x = 3 * outputSize * (lodOut > _lodMax - LOD_MIN ? lodOut - _lodMax + LOD_MIN : 0); + const y = 4 * (this._cubeSize - outputSize); + _setViewport(targetOut, x, y, 3 * outputSize, 2 * outputSize); + renderer.setRenderTarget(targetOut); + renderer.render(blurMesh, _flatCamera); + } +}; +function _createPlanes(lodMax) { + const lodPlanes = []; + const sizeLods = []; + const sigmas = []; + let lod = lodMax; + const totalLods = lodMax - LOD_MIN + 1 + EXTRA_LOD_SIGMA.length; + for (let i = 0; i < totalLods; i++) { + const sizeLod = Math.pow(2, lod); + sizeLods.push(sizeLod); + let sigma = 1 / sizeLod; + if (i > lodMax - LOD_MIN) { + sigma = EXTRA_LOD_SIGMA[i - lodMax + LOD_MIN - 1]; + } else if (i === 0) { + sigma = 0; + } + sigmas.push(sigma); + const texelSize = 1 / (sizeLod - 2); + const min = -texelSize; + const max2 = 1 + texelSize; + const uv1 = [min, min, max2, min, max2, max2, min, min, max2, max2, min, max2]; + const cubeFaces = 6; + const vertices = 6; + const positionSize = 3; + const uvSize = 2; + const faceIndexSize = 1; + const position = new Float32Array(positionSize * vertices * cubeFaces); + const uv = new Float32Array(uvSize * vertices * cubeFaces); + const faceIndex = new Float32Array(faceIndexSize * vertices * cubeFaces); + for (let face = 0; face < cubeFaces; face++) { + const x = face % 3 * 2 / 3 - 1; + const y = face > 2 ? 0 : -1; + const coordinates = [ + x, + y, + 0, + x + 2 / 3, + y, + 0, + x + 2 / 3, + y + 1, + 0, + x, + y, + 0, + x + 2 / 3, + y + 1, + 0, + x, + y + 1, + 0 + ]; + position.set(coordinates, positionSize * vertices * face); + uv.set(uv1, uvSize * vertices * face); + const fill = [face, face, face, face, face, face]; + faceIndex.set(fill, faceIndexSize * vertices * face); + } + const planes = new BufferGeometry(); + planes.setAttribute("position", new BufferAttribute(position, positionSize)); + planes.setAttribute("uv", new BufferAttribute(uv, uvSize)); + planes.setAttribute("faceIndex", new BufferAttribute(faceIndex, faceIndexSize)); + lodPlanes.push(planes); + if (lod > LOD_MIN) { + lod--; + } + } + return { lodPlanes, sizeLods, sigmas }; +} +function _createRenderTarget(width, height, params) { + const cubeUVRenderTarget = new WebGLRenderTarget(width, height, params); + cubeUVRenderTarget.texture.mapping = CubeUVReflectionMapping; + cubeUVRenderTarget.texture.name = "PMREM.cubeUv"; + cubeUVRenderTarget.scissorTest = true; + return cubeUVRenderTarget; +} +function _setViewport(target, x, y, width, height) { + target.viewport.set(x, y, width, height); + target.scissor.set(x, y, width, height); +} +function _getBlurShader(lodMax, width, height) { + const weights = new Float32Array(MAX_SAMPLES); + const poleAxis = new Vector3(0, 1, 0); + const shaderMaterial = new ShaderMaterial({ + name: "SphericalGaussianBlur", + defines: { + "n": MAX_SAMPLES, + "CUBEUV_TEXEL_WIDTH": 1 / width, + "CUBEUV_TEXEL_HEIGHT": 1 / height, + "CUBEUV_MAX_MIP": `${lodMax}.0` + }, + uniforms: { + "envMap": { value: null }, + "samples": { value: 1 }, + "weights": { value: weights }, + "latitudinal": { value: false }, + "dTheta": { value: 0 }, + "mipInt": { value: 0 }, + "poleAxis": { value: poleAxis } + }, + vertexShader: _getCommonVertexShader(), + fragmentShader: ( + /* glsl */ + ` + + precision mediump float; + precision mediump int; + + varying vec3 vOutputDirection; + + uniform sampler2D envMap; + uniform int samples; + uniform float weights[ n ]; + uniform bool latitudinal; + uniform float dTheta; + uniform float mipInt; + uniform vec3 poleAxis; + + #define ENVMAP_TYPE_CUBE_UV + #include + + vec3 getSample( float theta, vec3 axis ) { + + float cosTheta = cos( theta ); + // Rodrigues' axis-angle rotation + vec3 sampleDirection = vOutputDirection * cosTheta + + cross( axis, vOutputDirection ) * sin( theta ) + + axis * dot( axis, vOutputDirection ) * ( 1.0 - cosTheta ); + + return bilinearCubeUV( envMap, sampleDirection, mipInt ); + + } + + void main() { + + vec3 axis = latitudinal ? poleAxis : cross( poleAxis, vOutputDirection ); + + if ( all( equal( axis, vec3( 0.0 ) ) ) ) { + + axis = vec3( vOutputDirection.z, 0.0, - vOutputDirection.x ); + + } + + axis = normalize( axis ); + + gl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 ); + gl_FragColor.rgb += weights[ 0 ] * getSample( 0.0, axis ); + + for ( int i = 1; i < n; i++ ) { + + if ( i >= samples ) { + + break; + + } + + float theta = dTheta * float( i ); + gl_FragColor.rgb += weights[ i ] * getSample( -1.0 * theta, axis ); + gl_FragColor.rgb += weights[ i ] * getSample( theta, axis ); + + } + + } + ` + ), + blending: NoBlending, + depthTest: false, + depthWrite: false + }); + return shaderMaterial; +} +function _getEquirectMaterial() { + return new ShaderMaterial({ + name: "EquirectangularToCubeUV", + uniforms: { + "envMap": { value: null } + }, + vertexShader: _getCommonVertexShader(), + fragmentShader: ( + /* glsl */ + ` + + precision mediump float; + precision mediump int; + + varying vec3 vOutputDirection; + + uniform sampler2D envMap; + + #include + + void main() { + + vec3 outputDirection = normalize( vOutputDirection ); + vec2 uv = equirectUv( outputDirection ); + + gl_FragColor = vec4( texture2D ( envMap, uv ).rgb, 1.0 ); + + } + ` + ), + blending: NoBlending, + depthTest: false, + depthWrite: false + }); +} +function _getCubemapMaterial() { + return new ShaderMaterial({ + name: "CubemapToCubeUV", + uniforms: { + "envMap": { value: null }, + "flipEnvMap": { value: -1 } + }, + vertexShader: _getCommonVertexShader(), + fragmentShader: ( + /* glsl */ + ` + + precision mediump float; + precision mediump int; + + uniform float flipEnvMap; + + varying vec3 vOutputDirection; + + uniform samplerCube envMap; + + void main() { + + gl_FragColor = textureCube( envMap, vec3( flipEnvMap * vOutputDirection.x, vOutputDirection.yz ) ); + + } + ` + ), + blending: NoBlending, + depthTest: false, + depthWrite: false + }); +} +function _getCommonVertexShader() { + return ( + /* glsl */ + ` + + precision mediump float; + precision mediump int; + + attribute float faceIndex; + + varying vec3 vOutputDirection; + + // RH coordinate system; PMREM face-indexing convention + vec3 getDirection( vec2 uv, float face ) { + + uv = 2.0 * uv - 1.0; + + vec3 direction = vec3( uv, 1.0 ); + + if ( face == 0.0 ) { + + direction = direction.zyx; // ( 1, v, u ) pos x + + } else if ( face == 1.0 ) { + + direction = direction.xzy; + direction.xz *= -1.0; // ( -u, 1, -v ) pos y + + } else if ( face == 2.0 ) { + + direction.x *= -1.0; // ( -u, v, 1 ) pos z + + } else if ( face == 3.0 ) { + + direction = direction.zyx; + direction.xz *= -1.0; // ( -1, v, -u ) neg x + + } else if ( face == 4.0 ) { + + direction = direction.xzy; + direction.xy *= -1.0; // ( -u, -1, v ) neg y + + } else if ( face == 5.0 ) { + + direction.z *= -1.0; // ( u, v, -1 ) neg z + + } + + return direction; + + } + + void main() { + + vOutputDirection = getDirection( uv, faceIndex ); + gl_Position = vec4( position, 1.0 ); + + } + ` + ); +} +function WebGLCubeUVMaps(renderer) { + let cubeUVmaps = /* @__PURE__ */ new WeakMap(); + let pmremGenerator = null; + function get(texture) { + if (texture && texture.isTexture) { + const mapping = texture.mapping; + const isEquirectMap = mapping === EquirectangularReflectionMapping || mapping === EquirectangularRefractionMapping; + const isCubeMap = mapping === CubeReflectionMapping || mapping === CubeRefractionMapping; + if (isEquirectMap || isCubeMap) { + let renderTarget = cubeUVmaps.get(texture); + const currentPMREMVersion = renderTarget !== void 0 ? renderTarget.texture.pmremVersion : 0; + if (texture.isRenderTargetTexture && texture.pmremVersion !== currentPMREMVersion) { + if (pmremGenerator === null) pmremGenerator = new PMREMGenerator(renderer); + renderTarget = isEquirectMap ? pmremGenerator.fromEquirectangular(texture, renderTarget) : pmremGenerator.fromCubemap(texture, renderTarget); + renderTarget.texture.pmremVersion = texture.pmremVersion; + cubeUVmaps.set(texture, renderTarget); + return renderTarget.texture; + } else { + if (renderTarget !== void 0) { + return renderTarget.texture; + } else { + const image = texture.image; + if (isEquirectMap && image && image.height > 0 || isCubeMap && image && isCubeTextureComplete(image)) { + if (pmremGenerator === null) pmremGenerator = new PMREMGenerator(renderer); + renderTarget = isEquirectMap ? pmremGenerator.fromEquirectangular(texture) : pmremGenerator.fromCubemap(texture); + renderTarget.texture.pmremVersion = texture.pmremVersion; + cubeUVmaps.set(texture, renderTarget); + texture.addEventListener("dispose", onTextureDispose); + return renderTarget.texture; + } else { + return null; + } + } + } + } + } + return texture; + } + function isCubeTextureComplete(image) { + let count = 0; + const length = 6; + for (let i = 0; i < length; i++) { + if (image[i] !== void 0) count++; + } + return count === length; + } + function onTextureDispose(event) { + const texture = event.target; + texture.removeEventListener("dispose", onTextureDispose); + const cubemapUV = cubeUVmaps.get(texture); + if (cubemapUV !== void 0) { + cubeUVmaps.delete(texture); + cubemapUV.dispose(); + } + } + function dispose() { + cubeUVmaps = /* @__PURE__ */ new WeakMap(); + if (pmremGenerator !== null) { + pmremGenerator.dispose(); + pmremGenerator = null; + } + } + return { + get, + dispose + }; +} +function WebGLExtensions(gl) { + const extensions = {}; + function getExtension(name) { + if (extensions[name] !== void 0) { + return extensions[name]; + } + let extension; + switch (name) { + case "WEBGL_depth_texture": + extension = gl.getExtension("WEBGL_depth_texture") || gl.getExtension("MOZ_WEBGL_depth_texture") || gl.getExtension("WEBKIT_WEBGL_depth_texture"); + break; + case "EXT_texture_filter_anisotropic": + extension = gl.getExtension("EXT_texture_filter_anisotropic") || gl.getExtension("MOZ_EXT_texture_filter_anisotropic") || gl.getExtension("WEBKIT_EXT_texture_filter_anisotropic"); + break; + case "WEBGL_compressed_texture_s3tc": + extension = gl.getExtension("WEBGL_compressed_texture_s3tc") || gl.getExtension("MOZ_WEBGL_compressed_texture_s3tc") || gl.getExtension("WEBKIT_WEBGL_compressed_texture_s3tc"); + break; + case "WEBGL_compressed_texture_pvrtc": + extension = gl.getExtension("WEBGL_compressed_texture_pvrtc") || gl.getExtension("WEBKIT_WEBGL_compressed_texture_pvrtc"); + break; + default: + extension = gl.getExtension(name); + } + extensions[name] = extension; + return extension; + } + return { + has: function(name) { + return getExtension(name) !== null; + }, + init: function() { + getExtension("EXT_color_buffer_float"); + getExtension("WEBGL_clip_cull_distance"); + getExtension("OES_texture_float_linear"); + getExtension("EXT_color_buffer_half_float"); + getExtension("WEBGL_multisampled_render_to_texture"); + getExtension("WEBGL_render_shared_exponent"); + }, + get: function(name) { + const extension = getExtension(name); + if (extension === null) { + console.warn("THREE.WebGLRenderer: " + name + " extension not supported."); + } + return extension; + } + }; +} +function WebGLGeometries(gl, attributes, info, bindingStates) { + const geometries = {}; + const wireframeAttributes = /* @__PURE__ */ new WeakMap(); + function onGeometryDispose(event) { + const geometry = event.target; + if (geometry.index !== null) { + attributes.remove(geometry.index); + } + for (const name in geometry.attributes) { + attributes.remove(geometry.attributes[name]); + } + for (const name in geometry.morphAttributes) { + const array = geometry.morphAttributes[name]; + for (let i = 0, l = array.length; i < l; i++) { + attributes.remove(array[i]); + } + } + geometry.removeEventListener("dispose", onGeometryDispose); + delete geometries[geometry.id]; + const attribute = wireframeAttributes.get(geometry); + if (attribute) { + attributes.remove(attribute); + wireframeAttributes.delete(geometry); + } + bindingStates.releaseStatesOfGeometry(geometry); + if (geometry.isInstancedBufferGeometry === true) { + delete geometry._maxInstanceCount; + } + info.memory.geometries--; + } + function get(object, geometry) { + if (geometries[geometry.id] === true) return geometry; + geometry.addEventListener("dispose", onGeometryDispose); + geometries[geometry.id] = true; + info.memory.geometries++; + return geometry; + } + function update(geometry) { + const geometryAttributes = geometry.attributes; + for (const name in geometryAttributes) { + attributes.update(geometryAttributes[name], gl.ARRAY_BUFFER); + } + const morphAttributes = geometry.morphAttributes; + for (const name in morphAttributes) { + const array = morphAttributes[name]; + for (let i = 0, l = array.length; i < l; i++) { + attributes.update(array[i], gl.ARRAY_BUFFER); + } + } + } + function updateWireframeAttribute(geometry) { + const indices = []; + const geometryIndex = geometry.index; + const geometryPosition = geometry.attributes.position; + let version = 0; + if (geometryIndex !== null) { + const array = geometryIndex.array; + version = geometryIndex.version; + for (let i = 0, l = array.length; i < l; i += 3) { + const a = array[i + 0]; + const b = array[i + 1]; + const c = array[i + 2]; + indices.push(a, b, b, c, c, a); + } + } else if (geometryPosition !== void 0) { + const array = geometryPosition.array; + version = geometryPosition.version; + for (let i = 0, l = array.length / 3 - 1; i < l; i += 3) { + const a = i + 0; + const b = i + 1; + const c = i + 2; + indices.push(a, b, b, c, c, a); + } + } else { + return; + } + const attribute = new (arrayNeedsUint32(indices) ? Uint32BufferAttribute : Uint16BufferAttribute)(indices, 1); + attribute.version = version; + const previousAttribute = wireframeAttributes.get(geometry); + if (previousAttribute) attributes.remove(previousAttribute); + wireframeAttributes.set(geometry, attribute); + } + function getWireframeAttribute(geometry) { + const currentAttribute = wireframeAttributes.get(geometry); + if (currentAttribute) { + const geometryIndex = geometry.index; + if (geometryIndex !== null) { + if (currentAttribute.version < geometryIndex.version) { + updateWireframeAttribute(geometry); + } + } + } else { + updateWireframeAttribute(geometry); + } + return wireframeAttributes.get(geometry); + } + return { + get, + update, + getWireframeAttribute + }; +} +function WebGLIndexedBufferRenderer(gl, extensions, info) { + let mode; + function setMode(value) { + mode = value; + } + let type, bytesPerElement; + function setIndex(value) { + type = value.type; + bytesPerElement = value.bytesPerElement; + } + function render(start, count) { + gl.drawElements(mode, count, type, start * bytesPerElement); + info.update(count, mode, 1); + } + function renderInstances(start, count, primcount) { + if (primcount === 0) return; + gl.drawElementsInstanced(mode, count, type, start * bytesPerElement, primcount); + info.update(count, mode, primcount); + } + function renderMultiDraw(starts, counts, drawCount) { + if (drawCount === 0) return; + const extension = extensions.get("WEBGL_multi_draw"); + if (extension === null) { + for (let i = 0; i < drawCount; i++) { + this.render(starts[i] / bytesPerElement, counts[i]); + } + } else { + extension.multiDrawElementsWEBGL(mode, counts, 0, type, starts, 0, drawCount); + let elementCount = 0; + for (let i = 0; i < drawCount; i++) { + elementCount += counts[i]; + } + info.update(elementCount, mode, 1); + } + } + this.setMode = setMode; + this.setIndex = setIndex; + this.render = render; + this.renderInstances = renderInstances; + this.renderMultiDraw = renderMultiDraw; +} +function WebGLInfo(gl) { + const memory = { + geometries: 0, + textures: 0 + }; + const render = { + frame: 0, + calls: 0, + triangles: 0, + points: 0, + lines: 0 + }; + function update(count, mode, instanceCount) { + render.calls++; + switch (mode) { + case gl.TRIANGLES: + render.triangles += instanceCount * (count / 3); + break; + case gl.LINES: + render.lines += instanceCount * (count / 2); + break; + case gl.LINE_STRIP: + render.lines += instanceCount * (count - 1); + break; + case gl.LINE_LOOP: + render.lines += instanceCount * count; + break; + case gl.POINTS: + render.points += instanceCount * count; + break; + default: + console.error("THREE.WebGLInfo: Unknown draw mode:", mode); + break; + } + } + function reset() { + render.calls = 0; + render.triangles = 0; + render.points = 0; + render.lines = 0; + } + return { + memory, + render, + programs: null, + autoReset: true, + reset, + update + }; +} +function WebGLMorphtargets(gl, capabilities, textures) { + const morphTextures = /* @__PURE__ */ new WeakMap(); + const morph = new Vector4(); + function update(object, geometry, program) { + const objectInfluences = object.morphTargetInfluences; + const morphAttribute = geometry.morphAttributes.position || geometry.morphAttributes.normal || geometry.morphAttributes.color; + const morphTargetsCount = morphAttribute !== void 0 ? morphAttribute.length : 0; + let entry = morphTextures.get(geometry); + if (entry === void 0 || entry.count !== morphTargetsCount) { + let disposeTexture = function() { + texture.dispose(); + morphTextures.delete(geometry); + geometry.removeEventListener("dispose", disposeTexture); + }; + if (entry !== void 0) entry.texture.dispose(); + const hasMorphPosition = geometry.morphAttributes.position !== void 0; + const hasMorphNormals = geometry.morphAttributes.normal !== void 0; + const hasMorphColors = geometry.morphAttributes.color !== void 0; + const morphTargets = geometry.morphAttributes.position || []; + const morphNormals = geometry.morphAttributes.normal || []; + const morphColors = geometry.morphAttributes.color || []; + let vertexDataCount = 0; + if (hasMorphPosition === true) vertexDataCount = 1; + if (hasMorphNormals === true) vertexDataCount = 2; + if (hasMorphColors === true) vertexDataCount = 3; + let width = geometry.attributes.position.count * vertexDataCount; + let height = 1; + if (width > capabilities.maxTextureSize) { + height = Math.ceil(width / capabilities.maxTextureSize); + width = capabilities.maxTextureSize; + } + const buffer = new Float32Array(width * height * 4 * morphTargetsCount); + const texture = new DataArrayTexture(buffer, width, height, morphTargetsCount); + texture.type = FloatType; + texture.needsUpdate = true; + const vertexDataStride = vertexDataCount * 4; + for (let i = 0; i < morphTargetsCount; i++) { + const morphTarget = morphTargets[i]; + const morphNormal = morphNormals[i]; + const morphColor = morphColors[i]; + const offset = width * height * 4 * i; + for (let j = 0; j < morphTarget.count; j++) { + const stride = j * vertexDataStride; + if (hasMorphPosition === true) { + morph.fromBufferAttribute(morphTarget, j); + buffer[offset + stride + 0] = morph.x; + buffer[offset + stride + 1] = morph.y; + buffer[offset + stride + 2] = morph.z; + buffer[offset + stride + 3] = 0; + } + if (hasMorphNormals === true) { + morph.fromBufferAttribute(morphNormal, j); + buffer[offset + stride + 4] = morph.x; + buffer[offset + stride + 5] = morph.y; + buffer[offset + stride + 6] = morph.z; + buffer[offset + stride + 7] = 0; + } + if (hasMorphColors === true) { + morph.fromBufferAttribute(morphColor, j); + buffer[offset + stride + 8] = morph.x; + buffer[offset + stride + 9] = morph.y; + buffer[offset + stride + 10] = morph.z; + buffer[offset + stride + 11] = morphColor.itemSize === 4 ? morph.w : 1; + } + } + } + entry = { + count: morphTargetsCount, + texture, + size: new Vector2(width, height) + }; + morphTextures.set(geometry, entry); + geometry.addEventListener("dispose", disposeTexture); + } + if (object.isInstancedMesh === true && object.morphTexture !== null) { + program.getUniforms().setValue(gl, "morphTexture", object.morphTexture, textures); + } else { + let morphInfluencesSum = 0; + for (let i = 0; i < objectInfluences.length; i++) { + morphInfluencesSum += objectInfluences[i]; + } + const morphBaseInfluence = geometry.morphTargetsRelative ? 1 : 1 - morphInfluencesSum; + program.getUniforms().setValue(gl, "morphTargetBaseInfluence", morphBaseInfluence); + program.getUniforms().setValue(gl, "morphTargetInfluences", objectInfluences); + } + program.getUniforms().setValue(gl, "morphTargetsTexture", entry.texture, textures); + program.getUniforms().setValue(gl, "morphTargetsTextureSize", entry.size); + } + return { + update + }; +} +function WebGLObjects(gl, geometries, attributes, info) { + let updateMap = /* @__PURE__ */ new WeakMap(); + function update(object) { + const frame = info.render.frame; + const geometry = object.geometry; + const buffergeometry = geometries.get(object, geometry); + if (updateMap.get(buffergeometry) !== frame) { + geometries.update(buffergeometry); + updateMap.set(buffergeometry, frame); + } + if (object.isInstancedMesh) { + if (object.hasEventListener("dispose", onInstancedMeshDispose) === false) { + object.addEventListener("dispose", onInstancedMeshDispose); + } + if (updateMap.get(object) !== frame) { + attributes.update(object.instanceMatrix, gl.ARRAY_BUFFER); + if (object.instanceColor !== null) { + attributes.update(object.instanceColor, gl.ARRAY_BUFFER); + } + updateMap.set(object, frame); + } + } + if (object.isSkinnedMesh) { + const skeleton = object.skeleton; + if (updateMap.get(skeleton) !== frame) { + skeleton.update(); + updateMap.set(skeleton, frame); + } + } + return buffergeometry; + } + function dispose() { + updateMap = /* @__PURE__ */ new WeakMap(); + } + function onInstancedMeshDispose(event) { + const instancedMesh = event.target; + instancedMesh.removeEventListener("dispose", onInstancedMeshDispose); + attributes.remove(instancedMesh.instanceMatrix); + if (instancedMesh.instanceColor !== null) attributes.remove(instancedMesh.instanceColor); + } + return { + update, + dispose + }; +} +var DepthTexture = class extends Texture { + constructor(width, height, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy, format) { + format = format !== void 0 ? format : DepthFormat; + if (format !== DepthFormat && format !== DepthStencilFormat) { + throw new Error("DepthTexture format must be either THREE.DepthFormat or THREE.DepthStencilFormat"); + } + if (type === void 0 && format === DepthFormat) type = UnsignedIntType; + if (type === void 0 && format === DepthStencilFormat) type = UnsignedInt248Type; + super(null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy); + this.isDepthTexture = true; + this.image = { width, height }; + this.magFilter = magFilter !== void 0 ? magFilter : NearestFilter; + this.minFilter = minFilter !== void 0 ? minFilter : NearestFilter; + this.flipY = false; + this.generateMipmaps = false; + this.compareFunction = null; + } + copy(source) { + super.copy(source); + this.compareFunction = source.compareFunction; + return this; + } + toJSON(meta) { + const data = super.toJSON(meta); + if (this.compareFunction !== null) data.compareFunction = this.compareFunction; + return data; + } +}; +var emptyTexture = /* @__PURE__ */ new Texture(); +var emptyShadowTexture = /* @__PURE__ */ new DepthTexture(1, 1); +emptyShadowTexture.compareFunction = LessEqualCompare; +var emptyArrayTexture = /* @__PURE__ */ new DataArrayTexture(); +var empty3dTexture = /* @__PURE__ */ new Data3DTexture(); +var emptyCubeTexture = /* @__PURE__ */ new CubeTexture(); +var arrayCacheF32 = []; +var arrayCacheI32 = []; +var mat4array = new Float32Array(16); +var mat3array = new Float32Array(9); +var mat2array = new Float32Array(4); +function flatten(array, nBlocks, blockSize) { + const firstElem = array[0]; + if (firstElem <= 0 || firstElem > 0) return array; + const n = nBlocks * blockSize; + let r = arrayCacheF32[n]; + if (r === void 0) { + r = new Float32Array(n); + arrayCacheF32[n] = r; + } + if (nBlocks !== 0) { + firstElem.toArray(r, 0); + for (let i = 1, offset = 0; i !== nBlocks; ++i) { + offset += blockSize; + array[i].toArray(r, offset); + } + } + return r; +} +function arraysEqual(a, b) { + if (a.length !== b.length) return false; + for (let i = 0, l = a.length; i < l; i++) { + if (a[i] !== b[i]) return false; + } + return true; +} +function copyArray(a, b) { + for (let i = 0, l = b.length; i < l; i++) { + a[i] = b[i]; + } +} +function allocTexUnits(textures, n) { + let r = arrayCacheI32[n]; + if (r === void 0) { + r = new Int32Array(n); + arrayCacheI32[n] = r; + } + for (let i = 0; i !== n; ++i) { + r[i] = textures.allocateTextureUnit(); + } + return r; +} +function setValueV1f(gl, v) { + const cache = this.cache; + if (cache[0] === v) return; + gl.uniform1f(this.addr, v); + cache[0] = v; +} +function setValueV2f(gl, v) { + const cache = this.cache; + if (v.x !== void 0) { + if (cache[0] !== v.x || cache[1] !== v.y) { + gl.uniform2f(this.addr, v.x, v.y); + cache[0] = v.x; + cache[1] = v.y; + } + } else { + if (arraysEqual(cache, v)) return; + gl.uniform2fv(this.addr, v); + copyArray(cache, v); + } +} +function setValueV3f(gl, v) { + const cache = this.cache; + if (v.x !== void 0) { + if (cache[0] !== v.x || cache[1] !== v.y || cache[2] !== v.z) { + gl.uniform3f(this.addr, v.x, v.y, v.z); + cache[0] = v.x; + cache[1] = v.y; + cache[2] = v.z; + } + } else if (v.r !== void 0) { + if (cache[0] !== v.r || cache[1] !== v.g || cache[2] !== v.b) { + gl.uniform3f(this.addr, v.r, v.g, v.b); + cache[0] = v.r; + cache[1] = v.g; + cache[2] = v.b; + } + } else { + if (arraysEqual(cache, v)) return; + gl.uniform3fv(this.addr, v); + copyArray(cache, v); + } +} +function setValueV4f(gl, v) { + const cache = this.cache; + if (v.x !== void 0) { + if (cache[0] !== v.x || cache[1] !== v.y || cache[2] !== v.z || cache[3] !== v.w) { + gl.uniform4f(this.addr, v.x, v.y, v.z, v.w); + cache[0] = v.x; + cache[1] = v.y; + cache[2] = v.z; + cache[3] = v.w; + } + } else { + if (arraysEqual(cache, v)) return; + gl.uniform4fv(this.addr, v); + copyArray(cache, v); + } +} +function setValueM2(gl, v) { + const cache = this.cache; + const elements = v.elements; + if (elements === void 0) { + if (arraysEqual(cache, v)) return; + gl.uniformMatrix2fv(this.addr, false, v); + copyArray(cache, v); + } else { + if (arraysEqual(cache, elements)) return; + mat2array.set(elements); + gl.uniformMatrix2fv(this.addr, false, mat2array); + copyArray(cache, elements); + } +} +function setValueM3(gl, v) { + const cache = this.cache; + const elements = v.elements; + if (elements === void 0) { + if (arraysEqual(cache, v)) return; + gl.uniformMatrix3fv(this.addr, false, v); + copyArray(cache, v); + } else { + if (arraysEqual(cache, elements)) return; + mat3array.set(elements); + gl.uniformMatrix3fv(this.addr, false, mat3array); + copyArray(cache, elements); + } +} +function setValueM4(gl, v) { + const cache = this.cache; + const elements = v.elements; + if (elements === void 0) { + if (arraysEqual(cache, v)) return; + gl.uniformMatrix4fv(this.addr, false, v); + copyArray(cache, v); + } else { + if (arraysEqual(cache, elements)) return; + mat4array.set(elements); + gl.uniformMatrix4fv(this.addr, false, mat4array); + copyArray(cache, elements); + } +} +function setValueV1i(gl, v) { + const cache = this.cache; + if (cache[0] === v) return; + gl.uniform1i(this.addr, v); + cache[0] = v; +} +function setValueV2i(gl, v) { + const cache = this.cache; + if (v.x !== void 0) { + if (cache[0] !== v.x || cache[1] !== v.y) { + gl.uniform2i(this.addr, v.x, v.y); + cache[0] = v.x; + cache[1] = v.y; + } + } else { + if (arraysEqual(cache, v)) return; + gl.uniform2iv(this.addr, v); + copyArray(cache, v); + } +} +function setValueV3i(gl, v) { + const cache = this.cache; + if (v.x !== void 0) { + if (cache[0] !== v.x || cache[1] !== v.y || cache[2] !== v.z) { + gl.uniform3i(this.addr, v.x, v.y, v.z); + cache[0] = v.x; + cache[1] = v.y; + cache[2] = v.z; + } + } else { + if (arraysEqual(cache, v)) return; + gl.uniform3iv(this.addr, v); + copyArray(cache, v); + } +} +function setValueV4i(gl, v) { + const cache = this.cache; + if (v.x !== void 0) { + if (cache[0] !== v.x || cache[1] !== v.y || cache[2] !== v.z || cache[3] !== v.w) { + gl.uniform4i(this.addr, v.x, v.y, v.z, v.w); + cache[0] = v.x; + cache[1] = v.y; + cache[2] = v.z; + cache[3] = v.w; + } + } else { + if (arraysEqual(cache, v)) return; + gl.uniform4iv(this.addr, v); + copyArray(cache, v); + } +} +function setValueV1ui(gl, v) { + const cache = this.cache; + if (cache[0] === v) return; + gl.uniform1ui(this.addr, v); + cache[0] = v; +} +function setValueV2ui(gl, v) { + const cache = this.cache; + if (v.x !== void 0) { + if (cache[0] !== v.x || cache[1] !== v.y) { + gl.uniform2ui(this.addr, v.x, v.y); + cache[0] = v.x; + cache[1] = v.y; + } + } else { + if (arraysEqual(cache, v)) return; + gl.uniform2uiv(this.addr, v); + copyArray(cache, v); + } +} +function setValueV3ui(gl, v) { + const cache = this.cache; + if (v.x !== void 0) { + if (cache[0] !== v.x || cache[1] !== v.y || cache[2] !== v.z) { + gl.uniform3ui(this.addr, v.x, v.y, v.z); + cache[0] = v.x; + cache[1] = v.y; + cache[2] = v.z; + } + } else { + if (arraysEqual(cache, v)) return; + gl.uniform3uiv(this.addr, v); + copyArray(cache, v); + } +} +function setValueV4ui(gl, v) { + const cache = this.cache; + if (v.x !== void 0) { + if (cache[0] !== v.x || cache[1] !== v.y || cache[2] !== v.z || cache[3] !== v.w) { + gl.uniform4ui(this.addr, v.x, v.y, v.z, v.w); + cache[0] = v.x; + cache[1] = v.y; + cache[2] = v.z; + cache[3] = v.w; + } + } else { + if (arraysEqual(cache, v)) return; + gl.uniform4uiv(this.addr, v); + copyArray(cache, v); + } +} +function setValueT1(gl, v, textures) { + const cache = this.cache; + const unit = textures.allocateTextureUnit(); + if (cache[0] !== unit) { + gl.uniform1i(this.addr, unit); + cache[0] = unit; + } + const emptyTexture2D = this.type === gl.SAMPLER_2D_SHADOW ? emptyShadowTexture : emptyTexture; + textures.setTexture2D(v || emptyTexture2D, unit); +} +function setValueT3D1(gl, v, textures) { + const cache = this.cache; + const unit = textures.allocateTextureUnit(); + if (cache[0] !== unit) { + gl.uniform1i(this.addr, unit); + cache[0] = unit; + } + textures.setTexture3D(v || empty3dTexture, unit); +} +function setValueT6(gl, v, textures) { + const cache = this.cache; + const unit = textures.allocateTextureUnit(); + if (cache[0] !== unit) { + gl.uniform1i(this.addr, unit); + cache[0] = unit; + } + textures.setTextureCube(v || emptyCubeTexture, unit); +} +function setValueT2DArray1(gl, v, textures) { + const cache = this.cache; + const unit = textures.allocateTextureUnit(); + if (cache[0] !== unit) { + gl.uniform1i(this.addr, unit); + cache[0] = unit; + } + textures.setTexture2DArray(v || emptyArrayTexture, unit); +} +function getSingularSetter(type) { + switch (type) { + case 5126: + return setValueV1f; + // FLOAT + case 35664: + return setValueV2f; + // _VEC2 + case 35665: + return setValueV3f; + // _VEC3 + case 35666: + return setValueV4f; + // _VEC4 + case 35674: + return setValueM2; + // _MAT2 + case 35675: + return setValueM3; + // _MAT3 + case 35676: + return setValueM4; + // _MAT4 + case 5124: + case 35670: + return setValueV1i; + // INT, BOOL + case 35667: + case 35671: + return setValueV2i; + // _VEC2 + case 35668: + case 35672: + return setValueV3i; + // _VEC3 + case 35669: + case 35673: + return setValueV4i; + // _VEC4 + case 5125: + return setValueV1ui; + // UINT + case 36294: + return setValueV2ui; + // _VEC2 + case 36295: + return setValueV3ui; + // _VEC3 + case 36296: + return setValueV4ui; + // _VEC4 + case 35678: + // SAMPLER_2D + case 36198: + // SAMPLER_EXTERNAL_OES + case 36298: + // INT_SAMPLER_2D + case 36306: + // UNSIGNED_INT_SAMPLER_2D + case 35682: + return setValueT1; + case 35679: + // SAMPLER_3D + case 36299: + // INT_SAMPLER_3D + case 36307: + return setValueT3D1; + case 35680: + // SAMPLER_CUBE + case 36300: + // INT_SAMPLER_CUBE + case 36308: + // UNSIGNED_INT_SAMPLER_CUBE + case 36293: + return setValueT6; + case 36289: + // SAMPLER_2D_ARRAY + case 36303: + // INT_SAMPLER_2D_ARRAY + case 36311: + // UNSIGNED_INT_SAMPLER_2D_ARRAY + case 36292: + return setValueT2DArray1; + } +} +function setValueV1fArray(gl, v) { + gl.uniform1fv(this.addr, v); +} +function setValueV2fArray(gl, v) { + const data = flatten(v, this.size, 2); + gl.uniform2fv(this.addr, data); +} +function setValueV3fArray(gl, v) { + const data = flatten(v, this.size, 3); + gl.uniform3fv(this.addr, data); +} +function setValueV4fArray(gl, v) { + const data = flatten(v, this.size, 4); + gl.uniform4fv(this.addr, data); +} +function setValueM2Array(gl, v) { + const data = flatten(v, this.size, 4); + gl.uniformMatrix2fv(this.addr, false, data); +} +function setValueM3Array(gl, v) { + const data = flatten(v, this.size, 9); + gl.uniformMatrix3fv(this.addr, false, data); +} +function setValueM4Array(gl, v) { + const data = flatten(v, this.size, 16); + gl.uniformMatrix4fv(this.addr, false, data); +} +function setValueV1iArray(gl, v) { + gl.uniform1iv(this.addr, v); +} +function setValueV2iArray(gl, v) { + gl.uniform2iv(this.addr, v); +} +function setValueV3iArray(gl, v) { + gl.uniform3iv(this.addr, v); +} +function setValueV4iArray(gl, v) { + gl.uniform4iv(this.addr, v); +} +function setValueV1uiArray(gl, v) { + gl.uniform1uiv(this.addr, v); +} +function setValueV2uiArray(gl, v) { + gl.uniform2uiv(this.addr, v); +} +function setValueV3uiArray(gl, v) { + gl.uniform3uiv(this.addr, v); +} +function setValueV4uiArray(gl, v) { + gl.uniform4uiv(this.addr, v); +} +function setValueT1Array(gl, v, textures) { + const cache = this.cache; + const n = v.length; + const units = allocTexUnits(textures, n); + if (!arraysEqual(cache, units)) { + gl.uniform1iv(this.addr, units); + copyArray(cache, units); + } + for (let i = 0; i !== n; ++i) { + textures.setTexture2D(v[i] || emptyTexture, units[i]); + } +} +function setValueT3DArray(gl, v, textures) { + const cache = this.cache; + const n = v.length; + const units = allocTexUnits(textures, n); + if (!arraysEqual(cache, units)) { + gl.uniform1iv(this.addr, units); + copyArray(cache, units); + } + for (let i = 0; i !== n; ++i) { + textures.setTexture3D(v[i] || empty3dTexture, units[i]); + } +} +function setValueT6Array(gl, v, textures) { + const cache = this.cache; + const n = v.length; + const units = allocTexUnits(textures, n); + if (!arraysEqual(cache, units)) { + gl.uniform1iv(this.addr, units); + copyArray(cache, units); + } + for (let i = 0; i !== n; ++i) { + textures.setTextureCube(v[i] || emptyCubeTexture, units[i]); + } +} +function setValueT2DArrayArray(gl, v, textures) { + const cache = this.cache; + const n = v.length; + const units = allocTexUnits(textures, n); + if (!arraysEqual(cache, units)) { + gl.uniform1iv(this.addr, units); + copyArray(cache, units); + } + for (let i = 0; i !== n; ++i) { + textures.setTexture2DArray(v[i] || emptyArrayTexture, units[i]); + } +} +function getPureArraySetter(type) { + switch (type) { + case 5126: + return setValueV1fArray; + // FLOAT + case 35664: + return setValueV2fArray; + // _VEC2 + case 35665: + return setValueV3fArray; + // _VEC3 + case 35666: + return setValueV4fArray; + // _VEC4 + case 35674: + return setValueM2Array; + // _MAT2 + case 35675: + return setValueM3Array; + // _MAT3 + case 35676: + return setValueM4Array; + // _MAT4 + case 5124: + case 35670: + return setValueV1iArray; + // INT, BOOL + case 35667: + case 35671: + return setValueV2iArray; + // _VEC2 + case 35668: + case 35672: + return setValueV3iArray; + // _VEC3 + case 35669: + case 35673: + return setValueV4iArray; + // _VEC4 + case 5125: + return setValueV1uiArray; + // UINT + case 36294: + return setValueV2uiArray; + // _VEC2 + case 36295: + return setValueV3uiArray; + // _VEC3 + case 36296: + return setValueV4uiArray; + // _VEC4 + case 35678: + // SAMPLER_2D + case 36198: + // SAMPLER_EXTERNAL_OES + case 36298: + // INT_SAMPLER_2D + case 36306: + // UNSIGNED_INT_SAMPLER_2D + case 35682: + return setValueT1Array; + case 35679: + // SAMPLER_3D + case 36299: + // INT_SAMPLER_3D + case 36307: + return setValueT3DArray; + case 35680: + // SAMPLER_CUBE + case 36300: + // INT_SAMPLER_CUBE + case 36308: + // UNSIGNED_INT_SAMPLER_CUBE + case 36293: + return setValueT6Array; + case 36289: + // SAMPLER_2D_ARRAY + case 36303: + // INT_SAMPLER_2D_ARRAY + case 36311: + // UNSIGNED_INT_SAMPLER_2D_ARRAY + case 36292: + return setValueT2DArrayArray; + } +} +var SingleUniform = class { + constructor(id, activeInfo, addr) { + this.id = id; + this.addr = addr; + this.cache = []; + this.type = activeInfo.type; + this.setValue = getSingularSetter(activeInfo.type); + } +}; +var PureArrayUniform = class { + constructor(id, activeInfo, addr) { + this.id = id; + this.addr = addr; + this.cache = []; + this.type = activeInfo.type; + this.size = activeInfo.size; + this.setValue = getPureArraySetter(activeInfo.type); + } +}; +var StructuredUniform = class { + constructor(id) { + this.id = id; + this.seq = []; + this.map = {}; + } + setValue(gl, value, textures) { + const seq = this.seq; + for (let i = 0, n = seq.length; i !== n; ++i) { + const u = seq[i]; + u.setValue(gl, value[u.id], textures); + } + } +}; +var RePathPart = /(\w+)(\])?(\[|\.)?/g; +function addUniform(container, uniformObject) { + container.seq.push(uniformObject); + container.map[uniformObject.id] = uniformObject; +} +function parseUniform(activeInfo, addr, container) { + const path = activeInfo.name, pathLength = path.length; + RePathPart.lastIndex = 0; + while (true) { + const match = RePathPart.exec(path), matchEnd = RePathPart.lastIndex; + let id = match[1]; + const idIsIndex = match[2] === "]", subscript = match[3]; + if (idIsIndex) id = id | 0; + if (subscript === void 0 || subscript === "[" && matchEnd + 2 === pathLength) { + addUniform(container, subscript === void 0 ? new SingleUniform(id, activeInfo, addr) : new PureArrayUniform(id, activeInfo, addr)); + break; + } else { + const map = container.map; + let next = map[id]; + if (next === void 0) { + next = new StructuredUniform(id); + addUniform(container, next); + } + container = next; + } + } +} +var WebGLUniforms = class { + constructor(gl, program) { + this.seq = []; + this.map = {}; + const n = gl.getProgramParameter(program, gl.ACTIVE_UNIFORMS); + for (let i = 0; i < n; ++i) { + const info = gl.getActiveUniform(program, i), addr = gl.getUniformLocation(program, info.name); + parseUniform(info, addr, this); + } + } + setValue(gl, name, value, textures) { + const u = this.map[name]; + if (u !== void 0) u.setValue(gl, value, textures); + } + setOptional(gl, object, name) { + const v = object[name]; + if (v !== void 0) this.setValue(gl, name, v); + } + static upload(gl, seq, values, textures) { + for (let i = 0, n = seq.length; i !== n; ++i) { + const u = seq[i], v = values[u.id]; + if (v.needsUpdate !== false) { + u.setValue(gl, v.value, textures); + } + } + } + static seqWithValue(seq, values) { + const r = []; + for (let i = 0, n = seq.length; i !== n; ++i) { + const u = seq[i]; + if (u.id in values) r.push(u); + } + return r; + } +}; +function WebGLShader(gl, type, string) { + const shader = gl.createShader(type); + gl.shaderSource(shader, string); + gl.compileShader(shader); + return shader; +} +var COMPLETION_STATUS_KHR = 37297; +var programIdCount = 0; +function handleSource(string, errorLine) { + const lines = string.split("\n"); + const lines2 = []; + const from = Math.max(errorLine - 6, 0); + const to = Math.min(errorLine + 6, lines.length); + for (let i = from; i < to; i++) { + const line = i + 1; + lines2.push(`${line === errorLine ? ">" : " "} ${line}: ${lines[i]}`); + } + return lines2.join("\n"); +} +function getEncodingComponents(colorSpace) { + const workingPrimaries = ColorManagement.getPrimaries(ColorManagement.workingColorSpace); + const encodingPrimaries = ColorManagement.getPrimaries(colorSpace); + let gamutMapping; + if (workingPrimaries === encodingPrimaries) { + gamutMapping = ""; + } else if (workingPrimaries === P3Primaries && encodingPrimaries === Rec709Primaries) { + gamutMapping = "LinearDisplayP3ToLinearSRGB"; + } else if (workingPrimaries === Rec709Primaries && encodingPrimaries === P3Primaries) { + gamutMapping = "LinearSRGBToLinearDisplayP3"; + } + switch (colorSpace) { + case LinearSRGBColorSpace: + case LinearDisplayP3ColorSpace: + return [gamutMapping, "LinearTransferOETF"]; + case SRGBColorSpace: + case DisplayP3ColorSpace: + return [gamutMapping, "sRGBTransferOETF"]; + default: + console.warn("THREE.WebGLProgram: Unsupported color space:", colorSpace); + return [gamutMapping, "LinearTransferOETF"]; + } +} +function getShaderErrors(gl, shader, type) { + const status = gl.getShaderParameter(shader, gl.COMPILE_STATUS); + const errors = gl.getShaderInfoLog(shader).trim(); + if (status && errors === "") return ""; + const errorMatches = /ERROR: 0:(\d+)/.exec(errors); + if (errorMatches) { + const errorLine = parseInt(errorMatches[1]); + return type.toUpperCase() + "\n\n" + errors + "\n\n" + handleSource(gl.getShaderSource(shader), errorLine); + } else { + return errors; + } +} +function getTexelEncodingFunction(functionName, colorSpace) { + const components = getEncodingComponents(colorSpace); + return `vec4 ${functionName}( vec4 value ) { return ${components[0]}( ${components[1]}( value ) ); }`; +} +function getToneMappingFunction(functionName, toneMapping) { + let toneMappingName; + switch (toneMapping) { + case LinearToneMapping: + toneMappingName = "Linear"; + break; + case ReinhardToneMapping: + toneMappingName = "Reinhard"; + break; + case CineonToneMapping: + toneMappingName = "OptimizedCineon"; + break; + case ACESFilmicToneMapping: + toneMappingName = "ACESFilmic"; + break; + case AgXToneMapping: + toneMappingName = "AgX"; + break; + case NeutralToneMapping: + toneMappingName = "Neutral"; + break; + case CustomToneMapping: + toneMappingName = "Custom"; + break; + default: + console.warn("THREE.WebGLProgram: Unsupported toneMapping:", toneMapping); + toneMappingName = "Linear"; + } + return "vec3 " + functionName + "( vec3 color ) { return " + toneMappingName + "ToneMapping( color ); }"; +} +function generateVertexExtensions(parameters) { + const chunks = [ + parameters.extensionClipCullDistance ? "#extension GL_ANGLE_clip_cull_distance : require" : "", + parameters.extensionMultiDraw ? "#extension GL_ANGLE_multi_draw : require" : "" + ]; + return chunks.filter(filterEmptyLine).join("\n"); +} +function generateDefines(defines) { + const chunks = []; + for (const name in defines) { + const value = defines[name]; + if (value === false) continue; + chunks.push("#define " + name + " " + value); + } + return chunks.join("\n"); +} +function fetchAttributeLocations(gl, program) { + const attributes = {}; + const n = gl.getProgramParameter(program, gl.ACTIVE_ATTRIBUTES); + for (let i = 0; i < n; i++) { + const info = gl.getActiveAttrib(program, i); + const name = info.name; + let locationSize = 1; + if (info.type === gl.FLOAT_MAT2) locationSize = 2; + if (info.type === gl.FLOAT_MAT3) locationSize = 3; + if (info.type === gl.FLOAT_MAT4) locationSize = 4; + attributes[name] = { + type: info.type, + location: gl.getAttribLocation(program, name), + locationSize + }; + } + return attributes; +} +function filterEmptyLine(string) { + return string !== ""; +} +function replaceLightNums(string, parameters) { + const numSpotLightCoords = parameters.numSpotLightShadows + parameters.numSpotLightMaps - parameters.numSpotLightShadowsWithMaps; + return string.replace(/NUM_DIR_LIGHTS/g, parameters.numDirLights).replace(/NUM_SPOT_LIGHTS/g, parameters.numSpotLights).replace(/NUM_SPOT_LIGHT_MAPS/g, parameters.numSpotLightMaps).replace(/NUM_SPOT_LIGHT_COORDS/g, numSpotLightCoords).replace(/NUM_RECT_AREA_LIGHTS/g, parameters.numRectAreaLights).replace(/NUM_POINT_LIGHTS/g, parameters.numPointLights).replace(/NUM_HEMI_LIGHTS/g, parameters.numHemiLights).replace(/NUM_DIR_LIGHT_SHADOWS/g, parameters.numDirLightShadows).replace(/NUM_SPOT_LIGHT_SHADOWS_WITH_MAPS/g, parameters.numSpotLightShadowsWithMaps).replace(/NUM_SPOT_LIGHT_SHADOWS/g, parameters.numSpotLightShadows).replace(/NUM_POINT_LIGHT_SHADOWS/g, parameters.numPointLightShadows); +} +function replaceClippingPlaneNums(string, parameters) { + return string.replace(/NUM_CLIPPING_PLANES/g, parameters.numClippingPlanes).replace(/UNION_CLIPPING_PLANES/g, parameters.numClippingPlanes - parameters.numClipIntersection); +} +var includePattern = /^[ \t]*#include +<([\w\d./]+)>/gm; +function resolveIncludes(string) { + return string.replace(includePattern, includeReplacer); +} +var shaderChunkMap = /* @__PURE__ */ new Map([ + ["encodings_fragment", "colorspace_fragment"], + // @deprecated, r154 + ["encodings_pars_fragment", "colorspace_pars_fragment"], + // @deprecated, r154 + ["output_fragment", "opaque_fragment"] + // @deprecated, r154 +]); +function includeReplacer(match, include) { + let string = ShaderChunk[include]; + if (string === void 0) { + const newInclude = shaderChunkMap.get(include); + if (newInclude !== void 0) { + string = ShaderChunk[newInclude]; + console.warn('THREE.WebGLRenderer: Shader chunk "%s" has been deprecated. Use "%s" instead.', include, newInclude); + } else { + throw new Error("Can not resolve #include <" + include + ">"); + } + } + return resolveIncludes(string); +} +var unrollLoopPattern = /#pragma unroll_loop_start\s+for\s*\(\s*int\s+i\s*=\s*(\d+)\s*;\s*i\s*<\s*(\d+)\s*;\s*i\s*\+\+\s*\)\s*{([\s\S]+?)}\s+#pragma unroll_loop_end/g; +function unrollLoops(string) { + return string.replace(unrollLoopPattern, loopReplacer); +} +function loopReplacer(match, start, end, snippet) { + let string = ""; + for (let i = parseInt(start); i < parseInt(end); i++) { + string += snippet.replace(/\[\s*i\s*\]/g, "[ " + i + " ]").replace(/UNROLLED_LOOP_INDEX/g, i); + } + return string; +} +function generatePrecision(parameters) { + let precisionstring = `precision ${parameters.precision} float; + precision ${parameters.precision} int; + precision ${parameters.precision} sampler2D; + precision ${parameters.precision} samplerCube; + precision ${parameters.precision} sampler3D; + precision ${parameters.precision} sampler2DArray; + precision ${parameters.precision} sampler2DShadow; + precision ${parameters.precision} samplerCubeShadow; + precision ${parameters.precision} sampler2DArrayShadow; + precision ${parameters.precision} isampler2D; + precision ${parameters.precision} isampler3D; + precision ${parameters.precision} isamplerCube; + precision ${parameters.precision} isampler2DArray; + precision ${parameters.precision} usampler2D; + precision ${parameters.precision} usampler3D; + precision ${parameters.precision} usamplerCube; + precision ${parameters.precision} usampler2DArray; + `; + if (parameters.precision === "highp") { + precisionstring += "\n#define HIGH_PRECISION"; + } else if (parameters.precision === "mediump") { + precisionstring += "\n#define MEDIUM_PRECISION"; + } else if (parameters.precision === "lowp") { + precisionstring += "\n#define LOW_PRECISION"; + } + return precisionstring; +} +function generateShadowMapTypeDefine(parameters) { + let shadowMapTypeDefine = "SHADOWMAP_TYPE_BASIC"; + if (parameters.shadowMapType === PCFShadowMap) { + shadowMapTypeDefine = "SHADOWMAP_TYPE_PCF"; + } else if (parameters.shadowMapType === PCFSoftShadowMap) { + shadowMapTypeDefine = "SHADOWMAP_TYPE_PCF_SOFT"; + } else if (parameters.shadowMapType === VSMShadowMap) { + shadowMapTypeDefine = "SHADOWMAP_TYPE_VSM"; + } + return shadowMapTypeDefine; +} +function generateEnvMapTypeDefine(parameters) { + let envMapTypeDefine = "ENVMAP_TYPE_CUBE"; + if (parameters.envMap) { + switch (parameters.envMapMode) { + case CubeReflectionMapping: + case CubeRefractionMapping: + envMapTypeDefine = "ENVMAP_TYPE_CUBE"; + break; + case CubeUVReflectionMapping: + envMapTypeDefine = "ENVMAP_TYPE_CUBE_UV"; + break; + } + } + return envMapTypeDefine; +} +function generateEnvMapModeDefine(parameters) { + let envMapModeDefine = "ENVMAP_MODE_REFLECTION"; + if (parameters.envMap) { + switch (parameters.envMapMode) { + case CubeRefractionMapping: + envMapModeDefine = "ENVMAP_MODE_REFRACTION"; + break; + } + } + return envMapModeDefine; +} +function generateEnvMapBlendingDefine(parameters) { + let envMapBlendingDefine = "ENVMAP_BLENDING_NONE"; + if (parameters.envMap) { + switch (parameters.combine) { + case MultiplyOperation: + envMapBlendingDefine = "ENVMAP_BLENDING_MULTIPLY"; + break; + case MixOperation: + envMapBlendingDefine = "ENVMAP_BLENDING_MIX"; + break; + case AddOperation: + envMapBlendingDefine = "ENVMAP_BLENDING_ADD"; + break; + } + } + return envMapBlendingDefine; +} +function generateCubeUVSize(parameters) { + const imageHeight = parameters.envMapCubeUVHeight; + if (imageHeight === null) return null; + const maxMip = Math.log2(imageHeight) - 2; + const texelHeight = 1 / imageHeight; + const texelWidth = 1 / (3 * Math.max(Math.pow(2, maxMip), 7 * 16)); + return { texelWidth, texelHeight, maxMip }; +} +function WebGLProgram(renderer, cacheKey, parameters, bindingStates) { + const gl = renderer.getContext(); + const defines = parameters.defines; + let vertexShader2 = parameters.vertexShader; + let fragmentShader2 = parameters.fragmentShader; + const shadowMapTypeDefine = generateShadowMapTypeDefine(parameters); + const envMapTypeDefine = generateEnvMapTypeDefine(parameters); + const envMapModeDefine = generateEnvMapModeDefine(parameters); + const envMapBlendingDefine = generateEnvMapBlendingDefine(parameters); + const envMapCubeUVSize = generateCubeUVSize(parameters); + const customVertexExtensions = generateVertexExtensions(parameters); + const customDefines = generateDefines(defines); + const program = gl.createProgram(); + let prefixVertex, prefixFragment; + let versionString = parameters.glslVersion ? "#version " + parameters.glslVersion + "\n" : ""; + if (parameters.isRawShaderMaterial) { + prefixVertex = [ + "#define SHADER_TYPE " + parameters.shaderType, + "#define SHADER_NAME " + parameters.shaderName, + customDefines + ].filter(filterEmptyLine).join("\n"); + if (prefixVertex.length > 0) { + prefixVertex += "\n"; + } + prefixFragment = [ + "#define SHADER_TYPE " + parameters.shaderType, + "#define SHADER_NAME " + parameters.shaderName, + customDefines + ].filter(filterEmptyLine).join("\n"); + if (prefixFragment.length > 0) { + prefixFragment += "\n"; + } + } else { + prefixVertex = [ + generatePrecision(parameters), + "#define SHADER_TYPE " + parameters.shaderType, + "#define SHADER_NAME " + parameters.shaderName, + customDefines, + parameters.extensionClipCullDistance ? "#define USE_CLIP_DISTANCE" : "", + parameters.batching ? "#define USE_BATCHING" : "", + parameters.instancing ? "#define USE_INSTANCING" : "", + parameters.instancingColor ? "#define USE_INSTANCING_COLOR" : "", + parameters.instancingMorph ? "#define USE_INSTANCING_MORPH" : "", + parameters.useFog && parameters.fog ? "#define USE_FOG" : "", + parameters.useFog && parameters.fogExp2 ? "#define FOG_EXP2" : "", + parameters.map ? "#define USE_MAP" : "", + parameters.envMap ? "#define USE_ENVMAP" : "", + parameters.envMap ? "#define " + envMapModeDefine : "", + parameters.lightMap ? "#define USE_LIGHTMAP" : "", + parameters.aoMap ? "#define USE_AOMAP" : "", + parameters.bumpMap ? "#define USE_BUMPMAP" : "", + parameters.normalMap ? "#define USE_NORMALMAP" : "", + parameters.normalMapObjectSpace ? "#define USE_NORMALMAP_OBJECTSPACE" : "", + parameters.normalMapTangentSpace ? "#define USE_NORMALMAP_TANGENTSPACE" : "", + parameters.displacementMap ? "#define USE_DISPLACEMENTMAP" : "", + parameters.emissiveMap ? "#define USE_EMISSIVEMAP" : "", + parameters.anisotropy ? "#define USE_ANISOTROPY" : "", + parameters.anisotropyMap ? "#define USE_ANISOTROPYMAP" : "", + parameters.clearcoatMap ? "#define USE_CLEARCOATMAP" : "", + parameters.clearcoatRoughnessMap ? "#define USE_CLEARCOAT_ROUGHNESSMAP" : "", + parameters.clearcoatNormalMap ? "#define USE_CLEARCOAT_NORMALMAP" : "", + parameters.iridescenceMap ? "#define USE_IRIDESCENCEMAP" : "", + parameters.iridescenceThicknessMap ? "#define USE_IRIDESCENCE_THICKNESSMAP" : "", + parameters.specularMap ? "#define USE_SPECULARMAP" : "", + parameters.specularColorMap ? "#define USE_SPECULAR_COLORMAP" : "", + parameters.specularIntensityMap ? "#define USE_SPECULAR_INTENSITYMAP" : "", + parameters.roughnessMap ? "#define USE_ROUGHNESSMAP" : "", + parameters.metalnessMap ? "#define USE_METALNESSMAP" : "", + parameters.alphaMap ? "#define USE_ALPHAMAP" : "", + parameters.alphaHash ? "#define USE_ALPHAHASH" : "", + parameters.transmission ? "#define USE_TRANSMISSION" : "", + parameters.transmissionMap ? "#define USE_TRANSMISSIONMAP" : "", + parameters.thicknessMap ? "#define USE_THICKNESSMAP" : "", + parameters.sheenColorMap ? "#define USE_SHEEN_COLORMAP" : "", + parameters.sheenRoughnessMap ? "#define USE_SHEEN_ROUGHNESSMAP" : "", + // + parameters.mapUv ? "#define MAP_UV " + parameters.mapUv : "", + parameters.alphaMapUv ? "#define ALPHAMAP_UV " + parameters.alphaMapUv : "", + parameters.lightMapUv ? "#define LIGHTMAP_UV " + parameters.lightMapUv : "", + parameters.aoMapUv ? "#define AOMAP_UV " + parameters.aoMapUv : "", + parameters.emissiveMapUv ? "#define EMISSIVEMAP_UV " + parameters.emissiveMapUv : "", + parameters.bumpMapUv ? "#define BUMPMAP_UV " + parameters.bumpMapUv : "", + parameters.normalMapUv ? "#define NORMALMAP_UV " + parameters.normalMapUv : "", + parameters.displacementMapUv ? "#define DISPLACEMENTMAP_UV " + parameters.displacementMapUv : "", + parameters.metalnessMapUv ? "#define METALNESSMAP_UV " + parameters.metalnessMapUv : "", + parameters.roughnessMapUv ? "#define ROUGHNESSMAP_UV " + parameters.roughnessMapUv : "", + parameters.anisotropyMapUv ? "#define ANISOTROPYMAP_UV " + parameters.anisotropyMapUv : "", + parameters.clearcoatMapUv ? "#define CLEARCOATMAP_UV " + parameters.clearcoatMapUv : "", + parameters.clearcoatNormalMapUv ? "#define CLEARCOAT_NORMALMAP_UV " + parameters.clearcoatNormalMapUv : "", + parameters.clearcoatRoughnessMapUv ? "#define CLEARCOAT_ROUGHNESSMAP_UV " + parameters.clearcoatRoughnessMapUv : "", + parameters.iridescenceMapUv ? "#define IRIDESCENCEMAP_UV " + parameters.iridescenceMapUv : "", + parameters.iridescenceThicknessMapUv ? "#define IRIDESCENCE_THICKNESSMAP_UV " + parameters.iridescenceThicknessMapUv : "", + parameters.sheenColorMapUv ? "#define SHEEN_COLORMAP_UV " + parameters.sheenColorMapUv : "", + parameters.sheenRoughnessMapUv ? "#define SHEEN_ROUGHNESSMAP_UV " + parameters.sheenRoughnessMapUv : "", + parameters.specularMapUv ? "#define SPECULARMAP_UV " + parameters.specularMapUv : "", + parameters.specularColorMapUv ? "#define SPECULAR_COLORMAP_UV " + parameters.specularColorMapUv : "", + parameters.specularIntensityMapUv ? "#define SPECULAR_INTENSITYMAP_UV " + parameters.specularIntensityMapUv : "", + parameters.transmissionMapUv ? "#define TRANSMISSIONMAP_UV " + parameters.transmissionMapUv : "", + parameters.thicknessMapUv ? "#define THICKNESSMAP_UV " + parameters.thicknessMapUv : "", + // + parameters.vertexTangents && parameters.flatShading === false ? "#define USE_TANGENT" : "", + parameters.vertexColors ? "#define USE_COLOR" : "", + parameters.vertexAlphas ? "#define USE_COLOR_ALPHA" : "", + parameters.vertexUv1s ? "#define USE_UV1" : "", + parameters.vertexUv2s ? "#define USE_UV2" : "", + parameters.vertexUv3s ? "#define USE_UV3" : "", + parameters.pointsUvs ? "#define USE_POINTS_UV" : "", + parameters.flatShading ? "#define FLAT_SHADED" : "", + parameters.skinning ? "#define USE_SKINNING" : "", + parameters.morphTargets ? "#define USE_MORPHTARGETS" : "", + parameters.morphNormals && parameters.flatShading === false ? "#define USE_MORPHNORMALS" : "", + parameters.morphColors ? "#define USE_MORPHCOLORS" : "", + parameters.morphTargetsCount > 0 ? "#define MORPHTARGETS_TEXTURE" : "", + parameters.morphTargetsCount > 0 ? "#define MORPHTARGETS_TEXTURE_STRIDE " + parameters.morphTextureStride : "", + parameters.morphTargetsCount > 0 ? "#define MORPHTARGETS_COUNT " + parameters.morphTargetsCount : "", + parameters.doubleSided ? "#define DOUBLE_SIDED" : "", + parameters.flipSided ? "#define FLIP_SIDED" : "", + parameters.shadowMapEnabled ? "#define USE_SHADOWMAP" : "", + parameters.shadowMapEnabled ? "#define " + shadowMapTypeDefine : "", + parameters.sizeAttenuation ? "#define USE_SIZEATTENUATION" : "", + parameters.numLightProbes > 0 ? "#define USE_LIGHT_PROBES" : "", + parameters.useLegacyLights ? "#define LEGACY_LIGHTS" : "", + parameters.logarithmicDepthBuffer ? "#define USE_LOGDEPTHBUF" : "", + "uniform mat4 modelMatrix;", + "uniform mat4 modelViewMatrix;", + "uniform mat4 projectionMatrix;", + "uniform mat4 viewMatrix;", + "uniform mat3 normalMatrix;", + "uniform vec3 cameraPosition;", + "uniform bool isOrthographic;", + "#ifdef USE_INSTANCING", + " attribute mat4 instanceMatrix;", + "#endif", + "#ifdef USE_INSTANCING_COLOR", + " attribute vec3 instanceColor;", + "#endif", + "#ifdef USE_INSTANCING_MORPH", + " uniform sampler2D morphTexture;", + "#endif", + "attribute vec3 position;", + "attribute vec3 normal;", + "attribute vec2 uv;", + "#ifdef USE_UV1", + " attribute vec2 uv1;", + "#endif", + "#ifdef USE_UV2", + " attribute vec2 uv2;", + "#endif", + "#ifdef USE_UV3", + " attribute vec2 uv3;", + "#endif", + "#ifdef USE_TANGENT", + " attribute vec4 tangent;", + "#endif", + "#if defined( USE_COLOR_ALPHA )", + " attribute vec4 color;", + "#elif defined( USE_COLOR )", + " attribute vec3 color;", + "#endif", + "#if ( defined( USE_MORPHTARGETS ) && ! defined( MORPHTARGETS_TEXTURE ) )", + " attribute vec3 morphTarget0;", + " attribute vec3 morphTarget1;", + " attribute vec3 morphTarget2;", + " attribute vec3 morphTarget3;", + " #ifdef USE_MORPHNORMALS", + " attribute vec3 morphNormal0;", + " attribute vec3 morphNormal1;", + " attribute vec3 morphNormal2;", + " attribute vec3 morphNormal3;", + " #else", + " attribute vec3 morphTarget4;", + " attribute vec3 morphTarget5;", + " attribute vec3 morphTarget6;", + " attribute vec3 morphTarget7;", + " #endif", + "#endif", + "#ifdef USE_SKINNING", + " attribute vec4 skinIndex;", + " attribute vec4 skinWeight;", + "#endif", + "\n" + ].filter(filterEmptyLine).join("\n"); + prefixFragment = [ + generatePrecision(parameters), + "#define SHADER_TYPE " + parameters.shaderType, + "#define SHADER_NAME " + parameters.shaderName, + customDefines, + parameters.useFog && parameters.fog ? "#define USE_FOG" : "", + parameters.useFog && parameters.fogExp2 ? "#define FOG_EXP2" : "", + parameters.alphaToCoverage ? "#define ALPHA_TO_COVERAGE" : "", + parameters.map ? "#define USE_MAP" : "", + parameters.matcap ? "#define USE_MATCAP" : "", + parameters.envMap ? "#define USE_ENVMAP" : "", + parameters.envMap ? "#define " + envMapTypeDefine : "", + parameters.envMap ? "#define " + envMapModeDefine : "", + parameters.envMap ? "#define " + envMapBlendingDefine : "", + envMapCubeUVSize ? "#define CUBEUV_TEXEL_WIDTH " + envMapCubeUVSize.texelWidth : "", + envMapCubeUVSize ? "#define CUBEUV_TEXEL_HEIGHT " + envMapCubeUVSize.texelHeight : "", + envMapCubeUVSize ? "#define CUBEUV_MAX_MIP " + envMapCubeUVSize.maxMip + ".0" : "", + parameters.lightMap ? "#define USE_LIGHTMAP" : "", + parameters.aoMap ? "#define USE_AOMAP" : "", + parameters.bumpMap ? "#define USE_BUMPMAP" : "", + parameters.normalMap ? "#define USE_NORMALMAP" : "", + parameters.normalMapObjectSpace ? "#define USE_NORMALMAP_OBJECTSPACE" : "", + parameters.normalMapTangentSpace ? "#define USE_NORMALMAP_TANGENTSPACE" : "", + parameters.emissiveMap ? "#define USE_EMISSIVEMAP" : "", + parameters.anisotropy ? "#define USE_ANISOTROPY" : "", + parameters.anisotropyMap ? "#define USE_ANISOTROPYMAP" : "", + parameters.clearcoat ? "#define USE_CLEARCOAT" : "", + parameters.clearcoatMap ? "#define USE_CLEARCOATMAP" : "", + parameters.clearcoatRoughnessMap ? "#define USE_CLEARCOAT_ROUGHNESSMAP" : "", + parameters.clearcoatNormalMap ? "#define USE_CLEARCOAT_NORMALMAP" : "", + parameters.iridescence ? "#define USE_IRIDESCENCE" : "", + parameters.iridescenceMap ? "#define USE_IRIDESCENCEMAP" : "", + parameters.iridescenceThicknessMap ? "#define USE_IRIDESCENCE_THICKNESSMAP" : "", + parameters.specularMap ? "#define USE_SPECULARMAP" : "", + parameters.specularColorMap ? "#define USE_SPECULAR_COLORMAP" : "", + parameters.specularIntensityMap ? "#define USE_SPECULAR_INTENSITYMAP" : "", + parameters.roughnessMap ? "#define USE_ROUGHNESSMAP" : "", + parameters.metalnessMap ? "#define USE_METALNESSMAP" : "", + parameters.alphaMap ? "#define USE_ALPHAMAP" : "", + parameters.alphaTest ? "#define USE_ALPHATEST" : "", + parameters.alphaHash ? "#define USE_ALPHAHASH" : "", + parameters.sheen ? "#define USE_SHEEN" : "", + parameters.sheenColorMap ? "#define USE_SHEEN_COLORMAP" : "", + parameters.sheenRoughnessMap ? "#define USE_SHEEN_ROUGHNESSMAP" : "", + parameters.transmission ? "#define USE_TRANSMISSION" : "", + parameters.transmissionMap ? "#define USE_TRANSMISSIONMAP" : "", + parameters.thicknessMap ? "#define USE_THICKNESSMAP" : "", + parameters.vertexTangents && parameters.flatShading === false ? "#define USE_TANGENT" : "", + parameters.vertexColors || parameters.instancingColor ? "#define USE_COLOR" : "", + parameters.vertexAlphas ? "#define USE_COLOR_ALPHA" : "", + parameters.vertexUv1s ? "#define USE_UV1" : "", + parameters.vertexUv2s ? "#define USE_UV2" : "", + parameters.vertexUv3s ? "#define USE_UV3" : "", + parameters.pointsUvs ? "#define USE_POINTS_UV" : "", + parameters.gradientMap ? "#define USE_GRADIENTMAP" : "", + parameters.flatShading ? "#define FLAT_SHADED" : "", + parameters.doubleSided ? "#define DOUBLE_SIDED" : "", + parameters.flipSided ? "#define FLIP_SIDED" : "", + parameters.shadowMapEnabled ? "#define USE_SHADOWMAP" : "", + parameters.shadowMapEnabled ? "#define " + shadowMapTypeDefine : "", + parameters.premultipliedAlpha ? "#define PREMULTIPLIED_ALPHA" : "", + parameters.numLightProbes > 0 ? "#define USE_LIGHT_PROBES" : "", + parameters.useLegacyLights ? "#define LEGACY_LIGHTS" : "", + parameters.decodeVideoTexture ? "#define DECODE_VIDEO_TEXTURE" : "", + parameters.logarithmicDepthBuffer ? "#define USE_LOGDEPTHBUF" : "", + "uniform mat4 viewMatrix;", + "uniform vec3 cameraPosition;", + "uniform bool isOrthographic;", + parameters.toneMapping !== NoToneMapping ? "#define TONE_MAPPING" : "", + parameters.toneMapping !== NoToneMapping ? ShaderChunk["tonemapping_pars_fragment"] : "", + // this code is required here because it is used by the toneMapping() function defined below + parameters.toneMapping !== NoToneMapping ? getToneMappingFunction("toneMapping", parameters.toneMapping) : "", + parameters.dithering ? "#define DITHERING" : "", + parameters.opaque ? "#define OPAQUE" : "", + ShaderChunk["colorspace_pars_fragment"], + // this code is required here because it is used by the various encoding/decoding function defined below + getTexelEncodingFunction("linearToOutputTexel", parameters.outputColorSpace), + parameters.useDepthPacking ? "#define DEPTH_PACKING " + parameters.depthPacking : "", + "\n" + ].filter(filterEmptyLine).join("\n"); + } + vertexShader2 = resolveIncludes(vertexShader2); + vertexShader2 = replaceLightNums(vertexShader2, parameters); + vertexShader2 = replaceClippingPlaneNums(vertexShader2, parameters); + fragmentShader2 = resolveIncludes(fragmentShader2); + fragmentShader2 = replaceLightNums(fragmentShader2, parameters); + fragmentShader2 = replaceClippingPlaneNums(fragmentShader2, parameters); + vertexShader2 = unrollLoops(vertexShader2); + fragmentShader2 = unrollLoops(fragmentShader2); + if (parameters.isRawShaderMaterial !== true) { + versionString = "#version 300 es\n"; + prefixVertex = [ + customVertexExtensions, + "#define attribute in", + "#define varying out", + "#define texture2D texture" + ].join("\n") + "\n" + prefixVertex; + prefixFragment = [ + "#define varying in", + parameters.glslVersion === GLSL3 ? "" : "layout(location = 0) out highp vec4 pc_fragColor;", + parameters.glslVersion === GLSL3 ? "" : "#define gl_FragColor pc_fragColor", + "#define gl_FragDepthEXT gl_FragDepth", + "#define texture2D texture", + "#define textureCube texture", + "#define texture2DProj textureProj", + "#define texture2DLodEXT textureLod", + "#define texture2DProjLodEXT textureProjLod", + "#define textureCubeLodEXT textureLod", + "#define texture2DGradEXT textureGrad", + "#define texture2DProjGradEXT textureProjGrad", + "#define textureCubeGradEXT textureGrad" + ].join("\n") + "\n" + prefixFragment; + } + const vertexGlsl = versionString + prefixVertex + vertexShader2; + const fragmentGlsl = versionString + prefixFragment + fragmentShader2; + const glVertexShader = WebGLShader(gl, gl.VERTEX_SHADER, vertexGlsl); + const glFragmentShader = WebGLShader(gl, gl.FRAGMENT_SHADER, fragmentGlsl); + gl.attachShader(program, glVertexShader); + gl.attachShader(program, glFragmentShader); + if (parameters.index0AttributeName !== void 0) { + gl.bindAttribLocation(program, 0, parameters.index0AttributeName); + } else if (parameters.morphTargets === true) { + gl.bindAttribLocation(program, 0, "position"); + } + gl.linkProgram(program); + function onFirstUse(self2) { + if (renderer.debug.checkShaderErrors) { + const programLog = gl.getProgramInfoLog(program).trim(); + const vertexLog = gl.getShaderInfoLog(glVertexShader).trim(); + const fragmentLog = gl.getShaderInfoLog(glFragmentShader).trim(); + let runnable = true; + let haveDiagnostics = true; + if (gl.getProgramParameter(program, gl.LINK_STATUS) === false) { + runnable = false; + if (typeof renderer.debug.onShaderError === "function") { + renderer.debug.onShaderError(gl, program, glVertexShader, glFragmentShader); + } else { + const vertexErrors = getShaderErrors(gl, glVertexShader, "vertex"); + const fragmentErrors = getShaderErrors(gl, glFragmentShader, "fragment"); + console.error( + "THREE.WebGLProgram: Shader Error " + gl.getError() + " - VALIDATE_STATUS " + gl.getProgramParameter(program, gl.VALIDATE_STATUS) + "\n\nMaterial Name: " + self2.name + "\nMaterial Type: " + self2.type + "\n\nProgram Info Log: " + programLog + "\n" + vertexErrors + "\n" + fragmentErrors + ); + } + } else if (programLog !== "") { + console.warn("THREE.WebGLProgram: Program Info Log:", programLog); + } else if (vertexLog === "" || fragmentLog === "") { + haveDiagnostics = false; + } + if (haveDiagnostics) { + self2.diagnostics = { + runnable, + programLog, + vertexShader: { + log: vertexLog, + prefix: prefixVertex + }, + fragmentShader: { + log: fragmentLog, + prefix: prefixFragment + } + }; + } + } + gl.deleteShader(glVertexShader); + gl.deleteShader(glFragmentShader); + cachedUniforms = new WebGLUniforms(gl, program); + cachedAttributes = fetchAttributeLocations(gl, program); + } + let cachedUniforms; + this.getUniforms = function() { + if (cachedUniforms === void 0) { + onFirstUse(this); + } + return cachedUniforms; + }; + let cachedAttributes; + this.getAttributes = function() { + if (cachedAttributes === void 0) { + onFirstUse(this); + } + return cachedAttributes; + }; + let programReady = parameters.rendererExtensionParallelShaderCompile === false; + this.isReady = function() { + if (programReady === false) { + programReady = gl.getProgramParameter(program, COMPLETION_STATUS_KHR); + } + return programReady; + }; + this.destroy = function() { + bindingStates.releaseStatesOfProgram(this); + gl.deleteProgram(program); + this.program = void 0; + }; + this.type = parameters.shaderType; + this.name = parameters.shaderName; + this.id = programIdCount++; + this.cacheKey = cacheKey; + this.usedTimes = 1; + this.program = program; + this.vertexShader = glVertexShader; + this.fragmentShader = glFragmentShader; + return this; +} +var _id$1 = 0; +var WebGLShaderCache = class { + constructor() { + this.shaderCache = /* @__PURE__ */ new Map(); + this.materialCache = /* @__PURE__ */ new Map(); + } + update(material) { + const vertexShader2 = material.vertexShader; + const fragmentShader2 = material.fragmentShader; + const vertexShaderStage = this._getShaderStage(vertexShader2); + const fragmentShaderStage = this._getShaderStage(fragmentShader2); + const materialShaders = this._getShaderCacheForMaterial(material); + if (materialShaders.has(vertexShaderStage) === false) { + materialShaders.add(vertexShaderStage); + vertexShaderStage.usedTimes++; + } + if (materialShaders.has(fragmentShaderStage) === false) { + materialShaders.add(fragmentShaderStage); + fragmentShaderStage.usedTimes++; + } + return this; + } + remove(material) { + const materialShaders = this.materialCache.get(material); + for (const shaderStage of materialShaders) { + shaderStage.usedTimes--; + if (shaderStage.usedTimes === 0) this.shaderCache.delete(shaderStage.code); + } + this.materialCache.delete(material); + return this; + } + getVertexShaderID(material) { + return this._getShaderStage(material.vertexShader).id; + } + getFragmentShaderID(material) { + return this._getShaderStage(material.fragmentShader).id; + } + dispose() { + this.shaderCache.clear(); + this.materialCache.clear(); + } + _getShaderCacheForMaterial(material) { + const cache = this.materialCache; + let set = cache.get(material); + if (set === void 0) { + set = /* @__PURE__ */ new Set(); + cache.set(material, set); + } + return set; + } + _getShaderStage(code) { + const cache = this.shaderCache; + let stage = cache.get(code); + if (stage === void 0) { + stage = new WebGLShaderStage(code); + cache.set(code, stage); + } + return stage; + } +}; +var WebGLShaderStage = class { + constructor(code) { + this.id = _id$1++; + this.code = code; + this.usedTimes = 0; + } +}; +function WebGLPrograms(renderer, cubemaps, cubeuvmaps, extensions, capabilities, bindingStates, clipping) { + const _programLayers = new Layers(); + const _customShaders = new WebGLShaderCache(); + const _activeChannels = /* @__PURE__ */ new Set(); + const programs = []; + const logarithmicDepthBuffer = capabilities.logarithmicDepthBuffer; + const SUPPORTS_VERTEX_TEXTURES = capabilities.vertexTextures; + let precision = capabilities.precision; + const shaderIDs = { + MeshDepthMaterial: "depth", + MeshDistanceMaterial: "distanceRGBA", + MeshNormalMaterial: "normal", + MeshBasicMaterial: "basic", + MeshLambertMaterial: "lambert", + MeshPhongMaterial: "phong", + MeshToonMaterial: "toon", + MeshStandardMaterial: "physical", + MeshPhysicalMaterial: "physical", + MeshMatcapMaterial: "matcap", + LineBasicMaterial: "basic", + LineDashedMaterial: "dashed", + PointsMaterial: "points", + ShadowMaterial: "shadow", + SpriteMaterial: "sprite" + }; + function getChannel(value) { + _activeChannels.add(value); + if (value === 0) return "uv"; + return `uv${value}`; + } + function getParameters(material, lights, shadows, scene, object) { + const fog = scene.fog; + const geometry = object.geometry; + const environment = material.isMeshStandardMaterial ? scene.environment : null; + const envMap = (material.isMeshStandardMaterial ? cubeuvmaps : cubemaps).get(material.envMap || environment); + const envMapCubeUVHeight = !!envMap && envMap.mapping === CubeUVReflectionMapping ? envMap.image.height : null; + const shaderID = shaderIDs[material.type]; + if (material.precision !== null) { + precision = capabilities.getMaxPrecision(material.precision); + if (precision !== material.precision) { + console.warn("THREE.WebGLProgram.getParameters:", material.precision, "not supported, using", precision, "instead."); + } + } + const morphAttribute = geometry.morphAttributes.position || geometry.morphAttributes.normal || geometry.morphAttributes.color; + const morphTargetsCount = morphAttribute !== void 0 ? morphAttribute.length : 0; + let morphTextureStride = 0; + if (geometry.morphAttributes.position !== void 0) morphTextureStride = 1; + if (geometry.morphAttributes.normal !== void 0) morphTextureStride = 2; + if (geometry.morphAttributes.color !== void 0) morphTextureStride = 3; + let vertexShader2, fragmentShader2; + let customVertexShaderID, customFragmentShaderID; + if (shaderID) { + const shader = ShaderLib[shaderID]; + vertexShader2 = shader.vertexShader; + fragmentShader2 = shader.fragmentShader; + } else { + vertexShader2 = material.vertexShader; + fragmentShader2 = material.fragmentShader; + _customShaders.update(material); + customVertexShaderID = _customShaders.getVertexShaderID(material); + customFragmentShaderID = _customShaders.getFragmentShaderID(material); + } + const currentRenderTarget = renderer.getRenderTarget(); + const IS_INSTANCEDMESH = object.isInstancedMesh === true; + const IS_BATCHEDMESH = object.isBatchedMesh === true; + const HAS_MAP = !!material.map; + const HAS_MATCAP = !!material.matcap; + const HAS_ENVMAP = !!envMap; + const HAS_AOMAP = !!material.aoMap; + const HAS_LIGHTMAP = !!material.lightMap; + const HAS_BUMPMAP = !!material.bumpMap; + const HAS_NORMALMAP = !!material.normalMap; + const HAS_DISPLACEMENTMAP = !!material.displacementMap; + const HAS_EMISSIVEMAP = !!material.emissiveMap; + const HAS_METALNESSMAP = !!material.metalnessMap; + const HAS_ROUGHNESSMAP = !!material.roughnessMap; + const HAS_ANISOTROPY = material.anisotropy > 0; + const HAS_CLEARCOAT = material.clearcoat > 0; + const HAS_IRIDESCENCE = material.iridescence > 0; + const HAS_SHEEN = material.sheen > 0; + const HAS_TRANSMISSION = material.transmission > 0; + const HAS_ANISOTROPYMAP = HAS_ANISOTROPY && !!material.anisotropyMap; + const HAS_CLEARCOATMAP = HAS_CLEARCOAT && !!material.clearcoatMap; + const HAS_CLEARCOAT_NORMALMAP = HAS_CLEARCOAT && !!material.clearcoatNormalMap; + const HAS_CLEARCOAT_ROUGHNESSMAP = HAS_CLEARCOAT && !!material.clearcoatRoughnessMap; + const HAS_IRIDESCENCEMAP = HAS_IRIDESCENCE && !!material.iridescenceMap; + const HAS_IRIDESCENCE_THICKNESSMAP = HAS_IRIDESCENCE && !!material.iridescenceThicknessMap; + const HAS_SHEEN_COLORMAP = HAS_SHEEN && !!material.sheenColorMap; + const HAS_SHEEN_ROUGHNESSMAP = HAS_SHEEN && !!material.sheenRoughnessMap; + const HAS_SPECULARMAP = !!material.specularMap; + const HAS_SPECULAR_COLORMAP = !!material.specularColorMap; + const HAS_SPECULAR_INTENSITYMAP = !!material.specularIntensityMap; + const HAS_TRANSMISSIONMAP = HAS_TRANSMISSION && !!material.transmissionMap; + const HAS_THICKNESSMAP = HAS_TRANSMISSION && !!material.thicknessMap; + const HAS_GRADIENTMAP = !!material.gradientMap; + const HAS_ALPHAMAP = !!material.alphaMap; + const HAS_ALPHATEST = material.alphaTest > 0; + const HAS_ALPHAHASH = !!material.alphaHash; + const HAS_EXTENSIONS = !!material.extensions; + let toneMapping = NoToneMapping; + if (material.toneMapped) { + if (currentRenderTarget === null || currentRenderTarget.isXRRenderTarget === true) { + toneMapping = renderer.toneMapping; + } + } + const parameters = { + shaderID, + shaderType: material.type, + shaderName: material.name, + vertexShader: vertexShader2, + fragmentShader: fragmentShader2, + defines: material.defines, + customVertexShaderID, + customFragmentShaderID, + isRawShaderMaterial: material.isRawShaderMaterial === true, + glslVersion: material.glslVersion, + precision, + batching: IS_BATCHEDMESH, + instancing: IS_INSTANCEDMESH, + instancingColor: IS_INSTANCEDMESH && object.instanceColor !== null, + instancingMorph: IS_INSTANCEDMESH && object.morphTexture !== null, + supportsVertexTextures: SUPPORTS_VERTEX_TEXTURES, + outputColorSpace: currentRenderTarget === null ? renderer.outputColorSpace : currentRenderTarget.isXRRenderTarget === true ? currentRenderTarget.texture.colorSpace : LinearSRGBColorSpace, + alphaToCoverage: !!material.alphaToCoverage, + map: HAS_MAP, + matcap: HAS_MATCAP, + envMap: HAS_ENVMAP, + envMapMode: HAS_ENVMAP && envMap.mapping, + envMapCubeUVHeight, + aoMap: HAS_AOMAP, + lightMap: HAS_LIGHTMAP, + bumpMap: HAS_BUMPMAP, + normalMap: HAS_NORMALMAP, + displacementMap: SUPPORTS_VERTEX_TEXTURES && HAS_DISPLACEMENTMAP, + emissiveMap: HAS_EMISSIVEMAP, + normalMapObjectSpace: HAS_NORMALMAP && material.normalMapType === ObjectSpaceNormalMap, + normalMapTangentSpace: HAS_NORMALMAP && material.normalMapType === TangentSpaceNormalMap, + metalnessMap: HAS_METALNESSMAP, + roughnessMap: HAS_ROUGHNESSMAP, + anisotropy: HAS_ANISOTROPY, + anisotropyMap: HAS_ANISOTROPYMAP, + clearcoat: HAS_CLEARCOAT, + clearcoatMap: HAS_CLEARCOATMAP, + clearcoatNormalMap: HAS_CLEARCOAT_NORMALMAP, + clearcoatRoughnessMap: HAS_CLEARCOAT_ROUGHNESSMAP, + iridescence: HAS_IRIDESCENCE, + iridescenceMap: HAS_IRIDESCENCEMAP, + iridescenceThicknessMap: HAS_IRIDESCENCE_THICKNESSMAP, + sheen: HAS_SHEEN, + sheenColorMap: HAS_SHEEN_COLORMAP, + sheenRoughnessMap: HAS_SHEEN_ROUGHNESSMAP, + specularMap: HAS_SPECULARMAP, + specularColorMap: HAS_SPECULAR_COLORMAP, + specularIntensityMap: HAS_SPECULAR_INTENSITYMAP, + transmission: HAS_TRANSMISSION, + transmissionMap: HAS_TRANSMISSIONMAP, + thicknessMap: HAS_THICKNESSMAP, + gradientMap: HAS_GRADIENTMAP, + opaque: material.transparent === false && material.blending === NormalBlending && material.alphaToCoverage === false, + alphaMap: HAS_ALPHAMAP, + alphaTest: HAS_ALPHATEST, + alphaHash: HAS_ALPHAHASH, + combine: material.combine, + // + mapUv: HAS_MAP && getChannel(material.map.channel), + aoMapUv: HAS_AOMAP && getChannel(material.aoMap.channel), + lightMapUv: HAS_LIGHTMAP && getChannel(material.lightMap.channel), + bumpMapUv: HAS_BUMPMAP && getChannel(material.bumpMap.channel), + normalMapUv: HAS_NORMALMAP && getChannel(material.normalMap.channel), + displacementMapUv: HAS_DISPLACEMENTMAP && getChannel(material.displacementMap.channel), + emissiveMapUv: HAS_EMISSIVEMAP && getChannel(material.emissiveMap.channel), + metalnessMapUv: HAS_METALNESSMAP && getChannel(material.metalnessMap.channel), + roughnessMapUv: HAS_ROUGHNESSMAP && getChannel(material.roughnessMap.channel), + anisotropyMapUv: HAS_ANISOTROPYMAP && getChannel(material.anisotropyMap.channel), + clearcoatMapUv: HAS_CLEARCOATMAP && getChannel(material.clearcoatMap.channel), + clearcoatNormalMapUv: HAS_CLEARCOAT_NORMALMAP && getChannel(material.clearcoatNormalMap.channel), + clearcoatRoughnessMapUv: HAS_CLEARCOAT_ROUGHNESSMAP && getChannel(material.clearcoatRoughnessMap.channel), + iridescenceMapUv: HAS_IRIDESCENCEMAP && getChannel(material.iridescenceMap.channel), + iridescenceThicknessMapUv: HAS_IRIDESCENCE_THICKNESSMAP && getChannel(material.iridescenceThicknessMap.channel), + sheenColorMapUv: HAS_SHEEN_COLORMAP && getChannel(material.sheenColorMap.channel), + sheenRoughnessMapUv: HAS_SHEEN_ROUGHNESSMAP && getChannel(material.sheenRoughnessMap.channel), + specularMapUv: HAS_SPECULARMAP && getChannel(material.specularMap.channel), + specularColorMapUv: HAS_SPECULAR_COLORMAP && getChannel(material.specularColorMap.channel), + specularIntensityMapUv: HAS_SPECULAR_INTENSITYMAP && getChannel(material.specularIntensityMap.channel), + transmissionMapUv: HAS_TRANSMISSIONMAP && getChannel(material.transmissionMap.channel), + thicknessMapUv: HAS_THICKNESSMAP && getChannel(material.thicknessMap.channel), + alphaMapUv: HAS_ALPHAMAP && getChannel(material.alphaMap.channel), + // + vertexTangents: !!geometry.attributes.tangent && (HAS_NORMALMAP || HAS_ANISOTROPY), + vertexColors: material.vertexColors, + vertexAlphas: material.vertexColors === true && !!geometry.attributes.color && geometry.attributes.color.itemSize === 4, + pointsUvs: object.isPoints === true && !!geometry.attributes.uv && (HAS_MAP || HAS_ALPHAMAP), + fog: !!fog, + useFog: material.fog === true, + fogExp2: !!fog && fog.isFogExp2, + flatShading: material.flatShading === true, + sizeAttenuation: material.sizeAttenuation === true, + logarithmicDepthBuffer, + skinning: object.isSkinnedMesh === true, + morphTargets: geometry.morphAttributes.position !== void 0, + morphNormals: geometry.morphAttributes.normal !== void 0, + morphColors: geometry.morphAttributes.color !== void 0, + morphTargetsCount, + morphTextureStride, + numDirLights: lights.directional.length, + numPointLights: lights.point.length, + numSpotLights: lights.spot.length, + numSpotLightMaps: lights.spotLightMap.length, + numRectAreaLights: lights.rectArea.length, + numHemiLights: lights.hemi.length, + numDirLightShadows: lights.directionalShadowMap.length, + numPointLightShadows: lights.pointShadowMap.length, + numSpotLightShadows: lights.spotShadowMap.length, + numSpotLightShadowsWithMaps: lights.numSpotLightShadowsWithMaps, + numLightProbes: lights.numLightProbes, + numClippingPlanes: clipping.numPlanes, + numClipIntersection: clipping.numIntersection, + dithering: material.dithering, + shadowMapEnabled: renderer.shadowMap.enabled && shadows.length > 0, + shadowMapType: renderer.shadowMap.type, + toneMapping, + useLegacyLights: renderer._useLegacyLights, + decodeVideoTexture: HAS_MAP && material.map.isVideoTexture === true && ColorManagement.getTransfer(material.map.colorSpace) === SRGBTransfer, + premultipliedAlpha: material.premultipliedAlpha, + doubleSided: material.side === DoubleSide, + flipSided: material.side === BackSide, + useDepthPacking: material.depthPacking >= 0, + depthPacking: material.depthPacking || 0, + index0AttributeName: material.index0AttributeName, + extensionClipCullDistance: HAS_EXTENSIONS && material.extensions.clipCullDistance === true && extensions.has("WEBGL_clip_cull_distance"), + extensionMultiDraw: HAS_EXTENSIONS && material.extensions.multiDraw === true && extensions.has("WEBGL_multi_draw"), + rendererExtensionParallelShaderCompile: extensions.has("KHR_parallel_shader_compile"), + customProgramCacheKey: material.customProgramCacheKey() + }; + parameters.vertexUv1s = _activeChannels.has(1); + parameters.vertexUv2s = _activeChannels.has(2); + parameters.vertexUv3s = _activeChannels.has(3); + _activeChannels.clear(); + return parameters; + } + function getProgramCacheKey(parameters) { + const array = []; + if (parameters.shaderID) { + array.push(parameters.shaderID); + } else { + array.push(parameters.customVertexShaderID); + array.push(parameters.customFragmentShaderID); + } + if (parameters.defines !== void 0) { + for (const name in parameters.defines) { + array.push(name); + array.push(parameters.defines[name]); + } + } + if (parameters.isRawShaderMaterial === false) { + getProgramCacheKeyParameters(array, parameters); + getProgramCacheKeyBooleans(array, parameters); + array.push(renderer.outputColorSpace); + } + array.push(parameters.customProgramCacheKey); + return array.join(); + } + function getProgramCacheKeyParameters(array, parameters) { + array.push(parameters.precision); + array.push(parameters.outputColorSpace); + array.push(parameters.envMapMode); + array.push(parameters.envMapCubeUVHeight); + array.push(parameters.mapUv); + array.push(parameters.alphaMapUv); + array.push(parameters.lightMapUv); + array.push(parameters.aoMapUv); + array.push(parameters.bumpMapUv); + array.push(parameters.normalMapUv); + array.push(parameters.displacementMapUv); + array.push(parameters.emissiveMapUv); + array.push(parameters.metalnessMapUv); + array.push(parameters.roughnessMapUv); + array.push(parameters.anisotropyMapUv); + array.push(parameters.clearcoatMapUv); + array.push(parameters.clearcoatNormalMapUv); + array.push(parameters.clearcoatRoughnessMapUv); + array.push(parameters.iridescenceMapUv); + array.push(parameters.iridescenceThicknessMapUv); + array.push(parameters.sheenColorMapUv); + array.push(parameters.sheenRoughnessMapUv); + array.push(parameters.specularMapUv); + array.push(parameters.specularColorMapUv); + array.push(parameters.specularIntensityMapUv); + array.push(parameters.transmissionMapUv); + array.push(parameters.thicknessMapUv); + array.push(parameters.combine); + array.push(parameters.fogExp2); + array.push(parameters.sizeAttenuation); + array.push(parameters.morphTargetsCount); + array.push(parameters.morphAttributeCount); + array.push(parameters.numDirLights); + array.push(parameters.numPointLights); + array.push(parameters.numSpotLights); + array.push(parameters.numSpotLightMaps); + array.push(parameters.numHemiLights); + array.push(parameters.numRectAreaLights); + array.push(parameters.numDirLightShadows); + array.push(parameters.numPointLightShadows); + array.push(parameters.numSpotLightShadows); + array.push(parameters.numSpotLightShadowsWithMaps); + array.push(parameters.numLightProbes); + array.push(parameters.shadowMapType); + array.push(parameters.toneMapping); + array.push(parameters.numClippingPlanes); + array.push(parameters.numClipIntersection); + array.push(parameters.depthPacking); + } + function getProgramCacheKeyBooleans(array, parameters) { + _programLayers.disableAll(); + if (parameters.supportsVertexTextures) + _programLayers.enable(0); + if (parameters.instancing) + _programLayers.enable(1); + if (parameters.instancingColor) + _programLayers.enable(2); + if (parameters.instancingMorph) + _programLayers.enable(3); + if (parameters.matcap) + _programLayers.enable(4); + if (parameters.envMap) + _programLayers.enable(5); + if (parameters.normalMapObjectSpace) + _programLayers.enable(6); + if (parameters.normalMapTangentSpace) + _programLayers.enable(7); + if (parameters.clearcoat) + _programLayers.enable(8); + if (parameters.iridescence) + _programLayers.enable(9); + if (parameters.alphaTest) + _programLayers.enable(10); + if (parameters.vertexColors) + _programLayers.enable(11); + if (parameters.vertexAlphas) + _programLayers.enable(12); + if (parameters.vertexUv1s) + _programLayers.enable(13); + if (parameters.vertexUv2s) + _programLayers.enable(14); + if (parameters.vertexUv3s) + _programLayers.enable(15); + if (parameters.vertexTangents) + _programLayers.enable(16); + if (parameters.anisotropy) + _programLayers.enable(17); + if (parameters.alphaHash) + _programLayers.enable(18); + if (parameters.batching) + _programLayers.enable(19); + array.push(_programLayers.mask); + _programLayers.disableAll(); + if (parameters.fog) + _programLayers.enable(0); + if (parameters.useFog) + _programLayers.enable(1); + if (parameters.flatShading) + _programLayers.enable(2); + if (parameters.logarithmicDepthBuffer) + _programLayers.enable(3); + if (parameters.skinning) + _programLayers.enable(4); + if (parameters.morphTargets) + _programLayers.enable(5); + if (parameters.morphNormals) + _programLayers.enable(6); + if (parameters.morphColors) + _programLayers.enable(7); + if (parameters.premultipliedAlpha) + _programLayers.enable(8); + if (parameters.shadowMapEnabled) + _programLayers.enable(9); + if (parameters.useLegacyLights) + _programLayers.enable(10); + if (parameters.doubleSided) + _programLayers.enable(11); + if (parameters.flipSided) + _programLayers.enable(12); + if (parameters.useDepthPacking) + _programLayers.enable(13); + if (parameters.dithering) + _programLayers.enable(14); + if (parameters.transmission) + _programLayers.enable(15); + if (parameters.sheen) + _programLayers.enable(16); + if (parameters.opaque) + _programLayers.enable(17); + if (parameters.pointsUvs) + _programLayers.enable(18); + if (parameters.decodeVideoTexture) + _programLayers.enable(19); + if (parameters.alphaToCoverage) + _programLayers.enable(20); + array.push(_programLayers.mask); + } + function getUniforms(material) { + const shaderID = shaderIDs[material.type]; + let uniforms; + if (shaderID) { + const shader = ShaderLib[shaderID]; + uniforms = UniformsUtils.clone(shader.uniforms); + } else { + uniforms = material.uniforms; + } + return uniforms; + } + function acquireProgram(parameters, cacheKey) { + let program; + for (let p = 0, pl = programs.length; p < pl; p++) { + const preexistingProgram = programs[p]; + if (preexistingProgram.cacheKey === cacheKey) { + program = preexistingProgram; + ++program.usedTimes; + break; + } + } + if (program === void 0) { + program = new WebGLProgram(renderer, cacheKey, parameters, bindingStates); + programs.push(program); + } + return program; + } + function releaseProgram(program) { + if (--program.usedTimes === 0) { + const i = programs.indexOf(program); + programs[i] = programs[programs.length - 1]; + programs.pop(); + program.destroy(); + } + } + function releaseShaderCache(material) { + _customShaders.remove(material); + } + function dispose() { + _customShaders.dispose(); + } + return { + getParameters, + getProgramCacheKey, + getUniforms, + acquireProgram, + releaseProgram, + releaseShaderCache, + // Exposed for resource monitoring & error feedback via renderer.info: + programs, + dispose + }; +} +function WebGLProperties() { + let properties = /* @__PURE__ */ new WeakMap(); + function get(object) { + let map = properties.get(object); + if (map === void 0) { + map = {}; + properties.set(object, map); + } + return map; + } + function remove(object) { + properties.delete(object); + } + function update(object, key, value) { + properties.get(object)[key] = value; + } + function dispose() { + properties = /* @__PURE__ */ new WeakMap(); + } + return { + get, + remove, + update, + dispose + }; +} +function painterSortStable(a, b) { + if (a.groupOrder !== b.groupOrder) { + return a.groupOrder - b.groupOrder; + } else if (a.renderOrder !== b.renderOrder) { + return a.renderOrder - b.renderOrder; + } else if (a.material.id !== b.material.id) { + return a.material.id - b.material.id; + } else if (a.z !== b.z) { + return a.z - b.z; + } else { + return a.id - b.id; + } +} +function reversePainterSortStable(a, b) { + if (a.groupOrder !== b.groupOrder) { + return a.groupOrder - b.groupOrder; + } else if (a.renderOrder !== b.renderOrder) { + return a.renderOrder - b.renderOrder; + } else if (a.z !== b.z) { + return b.z - a.z; + } else { + return a.id - b.id; + } +} +function WebGLRenderList() { + const renderItems = []; + let renderItemsIndex = 0; + const opaque = []; + const transmissive = []; + const transparent = []; + function init() { + renderItemsIndex = 0; + opaque.length = 0; + transmissive.length = 0; + transparent.length = 0; + } + function getNextRenderItem(object, geometry, material, groupOrder, z, group) { + let renderItem = renderItems[renderItemsIndex]; + if (renderItem === void 0) { + renderItem = { + id: object.id, + object, + geometry, + material, + groupOrder, + renderOrder: object.renderOrder, + z, + group + }; + renderItems[renderItemsIndex] = renderItem; + } else { + renderItem.id = object.id; + renderItem.object = object; + renderItem.geometry = geometry; + renderItem.material = material; + renderItem.groupOrder = groupOrder; + renderItem.renderOrder = object.renderOrder; + renderItem.z = z; + renderItem.group = group; + } + renderItemsIndex++; + return renderItem; + } + function push(object, geometry, material, groupOrder, z, group) { + const renderItem = getNextRenderItem(object, geometry, material, groupOrder, z, group); + if (material.transmission > 0) { + transmissive.push(renderItem); + } else if (material.transparent === true) { + transparent.push(renderItem); + } else { + opaque.push(renderItem); + } + } + function unshift(object, geometry, material, groupOrder, z, group) { + const renderItem = getNextRenderItem(object, geometry, material, groupOrder, z, group); + if (material.transmission > 0) { + transmissive.unshift(renderItem); + } else if (material.transparent === true) { + transparent.unshift(renderItem); + } else { + opaque.unshift(renderItem); + } + } + function sort(customOpaqueSort, customTransparentSort) { + if (opaque.length > 1) opaque.sort(customOpaqueSort || painterSortStable); + if (transmissive.length > 1) transmissive.sort(customTransparentSort || reversePainterSortStable); + if (transparent.length > 1) transparent.sort(customTransparentSort || reversePainterSortStable); + } + function finish() { + for (let i = renderItemsIndex, il = renderItems.length; i < il; i++) { + const renderItem = renderItems[i]; + if (renderItem.id === null) break; + renderItem.id = null; + renderItem.object = null; + renderItem.geometry = null; + renderItem.material = null; + renderItem.group = null; + } + } + return { + opaque, + transmissive, + transparent, + init, + push, + unshift, + finish, + sort + }; +} +function WebGLRenderLists() { + let lists = /* @__PURE__ */ new WeakMap(); + function get(scene, renderCallDepth) { + const listArray = lists.get(scene); + let list; + if (listArray === void 0) { + list = new WebGLRenderList(); + lists.set(scene, [list]); + } else { + if (renderCallDepth >= listArray.length) { + list = new WebGLRenderList(); + listArray.push(list); + } else { + list = listArray[renderCallDepth]; + } + } + return list; + } + function dispose() { + lists = /* @__PURE__ */ new WeakMap(); + } + return { + get, + dispose + }; +} +function UniformsCache() { + const lights = {}; + return { + get: function(light) { + if (lights[light.id] !== void 0) { + return lights[light.id]; + } + let uniforms; + switch (light.type) { + case "DirectionalLight": + uniforms = { + direction: new Vector3(), + color: new Color() + }; + break; + case "SpotLight": + uniforms = { + position: new Vector3(), + direction: new Vector3(), + color: new Color(), + distance: 0, + coneCos: 0, + penumbraCos: 0, + decay: 0 + }; + break; + case "PointLight": + uniforms = { + position: new Vector3(), + color: new Color(), + distance: 0, + decay: 0 + }; + break; + case "HemisphereLight": + uniforms = { + direction: new Vector3(), + skyColor: new Color(), + groundColor: new Color() + }; + break; + case "RectAreaLight": + uniforms = { + color: new Color(), + position: new Vector3(), + halfWidth: new Vector3(), + halfHeight: new Vector3() + }; + break; + } + lights[light.id] = uniforms; + return uniforms; + } + }; +} +function ShadowUniformsCache() { + const lights = {}; + return { + get: function(light) { + if (lights[light.id] !== void 0) { + return lights[light.id]; + } + let uniforms; + switch (light.type) { + case "DirectionalLight": + uniforms = { + shadowBias: 0, + shadowNormalBias: 0, + shadowRadius: 1, + shadowMapSize: new Vector2() + }; + break; + case "SpotLight": + uniforms = { + shadowBias: 0, + shadowNormalBias: 0, + shadowRadius: 1, + shadowMapSize: new Vector2() + }; + break; + case "PointLight": + uniforms = { + shadowBias: 0, + shadowNormalBias: 0, + shadowRadius: 1, + shadowMapSize: new Vector2(), + shadowCameraNear: 1, + shadowCameraFar: 1e3 + }; + break; + } + lights[light.id] = uniforms; + return uniforms; + } + }; +} +var nextVersion = 0; +function shadowCastingAndTexturingLightsFirst(lightA, lightB) { + return (lightB.castShadow ? 2 : 0) - (lightA.castShadow ? 2 : 0) + (lightB.map ? 1 : 0) - (lightA.map ? 1 : 0); +} +function WebGLLights(extensions) { + const cache = new UniformsCache(); + const shadowCache = ShadowUniformsCache(); + const state = { + version: 0, + hash: { + directionalLength: -1, + pointLength: -1, + spotLength: -1, + rectAreaLength: -1, + hemiLength: -1, + numDirectionalShadows: -1, + numPointShadows: -1, + numSpotShadows: -1, + numSpotMaps: -1, + numLightProbes: -1 + }, + ambient: [0, 0, 0], + probe: [], + directional: [], + directionalShadow: [], + directionalShadowMap: [], + directionalShadowMatrix: [], + spot: [], + spotLightMap: [], + spotShadow: [], + spotShadowMap: [], + spotLightMatrix: [], + rectArea: [], + rectAreaLTC1: null, + rectAreaLTC2: null, + point: [], + pointShadow: [], + pointShadowMap: [], + pointShadowMatrix: [], + hemi: [], + numSpotLightShadowsWithMaps: 0, + numLightProbes: 0 + }; + for (let i = 0; i < 9; i++) state.probe.push(new Vector3()); + const vector3 = new Vector3(); + const matrix4 = new Matrix4(); + const matrix42 = new Matrix4(); + function setup(lights, useLegacyLights) { + let r = 0, g = 0, b = 0; + for (let i = 0; i < 9; i++) state.probe[i].set(0, 0, 0); + let directionalLength = 0; + let pointLength = 0; + let spotLength = 0; + let rectAreaLength = 0; + let hemiLength = 0; + let numDirectionalShadows = 0; + let numPointShadows = 0; + let numSpotShadows = 0; + let numSpotMaps = 0; + let numSpotShadowsWithMaps = 0; + let numLightProbes = 0; + lights.sort(shadowCastingAndTexturingLightsFirst); + const scaleFactor = useLegacyLights === true ? Math.PI : 1; + for (let i = 0, l = lights.length; i < l; i++) { + const light = lights[i]; + const color = light.color; + const intensity = light.intensity; + const distance = light.distance; + const shadowMap = light.shadow && light.shadow.map ? light.shadow.map.texture : null; + if (light.isAmbientLight) { + r += color.r * intensity * scaleFactor; + g += color.g * intensity * scaleFactor; + b += color.b * intensity * scaleFactor; + } else if (light.isLightProbe) { + for (let j = 0; j < 9; j++) { + state.probe[j].addScaledVector(light.sh.coefficients[j], intensity); + } + numLightProbes++; + } else if (light.isDirectionalLight) { + const uniforms = cache.get(light); + uniforms.color.copy(light.color).multiplyScalar(light.intensity * scaleFactor); + if (light.castShadow) { + const shadow = light.shadow; + const shadowUniforms = shadowCache.get(light); + shadowUniforms.shadowBias = shadow.bias; + shadowUniforms.shadowNormalBias = shadow.normalBias; + shadowUniforms.shadowRadius = shadow.radius; + shadowUniforms.shadowMapSize = shadow.mapSize; + state.directionalShadow[directionalLength] = shadowUniforms; + state.directionalShadowMap[directionalLength] = shadowMap; + state.directionalShadowMatrix[directionalLength] = light.shadow.matrix; + numDirectionalShadows++; + } + state.directional[directionalLength] = uniforms; + directionalLength++; + } else if (light.isSpotLight) { + const uniforms = cache.get(light); + uniforms.position.setFromMatrixPosition(light.matrixWorld); + uniforms.color.copy(color).multiplyScalar(intensity * scaleFactor); + uniforms.distance = distance; + uniforms.coneCos = Math.cos(light.angle); + uniforms.penumbraCos = Math.cos(light.angle * (1 - light.penumbra)); + uniforms.decay = light.decay; + state.spot[spotLength] = uniforms; + const shadow = light.shadow; + if (light.map) { + state.spotLightMap[numSpotMaps] = light.map; + numSpotMaps++; + shadow.updateMatrices(light); + if (light.castShadow) numSpotShadowsWithMaps++; + } + state.spotLightMatrix[spotLength] = shadow.matrix; + if (light.castShadow) { + const shadowUniforms = shadowCache.get(light); + shadowUniforms.shadowBias = shadow.bias; + shadowUniforms.shadowNormalBias = shadow.normalBias; + shadowUniforms.shadowRadius = shadow.radius; + shadowUniforms.shadowMapSize = shadow.mapSize; + state.spotShadow[spotLength] = shadowUniforms; + state.spotShadowMap[spotLength] = shadowMap; + numSpotShadows++; + } + spotLength++; + } else if (light.isRectAreaLight) { + const uniforms = cache.get(light); + uniforms.color.copy(color).multiplyScalar(intensity); + uniforms.halfWidth.set(light.width * 0.5, 0, 0); + uniforms.halfHeight.set(0, light.height * 0.5, 0); + state.rectArea[rectAreaLength] = uniforms; + rectAreaLength++; + } else if (light.isPointLight) { + const uniforms = cache.get(light); + uniforms.color.copy(light.color).multiplyScalar(light.intensity * scaleFactor); + uniforms.distance = light.distance; + uniforms.decay = light.decay; + if (light.castShadow) { + const shadow = light.shadow; + const shadowUniforms = shadowCache.get(light); + shadowUniforms.shadowBias = shadow.bias; + shadowUniforms.shadowNormalBias = shadow.normalBias; + shadowUniforms.shadowRadius = shadow.radius; + shadowUniforms.shadowMapSize = shadow.mapSize; + shadowUniforms.shadowCameraNear = shadow.camera.near; + shadowUniforms.shadowCameraFar = shadow.camera.far; + state.pointShadow[pointLength] = shadowUniforms; + state.pointShadowMap[pointLength] = shadowMap; + state.pointShadowMatrix[pointLength] = light.shadow.matrix; + numPointShadows++; + } + state.point[pointLength] = uniforms; + pointLength++; + } else if (light.isHemisphereLight) { + const uniforms = cache.get(light); + uniforms.skyColor.copy(light.color).multiplyScalar(intensity * scaleFactor); + uniforms.groundColor.copy(light.groundColor).multiplyScalar(intensity * scaleFactor); + state.hemi[hemiLength] = uniforms; + hemiLength++; + } + } + if (rectAreaLength > 0) { + if (extensions.has("OES_texture_float_linear") === true) { + state.rectAreaLTC1 = UniformsLib.LTC_FLOAT_1; + state.rectAreaLTC2 = UniformsLib.LTC_FLOAT_2; + } else { + state.rectAreaLTC1 = UniformsLib.LTC_HALF_1; + state.rectAreaLTC2 = UniformsLib.LTC_HALF_2; + } + } + state.ambient[0] = r; + state.ambient[1] = g; + state.ambient[2] = b; + const hash = state.hash; + if (hash.directionalLength !== directionalLength || hash.pointLength !== pointLength || hash.spotLength !== spotLength || hash.rectAreaLength !== rectAreaLength || hash.hemiLength !== hemiLength || hash.numDirectionalShadows !== numDirectionalShadows || hash.numPointShadows !== numPointShadows || hash.numSpotShadows !== numSpotShadows || hash.numSpotMaps !== numSpotMaps || hash.numLightProbes !== numLightProbes) { + state.directional.length = directionalLength; + state.spot.length = spotLength; + state.rectArea.length = rectAreaLength; + state.point.length = pointLength; + state.hemi.length = hemiLength; + state.directionalShadow.length = numDirectionalShadows; + state.directionalShadowMap.length = numDirectionalShadows; + state.pointShadow.length = numPointShadows; + state.pointShadowMap.length = numPointShadows; + state.spotShadow.length = numSpotShadows; + state.spotShadowMap.length = numSpotShadows; + state.directionalShadowMatrix.length = numDirectionalShadows; + state.pointShadowMatrix.length = numPointShadows; + state.spotLightMatrix.length = numSpotShadows + numSpotMaps - numSpotShadowsWithMaps; + state.spotLightMap.length = numSpotMaps; + state.numSpotLightShadowsWithMaps = numSpotShadowsWithMaps; + state.numLightProbes = numLightProbes; + hash.directionalLength = directionalLength; + hash.pointLength = pointLength; + hash.spotLength = spotLength; + hash.rectAreaLength = rectAreaLength; + hash.hemiLength = hemiLength; + hash.numDirectionalShadows = numDirectionalShadows; + hash.numPointShadows = numPointShadows; + hash.numSpotShadows = numSpotShadows; + hash.numSpotMaps = numSpotMaps; + hash.numLightProbes = numLightProbes; + state.version = nextVersion++; + } + } + function setupView(lights, camera) { + let directionalLength = 0; + let pointLength = 0; + let spotLength = 0; + let rectAreaLength = 0; + let hemiLength = 0; + const viewMatrix = camera.matrixWorldInverse; + for (let i = 0, l = lights.length; i < l; i++) { + const light = lights[i]; + if (light.isDirectionalLight) { + const uniforms = state.directional[directionalLength]; + uniforms.direction.setFromMatrixPosition(light.matrixWorld); + vector3.setFromMatrixPosition(light.target.matrixWorld); + uniforms.direction.sub(vector3); + uniforms.direction.transformDirection(viewMatrix); + directionalLength++; + } else if (light.isSpotLight) { + const uniforms = state.spot[spotLength]; + uniforms.position.setFromMatrixPosition(light.matrixWorld); + uniforms.position.applyMatrix4(viewMatrix); + uniforms.direction.setFromMatrixPosition(light.matrixWorld); + vector3.setFromMatrixPosition(light.target.matrixWorld); + uniforms.direction.sub(vector3); + uniforms.direction.transformDirection(viewMatrix); + spotLength++; + } else if (light.isRectAreaLight) { + const uniforms = state.rectArea[rectAreaLength]; + uniforms.position.setFromMatrixPosition(light.matrixWorld); + uniforms.position.applyMatrix4(viewMatrix); + matrix42.identity(); + matrix4.copy(light.matrixWorld); + matrix4.premultiply(viewMatrix); + matrix42.extractRotation(matrix4); + uniforms.halfWidth.set(light.width * 0.5, 0, 0); + uniforms.halfHeight.set(0, light.height * 0.5, 0); + uniforms.halfWidth.applyMatrix4(matrix42); + uniforms.halfHeight.applyMatrix4(matrix42); + rectAreaLength++; + } else if (light.isPointLight) { + const uniforms = state.point[pointLength]; + uniforms.position.setFromMatrixPosition(light.matrixWorld); + uniforms.position.applyMatrix4(viewMatrix); + pointLength++; + } else if (light.isHemisphereLight) { + const uniforms = state.hemi[hemiLength]; + uniforms.direction.setFromMatrixPosition(light.matrixWorld); + uniforms.direction.transformDirection(viewMatrix); + hemiLength++; + } + } + } + return { + setup, + setupView, + state + }; +} +function WebGLRenderState(extensions) { + const lights = new WebGLLights(extensions); + const lightsArray = []; + const shadowsArray = []; + function init() { + lightsArray.length = 0; + shadowsArray.length = 0; + } + function pushLight(light) { + lightsArray.push(light); + } + function pushShadow(shadowLight) { + shadowsArray.push(shadowLight); + } + function setupLights(useLegacyLights) { + lights.setup(lightsArray, useLegacyLights); + } + function setupLightsView(camera) { + lights.setupView(lightsArray, camera); + } + const state = { + lightsArray, + shadowsArray, + lights, + transmissionRenderTarget: null + }; + return { + init, + state, + setupLights, + setupLightsView, + pushLight, + pushShadow + }; +} +function WebGLRenderStates(extensions) { + let renderStates = /* @__PURE__ */ new WeakMap(); + function get(scene, renderCallDepth = 0) { + const renderStateArray = renderStates.get(scene); + let renderState; + if (renderStateArray === void 0) { + renderState = new WebGLRenderState(extensions); + renderStates.set(scene, [renderState]); + } else { + if (renderCallDepth >= renderStateArray.length) { + renderState = new WebGLRenderState(extensions); + renderStateArray.push(renderState); + } else { + renderState = renderStateArray[renderCallDepth]; + } + } + return renderState; + } + function dispose() { + renderStates = /* @__PURE__ */ new WeakMap(); + } + return { + get, + dispose + }; +} +var MeshDepthMaterial = class extends Material { + constructor(parameters) { + super(); + this.isMeshDepthMaterial = true; + this.type = "MeshDepthMaterial"; + this.depthPacking = BasicDepthPacking; + this.map = null; + this.alphaMap = null; + this.displacementMap = null; + this.displacementScale = 1; + this.displacementBias = 0; + this.wireframe = false; + this.wireframeLinewidth = 1; + this.setValues(parameters); + } + copy(source) { + super.copy(source); + this.depthPacking = source.depthPacking; + this.map = source.map; + this.alphaMap = source.alphaMap; + this.displacementMap = source.displacementMap; + this.displacementScale = source.displacementScale; + this.displacementBias = source.displacementBias; + this.wireframe = source.wireframe; + this.wireframeLinewidth = source.wireframeLinewidth; + return this; + } +}; +var MeshDistanceMaterial = class extends Material { + constructor(parameters) { + super(); + this.isMeshDistanceMaterial = true; + this.type = "MeshDistanceMaterial"; + this.map = null; + this.alphaMap = null; + this.displacementMap = null; + this.displacementScale = 1; + this.displacementBias = 0; + this.setValues(parameters); + } + copy(source) { + super.copy(source); + this.map = source.map; + this.alphaMap = source.alphaMap; + this.displacementMap = source.displacementMap; + this.displacementScale = source.displacementScale; + this.displacementBias = source.displacementBias; + return this; + } +}; +var vertex = "void main() {\n gl_Position = vec4( position, 1.0 );\n}"; +var fragment = "uniform sampler2D shadow_pass;\nuniform vec2 resolution;\nuniform float radius;\n#include \nvoid main() {\n const float samples = float( VSM_SAMPLES );\n float mean = 0.0;\n float squared_mean = 0.0;\n float uvStride = samples <= 1.0 ? 0.0 : 2.0 / ( samples - 1.0 );\n float uvStart = samples <= 1.0 ? 0.0 : - 1.0;\n for ( float i = 0.0; i < samples; i ++ ) {\n float uvOffset = uvStart + i * uvStride;\n #ifdef HORIZONTAL_PASS\n vec2 distribution = unpackRGBATo2Half( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( uvOffset, 0.0 ) * radius ) / resolution ) );\n mean += distribution.x;\n squared_mean += distribution.y * distribution.y + distribution.x * distribution.x;\n #else\n float depth = unpackRGBAToDepth( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( 0.0, uvOffset ) * radius ) / resolution ) );\n mean += depth;\n squared_mean += depth * depth;\n #endif\n }\n mean = mean / samples;\n squared_mean = squared_mean / samples;\n float std_dev = sqrt( squared_mean - mean * mean );\n gl_FragColor = pack2HalfToRGBA( vec2( mean, std_dev ) );\n}"; +function WebGLShadowMap(_renderer, _objects, _capabilities) { + let _frustum = new Frustum(); + const _shadowMapSize = new Vector2(), _viewportSize = new Vector2(), _viewport = new Vector4(), _depthMaterial = new MeshDepthMaterial({ depthPacking: RGBADepthPacking }), _distanceMaterial = new MeshDistanceMaterial(), _materialCache = {}, _maxTextureSize = _capabilities.maxTextureSize; + const shadowSide = { [FrontSide]: BackSide, [BackSide]: FrontSide, [DoubleSide]: DoubleSide }; + const shadowMaterialVertical = new ShaderMaterial({ + defines: { + VSM_SAMPLES: 8 + }, + uniforms: { + shadow_pass: { value: null }, + resolution: { value: new Vector2() }, + radius: { value: 4 } + }, + vertexShader: vertex, + fragmentShader: fragment + }); + const shadowMaterialHorizontal = shadowMaterialVertical.clone(); + shadowMaterialHorizontal.defines.HORIZONTAL_PASS = 1; + const fullScreenTri = new BufferGeometry(); + fullScreenTri.setAttribute( + "position", + new BufferAttribute( + new Float32Array([-1, -1, 0.5, 3, -1, 0.5, -1, 3, 0.5]), + 3 + ) + ); + const fullScreenMesh = new Mesh(fullScreenTri, shadowMaterialVertical); + const scope = this; + this.enabled = false; + this.autoUpdate = true; + this.needsUpdate = false; + this.type = PCFShadowMap; + let _previousType = this.type; + this.render = function(lights, scene, camera) { + if (scope.enabled === false) return; + if (scope.autoUpdate === false && scope.needsUpdate === false) return; + if (lights.length === 0) return; + const currentRenderTarget = _renderer.getRenderTarget(); + const activeCubeFace = _renderer.getActiveCubeFace(); + const activeMipmapLevel = _renderer.getActiveMipmapLevel(); + const _state = _renderer.state; + _state.setBlending(NoBlending); + _state.buffers.color.setClear(1, 1, 1, 1); + _state.buffers.depth.setTest(true); + _state.setScissorTest(false); + const toVSM = _previousType !== VSMShadowMap && this.type === VSMShadowMap; + const fromVSM = _previousType === VSMShadowMap && this.type !== VSMShadowMap; + for (let i = 0, il = lights.length; i < il; i++) { + const light = lights[i]; + const shadow = light.shadow; + if (shadow === void 0) { + console.warn("THREE.WebGLShadowMap:", light, "has no shadow."); + continue; + } + if (shadow.autoUpdate === false && shadow.needsUpdate === false) continue; + _shadowMapSize.copy(shadow.mapSize); + const shadowFrameExtents = shadow.getFrameExtents(); + _shadowMapSize.multiply(shadowFrameExtents); + _viewportSize.copy(shadow.mapSize); + if (_shadowMapSize.x > _maxTextureSize || _shadowMapSize.y > _maxTextureSize) { + if (_shadowMapSize.x > _maxTextureSize) { + _viewportSize.x = Math.floor(_maxTextureSize / shadowFrameExtents.x); + _shadowMapSize.x = _viewportSize.x * shadowFrameExtents.x; + shadow.mapSize.x = _viewportSize.x; + } + if (_shadowMapSize.y > _maxTextureSize) { + _viewportSize.y = Math.floor(_maxTextureSize / shadowFrameExtents.y); + _shadowMapSize.y = _viewportSize.y * shadowFrameExtents.y; + shadow.mapSize.y = _viewportSize.y; + } + } + if (shadow.map === null || toVSM === true || fromVSM === true) { + const pars = this.type !== VSMShadowMap ? { minFilter: NearestFilter, magFilter: NearestFilter } : {}; + if (shadow.map !== null) { + shadow.map.dispose(); + } + shadow.map = new WebGLRenderTarget(_shadowMapSize.x, _shadowMapSize.y, pars); + shadow.map.texture.name = light.name + ".shadowMap"; + shadow.camera.updateProjectionMatrix(); + } + _renderer.setRenderTarget(shadow.map); + _renderer.clear(); + const viewportCount = shadow.getViewportCount(); + for (let vp = 0; vp < viewportCount; vp++) { + const viewport = shadow.getViewport(vp); + _viewport.set( + _viewportSize.x * viewport.x, + _viewportSize.y * viewport.y, + _viewportSize.x * viewport.z, + _viewportSize.y * viewport.w + ); + _state.viewport(_viewport); + shadow.updateMatrices(light, vp); + _frustum = shadow.getFrustum(); + renderObject(scene, camera, shadow.camera, light, this.type); + } + if (shadow.isPointLightShadow !== true && this.type === VSMShadowMap) { + VSMPass(shadow, camera); + } + shadow.needsUpdate = false; + } + _previousType = this.type; + scope.needsUpdate = false; + _renderer.setRenderTarget(currentRenderTarget, activeCubeFace, activeMipmapLevel); + }; + function VSMPass(shadow, camera) { + const geometry = _objects.update(fullScreenMesh); + if (shadowMaterialVertical.defines.VSM_SAMPLES !== shadow.blurSamples) { + shadowMaterialVertical.defines.VSM_SAMPLES = shadow.blurSamples; + shadowMaterialHorizontal.defines.VSM_SAMPLES = shadow.blurSamples; + shadowMaterialVertical.needsUpdate = true; + shadowMaterialHorizontal.needsUpdate = true; + } + if (shadow.mapPass === null) { + shadow.mapPass = new WebGLRenderTarget(_shadowMapSize.x, _shadowMapSize.y); + } + shadowMaterialVertical.uniforms.shadow_pass.value = shadow.map.texture; + shadowMaterialVertical.uniforms.resolution.value = shadow.mapSize; + shadowMaterialVertical.uniforms.radius.value = shadow.radius; + _renderer.setRenderTarget(shadow.mapPass); + _renderer.clear(); + _renderer.renderBufferDirect(camera, null, geometry, shadowMaterialVertical, fullScreenMesh, null); + shadowMaterialHorizontal.uniforms.shadow_pass.value = shadow.mapPass.texture; + shadowMaterialHorizontal.uniforms.resolution.value = shadow.mapSize; + shadowMaterialHorizontal.uniforms.radius.value = shadow.radius; + _renderer.setRenderTarget(shadow.map); + _renderer.clear(); + _renderer.renderBufferDirect(camera, null, geometry, shadowMaterialHorizontal, fullScreenMesh, null); + } + function getDepthMaterial(object, material, light, type) { + let result = null; + const customMaterial = light.isPointLight === true ? object.customDistanceMaterial : object.customDepthMaterial; + if (customMaterial !== void 0) { + result = customMaterial; + } else { + result = light.isPointLight === true ? _distanceMaterial : _depthMaterial; + if (_renderer.localClippingEnabled && material.clipShadows === true && Array.isArray(material.clippingPlanes) && material.clippingPlanes.length !== 0 || material.displacementMap && material.displacementScale !== 0 || material.alphaMap && material.alphaTest > 0 || material.map && material.alphaTest > 0) { + const keyA = result.uuid, keyB = material.uuid; + let materialsForVariant = _materialCache[keyA]; + if (materialsForVariant === void 0) { + materialsForVariant = {}; + _materialCache[keyA] = materialsForVariant; + } + let cachedMaterial = materialsForVariant[keyB]; + if (cachedMaterial === void 0) { + cachedMaterial = result.clone(); + materialsForVariant[keyB] = cachedMaterial; + material.addEventListener("dispose", onMaterialDispose); + } + result = cachedMaterial; + } + } + result.visible = material.visible; + result.wireframe = material.wireframe; + if (type === VSMShadowMap) { + result.side = material.shadowSide !== null ? material.shadowSide : material.side; + } else { + result.side = material.shadowSide !== null ? material.shadowSide : shadowSide[material.side]; + } + result.alphaMap = material.alphaMap; + result.alphaTest = material.alphaTest; + result.map = material.map; + result.clipShadows = material.clipShadows; + result.clippingPlanes = material.clippingPlanes; + result.clipIntersection = material.clipIntersection; + result.displacementMap = material.displacementMap; + result.displacementScale = material.displacementScale; + result.displacementBias = material.displacementBias; + result.wireframeLinewidth = material.wireframeLinewidth; + result.linewidth = material.linewidth; + if (light.isPointLight === true && result.isMeshDistanceMaterial === true) { + const materialProperties = _renderer.properties.get(result); + materialProperties.light = light; + } + return result; + } + function renderObject(object, camera, shadowCamera, light, type) { + if (object.visible === false) return; + const visible = object.layers.test(camera.layers); + if (visible && (object.isMesh || object.isLine || object.isPoints)) { + if ((object.castShadow || object.receiveShadow && type === VSMShadowMap) && (!object.frustumCulled || _frustum.intersectsObject(object))) { + object.modelViewMatrix.multiplyMatrices(shadowCamera.matrixWorldInverse, object.matrixWorld); + const geometry = _objects.update(object); + const material = object.material; + if (Array.isArray(material)) { + const groups = geometry.groups; + for (let k = 0, kl = groups.length; k < kl; k++) { + const group = groups[k]; + const groupMaterial = material[group.materialIndex]; + if (groupMaterial && groupMaterial.visible) { + const depthMaterial = getDepthMaterial(object, groupMaterial, light, type); + object.onBeforeShadow(_renderer, object, camera, shadowCamera, geometry, depthMaterial, group); + _renderer.renderBufferDirect(shadowCamera, null, geometry, depthMaterial, object, group); + object.onAfterShadow(_renderer, object, camera, shadowCamera, geometry, depthMaterial, group); + } + } + } else if (material.visible) { + const depthMaterial = getDepthMaterial(object, material, light, type); + object.onBeforeShadow(_renderer, object, camera, shadowCamera, geometry, depthMaterial, null); + _renderer.renderBufferDirect(shadowCamera, null, geometry, depthMaterial, object, null); + object.onAfterShadow(_renderer, object, camera, shadowCamera, geometry, depthMaterial, null); + } + } + } + const children = object.children; + for (let i = 0, l = children.length; i < l; i++) { + renderObject(children[i], camera, shadowCamera, light, type); + } + } + function onMaterialDispose(event) { + const material = event.target; + material.removeEventListener("dispose", onMaterialDispose); + for (const id in _materialCache) { + const cache = _materialCache[id]; + const uuid = event.target.uuid; + if (uuid in cache) { + const shadowMaterial = cache[uuid]; + shadowMaterial.dispose(); + delete cache[uuid]; + } + } + } +} +function WebGLState(gl) { + function ColorBuffer() { + let locked = false; + const color = new Vector4(); + let currentColorMask = null; + const currentColorClear = new Vector4(0, 0, 0, 0); + return { + setMask: function(colorMask) { + if (currentColorMask !== colorMask && !locked) { + gl.colorMask(colorMask, colorMask, colorMask, colorMask); + currentColorMask = colorMask; + } + }, + setLocked: function(lock) { + locked = lock; + }, + setClear: function(r, g, b, a, premultipliedAlpha) { + if (premultipliedAlpha === true) { + r *= a; + g *= a; + b *= a; + } + color.set(r, g, b, a); + if (currentColorClear.equals(color) === false) { + gl.clearColor(r, g, b, a); + currentColorClear.copy(color); + } + }, + reset: function() { + locked = false; + currentColorMask = null; + currentColorClear.set(-1, 0, 0, 0); + } + }; + } + function DepthBuffer() { + let locked = false; + let currentDepthMask = null; + let currentDepthFunc = null; + let currentDepthClear = null; + return { + setTest: function(depthTest) { + if (depthTest) { + enable(gl.DEPTH_TEST); + } else { + disable(gl.DEPTH_TEST); + } + }, + setMask: function(depthMask) { + if (currentDepthMask !== depthMask && !locked) { + gl.depthMask(depthMask); + currentDepthMask = depthMask; + } + }, + setFunc: function(depthFunc) { + if (currentDepthFunc !== depthFunc) { + switch (depthFunc) { + case NeverDepth: + gl.depthFunc(gl.NEVER); + break; + case AlwaysDepth: + gl.depthFunc(gl.ALWAYS); + break; + case LessDepth: + gl.depthFunc(gl.LESS); + break; + case LessEqualDepth: + gl.depthFunc(gl.LEQUAL); + break; + case EqualDepth: + gl.depthFunc(gl.EQUAL); + break; + case GreaterEqualDepth: + gl.depthFunc(gl.GEQUAL); + break; + case GreaterDepth: + gl.depthFunc(gl.GREATER); + break; + case NotEqualDepth: + gl.depthFunc(gl.NOTEQUAL); + break; + default: + gl.depthFunc(gl.LEQUAL); + } + currentDepthFunc = depthFunc; + } + }, + setLocked: function(lock) { + locked = lock; + }, + setClear: function(depth) { + if (currentDepthClear !== depth) { + gl.clearDepth(depth); + currentDepthClear = depth; + } + }, + reset: function() { + locked = false; + currentDepthMask = null; + currentDepthFunc = null; + currentDepthClear = null; + } + }; + } + function StencilBuffer() { + let locked = false; + let currentStencilMask = null; + let currentStencilFunc = null; + let currentStencilRef = null; + let currentStencilFuncMask = null; + let currentStencilFail = null; + let currentStencilZFail = null; + let currentStencilZPass = null; + let currentStencilClear = null; + return { + setTest: function(stencilTest) { + if (!locked) { + if (stencilTest) { + enable(gl.STENCIL_TEST); + } else { + disable(gl.STENCIL_TEST); + } + } + }, + setMask: function(stencilMask) { + if (currentStencilMask !== stencilMask && !locked) { + gl.stencilMask(stencilMask); + currentStencilMask = stencilMask; + } + }, + setFunc: function(stencilFunc, stencilRef, stencilMask) { + if (currentStencilFunc !== stencilFunc || currentStencilRef !== stencilRef || currentStencilFuncMask !== stencilMask) { + gl.stencilFunc(stencilFunc, stencilRef, stencilMask); + currentStencilFunc = stencilFunc; + currentStencilRef = stencilRef; + currentStencilFuncMask = stencilMask; + } + }, + setOp: function(stencilFail, stencilZFail, stencilZPass) { + if (currentStencilFail !== stencilFail || currentStencilZFail !== stencilZFail || currentStencilZPass !== stencilZPass) { + gl.stencilOp(stencilFail, stencilZFail, stencilZPass); + currentStencilFail = stencilFail; + currentStencilZFail = stencilZFail; + currentStencilZPass = stencilZPass; + } + }, + setLocked: function(lock) { + locked = lock; + }, + setClear: function(stencil) { + if (currentStencilClear !== stencil) { + gl.clearStencil(stencil); + currentStencilClear = stencil; + } + }, + reset: function() { + locked = false; + currentStencilMask = null; + currentStencilFunc = null; + currentStencilRef = null; + currentStencilFuncMask = null; + currentStencilFail = null; + currentStencilZFail = null; + currentStencilZPass = null; + currentStencilClear = null; + } + }; + } + const colorBuffer = new ColorBuffer(); + const depthBuffer = new DepthBuffer(); + const stencilBuffer = new StencilBuffer(); + const uboBindings = /* @__PURE__ */ new WeakMap(); + const uboProgramMap = /* @__PURE__ */ new WeakMap(); + let enabledCapabilities = {}; + let currentBoundFramebuffers = {}; + let currentDrawbuffers = /* @__PURE__ */ new WeakMap(); + let defaultDrawbuffers = []; + let currentProgram = null; + let currentBlendingEnabled = false; + let currentBlending = null; + let currentBlendEquation = null; + let currentBlendSrc = null; + let currentBlendDst = null; + let currentBlendEquationAlpha = null; + let currentBlendSrcAlpha = null; + let currentBlendDstAlpha = null; + let currentBlendColor = new Color(0, 0, 0); + let currentBlendAlpha = 0; + let currentPremultipledAlpha = false; + let currentFlipSided = null; + let currentCullFace = null; + let currentLineWidth = null; + let currentPolygonOffsetFactor = null; + let currentPolygonOffsetUnits = null; + const maxTextures = gl.getParameter(gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS); + let lineWidthAvailable = false; + let version = 0; + const glVersion = gl.getParameter(gl.VERSION); + if (glVersion.indexOf("WebGL") !== -1) { + version = parseFloat(/^WebGL (\d)/.exec(glVersion)[1]); + lineWidthAvailable = version >= 1; + } else if (glVersion.indexOf("OpenGL ES") !== -1) { + version = parseFloat(/^OpenGL ES (\d)/.exec(glVersion)[1]); + lineWidthAvailable = version >= 2; + } + let currentTextureSlot = null; + let currentBoundTextures = {}; + const scissorParam = gl.getParameter(gl.SCISSOR_BOX); + const viewportParam = gl.getParameter(gl.VIEWPORT); + const currentScissor = new Vector4().fromArray(scissorParam); + const currentViewport = new Vector4().fromArray(viewportParam); + function createTexture(type, target, count, dimensions) { + const data = new Uint8Array(4); + const texture = gl.createTexture(); + gl.bindTexture(type, texture); + gl.texParameteri(type, gl.TEXTURE_MIN_FILTER, gl.NEAREST); + gl.texParameteri(type, gl.TEXTURE_MAG_FILTER, gl.NEAREST); + for (let i = 0; i < count; i++) { + if (type === gl.TEXTURE_3D || type === gl.TEXTURE_2D_ARRAY) { + gl.texImage3D(target, 0, gl.RGBA, 1, 1, dimensions, 0, gl.RGBA, gl.UNSIGNED_BYTE, data); + } else { + gl.texImage2D(target + i, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, data); + } + } + return texture; + } + const emptyTextures = {}; + emptyTextures[gl.TEXTURE_2D] = createTexture(gl.TEXTURE_2D, gl.TEXTURE_2D, 1); + emptyTextures[gl.TEXTURE_CUBE_MAP] = createTexture(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_CUBE_MAP_POSITIVE_X, 6); + emptyTextures[gl.TEXTURE_2D_ARRAY] = createTexture(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_2D_ARRAY, 1, 1); + emptyTextures[gl.TEXTURE_3D] = createTexture(gl.TEXTURE_3D, gl.TEXTURE_3D, 1, 1); + colorBuffer.setClear(0, 0, 0, 1); + depthBuffer.setClear(1); + stencilBuffer.setClear(0); + enable(gl.DEPTH_TEST); + depthBuffer.setFunc(LessEqualDepth); + setFlipSided(false); + setCullFace(CullFaceBack); + enable(gl.CULL_FACE); + setBlending(NoBlending); + function enable(id) { + if (enabledCapabilities[id] !== true) { + gl.enable(id); + enabledCapabilities[id] = true; + } + } + function disable(id) { + if (enabledCapabilities[id] !== false) { + gl.disable(id); + enabledCapabilities[id] = false; + } + } + function bindFramebuffer(target, framebuffer) { + if (currentBoundFramebuffers[target] !== framebuffer) { + gl.bindFramebuffer(target, framebuffer); + currentBoundFramebuffers[target] = framebuffer; + if (target === gl.DRAW_FRAMEBUFFER) { + currentBoundFramebuffers[gl.FRAMEBUFFER] = framebuffer; + } + if (target === gl.FRAMEBUFFER) { + currentBoundFramebuffers[gl.DRAW_FRAMEBUFFER] = framebuffer; + } + return true; + } + return false; + } + function drawBuffers(renderTarget, framebuffer) { + let drawBuffers2 = defaultDrawbuffers; + let needsUpdate = false; + if (renderTarget) { + drawBuffers2 = currentDrawbuffers.get(framebuffer); + if (drawBuffers2 === void 0) { + drawBuffers2 = []; + currentDrawbuffers.set(framebuffer, drawBuffers2); + } + const textures = renderTarget.textures; + if (drawBuffers2.length !== textures.length || drawBuffers2[0] !== gl.COLOR_ATTACHMENT0) { + for (let i = 0, il = textures.length; i < il; i++) { + drawBuffers2[i] = gl.COLOR_ATTACHMENT0 + i; + } + drawBuffers2.length = textures.length; + needsUpdate = true; + } + } else { + if (drawBuffers2[0] !== gl.BACK) { + drawBuffers2[0] = gl.BACK; + needsUpdate = true; + } + } + if (needsUpdate) { + gl.drawBuffers(drawBuffers2); + } + } + function useProgram(program) { + if (currentProgram !== program) { + gl.useProgram(program); + currentProgram = program; + return true; + } + return false; + } + const equationToGL = { + [AddEquation]: gl.FUNC_ADD, + [SubtractEquation]: gl.FUNC_SUBTRACT, + [ReverseSubtractEquation]: gl.FUNC_REVERSE_SUBTRACT + }; + equationToGL[MinEquation] = gl.MIN; + equationToGL[MaxEquation] = gl.MAX; + const factorToGL = { + [ZeroFactor]: gl.ZERO, + [OneFactor]: gl.ONE, + [SrcColorFactor]: gl.SRC_COLOR, + [SrcAlphaFactor]: gl.SRC_ALPHA, + [SrcAlphaSaturateFactor]: gl.SRC_ALPHA_SATURATE, + [DstColorFactor]: gl.DST_COLOR, + [DstAlphaFactor]: gl.DST_ALPHA, + [OneMinusSrcColorFactor]: gl.ONE_MINUS_SRC_COLOR, + [OneMinusSrcAlphaFactor]: gl.ONE_MINUS_SRC_ALPHA, + [OneMinusDstColorFactor]: gl.ONE_MINUS_DST_COLOR, + [OneMinusDstAlphaFactor]: gl.ONE_MINUS_DST_ALPHA, + [ConstantColorFactor]: gl.CONSTANT_COLOR, + [OneMinusConstantColorFactor]: gl.ONE_MINUS_CONSTANT_COLOR, + [ConstantAlphaFactor]: gl.CONSTANT_ALPHA, + [OneMinusConstantAlphaFactor]: gl.ONE_MINUS_CONSTANT_ALPHA + }; + function setBlending(blending, blendEquation, blendSrc, blendDst, blendEquationAlpha, blendSrcAlpha, blendDstAlpha, blendColor, blendAlpha, premultipliedAlpha) { + if (blending === NoBlending) { + if (currentBlendingEnabled === true) { + disable(gl.BLEND); + currentBlendingEnabled = false; + } + return; + } + if (currentBlendingEnabled === false) { + enable(gl.BLEND); + currentBlendingEnabled = true; + } + if (blending !== CustomBlending) { + if (blending !== currentBlending || premultipliedAlpha !== currentPremultipledAlpha) { + if (currentBlendEquation !== AddEquation || currentBlendEquationAlpha !== AddEquation) { + gl.blendEquation(gl.FUNC_ADD); + currentBlendEquation = AddEquation; + currentBlendEquationAlpha = AddEquation; + } + if (premultipliedAlpha) { + switch (blending) { + case NormalBlending: + gl.blendFuncSeparate(gl.ONE, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA); + break; + case AdditiveBlending: + gl.blendFunc(gl.ONE, gl.ONE); + break; + case SubtractiveBlending: + gl.blendFuncSeparate(gl.ZERO, gl.ONE_MINUS_SRC_COLOR, gl.ZERO, gl.ONE); + break; + case MultiplyBlending: + gl.blendFuncSeparate(gl.ZERO, gl.SRC_COLOR, gl.ZERO, gl.SRC_ALPHA); + break; + default: + console.error("THREE.WebGLState: Invalid blending: ", blending); + break; + } + } else { + switch (blending) { + case NormalBlending: + gl.blendFuncSeparate(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA); + break; + case AdditiveBlending: + gl.blendFunc(gl.SRC_ALPHA, gl.ONE); + break; + case SubtractiveBlending: + gl.blendFuncSeparate(gl.ZERO, gl.ONE_MINUS_SRC_COLOR, gl.ZERO, gl.ONE); + break; + case MultiplyBlending: + gl.blendFunc(gl.ZERO, gl.SRC_COLOR); + break; + default: + console.error("THREE.WebGLState: Invalid blending: ", blending); + break; + } + } + currentBlendSrc = null; + currentBlendDst = null; + currentBlendSrcAlpha = null; + currentBlendDstAlpha = null; + currentBlendColor.set(0, 0, 0); + currentBlendAlpha = 0; + currentBlending = blending; + currentPremultipledAlpha = premultipliedAlpha; + } + return; + } + blendEquationAlpha = blendEquationAlpha || blendEquation; + blendSrcAlpha = blendSrcAlpha || blendSrc; + blendDstAlpha = blendDstAlpha || blendDst; + if (blendEquation !== currentBlendEquation || blendEquationAlpha !== currentBlendEquationAlpha) { + gl.blendEquationSeparate(equationToGL[blendEquation], equationToGL[blendEquationAlpha]); + currentBlendEquation = blendEquation; + currentBlendEquationAlpha = blendEquationAlpha; + } + if (blendSrc !== currentBlendSrc || blendDst !== currentBlendDst || blendSrcAlpha !== currentBlendSrcAlpha || blendDstAlpha !== currentBlendDstAlpha) { + gl.blendFuncSeparate(factorToGL[blendSrc], factorToGL[blendDst], factorToGL[blendSrcAlpha], factorToGL[blendDstAlpha]); + currentBlendSrc = blendSrc; + currentBlendDst = blendDst; + currentBlendSrcAlpha = blendSrcAlpha; + currentBlendDstAlpha = blendDstAlpha; + } + if (blendColor.equals(currentBlendColor) === false || blendAlpha !== currentBlendAlpha) { + gl.blendColor(blendColor.r, blendColor.g, blendColor.b, blendAlpha); + currentBlendColor.copy(blendColor); + currentBlendAlpha = blendAlpha; + } + currentBlending = blending; + currentPremultipledAlpha = false; + } + function setMaterial(material, frontFaceCW) { + material.side === DoubleSide ? disable(gl.CULL_FACE) : enable(gl.CULL_FACE); + let flipSided = material.side === BackSide; + if (frontFaceCW) flipSided = !flipSided; + setFlipSided(flipSided); + material.blending === NormalBlending && material.transparent === false ? setBlending(NoBlending) : setBlending(material.blending, material.blendEquation, material.blendSrc, material.blendDst, material.blendEquationAlpha, material.blendSrcAlpha, material.blendDstAlpha, material.blendColor, material.blendAlpha, material.premultipliedAlpha); + depthBuffer.setFunc(material.depthFunc); + depthBuffer.setTest(material.depthTest); + depthBuffer.setMask(material.depthWrite); + colorBuffer.setMask(material.colorWrite); + const stencilWrite = material.stencilWrite; + stencilBuffer.setTest(stencilWrite); + if (stencilWrite) { + stencilBuffer.setMask(material.stencilWriteMask); + stencilBuffer.setFunc(material.stencilFunc, material.stencilRef, material.stencilFuncMask); + stencilBuffer.setOp(material.stencilFail, material.stencilZFail, material.stencilZPass); + } + setPolygonOffset(material.polygonOffset, material.polygonOffsetFactor, material.polygonOffsetUnits); + material.alphaToCoverage === true ? enable(gl.SAMPLE_ALPHA_TO_COVERAGE) : disable(gl.SAMPLE_ALPHA_TO_COVERAGE); + } + function setFlipSided(flipSided) { + if (currentFlipSided !== flipSided) { + if (flipSided) { + gl.frontFace(gl.CW); + } else { + gl.frontFace(gl.CCW); + } + currentFlipSided = flipSided; + } + } + function setCullFace(cullFace) { + if (cullFace !== CullFaceNone) { + enable(gl.CULL_FACE); + if (cullFace !== currentCullFace) { + if (cullFace === CullFaceBack) { + gl.cullFace(gl.BACK); + } else if (cullFace === CullFaceFront) { + gl.cullFace(gl.FRONT); + } else { + gl.cullFace(gl.FRONT_AND_BACK); + } + } + } else { + disable(gl.CULL_FACE); + } + currentCullFace = cullFace; + } + function setLineWidth(width) { + if (width !== currentLineWidth) { + if (lineWidthAvailable) gl.lineWidth(width); + currentLineWidth = width; + } + } + function setPolygonOffset(polygonOffset, factor, units) { + if (polygonOffset) { + enable(gl.POLYGON_OFFSET_FILL); + if (currentPolygonOffsetFactor !== factor || currentPolygonOffsetUnits !== units) { + gl.polygonOffset(factor, units); + currentPolygonOffsetFactor = factor; + currentPolygonOffsetUnits = units; + } + } else { + disable(gl.POLYGON_OFFSET_FILL); + } + } + function setScissorTest(scissorTest) { + if (scissorTest) { + enable(gl.SCISSOR_TEST); + } else { + disable(gl.SCISSOR_TEST); + } + } + function activeTexture(webglSlot) { + if (webglSlot === void 0) webglSlot = gl.TEXTURE0 + maxTextures - 1; + if (currentTextureSlot !== webglSlot) { + gl.activeTexture(webglSlot); + currentTextureSlot = webglSlot; + } + } + function bindTexture(webglType, webglTexture, webglSlot) { + if (webglSlot === void 0) { + if (currentTextureSlot === null) { + webglSlot = gl.TEXTURE0 + maxTextures - 1; + } else { + webglSlot = currentTextureSlot; + } + } + let boundTexture = currentBoundTextures[webglSlot]; + if (boundTexture === void 0) { + boundTexture = { type: void 0, texture: void 0 }; + currentBoundTextures[webglSlot] = boundTexture; + } + if (boundTexture.type !== webglType || boundTexture.texture !== webglTexture) { + if (currentTextureSlot !== webglSlot) { + gl.activeTexture(webglSlot); + currentTextureSlot = webglSlot; + } + gl.bindTexture(webglType, webglTexture || emptyTextures[webglType]); + boundTexture.type = webglType; + boundTexture.texture = webglTexture; + } + } + function unbindTexture() { + const boundTexture = currentBoundTextures[currentTextureSlot]; + if (boundTexture !== void 0 && boundTexture.type !== void 0) { + gl.bindTexture(boundTexture.type, null); + boundTexture.type = void 0; + boundTexture.texture = void 0; + } + } + function compressedTexImage2D() { + try { + gl.compressedTexImage2D.apply(gl, arguments); + } catch (error) { + console.error("THREE.WebGLState:", error); + } + } + function compressedTexImage3D() { + try { + gl.compressedTexImage3D.apply(gl, arguments); + } catch (error) { + console.error("THREE.WebGLState:", error); + } + } + function texSubImage2D() { + try { + gl.texSubImage2D.apply(gl, arguments); + } catch (error) { + console.error("THREE.WebGLState:", error); + } + } + function texSubImage3D() { + try { + gl.texSubImage3D.apply(gl, arguments); + } catch (error) { + console.error("THREE.WebGLState:", error); + } + } + function compressedTexSubImage2D() { + try { + gl.compressedTexSubImage2D.apply(gl, arguments); + } catch (error) { + console.error("THREE.WebGLState:", error); + } + } + function compressedTexSubImage3D() { + try { + gl.compressedTexSubImage3D.apply(gl, arguments); + } catch (error) { + console.error("THREE.WebGLState:", error); + } + } + function texStorage2D() { + try { + gl.texStorage2D.apply(gl, arguments); + } catch (error) { + console.error("THREE.WebGLState:", error); + } + } + function texStorage3D() { + try { + gl.texStorage3D.apply(gl, arguments); + } catch (error) { + console.error("THREE.WebGLState:", error); + } + } + function texImage2D() { + try { + gl.texImage2D.apply(gl, arguments); + } catch (error) { + console.error("THREE.WebGLState:", error); + } + } + function texImage3D() { + try { + gl.texImage3D.apply(gl, arguments); + } catch (error) { + console.error("THREE.WebGLState:", error); + } + } + function scissor(scissor2) { + if (currentScissor.equals(scissor2) === false) { + gl.scissor(scissor2.x, scissor2.y, scissor2.z, scissor2.w); + currentScissor.copy(scissor2); + } + } + function viewport(viewport2) { + if (currentViewport.equals(viewport2) === false) { + gl.viewport(viewport2.x, viewport2.y, viewport2.z, viewport2.w); + currentViewport.copy(viewport2); + } + } + function updateUBOMapping(uniformsGroup, program) { + let mapping = uboProgramMap.get(program); + if (mapping === void 0) { + mapping = /* @__PURE__ */ new WeakMap(); + uboProgramMap.set(program, mapping); + } + let blockIndex = mapping.get(uniformsGroup); + if (blockIndex === void 0) { + blockIndex = gl.getUniformBlockIndex(program, uniformsGroup.name); + mapping.set(uniformsGroup, blockIndex); + } + } + function uniformBlockBinding(uniformsGroup, program) { + const mapping = uboProgramMap.get(program); + const blockIndex = mapping.get(uniformsGroup); + if (uboBindings.get(program) !== blockIndex) { + gl.uniformBlockBinding(program, blockIndex, uniformsGroup.__bindingPointIndex); + uboBindings.set(program, blockIndex); + } + } + function reset() { + gl.disable(gl.BLEND); + gl.disable(gl.CULL_FACE); + gl.disable(gl.DEPTH_TEST); + gl.disable(gl.POLYGON_OFFSET_FILL); + gl.disable(gl.SCISSOR_TEST); + gl.disable(gl.STENCIL_TEST); + gl.disable(gl.SAMPLE_ALPHA_TO_COVERAGE); + gl.blendEquation(gl.FUNC_ADD); + gl.blendFunc(gl.ONE, gl.ZERO); + gl.blendFuncSeparate(gl.ONE, gl.ZERO, gl.ONE, gl.ZERO); + gl.blendColor(0, 0, 0, 0); + gl.colorMask(true, true, true, true); + gl.clearColor(0, 0, 0, 0); + gl.depthMask(true); + gl.depthFunc(gl.LESS); + gl.clearDepth(1); + gl.stencilMask(4294967295); + gl.stencilFunc(gl.ALWAYS, 0, 4294967295); + gl.stencilOp(gl.KEEP, gl.KEEP, gl.KEEP); + gl.clearStencil(0); + gl.cullFace(gl.BACK); + gl.frontFace(gl.CCW); + gl.polygonOffset(0, 0); + gl.activeTexture(gl.TEXTURE0); + gl.bindFramebuffer(gl.FRAMEBUFFER, null); + gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, null); + gl.bindFramebuffer(gl.READ_FRAMEBUFFER, null); + gl.useProgram(null); + gl.lineWidth(1); + gl.scissor(0, 0, gl.canvas.width, gl.canvas.height); + gl.viewport(0, 0, gl.canvas.width, gl.canvas.height); + enabledCapabilities = {}; + currentTextureSlot = null; + currentBoundTextures = {}; + currentBoundFramebuffers = {}; + currentDrawbuffers = /* @__PURE__ */ new WeakMap(); + defaultDrawbuffers = []; + currentProgram = null; + currentBlendingEnabled = false; + currentBlending = null; + currentBlendEquation = null; + currentBlendSrc = null; + currentBlendDst = null; + currentBlendEquationAlpha = null; + currentBlendSrcAlpha = null; + currentBlendDstAlpha = null; + currentBlendColor = new Color(0, 0, 0); + currentBlendAlpha = 0; + currentPremultipledAlpha = false; + currentFlipSided = null; + currentCullFace = null; + currentLineWidth = null; + currentPolygonOffsetFactor = null; + currentPolygonOffsetUnits = null; + currentScissor.set(0, 0, gl.canvas.width, gl.canvas.height); + currentViewport.set(0, 0, gl.canvas.width, gl.canvas.height); + colorBuffer.reset(); + depthBuffer.reset(); + stencilBuffer.reset(); + } + return { + buffers: { + color: colorBuffer, + depth: depthBuffer, + stencil: stencilBuffer + }, + enable, + disable, + bindFramebuffer, + drawBuffers, + useProgram, + setBlending, + setMaterial, + setFlipSided, + setCullFace, + setLineWidth, + setPolygonOffset, + setScissorTest, + activeTexture, + bindTexture, + unbindTexture, + compressedTexImage2D, + compressedTexImage3D, + texImage2D, + texImage3D, + updateUBOMapping, + uniformBlockBinding, + texStorage2D, + texStorage3D, + texSubImage2D, + texSubImage3D, + compressedTexSubImage2D, + compressedTexSubImage3D, + scissor, + viewport, + reset + }; +} +function WebGLTextures(_gl, extensions, state, properties, capabilities, utils, info) { + const multisampledRTTExt = extensions.has("WEBGL_multisampled_render_to_texture") ? extensions.get("WEBGL_multisampled_render_to_texture") : null; + const supportsInvalidateFramebuffer = typeof navigator === "undefined" ? false : /OculusBrowser/g.test(navigator.userAgent); + const _imageDimensions = new Vector2(); + const _videoTextures = /* @__PURE__ */ new WeakMap(); + let _canvas2; + const _sources = /* @__PURE__ */ new WeakMap(); + let useOffscreenCanvas = false; + try { + useOffscreenCanvas = typeof OffscreenCanvas !== "undefined" && new OffscreenCanvas(1, 1).getContext("2d") !== null; + } catch (err2) { + } + function createCanvas(width, height) { + return useOffscreenCanvas ? ( + // eslint-disable-next-line compat/compat + new OffscreenCanvas(width, height) + ) : createElementNS("canvas"); + } + function resizeImage(image, needsNewCanvas, maxSize) { + let scale = 1; + const dimensions = getDimensions(image); + if (dimensions.width > maxSize || dimensions.height > maxSize) { + scale = maxSize / Math.max(dimensions.width, dimensions.height); + } + if (scale < 1) { + if (typeof HTMLImageElement !== "undefined" && image instanceof HTMLImageElement || typeof HTMLCanvasElement !== "undefined" && image instanceof HTMLCanvasElement || typeof ImageBitmap !== "undefined" && image instanceof ImageBitmap || typeof VideoFrame !== "undefined" && image instanceof VideoFrame) { + const width = Math.floor(scale * dimensions.width); + const height = Math.floor(scale * dimensions.height); + if (_canvas2 === void 0) _canvas2 = createCanvas(width, height); + const canvas = needsNewCanvas ? createCanvas(width, height) : _canvas2; + canvas.width = width; + canvas.height = height; + const context = canvas.getContext("2d"); + context.drawImage(image, 0, 0, width, height); + console.warn("THREE.WebGLRenderer: Texture has been resized from (" + dimensions.width + "x" + dimensions.height + ") to (" + width + "x" + height + ")."); + return canvas; + } else { + if ("data" in image) { + console.warn("THREE.WebGLRenderer: Image in DataTexture is too big (" + dimensions.width + "x" + dimensions.height + ")."); + } + return image; + } + } + return image; + } + function textureNeedsGenerateMipmaps(texture) { + return texture.generateMipmaps && texture.minFilter !== NearestFilter && texture.minFilter !== LinearFilter; + } + function generateMipmap(target) { + _gl.generateMipmap(target); + } + function getInternalFormat(internalFormatName, glFormat, glType, colorSpace, forceLinearTransfer = false) { + if (internalFormatName !== null) { + if (_gl[internalFormatName] !== void 0) return _gl[internalFormatName]; + console.warn("THREE.WebGLRenderer: Attempt to use non-existing WebGL internal format '" + internalFormatName + "'"); + } + let internalFormat = glFormat; + if (glFormat === _gl.RED) { + if (glType === _gl.FLOAT) internalFormat = _gl.R32F; + if (glType === _gl.HALF_FLOAT) internalFormat = _gl.R16F; + if (glType === _gl.UNSIGNED_BYTE) internalFormat = _gl.R8; + } + if (glFormat === _gl.RED_INTEGER) { + if (glType === _gl.UNSIGNED_BYTE) internalFormat = _gl.R8UI; + if (glType === _gl.UNSIGNED_SHORT) internalFormat = _gl.R16UI; + if (glType === _gl.UNSIGNED_INT) internalFormat = _gl.R32UI; + if (glType === _gl.BYTE) internalFormat = _gl.R8I; + if (glType === _gl.SHORT) internalFormat = _gl.R16I; + if (glType === _gl.INT) internalFormat = _gl.R32I; + } + if (glFormat === _gl.RG) { + if (glType === _gl.FLOAT) internalFormat = _gl.RG32F; + if (glType === _gl.HALF_FLOAT) internalFormat = _gl.RG16F; + if (glType === _gl.UNSIGNED_BYTE) internalFormat = _gl.RG8; + } + if (glFormat === _gl.RG_INTEGER) { + if (glType === _gl.UNSIGNED_BYTE) internalFormat = _gl.RG8UI; + if (glType === _gl.UNSIGNED_SHORT) internalFormat = _gl.RG16UI; + if (glType === _gl.UNSIGNED_INT) internalFormat = _gl.RG32UI; + if (glType === _gl.BYTE) internalFormat = _gl.RG8I; + if (glType === _gl.SHORT) internalFormat = _gl.RG16I; + if (glType === _gl.INT) internalFormat = _gl.RG32I; + } + if (glFormat === _gl.RGB) { + if (glType === _gl.UNSIGNED_INT_5_9_9_9_REV) internalFormat = _gl.RGB9_E5; + } + if (glFormat === _gl.RGBA) { + const transfer = forceLinearTransfer ? LinearTransfer : ColorManagement.getTransfer(colorSpace); + if (glType === _gl.FLOAT) internalFormat = _gl.RGBA32F; + if (glType === _gl.HALF_FLOAT) internalFormat = _gl.RGBA16F; + if (glType === _gl.UNSIGNED_BYTE) internalFormat = transfer === SRGBTransfer ? _gl.SRGB8_ALPHA8 : _gl.RGBA8; + if (glType === _gl.UNSIGNED_SHORT_4_4_4_4) internalFormat = _gl.RGBA4; + if (glType === _gl.UNSIGNED_SHORT_5_5_5_1) internalFormat = _gl.RGB5_A1; + } + if (internalFormat === _gl.R16F || internalFormat === _gl.R32F || internalFormat === _gl.RG16F || internalFormat === _gl.RG32F || internalFormat === _gl.RGBA16F || internalFormat === _gl.RGBA32F) { + extensions.get("EXT_color_buffer_float"); + } + return internalFormat; + } + function getMipLevels(texture, image) { + if (textureNeedsGenerateMipmaps(texture) === true || texture.isFramebufferTexture && texture.minFilter !== NearestFilter && texture.minFilter !== LinearFilter) { + return Math.log2(Math.max(image.width, image.height)) + 1; + } else if (texture.mipmaps !== void 0 && texture.mipmaps.length > 0) { + return texture.mipmaps.length; + } else if (texture.isCompressedTexture && Array.isArray(texture.image)) { + return image.mipmaps.length; + } else { + return 1; + } + } + function onTextureDispose(event) { + const texture = event.target; + texture.removeEventListener("dispose", onTextureDispose); + deallocateTexture(texture); + if (texture.isVideoTexture) { + _videoTextures.delete(texture); + } + } + function onRenderTargetDispose(event) { + const renderTarget = event.target; + renderTarget.removeEventListener("dispose", onRenderTargetDispose); + deallocateRenderTarget(renderTarget); + } + function deallocateTexture(texture) { + const textureProperties = properties.get(texture); + if (textureProperties.__webglInit === void 0) return; + const source = texture.source; + const webglTextures = _sources.get(source); + if (webglTextures) { + const webglTexture = webglTextures[textureProperties.__cacheKey]; + webglTexture.usedTimes--; + if (webglTexture.usedTimes === 0) { + deleteTexture(texture); + } + if (Object.keys(webglTextures).length === 0) { + _sources.delete(source); + } + } + properties.remove(texture); + } + function deleteTexture(texture) { + const textureProperties = properties.get(texture); + _gl.deleteTexture(textureProperties.__webglTexture); + const source = texture.source; + const webglTextures = _sources.get(source); + delete webglTextures[textureProperties.__cacheKey]; + info.memory.textures--; + } + function deallocateRenderTarget(renderTarget) { + const renderTargetProperties = properties.get(renderTarget); + if (renderTarget.depthTexture) { + renderTarget.depthTexture.dispose(); + } + if (renderTarget.isWebGLCubeRenderTarget) { + for (let i = 0; i < 6; i++) { + if (Array.isArray(renderTargetProperties.__webglFramebuffer[i])) { + for (let level = 0; level < renderTargetProperties.__webglFramebuffer[i].length; level++) _gl.deleteFramebuffer(renderTargetProperties.__webglFramebuffer[i][level]); + } else { + _gl.deleteFramebuffer(renderTargetProperties.__webglFramebuffer[i]); + } + if (renderTargetProperties.__webglDepthbuffer) _gl.deleteRenderbuffer(renderTargetProperties.__webglDepthbuffer[i]); + } + } else { + if (Array.isArray(renderTargetProperties.__webglFramebuffer)) { + for (let level = 0; level < renderTargetProperties.__webglFramebuffer.length; level++) _gl.deleteFramebuffer(renderTargetProperties.__webglFramebuffer[level]); + } else { + _gl.deleteFramebuffer(renderTargetProperties.__webglFramebuffer); + } + if (renderTargetProperties.__webglDepthbuffer) _gl.deleteRenderbuffer(renderTargetProperties.__webglDepthbuffer); + if (renderTargetProperties.__webglMultisampledFramebuffer) _gl.deleteFramebuffer(renderTargetProperties.__webglMultisampledFramebuffer); + if (renderTargetProperties.__webglColorRenderbuffer) { + for (let i = 0; i < renderTargetProperties.__webglColorRenderbuffer.length; i++) { + if (renderTargetProperties.__webglColorRenderbuffer[i]) _gl.deleteRenderbuffer(renderTargetProperties.__webglColorRenderbuffer[i]); + } + } + if (renderTargetProperties.__webglDepthRenderbuffer) _gl.deleteRenderbuffer(renderTargetProperties.__webglDepthRenderbuffer); + } + const textures = renderTarget.textures; + for (let i = 0, il = textures.length; i < il; i++) { + const attachmentProperties = properties.get(textures[i]); + if (attachmentProperties.__webglTexture) { + _gl.deleteTexture(attachmentProperties.__webglTexture); + info.memory.textures--; + } + properties.remove(textures[i]); + } + properties.remove(renderTarget); + } + let textureUnits = 0; + function resetTextureUnits() { + textureUnits = 0; + } + function allocateTextureUnit() { + const textureUnit = textureUnits; + if (textureUnit >= capabilities.maxTextures) { + console.warn("THREE.WebGLTextures: Trying to use " + textureUnit + " texture units while this GPU supports only " + capabilities.maxTextures); + } + textureUnits += 1; + return textureUnit; + } + function getTextureCacheKey(texture) { + const array = []; + array.push(texture.wrapS); + array.push(texture.wrapT); + array.push(texture.wrapR || 0); + array.push(texture.magFilter); + array.push(texture.minFilter); + array.push(texture.anisotropy); + array.push(texture.internalFormat); + array.push(texture.format); + array.push(texture.type); + array.push(texture.generateMipmaps); + array.push(texture.premultiplyAlpha); + array.push(texture.flipY); + array.push(texture.unpackAlignment); + array.push(texture.colorSpace); + return array.join(); + } + function setTexture2D(texture, slot) { + const textureProperties = properties.get(texture); + if (texture.isVideoTexture) updateVideoTexture(texture); + if (texture.isRenderTargetTexture === false && texture.version > 0 && textureProperties.__version !== texture.version) { + const image = texture.image; + if (image === null) { + console.warn("THREE.WebGLRenderer: Texture marked for update but no image data found."); + } else if (image.complete === false) { + console.warn("THREE.WebGLRenderer: Texture marked for update but image is incomplete"); + } else { + uploadTexture(textureProperties, texture, slot); + return; + } + } + state.bindTexture(_gl.TEXTURE_2D, textureProperties.__webglTexture, _gl.TEXTURE0 + slot); + } + function setTexture2DArray(texture, slot) { + const textureProperties = properties.get(texture); + if (texture.version > 0 && textureProperties.__version !== texture.version) { + uploadTexture(textureProperties, texture, slot); + return; + } + state.bindTexture(_gl.TEXTURE_2D_ARRAY, textureProperties.__webglTexture, _gl.TEXTURE0 + slot); + } + function setTexture3D(texture, slot) { + const textureProperties = properties.get(texture); + if (texture.version > 0 && textureProperties.__version !== texture.version) { + uploadTexture(textureProperties, texture, slot); + return; + } + state.bindTexture(_gl.TEXTURE_3D, textureProperties.__webglTexture, _gl.TEXTURE0 + slot); + } + function setTextureCube(texture, slot) { + const textureProperties = properties.get(texture); + if (texture.version > 0 && textureProperties.__version !== texture.version) { + uploadCubeTexture(textureProperties, texture, slot); + return; + } + state.bindTexture(_gl.TEXTURE_CUBE_MAP, textureProperties.__webglTexture, _gl.TEXTURE0 + slot); + } + const wrappingToGL = { + [RepeatWrapping]: _gl.REPEAT, + [ClampToEdgeWrapping]: _gl.CLAMP_TO_EDGE, + [MirroredRepeatWrapping]: _gl.MIRRORED_REPEAT + }; + const filterToGL = { + [NearestFilter]: _gl.NEAREST, + [NearestMipmapNearestFilter]: _gl.NEAREST_MIPMAP_NEAREST, + [NearestMipmapLinearFilter]: _gl.NEAREST_MIPMAP_LINEAR, + [LinearFilter]: _gl.LINEAR, + [LinearMipmapNearestFilter]: _gl.LINEAR_MIPMAP_NEAREST, + [LinearMipmapLinearFilter]: _gl.LINEAR_MIPMAP_LINEAR + }; + const compareToGL = { + [NeverCompare]: _gl.NEVER, + [AlwaysCompare]: _gl.ALWAYS, + [LessCompare]: _gl.LESS, + [LessEqualCompare]: _gl.LEQUAL, + [EqualCompare]: _gl.EQUAL, + [GreaterEqualCompare]: _gl.GEQUAL, + [GreaterCompare]: _gl.GREATER, + [NotEqualCompare]: _gl.NOTEQUAL + }; + function setTextureParameters(textureType, texture) { + if (texture.type === FloatType && extensions.has("OES_texture_float_linear") === false && (texture.magFilter === LinearFilter || texture.magFilter === LinearMipmapNearestFilter || texture.magFilter === NearestMipmapLinearFilter || texture.magFilter === LinearMipmapLinearFilter || texture.minFilter === LinearFilter || texture.minFilter === LinearMipmapNearestFilter || texture.minFilter === NearestMipmapLinearFilter || texture.minFilter === LinearMipmapLinearFilter)) { + console.warn("THREE.WebGLRenderer: Unable to use linear filtering with floating point textures. OES_texture_float_linear not supported on this device."); + } + _gl.texParameteri(textureType, _gl.TEXTURE_WRAP_S, wrappingToGL[texture.wrapS]); + _gl.texParameteri(textureType, _gl.TEXTURE_WRAP_T, wrappingToGL[texture.wrapT]); + if (textureType === _gl.TEXTURE_3D || textureType === _gl.TEXTURE_2D_ARRAY) { + _gl.texParameteri(textureType, _gl.TEXTURE_WRAP_R, wrappingToGL[texture.wrapR]); + } + _gl.texParameteri(textureType, _gl.TEXTURE_MAG_FILTER, filterToGL[texture.magFilter]); + _gl.texParameteri(textureType, _gl.TEXTURE_MIN_FILTER, filterToGL[texture.minFilter]); + if (texture.compareFunction) { + _gl.texParameteri(textureType, _gl.TEXTURE_COMPARE_MODE, _gl.COMPARE_REF_TO_TEXTURE); + _gl.texParameteri(textureType, _gl.TEXTURE_COMPARE_FUNC, compareToGL[texture.compareFunction]); + } + if (extensions.has("EXT_texture_filter_anisotropic") === true) { + if (texture.magFilter === NearestFilter) return; + if (texture.minFilter !== NearestMipmapLinearFilter && texture.minFilter !== LinearMipmapLinearFilter) return; + if (texture.type === FloatType && extensions.has("OES_texture_float_linear") === false) return; + if (texture.anisotropy > 1 || properties.get(texture).__currentAnisotropy) { + const extension = extensions.get("EXT_texture_filter_anisotropic"); + _gl.texParameterf(textureType, extension.TEXTURE_MAX_ANISOTROPY_EXT, Math.min(texture.anisotropy, capabilities.getMaxAnisotropy())); + properties.get(texture).__currentAnisotropy = texture.anisotropy; + } + } + } + function initTexture(textureProperties, texture) { + let forceUpload = false; + if (textureProperties.__webglInit === void 0) { + textureProperties.__webglInit = true; + texture.addEventListener("dispose", onTextureDispose); + } + const source = texture.source; + let webglTextures = _sources.get(source); + if (webglTextures === void 0) { + webglTextures = {}; + _sources.set(source, webglTextures); + } + const textureCacheKey = getTextureCacheKey(texture); + if (textureCacheKey !== textureProperties.__cacheKey) { + if (webglTextures[textureCacheKey] === void 0) { + webglTextures[textureCacheKey] = { + texture: _gl.createTexture(), + usedTimes: 0 + }; + info.memory.textures++; + forceUpload = true; + } + webglTextures[textureCacheKey].usedTimes++; + const webglTexture = webglTextures[textureProperties.__cacheKey]; + if (webglTexture !== void 0) { + webglTextures[textureProperties.__cacheKey].usedTimes--; + if (webglTexture.usedTimes === 0) { + deleteTexture(texture); + } + } + textureProperties.__cacheKey = textureCacheKey; + textureProperties.__webglTexture = webglTextures[textureCacheKey].texture; + } + return forceUpload; + } + function uploadTexture(textureProperties, texture, slot) { + let textureType = _gl.TEXTURE_2D; + if (texture.isDataArrayTexture || texture.isCompressedArrayTexture) textureType = _gl.TEXTURE_2D_ARRAY; + if (texture.isData3DTexture) textureType = _gl.TEXTURE_3D; + const forceUpload = initTexture(textureProperties, texture); + const source = texture.source; + state.bindTexture(textureType, textureProperties.__webglTexture, _gl.TEXTURE0 + slot); + const sourceProperties = properties.get(source); + if (source.version !== sourceProperties.__version || forceUpload === true) { + state.activeTexture(_gl.TEXTURE0 + slot); + const workingPrimaries = ColorManagement.getPrimaries(ColorManagement.workingColorSpace); + const texturePrimaries = texture.colorSpace === NoColorSpace ? null : ColorManagement.getPrimaries(texture.colorSpace); + const unpackConversion = texture.colorSpace === NoColorSpace || workingPrimaries === texturePrimaries ? _gl.NONE : _gl.BROWSER_DEFAULT_WEBGL; + _gl.pixelStorei(_gl.UNPACK_FLIP_Y_WEBGL, texture.flipY); + _gl.pixelStorei(_gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, texture.premultiplyAlpha); + _gl.pixelStorei(_gl.UNPACK_ALIGNMENT, texture.unpackAlignment); + _gl.pixelStorei(_gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, unpackConversion); + let image = resizeImage(texture.image, false, capabilities.maxTextureSize); + image = verifyColorSpace(texture, image); + const glFormat = utils.convert(texture.format, texture.colorSpace); + const glType = utils.convert(texture.type); + let glInternalFormat = getInternalFormat(texture.internalFormat, glFormat, glType, texture.colorSpace, texture.isVideoTexture); + setTextureParameters(textureType, texture); + let mipmap; + const mipmaps = texture.mipmaps; + const useTexStorage = texture.isVideoTexture !== true && glInternalFormat !== RGB_ETC1_Format; + const allocateMemory = sourceProperties.__version === void 0 || forceUpload === true; + const dataReady = source.dataReady; + const levels = getMipLevels(texture, image); + if (texture.isDepthTexture) { + glInternalFormat = _gl.DEPTH_COMPONENT16; + if (texture.type === FloatType) { + glInternalFormat = _gl.DEPTH_COMPONENT32F; + } else if (texture.type === UnsignedIntType) { + glInternalFormat = _gl.DEPTH_COMPONENT24; + } else if (texture.type === UnsignedInt248Type) { + glInternalFormat = _gl.DEPTH24_STENCIL8; + } + if (allocateMemory) { + if (useTexStorage) { + state.texStorage2D(_gl.TEXTURE_2D, 1, glInternalFormat, image.width, image.height); + } else { + state.texImage2D(_gl.TEXTURE_2D, 0, glInternalFormat, image.width, image.height, 0, glFormat, glType, null); + } + } + } else if (texture.isDataTexture) { + if (mipmaps.length > 0) { + if (useTexStorage && allocateMemory) { + state.texStorage2D(_gl.TEXTURE_2D, levels, glInternalFormat, mipmaps[0].width, mipmaps[0].height); + } + for (let i = 0, il = mipmaps.length; i < il; i++) { + mipmap = mipmaps[i]; + if (useTexStorage) { + if (dataReady) { + state.texSubImage2D(_gl.TEXTURE_2D, i, 0, 0, mipmap.width, mipmap.height, glFormat, glType, mipmap.data); + } + } else { + state.texImage2D(_gl.TEXTURE_2D, i, glInternalFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data); + } + } + texture.generateMipmaps = false; + } else { + if (useTexStorage) { + if (allocateMemory) { + state.texStorage2D(_gl.TEXTURE_2D, levels, glInternalFormat, image.width, image.height); + } + if (dataReady) { + state.texSubImage2D(_gl.TEXTURE_2D, 0, 0, 0, image.width, image.height, glFormat, glType, image.data); + } + } else { + state.texImage2D(_gl.TEXTURE_2D, 0, glInternalFormat, image.width, image.height, 0, glFormat, glType, image.data); + } + } + } else if (texture.isCompressedTexture) { + if (texture.isCompressedArrayTexture) { + if (useTexStorage && allocateMemory) { + state.texStorage3D(_gl.TEXTURE_2D_ARRAY, levels, glInternalFormat, mipmaps[0].width, mipmaps[0].height, image.depth); + } + for (let i = 0, il = mipmaps.length; i < il; i++) { + mipmap = mipmaps[i]; + if (texture.format !== RGBAFormat) { + if (glFormat !== null) { + if (useTexStorage) { + if (dataReady) { + state.compressedTexSubImage3D(_gl.TEXTURE_2D_ARRAY, i, 0, 0, 0, mipmap.width, mipmap.height, image.depth, glFormat, mipmap.data, 0, 0); + } + } else { + state.compressedTexImage3D(_gl.TEXTURE_2D_ARRAY, i, glInternalFormat, mipmap.width, mipmap.height, image.depth, 0, mipmap.data, 0, 0); + } + } else { + console.warn("THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .uploadTexture()"); + } + } else { + if (useTexStorage) { + if (dataReady) { + state.texSubImage3D(_gl.TEXTURE_2D_ARRAY, i, 0, 0, 0, mipmap.width, mipmap.height, image.depth, glFormat, glType, mipmap.data); + } + } else { + state.texImage3D(_gl.TEXTURE_2D_ARRAY, i, glInternalFormat, mipmap.width, mipmap.height, image.depth, 0, glFormat, glType, mipmap.data); + } + } + } + } else { + if (useTexStorage && allocateMemory) { + state.texStorage2D(_gl.TEXTURE_2D, levels, glInternalFormat, mipmaps[0].width, mipmaps[0].height); + } + for (let i = 0, il = mipmaps.length; i < il; i++) { + mipmap = mipmaps[i]; + if (texture.format !== RGBAFormat) { + if (glFormat !== null) { + if (useTexStorage) { + if (dataReady) { + state.compressedTexSubImage2D(_gl.TEXTURE_2D, i, 0, 0, mipmap.width, mipmap.height, glFormat, mipmap.data); + } + } else { + state.compressedTexImage2D(_gl.TEXTURE_2D, i, glInternalFormat, mipmap.width, mipmap.height, 0, mipmap.data); + } + } else { + console.warn("THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .uploadTexture()"); + } + } else { + if (useTexStorage) { + if (dataReady) { + state.texSubImage2D(_gl.TEXTURE_2D, i, 0, 0, mipmap.width, mipmap.height, glFormat, glType, mipmap.data); + } + } else { + state.texImage2D(_gl.TEXTURE_2D, i, glInternalFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data); + } + } + } + } + } else if (texture.isDataArrayTexture) { + if (useTexStorage) { + if (allocateMemory) { + state.texStorage3D(_gl.TEXTURE_2D_ARRAY, levels, glInternalFormat, image.width, image.height, image.depth); + } + if (dataReady) { + state.texSubImage3D(_gl.TEXTURE_2D_ARRAY, 0, 0, 0, 0, image.width, image.height, image.depth, glFormat, glType, image.data); + } + } else { + state.texImage3D(_gl.TEXTURE_2D_ARRAY, 0, glInternalFormat, image.width, image.height, image.depth, 0, glFormat, glType, image.data); + } + } else if (texture.isData3DTexture) { + if (useTexStorage) { + if (allocateMemory) { + state.texStorage3D(_gl.TEXTURE_3D, levels, glInternalFormat, image.width, image.height, image.depth); + } + if (dataReady) { + state.texSubImage3D(_gl.TEXTURE_3D, 0, 0, 0, 0, image.width, image.height, image.depth, glFormat, glType, image.data); + } + } else { + state.texImage3D(_gl.TEXTURE_3D, 0, glInternalFormat, image.width, image.height, image.depth, 0, glFormat, glType, image.data); + } + } else if (texture.isFramebufferTexture) { + if (allocateMemory) { + if (useTexStorage) { + state.texStorage2D(_gl.TEXTURE_2D, levels, glInternalFormat, image.width, image.height); + } else { + let width = image.width, height = image.height; + for (let i = 0; i < levels; i++) { + state.texImage2D(_gl.TEXTURE_2D, i, glInternalFormat, width, height, 0, glFormat, glType, null); + width >>= 1; + height >>= 1; + } + } + } + } else { + if (mipmaps.length > 0) { + if (useTexStorage && allocateMemory) { + const dimensions = getDimensions(mipmaps[0]); + state.texStorage2D(_gl.TEXTURE_2D, levels, glInternalFormat, dimensions.width, dimensions.height); + } + for (let i = 0, il = mipmaps.length; i < il; i++) { + mipmap = mipmaps[i]; + if (useTexStorage) { + if (dataReady) { + state.texSubImage2D(_gl.TEXTURE_2D, i, 0, 0, glFormat, glType, mipmap); + } + } else { + state.texImage2D(_gl.TEXTURE_2D, i, glInternalFormat, glFormat, glType, mipmap); + } + } + texture.generateMipmaps = false; + } else { + if (useTexStorage) { + if (allocateMemory) { + const dimensions = getDimensions(image); + state.texStorage2D(_gl.TEXTURE_2D, levels, glInternalFormat, dimensions.width, dimensions.height); + } + if (dataReady) { + state.texSubImage2D(_gl.TEXTURE_2D, 0, 0, 0, glFormat, glType, image); + } + } else { + state.texImage2D(_gl.TEXTURE_2D, 0, glInternalFormat, glFormat, glType, image); + } + } + } + if (textureNeedsGenerateMipmaps(texture)) { + generateMipmap(textureType); + } + sourceProperties.__version = source.version; + if (texture.onUpdate) texture.onUpdate(texture); + } + textureProperties.__version = texture.version; + } + function uploadCubeTexture(textureProperties, texture, slot) { + if (texture.image.length !== 6) return; + const forceUpload = initTexture(textureProperties, texture); + const source = texture.source; + state.bindTexture(_gl.TEXTURE_CUBE_MAP, textureProperties.__webglTexture, _gl.TEXTURE0 + slot); + const sourceProperties = properties.get(source); + if (source.version !== sourceProperties.__version || forceUpload === true) { + state.activeTexture(_gl.TEXTURE0 + slot); + const workingPrimaries = ColorManagement.getPrimaries(ColorManagement.workingColorSpace); + const texturePrimaries = texture.colorSpace === NoColorSpace ? null : ColorManagement.getPrimaries(texture.colorSpace); + const unpackConversion = texture.colorSpace === NoColorSpace || workingPrimaries === texturePrimaries ? _gl.NONE : _gl.BROWSER_DEFAULT_WEBGL; + _gl.pixelStorei(_gl.UNPACK_FLIP_Y_WEBGL, texture.flipY); + _gl.pixelStorei(_gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, texture.premultiplyAlpha); + _gl.pixelStorei(_gl.UNPACK_ALIGNMENT, texture.unpackAlignment); + _gl.pixelStorei(_gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, unpackConversion); + const isCompressed = texture.isCompressedTexture || texture.image[0].isCompressedTexture; + const isDataTexture = texture.image[0] && texture.image[0].isDataTexture; + const cubeImage = []; + for (let i = 0; i < 6; i++) { + if (!isCompressed && !isDataTexture) { + cubeImage[i] = resizeImage(texture.image[i], true, capabilities.maxCubemapSize); + } else { + cubeImage[i] = isDataTexture ? texture.image[i].image : texture.image[i]; + } + cubeImage[i] = verifyColorSpace(texture, cubeImage[i]); + } + const image = cubeImage[0], glFormat = utils.convert(texture.format, texture.colorSpace), glType = utils.convert(texture.type), glInternalFormat = getInternalFormat(texture.internalFormat, glFormat, glType, texture.colorSpace); + const useTexStorage = texture.isVideoTexture !== true; + const allocateMemory = sourceProperties.__version === void 0 || forceUpload === true; + const dataReady = source.dataReady; + let levels = getMipLevels(texture, image); + setTextureParameters(_gl.TEXTURE_CUBE_MAP, texture); + let mipmaps; + if (isCompressed) { + if (useTexStorage && allocateMemory) { + state.texStorage2D(_gl.TEXTURE_CUBE_MAP, levels, glInternalFormat, image.width, image.height); + } + for (let i = 0; i < 6; i++) { + mipmaps = cubeImage[i].mipmaps; + for (let j = 0; j < mipmaps.length; j++) { + const mipmap = mipmaps[j]; + if (texture.format !== RGBAFormat) { + if (glFormat !== null) { + if (useTexStorage) { + if (dataReady) { + state.compressedTexSubImage2D(_gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j, 0, 0, mipmap.width, mipmap.height, glFormat, mipmap.data); + } + } else { + state.compressedTexImage2D(_gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j, glInternalFormat, mipmap.width, mipmap.height, 0, mipmap.data); + } + } else { + console.warn("THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .setTextureCube()"); + } + } else { + if (useTexStorage) { + if (dataReady) { + state.texSubImage2D(_gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j, 0, 0, mipmap.width, mipmap.height, glFormat, glType, mipmap.data); + } + } else { + state.texImage2D(_gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j, glInternalFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data); + } + } + } + } + } else { + mipmaps = texture.mipmaps; + if (useTexStorage && allocateMemory) { + if (mipmaps.length > 0) levels++; + const dimensions = getDimensions(cubeImage[0]); + state.texStorage2D(_gl.TEXTURE_CUBE_MAP, levels, glInternalFormat, dimensions.width, dimensions.height); + } + for (let i = 0; i < 6; i++) { + if (isDataTexture) { + if (useTexStorage) { + if (dataReady) { + state.texSubImage2D(_gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, 0, 0, cubeImage[i].width, cubeImage[i].height, glFormat, glType, cubeImage[i].data); + } + } else { + state.texImage2D(_gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glInternalFormat, cubeImage[i].width, cubeImage[i].height, 0, glFormat, glType, cubeImage[i].data); + } + for (let j = 0; j < mipmaps.length; j++) { + const mipmap = mipmaps[j]; + const mipmapImage = mipmap.image[i].image; + if (useTexStorage) { + if (dataReady) { + state.texSubImage2D(_gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j + 1, 0, 0, mipmapImage.width, mipmapImage.height, glFormat, glType, mipmapImage.data); + } + } else { + state.texImage2D(_gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j + 1, glInternalFormat, mipmapImage.width, mipmapImage.height, 0, glFormat, glType, mipmapImage.data); + } + } + } else { + if (useTexStorage) { + if (dataReady) { + state.texSubImage2D(_gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, 0, 0, glFormat, glType, cubeImage[i]); + } + } else { + state.texImage2D(_gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glInternalFormat, glFormat, glType, cubeImage[i]); + } + for (let j = 0; j < mipmaps.length; j++) { + const mipmap = mipmaps[j]; + if (useTexStorage) { + if (dataReady) { + state.texSubImage2D(_gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j + 1, 0, 0, glFormat, glType, mipmap.image[i]); + } + } else { + state.texImage2D(_gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j + 1, glInternalFormat, glFormat, glType, mipmap.image[i]); + } + } + } + } + } + if (textureNeedsGenerateMipmaps(texture)) { + generateMipmap(_gl.TEXTURE_CUBE_MAP); + } + sourceProperties.__version = source.version; + if (texture.onUpdate) texture.onUpdate(texture); + } + textureProperties.__version = texture.version; + } + function setupFrameBufferTexture(framebuffer, renderTarget, texture, attachment, textureTarget, level) { + const glFormat = utils.convert(texture.format, texture.colorSpace); + const glType = utils.convert(texture.type); + const glInternalFormat = getInternalFormat(texture.internalFormat, glFormat, glType, texture.colorSpace); + const renderTargetProperties = properties.get(renderTarget); + if (!renderTargetProperties.__hasExternalTextures) { + const width = Math.max(1, renderTarget.width >> level); + const height = Math.max(1, renderTarget.height >> level); + if (textureTarget === _gl.TEXTURE_3D || textureTarget === _gl.TEXTURE_2D_ARRAY) { + state.texImage3D(textureTarget, level, glInternalFormat, width, height, renderTarget.depth, 0, glFormat, glType, null); + } else { + state.texImage2D(textureTarget, level, glInternalFormat, width, height, 0, glFormat, glType, null); + } + } + state.bindFramebuffer(_gl.FRAMEBUFFER, framebuffer); + if (useMultisampledRTT(renderTarget)) { + multisampledRTTExt.framebufferTexture2DMultisampleEXT(_gl.FRAMEBUFFER, attachment, textureTarget, properties.get(texture).__webglTexture, 0, getRenderTargetSamples(renderTarget)); + } else if (textureTarget === _gl.TEXTURE_2D || textureTarget >= _gl.TEXTURE_CUBE_MAP_POSITIVE_X && textureTarget <= _gl.TEXTURE_CUBE_MAP_NEGATIVE_Z) { + _gl.framebufferTexture2D(_gl.FRAMEBUFFER, attachment, textureTarget, properties.get(texture).__webglTexture, level); + } + state.bindFramebuffer(_gl.FRAMEBUFFER, null); + } + function setupRenderBufferStorage(renderbuffer, renderTarget, isMultisample) { + _gl.bindRenderbuffer(_gl.RENDERBUFFER, renderbuffer); + if (renderTarget.depthBuffer && !renderTarget.stencilBuffer) { + let glInternalFormat = _gl.DEPTH_COMPONENT24; + if (isMultisample || useMultisampledRTT(renderTarget)) { + const depthTexture = renderTarget.depthTexture; + if (depthTexture && depthTexture.isDepthTexture) { + if (depthTexture.type === FloatType) { + glInternalFormat = _gl.DEPTH_COMPONENT32F; + } else if (depthTexture.type === UnsignedIntType) { + glInternalFormat = _gl.DEPTH_COMPONENT24; + } + } + const samples = getRenderTargetSamples(renderTarget); + if (useMultisampledRTT(renderTarget)) { + multisampledRTTExt.renderbufferStorageMultisampleEXT(_gl.RENDERBUFFER, samples, glInternalFormat, renderTarget.width, renderTarget.height); + } else { + _gl.renderbufferStorageMultisample(_gl.RENDERBUFFER, samples, glInternalFormat, renderTarget.width, renderTarget.height); + } + } else { + _gl.renderbufferStorage(_gl.RENDERBUFFER, glInternalFormat, renderTarget.width, renderTarget.height); + } + _gl.framebufferRenderbuffer(_gl.FRAMEBUFFER, _gl.DEPTH_ATTACHMENT, _gl.RENDERBUFFER, renderbuffer); + } else if (renderTarget.depthBuffer && renderTarget.stencilBuffer) { + const samples = getRenderTargetSamples(renderTarget); + if (isMultisample && useMultisampledRTT(renderTarget) === false) { + _gl.renderbufferStorageMultisample(_gl.RENDERBUFFER, samples, _gl.DEPTH24_STENCIL8, renderTarget.width, renderTarget.height); + } else if (useMultisampledRTT(renderTarget)) { + multisampledRTTExt.renderbufferStorageMultisampleEXT(_gl.RENDERBUFFER, samples, _gl.DEPTH24_STENCIL8, renderTarget.width, renderTarget.height); + } else { + _gl.renderbufferStorage(_gl.RENDERBUFFER, _gl.DEPTH_STENCIL, renderTarget.width, renderTarget.height); + } + _gl.framebufferRenderbuffer(_gl.FRAMEBUFFER, _gl.DEPTH_STENCIL_ATTACHMENT, _gl.RENDERBUFFER, renderbuffer); + } else { + const textures = renderTarget.textures; + for (let i = 0; i < textures.length; i++) { + const texture = textures[i]; + const glFormat = utils.convert(texture.format, texture.colorSpace); + const glType = utils.convert(texture.type); + const glInternalFormat = getInternalFormat(texture.internalFormat, glFormat, glType, texture.colorSpace); + const samples = getRenderTargetSamples(renderTarget); + if (isMultisample && useMultisampledRTT(renderTarget) === false) { + _gl.renderbufferStorageMultisample(_gl.RENDERBUFFER, samples, glInternalFormat, renderTarget.width, renderTarget.height); + } else if (useMultisampledRTT(renderTarget)) { + multisampledRTTExt.renderbufferStorageMultisampleEXT(_gl.RENDERBUFFER, samples, glInternalFormat, renderTarget.width, renderTarget.height); + } else { + _gl.renderbufferStorage(_gl.RENDERBUFFER, glInternalFormat, renderTarget.width, renderTarget.height); + } + } + } + _gl.bindRenderbuffer(_gl.RENDERBUFFER, null); + } + function setupDepthTexture(framebuffer, renderTarget) { + const isCube = renderTarget && renderTarget.isWebGLCubeRenderTarget; + if (isCube) throw new Error("Depth Texture with cube render targets is not supported"); + state.bindFramebuffer(_gl.FRAMEBUFFER, framebuffer); + if (!(renderTarget.depthTexture && renderTarget.depthTexture.isDepthTexture)) { + throw new Error("renderTarget.depthTexture must be an instance of THREE.DepthTexture"); + } + if (!properties.get(renderTarget.depthTexture).__webglTexture || renderTarget.depthTexture.image.width !== renderTarget.width || renderTarget.depthTexture.image.height !== renderTarget.height) { + renderTarget.depthTexture.image.width = renderTarget.width; + renderTarget.depthTexture.image.height = renderTarget.height; + renderTarget.depthTexture.needsUpdate = true; + } + setTexture2D(renderTarget.depthTexture, 0); + const webglDepthTexture = properties.get(renderTarget.depthTexture).__webglTexture; + const samples = getRenderTargetSamples(renderTarget); + if (renderTarget.depthTexture.format === DepthFormat) { + if (useMultisampledRTT(renderTarget)) { + multisampledRTTExt.framebufferTexture2DMultisampleEXT(_gl.FRAMEBUFFER, _gl.DEPTH_ATTACHMENT, _gl.TEXTURE_2D, webglDepthTexture, 0, samples); + } else { + _gl.framebufferTexture2D(_gl.FRAMEBUFFER, _gl.DEPTH_ATTACHMENT, _gl.TEXTURE_2D, webglDepthTexture, 0); + } + } else if (renderTarget.depthTexture.format === DepthStencilFormat) { + if (useMultisampledRTT(renderTarget)) { + multisampledRTTExt.framebufferTexture2DMultisampleEXT(_gl.FRAMEBUFFER, _gl.DEPTH_STENCIL_ATTACHMENT, _gl.TEXTURE_2D, webglDepthTexture, 0, samples); + } else { + _gl.framebufferTexture2D(_gl.FRAMEBUFFER, _gl.DEPTH_STENCIL_ATTACHMENT, _gl.TEXTURE_2D, webglDepthTexture, 0); + } + } else { + throw new Error("Unknown depthTexture format"); + } + } + function setupDepthRenderbuffer(renderTarget) { + const renderTargetProperties = properties.get(renderTarget); + const isCube = renderTarget.isWebGLCubeRenderTarget === true; + if (renderTarget.depthTexture && !renderTargetProperties.__autoAllocateDepthBuffer) { + if (isCube) throw new Error("target.depthTexture not supported in Cube render targets"); + setupDepthTexture(renderTargetProperties.__webglFramebuffer, renderTarget); + } else { + if (isCube) { + renderTargetProperties.__webglDepthbuffer = []; + for (let i = 0; i < 6; i++) { + state.bindFramebuffer(_gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer[i]); + renderTargetProperties.__webglDepthbuffer[i] = _gl.createRenderbuffer(); + setupRenderBufferStorage(renderTargetProperties.__webglDepthbuffer[i], renderTarget, false); + } + } else { + state.bindFramebuffer(_gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer); + renderTargetProperties.__webglDepthbuffer = _gl.createRenderbuffer(); + setupRenderBufferStorage(renderTargetProperties.__webglDepthbuffer, renderTarget, false); + } + } + state.bindFramebuffer(_gl.FRAMEBUFFER, null); + } + function rebindTextures(renderTarget, colorTexture, depthTexture) { + const renderTargetProperties = properties.get(renderTarget); + if (colorTexture !== void 0) { + setupFrameBufferTexture(renderTargetProperties.__webglFramebuffer, renderTarget, renderTarget.texture, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_2D, 0); + } + if (depthTexture !== void 0) { + setupDepthRenderbuffer(renderTarget); + } + } + function setupRenderTarget(renderTarget) { + const texture = renderTarget.texture; + const renderTargetProperties = properties.get(renderTarget); + const textureProperties = properties.get(texture); + renderTarget.addEventListener("dispose", onRenderTargetDispose); + const textures = renderTarget.textures; + const isCube = renderTarget.isWebGLCubeRenderTarget === true; + const isMultipleRenderTargets = textures.length > 1; + if (!isMultipleRenderTargets) { + if (textureProperties.__webglTexture === void 0) { + textureProperties.__webglTexture = _gl.createTexture(); + } + textureProperties.__version = texture.version; + info.memory.textures++; + } + if (isCube) { + renderTargetProperties.__webglFramebuffer = []; + for (let i = 0; i < 6; i++) { + if (texture.mipmaps && texture.mipmaps.length > 0) { + renderTargetProperties.__webglFramebuffer[i] = []; + for (let level = 0; level < texture.mipmaps.length; level++) { + renderTargetProperties.__webglFramebuffer[i][level] = _gl.createFramebuffer(); + } + } else { + renderTargetProperties.__webglFramebuffer[i] = _gl.createFramebuffer(); + } + } + } else { + if (texture.mipmaps && texture.mipmaps.length > 0) { + renderTargetProperties.__webglFramebuffer = []; + for (let level = 0; level < texture.mipmaps.length; level++) { + renderTargetProperties.__webglFramebuffer[level] = _gl.createFramebuffer(); + } + } else { + renderTargetProperties.__webglFramebuffer = _gl.createFramebuffer(); + } + if (isMultipleRenderTargets) { + for (let i = 0, il = textures.length; i < il; i++) { + const attachmentProperties = properties.get(textures[i]); + if (attachmentProperties.__webglTexture === void 0) { + attachmentProperties.__webglTexture = _gl.createTexture(); + info.memory.textures++; + } + } + } + if (renderTarget.samples > 0 && useMultisampledRTT(renderTarget) === false) { + renderTargetProperties.__webglMultisampledFramebuffer = _gl.createFramebuffer(); + renderTargetProperties.__webglColorRenderbuffer = []; + state.bindFramebuffer(_gl.FRAMEBUFFER, renderTargetProperties.__webglMultisampledFramebuffer); + for (let i = 0; i < textures.length; i++) { + const texture2 = textures[i]; + renderTargetProperties.__webglColorRenderbuffer[i] = _gl.createRenderbuffer(); + _gl.bindRenderbuffer(_gl.RENDERBUFFER, renderTargetProperties.__webglColorRenderbuffer[i]); + const glFormat = utils.convert(texture2.format, texture2.colorSpace); + const glType = utils.convert(texture2.type); + const glInternalFormat = getInternalFormat(texture2.internalFormat, glFormat, glType, texture2.colorSpace, renderTarget.isXRRenderTarget === true); + const samples = getRenderTargetSamples(renderTarget); + _gl.renderbufferStorageMultisample(_gl.RENDERBUFFER, samples, glInternalFormat, renderTarget.width, renderTarget.height); + _gl.framebufferRenderbuffer(_gl.FRAMEBUFFER, _gl.COLOR_ATTACHMENT0 + i, _gl.RENDERBUFFER, renderTargetProperties.__webglColorRenderbuffer[i]); + } + _gl.bindRenderbuffer(_gl.RENDERBUFFER, null); + if (renderTarget.depthBuffer) { + renderTargetProperties.__webglDepthRenderbuffer = _gl.createRenderbuffer(); + setupRenderBufferStorage(renderTargetProperties.__webglDepthRenderbuffer, renderTarget, true); + } + state.bindFramebuffer(_gl.FRAMEBUFFER, null); + } + } + if (isCube) { + state.bindTexture(_gl.TEXTURE_CUBE_MAP, textureProperties.__webglTexture); + setTextureParameters(_gl.TEXTURE_CUBE_MAP, texture); + for (let i = 0; i < 6; i++) { + if (texture.mipmaps && texture.mipmaps.length > 0) { + for (let level = 0; level < texture.mipmaps.length; level++) { + setupFrameBufferTexture(renderTargetProperties.__webglFramebuffer[i][level], renderTarget, texture, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, level); + } + } else { + setupFrameBufferTexture(renderTargetProperties.__webglFramebuffer[i], renderTarget, texture, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0); + } + } + if (textureNeedsGenerateMipmaps(texture)) { + generateMipmap(_gl.TEXTURE_CUBE_MAP); + } + state.unbindTexture(); + } else if (isMultipleRenderTargets) { + for (let i = 0, il = textures.length; i < il; i++) { + const attachment = textures[i]; + const attachmentProperties = properties.get(attachment); + state.bindTexture(_gl.TEXTURE_2D, attachmentProperties.__webglTexture); + setTextureParameters(_gl.TEXTURE_2D, attachment); + setupFrameBufferTexture(renderTargetProperties.__webglFramebuffer, renderTarget, attachment, _gl.COLOR_ATTACHMENT0 + i, _gl.TEXTURE_2D, 0); + if (textureNeedsGenerateMipmaps(attachment)) { + generateMipmap(_gl.TEXTURE_2D); + } + } + state.unbindTexture(); + } else { + let glTextureType = _gl.TEXTURE_2D; + if (renderTarget.isWebGL3DRenderTarget || renderTarget.isWebGLArrayRenderTarget) { + glTextureType = renderTarget.isWebGL3DRenderTarget ? _gl.TEXTURE_3D : _gl.TEXTURE_2D_ARRAY; + } + state.bindTexture(glTextureType, textureProperties.__webglTexture); + setTextureParameters(glTextureType, texture); + if (texture.mipmaps && texture.mipmaps.length > 0) { + for (let level = 0; level < texture.mipmaps.length; level++) { + setupFrameBufferTexture(renderTargetProperties.__webglFramebuffer[level], renderTarget, texture, _gl.COLOR_ATTACHMENT0, glTextureType, level); + } + } else { + setupFrameBufferTexture(renderTargetProperties.__webglFramebuffer, renderTarget, texture, _gl.COLOR_ATTACHMENT0, glTextureType, 0); + } + if (textureNeedsGenerateMipmaps(texture)) { + generateMipmap(glTextureType); + } + state.unbindTexture(); + } + if (renderTarget.depthBuffer) { + setupDepthRenderbuffer(renderTarget); + } + } + function updateRenderTargetMipmap(renderTarget) { + const textures = renderTarget.textures; + for (let i = 0, il = textures.length; i < il; i++) { + const texture = textures[i]; + if (textureNeedsGenerateMipmaps(texture)) { + const target = renderTarget.isWebGLCubeRenderTarget ? _gl.TEXTURE_CUBE_MAP : _gl.TEXTURE_2D; + const webglTexture = properties.get(texture).__webglTexture; + state.bindTexture(target, webglTexture); + generateMipmap(target); + state.unbindTexture(); + } + } + } + function updateMultisampleRenderTarget(renderTarget) { + if (renderTarget.samples > 0 && useMultisampledRTT(renderTarget) === false) { + const textures = renderTarget.textures; + const width = renderTarget.width; + const height = renderTarget.height; + let mask = _gl.COLOR_BUFFER_BIT; + const invalidationArray = []; + const depthStyle = renderTarget.stencilBuffer ? _gl.DEPTH_STENCIL_ATTACHMENT : _gl.DEPTH_ATTACHMENT; + const renderTargetProperties = properties.get(renderTarget); + const isMultipleRenderTargets = textures.length > 1; + if (isMultipleRenderTargets) { + for (let i = 0; i < textures.length; i++) { + state.bindFramebuffer(_gl.FRAMEBUFFER, renderTargetProperties.__webglMultisampledFramebuffer); + _gl.framebufferRenderbuffer(_gl.FRAMEBUFFER, _gl.COLOR_ATTACHMENT0 + i, _gl.RENDERBUFFER, null); + state.bindFramebuffer(_gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer); + _gl.framebufferTexture2D(_gl.DRAW_FRAMEBUFFER, _gl.COLOR_ATTACHMENT0 + i, _gl.TEXTURE_2D, null, 0); + } + } + state.bindFramebuffer(_gl.READ_FRAMEBUFFER, renderTargetProperties.__webglMultisampledFramebuffer); + state.bindFramebuffer(_gl.DRAW_FRAMEBUFFER, renderTargetProperties.__webglFramebuffer); + for (let i = 0; i < textures.length; i++) { + invalidationArray.push(_gl.COLOR_ATTACHMENT0 + i); + if (renderTarget.depthBuffer) { + invalidationArray.push(depthStyle); + } + const ignoreDepthValues = renderTargetProperties.__ignoreDepthValues !== void 0 ? renderTargetProperties.__ignoreDepthValues : false; + if (ignoreDepthValues === false) { + if (renderTarget.depthBuffer) mask |= _gl.DEPTH_BUFFER_BIT; + if (renderTarget.stencilBuffer && renderTargetProperties.__isTransmissionRenderTarget !== true) mask |= _gl.STENCIL_BUFFER_BIT; + } + if (isMultipleRenderTargets) { + _gl.framebufferRenderbuffer(_gl.READ_FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, _gl.RENDERBUFFER, renderTargetProperties.__webglColorRenderbuffer[i]); + } + if (ignoreDepthValues === true) { + _gl.invalidateFramebuffer(_gl.READ_FRAMEBUFFER, [depthStyle]); + _gl.invalidateFramebuffer(_gl.DRAW_FRAMEBUFFER, [depthStyle]); + } + if (isMultipleRenderTargets) { + const webglTexture = properties.get(textures[i]).__webglTexture; + _gl.framebufferTexture2D(_gl.DRAW_FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_2D, webglTexture, 0); + } + _gl.blitFramebuffer(0, 0, width, height, 0, 0, width, height, mask, _gl.NEAREST); + if (supportsInvalidateFramebuffer) { + _gl.invalidateFramebuffer(_gl.READ_FRAMEBUFFER, invalidationArray); + } + } + state.bindFramebuffer(_gl.READ_FRAMEBUFFER, null); + state.bindFramebuffer(_gl.DRAW_FRAMEBUFFER, null); + if (isMultipleRenderTargets) { + for (let i = 0; i < textures.length; i++) { + state.bindFramebuffer(_gl.FRAMEBUFFER, renderTargetProperties.__webglMultisampledFramebuffer); + _gl.framebufferRenderbuffer(_gl.FRAMEBUFFER, _gl.COLOR_ATTACHMENT0 + i, _gl.RENDERBUFFER, renderTargetProperties.__webglColorRenderbuffer[i]); + const webglTexture = properties.get(textures[i]).__webglTexture; + state.bindFramebuffer(_gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer); + _gl.framebufferTexture2D(_gl.DRAW_FRAMEBUFFER, _gl.COLOR_ATTACHMENT0 + i, _gl.TEXTURE_2D, webglTexture, 0); + } + } + state.bindFramebuffer(_gl.DRAW_FRAMEBUFFER, renderTargetProperties.__webglMultisampledFramebuffer); + } + } + function getRenderTargetSamples(renderTarget) { + return Math.min(capabilities.maxSamples, renderTarget.samples); + } + function useMultisampledRTT(renderTarget) { + const renderTargetProperties = properties.get(renderTarget); + return renderTarget.samples > 0 && extensions.has("WEBGL_multisampled_render_to_texture") === true && renderTargetProperties.__useRenderToTexture !== false; + } + function updateVideoTexture(texture) { + const frame = info.render.frame; + if (_videoTextures.get(texture) !== frame) { + _videoTextures.set(texture, frame); + texture.update(); + } + } + function verifyColorSpace(texture, image) { + const colorSpace = texture.colorSpace; + const format = texture.format; + const type = texture.type; + if (texture.isCompressedTexture === true || texture.isVideoTexture === true) return image; + if (colorSpace !== LinearSRGBColorSpace && colorSpace !== NoColorSpace) { + if (ColorManagement.getTransfer(colorSpace) === SRGBTransfer) { + if (format !== RGBAFormat || type !== UnsignedByteType) { + console.warn("THREE.WebGLTextures: sRGB encoded textures have to use RGBAFormat and UnsignedByteType."); + } + } else { + console.error("THREE.WebGLTextures: Unsupported texture color space:", colorSpace); + } + } + return image; + } + function getDimensions(image) { + if (typeof HTMLImageElement !== "undefined" && image instanceof HTMLImageElement) { + _imageDimensions.width = image.naturalWidth || image.width; + _imageDimensions.height = image.naturalHeight || image.height; + } else if (typeof VideoFrame !== "undefined" && image instanceof VideoFrame) { + _imageDimensions.width = image.displayWidth; + _imageDimensions.height = image.displayHeight; + } else { + _imageDimensions.width = image.width; + _imageDimensions.height = image.height; + } + return _imageDimensions; + } + this.allocateTextureUnit = allocateTextureUnit; + this.resetTextureUnits = resetTextureUnits; + this.setTexture2D = setTexture2D; + this.setTexture2DArray = setTexture2DArray; + this.setTexture3D = setTexture3D; + this.setTextureCube = setTextureCube; + this.rebindTextures = rebindTextures; + this.setupRenderTarget = setupRenderTarget; + this.updateRenderTargetMipmap = updateRenderTargetMipmap; + this.updateMultisampleRenderTarget = updateMultisampleRenderTarget; + this.setupDepthRenderbuffer = setupDepthRenderbuffer; + this.setupFrameBufferTexture = setupFrameBufferTexture; + this.useMultisampledRTT = useMultisampledRTT; +} +function WebGLUtils(gl, extensions) { + function convert(p, colorSpace = NoColorSpace) { + let extension; + const transfer = ColorManagement.getTransfer(colorSpace); + if (p === UnsignedByteType) return gl.UNSIGNED_BYTE; + if (p === UnsignedShort4444Type) return gl.UNSIGNED_SHORT_4_4_4_4; + if (p === UnsignedShort5551Type) return gl.UNSIGNED_SHORT_5_5_5_1; + if (p === UnsignedInt5999Type) return gl.UNSIGNED_INT_5_9_9_9_REV; + if (p === ByteType) return gl.BYTE; + if (p === ShortType) return gl.SHORT; + if (p === UnsignedShortType) return gl.UNSIGNED_SHORT; + if (p === IntType) return gl.INT; + if (p === UnsignedIntType) return gl.UNSIGNED_INT; + if (p === FloatType) return gl.FLOAT; + if (p === HalfFloatType) return gl.HALF_FLOAT; + if (p === AlphaFormat) return gl.ALPHA; + if (p === RGBFormat) return gl.RGB; + if (p === RGBAFormat) return gl.RGBA; + if (p === LuminanceFormat) return gl.LUMINANCE; + if (p === LuminanceAlphaFormat) return gl.LUMINANCE_ALPHA; + if (p === DepthFormat) return gl.DEPTH_COMPONENT; + if (p === DepthStencilFormat) return gl.DEPTH_STENCIL; + if (p === RedFormat) return gl.RED; + if (p === RedIntegerFormat) return gl.RED_INTEGER; + if (p === RGFormat) return gl.RG; + if (p === RGIntegerFormat) return gl.RG_INTEGER; + if (p === RGBAIntegerFormat) return gl.RGBA_INTEGER; + if (p === RGB_S3TC_DXT1_Format || p === RGBA_S3TC_DXT1_Format || p === RGBA_S3TC_DXT3_Format || p === RGBA_S3TC_DXT5_Format) { + if (transfer === SRGBTransfer) { + extension = extensions.get("WEBGL_compressed_texture_s3tc_srgb"); + if (extension !== null) { + if (p === RGB_S3TC_DXT1_Format) return extension.COMPRESSED_SRGB_S3TC_DXT1_EXT; + if (p === RGBA_S3TC_DXT1_Format) return extension.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT; + if (p === RGBA_S3TC_DXT3_Format) return extension.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT; + if (p === RGBA_S3TC_DXT5_Format) return extension.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT; + } else { + return null; + } + } else { + extension = extensions.get("WEBGL_compressed_texture_s3tc"); + if (extension !== null) { + if (p === RGB_S3TC_DXT1_Format) return extension.COMPRESSED_RGB_S3TC_DXT1_EXT; + if (p === RGBA_S3TC_DXT1_Format) return extension.COMPRESSED_RGBA_S3TC_DXT1_EXT; + if (p === RGBA_S3TC_DXT3_Format) return extension.COMPRESSED_RGBA_S3TC_DXT3_EXT; + if (p === RGBA_S3TC_DXT5_Format) return extension.COMPRESSED_RGBA_S3TC_DXT5_EXT; + } else { + return null; + } + } + } + if (p === RGB_PVRTC_4BPPV1_Format || p === RGB_PVRTC_2BPPV1_Format || p === RGBA_PVRTC_4BPPV1_Format || p === RGBA_PVRTC_2BPPV1_Format) { + extension = extensions.get("WEBGL_compressed_texture_pvrtc"); + if (extension !== null) { + if (p === RGB_PVRTC_4BPPV1_Format) return extension.COMPRESSED_RGB_PVRTC_4BPPV1_IMG; + if (p === RGB_PVRTC_2BPPV1_Format) return extension.COMPRESSED_RGB_PVRTC_2BPPV1_IMG; + if (p === RGBA_PVRTC_4BPPV1_Format) return extension.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG; + if (p === RGBA_PVRTC_2BPPV1_Format) return extension.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG; + } else { + return null; + } + } + if (p === RGB_ETC1_Format) { + extension = extensions.get("WEBGL_compressed_texture_etc1"); + if (extension !== null) { + return extension.COMPRESSED_RGB_ETC1_WEBGL; + } else { + return null; + } + } + if (p === RGB_ETC2_Format || p === RGBA_ETC2_EAC_Format) { + extension = extensions.get("WEBGL_compressed_texture_etc"); + if (extension !== null) { + if (p === RGB_ETC2_Format) return transfer === SRGBTransfer ? extension.COMPRESSED_SRGB8_ETC2 : extension.COMPRESSED_RGB8_ETC2; + if (p === RGBA_ETC2_EAC_Format) return transfer === SRGBTransfer ? extension.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC : extension.COMPRESSED_RGBA8_ETC2_EAC; + } else { + return null; + } + } + if (p === RGBA_ASTC_4x4_Format || p === RGBA_ASTC_5x4_Format || p === RGBA_ASTC_5x5_Format || p === RGBA_ASTC_6x5_Format || p === RGBA_ASTC_6x6_Format || p === RGBA_ASTC_8x5_Format || p === RGBA_ASTC_8x6_Format || p === RGBA_ASTC_8x8_Format || p === RGBA_ASTC_10x5_Format || p === RGBA_ASTC_10x6_Format || p === RGBA_ASTC_10x8_Format || p === RGBA_ASTC_10x10_Format || p === RGBA_ASTC_12x10_Format || p === RGBA_ASTC_12x12_Format) { + extension = extensions.get("WEBGL_compressed_texture_astc"); + if (extension !== null) { + if (p === RGBA_ASTC_4x4_Format) return transfer === SRGBTransfer ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR : extension.COMPRESSED_RGBA_ASTC_4x4_KHR; + if (p === RGBA_ASTC_5x4_Format) return transfer === SRGBTransfer ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR : extension.COMPRESSED_RGBA_ASTC_5x4_KHR; + if (p === RGBA_ASTC_5x5_Format) return transfer === SRGBTransfer ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR : extension.COMPRESSED_RGBA_ASTC_5x5_KHR; + if (p === RGBA_ASTC_6x5_Format) return transfer === SRGBTransfer ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR : extension.COMPRESSED_RGBA_ASTC_6x5_KHR; + if (p === RGBA_ASTC_6x6_Format) return transfer === SRGBTransfer ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR : extension.COMPRESSED_RGBA_ASTC_6x6_KHR; + if (p === RGBA_ASTC_8x5_Format) return transfer === SRGBTransfer ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR : extension.COMPRESSED_RGBA_ASTC_8x5_KHR; + if (p === RGBA_ASTC_8x6_Format) return transfer === SRGBTransfer ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR : extension.COMPRESSED_RGBA_ASTC_8x6_KHR; + if (p === RGBA_ASTC_8x8_Format) return transfer === SRGBTransfer ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR : extension.COMPRESSED_RGBA_ASTC_8x8_KHR; + if (p === RGBA_ASTC_10x5_Format) return transfer === SRGBTransfer ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR : extension.COMPRESSED_RGBA_ASTC_10x5_KHR; + if (p === RGBA_ASTC_10x6_Format) return transfer === SRGBTransfer ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR : extension.COMPRESSED_RGBA_ASTC_10x6_KHR; + if (p === RGBA_ASTC_10x8_Format) return transfer === SRGBTransfer ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR : extension.COMPRESSED_RGBA_ASTC_10x8_KHR; + if (p === RGBA_ASTC_10x10_Format) return transfer === SRGBTransfer ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR : extension.COMPRESSED_RGBA_ASTC_10x10_KHR; + if (p === RGBA_ASTC_12x10_Format) return transfer === SRGBTransfer ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR : extension.COMPRESSED_RGBA_ASTC_12x10_KHR; + if (p === RGBA_ASTC_12x12_Format) return transfer === SRGBTransfer ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR : extension.COMPRESSED_RGBA_ASTC_12x12_KHR; + } else { + return null; + } + } + if (p === RGBA_BPTC_Format || p === RGB_BPTC_SIGNED_Format || p === RGB_BPTC_UNSIGNED_Format) { + extension = extensions.get("EXT_texture_compression_bptc"); + if (extension !== null) { + if (p === RGBA_BPTC_Format) return transfer === SRGBTransfer ? extension.COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT : extension.COMPRESSED_RGBA_BPTC_UNORM_EXT; + if (p === RGB_BPTC_SIGNED_Format) return extension.COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT; + if (p === RGB_BPTC_UNSIGNED_Format) return extension.COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT; + } else { + return null; + } + } + if (p === RED_RGTC1_Format || p === SIGNED_RED_RGTC1_Format || p === RED_GREEN_RGTC2_Format || p === SIGNED_RED_GREEN_RGTC2_Format) { + extension = extensions.get("EXT_texture_compression_rgtc"); + if (extension !== null) { + if (p === RGBA_BPTC_Format) return extension.COMPRESSED_RED_RGTC1_EXT; + if (p === SIGNED_RED_RGTC1_Format) return extension.COMPRESSED_SIGNED_RED_RGTC1_EXT; + if (p === RED_GREEN_RGTC2_Format) return extension.COMPRESSED_RED_GREEN_RGTC2_EXT; + if (p === SIGNED_RED_GREEN_RGTC2_Format) return extension.COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT; + } else { + return null; + } + } + if (p === UnsignedInt248Type) return gl.UNSIGNED_INT_24_8; + return gl[p] !== void 0 ? gl[p] : null; + } + return { convert }; +} +var ArrayCamera = class extends PerspectiveCamera { + constructor(array = []) { + super(); + this.isArrayCamera = true; + this.cameras = array; + } +}; +var Group = class extends Object3D { + constructor() { + super(); + this.isGroup = true; + this.type = "Group"; + } +}; +var _moveEvent = { type: "move" }; +var WebXRController = class { + constructor() { + this._targetRay = null; + this._grip = null; + this._hand = null; + } + getHandSpace() { + if (this._hand === null) { + this._hand = new Group(); + this._hand.matrixAutoUpdate = false; + this._hand.visible = false; + this._hand.joints = {}; + this._hand.inputState = { pinching: false }; + } + return this._hand; + } + getTargetRaySpace() { + if (this._targetRay === null) { + this._targetRay = new Group(); + this._targetRay.matrixAutoUpdate = false; + this._targetRay.visible = false; + this._targetRay.hasLinearVelocity = false; + this._targetRay.linearVelocity = new Vector3(); + this._targetRay.hasAngularVelocity = false; + this._targetRay.angularVelocity = new Vector3(); + } + return this._targetRay; + } + getGripSpace() { + if (this._grip === null) { + this._grip = new Group(); + this._grip.matrixAutoUpdate = false; + this._grip.visible = false; + this._grip.hasLinearVelocity = false; + this._grip.linearVelocity = new Vector3(); + this._grip.hasAngularVelocity = false; + this._grip.angularVelocity = new Vector3(); + } + return this._grip; + } + dispatchEvent(event) { + if (this._targetRay !== null) { + this._targetRay.dispatchEvent(event); + } + if (this._grip !== null) { + this._grip.dispatchEvent(event); + } + if (this._hand !== null) { + this._hand.dispatchEvent(event); + } + return this; + } + connect(inputSource) { + if (inputSource && inputSource.hand) { + const hand = this._hand; + if (hand) { + for (const inputjoint of inputSource.hand.values()) { + this._getHandJoint(hand, inputjoint); + } + } + } + this.dispatchEvent({ type: "connected", data: inputSource }); + return this; + } + disconnect(inputSource) { + this.dispatchEvent({ type: "disconnected", data: inputSource }); + if (this._targetRay !== null) { + this._targetRay.visible = false; + } + if (this._grip !== null) { + this._grip.visible = false; + } + if (this._hand !== null) { + this._hand.visible = false; + } + return this; + } + update(inputSource, frame, referenceSpace) { + let inputPose = null; + let gripPose = null; + let handPose = null; + const targetRay = this._targetRay; + const grip = this._grip; + const hand = this._hand; + if (inputSource && frame.session.visibilityState !== "visible-blurred") { + if (hand && inputSource.hand) { + handPose = true; + for (const inputjoint of inputSource.hand.values()) { + const jointPose = frame.getJointPose(inputjoint, referenceSpace); + const joint = this._getHandJoint(hand, inputjoint); + if (jointPose !== null) { + joint.matrix.fromArray(jointPose.transform.matrix); + joint.matrix.decompose(joint.position, joint.rotation, joint.scale); + joint.matrixWorldNeedsUpdate = true; + joint.jointRadius = jointPose.radius; + } + joint.visible = jointPose !== null; + } + const indexTip = hand.joints["index-finger-tip"]; + const thumbTip = hand.joints["thumb-tip"]; + const distance = indexTip.position.distanceTo(thumbTip.position); + const distanceToPinch = 0.02; + const threshold = 5e-3; + if (hand.inputState.pinching && distance > distanceToPinch + threshold) { + hand.inputState.pinching = false; + this.dispatchEvent({ + type: "pinchend", + handedness: inputSource.handedness, + target: this + }); + } else if (!hand.inputState.pinching && distance <= distanceToPinch - threshold) { + hand.inputState.pinching = true; + this.dispatchEvent({ + type: "pinchstart", + handedness: inputSource.handedness, + target: this + }); + } + } else { + if (grip !== null && inputSource.gripSpace) { + gripPose = frame.getPose(inputSource.gripSpace, referenceSpace); + if (gripPose !== null) { + grip.matrix.fromArray(gripPose.transform.matrix); + grip.matrix.decompose(grip.position, grip.rotation, grip.scale); + grip.matrixWorldNeedsUpdate = true; + if (gripPose.linearVelocity) { + grip.hasLinearVelocity = true; + grip.linearVelocity.copy(gripPose.linearVelocity); + } else { + grip.hasLinearVelocity = false; + } + if (gripPose.angularVelocity) { + grip.hasAngularVelocity = true; + grip.angularVelocity.copy(gripPose.angularVelocity); + } else { + grip.hasAngularVelocity = false; + } + } + } + } + if (targetRay !== null) { + inputPose = frame.getPose(inputSource.targetRaySpace, referenceSpace); + if (inputPose === null && gripPose !== null) { + inputPose = gripPose; + } + if (inputPose !== null) { + targetRay.matrix.fromArray(inputPose.transform.matrix); + targetRay.matrix.decompose(targetRay.position, targetRay.rotation, targetRay.scale); + targetRay.matrixWorldNeedsUpdate = true; + if (inputPose.linearVelocity) { + targetRay.hasLinearVelocity = true; + targetRay.linearVelocity.copy(inputPose.linearVelocity); + } else { + targetRay.hasLinearVelocity = false; + } + if (inputPose.angularVelocity) { + targetRay.hasAngularVelocity = true; + targetRay.angularVelocity.copy(inputPose.angularVelocity); + } else { + targetRay.hasAngularVelocity = false; + } + this.dispatchEvent(_moveEvent); + } + } + } + if (targetRay !== null) { + targetRay.visible = inputPose !== null; + } + if (grip !== null) { + grip.visible = gripPose !== null; + } + if (hand !== null) { + hand.visible = handPose !== null; + } + return this; + } + // private method + _getHandJoint(hand, inputjoint) { + if (hand.joints[inputjoint.jointName] === void 0) { + const joint = new Group(); + joint.matrixAutoUpdate = false; + joint.visible = false; + hand.joints[inputjoint.jointName] = joint; + hand.add(joint); + } + return hand.joints[inputjoint.jointName]; + } +}; +var _occlusion_vertex = ` +void main() { + + gl_Position = vec4( position, 1.0 ); + +}`; +var _occlusion_fragment = ` +uniform sampler2DArray depthColor; +uniform float depthWidth; +uniform float depthHeight; + +void main() { + + vec2 coord = vec2( gl_FragCoord.x / depthWidth, gl_FragCoord.y / depthHeight ); + + if ( coord.x >= 1.0 ) { + + gl_FragDepth = texture( depthColor, vec3( coord.x - 1.0, coord.y, 1 ) ).r; + + } else { + + gl_FragDepth = texture( depthColor, vec3( coord.x, coord.y, 0 ) ).r; + + } + +}`; +var WebXRDepthSensing = class { + constructor() { + this.texture = null; + this.mesh = null; + this.depthNear = 0; + this.depthFar = 0; + } + init(renderer, depthData, renderState) { + if (this.texture === null) { + const texture = new Texture(); + const texProps = renderer.properties.get(texture); + texProps.__webglTexture = depthData.texture; + if (depthData.depthNear != renderState.depthNear || depthData.depthFar != renderState.depthFar) { + this.depthNear = depthData.depthNear; + this.depthFar = depthData.depthFar; + } + this.texture = texture; + } + } + render(renderer, cameraXR) { + if (this.texture !== null) { + if (this.mesh === null) { + const viewport = cameraXR.cameras[0].viewport; + const material = new ShaderMaterial({ + vertexShader: _occlusion_vertex, + fragmentShader: _occlusion_fragment, + uniforms: { + depthColor: { value: this.texture }, + depthWidth: { value: viewport.z }, + depthHeight: { value: viewport.w } + } + }); + this.mesh = new Mesh(new PlaneGeometry(20, 20), material); + } + renderer.render(this.mesh, cameraXR); + } + } + reset() { + this.texture = null; + this.mesh = null; + } +}; +var WebXRManager = class extends EventDispatcher { + constructor(renderer, gl) { + super(); + const scope = this; + let session = null; + let framebufferScaleFactor = 1; + let referenceSpace = null; + let referenceSpaceType = "local-floor"; + let foveation = 1; + let customReferenceSpace = null; + let pose = null; + let glBinding = null; + let glProjLayer = null; + let glBaseLayer = null; + let xrFrame = null; + const depthSensing = new WebXRDepthSensing(); + const attributes = gl.getContextAttributes(); + let initialRenderTarget = null; + let newRenderTarget = null; + const controllers = []; + const controllerInputSources = []; + const currentSize = new Vector2(); + let currentPixelRatio = null; + const cameraL = new PerspectiveCamera(); + cameraL.layers.enable(1); + cameraL.viewport = new Vector4(); + const cameraR = new PerspectiveCamera(); + cameraR.layers.enable(2); + cameraR.viewport = new Vector4(); + const cameras = [cameraL, cameraR]; + const cameraXR = new ArrayCamera(); + cameraXR.layers.enable(1); + cameraXR.layers.enable(2); + let _currentDepthNear = null; + let _currentDepthFar = null; + this.cameraAutoUpdate = true; + this.enabled = false; + this.isPresenting = false; + this.getController = function(index) { + let controller = controllers[index]; + if (controller === void 0) { + controller = new WebXRController(); + controllers[index] = controller; + } + return controller.getTargetRaySpace(); + }; + this.getControllerGrip = function(index) { + let controller = controllers[index]; + if (controller === void 0) { + controller = new WebXRController(); + controllers[index] = controller; + } + return controller.getGripSpace(); + }; + this.getHand = function(index) { + let controller = controllers[index]; + if (controller === void 0) { + controller = new WebXRController(); + controllers[index] = controller; + } + return controller.getHandSpace(); + }; + function onSessionEvent(event) { + const controllerIndex = controllerInputSources.indexOf(event.inputSource); + if (controllerIndex === -1) { + return; + } + const controller = controllers[controllerIndex]; + if (controller !== void 0) { + controller.update(event.inputSource, event.frame, customReferenceSpace || referenceSpace); + controller.dispatchEvent({ type: event.type, data: event.inputSource }); + } + } + function onSessionEnd() { + session.removeEventListener("select", onSessionEvent); + session.removeEventListener("selectstart", onSessionEvent); + session.removeEventListener("selectend", onSessionEvent); + session.removeEventListener("squeeze", onSessionEvent); + session.removeEventListener("squeezestart", onSessionEvent); + session.removeEventListener("squeezeend", onSessionEvent); + session.removeEventListener("end", onSessionEnd); + session.removeEventListener("inputsourceschange", onInputSourcesChange); + for (let i = 0; i < controllers.length; i++) { + const inputSource = controllerInputSources[i]; + if (inputSource === null) continue; + controllerInputSources[i] = null; + controllers[i].disconnect(inputSource); + } + _currentDepthNear = null; + _currentDepthFar = null; + depthSensing.reset(); + renderer.setRenderTarget(initialRenderTarget); + glBaseLayer = null; + glProjLayer = null; + glBinding = null; + session = null; + newRenderTarget = null; + animation.stop(); + scope.isPresenting = false; + renderer.setPixelRatio(currentPixelRatio); + renderer.setSize(currentSize.width, currentSize.height, false); + scope.dispatchEvent({ type: "sessionend" }); + } + this.setFramebufferScaleFactor = function(value) { + framebufferScaleFactor = value; + if (scope.isPresenting === true) { + console.warn("THREE.WebXRManager: Cannot change framebuffer scale while presenting."); + } + }; + this.setReferenceSpaceType = function(value) { + referenceSpaceType = value; + if (scope.isPresenting === true) { + console.warn("THREE.WebXRManager: Cannot change reference space type while presenting."); + } + }; + this.getReferenceSpace = function() { + return customReferenceSpace || referenceSpace; + }; + this.setReferenceSpace = function(space) { + customReferenceSpace = space; + }; + this.getBaseLayer = function() { + return glProjLayer !== null ? glProjLayer : glBaseLayer; + }; + this.getBinding = function() { + return glBinding; + }; + this.getFrame = function() { + return xrFrame; + }; + this.getSession = function() { + return session; + }; + this.setSession = async function(value) { + session = value; + if (session !== null) { + initialRenderTarget = renderer.getRenderTarget(); + session.addEventListener("select", onSessionEvent); + session.addEventListener("selectstart", onSessionEvent); + session.addEventListener("selectend", onSessionEvent); + session.addEventListener("squeeze", onSessionEvent); + session.addEventListener("squeezestart", onSessionEvent); + session.addEventListener("squeezeend", onSessionEvent); + session.addEventListener("end", onSessionEnd); + session.addEventListener("inputsourceschange", onInputSourcesChange); + if (attributes.xrCompatible !== true) { + await gl.makeXRCompatible(); + } + currentPixelRatio = renderer.getPixelRatio(); + renderer.getSize(currentSize); + if (session.renderState.layers === void 0) { + const layerInit = { + antialias: attributes.antialias, + alpha: true, + depth: attributes.depth, + stencil: attributes.stencil, + framebufferScaleFactor + }; + glBaseLayer = new XRWebGLLayer(session, gl, layerInit); + session.updateRenderState({ baseLayer: glBaseLayer }); + renderer.setPixelRatio(1); + renderer.setSize(glBaseLayer.framebufferWidth, glBaseLayer.framebufferHeight, false); + newRenderTarget = new WebGLRenderTarget( + glBaseLayer.framebufferWidth, + glBaseLayer.framebufferHeight, + { + format: RGBAFormat, + type: UnsignedByteType, + colorSpace: renderer.outputColorSpace, + stencilBuffer: attributes.stencil + } + ); + } else { + let depthFormat = null; + let depthType = null; + let glDepthFormat = null; + if (attributes.depth) { + glDepthFormat = attributes.stencil ? gl.DEPTH24_STENCIL8 : gl.DEPTH_COMPONENT24; + depthFormat = attributes.stencil ? DepthStencilFormat : DepthFormat; + depthType = attributes.stencil ? UnsignedInt248Type : UnsignedIntType; + } + const projectionlayerInit = { + colorFormat: gl.RGBA8, + depthFormat: glDepthFormat, + scaleFactor: framebufferScaleFactor + }; + glBinding = new XRWebGLBinding(session, gl); + glProjLayer = glBinding.createProjectionLayer(projectionlayerInit); + session.updateRenderState({ layers: [glProjLayer] }); + renderer.setPixelRatio(1); + renderer.setSize(glProjLayer.textureWidth, glProjLayer.textureHeight, false); + newRenderTarget = new WebGLRenderTarget( + glProjLayer.textureWidth, + glProjLayer.textureHeight, + { + format: RGBAFormat, + type: UnsignedByteType, + depthTexture: new DepthTexture(glProjLayer.textureWidth, glProjLayer.textureHeight, depthType, void 0, void 0, void 0, void 0, void 0, void 0, depthFormat), + stencilBuffer: attributes.stencil, + colorSpace: renderer.outputColorSpace, + samples: attributes.antialias ? 4 : 0 + } + ); + const renderTargetProperties = renderer.properties.get(newRenderTarget); + renderTargetProperties.__ignoreDepthValues = glProjLayer.ignoreDepthValues; + } + newRenderTarget.isXRRenderTarget = true; + this.setFoveation(foveation); + customReferenceSpace = null; + referenceSpace = await session.requestReferenceSpace(referenceSpaceType); + animation.setContext(session); + animation.start(); + scope.isPresenting = true; + scope.dispatchEvent({ type: "sessionstart" }); + } + }; + this.getEnvironmentBlendMode = function() { + if (session !== null) { + return session.environmentBlendMode; + } + }; + function onInputSourcesChange(event) { + for (let i = 0; i < event.removed.length; i++) { + const inputSource = event.removed[i]; + const index = controllerInputSources.indexOf(inputSource); + if (index >= 0) { + controllerInputSources[index] = null; + controllers[index].disconnect(inputSource); + } + } + for (let i = 0; i < event.added.length; i++) { + const inputSource = event.added[i]; + let controllerIndex = controllerInputSources.indexOf(inputSource); + if (controllerIndex === -1) { + for (let i2 = 0; i2 < controllers.length; i2++) { + if (i2 >= controllerInputSources.length) { + controllerInputSources.push(inputSource); + controllerIndex = i2; + break; + } else if (controllerInputSources[i2] === null) { + controllerInputSources[i2] = inputSource; + controllerIndex = i2; + break; + } + } + if (controllerIndex === -1) break; + } + const controller = controllers[controllerIndex]; + if (controller) { + controller.connect(inputSource); + } + } + } + const cameraLPos = new Vector3(); + const cameraRPos = new Vector3(); + function setProjectionFromUnion(camera, cameraL2, cameraR2) { + cameraLPos.setFromMatrixPosition(cameraL2.matrixWorld); + cameraRPos.setFromMatrixPosition(cameraR2.matrixWorld); + const ipd = cameraLPos.distanceTo(cameraRPos); + const projL = cameraL2.projectionMatrix.elements; + const projR = cameraR2.projectionMatrix.elements; + const near = projL[14] / (projL[10] - 1); + const far = projL[14] / (projL[10] + 1); + const topFov = (projL[9] + 1) / projL[5]; + const bottomFov = (projL[9] - 1) / projL[5]; + const leftFov = (projL[8] - 1) / projL[0]; + const rightFov = (projR[8] + 1) / projR[0]; + const left = near * leftFov; + const right2 = near * rightFov; + const zOffset = ipd / (-leftFov + rightFov); + const xOffset = zOffset * -leftFov; + cameraL2.matrixWorld.decompose(camera.position, camera.quaternion, camera.scale); + camera.translateX(xOffset); + camera.translateZ(zOffset); + camera.matrixWorld.compose(camera.position, camera.quaternion, camera.scale); + camera.matrixWorldInverse.copy(camera.matrixWorld).invert(); + const near2 = near + zOffset; + const far2 = far + zOffset; + const left2 = left - xOffset; + const right22 = right2 + (ipd - xOffset); + const top2 = topFov * far / far2 * near2; + const bottom2 = bottomFov * far / far2 * near2; + camera.projectionMatrix.makePerspective(left2, right22, top2, bottom2, near2, far2); + camera.projectionMatrixInverse.copy(camera.projectionMatrix).invert(); + } + function updateCamera(camera, parent) { + if (parent === null) { + camera.matrixWorld.copy(camera.matrix); + } else { + camera.matrixWorld.multiplyMatrices(parent.matrixWorld, camera.matrix); + } + camera.matrixWorldInverse.copy(camera.matrixWorld).invert(); + } + this.updateCamera = function(camera) { + if (session === null) return; + if (depthSensing.texture !== null) { + camera.near = depthSensing.depthNear; + camera.far = depthSensing.depthFar; + } + cameraXR.near = cameraR.near = cameraL.near = camera.near; + cameraXR.far = cameraR.far = cameraL.far = camera.far; + if (_currentDepthNear !== cameraXR.near || _currentDepthFar !== cameraXR.far) { + session.updateRenderState({ + depthNear: cameraXR.near, + depthFar: cameraXR.far + }); + _currentDepthNear = cameraXR.near; + _currentDepthFar = cameraXR.far; + cameraL.near = _currentDepthNear; + cameraL.far = _currentDepthFar; + cameraR.near = _currentDepthNear; + cameraR.far = _currentDepthFar; + cameraL.updateProjectionMatrix(); + cameraR.updateProjectionMatrix(); + camera.updateProjectionMatrix(); + } + const parent = camera.parent; + const cameras2 = cameraXR.cameras; + updateCamera(cameraXR, parent); + for (let i = 0; i < cameras2.length; i++) { + updateCamera(cameras2[i], parent); + } + if (cameras2.length === 2) { + setProjectionFromUnion(cameraXR, cameraL, cameraR); + } else { + cameraXR.projectionMatrix.copy(cameraL.projectionMatrix); + } + updateUserCamera(camera, cameraXR, parent); + }; + function updateUserCamera(camera, cameraXR2, parent) { + if (parent === null) { + camera.matrix.copy(cameraXR2.matrixWorld); + } else { + camera.matrix.copy(parent.matrixWorld); + camera.matrix.invert(); + camera.matrix.multiply(cameraXR2.matrixWorld); + } + camera.matrix.decompose(camera.position, camera.quaternion, camera.scale); + camera.updateMatrixWorld(true); + camera.projectionMatrix.copy(cameraXR2.projectionMatrix); + camera.projectionMatrixInverse.copy(cameraXR2.projectionMatrixInverse); + if (camera.isPerspectiveCamera) { + camera.fov = RAD2DEG * 2 * Math.atan(1 / camera.projectionMatrix.elements[5]); + camera.zoom = 1; + } + } + this.getCamera = function() { + return cameraXR; + }; + this.getFoveation = function() { + if (glProjLayer === null && glBaseLayer === null) { + return void 0; + } + return foveation; + }; + this.setFoveation = function(value) { + foveation = value; + if (glProjLayer !== null) { + glProjLayer.fixedFoveation = value; + } + if (glBaseLayer !== null && glBaseLayer.fixedFoveation !== void 0) { + glBaseLayer.fixedFoveation = value; + } + }; + this.hasDepthSensing = function() { + return depthSensing.texture !== null; + }; + let onAnimationFrameCallback = null; + function onAnimationFrame(time, frame) { + pose = frame.getViewerPose(customReferenceSpace || referenceSpace); + xrFrame = frame; + if (pose !== null) { + const views = pose.views; + if (glBaseLayer !== null) { + renderer.setRenderTargetFramebuffer(newRenderTarget, glBaseLayer.framebuffer); + renderer.setRenderTarget(newRenderTarget); + } + let cameraXRNeedsUpdate = false; + if (views.length !== cameraXR.cameras.length) { + cameraXR.cameras.length = 0; + cameraXRNeedsUpdate = true; + } + for (let i = 0; i < views.length; i++) { + const view = views[i]; + let viewport = null; + if (glBaseLayer !== null) { + viewport = glBaseLayer.getViewport(view); + } else { + const glSubImage = glBinding.getViewSubImage(glProjLayer, view); + viewport = glSubImage.viewport; + if (i === 0) { + renderer.setRenderTargetTextures( + newRenderTarget, + glSubImage.colorTexture, + glProjLayer.ignoreDepthValues ? void 0 : glSubImage.depthStencilTexture + ); + renderer.setRenderTarget(newRenderTarget); + } + } + let camera = cameras[i]; + if (camera === void 0) { + camera = new PerspectiveCamera(); + camera.layers.enable(i); + camera.viewport = new Vector4(); + cameras[i] = camera; + } + camera.matrix.fromArray(view.transform.matrix); + camera.matrix.decompose(camera.position, camera.quaternion, camera.scale); + camera.projectionMatrix.fromArray(view.projectionMatrix); + camera.projectionMatrixInverse.copy(camera.projectionMatrix).invert(); + camera.viewport.set(viewport.x, viewport.y, viewport.width, viewport.height); + if (i === 0) { + cameraXR.matrix.copy(camera.matrix); + cameraXR.matrix.decompose(cameraXR.position, cameraXR.quaternion, cameraXR.scale); + } + if (cameraXRNeedsUpdate === true) { + cameraXR.cameras.push(camera); + } + } + const enabledFeatures = session.enabledFeatures; + if (enabledFeatures && enabledFeatures.includes("depth-sensing")) { + const depthData = glBinding.getDepthInformation(views[0]); + if (depthData && depthData.isValid && depthData.texture) { + depthSensing.init(renderer, depthData, session.renderState); + } + } + } + for (let i = 0; i < controllers.length; i++) { + const inputSource = controllerInputSources[i]; + const controller = controllers[i]; + if (inputSource !== null && controller !== void 0) { + controller.update(inputSource, frame, customReferenceSpace || referenceSpace); + } + } + depthSensing.render(renderer, cameraXR); + if (onAnimationFrameCallback) onAnimationFrameCallback(time, frame); + if (frame.detectedPlanes) { + scope.dispatchEvent({ type: "planesdetected", data: frame }); + } + xrFrame = null; + } + const animation = new WebGLAnimation(); + animation.setAnimationLoop(onAnimationFrame); + this.setAnimationLoop = function(callback) { + onAnimationFrameCallback = callback; + }; + this.dispose = function() { + }; + } +}; +var _e1 = /* @__PURE__ */ new Euler(); +var _m1 = /* @__PURE__ */ new Matrix4(); +function WebGLMaterials(renderer, properties) { + function refreshTransformUniform(map, uniform) { + if (map.matrixAutoUpdate === true) { + map.updateMatrix(); + } + uniform.value.copy(map.matrix); + } + function refreshFogUniforms(uniforms, fog) { + fog.color.getRGB(uniforms.fogColor.value, getUnlitUniformColorSpace(renderer)); + if (fog.isFog) { + uniforms.fogNear.value = fog.near; + uniforms.fogFar.value = fog.far; + } else if (fog.isFogExp2) { + uniforms.fogDensity.value = fog.density; + } + } + function refreshMaterialUniforms(uniforms, material, pixelRatio, height, transmissionRenderTarget) { + if (material.isMeshBasicMaterial) { + refreshUniformsCommon(uniforms, material); + } else if (material.isMeshLambertMaterial) { + refreshUniformsCommon(uniforms, material); + } else if (material.isMeshToonMaterial) { + refreshUniformsCommon(uniforms, material); + refreshUniformsToon(uniforms, material); + } else if (material.isMeshPhongMaterial) { + refreshUniformsCommon(uniforms, material); + refreshUniformsPhong(uniforms, material); + } else if (material.isMeshStandardMaterial) { + refreshUniformsCommon(uniforms, material); + refreshUniformsStandard(uniforms, material); + if (material.isMeshPhysicalMaterial) { + refreshUniformsPhysical(uniforms, material, transmissionRenderTarget); + } + } else if (material.isMeshMatcapMaterial) { + refreshUniformsCommon(uniforms, material); + refreshUniformsMatcap(uniforms, material); + } else if (material.isMeshDepthMaterial) { + refreshUniformsCommon(uniforms, material); + } else if (material.isMeshDistanceMaterial) { + refreshUniformsCommon(uniforms, material); + refreshUniformsDistance(uniforms, material); + } else if (material.isMeshNormalMaterial) { + refreshUniformsCommon(uniforms, material); + } else if (material.isLineBasicMaterial) { + refreshUniformsLine(uniforms, material); + if (material.isLineDashedMaterial) { + refreshUniformsDash(uniforms, material); + } + } else if (material.isPointsMaterial) { + refreshUniformsPoints(uniforms, material, pixelRatio, height); + } else if (material.isSpriteMaterial) { + refreshUniformsSprites(uniforms, material); + } else if (material.isShadowMaterial) { + uniforms.color.value.copy(material.color); + uniforms.opacity.value = material.opacity; + } else if (material.isShaderMaterial) { + material.uniformsNeedUpdate = false; + } + } + function refreshUniformsCommon(uniforms, material) { + uniforms.opacity.value = material.opacity; + if (material.color) { + uniforms.diffuse.value.copy(material.color); + } + if (material.emissive) { + uniforms.emissive.value.copy(material.emissive).multiplyScalar(material.emissiveIntensity); + } + if (material.map) { + uniforms.map.value = material.map; + refreshTransformUniform(material.map, uniforms.mapTransform); + } + if (material.alphaMap) { + uniforms.alphaMap.value = material.alphaMap; + refreshTransformUniform(material.alphaMap, uniforms.alphaMapTransform); + } + if (material.bumpMap) { + uniforms.bumpMap.value = material.bumpMap; + refreshTransformUniform(material.bumpMap, uniforms.bumpMapTransform); + uniforms.bumpScale.value = material.bumpScale; + if (material.side === BackSide) { + uniforms.bumpScale.value *= -1; + } + } + if (material.normalMap) { + uniforms.normalMap.value = material.normalMap; + refreshTransformUniform(material.normalMap, uniforms.normalMapTransform); + uniforms.normalScale.value.copy(material.normalScale); + if (material.side === BackSide) { + uniforms.normalScale.value.negate(); + } + } + if (material.displacementMap) { + uniforms.displacementMap.value = material.displacementMap; + refreshTransformUniform(material.displacementMap, uniforms.displacementMapTransform); + uniforms.displacementScale.value = material.displacementScale; + uniforms.displacementBias.value = material.displacementBias; + } + if (material.emissiveMap) { + uniforms.emissiveMap.value = material.emissiveMap; + refreshTransformUniform(material.emissiveMap, uniforms.emissiveMapTransform); + } + if (material.specularMap) { + uniforms.specularMap.value = material.specularMap; + refreshTransformUniform(material.specularMap, uniforms.specularMapTransform); + } + if (material.alphaTest > 0) { + uniforms.alphaTest.value = material.alphaTest; + } + const materialProperties = properties.get(material); + const envMap = materialProperties.envMap; + const envMapRotation = materialProperties.envMapRotation; + if (envMap) { + uniforms.envMap.value = envMap; + _e1.copy(envMapRotation); + _e1.x *= -1; + _e1.y *= -1; + _e1.z *= -1; + if (envMap.isCubeTexture && envMap.isRenderTargetTexture === false) { + _e1.y *= -1; + _e1.z *= -1; + } + uniforms.envMapRotation.value.setFromMatrix4(_m1.makeRotationFromEuler(_e1)); + uniforms.flipEnvMap.value = envMap.isCubeTexture && envMap.isRenderTargetTexture === false ? -1 : 1; + uniforms.reflectivity.value = material.reflectivity; + uniforms.ior.value = material.ior; + uniforms.refractionRatio.value = material.refractionRatio; + } + if (material.lightMap) { + uniforms.lightMap.value = material.lightMap; + const scaleFactor = renderer._useLegacyLights === true ? Math.PI : 1; + uniforms.lightMapIntensity.value = material.lightMapIntensity * scaleFactor; + refreshTransformUniform(material.lightMap, uniforms.lightMapTransform); + } + if (material.aoMap) { + uniforms.aoMap.value = material.aoMap; + uniforms.aoMapIntensity.value = material.aoMapIntensity; + refreshTransformUniform(material.aoMap, uniforms.aoMapTransform); + } + } + function refreshUniformsLine(uniforms, material) { + uniforms.diffuse.value.copy(material.color); + uniforms.opacity.value = material.opacity; + if (material.map) { + uniforms.map.value = material.map; + refreshTransformUniform(material.map, uniforms.mapTransform); + } + } + function refreshUniformsDash(uniforms, material) { + uniforms.dashSize.value = material.dashSize; + uniforms.totalSize.value = material.dashSize + material.gapSize; + uniforms.scale.value = material.scale; + } + function refreshUniformsPoints(uniforms, material, pixelRatio, height) { + uniforms.diffuse.value.copy(material.color); + uniforms.opacity.value = material.opacity; + uniforms.size.value = material.size * pixelRatio; + uniforms.scale.value = height * 0.5; + if (material.map) { + uniforms.map.value = material.map; + refreshTransformUniform(material.map, uniforms.uvTransform); + } + if (material.alphaMap) { + uniforms.alphaMap.value = material.alphaMap; + refreshTransformUniform(material.alphaMap, uniforms.alphaMapTransform); + } + if (material.alphaTest > 0) { + uniforms.alphaTest.value = material.alphaTest; + } + } + function refreshUniformsSprites(uniforms, material) { + uniforms.diffuse.value.copy(material.color); + uniforms.opacity.value = material.opacity; + uniforms.rotation.value = material.rotation; + if (material.map) { + uniforms.map.value = material.map; + refreshTransformUniform(material.map, uniforms.mapTransform); + } + if (material.alphaMap) { + uniforms.alphaMap.value = material.alphaMap; + refreshTransformUniform(material.alphaMap, uniforms.alphaMapTransform); + } + if (material.alphaTest > 0) { + uniforms.alphaTest.value = material.alphaTest; + } + } + function refreshUniformsPhong(uniforms, material) { + uniforms.specular.value.copy(material.specular); + uniforms.shininess.value = Math.max(material.shininess, 1e-4); + } + function refreshUniformsToon(uniforms, material) { + if (material.gradientMap) { + uniforms.gradientMap.value = material.gradientMap; + } + } + function refreshUniformsStandard(uniforms, material) { + uniforms.metalness.value = material.metalness; + if (material.metalnessMap) { + uniforms.metalnessMap.value = material.metalnessMap; + refreshTransformUniform(material.metalnessMap, uniforms.metalnessMapTransform); + } + uniforms.roughness.value = material.roughness; + if (material.roughnessMap) { + uniforms.roughnessMap.value = material.roughnessMap; + refreshTransformUniform(material.roughnessMap, uniforms.roughnessMapTransform); + } + if (material.envMap) { + uniforms.envMapIntensity.value = material.envMapIntensity; + } + } + function refreshUniformsPhysical(uniforms, material, transmissionRenderTarget) { + uniforms.ior.value = material.ior; + if (material.sheen > 0) { + uniforms.sheenColor.value.copy(material.sheenColor).multiplyScalar(material.sheen); + uniforms.sheenRoughness.value = material.sheenRoughness; + if (material.sheenColorMap) { + uniforms.sheenColorMap.value = material.sheenColorMap; + refreshTransformUniform(material.sheenColorMap, uniforms.sheenColorMapTransform); + } + if (material.sheenRoughnessMap) { + uniforms.sheenRoughnessMap.value = material.sheenRoughnessMap; + refreshTransformUniform(material.sheenRoughnessMap, uniforms.sheenRoughnessMapTransform); + } + } + if (material.clearcoat > 0) { + uniforms.clearcoat.value = material.clearcoat; + uniforms.clearcoatRoughness.value = material.clearcoatRoughness; + if (material.clearcoatMap) { + uniforms.clearcoatMap.value = material.clearcoatMap; + refreshTransformUniform(material.clearcoatMap, uniforms.clearcoatMapTransform); + } + if (material.clearcoatRoughnessMap) { + uniforms.clearcoatRoughnessMap.value = material.clearcoatRoughnessMap; + refreshTransformUniform(material.clearcoatRoughnessMap, uniforms.clearcoatRoughnessMapTransform); + } + if (material.clearcoatNormalMap) { + uniforms.clearcoatNormalMap.value = material.clearcoatNormalMap; + refreshTransformUniform(material.clearcoatNormalMap, uniforms.clearcoatNormalMapTransform); + uniforms.clearcoatNormalScale.value.copy(material.clearcoatNormalScale); + if (material.side === BackSide) { + uniforms.clearcoatNormalScale.value.negate(); + } + } + } + if (material.iridescence > 0) { + uniforms.iridescence.value = material.iridescence; + uniforms.iridescenceIOR.value = material.iridescenceIOR; + uniforms.iridescenceThicknessMinimum.value = material.iridescenceThicknessRange[0]; + uniforms.iridescenceThicknessMaximum.value = material.iridescenceThicknessRange[1]; + if (material.iridescenceMap) { + uniforms.iridescenceMap.value = material.iridescenceMap; + refreshTransformUniform(material.iridescenceMap, uniforms.iridescenceMapTransform); + } + if (material.iridescenceThicknessMap) { + uniforms.iridescenceThicknessMap.value = material.iridescenceThicknessMap; + refreshTransformUniform(material.iridescenceThicknessMap, uniforms.iridescenceThicknessMapTransform); + } + } + if (material.transmission > 0) { + uniforms.transmission.value = material.transmission; + uniforms.transmissionSamplerMap.value = transmissionRenderTarget.texture; + uniforms.transmissionSamplerSize.value.set(transmissionRenderTarget.width, transmissionRenderTarget.height); + if (material.transmissionMap) { + uniforms.transmissionMap.value = material.transmissionMap; + refreshTransformUniform(material.transmissionMap, uniforms.transmissionMapTransform); + } + uniforms.thickness.value = material.thickness; + if (material.thicknessMap) { + uniforms.thicknessMap.value = material.thicknessMap; + refreshTransformUniform(material.thicknessMap, uniforms.thicknessMapTransform); + } + uniforms.attenuationDistance.value = material.attenuationDistance; + uniforms.attenuationColor.value.copy(material.attenuationColor); + } + if (material.anisotropy > 0) { + uniforms.anisotropyVector.value.set(material.anisotropy * Math.cos(material.anisotropyRotation), material.anisotropy * Math.sin(material.anisotropyRotation)); + if (material.anisotropyMap) { + uniforms.anisotropyMap.value = material.anisotropyMap; + refreshTransformUniform(material.anisotropyMap, uniforms.anisotropyMapTransform); + } + } + uniforms.specularIntensity.value = material.specularIntensity; + uniforms.specularColor.value.copy(material.specularColor); + if (material.specularColorMap) { + uniforms.specularColorMap.value = material.specularColorMap; + refreshTransformUniform(material.specularColorMap, uniforms.specularColorMapTransform); + } + if (material.specularIntensityMap) { + uniforms.specularIntensityMap.value = material.specularIntensityMap; + refreshTransformUniform(material.specularIntensityMap, uniforms.specularIntensityMapTransform); + } + } + function refreshUniformsMatcap(uniforms, material) { + if (material.matcap) { + uniforms.matcap.value = material.matcap; + } + } + function refreshUniformsDistance(uniforms, material) { + const light = properties.get(material).light; + uniforms.referencePosition.value.setFromMatrixPosition(light.matrixWorld); + uniforms.nearDistance.value = light.shadow.camera.near; + uniforms.farDistance.value = light.shadow.camera.far; + } + return { + refreshFogUniforms, + refreshMaterialUniforms + }; +} +function WebGLUniformsGroups(gl, info, capabilities, state) { + let buffers = {}; + let updateList = {}; + let allocatedBindingPoints = []; + const maxBindingPoints = gl.getParameter(gl.MAX_UNIFORM_BUFFER_BINDINGS); + function bind(uniformsGroup, program) { + const webglProgram = program.program; + state.uniformBlockBinding(uniformsGroup, webglProgram); + } + function update(uniformsGroup, program) { + let buffer = buffers[uniformsGroup.id]; + if (buffer === void 0) { + prepareUniformsGroup(uniformsGroup); + buffer = createBuffer(uniformsGroup); + buffers[uniformsGroup.id] = buffer; + uniformsGroup.addEventListener("dispose", onUniformsGroupsDispose); + } + const webglProgram = program.program; + state.updateUBOMapping(uniformsGroup, webglProgram); + const frame = info.render.frame; + if (updateList[uniformsGroup.id] !== frame) { + updateBufferData(uniformsGroup); + updateList[uniformsGroup.id] = frame; + } + } + function createBuffer(uniformsGroup) { + const bindingPointIndex = allocateBindingPointIndex(); + uniformsGroup.__bindingPointIndex = bindingPointIndex; + const buffer = gl.createBuffer(); + const size = uniformsGroup.__size; + const usage = uniformsGroup.usage; + gl.bindBuffer(gl.UNIFORM_BUFFER, buffer); + gl.bufferData(gl.UNIFORM_BUFFER, size, usage); + gl.bindBuffer(gl.UNIFORM_BUFFER, null); + gl.bindBufferBase(gl.UNIFORM_BUFFER, bindingPointIndex, buffer); + return buffer; + } + function allocateBindingPointIndex() { + for (let i = 0; i < maxBindingPoints; i++) { + if (allocatedBindingPoints.indexOf(i) === -1) { + allocatedBindingPoints.push(i); + return i; + } + } + console.error("THREE.WebGLRenderer: Maximum number of simultaneously usable uniforms groups reached."); + return 0; + } + function updateBufferData(uniformsGroup) { + const buffer = buffers[uniformsGroup.id]; + const uniforms = uniformsGroup.uniforms; + const cache = uniformsGroup.__cache; + gl.bindBuffer(gl.UNIFORM_BUFFER, buffer); + for (let i = 0, il = uniforms.length; i < il; i++) { + const uniformArray = Array.isArray(uniforms[i]) ? uniforms[i] : [uniforms[i]]; + for (let j = 0, jl = uniformArray.length; j < jl; j++) { + const uniform = uniformArray[j]; + if (hasUniformChanged(uniform, i, j, cache) === true) { + const offset = uniform.__offset; + const values = Array.isArray(uniform.value) ? uniform.value : [uniform.value]; + let arrayOffset = 0; + for (let k = 0; k < values.length; k++) { + const value = values[k]; + const info2 = getUniformSize(value); + if (typeof value === "number" || typeof value === "boolean") { + uniform.__data[0] = value; + gl.bufferSubData(gl.UNIFORM_BUFFER, offset + arrayOffset, uniform.__data); + } else if (value.isMatrix3) { + uniform.__data[0] = value.elements[0]; + uniform.__data[1] = value.elements[1]; + uniform.__data[2] = value.elements[2]; + uniform.__data[3] = 0; + uniform.__data[4] = value.elements[3]; + uniform.__data[5] = value.elements[4]; + uniform.__data[6] = value.elements[5]; + uniform.__data[7] = 0; + uniform.__data[8] = value.elements[6]; + uniform.__data[9] = value.elements[7]; + uniform.__data[10] = value.elements[8]; + uniform.__data[11] = 0; + } else { + value.toArray(uniform.__data, arrayOffset); + arrayOffset += info2.storage / Float32Array.BYTES_PER_ELEMENT; + } + } + gl.bufferSubData(gl.UNIFORM_BUFFER, offset, uniform.__data); + } + } + } + gl.bindBuffer(gl.UNIFORM_BUFFER, null); + } + function hasUniformChanged(uniform, index, indexArray, cache) { + const value = uniform.value; + const indexString = index + "_" + indexArray; + if (cache[indexString] === void 0) { + if (typeof value === "number" || typeof value === "boolean") { + cache[indexString] = value; + } else { + cache[indexString] = value.clone(); + } + return true; + } else { + const cachedObject = cache[indexString]; + if (typeof value === "number" || typeof value === "boolean") { + if (cachedObject !== value) { + cache[indexString] = value; + return true; + } + } else { + if (cachedObject.equals(value) === false) { + cachedObject.copy(value); + return true; + } + } + } + return false; + } + function prepareUniformsGroup(uniformsGroup) { + const uniforms = uniformsGroup.uniforms; + let offset = 0; + const chunkSize = 16; + for (let i = 0, l = uniforms.length; i < l; i++) { + const uniformArray = Array.isArray(uniforms[i]) ? uniforms[i] : [uniforms[i]]; + for (let j = 0, jl = uniformArray.length; j < jl; j++) { + const uniform = uniformArray[j]; + const values = Array.isArray(uniform.value) ? uniform.value : [uniform.value]; + for (let k = 0, kl = values.length; k < kl; k++) { + const value = values[k]; + const info2 = getUniformSize(value); + const chunkOffsetUniform = offset % chunkSize; + if (chunkOffsetUniform !== 0 && chunkSize - chunkOffsetUniform < info2.boundary) { + offset += chunkSize - chunkOffsetUniform; + } + uniform.__data = new Float32Array(info2.storage / Float32Array.BYTES_PER_ELEMENT); + uniform.__offset = offset; + offset += info2.storage; + } + } + } + const chunkOffset = offset % chunkSize; + if (chunkOffset > 0) offset += chunkSize - chunkOffset; + uniformsGroup.__size = offset; + uniformsGroup.__cache = {}; + return this; + } + function getUniformSize(value) { + const info2 = { + boundary: 0, + // bytes + storage: 0 + // bytes + }; + if (typeof value === "number" || typeof value === "boolean") { + info2.boundary = 4; + info2.storage = 4; + } else if (value.isVector2) { + info2.boundary = 8; + info2.storage = 8; + } else if (value.isVector3 || value.isColor) { + info2.boundary = 16; + info2.storage = 12; + } else if (value.isVector4) { + info2.boundary = 16; + info2.storage = 16; + } else if (value.isMatrix3) { + info2.boundary = 48; + info2.storage = 48; + } else if (value.isMatrix4) { + info2.boundary = 64; + info2.storage = 64; + } else if (value.isTexture) { + console.warn("THREE.WebGLRenderer: Texture samplers can not be part of an uniforms group."); + } else { + console.warn("THREE.WebGLRenderer: Unsupported uniform value type.", value); + } + return info2; + } + function onUniformsGroupsDispose(event) { + const uniformsGroup = event.target; + uniformsGroup.removeEventListener("dispose", onUniformsGroupsDispose); + const index = allocatedBindingPoints.indexOf(uniformsGroup.__bindingPointIndex); + allocatedBindingPoints.splice(index, 1); + gl.deleteBuffer(buffers[uniformsGroup.id]); + delete buffers[uniformsGroup.id]; + delete updateList[uniformsGroup.id]; + } + function dispose() { + for (const id in buffers) { + gl.deleteBuffer(buffers[id]); + } + allocatedBindingPoints = []; + buffers = {}; + updateList = {}; + } + return { + bind, + update, + dispose + }; +} +var WebGLRenderer = class { + constructor(parameters = {}) { + const { + canvas = createCanvasElement(), + context = null, + depth = true, + stencil = false, + alpha = false, + antialias = false, + premultipliedAlpha = true, + preserveDrawingBuffer = false, + powerPreference = "default", + failIfMajorPerformanceCaveat = false + } = parameters; + this.isWebGLRenderer = true; + let _alpha; + if (context !== null) { + if (typeof WebGLRenderingContext !== "undefined" && context instanceof WebGLRenderingContext) { + throw new Error("THREE.WebGLRenderer: WebGL 1 is not supported since r163."); + } + _alpha = context.getContextAttributes().alpha; + } else { + _alpha = alpha; + } + const uintClearColor = new Uint32Array(4); + const intClearColor = new Int32Array(4); + let currentRenderList = null; + let currentRenderState = null; + const renderListStack = []; + const renderStateStack = []; + this.domElement = canvas; + this.debug = { + /** + * Enables error checking and reporting when shader programs are being compiled + * @type {boolean} + */ + checkShaderErrors: true, + /** + * Callback for custom error reporting. + * @type {?Function} + */ + onShaderError: null + }; + this.autoClear = true; + this.autoClearColor = true; + this.autoClearDepth = true; + this.autoClearStencil = true; + this.sortObjects = true; + this.clippingPlanes = []; + this.localClippingEnabled = false; + this._outputColorSpace = SRGBColorSpace; + this._useLegacyLights = false; + this.toneMapping = NoToneMapping; + this.toneMappingExposure = 1; + const _this = this; + let _isContextLost = false; + let _currentActiveCubeFace = 0; + let _currentActiveMipmapLevel = 0; + let _currentRenderTarget = null; + let _currentMaterialId = -1; + let _currentCamera = null; + const _currentViewport = new Vector4(); + const _currentScissor = new Vector4(); + let _currentScissorTest = null; + const _currentClearColor = new Color(0); + let _currentClearAlpha = 0; + let _width = canvas.width; + let _height = canvas.height; + let _pixelRatio = 1; + let _opaqueSort = null; + let _transparentSort = null; + const _viewport = new Vector4(0, 0, _width, _height); + const _scissor = new Vector4(0, 0, _width, _height); + let _scissorTest = false; + const _frustum = new Frustum(); + let _clippingEnabled = false; + let _localClippingEnabled = false; + const _projScreenMatrix2 = new Matrix4(); + const _vector22 = new Vector2(); + const _vector32 = new Vector3(); + const _emptyScene = { background: null, fog: null, environment: null, overrideMaterial: null, isScene: true }; + function getTargetPixelRatio() { + return _currentRenderTarget === null ? _pixelRatio : 1; + } + let _gl = context; + function getContext(contextName, contextAttributes) { + const context2 = canvas.getContext(contextName, contextAttributes); + if (context2 !== null) return context2; + return null; + } + try { + const contextAttributes = { + alpha: true, + depth, + stencil, + antialias, + premultipliedAlpha, + preserveDrawingBuffer, + powerPreference, + failIfMajorPerformanceCaveat + }; + if ("setAttribute" in canvas) canvas.setAttribute("data-engine", `three.js r${REVISION}`); + canvas.addEventListener("webglcontextlost", onContextLost, false); + canvas.addEventListener("webglcontextrestored", onContextRestore, false); + canvas.addEventListener("webglcontextcreationerror", onContextCreationError, false); + if (_gl === null) { + const contextName = "webgl2"; + _gl = getContext(contextName, contextAttributes); + if (_gl === null) { + if (getContext(contextName)) { + throw new Error("Error creating WebGL context with your selected attributes."); + } else { + throw new Error("Error creating WebGL context."); + } + } + } + } catch (error) { + console.error("THREE.WebGLRenderer: " + error.message); + throw error; + } + let extensions, capabilities, state, info; + let properties, textures, cubemaps, cubeuvmaps, attributes, geometries, objects; + let programCache, materials, renderLists, renderStates, clipping, shadowMap; + let background, morphtargets, bufferRenderer, indexedBufferRenderer; + let utils, bindingStates, uniformsGroups; + function initGLContext() { + extensions = new WebGLExtensions(_gl); + extensions.init(); + capabilities = new WebGLCapabilities(_gl, extensions, parameters); + utils = new WebGLUtils(_gl, extensions); + state = new WebGLState(_gl); + info = new WebGLInfo(_gl); + properties = new WebGLProperties(); + textures = new WebGLTextures(_gl, extensions, state, properties, capabilities, utils, info); + cubemaps = new WebGLCubeMaps(_this); + cubeuvmaps = new WebGLCubeUVMaps(_this); + attributes = new WebGLAttributes(_gl); + bindingStates = new WebGLBindingStates(_gl, attributes); + geometries = new WebGLGeometries(_gl, attributes, info, bindingStates); + objects = new WebGLObjects(_gl, geometries, attributes, info); + morphtargets = new WebGLMorphtargets(_gl, capabilities, textures); + clipping = new WebGLClipping(properties); + programCache = new WebGLPrograms(_this, cubemaps, cubeuvmaps, extensions, capabilities, bindingStates, clipping); + materials = new WebGLMaterials(_this, properties); + renderLists = new WebGLRenderLists(); + renderStates = new WebGLRenderStates(extensions); + background = new WebGLBackground(_this, cubemaps, cubeuvmaps, state, objects, _alpha, premultipliedAlpha); + shadowMap = new WebGLShadowMap(_this, objects, capabilities); + uniformsGroups = new WebGLUniformsGroups(_gl, info, capabilities, state); + bufferRenderer = new WebGLBufferRenderer(_gl, extensions, info); + indexedBufferRenderer = new WebGLIndexedBufferRenderer(_gl, extensions, info); + info.programs = programCache.programs; + _this.capabilities = capabilities; + _this.extensions = extensions; + _this.properties = properties; + _this.renderLists = renderLists; + _this.shadowMap = shadowMap; + _this.state = state; + _this.info = info; + } + initGLContext(); + const xr = new WebXRManager(_this, _gl); + this.xr = xr; + this.getContext = function() { + return _gl; + }; + this.getContextAttributes = function() { + return _gl.getContextAttributes(); + }; + this.forceContextLoss = function() { + const extension = extensions.get("WEBGL_lose_context"); + if (extension) extension.loseContext(); + }; + this.forceContextRestore = function() { + const extension = extensions.get("WEBGL_lose_context"); + if (extension) extension.restoreContext(); + }; + this.getPixelRatio = function() { + return _pixelRatio; + }; + this.setPixelRatio = function(value) { + if (value === void 0) return; + _pixelRatio = value; + this.setSize(_width, _height, false); + }; + this.getSize = function(target) { + return target.set(_width, _height); + }; + this.setSize = function(width, height, updateStyle = true) { + if (xr.isPresenting) { + console.warn("THREE.WebGLRenderer: Can't change size while VR device is presenting."); + return; + } + _width = width; + _height = height; + canvas.width = Math.floor(width * _pixelRatio); + canvas.height = Math.floor(height * _pixelRatio); + if (updateStyle === true) { + canvas.style.width = width + "px"; + canvas.style.height = height + "px"; + } + this.setViewport(0, 0, width, height); + }; + this.getDrawingBufferSize = function(target) { + return target.set(_width * _pixelRatio, _height * _pixelRatio).floor(); + }; + this.setDrawingBufferSize = function(width, height, pixelRatio) { + _width = width; + _height = height; + _pixelRatio = pixelRatio; + canvas.width = Math.floor(width * pixelRatio); + canvas.height = Math.floor(height * pixelRatio); + this.setViewport(0, 0, width, height); + }; + this.getCurrentViewport = function(target) { + return target.copy(_currentViewport); + }; + this.getViewport = function(target) { + return target.copy(_viewport); + }; + this.setViewport = function(x, y, width, height) { + if (x.isVector4) { + _viewport.set(x.x, x.y, x.z, x.w); + } else { + _viewport.set(x, y, width, height); + } + state.viewport(_currentViewport.copy(_viewport).multiplyScalar(_pixelRatio).round()); + }; + this.getScissor = function(target) { + return target.copy(_scissor); + }; + this.setScissor = function(x, y, width, height) { + if (x.isVector4) { + _scissor.set(x.x, x.y, x.z, x.w); + } else { + _scissor.set(x, y, width, height); + } + state.scissor(_currentScissor.copy(_scissor).multiplyScalar(_pixelRatio).round()); + }; + this.getScissorTest = function() { + return _scissorTest; + }; + this.setScissorTest = function(boolean) { + state.setScissorTest(_scissorTest = boolean); + }; + this.setOpaqueSort = function(method) { + _opaqueSort = method; + }; + this.setTransparentSort = function(method) { + _transparentSort = method; + }; + this.getClearColor = function(target) { + return target.copy(background.getClearColor()); + }; + this.setClearColor = function() { + background.setClearColor.apply(background, arguments); + }; + this.getClearAlpha = function() { + return background.getClearAlpha(); + }; + this.setClearAlpha = function() { + background.setClearAlpha.apply(background, arguments); + }; + this.clear = function(color = true, depth2 = true, stencil2 = true) { + let bits2 = 0; + if (color) { + let isIntegerFormat = false; + if (_currentRenderTarget !== null) { + const targetFormat = _currentRenderTarget.texture.format; + isIntegerFormat = targetFormat === RGBAIntegerFormat || targetFormat === RGIntegerFormat || targetFormat === RedIntegerFormat; + } + if (isIntegerFormat) { + const targetType = _currentRenderTarget.texture.type; + const isUnsignedType = targetType === UnsignedByteType || targetType === UnsignedIntType || targetType === UnsignedShortType || targetType === UnsignedInt248Type || targetType === UnsignedShort4444Type || targetType === UnsignedShort5551Type; + const clearColor = background.getClearColor(); + const a = background.getClearAlpha(); + const r = clearColor.r; + const g = clearColor.g; + const b = clearColor.b; + if (isUnsignedType) { + uintClearColor[0] = r; + uintClearColor[1] = g; + uintClearColor[2] = b; + uintClearColor[3] = a; + _gl.clearBufferuiv(_gl.COLOR, 0, uintClearColor); + } else { + intClearColor[0] = r; + intClearColor[1] = g; + intClearColor[2] = b; + intClearColor[3] = a; + _gl.clearBufferiv(_gl.COLOR, 0, intClearColor); + } + } else { + bits2 |= _gl.COLOR_BUFFER_BIT; + } + } + if (depth2) bits2 |= _gl.DEPTH_BUFFER_BIT; + if (stencil2) { + bits2 |= _gl.STENCIL_BUFFER_BIT; + this.state.buffers.stencil.setMask(4294967295); + } + _gl.clear(bits2); + }; + this.clearColor = function() { + this.clear(true, false, false); + }; + this.clearDepth = function() { + this.clear(false, true, false); + }; + this.clearStencil = function() { + this.clear(false, false, true); + }; + this.dispose = function() { + canvas.removeEventListener("webglcontextlost", onContextLost, false); + canvas.removeEventListener("webglcontextrestored", onContextRestore, false); + canvas.removeEventListener("webglcontextcreationerror", onContextCreationError, false); + renderLists.dispose(); + renderStates.dispose(); + properties.dispose(); + cubemaps.dispose(); + cubeuvmaps.dispose(); + objects.dispose(); + bindingStates.dispose(); + uniformsGroups.dispose(); + programCache.dispose(); + xr.dispose(); + xr.removeEventListener("sessionstart", onXRSessionStart); + xr.removeEventListener("sessionend", onXRSessionEnd); + animation.stop(); + }; + function onContextLost(event) { + event.preventDefault(); + console.log("THREE.WebGLRenderer: Context Lost."); + _isContextLost = true; + } + function onContextRestore() { + console.log("THREE.WebGLRenderer: Context Restored."); + _isContextLost = false; + const infoAutoReset = info.autoReset; + const shadowMapEnabled = shadowMap.enabled; + const shadowMapAutoUpdate = shadowMap.autoUpdate; + const shadowMapNeedsUpdate = shadowMap.needsUpdate; + const shadowMapType = shadowMap.type; + initGLContext(); + info.autoReset = infoAutoReset; + shadowMap.enabled = shadowMapEnabled; + shadowMap.autoUpdate = shadowMapAutoUpdate; + shadowMap.needsUpdate = shadowMapNeedsUpdate; + shadowMap.type = shadowMapType; + } + function onContextCreationError(event) { + console.error("THREE.WebGLRenderer: A WebGL context could not be created. Reason: ", event.statusMessage); + } + function onMaterialDispose(event) { + const material = event.target; + material.removeEventListener("dispose", onMaterialDispose); + deallocateMaterial(material); + } + function deallocateMaterial(material) { + releaseMaterialProgramReferences(material); + properties.remove(material); + } + function releaseMaterialProgramReferences(material) { + const programs = properties.get(material).programs; + if (programs !== void 0) { + programs.forEach(function(program) { + programCache.releaseProgram(program); + }); + if (material.isShaderMaterial) { + programCache.releaseShaderCache(material); + } + } + } + this.renderBufferDirect = function(camera, scene, geometry, material, object, group) { + if (scene === null) scene = _emptyScene; + const frontFaceCW = object.isMesh && object.matrixWorld.determinant() < 0; + const program = setProgram(camera, scene, geometry, material, object); + state.setMaterial(material, frontFaceCW); + let index = geometry.index; + let rangeFactor = 1; + if (material.wireframe === true) { + index = geometries.getWireframeAttribute(geometry); + if (index === void 0) return; + rangeFactor = 2; + } + const drawRange = geometry.drawRange; + const position = geometry.attributes.position; + let drawStart = drawRange.start * rangeFactor; + let drawEnd = (drawRange.start + drawRange.count) * rangeFactor; + if (group !== null) { + drawStart = Math.max(drawStart, group.start * rangeFactor); + drawEnd = Math.min(drawEnd, (group.start + group.count) * rangeFactor); + } + if (index !== null) { + drawStart = Math.max(drawStart, 0); + drawEnd = Math.min(drawEnd, index.count); + } else if (position !== void 0 && position !== null) { + drawStart = Math.max(drawStart, 0); + drawEnd = Math.min(drawEnd, position.count); + } + const drawCount = drawEnd - drawStart; + if (drawCount < 0 || drawCount === Infinity) return; + bindingStates.setup(object, material, program, geometry, index); + let attribute; + let renderer = bufferRenderer; + if (index !== null) { + attribute = attributes.get(index); + renderer = indexedBufferRenderer; + renderer.setIndex(attribute); + } + if (object.isMesh) { + if (material.wireframe === true) { + state.setLineWidth(material.wireframeLinewidth * getTargetPixelRatio()); + renderer.setMode(_gl.LINES); + } else { + renderer.setMode(_gl.TRIANGLES); + } + } else if (object.isLine) { + let lineWidth = material.linewidth; + if (lineWidth === void 0) lineWidth = 1; + state.setLineWidth(lineWidth * getTargetPixelRatio()); + if (object.isLineSegments) { + renderer.setMode(_gl.LINES); + } else if (object.isLineLoop) { + renderer.setMode(_gl.LINE_LOOP); + } else { + renderer.setMode(_gl.LINE_STRIP); + } + } else if (object.isPoints) { + renderer.setMode(_gl.POINTS); + } else if (object.isSprite) { + renderer.setMode(_gl.TRIANGLES); + } + if (object.isBatchedMesh) { + renderer.renderMultiDraw(object._multiDrawStarts, object._multiDrawCounts, object._multiDrawCount); + } else if (object.isInstancedMesh) { + renderer.renderInstances(drawStart, drawCount, object.count); + } else if (geometry.isInstancedBufferGeometry) { + const maxInstanceCount = geometry._maxInstanceCount !== void 0 ? geometry._maxInstanceCount : Infinity; + const instanceCount = Math.min(geometry.instanceCount, maxInstanceCount); + renderer.renderInstances(drawStart, drawCount, instanceCount); + } else { + renderer.render(drawStart, drawCount); + } + }; + function prepareMaterial(material, scene, object) { + if (material.transparent === true && material.side === DoubleSide && material.forceSinglePass === false) { + material.side = BackSide; + material.needsUpdate = true; + getProgram(material, scene, object); + material.side = FrontSide; + material.needsUpdate = true; + getProgram(material, scene, object); + material.side = DoubleSide; + } else { + getProgram(material, scene, object); + } + } + this.compile = function(scene, camera, targetScene = null) { + if (targetScene === null) targetScene = scene; + currentRenderState = renderStates.get(targetScene); + currentRenderState.init(); + renderStateStack.push(currentRenderState); + targetScene.traverseVisible(function(object) { + if (object.isLight && object.layers.test(camera.layers)) { + currentRenderState.pushLight(object); + if (object.castShadow) { + currentRenderState.pushShadow(object); + } + } + }); + if (scene !== targetScene) { + scene.traverseVisible(function(object) { + if (object.isLight && object.layers.test(camera.layers)) { + currentRenderState.pushLight(object); + if (object.castShadow) { + currentRenderState.pushShadow(object); + } + } + }); + } + currentRenderState.setupLights(_this._useLegacyLights); + const materials2 = /* @__PURE__ */ new Set(); + scene.traverse(function(object) { + const material = object.material; + if (material) { + if (Array.isArray(material)) { + for (let i = 0; i < material.length; i++) { + const material2 = material[i]; + prepareMaterial(material2, targetScene, object); + materials2.add(material2); + } + } else { + prepareMaterial(material, targetScene, object); + materials2.add(material); + } + } + }); + renderStateStack.pop(); + currentRenderState = null; + return materials2; + }; + this.compileAsync = function(scene, camera, targetScene = null) { + const materials2 = this.compile(scene, camera, targetScene); + return new Promise((resolve) => { + function checkMaterialsReady() { + materials2.forEach(function(material) { + const materialProperties = properties.get(material); + const program = materialProperties.currentProgram; + if (program.isReady()) { + materials2.delete(material); + } + }); + if (materials2.size === 0) { + resolve(scene); + return; + } + setTimeout(checkMaterialsReady, 10); + } + if (extensions.get("KHR_parallel_shader_compile") !== null) { + checkMaterialsReady(); + } else { + setTimeout(checkMaterialsReady, 10); + } + }); + }; + let onAnimationFrameCallback = null; + function onAnimationFrame(time) { + if (onAnimationFrameCallback) onAnimationFrameCallback(time); + } + function onXRSessionStart() { + animation.stop(); + } + function onXRSessionEnd() { + animation.start(); + } + const animation = new WebGLAnimation(); + animation.setAnimationLoop(onAnimationFrame); + if (typeof self !== "undefined") animation.setContext(self); + this.setAnimationLoop = function(callback) { + onAnimationFrameCallback = callback; + xr.setAnimationLoop(callback); + callback === null ? animation.stop() : animation.start(); + }; + xr.addEventListener("sessionstart", onXRSessionStart); + xr.addEventListener("sessionend", onXRSessionEnd); + this.render = function(scene, camera) { + if (camera !== void 0 && camera.isCamera !== true) { + console.error("THREE.WebGLRenderer.render: camera is not an instance of THREE.Camera."); + return; + } + if (_isContextLost === true) return; + if (scene.matrixWorldAutoUpdate === true) scene.updateMatrixWorld(); + if (camera.parent === null && camera.matrixWorldAutoUpdate === true) camera.updateMatrixWorld(); + if (xr.enabled === true && xr.isPresenting === true) { + if (xr.cameraAutoUpdate === true) xr.updateCamera(camera); + camera = xr.getCamera(); + } + if (scene.isScene === true) scene.onBeforeRender(_this, scene, camera, _currentRenderTarget); + currentRenderState = renderStates.get(scene, renderStateStack.length); + currentRenderState.init(); + renderStateStack.push(currentRenderState); + _projScreenMatrix2.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse); + _frustum.setFromProjectionMatrix(_projScreenMatrix2); + _localClippingEnabled = this.localClippingEnabled; + _clippingEnabled = clipping.init(this.clippingPlanes, _localClippingEnabled); + currentRenderList = renderLists.get(scene, renderListStack.length); + currentRenderList.init(); + renderListStack.push(currentRenderList); + projectObject(scene, camera, 0, _this.sortObjects); + currentRenderList.finish(); + if (_this.sortObjects === true) { + currentRenderList.sort(_opaqueSort, _transparentSort); + } + this.info.render.frame++; + if (_clippingEnabled === true) clipping.beginShadows(); + const shadowsArray = currentRenderState.state.shadowsArray; + shadowMap.render(shadowsArray, scene, camera); + if (_clippingEnabled === true) clipping.endShadows(); + if (this.info.autoReset === true) this.info.reset(); + if (xr.enabled === false || xr.isPresenting === false || xr.hasDepthSensing() === false) { + background.render(currentRenderList, scene); + } + currentRenderState.setupLights(_this._useLegacyLights); + if (camera.isArrayCamera) { + const cameras = camera.cameras; + for (let i = 0, l = cameras.length; i < l; i++) { + const camera2 = cameras[i]; + renderScene(currentRenderList, scene, camera2, camera2.viewport); + } + } else { + renderScene(currentRenderList, scene, camera); + } + if (_currentRenderTarget !== null) { + textures.updateMultisampleRenderTarget(_currentRenderTarget); + textures.updateRenderTargetMipmap(_currentRenderTarget); + } + if (scene.isScene === true) scene.onAfterRender(_this, scene, camera); + bindingStates.resetDefaultState(); + _currentMaterialId = -1; + _currentCamera = null; + renderStateStack.pop(); + if (renderStateStack.length > 0) { + currentRenderState = renderStateStack[renderStateStack.length - 1]; + } else { + currentRenderState = null; + } + renderListStack.pop(); + if (renderListStack.length > 0) { + currentRenderList = renderListStack[renderListStack.length - 1]; + } else { + currentRenderList = null; + } + }; + function projectObject(object, camera, groupOrder, sortObjects) { + if (object.visible === false) return; + const visible = object.layers.test(camera.layers); + if (visible) { + if (object.isGroup) { + groupOrder = object.renderOrder; + } else if (object.isLOD) { + if (object.autoUpdate === true) object.update(camera); + } else if (object.isLight) { + currentRenderState.pushLight(object); + if (object.castShadow) { + currentRenderState.pushShadow(object); + } + } else if (object.isSprite) { + if (!object.frustumCulled || _frustum.intersectsSprite(object)) { + if (sortObjects) { + _vector32.setFromMatrixPosition(object.matrixWorld).applyMatrix4(_projScreenMatrix2); + } + const geometry = objects.update(object); + const material = object.material; + if (material.visible) { + currentRenderList.push(object, geometry, material, groupOrder, _vector32.z, null); + } + } + } else if (object.isMesh || object.isLine || object.isPoints) { + if (!object.frustumCulled || _frustum.intersectsObject(object)) { + const geometry = objects.update(object); + const material = object.material; + if (sortObjects) { + if (object.boundingSphere !== void 0) { + if (object.boundingSphere === null) object.computeBoundingSphere(); + _vector32.copy(object.boundingSphere.center); + } else { + if (geometry.boundingSphere === null) geometry.computeBoundingSphere(); + _vector32.copy(geometry.boundingSphere.center); + } + _vector32.applyMatrix4(object.matrixWorld).applyMatrix4(_projScreenMatrix2); + } + if (Array.isArray(material)) { + const groups = geometry.groups; + for (let i = 0, l = groups.length; i < l; i++) { + const group = groups[i]; + const groupMaterial = material[group.materialIndex]; + if (groupMaterial && groupMaterial.visible) { + currentRenderList.push(object, geometry, groupMaterial, groupOrder, _vector32.z, group); + } + } + } else if (material.visible) { + currentRenderList.push(object, geometry, material, groupOrder, _vector32.z, null); + } + } + } + } + const children = object.children; + for (let i = 0, l = children.length; i < l; i++) { + projectObject(children[i], camera, groupOrder, sortObjects); + } + } + function renderScene(currentRenderList2, scene, camera, viewport) { + const opaqueObjects = currentRenderList2.opaque; + const transmissiveObjects = currentRenderList2.transmissive; + const transparentObjects = currentRenderList2.transparent; + currentRenderState.setupLightsView(camera); + if (_clippingEnabled === true) clipping.setGlobalState(_this.clippingPlanes, camera); + if (transmissiveObjects.length > 0) renderTransmissionPass(opaqueObjects, transmissiveObjects, scene, camera); + if (viewport) state.viewport(_currentViewport.copy(viewport)); + if (opaqueObjects.length > 0) renderObjects(opaqueObjects, scene, camera); + if (transmissiveObjects.length > 0) renderObjects(transmissiveObjects, scene, camera); + if (transparentObjects.length > 0) renderObjects(transparentObjects, scene, camera); + state.buffers.depth.setTest(true); + state.buffers.depth.setMask(true); + state.buffers.color.setMask(true); + state.setPolygonOffset(false); + } + function renderTransmissionPass(opaqueObjects, transmissiveObjects, scene, camera) { + const overrideMaterial = scene.isScene === true ? scene.overrideMaterial : null; + if (overrideMaterial !== null) { + return; + } + if (currentRenderState.state.transmissionRenderTarget === null) { + currentRenderState.state.transmissionRenderTarget = new WebGLRenderTarget(1, 1, { + generateMipmaps: true, + type: extensions.has("EXT_color_buffer_half_float") || extensions.has("EXT_color_buffer_float") ? HalfFloatType : UnsignedByteType, + minFilter: LinearMipmapLinearFilter, + samples: 4, + stencilBuffer: stencil + }); + const renderTargetProperties = properties.get(currentRenderState.state.transmissionRenderTarget); + renderTargetProperties.__isTransmissionRenderTarget = true; + } + const transmissionRenderTarget = currentRenderState.state.transmissionRenderTarget; + _this.getDrawingBufferSize(_vector22); + transmissionRenderTarget.setSize(_vector22.x, _vector22.y); + const currentRenderTarget = _this.getRenderTarget(); + _this.setRenderTarget(transmissionRenderTarget); + _this.getClearColor(_currentClearColor); + _currentClearAlpha = _this.getClearAlpha(); + if (_currentClearAlpha < 1) _this.setClearColor(16777215, 0.5); + _this.clear(); + const currentToneMapping = _this.toneMapping; + _this.toneMapping = NoToneMapping; + renderObjects(opaqueObjects, scene, camera); + textures.updateMultisampleRenderTarget(transmissionRenderTarget); + textures.updateRenderTargetMipmap(transmissionRenderTarget); + let renderTargetNeedsUpdate = false; + for (let i = 0, l = transmissiveObjects.length; i < l; i++) { + const renderItem = transmissiveObjects[i]; + const object = renderItem.object; + const geometry = renderItem.geometry; + const material = renderItem.material; + const group = renderItem.group; + if (material.side === DoubleSide && object.layers.test(camera.layers)) { + const currentSide = material.side; + material.side = BackSide; + material.needsUpdate = true; + renderObject(object, scene, camera, geometry, material, group); + material.side = currentSide; + material.needsUpdate = true; + renderTargetNeedsUpdate = true; + } + } + if (renderTargetNeedsUpdate === true) { + textures.updateMultisampleRenderTarget(transmissionRenderTarget); + textures.updateRenderTargetMipmap(transmissionRenderTarget); + } + _this.setRenderTarget(currentRenderTarget); + _this.setClearColor(_currentClearColor, _currentClearAlpha); + _this.toneMapping = currentToneMapping; + } + function renderObjects(renderList, scene, camera) { + const overrideMaterial = scene.isScene === true ? scene.overrideMaterial : null; + for (let i = 0, l = renderList.length; i < l; i++) { + const renderItem = renderList[i]; + const object = renderItem.object; + const geometry = renderItem.geometry; + const material = overrideMaterial === null ? renderItem.material : overrideMaterial; + const group = renderItem.group; + if (object.layers.test(camera.layers)) { + renderObject(object, scene, camera, geometry, material, group); + } + } + } + function renderObject(object, scene, camera, geometry, material, group) { + object.onBeforeRender(_this, scene, camera, geometry, material, group); + object.modelViewMatrix.multiplyMatrices(camera.matrixWorldInverse, object.matrixWorld); + object.normalMatrix.getNormalMatrix(object.modelViewMatrix); + material.onBeforeRender(_this, scene, camera, geometry, object, group); + if (material.transparent === true && material.side === DoubleSide && material.forceSinglePass === false) { + material.side = BackSide; + material.needsUpdate = true; + _this.renderBufferDirect(camera, scene, geometry, material, object, group); + material.side = FrontSide; + material.needsUpdate = true; + _this.renderBufferDirect(camera, scene, geometry, material, object, group); + material.side = DoubleSide; + } else { + _this.renderBufferDirect(camera, scene, geometry, material, object, group); + } + object.onAfterRender(_this, scene, camera, geometry, material, group); + } + function getProgram(material, scene, object) { + if (scene.isScene !== true) scene = _emptyScene; + const materialProperties = properties.get(material); + const lights = currentRenderState.state.lights; + const shadowsArray = currentRenderState.state.shadowsArray; + const lightsStateVersion = lights.state.version; + const parameters2 = programCache.getParameters(material, lights.state, shadowsArray, scene, object); + const programCacheKey = programCache.getProgramCacheKey(parameters2); + let programs = materialProperties.programs; + materialProperties.environment = material.isMeshStandardMaterial ? scene.environment : null; + materialProperties.fog = scene.fog; + materialProperties.envMap = (material.isMeshStandardMaterial ? cubeuvmaps : cubemaps).get(material.envMap || materialProperties.environment); + materialProperties.envMapRotation = materialProperties.environment !== null && material.envMap === null ? scene.environmentRotation : material.envMapRotation; + if (programs === void 0) { + material.addEventListener("dispose", onMaterialDispose); + programs = /* @__PURE__ */ new Map(); + materialProperties.programs = programs; + } + let program = programs.get(programCacheKey); + if (program !== void 0) { + if (materialProperties.currentProgram === program && materialProperties.lightsStateVersion === lightsStateVersion) { + updateCommonMaterialProperties(material, parameters2); + return program; + } + } else { + parameters2.uniforms = programCache.getUniforms(material); + material.onBuild(object, parameters2, _this); + material.onBeforeCompile(parameters2, _this); + program = programCache.acquireProgram(parameters2, programCacheKey); + programs.set(programCacheKey, program); + materialProperties.uniforms = parameters2.uniforms; + } + const uniforms = materialProperties.uniforms; + if (!material.isShaderMaterial && !material.isRawShaderMaterial || material.clipping === true) { + uniforms.clippingPlanes = clipping.uniform; + } + updateCommonMaterialProperties(material, parameters2); + materialProperties.needsLights = materialNeedsLights(material); + materialProperties.lightsStateVersion = lightsStateVersion; + if (materialProperties.needsLights) { + uniforms.ambientLightColor.value = lights.state.ambient; + uniforms.lightProbe.value = lights.state.probe; + uniforms.directionalLights.value = lights.state.directional; + uniforms.directionalLightShadows.value = lights.state.directionalShadow; + uniforms.spotLights.value = lights.state.spot; + uniforms.spotLightShadows.value = lights.state.spotShadow; + uniforms.rectAreaLights.value = lights.state.rectArea; + uniforms.ltc_1.value = lights.state.rectAreaLTC1; + uniforms.ltc_2.value = lights.state.rectAreaLTC2; + uniforms.pointLights.value = lights.state.point; + uniforms.pointLightShadows.value = lights.state.pointShadow; + uniforms.hemisphereLights.value = lights.state.hemi; + uniforms.directionalShadowMap.value = lights.state.directionalShadowMap; + uniforms.directionalShadowMatrix.value = lights.state.directionalShadowMatrix; + uniforms.spotShadowMap.value = lights.state.spotShadowMap; + uniforms.spotLightMatrix.value = lights.state.spotLightMatrix; + uniforms.spotLightMap.value = lights.state.spotLightMap; + uniforms.pointShadowMap.value = lights.state.pointShadowMap; + uniforms.pointShadowMatrix.value = lights.state.pointShadowMatrix; + } + materialProperties.currentProgram = program; + materialProperties.uniformsList = null; + return program; + } + function getUniformList(materialProperties) { + if (materialProperties.uniformsList === null) { + const progUniforms = materialProperties.currentProgram.getUniforms(); + materialProperties.uniformsList = WebGLUniforms.seqWithValue(progUniforms.seq, materialProperties.uniforms); + } + return materialProperties.uniformsList; + } + function updateCommonMaterialProperties(material, parameters2) { + const materialProperties = properties.get(material); + materialProperties.outputColorSpace = parameters2.outputColorSpace; + materialProperties.batching = parameters2.batching; + materialProperties.instancing = parameters2.instancing; + materialProperties.instancingColor = parameters2.instancingColor; + materialProperties.instancingMorph = parameters2.instancingMorph; + materialProperties.skinning = parameters2.skinning; + materialProperties.morphTargets = parameters2.morphTargets; + materialProperties.morphNormals = parameters2.morphNormals; + materialProperties.morphColors = parameters2.morphColors; + materialProperties.morphTargetsCount = parameters2.morphTargetsCount; + materialProperties.numClippingPlanes = parameters2.numClippingPlanes; + materialProperties.numIntersection = parameters2.numClipIntersection; + materialProperties.vertexAlphas = parameters2.vertexAlphas; + materialProperties.vertexTangents = parameters2.vertexTangents; + materialProperties.toneMapping = parameters2.toneMapping; + } + function setProgram(camera, scene, geometry, material, object) { + if (scene.isScene !== true) scene = _emptyScene; + textures.resetTextureUnits(); + const fog = scene.fog; + const environment = material.isMeshStandardMaterial ? scene.environment : null; + const colorSpace = _currentRenderTarget === null ? _this.outputColorSpace : _currentRenderTarget.isXRRenderTarget === true ? _currentRenderTarget.texture.colorSpace : LinearSRGBColorSpace; + const envMap = (material.isMeshStandardMaterial ? cubeuvmaps : cubemaps).get(material.envMap || environment); + const vertexAlphas = material.vertexColors === true && !!geometry.attributes.color && geometry.attributes.color.itemSize === 4; + const vertexTangents = !!geometry.attributes.tangent && (!!material.normalMap || material.anisotropy > 0); + const morphTargets = !!geometry.morphAttributes.position; + const morphNormals = !!geometry.morphAttributes.normal; + const morphColors = !!geometry.morphAttributes.color; + let toneMapping = NoToneMapping; + if (material.toneMapped) { + if (_currentRenderTarget === null || _currentRenderTarget.isXRRenderTarget === true) { + toneMapping = _this.toneMapping; + } + } + const morphAttribute = geometry.morphAttributes.position || geometry.morphAttributes.normal || geometry.morphAttributes.color; + const morphTargetsCount = morphAttribute !== void 0 ? morphAttribute.length : 0; + const materialProperties = properties.get(material); + const lights = currentRenderState.state.lights; + if (_clippingEnabled === true) { + if (_localClippingEnabled === true || camera !== _currentCamera) { + const useCache = camera === _currentCamera && material.id === _currentMaterialId; + clipping.setState(material, camera, useCache); + } + } + let needsProgramChange = false; + if (material.version === materialProperties.__version) { + if (materialProperties.needsLights && materialProperties.lightsStateVersion !== lights.state.version) { + needsProgramChange = true; + } else if (materialProperties.outputColorSpace !== colorSpace) { + needsProgramChange = true; + } else if (object.isBatchedMesh && materialProperties.batching === false) { + needsProgramChange = true; + } else if (!object.isBatchedMesh && materialProperties.batching === true) { + needsProgramChange = true; + } else if (object.isInstancedMesh && materialProperties.instancing === false) { + needsProgramChange = true; + } else if (!object.isInstancedMesh && materialProperties.instancing === true) { + needsProgramChange = true; + } else if (object.isSkinnedMesh && materialProperties.skinning === false) { + needsProgramChange = true; + } else if (!object.isSkinnedMesh && materialProperties.skinning === true) { + needsProgramChange = true; + } else if (object.isInstancedMesh && materialProperties.instancingColor === true && object.instanceColor === null) { + needsProgramChange = true; + } else if (object.isInstancedMesh && materialProperties.instancingColor === false && object.instanceColor !== null) { + needsProgramChange = true; + } else if (object.isInstancedMesh && materialProperties.instancingMorph === true && object.morphTexture === null) { + needsProgramChange = true; + } else if (object.isInstancedMesh && materialProperties.instancingMorph === false && object.morphTexture !== null) { + needsProgramChange = true; + } else if (materialProperties.envMap !== envMap) { + needsProgramChange = true; + } else if (material.fog === true && materialProperties.fog !== fog) { + needsProgramChange = true; + } else if (materialProperties.numClippingPlanes !== void 0 && (materialProperties.numClippingPlanes !== clipping.numPlanes || materialProperties.numIntersection !== clipping.numIntersection)) { + needsProgramChange = true; + } else if (materialProperties.vertexAlphas !== vertexAlphas) { + needsProgramChange = true; + } else if (materialProperties.vertexTangents !== vertexTangents) { + needsProgramChange = true; + } else if (materialProperties.morphTargets !== morphTargets) { + needsProgramChange = true; + } else if (materialProperties.morphNormals !== morphNormals) { + needsProgramChange = true; + } else if (materialProperties.morphColors !== morphColors) { + needsProgramChange = true; + } else if (materialProperties.toneMapping !== toneMapping) { + needsProgramChange = true; + } else if (materialProperties.morphTargetsCount !== morphTargetsCount) { + needsProgramChange = true; + } + } else { + needsProgramChange = true; + materialProperties.__version = material.version; + } + let program = materialProperties.currentProgram; + if (needsProgramChange === true) { + program = getProgram(material, scene, object); + } + let refreshProgram = false; + let refreshMaterial = false; + let refreshLights = false; + const p_uniforms = program.getUniforms(), m_uniforms = materialProperties.uniforms; + if (state.useProgram(program.program)) { + refreshProgram = true; + refreshMaterial = true; + refreshLights = true; + } + if (material.id !== _currentMaterialId) { + _currentMaterialId = material.id; + refreshMaterial = true; + } + if (refreshProgram || _currentCamera !== camera) { + p_uniforms.setValue(_gl, "projectionMatrix", camera.projectionMatrix); + p_uniforms.setValue(_gl, "viewMatrix", camera.matrixWorldInverse); + const uCamPos = p_uniforms.map.cameraPosition; + if (uCamPos !== void 0) { + uCamPos.setValue(_gl, _vector32.setFromMatrixPosition(camera.matrixWorld)); + } + if (capabilities.logarithmicDepthBuffer) { + p_uniforms.setValue( + _gl, + "logDepthBufFC", + 2 / (Math.log(camera.far + 1) / Math.LN2) + ); + } + if (material.isMeshPhongMaterial || material.isMeshToonMaterial || material.isMeshLambertMaterial || material.isMeshBasicMaterial || material.isMeshStandardMaterial || material.isShaderMaterial) { + p_uniforms.setValue(_gl, "isOrthographic", camera.isOrthographicCamera === true); + } + if (_currentCamera !== camera) { + _currentCamera = camera; + refreshMaterial = true; + refreshLights = true; + } + } + if (object.isSkinnedMesh) { + p_uniforms.setOptional(_gl, object, "bindMatrix"); + p_uniforms.setOptional(_gl, object, "bindMatrixInverse"); + const skeleton = object.skeleton; + if (skeleton) { + if (skeleton.boneTexture === null) skeleton.computeBoneTexture(); + p_uniforms.setValue(_gl, "boneTexture", skeleton.boneTexture, textures); + } + } + if (object.isBatchedMesh) { + p_uniforms.setOptional(_gl, object, "batchingTexture"); + p_uniforms.setValue(_gl, "batchingTexture", object._matricesTexture, textures); + } + const morphAttributes = geometry.morphAttributes; + if (morphAttributes.position !== void 0 || morphAttributes.normal !== void 0 || morphAttributes.color !== void 0) { + morphtargets.update(object, geometry, program); + } + if (refreshMaterial || materialProperties.receiveShadow !== object.receiveShadow) { + materialProperties.receiveShadow = object.receiveShadow; + p_uniforms.setValue(_gl, "receiveShadow", object.receiveShadow); + } + if (material.isMeshGouraudMaterial && material.envMap !== null) { + m_uniforms.envMap.value = envMap; + m_uniforms.flipEnvMap.value = envMap.isCubeTexture && envMap.isRenderTargetTexture === false ? -1 : 1; + } + if (material.isMeshStandardMaterial && material.envMap === null && scene.environment !== null) { + m_uniforms.envMapIntensity.value = scene.environmentIntensity; + } + if (refreshMaterial) { + p_uniforms.setValue(_gl, "toneMappingExposure", _this.toneMappingExposure); + if (materialProperties.needsLights) { + markUniformsLightsNeedsUpdate(m_uniforms, refreshLights); + } + if (fog && material.fog === true) { + materials.refreshFogUniforms(m_uniforms, fog); + } + materials.refreshMaterialUniforms(m_uniforms, material, _pixelRatio, _height, currentRenderState.state.transmissionRenderTarget); + WebGLUniforms.upload(_gl, getUniformList(materialProperties), m_uniforms, textures); + } + if (material.isShaderMaterial && material.uniformsNeedUpdate === true) { + WebGLUniforms.upload(_gl, getUniformList(materialProperties), m_uniforms, textures); + material.uniformsNeedUpdate = false; + } + if (material.isSpriteMaterial) { + p_uniforms.setValue(_gl, "center", object.center); + } + p_uniforms.setValue(_gl, "modelViewMatrix", object.modelViewMatrix); + p_uniforms.setValue(_gl, "normalMatrix", object.normalMatrix); + p_uniforms.setValue(_gl, "modelMatrix", object.matrixWorld); + if (material.isShaderMaterial || material.isRawShaderMaterial) { + const groups = material.uniformsGroups; + for (let i = 0, l = groups.length; i < l; i++) { + const group = groups[i]; + uniformsGroups.update(group, program); + uniformsGroups.bind(group, program); + } + } + return program; + } + function markUniformsLightsNeedsUpdate(uniforms, value) { + uniforms.ambientLightColor.needsUpdate = value; + uniforms.lightProbe.needsUpdate = value; + uniforms.directionalLights.needsUpdate = value; + uniforms.directionalLightShadows.needsUpdate = value; + uniforms.pointLights.needsUpdate = value; + uniforms.pointLightShadows.needsUpdate = value; + uniforms.spotLights.needsUpdate = value; + uniforms.spotLightShadows.needsUpdate = value; + uniforms.rectAreaLights.needsUpdate = value; + uniforms.hemisphereLights.needsUpdate = value; + } + function materialNeedsLights(material) { + return material.isMeshLambertMaterial || material.isMeshToonMaterial || material.isMeshPhongMaterial || material.isMeshStandardMaterial || material.isShadowMaterial || material.isShaderMaterial && material.lights === true; + } + this.getActiveCubeFace = function() { + return _currentActiveCubeFace; + }; + this.getActiveMipmapLevel = function() { + return _currentActiveMipmapLevel; + }; + this.getRenderTarget = function() { + return _currentRenderTarget; + }; + this.setRenderTargetTextures = function(renderTarget, colorTexture, depthTexture) { + properties.get(renderTarget.texture).__webglTexture = colorTexture; + properties.get(renderTarget.depthTexture).__webglTexture = depthTexture; + const renderTargetProperties = properties.get(renderTarget); + renderTargetProperties.__hasExternalTextures = true; + renderTargetProperties.__autoAllocateDepthBuffer = depthTexture === void 0; + if (!renderTargetProperties.__autoAllocateDepthBuffer) { + if (extensions.has("WEBGL_multisampled_render_to_texture") === true) { + console.warn("THREE.WebGLRenderer: Render-to-texture extension was disabled because an external texture was provided"); + renderTargetProperties.__useRenderToTexture = false; + } + } + }; + this.setRenderTargetFramebuffer = function(renderTarget, defaultFramebuffer) { + const renderTargetProperties = properties.get(renderTarget); + renderTargetProperties.__webglFramebuffer = defaultFramebuffer; + renderTargetProperties.__useDefaultFramebuffer = defaultFramebuffer === void 0; + }; + this.setRenderTarget = function(renderTarget, activeCubeFace = 0, activeMipmapLevel = 0) { + _currentRenderTarget = renderTarget; + _currentActiveCubeFace = activeCubeFace; + _currentActiveMipmapLevel = activeMipmapLevel; + let useDefaultFramebuffer = true; + let framebuffer = null; + let isCube = false; + let isRenderTarget3D = false; + if (renderTarget) { + const renderTargetProperties = properties.get(renderTarget); + if (renderTargetProperties.__useDefaultFramebuffer !== void 0) { + state.bindFramebuffer(_gl.FRAMEBUFFER, null); + useDefaultFramebuffer = false; + } else if (renderTargetProperties.__webglFramebuffer === void 0) { + textures.setupRenderTarget(renderTarget); + } else if (renderTargetProperties.__hasExternalTextures) { + textures.rebindTextures(renderTarget, properties.get(renderTarget.texture).__webglTexture, properties.get(renderTarget.depthTexture).__webglTexture); + } + const texture = renderTarget.texture; + if (texture.isData3DTexture || texture.isDataArrayTexture || texture.isCompressedArrayTexture) { + isRenderTarget3D = true; + } + const __webglFramebuffer = properties.get(renderTarget).__webglFramebuffer; + if (renderTarget.isWebGLCubeRenderTarget) { + if (Array.isArray(__webglFramebuffer[activeCubeFace])) { + framebuffer = __webglFramebuffer[activeCubeFace][activeMipmapLevel]; + } else { + framebuffer = __webglFramebuffer[activeCubeFace]; + } + isCube = true; + } else if (renderTarget.samples > 0 && textures.useMultisampledRTT(renderTarget) === false) { + framebuffer = properties.get(renderTarget).__webglMultisampledFramebuffer; + } else { + if (Array.isArray(__webglFramebuffer)) { + framebuffer = __webglFramebuffer[activeMipmapLevel]; + } else { + framebuffer = __webglFramebuffer; + } + } + _currentViewport.copy(renderTarget.viewport); + _currentScissor.copy(renderTarget.scissor); + _currentScissorTest = renderTarget.scissorTest; + } else { + _currentViewport.copy(_viewport).multiplyScalar(_pixelRatio).floor(); + _currentScissor.copy(_scissor).multiplyScalar(_pixelRatio).floor(); + _currentScissorTest = _scissorTest; + } + const framebufferBound = state.bindFramebuffer(_gl.FRAMEBUFFER, framebuffer); + if (framebufferBound && useDefaultFramebuffer) { + state.drawBuffers(renderTarget, framebuffer); + } + state.viewport(_currentViewport); + state.scissor(_currentScissor); + state.setScissorTest(_currentScissorTest); + if (isCube) { + const textureProperties = properties.get(renderTarget.texture); + _gl.framebufferTexture2D(_gl.FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_CUBE_MAP_POSITIVE_X + activeCubeFace, textureProperties.__webglTexture, activeMipmapLevel); + } else if (isRenderTarget3D) { + const textureProperties = properties.get(renderTarget.texture); + const layer = activeCubeFace || 0; + _gl.framebufferTextureLayer(_gl.FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, textureProperties.__webglTexture, activeMipmapLevel || 0, layer); + } + _currentMaterialId = -1; + }; + this.readRenderTargetPixels = function(renderTarget, x, y, width, height, buffer, activeCubeFaceIndex) { + if (!(renderTarget && renderTarget.isWebGLRenderTarget)) { + console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget."); + return; + } + let framebuffer = properties.get(renderTarget).__webglFramebuffer; + if (renderTarget.isWebGLCubeRenderTarget && activeCubeFaceIndex !== void 0) { + framebuffer = framebuffer[activeCubeFaceIndex]; + } + if (framebuffer) { + state.bindFramebuffer(_gl.FRAMEBUFFER, framebuffer); + try { + const texture = renderTarget.texture; + const textureFormat = texture.format; + const textureType = texture.type; + if (textureFormat !== RGBAFormat && utils.convert(textureFormat) !== _gl.getParameter(_gl.IMPLEMENTATION_COLOR_READ_FORMAT)) { + console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in RGBA or implementation defined format."); + return; + } + const halfFloatSupportedByExt = textureType === HalfFloatType && (extensions.has("EXT_color_buffer_half_float") || extensions.has("EXT_color_buffer_float")); + if (textureType !== UnsignedByteType && utils.convert(textureType) !== _gl.getParameter(_gl.IMPLEMENTATION_COLOR_READ_TYPE) && // Edge and Chrome Mac < 52 (#9513) + textureType !== FloatType && !halfFloatSupportedByExt) { + console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in UnsignedByteType or implementation defined type."); + return; + } + if (x >= 0 && x <= renderTarget.width - width && (y >= 0 && y <= renderTarget.height - height)) { + _gl.readPixels(x, y, width, height, utils.convert(textureFormat), utils.convert(textureType), buffer); + } + } finally { + const framebuffer2 = _currentRenderTarget !== null ? properties.get(_currentRenderTarget).__webglFramebuffer : null; + state.bindFramebuffer(_gl.FRAMEBUFFER, framebuffer2); + } + } + }; + this.copyFramebufferToTexture = function(position, texture, level = 0) { + const levelScale = Math.pow(2, -level); + const width = Math.floor(texture.image.width * levelScale); + const height = Math.floor(texture.image.height * levelScale); + textures.setTexture2D(texture, 0); + _gl.copyTexSubImage2D(_gl.TEXTURE_2D, level, 0, 0, position.x, position.y, width, height); + state.unbindTexture(); + }; + this.copyTextureToTexture = function(position, srcTexture, dstTexture, level = 0) { + const width = srcTexture.image.width; + const height = srcTexture.image.height; + const glFormat = utils.convert(dstTexture.format); + const glType = utils.convert(dstTexture.type); + textures.setTexture2D(dstTexture, 0); + _gl.pixelStorei(_gl.UNPACK_FLIP_Y_WEBGL, dstTexture.flipY); + _gl.pixelStorei(_gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, dstTexture.premultiplyAlpha); + _gl.pixelStorei(_gl.UNPACK_ALIGNMENT, dstTexture.unpackAlignment); + if (srcTexture.isDataTexture) { + _gl.texSubImage2D(_gl.TEXTURE_2D, level, position.x, position.y, width, height, glFormat, glType, srcTexture.image.data); + } else { + if (srcTexture.isCompressedTexture) { + _gl.compressedTexSubImage2D(_gl.TEXTURE_2D, level, position.x, position.y, srcTexture.mipmaps[0].width, srcTexture.mipmaps[0].height, glFormat, srcTexture.mipmaps[0].data); + } else { + _gl.texSubImage2D(_gl.TEXTURE_2D, level, position.x, position.y, glFormat, glType, srcTexture.image); + } + } + if (level === 0 && dstTexture.generateMipmaps) _gl.generateMipmap(_gl.TEXTURE_2D); + state.unbindTexture(); + }; + this.copyTextureToTexture3D = function(sourceBox, position, srcTexture, dstTexture, level = 0) { + const width = Math.round(sourceBox.max.x - sourceBox.min.x); + const height = Math.round(sourceBox.max.y - sourceBox.min.y); + const depth2 = sourceBox.max.z - sourceBox.min.z + 1; + const glFormat = utils.convert(dstTexture.format); + const glType = utils.convert(dstTexture.type); + let glTarget; + if (dstTexture.isData3DTexture) { + textures.setTexture3D(dstTexture, 0); + glTarget = _gl.TEXTURE_3D; + } else if (dstTexture.isDataArrayTexture || dstTexture.isCompressedArrayTexture) { + textures.setTexture2DArray(dstTexture, 0); + glTarget = _gl.TEXTURE_2D_ARRAY; + } else { + console.warn("THREE.WebGLRenderer.copyTextureToTexture3D: only supports THREE.DataTexture3D and THREE.DataTexture2DArray."); + return; + } + _gl.pixelStorei(_gl.UNPACK_FLIP_Y_WEBGL, dstTexture.flipY); + _gl.pixelStorei(_gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, dstTexture.premultiplyAlpha); + _gl.pixelStorei(_gl.UNPACK_ALIGNMENT, dstTexture.unpackAlignment); + const unpackRowLen = _gl.getParameter(_gl.UNPACK_ROW_LENGTH); + const unpackImageHeight = _gl.getParameter(_gl.UNPACK_IMAGE_HEIGHT); + const unpackSkipPixels = _gl.getParameter(_gl.UNPACK_SKIP_PIXELS); + const unpackSkipRows = _gl.getParameter(_gl.UNPACK_SKIP_ROWS); + const unpackSkipImages = _gl.getParameter(_gl.UNPACK_SKIP_IMAGES); + const image = srcTexture.isCompressedTexture ? srcTexture.mipmaps[level] : srcTexture.image; + _gl.pixelStorei(_gl.UNPACK_ROW_LENGTH, image.width); + _gl.pixelStorei(_gl.UNPACK_IMAGE_HEIGHT, image.height); + _gl.pixelStorei(_gl.UNPACK_SKIP_PIXELS, sourceBox.min.x); + _gl.pixelStorei(_gl.UNPACK_SKIP_ROWS, sourceBox.min.y); + _gl.pixelStorei(_gl.UNPACK_SKIP_IMAGES, sourceBox.min.z); + if (srcTexture.isDataTexture || srcTexture.isData3DTexture) { + _gl.texSubImage3D(glTarget, level, position.x, position.y, position.z, width, height, depth2, glFormat, glType, image.data); + } else { + if (dstTexture.isCompressedArrayTexture) { + _gl.compressedTexSubImage3D(glTarget, level, position.x, position.y, position.z, width, height, depth2, glFormat, image.data); + } else { + _gl.texSubImage3D(glTarget, level, position.x, position.y, position.z, width, height, depth2, glFormat, glType, image); + } + } + _gl.pixelStorei(_gl.UNPACK_ROW_LENGTH, unpackRowLen); + _gl.pixelStorei(_gl.UNPACK_IMAGE_HEIGHT, unpackImageHeight); + _gl.pixelStorei(_gl.UNPACK_SKIP_PIXELS, unpackSkipPixels); + _gl.pixelStorei(_gl.UNPACK_SKIP_ROWS, unpackSkipRows); + _gl.pixelStorei(_gl.UNPACK_SKIP_IMAGES, unpackSkipImages); + if (level === 0 && dstTexture.generateMipmaps) _gl.generateMipmap(glTarget); + state.unbindTexture(); + }; + this.initTexture = function(texture) { + if (texture.isCubeTexture) { + textures.setTextureCube(texture, 0); + } else if (texture.isData3DTexture) { + textures.setTexture3D(texture, 0); + } else if (texture.isDataArrayTexture || texture.isCompressedArrayTexture) { + textures.setTexture2DArray(texture, 0); + } else { + textures.setTexture2D(texture, 0); + } + state.unbindTexture(); + }; + this.resetState = function() { + _currentActiveCubeFace = 0; + _currentActiveMipmapLevel = 0; + _currentRenderTarget = null; + state.reset(); + bindingStates.reset(); + }; + if (typeof __THREE_DEVTOOLS__ !== "undefined") { + __THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe", { detail: this })); + } + } + get coordinateSystem() { + return WebGLCoordinateSystem; + } + get outputColorSpace() { + return this._outputColorSpace; + } + set outputColorSpace(colorSpace) { + this._outputColorSpace = colorSpace; + const gl = this.getContext(); + gl.drawingBufferColorSpace = colorSpace === DisplayP3ColorSpace ? "display-p3" : "srgb"; + gl.unpackColorSpace = ColorManagement.workingColorSpace === LinearDisplayP3ColorSpace ? "display-p3" : "srgb"; + } + get useLegacyLights() { + console.warn("THREE.WebGLRenderer: The property .useLegacyLights has been deprecated. Migrate your lighting according to the following guide: https://discourse.threejs.org/t/updates-to-lighting-in-three-js-r155/53733."); + return this._useLegacyLights; + } + set useLegacyLights(value) { + console.warn("THREE.WebGLRenderer: The property .useLegacyLights has been deprecated. Migrate your lighting according to the following guide: https://discourse.threejs.org/t/updates-to-lighting-in-three-js-r155/53733."); + this._useLegacyLights = value; + } +}; +var Scene = class extends Object3D { + constructor() { + super(); + this.isScene = true; + this.type = "Scene"; + this.background = null; + this.environment = null; + this.fog = null; + this.backgroundBlurriness = 0; + this.backgroundIntensity = 1; + this.backgroundRotation = new Euler(); + this.environmentIntensity = 1; + this.environmentRotation = new Euler(); + this.overrideMaterial = null; + if (typeof __THREE_DEVTOOLS__ !== "undefined") { + __THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe", { detail: this })); + } + } + copy(source, recursive) { + super.copy(source, recursive); + if (source.background !== null) this.background = source.background.clone(); + if (source.environment !== null) this.environment = source.environment.clone(); + if (source.fog !== null) this.fog = source.fog.clone(); + this.backgroundBlurriness = source.backgroundBlurriness; + this.backgroundIntensity = source.backgroundIntensity; + this.backgroundRotation.copy(source.backgroundRotation); + this.environmentIntensity = source.environmentIntensity; + this.environmentRotation.copy(source.environmentRotation); + if (source.overrideMaterial !== null) this.overrideMaterial = source.overrideMaterial.clone(); + this.matrixAutoUpdate = source.matrixAutoUpdate; + return this; + } + toJSON(meta) { + const data = super.toJSON(meta); + if (this.fog !== null) data.object.fog = this.fog.toJSON(); + if (this.backgroundBlurriness > 0) data.object.backgroundBlurriness = this.backgroundBlurriness; + if (this.backgroundIntensity !== 1) data.object.backgroundIntensity = this.backgroundIntensity; + data.object.backgroundRotation = this.backgroundRotation.toArray(); + if (this.environmentIntensity !== 1) data.object.environmentIntensity = this.environmentIntensity; + data.object.environmentRotation = this.environmentRotation.toArray(); + return data; + } +}; +var InterleavedBuffer = class { + constructor(array, stride) { + this.isInterleavedBuffer = true; + this.array = array; + this.stride = stride; + this.count = array !== void 0 ? array.length / stride : 0; + this.usage = StaticDrawUsage; + this._updateRange = { offset: 0, count: -1 }; + this.updateRanges = []; + this.version = 0; + this.uuid = generateUUID(); + } + onUploadCallback() { + } + set needsUpdate(value) { + if (value === true) this.version++; + } + get updateRange() { + warnOnce("THREE.InterleavedBuffer: updateRange() is deprecated and will be removed in r169. Use addUpdateRange() instead."); + return this._updateRange; + } + setUsage(value) { + this.usage = value; + return this; + } + addUpdateRange(start, count) { + this.updateRanges.push({ start, count }); + } + clearUpdateRanges() { + this.updateRanges.length = 0; + } + copy(source) { + this.array = new source.array.constructor(source.array); + this.count = source.count; + this.stride = source.stride; + this.usage = source.usage; + return this; + } + copyAt(index1, attribute, index2) { + index1 *= this.stride; + index2 *= attribute.stride; + for (let i = 0, l = this.stride; i < l; i++) { + this.array[index1 + i] = attribute.array[index2 + i]; + } + return this; + } + set(value, offset = 0) { + this.array.set(value, offset); + return this; + } + clone(data) { + if (data.arrayBuffers === void 0) { + data.arrayBuffers = {}; + } + if (this.array.buffer._uuid === void 0) { + this.array.buffer._uuid = generateUUID(); + } + if (data.arrayBuffers[this.array.buffer._uuid] === void 0) { + data.arrayBuffers[this.array.buffer._uuid] = this.array.slice(0).buffer; + } + const array = new this.array.constructor(data.arrayBuffers[this.array.buffer._uuid]); + const ib = new this.constructor(array, this.stride); + ib.setUsage(this.usage); + return ib; + } + onUpload(callback) { + this.onUploadCallback = callback; + return this; + } + toJSON(data) { + if (data.arrayBuffers === void 0) { + data.arrayBuffers = {}; + } + if (this.array.buffer._uuid === void 0) { + this.array.buffer._uuid = generateUUID(); + } + if (data.arrayBuffers[this.array.buffer._uuid] === void 0) { + data.arrayBuffers[this.array.buffer._uuid] = Array.from(new Uint32Array(this.array.buffer)); + } + return { + uuid: this.uuid, + buffer: this.array.buffer._uuid, + type: this.array.constructor.name, + stride: this.stride + }; + } +}; +var _vector$6 = /* @__PURE__ */ new Vector3(); +var InterleavedBufferAttribute = class _InterleavedBufferAttribute { + constructor(interleavedBuffer, itemSize, offset, normalized = false) { + this.isInterleavedBufferAttribute = true; + this.name = ""; + this.data = interleavedBuffer; + this.itemSize = itemSize; + this.offset = offset; + this.normalized = normalized; + } + get count() { + return this.data.count; + } + get array() { + return this.data.array; + } + set needsUpdate(value) { + this.data.needsUpdate = value; + } + applyMatrix4(m) { + for (let i = 0, l = this.data.count; i < l; i++) { + _vector$6.fromBufferAttribute(this, i); + _vector$6.applyMatrix4(m); + this.setXYZ(i, _vector$6.x, _vector$6.y, _vector$6.z); + } + return this; + } + applyNormalMatrix(m) { + for (let i = 0, l = this.count; i < l; i++) { + _vector$6.fromBufferAttribute(this, i); + _vector$6.applyNormalMatrix(m); + this.setXYZ(i, _vector$6.x, _vector$6.y, _vector$6.z); + } + return this; + } + transformDirection(m) { + for (let i = 0, l = this.count; i < l; i++) { + _vector$6.fromBufferAttribute(this, i); + _vector$6.transformDirection(m); + this.setXYZ(i, _vector$6.x, _vector$6.y, _vector$6.z); + } + return this; + } + getComponent(index, component) { + let value = this.array[index * this.data.stride + this.offset + component]; + if (this.normalized) value = denormalize(value, this.array); + return value; + } + setComponent(index, component, value) { + if (this.normalized) value = normalize(value, this.array); + this.data.array[index * this.data.stride + this.offset + component] = value; + return this; + } + setX(index, x) { + if (this.normalized) x = normalize(x, this.array); + this.data.array[index * this.data.stride + this.offset] = x; + return this; + } + setY(index, y) { + if (this.normalized) y = normalize(y, this.array); + this.data.array[index * this.data.stride + this.offset + 1] = y; + return this; + } + setZ(index, z) { + if (this.normalized) z = normalize(z, this.array); + this.data.array[index * this.data.stride + this.offset + 2] = z; + return this; + } + setW(index, w) { + if (this.normalized) w = normalize(w, this.array); + this.data.array[index * this.data.stride + this.offset + 3] = w; + return this; + } + getX(index) { + let x = this.data.array[index * this.data.stride + this.offset]; + if (this.normalized) x = denormalize(x, this.array); + return x; + } + getY(index) { + let y = this.data.array[index * this.data.stride + this.offset + 1]; + if (this.normalized) y = denormalize(y, this.array); + return y; + } + getZ(index) { + let z = this.data.array[index * this.data.stride + this.offset + 2]; + if (this.normalized) z = denormalize(z, this.array); + return z; + } + getW(index) { + let w = this.data.array[index * this.data.stride + this.offset + 3]; + if (this.normalized) w = denormalize(w, this.array); + return w; + } + setXY(index, x, y) { + index = index * this.data.stride + this.offset; + if (this.normalized) { + x = normalize(x, this.array); + y = normalize(y, this.array); + } + this.data.array[index + 0] = x; + this.data.array[index + 1] = y; + return this; + } + setXYZ(index, x, y, z) { + index = index * this.data.stride + this.offset; + if (this.normalized) { + x = normalize(x, this.array); + y = normalize(y, this.array); + z = normalize(z, this.array); + } + this.data.array[index + 0] = x; + this.data.array[index + 1] = y; + this.data.array[index + 2] = z; + return this; + } + setXYZW(index, x, y, z, w) { + index = index * this.data.stride + this.offset; + if (this.normalized) { + x = normalize(x, this.array); + y = normalize(y, this.array); + z = normalize(z, this.array); + w = normalize(w, this.array); + } + this.data.array[index + 0] = x; + this.data.array[index + 1] = y; + this.data.array[index + 2] = z; + this.data.array[index + 3] = w; + return this; + } + clone(data) { + if (data === void 0) { + console.log("THREE.InterleavedBufferAttribute.clone(): Cloning an interleaved buffer attribute will de-interleave buffer data."); + const array = []; + for (let i = 0; i < this.count; i++) { + const index = i * this.data.stride + this.offset; + for (let j = 0; j < this.itemSize; j++) { + array.push(this.data.array[index + j]); + } + } + return new BufferAttribute(new this.array.constructor(array), this.itemSize, this.normalized); + } else { + if (data.interleavedBuffers === void 0) { + data.interleavedBuffers = {}; + } + if (data.interleavedBuffers[this.data.uuid] === void 0) { + data.interleavedBuffers[this.data.uuid] = this.data.clone(data); + } + return new _InterleavedBufferAttribute(data.interleavedBuffers[this.data.uuid], this.itemSize, this.offset, this.normalized); + } + } + toJSON(data) { + if (data === void 0) { + console.log("THREE.InterleavedBufferAttribute.toJSON(): Serializing an interleaved buffer attribute will de-interleave buffer data."); + const array = []; + for (let i = 0; i < this.count; i++) { + const index = i * this.data.stride + this.offset; + for (let j = 0; j < this.itemSize; j++) { + array.push(this.data.array[index + j]); + } + } + return { + itemSize: this.itemSize, + type: this.array.constructor.name, + array, + normalized: this.normalized + }; + } else { + if (data.interleavedBuffers === void 0) { + data.interleavedBuffers = {}; + } + if (data.interleavedBuffers[this.data.uuid] === void 0) { + data.interleavedBuffers[this.data.uuid] = this.data.toJSON(data); + } + return { + isInterleavedBufferAttribute: true, + itemSize: this.itemSize, + data: this.data.uuid, + offset: this.offset, + normalized: this.normalized + }; + } + } +}; +var _basePosition = /* @__PURE__ */ new Vector3(); +var _skinIndex = /* @__PURE__ */ new Vector4(); +var _skinWeight = /* @__PURE__ */ new Vector4(); +var _vector3 = /* @__PURE__ */ new Vector3(); +var _matrix4 = /* @__PURE__ */ new Matrix4(); +var _vertex = /* @__PURE__ */ new Vector3(); +var _sphere$4 = /* @__PURE__ */ new Sphere(); +var _inverseMatrix$2 = /* @__PURE__ */ new Matrix4(); +var _ray$2 = /* @__PURE__ */ new Ray(); +var SkinnedMesh = class extends Mesh { + constructor(geometry, material) { + super(geometry, material); + this.isSkinnedMesh = true; + this.type = "SkinnedMesh"; + this.bindMode = AttachedBindMode; + this.bindMatrix = new Matrix4(); + this.bindMatrixInverse = new Matrix4(); + this.boundingBox = null; + this.boundingSphere = null; + } + computeBoundingBox() { + const geometry = this.geometry; + if (this.boundingBox === null) { + this.boundingBox = new Box3(); + } + this.boundingBox.makeEmpty(); + const positionAttribute = geometry.getAttribute("position"); + for (let i = 0; i < positionAttribute.count; i++) { + this.getVertexPosition(i, _vertex); + this.boundingBox.expandByPoint(_vertex); + } + } + computeBoundingSphere() { + const geometry = this.geometry; + if (this.boundingSphere === null) { + this.boundingSphere = new Sphere(); + } + this.boundingSphere.makeEmpty(); + const positionAttribute = geometry.getAttribute("position"); + for (let i = 0; i < positionAttribute.count; i++) { + this.getVertexPosition(i, _vertex); + this.boundingSphere.expandByPoint(_vertex); + } + } + copy(source, recursive) { + super.copy(source, recursive); + this.bindMode = source.bindMode; + this.bindMatrix.copy(source.bindMatrix); + this.bindMatrixInverse.copy(source.bindMatrixInverse); + this.skeleton = source.skeleton; + if (source.boundingBox !== null) this.boundingBox = source.boundingBox.clone(); + if (source.boundingSphere !== null) this.boundingSphere = source.boundingSphere.clone(); + return this; + } + raycast(raycaster, intersects2) { + const material = this.material; + const matrixWorld = this.matrixWorld; + if (material === void 0) return; + if (this.boundingSphere === null) this.computeBoundingSphere(); + _sphere$4.copy(this.boundingSphere); + _sphere$4.applyMatrix4(matrixWorld); + if (raycaster.ray.intersectsSphere(_sphere$4) === false) return; + _inverseMatrix$2.copy(matrixWorld).invert(); + _ray$2.copy(raycaster.ray).applyMatrix4(_inverseMatrix$2); + if (this.boundingBox !== null) { + if (_ray$2.intersectsBox(this.boundingBox) === false) return; + } + this._computeIntersections(raycaster, intersects2, _ray$2); + } + getVertexPosition(index, target) { + super.getVertexPosition(index, target); + this.applyBoneTransform(index, target); + return target; + } + bind(skeleton, bindMatrix) { + this.skeleton = skeleton; + if (bindMatrix === void 0) { + this.updateMatrixWorld(true); + this.skeleton.calculateInverses(); + bindMatrix = this.matrixWorld; + } + this.bindMatrix.copy(bindMatrix); + this.bindMatrixInverse.copy(bindMatrix).invert(); + } + pose() { + this.skeleton.pose(); + } + normalizeSkinWeights() { + const vector = new Vector4(); + const skinWeight = this.geometry.attributes.skinWeight; + for (let i = 0, l = skinWeight.count; i < l; i++) { + vector.fromBufferAttribute(skinWeight, i); + const scale = 1 / vector.manhattanLength(); + if (scale !== Infinity) { + vector.multiplyScalar(scale); + } else { + vector.set(1, 0, 0, 0); + } + skinWeight.setXYZW(i, vector.x, vector.y, vector.z, vector.w); + } + } + updateMatrixWorld(force) { + super.updateMatrixWorld(force); + if (this.bindMode === AttachedBindMode) { + this.bindMatrixInverse.copy(this.matrixWorld).invert(); + } else if (this.bindMode === DetachedBindMode) { + this.bindMatrixInverse.copy(this.bindMatrix).invert(); + } else { + console.warn("THREE.SkinnedMesh: Unrecognized bindMode: " + this.bindMode); + } + } + applyBoneTransform(index, vector) { + const skeleton = this.skeleton; + const geometry = this.geometry; + _skinIndex.fromBufferAttribute(geometry.attributes.skinIndex, index); + _skinWeight.fromBufferAttribute(geometry.attributes.skinWeight, index); + _basePosition.copy(vector).applyMatrix4(this.bindMatrix); + vector.set(0, 0, 0); + for (let i = 0; i < 4; i++) { + const weight = _skinWeight.getComponent(i); + if (weight !== 0) { + const boneIndex = _skinIndex.getComponent(i); + _matrix4.multiplyMatrices(skeleton.bones[boneIndex].matrixWorld, skeleton.boneInverses[boneIndex]); + vector.addScaledVector(_vector3.copy(_basePosition).applyMatrix4(_matrix4), weight); + } + } + return vector.applyMatrix4(this.bindMatrixInverse); + } +}; +var Bone = class extends Object3D { + constructor() { + super(); + this.isBone = true; + this.type = "Bone"; + } +}; +var DataTexture = class extends Texture { + constructor(data = null, width = 1, height = 1, format, type, mapping, wrapS, wrapT, magFilter = NearestFilter, minFilter = NearestFilter, anisotropy, colorSpace) { + super(null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, colorSpace); + this.isDataTexture = true; + this.image = { data, width, height }; + this.generateMipmaps = false; + this.flipY = false; + this.unpackAlignment = 1; + } +}; +var _offsetMatrix = /* @__PURE__ */ new Matrix4(); +var _identityMatrix$1 = /* @__PURE__ */ new Matrix4(); +var Skeleton = class _Skeleton { + constructor(bones = [], boneInverses = []) { + this.uuid = generateUUID(); + this.bones = bones.slice(0); + this.boneInverses = boneInverses; + this.boneMatrices = null; + this.boneTexture = null; + this.init(); + } + init() { + const bones = this.bones; + const boneInverses = this.boneInverses; + this.boneMatrices = new Float32Array(bones.length * 16); + if (boneInverses.length === 0) { + this.calculateInverses(); + } else { + if (bones.length !== boneInverses.length) { + console.warn("THREE.Skeleton: Number of inverse bone matrices does not match amount of bones."); + this.boneInverses = []; + for (let i = 0, il = this.bones.length; i < il; i++) { + this.boneInverses.push(new Matrix4()); + } + } + } + } + calculateInverses() { + this.boneInverses.length = 0; + for (let i = 0, il = this.bones.length; i < il; i++) { + const inverse = new Matrix4(); + if (this.bones[i]) { + inverse.copy(this.bones[i].matrixWorld).invert(); + } + this.boneInverses.push(inverse); + } + } + pose() { + for (let i = 0, il = this.bones.length; i < il; i++) { + const bone = this.bones[i]; + if (bone) { + bone.matrixWorld.copy(this.boneInverses[i]).invert(); + } + } + for (let i = 0, il = this.bones.length; i < il; i++) { + const bone = this.bones[i]; + if (bone) { + if (bone.parent && bone.parent.isBone) { + bone.matrix.copy(bone.parent.matrixWorld).invert(); + bone.matrix.multiply(bone.matrixWorld); + } else { + bone.matrix.copy(bone.matrixWorld); + } + bone.matrix.decompose(bone.position, bone.quaternion, bone.scale); + } + } + } + update() { + const bones = this.bones; + const boneInverses = this.boneInverses; + const boneMatrices = this.boneMatrices; + const boneTexture = this.boneTexture; + for (let i = 0, il = bones.length; i < il; i++) { + const matrix = bones[i] ? bones[i].matrixWorld : _identityMatrix$1; + _offsetMatrix.multiplyMatrices(matrix, boneInverses[i]); + _offsetMatrix.toArray(boneMatrices, i * 16); + } + if (boneTexture !== null) { + boneTexture.needsUpdate = true; + } + } + clone() { + return new _Skeleton(this.bones, this.boneInverses); + } + computeBoneTexture() { + let size = Math.sqrt(this.bones.length * 4); + size = Math.ceil(size / 4) * 4; + size = Math.max(size, 4); + const boneMatrices = new Float32Array(size * size * 4); + boneMatrices.set(this.boneMatrices); + const boneTexture = new DataTexture(boneMatrices, size, size, RGBAFormat, FloatType); + boneTexture.needsUpdate = true; + this.boneMatrices = boneMatrices; + this.boneTexture = boneTexture; + return this; + } + getBoneByName(name) { + for (let i = 0, il = this.bones.length; i < il; i++) { + const bone = this.bones[i]; + if (bone.name === name) { + return bone; + } + } + return void 0; + } + dispose() { + if (this.boneTexture !== null) { + this.boneTexture.dispose(); + this.boneTexture = null; + } + } + fromJSON(json, bones) { + this.uuid = json.uuid; + for (let i = 0, l = json.bones.length; i < l; i++) { + const uuid = json.bones[i]; + let bone = bones[uuid]; + if (bone === void 0) { + console.warn("THREE.Skeleton: No bone found with UUID:", uuid); + bone = new Bone(); + } + this.bones.push(bone); + this.boneInverses.push(new Matrix4().fromArray(json.boneInverses[i])); + } + this.init(); + return this; + } + toJSON() { + const data = { + metadata: { + version: 4.6, + type: "Skeleton", + generator: "Skeleton.toJSON" + }, + bones: [], + boneInverses: [] + }; + data.uuid = this.uuid; + const bones = this.bones; + const boneInverses = this.boneInverses; + for (let i = 0, l = bones.length; i < l; i++) { + const bone = bones[i]; + data.bones.push(bone.uuid); + const boneInverse = boneInverses[i]; + data.boneInverses.push(boneInverse.toArray()); + } + return data; + } +}; +var InstancedBufferAttribute = class extends BufferAttribute { + constructor(array, itemSize, normalized, meshPerAttribute = 1) { + super(array, itemSize, normalized); + this.isInstancedBufferAttribute = true; + this.meshPerAttribute = meshPerAttribute; + } + copy(source) { + super.copy(source); + this.meshPerAttribute = source.meshPerAttribute; + return this; + } + toJSON() { + const data = super.toJSON(); + data.meshPerAttribute = this.meshPerAttribute; + data.isInstancedBufferAttribute = true; + return data; + } +}; +var _instanceLocalMatrix = /* @__PURE__ */ new Matrix4(); +var _instanceWorldMatrix = /* @__PURE__ */ new Matrix4(); +var _instanceIntersects = []; +var _box3 = /* @__PURE__ */ new Box3(); +var _identity = /* @__PURE__ */ new Matrix4(); +var _mesh$1 = /* @__PURE__ */ new Mesh(); +var _sphere$3 = /* @__PURE__ */ new Sphere(); +var InstancedMesh = class extends Mesh { + constructor(geometry, material, count) { + super(geometry, material); + this.isInstancedMesh = true; + this.instanceMatrix = new InstancedBufferAttribute(new Float32Array(count * 16), 16); + this.instanceColor = null; + this.morphTexture = null; + this.count = count; + this.boundingBox = null; + this.boundingSphere = null; + for (let i = 0; i < count; i++) { + this.setMatrixAt(i, _identity); + } + } + computeBoundingBox() { + const geometry = this.geometry; + const count = this.count; + if (this.boundingBox === null) { + this.boundingBox = new Box3(); + } + if (geometry.boundingBox === null) { + geometry.computeBoundingBox(); + } + this.boundingBox.makeEmpty(); + for (let i = 0; i < count; i++) { + this.getMatrixAt(i, _instanceLocalMatrix); + _box3.copy(geometry.boundingBox).applyMatrix4(_instanceLocalMatrix); + this.boundingBox.union(_box3); + } + } + computeBoundingSphere() { + const geometry = this.geometry; + const count = this.count; + if (this.boundingSphere === null) { + this.boundingSphere = new Sphere(); + } + if (geometry.boundingSphere === null) { + geometry.computeBoundingSphere(); + } + this.boundingSphere.makeEmpty(); + for (let i = 0; i < count; i++) { + this.getMatrixAt(i, _instanceLocalMatrix); + _sphere$3.copy(geometry.boundingSphere).applyMatrix4(_instanceLocalMatrix); + this.boundingSphere.union(_sphere$3); + } + } + copy(source, recursive) { + super.copy(source, recursive); + this.instanceMatrix.copy(source.instanceMatrix); + if (source.morphTexture !== null) this.morphTexture = source.morphTexture.clone(); + if (source.instanceColor !== null) this.instanceColor = source.instanceColor.clone(); + this.count = source.count; + if (source.boundingBox !== null) this.boundingBox = source.boundingBox.clone(); + if (source.boundingSphere !== null) this.boundingSphere = source.boundingSphere.clone(); + return this; + } + getColorAt(index, color) { + color.fromArray(this.instanceColor.array, index * 3); + } + getMatrixAt(index, matrix) { + matrix.fromArray(this.instanceMatrix.array, index * 16); + } + getMorphAt(index, object) { + const objectInfluences = object.morphTargetInfluences; + const array = this.morphTexture.source.data.data; + const len = objectInfluences.length + 1; + const dataIndex = index * len + 1; + for (let i = 0; i < objectInfluences.length; i++) { + objectInfluences[i] = array[dataIndex + i]; + } + } + raycast(raycaster, intersects2) { + const matrixWorld = this.matrixWorld; + const raycastTimes = this.count; + _mesh$1.geometry = this.geometry; + _mesh$1.material = this.material; + if (_mesh$1.material === void 0) return; + if (this.boundingSphere === null) this.computeBoundingSphere(); + _sphere$3.copy(this.boundingSphere); + _sphere$3.applyMatrix4(matrixWorld); + if (raycaster.ray.intersectsSphere(_sphere$3) === false) return; + for (let instanceId = 0; instanceId < raycastTimes; instanceId++) { + this.getMatrixAt(instanceId, _instanceLocalMatrix); + _instanceWorldMatrix.multiplyMatrices(matrixWorld, _instanceLocalMatrix); + _mesh$1.matrixWorld = _instanceWorldMatrix; + _mesh$1.raycast(raycaster, _instanceIntersects); + for (let i = 0, l = _instanceIntersects.length; i < l; i++) { + const intersect2 = _instanceIntersects[i]; + intersect2.instanceId = instanceId; + intersect2.object = this; + intersects2.push(intersect2); + } + _instanceIntersects.length = 0; + } + } + setColorAt(index, color) { + if (this.instanceColor === null) { + this.instanceColor = new InstancedBufferAttribute(new Float32Array(this.instanceMatrix.count * 3), 3); + } + color.toArray(this.instanceColor.array, index * 3); + } + setMatrixAt(index, matrix) { + matrix.toArray(this.instanceMatrix.array, index * 16); + } + setMorphAt(index, object) { + const objectInfluences = object.morphTargetInfluences; + const len = objectInfluences.length + 1; + if (this.morphTexture === null) { + this.morphTexture = new DataTexture(new Float32Array(len * this.count), len, this.count, RedFormat, FloatType); + } + const array = this.morphTexture.source.data.data; + let morphInfluencesSum = 0; + for (let i = 0; i < objectInfluences.length; i++) { + morphInfluencesSum += objectInfluences[i]; + } + const morphBaseInfluence = this.geometry.morphTargetsRelative ? 1 : 1 - morphInfluencesSum; + const dataIndex = len * index; + array[dataIndex] = morphBaseInfluence; + array.set(objectInfluences, dataIndex + 1); + } + updateMorphTargets() { + } + dispose() { + this.dispatchEvent({ type: "dispose" }); + if (this.morphTexture !== null) { + this.morphTexture.dispose(); + this.morphTexture = null; + } + return this; + } +}; +var LineBasicMaterial = class extends Material { + constructor(parameters) { + super(); + this.isLineBasicMaterial = true; + this.type = "LineBasicMaterial"; + this.color = new Color(16777215); + this.map = null; + this.linewidth = 1; + this.linecap = "round"; + this.linejoin = "round"; + this.fog = true; + this.setValues(parameters); + } + copy(source) { + super.copy(source); + this.color.copy(source.color); + this.map = source.map; + this.linewidth = source.linewidth; + this.linecap = source.linecap; + this.linejoin = source.linejoin; + this.fog = source.fog; + return this; + } +}; +var _start$1 = /* @__PURE__ */ new Vector3(); +var _end$1 = /* @__PURE__ */ new Vector3(); +var _inverseMatrix$1 = /* @__PURE__ */ new Matrix4(); +var _ray$1 = /* @__PURE__ */ new Ray(); +var _sphere$1 = /* @__PURE__ */ new Sphere(); +var Line = class extends Object3D { + constructor(geometry = new BufferGeometry(), material = new LineBasicMaterial()) { + super(); + this.isLine = true; + this.type = "Line"; + this.geometry = geometry; + this.material = material; + this.updateMorphTargets(); + } + copy(source, recursive) { + super.copy(source, recursive); + this.material = Array.isArray(source.material) ? source.material.slice() : source.material; + this.geometry = source.geometry; + return this; + } + computeLineDistances() { + const geometry = this.geometry; + if (geometry.index === null) { + const positionAttribute = geometry.attributes.position; + const lineDistances = [0]; + for (let i = 1, l = positionAttribute.count; i < l; i++) { + _start$1.fromBufferAttribute(positionAttribute, i - 1); + _end$1.fromBufferAttribute(positionAttribute, i); + lineDistances[i] = lineDistances[i - 1]; + lineDistances[i] += _start$1.distanceTo(_end$1); + } + geometry.setAttribute("lineDistance", new Float32BufferAttribute(lineDistances, 1)); + } else { + console.warn("THREE.Line.computeLineDistances(): Computation only possible with non-indexed BufferGeometry."); + } + return this; + } + raycast(raycaster, intersects2) { + const geometry = this.geometry; + const matrixWorld = this.matrixWorld; + const threshold = raycaster.params.Line.threshold; + const drawRange = geometry.drawRange; + if (geometry.boundingSphere === null) geometry.computeBoundingSphere(); + _sphere$1.copy(geometry.boundingSphere); + _sphere$1.applyMatrix4(matrixWorld); + _sphere$1.radius += threshold; + if (raycaster.ray.intersectsSphere(_sphere$1) === false) return; + _inverseMatrix$1.copy(matrixWorld).invert(); + _ray$1.copy(raycaster.ray).applyMatrix4(_inverseMatrix$1); + const localThreshold = threshold / ((this.scale.x + this.scale.y + this.scale.z) / 3); + const localThresholdSq = localThreshold * localThreshold; + const vStart = new Vector3(); + const vEnd = new Vector3(); + const interSegment = new Vector3(); + const interRay = new Vector3(); + const step = this.isLineSegments ? 2 : 1; + const index = geometry.index; + const attributes = geometry.attributes; + const positionAttribute = attributes.position; + if (index !== null) { + const start = Math.max(0, drawRange.start); + const end = Math.min(index.count, drawRange.start + drawRange.count); + for (let i = start, l = end - 1; i < l; i += step) { + const a = index.getX(i); + const b = index.getX(i + 1); + vStart.fromBufferAttribute(positionAttribute, a); + vEnd.fromBufferAttribute(positionAttribute, b); + const distSq = _ray$1.distanceSqToSegment(vStart, vEnd, interRay, interSegment); + if (distSq > localThresholdSq) continue; + interRay.applyMatrix4(this.matrixWorld); + const distance = raycaster.ray.origin.distanceTo(interRay); + if (distance < raycaster.near || distance > raycaster.far) continue; + intersects2.push({ + distance, + // What do we want? intersection point on the ray or on the segment?? + // point: raycaster.ray.at( distance ), + point: interSegment.clone().applyMatrix4(this.matrixWorld), + index: i, + face: null, + faceIndex: null, + object: this + }); + } + } else { + const start = Math.max(0, drawRange.start); + const end = Math.min(positionAttribute.count, drawRange.start + drawRange.count); + for (let i = start, l = end - 1; i < l; i += step) { + vStart.fromBufferAttribute(positionAttribute, i); + vEnd.fromBufferAttribute(positionAttribute, i + 1); + const distSq = _ray$1.distanceSqToSegment(vStart, vEnd, interRay, interSegment); + if (distSq > localThresholdSq) continue; + interRay.applyMatrix4(this.matrixWorld); + const distance = raycaster.ray.origin.distanceTo(interRay); + if (distance < raycaster.near || distance > raycaster.far) continue; + intersects2.push({ + distance, + // What do we want? intersection point on the ray or on the segment?? + // point: raycaster.ray.at( distance ), + point: interSegment.clone().applyMatrix4(this.matrixWorld), + index: i, + face: null, + faceIndex: null, + object: this + }); + } + } + } + updateMorphTargets() { + const geometry = this.geometry; + const morphAttributes = geometry.morphAttributes; + const keys = Object.keys(morphAttributes); + if (keys.length > 0) { + const morphAttribute = morphAttributes[keys[0]]; + if (morphAttribute !== void 0) { + this.morphTargetInfluences = []; + this.morphTargetDictionary = {}; + for (let m = 0, ml = morphAttribute.length; m < ml; m++) { + const name = morphAttribute[m].name || String(m); + this.morphTargetInfluences.push(0); + this.morphTargetDictionary[name] = m; + } + } + } + } +}; +var _start = /* @__PURE__ */ new Vector3(); +var _end = /* @__PURE__ */ new Vector3(); +var LineSegments = class extends Line { + constructor(geometry, material) { + super(geometry, material); + this.isLineSegments = true; + this.type = "LineSegments"; + } + computeLineDistances() { + const geometry = this.geometry; + if (geometry.index === null) { + const positionAttribute = geometry.attributes.position; + const lineDistances = []; + for (let i = 0, l = positionAttribute.count; i < l; i += 2) { + _start.fromBufferAttribute(positionAttribute, i); + _end.fromBufferAttribute(positionAttribute, i + 1); + lineDistances[i] = i === 0 ? 0 : lineDistances[i - 1]; + lineDistances[i + 1] = lineDistances[i] + _start.distanceTo(_end); + } + geometry.setAttribute("lineDistance", new Float32BufferAttribute(lineDistances, 1)); + } else { + console.warn("THREE.LineSegments.computeLineDistances(): Computation only possible with non-indexed BufferGeometry."); + } + return this; + } +}; +var LineLoop = class extends Line { + constructor(geometry, material) { + super(geometry, material); + this.isLineLoop = true; + this.type = "LineLoop"; + } +}; +var PointsMaterial = class extends Material { + constructor(parameters) { + super(); + this.isPointsMaterial = true; + this.type = "PointsMaterial"; + this.color = new Color(16777215); + this.map = null; + this.alphaMap = null; + this.size = 1; + this.sizeAttenuation = true; + this.fog = true; + this.setValues(parameters); + } + copy(source) { + super.copy(source); + this.color.copy(source.color); + this.map = source.map; + this.alphaMap = source.alphaMap; + this.size = source.size; + this.sizeAttenuation = source.sizeAttenuation; + this.fog = source.fog; + return this; + } +}; +var _inverseMatrix = /* @__PURE__ */ new Matrix4(); +var _ray = /* @__PURE__ */ new Ray(); +var _sphere = /* @__PURE__ */ new Sphere(); +var _position$2 = /* @__PURE__ */ new Vector3(); +var Points = class extends Object3D { + constructor(geometry = new BufferGeometry(), material = new PointsMaterial()) { + super(); + this.isPoints = true; + this.type = "Points"; + this.geometry = geometry; + this.material = material; + this.updateMorphTargets(); + } + copy(source, recursive) { + super.copy(source, recursive); + this.material = Array.isArray(source.material) ? source.material.slice() : source.material; + this.geometry = source.geometry; + return this; + } + raycast(raycaster, intersects2) { + const geometry = this.geometry; + const matrixWorld = this.matrixWorld; + const threshold = raycaster.params.Points.threshold; + const drawRange = geometry.drawRange; + if (geometry.boundingSphere === null) geometry.computeBoundingSphere(); + _sphere.copy(geometry.boundingSphere); + _sphere.applyMatrix4(matrixWorld); + _sphere.radius += threshold; + if (raycaster.ray.intersectsSphere(_sphere) === false) return; + _inverseMatrix.copy(matrixWorld).invert(); + _ray.copy(raycaster.ray).applyMatrix4(_inverseMatrix); + const localThreshold = threshold / ((this.scale.x + this.scale.y + this.scale.z) / 3); + const localThresholdSq = localThreshold * localThreshold; + const index = geometry.index; + const attributes = geometry.attributes; + const positionAttribute = attributes.position; + if (index !== null) { + const start = Math.max(0, drawRange.start); + const end = Math.min(index.count, drawRange.start + drawRange.count); + for (let i = start, il = end; i < il; i++) { + const a = index.getX(i); + _position$2.fromBufferAttribute(positionAttribute, a); + testPoint(_position$2, a, localThresholdSq, matrixWorld, raycaster, intersects2, this); + } + } else { + const start = Math.max(0, drawRange.start); + const end = Math.min(positionAttribute.count, drawRange.start + drawRange.count); + for (let i = start, l = end; i < l; i++) { + _position$2.fromBufferAttribute(positionAttribute, i); + testPoint(_position$2, i, localThresholdSq, matrixWorld, raycaster, intersects2, this); + } + } + } + updateMorphTargets() { + const geometry = this.geometry; + const morphAttributes = geometry.morphAttributes; + const keys = Object.keys(morphAttributes); + if (keys.length > 0) { + const morphAttribute = morphAttributes[keys[0]]; + if (morphAttribute !== void 0) { + this.morphTargetInfluences = []; + this.morphTargetDictionary = {}; + for (let m = 0, ml = morphAttribute.length; m < ml; m++) { + const name = morphAttribute[m].name || String(m); + this.morphTargetInfluences.push(0); + this.morphTargetDictionary[name] = m; + } + } + } + } +}; +function testPoint(point, index, localThresholdSq, matrixWorld, raycaster, intersects2, object) { + const rayPointDistanceSq = _ray.distanceSqToPoint(point); + if (rayPointDistanceSq < localThresholdSq) { + const intersectPoint = new Vector3(); + _ray.closestPointToPoint(point, intersectPoint); + intersectPoint.applyMatrix4(matrixWorld); + const distance = raycaster.ray.origin.distanceTo(intersectPoint); + if (distance < raycaster.near || distance > raycaster.far) return; + intersects2.push({ + distance, + distanceToRay: Math.sqrt(rayPointDistanceSq), + point: intersectPoint, + index, + face: null, + object + }); + } +} +var VideoTexture = class extends Texture { + constructor(video, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy) { + super(video, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy); + this.isVideoTexture = true; + this.minFilter = minFilter !== void 0 ? minFilter : LinearFilter; + this.magFilter = magFilter !== void 0 ? magFilter : LinearFilter; + this.generateMipmaps = false; + const scope = this; + function updateVideo() { + scope.needsUpdate = true; + video.requestVideoFrameCallback(updateVideo); + } + if ("requestVideoFrameCallback" in video) { + video.requestVideoFrameCallback(updateVideo); + } + } + clone() { + return new this.constructor(this.image).copy(this); + } + update() { + const video = this.image; + const hasVideoFrameCallback = "requestVideoFrameCallback" in video; + if (hasVideoFrameCallback === false && video.readyState >= video.HAVE_CURRENT_DATA) { + this.needsUpdate = true; + } + } +}; +var CanvasTexture = class extends Texture { + constructor(canvas, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy) { + super(canvas, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy); + this.isCanvasTexture = true; + this.needsUpdate = true; + } +}; +var Curve = class { + constructor() { + this.type = "Curve"; + this.arcLengthDivisions = 200; + } + // Virtual base class method to overwrite and implement in subclasses + // - t [0 .. 1] + getPoint() { + console.warn("THREE.Curve: .getPoint() not implemented."); + return null; + } + // Get point at relative position in curve according to arc length + // - u [0 .. 1] + getPointAt(u, optionalTarget) { + const t = this.getUtoTmapping(u); + return this.getPoint(t, optionalTarget); + } + // Get sequence of points using getPoint( t ) + getPoints(divisions = 5) { + const points = []; + for (let d = 0; d <= divisions; d++) { + points.push(this.getPoint(d / divisions)); + } + return points; + } + // Get sequence of points using getPointAt( u ) + getSpacedPoints(divisions = 5) { + const points = []; + for (let d = 0; d <= divisions; d++) { + points.push(this.getPointAt(d / divisions)); + } + return points; + } + // Get total curve arc length + getLength() { + const lengths = this.getLengths(); + return lengths[lengths.length - 1]; + } + // Get list of cumulative segment lengths + getLengths(divisions = this.arcLengthDivisions) { + if (this.cacheArcLengths && this.cacheArcLengths.length === divisions + 1 && !this.needsUpdate) { + return this.cacheArcLengths; + } + this.needsUpdate = false; + const cache = []; + let current, last = this.getPoint(0); + let sum = 0; + cache.push(0); + for (let p = 1; p <= divisions; p++) { + current = this.getPoint(p / divisions); + sum += current.distanceTo(last); + cache.push(sum); + last = current; + } + this.cacheArcLengths = cache; + return cache; + } + updateArcLengths() { + this.needsUpdate = true; + this.getLengths(); + } + // Given u ( 0 .. 1 ), get a t to find p. This gives you points which are equidistant + getUtoTmapping(u, distance) { + const arcLengths = this.getLengths(); + let i = 0; + const il = arcLengths.length; + let targetArcLength; + if (distance) { + targetArcLength = distance; + } else { + targetArcLength = u * arcLengths[il - 1]; + } + let low = 0, high = il - 1, comparison; + while (low <= high) { + i = Math.floor(low + (high - low) / 2); + comparison = arcLengths[i] - targetArcLength; + if (comparison < 0) { + low = i + 1; + } else if (comparison > 0) { + high = i - 1; + } else { + high = i; + break; + } + } + i = high; + if (arcLengths[i] === targetArcLength) { + return i / (il - 1); + } + const lengthBefore = arcLengths[i]; + const lengthAfter = arcLengths[i + 1]; + const segmentLength = lengthAfter - lengthBefore; + const segmentFraction = (targetArcLength - lengthBefore) / segmentLength; + const t = (i + segmentFraction) / (il - 1); + return t; + } + // Returns a unit vector tangent at t + // In case any sub curve does not implement its tangent derivation, + // 2 points a small delta apart will be used to find its gradient + // which seems to give a reasonable approximation + getTangent(t, optionalTarget) { + const delta = 1e-4; + let t1 = t - delta; + let t2 = t + delta; + if (t1 < 0) t1 = 0; + if (t2 > 1) t2 = 1; + const pt1 = this.getPoint(t1); + const pt2 = this.getPoint(t2); + const tangent = optionalTarget || (pt1.isVector2 ? new Vector2() : new Vector3()); + tangent.copy(pt2).sub(pt1).normalize(); + return tangent; + } + getTangentAt(u, optionalTarget) { + const t = this.getUtoTmapping(u); + return this.getTangent(t, optionalTarget); + } + computeFrenetFrames(segments, closed) { + const normal = new Vector3(); + const tangents = []; + const normals = []; + const binormals = []; + const vec = new Vector3(); + const mat = new Matrix4(); + for (let i = 0; i <= segments; i++) { + const u = i / segments; + tangents[i] = this.getTangentAt(u, new Vector3()); + } + normals[0] = new Vector3(); + binormals[0] = new Vector3(); + let min = Number.MAX_VALUE; + const tx = Math.abs(tangents[0].x); + const ty = Math.abs(tangents[0].y); + const tz = Math.abs(tangents[0].z); + if (tx <= min) { + min = tx; + normal.set(1, 0, 0); + } + if (ty <= min) { + min = ty; + normal.set(0, 1, 0); + } + if (tz <= min) { + normal.set(0, 0, 1); + } + vec.crossVectors(tangents[0], normal).normalize(); + normals[0].crossVectors(tangents[0], vec); + binormals[0].crossVectors(tangents[0], normals[0]); + for (let i = 1; i <= segments; i++) { + normals[i] = normals[i - 1].clone(); + binormals[i] = binormals[i - 1].clone(); + vec.crossVectors(tangents[i - 1], tangents[i]); + if (vec.length() > Number.EPSILON) { + vec.normalize(); + const theta = Math.acos(clamp(tangents[i - 1].dot(tangents[i]), -1, 1)); + normals[i].applyMatrix4(mat.makeRotationAxis(vec, theta)); + } + binormals[i].crossVectors(tangents[i], normals[i]); + } + if (closed === true) { + let theta = Math.acos(clamp(normals[0].dot(normals[segments]), -1, 1)); + theta /= segments; + if (tangents[0].dot(vec.crossVectors(normals[0], normals[segments])) > 0) { + theta = -theta; + } + for (let i = 1; i <= segments; i++) { + normals[i].applyMatrix4(mat.makeRotationAxis(tangents[i], theta * i)); + binormals[i].crossVectors(tangents[i], normals[i]); + } + } + return { + tangents, + normals, + binormals + }; + } + clone() { + return new this.constructor().copy(this); + } + copy(source) { + this.arcLengthDivisions = source.arcLengthDivisions; + return this; + } + toJSON() { + const data = { + metadata: { + version: 4.6, + type: "Curve", + generator: "Curve.toJSON" + } + }; + data.arcLengthDivisions = this.arcLengthDivisions; + data.type = this.type; + return data; + } + fromJSON(json) { + this.arcLengthDivisions = json.arcLengthDivisions; + return this; + } +}; +var CylinderGeometry = class _CylinderGeometry extends BufferGeometry { + constructor(radiusTop = 1, radiusBottom = 1, height = 1, radialSegments = 32, heightSegments = 1, openEnded = false, thetaStart = 0, thetaLength = Math.PI * 2) { + super(); + this.type = "CylinderGeometry"; + this.parameters = { + radiusTop, + radiusBottom, + height, + radialSegments, + heightSegments, + openEnded, + thetaStart, + thetaLength + }; + const scope = this; + radialSegments = Math.floor(radialSegments); + heightSegments = Math.floor(heightSegments); + const indices = []; + const vertices = []; + const normals = []; + const uvs = []; + let index = 0; + const indexArray = []; + const halfHeight = height / 2; + let groupStart = 0; + generateTorso(); + if (openEnded === false) { + if (radiusTop > 0) generateCap(true); + if (radiusBottom > 0) generateCap(false); + } + this.setIndex(indices); + this.setAttribute("position", new Float32BufferAttribute(vertices, 3)); + this.setAttribute("normal", new Float32BufferAttribute(normals, 3)); + this.setAttribute("uv", new Float32BufferAttribute(uvs, 2)); + function generateTorso() { + const normal = new Vector3(); + const vertex2 = new Vector3(); + let groupCount = 0; + const slope = (radiusBottom - radiusTop) / height; + for (let y = 0; y <= heightSegments; y++) { + const indexRow = []; + const v = y / heightSegments; + const radius = v * (radiusBottom - radiusTop) + radiusTop; + for (let x = 0; x <= radialSegments; x++) { + const u = x / radialSegments; + const theta = u * thetaLength + thetaStart; + const sinTheta = Math.sin(theta); + const cosTheta = Math.cos(theta); + vertex2.x = radius * sinTheta; + vertex2.y = -v * height + halfHeight; + vertex2.z = radius * cosTheta; + vertices.push(vertex2.x, vertex2.y, vertex2.z); + normal.set(sinTheta, slope, cosTheta).normalize(); + normals.push(normal.x, normal.y, normal.z); + uvs.push(u, 1 - v); + indexRow.push(index++); + } + indexArray.push(indexRow); + } + for (let x = 0; x < radialSegments; x++) { + for (let y = 0; y < heightSegments; y++) { + const a = indexArray[y][x]; + const b = indexArray[y + 1][x]; + const c = indexArray[y + 1][x + 1]; + const d = indexArray[y][x + 1]; + indices.push(a, b, d); + indices.push(b, c, d); + groupCount += 6; + } + } + scope.addGroup(groupStart, groupCount, 0); + groupStart += groupCount; + } + function generateCap(top) { + const centerIndexStart = index; + const uv = new Vector2(); + const vertex2 = new Vector3(); + let groupCount = 0; + const radius = top === true ? radiusTop : radiusBottom; + const sign2 = top === true ? 1 : -1; + for (let x = 1; x <= radialSegments; x++) { + vertices.push(0, halfHeight * sign2, 0); + normals.push(0, sign2, 0); + uvs.push(0.5, 0.5); + index++; + } + const centerIndexEnd = index; + for (let x = 0; x <= radialSegments; x++) { + const u = x / radialSegments; + const theta = u * thetaLength + thetaStart; + const cosTheta = Math.cos(theta); + const sinTheta = Math.sin(theta); + vertex2.x = radius * sinTheta; + vertex2.y = halfHeight * sign2; + vertex2.z = radius * cosTheta; + vertices.push(vertex2.x, vertex2.y, vertex2.z); + normals.push(0, sign2, 0); + uv.x = cosTheta * 0.5 + 0.5; + uv.y = sinTheta * 0.5 * sign2 + 0.5; + uvs.push(uv.x, uv.y); + index++; + } + for (let x = 0; x < radialSegments; x++) { + const c = centerIndexStart + x; + const i = centerIndexEnd + x; + if (top === true) { + indices.push(i, i + 1, c); + } else { + indices.push(i + 1, i, c); + } + groupCount += 3; + } + scope.addGroup(groupStart, groupCount, top === true ? 1 : 2); + groupStart += groupCount; + } + } + copy(source) { + super.copy(source); + this.parameters = Object.assign({}, source.parameters); + return this; + } + static fromJSON(data) { + return new _CylinderGeometry(data.radiusTop, data.radiusBottom, data.height, data.radialSegments, data.heightSegments, data.openEnded, data.thetaStart, data.thetaLength); + } +}; +var Earcut = { + triangulate: function(data, holeIndices, dim = 2) { + const hasHoles = holeIndices && holeIndices.length; + const outerLen = hasHoles ? holeIndices[0] * dim : data.length; + let outerNode = linkedList(data, 0, outerLen, dim, true); + const triangles = []; + if (!outerNode || outerNode.next === outerNode.prev) return triangles; + let minX, minY, maxX, maxY, x, y, invSize; + if (hasHoles) outerNode = eliminateHoles(data, holeIndices, outerNode, dim); + if (data.length > 80 * dim) { + minX = maxX = data[0]; + minY = maxY = data[1]; + for (let i = dim; i < outerLen; i += dim) { + x = data[i]; + y = data[i + 1]; + if (x < minX) minX = x; + if (y < minY) minY = y; + if (x > maxX) maxX = x; + if (y > maxY) maxY = y; + } + invSize = Math.max(maxX - minX, maxY - minY); + invSize = invSize !== 0 ? 32767 / invSize : 0; + } + earcutLinked(outerNode, triangles, dim, minX, minY, invSize, 0); + return triangles; + } +}; +function linkedList(data, start, end, dim, clockwise) { + let i, last; + if (clockwise === signedArea(data, start, end, dim) > 0) { + for (i = start; i < end; i += dim) last = insertNode(i, data[i], data[i + 1], last); + } else { + for (i = end - dim; i >= start; i -= dim) last = insertNode(i, data[i], data[i + 1], last); + } + if (last && equals(last, last.next)) { + removeNode(last); + last = last.next; + } + return last; +} +function filterPoints(start, end) { + if (!start) return start; + if (!end) end = start; + let p = start, again; + do { + again = false; + if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) { + removeNode(p); + p = end = p.prev; + if (p === p.next) break; + again = true; + } else { + p = p.next; + } + } while (again || p !== end); + return end; +} +function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) { + if (!ear) return; + if (!pass && invSize) indexCurve(ear, minX, minY, invSize); + let stop = ear, prev, next; + while (ear.prev !== ear.next) { + prev = ear.prev; + next = ear.next; + if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) { + triangles.push(prev.i / dim | 0); + triangles.push(ear.i / dim | 0); + triangles.push(next.i / dim | 0); + removeNode(ear); + ear = next.next; + stop = next.next; + continue; + } + ear = next; + if (ear === stop) { + if (!pass) { + earcutLinked(filterPoints(ear), triangles, dim, minX, minY, invSize, 1); + } else if (pass === 1) { + ear = cureLocalIntersections(filterPoints(ear), triangles, dim); + earcutLinked(ear, triangles, dim, minX, minY, invSize, 2); + } else if (pass === 2) { + splitEarcut(ear, triangles, dim, minX, minY, invSize); + } + break; + } + } +} +function isEar(ear) { + const a = ear.prev, b = ear, c = ear.next; + if (area(a, b, c) >= 0) return false; + const ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y; + const x0 = ax < bx ? ax < cx ? ax : cx : bx < cx ? bx : cx, y0 = ay < by ? ay < cy ? ay : cy : by < cy ? by : cy, x1 = ax > bx ? ax > cx ? ax : cx : bx > cx ? bx : cx, y1 = ay > by ? ay > cy ? ay : cy : by > cy ? by : cy; + let p = c.next; + while (p !== a) { + if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false; + p = p.next; + } + return true; +} +function isEarHashed(ear, minX, minY, invSize) { + const a = ear.prev, b = ear, c = ear.next; + if (area(a, b, c) >= 0) return false; + const ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y; + const x0 = ax < bx ? ax < cx ? ax : cx : bx < cx ? bx : cx, y0 = ay < by ? ay < cy ? ay : cy : by < cy ? by : cy, x1 = ax > bx ? ax > cx ? ax : cx : bx > cx ? bx : cx, y1 = ay > by ? ay > cy ? ay : cy : by > cy ? by : cy; + const minZ = zOrder(x0, y0, minX, minY, invSize), maxZ = zOrder(x1, y1, minX, minY, invSize); + let p = ear.prevZ, n = ear.nextZ; + while (p && p.z >= minZ && n && n.z <= maxZ) { + if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false; + p = p.prevZ; + if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false; + n = n.nextZ; + } + while (p && p.z >= minZ) { + if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false; + p = p.prevZ; + } + while (n && n.z <= maxZ) { + if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false; + n = n.nextZ; + } + return true; +} +function cureLocalIntersections(start, triangles, dim) { + let p = start; + do { + const a = p.prev, b = p.next.next; + if (!equals(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) { + triangles.push(a.i / dim | 0); + triangles.push(p.i / dim | 0); + triangles.push(b.i / dim | 0); + removeNode(p); + removeNode(p.next); + p = start = b; + } + p = p.next; + } while (p !== start); + return filterPoints(p); +} +function splitEarcut(start, triangles, dim, minX, minY, invSize) { + let a = start; + do { + let b = a.next.next; + while (b !== a.prev) { + if (a.i !== b.i && isValidDiagonal(a, b)) { + let c = splitPolygon(a, b); + a = filterPoints(a, a.next); + c = filterPoints(c, c.next); + earcutLinked(a, triangles, dim, minX, minY, invSize, 0); + earcutLinked(c, triangles, dim, minX, minY, invSize, 0); + return; + } + b = b.next; + } + a = a.next; + } while (a !== start); +} +function eliminateHoles(data, holeIndices, outerNode, dim) { + const queue = []; + let i, len, start, end, list; + for (i = 0, len = holeIndices.length; i < len; i++) { + start = holeIndices[i] * dim; + end = i < len - 1 ? holeIndices[i + 1] * dim : data.length; + list = linkedList(data, start, end, dim, false); + if (list === list.next) list.steiner = true; + queue.push(getLeftmost(list)); + } + queue.sort(compareX); + for (i = 0; i < queue.length; i++) { + outerNode = eliminateHole(queue[i], outerNode); + } + return outerNode; +} +function compareX(a, b) { + return a.x - b.x; +} +function eliminateHole(hole, outerNode) { + const bridge = findHoleBridge(hole, outerNode); + if (!bridge) { + return outerNode; + } + const bridgeReverse = splitPolygon(bridge, hole); + filterPoints(bridgeReverse, bridgeReverse.next); + return filterPoints(bridge, bridge.next); +} +function findHoleBridge(hole, outerNode) { + let p = outerNode, qx = -Infinity, m; + const hx = hole.x, hy = hole.y; + do { + if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) { + const x = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y); + if (x <= hx && x > qx) { + qx = x; + m = p.x < p.next.x ? p : p.next; + if (x === hx) return m; + } + } + p = p.next; + } while (p !== outerNode); + if (!m) return null; + const stop = m, mx = m.x, my = m.y; + let tanMin = Infinity, tan; + p = m; + do { + if (hx >= p.x && p.x >= mx && hx !== p.x && pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) { + tan = Math.abs(hy - p.y) / (hx - p.x); + if (locallyInside(p, hole) && (tan < tanMin || tan === tanMin && (p.x > m.x || p.x === m.x && sectorContainsSector(m, p)))) { + m = p; + tanMin = tan; + } + } + p = p.next; + } while (p !== stop); + return m; +} +function sectorContainsSector(m, p) { + return area(m.prev, m, p.prev) < 0 && area(p.next, m, m.next) < 0; +} +function indexCurve(start, minX, minY, invSize) { + let p = start; + do { + if (p.z === 0) p.z = zOrder(p.x, p.y, minX, minY, invSize); + p.prevZ = p.prev; + p.nextZ = p.next; + p = p.next; + } while (p !== start); + p.prevZ.nextZ = null; + p.prevZ = null; + sortLinked(p); +} +function sortLinked(list) { + let i, p, q, e, tail, numMerges, pSize, qSize, inSize = 1; + do { + p = list; + list = null; + tail = null; + numMerges = 0; + while (p) { + numMerges++; + q = p; + pSize = 0; + for (i = 0; i < inSize; i++) { + pSize++; + q = q.nextZ; + if (!q) break; + } + qSize = inSize; + while (pSize > 0 || qSize > 0 && q) { + if (pSize !== 0 && (qSize === 0 || !q || p.z <= q.z)) { + e = p; + p = p.nextZ; + pSize--; + } else { + e = q; + q = q.nextZ; + qSize--; + } + if (tail) tail.nextZ = e; + else list = e; + e.prevZ = tail; + tail = e; + } + p = q; + } + tail.nextZ = null; + inSize *= 2; + } while (numMerges > 1); + return list; +} +function zOrder(x, y, minX, minY, invSize) { + x = (x - minX) * invSize | 0; + y = (y - minY) * invSize | 0; + x = (x | x << 8) & 16711935; + x = (x | x << 4) & 252645135; + x = (x | x << 2) & 858993459; + x = (x | x << 1) & 1431655765; + y = (y | y << 8) & 16711935; + y = (y | y << 4) & 252645135; + y = (y | y << 2) & 858993459; + y = (y | y << 1) & 1431655765; + return x | y << 1; +} +function getLeftmost(start) { + let p = start, leftmost = start; + do { + if (p.x < leftmost.x || p.x === leftmost.x && p.y < leftmost.y) leftmost = p; + p = p.next; + } while (p !== start); + return leftmost; +} +function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) { + return (cx - px) * (ay - py) >= (ax - px) * (cy - py) && (ax - px) * (by - py) >= (bx - px) * (ay - py) && (bx - px) * (cy - py) >= (cx - px) * (by - py); +} +function isValidDiagonal(a, b) { + return a.next.i !== b.i && a.prev.i !== b.i && !intersectsPolygon(a, b) && // dones't intersect other edges + (locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b) && // locally visible + (area(a.prev, a, b.prev) || area(a, b.prev, b)) || // does not create opposite-facing sectors + equals(a, b) && area(a.prev, a, a.next) > 0 && area(b.prev, b, b.next) > 0); +} +function area(p, q, r) { + return (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y); +} +function equals(p1, p2) { + return p1.x === p2.x && p1.y === p2.y; +} +function intersects(p1, q1, p2, q2) { + const o1 = sign(area(p1, q1, p2)); + const o2 = sign(area(p1, q1, q2)); + const o3 = sign(area(p2, q2, p1)); + const o4 = sign(area(p2, q2, q1)); + if (o1 !== o2 && o3 !== o4) return true; + if (o1 === 0 && onSegment(p1, p2, q1)) return true; + if (o2 === 0 && onSegment(p1, q2, q1)) return true; + if (o3 === 0 && onSegment(p2, p1, q2)) return true; + if (o4 === 0 && onSegment(p2, q1, q2)) return true; + return false; +} +function onSegment(p, q, r) { + return q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) && q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y); +} +function sign(num) { + return num > 0 ? 1 : num < 0 ? -1 : 0; +} +function intersectsPolygon(a, b) { + let p = a; + do { + if (p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i && intersects(p, p.next, a, b)) return true; + p = p.next; + } while (p !== a); + return false; +} +function locallyInside(a, b) { + return area(a.prev, a, a.next) < 0 ? area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0 : area(a, b, a.prev) < 0 || area(a, a.next, b) < 0; +} +function middleInside(a, b) { + let p = a, inside = false; + const px = (a.x + b.x) / 2, py = (a.y + b.y) / 2; + do { + if (p.y > py !== p.next.y > py && p.next.y !== p.y && px < (p.next.x - p.x) * (py - p.y) / (p.next.y - p.y) + p.x) + inside = !inside; + p = p.next; + } while (p !== a); + return inside; +} +function splitPolygon(a, b) { + const a2 = new Node(a.i, a.x, a.y), b2 = new Node(b.i, b.x, b.y), an = a.next, bp = b.prev; + a.next = b; + b.prev = a; + a2.next = an; + an.prev = a2; + b2.next = a2; + a2.prev = b2; + bp.next = b2; + b2.prev = bp; + return b2; +} +function insertNode(i, x, y, last) { + const p = new Node(i, x, y); + if (!last) { + p.prev = p; + p.next = p; + } else { + p.next = last.next; + p.prev = last; + last.next.prev = p; + last.next = p; + } + return p; +} +function removeNode(p) { + p.next.prev = p.prev; + p.prev.next = p.next; + if (p.prevZ) p.prevZ.nextZ = p.nextZ; + if (p.nextZ) p.nextZ.prevZ = p.prevZ; +} +function Node(i, x, y) { + this.i = i; + this.x = x; + this.y = y; + this.prev = null; + this.next = null; + this.z = 0; + this.prevZ = null; + this.nextZ = null; + this.steiner = false; +} +function signedArea(data, start, end, dim) { + let sum = 0; + for (let i = start, j = end - dim; i < end; i += dim) { + sum += (data[j] - data[i]) * (data[i + 1] + data[j + 1]); + j = i; + } + return sum; +} +var ShapeUtils = class _ShapeUtils { + // calculate area of the contour polygon + static area(contour) { + const n = contour.length; + let a = 0; + for (let p = n - 1, q = 0; q < n; p = q++) { + a += contour[p].x * contour[q].y - contour[q].x * contour[p].y; + } + return a * 0.5; + } + static isClockWise(pts) { + return _ShapeUtils.area(pts) < 0; + } + static triangulateShape(contour, holes) { + const vertices = []; + const holeIndices = []; + const faces = []; + removeDupEndPts(contour); + addContour(vertices, contour); + let holeIndex = contour.length; + holes.forEach(removeDupEndPts); + for (let i = 0; i < holes.length; i++) { + holeIndices.push(holeIndex); + holeIndex += holes[i].length; + addContour(vertices, holes[i]); + } + const triangles = Earcut.triangulate(vertices, holeIndices); + for (let i = 0; i < triangles.length; i += 3) { + faces.push(triangles.slice(i, i + 3)); + } + return faces; + } +}; +function removeDupEndPts(points) { + const l = points.length; + if (l > 2 && points[l - 1].equals(points[0])) { + points.pop(); + } +} +function addContour(vertices, contour) { + for (let i = 0; i < contour.length; i++) { + vertices.push(contour[i].x); + vertices.push(contour[i].y); + } +} +var SphereGeometry = class _SphereGeometry extends BufferGeometry { + constructor(radius = 1, widthSegments = 32, heightSegments = 16, phiStart = 0, phiLength = Math.PI * 2, thetaStart = 0, thetaLength = Math.PI) { + super(); + this.type = "SphereGeometry"; + this.parameters = { + radius, + widthSegments, + heightSegments, + phiStart, + phiLength, + thetaStart, + thetaLength + }; + widthSegments = Math.max(3, Math.floor(widthSegments)); + heightSegments = Math.max(2, Math.floor(heightSegments)); + const thetaEnd = Math.min(thetaStart + thetaLength, Math.PI); + let index = 0; + const grid = []; + const vertex2 = new Vector3(); + const normal = new Vector3(); + const indices = []; + const vertices = []; + const normals = []; + const uvs = []; + for (let iy = 0; iy <= heightSegments; iy++) { + const verticesRow = []; + const v = iy / heightSegments; + let uOffset = 0; + if (iy === 0 && thetaStart === 0) { + uOffset = 0.5 / widthSegments; + } else if (iy === heightSegments && thetaEnd === Math.PI) { + uOffset = -0.5 / widthSegments; + } + for (let ix = 0; ix <= widthSegments; ix++) { + const u = ix / widthSegments; + vertex2.x = -radius * Math.cos(phiStart + u * phiLength) * Math.sin(thetaStart + v * thetaLength); + vertex2.y = radius * Math.cos(thetaStart + v * thetaLength); + vertex2.z = radius * Math.sin(phiStart + u * phiLength) * Math.sin(thetaStart + v * thetaLength); + vertices.push(vertex2.x, vertex2.y, vertex2.z); + normal.copy(vertex2).normalize(); + normals.push(normal.x, normal.y, normal.z); + uvs.push(u + uOffset, 1 - v); + verticesRow.push(index++); + } + grid.push(verticesRow); + } + for (let iy = 0; iy < heightSegments; iy++) { + for (let ix = 0; ix < widthSegments; ix++) { + const a = grid[iy][ix + 1]; + const b = grid[iy][ix]; + const c = grid[iy + 1][ix]; + const d = grid[iy + 1][ix + 1]; + if (iy !== 0 || thetaStart > 0) indices.push(a, b, d); + if (iy !== heightSegments - 1 || thetaEnd < Math.PI) indices.push(b, c, d); + } + } + this.setIndex(indices); + this.setAttribute("position", new Float32BufferAttribute(vertices, 3)); + this.setAttribute("normal", new Float32BufferAttribute(normals, 3)); + this.setAttribute("uv", new Float32BufferAttribute(uvs, 2)); + } + copy(source) { + super.copy(source); + this.parameters = Object.assign({}, source.parameters); + return this; + } + static fromJSON(data) { + return new _SphereGeometry(data.radius, data.widthSegments, data.heightSegments, data.phiStart, data.phiLength, data.thetaStart, data.thetaLength); + } +}; +var MeshStandardMaterial = class extends Material { + constructor(parameters) { + super(); + this.isMeshStandardMaterial = true; + this.defines = { "STANDARD": "" }; + this.type = "MeshStandardMaterial"; + this.color = new Color(16777215); + this.roughness = 1; + this.metalness = 0; + this.map = null; + this.lightMap = null; + this.lightMapIntensity = 1; + this.aoMap = null; + this.aoMapIntensity = 1; + this.emissive = new Color(0); + this.emissiveIntensity = 1; + this.emissiveMap = null; + this.bumpMap = null; + this.bumpScale = 1; + this.normalMap = null; + this.normalMapType = TangentSpaceNormalMap; + this.normalScale = new Vector2(1, 1); + this.displacementMap = null; + this.displacementScale = 1; + this.displacementBias = 0; + this.roughnessMap = null; + this.metalnessMap = null; + this.alphaMap = null; + this.envMap = null; + this.envMapRotation = new Euler(); + this.envMapIntensity = 1; + this.wireframe = false; + this.wireframeLinewidth = 1; + this.wireframeLinecap = "round"; + this.wireframeLinejoin = "round"; + this.flatShading = false; + this.fog = true; + this.setValues(parameters); + } + copy(source) { + super.copy(source); + this.defines = { "STANDARD": "" }; + this.color.copy(source.color); + this.roughness = source.roughness; + this.metalness = source.metalness; + this.map = source.map; + this.lightMap = source.lightMap; + this.lightMapIntensity = source.lightMapIntensity; + this.aoMap = source.aoMap; + this.aoMapIntensity = source.aoMapIntensity; + this.emissive.copy(source.emissive); + this.emissiveMap = source.emissiveMap; + this.emissiveIntensity = source.emissiveIntensity; + this.bumpMap = source.bumpMap; + this.bumpScale = source.bumpScale; + this.normalMap = source.normalMap; + this.normalMapType = source.normalMapType; + this.normalScale.copy(source.normalScale); + this.displacementMap = source.displacementMap; + this.displacementScale = source.displacementScale; + this.displacementBias = source.displacementBias; + this.roughnessMap = source.roughnessMap; + this.metalnessMap = source.metalnessMap; + this.alphaMap = source.alphaMap; + this.envMap = source.envMap; + this.envMapRotation.copy(source.envMapRotation); + this.envMapIntensity = source.envMapIntensity; + this.wireframe = source.wireframe; + this.wireframeLinewidth = source.wireframeLinewidth; + this.wireframeLinecap = source.wireframeLinecap; + this.wireframeLinejoin = source.wireframeLinejoin; + this.flatShading = source.flatShading; + this.fog = source.fog; + return this; + } +}; +var MeshPhysicalMaterial = class extends MeshStandardMaterial { + constructor(parameters) { + super(); + this.isMeshPhysicalMaterial = true; + this.defines = { + "STANDARD": "", + "PHYSICAL": "" + }; + this.type = "MeshPhysicalMaterial"; + this.anisotropyRotation = 0; + this.anisotropyMap = null; + this.clearcoatMap = null; + this.clearcoatRoughness = 0; + this.clearcoatRoughnessMap = null; + this.clearcoatNormalScale = new Vector2(1, 1); + this.clearcoatNormalMap = null; + this.ior = 1.5; + Object.defineProperty(this, "reflectivity", { + get: function() { + return clamp(2.5 * (this.ior - 1) / (this.ior + 1), 0, 1); + }, + set: function(reflectivity) { + this.ior = (1 + 0.4 * reflectivity) / (1 - 0.4 * reflectivity); + } + }); + this.iridescenceMap = null; + this.iridescenceIOR = 1.3; + this.iridescenceThicknessRange = [100, 400]; + this.iridescenceThicknessMap = null; + this.sheenColor = new Color(0); + this.sheenColorMap = null; + this.sheenRoughness = 1; + this.sheenRoughnessMap = null; + this.transmissionMap = null; + this.thickness = 0; + this.thicknessMap = null; + this.attenuationDistance = Infinity; + this.attenuationColor = new Color(1, 1, 1); + this.specularIntensity = 1; + this.specularIntensityMap = null; + this.specularColor = new Color(1, 1, 1); + this.specularColorMap = null; + this._anisotropy = 0; + this._clearcoat = 0; + this._iridescence = 0; + this._sheen = 0; + this._transmission = 0; + this.setValues(parameters); + } + get anisotropy() { + return this._anisotropy; + } + set anisotropy(value) { + if (this._anisotropy > 0 !== value > 0) { + this.version++; + } + this._anisotropy = value; + } + get clearcoat() { + return this._clearcoat; + } + set clearcoat(value) { + if (this._clearcoat > 0 !== value > 0) { + this.version++; + } + this._clearcoat = value; + } + get iridescence() { + return this._iridescence; + } + set iridescence(value) { + if (this._iridescence > 0 !== value > 0) { + this.version++; + } + this._iridescence = value; + } + get sheen() { + return this._sheen; + } + set sheen(value) { + if (this._sheen > 0 !== value > 0) { + this.version++; + } + this._sheen = value; + } + get transmission() { + return this._transmission; + } + set transmission(value) { + if (this._transmission > 0 !== value > 0) { + this.version++; + } + this._transmission = value; + } + copy(source) { + super.copy(source); + this.defines = { + "STANDARD": "", + "PHYSICAL": "" + }; + this.anisotropy = source.anisotropy; + this.anisotropyRotation = source.anisotropyRotation; + this.anisotropyMap = source.anisotropyMap; + this.clearcoat = source.clearcoat; + this.clearcoatMap = source.clearcoatMap; + this.clearcoatRoughness = source.clearcoatRoughness; + this.clearcoatRoughnessMap = source.clearcoatRoughnessMap; + this.clearcoatNormalMap = source.clearcoatNormalMap; + this.clearcoatNormalScale.copy(source.clearcoatNormalScale); + this.ior = source.ior; + this.iridescence = source.iridescence; + this.iridescenceMap = source.iridescenceMap; + this.iridescenceIOR = source.iridescenceIOR; + this.iridescenceThicknessRange = [...source.iridescenceThicknessRange]; + this.iridescenceThicknessMap = source.iridescenceThicknessMap; + this.sheen = source.sheen; + this.sheenColor.copy(source.sheenColor); + this.sheenColorMap = source.sheenColorMap; + this.sheenRoughness = source.sheenRoughness; + this.sheenRoughnessMap = source.sheenRoughnessMap; + this.transmission = source.transmission; + this.transmissionMap = source.transmissionMap; + this.thickness = source.thickness; + this.thicknessMap = source.thicknessMap; + this.attenuationDistance = source.attenuationDistance; + this.attenuationColor.copy(source.attenuationColor); + this.specularIntensity = source.specularIntensity; + this.specularIntensityMap = source.specularIntensityMap; + this.specularColor.copy(source.specularColor); + this.specularColorMap = source.specularColorMap; + return this; + } +}; +var MeshPhongMaterial = class extends Material { + constructor(parameters) { + super(); + this.isMeshPhongMaterial = true; + this.type = "MeshPhongMaterial"; + this.color = new Color(16777215); + this.specular = new Color(1118481); + this.shininess = 30; + this.map = null; + this.lightMap = null; + this.lightMapIntensity = 1; + this.aoMap = null; + this.aoMapIntensity = 1; + this.emissive = new Color(0); + this.emissiveIntensity = 1; + this.emissiveMap = null; + this.bumpMap = null; + this.bumpScale = 1; + this.normalMap = null; + this.normalMapType = TangentSpaceNormalMap; + this.normalScale = new Vector2(1, 1); + this.displacementMap = null; + this.displacementScale = 1; + this.displacementBias = 0; + this.specularMap = null; + this.alphaMap = null; + this.envMap = null; + this.envMapRotation = new Euler(); + this.combine = MultiplyOperation; + this.reflectivity = 1; + this.refractionRatio = 0.98; + this.wireframe = false; + this.wireframeLinewidth = 1; + this.wireframeLinecap = "round"; + this.wireframeLinejoin = "round"; + this.flatShading = false; + this.fog = true; + this.setValues(parameters); + } + copy(source) { + super.copy(source); + this.color.copy(source.color); + this.specular.copy(source.specular); + this.shininess = source.shininess; + this.map = source.map; + this.lightMap = source.lightMap; + this.lightMapIntensity = source.lightMapIntensity; + this.aoMap = source.aoMap; + this.aoMapIntensity = source.aoMapIntensity; + this.emissive.copy(source.emissive); + this.emissiveMap = source.emissiveMap; + this.emissiveIntensity = source.emissiveIntensity; + this.bumpMap = source.bumpMap; + this.bumpScale = source.bumpScale; + this.normalMap = source.normalMap; + this.normalMapType = source.normalMapType; + this.normalScale.copy(source.normalScale); + this.displacementMap = source.displacementMap; + this.displacementScale = source.displacementScale; + this.displacementBias = source.displacementBias; + this.specularMap = source.specularMap; + this.alphaMap = source.alphaMap; + this.envMap = source.envMap; + this.envMapRotation.copy(source.envMapRotation); + this.combine = source.combine; + this.reflectivity = source.reflectivity; + this.refractionRatio = source.refractionRatio; + this.wireframe = source.wireframe; + this.wireframeLinewidth = source.wireframeLinewidth; + this.wireframeLinecap = source.wireframeLinecap; + this.wireframeLinejoin = source.wireframeLinejoin; + this.flatShading = source.flatShading; + this.fog = source.fog; + return this; + } +}; +var MeshLambertMaterial = class extends Material { + constructor(parameters) { + super(); + this.isMeshLambertMaterial = true; + this.type = "MeshLambertMaterial"; + this.color = new Color(16777215); + this.map = null; + this.lightMap = null; + this.lightMapIntensity = 1; + this.aoMap = null; + this.aoMapIntensity = 1; + this.emissive = new Color(0); + this.emissiveIntensity = 1; + this.emissiveMap = null; + this.bumpMap = null; + this.bumpScale = 1; + this.normalMap = null; + this.normalMapType = TangentSpaceNormalMap; + this.normalScale = new Vector2(1, 1); + this.displacementMap = null; + this.displacementScale = 1; + this.displacementBias = 0; + this.specularMap = null; + this.alphaMap = null; + this.envMap = null; + this.envMapRotation = new Euler(); + this.combine = MultiplyOperation; + this.reflectivity = 1; + this.refractionRatio = 0.98; + this.wireframe = false; + this.wireframeLinewidth = 1; + this.wireframeLinecap = "round"; + this.wireframeLinejoin = "round"; + this.flatShading = false; + this.fog = true; + this.setValues(parameters); + } + copy(source) { + super.copy(source); + this.color.copy(source.color); + this.map = source.map; + this.lightMap = source.lightMap; + this.lightMapIntensity = source.lightMapIntensity; + this.aoMap = source.aoMap; + this.aoMapIntensity = source.aoMapIntensity; + this.emissive.copy(source.emissive); + this.emissiveMap = source.emissiveMap; + this.emissiveIntensity = source.emissiveIntensity; + this.bumpMap = source.bumpMap; + this.bumpScale = source.bumpScale; + this.normalMap = source.normalMap; + this.normalMapType = source.normalMapType; + this.normalScale.copy(source.normalScale); + this.displacementMap = source.displacementMap; + this.displacementScale = source.displacementScale; + this.displacementBias = source.displacementBias; + this.specularMap = source.specularMap; + this.alphaMap = source.alphaMap; + this.envMap = source.envMap; + this.envMapRotation.copy(source.envMapRotation); + this.combine = source.combine; + this.reflectivity = source.reflectivity; + this.refractionRatio = source.refractionRatio; + this.wireframe = source.wireframe; + this.wireframeLinewidth = source.wireframeLinewidth; + this.wireframeLinecap = source.wireframeLinecap; + this.wireframeLinejoin = source.wireframeLinejoin; + this.flatShading = source.flatShading; + this.fog = source.fog; + return this; + } +}; +function convertArray(array, type, forceClone) { + if (!array || // let 'undefined' and 'null' pass + !forceClone && array.constructor === type) return array; + if (typeof type.BYTES_PER_ELEMENT === "number") { + return new type(array); + } + return Array.prototype.slice.call(array); +} +function isTypedArray(object) { + return ArrayBuffer.isView(object) && !(object instanceof DataView); +} +function getKeyframeOrder(times) { + function compareTime(i, j) { + return times[i] - times[j]; + } + const n = times.length; + const result = new Array(n); + for (let i = 0; i !== n; ++i) result[i] = i; + result.sort(compareTime); + return result; +} +function sortedArray(values, stride, order) { + const nValues = values.length; + const result = new values.constructor(nValues); + for (let i = 0, dstOffset = 0; dstOffset !== nValues; ++i) { + const srcOffset = order[i] * stride; + for (let j = 0; j !== stride; ++j) { + result[dstOffset++] = values[srcOffset + j]; + } + } + return result; +} +function flattenJSON(jsonKeys, times, values, valuePropertyName) { + let i = 1, key = jsonKeys[0]; + while (key !== void 0 && key[valuePropertyName] === void 0) { + key = jsonKeys[i++]; + } + if (key === void 0) return; + let value = key[valuePropertyName]; + if (value === void 0) return; + if (Array.isArray(value)) { + do { + value = key[valuePropertyName]; + if (value !== void 0) { + times.push(key.time); + values.push.apply(values, value); + } + key = jsonKeys[i++]; + } while (key !== void 0); + } else if (value.toArray !== void 0) { + do { + value = key[valuePropertyName]; + if (value !== void 0) { + times.push(key.time); + value.toArray(values, values.length); + } + key = jsonKeys[i++]; + } while (key !== void 0); + } else { + do { + value = key[valuePropertyName]; + if (value !== void 0) { + times.push(key.time); + values.push(value); + } + key = jsonKeys[i++]; + } while (key !== void 0); + } +} +var Interpolant = class { + constructor(parameterPositions, sampleValues, sampleSize, resultBuffer) { + this.parameterPositions = parameterPositions; + this._cachedIndex = 0; + this.resultBuffer = resultBuffer !== void 0 ? resultBuffer : new sampleValues.constructor(sampleSize); + this.sampleValues = sampleValues; + this.valueSize = sampleSize; + this.settings = null; + this.DefaultSettings_ = {}; + } + evaluate(t) { + const pp = this.parameterPositions; + let i1 = this._cachedIndex, t1 = pp[i1], t0 = pp[i1 - 1]; + validate_interval: { + seek: { + let right2; + linear_scan: { + forward_scan: if (!(t < t1)) { + for (let giveUpAt = i1 + 2; ; ) { + if (t1 === void 0) { + if (t < t0) break forward_scan; + i1 = pp.length; + this._cachedIndex = i1; + return this.copySampleValue_(i1 - 1); + } + if (i1 === giveUpAt) break; + t0 = t1; + t1 = pp[++i1]; + if (t < t1) { + break seek; + } + } + right2 = pp.length; + break linear_scan; + } + if (!(t >= t0)) { + const t1global = pp[1]; + if (t < t1global) { + i1 = 2; + t0 = t1global; + } + for (let giveUpAt = i1 - 2; ; ) { + if (t0 === void 0) { + this._cachedIndex = 0; + return this.copySampleValue_(0); + } + if (i1 === giveUpAt) break; + t1 = t0; + t0 = pp[--i1 - 1]; + if (t >= t0) { + break seek; + } + } + right2 = i1; + i1 = 0; + break linear_scan; + } + break validate_interval; + } + while (i1 < right2) { + const mid = i1 + right2 >>> 1; + if (t < pp[mid]) { + right2 = mid; + } else { + i1 = mid + 1; + } + } + t1 = pp[i1]; + t0 = pp[i1 - 1]; + if (t0 === void 0) { + this._cachedIndex = 0; + return this.copySampleValue_(0); + } + if (t1 === void 0) { + i1 = pp.length; + this._cachedIndex = i1; + return this.copySampleValue_(i1 - 1); + } + } + this._cachedIndex = i1; + this.intervalChanged_(i1, t0, t1); + } + return this.interpolate_(i1, t0, t, t1); + } + getSettings_() { + return this.settings || this.DefaultSettings_; + } + copySampleValue_(index) { + const result = this.resultBuffer, values = this.sampleValues, stride = this.valueSize, offset = index * stride; + for (let i = 0; i !== stride; ++i) { + result[i] = values[offset + i]; + } + return result; + } + // Template methods for derived classes: + interpolate_() { + throw new Error("call to abstract method"); + } + intervalChanged_() { + } +}; +var CubicInterpolant = class extends Interpolant { + constructor(parameterPositions, sampleValues, sampleSize, resultBuffer) { + super(parameterPositions, sampleValues, sampleSize, resultBuffer); + this._weightPrev = -0; + this._offsetPrev = -0; + this._weightNext = -0; + this._offsetNext = -0; + this.DefaultSettings_ = { + endingStart: ZeroCurvatureEnding, + endingEnd: ZeroCurvatureEnding + }; + } + intervalChanged_(i1, t0, t1) { + const pp = this.parameterPositions; + let iPrev = i1 - 2, iNext = i1 + 1, tPrev = pp[iPrev], tNext = pp[iNext]; + if (tPrev === void 0) { + switch (this.getSettings_().endingStart) { + case ZeroSlopeEnding: + iPrev = i1; + tPrev = 2 * t0 - t1; + break; + case WrapAroundEnding: + iPrev = pp.length - 2; + tPrev = t0 + pp[iPrev] - pp[iPrev + 1]; + break; + default: + iPrev = i1; + tPrev = t1; + } + } + if (tNext === void 0) { + switch (this.getSettings_().endingEnd) { + case ZeroSlopeEnding: + iNext = i1; + tNext = 2 * t1 - t0; + break; + case WrapAroundEnding: + iNext = 1; + tNext = t1 + pp[1] - pp[0]; + break; + default: + iNext = i1 - 1; + tNext = t0; + } + } + const halfDt = (t1 - t0) * 0.5, stride = this.valueSize; + this._weightPrev = halfDt / (t0 - tPrev); + this._weightNext = halfDt / (tNext - t1); + this._offsetPrev = iPrev * stride; + this._offsetNext = iNext * stride; + } + interpolate_(i1, t0, t, t1) { + const result = this.resultBuffer, values = this.sampleValues, stride = this.valueSize, o1 = i1 * stride, o0 = o1 - stride, oP = this._offsetPrev, oN = this._offsetNext, wP = this._weightPrev, wN = this._weightNext, p = (t - t0) / (t1 - t0), pp = p * p, ppp = pp * p; + const sP = -wP * ppp + 2 * wP * pp - wP * p; + const s0 = (1 + wP) * ppp + (-1.5 - 2 * wP) * pp + (-0.5 + wP) * p + 1; + const s1 = (-1 - wN) * ppp + (1.5 + wN) * pp + 0.5 * p; + const sN = wN * ppp - wN * pp; + for (let i = 0; i !== stride; ++i) { + result[i] = sP * values[oP + i] + s0 * values[o0 + i] + s1 * values[o1 + i] + sN * values[oN + i]; + } + return result; + } +}; +var LinearInterpolant = class extends Interpolant { + constructor(parameterPositions, sampleValues, sampleSize, resultBuffer) { + super(parameterPositions, sampleValues, sampleSize, resultBuffer); + } + interpolate_(i1, t0, t, t1) { + const result = this.resultBuffer, values = this.sampleValues, stride = this.valueSize, offset1 = i1 * stride, offset0 = offset1 - stride, weight1 = (t - t0) / (t1 - t0), weight0 = 1 - weight1; + for (let i = 0; i !== stride; ++i) { + result[i] = values[offset0 + i] * weight0 + values[offset1 + i] * weight1; + } + return result; + } +}; +var DiscreteInterpolant = class extends Interpolant { + constructor(parameterPositions, sampleValues, sampleSize, resultBuffer) { + super(parameterPositions, sampleValues, sampleSize, resultBuffer); + } + interpolate_(i1) { + return this.copySampleValue_(i1 - 1); + } +}; +var KeyframeTrack = class { + constructor(name, times, values, interpolation) { + if (name === void 0) throw new Error("THREE.KeyframeTrack: track name is undefined"); + if (times === void 0 || times.length === 0) throw new Error("THREE.KeyframeTrack: no keyframes in track named " + name); + this.name = name; + this.times = convertArray(times, this.TimeBufferType); + this.values = convertArray(values, this.ValueBufferType); + this.setInterpolation(interpolation || this.DefaultInterpolation); + } + // Serialization (in static context, because of constructor invocation + // and automatic invocation of .toJSON): + static toJSON(track) { + const trackType = track.constructor; + let json; + if (trackType.toJSON !== this.toJSON) { + json = trackType.toJSON(track); + } else { + json = { + "name": track.name, + "times": convertArray(track.times, Array), + "values": convertArray(track.values, Array) + }; + const interpolation = track.getInterpolation(); + if (interpolation !== track.DefaultInterpolation) { + json.interpolation = interpolation; + } + } + json.type = track.ValueTypeName; + return json; + } + InterpolantFactoryMethodDiscrete(result) { + return new DiscreteInterpolant(this.times, this.values, this.getValueSize(), result); + } + InterpolantFactoryMethodLinear(result) { + return new LinearInterpolant(this.times, this.values, this.getValueSize(), result); + } + InterpolantFactoryMethodSmooth(result) { + return new CubicInterpolant(this.times, this.values, this.getValueSize(), result); + } + setInterpolation(interpolation) { + let factoryMethod; + switch (interpolation) { + case InterpolateDiscrete: + factoryMethod = this.InterpolantFactoryMethodDiscrete; + break; + case InterpolateLinear: + factoryMethod = this.InterpolantFactoryMethodLinear; + break; + case InterpolateSmooth: + factoryMethod = this.InterpolantFactoryMethodSmooth; + break; + } + if (factoryMethod === void 0) { + const message = "unsupported interpolation for " + this.ValueTypeName + " keyframe track named " + this.name; + if (this.createInterpolant === void 0) { + if (interpolation !== this.DefaultInterpolation) { + this.setInterpolation(this.DefaultInterpolation); + } else { + throw new Error(message); + } + } + console.warn("THREE.KeyframeTrack:", message); + return this; + } + this.createInterpolant = factoryMethod; + return this; + } + getInterpolation() { + switch (this.createInterpolant) { + case this.InterpolantFactoryMethodDiscrete: + return InterpolateDiscrete; + case this.InterpolantFactoryMethodLinear: + return InterpolateLinear; + case this.InterpolantFactoryMethodSmooth: + return InterpolateSmooth; + } + } + getValueSize() { + return this.values.length / this.times.length; + } + // move all keyframes either forwards or backwards in time + shift(timeOffset) { + if (timeOffset !== 0) { + const times = this.times; + for (let i = 0, n = times.length; i !== n; ++i) { + times[i] += timeOffset; + } + } + return this; + } + // scale all keyframe times by a factor (useful for frame <-> seconds conversions) + scale(timeScale) { + if (timeScale !== 1) { + const times = this.times; + for (let i = 0, n = times.length; i !== n; ++i) { + times[i] *= timeScale; + } + } + return this; + } + // removes keyframes before and after animation without changing any values within the range [startTime, endTime]. + // IMPORTANT: We do not shift around keys to the start of the track time, because for interpolated keys this will change their values + trim(startTime, endTime) { + const times = this.times, nKeys = times.length; + let from = 0, to = nKeys - 1; + while (from !== nKeys && times[from] < startTime) { + ++from; + } + while (to !== -1 && times[to] > endTime) { + --to; + } + ++to; + if (from !== 0 || to !== nKeys) { + if (from >= to) { + to = Math.max(to, 1); + from = to - 1; + } + const stride = this.getValueSize(); + this.times = times.slice(from, to); + this.values = this.values.slice(from * stride, to * stride); + } + return this; + } + // ensure we do not get a GarbageInGarbageOut situation, make sure tracks are at least minimally viable + validate() { + let valid = true; + const valueSize = this.getValueSize(); + if (valueSize - Math.floor(valueSize) !== 0) { + console.error("THREE.KeyframeTrack: Invalid value size in track.", this); + valid = false; + } + const times = this.times, values = this.values, nKeys = times.length; + if (nKeys === 0) { + console.error("THREE.KeyframeTrack: Track is empty.", this); + valid = false; + } + let prevTime = null; + for (let i = 0; i !== nKeys; i++) { + const currTime = times[i]; + if (typeof currTime === "number" && isNaN(currTime)) { + console.error("THREE.KeyframeTrack: Time is not a valid number.", this, i, currTime); + valid = false; + break; + } + if (prevTime !== null && prevTime > currTime) { + console.error("THREE.KeyframeTrack: Out of order keys.", this, i, currTime, prevTime); + valid = false; + break; + } + prevTime = currTime; + } + if (values !== void 0) { + if (isTypedArray(values)) { + for (let i = 0, n = values.length; i !== n; ++i) { + const value = values[i]; + if (isNaN(value)) { + console.error("THREE.KeyframeTrack: Value is not a valid number.", this, i, value); + valid = false; + break; + } + } + } + } + return valid; + } + // removes equivalent sequential keys as common in morph target sequences + // (0,0,0,0,1,1,1,0,0,0,0,0,0,0) --> (0,0,1,1,0,0) + optimize() { + const times = this.times.slice(), values = this.values.slice(), stride = this.getValueSize(), smoothInterpolation = this.getInterpolation() === InterpolateSmooth, lastIndex = times.length - 1; + let writeIndex = 1; + for (let i = 1; i < lastIndex; ++i) { + let keep = false; + const time = times[i]; + const timeNext = times[i + 1]; + if (time !== timeNext && (i !== 1 || time !== times[0])) { + if (!smoothInterpolation) { + const offset = i * stride, offsetP = offset - stride, offsetN = offset + stride; + for (let j = 0; j !== stride; ++j) { + const value = values[offset + j]; + if (value !== values[offsetP + j] || value !== values[offsetN + j]) { + keep = true; + break; + } + } + } else { + keep = true; + } + } + if (keep) { + if (i !== writeIndex) { + times[writeIndex] = times[i]; + const readOffset = i * stride, writeOffset = writeIndex * stride; + for (let j = 0; j !== stride; ++j) { + values[writeOffset + j] = values[readOffset + j]; + } + } + ++writeIndex; + } + } + if (lastIndex > 0) { + times[writeIndex] = times[lastIndex]; + for (let readOffset = lastIndex * stride, writeOffset = writeIndex * stride, j = 0; j !== stride; ++j) { + values[writeOffset + j] = values[readOffset + j]; + } + ++writeIndex; + } + if (writeIndex !== times.length) { + this.times = times.slice(0, writeIndex); + this.values = values.slice(0, writeIndex * stride); + } else { + this.times = times; + this.values = values; + } + return this; + } + clone() { + const times = this.times.slice(); + const values = this.values.slice(); + const TypedKeyframeTrack = this.constructor; + const track = new TypedKeyframeTrack(this.name, times, values); + track.createInterpolant = this.createInterpolant; + return track; + } +}; +KeyframeTrack.prototype.TimeBufferType = Float32Array; +KeyframeTrack.prototype.ValueBufferType = Float32Array; +KeyframeTrack.prototype.DefaultInterpolation = InterpolateLinear; +var BooleanKeyframeTrack = class extends KeyframeTrack { +}; +BooleanKeyframeTrack.prototype.ValueTypeName = "bool"; +BooleanKeyframeTrack.prototype.ValueBufferType = Array; +BooleanKeyframeTrack.prototype.DefaultInterpolation = InterpolateDiscrete; +BooleanKeyframeTrack.prototype.InterpolantFactoryMethodLinear = void 0; +BooleanKeyframeTrack.prototype.InterpolantFactoryMethodSmooth = void 0; +var ColorKeyframeTrack = class extends KeyframeTrack { +}; +ColorKeyframeTrack.prototype.ValueTypeName = "color"; +var NumberKeyframeTrack = class extends KeyframeTrack { +}; +NumberKeyframeTrack.prototype.ValueTypeName = "number"; +var QuaternionLinearInterpolant = class extends Interpolant { + constructor(parameterPositions, sampleValues, sampleSize, resultBuffer) { + super(parameterPositions, sampleValues, sampleSize, resultBuffer); + } + interpolate_(i1, t0, t, t1) { + const result = this.resultBuffer, values = this.sampleValues, stride = this.valueSize, alpha = (t - t0) / (t1 - t0); + let offset = i1 * stride; + for (let end = offset + stride; offset !== end; offset += 4) { + Quaternion.slerpFlat(result, 0, values, offset - stride, values, offset, alpha); + } + return result; + } +}; +var QuaternionKeyframeTrack = class extends KeyframeTrack { + InterpolantFactoryMethodLinear(result) { + return new QuaternionLinearInterpolant(this.times, this.values, this.getValueSize(), result); + } +}; +QuaternionKeyframeTrack.prototype.ValueTypeName = "quaternion"; +QuaternionKeyframeTrack.prototype.DefaultInterpolation = InterpolateLinear; +QuaternionKeyframeTrack.prototype.InterpolantFactoryMethodSmooth = void 0; +var StringKeyframeTrack = class extends KeyframeTrack { +}; +StringKeyframeTrack.prototype.ValueTypeName = "string"; +StringKeyframeTrack.prototype.ValueBufferType = Array; +StringKeyframeTrack.prototype.DefaultInterpolation = InterpolateDiscrete; +StringKeyframeTrack.prototype.InterpolantFactoryMethodLinear = void 0; +StringKeyframeTrack.prototype.InterpolantFactoryMethodSmooth = void 0; +var VectorKeyframeTrack = class extends KeyframeTrack { +}; +VectorKeyframeTrack.prototype.ValueTypeName = "vector"; +var AnimationClip = class { + constructor(name = "", duration = -1, tracks = [], blendMode = NormalAnimationBlendMode) { + this.name = name; + this.tracks = tracks; + this.duration = duration; + this.blendMode = blendMode; + this.uuid = generateUUID(); + if (this.duration < 0) { + this.resetDuration(); + } + } + static parse(json) { + const tracks = [], jsonTracks = json.tracks, frameTime = 1 / (json.fps || 1); + for (let i = 0, n = jsonTracks.length; i !== n; ++i) { + tracks.push(parseKeyframeTrack(jsonTracks[i]).scale(frameTime)); + } + const clip = new this(json.name, json.duration, tracks, json.blendMode); + clip.uuid = json.uuid; + return clip; + } + static toJSON(clip) { + const tracks = [], clipTracks = clip.tracks; + const json = { + "name": clip.name, + "duration": clip.duration, + "tracks": tracks, + "uuid": clip.uuid, + "blendMode": clip.blendMode + }; + for (let i = 0, n = clipTracks.length; i !== n; ++i) { + tracks.push(KeyframeTrack.toJSON(clipTracks[i])); + } + return json; + } + static CreateFromMorphTargetSequence(name, morphTargetSequence, fps, noLoop) { + const numMorphTargets = morphTargetSequence.length; + const tracks = []; + for (let i = 0; i < numMorphTargets; i++) { + let times = []; + let values = []; + times.push( + (i + numMorphTargets - 1) % numMorphTargets, + i, + (i + 1) % numMorphTargets + ); + values.push(0, 1, 0); + const order = getKeyframeOrder(times); + times = sortedArray(times, 1, order); + values = sortedArray(values, 1, order); + if (!noLoop && times[0] === 0) { + times.push(numMorphTargets); + values.push(values[0]); + } + tracks.push( + new NumberKeyframeTrack( + ".morphTargetInfluences[" + morphTargetSequence[i].name + "]", + times, + values + ).scale(1 / fps) + ); + } + return new this(name, -1, tracks); + } + static findByName(objectOrClipArray, name) { + let clipArray = objectOrClipArray; + if (!Array.isArray(objectOrClipArray)) { + const o = objectOrClipArray; + clipArray = o.geometry && o.geometry.animations || o.animations; + } + for (let i = 0; i < clipArray.length; i++) { + if (clipArray[i].name === name) { + return clipArray[i]; + } + } + return null; + } + static CreateClipsFromMorphTargetSequences(morphTargets, fps, noLoop) { + const animationToMorphTargets = {}; + const pattern = /^([\w-]*?)([\d]+)$/; + for (let i = 0, il = morphTargets.length; i < il; i++) { + const morphTarget = morphTargets[i]; + const parts = morphTarget.name.match(pattern); + if (parts && parts.length > 1) { + const name = parts[1]; + let animationMorphTargets = animationToMorphTargets[name]; + if (!animationMorphTargets) { + animationToMorphTargets[name] = animationMorphTargets = []; + } + animationMorphTargets.push(morphTarget); + } + } + const clips = []; + for (const name in animationToMorphTargets) { + clips.push(this.CreateFromMorphTargetSequence(name, animationToMorphTargets[name], fps, noLoop)); + } + return clips; + } + // parse the animation.hierarchy format + static parseAnimation(animation, bones) { + if (!animation) { + console.error("THREE.AnimationClip: No animation in JSONLoader data."); + return null; + } + const addNonemptyTrack = function(trackType, trackName, animationKeys, propertyName, destTracks) { + if (animationKeys.length !== 0) { + const times = []; + const values = []; + flattenJSON(animationKeys, times, values, propertyName); + if (times.length !== 0) { + destTracks.push(new trackType(trackName, times, values)); + } + } + }; + const tracks = []; + const clipName = animation.name || "default"; + const fps = animation.fps || 30; + const blendMode = animation.blendMode; + let duration = animation.length || -1; + const hierarchyTracks = animation.hierarchy || []; + for (let h = 0; h < hierarchyTracks.length; h++) { + const animationKeys = hierarchyTracks[h].keys; + if (!animationKeys || animationKeys.length === 0) continue; + if (animationKeys[0].morphTargets) { + const morphTargetNames = {}; + let k; + for (k = 0; k < animationKeys.length; k++) { + if (animationKeys[k].morphTargets) { + for (let m = 0; m < animationKeys[k].morphTargets.length; m++) { + morphTargetNames[animationKeys[k].morphTargets[m]] = -1; + } + } + } + for (const morphTargetName in morphTargetNames) { + const times = []; + const values = []; + for (let m = 0; m !== animationKeys[k].morphTargets.length; ++m) { + const animationKey = animationKeys[k]; + times.push(animationKey.time); + values.push(animationKey.morphTarget === morphTargetName ? 1 : 0); + } + tracks.push(new NumberKeyframeTrack(".morphTargetInfluence[" + morphTargetName + "]", times, values)); + } + duration = morphTargetNames.length * fps; + } else { + const boneName = ".bones[" + bones[h].name + "]"; + addNonemptyTrack( + VectorKeyframeTrack, + boneName + ".position", + animationKeys, + "pos", + tracks + ); + addNonemptyTrack( + QuaternionKeyframeTrack, + boneName + ".quaternion", + animationKeys, + "rot", + tracks + ); + addNonemptyTrack( + VectorKeyframeTrack, + boneName + ".scale", + animationKeys, + "scl", + tracks + ); + } + } + if (tracks.length === 0) { + return null; + } + const clip = new this(clipName, duration, tracks, blendMode); + return clip; + } + resetDuration() { + const tracks = this.tracks; + let duration = 0; + for (let i = 0, n = tracks.length; i !== n; ++i) { + const track = this.tracks[i]; + duration = Math.max(duration, track.times[track.times.length - 1]); + } + this.duration = duration; + return this; + } + trim() { + for (let i = 0; i < this.tracks.length; i++) { + this.tracks[i].trim(0, this.duration); + } + return this; + } + validate() { + let valid = true; + for (let i = 0; i < this.tracks.length; i++) { + valid = valid && this.tracks[i].validate(); + } + return valid; + } + optimize() { + for (let i = 0; i < this.tracks.length; i++) { + this.tracks[i].optimize(); + } + return this; + } + clone() { + const tracks = []; + for (let i = 0; i < this.tracks.length; i++) { + tracks.push(this.tracks[i].clone()); + } + return new this.constructor(this.name, this.duration, tracks, this.blendMode); + } + toJSON() { + return this.constructor.toJSON(this); + } +}; +function getTrackTypeForValueTypeName(typeName) { + switch (typeName.toLowerCase()) { + case "scalar": + case "double": + case "float": + case "number": + case "integer": + return NumberKeyframeTrack; + case "vector": + case "vector2": + case "vector3": + case "vector4": + return VectorKeyframeTrack; + case "color": + return ColorKeyframeTrack; + case "quaternion": + return QuaternionKeyframeTrack; + case "bool": + case "boolean": + return BooleanKeyframeTrack; + case "string": + return StringKeyframeTrack; + } + throw new Error("THREE.KeyframeTrack: Unsupported typeName: " + typeName); +} +function parseKeyframeTrack(json) { + if (json.type === void 0) { + throw new Error("THREE.KeyframeTrack: track type undefined, can not parse"); + } + const trackType = getTrackTypeForValueTypeName(json.type); + if (json.times === void 0) { + const times = [], values = []; + flattenJSON(json.keys, times, values, "value"); + json.times = times; + json.values = values; + } + if (trackType.parse !== void 0) { + return trackType.parse(json); + } else { + return new trackType(json.name, json.times, json.values, json.interpolation); + } +} +var Cache = { + enabled: false, + files: {}, + add: function(key, file) { + if (this.enabled === false) return; + this.files[key] = file; + }, + get: function(key) { + if (this.enabled === false) return; + return this.files[key]; + }, + remove: function(key) { + delete this.files[key]; + }, + clear: function() { + this.files = {}; + } +}; +var LoadingManager = class { + constructor(onLoad, onProgress, onError) { + const scope = this; + let isLoading = false; + let itemsLoaded = 0; + let itemsTotal = 0; + let urlModifier = void 0; + const handlers = []; + this.onStart = void 0; + this.onLoad = onLoad; + this.onProgress = onProgress; + this.onError = onError; + this.itemStart = function(url) { + itemsTotal++; + if (isLoading === false) { + if (scope.onStart !== void 0) { + scope.onStart(url, itemsLoaded, itemsTotal); + } + } + isLoading = true; + }; + this.itemEnd = function(url) { + itemsLoaded++; + if (scope.onProgress !== void 0) { + scope.onProgress(url, itemsLoaded, itemsTotal); + } + if (itemsLoaded === itemsTotal) { + isLoading = false; + if (scope.onLoad !== void 0) { + scope.onLoad(); + } + } + }; + this.itemError = function(url) { + if (scope.onError !== void 0) { + scope.onError(url); + } + }; + this.resolveURL = function(url) { + if (urlModifier) { + return urlModifier(url); + } + return url; + }; + this.setURLModifier = function(transform) { + urlModifier = transform; + return this; + }; + this.addHandler = function(regex, loader) { + handlers.push(regex, loader); + return this; + }; + this.removeHandler = function(regex) { + const index = handlers.indexOf(regex); + if (index !== -1) { + handlers.splice(index, 2); + } + return this; + }; + this.getHandler = function(file) { + for (let i = 0, l = handlers.length; i < l; i += 2) { + const regex = handlers[i]; + const loader = handlers[i + 1]; + if (regex.global) regex.lastIndex = 0; + if (regex.test(file)) { + return loader; + } + } + return null; + }; + } +}; +var DefaultLoadingManager = /* @__PURE__ */ new LoadingManager(); +var Loader = class { + constructor(manager) { + this.manager = manager !== void 0 ? manager : DefaultLoadingManager; + this.crossOrigin = "anonymous"; + this.withCredentials = false; + this.path = ""; + this.resourcePath = ""; + this.requestHeader = {}; + } + load() { + } + loadAsync(url, onProgress) { + const scope = this; + return new Promise(function(resolve, reject) { + scope.load(url, resolve, onProgress, reject); + }); + } + parse() { + } + setCrossOrigin(crossOrigin) { + this.crossOrigin = crossOrigin; + return this; + } + setWithCredentials(value) { + this.withCredentials = value; + return this; + } + setPath(path) { + this.path = path; + return this; + } + setResourcePath(resourcePath) { + this.resourcePath = resourcePath; + return this; + } + setRequestHeader(requestHeader) { + this.requestHeader = requestHeader; + return this; + } +}; +Loader.DEFAULT_MATERIAL_NAME = "__DEFAULT"; +var loading = {}; +var HttpError = class extends Error { + constructor(message, response) { + super(message); + this.response = response; + } +}; +var FileLoader = class extends Loader { + constructor(manager) { + super(manager); + } + load(url, onLoad, onProgress, onError) { + if (url === void 0) url = ""; + if (this.path !== void 0) url = this.path + url; + url = this.manager.resolveURL(url); + const cached = Cache.get(url); + if (cached !== void 0) { + this.manager.itemStart(url); + setTimeout(() => { + if (onLoad) onLoad(cached); + this.manager.itemEnd(url); + }, 0); + return cached; + } + if (loading[url] !== void 0) { + loading[url].push({ + onLoad, + onProgress, + onError + }); + return; + } + loading[url] = []; + loading[url].push({ + onLoad, + onProgress, + onError + }); + const req = new Request(url, { + headers: new Headers(this.requestHeader), + credentials: this.withCredentials ? "include" : "same-origin" + // An abort controller could be added within a future PR + }); + const mimeType = this.mimeType; + const responseType = this.responseType; + fetch(req).then((response) => { + if (response.status === 200 || response.status === 0) { + if (response.status === 0) { + console.warn("THREE.FileLoader: HTTP Status 0 received."); + } + if (typeof ReadableStream === "undefined" || response.body === void 0 || response.body.getReader === void 0) { + return response; + } + const callbacks = loading[url]; + const reader = response.body.getReader(); + const contentLength = response.headers.get("Content-Length") || response.headers.get("X-File-Size"); + const total = contentLength ? parseInt(contentLength) : 0; + const lengthComputable = total !== 0; + let loaded = 0; + const stream = new ReadableStream({ + start(controller) { + readData(); + function readData() { + reader.read().then(({ done, value }) => { + if (done) { + controller.close(); + } else { + loaded += value.byteLength; + const event = new ProgressEvent("progress", { lengthComputable, loaded, total }); + for (let i = 0, il = callbacks.length; i < il; i++) { + const callback = callbacks[i]; + if (callback.onProgress) callback.onProgress(event); + } + controller.enqueue(value); + readData(); + } + }); + } + } + }); + return new Response(stream); + } else { + throw new HttpError(`fetch for "${response.url}" responded with ${response.status}: ${response.statusText}`, response); + } + }).then((response) => { + switch (responseType) { + case "arraybuffer": + return response.arrayBuffer(); + case "blob": + return response.blob(); + case "document": + return response.text().then((text) => { + const parser = new DOMParser(); + return parser.parseFromString(text, mimeType); + }); + case "json": + return response.json(); + default: + if (mimeType === void 0) { + return response.text(); + } else { + const re = /charset="?([^;"\s]*)"?/i; + const exec = re.exec(mimeType); + const label = exec && exec[1] ? exec[1].toLowerCase() : void 0; + const decoder = new TextDecoder(label); + return response.arrayBuffer().then((ab) => decoder.decode(ab)); + } + } + }).then((data) => { + Cache.add(url, data); + const callbacks = loading[url]; + delete loading[url]; + for (let i = 0, il = callbacks.length; i < il; i++) { + const callback = callbacks[i]; + if (callback.onLoad) callback.onLoad(data); + } + }).catch((err2) => { + const callbacks = loading[url]; + if (callbacks === void 0) { + this.manager.itemError(url); + throw err2; + } + delete loading[url]; + for (let i = 0, il = callbacks.length; i < il; i++) { + const callback = callbacks[i]; + if (callback.onError) callback.onError(err2); + } + this.manager.itemError(url); + }).finally(() => { + this.manager.itemEnd(url); + }); + this.manager.itemStart(url); + } + setResponseType(value) { + this.responseType = value; + return this; + } + setMimeType(value) { + this.mimeType = value; + return this; + } +}; +var ImageLoader = class extends Loader { + constructor(manager) { + super(manager); + } + load(url, onLoad, onProgress, onError) { + if (this.path !== void 0) url = this.path + url; + url = this.manager.resolveURL(url); + const scope = this; + const cached = Cache.get(url); + if (cached !== void 0) { + scope.manager.itemStart(url); + setTimeout(function() { + if (onLoad) onLoad(cached); + scope.manager.itemEnd(url); + }, 0); + return cached; + } + const image = createElementNS("img"); + function onImageLoad() { + removeEventListeners(); + Cache.add(url, this); + if (onLoad) onLoad(this); + scope.manager.itemEnd(url); + } + function onImageError(event) { + removeEventListeners(); + if (onError) onError(event); + scope.manager.itemError(url); + scope.manager.itemEnd(url); + } + function removeEventListeners() { + image.removeEventListener("load", onImageLoad, false); + image.removeEventListener("error", onImageError, false); + } + image.addEventListener("load", onImageLoad, false); + image.addEventListener("error", onImageError, false); + if (url.slice(0, 5) !== "data:") { + if (this.crossOrigin !== void 0) image.crossOrigin = this.crossOrigin; + } + scope.manager.itemStart(url); + image.src = url; + return image; + } +}; +var TextureLoader = class extends Loader { + constructor(manager) { + super(manager); + } + load(url, onLoad, onProgress, onError) { + const texture = new Texture(); + const loader = new ImageLoader(this.manager); + loader.setCrossOrigin(this.crossOrigin); + loader.setPath(this.path); + loader.load(url, function(image) { + texture.image = image; + texture.needsUpdate = true; + if (onLoad !== void 0) { + onLoad(texture); + } + }, onProgress, onError); + return texture; + } +}; +var Light = class extends Object3D { + constructor(color, intensity = 1) { + super(); + this.isLight = true; + this.type = "Light"; + this.color = new Color(color); + this.intensity = intensity; + } + dispose() { + } + copy(source, recursive) { + super.copy(source, recursive); + this.color.copy(source.color); + this.intensity = source.intensity; + return this; + } + toJSON(meta) { + const data = super.toJSON(meta); + data.object.color = this.color.getHex(); + data.object.intensity = this.intensity; + if (this.groundColor !== void 0) data.object.groundColor = this.groundColor.getHex(); + if (this.distance !== void 0) data.object.distance = this.distance; + if (this.angle !== void 0) data.object.angle = this.angle; + if (this.decay !== void 0) data.object.decay = this.decay; + if (this.penumbra !== void 0) data.object.penumbra = this.penumbra; + if (this.shadow !== void 0) data.object.shadow = this.shadow.toJSON(); + return data; + } +}; +var _projScreenMatrix$1 = /* @__PURE__ */ new Matrix4(); +var _lightPositionWorld$1 = /* @__PURE__ */ new Vector3(); +var _lookTarget$1 = /* @__PURE__ */ new Vector3(); +var LightShadow = class { + constructor(camera) { + this.camera = camera; + this.bias = 0; + this.normalBias = 0; + this.radius = 1; + this.blurSamples = 8; + this.mapSize = new Vector2(512, 512); + this.map = null; + this.mapPass = null; + this.matrix = new Matrix4(); + this.autoUpdate = true; + this.needsUpdate = false; + this._frustum = new Frustum(); + this._frameExtents = new Vector2(1, 1); + this._viewportCount = 1; + this._viewports = [ + new Vector4(0, 0, 1, 1) + ]; + } + getViewportCount() { + return this._viewportCount; + } + getFrustum() { + return this._frustum; + } + updateMatrices(light) { + const shadowCamera = this.camera; + const shadowMatrix = this.matrix; + _lightPositionWorld$1.setFromMatrixPosition(light.matrixWorld); + shadowCamera.position.copy(_lightPositionWorld$1); + _lookTarget$1.setFromMatrixPosition(light.target.matrixWorld); + shadowCamera.lookAt(_lookTarget$1); + shadowCamera.updateMatrixWorld(); + _projScreenMatrix$1.multiplyMatrices(shadowCamera.projectionMatrix, shadowCamera.matrixWorldInverse); + this._frustum.setFromProjectionMatrix(_projScreenMatrix$1); + shadowMatrix.set( + 0.5, + 0, + 0, + 0.5, + 0, + 0.5, + 0, + 0.5, + 0, + 0, + 0.5, + 0.5, + 0, + 0, + 0, + 1 + ); + shadowMatrix.multiply(_projScreenMatrix$1); + } + getViewport(viewportIndex) { + return this._viewports[viewportIndex]; + } + getFrameExtents() { + return this._frameExtents; + } + dispose() { + if (this.map) { + this.map.dispose(); + } + if (this.mapPass) { + this.mapPass.dispose(); + } + } + copy(source) { + this.camera = source.camera.clone(); + this.bias = source.bias; + this.radius = source.radius; + this.mapSize.copy(source.mapSize); + return this; + } + clone() { + return new this.constructor().copy(this); + } + toJSON() { + const object = {}; + if (this.bias !== 0) object.bias = this.bias; + if (this.normalBias !== 0) object.normalBias = this.normalBias; + if (this.radius !== 1) object.radius = this.radius; + if (this.mapSize.x !== 512 || this.mapSize.y !== 512) object.mapSize = this.mapSize.toArray(); + object.camera = this.camera.toJSON(false).object; + delete object.camera.matrix; + return object; + } +}; +var SpotLightShadow = class extends LightShadow { + constructor() { + super(new PerspectiveCamera(50, 1, 0.5, 500)); + this.isSpotLightShadow = true; + this.focus = 1; + } + updateMatrices(light) { + const camera = this.camera; + const fov2 = RAD2DEG * 2 * light.angle * this.focus; + const aspect2 = this.mapSize.width / this.mapSize.height; + const far = light.distance || camera.far; + if (fov2 !== camera.fov || aspect2 !== camera.aspect || far !== camera.far) { + camera.fov = fov2; + camera.aspect = aspect2; + camera.far = far; + camera.updateProjectionMatrix(); + } + super.updateMatrices(light); + } + copy(source) { + super.copy(source); + this.focus = source.focus; + return this; + } +}; +var SpotLight = class extends Light { + constructor(color, intensity, distance = 0, angle = Math.PI / 3, penumbra = 0, decay = 2) { + super(color, intensity); + this.isSpotLight = true; + this.type = "SpotLight"; + this.position.copy(Object3D.DEFAULT_UP); + this.updateMatrix(); + this.target = new Object3D(); + this.distance = distance; + this.angle = angle; + this.penumbra = penumbra; + this.decay = decay; + this.map = null; + this.shadow = new SpotLightShadow(); + } + get power() { + return this.intensity * Math.PI; + } + set power(power) { + this.intensity = power / Math.PI; + } + dispose() { + this.shadow.dispose(); + } + copy(source, recursive) { + super.copy(source, recursive); + this.distance = source.distance; + this.angle = source.angle; + this.penumbra = source.penumbra; + this.decay = source.decay; + this.target = source.target.clone(); + this.shadow = source.shadow.clone(); + return this; + } +}; +var _projScreenMatrix = /* @__PURE__ */ new Matrix4(); +var _lightPositionWorld = /* @__PURE__ */ new Vector3(); +var _lookTarget = /* @__PURE__ */ new Vector3(); +var PointLightShadow = class extends LightShadow { + constructor() { + super(new PerspectiveCamera(90, 1, 0.5, 500)); + this.isPointLightShadow = true; + this._frameExtents = new Vector2(4, 2); + this._viewportCount = 6; + this._viewports = [ + // These viewports map a cube-map onto a 2D texture with the + // following orientation: + // + // xzXZ + // y Y + // + // X - Positive x direction + // x - Negative x direction + // Y - Positive y direction + // y - Negative y direction + // Z - Positive z direction + // z - Negative z direction + // positive X + new Vector4(2, 1, 1, 1), + // negative X + new Vector4(0, 1, 1, 1), + // positive Z + new Vector4(3, 1, 1, 1), + // negative Z + new Vector4(1, 1, 1, 1), + // positive Y + new Vector4(3, 0, 1, 1), + // negative Y + new Vector4(1, 0, 1, 1) + ]; + this._cubeDirections = [ + new Vector3(1, 0, 0), + new Vector3(-1, 0, 0), + new Vector3(0, 0, 1), + new Vector3(0, 0, -1), + new Vector3(0, 1, 0), + new Vector3(0, -1, 0) + ]; + this._cubeUps = [ + new Vector3(0, 1, 0), + new Vector3(0, 1, 0), + new Vector3(0, 1, 0), + new Vector3(0, 1, 0), + new Vector3(0, 0, 1), + new Vector3(0, 0, -1) + ]; + } + updateMatrices(light, viewportIndex = 0) { + const camera = this.camera; + const shadowMatrix = this.matrix; + const far = light.distance || camera.far; + if (far !== camera.far) { + camera.far = far; + camera.updateProjectionMatrix(); + } + _lightPositionWorld.setFromMatrixPosition(light.matrixWorld); + camera.position.copy(_lightPositionWorld); + _lookTarget.copy(camera.position); + _lookTarget.add(this._cubeDirections[viewportIndex]); + camera.up.copy(this._cubeUps[viewportIndex]); + camera.lookAt(_lookTarget); + camera.updateMatrixWorld(); + shadowMatrix.makeTranslation(-_lightPositionWorld.x, -_lightPositionWorld.y, -_lightPositionWorld.z); + _projScreenMatrix.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse); + this._frustum.setFromProjectionMatrix(_projScreenMatrix); + } +}; +var PointLight = class extends Light { + constructor(color, intensity, distance = 0, decay = 2) { + super(color, intensity); + this.isPointLight = true; + this.type = "PointLight"; + this.distance = distance; + this.decay = decay; + this.shadow = new PointLightShadow(); + } + get power() { + return this.intensity * 4 * Math.PI; + } + set power(power) { + this.intensity = power / (4 * Math.PI); + } + dispose() { + this.shadow.dispose(); + } + copy(source, recursive) { + super.copy(source, recursive); + this.distance = source.distance; + this.decay = source.decay; + this.shadow = source.shadow.clone(); + return this; + } +}; +var DirectionalLightShadow = class extends LightShadow { + constructor() { + super(new OrthographicCamera(-5, 5, 5, -5, 0.5, 500)); + this.isDirectionalLightShadow = true; + } +}; +var DirectionalLight = class extends Light { + constructor(color, intensity) { + super(color, intensity); + this.isDirectionalLight = true; + this.type = "DirectionalLight"; + this.position.copy(Object3D.DEFAULT_UP); + this.updateMatrix(); + this.target = new Object3D(); + this.shadow = new DirectionalLightShadow(); + } + dispose() { + this.shadow.dispose(); + } + copy(source) { + super.copy(source); + this.target = source.target.clone(); + this.shadow = source.shadow.clone(); + return this; + } +}; +var AmbientLight = class extends Light { + constructor(color, intensity) { + super(color, intensity); + this.isAmbientLight = true; + this.type = "AmbientLight"; + } +}; +var LoaderUtils = class { + static decodeText(array) { + if (typeof TextDecoder !== "undefined") { + return new TextDecoder().decode(array); + } + let s = ""; + for (let i = 0, il = array.length; i < il; i++) { + s += String.fromCharCode(array[i]); + } + try { + return decodeURIComponent(escape(s)); + } catch (e) { + return s; + } + } + static extractUrlBase(url) { + const index = url.lastIndexOf("/"); + if (index === -1) return "./"; + return url.slice(0, index + 1); + } + static resolveURL(url, path) { + if (typeof url !== "string" || url === "") return ""; + if (/^https?:\/\//i.test(path) && /^\//.test(url)) { + path = path.replace(/(^https?:\/\/[^\/]+).*/i, "$1"); + } + if (/^(https?:)?\/\//i.test(url)) return url; + if (/^data:.*,.*$/i.test(url)) return url; + if (/^blob:.*$/i.test(url)) return url; + return path + url; + } +}; +var ImageBitmapLoader = class extends Loader { + constructor(manager) { + super(manager); + this.isImageBitmapLoader = true; + if (typeof createImageBitmap === "undefined") { + console.warn("THREE.ImageBitmapLoader: createImageBitmap() not supported."); + } + if (typeof fetch === "undefined") { + console.warn("THREE.ImageBitmapLoader: fetch() not supported."); + } + this.options = { premultiplyAlpha: "none" }; + } + setOptions(options) { + this.options = options; + return this; + } + load(url, onLoad, onProgress, onError) { + if (url === void 0) url = ""; + if (this.path !== void 0) url = this.path + url; + url = this.manager.resolveURL(url); + const scope = this; + const cached = Cache.get(url); + if (cached !== void 0) { + scope.manager.itemStart(url); + if (cached.then) { + cached.then((imageBitmap) => { + if (onLoad) onLoad(imageBitmap); + scope.manager.itemEnd(url); + }).catch((e) => { + if (onError) onError(e); + }); + return; + } + setTimeout(function() { + if (onLoad) onLoad(cached); + scope.manager.itemEnd(url); + }, 0); + return cached; + } + const fetchOptions = {}; + fetchOptions.credentials = this.crossOrigin === "anonymous" ? "same-origin" : "include"; + fetchOptions.headers = this.requestHeader; + const promise = fetch(url, fetchOptions).then(function(res) { + return res.blob(); + }).then(function(blob) { + return createImageBitmap(blob, Object.assign(scope.options, { colorSpaceConversion: "none" })); + }).then(function(imageBitmap) { + Cache.add(url, imageBitmap); + if (onLoad) onLoad(imageBitmap); + scope.manager.itemEnd(url); + return imageBitmap; + }).catch(function(e) { + if (onError) onError(e); + Cache.remove(url); + scope.manager.itemError(url); + scope.manager.itemEnd(url); + }); + Cache.add(url, promise); + scope.manager.itemStart(url); + } +}; +var _context; +var AudioContext = class { + static getContext() { + if (_context === void 0) { + _context = new (window.AudioContext || window.webkitAudioContext)(); + } + return _context; + } + static setContext(value) { + _context = value; + } +}; +var Clock = class { + constructor(autoStart = true) { + this.autoStart = autoStart; + this.startTime = 0; + this.oldTime = 0; + this.elapsedTime = 0; + this.running = false; + } + start() { + this.startTime = now(); + this.oldTime = this.startTime; + this.elapsedTime = 0; + this.running = true; + } + stop() { + this.getElapsedTime(); + this.running = false; + this.autoStart = false; + } + getElapsedTime() { + this.getDelta(); + return this.elapsedTime; + } + getDelta() { + let diff = 0; + if (this.autoStart && !this.running) { + this.start(); + return 0; + } + if (this.running) { + const newTime = now(); + diff = (newTime - this.oldTime) / 1e3; + this.oldTime = newTime; + this.elapsedTime += diff; + } + return diff; + } +}; +function now() { + return (typeof performance === "undefined" ? Date : performance).now(); +} +var _position$1 = /* @__PURE__ */ new Vector3(); +var _quaternion$1 = /* @__PURE__ */ new Quaternion(); +var _scale$1 = /* @__PURE__ */ new Vector3(); +var _orientation$1 = /* @__PURE__ */ new Vector3(); +var AudioListener = class extends Object3D { + constructor() { + super(); + this.type = "AudioListener"; + this.context = AudioContext.getContext(); + this.gain = this.context.createGain(); + this.gain.connect(this.context.destination); + this.filter = null; + this.timeDelta = 0; + this._clock = new Clock(); + } + getInput() { + return this.gain; + } + removeFilter() { + if (this.filter !== null) { + this.gain.disconnect(this.filter); + this.filter.disconnect(this.context.destination); + this.gain.connect(this.context.destination); + this.filter = null; + } + return this; + } + getFilter() { + return this.filter; + } + setFilter(value) { + if (this.filter !== null) { + this.gain.disconnect(this.filter); + this.filter.disconnect(this.context.destination); + } else { + this.gain.disconnect(this.context.destination); + } + this.filter = value; + this.gain.connect(this.filter); + this.filter.connect(this.context.destination); + return this; + } + getMasterVolume() { + return this.gain.gain.value; + } + setMasterVolume(value) { + this.gain.gain.setTargetAtTime(value, this.context.currentTime, 0.01); + return this; + } + updateMatrixWorld(force) { + super.updateMatrixWorld(force); + const listener = this.context.listener; + const up2 = this.up; + this.timeDelta = this._clock.getDelta(); + this.matrixWorld.decompose(_position$1, _quaternion$1, _scale$1); + _orientation$1.set(0, 0, -1).applyQuaternion(_quaternion$1); + if (listener.positionX) { + const endTime = this.context.currentTime + this.timeDelta; + listener.positionX.linearRampToValueAtTime(_position$1.x, endTime); + listener.positionY.linearRampToValueAtTime(_position$1.y, endTime); + listener.positionZ.linearRampToValueAtTime(_position$1.z, endTime); + listener.forwardX.linearRampToValueAtTime(_orientation$1.x, endTime); + listener.forwardY.linearRampToValueAtTime(_orientation$1.y, endTime); + listener.forwardZ.linearRampToValueAtTime(_orientation$1.z, endTime); + listener.upX.linearRampToValueAtTime(up2.x, endTime); + listener.upY.linearRampToValueAtTime(up2.y, endTime); + listener.upZ.linearRampToValueAtTime(up2.z, endTime); + } else { + listener.setPosition(_position$1.x, _position$1.y, _position$1.z); + listener.setOrientation(_orientation$1.x, _orientation$1.y, _orientation$1.z, up2.x, up2.y, up2.z); + } + } +}; +var Audio2 = class extends Object3D { + constructor(listener) { + super(); + this.type = "Audio"; + this.listener = listener; + this.context = listener.context; + this.gain = this.context.createGain(); + this.gain.connect(listener.getInput()); + this.autoplay = false; + this.buffer = null; + this.detune = 0; + this.loop = false; + this.loopStart = 0; + this.loopEnd = 0; + this.offset = 0; + this.duration = void 0; + this.playbackRate = 1; + this.isPlaying = false; + this.hasPlaybackControl = true; + this.source = null; + this.sourceType = "empty"; + this._startedAt = 0; + this._progress = 0; + this._connected = false; + this.filters = []; + } + getOutput() { + return this.gain; + } + setNodeSource(audioNode) { + this.hasPlaybackControl = false; + this.sourceType = "audioNode"; + this.source = audioNode; + this.connect(); + return this; + } + setMediaElementSource(mediaElement) { + this.hasPlaybackControl = false; + this.sourceType = "mediaNode"; + this.source = this.context.createMediaElementSource(mediaElement); + this.connect(); + return this; + } + setMediaStreamSource(mediaStream) { + this.hasPlaybackControl = false; + this.sourceType = "mediaStreamNode"; + this.source = this.context.createMediaStreamSource(mediaStream); + this.connect(); + return this; + } + setBuffer(audioBuffer) { + this.buffer = audioBuffer; + this.sourceType = "buffer"; + if (this.autoplay) this.play(); + return this; + } + play(delay = 0) { + if (this.isPlaying === true) { + console.warn("THREE.Audio: Audio is already playing."); + return; + } + if (this.hasPlaybackControl === false) { + console.warn("THREE.Audio: this Audio has no playback control."); + return; + } + this._startedAt = this.context.currentTime + delay; + const source = this.context.createBufferSource(); + source.buffer = this.buffer; + source.loop = this.loop; + source.loopStart = this.loopStart; + source.loopEnd = this.loopEnd; + source.onended = this.onEnded.bind(this); + source.start(this._startedAt, this._progress + this.offset, this.duration); + this.isPlaying = true; + this.source = source; + this.setDetune(this.detune); + this.setPlaybackRate(this.playbackRate); + return this.connect(); + } + pause() { + if (this.hasPlaybackControl === false) { + console.warn("THREE.Audio: this Audio has no playback control."); + return; + } + if (this.isPlaying === true) { + this._progress += Math.max(this.context.currentTime - this._startedAt, 0) * this.playbackRate; + if (this.loop === true) { + this._progress = this._progress % (this.duration || this.buffer.duration); + } + this.source.stop(); + this.source.onended = null; + this.isPlaying = false; + } + return this; + } + stop() { + if (this.hasPlaybackControl === false) { + console.warn("THREE.Audio: this Audio has no playback control."); + return; + } + this._progress = 0; + if (this.source !== null) { + this.source.stop(); + this.source.onended = null; + } + this.isPlaying = false; + return this; + } + connect() { + if (this.filters.length > 0) { + this.source.connect(this.filters[0]); + for (let i = 1, l = this.filters.length; i < l; i++) { + this.filters[i - 1].connect(this.filters[i]); + } + this.filters[this.filters.length - 1].connect(this.getOutput()); + } else { + this.source.connect(this.getOutput()); + } + this._connected = true; + return this; + } + disconnect() { + if (this._connected === false) { + return; + } + if (this.filters.length > 0) { + this.source.disconnect(this.filters[0]); + for (let i = 1, l = this.filters.length; i < l; i++) { + this.filters[i - 1].disconnect(this.filters[i]); + } + this.filters[this.filters.length - 1].disconnect(this.getOutput()); + } else { + this.source.disconnect(this.getOutput()); + } + this._connected = false; + return this; + } + getFilters() { + return this.filters; + } + setFilters(value) { + if (!value) value = []; + if (this._connected === true) { + this.disconnect(); + this.filters = value.slice(); + this.connect(); + } else { + this.filters = value.slice(); + } + return this; + } + setDetune(value) { + this.detune = value; + if (this.isPlaying === true && this.source.detune !== void 0) { + this.source.detune.setTargetAtTime(this.detune, this.context.currentTime, 0.01); + } + return this; + } + getDetune() { + return this.detune; + } + getFilter() { + return this.getFilters()[0]; + } + setFilter(filter) { + return this.setFilters(filter ? [filter] : []); + } + setPlaybackRate(value) { + if (this.hasPlaybackControl === false) { + console.warn("THREE.Audio: this Audio has no playback control."); + return; + } + this.playbackRate = value; + if (this.isPlaying === true) { + this.source.playbackRate.setTargetAtTime(this.playbackRate, this.context.currentTime, 0.01); + } + return this; + } + getPlaybackRate() { + return this.playbackRate; + } + onEnded() { + this.isPlaying = false; + } + getLoop() { + if (this.hasPlaybackControl === false) { + console.warn("THREE.Audio: this Audio has no playback control."); + return false; + } + return this.loop; + } + setLoop(value) { + if (this.hasPlaybackControl === false) { + console.warn("THREE.Audio: this Audio has no playback control."); + return; + } + this.loop = value; + if (this.isPlaying === true) { + this.source.loop = this.loop; + } + return this; + } + setLoopStart(value) { + this.loopStart = value; + return this; + } + setLoopEnd(value) { + this.loopEnd = value; + return this; + } + getVolume() { + return this.gain.gain.value; + } + setVolume(value) { + this.gain.gain.setTargetAtTime(value, this.context.currentTime, 0.01); + return this; + } +}; +var _position = /* @__PURE__ */ new Vector3(); +var _quaternion = /* @__PURE__ */ new Quaternion(); +var _scale = /* @__PURE__ */ new Vector3(); +var _orientation = /* @__PURE__ */ new Vector3(); +var PositionalAudio = class extends Audio2 { + constructor(listener) { + super(listener); + this.panner = this.context.createPanner(); + this.panner.panningModel = "HRTF"; + this.panner.connect(this.gain); + } + connect() { + super.connect(); + this.panner.connect(this.gain); + } + disconnect() { + super.disconnect(); + this.panner.disconnect(this.gain); + } + getOutput() { + return this.panner; + } + getRefDistance() { + return this.panner.refDistance; + } + setRefDistance(value) { + this.panner.refDistance = value; + return this; + } + getRolloffFactor() { + return this.panner.rolloffFactor; + } + setRolloffFactor(value) { + this.panner.rolloffFactor = value; + return this; + } + getDistanceModel() { + return this.panner.distanceModel; + } + setDistanceModel(value) { + this.panner.distanceModel = value; + return this; + } + getMaxDistance() { + return this.panner.maxDistance; + } + setMaxDistance(value) { + this.panner.maxDistance = value; + return this; + } + setDirectionalCone(coneInnerAngle, coneOuterAngle, coneOuterGain) { + this.panner.coneInnerAngle = coneInnerAngle; + this.panner.coneOuterAngle = coneOuterAngle; + this.panner.coneOuterGain = coneOuterGain; + return this; + } + updateMatrixWorld(force) { + super.updateMatrixWorld(force); + if (this.hasPlaybackControl === true && this.isPlaying === false) return; + this.matrixWorld.decompose(_position, _quaternion, _scale); + _orientation.set(0, 0, 1).applyQuaternion(_quaternion); + const panner = this.panner; + if (panner.positionX) { + const endTime = this.context.currentTime + this.listener.timeDelta; + panner.positionX.linearRampToValueAtTime(_position.x, endTime); + panner.positionY.linearRampToValueAtTime(_position.y, endTime); + panner.positionZ.linearRampToValueAtTime(_position.z, endTime); + panner.orientationX.linearRampToValueAtTime(_orientation.x, endTime); + panner.orientationY.linearRampToValueAtTime(_orientation.y, endTime); + panner.orientationZ.linearRampToValueAtTime(_orientation.z, endTime); + } else { + panner.setPosition(_position.x, _position.y, _position.z); + panner.setOrientation(_orientation.x, _orientation.y, _orientation.z); + } + } +}; +var PropertyMixer = class { + constructor(binding, typeName, valueSize) { + this.binding = binding; + this.valueSize = valueSize; + let mixFunction, mixFunctionAdditive, setIdentity; + switch (typeName) { + case "quaternion": + mixFunction = this._slerp; + mixFunctionAdditive = this._slerpAdditive; + setIdentity = this._setAdditiveIdentityQuaternion; + this.buffer = new Float64Array(valueSize * 6); + this._workIndex = 5; + break; + case "string": + case "bool": + mixFunction = this._select; + mixFunctionAdditive = this._select; + setIdentity = this._setAdditiveIdentityOther; + this.buffer = new Array(valueSize * 5); + break; + default: + mixFunction = this._lerp; + mixFunctionAdditive = this._lerpAdditive; + setIdentity = this._setAdditiveIdentityNumeric; + this.buffer = new Float64Array(valueSize * 5); + } + this._mixBufferRegion = mixFunction; + this._mixBufferRegionAdditive = mixFunctionAdditive; + this._setIdentity = setIdentity; + this._origIndex = 3; + this._addIndex = 4; + this.cumulativeWeight = 0; + this.cumulativeWeightAdditive = 0; + this.useCount = 0; + this.referenceCount = 0; + } + // accumulate data in the 'incoming' region into 'accu' + accumulate(accuIndex, weight) { + const buffer = this.buffer, stride = this.valueSize, offset = accuIndex * stride + stride; + let currentWeight = this.cumulativeWeight; + if (currentWeight === 0) { + for (let i = 0; i !== stride; ++i) { + buffer[offset + i] = buffer[i]; + } + currentWeight = weight; + } else { + currentWeight += weight; + const mix = weight / currentWeight; + this._mixBufferRegion(buffer, offset, 0, mix, stride); + } + this.cumulativeWeight = currentWeight; + } + // accumulate data in the 'incoming' region into 'add' + accumulateAdditive(weight) { + const buffer = this.buffer, stride = this.valueSize, offset = stride * this._addIndex; + if (this.cumulativeWeightAdditive === 0) { + this._setIdentity(); + } + this._mixBufferRegionAdditive(buffer, offset, 0, weight, stride); + this.cumulativeWeightAdditive += weight; + } + // apply the state of 'accu' to the binding when accus differ + apply(accuIndex) { + const stride = this.valueSize, buffer = this.buffer, offset = accuIndex * stride + stride, weight = this.cumulativeWeight, weightAdditive = this.cumulativeWeightAdditive, binding = this.binding; + this.cumulativeWeight = 0; + this.cumulativeWeightAdditive = 0; + if (weight < 1) { + const originalValueOffset = stride * this._origIndex; + this._mixBufferRegion( + buffer, + offset, + originalValueOffset, + 1 - weight, + stride + ); + } + if (weightAdditive > 0) { + this._mixBufferRegionAdditive(buffer, offset, this._addIndex * stride, 1, stride); + } + for (let i = stride, e = stride + stride; i !== e; ++i) { + if (buffer[i] !== buffer[i + stride]) { + binding.setValue(buffer, offset); + break; + } + } + } + // remember the state of the bound property and copy it to both accus + saveOriginalState() { + const binding = this.binding; + const buffer = this.buffer, stride = this.valueSize, originalValueOffset = stride * this._origIndex; + binding.getValue(buffer, originalValueOffset); + for (let i = stride, e = originalValueOffset; i !== e; ++i) { + buffer[i] = buffer[originalValueOffset + i % stride]; + } + this._setIdentity(); + this.cumulativeWeight = 0; + this.cumulativeWeightAdditive = 0; + } + // apply the state previously taken via 'saveOriginalState' to the binding + restoreOriginalState() { + const originalValueOffset = this.valueSize * 3; + this.binding.setValue(this.buffer, originalValueOffset); + } + _setAdditiveIdentityNumeric() { + const startIndex = this._addIndex * this.valueSize; + const endIndex = startIndex + this.valueSize; + for (let i = startIndex; i < endIndex; i++) { + this.buffer[i] = 0; + } + } + _setAdditiveIdentityQuaternion() { + this._setAdditiveIdentityNumeric(); + this.buffer[this._addIndex * this.valueSize + 3] = 1; + } + _setAdditiveIdentityOther() { + const startIndex = this._origIndex * this.valueSize; + const targetIndex = this._addIndex * this.valueSize; + for (let i = 0; i < this.valueSize; i++) { + this.buffer[targetIndex + i] = this.buffer[startIndex + i]; + } + } + // mix functions + _select(buffer, dstOffset, srcOffset, t, stride) { + if (t >= 0.5) { + for (let i = 0; i !== stride; ++i) { + buffer[dstOffset + i] = buffer[srcOffset + i]; + } + } + } + _slerp(buffer, dstOffset, srcOffset, t) { + Quaternion.slerpFlat(buffer, dstOffset, buffer, dstOffset, buffer, srcOffset, t); + } + _slerpAdditive(buffer, dstOffset, srcOffset, t, stride) { + const workOffset = this._workIndex * stride; + Quaternion.multiplyQuaternionsFlat(buffer, workOffset, buffer, dstOffset, buffer, srcOffset); + Quaternion.slerpFlat(buffer, dstOffset, buffer, dstOffset, buffer, workOffset, t); + } + _lerp(buffer, dstOffset, srcOffset, t, stride) { + const s = 1 - t; + for (let i = 0; i !== stride; ++i) { + const j = dstOffset + i; + buffer[j] = buffer[j] * s + buffer[srcOffset + i] * t; + } + } + _lerpAdditive(buffer, dstOffset, srcOffset, t, stride) { + for (let i = 0; i !== stride; ++i) { + const j = dstOffset + i; + buffer[j] = buffer[j] + buffer[srcOffset + i] * t; + } + } +}; +var _RESERVED_CHARS_RE = "\\[\\]\\.:\\/"; +var _reservedRe = new RegExp("[" + _RESERVED_CHARS_RE + "]", "g"); +var _wordChar = "[^" + _RESERVED_CHARS_RE + "]"; +var _wordCharOrDot = "[^" + _RESERVED_CHARS_RE.replace("\\.", "") + "]"; +var _directoryRe = /* @__PURE__ */ /((?:WC+[\/:])*)/.source.replace("WC", _wordChar); +var _nodeRe = /* @__PURE__ */ /(WCOD+)?/.source.replace("WCOD", _wordCharOrDot); +var _objectRe = /* @__PURE__ */ /(?:\.(WC+)(?:\[(.+)\])?)?/.source.replace("WC", _wordChar); +var _propertyRe = /* @__PURE__ */ /\.(WC+)(?:\[(.+)\])?/.source.replace("WC", _wordChar); +var _trackRe = new RegExp( + "^" + _directoryRe + _nodeRe + _objectRe + _propertyRe + "$" +); +var _supportedObjectNames = ["material", "materials", "bones", "map"]; +var Composite = class { + constructor(targetGroup, path, optionalParsedPath) { + const parsedPath = optionalParsedPath || PropertyBinding.parseTrackName(path); + this._targetGroup = targetGroup; + this._bindings = targetGroup.subscribe_(path, parsedPath); + } + getValue(array, offset) { + this.bind(); + const firstValidIndex = this._targetGroup.nCachedObjects_, binding = this._bindings[firstValidIndex]; + if (binding !== void 0) binding.getValue(array, offset); + } + setValue(array, offset) { + const bindings = this._bindings; + for (let i = this._targetGroup.nCachedObjects_, n = bindings.length; i !== n; ++i) { + bindings[i].setValue(array, offset); + } + } + bind() { + const bindings = this._bindings; + for (let i = this._targetGroup.nCachedObjects_, n = bindings.length; i !== n; ++i) { + bindings[i].bind(); + } + } + unbind() { + const bindings = this._bindings; + for (let i = this._targetGroup.nCachedObjects_, n = bindings.length; i !== n; ++i) { + bindings[i].unbind(); + } + } +}; +var PropertyBinding = class _PropertyBinding { + constructor(rootNode, path, parsedPath) { + this.path = path; + this.parsedPath = parsedPath || _PropertyBinding.parseTrackName(path); + this.node = _PropertyBinding.findNode(rootNode, this.parsedPath.nodeName); + this.rootNode = rootNode; + this.getValue = this._getValue_unbound; + this.setValue = this._setValue_unbound; + } + static create(root, path, parsedPath) { + if (!(root && root.isAnimationObjectGroup)) { + return new _PropertyBinding(root, path, parsedPath); + } else { + return new _PropertyBinding.Composite(root, path, parsedPath); + } + } + /** + * Replaces spaces with underscores and removes unsupported characters from + * node names, to ensure compatibility with parseTrackName(). + * + * @param {string} name Node name to be sanitized. + * @return {string} + */ + static sanitizeNodeName(name) { + return name.replace(/\s/g, "_").replace(_reservedRe, ""); + } + static parseTrackName(trackName) { + const matches = _trackRe.exec(trackName); + if (matches === null) { + throw new Error("PropertyBinding: Cannot parse trackName: " + trackName); + } + const results = { + // directoryName: matches[ 1 ], // (tschw) currently unused + nodeName: matches[2], + objectName: matches[3], + objectIndex: matches[4], + propertyName: matches[5], + // required + propertyIndex: matches[6] + }; + const lastDot = results.nodeName && results.nodeName.lastIndexOf("."); + if (lastDot !== void 0 && lastDot !== -1) { + const objectName = results.nodeName.substring(lastDot + 1); + if (_supportedObjectNames.indexOf(objectName) !== -1) { + results.nodeName = results.nodeName.substring(0, lastDot); + results.objectName = objectName; + } + } + if (results.propertyName === null || results.propertyName.length === 0) { + throw new Error("PropertyBinding: can not parse propertyName from trackName: " + trackName); + } + return results; + } + static findNode(root, nodeName) { + if (nodeName === void 0 || nodeName === "" || nodeName === "." || nodeName === -1 || nodeName === root.name || nodeName === root.uuid) { + return root; + } + if (root.skeleton) { + const bone = root.skeleton.getBoneByName(nodeName); + if (bone !== void 0) { + return bone; + } + } + if (root.children) { + const searchNodeSubtree = function(children) { + for (let i = 0; i < children.length; i++) { + const childNode = children[i]; + if (childNode.name === nodeName || childNode.uuid === nodeName) { + return childNode; + } + const result = searchNodeSubtree(childNode.children); + if (result) return result; + } + return null; + }; + const subTreeNode = searchNodeSubtree(root.children); + if (subTreeNode) { + return subTreeNode; + } + } + return null; + } + // these are used to "bind" a nonexistent property + _getValue_unavailable() { + } + _setValue_unavailable() { + } + // Getters + _getValue_direct(buffer, offset) { + buffer[offset] = this.targetObject[this.propertyName]; + } + _getValue_array(buffer, offset) { + const source = this.resolvedProperty; + for (let i = 0, n = source.length; i !== n; ++i) { + buffer[offset++] = source[i]; + } + } + _getValue_arrayElement(buffer, offset) { + buffer[offset] = this.resolvedProperty[this.propertyIndex]; + } + _getValue_toArray(buffer, offset) { + this.resolvedProperty.toArray(buffer, offset); + } + // Direct + _setValue_direct(buffer, offset) { + this.targetObject[this.propertyName] = buffer[offset]; + } + _setValue_direct_setNeedsUpdate(buffer, offset) { + this.targetObject[this.propertyName] = buffer[offset]; + this.targetObject.needsUpdate = true; + } + _setValue_direct_setMatrixWorldNeedsUpdate(buffer, offset) { + this.targetObject[this.propertyName] = buffer[offset]; + this.targetObject.matrixWorldNeedsUpdate = true; + } + // EntireArray + _setValue_array(buffer, offset) { + const dest = this.resolvedProperty; + for (let i = 0, n = dest.length; i !== n; ++i) { + dest[i] = buffer[offset++]; + } + } + _setValue_array_setNeedsUpdate(buffer, offset) { + const dest = this.resolvedProperty; + for (let i = 0, n = dest.length; i !== n; ++i) { + dest[i] = buffer[offset++]; + } + this.targetObject.needsUpdate = true; + } + _setValue_array_setMatrixWorldNeedsUpdate(buffer, offset) { + const dest = this.resolvedProperty; + for (let i = 0, n = dest.length; i !== n; ++i) { + dest[i] = buffer[offset++]; + } + this.targetObject.matrixWorldNeedsUpdate = true; + } + // ArrayElement + _setValue_arrayElement(buffer, offset) { + this.resolvedProperty[this.propertyIndex] = buffer[offset]; + } + _setValue_arrayElement_setNeedsUpdate(buffer, offset) { + this.resolvedProperty[this.propertyIndex] = buffer[offset]; + this.targetObject.needsUpdate = true; + } + _setValue_arrayElement_setMatrixWorldNeedsUpdate(buffer, offset) { + this.resolvedProperty[this.propertyIndex] = buffer[offset]; + this.targetObject.matrixWorldNeedsUpdate = true; + } + // HasToFromArray + _setValue_fromArray(buffer, offset) { + this.resolvedProperty.fromArray(buffer, offset); + } + _setValue_fromArray_setNeedsUpdate(buffer, offset) { + this.resolvedProperty.fromArray(buffer, offset); + this.targetObject.needsUpdate = true; + } + _setValue_fromArray_setMatrixWorldNeedsUpdate(buffer, offset) { + this.resolvedProperty.fromArray(buffer, offset); + this.targetObject.matrixWorldNeedsUpdate = true; + } + _getValue_unbound(targetArray, offset) { + this.bind(); + this.getValue(targetArray, offset); + } + _setValue_unbound(sourceArray, offset) { + this.bind(); + this.setValue(sourceArray, offset); + } + // create getter / setter pair for a property in the scene graph + bind() { + let targetObject = this.node; + const parsedPath = this.parsedPath; + const objectName = parsedPath.objectName; + const propertyName = parsedPath.propertyName; + let propertyIndex = parsedPath.propertyIndex; + if (!targetObject) { + targetObject = _PropertyBinding.findNode(this.rootNode, parsedPath.nodeName); + this.node = targetObject; + } + this.getValue = this._getValue_unavailable; + this.setValue = this._setValue_unavailable; + if (!targetObject) { + console.warn("THREE.PropertyBinding: No target node found for track: " + this.path + "."); + return; + } + if (objectName) { + let objectIndex = parsedPath.objectIndex; + switch (objectName) { + case "materials": + if (!targetObject.material) { + console.error("THREE.PropertyBinding: Can not bind to material as node does not have a material.", this); + return; + } + if (!targetObject.material.materials) { + console.error("THREE.PropertyBinding: Can not bind to material.materials as node.material does not have a materials array.", this); + return; + } + targetObject = targetObject.material.materials; + break; + case "bones": + if (!targetObject.skeleton) { + console.error("THREE.PropertyBinding: Can not bind to bones as node does not have a skeleton.", this); + return; + } + targetObject = targetObject.skeleton.bones; + for (let i = 0; i < targetObject.length; i++) { + if (targetObject[i].name === objectIndex) { + objectIndex = i; + break; + } + } + break; + case "map": + if ("map" in targetObject) { + targetObject = targetObject.map; + break; + } + if (!targetObject.material) { + console.error("THREE.PropertyBinding: Can not bind to material as node does not have a material.", this); + return; + } + if (!targetObject.material.map) { + console.error("THREE.PropertyBinding: Can not bind to material.map as node.material does not have a map.", this); + return; + } + targetObject = targetObject.material.map; + break; + default: + if (targetObject[objectName] === void 0) { + console.error("THREE.PropertyBinding: Can not bind to objectName of node undefined.", this); + return; + } + targetObject = targetObject[objectName]; + } + if (objectIndex !== void 0) { + if (targetObject[objectIndex] === void 0) { + console.error("THREE.PropertyBinding: Trying to bind to objectIndex of objectName, but is undefined.", this, targetObject); + return; + } + targetObject = targetObject[objectIndex]; + } + } + const nodeProperty = targetObject[propertyName]; + if (nodeProperty === void 0) { + const nodeName = parsedPath.nodeName; + console.error("THREE.PropertyBinding: Trying to update property for track: " + nodeName + "." + propertyName + " but it wasn't found.", targetObject); + return; + } + let versioning = this.Versioning.None; + this.targetObject = targetObject; + if (targetObject.needsUpdate !== void 0) { + versioning = this.Versioning.NeedsUpdate; + } else if (targetObject.matrixWorldNeedsUpdate !== void 0) { + versioning = this.Versioning.MatrixWorldNeedsUpdate; + } + let bindingType = this.BindingType.Direct; + if (propertyIndex !== void 0) { + if (propertyName === "morphTargetInfluences") { + if (!targetObject.geometry) { + console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.", this); + return; + } + if (!targetObject.geometry.morphAttributes) { + console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.morphAttributes.", this); + return; + } + if (targetObject.morphTargetDictionary[propertyIndex] !== void 0) { + propertyIndex = targetObject.morphTargetDictionary[propertyIndex]; + } + } + bindingType = this.BindingType.ArrayElement; + this.resolvedProperty = nodeProperty; + this.propertyIndex = propertyIndex; + } else if (nodeProperty.fromArray !== void 0 && nodeProperty.toArray !== void 0) { + bindingType = this.BindingType.HasFromToArray; + this.resolvedProperty = nodeProperty; + } else if (Array.isArray(nodeProperty)) { + bindingType = this.BindingType.EntireArray; + this.resolvedProperty = nodeProperty; + } else { + this.propertyName = propertyName; + } + this.getValue = this.GetterByBindingType[bindingType]; + this.setValue = this.SetterByBindingTypeAndVersioning[bindingType][versioning]; + } + unbind() { + this.node = null; + this.getValue = this._getValue_unbound; + this.setValue = this._setValue_unbound; + } +}; +PropertyBinding.Composite = Composite; +PropertyBinding.prototype.BindingType = { + Direct: 0, + EntireArray: 1, + ArrayElement: 2, + HasFromToArray: 3 +}; +PropertyBinding.prototype.Versioning = { + None: 0, + NeedsUpdate: 1, + MatrixWorldNeedsUpdate: 2 +}; +PropertyBinding.prototype.GetterByBindingType = [ + PropertyBinding.prototype._getValue_direct, + PropertyBinding.prototype._getValue_array, + PropertyBinding.prototype._getValue_arrayElement, + PropertyBinding.prototype._getValue_toArray +]; +PropertyBinding.prototype.SetterByBindingTypeAndVersioning = [ + [ + // Direct + PropertyBinding.prototype._setValue_direct, + PropertyBinding.prototype._setValue_direct_setNeedsUpdate, + PropertyBinding.prototype._setValue_direct_setMatrixWorldNeedsUpdate + ], + [ + // EntireArray + PropertyBinding.prototype._setValue_array, + PropertyBinding.prototype._setValue_array_setNeedsUpdate, + PropertyBinding.prototype._setValue_array_setMatrixWorldNeedsUpdate + ], + [ + // ArrayElement + PropertyBinding.prototype._setValue_arrayElement, + PropertyBinding.prototype._setValue_arrayElement_setNeedsUpdate, + PropertyBinding.prototype._setValue_arrayElement_setMatrixWorldNeedsUpdate + ], + [ + // HasToFromArray + PropertyBinding.prototype._setValue_fromArray, + PropertyBinding.prototype._setValue_fromArray_setNeedsUpdate, + PropertyBinding.prototype._setValue_fromArray_setMatrixWorldNeedsUpdate + ] +]; +var AnimationObjectGroup = class { + constructor() { + this.isAnimationObjectGroup = true; + this.uuid = generateUUID(); + this._objects = Array.prototype.slice.call(arguments); + this.nCachedObjects_ = 0; + const indices = {}; + this._indicesByUUID = indices; + for (let i = 0, n = arguments.length; i !== n; ++i) { + indices[arguments[i].uuid] = i; + } + this._paths = []; + this._parsedPaths = []; + this._bindings = []; + this._bindingsIndicesByPath = {}; + const scope = this; + this.stats = { + objects: { + get total() { + return scope._objects.length; + }, + get inUse() { + return this.total - scope.nCachedObjects_; + } + }, + get bindingsPerObject() { + return scope._bindings.length; + } + }; + } + add() { + const objects = this._objects, indicesByUUID = this._indicesByUUID, paths = this._paths, parsedPaths = this._parsedPaths, bindings = this._bindings, nBindings = bindings.length; + let knownObject = void 0, nObjects = objects.length, nCachedObjects = this.nCachedObjects_; + for (let i = 0, n = arguments.length; i !== n; ++i) { + const object = arguments[i], uuid = object.uuid; + let index = indicesByUUID[uuid]; + if (index === void 0) { + index = nObjects++; + indicesByUUID[uuid] = index; + objects.push(object); + for (let j = 0, m = nBindings; j !== m; ++j) { + bindings[j].push(new PropertyBinding(object, paths[j], parsedPaths[j])); + } + } else if (index < nCachedObjects) { + knownObject = objects[index]; + const firstActiveIndex = --nCachedObjects, lastCachedObject = objects[firstActiveIndex]; + indicesByUUID[lastCachedObject.uuid] = index; + objects[index] = lastCachedObject; + indicesByUUID[uuid] = firstActiveIndex; + objects[firstActiveIndex] = object; + for (let j = 0, m = nBindings; j !== m; ++j) { + const bindingsForPath = bindings[j], lastCached = bindingsForPath[firstActiveIndex]; + let binding = bindingsForPath[index]; + bindingsForPath[index] = lastCached; + if (binding === void 0) { + binding = new PropertyBinding(object, paths[j], parsedPaths[j]); + } + bindingsForPath[firstActiveIndex] = binding; + } + } else if (objects[index] !== knownObject) { + console.error("THREE.AnimationObjectGroup: Different objects with the same UUID detected. Clean the caches or recreate your infrastructure when reloading scenes."); + } + } + this.nCachedObjects_ = nCachedObjects; + } + remove() { + const objects = this._objects, indicesByUUID = this._indicesByUUID, bindings = this._bindings, nBindings = bindings.length; + let nCachedObjects = this.nCachedObjects_; + for (let i = 0, n = arguments.length; i !== n; ++i) { + const object = arguments[i], uuid = object.uuid, index = indicesByUUID[uuid]; + if (index !== void 0 && index >= nCachedObjects) { + const lastCachedIndex = nCachedObjects++, firstActiveObject = objects[lastCachedIndex]; + indicesByUUID[firstActiveObject.uuid] = index; + objects[index] = firstActiveObject; + indicesByUUID[uuid] = lastCachedIndex; + objects[lastCachedIndex] = object; + for (let j = 0, m = nBindings; j !== m; ++j) { + const bindingsForPath = bindings[j], firstActive = bindingsForPath[lastCachedIndex], binding = bindingsForPath[index]; + bindingsForPath[index] = firstActive; + bindingsForPath[lastCachedIndex] = binding; + } + } + } + this.nCachedObjects_ = nCachedObjects; + } + // remove & forget + uncache() { + const objects = this._objects, indicesByUUID = this._indicesByUUID, bindings = this._bindings, nBindings = bindings.length; + let nCachedObjects = this.nCachedObjects_, nObjects = objects.length; + for (let i = 0, n = arguments.length; i !== n; ++i) { + const object = arguments[i], uuid = object.uuid, index = indicesByUUID[uuid]; + if (index !== void 0) { + delete indicesByUUID[uuid]; + if (index < nCachedObjects) { + const firstActiveIndex = --nCachedObjects, lastCachedObject = objects[firstActiveIndex], lastIndex = --nObjects, lastObject = objects[lastIndex]; + indicesByUUID[lastCachedObject.uuid] = index; + objects[index] = lastCachedObject; + indicesByUUID[lastObject.uuid] = firstActiveIndex; + objects[firstActiveIndex] = lastObject; + objects.pop(); + for (let j = 0, m = nBindings; j !== m; ++j) { + const bindingsForPath = bindings[j], lastCached = bindingsForPath[firstActiveIndex], last = bindingsForPath[lastIndex]; + bindingsForPath[index] = lastCached; + bindingsForPath[firstActiveIndex] = last; + bindingsForPath.pop(); + } + } else { + const lastIndex = --nObjects, lastObject = objects[lastIndex]; + if (lastIndex > 0) { + indicesByUUID[lastObject.uuid] = index; + } + objects[index] = lastObject; + objects.pop(); + for (let j = 0, m = nBindings; j !== m; ++j) { + const bindingsForPath = bindings[j]; + bindingsForPath[index] = bindingsForPath[lastIndex]; + bindingsForPath.pop(); + } + } + } + } + this.nCachedObjects_ = nCachedObjects; + } + // Internal interface used by befriended PropertyBinding.Composite: + subscribe_(path, parsedPath) { + const indicesByPath = this._bindingsIndicesByPath; + let index = indicesByPath[path]; + const bindings = this._bindings; + if (index !== void 0) return bindings[index]; + const paths = this._paths, parsedPaths = this._parsedPaths, objects = this._objects, nObjects = objects.length, nCachedObjects = this.nCachedObjects_, bindingsForPath = new Array(nObjects); + index = bindings.length; + indicesByPath[path] = index; + paths.push(path); + parsedPaths.push(parsedPath); + bindings.push(bindingsForPath); + for (let i = nCachedObjects, n = objects.length; i !== n; ++i) { + const object = objects[i]; + bindingsForPath[i] = new PropertyBinding(object, path, parsedPath); + } + return bindingsForPath; + } + unsubscribe_(path) { + const indicesByPath = this._bindingsIndicesByPath, index = indicesByPath[path]; + if (index !== void 0) { + const paths = this._paths, parsedPaths = this._parsedPaths, bindings = this._bindings, lastBindingsIndex = bindings.length - 1, lastBindings = bindings[lastBindingsIndex], lastBindingsPath = path[lastBindingsIndex]; + indicesByPath[lastBindingsPath] = index; + bindings[index] = lastBindings; + bindings.pop(); + parsedPaths[index] = parsedPaths[lastBindingsIndex]; + parsedPaths.pop(); + paths[index] = paths[lastBindingsIndex]; + paths.pop(); + } + } +}; +var AnimationAction = class { + constructor(mixer, clip, localRoot = null, blendMode = clip.blendMode) { + this._mixer = mixer; + this._clip = clip; + this._localRoot = localRoot; + this.blendMode = blendMode; + const tracks = clip.tracks, nTracks = tracks.length, interpolants = new Array(nTracks); + const interpolantSettings = { + endingStart: ZeroCurvatureEnding, + endingEnd: ZeroCurvatureEnding + }; + for (let i = 0; i !== nTracks; ++i) { + const interpolant = tracks[i].createInterpolant(null); + interpolants[i] = interpolant; + interpolant.settings = interpolantSettings; + } + this._interpolantSettings = interpolantSettings; + this._interpolants = interpolants; + this._propertyBindings = new Array(nTracks); + this._cacheIndex = null; + this._byClipCacheIndex = null; + this._timeScaleInterpolant = null; + this._weightInterpolant = null; + this.loop = LoopRepeat; + this._loopCount = -1; + this._startTime = null; + this.time = 0; + this.timeScale = 1; + this._effectiveTimeScale = 1; + this.weight = 1; + this._effectiveWeight = 1; + this.repetitions = Infinity; + this.paused = false; + this.enabled = true; + this.clampWhenFinished = false; + this.zeroSlopeAtStart = true; + this.zeroSlopeAtEnd = true; + } + // State & Scheduling + play() { + this._mixer._activateAction(this); + return this; + } + stop() { + this._mixer._deactivateAction(this); + return this.reset(); + } + reset() { + this.paused = false; + this.enabled = true; + this.time = 0; + this._loopCount = -1; + this._startTime = null; + return this.stopFading().stopWarping(); + } + isRunning() { + return this.enabled && !this.paused && this.timeScale !== 0 && this._startTime === null && this._mixer._isActiveAction(this); + } + // return true when play has been called + isScheduled() { + return this._mixer._isActiveAction(this); + } + startAt(time) { + this._startTime = time; + return this; + } + setLoop(mode, repetitions) { + this.loop = mode; + this.repetitions = repetitions; + return this; + } + // Weight + // set the weight stopping any scheduled fading + // although .enabled = false yields an effective weight of zero, this + // method does *not* change .enabled, because it would be confusing + setEffectiveWeight(weight) { + this.weight = weight; + this._effectiveWeight = this.enabled ? weight : 0; + return this.stopFading(); + } + // return the weight considering fading and .enabled + getEffectiveWeight() { + return this._effectiveWeight; + } + fadeIn(duration) { + return this._scheduleFading(duration, 0, 1); + } + fadeOut(duration) { + return this._scheduleFading(duration, 1, 0); + } + crossFadeFrom(fadeOutAction, duration, warp) { + fadeOutAction.fadeOut(duration); + this.fadeIn(duration); + if (warp) { + const fadeInDuration = this._clip.duration, fadeOutDuration = fadeOutAction._clip.duration, startEndRatio = fadeOutDuration / fadeInDuration, endStartRatio = fadeInDuration / fadeOutDuration; + fadeOutAction.warp(1, startEndRatio, duration); + this.warp(endStartRatio, 1, duration); + } + return this; + } + crossFadeTo(fadeInAction, duration, warp) { + return fadeInAction.crossFadeFrom(this, duration, warp); + } + stopFading() { + const weightInterpolant = this._weightInterpolant; + if (weightInterpolant !== null) { + this._weightInterpolant = null; + this._mixer._takeBackControlInterpolant(weightInterpolant); + } + return this; + } + // Time Scale Control + // set the time scale stopping any scheduled warping + // although .paused = true yields an effective time scale of zero, this + // method does *not* change .paused, because it would be confusing + setEffectiveTimeScale(timeScale) { + this.timeScale = timeScale; + this._effectiveTimeScale = this.paused ? 0 : timeScale; + return this.stopWarping(); + } + // return the time scale considering warping and .paused + getEffectiveTimeScale() { + return this._effectiveTimeScale; + } + setDuration(duration) { + this.timeScale = this._clip.duration / duration; + return this.stopWarping(); + } + syncWith(action) { + this.time = action.time; + this.timeScale = action.timeScale; + return this.stopWarping(); + } + halt(duration) { + return this.warp(this._effectiveTimeScale, 0, duration); + } + warp(startTimeScale, endTimeScale, duration) { + const mixer = this._mixer, now2 = mixer.time, timeScale = this.timeScale; + let interpolant = this._timeScaleInterpolant; + if (interpolant === null) { + interpolant = mixer._lendControlInterpolant(); + this._timeScaleInterpolant = interpolant; + } + const times = interpolant.parameterPositions, values = interpolant.sampleValues; + times[0] = now2; + times[1] = now2 + duration; + values[0] = startTimeScale / timeScale; + values[1] = endTimeScale / timeScale; + return this; + } + stopWarping() { + const timeScaleInterpolant = this._timeScaleInterpolant; + if (timeScaleInterpolant !== null) { + this._timeScaleInterpolant = null; + this._mixer._takeBackControlInterpolant(timeScaleInterpolant); + } + return this; + } + // Object Accessors + getMixer() { + return this._mixer; + } + getClip() { + return this._clip; + } + getRoot() { + return this._localRoot || this._mixer._root; + } + // Interna + _update(time, deltaTime, timeDirection, accuIndex) { + if (!this.enabled) { + this._updateWeight(time); + return; + } + const startTime = this._startTime; + if (startTime !== null) { + const timeRunning = (time - startTime) * timeDirection; + if (timeRunning < 0 || timeDirection === 0) { + deltaTime = 0; + } else { + this._startTime = null; + deltaTime = timeDirection * timeRunning; + } + } + deltaTime *= this._updateTimeScale(time); + const clipTime = this._updateTime(deltaTime); + const weight = this._updateWeight(time); + if (weight > 0) { + const interpolants = this._interpolants; + const propertyMixers = this._propertyBindings; + switch (this.blendMode) { + case AdditiveAnimationBlendMode: + for (let j = 0, m = interpolants.length; j !== m; ++j) { + interpolants[j].evaluate(clipTime); + propertyMixers[j].accumulateAdditive(weight); + } + break; + case NormalAnimationBlendMode: + default: + for (let j = 0, m = interpolants.length; j !== m; ++j) { + interpolants[j].evaluate(clipTime); + propertyMixers[j].accumulate(accuIndex, weight); + } + } + } + } + _updateWeight(time) { + let weight = 0; + if (this.enabled) { + weight = this.weight; + const interpolant = this._weightInterpolant; + if (interpolant !== null) { + const interpolantValue = interpolant.evaluate(time)[0]; + weight *= interpolantValue; + if (time > interpolant.parameterPositions[1]) { + this.stopFading(); + if (interpolantValue === 0) { + this.enabled = false; + } + } + } + } + this._effectiveWeight = weight; + return weight; + } + _updateTimeScale(time) { + let timeScale = 0; + if (!this.paused) { + timeScale = this.timeScale; + const interpolant = this._timeScaleInterpolant; + if (interpolant !== null) { + const interpolantValue = interpolant.evaluate(time)[0]; + timeScale *= interpolantValue; + if (time > interpolant.parameterPositions[1]) { + this.stopWarping(); + if (timeScale === 0) { + this.paused = true; + } else { + this.timeScale = timeScale; + } + } + } + } + this._effectiveTimeScale = timeScale; + return timeScale; + } + _updateTime(deltaTime) { + const duration = this._clip.duration; + const loop = this.loop; + let time = this.time + deltaTime; + let loopCount = this._loopCount; + const pingPong = loop === LoopPingPong; + if (deltaTime === 0) { + if (loopCount === -1) return time; + return pingPong && (loopCount & 1) === 1 ? duration - time : time; + } + if (loop === LoopOnce) { + if (loopCount === -1) { + this._loopCount = 0; + this._setEndings(true, true, false); + } + handle_stop: { + if (time >= duration) { + time = duration; + } else if (time < 0) { + time = 0; + } else { + this.time = time; + break handle_stop; + } + if (this.clampWhenFinished) this.paused = true; + else this.enabled = false; + this.time = time; + this._mixer.dispatchEvent({ + type: "finished", + action: this, + direction: deltaTime < 0 ? -1 : 1 + }); + } + } else { + if (loopCount === -1) { + if (deltaTime >= 0) { + loopCount = 0; + this._setEndings(true, this.repetitions === 0, pingPong); + } else { + this._setEndings(this.repetitions === 0, true, pingPong); + } + } + if (time >= duration || time < 0) { + const loopDelta = Math.floor(time / duration); + time -= duration * loopDelta; + loopCount += Math.abs(loopDelta); + const pending = this.repetitions - loopCount; + if (pending <= 0) { + if (this.clampWhenFinished) this.paused = true; + else this.enabled = false; + time = deltaTime > 0 ? duration : 0; + this.time = time; + this._mixer.dispatchEvent({ + type: "finished", + action: this, + direction: deltaTime > 0 ? 1 : -1 + }); + } else { + if (pending === 1) { + const atStart = deltaTime < 0; + this._setEndings(atStart, !atStart, pingPong); + } else { + this._setEndings(false, false, pingPong); + } + this._loopCount = loopCount; + this.time = time; + this._mixer.dispatchEvent({ + type: "loop", + action: this, + loopDelta + }); + } + } else { + this.time = time; + } + if (pingPong && (loopCount & 1) === 1) { + return duration - time; + } + } + return time; + } + _setEndings(atStart, atEnd, pingPong) { + const settings = this._interpolantSettings; + if (pingPong) { + settings.endingStart = ZeroSlopeEnding; + settings.endingEnd = ZeroSlopeEnding; + } else { + if (atStart) { + settings.endingStart = this.zeroSlopeAtStart ? ZeroSlopeEnding : ZeroCurvatureEnding; + } else { + settings.endingStart = WrapAroundEnding; + } + if (atEnd) { + settings.endingEnd = this.zeroSlopeAtEnd ? ZeroSlopeEnding : ZeroCurvatureEnding; + } else { + settings.endingEnd = WrapAroundEnding; + } + } + } + _scheduleFading(duration, weightNow, weightThen) { + const mixer = this._mixer, now2 = mixer.time; + let interpolant = this._weightInterpolant; + if (interpolant === null) { + interpolant = mixer._lendControlInterpolant(); + this._weightInterpolant = interpolant; + } + const times = interpolant.parameterPositions, values = interpolant.sampleValues; + times[0] = now2; + values[0] = weightNow; + times[1] = now2 + duration; + values[1] = weightThen; + return this; + } +}; +var _controlInterpolantsResultBuffer = new Float32Array(1); +var AnimationMixer = class extends EventDispatcher { + constructor(root) { + super(); + this._root = root; + this._initMemoryManager(); + this._accuIndex = 0; + this.time = 0; + this.timeScale = 1; + } + _bindAction(action, prototypeAction) { + const root = action._localRoot || this._root, tracks = action._clip.tracks, nTracks = tracks.length, bindings = action._propertyBindings, interpolants = action._interpolants, rootUuid = root.uuid, bindingsByRoot = this._bindingsByRootAndName; + let bindingsByName = bindingsByRoot[rootUuid]; + if (bindingsByName === void 0) { + bindingsByName = {}; + bindingsByRoot[rootUuid] = bindingsByName; + } + for (let i = 0; i !== nTracks; ++i) { + const track = tracks[i], trackName = track.name; + let binding = bindingsByName[trackName]; + if (binding !== void 0) { + ++binding.referenceCount; + bindings[i] = binding; + } else { + binding = bindings[i]; + if (binding !== void 0) { + if (binding._cacheIndex === null) { + ++binding.referenceCount; + this._addInactiveBinding(binding, rootUuid, trackName); + } + continue; + } + const path = prototypeAction && prototypeAction._propertyBindings[i].binding.parsedPath; + binding = new PropertyMixer( + PropertyBinding.create(root, trackName, path), + track.ValueTypeName, + track.getValueSize() + ); + ++binding.referenceCount; + this._addInactiveBinding(binding, rootUuid, trackName); + bindings[i] = binding; + } + interpolants[i].resultBuffer = binding.buffer; + } + } + _activateAction(action) { + if (!this._isActiveAction(action)) { + if (action._cacheIndex === null) { + const rootUuid = (action._localRoot || this._root).uuid, clipUuid = action._clip.uuid, actionsForClip = this._actionsByClip[clipUuid]; + this._bindAction( + action, + actionsForClip && actionsForClip.knownActions[0] + ); + this._addInactiveAction(action, clipUuid, rootUuid); + } + const bindings = action._propertyBindings; + for (let i = 0, n = bindings.length; i !== n; ++i) { + const binding = bindings[i]; + if (binding.useCount++ === 0) { + this._lendBinding(binding); + binding.saveOriginalState(); + } + } + this._lendAction(action); + } + } + _deactivateAction(action) { + if (this._isActiveAction(action)) { + const bindings = action._propertyBindings; + for (let i = 0, n = bindings.length; i !== n; ++i) { + const binding = bindings[i]; + if (--binding.useCount === 0) { + binding.restoreOriginalState(); + this._takeBackBinding(binding); + } + } + this._takeBackAction(action); + } + } + // Memory manager + _initMemoryManager() { + this._actions = []; + this._nActiveActions = 0; + this._actionsByClip = {}; + this._bindings = []; + this._nActiveBindings = 0; + this._bindingsByRootAndName = {}; + this._controlInterpolants = []; + this._nActiveControlInterpolants = 0; + const scope = this; + this.stats = { + actions: { + get total() { + return scope._actions.length; + }, + get inUse() { + return scope._nActiveActions; + } + }, + bindings: { + get total() { + return scope._bindings.length; + }, + get inUse() { + return scope._nActiveBindings; + } + }, + controlInterpolants: { + get total() { + return scope._controlInterpolants.length; + }, + get inUse() { + return scope._nActiveControlInterpolants; + } + } + }; + } + // Memory management for AnimationAction objects + _isActiveAction(action) { + const index = action._cacheIndex; + return index !== null && index < this._nActiveActions; + } + _addInactiveAction(action, clipUuid, rootUuid) { + const actions = this._actions, actionsByClip = this._actionsByClip; + let actionsForClip = actionsByClip[clipUuid]; + if (actionsForClip === void 0) { + actionsForClip = { + knownActions: [action], + actionByRoot: {} + }; + action._byClipCacheIndex = 0; + actionsByClip[clipUuid] = actionsForClip; + } else { + const knownActions = actionsForClip.knownActions; + action._byClipCacheIndex = knownActions.length; + knownActions.push(action); + } + action._cacheIndex = actions.length; + actions.push(action); + actionsForClip.actionByRoot[rootUuid] = action; + } + _removeInactiveAction(action) { + const actions = this._actions, lastInactiveAction = actions[actions.length - 1], cacheIndex = action._cacheIndex; + lastInactiveAction._cacheIndex = cacheIndex; + actions[cacheIndex] = lastInactiveAction; + actions.pop(); + action._cacheIndex = null; + const clipUuid = action._clip.uuid, actionsByClip = this._actionsByClip, actionsForClip = actionsByClip[clipUuid], knownActionsForClip = actionsForClip.knownActions, lastKnownAction = knownActionsForClip[knownActionsForClip.length - 1], byClipCacheIndex = action._byClipCacheIndex; + lastKnownAction._byClipCacheIndex = byClipCacheIndex; + knownActionsForClip[byClipCacheIndex] = lastKnownAction; + knownActionsForClip.pop(); + action._byClipCacheIndex = null; + const actionByRoot = actionsForClip.actionByRoot, rootUuid = (action._localRoot || this._root).uuid; + delete actionByRoot[rootUuid]; + if (knownActionsForClip.length === 0) { + delete actionsByClip[clipUuid]; + } + this._removeInactiveBindingsForAction(action); + } + _removeInactiveBindingsForAction(action) { + const bindings = action._propertyBindings; + for (let i = 0, n = bindings.length; i !== n; ++i) { + const binding = bindings[i]; + if (--binding.referenceCount === 0) { + this._removeInactiveBinding(binding); + } + } + } + _lendAction(action) { + const actions = this._actions, prevIndex = action._cacheIndex, lastActiveIndex = this._nActiveActions++, firstInactiveAction = actions[lastActiveIndex]; + action._cacheIndex = lastActiveIndex; + actions[lastActiveIndex] = action; + firstInactiveAction._cacheIndex = prevIndex; + actions[prevIndex] = firstInactiveAction; + } + _takeBackAction(action) { + const actions = this._actions, prevIndex = action._cacheIndex, firstInactiveIndex = --this._nActiveActions, lastActiveAction = actions[firstInactiveIndex]; + action._cacheIndex = firstInactiveIndex; + actions[firstInactiveIndex] = action; + lastActiveAction._cacheIndex = prevIndex; + actions[prevIndex] = lastActiveAction; + } + // Memory management for PropertyMixer objects + _addInactiveBinding(binding, rootUuid, trackName) { + const bindingsByRoot = this._bindingsByRootAndName, bindings = this._bindings; + let bindingByName = bindingsByRoot[rootUuid]; + if (bindingByName === void 0) { + bindingByName = {}; + bindingsByRoot[rootUuid] = bindingByName; + } + bindingByName[trackName] = binding; + binding._cacheIndex = bindings.length; + bindings.push(binding); + } + _removeInactiveBinding(binding) { + const bindings = this._bindings, propBinding = binding.binding, rootUuid = propBinding.rootNode.uuid, trackName = propBinding.path, bindingsByRoot = this._bindingsByRootAndName, bindingByName = bindingsByRoot[rootUuid], lastInactiveBinding = bindings[bindings.length - 1], cacheIndex = binding._cacheIndex; + lastInactiveBinding._cacheIndex = cacheIndex; + bindings[cacheIndex] = lastInactiveBinding; + bindings.pop(); + delete bindingByName[trackName]; + if (Object.keys(bindingByName).length === 0) { + delete bindingsByRoot[rootUuid]; + } + } + _lendBinding(binding) { + const bindings = this._bindings, prevIndex = binding._cacheIndex, lastActiveIndex = this._nActiveBindings++, firstInactiveBinding = bindings[lastActiveIndex]; + binding._cacheIndex = lastActiveIndex; + bindings[lastActiveIndex] = binding; + firstInactiveBinding._cacheIndex = prevIndex; + bindings[prevIndex] = firstInactiveBinding; + } + _takeBackBinding(binding) { + const bindings = this._bindings, prevIndex = binding._cacheIndex, firstInactiveIndex = --this._nActiveBindings, lastActiveBinding = bindings[firstInactiveIndex]; + binding._cacheIndex = firstInactiveIndex; + bindings[firstInactiveIndex] = binding; + lastActiveBinding._cacheIndex = prevIndex; + bindings[prevIndex] = lastActiveBinding; + } + // Memory management of Interpolants for weight and time scale + _lendControlInterpolant() { + const interpolants = this._controlInterpolants, lastActiveIndex = this._nActiveControlInterpolants++; + let interpolant = interpolants[lastActiveIndex]; + if (interpolant === void 0) { + interpolant = new LinearInterpolant( + new Float32Array(2), + new Float32Array(2), + 1, + _controlInterpolantsResultBuffer + ); + interpolant.__cacheIndex = lastActiveIndex; + interpolants[lastActiveIndex] = interpolant; + } + return interpolant; + } + _takeBackControlInterpolant(interpolant) { + const interpolants = this._controlInterpolants, prevIndex = interpolant.__cacheIndex, firstInactiveIndex = --this._nActiveControlInterpolants, lastActiveInterpolant = interpolants[firstInactiveIndex]; + interpolant.__cacheIndex = firstInactiveIndex; + interpolants[firstInactiveIndex] = interpolant; + lastActiveInterpolant.__cacheIndex = prevIndex; + interpolants[prevIndex] = lastActiveInterpolant; + } + // return an action for a clip optionally using a custom root target + // object (this method allocates a lot of dynamic memory in case a + // previously unknown clip/root combination is specified) + clipAction(clip, optionalRoot, blendMode) { + const root = optionalRoot || this._root, rootUuid = root.uuid; + let clipObject = typeof clip === "string" ? AnimationClip.findByName(root, clip) : clip; + const clipUuid = clipObject !== null ? clipObject.uuid : clip; + const actionsForClip = this._actionsByClip[clipUuid]; + let prototypeAction = null; + if (blendMode === void 0) { + if (clipObject !== null) { + blendMode = clipObject.blendMode; + } else { + blendMode = NormalAnimationBlendMode; + } + } + if (actionsForClip !== void 0) { + const existingAction = actionsForClip.actionByRoot[rootUuid]; + if (existingAction !== void 0 && existingAction.blendMode === blendMode) { + return existingAction; + } + prototypeAction = actionsForClip.knownActions[0]; + if (clipObject === null) + clipObject = prototypeAction._clip; + } + if (clipObject === null) return null; + const newAction = new AnimationAction(this, clipObject, optionalRoot, blendMode); + this._bindAction(newAction, prototypeAction); + this._addInactiveAction(newAction, clipUuid, rootUuid); + return newAction; + } + // get an existing action + existingAction(clip, optionalRoot) { + const root = optionalRoot || this._root, rootUuid = root.uuid, clipObject = typeof clip === "string" ? AnimationClip.findByName(root, clip) : clip, clipUuid = clipObject ? clipObject.uuid : clip, actionsForClip = this._actionsByClip[clipUuid]; + if (actionsForClip !== void 0) { + return actionsForClip.actionByRoot[rootUuid] || null; + } + return null; + } + // deactivates all previously scheduled actions + stopAllAction() { + const actions = this._actions, nActions = this._nActiveActions; + for (let i = nActions - 1; i >= 0; --i) { + actions[i].stop(); + } + return this; + } + // advance the time and update apply the animation + update(deltaTime) { + deltaTime *= this.timeScale; + const actions = this._actions, nActions = this._nActiveActions, time = this.time += deltaTime, timeDirection = Math.sign(deltaTime), accuIndex = this._accuIndex ^= 1; + for (let i = 0; i !== nActions; ++i) { + const action = actions[i]; + action._update(time, deltaTime, timeDirection, accuIndex); + } + const bindings = this._bindings, nBindings = this._nActiveBindings; + for (let i = 0; i !== nBindings; ++i) { + bindings[i].apply(accuIndex); + } + return this; + } + // Allows you to seek to a specific time in an animation. + setTime(timeInSeconds) { + this.time = 0; + for (let i = 0; i < this._actions.length; i++) { + this._actions[i].time = 0; + } + return this.update(timeInSeconds); + } + // return this mixer's root target object + getRoot() { + return this._root; + } + // free all resources specific to a particular clip + uncacheClip(clip) { + const actions = this._actions, clipUuid = clip.uuid, actionsByClip = this._actionsByClip, actionsForClip = actionsByClip[clipUuid]; + if (actionsForClip !== void 0) { + const actionsToRemove = actionsForClip.knownActions; + for (let i = 0, n = actionsToRemove.length; i !== n; ++i) { + const action = actionsToRemove[i]; + this._deactivateAction(action); + const cacheIndex = action._cacheIndex, lastInactiveAction = actions[actions.length - 1]; + action._cacheIndex = null; + action._byClipCacheIndex = null; + lastInactiveAction._cacheIndex = cacheIndex; + actions[cacheIndex] = lastInactiveAction; + actions.pop(); + this._removeInactiveBindingsForAction(action); + } + delete actionsByClip[clipUuid]; + } + } + // free all resources specific to a particular root target object + uncacheRoot(root) { + const rootUuid = root.uuid, actionsByClip = this._actionsByClip; + for (const clipUuid in actionsByClip) { + const actionByRoot = actionsByClip[clipUuid].actionByRoot, action = actionByRoot[rootUuid]; + if (action !== void 0) { + this._deactivateAction(action); + this._removeInactiveAction(action); + } + } + const bindingsByRoot = this._bindingsByRootAndName, bindingByName = bindingsByRoot[rootUuid]; + if (bindingByName !== void 0) { + for (const trackName in bindingByName) { + const binding = bindingByName[trackName]; + binding.restoreOriginalState(); + this._removeInactiveBinding(binding); + } + } + } + // remove a targeted clip from the cache + uncacheAction(clip, optionalRoot) { + const action = this.existingAction(clip, optionalRoot); + if (action !== null) { + this._deactivateAction(action); + this._removeInactiveAction(action); + } + } +}; +var _matrix = /* @__PURE__ */ new Matrix4(); +var Raycaster = class { + constructor(origin, direction, near = 0, far = Infinity) { + this.ray = new Ray(origin, direction); + this.near = near; + this.far = far; + this.camera = null; + this.layers = new Layers(); + this.params = { + Mesh: {}, + Line: { threshold: 1 }, + LOD: {}, + Points: { threshold: 1 }, + Sprite: {} + }; + } + set(origin, direction) { + this.ray.set(origin, direction); + } + setFromCamera(coords, camera) { + if (camera.isPerspectiveCamera) { + this.ray.origin.setFromMatrixPosition(camera.matrixWorld); + this.ray.direction.set(coords.x, coords.y, 0.5).unproject(camera).sub(this.ray.origin).normalize(); + this.camera = camera; + } else if (camera.isOrthographicCamera) { + this.ray.origin.set(coords.x, coords.y, (camera.near + camera.far) / (camera.near - camera.far)).unproject(camera); + this.ray.direction.set(0, 0, -1).transformDirection(camera.matrixWorld); + this.camera = camera; + } else { + console.error("THREE.Raycaster: Unsupported camera type: " + camera.type); + } + } + setFromXRController(controller) { + _matrix.identity().extractRotation(controller.matrixWorld); + this.ray.origin.setFromMatrixPosition(controller.matrixWorld); + this.ray.direction.set(0, 0, -1).applyMatrix4(_matrix); + return this; + } + intersectObject(object, recursive = true, intersects2 = []) { + intersect(object, this, intersects2, recursive); + intersects2.sort(ascSort); + return intersects2; + } + intersectObjects(objects, recursive = true, intersects2 = []) { + for (let i = 0, l = objects.length; i < l; i++) { + intersect(objects[i], this, intersects2, recursive); + } + intersects2.sort(ascSort); + return intersects2; + } +}; +function ascSort(a, b) { + return a.distance - b.distance; +} +function intersect(object, raycaster, intersects2, recursive) { + if (object.layers.test(raycaster.layers)) { + object.raycast(raycaster, intersects2); + } + if (recursive === true) { + const children = object.children; + for (let i = 0, l = children.length; i < l; i++) { + intersect(children[i], raycaster, intersects2, true); + } + } +} +var Spherical = class { + constructor(radius = 1, phi = 0, theta = 0) { + this.radius = radius; + this.phi = phi; + this.theta = theta; + return this; + } + set(radius, phi, theta) { + this.radius = radius; + this.phi = phi; + this.theta = theta; + return this; + } + copy(other) { + this.radius = other.radius; + this.phi = other.phi; + this.theta = other.theta; + return this; + } + // restrict phi to be between EPS and PI-EPS + makeSafe() { + const EPS = 1e-6; + this.phi = Math.max(EPS, Math.min(Math.PI - EPS, this.phi)); + return this; + } + setFromVector3(v) { + return this.setFromCartesianCoords(v.x, v.y, v.z); + } + setFromCartesianCoords(x, y, z) { + this.radius = Math.sqrt(x * x + y * y + z * z); + if (this.radius === 0) { + this.theta = 0; + this.phi = 0; + } else { + this.theta = Math.atan2(x, z); + this.phi = Math.acos(clamp(y / this.radius, -1, 1)); + } + return this; + } + clone() { + return new this.constructor().copy(this); + } +}; +var _vector$3 = /* @__PURE__ */ new Vector3(); +var SpotLightHelper = class extends Object3D { + constructor(light, color) { + super(); + this.light = light; + this.matrixAutoUpdate = false; + this.color = color; + this.type = "SpotLightHelper"; + const geometry = new BufferGeometry(); + const positions = [ + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + -1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + -1, + 1 + ]; + for (let i = 0, j = 1, l = 32; i < l; i++, j++) { + const p1 = i / l * Math.PI * 2; + const p2 = j / l * Math.PI * 2; + positions.push( + Math.cos(p1), + Math.sin(p1), + 1, + Math.cos(p2), + Math.sin(p2), + 1 + ); + } + geometry.setAttribute("position", new Float32BufferAttribute(positions, 3)); + const material = new LineBasicMaterial({ fog: false, toneMapped: false }); + this.cone = new LineSegments(geometry, material); + this.add(this.cone); + this.update(); + } + dispose() { + this.cone.geometry.dispose(); + this.cone.material.dispose(); + } + update() { + this.light.updateWorldMatrix(true, false); + this.light.target.updateWorldMatrix(true, false); + if (this.parent) { + this.parent.updateWorldMatrix(true); + this.matrix.copy(this.parent.matrixWorld).invert().multiply(this.light.matrixWorld); + } else { + this.matrix.copy(this.light.matrixWorld); + } + this.matrixWorld.copy(this.light.matrixWorld); + const coneLength = this.light.distance ? this.light.distance : 1e3; + const coneWidth = coneLength * Math.tan(this.light.angle); + this.cone.scale.set(coneWidth, coneWidth, coneLength); + _vector$3.setFromMatrixPosition(this.light.target.matrixWorld); + this.cone.lookAt(_vector$3); + if (this.color !== void 0) { + this.cone.material.color.set(this.color); + } else { + this.cone.material.color.copy(this.light.color); + } + } +}; +var PointLightHelper = class extends Mesh { + constructor(light, sphereSize, color) { + const geometry = new SphereGeometry(sphereSize, 4, 2); + const material = new MeshBasicMaterial({ wireframe: true, fog: false, toneMapped: false }); + super(geometry, material); + this.light = light; + this.color = color; + this.type = "PointLightHelper"; + this.matrix = this.light.matrixWorld; + this.matrixAutoUpdate = false; + this.update(); + } + dispose() { + this.geometry.dispose(); + this.material.dispose(); + } + update() { + this.light.updateWorldMatrix(true, false); + if (this.color !== void 0) { + this.material.color.set(this.color); + } else { + this.material.color.copy(this.light.color); + } + } +}; +var AxesHelper = class extends LineSegments { + constructor(size = 1) { + const vertices = [ + 0, + 0, + 0, + size, + 0, + 0, + 0, + 0, + 0, + 0, + size, + 0, + 0, + 0, + 0, + 0, + 0, + size + ]; + const colors = [ + 1, + 0, + 0, + 1, + 0.6, + 0, + 0, + 1, + 0, + 0.6, + 1, + 0, + 0, + 0, + 1, + 0, + 0.6, + 1 + ]; + const geometry = new BufferGeometry(); + geometry.setAttribute("position", new Float32BufferAttribute(vertices, 3)); + geometry.setAttribute("color", new Float32BufferAttribute(colors, 3)); + const material = new LineBasicMaterial({ vertexColors: true, toneMapped: false }); + super(geometry, material); + this.type = "AxesHelper"; + } + setColors(xAxisColor, yAxisColor, zAxisColor) { + const color = new Color(); + const array = this.geometry.attributes.color.array; + color.set(xAxisColor); + color.toArray(array, 0); + color.toArray(array, 3); + color.set(yAxisColor); + color.toArray(array, 6); + color.toArray(array, 9); + color.set(zAxisColor); + color.toArray(array, 12); + color.toArray(array, 15); + this.geometry.attributes.color.needsUpdate = true; + return this; + } + dispose() { + this.geometry.dispose(); + this.material.dispose(); + } +}; +if (typeof __THREE_DEVTOOLS__ !== "undefined") { + __THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("register", { detail: { + revision: REVISION + } })); +} +if (typeof window !== "undefined") { + if (window.__THREE__) { + console.warn("WARNING: Multiple instances of Three.js being imported."); + } else { + window.__THREE__ = REVISION; + } +} + +// ../../node_modules/three/examples/jsm/helpers/PositionalAudioHelper.js +var PositionalAudioHelper = class extends Line { + constructor(audio, range = 1, divisionsInnerAngle = 16, divisionsOuterAngle = 2) { + const geometry = new BufferGeometry(); + const divisions = divisionsInnerAngle + divisionsOuterAngle * 2; + const positions = new Float32Array((divisions * 3 + 3) * 3); + geometry.setAttribute("position", new BufferAttribute(positions, 3)); + const materialInnerAngle = new LineBasicMaterial({ color: 65280 }); + const materialOuterAngle = new LineBasicMaterial({ color: 16776960 }); + super(geometry, [materialOuterAngle, materialInnerAngle]); + this.audio = audio; + this.range = range; + this.divisionsInnerAngle = divisionsInnerAngle; + this.divisionsOuterAngle = divisionsOuterAngle; + this.type = "PositionalAudioHelper"; + this.update(); + } + update() { + const audio = this.audio; + const range = this.range; + const divisionsInnerAngle = this.divisionsInnerAngle; + const divisionsOuterAngle = this.divisionsOuterAngle; + const coneInnerAngle = MathUtils.degToRad(audio.panner.coneInnerAngle); + const coneOuterAngle = MathUtils.degToRad(audio.panner.coneOuterAngle); + const halfConeInnerAngle = coneInnerAngle / 2; + const halfConeOuterAngle = coneOuterAngle / 2; + let start = 0; + let count = 0; + let i; + let stride; + const geometry = this.geometry; + const positionAttribute = geometry.attributes.position; + geometry.clearGroups(); + function generateSegment(from, to, divisions, materialIndex) { + const step = (to - from) / divisions; + positionAttribute.setXYZ(start, 0, 0, 0); + count++; + for (i = from; i < to; i += step) { + stride = start + count; + positionAttribute.setXYZ(stride, Math.sin(i) * range, 0, Math.cos(i) * range); + positionAttribute.setXYZ(stride + 1, Math.sin(Math.min(i + step, to)) * range, 0, Math.cos(Math.min(i + step, to)) * range); + positionAttribute.setXYZ(stride + 2, 0, 0, 0); + count += 3; + } + geometry.addGroup(start, count, materialIndex); + start += count; + count = 0; + } + generateSegment(-halfConeOuterAngle, -halfConeInnerAngle, divisionsOuterAngle, 0); + generateSegment(-halfConeInnerAngle, halfConeInnerAngle, divisionsInnerAngle, 1); + generateSegment(halfConeInnerAngle, halfConeOuterAngle, divisionsOuterAngle, 0); + positionAttribute.needsUpdate = true; + if (coneInnerAngle === coneOuterAngle) this.material[0].visible = false; + } + dispose() { + this.geometry.dispose(); + this.material[0].dispose(); + this.material[1].dispose(); + } +}; + +// ../../node_modules/three/examples/jsm/loaders/DRACOLoader.js +var _taskCache = /* @__PURE__ */ new WeakMap(); +var DRACOLoader = class extends Loader { + constructor(manager) { + super(manager); + this.decoderPath = ""; + this.decoderConfig = {}; + this.decoderBinary = null; + this.decoderPending = null; + this.workerLimit = 4; + this.workerPool = []; + this.workerNextTaskID = 1; + this.workerSourceURL = ""; + this.defaultAttributeIDs = { + position: "POSITION", + normal: "NORMAL", + color: "COLOR", + uv: "TEX_COORD" + }; + this.defaultAttributeTypes = { + position: "Float32Array", + normal: "Float32Array", + color: "Float32Array", + uv: "Float32Array" + }; + } + setDecoderPath(path) { + this.decoderPath = path; + return this; + } + setDecoderConfig(config) { + this.decoderConfig = config; + return this; + } + setWorkerLimit(workerLimit) { + this.workerLimit = workerLimit; + return this; + } + load(url, onLoad, onProgress, onError) { + const loader = new FileLoader(this.manager); + loader.setPath(this.path); + loader.setResponseType("arraybuffer"); + loader.setRequestHeader(this.requestHeader); + loader.setWithCredentials(this.withCredentials); + loader.load(url, (buffer) => { + this.parse(buffer, onLoad, onError); + }, onProgress, onError); + } + parse(buffer, onLoad, onError = () => { + }) { + this.decodeDracoFile(buffer, onLoad, null, null, SRGBColorSpace).catch(onError); + } + decodeDracoFile(buffer, callback, attributeIDs, attributeTypes, vertexColorSpace = LinearSRGBColorSpace, onError = () => { + }) { + const taskConfig = { + attributeIDs: attributeIDs || this.defaultAttributeIDs, + attributeTypes: attributeTypes || this.defaultAttributeTypes, + useUniqueIDs: !!attributeIDs, + vertexColorSpace + }; + return this.decodeGeometry(buffer, taskConfig).then(callback).catch(onError); + } + decodeGeometry(buffer, taskConfig) { + const taskKey = JSON.stringify(taskConfig); + if (_taskCache.has(buffer)) { + const cachedTask = _taskCache.get(buffer); + if (cachedTask.key === taskKey) { + return cachedTask.promise; + } else if (buffer.byteLength === 0) { + throw new Error( + "THREE.DRACOLoader: Unable to re-decode a buffer with different settings. Buffer has already been transferred." + ); + } + } + let worker; + const taskID = this.workerNextTaskID++; + const taskCost = buffer.byteLength; + const geometryPending = this._getWorker(taskID, taskCost).then((_worker) => { + worker = _worker; + return new Promise((resolve, reject) => { + worker._callbacks[taskID] = { resolve, reject }; + worker.postMessage({ type: "decode", id: taskID, taskConfig, buffer }, [buffer]); + }); + }).then((message) => this._createGeometry(message.geometry)); + geometryPending.catch(() => true).then(() => { + if (worker && taskID) { + this._releaseTask(worker, taskID); + } + }); + _taskCache.set(buffer, { + key: taskKey, + promise: geometryPending + }); + return geometryPending; + } + _createGeometry(geometryData) { + const geometry = new BufferGeometry(); + if (geometryData.index) { + geometry.setIndex(new BufferAttribute(geometryData.index.array, 1)); + } + for (let i = 0; i < geometryData.attributes.length; i++) { + const result = geometryData.attributes[i]; + const name = result.name; + const array = result.array; + const itemSize = result.itemSize; + const attribute = new BufferAttribute(array, itemSize); + if (name === "color") { + this._assignVertexColorSpace(attribute, result.vertexColorSpace); + attribute.normalized = array instanceof Float32Array === false; + } + geometry.setAttribute(name, attribute); + } + return geometry; + } + _assignVertexColorSpace(attribute, inputColorSpace) { + if (inputColorSpace !== SRGBColorSpace) return; + const _color2 = new Color(); + for (let i = 0, il = attribute.count; i < il; i++) { + _color2.fromBufferAttribute(attribute, i).convertSRGBToLinear(); + attribute.setXYZ(i, _color2.r, _color2.g, _color2.b); + } + } + _loadLibrary(url, responseType) { + const loader = new FileLoader(this.manager); + loader.setPath(this.decoderPath); + loader.setResponseType(responseType); + loader.setWithCredentials(this.withCredentials); + return new Promise((resolve, reject) => { + loader.load(url, resolve, void 0, reject); + }); + } + preload() { + this._initDecoder(); + return this; + } + _initDecoder() { + if (this.decoderPending) return this.decoderPending; + const useJS = typeof WebAssembly !== "object" || this.decoderConfig.type === "js"; + const librariesPending = []; + if (useJS) { + librariesPending.push(this._loadLibrary("draco_decoder.js", "text")); + } else { + librariesPending.push(this._loadLibrary("draco_wasm_wrapper.js", "text")); + librariesPending.push(this._loadLibrary("draco_decoder.wasm", "arraybuffer")); + } + this.decoderPending = Promise.all(librariesPending).then((libraries) => { + const jsContent = libraries[0]; + if (!useJS) { + this.decoderConfig.wasmBinary = libraries[1]; + } + const fn = DRACOWorker.toString(); + const body = [ + "/* draco decoder */", + jsContent, + "", + "/* worker */", + fn.substring(fn.indexOf("{") + 1, fn.lastIndexOf("}")) + ].join("\n"); + this.workerSourceURL = URL.createObjectURL(new Blob([body])); + }); + return this.decoderPending; + } + _getWorker(taskID, taskCost) { + return this._initDecoder().then(() => { + if (this.workerPool.length < this.workerLimit) { + const worker2 = new Worker(this.workerSourceURL); + worker2._callbacks = {}; + worker2._taskCosts = {}; + worker2._taskLoad = 0; + worker2.postMessage({ type: "init", decoderConfig: this.decoderConfig }); + worker2.onmessage = function(e) { + const message = e.data; + switch (message.type) { + case "decode": + worker2._callbacks[message.id].resolve(message); + break; + case "error": + worker2._callbacks[message.id].reject(message); + break; + default: + console.error('THREE.DRACOLoader: Unexpected message, "' + message.type + '"'); + } + }; + this.workerPool.push(worker2); + } else { + this.workerPool.sort(function(a, b) { + return a._taskLoad > b._taskLoad ? -1 : 1; + }); + } + const worker = this.workerPool[this.workerPool.length - 1]; + worker._taskCosts[taskID] = taskCost; + worker._taskLoad += taskCost; + return worker; + }); + } + _releaseTask(worker, taskID) { + worker._taskLoad -= worker._taskCosts[taskID]; + delete worker._callbacks[taskID]; + delete worker._taskCosts[taskID]; + } + debug() { + console.log("Task load: ", this.workerPool.map((worker) => worker._taskLoad)); + } + dispose() { + for (let i = 0; i < this.workerPool.length; ++i) { + this.workerPool[i].terminate(); + } + this.workerPool.length = 0; + if (this.workerSourceURL !== "") { + URL.revokeObjectURL(this.workerSourceURL); + } + return this; + } +}; +function DRACOWorker() { + let decoderConfig; + let decoderPending; + onmessage = function(e) { + const message = e.data; + switch (message.type) { + case "init": + decoderConfig = message.decoderConfig; + decoderPending = new Promise(function(resolve) { + decoderConfig.onModuleLoaded = function(draco) { + resolve({ draco }); + }; + DracoDecoderModule(decoderConfig); + }); + break; + case "decode": + const buffer = message.buffer; + const taskConfig = message.taskConfig; + decoderPending.then((module) => { + const draco = module.draco; + const decoder = new draco.Decoder(); + try { + const geometry = decodeGeometry(draco, decoder, new Int8Array(buffer), taskConfig); + const buffers = geometry.attributes.map((attr) => attr.array.buffer); + if (geometry.index) buffers.push(geometry.index.array.buffer); + self.postMessage({ type: "decode", id: message.id, geometry }, buffers); + } catch (error) { + console.error(error); + self.postMessage({ type: "error", id: message.id, error: error.message }); + } finally { + draco.destroy(decoder); + } + }); + break; + } + }; + function decodeGeometry(draco, decoder, array, taskConfig) { + const attributeIDs = taskConfig.attributeIDs; + const attributeTypes = taskConfig.attributeTypes; + let dracoGeometry; + let decodingStatus; + const geometryType = decoder.GetEncodedGeometryType(array); + if (geometryType === draco.TRIANGULAR_MESH) { + dracoGeometry = new draco.Mesh(); + decodingStatus = decoder.DecodeArrayToMesh(array, array.byteLength, dracoGeometry); + } else if (geometryType === draco.POINT_CLOUD) { + dracoGeometry = new draco.PointCloud(); + decodingStatus = decoder.DecodeArrayToPointCloud(array, array.byteLength, dracoGeometry); + } else { + throw new Error("THREE.DRACOLoader: Unexpected geometry type."); + } + if (!decodingStatus.ok() || dracoGeometry.ptr === 0) { + throw new Error("THREE.DRACOLoader: Decoding failed: " + decodingStatus.error_msg()); + } + const geometry = { index: null, attributes: [] }; + for (const attributeName in attributeIDs) { + const attributeType = self[attributeTypes[attributeName]]; + let attribute; + let attributeID; + if (taskConfig.useUniqueIDs) { + attributeID = attributeIDs[attributeName]; + attribute = decoder.GetAttributeByUniqueId(dracoGeometry, attributeID); + } else { + attributeID = decoder.GetAttributeId(dracoGeometry, draco[attributeIDs[attributeName]]); + if (attributeID === -1) continue; + attribute = decoder.GetAttribute(dracoGeometry, attributeID); + } + const attributeResult = decodeAttribute(draco, decoder, dracoGeometry, attributeName, attributeType, attribute); + if (attributeName === "color") { + attributeResult.vertexColorSpace = taskConfig.vertexColorSpace; + } + geometry.attributes.push(attributeResult); + } + if (geometryType === draco.TRIANGULAR_MESH) { + geometry.index = decodeIndex(draco, decoder, dracoGeometry); + } + draco.destroy(dracoGeometry); + return geometry; + } + function decodeIndex(draco, decoder, dracoGeometry) { + const numFaces = dracoGeometry.num_faces(); + const numIndices = numFaces * 3; + const byteLength = numIndices * 4; + const ptr = draco._malloc(byteLength); + decoder.GetTrianglesUInt32Array(dracoGeometry, byteLength, ptr); + const index = new Uint32Array(draco.HEAPF32.buffer, ptr, numIndices).slice(); + draco._free(ptr); + return { array: index, itemSize: 1 }; + } + function decodeAttribute(draco, decoder, dracoGeometry, attributeName, attributeType, attribute) { + const numComponents = attribute.num_components(); + const numPoints = dracoGeometry.num_points(); + const numValues = numPoints * numComponents; + const byteLength = numValues * attributeType.BYTES_PER_ELEMENT; + const dataType = getDracoDataType(draco, attributeType); + const ptr = draco._malloc(byteLength); + decoder.GetAttributeDataArrayForAllPoints(dracoGeometry, attribute, dataType, byteLength, ptr); + const array = new attributeType(draco.HEAPF32.buffer, ptr, numValues).slice(); + draco._free(ptr); + return { + name: attributeName, + array, + itemSize: numComponents + }; + } + function getDracoDataType(draco, attributeType) { + switch (attributeType) { + case Float32Array: + return draco.DT_FLOAT32; + case Int8Array: + return draco.DT_INT8; + case Int16Array: + return draco.DT_INT16; + case Int32Array: + return draco.DT_INT32; + case Uint8Array: + return draco.DT_UINT8; + case Uint16Array: + return draco.DT_UINT16; + case Uint32Array: + return draco.DT_UINT32; + } + } +} + +// ../../node_modules/three/examples/jsm/libs/meshopt_decoder.module.js +var MeshoptDecoder = function() { + "use strict"; + var wasm_base = "b9H79Tebbbe8Fv9Gbb9Gvuuuuueu9Giuuub9Geueu9Giuuueuikqbeeedddillviebeoweuec:q;iekr;leDo9TW9T9VV95dbH9F9F939H79T9F9J9H229F9Jt9VV7bb8A9TW79O9V9Wt9F9KW9J9V9KW9wWVtW949c919M9MWVbeY9TW79O9V9Wt9F9KW9J9V9KW69U9KW949c919M9MWVbdE9TW79O9V9Wt9F9KW9J9V9KW69U9KW949tWG91W9U9JWbiL9TW79O9V9Wt9F9KW9J9V9KWS9P2tWV9p9JtblK9TW79O9V9Wt9F9KW9J9V9KWS9P2tWV9r919HtbvL9TW79O9V9Wt9F9KW9J9V9KWS9P2tWVT949Wbol79IV9Rbrq:P8Yqdbk;3sezu8Jjjjjbcj;eb9Rgv8Kjjjjbc9:hodnadcefal0mbcuhoaiRbbc:Ge9hmbavaialfgrad9Radz1jjjbhwcj;abad9UhoaicefhldnadTmbaoc;WFbGgocjdaocjd6EhDcbhqinaqae9pmeaDaeaq9RaqaDfae6Egkcsfgocl4cifcd4hxdndndndnaoc9WGgmTmbcbhPcehsawcjdfhzalhHinaraH9Rax6midnaraHaxfgl9RcK6mbczhoinawcj;cbfaogifgoc9WfhOdndndndndnaHaic9WfgAco4fRbbaAci4coG4ciGPlbedibkaO9cb83ibaOcwf9cb83ibxikaOalRblalRbbgAco4gCaCciSgCE86bbaocGfalclfaCfgORbbaAcl4ciGgCaCciSgCE86bbaocVfaOaCfgORbbaAcd4ciGgCaCciSgCE86bbaoc7faOaCfgORbbaAciGgAaAciSgAE86bbaoctfaOaAfgARbbalRbegOco4gCaCciSgCE86bbaoc91faAaCfgARbbaOcl4ciGgCaCciSgCE86bbaoc4faAaCfgARbbaOcd4ciGgCaCciSgCE86bbaoc93faAaCfgARbbaOciGgOaOciSgOE86bbaoc94faAaOfgARbbalRbdgOco4gCaCciSgCE86bbaoc95faAaCfgARbbaOcl4ciGgCaCciSgCE86bbaoc96faAaCfgARbbaOcd4ciGgCaCciSgCE86bbaoc97faAaCfgARbbaOciGgOaOciSgOE86bbaoc98faAaOfgORbbalRbiglco4gAaAciSgAE86bbaoc99faOaAfgORbbalcl4ciGgAaAciSgAE86bbaoc9:faOaAfgORbbalcd4ciGgAaAciSgAE86bbaocufaOaAfgoRbbalciGglalciSglE86bbaoalfhlxdkaOalRbwalRbbgAcl4gCaCcsSgCE86bbaocGfalcwfaCfgORbbaAcsGgAaAcsSgAE86bbaocVfaOaAfgORbbalRbegAcl4gCaCcsSgCE86bbaoc7faOaCfgORbbaAcsGgAaAcsSgAE86bbaoctfaOaAfgORbbalRbdgAcl4gCaCcsSgCE86bbaoc91faOaCfgORbbaAcsGgAaAcsSgAE86bbaoc4faOaAfgORbbalRbigAcl4gCaCcsSgCE86bbaoc93faOaCfgORbbaAcsGgAaAcsSgAE86bbaoc94faOaAfgORbbalRblgAcl4gCaCcsSgCE86bbaoc95faOaCfgORbbaAcsGgAaAcsSgAE86bbaoc96faOaAfgORbbalRbvgAcl4gCaCcsSgCE86bbaoc97faOaCfgORbbaAcsGgAaAcsSgAE86bbaoc98faOaAfgORbbalRbogAcl4gCaCcsSgCE86bbaoc99faOaCfgORbbaAcsGgAaAcsSgAE86bbaoc9:faOaAfgORbbalRbrglcl4gAaAcsSgAE86bbaocufaOaAfgoRbbalcsGglalcsSglE86bbaoalfhlxekaOal8Pbb83bbaOcwfalcwf8Pbb83bbalczfhlkdnaiam9pmbaiczfhoaral9RcL0mekkaiam6mialTmidnakTmbawaPfRbbhOcbhoazhiinaiawcj;cbfaofRbbgAce4cbaAceG9R7aOfgO86bbaiadfhiaocefgoak9hmbkkazcefhzaPcefgPad6hsalhHaPad9hmexvkkcbhlasceGmdxikalaxad2fhCdnakTmbcbhHcehsawcjdfhminaral9Rax6mialTmdalaxfhlawaHfRbbhOcbhoamhiinaiawcj;cbfaofRbbgAce4cbaAceG9R7aOfgO86bbaiadfhiaocefgoak9hmbkamcefhmaHcefgHad6hsaHad9hmbkaChlxikcbhocehsinaral9Rax6mdalTmealaxfhlaocefgoad6hsadao9hmbkaChlxdkcbhlasceGTmekc9:hoxikabaqad2fawcjdfakad2z1jjjb8Aawawcjdfakcufad2fadz1jjjb8Aakaqfhqalmbkc9:hoxekcbc99aral9Radcaadca0ESEhokavcj;ebf8Kjjjjbaok;yzeHu8Jjjjjbc;ae9Rgv8Kjjjjbc9:hodnaeci9UgrcHfal0mbcuhoaiRbbgwc;WeGc;Ge9hmbawcsGgDce0mbavc;abfcFecjez:jjjjb8AavcUf9cu83ibavc8Wf9cu83ibavcyf9cu83ibavcaf9cu83ibavcKf9cu83ibavczf9cu83ibav9cu83iwav9cu83ibaialfc9WfhqaicefgwarfhodnaeTmbcmcsaDceSEhkcbhxcbhmcbhDcbhicbhlindnaoaq9nmbc9:hoxikdndnawRbbgrc;Ve0mbavc;abfalarcl4cu7fcsGcitfgPydlhsaPydbhzdnarcsGgPak9pmbavaiarcu7fcsGcdtfydbaxaPEhraPThPdndnadcd9hmbabaDcetfgHaz87ebaHcdfas87ebaHclfar87ebxekabaDcdtfgHazBdbaHclfasBdbaHcwfarBdbkaxaPfhxavc;abfalcitfgHarBdbaHasBdlavaicdtfarBdbavc;abfalcefcsGglcitfgHazBdbaHarBdlaiaPfhialcefhlxdkdndnaPcsSmbamaPfaPc987fcefhmxekaocefhrao8SbbgPcFeGhHdndnaPcu9mmbarhoxekaocvfhoaHcFbGhHcrhPdninar8SbbgOcFbGaPtaHVhHaOcu9kmearcefhraPcrfgPc8J9hmbxdkkarcefhokaHce4cbaHceG9R7amfhmkdndnadcd9hmbabaDcetfgraz87ebarcdfas87ebarclfam87ebxekabaDcdtfgrazBdbarclfasBdbarcwfamBdbkavc;abfalcitfgramBdbarasBdlavaicdtfamBdbavc;abfalcefcsGglcitfgrazBdbaramBdlaicefhialcefhlxekdnarcpe0mbaxcefgOavaiaqarcsGfRbbgPcl49RcsGcdtfydbaPcz6gHEhravaiaP9RcsGcdtfydbaOaHfgsaPcsGgOEhPaOThOdndnadcd9hmbabaDcetfgzax87ebazcdfar87ebazclfaP87ebxekabaDcdtfgzaxBdbazclfarBdbazcwfaPBdbkavaicdtfaxBdbavc;abfalcitfgzarBdbazaxBdlavaicefgicsGcdtfarBdbavc;abfalcefcsGcitfgzaPBdbazarBdlavaiaHfcsGgicdtfaPBdbavc;abfalcdfcsGglcitfgraxBdbaraPBdlalcefhlaiaOfhiasaOfhxxekaxcbaoRbbgzEgAarc;:eSgrfhsazcsGhCazcl4hXdndnazcs0mbascefhOxekashOavaiaX9RcsGcdtfydbhskdndnaCmbaOcefhxxekaOhxavaiaz9RcsGcdtfydbhOkdndnarTmbaocefhrxekaocdfhrao8SbegHcFeGhPdnaHcu9kmbaocofhAaPcFbGhPcrhodninar8SbbgHcFbGaotaPVhPaHcu9kmearcefhraocrfgoc8J9hmbkaAhrxekarcefhrkaPce4cbaPceG9R7amfgmhAkdndnaXcsSmbarhPxekarcefhPar8SbbgocFeGhHdnaocu9kmbarcvfhsaHcFbGhHcrhodninaP8SbbgrcFbGaotaHVhHarcu9kmeaPcefhPaocrfgoc8J9hmbkashPxekaPcefhPkaHce4cbaHceG9R7amfgmhskdndnaCcsSmbaPhoxekaPcefhoaP8SbbgrcFeGhHdnarcu9kmbaPcvfhOaHcFbGhHcrhrdninao8SbbgPcFbGartaHVhHaPcu9kmeaocefhoarcrfgrc8J9hmbkaOhoxekaocefhokaHce4cbaHceG9R7amfgmhOkdndnadcd9hmbabaDcetfgraA87ebarcdfas87ebarclfaO87ebxekabaDcdtfgraABdbarclfasBdbarcwfaOBdbkavc;abfalcitfgrasBdbaraABdlavaicdtfaABdbavc;abfalcefcsGcitfgraOBdbarasBdlavaicefgicsGcdtfasBdbavc;abfalcdfcsGcitfgraABdbaraOBdlavaiazcz6aXcsSVfgicsGcdtfaOBdbaiaCTaCcsSVfhialcifhlkawcefhwalcsGhlaicsGhiaDcifgDae6mbkkcbc99aoaqSEhokavc;aef8Kjjjjbaok:llevu8Jjjjjbcz9Rhvc9:hodnaecvfal0mbcuhoaiRbbc;:eGc;qe9hmbav9cb83iwaicefhraialfc98fhwdnaeTmbdnadcdSmbcbhDindnaraw6mbc9:skarcefhoar8SbbglcFeGhidndnalcu9mmbaohrxekarcvfhraicFbGhicrhldninao8SbbgdcFbGaltaiVhiadcu9kmeaocefhoalcrfglc8J9hmbxdkkaocefhrkabaDcdtfaicd4cbaice4ceG9R7avcwfaiceGcdtVgoydbfglBdbaoalBdbaDcefgDae9hmbxdkkcbhDindnaraw6mbc9:skarcefhoar8SbbglcFeGhidndnalcu9mmbaohrxekarcvfhraicFbGhicrhldninao8SbbgdcFbGaltaiVhiadcu9kmeaocefhoalcrfglc8J9hmbxdkkaocefhrkabaDcetfaicd4cbaice4ceG9R7avcwfaiceGcdtVgoydbfgl87ebaoalBdbaDcefgDae9hmbkkcbc99arawSEhokaok:Lvoeue99dud99eud99dndnadcl9hmbaeTmeindndnabcdfgd8Sbb:Yab8Sbbgi:Ygl:l:tabcefgv8Sbbgo:Ygr:l:tgwJbb;:9cawawNJbbbbawawJbbbb9GgDEgq:mgkaqaicb9iEalMgwawNakaqaocb9iEarMgqaqNMM:r:vglNJbbbZJbbb:;aDEMgr:lJbbb9p9DTmbar:Ohixekcjjjj94hikadai86bbdndnaqalNJbbbZJbbb:;aqJbbbb9GEMgq:lJbbb9p9DTmbaq:Ohdxekcjjjj94hdkavad86bbdndnawalNJbbbZJbbb:;awJbbbb9GEMgw:lJbbb9p9DTmbaw:Ohdxekcjjjj94hdkabad86bbabclfhbaecufgembxdkkaeTmbindndnabclfgd8Ueb:Yab8Uebgi:Ygl:l:tabcdfgv8Uebgo:Ygr:l:tgwJb;:FSawawNJbbbbawawJbbbb9GgDEgq:mgkaqaicb9iEalMgwawNakaqaocb9iEarMgqaqNMM:r:vglNJbbbZJbbb:;aDEMgr:lJbbb9p9DTmbar:Ohixekcjjjj94hikadai87ebdndnaqalNJbbbZJbbb:;aqJbbbb9GEMgq:lJbbb9p9DTmbaq:Ohdxekcjjjj94hdkavad87ebdndnawalNJbbbZJbbb:;awJbbbb9GEMgw:lJbbb9p9DTmbaw:Ohdxekcjjjj94hdkabad87ebabcwfhbaecufgembkkk;siliui99iue99dnaeTmbcbhiabhlindndnJ;Zl81Zalcof8UebgvciV:Y:vgoal8Ueb:YNgrJb;:FSNJbbbZJbbb:;arJbbbb9GEMgw:lJbbb9p9DTmbaw:OhDxekcjjjj94hDkalclf8Uebhqalcdf8UebhkabavcefciGaiVcetfaD87ebdndnaoak:YNgwJb;:FSNJbbbZJbbb:;awJbbbb9GEMgx:lJbbb9p9DTmbax:Ohkxekcjjjj94hkkabavcdfciGaiVcetfak87ebdndnaoaq:YNgoJb;:FSNJbbbZJbbb:;aoJbbbb9GEMgx:lJbbb9p9DTmbax:Ohqxekcjjjj94hqkabavcufciGaiVcetfaq87ebdndnJbbjZararN:tawawN:taoaoN:tgrJbbbbarJbbbb9GE:rJb;:FSNJbbbZMgr:lJbbb9p9DTmbar:Ohqxekcjjjj94hqkabavciGaiVcetfaq87ebalcwfhlaiclfhiaecufgembkkk9mbdnadcd4ae2geTmbinababydbgdcwtcw91:Yadce91cjjj;8ifcjjj98G::NUdbabclfhbaecufgembkkk9teiucbcbydj1jjbgeabcifc98GfgbBdj1jjbdndnabZbcztgd9nmbcuhiabad9RcFFifcz4nbcuSmekaehikaik;LeeeudndnaeabVciGTmbabhixekdndnadcz9pmbabhixekabhiinaiaeydbBdbaiclfaeclfydbBdbaicwfaecwfydbBdbaicxfaecxfydbBdbaiczfhiaeczfheadc9Wfgdcs0mbkkadcl6mbinaiaeydbBdbaeclfheaiclfhiadc98fgdci0mbkkdnadTmbinaiaeRbb86bbaicefhiaecefheadcufgdmbkkabk;aeedudndnabciGTmbabhixekaecFeGc:b:c:ew2hldndnadcz9pmbabhixekabhiinaialBdbaicxfalBdbaicwfalBdbaiclfalBdbaiczfhiadc9Wfgdcs0mbkkadcl6mbinaialBdbaiclfhiadc98fgdci0mbkkdnadTmbinaiae86bbaicefhiadcufgdmbkkabkkkebcjwklz9Kbb"; + var wasm_simd = "b9H79TebbbeKl9Gbb9Gvuuuuueu9Giuuub9Geueuikqbbebeedddilve9Weeeviebeoweuec:q;Aekr;leDo9TW9T9VV95dbH9F9F939H79T9F9J9H229F9Jt9VV7bb8A9TW79O9V9Wt9F9KW9J9V9KW9wWVtW949c919M9MWVbdY9TW79O9V9Wt9F9KW9J9V9KW69U9KW949c919M9MWVblE9TW79O9V9Wt9F9KW9J9V9KW69U9KW949tWG91W9U9JWbvL9TW79O9V9Wt9F9KW9J9V9KWS9P2tWV9p9JtboK9TW79O9V9Wt9F9KW9J9V9KWS9P2tWV9r919HtbrL9TW79O9V9Wt9F9KW9J9V9KWS9P2tWVT949Wbwl79IV9RbDq;t9tqlbzik9:evu8Jjjjjbcz9Rhbcbheincbhdcbhiinabcwfadfaicjuaead4ceGglE86bbaialfhiadcefgdcw9hmbkaec:q:yjjbfai86bbaecitc:q1jjbfab8Piw83ibaecefgecjd9hmbkk;h8JlHud97euo978Jjjjjbcj;kb9Rgv8Kjjjjbc9:hodnadcefal0mbcuhoaiRbbc:Ge9hmbavaialfgrad9Rad;8qbbcj;abad9UhoaicefhldnadTmbaoc;WFbGgocjdaocjd6EhwcbhDinaDae9pmeawaeaD9RaDawfae6Egqcsfgoc9WGgkci2hxakcethmaocl4cifcd4hPabaDad2fhscbhzdnincehHalhOcbhAdninaraO9RaP6miavcj;cbfaAak2fhCaOaPfhlcbhidnakc;ab6mbaral9Rc;Gb6mbcbhoinaCaofhidndndndndnaOaoco4fRbbgXciGPlbedibkaipxbbbbbbbbbbbbbbbbpklbxikaialpbblalpbbbgQclp:meaQpmbzeHdOiAlCvXoQrLgQcdp:meaQpmbzeHdOiAlCvXoQrLpxiiiiiiiiiiiiiiiip9ogLpxiiiiiiiiiiiiiiiip8JgQp5b9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibaKc:q:yjjbfpbbbgYaYpmbbbbbbbbbbbbbbbbaQp5e9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibp9UpmbedilvorzHOACXQLpPaLaQp9spklbalclfaYpQbfaKc:q:yjjbfRbbfhlxdkaialpbbwalpbbbgQclp:meaQpmbzeHdOiAlCvXoQrLpxssssssssssssssssp9ogLpxssssssssssssssssp8JgQp5b9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibaKc:q:yjjbfpbbbgYaYpmbbbbbbbbbbbbbbbbaQp5e9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibp9UpmbedilvorzHOACXQLpPaLaQp9spklbalcwfaYpQbfaKc:q:yjjbfRbbfhlxekaialpbbbpklbalczfhlkdndndndndnaXcd4ciGPlbedibkaipxbbbbbbbbbbbbbbbbpklzxikaialpbblalpbbbgQclp:meaQpmbzeHdOiAlCvXoQrLgQcdp:meaQpmbzeHdOiAlCvXoQrLpxiiiiiiiiiiiiiiiip9ogLpxiiiiiiiiiiiiiiiip8JgQp5b9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibaKc:q:yjjbfpbbbgYaYpmbbbbbbbbbbbbbbbbaQp5e9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibp9UpmbedilvorzHOACXQLpPaLaQp9spklzalclfaYpQbfaKc:q:yjjbfRbbfhlxdkaialpbbwalpbbbgQclp:meaQpmbzeHdOiAlCvXoQrLpxssssssssssssssssp9ogLpxssssssssssssssssp8JgQp5b9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibaKc:q:yjjbfpbbbgYaYpmbbbbbbbbbbbbbbbbaQp5e9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibp9UpmbedilvorzHOACXQLpPaLaQp9spklzalcwfaYpQbfaKc:q:yjjbfRbbfhlxekaialpbbbpklzalczfhlkdndndndndnaXcl4ciGPlbedibkaipxbbbbbbbbbbbbbbbbpklaxikaialpbblalpbbbgQclp:meaQpmbzeHdOiAlCvXoQrLgQcdp:meaQpmbzeHdOiAlCvXoQrLpxiiiiiiiiiiiiiiiip9ogLpxiiiiiiiiiiiiiiiip8JgQp5b9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibaKc:q:yjjbfpbbbgYaYpmbbbbbbbbbbbbbbbbaQp5e9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibp9UpmbedilvorzHOACXQLpPaLaQp9spklaalclfaYpQbfaKc:q:yjjbfRbbfhlxdkaialpbbwalpbbbgQclp:meaQpmbzeHdOiAlCvXoQrLpxssssssssssssssssp9ogLpxssssssssssssssssp8JgQp5b9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibaKc:q:yjjbfpbbbgYaYpmbbbbbbbbbbbbbbbbaQp5e9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibp9UpmbedilvorzHOACXQLpPaLaQp9spklaalcwfaYpQbfaKc:q:yjjbfRbbfhlxekaialpbbbpklaalczfhlkdndndndndnaXco4Plbedibkaipxbbbbbbbbbbbbbbbbpkl8WxikaialpbblalpbbbgQclp:meaQpmbzeHdOiAlCvXoQrLgQcdp:meaQpmbzeHdOiAlCvXoQrLpxiiiiiiiiiiiiiiiip9ogLpxiiiiiiiiiiiiiiiip8JgQp5b9cjF;8;4;W;G;ab9:9cU1:NgXcitc:q1jjbfpbibaXc:q:yjjbfpbbbgYaYpmbbbbbbbbbbbbbbbbaQp5e9cjF;8;4;W;G;ab9:9cU1:NgXcitc:q1jjbfpbibp9UpmbedilvorzHOACXQLpPaLaQp9spkl8WalclfaYpQbfaXc:q:yjjbfRbbfhlxdkaialpbbwalpbbbgQclp:meaQpmbzeHdOiAlCvXoQrLpxssssssssssssssssp9ogLpxssssssssssssssssp8JgQp5b9cjF;8;4;W;G;ab9:9cU1:NgXcitc:q1jjbfpbibaXc:q:yjjbfpbbbgYaYpmbbbbbbbbbbbbbbbbaQp5e9cjF;8;4;W;G;ab9:9cU1:NgXcitc:q1jjbfpbibp9UpmbedilvorzHOACXQLpPaLaQp9spkl8WalcwfaYpQbfaXc:q:yjjbfRbbfhlxekaialpbbbpkl8Walczfhlkaoc;abfhiaocjefak0meaihoaral9Rc;Fb0mbkkdndnaiak9pmbaici4hoinaral9RcK6mdaCaifhXdndndndndnaOaico4fRbbaocoG4ciGPlbedibkaXpxbbbbbbbbbbbbbbbbpklbxikaXalpbblalpbbbgQclp:meaQpmbzeHdOiAlCvXoQrLgQcdp:meaQpmbzeHdOiAlCvXoQrLpxiiiiiiiiiiiiiiiip9ogLpxiiiiiiiiiiiiiiiip8JgQp5b9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibaKc:q:yjjbfpbbbgYaYpmbbbbbbbbbbbbbbbbaQp5e9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibp9UpmbedilvorzHOACXQLpPaLaQp9spklbalclfaYpQbfaKc:q:yjjbfRbbfhlxdkaXalpbbwalpbbbgQclp:meaQpmbzeHdOiAlCvXoQrLpxssssssssssssssssp9ogLpxssssssssssssssssp8JgQp5b9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibaKc:q:yjjbfpbbbgYaYpmbbbbbbbbbbbbbbbbaQp5e9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibp9UpmbedilvorzHOACXQLpPaLaQp9spklbalcwfaYpQbfaKc:q:yjjbfRbbfhlxekaXalpbbbpklbalczfhlkaocdfhoaiczfgiak6mbkkalTmbaAci6hHalhOaAcefgohAaoclSmdxekkcbhlaHceGmdkdnakTmbavcjdfazfhiavazfpbdbhYcbhXinaiavcj;cbfaXfgopblbgLcep9TaLpxeeeeeeeeeeeeeeeegQp9op9Hp9rgLaoakfpblbg8Acep9Ta8AaQp9op9Hp9rg8ApmbzeHdOiAlCvXoQrLgEaoamfpblbg3cep9Ta3aQp9op9Hp9rg3aoaxfpblbg5cep9Ta5aQp9op9Hp9rg5pmbzeHdOiAlCvXoQrLg8EpmbezHdiOAlvCXorQLgQaQpmbedibedibedibediaYp9UgYp9AdbbaiadfgoaYaQaQpmlvorlvorlvorlvorp9UgYp9AdbbaoadfgoaYaQaQpmwDqkwDqkwDqkwDqkp9UgYp9AdbbaoadfgoaYaQaQpmxmPsxmPsxmPsxmPsp9UgYp9AdbbaoadfgoaYaEa8EpmwDKYqk8AExm35Ps8E8FgQaQpmbedibedibedibedip9UgYp9AdbbaoadfgoaYaQaQpmlvorlvorlvorlvorp9UgYp9AdbbaoadfgoaYaQaQpmwDqkwDqkwDqkwDqkp9UgYp9AdbbaoadfgoaYaQaQpmxmPsxmPsxmPsxmPsp9UgYp9AdbbaoadfgoaYaLa8ApmwKDYq8AkEx3m5P8Es8FgLa3a5pmwKDYq8AkEx3m5P8Es8Fg8ApmbezHdiOAlvCXorQLgQaQpmbedibedibedibedip9UgYp9AdbbaoadfgoaYaQaQpmlvorlvorlvorlvorp9UgYp9AdbbaoadfgoaYaQaQpmwDqkwDqkwDqkwDqkp9UgYp9AdbbaoadfgoaYaQaQpmxmPsxmPsxmPsxmPsp9UgYp9AdbbaoadfgoaYaLa8ApmwDKYqk8AExm35Ps8E8FgQaQpmbedibedibedibedip9UgYp9AdbbaoadfgoaYaQaQpmlvorlvorlvorlvorp9UgYp9AdbbaoadfgoaYaQaQpmwDqkwDqkwDqkwDqkp9UgYp9AdbbaoadfgoaYaQaQpmxmPsxmPsxmPsxmPsp9UgYp9AdbbaoadfhiaXczfgXak6mbkkazclfgzad6mbkasavcjdfaqad2;8qbbavavcjdfaqcufad2fad;8qbbaqaDfhDc9:hoalmexikkc9:hoxekcbc99aral9Radcaadca0ESEhokavcj;kbf8Kjjjjbaokwbz:bjjjbk;uzeHu8Jjjjjbc;ae9Rgv8Kjjjjbc9:hodnaeci9UgrcHfal0mbcuhoaiRbbgwc;WeGc;Ge9hmbawcsGgDce0mbavc;abfcFecje;8kbavcUf9cu83ibavc8Wf9cu83ibavcyf9cu83ibavcaf9cu83ibavcKf9cu83ibavczf9cu83ibav9cu83iwav9cu83ibaialfc9WfhqaicefgwarfhodnaeTmbcmcsaDceSEhkcbhxcbhmcbhDcbhicbhlindnaoaq9nmbc9:hoxikdndnawRbbgrc;Ve0mbavc;abfalarcl4cu7fcsGcitfgPydlhsaPydbhzdnarcsGgPak9pmbavaiarcu7fcsGcdtfydbaxaPEhraPThPdndnadcd9hmbabaDcetfgHaz87ebaHcdfas87ebaHclfar87ebxekabaDcdtfgHazBdbaHclfasBdbaHcwfarBdbkaxaPfhxavc;abfalcitfgHarBdbaHasBdlavaicdtfarBdbavc;abfalcefcsGglcitfgHazBdbaHarBdlaiaPfhialcefhlxdkdndnaPcsSmbamaPfaPc987fcefhmxekaocefhrao8SbbgPcFeGhHdndnaPcu9mmbarhoxekaocvfhoaHcFbGhHcrhPdninar8SbbgOcFbGaPtaHVhHaOcu9kmearcefhraPcrfgPc8J9hmbxdkkarcefhokaHce4cbaHceG9R7amfhmkdndnadcd9hmbabaDcetfgraz87ebarcdfas87ebarclfam87ebxekabaDcdtfgrazBdbarclfasBdbarcwfamBdbkavc;abfalcitfgramBdbarasBdlavaicdtfamBdbavc;abfalcefcsGglcitfgrazBdbaramBdlaicefhialcefhlxekdnarcpe0mbaxcefgOavaiaqarcsGfRbbgPcl49RcsGcdtfydbaPcz6gHEhravaiaP9RcsGcdtfydbaOaHfgsaPcsGgOEhPaOThOdndnadcd9hmbabaDcetfgzax87ebazcdfar87ebazclfaP87ebxekabaDcdtfgzaxBdbazclfarBdbazcwfaPBdbkavaicdtfaxBdbavc;abfalcitfgzarBdbazaxBdlavaicefgicsGcdtfarBdbavc;abfalcefcsGcitfgzaPBdbazarBdlavaiaHfcsGgicdtfaPBdbavc;abfalcdfcsGglcitfgraxBdbaraPBdlalcefhlaiaOfhiasaOfhxxekaxcbaoRbbgzEgAarc;:eSgrfhsazcsGhCazcl4hXdndnazcs0mbascefhOxekashOavaiaX9RcsGcdtfydbhskdndnaCmbaOcefhxxekaOhxavaiaz9RcsGcdtfydbhOkdndnarTmbaocefhrxekaocdfhrao8SbegHcFeGhPdnaHcu9kmbaocofhAaPcFbGhPcrhodninar8SbbgHcFbGaotaPVhPaHcu9kmearcefhraocrfgoc8J9hmbkaAhrxekarcefhrkaPce4cbaPceG9R7amfgmhAkdndnaXcsSmbarhPxekarcefhPar8SbbgocFeGhHdnaocu9kmbarcvfhsaHcFbGhHcrhodninaP8SbbgrcFbGaotaHVhHarcu9kmeaPcefhPaocrfgoc8J9hmbkashPxekaPcefhPkaHce4cbaHceG9R7amfgmhskdndnaCcsSmbaPhoxekaPcefhoaP8SbbgrcFeGhHdnarcu9kmbaPcvfhOaHcFbGhHcrhrdninao8SbbgPcFbGartaHVhHaPcu9kmeaocefhoarcrfgrc8J9hmbkaOhoxekaocefhokaHce4cbaHceG9R7amfgmhOkdndnadcd9hmbabaDcetfgraA87ebarcdfas87ebarclfaO87ebxekabaDcdtfgraABdbarclfasBdbarcwfaOBdbkavc;abfalcitfgrasBdbaraABdlavaicdtfaABdbavc;abfalcefcsGcitfgraOBdbarasBdlavaicefgicsGcdtfasBdbavc;abfalcdfcsGcitfgraABdbaraOBdlavaiazcz6aXcsSVfgicsGcdtfaOBdbaiaCTaCcsSVfhialcifhlkawcefhwalcsGhlaicsGhiaDcifgDae6mbkkcbc99aoaqSEhokavc;aef8Kjjjjbaok:llevu8Jjjjjbcz9Rhvc9:hodnaecvfal0mbcuhoaiRbbc;:eGc;qe9hmbav9cb83iwaicefhraialfc98fhwdnaeTmbdnadcdSmbcbhDindnaraw6mbc9:skarcefhoar8SbbglcFeGhidndnalcu9mmbaohrxekarcvfhraicFbGhicrhldninao8SbbgdcFbGaltaiVhiadcu9kmeaocefhoalcrfglc8J9hmbxdkkaocefhrkabaDcdtfaicd4cbaice4ceG9R7avcwfaiceGcdtVgoydbfglBdbaoalBdbaDcefgDae9hmbxdkkcbhDindnaraw6mbc9:skarcefhoar8SbbglcFeGhidndnalcu9mmbaohrxekarcvfhraicFbGhicrhldninao8SbbgdcFbGaltaiVhiadcu9kmeaocefhoalcrfglc8J9hmbxdkkaocefhrkabaDcetfaicd4cbaice4ceG9R7avcwfaiceGcdtVgoydbfgl87ebaoalBdbaDcefgDae9hmbkkcbc99arawSEhokaok:EPliuo97eue978Jjjjjbca9Rhidndnadcl9hmbdnaec98GglTmbcbhvabhdinadadpbbbgocKp:RecKp:Sep;6egraocwp:RecKp:Sep;6earp;Geaoczp:RecKp:Sep;6egwp;Gep;Kep;LegDpxbbbbbbbbbbbbbbbbp:2egqarpxbbbjbbbjbbbjbbbjgkp9op9rp;Kegrpxbb;:9cbb;:9cbb;:9cbb;:9cararp;MeaDaDp;Meawaqawakp9op9rp;Kegrarp;Mep;Kep;Kep;Jep;Negwp;Mepxbbn0bbn0bbn0bbn0gqp;KepxFbbbFbbbFbbbFbbbp9oaopxbbbFbbbFbbbFbbbFp9op9qarawp;Meaqp;Kecwp:RepxbFbbbFbbbFbbbFbbp9op9qaDawp;Meaqp;Keczp:RepxbbFbbbFbbbFbbbFbp9op9qpkbbadczfhdavclfgval6mbkkalae9pmeaiaeciGgvcdtgdVcbczad9R;8kbaiabalcdtfglad;8qbbdnavTmbaiaipblbgocKp:RecKp:Sep;6egraocwp:RecKp:Sep;6earp;Geaoczp:RecKp:Sep;6egwp;Gep;Kep;LegDpxbbbbbbbbbbbbbbbbp:2egqarpxbbbjbbbjbbbjbbbjgkp9op9rp;Kegrpxbb;:9cbb;:9cbb;:9cbb;:9cararp;MeaDaDp;Meawaqawakp9op9rp;Kegrarp;Mep;Kep;Kep;Jep;Negwp;Mepxbbn0bbn0bbn0bbn0gqp;KepxFbbbFbbbFbbbFbbbp9oaopxbbbFbbbFbbbFbbbFp9op9qarawp;Meaqp;Kecwp:RepxbFbbbFbbbFbbbFbbp9op9qaDawp;Meaqp;Keczp:RepxbbFbbbFbbbFbbbFbp9op9qpklbkalaiad;8qbbskdnaec98GgxTmbcbhvabhdinadczfglalpbbbgopxbbbbbbFFbbbbbbFFgkp9oadpbbbgDaopmlvorxmPsCXQL358E8FpxFubbFubbFubbFubbp9op;6eaDaopmbediwDqkzHOAKY8AEgoczp:Sep;6egrp;Geaoczp:Reczp:Sep;6egwp;Gep;Kep;Legopxb;:FSb;:FSb;:FSb;:FSawaopxbbbbbbbbbbbbbbbbp:2egqawpxbbbjbbbjbbbjbbbjgmp9op9rp;Kegwawp;Meaoaop;Mearaqaramp9op9rp;Kegoaop;Mep;Kep;Kep;Jep;Negrp;Mepxbbn0bbn0bbn0bbn0gqp;Keczp:Reawarp;Meaqp;KepxFFbbFFbbFFbbFFbbp9op9qgwaoarp;Meaqp;KepxFFbbFFbbFFbbFFbbp9ogopmwDKYqk8AExm35Ps8E8Fp9qpkbbadaDakp9oawaopmbezHdiOAlvCXorQLp9qpkbbadcafhdavclfgvax6mbkkaxae9pmbaiaeciGgvcitgdfcbcaad9R;8kbaiabaxcitfglad;8qbbdnavTmbaiaipblzgopxbbbbbbFFbbbbbbFFgkp9oaipblbgDaopmlvorxmPsCXQL358E8FpxFubbFubbFubbFubbp9op;6eaDaopmbediwDqkzHOAKY8AEgoczp:Sep;6egrp;Geaoczp:Reczp:Sep;6egwp;Gep;Kep;Legopxb;:FSb;:FSb;:FSb;:FSawaopxbbbbbbbbbbbbbbbbp:2egqawpxbbbjbbbjbbbjbbbjgmp9op9rp;Kegwawp;Meaoaop;Mearaqaramp9op9rp;Kegoaop;Mep;Kep;Kep;Jep;Negrp;Mepxbbn0bbn0bbn0bbn0gqp;Keczp:Reawarp;Meaqp;KepxFFbbFFbbFFbbFFbbp9op9qgwaoarp;Meaqp;KepxFFbbFFbbFFbbFFbbp9ogopmwDKYqk8AExm35Ps8E8Fp9qpklzaiaDakp9oawaopmbezHdiOAlvCXorQLp9qpklbkalaiad;8qbbkk;4wllue97euv978Jjjjjbc8W9Rhidnaec98GglTmbcbhvabhoinaiaopbbbgraoczfgwpbbbgDpmlvorxmPsCXQL358E8Fgqczp:Segkclp:RepklbaopxbbjZbbjZbbjZbbjZpx;Zl81Z;Zl81Z;Zl81Z;Zl81Zakpxibbbibbbibbbibbbp9qp;6ep;NegkaraDpmbediwDqkzHOAKY8AEgrczp:Reczp:Sep;6ep;MegDaDp;Meakarczp:Sep;6ep;Megxaxp;Meakaqczp:Reczp:Sep;6ep;Megqaqp;Mep;Kep;Kep;Lepxbbbbbbbbbbbbbbbbp:4ep;Jepxb;:FSb;:FSb;:FSb;:FSgkp;Mepxbbn0bbn0bbn0bbn0grp;KepxFFbbFFbbFFbbFFbbgmp9oaxakp;Mearp;Keczp:Rep9qgxaqakp;Mearp;Keczp:ReaDakp;Mearp;Keamp9op9qgkpmbezHdiOAlvCXorQLgrp5baipblbpEb:T:j83ibaocwfarp5eaipblbpEe:T:j83ibawaxakpmwDKYqk8AExm35Ps8E8Fgkp5baipblbpEd:T:j83ibaocKfakp5eaipblbpEi:T:j83ibaocafhoavclfgval6mbkkdnalae9pmbaiaeciGgvcitgofcbcaao9R;8kbaiabalcitfgwao;8qbbdnavTmbaiaipblbgraipblzgDpmlvorxmPsCXQL358E8Fgqczp:Segkclp:RepklaaipxbbjZbbjZbbjZbbjZpx;Zl81Z;Zl81Z;Zl81Z;Zl81Zakpxibbbibbbibbbibbbp9qp;6ep;NegkaraDpmbediwDqkzHOAKY8AEgrczp:Reczp:Sep;6ep;MegDaDp;Meakarczp:Sep;6ep;Megxaxp;Meakaqczp:Reczp:Sep;6ep;Megqaqp;Mep;Kep;Kep;Lepxbbbbbbbbbbbbbbbbp:4ep;Jepxb;:FSb;:FSb;:FSb;:FSgkp;Mepxbbn0bbn0bbn0bbn0grp;KepxFFbbFFbbFFbbFFbbgmp9oaxakp;Mearp;Keczp:Rep9qgxaqakp;Mearp;Keczp:ReaDakp;Mearp;Keamp9op9qgkpmbezHdiOAlvCXorQLgrp5baipblapEb:T:j83ibaiarp5eaipblapEe:T:j83iwaiaxakpmwDKYqk8AExm35Ps8E8Fgkp5baipblapEd:T:j83izaiakp5eaipblapEi:T:j83iKkawaiao;8qbbkk:Pddiue978Jjjjjbc;ab9Rhidnadcd4ae2glc98GgvTmbcbhdabheinaeaepbbbgocwp:Recwp:Sep;6eaocep:SepxbbjZbbjZbbjZbbjZp:UepxbbjFbbjFbbjFbbjFp9op;Mepkbbaeczfheadclfgdav6mbkkdnaval9pmbaialciGgdcdtgeVcbc;abae9R;8kbaiabavcdtfgvae;8qbbdnadTmbaiaipblbgocwp:Recwp:Sep;6eaocep:SepxbbjZbbjZbbjZbbjZp:UepxbbjFbbjFbbjFbbjFp9op;Mepklbkavaiae;8qbbkk9teiucbcbydj1jjbgeabcifc98GfgbBdj1jjbdndnabZbcztgd9nmbcuhiabad9RcFFifcz4nbcuSmekaehikaikkkebcjwklz9Tbb"; + var detector = new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 3, 2, 0, 0, 5, 3, 1, 0, 1, 12, 1, 0, 10, 22, 2, 12, 0, 65, 0, 65, 0, 65, 0, 252, 10, 0, 0, 11, 7, 0, 65, 0, 253, 15, 26, 11]); + var wasmpack = new Uint8Array([32, 0, 65, 2, 1, 106, 34, 33, 3, 128, 11, 4, 13, 64, 6, 253, 10, 7, 15, 116, 127, 5, 8, 12, 40, 16, 19, 54, 20, 9, 27, 255, 113, 17, 42, 67, 24, 23, 146, 148, 18, 14, 22, 45, 70, 69, 56, 114, 101, 21, 25, 63, 75, 136, 108, 28, 118, 29, 73, 115]); + if (typeof WebAssembly !== "object") { + return { + supported: false + }; + } + var wasm = WebAssembly.validate(detector) ? wasm_simd : wasm_base; + var instance; + var ready = WebAssembly.instantiate(unpack(wasm), {}).then(function(result) { + instance = result.instance; + instance.exports.__wasm_call_ctors(); + }); + function unpack(data) { + var result = new Uint8Array(data.length); + for (var i = 0; i < data.length; ++i) { + var ch = data.charCodeAt(i); + result[i] = ch > 96 ? ch - 97 : ch > 64 ? ch - 39 : ch + 4; + } + var write = 0; + for (var i = 0; i < data.length; ++i) { + result[write++] = result[i] < 60 ? wasmpack[result[i]] : (result[i] - 60) * 64 + result[++i]; + } + return result.buffer.slice(0, write); + } + function decode(fun, target, count, size, source, filter) { + var sbrk = instance.exports.sbrk; + var count4 = count + 3 & ~3; + var tp = sbrk(count4 * size); + var sp = sbrk(source.length); + var heap = new Uint8Array(instance.exports.memory.buffer); + heap.set(source, sp); + var res = fun(tp, count, size, sp, source.length); + if (res == 0 && filter) { + filter(tp, count4, size); + } + target.set(heap.subarray(tp, tp + count * size)); + sbrk(tp - sbrk(0)); + if (res != 0) { + throw new Error("Malformed buffer data: " + res); + } + } + var filters = { + NONE: "", + OCTAHEDRAL: "meshopt_decodeFilterOct", + QUATERNION: "meshopt_decodeFilterQuat", + EXPONENTIAL: "meshopt_decodeFilterExp" + }; + var decoders = { + ATTRIBUTES: "meshopt_decodeVertexBuffer", + TRIANGLES: "meshopt_decodeIndexBuffer", + INDICES: "meshopt_decodeIndexSequence" + }; + var workers = []; + var requestId = 0; + function createWorker(url) { + var worker = { + object: new Worker(url), + pending: 0, + requests: {} + }; + worker.object.onmessage = function(event) { + var data = event.data; + worker.pending -= data.count; + worker.requests[data.id][data.action](data.value); + delete worker.requests[data.id]; + }; + return worker; + } + function initWorkers(count) { + var source = "var instance; var ready = WebAssembly.instantiate(new Uint8Array([" + new Uint8Array(unpack(wasm)) + "]), {}).then(function(result) { instance = result.instance; instance.exports.__wasm_call_ctors(); });self.onmessage = workerProcess;" + decode.toString() + workerProcess.toString(); + var blob = new Blob([source], { type: "text/javascript" }); + var url = URL.createObjectURL(blob); + for (var i = 0; i < count; ++i) { + workers[i] = createWorker(url); + } + URL.revokeObjectURL(url); + } + function decodeWorker(count, size, source, mode, filter) { + var worker = workers[0]; + for (var i = 1; i < workers.length; ++i) { + if (workers[i].pending < worker.pending) { + worker = workers[i]; + } + } + return new Promise(function(resolve, reject) { + var data = new Uint8Array(source); + var id = requestId++; + worker.pending += count; + worker.requests[id] = { resolve, reject }; + worker.object.postMessage({ id, count, size, source: data, mode, filter }, [data.buffer]); + }); + } + function workerProcess(event) { + ready.then(function() { + var data = event.data; + try { + var target = new Uint8Array(data.count * data.size); + decode(instance.exports[data.mode], target, data.count, data.size, data.source, instance.exports[data.filter]); + self.postMessage({ id: data.id, count: data.count, action: "resolve", value: target }, [target.buffer]); + } catch (error) { + self.postMessage({ id: data.id, count: data.count, action: "reject", value: error }); + } + }); + } + return { + ready, + supported: true, + useWorkers: function(count) { + initWorkers(count); + }, + decodeVertexBuffer: function(target, count, size, source, filter) { + decode(instance.exports.meshopt_decodeVertexBuffer, target, count, size, source, instance.exports[filters[filter]]); + }, + decodeIndexBuffer: function(target, count, size, source) { + decode(instance.exports.meshopt_decodeIndexBuffer, target, count, size, source); + }, + decodeIndexSequence: function(target, count, size, source) { + decode(instance.exports.meshopt_decodeIndexSequence, target, count, size, source); + }, + decodeGltfBuffer: function(target, count, size, source, mode, filter) { + decode(instance.exports[decoders[mode]], target, count, size, source, instance.exports[filters[filter]]); + }, + decodeGltfBufferAsync: function(count, size, source, mode, filter) { + if (workers.length > 0) { + return decodeWorker(count, size, source, decoders[mode], filters[filter]); + } + return ready.then(function() { + var target = new Uint8Array(count * size); + decode(instance.exports[decoders[mode]], target, count, size, source, instance.exports[filters[filter]]); + return target; + }); + } + }; +}(); + +// ../../node_modules/three/examples/jsm/libs/fflate.module.js +var u8 = Uint8Array; +var u16 = Uint16Array; +var i32 = Int32Array; +var fleb = new u8([ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 2, + 2, + 2, + 2, + 3, + 3, + 3, + 3, + 4, + 4, + 4, + 4, + 5, + 5, + 5, + 5, + 0, + /* unused */ + 0, + 0, + /* impossible */ + 0 +]); +var fdeb = new u8([ + 0, + 0, + 0, + 0, + 1, + 1, + 2, + 2, + 3, + 3, + 4, + 4, + 5, + 5, + 6, + 6, + 7, + 7, + 8, + 8, + 9, + 9, + 10, + 10, + 11, + 11, + 12, + 12, + 13, + 13, + /* unused */ + 0, + 0 +]); +var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]); +var freb = function(eb, start) { + var b = new u16(31); + for (var i = 0; i < 31; ++i) { + b[i] = start += 1 << eb[i - 1]; + } + var r = new i32(b[30]); + for (var i = 1; i < 30; ++i) { + for (var j = b[i]; j < b[i + 1]; ++j) { + r[j] = j - b[i] << 5 | i; + } + } + return { b, r }; +}; +var _a = freb(fleb, 2); +var fl = _a.b; +var revfl = _a.r; +fl[28] = 258, revfl[258] = 28; +var _b = freb(fdeb, 0); +var fd = _b.b; +var revfd = _b.r; +var rev = new u16(32768); +for (i = 0; i < 32768; ++i) { + x = (i & 43690) >> 1 | (i & 21845) << 1; + x = (x & 52428) >> 2 | (x & 13107) << 2; + x = (x & 61680) >> 4 | (x & 3855) << 4; + rev[i] = ((x & 65280) >> 8 | (x & 255) << 8) >> 1; +} +var x; +var i; +var hMap = function(cd, mb, r) { + var s = cd.length; + var i = 0; + var l = new u16(mb); + for (; i < s; ++i) { + if (cd[i]) + ++l[cd[i] - 1]; + } + var le = new u16(mb); + for (i = 1; i < mb; ++i) { + le[i] = le[i - 1] + l[i - 1] << 1; + } + var co; + if (r) { + co = new u16(1 << mb); + var rvb = 15 - mb; + for (i = 0; i < s; ++i) { + if (cd[i]) { + var sv = i << 4 | cd[i]; + var r_1 = mb - cd[i]; + var v = le[cd[i] - 1]++ << r_1; + for (var m = v | (1 << r_1) - 1; v <= m; ++v) { + co[rev[v] >> rvb] = sv; + } + } + } + } else { + co = new u16(s); + for (i = 0; i < s; ++i) { + if (cd[i]) { + co[i] = rev[le[cd[i] - 1]++] >> 15 - cd[i]; + } + } + } + return co; +}; +var flt = new u8(288); +for (i = 0; i < 144; ++i) + flt[i] = 8; +var i; +for (i = 144; i < 256; ++i) + flt[i] = 9; +var i; +for (i = 256; i < 280; ++i) + flt[i] = 7; +var i; +for (i = 280; i < 288; ++i) + flt[i] = 8; +var i; +var fdt = new u8(32); +for (i = 0; i < 32; ++i) + fdt[i] = 5; +var i; +var flrm = /* @__PURE__ */ hMap(flt, 9, 1); +var fdrm = /* @__PURE__ */ hMap(fdt, 5, 1); +var max = function(a) { + var m = a[0]; + for (var i = 1; i < a.length; ++i) { + if (a[i] > m) + m = a[i]; + } + return m; +}; +var bits = function(d, p, m) { + var o = p / 8 | 0; + return (d[o] | d[o + 1] << 8) >> (p & 7) & m; +}; +var bits16 = function(d, p) { + var o = p / 8 | 0; + return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7); +}; +var shft = function(p) { + return (p + 7) / 8 | 0; +}; +var slc = function(v, s, e) { + if (s == null || s < 0) + s = 0; + if (e == null || e > v.length) + e = v.length; + return new u8(v.subarray(s, e)); +}; +var ec = [ + "unexpected EOF", + "invalid block type", + "invalid length/literal", + "invalid distance", + "stream finished", + "no stream handler", + , + "no callback", + "invalid UTF-8 data", + "extra field too long", + "date not in range 1980-2099", + "filename too long", + "stream finishing", + "invalid zip data" + // determined by unknown compression method +]; +var err = function(ind, msg, nt) { + var e = new Error(msg || ec[ind]); + e.code = ind; + if (Error.captureStackTrace) + Error.captureStackTrace(e, err); + if (!nt) + throw e; + return e; +}; +var inflt = function(dat, st, buf, dict) { + var sl = dat.length, dl = dict ? dict.length : 0; + if (!sl || st.f && !st.l) + return buf || new u8(0); + var noBuf = !buf; + var resize = noBuf || st.i != 2; + var noSt = st.i; + if (noBuf) + buf = new u8(sl * 3); + var cbuf = function(l2) { + var bl = buf.length; + if (l2 > bl) { + var nbuf = new u8(Math.max(bl * 2, l2)); + nbuf.set(buf); + buf = nbuf; + } + }; + var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n; + var tbts = sl * 8; + do { + if (!lm) { + final = bits(dat, pos, 1); + var type = bits(dat, pos + 1, 3); + pos += 3; + if (!type) { + var s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l; + if (t > sl) { + if (noSt) + err(0); + break; + } + if (resize) + cbuf(bt + l); + buf.set(dat.subarray(s, t), bt); + st.b = bt += l, st.p = pos = t * 8, st.f = final; + continue; + } else if (type == 1) + lm = flrm, dm = fdrm, lbt = 9, dbt = 5; + else if (type == 2) { + var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4; + var tl = hLit + bits(dat, pos + 5, 31) + 1; + pos += 14; + var ldt = new u8(tl); + var clt = new u8(19); + for (var i = 0; i < hcLen; ++i) { + clt[clim[i]] = bits(dat, pos + i * 3, 7); + } + pos += hcLen * 3; + var clb = max(clt), clbmsk = (1 << clb) - 1; + var clm = hMap(clt, clb, 1); + for (var i = 0; i < tl; ) { + var r = clm[bits(dat, pos, clbmsk)]; + pos += r & 15; + var s = r >> 4; + if (s < 16) { + ldt[i++] = s; + } else { + var c = 0, n = 0; + if (s == 16) + n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1]; + else if (s == 17) + n = 3 + bits(dat, pos, 7), pos += 3; + else if (s == 18) + n = 11 + bits(dat, pos, 127), pos += 7; + while (n--) + ldt[i++] = c; + } + } + var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit); + lbt = max(lt); + dbt = max(dt); + lm = hMap(lt, lbt, 1); + dm = hMap(dt, dbt, 1); + } else + err(1); + if (pos > tbts) { + if (noSt) + err(0); + break; + } + } + if (resize) + cbuf(bt + 131072); + var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1; + var lpos = pos; + for (; ; lpos = pos) { + var c = lm[bits16(dat, pos) & lms], sym = c >> 4; + pos += c & 15; + if (pos > tbts) { + if (noSt) + err(0); + break; + } + if (!c) + err(2); + if (sym < 256) + buf[bt++] = sym; + else if (sym == 256) { + lpos = pos, lm = null; + break; + } else { + var add = sym - 254; + if (sym > 264) { + var i = sym - 257, b = fleb[i]; + add = bits(dat, pos, (1 << b) - 1) + fl[i]; + pos += b; + } + var d = dm[bits16(dat, pos) & dms], dsym = d >> 4; + if (!d) + err(3); + pos += d & 15; + var dt = fd[dsym]; + if (dsym > 3) { + var b = fdeb[dsym]; + dt += bits16(dat, pos) & (1 << b) - 1, pos += b; + } + if (pos > tbts) { + if (noSt) + err(0); + break; + } + if (resize) + cbuf(bt + 131072); + var end = bt + add; + if (bt < dt) { + var shift = dl - dt, dend = Math.min(dt, end); + if (shift + bt < 0) + err(3); + for (; bt < dend; ++bt) + buf[bt] = dict[shift + bt]; + } + for (; bt < end; ++bt) + buf[bt] = buf[bt - dt]; + } + } + st.l = lm, st.p = lpos, st.b = bt, st.f = final; + if (lm) + final = 1, st.m = lbt, st.d = dm, st.n = dbt; + } while (!final); + return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt); +}; +var et = /* @__PURE__ */ new u8(0); +var zls = function(d, dict) { + if ((d[0] & 15) != 8 || d[0] >> 4 > 7 || (d[0] << 8 | d[1]) % 31) + err(6, "invalid zlib data"); + if ((d[1] >> 5 & 1) == +!dict) + err(6, "invalid zlib data: " + (d[1] & 32 ? "need" : "unexpected") + " dictionary"); + return (d[1] >> 3 & 4) + 2; +}; +function unzlibSync(data, opts) { + return inflt(data.subarray(zls(data, opts && opts.dictionary), -4), { i: 2 }, opts && opts.out, opts && opts.dictionary); +} +var td = typeof TextDecoder != "undefined" && /* @__PURE__ */ new TextDecoder(); +var tds = 0; +try { + td.decode(et, { stream: true }); + tds = 1; +} catch (e) { +} + +// ../../node_modules/three/examples/jsm/curves/NURBSUtils.js +function findSpan(p, u, U) { + const n = U.length - p - 1; + if (u >= U[n]) { + return n - 1; + } + if (u <= U[p]) { + return p; + } + let low = p; + let high = n; + let mid = Math.floor((low + high) / 2); + while (u < U[mid] || u >= U[mid + 1]) { + if (u < U[mid]) { + high = mid; + } else { + low = mid; + } + mid = Math.floor((low + high) / 2); + } + return mid; +} +function calcBasisFunctions(span, u, p, U) { + const N = []; + const left = []; + const right2 = []; + N[0] = 1; + for (let j = 1; j <= p; ++j) { + left[j] = u - U[span + 1 - j]; + right2[j] = U[span + j] - u; + let saved = 0; + for (let r = 0; r < j; ++r) { + const rv = right2[r + 1]; + const lv = left[j - r]; + const temp = N[r] / (rv + lv); + N[r] = saved + rv * temp; + saved = lv * temp; + } + N[j] = saved; + } + return N; +} +function calcBSplinePoint(p, U, P, u) { + const span = findSpan(p, u, U); + const N = calcBasisFunctions(span, u, p, U); + const C = new Vector4(0, 0, 0, 0); + for (let j = 0; j <= p; ++j) { + const point = P[span - p + j]; + const Nj = N[j]; + const wNj = point.w * Nj; + C.x += point.x * wNj; + C.y += point.y * wNj; + C.z += point.z * wNj; + C.w += point.w * Nj; + } + return C; +} +function calcBasisFunctionDerivatives(span, u, p, n, U) { + const zeroArr = []; + for (let i = 0; i <= p; ++i) + zeroArr[i] = 0; + const ders = []; + for (let i = 0; i <= n; ++i) + ders[i] = zeroArr.slice(0); + const ndu = []; + for (let i = 0; i <= p; ++i) + ndu[i] = zeroArr.slice(0); + ndu[0][0] = 1; + const left = zeroArr.slice(0); + const right2 = zeroArr.slice(0); + for (let j = 1; j <= p; ++j) { + left[j] = u - U[span + 1 - j]; + right2[j] = U[span + j] - u; + let saved = 0; + for (let r2 = 0; r2 < j; ++r2) { + const rv = right2[r2 + 1]; + const lv = left[j - r2]; + ndu[j][r2] = rv + lv; + const temp = ndu[r2][j - 1] / ndu[j][r2]; + ndu[r2][j] = saved + rv * temp; + saved = lv * temp; + } + ndu[j][j] = saved; + } + for (let j = 0; j <= p; ++j) { + ders[0][j] = ndu[j][p]; + } + for (let r2 = 0; r2 <= p; ++r2) { + let s1 = 0; + let s2 = 1; + const a = []; + for (let i = 0; i <= p; ++i) { + a[i] = zeroArr.slice(0); + } + a[0][0] = 1; + for (let k = 1; k <= n; ++k) { + let d = 0; + const rk = r2 - k; + const pk = p - k; + if (r2 >= k) { + a[s2][0] = a[s1][0] / ndu[pk + 1][rk]; + d = a[s2][0] * ndu[rk][pk]; + } + const j1 = rk >= -1 ? 1 : -rk; + const j2 = r2 - 1 <= pk ? k - 1 : p - r2; + for (let j3 = j1; j3 <= j2; ++j3) { + a[s2][j3] = (a[s1][j3] - a[s1][j3 - 1]) / ndu[pk + 1][rk + j3]; + d += a[s2][j3] * ndu[rk + j3][pk]; + } + if (r2 <= pk) { + a[s2][k] = -a[s1][k - 1] / ndu[pk + 1][r2]; + d += a[s2][k] * ndu[r2][pk]; + } + ders[k][r2] = d; + const j = s1; + s1 = s2; + s2 = j; + } + } + let r = p; + for (let k = 1; k <= n; ++k) { + for (let j = 0; j <= p; ++j) { + ders[k][j] *= r; + } + r *= p - k; + } + return ders; +} +function calcBSplineDerivatives(p, U, P, u, nd) { + const du = nd < p ? nd : p; + const CK = []; + const span = findSpan(p, u, U); + const nders = calcBasisFunctionDerivatives(span, u, p, du, U); + const Pw = []; + for (let i = 0; i < P.length; ++i) { + const point = P[i].clone(); + const w = point.w; + point.x *= w; + point.y *= w; + point.z *= w; + Pw[i] = point; + } + for (let k = 0; k <= du; ++k) { + const point = Pw[span - p].clone().multiplyScalar(nders[k][0]); + for (let j = 1; j <= p; ++j) { + point.add(Pw[span - p + j].clone().multiplyScalar(nders[k][j])); + } + CK[k] = point; + } + for (let k = du + 1; k <= nd + 1; ++k) { + CK[k] = new Vector4(0, 0, 0); + } + return CK; +} +function calcKoverI(k, i) { + let nom = 1; + for (let j = 2; j <= k; ++j) { + nom *= j; + } + let denom = 1; + for (let j = 2; j <= i; ++j) { + denom *= j; + } + for (let j = 2; j <= k - i; ++j) { + denom *= j; + } + return nom / denom; +} +function calcRationalCurveDerivatives(Pders) { + const nd = Pders.length; + const Aders = []; + const wders = []; + for (let i = 0; i < nd; ++i) { + const point = Pders[i]; + Aders[i] = new Vector3(point.x, point.y, point.z); + wders[i] = point.w; + } + const CK = []; + for (let k = 0; k < nd; ++k) { + const v = Aders[k].clone(); + for (let i = 1; i <= k; ++i) { + v.sub(CK[k - i].clone().multiplyScalar(calcKoverI(k, i) * wders[i])); + } + CK[k] = v.divideScalar(wders[0]); + } + return CK; +} +function calcNURBSDerivatives(p, U, P, u, nd) { + const Pders = calcBSplineDerivatives(p, U, P, u, nd); + return calcRationalCurveDerivatives(Pders); +} + +// ../../node_modules/three/examples/jsm/curves/NURBSCurve.js +var NURBSCurve = class extends Curve { + constructor(degree, knots, controlPoints, startKnot, endKnot) { + super(); + this.degree = degree; + this.knots = knots; + this.controlPoints = []; + this.startKnot = startKnot || 0; + this.endKnot = endKnot || this.knots.length - 1; + for (let i = 0; i < controlPoints.length; ++i) { + const point = controlPoints[i]; + this.controlPoints[i] = new Vector4(point.x, point.y, point.z, point.w); + } + } + getPoint(t, optionalTarget = new Vector3()) { + const point = optionalTarget; + const u = this.knots[this.startKnot] + t * (this.knots[this.endKnot] - this.knots[this.startKnot]); + const hpoint = calcBSplinePoint(this.degree, this.knots, this.controlPoints, u); + if (hpoint.w !== 1) { + hpoint.divideScalar(hpoint.w); + } + return point.set(hpoint.x, hpoint.y, hpoint.z); + } + getTangent(t, optionalTarget = new Vector3()) { + const tangent = optionalTarget; + const u = this.knots[0] + t * (this.knots[this.knots.length - 1] - this.knots[0]); + const ders = calcNURBSDerivatives(this.degree, this.knots, this.controlPoints, u, 1); + tangent.copy(ders[1]).normalize(); + return tangent; + } +}; + +// ../../node_modules/three/examples/jsm/loaders/FBXLoader.js +var fbxTree; +var connections; +var sceneGraph; +var FBXLoader = class extends Loader { + constructor(manager) { + super(manager); + } + load(url, onLoad, onProgress, onError) { + const scope = this; + const path = scope.path === "" ? LoaderUtils.extractUrlBase(url) : scope.path; + const loader = new FileLoader(this.manager); + loader.setPath(scope.path); + loader.setResponseType("arraybuffer"); + loader.setRequestHeader(scope.requestHeader); + loader.setWithCredentials(scope.withCredentials); + loader.load(url, function(buffer) { + try { + onLoad(scope.parse(buffer, path)); + } catch (e) { + if (onError) { + onError(e); + } else { + console.error(e); + } + scope.manager.itemError(url); + } + }, onProgress, onError); + } + parse(FBXBuffer, path) { + if (isFbxFormatBinary(FBXBuffer)) { + fbxTree = new BinaryParser().parse(FBXBuffer); + } else { + const FBXText = convertArrayBufferToString(FBXBuffer); + if (!isFbxFormatASCII(FBXText)) { + throw new Error("THREE.FBXLoader: Unknown format."); + } + if (getFbxVersion(FBXText) < 7e3) { + throw new Error("THREE.FBXLoader: FBX version not supported, FileVersion: " + getFbxVersion(FBXText)); + } + fbxTree = new TextParser().parse(FBXText); + } + const textureLoader = new TextureLoader(this.manager).setPath(this.resourcePath || path).setCrossOrigin(this.crossOrigin); + return new FBXTreeParser(textureLoader, this.manager).parse(fbxTree); + } +}; +var FBXTreeParser = class { + constructor(textureLoader, manager) { + this.textureLoader = textureLoader; + this.manager = manager; + } + parse() { + connections = this.parseConnections(); + const images = this.parseImages(); + const textures = this.parseTextures(images); + const materials = this.parseMaterials(textures); + const deformers = this.parseDeformers(); + const geometryMap = new GeometryParser().parse(deformers); + this.parseScene(deformers, geometryMap, materials); + return sceneGraph; + } + // Parses FBXTree.Connections which holds parent-child connections between objects (e.g. material -> texture, model->geometry ) + // and details the connection type + parseConnections() { + const connectionMap = /* @__PURE__ */ new Map(); + if ("Connections" in fbxTree) { + const rawConnections = fbxTree.Connections.connections; + rawConnections.forEach(function(rawConnection) { + const fromID = rawConnection[0]; + const toID = rawConnection[1]; + const relationship = rawConnection[2]; + if (!connectionMap.has(fromID)) { + connectionMap.set(fromID, { + parents: [], + children: [] + }); + } + const parentRelationship = { ID: toID, relationship }; + connectionMap.get(fromID).parents.push(parentRelationship); + if (!connectionMap.has(toID)) { + connectionMap.set(toID, { + parents: [], + children: [] + }); + } + const childRelationship = { ID: fromID, relationship }; + connectionMap.get(toID).children.push(childRelationship); + }); + } + return connectionMap; + } + // Parse FBXTree.Objects.Video for embedded image data + // These images are connected to textures in FBXTree.Objects.Textures + // via FBXTree.Connections. + parseImages() { + const images = {}; + const blobs = {}; + if ("Video" in fbxTree.Objects) { + const videoNodes = fbxTree.Objects.Video; + for (const nodeID in videoNodes) { + const videoNode = videoNodes[nodeID]; + const id = parseInt(nodeID); + images[id] = videoNode.RelativeFilename || videoNode.Filename; + if ("Content" in videoNode) { + const arrayBufferContent = videoNode.Content instanceof ArrayBuffer && videoNode.Content.byteLength > 0; + const base64Content = typeof videoNode.Content === "string" && videoNode.Content !== ""; + if (arrayBufferContent || base64Content) { + const image = this.parseImage(videoNodes[nodeID]); + blobs[videoNode.RelativeFilename || videoNode.Filename] = image; + } + } + } + } + for (const id in images) { + const filename = images[id]; + if (blobs[filename] !== void 0) images[id] = blobs[filename]; + else images[id] = images[id].split("\\").pop(); + } + return images; + } + // Parse embedded image data in FBXTree.Video.Content + parseImage(videoNode) { + const content = videoNode.Content; + const fileName = videoNode.RelativeFilename || videoNode.Filename; + const extension = fileName.slice(fileName.lastIndexOf(".") + 1).toLowerCase(); + let type; + switch (extension) { + case "bmp": + type = "image/bmp"; + break; + case "jpg": + case "jpeg": + type = "image/jpeg"; + break; + case "png": + type = "image/png"; + break; + case "tif": + type = "image/tiff"; + break; + case "tga": + if (this.manager.getHandler(".tga") === null) { + console.warn("FBXLoader: TGA loader not found, skipping ", fileName); + } + type = "image/tga"; + break; + default: + console.warn('FBXLoader: Image type "' + extension + '" is not supported.'); + return; + } + if (typeof content === "string") { + return "data:" + type + ";base64," + content; + } else { + const array = new Uint8Array(content); + return window.URL.createObjectURL(new Blob([array], { type })); + } + } + // Parse nodes in FBXTree.Objects.Texture + // These contain details such as UV scaling, cropping, rotation etc and are connected + // to images in FBXTree.Objects.Video + parseTextures(images) { + const textureMap = /* @__PURE__ */ new Map(); + if ("Texture" in fbxTree.Objects) { + const textureNodes = fbxTree.Objects.Texture; + for (const nodeID in textureNodes) { + const texture = this.parseTexture(textureNodes[nodeID], images); + textureMap.set(parseInt(nodeID), texture); + } + } + return textureMap; + } + // Parse individual node in FBXTree.Objects.Texture + parseTexture(textureNode, images) { + const texture = this.loadTexture(textureNode, images); + texture.ID = textureNode.id; + texture.name = textureNode.attrName; + const wrapModeU = textureNode.WrapModeU; + const wrapModeV = textureNode.WrapModeV; + const valueU = wrapModeU !== void 0 ? wrapModeU.value : 0; + const valueV = wrapModeV !== void 0 ? wrapModeV.value : 0; + texture.wrapS = valueU === 0 ? RepeatWrapping : ClampToEdgeWrapping; + texture.wrapT = valueV === 0 ? RepeatWrapping : ClampToEdgeWrapping; + if ("Scaling" in textureNode) { + const values = textureNode.Scaling.value; + texture.repeat.x = values[0]; + texture.repeat.y = values[1]; + } + if ("Translation" in textureNode) { + const values = textureNode.Translation.value; + texture.offset.x = values[0]; + texture.offset.y = values[1]; + } + return texture; + } + // load a texture specified as a blob or data URI, or via an external URL using TextureLoader + loadTexture(textureNode, images) { + let fileName; + const currentPath = this.textureLoader.path; + const children = connections.get(textureNode.id).children; + if (children !== void 0 && children.length > 0 && images[children[0].ID] !== void 0) { + fileName = images[children[0].ID]; + if (fileName.indexOf("blob:") === 0 || fileName.indexOf("data:") === 0) { + this.textureLoader.setPath(void 0); + } + } + let texture; + const extension = textureNode.FileName.slice(-3).toLowerCase(); + if (extension === "tga") { + const loader = this.manager.getHandler(".tga"); + if (loader === null) { + console.warn("FBXLoader: TGA loader not found, creating placeholder texture for", textureNode.RelativeFilename); + texture = new Texture(); + } else { + loader.setPath(this.textureLoader.path); + texture = loader.load(fileName); + } + } else if (extension === "dds") { + const loader = this.manager.getHandler(".dds"); + if (loader === null) { + console.warn("FBXLoader: DDS loader not found, creating placeholder texture for", textureNode.RelativeFilename); + texture = new Texture(); + } else { + loader.setPath(this.textureLoader.path); + texture = loader.load(fileName); + } + } else if (extension === "psd") { + console.warn("FBXLoader: PSD textures are not supported, creating placeholder texture for", textureNode.RelativeFilename); + texture = new Texture(); + } else { + texture = this.textureLoader.load(fileName); + } + this.textureLoader.setPath(currentPath); + return texture; + } + // Parse nodes in FBXTree.Objects.Material + parseMaterials(textureMap) { + const materialMap = /* @__PURE__ */ new Map(); + if ("Material" in fbxTree.Objects) { + const materialNodes = fbxTree.Objects.Material; + for (const nodeID in materialNodes) { + const material = this.parseMaterial(materialNodes[nodeID], textureMap); + if (material !== null) materialMap.set(parseInt(nodeID), material); + } + } + return materialMap; + } + // Parse single node in FBXTree.Objects.Material + // Materials are connected to texture maps in FBXTree.Objects.Textures + // FBX format currently only supports Lambert and Phong shading models + parseMaterial(materialNode, textureMap) { + const ID = materialNode.id; + const name = materialNode.attrName; + let type = materialNode.ShadingModel; + if (typeof type === "object") { + type = type.value; + } + if (!connections.has(ID)) return null; + const parameters = this.parseParameters(materialNode, textureMap, ID); + let material; + switch (type.toLowerCase()) { + case "phong": + material = new MeshPhongMaterial(); + break; + case "lambert": + material = new MeshLambertMaterial(); + break; + default: + console.warn('THREE.FBXLoader: unknown material type "%s". Defaulting to MeshPhongMaterial.', type); + material = new MeshPhongMaterial(); + break; + } + material.setValues(parameters); + material.name = name; + return material; + } + // Parse FBX material and return parameters suitable for a three.js material + // Also parse the texture map and return any textures associated with the material + parseParameters(materialNode, textureMap, ID) { + const parameters = {}; + if (materialNode.BumpFactor) { + parameters.bumpScale = materialNode.BumpFactor.value; + } + if (materialNode.Diffuse) { + parameters.color = new Color().fromArray(materialNode.Diffuse.value).convertSRGBToLinear(); + } else if (materialNode.DiffuseColor && (materialNode.DiffuseColor.type === "Color" || materialNode.DiffuseColor.type === "ColorRGB")) { + parameters.color = new Color().fromArray(materialNode.DiffuseColor.value).convertSRGBToLinear(); + } + if (materialNode.DisplacementFactor) { + parameters.displacementScale = materialNode.DisplacementFactor.value; + } + if (materialNode.Emissive) { + parameters.emissive = new Color().fromArray(materialNode.Emissive.value).convertSRGBToLinear(); + } else if (materialNode.EmissiveColor && (materialNode.EmissiveColor.type === "Color" || materialNode.EmissiveColor.type === "ColorRGB")) { + parameters.emissive = new Color().fromArray(materialNode.EmissiveColor.value).convertSRGBToLinear(); + } + if (materialNode.EmissiveFactor) { + parameters.emissiveIntensity = parseFloat(materialNode.EmissiveFactor.value); + } + if (materialNode.Opacity) { + parameters.opacity = parseFloat(materialNode.Opacity.value); + } + if (parameters.opacity < 1) { + parameters.transparent = true; + } + if (materialNode.ReflectionFactor) { + parameters.reflectivity = materialNode.ReflectionFactor.value; + } + if (materialNode.Shininess) { + parameters.shininess = materialNode.Shininess.value; + } + if (materialNode.Specular) { + parameters.specular = new Color().fromArray(materialNode.Specular.value).convertSRGBToLinear(); + } else if (materialNode.SpecularColor && materialNode.SpecularColor.type === "Color") { + parameters.specular = new Color().fromArray(materialNode.SpecularColor.value).convertSRGBToLinear(); + } + const scope = this; + connections.get(ID).children.forEach(function(child) { + const type = child.relationship; + switch (type) { + case "Bump": + parameters.bumpMap = scope.getTexture(textureMap, child.ID); + break; + case "Maya|TEX_ao_map": + parameters.aoMap = scope.getTexture(textureMap, child.ID); + break; + case "DiffuseColor": + case "Maya|TEX_color_map": + parameters.map = scope.getTexture(textureMap, child.ID); + if (parameters.map !== void 0) { + parameters.map.colorSpace = SRGBColorSpace; + } + break; + case "DisplacementColor": + parameters.displacementMap = scope.getTexture(textureMap, child.ID); + break; + case "EmissiveColor": + parameters.emissiveMap = scope.getTexture(textureMap, child.ID); + if (parameters.emissiveMap !== void 0) { + parameters.emissiveMap.colorSpace = SRGBColorSpace; + } + break; + case "NormalMap": + case "Maya|TEX_normal_map": + parameters.normalMap = scope.getTexture(textureMap, child.ID); + break; + case "ReflectionColor": + parameters.envMap = scope.getTexture(textureMap, child.ID); + if (parameters.envMap !== void 0) { + parameters.envMap.mapping = EquirectangularReflectionMapping; + parameters.envMap.colorSpace = SRGBColorSpace; + } + break; + case "SpecularColor": + parameters.specularMap = scope.getTexture(textureMap, child.ID); + if (parameters.specularMap !== void 0) { + parameters.specularMap.colorSpace = SRGBColorSpace; + } + break; + case "TransparentColor": + case "TransparencyFactor": + parameters.alphaMap = scope.getTexture(textureMap, child.ID); + parameters.transparent = true; + break; + case "AmbientColor": + case "ShininessExponent": + // AKA glossiness map + case "SpecularFactor": + // AKA specularLevel + case "VectorDisplacementColor": + // NOTE: Seems to be a copy of DisplacementColor + default: + console.warn("THREE.FBXLoader: %s map is not supported in three.js, skipping texture.", type); + break; + } + }); + return parameters; + } + // get a texture from the textureMap for use by a material. + getTexture(textureMap, id) { + if ("LayeredTexture" in fbxTree.Objects && id in fbxTree.Objects.LayeredTexture) { + console.warn("THREE.FBXLoader: layered textures are not supported in three.js. Discarding all but first layer."); + id = connections.get(id).children[0].ID; + } + return textureMap.get(id); + } + // Parse nodes in FBXTree.Objects.Deformer + // Deformer node can contain skinning or Vertex Cache animation data, however only skinning is supported here + // Generates map of Skeleton-like objects for use later when generating and binding skeletons. + parseDeformers() { + const skeletons = {}; + const morphTargets = {}; + if ("Deformer" in fbxTree.Objects) { + const DeformerNodes = fbxTree.Objects.Deformer; + for (const nodeID in DeformerNodes) { + const deformerNode = DeformerNodes[nodeID]; + const relationships = connections.get(parseInt(nodeID)); + if (deformerNode.attrType === "Skin") { + const skeleton = this.parseSkeleton(relationships, DeformerNodes); + skeleton.ID = nodeID; + if (relationships.parents.length > 1) console.warn("THREE.FBXLoader: skeleton attached to more than one geometry is not supported."); + skeleton.geometryID = relationships.parents[0].ID; + skeletons[nodeID] = skeleton; + } else if (deformerNode.attrType === "BlendShape") { + const morphTarget = { + id: nodeID + }; + morphTarget.rawTargets = this.parseMorphTargets(relationships, DeformerNodes); + morphTarget.id = nodeID; + if (relationships.parents.length > 1) console.warn("THREE.FBXLoader: morph target attached to more than one geometry is not supported."); + morphTargets[nodeID] = morphTarget; + } + } + } + return { + skeletons, + morphTargets + }; + } + // Parse single nodes in FBXTree.Objects.Deformer + // The top level skeleton node has type 'Skin' and sub nodes have type 'Cluster' + // Each skin node represents a skeleton and each cluster node represents a bone + parseSkeleton(relationships, deformerNodes) { + const rawBones = []; + relationships.children.forEach(function(child) { + const boneNode = deformerNodes[child.ID]; + if (boneNode.attrType !== "Cluster") return; + const rawBone = { + ID: child.ID, + indices: [], + weights: [], + transformLink: new Matrix4().fromArray(boneNode.TransformLink.a) + // transform: new Matrix4().fromArray( boneNode.Transform.a ), + // linkMode: boneNode.Mode, + }; + if ("Indexes" in boneNode) { + rawBone.indices = boneNode.Indexes.a; + rawBone.weights = boneNode.Weights.a; + } + rawBones.push(rawBone); + }); + return { + rawBones, + bones: [] + }; + } + // The top level morph deformer node has type "BlendShape" and sub nodes have type "BlendShapeChannel" + parseMorphTargets(relationships, deformerNodes) { + const rawMorphTargets = []; + for (let i = 0; i < relationships.children.length; i++) { + const child = relationships.children[i]; + const morphTargetNode = deformerNodes[child.ID]; + const rawMorphTarget = { + name: morphTargetNode.attrName, + initialWeight: morphTargetNode.DeformPercent, + id: morphTargetNode.id, + fullWeights: morphTargetNode.FullWeights.a + }; + if (morphTargetNode.attrType !== "BlendShapeChannel") return; + rawMorphTarget.geoID = connections.get(parseInt(child.ID)).children.filter(function(child2) { + return child2.relationship === void 0; + })[0].ID; + rawMorphTargets.push(rawMorphTarget); + } + return rawMorphTargets; + } + // create the main Group() to be returned by the loader + parseScene(deformers, geometryMap, materialMap) { + sceneGraph = new Group(); + const modelMap = this.parseModels(deformers.skeletons, geometryMap, materialMap); + const modelNodes = fbxTree.Objects.Model; + const scope = this; + modelMap.forEach(function(model) { + const modelNode = modelNodes[model.ID]; + scope.setLookAtProperties(model, modelNode); + const parentConnections = connections.get(model.ID).parents; + parentConnections.forEach(function(connection) { + const parent = modelMap.get(connection.ID); + if (parent !== void 0) parent.add(model); + }); + if (model.parent === null) { + sceneGraph.add(model); + } + }); + this.bindSkeleton(deformers.skeletons, geometryMap, modelMap); + this.addGlobalSceneSettings(); + sceneGraph.traverse(function(node) { + if (node.userData.transformData) { + if (node.parent) { + node.userData.transformData.parentMatrix = node.parent.matrix; + node.userData.transformData.parentMatrixWorld = node.parent.matrixWorld; + } + const transform = generateTransform(node.userData.transformData); + node.applyMatrix4(transform); + node.updateWorldMatrix(); + } + }); + const animations = new AnimationParser().parse(); + if (sceneGraph.children.length === 1 && sceneGraph.children[0].isGroup) { + sceneGraph.children[0].animations = animations; + sceneGraph = sceneGraph.children[0]; + } + sceneGraph.animations = animations; + } + // parse nodes in FBXTree.Objects.Model + parseModels(skeletons, geometryMap, materialMap) { + const modelMap = /* @__PURE__ */ new Map(); + const modelNodes = fbxTree.Objects.Model; + for (const nodeID in modelNodes) { + const id = parseInt(nodeID); + const node = modelNodes[nodeID]; + const relationships = connections.get(id); + let model = this.buildSkeleton(relationships, skeletons, id, node.attrName); + if (!model) { + switch (node.attrType) { + case "Camera": + model = this.createCamera(relationships); + break; + case "Light": + model = this.createLight(relationships); + break; + case "Mesh": + model = this.createMesh(relationships, geometryMap, materialMap); + break; + case "NurbsCurve": + model = this.createCurve(relationships, geometryMap); + break; + case "LimbNode": + case "Root": + model = new Bone(); + break; + case "Null": + default: + model = new Group(); + break; + } + model.name = node.attrName ? PropertyBinding.sanitizeNodeName(node.attrName) : ""; + model.userData.originalName = node.attrName; + model.ID = id; + } + this.getTransformData(model, node); + modelMap.set(id, model); + } + return modelMap; + } + buildSkeleton(relationships, skeletons, id, name) { + let bone = null; + relationships.parents.forEach(function(parent) { + for (const ID in skeletons) { + const skeleton = skeletons[ID]; + skeleton.rawBones.forEach(function(rawBone, i) { + if (rawBone.ID === parent.ID) { + const subBone = bone; + bone = new Bone(); + bone.matrixWorld.copy(rawBone.transformLink); + bone.name = name ? PropertyBinding.sanitizeNodeName(name) : ""; + bone.userData.originalName = name; + bone.ID = id; + skeleton.bones[i] = bone; + if (subBone !== null) { + bone.add(subBone); + } + } + }); + } + }); + return bone; + } + // create a PerspectiveCamera or OrthographicCamera + createCamera(relationships) { + let model; + let cameraAttribute; + relationships.children.forEach(function(child) { + const attr = fbxTree.Objects.NodeAttribute[child.ID]; + if (attr !== void 0) { + cameraAttribute = attr; + } + }); + if (cameraAttribute === void 0) { + model = new Object3D(); + } else { + let type = 0; + if (cameraAttribute.CameraProjectionType !== void 0 && cameraAttribute.CameraProjectionType.value === 1) { + type = 1; + } + let nearClippingPlane = 1; + if (cameraAttribute.NearPlane !== void 0) { + nearClippingPlane = cameraAttribute.NearPlane.value / 1e3; + } + let farClippingPlane = 1e3; + if (cameraAttribute.FarPlane !== void 0) { + farClippingPlane = cameraAttribute.FarPlane.value / 1e3; + } + let width = window.innerWidth; + let height = window.innerHeight; + if (cameraAttribute.AspectWidth !== void 0 && cameraAttribute.AspectHeight !== void 0) { + width = cameraAttribute.AspectWidth.value; + height = cameraAttribute.AspectHeight.value; + } + const aspect2 = width / height; + let fov2 = 45; + if (cameraAttribute.FieldOfView !== void 0) { + fov2 = cameraAttribute.FieldOfView.value; + } + const focalLength = cameraAttribute.FocalLength ? cameraAttribute.FocalLength.value : null; + switch (type) { + case 0: + model = new PerspectiveCamera(fov2, aspect2, nearClippingPlane, farClippingPlane); + if (focalLength !== null) model.setFocalLength(focalLength); + break; + case 1: + model = new OrthographicCamera(-width / 2, width / 2, height / 2, -height / 2, nearClippingPlane, farClippingPlane); + break; + default: + console.warn("THREE.FBXLoader: Unknown camera type " + type + "."); + model = new Object3D(); + break; + } + } + return model; + } + // Create a DirectionalLight, PointLight or SpotLight + createLight(relationships) { + let model; + let lightAttribute; + relationships.children.forEach(function(child) { + const attr = fbxTree.Objects.NodeAttribute[child.ID]; + if (attr !== void 0) { + lightAttribute = attr; + } + }); + if (lightAttribute === void 0) { + model = new Object3D(); + } else { + let type; + if (lightAttribute.LightType === void 0) { + type = 0; + } else { + type = lightAttribute.LightType.value; + } + let color = 16777215; + if (lightAttribute.Color !== void 0) { + color = new Color().fromArray(lightAttribute.Color.value).convertSRGBToLinear(); + } + let intensity = lightAttribute.Intensity === void 0 ? 1 : lightAttribute.Intensity.value / 100; + if (lightAttribute.CastLightOnObject !== void 0 && lightAttribute.CastLightOnObject.value === 0) { + intensity = 0; + } + let distance = 0; + if (lightAttribute.FarAttenuationEnd !== void 0) { + if (lightAttribute.EnableFarAttenuation !== void 0 && lightAttribute.EnableFarAttenuation.value === 0) { + distance = 0; + } else { + distance = lightAttribute.FarAttenuationEnd.value; + } + } + const decay = 1; + switch (type) { + case 0: + model = new PointLight(color, intensity, distance, decay); + break; + case 1: + model = new DirectionalLight(color, intensity); + break; + case 2: + let angle = Math.PI / 3; + if (lightAttribute.InnerAngle !== void 0) { + angle = MathUtils.degToRad(lightAttribute.InnerAngle.value); + } + let penumbra = 0; + if (lightAttribute.OuterAngle !== void 0) { + penumbra = MathUtils.degToRad(lightAttribute.OuterAngle.value); + penumbra = Math.max(penumbra, 1); + } + model = new SpotLight(color, intensity, distance, angle, penumbra, decay); + break; + default: + console.warn("THREE.FBXLoader: Unknown light type " + lightAttribute.LightType.value + ", defaulting to a PointLight."); + model = new PointLight(color, intensity); + break; + } + if (lightAttribute.CastShadows !== void 0 && lightAttribute.CastShadows.value === 1) { + model.castShadow = true; + } + } + return model; + } + createMesh(relationships, geometryMap, materialMap) { + let model; + let geometry = null; + let material = null; + const materials = []; + relationships.children.forEach(function(child) { + if (geometryMap.has(child.ID)) { + geometry = geometryMap.get(child.ID); + } + if (materialMap.has(child.ID)) { + materials.push(materialMap.get(child.ID)); + } + }); + if (materials.length > 1) { + material = materials; + } else if (materials.length > 0) { + material = materials[0]; + } else { + material = new MeshPhongMaterial({ + name: Loader.DEFAULT_MATERIAL_NAME, + color: 13421772 + }); + materials.push(material); + } + if ("color" in geometry.attributes) { + materials.forEach(function(material2) { + material2.vertexColors = true; + }); + } + if (geometry.FBX_Deformer) { + model = new SkinnedMesh(geometry, material); + model.normalizeSkinWeights(); + } else { + model = new Mesh(geometry, material); + } + return model; + } + createCurve(relationships, geometryMap) { + const geometry = relationships.children.reduce(function(geo, child) { + if (geometryMap.has(child.ID)) geo = geometryMap.get(child.ID); + return geo; + }, null); + const material = new LineBasicMaterial({ + name: Loader.DEFAULT_MATERIAL_NAME, + color: 3342591, + linewidth: 1 + }); + return new Line(geometry, material); + } + // parse the model node for transform data + getTransformData(model, modelNode) { + const transformData = {}; + if ("InheritType" in modelNode) transformData.inheritType = parseInt(modelNode.InheritType.value); + if ("RotationOrder" in modelNode) transformData.eulerOrder = getEulerOrder(modelNode.RotationOrder.value); + else transformData.eulerOrder = "ZYX"; + if ("Lcl_Translation" in modelNode) transformData.translation = modelNode.Lcl_Translation.value; + if ("PreRotation" in modelNode) transformData.preRotation = modelNode.PreRotation.value; + if ("Lcl_Rotation" in modelNode) transformData.rotation = modelNode.Lcl_Rotation.value; + if ("PostRotation" in modelNode) transformData.postRotation = modelNode.PostRotation.value; + if ("Lcl_Scaling" in modelNode) transformData.scale = modelNode.Lcl_Scaling.value; + if ("ScalingOffset" in modelNode) transformData.scalingOffset = modelNode.ScalingOffset.value; + if ("ScalingPivot" in modelNode) transformData.scalingPivot = modelNode.ScalingPivot.value; + if ("RotationOffset" in modelNode) transformData.rotationOffset = modelNode.RotationOffset.value; + if ("RotationPivot" in modelNode) transformData.rotationPivot = modelNode.RotationPivot.value; + model.userData.transformData = transformData; + } + setLookAtProperties(model, modelNode) { + if ("LookAtProperty" in modelNode) { + const children = connections.get(model.ID).children; + children.forEach(function(child) { + if (child.relationship === "LookAtProperty") { + const lookAtTarget = fbxTree.Objects.Model[child.ID]; + if ("Lcl_Translation" in lookAtTarget) { + const pos = lookAtTarget.Lcl_Translation.value; + if (model.target !== void 0) { + model.target.position.fromArray(pos); + sceneGraph.add(model.target); + } else { + model.lookAt(new Vector3().fromArray(pos)); + } + } + } + }); + } + } + bindSkeleton(skeletons, geometryMap, modelMap) { + const bindMatrices = this.parsePoseNodes(); + for (const ID in skeletons) { + const skeleton = skeletons[ID]; + const parents = connections.get(parseInt(skeleton.ID)).parents; + parents.forEach(function(parent) { + if (geometryMap.has(parent.ID)) { + const geoID = parent.ID; + const geoRelationships = connections.get(geoID); + geoRelationships.parents.forEach(function(geoConnParent) { + if (modelMap.has(geoConnParent.ID)) { + const model = modelMap.get(geoConnParent.ID); + model.bind(new Skeleton(skeleton.bones), bindMatrices[geoConnParent.ID]); + } + }); + } + }); + } + } + parsePoseNodes() { + const bindMatrices = {}; + if ("Pose" in fbxTree.Objects) { + const BindPoseNode = fbxTree.Objects.Pose; + for (const nodeID in BindPoseNode) { + if (BindPoseNode[nodeID].attrType === "BindPose" && BindPoseNode[nodeID].NbPoseNodes > 0) { + const poseNodes = BindPoseNode[nodeID].PoseNode; + if (Array.isArray(poseNodes)) { + poseNodes.forEach(function(poseNode) { + bindMatrices[poseNode.Node] = new Matrix4().fromArray(poseNode.Matrix.a); + }); + } else { + bindMatrices[poseNodes.Node] = new Matrix4().fromArray(poseNodes.Matrix.a); + } + } + } + } + return bindMatrices; + } + addGlobalSceneSettings() { + if ("GlobalSettings" in fbxTree) { + if ("AmbientColor" in fbxTree.GlobalSettings) { + const ambientColor = fbxTree.GlobalSettings.AmbientColor.value; + const r = ambientColor[0]; + const g = ambientColor[1]; + const b = ambientColor[2]; + if (r !== 0 || g !== 0 || b !== 0) { + const color = new Color(r, g, b).convertSRGBToLinear(); + sceneGraph.add(new AmbientLight(color, 1)); + } + } + if ("UnitScaleFactor" in fbxTree.GlobalSettings) { + sceneGraph.userData.unitScaleFactor = fbxTree.GlobalSettings.UnitScaleFactor.value; + } + } + } +}; +var GeometryParser = class { + constructor() { + this.negativeMaterialIndices = false; + } + // Parse nodes in FBXTree.Objects.Geometry + parse(deformers) { + const geometryMap = /* @__PURE__ */ new Map(); + if ("Geometry" in fbxTree.Objects) { + const geoNodes = fbxTree.Objects.Geometry; + for (const nodeID in geoNodes) { + const relationships = connections.get(parseInt(nodeID)); + const geo = this.parseGeometry(relationships, geoNodes[nodeID], deformers); + geometryMap.set(parseInt(nodeID), geo); + } + } + if (this.negativeMaterialIndices === true) { + console.warn("THREE.FBXLoader: The FBX file contains invalid (negative) material indices. The asset might not render as expected."); + } + return geometryMap; + } + // Parse single node in FBXTree.Objects.Geometry + parseGeometry(relationships, geoNode, deformers) { + switch (geoNode.attrType) { + case "Mesh": + return this.parseMeshGeometry(relationships, geoNode, deformers); + break; + case "NurbsCurve": + return this.parseNurbsGeometry(geoNode); + break; + } + } + // Parse single node mesh geometry in FBXTree.Objects.Geometry + parseMeshGeometry(relationships, geoNode, deformers) { + const skeletons = deformers.skeletons; + const morphTargets = []; + const modelNodes = relationships.parents.map(function(parent) { + return fbxTree.Objects.Model[parent.ID]; + }); + if (modelNodes.length === 0) return; + const skeleton = relationships.children.reduce(function(skeleton2, child) { + if (skeletons[child.ID] !== void 0) skeleton2 = skeletons[child.ID]; + return skeleton2; + }, null); + relationships.children.forEach(function(child) { + if (deformers.morphTargets[child.ID] !== void 0) { + morphTargets.push(deformers.morphTargets[child.ID]); + } + }); + const modelNode = modelNodes[0]; + const transformData = {}; + if ("RotationOrder" in modelNode) transformData.eulerOrder = getEulerOrder(modelNode.RotationOrder.value); + if ("InheritType" in modelNode) transformData.inheritType = parseInt(modelNode.InheritType.value); + if ("GeometricTranslation" in modelNode) transformData.translation = modelNode.GeometricTranslation.value; + if ("GeometricRotation" in modelNode) transformData.rotation = modelNode.GeometricRotation.value; + if ("GeometricScaling" in modelNode) transformData.scale = modelNode.GeometricScaling.value; + const transform = generateTransform(transformData); + return this.genGeometry(geoNode, skeleton, morphTargets, transform); + } + // Generate a BufferGeometry from a node in FBXTree.Objects.Geometry + genGeometry(geoNode, skeleton, morphTargets, preTransform) { + const geo = new BufferGeometry(); + if (geoNode.attrName) geo.name = geoNode.attrName; + const geoInfo = this.parseGeoNode(geoNode, skeleton); + const buffers = this.genBuffers(geoInfo); + const positionAttribute = new Float32BufferAttribute(buffers.vertex, 3); + positionAttribute.applyMatrix4(preTransform); + geo.setAttribute("position", positionAttribute); + if (buffers.colors.length > 0) { + geo.setAttribute("color", new Float32BufferAttribute(buffers.colors, 3)); + } + if (skeleton) { + geo.setAttribute("skinIndex", new Uint16BufferAttribute(buffers.weightsIndices, 4)); + geo.setAttribute("skinWeight", new Float32BufferAttribute(buffers.vertexWeights, 4)); + geo.FBX_Deformer = skeleton; + } + if (buffers.normal.length > 0) { + const normalMatrix = new Matrix3().getNormalMatrix(preTransform); + const normalAttribute = new Float32BufferAttribute(buffers.normal, 3); + normalAttribute.applyNormalMatrix(normalMatrix); + geo.setAttribute("normal", normalAttribute); + } + buffers.uvs.forEach(function(uvBuffer, i) { + const name = i === 0 ? "uv" : `uv${i}`; + geo.setAttribute(name, new Float32BufferAttribute(buffers.uvs[i], 2)); + }); + if (geoInfo.material && geoInfo.material.mappingType !== "AllSame") { + let prevMaterialIndex = buffers.materialIndex[0]; + let startIndex = 0; + buffers.materialIndex.forEach(function(currentIndex, i) { + if (currentIndex !== prevMaterialIndex) { + geo.addGroup(startIndex, i - startIndex, prevMaterialIndex); + prevMaterialIndex = currentIndex; + startIndex = i; + } + }); + if (geo.groups.length > 0) { + const lastGroup = geo.groups[geo.groups.length - 1]; + const lastIndex = lastGroup.start + lastGroup.count; + if (lastIndex !== buffers.materialIndex.length) { + geo.addGroup(lastIndex, buffers.materialIndex.length - lastIndex, prevMaterialIndex); + } + } + if (geo.groups.length === 0) { + geo.addGroup(0, buffers.materialIndex.length, buffers.materialIndex[0]); + } + } + this.addMorphTargets(geo, geoNode, morphTargets, preTransform); + return geo; + } + parseGeoNode(geoNode, skeleton) { + const geoInfo = {}; + geoInfo.vertexPositions = geoNode.Vertices !== void 0 ? geoNode.Vertices.a : []; + geoInfo.vertexIndices = geoNode.PolygonVertexIndex !== void 0 ? geoNode.PolygonVertexIndex.a : []; + if (geoNode.LayerElementColor) { + geoInfo.color = this.parseVertexColors(geoNode.LayerElementColor[0]); + } + if (geoNode.LayerElementMaterial) { + geoInfo.material = this.parseMaterialIndices(geoNode.LayerElementMaterial[0]); + } + if (geoNode.LayerElementNormal) { + geoInfo.normal = this.parseNormals(geoNode.LayerElementNormal[0]); + } + if (geoNode.LayerElementUV) { + geoInfo.uv = []; + let i = 0; + while (geoNode.LayerElementUV[i]) { + if (geoNode.LayerElementUV[i].UV) { + geoInfo.uv.push(this.parseUVs(geoNode.LayerElementUV[i])); + } + i++; + } + } + geoInfo.weightTable = {}; + if (skeleton !== null) { + geoInfo.skeleton = skeleton; + skeleton.rawBones.forEach(function(rawBone, i) { + rawBone.indices.forEach(function(index, j) { + if (geoInfo.weightTable[index] === void 0) geoInfo.weightTable[index] = []; + geoInfo.weightTable[index].push({ + id: i, + weight: rawBone.weights[j] + }); + }); + }); + } + return geoInfo; + } + genBuffers(geoInfo) { + const buffers = { + vertex: [], + normal: [], + colors: [], + uvs: [], + materialIndex: [], + vertexWeights: [], + weightsIndices: [] + }; + let polygonIndex = 0; + let faceLength = 0; + let displayedWeightsWarning = false; + let facePositionIndexes = []; + let faceNormals = []; + let faceColors = []; + let faceUVs = []; + let faceWeights = []; + let faceWeightIndices = []; + const scope = this; + geoInfo.vertexIndices.forEach(function(vertexIndex, polygonVertexIndex) { + let materialIndex; + let endOfFace = false; + if (vertexIndex < 0) { + vertexIndex = vertexIndex ^ -1; + endOfFace = true; + } + let weightIndices = []; + let weights = []; + facePositionIndexes.push(vertexIndex * 3, vertexIndex * 3 + 1, vertexIndex * 3 + 2); + if (geoInfo.color) { + const data = getData(polygonVertexIndex, polygonIndex, vertexIndex, geoInfo.color); + faceColors.push(data[0], data[1], data[2]); + } + if (geoInfo.skeleton) { + if (geoInfo.weightTable[vertexIndex] !== void 0) { + geoInfo.weightTable[vertexIndex].forEach(function(wt) { + weights.push(wt.weight); + weightIndices.push(wt.id); + }); + } + if (weights.length > 4) { + if (!displayedWeightsWarning) { + console.warn("THREE.FBXLoader: Vertex has more than 4 skinning weights assigned to vertex. Deleting additional weights."); + displayedWeightsWarning = true; + } + const wIndex = [0, 0, 0, 0]; + const Weight = [0, 0, 0, 0]; + weights.forEach(function(weight, weightIndex) { + let currentWeight = weight; + let currentIndex = weightIndices[weightIndex]; + Weight.forEach(function(comparedWeight, comparedWeightIndex, comparedWeightArray) { + if (currentWeight > comparedWeight) { + comparedWeightArray[comparedWeightIndex] = currentWeight; + currentWeight = comparedWeight; + const tmp = wIndex[comparedWeightIndex]; + wIndex[comparedWeightIndex] = currentIndex; + currentIndex = tmp; + } + }); + }); + weightIndices = wIndex; + weights = Weight; + } + while (weights.length < 4) { + weights.push(0); + weightIndices.push(0); + } + for (let i = 0; i < 4; ++i) { + faceWeights.push(weights[i]); + faceWeightIndices.push(weightIndices[i]); + } + } + if (geoInfo.normal) { + const data = getData(polygonVertexIndex, polygonIndex, vertexIndex, geoInfo.normal); + faceNormals.push(data[0], data[1], data[2]); + } + if (geoInfo.material && geoInfo.material.mappingType !== "AllSame") { + materialIndex = getData(polygonVertexIndex, polygonIndex, vertexIndex, geoInfo.material)[0]; + if (materialIndex < 0) { + scope.negativeMaterialIndices = true; + materialIndex = 0; + } + } + if (geoInfo.uv) { + geoInfo.uv.forEach(function(uv, i) { + const data = getData(polygonVertexIndex, polygonIndex, vertexIndex, uv); + if (faceUVs[i] === void 0) { + faceUVs[i] = []; + } + faceUVs[i].push(data[0]); + faceUVs[i].push(data[1]); + }); + } + faceLength++; + if (endOfFace) { + scope.genFace(buffers, geoInfo, facePositionIndexes, materialIndex, faceNormals, faceColors, faceUVs, faceWeights, faceWeightIndices, faceLength); + polygonIndex++; + faceLength = 0; + facePositionIndexes = []; + faceNormals = []; + faceColors = []; + faceUVs = []; + faceWeights = []; + faceWeightIndices = []; + } + }); + return buffers; + } + // See https://www.khronos.org/opengl/wiki/Calculating_a_Surface_Normal + getNormalNewell(vertices) { + const normal = new Vector3(0, 0, 0); + for (let i = 0; i < vertices.length; i++) { + const current = vertices[i]; + const next = vertices[(i + 1) % vertices.length]; + normal.x += (current.y - next.y) * (current.z + next.z); + normal.y += (current.z - next.z) * (current.x + next.x); + normal.z += (current.x - next.x) * (current.y + next.y); + } + normal.normalize(); + return normal; + } + getNormalTangentAndBitangent(vertices) { + const normalVector = this.getNormalNewell(vertices); + const up2 = Math.abs(normalVector.z) > 0.5 ? new Vector3(0, 1, 0) : new Vector3(0, 0, 1); + const tangent = up2.cross(normalVector).normalize(); + const bitangent = normalVector.clone().cross(tangent).normalize(); + return { + normal: normalVector, + tangent, + bitangent + }; + } + flattenVertex(vertex2, normalTangent, normalBitangent) { + return new Vector2( + vertex2.dot(normalTangent), + vertex2.dot(normalBitangent) + ); + } + // Generate data for a single face in a geometry. If the face is a quad then split it into 2 tris + genFace(buffers, geoInfo, facePositionIndexes, materialIndex, faceNormals, faceColors, faceUVs, faceWeights, faceWeightIndices, faceLength) { + let triangles; + if (faceLength > 3) { + const vertices = []; + for (let i = 0; i < facePositionIndexes.length; i += 3) { + vertices.push(new Vector3( + geoInfo.vertexPositions[facePositionIndexes[i]], + geoInfo.vertexPositions[facePositionIndexes[i + 1]], + geoInfo.vertexPositions[facePositionIndexes[i + 2]] + )); + } + const { tangent, bitangent } = this.getNormalTangentAndBitangent(vertices); + const triangulationInput = []; + for (const vertex2 of vertices) { + triangulationInput.push(this.flattenVertex(vertex2, tangent, bitangent)); + } + triangles = ShapeUtils.triangulateShape(triangulationInput, []); + } else { + triangles = [[0, 1, 2]]; + } + for (const [i0, i1, i2] of triangles) { + buffers.vertex.push(geoInfo.vertexPositions[facePositionIndexes[i0 * 3]]); + buffers.vertex.push(geoInfo.vertexPositions[facePositionIndexes[i0 * 3 + 1]]); + buffers.vertex.push(geoInfo.vertexPositions[facePositionIndexes[i0 * 3 + 2]]); + buffers.vertex.push(geoInfo.vertexPositions[facePositionIndexes[i1 * 3]]); + buffers.vertex.push(geoInfo.vertexPositions[facePositionIndexes[i1 * 3 + 1]]); + buffers.vertex.push(geoInfo.vertexPositions[facePositionIndexes[i1 * 3 + 2]]); + buffers.vertex.push(geoInfo.vertexPositions[facePositionIndexes[i2 * 3]]); + buffers.vertex.push(geoInfo.vertexPositions[facePositionIndexes[i2 * 3 + 1]]); + buffers.vertex.push(geoInfo.vertexPositions[facePositionIndexes[i2 * 3 + 2]]); + if (geoInfo.skeleton) { + buffers.vertexWeights.push(faceWeights[i0 * 4]); + buffers.vertexWeights.push(faceWeights[i0 * 4 + 1]); + buffers.vertexWeights.push(faceWeights[i0 * 4 + 2]); + buffers.vertexWeights.push(faceWeights[i0 * 4 + 3]); + buffers.vertexWeights.push(faceWeights[i1 * 4]); + buffers.vertexWeights.push(faceWeights[i1 * 4 + 1]); + buffers.vertexWeights.push(faceWeights[i1 * 4 + 2]); + buffers.vertexWeights.push(faceWeights[i1 * 4 + 3]); + buffers.vertexWeights.push(faceWeights[i2 * 4]); + buffers.vertexWeights.push(faceWeights[i2 * 4 + 1]); + buffers.vertexWeights.push(faceWeights[i2 * 4 + 2]); + buffers.vertexWeights.push(faceWeights[i2 * 4 + 3]); + buffers.weightsIndices.push(faceWeightIndices[i0 * 4]); + buffers.weightsIndices.push(faceWeightIndices[i0 * 4 + 1]); + buffers.weightsIndices.push(faceWeightIndices[i0 * 4 + 2]); + buffers.weightsIndices.push(faceWeightIndices[i0 * 4 + 3]); + buffers.weightsIndices.push(faceWeightIndices[i1 * 4]); + buffers.weightsIndices.push(faceWeightIndices[i1 * 4 + 1]); + buffers.weightsIndices.push(faceWeightIndices[i1 * 4 + 2]); + buffers.weightsIndices.push(faceWeightIndices[i1 * 4 + 3]); + buffers.weightsIndices.push(faceWeightIndices[i2 * 4]); + buffers.weightsIndices.push(faceWeightIndices[i2 * 4 + 1]); + buffers.weightsIndices.push(faceWeightIndices[i2 * 4 + 2]); + buffers.weightsIndices.push(faceWeightIndices[i2 * 4 + 3]); + } + if (geoInfo.color) { + buffers.colors.push(faceColors[i0 * 3]); + buffers.colors.push(faceColors[i0 * 3 + 1]); + buffers.colors.push(faceColors[i0 * 3 + 2]); + buffers.colors.push(faceColors[i1 * 3]); + buffers.colors.push(faceColors[i1 * 3 + 1]); + buffers.colors.push(faceColors[i1 * 3 + 2]); + buffers.colors.push(faceColors[i2 * 3]); + buffers.colors.push(faceColors[i2 * 3 + 1]); + buffers.colors.push(faceColors[i2 * 3 + 2]); + } + if (geoInfo.material && geoInfo.material.mappingType !== "AllSame") { + buffers.materialIndex.push(materialIndex); + buffers.materialIndex.push(materialIndex); + buffers.materialIndex.push(materialIndex); + } + if (geoInfo.normal) { + buffers.normal.push(faceNormals[i0 * 3]); + buffers.normal.push(faceNormals[i0 * 3 + 1]); + buffers.normal.push(faceNormals[i0 * 3 + 2]); + buffers.normal.push(faceNormals[i1 * 3]); + buffers.normal.push(faceNormals[i1 * 3 + 1]); + buffers.normal.push(faceNormals[i1 * 3 + 2]); + buffers.normal.push(faceNormals[i2 * 3]); + buffers.normal.push(faceNormals[i2 * 3 + 1]); + buffers.normal.push(faceNormals[i2 * 3 + 2]); + } + if (geoInfo.uv) { + geoInfo.uv.forEach(function(uv, j) { + if (buffers.uvs[j] === void 0) buffers.uvs[j] = []; + buffers.uvs[j].push(faceUVs[j][i0 * 2]); + buffers.uvs[j].push(faceUVs[j][i0 * 2 + 1]); + buffers.uvs[j].push(faceUVs[j][i1 * 2]); + buffers.uvs[j].push(faceUVs[j][i1 * 2 + 1]); + buffers.uvs[j].push(faceUVs[j][i2 * 2]); + buffers.uvs[j].push(faceUVs[j][i2 * 2 + 1]); + }); + } + } + } + addMorphTargets(parentGeo, parentGeoNode, morphTargets, preTransform) { + if (morphTargets.length === 0) return; + parentGeo.morphTargetsRelative = true; + parentGeo.morphAttributes.position = []; + const scope = this; + morphTargets.forEach(function(morphTarget) { + morphTarget.rawTargets.forEach(function(rawTarget) { + const morphGeoNode = fbxTree.Objects.Geometry[rawTarget.geoID]; + if (morphGeoNode !== void 0) { + scope.genMorphGeometry(parentGeo, parentGeoNode, morphGeoNode, preTransform, rawTarget.name); + } + }); + }); + } + // a morph geometry node is similar to a standard node, and the node is also contained + // in FBXTree.Objects.Geometry, however it can only have attributes for position, normal + // and a special attribute Index defining which vertices of the original geometry are affected + // Normal and position attributes only have data for the vertices that are affected by the morph + genMorphGeometry(parentGeo, parentGeoNode, morphGeoNode, preTransform, name) { + const vertexIndices = parentGeoNode.PolygonVertexIndex !== void 0 ? parentGeoNode.PolygonVertexIndex.a : []; + const morphPositionsSparse = morphGeoNode.Vertices !== void 0 ? morphGeoNode.Vertices.a : []; + const indices = morphGeoNode.Indexes !== void 0 ? morphGeoNode.Indexes.a : []; + const length = parentGeo.attributes.position.count * 3; + const morphPositions = new Float32Array(length); + for (let i = 0; i < indices.length; i++) { + const morphIndex = indices[i] * 3; + morphPositions[morphIndex] = morphPositionsSparse[i * 3]; + morphPositions[morphIndex + 1] = morphPositionsSparse[i * 3 + 1]; + morphPositions[morphIndex + 2] = morphPositionsSparse[i * 3 + 2]; + } + const morphGeoInfo = { + vertexIndices, + vertexPositions: morphPositions + }; + const morphBuffers = this.genBuffers(morphGeoInfo); + const positionAttribute = new Float32BufferAttribute(morphBuffers.vertex, 3); + positionAttribute.name = name || morphGeoNode.attrName; + positionAttribute.applyMatrix4(preTransform); + parentGeo.morphAttributes.position.push(positionAttribute); + } + // Parse normal from FBXTree.Objects.Geometry.LayerElementNormal if it exists + parseNormals(NormalNode) { + const mappingType = NormalNode.MappingInformationType; + const referenceType = NormalNode.ReferenceInformationType; + const buffer = NormalNode.Normals.a; + let indexBuffer = []; + if (referenceType === "IndexToDirect") { + if ("NormalIndex" in NormalNode) { + indexBuffer = NormalNode.NormalIndex.a; + } else if ("NormalsIndex" in NormalNode) { + indexBuffer = NormalNode.NormalsIndex.a; + } + } + return { + dataSize: 3, + buffer, + indices: indexBuffer, + mappingType, + referenceType + }; + } + // Parse UVs from FBXTree.Objects.Geometry.LayerElementUV if it exists + parseUVs(UVNode) { + const mappingType = UVNode.MappingInformationType; + const referenceType = UVNode.ReferenceInformationType; + const buffer = UVNode.UV.a; + let indexBuffer = []; + if (referenceType === "IndexToDirect") { + indexBuffer = UVNode.UVIndex.a; + } + return { + dataSize: 2, + buffer, + indices: indexBuffer, + mappingType, + referenceType + }; + } + // Parse Vertex Colors from FBXTree.Objects.Geometry.LayerElementColor if it exists + parseVertexColors(ColorNode) { + const mappingType = ColorNode.MappingInformationType; + const referenceType = ColorNode.ReferenceInformationType; + const buffer = ColorNode.Colors.a; + let indexBuffer = []; + if (referenceType === "IndexToDirect") { + indexBuffer = ColorNode.ColorIndex.a; + } + for (let i = 0, c = new Color(); i < buffer.length; i += 4) { + c.fromArray(buffer, i).convertSRGBToLinear().toArray(buffer, i); + } + return { + dataSize: 4, + buffer, + indices: indexBuffer, + mappingType, + referenceType + }; + } + // Parse mapping and material data in FBXTree.Objects.Geometry.LayerElementMaterial if it exists + parseMaterialIndices(MaterialNode) { + const mappingType = MaterialNode.MappingInformationType; + const referenceType = MaterialNode.ReferenceInformationType; + if (mappingType === "NoMappingInformation") { + return { + dataSize: 1, + buffer: [0], + indices: [0], + mappingType: "AllSame", + referenceType + }; + } + const materialIndexBuffer = MaterialNode.Materials.a; + const materialIndices = []; + for (let i = 0; i < materialIndexBuffer.length; ++i) { + materialIndices.push(i); + } + return { + dataSize: 1, + buffer: materialIndexBuffer, + indices: materialIndices, + mappingType, + referenceType + }; + } + // Generate a NurbGeometry from a node in FBXTree.Objects.Geometry + parseNurbsGeometry(geoNode) { + const order = parseInt(geoNode.Order); + if (isNaN(order)) { + console.error("THREE.FBXLoader: Invalid Order %s given for geometry ID: %s", geoNode.Order, geoNode.id); + return new BufferGeometry(); + } + const degree = order - 1; + const knots = geoNode.KnotVector.a; + const controlPoints = []; + const pointsValues = geoNode.Points.a; + for (let i = 0, l = pointsValues.length; i < l; i += 4) { + controlPoints.push(new Vector4().fromArray(pointsValues, i)); + } + let startKnot, endKnot; + if (geoNode.Form === "Closed") { + controlPoints.push(controlPoints[0]); + } else if (geoNode.Form === "Periodic") { + startKnot = degree; + endKnot = knots.length - 1 - startKnot; + for (let i = 0; i < degree; ++i) { + controlPoints.push(controlPoints[i]); + } + } + const curve = new NURBSCurve(degree, knots, controlPoints, startKnot, endKnot); + const points = curve.getPoints(controlPoints.length * 12); + return new BufferGeometry().setFromPoints(points); + } +}; +var AnimationParser = class { + // take raw animation clips and turn them into three.js animation clips + parse() { + const animationClips = []; + const rawClips = this.parseClips(); + if (rawClips !== void 0) { + for (const key in rawClips) { + const rawClip = rawClips[key]; + const clip = this.addClip(rawClip); + animationClips.push(clip); + } + } + return animationClips; + } + parseClips() { + if (fbxTree.Objects.AnimationCurve === void 0) return void 0; + const curveNodesMap = this.parseAnimationCurveNodes(); + this.parseAnimationCurves(curveNodesMap); + const layersMap = this.parseAnimationLayers(curveNodesMap); + const rawClips = this.parseAnimStacks(layersMap); + return rawClips; + } + // parse nodes in FBXTree.Objects.AnimationCurveNode + // each AnimationCurveNode holds data for an animation transform for a model (e.g. left arm rotation ) + // and is referenced by an AnimationLayer + parseAnimationCurveNodes() { + const rawCurveNodes = fbxTree.Objects.AnimationCurveNode; + const curveNodesMap = /* @__PURE__ */ new Map(); + for (const nodeID in rawCurveNodes) { + const rawCurveNode = rawCurveNodes[nodeID]; + if (rawCurveNode.attrName.match(/S|R|T|DeformPercent/) !== null) { + const curveNode = { + id: rawCurveNode.id, + attr: rawCurveNode.attrName, + curves: {} + }; + curveNodesMap.set(curveNode.id, curveNode); + } + } + return curveNodesMap; + } + // parse nodes in FBXTree.Objects.AnimationCurve and connect them up to + // previously parsed AnimationCurveNodes. Each AnimationCurve holds data for a single animated + // axis ( e.g. times and values of x rotation) + parseAnimationCurves(curveNodesMap) { + const rawCurves = fbxTree.Objects.AnimationCurve; + for (const nodeID in rawCurves) { + const animationCurve = { + id: rawCurves[nodeID].id, + times: rawCurves[nodeID].KeyTime.a.map(convertFBXTimeToSeconds), + values: rawCurves[nodeID].KeyValueFloat.a + }; + const relationships = connections.get(animationCurve.id); + if (relationships !== void 0) { + const animationCurveID = relationships.parents[0].ID; + const animationCurveRelationship = relationships.parents[0].relationship; + if (animationCurveRelationship.match(/X/)) { + curveNodesMap.get(animationCurveID).curves["x"] = animationCurve; + } else if (animationCurveRelationship.match(/Y/)) { + curveNodesMap.get(animationCurveID).curves["y"] = animationCurve; + } else if (animationCurveRelationship.match(/Z/)) { + curveNodesMap.get(animationCurveID).curves["z"] = animationCurve; + } else if (animationCurveRelationship.match(/DeformPercent/) && curveNodesMap.has(animationCurveID)) { + curveNodesMap.get(animationCurveID).curves["morph"] = animationCurve; + } + } + } + } + // parse nodes in FBXTree.Objects.AnimationLayer. Each layers holds references + // to various AnimationCurveNodes and is referenced by an AnimationStack node + // note: theoretically a stack can have multiple layers, however in practice there always seems to be one per stack + parseAnimationLayers(curveNodesMap) { + const rawLayers = fbxTree.Objects.AnimationLayer; + const layersMap = /* @__PURE__ */ new Map(); + for (const nodeID in rawLayers) { + const layerCurveNodes = []; + const connection = connections.get(parseInt(nodeID)); + if (connection !== void 0) { + const children = connection.children; + children.forEach(function(child, i) { + if (curveNodesMap.has(child.ID)) { + const curveNode = curveNodesMap.get(child.ID); + if (curveNode.curves.x !== void 0 || curveNode.curves.y !== void 0 || curveNode.curves.z !== void 0) { + if (layerCurveNodes[i] === void 0) { + const modelID = connections.get(child.ID).parents.filter(function(parent) { + return parent.relationship !== void 0; + })[0].ID; + if (modelID !== void 0) { + const rawModel = fbxTree.Objects.Model[modelID.toString()]; + if (rawModel === void 0) { + console.warn("THREE.FBXLoader: Encountered a unused curve.", child); + return; + } + const node = { + modelName: rawModel.attrName ? PropertyBinding.sanitizeNodeName(rawModel.attrName) : "", + ID: rawModel.id, + initialPosition: [0, 0, 0], + initialRotation: [0, 0, 0], + initialScale: [1, 1, 1] + }; + sceneGraph.traverse(function(child2) { + if (child2.ID === rawModel.id) { + node.transform = child2.matrix; + if (child2.userData.transformData) node.eulerOrder = child2.userData.transformData.eulerOrder; + } + }); + if (!node.transform) node.transform = new Matrix4(); + if ("PreRotation" in rawModel) node.preRotation = rawModel.PreRotation.value; + if ("PostRotation" in rawModel) node.postRotation = rawModel.PostRotation.value; + layerCurveNodes[i] = node; + } + } + if (layerCurveNodes[i]) layerCurveNodes[i][curveNode.attr] = curveNode; + } else if (curveNode.curves.morph !== void 0) { + if (layerCurveNodes[i] === void 0) { + const deformerID = connections.get(child.ID).parents.filter(function(parent) { + return parent.relationship !== void 0; + })[0].ID; + const morpherID = connections.get(deformerID).parents[0].ID; + const geoID = connections.get(morpherID).parents[0].ID; + const modelID = connections.get(geoID).parents[0].ID; + const rawModel = fbxTree.Objects.Model[modelID]; + const node = { + modelName: rawModel.attrName ? PropertyBinding.sanitizeNodeName(rawModel.attrName) : "", + morphName: fbxTree.Objects.Deformer[deformerID].attrName + }; + layerCurveNodes[i] = node; + } + layerCurveNodes[i][curveNode.attr] = curveNode; + } + } + }); + layersMap.set(parseInt(nodeID), layerCurveNodes); + } + } + return layersMap; + } + // parse nodes in FBXTree.Objects.AnimationStack. These are the top level node in the animation + // hierarchy. Each Stack node will be used to create a AnimationClip + parseAnimStacks(layersMap) { + const rawStacks = fbxTree.Objects.AnimationStack; + const rawClips = {}; + for (const nodeID in rawStacks) { + const children = connections.get(parseInt(nodeID)).children; + if (children.length > 1) { + console.warn("THREE.FBXLoader: Encountered an animation stack with multiple layers, this is currently not supported. Ignoring subsequent layers."); + } + const layer = layersMap.get(children[0].ID); + rawClips[nodeID] = { + name: rawStacks[nodeID].attrName, + layer + }; + } + return rawClips; + } + addClip(rawClip) { + let tracks = []; + const scope = this; + rawClip.layer.forEach(function(rawTracks) { + tracks = tracks.concat(scope.generateTracks(rawTracks)); + }); + return new AnimationClip(rawClip.name, -1, tracks); + } + generateTracks(rawTracks) { + const tracks = []; + let initialPosition = new Vector3(); + let initialScale = new Vector3(); + if (rawTracks.transform) rawTracks.transform.decompose(initialPosition, new Quaternion(), initialScale); + initialPosition = initialPosition.toArray(); + initialScale = initialScale.toArray(); + if (rawTracks.T !== void 0 && Object.keys(rawTracks.T.curves).length > 0) { + const positionTrack = this.generateVectorTrack(rawTracks.modelName, rawTracks.T.curves, initialPosition, "position"); + if (positionTrack !== void 0) tracks.push(positionTrack); + } + if (rawTracks.R !== void 0 && Object.keys(rawTracks.R.curves).length > 0) { + const rotationTrack = this.generateRotationTrack(rawTracks.modelName, rawTracks.R.curves, rawTracks.preRotation, rawTracks.postRotation, rawTracks.eulerOrder); + if (rotationTrack !== void 0) tracks.push(rotationTrack); + } + if (rawTracks.S !== void 0 && Object.keys(rawTracks.S.curves).length > 0) { + const scaleTrack = this.generateVectorTrack(rawTracks.modelName, rawTracks.S.curves, initialScale, "scale"); + if (scaleTrack !== void 0) tracks.push(scaleTrack); + } + if (rawTracks.DeformPercent !== void 0) { + const morphTrack = this.generateMorphTrack(rawTracks); + if (morphTrack !== void 0) tracks.push(morphTrack); + } + return tracks; + } + generateVectorTrack(modelName, curves, initialValue, type) { + const times = this.getTimesForAllAxes(curves); + const values = this.getKeyframeTrackValues(times, curves, initialValue); + return new VectorKeyframeTrack(modelName + "." + type, times, values); + } + generateRotationTrack(modelName, curves, preRotation, postRotation, eulerOrder) { + let times; + let values; + if (curves.x !== void 0 && curves.y !== void 0 && curves.z !== void 0) { + const result = this.interpolateRotations(curves.x, curves.y, curves.z, eulerOrder); + times = result[0]; + values = result[1]; + } + if (preRotation !== void 0) { + preRotation = preRotation.map(MathUtils.degToRad); + preRotation.push(eulerOrder); + preRotation = new Euler().fromArray(preRotation); + preRotation = new Quaternion().setFromEuler(preRotation); + } + if (postRotation !== void 0) { + postRotation = postRotation.map(MathUtils.degToRad); + postRotation.push(eulerOrder); + postRotation = new Euler().fromArray(postRotation); + postRotation = new Quaternion().setFromEuler(postRotation).invert(); + } + const quaternion2 = new Quaternion(); + const euler = new Euler(); + const quaternionValues = []; + if (!values || !times) return new QuaternionKeyframeTrack(modelName + ".quaternion", [0], [0]); + for (let i = 0; i < values.length; i += 3) { + euler.set(values[i], values[i + 1], values[i + 2], eulerOrder); + quaternion2.setFromEuler(euler); + if (preRotation !== void 0) quaternion2.premultiply(preRotation); + if (postRotation !== void 0) quaternion2.multiply(postRotation); + if (i > 2) { + const prevQuat = new Quaternion().fromArray( + quaternionValues, + (i - 3) / 3 * 4 + ); + if (prevQuat.dot(quaternion2) < 0) { + quaternion2.set(-quaternion2.x, -quaternion2.y, -quaternion2.z, -quaternion2.w); + } + } + quaternion2.toArray(quaternionValues, i / 3 * 4); + } + return new QuaternionKeyframeTrack(modelName + ".quaternion", times, quaternionValues); + } + generateMorphTrack(rawTracks) { + const curves = rawTracks.DeformPercent.curves.morph; + const values = curves.values.map(function(val) { + return val / 100; + }); + const morphNum = sceneGraph.getObjectByName(rawTracks.modelName).morphTargetDictionary[rawTracks.morphName]; + return new NumberKeyframeTrack(rawTracks.modelName + ".morphTargetInfluences[" + morphNum + "]", curves.times, values); + } + // For all animated objects, times are defined separately for each axis + // Here we'll combine the times into one sorted array without duplicates + getTimesForAllAxes(curves) { + let times = []; + if (curves.x !== void 0) times = times.concat(curves.x.times); + if (curves.y !== void 0) times = times.concat(curves.y.times); + if (curves.z !== void 0) times = times.concat(curves.z.times); + times = times.sort(function(a, b) { + return a - b; + }); + if (times.length > 1) { + let targetIndex = 1; + let lastValue = times[0]; + for (let i = 1; i < times.length; i++) { + const currentValue = times[i]; + if (currentValue !== lastValue) { + times[targetIndex] = currentValue; + lastValue = currentValue; + targetIndex++; + } + } + times = times.slice(0, targetIndex); + } + return times; + } + getKeyframeTrackValues(times, curves, initialValue) { + const prevValue = initialValue; + const values = []; + let xIndex = -1; + let yIndex = -1; + let zIndex = -1; + times.forEach(function(time) { + if (curves.x) xIndex = curves.x.times.indexOf(time); + if (curves.y) yIndex = curves.y.times.indexOf(time); + if (curves.z) zIndex = curves.z.times.indexOf(time); + if (xIndex !== -1) { + const xValue = curves.x.values[xIndex]; + values.push(xValue); + prevValue[0] = xValue; + } else { + values.push(prevValue[0]); + } + if (yIndex !== -1) { + const yValue = curves.y.values[yIndex]; + values.push(yValue); + prevValue[1] = yValue; + } else { + values.push(prevValue[1]); + } + if (zIndex !== -1) { + const zValue = curves.z.values[zIndex]; + values.push(zValue); + prevValue[2] = zValue; + } else { + values.push(prevValue[2]); + } + }); + return values; + } + // Rotations are defined as Euler angles which can have values of any size + // These will be converted to quaternions which don't support values greater than + // PI, so we'll interpolate large rotations + interpolateRotations(curvex, curvey, curvez, eulerOrder) { + const times = []; + const values = []; + times.push(curvex.times[0]); + values.push(MathUtils.degToRad(curvex.values[0])); + values.push(MathUtils.degToRad(curvey.values[0])); + values.push(MathUtils.degToRad(curvez.values[0])); + for (let i = 1; i < curvex.values.length; i++) { + const initialValue = [ + curvex.values[i - 1], + curvey.values[i - 1], + curvez.values[i - 1] + ]; + if (isNaN(initialValue[0]) || isNaN(initialValue[1]) || isNaN(initialValue[2])) { + continue; + } + const initialValueRad = initialValue.map(MathUtils.degToRad); + const currentValue = [ + curvex.values[i], + curvey.values[i], + curvez.values[i] + ]; + if (isNaN(currentValue[0]) || isNaN(currentValue[1]) || isNaN(currentValue[2])) { + continue; + } + const currentValueRad = currentValue.map(MathUtils.degToRad); + const valuesSpan = [ + currentValue[0] - initialValue[0], + currentValue[1] - initialValue[1], + currentValue[2] - initialValue[2] + ]; + const absoluteSpan = [ + Math.abs(valuesSpan[0]), + Math.abs(valuesSpan[1]), + Math.abs(valuesSpan[2]) + ]; + if (absoluteSpan[0] >= 180 || absoluteSpan[1] >= 180 || absoluteSpan[2] >= 180) { + const maxAbsSpan = Math.max(...absoluteSpan); + const numSubIntervals = maxAbsSpan / 180; + const E1 = new Euler(...initialValueRad, eulerOrder); + const E2 = new Euler(...currentValueRad, eulerOrder); + const Q1 = new Quaternion().setFromEuler(E1); + const Q2 = new Quaternion().setFromEuler(E2); + if (Q1.dot(Q2)) { + Q2.set(-Q2.x, -Q2.y, -Q2.z, -Q2.w); + } + const initialTime = curvex.times[i - 1]; + const timeSpan = curvex.times[i] - initialTime; + const Q = new Quaternion(); + const E = new Euler(); + for (let t = 0; t < 1; t += 1 / numSubIntervals) { + Q.copy(Q1.clone().slerp(Q2.clone(), t)); + times.push(initialTime + t * timeSpan); + E.setFromQuaternion(Q, eulerOrder); + values.push(E.x); + values.push(E.y); + values.push(E.z); + } + } else { + times.push(curvex.times[i]); + values.push(MathUtils.degToRad(curvex.values[i])); + values.push(MathUtils.degToRad(curvey.values[i])); + values.push(MathUtils.degToRad(curvez.values[i])); + } + } + return [times, values]; + } +}; +var TextParser = class { + getPrevNode() { + return this.nodeStack[this.currentIndent - 2]; + } + getCurrentNode() { + return this.nodeStack[this.currentIndent - 1]; + } + getCurrentProp() { + return this.currentProp; + } + pushStack(node) { + this.nodeStack.push(node); + this.currentIndent += 1; + } + popStack() { + this.nodeStack.pop(); + this.currentIndent -= 1; + } + setCurrentProp(val, name) { + this.currentProp = val; + this.currentPropName = name; + } + parse(text) { + this.currentIndent = 0; + this.allNodes = new FBXTree(); + this.nodeStack = []; + this.currentProp = []; + this.currentPropName = ""; + const scope = this; + const split = text.split(/[\r\n]+/); + split.forEach(function(line, i) { + const matchComment = line.match(/^[\s\t]*;/); + const matchEmpty = line.match(/^[\s\t]*$/); + if (matchComment || matchEmpty) return; + const matchBeginning = line.match("^\\t{" + scope.currentIndent + "}(\\w+):(.*){", ""); + const matchProperty = line.match("^\\t{" + scope.currentIndent + "}(\\w+):[\\s\\t\\r\\n](.*)"); + const matchEnd = line.match("^\\t{" + (scope.currentIndent - 1) + "}}"); + if (matchBeginning) { + scope.parseNodeBegin(line, matchBeginning); + } else if (matchProperty) { + scope.parseNodeProperty(line, matchProperty, split[++i]); + } else if (matchEnd) { + scope.popStack(); + } else if (line.match(/^[^\s\t}]/)) { + scope.parseNodePropertyContinued(line); + } + }); + return this.allNodes; + } + parseNodeBegin(line, property) { + const nodeName = property[1].trim().replace(/^"/, "").replace(/"$/, ""); + const nodeAttrs = property[2].split(",").map(function(attr) { + return attr.trim().replace(/^"/, "").replace(/"$/, ""); + }); + const node = { name: nodeName }; + const attrs = this.parseNodeAttr(nodeAttrs); + const currentNode = this.getCurrentNode(); + if (this.currentIndent === 0) { + this.allNodes.add(nodeName, node); + } else { + if (nodeName in currentNode) { + if (nodeName === "PoseNode") { + currentNode.PoseNode.push(node); + } else if (currentNode[nodeName].id !== void 0) { + currentNode[nodeName] = {}; + currentNode[nodeName][currentNode[nodeName].id] = currentNode[nodeName]; + } + if (attrs.id !== "") currentNode[nodeName][attrs.id] = node; + } else if (typeof attrs.id === "number") { + currentNode[nodeName] = {}; + currentNode[nodeName][attrs.id] = node; + } else if (nodeName !== "Properties70") { + if (nodeName === "PoseNode") currentNode[nodeName] = [node]; + else currentNode[nodeName] = node; + } + } + if (typeof attrs.id === "number") node.id = attrs.id; + if (attrs.name !== "") node.attrName = attrs.name; + if (attrs.type !== "") node.attrType = attrs.type; + this.pushStack(node); + } + parseNodeAttr(attrs) { + let id = attrs[0]; + if (attrs[0] !== "") { + id = parseInt(attrs[0]); + if (isNaN(id)) { + id = attrs[0]; + } + } + let name = "", type = ""; + if (attrs.length > 1) { + name = attrs[1].replace(/^(\w+)::/, ""); + type = attrs[2]; + } + return { id, name, type }; + } + parseNodeProperty(line, property, contentLine) { + let propName = property[1].replace(/^"/, "").replace(/"$/, "").trim(); + let propValue = property[2].replace(/^"/, "").replace(/"$/, "").trim(); + if (propName === "Content" && propValue === ",") { + propValue = contentLine.replace(/"/g, "").replace(/,$/, "").trim(); + } + const currentNode = this.getCurrentNode(); + const parentName = currentNode.name; + if (parentName === "Properties70") { + this.parseNodeSpecialProperty(line, propName, propValue); + return; + } + if (propName === "C") { + const connProps = propValue.split(",").slice(1); + const from = parseInt(connProps[0]); + const to = parseInt(connProps[1]); + let rest = propValue.split(",").slice(3); + rest = rest.map(function(elem) { + return elem.trim().replace(/^"/, ""); + }); + propName = "connections"; + propValue = [from, to]; + append(propValue, rest); + if (currentNode[propName] === void 0) { + currentNode[propName] = []; + } + } + if (propName === "Node") currentNode.id = propValue; + if (propName in currentNode && Array.isArray(currentNode[propName])) { + currentNode[propName].push(propValue); + } else { + if (propName !== "a") currentNode[propName] = propValue; + else currentNode.a = propValue; + } + this.setCurrentProp(currentNode, propName); + if (propName === "a" && propValue.slice(-1) !== ",") { + currentNode.a = parseNumberArray(propValue); + } + } + parseNodePropertyContinued(line) { + const currentNode = this.getCurrentNode(); + currentNode.a += line; + if (line.slice(-1) !== ",") { + currentNode.a = parseNumberArray(currentNode.a); + } + } + // parse "Property70" + parseNodeSpecialProperty(line, propName, propValue) { + const props = propValue.split('",').map(function(prop) { + return prop.trim().replace(/^\"/, "").replace(/\s/, "_"); + }); + const innerPropName = props[0]; + const innerPropType1 = props[1]; + const innerPropType2 = props[2]; + const innerPropFlag = props[3]; + let innerPropValue = props[4]; + switch (innerPropType1) { + case "int": + case "enum": + case "bool": + case "ULongLong": + case "double": + case "Number": + case "FieldOfView": + innerPropValue = parseFloat(innerPropValue); + break; + case "Color": + case "ColorRGB": + case "Vector3D": + case "Lcl_Translation": + case "Lcl_Rotation": + case "Lcl_Scaling": + innerPropValue = parseNumberArray(innerPropValue); + break; + } + this.getPrevNode()[innerPropName] = { + "type": innerPropType1, + "type2": innerPropType2, + "flag": innerPropFlag, + "value": innerPropValue + }; + this.setCurrentProp(this.getPrevNode(), innerPropName); + } +}; +var BinaryParser = class { + parse(buffer) { + const reader = new BinaryReader(buffer); + reader.skip(23); + const version = reader.getUint32(); + if (version < 6400) { + throw new Error("THREE.FBXLoader: FBX version not supported, FileVersion: " + version); + } + const allNodes = new FBXTree(); + while (!this.endOfContent(reader)) { + const node = this.parseNode(reader, version); + if (node !== null) allNodes.add(node.name, node); + } + return allNodes; + } + // Check if reader has reached the end of content. + endOfContent(reader) { + if (reader.size() % 16 === 0) { + return (reader.getOffset() + 160 + 16 & ~15) >= reader.size(); + } else { + return reader.getOffset() + 160 + 16 >= reader.size(); + } + } + // recursively parse nodes until the end of the file is reached + parseNode(reader, version) { + const node = {}; + const endOffset = version >= 7500 ? reader.getUint64() : reader.getUint32(); + const numProperties = version >= 7500 ? reader.getUint64() : reader.getUint32(); + version >= 7500 ? reader.getUint64() : reader.getUint32(); + const nameLen = reader.getUint8(); + const name = reader.getString(nameLen); + if (endOffset === 0) return null; + const propertyList = []; + for (let i = 0; i < numProperties; i++) { + propertyList.push(this.parseProperty(reader)); + } + const id = propertyList.length > 0 ? propertyList[0] : ""; + const attrName = propertyList.length > 1 ? propertyList[1] : ""; + const attrType = propertyList.length > 2 ? propertyList[2] : ""; + node.singleProperty = numProperties === 1 && reader.getOffset() === endOffset ? true : false; + while (endOffset > reader.getOffset()) { + const subNode = this.parseNode(reader, version); + if (subNode !== null) this.parseSubNode(name, node, subNode); + } + node.propertyList = propertyList; + if (typeof id === "number") node.id = id; + if (attrName !== "") node.attrName = attrName; + if (attrType !== "") node.attrType = attrType; + if (name !== "") node.name = name; + return node; + } + parseSubNode(name, node, subNode) { + if (subNode.singleProperty === true) { + const value = subNode.propertyList[0]; + if (Array.isArray(value)) { + node[subNode.name] = subNode; + subNode.a = value; + } else { + node[subNode.name] = value; + } + } else if (name === "Connections" && subNode.name === "C") { + const array = []; + subNode.propertyList.forEach(function(property, i) { + if (i !== 0) array.push(property); + }); + if (node.connections === void 0) { + node.connections = []; + } + node.connections.push(array); + } else if (subNode.name === "Properties70") { + const keys = Object.keys(subNode); + keys.forEach(function(key) { + node[key] = subNode[key]; + }); + } else if (name === "Properties70" && subNode.name === "P") { + let innerPropName = subNode.propertyList[0]; + let innerPropType1 = subNode.propertyList[1]; + const innerPropType2 = subNode.propertyList[2]; + const innerPropFlag = subNode.propertyList[3]; + let innerPropValue; + if (innerPropName.indexOf("Lcl ") === 0) innerPropName = innerPropName.replace("Lcl ", "Lcl_"); + if (innerPropType1.indexOf("Lcl ") === 0) innerPropType1 = innerPropType1.replace("Lcl ", "Lcl_"); + if (innerPropType1 === "Color" || innerPropType1 === "ColorRGB" || innerPropType1 === "Vector" || innerPropType1 === "Vector3D" || innerPropType1.indexOf("Lcl_") === 0) { + innerPropValue = [ + subNode.propertyList[4], + subNode.propertyList[5], + subNode.propertyList[6] + ]; + } else { + innerPropValue = subNode.propertyList[4]; + } + node[innerPropName] = { + "type": innerPropType1, + "type2": innerPropType2, + "flag": innerPropFlag, + "value": innerPropValue + }; + } else if (node[subNode.name] === void 0) { + if (typeof subNode.id === "number") { + node[subNode.name] = {}; + node[subNode.name][subNode.id] = subNode; + } else { + node[subNode.name] = subNode; + } + } else { + if (subNode.name === "PoseNode") { + if (!Array.isArray(node[subNode.name])) { + node[subNode.name] = [node[subNode.name]]; + } + node[subNode.name].push(subNode); + } else if (node[subNode.name][subNode.id] === void 0) { + node[subNode.name][subNode.id] = subNode; + } + } + } + parseProperty(reader) { + const type = reader.getString(1); + let length; + switch (type) { + case "C": + return reader.getBoolean(); + case "D": + return reader.getFloat64(); + case "F": + return reader.getFloat32(); + case "I": + return reader.getInt32(); + case "L": + return reader.getInt64(); + case "R": + length = reader.getUint32(); + return reader.getArrayBuffer(length); + case "S": + length = reader.getUint32(); + return reader.getString(length); + case "Y": + return reader.getInt16(); + case "b": + case "c": + case "d": + case "f": + case "i": + case "l": + const arrayLength = reader.getUint32(); + const encoding = reader.getUint32(); + const compressedLength = reader.getUint32(); + if (encoding === 0) { + switch (type) { + case "b": + case "c": + return reader.getBooleanArray(arrayLength); + case "d": + return reader.getFloat64Array(arrayLength); + case "f": + return reader.getFloat32Array(arrayLength); + case "i": + return reader.getInt32Array(arrayLength); + case "l": + return reader.getInt64Array(arrayLength); + } + } + const data = unzlibSync(new Uint8Array(reader.getArrayBuffer(compressedLength))); + const reader2 = new BinaryReader(data.buffer); + switch (type) { + case "b": + case "c": + return reader2.getBooleanArray(arrayLength); + case "d": + return reader2.getFloat64Array(arrayLength); + case "f": + return reader2.getFloat32Array(arrayLength); + case "i": + return reader2.getInt32Array(arrayLength); + case "l": + return reader2.getInt64Array(arrayLength); + } + break; + // cannot happen but is required by the DeepScan + default: + throw new Error("THREE.FBXLoader: Unknown property type " + type); + } + } +}; +var BinaryReader = class { + constructor(buffer, littleEndian) { + this.dv = new DataView(buffer); + this.offset = 0; + this.littleEndian = littleEndian !== void 0 ? littleEndian : true; + this._textDecoder = new TextDecoder(); + } + getOffset() { + return this.offset; + } + size() { + return this.dv.buffer.byteLength; + } + skip(length) { + this.offset += length; + } + // seems like true/false representation depends on exporter. + // true: 1 or 'Y'(=0x59), false: 0 or 'T'(=0x54) + // then sees LSB. + getBoolean() { + return (this.getUint8() & 1) === 1; + } + getBooleanArray(size) { + const a = []; + for (let i = 0; i < size; i++) { + a.push(this.getBoolean()); + } + return a; + } + getUint8() { + const value = this.dv.getUint8(this.offset); + this.offset += 1; + return value; + } + getInt16() { + const value = this.dv.getInt16(this.offset, this.littleEndian); + this.offset += 2; + return value; + } + getInt32() { + const value = this.dv.getInt32(this.offset, this.littleEndian); + this.offset += 4; + return value; + } + getInt32Array(size) { + const a = []; + for (let i = 0; i < size; i++) { + a.push(this.getInt32()); + } + return a; + } + getUint32() { + const value = this.dv.getUint32(this.offset, this.littleEndian); + this.offset += 4; + return value; + } + // JavaScript doesn't support 64-bit integer so calculate this here + // 1 << 32 will return 1 so using multiply operation instead here. + // There's a possibility that this method returns wrong value if the value + // is out of the range between Number.MAX_SAFE_INTEGER and Number.MIN_SAFE_INTEGER. + // TODO: safely handle 64-bit integer + getInt64() { + let low, high; + if (this.littleEndian) { + low = this.getUint32(); + high = this.getUint32(); + } else { + high = this.getUint32(); + low = this.getUint32(); + } + if (high & 2147483648) { + high = ~high & 4294967295; + low = ~low & 4294967295; + if (low === 4294967295) high = high + 1 & 4294967295; + low = low + 1 & 4294967295; + return -(high * 4294967296 + low); + } + return high * 4294967296 + low; + } + getInt64Array(size) { + const a = []; + for (let i = 0; i < size; i++) { + a.push(this.getInt64()); + } + return a; + } + // Note: see getInt64() comment + getUint64() { + let low, high; + if (this.littleEndian) { + low = this.getUint32(); + high = this.getUint32(); + } else { + high = this.getUint32(); + low = this.getUint32(); + } + return high * 4294967296 + low; + } + getFloat32() { + const value = this.dv.getFloat32(this.offset, this.littleEndian); + this.offset += 4; + return value; + } + getFloat32Array(size) { + const a = []; + for (let i = 0; i < size; i++) { + a.push(this.getFloat32()); + } + return a; + } + getFloat64() { + const value = this.dv.getFloat64(this.offset, this.littleEndian); + this.offset += 8; + return value; + } + getFloat64Array(size) { + const a = []; + for (let i = 0; i < size; i++) { + a.push(this.getFloat64()); + } + return a; + } + getArrayBuffer(size) { + const value = this.dv.buffer.slice(this.offset, this.offset + size); + this.offset += size; + return value; + } + getString(size) { + const start = this.offset; + let a = new Uint8Array(this.dv.buffer, start, size); + this.skip(size); + const nullByte = a.indexOf(0); + if (nullByte >= 0) a = new Uint8Array(this.dv.buffer, start, nullByte); + return this._textDecoder.decode(a); + } +}; +var FBXTree = class { + add(key, val) { + this[key] = val; + } +}; +function isFbxFormatBinary(buffer) { + const CORRECT = "Kaydara FBX Binary \0"; + return buffer.byteLength >= CORRECT.length && CORRECT === convertArrayBufferToString(buffer, 0, CORRECT.length); +} +function isFbxFormatASCII(text) { + const CORRECT = ["K", "a", "y", "d", "a", "r", "a", "\\", "F", "B", "X", "\\", "B", "i", "n", "a", "r", "y", "\\", "\\"]; + let cursor = 0; + function read(offset) { + const result = text[offset - 1]; + text = text.slice(cursor + offset); + cursor++; + return result; + } + for (let i = 0; i < CORRECT.length; ++i) { + const num = read(1); + if (num === CORRECT[i]) { + return false; + } + } + return true; +} +function getFbxVersion(text) { + const versionRegExp = /FBXVersion: (\d+)/; + const match = text.match(versionRegExp); + if (match) { + const version = parseInt(match[1]); + return version; + } + throw new Error("THREE.FBXLoader: Cannot find the version number for the file given."); +} +function convertFBXTimeToSeconds(time) { + return time / 46186158e3; +} +var dataArray = []; +function getData(polygonVertexIndex, polygonIndex, vertexIndex, infoObject) { + let index; + switch (infoObject.mappingType) { + case "ByPolygonVertex": + index = polygonVertexIndex; + break; + case "ByPolygon": + index = polygonIndex; + break; + case "ByVertice": + index = vertexIndex; + break; + case "AllSame": + index = infoObject.indices[0]; + break; + default: + console.warn("THREE.FBXLoader: unknown attribute mapping type " + infoObject.mappingType); + } + if (infoObject.referenceType === "IndexToDirect") index = infoObject.indices[index]; + const from = index * infoObject.dataSize; + const to = from + infoObject.dataSize; + return slice(dataArray, infoObject.buffer, from, to); +} +var tempEuler = new Euler(); +var tempVec = new Vector3(); +function generateTransform(transformData) { + const lTranslationM = new Matrix4(); + const lPreRotationM = new Matrix4(); + const lRotationM = new Matrix4(); + const lPostRotationM = new Matrix4(); + const lScalingM = new Matrix4(); + const lScalingPivotM = new Matrix4(); + const lScalingOffsetM = new Matrix4(); + const lRotationOffsetM = new Matrix4(); + const lRotationPivotM = new Matrix4(); + const lParentGX = new Matrix4(); + const lParentLX = new Matrix4(); + const lGlobalT = new Matrix4(); + const inheritType = transformData.inheritType ? transformData.inheritType : 0; + if (transformData.translation) lTranslationM.setPosition(tempVec.fromArray(transformData.translation)); + if (transformData.preRotation) { + const array = transformData.preRotation.map(MathUtils.degToRad); + array.push(transformData.eulerOrder || Euler.DEFAULT_ORDER); + lPreRotationM.makeRotationFromEuler(tempEuler.fromArray(array)); + } + if (transformData.rotation) { + const array = transformData.rotation.map(MathUtils.degToRad); + array.push(transformData.eulerOrder || Euler.DEFAULT_ORDER); + lRotationM.makeRotationFromEuler(tempEuler.fromArray(array)); + } + if (transformData.postRotation) { + const array = transformData.postRotation.map(MathUtils.degToRad); + array.push(transformData.eulerOrder || Euler.DEFAULT_ORDER); + lPostRotationM.makeRotationFromEuler(tempEuler.fromArray(array)); + lPostRotationM.invert(); + } + if (transformData.scale) lScalingM.scale(tempVec.fromArray(transformData.scale)); + if (transformData.scalingOffset) lScalingOffsetM.setPosition(tempVec.fromArray(transformData.scalingOffset)); + if (transformData.scalingPivot) lScalingPivotM.setPosition(tempVec.fromArray(transformData.scalingPivot)); + if (transformData.rotationOffset) lRotationOffsetM.setPosition(tempVec.fromArray(transformData.rotationOffset)); + if (transformData.rotationPivot) lRotationPivotM.setPosition(tempVec.fromArray(transformData.rotationPivot)); + if (transformData.parentMatrixWorld) { + lParentLX.copy(transformData.parentMatrix); + lParentGX.copy(transformData.parentMatrixWorld); + } + const lLRM = lPreRotationM.clone().multiply(lRotationM).multiply(lPostRotationM); + const lParentGRM = new Matrix4(); + lParentGRM.extractRotation(lParentGX); + const lParentTM = new Matrix4(); + lParentTM.copyPosition(lParentGX); + const lParentGRSM = lParentTM.clone().invert().multiply(lParentGX); + const lParentGSM = lParentGRM.clone().invert().multiply(lParentGRSM); + const lLSM = lScalingM; + const lGlobalRS = new Matrix4(); + if (inheritType === 0) { + lGlobalRS.copy(lParentGRM).multiply(lLRM).multiply(lParentGSM).multiply(lLSM); + } else if (inheritType === 1) { + lGlobalRS.copy(lParentGRM).multiply(lParentGSM).multiply(lLRM).multiply(lLSM); + } else { + const lParentLSM = new Matrix4().scale(new Vector3().setFromMatrixScale(lParentLX)); + const lParentLSM_inv = lParentLSM.clone().invert(); + const lParentGSM_noLocal = lParentGSM.clone().multiply(lParentLSM_inv); + lGlobalRS.copy(lParentGRM).multiply(lLRM).multiply(lParentGSM_noLocal).multiply(lLSM); + } + const lRotationPivotM_inv = lRotationPivotM.clone().invert(); + const lScalingPivotM_inv = lScalingPivotM.clone().invert(); + let lTransform = lTranslationM.clone().multiply(lRotationOffsetM).multiply(lRotationPivotM).multiply(lPreRotationM).multiply(lRotationM).multiply(lPostRotationM).multiply(lRotationPivotM_inv).multiply(lScalingOffsetM).multiply(lScalingPivotM).multiply(lScalingM).multiply(lScalingPivotM_inv); + const lLocalTWithAllPivotAndOffsetInfo = new Matrix4().copyPosition(lTransform); + const lGlobalTranslation = lParentGX.clone().multiply(lLocalTWithAllPivotAndOffsetInfo); + lGlobalT.copyPosition(lGlobalTranslation); + lTransform = lGlobalT.clone().multiply(lGlobalRS); + lTransform.premultiply(lParentGX.invert()); + return lTransform; +} +function getEulerOrder(order) { + order = order || 0; + const enums = [ + "ZYX", + // -> XYZ extrinsic + "YZX", + // -> XZY extrinsic + "XZY", + // -> YZX extrinsic + "ZXY", + // -> YXZ extrinsic + "YXZ", + // -> ZXY extrinsic + "XYZ" + // -> ZYX extrinsic + //'SphericXYZ', // not possible to support + ]; + if (order === 6) { + console.warn("THREE.FBXLoader: unsupported Euler Order: Spherical XYZ. Animations and rotations may be incorrect."); + return enums[0]; + } + return enums[order]; +} +function parseNumberArray(value) { + const array = value.split(",").map(function(val) { + return parseFloat(val); + }); + return array; +} +function convertArrayBufferToString(buffer, from, to) { + if (from === void 0) from = 0; + if (to === void 0) to = buffer.byteLength; + return new TextDecoder().decode(new Uint8Array(buffer, from, to)); +} +function append(a, b) { + for (let i = 0, j = a.length, l = b.length; i < l; i++, j++) { + a[j] = b[i]; + } +} +function slice(a, b, from, to) { + for (let i = from, j = 0; i < to; i++, j++) { + a[j] = b[i]; + } + return a; +} + +// ../../node_modules/three/examples/jsm/utils/BufferGeometryUtils.js +function toTrianglesDrawMode(geometry, drawMode) { + if (drawMode === TrianglesDrawMode) { + console.warn("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Geometry already defined as triangles."); + return geometry; + } + if (drawMode === TriangleFanDrawMode || drawMode === TriangleStripDrawMode) { + let index = geometry.getIndex(); + if (index === null) { + const indices = []; + const position = geometry.getAttribute("position"); + if (position !== void 0) { + for (let i = 0; i < position.count; i++) { + indices.push(i); + } + geometry.setIndex(indices); + index = geometry.getIndex(); + } else { + console.error("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Undefined position attribute. Processing not possible."); + return geometry; + } + } + const numberOfTriangles = index.count - 2; + const newIndices = []; + if (drawMode === TriangleFanDrawMode) { + for (let i = 1; i <= numberOfTriangles; i++) { + newIndices.push(index.getX(0)); + newIndices.push(index.getX(i)); + newIndices.push(index.getX(i + 1)); + } + } else { + for (let i = 0; i < numberOfTriangles; i++) { + if (i % 2 === 0) { + newIndices.push(index.getX(i)); + newIndices.push(index.getX(i + 1)); + newIndices.push(index.getX(i + 2)); + } else { + newIndices.push(index.getX(i + 2)); + newIndices.push(index.getX(i + 1)); + newIndices.push(index.getX(i)); + } + } + } + if (newIndices.length / 3 !== numberOfTriangles) { + console.error("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Unable to generate correct amount of triangles."); + } + const newGeometry = geometry.clone(); + newGeometry.setIndex(newIndices); + newGeometry.clearGroups(); + return newGeometry; + } else { + console.error("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Unknown draw mode:", drawMode); + return geometry; + } +} + +// ../../node_modules/three/examples/jsm/loaders/GLTFLoader.js +var GLTFLoader = class extends Loader { + constructor(manager) { + super(manager); + this.dracoLoader = null; + this.ktx2Loader = null; + this.meshoptDecoder = null; + this.pluginCallbacks = []; + this.register(function(parser) { + return new GLTFMaterialsClearcoatExtension(parser); + }); + this.register(function(parser) { + return new GLTFTextureBasisUExtension(parser); + }); + this.register(function(parser) { + return new GLTFTextureWebPExtension(parser); + }); + this.register(function(parser) { + return new GLTFTextureAVIFExtension(parser); + }); + this.register(function(parser) { + return new GLTFMaterialsSheenExtension(parser); + }); + this.register(function(parser) { + return new GLTFMaterialsTransmissionExtension(parser); + }); + this.register(function(parser) { + return new GLTFMaterialsVolumeExtension(parser); + }); + this.register(function(parser) { + return new GLTFMaterialsIorExtension(parser); + }); + this.register(function(parser) { + return new GLTFMaterialsEmissiveStrengthExtension(parser); + }); + this.register(function(parser) { + return new GLTFMaterialsSpecularExtension(parser); + }); + this.register(function(parser) { + return new GLTFMaterialsIridescenceExtension(parser); + }); + this.register(function(parser) { + return new GLTFMaterialsAnisotropyExtension(parser); + }); + this.register(function(parser) { + return new GLTFMaterialsBumpExtension(parser); + }); + this.register(function(parser) { + return new GLTFLightsExtension(parser); + }); + this.register(function(parser) { + return new GLTFMeshoptCompression(parser); + }); + this.register(function(parser) { + return new GLTFMeshGpuInstancing(parser); + }); + } + load(url, onLoad, onProgress, onError) { + const scope = this; + let resourcePath; + if (this.resourcePath !== "") { + resourcePath = this.resourcePath; + } else if (this.path !== "") { + const relativeUrl = LoaderUtils.extractUrlBase(url); + resourcePath = LoaderUtils.resolveURL(relativeUrl, this.path); + } else { + resourcePath = LoaderUtils.extractUrlBase(url); + } + this.manager.itemStart(url); + const _onError = function(e) { + if (onError) { + onError(e); + } else { + console.error(e); + } + scope.manager.itemError(url); + scope.manager.itemEnd(url); + }; + const loader = new FileLoader(this.manager); + loader.setPath(this.path); + loader.setResponseType("arraybuffer"); + loader.setRequestHeader(this.requestHeader); + loader.setWithCredentials(this.withCredentials); + loader.load(url, function(data) { + try { + scope.parse(data, resourcePath, function(gltf) { + onLoad(gltf); + scope.manager.itemEnd(url); + }, _onError); + } catch (e) { + _onError(e); + } + }, onProgress, _onError); + } + setDRACOLoader(dracoLoader) { + this.dracoLoader = dracoLoader; + return this; + } + setDDSLoader() { + throw new Error( + 'THREE.GLTFLoader: "MSFT_texture_dds" no longer supported. Please update to "KHR_texture_basisu".' + ); + } + setKTX2Loader(ktx2Loader) { + this.ktx2Loader = ktx2Loader; + return this; + } + setMeshoptDecoder(meshoptDecoder) { + this.meshoptDecoder = meshoptDecoder; + return this; + } + register(callback) { + if (this.pluginCallbacks.indexOf(callback) === -1) { + this.pluginCallbacks.push(callback); + } + return this; + } + unregister(callback) { + if (this.pluginCallbacks.indexOf(callback) !== -1) { + this.pluginCallbacks.splice(this.pluginCallbacks.indexOf(callback), 1); + } + return this; + } + parse(data, path, onLoad, onError) { + let json; + const extensions = {}; + const plugins = {}; + const textDecoder2 = new TextDecoder(); + if (typeof data === "string") { + json = JSON.parse(data); + } else if (data instanceof ArrayBuffer) { + const magic = textDecoder2.decode(new Uint8Array(data, 0, 4)); + if (magic === BINARY_EXTENSION_HEADER_MAGIC) { + try { + extensions[EXTENSIONS.KHR_BINARY_GLTF] = new GLTFBinaryExtension(data); + } catch (error) { + if (onError) onError(error); + return; + } + json = JSON.parse(extensions[EXTENSIONS.KHR_BINARY_GLTF].content); + } else { + json = JSON.parse(textDecoder2.decode(data)); + } + } else { + json = data; + } + if (json.asset === void 0 || json.asset.version[0] < 2) { + if (onError) onError(new Error("THREE.GLTFLoader: Unsupported asset. glTF versions >=2.0 are supported.")); + return; + } + const parser = new GLTFParser(json, { + path: path || this.resourcePath || "", + crossOrigin: this.crossOrigin, + requestHeader: this.requestHeader, + manager: this.manager, + ktx2Loader: this.ktx2Loader, + meshoptDecoder: this.meshoptDecoder + }); + parser.fileLoader.setRequestHeader(this.requestHeader); + for (let i = 0; i < this.pluginCallbacks.length; i++) { + const plugin = this.pluginCallbacks[i](parser); + if (!plugin.name) console.error("THREE.GLTFLoader: Invalid plugin found: missing name"); + plugins[plugin.name] = plugin; + extensions[plugin.name] = true; + } + if (json.extensionsUsed) { + for (let i = 0; i < json.extensionsUsed.length; ++i) { + const extensionName = json.extensionsUsed[i]; + const extensionsRequired = json.extensionsRequired || []; + switch (extensionName) { + case EXTENSIONS.KHR_MATERIALS_UNLIT: + extensions[extensionName] = new GLTFMaterialsUnlitExtension(); + break; + case EXTENSIONS.KHR_DRACO_MESH_COMPRESSION: + extensions[extensionName] = new GLTFDracoMeshCompressionExtension(json, this.dracoLoader); + break; + case EXTENSIONS.KHR_TEXTURE_TRANSFORM: + extensions[extensionName] = new GLTFTextureTransformExtension(); + break; + case EXTENSIONS.KHR_MESH_QUANTIZATION: + extensions[extensionName] = new GLTFMeshQuantizationExtension(); + break; + default: + if (extensionsRequired.indexOf(extensionName) >= 0 && plugins[extensionName] === void 0) { + console.warn('THREE.GLTFLoader: Unknown extension "' + extensionName + '".'); + } + } + } + } + parser.setExtensions(extensions); + parser.setPlugins(plugins); + parser.parse(onLoad, onError); + } + parseAsync(data, path) { + const scope = this; + return new Promise(function(resolve, reject) { + scope.parse(data, path, resolve, reject); + }); + } +}; +function GLTFRegistry() { + let objects = {}; + return { + get: function(key) { + return objects[key]; + }, + add: function(key, object) { + objects[key] = object; + }, + remove: function(key) { + delete objects[key]; + }, + removeAll: function() { + objects = {}; + } + }; +} +var EXTENSIONS = { + KHR_BINARY_GLTF: "KHR_binary_glTF", + KHR_DRACO_MESH_COMPRESSION: "KHR_draco_mesh_compression", + KHR_LIGHTS_PUNCTUAL: "KHR_lights_punctual", + KHR_MATERIALS_CLEARCOAT: "KHR_materials_clearcoat", + KHR_MATERIALS_IOR: "KHR_materials_ior", + KHR_MATERIALS_SHEEN: "KHR_materials_sheen", + KHR_MATERIALS_SPECULAR: "KHR_materials_specular", + KHR_MATERIALS_TRANSMISSION: "KHR_materials_transmission", + KHR_MATERIALS_IRIDESCENCE: "KHR_materials_iridescence", + KHR_MATERIALS_ANISOTROPY: "KHR_materials_anisotropy", + KHR_MATERIALS_UNLIT: "KHR_materials_unlit", + KHR_MATERIALS_VOLUME: "KHR_materials_volume", + KHR_TEXTURE_BASISU: "KHR_texture_basisu", + KHR_TEXTURE_TRANSFORM: "KHR_texture_transform", + KHR_MESH_QUANTIZATION: "KHR_mesh_quantization", + KHR_MATERIALS_EMISSIVE_STRENGTH: "KHR_materials_emissive_strength", + EXT_MATERIALS_BUMP: "EXT_materials_bump", + EXT_TEXTURE_WEBP: "EXT_texture_webp", + EXT_TEXTURE_AVIF: "EXT_texture_avif", + EXT_MESHOPT_COMPRESSION: "EXT_meshopt_compression", + EXT_MESH_GPU_INSTANCING: "EXT_mesh_gpu_instancing" +}; +var GLTFLightsExtension = class { + constructor(parser) { + this.parser = parser; + this.name = EXTENSIONS.KHR_LIGHTS_PUNCTUAL; + this.cache = { refs: {}, uses: {} }; + } + _markDefs() { + const parser = this.parser; + const nodeDefs = this.parser.json.nodes || []; + for (let nodeIndex = 0, nodeLength = nodeDefs.length; nodeIndex < nodeLength; nodeIndex++) { + const nodeDef = nodeDefs[nodeIndex]; + if (nodeDef.extensions && nodeDef.extensions[this.name] && nodeDef.extensions[this.name].light !== void 0) { + parser._addNodeRef(this.cache, nodeDef.extensions[this.name].light); + } + } + } + _loadLight(lightIndex) { + const parser = this.parser; + const cacheKey = "light:" + lightIndex; + let dependency = parser.cache.get(cacheKey); + if (dependency) return dependency; + const json = parser.json; + const extensions = json.extensions && json.extensions[this.name] || {}; + const lightDefs = extensions.lights || []; + const lightDef = lightDefs[lightIndex]; + let lightNode; + const color = new Color(16777215); + if (lightDef.color !== void 0) color.setRGB(lightDef.color[0], lightDef.color[1], lightDef.color[2], LinearSRGBColorSpace); + const range = lightDef.range !== void 0 ? lightDef.range : 0; + switch (lightDef.type) { + case "directional": + lightNode = new DirectionalLight(color); + lightNode.target.position.set(0, 0, -1); + lightNode.add(lightNode.target); + break; + case "point": + lightNode = new PointLight(color); + lightNode.distance = range; + break; + case "spot": + lightNode = new SpotLight(color); + lightNode.distance = range; + lightDef.spot = lightDef.spot || {}; + lightDef.spot.innerConeAngle = lightDef.spot.innerConeAngle !== void 0 ? lightDef.spot.innerConeAngle : 0; + lightDef.spot.outerConeAngle = lightDef.spot.outerConeAngle !== void 0 ? lightDef.spot.outerConeAngle : Math.PI / 4; + lightNode.angle = lightDef.spot.outerConeAngle; + lightNode.penumbra = 1 - lightDef.spot.innerConeAngle / lightDef.spot.outerConeAngle; + lightNode.target.position.set(0, 0, -1); + lightNode.add(lightNode.target); + break; + default: + throw new Error("THREE.GLTFLoader: Unexpected light type: " + lightDef.type); + } + lightNode.position.set(0, 0, 0); + lightNode.decay = 2; + assignExtrasToUserData(lightNode, lightDef); + if (lightDef.intensity !== void 0) lightNode.intensity = lightDef.intensity; + lightNode.name = parser.createUniqueName(lightDef.name || "light_" + lightIndex); + dependency = Promise.resolve(lightNode); + parser.cache.add(cacheKey, dependency); + return dependency; + } + getDependency(type, index) { + if (type !== "light") return; + return this._loadLight(index); + } + createNodeAttachment(nodeIndex) { + const self2 = this; + const parser = this.parser; + const json = parser.json; + const nodeDef = json.nodes[nodeIndex]; + const lightDef = nodeDef.extensions && nodeDef.extensions[this.name] || {}; + const lightIndex = lightDef.light; + if (lightIndex === void 0) return null; + return this._loadLight(lightIndex).then(function(light) { + return parser._getNodeRef(self2.cache, lightIndex, light); + }); + } +}; +var GLTFMaterialsUnlitExtension = class { + constructor() { + this.name = EXTENSIONS.KHR_MATERIALS_UNLIT; + } + getMaterialType() { + return MeshBasicMaterial; + } + extendParams(materialParams, materialDef, parser) { + const pending = []; + materialParams.color = new Color(1, 1, 1); + materialParams.opacity = 1; + const metallicRoughness = materialDef.pbrMetallicRoughness; + if (metallicRoughness) { + if (Array.isArray(metallicRoughness.baseColorFactor)) { + const array = metallicRoughness.baseColorFactor; + materialParams.color.setRGB(array[0], array[1], array[2], LinearSRGBColorSpace); + materialParams.opacity = array[3]; + } + if (metallicRoughness.baseColorTexture !== void 0) { + pending.push(parser.assignTexture(materialParams, "map", metallicRoughness.baseColorTexture, SRGBColorSpace)); + } + } + return Promise.all(pending); + } +}; +var GLTFMaterialsEmissiveStrengthExtension = class { + constructor(parser) { + this.parser = parser; + this.name = EXTENSIONS.KHR_MATERIALS_EMISSIVE_STRENGTH; + } + extendMaterialParams(materialIndex, materialParams) { + const parser = this.parser; + const materialDef = parser.json.materials[materialIndex]; + if (!materialDef.extensions || !materialDef.extensions[this.name]) { + return Promise.resolve(); + } + const emissiveStrength = materialDef.extensions[this.name].emissiveStrength; + if (emissiveStrength !== void 0) { + materialParams.emissiveIntensity = emissiveStrength; + } + return Promise.resolve(); + } +}; +var GLTFMaterialsClearcoatExtension = class { + constructor(parser) { + this.parser = parser; + this.name = EXTENSIONS.KHR_MATERIALS_CLEARCOAT; + } + getMaterialType(materialIndex) { + const parser = this.parser; + const materialDef = parser.json.materials[materialIndex]; + if (!materialDef.extensions || !materialDef.extensions[this.name]) return null; + return MeshPhysicalMaterial; + } + extendMaterialParams(materialIndex, materialParams) { + const parser = this.parser; + const materialDef = parser.json.materials[materialIndex]; + if (!materialDef.extensions || !materialDef.extensions[this.name]) { + return Promise.resolve(); + } + const pending = []; + const extension = materialDef.extensions[this.name]; + if (extension.clearcoatFactor !== void 0) { + materialParams.clearcoat = extension.clearcoatFactor; + } + if (extension.clearcoatTexture !== void 0) { + pending.push(parser.assignTexture(materialParams, "clearcoatMap", extension.clearcoatTexture)); + } + if (extension.clearcoatRoughnessFactor !== void 0) { + materialParams.clearcoatRoughness = extension.clearcoatRoughnessFactor; + } + if (extension.clearcoatRoughnessTexture !== void 0) { + pending.push(parser.assignTexture(materialParams, "clearcoatRoughnessMap", extension.clearcoatRoughnessTexture)); + } + if (extension.clearcoatNormalTexture !== void 0) { + pending.push(parser.assignTexture(materialParams, "clearcoatNormalMap", extension.clearcoatNormalTexture)); + if (extension.clearcoatNormalTexture.scale !== void 0) { + const scale = extension.clearcoatNormalTexture.scale; + materialParams.clearcoatNormalScale = new Vector2(scale, scale); + } + } + return Promise.all(pending); + } +}; +var GLTFMaterialsIridescenceExtension = class { + constructor(parser) { + this.parser = parser; + this.name = EXTENSIONS.KHR_MATERIALS_IRIDESCENCE; + } + getMaterialType(materialIndex) { + const parser = this.parser; + const materialDef = parser.json.materials[materialIndex]; + if (!materialDef.extensions || !materialDef.extensions[this.name]) return null; + return MeshPhysicalMaterial; + } + extendMaterialParams(materialIndex, materialParams) { + const parser = this.parser; + const materialDef = parser.json.materials[materialIndex]; + if (!materialDef.extensions || !materialDef.extensions[this.name]) { + return Promise.resolve(); + } + const pending = []; + const extension = materialDef.extensions[this.name]; + if (extension.iridescenceFactor !== void 0) { + materialParams.iridescence = extension.iridescenceFactor; + } + if (extension.iridescenceTexture !== void 0) { + pending.push(parser.assignTexture(materialParams, "iridescenceMap", extension.iridescenceTexture)); + } + if (extension.iridescenceIor !== void 0) { + materialParams.iridescenceIOR = extension.iridescenceIor; + } + if (materialParams.iridescenceThicknessRange === void 0) { + materialParams.iridescenceThicknessRange = [100, 400]; + } + if (extension.iridescenceThicknessMinimum !== void 0) { + materialParams.iridescenceThicknessRange[0] = extension.iridescenceThicknessMinimum; + } + if (extension.iridescenceThicknessMaximum !== void 0) { + materialParams.iridescenceThicknessRange[1] = extension.iridescenceThicknessMaximum; + } + if (extension.iridescenceThicknessTexture !== void 0) { + pending.push(parser.assignTexture(materialParams, "iridescenceThicknessMap", extension.iridescenceThicknessTexture)); + } + return Promise.all(pending); + } +}; +var GLTFMaterialsSheenExtension = class { + constructor(parser) { + this.parser = parser; + this.name = EXTENSIONS.KHR_MATERIALS_SHEEN; + } + getMaterialType(materialIndex) { + const parser = this.parser; + const materialDef = parser.json.materials[materialIndex]; + if (!materialDef.extensions || !materialDef.extensions[this.name]) return null; + return MeshPhysicalMaterial; + } + extendMaterialParams(materialIndex, materialParams) { + const parser = this.parser; + const materialDef = parser.json.materials[materialIndex]; + if (!materialDef.extensions || !materialDef.extensions[this.name]) { + return Promise.resolve(); + } + const pending = []; + materialParams.sheenColor = new Color(0, 0, 0); + materialParams.sheenRoughness = 0; + materialParams.sheen = 1; + const extension = materialDef.extensions[this.name]; + if (extension.sheenColorFactor !== void 0) { + const colorFactor = extension.sheenColorFactor; + materialParams.sheenColor.setRGB(colorFactor[0], colorFactor[1], colorFactor[2], LinearSRGBColorSpace); + } + if (extension.sheenRoughnessFactor !== void 0) { + materialParams.sheenRoughness = extension.sheenRoughnessFactor; + } + if (extension.sheenColorTexture !== void 0) { + pending.push(parser.assignTexture(materialParams, "sheenColorMap", extension.sheenColorTexture, SRGBColorSpace)); + } + if (extension.sheenRoughnessTexture !== void 0) { + pending.push(parser.assignTexture(materialParams, "sheenRoughnessMap", extension.sheenRoughnessTexture)); + } + return Promise.all(pending); + } +}; +var GLTFMaterialsTransmissionExtension = class { + constructor(parser) { + this.parser = parser; + this.name = EXTENSIONS.KHR_MATERIALS_TRANSMISSION; + } + getMaterialType(materialIndex) { + const parser = this.parser; + const materialDef = parser.json.materials[materialIndex]; + if (!materialDef.extensions || !materialDef.extensions[this.name]) return null; + return MeshPhysicalMaterial; + } + extendMaterialParams(materialIndex, materialParams) { + const parser = this.parser; + const materialDef = parser.json.materials[materialIndex]; + if (!materialDef.extensions || !materialDef.extensions[this.name]) { + return Promise.resolve(); + } + const pending = []; + const extension = materialDef.extensions[this.name]; + if (extension.transmissionFactor !== void 0) { + materialParams.transmission = extension.transmissionFactor; + } + if (extension.transmissionTexture !== void 0) { + pending.push(parser.assignTexture(materialParams, "transmissionMap", extension.transmissionTexture)); + } + return Promise.all(pending); + } +}; +var GLTFMaterialsVolumeExtension = class { + constructor(parser) { + this.parser = parser; + this.name = EXTENSIONS.KHR_MATERIALS_VOLUME; + } + getMaterialType(materialIndex) { + const parser = this.parser; + const materialDef = parser.json.materials[materialIndex]; + if (!materialDef.extensions || !materialDef.extensions[this.name]) return null; + return MeshPhysicalMaterial; + } + extendMaterialParams(materialIndex, materialParams) { + const parser = this.parser; + const materialDef = parser.json.materials[materialIndex]; + if (!materialDef.extensions || !materialDef.extensions[this.name]) { + return Promise.resolve(); + } + const pending = []; + const extension = materialDef.extensions[this.name]; + materialParams.thickness = extension.thicknessFactor !== void 0 ? extension.thicknessFactor : 0; + if (extension.thicknessTexture !== void 0) { + pending.push(parser.assignTexture(materialParams, "thicknessMap", extension.thicknessTexture)); + } + materialParams.attenuationDistance = extension.attenuationDistance || Infinity; + const colorArray = extension.attenuationColor || [1, 1, 1]; + materialParams.attenuationColor = new Color().setRGB(colorArray[0], colorArray[1], colorArray[2], LinearSRGBColorSpace); + return Promise.all(pending); + } +}; +var GLTFMaterialsIorExtension = class { + constructor(parser) { + this.parser = parser; + this.name = EXTENSIONS.KHR_MATERIALS_IOR; + } + getMaterialType(materialIndex) { + const parser = this.parser; + const materialDef = parser.json.materials[materialIndex]; + if (!materialDef.extensions || !materialDef.extensions[this.name]) return null; + return MeshPhysicalMaterial; + } + extendMaterialParams(materialIndex, materialParams) { + const parser = this.parser; + const materialDef = parser.json.materials[materialIndex]; + if (!materialDef.extensions || !materialDef.extensions[this.name]) { + return Promise.resolve(); + } + const extension = materialDef.extensions[this.name]; + materialParams.ior = extension.ior !== void 0 ? extension.ior : 1.5; + return Promise.resolve(); + } +}; +var GLTFMaterialsSpecularExtension = class { + constructor(parser) { + this.parser = parser; + this.name = EXTENSIONS.KHR_MATERIALS_SPECULAR; + } + getMaterialType(materialIndex) { + const parser = this.parser; + const materialDef = parser.json.materials[materialIndex]; + if (!materialDef.extensions || !materialDef.extensions[this.name]) return null; + return MeshPhysicalMaterial; + } + extendMaterialParams(materialIndex, materialParams) { + const parser = this.parser; + const materialDef = parser.json.materials[materialIndex]; + if (!materialDef.extensions || !materialDef.extensions[this.name]) { + return Promise.resolve(); + } + const pending = []; + const extension = materialDef.extensions[this.name]; + materialParams.specularIntensity = extension.specularFactor !== void 0 ? extension.specularFactor : 1; + if (extension.specularTexture !== void 0) { + pending.push(parser.assignTexture(materialParams, "specularIntensityMap", extension.specularTexture)); + } + const colorArray = extension.specularColorFactor || [1, 1, 1]; + materialParams.specularColor = new Color().setRGB(colorArray[0], colorArray[1], colorArray[2], LinearSRGBColorSpace); + if (extension.specularColorTexture !== void 0) { + pending.push(parser.assignTexture(materialParams, "specularColorMap", extension.specularColorTexture, SRGBColorSpace)); + } + return Promise.all(pending); + } +}; +var GLTFMaterialsBumpExtension = class { + constructor(parser) { + this.parser = parser; + this.name = EXTENSIONS.EXT_MATERIALS_BUMP; + } + getMaterialType(materialIndex) { + const parser = this.parser; + const materialDef = parser.json.materials[materialIndex]; + if (!materialDef.extensions || !materialDef.extensions[this.name]) return null; + return MeshPhysicalMaterial; + } + extendMaterialParams(materialIndex, materialParams) { + const parser = this.parser; + const materialDef = parser.json.materials[materialIndex]; + if (!materialDef.extensions || !materialDef.extensions[this.name]) { + return Promise.resolve(); + } + const pending = []; + const extension = materialDef.extensions[this.name]; + materialParams.bumpScale = extension.bumpFactor !== void 0 ? extension.bumpFactor : 1; + if (extension.bumpTexture !== void 0) { + pending.push(parser.assignTexture(materialParams, "bumpMap", extension.bumpTexture)); + } + return Promise.all(pending); + } +}; +var GLTFMaterialsAnisotropyExtension = class { + constructor(parser) { + this.parser = parser; + this.name = EXTENSIONS.KHR_MATERIALS_ANISOTROPY; + } + getMaterialType(materialIndex) { + const parser = this.parser; + const materialDef = parser.json.materials[materialIndex]; + if (!materialDef.extensions || !materialDef.extensions[this.name]) return null; + return MeshPhysicalMaterial; + } + extendMaterialParams(materialIndex, materialParams) { + const parser = this.parser; + const materialDef = parser.json.materials[materialIndex]; + if (!materialDef.extensions || !materialDef.extensions[this.name]) { + return Promise.resolve(); + } + const pending = []; + const extension = materialDef.extensions[this.name]; + if (extension.anisotropyStrength !== void 0) { + materialParams.anisotropy = extension.anisotropyStrength; + } + if (extension.anisotropyRotation !== void 0) { + materialParams.anisotropyRotation = extension.anisotropyRotation; + } + if (extension.anisotropyTexture !== void 0) { + pending.push(parser.assignTexture(materialParams, "anisotropyMap", extension.anisotropyTexture)); + } + return Promise.all(pending); + } +}; +var GLTFTextureBasisUExtension = class { + constructor(parser) { + this.parser = parser; + this.name = EXTENSIONS.KHR_TEXTURE_BASISU; + } + loadTexture(textureIndex) { + const parser = this.parser; + const json = parser.json; + const textureDef = json.textures[textureIndex]; + if (!textureDef.extensions || !textureDef.extensions[this.name]) { + return null; + } + const extension = textureDef.extensions[this.name]; + const loader = parser.options.ktx2Loader; + if (!loader) { + if (json.extensionsRequired && json.extensionsRequired.indexOf(this.name) >= 0) { + throw new Error("THREE.GLTFLoader: setKTX2Loader must be called before loading KTX2 textures"); + } else { + return null; + } + } + return parser.loadTextureImage(textureIndex, extension.source, loader); + } +}; +var GLTFTextureWebPExtension = class { + constructor(parser) { + this.parser = parser; + this.name = EXTENSIONS.EXT_TEXTURE_WEBP; + this.isSupported = null; + } + loadTexture(textureIndex) { + const name = this.name; + const parser = this.parser; + const json = parser.json; + const textureDef = json.textures[textureIndex]; + if (!textureDef.extensions || !textureDef.extensions[name]) { + return null; + } + const extension = textureDef.extensions[name]; + const source = json.images[extension.source]; + let loader = parser.textureLoader; + if (source.uri) { + const handler = parser.options.manager.getHandler(source.uri); + if (handler !== null) loader = handler; + } + return this.detectSupport().then(function(isSupported) { + if (isSupported) return parser.loadTextureImage(textureIndex, extension.source, loader); + if (json.extensionsRequired && json.extensionsRequired.indexOf(name) >= 0) { + throw new Error("THREE.GLTFLoader: WebP required by asset but unsupported."); + } + return parser.loadTexture(textureIndex); + }); + } + detectSupport() { + if (!this.isSupported) { + this.isSupported = new Promise(function(resolve) { + const image = new Image(); + image.src = "data:image/webp;base64,UklGRiIAAABXRUJQVlA4IBYAAAAwAQCdASoBAAEADsD+JaQAA3AAAAAA"; + image.onload = image.onerror = function() { + resolve(image.height === 1); + }; + }); + } + return this.isSupported; + } +}; +var GLTFTextureAVIFExtension = class { + constructor(parser) { + this.parser = parser; + this.name = EXTENSIONS.EXT_TEXTURE_AVIF; + this.isSupported = null; + } + loadTexture(textureIndex) { + const name = this.name; + const parser = this.parser; + const json = parser.json; + const textureDef = json.textures[textureIndex]; + if (!textureDef.extensions || !textureDef.extensions[name]) { + return null; + } + const extension = textureDef.extensions[name]; + const source = json.images[extension.source]; + let loader = parser.textureLoader; + if (source.uri) { + const handler = parser.options.manager.getHandler(source.uri); + if (handler !== null) loader = handler; + } + return this.detectSupport().then(function(isSupported) { + if (isSupported) return parser.loadTextureImage(textureIndex, extension.source, loader); + if (json.extensionsRequired && json.extensionsRequired.indexOf(name) >= 0) { + throw new Error("THREE.GLTFLoader: AVIF required by asset but unsupported."); + } + return parser.loadTexture(textureIndex); + }); + } + detectSupport() { + if (!this.isSupported) { + this.isSupported = new Promise(function(resolve) { + const image = new Image(); + image.src = "data:image/avif;base64,AAAAIGZ0eXBhdmlmAAAAAGF2aWZtaWYxbWlhZk1BMUIAAADybWV0YQAAAAAAAAAoaGRscgAAAAAAAAAAcGljdAAAAAAAAAAAAAAAAGxpYmF2aWYAAAAADnBpdG0AAAAAAAEAAAAeaWxvYwAAAABEAAABAAEAAAABAAABGgAAABcAAAAoaWluZgAAAAAAAQAAABppbmZlAgAAAAABAABhdjAxQ29sb3IAAAAAamlwcnAAAABLaXBjbwAAABRpc3BlAAAAAAAAAAEAAAABAAAAEHBpeGkAAAAAAwgICAAAAAxhdjFDgQAMAAAAABNjb2xybmNseAACAAIABoAAAAAXaXBtYQAAAAAAAAABAAEEAQKDBAAAAB9tZGF0EgAKCBgABogQEDQgMgkQAAAAB8dSLfI="; + image.onload = image.onerror = function() { + resolve(image.height === 1); + }; + }); + } + return this.isSupported; + } +}; +var GLTFMeshoptCompression = class { + constructor(parser) { + this.name = EXTENSIONS.EXT_MESHOPT_COMPRESSION; + this.parser = parser; + } + loadBufferView(index) { + const json = this.parser.json; + const bufferView = json.bufferViews[index]; + if (bufferView.extensions && bufferView.extensions[this.name]) { + const extensionDef = bufferView.extensions[this.name]; + const buffer = this.parser.getDependency("buffer", extensionDef.buffer); + const decoder = this.parser.options.meshoptDecoder; + if (!decoder || !decoder.supported) { + if (json.extensionsRequired && json.extensionsRequired.indexOf(this.name) >= 0) { + throw new Error("THREE.GLTFLoader: setMeshoptDecoder must be called before loading compressed files"); + } else { + return null; + } + } + return buffer.then(function(res) { + const byteOffset = extensionDef.byteOffset || 0; + const byteLength = extensionDef.byteLength || 0; + const count = extensionDef.count; + const stride = extensionDef.byteStride; + const source = new Uint8Array(res, byteOffset, byteLength); + if (decoder.decodeGltfBufferAsync) { + return decoder.decodeGltfBufferAsync(count, stride, source, extensionDef.mode, extensionDef.filter).then(function(res2) { + return res2.buffer; + }); + } else { + return decoder.ready.then(function() { + const result = new ArrayBuffer(count * stride); + decoder.decodeGltfBuffer(new Uint8Array(result), count, stride, source, extensionDef.mode, extensionDef.filter); + return result; + }); + } + }); + } else { + return null; + } + } +}; +var GLTFMeshGpuInstancing = class { + constructor(parser) { + this.name = EXTENSIONS.EXT_MESH_GPU_INSTANCING; + this.parser = parser; + } + createNodeMesh(nodeIndex) { + const json = this.parser.json; + const nodeDef = json.nodes[nodeIndex]; + if (!nodeDef.extensions || !nodeDef.extensions[this.name] || nodeDef.mesh === void 0) { + return null; + } + const meshDef = json.meshes[nodeDef.mesh]; + for (const primitive of meshDef.primitives) { + if (primitive.mode !== WEBGL_CONSTANTS.TRIANGLES && primitive.mode !== WEBGL_CONSTANTS.TRIANGLE_STRIP && primitive.mode !== WEBGL_CONSTANTS.TRIANGLE_FAN && primitive.mode !== void 0) { + return null; + } + } + const extensionDef = nodeDef.extensions[this.name]; + const attributesDef = extensionDef.attributes; + const pending = []; + const attributes = {}; + for (const key in attributesDef) { + pending.push(this.parser.getDependency("accessor", attributesDef[key]).then((accessor) => { + attributes[key] = accessor; + return attributes[key]; + })); + } + if (pending.length < 1) { + return null; + } + pending.push(this.parser.createNodeMesh(nodeIndex)); + return Promise.all(pending).then((results) => { + const nodeObject = results.pop(); + const meshes = nodeObject.isGroup ? nodeObject.children : [nodeObject]; + const count = results[0].count; + const instancedMeshes = []; + for (const mesh of meshes) { + const m = new Matrix4(); + const p = new Vector3(); + const q = new Quaternion(); + const s = new Vector3(1, 1, 1); + const instancedMesh = new InstancedMesh(mesh.geometry, mesh.material, count); + for (let i = 0; i < count; i++) { + if (attributes.TRANSLATION) { + p.fromBufferAttribute(attributes.TRANSLATION, i); + } + if (attributes.ROTATION) { + q.fromBufferAttribute(attributes.ROTATION, i); + } + if (attributes.SCALE) { + s.fromBufferAttribute(attributes.SCALE, i); + } + instancedMesh.setMatrixAt(i, m.compose(p, q, s)); + } + for (const attributeName in attributes) { + if (attributeName === "_COLOR_0") { + const attr = attributes[attributeName]; + instancedMesh.instanceColor = new InstancedBufferAttribute(attr.array, attr.itemSize, attr.normalized); + } else if (attributeName !== "TRANSLATION" && attributeName !== "ROTATION" && attributeName !== "SCALE") { + mesh.geometry.setAttribute(attributeName, attributes[attributeName]); + } + } + Object3D.prototype.copy.call(instancedMesh, mesh); + this.parser.assignFinalMaterial(instancedMesh); + instancedMeshes.push(instancedMesh); + } + if (nodeObject.isGroup) { + nodeObject.clear(); + nodeObject.add(...instancedMeshes); + return nodeObject; + } + return instancedMeshes[0]; + }); + } +}; +var BINARY_EXTENSION_HEADER_MAGIC = "glTF"; +var BINARY_EXTENSION_HEADER_LENGTH = 12; +var BINARY_EXTENSION_CHUNK_TYPES = { JSON: 1313821514, BIN: 5130562 }; +var GLTFBinaryExtension = class { + constructor(data) { + this.name = EXTENSIONS.KHR_BINARY_GLTF; + this.content = null; + this.body = null; + const headerView = new DataView(data, 0, BINARY_EXTENSION_HEADER_LENGTH); + const textDecoder2 = new TextDecoder(); + this.header = { + magic: textDecoder2.decode(new Uint8Array(data.slice(0, 4))), + version: headerView.getUint32(4, true), + length: headerView.getUint32(8, true) + }; + if (this.header.magic !== BINARY_EXTENSION_HEADER_MAGIC) { + throw new Error("THREE.GLTFLoader: Unsupported glTF-Binary header."); + } else if (this.header.version < 2) { + throw new Error("THREE.GLTFLoader: Legacy binary file detected."); + } + const chunkContentsLength = this.header.length - BINARY_EXTENSION_HEADER_LENGTH; + const chunkView = new DataView(data, BINARY_EXTENSION_HEADER_LENGTH); + let chunkIndex = 0; + while (chunkIndex < chunkContentsLength) { + const chunkLength = chunkView.getUint32(chunkIndex, true); + chunkIndex += 4; + const chunkType = chunkView.getUint32(chunkIndex, true); + chunkIndex += 4; + if (chunkType === BINARY_EXTENSION_CHUNK_TYPES.JSON) { + const contentArray = new Uint8Array(data, BINARY_EXTENSION_HEADER_LENGTH + chunkIndex, chunkLength); + this.content = textDecoder2.decode(contentArray); + } else if (chunkType === BINARY_EXTENSION_CHUNK_TYPES.BIN) { + const byteOffset = BINARY_EXTENSION_HEADER_LENGTH + chunkIndex; + this.body = data.slice(byteOffset, byteOffset + chunkLength); + } + chunkIndex += chunkLength; + } + if (this.content === null) { + throw new Error("THREE.GLTFLoader: JSON content not found."); + } + } +}; +var GLTFDracoMeshCompressionExtension = class { + constructor(json, dracoLoader) { + if (!dracoLoader) { + throw new Error("THREE.GLTFLoader: No DRACOLoader instance provided."); + } + this.name = EXTENSIONS.KHR_DRACO_MESH_COMPRESSION; + this.json = json; + this.dracoLoader = dracoLoader; + this.dracoLoader.preload(); + } + decodePrimitive(primitive, parser) { + const json = this.json; + const dracoLoader = this.dracoLoader; + const bufferViewIndex = primitive.extensions[this.name].bufferView; + const gltfAttributeMap = primitive.extensions[this.name].attributes; + const threeAttributeMap = {}; + const attributeNormalizedMap = {}; + const attributeTypeMap = {}; + for (const attributeName in gltfAttributeMap) { + const threeAttributeName = ATTRIBUTES[attributeName] || attributeName.toLowerCase(); + threeAttributeMap[threeAttributeName] = gltfAttributeMap[attributeName]; + } + for (const attributeName in primitive.attributes) { + const threeAttributeName = ATTRIBUTES[attributeName] || attributeName.toLowerCase(); + if (gltfAttributeMap[attributeName] !== void 0) { + const accessorDef = json.accessors[primitive.attributes[attributeName]]; + const componentType = WEBGL_COMPONENT_TYPES[accessorDef.componentType]; + attributeTypeMap[threeAttributeName] = componentType.name; + attributeNormalizedMap[threeAttributeName] = accessorDef.normalized === true; + } + } + return parser.getDependency("bufferView", bufferViewIndex).then(function(bufferView) { + return new Promise(function(resolve, reject) { + dracoLoader.decodeDracoFile(bufferView, function(geometry) { + for (const attributeName in geometry.attributes) { + const attribute = geometry.attributes[attributeName]; + const normalized = attributeNormalizedMap[attributeName]; + if (normalized !== void 0) attribute.normalized = normalized; + } + resolve(geometry); + }, threeAttributeMap, attributeTypeMap, LinearSRGBColorSpace, reject); + }); + }); + } +}; +var GLTFTextureTransformExtension = class { + constructor() { + this.name = EXTENSIONS.KHR_TEXTURE_TRANSFORM; + } + extendTexture(texture, transform) { + if ((transform.texCoord === void 0 || transform.texCoord === texture.channel) && transform.offset === void 0 && transform.rotation === void 0 && transform.scale === void 0) { + return texture; + } + texture = texture.clone(); + if (transform.texCoord !== void 0) { + texture.channel = transform.texCoord; + } + if (transform.offset !== void 0) { + texture.offset.fromArray(transform.offset); + } + if (transform.rotation !== void 0) { + texture.rotation = transform.rotation; + } + if (transform.scale !== void 0) { + texture.repeat.fromArray(transform.scale); + } + texture.needsUpdate = true; + return texture; + } +}; +var GLTFMeshQuantizationExtension = class { + constructor() { + this.name = EXTENSIONS.KHR_MESH_QUANTIZATION; + } +}; +var GLTFCubicSplineInterpolant = class extends Interpolant { + constructor(parameterPositions, sampleValues, sampleSize, resultBuffer) { + super(parameterPositions, sampleValues, sampleSize, resultBuffer); + } + copySampleValue_(index) { + const result = this.resultBuffer, values = this.sampleValues, valueSize = this.valueSize, offset = index * valueSize * 3 + valueSize; + for (let i = 0; i !== valueSize; i++) { + result[i] = values[offset + i]; + } + return result; + } + interpolate_(i1, t0, t, t1) { + const result = this.resultBuffer; + const values = this.sampleValues; + const stride = this.valueSize; + const stride2 = stride * 2; + const stride3 = stride * 3; + const td2 = t1 - t0; + const p = (t - t0) / td2; + const pp = p * p; + const ppp = pp * p; + const offset1 = i1 * stride3; + const offset0 = offset1 - stride3; + const s2 = -2 * ppp + 3 * pp; + const s3 = ppp - pp; + const s0 = 1 - s2; + const s1 = s3 - pp + p; + for (let i = 0; i !== stride; i++) { + const p0 = values[offset0 + i + stride]; + const m0 = values[offset0 + i + stride2] * td2; + const p1 = values[offset1 + i + stride]; + const m1 = values[offset1 + i] * td2; + result[i] = s0 * p0 + s1 * m0 + s2 * p1 + s3 * m1; + } + return result; + } +}; +var _q = new Quaternion(); +var GLTFCubicSplineQuaternionInterpolant = class extends GLTFCubicSplineInterpolant { + interpolate_(i1, t0, t, t1) { + const result = super.interpolate_(i1, t0, t, t1); + _q.fromArray(result).normalize().toArray(result); + return result; + } +}; +var WEBGL_CONSTANTS = { + FLOAT: 5126, + //FLOAT_MAT2: 35674, + FLOAT_MAT3: 35675, + FLOAT_MAT4: 35676, + FLOAT_VEC2: 35664, + FLOAT_VEC3: 35665, + FLOAT_VEC4: 35666, + LINEAR: 9729, + REPEAT: 10497, + SAMPLER_2D: 35678, + POINTS: 0, + LINES: 1, + LINE_LOOP: 2, + LINE_STRIP: 3, + TRIANGLES: 4, + TRIANGLE_STRIP: 5, + TRIANGLE_FAN: 6, + UNSIGNED_BYTE: 5121, + UNSIGNED_SHORT: 5123 +}; +var WEBGL_COMPONENT_TYPES = { + 5120: Int8Array, + 5121: Uint8Array, + 5122: Int16Array, + 5123: Uint16Array, + 5125: Uint32Array, + 5126: Float32Array +}; +var WEBGL_FILTERS = { + 9728: NearestFilter, + 9729: LinearFilter, + 9984: NearestMipmapNearestFilter, + 9985: LinearMipmapNearestFilter, + 9986: NearestMipmapLinearFilter, + 9987: LinearMipmapLinearFilter +}; +var WEBGL_WRAPPINGS = { + 33071: ClampToEdgeWrapping, + 33648: MirroredRepeatWrapping, + 10497: RepeatWrapping +}; +var WEBGL_TYPE_SIZES = { + "SCALAR": 1, + "VEC2": 2, + "VEC3": 3, + "VEC4": 4, + "MAT2": 4, + "MAT3": 9, + "MAT4": 16 +}; +var ATTRIBUTES = { + POSITION: "position", + NORMAL: "normal", + TANGENT: "tangent", + TEXCOORD_0: "uv", + TEXCOORD_1: "uv1", + TEXCOORD_2: "uv2", + TEXCOORD_3: "uv3", + COLOR_0: "color", + WEIGHTS_0: "skinWeight", + JOINTS_0: "skinIndex" +}; +var PATH_PROPERTIES = { + scale: "scale", + translation: "position", + rotation: "quaternion", + weights: "morphTargetInfluences" +}; +var INTERPOLATION = { + CUBICSPLINE: void 0, + // We use a custom interpolant (GLTFCubicSplineInterpolation) for CUBICSPLINE tracks. Each + // keyframe track will be initialized with a default interpolation type, then modified. + LINEAR: InterpolateLinear, + STEP: InterpolateDiscrete +}; +var ALPHA_MODES = { + OPAQUE: "OPAQUE", + MASK: "MASK", + BLEND: "BLEND" +}; +function createDefaultMaterial(cache) { + if (cache["DefaultMaterial"] === void 0) { + cache["DefaultMaterial"] = new MeshStandardMaterial({ + color: 16777215, + emissive: 0, + metalness: 1, + roughness: 1, + transparent: false, + depthTest: true, + side: FrontSide + }); + } + return cache["DefaultMaterial"]; +} +function addUnknownExtensionsToUserData(knownExtensions, object, objectDef) { + for (const name in objectDef.extensions) { + if (knownExtensions[name] === void 0) { + object.userData.gltfExtensions = object.userData.gltfExtensions || {}; + object.userData.gltfExtensions[name] = objectDef.extensions[name]; + } + } +} +function assignExtrasToUserData(object, gltfDef) { + if (gltfDef.extras !== void 0) { + if (typeof gltfDef.extras === "object") { + Object.assign(object.userData, gltfDef.extras); + } else { + console.warn("THREE.GLTFLoader: Ignoring primitive type .extras, " + gltfDef.extras); + } + } +} +function addMorphTargets(geometry, targets, parser) { + let hasMorphPosition = false; + let hasMorphNormal = false; + let hasMorphColor = false; + for (let i = 0, il = targets.length; i < il; i++) { + const target = targets[i]; + if (target.POSITION !== void 0) hasMorphPosition = true; + if (target.NORMAL !== void 0) hasMorphNormal = true; + if (target.COLOR_0 !== void 0) hasMorphColor = true; + if (hasMorphPosition && hasMorphNormal && hasMorphColor) break; + } + if (!hasMorphPosition && !hasMorphNormal && !hasMorphColor) return Promise.resolve(geometry); + const pendingPositionAccessors = []; + const pendingNormalAccessors = []; + const pendingColorAccessors = []; + for (let i = 0, il = targets.length; i < il; i++) { + const target = targets[i]; + if (hasMorphPosition) { + const pendingAccessor = target.POSITION !== void 0 ? parser.getDependency("accessor", target.POSITION) : geometry.attributes.position; + pendingPositionAccessors.push(pendingAccessor); + } + if (hasMorphNormal) { + const pendingAccessor = target.NORMAL !== void 0 ? parser.getDependency("accessor", target.NORMAL) : geometry.attributes.normal; + pendingNormalAccessors.push(pendingAccessor); + } + if (hasMorphColor) { + const pendingAccessor = target.COLOR_0 !== void 0 ? parser.getDependency("accessor", target.COLOR_0) : geometry.attributes.color; + pendingColorAccessors.push(pendingAccessor); + } + } + return Promise.all([ + Promise.all(pendingPositionAccessors), + Promise.all(pendingNormalAccessors), + Promise.all(pendingColorAccessors) + ]).then(function(accessors) { + const morphPositions = accessors[0]; + const morphNormals = accessors[1]; + const morphColors = accessors[2]; + if (hasMorphPosition) geometry.morphAttributes.position = morphPositions; + if (hasMorphNormal) geometry.morphAttributes.normal = morphNormals; + if (hasMorphColor) geometry.morphAttributes.color = morphColors; + geometry.morphTargetsRelative = true; + return geometry; + }); +} +function updateMorphTargets(mesh, meshDef) { + mesh.updateMorphTargets(); + if (meshDef.weights !== void 0) { + for (let i = 0, il = meshDef.weights.length; i < il; i++) { + mesh.morphTargetInfluences[i] = meshDef.weights[i]; + } + } + if (meshDef.extras && Array.isArray(meshDef.extras.targetNames)) { + const targetNames = meshDef.extras.targetNames; + if (mesh.morphTargetInfluences.length === targetNames.length) { + mesh.morphTargetDictionary = {}; + for (let i = 0, il = targetNames.length; i < il; i++) { + mesh.morphTargetDictionary[targetNames[i]] = i; + } + } else { + console.warn("THREE.GLTFLoader: Invalid extras.targetNames length. Ignoring names."); + } + } +} +function createPrimitiveKey(primitiveDef) { + let geometryKey; + const dracoExtension = primitiveDef.extensions && primitiveDef.extensions[EXTENSIONS.KHR_DRACO_MESH_COMPRESSION]; + if (dracoExtension) { + geometryKey = "draco:" + dracoExtension.bufferView + ":" + dracoExtension.indices + ":" + createAttributesKey(dracoExtension.attributes); + } else { + geometryKey = primitiveDef.indices + ":" + createAttributesKey(primitiveDef.attributes) + ":" + primitiveDef.mode; + } + if (primitiveDef.targets !== void 0) { + for (let i = 0, il = primitiveDef.targets.length; i < il; i++) { + geometryKey += ":" + createAttributesKey(primitiveDef.targets[i]); + } + } + return geometryKey; +} +function createAttributesKey(attributes) { + let attributesKey = ""; + const keys = Object.keys(attributes).sort(); + for (let i = 0, il = keys.length; i < il; i++) { + attributesKey += keys[i] + ":" + attributes[keys[i]] + ";"; + } + return attributesKey; +} +function getNormalizedComponentScale(constructor) { + switch (constructor) { + case Int8Array: + return 1 / 127; + case Uint8Array: + return 1 / 255; + case Int16Array: + return 1 / 32767; + case Uint16Array: + return 1 / 65535; + default: + throw new Error("THREE.GLTFLoader: Unsupported normalized accessor component type."); + } +} +function getImageURIMimeType(uri) { + if (uri.search(/\.jpe?g($|\?)/i) > 0 || uri.search(/^data\:image\/jpeg/) === 0) return "image/jpeg"; + if (uri.search(/\.webp($|\?)/i) > 0 || uri.search(/^data\:image\/webp/) === 0) return "image/webp"; + return "image/png"; +} +var _identityMatrix = new Matrix4(); +var GLTFParser = class { + constructor(json = {}, options = {}) { + this.json = json; + this.extensions = {}; + this.plugins = {}; + this.options = options; + this.cache = new GLTFRegistry(); + this.associations = /* @__PURE__ */ new Map(); + this.primitiveCache = {}; + this.nodeCache = {}; + this.meshCache = { refs: {}, uses: {} }; + this.cameraCache = { refs: {}, uses: {} }; + this.lightCache = { refs: {}, uses: {} }; + this.sourceCache = {}; + this.textureCache = {}; + this.nodeNamesUsed = {}; + let isSafari = false; + let isFirefox = false; + let firefoxVersion = -1; + if (typeof navigator !== "undefined") { + isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent) === true; + isFirefox = navigator.userAgent.indexOf("Firefox") > -1; + firefoxVersion = isFirefox ? navigator.userAgent.match(/Firefox\/([0-9]+)\./)[1] : -1; + } + if (typeof createImageBitmap === "undefined" || isSafari || isFirefox && firefoxVersion < 98) { + this.textureLoader = new TextureLoader(this.options.manager); + } else { + this.textureLoader = new ImageBitmapLoader(this.options.manager); + } + this.textureLoader.setCrossOrigin(this.options.crossOrigin); + this.textureLoader.setRequestHeader(this.options.requestHeader); + this.fileLoader = new FileLoader(this.options.manager); + this.fileLoader.setResponseType("arraybuffer"); + if (this.options.crossOrigin === "use-credentials") { + this.fileLoader.setWithCredentials(true); + } + } + setExtensions(extensions) { + this.extensions = extensions; + } + setPlugins(plugins) { + this.plugins = plugins; + } + parse(onLoad, onError) { + const parser = this; + const json = this.json; + const extensions = this.extensions; + this.cache.removeAll(); + this.nodeCache = {}; + this._invokeAll(function(ext) { + return ext._markDefs && ext._markDefs(); + }); + Promise.all(this._invokeAll(function(ext) { + return ext.beforeRoot && ext.beforeRoot(); + })).then(function() { + return Promise.all([ + parser.getDependencies("scene"), + parser.getDependencies("animation"), + parser.getDependencies("camera") + ]); + }).then(function(dependencies) { + const result = { + scene: dependencies[0][json.scene || 0], + scenes: dependencies[0], + animations: dependencies[1], + cameras: dependencies[2], + asset: json.asset, + parser, + userData: {} + }; + addUnknownExtensionsToUserData(extensions, result, json); + assignExtrasToUserData(result, json); + return Promise.all(parser._invokeAll(function(ext) { + return ext.afterRoot && ext.afterRoot(result); + })).then(function() { + for (const scene of result.scenes) { + scene.updateMatrixWorld(); + } + onLoad(result); + }); + }).catch(onError); + } + /** + * Marks the special nodes/meshes in json for efficient parse. + */ + _markDefs() { + const nodeDefs = this.json.nodes || []; + const skinDefs = this.json.skins || []; + const meshDefs = this.json.meshes || []; + for (let skinIndex = 0, skinLength = skinDefs.length; skinIndex < skinLength; skinIndex++) { + const joints = skinDefs[skinIndex].joints; + for (let i = 0, il = joints.length; i < il; i++) { + nodeDefs[joints[i]].isBone = true; + } + } + for (let nodeIndex = 0, nodeLength = nodeDefs.length; nodeIndex < nodeLength; nodeIndex++) { + const nodeDef = nodeDefs[nodeIndex]; + if (nodeDef.mesh !== void 0) { + this._addNodeRef(this.meshCache, nodeDef.mesh); + if (nodeDef.skin !== void 0) { + meshDefs[nodeDef.mesh].isSkinnedMesh = true; + } + } + if (nodeDef.camera !== void 0) { + this._addNodeRef(this.cameraCache, nodeDef.camera); + } + } + } + /** + * Counts references to shared node / Object3D resources. These resources + * can be reused, or "instantiated", at multiple nodes in the scene + * hierarchy. Mesh, Camera, and Light instances are instantiated and must + * be marked. Non-scenegraph resources (like Materials, Geometries, and + * Textures) can be reused directly and are not marked here. + * + * Example: CesiumMilkTruck sample model reuses "Wheel" meshes. + */ + _addNodeRef(cache, index) { + if (index === void 0) return; + if (cache.refs[index] === void 0) { + cache.refs[index] = cache.uses[index] = 0; + } + cache.refs[index]++; + } + /** Returns a reference to a shared resource, cloning it if necessary. */ + _getNodeRef(cache, index, object) { + if (cache.refs[index] <= 1) return object; + const ref = object.clone(); + const updateMappings = (original, clone) => { + const mappings = this.associations.get(original); + if (mappings != null) { + this.associations.set(clone, mappings); + } + for (const [i, child] of original.children.entries()) { + updateMappings(child, clone.children[i]); + } + }; + updateMappings(object, ref); + ref.name += "_instance_" + cache.uses[index]++; + return ref; + } + _invokeOne(func) { + const extensions = Object.values(this.plugins); + extensions.push(this); + for (let i = 0; i < extensions.length; i++) { + const result = func(extensions[i]); + if (result) return result; + } + return null; + } + _invokeAll(func) { + const extensions = Object.values(this.plugins); + extensions.unshift(this); + const pending = []; + for (let i = 0; i < extensions.length; i++) { + const result = func(extensions[i]); + if (result) pending.push(result); + } + return pending; + } + /** + * Requests the specified dependency asynchronously, with caching. + * @param {string} type + * @param {number} index + * @return {Promise} + */ + getDependency(type, index) { + const cacheKey = type + ":" + index; + let dependency = this.cache.get(cacheKey); + if (!dependency) { + switch (type) { + case "scene": + dependency = this.loadScene(index); + break; + case "node": + dependency = this._invokeOne(function(ext) { + return ext.loadNode && ext.loadNode(index); + }); + break; + case "mesh": + dependency = this._invokeOne(function(ext) { + return ext.loadMesh && ext.loadMesh(index); + }); + break; + case "accessor": + dependency = this.loadAccessor(index); + break; + case "bufferView": + dependency = this._invokeOne(function(ext) { + return ext.loadBufferView && ext.loadBufferView(index); + }); + break; + case "buffer": + dependency = this.loadBuffer(index); + break; + case "material": + dependency = this._invokeOne(function(ext) { + return ext.loadMaterial && ext.loadMaterial(index); + }); + break; + case "texture": + dependency = this._invokeOne(function(ext) { + return ext.loadTexture && ext.loadTexture(index); + }); + break; + case "skin": + dependency = this.loadSkin(index); + break; + case "animation": + dependency = this._invokeOne(function(ext) { + return ext.loadAnimation && ext.loadAnimation(index); + }); + break; + case "camera": + dependency = this.loadCamera(index); + break; + default: + dependency = this._invokeOne(function(ext) { + return ext != this && ext.getDependency && ext.getDependency(type, index); + }); + if (!dependency) { + throw new Error("Unknown type: " + type); + } + break; + } + this.cache.add(cacheKey, dependency); + } + return dependency; + } + /** + * Requests all dependencies of the specified type asynchronously, with caching. + * @param {string} type + * @return {Promise>} + */ + getDependencies(type) { + let dependencies = this.cache.get(type); + if (!dependencies) { + const parser = this; + const defs = this.json[type + (type === "mesh" ? "es" : "s")] || []; + dependencies = Promise.all(defs.map(function(def, index) { + return parser.getDependency(type, index); + })); + this.cache.add(type, dependencies); + } + return dependencies; + } + /** + * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views + * @param {number} bufferIndex + * @return {Promise} + */ + loadBuffer(bufferIndex) { + const bufferDef = this.json.buffers[bufferIndex]; + const loader = this.fileLoader; + if (bufferDef.type && bufferDef.type !== "arraybuffer") { + throw new Error("THREE.GLTFLoader: " + bufferDef.type + " buffer type is not supported."); + } + if (bufferDef.uri === void 0 && bufferIndex === 0) { + return Promise.resolve(this.extensions[EXTENSIONS.KHR_BINARY_GLTF].body); + } + const options = this.options; + return new Promise(function(resolve, reject) { + loader.load(LoaderUtils.resolveURL(bufferDef.uri, options.path), resolve, void 0, function() { + reject(new Error('THREE.GLTFLoader: Failed to load buffer "' + bufferDef.uri + '".')); + }); + }); + } + /** + * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views + * @param {number} bufferViewIndex + * @return {Promise} + */ + loadBufferView(bufferViewIndex) { + const bufferViewDef = this.json.bufferViews[bufferViewIndex]; + return this.getDependency("buffer", bufferViewDef.buffer).then(function(buffer) { + const byteLength = bufferViewDef.byteLength || 0; + const byteOffset = bufferViewDef.byteOffset || 0; + return buffer.slice(byteOffset, byteOffset + byteLength); + }); + } + /** + * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#accessors + * @param {number} accessorIndex + * @return {Promise} + */ + loadAccessor(accessorIndex) { + const parser = this; + const json = this.json; + const accessorDef = this.json.accessors[accessorIndex]; + if (accessorDef.bufferView === void 0 && accessorDef.sparse === void 0) { + const itemSize = WEBGL_TYPE_SIZES[accessorDef.type]; + const TypedArray = WEBGL_COMPONENT_TYPES[accessorDef.componentType]; + const normalized = accessorDef.normalized === true; + const array = new TypedArray(accessorDef.count * itemSize); + return Promise.resolve(new BufferAttribute(array, itemSize, normalized)); + } + const pendingBufferViews = []; + if (accessorDef.bufferView !== void 0) { + pendingBufferViews.push(this.getDependency("bufferView", accessorDef.bufferView)); + } else { + pendingBufferViews.push(null); + } + if (accessorDef.sparse !== void 0) { + pendingBufferViews.push(this.getDependency("bufferView", accessorDef.sparse.indices.bufferView)); + pendingBufferViews.push(this.getDependency("bufferView", accessorDef.sparse.values.bufferView)); + } + return Promise.all(pendingBufferViews).then(function(bufferViews) { + const bufferView = bufferViews[0]; + const itemSize = WEBGL_TYPE_SIZES[accessorDef.type]; + const TypedArray = WEBGL_COMPONENT_TYPES[accessorDef.componentType]; + const elementBytes = TypedArray.BYTES_PER_ELEMENT; + const itemBytes = elementBytes * itemSize; + const byteOffset = accessorDef.byteOffset || 0; + const byteStride = accessorDef.bufferView !== void 0 ? json.bufferViews[accessorDef.bufferView].byteStride : void 0; + const normalized = accessorDef.normalized === true; + let array, bufferAttribute; + if (byteStride && byteStride !== itemBytes) { + const ibSlice = Math.floor(byteOffset / byteStride); + const ibCacheKey = "InterleavedBuffer:" + accessorDef.bufferView + ":" + accessorDef.componentType + ":" + ibSlice + ":" + accessorDef.count; + let ib = parser.cache.get(ibCacheKey); + if (!ib) { + array = new TypedArray(bufferView, ibSlice * byteStride, accessorDef.count * byteStride / elementBytes); + ib = new InterleavedBuffer(array, byteStride / elementBytes); + parser.cache.add(ibCacheKey, ib); + } + bufferAttribute = new InterleavedBufferAttribute(ib, itemSize, byteOffset % byteStride / elementBytes, normalized); + } else { + if (bufferView === null) { + array = new TypedArray(accessorDef.count * itemSize); + } else { + array = new TypedArray(bufferView, byteOffset, accessorDef.count * itemSize); + } + bufferAttribute = new BufferAttribute(array, itemSize, normalized); + } + if (accessorDef.sparse !== void 0) { + const itemSizeIndices = WEBGL_TYPE_SIZES.SCALAR; + const TypedArrayIndices = WEBGL_COMPONENT_TYPES[accessorDef.sparse.indices.componentType]; + const byteOffsetIndices = accessorDef.sparse.indices.byteOffset || 0; + const byteOffsetValues = accessorDef.sparse.values.byteOffset || 0; + const sparseIndices = new TypedArrayIndices(bufferViews[1], byteOffsetIndices, accessorDef.sparse.count * itemSizeIndices); + const sparseValues = new TypedArray(bufferViews[2], byteOffsetValues, accessorDef.sparse.count * itemSize); + if (bufferView !== null) { + bufferAttribute = new BufferAttribute(bufferAttribute.array.slice(), bufferAttribute.itemSize, bufferAttribute.normalized); + } + for (let i = 0, il = sparseIndices.length; i < il; i++) { + const index = sparseIndices[i]; + bufferAttribute.setX(index, sparseValues[i * itemSize]); + if (itemSize >= 2) bufferAttribute.setY(index, sparseValues[i * itemSize + 1]); + if (itemSize >= 3) bufferAttribute.setZ(index, sparseValues[i * itemSize + 2]); + if (itemSize >= 4) bufferAttribute.setW(index, sparseValues[i * itemSize + 3]); + if (itemSize >= 5) throw new Error("THREE.GLTFLoader: Unsupported itemSize in sparse BufferAttribute."); + } + } + return bufferAttribute; + }); + } + /** + * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#textures + * @param {number} textureIndex + * @return {Promise} + */ + loadTexture(textureIndex) { + const json = this.json; + const options = this.options; + const textureDef = json.textures[textureIndex]; + const sourceIndex = textureDef.source; + const sourceDef = json.images[sourceIndex]; + let loader = this.textureLoader; + if (sourceDef.uri) { + const handler = options.manager.getHandler(sourceDef.uri); + if (handler !== null) loader = handler; + } + return this.loadTextureImage(textureIndex, sourceIndex, loader); + } + loadTextureImage(textureIndex, sourceIndex, loader) { + const parser = this; + const json = this.json; + const textureDef = json.textures[textureIndex]; + const sourceDef = json.images[sourceIndex]; + const cacheKey = (sourceDef.uri || sourceDef.bufferView) + ":" + textureDef.sampler; + if (this.textureCache[cacheKey]) { + return this.textureCache[cacheKey]; + } + const promise = this.loadImageSource(sourceIndex, loader).then(function(texture) { + texture.flipY = false; + texture.name = textureDef.name || sourceDef.name || ""; + if (texture.name === "" && typeof sourceDef.uri === "string" && sourceDef.uri.startsWith("data:image/") === false) { + texture.name = sourceDef.uri; + } + const samplers = json.samplers || {}; + const sampler = samplers[textureDef.sampler] || {}; + texture.magFilter = WEBGL_FILTERS[sampler.magFilter] || LinearFilter; + texture.minFilter = WEBGL_FILTERS[sampler.minFilter] || LinearMipmapLinearFilter; + texture.wrapS = WEBGL_WRAPPINGS[sampler.wrapS] || RepeatWrapping; + texture.wrapT = WEBGL_WRAPPINGS[sampler.wrapT] || RepeatWrapping; + parser.associations.set(texture, { textures: textureIndex }); + return texture; + }).catch(function() { + return null; + }); + this.textureCache[cacheKey] = promise; + return promise; + } + loadImageSource(sourceIndex, loader) { + const parser = this; + const json = this.json; + const options = this.options; + if (this.sourceCache[sourceIndex] !== void 0) { + return this.sourceCache[sourceIndex].then((texture) => texture.clone()); + } + const sourceDef = json.images[sourceIndex]; + const URL2 = self.URL || self.webkitURL; + let sourceURI = sourceDef.uri || ""; + let isObjectURL = false; + if (sourceDef.bufferView !== void 0) { + sourceURI = parser.getDependency("bufferView", sourceDef.bufferView).then(function(bufferView) { + isObjectURL = true; + const blob = new Blob([bufferView], { type: sourceDef.mimeType }); + sourceURI = URL2.createObjectURL(blob); + return sourceURI; + }); + } else if (sourceDef.uri === void 0) { + throw new Error("THREE.GLTFLoader: Image " + sourceIndex + " is missing URI and bufferView"); + } + const promise = Promise.resolve(sourceURI).then(function(sourceURI2) { + return new Promise(function(resolve, reject) { + let onLoad = resolve; + if (loader.isImageBitmapLoader === true) { + onLoad = function(imageBitmap) { + const texture = new Texture(imageBitmap); + texture.needsUpdate = true; + resolve(texture); + }; + } + loader.load(LoaderUtils.resolveURL(sourceURI2, options.path), onLoad, void 0, reject); + }); + }).then(function(texture) { + if (isObjectURL === true) { + URL2.revokeObjectURL(sourceURI); + } + texture.userData.mimeType = sourceDef.mimeType || getImageURIMimeType(sourceDef.uri); + return texture; + }).catch(function(error) { + console.error("THREE.GLTFLoader: Couldn't load texture", sourceURI); + throw error; + }); + this.sourceCache[sourceIndex] = promise; + return promise; + } + /** + * Asynchronously assigns a texture to the given material parameters. + * @param {Object} materialParams + * @param {string} mapName + * @param {Object} mapDef + * @return {Promise} + */ + assignTexture(materialParams, mapName, mapDef, colorSpace) { + const parser = this; + return this.getDependency("texture", mapDef.index).then(function(texture) { + if (!texture) return null; + if (mapDef.texCoord !== void 0 && mapDef.texCoord > 0) { + texture = texture.clone(); + texture.channel = mapDef.texCoord; + } + if (parser.extensions[EXTENSIONS.KHR_TEXTURE_TRANSFORM]) { + const transform = mapDef.extensions !== void 0 ? mapDef.extensions[EXTENSIONS.KHR_TEXTURE_TRANSFORM] : void 0; + if (transform) { + const gltfReference = parser.associations.get(texture); + texture = parser.extensions[EXTENSIONS.KHR_TEXTURE_TRANSFORM].extendTexture(texture, transform); + parser.associations.set(texture, gltfReference); + } + } + if (colorSpace !== void 0) { + texture.colorSpace = colorSpace; + } + materialParams[mapName] = texture; + return texture; + }); + } + /** + * Assigns final material to a Mesh, Line, or Points instance. The instance + * already has a material (generated from the glTF material options alone) + * but reuse of the same glTF material may require multiple threejs materials + * to accommodate different primitive types, defines, etc. New materials will + * be created if necessary, and reused from a cache. + * @param {Object3D} mesh Mesh, Line, or Points instance. + */ + assignFinalMaterial(mesh) { + const geometry = mesh.geometry; + let material = mesh.material; + const useDerivativeTangents = geometry.attributes.tangent === void 0; + const useVertexColors = geometry.attributes.color !== void 0; + const useFlatShading = geometry.attributes.normal === void 0; + if (mesh.isPoints) { + const cacheKey = "PointsMaterial:" + material.uuid; + let pointsMaterial = this.cache.get(cacheKey); + if (!pointsMaterial) { + pointsMaterial = new PointsMaterial(); + Material.prototype.copy.call(pointsMaterial, material); + pointsMaterial.color.copy(material.color); + pointsMaterial.map = material.map; + pointsMaterial.sizeAttenuation = false; + this.cache.add(cacheKey, pointsMaterial); + } + material = pointsMaterial; + } else if (mesh.isLine) { + const cacheKey = "LineBasicMaterial:" + material.uuid; + let lineMaterial = this.cache.get(cacheKey); + if (!lineMaterial) { + lineMaterial = new LineBasicMaterial(); + Material.prototype.copy.call(lineMaterial, material); + lineMaterial.color.copy(material.color); + lineMaterial.map = material.map; + this.cache.add(cacheKey, lineMaterial); + } + material = lineMaterial; + } + if (useDerivativeTangents || useVertexColors || useFlatShading) { + let cacheKey = "ClonedMaterial:" + material.uuid + ":"; + if (useDerivativeTangents) cacheKey += "derivative-tangents:"; + if (useVertexColors) cacheKey += "vertex-colors:"; + if (useFlatShading) cacheKey += "flat-shading:"; + let cachedMaterial = this.cache.get(cacheKey); + if (!cachedMaterial) { + cachedMaterial = material.clone(); + if (useVertexColors) cachedMaterial.vertexColors = true; + if (useFlatShading) cachedMaterial.flatShading = true; + if (useDerivativeTangents) { + if (cachedMaterial.normalScale) cachedMaterial.normalScale.y *= -1; + if (cachedMaterial.clearcoatNormalScale) cachedMaterial.clearcoatNormalScale.y *= -1; + } + this.cache.add(cacheKey, cachedMaterial); + this.associations.set(cachedMaterial, this.associations.get(material)); + } + material = cachedMaterial; + } + mesh.material = material; + } + getMaterialType() { + return MeshStandardMaterial; + } + /** + * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#materials + * @param {number} materialIndex + * @return {Promise} + */ + loadMaterial(materialIndex) { + const parser = this; + const json = this.json; + const extensions = this.extensions; + const materialDef = json.materials[materialIndex]; + let materialType; + const materialParams = {}; + const materialExtensions = materialDef.extensions || {}; + const pending = []; + if (materialExtensions[EXTENSIONS.KHR_MATERIALS_UNLIT]) { + const kmuExtension = extensions[EXTENSIONS.KHR_MATERIALS_UNLIT]; + materialType = kmuExtension.getMaterialType(); + pending.push(kmuExtension.extendParams(materialParams, materialDef, parser)); + } else { + const metallicRoughness = materialDef.pbrMetallicRoughness || {}; + materialParams.color = new Color(1, 1, 1); + materialParams.opacity = 1; + if (Array.isArray(metallicRoughness.baseColorFactor)) { + const array = metallicRoughness.baseColorFactor; + materialParams.color.setRGB(array[0], array[1], array[2], LinearSRGBColorSpace); + materialParams.opacity = array[3]; + } + if (metallicRoughness.baseColorTexture !== void 0) { + pending.push(parser.assignTexture(materialParams, "map", metallicRoughness.baseColorTexture, SRGBColorSpace)); + } + materialParams.metalness = metallicRoughness.metallicFactor !== void 0 ? metallicRoughness.metallicFactor : 1; + materialParams.roughness = metallicRoughness.roughnessFactor !== void 0 ? metallicRoughness.roughnessFactor : 1; + if (metallicRoughness.metallicRoughnessTexture !== void 0) { + pending.push(parser.assignTexture(materialParams, "metalnessMap", metallicRoughness.metallicRoughnessTexture)); + pending.push(parser.assignTexture(materialParams, "roughnessMap", metallicRoughness.metallicRoughnessTexture)); + } + materialType = this._invokeOne(function(ext) { + return ext.getMaterialType && ext.getMaterialType(materialIndex); + }); + pending.push(Promise.all(this._invokeAll(function(ext) { + return ext.extendMaterialParams && ext.extendMaterialParams(materialIndex, materialParams); + }))); + } + if (materialDef.doubleSided === true) { + materialParams.side = DoubleSide; + } + const alphaMode = materialDef.alphaMode || ALPHA_MODES.OPAQUE; + if (alphaMode === ALPHA_MODES.BLEND) { + materialParams.transparent = true; + materialParams.depthWrite = false; + } else { + materialParams.transparent = false; + if (alphaMode === ALPHA_MODES.MASK) { + materialParams.alphaTest = materialDef.alphaCutoff !== void 0 ? materialDef.alphaCutoff : 0.5; + } + } + if (materialDef.normalTexture !== void 0 && materialType !== MeshBasicMaterial) { + pending.push(parser.assignTexture(materialParams, "normalMap", materialDef.normalTexture)); + materialParams.normalScale = new Vector2(1, 1); + if (materialDef.normalTexture.scale !== void 0) { + const scale = materialDef.normalTexture.scale; + materialParams.normalScale.set(scale, scale); + } + } + if (materialDef.occlusionTexture !== void 0 && materialType !== MeshBasicMaterial) { + pending.push(parser.assignTexture(materialParams, "aoMap", materialDef.occlusionTexture)); + if (materialDef.occlusionTexture.strength !== void 0) { + materialParams.aoMapIntensity = materialDef.occlusionTexture.strength; + } + } + if (materialDef.emissiveFactor !== void 0 && materialType !== MeshBasicMaterial) { + const emissiveFactor = materialDef.emissiveFactor; + materialParams.emissive = new Color().setRGB(emissiveFactor[0], emissiveFactor[1], emissiveFactor[2], LinearSRGBColorSpace); + } + if (materialDef.emissiveTexture !== void 0 && materialType !== MeshBasicMaterial) { + pending.push(parser.assignTexture(materialParams, "emissiveMap", materialDef.emissiveTexture, SRGBColorSpace)); + } + return Promise.all(pending).then(function() { + const material = new materialType(materialParams); + if (materialDef.name) material.name = materialDef.name; + assignExtrasToUserData(material, materialDef); + parser.associations.set(material, { materials: materialIndex }); + if (materialDef.extensions) addUnknownExtensionsToUserData(extensions, material, materialDef); + return material; + }); + } + /** When Object3D instances are targeted by animation, they need unique names. */ + createUniqueName(originalName) { + const sanitizedName = PropertyBinding.sanitizeNodeName(originalName || ""); + if (sanitizedName in this.nodeNamesUsed) { + return sanitizedName + "_" + ++this.nodeNamesUsed[sanitizedName]; + } else { + this.nodeNamesUsed[sanitizedName] = 0; + return sanitizedName; + } + } + /** + * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#geometry + * + * Creates BufferGeometries from primitives. + * + * @param {Array} primitives + * @return {Promise>} + */ + loadGeometries(primitives) { + const parser = this; + const extensions = this.extensions; + const cache = this.primitiveCache; + function createDracoPrimitive(primitive) { + return extensions[EXTENSIONS.KHR_DRACO_MESH_COMPRESSION].decodePrimitive(primitive, parser).then(function(geometry) { + return addPrimitiveAttributes(geometry, primitive, parser); + }); + } + const pending = []; + for (let i = 0, il = primitives.length; i < il; i++) { + const primitive = primitives[i]; + const cacheKey = createPrimitiveKey(primitive); + const cached = cache[cacheKey]; + if (cached) { + pending.push(cached.promise); + } else { + let geometryPromise; + if (primitive.extensions && primitive.extensions[EXTENSIONS.KHR_DRACO_MESH_COMPRESSION]) { + geometryPromise = createDracoPrimitive(primitive); + } else { + geometryPromise = addPrimitiveAttributes(new BufferGeometry(), primitive, parser); + } + cache[cacheKey] = { primitive, promise: geometryPromise }; + pending.push(geometryPromise); + } + } + return Promise.all(pending); + } + /** + * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#meshes + * @param {number} meshIndex + * @return {Promise} + */ + loadMesh(meshIndex) { + const parser = this; + const json = this.json; + const extensions = this.extensions; + const meshDef = json.meshes[meshIndex]; + const primitives = meshDef.primitives; + const pending = []; + for (let i = 0, il = primitives.length; i < il; i++) { + const material = primitives[i].material === void 0 ? createDefaultMaterial(this.cache) : this.getDependency("material", primitives[i].material); + pending.push(material); + } + pending.push(parser.loadGeometries(primitives)); + return Promise.all(pending).then(function(results) { + const materials = results.slice(0, results.length - 1); + const geometries = results[results.length - 1]; + const meshes = []; + for (let i = 0, il = geometries.length; i < il; i++) { + const geometry = geometries[i]; + const primitive = primitives[i]; + let mesh; + const material = materials[i]; + if (primitive.mode === WEBGL_CONSTANTS.TRIANGLES || primitive.mode === WEBGL_CONSTANTS.TRIANGLE_STRIP || primitive.mode === WEBGL_CONSTANTS.TRIANGLE_FAN || primitive.mode === void 0) { + mesh = meshDef.isSkinnedMesh === true ? new SkinnedMesh(geometry, material) : new Mesh(geometry, material); + if (mesh.isSkinnedMesh === true) { + mesh.normalizeSkinWeights(); + } + if (primitive.mode === WEBGL_CONSTANTS.TRIANGLE_STRIP) { + mesh.geometry = toTrianglesDrawMode(mesh.geometry, TriangleStripDrawMode); + } else if (primitive.mode === WEBGL_CONSTANTS.TRIANGLE_FAN) { + mesh.geometry = toTrianglesDrawMode(mesh.geometry, TriangleFanDrawMode); + } + } else if (primitive.mode === WEBGL_CONSTANTS.LINES) { + mesh = new LineSegments(geometry, material); + } else if (primitive.mode === WEBGL_CONSTANTS.LINE_STRIP) { + mesh = new Line(geometry, material); + } else if (primitive.mode === WEBGL_CONSTANTS.LINE_LOOP) { + mesh = new LineLoop(geometry, material); + } else if (primitive.mode === WEBGL_CONSTANTS.POINTS) { + mesh = new Points(geometry, material); + } else { + throw new Error("THREE.GLTFLoader: Primitive mode unsupported: " + primitive.mode); + } + if (Object.keys(mesh.geometry.morphAttributes).length > 0) { + updateMorphTargets(mesh, meshDef); + } + mesh.name = parser.createUniqueName(meshDef.name || "mesh_" + meshIndex); + assignExtrasToUserData(mesh, meshDef); + if (primitive.extensions) addUnknownExtensionsToUserData(extensions, mesh, primitive); + parser.assignFinalMaterial(mesh); + meshes.push(mesh); + } + for (let i = 0, il = meshes.length; i < il; i++) { + parser.associations.set(meshes[i], { + meshes: meshIndex, + primitives: i + }); + } + if (meshes.length === 1) { + if (meshDef.extensions) addUnknownExtensionsToUserData(extensions, meshes[0], meshDef); + return meshes[0]; + } + const group = new Group(); + if (meshDef.extensions) addUnknownExtensionsToUserData(extensions, group, meshDef); + parser.associations.set(group, { meshes: meshIndex }); + for (let i = 0, il = meshes.length; i < il; i++) { + group.add(meshes[i]); + } + return group; + }); + } + /** + * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#cameras + * @param {number} cameraIndex + * @return {Promise} + */ + loadCamera(cameraIndex) { + let camera; + const cameraDef = this.json.cameras[cameraIndex]; + const params = cameraDef[cameraDef.type]; + if (!params) { + console.warn("THREE.GLTFLoader: Missing camera parameters."); + return; + } + if (cameraDef.type === "perspective") { + camera = new PerspectiveCamera(MathUtils.radToDeg(params.yfov), params.aspectRatio || 1, params.znear || 1, params.zfar || 2e6); + } else if (cameraDef.type === "orthographic") { + camera = new OrthographicCamera(-params.xmag, params.xmag, params.ymag, -params.ymag, params.znear, params.zfar); + } + if (cameraDef.name) camera.name = this.createUniqueName(cameraDef.name); + assignExtrasToUserData(camera, cameraDef); + return Promise.resolve(camera); + } + /** + * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skins + * @param {number} skinIndex + * @return {Promise} + */ + loadSkin(skinIndex) { + const skinDef = this.json.skins[skinIndex]; + const pending = []; + for (let i = 0, il = skinDef.joints.length; i < il; i++) { + pending.push(this._loadNodeShallow(skinDef.joints[i])); + } + if (skinDef.inverseBindMatrices !== void 0) { + pending.push(this.getDependency("accessor", skinDef.inverseBindMatrices)); + } else { + pending.push(null); + } + return Promise.all(pending).then(function(results) { + const inverseBindMatrices = results.pop(); + const jointNodes = results; + const bones = []; + const boneInverses = []; + for (let i = 0, il = jointNodes.length; i < il; i++) { + const jointNode = jointNodes[i]; + if (jointNode) { + bones.push(jointNode); + const mat = new Matrix4(); + if (inverseBindMatrices !== null) { + mat.fromArray(inverseBindMatrices.array, i * 16); + } + boneInverses.push(mat); + } else { + console.warn('THREE.GLTFLoader: Joint "%s" could not be found.', skinDef.joints[i]); + } + } + return new Skeleton(bones, boneInverses); + }); + } + /** + * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#animations + * @param {number} animationIndex + * @return {Promise} + */ + loadAnimation(animationIndex) { + const json = this.json; + const parser = this; + const animationDef = json.animations[animationIndex]; + const animationName = animationDef.name ? animationDef.name : "animation_" + animationIndex; + const pendingNodes = []; + const pendingInputAccessors = []; + const pendingOutputAccessors = []; + const pendingSamplers = []; + const pendingTargets = []; + for (let i = 0, il = animationDef.channels.length; i < il; i++) { + const channel = animationDef.channels[i]; + const sampler = animationDef.samplers[channel.sampler]; + const target = channel.target; + const name = target.node; + const input = animationDef.parameters !== void 0 ? animationDef.parameters[sampler.input] : sampler.input; + const output = animationDef.parameters !== void 0 ? animationDef.parameters[sampler.output] : sampler.output; + if (target.node === void 0) continue; + pendingNodes.push(this.getDependency("node", name)); + pendingInputAccessors.push(this.getDependency("accessor", input)); + pendingOutputAccessors.push(this.getDependency("accessor", output)); + pendingSamplers.push(sampler); + pendingTargets.push(target); + } + return Promise.all([ + Promise.all(pendingNodes), + Promise.all(pendingInputAccessors), + Promise.all(pendingOutputAccessors), + Promise.all(pendingSamplers), + Promise.all(pendingTargets) + ]).then(function(dependencies) { + const nodes = dependencies[0]; + const inputAccessors = dependencies[1]; + const outputAccessors = dependencies[2]; + const samplers = dependencies[3]; + const targets = dependencies[4]; + const tracks = []; + for (let i = 0, il = nodes.length; i < il; i++) { + const node = nodes[i]; + const inputAccessor = inputAccessors[i]; + const outputAccessor = outputAccessors[i]; + const sampler = samplers[i]; + const target = targets[i]; + if (node === void 0) continue; + if (node.updateMatrix) { + node.updateMatrix(); + } + const createdTracks = parser._createAnimationTracks(node, inputAccessor, outputAccessor, sampler, target); + if (createdTracks) { + for (let k = 0; k < createdTracks.length; k++) { + tracks.push(createdTracks[k]); + } + } + } + return new AnimationClip(animationName, void 0, tracks); + }); + } + createNodeMesh(nodeIndex) { + const json = this.json; + const parser = this; + const nodeDef = json.nodes[nodeIndex]; + if (nodeDef.mesh === void 0) return null; + return parser.getDependency("mesh", nodeDef.mesh).then(function(mesh) { + const node = parser._getNodeRef(parser.meshCache, nodeDef.mesh, mesh); + if (nodeDef.weights !== void 0) { + node.traverse(function(o) { + if (!o.isMesh) return; + for (let i = 0, il = nodeDef.weights.length; i < il; i++) { + o.morphTargetInfluences[i] = nodeDef.weights[i]; + } + }); + } + return node; + }); + } + /** + * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#nodes-and-hierarchy + * @param {number} nodeIndex + * @return {Promise} + */ + loadNode(nodeIndex) { + const json = this.json; + const parser = this; + const nodeDef = json.nodes[nodeIndex]; + const nodePending = parser._loadNodeShallow(nodeIndex); + const childPending = []; + const childrenDef = nodeDef.children || []; + for (let i = 0, il = childrenDef.length; i < il; i++) { + childPending.push(parser.getDependency("node", childrenDef[i])); + } + const skeletonPending = nodeDef.skin === void 0 ? Promise.resolve(null) : parser.getDependency("skin", nodeDef.skin); + return Promise.all([ + nodePending, + Promise.all(childPending), + skeletonPending + ]).then(function(results) { + const node = results[0]; + const children = results[1]; + const skeleton = results[2]; + if (skeleton !== null) { + node.traverse(function(mesh) { + if (!mesh.isSkinnedMesh) return; + mesh.bind(skeleton, _identityMatrix); + }); + } + for (let i = 0, il = children.length; i < il; i++) { + node.add(children[i]); + } + return node; + }); + } + // ._loadNodeShallow() parses a single node. + // skin and child nodes are created and added in .loadNode() (no '_' prefix). + _loadNodeShallow(nodeIndex) { + const json = this.json; + const extensions = this.extensions; + const parser = this; + if (this.nodeCache[nodeIndex] !== void 0) { + return this.nodeCache[nodeIndex]; + } + const nodeDef = json.nodes[nodeIndex]; + const nodeName = nodeDef.name ? parser.createUniqueName(nodeDef.name) : ""; + const pending = []; + const meshPromise = parser._invokeOne(function(ext) { + return ext.createNodeMesh && ext.createNodeMesh(nodeIndex); + }); + if (meshPromise) { + pending.push(meshPromise); + } + if (nodeDef.camera !== void 0) { + pending.push(parser.getDependency("camera", nodeDef.camera).then(function(camera) { + return parser._getNodeRef(parser.cameraCache, nodeDef.camera, camera); + })); + } + parser._invokeAll(function(ext) { + return ext.createNodeAttachment && ext.createNodeAttachment(nodeIndex); + }).forEach(function(promise) { + pending.push(promise); + }); + this.nodeCache[nodeIndex] = Promise.all(pending).then(function(objects) { + let node; + if (nodeDef.isBone === true) { + node = new Bone(); + } else if (objects.length > 1) { + node = new Group(); + } else if (objects.length === 1) { + node = objects[0]; + } else { + node = new Object3D(); + } + if (node !== objects[0]) { + for (let i = 0, il = objects.length; i < il; i++) { + node.add(objects[i]); + } + } + if (nodeDef.name) { + node.userData.name = nodeDef.name; + node.name = nodeName; + } + assignExtrasToUserData(node, nodeDef); + if (nodeDef.extensions) addUnknownExtensionsToUserData(extensions, node, nodeDef); + if (nodeDef.matrix !== void 0) { + const matrix = new Matrix4(); + matrix.fromArray(nodeDef.matrix); + node.applyMatrix4(matrix); + } else { + if (nodeDef.translation !== void 0) { + node.position.fromArray(nodeDef.translation); + } + if (nodeDef.rotation !== void 0) { + node.quaternion.fromArray(nodeDef.rotation); + } + if (nodeDef.scale !== void 0) { + node.scale.fromArray(nodeDef.scale); + } + } + if (!parser.associations.has(node)) { + parser.associations.set(node, {}); + } + parser.associations.get(node).nodes = nodeIndex; + return node; + }); + return this.nodeCache[nodeIndex]; + } + /** + * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#scenes + * @param {number} sceneIndex + * @return {Promise} + */ + loadScene(sceneIndex) { + const extensions = this.extensions; + const sceneDef = this.json.scenes[sceneIndex]; + const parser = this; + const scene = new Group(); + if (sceneDef.name) scene.name = parser.createUniqueName(sceneDef.name); + assignExtrasToUserData(scene, sceneDef); + if (sceneDef.extensions) addUnknownExtensionsToUserData(extensions, scene, sceneDef); + const nodeIds = sceneDef.nodes || []; + const pending = []; + for (let i = 0, il = nodeIds.length; i < il; i++) { + pending.push(parser.getDependency("node", nodeIds[i])); + } + return Promise.all(pending).then(function(nodes) { + for (let i = 0, il = nodes.length; i < il; i++) { + scene.add(nodes[i]); + } + const reduceAssociations = (node) => { + const reducedAssociations = /* @__PURE__ */ new Map(); + for (const [key, value] of parser.associations) { + if (key instanceof Material || key instanceof Texture) { + reducedAssociations.set(key, value); + } + } + node.traverse((node2) => { + const mappings = parser.associations.get(node2); + if (mappings != null) { + reducedAssociations.set(node2, mappings); + } + }); + return reducedAssociations; + }; + parser.associations = reduceAssociations(scene); + return scene; + }); + } + _createAnimationTracks(node, inputAccessor, outputAccessor, sampler, target) { + const tracks = []; + const targetName = node.name ? node.name : node.uuid; + const targetNames = []; + if (PATH_PROPERTIES[target.path] === PATH_PROPERTIES.weights) { + node.traverse(function(object) { + if (object.morphTargetInfluences) { + targetNames.push(object.name ? object.name : object.uuid); + } + }); + } else { + targetNames.push(targetName); + } + let TypedKeyframeTrack; + switch (PATH_PROPERTIES[target.path]) { + case PATH_PROPERTIES.weights: + TypedKeyframeTrack = NumberKeyframeTrack; + break; + case PATH_PROPERTIES.rotation: + TypedKeyframeTrack = QuaternionKeyframeTrack; + break; + case PATH_PROPERTIES.position: + case PATH_PROPERTIES.scale: + TypedKeyframeTrack = VectorKeyframeTrack; + break; + default: + switch (outputAccessor.itemSize) { + case 1: + TypedKeyframeTrack = NumberKeyframeTrack; + break; + case 2: + case 3: + default: + TypedKeyframeTrack = VectorKeyframeTrack; + break; + } + break; + } + const interpolation = sampler.interpolation !== void 0 ? INTERPOLATION[sampler.interpolation] : InterpolateLinear; + const outputArray = this._getArrayFromAccessor(outputAccessor); + for (let j = 0, jl = targetNames.length; j < jl; j++) { + const track = new TypedKeyframeTrack( + targetNames[j] + "." + PATH_PROPERTIES[target.path], + inputAccessor.array, + outputArray, + interpolation + ); + if (sampler.interpolation === "CUBICSPLINE") { + this._createCubicSplineTrackInterpolant(track); + } + tracks.push(track); + } + return tracks; + } + _getArrayFromAccessor(accessor) { + let outputArray = accessor.array; + if (accessor.normalized) { + const scale = getNormalizedComponentScale(outputArray.constructor); + const scaled = new Float32Array(outputArray.length); + for (let j = 0, jl = outputArray.length; j < jl; j++) { + scaled[j] = outputArray[j] * scale; + } + outputArray = scaled; + } + return outputArray; + } + _createCubicSplineTrackInterpolant(track) { + track.createInterpolant = function InterpolantFactoryMethodGLTFCubicSpline(result) { + const interpolantType = this instanceof QuaternionKeyframeTrack ? GLTFCubicSplineQuaternionInterpolant : GLTFCubicSplineInterpolant; + return new interpolantType(this.times, this.values, this.getValueSize() / 3, result); + }; + track.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline = true; + } +}; +function computeBounds(geometry, primitiveDef, parser) { + const attributes = primitiveDef.attributes; + const box = new Box3(); + if (attributes.POSITION !== void 0) { + const accessor = parser.json.accessors[attributes.POSITION]; + const min = accessor.min; + const max2 = accessor.max; + if (min !== void 0 && max2 !== void 0) { + box.set( + new Vector3(min[0], min[1], min[2]), + new Vector3(max2[0], max2[1], max2[2]) + ); + if (accessor.normalized) { + const boxScale = getNormalizedComponentScale(WEBGL_COMPONENT_TYPES[accessor.componentType]); + box.min.multiplyScalar(boxScale); + box.max.multiplyScalar(boxScale); + } + } else { + console.warn("THREE.GLTFLoader: Missing min/max properties for accessor POSITION."); + return; + } + } else { + return; + } + const targets = primitiveDef.targets; + if (targets !== void 0) { + const maxDisplacement = new Vector3(); + const vector = new Vector3(); + for (let i = 0, il = targets.length; i < il; i++) { + const target = targets[i]; + if (target.POSITION !== void 0) { + const accessor = parser.json.accessors[target.POSITION]; + const min = accessor.min; + const max2 = accessor.max; + if (min !== void 0 && max2 !== void 0) { + vector.setX(Math.max(Math.abs(min[0]), Math.abs(max2[0]))); + vector.setY(Math.max(Math.abs(min[1]), Math.abs(max2[1]))); + vector.setZ(Math.max(Math.abs(min[2]), Math.abs(max2[2]))); + if (accessor.normalized) { + const boxScale = getNormalizedComponentScale(WEBGL_COMPONENT_TYPES[accessor.componentType]); + vector.multiplyScalar(boxScale); + } + maxDisplacement.max(vector); + } else { + console.warn("THREE.GLTFLoader: Missing min/max properties for accessor POSITION."); + } + } + } + box.expandByVector(maxDisplacement); + } + geometry.boundingBox = box; + const sphere = new Sphere(); + box.getCenter(sphere.center); + sphere.radius = box.min.distanceTo(box.max) / 2; + geometry.boundingSphere = sphere; +} +function addPrimitiveAttributes(geometry, primitiveDef, parser) { + const attributes = primitiveDef.attributes; + const pending = []; + function assignAttributeAccessor(accessorIndex, attributeName) { + return parser.getDependency("accessor", accessorIndex).then(function(accessor) { + geometry.setAttribute(attributeName, accessor); + }); + } + for (const gltfAttributeName in attributes) { + const threeAttributeName = ATTRIBUTES[gltfAttributeName] || gltfAttributeName.toLowerCase(); + if (threeAttributeName in geometry.attributes) continue; + pending.push(assignAttributeAccessor(attributes[gltfAttributeName], threeAttributeName)); + } + if (primitiveDef.indices !== void 0 && !geometry.index) { + const accessor = parser.getDependency("accessor", primitiveDef.indices).then(function(accessor2) { + geometry.setIndex(accessor2); + }); + pending.push(accessor); + } + if (ColorManagement.workingColorSpace !== LinearSRGBColorSpace && "COLOR_0" in attributes) { + console.warn(`THREE.GLTFLoader: Converting vertex colors from "srgb-linear" to "${ColorManagement.workingColorSpace}" not supported.`); + } + assignExtrasToUserData(geometry, primitiveDef); + computeBounds(geometry, primitiveDef, parser); + return Promise.all(pending).then(function() { + return primitiveDef.targets !== void 0 ? addMorphTargets(geometry, primitiveDef.targets, parser) : geometry; + }); +} + +// ../../node_modules/@mml-io/model-loader/build/index.js +var draco_decoder_default = "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"; +var draco_wasm_wrapper_default = "var $jscomp=$jscomp||{};$jscomp.scope={};$jscomp.arrayIteratorImpl=function(h){var n=0;return function(){return n<h.length?{done:!1,value:h[n++]}:{done:!0}}};$jscomp.arrayIterator=function(h){return{next:$jscomp.arrayIteratorImpl(h)}};$jscomp.makeIterator=function(h){var n="undefined"!=typeof Symbol&&Symbol.iterator&&h[Symbol.iterator];return n?n.call(h):$jscomp.arrayIterator(h)};$jscomp.ASSUME_ES5=!1;$jscomp.ASSUME_NO_NATIVE_MAP=!1;$jscomp.ASSUME_NO_NATIVE_SET=!1;$jscomp.SIMPLE_FROUND_POLYFILL=!1;
$jscomp.ISOLATE_POLYFILLS=!1;$jscomp.FORCE_POLYFILL_PROMISE=!1;$jscomp.FORCE_POLYFILL_PROMISE_WHEN_NO_UNHANDLED_REJECTION=!1;$jscomp.getGlobal=function(h){h=["object"==typeof globalThis&&globalThis,h,"object"==typeof window&&window,"object"==typeof self&&self,"object"==typeof global&&global];for(var n=0;n<h.length;++n){var k=h[n];if(k&&k.Math==Math)return k}throw Error("Cannot find global object");};$jscomp.global=$jscomp.getGlobal(this);
$jscomp.defineProperty=$jscomp.ASSUME_ES5||"function"==typeof Object.defineProperties?Object.defineProperty:function(h,n,k){if(h==Array.prototype||h==Object.prototype)return h;h[n]=k.value;return h};$jscomp.IS_SYMBOL_NATIVE="function"===typeof Symbol&&"symbol"===typeof Symbol("x");$jscomp.TRUST_ES6_POLYFILLS=!$jscomp.ISOLATE_POLYFILLS||$jscomp.IS_SYMBOL_NATIVE;$jscomp.polyfills={};$jscomp.propertyToPolyfillSymbol={};$jscomp.POLYFILL_PREFIX="$jscp$";
var $jscomp$lookupPolyfilledValue=function(h,n){var k=$jscomp.propertyToPolyfillSymbol[n];if(null==k)return h[n];k=h[k];return void 0!==k?k:h[n]};$jscomp.polyfill=function(h,n,k,p){n&&($jscomp.ISOLATE_POLYFILLS?$jscomp.polyfillIsolated(h,n,k,p):$jscomp.polyfillUnisolated(h,n,k,p))};
$jscomp.polyfillUnisolated=function(h,n,k,p){k=$jscomp.global;h=h.split(".");for(p=0;p<h.length-1;p++){var l=h[p];if(!(l in k))return;k=k[l]}h=h[h.length-1];p=k[h];n=n(p);n!=p&&null!=n&&$jscomp.defineProperty(k,h,{configurable:!0,writable:!0,value:n})};
$jscomp.polyfillIsolated=function(h,n,k,p){var l=h.split(".");h=1===l.length;p=l[0];p=!h&&p in $jscomp.polyfills?$jscomp.polyfills:$jscomp.global;for(var y=0;y<l.length-1;y++){var f=l[y];if(!(f in p))return;p=p[f]}l=l[l.length-1];k=$jscomp.IS_SYMBOL_NATIVE&&"es6"===k?p[l]:null;n=n(k);null!=n&&(h?$jscomp.defineProperty($jscomp.polyfills,l,{configurable:!0,writable:!0,value:n}):n!==k&&(void 0===$jscomp.propertyToPolyfillSymbol[l]&&(k=1E9*Math.random()>>>0,$jscomp.propertyToPolyfillSymbol[l]=$jscomp.IS_SYMBOL_NATIVE?
$jscomp.global.Symbol(l):$jscomp.POLYFILL_PREFIX+k+"$"+l),$jscomp.defineProperty(p,$jscomp.propertyToPolyfillSymbol[l],{configurable:!0,writable:!0,value:n})))};
$jscomp.polyfill("Promise",function(h){function n(){this.batch_=null}function k(f){return f instanceof l?f:new l(function(q,u){q(f)})}if(h&&(!($jscomp.FORCE_POLYFILL_PROMISE||$jscomp.FORCE_POLYFILL_PROMISE_WHEN_NO_UNHANDLED_REJECTION&&"undefined"===typeof $jscomp.global.PromiseRejectionEvent)||!$jscomp.global.Promise||-1===$jscomp.global.Promise.toString().indexOf("[native code]")))return h;n.prototype.asyncExecute=function(f){if(null==this.batch_){this.batch_=[];var q=this;this.asyncExecuteFunction(function(){q.executeBatch_()})}this.batch_.push(f)};
var p=$jscomp.global.setTimeout;n.prototype.asyncExecuteFunction=function(f){p(f,0)};n.prototype.executeBatch_=function(){for(;this.batch_&&this.batch_.length;){var f=this.batch_;this.batch_=[];for(var q=0;q<f.length;++q){var u=f[q];f[q]=null;try{u()}catch(A){this.asyncThrow_(A)}}}this.batch_=null};n.prototype.asyncThrow_=function(f){this.asyncExecuteFunction(function(){throw f;})};var l=function(f){this.state_=0;this.result_=void 0;this.onSettledCallbacks_=[];this.isRejectionHandled_=!1;var q=this.createResolveAndReject_();
try{f(q.resolve,q.reject)}catch(u){q.reject(u)}};l.prototype.createResolveAndReject_=function(){function f(A){return function(F){u||(u=!0,A.call(q,F))}}var q=this,u=!1;return{resolve:f(this.resolveTo_),reject:f(this.reject_)}};l.prototype.resolveTo_=function(f){if(f===this)this.reject_(new TypeError("A Promise cannot resolve to itself"));else if(f instanceof l)this.settleSameAsPromise_(f);else{a:switch(typeof f){case "object":var q=null!=f;break a;case "function":q=!0;break a;default:q=!1}q?this.resolveToNonPromiseObj_(f):
this.fulfill_(f)}};l.prototype.resolveToNonPromiseObj_=function(f){var q=void 0;try{q=f.then}catch(u){this.reject_(u);return}"function"==typeof q?this.settleSameAsThenable_(q,f):this.fulfill_(f)};l.prototype.reject_=function(f){this.settle_(2,f)};l.prototype.fulfill_=function(f){this.settle_(1,f)};l.prototype.settle_=function(f,q){if(0!=this.state_)throw Error("Cannot settle("+f+", "+q+"): Promise already settled in state"+this.state_);this.state_=f;this.result_=q;2===this.state_&&this.scheduleUnhandledRejectionCheck_();
this.executeOnSettledCallbacks_()};l.prototype.scheduleUnhandledRejectionCheck_=function(){var f=this;p(function(){if(f.notifyUnhandledRejection_()){var q=$jscomp.global.console;"undefined"!==typeof q&&q.error(f.result_)}},1)};l.prototype.notifyUnhandledRejection_=function(){if(this.isRejectionHandled_)return!1;var f=$jscomp.global.CustomEvent,q=$jscomp.global.Event,u=$jscomp.global.dispatchEvent;if("undefined"===typeof u)return!0;"function"===typeof f?f=new f("unhandledrejection",{cancelable:!0}):
"function"===typeof q?f=new q("unhandledrejection",{cancelable:!0}):(f=$jscomp.global.document.createEvent("CustomEvent"),f.initCustomEvent("unhandledrejection",!1,!0,f));f.promise=this;f.reason=this.result_;return u(f)};l.prototype.executeOnSettledCallbacks_=function(){if(null!=this.onSettledCallbacks_){for(var f=0;f<this.onSettledCallbacks_.length;++f)y.asyncExecute(this.onSettledCallbacks_[f]);this.onSettledCallbacks_=null}};var y=new n;l.prototype.settleSameAsPromise_=function(f){var q=this.createResolveAndReject_();
f.callWhenSettled_(q.resolve,q.reject)};l.prototype.settleSameAsThenable_=function(f,q){var u=this.createResolveAndReject_();try{f.call(q,u.resolve,u.reject)}catch(A){u.reject(A)}};l.prototype.then=function(f,q){function u(w,B){return"function"==typeof w?function(R){try{A(w(R))}catch(Z){F(Z)}}:B}var A,F,v=new l(function(w,B){A=w;F=B});this.callWhenSettled_(u(f,A),u(q,F));return v};l.prototype.catch=function(f){return this.then(void 0,f)};l.prototype.callWhenSettled_=function(f,q){function u(){switch(A.state_){case 1:f(A.result_);
break;case 2:q(A.result_);break;default:throw Error("Unexpected state: "+A.state_);}}var A=this;null==this.onSettledCallbacks_?y.asyncExecute(u):this.onSettledCallbacks_.push(u);this.isRejectionHandled_=!0};l.resolve=k;l.reject=function(f){return new l(function(q,u){u(f)})};l.race=function(f){return new l(function(q,u){for(var A=$jscomp.makeIterator(f),F=A.next();!F.done;F=A.next())k(F.value).callWhenSettled_(q,u)})};l.all=function(f){var q=$jscomp.makeIterator(f),u=q.next();return u.done?k([]):new l(function(A,
F){function v(R){return function(Z){w[R]=Z;B--;0==B&&A(w)}}var w=[],B=0;do w.push(void 0),B++,k(u.value).callWhenSettled_(v(w.length-1),F),u=q.next();while(!u.done)})};return l},"es6","es3");$jscomp.owns=function(h,n){return Object.prototype.hasOwnProperty.call(h,n)};$jscomp.assign=$jscomp.TRUST_ES6_POLYFILLS&&"function"==typeof Object.assign?Object.assign:function(h,n){for(var k=1;k<arguments.length;k++){var p=arguments[k];if(p)for(var l in p)$jscomp.owns(p,l)&&(h[l]=p[l])}return h};
$jscomp.polyfill("Object.assign",function(h){return h||$jscomp.assign},"es6","es3");$jscomp.checkStringArgs=function(h,n,k){if(null==h)throw new TypeError("The 'this' value for String.prototype."+k+" must not be null or undefined");if(n instanceof RegExp)throw new TypeError("First argument to String.prototype."+k+" must not be a regular expression");return h+""};
$jscomp.polyfill("String.prototype.startsWith",function(h){return h?h:function(n,k){var p=$jscomp.checkStringArgs(this,n,"startsWith");n+="";var l=p.length,y=n.length;k=Math.max(0,Math.min(k|0,p.length));for(var f=0;f<y&&k<l;)if(p[k++]!=n[f++])return!1;return f>=y}},"es6","es3");
$jscomp.polyfill("Array.prototype.copyWithin",function(h){function n(k){k=Number(k);return Infinity===k||-Infinity===k?k:k|0}return h?h:function(k,p,l){var y=this.length;k=n(k);p=n(p);l=void 0===l?y:n(l);k=0>k?Math.max(y+k,0):Math.min(k,y);p=0>p?Math.max(y+p,0):Math.min(p,y);l=0>l?Math.max(y+l,0):Math.min(l,y);if(k<p)for(;p<l;)p in this?this[k++]=this[p++]:(delete this[k++],p++);else for(l=Math.min(l,y+p-k),k+=l-p;l>p;)--l in this?this[--k]=this[l]:delete this[--k];return this}},"es6","es3");
$jscomp.typedArrayCopyWithin=function(h){return h?h:Array.prototype.copyWithin};$jscomp.polyfill("Int8Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");$jscomp.polyfill("Uint8Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");$jscomp.polyfill("Uint8ClampedArray.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");$jscomp.polyfill("Int16Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");
$jscomp.polyfill("Uint16Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");$jscomp.polyfill("Int32Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");$jscomp.polyfill("Uint32Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");$jscomp.polyfill("Float32Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");$jscomp.polyfill("Float64Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");
var DracoDecoderModule=function(){var h="undefined"!==typeof document&&document.currentScript?document.currentScript.src:void 0;"undefined"!==typeof __filename&&(h=h||__filename);return function(n){function k(e){return a.locateFile?a.locateFile(e,U):U+e}function p(e,b){if(e){var c=ia;var d=e+b;for(b=e;c[b]&&!(b>=d);)++b;if(16<b-e&&c.buffer&&ra)c=ra.decode(c.subarray(e,b));else{for(d="";e<b;){var g=c[e++];if(g&128){var t=c[e++]&63;if(192==(g&224))d+=String.fromCharCode((g&31)<<6|t);else{var aa=c[e++]&
63;g=224==(g&240)?(g&15)<<12|t<<6|aa:(g&7)<<18|t<<12|aa<<6|c[e++]&63;65536>g?d+=String.fromCharCode(g):(g-=65536,d+=String.fromCharCode(55296|g>>10,56320|g&1023))}}else d+=String.fromCharCode(g)}c=d}}else c="";return c}function l(){var e=ja.buffer;a.HEAP8=W=new Int8Array(e);a.HEAP16=new Int16Array(e);a.HEAP32=ca=new Int32Array(e);a.HEAPU8=ia=new Uint8Array(e);a.HEAPU16=new Uint16Array(e);a.HEAPU32=Y=new Uint32Array(e);a.HEAPF32=new Float32Array(e);a.HEAPF64=new Float64Array(e)}function y(e){if(a.onAbort)a.onAbort(e);
e="Aborted("+e+")";da(e);sa=!0;e=new WebAssembly.RuntimeError(e+". Build with -sASSERTIONS for more info.");ka(e);throw e;}function f(e){try{if(e==P&&ea)return new Uint8Array(ea);if(ma)return ma(e);throw"both async and sync fetching of the wasm failed";}catch(b){y(b)}}function q(){if(!ea&&(ta||fa)){if("function"==typeof fetch&&!P.startsWith("file://"))return fetch(P,{credentials:"same-origin"}).then(function(e){if(!e.ok)throw"failed to load wasm binary file at '"+P+"'";return e.arrayBuffer()}).catch(function(){return f(P)});
if(na)return new Promise(function(e,b){na(P,function(c){e(new Uint8Array(c))},b)})}return Promise.resolve().then(function(){return f(P)})}function u(e){for(;0<e.length;)e.shift()(a)}function A(e){this.excPtr=e;this.ptr=e-24;this.set_type=function(b){Y[this.ptr+4>>2]=b};this.get_type=function(){return Y[this.ptr+4>>2]};this.set_destructor=function(b){Y[this.ptr+8>>2]=b};this.get_destructor=function(){return Y[this.ptr+8>>2]};this.set_refcount=function(b){ca[this.ptr>>2]=b};this.set_caught=function(b){W[this.ptr+
12>>0]=b?1:0};this.get_caught=function(){return 0!=W[this.ptr+12>>0]};this.set_rethrown=function(b){W[this.ptr+13>>0]=b?1:0};this.get_rethrown=function(){return 0!=W[this.ptr+13>>0]};this.init=function(b,c){this.set_adjusted_ptr(0);this.set_type(b);this.set_destructor(c);this.set_refcount(0);this.set_caught(!1);this.set_rethrown(!1)};this.add_ref=function(){ca[this.ptr>>2]+=1};this.release_ref=function(){var b=ca[this.ptr>>2];ca[this.ptr>>2]=b-1;return 1===b};this.set_adjusted_ptr=function(b){Y[this.ptr+
16>>2]=b};this.get_adjusted_ptr=function(){return Y[this.ptr+16>>2]};this.get_exception_ptr=function(){if(ua(this.get_type()))return Y[this.excPtr>>2];var b=this.get_adjusted_ptr();return 0!==b?b:this.excPtr}}function F(){function e(){if(!la&&(la=!0,a.calledRun=!0,!sa)){va=!0;u(oa);wa(a);if(a.onRuntimeInitialized)a.onRuntimeInitialized();if(a.postRun)for("function"==typeof a.postRun&&(a.postRun=[a.postRun]);a.postRun.length;)xa.unshift(a.postRun.shift());u(xa)}}if(!(0<ba)){if(a.preRun)for("function"==
typeof a.preRun&&(a.preRun=[a.preRun]);a.preRun.length;)ya.unshift(a.preRun.shift());u(ya);0<ba||(a.setStatus?(a.setStatus("Running..."),setTimeout(function(){setTimeout(function(){a.setStatus("")},1);e()},1)):e())}}function v(){}function w(e){return(e||v).__cache__}function B(e,b){var c=w(b),d=c[e];if(d)return d;d=Object.create((b||v).prototype);d.ptr=e;return c[e]=d}function R(e){if("string"===typeof e){for(var b=0,c=0;c<e.length;++c){var d=e.charCodeAt(c);127>=d?b++:2047>=d?b+=2:55296<=d&&57343>=
d?(b+=4,++c):b+=3}b=Array(b+1);c=0;d=b.length;if(0<d){d=c+d-1;for(var g=0;g<e.length;++g){var t=e.charCodeAt(g);if(55296<=t&&57343>=t){var aa=e.charCodeAt(++g);t=65536+((t&1023)<<10)|aa&1023}if(127>=t){if(c>=d)break;b[c++]=t}else{if(2047>=t){if(c+1>=d)break;b[c++]=192|t>>6}else{if(65535>=t){if(c+2>=d)break;b[c++]=224|t>>12}else{if(c+3>=d)break;b[c++]=240|t>>18;b[c++]=128|t>>12&63}b[c++]=128|t>>6&63}b[c++]=128|t&63}}b[c]=0}e=r.alloc(b,W);r.copy(b,W,e);return e}return e}function Z(e){if("object"===
typeof e){var b=r.alloc(e,W);r.copy(e,W,b);return b}return e}function X(){throw"cannot construct a VoidPtr, no constructor in IDL";}function S(){this.ptr=za();w(S)[this.ptr]=this}function Q(){this.ptr=Aa();w(Q)[this.ptr]=this}function V(){this.ptr=Ba();w(V)[this.ptr]=this}function x(){this.ptr=Ca();w(x)[this.ptr]=this}function D(){this.ptr=Da();w(D)[this.ptr]=this}function G(){this.ptr=Ea();w(G)[this.ptr]=this}function H(){this.ptr=Fa();w(H)[this.ptr]=this}function E(){this.ptr=Ga();w(E)[this.ptr]=
this}function T(){this.ptr=Ha();w(T)[this.ptr]=this}function C(){throw"cannot construct a Status, no constructor in IDL";}function I(){this.ptr=Ia();w(I)[this.ptr]=this}function J(){this.ptr=Ja();w(J)[this.ptr]=this}function K(){this.ptr=Ka();w(K)[this.ptr]=this}function L(){this.ptr=La();w(L)[this.ptr]=this}function M(){this.ptr=Ma();w(M)[this.ptr]=this}function N(){this.ptr=Na();w(N)[this.ptr]=this}function O(){this.ptr=Oa();w(O)[this.ptr]=this}function z(){this.ptr=Pa();w(z)[this.ptr]=this}function m(){this.ptr=
Qa();w(m)[this.ptr]=this}n=void 0===n?{}:n;var a="undefined"!=typeof n?n:{},wa,ka;a.ready=new Promise(function(e,b){wa=e;ka=b});var Ra=!1,Sa=!1;a.onRuntimeInitialized=function(){Ra=!0;if(Sa&&"function"===typeof a.onModuleLoaded)a.onModuleLoaded(a)};a.onModuleParsed=function(){Sa=!0;if(Ra&&"function"===typeof a.onModuleLoaded)a.onModuleLoaded(a)};a.isVersionSupported=function(e){if("string"!==typeof e)return!1;e=e.split(".");return 2>e.length||3<e.length?!1:1==e[0]&&0<=e[1]&&5>=e[1]?!0:0!=e[0]||10<
e[1]?!1:!0};var Ta=Object.assign({},a),ta="object"==typeof window,fa="function"==typeof importScripts,Ua="object"==typeof process&&"object"==typeof process.versions&&"string"==typeof process.versions.node,U="";if(Ua){var Va=require("fs"),pa=require("path");U=fa?pa.dirname(U)+"/":__dirname+"/";var Wa=function(e,b){e=e.startsWith("file://")?new URL(e):pa.normalize(e);return Va.readFileSync(e,b?void 0:"utf8")};var ma=function(e){e=Wa(e,!0);e.buffer||(e=new Uint8Array(e));return e};var na=function(e,
b,c){e=e.startsWith("file://")?new URL(e):pa.normalize(e);Va.readFile(e,function(d,g){d?c(d):b(g.buffer)})};1<process.argv.length&&process.argv[1].replace(/\\/g,"/");process.argv.slice(2);a.inspect=function(){return"[Emscripten Module object]"}}else if(ta||fa)fa?U=self.location.href:"undefined"!=typeof document&&document.currentScript&&(U=document.currentScript.src),h&&(U=h),U=0!==U.indexOf("blob:")?U.substr(0,U.replace(/[?#].*/,"").lastIndexOf("/")+1):"",Wa=function(e){var b=new XMLHttpRequest;b.open("GET",
e,!1);b.send(null);return b.responseText},fa&&(ma=function(e){var b=new XMLHttpRequest;b.open("GET",e,!1);b.responseType="arraybuffer";b.send(null);return new Uint8Array(b.response)}),na=function(e,b,c){var d=new XMLHttpRequest;d.open("GET",e,!0);d.responseType="arraybuffer";d.onload=function(){200==d.status||0==d.status&&d.response?b(d.response):c()};d.onerror=c;d.send(null)};a.print||console.log.bind(console);var da=a.printErr||console.warn.bind(console);Object.assign(a,Ta);Ta=null;var ea;a.wasmBinary&&
(ea=a.wasmBinary);"object"!=typeof WebAssembly&&y("no native wasm support detected");var ja,sa=!1,ra="undefined"!=typeof TextDecoder?new TextDecoder("utf8"):void 0,W,ia,ca,Y,ya=[],oa=[],xa=[],va=!1,ba=0,qa=null,ha=null;var P="draco_decoder_gltf.wasm";P.startsWith("data:application/octet-stream;base64,")||(P=k(P));var pd=0,qd={b:function(e,b,c){(new A(e)).init(b,c);pd++;throw e;},a:function(){y("")},d:function(e,b,c){ia.copyWithin(e,b,b+c)},c:function(e){var b=ia.length;e>>>=0;if(2147483648<e)return!1;
for(var c=1;4>=c;c*=2){var d=b*(1+.2/c);d=Math.min(d,e+100663296);var g=Math;d=Math.max(e,d);g=g.min.call(g,2147483648,d+(65536-d%65536)%65536);a:{d=ja.buffer;try{ja.grow(g-d.byteLength+65535>>>16);l();var t=1;break a}catch(aa){}t=void 0}if(t)return!0}return!1}};(function(){function e(g,t){a.asm=g.exports;ja=a.asm.e;l();oa.unshift(a.asm.f);ba--;a.monitorRunDependencies&&a.monitorRunDependencies(ba);0==ba&&(null!==qa&&(clearInterval(qa),qa=null),ha&&(g=ha,ha=null,g()))}function b(g){e(g.instance)}
function c(g){return q().then(function(t){return WebAssembly.instantiate(t,d)}).then(function(t){return t}).then(g,function(t){da("failed to asynchronously prepare wasm: "+t);y(t)})}var d={a:qd};ba++;a.monitorRunDependencies&&a.monitorRunDependencies(ba);if(a.instantiateWasm)try{return a.instantiateWasm(d,e)}catch(g){da("Module.instantiateWasm callback failed with error: "+g),ka(g)}(function(){return ea||"function"!=typeof WebAssembly.instantiateStreaming||P.startsWith("data:application/octet-stream;base64,")||
P.startsWith("file://")||Ua||"function"!=typeof fetch?c(b):fetch(P,{credentials:"same-origin"}).then(function(g){return WebAssembly.instantiateStreaming(g,d).then(b,function(t){da("wasm streaming compile failed: "+t);da("falling back to ArrayBuffer instantiation");return c(b)})})})().catch(ka);return{}})();var Xa=a._emscripten_bind_VoidPtr___destroy___0=function(){return(Xa=a._emscripten_bind_VoidPtr___destroy___0=a.asm.h).apply(null,arguments)},za=a._emscripten_bind_DecoderBuffer_DecoderBuffer_0=
function(){return(za=a._emscripten_bind_DecoderBuffer_DecoderBuffer_0=a.asm.i).apply(null,arguments)},Ya=a._emscripten_bind_DecoderBuffer_Init_2=function(){return(Ya=a._emscripten_bind_DecoderBuffer_Init_2=a.asm.j).apply(null,arguments)},Za=a._emscripten_bind_DecoderBuffer___destroy___0=function(){return(Za=a._emscripten_bind_DecoderBuffer___destroy___0=a.asm.k).apply(null,arguments)},Aa=a._emscripten_bind_AttributeTransformData_AttributeTransformData_0=function(){return(Aa=a._emscripten_bind_AttributeTransformData_AttributeTransformData_0=
a.asm.l).apply(null,arguments)},$a=a._emscripten_bind_AttributeTransformData_transform_type_0=function(){return($a=a._emscripten_bind_AttributeTransformData_transform_type_0=a.asm.m).apply(null,arguments)},ab=a._emscripten_bind_AttributeTransformData___destroy___0=function(){return(ab=a._emscripten_bind_AttributeTransformData___destroy___0=a.asm.n).apply(null,arguments)},Ba=a._emscripten_bind_GeometryAttribute_GeometryAttribute_0=function(){return(Ba=a._emscripten_bind_GeometryAttribute_GeometryAttribute_0=
a.asm.o).apply(null,arguments)},bb=a._emscripten_bind_GeometryAttribute___destroy___0=function(){return(bb=a._emscripten_bind_GeometryAttribute___destroy___0=a.asm.p).apply(null,arguments)},Ca=a._emscripten_bind_PointAttribute_PointAttribute_0=function(){return(Ca=a._emscripten_bind_PointAttribute_PointAttribute_0=a.asm.q).apply(null,arguments)},cb=a._emscripten_bind_PointAttribute_size_0=function(){return(cb=a._emscripten_bind_PointAttribute_size_0=a.asm.r).apply(null,arguments)},db=a._emscripten_bind_PointAttribute_GetAttributeTransformData_0=
function(){return(db=a._emscripten_bind_PointAttribute_GetAttributeTransformData_0=a.asm.s).apply(null,arguments)},eb=a._emscripten_bind_PointAttribute_attribute_type_0=function(){return(eb=a._emscripten_bind_PointAttribute_attribute_type_0=a.asm.t).apply(null,arguments)},fb=a._emscripten_bind_PointAttribute_data_type_0=function(){return(fb=a._emscripten_bind_PointAttribute_data_type_0=a.asm.u).apply(null,arguments)},gb=a._emscripten_bind_PointAttribute_num_components_0=function(){return(gb=a._emscripten_bind_PointAttribute_num_components_0=
a.asm.v).apply(null,arguments)},hb=a._emscripten_bind_PointAttribute_normalized_0=function(){return(hb=a._emscripten_bind_PointAttribute_normalized_0=a.asm.w).apply(null,arguments)},ib=a._emscripten_bind_PointAttribute_byte_stride_0=function(){return(ib=a._emscripten_bind_PointAttribute_byte_stride_0=a.asm.x).apply(null,arguments)},jb=a._emscripten_bind_PointAttribute_byte_offset_0=function(){return(jb=a._emscripten_bind_PointAttribute_byte_offset_0=a.asm.y).apply(null,arguments)},kb=a._emscripten_bind_PointAttribute_unique_id_0=
function(){return(kb=a._emscripten_bind_PointAttribute_unique_id_0=a.asm.z).apply(null,arguments)},lb=a._emscripten_bind_PointAttribute___destroy___0=function(){return(lb=a._emscripten_bind_PointAttribute___destroy___0=a.asm.A).apply(null,arguments)},Da=a._emscripten_bind_AttributeQuantizationTransform_AttributeQuantizationTransform_0=function(){return(Da=a._emscripten_bind_AttributeQuantizationTransform_AttributeQuantizationTransform_0=a.asm.B).apply(null,arguments)},mb=a._emscripten_bind_AttributeQuantizationTransform_InitFromAttribute_1=
function(){return(mb=a._emscripten_bind_AttributeQuantizationTransform_InitFromAttribute_1=a.asm.C).apply(null,arguments)},nb=a._emscripten_bind_AttributeQuantizationTransform_quantization_bits_0=function(){return(nb=a._emscripten_bind_AttributeQuantizationTransform_quantization_bits_0=a.asm.D).apply(null,arguments)},ob=a._emscripten_bind_AttributeQuantizationTransform_min_value_1=function(){return(ob=a._emscripten_bind_AttributeQuantizationTransform_min_value_1=a.asm.E).apply(null,arguments)},pb=
a._emscripten_bind_AttributeQuantizationTransform_range_0=function(){return(pb=a._emscripten_bind_AttributeQuantizationTransform_range_0=a.asm.F).apply(null,arguments)},qb=a._emscripten_bind_AttributeQuantizationTransform___destroy___0=function(){return(qb=a._emscripten_bind_AttributeQuantizationTransform___destroy___0=a.asm.G).apply(null,arguments)},Ea=a._emscripten_bind_AttributeOctahedronTransform_AttributeOctahedronTransform_0=function(){return(Ea=a._emscripten_bind_AttributeOctahedronTransform_AttributeOctahedronTransform_0=
a.asm.H).apply(null,arguments)},rb=a._emscripten_bind_AttributeOctahedronTransform_InitFromAttribute_1=function(){return(rb=a._emscripten_bind_AttributeOctahedronTransform_InitFromAttribute_1=a.asm.I).apply(null,arguments)},sb=a._emscripten_bind_AttributeOctahedronTransform_quantization_bits_0=function(){return(sb=a._emscripten_bind_AttributeOctahedronTransform_quantization_bits_0=a.asm.J).apply(null,arguments)},tb=a._emscripten_bind_AttributeOctahedronTransform___destroy___0=function(){return(tb=
a._emscripten_bind_AttributeOctahedronTransform___destroy___0=a.asm.K).apply(null,arguments)},Fa=a._emscripten_bind_PointCloud_PointCloud_0=function(){return(Fa=a._emscripten_bind_PointCloud_PointCloud_0=a.asm.L).apply(null,arguments)},ub=a._emscripten_bind_PointCloud_num_attributes_0=function(){return(ub=a._emscripten_bind_PointCloud_num_attributes_0=a.asm.M).apply(null,arguments)},vb=a._emscripten_bind_PointCloud_num_points_0=function(){return(vb=a._emscripten_bind_PointCloud_num_points_0=a.asm.N).apply(null,
arguments)},wb=a._emscripten_bind_PointCloud___destroy___0=function(){return(wb=a._emscripten_bind_PointCloud___destroy___0=a.asm.O).apply(null,arguments)},Ga=a._emscripten_bind_Mesh_Mesh_0=function(){return(Ga=a._emscripten_bind_Mesh_Mesh_0=a.asm.P).apply(null,arguments)},xb=a._emscripten_bind_Mesh_num_faces_0=function(){return(xb=a._emscripten_bind_Mesh_num_faces_0=a.asm.Q).apply(null,arguments)},yb=a._emscripten_bind_Mesh_num_attributes_0=function(){return(yb=a._emscripten_bind_Mesh_num_attributes_0=
a.asm.R).apply(null,arguments)},zb=a._emscripten_bind_Mesh_num_points_0=function(){return(zb=a._emscripten_bind_Mesh_num_points_0=a.asm.S).apply(null,arguments)},Ab=a._emscripten_bind_Mesh___destroy___0=function(){return(Ab=a._emscripten_bind_Mesh___destroy___0=a.asm.T).apply(null,arguments)},Ha=a._emscripten_bind_Metadata_Metadata_0=function(){return(Ha=a._emscripten_bind_Metadata_Metadata_0=a.asm.U).apply(null,arguments)},Bb=a._emscripten_bind_Metadata___destroy___0=function(){return(Bb=a._emscripten_bind_Metadata___destroy___0=
a.asm.V).apply(null,arguments)},Cb=a._emscripten_bind_Status_code_0=function(){return(Cb=a._emscripten_bind_Status_code_0=a.asm.W).apply(null,arguments)},Db=a._emscripten_bind_Status_ok_0=function(){return(Db=a._emscripten_bind_Status_ok_0=a.asm.X).apply(null,arguments)},Eb=a._emscripten_bind_Status_error_msg_0=function(){return(Eb=a._emscripten_bind_Status_error_msg_0=a.asm.Y).apply(null,arguments)},Fb=a._emscripten_bind_Status___destroy___0=function(){return(Fb=a._emscripten_bind_Status___destroy___0=
a.asm.Z).apply(null,arguments)},Ia=a._emscripten_bind_DracoFloat32Array_DracoFloat32Array_0=function(){return(Ia=a._emscripten_bind_DracoFloat32Array_DracoFloat32Array_0=a.asm._).apply(null,arguments)},Gb=a._emscripten_bind_DracoFloat32Array_GetValue_1=function(){return(Gb=a._emscripten_bind_DracoFloat32Array_GetValue_1=a.asm.$).apply(null,arguments)},Hb=a._emscripten_bind_DracoFloat32Array_size_0=function(){return(Hb=a._emscripten_bind_DracoFloat32Array_size_0=a.asm.aa).apply(null,arguments)},Ib=
a._emscripten_bind_DracoFloat32Array___destroy___0=function(){return(Ib=a._emscripten_bind_DracoFloat32Array___destroy___0=a.asm.ba).apply(null,arguments)},Ja=a._emscripten_bind_DracoInt8Array_DracoInt8Array_0=function(){return(Ja=a._emscripten_bind_DracoInt8Array_DracoInt8Array_0=a.asm.ca).apply(null,arguments)},Jb=a._emscripten_bind_DracoInt8Array_GetValue_1=function(){return(Jb=a._emscripten_bind_DracoInt8Array_GetValue_1=a.asm.da).apply(null,arguments)},Kb=a._emscripten_bind_DracoInt8Array_size_0=
function(){return(Kb=a._emscripten_bind_DracoInt8Array_size_0=a.asm.ea).apply(null,arguments)},Lb=a._emscripten_bind_DracoInt8Array___destroy___0=function(){return(Lb=a._emscripten_bind_DracoInt8Array___destroy___0=a.asm.fa).apply(null,arguments)},Ka=a._emscripten_bind_DracoUInt8Array_DracoUInt8Array_0=function(){return(Ka=a._emscripten_bind_DracoUInt8Array_DracoUInt8Array_0=a.asm.ga).apply(null,arguments)},Mb=a._emscripten_bind_DracoUInt8Array_GetValue_1=function(){return(Mb=a._emscripten_bind_DracoUInt8Array_GetValue_1=
a.asm.ha).apply(null,arguments)},Nb=a._emscripten_bind_DracoUInt8Array_size_0=function(){return(Nb=a._emscripten_bind_DracoUInt8Array_size_0=a.asm.ia).apply(null,arguments)},Ob=a._emscripten_bind_DracoUInt8Array___destroy___0=function(){return(Ob=a._emscripten_bind_DracoUInt8Array___destroy___0=a.asm.ja).apply(null,arguments)},La=a._emscripten_bind_DracoInt16Array_DracoInt16Array_0=function(){return(La=a._emscripten_bind_DracoInt16Array_DracoInt16Array_0=a.asm.ka).apply(null,arguments)},Pb=a._emscripten_bind_DracoInt16Array_GetValue_1=
function(){return(Pb=a._emscripten_bind_DracoInt16Array_GetValue_1=a.asm.la).apply(null,arguments)},Qb=a._emscripten_bind_DracoInt16Array_size_0=function(){return(Qb=a._emscripten_bind_DracoInt16Array_size_0=a.asm.ma).apply(null,arguments)},Rb=a._emscripten_bind_DracoInt16Array___destroy___0=function(){return(Rb=a._emscripten_bind_DracoInt16Array___destroy___0=a.asm.na).apply(null,arguments)},Ma=a._emscripten_bind_DracoUInt16Array_DracoUInt16Array_0=function(){return(Ma=a._emscripten_bind_DracoUInt16Array_DracoUInt16Array_0=
a.asm.oa).apply(null,arguments)},Sb=a._emscripten_bind_DracoUInt16Array_GetValue_1=function(){return(Sb=a._emscripten_bind_DracoUInt16Array_GetValue_1=a.asm.pa).apply(null,arguments)},Tb=a._emscripten_bind_DracoUInt16Array_size_0=function(){return(Tb=a._emscripten_bind_DracoUInt16Array_size_0=a.asm.qa).apply(null,arguments)},Ub=a._emscripten_bind_DracoUInt16Array___destroy___0=function(){return(Ub=a._emscripten_bind_DracoUInt16Array___destroy___0=a.asm.ra).apply(null,arguments)},Na=a._emscripten_bind_DracoInt32Array_DracoInt32Array_0=
function(){return(Na=a._emscripten_bind_DracoInt32Array_DracoInt32Array_0=a.asm.sa).apply(null,arguments)},Vb=a._emscripten_bind_DracoInt32Array_GetValue_1=function(){return(Vb=a._emscripten_bind_DracoInt32Array_GetValue_1=a.asm.ta).apply(null,arguments)},Wb=a._emscripten_bind_DracoInt32Array_size_0=function(){return(Wb=a._emscripten_bind_DracoInt32Array_size_0=a.asm.ua).apply(null,arguments)},Xb=a._emscripten_bind_DracoInt32Array___destroy___0=function(){return(Xb=a._emscripten_bind_DracoInt32Array___destroy___0=
a.asm.va).apply(null,arguments)},Oa=a._emscripten_bind_DracoUInt32Array_DracoUInt32Array_0=function(){return(Oa=a._emscripten_bind_DracoUInt32Array_DracoUInt32Array_0=a.asm.wa).apply(null,arguments)},Yb=a._emscripten_bind_DracoUInt32Array_GetValue_1=function(){return(Yb=a._emscripten_bind_DracoUInt32Array_GetValue_1=a.asm.xa).apply(null,arguments)},Zb=a._emscripten_bind_DracoUInt32Array_size_0=function(){return(Zb=a._emscripten_bind_DracoUInt32Array_size_0=a.asm.ya).apply(null,arguments)},$b=a._emscripten_bind_DracoUInt32Array___destroy___0=
function(){return($b=a._emscripten_bind_DracoUInt32Array___destroy___0=a.asm.za).apply(null,arguments)},Pa=a._emscripten_bind_MetadataQuerier_MetadataQuerier_0=function(){return(Pa=a._emscripten_bind_MetadataQuerier_MetadataQuerier_0=a.asm.Aa).apply(null,arguments)},ac=a._emscripten_bind_MetadataQuerier_HasEntry_2=function(){return(ac=a._emscripten_bind_MetadataQuerier_HasEntry_2=a.asm.Ba).apply(null,arguments)},bc=a._emscripten_bind_MetadataQuerier_GetIntEntry_2=function(){return(bc=a._emscripten_bind_MetadataQuerier_GetIntEntry_2=
a.asm.Ca).apply(null,arguments)},cc=a._emscripten_bind_MetadataQuerier_GetIntEntryArray_3=function(){return(cc=a._emscripten_bind_MetadataQuerier_GetIntEntryArray_3=a.asm.Da).apply(null,arguments)},dc=a._emscripten_bind_MetadataQuerier_GetDoubleEntry_2=function(){return(dc=a._emscripten_bind_MetadataQuerier_GetDoubleEntry_2=a.asm.Ea).apply(null,arguments)},ec=a._emscripten_bind_MetadataQuerier_GetStringEntry_2=function(){return(ec=a._emscripten_bind_MetadataQuerier_GetStringEntry_2=a.asm.Fa).apply(null,
arguments)},fc=a._emscripten_bind_MetadataQuerier_NumEntries_1=function(){return(fc=a._emscripten_bind_MetadataQuerier_NumEntries_1=a.asm.Ga).apply(null,arguments)},gc=a._emscripten_bind_MetadataQuerier_GetEntryName_2=function(){return(gc=a._emscripten_bind_MetadataQuerier_GetEntryName_2=a.asm.Ha).apply(null,arguments)},hc=a._emscripten_bind_MetadataQuerier___destroy___0=function(){return(hc=a._emscripten_bind_MetadataQuerier___destroy___0=a.asm.Ia).apply(null,arguments)},Qa=a._emscripten_bind_Decoder_Decoder_0=
function(){return(Qa=a._emscripten_bind_Decoder_Decoder_0=a.asm.Ja).apply(null,arguments)},ic=a._emscripten_bind_Decoder_DecodeArrayToPointCloud_3=function(){return(ic=a._emscripten_bind_Decoder_DecodeArrayToPointCloud_3=a.asm.Ka).apply(null,arguments)},jc=a._emscripten_bind_Decoder_DecodeArrayToMesh_3=function(){return(jc=a._emscripten_bind_Decoder_DecodeArrayToMesh_3=a.asm.La).apply(null,arguments)},kc=a._emscripten_bind_Decoder_GetAttributeId_2=function(){return(kc=a._emscripten_bind_Decoder_GetAttributeId_2=
a.asm.Ma).apply(null,arguments)},lc=a._emscripten_bind_Decoder_GetAttributeIdByName_2=function(){return(lc=a._emscripten_bind_Decoder_GetAttributeIdByName_2=a.asm.Na).apply(null,arguments)},mc=a._emscripten_bind_Decoder_GetAttributeIdByMetadataEntry_3=function(){return(mc=a._emscripten_bind_Decoder_GetAttributeIdByMetadataEntry_3=a.asm.Oa).apply(null,arguments)},nc=a._emscripten_bind_Decoder_GetAttribute_2=function(){return(nc=a._emscripten_bind_Decoder_GetAttribute_2=a.asm.Pa).apply(null,arguments)},
oc=a._emscripten_bind_Decoder_GetAttributeByUniqueId_2=function(){return(oc=a._emscripten_bind_Decoder_GetAttributeByUniqueId_2=a.asm.Qa).apply(null,arguments)},pc=a._emscripten_bind_Decoder_GetMetadata_1=function(){return(pc=a._emscripten_bind_Decoder_GetMetadata_1=a.asm.Ra).apply(null,arguments)},qc=a._emscripten_bind_Decoder_GetAttributeMetadata_2=function(){return(qc=a._emscripten_bind_Decoder_GetAttributeMetadata_2=a.asm.Sa).apply(null,arguments)},rc=a._emscripten_bind_Decoder_GetFaceFromMesh_3=
function(){return(rc=a._emscripten_bind_Decoder_GetFaceFromMesh_3=a.asm.Ta).apply(null,arguments)},sc=a._emscripten_bind_Decoder_GetTriangleStripsFromMesh_2=function(){return(sc=a._emscripten_bind_Decoder_GetTriangleStripsFromMesh_2=a.asm.Ua).apply(null,arguments)},tc=a._emscripten_bind_Decoder_GetTrianglesUInt16Array_3=function(){return(tc=a._emscripten_bind_Decoder_GetTrianglesUInt16Array_3=a.asm.Va).apply(null,arguments)},uc=a._emscripten_bind_Decoder_GetTrianglesUInt32Array_3=function(){return(uc=
a._emscripten_bind_Decoder_GetTrianglesUInt32Array_3=a.asm.Wa).apply(null,arguments)},vc=a._emscripten_bind_Decoder_GetAttributeFloat_3=function(){return(vc=a._emscripten_bind_Decoder_GetAttributeFloat_3=a.asm.Xa).apply(null,arguments)},wc=a._emscripten_bind_Decoder_GetAttributeFloatForAllPoints_3=function(){return(wc=a._emscripten_bind_Decoder_GetAttributeFloatForAllPoints_3=a.asm.Ya).apply(null,arguments)},xc=a._emscripten_bind_Decoder_GetAttributeIntForAllPoints_3=function(){return(xc=a._emscripten_bind_Decoder_GetAttributeIntForAllPoints_3=
a.asm.Za).apply(null,arguments)},yc=a._emscripten_bind_Decoder_GetAttributeInt8ForAllPoints_3=function(){return(yc=a._emscripten_bind_Decoder_GetAttributeInt8ForAllPoints_3=a.asm._a).apply(null,arguments)},zc=a._emscripten_bind_Decoder_GetAttributeUInt8ForAllPoints_3=function(){return(zc=a._emscripten_bind_Decoder_GetAttributeUInt8ForAllPoints_3=a.asm.$a).apply(null,arguments)},Ac=a._emscripten_bind_Decoder_GetAttributeInt16ForAllPoints_3=function(){return(Ac=a._emscripten_bind_Decoder_GetAttributeInt16ForAllPoints_3=
a.asm.ab).apply(null,arguments)},Bc=a._emscripten_bind_Decoder_GetAttributeUInt16ForAllPoints_3=function(){return(Bc=a._emscripten_bind_Decoder_GetAttributeUInt16ForAllPoints_3=a.asm.bb).apply(null,arguments)},Cc=a._emscripten_bind_Decoder_GetAttributeInt32ForAllPoints_3=function(){return(Cc=a._emscripten_bind_Decoder_GetAttributeInt32ForAllPoints_3=a.asm.cb).apply(null,arguments)},Dc=a._emscripten_bind_Decoder_GetAttributeUInt32ForAllPoints_3=function(){return(Dc=a._emscripten_bind_Decoder_GetAttributeUInt32ForAllPoints_3=
a.asm.db).apply(null,arguments)},Ec=a._emscripten_bind_Decoder_GetAttributeDataArrayForAllPoints_5=function(){return(Ec=a._emscripten_bind_Decoder_GetAttributeDataArrayForAllPoints_5=a.asm.eb).apply(null,arguments)},Fc=a._emscripten_bind_Decoder_SkipAttributeTransform_1=function(){return(Fc=a._emscripten_bind_Decoder_SkipAttributeTransform_1=a.asm.fb).apply(null,arguments)},Gc=a._emscripten_bind_Decoder_GetEncodedGeometryType_Deprecated_1=function(){return(Gc=a._emscripten_bind_Decoder_GetEncodedGeometryType_Deprecated_1=
a.asm.gb).apply(null,arguments)},Hc=a._emscripten_bind_Decoder_DecodeBufferToPointCloud_2=function(){return(Hc=a._emscripten_bind_Decoder_DecodeBufferToPointCloud_2=a.asm.hb).apply(null,arguments)},Ic=a._emscripten_bind_Decoder_DecodeBufferToMesh_2=function(){return(Ic=a._emscripten_bind_Decoder_DecodeBufferToMesh_2=a.asm.ib).apply(null,arguments)},Jc=a._emscripten_bind_Decoder___destroy___0=function(){return(Jc=a._emscripten_bind_Decoder___destroy___0=a.asm.jb).apply(null,arguments)},Kc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_INVALID_TRANSFORM=
function(){return(Kc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_INVALID_TRANSFORM=a.asm.kb).apply(null,arguments)},Lc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_NO_TRANSFORM=function(){return(Lc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_NO_TRANSFORM=a.asm.lb).apply(null,arguments)},Mc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_QUANTIZATION_TRANSFORM=function(){return(Mc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_QUANTIZATION_TRANSFORM=
a.asm.mb).apply(null,arguments)},Nc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_OCTAHEDRON_TRANSFORM=function(){return(Nc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_OCTAHEDRON_TRANSFORM=a.asm.nb).apply(null,arguments)},Oc=a._emscripten_enum_draco_GeometryAttribute_Type_INVALID=function(){return(Oc=a._emscripten_enum_draco_GeometryAttribute_Type_INVALID=a.asm.ob).apply(null,arguments)},Pc=a._emscripten_enum_draco_GeometryAttribute_Type_POSITION=function(){return(Pc=a._emscripten_enum_draco_GeometryAttribute_Type_POSITION=
a.asm.pb).apply(null,arguments)},Qc=a._emscripten_enum_draco_GeometryAttribute_Type_NORMAL=function(){return(Qc=a._emscripten_enum_draco_GeometryAttribute_Type_NORMAL=a.asm.qb).apply(null,arguments)},Rc=a._emscripten_enum_draco_GeometryAttribute_Type_COLOR=function(){return(Rc=a._emscripten_enum_draco_GeometryAttribute_Type_COLOR=a.asm.rb).apply(null,arguments)},Sc=a._emscripten_enum_draco_GeometryAttribute_Type_TEX_COORD=function(){return(Sc=a._emscripten_enum_draco_GeometryAttribute_Type_TEX_COORD=
a.asm.sb).apply(null,arguments)},Tc=a._emscripten_enum_draco_GeometryAttribute_Type_GENERIC=function(){return(Tc=a._emscripten_enum_draco_GeometryAttribute_Type_GENERIC=a.asm.tb).apply(null,arguments)},Uc=a._emscripten_enum_draco_EncodedGeometryType_INVALID_GEOMETRY_TYPE=function(){return(Uc=a._emscripten_enum_draco_EncodedGeometryType_INVALID_GEOMETRY_TYPE=a.asm.ub).apply(null,arguments)},Vc=a._emscripten_enum_draco_EncodedGeometryType_POINT_CLOUD=function(){return(Vc=a._emscripten_enum_draco_EncodedGeometryType_POINT_CLOUD=
a.asm.vb).apply(null,arguments)},Wc=a._emscripten_enum_draco_EncodedGeometryType_TRIANGULAR_MESH=function(){return(Wc=a._emscripten_enum_draco_EncodedGeometryType_TRIANGULAR_MESH=a.asm.wb).apply(null,arguments)},Xc=a._emscripten_enum_draco_DataType_DT_INVALID=function(){return(Xc=a._emscripten_enum_draco_DataType_DT_INVALID=a.asm.xb).apply(null,arguments)},Yc=a._emscripten_enum_draco_DataType_DT_INT8=function(){return(Yc=a._emscripten_enum_draco_DataType_DT_INT8=a.asm.yb).apply(null,arguments)},Zc=
a._emscripten_enum_draco_DataType_DT_UINT8=function(){return(Zc=a._emscripten_enum_draco_DataType_DT_UINT8=a.asm.zb).apply(null,arguments)},$c=a._emscripten_enum_draco_DataType_DT_INT16=function(){return($c=a._emscripten_enum_draco_DataType_DT_INT16=a.asm.Ab).apply(null,arguments)},ad=a._emscripten_enum_draco_DataType_DT_UINT16=function(){return(ad=a._emscripten_enum_draco_DataType_DT_UINT16=a.asm.Bb).apply(null,arguments)},bd=a._emscripten_enum_draco_DataType_DT_INT32=function(){return(bd=a._emscripten_enum_draco_DataType_DT_INT32=
a.asm.Cb).apply(null,arguments)},cd=a._emscripten_enum_draco_DataType_DT_UINT32=function(){return(cd=a._emscripten_enum_draco_DataType_DT_UINT32=a.asm.Db).apply(null,arguments)},dd=a._emscripten_enum_draco_DataType_DT_INT64=function(){return(dd=a._emscripten_enum_draco_DataType_DT_INT64=a.asm.Eb).apply(null,arguments)},ed=a._emscripten_enum_draco_DataType_DT_UINT64=function(){return(ed=a._emscripten_enum_draco_DataType_DT_UINT64=a.asm.Fb).apply(null,arguments)},fd=a._emscripten_enum_draco_DataType_DT_FLOAT32=
function(){return(fd=a._emscripten_enum_draco_DataType_DT_FLOAT32=a.asm.Gb).apply(null,arguments)},gd=a._emscripten_enum_draco_DataType_DT_FLOAT64=function(){return(gd=a._emscripten_enum_draco_DataType_DT_FLOAT64=a.asm.Hb).apply(null,arguments)},hd=a._emscripten_enum_draco_DataType_DT_BOOL=function(){return(hd=a._emscripten_enum_draco_DataType_DT_BOOL=a.asm.Ib).apply(null,arguments)},id=a._emscripten_enum_draco_DataType_DT_TYPES_COUNT=function(){return(id=a._emscripten_enum_draco_DataType_DT_TYPES_COUNT=
a.asm.Jb).apply(null,arguments)},jd=a._emscripten_enum_draco_StatusCode_OK=function(){return(jd=a._emscripten_enum_draco_StatusCode_OK=a.asm.Kb).apply(null,arguments)},kd=a._emscripten_enum_draco_StatusCode_DRACO_ERROR=function(){return(kd=a._emscripten_enum_draco_StatusCode_DRACO_ERROR=a.asm.Lb).apply(null,arguments)},ld=a._emscripten_enum_draco_StatusCode_IO_ERROR=function(){return(ld=a._emscripten_enum_draco_StatusCode_IO_ERROR=a.asm.Mb).apply(null,arguments)},md=a._emscripten_enum_draco_StatusCode_INVALID_PARAMETER=
function(){return(md=a._emscripten_enum_draco_StatusCode_INVALID_PARAMETER=a.asm.Nb).apply(null,arguments)},nd=a._emscripten_enum_draco_StatusCode_UNSUPPORTED_VERSION=function(){return(nd=a._emscripten_enum_draco_StatusCode_UNSUPPORTED_VERSION=a.asm.Ob).apply(null,arguments)},od=a._emscripten_enum_draco_StatusCode_UNKNOWN_VERSION=function(){return(od=a._emscripten_enum_draco_StatusCode_UNKNOWN_VERSION=a.asm.Pb).apply(null,arguments)};a._malloc=function(){return(a._malloc=a.asm.Qb).apply(null,arguments)};
a._free=function(){return(a._free=a.asm.Rb).apply(null,arguments)};var ua=function(){return(ua=a.asm.Sb).apply(null,arguments)};a.___start_em_js=11660;a.___stop_em_js=11758;var la;ha=function b(){la||F();la||(ha=b)};if(a.preInit)for("function"==typeof a.preInit&&(a.preInit=[a.preInit]);0<a.preInit.length;)a.preInit.pop()();F();v.prototype=Object.create(v.prototype);v.prototype.constructor=v;v.prototype.__class__=v;v.__cache__={};a.WrapperObject=v;a.getCache=w;a.wrapPointer=B;a.castObject=function(b,
c){return B(b.ptr,c)};a.NULL=B(0);a.destroy=function(b){if(!b.__destroy__)throw"Error: Cannot destroy object. (Did you create it yourself?)";b.__destroy__();delete w(b.__class__)[b.ptr]};a.compare=function(b,c){return b.ptr===c.ptr};a.getPointer=function(b){return b.ptr};a.getClass=function(b){return b.__class__};var r={buffer:0,size:0,pos:0,temps:[],needed:0,prepare:function(){if(r.needed){for(var b=0;b<r.temps.length;b++)a._free(r.temps[b]);r.temps.length=0;a._free(r.buffer);r.buffer=0;r.size+=
r.needed;r.needed=0}r.buffer||(r.size+=128,r.buffer=a._malloc(r.size),r.buffer||y(void 0));r.pos=0},alloc:function(b,c){r.buffer||y(void 0);b=b.length*c.BYTES_PER_ELEMENT;b=b+7&-8;r.pos+b>=r.size?(0<b||y(void 0),r.needed+=b,c=a._malloc(b),r.temps.push(c)):(c=r.buffer+r.pos,r.pos+=b);return c},copy:function(b,c,d){d>>>=0;switch(c.BYTES_PER_ELEMENT){case 2:d>>>=1;break;case 4:d>>>=2;break;case 8:d>>>=3}for(var g=0;g<b.length;g++)c[d+g]=b[g]}};X.prototype=Object.create(v.prototype);X.prototype.constructor=
X;X.prototype.__class__=X;X.__cache__={};a.VoidPtr=X;X.prototype.__destroy__=X.prototype.__destroy__=function(){Xa(this.ptr)};S.prototype=Object.create(v.prototype);S.prototype.constructor=S;S.prototype.__class__=S;S.__cache__={};a.DecoderBuffer=S;S.prototype.Init=S.prototype.Init=function(b,c){var d=this.ptr;r.prepare();"object"==typeof b&&(b=Z(b));c&&"object"===typeof c&&(c=c.ptr);Ya(d,b,c)};S.prototype.__destroy__=S.prototype.__destroy__=function(){Za(this.ptr)};Q.prototype=Object.create(v.prototype);
Q.prototype.constructor=Q;Q.prototype.__class__=Q;Q.__cache__={};a.AttributeTransformData=Q;Q.prototype.transform_type=Q.prototype.transform_type=function(){return $a(this.ptr)};Q.prototype.__destroy__=Q.prototype.__destroy__=function(){ab(this.ptr)};V.prototype=Object.create(v.prototype);V.prototype.constructor=V;V.prototype.__class__=V;V.__cache__={};a.GeometryAttribute=V;V.prototype.__destroy__=V.prototype.__destroy__=function(){bb(this.ptr)};x.prototype=Object.create(v.prototype);x.prototype.constructor=
x;x.prototype.__class__=x;x.__cache__={};a.PointAttribute=x;x.prototype.size=x.prototype.size=function(){return cb(this.ptr)};x.prototype.GetAttributeTransformData=x.prototype.GetAttributeTransformData=function(){return B(db(this.ptr),Q)};x.prototype.attribute_type=x.prototype.attribute_type=function(){return eb(this.ptr)};x.prototype.data_type=x.prototype.data_type=function(){return fb(this.ptr)};x.prototype.num_components=x.prototype.num_components=function(){return gb(this.ptr)};x.prototype.normalized=
x.prototype.normalized=function(){return!!hb(this.ptr)};x.prototype.byte_stride=x.prototype.byte_stride=function(){return ib(this.ptr)};x.prototype.byte_offset=x.prototype.byte_offset=function(){return jb(this.ptr)};x.prototype.unique_id=x.prototype.unique_id=function(){return kb(this.ptr)};x.prototype.__destroy__=x.prototype.__destroy__=function(){lb(this.ptr)};D.prototype=Object.create(v.prototype);D.prototype.constructor=D;D.prototype.__class__=D;D.__cache__={};a.AttributeQuantizationTransform=
D;D.prototype.InitFromAttribute=D.prototype.InitFromAttribute=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return!!mb(c,b)};D.prototype.quantization_bits=D.prototype.quantization_bits=function(){return nb(this.ptr)};D.prototype.min_value=D.prototype.min_value=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return ob(c,b)};D.prototype.range=D.prototype.range=function(){return pb(this.ptr)};D.prototype.__destroy__=D.prototype.__destroy__=function(){qb(this.ptr)};G.prototype=
Object.create(v.prototype);G.prototype.constructor=G;G.prototype.__class__=G;G.__cache__={};a.AttributeOctahedronTransform=G;G.prototype.InitFromAttribute=G.prototype.InitFromAttribute=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return!!rb(c,b)};G.prototype.quantization_bits=G.prototype.quantization_bits=function(){return sb(this.ptr)};G.prototype.__destroy__=G.prototype.__destroy__=function(){tb(this.ptr)};H.prototype=Object.create(v.prototype);H.prototype.constructor=H;H.prototype.__class__=
H;H.__cache__={};a.PointCloud=H;H.prototype.num_attributes=H.prototype.num_attributes=function(){return ub(this.ptr)};H.prototype.num_points=H.prototype.num_points=function(){return vb(this.ptr)};H.prototype.__destroy__=H.prototype.__destroy__=function(){wb(this.ptr)};E.prototype=Object.create(v.prototype);E.prototype.constructor=E;E.prototype.__class__=E;E.__cache__={};a.Mesh=E;E.prototype.num_faces=E.prototype.num_faces=function(){return xb(this.ptr)};E.prototype.num_attributes=E.prototype.num_attributes=
function(){return yb(this.ptr)};E.prototype.num_points=E.prototype.num_points=function(){return zb(this.ptr)};E.prototype.__destroy__=E.prototype.__destroy__=function(){Ab(this.ptr)};T.prototype=Object.create(v.prototype);T.prototype.constructor=T;T.prototype.__class__=T;T.__cache__={};a.Metadata=T;T.prototype.__destroy__=T.prototype.__destroy__=function(){Bb(this.ptr)};C.prototype=Object.create(v.prototype);C.prototype.constructor=C;C.prototype.__class__=C;C.__cache__={};a.Status=C;C.prototype.code=
C.prototype.code=function(){return Cb(this.ptr)};C.prototype.ok=C.prototype.ok=function(){return!!Db(this.ptr)};C.prototype.error_msg=C.prototype.error_msg=function(){return p(Eb(this.ptr))};C.prototype.__destroy__=C.prototype.__destroy__=function(){Fb(this.ptr)};I.prototype=Object.create(v.prototype);I.prototype.constructor=I;I.prototype.__class__=I;I.__cache__={};a.DracoFloat32Array=I;I.prototype.GetValue=I.prototype.GetValue=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return Gb(c,
b)};I.prototype.size=I.prototype.size=function(){return Hb(this.ptr)};I.prototype.__destroy__=I.prototype.__destroy__=function(){Ib(this.ptr)};J.prototype=Object.create(v.prototype);J.prototype.constructor=J;J.prototype.__class__=J;J.__cache__={};a.DracoInt8Array=J;J.prototype.GetValue=J.prototype.GetValue=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return Jb(c,b)};J.prototype.size=J.prototype.size=function(){return Kb(this.ptr)};J.prototype.__destroy__=J.prototype.__destroy__=function(){Lb(this.ptr)};
K.prototype=Object.create(v.prototype);K.prototype.constructor=K;K.prototype.__class__=K;K.__cache__={};a.DracoUInt8Array=K;K.prototype.GetValue=K.prototype.GetValue=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return Mb(c,b)};K.prototype.size=K.prototype.size=function(){return Nb(this.ptr)};K.prototype.__destroy__=K.prototype.__destroy__=function(){Ob(this.ptr)};L.prototype=Object.create(v.prototype);L.prototype.constructor=L;L.prototype.__class__=L;L.__cache__={};a.DracoInt16Array=
L;L.prototype.GetValue=L.prototype.GetValue=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return Pb(c,b)};L.prototype.size=L.prototype.size=function(){return Qb(this.ptr)};L.prototype.__destroy__=L.prototype.__destroy__=function(){Rb(this.ptr)};M.prototype=Object.create(v.prototype);M.prototype.constructor=M;M.prototype.__class__=M;M.__cache__={};a.DracoUInt16Array=M;M.prototype.GetValue=M.prototype.GetValue=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return Sb(c,b)};
M.prototype.size=M.prototype.size=function(){return Tb(this.ptr)};M.prototype.__destroy__=M.prototype.__destroy__=function(){Ub(this.ptr)};N.prototype=Object.create(v.prototype);N.prototype.constructor=N;N.prototype.__class__=N;N.__cache__={};a.DracoInt32Array=N;N.prototype.GetValue=N.prototype.GetValue=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return Vb(c,b)};N.prototype.size=N.prototype.size=function(){return Wb(this.ptr)};N.prototype.__destroy__=N.prototype.__destroy__=function(){Xb(this.ptr)};
O.prototype=Object.create(v.prototype);O.prototype.constructor=O;O.prototype.__class__=O;O.__cache__={};a.DracoUInt32Array=O;O.prototype.GetValue=O.prototype.GetValue=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return Yb(c,b)};O.prototype.size=O.prototype.size=function(){return Zb(this.ptr)};O.prototype.__destroy__=O.prototype.__destroy__=function(){$b(this.ptr)};z.prototype=Object.create(v.prototype);z.prototype.constructor=z;z.prototype.__class__=z;z.__cache__={};a.MetadataQuerier=
z;z.prototype.HasEntry=z.prototype.HasEntry=function(b,c){var d=this.ptr;r.prepare();b&&"object"===typeof b&&(b=b.ptr);c=c&&"object"===typeof c?c.ptr:R(c);return!!ac(d,b,c)};z.prototype.GetIntEntry=z.prototype.GetIntEntry=function(b,c){var d=this.ptr;r.prepare();b&&"object"===typeof b&&(b=b.ptr);c=c&&"object"===typeof c?c.ptr:R(c);return bc(d,b,c)};z.prototype.GetIntEntryArray=z.prototype.GetIntEntryArray=function(b,c,d){var g=this.ptr;r.prepare();b&&"object"===typeof b&&(b=b.ptr);c=c&&"object"===
typeof c?c.ptr:R(c);d&&"object"===typeof d&&(d=d.ptr);cc(g,b,c,d)};z.prototype.GetDoubleEntry=z.prototype.GetDoubleEntry=function(b,c){var d=this.ptr;r.prepare();b&&"object"===typeof b&&(b=b.ptr);c=c&&"object"===typeof c?c.ptr:R(c);return dc(d,b,c)};z.prototype.GetStringEntry=z.prototype.GetStringEntry=function(b,c){var d=this.ptr;r.prepare();b&&"object"===typeof b&&(b=b.ptr);c=c&&"object"===typeof c?c.ptr:R(c);return p(ec(d,b,c))};z.prototype.NumEntries=z.prototype.NumEntries=function(b){var c=this.ptr;
b&&"object"===typeof b&&(b=b.ptr);return fc(c,b)};z.prototype.GetEntryName=z.prototype.GetEntryName=function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);return p(gc(d,b,c))};z.prototype.__destroy__=z.prototype.__destroy__=function(){hc(this.ptr)};m.prototype=Object.create(v.prototype);m.prototype.constructor=m;m.prototype.__class__=m;m.__cache__={};a.Decoder=m;m.prototype.DecodeArrayToPointCloud=m.prototype.DecodeArrayToPointCloud=function(b,c,d){var g=
this.ptr;r.prepare();"object"==typeof b&&(b=Z(b));c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return B(ic(g,b,c,d),C)};m.prototype.DecodeArrayToMesh=m.prototype.DecodeArrayToMesh=function(b,c,d){var g=this.ptr;r.prepare();"object"==typeof b&&(b=Z(b));c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return B(jc(g,b,c,d),C)};m.prototype.GetAttributeId=m.prototype.GetAttributeId=function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&
(c=c.ptr);return kc(d,b,c)};m.prototype.GetAttributeIdByName=m.prototype.GetAttributeIdByName=function(b,c){var d=this.ptr;r.prepare();b&&"object"===typeof b&&(b=b.ptr);c=c&&"object"===typeof c?c.ptr:R(c);return lc(d,b,c)};m.prototype.GetAttributeIdByMetadataEntry=m.prototype.GetAttributeIdByMetadataEntry=function(b,c,d){var g=this.ptr;r.prepare();b&&"object"===typeof b&&(b=b.ptr);c=c&&"object"===typeof c?c.ptr:R(c);d=d&&"object"===typeof d?d.ptr:R(d);return mc(g,b,c,d)};m.prototype.GetAttribute=
m.prototype.GetAttribute=function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);return B(nc(d,b,c),x)};m.prototype.GetAttributeByUniqueId=m.prototype.GetAttributeByUniqueId=function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);return B(oc(d,b,c),x)};m.prototype.GetMetadata=m.prototype.GetMetadata=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return B(pc(c,b),T)};m.prototype.GetAttributeMetadata=m.prototype.GetAttributeMetadata=
function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);return B(qc(d,b,c),T)};m.prototype.GetFaceFromMesh=m.prototype.GetFaceFromMesh=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!rc(g,b,c,d)};m.prototype.GetTriangleStripsFromMesh=m.prototype.GetTriangleStripsFromMesh=function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);
return sc(d,b,c)};m.prototype.GetTrianglesUInt16Array=m.prototype.GetTrianglesUInt16Array=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!tc(g,b,c,d)};m.prototype.GetTrianglesUInt32Array=m.prototype.GetTrianglesUInt32Array=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!uc(g,b,c,d)};m.prototype.GetAttributeFloat=m.prototype.GetAttributeFloat=
function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!vc(g,b,c,d)};m.prototype.GetAttributeFloatForAllPoints=m.prototype.GetAttributeFloatForAllPoints=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!wc(g,b,c,d)};m.prototype.GetAttributeIntForAllPoints=m.prototype.GetAttributeIntForAllPoints=function(b,c,d){var g=this.ptr;
b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!xc(g,b,c,d)};m.prototype.GetAttributeInt8ForAllPoints=m.prototype.GetAttributeInt8ForAllPoints=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!yc(g,b,c,d)};m.prototype.GetAttributeUInt8ForAllPoints=m.prototype.GetAttributeUInt8ForAllPoints=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=
b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!zc(g,b,c,d)};m.prototype.GetAttributeInt16ForAllPoints=m.prototype.GetAttributeInt16ForAllPoints=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!Ac(g,b,c,d)};m.prototype.GetAttributeUInt16ForAllPoints=m.prototype.GetAttributeUInt16ForAllPoints=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&
(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!Bc(g,b,c,d)};m.prototype.GetAttributeInt32ForAllPoints=m.prototype.GetAttributeInt32ForAllPoints=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!Cc(g,b,c,d)};m.prototype.GetAttributeUInt32ForAllPoints=m.prototype.GetAttributeUInt32ForAllPoints=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===
typeof d&&(d=d.ptr);return!!Dc(g,b,c,d)};m.prototype.GetAttributeDataArrayForAllPoints=m.prototype.GetAttributeDataArrayForAllPoints=function(b,c,d,g,t){var aa=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);g&&"object"===typeof g&&(g=g.ptr);t&&"object"===typeof t&&(t=t.ptr);return!!Ec(aa,b,c,d,g,t)};m.prototype.SkipAttributeTransform=m.prototype.SkipAttributeTransform=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);Fc(c,
b)};m.prototype.GetEncodedGeometryType_Deprecated=m.prototype.GetEncodedGeometryType_Deprecated=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return Gc(c,b)};m.prototype.DecodeBufferToPointCloud=m.prototype.DecodeBufferToPointCloud=function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);return B(Hc(d,b,c),C)};m.prototype.DecodeBufferToMesh=m.prototype.DecodeBufferToMesh=function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===
typeof c&&(c=c.ptr);return B(Ic(d,b,c),C)};m.prototype.__destroy__=m.prototype.__destroy__=function(){Jc(this.ptr)};(function(){function b(){a.ATTRIBUTE_INVALID_TRANSFORM=Kc();a.ATTRIBUTE_NO_TRANSFORM=Lc();a.ATTRIBUTE_QUANTIZATION_TRANSFORM=Mc();a.ATTRIBUTE_OCTAHEDRON_TRANSFORM=Nc();a.INVALID=Oc();a.POSITION=Pc();a.NORMAL=Qc();a.COLOR=Rc();a.TEX_COORD=Sc();a.GENERIC=Tc();a.INVALID_GEOMETRY_TYPE=Uc();a.POINT_CLOUD=Vc();a.TRIANGULAR_MESH=Wc();a.DT_INVALID=Xc();a.DT_INT8=Yc();a.DT_UINT8=Zc();a.DT_INT16=
$c();a.DT_UINT16=ad();a.DT_INT32=bd();a.DT_UINT32=cd();a.DT_INT64=dd();a.DT_UINT64=ed();a.DT_FLOAT32=fd();a.DT_FLOAT64=gd();a.DT_BOOL=hd();a.DT_TYPES_COUNT=id();a.OK=jd();a.DRACO_ERROR=kd();a.IO_ERROR=ld();a.INVALID_PARAMETER=md();a.UNSUPPORTED_VERSION=nd();a.UNKNOWN_VERSION=od()}va?b():oa.unshift(b)})();if("function"===typeof a.onModuleParsed)a.onModuleParsed();a.Decoder.prototype.GetEncodedGeometryType=function(b){if(b.__class__&&b.__class__===a.DecoderBuffer)return a.Decoder.prototype.GetEncodedGeometryType_Deprecated(b);
if(8>b.byteLength)return a.INVALID_GEOMETRY_TYPE;switch(b[7]){case 0:return a.POINT_CLOUD;case 1:return a.TRIANGULAR_MESH;default:return a.INVALID_GEOMETRY_TYPE}};return n.ready}}();"object"===typeof exports&&"object"===typeof module?module.exports=DracoDecoderModule:"function"===typeof define&&define.amd?define([],function(){return DracoDecoderModule}):"object"===typeof exports&&(exports.DracoDecoderModule=DracoDecoderModule);
"; +var textDecoder = new TextDecoder(); +function convertArrayBufferToString2(buffer, from, to) { + if (from === void 0) { + from = 0; + } + if (to === void 0) { + to = buffer.byteLength; + } + return textDecoder.decode(new Uint8Array(buffer, from, to)); +} +var fbxBinaryHeader = "Kaydara FBX Binary \0"; +function IsFBXBinary(buffer) { + return buffer.byteLength >= fbxBinaryHeader.length && fbxBinaryHeader === convertArrayBufferToString2(buffer, 0, fbxBinaryHeader.length); +} +var gtlfBinaryHeader = "glTF"; +function IsGLB(buffer) { + return buffer.byteLength >= 4 && gtlfBinaryHeader === convertArrayBufferToString2(buffer, 0, 4); +} +var fbxTextHeader = [ + "K", + "a", + "y", + "d", + "a", + "r", + "a", + "\\", + "F", + "B", + "X", + "\\", + "B", + "i", + "n", + "a", + "r", + "y", + "\\", + "\\" +]; +function isFbxFormatASCII2(text) { + let cursor = 0; + function read(offset) { + const result = text[offset - 1]; + text = text.slice(cursor + offset); + cursor++; + return result; + } + for (let i = 0; i < fbxTextHeader.length; ++i) { + const num = read(1); + if (num !== fbxTextHeader[i]) { + return false; + } + } + return true; +} +var _ModelLoader = class _ModelLoader2 { + constructor(manager, options = {}) { + this.manager = manager; + this.options = options; + this.gltfLoader = new GLTFLoader(this.manager).setMeshoptDecoder(MeshoptDecoder).setDRACOLoader(_ModelLoader2.getDracoLoader()); + this.fbxLoader = new FBXLoader(this.manager); + } + static getDracoLoader() { + if (_ModelLoader2.dracoLoader) { + return _ModelLoader2.dracoLoader; + } + _ModelLoader2.dracoLoader = new DRACOLoader({ + /* + Implement the methods of the LoadingManager interface so that we can inject the embedded Draco decoder + rather than retrieve it from the network by overriding the resolveURL method to return data URIs. + */ + resolveURL: (url) => { + if (url === "draco_wasm_wrapper.js") { + return "data:text/javascript;base64," + draco_wasm_wrapper_default; + } else if (url === "draco_decoder.wasm") { + return "data:application/wasm;base64," + draco_decoder_default; + } + return url; + }, + itemStart: () => { + }, + itemEnd: () => { + }, + itemError: () => { + } + }).preload(); + return _ModelLoader2.dracoLoader; + } + async load(url, onProgress) { + return new Promise((resolve, reject) => { + var _a2; + const resourcePath = _ModelLoader2.extractUrlBase(url); + (_a2 = this.manager) == null ? void 0 : _a2.itemStart(url); + const _onError = (e) => { + var _a22, _b2; + reject(e); + (_a22 = this.manager) == null ? void 0 : _a22.itemError(url); + (_b2 = this.manager) == null ? void 0 : _b2.itemEnd(url); + }; + const loader = new FileLoader(this.manager); + loader.setResponseType("arraybuffer"); + if (this.options.requestHeader) { + loader.setRequestHeader(this.options.requestHeader); + } + if (this.options.withCredentials !== void 0) { + loader.setWithCredentials(this.options.withCredentials); + } + loader.load( + url, + async (data) => { + var _a22; + try { + const loadResult = await this.loadFromBuffer(data, resourcePath); + (_a22 = this.manager) == null ? void 0 : _a22.itemEnd(url); + resolve(loadResult); + } catch (e) { + _onError(e); + } + }, + (progressEvent) => { + if (onProgress && progressEvent.lengthComputable) { + onProgress(progressEvent.loaded, progressEvent.total); + } + }, + _onError + ); + }); + } + static extractUrlBase(url) { + const index = url.lastIndexOf("/"); + if (index === -1) { + return "./"; + } + return url.slice(0, index + 1); + } + async loadFromBuffer(buffer, pathName) { + if (IsFBXBinary(buffer)) { + const group = this.fbxLoader.parse(buffer, pathName); + return { group, animations: [] }; + } + if (IsGLB(buffer)) { + const gltf2 = await this.gltfLoader.parseAsync(buffer, pathName); + return { group: gltf2.scene, animations: gltf2.animations }; + } + const text = convertArrayBufferToString2(buffer); + if (isFbxFormatASCII2(text)) { + const group = this.fbxLoader.parse(text, pathName); + return { group, animations: [] }; + } + const gltf = await this.gltfLoader.parseAsync(text, pathName); + return { group: gltf.scene, animations: gltf.animations }; + } +}; +_ModelLoader.dracoLoader = null; +var ModelLoader = _ModelLoader; + +// ../../node_modules/@mml-io/mml-web-threejs/build/index.js +var debugAudioSphereSize = 0.25; +var debugAudioGeometry = new SphereGeometry(debugAudioSphereSize, 4, 2); +var debugAudioMaterial = new MeshBasicMaterial({ + wireframe: true, + fog: false, + toneMapped: false, + color: 65280 +}); +var audioRefDistance = 1; +var audioRolloffFactor = 1; +function extendAudioToDuration(context, buffer, seconds) { + const updatedBuffer = context.createBuffer( + buffer.numberOfChannels, + Math.ceil(seconds * buffer.sampleRate), + buffer.sampleRate + ); + for (let channelNumber = 0; channelNumber < buffer.numberOfChannels; channelNumber++) { + const channelData = buffer.getChannelData(channelNumber); + const updatedChannelData = updatedBuffer.getChannelData(channelNumber); + updatedChannelData.set(channelData, 0); + } + return updatedBuffer; +} +var ThreeJSAudio = class extends AudioGraphics { + constructor(audio) { + super(audio); + this.audio = audio; + this.audioDebugHelper = null; + this.audioContextStateChangedListener = () => { + this.syncAudioTime(); + }; + this.delayedPauseTimer = null; + this.srcLoadingInstanceManager = new LoadingInstanceManager(`${Audio.tagName}.src`); + this.loadedAudioState = null; + this.documentTimeListener = this.audio.addDocumentTimeListener(() => { + if (this.loadedAudioState) { + this.syncAudioTime(); + } + }); + const audioListener = this.getAudioListener(); + this.positionalAudio = new PositionalAudio(audioListener); + this.positionalAudio.context.addEventListener( + "statechange", + this.audioContextStateChangedListener + ); + this.positionalAudio.setVolume(this.audio.props.volume); + this.positionalAudio.setDirectionalCone( + this.audio.props.coneFalloffAngle ?? 360, + this.audio.props.coneAngle, + 0 + ); + this.positionalAudio.setRefDistance(audioRefDistance); + this.positionalAudio.setRolloffFactor(audioRolloffFactor); + this.audio.getContainer().add(this.positionalAudio); + this.updateAudio(); + this.updateDebugVisualisation(); + } + disable() { + } + enable() { + } + syncAudioTime() { + const audioContext = this.positionalAudio.context; + if (audioContext.state !== "running") { + return; + } + if (this.delayedPauseTimer !== null) { + clearTimeout(this.delayedPauseTimer); + this.delayedPauseTimer = null; + } + if (!this.loadedAudioState || !this.loadedAudioState.loadedAudio || this.loadedAudioState.loadedAudio.mode !== "LOADED") { + return; + } + const loadedAudio = this.loadedAudioState.loadedAudio; + const audioBuffer = loadedAudio.buffer; + let currentSource = loadedAudio.currentSource; + if (!this.audio.props.enabled || this.audio.isDisabled()) { + if (currentSource) { + currentSource.sourceNode.stop(); + loadedAudio.currentSource = null; + } + return; + } + const documentTime = this.audio.getDocumentTime(); + if (this.audio.props.pauseTime !== null) { + const timeUntilPause = this.audio.props.pauseTime - documentTime; + if (timeUntilPause < 2) { + if (currentSource) { + currentSource.sourceNode.stop(); + loadedAudio.currentSource = null; + } + return; + } else { + const delayedPauseTimer = setTimeout(() => { + if (this.delayedPauseTimer === delayedPauseTimer) { + this.delayedPauseTimer = null; + } + this.syncAudioTime(); + }, timeUntilPause); + this.delayedPauseTimer = delayedPauseTimer; + } + } + const currentTime = (documentTime - this.audio.props.startTime) / 1e3; + const audioDuration = audioBuffer.duration; + let loopDurationSeconds = null; + if (this.audio.props.loopDuration !== null && this.audio.props.loopDuration > 0) { + loopDurationSeconds = this.audio.props.loopDuration / 1e3; + } + let desiredAudioTime; + if (this.audio.props.loop) { + if (currentTime < 0) { + desiredAudioTime = currentTime; + } else { + if (loopDurationSeconds === null) { + desiredAudioTime = currentTime % audioDuration; + } else { + desiredAudioTime = currentTime % loopDurationSeconds; + } + } + } else { + desiredAudioTime = currentTime; + if (desiredAudioTime > audioDuration) { + if (currentSource) { + currentSource.sourceNode.stop(); + loadedAudio.currentSource = null; + } + return; + } + } + const loopDurationLongerThanAudioDuration = loopDurationSeconds && loopDurationSeconds > audioDuration; + const playbackLength = loopDurationSeconds ? loopDurationSeconds : audioDuration; + if (currentSource) { + if (currentSource.sourceNode.loop !== this.audio.props.loop) { + currentSource.sourceNode.stop(); + loadedAudio.currentSource = null; + currentSource = null; + } else if (loopDurationSeconds !== null && loopDurationLongerThanAudioDuration && (!loadedAudio.paddedBuffer || loadedAudio.paddedBuffer.totalDuration < loopDurationSeconds)) { + currentSource.sourceNode.stop(); + loadedAudio.currentSource = null; + currentSource = null; + } else if (loopDurationSeconds === null && currentSource.sourceNode.loopEnd !== audioBuffer.duration) { + currentSource.sourceNode.stop(); + loadedAudio.currentSource = null; + currentSource = null; + } else { + if (this.audio.props.startTime > documentTime) { + currentSource.sourceNode.stop(); + loadedAudio.currentSource = null; + currentSource = null; + } else { + const unloopedCurrentAudioPoint = (audioContext.currentTime - currentSource.contextStartTime) / currentSource.sourceNode.playbackRate.value; + if (unloopedCurrentAudioPoint < 0) { + currentSource.sourceNode.stop(); + loadedAudio.currentSource = null; + currentSource = null; + } else { + if (loopDurationSeconds !== null && currentSource.sourceNode.loopEnd !== loopDurationSeconds) { + currentSource.sourceNode.loopEnd = loopDurationSeconds; + } + const currentAudioPoint = unloopedCurrentAudioPoint % playbackLength; + let delta = desiredAudioTime - currentAudioPoint; + if (this.audio.props.loop) { + const loopedDelta = delta - playbackLength; + if (Math.abs(delta) > Math.abs(loopedDelta)) { + delta = loopedDelta; + } + } + if (Math.abs(delta) > 0.5) { + currentSource.sourceNode.stop(); + loadedAudio.currentSource = null; + currentSource = null; + } else { + if (Math.abs(delta) < 0.1) { + currentSource.sourceNode.playbackRate.value = 1; + } else { + if (delta > 0) { + currentSource.sourceNode.playbackRate.value = 1.01; + } else { + currentSource.sourceNode.playbackRate.value = 0.99; + } + } + currentSource.contextStartTime = audioContext.currentTime - currentAudioPoint / currentSource.sourceNode.playbackRate.value; + } + } + } + } + } + if (!currentSource) { + const currentSourceNode = this.positionalAudio.context.createBufferSource(); + let buffer = audioBuffer; + if (loopDurationSeconds && loopDurationLongerThanAudioDuration) { + if (loadedAudio.paddedBuffer && loadedAudio.paddedBuffer.totalDuration === loopDurationSeconds) { + buffer = loadedAudio.paddedBuffer.buffer; + } else { + const paddedBuffer = extendAudioToDuration( + this.positionalAudio.context, + audioBuffer, + loopDurationSeconds + ); + loadedAudio.paddedBuffer = { + buffer: paddedBuffer, + totalDuration: loopDurationSeconds + }; + buffer = paddedBuffer; + } + } + currentSourceNode.buffer = buffer; + currentSourceNode.loop = this.audio.props.loop; + currentSourceNode.loopStart = 0; + if (loopDurationSeconds) { + currentSourceNode.loopEnd = loopDurationSeconds; + } else { + currentSourceNode.loopEnd = audioBuffer.duration; + } + let contextStartTime; + if (desiredAudioTime < 0) { + const timeFromNowToStart = -desiredAudioTime; + contextStartTime = audioContext.currentTime + timeFromNowToStart; + currentSourceNode.start(contextStartTime); + } else { + contextStartTime = audioContext.currentTime - desiredAudioTime; + currentSourceNode.start(0, desiredAudioTime); + } + loadedAudio.currentSource = { + sourceNode: currentSourceNode, + contextStartTime + }; + this.positionalAudio.setNodeSource(currentSourceNode); + } + } + clearAudio() { + var _a2; + if (this.loadedAudioState) { + if (this.loadedAudioState.loadedAudio) { + if (this.loadedAudioState.loadedAudio.mode === "LOADING") { + this.loadedAudioState.loadedAudio.abortController.abort(); + } else { + if ((_a2 = this.loadedAudioState.loadedAudio.currentSource) == null ? void 0 : _a2.sourceNode) { + this.loadedAudioState.loadedAudio.currentSource.sourceNode.stop(); + } + } + } + this.loadedAudioState = null; + } + } + updateAudio() { + if (!this.audio.isConnected) { + return; + } + const audioListener = this.getAudioListener(); + const audioContext = audioListener.context; + if (!this.audio.props.src) { + this.clearAudio(); + } else { + const contentAddress = this.audio.contentSrcToContentAddress(this.audio.props.src); + if (this.loadedAudioState && this.loadedAudioState.currentSrc === contentAddress) { + } else { + this.clearAudio(); + const abortController = new AbortController(); + this.srcLoadingInstanceManager.start( + this.audio.getLoadingProgressManager(), + contentAddress + ); + const srcLoadPromise = this.asyncLoadSourceAsset( + contentAddress, + abortController, + audioContext, + (loaded, total) => { + this.srcLoadingInstanceManager.setProgress(loaded / total); + } + ); + this.loadedAudioState = { + loadedAudio: { + mode: "LOADING", + abortController, + srcLoadPromise + }, + currentSrc: contentAddress + }; + srcLoadPromise.then((buffer) => { + var _a2; + if (this.loadedAudioState && ((_a2 = this.loadedAudioState.loadedAudio) == null ? void 0 : _a2.mode) === "LOADING" && this.loadedAudioState.loadedAudio.srcLoadPromise === srcLoadPromise) { + this.loadedAudioState.loadedAudio = { + mode: "LOADED", + buffer, + currentSource: null + }; + this.srcLoadingInstanceManager.finish(); + this.syncAudioTime(); + } + }).catch((e) => { + var _a2; + if (this.loadedAudioState && ((_a2 = this.loadedAudioState.loadedAudio) == null ? void 0 : _a2.mode) === "LOADING" && this.loadedAudioState.loadedAudio.srcLoadPromise === srcLoadPromise) { + console.error("Failed to load audio", e); + this.srcLoadingInstanceManager.error(e); + this.clearAudio(); + } + }); + } + } + this.syncAudioTime(); + } + async asyncLoadSourceAsset(contentAddress, abortController, audioContext, onProgress) { + return new Promise((resolve, reject) => { + (async () => { + if (contentAddress.startsWith("data:")) { + const base64 = contentAddress.split(",", 2)[1]; + if (!base64) { + reject(new Error("Invalid data URL")); + return; + } + let arrayBuffer; + try { + const binary = atob(base64); + const uint8Array = new Uint8Array(binary.length); + for (let i = 0; i < binary.length; i++) { + uint8Array[i] = binary.charCodeAt(i); + } + arrayBuffer = uint8Array.buffer; + } catch (e) { + console.error("Failed to decode base64 data URL", e); + return; + } + audioContext.decodeAudioData(arrayBuffer).then((audioBuffer) => { + if (abortController.signal.aborted) { + return; + } + resolve(audioBuffer); + }).catch((e) => { + console.error("Failed to decode data URI audio data", e); + }); + return; + } + const response = await fetch(contentAddress, { + signal: abortController.signal + }); + if (response.ok) { + response.arrayBuffer().then((buffer) => { + if (abortController.signal.aborted) { + return; + } + audioContext.decodeAudioData(buffer).then((audioBuffer) => { + if (abortController.signal.aborted) { + return; + } + resolve(audioBuffer); + }); + }).catch((e) => { + console.error("Failed to decode fetched audio data", e); + }); + } else { + console.error("Failed to fetch audio data", response); + } + })(); + }); + } + setSrc() { + this.updateAudio(); + } + setStartTime() { + if (this.loadedAudioState) { + this.syncAudioTime(); + } + } + setPauseTime() { + if (this.loadedAudioState) { + this.syncAudioTime(); + } + } + setLoopDuration() { + if (this.loadedAudioState) { + this.syncAudioTime(); + } + } + setLoop() { + this.updateAudio(); + } + setEnabled() { + this.updateAudio(); + } + setVolume(volume) { + this.positionalAudio.setVolume(volume); + } + setConeAngle(coneAngle, mAudioProps) { + this.positionalAudio.setDirectionalCone( + mAudioProps.coneAngle, + mAudioProps.coneFalloffAngle ?? 360, + 0 + ); + this.updateDebugVisualisation(); + } + setConeFalloffAngle(coneFalloffAngle, mAudioProps) { + this.positionalAudio.setDirectionalCone( + mAudioProps.coneAngle, + mAudioProps.coneFalloffAngle ?? 360, + 0 + ); + this.updateDebugVisualisation(); + } + setDebug() { + this.updateDebugVisualisation(); + } + dispose() { + if (this.positionalAudio) { + this.positionalAudio.context.removeEventListener( + "statechange", + this.audioContextStateChangedListener + ); + this.positionalAudio.disconnect(); + this.positionalAudio.removeFromParent(); + } + this.clearAudio(); + if (this.delayedPauseTimer) { + clearTimeout(this.delayedPauseTimer); + this.delayedPauseTimer = null; + } + this.documentTimeListener.remove(); + this.clearDebugVisualisation(); + this.srcLoadingInstanceManager.dispose(); + } + clearDebugVisualisation() { + var _a2; + if (this.audioDebugHelper) { + this.audioDebugHelper.removeFromParent(); + this.audioDebugHelper = null; + } + if (this.audioDebugConeX) { + this.audioDebugConeX.removeFromParent(); + this.audioDebugConeX = null; + (_a2 = this.audioDebugConeY) == null ? void 0 : _a2.removeFromParent(); + this.audioDebugConeY = null; + } + } + updateDebugVisualisation() { + var _a2, _b2, _c; + if (!this.audio.props.debug) { + this.clearDebugVisualisation(); + } else { + if (!this.audioDebugHelper) { + this.audioDebugHelper = new Mesh(debugAudioGeometry, debugAudioMaterial); + this.audio.getContainer().add(this.audioDebugHelper); + } + if (!this.audioDebugConeX && this.audio.props.coneAngle) { + this.audioDebugConeX = new PositionalAudioHelper(this.positionalAudio, 10); + this.positionalAudio.add(this.audioDebugConeX); + this.audioDebugConeY = new PositionalAudioHelper(this.positionalAudio, 10); + this.audioDebugConeY.rotation.z = Math.PI / 2; + this.positionalAudio.add(this.audioDebugConeY); + } + if (!this.audio.props.coneAngle && this.audioDebugConeX) { + this.audioDebugConeX.removeFromParent(); + this.audioDebugConeX = null; + (_a2 = this.audioDebugConeY) == null ? void 0 : _a2.removeFromParent(); + this.audioDebugConeY = null; + } + } + (_b2 = this.audioDebugConeX) == null ? void 0 : _b2.update(); + (_c = this.audioDebugConeY) == null ? void 0 : _c.update(); + } + getAudioListener() { + return this.audio.getScene().getGraphicsAdapter().getAudioListener(); + } +}; +var _ThreeJSChatProbe = class _ThreeJSChatProbe2 extends ChatProbeGraphics { + constructor(chatProbe) { + super(chatProbe); + this.chatProbe = chatProbe; + this.debugMesh = null; + } + disable() { + } + enable() { + } + setRange() { + this.updateDebugVisualisation(); + } + setDebug() { + this.updateDebugVisualisation(); + } + clearDebugVisualisation() { + if (this.debugMesh) { + this.debugMesh.removeFromParent(); + this.debugMesh = null; + } + } + updateDebugVisualisation() { + if (!this.chatProbe.props.debug) { + this.clearDebugVisualisation(); + } else { + if (this.chatProbe.isConnected && !this.debugMesh) { + const mesh = new Mesh(_ThreeJSChatProbe2.DebugGeometry, _ThreeJSChatProbe2.DebugMaterial); + mesh.castShadow = false; + mesh.receiveShadow = false; + this.debugMesh = mesh; + this.chatProbe.getContainer().add(this.debugMesh); + } + if (this.debugMesh) { + this.debugMesh.scale.set( + this.chatProbe.props.range, + this.chatProbe.props.range, + this.chatProbe.props.range + ); + } + } + } + dispose() { + this.clearDebugVisualisation(); + } +}; +_ThreeJSChatProbe.DebugGeometry = new SphereGeometry(1, 16, 16, 1); +_ThreeJSChatProbe.DebugMaterial = new MeshBasicMaterial({ + color: 16776960, + wireframe: true, + transparent: true, + opacity: 0.3 +}); +var ThreeJSChatProbe = _ThreeJSChatProbe; +var _ThreeJSCube = class _ThreeJSCube2 extends CubeGraphics { + constructor(cube) { + super(cube); + this.cube = cube; + this.material = new MeshStandardMaterial({ + color: new Color(cube.props.color.r, cube.props.color.g, cube.props.color.b) + }); + this.mesh = new Mesh(_ThreeJSCube2.boxGeometry, this.material); + this.mesh.castShadow = cube.props.castShadows; + this.mesh.receiveShadow = true; + this.cube.getContainer().add(this.mesh); + } + disable() { + } + enable() { + } + getCollisionElement() { + return this.mesh; + } + setColor(color) { + this.material.color = new Color(color.r, color.g, color.b); + } + setWidth(width) { + this.mesh.scale.x = width; + } + setHeight(height) { + this.mesh.scale.y = height; + } + setDepth(depth) { + this.mesh.scale.z = depth; + } + setCastShadows(castShadows) { + this.mesh.castShadow = castShadows; + } + setOpacity(opacity) { + const needsUpdate = this.material.transparent === (opacity === 1); + this.material.transparent = opacity !== 1; + this.material.needsUpdate = needsUpdate; + this.material.opacity = opacity; + } + dispose() { + } +}; +_ThreeJSCube.boxGeometry = new BoxGeometry(1, 1, 1); +var ThreeJSCube = _ThreeJSCube; +var _ThreeJSCylinder = class _ThreeJSCylinder2 extends CylinderGraphics { + constructor(cylinder) { + super(cylinder); + this.cylinder = cylinder; + this.material = new MeshStandardMaterial({ + color: new Color( + cylinder.props.color.r, + cylinder.props.color.g, + cylinder.props.color.b + ) + }); + this.mesh = new Mesh(_ThreeJSCylinder2.cylinderGeometry, this.material); + this.mesh.castShadow = cylinder.props.castShadows; + this.mesh.receiveShadow = true; + this.cylinder.getContainer().add(this.mesh); + } + disable() { + } + enable() { + } + getCollisionElement() { + return this.mesh; + } + setColor(color) { + this.material.color = new Color(color.r, color.g, color.b); + } + setRadius(radius) { + this.mesh.scale.x = radius * 2; + this.mesh.scale.z = radius * 2; + } + setHeight(height) { + this.mesh.scale.y = height; + } + setCastShadows(castShadows) { + this.mesh.castShadow = castShadows; + } + setOpacity(opacity) { + const needsUpdate = this.material.transparent === (opacity === 1); + this.material.transparent = opacity !== 1; + this.material.needsUpdate = needsUpdate; + this.material.opacity = opacity; + } + dispose() { + } +}; +_ThreeJSCylinder.cylinderGeometry = new CylinderGeometry(0.5, 0.5, 1); +var ThreeJSCylinder = _ThreeJSCylinder; +var ThreeJSDebugHelper = class extends DebugHelperGraphics { + constructor(debugHelper) { + super(debugHelper); + this.debugHelper = debugHelper; + this.debugAxes = null; + this.debugAxes = new AxesHelper(1); + this.debugHelper.getContainer().add(this.debugAxes); + } + dispose() { + if (this.debugAxes) { + this.debugHelper.getContainer().remove(this.debugAxes); + } + this.debugAxes = null; + } +}; +function setMeshToBoundingBox(mesh, minX, maxX, minY, maxY, minZ, maxZ) { + mesh.scale.set(maxX - minX, maxY - minY, maxZ - minZ); + mesh.position.set((maxX + minX) / 2, (maxY + minY) / 2, (maxZ + minZ) / 2); +} +var _ThreeJSFrame = class _ThreeJSFrame2 extends FrameGraphics { + constructor(frame) { + super(frame); + this.frame = frame; + this.debugMeshes = null; + } + setSrc() { + } + setDebug() { + this.updateDebugVisualisation(); + } + setLoadRange() { + this.updateDebugVisualisation(); + } + setUnloadRange() { + this.updateDebugVisualisation(); + } + setMinX() { + this.updateDebugVisualisation(); + } + setMaxX() { + this.updateDebugVisualisation(); + } + setMinY() { + this.updateDebugVisualisation(); + } + setMaxY() { + this.updateDebugVisualisation(); + } + setMinZ() { + this.updateDebugVisualisation(); + } + setMaxZ() { + this.updateDebugVisualisation(); + } + disable() { + } + enable() { + } + dispose() { + } + clearDebugVisualisation() { + if (this.debugMeshes) { + this.debugMeshes.debugBoxConstraintMesh.removeFromParent(); + this.debugMeshes.debugBoxLoadRangeMesh.removeFromParent(); + this.debugMeshes.debugBoxUnloadRangeMesh.removeFromParent(); + this.debugMeshes = null; + } + } + updateDebugVisualisation() { + if (!this.frame.props.debug) { + this.clearDebugVisualisation(); + } else { + if (!this.frame.isConnected) { + return; + } + if (!this.debugMeshes) { + this.debugMeshes = { + debugBoxConstraintMesh: new Mesh( + _ThreeJSFrame2.DebugBoxGeometry, + _ThreeJSFrame2.DebugConstraintMaterial + ), + debugBoxLoadRangeMesh: new Mesh( + _ThreeJSFrame2.DebugBoxGeometry, + _ThreeJSFrame2.DebugLoadRangeMaterial + ), + debugBoxUnloadRangeMesh: new Mesh( + _ThreeJSFrame2.DebugBoxGeometry, + _ThreeJSFrame2.DebugUnloadRangeMaterial + ) + }; + this.frame.getContainer().add(this.debugMeshes.debugBoxConstraintMesh); + this.frame.getContainer().add(this.debugMeshes.debugBoxLoadRangeMesh); + this.frame.getContainer().add(this.debugMeshes.debugBoxUnloadRangeMesh); + } + let boxBounds = this.frame.getDefinedBoxBounds(); + if (!boxBounds) { + boxBounds = [0, 0, 0, 0, 0, 0]; + } + const [minX, maxX, minY, maxY, minZ, maxZ] = boxBounds; + this.debugMeshes.debugBoxConstraintMesh.visible = true; + this.debugMeshes.debugBoxLoadRangeMesh.visible = true; + this.debugMeshes.debugBoxUnloadRangeMesh.visible = true; + setMeshToBoundingBox( + this.debugMeshes.debugBoxConstraintMesh, + minX, + maxX, + minY, + maxY, + minZ, + maxZ + ); + if (this.frame.props.loadRange === null) { + this.debugMeshes.debugBoxLoadRangeMesh.visible = false; + this.debugMeshes.debugBoxUnloadRangeMesh.visible = false; + } else { + this.debugMeshes.debugBoxLoadRangeMesh.visible = true; + this.debugMeshes.debugBoxUnloadRangeMesh.visible = true; + setMeshToBoundingBox( + this.debugMeshes.debugBoxLoadRangeMesh, + minX - this.frame.props.loadRange, + maxX + this.frame.props.loadRange, + minY - this.frame.props.loadRange, + maxY + this.frame.props.loadRange, + minZ - this.frame.props.loadRange, + maxZ + this.frame.props.loadRange + ); + setMeshToBoundingBox( + this.debugMeshes.debugBoxUnloadRangeMesh, + minX - this.frame.props.loadRange - this.frame.props.unloadRange, + maxX + this.frame.props.loadRange + this.frame.props.unloadRange, + minY - this.frame.props.loadRange - this.frame.props.unloadRange, + maxY + this.frame.props.loadRange + this.frame.props.unloadRange, + minZ - this.frame.props.loadRange - this.frame.props.unloadRange, + maxZ + this.frame.props.loadRange + this.frame.props.unloadRange + ); + } + } + } +}; +_ThreeJSFrame.DebugBoxGeometry = new BoxGeometry(1, 1, 1, 1, 1, 1); +_ThreeJSFrame.DebugConstraintMaterial = new MeshBasicMaterial({ + color: 16711680, + wireframe: true, + transparent: true, + opacity: 0.3 +}); +_ThreeJSFrame.DebugLoadRangeMaterial = new MeshBasicMaterial({ + color: 65280, + wireframe: true, + transparent: true, + opacity: 0.3 +}); +_ThreeJSFrame.DebugUnloadRangeMaterial = new MeshBasicMaterial({ + color: 255, + wireframe: true, + transparent: true, + opacity: 0.3 +}); +var ThreeJSFrame = _ThreeJSFrame; +var _ThreeJSImage = class _ThreeJSImage2 extends ImageGraphics { + constructor(image, updateMeshCallback) { + super(image, updateMeshCallback); + this.image = image; + this.updateMeshCallback = updateMeshCallback; + this.srcApplyPromise = null; + this.loadedImageHasTransparency = false; + this.srcLoadingInstanceManager = new LoadingInstanceManager(`${Image2.tagName}.src`); + this.material = new MeshStandardMaterial({ + color: 16777215, + transparent: this.image.props.opacity !== 1 || this.loadedImageHasTransparency, + opacity: this.image.props.opacity, + side: DoubleSide + }); + this.mesh = new Mesh(_ThreeJSImage2.planeGeometry, this.material); + this.mesh.castShadow = image.props.castShadows; + this.mesh.receiveShadow = true; + this.image.getContainer().add(this.mesh); + } + getWidthAndHeight() { + return { + width: this.mesh.scale.x, + height: this.mesh.scale.y + }; + } + disable() { + } + enable() { + } + getCollisionElement() { + return this.mesh; + } + setWidth() { + this.updateWidthAndHeight(); + } + setHeight() { + this.updateWidthAndHeight(); + } + setCastShadows(castShadows) { + this.mesh.castShadow = castShadows; + } + setOpacity(opacity) { + const needsUpdate = this.material.transparent === (opacity === 1); + this.material.transparent = opacity !== 1; + this.material.needsUpdate = needsUpdate; + this.material.opacity = opacity; + } + setEmissive() { + this.updateMaterialEmissiveIntensity(); + } + updateMaterialEmissiveIntensity() { + if (this.material) { + const map = this.material.map; + if (this.image.props.emissive > 0) { + this.material.emissive = new Color(16777215); + this.material.emissiveMap = map; + this.material.emissiveIntensity = this.image.props.emissive; + this.material.needsUpdate = true; + } else { + this.material.emissive = new Color(0); + this.material.emissiveMap = null; + this.material.emissiveIntensity = 1; + this.material.needsUpdate = true; + } + } + } + setSrc(newValue) { + const src = (newValue || "").trim(); + const isDataUri = src.startsWith("data:image/"); + if (this.loadedImage !== null && !isDataUri) { + this.clearImage(); + } + if (!src) { + this.updateWidthAndHeight(); + this.srcLoadingInstanceManager.abortIfLoading(); + return; + } + if (!this.material) { + return; + } + if (isDataUri) { + const image = document.createElement("img"); + image.src = src; + this.applyImage(image); + this.srcLoadingInstanceManager.abortIfLoading(); + return; + } + const contentSrc = this.image.contentSrcToContentAddress(src); + const srcApplyPromise = loadImageAsPromise( + _ThreeJSImage2.imageLoader, + contentSrc, + (loaded, total) => { + this.srcLoadingInstanceManager.setProgress(loaded / total); + } + ); + this.srcLoadingInstanceManager.start(this.image.getLoadingProgressManager(), contentSrc); + this.srcApplyPromise = srcApplyPromise; + srcApplyPromise.then((image) => { + if (this.srcApplyPromise !== srcApplyPromise || !this.material) { + return; + } + this.applyImage(image); + this.srcLoadingInstanceManager.finish(); + }).catch((error) => { + console.error("Error loading image:", newValue, error); + if (this.srcApplyPromise !== srcApplyPromise || !this.material) { + return; + } + this.clearImage(); + this.srcLoadingInstanceManager.error(error); + }); + } + updateWidthAndHeight() { + const mesh = this.mesh; + const { width, height } = calculateContentSize({ + content: this.loadedImage ? { width: this.loadedImage.width, height: this.loadedImage.height } : void 0, + width: this.image.props.width, + height: this.image.props.height + }); + mesh.scale.x = width; + mesh.scale.y = height; + this.updateMeshCallback(); + } + applyImage(image) { + this.loadedImage = image; + if (!image.complete) { + image.addEventListener("load", () => { + if (this.loadedImage !== image) { + return; + } + this.applyImage(image); + }); + return; + } + this.loadedImageHasTransparency = hasTransparency(this.loadedImage); + if (!this.material) { + return; + } + if (this.loadedImageHasTransparency) { + this.material.alphaMap = new CanvasTexture(this.loadedImage); + this.material.alphaTest = 0.01; + } else { + this.material.alphaMap = null; + this.material.alphaTest = 0; + } + this.material.transparent = this.image.props.opacity !== 1 || this.loadedImageHasTransparency; + this.material.map = new CanvasTexture(this.loadedImage); + this.material.needsUpdate = true; + this.updateMaterialEmissiveIntensity(); + this.updateWidthAndHeight(); + } + clearImage() { + this.loadedImage = null; + this.srcApplyPromise = null; + if (this.material && this.material.map) { + this.material.map.dispose(); + this.material.needsUpdate = true; + this.material.map = null; + this.material.alphaMap = null; + this.material.alphaTest = 0; + } + this.updateWidthAndHeight(); + } + dispose() { + if (this.material.map) { + this.material.map.dispose(); + this.material.map = null; + } + if (this.material.emissiveMap) { + this.material.emissiveMap.dispose(); + this.material.emissiveMap = null; + } + this.material.dispose(); + this.loadedImage = null; + this.srcLoadingInstanceManager.dispose(); + } +}; +_ThreeJSImage.planeGeometry = new PlaneGeometry(1, 1); +_ThreeJSImage.imageLoader = new ImageLoader(); +var ThreeJSImage = _ThreeJSImage; +function loadImageAsPromise(imageLoader, path, onProgress) { + return new Promise((resolve, reject) => { + imageLoader.load( + path, + (image) => { + resolve(image); + }, + (xhr) => { + if (onProgress) { + onProgress(xhr.loaded, xhr.total); + } + }, + (error) => { + reject(error); + } + ); + }); +} +function hasTransparency(image) { + if (image.width === 0 || image.height === 0) { + return false; + } + const canvas = document.createElement("canvas"); + canvas.width = image.width; + canvas.height = image.height; + const ctx = canvas.getContext("2d"); + ctx.drawImage(image, 0, 0); + const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height).data; + for (let i = 3, n = imageData.length; i < n; i += 4) { + if (imageData[i] < 255) { + return true; + } + } + return false; +} +var _ThreeJSInteraction = class _ThreeJSInteraction2 extends InteractionGraphics { + constructor(positionProbe) { + super(positionProbe); + this.positionProbe = positionProbe; + this.debugMesh = null; + } + disable() { + } + enable() { + } + setRange() { + this.updateDebugVisualisation(); + } + setInFocus() { + } + setLineOfSight() { + } + setPriority() { + } + setPrompt() { + } + setDebug() { + this.updateDebugVisualisation(); + } + clearDebugVisualisation() { + if (this.debugMesh) { + this.debugMesh.removeFromParent(); + this.debugMesh = null; + } + } + updateDebugVisualisation() { + if (!this.positionProbe.props.debug) { + this.clearDebugVisualisation(); + } else { + if (this.positionProbe.isConnected && !this.debugMesh) { + const mesh = new Mesh( + _ThreeJSInteraction2.DebugGeometry, + _ThreeJSInteraction2.DebugMaterial + ); + mesh.castShadow = false; + mesh.receiveShadow = false; + this.debugMesh = mesh; + this.positionProbe.getContainer().add(this.debugMesh); + } + if (this.debugMesh) { + this.debugMesh.scale.set( + this.positionProbe.props.range, + this.positionProbe.props.range, + this.positionProbe.props.range + ); + } + } + } + dispose() { + this.clearDebugVisualisation(); + } +}; +_ThreeJSInteraction.DebugGeometry = new SphereGeometry(1, 16, 16, 1); +_ThreeJSInteraction.DebugMaterial = new MeshBasicMaterial({ + color: 43520, + wireframe: true, + transparent: true, + opacity: 0.3 +}); +var ThreeJSInteraction = _ThreeJSInteraction; +var _ThreeJSLabel = class _ThreeJSLabel2 extends LabelGraphics { + constructor(label) { + super(label); + this.label = label; + this.material = null; + this.canvasText = new CanvasText(); + this.material = new MeshStandardMaterial({ + transparent: false + }); + this.mesh = new Mesh(_ThreeJSLabel2.labelGeometry, this.material); + this.mesh.material = this.material; + this.mesh.scale.x = this.label.props.width; + this.mesh.scale.y = this.label.props.height; + this.mesh.castShadow = this.label.props.castShadows; + this.mesh.receiveShadow = true; + this.redrawText(); + this.label.getContainer().add(this.mesh); + } + disable() { + } + enable() { + } + getCollisionElement() { + return this.mesh; + } + setContent() { + this.redrawText(); + } + setAlignment() { + this.redrawText(); + } + setFontSize() { + this.redrawText(); + } + setPadding() { + this.redrawText(); + } + setFontColor() { + this.redrawText(); + } + setEmissive() { + this.updateMaterialEmissiveIntensity(); + } + setColor() { + this.redrawText(); + } + setWidth(width) { + this.mesh.scale.x = width; + this.redrawText(); + } + setHeight(height) { + this.mesh.scale.y = height; + this.redrawText(); + } + setCastShadows(castShadows) { + this.mesh.castShadow = castShadows; + } + redrawText() { + if (!this.material) { + return; + } + if (this.material.map) { + this.material.map.dispose(); + } + const canvas = this.canvasText.renderText(this.label.props.content, { + bold: true, + fontSize: this.label.props.fontSize * 2, + paddingPx: this.label.props.padding, + textColorRGB255A1: { + r: this.label.props.fontColor.r * 255, + g: this.label.props.fontColor.g * 255, + b: this.label.props.fontColor.b * 255, + a: this.label.props.fontColor.a ?? 1 + }, + backgroundColorRGB255A1: { + r: this.label.props.color.r * 255, + g: this.label.props.color.g * 255, + b: this.label.props.color.b * 255, + a: this.label.props.color.a ?? 1 + }, + dimensions: { + width: this.label.props.width * 200, + height: this.label.props.height * 200 + }, + alignment: this.label.props.alignment + }); + this.material.map = new CanvasTexture(canvas); + this.material.transparent = (this.label.props.color.a ?? 1) < 1; + this.updateMaterialEmissiveIntensity(); + } + updateMaterialEmissiveIntensity() { + if (this.material) { + const map = this.material.map; + if (this.label.props.emissive > 0) { + this.material.emissive = new Color(16777215); + this.material.emissiveMap = map; + this.material.emissiveIntensity = this.label.props.emissive; + this.material.needsUpdate = true; + } else { + this.material.emissive = new Color(0); + this.material.emissiveMap = null; + this.material.emissiveIntensity = 1; + this.material.needsUpdate = true; + } + } + } + dispose() { + this.mesh.geometry.dispose(); + if (this.material) { + if (this.material.map) { + this.material.map.dispose(); + } + this.material.dispose(); + this.material = null; + } + } +}; +_ThreeJSLabel.labelGeometry = new PlaneGeometry(1, 1); +var ThreeJSLabel = _ThreeJSLabel; +var debugSphereSize = 0.25; +var ThreeJSLight = class extends LightGraphics { + constructor(light) { + super(light); + this.light = light; + this.createLight(); + } + createLight() { + if (this.threeLight) { + this.threeLight.removeFromParent(); + } + const { r, g, b } = this.light.props.color; + const color = new Color(r, g, b); + switch (this.light.props.type) { + case LightTypes.spotlight: { + const light = new SpotLight( + color, + this.light.props.intensity, + this.light.props.distance ?? void 0, + MathUtils.degToRad(this.light.props.angleDeg) + ); + const target = new Object3D(); + target.position.set(0, -1, 0); + light.position.set(0, 0, 0); + light.add(target); + light.target = target; + this.threeLight = light; + break; + } + case LightTypes.point: + this.threeLight = new PointLight( + color, + this.light.props.intensity, + this.light.props.distance ?? void 0 + ); + break; + } + if (this.threeLight.shadow) { + this.threeLight.castShadow = this.light.props.castShadows; + this.threeLight.shadow.mapSize.width = 512; + this.threeLight.shadow.mapSize.height = 512; + if (this.threeLight.shadow.camera instanceof PerspectiveCamera) { + this.threeLight.shadow.camera.near = 0.5; + this.threeLight.shadow.camera.far = 500; + } + this.threeLight.shadow.bias = -1e-3; + this.threeLight.shadow.normalBias = 0.01; + const d = 10; + const c = this.threeLight.shadow.camera; + c.left = -d; + c.right = d; + c.top = d; + c.bottom = -d; + } + this.threeLight.intensity = this.light.props.intensity; + this.light.getContainer().add(this.threeLight); + if (this.threeLightHelper) { + this.makeLightHelper(); + } + if (!this.light.props.enabled) { + this.threeLight.visible = false; + if (this.threeLightHelper) { + this.threeLightHelper.visible = false; + } + } + } + makeLightHelper() { + if (this.threeLightHelper) { + this.threeLightHelper.removeFromParent(); + this.threeLightHelper = null; + } + if (this.light instanceof PointLight) { + this.threeLightHelper = new PointLightHelper(this.light, debugSphereSize); + } else if (this.light instanceof SpotLight) { + this.threeLightHelper = new SpotLightHelper(this.light); + } + if (this.threeLightHelper) { + this.light.getContainer().add(this.threeLightHelper); + this.threeLightHelper.matrix = this.threeLight.matrix; + this.threeLightHelper.visible = this.threeLight.visible; + } + } + disable() { + } + enable() { + } + setEnabled(enabled) { + this.threeLight.visible = enabled; + if (this.threeLightHelper) { + this.threeLightHelper.visible = enabled; + } + } + setCastShadows(castShadows) { + this.threeLight.castShadow = castShadows; + } + setAngle(angle) { + if (this.threeLight instanceof SpotLight) { + this.threeLight.angle = MathUtils.degToRad(angle); + } + } + setIntensity(intensity) { + this.threeLight.intensity = intensity; + } + setDistance(distance) { + this.threeLight.distance = distance; + } + setType() { + this.createLight(); + } + setDebug(debug) { + if (debug && !this.threeLightHelper) { + this.makeLightHelper(); + } else if (!debug && this.threeLightHelper) { + this.threeLightHelper.removeFromParent(); + this.threeLightHelper = null; + } + } + setColor(color) { + this.threeLight.color.set(new Color(color.r, color.g, color.b)); + if (this.threeLightHelper) { + this.threeLightHelper.color = new Color(color.r, color.g, color.b); + } + } + dispose() { + this.light.getContainer().remove(this.threeLight); + if (this.threeLightHelper) { + this.threeLightHelper.removeFromParent(); + } + } +}; +var ThreeJSLink = class extends LinkGraphics { + constructor(link) { + super(link); + this.link = link; + } + disable() { + } + enable() { + } + setHref() { + } + setTarget() { + } + dispose() { + } +}; +var ThreeJSMElement = class extends MElementGraphics { + constructor(element) { + super(element); + this.element = element; + this.currentParentContainer = null; + this.container = new Group(); + this.container.name = this.constructor.name; + this.container[MELEMENT_PROPERTY_NAME] = element; + if (this.currentParentContainer !== null) { + throw new Error("Already connected to a parent"); + } + const mElementParent = this.element.getMElementParent(); + if (mElementParent) { + this.currentParentContainer = mElementParent.getContainer(); + this.currentParentContainer.add(this.container); + return; + } + const scene = this.element.getScene(); + this.currentParentContainer = scene.getRootContainer(); + this.currentParentContainer.add(this.container); + } + getContainer() { + return this.container; + } + dispose() { + if (this.currentParentContainer === null) { + throw new Error("Was not connected to a parent"); + } + this.currentParentContainer.remove(this.container); + this.currentParentContainer = null; + } +}; +var _ThreeJSModel = class _ThreeJSModel2 extends ModelGraphics { + constructor(model, updateMeshCallback) { + super(model, updateMeshCallback); + this.model = model; + this.updateMeshCallback = updateMeshCallback; + this.srcLoadingInstanceManager = new LoadingInstanceManager(`${Model.tagName}.src`); + this.animLoadingInstanceManager = new LoadingInstanceManager(`${Model.tagName}.anim`); + this.latestSrcModelPromise = null; + this.latestAnimPromise = null; + this.socketChildrenByBone = /* @__PURE__ */ new Map(); + this.attachments = /* @__PURE__ */ new Map(); + this.registeredParentAttachment = null; + this.debugBoundingBox = null; + this.loadedState = null; + this.animState = null; + this.documentTimeTickListener = null; + } + hasLoadedModel() { + var _a2; + return !!((_a2 = this.loadedState) == null ? void 0 : _a2.group); + } + hasLoadedAnimation() { + var _a2; + return !!((_a2 = this.animState) == null ? void 0 : _a2.appliedAnimation); + } + disable() { + } + enable() { + } + getBoundingBox() { + if (this.loadedState) { + return { + centerOffset: this.loadedState.boundingBox.centerOffset, + size: this.loadedState.boundingBox.size + }; + } + return null; + } + getCollisionElement() { + var _a2; + return ((_a2 = this.loadedState) == null ? void 0 : _a2.group) ?? new Object3D(); + } + setDebug() { + this.updateDebugVisualisation(); + } + setCastShadows(castShadows) { + if (this.loadedState) { + this.loadedState.group.traverse((object) => { + if (object.isMesh) { + const mesh = object; + mesh.castShadow = castShadows; + } + }); + } + } + setAnim(anim) { + this.resetAnimationMixer(); + this.animState = null; + for (const [attachment, animState] of this.attachments) { + if (animState) { + animState.animationMixer.stopAllAction(); + this.attachments.set(attachment, null); + } + } + if (!anim) { + this.latestAnimPromise = null; + this.animLoadingInstanceManager.abortIfLoading(); + if (this.loadedState && !this.registeredParentAttachment) { + const parent = this.model.parentElement; + if (parent instanceof Model) { + this.registeredParentAttachment = parent; + parent.modelGraphics.registerAttachment(this.model); + } + } + return; + } + if (this.registeredParentAttachment) { + this.registeredParentAttachment.modelGraphics.unregisterAttachment( + this.model + ); + this.registeredParentAttachment = null; + } + const animSrc = this.model.contentSrcToContentAddress(anim); + const animPromise = this.asyncLoadSourceAsset(animSrc, (loaded, total) => { + this.animLoadingInstanceManager.setProgress(loaded / total); + }); + this.animLoadingInstanceManager.start(this.model.getLoadingProgressManager(), animSrc); + this.latestAnimPromise = animPromise; + animPromise.then((result) => { + if (this.latestAnimPromise !== animPromise || !this.model.isConnected) { + return; + } + this.latestAnimPromise = null; + this.playAnimation(result.animations[0]); + for (const [model] of this.attachments) { + this.registerAttachment(model); + } + this.animLoadingInstanceManager.finish(); + }).catch((err2) => { + console.error("Error loading m-model.anim", err2); + this.latestAnimPromise = null; + this.animLoadingInstanceManager.error(err2); + }); + } + setAnimEnabled() { + } + setAnimLoop() { + } + setAnimStartTime() { + } + setAnimPauseTime() { + } + transformed() { + } + setSrc(src) { + if (this.loadedState !== null) { + this.loadedState.group.removeFromParent(); + if (this.registeredParentAttachment) { + this.registeredParentAttachment.modelGraphics.unregisterAttachment( + this.model + ); + this.registeredParentAttachment = null; + } + _ThreeJSModel2.disposeOfGroup(this.loadedState.group); + this.loadedState = null; + this.updateMeshCallback(); + this.updateDebugVisualisation(); + } + if (!src) { + this.srcLoadingInstanceManager.abortIfLoading(); + this.socketChildrenByBone.forEach((children) => { + children.forEach((child) => { + this.model.getContainer().add(child.getContainer()); + }); + }); + this.updateMeshCallback(); + this.updateDebugVisualisation(); + return; + } + const contentSrc = this.model.contentSrcToContentAddress(src); + const srcModelPromise = this.asyncLoadSourceAsset(contentSrc, (loaded, total) => { + this.srcLoadingInstanceManager.setProgress(loaded / total); + }); + this.srcLoadingInstanceManager.start(this.model.getLoadingProgressManager(), contentSrc); + this.latestSrcModelPromise = srcModelPromise; + srcModelPromise.then((result) => { + if (this.latestSrcModelPromise !== srcModelPromise || !this.model.isConnected) { + _ThreeJSModel2.disposeOfGroup(result.group); + return; + } + result.group.traverse((child) => { + if (child.isMesh) { + child.castShadow = this.model.props.castShadows; + child.receiveShadow = true; + } + }); + this.latestSrcModelPromise = null; + const group = result.group; + const bones = /* @__PURE__ */ new Map(); + group.traverse((object) => { + if (object instanceof Bone) { + bones.set(object.name, object); + } + }); + const boundingBox = new Box3(); + group.updateWorldMatrix(true, true); + boundingBox.expandByObject(group); + this.loadedState = { + group, + bones, + boundingBox: { + size: boundingBox.getSize(new Vector3(0, 0, 0)), + centerOffset: boundingBox.getCenter(new Vector3(0, 0, 0)) + } + }; + this.model.getContainer().add(group); + for (const [boneName, children] of this.socketChildrenByBone) { + const bone = bones.get(boneName); + if (bone) { + children.forEach((child) => { + bone.add(child.getContainer()); + }); + } + } + this.updateMeshCallback(); + const parent = this.model.parentElement; + if (parent instanceof Model) { + if (!this.latestAnimPromise && !this.animState) { + this.registeredParentAttachment = parent; + parent.modelGraphics.registerAttachment(this.model); + } + } + if (this.animState) { + this.playAnimation(this.animState.currentAnimationClip); + } + this.srcLoadingInstanceManager.finish(); + this.updateDebugVisualisation(); + }).catch((err2) => { + console.error("Error loading m-model.src", err2); + this.srcLoadingInstanceManager.error(err2); + }); + } + registerAttachment(attachment) { + let animState = null; + if (this.animState) { + const attachmentLoadedState = attachment.modelGraphics.loadedState; + if (!attachmentLoadedState) { + throw new Error("Attachment must be loaded before registering"); + } + const animationGroup = new AnimationObjectGroup(); + const animationMixer = new AnimationMixer(animationGroup); + const action = animationMixer.clipAction(this.animState.currentAnimationClip); + animState = { + animationGroup, + animationMixer, + animationAction: action + }; + animationGroup.add(attachmentLoadedState.group); + action.play(); + } + this.attachments.set(attachment, animState); + } + unregisterAttachment(attachment) { + const attachmentState = this.attachments.get(attachment); + if (attachmentState) { + attachmentState.animationMixer.stopAllAction(); + } + this.attachments.delete(attachment); + } + updateDebugVisualisation() { + if (!this.model.props.debug) { + this.clearDebugVisualisation(); + } else { + if (!this.debugBoundingBox) { + this.debugBoundingBox = new Mesh( + _ThreeJSModel2.DebugBoundingBoxGeometry, + _ThreeJSModel2.DebugBoundingBoxMaterial + ); + this.model.getContainer().add(this.debugBoundingBox); + } + if (this.loadedState) { + const boundingBox = this.loadedState.boundingBox; + if (boundingBox.centerOffset) { + this.debugBoundingBox.position.copy(boundingBox.centerOffset); + } else { + this.debugBoundingBox.position.set(0, 0, 0); + } + this.debugBoundingBox.scale.copy(boundingBox.size); + } else { + this.debugBoundingBox.scale.set(0, 0, 0); + } + } + } + clearDebugVisualisation() { + if (this.debugBoundingBox) { + this.debugBoundingBox.removeFromParent(); + this.debugBoundingBox = null; + } + } + async asyncLoadSourceAsset(url, onProgress) { + return await _ThreeJSModel2.modelLoader.load(url, onProgress); + } + resetAnimationMixer() { + if (this.documentTimeTickListener) { + this.documentTimeTickListener.remove(); + this.documentTimeTickListener = null; + } + if (this.animState) { + const appliedAnimation = this.animState.appliedAnimation; + if (appliedAnimation) { + appliedAnimation.animationMixer.stopAllAction(); + } + this.animState.appliedAnimation = null; + } + } + registerSocketChild(child, socketName) { + let children = this.socketChildrenByBone.get(socketName); + if (!children) { + children = /* @__PURE__ */ new Set(); + this.socketChildrenByBone.set(socketName, children); + } + children.add(child); + if (this.loadedState) { + const bone = this.loadedState.bones.get(socketName); + if (bone) { + bone.add(child.getContainer()); + } else { + this.model.getContainer().add(child.getContainer()); + } + } + } + unregisterSocketChild(child, socketName, addToRoot = true) { + const socketChildren = this.socketChildrenByBone.get(socketName); + if (socketChildren) { + socketChildren.delete(child); + if (addToRoot) { + this.model.getContainer().add(child.getContainer()); + } + if (socketChildren.size === 0) { + this.socketChildrenByBone.delete(socketName); + } + } + } + triggerSocketedChildrenTransformed() { + this.socketChildrenByBone.forEach((children) => { + children.forEach((child) => { + if (child instanceof TransformableElement) { + child.didUpdateTransformation(); + } + }); + }); + } + playAnimation(anim) { + this.resetAnimationMixer(); + this.animState = { + currentAnimationClip: anim, + appliedAnimation: null + }; + const animationGroup = new AnimationObjectGroup(); + const animationMixer = new AnimationMixer(animationGroup); + const action = animationMixer.clipAction(anim); + this.animState.appliedAnimation = { + animationGroup, + animationMixer, + animationAction: action + }; + if (this.loadedState) { + animationGroup.add(this.loadedState.group); + } + action.play(); + if (!this.documentTimeTickListener) { + this.documentTimeTickListener = this.model.addDocumentTimeTickListener( + (documentTime) => { + this.updateAnimation(documentTime); + } + ); + } + } + updateAnimation(docTimeMs, force = false) { + var _a2, _b2; + if (this.animState) { + if (!this.model.props.animEnabled && this.animState.appliedAnimation) { + this.resetAnimationMixer(); + this.triggerSocketedChildrenTransformed(); + } else { + if (!this.animState.appliedAnimation) { + this.playAnimation(this.animState.currentAnimationClip); + } + let animationTimeMs = docTimeMs - this.model.props.animStartTime; + if (docTimeMs < this.model.props.animStartTime) { + animationTimeMs = 0; + } else if (this.model.props.animPauseTime !== null) { + if (docTimeMs > this.model.props.animPauseTime) { + animationTimeMs = this.model.props.animPauseTime - this.model.props.animStartTime; + } + } + const clip = this.animState.currentAnimationClip; + if (clip !== null) { + if (!this.model.props.animLoop) { + if (animationTimeMs > clip.duration * 1e3) { + animationTimeMs = clip.duration * 1e3; + } + } + } + for (const [model, attachmentState] of this.attachments) { + if (attachmentState) { + attachmentState.animationMixer.setTime(animationTimeMs / 1e3); + model.modelGraphics.triggerSocketedChildrenTransformed(); + } + } + if (force) { + (_a2 = this.animState.appliedAnimation) == null ? void 0 : _a2.animationMixer.setTime((animationTimeMs + 1) / 1e3); + } + (_b2 = this.animState.appliedAnimation) == null ? void 0 : _b2.animationMixer.setTime(animationTimeMs / 1e3); + this.triggerSocketedChildrenTransformed(); + } + } + } + dispose() { + var _a2, _b2; + if (this.documentTimeTickListener) { + this.documentTimeTickListener.remove(); + this.documentTimeTickListener = null; + } + if (this.registeredParentAttachment) { + (_b2 = (_a2 = this.registeredParentAttachment) == null ? void 0 : _a2.modelGraphics) == null ? void 0 : _b2.unregisterAttachment( + this.model + ); + this.registeredParentAttachment = null; + } + if (this.loadedState) { + this.loadedState.group.removeFromParent(); + _ThreeJSModel2.disposeOfGroup(this.loadedState.group); + this.loadedState = null; + } + this.clearDebugVisualisation(); + this.animLoadingInstanceManager.dispose(); + this.srcLoadingInstanceManager.dispose(); + } + static disposeOfGroup(group) { + group.traverse((child) => { + if (child.isMesh) { + const mesh = child; + mesh.geometry.dispose(); + if (Array.isArray(mesh.material)) { + for (const material of mesh.material) { + _ThreeJSModel2.disposeOfMaterial(material); + } + } else if (mesh.material) { + _ThreeJSModel2.disposeOfMaterial(mesh.material); + } + } + }); + } + static disposeOfMaterial(material) { + material.dispose(); + for (const key of Object.keys(material)) { + const value = material[key]; + if (value && typeof value === "object" && "minFilter" in value) { + value.dispose(); + } + } + } +}; +_ThreeJSModel.modelLoader = new ModelLoader(); +_ThreeJSModel.DebugBoundingBoxGeometry = new BoxGeometry(1, 1, 1, 1, 1, 1); +_ThreeJSModel.DebugBoundingBoxMaterial = new MeshBasicMaterial({ + color: 16711680, + wireframe: true, + transparent: true, + opacity: 0.3 +}); +var ThreeJSModel = _ThreeJSModel; +var _ThreeJSPlane = class _ThreeJSPlane2 extends PlaneGraphics { + constructor(plane) { + super(plane); + this.plane = plane; + this.material = new MeshStandardMaterial({ + color: new Color(plane.props.color.r, plane.props.color.g, plane.props.color.b) + }); + this.mesh = new Mesh(_ThreeJSPlane2.planeGeometry, this.material); + this.mesh.castShadow = plane.props.castShadows; + this.mesh.receiveShadow = true; + this.plane.getContainer().add(this.mesh); + } + disable() { + } + enable() { + } + getCollisionElement() { + return this.mesh; + } + setColor(color) { + this.material.color = new Color(color.r, color.g, color.b); + } + setWidth(width) { + this.mesh.scale.x = width; + } + setHeight(height) { + this.mesh.scale.y = height; + } + setCastShadows(castShadows) { + this.mesh.castShadow = castShadows; + } + setOpacity(opacity) { + const needsUpdate = this.material.transparent === (opacity === 1); + this.material.transparent = opacity !== 1; + this.material.needsUpdate = needsUpdate; + this.material.opacity = opacity; + } + dispose() { + } +}; +_ThreeJSPlane.planeGeometry = new PlaneGeometry(1, 1); +var ThreeJSPlane = _ThreeJSPlane; +var _ThreeJSPositionProbe = class _ThreeJSPositionProbe2 extends PositionProbeGraphics { + constructor(positionProbe) { + super(positionProbe); + this.positionProbe = positionProbe; + this.debugMesh = null; + } + disable() { + } + enable() { + } + setRange() { + this.updateDebugVisualisation(); + } + setDebug() { + this.updateDebugVisualisation(); + } + clearDebugVisualisation() { + if (this.debugMesh) { + this.debugMesh.removeFromParent(); + this.debugMesh = null; + } + } + updateDebugVisualisation() { + if (!this.positionProbe.props.debug) { + this.clearDebugVisualisation(); + } else { + if (this.positionProbe.isConnected && !this.debugMesh) { + const mesh = new Mesh( + _ThreeJSPositionProbe2.DebugGeometry, + _ThreeJSPositionProbe2.DebugMaterial + ); + mesh.castShadow = false; + mesh.receiveShadow = false; + this.debugMesh = mesh; + this.positionProbe.getContainer().add(this.debugMesh); + } + if (this.debugMesh) { + this.debugMesh.scale.set( + this.positionProbe.props.range, + this.positionProbe.props.range, + this.positionProbe.props.range + ); + } + } + } + dispose() { + this.clearDebugVisualisation(); + } +}; +_ThreeJSPositionProbe.DebugGeometry = new SphereGeometry(1, 16, 16, 1); +_ThreeJSPositionProbe.DebugMaterial = new MeshBasicMaterial({ + color: 16711680, + wireframe: true, + transparent: true, + opacity: 0.3 +}); +var ThreeJSPositionProbe = _ThreeJSPositionProbe; +var ThreeJSPrompt = class extends PromptGraphics { + constructor(prompt) { + super(prompt); + this.prompt = prompt; + } + disable() { + } + enable() { + } + setMessage() { + } + setPlaceholder() { + } + setPrefill() { + } + setDebug() { + } + dispose() { + } +}; +function createReconnectingStatus() { + const canvas = new CanvasText().renderText("Reconnecting", { + bold: true, + fontSize: 32, + paddingPx: 10, + textColorRGB255A1: { + r: 255, + g: 0, + b: 0, + a: 1 + }, + backgroundColorRGB255A1: { + r: 255, + g: 255, + b: 255, + a: 1 + }, + alignment: "center" + }); + const texture = new Texture(canvas); + texture.minFilter = LinearFilter; + texture.magFilter = LinearFilter; + texture.format = RGBAFormat; + texture.needsUpdate = true; + const width = canvas.width; + const height = canvas.height; + const material = new MeshBasicMaterial({ + map: texture, + side: DoubleSide + }); + const geometry = new PlaneGeometry(width / 100, height / 100, 1, 1); + return { geometry, material, width: width / 100, height: height / 100 }; +} +var reconnectingStatus = null; +function getThreeJSReconnectingStatus() { + if (!reconnectingStatus) { + reconnectingStatus = createReconnectingStatus(); + } + return reconnectingStatus; +} +var ThreeJSRemoteDocument = class extends RemoteDocumentGraphics { + constructor(element) { + super(element); + this.element = element; + this.statusUI = null; + } + showError(showError) { + if (!showError) { + if (this.statusUI !== null) { + this.element.getContainer().remove(this.statusUI); + this.statusUI = null; + } + } else { + if (this.statusUI === null) { + const { geometry, material, height } = getThreeJSReconnectingStatus(); + const mesh = new Mesh( + geometry, + material + ); + mesh.position.set(0, height / 2, 0); + this.statusUI = mesh; + this.element.getContainer().add(this.statusUI); + } + } + } + dispose() { + } +}; +var defaultSphereWidthSegments = 16; +var defaultSphereHeightSegments = 16; +var _ThreeJSSphere = class _ThreeJSSphere2 extends SphereGraphics { + constructor(sphere) { + super(sphere); + this.sphere = sphere; + this.material = new MeshStandardMaterial({ + color: new Color(sphere.props.color.r, sphere.props.color.g, sphere.props.color.b) + }); + this.mesh = new Mesh(_ThreeJSSphere2.sphereGeometry, this.material); + this.mesh.castShadow = sphere.props.castShadows; + this.mesh.receiveShadow = true; + this.sphere.getContainer().add(this.mesh); + } + disable() { + } + enable() { + } + getCollisionElement() { + return this.mesh; + } + setColor(color) { + this.material.color = new Color(color.r, color.g, color.b); + } + setRadius(radius) { + this.mesh.scale.x = radius * 2; + this.mesh.scale.y = radius * 2; + this.mesh.scale.z = radius * 2; + } + setCastShadows(castShadows) { + this.mesh.castShadow = castShadows; + } + setOpacity(opacity) { + const needsUpdate = this.material.transparent === (opacity === 1); + this.material.transparent = opacity !== 1; + this.material.needsUpdate = needsUpdate; + this.material.opacity = opacity; + } + dispose() { + } +}; +_ThreeJSSphere.sphereGeometry = new SphereGeometry( + 0.5, + defaultSphereWidthSegments, + defaultSphereHeightSegments +); +var ThreeJSSphere = _ThreeJSSphere; +var ThreeJSTransformable = class extends TransformableGraphics { + constructor(transformableElement) { + super(transformableElement); + this.transformableElement = transformableElement; + this.socketName = null; + this.registeredSocketParent = null; + } + getWorldMatrix() { + const container = this.getContainer(); + container.updateWorldMatrix(true, false); + return new Matr4(container.matrixWorld.elements); + } + setVisible(visible) { + this.getContainer().visible = visible; + } + setSocket(socketName) { + if (this.socketName !== socketName) { + if (this.socketName !== null && this.registeredSocketParent) { + this.registeredSocketParent.unregisterSocketChild( + this.transformableElement, + this.socketName + ); + } + this.socketName = socketName; + if (socketName !== null) { + this.registerWithParentModel(socketName); + } + } else { + this.socketName = socketName; + } + } + registerWithParentModel(socketName) { + var _a2; + if ((_a2 = this.transformableElement.parentElement) == null ? void 0 : _a2.isModel) { + const parentModel = this.transformableElement.parentElement; + this.registeredSocketParent = parentModel.modelGraphics; + this.registeredSocketParent.registerSocketChild(this.transformableElement, socketName); + } + } + getContainer() { + return this.transformableElement.getContainer(); + } + setX(x) { + this.getContainer().position.x = x; + } + setY(y) { + this.getContainer().position.y = y; + } + setZ(z) { + this.getContainer().position.z = z; + } + setRotationX(rotationX) { + this.getContainer().rotation.x = rotationX * MathUtils.DEG2RAD; + } + setRotationY(rotationY) { + this.getContainer().rotation.y = rotationY * MathUtils.DEG2RAD; + } + setRotationZ(rotationZ) { + this.getContainer().rotation.z = rotationZ * MathUtils.DEG2RAD; + } + setScaleX(scaleX) { + this.getContainer().scale.x = scaleX; + } + setScaleY(scaleY) { + this.getContainer().scale.y = scaleY; + } + setScaleZ(scaleZ) { + this.getContainer().scale.z = scaleZ; + } + dispose() { + if (this.socketName && this.registeredSocketParent !== null) { + this.registeredSocketParent.unregisterSocketChild( + this.transformableElement, + this.socketName, + false + ); + } + } +}; +var audioRefDistance2 = 1; +var audioRolloffFactor2 = 1; +var disabledVideoMaterial = new MeshStandardMaterial({ + color: 0, + side: DoubleSide +}); +var ThreeJSVideo = class extends VideoGraphics { + constructor(video, updateMeshCallback) { + super(video, updateMeshCallback); + this.video = video; + this.updateMeshCallback = updateMeshCallback; + this.videoSource = null; + this.loadedVideoState = null; + const geometry = new PlaneGeometry(1, 1, 1, 1); + this.videoMaterial = new MeshStandardMaterial({ + color: 16777215, + transparent: false, + side: DoubleSide + }); + this.mesh = new Mesh(geometry, disabledVideoMaterial); + this.mesh.castShadow = true; + this.mesh.receiveShadow = false; + this.video.getContainer().add(this.mesh); + } + getWidthAndHeight() { + return { + width: this.mesh.scale.x, + height: this.mesh.scale.y + }; + } + syncVideoTime() { + if (this.loadedVideoState) { + const videoTag = this.loadedVideoState.video; + if (videoTag.readyState === 0) { + return; + } + const audioListener = this.getAudioListener(); + const audioContext = audioListener.context; + if (audioContext.state === "running") { + videoTag.muted = false; + } + if (this.video.isDisabled()) { + videoTag.muted = true; + } + if (this.videoSource) { + this.videoSource.syncVideoSource(this.video.props); + } + } + } + getAudioListener() { + return this.video.getScene().getGraphicsAdapter().getAudioListener(); + } + enable() { + this.updateVideo(); + } + disable() { + this.updateVideo(); + } + getCollisionElement() { + return this.mesh; + } + setSrc() { + this.updateVideo(); + } + setWidth() { + this.updateWidthAndHeight(); + } + setHeight() { + this.updateWidthAndHeight(); + } + setEnabled() { + this.updateVideo(); + } + setCastShadows() { + this.updateVideo(); + } + setLoop() { + this.updateVideo(); + } + setVolume() { + if (this.loadedVideoState) { + this.loadedVideoState.audio.setVolume(this.video.props.volume); + } + } + setEmissive() { + this.updateVideo(); + this.updateMaterialEmissiveIntensity(); + } + setStartTime() { + this.updateVideo(); + } + setPauseTime() { + this.updateVideo(); + } + updateVideo() { + if (!this.video.isConnected) { + return; + } + if (!this.video.props.enabled) { + this.clearSource(); + return; + } + if (!this.video.props.src) { + this.clearSource(); + } else { + const contentAddress = this.video.contentSrcToContentAddress(this.video.props.src); + if (this.videoSource === null || this.videoSource.getContentAddress() !== contentAddress) { + this.clearSource(); + const video = document.createElement("video"); + video.playsInline = true; + video.muted = true; + video.autoplay = true; + video.crossOrigin = "anonymous"; + const audioListener = this.getAudioListener(); + const audioContext = audioListener.context; + const audio = new PositionalAudio(audioListener); + audio.setMediaElementSource(video); + audio.setVolume(this.video.props.volume); + audio.setRefDistance(audioRefDistance2); + audio.setRolloffFactor(audioRolloffFactor2); + this.loadedVideoState = { + video, + audio, + videoTexture: null + }; + this.updateMaterialEmissiveIntensity(); + this.video.getContainer().add(audio); + const url = new URL(contentAddress); + if (WHEPVideoSource.isWHEPURL(url)) { + this.videoSource = new WHEPVideoSource(url, video); + } else { + this.videoSource = new StaticFileVideoSource(url, video, this.video.props, () => { + return this.video.getDocumentTime(); + }); + } + audioContext.addEventListener("statechange", () => { + this.syncVideoTime(); + }); + video.addEventListener("loadeddata", () => { + if (!this.loadedVideoState || this.loadedVideoState.video !== video) { + return; + } + const videoTexture = new VideoTexture(video); + this.videoMaterial.map = videoTexture; + this.videoMaterial.needsUpdate = true; + this.mesh.material = this.videoMaterial; + this.loadedVideoState.videoTexture = videoTexture; + this.syncVideoTime(); + this.updateWidthAndHeight(); + this.updateMaterialEmissiveIntensity(); + }); + } + } + if (this.videoSource) { + this.syncVideoTime(); + } + } + clearSource() { + if (this.videoSource) { + this.videoSource.dispose(); + this.videoSource = null; + } + if (this.loadedVideoState) { + const tag = this.loadedVideoState.video; + tag.pause(); + tag.src = ""; + tag.load(); + this.loadedVideoState = null; + this.mesh.material = disabledVideoMaterial; + this.updateWidthAndHeight(); + } + } + dispose() { + this.clearSource(); + if (this.loadedVideoState) { + this.loadedVideoState = null; + } + } + updateMaterialEmissiveIntensity() { + if (this.loadedVideoState && this.loadedVideoState.videoTexture) { + if (this.video.props.emissive > 0) { + this.videoMaterial.emissive = new Color(16777215); + this.videoMaterial.emissiveMap = this.loadedVideoState.videoTexture; + this.videoMaterial.emissiveIntensity = this.video.props.emissive; + this.videoMaterial.needsUpdate = true; + } else { + this.videoMaterial.emissive = new Color(0); + this.videoMaterial.emissiveMap = null; + this.videoMaterial.emissiveIntensity = 1; + this.videoMaterial.needsUpdate = true; + } + } + } + updateWidthAndHeight() { + const mesh = this.mesh; + const { width, height } = calculateContentSize({ + content: this.loadedVideoState ? { + width: this.loadedVideoState.video.videoWidth, + height: this.loadedVideoState.video.videoHeight + } : void 0, + width: this.video.props.width, + height: this.video.props.height + }); + mesh.scale.x = width; + mesh.scale.y = height; + this.updateMeshCallback(); + } +}; +var mouseMovePixelsThreshold = 10; +var mouseMoveTimeThresholdMilliseconds = 500; +var ThreeJSClickTrigger = class _ThreeJSClickTrigger { + constructor(clickTarget, rootContainer, camera) { + this.clickTarget = clickTarget; + this.rootContainer = rootContainer; + this.camera = camera; + this.eventHandlerCollection = new EventHandlerCollection(); + this.mouseDownTime = null; + this.mouseMoveDelta = 0; + this.raycaster = new Raycaster(); + this.eventHandlerCollection.add(clickTarget, "mousedown", this.handleMouseDown.bind(this)); + this.eventHandlerCollection.add(clickTarget, "mouseup", this.handleMouseUp.bind(this)); + this.eventHandlerCollection.add(clickTarget, "mousemove", this.handleMouseMove.bind(this)); + } + static init(clickTarget, rootContainer, camera) { + return new _ThreeJSClickTrigger(clickTarget, rootContainer, camera); + } + handleMouseDown() { + this.mouseDownTime = Date.now(); + this.mouseMoveDelta = 0; + } + handleMouseUp(event) { + if (!this.mouseDownTime) { + return; + } + const duration = Date.now() - this.mouseDownTime; + this.mouseDownTime = null; + if (this.mouseMoveDelta < mouseMovePixelsThreshold && duration < mouseMoveTimeThresholdMilliseconds) { + this.handleClick(event); + } + } + handleMouseMove(event) { + if (this.mouseDownTime) { + this.mouseMoveDelta += Math.abs(event.movementX) + Math.abs(event.movementY); + } + } + handleClick(event) { + if (event.detail.element) { + return; + } + let x = 0; + let y = 0; + if (!document.pointerLockElement) { + let width = window.innerWidth; + let height = window.innerHeight; + if (this.clickTarget instanceof HTMLElement) { + width = this.clickTarget.offsetWidth; + height = this.clickTarget.offsetHeight; + } + x = event.offsetX / width * 2 - 1; + y = -(event.offsetY / height * 2 - 1); + } + this.raycaster.setFromCamera(new Vector2(x, y), this.camera); + const intersections = this.raycaster.intersectObject(this.rootContainer, true); + if (intersections.length > 0) { + for (const intersection of intersections) { + let obj = intersection.object; + while (obj) { + if (this.isMaterialIgnored(obj)) { + break; + } + const mElement = MElement.getMElementFromObject(obj); + if (mElement && mElement instanceof TransformableElement && mElement.isClickable()) { + const elementRelative = getRelativePositionAndRotationRelativeToObject( + { + position: intersection.point, + rotation: { + x: 0, + y: 0, + z: 0 + } + }, + mElement + ); + mElement.dispatchEvent( + new CustomEvent("click", { + bubbles: true, + detail: { + position: { + ...elementRelative.position + } + } + }) + ); + return; + } + obj = obj.parent; + } + } + } + } + dispose() { + this.eventHandlerCollection.clear(); + } + isMaterialIgnored(obj) { + const mesh = obj; + if (mesh) { + if (mesh.material && mesh.material.transparent && mesh.material.opacity < 1 || mesh.material && mesh.material.wireframe || mesh.material && mesh.material.wireframe || mesh.material && mesh.material.wireframe || mesh.material && mesh.material.wireframe || mesh.material && mesh.material.isLineBasicMaterial) { + return true; + } + } + return false; + } +}; +var ThreeJSGraphicsInterface = { + MElementGraphicsInterface: (element) => new ThreeJSMElement(element), + MMLDebugHelperGraphicsInterface: (debugHelper) => new ThreeJSDebugHelper(debugHelper), + MMLAudioGraphicsInterface: (element) => new ThreeJSAudio(element), + MMLChatProbeGraphicsInterface: (element) => new ThreeJSChatProbe(element), + MMLCubeGraphicsInterface: (element) => new ThreeJSCube(element), + MMLCylinderGraphicsInterface: (element) => new ThreeJSCylinder(element), + MMLFrameGraphicsInterface: (element) => new ThreeJSFrame(element), + MMLImageGraphicsInterface: (element, updateMeshCallback) => new ThreeJSImage(element, updateMeshCallback), + MMLInteractionGraphicsInterface: (element) => new ThreeJSInteraction(element), + MMLLabelGraphicsInterface: (element) => new ThreeJSLabel(element), + MMLLightGraphicsInterface: (element) => new ThreeJSLight(element), + MMLLinkGraphicsInterface: (element) => new ThreeJSLink(element), + MMLModelGraphicsInterface: (element, updateMeshCallback) => new ThreeJSModel(element, updateMeshCallback), + MMLPlaneGraphicsInterface: (element) => new ThreeJSPlane(element), + MMLPositionProbeGraphicsInterface: (element) => new ThreeJSPositionProbe(element), + MMLPromptGraphicsInterface: (element) => new ThreeJSPrompt(element), + MMLSphereGraphicsInterface: (element) => new ThreeJSSphere(element), + MMLTransformableGraphicsInterface: (element) => new ThreeJSTransformable(element), + MMLVideoGraphicsInterface: (element, updateMeshCallback) => new ThreeJSVideo(element, updateMeshCallback), + RemoteDocumentGraphicsInterface: (element) => new ThreeJSRemoteDocument(element) +}; +var _ThreeJSInteractionAdapter = class _ThreeJSInteractionAdapter2 { + static interactionShouldShowDistance(interaction, camera, scene) { + const worldPos = interaction.getContainer().getWorldPosition(_ThreeJSInteractionAdapter2.worldPos); + const cameraPos = camera.position; + const distance = cameraPos.distanceTo(worldPos); + if (distance > interaction.props.range) { + return null; + } + if (interaction.props.inFocus) { + _ThreeJSInteractionAdapter2.matrix.multiplyMatrices( + camera.projectionMatrix, + camera.matrixWorldInverse + ); + _ThreeJSInteractionAdapter2.frustum.setFromProjectionMatrix(_ThreeJSInteractionAdapter2.matrix); + if (!_ThreeJSInteractionAdapter2.frustum.containsPoint(worldPos)) { + return null; + } + } + if (interaction.props.lineOfSight) { + const raycastResults = _ThreeJSInteractionAdapter2.getRaycastResults( + cameraPos, + worldPos, + distance, + scene + ); + if (raycastResults.length > 0) { + for (const result of raycastResults) { + if (!_ThreeJSInteractionAdapter2.hasAncestor(result.object, interaction.getContainer())) { + return null; + } + } + } + } + return distance; + } + static getRaycastResults(a, b, distance, scene) { + _ThreeJSInteractionAdapter2.direction.copy(b); + _ThreeJSInteractionAdapter2.direction.sub(a); + _ThreeJSInteractionAdapter2.direction.normalize(); + _ThreeJSInteractionAdapter2.raycaster.set(a, _ThreeJSInteractionAdapter2.direction); + _ThreeJSInteractionAdapter2.raycaster.near = 0; + _ThreeJSInteractionAdapter2.raycaster.far = distance; + _ThreeJSInteractionAdapter2.intersections.length = 0; + _ThreeJSInteractionAdapter2.raycaster.intersectObject( + scene, + true, + _ThreeJSInteractionAdapter2.intersections + ); + return _ThreeJSInteractionAdapter2.intersections; + } + static hasAncestor(object, ancestor) { + let parent = object.parent; + while (parent !== null) { + if (parent === ancestor) { + return true; + } + parent = parent.parent; + } + return false; + } +}; +_ThreeJSInteractionAdapter.worldPos = new Vector3(); +_ThreeJSInteractionAdapter.matrix = new Matrix4(); +_ThreeJSInteractionAdapter.frustum = new Frustum(); +_ThreeJSInteractionAdapter.raycaster = new Raycaster(); +_ThreeJSInteractionAdapter.intersections = new Array(); +_ThreeJSInteractionAdapter.direction = new Vector3(); +var ThreeJSInteractionAdapter = _ThreeJSInteractionAdapter; + +// ../../node_modules/@mml-io/mml-web-threejs-standalone/build/index.js +var up = { x: 0, y: 1, z: 0 }; +var right = { x: 1, y: 0, z: 0 }; +var quaternion = new Quat(); +var qPitch = new Quat(); +var qYaw = new Quat(); +var tempVector = new Vector3(); +var ThreeJSDragFlyCameraControls = class { + constructor(camera, domElement, speed = 15) { + this.camera = camera; + this.domElement = domElement; + this.speed = speed; + this.type = "drag-fly"; + this.enabled = false; + this.yaw = 0; + this.pitch = 0; + this.forward = false; + this.backward = false; + this.left = false; + this.right = false; + this.up = false; + this.down = false; + this.minPolarAngle = 0 * (Math.PI / 180); + this.maxPolarAngle = 180 * (Math.PI / 180); + this.invertedMouseY = false; + this.eventHandlerCollection = new EventHandlerCollection(); + this.mouseDown = false; + this.domElement.style.userSelect = "none"; + } + fitContent(boundingBox) { + const center = { + x: (boundingBox.min.x + boundingBox.max.x) / 2, + y: (boundingBox.min.y + boundingBox.max.y) / 2, + z: (boundingBox.min.z + boundingBox.max.z) / 2 + }; + const size = { + x: boundingBox.max.x - boundingBox.min.x, + y: boundingBox.max.y - boundingBox.min.y, + z: boundingBox.max.z - boundingBox.min.z + }; + const fov2 = this.camera.fov; + const maximumDimension = Math.max(size.x, size.y, size.z); + const distance = Math.abs(maximumDimension / 4 / Math.tan(fov2 / 2)); + const currentCameraRay = this.camera.getWorldDirection(new Vector3()).normalize(); + currentCameraRay.multiplyScalar(-distance); + this.camera.position.set( + center.x + currentCameraRay.x, + center.y + currentCameraRay.y, + center.z + currentCameraRay.z + ); + this.setLookAt(center.x, center.y, center.z); + } + enable() { + if (this.enabled) { + return; + } + this.enabled = true; + this.eventHandlerCollection.add(document, "keydown", this.onKeyDown.bind(this)); + this.eventHandlerCollection.add(document, "keyup", this.onKeyUp.bind(this)); + this.eventHandlerCollection.add(window, "blur", this.onBlur.bind(this)); + this.eventHandlerCollection.add(document, "mousemove", this.onMouseMove.bind(this)); + this.eventHandlerCollection.add(this.domElement, "mousedown", this.onMouseDown.bind(this)); + this.eventHandlerCollection.add(document, "mouseup", this.onMouseUp.bind(this)); + this.eventHandlerCollection.add(document, "wheel", this.onMouseWheel.bind(this)); + } + disable() { + if (!this.enabled) { + return; + } + this.eventHandlerCollection.clear(); + this.enabled = false; + } + setInvert(invert) { + this.invertedMouseY = invert; + } + dispose() { + this.disable(); + } + update(dt) { + if (!this.mouseDown) { + return; + } + tempVector.set( + (Number(this.right) - Number(this.left)) * dt * 30, + (Number(this.up) - Number(this.down)) * dt * 30, + (Number(this.backward) - Number(this.forward)) * dt * 30 + ); + tempVector.applyQuaternion(this.camera.quaternion); + this.camera.position.add(tempVector); + } + onKeyDown(event) { + if (!this.mouseDown) { + return; + } + switch (event.code) { + case "ArrowUp": + case "KeyW": + this.forward = true; + break; + case "ArrowLeft": + case "KeyA": + this.left = true; + break; + case "ArrowDown": + case "KeyS": + this.backward = true; + break; + case "ArrowRight": + case "KeyD": + this.right = true; + break; + case "Space": + this.up = true; + break; + case "ShiftLeft": + this.down = true; + break; + } + event.preventDefault(); + } + onKeyUp(event) { + switch (event.code) { + case "ArrowUp": + case "KeyW": + this.forward = false; + break; + case "ArrowLeft": + case "KeyA": + this.left = false; + break; + case "ArrowDown": + case "KeyS": + this.backward = false; + break; + case "ArrowRight": + case "KeyD": + this.right = false; + break; + case "Space": + this.up = false; + break; + case "ShiftLeft": + this.down = false; + break; + } + } + onBlur() { + this.mouseDown = false; + this.forward = false; + this.left = false; + this.backward = false; + this.right = false; + this.up = false; + this.down = false; + } + onMouseDown() { + this.mouseDown = true; + } + setCameraPosition(x, y, z) { + this.camera.position.set(x, y, z); + } + setLookAt(x, y, z) { + this.camera.lookAt(new Vector3(x, y, z)); + const q1 = new Quat().setFromEulerXYZ(this.camera.rotation); + const { yaw, pitch } = getYawPitchFromQuaternion(q1); + this.yaw = yaw; + this.pitch = pitch; + this.updateCameraFromYawAndPitch(); + } + onMouseMove(event) { + if (!this.mouseDown) { + return; + } + const movementX = event.movementX; + let movementY = event.movementY; + if (this.invertedMouseY) { + movementY *= -1; + } + this.yaw += movementX * -2e-3; + this.pitch += movementY * -2e-3; + this.updateCameraFromYawAndPitch(); + } + updateCameraFromYawAndPitch() { + this.yaw = this.yaw % (Math.PI * 2); + this.pitch = this.pitch % (Math.PI * 2); + this.pitch = Math.max( + Math.PI / 2 - this.maxPolarAngle, + Math.min(Math.PI / 2 - this.minPolarAngle, this.pitch) + ); + qPitch.setFromAxisAngle(right, this.pitch); + qYaw.setFromAxisAngle(up, this.yaw); + quaternion.set(0, 0, 0, 1); + quaternion.multiply(qYaw); + quaternion.multiply(qPitch); + this.camera.quaternion.set(quaternion.x, quaternion.y, quaternion.z, quaternion.w); + } + onMouseUp() { + this.mouseDown = false; + } + onMouseWheel(event) { + if (!this.mouseDown) { + return; + } + this.speed -= event.deltaY * 0.1; + this.speed = Math.max(5, Math.min(this.speed, 1e3)); + } +}; +function clamp2(value, min, max2) { + return Math.max(min, Math.min(max2, value)); +} +function getYawPitchFromQuaternion(quaternion2) { + const matr4 = new Matr4(); + matr4.setRotationFromQuaternion(quaternion2); + const d = matr4.data; + const m11 = d[0]; + const m13 = d[8]; + const m23 = d[9]; + const m31 = d[2]; + const m33 = d[10]; + const yaw = Math.abs(m23) < 0.9999999 ? Math.atan2(m13, m33) : Math.atan2(-m31, m11); + const pitch = Math.asin(-clamp2(m23, -1, 1)); + return { yaw, pitch }; +} +var tempSpherical = new Spherical(); +var ThreeJSOrbitCameraControls = class { + constructor(camera, domElement, distance = 15) { + this.camera = camera; + this.domElement = domElement; + this.distance = distance; + this.type = "orbit"; + this.enabled = false; + this.degreesPerSecond = 10; + this.yaw = 0; + this.pitch = Math.PI * 0.4; + this.minPolarAngle = -89.9999 * (Math.PI / 180); + this.maxPolarAngle = 89.9999 * (Math.PI / 180); + this.invertedMouseY = false; + this.eventHandlerCollection = new EventHandlerCollection(); + this.mouseDown = false; + this.cameraLookAt = new Vector3(); + this.domElement.style.userSelect = "none"; + } + fitContent(boundingBox) { + const center = { + x: (boundingBox.min.x + boundingBox.max.x) / 2, + y: (boundingBox.min.y + boundingBox.max.y) / 2, + z: (boundingBox.min.z + boundingBox.max.z) / 2 + }; + const size = { + x: boundingBox.max.x - boundingBox.min.x, + y: boundingBox.max.y - boundingBox.min.y, + z: boundingBox.max.z - boundingBox.min.z + }; + const fov2 = this.camera.fov || 1; + const maximumDimension = Math.max(size.x, size.y, size.z); + this.distance = Math.abs(maximumDimension / 4 / Math.tan(fov2 / 2)); + this.setLookAt(center.x, center.y, center.z); + this.update(); + } + enable() { + if (this.enabled) { + return; + } + this.enabled = true; + this.eventHandlerCollection.add(window, "blur", this.onBlur.bind(this)); + this.eventHandlerCollection.add(document, "mousemove", this.onMouseMove.bind(this)); + this.eventHandlerCollection.add(this.domElement, "mousedown", this.onMouseDown.bind(this)); + this.eventHandlerCollection.add(document, "mouseup", this.onMouseUp.bind(this)); + this.eventHandlerCollection.add(document, "wheel", this.onMouseWheel.bind(this)); + } + disable() { + if (!this.enabled) { + return; + } + this.eventHandlerCollection.clear(); + this.enabled = false; + } + setInvert(invert) { + this.invertedMouseY = invert; + } + dispose() { + this.disable(); + } + getBaseYaw() { + return -(Date.now() / 1e3 * this.degreesPerSecond) % 360 * (Math.PI / 180); + } + update() { + const baseYaw = this.getBaseYaw(); + const yaw = baseYaw + this.yaw; + tempSpherical.set(this.distance, this.pitch, yaw); + this.camera.position.setFromSpherical(tempSpherical); + this.camera.position.add(this.cameraLookAt); + this.camera.lookAt(this.cameraLookAt.x, this.cameraLookAt.y, this.cameraLookAt.z); + } + onBlur() { + this.mouseDown = false; + } + onMouseDown() { + this.mouseDown = true; + } + setDegreesPerSecond(degreesPerSecond) { + this.degreesPerSecond = degreesPerSecond; + } + setLookAt(x, y, z) { + this.cameraLookAt.set(x, y, z); + } + setDistance(distance) { + this.distance = distance; + } + setPitchDegrees(pitch) { + this.pitch = pitch * (Math.PI / 180); + this.pitch = this.pitch % (Math.PI * 2); + } + onMouseMove(event) { + if (!this.mouseDown) { + return; + } + const movementX = event.movementX; + let movementY = event.movementY; + if (this.invertedMouseY) { + movementY *= -1; + } + this.yaw += movementX * -2e-3; + this.pitch += movementY * -2e-3; + this.yaw = this.yaw % (Math.PI * 2); + this.pitch = this.pitch % (Math.PI * 2); + this.pitch = Math.max( + Math.PI / 2 - this.maxPolarAngle, + Math.min(Math.PI / 2 - this.minPolarAngle, this.pitch) + ); + } + onMouseUp() { + this.mouseDown = false; + } + onMouseWheel(event) { + this.distance += event.deltaY * 0.1; + this.distance = Math.max(0.01, Math.min(this.distance, 1e3)); + } +}; +var StandaloneThreeJSAdapterControlsType = /* @__PURE__ */ ((StandaloneThreeJSAdapterControlsType2) => { + StandaloneThreeJSAdapterControlsType2[StandaloneThreeJSAdapterControlsType2["None"] = 0] = "None"; + StandaloneThreeJSAdapterControlsType2[StandaloneThreeJSAdapterControlsType2["DragFly"] = 1] = "DragFly"; + StandaloneThreeJSAdapterControlsType2[StandaloneThreeJSAdapterControlsType2["Orbit"] = 2] = "Orbit"; + return StandaloneThreeJSAdapterControlsType2; +})(StandaloneThreeJSAdapterControlsType || {}); +var StandaloneThreeJSAdapter = class _StandaloneThreeJSAdapter { + constructor(element, options) { + this.element = element; + this.options = options; + this.controls = null; + } + static async create(element, options) { + const adapter = new _StandaloneThreeJSAdapter(element, options); + await adapter.init(); + return adapter; + } + interactionShouldShowDistance(interaction) { + return ThreeJSInteractionAdapter.interactionShouldShowDistance( + interaction, + this.camera, + this.threeScene + ); + } + getThreeScene() { + return this.threeScene; + } + getRenderer() { + return this.renderer; + } + setCameraFOV(fov2) { + this.camera.fov = fov2; + this.camera.updateProjectionMatrix(); + } + getGraphicsAdapterFactory() { + return ThreeJSGraphicsInterface; + } + async init() { + return new Promise((resolve) => { + this.rootContainer = new Group(); + this.threeScene = new Scene(); + this.threeScene.add(this.rootContainer); + this.camera = new PerspectiveCamera( + 75, + window.innerWidth / window.innerHeight, + 0.01, + 1e3 + ); + this.clickTrigger = ThreeJSClickTrigger.init(this.element, this.rootContainer, this.camera); + this.renderer = this.createRenderer(); + this.audioListener = new AudioListener(); + if (this.audioListener.context.state === "suspended") { + const resumeAudio = () => { + this.audioListener.context.resume(); + document.removeEventListener("click", resumeAudio); + document.removeEventListener("touchstart", resumeAudio); + }; + document.addEventListener("click", resumeAudio); + document.addEventListener("touchstart", resumeAudio); + } + this.camera.add(this.audioListener); + this.camera.position.z = 10; + this.camera.position.y = 5; + Cache.enabled = true; + this.setControlsType(this.options.controlsType); + const clock = new Clock(); + this.animationFrameCallback = () => { + this.animationFrameRequest = requestAnimationFrame(this.animationFrameCallback); + if (this.controls) { + this.controls.update(clock.getDelta()); + } + this.renderer.render(this.threeScene, this.camera); + }; + this.element.appendChild(this.renderer.domElement); + resolve(); + }); + } + setControlsType(type) { + if (this.controls) { + this.controls.dispose(); + this.controls = null; + } + switch (type) { + case 0: + break; + case 2: + this.controls = new ThreeJSOrbitCameraControls(this.camera, this.element); + break; + case 1: + default: + this.controls = new ThreeJSDragFlyCameraControls(this.camera, this.element); + break; + } + if (this.controls) { + this.controls.enable(); + } + } + createRenderer() { + let renderer; + if (navigator.userAgent.includes("jsdom")) { + renderer = { + domElement: document.createElement("canvas"), + setSize: () => void 0, + render: () => void 0 + }; + } else { + renderer = new WebGLRenderer({ antialias: true, alpha: true }); + renderer.setPixelRatio(window.devicePixelRatio); + renderer.outputColorSpace = SRGBColorSpace; + renderer.shadowMap.enabled = true; + renderer.shadowMap.type = PCFSoftShadowMap; + } + renderer.domElement.style.pointerEvents = "none"; + return renderer; + } + start() { + this.animationFrameRequest = requestAnimationFrame(this.animationFrameCallback); + } + getUserPositionAndRotation() { + const position = this.camera.position; + const rotation = this.camera.rotation; + return { + position: { + x: position.x, + y: position.y, + z: position.z + }, + rotation: { + x: radToDeg(rotation.x), + y: radToDeg(rotation.y), + z: radToDeg(rotation.z) + } + }; + } + getAudioListener() { + return this.audioListener; + } + resize(width, height) { + this.camera.aspect = width / height; + this.camera.updateProjectionMatrix(); + this.renderer.setSize(width, height); + } + dispose() { + this.clickTrigger.dispose(); + if (this.controls) { + this.controls.dispose(); + this.controls = null; + } + cancelAnimationFrame(this.animationFrameRequest); + } + getRootContainer() { + return this.rootContainer; + } + getCamera() { + return this.camera; + } + getBoundingBoxForElement(element) { + const camera = this.camera; + const renderer = this.renderer; + if (!(element instanceof MElement)) { + return null; + } + const object = element.getContainer(); + const box3 = new Box3().setFromObject(object); + const toCanvasCoords = (point) => { + const vec = point.clone().project(camera); + vec.x = (vec.x + 1) / 2 * renderer.domElement.clientWidth; + vec.y = (-vec.y + 1) / 2 * renderer.domElement.clientHeight; + return vec; + }; + const corners3D = [ + new Vector3(box3.min.x, box3.min.y, box3.min.z), + new Vector3(box3.max.x, box3.min.y, box3.min.z), + new Vector3(box3.max.x, box3.min.y, box3.max.z), + new Vector3(box3.min.x, box3.min.y, box3.max.z), + new Vector3(box3.min.x, box3.max.y, box3.min.z), + new Vector3(box3.max.x, box3.max.y, box3.min.z), + new Vector3(box3.max.x, box3.max.y, box3.max.z), + new Vector3(box3.min.x, box3.max.y, box3.max.z) + ]; + const corners2D = corners3D.map(toCanvasCoords); + const minX = Math.min(...corners2D.map((corner) => corner.x)); + const maxX = Math.max(...corners2D.map((corner) => corner.x)); + const minY = Math.min(...corners2D.map((corner) => corner.y)); + const maxY = Math.max(...corners2D.map((corner) => corner.y)); + return { + x: minX, + y: minY, + width: maxX - minX, + height: maxY - minY + }; + } +}; + +// ../../node_modules/@monogrid/gainmap-js/dist/QuadRenderer-B3h-sJtp.js +var getBufferForType = (type, width, height) => { + let out; + switch (type) { + case UnsignedByteType: + out = new Uint8ClampedArray(width * height * 4); + break; + case HalfFloatType: + out = new Uint16Array(width * height * 4); + break; + case UnsignedIntType: + out = new Uint32Array(width * height * 4); + break; + case ByteType: + out = new Int8Array(width * height * 4); + break; + case ShortType: + out = new Int16Array(width * height * 4); + break; + case IntType: + out = new Int32Array(width * height * 4); + break; + case FloatType: + out = new Float32Array(width * height * 4); + break; + default: + throw new Error("Unsupported data type"); + } + return out; +}; +var _canReadPixelsResult; +var canReadPixels = (type, renderer, camera, renderTargetOptions) => { + if (_canReadPixelsResult !== void 0) + return _canReadPixelsResult; + const testRT = new WebGLRenderTarget(1, 1, renderTargetOptions); + renderer.setRenderTarget(testRT); + const mesh = new Mesh(new PlaneGeometry(), new MeshBasicMaterial({ color: 16777215 })); + renderer.render(mesh, camera); + renderer.setRenderTarget(null); + const out = getBufferForType(type, testRT.width, testRT.height); + renderer.readRenderTargetPixels(testRT, 0, 0, testRT.width, testRT.height, out); + testRT.dispose(); + mesh.geometry.dispose(); + mesh.material.dispose(); + _canReadPixelsResult = out[0] !== 0; + return _canReadPixelsResult; +}; +var QuadRenderer = class _QuadRenderer { + /** + * Constructs a new QuadRenderer + * + * @param options Parameters for this QuadRenderer + */ + constructor(options) { + var _a2, _b2, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q2, _r; + this._rendererIsDisposable = false; + this._supportsReadPixels = true; + this.render = () => { + this._renderer.setRenderTarget(this._renderTarget); + try { + this._renderer.render(this._scene, this._camera); + } catch (e) { + this._renderer.setRenderTarget(null); + throw e; + } + this._renderer.setRenderTarget(null); + }; + this._width = options.width; + this._height = options.height; + this._type = options.type; + this._colorSpace = options.colorSpace; + const rtOptions = { + // fixed options + format: RGBAFormat, + depthBuffer: false, + stencilBuffer: false, + // user options + type: this._type, + // set in class property + colorSpace: this._colorSpace, + // set in class property + anisotropy: ((_a2 = options.renderTargetOptions) === null || _a2 === void 0 ? void 0 : _a2.anisotropy) !== void 0 ? (_b2 = options.renderTargetOptions) === null || _b2 === void 0 ? void 0 : _b2.anisotropy : 1, + generateMipmaps: ((_c = options.renderTargetOptions) === null || _c === void 0 ? void 0 : _c.generateMipmaps) !== void 0 ? (_d = options.renderTargetOptions) === null || _d === void 0 ? void 0 : _d.generateMipmaps : false, + magFilter: ((_e = options.renderTargetOptions) === null || _e === void 0 ? void 0 : _e.magFilter) !== void 0 ? (_f = options.renderTargetOptions) === null || _f === void 0 ? void 0 : _f.magFilter : LinearFilter, + minFilter: ((_g = options.renderTargetOptions) === null || _g === void 0 ? void 0 : _g.minFilter) !== void 0 ? (_h = options.renderTargetOptions) === null || _h === void 0 ? void 0 : _h.minFilter : LinearFilter, + samples: ((_j = options.renderTargetOptions) === null || _j === void 0 ? void 0 : _j.samples) !== void 0 ? (_k = options.renderTargetOptions) === null || _k === void 0 ? void 0 : _k.samples : void 0, + wrapS: ((_l = options.renderTargetOptions) === null || _l === void 0 ? void 0 : _l.wrapS) !== void 0 ? (_m = options.renderTargetOptions) === null || _m === void 0 ? void 0 : _m.wrapS : ClampToEdgeWrapping, + wrapT: ((_o = options.renderTargetOptions) === null || _o === void 0 ? void 0 : _o.wrapT) !== void 0 ? (_p = options.renderTargetOptions) === null || _p === void 0 ? void 0 : _p.wrapT : ClampToEdgeWrapping + }; + this._material = options.material; + if (options.renderer) { + this._renderer = options.renderer; + } else { + this._renderer = _QuadRenderer.instantiateRenderer(); + this._rendererIsDisposable = true; + } + this._scene = new Scene(); + this._camera = new OrthographicCamera(); + this._camera.position.set(0, 0, 10); + this._camera.left = -0.5; + this._camera.right = 0.5; + this._camera.top = 0.5; + this._camera.bottom = -0.5; + this._camera.updateProjectionMatrix(); + if (!canReadPixels(this._type, this._renderer, this._camera, rtOptions)) { + let alternativeType; + switch (this._type) { + case HalfFloatType: + alternativeType = this._renderer.extensions.has("EXT_color_buffer_float") ? FloatType : void 0; + break; + } + if (alternativeType !== void 0) { + console.warn(`This browser does not support reading pixels from ${this._type} RenderTargets, switching to ${FloatType}`); + this._type = alternativeType; + } else { + this._supportsReadPixels = false; + console.warn("This browser dos not support toArray or toDataTexture, calls to those methods will result in an error thrown"); + } + } + this._quad = new Mesh(new PlaneGeometry(), this._material); + this._quad.geometry.computeBoundingBox(); + this._scene.add(this._quad); + this._renderTarget = new WebGLRenderTarget(this.width, this.height, rtOptions); + this._renderTarget.texture.mapping = ((_q2 = options.renderTargetOptions) === null || _q2 === void 0 ? void 0 : _q2.mapping) !== void 0 ? (_r = options.renderTargetOptions) === null || _r === void 0 ? void 0 : _r.mapping : UVMapping; + } + /** + * Instantiates a temporary renderer + * + * @returns + */ + static instantiateRenderer() { + const renderer = new WebGLRenderer(); + renderer.setSize(128, 128); + return renderer; + } + /** + * Obtains a Buffer containing the rendered texture. + * + * @throws Error if the browser cannot read pixels from this RenderTarget type. + * @returns a TypedArray containing RGBA values from this renderer + */ + toArray() { + if (!this._supportsReadPixels) + throw new Error("Can't read pixels in this browser"); + const out = getBufferForType(this._type, this._width, this._height); + this._renderer.readRenderTargetPixels(this._renderTarget, 0, 0, this._width, this._height, out); + return out; + } + /** + * Performs a readPixel operation in the renderTarget + * and returns a DataTexture containing the read data + * + * @param options options + * @returns + */ + toDataTexture(options) { + const returnValue = new DataTexture( + // fixed values + this.toArray(), + this.width, + this.height, + RGBAFormat, + this._type, + // user values + (options === null || options === void 0 ? void 0 : options.mapping) || UVMapping, + (options === null || options === void 0 ? void 0 : options.wrapS) || ClampToEdgeWrapping, + (options === null || options === void 0 ? void 0 : options.wrapT) || ClampToEdgeWrapping, + (options === null || options === void 0 ? void 0 : options.magFilter) || LinearFilter, + (options === null || options === void 0 ? void 0 : options.minFilter) || LinearFilter, + (options === null || options === void 0 ? void 0 : options.anisotropy) || 1, + // fixed value + LinearSRGBColorSpace + ); + returnValue.generateMipmaps = (options === null || options === void 0 ? void 0 : options.generateMipmaps) !== void 0 ? options === null || options === void 0 ? void 0 : options.generateMipmaps : false; + return returnValue; + } + /** + * If using a disposable renderer, it will dispose it. + */ + disposeOnDemandRenderer() { + this._renderer.setRenderTarget(null); + if (this._rendererIsDisposable) { + this._renderer.dispose(); + this._renderer.forceContextLoss(); + } + } + /** + * Will dispose of **all** assets used by this renderer. + * + * + * @param disposeRenderTarget will dispose of the renderTarget which will not be usable later + * set this to true if you passed the `renderTarget.texture` to a `PMREMGenerator` + * or are otherwise done with it. + * + * @example + * ```js + * const loader = new HDRJPGLoader(renderer) + * const result = await loader.loadAsync('gainmap.jpeg') + * const mesh = new Mesh(geometry, new MeshBasicMaterial({ map: result.renderTarget.texture }) ) + * // DO NOT dispose the renderTarget here, + * // it is used directly in the material + * result.dispose() + * ``` + * + * @example + * ```js + * const loader = new HDRJPGLoader(renderer) + * const pmremGenerator = new PMREMGenerator( renderer ); + * const result = await loader.loadAsync('gainmap.jpeg') + * const envMap = pmremGenerator.fromEquirectangular(result.renderTarget.texture) + * const mesh = new Mesh(geometry, new MeshStandardMaterial({ envMap }) ) + * // renderTarget can be disposed here + * // because it was used to generate a PMREM texture + * result.dispose(true) + * ``` + */ + dispose(disposeRenderTarget) { + this.disposeOnDemandRenderer(); + if (disposeRenderTarget) { + this.renderTarget.dispose(); + } + if (this.material instanceof ShaderMaterial) { + Object.values(this.material.uniforms).forEach((v) => { + if (v.value instanceof Texture) + v.value.dispose(); + }); + } + Object.values(this.material).forEach((value) => { + if (value instanceof Texture) + value.dispose(); + }); + this.material.dispose(); + this._quad.geometry.dispose(); + } + /** + * Width of the texture + */ + get width() { + return this._width; + } + set width(value) { + this._width = value; + this._renderTarget.setSize(this._width, this._height); + } + /** + * Height of the texture + */ + get height() { + return this._height; + } + set height(value) { + this._height = value; + this._renderTarget.setSize(this._width, this._height); + } + /** + * The renderer used + */ + get renderer() { + return this._renderer; + } + /** + * The `WebGLRenderTarget` used. + */ + get renderTarget() { + return this._renderTarget; + } + set renderTarget(value) { + this._renderTarget = value; + this._width = value.width; + this._height = value.height; + } + /** + * The `Material` used. + */ + get material() { + return this._material; + } + /** + * + */ + get type() { + return this._type; + } + get colorSpace() { + return this._colorSpace; + } +}; + +// ../../node_modules/@monogrid/gainmap-js/dist/decode.js +var vertexShader = ( + /* glsl */ + ` +varying vec2 vUv; + +void main() { + vUv = uv; + gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0); +} +` +); +var fragmentShader = ( + /* glsl */ + ` +// min half float value +#define HALF_FLOAT_MIN vec3( -65504, -65504, -65504 ) +// max half float value +#define HALF_FLOAT_MAX vec3( 65504, 65504, 65504 ) + +uniform sampler2D sdr; +uniform sampler2D gainMap; +uniform vec3 gamma; +uniform vec3 offsetHdr; +uniform vec3 offsetSdr; +uniform vec3 gainMapMin; +uniform vec3 gainMapMax; +uniform float weightFactor; + +varying vec2 vUv; + +void main() { + vec3 rgb = texture2D( sdr, vUv ).rgb; + vec3 recovery = texture2D( gainMap, vUv ).rgb; + vec3 logRecovery = pow( recovery, gamma ); + vec3 logBoost = gainMapMin * ( 1.0 - logRecovery ) + gainMapMax * logRecovery; + vec3 hdrColor = (rgb + offsetSdr) * exp2( logBoost * weightFactor ) - offsetHdr; + vec3 clampedHdrColor = max( HALF_FLOAT_MIN, min( HALF_FLOAT_MAX, hdrColor )); + gl_FragColor = vec4( clampedHdrColor , 1.0 ); +} +` +); +var GainMapDecoderMaterial = class extends ShaderMaterial { + /** + * + * @param params + */ + constructor({ gamma, offsetHdr, offsetSdr, gainMapMin, gainMapMax, maxDisplayBoost, hdrCapacityMin, hdrCapacityMax, sdr, gainMap }) { + super({ + name: "GainMapDecoderMaterial", + vertexShader, + fragmentShader, + uniforms: { + sdr: { value: sdr }, + gainMap: { value: gainMap }, + gamma: { value: new Vector3(1 / gamma[0], 1 / gamma[1], 1 / gamma[2]) }, + offsetHdr: { value: new Vector3().fromArray(offsetHdr) }, + offsetSdr: { value: new Vector3().fromArray(offsetSdr) }, + gainMapMin: { value: new Vector3().fromArray(gainMapMin) }, + gainMapMax: { value: new Vector3().fromArray(gainMapMax) }, + weightFactor: { + value: (Math.log2(maxDisplayBoost) - hdrCapacityMin) / (hdrCapacityMax - hdrCapacityMin) + } + }, + blending: NoBlending, + depthTest: false, + depthWrite: false + }); + this._maxDisplayBoost = maxDisplayBoost; + this._hdrCapacityMin = hdrCapacityMin; + this._hdrCapacityMax = hdrCapacityMax; + this.needsUpdate = true; + this.uniformsNeedUpdate = true; + } + get sdr() { + return this.uniforms.sdr.value; + } + set sdr(value) { + this.uniforms.sdr.value = value; + } + get gainMap() { + return this.uniforms.gainMap.value; + } + set gainMap(value) { + this.uniforms.gainMap.value = value; + } + /** + * @see {@link GainMapMetadata.offsetHdr} + */ + get offsetHdr() { + return this.uniforms.offsetHdr.value.toArray(); + } + set offsetHdr(value) { + this.uniforms.offsetHdr.value.fromArray(value); + } + /** + * @see {@link GainMapMetadata.offsetSdr} + */ + get offsetSdr() { + return this.uniforms.offsetSdr.value.toArray(); + } + set offsetSdr(value) { + this.uniforms.offsetSdr.value.fromArray(value); + } + /** + * @see {@link GainMapMetadata.gainMapMin} + */ + get gainMapMin() { + return this.uniforms.gainMapMin.value.toArray(); + } + set gainMapMin(value) { + this.uniforms.gainMapMin.value.fromArray(value); + } + /** + * @see {@link GainMapMetadata.gainMapMax} + */ + get gainMapMax() { + return this.uniforms.gainMapMax.value.toArray(); + } + set gainMapMax(value) { + this.uniforms.gainMapMax.value.fromArray(value); + } + /** + * @see {@link GainMapMetadata.gamma} + */ + get gamma() { + const g = this.uniforms.gamma.value; + return [1 / g.x, 1 / g.y, 1 / g.z]; + } + set gamma(value) { + const g = this.uniforms.gamma.value; + g.x = 1 / value[0]; + g.y = 1 / value[1]; + g.z = 1 / value[2]; + } + /** + * @see {@link GainMapMetadata.hdrCapacityMin} + * @remarks Logarithmic space + */ + get hdrCapacityMin() { + return this._hdrCapacityMin; + } + set hdrCapacityMin(value) { + this._hdrCapacityMin = value; + this.calculateWeight(); + } + /** + * @see {@link GainMapMetadata.hdrCapacityMin} + * @remarks Logarithmic space + */ + get hdrCapacityMax() { + return this._hdrCapacityMax; + } + set hdrCapacityMax(value) { + this._hdrCapacityMax = value; + this.calculateWeight(); + } + /** + * @see {@link GainmapDecodingParameters.maxDisplayBoost} + * @remarks Non Logarithmic space + */ + get maxDisplayBoost() { + return this._maxDisplayBoost; + } + set maxDisplayBoost(value) { + this._maxDisplayBoost = Math.max(1, Math.min(65504, value)); + this.calculateWeight(); + } + calculateWeight() { + const val = (Math.log2(this._maxDisplayBoost) - this._hdrCapacityMin) / (this._hdrCapacityMax - this._hdrCapacityMin); + this.uniforms.weightFactor.value = Math.max(0, Math.min(1, val)); + } +}; +var GainMapNotFoundError = class extends Error { +}; +var XMPMetadataNotFoundError = class extends Error { +}; +var getAttribute = (description, name, defaultValue) => { + var _a2; + let returnValue; + const parsedValue = (_a2 = description.attributes.getNamedItem(name)) === null || _a2 === void 0 ? void 0 : _a2.nodeValue; + if (!parsedValue) { + const node = description.getElementsByTagName(name)[0]; + if (node) { + const values = node.getElementsByTagName("rdf:li"); + if (values.length === 3) { + returnValue = Array.from(values).map((v) => v.innerHTML); + } else { + throw new Error(`Gainmap metadata contains an array of items for ${name} but its length is not 3`); + } + } else { + if (defaultValue) + return defaultValue; + else + throw new Error(`Can't find ${name} in gainmap metadata`); + } + } else { + returnValue = parsedValue; + } + return returnValue; +}; +var extractXMP = (input) => { + var _a2, _b2; + let str; + if (typeof TextDecoder !== "undefined") + str = new TextDecoder().decode(input); + else + str = input.toString(); + let start = str.indexOf("", start); + str.slice(start, end + 10); + const xmpBlock = str.slice(start, end + 10); + try { + const xmlDocument = parser.parseFromString(xmpBlock, "text/xml"); + const description = xmlDocument.getElementsByTagName("rdf:Description")[0]; + const gainMapMin = getAttribute(description, "hdrgm:GainMapMin", "0"); + const gainMapMax = getAttribute(description, "hdrgm:GainMapMax"); + const gamma = getAttribute(description, "hdrgm:Gamma", "1"); + const offsetSDR = getAttribute(description, "hdrgm:OffsetSDR", "0.015625"); + const offsetHDR = getAttribute(description, "hdrgm:OffsetHDR", "0.015625"); + let hdrCapacityMin = (_a2 = description.attributes.getNamedItem("hdrgm:HDRCapacityMin")) === null || _a2 === void 0 ? void 0 : _a2.nodeValue; + if (!hdrCapacityMin) + hdrCapacityMin = "0"; + const hdrCapacityMax = (_b2 = description.attributes.getNamedItem("hdrgm:HDRCapacityMax")) === null || _b2 === void 0 ? void 0 : _b2.nodeValue; + if (!hdrCapacityMax) + throw new Error("Incomplete gainmap metadata"); + return { + gainMapMin: Array.isArray(gainMapMin) ? gainMapMin.map((v) => parseFloat(v)) : [parseFloat(gainMapMin), parseFloat(gainMapMin), parseFloat(gainMapMin)], + gainMapMax: Array.isArray(gainMapMax) ? gainMapMax.map((v) => parseFloat(v)) : [parseFloat(gainMapMax), parseFloat(gainMapMax), parseFloat(gainMapMax)], + gamma: Array.isArray(gamma) ? gamma.map((v) => parseFloat(v)) : [parseFloat(gamma), parseFloat(gamma), parseFloat(gamma)], + offsetSdr: Array.isArray(offsetSDR) ? offsetSDR.map((v) => parseFloat(v)) : [parseFloat(offsetSDR), parseFloat(offsetSDR), parseFloat(offsetSDR)], + offsetHdr: Array.isArray(offsetHDR) ? offsetHDR.map((v) => parseFloat(v)) : [parseFloat(offsetHDR), parseFloat(offsetHDR), parseFloat(offsetHDR)], + hdrCapacityMin: parseFloat(hdrCapacityMin), + hdrCapacityMax: parseFloat(hdrCapacityMax) + }; + } catch (e) { + } + start = str.indexOf(" { + const debug = this.options.debug; + const dataView = new DataView(imageArrayBuffer.buffer); + if (dataView.getUint16(0) !== 65496) { + reject(new Error("Not a valid jpeg")); + return; + } + const length = dataView.byteLength; + let offset = 2; + let loops = 0; + let marker; + while (offset < length) { + if (++loops > 250) { + reject(new Error(`Found no marker after ${loops} loops \u{1F635}`)); + return; + } + if (dataView.getUint8(offset) !== 255) { + reject(new Error(`Not a valid marker at offset 0x${offset.toString(16)}, found: 0x${dataView.getUint8(offset).toString(16)}`)); + return; + } + marker = dataView.getUint8(offset + 1); + if (debug) + console.log(`Marker: ${marker.toString(16)}`); + if (marker === 226) { + if (debug) + console.log("Found APP2 marker (0xffe2)"); + const formatPt = offset + 4; + if (dataView.getUint32(formatPt) === 1297106432) { + const tiffOffset = formatPt + 4; + let bigEnd; + if (dataView.getUint16(tiffOffset) === 18761) { + bigEnd = false; + } else if (dataView.getUint16(tiffOffset) === 19789) { + bigEnd = true; + } else { + reject(new Error("No valid endianness marker found in TIFF header")); + return; + } + if (dataView.getUint16(tiffOffset + 2, !bigEnd) !== 42) { + reject(new Error("Not valid TIFF data! (no 0x002A marker)")); + return; + } + const firstIFDOffset = dataView.getUint32(tiffOffset + 4, !bigEnd); + if (firstIFDOffset < 8) { + reject(new Error("Not valid TIFF data! (First offset less than 8)")); + return; + } + const dirStart = tiffOffset + firstIFDOffset; + const count = dataView.getUint16(dirStart, !bigEnd); + const entriesStart = dirStart + 2; + let numberOfImages = 0; + for (let i = entriesStart; i < entriesStart + 12 * count; i += 12) { + if (dataView.getUint16(i, !bigEnd) === 45057) { + numberOfImages = dataView.getUint32(i + 8, !bigEnd); + } + } + const nextIFDOffsetLen = 4; + const MPImageListValPt = dirStart + 2 + count * 12 + nextIFDOffsetLen; + const images = []; + for (let i = MPImageListValPt; i < MPImageListValPt + numberOfImages * 16; i += 16) { + const image = { + MPType: dataView.getUint32(i, !bigEnd), + size: dataView.getUint32(i + 4, !bigEnd), + // This offset is specified relative to the address of the MP Endian + // field in the MP Header, unless the image is a First Individual Image, + // in which case the value of the offset shall be NULL (0x00000000). + dataOffset: dataView.getUint32(i + 8, !bigEnd), + dependantImages: dataView.getUint32(i + 12, !bigEnd), + start: -1, + end: -1, + isFII: false + }; + if (!image.dataOffset) { + image.start = 0; + image.isFII = true; + } else { + image.start = tiffOffset + image.dataOffset; + image.isFII = false; + } + image.end = image.start + image.size; + images.push(image); + } + if (this.options.extractNonFII && images.length) { + const bufferBlob = new Blob([dataView]); + const imgs = []; + for (const image of images) { + if (image.isFII && !this.options.extractFII) { + continue; + } + const imageBlob = bufferBlob.slice(image.start, image.end + 1, "image/jpeg"); + imgs.push(imageBlob); + } + resolve(imgs); + } + } + } + offset += 2 + dataView.getUint16(offset + 2); + } + }); + } +}; +var extractGainmapFromJPEG = async (jpegFile) => { + const metadata = extractXMP(jpegFile); + if (!metadata) + throw new XMPMetadataNotFoundError("Gain map XMP metadata not found"); + const mpfExtractor = new MPFExtractor({ extractFII: true, extractNonFII: true }); + const images = await mpfExtractor.extract(jpegFile); + if (images.length !== 2) + throw new GainMapNotFoundError("Gain map recovery image not found"); + return { + sdr: new Uint8Array(await images[0].arrayBuffer()), + gainMap: new Uint8Array(await images[1].arrayBuffer()), + metadata + }; +}; +var getHTMLImageFromBlob = (blob) => { + return new Promise((resolve, reject) => { + const img = document.createElement("img"); + img.onload = () => { + resolve(img); + }; + img.onerror = (e) => { + reject(e); + }; + img.src = URL.createObjectURL(blob); + }); +}; +var LoaderBase = class extends Loader { + /** + * + * @param renderer + * @param manager + */ + constructor(renderer, manager) { + super(manager); + if (renderer) + this._renderer = renderer; + this._internalLoadingManager = new LoadingManager(); + } + /** + * Specify the renderer to use when rendering the gain map + * + * @param renderer + * @returns + */ + setRenderer(renderer) { + this._renderer = renderer; + return this; + } + /** + * Specify the renderTarget options to use when rendering the gain map + * + * @param options + * @returns + */ + setRenderTargetOptions(options) { + this._renderTargetOptions = options; + return this; + } + /** + * @private + * @returns + */ + prepareQuadRenderer() { + if (!this._renderer) + console.warn("WARNING: An existing WebGL Renderer was not passed to this Loader constructor or in setRenderer, the result of this Loader will need to be converted to a Data Texture with toDataTexture() before you can use it in your renderer."); + const material = new GainMapDecoderMaterial({ + gainMapMax: [1, 1, 1], + gainMapMin: [0, 0, 0], + gamma: [1, 1, 1], + offsetHdr: [1, 1, 1], + offsetSdr: [1, 1, 1], + hdrCapacityMax: 1, + hdrCapacityMin: 0, + maxDisplayBoost: 1, + gainMap: new Texture(), + sdr: new Texture() + }); + return new QuadRenderer({ + width: 16, + height: 16, + type: HalfFloatType, + colorSpace: LinearSRGBColorSpace, + material, + renderer: this._renderer, + renderTargetOptions: this._renderTargetOptions + }); + } + /** + * @private + * @param quadRenderer + * @param metadata + * @param sdrBuffer + * @param gainMapBuffer + */ + async render(quadRenderer, metadata, sdrBuffer, gainMapBuffer) { + const gainMapBlob = gainMapBuffer ? new Blob([gainMapBuffer], { type: "image/jpeg" }) : void 0; + const sdrBlob = new Blob([sdrBuffer], { type: "image/jpeg" }); + let sdrImage; + let gainMapImage; + let needsFlip = false; + if (typeof createImageBitmap === "undefined") { + const res = await Promise.all([ + gainMapBlob ? getHTMLImageFromBlob(gainMapBlob) : Promise.resolve(void 0), + getHTMLImageFromBlob(sdrBlob) + ]); + gainMapImage = res[0]; + sdrImage = res[1]; + needsFlip = true; + } else { + const res = await Promise.all([ + gainMapBlob ? createImageBitmap(gainMapBlob, { imageOrientation: "flipY" }) : Promise.resolve(void 0), + createImageBitmap(sdrBlob, { imageOrientation: "flipY" }) + ]); + gainMapImage = res[0]; + sdrImage = res[1]; + } + const gainMap = new Texture(gainMapImage || new ImageData(2, 2), UVMapping, ClampToEdgeWrapping, ClampToEdgeWrapping, LinearFilter, LinearMipMapLinearFilter, RGBAFormat, UnsignedByteType, 1, LinearSRGBColorSpace); + gainMap.flipY = needsFlip; + gainMap.needsUpdate = true; + const sdr = new Texture(sdrImage, UVMapping, ClampToEdgeWrapping, ClampToEdgeWrapping, LinearFilter, LinearMipMapLinearFilter, RGBAFormat, UnsignedByteType, 1, SRGBColorSpace); + sdr.flipY = needsFlip; + sdr.needsUpdate = true; + quadRenderer.width = sdrImage.width; + quadRenderer.height = sdrImage.height; + quadRenderer.material.gainMap = gainMap; + quadRenderer.material.sdr = sdr; + quadRenderer.material.gainMapMin = metadata.gainMapMin; + quadRenderer.material.gainMapMax = metadata.gainMapMax; + quadRenderer.material.offsetHdr = metadata.offsetHdr; + quadRenderer.material.offsetSdr = metadata.offsetSdr; + quadRenderer.material.gamma = metadata.gamma; + quadRenderer.material.hdrCapacityMin = metadata.hdrCapacityMin; + quadRenderer.material.hdrCapacityMax = metadata.hdrCapacityMax; + quadRenderer.material.maxDisplayBoost = Math.pow(2, metadata.hdrCapacityMax); + quadRenderer.material.needsUpdate = true; + quadRenderer.render(); + } +}; +var HDRJPGLoader = class extends LoaderBase { + /** + * Loads a JPEG containing gain map metadata + * Renders a normal SDR image if gainmap data is not found + * + * @param url An array in the form of [sdr.jpg, gainmap.jpg, metadata.json] + * @param onLoad Load complete callback, will receive the result + * @param onProgress Progress callback, will receive a {@link ProgressEvent} + * @param onError Error callback + * @returns + */ + load(url, onLoad, onProgress, onError) { + const quadRenderer = this.prepareQuadRenderer(); + const loader = new FileLoader(this._internalLoadingManager); + loader.setResponseType("arraybuffer"); + loader.setRequestHeader(this.requestHeader); + loader.setPath(this.path); + loader.setWithCredentials(this.withCredentials); + this.manager.itemStart(url); + loader.load(url, async (jpeg) => { + if (typeof jpeg === "string") + throw new Error("Invalid buffer, received [string], was expecting [ArrayBuffer]"); + const jpegBuffer = new Uint8Array(jpeg); + let sdrJPEG; + let gainMapJPEG; + let metadata; + try { + const extractionResult = await extractGainmapFromJPEG(jpegBuffer); + sdrJPEG = extractionResult.sdr; + gainMapJPEG = extractionResult.gainMap; + metadata = extractionResult.metadata; + } catch (e) { + if (e instanceof XMPMetadataNotFoundError || e instanceof GainMapNotFoundError) { + console.warn(`Failure to reconstruct an HDR image from ${url}: Gain map metadata not found in the file, HDRJPGLoader will render the SDR jpeg`); + metadata = { + gainMapMin: [0, 0, 0], + gainMapMax: [1, 1, 1], + gamma: [1, 1, 1], + hdrCapacityMin: 0, + hdrCapacityMax: 1, + offsetHdr: [0, 0, 0], + offsetSdr: [0, 0, 0] + }; + sdrJPEG = jpegBuffer; + } else { + throw e; + } + } + try { + await this.render(quadRenderer, metadata, sdrJPEG, gainMapJPEG); + } catch (error) { + this.manager.itemError(url); + if (typeof onError === "function") + onError(error); + quadRenderer.disposeOnDemandRenderer(); + return; + } + if (typeof onLoad === "function") + onLoad(quadRenderer); + this.manager.itemEnd(url); + quadRenderer.disposeOnDemandRenderer(); + }, onProgress, (error) => { + this.manager.itemError(url); + if (typeof onError === "function") + onError(error); + }); + return quadRenderer; + } +}; + +// src/ThreeJSModeInternal.ts +var ThreeJSModeInternal = class { + constructor(windowTarget, targetForWrappers, mmlSourceDefinition, formIteration) { + this.windowTarget = windowTarget; + this.targetForWrappers = targetForWrappers; + this.mmlSourceDefinition = mmlSourceDefinition; + this.formIteration = formIteration; + this.disposed = false; + this.loadedState = null; + this.ambientLight = null; + this.type = "three"; + this.environmentMap = null; + this.init(); + } + async init() { + const fullScreenMMLScene = new FullScreenMMLScene(); + document.body.append(fullScreenMMLScene.element); + const graphicsAdapter = await StandaloneThreeJSAdapter.create(fullScreenMMLScene.element, { + controlsType: StandaloneThreeJSAdapterControlsType.DragFly + }); + if (this.disposed) { + graphicsAdapter.dispose(); + return; + } + fullScreenMMLScene.init(graphicsAdapter); + const statusUI = new StatusUI(); + const mmlNetworkSource = MMLNetworkSource.create({ + mmlScene: fullScreenMMLScene, + statusUpdated: (status) => { + if (status === NetworkedDOMWebsocketStatus.Connected) { + statusUI.setNoStatus(); + } else { + statusUI.setStatus(NetworkedDOMWebsocketStatusToString(status)); + } + }, + url: this.mmlSourceDefinition.url, + windowTarget: this.windowTarget, + targetForWrappers: this.targetForWrappers + }); + setDebugGlobals({ + mmlScene: fullScreenMMLScene, + remoteDocumentWrapper: mmlNetworkSource.remoteDocumentWrapper + }); + const loadingCallback = () => { + const [, completedLoading] = fullScreenMMLScene.getLoadingProgressManager().toRatio(); + if (completedLoading) { + fullScreenMMLScene.getLoadingProgressManager().removeProgressCallback(loadingCallback); + const fitContent = this.formIteration.getFieldValue(cameraFitContents); + if (fitContent === "true") { + graphicsAdapter.controls?.fitContent(calculateContentBounds(this.targetForWrappers)); + } + } + }; + fullScreenMMLScene.getLoadingProgressManager().addProgressCallback(loadingCallback); + this.loadedState = { + mmlNetworkSource, + graphicsAdapter, + fullScreenMMLScene, + statusUI + }; + this.update(this.formIteration); + } + update(formIteration) { + this.formIteration = formIteration; + if (!this.loadedState) { + return; + } + const graphicsAdapter = this.loadedState.graphicsAdapter; + const threeScene = graphicsAdapter.getThreeScene(); + const threeRenderer = graphicsAdapter.getRenderer(); + this.setBackgroundColor(formIteration, threeRenderer); + this.setAmbientLight(formIteration, threeScene); + this.setAmbientLightColor(formIteration); + this.setEnvironmentMap(formIteration, threeRenderer, threeScene); + this.setCameraMode(formIteration, graphicsAdapter); + formIteration.completed(); + } + setEnvironmentMap(formIteration, threeRenderer, threeScene) { + let environmentMap = formIteration.getFieldValue(environmentMapField); + const foundEnvMap = envMaps[environmentMap]; + if (foundEnvMap) { + environmentMap = foundEnvMap.url; + } + if (!environmentMap) { + threeScene.environment = null; + threeScene.background = null; + this.environmentMap = null; + return; + } + if (environmentMap === this.environmentMap) { + return; + } + const pmremGenerator = new PMREMGenerator(threeRenderer); + const loader = new HDRJPGLoader(threeRenderer); + loader.loadAsync(environmentMap).then((result) => { + const hdrJpg = result.renderTarget.texture; + hdrJpg.mapping = EquirectangularReflectionMapping; + const envMap = pmremGenerator.fromEquirectangular(hdrJpg).texture; + threeScene.backgroundIntensity = 1; + threeScene.backgroundBlurriness = 0; + threeScene.backgroundRotation = new Euler(0, -Math.PI / 2, 0); + threeScene.background = envMap; + threeScene.environment = envMap; + result.dispose(); + }); + } + setAmbientLightColor(formIteration) { + const ambientLightColorString = formIteration.getFieldValue(ambientLightColorField); + const color = parseColorAttribute(ambientLightColorString, { + r: 1, + g: 1, + b: 1 + }); + if (this.ambientLight) { + this.ambientLight.color.setRGB(color.r, color.g, color.b); + } + } + setAmbientLight(formIteration, threeScene) { + const ambientLightIntensityString = formIteration.getFieldValue(ambientLightField); + let ambientLightIntensity = parseFloat(ambientLightIntensityString); + if (isNaN(ambientLightIntensity)) { + ambientLightIntensity = 0; + } + if (ambientLightIntensity < 0) { + ambientLightIntensity = 0; + } + if (this.ambientLight && ambientLightIntensity <= 0) { + this.ambientLight.removeFromParent(); + this.ambientLight = null; + } + if (!this.ambientLight && ambientLightIntensity > 0) { + this.ambientLight = new AmbientLight(16777215, ambientLightIntensity); + threeScene.add(this.ambientLight); + } else if (this.ambientLight) { + this.ambientLight.intensity = ambientLightIntensity; + } + } + setBackgroundColor(formIteration, threeRenderer) { + const backgroundColorString = formIteration.getFieldValue(backgroundColorField); + const color = parseColorAttribute(backgroundColorString, { + r: 1, + g: 1, + b: 1, + a: 0 + }); + threeRenderer.setClearColor(new Color(color.r, color.g, color.b), color.a); + } + dispose() { + this.disposed = true; + if (this.loadedState) { + this.loadedState.mmlNetworkSource.dispose(); + this.loadedState.graphicsAdapter.dispose(); + this.loadedState.fullScreenMMLScene.dispose(); + this.loadedState.statusUI.dispose(); + this.loadedState = null; + } + } + setCameraMode(formIteration, graphicsAdapter) { + let cameraFOV = parseFloat(formIteration.getFieldValue(cameraFovField)); + if (isNaN(cameraFOV)) { + cameraFOV = 75; + } + graphicsAdapter.setCameraFOV(cameraFOV); + const cameraMode = formIteration.getFieldValue(cameraModeField); + if (cameraMode === "orbit") { + if (graphicsAdapter.controls?.type !== "orbit") { + graphicsAdapter.setControlsType(StandaloneThreeJSAdapterControlsType.Orbit); + } + const controls = graphicsAdapter.controls; + let orbitSpeed = parseFloat(formIteration.getFieldValue(cameraOrbitSpeedField)); + if (isNaN(orbitSpeed)) { + orbitSpeed = 0; + } + controls.setDegreesPerSecond(orbitSpeed); + let orbitPitch = parseFloat(formIteration.getFieldValue(cameraOrbitPitchField)); + if (isNaN(orbitPitch)) { + orbitPitch = 0; + } + controls.setPitchDegrees(orbitPitch); + const fitContent = formIteration.getFieldValue(cameraFitContents); + if (fitContent === "true") { + controls.fitContent(calculateContentBounds(this.targetForWrappers)); + } else { + const lookAt = parseXYZ(formIteration.getFieldValue(cameraLookAtField)); + controls.setLookAt(lookAt[0], lookAt[1], lookAt[2]); + let orbitDistance = parseFloat(formIteration.getFieldValue(cameraOrbitDistanceField)); + if (isNaN(orbitDistance)) { + orbitDistance = 1; + } + controls.setDistance(orbitDistance); + } + } else if (cameraMode === "drag-fly") { + if (graphicsAdapter.controls?.type !== "drag-fly") { + graphicsAdapter.setControlsType(StandaloneThreeJSAdapterControlsType.DragFly); + } + const controls = graphicsAdapter.controls; + const cameraPosition = parseXYZ(formIteration.getFieldValue(cameraPositionField)); + controls.setCameraPosition(cameraPosition[0], cameraPosition[1], cameraPosition[2]); + const lookAt = parseXYZ(formIteration.getFieldValue(cameraLookAtField)); + controls.setLookAt(lookAt[0], lookAt[1], lookAt[2]); + const fitContent = formIteration.getFieldValue(cameraFitContents); + if (fitContent === "true") { + controls.fitContent(calculateContentBounds(this.targetForWrappers)); + } + } else if (cameraMode === "none" && graphicsAdapter.controls !== null) { + graphicsAdapter.setControlsType(StandaloneThreeJSAdapterControlsType.None); + } + } +}; +export { + ThreeJSModeInternal +}; +/*! Bundled license information: + +three/build/three.module.js: + (** + * @license + * Copyright 2010-2023 Three.js Authors + * SPDX-License-Identifier: MIT + *) + +three/examples/jsm/libs/fflate.module.js: + (*! + fflate - fast JavaScript compression/decompression + + Licensed under MIT. https://github.com/101arrowz/fflate/blob/master/LICENSE + version 0.8.2 + *) +*/ +//# sourceMappingURL=ThreeJSModeInternal-OES4PZ5X.js.map diff --git a/pull/212/v1/ThreeJSModeInternal-OES4PZ5X.js.map b/pull/212/v1/ThreeJSModeInternal-OES4PZ5X.js.map new file mode 100644 index 00000000..01638d41 --- /dev/null +++ b/pull/212/v1/ThreeJSModeInternal-OES4PZ5X.js.map @@ -0,0 +1,7 @@ +{ + "version": 3, + "sources": ["../../../node_modules/three/build/three.module.js", "../../../node_modules/three/examples/jsm/helpers/PositionalAudioHelper.js", "../../../node_modules/three/examples/jsm/loaders/DRACOLoader.js", "../../../node_modules/three/examples/jsm/libs/meshopt_decoder.module.js", "../../../node_modules/three/examples/jsm/libs/fflate.module.js", "../../../node_modules/three/examples/jsm/curves/NURBSUtils.js", "../../../node_modules/three/examples/jsm/curves/NURBSCurve.js", "../../../node_modules/three/examples/jsm/loaders/FBXLoader.js", "../../../node_modules/three/examples/jsm/utils/BufferGeometryUtils.js", "../../../node_modules/three/examples/jsm/loaders/GLTFLoader.js", "../../../node_modules/@mml-io/model-loader/build/base64:/home/runner/work/mml/mml/node_modules/three/examples/jsm/libs/draco/gltf/draco_decoder.wasm", "../../../node_modules/@mml-io/model-loader/build/base64:/home/runner/work/mml/mml/node_modules/three/examples/jsm/libs/draco/gltf/draco_wasm_wrapper.js", "../../../node_modules/@mml-io/model-loader/src/ModelLoader.ts", "../../../node_modules/@mml-io/mml-web-threejs/src/elements/ThreeJSAudio.ts", "../../../node_modules/@mml-io/mml-web-threejs/src/elements/ThreeJSChatProbe.ts", "../../../node_modules/@mml-io/mml-web-threejs/src/elements/ThreeJSCube.ts", "../../../node_modules/@mml-io/mml-web-threejs/src/elements/ThreeJSCylinder.ts", "../../../node_modules/@mml-io/mml-web-threejs/src/elements/ThreeJSDebugHelper.ts", "../../../node_modules/@mml-io/mml-web-threejs/src/elements/ThreeJSFrame.ts", "../../../node_modules/@mml-io/mml-web-threejs/src/elements/ThreeJSImage.ts", "../../../node_modules/@mml-io/mml-web-threejs/src/elements/ThreeJSInteraction.ts", "../../../node_modules/@mml-io/mml-web-threejs/src/elements/ThreeJSLabel.ts", "../../../node_modules/@mml-io/mml-web-threejs/src/elements/ThreeJSLight.ts", "../../../node_modules/@mml-io/mml-web-threejs/src/elements/ThreeJSLink.ts", "../../../node_modules/@mml-io/mml-web-threejs/src/elements/ThreeJSMElement.ts", "../../../node_modules/@mml-io/mml-web-threejs/src/elements/ThreeJSModel.ts", "../../../node_modules/@mml-io/mml-web-threejs/src/elements/ThreeJSPlane.ts", "../../../node_modules/@mml-io/mml-web-threejs/src/elements/ThreeJSPositionProbe.ts", "../../../node_modules/@mml-io/mml-web-threejs/src/elements/ThreeJSPrompt.ts", "../../../node_modules/@mml-io/mml-web-threejs/src/elements/ThreeJSRemoteDocument.ts", "../../../node_modules/@mml-io/mml-web-threejs/src/ThreeJSReconnectingStatus.ts", "../../../node_modules/@mml-io/mml-web-threejs/src/elements/ThreeJSSphere.ts", "../../../node_modules/@mml-io/mml-web-threejs/src/elements/ThreeJSTransformable.ts", "../../../node_modules/@mml-io/mml-web-threejs/src/elements/ThreeJSVideo.ts", "../../../node_modules/@mml-io/mml-web-threejs/src/ThreeJSClickTrigger.ts", "../../../node_modules/@mml-io/mml-web-threejs/src/ThreeJSGraphicsInterface.ts", "../../../node_modules/@mml-io/mml-web-threejs/src/ThreeJSInteractionAdapter.ts", "../../../node_modules/@mml-io/mml-web-threejs-standalone/src/controls/ThreeJSDragFlyCameraControls.ts", "../../../node_modules/@mml-io/mml-web-threejs-standalone/src/controls/ThreeJSOrbitCameraControls.ts", "../../../node_modules/@mml-io/mml-web-threejs-standalone/src/StandaloneThreeJSAdapter.ts", "../../../node_modules/@monogrid/gainmap-js/dist/QuadRenderer-B3h-sJtp.js", "../../../node_modules/@monogrid/gainmap-js/dist/decode.js", "../src/ThreeJSModeInternal.ts"], + "sourcesContent": ["/**\n * @license\n * Copyright 2010-2023 Three.js Authors\n * SPDX-License-Identifier: MIT\n */\nconst REVISION = '163';\n\nconst MOUSE = { LEFT: 0, MIDDLE: 1, RIGHT: 2, ROTATE: 0, DOLLY: 1, PAN: 2 };\nconst TOUCH = { ROTATE: 0, PAN: 1, DOLLY_PAN: 2, DOLLY_ROTATE: 3 };\nconst CullFaceNone = 0;\nconst CullFaceBack = 1;\nconst CullFaceFront = 2;\nconst CullFaceFrontBack = 3;\nconst BasicShadowMap = 0;\nconst PCFShadowMap = 1;\nconst PCFSoftShadowMap = 2;\nconst VSMShadowMap = 3;\nconst FrontSide = 0;\nconst BackSide = 1;\nconst DoubleSide = 2;\nconst NoBlending = 0;\nconst NormalBlending = 1;\nconst AdditiveBlending = 2;\nconst SubtractiveBlending = 3;\nconst MultiplyBlending = 4;\nconst CustomBlending = 5;\nconst AddEquation = 100;\nconst SubtractEquation = 101;\nconst ReverseSubtractEquation = 102;\nconst MinEquation = 103;\nconst MaxEquation = 104;\nconst ZeroFactor = 200;\nconst OneFactor = 201;\nconst SrcColorFactor = 202;\nconst OneMinusSrcColorFactor = 203;\nconst SrcAlphaFactor = 204;\nconst OneMinusSrcAlphaFactor = 205;\nconst DstAlphaFactor = 206;\nconst OneMinusDstAlphaFactor = 207;\nconst DstColorFactor = 208;\nconst OneMinusDstColorFactor = 209;\nconst SrcAlphaSaturateFactor = 210;\nconst ConstantColorFactor = 211;\nconst OneMinusConstantColorFactor = 212;\nconst ConstantAlphaFactor = 213;\nconst OneMinusConstantAlphaFactor = 214;\nconst NeverDepth = 0;\nconst AlwaysDepth = 1;\nconst LessDepth = 2;\nconst LessEqualDepth = 3;\nconst EqualDepth = 4;\nconst GreaterEqualDepth = 5;\nconst GreaterDepth = 6;\nconst NotEqualDepth = 7;\nconst MultiplyOperation = 0;\nconst MixOperation = 1;\nconst AddOperation = 2;\nconst NoToneMapping = 0;\nconst LinearToneMapping = 1;\nconst ReinhardToneMapping = 2;\nconst CineonToneMapping = 3;\nconst ACESFilmicToneMapping = 4;\nconst CustomToneMapping = 5;\nconst AgXToneMapping = 6;\nconst NeutralToneMapping = 7;\nconst AttachedBindMode = 'attached';\nconst DetachedBindMode = 'detached';\n\nconst UVMapping = 300;\nconst CubeReflectionMapping = 301;\nconst CubeRefractionMapping = 302;\nconst EquirectangularReflectionMapping = 303;\nconst EquirectangularRefractionMapping = 304;\nconst CubeUVReflectionMapping = 306;\nconst RepeatWrapping = 1000;\nconst ClampToEdgeWrapping = 1001;\nconst MirroredRepeatWrapping = 1002;\nconst NearestFilter = 1003;\nconst NearestMipmapNearestFilter = 1004;\nconst NearestMipMapNearestFilter = 1004;\nconst NearestMipmapLinearFilter = 1005;\nconst NearestMipMapLinearFilter = 1005;\nconst LinearFilter = 1006;\nconst LinearMipmapNearestFilter = 1007;\nconst LinearMipMapNearestFilter = 1007;\nconst LinearMipmapLinearFilter = 1008;\nconst LinearMipMapLinearFilter = 1008;\nconst UnsignedByteType = 1009;\nconst ByteType = 1010;\nconst ShortType = 1011;\nconst UnsignedShortType = 1012;\nconst IntType = 1013;\nconst UnsignedIntType = 1014;\nconst FloatType = 1015;\nconst HalfFloatType = 1016;\nconst UnsignedShort4444Type = 1017;\nconst UnsignedShort5551Type = 1018;\nconst UnsignedInt248Type = 1020;\nconst UnsignedInt5999Type = 35902;\nconst AlphaFormat = 1021;\nconst RGBFormat = 1022;\nconst RGBAFormat = 1023;\nconst LuminanceFormat = 1024;\nconst LuminanceAlphaFormat = 1025;\nconst DepthFormat = 1026;\nconst DepthStencilFormat = 1027;\nconst RedFormat = 1028;\nconst RedIntegerFormat = 1029;\nconst RGFormat = 1030;\nconst RGIntegerFormat = 1031;\nconst RGBAIntegerFormat = 1033;\n\nconst RGB_S3TC_DXT1_Format = 33776;\nconst RGBA_S3TC_DXT1_Format = 33777;\nconst RGBA_S3TC_DXT3_Format = 33778;\nconst RGBA_S3TC_DXT5_Format = 33779;\nconst RGB_PVRTC_4BPPV1_Format = 35840;\nconst RGB_PVRTC_2BPPV1_Format = 35841;\nconst RGBA_PVRTC_4BPPV1_Format = 35842;\nconst RGBA_PVRTC_2BPPV1_Format = 35843;\nconst RGB_ETC1_Format = 36196;\nconst RGB_ETC2_Format = 37492;\nconst RGBA_ETC2_EAC_Format = 37496;\nconst RGBA_ASTC_4x4_Format = 37808;\nconst RGBA_ASTC_5x4_Format = 37809;\nconst RGBA_ASTC_5x5_Format = 37810;\nconst RGBA_ASTC_6x5_Format = 37811;\nconst RGBA_ASTC_6x6_Format = 37812;\nconst RGBA_ASTC_8x5_Format = 37813;\nconst RGBA_ASTC_8x6_Format = 37814;\nconst RGBA_ASTC_8x8_Format = 37815;\nconst RGBA_ASTC_10x5_Format = 37816;\nconst RGBA_ASTC_10x6_Format = 37817;\nconst RGBA_ASTC_10x8_Format = 37818;\nconst RGBA_ASTC_10x10_Format = 37819;\nconst RGBA_ASTC_12x10_Format = 37820;\nconst RGBA_ASTC_12x12_Format = 37821;\nconst RGBA_BPTC_Format = 36492;\nconst RGB_BPTC_SIGNED_Format = 36494;\nconst RGB_BPTC_UNSIGNED_Format = 36495;\nconst RED_RGTC1_Format = 36283;\nconst SIGNED_RED_RGTC1_Format = 36284;\nconst RED_GREEN_RGTC2_Format = 36285;\nconst SIGNED_RED_GREEN_RGTC2_Format = 36286;\nconst LoopOnce = 2200;\nconst LoopRepeat = 2201;\nconst LoopPingPong = 2202;\nconst InterpolateDiscrete = 2300;\nconst InterpolateLinear = 2301;\nconst InterpolateSmooth = 2302;\nconst ZeroCurvatureEnding = 2400;\nconst ZeroSlopeEnding = 2401;\nconst WrapAroundEnding = 2402;\nconst NormalAnimationBlendMode = 2500;\nconst AdditiveAnimationBlendMode = 2501;\nconst TrianglesDrawMode = 0;\nconst TriangleStripDrawMode = 1;\nconst TriangleFanDrawMode = 2;\nconst BasicDepthPacking = 3200;\nconst RGBADepthPacking = 3201;\nconst TangentSpaceNormalMap = 0;\nconst ObjectSpaceNormalMap = 1;\n\n// Color space string identifiers, matching CSS Color Module Level 4 and WebGPU names where available.\nconst NoColorSpace = '';\nconst SRGBColorSpace = 'srgb';\nconst LinearSRGBColorSpace = 'srgb-linear';\nconst DisplayP3ColorSpace = 'display-p3';\nconst LinearDisplayP3ColorSpace = 'display-p3-linear';\n\nconst LinearTransfer = 'linear';\nconst SRGBTransfer = 'srgb';\n\nconst Rec709Primaries = 'rec709';\nconst P3Primaries = 'p3';\n\nconst ZeroStencilOp = 0;\nconst KeepStencilOp = 7680;\nconst ReplaceStencilOp = 7681;\nconst IncrementStencilOp = 7682;\nconst DecrementStencilOp = 7683;\nconst IncrementWrapStencilOp = 34055;\nconst DecrementWrapStencilOp = 34056;\nconst InvertStencilOp = 5386;\n\nconst NeverStencilFunc = 512;\nconst LessStencilFunc = 513;\nconst EqualStencilFunc = 514;\nconst LessEqualStencilFunc = 515;\nconst GreaterStencilFunc = 516;\nconst NotEqualStencilFunc = 517;\nconst GreaterEqualStencilFunc = 518;\nconst AlwaysStencilFunc = 519;\n\nconst NeverCompare = 512;\nconst LessCompare = 513;\nconst EqualCompare = 514;\nconst LessEqualCompare = 515;\nconst GreaterCompare = 516;\nconst NotEqualCompare = 517;\nconst GreaterEqualCompare = 518;\nconst AlwaysCompare = 519;\n\nconst StaticDrawUsage = 35044;\nconst DynamicDrawUsage = 35048;\nconst StreamDrawUsage = 35040;\nconst StaticReadUsage = 35045;\nconst DynamicReadUsage = 35049;\nconst StreamReadUsage = 35041;\nconst StaticCopyUsage = 35046;\nconst DynamicCopyUsage = 35050;\nconst StreamCopyUsage = 35042;\n\nconst GLSL1 = '100';\nconst GLSL3 = '300 es';\n\nconst WebGLCoordinateSystem = 2000;\nconst WebGPUCoordinateSystem = 2001;\n\n/**\n * https://github.com/mrdoob/eventdispatcher.js/\n */\n\nclass EventDispatcher {\n\n\taddEventListener( type, listener ) {\n\n\t\tif ( this._listeners === undefined ) this._listeners = {};\n\n\t\tconst listeners = this._listeners;\n\n\t\tif ( listeners[ type ] === undefined ) {\n\n\t\t\tlisteners[ type ] = [];\n\n\t\t}\n\n\t\tif ( listeners[ type ].indexOf( listener ) === - 1 ) {\n\n\t\t\tlisteners[ type ].push( listener );\n\n\t\t}\n\n\t}\n\n\thasEventListener( type, listener ) {\n\n\t\tif ( this._listeners === undefined ) return false;\n\n\t\tconst listeners = this._listeners;\n\n\t\treturn listeners[ type ] !== undefined && listeners[ type ].indexOf( listener ) !== - 1;\n\n\t}\n\n\tremoveEventListener( type, listener ) {\n\n\t\tif ( this._listeners === undefined ) return;\n\n\t\tconst listeners = this._listeners;\n\t\tconst listenerArray = listeners[ type ];\n\n\t\tif ( listenerArray !== undefined ) {\n\n\t\t\tconst index = listenerArray.indexOf( listener );\n\n\t\t\tif ( index !== - 1 ) {\n\n\t\t\t\tlistenerArray.splice( index, 1 );\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n\tdispatchEvent( event ) {\n\n\t\tif ( this._listeners === undefined ) return;\n\n\t\tconst listeners = this._listeners;\n\t\tconst listenerArray = listeners[ event.type ];\n\n\t\tif ( listenerArray !== undefined ) {\n\n\t\t\tevent.target = this;\n\n\t\t\t// Make a copy, in case listeners are removed while iterating.\n\t\t\tconst array = listenerArray.slice( 0 );\n\n\t\t\tfor ( let i = 0, l = array.length; i < l; i ++ ) {\n\n\t\t\t\tarray[ i ].call( this, event );\n\n\t\t\t}\n\n\t\t\tevent.target = null;\n\n\t\t}\n\n\t}\n\n}\n\nconst _lut = [ '00', '01', '02', '03', '04', '05', '06', '07', '08', '09', '0a', '0b', '0c', '0d', '0e', '0f', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '1a', '1b', '1c', '1d', '1e', '1f', '20', '21', '22', '23', '24', '25', '26', '27', '28', '29', '2a', '2b', '2c', '2d', '2e', '2f', '30', '31', '32', '33', '34', '35', '36', '37', '38', '39', '3a', '3b', '3c', '3d', '3e', '3f', '40', '41', '42', '43', '44', '45', '46', '47', '48', '49', '4a', '4b', '4c', '4d', '4e', '4f', '50', '51', '52', '53', '54', '55', '56', '57', '58', '59', '5a', '5b', '5c', '5d', '5e', '5f', '60', '61', '62', '63', '64', '65', '66', '67', '68', '69', '6a', '6b', '6c', '6d', '6e', '6f', '70', '71', '72', '73', '74', '75', '76', '77', '78', '79', '7a', '7b', '7c', '7d', '7e', '7f', '80', '81', '82', '83', '84', '85', '86', '87', '88', '89', '8a', '8b', '8c', '8d', '8e', '8f', '90', '91', '92', '93', '94', '95', '96', '97', '98', '99', '9a', '9b', '9c', '9d', '9e', '9f', 'a0', 'a1', 'a2', 'a3', 'a4', 'a5', 'a6', 'a7', 'a8', 'a9', 'aa', 'ab', 'ac', 'ad', 'ae', 'af', 'b0', 'b1', 'b2', 'b3', 'b4', 'b5', 'b6', 'b7', 'b8', 'b9', 'ba', 'bb', 'bc', 'bd', 'be', 'bf', 'c0', 'c1', 'c2', 'c3', 'c4', 'c5', 'c6', 'c7', 'c8', 'c9', 'ca', 'cb', 'cc', 'cd', 'ce', 'cf', 'd0', 'd1', 'd2', 'd3', 'd4', 'd5', 'd6', 'd7', 'd8', 'd9', 'da', 'db', 'dc', 'dd', 'de', 'df', 'e0', 'e1', 'e2', 'e3', 'e4', 'e5', 'e6', 'e7', 'e8', 'e9', 'ea', 'eb', 'ec', 'ed', 'ee', 'ef', 'f0', 'f1', 'f2', 'f3', 'f4', 'f5', 'f6', 'f7', 'f8', 'f9', 'fa', 'fb', 'fc', 'fd', 'fe', 'ff' ];\n\nlet _seed = 1234567;\n\n\nconst DEG2RAD = Math.PI / 180;\nconst RAD2DEG = 180 / Math.PI;\n\n// http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/21963136#21963136\nfunction generateUUID() {\n\n\tconst d0 = Math.random() * 0xffffffff | 0;\n\tconst d1 = Math.random() * 0xffffffff | 0;\n\tconst d2 = Math.random() * 0xffffffff | 0;\n\tconst d3 = Math.random() * 0xffffffff | 0;\n\tconst uuid = _lut[ d0 & 0xff ] + _lut[ d0 >> 8 & 0xff ] + _lut[ d0 >> 16 & 0xff ] + _lut[ d0 >> 24 & 0xff ] + '-' +\n\t\t\t_lut[ d1 & 0xff ] + _lut[ d1 >> 8 & 0xff ] + '-' + _lut[ d1 >> 16 & 0x0f | 0x40 ] + _lut[ d1 >> 24 & 0xff ] + '-' +\n\t\t\t_lut[ d2 & 0x3f | 0x80 ] + _lut[ d2 >> 8 & 0xff ] + '-' + _lut[ d2 >> 16 & 0xff ] + _lut[ d2 >> 24 & 0xff ] +\n\t\t\t_lut[ d3 & 0xff ] + _lut[ d3 >> 8 & 0xff ] + _lut[ d3 >> 16 & 0xff ] + _lut[ d3 >> 24 & 0xff ];\n\n\t// .toLowerCase() here flattens concatenated strings to save heap memory space.\n\treturn uuid.toLowerCase();\n\n}\n\nfunction clamp( value, min, max ) {\n\n\treturn Math.max( min, Math.min( max, value ) );\n\n}\n\n// compute euclidean modulo of m % n\n// https://en.wikipedia.org/wiki/Modulo_operation\nfunction euclideanModulo( n, m ) {\n\n\treturn ( ( n % m ) + m ) % m;\n\n}\n\n// Linear mapping from range to range \nfunction mapLinear( x, a1, a2, b1, b2 ) {\n\n\treturn b1 + ( x - a1 ) * ( b2 - b1 ) / ( a2 - a1 );\n\n}\n\n// https://www.gamedev.net/tutorials/programming/general-and-gameplay-programming/inverse-lerp-a-super-useful-yet-often-overlooked-function-r5230/\nfunction inverseLerp( x, y, value ) {\n\n\tif ( x !== y ) {\n\n\t\treturn ( value - x ) / ( y - x );\n\n\t} else {\n\n\t\treturn 0;\n\n\t}\n\n}\n\n// https://en.wikipedia.org/wiki/Linear_interpolation\nfunction lerp( x, y, t ) {\n\n\treturn ( 1 - t ) * x + t * y;\n\n}\n\n// http://www.rorydriscoll.com/2016/03/07/frame-rate-independent-damping-using-lerp/\nfunction damp( x, y, lambda, dt ) {\n\n\treturn lerp( x, y, 1 - Math.exp( - lambda * dt ) );\n\n}\n\n// https://www.desmos.com/calculator/vcsjnyz7x4\nfunction pingpong( x, length = 1 ) {\n\n\treturn length - Math.abs( euclideanModulo( x, length * 2 ) - length );\n\n}\n\n// http://en.wikipedia.org/wiki/Smoothstep\nfunction smoothstep( x, min, max ) {\n\n\tif ( x <= min ) return 0;\n\tif ( x >= max ) return 1;\n\n\tx = ( x - min ) / ( max - min );\n\n\treturn x * x * ( 3 - 2 * x );\n\n}\n\nfunction smootherstep( x, min, max ) {\n\n\tif ( x <= min ) return 0;\n\tif ( x >= max ) return 1;\n\n\tx = ( x - min ) / ( max - min );\n\n\treturn x * x * x * ( x * ( x * 6 - 15 ) + 10 );\n\n}\n\n// Random integer from interval\nfunction randInt( low, high ) {\n\n\treturn low + Math.floor( Math.random() * ( high - low + 1 ) );\n\n}\n\n// Random float from interval\nfunction randFloat( low, high ) {\n\n\treturn low + Math.random() * ( high - low );\n\n}\n\n// Random float from <-range/2, range/2> interval\nfunction randFloatSpread( range ) {\n\n\treturn range * ( 0.5 - Math.random() );\n\n}\n\n// Deterministic pseudo-random float in the interval [ 0, 1 ]\nfunction seededRandom( s ) {\n\n\tif ( s !== undefined ) _seed = s;\n\n\t// Mulberry32 generator\n\n\tlet t = _seed += 0x6D2B79F5;\n\n\tt = Math.imul( t ^ t >>> 15, t | 1 );\n\n\tt ^= t + Math.imul( t ^ t >>> 7, t | 61 );\n\n\treturn ( ( t ^ t >>> 14 ) >>> 0 ) / 4294967296;\n\n}\n\nfunction degToRad( degrees ) {\n\n\treturn degrees * DEG2RAD;\n\n}\n\nfunction radToDeg( radians ) {\n\n\treturn radians * RAD2DEG;\n\n}\n\nfunction isPowerOfTwo( value ) {\n\n\treturn ( value & ( value - 1 ) ) === 0 && value !== 0;\n\n}\n\nfunction ceilPowerOfTwo( value ) {\n\n\treturn Math.pow( 2, Math.ceil( Math.log( value ) / Math.LN2 ) );\n\n}\n\nfunction floorPowerOfTwo( value ) {\n\n\treturn Math.pow( 2, Math.floor( Math.log( value ) / Math.LN2 ) );\n\n}\n\nfunction setQuaternionFromProperEuler( q, a, b, c, order ) {\n\n\t// Intrinsic Proper Euler Angles - see https://en.wikipedia.org/wiki/Euler_angles\n\n\t// rotations are applied to the axes in the order specified by 'order'\n\t// rotation by angle 'a' is applied first, then by angle 'b', then by angle 'c'\n\t// angles are in radians\n\n\tconst cos = Math.cos;\n\tconst sin = Math.sin;\n\n\tconst c2 = cos( b / 2 );\n\tconst s2 = sin( b / 2 );\n\n\tconst c13 = cos( ( a + c ) / 2 );\n\tconst s13 = sin( ( a + c ) / 2 );\n\n\tconst c1_3 = cos( ( a - c ) / 2 );\n\tconst s1_3 = sin( ( a - c ) / 2 );\n\n\tconst c3_1 = cos( ( c - a ) / 2 );\n\tconst s3_1 = sin( ( c - a ) / 2 );\n\n\tswitch ( order ) {\n\n\t\tcase 'XYX':\n\t\t\tq.set( c2 * s13, s2 * c1_3, s2 * s1_3, c2 * c13 );\n\t\t\tbreak;\n\n\t\tcase 'YZY':\n\t\t\tq.set( s2 * s1_3, c2 * s13, s2 * c1_3, c2 * c13 );\n\t\t\tbreak;\n\n\t\tcase 'ZXZ':\n\t\t\tq.set( s2 * c1_3, s2 * s1_3, c2 * s13, c2 * c13 );\n\t\t\tbreak;\n\n\t\tcase 'XZX':\n\t\t\tq.set( c2 * s13, s2 * s3_1, s2 * c3_1, c2 * c13 );\n\t\t\tbreak;\n\n\t\tcase 'YXY':\n\t\t\tq.set( s2 * c3_1, c2 * s13, s2 * s3_1, c2 * c13 );\n\t\t\tbreak;\n\n\t\tcase 'ZYZ':\n\t\t\tq.set( s2 * s3_1, s2 * c3_1, c2 * s13, c2 * c13 );\n\t\t\tbreak;\n\n\t\tdefault:\n\t\t\tconsole.warn( 'THREE.MathUtils: .setQuaternionFromProperEuler() encountered an unknown order: ' + order );\n\n\t}\n\n}\n\nfunction denormalize( value, array ) {\n\n\tswitch ( array.constructor ) {\n\n\t\tcase Float32Array:\n\n\t\t\treturn value;\n\n\t\tcase Uint32Array:\n\n\t\t\treturn value / 4294967295.0;\n\n\t\tcase Uint16Array:\n\n\t\t\treturn value / 65535.0;\n\n\t\tcase Uint8Array:\n\n\t\t\treturn value / 255.0;\n\n\t\tcase Int32Array:\n\n\t\t\treturn Math.max( value / 2147483647.0, - 1.0 );\n\n\t\tcase Int16Array:\n\n\t\t\treturn Math.max( value / 32767.0, - 1.0 );\n\n\t\tcase Int8Array:\n\n\t\t\treturn Math.max( value / 127.0, - 1.0 );\n\n\t\tdefault:\n\n\t\t\tthrow new Error( 'Invalid component type.' );\n\n\t}\n\n}\n\nfunction normalize( value, array ) {\n\n\tswitch ( array.constructor ) {\n\n\t\tcase Float32Array:\n\n\t\t\treturn value;\n\n\t\tcase Uint32Array:\n\n\t\t\treturn Math.round( value * 4294967295.0 );\n\n\t\tcase Uint16Array:\n\n\t\t\treturn Math.round( value * 65535.0 );\n\n\t\tcase Uint8Array:\n\n\t\t\treturn Math.round( value * 255.0 );\n\n\t\tcase Int32Array:\n\n\t\t\treturn Math.round( value * 2147483647.0 );\n\n\t\tcase Int16Array:\n\n\t\t\treturn Math.round( value * 32767.0 );\n\n\t\tcase Int8Array:\n\n\t\t\treturn Math.round( value * 127.0 );\n\n\t\tdefault:\n\n\t\t\tthrow new Error( 'Invalid component type.' );\n\n\t}\n\n}\n\nconst MathUtils = {\n\tDEG2RAD: DEG2RAD,\n\tRAD2DEG: RAD2DEG,\n\tgenerateUUID: generateUUID,\n\tclamp: clamp,\n\teuclideanModulo: euclideanModulo,\n\tmapLinear: mapLinear,\n\tinverseLerp: inverseLerp,\n\tlerp: lerp,\n\tdamp: damp,\n\tpingpong: pingpong,\n\tsmoothstep: smoothstep,\n\tsmootherstep: smootherstep,\n\trandInt: randInt,\n\trandFloat: randFloat,\n\trandFloatSpread: randFloatSpread,\n\tseededRandom: seededRandom,\n\tdegToRad: degToRad,\n\tradToDeg: radToDeg,\n\tisPowerOfTwo: isPowerOfTwo,\n\tceilPowerOfTwo: ceilPowerOfTwo,\n\tfloorPowerOfTwo: floorPowerOfTwo,\n\tsetQuaternionFromProperEuler: setQuaternionFromProperEuler,\n\tnormalize: normalize,\n\tdenormalize: denormalize\n};\n\nclass Vector2 {\n\n\tconstructor( x = 0, y = 0 ) {\n\n\t\tVector2.prototype.isVector2 = true;\n\n\t\tthis.x = x;\n\t\tthis.y = y;\n\n\t}\n\n\tget width() {\n\n\t\treturn this.x;\n\n\t}\n\n\tset width( value ) {\n\n\t\tthis.x = value;\n\n\t}\n\n\tget height() {\n\n\t\treturn this.y;\n\n\t}\n\n\tset height( value ) {\n\n\t\tthis.y = value;\n\n\t}\n\n\tset( x, y ) {\n\n\t\tthis.x = x;\n\t\tthis.y = y;\n\n\t\treturn this;\n\n\t}\n\n\tsetScalar( scalar ) {\n\n\t\tthis.x = scalar;\n\t\tthis.y = scalar;\n\n\t\treturn this;\n\n\t}\n\n\tsetX( x ) {\n\n\t\tthis.x = x;\n\n\t\treturn this;\n\n\t}\n\n\tsetY( y ) {\n\n\t\tthis.y = y;\n\n\t\treturn this;\n\n\t}\n\n\tsetComponent( index, value ) {\n\n\t\tswitch ( index ) {\n\n\t\t\tcase 0: this.x = value; break;\n\t\t\tcase 1: this.y = value; break;\n\t\t\tdefault: throw new Error( 'index is out of range: ' + index );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tgetComponent( index ) {\n\n\t\tswitch ( index ) {\n\n\t\t\tcase 0: return this.x;\n\t\t\tcase 1: return this.y;\n\t\t\tdefault: throw new Error( 'index is out of range: ' + index );\n\n\t\t}\n\n\t}\n\n\tclone() {\n\n\t\treturn new this.constructor( this.x, this.y );\n\n\t}\n\n\tcopy( v ) {\n\n\t\tthis.x = v.x;\n\t\tthis.y = v.y;\n\n\t\treturn this;\n\n\t}\n\n\tadd( v ) {\n\n\t\tthis.x += v.x;\n\t\tthis.y += v.y;\n\n\t\treturn this;\n\n\t}\n\n\taddScalar( s ) {\n\n\t\tthis.x += s;\n\t\tthis.y += s;\n\n\t\treturn this;\n\n\t}\n\n\taddVectors( a, b ) {\n\n\t\tthis.x = a.x + b.x;\n\t\tthis.y = a.y + b.y;\n\n\t\treturn this;\n\n\t}\n\n\taddScaledVector( v, s ) {\n\n\t\tthis.x += v.x * s;\n\t\tthis.y += v.y * s;\n\n\t\treturn this;\n\n\t}\n\n\tsub( v ) {\n\n\t\tthis.x -= v.x;\n\t\tthis.y -= v.y;\n\n\t\treturn this;\n\n\t}\n\n\tsubScalar( s ) {\n\n\t\tthis.x -= s;\n\t\tthis.y -= s;\n\n\t\treturn this;\n\n\t}\n\n\tsubVectors( a, b ) {\n\n\t\tthis.x = a.x - b.x;\n\t\tthis.y = a.y - b.y;\n\n\t\treturn this;\n\n\t}\n\n\tmultiply( v ) {\n\n\t\tthis.x *= v.x;\n\t\tthis.y *= v.y;\n\n\t\treturn this;\n\n\t}\n\n\tmultiplyScalar( scalar ) {\n\n\t\tthis.x *= scalar;\n\t\tthis.y *= scalar;\n\n\t\treturn this;\n\n\t}\n\n\tdivide( v ) {\n\n\t\tthis.x /= v.x;\n\t\tthis.y /= v.y;\n\n\t\treturn this;\n\n\t}\n\n\tdivideScalar( scalar ) {\n\n\t\treturn this.multiplyScalar( 1 / scalar );\n\n\t}\n\n\tapplyMatrix3( m ) {\n\n\t\tconst x = this.x, y = this.y;\n\t\tconst e = m.elements;\n\n\t\tthis.x = e[ 0 ] * x + e[ 3 ] * y + e[ 6 ];\n\t\tthis.y = e[ 1 ] * x + e[ 4 ] * y + e[ 7 ];\n\n\t\treturn this;\n\n\t}\n\n\tmin( v ) {\n\n\t\tthis.x = Math.min( this.x, v.x );\n\t\tthis.y = Math.min( this.y, v.y );\n\n\t\treturn this;\n\n\t}\n\n\tmax( v ) {\n\n\t\tthis.x = Math.max( this.x, v.x );\n\t\tthis.y = Math.max( this.y, v.y );\n\n\t\treturn this;\n\n\t}\n\n\tclamp( min, max ) {\n\n\t\t// assumes min < max, componentwise\n\n\t\tthis.x = Math.max( min.x, Math.min( max.x, this.x ) );\n\t\tthis.y = Math.max( min.y, Math.min( max.y, this.y ) );\n\n\t\treturn this;\n\n\t}\n\n\tclampScalar( minVal, maxVal ) {\n\n\t\tthis.x = Math.max( minVal, Math.min( maxVal, this.x ) );\n\t\tthis.y = Math.max( minVal, Math.min( maxVal, this.y ) );\n\n\t\treturn this;\n\n\t}\n\n\tclampLength( min, max ) {\n\n\t\tconst length = this.length();\n\n\t\treturn this.divideScalar( length || 1 ).multiplyScalar( Math.max( min, Math.min( max, length ) ) );\n\n\t}\n\n\tfloor() {\n\n\t\tthis.x = Math.floor( this.x );\n\t\tthis.y = Math.floor( this.y );\n\n\t\treturn this;\n\n\t}\n\n\tceil() {\n\n\t\tthis.x = Math.ceil( this.x );\n\t\tthis.y = Math.ceil( this.y );\n\n\t\treturn this;\n\n\t}\n\n\tround() {\n\n\t\tthis.x = Math.round( this.x );\n\t\tthis.y = Math.round( this.y );\n\n\t\treturn this;\n\n\t}\n\n\troundToZero() {\n\n\t\tthis.x = Math.trunc( this.x );\n\t\tthis.y = Math.trunc( this.y );\n\n\t\treturn this;\n\n\t}\n\n\tnegate() {\n\n\t\tthis.x = - this.x;\n\t\tthis.y = - this.y;\n\n\t\treturn this;\n\n\t}\n\n\tdot( v ) {\n\n\t\treturn this.x * v.x + this.y * v.y;\n\n\t}\n\n\tcross( v ) {\n\n\t\treturn this.x * v.y - this.y * v.x;\n\n\t}\n\n\tlengthSq() {\n\n\t\treturn this.x * this.x + this.y * this.y;\n\n\t}\n\n\tlength() {\n\n\t\treturn Math.sqrt( this.x * this.x + this.y * this.y );\n\n\t}\n\n\tmanhattanLength() {\n\n\t\treturn Math.abs( this.x ) + Math.abs( this.y );\n\n\t}\n\n\tnormalize() {\n\n\t\treturn this.divideScalar( this.length() || 1 );\n\n\t}\n\n\tangle() {\n\n\t\t// computes the angle in radians with respect to the positive x-axis\n\n\t\tconst angle = Math.atan2( - this.y, - this.x ) + Math.PI;\n\n\t\treturn angle;\n\n\t}\n\n\tangleTo( v ) {\n\n\t\tconst denominator = Math.sqrt( this.lengthSq() * v.lengthSq() );\n\n\t\tif ( denominator === 0 ) return Math.PI / 2;\n\n\t\tconst theta = this.dot( v ) / denominator;\n\n\t\t// clamp, to handle numerical problems\n\n\t\treturn Math.acos( clamp( theta, - 1, 1 ) );\n\n\t}\n\n\tdistanceTo( v ) {\n\n\t\treturn Math.sqrt( this.distanceToSquared( v ) );\n\n\t}\n\n\tdistanceToSquared( v ) {\n\n\t\tconst dx = this.x - v.x, dy = this.y - v.y;\n\t\treturn dx * dx + dy * dy;\n\n\t}\n\n\tmanhattanDistanceTo( v ) {\n\n\t\treturn Math.abs( this.x - v.x ) + Math.abs( this.y - v.y );\n\n\t}\n\n\tsetLength( length ) {\n\n\t\treturn this.normalize().multiplyScalar( length );\n\n\t}\n\n\tlerp( v, alpha ) {\n\n\t\tthis.x += ( v.x - this.x ) * alpha;\n\t\tthis.y += ( v.y - this.y ) * alpha;\n\n\t\treturn this;\n\n\t}\n\n\tlerpVectors( v1, v2, alpha ) {\n\n\t\tthis.x = v1.x + ( v2.x - v1.x ) * alpha;\n\t\tthis.y = v1.y + ( v2.y - v1.y ) * alpha;\n\n\t\treturn this;\n\n\t}\n\n\tequals( v ) {\n\n\t\treturn ( ( v.x === this.x ) && ( v.y === this.y ) );\n\n\t}\n\n\tfromArray( array, offset = 0 ) {\n\n\t\tthis.x = array[ offset ];\n\t\tthis.y = array[ offset + 1 ];\n\n\t\treturn this;\n\n\t}\n\n\ttoArray( array = [], offset = 0 ) {\n\n\t\tarray[ offset ] = this.x;\n\t\tarray[ offset + 1 ] = this.y;\n\n\t\treturn array;\n\n\t}\n\n\tfromBufferAttribute( attribute, index ) {\n\n\t\tthis.x = attribute.getX( index );\n\t\tthis.y = attribute.getY( index );\n\n\t\treturn this;\n\n\t}\n\n\trotateAround( center, angle ) {\n\n\t\tconst c = Math.cos( angle ), s = Math.sin( angle );\n\n\t\tconst x = this.x - center.x;\n\t\tconst y = this.y - center.y;\n\n\t\tthis.x = x * c - y * s + center.x;\n\t\tthis.y = x * s + y * c + center.y;\n\n\t\treturn this;\n\n\t}\n\n\trandom() {\n\n\t\tthis.x = Math.random();\n\t\tthis.y = Math.random();\n\n\t\treturn this;\n\n\t}\n\n\t*[ Symbol.iterator ]() {\n\n\t\tyield this.x;\n\t\tyield this.y;\n\n\t}\n\n}\n\nclass Matrix3 {\n\n\tconstructor( n11, n12, n13, n21, n22, n23, n31, n32, n33 ) {\n\n\t\tMatrix3.prototype.isMatrix3 = true;\n\n\t\tthis.elements = [\n\n\t\t\t1, 0, 0,\n\t\t\t0, 1, 0,\n\t\t\t0, 0, 1\n\n\t\t];\n\n\t\tif ( n11 !== undefined ) {\n\n\t\t\tthis.set( n11, n12, n13, n21, n22, n23, n31, n32, n33 );\n\n\t\t}\n\n\t}\n\n\tset( n11, n12, n13, n21, n22, n23, n31, n32, n33 ) {\n\n\t\tconst te = this.elements;\n\n\t\tte[ 0 ] = n11; te[ 1 ] = n21; te[ 2 ] = n31;\n\t\tte[ 3 ] = n12; te[ 4 ] = n22; te[ 5 ] = n32;\n\t\tte[ 6 ] = n13; te[ 7 ] = n23; te[ 8 ] = n33;\n\n\t\treturn this;\n\n\t}\n\n\tidentity() {\n\n\t\tthis.set(\n\n\t\t\t1, 0, 0,\n\t\t\t0, 1, 0,\n\t\t\t0, 0, 1\n\n\t\t);\n\n\t\treturn this;\n\n\t}\n\n\tcopy( m ) {\n\n\t\tconst te = this.elements;\n\t\tconst me = m.elements;\n\n\t\tte[ 0 ] = me[ 0 ]; te[ 1 ] = me[ 1 ]; te[ 2 ] = me[ 2 ];\n\t\tte[ 3 ] = me[ 3 ]; te[ 4 ] = me[ 4 ]; te[ 5 ] = me[ 5 ];\n\t\tte[ 6 ] = me[ 6 ]; te[ 7 ] = me[ 7 ]; te[ 8 ] = me[ 8 ];\n\n\t\treturn this;\n\n\t}\n\n\textractBasis( xAxis, yAxis, zAxis ) {\n\n\t\txAxis.setFromMatrix3Column( this, 0 );\n\t\tyAxis.setFromMatrix3Column( this, 1 );\n\t\tzAxis.setFromMatrix3Column( this, 2 );\n\n\t\treturn this;\n\n\t}\n\n\tsetFromMatrix4( m ) {\n\n\t\tconst me = m.elements;\n\n\t\tthis.set(\n\n\t\t\tme[ 0 ], me[ 4 ], me[ 8 ],\n\t\t\tme[ 1 ], me[ 5 ], me[ 9 ],\n\t\t\tme[ 2 ], me[ 6 ], me[ 10 ]\n\n\t\t);\n\n\t\treturn this;\n\n\t}\n\n\tmultiply( m ) {\n\n\t\treturn this.multiplyMatrices( this, m );\n\n\t}\n\n\tpremultiply( m ) {\n\n\t\treturn this.multiplyMatrices( m, this );\n\n\t}\n\n\tmultiplyMatrices( a, b ) {\n\n\t\tconst ae = a.elements;\n\t\tconst be = b.elements;\n\t\tconst te = this.elements;\n\n\t\tconst a11 = ae[ 0 ], a12 = ae[ 3 ], a13 = ae[ 6 ];\n\t\tconst a21 = ae[ 1 ], a22 = ae[ 4 ], a23 = ae[ 7 ];\n\t\tconst a31 = ae[ 2 ], a32 = ae[ 5 ], a33 = ae[ 8 ];\n\n\t\tconst b11 = be[ 0 ], b12 = be[ 3 ], b13 = be[ 6 ];\n\t\tconst b21 = be[ 1 ], b22 = be[ 4 ], b23 = be[ 7 ];\n\t\tconst b31 = be[ 2 ], b32 = be[ 5 ], b33 = be[ 8 ];\n\n\t\tte[ 0 ] = a11 * b11 + a12 * b21 + a13 * b31;\n\t\tte[ 3 ] = a11 * b12 + a12 * b22 + a13 * b32;\n\t\tte[ 6 ] = a11 * b13 + a12 * b23 + a13 * b33;\n\n\t\tte[ 1 ] = a21 * b11 + a22 * b21 + a23 * b31;\n\t\tte[ 4 ] = a21 * b12 + a22 * b22 + a23 * b32;\n\t\tte[ 7 ] = a21 * b13 + a22 * b23 + a23 * b33;\n\n\t\tte[ 2 ] = a31 * b11 + a32 * b21 + a33 * b31;\n\t\tte[ 5 ] = a31 * b12 + a32 * b22 + a33 * b32;\n\t\tte[ 8 ] = a31 * b13 + a32 * b23 + a33 * b33;\n\n\t\treturn this;\n\n\t}\n\n\tmultiplyScalar( s ) {\n\n\t\tconst te = this.elements;\n\n\t\tte[ 0 ] *= s; te[ 3 ] *= s; te[ 6 ] *= s;\n\t\tte[ 1 ] *= s; te[ 4 ] *= s; te[ 7 ] *= s;\n\t\tte[ 2 ] *= s; te[ 5 ] *= s; te[ 8 ] *= s;\n\n\t\treturn this;\n\n\t}\n\n\tdeterminant() {\n\n\t\tconst te = this.elements;\n\n\t\tconst a = te[ 0 ], b = te[ 1 ], c = te[ 2 ],\n\t\t\td = te[ 3 ], e = te[ 4 ], f = te[ 5 ],\n\t\t\tg = te[ 6 ], h = te[ 7 ], i = te[ 8 ];\n\n\t\treturn a * e * i - a * f * h - b * d * i + b * f * g + c * d * h - c * e * g;\n\n\t}\n\n\tinvert() {\n\n\t\tconst te = this.elements,\n\n\t\t\tn11 = te[ 0 ], n21 = te[ 1 ], n31 = te[ 2 ],\n\t\t\tn12 = te[ 3 ], n22 = te[ 4 ], n32 = te[ 5 ],\n\t\t\tn13 = te[ 6 ], n23 = te[ 7 ], n33 = te[ 8 ],\n\n\t\t\tt11 = n33 * n22 - n32 * n23,\n\t\t\tt12 = n32 * n13 - n33 * n12,\n\t\t\tt13 = n23 * n12 - n22 * n13,\n\n\t\t\tdet = n11 * t11 + n21 * t12 + n31 * t13;\n\n\t\tif ( det === 0 ) return this.set( 0, 0, 0, 0, 0, 0, 0, 0, 0 );\n\n\t\tconst detInv = 1 / det;\n\n\t\tte[ 0 ] = t11 * detInv;\n\t\tte[ 1 ] = ( n31 * n23 - n33 * n21 ) * detInv;\n\t\tte[ 2 ] = ( n32 * n21 - n31 * n22 ) * detInv;\n\n\t\tte[ 3 ] = t12 * detInv;\n\t\tte[ 4 ] = ( n33 * n11 - n31 * n13 ) * detInv;\n\t\tte[ 5 ] = ( n31 * n12 - n32 * n11 ) * detInv;\n\n\t\tte[ 6 ] = t13 * detInv;\n\t\tte[ 7 ] = ( n21 * n13 - n23 * n11 ) * detInv;\n\t\tte[ 8 ] = ( n22 * n11 - n21 * n12 ) * detInv;\n\n\t\treturn this;\n\n\t}\n\n\ttranspose() {\n\n\t\tlet tmp;\n\t\tconst m = this.elements;\n\n\t\ttmp = m[ 1 ]; m[ 1 ] = m[ 3 ]; m[ 3 ] = tmp;\n\t\ttmp = m[ 2 ]; m[ 2 ] = m[ 6 ]; m[ 6 ] = tmp;\n\t\ttmp = m[ 5 ]; m[ 5 ] = m[ 7 ]; m[ 7 ] = tmp;\n\n\t\treturn this;\n\n\t}\n\n\tgetNormalMatrix( matrix4 ) {\n\n\t\treturn this.setFromMatrix4( matrix4 ).invert().transpose();\n\n\t}\n\n\ttransposeIntoArray( r ) {\n\n\t\tconst m = this.elements;\n\n\t\tr[ 0 ] = m[ 0 ];\n\t\tr[ 1 ] = m[ 3 ];\n\t\tr[ 2 ] = m[ 6 ];\n\t\tr[ 3 ] = m[ 1 ];\n\t\tr[ 4 ] = m[ 4 ];\n\t\tr[ 5 ] = m[ 7 ];\n\t\tr[ 6 ] = m[ 2 ];\n\t\tr[ 7 ] = m[ 5 ];\n\t\tr[ 8 ] = m[ 8 ];\n\n\t\treturn this;\n\n\t}\n\n\tsetUvTransform( tx, ty, sx, sy, rotation, cx, cy ) {\n\n\t\tconst c = Math.cos( rotation );\n\t\tconst s = Math.sin( rotation );\n\n\t\tthis.set(\n\t\t\tsx * c, sx * s, - sx * ( c * cx + s * cy ) + cx + tx,\n\t\t\t- sy * s, sy * c, - sy * ( - s * cx + c * cy ) + cy + ty,\n\t\t\t0, 0, 1\n\t\t);\n\n\t\treturn this;\n\n\t}\n\n\t//\n\n\tscale( sx, sy ) {\n\n\t\tthis.premultiply( _m3.makeScale( sx, sy ) );\n\n\t\treturn this;\n\n\t}\n\n\trotate( theta ) {\n\n\t\tthis.premultiply( _m3.makeRotation( - theta ) );\n\n\t\treturn this;\n\n\t}\n\n\ttranslate( tx, ty ) {\n\n\t\tthis.premultiply( _m3.makeTranslation( tx, ty ) );\n\n\t\treturn this;\n\n\t}\n\n\t// for 2D Transforms\n\n\tmakeTranslation( x, y ) {\n\n\t\tif ( x.isVector2 ) {\n\n\t\t\tthis.set(\n\n\t\t\t\t1, 0, x.x,\n\t\t\t\t0, 1, x.y,\n\t\t\t\t0, 0, 1\n\n\t\t\t);\n\n\t\t} else {\n\n\t\t\tthis.set(\n\n\t\t\t\t1, 0, x,\n\t\t\t\t0, 1, y,\n\t\t\t\t0, 0, 1\n\n\t\t\t);\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tmakeRotation( theta ) {\n\n\t\t// counterclockwise\n\n\t\tconst c = Math.cos( theta );\n\t\tconst s = Math.sin( theta );\n\n\t\tthis.set(\n\n\t\t\tc, - s, 0,\n\t\t\ts, c, 0,\n\t\t\t0, 0, 1\n\n\t\t);\n\n\t\treturn this;\n\n\t}\n\n\tmakeScale( x, y ) {\n\n\t\tthis.set(\n\n\t\t\tx, 0, 0,\n\t\t\t0, y, 0,\n\t\t\t0, 0, 1\n\n\t\t);\n\n\t\treturn this;\n\n\t}\n\n\t//\n\n\tequals( matrix ) {\n\n\t\tconst te = this.elements;\n\t\tconst me = matrix.elements;\n\n\t\tfor ( let i = 0; i < 9; i ++ ) {\n\n\t\t\tif ( te[ i ] !== me[ i ] ) return false;\n\n\t\t}\n\n\t\treturn true;\n\n\t}\n\n\tfromArray( array, offset = 0 ) {\n\n\t\tfor ( let i = 0; i < 9; i ++ ) {\n\n\t\t\tthis.elements[ i ] = array[ i + offset ];\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\ttoArray( array = [], offset = 0 ) {\n\n\t\tconst te = this.elements;\n\n\t\tarray[ offset ] = te[ 0 ];\n\t\tarray[ offset + 1 ] = te[ 1 ];\n\t\tarray[ offset + 2 ] = te[ 2 ];\n\n\t\tarray[ offset + 3 ] = te[ 3 ];\n\t\tarray[ offset + 4 ] = te[ 4 ];\n\t\tarray[ offset + 5 ] = te[ 5 ];\n\n\t\tarray[ offset + 6 ] = te[ 6 ];\n\t\tarray[ offset + 7 ] = te[ 7 ];\n\t\tarray[ offset + 8 ] = te[ 8 ];\n\n\t\treturn array;\n\n\t}\n\n\tclone() {\n\n\t\treturn new this.constructor().fromArray( this.elements );\n\n\t}\n\n}\n\nconst _m3 = /*@__PURE__*/ new Matrix3();\n\nfunction arrayNeedsUint32( array ) {\n\n\t// assumes larger values usually on last\n\n\tfor ( let i = array.length - 1; i >= 0; -- i ) {\n\n\t\tif ( array[ i ] >= 65535 ) return true; // account for PRIMITIVE_RESTART_FIXED_INDEX, #24565\n\n\t}\n\n\treturn false;\n\n}\n\nconst TYPED_ARRAYS = {\n\tInt8Array: Int8Array,\n\tUint8Array: Uint8Array,\n\tUint8ClampedArray: Uint8ClampedArray,\n\tInt16Array: Int16Array,\n\tUint16Array: Uint16Array,\n\tInt32Array: Int32Array,\n\tUint32Array: Uint32Array,\n\tFloat32Array: Float32Array,\n\tFloat64Array: Float64Array\n};\n\nfunction getTypedArray( type, buffer ) {\n\n\treturn new TYPED_ARRAYS[ type ]( buffer );\n\n}\n\nfunction createElementNS( name ) {\n\n\treturn document.createElementNS( 'http://www.w3.org/1999/xhtml', name );\n\n}\n\nfunction createCanvasElement() {\n\n\tconst canvas = createElementNS( 'canvas' );\n\tcanvas.style.display = 'block';\n\treturn canvas;\n\n}\n\nconst _cache = {};\n\nfunction warnOnce( message ) {\n\n\tif ( message in _cache ) return;\n\n\t_cache[ message ] = true;\n\n\tconsole.warn( message );\n\n}\n\n/**\n * Matrices converting P3 <-> Rec. 709 primaries, without gamut mapping\n * or clipping. Based on W3C specifications for sRGB and Display P3,\n * and ICC specifications for the D50 connection space. Values in/out\n * are _linear_ sRGB and _linear_ Display P3.\n *\n * Note that both sRGB and Display P3 use the sRGB transfer functions.\n *\n * Reference:\n * - http://www.russellcottrell.com/photo/matrixCalculator.htm\n */\n\nconst LINEAR_SRGB_TO_LINEAR_DISPLAY_P3 = /*@__PURE__*/ new Matrix3().set(\n\t0.8224621, 0.177538, 0.0,\n\t0.0331941, 0.9668058, 0.0,\n\t0.0170827, 0.0723974, 0.9105199,\n);\n\nconst LINEAR_DISPLAY_P3_TO_LINEAR_SRGB = /*@__PURE__*/ new Matrix3().set(\n\t1.2249401, - 0.2249404, 0.0,\n\t- 0.0420569, 1.0420571, 0.0,\n\t- 0.0196376, - 0.0786361, 1.0982735\n);\n\n/**\n * Defines supported color spaces by transfer function and primaries,\n * and provides conversions to/from the Linear-sRGB reference space.\n */\nconst COLOR_SPACES = {\n\t[ LinearSRGBColorSpace ]: {\n\t\ttransfer: LinearTransfer,\n\t\tprimaries: Rec709Primaries,\n\t\ttoReference: ( color ) => color,\n\t\tfromReference: ( color ) => color,\n\t},\n\t[ SRGBColorSpace ]: {\n\t\ttransfer: SRGBTransfer,\n\t\tprimaries: Rec709Primaries,\n\t\ttoReference: ( color ) => color.convertSRGBToLinear(),\n\t\tfromReference: ( color ) => color.convertLinearToSRGB(),\n\t},\n\t[ LinearDisplayP3ColorSpace ]: {\n\t\ttransfer: LinearTransfer,\n\t\tprimaries: P3Primaries,\n\t\ttoReference: ( color ) => color.applyMatrix3( LINEAR_DISPLAY_P3_TO_LINEAR_SRGB ),\n\t\tfromReference: ( color ) => color.applyMatrix3( LINEAR_SRGB_TO_LINEAR_DISPLAY_P3 ),\n\t},\n\t[ DisplayP3ColorSpace ]: {\n\t\ttransfer: SRGBTransfer,\n\t\tprimaries: P3Primaries,\n\t\ttoReference: ( color ) => color.convertSRGBToLinear().applyMatrix3( LINEAR_DISPLAY_P3_TO_LINEAR_SRGB ),\n\t\tfromReference: ( color ) => color.applyMatrix3( LINEAR_SRGB_TO_LINEAR_DISPLAY_P3 ).convertLinearToSRGB(),\n\t},\n};\n\nconst SUPPORTED_WORKING_COLOR_SPACES = new Set( [ LinearSRGBColorSpace, LinearDisplayP3ColorSpace ] );\n\nconst ColorManagement = {\n\n\tenabled: true,\n\n\t_workingColorSpace: LinearSRGBColorSpace,\n\n\tget workingColorSpace() {\n\n\t\treturn this._workingColorSpace;\n\n\t},\n\n\tset workingColorSpace( colorSpace ) {\n\n\t\tif ( ! SUPPORTED_WORKING_COLOR_SPACES.has( colorSpace ) ) {\n\n\t\t\tthrow new Error( `Unsupported working color space, \"${ colorSpace }\".` );\n\n\t\t}\n\n\t\tthis._workingColorSpace = colorSpace;\n\n\t},\n\n\tconvert: function ( color, sourceColorSpace, targetColorSpace ) {\n\n\t\tif ( this.enabled === false || sourceColorSpace === targetColorSpace || ! sourceColorSpace || ! targetColorSpace ) {\n\n\t\t\treturn color;\n\n\t\t}\n\n\t\tconst sourceToReference = COLOR_SPACES[ sourceColorSpace ].toReference;\n\t\tconst targetFromReference = COLOR_SPACES[ targetColorSpace ].fromReference;\n\n\t\treturn targetFromReference( sourceToReference( color ) );\n\n\t},\n\n\tfromWorkingColorSpace: function ( color, targetColorSpace ) {\n\n\t\treturn this.convert( color, this._workingColorSpace, targetColorSpace );\n\n\t},\n\n\ttoWorkingColorSpace: function ( color, sourceColorSpace ) {\n\n\t\treturn this.convert( color, sourceColorSpace, this._workingColorSpace );\n\n\t},\n\n\tgetPrimaries: function ( colorSpace ) {\n\n\t\treturn COLOR_SPACES[ colorSpace ].primaries;\n\n\t},\n\n\tgetTransfer: function ( colorSpace ) {\n\n\t\tif ( colorSpace === NoColorSpace ) return LinearTransfer;\n\n\t\treturn COLOR_SPACES[ colorSpace ].transfer;\n\n\t},\n\n};\n\n\nfunction SRGBToLinear( c ) {\n\n\treturn ( c < 0.04045 ) ? c * 0.0773993808 : Math.pow( c * 0.9478672986 + 0.0521327014, 2.4 );\n\n}\n\nfunction LinearToSRGB( c ) {\n\n\treturn ( c < 0.0031308 ) ? c * 12.92 : 1.055 * ( Math.pow( c, 0.41666 ) ) - 0.055;\n\n}\n\nlet _canvas;\n\nclass ImageUtils {\n\n\tstatic getDataURL( image ) {\n\n\t\tif ( /^data:/i.test( image.src ) ) {\n\n\t\t\treturn image.src;\n\n\t\t}\n\n\t\tif ( typeof HTMLCanvasElement === 'undefined' ) {\n\n\t\t\treturn image.src;\n\n\t\t}\n\n\t\tlet canvas;\n\n\t\tif ( image instanceof HTMLCanvasElement ) {\n\n\t\t\tcanvas = image;\n\n\t\t} else {\n\n\t\t\tif ( _canvas === undefined ) _canvas = createElementNS( 'canvas' );\n\n\t\t\t_canvas.width = image.width;\n\t\t\t_canvas.height = image.height;\n\n\t\t\tconst context = _canvas.getContext( '2d' );\n\n\t\t\tif ( image instanceof ImageData ) {\n\n\t\t\t\tcontext.putImageData( image, 0, 0 );\n\n\t\t\t} else {\n\n\t\t\t\tcontext.drawImage( image, 0, 0, image.width, image.height );\n\n\t\t\t}\n\n\t\t\tcanvas = _canvas;\n\n\t\t}\n\n\t\tif ( canvas.width > 2048 || canvas.height > 2048 ) {\n\n\t\t\tconsole.warn( 'THREE.ImageUtils.getDataURL: Image converted to jpg for performance reasons', image );\n\n\t\t\treturn canvas.toDataURL( 'image/jpeg', 0.6 );\n\n\t\t} else {\n\n\t\t\treturn canvas.toDataURL( 'image/png' );\n\n\t\t}\n\n\t}\n\n\tstatic sRGBToLinear( image ) {\n\n\t\tif ( ( typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement ) ||\n\t\t\t( typeof HTMLCanvasElement !== 'undefined' && image instanceof HTMLCanvasElement ) ||\n\t\t\t( typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap ) ) {\n\n\t\t\tconst canvas = createElementNS( 'canvas' );\n\n\t\t\tcanvas.width = image.width;\n\t\t\tcanvas.height = image.height;\n\n\t\t\tconst context = canvas.getContext( '2d' );\n\t\t\tcontext.drawImage( image, 0, 0, image.width, image.height );\n\n\t\t\tconst imageData = context.getImageData( 0, 0, image.width, image.height );\n\t\t\tconst data = imageData.data;\n\n\t\t\tfor ( let i = 0; i < data.length; i ++ ) {\n\n\t\t\t\tdata[ i ] = SRGBToLinear( data[ i ] / 255 ) * 255;\n\n\t\t\t}\n\n\t\t\tcontext.putImageData( imageData, 0, 0 );\n\n\t\t\treturn canvas;\n\n\t\t} else if ( image.data ) {\n\n\t\t\tconst data = image.data.slice( 0 );\n\n\t\t\tfor ( let i = 0; i < data.length; i ++ ) {\n\n\t\t\t\tif ( data instanceof Uint8Array || data instanceof Uint8ClampedArray ) {\n\n\t\t\t\t\tdata[ i ] = Math.floor( SRGBToLinear( data[ i ] / 255 ) * 255 );\n\n\t\t\t\t} else {\n\n\t\t\t\t\t// assuming float\n\n\t\t\t\t\tdata[ i ] = SRGBToLinear( data[ i ] );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\treturn {\n\t\t\t\tdata: data,\n\t\t\t\twidth: image.width,\n\t\t\t\theight: image.height\n\t\t\t};\n\n\t\t} else {\n\n\t\t\tconsole.warn( 'THREE.ImageUtils.sRGBToLinear(): Unsupported image type. No color space conversion applied.' );\n\t\t\treturn image;\n\n\t\t}\n\n\t}\n\n}\n\nlet _sourceId = 0;\n\nclass Source {\n\n\tconstructor( data = null ) {\n\n\t\tthis.isSource = true;\n\n\t\tObject.defineProperty( this, 'id', { value: _sourceId ++ } );\n\n\t\tthis.uuid = generateUUID();\n\n\t\tthis.data = data;\n\t\tthis.dataReady = true;\n\n\t\tthis.version = 0;\n\n\t}\n\n\tset needsUpdate( value ) {\n\n\t\tif ( value === true ) this.version ++;\n\n\t}\n\n\ttoJSON( meta ) {\n\n\t\tconst isRootObject = ( meta === undefined || typeof meta === 'string' );\n\n\t\tif ( ! isRootObject && meta.images[ this.uuid ] !== undefined ) {\n\n\t\t\treturn meta.images[ this.uuid ];\n\n\t\t}\n\n\t\tconst output = {\n\t\t\tuuid: this.uuid,\n\t\t\turl: ''\n\t\t};\n\n\t\tconst data = this.data;\n\n\t\tif ( data !== null ) {\n\n\t\t\tlet url;\n\n\t\t\tif ( Array.isArray( data ) ) {\n\n\t\t\t\t// cube texture\n\n\t\t\t\turl = [];\n\n\t\t\t\tfor ( let i = 0, l = data.length; i < l; i ++ ) {\n\n\t\t\t\t\tif ( data[ i ].isDataTexture ) {\n\n\t\t\t\t\t\turl.push( serializeImage( data[ i ].image ) );\n\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\turl.push( serializeImage( data[ i ] ) );\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t} else {\n\n\t\t\t\t// texture\n\n\t\t\t\turl = serializeImage( data );\n\n\t\t\t}\n\n\t\t\toutput.url = url;\n\n\t\t}\n\n\t\tif ( ! isRootObject ) {\n\n\t\t\tmeta.images[ this.uuid ] = output;\n\n\t\t}\n\n\t\treturn output;\n\n\t}\n\n}\n\nfunction serializeImage( image ) {\n\n\tif ( ( typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement ) ||\n\t\t( typeof HTMLCanvasElement !== 'undefined' && image instanceof HTMLCanvasElement ) ||\n\t\t( typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap ) ) {\n\n\t\t// default images\n\n\t\treturn ImageUtils.getDataURL( image );\n\n\t} else {\n\n\t\tif ( image.data ) {\n\n\t\t\t// images of DataTexture\n\n\t\t\treturn {\n\t\t\t\tdata: Array.from( image.data ),\n\t\t\t\twidth: image.width,\n\t\t\t\theight: image.height,\n\t\t\t\ttype: image.data.constructor.name\n\t\t\t};\n\n\t\t} else {\n\n\t\t\tconsole.warn( 'THREE.Texture: Unable to serialize Texture.' );\n\t\t\treturn {};\n\n\t\t}\n\n\t}\n\n}\n\nlet _textureId = 0;\n\nclass Texture extends EventDispatcher {\n\n\tconstructor( image = Texture.DEFAULT_IMAGE, mapping = Texture.DEFAULT_MAPPING, wrapS = ClampToEdgeWrapping, wrapT = ClampToEdgeWrapping, magFilter = LinearFilter, minFilter = LinearMipmapLinearFilter, format = RGBAFormat, type = UnsignedByteType, anisotropy = Texture.DEFAULT_ANISOTROPY, colorSpace = NoColorSpace ) {\n\n\t\tsuper();\n\n\t\tthis.isTexture = true;\n\n\t\tObject.defineProperty( this, 'id', { value: _textureId ++ } );\n\n\t\tthis.uuid = generateUUID();\n\n\t\tthis.name = '';\n\n\t\tthis.source = new Source( image );\n\t\tthis.mipmaps = [];\n\n\t\tthis.mapping = mapping;\n\t\tthis.channel = 0;\n\n\t\tthis.wrapS = wrapS;\n\t\tthis.wrapT = wrapT;\n\n\t\tthis.magFilter = magFilter;\n\t\tthis.minFilter = minFilter;\n\n\t\tthis.anisotropy = anisotropy;\n\n\t\tthis.format = format;\n\t\tthis.internalFormat = null;\n\t\tthis.type = type;\n\n\t\tthis.offset = new Vector2( 0, 0 );\n\t\tthis.repeat = new Vector2( 1, 1 );\n\t\tthis.center = new Vector2( 0, 0 );\n\t\tthis.rotation = 0;\n\n\t\tthis.matrixAutoUpdate = true;\n\t\tthis.matrix = new Matrix3();\n\n\t\tthis.generateMipmaps = true;\n\t\tthis.premultiplyAlpha = false;\n\t\tthis.flipY = true;\n\t\tthis.unpackAlignment = 4;\t// valid values: 1, 2, 4, 8 (see http://www.khronos.org/opengles/sdk/docs/man/xhtml/glPixelStorei.xml)\n\n\t\tthis.colorSpace = colorSpace;\n\n\t\tthis.userData = {};\n\n\t\tthis.version = 0;\n\t\tthis.onUpdate = null;\n\n\t\tthis.isRenderTargetTexture = false; // indicates whether a texture belongs to a render target or not\n\t\tthis.pmremVersion = 0; // indicates whether this texture should be processed by PMREMGenerator or not (only relevant for render target textures)\n\n\t}\n\n\tget image() {\n\n\t\treturn this.source.data;\n\n\t}\n\n\tset image( value = null ) {\n\n\t\tthis.source.data = value;\n\n\t}\n\n\tupdateMatrix() {\n\n\t\tthis.matrix.setUvTransform( this.offset.x, this.offset.y, this.repeat.x, this.repeat.y, this.rotation, this.center.x, this.center.y );\n\n\t}\n\n\tclone() {\n\n\t\treturn new this.constructor().copy( this );\n\n\t}\n\n\tcopy( source ) {\n\n\t\tthis.name = source.name;\n\n\t\tthis.source = source.source;\n\t\tthis.mipmaps = source.mipmaps.slice( 0 );\n\n\t\tthis.mapping = source.mapping;\n\t\tthis.channel = source.channel;\n\n\t\tthis.wrapS = source.wrapS;\n\t\tthis.wrapT = source.wrapT;\n\n\t\tthis.magFilter = source.magFilter;\n\t\tthis.minFilter = source.minFilter;\n\n\t\tthis.anisotropy = source.anisotropy;\n\n\t\tthis.format = source.format;\n\t\tthis.internalFormat = source.internalFormat;\n\t\tthis.type = source.type;\n\n\t\tthis.offset.copy( source.offset );\n\t\tthis.repeat.copy( source.repeat );\n\t\tthis.center.copy( source.center );\n\t\tthis.rotation = source.rotation;\n\n\t\tthis.matrixAutoUpdate = source.matrixAutoUpdate;\n\t\tthis.matrix.copy( source.matrix );\n\n\t\tthis.generateMipmaps = source.generateMipmaps;\n\t\tthis.premultiplyAlpha = source.premultiplyAlpha;\n\t\tthis.flipY = source.flipY;\n\t\tthis.unpackAlignment = source.unpackAlignment;\n\t\tthis.colorSpace = source.colorSpace;\n\n\t\tthis.userData = JSON.parse( JSON.stringify( source.userData ) );\n\n\t\tthis.needsUpdate = true;\n\n\t\treturn this;\n\n\t}\n\n\ttoJSON( meta ) {\n\n\t\tconst isRootObject = ( meta === undefined || typeof meta === 'string' );\n\n\t\tif ( ! isRootObject && meta.textures[ this.uuid ] !== undefined ) {\n\n\t\t\treturn meta.textures[ this.uuid ];\n\n\t\t}\n\n\t\tconst output = {\n\n\t\t\tmetadata: {\n\t\t\t\tversion: 4.6,\n\t\t\t\ttype: 'Texture',\n\t\t\t\tgenerator: 'Texture.toJSON'\n\t\t\t},\n\n\t\t\tuuid: this.uuid,\n\t\t\tname: this.name,\n\n\t\t\timage: this.source.toJSON( meta ).uuid,\n\n\t\t\tmapping: this.mapping,\n\t\t\tchannel: this.channel,\n\n\t\t\trepeat: [ this.repeat.x, this.repeat.y ],\n\t\t\toffset: [ this.offset.x, this.offset.y ],\n\t\t\tcenter: [ this.center.x, this.center.y ],\n\t\t\trotation: this.rotation,\n\n\t\t\twrap: [ this.wrapS, this.wrapT ],\n\n\t\t\tformat: this.format,\n\t\t\tinternalFormat: this.internalFormat,\n\t\t\ttype: this.type,\n\t\t\tcolorSpace: this.colorSpace,\n\n\t\t\tminFilter: this.minFilter,\n\t\t\tmagFilter: this.magFilter,\n\t\t\tanisotropy: this.anisotropy,\n\n\t\t\tflipY: this.flipY,\n\n\t\t\tgenerateMipmaps: this.generateMipmaps,\n\t\t\tpremultiplyAlpha: this.premultiplyAlpha,\n\t\t\tunpackAlignment: this.unpackAlignment\n\n\t\t};\n\n\t\tif ( Object.keys( this.userData ).length > 0 ) output.userData = this.userData;\n\n\t\tif ( ! isRootObject ) {\n\n\t\t\tmeta.textures[ this.uuid ] = output;\n\n\t\t}\n\n\t\treturn output;\n\n\t}\n\n\tdispose() {\n\n\t\tthis.dispatchEvent( { type: 'dispose' } );\n\n\t}\n\n\ttransformUv( uv ) {\n\n\t\tif ( this.mapping !== UVMapping ) return uv;\n\n\t\tuv.applyMatrix3( this.matrix );\n\n\t\tif ( uv.x < 0 || uv.x > 1 ) {\n\n\t\t\tswitch ( this.wrapS ) {\n\n\t\t\t\tcase RepeatWrapping:\n\n\t\t\t\t\tuv.x = uv.x - Math.floor( uv.x );\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase ClampToEdgeWrapping:\n\n\t\t\t\t\tuv.x = uv.x < 0 ? 0 : 1;\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase MirroredRepeatWrapping:\n\n\t\t\t\t\tif ( Math.abs( Math.floor( uv.x ) % 2 ) === 1 ) {\n\n\t\t\t\t\t\tuv.x = Math.ceil( uv.x ) - uv.x;\n\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\tuv.x = uv.x - Math.floor( uv.x );\n\n\t\t\t\t\t}\n\n\t\t\t\t\tbreak;\n\n\t\t\t}\n\n\t\t}\n\n\t\tif ( uv.y < 0 || uv.y > 1 ) {\n\n\t\t\tswitch ( this.wrapT ) {\n\n\t\t\t\tcase RepeatWrapping:\n\n\t\t\t\t\tuv.y = uv.y - Math.floor( uv.y );\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase ClampToEdgeWrapping:\n\n\t\t\t\t\tuv.y = uv.y < 0 ? 0 : 1;\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase MirroredRepeatWrapping:\n\n\t\t\t\t\tif ( Math.abs( Math.floor( uv.y ) % 2 ) === 1 ) {\n\n\t\t\t\t\t\tuv.y = Math.ceil( uv.y ) - uv.y;\n\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\tuv.y = uv.y - Math.floor( uv.y );\n\n\t\t\t\t\t}\n\n\t\t\t\t\tbreak;\n\n\t\t\t}\n\n\t\t}\n\n\t\tif ( this.flipY ) {\n\n\t\t\tuv.y = 1 - uv.y;\n\n\t\t}\n\n\t\treturn uv;\n\n\t}\n\n\tset needsUpdate( value ) {\n\n\t\tif ( value === true ) {\n\n\t\t\tthis.version ++;\n\t\t\tthis.source.needsUpdate = true;\n\n\t\t}\n\n\t}\n\n\tset needsPMREMUpdate( value ) {\n\n\t\tif ( value === true ) {\n\n\t\t\tthis.pmremVersion ++;\n\n\t\t}\n\n\t}\n\n}\n\nTexture.DEFAULT_IMAGE = null;\nTexture.DEFAULT_MAPPING = UVMapping;\nTexture.DEFAULT_ANISOTROPY = 1;\n\nclass Vector4 {\n\n\tconstructor( x = 0, y = 0, z = 0, w = 1 ) {\n\n\t\tVector4.prototype.isVector4 = true;\n\n\t\tthis.x = x;\n\t\tthis.y = y;\n\t\tthis.z = z;\n\t\tthis.w = w;\n\n\t}\n\n\tget width() {\n\n\t\treturn this.z;\n\n\t}\n\n\tset width( value ) {\n\n\t\tthis.z = value;\n\n\t}\n\n\tget height() {\n\n\t\treturn this.w;\n\n\t}\n\n\tset height( value ) {\n\n\t\tthis.w = value;\n\n\t}\n\n\tset( x, y, z, w ) {\n\n\t\tthis.x = x;\n\t\tthis.y = y;\n\t\tthis.z = z;\n\t\tthis.w = w;\n\n\t\treturn this;\n\n\t}\n\n\tsetScalar( scalar ) {\n\n\t\tthis.x = scalar;\n\t\tthis.y = scalar;\n\t\tthis.z = scalar;\n\t\tthis.w = scalar;\n\n\t\treturn this;\n\n\t}\n\n\tsetX( x ) {\n\n\t\tthis.x = x;\n\n\t\treturn this;\n\n\t}\n\n\tsetY( y ) {\n\n\t\tthis.y = y;\n\n\t\treturn this;\n\n\t}\n\n\tsetZ( z ) {\n\n\t\tthis.z = z;\n\n\t\treturn this;\n\n\t}\n\n\tsetW( w ) {\n\n\t\tthis.w = w;\n\n\t\treturn this;\n\n\t}\n\n\tsetComponent( index, value ) {\n\n\t\tswitch ( index ) {\n\n\t\t\tcase 0: this.x = value; break;\n\t\t\tcase 1: this.y = value; break;\n\t\t\tcase 2: this.z = value; break;\n\t\t\tcase 3: this.w = value; break;\n\t\t\tdefault: throw new Error( 'index is out of range: ' + index );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tgetComponent( index ) {\n\n\t\tswitch ( index ) {\n\n\t\t\tcase 0: return this.x;\n\t\t\tcase 1: return this.y;\n\t\t\tcase 2: return this.z;\n\t\t\tcase 3: return this.w;\n\t\t\tdefault: throw new Error( 'index is out of range: ' + index );\n\n\t\t}\n\n\t}\n\n\tclone() {\n\n\t\treturn new this.constructor( this.x, this.y, this.z, this.w );\n\n\t}\n\n\tcopy( v ) {\n\n\t\tthis.x = v.x;\n\t\tthis.y = v.y;\n\t\tthis.z = v.z;\n\t\tthis.w = ( v.w !== undefined ) ? v.w : 1;\n\n\t\treturn this;\n\n\t}\n\n\tadd( v ) {\n\n\t\tthis.x += v.x;\n\t\tthis.y += v.y;\n\t\tthis.z += v.z;\n\t\tthis.w += v.w;\n\n\t\treturn this;\n\n\t}\n\n\taddScalar( s ) {\n\n\t\tthis.x += s;\n\t\tthis.y += s;\n\t\tthis.z += s;\n\t\tthis.w += s;\n\n\t\treturn this;\n\n\t}\n\n\taddVectors( a, b ) {\n\n\t\tthis.x = a.x + b.x;\n\t\tthis.y = a.y + b.y;\n\t\tthis.z = a.z + b.z;\n\t\tthis.w = a.w + b.w;\n\n\t\treturn this;\n\n\t}\n\n\taddScaledVector( v, s ) {\n\n\t\tthis.x += v.x * s;\n\t\tthis.y += v.y * s;\n\t\tthis.z += v.z * s;\n\t\tthis.w += v.w * s;\n\n\t\treturn this;\n\n\t}\n\n\tsub( v ) {\n\n\t\tthis.x -= v.x;\n\t\tthis.y -= v.y;\n\t\tthis.z -= v.z;\n\t\tthis.w -= v.w;\n\n\t\treturn this;\n\n\t}\n\n\tsubScalar( s ) {\n\n\t\tthis.x -= s;\n\t\tthis.y -= s;\n\t\tthis.z -= s;\n\t\tthis.w -= s;\n\n\t\treturn this;\n\n\t}\n\n\tsubVectors( a, b ) {\n\n\t\tthis.x = a.x - b.x;\n\t\tthis.y = a.y - b.y;\n\t\tthis.z = a.z - b.z;\n\t\tthis.w = a.w - b.w;\n\n\t\treturn this;\n\n\t}\n\n\tmultiply( v ) {\n\n\t\tthis.x *= v.x;\n\t\tthis.y *= v.y;\n\t\tthis.z *= v.z;\n\t\tthis.w *= v.w;\n\n\t\treturn this;\n\n\t}\n\n\tmultiplyScalar( scalar ) {\n\n\t\tthis.x *= scalar;\n\t\tthis.y *= scalar;\n\t\tthis.z *= scalar;\n\t\tthis.w *= scalar;\n\n\t\treturn this;\n\n\t}\n\n\tapplyMatrix4( m ) {\n\n\t\tconst x = this.x, y = this.y, z = this.z, w = this.w;\n\t\tconst e = m.elements;\n\n\t\tthis.x = e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z + e[ 12 ] * w;\n\t\tthis.y = e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z + e[ 13 ] * w;\n\t\tthis.z = e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z + e[ 14 ] * w;\n\t\tthis.w = e[ 3 ] * x + e[ 7 ] * y + e[ 11 ] * z + e[ 15 ] * w;\n\n\t\treturn this;\n\n\t}\n\n\tdivideScalar( scalar ) {\n\n\t\treturn this.multiplyScalar( 1 / scalar );\n\n\t}\n\n\tsetAxisAngleFromQuaternion( q ) {\n\n\t\t// http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToAngle/index.htm\n\n\t\t// q is assumed to be normalized\n\n\t\tthis.w = 2 * Math.acos( q.w );\n\n\t\tconst s = Math.sqrt( 1 - q.w * q.w );\n\n\t\tif ( s < 0.0001 ) {\n\n\t\t\tthis.x = 1;\n\t\t\tthis.y = 0;\n\t\t\tthis.z = 0;\n\n\t\t} else {\n\n\t\t\tthis.x = q.x / s;\n\t\t\tthis.y = q.y / s;\n\t\t\tthis.z = q.z / s;\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tsetAxisAngleFromRotationMatrix( m ) {\n\n\t\t// http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToAngle/index.htm\n\n\t\t// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)\n\n\t\tlet angle, x, y, z; // variables for result\n\t\tconst epsilon = 0.01,\t\t// margin to allow for rounding errors\n\t\t\tepsilon2 = 0.1,\t\t// margin to distinguish between 0 and 180 degrees\n\n\t\t\tte = m.elements,\n\n\t\t\tm11 = te[ 0 ], m12 = te[ 4 ], m13 = te[ 8 ],\n\t\t\tm21 = te[ 1 ], m22 = te[ 5 ], m23 = te[ 9 ],\n\t\t\tm31 = te[ 2 ], m32 = te[ 6 ], m33 = te[ 10 ];\n\n\t\tif ( ( Math.abs( m12 - m21 ) < epsilon ) &&\n\t\t ( Math.abs( m13 - m31 ) < epsilon ) &&\n\t\t ( Math.abs( m23 - m32 ) < epsilon ) ) {\n\n\t\t\t// singularity found\n\t\t\t// first check for identity matrix which must have +1 for all terms\n\t\t\t// in leading diagonal and zero in other terms\n\n\t\t\tif ( ( Math.abs( m12 + m21 ) < epsilon2 ) &&\n\t\t\t ( Math.abs( m13 + m31 ) < epsilon2 ) &&\n\t\t\t ( Math.abs( m23 + m32 ) < epsilon2 ) &&\n\t\t\t ( Math.abs( m11 + m22 + m33 - 3 ) < epsilon2 ) ) {\n\n\t\t\t\t// this singularity is identity matrix so angle = 0\n\n\t\t\t\tthis.set( 1, 0, 0, 0 );\n\n\t\t\t\treturn this; // zero angle, arbitrary axis\n\n\t\t\t}\n\n\t\t\t// otherwise this singularity is angle = 180\n\n\t\t\tangle = Math.PI;\n\n\t\t\tconst xx = ( m11 + 1 ) / 2;\n\t\t\tconst yy = ( m22 + 1 ) / 2;\n\t\t\tconst zz = ( m33 + 1 ) / 2;\n\t\t\tconst xy = ( m12 + m21 ) / 4;\n\t\t\tconst xz = ( m13 + m31 ) / 4;\n\t\t\tconst yz = ( m23 + m32 ) / 4;\n\n\t\t\tif ( ( xx > yy ) && ( xx > zz ) ) {\n\n\t\t\t\t// m11 is the largest diagonal term\n\n\t\t\t\tif ( xx < epsilon ) {\n\n\t\t\t\t\tx = 0;\n\t\t\t\t\ty = 0.707106781;\n\t\t\t\t\tz = 0.707106781;\n\n\t\t\t\t} else {\n\n\t\t\t\t\tx = Math.sqrt( xx );\n\t\t\t\t\ty = xy / x;\n\t\t\t\t\tz = xz / x;\n\n\t\t\t\t}\n\n\t\t\t} else if ( yy > zz ) {\n\n\t\t\t\t// m22 is the largest diagonal term\n\n\t\t\t\tif ( yy < epsilon ) {\n\n\t\t\t\t\tx = 0.707106781;\n\t\t\t\t\ty = 0;\n\t\t\t\t\tz = 0.707106781;\n\n\t\t\t\t} else {\n\n\t\t\t\t\ty = Math.sqrt( yy );\n\t\t\t\t\tx = xy / y;\n\t\t\t\t\tz = yz / y;\n\n\t\t\t\t}\n\n\t\t\t} else {\n\n\t\t\t\t// m33 is the largest diagonal term so base result on this\n\n\t\t\t\tif ( zz < epsilon ) {\n\n\t\t\t\t\tx = 0.707106781;\n\t\t\t\t\ty = 0.707106781;\n\t\t\t\t\tz = 0;\n\n\t\t\t\t} else {\n\n\t\t\t\t\tz = Math.sqrt( zz );\n\t\t\t\t\tx = xz / z;\n\t\t\t\t\ty = yz / z;\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tthis.set( x, y, z, angle );\n\n\t\t\treturn this; // return 180 deg rotation\n\n\t\t}\n\n\t\t// as we have reached here there are no singularities so we can handle normally\n\n\t\tlet s = Math.sqrt( ( m32 - m23 ) * ( m32 - m23 ) +\n\t\t\t( m13 - m31 ) * ( m13 - m31 ) +\n\t\t\t( m21 - m12 ) * ( m21 - m12 ) ); // used to normalize\n\n\t\tif ( Math.abs( s ) < 0.001 ) s = 1;\n\n\t\t// prevent divide by zero, should not happen if matrix is orthogonal and should be\n\t\t// caught by singularity test above, but I've left it in just in case\n\n\t\tthis.x = ( m32 - m23 ) / s;\n\t\tthis.y = ( m13 - m31 ) / s;\n\t\tthis.z = ( m21 - m12 ) / s;\n\t\tthis.w = Math.acos( ( m11 + m22 + m33 - 1 ) / 2 );\n\n\t\treturn this;\n\n\t}\n\n\tmin( v ) {\n\n\t\tthis.x = Math.min( this.x, v.x );\n\t\tthis.y = Math.min( this.y, v.y );\n\t\tthis.z = Math.min( this.z, v.z );\n\t\tthis.w = Math.min( this.w, v.w );\n\n\t\treturn this;\n\n\t}\n\n\tmax( v ) {\n\n\t\tthis.x = Math.max( this.x, v.x );\n\t\tthis.y = Math.max( this.y, v.y );\n\t\tthis.z = Math.max( this.z, v.z );\n\t\tthis.w = Math.max( this.w, v.w );\n\n\t\treturn this;\n\n\t}\n\n\tclamp( min, max ) {\n\n\t\t// assumes min < max, componentwise\n\n\t\tthis.x = Math.max( min.x, Math.min( max.x, this.x ) );\n\t\tthis.y = Math.max( min.y, Math.min( max.y, this.y ) );\n\t\tthis.z = Math.max( min.z, Math.min( max.z, this.z ) );\n\t\tthis.w = Math.max( min.w, Math.min( max.w, this.w ) );\n\n\t\treturn this;\n\n\t}\n\n\tclampScalar( minVal, maxVal ) {\n\n\t\tthis.x = Math.max( minVal, Math.min( maxVal, this.x ) );\n\t\tthis.y = Math.max( minVal, Math.min( maxVal, this.y ) );\n\t\tthis.z = Math.max( minVal, Math.min( maxVal, this.z ) );\n\t\tthis.w = Math.max( minVal, Math.min( maxVal, this.w ) );\n\n\t\treturn this;\n\n\t}\n\n\tclampLength( min, max ) {\n\n\t\tconst length = this.length();\n\n\t\treturn this.divideScalar( length || 1 ).multiplyScalar( Math.max( min, Math.min( max, length ) ) );\n\n\t}\n\n\tfloor() {\n\n\t\tthis.x = Math.floor( this.x );\n\t\tthis.y = Math.floor( this.y );\n\t\tthis.z = Math.floor( this.z );\n\t\tthis.w = Math.floor( this.w );\n\n\t\treturn this;\n\n\t}\n\n\tceil() {\n\n\t\tthis.x = Math.ceil( this.x );\n\t\tthis.y = Math.ceil( this.y );\n\t\tthis.z = Math.ceil( this.z );\n\t\tthis.w = Math.ceil( this.w );\n\n\t\treturn this;\n\n\t}\n\n\tround() {\n\n\t\tthis.x = Math.round( this.x );\n\t\tthis.y = Math.round( this.y );\n\t\tthis.z = Math.round( this.z );\n\t\tthis.w = Math.round( this.w );\n\n\t\treturn this;\n\n\t}\n\n\troundToZero() {\n\n\t\tthis.x = Math.trunc( this.x );\n\t\tthis.y = Math.trunc( this.y );\n\t\tthis.z = Math.trunc( this.z );\n\t\tthis.w = Math.trunc( this.w );\n\n\t\treturn this;\n\n\t}\n\n\tnegate() {\n\n\t\tthis.x = - this.x;\n\t\tthis.y = - this.y;\n\t\tthis.z = - this.z;\n\t\tthis.w = - this.w;\n\n\t\treturn this;\n\n\t}\n\n\tdot( v ) {\n\n\t\treturn this.x * v.x + this.y * v.y + this.z * v.z + this.w * v.w;\n\n\t}\n\n\tlengthSq() {\n\n\t\treturn this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w;\n\n\t}\n\n\tlength() {\n\n\t\treturn Math.sqrt( this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w );\n\n\t}\n\n\tmanhattanLength() {\n\n\t\treturn Math.abs( this.x ) + Math.abs( this.y ) + Math.abs( this.z ) + Math.abs( this.w );\n\n\t}\n\n\tnormalize() {\n\n\t\treturn this.divideScalar( this.length() || 1 );\n\n\t}\n\n\tsetLength( length ) {\n\n\t\treturn this.normalize().multiplyScalar( length );\n\n\t}\n\n\tlerp( v, alpha ) {\n\n\t\tthis.x += ( v.x - this.x ) * alpha;\n\t\tthis.y += ( v.y - this.y ) * alpha;\n\t\tthis.z += ( v.z - this.z ) * alpha;\n\t\tthis.w += ( v.w - this.w ) * alpha;\n\n\t\treturn this;\n\n\t}\n\n\tlerpVectors( v1, v2, alpha ) {\n\n\t\tthis.x = v1.x + ( v2.x - v1.x ) * alpha;\n\t\tthis.y = v1.y + ( v2.y - v1.y ) * alpha;\n\t\tthis.z = v1.z + ( v2.z - v1.z ) * alpha;\n\t\tthis.w = v1.w + ( v2.w - v1.w ) * alpha;\n\n\t\treturn this;\n\n\t}\n\n\tequals( v ) {\n\n\t\treturn ( ( v.x === this.x ) && ( v.y === this.y ) && ( v.z === this.z ) && ( v.w === this.w ) );\n\n\t}\n\n\tfromArray( array, offset = 0 ) {\n\n\t\tthis.x = array[ offset ];\n\t\tthis.y = array[ offset + 1 ];\n\t\tthis.z = array[ offset + 2 ];\n\t\tthis.w = array[ offset + 3 ];\n\n\t\treturn this;\n\n\t}\n\n\ttoArray( array = [], offset = 0 ) {\n\n\t\tarray[ offset ] = this.x;\n\t\tarray[ offset + 1 ] = this.y;\n\t\tarray[ offset + 2 ] = this.z;\n\t\tarray[ offset + 3 ] = this.w;\n\n\t\treturn array;\n\n\t}\n\n\tfromBufferAttribute( attribute, index ) {\n\n\t\tthis.x = attribute.getX( index );\n\t\tthis.y = attribute.getY( index );\n\t\tthis.z = attribute.getZ( index );\n\t\tthis.w = attribute.getW( index );\n\n\t\treturn this;\n\n\t}\n\n\trandom() {\n\n\t\tthis.x = Math.random();\n\t\tthis.y = Math.random();\n\t\tthis.z = Math.random();\n\t\tthis.w = Math.random();\n\n\t\treturn this;\n\n\t}\n\n\t*[ Symbol.iterator ]() {\n\n\t\tyield this.x;\n\t\tyield this.y;\n\t\tyield this.z;\n\t\tyield this.w;\n\n\t}\n\n}\n\n/*\n In options, we can specify:\n * Texture parameters for an auto-generated target texture\n * depthBuffer/stencilBuffer: Booleans to indicate if we should generate these buffers\n*/\nclass RenderTarget extends EventDispatcher {\n\n\tconstructor( width = 1, height = 1, options = {} ) {\n\n\t\tsuper();\n\n\t\tthis.isRenderTarget = true;\n\n\t\tthis.width = width;\n\t\tthis.height = height;\n\t\tthis.depth = 1;\n\n\t\tthis.scissor = new Vector4( 0, 0, width, height );\n\t\tthis.scissorTest = false;\n\n\t\tthis.viewport = new Vector4( 0, 0, width, height );\n\n\t\tconst image = { width: width, height: height, depth: 1 };\n\n\t\toptions = Object.assign( {\n\t\t\tgenerateMipmaps: false,\n\t\t\tinternalFormat: null,\n\t\t\tminFilter: LinearFilter,\n\t\t\tdepthBuffer: true,\n\t\t\tstencilBuffer: false,\n\t\t\tdepthTexture: null,\n\t\t\tsamples: 0,\n\t\t\tcount: 1\n\t\t}, options );\n\n\t\tconst texture = new Texture( image, options.mapping, options.wrapS, options.wrapT, options.magFilter, options.minFilter, options.format, options.type, options.anisotropy, options.colorSpace );\n\n\t\ttexture.flipY = false;\n\t\ttexture.generateMipmaps = options.generateMipmaps;\n\t\ttexture.internalFormat = options.internalFormat;\n\n\t\tthis.textures = [];\n\n\t\tconst count = options.count;\n\t\tfor ( let i = 0; i < count; i ++ ) {\n\n\t\t\tthis.textures[ i ] = texture.clone();\n\t\t\tthis.textures[ i ].isRenderTargetTexture = true;\n\n\t\t}\n\n\t\tthis.depthBuffer = options.depthBuffer;\n\t\tthis.stencilBuffer = options.stencilBuffer;\n\n\t\tthis.depthTexture = options.depthTexture;\n\n\t\tthis.samples = options.samples;\n\n\t}\n\n\tget texture() {\n\n\t\treturn this.textures[ 0 ];\n\n\t}\n\n\tset texture( value ) {\n\n\t\tthis.textures[ 0 ] = value;\n\n\t}\n\n\tsetSize( width, height, depth = 1 ) {\n\n\t\tif ( this.width !== width || this.height !== height || this.depth !== depth ) {\n\n\t\t\tthis.width = width;\n\t\t\tthis.height = height;\n\t\t\tthis.depth = depth;\n\n\t\t\tfor ( let i = 0, il = this.textures.length; i < il; i ++ ) {\n\n\t\t\t\tthis.textures[ i ].image.width = width;\n\t\t\t\tthis.textures[ i ].image.height = height;\n\t\t\t\tthis.textures[ i ].image.depth = depth;\n\n\t\t\t}\n\n\t\t\tthis.dispose();\n\n\t\t}\n\n\t\tthis.viewport.set( 0, 0, width, height );\n\t\tthis.scissor.set( 0, 0, width, height );\n\n\t}\n\n\tclone() {\n\n\t\treturn new this.constructor().copy( this );\n\n\t}\n\n\tcopy( source ) {\n\n\t\tthis.width = source.width;\n\t\tthis.height = source.height;\n\t\tthis.depth = source.depth;\n\n\t\tthis.scissor.copy( source.scissor );\n\t\tthis.scissorTest = source.scissorTest;\n\n\t\tthis.viewport.copy( source.viewport );\n\n\t\tthis.textures.length = 0;\n\n\t\tfor ( let i = 0, il = source.textures.length; i < il; i ++ ) {\n\n\t\t\tthis.textures[ i ] = source.textures[ i ].clone();\n\t\t\tthis.textures[ i ].isRenderTargetTexture = true;\n\n\t\t}\n\n\t\t// ensure image object is not shared, see #20328\n\n\t\tconst image = Object.assign( {}, source.texture.image );\n\t\tthis.texture.source = new Source( image );\n\n\t\tthis.depthBuffer = source.depthBuffer;\n\t\tthis.stencilBuffer = source.stencilBuffer;\n\n\t\tif ( source.depthTexture !== null ) this.depthTexture = source.depthTexture.clone();\n\n\t\tthis.samples = source.samples;\n\n\t\treturn this;\n\n\t}\n\n\tdispose() {\n\n\t\tthis.dispatchEvent( { type: 'dispose' } );\n\n\t}\n\n}\n\nclass WebGLRenderTarget extends RenderTarget {\n\n\tconstructor( width = 1, height = 1, options = {} ) {\n\n\t\tsuper( width, height, options );\n\n\t\tthis.isWebGLRenderTarget = true;\n\n\t}\n\n}\n\nclass DataArrayTexture extends Texture {\n\n\tconstructor( data = null, width = 1, height = 1, depth = 1 ) {\n\n\t\tsuper( null );\n\n\t\tthis.isDataArrayTexture = true;\n\n\t\tthis.image = { data, width, height, depth };\n\n\t\tthis.magFilter = NearestFilter;\n\t\tthis.minFilter = NearestFilter;\n\n\t\tthis.wrapR = ClampToEdgeWrapping;\n\n\t\tthis.generateMipmaps = false;\n\t\tthis.flipY = false;\n\t\tthis.unpackAlignment = 1;\n\n\t}\n\n}\n\nclass WebGLArrayRenderTarget extends WebGLRenderTarget {\n\n\tconstructor( width = 1, height = 1, depth = 1, options = {} ) {\n\n\t\tsuper( width, height, options );\n\n\t\tthis.isWebGLArrayRenderTarget = true;\n\n\t\tthis.depth = depth;\n\n\t\tthis.texture = new DataArrayTexture( null, width, height, depth );\n\n\t\tthis.texture.isRenderTargetTexture = true;\n\n\t}\n\n}\n\nclass Data3DTexture extends Texture {\n\n\tconstructor( data = null, width = 1, height = 1, depth = 1 ) {\n\n\t\t// We're going to add .setXXX() methods for setting properties later.\n\t\t// Users can still set in DataTexture3D directly.\n\t\t//\n\t\t//\tconst texture = new THREE.DataTexture3D( data, width, height, depth );\n\t\t// \ttexture.anisotropy = 16;\n\t\t//\n\t\t// See #14839\n\n\t\tsuper( null );\n\n\t\tthis.isData3DTexture = true;\n\n\t\tthis.image = { data, width, height, depth };\n\n\t\tthis.magFilter = NearestFilter;\n\t\tthis.minFilter = NearestFilter;\n\n\t\tthis.wrapR = ClampToEdgeWrapping;\n\n\t\tthis.generateMipmaps = false;\n\t\tthis.flipY = false;\n\t\tthis.unpackAlignment = 1;\n\n\t}\n\n}\n\nclass WebGL3DRenderTarget extends WebGLRenderTarget {\n\n\tconstructor( width = 1, height = 1, depth = 1, options = {} ) {\n\n\t\tsuper( width, height, options );\n\n\t\tthis.isWebGL3DRenderTarget = true;\n\n\t\tthis.depth = depth;\n\n\t\tthis.texture = new Data3DTexture( null, width, height, depth );\n\n\t\tthis.texture.isRenderTargetTexture = true;\n\n\t}\n\n}\n\nclass Quaternion {\n\n\tconstructor( x = 0, y = 0, z = 0, w = 1 ) {\n\n\t\tthis.isQuaternion = true;\n\n\t\tthis._x = x;\n\t\tthis._y = y;\n\t\tthis._z = z;\n\t\tthis._w = w;\n\n\t}\n\n\tstatic slerpFlat( dst, dstOffset, src0, srcOffset0, src1, srcOffset1, t ) {\n\n\t\t// fuzz-free, array-based Quaternion SLERP operation\n\n\t\tlet x0 = src0[ srcOffset0 + 0 ],\n\t\t\ty0 = src0[ srcOffset0 + 1 ],\n\t\t\tz0 = src0[ srcOffset0 + 2 ],\n\t\t\tw0 = src0[ srcOffset0 + 3 ];\n\n\t\tconst x1 = src1[ srcOffset1 + 0 ],\n\t\t\ty1 = src1[ srcOffset1 + 1 ],\n\t\t\tz1 = src1[ srcOffset1 + 2 ],\n\t\t\tw1 = src1[ srcOffset1 + 3 ];\n\n\t\tif ( t === 0 ) {\n\n\t\t\tdst[ dstOffset + 0 ] = x0;\n\t\t\tdst[ dstOffset + 1 ] = y0;\n\t\t\tdst[ dstOffset + 2 ] = z0;\n\t\t\tdst[ dstOffset + 3 ] = w0;\n\t\t\treturn;\n\n\t\t}\n\n\t\tif ( t === 1 ) {\n\n\t\t\tdst[ dstOffset + 0 ] = x1;\n\t\t\tdst[ dstOffset + 1 ] = y1;\n\t\t\tdst[ dstOffset + 2 ] = z1;\n\t\t\tdst[ dstOffset + 3 ] = w1;\n\t\t\treturn;\n\n\t\t}\n\n\t\tif ( w0 !== w1 || x0 !== x1 || y0 !== y1 || z0 !== z1 ) {\n\n\t\t\tlet s = 1 - t;\n\t\t\tconst cos = x0 * x1 + y0 * y1 + z0 * z1 + w0 * w1,\n\t\t\t\tdir = ( cos >= 0 ? 1 : - 1 ),\n\t\t\t\tsqrSin = 1 - cos * cos;\n\n\t\t\t// Skip the Slerp for tiny steps to avoid numeric problems:\n\t\t\tif ( sqrSin > Number.EPSILON ) {\n\n\t\t\t\tconst sin = Math.sqrt( sqrSin ),\n\t\t\t\t\tlen = Math.atan2( sin, cos * dir );\n\n\t\t\t\ts = Math.sin( s * len ) / sin;\n\t\t\t\tt = Math.sin( t * len ) / sin;\n\n\t\t\t}\n\n\t\t\tconst tDir = t * dir;\n\n\t\t\tx0 = x0 * s + x1 * tDir;\n\t\t\ty0 = y0 * s + y1 * tDir;\n\t\t\tz0 = z0 * s + z1 * tDir;\n\t\t\tw0 = w0 * s + w1 * tDir;\n\n\t\t\t// Normalize in case we just did a lerp:\n\t\t\tif ( s === 1 - t ) {\n\n\t\t\t\tconst f = 1 / Math.sqrt( x0 * x0 + y0 * y0 + z0 * z0 + w0 * w0 );\n\n\t\t\t\tx0 *= f;\n\t\t\t\ty0 *= f;\n\t\t\t\tz0 *= f;\n\t\t\t\tw0 *= f;\n\n\t\t\t}\n\n\t\t}\n\n\t\tdst[ dstOffset ] = x0;\n\t\tdst[ dstOffset + 1 ] = y0;\n\t\tdst[ dstOffset + 2 ] = z0;\n\t\tdst[ dstOffset + 3 ] = w0;\n\n\t}\n\n\tstatic multiplyQuaternionsFlat( dst, dstOffset, src0, srcOffset0, src1, srcOffset1 ) {\n\n\t\tconst x0 = src0[ srcOffset0 ];\n\t\tconst y0 = src0[ srcOffset0 + 1 ];\n\t\tconst z0 = src0[ srcOffset0 + 2 ];\n\t\tconst w0 = src0[ srcOffset0 + 3 ];\n\n\t\tconst x1 = src1[ srcOffset1 ];\n\t\tconst y1 = src1[ srcOffset1 + 1 ];\n\t\tconst z1 = src1[ srcOffset1 + 2 ];\n\t\tconst w1 = src1[ srcOffset1 + 3 ];\n\n\t\tdst[ dstOffset ] = x0 * w1 + w0 * x1 + y0 * z1 - z0 * y1;\n\t\tdst[ dstOffset + 1 ] = y0 * w1 + w0 * y1 + z0 * x1 - x0 * z1;\n\t\tdst[ dstOffset + 2 ] = z0 * w1 + w0 * z1 + x0 * y1 - y0 * x1;\n\t\tdst[ dstOffset + 3 ] = w0 * w1 - x0 * x1 - y0 * y1 - z0 * z1;\n\n\t\treturn dst;\n\n\t}\n\n\tget x() {\n\n\t\treturn this._x;\n\n\t}\n\n\tset x( value ) {\n\n\t\tthis._x = value;\n\t\tthis._onChangeCallback();\n\n\t}\n\n\tget y() {\n\n\t\treturn this._y;\n\n\t}\n\n\tset y( value ) {\n\n\t\tthis._y = value;\n\t\tthis._onChangeCallback();\n\n\t}\n\n\tget z() {\n\n\t\treturn this._z;\n\n\t}\n\n\tset z( value ) {\n\n\t\tthis._z = value;\n\t\tthis._onChangeCallback();\n\n\t}\n\n\tget w() {\n\n\t\treturn this._w;\n\n\t}\n\n\tset w( value ) {\n\n\t\tthis._w = value;\n\t\tthis._onChangeCallback();\n\n\t}\n\n\tset( x, y, z, w ) {\n\n\t\tthis._x = x;\n\t\tthis._y = y;\n\t\tthis._z = z;\n\t\tthis._w = w;\n\n\t\tthis._onChangeCallback();\n\n\t\treturn this;\n\n\t}\n\n\tclone() {\n\n\t\treturn new this.constructor( this._x, this._y, this._z, this._w );\n\n\t}\n\n\tcopy( quaternion ) {\n\n\t\tthis._x = quaternion.x;\n\t\tthis._y = quaternion.y;\n\t\tthis._z = quaternion.z;\n\t\tthis._w = quaternion.w;\n\n\t\tthis._onChangeCallback();\n\n\t\treturn this;\n\n\t}\n\n\tsetFromEuler( euler, update = true ) {\n\n\t\tconst x = euler._x, y = euler._y, z = euler._z, order = euler._order;\n\n\t\t// http://www.mathworks.com/matlabcentral/fileexchange/\n\t\t// \t20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/\n\t\t//\tcontent/SpinCalc.m\n\n\t\tconst cos = Math.cos;\n\t\tconst sin = Math.sin;\n\n\t\tconst c1 = cos( x / 2 );\n\t\tconst c2 = cos( y / 2 );\n\t\tconst c3 = cos( z / 2 );\n\n\t\tconst s1 = sin( x / 2 );\n\t\tconst s2 = sin( y / 2 );\n\t\tconst s3 = sin( z / 2 );\n\n\t\tswitch ( order ) {\n\n\t\t\tcase 'XYZ':\n\t\t\t\tthis._x = s1 * c2 * c3 + c1 * s2 * s3;\n\t\t\t\tthis._y = c1 * s2 * c3 - s1 * c2 * s3;\n\t\t\t\tthis._z = c1 * c2 * s3 + s1 * s2 * c3;\n\t\t\t\tthis._w = c1 * c2 * c3 - s1 * s2 * s3;\n\t\t\t\tbreak;\n\n\t\t\tcase 'YXZ':\n\t\t\t\tthis._x = s1 * c2 * c3 + c1 * s2 * s3;\n\t\t\t\tthis._y = c1 * s2 * c3 - s1 * c2 * s3;\n\t\t\t\tthis._z = c1 * c2 * s3 - s1 * s2 * c3;\n\t\t\t\tthis._w = c1 * c2 * c3 + s1 * s2 * s3;\n\t\t\t\tbreak;\n\n\t\t\tcase 'ZXY':\n\t\t\t\tthis._x = s1 * c2 * c3 - c1 * s2 * s3;\n\t\t\t\tthis._y = c1 * s2 * c3 + s1 * c2 * s3;\n\t\t\t\tthis._z = c1 * c2 * s3 + s1 * s2 * c3;\n\t\t\t\tthis._w = c1 * c2 * c3 - s1 * s2 * s3;\n\t\t\t\tbreak;\n\n\t\t\tcase 'ZYX':\n\t\t\t\tthis._x = s1 * c2 * c3 - c1 * s2 * s3;\n\t\t\t\tthis._y = c1 * s2 * c3 + s1 * c2 * s3;\n\t\t\t\tthis._z = c1 * c2 * s3 - s1 * s2 * c3;\n\t\t\t\tthis._w = c1 * c2 * c3 + s1 * s2 * s3;\n\t\t\t\tbreak;\n\n\t\t\tcase 'YZX':\n\t\t\t\tthis._x = s1 * c2 * c3 + c1 * s2 * s3;\n\t\t\t\tthis._y = c1 * s2 * c3 + s1 * c2 * s3;\n\t\t\t\tthis._z = c1 * c2 * s3 - s1 * s2 * c3;\n\t\t\t\tthis._w = c1 * c2 * c3 - s1 * s2 * s3;\n\t\t\t\tbreak;\n\n\t\t\tcase 'XZY':\n\t\t\t\tthis._x = s1 * c2 * c3 - c1 * s2 * s3;\n\t\t\t\tthis._y = c1 * s2 * c3 - s1 * c2 * s3;\n\t\t\t\tthis._z = c1 * c2 * s3 + s1 * s2 * c3;\n\t\t\t\tthis._w = c1 * c2 * c3 + s1 * s2 * s3;\n\t\t\t\tbreak;\n\n\t\t\tdefault:\n\t\t\t\tconsole.warn( 'THREE.Quaternion: .setFromEuler() encountered an unknown order: ' + order );\n\n\t\t}\n\n\t\tif ( update === true ) this._onChangeCallback();\n\n\t\treturn this;\n\n\t}\n\n\tsetFromAxisAngle( axis, angle ) {\n\n\t\t// http://www.euclideanspace.com/maths/geometry/rotations/conversions/angleToQuaternion/index.htm\n\n\t\t// assumes axis is normalized\n\n\t\tconst halfAngle = angle / 2, s = Math.sin( halfAngle );\n\n\t\tthis._x = axis.x * s;\n\t\tthis._y = axis.y * s;\n\t\tthis._z = axis.z * s;\n\t\tthis._w = Math.cos( halfAngle );\n\n\t\tthis._onChangeCallback();\n\n\t\treturn this;\n\n\t}\n\n\tsetFromRotationMatrix( m ) {\n\n\t\t// http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm\n\n\t\t// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)\n\n\t\tconst te = m.elements,\n\n\t\t\tm11 = te[ 0 ], m12 = te[ 4 ], m13 = te[ 8 ],\n\t\t\tm21 = te[ 1 ], m22 = te[ 5 ], m23 = te[ 9 ],\n\t\t\tm31 = te[ 2 ], m32 = te[ 6 ], m33 = te[ 10 ],\n\n\t\t\ttrace = m11 + m22 + m33;\n\n\t\tif ( trace > 0 ) {\n\n\t\t\tconst s = 0.5 / Math.sqrt( trace + 1.0 );\n\n\t\t\tthis._w = 0.25 / s;\n\t\t\tthis._x = ( m32 - m23 ) * s;\n\t\t\tthis._y = ( m13 - m31 ) * s;\n\t\t\tthis._z = ( m21 - m12 ) * s;\n\n\t\t} else if ( m11 > m22 && m11 > m33 ) {\n\n\t\t\tconst s = 2.0 * Math.sqrt( 1.0 + m11 - m22 - m33 );\n\n\t\t\tthis._w = ( m32 - m23 ) / s;\n\t\t\tthis._x = 0.25 * s;\n\t\t\tthis._y = ( m12 + m21 ) / s;\n\t\t\tthis._z = ( m13 + m31 ) / s;\n\n\t\t} else if ( m22 > m33 ) {\n\n\t\t\tconst s = 2.0 * Math.sqrt( 1.0 + m22 - m11 - m33 );\n\n\t\t\tthis._w = ( m13 - m31 ) / s;\n\t\t\tthis._x = ( m12 + m21 ) / s;\n\t\t\tthis._y = 0.25 * s;\n\t\t\tthis._z = ( m23 + m32 ) / s;\n\n\t\t} else {\n\n\t\t\tconst s = 2.0 * Math.sqrt( 1.0 + m33 - m11 - m22 );\n\n\t\t\tthis._w = ( m21 - m12 ) / s;\n\t\t\tthis._x = ( m13 + m31 ) / s;\n\t\t\tthis._y = ( m23 + m32 ) / s;\n\t\t\tthis._z = 0.25 * s;\n\n\t\t}\n\n\t\tthis._onChangeCallback();\n\n\t\treturn this;\n\n\t}\n\n\tsetFromUnitVectors( vFrom, vTo ) {\n\n\t\t// assumes direction vectors vFrom and vTo are normalized\n\n\t\tlet r = vFrom.dot( vTo ) + 1;\n\n\t\tif ( r < Number.EPSILON ) {\n\n\t\t\t// vFrom and vTo point in opposite directions\n\n\t\t\tr = 0;\n\n\t\t\tif ( Math.abs( vFrom.x ) > Math.abs( vFrom.z ) ) {\n\n\t\t\t\tthis._x = - vFrom.y;\n\t\t\t\tthis._y = vFrom.x;\n\t\t\t\tthis._z = 0;\n\t\t\t\tthis._w = r;\n\n\t\t\t} else {\n\n\t\t\t\tthis._x = 0;\n\t\t\t\tthis._y = - vFrom.z;\n\t\t\t\tthis._z = vFrom.y;\n\t\t\t\tthis._w = r;\n\n\t\t\t}\n\n\t\t} else {\n\n\t\t\t// crossVectors( vFrom, vTo ); // inlined to avoid cyclic dependency on Vector3\n\n\t\t\tthis._x = vFrom.y * vTo.z - vFrom.z * vTo.y;\n\t\t\tthis._y = vFrom.z * vTo.x - vFrom.x * vTo.z;\n\t\t\tthis._z = vFrom.x * vTo.y - vFrom.y * vTo.x;\n\t\t\tthis._w = r;\n\n\t\t}\n\n\t\treturn this.normalize();\n\n\t}\n\n\tangleTo( q ) {\n\n\t\treturn 2 * Math.acos( Math.abs( clamp( this.dot( q ), - 1, 1 ) ) );\n\n\t}\n\n\trotateTowards( q, step ) {\n\n\t\tconst angle = this.angleTo( q );\n\n\t\tif ( angle === 0 ) return this;\n\n\t\tconst t = Math.min( 1, step / angle );\n\n\t\tthis.slerp( q, t );\n\n\t\treturn this;\n\n\t}\n\n\tidentity() {\n\n\t\treturn this.set( 0, 0, 0, 1 );\n\n\t}\n\n\tinvert() {\n\n\t\t// quaternion is assumed to have unit length\n\n\t\treturn this.conjugate();\n\n\t}\n\n\tconjugate() {\n\n\t\tthis._x *= - 1;\n\t\tthis._y *= - 1;\n\t\tthis._z *= - 1;\n\n\t\tthis._onChangeCallback();\n\n\t\treturn this;\n\n\t}\n\n\tdot( v ) {\n\n\t\treturn this._x * v._x + this._y * v._y + this._z * v._z + this._w * v._w;\n\n\t}\n\n\tlengthSq() {\n\n\t\treturn this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w;\n\n\t}\n\n\tlength() {\n\n\t\treturn Math.sqrt( this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w );\n\n\t}\n\n\tnormalize() {\n\n\t\tlet l = this.length();\n\n\t\tif ( l === 0 ) {\n\n\t\t\tthis._x = 0;\n\t\t\tthis._y = 0;\n\t\t\tthis._z = 0;\n\t\t\tthis._w = 1;\n\n\t\t} else {\n\n\t\t\tl = 1 / l;\n\n\t\t\tthis._x = this._x * l;\n\t\t\tthis._y = this._y * l;\n\t\t\tthis._z = this._z * l;\n\t\t\tthis._w = this._w * l;\n\n\t\t}\n\n\t\tthis._onChangeCallback();\n\n\t\treturn this;\n\n\t}\n\n\tmultiply( q ) {\n\n\t\treturn this.multiplyQuaternions( this, q );\n\n\t}\n\n\tpremultiply( q ) {\n\n\t\treturn this.multiplyQuaternions( q, this );\n\n\t}\n\n\tmultiplyQuaternions( a, b ) {\n\n\t\t// from http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/code/index.htm\n\n\t\tconst qax = a._x, qay = a._y, qaz = a._z, qaw = a._w;\n\t\tconst qbx = b._x, qby = b._y, qbz = b._z, qbw = b._w;\n\n\t\tthis._x = qax * qbw + qaw * qbx + qay * qbz - qaz * qby;\n\t\tthis._y = qay * qbw + qaw * qby + qaz * qbx - qax * qbz;\n\t\tthis._z = qaz * qbw + qaw * qbz + qax * qby - qay * qbx;\n\t\tthis._w = qaw * qbw - qax * qbx - qay * qby - qaz * qbz;\n\n\t\tthis._onChangeCallback();\n\n\t\treturn this;\n\n\t}\n\n\tslerp( qb, t ) {\n\n\t\tif ( t === 0 ) return this;\n\t\tif ( t === 1 ) return this.copy( qb );\n\n\t\tconst x = this._x, y = this._y, z = this._z, w = this._w;\n\n\t\t// http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/slerp/\n\n\t\tlet cosHalfTheta = w * qb._w + x * qb._x + y * qb._y + z * qb._z;\n\n\t\tif ( cosHalfTheta < 0 ) {\n\n\t\t\tthis._w = - qb._w;\n\t\t\tthis._x = - qb._x;\n\t\t\tthis._y = - qb._y;\n\t\t\tthis._z = - qb._z;\n\n\t\t\tcosHalfTheta = - cosHalfTheta;\n\n\t\t} else {\n\n\t\t\tthis.copy( qb );\n\n\t\t}\n\n\t\tif ( cosHalfTheta >= 1.0 ) {\n\n\t\t\tthis._w = w;\n\t\t\tthis._x = x;\n\t\t\tthis._y = y;\n\t\t\tthis._z = z;\n\n\t\t\treturn this;\n\n\t\t}\n\n\t\tconst sqrSinHalfTheta = 1.0 - cosHalfTheta * cosHalfTheta;\n\n\t\tif ( sqrSinHalfTheta <= Number.EPSILON ) {\n\n\t\t\tconst s = 1 - t;\n\t\t\tthis._w = s * w + t * this._w;\n\t\t\tthis._x = s * x + t * this._x;\n\t\t\tthis._y = s * y + t * this._y;\n\t\t\tthis._z = s * z + t * this._z;\n\n\t\t\tthis.normalize(); // normalize calls _onChangeCallback()\n\n\t\t\treturn this;\n\n\t\t}\n\n\t\tconst sinHalfTheta = Math.sqrt( sqrSinHalfTheta );\n\t\tconst halfTheta = Math.atan2( sinHalfTheta, cosHalfTheta );\n\t\tconst ratioA = Math.sin( ( 1 - t ) * halfTheta ) / sinHalfTheta,\n\t\t\tratioB = Math.sin( t * halfTheta ) / sinHalfTheta;\n\n\t\tthis._w = ( w * ratioA + this._w * ratioB );\n\t\tthis._x = ( x * ratioA + this._x * ratioB );\n\t\tthis._y = ( y * ratioA + this._y * ratioB );\n\t\tthis._z = ( z * ratioA + this._z * ratioB );\n\n\t\tthis._onChangeCallback();\n\n\t\treturn this;\n\n\t}\n\n\tslerpQuaternions( qa, qb, t ) {\n\n\t\treturn this.copy( qa ).slerp( qb, t );\n\n\t}\n\n\trandom() {\n\n\t\t// sets this quaternion to a uniform random unit quaternnion\n\n\t\t// Ken Shoemake\n\t\t// Uniform random rotations\n\t\t// D. Kirk, editor, Graphics Gems III, pages 124-132. Academic Press, New York, 1992.\n\n\t\tconst theta1 = 2 * Math.PI * Math.random();\n\t\tconst theta2 = 2 * Math.PI * Math.random();\n\n\t\tconst x0 = Math.random();\n\t\tconst r1 = Math.sqrt( 1 - x0 );\n\t\tconst r2 = Math.sqrt( x0 );\n\n\t\treturn this.set(\n\t\t\tr1 * Math.sin( theta1 ),\n\t\t\tr1 * Math.cos( theta1 ),\n\t\t\tr2 * Math.sin( theta2 ),\n\t\t\tr2 * Math.cos( theta2 ),\n\t\t);\n\n\t}\n\n\tequals( quaternion ) {\n\n\t\treturn ( quaternion._x === this._x ) && ( quaternion._y === this._y ) && ( quaternion._z === this._z ) && ( quaternion._w === this._w );\n\n\t}\n\n\tfromArray( array, offset = 0 ) {\n\n\t\tthis._x = array[ offset ];\n\t\tthis._y = array[ offset + 1 ];\n\t\tthis._z = array[ offset + 2 ];\n\t\tthis._w = array[ offset + 3 ];\n\n\t\tthis._onChangeCallback();\n\n\t\treturn this;\n\n\t}\n\n\ttoArray( array = [], offset = 0 ) {\n\n\t\tarray[ offset ] = this._x;\n\t\tarray[ offset + 1 ] = this._y;\n\t\tarray[ offset + 2 ] = this._z;\n\t\tarray[ offset + 3 ] = this._w;\n\n\t\treturn array;\n\n\t}\n\n\tfromBufferAttribute( attribute, index ) {\n\n\t\tthis._x = attribute.getX( index );\n\t\tthis._y = attribute.getY( index );\n\t\tthis._z = attribute.getZ( index );\n\t\tthis._w = attribute.getW( index );\n\n\t\tthis._onChangeCallback();\n\n\t\treturn this;\n\n\t}\n\n\ttoJSON() {\n\n\t\treturn this.toArray();\n\n\t}\n\n\t_onChange( callback ) {\n\n\t\tthis._onChangeCallback = callback;\n\n\t\treturn this;\n\n\t}\n\n\t_onChangeCallback() {}\n\n\t*[ Symbol.iterator ]() {\n\n\t\tyield this._x;\n\t\tyield this._y;\n\t\tyield this._z;\n\t\tyield this._w;\n\n\t}\n\n}\n\nclass Vector3 {\n\n\tconstructor( x = 0, y = 0, z = 0 ) {\n\n\t\tVector3.prototype.isVector3 = true;\n\n\t\tthis.x = x;\n\t\tthis.y = y;\n\t\tthis.z = z;\n\n\t}\n\n\tset( x, y, z ) {\n\n\t\tif ( z === undefined ) z = this.z; // sprite.scale.set(x,y)\n\n\t\tthis.x = x;\n\t\tthis.y = y;\n\t\tthis.z = z;\n\n\t\treturn this;\n\n\t}\n\n\tsetScalar( scalar ) {\n\n\t\tthis.x = scalar;\n\t\tthis.y = scalar;\n\t\tthis.z = scalar;\n\n\t\treturn this;\n\n\t}\n\n\tsetX( x ) {\n\n\t\tthis.x = x;\n\n\t\treturn this;\n\n\t}\n\n\tsetY( y ) {\n\n\t\tthis.y = y;\n\n\t\treturn this;\n\n\t}\n\n\tsetZ( z ) {\n\n\t\tthis.z = z;\n\n\t\treturn this;\n\n\t}\n\n\tsetComponent( index, value ) {\n\n\t\tswitch ( index ) {\n\n\t\t\tcase 0: this.x = value; break;\n\t\t\tcase 1: this.y = value; break;\n\t\t\tcase 2: this.z = value; break;\n\t\t\tdefault: throw new Error( 'index is out of range: ' + index );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tgetComponent( index ) {\n\n\t\tswitch ( index ) {\n\n\t\t\tcase 0: return this.x;\n\t\t\tcase 1: return this.y;\n\t\t\tcase 2: return this.z;\n\t\t\tdefault: throw new Error( 'index is out of range: ' + index );\n\n\t\t}\n\n\t}\n\n\tclone() {\n\n\t\treturn new this.constructor( this.x, this.y, this.z );\n\n\t}\n\n\tcopy( v ) {\n\n\t\tthis.x = v.x;\n\t\tthis.y = v.y;\n\t\tthis.z = v.z;\n\n\t\treturn this;\n\n\t}\n\n\tadd( v ) {\n\n\t\tthis.x += v.x;\n\t\tthis.y += v.y;\n\t\tthis.z += v.z;\n\n\t\treturn this;\n\n\t}\n\n\taddScalar( s ) {\n\n\t\tthis.x += s;\n\t\tthis.y += s;\n\t\tthis.z += s;\n\n\t\treturn this;\n\n\t}\n\n\taddVectors( a, b ) {\n\n\t\tthis.x = a.x + b.x;\n\t\tthis.y = a.y + b.y;\n\t\tthis.z = a.z + b.z;\n\n\t\treturn this;\n\n\t}\n\n\taddScaledVector( v, s ) {\n\n\t\tthis.x += v.x * s;\n\t\tthis.y += v.y * s;\n\t\tthis.z += v.z * s;\n\n\t\treturn this;\n\n\t}\n\n\tsub( v ) {\n\n\t\tthis.x -= v.x;\n\t\tthis.y -= v.y;\n\t\tthis.z -= v.z;\n\n\t\treturn this;\n\n\t}\n\n\tsubScalar( s ) {\n\n\t\tthis.x -= s;\n\t\tthis.y -= s;\n\t\tthis.z -= s;\n\n\t\treturn this;\n\n\t}\n\n\tsubVectors( a, b ) {\n\n\t\tthis.x = a.x - b.x;\n\t\tthis.y = a.y - b.y;\n\t\tthis.z = a.z - b.z;\n\n\t\treturn this;\n\n\t}\n\n\tmultiply( v ) {\n\n\t\tthis.x *= v.x;\n\t\tthis.y *= v.y;\n\t\tthis.z *= v.z;\n\n\t\treturn this;\n\n\t}\n\n\tmultiplyScalar( scalar ) {\n\n\t\tthis.x *= scalar;\n\t\tthis.y *= scalar;\n\t\tthis.z *= scalar;\n\n\t\treturn this;\n\n\t}\n\n\tmultiplyVectors( a, b ) {\n\n\t\tthis.x = a.x * b.x;\n\t\tthis.y = a.y * b.y;\n\t\tthis.z = a.z * b.z;\n\n\t\treturn this;\n\n\t}\n\n\tapplyEuler( euler ) {\n\n\t\treturn this.applyQuaternion( _quaternion$4.setFromEuler( euler ) );\n\n\t}\n\n\tapplyAxisAngle( axis, angle ) {\n\n\t\treturn this.applyQuaternion( _quaternion$4.setFromAxisAngle( axis, angle ) );\n\n\t}\n\n\tapplyMatrix3( m ) {\n\n\t\tconst x = this.x, y = this.y, z = this.z;\n\t\tconst e = m.elements;\n\n\t\tthis.x = e[ 0 ] * x + e[ 3 ] * y + e[ 6 ] * z;\n\t\tthis.y = e[ 1 ] * x + e[ 4 ] * y + e[ 7 ] * z;\n\t\tthis.z = e[ 2 ] * x + e[ 5 ] * y + e[ 8 ] * z;\n\n\t\treturn this;\n\n\t}\n\n\tapplyNormalMatrix( m ) {\n\n\t\treturn this.applyMatrix3( m ).normalize();\n\n\t}\n\n\tapplyMatrix4( m ) {\n\n\t\tconst x = this.x, y = this.y, z = this.z;\n\t\tconst e = m.elements;\n\n\t\tconst w = 1 / ( e[ 3 ] * x + e[ 7 ] * y + e[ 11 ] * z + e[ 15 ] );\n\n\t\tthis.x = ( e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z + e[ 12 ] ) * w;\n\t\tthis.y = ( e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z + e[ 13 ] ) * w;\n\t\tthis.z = ( e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z + e[ 14 ] ) * w;\n\n\t\treturn this;\n\n\t}\n\n\tapplyQuaternion( q ) {\n\n\t\t// quaternion q is assumed to have unit length\n\n\t\tconst vx = this.x, vy = this.y, vz = this.z;\n\t\tconst qx = q.x, qy = q.y, qz = q.z, qw = q.w;\n\n\t\t// t = 2 * cross( q.xyz, v );\n\t\tconst tx = 2 * ( qy * vz - qz * vy );\n\t\tconst ty = 2 * ( qz * vx - qx * vz );\n\t\tconst tz = 2 * ( qx * vy - qy * vx );\n\n\t\t// v + q.w * t + cross( q.xyz, t );\n\t\tthis.x = vx + qw * tx + qy * tz - qz * ty;\n\t\tthis.y = vy + qw * ty + qz * tx - qx * tz;\n\t\tthis.z = vz + qw * tz + qx * ty - qy * tx;\n\n\t\treturn this;\n\n\t}\n\n\tproject( camera ) {\n\n\t\treturn this.applyMatrix4( camera.matrixWorldInverse ).applyMatrix4( camera.projectionMatrix );\n\n\t}\n\n\tunproject( camera ) {\n\n\t\treturn this.applyMatrix4( camera.projectionMatrixInverse ).applyMatrix4( camera.matrixWorld );\n\n\t}\n\n\ttransformDirection( m ) {\n\n\t\t// input: THREE.Matrix4 affine matrix\n\t\t// vector interpreted as a direction\n\n\t\tconst x = this.x, y = this.y, z = this.z;\n\t\tconst e = m.elements;\n\n\t\tthis.x = e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z;\n\t\tthis.y = e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z;\n\t\tthis.z = e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z;\n\n\t\treturn this.normalize();\n\n\t}\n\n\tdivide( v ) {\n\n\t\tthis.x /= v.x;\n\t\tthis.y /= v.y;\n\t\tthis.z /= v.z;\n\n\t\treturn this;\n\n\t}\n\n\tdivideScalar( scalar ) {\n\n\t\treturn this.multiplyScalar( 1 / scalar );\n\n\t}\n\n\tmin( v ) {\n\n\t\tthis.x = Math.min( this.x, v.x );\n\t\tthis.y = Math.min( this.y, v.y );\n\t\tthis.z = Math.min( this.z, v.z );\n\n\t\treturn this;\n\n\t}\n\n\tmax( v ) {\n\n\t\tthis.x = Math.max( this.x, v.x );\n\t\tthis.y = Math.max( this.y, v.y );\n\t\tthis.z = Math.max( this.z, v.z );\n\n\t\treturn this;\n\n\t}\n\n\tclamp( min, max ) {\n\n\t\t// assumes min < max, componentwise\n\n\t\tthis.x = Math.max( min.x, Math.min( max.x, this.x ) );\n\t\tthis.y = Math.max( min.y, Math.min( max.y, this.y ) );\n\t\tthis.z = Math.max( min.z, Math.min( max.z, this.z ) );\n\n\t\treturn this;\n\n\t}\n\n\tclampScalar( minVal, maxVal ) {\n\n\t\tthis.x = Math.max( minVal, Math.min( maxVal, this.x ) );\n\t\tthis.y = Math.max( minVal, Math.min( maxVal, this.y ) );\n\t\tthis.z = Math.max( minVal, Math.min( maxVal, this.z ) );\n\n\t\treturn this;\n\n\t}\n\n\tclampLength( min, max ) {\n\n\t\tconst length = this.length();\n\n\t\treturn this.divideScalar( length || 1 ).multiplyScalar( Math.max( min, Math.min( max, length ) ) );\n\n\t}\n\n\tfloor() {\n\n\t\tthis.x = Math.floor( this.x );\n\t\tthis.y = Math.floor( this.y );\n\t\tthis.z = Math.floor( this.z );\n\n\t\treturn this;\n\n\t}\n\n\tceil() {\n\n\t\tthis.x = Math.ceil( this.x );\n\t\tthis.y = Math.ceil( this.y );\n\t\tthis.z = Math.ceil( this.z );\n\n\t\treturn this;\n\n\t}\n\n\tround() {\n\n\t\tthis.x = Math.round( this.x );\n\t\tthis.y = Math.round( this.y );\n\t\tthis.z = Math.round( this.z );\n\n\t\treturn this;\n\n\t}\n\n\troundToZero() {\n\n\t\tthis.x = Math.trunc( this.x );\n\t\tthis.y = Math.trunc( this.y );\n\t\tthis.z = Math.trunc( this.z );\n\n\t\treturn this;\n\n\t}\n\n\tnegate() {\n\n\t\tthis.x = - this.x;\n\t\tthis.y = - this.y;\n\t\tthis.z = - this.z;\n\n\t\treturn this;\n\n\t}\n\n\tdot( v ) {\n\n\t\treturn this.x * v.x + this.y * v.y + this.z * v.z;\n\n\t}\n\n\t// TODO lengthSquared?\n\n\tlengthSq() {\n\n\t\treturn this.x * this.x + this.y * this.y + this.z * this.z;\n\n\t}\n\n\tlength() {\n\n\t\treturn Math.sqrt( this.x * this.x + this.y * this.y + this.z * this.z );\n\n\t}\n\n\tmanhattanLength() {\n\n\t\treturn Math.abs( this.x ) + Math.abs( this.y ) + Math.abs( this.z );\n\n\t}\n\n\tnormalize() {\n\n\t\treturn this.divideScalar( this.length() || 1 );\n\n\t}\n\n\tsetLength( length ) {\n\n\t\treturn this.normalize().multiplyScalar( length );\n\n\t}\n\n\tlerp( v, alpha ) {\n\n\t\tthis.x += ( v.x - this.x ) * alpha;\n\t\tthis.y += ( v.y - this.y ) * alpha;\n\t\tthis.z += ( v.z - this.z ) * alpha;\n\n\t\treturn this;\n\n\t}\n\n\tlerpVectors( v1, v2, alpha ) {\n\n\t\tthis.x = v1.x + ( v2.x - v1.x ) * alpha;\n\t\tthis.y = v1.y + ( v2.y - v1.y ) * alpha;\n\t\tthis.z = v1.z + ( v2.z - v1.z ) * alpha;\n\n\t\treturn this;\n\n\t}\n\n\tcross( v ) {\n\n\t\treturn this.crossVectors( this, v );\n\n\t}\n\n\tcrossVectors( a, b ) {\n\n\t\tconst ax = a.x, ay = a.y, az = a.z;\n\t\tconst bx = b.x, by = b.y, bz = b.z;\n\n\t\tthis.x = ay * bz - az * by;\n\t\tthis.y = az * bx - ax * bz;\n\t\tthis.z = ax * by - ay * bx;\n\n\t\treturn this;\n\n\t}\n\n\tprojectOnVector( v ) {\n\n\t\tconst denominator = v.lengthSq();\n\n\t\tif ( denominator === 0 ) return this.set( 0, 0, 0 );\n\n\t\tconst scalar = v.dot( this ) / denominator;\n\n\t\treturn this.copy( v ).multiplyScalar( scalar );\n\n\t}\n\n\tprojectOnPlane( planeNormal ) {\n\n\t\t_vector$c.copy( this ).projectOnVector( planeNormal );\n\n\t\treturn this.sub( _vector$c );\n\n\t}\n\n\treflect( normal ) {\n\n\t\t// reflect incident vector off plane orthogonal to normal\n\t\t// normal is assumed to have unit length\n\n\t\treturn this.sub( _vector$c.copy( normal ).multiplyScalar( 2 * this.dot( normal ) ) );\n\n\t}\n\n\tangleTo( v ) {\n\n\t\tconst denominator = Math.sqrt( this.lengthSq() * v.lengthSq() );\n\n\t\tif ( denominator === 0 ) return Math.PI / 2;\n\n\t\tconst theta = this.dot( v ) / denominator;\n\n\t\t// clamp, to handle numerical problems\n\n\t\treturn Math.acos( clamp( theta, - 1, 1 ) );\n\n\t}\n\n\tdistanceTo( v ) {\n\n\t\treturn Math.sqrt( this.distanceToSquared( v ) );\n\n\t}\n\n\tdistanceToSquared( v ) {\n\n\t\tconst dx = this.x - v.x, dy = this.y - v.y, dz = this.z - v.z;\n\n\t\treturn dx * dx + dy * dy + dz * dz;\n\n\t}\n\n\tmanhattanDistanceTo( v ) {\n\n\t\treturn Math.abs( this.x - v.x ) + Math.abs( this.y - v.y ) + Math.abs( this.z - v.z );\n\n\t}\n\n\tsetFromSpherical( s ) {\n\n\t\treturn this.setFromSphericalCoords( s.radius, s.phi, s.theta );\n\n\t}\n\n\tsetFromSphericalCoords( radius, phi, theta ) {\n\n\t\tconst sinPhiRadius = Math.sin( phi ) * radius;\n\n\t\tthis.x = sinPhiRadius * Math.sin( theta );\n\t\tthis.y = Math.cos( phi ) * radius;\n\t\tthis.z = sinPhiRadius * Math.cos( theta );\n\n\t\treturn this;\n\n\t}\n\n\tsetFromCylindrical( c ) {\n\n\t\treturn this.setFromCylindricalCoords( c.radius, c.theta, c.y );\n\n\t}\n\n\tsetFromCylindricalCoords( radius, theta, y ) {\n\n\t\tthis.x = radius * Math.sin( theta );\n\t\tthis.y = y;\n\t\tthis.z = radius * Math.cos( theta );\n\n\t\treturn this;\n\n\t}\n\n\tsetFromMatrixPosition( m ) {\n\n\t\tconst e = m.elements;\n\n\t\tthis.x = e[ 12 ];\n\t\tthis.y = e[ 13 ];\n\t\tthis.z = e[ 14 ];\n\n\t\treturn this;\n\n\t}\n\n\tsetFromMatrixScale( m ) {\n\n\t\tconst sx = this.setFromMatrixColumn( m, 0 ).length();\n\t\tconst sy = this.setFromMatrixColumn( m, 1 ).length();\n\t\tconst sz = this.setFromMatrixColumn( m, 2 ).length();\n\n\t\tthis.x = sx;\n\t\tthis.y = sy;\n\t\tthis.z = sz;\n\n\t\treturn this;\n\n\t}\n\n\tsetFromMatrixColumn( m, index ) {\n\n\t\treturn this.fromArray( m.elements, index * 4 );\n\n\t}\n\n\tsetFromMatrix3Column( m, index ) {\n\n\t\treturn this.fromArray( m.elements, index * 3 );\n\n\t}\n\n\tsetFromEuler( e ) {\n\n\t\tthis.x = e._x;\n\t\tthis.y = e._y;\n\t\tthis.z = e._z;\n\n\t\treturn this;\n\n\t}\n\n\tsetFromColor( c ) {\n\n\t\tthis.x = c.r;\n\t\tthis.y = c.g;\n\t\tthis.z = c.b;\n\n\t\treturn this;\n\n\t}\n\n\tequals( v ) {\n\n\t\treturn ( ( v.x === this.x ) && ( v.y === this.y ) && ( v.z === this.z ) );\n\n\t}\n\n\tfromArray( array, offset = 0 ) {\n\n\t\tthis.x = array[ offset ];\n\t\tthis.y = array[ offset + 1 ];\n\t\tthis.z = array[ offset + 2 ];\n\n\t\treturn this;\n\n\t}\n\n\ttoArray( array = [], offset = 0 ) {\n\n\t\tarray[ offset ] = this.x;\n\t\tarray[ offset + 1 ] = this.y;\n\t\tarray[ offset + 2 ] = this.z;\n\n\t\treturn array;\n\n\t}\n\n\tfromBufferAttribute( attribute, index ) {\n\n\t\tthis.x = attribute.getX( index );\n\t\tthis.y = attribute.getY( index );\n\t\tthis.z = attribute.getZ( index );\n\n\t\treturn this;\n\n\t}\n\n\trandom() {\n\n\t\tthis.x = Math.random();\n\t\tthis.y = Math.random();\n\t\tthis.z = Math.random();\n\n\t\treturn this;\n\n\t}\n\n\trandomDirection() {\n\n\t\t// https://mathworld.wolfram.com/SpherePointPicking.html\n\n\t\tconst theta = Math.random() * Math.PI * 2;\n\t\tconst u = Math.random() * 2 - 1;\n\t\tconst c = Math.sqrt( 1 - u * u );\n\n\t\tthis.x = c * Math.cos( theta );\n\t\tthis.y = u;\n\t\tthis.z = c * Math.sin( theta );\n\n\t\treturn this;\n\n\t}\n\n\t*[ Symbol.iterator ]() {\n\n\t\tyield this.x;\n\t\tyield this.y;\n\t\tyield this.z;\n\n\t}\n\n}\n\nconst _vector$c = /*@__PURE__*/ new Vector3();\nconst _quaternion$4 = /*@__PURE__*/ new Quaternion();\n\nclass Box3 {\n\n\tconstructor( min = new Vector3( + Infinity, + Infinity, + Infinity ), max = new Vector3( - Infinity, - Infinity, - Infinity ) ) {\n\n\t\tthis.isBox3 = true;\n\n\t\tthis.min = min;\n\t\tthis.max = max;\n\n\t}\n\n\tset( min, max ) {\n\n\t\tthis.min.copy( min );\n\t\tthis.max.copy( max );\n\n\t\treturn this;\n\n\t}\n\n\tsetFromArray( array ) {\n\n\t\tthis.makeEmpty();\n\n\t\tfor ( let i = 0, il = array.length; i < il; i += 3 ) {\n\n\t\t\tthis.expandByPoint( _vector$b.fromArray( array, i ) );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tsetFromBufferAttribute( attribute ) {\n\n\t\tthis.makeEmpty();\n\n\t\tfor ( let i = 0, il = attribute.count; i < il; i ++ ) {\n\n\t\t\tthis.expandByPoint( _vector$b.fromBufferAttribute( attribute, i ) );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tsetFromPoints( points ) {\n\n\t\tthis.makeEmpty();\n\n\t\tfor ( let i = 0, il = points.length; i < il; i ++ ) {\n\n\t\t\tthis.expandByPoint( points[ i ] );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tsetFromCenterAndSize( center, size ) {\n\n\t\tconst halfSize = _vector$b.copy( size ).multiplyScalar( 0.5 );\n\n\t\tthis.min.copy( center ).sub( halfSize );\n\t\tthis.max.copy( center ).add( halfSize );\n\n\t\treturn this;\n\n\t}\n\n\tsetFromObject( object, precise = false ) {\n\n\t\tthis.makeEmpty();\n\n\t\treturn this.expandByObject( object, precise );\n\n\t}\n\n\tclone() {\n\n\t\treturn new this.constructor().copy( this );\n\n\t}\n\n\tcopy( box ) {\n\n\t\tthis.min.copy( box.min );\n\t\tthis.max.copy( box.max );\n\n\t\treturn this;\n\n\t}\n\n\tmakeEmpty() {\n\n\t\tthis.min.x = this.min.y = this.min.z = + Infinity;\n\t\tthis.max.x = this.max.y = this.max.z = - Infinity;\n\n\t\treturn this;\n\n\t}\n\n\tisEmpty() {\n\n\t\t// this is a more robust check for empty than ( volume <= 0 ) because volume can get positive with two negative axes\n\n\t\treturn ( this.max.x < this.min.x ) || ( this.max.y < this.min.y ) || ( this.max.z < this.min.z );\n\n\t}\n\n\tgetCenter( target ) {\n\n\t\treturn this.isEmpty() ? target.set( 0, 0, 0 ) : target.addVectors( this.min, this.max ).multiplyScalar( 0.5 );\n\n\t}\n\n\tgetSize( target ) {\n\n\t\treturn this.isEmpty() ? target.set( 0, 0, 0 ) : target.subVectors( this.max, this.min );\n\n\t}\n\n\texpandByPoint( point ) {\n\n\t\tthis.min.min( point );\n\t\tthis.max.max( point );\n\n\t\treturn this;\n\n\t}\n\n\texpandByVector( vector ) {\n\n\t\tthis.min.sub( vector );\n\t\tthis.max.add( vector );\n\n\t\treturn this;\n\n\t}\n\n\texpandByScalar( scalar ) {\n\n\t\tthis.min.addScalar( - scalar );\n\t\tthis.max.addScalar( scalar );\n\n\t\treturn this;\n\n\t}\n\n\texpandByObject( object, precise = false ) {\n\n\t\t// Computes the world-axis-aligned bounding box of an object (including its children),\n\t\t// accounting for both the object's, and children's, world transforms\n\n\t\tobject.updateWorldMatrix( false, false );\n\n\t\tconst geometry = object.geometry;\n\n\t\tif ( geometry !== undefined ) {\n\n\t\t\tconst positionAttribute = geometry.getAttribute( 'position' );\n\n\t\t\t// precise AABB computation based on vertex data requires at least a position attribute.\n\t\t\t// instancing isn't supported so far and uses the normal (conservative) code path.\n\n\t\t\tif ( precise === true && positionAttribute !== undefined && object.isInstancedMesh !== true ) {\n\n\t\t\t\tfor ( let i = 0, l = positionAttribute.count; i < l; i ++ ) {\n\n\t\t\t\t\tif ( object.isMesh === true ) {\n\n\t\t\t\t\t\tobject.getVertexPosition( i, _vector$b );\n\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\t_vector$b.fromBufferAttribute( positionAttribute, i );\n\n\t\t\t\t\t}\n\n\t\t\t\t\t_vector$b.applyMatrix4( object.matrixWorld );\n\t\t\t\t\tthis.expandByPoint( _vector$b );\n\n\t\t\t\t}\n\n\t\t\t} else {\n\n\t\t\t\tif ( object.boundingBox !== undefined ) {\n\n\t\t\t\t\t// object-level bounding box\n\n\t\t\t\t\tif ( object.boundingBox === null ) {\n\n\t\t\t\t\t\tobject.computeBoundingBox();\n\n\t\t\t\t\t}\n\n\t\t\t\t\t_box$4.copy( object.boundingBox );\n\n\n\t\t\t\t} else {\n\n\t\t\t\t\t// geometry-level bounding box\n\n\t\t\t\t\tif ( geometry.boundingBox === null ) {\n\n\t\t\t\t\t\tgeometry.computeBoundingBox();\n\n\t\t\t\t\t}\n\n\t\t\t\t\t_box$4.copy( geometry.boundingBox );\n\n\t\t\t\t}\n\n\t\t\t\t_box$4.applyMatrix4( object.matrixWorld );\n\n\t\t\t\tthis.union( _box$4 );\n\n\t\t\t}\n\n\t\t}\n\n\t\tconst children = object.children;\n\n\t\tfor ( let i = 0, l = children.length; i < l; i ++ ) {\n\n\t\t\tthis.expandByObject( children[ i ], precise );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tcontainsPoint( point ) {\n\n\t\treturn point.x < this.min.x || point.x > this.max.x ||\n\t\t\tpoint.y < this.min.y || point.y > this.max.y ||\n\t\t\tpoint.z < this.min.z || point.z > this.max.z ? false : true;\n\n\t}\n\n\tcontainsBox( box ) {\n\n\t\treturn this.min.x <= box.min.x && box.max.x <= this.max.x &&\n\t\t\tthis.min.y <= box.min.y && box.max.y <= this.max.y &&\n\t\t\tthis.min.z <= box.min.z && box.max.z <= this.max.z;\n\n\t}\n\n\tgetParameter( point, target ) {\n\n\t\t// This can potentially have a divide by zero if the box\n\t\t// has a size dimension of 0.\n\n\t\treturn target.set(\n\t\t\t( point.x - this.min.x ) / ( this.max.x - this.min.x ),\n\t\t\t( point.y - this.min.y ) / ( this.max.y - this.min.y ),\n\t\t\t( point.z - this.min.z ) / ( this.max.z - this.min.z )\n\t\t);\n\n\t}\n\n\tintersectsBox( box ) {\n\n\t\t// using 6 splitting planes to rule out intersections.\n\t\treturn box.max.x < this.min.x || box.min.x > this.max.x ||\n\t\t\tbox.max.y < this.min.y || box.min.y > this.max.y ||\n\t\t\tbox.max.z < this.min.z || box.min.z > this.max.z ? false : true;\n\n\t}\n\n\tintersectsSphere( sphere ) {\n\n\t\t// Find the point on the AABB closest to the sphere center.\n\t\tthis.clampPoint( sphere.center, _vector$b );\n\n\t\t// If that point is inside the sphere, the AABB and sphere intersect.\n\t\treturn _vector$b.distanceToSquared( sphere.center ) <= ( sphere.radius * sphere.radius );\n\n\t}\n\n\tintersectsPlane( plane ) {\n\n\t\t// We compute the minimum and maximum dot product values. If those values\n\t\t// are on the same side (back or front) of the plane, then there is no intersection.\n\n\t\tlet min, max;\n\n\t\tif ( plane.normal.x > 0 ) {\n\n\t\t\tmin = plane.normal.x * this.min.x;\n\t\t\tmax = plane.normal.x * this.max.x;\n\n\t\t} else {\n\n\t\t\tmin = plane.normal.x * this.max.x;\n\t\t\tmax = plane.normal.x * this.min.x;\n\n\t\t}\n\n\t\tif ( plane.normal.y > 0 ) {\n\n\t\t\tmin += plane.normal.y * this.min.y;\n\t\t\tmax += plane.normal.y * this.max.y;\n\n\t\t} else {\n\n\t\t\tmin += plane.normal.y * this.max.y;\n\t\t\tmax += plane.normal.y * this.min.y;\n\n\t\t}\n\n\t\tif ( plane.normal.z > 0 ) {\n\n\t\t\tmin += plane.normal.z * this.min.z;\n\t\t\tmax += plane.normal.z * this.max.z;\n\n\t\t} else {\n\n\t\t\tmin += plane.normal.z * this.max.z;\n\t\t\tmax += plane.normal.z * this.min.z;\n\n\t\t}\n\n\t\treturn ( min <= - plane.constant && max >= - plane.constant );\n\n\t}\n\n\tintersectsTriangle( triangle ) {\n\n\t\tif ( this.isEmpty() ) {\n\n\t\t\treturn false;\n\n\t\t}\n\n\t\t// compute box center and extents\n\t\tthis.getCenter( _center );\n\t\t_extents.subVectors( this.max, _center );\n\n\t\t// translate triangle to aabb origin\n\t\t_v0$2.subVectors( triangle.a, _center );\n\t\t_v1$7.subVectors( triangle.b, _center );\n\t\t_v2$4.subVectors( triangle.c, _center );\n\n\t\t// compute edge vectors for triangle\n\t\t_f0.subVectors( _v1$7, _v0$2 );\n\t\t_f1.subVectors( _v2$4, _v1$7 );\n\t\t_f2.subVectors( _v0$2, _v2$4 );\n\n\t\t// test against axes that are given by cross product combinations of the edges of the triangle and the edges of the aabb\n\t\t// make an axis testing of each of the 3 sides of the aabb against each of the 3 sides of the triangle = 9 axis of separation\n\t\t// axis_ij = u_i x f_j (u0, u1, u2 = face normals of aabb = x,y,z axes vectors since aabb is axis aligned)\n\t\tlet axes = [\n\t\t\t0, - _f0.z, _f0.y, 0, - _f1.z, _f1.y, 0, - _f2.z, _f2.y,\n\t\t\t_f0.z, 0, - _f0.x, _f1.z, 0, - _f1.x, _f2.z, 0, - _f2.x,\n\t\t\t- _f0.y, _f0.x, 0, - _f1.y, _f1.x, 0, - _f2.y, _f2.x, 0\n\t\t];\n\t\tif ( ! satForAxes( axes, _v0$2, _v1$7, _v2$4, _extents ) ) {\n\n\t\t\treturn false;\n\n\t\t}\n\n\t\t// test 3 face normals from the aabb\n\t\taxes = [ 1, 0, 0, 0, 1, 0, 0, 0, 1 ];\n\t\tif ( ! satForAxes( axes, _v0$2, _v1$7, _v2$4, _extents ) ) {\n\n\t\t\treturn false;\n\n\t\t}\n\n\t\t// finally testing the face normal of the triangle\n\t\t// use already existing triangle edge vectors here\n\t\t_triangleNormal.crossVectors( _f0, _f1 );\n\t\taxes = [ _triangleNormal.x, _triangleNormal.y, _triangleNormal.z ];\n\n\t\treturn satForAxes( axes, _v0$2, _v1$7, _v2$4, _extents );\n\n\t}\n\n\tclampPoint( point, target ) {\n\n\t\treturn target.copy( point ).clamp( this.min, this.max );\n\n\t}\n\n\tdistanceToPoint( point ) {\n\n\t\treturn this.clampPoint( point, _vector$b ).distanceTo( point );\n\n\t}\n\n\tgetBoundingSphere( target ) {\n\n\t\tif ( this.isEmpty() ) {\n\n\t\t\ttarget.makeEmpty();\n\n\t\t} else {\n\n\t\t\tthis.getCenter( target.center );\n\n\t\t\ttarget.radius = this.getSize( _vector$b ).length() * 0.5;\n\n\t\t}\n\n\t\treturn target;\n\n\t}\n\n\tintersect( box ) {\n\n\t\tthis.min.max( box.min );\n\t\tthis.max.min( box.max );\n\n\t\t// ensure that if there is no overlap, the result is fully empty, not slightly empty with non-inf/+inf values that will cause subsequence intersects to erroneously return valid values.\n\t\tif ( this.isEmpty() ) this.makeEmpty();\n\n\t\treturn this;\n\n\t}\n\n\tunion( box ) {\n\n\t\tthis.min.min( box.min );\n\t\tthis.max.max( box.max );\n\n\t\treturn this;\n\n\t}\n\n\tapplyMatrix4( matrix ) {\n\n\t\t// transform of empty box is an empty box.\n\t\tif ( this.isEmpty() ) return this;\n\n\t\t// NOTE: I am using a binary pattern to specify all 2^3 combinations below\n\t\t_points[ 0 ].set( this.min.x, this.min.y, this.min.z ).applyMatrix4( matrix ); // 000\n\t\t_points[ 1 ].set( this.min.x, this.min.y, this.max.z ).applyMatrix4( matrix ); // 001\n\t\t_points[ 2 ].set( this.min.x, this.max.y, this.min.z ).applyMatrix4( matrix ); // 010\n\t\t_points[ 3 ].set( this.min.x, this.max.y, this.max.z ).applyMatrix4( matrix ); // 011\n\t\t_points[ 4 ].set( this.max.x, this.min.y, this.min.z ).applyMatrix4( matrix ); // 100\n\t\t_points[ 5 ].set( this.max.x, this.min.y, this.max.z ).applyMatrix4( matrix ); // 101\n\t\t_points[ 6 ].set( this.max.x, this.max.y, this.min.z ).applyMatrix4( matrix ); // 110\n\t\t_points[ 7 ].set( this.max.x, this.max.y, this.max.z ).applyMatrix4( matrix ); // 111\n\n\t\tthis.setFromPoints( _points );\n\n\t\treturn this;\n\n\t}\n\n\ttranslate( offset ) {\n\n\t\tthis.min.add( offset );\n\t\tthis.max.add( offset );\n\n\t\treturn this;\n\n\t}\n\n\tequals( box ) {\n\n\t\treturn box.min.equals( this.min ) && box.max.equals( this.max );\n\n\t}\n\n}\n\nconst _points = [\n\t/*@__PURE__*/ new Vector3(),\n\t/*@__PURE__*/ new Vector3(),\n\t/*@__PURE__*/ new Vector3(),\n\t/*@__PURE__*/ new Vector3(),\n\t/*@__PURE__*/ new Vector3(),\n\t/*@__PURE__*/ new Vector3(),\n\t/*@__PURE__*/ new Vector3(),\n\t/*@__PURE__*/ new Vector3()\n];\n\nconst _vector$b = /*@__PURE__*/ new Vector3();\n\nconst _box$4 = /*@__PURE__*/ new Box3();\n\n// triangle centered vertices\n\nconst _v0$2 = /*@__PURE__*/ new Vector3();\nconst _v1$7 = /*@__PURE__*/ new Vector3();\nconst _v2$4 = /*@__PURE__*/ new Vector3();\n\n// triangle edge vectors\n\nconst _f0 = /*@__PURE__*/ new Vector3();\nconst _f1 = /*@__PURE__*/ new Vector3();\nconst _f2 = /*@__PURE__*/ new Vector3();\n\nconst _center = /*@__PURE__*/ new Vector3();\nconst _extents = /*@__PURE__*/ new Vector3();\nconst _triangleNormal = /*@__PURE__*/ new Vector3();\nconst _testAxis = /*@__PURE__*/ new Vector3();\n\nfunction satForAxes( axes, v0, v1, v2, extents ) {\n\n\tfor ( let i = 0, j = axes.length - 3; i <= j; i += 3 ) {\n\n\t\t_testAxis.fromArray( axes, i );\n\t\t// project the aabb onto the separating axis\n\t\tconst r = extents.x * Math.abs( _testAxis.x ) + extents.y * Math.abs( _testAxis.y ) + extents.z * Math.abs( _testAxis.z );\n\t\t// project all 3 vertices of the triangle onto the separating axis\n\t\tconst p0 = v0.dot( _testAxis );\n\t\tconst p1 = v1.dot( _testAxis );\n\t\tconst p2 = v2.dot( _testAxis );\n\t\t// actual test, basically see if either of the most extreme of the triangle points intersects r\n\t\tif ( Math.max( - Math.max( p0, p1, p2 ), Math.min( p0, p1, p2 ) ) > r ) {\n\n\t\t\t// points of the projected triangle are outside the projected half-length of the aabb\n\t\t\t// the axis is separating and we can exit\n\t\t\treturn false;\n\n\t\t}\n\n\t}\n\n\treturn true;\n\n}\n\nconst _box$3 = /*@__PURE__*/ new Box3();\nconst _v1$6 = /*@__PURE__*/ new Vector3();\nconst _v2$3 = /*@__PURE__*/ new Vector3();\n\nclass Sphere {\n\n\tconstructor( center = new Vector3(), radius = - 1 ) {\n\n\t\tthis.isSphere = true;\n\n\t\tthis.center = center;\n\t\tthis.radius = radius;\n\n\t}\n\n\tset( center, radius ) {\n\n\t\tthis.center.copy( center );\n\t\tthis.radius = radius;\n\n\t\treturn this;\n\n\t}\n\n\tsetFromPoints( points, optionalCenter ) {\n\n\t\tconst center = this.center;\n\n\t\tif ( optionalCenter !== undefined ) {\n\n\t\t\tcenter.copy( optionalCenter );\n\n\t\t} else {\n\n\t\t\t_box$3.setFromPoints( points ).getCenter( center );\n\n\t\t}\n\n\t\tlet maxRadiusSq = 0;\n\n\t\tfor ( let i = 0, il = points.length; i < il; i ++ ) {\n\n\t\t\tmaxRadiusSq = Math.max( maxRadiusSq, center.distanceToSquared( points[ i ] ) );\n\n\t\t}\n\n\t\tthis.radius = Math.sqrt( maxRadiusSq );\n\n\t\treturn this;\n\n\t}\n\n\tcopy( sphere ) {\n\n\t\tthis.center.copy( sphere.center );\n\t\tthis.radius = sphere.radius;\n\n\t\treturn this;\n\n\t}\n\n\tisEmpty() {\n\n\t\treturn ( this.radius < 0 );\n\n\t}\n\n\tmakeEmpty() {\n\n\t\tthis.center.set( 0, 0, 0 );\n\t\tthis.radius = - 1;\n\n\t\treturn this;\n\n\t}\n\n\tcontainsPoint( point ) {\n\n\t\treturn ( point.distanceToSquared( this.center ) <= ( this.radius * this.radius ) );\n\n\t}\n\n\tdistanceToPoint( point ) {\n\n\t\treturn ( point.distanceTo( this.center ) - this.radius );\n\n\t}\n\n\tintersectsSphere( sphere ) {\n\n\t\tconst radiusSum = this.radius + sphere.radius;\n\n\t\treturn sphere.center.distanceToSquared( this.center ) <= ( radiusSum * radiusSum );\n\n\t}\n\n\tintersectsBox( box ) {\n\n\t\treturn box.intersectsSphere( this );\n\n\t}\n\n\tintersectsPlane( plane ) {\n\n\t\treturn Math.abs( plane.distanceToPoint( this.center ) ) <= this.radius;\n\n\t}\n\n\tclampPoint( point, target ) {\n\n\t\tconst deltaLengthSq = this.center.distanceToSquared( point );\n\n\t\ttarget.copy( point );\n\n\t\tif ( deltaLengthSq > ( this.radius * this.radius ) ) {\n\n\t\t\ttarget.sub( this.center ).normalize();\n\t\t\ttarget.multiplyScalar( this.radius ).add( this.center );\n\n\t\t}\n\n\t\treturn target;\n\n\t}\n\n\tgetBoundingBox( target ) {\n\n\t\tif ( this.isEmpty() ) {\n\n\t\t\t// Empty sphere produces empty bounding box\n\t\t\ttarget.makeEmpty();\n\t\t\treturn target;\n\n\t\t}\n\n\t\ttarget.set( this.center, this.center );\n\t\ttarget.expandByScalar( this.radius );\n\n\t\treturn target;\n\n\t}\n\n\tapplyMatrix4( matrix ) {\n\n\t\tthis.center.applyMatrix4( matrix );\n\t\tthis.radius = this.radius * matrix.getMaxScaleOnAxis();\n\n\t\treturn this;\n\n\t}\n\n\ttranslate( offset ) {\n\n\t\tthis.center.add( offset );\n\n\t\treturn this;\n\n\t}\n\n\texpandByPoint( point ) {\n\n\t\tif ( this.isEmpty() ) {\n\n\t\t\tthis.center.copy( point );\n\n\t\t\tthis.radius = 0;\n\n\t\t\treturn this;\n\n\t\t}\n\n\t\t_v1$6.subVectors( point, this.center );\n\n\t\tconst lengthSq = _v1$6.lengthSq();\n\n\t\tif ( lengthSq > ( this.radius * this.radius ) ) {\n\n\t\t\t// calculate the minimal sphere\n\n\t\t\tconst length = Math.sqrt( lengthSq );\n\n\t\t\tconst delta = ( length - this.radius ) * 0.5;\n\n\t\t\tthis.center.addScaledVector( _v1$6, delta / length );\n\n\t\t\tthis.radius += delta;\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tunion( sphere ) {\n\n\t\tif ( sphere.isEmpty() ) {\n\n\t\t\treturn this;\n\n\t\t}\n\n\t\tif ( this.isEmpty() ) {\n\n\t\t\tthis.copy( sphere );\n\n\t\t\treturn this;\n\n\t\t}\n\n\t\tif ( this.center.equals( sphere.center ) === true ) {\n\n\t\t\t this.radius = Math.max( this.radius, sphere.radius );\n\n\t\t} else {\n\n\t\t\t_v2$3.subVectors( sphere.center, this.center ).setLength( sphere.radius );\n\n\t\t\tthis.expandByPoint( _v1$6.copy( sphere.center ).add( _v2$3 ) );\n\n\t\t\tthis.expandByPoint( _v1$6.copy( sphere.center ).sub( _v2$3 ) );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tequals( sphere ) {\n\n\t\treturn sphere.center.equals( this.center ) && ( sphere.radius === this.radius );\n\n\t}\n\n\tclone() {\n\n\t\treturn new this.constructor().copy( this );\n\n\t}\n\n}\n\nconst _vector$a = /*@__PURE__*/ new Vector3();\nconst _segCenter = /*@__PURE__*/ new Vector3();\nconst _segDir = /*@__PURE__*/ new Vector3();\nconst _diff = /*@__PURE__*/ new Vector3();\n\nconst _edge1 = /*@__PURE__*/ new Vector3();\nconst _edge2 = /*@__PURE__*/ new Vector3();\nconst _normal$1 = /*@__PURE__*/ new Vector3();\n\nclass Ray {\n\n\tconstructor( origin = new Vector3(), direction = new Vector3( 0, 0, - 1 ) ) {\n\n\t\tthis.origin = origin;\n\t\tthis.direction = direction;\n\n\t}\n\n\tset( origin, direction ) {\n\n\t\tthis.origin.copy( origin );\n\t\tthis.direction.copy( direction );\n\n\t\treturn this;\n\n\t}\n\n\tcopy( ray ) {\n\n\t\tthis.origin.copy( ray.origin );\n\t\tthis.direction.copy( ray.direction );\n\n\t\treturn this;\n\n\t}\n\n\tat( t, target ) {\n\n\t\treturn target.copy( this.origin ).addScaledVector( this.direction, t );\n\n\t}\n\n\tlookAt( v ) {\n\n\t\tthis.direction.copy( v ).sub( this.origin ).normalize();\n\n\t\treturn this;\n\n\t}\n\n\trecast( t ) {\n\n\t\tthis.origin.copy( this.at( t, _vector$a ) );\n\n\t\treturn this;\n\n\t}\n\n\tclosestPointToPoint( point, target ) {\n\n\t\ttarget.subVectors( point, this.origin );\n\n\t\tconst directionDistance = target.dot( this.direction );\n\n\t\tif ( directionDistance < 0 ) {\n\n\t\t\treturn target.copy( this.origin );\n\n\t\t}\n\n\t\treturn target.copy( this.origin ).addScaledVector( this.direction, directionDistance );\n\n\t}\n\n\tdistanceToPoint( point ) {\n\n\t\treturn Math.sqrt( this.distanceSqToPoint( point ) );\n\n\t}\n\n\tdistanceSqToPoint( point ) {\n\n\t\tconst directionDistance = _vector$a.subVectors( point, this.origin ).dot( this.direction );\n\n\t\t// point behind the ray\n\n\t\tif ( directionDistance < 0 ) {\n\n\t\t\treturn this.origin.distanceToSquared( point );\n\n\t\t}\n\n\t\t_vector$a.copy( this.origin ).addScaledVector( this.direction, directionDistance );\n\n\t\treturn _vector$a.distanceToSquared( point );\n\n\t}\n\n\tdistanceSqToSegment( v0, v1, optionalPointOnRay, optionalPointOnSegment ) {\n\n\t\t// from https://github.com/pmjoniak/GeometricTools/blob/master/GTEngine/Include/Mathematics/GteDistRaySegment.h\n\t\t// It returns the min distance between the ray and the segment\n\t\t// defined by v0 and v1\n\t\t// It can also set two optional targets :\n\t\t// - The closest point on the ray\n\t\t// - The closest point on the segment\n\n\t\t_segCenter.copy( v0 ).add( v1 ).multiplyScalar( 0.5 );\n\t\t_segDir.copy( v1 ).sub( v0 ).normalize();\n\t\t_diff.copy( this.origin ).sub( _segCenter );\n\n\t\tconst segExtent = v0.distanceTo( v1 ) * 0.5;\n\t\tconst a01 = - this.direction.dot( _segDir );\n\t\tconst b0 = _diff.dot( this.direction );\n\t\tconst b1 = - _diff.dot( _segDir );\n\t\tconst c = _diff.lengthSq();\n\t\tconst det = Math.abs( 1 - a01 * a01 );\n\t\tlet s0, s1, sqrDist, extDet;\n\n\t\tif ( det > 0 ) {\n\n\t\t\t// The ray and segment are not parallel.\n\n\t\t\ts0 = a01 * b1 - b0;\n\t\t\ts1 = a01 * b0 - b1;\n\t\t\textDet = segExtent * det;\n\n\t\t\tif ( s0 >= 0 ) {\n\n\t\t\t\tif ( s1 >= - extDet ) {\n\n\t\t\t\t\tif ( s1 <= extDet ) {\n\n\t\t\t\t\t\t// region 0\n\t\t\t\t\t\t// Minimum at interior points of ray and segment.\n\n\t\t\t\t\t\tconst invDet = 1 / det;\n\t\t\t\t\t\ts0 *= invDet;\n\t\t\t\t\t\ts1 *= invDet;\n\t\t\t\t\t\tsqrDist = s0 * ( s0 + a01 * s1 + 2 * b0 ) + s1 * ( a01 * s0 + s1 + 2 * b1 ) + c;\n\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\t// region 1\n\n\t\t\t\t\t\ts1 = segExtent;\n\t\t\t\t\t\ts0 = Math.max( 0, - ( a01 * s1 + b0 ) );\n\t\t\t\t\t\tsqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c;\n\n\t\t\t\t\t}\n\n\t\t\t\t} else {\n\n\t\t\t\t\t// region 5\n\n\t\t\t\t\ts1 = - segExtent;\n\t\t\t\t\ts0 = Math.max( 0, - ( a01 * s1 + b0 ) );\n\t\t\t\t\tsqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c;\n\n\t\t\t\t}\n\n\t\t\t} else {\n\n\t\t\t\tif ( s1 <= - extDet ) {\n\n\t\t\t\t\t// region 4\n\n\t\t\t\t\ts0 = Math.max( 0, - ( - a01 * segExtent + b0 ) );\n\t\t\t\t\ts1 = ( s0 > 0 ) ? - segExtent : Math.min( Math.max( - segExtent, - b1 ), segExtent );\n\t\t\t\t\tsqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c;\n\n\t\t\t\t} else if ( s1 <= extDet ) {\n\n\t\t\t\t\t// region 3\n\n\t\t\t\t\ts0 = 0;\n\t\t\t\t\ts1 = Math.min( Math.max( - segExtent, - b1 ), segExtent );\n\t\t\t\t\tsqrDist = s1 * ( s1 + 2 * b1 ) + c;\n\n\t\t\t\t} else {\n\n\t\t\t\t\t// region 2\n\n\t\t\t\t\ts0 = Math.max( 0, - ( a01 * segExtent + b0 ) );\n\t\t\t\t\ts1 = ( s0 > 0 ) ? segExtent : Math.min( Math.max( - segExtent, - b1 ), segExtent );\n\t\t\t\t\tsqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c;\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t} else {\n\n\t\t\t// Ray and segment are parallel.\n\n\t\t\ts1 = ( a01 > 0 ) ? - segExtent : segExtent;\n\t\t\ts0 = Math.max( 0, - ( a01 * s1 + b0 ) );\n\t\t\tsqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c;\n\n\t\t}\n\n\t\tif ( optionalPointOnRay ) {\n\n\t\t\toptionalPointOnRay.copy( this.origin ).addScaledVector( this.direction, s0 );\n\n\t\t}\n\n\t\tif ( optionalPointOnSegment ) {\n\n\t\t\toptionalPointOnSegment.copy( _segCenter ).addScaledVector( _segDir, s1 );\n\n\t\t}\n\n\t\treturn sqrDist;\n\n\t}\n\n\tintersectSphere( sphere, target ) {\n\n\t\t_vector$a.subVectors( sphere.center, this.origin );\n\t\tconst tca = _vector$a.dot( this.direction );\n\t\tconst d2 = _vector$a.dot( _vector$a ) - tca * tca;\n\t\tconst radius2 = sphere.radius * sphere.radius;\n\n\t\tif ( d2 > radius2 ) return null;\n\n\t\tconst thc = Math.sqrt( radius2 - d2 );\n\n\t\t// t0 = first intersect point - entrance on front of sphere\n\t\tconst t0 = tca - thc;\n\n\t\t// t1 = second intersect point - exit point on back of sphere\n\t\tconst t1 = tca + thc;\n\n\t\t// test to see if t1 is behind the ray - if so, return null\n\t\tif ( t1 < 0 ) return null;\n\n\t\t// test to see if t0 is behind the ray:\n\t\t// if it is, the ray is inside the sphere, so return the second exit point scaled by t1,\n\t\t// in order to always return an intersect point that is in front of the ray.\n\t\tif ( t0 < 0 ) return this.at( t1, target );\n\n\t\t// else t0 is in front of the ray, so return the first collision point scaled by t0\n\t\treturn this.at( t0, target );\n\n\t}\n\n\tintersectsSphere( sphere ) {\n\n\t\treturn this.distanceSqToPoint( sphere.center ) <= ( sphere.radius * sphere.radius );\n\n\t}\n\n\tdistanceToPlane( plane ) {\n\n\t\tconst denominator = plane.normal.dot( this.direction );\n\n\t\tif ( denominator === 0 ) {\n\n\t\t\t// line is coplanar, return origin\n\t\t\tif ( plane.distanceToPoint( this.origin ) === 0 ) {\n\n\t\t\t\treturn 0;\n\n\t\t\t}\n\n\t\t\t// Null is preferable to undefined since undefined means.... it is undefined\n\n\t\t\treturn null;\n\n\t\t}\n\n\t\tconst t = - ( this.origin.dot( plane.normal ) + plane.constant ) / denominator;\n\n\t\t// Return if the ray never intersects the plane\n\n\t\treturn t >= 0 ? t : null;\n\n\t}\n\n\tintersectPlane( plane, target ) {\n\n\t\tconst t = this.distanceToPlane( plane );\n\n\t\tif ( t === null ) {\n\n\t\t\treturn null;\n\n\t\t}\n\n\t\treturn this.at( t, target );\n\n\t}\n\n\tintersectsPlane( plane ) {\n\n\t\t// check if the ray lies on the plane first\n\n\t\tconst distToPoint = plane.distanceToPoint( this.origin );\n\n\t\tif ( distToPoint === 0 ) {\n\n\t\t\treturn true;\n\n\t\t}\n\n\t\tconst denominator = plane.normal.dot( this.direction );\n\n\t\tif ( denominator * distToPoint < 0 ) {\n\n\t\t\treturn true;\n\n\t\t}\n\n\t\t// ray origin is behind the plane (and is pointing behind it)\n\n\t\treturn false;\n\n\t}\n\n\tintersectBox( box, target ) {\n\n\t\tlet tmin, tmax, tymin, tymax, tzmin, tzmax;\n\n\t\tconst invdirx = 1 / this.direction.x,\n\t\t\tinvdiry = 1 / this.direction.y,\n\t\t\tinvdirz = 1 / this.direction.z;\n\n\t\tconst origin = this.origin;\n\n\t\tif ( invdirx >= 0 ) {\n\n\t\t\ttmin = ( box.min.x - origin.x ) * invdirx;\n\t\t\ttmax = ( box.max.x - origin.x ) * invdirx;\n\n\t\t} else {\n\n\t\t\ttmin = ( box.max.x - origin.x ) * invdirx;\n\t\t\ttmax = ( box.min.x - origin.x ) * invdirx;\n\n\t\t}\n\n\t\tif ( invdiry >= 0 ) {\n\n\t\t\ttymin = ( box.min.y - origin.y ) * invdiry;\n\t\t\ttymax = ( box.max.y - origin.y ) * invdiry;\n\n\t\t} else {\n\n\t\t\ttymin = ( box.max.y - origin.y ) * invdiry;\n\t\t\ttymax = ( box.min.y - origin.y ) * invdiry;\n\n\t\t}\n\n\t\tif ( ( tmin > tymax ) || ( tymin > tmax ) ) return null;\n\n\t\tif ( tymin > tmin || isNaN( tmin ) ) tmin = tymin;\n\n\t\tif ( tymax < tmax || isNaN( tmax ) ) tmax = tymax;\n\n\t\tif ( invdirz >= 0 ) {\n\n\t\t\ttzmin = ( box.min.z - origin.z ) * invdirz;\n\t\t\ttzmax = ( box.max.z - origin.z ) * invdirz;\n\n\t\t} else {\n\n\t\t\ttzmin = ( box.max.z - origin.z ) * invdirz;\n\t\t\ttzmax = ( box.min.z - origin.z ) * invdirz;\n\n\t\t}\n\n\t\tif ( ( tmin > tzmax ) || ( tzmin > tmax ) ) return null;\n\n\t\tif ( tzmin > tmin || tmin !== tmin ) tmin = tzmin;\n\n\t\tif ( tzmax < tmax || tmax !== tmax ) tmax = tzmax;\n\n\t\t//return point closest to the ray (positive side)\n\n\t\tif ( tmax < 0 ) return null;\n\n\t\treturn this.at( tmin >= 0 ? tmin : tmax, target );\n\n\t}\n\n\tintersectsBox( box ) {\n\n\t\treturn this.intersectBox( box, _vector$a ) !== null;\n\n\t}\n\n\tintersectTriangle( a, b, c, backfaceCulling, target ) {\n\n\t\t// Compute the offset origin, edges, and normal.\n\n\t\t// from https://github.com/pmjoniak/GeometricTools/blob/master/GTEngine/Include/Mathematics/GteIntrRay3Triangle3.h\n\n\t\t_edge1.subVectors( b, a );\n\t\t_edge2.subVectors( c, a );\n\t\t_normal$1.crossVectors( _edge1, _edge2 );\n\n\t\t// Solve Q + t*D = b1*E1 + b2*E2 (Q = kDiff, D = ray direction,\n\t\t// E1 = kEdge1, E2 = kEdge2, N = Cross(E1,E2)) by\n\t\t// |Dot(D,N)|*b1 = sign(Dot(D,N))*Dot(D,Cross(Q,E2))\n\t\t// |Dot(D,N)|*b2 = sign(Dot(D,N))*Dot(D,Cross(E1,Q))\n\t\t// |Dot(D,N)|*t = -sign(Dot(D,N))*Dot(Q,N)\n\t\tlet DdN = this.direction.dot( _normal$1 );\n\t\tlet sign;\n\n\t\tif ( DdN > 0 ) {\n\n\t\t\tif ( backfaceCulling ) return null;\n\t\t\tsign = 1;\n\n\t\t} else if ( DdN < 0 ) {\n\n\t\t\tsign = - 1;\n\t\t\tDdN = - DdN;\n\n\t\t} else {\n\n\t\t\treturn null;\n\n\t\t}\n\n\t\t_diff.subVectors( this.origin, a );\n\t\tconst DdQxE2 = sign * this.direction.dot( _edge2.crossVectors( _diff, _edge2 ) );\n\n\t\t// b1 < 0, no intersection\n\t\tif ( DdQxE2 < 0 ) {\n\n\t\t\treturn null;\n\n\t\t}\n\n\t\tconst DdE1xQ = sign * this.direction.dot( _edge1.cross( _diff ) );\n\n\t\t// b2 < 0, no intersection\n\t\tif ( DdE1xQ < 0 ) {\n\n\t\t\treturn null;\n\n\t\t}\n\n\t\t// b1+b2 > 1, no intersection\n\t\tif ( DdQxE2 + DdE1xQ > DdN ) {\n\n\t\t\treturn null;\n\n\t\t}\n\n\t\t// Line intersects triangle, check if ray does.\n\t\tconst QdN = - sign * _diff.dot( _normal$1 );\n\n\t\t// t < 0, no intersection\n\t\tif ( QdN < 0 ) {\n\n\t\t\treturn null;\n\n\t\t}\n\n\t\t// Ray intersects triangle.\n\t\treturn this.at( QdN / DdN, target );\n\n\t}\n\n\tapplyMatrix4( matrix4 ) {\n\n\t\tthis.origin.applyMatrix4( matrix4 );\n\t\tthis.direction.transformDirection( matrix4 );\n\n\t\treturn this;\n\n\t}\n\n\tequals( ray ) {\n\n\t\treturn ray.origin.equals( this.origin ) && ray.direction.equals( this.direction );\n\n\t}\n\n\tclone() {\n\n\t\treturn new this.constructor().copy( this );\n\n\t}\n\n}\n\nclass Matrix4 {\n\n\tconstructor( n11, n12, n13, n14, n21, n22, n23, n24, n31, n32, n33, n34, n41, n42, n43, n44 ) {\n\n\t\tMatrix4.prototype.isMatrix4 = true;\n\n\t\tthis.elements = [\n\n\t\t\t1, 0, 0, 0,\n\t\t\t0, 1, 0, 0,\n\t\t\t0, 0, 1, 0,\n\t\t\t0, 0, 0, 1\n\n\t\t];\n\n\t\tif ( n11 !== undefined ) {\n\n\t\t\tthis.set( n11, n12, n13, n14, n21, n22, n23, n24, n31, n32, n33, n34, n41, n42, n43, n44 );\n\n\t\t}\n\n\t}\n\n\tset( n11, n12, n13, n14, n21, n22, n23, n24, n31, n32, n33, n34, n41, n42, n43, n44 ) {\n\n\t\tconst te = this.elements;\n\n\t\tte[ 0 ] = n11; te[ 4 ] = n12; te[ 8 ] = n13; te[ 12 ] = n14;\n\t\tte[ 1 ] = n21; te[ 5 ] = n22; te[ 9 ] = n23; te[ 13 ] = n24;\n\t\tte[ 2 ] = n31; te[ 6 ] = n32; te[ 10 ] = n33; te[ 14 ] = n34;\n\t\tte[ 3 ] = n41; te[ 7 ] = n42; te[ 11 ] = n43; te[ 15 ] = n44;\n\n\t\treturn this;\n\n\t}\n\n\tidentity() {\n\n\t\tthis.set(\n\n\t\t\t1, 0, 0, 0,\n\t\t\t0, 1, 0, 0,\n\t\t\t0, 0, 1, 0,\n\t\t\t0, 0, 0, 1\n\n\t\t);\n\n\t\treturn this;\n\n\t}\n\n\tclone() {\n\n\t\treturn new Matrix4().fromArray( this.elements );\n\n\t}\n\n\tcopy( m ) {\n\n\t\tconst te = this.elements;\n\t\tconst me = m.elements;\n\n\t\tte[ 0 ] = me[ 0 ]; te[ 1 ] = me[ 1 ]; te[ 2 ] = me[ 2 ]; te[ 3 ] = me[ 3 ];\n\t\tte[ 4 ] = me[ 4 ]; te[ 5 ] = me[ 5 ]; te[ 6 ] = me[ 6 ]; te[ 7 ] = me[ 7 ];\n\t\tte[ 8 ] = me[ 8 ]; te[ 9 ] = me[ 9 ]; te[ 10 ] = me[ 10 ]; te[ 11 ] = me[ 11 ];\n\t\tte[ 12 ] = me[ 12 ]; te[ 13 ] = me[ 13 ]; te[ 14 ] = me[ 14 ]; te[ 15 ] = me[ 15 ];\n\n\t\treturn this;\n\n\t}\n\n\tcopyPosition( m ) {\n\n\t\tconst te = this.elements, me = m.elements;\n\n\t\tte[ 12 ] = me[ 12 ];\n\t\tte[ 13 ] = me[ 13 ];\n\t\tte[ 14 ] = me[ 14 ];\n\n\t\treturn this;\n\n\t}\n\n\tsetFromMatrix3( m ) {\n\n\t\tconst me = m.elements;\n\n\t\tthis.set(\n\n\t\t\tme[ 0 ], me[ 3 ], me[ 6 ], 0,\n\t\t\tme[ 1 ], me[ 4 ], me[ 7 ], 0,\n\t\t\tme[ 2 ], me[ 5 ], me[ 8 ], 0,\n\t\t\t0, 0, 0, 1\n\n\t\t);\n\n\t\treturn this;\n\n\t}\n\n\textractBasis( xAxis, yAxis, zAxis ) {\n\n\t\txAxis.setFromMatrixColumn( this, 0 );\n\t\tyAxis.setFromMatrixColumn( this, 1 );\n\t\tzAxis.setFromMatrixColumn( this, 2 );\n\n\t\treturn this;\n\n\t}\n\n\tmakeBasis( xAxis, yAxis, zAxis ) {\n\n\t\tthis.set(\n\t\t\txAxis.x, yAxis.x, zAxis.x, 0,\n\t\t\txAxis.y, yAxis.y, zAxis.y, 0,\n\t\t\txAxis.z, yAxis.z, zAxis.z, 0,\n\t\t\t0, 0, 0, 1\n\t\t);\n\n\t\treturn this;\n\n\t}\n\n\textractRotation( m ) {\n\n\t\t// this method does not support reflection matrices\n\n\t\tconst te = this.elements;\n\t\tconst me = m.elements;\n\n\t\tconst scaleX = 1 / _v1$5.setFromMatrixColumn( m, 0 ).length();\n\t\tconst scaleY = 1 / _v1$5.setFromMatrixColumn( m, 1 ).length();\n\t\tconst scaleZ = 1 / _v1$5.setFromMatrixColumn( m, 2 ).length();\n\n\t\tte[ 0 ] = me[ 0 ] * scaleX;\n\t\tte[ 1 ] = me[ 1 ] * scaleX;\n\t\tte[ 2 ] = me[ 2 ] * scaleX;\n\t\tte[ 3 ] = 0;\n\n\t\tte[ 4 ] = me[ 4 ] * scaleY;\n\t\tte[ 5 ] = me[ 5 ] * scaleY;\n\t\tte[ 6 ] = me[ 6 ] * scaleY;\n\t\tte[ 7 ] = 0;\n\n\t\tte[ 8 ] = me[ 8 ] * scaleZ;\n\t\tte[ 9 ] = me[ 9 ] * scaleZ;\n\t\tte[ 10 ] = me[ 10 ] * scaleZ;\n\t\tte[ 11 ] = 0;\n\n\t\tte[ 12 ] = 0;\n\t\tte[ 13 ] = 0;\n\t\tte[ 14 ] = 0;\n\t\tte[ 15 ] = 1;\n\n\t\treturn this;\n\n\t}\n\n\tmakeRotationFromEuler( euler ) {\n\n\t\tconst te = this.elements;\n\n\t\tconst x = euler.x, y = euler.y, z = euler.z;\n\t\tconst a = Math.cos( x ), b = Math.sin( x );\n\t\tconst c = Math.cos( y ), d = Math.sin( y );\n\t\tconst e = Math.cos( z ), f = Math.sin( z );\n\n\t\tif ( euler.order === 'XYZ' ) {\n\n\t\t\tconst ae = a * e, af = a * f, be = b * e, bf = b * f;\n\n\t\t\tte[ 0 ] = c * e;\n\t\t\tte[ 4 ] = - c * f;\n\t\t\tte[ 8 ] = d;\n\n\t\t\tte[ 1 ] = af + be * d;\n\t\t\tte[ 5 ] = ae - bf * d;\n\t\t\tte[ 9 ] = - b * c;\n\n\t\t\tte[ 2 ] = bf - ae * d;\n\t\t\tte[ 6 ] = be + af * d;\n\t\t\tte[ 10 ] = a * c;\n\n\t\t} else if ( euler.order === 'YXZ' ) {\n\n\t\t\tconst ce = c * e, cf = c * f, de = d * e, df = d * f;\n\n\t\t\tte[ 0 ] = ce + df * b;\n\t\t\tte[ 4 ] = de * b - cf;\n\t\t\tte[ 8 ] = a * d;\n\n\t\t\tte[ 1 ] = a * f;\n\t\t\tte[ 5 ] = a * e;\n\t\t\tte[ 9 ] = - b;\n\n\t\t\tte[ 2 ] = cf * b - de;\n\t\t\tte[ 6 ] = df + ce * b;\n\t\t\tte[ 10 ] = a * c;\n\n\t\t} else if ( euler.order === 'ZXY' ) {\n\n\t\t\tconst ce = c * e, cf = c * f, de = d * e, df = d * f;\n\n\t\t\tte[ 0 ] = ce - df * b;\n\t\t\tte[ 4 ] = - a * f;\n\t\t\tte[ 8 ] = de + cf * b;\n\n\t\t\tte[ 1 ] = cf + de * b;\n\t\t\tte[ 5 ] = a * e;\n\t\t\tte[ 9 ] = df - ce * b;\n\n\t\t\tte[ 2 ] = - a * d;\n\t\t\tte[ 6 ] = b;\n\t\t\tte[ 10 ] = a * c;\n\n\t\t} else if ( euler.order === 'ZYX' ) {\n\n\t\t\tconst ae = a * e, af = a * f, be = b * e, bf = b * f;\n\n\t\t\tte[ 0 ] = c * e;\n\t\t\tte[ 4 ] = be * d - af;\n\t\t\tte[ 8 ] = ae * d + bf;\n\n\t\t\tte[ 1 ] = c * f;\n\t\t\tte[ 5 ] = bf * d + ae;\n\t\t\tte[ 9 ] = af * d - be;\n\n\t\t\tte[ 2 ] = - d;\n\t\t\tte[ 6 ] = b * c;\n\t\t\tte[ 10 ] = a * c;\n\n\t\t} else if ( euler.order === 'YZX' ) {\n\n\t\t\tconst ac = a * c, ad = a * d, bc = b * c, bd = b * d;\n\n\t\t\tte[ 0 ] = c * e;\n\t\t\tte[ 4 ] = bd - ac * f;\n\t\t\tte[ 8 ] = bc * f + ad;\n\n\t\t\tte[ 1 ] = f;\n\t\t\tte[ 5 ] = a * e;\n\t\t\tte[ 9 ] = - b * e;\n\n\t\t\tte[ 2 ] = - d * e;\n\t\t\tte[ 6 ] = ad * f + bc;\n\t\t\tte[ 10 ] = ac - bd * f;\n\n\t\t} else if ( euler.order === 'XZY' ) {\n\n\t\t\tconst ac = a * c, ad = a * d, bc = b * c, bd = b * d;\n\n\t\t\tte[ 0 ] = c * e;\n\t\t\tte[ 4 ] = - f;\n\t\t\tte[ 8 ] = d * e;\n\n\t\t\tte[ 1 ] = ac * f + bd;\n\t\t\tte[ 5 ] = a * e;\n\t\t\tte[ 9 ] = ad * f - bc;\n\n\t\t\tte[ 2 ] = bc * f - ad;\n\t\t\tte[ 6 ] = b * e;\n\t\t\tte[ 10 ] = bd * f + ac;\n\n\t\t}\n\n\t\t// bottom row\n\t\tte[ 3 ] = 0;\n\t\tte[ 7 ] = 0;\n\t\tte[ 11 ] = 0;\n\n\t\t// last column\n\t\tte[ 12 ] = 0;\n\t\tte[ 13 ] = 0;\n\t\tte[ 14 ] = 0;\n\t\tte[ 15 ] = 1;\n\n\t\treturn this;\n\n\t}\n\n\tmakeRotationFromQuaternion( q ) {\n\n\t\treturn this.compose( _zero, q, _one );\n\n\t}\n\n\tlookAt( eye, target, up ) {\n\n\t\tconst te = this.elements;\n\n\t\t_z.subVectors( eye, target );\n\n\t\tif ( _z.lengthSq() === 0 ) {\n\n\t\t\t// eye and target are in the same position\n\n\t\t\t_z.z = 1;\n\n\t\t}\n\n\t\t_z.normalize();\n\t\t_x.crossVectors( up, _z );\n\n\t\tif ( _x.lengthSq() === 0 ) {\n\n\t\t\t// up and z are parallel\n\n\t\t\tif ( Math.abs( up.z ) === 1 ) {\n\n\t\t\t\t_z.x += 0.0001;\n\n\t\t\t} else {\n\n\t\t\t\t_z.z += 0.0001;\n\n\t\t\t}\n\n\t\t\t_z.normalize();\n\t\t\t_x.crossVectors( up, _z );\n\n\t\t}\n\n\t\t_x.normalize();\n\t\t_y.crossVectors( _z, _x );\n\n\t\tte[ 0 ] = _x.x; te[ 4 ] = _y.x; te[ 8 ] = _z.x;\n\t\tte[ 1 ] = _x.y; te[ 5 ] = _y.y; te[ 9 ] = _z.y;\n\t\tte[ 2 ] = _x.z; te[ 6 ] = _y.z; te[ 10 ] = _z.z;\n\n\t\treturn this;\n\n\t}\n\n\tmultiply( m ) {\n\n\t\treturn this.multiplyMatrices( this, m );\n\n\t}\n\n\tpremultiply( m ) {\n\n\t\treturn this.multiplyMatrices( m, this );\n\n\t}\n\n\tmultiplyMatrices( a, b ) {\n\n\t\tconst ae = a.elements;\n\t\tconst be = b.elements;\n\t\tconst te = this.elements;\n\n\t\tconst a11 = ae[ 0 ], a12 = ae[ 4 ], a13 = ae[ 8 ], a14 = ae[ 12 ];\n\t\tconst a21 = ae[ 1 ], a22 = ae[ 5 ], a23 = ae[ 9 ], a24 = ae[ 13 ];\n\t\tconst a31 = ae[ 2 ], a32 = ae[ 6 ], a33 = ae[ 10 ], a34 = ae[ 14 ];\n\t\tconst a41 = ae[ 3 ], a42 = ae[ 7 ], a43 = ae[ 11 ], a44 = ae[ 15 ];\n\n\t\tconst b11 = be[ 0 ], b12 = be[ 4 ], b13 = be[ 8 ], b14 = be[ 12 ];\n\t\tconst b21 = be[ 1 ], b22 = be[ 5 ], b23 = be[ 9 ], b24 = be[ 13 ];\n\t\tconst b31 = be[ 2 ], b32 = be[ 6 ], b33 = be[ 10 ], b34 = be[ 14 ];\n\t\tconst b41 = be[ 3 ], b42 = be[ 7 ], b43 = be[ 11 ], b44 = be[ 15 ];\n\n\t\tte[ 0 ] = a11 * b11 + a12 * b21 + a13 * b31 + a14 * b41;\n\t\tte[ 4 ] = a11 * b12 + a12 * b22 + a13 * b32 + a14 * b42;\n\t\tte[ 8 ] = a11 * b13 + a12 * b23 + a13 * b33 + a14 * b43;\n\t\tte[ 12 ] = a11 * b14 + a12 * b24 + a13 * b34 + a14 * b44;\n\n\t\tte[ 1 ] = a21 * b11 + a22 * b21 + a23 * b31 + a24 * b41;\n\t\tte[ 5 ] = a21 * b12 + a22 * b22 + a23 * b32 + a24 * b42;\n\t\tte[ 9 ] = a21 * b13 + a22 * b23 + a23 * b33 + a24 * b43;\n\t\tte[ 13 ] = a21 * b14 + a22 * b24 + a23 * b34 + a24 * b44;\n\n\t\tte[ 2 ] = a31 * b11 + a32 * b21 + a33 * b31 + a34 * b41;\n\t\tte[ 6 ] = a31 * b12 + a32 * b22 + a33 * b32 + a34 * b42;\n\t\tte[ 10 ] = a31 * b13 + a32 * b23 + a33 * b33 + a34 * b43;\n\t\tte[ 14 ] = a31 * b14 + a32 * b24 + a33 * b34 + a34 * b44;\n\n\t\tte[ 3 ] = a41 * b11 + a42 * b21 + a43 * b31 + a44 * b41;\n\t\tte[ 7 ] = a41 * b12 + a42 * b22 + a43 * b32 + a44 * b42;\n\t\tte[ 11 ] = a41 * b13 + a42 * b23 + a43 * b33 + a44 * b43;\n\t\tte[ 15 ] = a41 * b14 + a42 * b24 + a43 * b34 + a44 * b44;\n\n\t\treturn this;\n\n\t}\n\n\tmultiplyScalar( s ) {\n\n\t\tconst te = this.elements;\n\n\t\tte[ 0 ] *= s; te[ 4 ] *= s; te[ 8 ] *= s; te[ 12 ] *= s;\n\t\tte[ 1 ] *= s; te[ 5 ] *= s; te[ 9 ] *= s; te[ 13 ] *= s;\n\t\tte[ 2 ] *= s; te[ 6 ] *= s; te[ 10 ] *= s; te[ 14 ] *= s;\n\t\tte[ 3 ] *= s; te[ 7 ] *= s; te[ 11 ] *= s; te[ 15 ] *= s;\n\n\t\treturn this;\n\n\t}\n\n\tdeterminant() {\n\n\t\tconst te = this.elements;\n\n\t\tconst n11 = te[ 0 ], n12 = te[ 4 ], n13 = te[ 8 ], n14 = te[ 12 ];\n\t\tconst n21 = te[ 1 ], n22 = te[ 5 ], n23 = te[ 9 ], n24 = te[ 13 ];\n\t\tconst n31 = te[ 2 ], n32 = te[ 6 ], n33 = te[ 10 ], n34 = te[ 14 ];\n\t\tconst n41 = te[ 3 ], n42 = te[ 7 ], n43 = te[ 11 ], n44 = te[ 15 ];\n\n\t\t//TODO: make this more efficient\n\t\t//( based on http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm )\n\n\t\treturn (\n\t\t\tn41 * (\n\t\t\t\t+ n14 * n23 * n32\n\t\t\t\t - n13 * n24 * n32\n\t\t\t\t - n14 * n22 * n33\n\t\t\t\t + n12 * n24 * n33\n\t\t\t\t + n13 * n22 * n34\n\t\t\t\t - n12 * n23 * n34\n\t\t\t) +\n\t\t\tn42 * (\n\t\t\t\t+ n11 * n23 * n34\n\t\t\t\t - n11 * n24 * n33\n\t\t\t\t + n14 * n21 * n33\n\t\t\t\t - n13 * n21 * n34\n\t\t\t\t + n13 * n24 * n31\n\t\t\t\t - n14 * n23 * n31\n\t\t\t) +\n\t\t\tn43 * (\n\t\t\t\t+ n11 * n24 * n32\n\t\t\t\t - n11 * n22 * n34\n\t\t\t\t - n14 * n21 * n32\n\t\t\t\t + n12 * n21 * n34\n\t\t\t\t + n14 * n22 * n31\n\t\t\t\t - n12 * n24 * n31\n\t\t\t) +\n\t\t\tn44 * (\n\t\t\t\t- n13 * n22 * n31\n\t\t\t\t - n11 * n23 * n32\n\t\t\t\t + n11 * n22 * n33\n\t\t\t\t + n13 * n21 * n32\n\t\t\t\t - n12 * n21 * n33\n\t\t\t\t + n12 * n23 * n31\n\t\t\t)\n\n\t\t);\n\n\t}\n\n\ttranspose() {\n\n\t\tconst te = this.elements;\n\t\tlet tmp;\n\n\t\ttmp = te[ 1 ]; te[ 1 ] = te[ 4 ]; te[ 4 ] = tmp;\n\t\ttmp = te[ 2 ]; te[ 2 ] = te[ 8 ]; te[ 8 ] = tmp;\n\t\ttmp = te[ 6 ]; te[ 6 ] = te[ 9 ]; te[ 9 ] = tmp;\n\n\t\ttmp = te[ 3 ]; te[ 3 ] = te[ 12 ]; te[ 12 ] = tmp;\n\t\ttmp = te[ 7 ]; te[ 7 ] = te[ 13 ]; te[ 13 ] = tmp;\n\t\ttmp = te[ 11 ]; te[ 11 ] = te[ 14 ]; te[ 14 ] = tmp;\n\n\t\treturn this;\n\n\t}\n\n\tsetPosition( x, y, z ) {\n\n\t\tconst te = this.elements;\n\n\t\tif ( x.isVector3 ) {\n\n\t\t\tte[ 12 ] = x.x;\n\t\t\tte[ 13 ] = x.y;\n\t\t\tte[ 14 ] = x.z;\n\n\t\t} else {\n\n\t\t\tte[ 12 ] = x;\n\t\t\tte[ 13 ] = y;\n\t\t\tte[ 14 ] = z;\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tinvert() {\n\n\t\t// based on http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm\n\t\tconst te = this.elements,\n\n\t\t\tn11 = te[ 0 ], n21 = te[ 1 ], n31 = te[ 2 ], n41 = te[ 3 ],\n\t\t\tn12 = te[ 4 ], n22 = te[ 5 ], n32 = te[ 6 ], n42 = te[ 7 ],\n\t\t\tn13 = te[ 8 ], n23 = te[ 9 ], n33 = te[ 10 ], n43 = te[ 11 ],\n\t\t\tn14 = te[ 12 ], n24 = te[ 13 ], n34 = te[ 14 ], n44 = te[ 15 ],\n\n\t\t\tt11 = n23 * n34 * n42 - n24 * n33 * n42 + n24 * n32 * n43 - n22 * n34 * n43 - n23 * n32 * n44 + n22 * n33 * n44,\n\t\t\tt12 = n14 * n33 * n42 - n13 * n34 * n42 - n14 * n32 * n43 + n12 * n34 * n43 + n13 * n32 * n44 - n12 * n33 * n44,\n\t\t\tt13 = n13 * n24 * n42 - n14 * n23 * n42 + n14 * n22 * n43 - n12 * n24 * n43 - n13 * n22 * n44 + n12 * n23 * n44,\n\t\t\tt14 = n14 * n23 * n32 - n13 * n24 * n32 - n14 * n22 * n33 + n12 * n24 * n33 + n13 * n22 * n34 - n12 * n23 * n34;\n\n\t\tconst det = n11 * t11 + n21 * t12 + n31 * t13 + n41 * t14;\n\n\t\tif ( det === 0 ) return this.set( 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 );\n\n\t\tconst detInv = 1 / det;\n\n\t\tte[ 0 ] = t11 * detInv;\n\t\tte[ 1 ] = ( n24 * n33 * n41 - n23 * n34 * n41 - n24 * n31 * n43 + n21 * n34 * n43 + n23 * n31 * n44 - n21 * n33 * n44 ) * detInv;\n\t\tte[ 2 ] = ( n22 * n34 * n41 - n24 * n32 * n41 + n24 * n31 * n42 - n21 * n34 * n42 - n22 * n31 * n44 + n21 * n32 * n44 ) * detInv;\n\t\tte[ 3 ] = ( n23 * n32 * n41 - n22 * n33 * n41 - n23 * n31 * n42 + n21 * n33 * n42 + n22 * n31 * n43 - n21 * n32 * n43 ) * detInv;\n\n\t\tte[ 4 ] = t12 * detInv;\n\t\tte[ 5 ] = ( n13 * n34 * n41 - n14 * n33 * n41 + n14 * n31 * n43 - n11 * n34 * n43 - n13 * n31 * n44 + n11 * n33 * n44 ) * detInv;\n\t\tte[ 6 ] = ( n14 * n32 * n41 - n12 * n34 * n41 - n14 * n31 * n42 + n11 * n34 * n42 + n12 * n31 * n44 - n11 * n32 * n44 ) * detInv;\n\t\tte[ 7 ] = ( n12 * n33 * n41 - n13 * n32 * n41 + n13 * n31 * n42 - n11 * n33 * n42 - n12 * n31 * n43 + n11 * n32 * n43 ) * detInv;\n\n\t\tte[ 8 ] = t13 * detInv;\n\t\tte[ 9 ] = ( n14 * n23 * n41 - n13 * n24 * n41 - n14 * n21 * n43 + n11 * n24 * n43 + n13 * n21 * n44 - n11 * n23 * n44 ) * detInv;\n\t\tte[ 10 ] = ( n12 * n24 * n41 - n14 * n22 * n41 + n14 * n21 * n42 - n11 * n24 * n42 - n12 * n21 * n44 + n11 * n22 * n44 ) * detInv;\n\t\tte[ 11 ] = ( n13 * n22 * n41 - n12 * n23 * n41 - n13 * n21 * n42 + n11 * n23 * n42 + n12 * n21 * n43 - n11 * n22 * n43 ) * detInv;\n\n\t\tte[ 12 ] = t14 * detInv;\n\t\tte[ 13 ] = ( n13 * n24 * n31 - n14 * n23 * n31 + n14 * n21 * n33 - n11 * n24 * n33 - n13 * n21 * n34 + n11 * n23 * n34 ) * detInv;\n\t\tte[ 14 ] = ( n14 * n22 * n31 - n12 * n24 * n31 - n14 * n21 * n32 + n11 * n24 * n32 + n12 * n21 * n34 - n11 * n22 * n34 ) * detInv;\n\t\tte[ 15 ] = ( n12 * n23 * n31 - n13 * n22 * n31 + n13 * n21 * n32 - n11 * n23 * n32 - n12 * n21 * n33 + n11 * n22 * n33 ) * detInv;\n\n\t\treturn this;\n\n\t}\n\n\tscale( v ) {\n\n\t\tconst te = this.elements;\n\t\tconst x = v.x, y = v.y, z = v.z;\n\n\t\tte[ 0 ] *= x; te[ 4 ] *= y; te[ 8 ] *= z;\n\t\tte[ 1 ] *= x; te[ 5 ] *= y; te[ 9 ] *= z;\n\t\tte[ 2 ] *= x; te[ 6 ] *= y; te[ 10 ] *= z;\n\t\tte[ 3 ] *= x; te[ 7 ] *= y; te[ 11 ] *= z;\n\n\t\treturn this;\n\n\t}\n\n\tgetMaxScaleOnAxis() {\n\n\t\tconst te = this.elements;\n\n\t\tconst scaleXSq = te[ 0 ] * te[ 0 ] + te[ 1 ] * te[ 1 ] + te[ 2 ] * te[ 2 ];\n\t\tconst scaleYSq = te[ 4 ] * te[ 4 ] + te[ 5 ] * te[ 5 ] + te[ 6 ] * te[ 6 ];\n\t\tconst scaleZSq = te[ 8 ] * te[ 8 ] + te[ 9 ] * te[ 9 ] + te[ 10 ] * te[ 10 ];\n\n\t\treturn Math.sqrt( Math.max( scaleXSq, scaleYSq, scaleZSq ) );\n\n\t}\n\n\tmakeTranslation( x, y, z ) {\n\n\t\tif ( x.isVector3 ) {\n\n\t\t\tthis.set(\n\n\t\t\t\t1, 0, 0, x.x,\n\t\t\t\t0, 1, 0, x.y,\n\t\t\t\t0, 0, 1, x.z,\n\t\t\t\t0, 0, 0, 1\n\n\t\t\t);\n\n\t\t} else {\n\n\t\t\tthis.set(\n\n\t\t\t\t1, 0, 0, x,\n\t\t\t\t0, 1, 0, y,\n\t\t\t\t0, 0, 1, z,\n\t\t\t\t0, 0, 0, 1\n\n\t\t\t);\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tmakeRotationX( theta ) {\n\n\t\tconst c = Math.cos( theta ), s = Math.sin( theta );\n\n\t\tthis.set(\n\n\t\t\t1, 0, 0, 0,\n\t\t\t0, c, - s, 0,\n\t\t\t0, s, c, 0,\n\t\t\t0, 0, 0, 1\n\n\t\t);\n\n\t\treturn this;\n\n\t}\n\n\tmakeRotationY( theta ) {\n\n\t\tconst c = Math.cos( theta ), s = Math.sin( theta );\n\n\t\tthis.set(\n\n\t\t\t c, 0, s, 0,\n\t\t\t 0, 1, 0, 0,\n\t\t\t- s, 0, c, 0,\n\t\t\t 0, 0, 0, 1\n\n\t\t);\n\n\t\treturn this;\n\n\t}\n\n\tmakeRotationZ( theta ) {\n\n\t\tconst c = Math.cos( theta ), s = Math.sin( theta );\n\n\t\tthis.set(\n\n\t\t\tc, - s, 0, 0,\n\t\t\ts, c, 0, 0,\n\t\t\t0, 0, 1, 0,\n\t\t\t0, 0, 0, 1\n\n\t\t);\n\n\t\treturn this;\n\n\t}\n\n\tmakeRotationAxis( axis, angle ) {\n\n\t\t// Based on http://www.gamedev.net/reference/articles/article1199.asp\n\n\t\tconst c = Math.cos( angle );\n\t\tconst s = Math.sin( angle );\n\t\tconst t = 1 - c;\n\t\tconst x = axis.x, y = axis.y, z = axis.z;\n\t\tconst tx = t * x, ty = t * y;\n\n\t\tthis.set(\n\n\t\t\ttx * x + c, tx * y - s * z, tx * z + s * y, 0,\n\t\t\ttx * y + s * z, ty * y + c, ty * z - s * x, 0,\n\t\t\ttx * z - s * y, ty * z + s * x, t * z * z + c, 0,\n\t\t\t0, 0, 0, 1\n\n\t\t);\n\n\t\treturn this;\n\n\t}\n\n\tmakeScale( x, y, z ) {\n\n\t\tthis.set(\n\n\t\t\tx, 0, 0, 0,\n\t\t\t0, y, 0, 0,\n\t\t\t0, 0, z, 0,\n\t\t\t0, 0, 0, 1\n\n\t\t);\n\n\t\treturn this;\n\n\t}\n\n\tmakeShear( xy, xz, yx, yz, zx, zy ) {\n\n\t\tthis.set(\n\n\t\t\t1, yx, zx, 0,\n\t\t\txy, 1, zy, 0,\n\t\t\txz, yz, 1, 0,\n\t\t\t0, 0, 0, 1\n\n\t\t);\n\n\t\treturn this;\n\n\t}\n\n\tcompose( position, quaternion, scale ) {\n\n\t\tconst te = this.elements;\n\n\t\tconst x = quaternion._x, y = quaternion._y, z = quaternion._z, w = quaternion._w;\n\t\tconst x2 = x + x,\ty2 = y + y, z2 = z + z;\n\t\tconst xx = x * x2, xy = x * y2, xz = x * z2;\n\t\tconst yy = y * y2, yz = y * z2, zz = z * z2;\n\t\tconst wx = w * x2, wy = w * y2, wz = w * z2;\n\n\t\tconst sx = scale.x, sy = scale.y, sz = scale.z;\n\n\t\tte[ 0 ] = ( 1 - ( yy + zz ) ) * sx;\n\t\tte[ 1 ] = ( xy + wz ) * sx;\n\t\tte[ 2 ] = ( xz - wy ) * sx;\n\t\tte[ 3 ] = 0;\n\n\t\tte[ 4 ] = ( xy - wz ) * sy;\n\t\tte[ 5 ] = ( 1 - ( xx + zz ) ) * sy;\n\t\tte[ 6 ] = ( yz + wx ) * sy;\n\t\tte[ 7 ] = 0;\n\n\t\tte[ 8 ] = ( xz + wy ) * sz;\n\t\tte[ 9 ] = ( yz - wx ) * sz;\n\t\tte[ 10 ] = ( 1 - ( xx + yy ) ) * sz;\n\t\tte[ 11 ] = 0;\n\n\t\tte[ 12 ] = position.x;\n\t\tte[ 13 ] = position.y;\n\t\tte[ 14 ] = position.z;\n\t\tte[ 15 ] = 1;\n\n\t\treturn this;\n\n\t}\n\n\tdecompose( position, quaternion, scale ) {\n\n\t\tconst te = this.elements;\n\n\t\tlet sx = _v1$5.set( te[ 0 ], te[ 1 ], te[ 2 ] ).length();\n\t\tconst sy = _v1$5.set( te[ 4 ], te[ 5 ], te[ 6 ] ).length();\n\t\tconst sz = _v1$5.set( te[ 8 ], te[ 9 ], te[ 10 ] ).length();\n\n\t\t// if determine is negative, we need to invert one scale\n\t\tconst det = this.determinant();\n\t\tif ( det < 0 ) sx = - sx;\n\n\t\tposition.x = te[ 12 ];\n\t\tposition.y = te[ 13 ];\n\t\tposition.z = te[ 14 ];\n\n\t\t// scale the rotation part\n\t\t_m1$4.copy( this );\n\n\t\tconst invSX = 1 / sx;\n\t\tconst invSY = 1 / sy;\n\t\tconst invSZ = 1 / sz;\n\n\t\t_m1$4.elements[ 0 ] *= invSX;\n\t\t_m1$4.elements[ 1 ] *= invSX;\n\t\t_m1$4.elements[ 2 ] *= invSX;\n\n\t\t_m1$4.elements[ 4 ] *= invSY;\n\t\t_m1$4.elements[ 5 ] *= invSY;\n\t\t_m1$4.elements[ 6 ] *= invSY;\n\n\t\t_m1$4.elements[ 8 ] *= invSZ;\n\t\t_m1$4.elements[ 9 ] *= invSZ;\n\t\t_m1$4.elements[ 10 ] *= invSZ;\n\n\t\tquaternion.setFromRotationMatrix( _m1$4 );\n\n\t\tscale.x = sx;\n\t\tscale.y = sy;\n\t\tscale.z = sz;\n\n\t\treturn this;\n\n\t}\n\n\tmakePerspective( left, right, top, bottom, near, far, coordinateSystem = WebGLCoordinateSystem ) {\n\n\t\tconst te = this.elements;\n\t\tconst x = 2 * near / ( right - left );\n\t\tconst y = 2 * near / ( top - bottom );\n\n\t\tconst a = ( right + left ) / ( right - left );\n\t\tconst b = ( top + bottom ) / ( top - bottom );\n\n\t\tlet c, d;\n\n\t\tif ( coordinateSystem === WebGLCoordinateSystem ) {\n\n\t\t\tc = - ( far + near ) / ( far - near );\n\t\t\td = ( - 2 * far * near ) / ( far - near );\n\n\t\t} else if ( coordinateSystem === WebGPUCoordinateSystem ) {\n\n\t\t\tc = - far / ( far - near );\n\t\t\td = ( - far * near ) / ( far - near );\n\n\t\t} else {\n\n\t\t\tthrow new Error( 'THREE.Matrix4.makePerspective(): Invalid coordinate system: ' + coordinateSystem );\n\n\t\t}\n\n\t\tte[ 0 ] = x;\tte[ 4 ] = 0;\tte[ 8 ] = a; \tte[ 12 ] = 0;\n\t\tte[ 1 ] = 0;\tte[ 5 ] = y;\tte[ 9 ] = b; \tte[ 13 ] = 0;\n\t\tte[ 2 ] = 0;\tte[ 6 ] = 0;\tte[ 10 ] = c; \tte[ 14 ] = d;\n\t\tte[ 3 ] = 0;\tte[ 7 ] = 0;\tte[ 11 ] = - 1;\tte[ 15 ] = 0;\n\n\t\treturn this;\n\n\t}\n\n\tmakeOrthographic( left, right, top, bottom, near, far, coordinateSystem = WebGLCoordinateSystem ) {\n\n\t\tconst te = this.elements;\n\t\tconst w = 1.0 / ( right - left );\n\t\tconst h = 1.0 / ( top - bottom );\n\t\tconst p = 1.0 / ( far - near );\n\n\t\tconst x = ( right + left ) * w;\n\t\tconst y = ( top + bottom ) * h;\n\n\t\tlet z, zInv;\n\n\t\tif ( coordinateSystem === WebGLCoordinateSystem ) {\n\n\t\t\tz = ( far + near ) * p;\n\t\t\tzInv = - 2 * p;\n\n\t\t} else if ( coordinateSystem === WebGPUCoordinateSystem ) {\n\n\t\t\tz = near * p;\n\t\t\tzInv = - 1 * p;\n\n\t\t} else {\n\n\t\t\tthrow new Error( 'THREE.Matrix4.makeOrthographic(): Invalid coordinate system: ' + coordinateSystem );\n\n\t\t}\n\n\t\tte[ 0 ] = 2 * w;\tte[ 4 ] = 0;\t\tte[ 8 ] = 0; \t\tte[ 12 ] = - x;\n\t\tte[ 1 ] = 0; \t\tte[ 5 ] = 2 * h;\tte[ 9 ] = 0; \t\tte[ 13 ] = - y;\n\t\tte[ 2 ] = 0; \t\tte[ 6 ] = 0;\t\tte[ 10 ] = zInv;\tte[ 14 ] = - z;\n\t\tte[ 3 ] = 0; \t\tte[ 7 ] = 0;\t\tte[ 11 ] = 0;\t\tte[ 15 ] = 1;\n\n\t\treturn this;\n\n\t}\n\n\tequals( matrix ) {\n\n\t\tconst te = this.elements;\n\t\tconst me = matrix.elements;\n\n\t\tfor ( let i = 0; i < 16; i ++ ) {\n\n\t\t\tif ( te[ i ] !== me[ i ] ) return false;\n\n\t\t}\n\n\t\treturn true;\n\n\t}\n\n\tfromArray( array, offset = 0 ) {\n\n\t\tfor ( let i = 0; i < 16; i ++ ) {\n\n\t\t\tthis.elements[ i ] = array[ i + offset ];\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\ttoArray( array = [], offset = 0 ) {\n\n\t\tconst te = this.elements;\n\n\t\tarray[ offset ] = te[ 0 ];\n\t\tarray[ offset + 1 ] = te[ 1 ];\n\t\tarray[ offset + 2 ] = te[ 2 ];\n\t\tarray[ offset + 3 ] = te[ 3 ];\n\n\t\tarray[ offset + 4 ] = te[ 4 ];\n\t\tarray[ offset + 5 ] = te[ 5 ];\n\t\tarray[ offset + 6 ] = te[ 6 ];\n\t\tarray[ offset + 7 ] = te[ 7 ];\n\n\t\tarray[ offset + 8 ] = te[ 8 ];\n\t\tarray[ offset + 9 ] = te[ 9 ];\n\t\tarray[ offset + 10 ] = te[ 10 ];\n\t\tarray[ offset + 11 ] = te[ 11 ];\n\n\t\tarray[ offset + 12 ] = te[ 12 ];\n\t\tarray[ offset + 13 ] = te[ 13 ];\n\t\tarray[ offset + 14 ] = te[ 14 ];\n\t\tarray[ offset + 15 ] = te[ 15 ];\n\n\t\treturn array;\n\n\t}\n\n}\n\nconst _v1$5 = /*@__PURE__*/ new Vector3();\nconst _m1$4 = /*@__PURE__*/ new Matrix4();\nconst _zero = /*@__PURE__*/ new Vector3( 0, 0, 0 );\nconst _one = /*@__PURE__*/ new Vector3( 1, 1, 1 );\nconst _x = /*@__PURE__*/ new Vector3();\nconst _y = /*@__PURE__*/ new Vector3();\nconst _z = /*@__PURE__*/ new Vector3();\n\nconst _matrix$2 = /*@__PURE__*/ new Matrix4();\nconst _quaternion$3 = /*@__PURE__*/ new Quaternion();\n\nclass Euler {\n\n\tconstructor( x = 0, y = 0, z = 0, order = Euler.DEFAULT_ORDER ) {\n\n\t\tthis.isEuler = true;\n\n\t\tthis._x = x;\n\t\tthis._y = y;\n\t\tthis._z = z;\n\t\tthis._order = order;\n\n\t}\n\n\tget x() {\n\n\t\treturn this._x;\n\n\t}\n\n\tset x( value ) {\n\n\t\tthis._x = value;\n\t\tthis._onChangeCallback();\n\n\t}\n\n\tget y() {\n\n\t\treturn this._y;\n\n\t}\n\n\tset y( value ) {\n\n\t\tthis._y = value;\n\t\tthis._onChangeCallback();\n\n\t}\n\n\tget z() {\n\n\t\treturn this._z;\n\n\t}\n\n\tset z( value ) {\n\n\t\tthis._z = value;\n\t\tthis._onChangeCallback();\n\n\t}\n\n\tget order() {\n\n\t\treturn this._order;\n\n\t}\n\n\tset order( value ) {\n\n\t\tthis._order = value;\n\t\tthis._onChangeCallback();\n\n\t}\n\n\tset( x, y, z, order = this._order ) {\n\n\t\tthis._x = x;\n\t\tthis._y = y;\n\t\tthis._z = z;\n\t\tthis._order = order;\n\n\t\tthis._onChangeCallback();\n\n\t\treturn this;\n\n\t}\n\n\tclone() {\n\n\t\treturn new this.constructor( this._x, this._y, this._z, this._order );\n\n\t}\n\n\tcopy( euler ) {\n\n\t\tthis._x = euler._x;\n\t\tthis._y = euler._y;\n\t\tthis._z = euler._z;\n\t\tthis._order = euler._order;\n\n\t\tthis._onChangeCallback();\n\n\t\treturn this;\n\n\t}\n\n\tsetFromRotationMatrix( m, order = this._order, update = true ) {\n\n\t\t// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)\n\n\t\tconst te = m.elements;\n\t\tconst m11 = te[ 0 ], m12 = te[ 4 ], m13 = te[ 8 ];\n\t\tconst m21 = te[ 1 ], m22 = te[ 5 ], m23 = te[ 9 ];\n\t\tconst m31 = te[ 2 ], m32 = te[ 6 ], m33 = te[ 10 ];\n\n\t\tswitch ( order ) {\n\n\t\t\tcase 'XYZ':\n\n\t\t\t\tthis._y = Math.asin( clamp( m13, - 1, 1 ) );\n\n\t\t\t\tif ( Math.abs( m13 ) < 0.9999999 ) {\n\n\t\t\t\t\tthis._x = Math.atan2( - m23, m33 );\n\t\t\t\t\tthis._z = Math.atan2( - m12, m11 );\n\n\t\t\t\t} else {\n\n\t\t\t\t\tthis._x = Math.atan2( m32, m22 );\n\t\t\t\t\tthis._z = 0;\n\n\t\t\t\t}\n\n\t\t\t\tbreak;\n\n\t\t\tcase 'YXZ':\n\n\t\t\t\tthis._x = Math.asin( - clamp( m23, - 1, 1 ) );\n\n\t\t\t\tif ( Math.abs( m23 ) < 0.9999999 ) {\n\n\t\t\t\t\tthis._y = Math.atan2( m13, m33 );\n\t\t\t\t\tthis._z = Math.atan2( m21, m22 );\n\n\t\t\t\t} else {\n\n\t\t\t\t\tthis._y = Math.atan2( - m31, m11 );\n\t\t\t\t\tthis._z = 0;\n\n\t\t\t\t}\n\n\t\t\t\tbreak;\n\n\t\t\tcase 'ZXY':\n\n\t\t\t\tthis._x = Math.asin( clamp( m32, - 1, 1 ) );\n\n\t\t\t\tif ( Math.abs( m32 ) < 0.9999999 ) {\n\n\t\t\t\t\tthis._y = Math.atan2( - m31, m33 );\n\t\t\t\t\tthis._z = Math.atan2( - m12, m22 );\n\n\t\t\t\t} else {\n\n\t\t\t\t\tthis._y = 0;\n\t\t\t\t\tthis._z = Math.atan2( m21, m11 );\n\n\t\t\t\t}\n\n\t\t\t\tbreak;\n\n\t\t\tcase 'ZYX':\n\n\t\t\t\tthis._y = Math.asin( - clamp( m31, - 1, 1 ) );\n\n\t\t\t\tif ( Math.abs( m31 ) < 0.9999999 ) {\n\n\t\t\t\t\tthis._x = Math.atan2( m32, m33 );\n\t\t\t\t\tthis._z = Math.atan2( m21, m11 );\n\n\t\t\t\t} else {\n\n\t\t\t\t\tthis._x = 0;\n\t\t\t\t\tthis._z = Math.atan2( - m12, m22 );\n\n\t\t\t\t}\n\n\t\t\t\tbreak;\n\n\t\t\tcase 'YZX':\n\n\t\t\t\tthis._z = Math.asin( clamp( m21, - 1, 1 ) );\n\n\t\t\t\tif ( Math.abs( m21 ) < 0.9999999 ) {\n\n\t\t\t\t\tthis._x = Math.atan2( - m23, m22 );\n\t\t\t\t\tthis._y = Math.atan2( - m31, m11 );\n\n\t\t\t\t} else {\n\n\t\t\t\t\tthis._x = 0;\n\t\t\t\t\tthis._y = Math.atan2( m13, m33 );\n\n\t\t\t\t}\n\n\t\t\t\tbreak;\n\n\t\t\tcase 'XZY':\n\n\t\t\t\tthis._z = Math.asin( - clamp( m12, - 1, 1 ) );\n\n\t\t\t\tif ( Math.abs( m12 ) < 0.9999999 ) {\n\n\t\t\t\t\tthis._x = Math.atan2( m32, m22 );\n\t\t\t\t\tthis._y = Math.atan2( m13, m11 );\n\n\t\t\t\t} else {\n\n\t\t\t\t\tthis._x = Math.atan2( - m23, m33 );\n\t\t\t\t\tthis._y = 0;\n\n\t\t\t\t}\n\n\t\t\t\tbreak;\n\n\t\t\tdefault:\n\n\t\t\t\tconsole.warn( 'THREE.Euler: .setFromRotationMatrix() encountered an unknown order: ' + order );\n\n\t\t}\n\n\t\tthis._order = order;\n\n\t\tif ( update === true ) this._onChangeCallback();\n\n\t\treturn this;\n\n\t}\n\n\tsetFromQuaternion( q, order, update ) {\n\n\t\t_matrix$2.makeRotationFromQuaternion( q );\n\n\t\treturn this.setFromRotationMatrix( _matrix$2, order, update );\n\n\t}\n\n\tsetFromVector3( v, order = this._order ) {\n\n\t\treturn this.set( v.x, v.y, v.z, order );\n\n\t}\n\n\treorder( newOrder ) {\n\n\t\t// WARNING: this discards revolution information -bhouston\n\n\t\t_quaternion$3.setFromEuler( this );\n\n\t\treturn this.setFromQuaternion( _quaternion$3, newOrder );\n\n\t}\n\n\tequals( euler ) {\n\n\t\treturn ( euler._x === this._x ) && ( euler._y === this._y ) && ( euler._z === this._z ) && ( euler._order === this._order );\n\n\t}\n\n\tfromArray( array ) {\n\n\t\tthis._x = array[ 0 ];\n\t\tthis._y = array[ 1 ];\n\t\tthis._z = array[ 2 ];\n\t\tif ( array[ 3 ] !== undefined ) this._order = array[ 3 ];\n\n\t\tthis._onChangeCallback();\n\n\t\treturn this;\n\n\t}\n\n\ttoArray( array = [], offset = 0 ) {\n\n\t\tarray[ offset ] = this._x;\n\t\tarray[ offset + 1 ] = this._y;\n\t\tarray[ offset + 2 ] = this._z;\n\t\tarray[ offset + 3 ] = this._order;\n\n\t\treturn array;\n\n\t}\n\n\t_onChange( callback ) {\n\n\t\tthis._onChangeCallback = callback;\n\n\t\treturn this;\n\n\t}\n\n\t_onChangeCallback() {}\n\n\t*[ Symbol.iterator ]() {\n\n\t\tyield this._x;\n\t\tyield this._y;\n\t\tyield this._z;\n\t\tyield this._order;\n\n\t}\n\n}\n\nEuler.DEFAULT_ORDER = 'XYZ';\n\nclass Layers {\n\n\tconstructor() {\n\n\t\tthis.mask = 1 | 0;\n\n\t}\n\n\tset( channel ) {\n\n\t\tthis.mask = ( 1 << channel | 0 ) >>> 0;\n\n\t}\n\n\tenable( channel ) {\n\n\t\tthis.mask |= 1 << channel | 0;\n\n\t}\n\n\tenableAll() {\n\n\t\tthis.mask = 0xffffffff | 0;\n\n\t}\n\n\ttoggle( channel ) {\n\n\t\tthis.mask ^= 1 << channel | 0;\n\n\t}\n\n\tdisable( channel ) {\n\n\t\tthis.mask &= ~ ( 1 << channel | 0 );\n\n\t}\n\n\tdisableAll() {\n\n\t\tthis.mask = 0;\n\n\t}\n\n\ttest( layers ) {\n\n\t\treturn ( this.mask & layers.mask ) !== 0;\n\n\t}\n\n\tisEnabled( channel ) {\n\n\t\treturn ( this.mask & ( 1 << channel | 0 ) ) !== 0;\n\n\t}\n\n}\n\nlet _object3DId = 0;\n\nconst _v1$4 = /*@__PURE__*/ new Vector3();\nconst _q1 = /*@__PURE__*/ new Quaternion();\nconst _m1$3 = /*@__PURE__*/ new Matrix4();\nconst _target = /*@__PURE__*/ new Vector3();\n\nconst _position$3 = /*@__PURE__*/ new Vector3();\nconst _scale$2 = /*@__PURE__*/ new Vector3();\nconst _quaternion$2 = /*@__PURE__*/ new Quaternion();\n\nconst _xAxis = /*@__PURE__*/ new Vector3( 1, 0, 0 );\nconst _yAxis = /*@__PURE__*/ new Vector3( 0, 1, 0 );\nconst _zAxis = /*@__PURE__*/ new Vector3( 0, 0, 1 );\n\nconst _addedEvent = { type: 'added' };\nconst _removedEvent = { type: 'removed' };\n\nconst _childaddedEvent = { type: 'childadded', child: null };\nconst _childremovedEvent = { type: 'childremoved', child: null };\n\nclass Object3D extends EventDispatcher {\n\n\tconstructor() {\n\n\t\tsuper();\n\n\t\tthis.isObject3D = true;\n\n\t\tObject.defineProperty( this, 'id', { value: _object3DId ++ } );\n\n\t\tthis.uuid = generateUUID();\n\n\t\tthis.name = '';\n\t\tthis.type = 'Object3D';\n\n\t\tthis.parent = null;\n\t\tthis.children = [];\n\n\t\tthis.up = Object3D.DEFAULT_UP.clone();\n\n\t\tconst position = new Vector3();\n\t\tconst rotation = new Euler();\n\t\tconst quaternion = new Quaternion();\n\t\tconst scale = new Vector3( 1, 1, 1 );\n\n\t\tfunction onRotationChange() {\n\n\t\t\tquaternion.setFromEuler( rotation, false );\n\n\t\t}\n\n\t\tfunction onQuaternionChange() {\n\n\t\t\trotation.setFromQuaternion( quaternion, undefined, false );\n\n\t\t}\n\n\t\trotation._onChange( onRotationChange );\n\t\tquaternion._onChange( onQuaternionChange );\n\n\t\tObject.defineProperties( this, {\n\t\t\tposition: {\n\t\t\t\tconfigurable: true,\n\t\t\t\tenumerable: true,\n\t\t\t\tvalue: position\n\t\t\t},\n\t\t\trotation: {\n\t\t\t\tconfigurable: true,\n\t\t\t\tenumerable: true,\n\t\t\t\tvalue: rotation\n\t\t\t},\n\t\t\tquaternion: {\n\t\t\t\tconfigurable: true,\n\t\t\t\tenumerable: true,\n\t\t\t\tvalue: quaternion\n\t\t\t},\n\t\t\tscale: {\n\t\t\t\tconfigurable: true,\n\t\t\t\tenumerable: true,\n\t\t\t\tvalue: scale\n\t\t\t},\n\t\t\tmodelViewMatrix: {\n\t\t\t\tvalue: new Matrix4()\n\t\t\t},\n\t\t\tnormalMatrix: {\n\t\t\t\tvalue: new Matrix3()\n\t\t\t}\n\t\t} );\n\n\t\tthis.matrix = new Matrix4();\n\t\tthis.matrixWorld = new Matrix4();\n\n\t\tthis.matrixAutoUpdate = Object3D.DEFAULT_MATRIX_AUTO_UPDATE;\n\n\t\tthis.matrixWorldAutoUpdate = Object3D.DEFAULT_MATRIX_WORLD_AUTO_UPDATE; // checked by the renderer\n\t\tthis.matrixWorldNeedsUpdate = false;\n\n\t\tthis.layers = new Layers();\n\t\tthis.visible = true;\n\n\t\tthis.castShadow = false;\n\t\tthis.receiveShadow = false;\n\n\t\tthis.frustumCulled = true;\n\t\tthis.renderOrder = 0;\n\n\t\tthis.animations = [];\n\n\t\tthis.userData = {};\n\n\t}\n\n\tonBeforeShadow( /* renderer, object, camera, shadowCamera, geometry, depthMaterial, group */ ) {}\n\n\tonAfterShadow( /* renderer, object, camera, shadowCamera, geometry, depthMaterial, group */ ) {}\n\n\tonBeforeRender( /* renderer, scene, camera, geometry, material, group */ ) {}\n\n\tonAfterRender( /* renderer, scene, camera, geometry, material, group */ ) {}\n\n\tapplyMatrix4( matrix ) {\n\n\t\tif ( this.matrixAutoUpdate ) this.updateMatrix();\n\n\t\tthis.matrix.premultiply( matrix );\n\n\t\tthis.matrix.decompose( this.position, this.quaternion, this.scale );\n\n\t}\n\n\tapplyQuaternion( q ) {\n\n\t\tthis.quaternion.premultiply( q );\n\n\t\treturn this;\n\n\t}\n\n\tsetRotationFromAxisAngle( axis, angle ) {\n\n\t\t// assumes axis is normalized\n\n\t\tthis.quaternion.setFromAxisAngle( axis, angle );\n\n\t}\n\n\tsetRotationFromEuler( euler ) {\n\n\t\tthis.quaternion.setFromEuler( euler, true );\n\n\t}\n\n\tsetRotationFromMatrix( m ) {\n\n\t\t// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)\n\n\t\tthis.quaternion.setFromRotationMatrix( m );\n\n\t}\n\n\tsetRotationFromQuaternion( q ) {\n\n\t\t// assumes q is normalized\n\n\t\tthis.quaternion.copy( q );\n\n\t}\n\n\trotateOnAxis( axis, angle ) {\n\n\t\t// rotate object on axis in object space\n\t\t// axis is assumed to be normalized\n\n\t\t_q1.setFromAxisAngle( axis, angle );\n\n\t\tthis.quaternion.multiply( _q1 );\n\n\t\treturn this;\n\n\t}\n\n\trotateOnWorldAxis( axis, angle ) {\n\n\t\t// rotate object on axis in world space\n\t\t// axis is assumed to be normalized\n\t\t// method assumes no rotated parent\n\n\t\t_q1.setFromAxisAngle( axis, angle );\n\n\t\tthis.quaternion.premultiply( _q1 );\n\n\t\treturn this;\n\n\t}\n\n\trotateX( angle ) {\n\n\t\treturn this.rotateOnAxis( _xAxis, angle );\n\n\t}\n\n\trotateY( angle ) {\n\n\t\treturn this.rotateOnAxis( _yAxis, angle );\n\n\t}\n\n\trotateZ( angle ) {\n\n\t\treturn this.rotateOnAxis( _zAxis, angle );\n\n\t}\n\n\ttranslateOnAxis( axis, distance ) {\n\n\t\t// translate object by distance along axis in object space\n\t\t// axis is assumed to be normalized\n\n\t\t_v1$4.copy( axis ).applyQuaternion( this.quaternion );\n\n\t\tthis.position.add( _v1$4.multiplyScalar( distance ) );\n\n\t\treturn this;\n\n\t}\n\n\ttranslateX( distance ) {\n\n\t\treturn this.translateOnAxis( _xAxis, distance );\n\n\t}\n\n\ttranslateY( distance ) {\n\n\t\treturn this.translateOnAxis( _yAxis, distance );\n\n\t}\n\n\ttranslateZ( distance ) {\n\n\t\treturn this.translateOnAxis( _zAxis, distance );\n\n\t}\n\n\tlocalToWorld( vector ) {\n\n\t\tthis.updateWorldMatrix( true, false );\n\n\t\treturn vector.applyMatrix4( this.matrixWorld );\n\n\t}\n\n\tworldToLocal( vector ) {\n\n\t\tthis.updateWorldMatrix( true, false );\n\n\t\treturn vector.applyMatrix4( _m1$3.copy( this.matrixWorld ).invert() );\n\n\t}\n\n\tlookAt( x, y, z ) {\n\n\t\t// This method does not support objects having non-uniformly-scaled parent(s)\n\n\t\tif ( x.isVector3 ) {\n\n\t\t\t_target.copy( x );\n\n\t\t} else {\n\n\t\t\t_target.set( x, y, z );\n\n\t\t}\n\n\t\tconst parent = this.parent;\n\n\t\tthis.updateWorldMatrix( true, false );\n\n\t\t_position$3.setFromMatrixPosition( this.matrixWorld );\n\n\t\tif ( this.isCamera || this.isLight ) {\n\n\t\t\t_m1$3.lookAt( _position$3, _target, this.up );\n\n\t\t} else {\n\n\t\t\t_m1$3.lookAt( _target, _position$3, this.up );\n\n\t\t}\n\n\t\tthis.quaternion.setFromRotationMatrix( _m1$3 );\n\n\t\tif ( parent ) {\n\n\t\t\t_m1$3.extractRotation( parent.matrixWorld );\n\t\t\t_q1.setFromRotationMatrix( _m1$3 );\n\t\t\tthis.quaternion.premultiply( _q1.invert() );\n\n\t\t}\n\n\t}\n\n\tadd( object ) {\n\n\t\tif ( arguments.length > 1 ) {\n\n\t\t\tfor ( let i = 0; i < arguments.length; i ++ ) {\n\n\t\t\t\tthis.add( arguments[ i ] );\n\n\t\t\t}\n\n\t\t\treturn this;\n\n\t\t}\n\n\t\tif ( object === this ) {\n\n\t\t\tconsole.error( 'THREE.Object3D.add: object can\\'t be added as a child of itself.', object );\n\t\t\treturn this;\n\n\t\t}\n\n\t\tif ( object && object.isObject3D ) {\n\n\t\t\tobject.removeFromParent();\n\t\t\tobject.parent = this;\n\t\t\tthis.children.push( object );\n\n\t\t\tobject.dispatchEvent( _addedEvent );\n\n\t\t\t_childaddedEvent.child = object;\n\t\t\tthis.dispatchEvent( _childaddedEvent );\n\t\t\t_childaddedEvent.child = null;\n\n\t\t} else {\n\n\t\t\tconsole.error( 'THREE.Object3D.add: object not an instance of THREE.Object3D.', object );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tremove( object ) {\n\n\t\tif ( arguments.length > 1 ) {\n\n\t\t\tfor ( let i = 0; i < arguments.length; i ++ ) {\n\n\t\t\t\tthis.remove( arguments[ i ] );\n\n\t\t\t}\n\n\t\t\treturn this;\n\n\t\t}\n\n\t\tconst index = this.children.indexOf( object );\n\n\t\tif ( index !== - 1 ) {\n\n\t\t\tobject.parent = null;\n\t\t\tthis.children.splice( index, 1 );\n\n\t\t\tobject.dispatchEvent( _removedEvent );\n\n\t\t\t_childremovedEvent.child = object;\n\t\t\tthis.dispatchEvent( _childremovedEvent );\n\t\t\t_childremovedEvent.child = null;\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tremoveFromParent() {\n\n\t\tconst parent = this.parent;\n\n\t\tif ( parent !== null ) {\n\n\t\t\tparent.remove( this );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tclear() {\n\n\t\treturn this.remove( ... this.children );\n\n\t}\n\n\tattach( object ) {\n\n\t\t// adds object as a child of this, while maintaining the object's world transform\n\n\t\t// Note: This method does not support scene graphs having non-uniformly-scaled nodes(s)\n\n\t\tthis.updateWorldMatrix( true, false );\n\n\t\t_m1$3.copy( this.matrixWorld ).invert();\n\n\t\tif ( object.parent !== null ) {\n\n\t\t\tobject.parent.updateWorldMatrix( true, false );\n\n\t\t\t_m1$3.multiply( object.parent.matrixWorld );\n\n\t\t}\n\n\t\tobject.applyMatrix4( _m1$3 );\n\n\t\tobject.removeFromParent();\n\t\tobject.parent = this;\n\t\tthis.children.push( object );\n\n\t\tobject.updateWorldMatrix( false, true );\n\n\t\tobject.dispatchEvent( _addedEvent );\n\n\t\t_childaddedEvent.child = object;\n\t\tthis.dispatchEvent( _childaddedEvent );\n\t\t_childaddedEvent.child = null;\n\n\t\treturn this;\n\n\t}\n\n\tgetObjectById( id ) {\n\n\t\treturn this.getObjectByProperty( 'id', id );\n\n\t}\n\n\tgetObjectByName( name ) {\n\n\t\treturn this.getObjectByProperty( 'name', name );\n\n\t}\n\n\tgetObjectByProperty( name, value ) {\n\n\t\tif ( this[ name ] === value ) return this;\n\n\t\tfor ( let i = 0, l = this.children.length; i < l; i ++ ) {\n\n\t\t\tconst child = this.children[ i ];\n\t\t\tconst object = child.getObjectByProperty( name, value );\n\n\t\t\tif ( object !== undefined ) {\n\n\t\t\t\treturn object;\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn undefined;\n\n\t}\n\n\tgetObjectsByProperty( name, value, result = [] ) {\n\n\t\tif ( this[ name ] === value ) result.push( this );\n\n\t\tconst children = this.children;\n\n\t\tfor ( let i = 0, l = children.length; i < l; i ++ ) {\n\n\t\t\tchildren[ i ].getObjectsByProperty( name, value, result );\n\n\t\t}\n\n\t\treturn result;\n\n\t}\n\n\tgetWorldPosition( target ) {\n\n\t\tthis.updateWorldMatrix( true, false );\n\n\t\treturn target.setFromMatrixPosition( this.matrixWorld );\n\n\t}\n\n\tgetWorldQuaternion( target ) {\n\n\t\tthis.updateWorldMatrix( true, false );\n\n\t\tthis.matrixWorld.decompose( _position$3, target, _scale$2 );\n\n\t\treturn target;\n\n\t}\n\n\tgetWorldScale( target ) {\n\n\t\tthis.updateWorldMatrix( true, false );\n\n\t\tthis.matrixWorld.decompose( _position$3, _quaternion$2, target );\n\n\t\treturn target;\n\n\t}\n\n\tgetWorldDirection( target ) {\n\n\t\tthis.updateWorldMatrix( true, false );\n\n\t\tconst e = this.matrixWorld.elements;\n\n\t\treturn target.set( e[ 8 ], e[ 9 ], e[ 10 ] ).normalize();\n\n\t}\n\n\traycast( /* raycaster, intersects */ ) {}\n\n\ttraverse( callback ) {\n\n\t\tcallback( this );\n\n\t\tconst children = this.children;\n\n\t\tfor ( let i = 0, l = children.length; i < l; i ++ ) {\n\n\t\t\tchildren[ i ].traverse( callback );\n\n\t\t}\n\n\t}\n\n\ttraverseVisible( callback ) {\n\n\t\tif ( this.visible === false ) return;\n\n\t\tcallback( this );\n\n\t\tconst children = this.children;\n\n\t\tfor ( let i = 0, l = children.length; i < l; i ++ ) {\n\n\t\t\tchildren[ i ].traverseVisible( callback );\n\n\t\t}\n\n\t}\n\n\ttraverseAncestors( callback ) {\n\n\t\tconst parent = this.parent;\n\n\t\tif ( parent !== null ) {\n\n\t\t\tcallback( parent );\n\n\t\t\tparent.traverseAncestors( callback );\n\n\t\t}\n\n\t}\n\n\tupdateMatrix() {\n\n\t\tthis.matrix.compose( this.position, this.quaternion, this.scale );\n\n\t\tthis.matrixWorldNeedsUpdate = true;\n\n\t}\n\n\tupdateMatrixWorld( force ) {\n\n\t\tif ( this.matrixAutoUpdate ) this.updateMatrix();\n\n\t\tif ( this.matrixWorldNeedsUpdate || force ) {\n\n\t\t\tif ( this.parent === null ) {\n\n\t\t\t\tthis.matrixWorld.copy( this.matrix );\n\n\t\t\t} else {\n\n\t\t\t\tthis.matrixWorld.multiplyMatrices( this.parent.matrixWorld, this.matrix );\n\n\t\t\t}\n\n\t\t\tthis.matrixWorldNeedsUpdate = false;\n\n\t\t\tforce = true;\n\n\t\t}\n\n\t\t// update children\n\n\t\tconst children = this.children;\n\n\t\tfor ( let i = 0, l = children.length; i < l; i ++ ) {\n\n\t\t\tconst child = children[ i ];\n\n\t\t\tif ( child.matrixWorldAutoUpdate === true || force === true ) {\n\n\t\t\t\tchild.updateMatrixWorld( force );\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n\tupdateWorldMatrix( updateParents, updateChildren ) {\n\n\t\tconst parent = this.parent;\n\n\t\tif ( updateParents === true && parent !== null && parent.matrixWorldAutoUpdate === true ) {\n\n\t\t\tparent.updateWorldMatrix( true, false );\n\n\t\t}\n\n\t\tif ( this.matrixAutoUpdate ) this.updateMatrix();\n\n\t\tif ( this.parent === null ) {\n\n\t\t\tthis.matrixWorld.copy( this.matrix );\n\n\t\t} else {\n\n\t\t\tthis.matrixWorld.multiplyMatrices( this.parent.matrixWorld, this.matrix );\n\n\t\t}\n\n\t\t// update children\n\n\t\tif ( updateChildren === true ) {\n\n\t\t\tconst children = this.children;\n\n\t\t\tfor ( let i = 0, l = children.length; i < l; i ++ ) {\n\n\t\t\t\tconst child = children[ i ];\n\n\t\t\t\tif ( child.matrixWorldAutoUpdate === true ) {\n\n\t\t\t\t\tchild.updateWorldMatrix( false, true );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n\ttoJSON( meta ) {\n\n\t\t// meta is a string when called from JSON.stringify\n\t\tconst isRootObject = ( meta === undefined || typeof meta === 'string' );\n\n\t\tconst output = {};\n\n\t\t// meta is a hash used to collect geometries, materials.\n\t\t// not providing it implies that this is the root object\n\t\t// being serialized.\n\t\tif ( isRootObject ) {\n\n\t\t\t// initialize meta obj\n\t\t\tmeta = {\n\t\t\t\tgeometries: {},\n\t\t\t\tmaterials: {},\n\t\t\t\ttextures: {},\n\t\t\t\timages: {},\n\t\t\t\tshapes: {},\n\t\t\t\tskeletons: {},\n\t\t\t\tanimations: {},\n\t\t\t\tnodes: {}\n\t\t\t};\n\n\t\t\toutput.metadata = {\n\t\t\t\tversion: 4.6,\n\t\t\t\ttype: 'Object',\n\t\t\t\tgenerator: 'Object3D.toJSON'\n\t\t\t};\n\n\t\t}\n\n\t\t// standard Object3D serialization\n\n\t\tconst object = {};\n\n\t\tobject.uuid = this.uuid;\n\t\tobject.type = this.type;\n\n\t\tif ( this.name !== '' ) object.name = this.name;\n\t\tif ( this.castShadow === true ) object.castShadow = true;\n\t\tif ( this.receiveShadow === true ) object.receiveShadow = true;\n\t\tif ( this.visible === false ) object.visible = false;\n\t\tif ( this.frustumCulled === false ) object.frustumCulled = false;\n\t\tif ( this.renderOrder !== 0 ) object.renderOrder = this.renderOrder;\n\t\tif ( Object.keys( this.userData ).length > 0 ) object.userData = this.userData;\n\n\t\tobject.layers = this.layers.mask;\n\t\tobject.matrix = this.matrix.toArray();\n\t\tobject.up = this.up.toArray();\n\n\t\tif ( this.matrixAutoUpdate === false ) object.matrixAutoUpdate = false;\n\n\t\t// object specific properties\n\n\t\tif ( this.isInstancedMesh ) {\n\n\t\t\tobject.type = 'InstancedMesh';\n\t\t\tobject.count = this.count;\n\t\t\tobject.instanceMatrix = this.instanceMatrix.toJSON();\n\t\t\tif ( this.instanceColor !== null ) object.instanceColor = this.instanceColor.toJSON();\n\n\t\t}\n\n\t\tif ( this.isBatchedMesh ) {\n\n\t\t\tobject.type = 'BatchedMesh';\n\t\t\tobject.perObjectFrustumCulled = this.perObjectFrustumCulled;\n\t\t\tobject.sortObjects = this.sortObjects;\n\n\t\t\tobject.drawRanges = this._drawRanges;\n\t\t\tobject.reservedRanges = this._reservedRanges;\n\n\t\t\tobject.visibility = this._visibility;\n\t\t\tobject.active = this._active;\n\t\t\tobject.bounds = this._bounds.map( bound => ( {\n\t\t\t\tboxInitialized: bound.boxInitialized,\n\t\t\t\tboxMin: bound.box.min.toArray(),\n\t\t\t\tboxMax: bound.box.max.toArray(),\n\n\t\t\t\tsphereInitialized: bound.sphereInitialized,\n\t\t\t\tsphereRadius: bound.sphere.radius,\n\t\t\t\tsphereCenter: bound.sphere.center.toArray()\n\t\t\t} ) );\n\n\t\t\tobject.maxGeometryCount = this._maxGeometryCount;\n\t\t\tobject.maxVertexCount = this._maxVertexCount;\n\t\t\tobject.maxIndexCount = this._maxIndexCount;\n\n\t\t\tobject.geometryInitialized = this._geometryInitialized;\n\t\t\tobject.geometryCount = this._geometryCount;\n\n\t\t\tobject.matricesTexture = this._matricesTexture.toJSON( meta );\n\n\t\t\tif ( this.boundingSphere !== null ) {\n\n\t\t\t\tobject.boundingSphere = {\n\t\t\t\t\tcenter: object.boundingSphere.center.toArray(),\n\t\t\t\t\tradius: object.boundingSphere.radius\n\t\t\t\t};\n\n\t\t\t}\n\n\t\t\tif ( this.boundingBox !== null ) {\n\n\t\t\t\tobject.boundingBox = {\n\t\t\t\t\tmin: object.boundingBox.min.toArray(),\n\t\t\t\t\tmax: object.boundingBox.max.toArray()\n\t\t\t\t};\n\n\t\t\t}\n\n\t\t}\n\n\t\t//\n\n\t\tfunction serialize( library, element ) {\n\n\t\t\tif ( library[ element.uuid ] === undefined ) {\n\n\t\t\t\tlibrary[ element.uuid ] = element.toJSON( meta );\n\n\t\t\t}\n\n\t\t\treturn element.uuid;\n\n\t\t}\n\n\t\tif ( this.isScene ) {\n\n\t\t\tif ( this.background ) {\n\n\t\t\t\tif ( this.background.isColor ) {\n\n\t\t\t\t\tobject.background = this.background.toJSON();\n\n\t\t\t\t} else if ( this.background.isTexture ) {\n\n\t\t\t\t\tobject.background = this.background.toJSON( meta ).uuid;\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tif ( this.environment && this.environment.isTexture && this.environment.isRenderTargetTexture !== true ) {\n\n\t\t\t\tobject.environment = this.environment.toJSON( meta ).uuid;\n\n\t\t\t}\n\n\t\t} else if ( this.isMesh || this.isLine || this.isPoints ) {\n\n\t\t\tobject.geometry = serialize( meta.geometries, this.geometry );\n\n\t\t\tconst parameters = this.geometry.parameters;\n\n\t\t\tif ( parameters !== undefined && parameters.shapes !== undefined ) {\n\n\t\t\t\tconst shapes = parameters.shapes;\n\n\t\t\t\tif ( Array.isArray( shapes ) ) {\n\n\t\t\t\t\tfor ( let i = 0, l = shapes.length; i < l; i ++ ) {\n\n\t\t\t\t\t\tconst shape = shapes[ i ];\n\n\t\t\t\t\t\tserialize( meta.shapes, shape );\n\n\t\t\t\t\t}\n\n\t\t\t\t} else {\n\n\t\t\t\t\tserialize( meta.shapes, shapes );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t\tif ( this.isSkinnedMesh ) {\n\n\t\t\tobject.bindMode = this.bindMode;\n\t\t\tobject.bindMatrix = this.bindMatrix.toArray();\n\n\t\t\tif ( this.skeleton !== undefined ) {\n\n\t\t\t\tserialize( meta.skeletons, this.skeleton );\n\n\t\t\t\tobject.skeleton = this.skeleton.uuid;\n\n\t\t\t}\n\n\t\t}\n\n\t\tif ( this.material !== undefined ) {\n\n\t\t\tif ( Array.isArray( this.material ) ) {\n\n\t\t\t\tconst uuids = [];\n\n\t\t\t\tfor ( let i = 0, l = this.material.length; i < l; i ++ ) {\n\n\t\t\t\t\tuuids.push( serialize( meta.materials, this.material[ i ] ) );\n\n\t\t\t\t}\n\n\t\t\t\tobject.material = uuids;\n\n\t\t\t} else {\n\n\t\t\t\tobject.material = serialize( meta.materials, this.material );\n\n\t\t\t}\n\n\t\t}\n\n\t\t//\n\n\t\tif ( this.children.length > 0 ) {\n\n\t\t\tobject.children = [];\n\n\t\t\tfor ( let i = 0; i < this.children.length; i ++ ) {\n\n\t\t\t\tobject.children.push( this.children[ i ].toJSON( meta ).object );\n\n\t\t\t}\n\n\t\t}\n\n\t\t//\n\n\t\tif ( this.animations.length > 0 ) {\n\n\t\t\tobject.animations = [];\n\n\t\t\tfor ( let i = 0; i < this.animations.length; i ++ ) {\n\n\t\t\t\tconst animation = this.animations[ i ];\n\n\t\t\t\tobject.animations.push( serialize( meta.animations, animation ) );\n\n\t\t\t}\n\n\t\t}\n\n\t\tif ( isRootObject ) {\n\n\t\t\tconst geometries = extractFromCache( meta.geometries );\n\t\t\tconst materials = extractFromCache( meta.materials );\n\t\t\tconst textures = extractFromCache( meta.textures );\n\t\t\tconst images = extractFromCache( meta.images );\n\t\t\tconst shapes = extractFromCache( meta.shapes );\n\t\t\tconst skeletons = extractFromCache( meta.skeletons );\n\t\t\tconst animations = extractFromCache( meta.animations );\n\t\t\tconst nodes = extractFromCache( meta.nodes );\n\n\t\t\tif ( geometries.length > 0 ) output.geometries = geometries;\n\t\t\tif ( materials.length > 0 ) output.materials = materials;\n\t\t\tif ( textures.length > 0 ) output.textures = textures;\n\t\t\tif ( images.length > 0 ) output.images = images;\n\t\t\tif ( shapes.length > 0 ) output.shapes = shapes;\n\t\t\tif ( skeletons.length > 0 ) output.skeletons = skeletons;\n\t\t\tif ( animations.length > 0 ) output.animations = animations;\n\t\t\tif ( nodes.length > 0 ) output.nodes = nodes;\n\n\t\t}\n\n\t\toutput.object = object;\n\n\t\treturn output;\n\n\t\t// extract data from the cache hash\n\t\t// remove metadata on each item\n\t\t// and return as array\n\t\tfunction extractFromCache( cache ) {\n\n\t\t\tconst values = [];\n\t\t\tfor ( const key in cache ) {\n\n\t\t\t\tconst data = cache[ key ];\n\t\t\t\tdelete data.metadata;\n\t\t\t\tvalues.push( data );\n\n\t\t\t}\n\n\t\t\treturn values;\n\n\t\t}\n\n\t}\n\n\tclone( recursive ) {\n\n\t\treturn new this.constructor().copy( this, recursive );\n\n\t}\n\n\tcopy( source, recursive = true ) {\n\n\t\tthis.name = source.name;\n\n\t\tthis.up.copy( source.up );\n\n\t\tthis.position.copy( source.position );\n\t\tthis.rotation.order = source.rotation.order;\n\t\tthis.quaternion.copy( source.quaternion );\n\t\tthis.scale.copy( source.scale );\n\n\t\tthis.matrix.copy( source.matrix );\n\t\tthis.matrixWorld.copy( source.matrixWorld );\n\n\t\tthis.matrixAutoUpdate = source.matrixAutoUpdate;\n\n\t\tthis.matrixWorldAutoUpdate = source.matrixWorldAutoUpdate;\n\t\tthis.matrixWorldNeedsUpdate = source.matrixWorldNeedsUpdate;\n\n\t\tthis.layers.mask = source.layers.mask;\n\t\tthis.visible = source.visible;\n\n\t\tthis.castShadow = source.castShadow;\n\t\tthis.receiveShadow = source.receiveShadow;\n\n\t\tthis.frustumCulled = source.frustumCulled;\n\t\tthis.renderOrder = source.renderOrder;\n\n\t\tthis.animations = source.animations.slice();\n\n\t\tthis.userData = JSON.parse( JSON.stringify( source.userData ) );\n\n\t\tif ( recursive === true ) {\n\n\t\t\tfor ( let i = 0; i < source.children.length; i ++ ) {\n\n\t\t\t\tconst child = source.children[ i ];\n\t\t\t\tthis.add( child.clone() );\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n}\n\nObject3D.DEFAULT_UP = /*@__PURE__*/ new Vector3( 0, 1, 0 );\nObject3D.DEFAULT_MATRIX_AUTO_UPDATE = true;\nObject3D.DEFAULT_MATRIX_WORLD_AUTO_UPDATE = true;\n\nconst _v0$1 = /*@__PURE__*/ new Vector3();\nconst _v1$3 = /*@__PURE__*/ new Vector3();\nconst _v2$2 = /*@__PURE__*/ new Vector3();\nconst _v3$2 = /*@__PURE__*/ new Vector3();\n\nconst _vab = /*@__PURE__*/ new Vector3();\nconst _vac = /*@__PURE__*/ new Vector3();\nconst _vbc = /*@__PURE__*/ new Vector3();\nconst _vap = /*@__PURE__*/ new Vector3();\nconst _vbp = /*@__PURE__*/ new Vector3();\nconst _vcp = /*@__PURE__*/ new Vector3();\n\nclass Triangle {\n\n\tconstructor( a = new Vector3(), b = new Vector3(), c = new Vector3() ) {\n\n\t\tthis.a = a;\n\t\tthis.b = b;\n\t\tthis.c = c;\n\n\t}\n\n\tstatic getNormal( a, b, c, target ) {\n\n\t\ttarget.subVectors( c, b );\n\t\t_v0$1.subVectors( a, b );\n\t\ttarget.cross( _v0$1 );\n\n\t\tconst targetLengthSq = target.lengthSq();\n\t\tif ( targetLengthSq > 0 ) {\n\n\t\t\treturn target.multiplyScalar( 1 / Math.sqrt( targetLengthSq ) );\n\n\t\t}\n\n\t\treturn target.set( 0, 0, 0 );\n\n\t}\n\n\t// static/instance method to calculate barycentric coordinates\n\t// based on: http://www.blackpawn.com/texts/pointinpoly/default.html\n\tstatic getBarycoord( point, a, b, c, target ) {\n\n\t\t_v0$1.subVectors( c, a );\n\t\t_v1$3.subVectors( b, a );\n\t\t_v2$2.subVectors( point, a );\n\n\t\tconst dot00 = _v0$1.dot( _v0$1 );\n\t\tconst dot01 = _v0$1.dot( _v1$3 );\n\t\tconst dot02 = _v0$1.dot( _v2$2 );\n\t\tconst dot11 = _v1$3.dot( _v1$3 );\n\t\tconst dot12 = _v1$3.dot( _v2$2 );\n\n\t\tconst denom = ( dot00 * dot11 - dot01 * dot01 );\n\n\t\t// collinear or singular triangle\n\t\tif ( denom === 0 ) {\n\n\t\t\ttarget.set( 0, 0, 0 );\n\t\t\treturn null;\n\n\t\t}\n\n\t\tconst invDenom = 1 / denom;\n\t\tconst u = ( dot11 * dot02 - dot01 * dot12 ) * invDenom;\n\t\tconst v = ( dot00 * dot12 - dot01 * dot02 ) * invDenom;\n\n\t\t// barycentric coordinates must always sum to 1\n\t\treturn target.set( 1 - u - v, v, u );\n\n\t}\n\n\tstatic containsPoint( point, a, b, c ) {\n\n\t\t// if the triangle is degenerate then we can't contain a point\n\t\tif ( this.getBarycoord( point, a, b, c, _v3$2 ) === null ) {\n\n\t\t\treturn false;\n\n\t\t}\n\n\t\treturn ( _v3$2.x >= 0 ) && ( _v3$2.y >= 0 ) && ( ( _v3$2.x + _v3$2.y ) <= 1 );\n\n\t}\n\n\tstatic getInterpolation( point, p1, p2, p3, v1, v2, v3, target ) {\n\n\t\tif ( this.getBarycoord( point, p1, p2, p3, _v3$2 ) === null ) {\n\n\t\t\ttarget.x = 0;\n\t\t\ttarget.y = 0;\n\t\t\tif ( 'z' in target ) target.z = 0;\n\t\t\tif ( 'w' in target ) target.w = 0;\n\t\t\treturn null;\n\n\t\t}\n\n\t\ttarget.setScalar( 0 );\n\t\ttarget.addScaledVector( v1, _v3$2.x );\n\t\ttarget.addScaledVector( v2, _v3$2.y );\n\t\ttarget.addScaledVector( v3, _v3$2.z );\n\n\t\treturn target;\n\n\t}\n\n\tstatic isFrontFacing( a, b, c, direction ) {\n\n\t\t_v0$1.subVectors( c, b );\n\t\t_v1$3.subVectors( a, b );\n\n\t\t// strictly front facing\n\t\treturn ( _v0$1.cross( _v1$3 ).dot( direction ) < 0 ) ? true : false;\n\n\t}\n\n\tset( a, b, c ) {\n\n\t\tthis.a.copy( a );\n\t\tthis.b.copy( b );\n\t\tthis.c.copy( c );\n\n\t\treturn this;\n\n\t}\n\n\tsetFromPointsAndIndices( points, i0, i1, i2 ) {\n\n\t\tthis.a.copy( points[ i0 ] );\n\t\tthis.b.copy( points[ i1 ] );\n\t\tthis.c.copy( points[ i2 ] );\n\n\t\treturn this;\n\n\t}\n\n\tsetFromAttributeAndIndices( attribute, i0, i1, i2 ) {\n\n\t\tthis.a.fromBufferAttribute( attribute, i0 );\n\t\tthis.b.fromBufferAttribute( attribute, i1 );\n\t\tthis.c.fromBufferAttribute( attribute, i2 );\n\n\t\treturn this;\n\n\t}\n\n\tclone() {\n\n\t\treturn new this.constructor().copy( this );\n\n\t}\n\n\tcopy( triangle ) {\n\n\t\tthis.a.copy( triangle.a );\n\t\tthis.b.copy( triangle.b );\n\t\tthis.c.copy( triangle.c );\n\n\t\treturn this;\n\n\t}\n\n\tgetArea() {\n\n\t\t_v0$1.subVectors( this.c, this.b );\n\t\t_v1$3.subVectors( this.a, this.b );\n\n\t\treturn _v0$1.cross( _v1$3 ).length() * 0.5;\n\n\t}\n\n\tgetMidpoint( target ) {\n\n\t\treturn target.addVectors( this.a, this.b ).add( this.c ).multiplyScalar( 1 / 3 );\n\n\t}\n\n\tgetNormal( target ) {\n\n\t\treturn Triangle.getNormal( this.a, this.b, this.c, target );\n\n\t}\n\n\tgetPlane( target ) {\n\n\t\treturn target.setFromCoplanarPoints( this.a, this.b, this.c );\n\n\t}\n\n\tgetBarycoord( point, target ) {\n\n\t\treturn Triangle.getBarycoord( point, this.a, this.b, this.c, target );\n\n\t}\n\n\tgetInterpolation( point, v1, v2, v3, target ) {\n\n\t\treturn Triangle.getInterpolation( point, this.a, this.b, this.c, v1, v2, v3, target );\n\n\t}\n\n\tcontainsPoint( point ) {\n\n\t\treturn Triangle.containsPoint( point, this.a, this.b, this.c );\n\n\t}\n\n\tisFrontFacing( direction ) {\n\n\t\treturn Triangle.isFrontFacing( this.a, this.b, this.c, direction );\n\n\t}\n\n\tintersectsBox( box ) {\n\n\t\treturn box.intersectsTriangle( this );\n\n\t}\n\n\tclosestPointToPoint( p, target ) {\n\n\t\tconst a = this.a, b = this.b, c = this.c;\n\t\tlet v, w;\n\n\t\t// algorithm thanks to Real-Time Collision Detection by Christer Ericson,\n\t\t// published by Morgan Kaufmann Publishers, (c) 2005 Elsevier Inc.,\n\t\t// under the accompanying license; see chapter 5.1.5 for detailed explanation.\n\t\t// basically, we're distinguishing which of the voronoi regions of the triangle\n\t\t// the point lies in with the minimum amount of redundant computation.\n\n\t\t_vab.subVectors( b, a );\n\t\t_vac.subVectors( c, a );\n\t\t_vap.subVectors( p, a );\n\t\tconst d1 = _vab.dot( _vap );\n\t\tconst d2 = _vac.dot( _vap );\n\t\tif ( d1 <= 0 && d2 <= 0 ) {\n\n\t\t\t// vertex region of A; barycentric coords (1, 0, 0)\n\t\t\treturn target.copy( a );\n\n\t\t}\n\n\t\t_vbp.subVectors( p, b );\n\t\tconst d3 = _vab.dot( _vbp );\n\t\tconst d4 = _vac.dot( _vbp );\n\t\tif ( d3 >= 0 && d4 <= d3 ) {\n\n\t\t\t// vertex region of B; barycentric coords (0, 1, 0)\n\t\t\treturn target.copy( b );\n\n\t\t}\n\n\t\tconst vc = d1 * d4 - d3 * d2;\n\t\tif ( vc <= 0 && d1 >= 0 && d3 <= 0 ) {\n\n\t\t\tv = d1 / ( d1 - d3 );\n\t\t\t// edge region of AB; barycentric coords (1-v, v, 0)\n\t\t\treturn target.copy( a ).addScaledVector( _vab, v );\n\n\t\t}\n\n\t\t_vcp.subVectors( p, c );\n\t\tconst d5 = _vab.dot( _vcp );\n\t\tconst d6 = _vac.dot( _vcp );\n\t\tif ( d6 >= 0 && d5 <= d6 ) {\n\n\t\t\t// vertex region of C; barycentric coords (0, 0, 1)\n\t\t\treturn target.copy( c );\n\n\t\t}\n\n\t\tconst vb = d5 * d2 - d1 * d6;\n\t\tif ( vb <= 0 && d2 >= 0 && d6 <= 0 ) {\n\n\t\t\tw = d2 / ( d2 - d6 );\n\t\t\t// edge region of AC; barycentric coords (1-w, 0, w)\n\t\t\treturn target.copy( a ).addScaledVector( _vac, w );\n\n\t\t}\n\n\t\tconst va = d3 * d6 - d5 * d4;\n\t\tif ( va <= 0 && ( d4 - d3 ) >= 0 && ( d5 - d6 ) >= 0 ) {\n\n\t\t\t_vbc.subVectors( c, b );\n\t\t\tw = ( d4 - d3 ) / ( ( d4 - d3 ) + ( d5 - d6 ) );\n\t\t\t// edge region of BC; barycentric coords (0, 1-w, w)\n\t\t\treturn target.copy( b ).addScaledVector( _vbc, w ); // edge region of BC\n\n\t\t}\n\n\t\t// face region\n\t\tconst denom = 1 / ( va + vb + vc );\n\t\t// u = va * denom\n\t\tv = vb * denom;\n\t\tw = vc * denom;\n\n\t\treturn target.copy( a ).addScaledVector( _vab, v ).addScaledVector( _vac, w );\n\n\t}\n\n\tequals( triangle ) {\n\n\t\treturn triangle.a.equals( this.a ) && triangle.b.equals( this.b ) && triangle.c.equals( this.c );\n\n\t}\n\n}\n\nconst _colorKeywords = { 'aliceblue': 0xF0F8FF, 'antiquewhite': 0xFAEBD7, 'aqua': 0x00FFFF, 'aquamarine': 0x7FFFD4, 'azure': 0xF0FFFF,\n\t'beige': 0xF5F5DC, 'bisque': 0xFFE4C4, 'black': 0x000000, 'blanchedalmond': 0xFFEBCD, 'blue': 0x0000FF, 'blueviolet': 0x8A2BE2,\n\t'brown': 0xA52A2A, 'burlywood': 0xDEB887, 'cadetblue': 0x5F9EA0, 'chartreuse': 0x7FFF00, 'chocolate': 0xD2691E, 'coral': 0xFF7F50,\n\t'cornflowerblue': 0x6495ED, 'cornsilk': 0xFFF8DC, 'crimson': 0xDC143C, 'cyan': 0x00FFFF, 'darkblue': 0x00008B, 'darkcyan': 0x008B8B,\n\t'darkgoldenrod': 0xB8860B, 'darkgray': 0xA9A9A9, 'darkgreen': 0x006400, 'darkgrey': 0xA9A9A9, 'darkkhaki': 0xBDB76B, 'darkmagenta': 0x8B008B,\n\t'darkolivegreen': 0x556B2F, 'darkorange': 0xFF8C00, 'darkorchid': 0x9932CC, 'darkred': 0x8B0000, 'darksalmon': 0xE9967A, 'darkseagreen': 0x8FBC8F,\n\t'darkslateblue': 0x483D8B, 'darkslategray': 0x2F4F4F, 'darkslategrey': 0x2F4F4F, 'darkturquoise': 0x00CED1, 'darkviolet': 0x9400D3,\n\t'deeppink': 0xFF1493, 'deepskyblue': 0x00BFFF, 'dimgray': 0x696969, 'dimgrey': 0x696969, 'dodgerblue': 0x1E90FF, 'firebrick': 0xB22222,\n\t'floralwhite': 0xFFFAF0, 'forestgreen': 0x228B22, 'fuchsia': 0xFF00FF, 'gainsboro': 0xDCDCDC, 'ghostwhite': 0xF8F8FF, 'gold': 0xFFD700,\n\t'goldenrod': 0xDAA520, 'gray': 0x808080, 'green': 0x008000, 'greenyellow': 0xADFF2F, 'grey': 0x808080, 'honeydew': 0xF0FFF0, 'hotpink': 0xFF69B4,\n\t'indianred': 0xCD5C5C, 'indigo': 0x4B0082, 'ivory': 0xFFFFF0, 'khaki': 0xF0E68C, 'lavender': 0xE6E6FA, 'lavenderblush': 0xFFF0F5, 'lawngreen': 0x7CFC00,\n\t'lemonchiffon': 0xFFFACD, 'lightblue': 0xADD8E6, 'lightcoral': 0xF08080, 'lightcyan': 0xE0FFFF, 'lightgoldenrodyellow': 0xFAFAD2, 'lightgray': 0xD3D3D3,\n\t'lightgreen': 0x90EE90, 'lightgrey': 0xD3D3D3, 'lightpink': 0xFFB6C1, 'lightsalmon': 0xFFA07A, 'lightseagreen': 0x20B2AA, 'lightskyblue': 0x87CEFA,\n\t'lightslategray': 0x778899, 'lightslategrey': 0x778899, 'lightsteelblue': 0xB0C4DE, 'lightyellow': 0xFFFFE0, 'lime': 0x00FF00, 'limegreen': 0x32CD32,\n\t'linen': 0xFAF0E6, 'magenta': 0xFF00FF, 'maroon': 0x800000, 'mediumaquamarine': 0x66CDAA, 'mediumblue': 0x0000CD, 'mediumorchid': 0xBA55D3,\n\t'mediumpurple': 0x9370DB, 'mediumseagreen': 0x3CB371, 'mediumslateblue': 0x7B68EE, 'mediumspringgreen': 0x00FA9A, 'mediumturquoise': 0x48D1CC,\n\t'mediumvioletred': 0xC71585, 'midnightblue': 0x191970, 'mintcream': 0xF5FFFA, 'mistyrose': 0xFFE4E1, 'moccasin': 0xFFE4B5, 'navajowhite': 0xFFDEAD,\n\t'navy': 0x000080, 'oldlace': 0xFDF5E6, 'olive': 0x808000, 'olivedrab': 0x6B8E23, 'orange': 0xFFA500, 'orangered': 0xFF4500, 'orchid': 0xDA70D6,\n\t'palegoldenrod': 0xEEE8AA, 'palegreen': 0x98FB98, 'paleturquoise': 0xAFEEEE, 'palevioletred': 0xDB7093, 'papayawhip': 0xFFEFD5, 'peachpuff': 0xFFDAB9,\n\t'peru': 0xCD853F, 'pink': 0xFFC0CB, 'plum': 0xDDA0DD, 'powderblue': 0xB0E0E6, 'purple': 0x800080, 'rebeccapurple': 0x663399, 'red': 0xFF0000, 'rosybrown': 0xBC8F8F,\n\t'royalblue': 0x4169E1, 'saddlebrown': 0x8B4513, 'salmon': 0xFA8072, 'sandybrown': 0xF4A460, 'seagreen': 0x2E8B57, 'seashell': 0xFFF5EE,\n\t'sienna': 0xA0522D, 'silver': 0xC0C0C0, 'skyblue': 0x87CEEB, 'slateblue': 0x6A5ACD, 'slategray': 0x708090, 'slategrey': 0x708090, 'snow': 0xFFFAFA,\n\t'springgreen': 0x00FF7F, 'steelblue': 0x4682B4, 'tan': 0xD2B48C, 'teal': 0x008080, 'thistle': 0xD8BFD8, 'tomato': 0xFF6347, 'turquoise': 0x40E0D0,\n\t'violet': 0xEE82EE, 'wheat': 0xF5DEB3, 'white': 0xFFFFFF, 'whitesmoke': 0xF5F5F5, 'yellow': 0xFFFF00, 'yellowgreen': 0x9ACD32 };\n\nconst _hslA = { h: 0, s: 0, l: 0 };\nconst _hslB = { h: 0, s: 0, l: 0 };\n\nfunction hue2rgb( p, q, t ) {\n\n\tif ( t < 0 ) t += 1;\n\tif ( t > 1 ) t -= 1;\n\tif ( t < 1 / 6 ) return p + ( q - p ) * 6 * t;\n\tif ( t < 1 / 2 ) return q;\n\tif ( t < 2 / 3 ) return p + ( q - p ) * 6 * ( 2 / 3 - t );\n\treturn p;\n\n}\n\nclass Color {\n\n\tconstructor( r, g, b ) {\n\n\t\tthis.isColor = true;\n\n\t\tthis.r = 1;\n\t\tthis.g = 1;\n\t\tthis.b = 1;\n\n\t\treturn this.set( r, g, b );\n\n\t}\n\n\tset( r, g, b ) {\n\n\t\tif ( g === undefined && b === undefined ) {\n\n\t\t\t// r is THREE.Color, hex or string\n\n\t\t\tconst value = r;\n\n\t\t\tif ( value && value.isColor ) {\n\n\t\t\t\tthis.copy( value );\n\n\t\t\t} else if ( typeof value === 'number' ) {\n\n\t\t\t\tthis.setHex( value );\n\n\t\t\t} else if ( typeof value === 'string' ) {\n\n\t\t\t\tthis.setStyle( value );\n\n\t\t\t}\n\n\t\t} else {\n\n\t\t\tthis.setRGB( r, g, b );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tsetScalar( scalar ) {\n\n\t\tthis.r = scalar;\n\t\tthis.g = scalar;\n\t\tthis.b = scalar;\n\n\t\treturn this;\n\n\t}\n\n\tsetHex( hex, colorSpace = SRGBColorSpace ) {\n\n\t\thex = Math.floor( hex );\n\n\t\tthis.r = ( hex >> 16 & 255 ) / 255;\n\t\tthis.g = ( hex >> 8 & 255 ) / 255;\n\t\tthis.b = ( hex & 255 ) / 255;\n\n\t\tColorManagement.toWorkingColorSpace( this, colorSpace );\n\n\t\treturn this;\n\n\t}\n\n\tsetRGB( r, g, b, colorSpace = ColorManagement.workingColorSpace ) {\n\n\t\tthis.r = r;\n\t\tthis.g = g;\n\t\tthis.b = b;\n\n\t\tColorManagement.toWorkingColorSpace( this, colorSpace );\n\n\t\treturn this;\n\n\t}\n\n\tsetHSL( h, s, l, colorSpace = ColorManagement.workingColorSpace ) {\n\n\t\t// h,s,l ranges are in 0.0 - 1.0\n\t\th = euclideanModulo( h, 1 );\n\t\ts = clamp( s, 0, 1 );\n\t\tl = clamp( l, 0, 1 );\n\n\t\tif ( s === 0 ) {\n\n\t\t\tthis.r = this.g = this.b = l;\n\n\t\t} else {\n\n\t\t\tconst p = l <= 0.5 ? l * ( 1 + s ) : l + s - ( l * s );\n\t\t\tconst q = ( 2 * l ) - p;\n\n\t\t\tthis.r = hue2rgb( q, p, h + 1 / 3 );\n\t\t\tthis.g = hue2rgb( q, p, h );\n\t\t\tthis.b = hue2rgb( q, p, h - 1 / 3 );\n\n\t\t}\n\n\t\tColorManagement.toWorkingColorSpace( this, colorSpace );\n\n\t\treturn this;\n\n\t}\n\n\tsetStyle( style, colorSpace = SRGBColorSpace ) {\n\n\t\tfunction handleAlpha( string ) {\n\n\t\t\tif ( string === undefined ) return;\n\n\t\t\tif ( parseFloat( string ) < 1 ) {\n\n\t\t\t\tconsole.warn( 'THREE.Color: Alpha component of ' + style + ' will be ignored.' );\n\n\t\t\t}\n\n\t\t}\n\n\n\t\tlet m;\n\n\t\tif ( m = /^(\\w+)\\(([^\\)]*)\\)/.exec( style ) ) {\n\n\t\t\t// rgb / hsl\n\n\t\t\tlet color;\n\t\t\tconst name = m[ 1 ];\n\t\t\tconst components = m[ 2 ];\n\n\t\t\tswitch ( name ) {\n\n\t\t\t\tcase 'rgb':\n\t\t\t\tcase 'rgba':\n\n\t\t\t\t\tif ( color = /^\\s*(\\d+)\\s*,\\s*(\\d+)\\s*,\\s*(\\d+)\\s*(?:,\\s*(\\d*\\.?\\d+)\\s*)?$/.exec( components ) ) {\n\n\t\t\t\t\t\t// rgb(255,0,0) rgba(255,0,0,0.5)\n\n\t\t\t\t\t\thandleAlpha( color[ 4 ] );\n\n\t\t\t\t\t\treturn this.setRGB(\n\t\t\t\t\t\t\tMath.min( 255, parseInt( color[ 1 ], 10 ) ) / 255,\n\t\t\t\t\t\t\tMath.min( 255, parseInt( color[ 2 ], 10 ) ) / 255,\n\t\t\t\t\t\t\tMath.min( 255, parseInt( color[ 3 ], 10 ) ) / 255,\n\t\t\t\t\t\t\tcolorSpace\n\t\t\t\t\t\t);\n\n\t\t\t\t\t}\n\n\t\t\t\t\tif ( color = /^\\s*(\\d+)\\%\\s*,\\s*(\\d+)\\%\\s*,\\s*(\\d+)\\%\\s*(?:,\\s*(\\d*\\.?\\d+)\\s*)?$/.exec( components ) ) {\n\n\t\t\t\t\t\t// rgb(100%,0%,0%) rgba(100%,0%,0%,0.5)\n\n\t\t\t\t\t\thandleAlpha( color[ 4 ] );\n\n\t\t\t\t\t\treturn this.setRGB(\n\t\t\t\t\t\t\tMath.min( 100, parseInt( color[ 1 ], 10 ) ) / 100,\n\t\t\t\t\t\t\tMath.min( 100, parseInt( color[ 2 ], 10 ) ) / 100,\n\t\t\t\t\t\t\tMath.min( 100, parseInt( color[ 3 ], 10 ) ) / 100,\n\t\t\t\t\t\t\tcolorSpace\n\t\t\t\t\t\t);\n\n\t\t\t\t\t}\n\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase 'hsl':\n\t\t\t\tcase 'hsla':\n\n\t\t\t\t\tif ( color = /^\\s*(\\d*\\.?\\d+)\\s*,\\s*(\\d*\\.?\\d+)\\%\\s*,\\s*(\\d*\\.?\\d+)\\%\\s*(?:,\\s*(\\d*\\.?\\d+)\\s*)?$/.exec( components ) ) {\n\n\t\t\t\t\t\t// hsl(120,50%,50%) hsla(120,50%,50%,0.5)\n\n\t\t\t\t\t\thandleAlpha( color[ 4 ] );\n\n\t\t\t\t\t\treturn this.setHSL(\n\t\t\t\t\t\t\tparseFloat( color[ 1 ] ) / 360,\n\t\t\t\t\t\t\tparseFloat( color[ 2 ] ) / 100,\n\t\t\t\t\t\t\tparseFloat( color[ 3 ] ) / 100,\n\t\t\t\t\t\t\tcolorSpace\n\t\t\t\t\t\t);\n\n\t\t\t\t\t}\n\n\t\t\t\t\tbreak;\n\n\t\t\t\tdefault:\n\n\t\t\t\t\tconsole.warn( 'THREE.Color: Unknown color model ' + style );\n\n\t\t\t}\n\n\t\t} else if ( m = /^\\#([A-Fa-f\\d]+)$/.exec( style ) ) {\n\n\t\t\t// hex color\n\n\t\t\tconst hex = m[ 1 ];\n\t\t\tconst size = hex.length;\n\n\t\t\tif ( size === 3 ) {\n\n\t\t\t\t// #ff0\n\t\t\t\treturn this.setRGB(\n\t\t\t\t\tparseInt( hex.charAt( 0 ), 16 ) / 15,\n\t\t\t\t\tparseInt( hex.charAt( 1 ), 16 ) / 15,\n\t\t\t\t\tparseInt( hex.charAt( 2 ), 16 ) / 15,\n\t\t\t\t\tcolorSpace\n\t\t\t\t);\n\n\t\t\t} else if ( size === 6 ) {\n\n\t\t\t\t// #ff0000\n\t\t\t\treturn this.setHex( parseInt( hex, 16 ), colorSpace );\n\n\t\t\t} else {\n\n\t\t\t\tconsole.warn( 'THREE.Color: Invalid hex color ' + style );\n\n\t\t\t}\n\n\t\t} else if ( style && style.length > 0 ) {\n\n\t\t\treturn this.setColorName( style, colorSpace );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tsetColorName( style, colorSpace = SRGBColorSpace ) {\n\n\t\t// color keywords\n\t\tconst hex = _colorKeywords[ style.toLowerCase() ];\n\n\t\tif ( hex !== undefined ) {\n\n\t\t\t// red\n\t\t\tthis.setHex( hex, colorSpace );\n\n\t\t} else {\n\n\t\t\t// unknown color\n\t\t\tconsole.warn( 'THREE.Color: Unknown color ' + style );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tclone() {\n\n\t\treturn new this.constructor( this.r, this.g, this.b );\n\n\t}\n\n\tcopy( color ) {\n\n\t\tthis.r = color.r;\n\t\tthis.g = color.g;\n\t\tthis.b = color.b;\n\n\t\treturn this;\n\n\t}\n\n\tcopySRGBToLinear( color ) {\n\n\t\tthis.r = SRGBToLinear( color.r );\n\t\tthis.g = SRGBToLinear( color.g );\n\t\tthis.b = SRGBToLinear( color.b );\n\n\t\treturn this;\n\n\t}\n\n\tcopyLinearToSRGB( color ) {\n\n\t\tthis.r = LinearToSRGB( color.r );\n\t\tthis.g = LinearToSRGB( color.g );\n\t\tthis.b = LinearToSRGB( color.b );\n\n\t\treturn this;\n\n\t}\n\n\tconvertSRGBToLinear() {\n\n\t\tthis.copySRGBToLinear( this );\n\n\t\treturn this;\n\n\t}\n\n\tconvertLinearToSRGB() {\n\n\t\tthis.copyLinearToSRGB( this );\n\n\t\treturn this;\n\n\t}\n\n\tgetHex( colorSpace = SRGBColorSpace ) {\n\n\t\tColorManagement.fromWorkingColorSpace( _color.copy( this ), colorSpace );\n\n\t\treturn Math.round( clamp( _color.r * 255, 0, 255 ) ) * 65536 + Math.round( clamp( _color.g * 255, 0, 255 ) ) * 256 + Math.round( clamp( _color.b * 255, 0, 255 ) );\n\n\t}\n\n\tgetHexString( colorSpace = SRGBColorSpace ) {\n\n\t\treturn ( '000000' + this.getHex( colorSpace ).toString( 16 ) ).slice( - 6 );\n\n\t}\n\n\tgetHSL( target, colorSpace = ColorManagement.workingColorSpace ) {\n\n\t\t// h,s,l ranges are in 0.0 - 1.0\n\n\t\tColorManagement.fromWorkingColorSpace( _color.copy( this ), colorSpace );\n\n\t\tconst r = _color.r, g = _color.g, b = _color.b;\n\n\t\tconst max = Math.max( r, g, b );\n\t\tconst min = Math.min( r, g, b );\n\n\t\tlet hue, saturation;\n\t\tconst lightness = ( min + max ) / 2.0;\n\n\t\tif ( min === max ) {\n\n\t\t\thue = 0;\n\t\t\tsaturation = 0;\n\n\t\t} else {\n\n\t\t\tconst delta = max - min;\n\n\t\t\tsaturation = lightness <= 0.5 ? delta / ( max + min ) : delta / ( 2 - max - min );\n\n\t\t\tswitch ( max ) {\n\n\t\t\t\tcase r: hue = ( g - b ) / delta + ( g < b ? 6 : 0 ); break;\n\t\t\t\tcase g: hue = ( b - r ) / delta + 2; break;\n\t\t\t\tcase b: hue = ( r - g ) / delta + 4; break;\n\n\t\t\t}\n\n\t\t\thue /= 6;\n\n\t\t}\n\n\t\ttarget.h = hue;\n\t\ttarget.s = saturation;\n\t\ttarget.l = lightness;\n\n\t\treturn target;\n\n\t}\n\n\tgetRGB( target, colorSpace = ColorManagement.workingColorSpace ) {\n\n\t\tColorManagement.fromWorkingColorSpace( _color.copy( this ), colorSpace );\n\n\t\ttarget.r = _color.r;\n\t\ttarget.g = _color.g;\n\t\ttarget.b = _color.b;\n\n\t\treturn target;\n\n\t}\n\n\tgetStyle( colorSpace = SRGBColorSpace ) {\n\n\t\tColorManagement.fromWorkingColorSpace( _color.copy( this ), colorSpace );\n\n\t\tconst r = _color.r, g = _color.g, b = _color.b;\n\n\t\tif ( colorSpace !== SRGBColorSpace ) {\n\n\t\t\t// Requires CSS Color Module Level 4 (https://www.w3.org/TR/css-color-4/).\n\t\t\treturn `color(${ colorSpace } ${ r.toFixed( 3 ) } ${ g.toFixed( 3 ) } ${ b.toFixed( 3 ) })`;\n\n\t\t}\n\n\t\treturn `rgb(${ Math.round( r * 255 ) },${ Math.round( g * 255 ) },${ Math.round( b * 255 ) })`;\n\n\t}\n\n\toffsetHSL( h, s, l ) {\n\n\t\tthis.getHSL( _hslA );\n\n\t\treturn this.setHSL( _hslA.h + h, _hslA.s + s, _hslA.l + l );\n\n\t}\n\n\tadd( color ) {\n\n\t\tthis.r += color.r;\n\t\tthis.g += color.g;\n\t\tthis.b += color.b;\n\n\t\treturn this;\n\n\t}\n\n\taddColors( color1, color2 ) {\n\n\t\tthis.r = color1.r + color2.r;\n\t\tthis.g = color1.g + color2.g;\n\t\tthis.b = color1.b + color2.b;\n\n\t\treturn this;\n\n\t}\n\n\taddScalar( s ) {\n\n\t\tthis.r += s;\n\t\tthis.g += s;\n\t\tthis.b += s;\n\n\t\treturn this;\n\n\t}\n\n\tsub( color ) {\n\n\t\tthis.r = Math.max( 0, this.r - color.r );\n\t\tthis.g = Math.max( 0, this.g - color.g );\n\t\tthis.b = Math.max( 0, this.b - color.b );\n\n\t\treturn this;\n\n\t}\n\n\tmultiply( color ) {\n\n\t\tthis.r *= color.r;\n\t\tthis.g *= color.g;\n\t\tthis.b *= color.b;\n\n\t\treturn this;\n\n\t}\n\n\tmultiplyScalar( s ) {\n\n\t\tthis.r *= s;\n\t\tthis.g *= s;\n\t\tthis.b *= s;\n\n\t\treturn this;\n\n\t}\n\n\tlerp( color, alpha ) {\n\n\t\tthis.r += ( color.r - this.r ) * alpha;\n\t\tthis.g += ( color.g - this.g ) * alpha;\n\t\tthis.b += ( color.b - this.b ) * alpha;\n\n\t\treturn this;\n\n\t}\n\n\tlerpColors( color1, color2, alpha ) {\n\n\t\tthis.r = color1.r + ( color2.r - color1.r ) * alpha;\n\t\tthis.g = color1.g + ( color2.g - color1.g ) * alpha;\n\t\tthis.b = color1.b + ( color2.b - color1.b ) * alpha;\n\n\t\treturn this;\n\n\t}\n\n\tlerpHSL( color, alpha ) {\n\n\t\tthis.getHSL( _hslA );\n\t\tcolor.getHSL( _hslB );\n\n\t\tconst h = lerp( _hslA.h, _hslB.h, alpha );\n\t\tconst s = lerp( _hslA.s, _hslB.s, alpha );\n\t\tconst l = lerp( _hslA.l, _hslB.l, alpha );\n\n\t\tthis.setHSL( h, s, l );\n\n\t\treturn this;\n\n\t}\n\n\tsetFromVector3( v ) {\n\n\t\tthis.r = v.x;\n\t\tthis.g = v.y;\n\t\tthis.b = v.z;\n\n\t\treturn this;\n\n\t}\n\n\tapplyMatrix3( m ) {\n\n\t\tconst r = this.r, g = this.g, b = this.b;\n\t\tconst e = m.elements;\n\n\t\tthis.r = e[ 0 ] * r + e[ 3 ] * g + e[ 6 ] * b;\n\t\tthis.g = e[ 1 ] * r + e[ 4 ] * g + e[ 7 ] * b;\n\t\tthis.b = e[ 2 ] * r + e[ 5 ] * g + e[ 8 ] * b;\n\n\t\treturn this;\n\n\t}\n\n\tequals( c ) {\n\n\t\treturn ( c.r === this.r ) && ( c.g === this.g ) && ( c.b === this.b );\n\n\t}\n\n\tfromArray( array, offset = 0 ) {\n\n\t\tthis.r = array[ offset ];\n\t\tthis.g = array[ offset + 1 ];\n\t\tthis.b = array[ offset + 2 ];\n\n\t\treturn this;\n\n\t}\n\n\ttoArray( array = [], offset = 0 ) {\n\n\t\tarray[ offset ] = this.r;\n\t\tarray[ offset + 1 ] = this.g;\n\t\tarray[ offset + 2 ] = this.b;\n\n\t\treturn array;\n\n\t}\n\n\tfromBufferAttribute( attribute, index ) {\n\n\t\tthis.r = attribute.getX( index );\n\t\tthis.g = attribute.getY( index );\n\t\tthis.b = attribute.getZ( index );\n\n\t\treturn this;\n\n\t}\n\n\ttoJSON() {\n\n\t\treturn this.getHex();\n\n\t}\n\n\t*[ Symbol.iterator ]() {\n\n\t\tyield this.r;\n\t\tyield this.g;\n\t\tyield this.b;\n\n\t}\n\n}\n\nconst _color = /*@__PURE__*/ new Color();\n\nColor.NAMES = _colorKeywords;\n\nlet _materialId = 0;\n\nclass Material extends EventDispatcher {\n\n\tconstructor() {\n\n\t\tsuper();\n\n\t\tthis.isMaterial = true;\n\n\t\tObject.defineProperty( this, 'id', { value: _materialId ++ } );\n\n\t\tthis.uuid = generateUUID();\n\n\t\tthis.name = '';\n\t\tthis.type = 'Material';\n\n\t\tthis.blending = NormalBlending;\n\t\tthis.side = FrontSide;\n\t\tthis.vertexColors = false;\n\n\t\tthis.opacity = 1;\n\t\tthis.transparent = false;\n\t\tthis.alphaHash = false;\n\n\t\tthis.blendSrc = SrcAlphaFactor;\n\t\tthis.blendDst = OneMinusSrcAlphaFactor;\n\t\tthis.blendEquation = AddEquation;\n\t\tthis.blendSrcAlpha = null;\n\t\tthis.blendDstAlpha = null;\n\t\tthis.blendEquationAlpha = null;\n\t\tthis.blendColor = new Color( 0, 0, 0 );\n\t\tthis.blendAlpha = 0;\n\n\t\tthis.depthFunc = LessEqualDepth;\n\t\tthis.depthTest = true;\n\t\tthis.depthWrite = true;\n\n\t\tthis.stencilWriteMask = 0xff;\n\t\tthis.stencilFunc = AlwaysStencilFunc;\n\t\tthis.stencilRef = 0;\n\t\tthis.stencilFuncMask = 0xff;\n\t\tthis.stencilFail = KeepStencilOp;\n\t\tthis.stencilZFail = KeepStencilOp;\n\t\tthis.stencilZPass = KeepStencilOp;\n\t\tthis.stencilWrite = false;\n\n\t\tthis.clippingPlanes = null;\n\t\tthis.clipIntersection = false;\n\t\tthis.clipShadows = false;\n\n\t\tthis.shadowSide = null;\n\n\t\tthis.colorWrite = true;\n\n\t\tthis.precision = null; // override the renderer's default precision for this material\n\n\t\tthis.polygonOffset = false;\n\t\tthis.polygonOffsetFactor = 0;\n\t\tthis.polygonOffsetUnits = 0;\n\n\t\tthis.dithering = false;\n\n\t\tthis.alphaToCoverage = false;\n\t\tthis.premultipliedAlpha = false;\n\t\tthis.forceSinglePass = false;\n\n\t\tthis.visible = true;\n\n\t\tthis.toneMapped = true;\n\n\t\tthis.userData = {};\n\n\t\tthis.version = 0;\n\n\t\tthis._alphaTest = 0;\n\n\t}\n\n\tget alphaTest() {\n\n\t\treturn this._alphaTest;\n\n\t}\n\n\tset alphaTest( value ) {\n\n\t\tif ( this._alphaTest > 0 !== value > 0 ) {\n\n\t\t\tthis.version ++;\n\n\t\t}\n\n\t\tthis._alphaTest = value;\n\n\t}\n\n\tonBuild( /* shaderobject, renderer */ ) {}\n\n\tonBeforeRender( /* renderer, scene, camera, geometry, object, group */ ) {}\n\n\tonBeforeCompile( /* shaderobject, renderer */ ) {}\n\n\tcustomProgramCacheKey() {\n\n\t\treturn this.onBeforeCompile.toString();\n\n\t}\n\n\tsetValues( values ) {\n\n\t\tif ( values === undefined ) return;\n\n\t\tfor ( const key in values ) {\n\n\t\t\tconst newValue = values[ key ];\n\n\t\t\tif ( newValue === undefined ) {\n\n\t\t\t\tconsole.warn( `THREE.Material: parameter '${ key }' has value of undefined.` );\n\t\t\t\tcontinue;\n\n\t\t\t}\n\n\t\t\tconst currentValue = this[ key ];\n\n\t\t\tif ( currentValue === undefined ) {\n\n\t\t\t\tconsole.warn( `THREE.Material: '${ key }' is not a property of THREE.${ this.type }.` );\n\t\t\t\tcontinue;\n\n\t\t\t}\n\n\t\t\tif ( currentValue && currentValue.isColor ) {\n\n\t\t\t\tcurrentValue.set( newValue );\n\n\t\t\t} else if ( ( currentValue && currentValue.isVector3 ) && ( newValue && newValue.isVector3 ) ) {\n\n\t\t\t\tcurrentValue.copy( newValue );\n\n\t\t\t} else {\n\n\t\t\t\tthis[ key ] = newValue;\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n\ttoJSON( meta ) {\n\n\t\tconst isRootObject = ( meta === undefined || typeof meta === 'string' );\n\n\t\tif ( isRootObject ) {\n\n\t\t\tmeta = {\n\t\t\t\ttextures: {},\n\t\t\t\timages: {}\n\t\t\t};\n\n\t\t}\n\n\t\tconst data = {\n\t\t\tmetadata: {\n\t\t\t\tversion: 4.6,\n\t\t\t\ttype: 'Material',\n\t\t\t\tgenerator: 'Material.toJSON'\n\t\t\t}\n\t\t};\n\n\t\t// standard Material serialization\n\t\tdata.uuid = this.uuid;\n\t\tdata.type = this.type;\n\n\t\tif ( this.name !== '' ) data.name = this.name;\n\n\t\tif ( this.color && this.color.isColor ) data.color = this.color.getHex();\n\n\t\tif ( this.roughness !== undefined ) data.roughness = this.roughness;\n\t\tif ( this.metalness !== undefined ) data.metalness = this.metalness;\n\n\t\tif ( this.sheen !== undefined ) data.sheen = this.sheen;\n\t\tif ( this.sheenColor && this.sheenColor.isColor ) data.sheenColor = this.sheenColor.getHex();\n\t\tif ( this.sheenRoughness !== undefined ) data.sheenRoughness = this.sheenRoughness;\n\t\tif ( this.emissive && this.emissive.isColor ) data.emissive = this.emissive.getHex();\n\t\tif ( this.emissiveIntensity !== undefined && this.emissiveIntensity !== 1 ) data.emissiveIntensity = this.emissiveIntensity;\n\n\t\tif ( this.specular && this.specular.isColor ) data.specular = this.specular.getHex();\n\t\tif ( this.specularIntensity !== undefined ) data.specularIntensity = this.specularIntensity;\n\t\tif ( this.specularColor && this.specularColor.isColor ) data.specularColor = this.specularColor.getHex();\n\t\tif ( this.shininess !== undefined ) data.shininess = this.shininess;\n\t\tif ( this.clearcoat !== undefined ) data.clearcoat = this.clearcoat;\n\t\tif ( this.clearcoatRoughness !== undefined ) data.clearcoatRoughness = this.clearcoatRoughness;\n\n\t\tif ( this.clearcoatMap && this.clearcoatMap.isTexture ) {\n\n\t\t\tdata.clearcoatMap = this.clearcoatMap.toJSON( meta ).uuid;\n\n\t\t}\n\n\t\tif ( this.clearcoatRoughnessMap && this.clearcoatRoughnessMap.isTexture ) {\n\n\t\t\tdata.clearcoatRoughnessMap = this.clearcoatRoughnessMap.toJSON( meta ).uuid;\n\n\t\t}\n\n\t\tif ( this.clearcoatNormalMap && this.clearcoatNormalMap.isTexture ) {\n\n\t\t\tdata.clearcoatNormalMap = this.clearcoatNormalMap.toJSON( meta ).uuid;\n\t\t\tdata.clearcoatNormalScale = this.clearcoatNormalScale.toArray();\n\n\t\t}\n\n\t\tif ( this.iridescence !== undefined ) data.iridescence = this.iridescence;\n\t\tif ( this.iridescenceIOR !== undefined ) data.iridescenceIOR = this.iridescenceIOR;\n\t\tif ( this.iridescenceThicknessRange !== undefined ) data.iridescenceThicknessRange = this.iridescenceThicknessRange;\n\n\t\tif ( this.iridescenceMap && this.iridescenceMap.isTexture ) {\n\n\t\t\tdata.iridescenceMap = this.iridescenceMap.toJSON( meta ).uuid;\n\n\t\t}\n\n\t\tif ( this.iridescenceThicknessMap && this.iridescenceThicknessMap.isTexture ) {\n\n\t\t\tdata.iridescenceThicknessMap = this.iridescenceThicknessMap.toJSON( meta ).uuid;\n\n\t\t}\n\n\t\tif ( this.anisotropy !== undefined ) data.anisotropy = this.anisotropy;\n\t\tif ( this.anisotropyRotation !== undefined ) data.anisotropyRotation = this.anisotropyRotation;\n\n\t\tif ( this.anisotropyMap && this.anisotropyMap.isTexture ) {\n\n\t\t\tdata.anisotropyMap = this.anisotropyMap.toJSON( meta ).uuid;\n\n\t\t}\n\n\t\tif ( this.map && this.map.isTexture ) data.map = this.map.toJSON( meta ).uuid;\n\t\tif ( this.matcap && this.matcap.isTexture ) data.matcap = this.matcap.toJSON( meta ).uuid;\n\t\tif ( this.alphaMap && this.alphaMap.isTexture ) data.alphaMap = this.alphaMap.toJSON( meta ).uuid;\n\n\t\tif ( this.lightMap && this.lightMap.isTexture ) {\n\n\t\t\tdata.lightMap = this.lightMap.toJSON( meta ).uuid;\n\t\t\tdata.lightMapIntensity = this.lightMapIntensity;\n\n\t\t}\n\n\t\tif ( this.aoMap && this.aoMap.isTexture ) {\n\n\t\t\tdata.aoMap = this.aoMap.toJSON( meta ).uuid;\n\t\t\tdata.aoMapIntensity = this.aoMapIntensity;\n\n\t\t}\n\n\t\tif ( this.bumpMap && this.bumpMap.isTexture ) {\n\n\t\t\tdata.bumpMap = this.bumpMap.toJSON( meta ).uuid;\n\t\t\tdata.bumpScale = this.bumpScale;\n\n\t\t}\n\n\t\tif ( this.normalMap && this.normalMap.isTexture ) {\n\n\t\t\tdata.normalMap = this.normalMap.toJSON( meta ).uuid;\n\t\t\tdata.normalMapType = this.normalMapType;\n\t\t\tdata.normalScale = this.normalScale.toArray();\n\n\t\t}\n\n\t\tif ( this.displacementMap && this.displacementMap.isTexture ) {\n\n\t\t\tdata.displacementMap = this.displacementMap.toJSON( meta ).uuid;\n\t\t\tdata.displacementScale = this.displacementScale;\n\t\t\tdata.displacementBias = this.displacementBias;\n\n\t\t}\n\n\t\tif ( this.roughnessMap && this.roughnessMap.isTexture ) data.roughnessMap = this.roughnessMap.toJSON( meta ).uuid;\n\t\tif ( this.metalnessMap && this.metalnessMap.isTexture ) data.metalnessMap = this.metalnessMap.toJSON( meta ).uuid;\n\n\t\tif ( this.emissiveMap && this.emissiveMap.isTexture ) data.emissiveMap = this.emissiveMap.toJSON( meta ).uuid;\n\t\tif ( this.specularMap && this.specularMap.isTexture ) data.specularMap = this.specularMap.toJSON( meta ).uuid;\n\t\tif ( this.specularIntensityMap && this.specularIntensityMap.isTexture ) data.specularIntensityMap = this.specularIntensityMap.toJSON( meta ).uuid;\n\t\tif ( this.specularColorMap && this.specularColorMap.isTexture ) data.specularColorMap = this.specularColorMap.toJSON( meta ).uuid;\n\n\t\tif ( this.envMap && this.envMap.isTexture ) {\n\n\t\t\tdata.envMap = this.envMap.toJSON( meta ).uuid;\n\n\t\t\tif ( this.combine !== undefined ) data.combine = this.combine;\n\n\t\t}\n\n\t\tif ( this.envMapRotation !== undefined ) data.envMapRotation = this.envMapRotation.toArray();\n\t\tif ( this.envMapIntensity !== undefined ) data.envMapIntensity = this.envMapIntensity;\n\t\tif ( this.reflectivity !== undefined ) data.reflectivity = this.reflectivity;\n\t\tif ( this.refractionRatio !== undefined ) data.refractionRatio = this.refractionRatio;\n\n\t\tif ( this.gradientMap && this.gradientMap.isTexture ) {\n\n\t\t\tdata.gradientMap = this.gradientMap.toJSON( meta ).uuid;\n\n\t\t}\n\n\t\tif ( this.transmission !== undefined ) data.transmission = this.transmission;\n\t\tif ( this.transmissionMap && this.transmissionMap.isTexture ) data.transmissionMap = this.transmissionMap.toJSON( meta ).uuid;\n\t\tif ( this.thickness !== undefined ) data.thickness = this.thickness;\n\t\tif ( this.thicknessMap && this.thicknessMap.isTexture ) data.thicknessMap = this.thicknessMap.toJSON( meta ).uuid;\n\t\tif ( this.attenuationDistance !== undefined && this.attenuationDistance !== Infinity ) data.attenuationDistance = this.attenuationDistance;\n\t\tif ( this.attenuationColor !== undefined ) data.attenuationColor = this.attenuationColor.getHex();\n\n\t\tif ( this.size !== undefined ) data.size = this.size;\n\t\tif ( this.shadowSide !== null ) data.shadowSide = this.shadowSide;\n\t\tif ( this.sizeAttenuation !== undefined ) data.sizeAttenuation = this.sizeAttenuation;\n\n\t\tif ( this.blending !== NormalBlending ) data.blending = this.blending;\n\t\tif ( this.side !== FrontSide ) data.side = this.side;\n\t\tif ( this.vertexColors === true ) data.vertexColors = true;\n\n\t\tif ( this.opacity < 1 ) data.opacity = this.opacity;\n\t\tif ( this.transparent === true ) data.transparent = true;\n\n\t\tif ( this.blendSrc !== SrcAlphaFactor ) data.blendSrc = this.blendSrc;\n\t\tif ( this.blendDst !== OneMinusSrcAlphaFactor ) data.blendDst = this.blendDst;\n\t\tif ( this.blendEquation !== AddEquation ) data.blendEquation = this.blendEquation;\n\t\tif ( this.blendSrcAlpha !== null ) data.blendSrcAlpha = this.blendSrcAlpha;\n\t\tif ( this.blendDstAlpha !== null ) data.blendDstAlpha = this.blendDstAlpha;\n\t\tif ( this.blendEquationAlpha !== null ) data.blendEquationAlpha = this.blendEquationAlpha;\n\t\tif ( this.blendColor && this.blendColor.isColor ) data.blendColor = this.blendColor.getHex();\n\t\tif ( this.blendAlpha !== 0 ) data.blendAlpha = this.blendAlpha;\n\n\t\tif ( this.depthFunc !== LessEqualDepth ) data.depthFunc = this.depthFunc;\n\t\tif ( this.depthTest === false ) data.depthTest = this.depthTest;\n\t\tif ( this.depthWrite === false ) data.depthWrite = this.depthWrite;\n\t\tif ( this.colorWrite === false ) data.colorWrite = this.colorWrite;\n\n\t\tif ( this.stencilWriteMask !== 0xff ) data.stencilWriteMask = this.stencilWriteMask;\n\t\tif ( this.stencilFunc !== AlwaysStencilFunc ) data.stencilFunc = this.stencilFunc;\n\t\tif ( this.stencilRef !== 0 ) data.stencilRef = this.stencilRef;\n\t\tif ( this.stencilFuncMask !== 0xff ) data.stencilFuncMask = this.stencilFuncMask;\n\t\tif ( this.stencilFail !== KeepStencilOp ) data.stencilFail = this.stencilFail;\n\t\tif ( this.stencilZFail !== KeepStencilOp ) data.stencilZFail = this.stencilZFail;\n\t\tif ( this.stencilZPass !== KeepStencilOp ) data.stencilZPass = this.stencilZPass;\n\t\tif ( this.stencilWrite === true ) data.stencilWrite = this.stencilWrite;\n\n\t\t// rotation (SpriteMaterial)\n\t\tif ( this.rotation !== undefined && this.rotation !== 0 ) data.rotation = this.rotation;\n\n\t\tif ( this.polygonOffset === true ) data.polygonOffset = true;\n\t\tif ( this.polygonOffsetFactor !== 0 ) data.polygonOffsetFactor = this.polygonOffsetFactor;\n\t\tif ( this.polygonOffsetUnits !== 0 ) data.polygonOffsetUnits = this.polygonOffsetUnits;\n\n\t\tif ( this.linewidth !== undefined && this.linewidth !== 1 ) data.linewidth = this.linewidth;\n\t\tif ( this.dashSize !== undefined ) data.dashSize = this.dashSize;\n\t\tif ( this.gapSize !== undefined ) data.gapSize = this.gapSize;\n\t\tif ( this.scale !== undefined ) data.scale = this.scale;\n\n\t\tif ( this.dithering === true ) data.dithering = true;\n\n\t\tif ( this.alphaTest > 0 ) data.alphaTest = this.alphaTest;\n\t\tif ( this.alphaHash === true ) data.alphaHash = true;\n\t\tif ( this.alphaToCoverage === true ) data.alphaToCoverage = true;\n\t\tif ( this.premultipliedAlpha === true ) data.premultipliedAlpha = true;\n\t\tif ( this.forceSinglePass === true ) data.forceSinglePass = true;\n\n\t\tif ( this.wireframe === true ) data.wireframe = true;\n\t\tif ( this.wireframeLinewidth > 1 ) data.wireframeLinewidth = this.wireframeLinewidth;\n\t\tif ( this.wireframeLinecap !== 'round' ) data.wireframeLinecap = this.wireframeLinecap;\n\t\tif ( this.wireframeLinejoin !== 'round' ) data.wireframeLinejoin = this.wireframeLinejoin;\n\n\t\tif ( this.flatShading === true ) data.flatShading = true;\n\n\t\tif ( this.visible === false ) data.visible = false;\n\n\t\tif ( this.toneMapped === false ) data.toneMapped = false;\n\n\t\tif ( this.fog === false ) data.fog = false;\n\n\t\tif ( Object.keys( this.userData ).length > 0 ) data.userData = this.userData;\n\n\t\t// TODO: Copied from Object3D.toJSON\n\n\t\tfunction extractFromCache( cache ) {\n\n\t\t\tconst values = [];\n\n\t\t\tfor ( const key in cache ) {\n\n\t\t\t\tconst data = cache[ key ];\n\t\t\t\tdelete data.metadata;\n\t\t\t\tvalues.push( data );\n\n\t\t\t}\n\n\t\t\treturn values;\n\n\t\t}\n\n\t\tif ( isRootObject ) {\n\n\t\t\tconst textures = extractFromCache( meta.textures );\n\t\t\tconst images = extractFromCache( meta.images );\n\n\t\t\tif ( textures.length > 0 ) data.textures = textures;\n\t\t\tif ( images.length > 0 ) data.images = images;\n\n\t\t}\n\n\t\treturn data;\n\n\t}\n\n\tclone() {\n\n\t\treturn new this.constructor().copy( this );\n\n\t}\n\n\tcopy( source ) {\n\n\t\tthis.name = source.name;\n\n\t\tthis.blending = source.blending;\n\t\tthis.side = source.side;\n\t\tthis.vertexColors = source.vertexColors;\n\n\t\tthis.opacity = source.opacity;\n\t\tthis.transparent = source.transparent;\n\n\t\tthis.blendSrc = source.blendSrc;\n\t\tthis.blendDst = source.blendDst;\n\t\tthis.blendEquation = source.blendEquation;\n\t\tthis.blendSrcAlpha = source.blendSrcAlpha;\n\t\tthis.blendDstAlpha = source.blendDstAlpha;\n\t\tthis.blendEquationAlpha = source.blendEquationAlpha;\n\t\tthis.blendColor.copy( source.blendColor );\n\t\tthis.blendAlpha = source.blendAlpha;\n\n\t\tthis.depthFunc = source.depthFunc;\n\t\tthis.depthTest = source.depthTest;\n\t\tthis.depthWrite = source.depthWrite;\n\n\t\tthis.stencilWriteMask = source.stencilWriteMask;\n\t\tthis.stencilFunc = source.stencilFunc;\n\t\tthis.stencilRef = source.stencilRef;\n\t\tthis.stencilFuncMask = source.stencilFuncMask;\n\t\tthis.stencilFail = source.stencilFail;\n\t\tthis.stencilZFail = source.stencilZFail;\n\t\tthis.stencilZPass = source.stencilZPass;\n\t\tthis.stencilWrite = source.stencilWrite;\n\n\t\tconst srcPlanes = source.clippingPlanes;\n\t\tlet dstPlanes = null;\n\n\t\tif ( srcPlanes !== null ) {\n\n\t\t\tconst n = srcPlanes.length;\n\t\t\tdstPlanes = new Array( n );\n\n\t\t\tfor ( let i = 0; i !== n; ++ i ) {\n\n\t\t\t\tdstPlanes[ i ] = srcPlanes[ i ].clone();\n\n\t\t\t}\n\n\t\t}\n\n\t\tthis.clippingPlanes = dstPlanes;\n\t\tthis.clipIntersection = source.clipIntersection;\n\t\tthis.clipShadows = source.clipShadows;\n\n\t\tthis.shadowSide = source.shadowSide;\n\n\t\tthis.colorWrite = source.colorWrite;\n\n\t\tthis.precision = source.precision;\n\n\t\tthis.polygonOffset = source.polygonOffset;\n\t\tthis.polygonOffsetFactor = source.polygonOffsetFactor;\n\t\tthis.polygonOffsetUnits = source.polygonOffsetUnits;\n\n\t\tthis.dithering = source.dithering;\n\n\t\tthis.alphaTest = source.alphaTest;\n\t\tthis.alphaHash = source.alphaHash;\n\t\tthis.alphaToCoverage = source.alphaToCoverage;\n\t\tthis.premultipliedAlpha = source.premultipliedAlpha;\n\t\tthis.forceSinglePass = source.forceSinglePass;\n\n\t\tthis.visible = source.visible;\n\n\t\tthis.toneMapped = source.toneMapped;\n\n\t\tthis.userData = JSON.parse( JSON.stringify( source.userData ) );\n\n\t\treturn this;\n\n\t}\n\n\tdispose() {\n\n\t\tthis.dispatchEvent( { type: 'dispose' } );\n\n\t}\n\n\tset needsUpdate( value ) {\n\n\t\tif ( value === true ) this.version ++;\n\n\t}\n\n}\n\nclass MeshBasicMaterial extends Material {\n\n\tconstructor( parameters ) {\n\n\t\tsuper();\n\n\t\tthis.isMeshBasicMaterial = true;\n\n\t\tthis.type = 'MeshBasicMaterial';\n\n\t\tthis.color = new Color( 0xffffff ); // emissive\n\n\t\tthis.map = null;\n\n\t\tthis.lightMap = null;\n\t\tthis.lightMapIntensity = 1.0;\n\n\t\tthis.aoMap = null;\n\t\tthis.aoMapIntensity = 1.0;\n\n\t\tthis.specularMap = null;\n\n\t\tthis.alphaMap = null;\n\n\t\tthis.envMap = null;\n\t\tthis.envMapRotation = new Euler();\n\t\tthis.combine = MultiplyOperation;\n\t\tthis.reflectivity = 1;\n\t\tthis.refractionRatio = 0.98;\n\n\t\tthis.wireframe = false;\n\t\tthis.wireframeLinewidth = 1;\n\t\tthis.wireframeLinecap = 'round';\n\t\tthis.wireframeLinejoin = 'round';\n\n\t\tthis.fog = true;\n\n\t\tthis.setValues( parameters );\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.color.copy( source.color );\n\n\t\tthis.map = source.map;\n\n\t\tthis.lightMap = source.lightMap;\n\t\tthis.lightMapIntensity = source.lightMapIntensity;\n\n\t\tthis.aoMap = source.aoMap;\n\t\tthis.aoMapIntensity = source.aoMapIntensity;\n\n\t\tthis.specularMap = source.specularMap;\n\n\t\tthis.alphaMap = source.alphaMap;\n\n\t\tthis.envMap = source.envMap;\n\t\tthis.envMapRotation.copy( source.envMapRotation );\n\t\tthis.combine = source.combine;\n\t\tthis.reflectivity = source.reflectivity;\n\t\tthis.refractionRatio = source.refractionRatio;\n\n\t\tthis.wireframe = source.wireframe;\n\t\tthis.wireframeLinewidth = source.wireframeLinewidth;\n\t\tthis.wireframeLinecap = source.wireframeLinecap;\n\t\tthis.wireframeLinejoin = source.wireframeLinejoin;\n\n\t\tthis.fog = source.fog;\n\n\t\treturn this;\n\n\t}\n\n}\n\n// Fast Half Float Conversions, http://www.fox-toolkit.org/ftp/fasthalffloatconversion.pdf\n\nconst _tables = /*@__PURE__*/ _generateTables();\n\nfunction _generateTables() {\n\n\t// float32 to float16 helpers\n\n\tconst buffer = new ArrayBuffer( 4 );\n\tconst floatView = new Float32Array( buffer );\n\tconst uint32View = new Uint32Array( buffer );\n\n\tconst baseTable = new Uint32Array( 512 );\n\tconst shiftTable = new Uint32Array( 512 );\n\n\tfor ( let i = 0; i < 256; ++ i ) {\n\n\t\tconst e = i - 127;\n\n\t\t// very small number (0, -0)\n\n\t\tif ( e < - 27 ) {\n\n\t\t\tbaseTable[ i ] = 0x0000;\n\t\t\tbaseTable[ i | 0x100 ] = 0x8000;\n\t\t\tshiftTable[ i ] = 24;\n\t\t\tshiftTable[ i | 0x100 ] = 24;\n\n\t\t\t// small number (denorm)\n\n\t\t} else if ( e < - 14 ) {\n\n\t\t\tbaseTable[ i ] = 0x0400 >> ( - e - 14 );\n\t\t\tbaseTable[ i | 0x100 ] = ( 0x0400 >> ( - e - 14 ) ) | 0x8000;\n\t\t\tshiftTable[ i ] = - e - 1;\n\t\t\tshiftTable[ i | 0x100 ] = - e - 1;\n\n\t\t\t// normal number\n\n\t\t} else if ( e <= 15 ) {\n\n\t\t\tbaseTable[ i ] = ( e + 15 ) << 10;\n\t\t\tbaseTable[ i | 0x100 ] = ( ( e + 15 ) << 10 ) | 0x8000;\n\t\t\tshiftTable[ i ] = 13;\n\t\t\tshiftTable[ i | 0x100 ] = 13;\n\n\t\t\t// large number (Infinity, -Infinity)\n\n\t\t} else if ( e < 128 ) {\n\n\t\t\tbaseTable[ i ] = 0x7c00;\n\t\t\tbaseTable[ i | 0x100 ] = 0xfc00;\n\t\t\tshiftTable[ i ] = 24;\n\t\t\tshiftTable[ i | 0x100 ] = 24;\n\n\t\t\t// stay (NaN, Infinity, -Infinity)\n\n\t\t} else {\n\n\t\t\tbaseTable[ i ] = 0x7c00;\n\t\t\tbaseTable[ i | 0x100 ] = 0xfc00;\n\t\t\tshiftTable[ i ] = 13;\n\t\t\tshiftTable[ i | 0x100 ] = 13;\n\n\t\t}\n\n\t}\n\n\t// float16 to float32 helpers\n\n\tconst mantissaTable = new Uint32Array( 2048 );\n\tconst exponentTable = new Uint32Array( 64 );\n\tconst offsetTable = new Uint32Array( 64 );\n\n\tfor ( let i = 1; i < 1024; ++ i ) {\n\n\t\tlet m = i << 13; // zero pad mantissa bits\n\t\tlet e = 0; // zero exponent\n\n\t\t// normalized\n\t\twhile ( ( m & 0x00800000 ) === 0 ) {\n\n\t\t\tm <<= 1;\n\t\t\te -= 0x00800000; // decrement exponent\n\n\t\t}\n\n\t\tm &= ~ 0x00800000; // clear leading 1 bit\n\t\te += 0x38800000; // adjust bias\n\n\t\tmantissaTable[ i ] = m | e;\n\n\t}\n\n\tfor ( let i = 1024; i < 2048; ++ i ) {\n\n\t\tmantissaTable[ i ] = 0x38000000 + ( ( i - 1024 ) << 13 );\n\n\t}\n\n\tfor ( let i = 1; i < 31; ++ i ) {\n\n\t\texponentTable[ i ] = i << 23;\n\n\t}\n\n\texponentTable[ 31 ] = 0x47800000;\n\texponentTable[ 32 ] = 0x80000000;\n\n\tfor ( let i = 33; i < 63; ++ i ) {\n\n\t\texponentTable[ i ] = 0x80000000 + ( ( i - 32 ) << 23 );\n\n\t}\n\n\texponentTable[ 63 ] = 0xc7800000;\n\n\tfor ( let i = 1; i < 64; ++ i ) {\n\n\t\tif ( i !== 32 ) {\n\n\t\t\toffsetTable[ i ] = 1024;\n\n\t\t}\n\n\t}\n\n\treturn {\n\t\tfloatView: floatView,\n\t\tuint32View: uint32View,\n\t\tbaseTable: baseTable,\n\t\tshiftTable: shiftTable,\n\t\tmantissaTable: mantissaTable,\n\t\texponentTable: exponentTable,\n\t\toffsetTable: offsetTable\n\t};\n\n}\n\n// float32 to float16\n\nfunction toHalfFloat( val ) {\n\n\tif ( Math.abs( val ) > 65504 ) console.warn( 'THREE.DataUtils.toHalfFloat(): Value out of range.' );\n\n\tval = clamp( val, - 65504, 65504 );\n\n\t_tables.floatView[ 0 ] = val;\n\tconst f = _tables.uint32View[ 0 ];\n\tconst e = ( f >> 23 ) & 0x1ff;\n\treturn _tables.baseTable[ e ] + ( ( f & 0x007fffff ) >> _tables.shiftTable[ e ] );\n\n}\n\n// float16 to float32\n\nfunction fromHalfFloat( val ) {\n\n\tconst m = val >> 10;\n\t_tables.uint32View[ 0 ] = _tables.mantissaTable[ _tables.offsetTable[ m ] + ( val & 0x3ff ) ] + _tables.exponentTable[ m ];\n\treturn _tables.floatView[ 0 ];\n\n}\n\nconst DataUtils = {\n\ttoHalfFloat: toHalfFloat,\n\tfromHalfFloat: fromHalfFloat,\n};\n\nconst _vector$9 = /*@__PURE__*/ new Vector3();\nconst _vector2$1 = /*@__PURE__*/ new Vector2();\n\nclass BufferAttribute {\n\n\tconstructor( array, itemSize, normalized = false ) {\n\n\t\tif ( Array.isArray( array ) ) {\n\n\t\t\tthrow new TypeError( 'THREE.BufferAttribute: array should be a Typed Array.' );\n\n\t\t}\n\n\t\tthis.isBufferAttribute = true;\n\n\t\tthis.name = '';\n\n\t\tthis.array = array;\n\t\tthis.itemSize = itemSize;\n\t\tthis.count = array !== undefined ? array.length / itemSize : 0;\n\t\tthis.normalized = normalized;\n\n\t\tthis.usage = StaticDrawUsage;\n\t\tthis._updateRange = { offset: 0, count: - 1 };\n\t\tthis.updateRanges = [];\n\t\tthis.gpuType = FloatType;\n\n\t\tthis.version = 0;\n\n\t}\n\n\tonUploadCallback() {}\n\n\tset needsUpdate( value ) {\n\n\t\tif ( value === true ) this.version ++;\n\n\t}\n\n\tget updateRange() {\n\n\t\twarnOnce( 'THREE.BufferAttribute: updateRange() is deprecated and will be removed in r169. Use addUpdateRange() instead.' ); // @deprecated, r159\n\t\treturn this._updateRange;\n\n\t}\n\n\tsetUsage( value ) {\n\n\t\tthis.usage = value;\n\n\t\treturn this;\n\n\t}\n\n\taddUpdateRange( start, count ) {\n\n\t\tthis.updateRanges.push( { start, count } );\n\n\t}\n\n\tclearUpdateRanges() {\n\n\t\tthis.updateRanges.length = 0;\n\n\t}\n\n\tcopy( source ) {\n\n\t\tthis.name = source.name;\n\t\tthis.array = new source.array.constructor( source.array );\n\t\tthis.itemSize = source.itemSize;\n\t\tthis.count = source.count;\n\t\tthis.normalized = source.normalized;\n\n\t\tthis.usage = source.usage;\n\t\tthis.gpuType = source.gpuType;\n\n\t\treturn this;\n\n\t}\n\n\tcopyAt( index1, attribute, index2 ) {\n\n\t\tindex1 *= this.itemSize;\n\t\tindex2 *= attribute.itemSize;\n\n\t\tfor ( let i = 0, l = this.itemSize; i < l; i ++ ) {\n\n\t\t\tthis.array[ index1 + i ] = attribute.array[ index2 + i ];\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tcopyArray( array ) {\n\n\t\tthis.array.set( array );\n\n\t\treturn this;\n\n\t}\n\n\tapplyMatrix3( m ) {\n\n\t\tif ( this.itemSize === 2 ) {\n\n\t\t\tfor ( let i = 0, l = this.count; i < l; i ++ ) {\n\n\t\t\t\t_vector2$1.fromBufferAttribute( this, i );\n\t\t\t\t_vector2$1.applyMatrix3( m );\n\n\t\t\t\tthis.setXY( i, _vector2$1.x, _vector2$1.y );\n\n\t\t\t}\n\n\t\t} else if ( this.itemSize === 3 ) {\n\n\t\t\tfor ( let i = 0, l = this.count; i < l; i ++ ) {\n\n\t\t\t\t_vector$9.fromBufferAttribute( this, i );\n\t\t\t\t_vector$9.applyMatrix3( m );\n\n\t\t\t\tthis.setXYZ( i, _vector$9.x, _vector$9.y, _vector$9.z );\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tapplyMatrix4( m ) {\n\n\t\tfor ( let i = 0, l = this.count; i < l; i ++ ) {\n\n\t\t\t_vector$9.fromBufferAttribute( this, i );\n\n\t\t\t_vector$9.applyMatrix4( m );\n\n\t\t\tthis.setXYZ( i, _vector$9.x, _vector$9.y, _vector$9.z );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tapplyNormalMatrix( m ) {\n\n\t\tfor ( let i = 0, l = this.count; i < l; i ++ ) {\n\n\t\t\t_vector$9.fromBufferAttribute( this, i );\n\n\t\t\t_vector$9.applyNormalMatrix( m );\n\n\t\t\tthis.setXYZ( i, _vector$9.x, _vector$9.y, _vector$9.z );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\ttransformDirection( m ) {\n\n\t\tfor ( let i = 0, l = this.count; i < l; i ++ ) {\n\n\t\t\t_vector$9.fromBufferAttribute( this, i );\n\n\t\t\t_vector$9.transformDirection( m );\n\n\t\t\tthis.setXYZ( i, _vector$9.x, _vector$9.y, _vector$9.z );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tset( value, offset = 0 ) {\n\n\t\t// Matching BufferAttribute constructor, do not normalize the array.\n\t\tthis.array.set( value, offset );\n\n\t\treturn this;\n\n\t}\n\n\tgetComponent( index, component ) {\n\n\t\tlet value = this.array[ index * this.itemSize + component ];\n\n\t\tif ( this.normalized ) value = denormalize( value, this.array );\n\n\t\treturn value;\n\n\t}\n\n\tsetComponent( index, component, value ) {\n\n\t\tif ( this.normalized ) value = normalize( value, this.array );\n\n\t\tthis.array[ index * this.itemSize + component ] = value;\n\n\t\treturn this;\n\n\t}\n\n\tgetX( index ) {\n\n\t\tlet x = this.array[ index * this.itemSize ];\n\n\t\tif ( this.normalized ) x = denormalize( x, this.array );\n\n\t\treturn x;\n\n\t}\n\n\tsetX( index, x ) {\n\n\t\tif ( this.normalized ) x = normalize( x, this.array );\n\n\t\tthis.array[ index * this.itemSize ] = x;\n\n\t\treturn this;\n\n\t}\n\n\tgetY( index ) {\n\n\t\tlet y = this.array[ index * this.itemSize + 1 ];\n\n\t\tif ( this.normalized ) y = denormalize( y, this.array );\n\n\t\treturn y;\n\n\t}\n\n\tsetY( index, y ) {\n\n\t\tif ( this.normalized ) y = normalize( y, this.array );\n\n\t\tthis.array[ index * this.itemSize + 1 ] = y;\n\n\t\treturn this;\n\n\t}\n\n\tgetZ( index ) {\n\n\t\tlet z = this.array[ index * this.itemSize + 2 ];\n\n\t\tif ( this.normalized ) z = denormalize( z, this.array );\n\n\t\treturn z;\n\n\t}\n\n\tsetZ( index, z ) {\n\n\t\tif ( this.normalized ) z = normalize( z, this.array );\n\n\t\tthis.array[ index * this.itemSize + 2 ] = z;\n\n\t\treturn this;\n\n\t}\n\n\tgetW( index ) {\n\n\t\tlet w = this.array[ index * this.itemSize + 3 ];\n\n\t\tif ( this.normalized ) w = denormalize( w, this.array );\n\n\t\treturn w;\n\n\t}\n\n\tsetW( index, w ) {\n\n\t\tif ( this.normalized ) w = normalize( w, this.array );\n\n\t\tthis.array[ index * this.itemSize + 3 ] = w;\n\n\t\treturn this;\n\n\t}\n\n\tsetXY( index, x, y ) {\n\n\t\tindex *= this.itemSize;\n\n\t\tif ( this.normalized ) {\n\n\t\t\tx = normalize( x, this.array );\n\t\t\ty = normalize( y, this.array );\n\n\t\t}\n\n\t\tthis.array[ index + 0 ] = x;\n\t\tthis.array[ index + 1 ] = y;\n\n\t\treturn this;\n\n\t}\n\n\tsetXYZ( index, x, y, z ) {\n\n\t\tindex *= this.itemSize;\n\n\t\tif ( this.normalized ) {\n\n\t\t\tx = normalize( x, this.array );\n\t\t\ty = normalize( y, this.array );\n\t\t\tz = normalize( z, this.array );\n\n\t\t}\n\n\t\tthis.array[ index + 0 ] = x;\n\t\tthis.array[ index + 1 ] = y;\n\t\tthis.array[ index + 2 ] = z;\n\n\t\treturn this;\n\n\t}\n\n\tsetXYZW( index, x, y, z, w ) {\n\n\t\tindex *= this.itemSize;\n\n\t\tif ( this.normalized ) {\n\n\t\t\tx = normalize( x, this.array );\n\t\t\ty = normalize( y, this.array );\n\t\t\tz = normalize( z, this.array );\n\t\t\tw = normalize( w, this.array );\n\n\t\t}\n\n\t\tthis.array[ index + 0 ] = x;\n\t\tthis.array[ index + 1 ] = y;\n\t\tthis.array[ index + 2 ] = z;\n\t\tthis.array[ index + 3 ] = w;\n\n\t\treturn this;\n\n\t}\n\n\tonUpload( callback ) {\n\n\t\tthis.onUploadCallback = callback;\n\n\t\treturn this;\n\n\t}\n\n\tclone() {\n\n\t\treturn new this.constructor( this.array, this.itemSize ).copy( this );\n\n\t}\n\n\ttoJSON() {\n\n\t\tconst data = {\n\t\t\titemSize: this.itemSize,\n\t\t\ttype: this.array.constructor.name,\n\t\t\tarray: Array.from( this.array ),\n\t\t\tnormalized: this.normalized\n\t\t};\n\n\t\tif ( this.name !== '' ) data.name = this.name;\n\t\tif ( this.usage !== StaticDrawUsage ) data.usage = this.usage;\n\n\t\treturn data;\n\n\t}\n\n}\n\n//\n\nclass Int8BufferAttribute extends BufferAttribute {\n\n\tconstructor( array, itemSize, normalized ) {\n\n\t\tsuper( new Int8Array( array ), itemSize, normalized );\n\n\t}\n\n}\n\nclass Uint8BufferAttribute extends BufferAttribute {\n\n\tconstructor( array, itemSize, normalized ) {\n\n\t\tsuper( new Uint8Array( array ), itemSize, normalized );\n\n\t}\n\n}\n\nclass Uint8ClampedBufferAttribute extends BufferAttribute {\n\n\tconstructor( array, itemSize, normalized ) {\n\n\t\tsuper( new Uint8ClampedArray( array ), itemSize, normalized );\n\n\t}\n\n}\n\nclass Int16BufferAttribute extends BufferAttribute {\n\n\tconstructor( array, itemSize, normalized ) {\n\n\t\tsuper( new Int16Array( array ), itemSize, normalized );\n\n\t}\n\n}\n\nclass Uint16BufferAttribute extends BufferAttribute {\n\n\tconstructor( array, itemSize, normalized ) {\n\n\t\tsuper( new Uint16Array( array ), itemSize, normalized );\n\n\t}\n\n}\n\nclass Int32BufferAttribute extends BufferAttribute {\n\n\tconstructor( array, itemSize, normalized ) {\n\n\t\tsuper( new Int32Array( array ), itemSize, normalized );\n\n\t}\n\n}\n\nclass Uint32BufferAttribute extends BufferAttribute {\n\n\tconstructor( array, itemSize, normalized ) {\n\n\t\tsuper( new Uint32Array( array ), itemSize, normalized );\n\n\t}\n\n}\n\nclass Float16BufferAttribute extends BufferAttribute {\n\n\tconstructor( array, itemSize, normalized ) {\n\n\t\tsuper( new Uint16Array( array ), itemSize, normalized );\n\n\t\tthis.isFloat16BufferAttribute = true;\n\n\t}\n\n\tgetX( index ) {\n\n\t\tlet x = fromHalfFloat( this.array[ index * this.itemSize ] );\n\n\t\tif ( this.normalized ) x = denormalize( x, this.array );\n\n\t\treturn x;\n\n\t}\n\n\tsetX( index, x ) {\n\n\t\tif ( this.normalized ) x = normalize( x, this.array );\n\n\t\tthis.array[ index * this.itemSize ] = toHalfFloat( x );\n\n\t\treturn this;\n\n\t}\n\n\tgetY( index ) {\n\n\t\tlet y = fromHalfFloat( this.array[ index * this.itemSize + 1 ] );\n\n\t\tif ( this.normalized ) y = denormalize( y, this.array );\n\n\t\treturn y;\n\n\t}\n\n\tsetY( index, y ) {\n\n\t\tif ( this.normalized ) y = normalize( y, this.array );\n\n\t\tthis.array[ index * this.itemSize + 1 ] = toHalfFloat( y );\n\n\t\treturn this;\n\n\t}\n\n\tgetZ( index ) {\n\n\t\tlet z = fromHalfFloat( this.array[ index * this.itemSize + 2 ] );\n\n\t\tif ( this.normalized ) z = denormalize( z, this.array );\n\n\t\treturn z;\n\n\t}\n\n\tsetZ( index, z ) {\n\n\t\tif ( this.normalized ) z = normalize( z, this.array );\n\n\t\tthis.array[ index * this.itemSize + 2 ] = toHalfFloat( z );\n\n\t\treturn this;\n\n\t}\n\n\tgetW( index ) {\n\n\t\tlet w = fromHalfFloat( this.array[ index * this.itemSize + 3 ] );\n\n\t\tif ( this.normalized ) w = denormalize( w, this.array );\n\n\t\treturn w;\n\n\t}\n\n\tsetW( index, w ) {\n\n\t\tif ( this.normalized ) w = normalize( w, this.array );\n\n\t\tthis.array[ index * this.itemSize + 3 ] = toHalfFloat( w );\n\n\t\treturn this;\n\n\t}\n\n\tsetXY( index, x, y ) {\n\n\t\tindex *= this.itemSize;\n\n\t\tif ( this.normalized ) {\n\n\t\t\tx = normalize( x, this.array );\n\t\t\ty = normalize( y, this.array );\n\n\t\t}\n\n\t\tthis.array[ index + 0 ] = toHalfFloat( x );\n\t\tthis.array[ index + 1 ] = toHalfFloat( y );\n\n\t\treturn this;\n\n\t}\n\n\tsetXYZ( index, x, y, z ) {\n\n\t\tindex *= this.itemSize;\n\n\t\tif ( this.normalized ) {\n\n\t\t\tx = normalize( x, this.array );\n\t\t\ty = normalize( y, this.array );\n\t\t\tz = normalize( z, this.array );\n\n\t\t}\n\n\t\tthis.array[ index + 0 ] = toHalfFloat( x );\n\t\tthis.array[ index + 1 ] = toHalfFloat( y );\n\t\tthis.array[ index + 2 ] = toHalfFloat( z );\n\n\t\treturn this;\n\n\t}\n\n\tsetXYZW( index, x, y, z, w ) {\n\n\t\tindex *= this.itemSize;\n\n\t\tif ( this.normalized ) {\n\n\t\t\tx = normalize( x, this.array );\n\t\t\ty = normalize( y, this.array );\n\t\t\tz = normalize( z, this.array );\n\t\t\tw = normalize( w, this.array );\n\n\t\t}\n\n\t\tthis.array[ index + 0 ] = toHalfFloat( x );\n\t\tthis.array[ index + 1 ] = toHalfFloat( y );\n\t\tthis.array[ index + 2 ] = toHalfFloat( z );\n\t\tthis.array[ index + 3 ] = toHalfFloat( w );\n\n\t\treturn this;\n\n\t}\n\n}\n\n\nclass Float32BufferAttribute extends BufferAttribute {\n\n\tconstructor( array, itemSize, normalized ) {\n\n\t\tsuper( new Float32Array( array ), itemSize, normalized );\n\n\t}\n\n}\n\nlet _id$2 = 0;\n\nconst _m1$2 = /*@__PURE__*/ new Matrix4();\nconst _obj = /*@__PURE__*/ new Object3D();\nconst _offset = /*@__PURE__*/ new Vector3();\nconst _box$2 = /*@__PURE__*/ new Box3();\nconst _boxMorphTargets = /*@__PURE__*/ new Box3();\nconst _vector$8 = /*@__PURE__*/ new Vector3();\n\nclass BufferGeometry extends EventDispatcher {\n\n\tconstructor() {\n\n\t\tsuper();\n\n\t\tthis.isBufferGeometry = true;\n\n\t\tObject.defineProperty( this, 'id', { value: _id$2 ++ } );\n\n\t\tthis.uuid = generateUUID();\n\n\t\tthis.name = '';\n\t\tthis.type = 'BufferGeometry';\n\n\t\tthis.index = null;\n\t\tthis.attributes = {};\n\n\t\tthis.morphAttributes = {};\n\t\tthis.morphTargetsRelative = false;\n\n\t\tthis.groups = [];\n\n\t\tthis.boundingBox = null;\n\t\tthis.boundingSphere = null;\n\n\t\tthis.drawRange = { start: 0, count: Infinity };\n\n\t\tthis.userData = {};\n\n\t}\n\n\tgetIndex() {\n\n\t\treturn this.index;\n\n\t}\n\n\tsetIndex( index ) {\n\n\t\tif ( Array.isArray( index ) ) {\n\n\t\t\tthis.index = new ( arrayNeedsUint32( index ) ? Uint32BufferAttribute : Uint16BufferAttribute )( index, 1 );\n\n\t\t} else {\n\n\t\t\tthis.index = index;\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tgetAttribute( name ) {\n\n\t\treturn this.attributes[ name ];\n\n\t}\n\n\tsetAttribute( name, attribute ) {\n\n\t\tthis.attributes[ name ] = attribute;\n\n\t\treturn this;\n\n\t}\n\n\tdeleteAttribute( name ) {\n\n\t\tdelete this.attributes[ name ];\n\n\t\treturn this;\n\n\t}\n\n\thasAttribute( name ) {\n\n\t\treturn this.attributes[ name ] !== undefined;\n\n\t}\n\n\taddGroup( start, count, materialIndex = 0 ) {\n\n\t\tthis.groups.push( {\n\n\t\t\tstart: start,\n\t\t\tcount: count,\n\t\t\tmaterialIndex: materialIndex\n\n\t\t} );\n\n\t}\n\n\tclearGroups() {\n\n\t\tthis.groups = [];\n\n\t}\n\n\tsetDrawRange( start, count ) {\n\n\t\tthis.drawRange.start = start;\n\t\tthis.drawRange.count = count;\n\n\t}\n\n\tapplyMatrix4( matrix ) {\n\n\t\tconst position = this.attributes.position;\n\n\t\tif ( position !== undefined ) {\n\n\t\t\tposition.applyMatrix4( matrix );\n\n\t\t\tposition.needsUpdate = true;\n\n\t\t}\n\n\t\tconst normal = this.attributes.normal;\n\n\t\tif ( normal !== undefined ) {\n\n\t\t\tconst normalMatrix = new Matrix3().getNormalMatrix( matrix );\n\n\t\t\tnormal.applyNormalMatrix( normalMatrix );\n\n\t\t\tnormal.needsUpdate = true;\n\n\t\t}\n\n\t\tconst tangent = this.attributes.tangent;\n\n\t\tif ( tangent !== undefined ) {\n\n\t\t\ttangent.transformDirection( matrix );\n\n\t\t\ttangent.needsUpdate = true;\n\n\t\t}\n\n\t\tif ( this.boundingBox !== null ) {\n\n\t\t\tthis.computeBoundingBox();\n\n\t\t}\n\n\t\tif ( this.boundingSphere !== null ) {\n\n\t\t\tthis.computeBoundingSphere();\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tapplyQuaternion( q ) {\n\n\t\t_m1$2.makeRotationFromQuaternion( q );\n\n\t\tthis.applyMatrix4( _m1$2 );\n\n\t\treturn this;\n\n\t}\n\n\trotateX( angle ) {\n\n\t\t// rotate geometry around world x-axis\n\n\t\t_m1$2.makeRotationX( angle );\n\n\t\tthis.applyMatrix4( _m1$2 );\n\n\t\treturn this;\n\n\t}\n\n\trotateY( angle ) {\n\n\t\t// rotate geometry around world y-axis\n\n\t\t_m1$2.makeRotationY( angle );\n\n\t\tthis.applyMatrix4( _m1$2 );\n\n\t\treturn this;\n\n\t}\n\n\trotateZ( angle ) {\n\n\t\t// rotate geometry around world z-axis\n\n\t\t_m1$2.makeRotationZ( angle );\n\n\t\tthis.applyMatrix4( _m1$2 );\n\n\t\treturn this;\n\n\t}\n\n\ttranslate( x, y, z ) {\n\n\t\t// translate geometry\n\n\t\t_m1$2.makeTranslation( x, y, z );\n\n\t\tthis.applyMatrix4( _m1$2 );\n\n\t\treturn this;\n\n\t}\n\n\tscale( x, y, z ) {\n\n\t\t// scale geometry\n\n\t\t_m1$2.makeScale( x, y, z );\n\n\t\tthis.applyMatrix4( _m1$2 );\n\n\t\treturn this;\n\n\t}\n\n\tlookAt( vector ) {\n\n\t\t_obj.lookAt( vector );\n\n\t\t_obj.updateMatrix();\n\n\t\tthis.applyMatrix4( _obj.matrix );\n\n\t\treturn this;\n\n\t}\n\n\tcenter() {\n\n\t\tthis.computeBoundingBox();\n\n\t\tthis.boundingBox.getCenter( _offset ).negate();\n\n\t\tthis.translate( _offset.x, _offset.y, _offset.z );\n\n\t\treturn this;\n\n\t}\n\n\tsetFromPoints( points ) {\n\n\t\tconst position = [];\n\n\t\tfor ( let i = 0, l = points.length; i < l; i ++ ) {\n\n\t\t\tconst point = points[ i ];\n\t\t\tposition.push( point.x, point.y, point.z || 0 );\n\n\t\t}\n\n\t\tthis.setAttribute( 'position', new Float32BufferAttribute( position, 3 ) );\n\n\t\treturn this;\n\n\t}\n\n\tcomputeBoundingBox() {\n\n\t\tif ( this.boundingBox === null ) {\n\n\t\t\tthis.boundingBox = new Box3();\n\n\t\t}\n\n\t\tconst position = this.attributes.position;\n\t\tconst morphAttributesPosition = this.morphAttributes.position;\n\n\t\tif ( position && position.isGLBufferAttribute ) {\n\n\t\t\tconsole.error( 'THREE.BufferGeometry.computeBoundingBox(): GLBufferAttribute requires a manual bounding box.', this );\n\n\t\t\tthis.boundingBox.set(\n\t\t\t\tnew Vector3( - Infinity, - Infinity, - Infinity ),\n\t\t\t\tnew Vector3( + Infinity, + Infinity, + Infinity )\n\t\t\t);\n\n\t\t\treturn;\n\n\t\t}\n\n\t\tif ( position !== undefined ) {\n\n\t\t\tthis.boundingBox.setFromBufferAttribute( position );\n\n\t\t\t// process morph attributes if present\n\n\t\t\tif ( morphAttributesPosition ) {\n\n\t\t\t\tfor ( let i = 0, il = morphAttributesPosition.length; i < il; i ++ ) {\n\n\t\t\t\t\tconst morphAttribute = morphAttributesPosition[ i ];\n\t\t\t\t\t_box$2.setFromBufferAttribute( morphAttribute );\n\n\t\t\t\t\tif ( this.morphTargetsRelative ) {\n\n\t\t\t\t\t\t_vector$8.addVectors( this.boundingBox.min, _box$2.min );\n\t\t\t\t\t\tthis.boundingBox.expandByPoint( _vector$8 );\n\n\t\t\t\t\t\t_vector$8.addVectors( this.boundingBox.max, _box$2.max );\n\t\t\t\t\t\tthis.boundingBox.expandByPoint( _vector$8 );\n\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\tthis.boundingBox.expandByPoint( _box$2.min );\n\t\t\t\t\t\tthis.boundingBox.expandByPoint( _box$2.max );\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t} else {\n\n\t\t\tthis.boundingBox.makeEmpty();\n\n\t\t}\n\n\t\tif ( isNaN( this.boundingBox.min.x ) || isNaN( this.boundingBox.min.y ) || isNaN( this.boundingBox.min.z ) ) {\n\n\t\t\tconsole.error( 'THREE.BufferGeometry.computeBoundingBox(): Computed min/max have NaN values. The \"position\" attribute is likely to have NaN values.', this );\n\n\t\t}\n\n\t}\n\n\tcomputeBoundingSphere() {\n\n\t\tif ( this.boundingSphere === null ) {\n\n\t\t\tthis.boundingSphere = new Sphere();\n\n\t\t}\n\n\t\tconst position = this.attributes.position;\n\t\tconst morphAttributesPosition = this.morphAttributes.position;\n\n\t\tif ( position && position.isGLBufferAttribute ) {\n\n\t\t\tconsole.error( 'THREE.BufferGeometry.computeBoundingSphere(): GLBufferAttribute requires a manual bounding sphere.', this );\n\n\t\t\tthis.boundingSphere.set( new Vector3(), Infinity );\n\n\t\t\treturn;\n\n\t\t}\n\n\t\tif ( position ) {\n\n\t\t\t// first, find the center of the bounding sphere\n\n\t\t\tconst center = this.boundingSphere.center;\n\n\t\t\t_box$2.setFromBufferAttribute( position );\n\n\t\t\t// process morph attributes if present\n\n\t\t\tif ( morphAttributesPosition ) {\n\n\t\t\t\tfor ( let i = 0, il = morphAttributesPosition.length; i < il; i ++ ) {\n\n\t\t\t\t\tconst morphAttribute = morphAttributesPosition[ i ];\n\t\t\t\t\t_boxMorphTargets.setFromBufferAttribute( morphAttribute );\n\n\t\t\t\t\tif ( this.morphTargetsRelative ) {\n\n\t\t\t\t\t\t_vector$8.addVectors( _box$2.min, _boxMorphTargets.min );\n\t\t\t\t\t\t_box$2.expandByPoint( _vector$8 );\n\n\t\t\t\t\t\t_vector$8.addVectors( _box$2.max, _boxMorphTargets.max );\n\t\t\t\t\t\t_box$2.expandByPoint( _vector$8 );\n\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\t_box$2.expandByPoint( _boxMorphTargets.min );\n\t\t\t\t\t\t_box$2.expandByPoint( _boxMorphTargets.max );\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\t_box$2.getCenter( center );\n\n\t\t\t// second, try to find a boundingSphere with a radius smaller than the\n\t\t\t// boundingSphere of the boundingBox: sqrt(3) smaller in the best case\n\n\t\t\tlet maxRadiusSq = 0;\n\n\t\t\tfor ( let i = 0, il = position.count; i < il; i ++ ) {\n\n\t\t\t\t_vector$8.fromBufferAttribute( position, i );\n\n\t\t\t\tmaxRadiusSq = Math.max( maxRadiusSq, center.distanceToSquared( _vector$8 ) );\n\n\t\t\t}\n\n\t\t\t// process morph attributes if present\n\n\t\t\tif ( morphAttributesPosition ) {\n\n\t\t\t\tfor ( let i = 0, il = morphAttributesPosition.length; i < il; i ++ ) {\n\n\t\t\t\t\tconst morphAttribute = morphAttributesPosition[ i ];\n\t\t\t\t\tconst morphTargetsRelative = this.morphTargetsRelative;\n\n\t\t\t\t\tfor ( let j = 0, jl = morphAttribute.count; j < jl; j ++ ) {\n\n\t\t\t\t\t\t_vector$8.fromBufferAttribute( morphAttribute, j );\n\n\t\t\t\t\t\tif ( morphTargetsRelative ) {\n\n\t\t\t\t\t\t\t_offset.fromBufferAttribute( position, j );\n\t\t\t\t\t\t\t_vector$8.add( _offset );\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tmaxRadiusSq = Math.max( maxRadiusSq, center.distanceToSquared( _vector$8 ) );\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tthis.boundingSphere.radius = Math.sqrt( maxRadiusSq );\n\n\t\t\tif ( isNaN( this.boundingSphere.radius ) ) {\n\n\t\t\t\tconsole.error( 'THREE.BufferGeometry.computeBoundingSphere(): Computed radius is NaN. The \"position\" attribute is likely to have NaN values.', this );\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n\tcomputeTangents() {\n\n\t\tconst index = this.index;\n\t\tconst attributes = this.attributes;\n\n\t\t// based on http://www.terathon.com/code/tangent.html\n\t\t// (per vertex tangents)\n\n\t\tif ( index === null ||\n\t\t\t attributes.position === undefined ||\n\t\t\t attributes.normal === undefined ||\n\t\t\t attributes.uv === undefined ) {\n\n\t\t\tconsole.error( 'THREE.BufferGeometry: .computeTangents() failed. Missing required attributes (index, position, normal or uv)' );\n\t\t\treturn;\n\n\t\t}\n\n\t\tconst positionAttribute = attributes.position;\n\t\tconst normalAttribute = attributes.normal;\n\t\tconst uvAttribute = attributes.uv;\n\n\t\tif ( this.hasAttribute( 'tangent' ) === false ) {\n\n\t\t\tthis.setAttribute( 'tangent', new BufferAttribute( new Float32Array( 4 * positionAttribute.count ), 4 ) );\n\n\t\t}\n\n\t\tconst tangentAttribute = this.getAttribute( 'tangent' );\n\n\t\tconst tan1 = [], tan2 = [];\n\n\t\tfor ( let i = 0; i < positionAttribute.count; i ++ ) {\n\n\t\t\ttan1[ i ] = new Vector3();\n\t\t\ttan2[ i ] = new Vector3();\n\n\t\t}\n\n\t\tconst vA = new Vector3(),\n\t\t\tvB = new Vector3(),\n\t\t\tvC = new Vector3(),\n\n\t\t\tuvA = new Vector2(),\n\t\t\tuvB = new Vector2(),\n\t\t\tuvC = new Vector2(),\n\n\t\t\tsdir = new Vector3(),\n\t\t\ttdir = new Vector3();\n\n\t\tfunction handleTriangle( a, b, c ) {\n\n\t\t\tvA.fromBufferAttribute( positionAttribute, a );\n\t\t\tvB.fromBufferAttribute( positionAttribute, b );\n\t\t\tvC.fromBufferAttribute( positionAttribute, c );\n\n\t\t\tuvA.fromBufferAttribute( uvAttribute, a );\n\t\t\tuvB.fromBufferAttribute( uvAttribute, b );\n\t\t\tuvC.fromBufferAttribute( uvAttribute, c );\n\n\t\t\tvB.sub( vA );\n\t\t\tvC.sub( vA );\n\n\t\t\tuvB.sub( uvA );\n\t\t\tuvC.sub( uvA );\n\n\t\t\tconst r = 1.0 / ( uvB.x * uvC.y - uvC.x * uvB.y );\n\n\t\t\t// silently ignore degenerate uv triangles having coincident or colinear vertices\n\n\t\t\tif ( ! isFinite( r ) ) return;\n\n\t\t\tsdir.copy( vB ).multiplyScalar( uvC.y ).addScaledVector( vC, - uvB.y ).multiplyScalar( r );\n\t\t\ttdir.copy( vC ).multiplyScalar( uvB.x ).addScaledVector( vB, - uvC.x ).multiplyScalar( r );\n\n\t\t\ttan1[ a ].add( sdir );\n\t\t\ttan1[ b ].add( sdir );\n\t\t\ttan1[ c ].add( sdir );\n\n\t\t\ttan2[ a ].add( tdir );\n\t\t\ttan2[ b ].add( tdir );\n\t\t\ttan2[ c ].add( tdir );\n\n\t\t}\n\n\t\tlet groups = this.groups;\n\n\t\tif ( groups.length === 0 ) {\n\n\t\t\tgroups = [ {\n\t\t\t\tstart: 0,\n\t\t\t\tcount: index.count\n\t\t\t} ];\n\n\t\t}\n\n\t\tfor ( let i = 0, il = groups.length; i < il; ++ i ) {\n\n\t\t\tconst group = groups[ i ];\n\n\t\t\tconst start = group.start;\n\t\t\tconst count = group.count;\n\n\t\t\tfor ( let j = start, jl = start + count; j < jl; j += 3 ) {\n\n\t\t\t\thandleTriangle(\n\t\t\t\t\tindex.getX( j + 0 ),\n\t\t\t\t\tindex.getX( j + 1 ),\n\t\t\t\t\tindex.getX( j + 2 )\n\t\t\t\t);\n\n\t\t\t}\n\n\t\t}\n\n\t\tconst tmp = new Vector3(), tmp2 = new Vector3();\n\t\tconst n = new Vector3(), n2 = new Vector3();\n\n\t\tfunction handleVertex( v ) {\n\n\t\t\tn.fromBufferAttribute( normalAttribute, v );\n\t\t\tn2.copy( n );\n\n\t\t\tconst t = tan1[ v ];\n\n\t\t\t// Gram-Schmidt orthogonalize\n\n\t\t\ttmp.copy( t );\n\t\t\ttmp.sub( n.multiplyScalar( n.dot( t ) ) ).normalize();\n\n\t\t\t// Calculate handedness\n\n\t\t\ttmp2.crossVectors( n2, t );\n\t\t\tconst test = tmp2.dot( tan2[ v ] );\n\t\t\tconst w = ( test < 0.0 ) ? - 1.0 : 1.0;\n\n\t\t\ttangentAttribute.setXYZW( v, tmp.x, tmp.y, tmp.z, w );\n\n\t\t}\n\n\t\tfor ( let i = 0, il = groups.length; i < il; ++ i ) {\n\n\t\t\tconst group = groups[ i ];\n\n\t\t\tconst start = group.start;\n\t\t\tconst count = group.count;\n\n\t\t\tfor ( let j = start, jl = start + count; j < jl; j += 3 ) {\n\n\t\t\t\thandleVertex( index.getX( j + 0 ) );\n\t\t\t\thandleVertex( index.getX( j + 1 ) );\n\t\t\t\thandleVertex( index.getX( j + 2 ) );\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n\tcomputeVertexNormals() {\n\n\t\tconst index = this.index;\n\t\tconst positionAttribute = this.getAttribute( 'position' );\n\n\t\tif ( positionAttribute !== undefined ) {\n\n\t\t\tlet normalAttribute = this.getAttribute( 'normal' );\n\n\t\t\tif ( normalAttribute === undefined ) {\n\n\t\t\t\tnormalAttribute = new BufferAttribute( new Float32Array( positionAttribute.count * 3 ), 3 );\n\t\t\t\tthis.setAttribute( 'normal', normalAttribute );\n\n\t\t\t} else {\n\n\t\t\t\t// reset existing normals to zero\n\n\t\t\t\tfor ( let i = 0, il = normalAttribute.count; i < il; i ++ ) {\n\n\t\t\t\t\tnormalAttribute.setXYZ( i, 0, 0, 0 );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tconst pA = new Vector3(), pB = new Vector3(), pC = new Vector3();\n\t\t\tconst nA = new Vector3(), nB = new Vector3(), nC = new Vector3();\n\t\t\tconst cb = new Vector3(), ab = new Vector3();\n\n\t\t\t// indexed elements\n\n\t\t\tif ( index ) {\n\n\t\t\t\tfor ( let i = 0, il = index.count; i < il; i += 3 ) {\n\n\t\t\t\t\tconst vA = index.getX( i + 0 );\n\t\t\t\t\tconst vB = index.getX( i + 1 );\n\t\t\t\t\tconst vC = index.getX( i + 2 );\n\n\t\t\t\t\tpA.fromBufferAttribute( positionAttribute, vA );\n\t\t\t\t\tpB.fromBufferAttribute( positionAttribute, vB );\n\t\t\t\t\tpC.fromBufferAttribute( positionAttribute, vC );\n\n\t\t\t\t\tcb.subVectors( pC, pB );\n\t\t\t\t\tab.subVectors( pA, pB );\n\t\t\t\t\tcb.cross( ab );\n\n\t\t\t\t\tnA.fromBufferAttribute( normalAttribute, vA );\n\t\t\t\t\tnB.fromBufferAttribute( normalAttribute, vB );\n\t\t\t\t\tnC.fromBufferAttribute( normalAttribute, vC );\n\n\t\t\t\t\tnA.add( cb );\n\t\t\t\t\tnB.add( cb );\n\t\t\t\t\tnC.add( cb );\n\n\t\t\t\t\tnormalAttribute.setXYZ( vA, nA.x, nA.y, nA.z );\n\t\t\t\t\tnormalAttribute.setXYZ( vB, nB.x, nB.y, nB.z );\n\t\t\t\t\tnormalAttribute.setXYZ( vC, nC.x, nC.y, nC.z );\n\n\t\t\t\t}\n\n\t\t\t} else {\n\n\t\t\t\t// non-indexed elements (unconnected triangle soup)\n\n\t\t\t\tfor ( let i = 0, il = positionAttribute.count; i < il; i += 3 ) {\n\n\t\t\t\t\tpA.fromBufferAttribute( positionAttribute, i + 0 );\n\t\t\t\t\tpB.fromBufferAttribute( positionAttribute, i + 1 );\n\t\t\t\t\tpC.fromBufferAttribute( positionAttribute, i + 2 );\n\n\t\t\t\t\tcb.subVectors( pC, pB );\n\t\t\t\t\tab.subVectors( pA, pB );\n\t\t\t\t\tcb.cross( ab );\n\n\t\t\t\t\tnormalAttribute.setXYZ( i + 0, cb.x, cb.y, cb.z );\n\t\t\t\t\tnormalAttribute.setXYZ( i + 1, cb.x, cb.y, cb.z );\n\t\t\t\t\tnormalAttribute.setXYZ( i + 2, cb.x, cb.y, cb.z );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tthis.normalizeNormals();\n\n\t\t\tnormalAttribute.needsUpdate = true;\n\n\t\t}\n\n\t}\n\n\tnormalizeNormals() {\n\n\t\tconst normals = this.attributes.normal;\n\n\t\tfor ( let i = 0, il = normals.count; i < il; i ++ ) {\n\n\t\t\t_vector$8.fromBufferAttribute( normals, i );\n\n\t\t\t_vector$8.normalize();\n\n\t\t\tnormals.setXYZ( i, _vector$8.x, _vector$8.y, _vector$8.z );\n\n\t\t}\n\n\t}\n\n\ttoNonIndexed() {\n\n\t\tfunction convertBufferAttribute( attribute, indices ) {\n\n\t\t\tconst array = attribute.array;\n\t\t\tconst itemSize = attribute.itemSize;\n\t\t\tconst normalized = attribute.normalized;\n\n\t\t\tconst array2 = new array.constructor( indices.length * itemSize );\n\n\t\t\tlet index = 0, index2 = 0;\n\n\t\t\tfor ( let i = 0, l = indices.length; i < l; i ++ ) {\n\n\t\t\t\tif ( attribute.isInterleavedBufferAttribute ) {\n\n\t\t\t\t\tindex = indices[ i ] * attribute.data.stride + attribute.offset;\n\n\t\t\t\t} else {\n\n\t\t\t\t\tindex = indices[ i ] * itemSize;\n\n\t\t\t\t}\n\n\t\t\t\tfor ( let j = 0; j < itemSize; j ++ ) {\n\n\t\t\t\t\tarray2[ index2 ++ ] = array[ index ++ ];\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\treturn new BufferAttribute( array2, itemSize, normalized );\n\n\t\t}\n\n\t\t//\n\n\t\tif ( this.index === null ) {\n\n\t\t\tconsole.warn( 'THREE.BufferGeometry.toNonIndexed(): BufferGeometry is already non-indexed.' );\n\t\t\treturn this;\n\n\t\t}\n\n\t\tconst geometry2 = new BufferGeometry();\n\n\t\tconst indices = this.index.array;\n\t\tconst attributes = this.attributes;\n\n\t\t// attributes\n\n\t\tfor ( const name in attributes ) {\n\n\t\t\tconst attribute = attributes[ name ];\n\n\t\t\tconst newAttribute = convertBufferAttribute( attribute, indices );\n\n\t\t\tgeometry2.setAttribute( name, newAttribute );\n\n\t\t}\n\n\t\t// morph attributes\n\n\t\tconst morphAttributes = this.morphAttributes;\n\n\t\tfor ( const name in morphAttributes ) {\n\n\t\t\tconst morphArray = [];\n\t\t\tconst morphAttribute = morphAttributes[ name ]; // morphAttribute: array of Float32BufferAttributes\n\n\t\t\tfor ( let i = 0, il = morphAttribute.length; i < il; i ++ ) {\n\n\t\t\t\tconst attribute = morphAttribute[ i ];\n\n\t\t\t\tconst newAttribute = convertBufferAttribute( attribute, indices );\n\n\t\t\t\tmorphArray.push( newAttribute );\n\n\t\t\t}\n\n\t\t\tgeometry2.morphAttributes[ name ] = morphArray;\n\n\t\t}\n\n\t\tgeometry2.morphTargetsRelative = this.morphTargetsRelative;\n\n\t\t// groups\n\n\t\tconst groups = this.groups;\n\n\t\tfor ( let i = 0, l = groups.length; i < l; i ++ ) {\n\n\t\t\tconst group = groups[ i ];\n\t\t\tgeometry2.addGroup( group.start, group.count, group.materialIndex );\n\n\t\t}\n\n\t\treturn geometry2;\n\n\t}\n\n\ttoJSON() {\n\n\t\tconst data = {\n\t\t\tmetadata: {\n\t\t\t\tversion: 4.6,\n\t\t\t\ttype: 'BufferGeometry',\n\t\t\t\tgenerator: 'BufferGeometry.toJSON'\n\t\t\t}\n\t\t};\n\n\t\t// standard BufferGeometry serialization\n\n\t\tdata.uuid = this.uuid;\n\t\tdata.type = this.type;\n\t\tif ( this.name !== '' ) data.name = this.name;\n\t\tif ( Object.keys( this.userData ).length > 0 ) data.userData = this.userData;\n\n\t\tif ( this.parameters !== undefined ) {\n\n\t\t\tconst parameters = this.parameters;\n\n\t\t\tfor ( const key in parameters ) {\n\n\t\t\t\tif ( parameters[ key ] !== undefined ) data[ key ] = parameters[ key ];\n\n\t\t\t}\n\n\t\t\treturn data;\n\n\t\t}\n\n\t\t// for simplicity the code assumes attributes are not shared across geometries, see #15811\n\n\t\tdata.data = { attributes: {} };\n\n\t\tconst index = this.index;\n\n\t\tif ( index !== null ) {\n\n\t\t\tdata.data.index = {\n\t\t\t\ttype: index.array.constructor.name,\n\t\t\t\tarray: Array.prototype.slice.call( index.array )\n\t\t\t};\n\n\t\t}\n\n\t\tconst attributes = this.attributes;\n\n\t\tfor ( const key in attributes ) {\n\n\t\t\tconst attribute = attributes[ key ];\n\n\t\t\tdata.data.attributes[ key ] = attribute.toJSON( data.data );\n\n\t\t}\n\n\t\tconst morphAttributes = {};\n\t\tlet hasMorphAttributes = false;\n\n\t\tfor ( const key in this.morphAttributes ) {\n\n\t\t\tconst attributeArray = this.morphAttributes[ key ];\n\n\t\t\tconst array = [];\n\n\t\t\tfor ( let i = 0, il = attributeArray.length; i < il; i ++ ) {\n\n\t\t\t\tconst attribute = attributeArray[ i ];\n\n\t\t\t\tarray.push( attribute.toJSON( data.data ) );\n\n\t\t\t}\n\n\t\t\tif ( array.length > 0 ) {\n\n\t\t\t\tmorphAttributes[ key ] = array;\n\n\t\t\t\thasMorphAttributes = true;\n\n\t\t\t}\n\n\t\t}\n\n\t\tif ( hasMorphAttributes ) {\n\n\t\t\tdata.data.morphAttributes = morphAttributes;\n\t\t\tdata.data.morphTargetsRelative = this.morphTargetsRelative;\n\n\t\t}\n\n\t\tconst groups = this.groups;\n\n\t\tif ( groups.length > 0 ) {\n\n\t\t\tdata.data.groups = JSON.parse( JSON.stringify( groups ) );\n\n\t\t}\n\n\t\tconst boundingSphere = this.boundingSphere;\n\n\t\tif ( boundingSphere !== null ) {\n\n\t\t\tdata.data.boundingSphere = {\n\t\t\t\tcenter: boundingSphere.center.toArray(),\n\t\t\t\tradius: boundingSphere.radius\n\t\t\t};\n\n\t\t}\n\n\t\treturn data;\n\n\t}\n\n\tclone() {\n\n\t\treturn new this.constructor().copy( this );\n\n\t}\n\n\tcopy( source ) {\n\n\t\t// reset\n\n\t\tthis.index = null;\n\t\tthis.attributes = {};\n\t\tthis.morphAttributes = {};\n\t\tthis.groups = [];\n\t\tthis.boundingBox = null;\n\t\tthis.boundingSphere = null;\n\n\t\t// used for storing cloned, shared data\n\n\t\tconst data = {};\n\n\t\t// name\n\n\t\tthis.name = source.name;\n\n\t\t// index\n\n\t\tconst index = source.index;\n\n\t\tif ( index !== null ) {\n\n\t\t\tthis.setIndex( index.clone( data ) );\n\n\t\t}\n\n\t\t// attributes\n\n\t\tconst attributes = source.attributes;\n\n\t\tfor ( const name in attributes ) {\n\n\t\t\tconst attribute = attributes[ name ];\n\t\t\tthis.setAttribute( name, attribute.clone( data ) );\n\n\t\t}\n\n\t\t// morph attributes\n\n\t\tconst morphAttributes = source.morphAttributes;\n\n\t\tfor ( const name in morphAttributes ) {\n\n\t\t\tconst array = [];\n\t\t\tconst morphAttribute = morphAttributes[ name ]; // morphAttribute: array of Float32BufferAttributes\n\n\t\t\tfor ( let i = 0, l = morphAttribute.length; i < l; i ++ ) {\n\n\t\t\t\tarray.push( morphAttribute[ i ].clone( data ) );\n\n\t\t\t}\n\n\t\t\tthis.morphAttributes[ name ] = array;\n\n\t\t}\n\n\t\tthis.morphTargetsRelative = source.morphTargetsRelative;\n\n\t\t// groups\n\n\t\tconst groups = source.groups;\n\n\t\tfor ( let i = 0, l = groups.length; i < l; i ++ ) {\n\n\t\t\tconst group = groups[ i ];\n\t\t\tthis.addGroup( group.start, group.count, group.materialIndex );\n\n\t\t}\n\n\t\t// bounding box\n\n\t\tconst boundingBox = source.boundingBox;\n\n\t\tif ( boundingBox !== null ) {\n\n\t\t\tthis.boundingBox = boundingBox.clone();\n\n\t\t}\n\n\t\t// bounding sphere\n\n\t\tconst boundingSphere = source.boundingSphere;\n\n\t\tif ( boundingSphere !== null ) {\n\n\t\t\tthis.boundingSphere = boundingSphere.clone();\n\n\t\t}\n\n\t\t// draw range\n\n\t\tthis.drawRange.start = source.drawRange.start;\n\t\tthis.drawRange.count = source.drawRange.count;\n\n\t\t// user data\n\n\t\tthis.userData = source.userData;\n\n\t\treturn this;\n\n\t}\n\n\tdispose() {\n\n\t\tthis.dispatchEvent( { type: 'dispose' } );\n\n\t}\n\n}\n\nconst _inverseMatrix$3 = /*@__PURE__*/ new Matrix4();\nconst _ray$3 = /*@__PURE__*/ new Ray();\nconst _sphere$6 = /*@__PURE__*/ new Sphere();\nconst _sphereHitAt = /*@__PURE__*/ new Vector3();\n\nconst _vA$1 = /*@__PURE__*/ new Vector3();\nconst _vB$1 = /*@__PURE__*/ new Vector3();\nconst _vC$1 = /*@__PURE__*/ new Vector3();\n\nconst _tempA = /*@__PURE__*/ new Vector3();\nconst _morphA = /*@__PURE__*/ new Vector3();\n\nconst _uvA$1 = /*@__PURE__*/ new Vector2();\nconst _uvB$1 = /*@__PURE__*/ new Vector2();\nconst _uvC$1 = /*@__PURE__*/ new Vector2();\n\nconst _normalA = /*@__PURE__*/ new Vector3();\nconst _normalB = /*@__PURE__*/ new Vector3();\nconst _normalC = /*@__PURE__*/ new Vector3();\n\nconst _intersectionPoint = /*@__PURE__*/ new Vector3();\nconst _intersectionPointWorld = /*@__PURE__*/ new Vector3();\n\nclass Mesh extends Object3D {\n\n\tconstructor( geometry = new BufferGeometry(), material = new MeshBasicMaterial() ) {\n\n\t\tsuper();\n\n\t\tthis.isMesh = true;\n\n\t\tthis.type = 'Mesh';\n\n\t\tthis.geometry = geometry;\n\t\tthis.material = material;\n\n\t\tthis.updateMorphTargets();\n\n\t}\n\n\tcopy( source, recursive ) {\n\n\t\tsuper.copy( source, recursive );\n\n\t\tif ( source.morphTargetInfluences !== undefined ) {\n\n\t\t\tthis.morphTargetInfluences = source.morphTargetInfluences.slice();\n\n\t\t}\n\n\t\tif ( source.morphTargetDictionary !== undefined ) {\n\n\t\t\tthis.morphTargetDictionary = Object.assign( {}, source.morphTargetDictionary );\n\n\t\t}\n\n\t\tthis.material = Array.isArray( source.material ) ? source.material.slice() : source.material;\n\t\tthis.geometry = source.geometry;\n\n\t\treturn this;\n\n\t}\n\n\tupdateMorphTargets() {\n\n\t\tconst geometry = this.geometry;\n\n\t\tconst morphAttributes = geometry.morphAttributes;\n\t\tconst keys = Object.keys( morphAttributes );\n\n\t\tif ( keys.length > 0 ) {\n\n\t\t\tconst morphAttribute = morphAttributes[ keys[ 0 ] ];\n\n\t\t\tif ( morphAttribute !== undefined ) {\n\n\t\t\t\tthis.morphTargetInfluences = [];\n\t\t\t\tthis.morphTargetDictionary = {};\n\n\t\t\t\tfor ( let m = 0, ml = morphAttribute.length; m < ml; m ++ ) {\n\n\t\t\t\t\tconst name = morphAttribute[ m ].name || String( m );\n\n\t\t\t\t\tthis.morphTargetInfluences.push( 0 );\n\t\t\t\t\tthis.morphTargetDictionary[ name ] = m;\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n\tgetVertexPosition( index, target ) {\n\n\t\tconst geometry = this.geometry;\n\t\tconst position = geometry.attributes.position;\n\t\tconst morphPosition = geometry.morphAttributes.position;\n\t\tconst morphTargetsRelative = geometry.morphTargetsRelative;\n\n\t\ttarget.fromBufferAttribute( position, index );\n\n\t\tconst morphInfluences = this.morphTargetInfluences;\n\n\t\tif ( morphPosition && morphInfluences ) {\n\n\t\t\t_morphA.set( 0, 0, 0 );\n\n\t\t\tfor ( let i = 0, il = morphPosition.length; i < il; i ++ ) {\n\n\t\t\t\tconst influence = morphInfluences[ i ];\n\t\t\t\tconst morphAttribute = morphPosition[ i ];\n\n\t\t\t\tif ( influence === 0 ) continue;\n\n\t\t\t\t_tempA.fromBufferAttribute( morphAttribute, index );\n\n\t\t\t\tif ( morphTargetsRelative ) {\n\n\t\t\t\t\t_morphA.addScaledVector( _tempA, influence );\n\n\t\t\t\t} else {\n\n\t\t\t\t\t_morphA.addScaledVector( _tempA.sub( target ), influence );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\ttarget.add( _morphA );\n\n\t\t}\n\n\t\treturn target;\n\n\t}\n\n\traycast( raycaster, intersects ) {\n\n\t\tconst geometry = this.geometry;\n\t\tconst material = this.material;\n\t\tconst matrixWorld = this.matrixWorld;\n\n\t\tif ( material === undefined ) return;\n\n\t\t// test with bounding sphere in world space\n\n\t\tif ( geometry.boundingSphere === null ) geometry.computeBoundingSphere();\n\n\t\t_sphere$6.copy( geometry.boundingSphere );\n\t\t_sphere$6.applyMatrix4( matrixWorld );\n\n\t\t// check distance from ray origin to bounding sphere\n\n\t\t_ray$3.copy( raycaster.ray ).recast( raycaster.near );\n\n\t\tif ( _sphere$6.containsPoint( _ray$3.origin ) === false ) {\n\n\t\t\tif ( _ray$3.intersectSphere( _sphere$6, _sphereHitAt ) === null ) return;\n\n\t\t\tif ( _ray$3.origin.distanceToSquared( _sphereHitAt ) > ( raycaster.far - raycaster.near ) ** 2 ) return;\n\n\t\t}\n\n\t\t// convert ray to local space of mesh\n\n\t\t_inverseMatrix$3.copy( matrixWorld ).invert();\n\t\t_ray$3.copy( raycaster.ray ).applyMatrix4( _inverseMatrix$3 );\n\n\t\t// test with bounding box in local space\n\n\t\tif ( geometry.boundingBox !== null ) {\n\n\t\t\tif ( _ray$3.intersectsBox( geometry.boundingBox ) === false ) return;\n\n\t\t}\n\n\t\t// test for intersections with geometry\n\n\t\tthis._computeIntersections( raycaster, intersects, _ray$3 );\n\n\t}\n\n\t_computeIntersections( raycaster, intersects, rayLocalSpace ) {\n\n\t\tlet intersection;\n\n\t\tconst geometry = this.geometry;\n\t\tconst material = this.material;\n\n\t\tconst index = geometry.index;\n\t\tconst position = geometry.attributes.position;\n\t\tconst uv = geometry.attributes.uv;\n\t\tconst uv1 = geometry.attributes.uv1;\n\t\tconst normal = geometry.attributes.normal;\n\t\tconst groups = geometry.groups;\n\t\tconst drawRange = geometry.drawRange;\n\n\t\tif ( index !== null ) {\n\n\t\t\t// indexed buffer geometry\n\n\t\t\tif ( Array.isArray( material ) ) {\n\n\t\t\t\tfor ( let i = 0, il = groups.length; i < il; i ++ ) {\n\n\t\t\t\t\tconst group = groups[ i ];\n\t\t\t\t\tconst groupMaterial = material[ group.materialIndex ];\n\n\t\t\t\t\tconst start = Math.max( group.start, drawRange.start );\n\t\t\t\t\tconst end = Math.min( index.count, Math.min( ( group.start + group.count ), ( drawRange.start + drawRange.count ) ) );\n\n\t\t\t\t\tfor ( let j = start, jl = end; j < jl; j += 3 ) {\n\n\t\t\t\t\t\tconst a = index.getX( j );\n\t\t\t\t\t\tconst b = index.getX( j + 1 );\n\t\t\t\t\t\tconst c = index.getX( j + 2 );\n\n\t\t\t\t\t\tintersection = checkGeometryIntersection( this, groupMaterial, raycaster, rayLocalSpace, uv, uv1, normal, a, b, c );\n\n\t\t\t\t\t\tif ( intersection ) {\n\n\t\t\t\t\t\t\tintersection.faceIndex = Math.floor( j / 3 ); // triangle number in indexed buffer semantics\n\t\t\t\t\t\t\tintersection.face.materialIndex = group.materialIndex;\n\t\t\t\t\t\t\tintersects.push( intersection );\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t} else {\n\n\t\t\t\tconst start = Math.max( 0, drawRange.start );\n\t\t\t\tconst end = Math.min( index.count, ( drawRange.start + drawRange.count ) );\n\n\t\t\t\tfor ( let i = start, il = end; i < il; i += 3 ) {\n\n\t\t\t\t\tconst a = index.getX( i );\n\t\t\t\t\tconst b = index.getX( i + 1 );\n\t\t\t\t\tconst c = index.getX( i + 2 );\n\n\t\t\t\t\tintersection = checkGeometryIntersection( this, material, raycaster, rayLocalSpace, uv, uv1, normal, a, b, c );\n\n\t\t\t\t\tif ( intersection ) {\n\n\t\t\t\t\t\tintersection.faceIndex = Math.floor( i / 3 ); // triangle number in indexed buffer semantics\n\t\t\t\t\t\tintersects.push( intersection );\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t} else if ( position !== undefined ) {\n\n\t\t\t// non-indexed buffer geometry\n\n\t\t\tif ( Array.isArray( material ) ) {\n\n\t\t\t\tfor ( let i = 0, il = groups.length; i < il; i ++ ) {\n\n\t\t\t\t\tconst group = groups[ i ];\n\t\t\t\t\tconst groupMaterial = material[ group.materialIndex ];\n\n\t\t\t\t\tconst start = Math.max( group.start, drawRange.start );\n\t\t\t\t\tconst end = Math.min( position.count, Math.min( ( group.start + group.count ), ( drawRange.start + drawRange.count ) ) );\n\n\t\t\t\t\tfor ( let j = start, jl = end; j < jl; j += 3 ) {\n\n\t\t\t\t\t\tconst a = j;\n\t\t\t\t\t\tconst b = j + 1;\n\t\t\t\t\t\tconst c = j + 2;\n\n\t\t\t\t\t\tintersection = checkGeometryIntersection( this, groupMaterial, raycaster, rayLocalSpace, uv, uv1, normal, a, b, c );\n\n\t\t\t\t\t\tif ( intersection ) {\n\n\t\t\t\t\t\t\tintersection.faceIndex = Math.floor( j / 3 ); // triangle number in non-indexed buffer semantics\n\t\t\t\t\t\t\tintersection.face.materialIndex = group.materialIndex;\n\t\t\t\t\t\t\tintersects.push( intersection );\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t} else {\n\n\t\t\t\tconst start = Math.max( 0, drawRange.start );\n\t\t\t\tconst end = Math.min( position.count, ( drawRange.start + drawRange.count ) );\n\n\t\t\t\tfor ( let i = start, il = end; i < il; i += 3 ) {\n\n\t\t\t\t\tconst a = i;\n\t\t\t\t\tconst b = i + 1;\n\t\t\t\t\tconst c = i + 2;\n\n\t\t\t\t\tintersection = checkGeometryIntersection( this, material, raycaster, rayLocalSpace, uv, uv1, normal, a, b, c );\n\n\t\t\t\t\tif ( intersection ) {\n\n\t\t\t\t\t\tintersection.faceIndex = Math.floor( i / 3 ); // triangle number in non-indexed buffer semantics\n\t\t\t\t\t\tintersects.push( intersection );\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n}\n\nfunction checkIntersection( object, material, raycaster, ray, pA, pB, pC, point ) {\n\n\tlet intersect;\n\n\tif ( material.side === BackSide ) {\n\n\t\tintersect = ray.intersectTriangle( pC, pB, pA, true, point );\n\n\t} else {\n\n\t\tintersect = ray.intersectTriangle( pA, pB, pC, ( material.side === FrontSide ), point );\n\n\t}\n\n\tif ( intersect === null ) return null;\n\n\t_intersectionPointWorld.copy( point );\n\t_intersectionPointWorld.applyMatrix4( object.matrixWorld );\n\n\tconst distance = raycaster.ray.origin.distanceTo( _intersectionPointWorld );\n\n\tif ( distance < raycaster.near || distance > raycaster.far ) return null;\n\n\treturn {\n\t\tdistance: distance,\n\t\tpoint: _intersectionPointWorld.clone(),\n\t\tobject: object\n\t};\n\n}\n\nfunction checkGeometryIntersection( object, material, raycaster, ray, uv, uv1, normal, a, b, c ) {\n\n\tobject.getVertexPosition( a, _vA$1 );\n\tobject.getVertexPosition( b, _vB$1 );\n\tobject.getVertexPosition( c, _vC$1 );\n\n\tconst intersection = checkIntersection( object, material, raycaster, ray, _vA$1, _vB$1, _vC$1, _intersectionPoint );\n\n\tif ( intersection ) {\n\n\t\tif ( uv ) {\n\n\t\t\t_uvA$1.fromBufferAttribute( uv, a );\n\t\t\t_uvB$1.fromBufferAttribute( uv, b );\n\t\t\t_uvC$1.fromBufferAttribute( uv, c );\n\n\t\t\tintersection.uv = Triangle.getInterpolation( _intersectionPoint, _vA$1, _vB$1, _vC$1, _uvA$1, _uvB$1, _uvC$1, new Vector2() );\n\n\t\t}\n\n\t\tif ( uv1 ) {\n\n\t\t\t_uvA$1.fromBufferAttribute( uv1, a );\n\t\t\t_uvB$1.fromBufferAttribute( uv1, b );\n\t\t\t_uvC$1.fromBufferAttribute( uv1, c );\n\n\t\t\tintersection.uv1 = Triangle.getInterpolation( _intersectionPoint, _vA$1, _vB$1, _vC$1, _uvA$1, _uvB$1, _uvC$1, new Vector2() );\n\n\t\t}\n\n\t\tif ( normal ) {\n\n\t\t\t_normalA.fromBufferAttribute( normal, a );\n\t\t\t_normalB.fromBufferAttribute( normal, b );\n\t\t\t_normalC.fromBufferAttribute( normal, c );\n\n\t\t\tintersection.normal = Triangle.getInterpolation( _intersectionPoint, _vA$1, _vB$1, _vC$1, _normalA, _normalB, _normalC, new Vector3() );\n\n\t\t\tif ( intersection.normal.dot( ray.direction ) > 0 ) {\n\n\t\t\t\tintersection.normal.multiplyScalar( - 1 );\n\n\t\t\t}\n\n\t\t}\n\n\t\tconst face = {\n\t\t\ta: a,\n\t\t\tb: b,\n\t\t\tc: c,\n\t\t\tnormal: new Vector3(),\n\t\t\tmaterialIndex: 0\n\t\t};\n\n\t\tTriangle.getNormal( _vA$1, _vB$1, _vC$1, face.normal );\n\n\t\tintersection.face = face;\n\n\t}\n\n\treturn intersection;\n\n}\n\nclass BoxGeometry extends BufferGeometry {\n\n\tconstructor( width = 1, height = 1, depth = 1, widthSegments = 1, heightSegments = 1, depthSegments = 1 ) {\n\n\t\tsuper();\n\n\t\tthis.type = 'BoxGeometry';\n\n\t\tthis.parameters = {\n\t\t\twidth: width,\n\t\t\theight: height,\n\t\t\tdepth: depth,\n\t\t\twidthSegments: widthSegments,\n\t\t\theightSegments: heightSegments,\n\t\t\tdepthSegments: depthSegments\n\t\t};\n\n\t\tconst scope = this;\n\n\t\t// segments\n\n\t\twidthSegments = Math.floor( widthSegments );\n\t\theightSegments = Math.floor( heightSegments );\n\t\tdepthSegments = Math.floor( depthSegments );\n\n\t\t// buffers\n\n\t\tconst indices = [];\n\t\tconst vertices = [];\n\t\tconst normals = [];\n\t\tconst uvs = [];\n\n\t\t// helper variables\n\n\t\tlet numberOfVertices = 0;\n\t\tlet groupStart = 0;\n\n\t\t// build each side of the box geometry\n\n\t\tbuildPlane( 'z', 'y', 'x', - 1, - 1, depth, height, width, depthSegments, heightSegments, 0 ); // px\n\t\tbuildPlane( 'z', 'y', 'x', 1, - 1, depth, height, - width, depthSegments, heightSegments, 1 ); // nx\n\t\tbuildPlane( 'x', 'z', 'y', 1, 1, width, depth, height, widthSegments, depthSegments, 2 ); // py\n\t\tbuildPlane( 'x', 'z', 'y', 1, - 1, width, depth, - height, widthSegments, depthSegments, 3 ); // ny\n\t\tbuildPlane( 'x', 'y', 'z', 1, - 1, width, height, depth, widthSegments, heightSegments, 4 ); // pz\n\t\tbuildPlane( 'x', 'y', 'z', - 1, - 1, width, height, - depth, widthSegments, heightSegments, 5 ); // nz\n\n\t\t// build geometry\n\n\t\tthis.setIndex( indices );\n\t\tthis.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\n\t\tthis.setAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );\n\t\tthis.setAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );\n\n\t\tfunction buildPlane( u, v, w, udir, vdir, width, height, depth, gridX, gridY, materialIndex ) {\n\n\t\t\tconst segmentWidth = width / gridX;\n\t\t\tconst segmentHeight = height / gridY;\n\n\t\t\tconst widthHalf = width / 2;\n\t\t\tconst heightHalf = height / 2;\n\t\t\tconst depthHalf = depth / 2;\n\n\t\t\tconst gridX1 = gridX + 1;\n\t\t\tconst gridY1 = gridY + 1;\n\n\t\t\tlet vertexCounter = 0;\n\t\t\tlet groupCount = 0;\n\n\t\t\tconst vector = new Vector3();\n\n\t\t\t// generate vertices, normals and uvs\n\n\t\t\tfor ( let iy = 0; iy < gridY1; iy ++ ) {\n\n\t\t\t\tconst y = iy * segmentHeight - heightHalf;\n\n\t\t\t\tfor ( let ix = 0; ix < gridX1; ix ++ ) {\n\n\t\t\t\t\tconst x = ix * segmentWidth - widthHalf;\n\n\t\t\t\t\t// set values to correct vector component\n\n\t\t\t\t\tvector[ u ] = x * udir;\n\t\t\t\t\tvector[ v ] = y * vdir;\n\t\t\t\t\tvector[ w ] = depthHalf;\n\n\t\t\t\t\t// now apply vector to vertex buffer\n\n\t\t\t\t\tvertices.push( vector.x, vector.y, vector.z );\n\n\t\t\t\t\t// set values to correct vector component\n\n\t\t\t\t\tvector[ u ] = 0;\n\t\t\t\t\tvector[ v ] = 0;\n\t\t\t\t\tvector[ w ] = depth > 0 ? 1 : - 1;\n\n\t\t\t\t\t// now apply vector to normal buffer\n\n\t\t\t\t\tnormals.push( vector.x, vector.y, vector.z );\n\n\t\t\t\t\t// uvs\n\n\t\t\t\t\tuvs.push( ix / gridX );\n\t\t\t\t\tuvs.push( 1 - ( iy / gridY ) );\n\n\t\t\t\t\t// counters\n\n\t\t\t\t\tvertexCounter += 1;\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\t// indices\n\n\t\t\t// 1. you need three indices to draw a single face\n\t\t\t// 2. a single segment consists of two faces\n\t\t\t// 3. so we need to generate six (2*3) indices per segment\n\n\t\t\tfor ( let iy = 0; iy < gridY; iy ++ ) {\n\n\t\t\t\tfor ( let ix = 0; ix < gridX; ix ++ ) {\n\n\t\t\t\t\tconst a = numberOfVertices + ix + gridX1 * iy;\n\t\t\t\t\tconst b = numberOfVertices + ix + gridX1 * ( iy + 1 );\n\t\t\t\t\tconst c = numberOfVertices + ( ix + 1 ) + gridX1 * ( iy + 1 );\n\t\t\t\t\tconst d = numberOfVertices + ( ix + 1 ) + gridX1 * iy;\n\n\t\t\t\t\t// faces\n\n\t\t\t\t\tindices.push( a, b, d );\n\t\t\t\t\tindices.push( b, c, d );\n\n\t\t\t\t\t// increase counter\n\n\t\t\t\t\tgroupCount += 6;\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\t// add a group to the geometry. this will ensure multi material support\n\n\t\t\tscope.addGroup( groupStart, groupCount, materialIndex );\n\n\t\t\t// calculate new start value for groups\n\n\t\t\tgroupStart += groupCount;\n\n\t\t\t// update total number of vertices\n\n\t\t\tnumberOfVertices += vertexCounter;\n\n\t\t}\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.parameters = Object.assign( {}, source.parameters );\n\n\t\treturn this;\n\n\t}\n\n\tstatic fromJSON( data ) {\n\n\t\treturn new BoxGeometry( data.width, data.height, data.depth, data.widthSegments, data.heightSegments, data.depthSegments );\n\n\t}\n\n}\n\n/**\n * Uniform Utilities\n */\n\nfunction cloneUniforms( src ) {\n\n\tconst dst = {};\n\n\tfor ( const u in src ) {\n\n\t\tdst[ u ] = {};\n\n\t\tfor ( const p in src[ u ] ) {\n\n\t\t\tconst property = src[ u ][ p ];\n\n\t\t\tif ( property && ( property.isColor ||\n\t\t\t\tproperty.isMatrix3 || property.isMatrix4 ||\n\t\t\t\tproperty.isVector2 || property.isVector3 || property.isVector4 ||\n\t\t\t\tproperty.isTexture || property.isQuaternion ) ) {\n\n\t\t\t\tif ( property.isRenderTargetTexture ) {\n\n\t\t\t\t\tconsole.warn( 'UniformsUtils: Textures of render targets cannot be cloned via cloneUniforms() or mergeUniforms().' );\n\t\t\t\t\tdst[ u ][ p ] = null;\n\n\t\t\t\t} else {\n\n\t\t\t\t\tdst[ u ][ p ] = property.clone();\n\n\t\t\t\t}\n\n\t\t\t} else if ( Array.isArray( property ) ) {\n\n\t\t\t\tdst[ u ][ p ] = property.slice();\n\n\t\t\t} else {\n\n\t\t\t\tdst[ u ][ p ] = property;\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n\treturn dst;\n\n}\n\nfunction mergeUniforms( uniforms ) {\n\n\tconst merged = {};\n\n\tfor ( let u = 0; u < uniforms.length; u ++ ) {\n\n\t\tconst tmp = cloneUniforms( uniforms[ u ] );\n\n\t\tfor ( const p in tmp ) {\n\n\t\t\tmerged[ p ] = tmp[ p ];\n\n\t\t}\n\n\t}\n\n\treturn merged;\n\n}\n\nfunction cloneUniformsGroups( src ) {\n\n\tconst dst = [];\n\n\tfor ( let u = 0; u < src.length; u ++ ) {\n\n\t\tdst.push( src[ u ].clone() );\n\n\t}\n\n\treturn dst;\n\n}\n\nfunction getUnlitUniformColorSpace( renderer ) {\n\n\tconst currentRenderTarget = renderer.getRenderTarget();\n\n\tif ( currentRenderTarget === null ) {\n\n\t\t// https://github.com/mrdoob/three.js/pull/23937#issuecomment-1111067398\n\t\treturn renderer.outputColorSpace;\n\n\t}\n\n\t// https://github.com/mrdoob/three.js/issues/27868\n\tif ( currentRenderTarget.isXRRenderTarget === true ) {\n\n\t\treturn currentRenderTarget.texture.colorSpace;\n\n\t}\n\n\treturn ColorManagement.workingColorSpace;\n\n}\n\n// Legacy\n\nconst UniformsUtils = { clone: cloneUniforms, merge: mergeUniforms };\n\nvar default_vertex = \"void main() {\\n\\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\\n}\";\n\nvar default_fragment = \"void main() {\\n\\tgl_FragColor = vec4( 1.0, 0.0, 0.0, 1.0 );\\n}\";\n\nclass ShaderMaterial extends Material {\n\n\tconstructor( parameters ) {\n\n\t\tsuper();\n\n\t\tthis.isShaderMaterial = true;\n\n\t\tthis.type = 'ShaderMaterial';\n\n\t\tthis.defines = {};\n\t\tthis.uniforms = {};\n\t\tthis.uniformsGroups = [];\n\n\t\tthis.vertexShader = default_vertex;\n\t\tthis.fragmentShader = default_fragment;\n\n\t\tthis.linewidth = 1;\n\n\t\tthis.wireframe = false;\n\t\tthis.wireframeLinewidth = 1;\n\n\t\tthis.fog = false; // set to use scene fog\n\t\tthis.lights = false; // set to use scene lights\n\t\tthis.clipping = false; // set to use user-defined clipping planes\n\n\t\tthis.forceSinglePass = true;\n\n\t\tthis.extensions = {\n\t\t\tclipCullDistance: false, // set to use vertex shader clipping\n\t\t\tmultiDraw: false // set to use vertex shader multi_draw / enable gl_DrawID\n\t\t};\n\n\t\t// When rendered geometry doesn't include these attributes but the material does,\n\t\t// use these default values in WebGL. This avoids errors when buffer data is missing.\n\t\tthis.defaultAttributeValues = {\n\t\t\t'color': [ 1, 1, 1 ],\n\t\t\t'uv': [ 0, 0 ],\n\t\t\t'uv1': [ 0, 0 ]\n\t\t};\n\n\t\tthis.index0AttributeName = undefined;\n\t\tthis.uniformsNeedUpdate = false;\n\n\t\tthis.glslVersion = null;\n\n\t\tif ( parameters !== undefined ) {\n\n\t\t\tthis.setValues( parameters );\n\n\t\t}\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.fragmentShader = source.fragmentShader;\n\t\tthis.vertexShader = source.vertexShader;\n\n\t\tthis.uniforms = cloneUniforms( source.uniforms );\n\t\tthis.uniformsGroups = cloneUniformsGroups( source.uniformsGroups );\n\n\t\tthis.defines = Object.assign( {}, source.defines );\n\n\t\tthis.wireframe = source.wireframe;\n\t\tthis.wireframeLinewidth = source.wireframeLinewidth;\n\n\t\tthis.fog = source.fog;\n\t\tthis.lights = source.lights;\n\t\tthis.clipping = source.clipping;\n\n\t\tthis.extensions = Object.assign( {}, source.extensions );\n\n\t\tthis.glslVersion = source.glslVersion;\n\n\t\treturn this;\n\n\t}\n\n\ttoJSON( meta ) {\n\n\t\tconst data = super.toJSON( meta );\n\n\t\tdata.glslVersion = this.glslVersion;\n\t\tdata.uniforms = {};\n\n\t\tfor ( const name in this.uniforms ) {\n\n\t\t\tconst uniform = this.uniforms[ name ];\n\t\t\tconst value = uniform.value;\n\n\t\t\tif ( value && value.isTexture ) {\n\n\t\t\t\tdata.uniforms[ name ] = {\n\t\t\t\t\ttype: 't',\n\t\t\t\t\tvalue: value.toJSON( meta ).uuid\n\t\t\t\t};\n\n\t\t\t} else if ( value && value.isColor ) {\n\n\t\t\t\tdata.uniforms[ name ] = {\n\t\t\t\t\ttype: 'c',\n\t\t\t\t\tvalue: value.getHex()\n\t\t\t\t};\n\n\t\t\t} else if ( value && value.isVector2 ) {\n\n\t\t\t\tdata.uniforms[ name ] = {\n\t\t\t\t\ttype: 'v2',\n\t\t\t\t\tvalue: value.toArray()\n\t\t\t\t};\n\n\t\t\t} else if ( value && value.isVector3 ) {\n\n\t\t\t\tdata.uniforms[ name ] = {\n\t\t\t\t\ttype: 'v3',\n\t\t\t\t\tvalue: value.toArray()\n\t\t\t\t};\n\n\t\t\t} else if ( value && value.isVector4 ) {\n\n\t\t\t\tdata.uniforms[ name ] = {\n\t\t\t\t\ttype: 'v4',\n\t\t\t\t\tvalue: value.toArray()\n\t\t\t\t};\n\n\t\t\t} else if ( value && value.isMatrix3 ) {\n\n\t\t\t\tdata.uniforms[ name ] = {\n\t\t\t\t\ttype: 'm3',\n\t\t\t\t\tvalue: value.toArray()\n\t\t\t\t};\n\n\t\t\t} else if ( value && value.isMatrix4 ) {\n\n\t\t\t\tdata.uniforms[ name ] = {\n\t\t\t\t\ttype: 'm4',\n\t\t\t\t\tvalue: value.toArray()\n\t\t\t\t};\n\n\t\t\t} else {\n\n\t\t\t\tdata.uniforms[ name ] = {\n\t\t\t\t\tvalue: value\n\t\t\t\t};\n\n\t\t\t\t// note: the array variants v2v, v3v, v4v, m4v and tv are not supported so far\n\n\t\t\t}\n\n\t\t}\n\n\t\tif ( Object.keys( this.defines ).length > 0 ) data.defines = this.defines;\n\n\t\tdata.vertexShader = this.vertexShader;\n\t\tdata.fragmentShader = this.fragmentShader;\n\n\t\tdata.lights = this.lights;\n\t\tdata.clipping = this.clipping;\n\n\t\tconst extensions = {};\n\n\t\tfor ( const key in this.extensions ) {\n\n\t\t\tif ( this.extensions[ key ] === true ) extensions[ key ] = true;\n\n\t\t}\n\n\t\tif ( Object.keys( extensions ).length > 0 ) data.extensions = extensions;\n\n\t\treturn data;\n\n\t}\n\n}\n\nclass Camera extends Object3D {\n\n\tconstructor() {\n\n\t\tsuper();\n\n\t\tthis.isCamera = true;\n\n\t\tthis.type = 'Camera';\n\n\t\tthis.matrixWorldInverse = new Matrix4();\n\n\t\tthis.projectionMatrix = new Matrix4();\n\t\tthis.projectionMatrixInverse = new Matrix4();\n\n\t\tthis.coordinateSystem = WebGLCoordinateSystem;\n\n\t}\n\n\tcopy( source, recursive ) {\n\n\t\tsuper.copy( source, recursive );\n\n\t\tthis.matrixWorldInverse.copy( source.matrixWorldInverse );\n\n\t\tthis.projectionMatrix.copy( source.projectionMatrix );\n\t\tthis.projectionMatrixInverse.copy( source.projectionMatrixInverse );\n\n\t\tthis.coordinateSystem = source.coordinateSystem;\n\n\t\treturn this;\n\n\t}\n\n\tgetWorldDirection( target ) {\n\n\t\treturn super.getWorldDirection( target ).negate();\n\n\t}\n\n\tupdateMatrixWorld( force ) {\n\n\t\tsuper.updateMatrixWorld( force );\n\n\t\tthis.matrixWorldInverse.copy( this.matrixWorld ).invert();\n\n\t}\n\n\tupdateWorldMatrix( updateParents, updateChildren ) {\n\n\t\tsuper.updateWorldMatrix( updateParents, updateChildren );\n\n\t\tthis.matrixWorldInverse.copy( this.matrixWorld ).invert();\n\n\t}\n\n\tclone() {\n\n\t\treturn new this.constructor().copy( this );\n\n\t}\n\n}\n\nconst _v3$1 = /*@__PURE__*/ new Vector3();\nconst _minTarget = /*@__PURE__*/ new Vector2();\nconst _maxTarget = /*@__PURE__*/ new Vector2();\n\n\nclass PerspectiveCamera extends Camera {\n\n\tconstructor( fov = 50, aspect = 1, near = 0.1, far = 2000 ) {\n\n\t\tsuper();\n\n\t\tthis.isPerspectiveCamera = true;\n\n\t\tthis.type = 'PerspectiveCamera';\n\n\t\tthis.fov = fov;\n\t\tthis.zoom = 1;\n\n\t\tthis.near = near;\n\t\tthis.far = far;\n\t\tthis.focus = 10;\n\n\t\tthis.aspect = aspect;\n\t\tthis.view = null;\n\n\t\tthis.filmGauge = 35;\t// width of the film (default in millimeters)\n\t\tthis.filmOffset = 0;\t// horizontal film offset (same unit as gauge)\n\n\t\tthis.updateProjectionMatrix();\n\n\t}\n\n\tcopy( source, recursive ) {\n\n\t\tsuper.copy( source, recursive );\n\n\t\tthis.fov = source.fov;\n\t\tthis.zoom = source.zoom;\n\n\t\tthis.near = source.near;\n\t\tthis.far = source.far;\n\t\tthis.focus = source.focus;\n\n\t\tthis.aspect = source.aspect;\n\t\tthis.view = source.view === null ? null : Object.assign( {}, source.view );\n\n\t\tthis.filmGauge = source.filmGauge;\n\t\tthis.filmOffset = source.filmOffset;\n\n\t\treturn this;\n\n\t}\n\n\t/**\n\t * Sets the FOV by focal length in respect to the current .filmGauge.\n\t *\n\t * The default film gauge is 35, so that the focal length can be specified for\n\t * a 35mm (full frame) camera.\n\t *\n\t * Values for focal length and film gauge must have the same unit.\n\t */\n\tsetFocalLength( focalLength ) {\n\n\t\t/** see {@link http://www.bobatkins.com/photography/technical/field_of_view.html} */\n\t\tconst vExtentSlope = 0.5 * this.getFilmHeight() / focalLength;\n\n\t\tthis.fov = RAD2DEG * 2 * Math.atan( vExtentSlope );\n\t\tthis.updateProjectionMatrix();\n\n\t}\n\n\t/**\n\t * Calculates the focal length from the current .fov and .filmGauge.\n\t */\n\tgetFocalLength() {\n\n\t\tconst vExtentSlope = Math.tan( DEG2RAD * 0.5 * this.fov );\n\n\t\treturn 0.5 * this.getFilmHeight() / vExtentSlope;\n\n\t}\n\n\tgetEffectiveFOV() {\n\n\t\treturn RAD2DEG * 2 * Math.atan(\n\t\t\tMath.tan( DEG2RAD * 0.5 * this.fov ) / this.zoom );\n\n\t}\n\n\tgetFilmWidth() {\n\n\t\t// film not completely covered in portrait format (aspect < 1)\n\t\treturn this.filmGauge * Math.min( this.aspect, 1 );\n\n\t}\n\n\tgetFilmHeight() {\n\n\t\t// film not completely covered in landscape format (aspect > 1)\n\t\treturn this.filmGauge / Math.max( this.aspect, 1 );\n\n\t}\n\n\t/**\n\t * Computes the 2D bounds of the camera's viewable rectangle at a given distance along the viewing direction.\n\t * Sets minTarget and maxTarget to the coordinates of the lower-left and upper-right corners of the view rectangle.\n\t */\n\tgetViewBounds( distance, minTarget, maxTarget ) {\n\n\t\t_v3$1.set( - 1, - 1, 0.5 ).applyMatrix4( this.projectionMatrixInverse );\n\n\t\tminTarget.set( _v3$1.x, _v3$1.y ).multiplyScalar( - distance / _v3$1.z );\n\n\t\t_v3$1.set( 1, 1, 0.5 ).applyMatrix4( this.projectionMatrixInverse );\n\n\t\tmaxTarget.set( _v3$1.x, _v3$1.y ).multiplyScalar( - distance / _v3$1.z );\n\n\t}\n\n\t/**\n\t * Computes the width and height of the camera's viewable rectangle at a given distance along the viewing direction.\n\t * Copies the result into the target Vector2, where x is width and y is height.\n\t */\n\tgetViewSize( distance, target ) {\n\n\t\tthis.getViewBounds( distance, _minTarget, _maxTarget );\n\n\t\treturn target.subVectors( _maxTarget, _minTarget );\n\n\t}\n\n\t/**\n\t * Sets an offset in a larger frustum. This is useful for multi-window or\n\t * multi-monitor/multi-machine setups.\n\t *\n\t * For example, if you have 3x2 monitors and each monitor is 1920x1080 and\n\t * the monitors are in grid like this\n\t *\n\t * +---+---+---+\n\t * | A | B | C |\n\t * +---+---+---+\n\t * | D | E | F |\n\t * +---+---+---+\n\t *\n\t * then for each monitor you would call it like this\n\t *\n\t * const w = 1920;\n\t * const h = 1080;\n\t * const fullWidth = w * 3;\n\t * const fullHeight = h * 2;\n\t *\n\t * --A--\n\t * camera.setViewOffset( fullWidth, fullHeight, w * 0, h * 0, w, h );\n\t * --B--\n\t * camera.setViewOffset( fullWidth, fullHeight, w * 1, h * 0, w, h );\n\t * --C--\n\t * camera.setViewOffset( fullWidth, fullHeight, w * 2, h * 0, w, h );\n\t * --D--\n\t * camera.setViewOffset( fullWidth, fullHeight, w * 0, h * 1, w, h );\n\t * --E--\n\t * camera.setViewOffset( fullWidth, fullHeight, w * 1, h * 1, w, h );\n\t * --F--\n\t * camera.setViewOffset( fullWidth, fullHeight, w * 2, h * 1, w, h );\n\t *\n\t * Note there is no reason monitors have to be the same size or in a grid.\n\t */\n\tsetViewOffset( fullWidth, fullHeight, x, y, width, height ) {\n\n\t\tthis.aspect = fullWidth / fullHeight;\n\n\t\tif ( this.view === null ) {\n\n\t\t\tthis.view = {\n\t\t\t\tenabled: true,\n\t\t\t\tfullWidth: 1,\n\t\t\t\tfullHeight: 1,\n\t\t\t\toffsetX: 0,\n\t\t\t\toffsetY: 0,\n\t\t\t\twidth: 1,\n\t\t\t\theight: 1\n\t\t\t};\n\n\t\t}\n\n\t\tthis.view.enabled = true;\n\t\tthis.view.fullWidth = fullWidth;\n\t\tthis.view.fullHeight = fullHeight;\n\t\tthis.view.offsetX = x;\n\t\tthis.view.offsetY = y;\n\t\tthis.view.width = width;\n\t\tthis.view.height = height;\n\n\t\tthis.updateProjectionMatrix();\n\n\t}\n\n\tclearViewOffset() {\n\n\t\tif ( this.view !== null ) {\n\n\t\t\tthis.view.enabled = false;\n\n\t\t}\n\n\t\tthis.updateProjectionMatrix();\n\n\t}\n\n\tupdateProjectionMatrix() {\n\n\t\tconst near = this.near;\n\t\tlet top = near * Math.tan( DEG2RAD * 0.5 * this.fov ) / this.zoom;\n\t\tlet height = 2 * top;\n\t\tlet width = this.aspect * height;\n\t\tlet left = - 0.5 * width;\n\t\tconst view = this.view;\n\n\t\tif ( this.view !== null && this.view.enabled ) {\n\n\t\t\tconst fullWidth = view.fullWidth,\n\t\t\t\tfullHeight = view.fullHeight;\n\n\t\t\tleft += view.offsetX * width / fullWidth;\n\t\t\ttop -= view.offsetY * height / fullHeight;\n\t\t\twidth *= view.width / fullWidth;\n\t\t\theight *= view.height / fullHeight;\n\n\t\t}\n\n\t\tconst skew = this.filmOffset;\n\t\tif ( skew !== 0 ) left += near * skew / this.getFilmWidth();\n\n\t\tthis.projectionMatrix.makePerspective( left, left + width, top, top - height, near, this.far, this.coordinateSystem );\n\n\t\tthis.projectionMatrixInverse.copy( this.projectionMatrix ).invert();\n\n\t}\n\n\ttoJSON( meta ) {\n\n\t\tconst data = super.toJSON( meta );\n\n\t\tdata.object.fov = this.fov;\n\t\tdata.object.zoom = this.zoom;\n\n\t\tdata.object.near = this.near;\n\t\tdata.object.far = this.far;\n\t\tdata.object.focus = this.focus;\n\n\t\tdata.object.aspect = this.aspect;\n\n\t\tif ( this.view !== null ) data.object.view = Object.assign( {}, this.view );\n\n\t\tdata.object.filmGauge = this.filmGauge;\n\t\tdata.object.filmOffset = this.filmOffset;\n\n\t\treturn data;\n\n\t}\n\n}\n\nconst fov = - 90; // negative fov is not an error\nconst aspect = 1;\n\nclass CubeCamera extends Object3D {\n\n\tconstructor( near, far, renderTarget ) {\n\n\t\tsuper();\n\n\t\tthis.type = 'CubeCamera';\n\n\t\tthis.renderTarget = renderTarget;\n\t\tthis.coordinateSystem = null;\n\t\tthis.activeMipmapLevel = 0;\n\n\t\tconst cameraPX = new PerspectiveCamera( fov, aspect, near, far );\n\t\tcameraPX.layers = this.layers;\n\t\tthis.add( cameraPX );\n\n\t\tconst cameraNX = new PerspectiveCamera( fov, aspect, near, far );\n\t\tcameraNX.layers = this.layers;\n\t\tthis.add( cameraNX );\n\n\t\tconst cameraPY = new PerspectiveCamera( fov, aspect, near, far );\n\t\tcameraPY.layers = this.layers;\n\t\tthis.add( cameraPY );\n\n\t\tconst cameraNY = new PerspectiveCamera( fov, aspect, near, far );\n\t\tcameraNY.layers = this.layers;\n\t\tthis.add( cameraNY );\n\n\t\tconst cameraPZ = new PerspectiveCamera( fov, aspect, near, far );\n\t\tcameraPZ.layers = this.layers;\n\t\tthis.add( cameraPZ );\n\n\t\tconst cameraNZ = new PerspectiveCamera( fov, aspect, near, far );\n\t\tcameraNZ.layers = this.layers;\n\t\tthis.add( cameraNZ );\n\n\t}\n\n\tupdateCoordinateSystem() {\n\n\t\tconst coordinateSystem = this.coordinateSystem;\n\n\t\tconst cameras = this.children.concat();\n\n\t\tconst [ cameraPX, cameraNX, cameraPY, cameraNY, cameraPZ, cameraNZ ] = cameras;\n\n\t\tfor ( const camera of cameras ) this.remove( camera );\n\n\t\tif ( coordinateSystem === WebGLCoordinateSystem ) {\n\n\t\t\tcameraPX.up.set( 0, 1, 0 );\n\t\t\tcameraPX.lookAt( 1, 0, 0 );\n\n\t\t\tcameraNX.up.set( 0, 1, 0 );\n\t\t\tcameraNX.lookAt( - 1, 0, 0 );\n\n\t\t\tcameraPY.up.set( 0, 0, - 1 );\n\t\t\tcameraPY.lookAt( 0, 1, 0 );\n\n\t\t\tcameraNY.up.set( 0, 0, 1 );\n\t\t\tcameraNY.lookAt( 0, - 1, 0 );\n\n\t\t\tcameraPZ.up.set( 0, 1, 0 );\n\t\t\tcameraPZ.lookAt( 0, 0, 1 );\n\n\t\t\tcameraNZ.up.set( 0, 1, 0 );\n\t\t\tcameraNZ.lookAt( 0, 0, - 1 );\n\n\t\t} else if ( coordinateSystem === WebGPUCoordinateSystem ) {\n\n\t\t\tcameraPX.up.set( 0, - 1, 0 );\n\t\t\tcameraPX.lookAt( - 1, 0, 0 );\n\n\t\t\tcameraNX.up.set( 0, - 1, 0 );\n\t\t\tcameraNX.lookAt( 1, 0, 0 );\n\n\t\t\tcameraPY.up.set( 0, 0, 1 );\n\t\t\tcameraPY.lookAt( 0, 1, 0 );\n\n\t\t\tcameraNY.up.set( 0, 0, - 1 );\n\t\t\tcameraNY.lookAt( 0, - 1, 0 );\n\n\t\t\tcameraPZ.up.set( 0, - 1, 0 );\n\t\t\tcameraPZ.lookAt( 0, 0, 1 );\n\n\t\t\tcameraNZ.up.set( 0, - 1, 0 );\n\t\t\tcameraNZ.lookAt( 0, 0, - 1 );\n\n\t\t} else {\n\n\t\t\tthrow new Error( 'THREE.CubeCamera.updateCoordinateSystem(): Invalid coordinate system: ' + coordinateSystem );\n\n\t\t}\n\n\t\tfor ( const camera of cameras ) {\n\n\t\t\tthis.add( camera );\n\n\t\t\tcamera.updateMatrixWorld();\n\n\t\t}\n\n\t}\n\n\tupdate( renderer, scene ) {\n\n\t\tif ( this.parent === null ) this.updateMatrixWorld();\n\n\t\tconst { renderTarget, activeMipmapLevel } = this;\n\n\t\tif ( this.coordinateSystem !== renderer.coordinateSystem ) {\n\n\t\t\tthis.coordinateSystem = renderer.coordinateSystem;\n\n\t\t\tthis.updateCoordinateSystem();\n\n\t\t}\n\n\t\tconst [ cameraPX, cameraNX, cameraPY, cameraNY, cameraPZ, cameraNZ ] = this.children;\n\n\t\tconst currentRenderTarget = renderer.getRenderTarget();\n\t\tconst currentActiveCubeFace = renderer.getActiveCubeFace();\n\t\tconst currentActiveMipmapLevel = renderer.getActiveMipmapLevel();\n\n\t\tconst currentXrEnabled = renderer.xr.enabled;\n\n\t\trenderer.xr.enabled = false;\n\n\t\tconst generateMipmaps = renderTarget.texture.generateMipmaps;\n\n\t\trenderTarget.texture.generateMipmaps = false;\n\n\t\trenderer.setRenderTarget( renderTarget, 0, activeMipmapLevel );\n\t\trenderer.render( scene, cameraPX );\n\n\t\trenderer.setRenderTarget( renderTarget, 1, activeMipmapLevel );\n\t\trenderer.render( scene, cameraNX );\n\n\t\trenderer.setRenderTarget( renderTarget, 2, activeMipmapLevel );\n\t\trenderer.render( scene, cameraPY );\n\n\t\trenderer.setRenderTarget( renderTarget, 3, activeMipmapLevel );\n\t\trenderer.render( scene, cameraNY );\n\n\t\trenderer.setRenderTarget( renderTarget, 4, activeMipmapLevel );\n\t\trenderer.render( scene, cameraPZ );\n\n\t\t// mipmaps are generated during the last call of render()\n\t\t// at this point, all sides of the cube render target are defined\n\n\t\trenderTarget.texture.generateMipmaps = generateMipmaps;\n\n\t\trenderer.setRenderTarget( renderTarget, 5, activeMipmapLevel );\n\t\trenderer.render( scene, cameraNZ );\n\n\t\trenderer.setRenderTarget( currentRenderTarget, currentActiveCubeFace, currentActiveMipmapLevel );\n\n\t\trenderer.xr.enabled = currentXrEnabled;\n\n\t\trenderTarget.texture.needsPMREMUpdate = true;\n\n\t}\n\n}\n\nclass CubeTexture extends Texture {\n\n\tconstructor( images, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, colorSpace ) {\n\n\t\timages = images !== undefined ? images : [];\n\t\tmapping = mapping !== undefined ? mapping : CubeReflectionMapping;\n\n\t\tsuper( images, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, colorSpace );\n\n\t\tthis.isCubeTexture = true;\n\n\t\tthis.flipY = false;\n\n\t}\n\n\tget images() {\n\n\t\treturn this.image;\n\n\t}\n\n\tset images( value ) {\n\n\t\tthis.image = value;\n\n\t}\n\n}\n\nclass WebGLCubeRenderTarget extends WebGLRenderTarget {\n\n\tconstructor( size = 1, options = {} ) {\n\n\t\tsuper( size, size, options );\n\n\t\tthis.isWebGLCubeRenderTarget = true;\n\n\t\tconst image = { width: size, height: size, depth: 1 };\n\t\tconst images = [ image, image, image, image, image, image ];\n\n\t\tthis.texture = new CubeTexture( images, options.mapping, options.wrapS, options.wrapT, options.magFilter, options.minFilter, options.format, options.type, options.anisotropy, options.colorSpace );\n\n\t\t// By convention -- likely based on the RenderMan spec from the 1990's -- cube maps are specified by WebGL (and three.js)\n\t\t// in a coordinate system in which positive-x is to the right when looking up the positive-z axis -- in other words,\n\t\t// in a left-handed coordinate system. By continuing this convention, preexisting cube maps continued to render correctly.\n\n\t\t// three.js uses a right-handed coordinate system. So environment maps used in three.js appear to have px and nx swapped\n\t\t// and the flag isRenderTargetTexture controls this conversion. The flip is not required when using WebGLCubeRenderTarget.texture\n\t\t// as a cube texture (this is detected when isRenderTargetTexture is set to true for cube textures).\n\n\t\tthis.texture.isRenderTargetTexture = true;\n\n\t\tthis.texture.generateMipmaps = options.generateMipmaps !== undefined ? options.generateMipmaps : false;\n\t\tthis.texture.minFilter = options.minFilter !== undefined ? options.minFilter : LinearFilter;\n\n\t}\n\n\tfromEquirectangularTexture( renderer, texture ) {\n\n\t\tthis.texture.type = texture.type;\n\t\tthis.texture.colorSpace = texture.colorSpace;\n\n\t\tthis.texture.generateMipmaps = texture.generateMipmaps;\n\t\tthis.texture.minFilter = texture.minFilter;\n\t\tthis.texture.magFilter = texture.magFilter;\n\n\t\tconst shader = {\n\n\t\t\tuniforms: {\n\t\t\t\ttEquirect: { value: null },\n\t\t\t},\n\n\t\t\tvertexShader: /* glsl */`\n\n\t\t\t\tvarying vec3 vWorldDirection;\n\n\t\t\t\tvec3 transformDirection( in vec3 dir, in mat4 matrix ) {\n\n\t\t\t\t\treturn normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );\n\n\t\t\t\t}\n\n\t\t\t\tvoid main() {\n\n\t\t\t\t\tvWorldDirection = transformDirection( position, modelMatrix );\n\n\t\t\t\t\t#include \n\t\t\t\t\t#include \n\n\t\t\t\t}\n\t\t\t`,\n\n\t\t\tfragmentShader: /* glsl */`\n\n\t\t\t\tuniform sampler2D tEquirect;\n\n\t\t\t\tvarying vec3 vWorldDirection;\n\n\t\t\t\t#include \n\n\t\t\t\tvoid main() {\n\n\t\t\t\t\tvec3 direction = normalize( vWorldDirection );\n\n\t\t\t\t\tvec2 sampleUV = equirectUv( direction );\n\n\t\t\t\t\tgl_FragColor = texture2D( tEquirect, sampleUV );\n\n\t\t\t\t}\n\t\t\t`\n\t\t};\n\n\t\tconst geometry = new BoxGeometry( 5, 5, 5 );\n\n\t\tconst material = new ShaderMaterial( {\n\n\t\t\tname: 'CubemapFromEquirect',\n\n\t\t\tuniforms: cloneUniforms( shader.uniforms ),\n\t\t\tvertexShader: shader.vertexShader,\n\t\t\tfragmentShader: shader.fragmentShader,\n\t\t\tside: BackSide,\n\t\t\tblending: NoBlending\n\n\t\t} );\n\n\t\tmaterial.uniforms.tEquirect.value = texture;\n\n\t\tconst mesh = new Mesh( geometry, material );\n\n\t\tconst currentMinFilter = texture.minFilter;\n\n\t\t// Avoid blurred poles\n\t\tif ( texture.minFilter === LinearMipmapLinearFilter ) texture.minFilter = LinearFilter;\n\n\t\tconst camera = new CubeCamera( 1, 10, this );\n\t\tcamera.update( renderer, mesh );\n\n\t\ttexture.minFilter = currentMinFilter;\n\n\t\tmesh.geometry.dispose();\n\t\tmesh.material.dispose();\n\n\t\treturn this;\n\n\t}\n\n\tclear( renderer, color, depth, stencil ) {\n\n\t\tconst currentRenderTarget = renderer.getRenderTarget();\n\n\t\tfor ( let i = 0; i < 6; i ++ ) {\n\n\t\t\trenderer.setRenderTarget( this, i );\n\n\t\t\trenderer.clear( color, depth, stencil );\n\n\t\t}\n\n\t\trenderer.setRenderTarget( currentRenderTarget );\n\n\t}\n\n}\n\nconst _vector1 = /*@__PURE__*/ new Vector3();\nconst _vector2 = /*@__PURE__*/ new Vector3();\nconst _normalMatrix = /*@__PURE__*/ new Matrix3();\n\nclass Plane {\n\n\tconstructor( normal = new Vector3( 1, 0, 0 ), constant = 0 ) {\n\n\t\tthis.isPlane = true;\n\n\t\t// normal is assumed to be normalized\n\n\t\tthis.normal = normal;\n\t\tthis.constant = constant;\n\n\t}\n\n\tset( normal, constant ) {\n\n\t\tthis.normal.copy( normal );\n\t\tthis.constant = constant;\n\n\t\treturn this;\n\n\t}\n\n\tsetComponents( x, y, z, w ) {\n\n\t\tthis.normal.set( x, y, z );\n\t\tthis.constant = w;\n\n\t\treturn this;\n\n\t}\n\n\tsetFromNormalAndCoplanarPoint( normal, point ) {\n\n\t\tthis.normal.copy( normal );\n\t\tthis.constant = - point.dot( this.normal );\n\n\t\treturn this;\n\n\t}\n\n\tsetFromCoplanarPoints( a, b, c ) {\n\n\t\tconst normal = _vector1.subVectors( c, b ).cross( _vector2.subVectors( a, b ) ).normalize();\n\n\t\t// Q: should an error be thrown if normal is zero (e.g. degenerate plane)?\n\n\t\tthis.setFromNormalAndCoplanarPoint( normal, a );\n\n\t\treturn this;\n\n\t}\n\n\tcopy( plane ) {\n\n\t\tthis.normal.copy( plane.normal );\n\t\tthis.constant = plane.constant;\n\n\t\treturn this;\n\n\t}\n\n\tnormalize() {\n\n\t\t// Note: will lead to a divide by zero if the plane is invalid.\n\n\t\tconst inverseNormalLength = 1.0 / this.normal.length();\n\t\tthis.normal.multiplyScalar( inverseNormalLength );\n\t\tthis.constant *= inverseNormalLength;\n\n\t\treturn this;\n\n\t}\n\n\tnegate() {\n\n\t\tthis.constant *= - 1;\n\t\tthis.normal.negate();\n\n\t\treturn this;\n\n\t}\n\n\tdistanceToPoint( point ) {\n\n\t\treturn this.normal.dot( point ) + this.constant;\n\n\t}\n\n\tdistanceToSphere( sphere ) {\n\n\t\treturn this.distanceToPoint( sphere.center ) - sphere.radius;\n\n\t}\n\n\tprojectPoint( point, target ) {\n\n\t\treturn target.copy( point ).addScaledVector( this.normal, - this.distanceToPoint( point ) );\n\n\t}\n\n\tintersectLine( line, target ) {\n\n\t\tconst direction = line.delta( _vector1 );\n\n\t\tconst denominator = this.normal.dot( direction );\n\n\t\tif ( denominator === 0 ) {\n\n\t\t\t// line is coplanar, return origin\n\t\t\tif ( this.distanceToPoint( line.start ) === 0 ) {\n\n\t\t\t\treturn target.copy( line.start );\n\n\t\t\t}\n\n\t\t\t// Unsure if this is the correct method to handle this case.\n\t\t\treturn null;\n\n\t\t}\n\n\t\tconst t = - ( line.start.dot( this.normal ) + this.constant ) / denominator;\n\n\t\tif ( t < 0 || t > 1 ) {\n\n\t\t\treturn null;\n\n\t\t}\n\n\t\treturn target.copy( line.start ).addScaledVector( direction, t );\n\n\t}\n\n\tintersectsLine( line ) {\n\n\t\t// Note: this tests if a line intersects the plane, not whether it (or its end-points) are coplanar with it.\n\n\t\tconst startSign = this.distanceToPoint( line.start );\n\t\tconst endSign = this.distanceToPoint( line.end );\n\n\t\treturn ( startSign < 0 && endSign > 0 ) || ( endSign < 0 && startSign > 0 );\n\n\t}\n\n\tintersectsBox( box ) {\n\n\t\treturn box.intersectsPlane( this );\n\n\t}\n\n\tintersectsSphere( sphere ) {\n\n\t\treturn sphere.intersectsPlane( this );\n\n\t}\n\n\tcoplanarPoint( target ) {\n\n\t\treturn target.copy( this.normal ).multiplyScalar( - this.constant );\n\n\t}\n\n\tapplyMatrix4( matrix, optionalNormalMatrix ) {\n\n\t\tconst normalMatrix = optionalNormalMatrix || _normalMatrix.getNormalMatrix( matrix );\n\n\t\tconst referencePoint = this.coplanarPoint( _vector1 ).applyMatrix4( matrix );\n\n\t\tconst normal = this.normal.applyMatrix3( normalMatrix ).normalize();\n\n\t\tthis.constant = - referencePoint.dot( normal );\n\n\t\treturn this;\n\n\t}\n\n\ttranslate( offset ) {\n\n\t\tthis.constant -= offset.dot( this.normal );\n\n\t\treturn this;\n\n\t}\n\n\tequals( plane ) {\n\n\t\treturn plane.normal.equals( this.normal ) && ( plane.constant === this.constant );\n\n\t}\n\n\tclone() {\n\n\t\treturn new this.constructor().copy( this );\n\n\t}\n\n}\n\nconst _sphere$5 = /*@__PURE__*/ new Sphere();\nconst _vector$7 = /*@__PURE__*/ new Vector3();\n\nclass Frustum {\n\n\tconstructor( p0 = new Plane(), p1 = new Plane(), p2 = new Plane(), p3 = new Plane(), p4 = new Plane(), p5 = new Plane() ) {\n\n\t\tthis.planes = [ p0, p1, p2, p3, p4, p5 ];\n\n\t}\n\n\tset( p0, p1, p2, p3, p4, p5 ) {\n\n\t\tconst planes = this.planes;\n\n\t\tplanes[ 0 ].copy( p0 );\n\t\tplanes[ 1 ].copy( p1 );\n\t\tplanes[ 2 ].copy( p2 );\n\t\tplanes[ 3 ].copy( p3 );\n\t\tplanes[ 4 ].copy( p4 );\n\t\tplanes[ 5 ].copy( p5 );\n\n\t\treturn this;\n\n\t}\n\n\tcopy( frustum ) {\n\n\t\tconst planes = this.planes;\n\n\t\tfor ( let i = 0; i < 6; i ++ ) {\n\n\t\t\tplanes[ i ].copy( frustum.planes[ i ] );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tsetFromProjectionMatrix( m, coordinateSystem = WebGLCoordinateSystem ) {\n\n\t\tconst planes = this.planes;\n\t\tconst me = m.elements;\n\t\tconst me0 = me[ 0 ], me1 = me[ 1 ], me2 = me[ 2 ], me3 = me[ 3 ];\n\t\tconst me4 = me[ 4 ], me5 = me[ 5 ], me6 = me[ 6 ], me7 = me[ 7 ];\n\t\tconst me8 = me[ 8 ], me9 = me[ 9 ], me10 = me[ 10 ], me11 = me[ 11 ];\n\t\tconst me12 = me[ 12 ], me13 = me[ 13 ], me14 = me[ 14 ], me15 = me[ 15 ];\n\n\t\tplanes[ 0 ].setComponents( me3 - me0, me7 - me4, me11 - me8, me15 - me12 ).normalize();\n\t\tplanes[ 1 ].setComponents( me3 + me0, me7 + me4, me11 + me8, me15 + me12 ).normalize();\n\t\tplanes[ 2 ].setComponents( me3 + me1, me7 + me5, me11 + me9, me15 + me13 ).normalize();\n\t\tplanes[ 3 ].setComponents( me3 - me1, me7 - me5, me11 - me9, me15 - me13 ).normalize();\n\t\tplanes[ 4 ].setComponents( me3 - me2, me7 - me6, me11 - me10, me15 - me14 ).normalize();\n\n\t\tif ( coordinateSystem === WebGLCoordinateSystem ) {\n\n\t\t\tplanes[ 5 ].setComponents( me3 + me2, me7 + me6, me11 + me10, me15 + me14 ).normalize();\n\n\t\t} else if ( coordinateSystem === WebGPUCoordinateSystem ) {\n\n\t\t\tplanes[ 5 ].setComponents( me2, me6, me10, me14 ).normalize();\n\n\t\t} else {\n\n\t\t\tthrow new Error( 'THREE.Frustum.setFromProjectionMatrix(): Invalid coordinate system: ' + coordinateSystem );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tintersectsObject( object ) {\n\n\t\tif ( object.boundingSphere !== undefined ) {\n\n\t\t\tif ( object.boundingSphere === null ) object.computeBoundingSphere();\n\n\t\t\t_sphere$5.copy( object.boundingSphere ).applyMatrix4( object.matrixWorld );\n\n\t\t} else {\n\n\t\t\tconst geometry = object.geometry;\n\n\t\t\tif ( geometry.boundingSphere === null ) geometry.computeBoundingSphere();\n\n\t\t\t_sphere$5.copy( geometry.boundingSphere ).applyMatrix4( object.matrixWorld );\n\n\t\t}\n\n\t\treturn this.intersectsSphere( _sphere$5 );\n\n\t}\n\n\tintersectsSprite( sprite ) {\n\n\t\t_sphere$5.center.set( 0, 0, 0 );\n\t\t_sphere$5.radius = 0.7071067811865476;\n\t\t_sphere$5.applyMatrix4( sprite.matrixWorld );\n\n\t\treturn this.intersectsSphere( _sphere$5 );\n\n\t}\n\n\tintersectsSphere( sphere ) {\n\n\t\tconst planes = this.planes;\n\t\tconst center = sphere.center;\n\t\tconst negRadius = - sphere.radius;\n\n\t\tfor ( let i = 0; i < 6; i ++ ) {\n\n\t\t\tconst distance = planes[ i ].distanceToPoint( center );\n\n\t\t\tif ( distance < negRadius ) {\n\n\t\t\t\treturn false;\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn true;\n\n\t}\n\n\tintersectsBox( box ) {\n\n\t\tconst planes = this.planes;\n\n\t\tfor ( let i = 0; i < 6; i ++ ) {\n\n\t\t\tconst plane = planes[ i ];\n\n\t\t\t// corner at max distance\n\n\t\t\t_vector$7.x = plane.normal.x > 0 ? box.max.x : box.min.x;\n\t\t\t_vector$7.y = plane.normal.y > 0 ? box.max.y : box.min.y;\n\t\t\t_vector$7.z = plane.normal.z > 0 ? box.max.z : box.min.z;\n\n\t\t\tif ( plane.distanceToPoint( _vector$7 ) < 0 ) {\n\n\t\t\t\treturn false;\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn true;\n\n\t}\n\n\tcontainsPoint( point ) {\n\n\t\tconst planes = this.planes;\n\n\t\tfor ( let i = 0; i < 6; i ++ ) {\n\n\t\t\tif ( planes[ i ].distanceToPoint( point ) < 0 ) {\n\n\t\t\t\treturn false;\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn true;\n\n\t}\n\n\tclone() {\n\n\t\treturn new this.constructor().copy( this );\n\n\t}\n\n}\n\nfunction WebGLAnimation() {\n\n\tlet context = null;\n\tlet isAnimating = false;\n\tlet animationLoop = null;\n\tlet requestId = null;\n\n\tfunction onAnimationFrame( time, frame ) {\n\n\t\tanimationLoop( time, frame );\n\n\t\trequestId = context.requestAnimationFrame( onAnimationFrame );\n\n\t}\n\n\treturn {\n\n\t\tstart: function () {\n\n\t\t\tif ( isAnimating === true ) return;\n\t\t\tif ( animationLoop === null ) return;\n\n\t\t\trequestId = context.requestAnimationFrame( onAnimationFrame );\n\n\t\t\tisAnimating = true;\n\n\t\t},\n\n\t\tstop: function () {\n\n\t\t\tcontext.cancelAnimationFrame( requestId );\n\n\t\t\tisAnimating = false;\n\n\t\t},\n\n\t\tsetAnimationLoop: function ( callback ) {\n\n\t\t\tanimationLoop = callback;\n\n\t\t},\n\n\t\tsetContext: function ( value ) {\n\n\t\t\tcontext = value;\n\n\t\t}\n\n\t};\n\n}\n\nfunction WebGLAttributes( gl ) {\n\n\tconst buffers = new WeakMap();\n\n\tfunction createBuffer( attribute, bufferType ) {\n\n\t\tconst array = attribute.array;\n\t\tconst usage = attribute.usage;\n\t\tconst size = array.byteLength;\n\n\t\tconst buffer = gl.createBuffer();\n\n\t\tgl.bindBuffer( bufferType, buffer );\n\t\tgl.bufferData( bufferType, array, usage );\n\n\t\tattribute.onUploadCallback();\n\n\t\tlet type;\n\n\t\tif ( array instanceof Float32Array ) {\n\n\t\t\ttype = gl.FLOAT;\n\n\t\t} else if ( array instanceof Uint16Array ) {\n\n\t\t\tif ( attribute.isFloat16BufferAttribute ) {\n\n\t\t\t\ttype = gl.HALF_FLOAT;\n\n\t\t\t} else {\n\n\t\t\t\ttype = gl.UNSIGNED_SHORT;\n\n\t\t\t}\n\n\t\t} else if ( array instanceof Int16Array ) {\n\n\t\t\ttype = gl.SHORT;\n\n\t\t} else if ( array instanceof Uint32Array ) {\n\n\t\t\ttype = gl.UNSIGNED_INT;\n\n\t\t} else if ( array instanceof Int32Array ) {\n\n\t\t\ttype = gl.INT;\n\n\t\t} else if ( array instanceof Int8Array ) {\n\n\t\t\ttype = gl.BYTE;\n\n\t\t} else if ( array instanceof Uint8Array ) {\n\n\t\t\ttype = gl.UNSIGNED_BYTE;\n\n\t\t} else if ( array instanceof Uint8ClampedArray ) {\n\n\t\t\ttype = gl.UNSIGNED_BYTE;\n\n\t\t} else {\n\n\t\t\tthrow new Error( 'THREE.WebGLAttributes: Unsupported buffer data format: ' + array );\n\n\t\t}\n\n\t\treturn {\n\t\t\tbuffer: buffer,\n\t\t\ttype: type,\n\t\t\tbytesPerElement: array.BYTES_PER_ELEMENT,\n\t\t\tversion: attribute.version,\n\t\t\tsize: size\n\t\t};\n\n\t}\n\n\tfunction updateBuffer( buffer, attribute, bufferType ) {\n\n\t\tconst array = attribute.array;\n\t\tconst updateRange = attribute._updateRange; // @deprecated, r159\n\t\tconst updateRanges = attribute.updateRanges;\n\n\t\tgl.bindBuffer( bufferType, buffer );\n\n\t\tif ( updateRange.count === - 1 && updateRanges.length === 0 ) {\n\n\t\t\t// Not using update ranges\n\t\t\tgl.bufferSubData( bufferType, 0, array );\n\n\t\t}\n\n\t\tif ( updateRanges.length !== 0 ) {\n\n\t\t\tfor ( let i = 0, l = updateRanges.length; i < l; i ++ ) {\n\n\t\t\t\tconst range = updateRanges[ i ];\n\n\t\t\t\tgl.bufferSubData( bufferType, range.start * array.BYTES_PER_ELEMENT,\n\t\t\t\t\tarray, range.start, range.count );\n\n\t\t\t}\n\n\t\t\tattribute.clearUpdateRanges();\n\n\t\t}\n\n\t\t// @deprecated, r159\n\t\tif ( updateRange.count !== - 1 ) {\n\n\t\t\tgl.bufferSubData( bufferType, updateRange.offset * array.BYTES_PER_ELEMENT,\n\t\t\t\tarray, updateRange.offset, updateRange.count );\n\n\t\t\tupdateRange.count = - 1; // reset range\n\n\t\t}\n\n\t\tattribute.onUploadCallback();\n\n\t}\n\n\t//\n\n\tfunction get( attribute ) {\n\n\t\tif ( attribute.isInterleavedBufferAttribute ) attribute = attribute.data;\n\n\t\treturn buffers.get( attribute );\n\n\t}\n\n\tfunction remove( attribute ) {\n\n\t\tif ( attribute.isInterleavedBufferAttribute ) attribute = attribute.data;\n\n\t\tconst data = buffers.get( attribute );\n\n\t\tif ( data ) {\n\n\t\t\tgl.deleteBuffer( data.buffer );\n\n\t\t\tbuffers.delete( attribute );\n\n\t\t}\n\n\t}\n\n\tfunction update( attribute, bufferType ) {\n\n\t\tif ( attribute.isGLBufferAttribute ) {\n\n\t\t\tconst cached = buffers.get( attribute );\n\n\t\t\tif ( ! cached || cached.version < attribute.version ) {\n\n\t\t\t\tbuffers.set( attribute, {\n\t\t\t\t\tbuffer: attribute.buffer,\n\t\t\t\t\ttype: attribute.type,\n\t\t\t\t\tbytesPerElement: attribute.elementSize,\n\t\t\t\t\tversion: attribute.version\n\t\t\t\t} );\n\n\t\t\t}\n\n\t\t\treturn;\n\n\t\t}\n\n\t\tif ( attribute.isInterleavedBufferAttribute ) attribute = attribute.data;\n\n\t\tconst data = buffers.get( attribute );\n\n\t\tif ( data === undefined ) {\n\n\t\t\tbuffers.set( attribute, createBuffer( attribute, bufferType ) );\n\n\t\t} else if ( data.version < attribute.version ) {\n\n\t\t\tif ( data.size !== attribute.array.byteLength ) {\n\n\t\t\t\tthrow new Error( 'THREE.WebGLAttributes: The size of the buffer attribute\\'s array buffer does not match the original size. Resizing buffer attributes is not supported.' );\n\n\t\t\t}\n\n\t\t\tupdateBuffer( data.buffer, attribute, bufferType );\n\n\t\t\tdata.version = attribute.version;\n\n\t\t}\n\n\t}\n\n\treturn {\n\n\t\tget: get,\n\t\tremove: remove,\n\t\tupdate: update\n\n\t};\n\n}\n\nclass PlaneGeometry extends BufferGeometry {\n\n\tconstructor( width = 1, height = 1, widthSegments = 1, heightSegments = 1 ) {\n\n\t\tsuper();\n\n\t\tthis.type = 'PlaneGeometry';\n\n\t\tthis.parameters = {\n\t\t\twidth: width,\n\t\t\theight: height,\n\t\t\twidthSegments: widthSegments,\n\t\t\theightSegments: heightSegments\n\t\t};\n\n\t\tconst width_half = width / 2;\n\t\tconst height_half = height / 2;\n\n\t\tconst gridX = Math.floor( widthSegments );\n\t\tconst gridY = Math.floor( heightSegments );\n\n\t\tconst gridX1 = gridX + 1;\n\t\tconst gridY1 = gridY + 1;\n\n\t\tconst segment_width = width / gridX;\n\t\tconst segment_height = height / gridY;\n\n\t\t//\n\n\t\tconst indices = [];\n\t\tconst vertices = [];\n\t\tconst normals = [];\n\t\tconst uvs = [];\n\n\t\tfor ( let iy = 0; iy < gridY1; iy ++ ) {\n\n\t\t\tconst y = iy * segment_height - height_half;\n\n\t\t\tfor ( let ix = 0; ix < gridX1; ix ++ ) {\n\n\t\t\t\tconst x = ix * segment_width - width_half;\n\n\t\t\t\tvertices.push( x, - y, 0 );\n\n\t\t\t\tnormals.push( 0, 0, 1 );\n\n\t\t\t\tuvs.push( ix / gridX );\n\t\t\t\tuvs.push( 1 - ( iy / gridY ) );\n\n\t\t\t}\n\n\t\t}\n\n\t\tfor ( let iy = 0; iy < gridY; iy ++ ) {\n\n\t\t\tfor ( let ix = 0; ix < gridX; ix ++ ) {\n\n\t\t\t\tconst a = ix + gridX1 * iy;\n\t\t\t\tconst b = ix + gridX1 * ( iy + 1 );\n\t\t\t\tconst c = ( ix + 1 ) + gridX1 * ( iy + 1 );\n\t\t\t\tconst d = ( ix + 1 ) + gridX1 * iy;\n\n\t\t\t\tindices.push( a, b, d );\n\t\t\t\tindices.push( b, c, d );\n\n\t\t\t}\n\n\t\t}\n\n\t\tthis.setIndex( indices );\n\t\tthis.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\n\t\tthis.setAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );\n\t\tthis.setAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.parameters = Object.assign( {}, source.parameters );\n\n\t\treturn this;\n\n\t}\n\n\tstatic fromJSON( data ) {\n\n\t\treturn new PlaneGeometry( data.width, data.height, data.widthSegments, data.heightSegments );\n\n\t}\n\n}\n\nvar alphahash_fragment = \"#ifdef USE_ALPHAHASH\\n\\tif ( diffuseColor.a < getAlphaHashThreshold( vPosition ) ) discard;\\n#endif\";\n\nvar alphahash_pars_fragment = \"#ifdef USE_ALPHAHASH\\n\\tconst float ALPHA_HASH_SCALE = 0.05;\\n\\tfloat hash2D( vec2 value ) {\\n\\t\\treturn fract( 1.0e4 * sin( 17.0 * value.x + 0.1 * value.y ) * ( 0.1 + abs( sin( 13.0 * value.y + value.x ) ) ) );\\n\\t}\\n\\tfloat hash3D( vec3 value ) {\\n\\t\\treturn hash2D( vec2( hash2D( value.xy ), value.z ) );\\n\\t}\\n\\tfloat getAlphaHashThreshold( vec3 position ) {\\n\\t\\tfloat maxDeriv = max(\\n\\t\\t\\tlength( dFdx( position.xyz ) ),\\n\\t\\t\\tlength( dFdy( position.xyz ) )\\n\\t\\t);\\n\\t\\tfloat pixScale = 1.0 / ( ALPHA_HASH_SCALE * maxDeriv );\\n\\t\\tvec2 pixScales = vec2(\\n\\t\\t\\texp2( floor( log2( pixScale ) ) ),\\n\\t\\t\\texp2( ceil( log2( pixScale ) ) )\\n\\t\\t);\\n\\t\\tvec2 alpha = vec2(\\n\\t\\t\\thash3D( floor( pixScales.x * position.xyz ) ),\\n\\t\\t\\thash3D( floor( pixScales.y * position.xyz ) )\\n\\t\\t);\\n\\t\\tfloat lerpFactor = fract( log2( pixScale ) );\\n\\t\\tfloat x = ( 1.0 - lerpFactor ) * alpha.x + lerpFactor * alpha.y;\\n\\t\\tfloat a = min( lerpFactor, 1.0 - lerpFactor );\\n\\t\\tvec3 cases = vec3(\\n\\t\\t\\tx * x / ( 2.0 * a * ( 1.0 - a ) ),\\n\\t\\t\\t( x - 0.5 * a ) / ( 1.0 - a ),\\n\\t\\t\\t1.0 - ( ( 1.0 - x ) * ( 1.0 - x ) / ( 2.0 * a * ( 1.0 - a ) ) )\\n\\t\\t);\\n\\t\\tfloat threshold = ( x < ( 1.0 - a ) )\\n\\t\\t\\t? ( ( x < a ) ? cases.x : cases.y )\\n\\t\\t\\t: cases.z;\\n\\t\\treturn clamp( threshold , 1.0e-6, 1.0 );\\n\\t}\\n#endif\";\n\nvar alphamap_fragment = \"#ifdef USE_ALPHAMAP\\n\\tdiffuseColor.a *= texture2D( alphaMap, vAlphaMapUv ).g;\\n#endif\";\n\nvar alphamap_pars_fragment = \"#ifdef USE_ALPHAMAP\\n\\tuniform sampler2D alphaMap;\\n#endif\";\n\nvar alphatest_fragment = \"#ifdef USE_ALPHATEST\\n\\t#ifdef ALPHA_TO_COVERAGE\\n\\tdiffuseColor.a = smoothstep( alphaTest, alphaTest + fwidth( diffuseColor.a ), diffuseColor.a );\\n\\tif ( diffuseColor.a == 0.0 ) discard;\\n\\t#else\\n\\tif ( diffuseColor.a < alphaTest ) discard;\\n\\t#endif\\n#endif\";\n\nvar alphatest_pars_fragment = \"#ifdef USE_ALPHATEST\\n\\tuniform float alphaTest;\\n#endif\";\n\nvar aomap_fragment = \"#ifdef USE_AOMAP\\n\\tfloat ambientOcclusion = ( texture2D( aoMap, vAoMapUv ).r - 1.0 ) * aoMapIntensity + 1.0;\\n\\treflectedLight.indirectDiffuse *= ambientOcclusion;\\n\\t#if defined( USE_CLEARCOAT ) \\n\\t\\tclearcoatSpecularIndirect *= ambientOcclusion;\\n\\t#endif\\n\\t#if defined( USE_SHEEN ) \\n\\t\\tsheenSpecularIndirect *= ambientOcclusion;\\n\\t#endif\\n\\t#if defined( USE_ENVMAP ) && defined( STANDARD )\\n\\t\\tfloat dotNV = saturate( dot( geometryNormal, geometryViewDir ) );\\n\\t\\treflectedLight.indirectSpecular *= computeSpecularOcclusion( dotNV, ambientOcclusion, material.roughness );\\n\\t#endif\\n#endif\";\n\nvar aomap_pars_fragment = \"#ifdef USE_AOMAP\\n\\tuniform sampler2D aoMap;\\n\\tuniform float aoMapIntensity;\\n#endif\";\n\nvar batching_pars_vertex = \"#ifdef USE_BATCHING\\n\\tattribute float batchId;\\n\\tuniform highp sampler2D batchingTexture;\\n\\tmat4 getBatchingMatrix( const in float i ) {\\n\\t\\tint size = textureSize( batchingTexture, 0 ).x;\\n\\t\\tint j = int( i ) * 4;\\n\\t\\tint x = j % size;\\n\\t\\tint y = j / size;\\n\\t\\tvec4 v1 = texelFetch( batchingTexture, ivec2( x, y ), 0 );\\n\\t\\tvec4 v2 = texelFetch( batchingTexture, ivec2( x + 1, y ), 0 );\\n\\t\\tvec4 v3 = texelFetch( batchingTexture, ivec2( x + 2, y ), 0 );\\n\\t\\tvec4 v4 = texelFetch( batchingTexture, ivec2( x + 3, y ), 0 );\\n\\t\\treturn mat4( v1, v2, v3, v4 );\\n\\t}\\n#endif\";\n\nvar batching_vertex = \"#ifdef USE_BATCHING\\n\\tmat4 batchingMatrix = getBatchingMatrix( batchId );\\n#endif\";\n\nvar begin_vertex = \"vec3 transformed = vec3( position );\\n#ifdef USE_ALPHAHASH\\n\\tvPosition = vec3( position );\\n#endif\";\n\nvar beginnormal_vertex = \"vec3 objectNormal = vec3( normal );\\n#ifdef USE_TANGENT\\n\\tvec3 objectTangent = vec3( tangent.xyz );\\n#endif\";\n\nvar bsdfs = \"float G_BlinnPhong_Implicit( ) {\\n\\treturn 0.25;\\n}\\nfloat D_BlinnPhong( const in float shininess, const in float dotNH ) {\\n\\treturn RECIPROCAL_PI * ( shininess * 0.5 + 1.0 ) * pow( dotNH, shininess );\\n}\\nvec3 BRDF_BlinnPhong( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in vec3 specularColor, const in float shininess ) {\\n\\tvec3 halfDir = normalize( lightDir + viewDir );\\n\\tfloat dotNH = saturate( dot( normal, halfDir ) );\\n\\tfloat dotVH = saturate( dot( viewDir, halfDir ) );\\n\\tvec3 F = F_Schlick( specularColor, 1.0, dotVH );\\n\\tfloat G = G_BlinnPhong_Implicit( );\\n\\tfloat D = D_BlinnPhong( shininess, dotNH );\\n\\treturn F * ( G * D );\\n} // validated\";\n\nvar iridescence_fragment = \"#ifdef USE_IRIDESCENCE\\n\\tconst mat3 XYZ_TO_REC709 = mat3(\\n\\t\\t 3.2404542, -0.9692660, 0.0556434,\\n\\t\\t-1.5371385, 1.8760108, -0.2040259,\\n\\t\\t-0.4985314, 0.0415560, 1.0572252\\n\\t);\\n\\tvec3 Fresnel0ToIor( vec3 fresnel0 ) {\\n\\t\\tvec3 sqrtF0 = sqrt( fresnel0 );\\n\\t\\treturn ( vec3( 1.0 ) + sqrtF0 ) / ( vec3( 1.0 ) - sqrtF0 );\\n\\t}\\n\\tvec3 IorToFresnel0( vec3 transmittedIor, float incidentIor ) {\\n\\t\\treturn pow2( ( transmittedIor - vec3( incidentIor ) ) / ( transmittedIor + vec3( incidentIor ) ) );\\n\\t}\\n\\tfloat IorToFresnel0( float transmittedIor, float incidentIor ) {\\n\\t\\treturn pow2( ( transmittedIor - incidentIor ) / ( transmittedIor + incidentIor ));\\n\\t}\\n\\tvec3 evalSensitivity( float OPD, vec3 shift ) {\\n\\t\\tfloat phase = 2.0 * PI * OPD * 1.0e-9;\\n\\t\\tvec3 val = vec3( 5.4856e-13, 4.4201e-13, 5.2481e-13 );\\n\\t\\tvec3 pos = vec3( 1.6810e+06, 1.7953e+06, 2.2084e+06 );\\n\\t\\tvec3 var = vec3( 4.3278e+09, 9.3046e+09, 6.6121e+09 );\\n\\t\\tvec3 xyz = val * sqrt( 2.0 * PI * var ) * cos( pos * phase + shift ) * exp( - pow2( phase ) * var );\\n\\t\\txyz.x += 9.7470e-14 * sqrt( 2.0 * PI * 4.5282e+09 ) * cos( 2.2399e+06 * phase + shift[ 0 ] ) * exp( - 4.5282e+09 * pow2( phase ) );\\n\\t\\txyz /= 1.0685e-7;\\n\\t\\tvec3 rgb = XYZ_TO_REC709 * xyz;\\n\\t\\treturn rgb;\\n\\t}\\n\\tvec3 evalIridescence( float outsideIOR, float eta2, float cosTheta1, float thinFilmThickness, vec3 baseF0 ) {\\n\\t\\tvec3 I;\\n\\t\\tfloat iridescenceIOR = mix( outsideIOR, eta2, smoothstep( 0.0, 0.03, thinFilmThickness ) );\\n\\t\\tfloat sinTheta2Sq = pow2( outsideIOR / iridescenceIOR ) * ( 1.0 - pow2( cosTheta1 ) );\\n\\t\\tfloat cosTheta2Sq = 1.0 - sinTheta2Sq;\\n\\t\\tif ( cosTheta2Sq < 0.0 ) {\\n\\t\\t\\treturn vec3( 1.0 );\\n\\t\\t}\\n\\t\\tfloat cosTheta2 = sqrt( cosTheta2Sq );\\n\\t\\tfloat R0 = IorToFresnel0( iridescenceIOR, outsideIOR );\\n\\t\\tfloat R12 = F_Schlick( R0, 1.0, cosTheta1 );\\n\\t\\tfloat T121 = 1.0 - R12;\\n\\t\\tfloat phi12 = 0.0;\\n\\t\\tif ( iridescenceIOR < outsideIOR ) phi12 = PI;\\n\\t\\tfloat phi21 = PI - phi12;\\n\\t\\tvec3 baseIOR = Fresnel0ToIor( clamp( baseF0, 0.0, 0.9999 ) );\\t\\tvec3 R1 = IorToFresnel0( baseIOR, iridescenceIOR );\\n\\t\\tvec3 R23 = F_Schlick( R1, 1.0, cosTheta2 );\\n\\t\\tvec3 phi23 = vec3( 0.0 );\\n\\t\\tif ( baseIOR[ 0 ] < iridescenceIOR ) phi23[ 0 ] = PI;\\n\\t\\tif ( baseIOR[ 1 ] < iridescenceIOR ) phi23[ 1 ] = PI;\\n\\t\\tif ( baseIOR[ 2 ] < iridescenceIOR ) phi23[ 2 ] = PI;\\n\\t\\tfloat OPD = 2.0 * iridescenceIOR * thinFilmThickness * cosTheta2;\\n\\t\\tvec3 phi = vec3( phi21 ) + phi23;\\n\\t\\tvec3 R123 = clamp( R12 * R23, 1e-5, 0.9999 );\\n\\t\\tvec3 r123 = sqrt( R123 );\\n\\t\\tvec3 Rs = pow2( T121 ) * R23 / ( vec3( 1.0 ) - R123 );\\n\\t\\tvec3 C0 = R12 + Rs;\\n\\t\\tI = C0;\\n\\t\\tvec3 Cm = Rs - T121;\\n\\t\\tfor ( int m = 1; m <= 2; ++ m ) {\\n\\t\\t\\tCm *= r123;\\n\\t\\t\\tvec3 Sm = 2.0 * evalSensitivity( float( m ) * OPD, float( m ) * phi );\\n\\t\\t\\tI += Cm * Sm;\\n\\t\\t}\\n\\t\\treturn max( I, vec3( 0.0 ) );\\n\\t}\\n#endif\";\n\nvar bumpmap_pars_fragment = \"#ifdef USE_BUMPMAP\\n\\tuniform sampler2D bumpMap;\\n\\tuniform float bumpScale;\\n\\tvec2 dHdxy_fwd() {\\n\\t\\tvec2 dSTdx = dFdx( vBumpMapUv );\\n\\t\\tvec2 dSTdy = dFdy( vBumpMapUv );\\n\\t\\tfloat Hll = bumpScale * texture2D( bumpMap, vBumpMapUv ).x;\\n\\t\\tfloat dBx = bumpScale * texture2D( bumpMap, vBumpMapUv + dSTdx ).x - Hll;\\n\\t\\tfloat dBy = bumpScale * texture2D( bumpMap, vBumpMapUv + dSTdy ).x - Hll;\\n\\t\\treturn vec2( dBx, dBy );\\n\\t}\\n\\tvec3 perturbNormalArb( vec3 surf_pos, vec3 surf_norm, vec2 dHdxy, float faceDirection ) {\\n\\t\\tvec3 vSigmaX = normalize( dFdx( surf_pos.xyz ) );\\n\\t\\tvec3 vSigmaY = normalize( dFdy( surf_pos.xyz ) );\\n\\t\\tvec3 vN = surf_norm;\\n\\t\\tvec3 R1 = cross( vSigmaY, vN );\\n\\t\\tvec3 R2 = cross( vN, vSigmaX );\\n\\t\\tfloat fDet = dot( vSigmaX, R1 ) * faceDirection;\\n\\t\\tvec3 vGrad = sign( fDet ) * ( dHdxy.x * R1 + dHdxy.y * R2 );\\n\\t\\treturn normalize( abs( fDet ) * surf_norm - vGrad );\\n\\t}\\n#endif\";\n\nvar clipping_planes_fragment = \"#if NUM_CLIPPING_PLANES > 0\\n\\tvec4 plane;\\n\\t#ifdef ALPHA_TO_COVERAGE\\n\\t\\tfloat distanceToPlane, distanceGradient;\\n\\t\\tfloat clipOpacity = 1.0;\\n\\t\\t#pragma unroll_loop_start\\n\\t\\tfor ( int i = 0; i < UNION_CLIPPING_PLANES; i ++ ) {\\n\\t\\t\\tplane = clippingPlanes[ i ];\\n\\t\\t\\tdistanceToPlane = - dot( vClipPosition, plane.xyz ) + plane.w;\\n\\t\\t\\tdistanceGradient = fwidth( distanceToPlane ) / 2.0;\\n\\t\\t\\tclipOpacity *= smoothstep( - distanceGradient, distanceGradient, distanceToPlane );\\n\\t\\t\\tif ( clipOpacity == 0.0 ) discard;\\n\\t\\t}\\n\\t\\t#pragma unroll_loop_end\\n\\t\\t#if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES\\n\\t\\t\\tfloat unionClipOpacity = 1.0;\\n\\t\\t\\t#pragma unroll_loop_start\\n\\t\\t\\tfor ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; i ++ ) {\\n\\t\\t\\t\\tplane = clippingPlanes[ i ];\\n\\t\\t\\t\\tdistanceToPlane = - dot( vClipPosition, plane.xyz ) + plane.w;\\n\\t\\t\\t\\tdistanceGradient = fwidth( distanceToPlane ) / 2.0;\\n\\t\\t\\t\\tunionClipOpacity *= 1.0 - smoothstep( - distanceGradient, distanceGradient, distanceToPlane );\\n\\t\\t\\t}\\n\\t\\t\\t#pragma unroll_loop_end\\n\\t\\t\\tclipOpacity *= 1.0 - unionClipOpacity;\\n\\t\\t#endif\\n\\t\\tdiffuseColor.a *= clipOpacity;\\n\\t\\tif ( diffuseColor.a == 0.0 ) discard;\\n\\t#else\\n\\t\\t#pragma unroll_loop_start\\n\\t\\tfor ( int i = 0; i < UNION_CLIPPING_PLANES; i ++ ) {\\n\\t\\t\\tplane = clippingPlanes[ i ];\\n\\t\\t\\tif ( dot( vClipPosition, plane.xyz ) > plane.w ) discard;\\n\\t\\t}\\n\\t\\t#pragma unroll_loop_end\\n\\t\\t#if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES\\n\\t\\t\\tbool clipped = true;\\n\\t\\t\\t#pragma unroll_loop_start\\n\\t\\t\\tfor ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; i ++ ) {\\n\\t\\t\\t\\tplane = clippingPlanes[ i ];\\n\\t\\t\\t\\tclipped = ( dot( vClipPosition, plane.xyz ) > plane.w ) && clipped;\\n\\t\\t\\t}\\n\\t\\t\\t#pragma unroll_loop_end\\n\\t\\t\\tif ( clipped ) discard;\\n\\t\\t#endif\\n\\t#endif\\n#endif\";\n\nvar clipping_planes_pars_fragment = \"#if NUM_CLIPPING_PLANES > 0\\n\\tvarying vec3 vClipPosition;\\n\\tuniform vec4 clippingPlanes[ NUM_CLIPPING_PLANES ];\\n#endif\";\n\nvar clipping_planes_pars_vertex = \"#if NUM_CLIPPING_PLANES > 0\\n\\tvarying vec3 vClipPosition;\\n#endif\";\n\nvar clipping_planes_vertex = \"#if NUM_CLIPPING_PLANES > 0\\n\\tvClipPosition = - mvPosition.xyz;\\n#endif\";\n\nvar color_fragment = \"#if defined( USE_COLOR_ALPHA )\\n\\tdiffuseColor *= vColor;\\n#elif defined( USE_COLOR )\\n\\tdiffuseColor.rgb *= vColor;\\n#endif\";\n\nvar color_pars_fragment = \"#if defined( USE_COLOR_ALPHA )\\n\\tvarying vec4 vColor;\\n#elif defined( USE_COLOR )\\n\\tvarying vec3 vColor;\\n#endif\";\n\nvar color_pars_vertex = \"#if defined( USE_COLOR_ALPHA )\\n\\tvarying vec4 vColor;\\n#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )\\n\\tvarying vec3 vColor;\\n#endif\";\n\nvar color_vertex = \"#if defined( USE_COLOR_ALPHA )\\n\\tvColor = vec4( 1.0 );\\n#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )\\n\\tvColor = vec3( 1.0 );\\n#endif\\n#ifdef USE_COLOR\\n\\tvColor *= color;\\n#endif\\n#ifdef USE_INSTANCING_COLOR\\n\\tvColor.xyz *= instanceColor.xyz;\\n#endif\";\n\nvar common = \"#define PI 3.141592653589793\\n#define PI2 6.283185307179586\\n#define PI_HALF 1.5707963267948966\\n#define RECIPROCAL_PI 0.3183098861837907\\n#define RECIPROCAL_PI2 0.15915494309189535\\n#define EPSILON 1e-6\\n#ifndef saturate\\n#define saturate( a ) clamp( a, 0.0, 1.0 )\\n#endif\\n#define whiteComplement( a ) ( 1.0 - saturate( a ) )\\nfloat pow2( const in float x ) { return x*x; }\\nvec3 pow2( const in vec3 x ) { return x*x; }\\nfloat pow3( const in float x ) { return x*x*x; }\\nfloat pow4( const in float x ) { float x2 = x*x; return x2*x2; }\\nfloat max3( const in vec3 v ) { return max( max( v.x, v.y ), v.z ); }\\nfloat average( const in vec3 v ) { return dot( v, vec3( 0.3333333 ) ); }\\nhighp float rand( const in vec2 uv ) {\\n\\tconst highp float a = 12.9898, b = 78.233, c = 43758.5453;\\n\\thighp float dt = dot( uv.xy, vec2( a,b ) ), sn = mod( dt, PI );\\n\\treturn fract( sin( sn ) * c );\\n}\\n#ifdef HIGH_PRECISION\\n\\tfloat precisionSafeLength( vec3 v ) { return length( v ); }\\n#else\\n\\tfloat precisionSafeLength( vec3 v ) {\\n\\t\\tfloat maxComponent = max3( abs( v ) );\\n\\t\\treturn length( v / maxComponent ) * maxComponent;\\n\\t}\\n#endif\\nstruct IncidentLight {\\n\\tvec3 color;\\n\\tvec3 direction;\\n\\tbool visible;\\n};\\nstruct ReflectedLight {\\n\\tvec3 directDiffuse;\\n\\tvec3 directSpecular;\\n\\tvec3 indirectDiffuse;\\n\\tvec3 indirectSpecular;\\n};\\n#ifdef USE_ALPHAHASH\\n\\tvarying vec3 vPosition;\\n#endif\\nvec3 transformDirection( in vec3 dir, in mat4 matrix ) {\\n\\treturn normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );\\n}\\nvec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {\\n\\treturn normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );\\n}\\nmat3 transposeMat3( const in mat3 m ) {\\n\\tmat3 tmp;\\n\\ttmp[ 0 ] = vec3( m[ 0 ].x, m[ 1 ].x, m[ 2 ].x );\\n\\ttmp[ 1 ] = vec3( m[ 0 ].y, m[ 1 ].y, m[ 2 ].y );\\n\\ttmp[ 2 ] = vec3( m[ 0 ].z, m[ 1 ].z, m[ 2 ].z );\\n\\treturn tmp;\\n}\\nfloat luminance( const in vec3 rgb ) {\\n\\tconst vec3 weights = vec3( 0.2126729, 0.7151522, 0.0721750 );\\n\\treturn dot( weights, rgb );\\n}\\nbool isPerspectiveMatrix( mat4 m ) {\\n\\treturn m[ 2 ][ 3 ] == - 1.0;\\n}\\nvec2 equirectUv( in vec3 dir ) {\\n\\tfloat u = atan( dir.z, dir.x ) * RECIPROCAL_PI2 + 0.5;\\n\\tfloat v = asin( clamp( dir.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;\\n\\treturn vec2( u, v );\\n}\\nvec3 BRDF_Lambert( const in vec3 diffuseColor ) {\\n\\treturn RECIPROCAL_PI * diffuseColor;\\n}\\nvec3 F_Schlick( const in vec3 f0, const in float f90, const in float dotVH ) {\\n\\tfloat fresnel = exp2( ( - 5.55473 * dotVH - 6.98316 ) * dotVH );\\n\\treturn f0 * ( 1.0 - fresnel ) + ( f90 * fresnel );\\n}\\nfloat F_Schlick( const in float f0, const in float f90, const in float dotVH ) {\\n\\tfloat fresnel = exp2( ( - 5.55473 * dotVH - 6.98316 ) * dotVH );\\n\\treturn f0 * ( 1.0 - fresnel ) + ( f90 * fresnel );\\n} // validated\";\n\nvar cube_uv_reflection_fragment = \"#ifdef ENVMAP_TYPE_CUBE_UV\\n\\t#define cubeUV_minMipLevel 4.0\\n\\t#define cubeUV_minTileSize 16.0\\n\\tfloat getFace( vec3 direction ) {\\n\\t\\tvec3 absDirection = abs( direction );\\n\\t\\tfloat face = - 1.0;\\n\\t\\tif ( absDirection.x > absDirection.z ) {\\n\\t\\t\\tif ( absDirection.x > absDirection.y )\\n\\t\\t\\t\\tface = direction.x > 0.0 ? 0.0 : 3.0;\\n\\t\\t\\telse\\n\\t\\t\\t\\tface = direction.y > 0.0 ? 1.0 : 4.0;\\n\\t\\t} else {\\n\\t\\t\\tif ( absDirection.z > absDirection.y )\\n\\t\\t\\t\\tface = direction.z > 0.0 ? 2.0 : 5.0;\\n\\t\\t\\telse\\n\\t\\t\\t\\tface = direction.y > 0.0 ? 1.0 : 4.0;\\n\\t\\t}\\n\\t\\treturn face;\\n\\t}\\n\\tvec2 getUV( vec3 direction, float face ) {\\n\\t\\tvec2 uv;\\n\\t\\tif ( face == 0.0 ) {\\n\\t\\t\\tuv = vec2( direction.z, direction.y ) / abs( direction.x );\\n\\t\\t} else if ( face == 1.0 ) {\\n\\t\\t\\tuv = vec2( - direction.x, - direction.z ) / abs( direction.y );\\n\\t\\t} else if ( face == 2.0 ) {\\n\\t\\t\\tuv = vec2( - direction.x, direction.y ) / abs( direction.z );\\n\\t\\t} else if ( face == 3.0 ) {\\n\\t\\t\\tuv = vec2( - direction.z, direction.y ) / abs( direction.x );\\n\\t\\t} else if ( face == 4.0 ) {\\n\\t\\t\\tuv = vec2( - direction.x, direction.z ) / abs( direction.y );\\n\\t\\t} else {\\n\\t\\t\\tuv = vec2( direction.x, direction.y ) / abs( direction.z );\\n\\t\\t}\\n\\t\\treturn 0.5 * ( uv + 1.0 );\\n\\t}\\n\\tvec3 bilinearCubeUV( sampler2D envMap, vec3 direction, float mipInt ) {\\n\\t\\tfloat face = getFace( direction );\\n\\t\\tfloat filterInt = max( cubeUV_minMipLevel - mipInt, 0.0 );\\n\\t\\tmipInt = max( mipInt, cubeUV_minMipLevel );\\n\\t\\tfloat faceSize = exp2( mipInt );\\n\\t\\thighp vec2 uv = getUV( direction, face ) * ( faceSize - 2.0 ) + 1.0;\\n\\t\\tif ( face > 2.0 ) {\\n\\t\\t\\tuv.y += faceSize;\\n\\t\\t\\tface -= 3.0;\\n\\t\\t}\\n\\t\\tuv.x += face * faceSize;\\n\\t\\tuv.x += filterInt * 3.0 * cubeUV_minTileSize;\\n\\t\\tuv.y += 4.0 * ( exp2( CUBEUV_MAX_MIP ) - faceSize );\\n\\t\\tuv.x *= CUBEUV_TEXEL_WIDTH;\\n\\t\\tuv.y *= CUBEUV_TEXEL_HEIGHT;\\n\\t\\t#ifdef texture2DGradEXT\\n\\t\\t\\treturn texture2DGradEXT( envMap, uv, vec2( 0.0 ), vec2( 0.0 ) ).rgb;\\n\\t\\t#else\\n\\t\\t\\treturn texture2D( envMap, uv ).rgb;\\n\\t\\t#endif\\n\\t}\\n\\t#define cubeUV_r0 1.0\\n\\t#define cubeUV_m0 - 2.0\\n\\t#define cubeUV_r1 0.8\\n\\t#define cubeUV_m1 - 1.0\\n\\t#define cubeUV_r4 0.4\\n\\t#define cubeUV_m4 2.0\\n\\t#define cubeUV_r5 0.305\\n\\t#define cubeUV_m5 3.0\\n\\t#define cubeUV_r6 0.21\\n\\t#define cubeUV_m6 4.0\\n\\tfloat roughnessToMip( float roughness ) {\\n\\t\\tfloat mip = 0.0;\\n\\t\\tif ( roughness >= cubeUV_r1 ) {\\n\\t\\t\\tmip = ( cubeUV_r0 - roughness ) * ( cubeUV_m1 - cubeUV_m0 ) / ( cubeUV_r0 - cubeUV_r1 ) + cubeUV_m0;\\n\\t\\t} else if ( roughness >= cubeUV_r4 ) {\\n\\t\\t\\tmip = ( cubeUV_r1 - roughness ) * ( cubeUV_m4 - cubeUV_m1 ) / ( cubeUV_r1 - cubeUV_r4 ) + cubeUV_m1;\\n\\t\\t} else if ( roughness >= cubeUV_r5 ) {\\n\\t\\t\\tmip = ( cubeUV_r4 - roughness ) * ( cubeUV_m5 - cubeUV_m4 ) / ( cubeUV_r4 - cubeUV_r5 ) + cubeUV_m4;\\n\\t\\t} else if ( roughness >= cubeUV_r6 ) {\\n\\t\\t\\tmip = ( cubeUV_r5 - roughness ) * ( cubeUV_m6 - cubeUV_m5 ) / ( cubeUV_r5 - cubeUV_r6 ) + cubeUV_m5;\\n\\t\\t} else {\\n\\t\\t\\tmip = - 2.0 * log2( 1.16 * roughness );\\t\\t}\\n\\t\\treturn mip;\\n\\t}\\n\\tvec4 textureCubeUV( sampler2D envMap, vec3 sampleDir, float roughness ) {\\n\\t\\tfloat mip = clamp( roughnessToMip( roughness ), cubeUV_m0, CUBEUV_MAX_MIP );\\n\\t\\tfloat mipF = fract( mip );\\n\\t\\tfloat mipInt = floor( mip );\\n\\t\\tvec3 color0 = bilinearCubeUV( envMap, sampleDir, mipInt );\\n\\t\\tif ( mipF == 0.0 ) {\\n\\t\\t\\treturn vec4( color0, 1.0 );\\n\\t\\t} else {\\n\\t\\t\\tvec3 color1 = bilinearCubeUV( envMap, sampleDir, mipInt + 1.0 );\\n\\t\\t\\treturn vec4( mix( color0, color1, mipF ), 1.0 );\\n\\t\\t}\\n\\t}\\n#endif\";\n\nvar defaultnormal_vertex = \"vec3 transformedNormal = objectNormal;\\n#ifdef USE_TANGENT\\n\\tvec3 transformedTangent = objectTangent;\\n#endif\\n#ifdef USE_BATCHING\\n\\tmat3 bm = mat3( batchingMatrix );\\n\\ttransformedNormal /= vec3( dot( bm[ 0 ], bm[ 0 ] ), dot( bm[ 1 ], bm[ 1 ] ), dot( bm[ 2 ], bm[ 2 ] ) );\\n\\ttransformedNormal = bm * transformedNormal;\\n\\t#ifdef USE_TANGENT\\n\\t\\ttransformedTangent = bm * transformedTangent;\\n\\t#endif\\n#endif\\n#ifdef USE_INSTANCING\\n\\tmat3 im = mat3( instanceMatrix );\\n\\ttransformedNormal /= vec3( dot( im[ 0 ], im[ 0 ] ), dot( im[ 1 ], im[ 1 ] ), dot( im[ 2 ], im[ 2 ] ) );\\n\\ttransformedNormal = im * transformedNormal;\\n\\t#ifdef USE_TANGENT\\n\\t\\ttransformedTangent = im * transformedTangent;\\n\\t#endif\\n#endif\\ntransformedNormal = normalMatrix * transformedNormal;\\n#ifdef FLIP_SIDED\\n\\ttransformedNormal = - transformedNormal;\\n#endif\\n#ifdef USE_TANGENT\\n\\ttransformedTangent = ( modelViewMatrix * vec4( transformedTangent, 0.0 ) ).xyz;\\n\\t#ifdef FLIP_SIDED\\n\\t\\ttransformedTangent = - transformedTangent;\\n\\t#endif\\n#endif\";\n\nvar displacementmap_pars_vertex = \"#ifdef USE_DISPLACEMENTMAP\\n\\tuniform sampler2D displacementMap;\\n\\tuniform float displacementScale;\\n\\tuniform float displacementBias;\\n#endif\";\n\nvar displacementmap_vertex = \"#ifdef USE_DISPLACEMENTMAP\\n\\ttransformed += normalize( objectNormal ) * ( texture2D( displacementMap, vDisplacementMapUv ).x * displacementScale + displacementBias );\\n#endif\";\n\nvar emissivemap_fragment = \"#ifdef USE_EMISSIVEMAP\\n\\tvec4 emissiveColor = texture2D( emissiveMap, vEmissiveMapUv );\\n\\ttotalEmissiveRadiance *= emissiveColor.rgb;\\n#endif\";\n\nvar emissivemap_pars_fragment = \"#ifdef USE_EMISSIVEMAP\\n\\tuniform sampler2D emissiveMap;\\n#endif\";\n\nvar colorspace_fragment = \"gl_FragColor = linearToOutputTexel( gl_FragColor );\";\n\nvar colorspace_pars_fragment = \"\\nconst mat3 LINEAR_SRGB_TO_LINEAR_DISPLAY_P3 = mat3(\\n\\tvec3( 0.8224621, 0.177538, 0.0 ),\\n\\tvec3( 0.0331941, 0.9668058, 0.0 ),\\n\\tvec3( 0.0170827, 0.0723974, 0.9105199 )\\n);\\nconst mat3 LINEAR_DISPLAY_P3_TO_LINEAR_SRGB = mat3(\\n\\tvec3( 1.2249401, - 0.2249404, 0.0 ),\\n\\tvec3( - 0.0420569, 1.0420571, 0.0 ),\\n\\tvec3( - 0.0196376, - 0.0786361, 1.0982735 )\\n);\\nvec4 LinearSRGBToLinearDisplayP3( in vec4 value ) {\\n\\treturn vec4( value.rgb * LINEAR_SRGB_TO_LINEAR_DISPLAY_P3, value.a );\\n}\\nvec4 LinearDisplayP3ToLinearSRGB( in vec4 value ) {\\n\\treturn vec4( value.rgb * LINEAR_DISPLAY_P3_TO_LINEAR_SRGB, value.a );\\n}\\nvec4 LinearTransferOETF( in vec4 value ) {\\n\\treturn value;\\n}\\nvec4 sRGBTransferOETF( in vec4 value ) {\\n\\treturn vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) * 1.055 - vec3( 0.055 ), value.rgb * 12.92, vec3( lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ) ), value.a );\\n}\\nvec4 LinearToLinear( in vec4 value ) {\\n\\treturn value;\\n}\\nvec4 LinearTosRGB( in vec4 value ) {\\n\\treturn sRGBTransferOETF( value );\\n}\";\n\nvar envmap_fragment = \"#ifdef USE_ENVMAP\\n\\t#ifdef ENV_WORLDPOS\\n\\t\\tvec3 cameraToFrag;\\n\\t\\tif ( isOrthographic ) {\\n\\t\\t\\tcameraToFrag = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );\\n\\t\\t} else {\\n\\t\\t\\tcameraToFrag = normalize( vWorldPosition - cameraPosition );\\n\\t\\t}\\n\\t\\tvec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\\n\\t\\t#ifdef ENVMAP_MODE_REFLECTION\\n\\t\\t\\tvec3 reflectVec = reflect( cameraToFrag, worldNormal );\\n\\t\\t#else\\n\\t\\t\\tvec3 reflectVec = refract( cameraToFrag, worldNormal, refractionRatio );\\n\\t\\t#endif\\n\\t#else\\n\\t\\tvec3 reflectVec = vReflect;\\n\\t#endif\\n\\t#ifdef ENVMAP_TYPE_CUBE\\n\\t\\tvec4 envColor = textureCube( envMap, envMapRotation * vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );\\n\\t#else\\n\\t\\tvec4 envColor = vec4( 0.0 );\\n\\t#endif\\n\\t#ifdef ENVMAP_BLENDING_MULTIPLY\\n\\t\\toutgoingLight = mix( outgoingLight, outgoingLight * envColor.xyz, specularStrength * reflectivity );\\n\\t#elif defined( ENVMAP_BLENDING_MIX )\\n\\t\\toutgoingLight = mix( outgoingLight, envColor.xyz, specularStrength * reflectivity );\\n\\t#elif defined( ENVMAP_BLENDING_ADD )\\n\\t\\toutgoingLight += envColor.xyz * specularStrength * reflectivity;\\n\\t#endif\\n#endif\";\n\nvar envmap_common_pars_fragment = \"#ifdef USE_ENVMAP\\n\\tuniform float envMapIntensity;\\n\\tuniform float flipEnvMap;\\n\\tuniform mat3 envMapRotation;\\n\\t#ifdef ENVMAP_TYPE_CUBE\\n\\t\\tuniform samplerCube envMap;\\n\\t#else\\n\\t\\tuniform sampler2D envMap;\\n\\t#endif\\n\\t\\n#endif\";\n\nvar envmap_pars_fragment = \"#ifdef USE_ENVMAP\\n\\tuniform float reflectivity;\\n\\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG ) || defined( LAMBERT )\\n\\t\\t#define ENV_WORLDPOS\\n\\t#endif\\n\\t#ifdef ENV_WORLDPOS\\n\\t\\tvarying vec3 vWorldPosition;\\n\\t\\tuniform float refractionRatio;\\n\\t#else\\n\\t\\tvarying vec3 vReflect;\\n\\t#endif\\n#endif\";\n\nvar envmap_pars_vertex = \"#ifdef USE_ENVMAP\\n\\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG ) || defined( LAMBERT )\\n\\t\\t#define ENV_WORLDPOS\\n\\t#endif\\n\\t#ifdef ENV_WORLDPOS\\n\\t\\t\\n\\t\\tvarying vec3 vWorldPosition;\\n\\t#else\\n\\t\\tvarying vec3 vReflect;\\n\\t\\tuniform float refractionRatio;\\n\\t#endif\\n#endif\";\n\nvar envmap_vertex = \"#ifdef USE_ENVMAP\\n\\t#ifdef ENV_WORLDPOS\\n\\t\\tvWorldPosition = worldPosition.xyz;\\n\\t#else\\n\\t\\tvec3 cameraToVertex;\\n\\t\\tif ( isOrthographic ) {\\n\\t\\t\\tcameraToVertex = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );\\n\\t\\t} else {\\n\\t\\t\\tcameraToVertex = normalize( worldPosition.xyz - cameraPosition );\\n\\t\\t}\\n\\t\\tvec3 worldNormal = inverseTransformDirection( transformedNormal, viewMatrix );\\n\\t\\t#ifdef ENVMAP_MODE_REFLECTION\\n\\t\\t\\tvReflect = reflect( cameraToVertex, worldNormal );\\n\\t\\t#else\\n\\t\\t\\tvReflect = refract( cameraToVertex, worldNormal, refractionRatio );\\n\\t\\t#endif\\n\\t#endif\\n#endif\";\n\nvar fog_vertex = \"#ifdef USE_FOG\\n\\tvFogDepth = - mvPosition.z;\\n#endif\";\n\nvar fog_pars_vertex = \"#ifdef USE_FOG\\n\\tvarying float vFogDepth;\\n#endif\";\n\nvar fog_fragment = \"#ifdef USE_FOG\\n\\t#ifdef FOG_EXP2\\n\\t\\tfloat fogFactor = 1.0 - exp( - fogDensity * fogDensity * vFogDepth * vFogDepth );\\n\\t#else\\n\\t\\tfloat fogFactor = smoothstep( fogNear, fogFar, vFogDepth );\\n\\t#endif\\n\\tgl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );\\n#endif\";\n\nvar fog_pars_fragment = \"#ifdef USE_FOG\\n\\tuniform vec3 fogColor;\\n\\tvarying float vFogDepth;\\n\\t#ifdef FOG_EXP2\\n\\t\\tuniform float fogDensity;\\n\\t#else\\n\\t\\tuniform float fogNear;\\n\\t\\tuniform float fogFar;\\n\\t#endif\\n#endif\";\n\nvar gradientmap_pars_fragment = \"#ifdef USE_GRADIENTMAP\\n\\tuniform sampler2D gradientMap;\\n#endif\\nvec3 getGradientIrradiance( vec3 normal, vec3 lightDirection ) {\\n\\tfloat dotNL = dot( normal, lightDirection );\\n\\tvec2 coord = vec2( dotNL * 0.5 + 0.5, 0.0 );\\n\\t#ifdef USE_GRADIENTMAP\\n\\t\\treturn vec3( texture2D( gradientMap, coord ).r );\\n\\t#else\\n\\t\\tvec2 fw = fwidth( coord ) * 0.5;\\n\\t\\treturn mix( vec3( 0.7 ), vec3( 1.0 ), smoothstep( 0.7 - fw.x, 0.7 + fw.x, coord.x ) );\\n\\t#endif\\n}\";\n\nvar lightmap_fragment = \"#ifdef USE_LIGHTMAP\\n\\tvec4 lightMapTexel = texture2D( lightMap, vLightMapUv );\\n\\tvec3 lightMapIrradiance = lightMapTexel.rgb * lightMapIntensity;\\n\\treflectedLight.indirectDiffuse += lightMapIrradiance;\\n#endif\";\n\nvar lightmap_pars_fragment = \"#ifdef USE_LIGHTMAP\\n\\tuniform sampler2D lightMap;\\n\\tuniform float lightMapIntensity;\\n#endif\";\n\nvar lights_lambert_fragment = \"LambertMaterial material;\\nmaterial.diffuseColor = diffuseColor.rgb;\\nmaterial.specularStrength = specularStrength;\";\n\nvar lights_lambert_pars_fragment = \"varying vec3 vViewPosition;\\nstruct LambertMaterial {\\n\\tvec3 diffuseColor;\\n\\tfloat specularStrength;\\n};\\nvoid RE_Direct_Lambert( const in IncidentLight directLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in LambertMaterial material, inout ReflectedLight reflectedLight ) {\\n\\tfloat dotNL = saturate( dot( geometryNormal, directLight.direction ) );\\n\\tvec3 irradiance = dotNL * directLight.color;\\n\\treflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\\n}\\nvoid RE_IndirectDiffuse_Lambert( const in vec3 irradiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in LambertMaterial material, inout ReflectedLight reflectedLight ) {\\n\\treflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\\n}\\n#define RE_Direct\\t\\t\\t\\tRE_Direct_Lambert\\n#define RE_IndirectDiffuse\\t\\tRE_IndirectDiffuse_Lambert\";\n\nvar lights_pars_begin = \"uniform bool receiveShadow;\\nuniform vec3 ambientLightColor;\\n#if defined( USE_LIGHT_PROBES )\\n\\tuniform vec3 lightProbe[ 9 ];\\n#endif\\nvec3 shGetIrradianceAt( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {\\n\\tfloat x = normal.x, y = normal.y, z = normal.z;\\n\\tvec3 result = shCoefficients[ 0 ] * 0.886227;\\n\\tresult += shCoefficients[ 1 ] * 2.0 * 0.511664 * y;\\n\\tresult += shCoefficients[ 2 ] * 2.0 * 0.511664 * z;\\n\\tresult += shCoefficients[ 3 ] * 2.0 * 0.511664 * x;\\n\\tresult += shCoefficients[ 4 ] * 2.0 * 0.429043 * x * y;\\n\\tresult += shCoefficients[ 5 ] * 2.0 * 0.429043 * y * z;\\n\\tresult += shCoefficients[ 6 ] * ( 0.743125 * z * z - 0.247708 );\\n\\tresult += shCoefficients[ 7 ] * 2.0 * 0.429043 * x * z;\\n\\tresult += shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );\\n\\treturn result;\\n}\\nvec3 getLightProbeIrradiance( const in vec3 lightProbe[ 9 ], const in vec3 normal ) {\\n\\tvec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\\n\\tvec3 irradiance = shGetIrradianceAt( worldNormal, lightProbe );\\n\\treturn irradiance;\\n}\\nvec3 getAmbientLightIrradiance( const in vec3 ambientLightColor ) {\\n\\tvec3 irradiance = ambientLightColor;\\n\\treturn irradiance;\\n}\\nfloat getDistanceAttenuation( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {\\n\\t#if defined ( LEGACY_LIGHTS )\\n\\t\\tif ( cutoffDistance > 0.0 && decayExponent > 0.0 ) {\\n\\t\\t\\treturn pow( saturate( - lightDistance / cutoffDistance + 1.0 ), decayExponent );\\n\\t\\t}\\n\\t\\treturn 1.0;\\n\\t#else\\n\\t\\tfloat distanceFalloff = 1.0 / max( pow( lightDistance, decayExponent ), 0.01 );\\n\\t\\tif ( cutoffDistance > 0.0 ) {\\n\\t\\t\\tdistanceFalloff *= pow2( saturate( 1.0 - pow4( lightDistance / cutoffDistance ) ) );\\n\\t\\t}\\n\\t\\treturn distanceFalloff;\\n\\t#endif\\n}\\nfloat getSpotAttenuation( const in float coneCosine, const in float penumbraCosine, const in float angleCosine ) {\\n\\treturn smoothstep( coneCosine, penumbraCosine, angleCosine );\\n}\\n#if NUM_DIR_LIGHTS > 0\\n\\tstruct DirectionalLight {\\n\\t\\tvec3 direction;\\n\\t\\tvec3 color;\\n\\t};\\n\\tuniform DirectionalLight directionalLights[ NUM_DIR_LIGHTS ];\\n\\tvoid getDirectionalLightInfo( const in DirectionalLight directionalLight, out IncidentLight light ) {\\n\\t\\tlight.color = directionalLight.color;\\n\\t\\tlight.direction = directionalLight.direction;\\n\\t\\tlight.visible = true;\\n\\t}\\n#endif\\n#if NUM_POINT_LIGHTS > 0\\n\\tstruct PointLight {\\n\\t\\tvec3 position;\\n\\t\\tvec3 color;\\n\\t\\tfloat distance;\\n\\t\\tfloat decay;\\n\\t};\\n\\tuniform PointLight pointLights[ NUM_POINT_LIGHTS ];\\n\\tvoid getPointLightInfo( const in PointLight pointLight, const in vec3 geometryPosition, out IncidentLight light ) {\\n\\t\\tvec3 lVector = pointLight.position - geometryPosition;\\n\\t\\tlight.direction = normalize( lVector );\\n\\t\\tfloat lightDistance = length( lVector );\\n\\t\\tlight.color = pointLight.color;\\n\\t\\tlight.color *= getDistanceAttenuation( lightDistance, pointLight.distance, pointLight.decay );\\n\\t\\tlight.visible = ( light.color != vec3( 0.0 ) );\\n\\t}\\n#endif\\n#if NUM_SPOT_LIGHTS > 0\\n\\tstruct SpotLight {\\n\\t\\tvec3 position;\\n\\t\\tvec3 direction;\\n\\t\\tvec3 color;\\n\\t\\tfloat distance;\\n\\t\\tfloat decay;\\n\\t\\tfloat coneCos;\\n\\t\\tfloat penumbraCos;\\n\\t};\\n\\tuniform SpotLight spotLights[ NUM_SPOT_LIGHTS ];\\n\\tvoid getSpotLightInfo( const in SpotLight spotLight, const in vec3 geometryPosition, out IncidentLight light ) {\\n\\t\\tvec3 lVector = spotLight.position - geometryPosition;\\n\\t\\tlight.direction = normalize( lVector );\\n\\t\\tfloat angleCos = dot( light.direction, spotLight.direction );\\n\\t\\tfloat spotAttenuation = getSpotAttenuation( spotLight.coneCos, spotLight.penumbraCos, angleCos );\\n\\t\\tif ( spotAttenuation > 0.0 ) {\\n\\t\\t\\tfloat lightDistance = length( lVector );\\n\\t\\t\\tlight.color = spotLight.color * spotAttenuation;\\n\\t\\t\\tlight.color *= getDistanceAttenuation( lightDistance, spotLight.distance, spotLight.decay );\\n\\t\\t\\tlight.visible = ( light.color != vec3( 0.0 ) );\\n\\t\\t} else {\\n\\t\\t\\tlight.color = vec3( 0.0 );\\n\\t\\t\\tlight.visible = false;\\n\\t\\t}\\n\\t}\\n#endif\\n#if NUM_RECT_AREA_LIGHTS > 0\\n\\tstruct RectAreaLight {\\n\\t\\tvec3 color;\\n\\t\\tvec3 position;\\n\\t\\tvec3 halfWidth;\\n\\t\\tvec3 halfHeight;\\n\\t};\\n\\tuniform sampler2D ltc_1;\\tuniform sampler2D ltc_2;\\n\\tuniform RectAreaLight rectAreaLights[ NUM_RECT_AREA_LIGHTS ];\\n#endif\\n#if NUM_HEMI_LIGHTS > 0\\n\\tstruct HemisphereLight {\\n\\t\\tvec3 direction;\\n\\t\\tvec3 skyColor;\\n\\t\\tvec3 groundColor;\\n\\t};\\n\\tuniform HemisphereLight hemisphereLights[ NUM_HEMI_LIGHTS ];\\n\\tvec3 getHemisphereLightIrradiance( const in HemisphereLight hemiLight, const in vec3 normal ) {\\n\\t\\tfloat dotNL = dot( normal, hemiLight.direction );\\n\\t\\tfloat hemiDiffuseWeight = 0.5 * dotNL + 0.5;\\n\\t\\tvec3 irradiance = mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );\\n\\t\\treturn irradiance;\\n\\t}\\n#endif\";\n\nvar envmap_physical_pars_fragment = \"#ifdef USE_ENVMAP\\n\\tvec3 getIBLIrradiance( const in vec3 normal ) {\\n\\t\\t#ifdef ENVMAP_TYPE_CUBE_UV\\n\\t\\t\\tvec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\\n\\t\\t\\tvec4 envMapColor = textureCubeUV( envMap, envMapRotation * worldNormal, 1.0 );\\n\\t\\t\\treturn PI * envMapColor.rgb * envMapIntensity;\\n\\t\\t#else\\n\\t\\t\\treturn vec3( 0.0 );\\n\\t\\t#endif\\n\\t}\\n\\tvec3 getIBLRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness ) {\\n\\t\\t#ifdef ENVMAP_TYPE_CUBE_UV\\n\\t\\t\\tvec3 reflectVec = reflect( - viewDir, normal );\\n\\t\\t\\treflectVec = normalize( mix( reflectVec, normal, roughness * roughness) );\\n\\t\\t\\treflectVec = inverseTransformDirection( reflectVec, viewMatrix );\\n\\t\\t\\tvec4 envMapColor = textureCubeUV( envMap, envMapRotation * reflectVec, roughness );\\n\\t\\t\\treturn envMapColor.rgb * envMapIntensity;\\n\\t\\t#else\\n\\t\\t\\treturn vec3( 0.0 );\\n\\t\\t#endif\\n\\t}\\n\\t#ifdef USE_ANISOTROPY\\n\\t\\tvec3 getIBLAnisotropyRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness, const in vec3 bitangent, const in float anisotropy ) {\\n\\t\\t\\t#ifdef ENVMAP_TYPE_CUBE_UV\\n\\t\\t\\t\\tvec3 bentNormal = cross( bitangent, viewDir );\\n\\t\\t\\t\\tbentNormal = normalize( cross( bentNormal, bitangent ) );\\n\\t\\t\\t\\tbentNormal = normalize( mix( bentNormal, normal, pow2( pow2( 1.0 - anisotropy * ( 1.0 - roughness ) ) ) ) );\\n\\t\\t\\t\\treturn getIBLRadiance( viewDir, bentNormal, roughness );\\n\\t\\t\\t#else\\n\\t\\t\\t\\treturn vec3( 0.0 );\\n\\t\\t\\t#endif\\n\\t\\t}\\n\\t#endif\\n#endif\";\n\nvar lights_toon_fragment = \"ToonMaterial material;\\nmaterial.diffuseColor = diffuseColor.rgb;\";\n\nvar lights_toon_pars_fragment = \"varying vec3 vViewPosition;\\nstruct ToonMaterial {\\n\\tvec3 diffuseColor;\\n};\\nvoid RE_Direct_Toon( const in IncidentLight directLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {\\n\\tvec3 irradiance = getGradientIrradiance( geometryNormal, directLight.direction ) * directLight.color;\\n\\treflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\\n}\\nvoid RE_IndirectDiffuse_Toon( const in vec3 irradiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {\\n\\treflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\\n}\\n#define RE_Direct\\t\\t\\t\\tRE_Direct_Toon\\n#define RE_IndirectDiffuse\\t\\tRE_IndirectDiffuse_Toon\";\n\nvar lights_phong_fragment = \"BlinnPhongMaterial material;\\nmaterial.diffuseColor = diffuseColor.rgb;\\nmaterial.specularColor = specular;\\nmaterial.specularShininess = shininess;\\nmaterial.specularStrength = specularStrength;\";\n\nvar lights_phong_pars_fragment = \"varying vec3 vViewPosition;\\nstruct BlinnPhongMaterial {\\n\\tvec3 diffuseColor;\\n\\tvec3 specularColor;\\n\\tfloat specularShininess;\\n\\tfloat specularStrength;\\n};\\nvoid RE_Direct_BlinnPhong( const in IncidentLight directLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\\n\\tfloat dotNL = saturate( dot( geometryNormal, directLight.direction ) );\\n\\tvec3 irradiance = dotNL * directLight.color;\\n\\treflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\\n\\treflectedLight.directSpecular += irradiance * BRDF_BlinnPhong( directLight.direction, geometryViewDir, geometryNormal, material.specularColor, material.specularShininess ) * material.specularStrength;\\n}\\nvoid RE_IndirectDiffuse_BlinnPhong( const in vec3 irradiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\\n\\treflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\\n}\\n#define RE_Direct\\t\\t\\t\\tRE_Direct_BlinnPhong\\n#define RE_IndirectDiffuse\\t\\tRE_IndirectDiffuse_BlinnPhong\";\n\nvar lights_physical_fragment = \"PhysicalMaterial material;\\nmaterial.diffuseColor = diffuseColor.rgb * ( 1.0 - metalnessFactor );\\nvec3 dxy = max( abs( dFdx( nonPerturbedNormal ) ), abs( dFdy( nonPerturbedNormal ) ) );\\nfloat geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );\\nmaterial.roughness = max( roughnessFactor, 0.0525 );material.roughness += geometryRoughness;\\nmaterial.roughness = min( material.roughness, 1.0 );\\n#ifdef IOR\\n\\tmaterial.ior = ior;\\n\\t#ifdef USE_SPECULAR\\n\\t\\tfloat specularIntensityFactor = specularIntensity;\\n\\t\\tvec3 specularColorFactor = specularColor;\\n\\t\\t#ifdef USE_SPECULAR_COLORMAP\\n\\t\\t\\tspecularColorFactor *= texture2D( specularColorMap, vSpecularColorMapUv ).rgb;\\n\\t\\t#endif\\n\\t\\t#ifdef USE_SPECULAR_INTENSITYMAP\\n\\t\\t\\tspecularIntensityFactor *= texture2D( specularIntensityMap, vSpecularIntensityMapUv ).a;\\n\\t\\t#endif\\n\\t\\tmaterial.specularF90 = mix( specularIntensityFactor, 1.0, metalnessFactor );\\n\\t#else\\n\\t\\tfloat specularIntensityFactor = 1.0;\\n\\t\\tvec3 specularColorFactor = vec3( 1.0 );\\n\\t\\tmaterial.specularF90 = 1.0;\\n\\t#endif\\n\\tmaterial.specularColor = mix( min( pow2( ( material.ior - 1.0 ) / ( material.ior + 1.0 ) ) * specularColorFactor, vec3( 1.0 ) ) * specularIntensityFactor, diffuseColor.rgb, metalnessFactor );\\n#else\\n\\tmaterial.specularColor = mix( vec3( 0.04 ), diffuseColor.rgb, metalnessFactor );\\n\\tmaterial.specularF90 = 1.0;\\n#endif\\n#ifdef USE_CLEARCOAT\\n\\tmaterial.clearcoat = clearcoat;\\n\\tmaterial.clearcoatRoughness = clearcoatRoughness;\\n\\tmaterial.clearcoatF0 = vec3( 0.04 );\\n\\tmaterial.clearcoatF90 = 1.0;\\n\\t#ifdef USE_CLEARCOATMAP\\n\\t\\tmaterial.clearcoat *= texture2D( clearcoatMap, vClearcoatMapUv ).x;\\n\\t#endif\\n\\t#ifdef USE_CLEARCOAT_ROUGHNESSMAP\\n\\t\\tmaterial.clearcoatRoughness *= texture2D( clearcoatRoughnessMap, vClearcoatRoughnessMapUv ).y;\\n\\t#endif\\n\\tmaterial.clearcoat = saturate( material.clearcoat );\\tmaterial.clearcoatRoughness = max( material.clearcoatRoughness, 0.0525 );\\n\\tmaterial.clearcoatRoughness += geometryRoughness;\\n\\tmaterial.clearcoatRoughness = min( material.clearcoatRoughness, 1.0 );\\n#endif\\n#ifdef USE_IRIDESCENCE\\n\\tmaterial.iridescence = iridescence;\\n\\tmaterial.iridescenceIOR = iridescenceIOR;\\n\\t#ifdef USE_IRIDESCENCEMAP\\n\\t\\tmaterial.iridescence *= texture2D( iridescenceMap, vIridescenceMapUv ).r;\\n\\t#endif\\n\\t#ifdef USE_IRIDESCENCE_THICKNESSMAP\\n\\t\\tmaterial.iridescenceThickness = (iridescenceThicknessMaximum - iridescenceThicknessMinimum) * texture2D( iridescenceThicknessMap, vIridescenceThicknessMapUv ).g + iridescenceThicknessMinimum;\\n\\t#else\\n\\t\\tmaterial.iridescenceThickness = iridescenceThicknessMaximum;\\n\\t#endif\\n#endif\\n#ifdef USE_SHEEN\\n\\tmaterial.sheenColor = sheenColor;\\n\\t#ifdef USE_SHEEN_COLORMAP\\n\\t\\tmaterial.sheenColor *= texture2D( sheenColorMap, vSheenColorMapUv ).rgb;\\n\\t#endif\\n\\tmaterial.sheenRoughness = clamp( sheenRoughness, 0.07, 1.0 );\\n\\t#ifdef USE_SHEEN_ROUGHNESSMAP\\n\\t\\tmaterial.sheenRoughness *= texture2D( sheenRoughnessMap, vSheenRoughnessMapUv ).a;\\n\\t#endif\\n#endif\\n#ifdef USE_ANISOTROPY\\n\\t#ifdef USE_ANISOTROPYMAP\\n\\t\\tmat2 anisotropyMat = mat2( anisotropyVector.x, anisotropyVector.y, - anisotropyVector.y, anisotropyVector.x );\\n\\t\\tvec3 anisotropyPolar = texture2D( anisotropyMap, vAnisotropyMapUv ).rgb;\\n\\t\\tvec2 anisotropyV = anisotropyMat * normalize( 2.0 * anisotropyPolar.rg - vec2( 1.0 ) ) * anisotropyPolar.b;\\n\\t#else\\n\\t\\tvec2 anisotropyV = anisotropyVector;\\n\\t#endif\\n\\tmaterial.anisotropy = length( anisotropyV );\\n\\tif( material.anisotropy == 0.0 ) {\\n\\t\\tanisotropyV = vec2( 1.0, 0.0 );\\n\\t} else {\\n\\t\\tanisotropyV /= material.anisotropy;\\n\\t\\tmaterial.anisotropy = saturate( material.anisotropy );\\n\\t}\\n\\tmaterial.alphaT = mix( pow2( material.roughness ), 1.0, pow2( material.anisotropy ) );\\n\\tmaterial.anisotropyT = tbn[ 0 ] * anisotropyV.x + tbn[ 1 ] * anisotropyV.y;\\n\\tmaterial.anisotropyB = tbn[ 1 ] * anisotropyV.x - tbn[ 0 ] * anisotropyV.y;\\n#endif\";\n\nvar lights_physical_pars_fragment = \"struct PhysicalMaterial {\\n\\tvec3 diffuseColor;\\n\\tfloat roughness;\\n\\tvec3 specularColor;\\n\\tfloat specularF90;\\n\\t#ifdef USE_CLEARCOAT\\n\\t\\tfloat clearcoat;\\n\\t\\tfloat clearcoatRoughness;\\n\\t\\tvec3 clearcoatF0;\\n\\t\\tfloat clearcoatF90;\\n\\t#endif\\n\\t#ifdef USE_IRIDESCENCE\\n\\t\\tfloat iridescence;\\n\\t\\tfloat iridescenceIOR;\\n\\t\\tfloat iridescenceThickness;\\n\\t\\tvec3 iridescenceFresnel;\\n\\t\\tvec3 iridescenceF0;\\n\\t#endif\\n\\t#ifdef USE_SHEEN\\n\\t\\tvec3 sheenColor;\\n\\t\\tfloat sheenRoughness;\\n\\t#endif\\n\\t#ifdef IOR\\n\\t\\tfloat ior;\\n\\t#endif\\n\\t#ifdef USE_TRANSMISSION\\n\\t\\tfloat transmission;\\n\\t\\tfloat transmissionAlpha;\\n\\t\\tfloat thickness;\\n\\t\\tfloat attenuationDistance;\\n\\t\\tvec3 attenuationColor;\\n\\t#endif\\n\\t#ifdef USE_ANISOTROPY\\n\\t\\tfloat anisotropy;\\n\\t\\tfloat alphaT;\\n\\t\\tvec3 anisotropyT;\\n\\t\\tvec3 anisotropyB;\\n\\t#endif\\n};\\nvec3 clearcoatSpecularDirect = vec3( 0.0 );\\nvec3 clearcoatSpecularIndirect = vec3( 0.0 );\\nvec3 sheenSpecularDirect = vec3( 0.0 );\\nvec3 sheenSpecularIndirect = vec3(0.0 );\\nvec3 Schlick_to_F0( const in vec3 f, const in float f90, const in float dotVH ) {\\n float x = clamp( 1.0 - dotVH, 0.0, 1.0 );\\n float x2 = x * x;\\n float x5 = clamp( x * x2 * x2, 0.0, 0.9999 );\\n return ( f - vec3( f90 ) * x5 ) / ( 1.0 - x5 );\\n}\\nfloat V_GGX_SmithCorrelated( const in float alpha, const in float dotNL, const in float dotNV ) {\\n\\tfloat a2 = pow2( alpha );\\n\\tfloat gv = dotNL * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );\\n\\tfloat gl = dotNV * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );\\n\\treturn 0.5 / max( gv + gl, EPSILON );\\n}\\nfloat D_GGX( const in float alpha, const in float dotNH ) {\\n\\tfloat a2 = pow2( alpha );\\n\\tfloat denom = pow2( dotNH ) * ( a2 - 1.0 ) + 1.0;\\n\\treturn RECIPROCAL_PI * a2 / pow2( denom );\\n}\\n#ifdef USE_ANISOTROPY\\n\\tfloat V_GGX_SmithCorrelated_Anisotropic( const in float alphaT, const in float alphaB, const in float dotTV, const in float dotBV, const in float dotTL, const in float dotBL, const in float dotNV, const in float dotNL ) {\\n\\t\\tfloat gv = dotNL * length( vec3( alphaT * dotTV, alphaB * dotBV, dotNV ) );\\n\\t\\tfloat gl = dotNV * length( vec3( alphaT * dotTL, alphaB * dotBL, dotNL ) );\\n\\t\\tfloat v = 0.5 / ( gv + gl );\\n\\t\\treturn saturate(v);\\n\\t}\\n\\tfloat D_GGX_Anisotropic( const in float alphaT, const in float alphaB, const in float dotNH, const in float dotTH, const in float dotBH ) {\\n\\t\\tfloat a2 = alphaT * alphaB;\\n\\t\\thighp vec3 v = vec3( alphaB * dotTH, alphaT * dotBH, a2 * dotNH );\\n\\t\\thighp float v2 = dot( v, v );\\n\\t\\tfloat w2 = a2 / v2;\\n\\t\\treturn RECIPROCAL_PI * a2 * pow2 ( w2 );\\n\\t}\\n#endif\\n#ifdef USE_CLEARCOAT\\n\\tvec3 BRDF_GGX_Clearcoat( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in PhysicalMaterial material) {\\n\\t\\tvec3 f0 = material.clearcoatF0;\\n\\t\\tfloat f90 = material.clearcoatF90;\\n\\t\\tfloat roughness = material.clearcoatRoughness;\\n\\t\\tfloat alpha = pow2( roughness );\\n\\t\\tvec3 halfDir = normalize( lightDir + viewDir );\\n\\t\\tfloat dotNL = saturate( dot( normal, lightDir ) );\\n\\t\\tfloat dotNV = saturate( dot( normal, viewDir ) );\\n\\t\\tfloat dotNH = saturate( dot( normal, halfDir ) );\\n\\t\\tfloat dotVH = saturate( dot( viewDir, halfDir ) );\\n\\t\\tvec3 F = F_Schlick( f0, f90, dotVH );\\n\\t\\tfloat V = V_GGX_SmithCorrelated( alpha, dotNL, dotNV );\\n\\t\\tfloat D = D_GGX( alpha, dotNH );\\n\\t\\treturn F * ( V * D );\\n\\t}\\n#endif\\nvec3 BRDF_GGX( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in PhysicalMaterial material ) {\\n\\tvec3 f0 = material.specularColor;\\n\\tfloat f90 = material.specularF90;\\n\\tfloat roughness = material.roughness;\\n\\tfloat alpha = pow2( roughness );\\n\\tvec3 halfDir = normalize( lightDir + viewDir );\\n\\tfloat dotNL = saturate( dot( normal, lightDir ) );\\n\\tfloat dotNV = saturate( dot( normal, viewDir ) );\\n\\tfloat dotNH = saturate( dot( normal, halfDir ) );\\n\\tfloat dotVH = saturate( dot( viewDir, halfDir ) );\\n\\tvec3 F = F_Schlick( f0, f90, dotVH );\\n\\t#ifdef USE_IRIDESCENCE\\n\\t\\tF = mix( F, material.iridescenceFresnel, material.iridescence );\\n\\t#endif\\n\\t#ifdef USE_ANISOTROPY\\n\\t\\tfloat dotTL = dot( material.anisotropyT, lightDir );\\n\\t\\tfloat dotTV = dot( material.anisotropyT, viewDir );\\n\\t\\tfloat dotTH = dot( material.anisotropyT, halfDir );\\n\\t\\tfloat dotBL = dot( material.anisotropyB, lightDir );\\n\\t\\tfloat dotBV = dot( material.anisotropyB, viewDir );\\n\\t\\tfloat dotBH = dot( material.anisotropyB, halfDir );\\n\\t\\tfloat V = V_GGX_SmithCorrelated_Anisotropic( material.alphaT, alpha, dotTV, dotBV, dotTL, dotBL, dotNV, dotNL );\\n\\t\\tfloat D = D_GGX_Anisotropic( material.alphaT, alpha, dotNH, dotTH, dotBH );\\n\\t#else\\n\\t\\tfloat V = V_GGX_SmithCorrelated( alpha, dotNL, dotNV );\\n\\t\\tfloat D = D_GGX( alpha, dotNH );\\n\\t#endif\\n\\treturn F * ( V * D );\\n}\\nvec2 LTC_Uv( const in vec3 N, const in vec3 V, const in float roughness ) {\\n\\tconst float LUT_SIZE = 64.0;\\n\\tconst float LUT_SCALE = ( LUT_SIZE - 1.0 ) / LUT_SIZE;\\n\\tconst float LUT_BIAS = 0.5 / LUT_SIZE;\\n\\tfloat dotNV = saturate( dot( N, V ) );\\n\\tvec2 uv = vec2( roughness, sqrt( 1.0 - dotNV ) );\\n\\tuv = uv * LUT_SCALE + LUT_BIAS;\\n\\treturn uv;\\n}\\nfloat LTC_ClippedSphereFormFactor( const in vec3 f ) {\\n\\tfloat l = length( f );\\n\\treturn max( ( l * l + f.z ) / ( l + 1.0 ), 0.0 );\\n}\\nvec3 LTC_EdgeVectorFormFactor( const in vec3 v1, const in vec3 v2 ) {\\n\\tfloat x = dot( v1, v2 );\\n\\tfloat y = abs( x );\\n\\tfloat a = 0.8543985 + ( 0.4965155 + 0.0145206 * y ) * y;\\n\\tfloat b = 3.4175940 + ( 4.1616724 + y ) * y;\\n\\tfloat v = a / b;\\n\\tfloat theta_sintheta = ( x > 0.0 ) ? v : 0.5 * inversesqrt( max( 1.0 - x * x, 1e-7 ) ) - v;\\n\\treturn cross( v1, v2 ) * theta_sintheta;\\n}\\nvec3 LTC_Evaluate( const in vec3 N, const in vec3 V, const in vec3 P, const in mat3 mInv, const in vec3 rectCoords[ 4 ] ) {\\n\\tvec3 v1 = rectCoords[ 1 ] - rectCoords[ 0 ];\\n\\tvec3 v2 = rectCoords[ 3 ] - rectCoords[ 0 ];\\n\\tvec3 lightNormal = cross( v1, v2 );\\n\\tif( dot( lightNormal, P - rectCoords[ 0 ] ) < 0.0 ) return vec3( 0.0 );\\n\\tvec3 T1, T2;\\n\\tT1 = normalize( V - N * dot( V, N ) );\\n\\tT2 = - cross( N, T1 );\\n\\tmat3 mat = mInv * transposeMat3( mat3( T1, T2, N ) );\\n\\tvec3 coords[ 4 ];\\n\\tcoords[ 0 ] = mat * ( rectCoords[ 0 ] - P );\\n\\tcoords[ 1 ] = mat * ( rectCoords[ 1 ] - P );\\n\\tcoords[ 2 ] = mat * ( rectCoords[ 2 ] - P );\\n\\tcoords[ 3 ] = mat * ( rectCoords[ 3 ] - P );\\n\\tcoords[ 0 ] = normalize( coords[ 0 ] );\\n\\tcoords[ 1 ] = normalize( coords[ 1 ] );\\n\\tcoords[ 2 ] = normalize( coords[ 2 ] );\\n\\tcoords[ 3 ] = normalize( coords[ 3 ] );\\n\\tvec3 vectorFormFactor = vec3( 0.0 );\\n\\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 0 ], coords[ 1 ] );\\n\\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 1 ], coords[ 2 ] );\\n\\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 2 ], coords[ 3 ] );\\n\\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 3 ], coords[ 0 ] );\\n\\tfloat result = LTC_ClippedSphereFormFactor( vectorFormFactor );\\n\\treturn vec3( result );\\n}\\n#if defined( USE_SHEEN )\\nfloat D_Charlie( float roughness, float dotNH ) {\\n\\tfloat alpha = pow2( roughness );\\n\\tfloat invAlpha = 1.0 / alpha;\\n\\tfloat cos2h = dotNH * dotNH;\\n\\tfloat sin2h = max( 1.0 - cos2h, 0.0078125 );\\n\\treturn ( 2.0 + invAlpha ) * pow( sin2h, invAlpha * 0.5 ) / ( 2.0 * PI );\\n}\\nfloat V_Neubelt( float dotNV, float dotNL ) {\\n\\treturn saturate( 1.0 / ( 4.0 * ( dotNL + dotNV - dotNL * dotNV ) ) );\\n}\\nvec3 BRDF_Sheen( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, vec3 sheenColor, const in float sheenRoughness ) {\\n\\tvec3 halfDir = normalize( lightDir + viewDir );\\n\\tfloat dotNL = saturate( dot( normal, lightDir ) );\\n\\tfloat dotNV = saturate( dot( normal, viewDir ) );\\n\\tfloat dotNH = saturate( dot( normal, halfDir ) );\\n\\tfloat D = D_Charlie( sheenRoughness, dotNH );\\n\\tfloat V = V_Neubelt( dotNV, dotNL );\\n\\treturn sheenColor * ( D * V );\\n}\\n#endif\\nfloat IBLSheenBRDF( const in vec3 normal, const in vec3 viewDir, const in float roughness ) {\\n\\tfloat dotNV = saturate( dot( normal, viewDir ) );\\n\\tfloat r2 = roughness * roughness;\\n\\tfloat a = roughness < 0.25 ? -339.2 * r2 + 161.4 * roughness - 25.9 : -8.48 * r2 + 14.3 * roughness - 9.95;\\n\\tfloat b = roughness < 0.25 ? 44.0 * r2 - 23.7 * roughness + 3.26 : 1.97 * r2 - 3.27 * roughness + 0.72;\\n\\tfloat DG = exp( a * dotNV + b ) + ( roughness < 0.25 ? 0.0 : 0.1 * ( roughness - 0.25 ) );\\n\\treturn saturate( DG * RECIPROCAL_PI );\\n}\\nvec2 DFGApprox( const in vec3 normal, const in vec3 viewDir, const in float roughness ) {\\n\\tfloat dotNV = saturate( dot( normal, viewDir ) );\\n\\tconst vec4 c0 = vec4( - 1, - 0.0275, - 0.572, 0.022 );\\n\\tconst vec4 c1 = vec4( 1, 0.0425, 1.04, - 0.04 );\\n\\tvec4 r = roughness * c0 + c1;\\n\\tfloat a004 = min( r.x * r.x, exp2( - 9.28 * dotNV ) ) * r.x + r.y;\\n\\tvec2 fab = vec2( - 1.04, 1.04 ) * a004 + r.zw;\\n\\treturn fab;\\n}\\nvec3 EnvironmentBRDF( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness ) {\\n\\tvec2 fab = DFGApprox( normal, viewDir, roughness );\\n\\treturn specularColor * fab.x + specularF90 * fab.y;\\n}\\n#ifdef USE_IRIDESCENCE\\nvoid computeMultiscatteringIridescence( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float iridescence, const in vec3 iridescenceF0, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {\\n#else\\nvoid computeMultiscattering( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {\\n#endif\\n\\tvec2 fab = DFGApprox( normal, viewDir, roughness );\\n\\t#ifdef USE_IRIDESCENCE\\n\\t\\tvec3 Fr = mix( specularColor, iridescenceF0, iridescence );\\n\\t#else\\n\\t\\tvec3 Fr = specularColor;\\n\\t#endif\\n\\tvec3 FssEss = Fr * fab.x + specularF90 * fab.y;\\n\\tfloat Ess = fab.x + fab.y;\\n\\tfloat Ems = 1.0 - Ess;\\n\\tvec3 Favg = Fr + ( 1.0 - Fr ) * 0.047619;\\tvec3 Fms = FssEss * Favg / ( 1.0 - Ems * Favg );\\n\\tsingleScatter += FssEss;\\n\\tmultiScatter += Fms * Ems;\\n}\\n#if NUM_RECT_AREA_LIGHTS > 0\\n\\tvoid RE_Direct_RectArea_Physical( const in RectAreaLight rectAreaLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\\n\\t\\tvec3 normal = geometryNormal;\\n\\t\\tvec3 viewDir = geometryViewDir;\\n\\t\\tvec3 position = geometryPosition;\\n\\t\\tvec3 lightPos = rectAreaLight.position;\\n\\t\\tvec3 halfWidth = rectAreaLight.halfWidth;\\n\\t\\tvec3 halfHeight = rectAreaLight.halfHeight;\\n\\t\\tvec3 lightColor = rectAreaLight.color;\\n\\t\\tfloat roughness = material.roughness;\\n\\t\\tvec3 rectCoords[ 4 ];\\n\\t\\trectCoords[ 0 ] = lightPos + halfWidth - halfHeight;\\t\\trectCoords[ 1 ] = lightPos - halfWidth - halfHeight;\\n\\t\\trectCoords[ 2 ] = lightPos - halfWidth + halfHeight;\\n\\t\\trectCoords[ 3 ] = lightPos + halfWidth + halfHeight;\\n\\t\\tvec2 uv = LTC_Uv( normal, viewDir, roughness );\\n\\t\\tvec4 t1 = texture2D( ltc_1, uv );\\n\\t\\tvec4 t2 = texture2D( ltc_2, uv );\\n\\t\\tmat3 mInv = mat3(\\n\\t\\t\\tvec3( t1.x, 0, t1.y ),\\n\\t\\t\\tvec3( 0, 1, 0 ),\\n\\t\\t\\tvec3( t1.z, 0, t1.w )\\n\\t\\t);\\n\\t\\tvec3 fresnel = ( material.specularColor * t2.x + ( vec3( 1.0 ) - material.specularColor ) * t2.y );\\n\\t\\treflectedLight.directSpecular += lightColor * fresnel * LTC_Evaluate( normal, viewDir, position, mInv, rectCoords );\\n\\t\\treflectedLight.directDiffuse += lightColor * material.diffuseColor * LTC_Evaluate( normal, viewDir, position, mat3( 1.0 ), rectCoords );\\n\\t}\\n#endif\\nvoid RE_Direct_Physical( const in IncidentLight directLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\\n\\tfloat dotNL = saturate( dot( geometryNormal, directLight.direction ) );\\n\\tvec3 irradiance = dotNL * directLight.color;\\n\\t#ifdef USE_CLEARCOAT\\n\\t\\tfloat dotNLcc = saturate( dot( geometryClearcoatNormal, directLight.direction ) );\\n\\t\\tvec3 ccIrradiance = dotNLcc * directLight.color;\\n\\t\\tclearcoatSpecularDirect += ccIrradiance * BRDF_GGX_Clearcoat( directLight.direction, geometryViewDir, geometryClearcoatNormal, material );\\n\\t#endif\\n\\t#ifdef USE_SHEEN\\n\\t\\tsheenSpecularDirect += irradiance * BRDF_Sheen( directLight.direction, geometryViewDir, geometryNormal, material.sheenColor, material.sheenRoughness );\\n\\t#endif\\n\\treflectedLight.directSpecular += irradiance * BRDF_GGX( directLight.direction, geometryViewDir, geometryNormal, material );\\n\\treflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\\n}\\nvoid RE_IndirectDiffuse_Physical( const in vec3 irradiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\\n\\treflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\\n}\\nvoid RE_IndirectSpecular_Physical( const in vec3 radiance, const in vec3 irradiance, const in vec3 clearcoatRadiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {\\n\\t#ifdef USE_CLEARCOAT\\n\\t\\tclearcoatSpecularIndirect += clearcoatRadiance * EnvironmentBRDF( geometryClearcoatNormal, geometryViewDir, material.clearcoatF0, material.clearcoatF90, material.clearcoatRoughness );\\n\\t#endif\\n\\t#ifdef USE_SHEEN\\n\\t\\tsheenSpecularIndirect += irradiance * material.sheenColor * IBLSheenBRDF( geometryNormal, geometryViewDir, material.sheenRoughness );\\n\\t#endif\\n\\tvec3 singleScattering = vec3( 0.0 );\\n\\tvec3 multiScattering = vec3( 0.0 );\\n\\tvec3 cosineWeightedIrradiance = irradiance * RECIPROCAL_PI;\\n\\t#ifdef USE_IRIDESCENCE\\n\\t\\tcomputeMultiscatteringIridescence( geometryNormal, geometryViewDir, material.specularColor, material.specularF90, material.iridescence, material.iridescenceFresnel, material.roughness, singleScattering, multiScattering );\\n\\t#else\\n\\t\\tcomputeMultiscattering( geometryNormal, geometryViewDir, material.specularColor, material.specularF90, material.roughness, singleScattering, multiScattering );\\n\\t#endif\\n\\tvec3 totalScattering = singleScattering + multiScattering;\\n\\tvec3 diffuse = material.diffuseColor * ( 1.0 - max( max( totalScattering.r, totalScattering.g ), totalScattering.b ) );\\n\\treflectedLight.indirectSpecular += radiance * singleScattering;\\n\\treflectedLight.indirectSpecular += multiScattering * cosineWeightedIrradiance;\\n\\treflectedLight.indirectDiffuse += diffuse * cosineWeightedIrradiance;\\n}\\n#define RE_Direct\\t\\t\\t\\tRE_Direct_Physical\\n#define RE_Direct_RectArea\\t\\tRE_Direct_RectArea_Physical\\n#define RE_IndirectDiffuse\\t\\tRE_IndirectDiffuse_Physical\\n#define RE_IndirectSpecular\\t\\tRE_IndirectSpecular_Physical\\nfloat computeSpecularOcclusion( const in float dotNV, const in float ambientOcclusion, const in float roughness ) {\\n\\treturn saturate( pow( dotNV + ambientOcclusion, exp2( - 16.0 * roughness - 1.0 ) ) - 1.0 + ambientOcclusion );\\n}\";\n\nvar lights_fragment_begin = \"\\nvec3 geometryPosition = - vViewPosition;\\nvec3 geometryNormal = normal;\\nvec3 geometryViewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( vViewPosition );\\nvec3 geometryClearcoatNormal = vec3( 0.0 );\\n#ifdef USE_CLEARCOAT\\n\\tgeometryClearcoatNormal = clearcoatNormal;\\n#endif\\n#ifdef USE_IRIDESCENCE\\n\\tfloat dotNVi = saturate( dot( normal, geometryViewDir ) );\\n\\tif ( material.iridescenceThickness == 0.0 ) {\\n\\t\\tmaterial.iridescence = 0.0;\\n\\t} else {\\n\\t\\tmaterial.iridescence = saturate( material.iridescence );\\n\\t}\\n\\tif ( material.iridescence > 0.0 ) {\\n\\t\\tmaterial.iridescenceFresnel = evalIridescence( 1.0, material.iridescenceIOR, dotNVi, material.iridescenceThickness, material.specularColor );\\n\\t\\tmaterial.iridescenceF0 = Schlick_to_F0( material.iridescenceFresnel, 1.0, dotNVi );\\n\\t}\\n#endif\\nIncidentLight directLight;\\n#if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )\\n\\tPointLight pointLight;\\n\\t#if defined( USE_SHADOWMAP ) && NUM_POINT_LIGHT_SHADOWS > 0\\n\\tPointLightShadow pointLightShadow;\\n\\t#endif\\n\\t#pragma unroll_loop_start\\n\\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\\n\\t\\tpointLight = pointLights[ i ];\\n\\t\\tgetPointLightInfo( pointLight, geometryPosition, directLight );\\n\\t\\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_POINT_LIGHT_SHADOWS )\\n\\t\\tpointLightShadow = pointLightShadows[ i ];\\n\\t\\tdirectLight.color *= ( directLight.visible && receiveShadow ) ? getPointShadow( pointShadowMap[ i ], pointLightShadow.shadowMapSize, pointLightShadow.shadowBias, pointLightShadow.shadowRadius, vPointShadowCoord[ i ], pointLightShadow.shadowCameraNear, pointLightShadow.shadowCameraFar ) : 1.0;\\n\\t\\t#endif\\n\\t\\tRE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\\n\\t}\\n\\t#pragma unroll_loop_end\\n#endif\\n#if ( NUM_SPOT_LIGHTS > 0 ) && defined( RE_Direct )\\n\\tSpotLight spotLight;\\n\\tvec4 spotColor;\\n\\tvec3 spotLightCoord;\\n\\tbool inSpotLightMap;\\n\\t#if defined( USE_SHADOWMAP ) && NUM_SPOT_LIGHT_SHADOWS > 0\\n\\tSpotLightShadow spotLightShadow;\\n\\t#endif\\n\\t#pragma unroll_loop_start\\n\\tfor ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\\n\\t\\tspotLight = spotLights[ i ];\\n\\t\\tgetSpotLightInfo( spotLight, geometryPosition, directLight );\\n\\t\\t#if ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS_WITH_MAPS )\\n\\t\\t#define SPOT_LIGHT_MAP_INDEX UNROLLED_LOOP_INDEX\\n\\t\\t#elif ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )\\n\\t\\t#define SPOT_LIGHT_MAP_INDEX NUM_SPOT_LIGHT_MAPS\\n\\t\\t#else\\n\\t\\t#define SPOT_LIGHT_MAP_INDEX ( UNROLLED_LOOP_INDEX - NUM_SPOT_LIGHT_SHADOWS + NUM_SPOT_LIGHT_SHADOWS_WITH_MAPS )\\n\\t\\t#endif\\n\\t\\t#if ( SPOT_LIGHT_MAP_INDEX < NUM_SPOT_LIGHT_MAPS )\\n\\t\\t\\tspotLightCoord = vSpotLightCoord[ i ].xyz / vSpotLightCoord[ i ].w;\\n\\t\\t\\tinSpotLightMap = all( lessThan( abs( spotLightCoord * 2. - 1. ), vec3( 1.0 ) ) );\\n\\t\\t\\tspotColor = texture2D( spotLightMap[ SPOT_LIGHT_MAP_INDEX ], spotLightCoord.xy );\\n\\t\\t\\tdirectLight.color = inSpotLightMap ? directLight.color * spotColor.rgb : directLight.color;\\n\\t\\t#endif\\n\\t\\t#undef SPOT_LIGHT_MAP_INDEX\\n\\t\\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )\\n\\t\\tspotLightShadow = spotLightShadows[ i ];\\n\\t\\tdirectLight.color *= ( directLight.visible && receiveShadow ) ? getShadow( spotShadowMap[ i ], spotLightShadow.shadowMapSize, spotLightShadow.shadowBias, spotLightShadow.shadowRadius, vSpotLightCoord[ i ] ) : 1.0;\\n\\t\\t#endif\\n\\t\\tRE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\\n\\t}\\n\\t#pragma unroll_loop_end\\n#endif\\n#if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct )\\n\\tDirectionalLight directionalLight;\\n\\t#if defined( USE_SHADOWMAP ) && NUM_DIR_LIGHT_SHADOWS > 0\\n\\tDirectionalLightShadow directionalLightShadow;\\n\\t#endif\\n\\t#pragma unroll_loop_start\\n\\tfor ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\\n\\t\\tdirectionalLight = directionalLights[ i ];\\n\\t\\tgetDirectionalLightInfo( directionalLight, directLight );\\n\\t\\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )\\n\\t\\tdirectionalLightShadow = directionalLightShadows[ i ];\\n\\t\\tdirectLight.color *= ( directLight.visible && receiveShadow ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\\n\\t\\t#endif\\n\\t\\tRE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\\n\\t}\\n\\t#pragma unroll_loop_end\\n#endif\\n#if ( NUM_RECT_AREA_LIGHTS > 0 ) && defined( RE_Direct_RectArea )\\n\\tRectAreaLight rectAreaLight;\\n\\t#pragma unroll_loop_start\\n\\tfor ( int i = 0; i < NUM_RECT_AREA_LIGHTS; i ++ ) {\\n\\t\\trectAreaLight = rectAreaLights[ i ];\\n\\t\\tRE_Direct_RectArea( rectAreaLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\\n\\t}\\n\\t#pragma unroll_loop_end\\n#endif\\n#if defined( RE_IndirectDiffuse )\\n\\tvec3 iblIrradiance = vec3( 0.0 );\\n\\tvec3 irradiance = getAmbientLightIrradiance( ambientLightColor );\\n\\t#if defined( USE_LIGHT_PROBES )\\n\\t\\tirradiance += getLightProbeIrradiance( lightProbe, geometryNormal );\\n\\t#endif\\n\\t#if ( NUM_HEMI_LIGHTS > 0 )\\n\\t\\t#pragma unroll_loop_start\\n\\t\\tfor ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\\n\\t\\t\\tirradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometryNormal );\\n\\t\\t}\\n\\t\\t#pragma unroll_loop_end\\n\\t#endif\\n#endif\\n#if defined( RE_IndirectSpecular )\\n\\tvec3 radiance = vec3( 0.0 );\\n\\tvec3 clearcoatRadiance = vec3( 0.0 );\\n#endif\";\n\nvar lights_fragment_maps = \"#if defined( RE_IndirectDiffuse )\\n\\t#ifdef USE_LIGHTMAP\\n\\t\\tvec4 lightMapTexel = texture2D( lightMap, vLightMapUv );\\n\\t\\tvec3 lightMapIrradiance = lightMapTexel.rgb * lightMapIntensity;\\n\\t\\tirradiance += lightMapIrradiance;\\n\\t#endif\\n\\t#if defined( USE_ENVMAP ) && defined( STANDARD ) && defined( ENVMAP_TYPE_CUBE_UV )\\n\\t\\tiblIrradiance += getIBLIrradiance( geometryNormal );\\n\\t#endif\\n#endif\\n#if defined( USE_ENVMAP ) && defined( RE_IndirectSpecular )\\n\\t#ifdef USE_ANISOTROPY\\n\\t\\tradiance += getIBLAnisotropyRadiance( geometryViewDir, geometryNormal, material.roughness, material.anisotropyB, material.anisotropy );\\n\\t#else\\n\\t\\tradiance += getIBLRadiance( geometryViewDir, geometryNormal, material.roughness );\\n\\t#endif\\n\\t#ifdef USE_CLEARCOAT\\n\\t\\tclearcoatRadiance += getIBLRadiance( geometryViewDir, geometryClearcoatNormal, material.clearcoatRoughness );\\n\\t#endif\\n#endif\";\n\nvar lights_fragment_end = \"#if defined( RE_IndirectDiffuse )\\n\\tRE_IndirectDiffuse( irradiance, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\\n#endif\\n#if defined( RE_IndirectSpecular )\\n\\tRE_IndirectSpecular( radiance, iblIrradiance, clearcoatRadiance, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\\n#endif\";\n\nvar logdepthbuf_fragment = \"#if defined( USE_LOGDEPTHBUF )\\n\\tgl_FragDepth = vIsPerspective == 0.0 ? gl_FragCoord.z : log2( vFragDepth ) * logDepthBufFC * 0.5;\\n#endif\";\n\nvar logdepthbuf_pars_fragment = \"#if defined( USE_LOGDEPTHBUF )\\n\\tuniform float logDepthBufFC;\\n\\tvarying float vFragDepth;\\n\\tvarying float vIsPerspective;\\n#endif\";\n\nvar logdepthbuf_pars_vertex = \"#ifdef USE_LOGDEPTHBUF\\n\\tvarying float vFragDepth;\\n\\tvarying float vIsPerspective;\\n#endif\";\n\nvar logdepthbuf_vertex = \"#ifdef USE_LOGDEPTHBUF\\n\\tvFragDepth = 1.0 + gl_Position.w;\\n\\tvIsPerspective = float( isPerspectiveMatrix( projectionMatrix ) );\\n#endif\";\n\nvar map_fragment = \"#ifdef USE_MAP\\n\\tvec4 sampledDiffuseColor = texture2D( map, vMapUv );\\n\\t#ifdef DECODE_VIDEO_TEXTURE\\n\\t\\tsampledDiffuseColor = vec4( mix( pow( sampledDiffuseColor.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), sampledDiffuseColor.rgb * 0.0773993808, vec3( lessThanEqual( sampledDiffuseColor.rgb, vec3( 0.04045 ) ) ) ), sampledDiffuseColor.w );\\n\\t\\n\\t#endif\\n\\tdiffuseColor *= sampledDiffuseColor;\\n#endif\";\n\nvar map_pars_fragment = \"#ifdef USE_MAP\\n\\tuniform sampler2D map;\\n#endif\";\n\nvar map_particle_fragment = \"#if defined( USE_MAP ) || defined( USE_ALPHAMAP )\\n\\t#if defined( USE_POINTS_UV )\\n\\t\\tvec2 uv = vUv;\\n\\t#else\\n\\t\\tvec2 uv = ( uvTransform * vec3( gl_PointCoord.x, 1.0 - gl_PointCoord.y, 1 ) ).xy;\\n\\t#endif\\n#endif\\n#ifdef USE_MAP\\n\\tdiffuseColor *= texture2D( map, uv );\\n#endif\\n#ifdef USE_ALPHAMAP\\n\\tdiffuseColor.a *= texture2D( alphaMap, uv ).g;\\n#endif\";\n\nvar map_particle_pars_fragment = \"#if defined( USE_POINTS_UV )\\n\\tvarying vec2 vUv;\\n#else\\n\\t#if defined( USE_MAP ) || defined( USE_ALPHAMAP )\\n\\t\\tuniform mat3 uvTransform;\\n\\t#endif\\n#endif\\n#ifdef USE_MAP\\n\\tuniform sampler2D map;\\n#endif\\n#ifdef USE_ALPHAMAP\\n\\tuniform sampler2D alphaMap;\\n#endif\";\n\nvar metalnessmap_fragment = \"float metalnessFactor = metalness;\\n#ifdef USE_METALNESSMAP\\n\\tvec4 texelMetalness = texture2D( metalnessMap, vMetalnessMapUv );\\n\\tmetalnessFactor *= texelMetalness.b;\\n#endif\";\n\nvar metalnessmap_pars_fragment = \"#ifdef USE_METALNESSMAP\\n\\tuniform sampler2D metalnessMap;\\n#endif\";\n\nvar morphinstance_vertex = \"#ifdef USE_INSTANCING_MORPH\\n\\tfloat morphTargetInfluences[MORPHTARGETS_COUNT];\\n\\tfloat morphTargetBaseInfluence = texelFetch( morphTexture, ivec2( 0, gl_InstanceID ), 0 ).r;\\n\\tfor ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {\\n\\t\\tmorphTargetInfluences[i] = texelFetch( morphTexture, ivec2( i + 1, gl_InstanceID ), 0 ).r;\\n\\t}\\n#endif\";\n\nvar morphcolor_vertex = \"#if defined( USE_MORPHCOLORS ) && defined( MORPHTARGETS_TEXTURE )\\n\\tvColor *= morphTargetBaseInfluence;\\n\\tfor ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {\\n\\t\\t#if defined( USE_COLOR_ALPHA )\\n\\t\\t\\tif ( morphTargetInfluences[ i ] != 0.0 ) vColor += getMorph( gl_VertexID, i, 2 ) * morphTargetInfluences[ i ];\\n\\t\\t#elif defined( USE_COLOR )\\n\\t\\t\\tif ( morphTargetInfluences[ i ] != 0.0 ) vColor += getMorph( gl_VertexID, i, 2 ).rgb * morphTargetInfluences[ i ];\\n\\t\\t#endif\\n\\t}\\n#endif\";\n\nvar morphnormal_vertex = \"#ifdef USE_MORPHNORMALS\\n\\tobjectNormal *= morphTargetBaseInfluence;\\n\\t#ifdef MORPHTARGETS_TEXTURE\\n\\t\\tfor ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {\\n\\t\\t\\tif ( morphTargetInfluences[ i ] != 0.0 ) objectNormal += getMorph( gl_VertexID, i, 1 ).xyz * morphTargetInfluences[ i ];\\n\\t\\t}\\n\\t#else\\n\\t\\tobjectNormal += morphNormal0 * morphTargetInfluences[ 0 ];\\n\\t\\tobjectNormal += morphNormal1 * morphTargetInfluences[ 1 ];\\n\\t\\tobjectNormal += morphNormal2 * morphTargetInfluences[ 2 ];\\n\\t\\tobjectNormal += morphNormal3 * morphTargetInfluences[ 3 ];\\n\\t#endif\\n#endif\";\n\nvar morphtarget_pars_vertex = \"#ifdef USE_MORPHTARGETS\\n\\t#ifndef USE_INSTANCING_MORPH\\n\\t\\tuniform float morphTargetBaseInfluence;\\n\\t#endif\\n\\t#ifdef MORPHTARGETS_TEXTURE\\n\\t\\t#ifndef USE_INSTANCING_MORPH\\n\\t\\t\\tuniform float morphTargetInfluences[ MORPHTARGETS_COUNT ];\\n\\t\\t#endif\\n\\t\\tuniform sampler2DArray morphTargetsTexture;\\n\\t\\tuniform ivec2 morphTargetsTextureSize;\\n\\t\\tvec4 getMorph( const in int vertexIndex, const in int morphTargetIndex, const in int offset ) {\\n\\t\\t\\tint texelIndex = vertexIndex * MORPHTARGETS_TEXTURE_STRIDE + offset;\\n\\t\\t\\tint y = texelIndex / morphTargetsTextureSize.x;\\n\\t\\t\\tint x = texelIndex - y * morphTargetsTextureSize.x;\\n\\t\\t\\tivec3 morphUV = ivec3( x, y, morphTargetIndex );\\n\\t\\t\\treturn texelFetch( morphTargetsTexture, morphUV, 0 );\\n\\t\\t}\\n\\t#else\\n\\t\\t#ifndef USE_MORPHNORMALS\\n\\t\\t\\tuniform float morphTargetInfluences[ 8 ];\\n\\t\\t#else\\n\\t\\t\\tuniform float morphTargetInfluences[ 4 ];\\n\\t\\t#endif\\n\\t#endif\\n#endif\";\n\nvar morphtarget_vertex = \"#ifdef USE_MORPHTARGETS\\n\\ttransformed *= morphTargetBaseInfluence;\\n\\t#ifdef MORPHTARGETS_TEXTURE\\n\\t\\tfor ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {\\n\\t\\t\\tif ( morphTargetInfluences[ i ] != 0.0 ) transformed += getMorph( gl_VertexID, i, 0 ).xyz * morphTargetInfluences[ i ];\\n\\t\\t}\\n\\t#else\\n\\t\\ttransformed += morphTarget0 * morphTargetInfluences[ 0 ];\\n\\t\\ttransformed += morphTarget1 * morphTargetInfluences[ 1 ];\\n\\t\\ttransformed += morphTarget2 * morphTargetInfluences[ 2 ];\\n\\t\\ttransformed += morphTarget3 * morphTargetInfluences[ 3 ];\\n\\t\\t#ifndef USE_MORPHNORMALS\\n\\t\\t\\ttransformed += morphTarget4 * morphTargetInfluences[ 4 ];\\n\\t\\t\\ttransformed += morphTarget5 * morphTargetInfluences[ 5 ];\\n\\t\\t\\ttransformed += morphTarget6 * morphTargetInfluences[ 6 ];\\n\\t\\t\\ttransformed += morphTarget7 * morphTargetInfluences[ 7 ];\\n\\t\\t#endif\\n\\t#endif\\n#endif\";\n\nvar normal_fragment_begin = \"float faceDirection = gl_FrontFacing ? 1.0 : - 1.0;\\n#ifdef FLAT_SHADED\\n\\tvec3 fdx = dFdx( vViewPosition );\\n\\tvec3 fdy = dFdy( vViewPosition );\\n\\tvec3 normal = normalize( cross( fdx, fdy ) );\\n#else\\n\\tvec3 normal = normalize( vNormal );\\n\\t#ifdef DOUBLE_SIDED\\n\\t\\tnormal *= faceDirection;\\n\\t#endif\\n#endif\\n#if defined( USE_NORMALMAP_TANGENTSPACE ) || defined( USE_CLEARCOAT_NORMALMAP ) || defined( USE_ANISOTROPY )\\n\\t#ifdef USE_TANGENT\\n\\t\\tmat3 tbn = mat3( normalize( vTangent ), normalize( vBitangent ), normal );\\n\\t#else\\n\\t\\tmat3 tbn = getTangentFrame( - vViewPosition, normal,\\n\\t\\t#if defined( USE_NORMALMAP )\\n\\t\\t\\tvNormalMapUv\\n\\t\\t#elif defined( USE_CLEARCOAT_NORMALMAP )\\n\\t\\t\\tvClearcoatNormalMapUv\\n\\t\\t#else\\n\\t\\t\\tvUv\\n\\t\\t#endif\\n\\t\\t);\\n\\t#endif\\n\\t#if defined( DOUBLE_SIDED ) && ! defined( FLAT_SHADED )\\n\\t\\ttbn[0] *= faceDirection;\\n\\t\\ttbn[1] *= faceDirection;\\n\\t#endif\\n#endif\\n#ifdef USE_CLEARCOAT_NORMALMAP\\n\\t#ifdef USE_TANGENT\\n\\t\\tmat3 tbn2 = mat3( normalize( vTangent ), normalize( vBitangent ), normal );\\n\\t#else\\n\\t\\tmat3 tbn2 = getTangentFrame( - vViewPosition, normal, vClearcoatNormalMapUv );\\n\\t#endif\\n\\t#if defined( DOUBLE_SIDED ) && ! defined( FLAT_SHADED )\\n\\t\\ttbn2[0] *= faceDirection;\\n\\t\\ttbn2[1] *= faceDirection;\\n\\t#endif\\n#endif\\nvec3 nonPerturbedNormal = normal;\";\n\nvar normal_fragment_maps = \"#ifdef USE_NORMALMAP_OBJECTSPACE\\n\\tnormal = texture2D( normalMap, vNormalMapUv ).xyz * 2.0 - 1.0;\\n\\t#ifdef FLIP_SIDED\\n\\t\\tnormal = - normal;\\n\\t#endif\\n\\t#ifdef DOUBLE_SIDED\\n\\t\\tnormal = normal * faceDirection;\\n\\t#endif\\n\\tnormal = normalize( normalMatrix * normal );\\n#elif defined( USE_NORMALMAP_TANGENTSPACE )\\n\\tvec3 mapN = texture2D( normalMap, vNormalMapUv ).xyz * 2.0 - 1.0;\\n\\tmapN.xy *= normalScale;\\n\\tnormal = normalize( tbn * mapN );\\n#elif defined( USE_BUMPMAP )\\n\\tnormal = perturbNormalArb( - vViewPosition, normal, dHdxy_fwd(), faceDirection );\\n#endif\";\n\nvar normal_pars_fragment = \"#ifndef FLAT_SHADED\\n\\tvarying vec3 vNormal;\\n\\t#ifdef USE_TANGENT\\n\\t\\tvarying vec3 vTangent;\\n\\t\\tvarying vec3 vBitangent;\\n\\t#endif\\n#endif\";\n\nvar normal_pars_vertex = \"#ifndef FLAT_SHADED\\n\\tvarying vec3 vNormal;\\n\\t#ifdef USE_TANGENT\\n\\t\\tvarying vec3 vTangent;\\n\\t\\tvarying vec3 vBitangent;\\n\\t#endif\\n#endif\";\n\nvar normal_vertex = \"#ifndef FLAT_SHADED\\n\\tvNormal = normalize( transformedNormal );\\n\\t#ifdef USE_TANGENT\\n\\t\\tvTangent = normalize( transformedTangent );\\n\\t\\tvBitangent = normalize( cross( vNormal, vTangent ) * tangent.w );\\n\\t#endif\\n#endif\";\n\nvar normalmap_pars_fragment = \"#ifdef USE_NORMALMAP\\n\\tuniform sampler2D normalMap;\\n\\tuniform vec2 normalScale;\\n#endif\\n#ifdef USE_NORMALMAP_OBJECTSPACE\\n\\tuniform mat3 normalMatrix;\\n#endif\\n#if ! defined ( USE_TANGENT ) && ( defined ( USE_NORMALMAP_TANGENTSPACE ) || defined ( USE_CLEARCOAT_NORMALMAP ) || defined( USE_ANISOTROPY ) )\\n\\tmat3 getTangentFrame( vec3 eye_pos, vec3 surf_norm, vec2 uv ) {\\n\\t\\tvec3 q0 = dFdx( eye_pos.xyz );\\n\\t\\tvec3 q1 = dFdy( eye_pos.xyz );\\n\\t\\tvec2 st0 = dFdx( uv.st );\\n\\t\\tvec2 st1 = dFdy( uv.st );\\n\\t\\tvec3 N = surf_norm;\\n\\t\\tvec3 q1perp = cross( q1, N );\\n\\t\\tvec3 q0perp = cross( N, q0 );\\n\\t\\tvec3 T = q1perp * st0.x + q0perp * st1.x;\\n\\t\\tvec3 B = q1perp * st0.y + q0perp * st1.y;\\n\\t\\tfloat det = max( dot( T, T ), dot( B, B ) );\\n\\t\\tfloat scale = ( det == 0.0 ) ? 0.0 : inversesqrt( det );\\n\\t\\treturn mat3( T * scale, B * scale, N );\\n\\t}\\n#endif\";\n\nvar clearcoat_normal_fragment_begin = \"#ifdef USE_CLEARCOAT\\n\\tvec3 clearcoatNormal = nonPerturbedNormal;\\n#endif\";\n\nvar clearcoat_normal_fragment_maps = \"#ifdef USE_CLEARCOAT_NORMALMAP\\n\\tvec3 clearcoatMapN = texture2D( clearcoatNormalMap, vClearcoatNormalMapUv ).xyz * 2.0 - 1.0;\\n\\tclearcoatMapN.xy *= clearcoatNormalScale;\\n\\tclearcoatNormal = normalize( tbn2 * clearcoatMapN );\\n#endif\";\n\nvar clearcoat_pars_fragment = \"#ifdef USE_CLEARCOATMAP\\n\\tuniform sampler2D clearcoatMap;\\n#endif\\n#ifdef USE_CLEARCOAT_NORMALMAP\\n\\tuniform sampler2D clearcoatNormalMap;\\n\\tuniform vec2 clearcoatNormalScale;\\n#endif\\n#ifdef USE_CLEARCOAT_ROUGHNESSMAP\\n\\tuniform sampler2D clearcoatRoughnessMap;\\n#endif\";\n\nvar iridescence_pars_fragment = \"#ifdef USE_IRIDESCENCEMAP\\n\\tuniform sampler2D iridescenceMap;\\n#endif\\n#ifdef USE_IRIDESCENCE_THICKNESSMAP\\n\\tuniform sampler2D iridescenceThicknessMap;\\n#endif\";\n\nvar opaque_fragment = \"#ifdef OPAQUE\\ndiffuseColor.a = 1.0;\\n#endif\\n#ifdef USE_TRANSMISSION\\ndiffuseColor.a *= material.transmissionAlpha;\\n#endif\\ngl_FragColor = vec4( outgoingLight, diffuseColor.a );\";\n\nvar packing = \"vec3 packNormalToRGB( const in vec3 normal ) {\\n\\treturn normalize( normal ) * 0.5 + 0.5;\\n}\\nvec3 unpackRGBToNormal( const in vec3 rgb ) {\\n\\treturn 2.0 * rgb.xyz - 1.0;\\n}\\nconst float PackUpscale = 256. / 255.;const float UnpackDownscale = 255. / 256.;\\nconst vec3 PackFactors = vec3( 256. * 256. * 256., 256. * 256., 256. );\\nconst vec4 UnpackFactors = UnpackDownscale / vec4( PackFactors, 1. );\\nconst float ShiftRight8 = 1. / 256.;\\nvec4 packDepthToRGBA( const in float v ) {\\n\\tvec4 r = vec4( fract( v * PackFactors ), v );\\n\\tr.yzw -= r.xyz * ShiftRight8;\\treturn r * PackUpscale;\\n}\\nfloat unpackRGBAToDepth( const in vec4 v ) {\\n\\treturn dot( v, UnpackFactors );\\n}\\nvec2 packDepthToRG( in highp float v ) {\\n\\treturn packDepthToRGBA( v ).yx;\\n}\\nfloat unpackRGToDepth( const in highp vec2 v ) {\\n\\treturn unpackRGBAToDepth( vec4( v.xy, 0.0, 0.0 ) );\\n}\\nvec4 pack2HalfToRGBA( vec2 v ) {\\n\\tvec4 r = vec4( v.x, fract( v.x * 255.0 ), v.y, fract( v.y * 255.0 ) );\\n\\treturn vec4( r.x - r.y / 255.0, r.y, r.z - r.w / 255.0, r.w );\\n}\\nvec2 unpackRGBATo2Half( vec4 v ) {\\n\\treturn vec2( v.x + ( v.y / 255.0 ), v.z + ( v.w / 255.0 ) );\\n}\\nfloat viewZToOrthographicDepth( const in float viewZ, const in float near, const in float far ) {\\n\\treturn ( viewZ + near ) / ( near - far );\\n}\\nfloat orthographicDepthToViewZ( const in float depth, const in float near, const in float far ) {\\n\\treturn depth * ( near - far ) - near;\\n}\\nfloat viewZToPerspectiveDepth( const in float viewZ, const in float near, const in float far ) {\\n\\treturn ( ( near + viewZ ) * far ) / ( ( far - near ) * viewZ );\\n}\\nfloat perspectiveDepthToViewZ( const in float depth, const in float near, const in float far ) {\\n\\treturn ( near * far ) / ( ( far - near ) * depth - far );\\n}\";\n\nvar premultiplied_alpha_fragment = \"#ifdef PREMULTIPLIED_ALPHA\\n\\tgl_FragColor.rgb *= gl_FragColor.a;\\n#endif\";\n\nvar project_vertex = \"vec4 mvPosition = vec4( transformed, 1.0 );\\n#ifdef USE_BATCHING\\n\\tmvPosition = batchingMatrix * mvPosition;\\n#endif\\n#ifdef USE_INSTANCING\\n\\tmvPosition = instanceMatrix * mvPosition;\\n#endif\\nmvPosition = modelViewMatrix * mvPosition;\\ngl_Position = projectionMatrix * mvPosition;\";\n\nvar dithering_fragment = \"#ifdef DITHERING\\n\\tgl_FragColor.rgb = dithering( gl_FragColor.rgb );\\n#endif\";\n\nvar dithering_pars_fragment = \"#ifdef DITHERING\\n\\tvec3 dithering( vec3 color ) {\\n\\t\\tfloat grid_position = rand( gl_FragCoord.xy );\\n\\t\\tvec3 dither_shift_RGB = vec3( 0.25 / 255.0, -0.25 / 255.0, 0.25 / 255.0 );\\n\\t\\tdither_shift_RGB = mix( 2.0 * dither_shift_RGB, -2.0 * dither_shift_RGB, grid_position );\\n\\t\\treturn color + dither_shift_RGB;\\n\\t}\\n#endif\";\n\nvar roughnessmap_fragment = \"float roughnessFactor = roughness;\\n#ifdef USE_ROUGHNESSMAP\\n\\tvec4 texelRoughness = texture2D( roughnessMap, vRoughnessMapUv );\\n\\troughnessFactor *= texelRoughness.g;\\n#endif\";\n\nvar roughnessmap_pars_fragment = \"#ifdef USE_ROUGHNESSMAP\\n\\tuniform sampler2D roughnessMap;\\n#endif\";\n\nvar shadowmap_pars_fragment = \"#if NUM_SPOT_LIGHT_COORDS > 0\\n\\tvarying vec4 vSpotLightCoord[ NUM_SPOT_LIGHT_COORDS ];\\n#endif\\n#if NUM_SPOT_LIGHT_MAPS > 0\\n\\tuniform sampler2D spotLightMap[ NUM_SPOT_LIGHT_MAPS ];\\n#endif\\n#ifdef USE_SHADOWMAP\\n\\t#if NUM_DIR_LIGHT_SHADOWS > 0\\n\\t\\tuniform sampler2D directionalShadowMap[ NUM_DIR_LIGHT_SHADOWS ];\\n\\t\\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];\\n\\t\\tstruct DirectionalLightShadow {\\n\\t\\t\\tfloat shadowBias;\\n\\t\\t\\tfloat shadowNormalBias;\\n\\t\\t\\tfloat shadowRadius;\\n\\t\\t\\tvec2 shadowMapSize;\\n\\t\\t};\\n\\t\\tuniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];\\n\\t#endif\\n\\t#if NUM_SPOT_LIGHT_SHADOWS > 0\\n\\t\\tuniform sampler2D spotShadowMap[ NUM_SPOT_LIGHT_SHADOWS ];\\n\\t\\tstruct SpotLightShadow {\\n\\t\\t\\tfloat shadowBias;\\n\\t\\t\\tfloat shadowNormalBias;\\n\\t\\t\\tfloat shadowRadius;\\n\\t\\t\\tvec2 shadowMapSize;\\n\\t\\t};\\n\\t\\tuniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];\\n\\t#endif\\n\\t#if NUM_POINT_LIGHT_SHADOWS > 0\\n\\t\\tuniform sampler2D pointShadowMap[ NUM_POINT_LIGHT_SHADOWS ];\\n\\t\\tvarying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];\\n\\t\\tstruct PointLightShadow {\\n\\t\\t\\tfloat shadowBias;\\n\\t\\t\\tfloat shadowNormalBias;\\n\\t\\t\\tfloat shadowRadius;\\n\\t\\t\\tvec2 shadowMapSize;\\n\\t\\t\\tfloat shadowCameraNear;\\n\\t\\t\\tfloat shadowCameraFar;\\n\\t\\t};\\n\\t\\tuniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];\\n\\t#endif\\n\\tfloat texture2DCompare( sampler2D depths, vec2 uv, float compare ) {\\n\\t\\treturn step( compare, unpackRGBAToDepth( texture2D( depths, uv ) ) );\\n\\t}\\n\\tvec2 texture2DDistribution( sampler2D shadow, vec2 uv ) {\\n\\t\\treturn unpackRGBATo2Half( texture2D( shadow, uv ) );\\n\\t}\\n\\tfloat VSMShadow (sampler2D shadow, vec2 uv, float compare ){\\n\\t\\tfloat occlusion = 1.0;\\n\\t\\tvec2 distribution = texture2DDistribution( shadow, uv );\\n\\t\\tfloat hard_shadow = step( compare , distribution.x );\\n\\t\\tif (hard_shadow != 1.0 ) {\\n\\t\\t\\tfloat distance = compare - distribution.x ;\\n\\t\\t\\tfloat variance = max( 0.00000, distribution.y * distribution.y );\\n\\t\\t\\tfloat softness_probability = variance / (variance + distance * distance );\\t\\t\\tsoftness_probability = clamp( ( softness_probability - 0.3 ) / ( 0.95 - 0.3 ), 0.0, 1.0 );\\t\\t\\tocclusion = clamp( max( hard_shadow, softness_probability ), 0.0, 1.0 );\\n\\t\\t}\\n\\t\\treturn occlusion;\\n\\t}\\n\\tfloat getShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord ) {\\n\\t\\tfloat shadow = 1.0;\\n\\t\\tshadowCoord.xyz /= shadowCoord.w;\\n\\t\\tshadowCoord.z += shadowBias;\\n\\t\\tbool inFrustum = shadowCoord.x >= 0.0 && shadowCoord.x <= 1.0 && shadowCoord.y >= 0.0 && shadowCoord.y <= 1.0;\\n\\t\\tbool frustumTest = inFrustum && shadowCoord.z <= 1.0;\\n\\t\\tif ( frustumTest ) {\\n\\t\\t#if defined( SHADOWMAP_TYPE_PCF )\\n\\t\\t\\tvec2 texelSize = vec2( 1.0 ) / shadowMapSize;\\n\\t\\t\\tfloat dx0 = - texelSize.x * shadowRadius;\\n\\t\\t\\tfloat dy0 = - texelSize.y * shadowRadius;\\n\\t\\t\\tfloat dx1 = + texelSize.x * shadowRadius;\\n\\t\\t\\tfloat dy1 = + texelSize.y * shadowRadius;\\n\\t\\t\\tfloat dx2 = dx0 / 2.0;\\n\\t\\t\\tfloat dy2 = dy0 / 2.0;\\n\\t\\t\\tfloat dx3 = dx1 / 2.0;\\n\\t\\t\\tfloat dy3 = dy1 / 2.0;\\n\\t\\t\\tshadow = (\\n\\t\\t\\t\\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +\\n\\t\\t\\t\\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +\\n\\t\\t\\t\\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +\\n\\t\\t\\t\\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy2 ), shadowCoord.z ) +\\n\\t\\t\\t\\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy2 ), shadowCoord.z ) +\\n\\t\\t\\t\\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy2 ), shadowCoord.z ) +\\n\\t\\t\\t\\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +\\n\\t\\t\\t\\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, 0.0 ), shadowCoord.z ) +\\n\\t\\t\\t\\ttexture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z ) +\\n\\t\\t\\t\\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, 0.0 ), shadowCoord.z ) +\\n\\t\\t\\t\\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +\\n\\t\\t\\t\\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy3 ), shadowCoord.z ) +\\n\\t\\t\\t\\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy3 ), shadowCoord.z ) +\\n\\t\\t\\t\\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy3 ), shadowCoord.z ) +\\n\\t\\t\\t\\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +\\n\\t\\t\\t\\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +\\n\\t\\t\\t\\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )\\n\\t\\t\\t) * ( 1.0 / 17.0 );\\n\\t\\t#elif defined( SHADOWMAP_TYPE_PCF_SOFT )\\n\\t\\t\\tvec2 texelSize = vec2( 1.0 ) / shadowMapSize;\\n\\t\\t\\tfloat dx = texelSize.x;\\n\\t\\t\\tfloat dy = texelSize.y;\\n\\t\\t\\tvec2 uv = shadowCoord.xy;\\n\\t\\t\\tvec2 f = fract( uv * shadowMapSize + 0.5 );\\n\\t\\t\\tuv -= f * texelSize;\\n\\t\\t\\tshadow = (\\n\\t\\t\\t\\ttexture2DCompare( shadowMap, uv, shadowCoord.z ) +\\n\\t\\t\\t\\ttexture2DCompare( shadowMap, uv + vec2( dx, 0.0 ), shadowCoord.z ) +\\n\\t\\t\\t\\ttexture2DCompare( shadowMap, uv + vec2( 0.0, dy ), shadowCoord.z ) +\\n\\t\\t\\t\\ttexture2DCompare( shadowMap, uv + texelSize, shadowCoord.z ) +\\n\\t\\t\\t\\tmix( texture2DCompare( shadowMap, uv + vec2( -dx, 0.0 ), shadowCoord.z ),\\n\\t\\t\\t\\t\\t texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 0.0 ), shadowCoord.z ),\\n\\t\\t\\t\\t\\t f.x ) +\\n\\t\\t\\t\\tmix( texture2DCompare( shadowMap, uv + vec2( -dx, dy ), shadowCoord.z ),\\n\\t\\t\\t\\t\\t texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, dy ), shadowCoord.z ),\\n\\t\\t\\t\\t\\t f.x ) +\\n\\t\\t\\t\\tmix( texture2DCompare( shadowMap, uv + vec2( 0.0, -dy ), shadowCoord.z ),\\n\\t\\t\\t\\t\\t texture2DCompare( shadowMap, uv + vec2( 0.0, 2.0 * dy ), shadowCoord.z ),\\n\\t\\t\\t\\t\\t f.y ) +\\n\\t\\t\\t\\tmix( texture2DCompare( shadowMap, uv + vec2( dx, -dy ), shadowCoord.z ),\\n\\t\\t\\t\\t\\t texture2DCompare( shadowMap, uv + vec2( dx, 2.0 * dy ), shadowCoord.z ),\\n\\t\\t\\t\\t\\t f.y ) +\\n\\t\\t\\t\\tmix( mix( texture2DCompare( shadowMap, uv + vec2( -dx, -dy ), shadowCoord.z ),\\n\\t\\t\\t\\t\\t\\t texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, -dy ), shadowCoord.z ),\\n\\t\\t\\t\\t\\t\\t f.x ),\\n\\t\\t\\t\\t\\t mix( texture2DCompare( shadowMap, uv + vec2( -dx, 2.0 * dy ), shadowCoord.z ),\\n\\t\\t\\t\\t\\t\\t texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 2.0 * dy ), shadowCoord.z ),\\n\\t\\t\\t\\t\\t\\t f.x ),\\n\\t\\t\\t\\t\\t f.y )\\n\\t\\t\\t) * ( 1.0 / 9.0 );\\n\\t\\t#elif defined( SHADOWMAP_TYPE_VSM )\\n\\t\\t\\tshadow = VSMShadow( shadowMap, shadowCoord.xy, shadowCoord.z );\\n\\t\\t#else\\n\\t\\t\\tshadow = texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z );\\n\\t\\t#endif\\n\\t\\t}\\n\\t\\treturn shadow;\\n\\t}\\n\\tvec2 cubeToUV( vec3 v, float texelSizeY ) {\\n\\t\\tvec3 absV = abs( v );\\n\\t\\tfloat scaleToCube = 1.0 / max( absV.x, max( absV.y, absV.z ) );\\n\\t\\tabsV *= scaleToCube;\\n\\t\\tv *= scaleToCube * ( 1.0 - 2.0 * texelSizeY );\\n\\t\\tvec2 planar = v.xy;\\n\\t\\tfloat almostATexel = 1.5 * texelSizeY;\\n\\t\\tfloat almostOne = 1.0 - almostATexel;\\n\\t\\tif ( absV.z >= almostOne ) {\\n\\t\\t\\tif ( v.z > 0.0 )\\n\\t\\t\\t\\tplanar.x = 4.0 - v.x;\\n\\t\\t} else if ( absV.x >= almostOne ) {\\n\\t\\t\\tfloat signX = sign( v.x );\\n\\t\\t\\tplanar.x = v.z * signX + 2.0 * signX;\\n\\t\\t} else if ( absV.y >= almostOne ) {\\n\\t\\t\\tfloat signY = sign( v.y );\\n\\t\\t\\tplanar.x = v.x + 2.0 * signY + 2.0;\\n\\t\\t\\tplanar.y = v.z * signY - 2.0;\\n\\t\\t}\\n\\t\\treturn vec2( 0.125, 0.25 ) * planar + vec2( 0.375, 0.75 );\\n\\t}\\n\\tfloat getPointShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord, float shadowCameraNear, float shadowCameraFar ) {\\n\\t\\tfloat shadow = 1.0;\\n\\t\\tvec3 lightToPosition = shadowCoord.xyz;\\n\\t\\t\\n\\t\\tfloat lightToPositionLength = length( lightToPosition );\\n\\t\\tif ( lightToPositionLength - shadowCameraFar <= 0.0 && lightToPositionLength - shadowCameraNear >= 0.0 ) {\\n\\t\\t\\tfloat dp = ( lightToPositionLength - shadowCameraNear ) / ( shadowCameraFar - shadowCameraNear );\\t\\t\\tdp += shadowBias;\\n\\t\\t\\tvec3 bd3D = normalize( lightToPosition );\\n\\t\\t\\tvec2 texelSize = vec2( 1.0 ) / ( shadowMapSize * vec2( 4.0, 2.0 ) );\\n\\t\\t\\t#if defined( SHADOWMAP_TYPE_PCF ) || defined( SHADOWMAP_TYPE_PCF_SOFT ) || defined( SHADOWMAP_TYPE_VSM )\\n\\t\\t\\t\\tvec2 offset = vec2( - 1, 1 ) * shadowRadius * texelSize.y;\\n\\t\\t\\t\\tshadow = (\\n\\t\\t\\t\\t\\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyy, texelSize.y ), dp ) +\\n\\t\\t\\t\\t\\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyy, texelSize.y ), dp ) +\\n\\t\\t\\t\\t\\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyx, texelSize.y ), dp ) +\\n\\t\\t\\t\\t\\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyx, texelSize.y ), dp ) +\\n\\t\\t\\t\\t\\ttexture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp ) +\\n\\t\\t\\t\\t\\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxy, texelSize.y ), dp ) +\\n\\t\\t\\t\\t\\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxy, texelSize.y ), dp ) +\\n\\t\\t\\t\\t\\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxx, texelSize.y ), dp ) +\\n\\t\\t\\t\\t\\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxx, texelSize.y ), dp )\\n\\t\\t\\t\\t) * ( 1.0 / 9.0 );\\n\\t\\t\\t#else\\n\\t\\t\\t\\tshadow = texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp );\\n\\t\\t\\t#endif\\n\\t\\t}\\n\\t\\treturn shadow;\\n\\t}\\n#endif\";\n\nvar shadowmap_pars_vertex = \"#if NUM_SPOT_LIGHT_COORDS > 0\\n\\tuniform mat4 spotLightMatrix[ NUM_SPOT_LIGHT_COORDS ];\\n\\tvarying vec4 vSpotLightCoord[ NUM_SPOT_LIGHT_COORDS ];\\n#endif\\n#ifdef USE_SHADOWMAP\\n\\t#if NUM_DIR_LIGHT_SHADOWS > 0\\n\\t\\tuniform mat4 directionalShadowMatrix[ NUM_DIR_LIGHT_SHADOWS ];\\n\\t\\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];\\n\\t\\tstruct DirectionalLightShadow {\\n\\t\\t\\tfloat shadowBias;\\n\\t\\t\\tfloat shadowNormalBias;\\n\\t\\t\\tfloat shadowRadius;\\n\\t\\t\\tvec2 shadowMapSize;\\n\\t\\t};\\n\\t\\tuniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];\\n\\t#endif\\n\\t#if NUM_SPOT_LIGHT_SHADOWS > 0\\n\\t\\tstruct SpotLightShadow {\\n\\t\\t\\tfloat shadowBias;\\n\\t\\t\\tfloat shadowNormalBias;\\n\\t\\t\\tfloat shadowRadius;\\n\\t\\t\\tvec2 shadowMapSize;\\n\\t\\t};\\n\\t\\tuniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];\\n\\t#endif\\n\\t#if NUM_POINT_LIGHT_SHADOWS > 0\\n\\t\\tuniform mat4 pointShadowMatrix[ NUM_POINT_LIGHT_SHADOWS ];\\n\\t\\tvarying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];\\n\\t\\tstruct PointLightShadow {\\n\\t\\t\\tfloat shadowBias;\\n\\t\\t\\tfloat shadowNormalBias;\\n\\t\\t\\tfloat shadowRadius;\\n\\t\\t\\tvec2 shadowMapSize;\\n\\t\\t\\tfloat shadowCameraNear;\\n\\t\\t\\tfloat shadowCameraFar;\\n\\t\\t};\\n\\t\\tuniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];\\n\\t#endif\\n#endif\";\n\nvar shadowmap_vertex = \"#if ( defined( USE_SHADOWMAP ) && ( NUM_DIR_LIGHT_SHADOWS > 0 || NUM_POINT_LIGHT_SHADOWS > 0 ) ) || ( NUM_SPOT_LIGHT_COORDS > 0 )\\n\\tvec3 shadowWorldNormal = inverseTransformDirection( transformedNormal, viewMatrix );\\n\\tvec4 shadowWorldPosition;\\n#endif\\n#if defined( USE_SHADOWMAP )\\n\\t#if NUM_DIR_LIGHT_SHADOWS > 0\\n\\t\\t#pragma unroll_loop_start\\n\\t\\tfor ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {\\n\\t\\t\\tshadowWorldPosition = worldPosition + vec4( shadowWorldNormal * directionalLightShadows[ i ].shadowNormalBias, 0 );\\n\\t\\t\\tvDirectionalShadowCoord[ i ] = directionalShadowMatrix[ i ] * shadowWorldPosition;\\n\\t\\t}\\n\\t\\t#pragma unroll_loop_end\\n\\t#endif\\n\\t#if NUM_POINT_LIGHT_SHADOWS > 0\\n\\t\\t#pragma unroll_loop_start\\n\\t\\tfor ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {\\n\\t\\t\\tshadowWorldPosition = worldPosition + vec4( shadowWorldNormal * pointLightShadows[ i ].shadowNormalBias, 0 );\\n\\t\\t\\tvPointShadowCoord[ i ] = pointShadowMatrix[ i ] * shadowWorldPosition;\\n\\t\\t}\\n\\t\\t#pragma unroll_loop_end\\n\\t#endif\\n#endif\\n#if NUM_SPOT_LIGHT_COORDS > 0\\n\\t#pragma unroll_loop_start\\n\\tfor ( int i = 0; i < NUM_SPOT_LIGHT_COORDS; i ++ ) {\\n\\t\\tshadowWorldPosition = worldPosition;\\n\\t\\t#if ( defined( USE_SHADOWMAP ) && UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )\\n\\t\\t\\tshadowWorldPosition.xyz += shadowWorldNormal * spotLightShadows[ i ].shadowNormalBias;\\n\\t\\t#endif\\n\\t\\tvSpotLightCoord[ i ] = spotLightMatrix[ i ] * shadowWorldPosition;\\n\\t}\\n\\t#pragma unroll_loop_end\\n#endif\";\n\nvar shadowmask_pars_fragment = \"float getShadowMask() {\\n\\tfloat shadow = 1.0;\\n\\t#ifdef USE_SHADOWMAP\\n\\t#if NUM_DIR_LIGHT_SHADOWS > 0\\n\\tDirectionalLightShadow directionalLight;\\n\\t#pragma unroll_loop_start\\n\\tfor ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {\\n\\t\\tdirectionalLight = directionalLightShadows[ i ];\\n\\t\\tshadow *= receiveShadow ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\\n\\t}\\n\\t#pragma unroll_loop_end\\n\\t#endif\\n\\t#if NUM_SPOT_LIGHT_SHADOWS > 0\\n\\tSpotLightShadow spotLight;\\n\\t#pragma unroll_loop_start\\n\\tfor ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {\\n\\t\\tspotLight = spotLightShadows[ i ];\\n\\t\\tshadow *= receiveShadow ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotLightCoord[ i ] ) : 1.0;\\n\\t}\\n\\t#pragma unroll_loop_end\\n\\t#endif\\n\\t#if NUM_POINT_LIGHT_SHADOWS > 0\\n\\tPointLightShadow pointLight;\\n\\t#pragma unroll_loop_start\\n\\tfor ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {\\n\\t\\tpointLight = pointLightShadows[ i ];\\n\\t\\tshadow *= receiveShadow ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;\\n\\t}\\n\\t#pragma unroll_loop_end\\n\\t#endif\\n\\t#endif\\n\\treturn shadow;\\n}\";\n\nvar skinbase_vertex = \"#ifdef USE_SKINNING\\n\\tmat4 boneMatX = getBoneMatrix( skinIndex.x );\\n\\tmat4 boneMatY = getBoneMatrix( skinIndex.y );\\n\\tmat4 boneMatZ = getBoneMatrix( skinIndex.z );\\n\\tmat4 boneMatW = getBoneMatrix( skinIndex.w );\\n#endif\";\n\nvar skinning_pars_vertex = \"#ifdef USE_SKINNING\\n\\tuniform mat4 bindMatrix;\\n\\tuniform mat4 bindMatrixInverse;\\n\\tuniform highp sampler2D boneTexture;\\n\\tmat4 getBoneMatrix( const in float i ) {\\n\\t\\tint size = textureSize( boneTexture, 0 ).x;\\n\\t\\tint j = int( i ) * 4;\\n\\t\\tint x = j % size;\\n\\t\\tint y = j / size;\\n\\t\\tvec4 v1 = texelFetch( boneTexture, ivec2( x, y ), 0 );\\n\\t\\tvec4 v2 = texelFetch( boneTexture, ivec2( x + 1, y ), 0 );\\n\\t\\tvec4 v3 = texelFetch( boneTexture, ivec2( x + 2, y ), 0 );\\n\\t\\tvec4 v4 = texelFetch( boneTexture, ivec2( x + 3, y ), 0 );\\n\\t\\treturn mat4( v1, v2, v3, v4 );\\n\\t}\\n#endif\";\n\nvar skinning_vertex = \"#ifdef USE_SKINNING\\n\\tvec4 skinVertex = bindMatrix * vec4( transformed, 1.0 );\\n\\tvec4 skinned = vec4( 0.0 );\\n\\tskinned += boneMatX * skinVertex * skinWeight.x;\\n\\tskinned += boneMatY * skinVertex * skinWeight.y;\\n\\tskinned += boneMatZ * skinVertex * skinWeight.z;\\n\\tskinned += boneMatW * skinVertex * skinWeight.w;\\n\\ttransformed = ( bindMatrixInverse * skinned ).xyz;\\n#endif\";\n\nvar skinnormal_vertex = \"#ifdef USE_SKINNING\\n\\tmat4 skinMatrix = mat4( 0.0 );\\n\\tskinMatrix += skinWeight.x * boneMatX;\\n\\tskinMatrix += skinWeight.y * boneMatY;\\n\\tskinMatrix += skinWeight.z * boneMatZ;\\n\\tskinMatrix += skinWeight.w * boneMatW;\\n\\tskinMatrix = bindMatrixInverse * skinMatrix * bindMatrix;\\n\\tobjectNormal = vec4( skinMatrix * vec4( objectNormal, 0.0 ) ).xyz;\\n\\t#ifdef USE_TANGENT\\n\\t\\tobjectTangent = vec4( skinMatrix * vec4( objectTangent, 0.0 ) ).xyz;\\n\\t#endif\\n#endif\";\n\nvar specularmap_fragment = \"float specularStrength;\\n#ifdef USE_SPECULARMAP\\n\\tvec4 texelSpecular = texture2D( specularMap, vSpecularMapUv );\\n\\tspecularStrength = texelSpecular.r;\\n#else\\n\\tspecularStrength = 1.0;\\n#endif\";\n\nvar specularmap_pars_fragment = \"#ifdef USE_SPECULARMAP\\n\\tuniform sampler2D specularMap;\\n#endif\";\n\nvar tonemapping_fragment = \"#if defined( TONE_MAPPING )\\n\\tgl_FragColor.rgb = toneMapping( gl_FragColor.rgb );\\n#endif\";\n\nvar tonemapping_pars_fragment = \"#ifndef saturate\\n#define saturate( a ) clamp( a, 0.0, 1.0 )\\n#endif\\nuniform float toneMappingExposure;\\nvec3 LinearToneMapping( vec3 color ) {\\n\\treturn saturate( toneMappingExposure * color );\\n}\\nvec3 ReinhardToneMapping( vec3 color ) {\\n\\tcolor *= toneMappingExposure;\\n\\treturn saturate( color / ( vec3( 1.0 ) + color ) );\\n}\\nvec3 OptimizedCineonToneMapping( vec3 color ) {\\n\\tcolor *= toneMappingExposure;\\n\\tcolor = max( vec3( 0.0 ), color - 0.004 );\\n\\treturn pow( ( color * ( 6.2 * color + 0.5 ) ) / ( color * ( 6.2 * color + 1.7 ) + 0.06 ), vec3( 2.2 ) );\\n}\\nvec3 RRTAndODTFit( vec3 v ) {\\n\\tvec3 a = v * ( v + 0.0245786 ) - 0.000090537;\\n\\tvec3 b = v * ( 0.983729 * v + 0.4329510 ) + 0.238081;\\n\\treturn a / b;\\n}\\nvec3 ACESFilmicToneMapping( vec3 color ) {\\n\\tconst mat3 ACESInputMat = mat3(\\n\\t\\tvec3( 0.59719, 0.07600, 0.02840 ),\\t\\tvec3( 0.35458, 0.90834, 0.13383 ),\\n\\t\\tvec3( 0.04823, 0.01566, 0.83777 )\\n\\t);\\n\\tconst mat3 ACESOutputMat = mat3(\\n\\t\\tvec3( 1.60475, -0.10208, -0.00327 ),\\t\\tvec3( -0.53108, 1.10813, -0.07276 ),\\n\\t\\tvec3( -0.07367, -0.00605, 1.07602 )\\n\\t);\\n\\tcolor *= toneMappingExposure / 0.6;\\n\\tcolor = ACESInputMat * color;\\n\\tcolor = RRTAndODTFit( color );\\n\\tcolor = ACESOutputMat * color;\\n\\treturn saturate( color );\\n}\\nconst mat3 LINEAR_REC2020_TO_LINEAR_SRGB = mat3(\\n\\tvec3( 1.6605, - 0.1246, - 0.0182 ),\\n\\tvec3( - 0.5876, 1.1329, - 0.1006 ),\\n\\tvec3( - 0.0728, - 0.0083, 1.1187 )\\n);\\nconst mat3 LINEAR_SRGB_TO_LINEAR_REC2020 = mat3(\\n\\tvec3( 0.6274, 0.0691, 0.0164 ),\\n\\tvec3( 0.3293, 0.9195, 0.0880 ),\\n\\tvec3( 0.0433, 0.0113, 0.8956 )\\n);\\nvec3 agxDefaultContrastApprox( vec3 x ) {\\n\\tvec3 x2 = x * x;\\n\\tvec3 x4 = x2 * x2;\\n\\treturn + 15.5 * x4 * x2\\n\\t\\t- 40.14 * x4 * x\\n\\t\\t+ 31.96 * x4\\n\\t\\t- 6.868 * x2 * x\\n\\t\\t+ 0.4298 * x2\\n\\t\\t+ 0.1191 * x\\n\\t\\t- 0.00232;\\n}\\nvec3 AgXToneMapping( vec3 color ) {\\n\\tconst mat3 AgXInsetMatrix = mat3(\\n\\t\\tvec3( 0.856627153315983, 0.137318972929847, 0.11189821299995 ),\\n\\t\\tvec3( 0.0951212405381588, 0.761241990602591, 0.0767994186031903 ),\\n\\t\\tvec3( 0.0482516061458583, 0.101439036467562, 0.811302368396859 )\\n\\t);\\n\\tconst mat3 AgXOutsetMatrix = mat3(\\n\\t\\tvec3( 1.1271005818144368, - 0.1413297634984383, - 0.14132976349843826 ),\\n\\t\\tvec3( - 0.11060664309660323, 1.157823702216272, - 0.11060664309660294 ),\\n\\t\\tvec3( - 0.016493938717834573, - 0.016493938717834257, 1.2519364065950405 )\\n\\t);\\n\\tconst float AgxMinEv = - 12.47393;\\tconst float AgxMaxEv = 4.026069;\\n\\tcolor *= toneMappingExposure;\\n\\tcolor = LINEAR_SRGB_TO_LINEAR_REC2020 * color;\\n\\tcolor = AgXInsetMatrix * color;\\n\\tcolor = max( color, 1e-10 );\\tcolor = log2( color );\\n\\tcolor = ( color - AgxMinEv ) / ( AgxMaxEv - AgxMinEv );\\n\\tcolor = clamp( color, 0.0, 1.0 );\\n\\tcolor = agxDefaultContrastApprox( color );\\n\\tcolor = AgXOutsetMatrix * color;\\n\\tcolor = pow( max( vec3( 0.0 ), color ), vec3( 2.2 ) );\\n\\tcolor = LINEAR_REC2020_TO_LINEAR_SRGB * color;\\n\\tcolor = clamp( color, 0.0, 1.0 );\\n\\treturn color;\\n}\\nvec3 NeutralToneMapping( vec3 color ) {\\n\\tfloat startCompression = 0.8 - 0.04;\\n\\tfloat desaturation = 0.15;\\n\\tcolor *= toneMappingExposure;\\n\\tfloat x = min(color.r, min(color.g, color.b));\\n\\tfloat offset = x < 0.08 ? x - 6.25 * x * x : 0.04;\\n\\tcolor -= offset;\\n\\tfloat peak = max(color.r, max(color.g, color.b));\\n\\tif (peak < startCompression) return color;\\n\\tfloat d = 1. - startCompression;\\n\\tfloat newPeak = 1. - d * d / (peak + d - startCompression);\\n\\tcolor *= newPeak / peak;\\n\\tfloat g = 1. - 1. / (desaturation * (peak - newPeak) + 1.);\\n\\treturn mix(color, newPeak * vec3(1, 1, 1), g);\\n}\\nvec3 CustomToneMapping( vec3 color ) { return color; }\";\n\nvar transmission_fragment = \"#ifdef USE_TRANSMISSION\\n\\tmaterial.transmission = transmission;\\n\\tmaterial.transmissionAlpha = 1.0;\\n\\tmaterial.thickness = thickness;\\n\\tmaterial.attenuationDistance = attenuationDistance;\\n\\tmaterial.attenuationColor = attenuationColor;\\n\\t#ifdef USE_TRANSMISSIONMAP\\n\\t\\tmaterial.transmission *= texture2D( transmissionMap, vTransmissionMapUv ).r;\\n\\t#endif\\n\\t#ifdef USE_THICKNESSMAP\\n\\t\\tmaterial.thickness *= texture2D( thicknessMap, vThicknessMapUv ).g;\\n\\t#endif\\n\\tvec3 pos = vWorldPosition;\\n\\tvec3 v = normalize( cameraPosition - pos );\\n\\tvec3 n = inverseTransformDirection( normal, viewMatrix );\\n\\tvec4 transmitted = getIBLVolumeRefraction(\\n\\t\\tn, v, material.roughness, material.diffuseColor, material.specularColor, material.specularF90,\\n\\t\\tpos, modelMatrix, viewMatrix, projectionMatrix, material.ior, material.thickness,\\n\\t\\tmaterial.attenuationColor, material.attenuationDistance );\\n\\tmaterial.transmissionAlpha = mix( material.transmissionAlpha, transmitted.a, material.transmission );\\n\\ttotalDiffuse = mix( totalDiffuse, transmitted.rgb, material.transmission );\\n#endif\";\n\nvar transmission_pars_fragment = \"#ifdef USE_TRANSMISSION\\n\\tuniform float transmission;\\n\\tuniform float thickness;\\n\\tuniform float attenuationDistance;\\n\\tuniform vec3 attenuationColor;\\n\\t#ifdef USE_TRANSMISSIONMAP\\n\\t\\tuniform sampler2D transmissionMap;\\n\\t#endif\\n\\t#ifdef USE_THICKNESSMAP\\n\\t\\tuniform sampler2D thicknessMap;\\n\\t#endif\\n\\tuniform vec2 transmissionSamplerSize;\\n\\tuniform sampler2D transmissionSamplerMap;\\n\\tuniform mat4 modelMatrix;\\n\\tuniform mat4 projectionMatrix;\\n\\tvarying vec3 vWorldPosition;\\n\\tfloat w0( float a ) {\\n\\t\\treturn ( 1.0 / 6.0 ) * ( a * ( a * ( - a + 3.0 ) - 3.0 ) + 1.0 );\\n\\t}\\n\\tfloat w1( float a ) {\\n\\t\\treturn ( 1.0 / 6.0 ) * ( a * a * ( 3.0 * a - 6.0 ) + 4.0 );\\n\\t}\\n\\tfloat w2( float a ){\\n\\t\\treturn ( 1.0 / 6.0 ) * ( a * ( a * ( - 3.0 * a + 3.0 ) + 3.0 ) + 1.0 );\\n\\t}\\n\\tfloat w3( float a ) {\\n\\t\\treturn ( 1.0 / 6.0 ) * ( a * a * a );\\n\\t}\\n\\tfloat g0( float a ) {\\n\\t\\treturn w0( a ) + w1( a );\\n\\t}\\n\\tfloat g1( float a ) {\\n\\t\\treturn w2( a ) + w3( a );\\n\\t}\\n\\tfloat h0( float a ) {\\n\\t\\treturn - 1.0 + w1( a ) / ( w0( a ) + w1( a ) );\\n\\t}\\n\\tfloat h1( float a ) {\\n\\t\\treturn 1.0 + w3( a ) / ( w2( a ) + w3( a ) );\\n\\t}\\n\\tvec4 bicubic( sampler2D tex, vec2 uv, vec4 texelSize, float lod ) {\\n\\t\\tuv = uv * texelSize.zw + 0.5;\\n\\t\\tvec2 iuv = floor( uv );\\n\\t\\tvec2 fuv = fract( uv );\\n\\t\\tfloat g0x = g0( fuv.x );\\n\\t\\tfloat g1x = g1( fuv.x );\\n\\t\\tfloat h0x = h0( fuv.x );\\n\\t\\tfloat h1x = h1( fuv.x );\\n\\t\\tfloat h0y = h0( fuv.y );\\n\\t\\tfloat h1y = h1( fuv.y );\\n\\t\\tvec2 p0 = ( vec2( iuv.x + h0x, iuv.y + h0y ) - 0.5 ) * texelSize.xy;\\n\\t\\tvec2 p1 = ( vec2( iuv.x + h1x, iuv.y + h0y ) - 0.5 ) * texelSize.xy;\\n\\t\\tvec2 p2 = ( vec2( iuv.x + h0x, iuv.y + h1y ) - 0.5 ) * texelSize.xy;\\n\\t\\tvec2 p3 = ( vec2( iuv.x + h1x, iuv.y + h1y ) - 0.5 ) * texelSize.xy;\\n\\t\\treturn g0( fuv.y ) * ( g0x * textureLod( tex, p0, lod ) + g1x * textureLod( tex, p1, lod ) ) +\\n\\t\\t\\tg1( fuv.y ) * ( g0x * textureLod( tex, p2, lod ) + g1x * textureLod( tex, p3, lod ) );\\n\\t}\\n\\tvec4 textureBicubic( sampler2D sampler, vec2 uv, float lod ) {\\n\\t\\tvec2 fLodSize = vec2( textureSize( sampler, int( lod ) ) );\\n\\t\\tvec2 cLodSize = vec2( textureSize( sampler, int( lod + 1.0 ) ) );\\n\\t\\tvec2 fLodSizeInv = 1.0 / fLodSize;\\n\\t\\tvec2 cLodSizeInv = 1.0 / cLodSize;\\n\\t\\tvec4 fSample = bicubic( sampler, uv, vec4( fLodSizeInv, fLodSize ), floor( lod ) );\\n\\t\\tvec4 cSample = bicubic( sampler, uv, vec4( cLodSizeInv, cLodSize ), ceil( lod ) );\\n\\t\\treturn mix( fSample, cSample, fract( lod ) );\\n\\t}\\n\\tvec3 getVolumeTransmissionRay( const in vec3 n, const in vec3 v, const in float thickness, const in float ior, const in mat4 modelMatrix ) {\\n\\t\\tvec3 refractionVector = refract( - v, normalize( n ), 1.0 / ior );\\n\\t\\tvec3 modelScale;\\n\\t\\tmodelScale.x = length( vec3( modelMatrix[ 0 ].xyz ) );\\n\\t\\tmodelScale.y = length( vec3( modelMatrix[ 1 ].xyz ) );\\n\\t\\tmodelScale.z = length( vec3( modelMatrix[ 2 ].xyz ) );\\n\\t\\treturn normalize( refractionVector ) * thickness * modelScale;\\n\\t}\\n\\tfloat applyIorToRoughness( const in float roughness, const in float ior ) {\\n\\t\\treturn roughness * clamp( ior * 2.0 - 2.0, 0.0, 1.0 );\\n\\t}\\n\\tvec4 getTransmissionSample( const in vec2 fragCoord, const in float roughness, const in float ior ) {\\n\\t\\tfloat lod = log2( transmissionSamplerSize.x ) * applyIorToRoughness( roughness, ior );\\n\\t\\treturn textureBicubic( transmissionSamplerMap, fragCoord.xy, lod );\\n\\t}\\n\\tvec3 volumeAttenuation( const in float transmissionDistance, const in vec3 attenuationColor, const in float attenuationDistance ) {\\n\\t\\tif ( isinf( attenuationDistance ) ) {\\n\\t\\t\\treturn vec3( 1.0 );\\n\\t\\t} else {\\n\\t\\t\\tvec3 attenuationCoefficient = -log( attenuationColor ) / attenuationDistance;\\n\\t\\t\\tvec3 transmittance = exp( - attenuationCoefficient * transmissionDistance );\\t\\t\\treturn transmittance;\\n\\t\\t}\\n\\t}\\n\\tvec4 getIBLVolumeRefraction( const in vec3 n, const in vec3 v, const in float roughness, const in vec3 diffuseColor,\\n\\t\\tconst in vec3 specularColor, const in float specularF90, const in vec3 position, const in mat4 modelMatrix,\\n\\t\\tconst in mat4 viewMatrix, const in mat4 projMatrix, const in float ior, const in float thickness,\\n\\t\\tconst in vec3 attenuationColor, const in float attenuationDistance ) {\\n\\t\\tvec3 transmissionRay = getVolumeTransmissionRay( n, v, thickness, ior, modelMatrix );\\n\\t\\tvec3 refractedRayExit = position + transmissionRay;\\n\\t\\tvec4 ndcPos = projMatrix * viewMatrix * vec4( refractedRayExit, 1.0 );\\n\\t\\tvec2 refractionCoords = ndcPos.xy / ndcPos.w;\\n\\t\\trefractionCoords += 1.0;\\n\\t\\trefractionCoords /= 2.0;\\n\\t\\tvec4 transmittedLight = getTransmissionSample( refractionCoords, roughness, ior );\\n\\t\\tvec3 transmittance = diffuseColor * volumeAttenuation( length( transmissionRay ), attenuationColor, attenuationDistance );\\n\\t\\tvec3 attenuatedColor = transmittance * transmittedLight.rgb;\\n\\t\\tvec3 F = EnvironmentBRDF( n, v, specularColor, specularF90, roughness );\\n\\t\\tfloat transmittanceFactor = ( transmittance.r + transmittance.g + transmittance.b ) / 3.0;\\n\\t\\treturn vec4( ( 1.0 - F ) * attenuatedColor, 1.0 - ( 1.0 - transmittedLight.a ) * transmittanceFactor );\\n\\t}\\n#endif\";\n\nvar uv_pars_fragment = \"#if defined( USE_UV ) || defined( USE_ANISOTROPY )\\n\\tvarying vec2 vUv;\\n#endif\\n#ifdef USE_MAP\\n\\tvarying vec2 vMapUv;\\n#endif\\n#ifdef USE_ALPHAMAP\\n\\tvarying vec2 vAlphaMapUv;\\n#endif\\n#ifdef USE_LIGHTMAP\\n\\tvarying vec2 vLightMapUv;\\n#endif\\n#ifdef USE_AOMAP\\n\\tvarying vec2 vAoMapUv;\\n#endif\\n#ifdef USE_BUMPMAP\\n\\tvarying vec2 vBumpMapUv;\\n#endif\\n#ifdef USE_NORMALMAP\\n\\tvarying vec2 vNormalMapUv;\\n#endif\\n#ifdef USE_EMISSIVEMAP\\n\\tvarying vec2 vEmissiveMapUv;\\n#endif\\n#ifdef USE_METALNESSMAP\\n\\tvarying vec2 vMetalnessMapUv;\\n#endif\\n#ifdef USE_ROUGHNESSMAP\\n\\tvarying vec2 vRoughnessMapUv;\\n#endif\\n#ifdef USE_ANISOTROPYMAP\\n\\tvarying vec2 vAnisotropyMapUv;\\n#endif\\n#ifdef USE_CLEARCOATMAP\\n\\tvarying vec2 vClearcoatMapUv;\\n#endif\\n#ifdef USE_CLEARCOAT_NORMALMAP\\n\\tvarying vec2 vClearcoatNormalMapUv;\\n#endif\\n#ifdef USE_CLEARCOAT_ROUGHNESSMAP\\n\\tvarying vec2 vClearcoatRoughnessMapUv;\\n#endif\\n#ifdef USE_IRIDESCENCEMAP\\n\\tvarying vec2 vIridescenceMapUv;\\n#endif\\n#ifdef USE_IRIDESCENCE_THICKNESSMAP\\n\\tvarying vec2 vIridescenceThicknessMapUv;\\n#endif\\n#ifdef USE_SHEEN_COLORMAP\\n\\tvarying vec2 vSheenColorMapUv;\\n#endif\\n#ifdef USE_SHEEN_ROUGHNESSMAP\\n\\tvarying vec2 vSheenRoughnessMapUv;\\n#endif\\n#ifdef USE_SPECULARMAP\\n\\tvarying vec2 vSpecularMapUv;\\n#endif\\n#ifdef USE_SPECULAR_COLORMAP\\n\\tvarying vec2 vSpecularColorMapUv;\\n#endif\\n#ifdef USE_SPECULAR_INTENSITYMAP\\n\\tvarying vec2 vSpecularIntensityMapUv;\\n#endif\\n#ifdef USE_TRANSMISSIONMAP\\n\\tuniform mat3 transmissionMapTransform;\\n\\tvarying vec2 vTransmissionMapUv;\\n#endif\\n#ifdef USE_THICKNESSMAP\\n\\tuniform mat3 thicknessMapTransform;\\n\\tvarying vec2 vThicknessMapUv;\\n#endif\";\n\nvar uv_pars_vertex = \"#if defined( USE_UV ) || defined( USE_ANISOTROPY )\\n\\tvarying vec2 vUv;\\n#endif\\n#ifdef USE_MAP\\n\\tuniform mat3 mapTransform;\\n\\tvarying vec2 vMapUv;\\n#endif\\n#ifdef USE_ALPHAMAP\\n\\tuniform mat3 alphaMapTransform;\\n\\tvarying vec2 vAlphaMapUv;\\n#endif\\n#ifdef USE_LIGHTMAP\\n\\tuniform mat3 lightMapTransform;\\n\\tvarying vec2 vLightMapUv;\\n#endif\\n#ifdef USE_AOMAP\\n\\tuniform mat3 aoMapTransform;\\n\\tvarying vec2 vAoMapUv;\\n#endif\\n#ifdef USE_BUMPMAP\\n\\tuniform mat3 bumpMapTransform;\\n\\tvarying vec2 vBumpMapUv;\\n#endif\\n#ifdef USE_NORMALMAP\\n\\tuniform mat3 normalMapTransform;\\n\\tvarying vec2 vNormalMapUv;\\n#endif\\n#ifdef USE_DISPLACEMENTMAP\\n\\tuniform mat3 displacementMapTransform;\\n\\tvarying vec2 vDisplacementMapUv;\\n#endif\\n#ifdef USE_EMISSIVEMAP\\n\\tuniform mat3 emissiveMapTransform;\\n\\tvarying vec2 vEmissiveMapUv;\\n#endif\\n#ifdef USE_METALNESSMAP\\n\\tuniform mat3 metalnessMapTransform;\\n\\tvarying vec2 vMetalnessMapUv;\\n#endif\\n#ifdef USE_ROUGHNESSMAP\\n\\tuniform mat3 roughnessMapTransform;\\n\\tvarying vec2 vRoughnessMapUv;\\n#endif\\n#ifdef USE_ANISOTROPYMAP\\n\\tuniform mat3 anisotropyMapTransform;\\n\\tvarying vec2 vAnisotropyMapUv;\\n#endif\\n#ifdef USE_CLEARCOATMAP\\n\\tuniform mat3 clearcoatMapTransform;\\n\\tvarying vec2 vClearcoatMapUv;\\n#endif\\n#ifdef USE_CLEARCOAT_NORMALMAP\\n\\tuniform mat3 clearcoatNormalMapTransform;\\n\\tvarying vec2 vClearcoatNormalMapUv;\\n#endif\\n#ifdef USE_CLEARCOAT_ROUGHNESSMAP\\n\\tuniform mat3 clearcoatRoughnessMapTransform;\\n\\tvarying vec2 vClearcoatRoughnessMapUv;\\n#endif\\n#ifdef USE_SHEEN_COLORMAP\\n\\tuniform mat3 sheenColorMapTransform;\\n\\tvarying vec2 vSheenColorMapUv;\\n#endif\\n#ifdef USE_SHEEN_ROUGHNESSMAP\\n\\tuniform mat3 sheenRoughnessMapTransform;\\n\\tvarying vec2 vSheenRoughnessMapUv;\\n#endif\\n#ifdef USE_IRIDESCENCEMAP\\n\\tuniform mat3 iridescenceMapTransform;\\n\\tvarying vec2 vIridescenceMapUv;\\n#endif\\n#ifdef USE_IRIDESCENCE_THICKNESSMAP\\n\\tuniform mat3 iridescenceThicknessMapTransform;\\n\\tvarying vec2 vIridescenceThicknessMapUv;\\n#endif\\n#ifdef USE_SPECULARMAP\\n\\tuniform mat3 specularMapTransform;\\n\\tvarying vec2 vSpecularMapUv;\\n#endif\\n#ifdef USE_SPECULAR_COLORMAP\\n\\tuniform mat3 specularColorMapTransform;\\n\\tvarying vec2 vSpecularColorMapUv;\\n#endif\\n#ifdef USE_SPECULAR_INTENSITYMAP\\n\\tuniform mat3 specularIntensityMapTransform;\\n\\tvarying vec2 vSpecularIntensityMapUv;\\n#endif\\n#ifdef USE_TRANSMISSIONMAP\\n\\tuniform mat3 transmissionMapTransform;\\n\\tvarying vec2 vTransmissionMapUv;\\n#endif\\n#ifdef USE_THICKNESSMAP\\n\\tuniform mat3 thicknessMapTransform;\\n\\tvarying vec2 vThicknessMapUv;\\n#endif\";\n\nvar uv_vertex = \"#if defined( USE_UV ) || defined( USE_ANISOTROPY )\\n\\tvUv = vec3( uv, 1 ).xy;\\n#endif\\n#ifdef USE_MAP\\n\\tvMapUv = ( mapTransform * vec3( MAP_UV, 1 ) ).xy;\\n#endif\\n#ifdef USE_ALPHAMAP\\n\\tvAlphaMapUv = ( alphaMapTransform * vec3( ALPHAMAP_UV, 1 ) ).xy;\\n#endif\\n#ifdef USE_LIGHTMAP\\n\\tvLightMapUv = ( lightMapTransform * vec3( LIGHTMAP_UV, 1 ) ).xy;\\n#endif\\n#ifdef USE_AOMAP\\n\\tvAoMapUv = ( aoMapTransform * vec3( AOMAP_UV, 1 ) ).xy;\\n#endif\\n#ifdef USE_BUMPMAP\\n\\tvBumpMapUv = ( bumpMapTransform * vec3( BUMPMAP_UV, 1 ) ).xy;\\n#endif\\n#ifdef USE_NORMALMAP\\n\\tvNormalMapUv = ( normalMapTransform * vec3( NORMALMAP_UV, 1 ) ).xy;\\n#endif\\n#ifdef USE_DISPLACEMENTMAP\\n\\tvDisplacementMapUv = ( displacementMapTransform * vec3( DISPLACEMENTMAP_UV, 1 ) ).xy;\\n#endif\\n#ifdef USE_EMISSIVEMAP\\n\\tvEmissiveMapUv = ( emissiveMapTransform * vec3( EMISSIVEMAP_UV, 1 ) ).xy;\\n#endif\\n#ifdef USE_METALNESSMAP\\n\\tvMetalnessMapUv = ( metalnessMapTransform * vec3( METALNESSMAP_UV, 1 ) ).xy;\\n#endif\\n#ifdef USE_ROUGHNESSMAP\\n\\tvRoughnessMapUv = ( roughnessMapTransform * vec3( ROUGHNESSMAP_UV, 1 ) ).xy;\\n#endif\\n#ifdef USE_ANISOTROPYMAP\\n\\tvAnisotropyMapUv = ( anisotropyMapTransform * vec3( ANISOTROPYMAP_UV, 1 ) ).xy;\\n#endif\\n#ifdef USE_CLEARCOATMAP\\n\\tvClearcoatMapUv = ( clearcoatMapTransform * vec3( CLEARCOATMAP_UV, 1 ) ).xy;\\n#endif\\n#ifdef USE_CLEARCOAT_NORMALMAP\\n\\tvClearcoatNormalMapUv = ( clearcoatNormalMapTransform * vec3( CLEARCOAT_NORMALMAP_UV, 1 ) ).xy;\\n#endif\\n#ifdef USE_CLEARCOAT_ROUGHNESSMAP\\n\\tvClearcoatRoughnessMapUv = ( clearcoatRoughnessMapTransform * vec3( CLEARCOAT_ROUGHNESSMAP_UV, 1 ) ).xy;\\n#endif\\n#ifdef USE_IRIDESCENCEMAP\\n\\tvIridescenceMapUv = ( iridescenceMapTransform * vec3( IRIDESCENCEMAP_UV, 1 ) ).xy;\\n#endif\\n#ifdef USE_IRIDESCENCE_THICKNESSMAP\\n\\tvIridescenceThicknessMapUv = ( iridescenceThicknessMapTransform * vec3( IRIDESCENCE_THICKNESSMAP_UV, 1 ) ).xy;\\n#endif\\n#ifdef USE_SHEEN_COLORMAP\\n\\tvSheenColorMapUv = ( sheenColorMapTransform * vec3( SHEEN_COLORMAP_UV, 1 ) ).xy;\\n#endif\\n#ifdef USE_SHEEN_ROUGHNESSMAP\\n\\tvSheenRoughnessMapUv = ( sheenRoughnessMapTransform * vec3( SHEEN_ROUGHNESSMAP_UV, 1 ) ).xy;\\n#endif\\n#ifdef USE_SPECULARMAP\\n\\tvSpecularMapUv = ( specularMapTransform * vec3( SPECULARMAP_UV, 1 ) ).xy;\\n#endif\\n#ifdef USE_SPECULAR_COLORMAP\\n\\tvSpecularColorMapUv = ( specularColorMapTransform * vec3( SPECULAR_COLORMAP_UV, 1 ) ).xy;\\n#endif\\n#ifdef USE_SPECULAR_INTENSITYMAP\\n\\tvSpecularIntensityMapUv = ( specularIntensityMapTransform * vec3( SPECULAR_INTENSITYMAP_UV, 1 ) ).xy;\\n#endif\\n#ifdef USE_TRANSMISSIONMAP\\n\\tvTransmissionMapUv = ( transmissionMapTransform * vec3( TRANSMISSIONMAP_UV, 1 ) ).xy;\\n#endif\\n#ifdef USE_THICKNESSMAP\\n\\tvThicknessMapUv = ( thicknessMapTransform * vec3( THICKNESSMAP_UV, 1 ) ).xy;\\n#endif\";\n\nvar worldpos_vertex = \"#if defined( USE_ENVMAP ) || defined( DISTANCE ) || defined ( USE_SHADOWMAP ) || defined ( USE_TRANSMISSION ) || NUM_SPOT_LIGHT_COORDS > 0\\n\\tvec4 worldPosition = vec4( transformed, 1.0 );\\n\\t#ifdef USE_BATCHING\\n\\t\\tworldPosition = batchingMatrix * worldPosition;\\n\\t#endif\\n\\t#ifdef USE_INSTANCING\\n\\t\\tworldPosition = instanceMatrix * worldPosition;\\n\\t#endif\\n\\tworldPosition = modelMatrix * worldPosition;\\n#endif\";\n\nconst vertex$h = \"varying vec2 vUv;\\nuniform mat3 uvTransform;\\nvoid main() {\\n\\tvUv = ( uvTransform * vec3( uv, 1 ) ).xy;\\n\\tgl_Position = vec4( position.xy, 1.0, 1.0 );\\n}\";\n\nconst fragment$h = \"uniform sampler2D t2D;\\nuniform float backgroundIntensity;\\nvarying vec2 vUv;\\nvoid main() {\\n\\tvec4 texColor = texture2D( t2D, vUv );\\n\\t#ifdef DECODE_VIDEO_TEXTURE\\n\\t\\ttexColor = vec4( mix( pow( texColor.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), texColor.rgb * 0.0773993808, vec3( lessThanEqual( texColor.rgb, vec3( 0.04045 ) ) ) ), texColor.w );\\n\\t#endif\\n\\ttexColor.rgb *= backgroundIntensity;\\n\\tgl_FragColor = texColor;\\n\\t#include \\n\\t#include \\n}\";\n\nconst vertex$g = \"varying vec3 vWorldDirection;\\n#include \\nvoid main() {\\n\\tvWorldDirection = transformDirection( position, modelMatrix );\\n\\t#include \\n\\t#include \\n\\tgl_Position.z = gl_Position.w;\\n}\";\n\nconst fragment$g = \"#ifdef ENVMAP_TYPE_CUBE\\n\\tuniform samplerCube envMap;\\n#elif defined( ENVMAP_TYPE_CUBE_UV )\\n\\tuniform sampler2D envMap;\\n#endif\\nuniform float flipEnvMap;\\nuniform float backgroundBlurriness;\\nuniform float backgroundIntensity;\\nuniform mat3 backgroundRotation;\\nvarying vec3 vWorldDirection;\\n#include \\nvoid main() {\\n\\t#ifdef ENVMAP_TYPE_CUBE\\n\\t\\tvec4 texColor = textureCube( envMap, backgroundRotation * vec3( flipEnvMap * vWorldDirection.x, vWorldDirection.yz ) );\\n\\t#elif defined( ENVMAP_TYPE_CUBE_UV )\\n\\t\\tvec4 texColor = textureCubeUV( envMap, backgroundRotation * vWorldDirection, backgroundBlurriness );\\n\\t#else\\n\\t\\tvec4 texColor = vec4( 0.0, 0.0, 0.0, 1.0 );\\n\\t#endif\\n\\ttexColor.rgb *= backgroundIntensity;\\n\\tgl_FragColor = texColor;\\n\\t#include \\n\\t#include \\n}\";\n\nconst vertex$f = \"varying vec3 vWorldDirection;\\n#include \\nvoid main() {\\n\\tvWorldDirection = transformDirection( position, modelMatrix );\\n\\t#include \\n\\t#include \\n\\tgl_Position.z = gl_Position.w;\\n}\";\n\nconst fragment$f = \"uniform samplerCube tCube;\\nuniform float tFlip;\\nuniform float opacity;\\nvarying vec3 vWorldDirection;\\nvoid main() {\\n\\tvec4 texColor = textureCube( tCube, vec3( tFlip * vWorldDirection.x, vWorldDirection.yz ) );\\n\\tgl_FragColor = texColor;\\n\\tgl_FragColor.a *= opacity;\\n\\t#include \\n\\t#include \\n}\";\n\nconst vertex$e = \"#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\nvarying vec2 vHighPrecisionZW;\\nvoid main() {\\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#ifdef USE_DISPLACEMENTMAP\\n\\t\\t#include \\n\\t\\t#include \\n\\t\\t#include \\n\\t#endif\\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\tvHighPrecisionZW = gl_Position.zw;\\n}\";\n\nconst fragment$e = \"#if DEPTH_PACKING == 3200\\n\\tuniform float opacity;\\n#endif\\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\nvarying vec2 vHighPrecisionZW;\\nvoid main() {\\n\\tvec4 diffuseColor = vec4( 1.0 );\\n\\t#include \\n\\t#if DEPTH_PACKING == 3200\\n\\t\\tdiffuseColor.a = opacity;\\n\\t#endif\\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\tfloat fragCoordZ = 0.5 * vHighPrecisionZW[0] / vHighPrecisionZW[1] + 0.5;\\n\\t#if DEPTH_PACKING == 3200\\n\\t\\tgl_FragColor = vec4( vec3( 1.0 - fragCoordZ ), opacity );\\n\\t#elif DEPTH_PACKING == 3201\\n\\t\\tgl_FragColor = packDepthToRGBA( fragCoordZ );\\n\\t#endif\\n}\";\n\nconst vertex$d = \"#define DISTANCE\\nvarying vec3 vWorldPosition;\\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\nvoid main() {\\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#ifdef USE_DISPLACEMENTMAP\\n\\t\\t#include \\n\\t\\t#include \\n\\t\\t#include \\n\\t#endif\\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\tvWorldPosition = worldPosition.xyz;\\n}\";\n\nconst fragment$d = \"#define DISTANCE\\nuniform vec3 referencePosition;\\nuniform float nearDistance;\\nuniform float farDistance;\\nvarying vec3 vWorldPosition;\\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\nvoid main () {\\n\\tvec4 diffuseColor = vec4( 1.0 );\\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\tfloat dist = length( vWorldPosition - referencePosition );\\n\\tdist = ( dist - nearDistance ) / ( farDistance - nearDistance );\\n\\tdist = saturate( dist );\\n\\tgl_FragColor = packDepthToRGBA( dist );\\n}\";\n\nconst vertex$c = \"varying vec3 vWorldDirection;\\n#include \\nvoid main() {\\n\\tvWorldDirection = transformDirection( position, modelMatrix );\\n\\t#include \\n\\t#include \\n}\";\n\nconst fragment$c = \"uniform sampler2D tEquirect;\\nvarying vec3 vWorldDirection;\\n#include \\nvoid main() {\\n\\tvec3 direction = normalize( vWorldDirection );\\n\\tvec2 sampleUV = equirectUv( direction );\\n\\tgl_FragColor = texture2D( tEquirect, sampleUV );\\n\\t#include \\n\\t#include \\n}\";\n\nconst vertex$b = \"uniform float scale;\\nattribute float lineDistance;\\nvarying float vLineDistance;\\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\nvoid main() {\\n\\tvLineDistance = scale * lineDistance;\\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n}\";\n\nconst fragment$b = \"uniform vec3 diffuse;\\nuniform float opacity;\\nuniform float dashSize;\\nuniform float totalSize;\\nvarying float vLineDistance;\\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\nvoid main() {\\n\\tvec4 diffuseColor = vec4( diffuse, opacity );\\n\\t#include \\n\\tif ( mod( vLineDistance, totalSize ) > dashSize ) {\\n\\t\\tdiscard;\\n\\t}\\n\\tvec3 outgoingLight = vec3( 0.0 );\\n\\t#include \\n\\t#include \\n\\t#include \\n\\toutgoingLight = diffuseColor.rgb;\\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n}\";\n\nconst vertex$a = \"#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\nvoid main() {\\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#if defined ( USE_ENVMAP ) || defined ( USE_SKINNING )\\n\\t\\t#include \\n\\t\\t#include \\n\\t\\t#include \\n\\t\\t#include \\n\\t\\t#include \\n\\t#endif\\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n}\";\n\nconst fragment$a = \"uniform vec3 diffuse;\\nuniform float opacity;\\n#ifndef FLAT_SHADED\\n\\tvarying vec3 vNormal;\\n#endif\\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\nvoid main() {\\n\\tvec4 diffuseColor = vec4( diffuse, opacity );\\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\\n\\t#ifdef USE_LIGHTMAP\\n\\t\\tvec4 lightMapTexel = texture2D( lightMap, vLightMapUv );\\n\\t\\treflectedLight.indirectDiffuse += lightMapTexel.rgb * lightMapIntensity * RECIPROCAL_PI;\\n\\t#else\\n\\t\\treflectedLight.indirectDiffuse += vec3( 1.0 );\\n\\t#endif\\n\\t#include \\n\\treflectedLight.indirectDiffuse *= diffuseColor.rgb;\\n\\tvec3 outgoingLight = reflectedLight.indirectDiffuse;\\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n}\";\n\nconst vertex$9 = \"#define LAMBERT\\nvarying vec3 vViewPosition;\\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\nvoid main() {\\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\tvViewPosition = - mvPosition.xyz;\\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n}\";\n\nconst fragment$9 = \"#define LAMBERT\\nuniform vec3 diffuse;\\nuniform vec3 emissive;\\nuniform float opacity;\\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\nvoid main() {\\n\\tvec4 diffuseColor = vec4( diffuse, opacity );\\n\\t#include \\n\\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\\n\\tvec3 totalEmissiveRadiance = emissive;\\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;\\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n}\";\n\nconst vertex$8 = \"#define MATCAP\\nvarying vec3 vViewPosition;\\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\nvoid main() {\\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\tvViewPosition = - mvPosition.xyz;\\n}\";\n\nconst fragment$8 = \"#define MATCAP\\nuniform vec3 diffuse;\\nuniform float opacity;\\nuniform sampler2D matcap;\\nvarying vec3 vViewPosition;\\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\nvoid main() {\\n\\tvec4 diffuseColor = vec4( diffuse, opacity );\\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\tvec3 viewDir = normalize( vViewPosition );\\n\\tvec3 x = normalize( vec3( viewDir.z, 0.0, - viewDir.x ) );\\n\\tvec3 y = cross( viewDir, x );\\n\\tvec2 uv = vec2( dot( x, normal ), dot( y, normal ) ) * 0.495 + 0.5;\\n\\t#ifdef USE_MATCAP\\n\\t\\tvec4 matcapColor = texture2D( matcap, uv );\\n\\t#else\\n\\t\\tvec4 matcapColor = vec4( vec3( mix( 0.2, 0.8, uv.y ) ), 1.0 );\\n\\t#endif\\n\\tvec3 outgoingLight = diffuseColor.rgb * matcapColor.rgb;\\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n}\";\n\nconst vertex$7 = \"#define NORMAL\\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP_TANGENTSPACE )\\n\\tvarying vec3 vViewPosition;\\n#endif\\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\nvoid main() {\\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP_TANGENTSPACE )\\n\\tvViewPosition = - mvPosition.xyz;\\n#endif\\n}\";\n\nconst fragment$7 = \"#define NORMAL\\nuniform float opacity;\\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP_TANGENTSPACE )\\n\\tvarying vec3 vViewPosition;\\n#endif\\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\nvoid main() {\\n\\tvec4 diffuseColor = vec4( 0.0, 0.0, 0.0, opacity );\\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\tgl_FragColor = vec4( packNormalToRGB( normal ), diffuseColor.a );\\n\\t#ifdef OPAQUE\\n\\t\\tgl_FragColor.a = 1.0;\\n\\t#endif\\n}\";\n\nconst vertex$6 = \"#define PHONG\\nvarying vec3 vViewPosition;\\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\nvoid main() {\\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\tvViewPosition = - mvPosition.xyz;\\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n}\";\n\nconst fragment$6 = \"#define PHONG\\nuniform vec3 diffuse;\\nuniform vec3 emissive;\\nuniform vec3 specular;\\nuniform float shininess;\\nuniform float opacity;\\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\nvoid main() {\\n\\tvec4 diffuseColor = vec4( diffuse, opacity );\\n\\t#include \\n\\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\\n\\tvec3 totalEmissiveRadiance = emissive;\\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;\\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n}\";\n\nconst vertex$5 = \"#define STANDARD\\nvarying vec3 vViewPosition;\\n#ifdef USE_TRANSMISSION\\n\\tvarying vec3 vWorldPosition;\\n#endif\\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\nvoid main() {\\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\tvViewPosition = - mvPosition.xyz;\\n\\t#include \\n\\t#include \\n\\t#include \\n#ifdef USE_TRANSMISSION\\n\\tvWorldPosition = worldPosition.xyz;\\n#endif\\n}\";\n\nconst fragment$5 = \"#define STANDARD\\n#ifdef PHYSICAL\\n\\t#define IOR\\n\\t#define USE_SPECULAR\\n#endif\\nuniform vec3 diffuse;\\nuniform vec3 emissive;\\nuniform float roughness;\\nuniform float metalness;\\nuniform float opacity;\\n#ifdef IOR\\n\\tuniform float ior;\\n#endif\\n#ifdef USE_SPECULAR\\n\\tuniform float specularIntensity;\\n\\tuniform vec3 specularColor;\\n\\t#ifdef USE_SPECULAR_COLORMAP\\n\\t\\tuniform sampler2D specularColorMap;\\n\\t#endif\\n\\t#ifdef USE_SPECULAR_INTENSITYMAP\\n\\t\\tuniform sampler2D specularIntensityMap;\\n\\t#endif\\n#endif\\n#ifdef USE_CLEARCOAT\\n\\tuniform float clearcoat;\\n\\tuniform float clearcoatRoughness;\\n#endif\\n#ifdef USE_IRIDESCENCE\\n\\tuniform float iridescence;\\n\\tuniform float iridescenceIOR;\\n\\tuniform float iridescenceThicknessMinimum;\\n\\tuniform float iridescenceThicknessMaximum;\\n#endif\\n#ifdef USE_SHEEN\\n\\tuniform vec3 sheenColor;\\n\\tuniform float sheenRoughness;\\n\\t#ifdef USE_SHEEN_COLORMAP\\n\\t\\tuniform sampler2D sheenColorMap;\\n\\t#endif\\n\\t#ifdef USE_SHEEN_ROUGHNESSMAP\\n\\t\\tuniform sampler2D sheenRoughnessMap;\\n\\t#endif\\n#endif\\n#ifdef USE_ANISOTROPY\\n\\tuniform vec2 anisotropyVector;\\n\\t#ifdef USE_ANISOTROPYMAP\\n\\t\\tuniform sampler2D anisotropyMap;\\n\\t#endif\\n#endif\\nvarying vec3 vViewPosition;\\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\nvoid main() {\\n\\tvec4 diffuseColor = vec4( diffuse, opacity );\\n\\t#include \\n\\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\\n\\tvec3 totalEmissiveRadiance = emissive;\\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\tvec3 totalDiffuse = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse;\\n\\tvec3 totalSpecular = reflectedLight.directSpecular + reflectedLight.indirectSpecular;\\n\\t#include \\n\\tvec3 outgoingLight = totalDiffuse + totalSpecular + totalEmissiveRadiance;\\n\\t#ifdef USE_SHEEN\\n\\t\\tfloat sheenEnergyComp = 1.0 - 0.157 * max3( material.sheenColor );\\n\\t\\toutgoingLight = outgoingLight * sheenEnergyComp + sheenSpecularDirect + sheenSpecularIndirect;\\n\\t#endif\\n\\t#ifdef USE_CLEARCOAT\\n\\t\\tfloat dotNVcc = saturate( dot( geometryClearcoatNormal, geometryViewDir ) );\\n\\t\\tvec3 Fcc = F_Schlick( material.clearcoatF0, material.clearcoatF90, dotNVcc );\\n\\t\\toutgoingLight = outgoingLight * ( 1.0 - material.clearcoat * Fcc ) + ( clearcoatSpecularDirect + clearcoatSpecularIndirect ) * material.clearcoat;\\n\\t#endif\\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n}\";\n\nconst vertex$4 = \"#define TOON\\nvarying vec3 vViewPosition;\\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\nvoid main() {\\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\tvViewPosition = - mvPosition.xyz;\\n\\t#include \\n\\t#include \\n\\t#include \\n}\";\n\nconst fragment$4 = \"#define TOON\\nuniform vec3 diffuse;\\nuniform vec3 emissive;\\nuniform float opacity;\\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\nvoid main() {\\n\\tvec4 diffuseColor = vec4( diffuse, opacity );\\n\\t#include \\n\\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\\n\\tvec3 totalEmissiveRadiance = emissive;\\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;\\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n}\";\n\nconst vertex$3 = \"uniform float size;\\nuniform float scale;\\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#ifdef USE_POINTS_UV\\n\\tvarying vec2 vUv;\\n\\tuniform mat3 uvTransform;\\n#endif\\nvoid main() {\\n\\t#ifdef USE_POINTS_UV\\n\\t\\tvUv = ( uvTransform * vec3( uv, 1 ) ).xy;\\n\\t#endif\\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\tgl_PointSize = size;\\n\\t#ifdef USE_SIZEATTENUATION\\n\\t\\tbool isPerspective = isPerspectiveMatrix( projectionMatrix );\\n\\t\\tif ( isPerspective ) gl_PointSize *= ( scale / - mvPosition.z );\\n\\t#endif\\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n}\";\n\nconst fragment$3 = \"uniform vec3 diffuse;\\nuniform float opacity;\\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\nvoid main() {\\n\\tvec4 diffuseColor = vec4( diffuse, opacity );\\n\\t#include \\n\\tvec3 outgoingLight = vec3( 0.0 );\\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\toutgoingLight = diffuseColor.rgb;\\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n}\";\n\nconst vertex$2 = \"#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\nvoid main() {\\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n}\";\n\nconst fragment$2 = \"uniform vec3 color;\\nuniform float opacity;\\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\nvoid main() {\\n\\t#include \\n\\tgl_FragColor = vec4( color, opacity * ( 1.0 - getShadowMask() ) );\\n\\t#include \\n\\t#include \\n\\t#include \\n}\";\n\nconst vertex$1 = \"uniform float rotation;\\nuniform vec2 center;\\n#include \\n#include \\n#include \\n#include \\n#include \\nvoid main() {\\n\\t#include \\n\\tvec4 mvPosition = modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );\\n\\tvec2 scale;\\n\\tscale.x = length( vec3( modelMatrix[ 0 ].x, modelMatrix[ 0 ].y, modelMatrix[ 0 ].z ) );\\n\\tscale.y = length( vec3( modelMatrix[ 1 ].x, modelMatrix[ 1 ].y, modelMatrix[ 1 ].z ) );\\n\\t#ifndef USE_SIZEATTENUATION\\n\\t\\tbool isPerspective = isPerspectiveMatrix( projectionMatrix );\\n\\t\\tif ( isPerspective ) scale *= - mvPosition.z;\\n\\t#endif\\n\\tvec2 alignedPosition = ( position.xy - ( center - vec2( 0.5 ) ) ) * scale;\\n\\tvec2 rotatedPosition;\\n\\trotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;\\n\\trotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;\\n\\tmvPosition.xy += rotatedPosition;\\n\\tgl_Position = projectionMatrix * mvPosition;\\n\\t#include \\n\\t#include \\n\\t#include \\n}\";\n\nconst fragment$1 = \"uniform vec3 diffuse;\\nuniform float opacity;\\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\n#include \\nvoid main() {\\n\\tvec4 diffuseColor = vec4( diffuse, opacity );\\n\\t#include \\n\\tvec3 outgoingLight = vec3( 0.0 );\\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n\\toutgoingLight = diffuseColor.rgb;\\n\\t#include \\n\\t#include \\n\\t#include \\n\\t#include \\n}\";\n\nconst ShaderChunk = {\n\talphahash_fragment: alphahash_fragment,\n\talphahash_pars_fragment: alphahash_pars_fragment,\n\talphamap_fragment: alphamap_fragment,\n\talphamap_pars_fragment: alphamap_pars_fragment,\n\talphatest_fragment: alphatest_fragment,\n\talphatest_pars_fragment: alphatest_pars_fragment,\n\taomap_fragment: aomap_fragment,\n\taomap_pars_fragment: aomap_pars_fragment,\n\tbatching_pars_vertex: batching_pars_vertex,\n\tbatching_vertex: batching_vertex,\n\tbegin_vertex: begin_vertex,\n\tbeginnormal_vertex: beginnormal_vertex,\n\tbsdfs: bsdfs,\n\tiridescence_fragment: iridescence_fragment,\n\tbumpmap_pars_fragment: bumpmap_pars_fragment,\n\tclipping_planes_fragment: clipping_planes_fragment,\n\tclipping_planes_pars_fragment: clipping_planes_pars_fragment,\n\tclipping_planes_pars_vertex: clipping_planes_pars_vertex,\n\tclipping_planes_vertex: clipping_planes_vertex,\n\tcolor_fragment: color_fragment,\n\tcolor_pars_fragment: color_pars_fragment,\n\tcolor_pars_vertex: color_pars_vertex,\n\tcolor_vertex: color_vertex,\n\tcommon: common,\n\tcube_uv_reflection_fragment: cube_uv_reflection_fragment,\n\tdefaultnormal_vertex: defaultnormal_vertex,\n\tdisplacementmap_pars_vertex: displacementmap_pars_vertex,\n\tdisplacementmap_vertex: displacementmap_vertex,\n\temissivemap_fragment: emissivemap_fragment,\n\temissivemap_pars_fragment: emissivemap_pars_fragment,\n\tcolorspace_fragment: colorspace_fragment,\n\tcolorspace_pars_fragment: colorspace_pars_fragment,\n\tenvmap_fragment: envmap_fragment,\n\tenvmap_common_pars_fragment: envmap_common_pars_fragment,\n\tenvmap_pars_fragment: envmap_pars_fragment,\n\tenvmap_pars_vertex: envmap_pars_vertex,\n\tenvmap_physical_pars_fragment: envmap_physical_pars_fragment,\n\tenvmap_vertex: envmap_vertex,\n\tfog_vertex: fog_vertex,\n\tfog_pars_vertex: fog_pars_vertex,\n\tfog_fragment: fog_fragment,\n\tfog_pars_fragment: fog_pars_fragment,\n\tgradientmap_pars_fragment: gradientmap_pars_fragment,\n\tlightmap_fragment: lightmap_fragment,\n\tlightmap_pars_fragment: lightmap_pars_fragment,\n\tlights_lambert_fragment: lights_lambert_fragment,\n\tlights_lambert_pars_fragment: lights_lambert_pars_fragment,\n\tlights_pars_begin: lights_pars_begin,\n\tlights_toon_fragment: lights_toon_fragment,\n\tlights_toon_pars_fragment: lights_toon_pars_fragment,\n\tlights_phong_fragment: lights_phong_fragment,\n\tlights_phong_pars_fragment: lights_phong_pars_fragment,\n\tlights_physical_fragment: lights_physical_fragment,\n\tlights_physical_pars_fragment: lights_physical_pars_fragment,\n\tlights_fragment_begin: lights_fragment_begin,\n\tlights_fragment_maps: lights_fragment_maps,\n\tlights_fragment_end: lights_fragment_end,\n\tlogdepthbuf_fragment: logdepthbuf_fragment,\n\tlogdepthbuf_pars_fragment: logdepthbuf_pars_fragment,\n\tlogdepthbuf_pars_vertex: logdepthbuf_pars_vertex,\n\tlogdepthbuf_vertex: logdepthbuf_vertex,\n\tmap_fragment: map_fragment,\n\tmap_pars_fragment: map_pars_fragment,\n\tmap_particle_fragment: map_particle_fragment,\n\tmap_particle_pars_fragment: map_particle_pars_fragment,\n\tmetalnessmap_fragment: metalnessmap_fragment,\n\tmetalnessmap_pars_fragment: metalnessmap_pars_fragment,\n\tmorphinstance_vertex: morphinstance_vertex,\n\tmorphcolor_vertex: morphcolor_vertex,\n\tmorphnormal_vertex: morphnormal_vertex,\n\tmorphtarget_pars_vertex: morphtarget_pars_vertex,\n\tmorphtarget_vertex: morphtarget_vertex,\n\tnormal_fragment_begin: normal_fragment_begin,\n\tnormal_fragment_maps: normal_fragment_maps,\n\tnormal_pars_fragment: normal_pars_fragment,\n\tnormal_pars_vertex: normal_pars_vertex,\n\tnormal_vertex: normal_vertex,\n\tnormalmap_pars_fragment: normalmap_pars_fragment,\n\tclearcoat_normal_fragment_begin: clearcoat_normal_fragment_begin,\n\tclearcoat_normal_fragment_maps: clearcoat_normal_fragment_maps,\n\tclearcoat_pars_fragment: clearcoat_pars_fragment,\n\tiridescence_pars_fragment: iridescence_pars_fragment,\n\topaque_fragment: opaque_fragment,\n\tpacking: packing,\n\tpremultiplied_alpha_fragment: premultiplied_alpha_fragment,\n\tproject_vertex: project_vertex,\n\tdithering_fragment: dithering_fragment,\n\tdithering_pars_fragment: dithering_pars_fragment,\n\troughnessmap_fragment: roughnessmap_fragment,\n\troughnessmap_pars_fragment: roughnessmap_pars_fragment,\n\tshadowmap_pars_fragment: shadowmap_pars_fragment,\n\tshadowmap_pars_vertex: shadowmap_pars_vertex,\n\tshadowmap_vertex: shadowmap_vertex,\n\tshadowmask_pars_fragment: shadowmask_pars_fragment,\n\tskinbase_vertex: skinbase_vertex,\n\tskinning_pars_vertex: skinning_pars_vertex,\n\tskinning_vertex: skinning_vertex,\n\tskinnormal_vertex: skinnormal_vertex,\n\tspecularmap_fragment: specularmap_fragment,\n\tspecularmap_pars_fragment: specularmap_pars_fragment,\n\ttonemapping_fragment: tonemapping_fragment,\n\ttonemapping_pars_fragment: tonemapping_pars_fragment,\n\ttransmission_fragment: transmission_fragment,\n\ttransmission_pars_fragment: transmission_pars_fragment,\n\tuv_pars_fragment: uv_pars_fragment,\n\tuv_pars_vertex: uv_pars_vertex,\n\tuv_vertex: uv_vertex,\n\tworldpos_vertex: worldpos_vertex,\n\n\tbackground_vert: vertex$h,\n\tbackground_frag: fragment$h,\n\tbackgroundCube_vert: vertex$g,\n\tbackgroundCube_frag: fragment$g,\n\tcube_vert: vertex$f,\n\tcube_frag: fragment$f,\n\tdepth_vert: vertex$e,\n\tdepth_frag: fragment$e,\n\tdistanceRGBA_vert: vertex$d,\n\tdistanceRGBA_frag: fragment$d,\n\tequirect_vert: vertex$c,\n\tequirect_frag: fragment$c,\n\tlinedashed_vert: vertex$b,\n\tlinedashed_frag: fragment$b,\n\tmeshbasic_vert: vertex$a,\n\tmeshbasic_frag: fragment$a,\n\tmeshlambert_vert: vertex$9,\n\tmeshlambert_frag: fragment$9,\n\tmeshmatcap_vert: vertex$8,\n\tmeshmatcap_frag: fragment$8,\n\tmeshnormal_vert: vertex$7,\n\tmeshnormal_frag: fragment$7,\n\tmeshphong_vert: vertex$6,\n\tmeshphong_frag: fragment$6,\n\tmeshphysical_vert: vertex$5,\n\tmeshphysical_frag: fragment$5,\n\tmeshtoon_vert: vertex$4,\n\tmeshtoon_frag: fragment$4,\n\tpoints_vert: vertex$3,\n\tpoints_frag: fragment$3,\n\tshadow_vert: vertex$2,\n\tshadow_frag: fragment$2,\n\tsprite_vert: vertex$1,\n\tsprite_frag: fragment$1\n};\n\n/**\n * Uniforms library for shared webgl shaders\n */\n\nconst UniformsLib = {\n\n\tcommon: {\n\n\t\tdiffuse: { value: /*@__PURE__*/ new Color( 0xffffff ) },\n\t\topacity: { value: 1.0 },\n\n\t\tmap: { value: null },\n\t\tmapTransform: { value: /*@__PURE__*/ new Matrix3() },\n\n\t\talphaMap: { value: null },\n\t\talphaMapTransform: { value: /*@__PURE__*/ new Matrix3() },\n\n\t\talphaTest: { value: 0 }\n\n\t},\n\n\tspecularmap: {\n\n\t\tspecularMap: { value: null },\n\t\tspecularMapTransform: { value: /*@__PURE__*/ new Matrix3() }\n\n\t},\n\n\tenvmap: {\n\n\t\tenvMap: { value: null },\n\t\tenvMapRotation: { value: /*@__PURE__*/ new Matrix3() },\n\t\tflipEnvMap: { value: - 1 },\n\t\treflectivity: { value: 1.0 }, // basic, lambert, phong\n\t\tior: { value: 1.5 }, // physical\n\t\trefractionRatio: { value: 0.98 }, // basic, lambert, phong\n\n\t},\n\n\taomap: {\n\n\t\taoMap: { value: null },\n\t\taoMapIntensity: { value: 1 },\n\t\taoMapTransform: { value: /*@__PURE__*/ new Matrix3() }\n\n\t},\n\n\tlightmap: {\n\n\t\tlightMap: { value: null },\n\t\tlightMapIntensity: { value: 1 },\n\t\tlightMapTransform: { value: /*@__PURE__*/ new Matrix3() }\n\n\t},\n\n\tbumpmap: {\n\n\t\tbumpMap: { value: null },\n\t\tbumpMapTransform: { value: /*@__PURE__*/ new Matrix3() },\n\t\tbumpScale: { value: 1 }\n\n\t},\n\n\tnormalmap: {\n\n\t\tnormalMap: { value: null },\n\t\tnormalMapTransform: { value: /*@__PURE__*/ new Matrix3() },\n\t\tnormalScale: { value: /*@__PURE__*/ new Vector2( 1, 1 ) }\n\n\t},\n\n\tdisplacementmap: {\n\n\t\tdisplacementMap: { value: null },\n\t\tdisplacementMapTransform: { value: /*@__PURE__*/ new Matrix3() },\n\t\tdisplacementScale: { value: 1 },\n\t\tdisplacementBias: { value: 0 }\n\n\t},\n\n\temissivemap: {\n\n\t\temissiveMap: { value: null },\n\t\temissiveMapTransform: { value: /*@__PURE__*/ new Matrix3() }\n\n\t},\n\n\tmetalnessmap: {\n\n\t\tmetalnessMap: { value: null },\n\t\tmetalnessMapTransform: { value: /*@__PURE__*/ new Matrix3() }\n\n\t},\n\n\troughnessmap: {\n\n\t\troughnessMap: { value: null },\n\t\troughnessMapTransform: { value: /*@__PURE__*/ new Matrix3() }\n\n\t},\n\n\tgradientmap: {\n\n\t\tgradientMap: { value: null }\n\n\t},\n\n\tfog: {\n\n\t\tfogDensity: { value: 0.00025 },\n\t\tfogNear: { value: 1 },\n\t\tfogFar: { value: 2000 },\n\t\tfogColor: { value: /*@__PURE__*/ new Color( 0xffffff ) }\n\n\t},\n\n\tlights: {\n\n\t\tambientLightColor: { value: [] },\n\n\t\tlightProbe: { value: [] },\n\n\t\tdirectionalLights: { value: [], properties: {\n\t\t\tdirection: {},\n\t\t\tcolor: {}\n\t\t} },\n\n\t\tdirectionalLightShadows: { value: [], properties: {\n\t\t\tshadowBias: {},\n\t\t\tshadowNormalBias: {},\n\t\t\tshadowRadius: {},\n\t\t\tshadowMapSize: {}\n\t\t} },\n\n\t\tdirectionalShadowMap: { value: [] },\n\t\tdirectionalShadowMatrix: { value: [] },\n\n\t\tspotLights: { value: [], properties: {\n\t\t\tcolor: {},\n\t\t\tposition: {},\n\t\t\tdirection: {},\n\t\t\tdistance: {},\n\t\t\tconeCos: {},\n\t\t\tpenumbraCos: {},\n\t\t\tdecay: {}\n\t\t} },\n\n\t\tspotLightShadows: { value: [], properties: {\n\t\t\tshadowBias: {},\n\t\t\tshadowNormalBias: {},\n\t\t\tshadowRadius: {},\n\t\t\tshadowMapSize: {}\n\t\t} },\n\n\t\tspotLightMap: { value: [] },\n\t\tspotShadowMap: { value: [] },\n\t\tspotLightMatrix: { value: [] },\n\n\t\tpointLights: { value: [], properties: {\n\t\t\tcolor: {},\n\t\t\tposition: {},\n\t\t\tdecay: {},\n\t\t\tdistance: {}\n\t\t} },\n\n\t\tpointLightShadows: { value: [], properties: {\n\t\t\tshadowBias: {},\n\t\t\tshadowNormalBias: {},\n\t\t\tshadowRadius: {},\n\t\t\tshadowMapSize: {},\n\t\t\tshadowCameraNear: {},\n\t\t\tshadowCameraFar: {}\n\t\t} },\n\n\t\tpointShadowMap: { value: [] },\n\t\tpointShadowMatrix: { value: [] },\n\n\t\themisphereLights: { value: [], properties: {\n\t\t\tdirection: {},\n\t\t\tskyColor: {},\n\t\t\tgroundColor: {}\n\t\t} },\n\n\t\t// TODO (abelnation): RectAreaLight BRDF data needs to be moved from example to main src\n\t\trectAreaLights: { value: [], properties: {\n\t\t\tcolor: {},\n\t\t\tposition: {},\n\t\t\twidth: {},\n\t\t\theight: {}\n\t\t} },\n\n\t\tltc_1: { value: null },\n\t\tltc_2: { value: null }\n\n\t},\n\n\tpoints: {\n\n\t\tdiffuse: { value: /*@__PURE__*/ new Color( 0xffffff ) },\n\t\topacity: { value: 1.0 },\n\t\tsize: { value: 1.0 },\n\t\tscale: { value: 1.0 },\n\t\tmap: { value: null },\n\t\talphaMap: { value: null },\n\t\talphaMapTransform: { value: /*@__PURE__*/ new Matrix3() },\n\t\talphaTest: { value: 0 },\n\t\tuvTransform: { value: /*@__PURE__*/ new Matrix3() }\n\n\t},\n\n\tsprite: {\n\n\t\tdiffuse: { value: /*@__PURE__*/ new Color( 0xffffff ) },\n\t\topacity: { value: 1.0 },\n\t\tcenter: { value: /*@__PURE__*/ new Vector2( 0.5, 0.5 ) },\n\t\trotation: { value: 0.0 },\n\t\tmap: { value: null },\n\t\tmapTransform: { value: /*@__PURE__*/ new Matrix3() },\n\t\talphaMap: { value: null },\n\t\talphaMapTransform: { value: /*@__PURE__*/ new Matrix3() },\n\t\talphaTest: { value: 0 }\n\n\t}\n\n};\n\nconst ShaderLib = {\n\n\tbasic: {\n\n\t\tuniforms: /*@__PURE__*/ mergeUniforms( [\n\t\t\tUniformsLib.common,\n\t\t\tUniformsLib.specularmap,\n\t\t\tUniformsLib.envmap,\n\t\t\tUniformsLib.aomap,\n\t\t\tUniformsLib.lightmap,\n\t\t\tUniformsLib.fog\n\t\t] ),\n\n\t\tvertexShader: ShaderChunk.meshbasic_vert,\n\t\tfragmentShader: ShaderChunk.meshbasic_frag\n\n\t},\n\n\tlambert: {\n\n\t\tuniforms: /*@__PURE__*/ mergeUniforms( [\n\t\t\tUniformsLib.common,\n\t\t\tUniformsLib.specularmap,\n\t\t\tUniformsLib.envmap,\n\t\t\tUniformsLib.aomap,\n\t\t\tUniformsLib.lightmap,\n\t\t\tUniformsLib.emissivemap,\n\t\t\tUniformsLib.bumpmap,\n\t\t\tUniformsLib.normalmap,\n\t\t\tUniformsLib.displacementmap,\n\t\t\tUniformsLib.fog,\n\t\t\tUniformsLib.lights,\n\t\t\t{\n\t\t\t\temissive: { value: /*@__PURE__*/ new Color( 0x000000 ) }\n\t\t\t}\n\t\t] ),\n\n\t\tvertexShader: ShaderChunk.meshlambert_vert,\n\t\tfragmentShader: ShaderChunk.meshlambert_frag\n\n\t},\n\n\tphong: {\n\n\t\tuniforms: /*@__PURE__*/ mergeUniforms( [\n\t\t\tUniformsLib.common,\n\t\t\tUniformsLib.specularmap,\n\t\t\tUniformsLib.envmap,\n\t\t\tUniformsLib.aomap,\n\t\t\tUniformsLib.lightmap,\n\t\t\tUniformsLib.emissivemap,\n\t\t\tUniformsLib.bumpmap,\n\t\t\tUniformsLib.normalmap,\n\t\t\tUniformsLib.displacementmap,\n\t\t\tUniformsLib.fog,\n\t\t\tUniformsLib.lights,\n\t\t\t{\n\t\t\t\temissive: { value: /*@__PURE__*/ new Color( 0x000000 ) },\n\t\t\t\tspecular: { value: /*@__PURE__*/ new Color( 0x111111 ) },\n\t\t\t\tshininess: { value: 30 }\n\t\t\t}\n\t\t] ),\n\n\t\tvertexShader: ShaderChunk.meshphong_vert,\n\t\tfragmentShader: ShaderChunk.meshphong_frag\n\n\t},\n\n\tstandard: {\n\n\t\tuniforms: /*@__PURE__*/ mergeUniforms( [\n\t\t\tUniformsLib.common,\n\t\t\tUniformsLib.envmap,\n\t\t\tUniformsLib.aomap,\n\t\t\tUniformsLib.lightmap,\n\t\t\tUniformsLib.emissivemap,\n\t\t\tUniformsLib.bumpmap,\n\t\t\tUniformsLib.normalmap,\n\t\t\tUniformsLib.displacementmap,\n\t\t\tUniformsLib.roughnessmap,\n\t\t\tUniformsLib.metalnessmap,\n\t\t\tUniformsLib.fog,\n\t\t\tUniformsLib.lights,\n\t\t\t{\n\t\t\t\temissive: { value: /*@__PURE__*/ new Color( 0x000000 ) },\n\t\t\t\troughness: { value: 1.0 },\n\t\t\t\tmetalness: { value: 0.0 },\n\t\t\t\tenvMapIntensity: { value: 1 }\n\t\t\t}\n\t\t] ),\n\n\t\tvertexShader: ShaderChunk.meshphysical_vert,\n\t\tfragmentShader: ShaderChunk.meshphysical_frag\n\n\t},\n\n\ttoon: {\n\n\t\tuniforms: /*@__PURE__*/ mergeUniforms( [\n\t\t\tUniformsLib.common,\n\t\t\tUniformsLib.aomap,\n\t\t\tUniformsLib.lightmap,\n\t\t\tUniformsLib.emissivemap,\n\t\t\tUniformsLib.bumpmap,\n\t\t\tUniformsLib.normalmap,\n\t\t\tUniformsLib.displacementmap,\n\t\t\tUniformsLib.gradientmap,\n\t\t\tUniformsLib.fog,\n\t\t\tUniformsLib.lights,\n\t\t\t{\n\t\t\t\temissive: { value: /*@__PURE__*/ new Color( 0x000000 ) }\n\t\t\t}\n\t\t] ),\n\n\t\tvertexShader: ShaderChunk.meshtoon_vert,\n\t\tfragmentShader: ShaderChunk.meshtoon_frag\n\n\t},\n\n\tmatcap: {\n\n\t\tuniforms: /*@__PURE__*/ mergeUniforms( [\n\t\t\tUniformsLib.common,\n\t\t\tUniformsLib.bumpmap,\n\t\t\tUniformsLib.normalmap,\n\t\t\tUniformsLib.displacementmap,\n\t\t\tUniformsLib.fog,\n\t\t\t{\n\t\t\t\tmatcap: { value: null }\n\t\t\t}\n\t\t] ),\n\n\t\tvertexShader: ShaderChunk.meshmatcap_vert,\n\t\tfragmentShader: ShaderChunk.meshmatcap_frag\n\n\t},\n\n\tpoints: {\n\n\t\tuniforms: /*@__PURE__*/ mergeUniforms( [\n\t\t\tUniformsLib.points,\n\t\t\tUniformsLib.fog\n\t\t] ),\n\n\t\tvertexShader: ShaderChunk.points_vert,\n\t\tfragmentShader: ShaderChunk.points_frag\n\n\t},\n\n\tdashed: {\n\n\t\tuniforms: /*@__PURE__*/ mergeUniforms( [\n\t\t\tUniformsLib.common,\n\t\t\tUniformsLib.fog,\n\t\t\t{\n\t\t\t\tscale: { value: 1 },\n\t\t\t\tdashSize: { value: 1 },\n\t\t\t\ttotalSize: { value: 2 }\n\t\t\t}\n\t\t] ),\n\n\t\tvertexShader: ShaderChunk.linedashed_vert,\n\t\tfragmentShader: ShaderChunk.linedashed_frag\n\n\t},\n\n\tdepth: {\n\n\t\tuniforms: /*@__PURE__*/ mergeUniforms( [\n\t\t\tUniformsLib.common,\n\t\t\tUniformsLib.displacementmap\n\t\t] ),\n\n\t\tvertexShader: ShaderChunk.depth_vert,\n\t\tfragmentShader: ShaderChunk.depth_frag\n\n\t},\n\n\tnormal: {\n\n\t\tuniforms: /*@__PURE__*/ mergeUniforms( [\n\t\t\tUniformsLib.common,\n\t\t\tUniformsLib.bumpmap,\n\t\t\tUniformsLib.normalmap,\n\t\t\tUniformsLib.displacementmap,\n\t\t\t{\n\t\t\t\topacity: { value: 1.0 }\n\t\t\t}\n\t\t] ),\n\n\t\tvertexShader: ShaderChunk.meshnormal_vert,\n\t\tfragmentShader: ShaderChunk.meshnormal_frag\n\n\t},\n\n\tsprite: {\n\n\t\tuniforms: /*@__PURE__*/ mergeUniforms( [\n\t\t\tUniformsLib.sprite,\n\t\t\tUniformsLib.fog\n\t\t] ),\n\n\t\tvertexShader: ShaderChunk.sprite_vert,\n\t\tfragmentShader: ShaderChunk.sprite_frag\n\n\t},\n\n\tbackground: {\n\n\t\tuniforms: {\n\t\t\tuvTransform: { value: /*@__PURE__*/ new Matrix3() },\n\t\t\tt2D: { value: null },\n\t\t\tbackgroundIntensity: { value: 1 }\n\t\t},\n\n\t\tvertexShader: ShaderChunk.background_vert,\n\t\tfragmentShader: ShaderChunk.background_frag\n\n\t},\n\n\tbackgroundCube: {\n\n\t\tuniforms: {\n\t\t\tenvMap: { value: null },\n\t\t\tflipEnvMap: { value: - 1 },\n\t\t\tbackgroundBlurriness: { value: 0 },\n\t\t\tbackgroundIntensity: { value: 1 },\n\t\t\tbackgroundRotation: { value: /*@__PURE__*/ new Matrix3() }\n\t\t},\n\n\t\tvertexShader: ShaderChunk.backgroundCube_vert,\n\t\tfragmentShader: ShaderChunk.backgroundCube_frag\n\n\t},\n\n\tcube: {\n\n\t\tuniforms: {\n\t\t\ttCube: { value: null },\n\t\t\ttFlip: { value: - 1 },\n\t\t\topacity: { value: 1.0 }\n\t\t},\n\n\t\tvertexShader: ShaderChunk.cube_vert,\n\t\tfragmentShader: ShaderChunk.cube_frag\n\n\t},\n\n\tequirect: {\n\n\t\tuniforms: {\n\t\t\ttEquirect: { value: null },\n\t\t},\n\n\t\tvertexShader: ShaderChunk.equirect_vert,\n\t\tfragmentShader: ShaderChunk.equirect_frag\n\n\t},\n\n\tdistanceRGBA: {\n\n\t\tuniforms: /*@__PURE__*/ mergeUniforms( [\n\t\t\tUniformsLib.common,\n\t\t\tUniformsLib.displacementmap,\n\t\t\t{\n\t\t\t\treferencePosition: { value: /*@__PURE__*/ new Vector3() },\n\t\t\t\tnearDistance: { value: 1 },\n\t\t\t\tfarDistance: { value: 1000 }\n\t\t\t}\n\t\t] ),\n\n\t\tvertexShader: ShaderChunk.distanceRGBA_vert,\n\t\tfragmentShader: ShaderChunk.distanceRGBA_frag\n\n\t},\n\n\tshadow: {\n\n\t\tuniforms: /*@__PURE__*/ mergeUniforms( [\n\t\t\tUniformsLib.lights,\n\t\t\tUniformsLib.fog,\n\t\t\t{\n\t\t\t\tcolor: { value: /*@__PURE__*/ new Color( 0x00000 ) },\n\t\t\t\topacity: { value: 1.0 }\n\t\t\t},\n\t\t] ),\n\n\t\tvertexShader: ShaderChunk.shadow_vert,\n\t\tfragmentShader: ShaderChunk.shadow_frag\n\n\t}\n\n};\n\nShaderLib.physical = {\n\n\tuniforms: /*@__PURE__*/ mergeUniforms( [\n\t\tShaderLib.standard.uniforms,\n\t\t{\n\t\t\tclearcoat: { value: 0 },\n\t\t\tclearcoatMap: { value: null },\n\t\t\tclearcoatMapTransform: { value: /*@__PURE__*/ new Matrix3() },\n\t\t\tclearcoatNormalMap: { value: null },\n\t\t\tclearcoatNormalMapTransform: { value: /*@__PURE__*/ new Matrix3() },\n\t\t\tclearcoatNormalScale: { value: /*@__PURE__*/ new Vector2( 1, 1 ) },\n\t\t\tclearcoatRoughness: { value: 0 },\n\t\t\tclearcoatRoughnessMap: { value: null },\n\t\t\tclearcoatRoughnessMapTransform: { value: /*@__PURE__*/ new Matrix3() },\n\t\t\tiridescence: { value: 0 },\n\t\t\tiridescenceMap: { value: null },\n\t\t\tiridescenceMapTransform: { value: /*@__PURE__*/ new Matrix3() },\n\t\t\tiridescenceIOR: { value: 1.3 },\n\t\t\tiridescenceThicknessMinimum: { value: 100 },\n\t\t\tiridescenceThicknessMaximum: { value: 400 },\n\t\t\tiridescenceThicknessMap: { value: null },\n\t\t\tiridescenceThicknessMapTransform: { value: /*@__PURE__*/ new Matrix3() },\n\t\t\tsheen: { value: 0 },\n\t\t\tsheenColor: { value: /*@__PURE__*/ new Color( 0x000000 ) },\n\t\t\tsheenColorMap: { value: null },\n\t\t\tsheenColorMapTransform: { value: /*@__PURE__*/ new Matrix3() },\n\t\t\tsheenRoughness: { value: 1 },\n\t\t\tsheenRoughnessMap: { value: null },\n\t\t\tsheenRoughnessMapTransform: { value: /*@__PURE__*/ new Matrix3() },\n\t\t\ttransmission: { value: 0 },\n\t\t\ttransmissionMap: { value: null },\n\t\t\ttransmissionMapTransform: { value: /*@__PURE__*/ new Matrix3() },\n\t\t\ttransmissionSamplerSize: { value: /*@__PURE__*/ new Vector2() },\n\t\t\ttransmissionSamplerMap: { value: null },\n\t\t\tthickness: { value: 0 },\n\t\t\tthicknessMap: { value: null },\n\t\t\tthicknessMapTransform: { value: /*@__PURE__*/ new Matrix3() },\n\t\t\tattenuationDistance: { value: 0 },\n\t\t\tattenuationColor: { value: /*@__PURE__*/ new Color( 0x000000 ) },\n\t\t\tspecularColor: { value: /*@__PURE__*/ new Color( 1, 1, 1 ) },\n\t\t\tspecularColorMap: { value: null },\n\t\t\tspecularColorMapTransform: { value: /*@__PURE__*/ new Matrix3() },\n\t\t\tspecularIntensity: { value: 1 },\n\t\t\tspecularIntensityMap: { value: null },\n\t\t\tspecularIntensityMapTransform: { value: /*@__PURE__*/ new Matrix3() },\n\t\t\tanisotropyVector: { value: /*@__PURE__*/ new Vector2() },\n\t\t\tanisotropyMap: { value: null },\n\t\t\tanisotropyMapTransform: { value: /*@__PURE__*/ new Matrix3() },\n\t\t}\n\t] ),\n\n\tvertexShader: ShaderChunk.meshphysical_vert,\n\tfragmentShader: ShaderChunk.meshphysical_frag\n\n};\n\nconst _rgb = { r: 0, b: 0, g: 0 };\nconst _e1$1 = /*@__PURE__*/ new Euler();\nconst _m1$1 = /*@__PURE__*/ new Matrix4();\n\nfunction WebGLBackground( renderer, cubemaps, cubeuvmaps, state, objects, alpha, premultipliedAlpha ) {\n\n\tconst clearColor = new Color( 0x000000 );\n\tlet clearAlpha = alpha === true ? 0 : 1;\n\n\tlet planeMesh;\n\tlet boxMesh;\n\n\tlet currentBackground = null;\n\tlet currentBackgroundVersion = 0;\n\tlet currentTonemapping = null;\n\n\tfunction render( renderList, scene ) {\n\n\t\tlet forceClear = false;\n\t\tlet background = scene.isScene === true ? scene.background : null;\n\n\t\tif ( background && background.isTexture ) {\n\n\t\t\tconst usePMREM = scene.backgroundBlurriness > 0; // use PMREM if the user wants to blur the background\n\t\t\tbackground = ( usePMREM ? cubeuvmaps : cubemaps ).get( background );\n\n\t\t}\n\n\t\tif ( background === null ) {\n\n\t\t\tsetClear( clearColor, clearAlpha );\n\n\t\t} else if ( background && background.isColor ) {\n\n\t\t\tsetClear( background, 1 );\n\t\t\tforceClear = true;\n\n\t\t}\n\n\t\tconst environmentBlendMode = renderer.xr.getEnvironmentBlendMode();\n\n\t\tif ( environmentBlendMode === 'additive' ) {\n\n\t\t\tstate.buffers.color.setClear( 0, 0, 0, 1, premultipliedAlpha );\n\n\t\t} else if ( environmentBlendMode === 'alpha-blend' ) {\n\n\t\t\tstate.buffers.color.setClear( 0, 0, 0, 0, premultipliedAlpha );\n\n\t\t}\n\n\t\tif ( renderer.autoClear || forceClear ) {\n\n\t\t\trenderer.clear( renderer.autoClearColor, renderer.autoClearDepth, renderer.autoClearStencil );\n\n\t\t}\n\n\t\tif ( background && ( background.isCubeTexture || background.mapping === CubeUVReflectionMapping ) ) {\n\n\t\t\tif ( boxMesh === undefined ) {\n\n\t\t\t\tboxMesh = new Mesh(\n\t\t\t\t\tnew BoxGeometry( 1, 1, 1 ),\n\t\t\t\t\tnew ShaderMaterial( {\n\t\t\t\t\t\tname: 'BackgroundCubeMaterial',\n\t\t\t\t\t\tuniforms: cloneUniforms( ShaderLib.backgroundCube.uniforms ),\n\t\t\t\t\t\tvertexShader: ShaderLib.backgroundCube.vertexShader,\n\t\t\t\t\t\tfragmentShader: ShaderLib.backgroundCube.fragmentShader,\n\t\t\t\t\t\tside: BackSide,\n\t\t\t\t\t\tdepthTest: false,\n\t\t\t\t\t\tdepthWrite: false,\n\t\t\t\t\t\tfog: false\n\t\t\t\t\t} )\n\t\t\t\t);\n\n\t\t\t\tboxMesh.geometry.deleteAttribute( 'normal' );\n\t\t\t\tboxMesh.geometry.deleteAttribute( 'uv' );\n\n\t\t\t\tboxMesh.onBeforeRender = function ( renderer, scene, camera ) {\n\n\t\t\t\t\tthis.matrixWorld.copyPosition( camera.matrixWorld );\n\n\t\t\t\t};\n\n\t\t\t\t// add \"envMap\" material property so the renderer can evaluate it like for built-in materials\n\t\t\t\tObject.defineProperty( boxMesh.material, 'envMap', {\n\n\t\t\t\t\tget: function () {\n\n\t\t\t\t\t\treturn this.uniforms.envMap.value;\n\n\t\t\t\t\t}\n\n\t\t\t\t} );\n\n\t\t\t\tobjects.update( boxMesh );\n\n\t\t\t}\n\n\t\t\t_e1$1.copy( scene.backgroundRotation );\n\n\t\t\t// accommodate left-handed frame\n\t\t\t_e1$1.x *= - 1; _e1$1.y *= - 1; _e1$1.z *= - 1;\n\n\t\t\tif ( background.isCubeTexture && background.isRenderTargetTexture === false ) {\n\n\t\t\t\t// environment maps which are not cube render targets or PMREMs follow a different convention\n\t\t\t\t_e1$1.y *= - 1;\n\t\t\t\t_e1$1.z *= - 1;\n\n\t\t\t}\n\n\t\t\tboxMesh.material.uniforms.envMap.value = background;\n\t\t\tboxMesh.material.uniforms.flipEnvMap.value = ( background.isCubeTexture && background.isRenderTargetTexture === false ) ? - 1 : 1;\n\t\t\tboxMesh.material.uniforms.backgroundBlurriness.value = scene.backgroundBlurriness;\n\t\t\tboxMesh.material.uniforms.backgroundIntensity.value = scene.backgroundIntensity;\n\t\t\tboxMesh.material.uniforms.backgroundRotation.value.setFromMatrix4( _m1$1.makeRotationFromEuler( _e1$1 ) );\n\t\t\tboxMesh.material.toneMapped = ColorManagement.getTransfer( background.colorSpace ) !== SRGBTransfer;\n\n\t\t\tif ( currentBackground !== background ||\n\t\t\t\tcurrentBackgroundVersion !== background.version ||\n\t\t\t\tcurrentTonemapping !== renderer.toneMapping ) {\n\n\t\t\t\tboxMesh.material.needsUpdate = true;\n\n\t\t\t\tcurrentBackground = background;\n\t\t\t\tcurrentBackgroundVersion = background.version;\n\t\t\t\tcurrentTonemapping = renderer.toneMapping;\n\n\t\t\t}\n\n\t\t\tboxMesh.layers.enableAll();\n\n\t\t\t// push to the pre-sorted opaque render list\n\t\t\trenderList.unshift( boxMesh, boxMesh.geometry, boxMesh.material, 0, 0, null );\n\n\t\t} else if ( background && background.isTexture ) {\n\n\t\t\tif ( planeMesh === undefined ) {\n\n\t\t\t\tplaneMesh = new Mesh(\n\t\t\t\t\tnew PlaneGeometry( 2, 2 ),\n\t\t\t\t\tnew ShaderMaterial( {\n\t\t\t\t\t\tname: 'BackgroundMaterial',\n\t\t\t\t\t\tuniforms: cloneUniforms( ShaderLib.background.uniforms ),\n\t\t\t\t\t\tvertexShader: ShaderLib.background.vertexShader,\n\t\t\t\t\t\tfragmentShader: ShaderLib.background.fragmentShader,\n\t\t\t\t\t\tside: FrontSide,\n\t\t\t\t\t\tdepthTest: false,\n\t\t\t\t\t\tdepthWrite: false,\n\t\t\t\t\t\tfog: false\n\t\t\t\t\t} )\n\t\t\t\t);\n\n\t\t\t\tplaneMesh.geometry.deleteAttribute( 'normal' );\n\n\t\t\t\t// add \"map\" material property so the renderer can evaluate it like for built-in materials\n\t\t\t\tObject.defineProperty( planeMesh.material, 'map', {\n\n\t\t\t\t\tget: function () {\n\n\t\t\t\t\t\treturn this.uniforms.t2D.value;\n\n\t\t\t\t\t}\n\n\t\t\t\t} );\n\n\t\t\t\tobjects.update( planeMesh );\n\n\t\t\t}\n\n\t\t\tplaneMesh.material.uniforms.t2D.value = background;\n\t\t\tplaneMesh.material.uniforms.backgroundIntensity.value = scene.backgroundIntensity;\n\t\t\tplaneMesh.material.toneMapped = ColorManagement.getTransfer( background.colorSpace ) !== SRGBTransfer;\n\n\t\t\tif ( background.matrixAutoUpdate === true ) {\n\n\t\t\t\tbackground.updateMatrix();\n\n\t\t\t}\n\n\t\t\tplaneMesh.material.uniforms.uvTransform.value.copy( background.matrix );\n\n\t\t\tif ( currentBackground !== background ||\n\t\t\t\tcurrentBackgroundVersion !== background.version ||\n\t\t\t\tcurrentTonemapping !== renderer.toneMapping ) {\n\n\t\t\t\tplaneMesh.material.needsUpdate = true;\n\n\t\t\t\tcurrentBackground = background;\n\t\t\t\tcurrentBackgroundVersion = background.version;\n\t\t\t\tcurrentTonemapping = renderer.toneMapping;\n\n\t\t\t}\n\n\t\t\tplaneMesh.layers.enableAll();\n\n\t\t\t// push to the pre-sorted opaque render list\n\t\t\trenderList.unshift( planeMesh, planeMesh.geometry, planeMesh.material, 0, 0, null );\n\n\t\t}\n\n\t}\n\n\tfunction setClear( color, alpha ) {\n\n\t\tcolor.getRGB( _rgb, getUnlitUniformColorSpace( renderer ) );\n\n\t\tstate.buffers.color.setClear( _rgb.r, _rgb.g, _rgb.b, alpha, premultipliedAlpha );\n\n\t}\n\n\treturn {\n\n\t\tgetClearColor: function () {\n\n\t\t\treturn clearColor;\n\n\t\t},\n\t\tsetClearColor: function ( color, alpha = 1 ) {\n\n\t\t\tclearColor.set( color );\n\t\t\tclearAlpha = alpha;\n\t\t\tsetClear( clearColor, clearAlpha );\n\n\t\t},\n\t\tgetClearAlpha: function () {\n\n\t\t\treturn clearAlpha;\n\n\t\t},\n\t\tsetClearAlpha: function ( alpha ) {\n\n\t\t\tclearAlpha = alpha;\n\t\t\tsetClear( clearColor, clearAlpha );\n\n\t\t},\n\t\trender: render\n\n\t};\n\n}\n\nfunction WebGLBindingStates( gl, attributes ) {\n\n\tconst maxVertexAttributes = gl.getParameter( gl.MAX_VERTEX_ATTRIBS );\n\n\tconst bindingStates = {};\n\n\tconst defaultState = createBindingState( null );\n\tlet currentState = defaultState;\n\tlet forceUpdate = false;\n\n\tfunction setup( object, material, program, geometry, index ) {\n\n\t\tlet updateBuffers = false;\n\n\t\tconst state = getBindingState( geometry, program, material );\n\n\t\tif ( currentState !== state ) {\n\n\t\t\tcurrentState = state;\n\t\t\tbindVertexArrayObject( currentState.object );\n\n\t\t}\n\n\t\tupdateBuffers = needsUpdate( object, geometry, program, index );\n\n\t\tif ( updateBuffers ) saveCache( object, geometry, program, index );\n\n\t\tif ( index !== null ) {\n\n\t\t\tattributes.update( index, gl.ELEMENT_ARRAY_BUFFER );\n\n\t\t}\n\n\t\tif ( updateBuffers || forceUpdate ) {\n\n\t\t\tforceUpdate = false;\n\n\t\t\tsetupVertexAttributes( object, material, program, geometry );\n\n\t\t\tif ( index !== null ) {\n\n\t\t\t\tgl.bindBuffer( gl.ELEMENT_ARRAY_BUFFER, attributes.get( index ).buffer );\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n\tfunction createVertexArrayObject() {\n\n\t\treturn gl.createVertexArray();\n\n\t}\n\n\tfunction bindVertexArrayObject( vao ) {\n\n\t\treturn gl.bindVertexArray( vao );\n\n\t}\n\n\tfunction deleteVertexArrayObject( vao ) {\n\n\t\treturn gl.deleteVertexArray( vao );\n\n\t}\n\n\tfunction getBindingState( geometry, program, material ) {\n\n\t\tconst wireframe = ( material.wireframe === true );\n\n\t\tlet programMap = bindingStates[ geometry.id ];\n\n\t\tif ( programMap === undefined ) {\n\n\t\t\tprogramMap = {};\n\t\t\tbindingStates[ geometry.id ] = programMap;\n\n\t\t}\n\n\t\tlet stateMap = programMap[ program.id ];\n\n\t\tif ( stateMap === undefined ) {\n\n\t\t\tstateMap = {};\n\t\t\tprogramMap[ program.id ] = stateMap;\n\n\t\t}\n\n\t\tlet state = stateMap[ wireframe ];\n\n\t\tif ( state === undefined ) {\n\n\t\t\tstate = createBindingState( createVertexArrayObject() );\n\t\t\tstateMap[ wireframe ] = state;\n\n\t\t}\n\n\t\treturn state;\n\n\t}\n\n\tfunction createBindingState( vao ) {\n\n\t\tconst newAttributes = [];\n\t\tconst enabledAttributes = [];\n\t\tconst attributeDivisors = [];\n\n\t\tfor ( let i = 0; i < maxVertexAttributes; i ++ ) {\n\n\t\t\tnewAttributes[ i ] = 0;\n\t\t\tenabledAttributes[ i ] = 0;\n\t\t\tattributeDivisors[ i ] = 0;\n\n\t\t}\n\n\t\treturn {\n\n\t\t\t// for backward compatibility on non-VAO support browser\n\t\t\tgeometry: null,\n\t\t\tprogram: null,\n\t\t\twireframe: false,\n\n\t\t\tnewAttributes: newAttributes,\n\t\t\tenabledAttributes: enabledAttributes,\n\t\t\tattributeDivisors: attributeDivisors,\n\t\t\tobject: vao,\n\t\t\tattributes: {},\n\t\t\tindex: null\n\n\t\t};\n\n\t}\n\n\tfunction needsUpdate( object, geometry, program, index ) {\n\n\t\tconst cachedAttributes = currentState.attributes;\n\t\tconst geometryAttributes = geometry.attributes;\n\n\t\tlet attributesNum = 0;\n\n\t\tconst programAttributes = program.getAttributes();\n\n\t\tfor ( const name in programAttributes ) {\n\n\t\t\tconst programAttribute = programAttributes[ name ];\n\n\t\t\tif ( programAttribute.location >= 0 ) {\n\n\t\t\t\tconst cachedAttribute = cachedAttributes[ name ];\n\t\t\t\tlet geometryAttribute = geometryAttributes[ name ];\n\n\t\t\t\tif ( geometryAttribute === undefined ) {\n\n\t\t\t\t\tif ( name === 'instanceMatrix' && object.instanceMatrix ) geometryAttribute = object.instanceMatrix;\n\t\t\t\t\tif ( name === 'instanceColor' && object.instanceColor ) geometryAttribute = object.instanceColor;\n\n\t\t\t\t}\n\n\t\t\t\tif ( cachedAttribute === undefined ) return true;\n\n\t\t\t\tif ( cachedAttribute.attribute !== geometryAttribute ) return true;\n\n\t\t\t\tif ( geometryAttribute && cachedAttribute.data !== geometryAttribute.data ) return true;\n\n\t\t\t\tattributesNum ++;\n\n\t\t\t}\n\n\t\t}\n\n\t\tif ( currentState.attributesNum !== attributesNum ) return true;\n\n\t\tif ( currentState.index !== index ) return true;\n\n\t\treturn false;\n\n\t}\n\n\tfunction saveCache( object, geometry, program, index ) {\n\n\t\tconst cache = {};\n\t\tconst attributes = geometry.attributes;\n\t\tlet attributesNum = 0;\n\n\t\tconst programAttributes = program.getAttributes();\n\n\t\tfor ( const name in programAttributes ) {\n\n\t\t\tconst programAttribute = programAttributes[ name ];\n\n\t\t\tif ( programAttribute.location >= 0 ) {\n\n\t\t\t\tlet attribute = attributes[ name ];\n\n\t\t\t\tif ( attribute === undefined ) {\n\n\t\t\t\t\tif ( name === 'instanceMatrix' && object.instanceMatrix ) attribute = object.instanceMatrix;\n\t\t\t\t\tif ( name === 'instanceColor' && object.instanceColor ) attribute = object.instanceColor;\n\n\t\t\t\t}\n\n\t\t\t\tconst data = {};\n\t\t\t\tdata.attribute = attribute;\n\n\t\t\t\tif ( attribute && attribute.data ) {\n\n\t\t\t\t\tdata.data = attribute.data;\n\n\t\t\t\t}\n\n\t\t\t\tcache[ name ] = data;\n\n\t\t\t\tattributesNum ++;\n\n\t\t\t}\n\n\t\t}\n\n\t\tcurrentState.attributes = cache;\n\t\tcurrentState.attributesNum = attributesNum;\n\n\t\tcurrentState.index = index;\n\n\t}\n\n\tfunction initAttributes() {\n\n\t\tconst newAttributes = currentState.newAttributes;\n\n\t\tfor ( let i = 0, il = newAttributes.length; i < il; i ++ ) {\n\n\t\t\tnewAttributes[ i ] = 0;\n\n\t\t}\n\n\t}\n\n\tfunction enableAttribute( attribute ) {\n\n\t\tenableAttributeAndDivisor( attribute, 0 );\n\n\t}\n\n\tfunction enableAttributeAndDivisor( attribute, meshPerAttribute ) {\n\n\t\tconst newAttributes = currentState.newAttributes;\n\t\tconst enabledAttributes = currentState.enabledAttributes;\n\t\tconst attributeDivisors = currentState.attributeDivisors;\n\n\t\tnewAttributes[ attribute ] = 1;\n\n\t\tif ( enabledAttributes[ attribute ] === 0 ) {\n\n\t\t\tgl.enableVertexAttribArray( attribute );\n\t\t\tenabledAttributes[ attribute ] = 1;\n\n\t\t}\n\n\t\tif ( attributeDivisors[ attribute ] !== meshPerAttribute ) {\n\n\t\t\tgl.vertexAttribDivisor( attribute, meshPerAttribute );\n\t\t\tattributeDivisors[ attribute ] = meshPerAttribute;\n\n\t\t}\n\n\t}\n\n\tfunction disableUnusedAttributes() {\n\n\t\tconst newAttributes = currentState.newAttributes;\n\t\tconst enabledAttributes = currentState.enabledAttributes;\n\n\t\tfor ( let i = 0, il = enabledAttributes.length; i < il; i ++ ) {\n\n\t\t\tif ( enabledAttributes[ i ] !== newAttributes[ i ] ) {\n\n\t\t\t\tgl.disableVertexAttribArray( i );\n\t\t\t\tenabledAttributes[ i ] = 0;\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n\tfunction vertexAttribPointer( index, size, type, normalized, stride, offset, integer ) {\n\n\t\tif ( integer === true ) {\n\n\t\t\tgl.vertexAttribIPointer( index, size, type, stride, offset );\n\n\t\t} else {\n\n\t\t\tgl.vertexAttribPointer( index, size, type, normalized, stride, offset );\n\n\t\t}\n\n\t}\n\n\tfunction setupVertexAttributes( object, material, program, geometry ) {\n\n\t\tinitAttributes();\n\n\t\tconst geometryAttributes = geometry.attributes;\n\n\t\tconst programAttributes = program.getAttributes();\n\n\t\tconst materialDefaultAttributeValues = material.defaultAttributeValues;\n\n\t\tfor ( const name in programAttributes ) {\n\n\t\t\tconst programAttribute = programAttributes[ name ];\n\n\t\t\tif ( programAttribute.location >= 0 ) {\n\n\t\t\t\tlet geometryAttribute = geometryAttributes[ name ];\n\n\t\t\t\tif ( geometryAttribute === undefined ) {\n\n\t\t\t\t\tif ( name === 'instanceMatrix' && object.instanceMatrix ) geometryAttribute = object.instanceMatrix;\n\t\t\t\t\tif ( name === 'instanceColor' && object.instanceColor ) geometryAttribute = object.instanceColor;\n\n\t\t\t\t}\n\n\t\t\t\tif ( geometryAttribute !== undefined ) {\n\n\t\t\t\t\tconst normalized = geometryAttribute.normalized;\n\t\t\t\t\tconst size = geometryAttribute.itemSize;\n\n\t\t\t\t\tconst attribute = attributes.get( geometryAttribute );\n\n\t\t\t\t\t// TODO Attribute may not be available on context restore\n\n\t\t\t\t\tif ( attribute === undefined ) continue;\n\n\t\t\t\t\tconst buffer = attribute.buffer;\n\t\t\t\t\tconst type = attribute.type;\n\t\t\t\t\tconst bytesPerElement = attribute.bytesPerElement;\n\n\t\t\t\t\t// check for integer attributes\n\n\t\t\t\t\tconst integer = ( type === gl.INT || type === gl.UNSIGNED_INT || geometryAttribute.gpuType === IntType );\n\n\t\t\t\t\tif ( geometryAttribute.isInterleavedBufferAttribute ) {\n\n\t\t\t\t\t\tconst data = geometryAttribute.data;\n\t\t\t\t\t\tconst stride = data.stride;\n\t\t\t\t\t\tconst offset = geometryAttribute.offset;\n\n\t\t\t\t\t\tif ( data.isInstancedInterleavedBuffer ) {\n\n\t\t\t\t\t\t\tfor ( let i = 0; i < programAttribute.locationSize; i ++ ) {\n\n\t\t\t\t\t\t\t\tenableAttributeAndDivisor( programAttribute.location + i, data.meshPerAttribute );\n\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\tif ( object.isInstancedMesh !== true && geometry._maxInstanceCount === undefined ) {\n\n\t\t\t\t\t\t\t\tgeometry._maxInstanceCount = data.meshPerAttribute * data.count;\n\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\tfor ( let i = 0; i < programAttribute.locationSize; i ++ ) {\n\n\t\t\t\t\t\t\t\tenableAttribute( programAttribute.location + i );\n\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tgl.bindBuffer( gl.ARRAY_BUFFER, buffer );\n\n\t\t\t\t\t\tfor ( let i = 0; i < programAttribute.locationSize; i ++ ) {\n\n\t\t\t\t\t\t\tvertexAttribPointer(\n\t\t\t\t\t\t\t\tprogramAttribute.location + i,\n\t\t\t\t\t\t\t\tsize / programAttribute.locationSize,\n\t\t\t\t\t\t\t\ttype,\n\t\t\t\t\t\t\t\tnormalized,\n\t\t\t\t\t\t\t\tstride * bytesPerElement,\n\t\t\t\t\t\t\t\t( offset + ( size / programAttribute.locationSize ) * i ) * bytesPerElement,\n\t\t\t\t\t\t\t\tinteger\n\t\t\t\t\t\t\t);\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\tif ( geometryAttribute.isInstancedBufferAttribute ) {\n\n\t\t\t\t\t\t\tfor ( let i = 0; i < programAttribute.locationSize; i ++ ) {\n\n\t\t\t\t\t\t\t\tenableAttributeAndDivisor( programAttribute.location + i, geometryAttribute.meshPerAttribute );\n\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\tif ( object.isInstancedMesh !== true && geometry._maxInstanceCount === undefined ) {\n\n\t\t\t\t\t\t\t\tgeometry._maxInstanceCount = geometryAttribute.meshPerAttribute * geometryAttribute.count;\n\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\tfor ( let i = 0; i < programAttribute.locationSize; i ++ ) {\n\n\t\t\t\t\t\t\t\tenableAttribute( programAttribute.location + i );\n\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tgl.bindBuffer( gl.ARRAY_BUFFER, buffer );\n\n\t\t\t\t\t\tfor ( let i = 0; i < programAttribute.locationSize; i ++ ) {\n\n\t\t\t\t\t\t\tvertexAttribPointer(\n\t\t\t\t\t\t\t\tprogramAttribute.location + i,\n\t\t\t\t\t\t\t\tsize / programAttribute.locationSize,\n\t\t\t\t\t\t\t\ttype,\n\t\t\t\t\t\t\t\tnormalized,\n\t\t\t\t\t\t\t\tsize * bytesPerElement,\n\t\t\t\t\t\t\t\t( size / programAttribute.locationSize ) * i * bytesPerElement,\n\t\t\t\t\t\t\t\tinteger\n\t\t\t\t\t\t\t);\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}\n\n\t\t\t\t} else if ( materialDefaultAttributeValues !== undefined ) {\n\n\t\t\t\t\tconst value = materialDefaultAttributeValues[ name ];\n\n\t\t\t\t\tif ( value !== undefined ) {\n\n\t\t\t\t\t\tswitch ( value.length ) {\n\n\t\t\t\t\t\t\tcase 2:\n\t\t\t\t\t\t\t\tgl.vertexAttrib2fv( programAttribute.location, value );\n\t\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t\t\tcase 3:\n\t\t\t\t\t\t\t\tgl.vertexAttrib3fv( programAttribute.location, value );\n\t\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t\t\tcase 4:\n\t\t\t\t\t\t\t\tgl.vertexAttrib4fv( programAttribute.location, value );\n\t\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t\t\tdefault:\n\t\t\t\t\t\t\t\tgl.vertexAttrib1fv( programAttribute.location, value );\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t\tdisableUnusedAttributes();\n\n\t}\n\n\tfunction dispose() {\n\n\t\treset();\n\n\t\tfor ( const geometryId in bindingStates ) {\n\n\t\t\tconst programMap = bindingStates[ geometryId ];\n\n\t\t\tfor ( const programId in programMap ) {\n\n\t\t\t\tconst stateMap = programMap[ programId ];\n\n\t\t\t\tfor ( const wireframe in stateMap ) {\n\n\t\t\t\t\tdeleteVertexArrayObject( stateMap[ wireframe ].object );\n\n\t\t\t\t\tdelete stateMap[ wireframe ];\n\n\t\t\t\t}\n\n\t\t\t\tdelete programMap[ programId ];\n\n\t\t\t}\n\n\t\t\tdelete bindingStates[ geometryId ];\n\n\t\t}\n\n\t}\n\n\tfunction releaseStatesOfGeometry( geometry ) {\n\n\t\tif ( bindingStates[ geometry.id ] === undefined ) return;\n\n\t\tconst programMap = bindingStates[ geometry.id ];\n\n\t\tfor ( const programId in programMap ) {\n\n\t\t\tconst stateMap = programMap[ programId ];\n\n\t\t\tfor ( const wireframe in stateMap ) {\n\n\t\t\t\tdeleteVertexArrayObject( stateMap[ wireframe ].object );\n\n\t\t\t\tdelete stateMap[ wireframe ];\n\n\t\t\t}\n\n\t\t\tdelete programMap[ programId ];\n\n\t\t}\n\n\t\tdelete bindingStates[ geometry.id ];\n\n\t}\n\n\tfunction releaseStatesOfProgram( program ) {\n\n\t\tfor ( const geometryId in bindingStates ) {\n\n\t\t\tconst programMap = bindingStates[ geometryId ];\n\n\t\t\tif ( programMap[ program.id ] === undefined ) continue;\n\n\t\t\tconst stateMap = programMap[ program.id ];\n\n\t\t\tfor ( const wireframe in stateMap ) {\n\n\t\t\t\tdeleteVertexArrayObject( stateMap[ wireframe ].object );\n\n\t\t\t\tdelete stateMap[ wireframe ];\n\n\t\t\t}\n\n\t\t\tdelete programMap[ program.id ];\n\n\t\t}\n\n\t}\n\n\tfunction reset() {\n\n\t\tresetDefaultState();\n\t\tforceUpdate = true;\n\n\t\tif ( currentState === defaultState ) return;\n\n\t\tcurrentState = defaultState;\n\t\tbindVertexArrayObject( currentState.object );\n\n\t}\n\n\t// for backward-compatibility\n\n\tfunction resetDefaultState() {\n\n\t\tdefaultState.geometry = null;\n\t\tdefaultState.program = null;\n\t\tdefaultState.wireframe = false;\n\n\t}\n\n\treturn {\n\n\t\tsetup: setup,\n\t\treset: reset,\n\t\tresetDefaultState: resetDefaultState,\n\t\tdispose: dispose,\n\t\treleaseStatesOfGeometry: releaseStatesOfGeometry,\n\t\treleaseStatesOfProgram: releaseStatesOfProgram,\n\n\t\tinitAttributes: initAttributes,\n\t\tenableAttribute: enableAttribute,\n\t\tdisableUnusedAttributes: disableUnusedAttributes\n\n\t};\n\n}\n\nfunction WebGLBufferRenderer( gl, extensions, info ) {\n\n\tlet mode;\n\n\tfunction setMode( value ) {\n\n\t\tmode = value;\n\n\t}\n\n\tfunction render( start, count ) {\n\n\t\tgl.drawArrays( mode, start, count );\n\n\t\tinfo.update( count, mode, 1 );\n\n\t}\n\n\tfunction renderInstances( start, count, primcount ) {\n\n\t\tif ( primcount === 0 ) return;\n\n\t\tgl.drawArraysInstanced( mode, start, count, primcount );\n\n\t\tinfo.update( count, mode, primcount );\n\n\t}\n\n\tfunction renderMultiDraw( starts, counts, drawCount ) {\n\n\t\tif ( drawCount === 0 ) return;\n\n\t\tconst extension = extensions.get( 'WEBGL_multi_draw' );\n\n\t\tif ( extension === null ) {\n\n\t\t\tfor ( let i = 0; i < drawCount; i ++ ) {\n\n\t\t\t\tthis.render( starts[ i ], counts[ i ] );\n\n\t\t\t}\n\n\t\t} else {\n\n\t\t\textension.multiDrawArraysWEBGL( mode, starts, 0, counts, 0, drawCount );\n\n\t\t\tlet elementCount = 0;\n\t\t\tfor ( let i = 0; i < drawCount; i ++ ) {\n\n\t\t\t\telementCount += counts[ i ];\n\n\t\t\t}\n\n\t\t\tinfo.update( elementCount, mode, 1 );\n\n\t\t}\n\n\t}\n\n\t//\n\n\tthis.setMode = setMode;\n\tthis.render = render;\n\tthis.renderInstances = renderInstances;\n\tthis.renderMultiDraw = renderMultiDraw;\n\n}\n\nfunction WebGLCapabilities( gl, extensions, parameters ) {\n\n\tlet maxAnisotropy;\n\n\tfunction getMaxAnisotropy() {\n\n\t\tif ( maxAnisotropy !== undefined ) return maxAnisotropy;\n\n\t\tif ( extensions.has( 'EXT_texture_filter_anisotropic' ) === true ) {\n\n\t\t\tconst extension = extensions.get( 'EXT_texture_filter_anisotropic' );\n\n\t\t\tmaxAnisotropy = gl.getParameter( extension.MAX_TEXTURE_MAX_ANISOTROPY_EXT );\n\n\t\t} else {\n\n\t\t\tmaxAnisotropy = 0;\n\n\t\t}\n\n\t\treturn maxAnisotropy;\n\n\t}\n\n\tfunction getMaxPrecision( precision ) {\n\n\t\tif ( precision === 'highp' ) {\n\n\t\t\tif ( gl.getShaderPrecisionFormat( gl.VERTEX_SHADER, gl.HIGH_FLOAT ).precision > 0 &&\n\t\t\t\tgl.getShaderPrecisionFormat( gl.FRAGMENT_SHADER, gl.HIGH_FLOAT ).precision > 0 ) {\n\n\t\t\t\treturn 'highp';\n\n\t\t\t}\n\n\t\t\tprecision = 'mediump';\n\n\t\t}\n\n\t\tif ( precision === 'mediump' ) {\n\n\t\t\tif ( gl.getShaderPrecisionFormat( gl.VERTEX_SHADER, gl.MEDIUM_FLOAT ).precision > 0 &&\n\t\t\t\tgl.getShaderPrecisionFormat( gl.FRAGMENT_SHADER, gl.MEDIUM_FLOAT ).precision > 0 ) {\n\n\t\t\t\treturn 'mediump';\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn 'lowp';\n\n\t}\n\n\tlet precision = parameters.precision !== undefined ? parameters.precision : 'highp';\n\tconst maxPrecision = getMaxPrecision( precision );\n\n\tif ( maxPrecision !== precision ) {\n\n\t\tconsole.warn( 'THREE.WebGLRenderer:', precision, 'not supported, using', maxPrecision, 'instead.' );\n\t\tprecision = maxPrecision;\n\n\t}\n\n\tconst logarithmicDepthBuffer = parameters.logarithmicDepthBuffer === true;\n\n\tconst maxTextures = gl.getParameter( gl.MAX_TEXTURE_IMAGE_UNITS );\n\tconst maxVertexTextures = gl.getParameter( gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS );\n\tconst maxTextureSize = gl.getParameter( gl.MAX_TEXTURE_SIZE );\n\tconst maxCubemapSize = gl.getParameter( gl.MAX_CUBE_MAP_TEXTURE_SIZE );\n\n\tconst maxAttributes = gl.getParameter( gl.MAX_VERTEX_ATTRIBS );\n\tconst maxVertexUniforms = gl.getParameter( gl.MAX_VERTEX_UNIFORM_VECTORS );\n\tconst maxVaryings = gl.getParameter( gl.MAX_VARYING_VECTORS );\n\tconst maxFragmentUniforms = gl.getParameter( gl.MAX_FRAGMENT_UNIFORM_VECTORS );\n\n\tconst vertexTextures = maxVertexTextures > 0;\n\n\tconst maxSamples = gl.getParameter( gl.MAX_SAMPLES );\n\n\treturn {\n\n\t\tisWebGL2: true, // keeping this for backwards compatibility\n\n\t\tgetMaxAnisotropy: getMaxAnisotropy,\n\t\tgetMaxPrecision: getMaxPrecision,\n\n\t\tprecision: precision,\n\t\tlogarithmicDepthBuffer: logarithmicDepthBuffer,\n\n\t\tmaxTextures: maxTextures,\n\t\tmaxVertexTextures: maxVertexTextures,\n\t\tmaxTextureSize: maxTextureSize,\n\t\tmaxCubemapSize: maxCubemapSize,\n\n\t\tmaxAttributes: maxAttributes,\n\t\tmaxVertexUniforms: maxVertexUniforms,\n\t\tmaxVaryings: maxVaryings,\n\t\tmaxFragmentUniforms: maxFragmentUniforms,\n\n\t\tvertexTextures: vertexTextures,\n\n\t\tmaxSamples: maxSamples\n\n\t};\n\n}\n\nfunction WebGLClipping( properties ) {\n\n\tconst scope = this;\n\n\tlet globalState = null,\n\t\tnumGlobalPlanes = 0,\n\t\tlocalClippingEnabled = false,\n\t\trenderingShadows = false;\n\n\tconst plane = new Plane(),\n\t\tviewNormalMatrix = new Matrix3(),\n\n\t\tuniform = { value: null, needsUpdate: false };\n\n\tthis.uniform = uniform;\n\tthis.numPlanes = 0;\n\tthis.numIntersection = 0;\n\n\tthis.init = function ( planes, enableLocalClipping ) {\n\n\t\tconst enabled =\n\t\t\tplanes.length !== 0 ||\n\t\t\tenableLocalClipping ||\n\t\t\t// enable state of previous frame - the clipping code has to\n\t\t\t// run another frame in order to reset the state:\n\t\t\tnumGlobalPlanes !== 0 ||\n\t\t\tlocalClippingEnabled;\n\n\t\tlocalClippingEnabled = enableLocalClipping;\n\n\t\tnumGlobalPlanes = planes.length;\n\n\t\treturn enabled;\n\n\t};\n\n\tthis.beginShadows = function () {\n\n\t\trenderingShadows = true;\n\t\tprojectPlanes( null );\n\n\t};\n\n\tthis.endShadows = function () {\n\n\t\trenderingShadows = false;\n\n\t};\n\n\tthis.setGlobalState = function ( planes, camera ) {\n\n\t\tglobalState = projectPlanes( planes, camera, 0 );\n\n\t};\n\n\tthis.setState = function ( material, camera, useCache ) {\n\n\t\tconst planes = material.clippingPlanes,\n\t\t\tclipIntersection = material.clipIntersection,\n\t\t\tclipShadows = material.clipShadows;\n\n\t\tconst materialProperties = properties.get( material );\n\n\t\tif ( ! localClippingEnabled || planes === null || planes.length === 0 || renderingShadows && ! clipShadows ) {\n\n\t\t\t// there's no local clipping\n\n\t\t\tif ( renderingShadows ) {\n\n\t\t\t\t// there's no global clipping\n\n\t\t\t\tprojectPlanes( null );\n\n\t\t\t} else {\n\n\t\t\t\tresetGlobalState();\n\n\t\t\t}\n\n\t\t} else {\n\n\t\t\tconst nGlobal = renderingShadows ? 0 : numGlobalPlanes,\n\t\t\t\tlGlobal = nGlobal * 4;\n\n\t\t\tlet dstArray = materialProperties.clippingState || null;\n\n\t\t\tuniform.value = dstArray; // ensure unique state\n\n\t\t\tdstArray = projectPlanes( planes, camera, lGlobal, useCache );\n\n\t\t\tfor ( let i = 0; i !== lGlobal; ++ i ) {\n\n\t\t\t\tdstArray[ i ] = globalState[ i ];\n\n\t\t\t}\n\n\t\t\tmaterialProperties.clippingState = dstArray;\n\t\t\tthis.numIntersection = clipIntersection ? this.numPlanes : 0;\n\t\t\tthis.numPlanes += nGlobal;\n\n\t\t}\n\n\n\t};\n\n\tfunction resetGlobalState() {\n\n\t\tif ( uniform.value !== globalState ) {\n\n\t\t\tuniform.value = globalState;\n\t\t\tuniform.needsUpdate = numGlobalPlanes > 0;\n\n\t\t}\n\n\t\tscope.numPlanes = numGlobalPlanes;\n\t\tscope.numIntersection = 0;\n\n\t}\n\n\tfunction projectPlanes( planes, camera, dstOffset, skipTransform ) {\n\n\t\tconst nPlanes = planes !== null ? planes.length : 0;\n\t\tlet dstArray = null;\n\n\t\tif ( nPlanes !== 0 ) {\n\n\t\t\tdstArray = uniform.value;\n\n\t\t\tif ( skipTransform !== true || dstArray === null ) {\n\n\t\t\t\tconst flatSize = dstOffset + nPlanes * 4,\n\t\t\t\t\tviewMatrix = camera.matrixWorldInverse;\n\n\t\t\t\tviewNormalMatrix.getNormalMatrix( viewMatrix );\n\n\t\t\t\tif ( dstArray === null || dstArray.length < flatSize ) {\n\n\t\t\t\t\tdstArray = new Float32Array( flatSize );\n\n\t\t\t\t}\n\n\t\t\t\tfor ( let i = 0, i4 = dstOffset; i !== nPlanes; ++ i, i4 += 4 ) {\n\n\t\t\t\t\tplane.copy( planes[ i ] ).applyMatrix4( viewMatrix, viewNormalMatrix );\n\n\t\t\t\t\tplane.normal.toArray( dstArray, i4 );\n\t\t\t\t\tdstArray[ i4 + 3 ] = plane.constant;\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tuniform.value = dstArray;\n\t\t\tuniform.needsUpdate = true;\n\n\t\t}\n\n\t\tscope.numPlanes = nPlanes;\n\t\tscope.numIntersection = 0;\n\n\t\treturn dstArray;\n\n\t}\n\n}\n\nfunction WebGLCubeMaps( renderer ) {\n\n\tlet cubemaps = new WeakMap();\n\n\tfunction mapTextureMapping( texture, mapping ) {\n\n\t\tif ( mapping === EquirectangularReflectionMapping ) {\n\n\t\t\ttexture.mapping = CubeReflectionMapping;\n\n\t\t} else if ( mapping === EquirectangularRefractionMapping ) {\n\n\t\t\ttexture.mapping = CubeRefractionMapping;\n\n\t\t}\n\n\t\treturn texture;\n\n\t}\n\n\tfunction get( texture ) {\n\n\t\tif ( texture && texture.isTexture ) {\n\n\t\t\tconst mapping = texture.mapping;\n\n\t\t\tif ( mapping === EquirectangularReflectionMapping || mapping === EquirectangularRefractionMapping ) {\n\n\t\t\t\tif ( cubemaps.has( texture ) ) {\n\n\t\t\t\t\tconst cubemap = cubemaps.get( texture ).texture;\n\t\t\t\t\treturn mapTextureMapping( cubemap, texture.mapping );\n\n\t\t\t\t} else {\n\n\t\t\t\t\tconst image = texture.image;\n\n\t\t\t\t\tif ( image && image.height > 0 ) {\n\n\t\t\t\t\t\tconst renderTarget = new WebGLCubeRenderTarget( image.height );\n\t\t\t\t\t\trenderTarget.fromEquirectangularTexture( renderer, texture );\n\t\t\t\t\t\tcubemaps.set( texture, renderTarget );\n\n\t\t\t\t\t\ttexture.addEventListener( 'dispose', onTextureDispose );\n\n\t\t\t\t\t\treturn mapTextureMapping( renderTarget.texture, texture.mapping );\n\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\t// image not yet ready. try the conversion next frame\n\n\t\t\t\t\t\treturn null;\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn texture;\n\n\t}\n\n\tfunction onTextureDispose( event ) {\n\n\t\tconst texture = event.target;\n\n\t\ttexture.removeEventListener( 'dispose', onTextureDispose );\n\n\t\tconst cubemap = cubemaps.get( texture );\n\n\t\tif ( cubemap !== undefined ) {\n\n\t\t\tcubemaps.delete( texture );\n\t\t\tcubemap.dispose();\n\n\t\t}\n\n\t}\n\n\tfunction dispose() {\n\n\t\tcubemaps = new WeakMap();\n\n\t}\n\n\treturn {\n\t\tget: get,\n\t\tdispose: dispose\n\t};\n\n}\n\nclass OrthographicCamera extends Camera {\n\n\tconstructor( left = - 1, right = 1, top = 1, bottom = - 1, near = 0.1, far = 2000 ) {\n\n\t\tsuper();\n\n\t\tthis.isOrthographicCamera = true;\n\n\t\tthis.type = 'OrthographicCamera';\n\n\t\tthis.zoom = 1;\n\t\tthis.view = null;\n\n\t\tthis.left = left;\n\t\tthis.right = right;\n\t\tthis.top = top;\n\t\tthis.bottom = bottom;\n\n\t\tthis.near = near;\n\t\tthis.far = far;\n\n\t\tthis.updateProjectionMatrix();\n\n\t}\n\n\tcopy( source, recursive ) {\n\n\t\tsuper.copy( source, recursive );\n\n\t\tthis.left = source.left;\n\t\tthis.right = source.right;\n\t\tthis.top = source.top;\n\t\tthis.bottom = source.bottom;\n\t\tthis.near = source.near;\n\t\tthis.far = source.far;\n\n\t\tthis.zoom = source.zoom;\n\t\tthis.view = source.view === null ? null : Object.assign( {}, source.view );\n\n\t\treturn this;\n\n\t}\n\n\tsetViewOffset( fullWidth, fullHeight, x, y, width, height ) {\n\n\t\tif ( this.view === null ) {\n\n\t\t\tthis.view = {\n\t\t\t\tenabled: true,\n\t\t\t\tfullWidth: 1,\n\t\t\t\tfullHeight: 1,\n\t\t\t\toffsetX: 0,\n\t\t\t\toffsetY: 0,\n\t\t\t\twidth: 1,\n\t\t\t\theight: 1\n\t\t\t};\n\n\t\t}\n\n\t\tthis.view.enabled = true;\n\t\tthis.view.fullWidth = fullWidth;\n\t\tthis.view.fullHeight = fullHeight;\n\t\tthis.view.offsetX = x;\n\t\tthis.view.offsetY = y;\n\t\tthis.view.width = width;\n\t\tthis.view.height = height;\n\n\t\tthis.updateProjectionMatrix();\n\n\t}\n\n\tclearViewOffset() {\n\n\t\tif ( this.view !== null ) {\n\n\t\t\tthis.view.enabled = false;\n\n\t\t}\n\n\t\tthis.updateProjectionMatrix();\n\n\t}\n\n\tupdateProjectionMatrix() {\n\n\t\tconst dx = ( this.right - this.left ) / ( 2 * this.zoom );\n\t\tconst dy = ( this.top - this.bottom ) / ( 2 * this.zoom );\n\t\tconst cx = ( this.right + this.left ) / 2;\n\t\tconst cy = ( this.top + this.bottom ) / 2;\n\n\t\tlet left = cx - dx;\n\t\tlet right = cx + dx;\n\t\tlet top = cy + dy;\n\t\tlet bottom = cy - dy;\n\n\t\tif ( this.view !== null && this.view.enabled ) {\n\n\t\t\tconst scaleW = ( this.right - this.left ) / this.view.fullWidth / this.zoom;\n\t\t\tconst scaleH = ( this.top - this.bottom ) / this.view.fullHeight / this.zoom;\n\n\t\t\tleft += scaleW * this.view.offsetX;\n\t\t\tright = left + scaleW * this.view.width;\n\t\t\ttop -= scaleH * this.view.offsetY;\n\t\t\tbottom = top - scaleH * this.view.height;\n\n\t\t}\n\n\t\tthis.projectionMatrix.makeOrthographic( left, right, top, bottom, this.near, this.far, this.coordinateSystem );\n\n\t\tthis.projectionMatrixInverse.copy( this.projectionMatrix ).invert();\n\n\t}\n\n\ttoJSON( meta ) {\n\n\t\tconst data = super.toJSON( meta );\n\n\t\tdata.object.zoom = this.zoom;\n\t\tdata.object.left = this.left;\n\t\tdata.object.right = this.right;\n\t\tdata.object.top = this.top;\n\t\tdata.object.bottom = this.bottom;\n\t\tdata.object.near = this.near;\n\t\tdata.object.far = this.far;\n\n\t\tif ( this.view !== null ) data.object.view = Object.assign( {}, this.view );\n\n\t\treturn data;\n\n\t}\n\n}\n\nconst LOD_MIN = 4;\n\n// The standard deviations (radians) associated with the extra mips. These are\n// chosen to approximate a Trowbridge-Reitz distribution function times the\n// geometric shadowing function. These sigma values squared must match the\n// variance #defines in cube_uv_reflection_fragment.glsl.js.\nconst EXTRA_LOD_SIGMA = [ 0.125, 0.215, 0.35, 0.446, 0.526, 0.582 ];\n\n// The maximum length of the blur for loop. Smaller sigmas will use fewer\n// samples and exit early, but not recompile the shader.\nconst MAX_SAMPLES = 20;\n\nconst _flatCamera = /*@__PURE__*/ new OrthographicCamera();\nconst _clearColor = /*@__PURE__*/ new Color();\nlet _oldTarget = null;\nlet _oldActiveCubeFace = 0;\nlet _oldActiveMipmapLevel = 0;\nlet _oldXrEnabled = false;\n\n// Golden Ratio\nconst PHI = ( 1 + Math.sqrt( 5 ) ) / 2;\nconst INV_PHI = 1 / PHI;\n\n// Vertices of a dodecahedron (except the opposites, which represent the\n// same axis), used as axis directions evenly spread on a sphere.\nconst _axisDirections = [\n\t/*@__PURE__*/ new Vector3( 1, 1, 1 ),\n\t/*@__PURE__*/ new Vector3( - 1, 1, 1 ),\n\t/*@__PURE__*/ new Vector3( 1, 1, - 1 ),\n\t/*@__PURE__*/ new Vector3( - 1, 1, - 1 ),\n\t/*@__PURE__*/ new Vector3( 0, PHI, INV_PHI ),\n\t/*@__PURE__*/ new Vector3( 0, PHI, - INV_PHI ),\n\t/*@__PURE__*/ new Vector3( INV_PHI, 0, PHI ),\n\t/*@__PURE__*/ new Vector3( - INV_PHI, 0, PHI ),\n\t/*@__PURE__*/ new Vector3( PHI, INV_PHI, 0 ),\n\t/*@__PURE__*/ new Vector3( - PHI, INV_PHI, 0 ) ];\n\n/**\n * This class generates a Prefiltered, Mipmapped Radiance Environment Map\n * (PMREM) from a cubeMap environment texture. This allows different levels of\n * blur to be quickly accessed based on material roughness. It is packed into a\n * special CubeUV format that allows us to perform custom interpolation so that\n * we can support nonlinear formats such as RGBE. Unlike a traditional mipmap\n * chain, it only goes down to the LOD_MIN level (above), and then creates extra\n * even more filtered 'mips' at the same LOD_MIN resolution, associated with\n * higher roughness levels. In this way we maintain resolution to smoothly\n * interpolate diffuse lighting while limiting sampling computation.\n *\n * Paper: Fast, Accurate Image-Based Lighting\n * https://drive.google.com/file/d/15y8r_UpKlU9SvV4ILb0C3qCPecS8pvLz/view\n*/\n\nclass PMREMGenerator {\n\n\tconstructor( renderer ) {\n\n\t\tthis._renderer = renderer;\n\t\tthis._pingPongRenderTarget = null;\n\n\t\tthis._lodMax = 0;\n\t\tthis._cubeSize = 0;\n\t\tthis._lodPlanes = [];\n\t\tthis._sizeLods = [];\n\t\tthis._sigmas = [];\n\n\t\tthis._blurMaterial = null;\n\t\tthis._cubemapMaterial = null;\n\t\tthis._equirectMaterial = null;\n\n\t\tthis._compileMaterial( this._blurMaterial );\n\n\t}\n\n\t/**\n\t * Generates a PMREM from a supplied Scene, which can be faster than using an\n\t * image if networking bandwidth is low. Optional sigma specifies a blur radius\n\t * in radians to be applied to the scene before PMREM generation. Optional near\n\t * and far planes ensure the scene is rendered in its entirety (the cubeCamera\n\t * is placed at the origin).\n\t */\n\tfromScene( scene, sigma = 0, near = 0.1, far = 100 ) {\n\n\t\t_oldTarget = this._renderer.getRenderTarget();\n\t\t_oldActiveCubeFace = this._renderer.getActiveCubeFace();\n\t\t_oldActiveMipmapLevel = this._renderer.getActiveMipmapLevel();\n\t\t_oldXrEnabled = this._renderer.xr.enabled;\n\n\t\tthis._renderer.xr.enabled = false;\n\n\t\tthis._setSize( 256 );\n\n\t\tconst cubeUVRenderTarget = this._allocateTargets();\n\t\tcubeUVRenderTarget.depthBuffer = true;\n\n\t\tthis._sceneToCubeUV( scene, near, far, cubeUVRenderTarget );\n\n\t\tif ( sigma > 0 ) {\n\n\t\t\tthis._blur( cubeUVRenderTarget, 0, 0, sigma );\n\n\t\t}\n\n\t\tthis._applyPMREM( cubeUVRenderTarget );\n\t\tthis._cleanup( cubeUVRenderTarget );\n\n\t\treturn cubeUVRenderTarget;\n\n\t}\n\n\t/**\n\t * Generates a PMREM from an equirectangular texture, which can be either LDR\n\t * or HDR. The ideal input image size is 1k (1024 x 512),\n\t * as this matches best with the 256 x 256 cubemap output.\n\t * The smallest supported equirectangular image size is 64 x 32.\n\t */\n\tfromEquirectangular( equirectangular, renderTarget = null ) {\n\n\t\treturn this._fromTexture( equirectangular, renderTarget );\n\n\t}\n\n\t/**\n\t * Generates a PMREM from an cubemap texture, which can be either LDR\n\t * or HDR. The ideal input cube size is 256 x 256,\n\t * as this matches best with the 256 x 256 cubemap output.\n\t * The smallest supported cube size is 16 x 16.\n\t */\n\tfromCubemap( cubemap, renderTarget = null ) {\n\n\t\treturn this._fromTexture( cubemap, renderTarget );\n\n\t}\n\n\t/**\n\t * Pre-compiles the cubemap shader. You can get faster start-up by invoking this method during\n\t * your texture's network fetch for increased concurrency.\n\t */\n\tcompileCubemapShader() {\n\n\t\tif ( this._cubemapMaterial === null ) {\n\n\t\t\tthis._cubemapMaterial = _getCubemapMaterial();\n\t\t\tthis._compileMaterial( this._cubemapMaterial );\n\n\t\t}\n\n\t}\n\n\t/**\n\t * Pre-compiles the equirectangular shader. You can get faster start-up by invoking this method during\n\t * your texture's network fetch for increased concurrency.\n\t */\n\tcompileEquirectangularShader() {\n\n\t\tif ( this._equirectMaterial === null ) {\n\n\t\t\tthis._equirectMaterial = _getEquirectMaterial();\n\t\t\tthis._compileMaterial( this._equirectMaterial );\n\n\t\t}\n\n\t}\n\n\t/**\n\t * Disposes of the PMREMGenerator's internal memory. Note that PMREMGenerator is a static class,\n\t * so you should not need more than one PMREMGenerator object. If you do, calling dispose() on\n\t * one of them will cause any others to also become unusable.\n\t */\n\tdispose() {\n\n\t\tthis._dispose();\n\n\t\tif ( this._cubemapMaterial !== null ) this._cubemapMaterial.dispose();\n\t\tif ( this._equirectMaterial !== null ) this._equirectMaterial.dispose();\n\n\t}\n\n\t// private interface\n\n\t_setSize( cubeSize ) {\n\n\t\tthis._lodMax = Math.floor( Math.log2( cubeSize ) );\n\t\tthis._cubeSize = Math.pow( 2, this._lodMax );\n\n\t}\n\n\t_dispose() {\n\n\t\tif ( this._blurMaterial !== null ) this._blurMaterial.dispose();\n\n\t\tif ( this._pingPongRenderTarget !== null ) this._pingPongRenderTarget.dispose();\n\n\t\tfor ( let i = 0; i < this._lodPlanes.length; i ++ ) {\n\n\t\t\tthis._lodPlanes[ i ].dispose();\n\n\t\t}\n\n\t}\n\n\t_cleanup( outputTarget ) {\n\n\t\tthis._renderer.setRenderTarget( _oldTarget, _oldActiveCubeFace, _oldActiveMipmapLevel );\n\t\tthis._renderer.xr.enabled = _oldXrEnabled;\n\n\t\toutputTarget.scissorTest = false;\n\t\t_setViewport( outputTarget, 0, 0, outputTarget.width, outputTarget.height );\n\n\t}\n\n\t_fromTexture( texture, renderTarget ) {\n\n\t\tif ( texture.mapping === CubeReflectionMapping || texture.mapping === CubeRefractionMapping ) {\n\n\t\t\tthis._setSize( texture.image.length === 0 ? 16 : ( texture.image[ 0 ].width || texture.image[ 0 ].image.width ) );\n\n\t\t} else { // Equirectangular\n\n\t\t\tthis._setSize( texture.image.width / 4 );\n\n\t\t}\n\n\t\t_oldTarget = this._renderer.getRenderTarget();\n\t\t_oldActiveCubeFace = this._renderer.getActiveCubeFace();\n\t\t_oldActiveMipmapLevel = this._renderer.getActiveMipmapLevel();\n\t\t_oldXrEnabled = this._renderer.xr.enabled;\n\n\t\tthis._renderer.xr.enabled = false;\n\n\t\tconst cubeUVRenderTarget = renderTarget || this._allocateTargets();\n\t\tthis._textureToCubeUV( texture, cubeUVRenderTarget );\n\t\tthis._applyPMREM( cubeUVRenderTarget );\n\t\tthis._cleanup( cubeUVRenderTarget );\n\n\t\treturn cubeUVRenderTarget;\n\n\t}\n\n\t_allocateTargets() {\n\n\t\tconst width = 3 * Math.max( this._cubeSize, 16 * 7 );\n\t\tconst height = 4 * this._cubeSize;\n\n\t\tconst params = {\n\t\t\tmagFilter: LinearFilter,\n\t\t\tminFilter: LinearFilter,\n\t\t\tgenerateMipmaps: false,\n\t\t\ttype: HalfFloatType,\n\t\t\tformat: RGBAFormat,\n\t\t\tcolorSpace: LinearSRGBColorSpace,\n\t\t\tdepthBuffer: false\n\t\t};\n\n\t\tconst cubeUVRenderTarget = _createRenderTarget( width, height, params );\n\n\t\tif ( this._pingPongRenderTarget === null || this._pingPongRenderTarget.width !== width || this._pingPongRenderTarget.height !== height ) {\n\n\t\t\tif ( this._pingPongRenderTarget !== null ) {\n\n\t\t\t\tthis._dispose();\n\n\t\t\t}\n\n\t\t\tthis._pingPongRenderTarget = _createRenderTarget( width, height, params );\n\n\t\t\tconst { _lodMax } = this;\n\t\t\t( { sizeLods: this._sizeLods, lodPlanes: this._lodPlanes, sigmas: this._sigmas } = _createPlanes( _lodMax ) );\n\n\t\t\tthis._blurMaterial = _getBlurShader( _lodMax, width, height );\n\n\t\t}\n\n\t\treturn cubeUVRenderTarget;\n\n\t}\n\n\t_compileMaterial( material ) {\n\n\t\tconst tmpMesh = new Mesh( this._lodPlanes[ 0 ], material );\n\t\tthis._renderer.compile( tmpMesh, _flatCamera );\n\n\t}\n\n\t_sceneToCubeUV( scene, near, far, cubeUVRenderTarget ) {\n\n\t\tconst fov = 90;\n\t\tconst aspect = 1;\n\t\tconst cubeCamera = new PerspectiveCamera( fov, aspect, near, far );\n\t\tconst upSign = [ 1, - 1, 1, 1, 1, 1 ];\n\t\tconst forwardSign = [ 1, 1, 1, - 1, - 1, - 1 ];\n\t\tconst renderer = this._renderer;\n\n\t\tconst originalAutoClear = renderer.autoClear;\n\t\tconst toneMapping = renderer.toneMapping;\n\t\trenderer.getClearColor( _clearColor );\n\n\t\trenderer.toneMapping = NoToneMapping;\n\t\trenderer.autoClear = false;\n\n\t\tconst backgroundMaterial = new MeshBasicMaterial( {\n\t\t\tname: 'PMREM.Background',\n\t\t\tside: BackSide,\n\t\t\tdepthWrite: false,\n\t\t\tdepthTest: false,\n\t\t} );\n\n\t\tconst backgroundBox = new Mesh( new BoxGeometry(), backgroundMaterial );\n\n\t\tlet useSolidColor = false;\n\t\tconst background = scene.background;\n\n\t\tif ( background ) {\n\n\t\t\tif ( background.isColor ) {\n\n\t\t\t\tbackgroundMaterial.color.copy( background );\n\t\t\t\tscene.background = null;\n\t\t\t\tuseSolidColor = true;\n\n\t\t\t}\n\n\t\t} else {\n\n\t\t\tbackgroundMaterial.color.copy( _clearColor );\n\t\t\tuseSolidColor = true;\n\n\t\t}\n\n\t\tfor ( let i = 0; i < 6; i ++ ) {\n\n\t\t\tconst col = i % 3;\n\n\t\t\tif ( col === 0 ) {\n\n\t\t\t\tcubeCamera.up.set( 0, upSign[ i ], 0 );\n\t\t\t\tcubeCamera.lookAt( forwardSign[ i ], 0, 0 );\n\n\t\t\t} else if ( col === 1 ) {\n\n\t\t\t\tcubeCamera.up.set( 0, 0, upSign[ i ] );\n\t\t\t\tcubeCamera.lookAt( 0, forwardSign[ i ], 0 );\n\n\t\t\t} else {\n\n\t\t\t\tcubeCamera.up.set( 0, upSign[ i ], 0 );\n\t\t\t\tcubeCamera.lookAt( 0, 0, forwardSign[ i ] );\n\n\t\t\t}\n\n\t\t\tconst size = this._cubeSize;\n\n\t\t\t_setViewport( cubeUVRenderTarget, col * size, i > 2 ? size : 0, size, size );\n\n\t\t\trenderer.setRenderTarget( cubeUVRenderTarget );\n\n\t\t\tif ( useSolidColor ) {\n\n\t\t\t\trenderer.render( backgroundBox, cubeCamera );\n\n\t\t\t}\n\n\t\t\trenderer.render( scene, cubeCamera );\n\n\t\t}\n\n\t\tbackgroundBox.geometry.dispose();\n\t\tbackgroundBox.material.dispose();\n\n\t\trenderer.toneMapping = toneMapping;\n\t\trenderer.autoClear = originalAutoClear;\n\t\tscene.background = background;\n\n\t}\n\n\t_textureToCubeUV( texture, cubeUVRenderTarget ) {\n\n\t\tconst renderer = this._renderer;\n\n\t\tconst isCubeTexture = ( texture.mapping === CubeReflectionMapping || texture.mapping === CubeRefractionMapping );\n\n\t\tif ( isCubeTexture ) {\n\n\t\t\tif ( this._cubemapMaterial === null ) {\n\n\t\t\t\tthis._cubemapMaterial = _getCubemapMaterial();\n\n\t\t\t}\n\n\t\t\tthis._cubemapMaterial.uniforms.flipEnvMap.value = ( texture.isRenderTargetTexture === false ) ? - 1 : 1;\n\n\t\t} else {\n\n\t\t\tif ( this._equirectMaterial === null ) {\n\n\t\t\t\tthis._equirectMaterial = _getEquirectMaterial();\n\n\t\t\t}\n\n\t\t}\n\n\t\tconst material = isCubeTexture ? this._cubemapMaterial : this._equirectMaterial;\n\t\tconst mesh = new Mesh( this._lodPlanes[ 0 ], material );\n\n\t\tconst uniforms = material.uniforms;\n\n\t\tuniforms[ 'envMap' ].value = texture;\n\n\t\tconst size = this._cubeSize;\n\n\t\t_setViewport( cubeUVRenderTarget, 0, 0, 3 * size, 2 * size );\n\n\t\trenderer.setRenderTarget( cubeUVRenderTarget );\n\t\trenderer.render( mesh, _flatCamera );\n\n\t}\n\n\t_applyPMREM( cubeUVRenderTarget ) {\n\n\t\tconst renderer = this._renderer;\n\t\tconst autoClear = renderer.autoClear;\n\t\trenderer.autoClear = false;\n\n\t\tfor ( let i = 1; i < this._lodPlanes.length; i ++ ) {\n\n\t\t\tconst sigma = Math.sqrt( this._sigmas[ i ] * this._sigmas[ i ] - this._sigmas[ i - 1 ] * this._sigmas[ i - 1 ] );\n\n\t\t\tconst poleAxis = _axisDirections[ ( i - 1 ) % _axisDirections.length ];\n\n\t\t\tthis._blur( cubeUVRenderTarget, i - 1, i, sigma, poleAxis );\n\n\t\t}\n\n\t\trenderer.autoClear = autoClear;\n\n\t}\n\n\t/**\n\t * This is a two-pass Gaussian blur for a cubemap. Normally this is done\n\t * vertically and horizontally, but this breaks down on a cube. Here we apply\n\t * the blur latitudinally (around the poles), and then longitudinally (towards\n\t * the poles) to approximate the orthogonally-separable blur. It is least\n\t * accurate at the poles, but still does a decent job.\n\t */\n\t_blur( cubeUVRenderTarget, lodIn, lodOut, sigma, poleAxis ) {\n\n\t\tconst pingPongRenderTarget = this._pingPongRenderTarget;\n\n\t\tthis._halfBlur(\n\t\t\tcubeUVRenderTarget,\n\t\t\tpingPongRenderTarget,\n\t\t\tlodIn,\n\t\t\tlodOut,\n\t\t\tsigma,\n\t\t\t'latitudinal',\n\t\t\tpoleAxis );\n\n\t\tthis._halfBlur(\n\t\t\tpingPongRenderTarget,\n\t\t\tcubeUVRenderTarget,\n\t\t\tlodOut,\n\t\t\tlodOut,\n\t\t\tsigma,\n\t\t\t'longitudinal',\n\t\t\tpoleAxis );\n\n\t}\n\n\t_halfBlur( targetIn, targetOut, lodIn, lodOut, sigmaRadians, direction, poleAxis ) {\n\n\t\tconst renderer = this._renderer;\n\t\tconst blurMaterial = this._blurMaterial;\n\n\t\tif ( direction !== 'latitudinal' && direction !== 'longitudinal' ) {\n\n\t\t\tconsole.error(\n\t\t\t\t'blur direction must be either latitudinal or longitudinal!' );\n\n\t\t}\n\n\t\t// Number of standard deviations at which to cut off the discrete approximation.\n\t\tconst STANDARD_DEVIATIONS = 3;\n\n\t\tconst blurMesh = new Mesh( this._lodPlanes[ lodOut ], blurMaterial );\n\t\tconst blurUniforms = blurMaterial.uniforms;\n\n\t\tconst pixels = this._sizeLods[ lodIn ] - 1;\n\t\tconst radiansPerPixel = isFinite( sigmaRadians ) ? Math.PI / ( 2 * pixels ) : 2 * Math.PI / ( 2 * MAX_SAMPLES - 1 );\n\t\tconst sigmaPixels = sigmaRadians / radiansPerPixel;\n\t\tconst samples = isFinite( sigmaRadians ) ? 1 + Math.floor( STANDARD_DEVIATIONS * sigmaPixels ) : MAX_SAMPLES;\n\n\t\tif ( samples > MAX_SAMPLES ) {\n\n\t\t\tconsole.warn( `sigmaRadians, ${\n\t\t\t\tsigmaRadians}, is too large and will clip, as it requested ${\n\t\t\t\tsamples} samples when the maximum is set to ${MAX_SAMPLES}` );\n\n\t\t}\n\n\t\tconst weights = [];\n\t\tlet sum = 0;\n\n\t\tfor ( let i = 0; i < MAX_SAMPLES; ++ i ) {\n\n\t\t\tconst x = i / sigmaPixels;\n\t\t\tconst weight = Math.exp( - x * x / 2 );\n\t\t\tweights.push( weight );\n\n\t\t\tif ( i === 0 ) {\n\n\t\t\t\tsum += weight;\n\n\t\t\t} else if ( i < samples ) {\n\n\t\t\t\tsum += 2 * weight;\n\n\t\t\t}\n\n\t\t}\n\n\t\tfor ( let i = 0; i < weights.length; i ++ ) {\n\n\t\t\tweights[ i ] = weights[ i ] / sum;\n\n\t\t}\n\n\t\tblurUniforms[ 'envMap' ].value = targetIn.texture;\n\t\tblurUniforms[ 'samples' ].value = samples;\n\t\tblurUniforms[ 'weights' ].value = weights;\n\t\tblurUniforms[ 'latitudinal' ].value = direction === 'latitudinal';\n\n\t\tif ( poleAxis ) {\n\n\t\t\tblurUniforms[ 'poleAxis' ].value = poleAxis;\n\n\t\t}\n\n\t\tconst { _lodMax } = this;\n\t\tblurUniforms[ 'dTheta' ].value = radiansPerPixel;\n\t\tblurUniforms[ 'mipInt' ].value = _lodMax - lodIn;\n\n\t\tconst outputSize = this._sizeLods[ lodOut ];\n\t\tconst x = 3 * outputSize * ( lodOut > _lodMax - LOD_MIN ? lodOut - _lodMax + LOD_MIN : 0 );\n\t\tconst y = 4 * ( this._cubeSize - outputSize );\n\n\t\t_setViewport( targetOut, x, y, 3 * outputSize, 2 * outputSize );\n\t\trenderer.setRenderTarget( targetOut );\n\t\trenderer.render( blurMesh, _flatCamera );\n\n\t}\n\n}\n\n\n\nfunction _createPlanes( lodMax ) {\n\n\tconst lodPlanes = [];\n\tconst sizeLods = [];\n\tconst sigmas = [];\n\n\tlet lod = lodMax;\n\n\tconst totalLods = lodMax - LOD_MIN + 1 + EXTRA_LOD_SIGMA.length;\n\n\tfor ( let i = 0; i < totalLods; i ++ ) {\n\n\t\tconst sizeLod = Math.pow( 2, lod );\n\t\tsizeLods.push( sizeLod );\n\t\tlet sigma = 1.0 / sizeLod;\n\n\t\tif ( i > lodMax - LOD_MIN ) {\n\n\t\t\tsigma = EXTRA_LOD_SIGMA[ i - lodMax + LOD_MIN - 1 ];\n\n\t\t} else if ( i === 0 ) {\n\n\t\t\tsigma = 0;\n\n\t\t}\n\n\t\tsigmas.push( sigma );\n\n\t\tconst texelSize = 1.0 / ( sizeLod - 2 );\n\t\tconst min = - texelSize;\n\t\tconst max = 1 + texelSize;\n\t\tconst uv1 = [ min, min, max, min, max, max, min, min, max, max, min, max ];\n\n\t\tconst cubeFaces = 6;\n\t\tconst vertices = 6;\n\t\tconst positionSize = 3;\n\t\tconst uvSize = 2;\n\t\tconst faceIndexSize = 1;\n\n\t\tconst position = new Float32Array( positionSize * vertices * cubeFaces );\n\t\tconst uv = new Float32Array( uvSize * vertices * cubeFaces );\n\t\tconst faceIndex = new Float32Array( faceIndexSize * vertices * cubeFaces );\n\n\t\tfor ( let face = 0; face < cubeFaces; face ++ ) {\n\n\t\t\tconst x = ( face % 3 ) * 2 / 3 - 1;\n\t\t\tconst y = face > 2 ? 0 : - 1;\n\t\t\tconst coordinates = [\n\t\t\t\tx, y, 0,\n\t\t\t\tx + 2 / 3, y, 0,\n\t\t\t\tx + 2 / 3, y + 1, 0,\n\t\t\t\tx, y, 0,\n\t\t\t\tx + 2 / 3, y + 1, 0,\n\t\t\t\tx, y + 1, 0\n\t\t\t];\n\t\t\tposition.set( coordinates, positionSize * vertices * face );\n\t\t\tuv.set( uv1, uvSize * vertices * face );\n\t\t\tconst fill = [ face, face, face, face, face, face ];\n\t\t\tfaceIndex.set( fill, faceIndexSize * vertices * face );\n\n\t\t}\n\n\t\tconst planes = new BufferGeometry();\n\t\tplanes.setAttribute( 'position', new BufferAttribute( position, positionSize ) );\n\t\tplanes.setAttribute( 'uv', new BufferAttribute( uv, uvSize ) );\n\t\tplanes.setAttribute( 'faceIndex', new BufferAttribute( faceIndex, faceIndexSize ) );\n\t\tlodPlanes.push( planes );\n\n\t\tif ( lod > LOD_MIN ) {\n\n\t\t\tlod --;\n\n\t\t}\n\n\t}\n\n\treturn { lodPlanes, sizeLods, sigmas };\n\n}\n\nfunction _createRenderTarget( width, height, params ) {\n\n\tconst cubeUVRenderTarget = new WebGLRenderTarget( width, height, params );\n\tcubeUVRenderTarget.texture.mapping = CubeUVReflectionMapping;\n\tcubeUVRenderTarget.texture.name = 'PMREM.cubeUv';\n\tcubeUVRenderTarget.scissorTest = true;\n\treturn cubeUVRenderTarget;\n\n}\n\nfunction _setViewport( target, x, y, width, height ) {\n\n\ttarget.viewport.set( x, y, width, height );\n\ttarget.scissor.set( x, y, width, height );\n\n}\n\nfunction _getBlurShader( lodMax, width, height ) {\n\n\tconst weights = new Float32Array( MAX_SAMPLES );\n\tconst poleAxis = new Vector3( 0, 1, 0 );\n\tconst shaderMaterial = new ShaderMaterial( {\n\n\t\tname: 'SphericalGaussianBlur',\n\n\t\tdefines: {\n\t\t\t'n': MAX_SAMPLES,\n\t\t\t'CUBEUV_TEXEL_WIDTH': 1.0 / width,\n\t\t\t'CUBEUV_TEXEL_HEIGHT': 1.0 / height,\n\t\t\t'CUBEUV_MAX_MIP': `${lodMax}.0`,\n\t\t},\n\n\t\tuniforms: {\n\t\t\t'envMap': { value: null },\n\t\t\t'samples': { value: 1 },\n\t\t\t'weights': { value: weights },\n\t\t\t'latitudinal': { value: false },\n\t\t\t'dTheta': { value: 0 },\n\t\t\t'mipInt': { value: 0 },\n\t\t\t'poleAxis': { value: poleAxis }\n\t\t},\n\n\t\tvertexShader: _getCommonVertexShader(),\n\n\t\tfragmentShader: /* glsl */`\n\n\t\t\tprecision mediump float;\n\t\t\tprecision mediump int;\n\n\t\t\tvarying vec3 vOutputDirection;\n\n\t\t\tuniform sampler2D envMap;\n\t\t\tuniform int samples;\n\t\t\tuniform float weights[ n ];\n\t\t\tuniform bool latitudinal;\n\t\t\tuniform float dTheta;\n\t\t\tuniform float mipInt;\n\t\t\tuniform vec3 poleAxis;\n\n\t\t\t#define ENVMAP_TYPE_CUBE_UV\n\t\t\t#include \n\n\t\t\tvec3 getSample( float theta, vec3 axis ) {\n\n\t\t\t\tfloat cosTheta = cos( theta );\n\t\t\t\t// Rodrigues' axis-angle rotation\n\t\t\t\tvec3 sampleDirection = vOutputDirection * cosTheta\n\t\t\t\t\t+ cross( axis, vOutputDirection ) * sin( theta )\n\t\t\t\t\t+ axis * dot( axis, vOutputDirection ) * ( 1.0 - cosTheta );\n\n\t\t\t\treturn bilinearCubeUV( envMap, sampleDirection, mipInt );\n\n\t\t\t}\n\n\t\t\tvoid main() {\n\n\t\t\t\tvec3 axis = latitudinal ? poleAxis : cross( poleAxis, vOutputDirection );\n\n\t\t\t\tif ( all( equal( axis, vec3( 0.0 ) ) ) ) {\n\n\t\t\t\t\taxis = vec3( vOutputDirection.z, 0.0, - vOutputDirection.x );\n\n\t\t\t\t}\n\n\t\t\t\taxis = normalize( axis );\n\n\t\t\t\tgl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );\n\t\t\t\tgl_FragColor.rgb += weights[ 0 ] * getSample( 0.0, axis );\n\n\t\t\t\tfor ( int i = 1; i < n; i++ ) {\n\n\t\t\t\t\tif ( i >= samples ) {\n\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t}\n\n\t\t\t\t\tfloat theta = dTheta * float( i );\n\t\t\t\t\tgl_FragColor.rgb += weights[ i ] * getSample( -1.0 * theta, axis );\n\t\t\t\t\tgl_FragColor.rgb += weights[ i ] * getSample( theta, axis );\n\n\t\t\t\t}\n\n\t\t\t}\n\t\t`,\n\n\t\tblending: NoBlending,\n\t\tdepthTest: false,\n\t\tdepthWrite: false\n\n\t} );\n\n\treturn shaderMaterial;\n\n}\n\nfunction _getEquirectMaterial() {\n\n\treturn new ShaderMaterial( {\n\n\t\tname: 'EquirectangularToCubeUV',\n\n\t\tuniforms: {\n\t\t\t'envMap': { value: null }\n\t\t},\n\n\t\tvertexShader: _getCommonVertexShader(),\n\n\t\tfragmentShader: /* glsl */`\n\n\t\t\tprecision mediump float;\n\t\t\tprecision mediump int;\n\n\t\t\tvarying vec3 vOutputDirection;\n\n\t\t\tuniform sampler2D envMap;\n\n\t\t\t#include \n\n\t\t\tvoid main() {\n\n\t\t\t\tvec3 outputDirection = normalize( vOutputDirection );\n\t\t\t\tvec2 uv = equirectUv( outputDirection );\n\n\t\t\t\tgl_FragColor = vec4( texture2D ( envMap, uv ).rgb, 1.0 );\n\n\t\t\t}\n\t\t`,\n\n\t\tblending: NoBlending,\n\t\tdepthTest: false,\n\t\tdepthWrite: false\n\n\t} );\n\n}\n\nfunction _getCubemapMaterial() {\n\n\treturn new ShaderMaterial( {\n\n\t\tname: 'CubemapToCubeUV',\n\n\t\tuniforms: {\n\t\t\t'envMap': { value: null },\n\t\t\t'flipEnvMap': { value: - 1 }\n\t\t},\n\n\t\tvertexShader: _getCommonVertexShader(),\n\n\t\tfragmentShader: /* glsl */`\n\n\t\t\tprecision mediump float;\n\t\t\tprecision mediump int;\n\n\t\t\tuniform float flipEnvMap;\n\n\t\t\tvarying vec3 vOutputDirection;\n\n\t\t\tuniform samplerCube envMap;\n\n\t\t\tvoid main() {\n\n\t\t\t\tgl_FragColor = textureCube( envMap, vec3( flipEnvMap * vOutputDirection.x, vOutputDirection.yz ) );\n\n\t\t\t}\n\t\t`,\n\n\t\tblending: NoBlending,\n\t\tdepthTest: false,\n\t\tdepthWrite: false\n\n\t} );\n\n}\n\nfunction _getCommonVertexShader() {\n\n\treturn /* glsl */`\n\n\t\tprecision mediump float;\n\t\tprecision mediump int;\n\n\t\tattribute float faceIndex;\n\n\t\tvarying vec3 vOutputDirection;\n\n\t\t// RH coordinate system; PMREM face-indexing convention\n\t\tvec3 getDirection( vec2 uv, float face ) {\n\n\t\t\tuv = 2.0 * uv - 1.0;\n\n\t\t\tvec3 direction = vec3( uv, 1.0 );\n\n\t\t\tif ( face == 0.0 ) {\n\n\t\t\t\tdirection = direction.zyx; // ( 1, v, u ) pos x\n\n\t\t\t} else if ( face == 1.0 ) {\n\n\t\t\t\tdirection = direction.xzy;\n\t\t\t\tdirection.xz *= -1.0; // ( -u, 1, -v ) pos y\n\n\t\t\t} else if ( face == 2.0 ) {\n\n\t\t\t\tdirection.x *= -1.0; // ( -u, v, 1 ) pos z\n\n\t\t\t} else if ( face == 3.0 ) {\n\n\t\t\t\tdirection = direction.zyx;\n\t\t\t\tdirection.xz *= -1.0; // ( -1, v, -u ) neg x\n\n\t\t\t} else if ( face == 4.0 ) {\n\n\t\t\t\tdirection = direction.xzy;\n\t\t\t\tdirection.xy *= -1.0; // ( -u, -1, v ) neg y\n\n\t\t\t} else if ( face == 5.0 ) {\n\n\t\t\t\tdirection.z *= -1.0; // ( u, v, -1 ) neg z\n\n\t\t\t}\n\n\t\t\treturn direction;\n\n\t\t}\n\n\t\tvoid main() {\n\n\t\t\tvOutputDirection = getDirection( uv, faceIndex );\n\t\t\tgl_Position = vec4( position, 1.0 );\n\n\t\t}\n\t`;\n\n}\n\nfunction WebGLCubeUVMaps( renderer ) {\n\n\tlet cubeUVmaps = new WeakMap();\n\n\tlet pmremGenerator = null;\n\n\tfunction get( texture ) {\n\n\t\tif ( texture && texture.isTexture ) {\n\n\t\t\tconst mapping = texture.mapping;\n\n\t\t\tconst isEquirectMap = ( mapping === EquirectangularReflectionMapping || mapping === EquirectangularRefractionMapping );\n\t\t\tconst isCubeMap = ( mapping === CubeReflectionMapping || mapping === CubeRefractionMapping );\n\n\t\t\t// equirect/cube map to cubeUV conversion\n\n\t\t\tif ( isEquirectMap || isCubeMap ) {\n\n\t\t\t\tlet renderTarget = cubeUVmaps.get( texture );\n\n\t\t\t\tconst currentPMREMVersion = renderTarget !== undefined ? renderTarget.texture.pmremVersion : 0;\n\n\t\t\t\tif ( texture.isRenderTargetTexture && texture.pmremVersion !== currentPMREMVersion ) {\n\n\t\t\t\t\tif ( pmremGenerator === null ) pmremGenerator = new PMREMGenerator( renderer );\n\n\t\t\t\t\trenderTarget = isEquirectMap ? pmremGenerator.fromEquirectangular( texture, renderTarget ) : pmremGenerator.fromCubemap( texture, renderTarget );\n\t\t\t\t\trenderTarget.texture.pmremVersion = texture.pmremVersion;\n\n\t\t\t\t\tcubeUVmaps.set( texture, renderTarget );\n\n\t\t\t\t\treturn renderTarget.texture;\n\n\t\t\t\t} else {\n\n\t\t\t\t\tif ( renderTarget !== undefined ) {\n\n\t\t\t\t\t\treturn renderTarget.texture;\n\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\tconst image = texture.image;\n\n\t\t\t\t\t\tif ( ( isEquirectMap && image && image.height > 0 ) || ( isCubeMap && image && isCubeTextureComplete( image ) ) ) {\n\n\t\t\t\t\t\t\tif ( pmremGenerator === null ) pmremGenerator = new PMREMGenerator( renderer );\n\n\t\t\t\t\t\t\trenderTarget = isEquirectMap ? pmremGenerator.fromEquirectangular( texture ) : pmremGenerator.fromCubemap( texture );\n\t\t\t\t\t\t\trenderTarget.texture.pmremVersion = texture.pmremVersion;\n\n\t\t\t\t\t\t\tcubeUVmaps.set( texture, renderTarget );\n\n\t\t\t\t\t\t\ttexture.addEventListener( 'dispose', onTextureDispose );\n\n\t\t\t\t\t\t\treturn renderTarget.texture;\n\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t// image not yet ready. try the conversion next frame\n\n\t\t\t\t\t\t\treturn null;\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn texture;\n\n\t}\n\n\tfunction isCubeTextureComplete( image ) {\n\n\t\tlet count = 0;\n\t\tconst length = 6;\n\n\t\tfor ( let i = 0; i < length; i ++ ) {\n\n\t\t\tif ( image[ i ] !== undefined ) count ++;\n\n\t\t}\n\n\t\treturn count === length;\n\n\n\t}\n\n\tfunction onTextureDispose( event ) {\n\n\t\tconst texture = event.target;\n\n\t\ttexture.removeEventListener( 'dispose', onTextureDispose );\n\n\t\tconst cubemapUV = cubeUVmaps.get( texture );\n\n\t\tif ( cubemapUV !== undefined ) {\n\n\t\t\tcubeUVmaps.delete( texture );\n\t\t\tcubemapUV.dispose();\n\n\t\t}\n\n\t}\n\n\tfunction dispose() {\n\n\t\tcubeUVmaps = new WeakMap();\n\n\t\tif ( pmremGenerator !== null ) {\n\n\t\t\tpmremGenerator.dispose();\n\t\t\tpmremGenerator = null;\n\n\t\t}\n\n\t}\n\n\treturn {\n\t\tget: get,\n\t\tdispose: dispose\n\t};\n\n}\n\nfunction WebGLExtensions( gl ) {\n\n\tconst extensions = {};\n\n\tfunction getExtension( name ) {\n\n\t\tif ( extensions[ name ] !== undefined ) {\n\n\t\t\treturn extensions[ name ];\n\n\t\t}\n\n\t\tlet extension;\n\n\t\tswitch ( name ) {\n\n\t\t\tcase 'WEBGL_depth_texture':\n\t\t\t\textension = gl.getExtension( 'WEBGL_depth_texture' ) || gl.getExtension( 'MOZ_WEBGL_depth_texture' ) || gl.getExtension( 'WEBKIT_WEBGL_depth_texture' );\n\t\t\t\tbreak;\n\n\t\t\tcase 'EXT_texture_filter_anisotropic':\n\t\t\t\textension = gl.getExtension( 'EXT_texture_filter_anisotropic' ) || gl.getExtension( 'MOZ_EXT_texture_filter_anisotropic' ) || gl.getExtension( 'WEBKIT_EXT_texture_filter_anisotropic' );\n\t\t\t\tbreak;\n\n\t\t\tcase 'WEBGL_compressed_texture_s3tc':\n\t\t\t\textension = gl.getExtension( 'WEBGL_compressed_texture_s3tc' ) || gl.getExtension( 'MOZ_WEBGL_compressed_texture_s3tc' ) || gl.getExtension( 'WEBKIT_WEBGL_compressed_texture_s3tc' );\n\t\t\t\tbreak;\n\n\t\t\tcase 'WEBGL_compressed_texture_pvrtc':\n\t\t\t\textension = gl.getExtension( 'WEBGL_compressed_texture_pvrtc' ) || gl.getExtension( 'WEBKIT_WEBGL_compressed_texture_pvrtc' );\n\t\t\t\tbreak;\n\n\t\t\tdefault:\n\t\t\t\textension = gl.getExtension( name );\n\n\t\t}\n\n\t\textensions[ name ] = extension;\n\n\t\treturn extension;\n\n\t}\n\n\treturn {\n\n\t\thas: function ( name ) {\n\n\t\t\treturn getExtension( name ) !== null;\n\n\t\t},\n\n\t\tinit: function () {\n\n\t\t\tgetExtension( 'EXT_color_buffer_float' );\n\t\t\tgetExtension( 'WEBGL_clip_cull_distance' );\n\t\t\tgetExtension( 'OES_texture_float_linear' );\n\t\t\tgetExtension( 'EXT_color_buffer_half_float' );\n\t\t\tgetExtension( 'WEBGL_multisampled_render_to_texture' );\n\t\t\tgetExtension( 'WEBGL_render_shared_exponent' );\n\n\t\t},\n\n\t\tget: function ( name ) {\n\n\t\t\tconst extension = getExtension( name );\n\n\t\t\tif ( extension === null ) {\n\n\t\t\t\tconsole.warn( 'THREE.WebGLRenderer: ' + name + ' extension not supported.' );\n\n\t\t\t}\n\n\t\t\treturn extension;\n\n\t\t}\n\n\t};\n\n}\n\nfunction WebGLGeometries( gl, attributes, info, bindingStates ) {\n\n\tconst geometries = {};\n\tconst wireframeAttributes = new WeakMap();\n\n\tfunction onGeometryDispose( event ) {\n\n\t\tconst geometry = event.target;\n\n\t\tif ( geometry.index !== null ) {\n\n\t\t\tattributes.remove( geometry.index );\n\n\t\t}\n\n\t\tfor ( const name in geometry.attributes ) {\n\n\t\t\tattributes.remove( geometry.attributes[ name ] );\n\n\t\t}\n\n\t\tfor ( const name in geometry.morphAttributes ) {\n\n\t\t\tconst array = geometry.morphAttributes[ name ];\n\n\t\t\tfor ( let i = 0, l = array.length; i < l; i ++ ) {\n\n\t\t\t\tattributes.remove( array[ i ] );\n\n\t\t\t}\n\n\t\t}\n\n\t\tgeometry.removeEventListener( 'dispose', onGeometryDispose );\n\n\t\tdelete geometries[ geometry.id ];\n\n\t\tconst attribute = wireframeAttributes.get( geometry );\n\n\t\tif ( attribute ) {\n\n\t\t\tattributes.remove( attribute );\n\t\t\twireframeAttributes.delete( geometry );\n\n\t\t}\n\n\t\tbindingStates.releaseStatesOfGeometry( geometry );\n\n\t\tif ( geometry.isInstancedBufferGeometry === true ) {\n\n\t\t\tdelete geometry._maxInstanceCount;\n\n\t\t}\n\n\t\t//\n\n\t\tinfo.memory.geometries --;\n\n\t}\n\n\tfunction get( object, geometry ) {\n\n\t\tif ( geometries[ geometry.id ] === true ) return geometry;\n\n\t\tgeometry.addEventListener( 'dispose', onGeometryDispose );\n\n\t\tgeometries[ geometry.id ] = true;\n\n\t\tinfo.memory.geometries ++;\n\n\t\treturn geometry;\n\n\t}\n\n\tfunction update( geometry ) {\n\n\t\tconst geometryAttributes = geometry.attributes;\n\n\t\t// Updating index buffer in VAO now. See WebGLBindingStates.\n\n\t\tfor ( const name in geometryAttributes ) {\n\n\t\t\tattributes.update( geometryAttributes[ name ], gl.ARRAY_BUFFER );\n\n\t\t}\n\n\t\t// morph targets\n\n\t\tconst morphAttributes = geometry.morphAttributes;\n\n\t\tfor ( const name in morphAttributes ) {\n\n\t\t\tconst array = morphAttributes[ name ];\n\n\t\t\tfor ( let i = 0, l = array.length; i < l; i ++ ) {\n\n\t\t\t\tattributes.update( array[ i ], gl.ARRAY_BUFFER );\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n\tfunction updateWireframeAttribute( geometry ) {\n\n\t\tconst indices = [];\n\n\t\tconst geometryIndex = geometry.index;\n\t\tconst geometryPosition = geometry.attributes.position;\n\t\tlet version = 0;\n\n\t\tif ( geometryIndex !== null ) {\n\n\t\t\tconst array = geometryIndex.array;\n\t\t\tversion = geometryIndex.version;\n\n\t\t\tfor ( let i = 0, l = array.length; i < l; i += 3 ) {\n\n\t\t\t\tconst a = array[ i + 0 ];\n\t\t\t\tconst b = array[ i + 1 ];\n\t\t\t\tconst c = array[ i + 2 ];\n\n\t\t\t\tindices.push( a, b, b, c, c, a );\n\n\t\t\t}\n\n\t\t} else if ( geometryPosition !== undefined ) {\n\n\t\t\tconst array = geometryPosition.array;\n\t\t\tversion = geometryPosition.version;\n\n\t\t\tfor ( let i = 0, l = ( array.length / 3 ) - 1; i < l; i += 3 ) {\n\n\t\t\t\tconst a = i + 0;\n\t\t\t\tconst b = i + 1;\n\t\t\t\tconst c = i + 2;\n\n\t\t\t\tindices.push( a, b, b, c, c, a );\n\n\t\t\t}\n\n\t\t} else {\n\n\t\t\treturn;\n\n\t\t}\n\n\t\tconst attribute = new ( arrayNeedsUint32( indices ) ? Uint32BufferAttribute : Uint16BufferAttribute )( indices, 1 );\n\t\tattribute.version = version;\n\n\t\t// Updating index buffer in VAO now. See WebGLBindingStates\n\n\t\t//\n\n\t\tconst previousAttribute = wireframeAttributes.get( geometry );\n\n\t\tif ( previousAttribute ) attributes.remove( previousAttribute );\n\n\t\t//\n\n\t\twireframeAttributes.set( geometry, attribute );\n\n\t}\n\n\tfunction getWireframeAttribute( geometry ) {\n\n\t\tconst currentAttribute = wireframeAttributes.get( geometry );\n\n\t\tif ( currentAttribute ) {\n\n\t\t\tconst geometryIndex = geometry.index;\n\n\t\t\tif ( geometryIndex !== null ) {\n\n\t\t\t\t// if the attribute is obsolete, create a new one\n\n\t\t\t\tif ( currentAttribute.version < geometryIndex.version ) {\n\n\t\t\t\t\tupdateWireframeAttribute( geometry );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t} else {\n\n\t\t\tupdateWireframeAttribute( geometry );\n\n\t\t}\n\n\t\treturn wireframeAttributes.get( geometry );\n\n\t}\n\n\treturn {\n\n\t\tget: get,\n\t\tupdate: update,\n\n\t\tgetWireframeAttribute: getWireframeAttribute\n\n\t};\n\n}\n\nfunction WebGLIndexedBufferRenderer( gl, extensions, info ) {\n\n\tlet mode;\n\n\tfunction setMode( value ) {\n\n\t\tmode = value;\n\n\t}\n\n\tlet type, bytesPerElement;\n\n\tfunction setIndex( value ) {\n\n\t\ttype = value.type;\n\t\tbytesPerElement = value.bytesPerElement;\n\n\t}\n\n\tfunction render( start, count ) {\n\n\t\tgl.drawElements( mode, count, type, start * bytesPerElement );\n\n\t\tinfo.update( count, mode, 1 );\n\n\t}\n\n\tfunction renderInstances( start, count, primcount ) {\n\n\t\tif ( primcount === 0 ) return;\n\n\t\tgl.drawElementsInstanced( mode, count, type, start * bytesPerElement, primcount );\n\n\t\tinfo.update( count, mode, primcount );\n\n\t}\n\n\tfunction renderMultiDraw( starts, counts, drawCount ) {\n\n\t\tif ( drawCount === 0 ) return;\n\n\t\tconst extension = extensions.get( 'WEBGL_multi_draw' );\n\n\t\tif ( extension === null ) {\n\n\t\t\tfor ( let i = 0; i < drawCount; i ++ ) {\n\n\t\t\t\tthis.render( starts[ i ] / bytesPerElement, counts[ i ] );\n\n\t\t\t}\n\n\t\t} else {\n\n\t\t\textension.multiDrawElementsWEBGL( mode, counts, 0, type, starts, 0, drawCount );\n\n\t\t\tlet elementCount = 0;\n\t\t\tfor ( let i = 0; i < drawCount; i ++ ) {\n\n\t\t\t\telementCount += counts[ i ];\n\n\t\t\t}\n\n\t\t\tinfo.update( elementCount, mode, 1 );\n\n\t\t}\n\n\t}\n\n\t//\n\n\tthis.setMode = setMode;\n\tthis.setIndex = setIndex;\n\tthis.render = render;\n\tthis.renderInstances = renderInstances;\n\tthis.renderMultiDraw = renderMultiDraw;\n\n}\n\nfunction WebGLInfo( gl ) {\n\n\tconst memory = {\n\t\tgeometries: 0,\n\t\ttextures: 0\n\t};\n\n\tconst render = {\n\t\tframe: 0,\n\t\tcalls: 0,\n\t\ttriangles: 0,\n\t\tpoints: 0,\n\t\tlines: 0\n\t};\n\n\tfunction update( count, mode, instanceCount ) {\n\n\t\trender.calls ++;\n\n\t\tswitch ( mode ) {\n\n\t\t\tcase gl.TRIANGLES:\n\t\t\t\trender.triangles += instanceCount * ( count / 3 );\n\t\t\t\tbreak;\n\n\t\t\tcase gl.LINES:\n\t\t\t\trender.lines += instanceCount * ( count / 2 );\n\t\t\t\tbreak;\n\n\t\t\tcase gl.LINE_STRIP:\n\t\t\t\trender.lines += instanceCount * ( count - 1 );\n\t\t\t\tbreak;\n\n\t\t\tcase gl.LINE_LOOP:\n\t\t\t\trender.lines += instanceCount * count;\n\t\t\t\tbreak;\n\n\t\t\tcase gl.POINTS:\n\t\t\t\trender.points += instanceCount * count;\n\t\t\t\tbreak;\n\n\t\t\tdefault:\n\t\t\t\tconsole.error( 'THREE.WebGLInfo: Unknown draw mode:', mode );\n\t\t\t\tbreak;\n\n\t\t}\n\n\t}\n\n\tfunction reset() {\n\n\t\trender.calls = 0;\n\t\trender.triangles = 0;\n\t\trender.points = 0;\n\t\trender.lines = 0;\n\n\t}\n\n\treturn {\n\t\tmemory: memory,\n\t\trender: render,\n\t\tprograms: null,\n\t\tautoReset: true,\n\t\treset: reset,\n\t\tupdate: update\n\t};\n\n}\n\nfunction WebGLMorphtargets( gl, capabilities, textures ) {\n\n\tconst morphTextures = new WeakMap();\n\tconst morph = new Vector4();\n\n\tfunction update( object, geometry, program ) {\n\n\t\tconst objectInfluences = object.morphTargetInfluences;\n\n\t\t// instead of using attributes, the WebGL 2 code path encodes morph targets\n\t\t// into an array of data textures. Each layer represents a single morph target.\n\n\t\tconst morphAttribute = geometry.morphAttributes.position || geometry.morphAttributes.normal || geometry.morphAttributes.color;\n\t\tconst morphTargetsCount = ( morphAttribute !== undefined ) ? morphAttribute.length : 0;\n\n\t\tlet entry = morphTextures.get( geometry );\n\n\t\tif ( entry === undefined || entry.count !== morphTargetsCount ) {\n\n\t\t\tif ( entry !== undefined ) entry.texture.dispose();\n\n\t\t\tconst hasMorphPosition = geometry.morphAttributes.position !== undefined;\n\t\t\tconst hasMorphNormals = geometry.morphAttributes.normal !== undefined;\n\t\t\tconst hasMorphColors = geometry.morphAttributes.color !== undefined;\n\n\t\t\tconst morphTargets = geometry.morphAttributes.position || [];\n\t\t\tconst morphNormals = geometry.morphAttributes.normal || [];\n\t\t\tconst morphColors = geometry.morphAttributes.color || [];\n\n\t\t\tlet vertexDataCount = 0;\n\n\t\t\tif ( hasMorphPosition === true ) vertexDataCount = 1;\n\t\t\tif ( hasMorphNormals === true ) vertexDataCount = 2;\n\t\t\tif ( hasMorphColors === true ) vertexDataCount = 3;\n\n\t\t\tlet width = geometry.attributes.position.count * vertexDataCount;\n\t\t\tlet height = 1;\n\n\t\t\tif ( width > capabilities.maxTextureSize ) {\n\n\t\t\t\theight = Math.ceil( width / capabilities.maxTextureSize );\n\t\t\t\twidth = capabilities.maxTextureSize;\n\n\t\t\t}\n\n\t\t\tconst buffer = new Float32Array( width * height * 4 * morphTargetsCount );\n\n\t\t\tconst texture = new DataArrayTexture( buffer, width, height, morphTargetsCount );\n\t\t\ttexture.type = FloatType;\n\t\t\ttexture.needsUpdate = true;\n\n\t\t\t// fill buffer\n\n\t\t\tconst vertexDataStride = vertexDataCount * 4;\n\n\t\t\tfor ( let i = 0; i < morphTargetsCount; i ++ ) {\n\n\t\t\t\tconst morphTarget = morphTargets[ i ];\n\t\t\t\tconst morphNormal = morphNormals[ i ];\n\t\t\t\tconst morphColor = morphColors[ i ];\n\n\t\t\t\tconst offset = width * height * 4 * i;\n\n\t\t\t\tfor ( let j = 0; j < morphTarget.count; j ++ ) {\n\n\t\t\t\t\tconst stride = j * vertexDataStride;\n\n\t\t\t\t\tif ( hasMorphPosition === true ) {\n\n\t\t\t\t\t\tmorph.fromBufferAttribute( morphTarget, j );\n\n\t\t\t\t\t\tbuffer[ offset + stride + 0 ] = morph.x;\n\t\t\t\t\t\tbuffer[ offset + stride + 1 ] = morph.y;\n\t\t\t\t\t\tbuffer[ offset + stride + 2 ] = morph.z;\n\t\t\t\t\t\tbuffer[ offset + stride + 3 ] = 0;\n\n\t\t\t\t\t}\n\n\t\t\t\t\tif ( hasMorphNormals === true ) {\n\n\t\t\t\t\t\tmorph.fromBufferAttribute( morphNormal, j );\n\n\t\t\t\t\t\tbuffer[ offset + stride + 4 ] = morph.x;\n\t\t\t\t\t\tbuffer[ offset + stride + 5 ] = morph.y;\n\t\t\t\t\t\tbuffer[ offset + stride + 6 ] = morph.z;\n\t\t\t\t\t\tbuffer[ offset + stride + 7 ] = 0;\n\n\t\t\t\t\t}\n\n\t\t\t\t\tif ( hasMorphColors === true ) {\n\n\t\t\t\t\t\tmorph.fromBufferAttribute( morphColor, j );\n\n\t\t\t\t\t\tbuffer[ offset + stride + 8 ] = morph.x;\n\t\t\t\t\t\tbuffer[ offset + stride + 9 ] = morph.y;\n\t\t\t\t\t\tbuffer[ offset + stride + 10 ] = morph.z;\n\t\t\t\t\t\tbuffer[ offset + stride + 11 ] = ( morphColor.itemSize === 4 ) ? morph.w : 1;\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tentry = {\n\t\t\t\tcount: morphTargetsCount,\n\t\t\t\ttexture: texture,\n\t\t\t\tsize: new Vector2( width, height )\n\t\t\t};\n\n\t\t\tmorphTextures.set( geometry, entry );\n\n\t\t\tfunction disposeTexture() {\n\n\t\t\t\ttexture.dispose();\n\n\t\t\t\tmorphTextures.delete( geometry );\n\n\t\t\t\tgeometry.removeEventListener( 'dispose', disposeTexture );\n\n\t\t\t}\n\n\t\t\tgeometry.addEventListener( 'dispose', disposeTexture );\n\n\t\t}\n\n\t\t//\n\t\tif ( object.isInstancedMesh === true && object.morphTexture !== null ) {\n\n\t\t\tprogram.getUniforms().setValue( gl, 'morphTexture', object.morphTexture, textures );\n\n\t\t} else {\n\n\t\t\tlet morphInfluencesSum = 0;\n\n\t\t\tfor ( let i = 0; i < objectInfluences.length; i ++ ) {\n\n\t\t\t\tmorphInfluencesSum += objectInfluences[ i ];\n\n\t\t\t}\n\n\t\t\tconst morphBaseInfluence = geometry.morphTargetsRelative ? 1 : 1 - morphInfluencesSum;\n\n\n\t\t\tprogram.getUniforms().setValue( gl, 'morphTargetBaseInfluence', morphBaseInfluence );\n\t\t\tprogram.getUniforms().setValue( gl, 'morphTargetInfluences', objectInfluences );\n\n\t\t}\n\n\t\tprogram.getUniforms().setValue( gl, 'morphTargetsTexture', entry.texture, textures );\n\t\tprogram.getUniforms().setValue( gl, 'morphTargetsTextureSize', entry.size );\n\n\t}\n\n\treturn {\n\n\t\tupdate: update\n\n\t};\n\n}\n\nfunction WebGLObjects( gl, geometries, attributes, info ) {\n\n\tlet updateMap = new WeakMap();\n\n\tfunction update( object ) {\n\n\t\tconst frame = info.render.frame;\n\n\t\tconst geometry = object.geometry;\n\t\tconst buffergeometry = geometries.get( object, geometry );\n\n\t\t// Update once per frame\n\n\t\tif ( updateMap.get( buffergeometry ) !== frame ) {\n\n\t\t\tgeometries.update( buffergeometry );\n\n\t\t\tupdateMap.set( buffergeometry, frame );\n\n\t\t}\n\n\t\tif ( object.isInstancedMesh ) {\n\n\t\t\tif ( object.hasEventListener( 'dispose', onInstancedMeshDispose ) === false ) {\n\n\t\t\t\tobject.addEventListener( 'dispose', onInstancedMeshDispose );\n\n\t\t\t}\n\n\t\t\tif ( updateMap.get( object ) !== frame ) {\n\n\t\t\t\tattributes.update( object.instanceMatrix, gl.ARRAY_BUFFER );\n\n\t\t\t\tif ( object.instanceColor !== null ) {\n\n\t\t\t\t\tattributes.update( object.instanceColor, gl.ARRAY_BUFFER );\n\n\t\t\t\t}\n\n\t\t\t\tupdateMap.set( object, frame );\n\n\t\t\t}\n\n\t\t}\n\n\t\tif ( object.isSkinnedMesh ) {\n\n\t\t\tconst skeleton = object.skeleton;\n\n\t\t\tif ( updateMap.get( skeleton ) !== frame ) {\n\n\t\t\t\tskeleton.update();\n\n\t\t\t\tupdateMap.set( skeleton, frame );\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn buffergeometry;\n\n\t}\n\n\tfunction dispose() {\n\n\t\tupdateMap = new WeakMap();\n\n\t}\n\n\tfunction onInstancedMeshDispose( event ) {\n\n\t\tconst instancedMesh = event.target;\n\n\t\tinstancedMesh.removeEventListener( 'dispose', onInstancedMeshDispose );\n\n\t\tattributes.remove( instancedMesh.instanceMatrix );\n\n\t\tif ( instancedMesh.instanceColor !== null ) attributes.remove( instancedMesh.instanceColor );\n\n\t}\n\n\treturn {\n\n\t\tupdate: update,\n\t\tdispose: dispose\n\n\t};\n\n}\n\nclass DepthTexture extends Texture {\n\n\tconstructor( width, height, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy, format ) {\n\n\t\tformat = format !== undefined ? format : DepthFormat;\n\n\t\tif ( format !== DepthFormat && format !== DepthStencilFormat ) {\n\n\t\t\tthrow new Error( 'DepthTexture format must be either THREE.DepthFormat or THREE.DepthStencilFormat' );\n\n\t\t}\n\n\t\tif ( type === undefined && format === DepthFormat ) type = UnsignedIntType;\n\t\tif ( type === undefined && format === DepthStencilFormat ) type = UnsignedInt248Type;\n\n\t\tsuper( null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy );\n\n\t\tthis.isDepthTexture = true;\n\n\t\tthis.image = { width: width, height: height };\n\n\t\tthis.magFilter = magFilter !== undefined ? magFilter : NearestFilter;\n\t\tthis.minFilter = minFilter !== undefined ? minFilter : NearestFilter;\n\n\t\tthis.flipY = false;\n\t\tthis.generateMipmaps = false;\n\n\t\tthis.compareFunction = null;\n\n\t}\n\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.compareFunction = source.compareFunction;\n\n\t\treturn this;\n\n\t}\n\n\ttoJSON( meta ) {\n\n\t\tconst data = super.toJSON( meta );\n\n\t\tif ( this.compareFunction !== null ) data.compareFunction = this.compareFunction;\n\n\t\treturn data;\n\n\t}\n\n}\n\n/**\n * Uniforms of a program.\n * Those form a tree structure with a special top-level container for the root,\n * which you get by calling 'new WebGLUniforms( gl, program )'.\n *\n *\n * Properties of inner nodes including the top-level container:\n *\n * .seq - array of nested uniforms\n * .map - nested uniforms by name\n *\n *\n * Methods of all nodes except the top-level container:\n *\n * .setValue( gl, value, [textures] )\n *\n * \t\tuploads a uniform value(s)\n * \tthe 'textures' parameter is needed for sampler uniforms\n *\n *\n * Static methods of the top-level container (textures factorizations):\n *\n * .upload( gl, seq, values, textures )\n *\n * \t\tsets uniforms in 'seq' to 'values[id].value'\n *\n * .seqWithValue( seq, values ) : filteredSeq\n *\n * \t\tfilters 'seq' entries with corresponding entry in values\n *\n *\n * Methods of the top-level container (textures factorizations):\n *\n * .setValue( gl, name, value, textures )\n *\n * \t\tsets uniform with name 'name' to 'value'\n *\n * .setOptional( gl, obj, prop )\n *\n * \t\tlike .set for an optional property of the object\n *\n */\n\n\nconst emptyTexture = /*@__PURE__*/ new Texture();\n\nconst emptyShadowTexture = /*@__PURE__*/ new DepthTexture( 1, 1 );\nemptyShadowTexture.compareFunction = LessEqualCompare;\n\nconst emptyArrayTexture = /*@__PURE__*/ new DataArrayTexture();\nconst empty3dTexture = /*@__PURE__*/ new Data3DTexture();\nconst emptyCubeTexture = /*@__PURE__*/ new CubeTexture();\n\n// --- Utilities ---\n\n// Array Caches (provide typed arrays for temporary by size)\n\nconst arrayCacheF32 = [];\nconst arrayCacheI32 = [];\n\n// Float32Array caches used for uploading Matrix uniforms\n\nconst mat4array = new Float32Array( 16 );\nconst mat3array = new Float32Array( 9 );\nconst mat2array = new Float32Array( 4 );\n\n// Flattening for arrays of vectors and matrices\n\nfunction flatten( array, nBlocks, blockSize ) {\n\n\tconst firstElem = array[ 0 ];\n\n\tif ( firstElem <= 0 || firstElem > 0 ) return array;\n\t// unoptimized: ! isNaN( firstElem )\n\t// see http://jacksondunstan.com/articles/983\n\n\tconst n = nBlocks * blockSize;\n\tlet r = arrayCacheF32[ n ];\n\n\tif ( r === undefined ) {\n\n\t\tr = new Float32Array( n );\n\t\tarrayCacheF32[ n ] = r;\n\n\t}\n\n\tif ( nBlocks !== 0 ) {\n\n\t\tfirstElem.toArray( r, 0 );\n\n\t\tfor ( let i = 1, offset = 0; i !== nBlocks; ++ i ) {\n\n\t\t\toffset += blockSize;\n\t\t\tarray[ i ].toArray( r, offset );\n\n\t\t}\n\n\t}\n\n\treturn r;\n\n}\n\nfunction arraysEqual( a, b ) {\n\n\tif ( a.length !== b.length ) return false;\n\n\tfor ( let i = 0, l = a.length; i < l; i ++ ) {\n\n\t\tif ( a[ i ] !== b[ i ] ) return false;\n\n\t}\n\n\treturn true;\n\n}\n\nfunction copyArray( a, b ) {\n\n\tfor ( let i = 0, l = b.length; i < l; i ++ ) {\n\n\t\ta[ i ] = b[ i ];\n\n\t}\n\n}\n\n// Texture unit allocation\n\nfunction allocTexUnits( textures, n ) {\n\n\tlet r = arrayCacheI32[ n ];\n\n\tif ( r === undefined ) {\n\n\t\tr = new Int32Array( n );\n\t\tarrayCacheI32[ n ] = r;\n\n\t}\n\n\tfor ( let i = 0; i !== n; ++ i ) {\n\n\t\tr[ i ] = textures.allocateTextureUnit();\n\n\t}\n\n\treturn r;\n\n}\n\n// --- Setters ---\n\n// Note: Defining these methods externally, because they come in a bunch\n// and this way their names minify.\n\n// Single scalar\n\nfunction setValueV1f( gl, v ) {\n\n\tconst cache = this.cache;\n\n\tif ( cache[ 0 ] === v ) return;\n\n\tgl.uniform1f( this.addr, v );\n\n\tcache[ 0 ] = v;\n\n}\n\n// Single float vector (from flat array or THREE.VectorN)\n\nfunction setValueV2f( gl, v ) {\n\n\tconst cache = this.cache;\n\n\tif ( v.x !== undefined ) {\n\n\t\tif ( cache[ 0 ] !== v.x || cache[ 1 ] !== v.y ) {\n\n\t\t\tgl.uniform2f( this.addr, v.x, v.y );\n\n\t\t\tcache[ 0 ] = v.x;\n\t\t\tcache[ 1 ] = v.y;\n\n\t\t}\n\n\t} else {\n\n\t\tif ( arraysEqual( cache, v ) ) return;\n\n\t\tgl.uniform2fv( this.addr, v );\n\n\t\tcopyArray( cache, v );\n\n\t}\n\n}\n\nfunction setValueV3f( gl, v ) {\n\n\tconst cache = this.cache;\n\n\tif ( v.x !== undefined ) {\n\n\t\tif ( cache[ 0 ] !== v.x || cache[ 1 ] !== v.y || cache[ 2 ] !== v.z ) {\n\n\t\t\tgl.uniform3f( this.addr, v.x, v.y, v.z );\n\n\t\t\tcache[ 0 ] = v.x;\n\t\t\tcache[ 1 ] = v.y;\n\t\t\tcache[ 2 ] = v.z;\n\n\t\t}\n\n\t} else if ( v.r !== undefined ) {\n\n\t\tif ( cache[ 0 ] !== v.r || cache[ 1 ] !== v.g || cache[ 2 ] !== v.b ) {\n\n\t\t\tgl.uniform3f( this.addr, v.r, v.g, v.b );\n\n\t\t\tcache[ 0 ] = v.r;\n\t\t\tcache[ 1 ] = v.g;\n\t\t\tcache[ 2 ] = v.b;\n\n\t\t}\n\n\t} else {\n\n\t\tif ( arraysEqual( cache, v ) ) return;\n\n\t\tgl.uniform3fv( this.addr, v );\n\n\t\tcopyArray( cache, v );\n\n\t}\n\n}\n\nfunction setValueV4f( gl, v ) {\n\n\tconst cache = this.cache;\n\n\tif ( v.x !== undefined ) {\n\n\t\tif ( cache[ 0 ] !== v.x || cache[ 1 ] !== v.y || cache[ 2 ] !== v.z || cache[ 3 ] !== v.w ) {\n\n\t\t\tgl.uniform4f( this.addr, v.x, v.y, v.z, v.w );\n\n\t\t\tcache[ 0 ] = v.x;\n\t\t\tcache[ 1 ] = v.y;\n\t\t\tcache[ 2 ] = v.z;\n\t\t\tcache[ 3 ] = v.w;\n\n\t\t}\n\n\t} else {\n\n\t\tif ( arraysEqual( cache, v ) ) return;\n\n\t\tgl.uniform4fv( this.addr, v );\n\n\t\tcopyArray( cache, v );\n\n\t}\n\n}\n\n// Single matrix (from flat array or THREE.MatrixN)\n\nfunction setValueM2( gl, v ) {\n\n\tconst cache = this.cache;\n\tconst elements = v.elements;\n\n\tif ( elements === undefined ) {\n\n\t\tif ( arraysEqual( cache, v ) ) return;\n\n\t\tgl.uniformMatrix2fv( this.addr, false, v );\n\n\t\tcopyArray( cache, v );\n\n\t} else {\n\n\t\tif ( arraysEqual( cache, elements ) ) return;\n\n\t\tmat2array.set( elements );\n\n\t\tgl.uniformMatrix2fv( this.addr, false, mat2array );\n\n\t\tcopyArray( cache, elements );\n\n\t}\n\n}\n\nfunction setValueM3( gl, v ) {\n\n\tconst cache = this.cache;\n\tconst elements = v.elements;\n\n\tif ( elements === undefined ) {\n\n\t\tif ( arraysEqual( cache, v ) ) return;\n\n\t\tgl.uniformMatrix3fv( this.addr, false, v );\n\n\t\tcopyArray( cache, v );\n\n\t} else {\n\n\t\tif ( arraysEqual( cache, elements ) ) return;\n\n\t\tmat3array.set( elements );\n\n\t\tgl.uniformMatrix3fv( this.addr, false, mat3array );\n\n\t\tcopyArray( cache, elements );\n\n\t}\n\n}\n\nfunction setValueM4( gl, v ) {\n\n\tconst cache = this.cache;\n\tconst elements = v.elements;\n\n\tif ( elements === undefined ) {\n\n\t\tif ( arraysEqual( cache, v ) ) return;\n\n\t\tgl.uniformMatrix4fv( this.addr, false, v );\n\n\t\tcopyArray( cache, v );\n\n\t} else {\n\n\t\tif ( arraysEqual( cache, elements ) ) return;\n\n\t\tmat4array.set( elements );\n\n\t\tgl.uniformMatrix4fv( this.addr, false, mat4array );\n\n\t\tcopyArray( cache, elements );\n\n\t}\n\n}\n\n// Single integer / boolean\n\nfunction setValueV1i( gl, v ) {\n\n\tconst cache = this.cache;\n\n\tif ( cache[ 0 ] === v ) return;\n\n\tgl.uniform1i( this.addr, v );\n\n\tcache[ 0 ] = v;\n\n}\n\n// Single integer / boolean vector (from flat array or THREE.VectorN)\n\nfunction setValueV2i( gl, v ) {\n\n\tconst cache = this.cache;\n\n\tif ( v.x !== undefined ) {\n\n\t\tif ( cache[ 0 ] !== v.x || cache[ 1 ] !== v.y ) {\n\n\t\t\tgl.uniform2i( this.addr, v.x, v.y );\n\n\t\t\tcache[ 0 ] = v.x;\n\t\t\tcache[ 1 ] = v.y;\n\n\t\t}\n\n\t} else {\n\n\t\tif ( arraysEqual( cache, v ) ) return;\n\n\t\tgl.uniform2iv( this.addr, v );\n\n\t\tcopyArray( cache, v );\n\n\t}\n\n}\n\nfunction setValueV3i( gl, v ) {\n\n\tconst cache = this.cache;\n\n\tif ( v.x !== undefined ) {\n\n\t\tif ( cache[ 0 ] !== v.x || cache[ 1 ] !== v.y || cache[ 2 ] !== v.z ) {\n\n\t\t\tgl.uniform3i( this.addr, v.x, v.y, v.z );\n\n\t\t\tcache[ 0 ] = v.x;\n\t\t\tcache[ 1 ] = v.y;\n\t\t\tcache[ 2 ] = v.z;\n\n\t\t}\n\n\t} else {\n\n\t\tif ( arraysEqual( cache, v ) ) return;\n\n\t\tgl.uniform3iv( this.addr, v );\n\n\t\tcopyArray( cache, v );\n\n\t}\n\n}\n\nfunction setValueV4i( gl, v ) {\n\n\tconst cache = this.cache;\n\n\tif ( v.x !== undefined ) {\n\n\t\tif ( cache[ 0 ] !== v.x || cache[ 1 ] !== v.y || cache[ 2 ] !== v.z || cache[ 3 ] !== v.w ) {\n\n\t\t\tgl.uniform4i( this.addr, v.x, v.y, v.z, v.w );\n\n\t\t\tcache[ 0 ] = v.x;\n\t\t\tcache[ 1 ] = v.y;\n\t\t\tcache[ 2 ] = v.z;\n\t\t\tcache[ 3 ] = v.w;\n\n\t\t}\n\n\t} else {\n\n\t\tif ( arraysEqual( cache, v ) ) return;\n\n\t\tgl.uniform4iv( this.addr, v );\n\n\t\tcopyArray( cache, v );\n\n\t}\n\n}\n\n// Single unsigned integer\n\nfunction setValueV1ui( gl, v ) {\n\n\tconst cache = this.cache;\n\n\tif ( cache[ 0 ] === v ) return;\n\n\tgl.uniform1ui( this.addr, v );\n\n\tcache[ 0 ] = v;\n\n}\n\n// Single unsigned integer vector (from flat array or THREE.VectorN)\n\nfunction setValueV2ui( gl, v ) {\n\n\tconst cache = this.cache;\n\n\tif ( v.x !== undefined ) {\n\n\t\tif ( cache[ 0 ] !== v.x || cache[ 1 ] !== v.y ) {\n\n\t\t\tgl.uniform2ui( this.addr, v.x, v.y );\n\n\t\t\tcache[ 0 ] = v.x;\n\t\t\tcache[ 1 ] = v.y;\n\n\t\t}\n\n\t} else {\n\n\t\tif ( arraysEqual( cache, v ) ) return;\n\n\t\tgl.uniform2uiv( this.addr, v );\n\n\t\tcopyArray( cache, v );\n\n\t}\n\n}\n\nfunction setValueV3ui( gl, v ) {\n\n\tconst cache = this.cache;\n\n\tif ( v.x !== undefined ) {\n\n\t\tif ( cache[ 0 ] !== v.x || cache[ 1 ] !== v.y || cache[ 2 ] !== v.z ) {\n\n\t\t\tgl.uniform3ui( this.addr, v.x, v.y, v.z );\n\n\t\t\tcache[ 0 ] = v.x;\n\t\t\tcache[ 1 ] = v.y;\n\t\t\tcache[ 2 ] = v.z;\n\n\t\t}\n\n\t} else {\n\n\t\tif ( arraysEqual( cache, v ) ) return;\n\n\t\tgl.uniform3uiv( this.addr, v );\n\n\t\tcopyArray( cache, v );\n\n\t}\n\n}\n\nfunction setValueV4ui( gl, v ) {\n\n\tconst cache = this.cache;\n\n\tif ( v.x !== undefined ) {\n\n\t\tif ( cache[ 0 ] !== v.x || cache[ 1 ] !== v.y || cache[ 2 ] !== v.z || cache[ 3 ] !== v.w ) {\n\n\t\t\tgl.uniform4ui( this.addr, v.x, v.y, v.z, v.w );\n\n\t\t\tcache[ 0 ] = v.x;\n\t\t\tcache[ 1 ] = v.y;\n\t\t\tcache[ 2 ] = v.z;\n\t\t\tcache[ 3 ] = v.w;\n\n\t\t}\n\n\t} else {\n\n\t\tif ( arraysEqual( cache, v ) ) return;\n\n\t\tgl.uniform4uiv( this.addr, v );\n\n\t\tcopyArray( cache, v );\n\n\t}\n\n}\n\n\n// Single texture (2D / Cube)\n\nfunction setValueT1( gl, v, textures ) {\n\n\tconst cache = this.cache;\n\tconst unit = textures.allocateTextureUnit();\n\n\tif ( cache[ 0 ] !== unit ) {\n\n\t\tgl.uniform1i( this.addr, unit );\n\t\tcache[ 0 ] = unit;\n\n\t}\n\n\tconst emptyTexture2D = ( this.type === gl.SAMPLER_2D_SHADOW ) ? emptyShadowTexture : emptyTexture;\n\n\ttextures.setTexture2D( v || emptyTexture2D, unit );\n\n}\n\nfunction setValueT3D1( gl, v, textures ) {\n\n\tconst cache = this.cache;\n\tconst unit = textures.allocateTextureUnit();\n\n\tif ( cache[ 0 ] !== unit ) {\n\n\t\tgl.uniform1i( this.addr, unit );\n\t\tcache[ 0 ] = unit;\n\n\t}\n\n\ttextures.setTexture3D( v || empty3dTexture, unit );\n\n}\n\nfunction setValueT6( gl, v, textures ) {\n\n\tconst cache = this.cache;\n\tconst unit = textures.allocateTextureUnit();\n\n\tif ( cache[ 0 ] !== unit ) {\n\n\t\tgl.uniform1i( this.addr, unit );\n\t\tcache[ 0 ] = unit;\n\n\t}\n\n\ttextures.setTextureCube( v || emptyCubeTexture, unit );\n\n}\n\nfunction setValueT2DArray1( gl, v, textures ) {\n\n\tconst cache = this.cache;\n\tconst unit = textures.allocateTextureUnit();\n\n\tif ( cache[ 0 ] !== unit ) {\n\n\t\tgl.uniform1i( this.addr, unit );\n\t\tcache[ 0 ] = unit;\n\n\t}\n\n\ttextures.setTexture2DArray( v || emptyArrayTexture, unit );\n\n}\n\n// Helper to pick the right setter for the singular case\n\nfunction getSingularSetter( type ) {\n\n\tswitch ( type ) {\n\n\t\tcase 0x1406: return setValueV1f; // FLOAT\n\t\tcase 0x8b50: return setValueV2f; // _VEC2\n\t\tcase 0x8b51: return setValueV3f; // _VEC3\n\t\tcase 0x8b52: return setValueV4f; // _VEC4\n\n\t\tcase 0x8b5a: return setValueM2; // _MAT2\n\t\tcase 0x8b5b: return setValueM3; // _MAT3\n\t\tcase 0x8b5c: return setValueM4; // _MAT4\n\n\t\tcase 0x1404: case 0x8b56: return setValueV1i; // INT, BOOL\n\t\tcase 0x8b53: case 0x8b57: return setValueV2i; // _VEC2\n\t\tcase 0x8b54: case 0x8b58: return setValueV3i; // _VEC3\n\t\tcase 0x8b55: case 0x8b59: return setValueV4i; // _VEC4\n\n\t\tcase 0x1405: return setValueV1ui; // UINT\n\t\tcase 0x8dc6: return setValueV2ui; // _VEC2\n\t\tcase 0x8dc7: return setValueV3ui; // _VEC3\n\t\tcase 0x8dc8: return setValueV4ui; // _VEC4\n\n\t\tcase 0x8b5e: // SAMPLER_2D\n\t\tcase 0x8d66: // SAMPLER_EXTERNAL_OES\n\t\tcase 0x8dca: // INT_SAMPLER_2D\n\t\tcase 0x8dd2: // UNSIGNED_INT_SAMPLER_2D\n\t\tcase 0x8b62: // SAMPLER_2D_SHADOW\n\t\t\treturn setValueT1;\n\n\t\tcase 0x8b5f: // SAMPLER_3D\n\t\tcase 0x8dcb: // INT_SAMPLER_3D\n\t\tcase 0x8dd3: // UNSIGNED_INT_SAMPLER_3D\n\t\t\treturn setValueT3D1;\n\n\t\tcase 0x8b60: // SAMPLER_CUBE\n\t\tcase 0x8dcc: // INT_SAMPLER_CUBE\n\t\tcase 0x8dd4: // UNSIGNED_INT_SAMPLER_CUBE\n\t\tcase 0x8dc5: // SAMPLER_CUBE_SHADOW\n\t\t\treturn setValueT6;\n\n\t\tcase 0x8dc1: // SAMPLER_2D_ARRAY\n\t\tcase 0x8dcf: // INT_SAMPLER_2D_ARRAY\n\t\tcase 0x8dd7: // UNSIGNED_INT_SAMPLER_2D_ARRAY\n\t\tcase 0x8dc4: // SAMPLER_2D_ARRAY_SHADOW\n\t\t\treturn setValueT2DArray1;\n\n\t}\n\n}\n\n\n// Array of scalars\n\nfunction setValueV1fArray( gl, v ) {\n\n\tgl.uniform1fv( this.addr, v );\n\n}\n\n// Array of vectors (from flat array or array of THREE.VectorN)\n\nfunction setValueV2fArray( gl, v ) {\n\n\tconst data = flatten( v, this.size, 2 );\n\n\tgl.uniform2fv( this.addr, data );\n\n}\n\nfunction setValueV3fArray( gl, v ) {\n\n\tconst data = flatten( v, this.size, 3 );\n\n\tgl.uniform3fv( this.addr, data );\n\n}\n\nfunction setValueV4fArray( gl, v ) {\n\n\tconst data = flatten( v, this.size, 4 );\n\n\tgl.uniform4fv( this.addr, data );\n\n}\n\n// Array of matrices (from flat array or array of THREE.MatrixN)\n\nfunction setValueM2Array( gl, v ) {\n\n\tconst data = flatten( v, this.size, 4 );\n\n\tgl.uniformMatrix2fv( this.addr, false, data );\n\n}\n\nfunction setValueM3Array( gl, v ) {\n\n\tconst data = flatten( v, this.size, 9 );\n\n\tgl.uniformMatrix3fv( this.addr, false, data );\n\n}\n\nfunction setValueM4Array( gl, v ) {\n\n\tconst data = flatten( v, this.size, 16 );\n\n\tgl.uniformMatrix4fv( this.addr, false, data );\n\n}\n\n// Array of integer / boolean\n\nfunction setValueV1iArray( gl, v ) {\n\n\tgl.uniform1iv( this.addr, v );\n\n}\n\n// Array of integer / boolean vectors (from flat array)\n\nfunction setValueV2iArray( gl, v ) {\n\n\tgl.uniform2iv( this.addr, v );\n\n}\n\nfunction setValueV3iArray( gl, v ) {\n\n\tgl.uniform3iv( this.addr, v );\n\n}\n\nfunction setValueV4iArray( gl, v ) {\n\n\tgl.uniform4iv( this.addr, v );\n\n}\n\n// Array of unsigned integer\n\nfunction setValueV1uiArray( gl, v ) {\n\n\tgl.uniform1uiv( this.addr, v );\n\n}\n\n// Array of unsigned integer vectors (from flat array)\n\nfunction setValueV2uiArray( gl, v ) {\n\n\tgl.uniform2uiv( this.addr, v );\n\n}\n\nfunction setValueV3uiArray( gl, v ) {\n\n\tgl.uniform3uiv( this.addr, v );\n\n}\n\nfunction setValueV4uiArray( gl, v ) {\n\n\tgl.uniform4uiv( this.addr, v );\n\n}\n\n\n// Array of textures (2D / 3D / Cube / 2DArray)\n\nfunction setValueT1Array( gl, v, textures ) {\n\n\tconst cache = this.cache;\n\n\tconst n = v.length;\n\n\tconst units = allocTexUnits( textures, n );\n\n\tif ( ! arraysEqual( cache, units ) ) {\n\n\t\tgl.uniform1iv( this.addr, units );\n\n\t\tcopyArray( cache, units );\n\n\t}\n\n\tfor ( let i = 0; i !== n; ++ i ) {\n\n\t\ttextures.setTexture2D( v[ i ] || emptyTexture, units[ i ] );\n\n\t}\n\n}\n\nfunction setValueT3DArray( gl, v, textures ) {\n\n\tconst cache = this.cache;\n\n\tconst n = v.length;\n\n\tconst units = allocTexUnits( textures, n );\n\n\tif ( ! arraysEqual( cache, units ) ) {\n\n\t\tgl.uniform1iv( this.addr, units );\n\n\t\tcopyArray( cache, units );\n\n\t}\n\n\tfor ( let i = 0; i !== n; ++ i ) {\n\n\t\ttextures.setTexture3D( v[ i ] || empty3dTexture, units[ i ] );\n\n\t}\n\n}\n\nfunction setValueT6Array( gl, v, textures ) {\n\n\tconst cache = this.cache;\n\n\tconst n = v.length;\n\n\tconst units = allocTexUnits( textures, n );\n\n\tif ( ! arraysEqual( cache, units ) ) {\n\n\t\tgl.uniform1iv( this.addr, units );\n\n\t\tcopyArray( cache, units );\n\n\t}\n\n\tfor ( let i = 0; i !== n; ++ i ) {\n\n\t\ttextures.setTextureCube( v[ i ] || emptyCubeTexture, units[ i ] );\n\n\t}\n\n}\n\nfunction setValueT2DArrayArray( gl, v, textures ) {\n\n\tconst cache = this.cache;\n\n\tconst n = v.length;\n\n\tconst units = allocTexUnits( textures, n );\n\n\tif ( ! arraysEqual( cache, units ) ) {\n\n\t\tgl.uniform1iv( this.addr, units );\n\n\t\tcopyArray( cache, units );\n\n\t}\n\n\tfor ( let i = 0; i !== n; ++ i ) {\n\n\t\ttextures.setTexture2DArray( v[ i ] || emptyArrayTexture, units[ i ] );\n\n\t}\n\n}\n\n\n// Helper to pick the right setter for a pure (bottom-level) array\n\nfunction getPureArraySetter( type ) {\n\n\tswitch ( type ) {\n\n\t\tcase 0x1406: return setValueV1fArray; // FLOAT\n\t\tcase 0x8b50: return setValueV2fArray; // _VEC2\n\t\tcase 0x8b51: return setValueV3fArray; // _VEC3\n\t\tcase 0x8b52: return setValueV4fArray; // _VEC4\n\n\t\tcase 0x8b5a: return setValueM2Array; // _MAT2\n\t\tcase 0x8b5b: return setValueM3Array; // _MAT3\n\t\tcase 0x8b5c: return setValueM4Array; // _MAT4\n\n\t\tcase 0x1404: case 0x8b56: return setValueV1iArray; // INT, BOOL\n\t\tcase 0x8b53: case 0x8b57: return setValueV2iArray; // _VEC2\n\t\tcase 0x8b54: case 0x8b58: return setValueV3iArray; // _VEC3\n\t\tcase 0x8b55: case 0x8b59: return setValueV4iArray; // _VEC4\n\n\t\tcase 0x1405: return setValueV1uiArray; // UINT\n\t\tcase 0x8dc6: return setValueV2uiArray; // _VEC2\n\t\tcase 0x8dc7: return setValueV3uiArray; // _VEC3\n\t\tcase 0x8dc8: return setValueV4uiArray; // _VEC4\n\n\t\tcase 0x8b5e: // SAMPLER_2D\n\t\tcase 0x8d66: // SAMPLER_EXTERNAL_OES\n\t\tcase 0x8dca: // INT_SAMPLER_2D\n\t\tcase 0x8dd2: // UNSIGNED_INT_SAMPLER_2D\n\t\tcase 0x8b62: // SAMPLER_2D_SHADOW\n\t\t\treturn setValueT1Array;\n\n\t\tcase 0x8b5f: // SAMPLER_3D\n\t\tcase 0x8dcb: // INT_SAMPLER_3D\n\t\tcase 0x8dd3: // UNSIGNED_INT_SAMPLER_3D\n\t\t\treturn setValueT3DArray;\n\n\t\tcase 0x8b60: // SAMPLER_CUBE\n\t\tcase 0x8dcc: // INT_SAMPLER_CUBE\n\t\tcase 0x8dd4: // UNSIGNED_INT_SAMPLER_CUBE\n\t\tcase 0x8dc5: // SAMPLER_CUBE_SHADOW\n\t\t\treturn setValueT6Array;\n\n\t\tcase 0x8dc1: // SAMPLER_2D_ARRAY\n\t\tcase 0x8dcf: // INT_SAMPLER_2D_ARRAY\n\t\tcase 0x8dd7: // UNSIGNED_INT_SAMPLER_2D_ARRAY\n\t\tcase 0x8dc4: // SAMPLER_2D_ARRAY_SHADOW\n\t\t\treturn setValueT2DArrayArray;\n\n\t}\n\n}\n\n// --- Uniform Classes ---\n\nclass SingleUniform {\n\n\tconstructor( id, activeInfo, addr ) {\n\n\t\tthis.id = id;\n\t\tthis.addr = addr;\n\t\tthis.cache = [];\n\t\tthis.type = activeInfo.type;\n\t\tthis.setValue = getSingularSetter( activeInfo.type );\n\n\t\t// this.path = activeInfo.name; // DEBUG\n\n\t}\n\n}\n\nclass PureArrayUniform {\n\n\tconstructor( id, activeInfo, addr ) {\n\n\t\tthis.id = id;\n\t\tthis.addr = addr;\n\t\tthis.cache = [];\n\t\tthis.type = activeInfo.type;\n\t\tthis.size = activeInfo.size;\n\t\tthis.setValue = getPureArraySetter( activeInfo.type );\n\n\t\t// this.path = activeInfo.name; // DEBUG\n\n\t}\n\n}\n\nclass StructuredUniform {\n\n\tconstructor( id ) {\n\n\t\tthis.id = id;\n\n\t\tthis.seq = [];\n\t\tthis.map = {};\n\n\t}\n\n\tsetValue( gl, value, textures ) {\n\n\t\tconst seq = this.seq;\n\n\t\tfor ( let i = 0, n = seq.length; i !== n; ++ i ) {\n\n\t\t\tconst u = seq[ i ];\n\t\t\tu.setValue( gl, value[ u.id ], textures );\n\n\t\t}\n\n\t}\n\n}\n\n// --- Top-level ---\n\n// Parser - builds up the property tree from the path strings\n\nconst RePathPart = /(\\w+)(\\])?(\\[|\\.)?/g;\n\n// extracts\n// \t- the identifier (member name or array index)\n// - followed by an optional right bracket (found when array index)\n// - followed by an optional left bracket or dot (type of subscript)\n//\n// Note: These portions can be read in a non-overlapping fashion and\n// allow straightforward parsing of the hierarchy that WebGL encodes\n// in the uniform names.\n\nfunction addUniform( container, uniformObject ) {\n\n\tcontainer.seq.push( uniformObject );\n\tcontainer.map[ uniformObject.id ] = uniformObject;\n\n}\n\nfunction parseUniform( activeInfo, addr, container ) {\n\n\tconst path = activeInfo.name,\n\t\tpathLength = path.length;\n\n\t// reset RegExp object, because of the early exit of a previous run\n\tRePathPart.lastIndex = 0;\n\n\twhile ( true ) {\n\n\t\tconst match = RePathPart.exec( path ),\n\t\t\tmatchEnd = RePathPart.lastIndex;\n\n\t\tlet id = match[ 1 ];\n\t\tconst idIsIndex = match[ 2 ] === ']',\n\t\t\tsubscript = match[ 3 ];\n\n\t\tif ( idIsIndex ) id = id | 0; // convert to integer\n\n\t\tif ( subscript === undefined || subscript === '[' && matchEnd + 2 === pathLength ) {\n\n\t\t\t// bare name or \"pure\" bottom-level array \"[0]\" suffix\n\n\t\t\taddUniform( container, subscript === undefined ?\n\t\t\t\tnew SingleUniform( id, activeInfo, addr ) :\n\t\t\t\tnew PureArrayUniform( id, activeInfo, addr ) );\n\n\t\t\tbreak;\n\n\t\t} else {\n\n\t\t\t// step into inner node / create it in case it doesn't exist\n\n\t\t\tconst map = container.map;\n\t\t\tlet next = map[ id ];\n\n\t\t\tif ( next === undefined ) {\n\n\t\t\t\tnext = new StructuredUniform( id );\n\t\t\t\taddUniform( container, next );\n\n\t\t\t}\n\n\t\t\tcontainer = next;\n\n\t\t}\n\n\t}\n\n}\n\n// Root Container\n\nclass WebGLUniforms {\n\n\tconstructor( gl, program ) {\n\n\t\tthis.seq = [];\n\t\tthis.map = {};\n\n\t\tconst n = gl.getProgramParameter( program, gl.ACTIVE_UNIFORMS );\n\n\t\tfor ( let i = 0; i < n; ++ i ) {\n\n\t\t\tconst info = gl.getActiveUniform( program, i ),\n\t\t\t\taddr = gl.getUniformLocation( program, info.name );\n\n\t\t\tparseUniform( info, addr, this );\n\n\t\t}\n\n\t}\n\n\tsetValue( gl, name, value, textures ) {\n\n\t\tconst u = this.map[ name ];\n\n\t\tif ( u !== undefined ) u.setValue( gl, value, textures );\n\n\t}\n\n\tsetOptional( gl, object, name ) {\n\n\t\tconst v = object[ name ];\n\n\t\tif ( v !== undefined ) this.setValue( gl, name, v );\n\n\t}\n\n\tstatic upload( gl, seq, values, textures ) {\n\n\t\tfor ( let i = 0, n = seq.length; i !== n; ++ i ) {\n\n\t\t\tconst u = seq[ i ],\n\t\t\t\tv = values[ u.id ];\n\n\t\t\tif ( v.needsUpdate !== false ) {\n\n\t\t\t\t// note: always updating when .needsUpdate is undefined\n\t\t\t\tu.setValue( gl, v.value, textures );\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n\tstatic seqWithValue( seq, values ) {\n\n\t\tconst r = [];\n\n\t\tfor ( let i = 0, n = seq.length; i !== n; ++ i ) {\n\n\t\t\tconst u = seq[ i ];\n\t\t\tif ( u.id in values ) r.push( u );\n\n\t\t}\n\n\t\treturn r;\n\n\t}\n\n}\n\nfunction WebGLShader( gl, type, string ) {\n\n\tconst shader = gl.createShader( type );\n\n\tgl.shaderSource( shader, string );\n\tgl.compileShader( shader );\n\n\treturn shader;\n\n}\n\n// From https://www.khronos.org/registry/webgl/extensions/KHR_parallel_shader_compile/\nconst COMPLETION_STATUS_KHR = 0x91B1;\n\nlet programIdCount = 0;\n\nfunction handleSource( string, errorLine ) {\n\n\tconst lines = string.split( '\\n' );\n\tconst lines2 = [];\n\n\tconst from = Math.max( errorLine - 6, 0 );\n\tconst to = Math.min( errorLine + 6, lines.length );\n\n\tfor ( let i = from; i < to; i ++ ) {\n\n\t\tconst line = i + 1;\n\t\tlines2.push( `${line === errorLine ? '>' : ' '} ${line}: ${lines[ i ]}` );\n\n\t}\n\n\treturn lines2.join( '\\n' );\n\n}\n\nfunction getEncodingComponents( colorSpace ) {\n\n\tconst workingPrimaries = ColorManagement.getPrimaries( ColorManagement.workingColorSpace );\n\tconst encodingPrimaries = ColorManagement.getPrimaries( colorSpace );\n\n\tlet gamutMapping;\n\n\tif ( workingPrimaries === encodingPrimaries ) {\n\n\t\tgamutMapping = '';\n\n\t} else if ( workingPrimaries === P3Primaries && encodingPrimaries === Rec709Primaries ) {\n\n\t\tgamutMapping = 'LinearDisplayP3ToLinearSRGB';\n\n\t} else if ( workingPrimaries === Rec709Primaries && encodingPrimaries === P3Primaries ) {\n\n\t\tgamutMapping = 'LinearSRGBToLinearDisplayP3';\n\n\t}\n\n\tswitch ( colorSpace ) {\n\n\t\tcase LinearSRGBColorSpace:\n\t\tcase LinearDisplayP3ColorSpace:\n\t\t\treturn [ gamutMapping, 'LinearTransferOETF' ];\n\n\t\tcase SRGBColorSpace:\n\t\tcase DisplayP3ColorSpace:\n\t\t\treturn [ gamutMapping, 'sRGBTransferOETF' ];\n\n\t\tdefault:\n\t\t\tconsole.warn( 'THREE.WebGLProgram: Unsupported color space:', colorSpace );\n\t\t\treturn [ gamutMapping, 'LinearTransferOETF' ];\n\n\t}\n\n}\n\nfunction getShaderErrors( gl, shader, type ) {\n\n\tconst status = gl.getShaderParameter( shader, gl.COMPILE_STATUS );\n\tconst errors = gl.getShaderInfoLog( shader ).trim();\n\n\tif ( status && errors === '' ) return '';\n\n\tconst errorMatches = /ERROR: 0:(\\d+)/.exec( errors );\n\tif ( errorMatches ) {\n\n\t\t// --enable-privileged-webgl-extension\n\t\t// console.log( '**' + type + '**', gl.getExtension( 'WEBGL_debug_shaders' ).getTranslatedShaderSource( shader ) );\n\n\t\tconst errorLine = parseInt( errorMatches[ 1 ] );\n\t\treturn type.toUpperCase() + '\\n\\n' + errors + '\\n\\n' + handleSource( gl.getShaderSource( shader ), errorLine );\n\n\t} else {\n\n\t\treturn errors;\n\n\t}\n\n}\n\nfunction getTexelEncodingFunction( functionName, colorSpace ) {\n\n\tconst components = getEncodingComponents( colorSpace );\n\treturn `vec4 ${functionName}( vec4 value ) { return ${components[ 0 ]}( ${components[ 1 ]}( value ) ); }`;\n\n}\n\nfunction getToneMappingFunction( functionName, toneMapping ) {\n\n\tlet toneMappingName;\n\n\tswitch ( toneMapping ) {\n\n\t\tcase LinearToneMapping:\n\t\t\ttoneMappingName = 'Linear';\n\t\t\tbreak;\n\n\t\tcase ReinhardToneMapping:\n\t\t\ttoneMappingName = 'Reinhard';\n\t\t\tbreak;\n\n\t\tcase CineonToneMapping:\n\t\t\ttoneMappingName = 'OptimizedCineon';\n\t\t\tbreak;\n\n\t\tcase ACESFilmicToneMapping:\n\t\t\ttoneMappingName = 'ACESFilmic';\n\t\t\tbreak;\n\n\t\tcase AgXToneMapping:\n\t\t\ttoneMappingName = 'AgX';\n\t\t\tbreak;\n\n\t\tcase NeutralToneMapping:\n\t\t\ttoneMappingName = 'Neutral';\n\t\t\tbreak;\n\n\t\tcase CustomToneMapping:\n\t\t\ttoneMappingName = 'Custom';\n\t\t\tbreak;\n\n\t\tdefault:\n\t\t\tconsole.warn( 'THREE.WebGLProgram: Unsupported toneMapping:', toneMapping );\n\t\t\ttoneMappingName = 'Linear';\n\n\t}\n\n\treturn 'vec3 ' + functionName + '( vec3 color ) { return ' + toneMappingName + 'ToneMapping( color ); }';\n\n}\n\nfunction generateVertexExtensions( parameters ) {\n\n\tconst chunks = [\n\t\tparameters.extensionClipCullDistance ? '#extension GL_ANGLE_clip_cull_distance : require' : '',\n\t\tparameters.extensionMultiDraw ? '#extension GL_ANGLE_multi_draw : require' : '',\n\t];\n\n\treturn chunks.filter( filterEmptyLine ).join( '\\n' );\n\n}\n\nfunction generateDefines( defines ) {\n\n\tconst chunks = [];\n\n\tfor ( const name in defines ) {\n\n\t\tconst value = defines[ name ];\n\n\t\tif ( value === false ) continue;\n\n\t\tchunks.push( '#define ' + name + ' ' + value );\n\n\t}\n\n\treturn chunks.join( '\\n' );\n\n}\n\nfunction fetchAttributeLocations( gl, program ) {\n\n\tconst attributes = {};\n\n\tconst n = gl.getProgramParameter( program, gl.ACTIVE_ATTRIBUTES );\n\n\tfor ( let i = 0; i < n; i ++ ) {\n\n\t\tconst info = gl.getActiveAttrib( program, i );\n\t\tconst name = info.name;\n\n\t\tlet locationSize = 1;\n\t\tif ( info.type === gl.FLOAT_MAT2 ) locationSize = 2;\n\t\tif ( info.type === gl.FLOAT_MAT3 ) locationSize = 3;\n\t\tif ( info.type === gl.FLOAT_MAT4 ) locationSize = 4;\n\n\t\t// console.log( 'THREE.WebGLProgram: ACTIVE VERTEX ATTRIBUTE:', name, i );\n\n\t\tattributes[ name ] = {\n\t\t\ttype: info.type,\n\t\t\tlocation: gl.getAttribLocation( program, name ),\n\t\t\tlocationSize: locationSize\n\t\t};\n\n\t}\n\n\treturn attributes;\n\n}\n\nfunction filterEmptyLine( string ) {\n\n\treturn string !== '';\n\n}\n\nfunction replaceLightNums( string, parameters ) {\n\n\tconst numSpotLightCoords = parameters.numSpotLightShadows + parameters.numSpotLightMaps - parameters.numSpotLightShadowsWithMaps;\n\n\treturn string\n\t\t.replace( /NUM_DIR_LIGHTS/g, parameters.numDirLights )\n\t\t.replace( /NUM_SPOT_LIGHTS/g, parameters.numSpotLights )\n\t\t.replace( /NUM_SPOT_LIGHT_MAPS/g, parameters.numSpotLightMaps )\n\t\t.replace( /NUM_SPOT_LIGHT_COORDS/g, numSpotLightCoords )\n\t\t.replace( /NUM_RECT_AREA_LIGHTS/g, parameters.numRectAreaLights )\n\t\t.replace( /NUM_POINT_LIGHTS/g, parameters.numPointLights )\n\t\t.replace( /NUM_HEMI_LIGHTS/g, parameters.numHemiLights )\n\t\t.replace( /NUM_DIR_LIGHT_SHADOWS/g, parameters.numDirLightShadows )\n\t\t.replace( /NUM_SPOT_LIGHT_SHADOWS_WITH_MAPS/g, parameters.numSpotLightShadowsWithMaps )\n\t\t.replace( /NUM_SPOT_LIGHT_SHADOWS/g, parameters.numSpotLightShadows )\n\t\t.replace( /NUM_POINT_LIGHT_SHADOWS/g, parameters.numPointLightShadows );\n\n}\n\nfunction replaceClippingPlaneNums( string, parameters ) {\n\n\treturn string\n\t\t.replace( /NUM_CLIPPING_PLANES/g, parameters.numClippingPlanes )\n\t\t.replace( /UNION_CLIPPING_PLANES/g, ( parameters.numClippingPlanes - parameters.numClipIntersection ) );\n\n}\n\n// Resolve Includes\n\nconst includePattern = /^[ \\t]*#include +<([\\w\\d./]+)>/gm;\n\nfunction resolveIncludes( string ) {\n\n\treturn string.replace( includePattern, includeReplacer );\n\n}\n\nconst shaderChunkMap = new Map( [\n\t[ 'encodings_fragment', 'colorspace_fragment' ], // @deprecated, r154\n\t[ 'encodings_pars_fragment', 'colorspace_pars_fragment' ], // @deprecated, r154\n\t[ 'output_fragment', 'opaque_fragment' ], // @deprecated, r154\n] );\n\nfunction includeReplacer( match, include ) {\n\n\tlet string = ShaderChunk[ include ];\n\n\tif ( string === undefined ) {\n\n\t\tconst newInclude = shaderChunkMap.get( include );\n\n\t\tif ( newInclude !== undefined ) {\n\n\t\t\tstring = ShaderChunk[ newInclude ];\n\t\t\tconsole.warn( 'THREE.WebGLRenderer: Shader chunk \"%s\" has been deprecated. Use \"%s\" instead.', include, newInclude );\n\n\t\t} else {\n\n\t\t\tthrow new Error( 'Can not resolve #include <' + include + '>' );\n\n\t\t}\n\n\t}\n\n\treturn resolveIncludes( string );\n\n}\n\n// Unroll Loops\n\nconst unrollLoopPattern = /#pragma unroll_loop_start\\s+for\\s*\\(\\s*int\\s+i\\s*=\\s*(\\d+)\\s*;\\s*i\\s*<\\s*(\\d+)\\s*;\\s*i\\s*\\+\\+\\s*\\)\\s*{([\\s\\S]+?)}\\s+#pragma unroll_loop_end/g;\n\nfunction unrollLoops( string ) {\n\n\treturn string.replace( unrollLoopPattern, loopReplacer );\n\n}\n\nfunction loopReplacer( match, start, end, snippet ) {\n\n\tlet string = '';\n\n\tfor ( let i = parseInt( start ); i < parseInt( end ); i ++ ) {\n\n\t\tstring += snippet\n\t\t\t.replace( /\\[\\s*i\\s*\\]/g, '[ ' + i + ' ]' )\n\t\t\t.replace( /UNROLLED_LOOP_INDEX/g, i );\n\n\t}\n\n\treturn string;\n\n}\n\n//\n\nfunction generatePrecision( parameters ) {\n\n\tlet precisionstring = `precision ${parameters.precision} float;\n\tprecision ${parameters.precision} int;\n\tprecision ${parameters.precision} sampler2D;\n\tprecision ${parameters.precision} samplerCube;\n\tprecision ${parameters.precision} sampler3D;\n\tprecision ${parameters.precision} sampler2DArray;\n\tprecision ${parameters.precision} sampler2DShadow;\n\tprecision ${parameters.precision} samplerCubeShadow;\n\tprecision ${parameters.precision} sampler2DArrayShadow;\n\tprecision ${parameters.precision} isampler2D;\n\tprecision ${parameters.precision} isampler3D;\n\tprecision ${parameters.precision} isamplerCube;\n\tprecision ${parameters.precision} isampler2DArray;\n\tprecision ${parameters.precision} usampler2D;\n\tprecision ${parameters.precision} usampler3D;\n\tprecision ${parameters.precision} usamplerCube;\n\tprecision ${parameters.precision} usampler2DArray;\n\t`;\n\n\tif ( parameters.precision === 'highp' ) {\n\n\t\tprecisionstring += '\\n#define HIGH_PRECISION';\n\n\t} else if ( parameters.precision === 'mediump' ) {\n\n\t\tprecisionstring += '\\n#define MEDIUM_PRECISION';\n\n\t} else if ( parameters.precision === 'lowp' ) {\n\n\t\tprecisionstring += '\\n#define LOW_PRECISION';\n\n\t}\n\n\treturn precisionstring;\n\n}\n\nfunction generateShadowMapTypeDefine( parameters ) {\n\n\tlet shadowMapTypeDefine = 'SHADOWMAP_TYPE_BASIC';\n\n\tif ( parameters.shadowMapType === PCFShadowMap ) {\n\n\t\tshadowMapTypeDefine = 'SHADOWMAP_TYPE_PCF';\n\n\t} else if ( parameters.shadowMapType === PCFSoftShadowMap ) {\n\n\t\tshadowMapTypeDefine = 'SHADOWMAP_TYPE_PCF_SOFT';\n\n\t} else if ( parameters.shadowMapType === VSMShadowMap ) {\n\n\t\tshadowMapTypeDefine = 'SHADOWMAP_TYPE_VSM';\n\n\t}\n\n\treturn shadowMapTypeDefine;\n\n}\n\nfunction generateEnvMapTypeDefine( parameters ) {\n\n\tlet envMapTypeDefine = 'ENVMAP_TYPE_CUBE';\n\n\tif ( parameters.envMap ) {\n\n\t\tswitch ( parameters.envMapMode ) {\n\n\t\t\tcase CubeReflectionMapping:\n\t\t\tcase CubeRefractionMapping:\n\t\t\t\tenvMapTypeDefine = 'ENVMAP_TYPE_CUBE';\n\t\t\t\tbreak;\n\n\t\t\tcase CubeUVReflectionMapping:\n\t\t\t\tenvMapTypeDefine = 'ENVMAP_TYPE_CUBE_UV';\n\t\t\t\tbreak;\n\n\t\t}\n\n\t}\n\n\treturn envMapTypeDefine;\n\n}\n\nfunction generateEnvMapModeDefine( parameters ) {\n\n\tlet envMapModeDefine = 'ENVMAP_MODE_REFLECTION';\n\n\tif ( parameters.envMap ) {\n\n\t\tswitch ( parameters.envMapMode ) {\n\n\t\t\tcase CubeRefractionMapping:\n\n\t\t\t\tenvMapModeDefine = 'ENVMAP_MODE_REFRACTION';\n\t\t\t\tbreak;\n\n\t\t}\n\n\t}\n\n\treturn envMapModeDefine;\n\n}\n\nfunction generateEnvMapBlendingDefine( parameters ) {\n\n\tlet envMapBlendingDefine = 'ENVMAP_BLENDING_NONE';\n\n\tif ( parameters.envMap ) {\n\n\t\tswitch ( parameters.combine ) {\n\n\t\t\tcase MultiplyOperation:\n\t\t\t\tenvMapBlendingDefine = 'ENVMAP_BLENDING_MULTIPLY';\n\t\t\t\tbreak;\n\n\t\t\tcase MixOperation:\n\t\t\t\tenvMapBlendingDefine = 'ENVMAP_BLENDING_MIX';\n\t\t\t\tbreak;\n\n\t\t\tcase AddOperation:\n\t\t\t\tenvMapBlendingDefine = 'ENVMAP_BLENDING_ADD';\n\t\t\t\tbreak;\n\n\t\t}\n\n\t}\n\n\treturn envMapBlendingDefine;\n\n}\n\nfunction generateCubeUVSize( parameters ) {\n\n\tconst imageHeight = parameters.envMapCubeUVHeight;\n\n\tif ( imageHeight === null ) return null;\n\n\tconst maxMip = Math.log2( imageHeight ) - 2;\n\n\tconst texelHeight = 1.0 / imageHeight;\n\n\tconst texelWidth = 1.0 / ( 3 * Math.max( Math.pow( 2, maxMip ), 7 * 16 ) );\n\n\treturn { texelWidth, texelHeight, maxMip };\n\n}\n\nfunction WebGLProgram( renderer, cacheKey, parameters, bindingStates ) {\n\n\t// TODO Send this event to Three.js DevTools\n\t// console.log( 'WebGLProgram', cacheKey );\n\n\tconst gl = renderer.getContext();\n\n\tconst defines = parameters.defines;\n\n\tlet vertexShader = parameters.vertexShader;\n\tlet fragmentShader = parameters.fragmentShader;\n\n\tconst shadowMapTypeDefine = generateShadowMapTypeDefine( parameters );\n\tconst envMapTypeDefine = generateEnvMapTypeDefine( parameters );\n\tconst envMapModeDefine = generateEnvMapModeDefine( parameters );\n\tconst envMapBlendingDefine = generateEnvMapBlendingDefine( parameters );\n\tconst envMapCubeUVSize = generateCubeUVSize( parameters );\n\n\tconst customVertexExtensions = generateVertexExtensions( parameters );\n\n\tconst customDefines = generateDefines( defines );\n\n\tconst program = gl.createProgram();\n\n\tlet prefixVertex, prefixFragment;\n\tlet versionString = parameters.glslVersion ? '#version ' + parameters.glslVersion + '\\n' : '';\n\n\tif ( parameters.isRawShaderMaterial ) {\n\n\t\tprefixVertex = [\n\n\t\t\t'#define SHADER_TYPE ' + parameters.shaderType,\n\t\t\t'#define SHADER_NAME ' + parameters.shaderName,\n\n\t\t\tcustomDefines\n\n\t\t].filter( filterEmptyLine ).join( '\\n' );\n\n\t\tif ( prefixVertex.length > 0 ) {\n\n\t\t\tprefixVertex += '\\n';\n\n\t\t}\n\n\t\tprefixFragment = [\n\n\t\t\t'#define SHADER_TYPE ' + parameters.shaderType,\n\t\t\t'#define SHADER_NAME ' + parameters.shaderName,\n\n\t\t\tcustomDefines\n\n\t\t].filter( filterEmptyLine ).join( '\\n' );\n\n\t\tif ( prefixFragment.length > 0 ) {\n\n\t\t\tprefixFragment += '\\n';\n\n\t\t}\n\n\t} else {\n\n\t\tprefixVertex = [\n\n\t\t\tgeneratePrecision( parameters ),\n\n\t\t\t'#define SHADER_TYPE ' + parameters.shaderType,\n\t\t\t'#define SHADER_NAME ' + parameters.shaderName,\n\n\t\t\tcustomDefines,\n\n\t\t\tparameters.extensionClipCullDistance ? '#define USE_CLIP_DISTANCE' : '',\n\t\t\tparameters.batching ? '#define USE_BATCHING' : '',\n\t\t\tparameters.instancing ? '#define USE_INSTANCING' : '',\n\t\t\tparameters.instancingColor ? '#define USE_INSTANCING_COLOR' : '',\n\t\t\tparameters.instancingMorph ? '#define USE_INSTANCING_MORPH' : '',\n\n\t\t\tparameters.useFog && parameters.fog ? '#define USE_FOG' : '',\n\t\t\tparameters.useFog && parameters.fogExp2 ? '#define FOG_EXP2' : '',\n\n\t\t\tparameters.map ? '#define USE_MAP' : '',\n\t\t\tparameters.envMap ? '#define USE_ENVMAP' : '',\n\t\t\tparameters.envMap ? '#define ' + envMapModeDefine : '',\n\t\t\tparameters.lightMap ? '#define USE_LIGHTMAP' : '',\n\t\t\tparameters.aoMap ? '#define USE_AOMAP' : '',\n\t\t\tparameters.bumpMap ? '#define USE_BUMPMAP' : '',\n\t\t\tparameters.normalMap ? '#define USE_NORMALMAP' : '',\n\t\t\tparameters.normalMapObjectSpace ? '#define USE_NORMALMAP_OBJECTSPACE' : '',\n\t\t\tparameters.normalMapTangentSpace ? '#define USE_NORMALMAP_TANGENTSPACE' : '',\n\t\t\tparameters.displacementMap ? '#define USE_DISPLACEMENTMAP' : '',\n\t\t\tparameters.emissiveMap ? '#define USE_EMISSIVEMAP' : '',\n\n\t\t\tparameters.anisotropy ? '#define USE_ANISOTROPY' : '',\n\t\t\tparameters.anisotropyMap ? '#define USE_ANISOTROPYMAP' : '',\n\n\t\t\tparameters.clearcoatMap ? '#define USE_CLEARCOATMAP' : '',\n\t\t\tparameters.clearcoatRoughnessMap ? '#define USE_CLEARCOAT_ROUGHNESSMAP' : '',\n\t\t\tparameters.clearcoatNormalMap ? '#define USE_CLEARCOAT_NORMALMAP' : '',\n\n\t\t\tparameters.iridescenceMap ? '#define USE_IRIDESCENCEMAP' : '',\n\t\t\tparameters.iridescenceThicknessMap ? '#define USE_IRIDESCENCE_THICKNESSMAP' : '',\n\n\t\t\tparameters.specularMap ? '#define USE_SPECULARMAP' : '',\n\t\t\tparameters.specularColorMap ? '#define USE_SPECULAR_COLORMAP' : '',\n\t\t\tparameters.specularIntensityMap ? '#define USE_SPECULAR_INTENSITYMAP' : '',\n\n\t\t\tparameters.roughnessMap ? '#define USE_ROUGHNESSMAP' : '',\n\t\t\tparameters.metalnessMap ? '#define USE_METALNESSMAP' : '',\n\t\t\tparameters.alphaMap ? '#define USE_ALPHAMAP' : '',\n\t\t\tparameters.alphaHash ? '#define USE_ALPHAHASH' : '',\n\n\t\t\tparameters.transmission ? '#define USE_TRANSMISSION' : '',\n\t\t\tparameters.transmissionMap ? '#define USE_TRANSMISSIONMAP' : '',\n\t\t\tparameters.thicknessMap ? '#define USE_THICKNESSMAP' : '',\n\n\t\t\tparameters.sheenColorMap ? '#define USE_SHEEN_COLORMAP' : '',\n\t\t\tparameters.sheenRoughnessMap ? '#define USE_SHEEN_ROUGHNESSMAP' : '',\n\n\t\t\t//\n\n\t\t\tparameters.mapUv ? '#define MAP_UV ' + parameters.mapUv : '',\n\t\t\tparameters.alphaMapUv ? '#define ALPHAMAP_UV ' + parameters.alphaMapUv : '',\n\t\t\tparameters.lightMapUv ? '#define LIGHTMAP_UV ' + parameters.lightMapUv : '',\n\t\t\tparameters.aoMapUv ? '#define AOMAP_UV ' + parameters.aoMapUv : '',\n\t\t\tparameters.emissiveMapUv ? '#define EMISSIVEMAP_UV ' + parameters.emissiveMapUv : '',\n\t\t\tparameters.bumpMapUv ? '#define BUMPMAP_UV ' + parameters.bumpMapUv : '',\n\t\t\tparameters.normalMapUv ? '#define NORMALMAP_UV ' + parameters.normalMapUv : '',\n\t\t\tparameters.displacementMapUv ? '#define DISPLACEMENTMAP_UV ' + parameters.displacementMapUv : '',\n\n\t\t\tparameters.metalnessMapUv ? '#define METALNESSMAP_UV ' + parameters.metalnessMapUv : '',\n\t\t\tparameters.roughnessMapUv ? '#define ROUGHNESSMAP_UV ' + parameters.roughnessMapUv : '',\n\n\t\t\tparameters.anisotropyMapUv ? '#define ANISOTROPYMAP_UV ' + parameters.anisotropyMapUv : '',\n\n\t\t\tparameters.clearcoatMapUv ? '#define CLEARCOATMAP_UV ' + parameters.clearcoatMapUv : '',\n\t\t\tparameters.clearcoatNormalMapUv ? '#define CLEARCOAT_NORMALMAP_UV ' + parameters.clearcoatNormalMapUv : '',\n\t\t\tparameters.clearcoatRoughnessMapUv ? '#define CLEARCOAT_ROUGHNESSMAP_UV ' + parameters.clearcoatRoughnessMapUv : '',\n\n\t\t\tparameters.iridescenceMapUv ? '#define IRIDESCENCEMAP_UV ' + parameters.iridescenceMapUv : '',\n\t\t\tparameters.iridescenceThicknessMapUv ? '#define IRIDESCENCE_THICKNESSMAP_UV ' + parameters.iridescenceThicknessMapUv : '',\n\n\t\t\tparameters.sheenColorMapUv ? '#define SHEEN_COLORMAP_UV ' + parameters.sheenColorMapUv : '',\n\t\t\tparameters.sheenRoughnessMapUv ? '#define SHEEN_ROUGHNESSMAP_UV ' + parameters.sheenRoughnessMapUv : '',\n\n\t\t\tparameters.specularMapUv ? '#define SPECULARMAP_UV ' + parameters.specularMapUv : '',\n\t\t\tparameters.specularColorMapUv ? '#define SPECULAR_COLORMAP_UV ' + parameters.specularColorMapUv : '',\n\t\t\tparameters.specularIntensityMapUv ? '#define SPECULAR_INTENSITYMAP_UV ' + parameters.specularIntensityMapUv : '',\n\n\t\t\tparameters.transmissionMapUv ? '#define TRANSMISSIONMAP_UV ' + parameters.transmissionMapUv : '',\n\t\t\tparameters.thicknessMapUv ? '#define THICKNESSMAP_UV ' + parameters.thicknessMapUv : '',\n\n\t\t\t//\n\n\t\t\tparameters.vertexTangents && parameters.flatShading === false ? '#define USE_TANGENT' : '',\n\t\t\tparameters.vertexColors ? '#define USE_COLOR' : '',\n\t\t\tparameters.vertexAlphas ? '#define USE_COLOR_ALPHA' : '',\n\t\t\tparameters.vertexUv1s ? '#define USE_UV1' : '',\n\t\t\tparameters.vertexUv2s ? '#define USE_UV2' : '',\n\t\t\tparameters.vertexUv3s ? '#define USE_UV3' : '',\n\n\t\t\tparameters.pointsUvs ? '#define USE_POINTS_UV' : '',\n\n\t\t\tparameters.flatShading ? '#define FLAT_SHADED' : '',\n\n\t\t\tparameters.skinning ? '#define USE_SKINNING' : '',\n\n\t\t\tparameters.morphTargets ? '#define USE_MORPHTARGETS' : '',\n\t\t\tparameters.morphNormals && parameters.flatShading === false ? '#define USE_MORPHNORMALS' : '',\n\t\t\t( parameters.morphColors ) ? '#define USE_MORPHCOLORS' : '',\n\t\t\t( parameters.morphTargetsCount > 0 ) ? '#define MORPHTARGETS_TEXTURE' : '',\n\t\t\t( parameters.morphTargetsCount > 0 ) ? '#define MORPHTARGETS_TEXTURE_STRIDE ' + parameters.morphTextureStride : '',\n\t\t\t( parameters.morphTargetsCount > 0 ) ? '#define MORPHTARGETS_COUNT ' + parameters.morphTargetsCount : '',\n\t\t\tparameters.doubleSided ? '#define DOUBLE_SIDED' : '',\n\t\t\tparameters.flipSided ? '#define FLIP_SIDED' : '',\n\n\t\t\tparameters.shadowMapEnabled ? '#define USE_SHADOWMAP' : '',\n\t\t\tparameters.shadowMapEnabled ? '#define ' + shadowMapTypeDefine : '',\n\n\t\t\tparameters.sizeAttenuation ? '#define USE_SIZEATTENUATION' : '',\n\n\t\t\tparameters.numLightProbes > 0 ? '#define USE_LIGHT_PROBES' : '',\n\n\t\t\tparameters.useLegacyLights ? '#define LEGACY_LIGHTS' : '',\n\n\t\t\tparameters.logarithmicDepthBuffer ? '#define USE_LOGDEPTHBUF' : '',\n\n\t\t\t'uniform mat4 modelMatrix;',\n\t\t\t'uniform mat4 modelViewMatrix;',\n\t\t\t'uniform mat4 projectionMatrix;',\n\t\t\t'uniform mat4 viewMatrix;',\n\t\t\t'uniform mat3 normalMatrix;',\n\t\t\t'uniform vec3 cameraPosition;',\n\t\t\t'uniform bool isOrthographic;',\n\n\t\t\t'#ifdef USE_INSTANCING',\n\n\t\t\t'\tattribute mat4 instanceMatrix;',\n\n\t\t\t'#endif',\n\n\t\t\t'#ifdef USE_INSTANCING_COLOR',\n\n\t\t\t'\tattribute vec3 instanceColor;',\n\n\t\t\t'#endif',\n\n\t\t\t'#ifdef USE_INSTANCING_MORPH',\n\n\t\t\t'\tuniform sampler2D morphTexture;',\n\n\t\t\t'#endif',\n\n\t\t\t'attribute vec3 position;',\n\t\t\t'attribute vec3 normal;',\n\t\t\t'attribute vec2 uv;',\n\n\t\t\t'#ifdef USE_UV1',\n\n\t\t\t'\tattribute vec2 uv1;',\n\n\t\t\t'#endif',\n\n\t\t\t'#ifdef USE_UV2',\n\n\t\t\t'\tattribute vec2 uv2;',\n\n\t\t\t'#endif',\n\n\t\t\t'#ifdef USE_UV3',\n\n\t\t\t'\tattribute vec2 uv3;',\n\n\t\t\t'#endif',\n\n\t\t\t'#ifdef USE_TANGENT',\n\n\t\t\t'\tattribute vec4 tangent;',\n\n\t\t\t'#endif',\n\n\t\t\t'#if defined( USE_COLOR_ALPHA )',\n\n\t\t\t'\tattribute vec4 color;',\n\n\t\t\t'#elif defined( USE_COLOR )',\n\n\t\t\t'\tattribute vec3 color;',\n\n\t\t\t'#endif',\n\n\t\t\t'#if ( defined( USE_MORPHTARGETS ) && ! defined( MORPHTARGETS_TEXTURE ) )',\n\n\t\t\t'\tattribute vec3 morphTarget0;',\n\t\t\t'\tattribute vec3 morphTarget1;',\n\t\t\t'\tattribute vec3 morphTarget2;',\n\t\t\t'\tattribute vec3 morphTarget3;',\n\n\t\t\t'\t#ifdef USE_MORPHNORMALS',\n\n\t\t\t'\t\tattribute vec3 morphNormal0;',\n\t\t\t'\t\tattribute vec3 morphNormal1;',\n\t\t\t'\t\tattribute vec3 morphNormal2;',\n\t\t\t'\t\tattribute vec3 morphNormal3;',\n\n\t\t\t'\t#else',\n\n\t\t\t'\t\tattribute vec3 morphTarget4;',\n\t\t\t'\t\tattribute vec3 morphTarget5;',\n\t\t\t'\t\tattribute vec3 morphTarget6;',\n\t\t\t'\t\tattribute vec3 morphTarget7;',\n\n\t\t\t'\t#endif',\n\n\t\t\t'#endif',\n\n\t\t\t'#ifdef USE_SKINNING',\n\n\t\t\t'\tattribute vec4 skinIndex;',\n\t\t\t'\tattribute vec4 skinWeight;',\n\n\t\t\t'#endif',\n\n\t\t\t'\\n'\n\n\t\t].filter( filterEmptyLine ).join( '\\n' );\n\n\t\tprefixFragment = [\n\n\t\t\tgeneratePrecision( parameters ),\n\n\t\t\t'#define SHADER_TYPE ' + parameters.shaderType,\n\t\t\t'#define SHADER_NAME ' + parameters.shaderName,\n\n\t\t\tcustomDefines,\n\n\t\t\tparameters.useFog && parameters.fog ? '#define USE_FOG' : '',\n\t\t\tparameters.useFog && parameters.fogExp2 ? '#define FOG_EXP2' : '',\n\n\t\t\tparameters.alphaToCoverage ? '#define ALPHA_TO_COVERAGE' : '',\n\t\t\tparameters.map ? '#define USE_MAP' : '',\n\t\t\tparameters.matcap ? '#define USE_MATCAP' : '',\n\t\t\tparameters.envMap ? '#define USE_ENVMAP' : '',\n\t\t\tparameters.envMap ? '#define ' + envMapTypeDefine : '',\n\t\t\tparameters.envMap ? '#define ' + envMapModeDefine : '',\n\t\t\tparameters.envMap ? '#define ' + envMapBlendingDefine : '',\n\t\t\tenvMapCubeUVSize ? '#define CUBEUV_TEXEL_WIDTH ' + envMapCubeUVSize.texelWidth : '',\n\t\t\tenvMapCubeUVSize ? '#define CUBEUV_TEXEL_HEIGHT ' + envMapCubeUVSize.texelHeight : '',\n\t\t\tenvMapCubeUVSize ? '#define CUBEUV_MAX_MIP ' + envMapCubeUVSize.maxMip + '.0' : '',\n\t\t\tparameters.lightMap ? '#define USE_LIGHTMAP' : '',\n\t\t\tparameters.aoMap ? '#define USE_AOMAP' : '',\n\t\t\tparameters.bumpMap ? '#define USE_BUMPMAP' : '',\n\t\t\tparameters.normalMap ? '#define USE_NORMALMAP' : '',\n\t\t\tparameters.normalMapObjectSpace ? '#define USE_NORMALMAP_OBJECTSPACE' : '',\n\t\t\tparameters.normalMapTangentSpace ? '#define USE_NORMALMAP_TANGENTSPACE' : '',\n\t\t\tparameters.emissiveMap ? '#define USE_EMISSIVEMAP' : '',\n\n\t\t\tparameters.anisotropy ? '#define USE_ANISOTROPY' : '',\n\t\t\tparameters.anisotropyMap ? '#define USE_ANISOTROPYMAP' : '',\n\n\t\t\tparameters.clearcoat ? '#define USE_CLEARCOAT' : '',\n\t\t\tparameters.clearcoatMap ? '#define USE_CLEARCOATMAP' : '',\n\t\t\tparameters.clearcoatRoughnessMap ? '#define USE_CLEARCOAT_ROUGHNESSMAP' : '',\n\t\t\tparameters.clearcoatNormalMap ? '#define USE_CLEARCOAT_NORMALMAP' : '',\n\n\t\t\tparameters.iridescence ? '#define USE_IRIDESCENCE' : '',\n\t\t\tparameters.iridescenceMap ? '#define USE_IRIDESCENCEMAP' : '',\n\t\t\tparameters.iridescenceThicknessMap ? '#define USE_IRIDESCENCE_THICKNESSMAP' : '',\n\n\t\t\tparameters.specularMap ? '#define USE_SPECULARMAP' : '',\n\t\t\tparameters.specularColorMap ? '#define USE_SPECULAR_COLORMAP' : '',\n\t\t\tparameters.specularIntensityMap ? '#define USE_SPECULAR_INTENSITYMAP' : '',\n\n\t\t\tparameters.roughnessMap ? '#define USE_ROUGHNESSMAP' : '',\n\t\t\tparameters.metalnessMap ? '#define USE_METALNESSMAP' : '',\n\n\t\t\tparameters.alphaMap ? '#define USE_ALPHAMAP' : '',\n\t\t\tparameters.alphaTest ? '#define USE_ALPHATEST' : '',\n\t\t\tparameters.alphaHash ? '#define USE_ALPHAHASH' : '',\n\n\t\t\tparameters.sheen ? '#define USE_SHEEN' : '',\n\t\t\tparameters.sheenColorMap ? '#define USE_SHEEN_COLORMAP' : '',\n\t\t\tparameters.sheenRoughnessMap ? '#define USE_SHEEN_ROUGHNESSMAP' : '',\n\n\t\t\tparameters.transmission ? '#define USE_TRANSMISSION' : '',\n\t\t\tparameters.transmissionMap ? '#define USE_TRANSMISSIONMAP' : '',\n\t\t\tparameters.thicknessMap ? '#define USE_THICKNESSMAP' : '',\n\n\t\t\tparameters.vertexTangents && parameters.flatShading === false ? '#define USE_TANGENT' : '',\n\t\t\tparameters.vertexColors || parameters.instancingColor ? '#define USE_COLOR' : '',\n\t\t\tparameters.vertexAlphas ? '#define USE_COLOR_ALPHA' : '',\n\t\t\tparameters.vertexUv1s ? '#define USE_UV1' : '',\n\t\t\tparameters.vertexUv2s ? '#define USE_UV2' : '',\n\t\t\tparameters.vertexUv3s ? '#define USE_UV3' : '',\n\n\t\t\tparameters.pointsUvs ? '#define USE_POINTS_UV' : '',\n\n\t\t\tparameters.gradientMap ? '#define USE_GRADIENTMAP' : '',\n\n\t\t\tparameters.flatShading ? '#define FLAT_SHADED' : '',\n\n\t\t\tparameters.doubleSided ? '#define DOUBLE_SIDED' : '',\n\t\t\tparameters.flipSided ? '#define FLIP_SIDED' : '',\n\n\t\t\tparameters.shadowMapEnabled ? '#define USE_SHADOWMAP' : '',\n\t\t\tparameters.shadowMapEnabled ? '#define ' + shadowMapTypeDefine : '',\n\n\t\t\tparameters.premultipliedAlpha ? '#define PREMULTIPLIED_ALPHA' : '',\n\n\t\t\tparameters.numLightProbes > 0 ? '#define USE_LIGHT_PROBES' : '',\n\n\t\t\tparameters.useLegacyLights ? '#define LEGACY_LIGHTS' : '',\n\n\t\t\tparameters.decodeVideoTexture ? '#define DECODE_VIDEO_TEXTURE' : '',\n\n\t\t\tparameters.logarithmicDepthBuffer ? '#define USE_LOGDEPTHBUF' : '',\n\n\t\t\t'uniform mat4 viewMatrix;',\n\t\t\t'uniform vec3 cameraPosition;',\n\t\t\t'uniform bool isOrthographic;',\n\n\t\t\t( parameters.toneMapping !== NoToneMapping ) ? '#define TONE_MAPPING' : '',\n\t\t\t( parameters.toneMapping !== NoToneMapping ) ? ShaderChunk[ 'tonemapping_pars_fragment' ] : '', // this code is required here because it is used by the toneMapping() function defined below\n\t\t\t( parameters.toneMapping !== NoToneMapping ) ? getToneMappingFunction( 'toneMapping', parameters.toneMapping ) : '',\n\n\t\t\tparameters.dithering ? '#define DITHERING' : '',\n\t\t\tparameters.opaque ? '#define OPAQUE' : '',\n\n\t\t\tShaderChunk[ 'colorspace_pars_fragment' ], // this code is required here because it is used by the various encoding/decoding function defined below\n\t\t\tgetTexelEncodingFunction( 'linearToOutputTexel', parameters.outputColorSpace ),\n\n\t\t\tparameters.useDepthPacking ? '#define DEPTH_PACKING ' + parameters.depthPacking : '',\n\n\t\t\t'\\n'\n\n\t\t].filter( filterEmptyLine ).join( '\\n' );\n\n\t}\n\n\tvertexShader = resolveIncludes( vertexShader );\n\tvertexShader = replaceLightNums( vertexShader, parameters );\n\tvertexShader = replaceClippingPlaneNums( vertexShader, parameters );\n\n\tfragmentShader = resolveIncludes( fragmentShader );\n\tfragmentShader = replaceLightNums( fragmentShader, parameters );\n\tfragmentShader = replaceClippingPlaneNums( fragmentShader, parameters );\n\n\tvertexShader = unrollLoops( vertexShader );\n\tfragmentShader = unrollLoops( fragmentShader );\n\n\tif ( parameters.isRawShaderMaterial !== true ) {\n\n\t\t// GLSL 3.0 conversion for built-in materials and ShaderMaterial\n\n\t\tversionString = '#version 300 es\\n';\n\n\t\tprefixVertex = [\n\t\t\tcustomVertexExtensions,\n\t\t\t'#define attribute in',\n\t\t\t'#define varying out',\n\t\t\t'#define texture2D texture'\n\t\t].join( '\\n' ) + '\\n' + prefixVertex;\n\n\t\tprefixFragment = [\n\t\t\t'#define varying in',\n\t\t\t( parameters.glslVersion === GLSL3 ) ? '' : 'layout(location = 0) out highp vec4 pc_fragColor;',\n\t\t\t( parameters.glslVersion === GLSL3 ) ? '' : '#define gl_FragColor pc_fragColor',\n\t\t\t'#define gl_FragDepthEXT gl_FragDepth',\n\t\t\t'#define texture2D texture',\n\t\t\t'#define textureCube texture',\n\t\t\t'#define texture2DProj textureProj',\n\t\t\t'#define texture2DLodEXT textureLod',\n\t\t\t'#define texture2DProjLodEXT textureProjLod',\n\t\t\t'#define textureCubeLodEXT textureLod',\n\t\t\t'#define texture2DGradEXT textureGrad',\n\t\t\t'#define texture2DProjGradEXT textureProjGrad',\n\t\t\t'#define textureCubeGradEXT textureGrad'\n\t\t].join( '\\n' ) + '\\n' + prefixFragment;\n\n\t}\n\n\tconst vertexGlsl = versionString + prefixVertex + vertexShader;\n\tconst fragmentGlsl = versionString + prefixFragment + fragmentShader;\n\n\t// console.log( '*VERTEX*', vertexGlsl );\n\t// console.log( '*FRAGMENT*', fragmentGlsl );\n\n\tconst glVertexShader = WebGLShader( gl, gl.VERTEX_SHADER, vertexGlsl );\n\tconst glFragmentShader = WebGLShader( gl, gl.FRAGMENT_SHADER, fragmentGlsl );\n\n\tgl.attachShader( program, glVertexShader );\n\tgl.attachShader( program, glFragmentShader );\n\n\t// Force a particular attribute to index 0.\n\n\tif ( parameters.index0AttributeName !== undefined ) {\n\n\t\tgl.bindAttribLocation( program, 0, parameters.index0AttributeName );\n\n\t} else if ( parameters.morphTargets === true ) {\n\n\t\t// programs with morphTargets displace position out of attribute 0\n\t\tgl.bindAttribLocation( program, 0, 'position' );\n\n\t}\n\n\tgl.linkProgram( program );\n\n\tfunction onFirstUse( self ) {\n\n\t\t// check for link errors\n\t\tif ( renderer.debug.checkShaderErrors ) {\n\n\t\t\tconst programLog = gl.getProgramInfoLog( program ).trim();\n\t\t\tconst vertexLog = gl.getShaderInfoLog( glVertexShader ).trim();\n\t\t\tconst fragmentLog = gl.getShaderInfoLog( glFragmentShader ).trim();\n\n\t\t\tlet runnable = true;\n\t\t\tlet haveDiagnostics = true;\n\n\t\t\tif ( gl.getProgramParameter( program, gl.LINK_STATUS ) === false ) {\n\n\t\t\t\trunnable = false;\n\n\t\t\t\tif ( typeof renderer.debug.onShaderError === 'function' ) {\n\n\t\t\t\t\trenderer.debug.onShaderError( gl, program, glVertexShader, glFragmentShader );\n\n\t\t\t\t} else {\n\n\t\t\t\t\t// default error reporting\n\n\t\t\t\t\tconst vertexErrors = getShaderErrors( gl, glVertexShader, 'vertex' );\n\t\t\t\t\tconst fragmentErrors = getShaderErrors( gl, glFragmentShader, 'fragment' );\n\n\t\t\t\t\tconsole.error(\n\t\t\t\t\t\t'THREE.WebGLProgram: Shader Error ' + gl.getError() + ' - ' +\n\t\t\t\t\t\t'VALIDATE_STATUS ' + gl.getProgramParameter( program, gl.VALIDATE_STATUS ) + '\\n\\n' +\n\t\t\t\t\t\t'Material Name: ' + self.name + '\\n' +\n\t\t\t\t\t\t'Material Type: ' + self.type + '\\n\\n' +\n\t\t\t\t\t\t'Program Info Log: ' + programLog + '\\n' +\n\t\t\t\t\t\tvertexErrors + '\\n' +\n\t\t\t\t\t\tfragmentErrors\n\t\t\t\t\t);\n\n\t\t\t\t}\n\n\t\t\t} else if ( programLog !== '' ) {\n\n\t\t\t\tconsole.warn( 'THREE.WebGLProgram: Program Info Log:', programLog );\n\n\t\t\t} else if ( vertexLog === '' || fragmentLog === '' ) {\n\n\t\t\t\thaveDiagnostics = false;\n\n\t\t\t}\n\n\t\t\tif ( haveDiagnostics ) {\n\n\t\t\t\tself.diagnostics = {\n\n\t\t\t\t\trunnable: runnable,\n\n\t\t\t\t\tprogramLog: programLog,\n\n\t\t\t\t\tvertexShader: {\n\n\t\t\t\t\t\tlog: vertexLog,\n\t\t\t\t\t\tprefix: prefixVertex\n\n\t\t\t\t\t},\n\n\t\t\t\t\tfragmentShader: {\n\n\t\t\t\t\t\tlog: fragmentLog,\n\t\t\t\t\t\tprefix: prefixFragment\n\n\t\t\t\t\t}\n\n\t\t\t\t};\n\n\t\t\t}\n\n\t\t}\n\n\t\t// Clean up\n\n\t\t// Crashes in iOS9 and iOS10. #18402\n\t\t// gl.detachShader( program, glVertexShader );\n\t\t// gl.detachShader( program, glFragmentShader );\n\n\t\tgl.deleteShader( glVertexShader );\n\t\tgl.deleteShader( glFragmentShader );\n\n\t\tcachedUniforms = new WebGLUniforms( gl, program );\n\t\tcachedAttributes = fetchAttributeLocations( gl, program );\n\n\t}\n\n\t// set up caching for uniform locations\n\n\tlet cachedUniforms;\n\n\tthis.getUniforms = function () {\n\n\t\tif ( cachedUniforms === undefined ) {\n\n\t\t\t// Populates cachedUniforms and cachedAttributes\n\t\t\tonFirstUse( this );\n\n\t\t}\n\n\t\treturn cachedUniforms;\n\n\t};\n\n\t// set up caching for attribute locations\n\n\tlet cachedAttributes;\n\n\tthis.getAttributes = function () {\n\n\t\tif ( cachedAttributes === undefined ) {\n\n\t\t\t// Populates cachedAttributes and cachedUniforms\n\t\t\tonFirstUse( this );\n\n\t\t}\n\n\t\treturn cachedAttributes;\n\n\t};\n\n\t// indicate when the program is ready to be used. if the KHR_parallel_shader_compile extension isn't supported,\n\t// flag the program as ready immediately. It may cause a stall when it's first used.\n\n\tlet programReady = ( parameters.rendererExtensionParallelShaderCompile === false );\n\n\tthis.isReady = function () {\n\n\t\tif ( programReady === false ) {\n\n\t\t\tprogramReady = gl.getProgramParameter( program, COMPLETION_STATUS_KHR );\n\n\t\t}\n\n\t\treturn programReady;\n\n\t};\n\n\t// free resource\n\n\tthis.destroy = function () {\n\n\t\tbindingStates.releaseStatesOfProgram( this );\n\n\t\tgl.deleteProgram( program );\n\t\tthis.program = undefined;\n\n\t};\n\n\t//\n\n\tthis.type = parameters.shaderType;\n\tthis.name = parameters.shaderName;\n\tthis.id = programIdCount ++;\n\tthis.cacheKey = cacheKey;\n\tthis.usedTimes = 1;\n\tthis.program = program;\n\tthis.vertexShader = glVertexShader;\n\tthis.fragmentShader = glFragmentShader;\n\n\treturn this;\n\n}\n\nlet _id$1 = 0;\n\nclass WebGLShaderCache {\n\n\tconstructor() {\n\n\t\tthis.shaderCache = new Map();\n\t\tthis.materialCache = new Map();\n\n\t}\n\n\tupdate( material ) {\n\n\t\tconst vertexShader = material.vertexShader;\n\t\tconst fragmentShader = material.fragmentShader;\n\n\t\tconst vertexShaderStage = this._getShaderStage( vertexShader );\n\t\tconst fragmentShaderStage = this._getShaderStage( fragmentShader );\n\n\t\tconst materialShaders = this._getShaderCacheForMaterial( material );\n\n\t\tif ( materialShaders.has( vertexShaderStage ) === false ) {\n\n\t\t\tmaterialShaders.add( vertexShaderStage );\n\t\t\tvertexShaderStage.usedTimes ++;\n\n\t\t}\n\n\t\tif ( materialShaders.has( fragmentShaderStage ) === false ) {\n\n\t\t\tmaterialShaders.add( fragmentShaderStage );\n\t\t\tfragmentShaderStage.usedTimes ++;\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tremove( material ) {\n\n\t\tconst materialShaders = this.materialCache.get( material );\n\n\t\tfor ( const shaderStage of materialShaders ) {\n\n\t\t\tshaderStage.usedTimes --;\n\n\t\t\tif ( shaderStage.usedTimes === 0 ) this.shaderCache.delete( shaderStage.code );\n\n\t\t}\n\n\t\tthis.materialCache.delete( material );\n\n\t\treturn this;\n\n\t}\n\n\tgetVertexShaderID( material ) {\n\n\t\treturn this._getShaderStage( material.vertexShader ).id;\n\n\t}\n\n\tgetFragmentShaderID( material ) {\n\n\t\treturn this._getShaderStage( material.fragmentShader ).id;\n\n\t}\n\n\tdispose() {\n\n\t\tthis.shaderCache.clear();\n\t\tthis.materialCache.clear();\n\n\t}\n\n\t_getShaderCacheForMaterial( material ) {\n\n\t\tconst cache = this.materialCache;\n\t\tlet set = cache.get( material );\n\n\t\tif ( set === undefined ) {\n\n\t\t\tset = new Set();\n\t\t\tcache.set( material, set );\n\n\t\t}\n\n\t\treturn set;\n\n\t}\n\n\t_getShaderStage( code ) {\n\n\t\tconst cache = this.shaderCache;\n\t\tlet stage = cache.get( code );\n\n\t\tif ( stage === undefined ) {\n\n\t\t\tstage = new WebGLShaderStage( code );\n\t\t\tcache.set( code, stage );\n\n\t\t}\n\n\t\treturn stage;\n\n\t}\n\n}\n\nclass WebGLShaderStage {\n\n\tconstructor( code ) {\n\n\t\tthis.id = _id$1 ++;\n\n\t\tthis.code = code;\n\t\tthis.usedTimes = 0;\n\n\t}\n\n}\n\nfunction WebGLPrograms( renderer, cubemaps, cubeuvmaps, extensions, capabilities, bindingStates, clipping ) {\n\n\tconst _programLayers = new Layers();\n\tconst _customShaders = new WebGLShaderCache();\n\tconst _activeChannels = new Set();\n\tconst programs = [];\n\n\tconst logarithmicDepthBuffer = capabilities.logarithmicDepthBuffer;\n\tconst SUPPORTS_VERTEX_TEXTURES = capabilities.vertexTextures;\n\n\tlet precision = capabilities.precision;\n\n\tconst shaderIDs = {\n\t\tMeshDepthMaterial: 'depth',\n\t\tMeshDistanceMaterial: 'distanceRGBA',\n\t\tMeshNormalMaterial: 'normal',\n\t\tMeshBasicMaterial: 'basic',\n\t\tMeshLambertMaterial: 'lambert',\n\t\tMeshPhongMaterial: 'phong',\n\t\tMeshToonMaterial: 'toon',\n\t\tMeshStandardMaterial: 'physical',\n\t\tMeshPhysicalMaterial: 'physical',\n\t\tMeshMatcapMaterial: 'matcap',\n\t\tLineBasicMaterial: 'basic',\n\t\tLineDashedMaterial: 'dashed',\n\t\tPointsMaterial: 'points',\n\t\tShadowMaterial: 'shadow',\n\t\tSpriteMaterial: 'sprite'\n\t};\n\n\tfunction getChannel( value ) {\n\n\t\t_activeChannels.add( value );\n\n\t\tif ( value === 0 ) return 'uv';\n\n\t\treturn `uv${ value }`;\n\n\t}\n\n\tfunction getParameters( material, lights, shadows, scene, object ) {\n\n\t\tconst fog = scene.fog;\n\t\tconst geometry = object.geometry;\n\t\tconst environment = material.isMeshStandardMaterial ? scene.environment : null;\n\n\t\tconst envMap = ( material.isMeshStandardMaterial ? cubeuvmaps : cubemaps ).get( material.envMap || environment );\n\t\tconst envMapCubeUVHeight = ( !! envMap ) && ( envMap.mapping === CubeUVReflectionMapping ) ? envMap.image.height : null;\n\n\t\tconst shaderID = shaderIDs[ material.type ];\n\n\t\t// heuristics to create shader parameters according to lights in the scene\n\t\t// (not to blow over maxLights budget)\n\n\t\tif ( material.precision !== null ) {\n\n\t\t\tprecision = capabilities.getMaxPrecision( material.precision );\n\n\t\t\tif ( precision !== material.precision ) {\n\n\t\t\t\tconsole.warn( 'THREE.WebGLProgram.getParameters:', material.precision, 'not supported, using', precision, 'instead.' );\n\n\t\t\t}\n\n\t\t}\n\n\t\t//\n\n\t\tconst morphAttribute = geometry.morphAttributes.position || geometry.morphAttributes.normal || geometry.morphAttributes.color;\n\t\tconst morphTargetsCount = ( morphAttribute !== undefined ) ? morphAttribute.length : 0;\n\n\t\tlet morphTextureStride = 0;\n\n\t\tif ( geometry.morphAttributes.position !== undefined ) morphTextureStride = 1;\n\t\tif ( geometry.morphAttributes.normal !== undefined ) morphTextureStride = 2;\n\t\tif ( geometry.morphAttributes.color !== undefined ) morphTextureStride = 3;\n\n\t\t//\n\n\t\tlet vertexShader, fragmentShader;\n\t\tlet customVertexShaderID, customFragmentShaderID;\n\n\t\tif ( shaderID ) {\n\n\t\t\tconst shader = ShaderLib[ shaderID ];\n\n\t\t\tvertexShader = shader.vertexShader;\n\t\t\tfragmentShader = shader.fragmentShader;\n\n\t\t} else {\n\n\t\t\tvertexShader = material.vertexShader;\n\t\t\tfragmentShader = material.fragmentShader;\n\n\t\t\t_customShaders.update( material );\n\n\t\t\tcustomVertexShaderID = _customShaders.getVertexShaderID( material );\n\t\t\tcustomFragmentShaderID = _customShaders.getFragmentShaderID( material );\n\n\t\t}\n\n\t\tconst currentRenderTarget = renderer.getRenderTarget();\n\n\t\tconst IS_INSTANCEDMESH = object.isInstancedMesh === true;\n\t\tconst IS_BATCHEDMESH = object.isBatchedMesh === true;\n\n\t\tconst HAS_MAP = !! material.map;\n\t\tconst HAS_MATCAP = !! material.matcap;\n\t\tconst HAS_ENVMAP = !! envMap;\n\t\tconst HAS_AOMAP = !! material.aoMap;\n\t\tconst HAS_LIGHTMAP = !! material.lightMap;\n\t\tconst HAS_BUMPMAP = !! material.bumpMap;\n\t\tconst HAS_NORMALMAP = !! material.normalMap;\n\t\tconst HAS_DISPLACEMENTMAP = !! material.displacementMap;\n\t\tconst HAS_EMISSIVEMAP = !! material.emissiveMap;\n\n\t\tconst HAS_METALNESSMAP = !! material.metalnessMap;\n\t\tconst HAS_ROUGHNESSMAP = !! material.roughnessMap;\n\n\t\tconst HAS_ANISOTROPY = material.anisotropy > 0;\n\t\tconst HAS_CLEARCOAT = material.clearcoat > 0;\n\t\tconst HAS_IRIDESCENCE = material.iridescence > 0;\n\t\tconst HAS_SHEEN = material.sheen > 0;\n\t\tconst HAS_TRANSMISSION = material.transmission > 0;\n\n\t\tconst HAS_ANISOTROPYMAP = HAS_ANISOTROPY && !! material.anisotropyMap;\n\n\t\tconst HAS_CLEARCOATMAP = HAS_CLEARCOAT && !! material.clearcoatMap;\n\t\tconst HAS_CLEARCOAT_NORMALMAP = HAS_CLEARCOAT && !! material.clearcoatNormalMap;\n\t\tconst HAS_CLEARCOAT_ROUGHNESSMAP = HAS_CLEARCOAT && !! material.clearcoatRoughnessMap;\n\n\t\tconst HAS_IRIDESCENCEMAP = HAS_IRIDESCENCE && !! material.iridescenceMap;\n\t\tconst HAS_IRIDESCENCE_THICKNESSMAP = HAS_IRIDESCENCE && !! material.iridescenceThicknessMap;\n\n\t\tconst HAS_SHEEN_COLORMAP = HAS_SHEEN && !! material.sheenColorMap;\n\t\tconst HAS_SHEEN_ROUGHNESSMAP = HAS_SHEEN && !! material.sheenRoughnessMap;\n\n\t\tconst HAS_SPECULARMAP = !! material.specularMap;\n\t\tconst HAS_SPECULAR_COLORMAP = !! material.specularColorMap;\n\t\tconst HAS_SPECULAR_INTENSITYMAP = !! material.specularIntensityMap;\n\n\t\tconst HAS_TRANSMISSIONMAP = HAS_TRANSMISSION && !! material.transmissionMap;\n\t\tconst HAS_THICKNESSMAP = HAS_TRANSMISSION && !! material.thicknessMap;\n\n\t\tconst HAS_GRADIENTMAP = !! material.gradientMap;\n\n\t\tconst HAS_ALPHAMAP = !! material.alphaMap;\n\n\t\tconst HAS_ALPHATEST = material.alphaTest > 0;\n\n\t\tconst HAS_ALPHAHASH = !! material.alphaHash;\n\n\t\tconst HAS_EXTENSIONS = !! material.extensions;\n\n\t\tlet toneMapping = NoToneMapping;\n\n\t\tif ( material.toneMapped ) {\n\n\t\t\tif ( currentRenderTarget === null || currentRenderTarget.isXRRenderTarget === true ) {\n\n\t\t\t\ttoneMapping = renderer.toneMapping;\n\n\t\t\t}\n\n\t\t}\n\n\t\tconst parameters = {\n\n\t\t\tshaderID: shaderID,\n\t\t\tshaderType: material.type,\n\t\t\tshaderName: material.name,\n\n\t\t\tvertexShader: vertexShader,\n\t\t\tfragmentShader: fragmentShader,\n\t\t\tdefines: material.defines,\n\n\t\t\tcustomVertexShaderID: customVertexShaderID,\n\t\t\tcustomFragmentShaderID: customFragmentShaderID,\n\n\t\t\tisRawShaderMaterial: material.isRawShaderMaterial === true,\n\t\t\tglslVersion: material.glslVersion,\n\n\t\t\tprecision: precision,\n\n\t\t\tbatching: IS_BATCHEDMESH,\n\t\t\tinstancing: IS_INSTANCEDMESH,\n\t\t\tinstancingColor: IS_INSTANCEDMESH && object.instanceColor !== null,\n\t\t\tinstancingMorph: IS_INSTANCEDMESH && object.morphTexture !== null,\n\n\t\t\tsupportsVertexTextures: SUPPORTS_VERTEX_TEXTURES,\n\t\t\toutputColorSpace: ( currentRenderTarget === null ) ? renderer.outputColorSpace : ( currentRenderTarget.isXRRenderTarget === true ? currentRenderTarget.texture.colorSpace : LinearSRGBColorSpace ),\n\t\t\talphaToCoverage: !! material.alphaToCoverage,\n\n\t\t\tmap: HAS_MAP,\n\t\t\tmatcap: HAS_MATCAP,\n\t\t\tenvMap: HAS_ENVMAP,\n\t\t\tenvMapMode: HAS_ENVMAP && envMap.mapping,\n\t\t\tenvMapCubeUVHeight: envMapCubeUVHeight,\n\t\t\taoMap: HAS_AOMAP,\n\t\t\tlightMap: HAS_LIGHTMAP,\n\t\t\tbumpMap: HAS_BUMPMAP,\n\t\t\tnormalMap: HAS_NORMALMAP,\n\t\t\tdisplacementMap: SUPPORTS_VERTEX_TEXTURES && HAS_DISPLACEMENTMAP,\n\t\t\temissiveMap: HAS_EMISSIVEMAP,\n\n\t\t\tnormalMapObjectSpace: HAS_NORMALMAP && material.normalMapType === ObjectSpaceNormalMap,\n\t\t\tnormalMapTangentSpace: HAS_NORMALMAP && material.normalMapType === TangentSpaceNormalMap,\n\n\t\t\tmetalnessMap: HAS_METALNESSMAP,\n\t\t\troughnessMap: HAS_ROUGHNESSMAP,\n\n\t\t\tanisotropy: HAS_ANISOTROPY,\n\t\t\tanisotropyMap: HAS_ANISOTROPYMAP,\n\n\t\t\tclearcoat: HAS_CLEARCOAT,\n\t\t\tclearcoatMap: HAS_CLEARCOATMAP,\n\t\t\tclearcoatNormalMap: HAS_CLEARCOAT_NORMALMAP,\n\t\t\tclearcoatRoughnessMap: HAS_CLEARCOAT_ROUGHNESSMAP,\n\n\t\t\tiridescence: HAS_IRIDESCENCE,\n\t\t\tiridescenceMap: HAS_IRIDESCENCEMAP,\n\t\t\tiridescenceThicknessMap: HAS_IRIDESCENCE_THICKNESSMAP,\n\n\t\t\tsheen: HAS_SHEEN,\n\t\t\tsheenColorMap: HAS_SHEEN_COLORMAP,\n\t\t\tsheenRoughnessMap: HAS_SHEEN_ROUGHNESSMAP,\n\n\t\t\tspecularMap: HAS_SPECULARMAP,\n\t\t\tspecularColorMap: HAS_SPECULAR_COLORMAP,\n\t\t\tspecularIntensityMap: HAS_SPECULAR_INTENSITYMAP,\n\n\t\t\ttransmission: HAS_TRANSMISSION,\n\t\t\ttransmissionMap: HAS_TRANSMISSIONMAP,\n\t\t\tthicknessMap: HAS_THICKNESSMAP,\n\n\t\t\tgradientMap: HAS_GRADIENTMAP,\n\n\t\t\topaque: material.transparent === false && material.blending === NormalBlending && material.alphaToCoverage === false,\n\n\t\t\talphaMap: HAS_ALPHAMAP,\n\t\t\talphaTest: HAS_ALPHATEST,\n\t\t\talphaHash: HAS_ALPHAHASH,\n\n\t\t\tcombine: material.combine,\n\n\t\t\t//\n\n\t\t\tmapUv: HAS_MAP && getChannel( material.map.channel ),\n\t\t\taoMapUv: HAS_AOMAP && getChannel( material.aoMap.channel ),\n\t\t\tlightMapUv: HAS_LIGHTMAP && getChannel( material.lightMap.channel ),\n\t\t\tbumpMapUv: HAS_BUMPMAP && getChannel( material.bumpMap.channel ),\n\t\t\tnormalMapUv: HAS_NORMALMAP && getChannel( material.normalMap.channel ),\n\t\t\tdisplacementMapUv: HAS_DISPLACEMENTMAP && getChannel( material.displacementMap.channel ),\n\t\t\temissiveMapUv: HAS_EMISSIVEMAP && getChannel( material.emissiveMap.channel ),\n\n\t\t\tmetalnessMapUv: HAS_METALNESSMAP && getChannel( material.metalnessMap.channel ),\n\t\t\troughnessMapUv: HAS_ROUGHNESSMAP && getChannel( material.roughnessMap.channel ),\n\n\t\t\tanisotropyMapUv: HAS_ANISOTROPYMAP && getChannel( material.anisotropyMap.channel ),\n\n\t\t\tclearcoatMapUv: HAS_CLEARCOATMAP && getChannel( material.clearcoatMap.channel ),\n\t\t\tclearcoatNormalMapUv: HAS_CLEARCOAT_NORMALMAP && getChannel( material.clearcoatNormalMap.channel ),\n\t\t\tclearcoatRoughnessMapUv: HAS_CLEARCOAT_ROUGHNESSMAP && getChannel( material.clearcoatRoughnessMap.channel ),\n\n\t\t\tiridescenceMapUv: HAS_IRIDESCENCEMAP && getChannel( material.iridescenceMap.channel ),\n\t\t\tiridescenceThicknessMapUv: HAS_IRIDESCENCE_THICKNESSMAP && getChannel( material.iridescenceThicknessMap.channel ),\n\n\t\t\tsheenColorMapUv: HAS_SHEEN_COLORMAP && getChannel( material.sheenColorMap.channel ),\n\t\t\tsheenRoughnessMapUv: HAS_SHEEN_ROUGHNESSMAP && getChannel( material.sheenRoughnessMap.channel ),\n\n\t\t\tspecularMapUv: HAS_SPECULARMAP && getChannel( material.specularMap.channel ),\n\t\t\tspecularColorMapUv: HAS_SPECULAR_COLORMAP && getChannel( material.specularColorMap.channel ),\n\t\t\tspecularIntensityMapUv: HAS_SPECULAR_INTENSITYMAP && getChannel( material.specularIntensityMap.channel ),\n\n\t\t\ttransmissionMapUv: HAS_TRANSMISSIONMAP && getChannel( material.transmissionMap.channel ),\n\t\t\tthicknessMapUv: HAS_THICKNESSMAP && getChannel( material.thicknessMap.channel ),\n\n\t\t\talphaMapUv: HAS_ALPHAMAP && getChannel( material.alphaMap.channel ),\n\n\t\t\t//\n\n\t\t\tvertexTangents: !! geometry.attributes.tangent && ( HAS_NORMALMAP || HAS_ANISOTROPY ),\n\t\t\tvertexColors: material.vertexColors,\n\t\t\tvertexAlphas: material.vertexColors === true && !! geometry.attributes.color && geometry.attributes.color.itemSize === 4,\n\n\t\t\tpointsUvs: object.isPoints === true && !! geometry.attributes.uv && ( HAS_MAP || HAS_ALPHAMAP ),\n\n\t\t\tfog: !! fog,\n\t\t\tuseFog: material.fog === true,\n\t\t\tfogExp2: ( !! fog && fog.isFogExp2 ),\n\n\t\t\tflatShading: material.flatShading === true,\n\n\t\t\tsizeAttenuation: material.sizeAttenuation === true,\n\t\t\tlogarithmicDepthBuffer: logarithmicDepthBuffer,\n\n\t\t\tskinning: object.isSkinnedMesh === true,\n\n\t\t\tmorphTargets: geometry.morphAttributes.position !== undefined,\n\t\t\tmorphNormals: geometry.morphAttributes.normal !== undefined,\n\t\t\tmorphColors: geometry.morphAttributes.color !== undefined,\n\t\t\tmorphTargetsCount: morphTargetsCount,\n\t\t\tmorphTextureStride: morphTextureStride,\n\n\t\t\tnumDirLights: lights.directional.length,\n\t\t\tnumPointLights: lights.point.length,\n\t\t\tnumSpotLights: lights.spot.length,\n\t\t\tnumSpotLightMaps: lights.spotLightMap.length,\n\t\t\tnumRectAreaLights: lights.rectArea.length,\n\t\t\tnumHemiLights: lights.hemi.length,\n\n\t\t\tnumDirLightShadows: lights.directionalShadowMap.length,\n\t\t\tnumPointLightShadows: lights.pointShadowMap.length,\n\t\t\tnumSpotLightShadows: lights.spotShadowMap.length,\n\t\t\tnumSpotLightShadowsWithMaps: lights.numSpotLightShadowsWithMaps,\n\n\t\t\tnumLightProbes: lights.numLightProbes,\n\n\t\t\tnumClippingPlanes: clipping.numPlanes,\n\t\t\tnumClipIntersection: clipping.numIntersection,\n\n\t\t\tdithering: material.dithering,\n\n\t\t\tshadowMapEnabled: renderer.shadowMap.enabled && shadows.length > 0,\n\t\t\tshadowMapType: renderer.shadowMap.type,\n\n\t\t\ttoneMapping: toneMapping,\n\t\t\tuseLegacyLights: renderer._useLegacyLights,\n\n\t\t\tdecodeVideoTexture: HAS_MAP && ( material.map.isVideoTexture === true ) && ( ColorManagement.getTransfer( material.map.colorSpace ) === SRGBTransfer ),\n\n\t\t\tpremultipliedAlpha: material.premultipliedAlpha,\n\n\t\t\tdoubleSided: material.side === DoubleSide,\n\t\t\tflipSided: material.side === BackSide,\n\n\t\t\tuseDepthPacking: material.depthPacking >= 0,\n\t\t\tdepthPacking: material.depthPacking || 0,\n\n\t\t\tindex0AttributeName: material.index0AttributeName,\n\n\t\t\textensionClipCullDistance: HAS_EXTENSIONS && material.extensions.clipCullDistance === true && extensions.has( 'WEBGL_clip_cull_distance' ),\n\t\t\textensionMultiDraw: HAS_EXTENSIONS && material.extensions.multiDraw === true && extensions.has( 'WEBGL_multi_draw' ),\n\n\t\t\trendererExtensionParallelShaderCompile: extensions.has( 'KHR_parallel_shader_compile' ),\n\n\t\t\tcustomProgramCacheKey: material.customProgramCacheKey()\n\n\t\t};\n\n\t\t// the usage of getChannel() determines the active texture channels for this shader\n\n\t\tparameters.vertexUv1s = _activeChannels.has( 1 );\n\t\tparameters.vertexUv2s = _activeChannels.has( 2 );\n\t\tparameters.vertexUv3s = _activeChannels.has( 3 );\n\n\t\t_activeChannels.clear();\n\n\t\treturn parameters;\n\n\t}\n\n\tfunction getProgramCacheKey( parameters ) {\n\n\t\tconst array = [];\n\n\t\tif ( parameters.shaderID ) {\n\n\t\t\tarray.push( parameters.shaderID );\n\n\t\t} else {\n\n\t\t\tarray.push( parameters.customVertexShaderID );\n\t\t\tarray.push( parameters.customFragmentShaderID );\n\n\t\t}\n\n\t\tif ( parameters.defines !== undefined ) {\n\n\t\t\tfor ( const name in parameters.defines ) {\n\n\t\t\t\tarray.push( name );\n\t\t\t\tarray.push( parameters.defines[ name ] );\n\n\t\t\t}\n\n\t\t}\n\n\t\tif ( parameters.isRawShaderMaterial === false ) {\n\n\t\t\tgetProgramCacheKeyParameters( array, parameters );\n\t\t\tgetProgramCacheKeyBooleans( array, parameters );\n\t\t\tarray.push( renderer.outputColorSpace );\n\n\t\t}\n\n\t\tarray.push( parameters.customProgramCacheKey );\n\n\t\treturn array.join();\n\n\t}\n\n\tfunction getProgramCacheKeyParameters( array, parameters ) {\n\n\t\tarray.push( parameters.precision );\n\t\tarray.push( parameters.outputColorSpace );\n\t\tarray.push( parameters.envMapMode );\n\t\tarray.push( parameters.envMapCubeUVHeight );\n\t\tarray.push( parameters.mapUv );\n\t\tarray.push( parameters.alphaMapUv );\n\t\tarray.push( parameters.lightMapUv );\n\t\tarray.push( parameters.aoMapUv );\n\t\tarray.push( parameters.bumpMapUv );\n\t\tarray.push( parameters.normalMapUv );\n\t\tarray.push( parameters.displacementMapUv );\n\t\tarray.push( parameters.emissiveMapUv );\n\t\tarray.push( parameters.metalnessMapUv );\n\t\tarray.push( parameters.roughnessMapUv );\n\t\tarray.push( parameters.anisotropyMapUv );\n\t\tarray.push( parameters.clearcoatMapUv );\n\t\tarray.push( parameters.clearcoatNormalMapUv );\n\t\tarray.push( parameters.clearcoatRoughnessMapUv );\n\t\tarray.push( parameters.iridescenceMapUv );\n\t\tarray.push( parameters.iridescenceThicknessMapUv );\n\t\tarray.push( parameters.sheenColorMapUv );\n\t\tarray.push( parameters.sheenRoughnessMapUv );\n\t\tarray.push( parameters.specularMapUv );\n\t\tarray.push( parameters.specularColorMapUv );\n\t\tarray.push( parameters.specularIntensityMapUv );\n\t\tarray.push( parameters.transmissionMapUv );\n\t\tarray.push( parameters.thicknessMapUv );\n\t\tarray.push( parameters.combine );\n\t\tarray.push( parameters.fogExp2 );\n\t\tarray.push( parameters.sizeAttenuation );\n\t\tarray.push( parameters.morphTargetsCount );\n\t\tarray.push( parameters.morphAttributeCount );\n\t\tarray.push( parameters.numDirLights );\n\t\tarray.push( parameters.numPointLights );\n\t\tarray.push( parameters.numSpotLights );\n\t\tarray.push( parameters.numSpotLightMaps );\n\t\tarray.push( parameters.numHemiLights );\n\t\tarray.push( parameters.numRectAreaLights );\n\t\tarray.push( parameters.numDirLightShadows );\n\t\tarray.push( parameters.numPointLightShadows );\n\t\tarray.push( parameters.numSpotLightShadows );\n\t\tarray.push( parameters.numSpotLightShadowsWithMaps );\n\t\tarray.push( parameters.numLightProbes );\n\t\tarray.push( parameters.shadowMapType );\n\t\tarray.push( parameters.toneMapping );\n\t\tarray.push( parameters.numClippingPlanes );\n\t\tarray.push( parameters.numClipIntersection );\n\t\tarray.push( parameters.depthPacking );\n\n\t}\n\n\tfunction getProgramCacheKeyBooleans( array, parameters ) {\n\n\t\t_programLayers.disableAll();\n\n\t\tif ( parameters.supportsVertexTextures )\n\t\t\t_programLayers.enable( 0 );\n\t\tif ( parameters.instancing )\n\t\t\t_programLayers.enable( 1 );\n\t\tif ( parameters.instancingColor )\n\t\t\t_programLayers.enable( 2 );\n\t\tif ( parameters.instancingMorph )\n\t\t\t_programLayers.enable( 3 );\n\t\tif ( parameters.matcap )\n\t\t\t_programLayers.enable( 4 );\n\t\tif ( parameters.envMap )\n\t\t\t_programLayers.enable( 5 );\n\t\tif ( parameters.normalMapObjectSpace )\n\t\t\t_programLayers.enable( 6 );\n\t\tif ( parameters.normalMapTangentSpace )\n\t\t\t_programLayers.enable( 7 );\n\t\tif ( parameters.clearcoat )\n\t\t\t_programLayers.enable( 8 );\n\t\tif ( parameters.iridescence )\n\t\t\t_programLayers.enable( 9 );\n\t\tif ( parameters.alphaTest )\n\t\t\t_programLayers.enable( 10 );\n\t\tif ( parameters.vertexColors )\n\t\t\t_programLayers.enable( 11 );\n\t\tif ( parameters.vertexAlphas )\n\t\t\t_programLayers.enable( 12 );\n\t\tif ( parameters.vertexUv1s )\n\t\t\t_programLayers.enable( 13 );\n\t\tif ( parameters.vertexUv2s )\n\t\t\t_programLayers.enable( 14 );\n\t\tif ( parameters.vertexUv3s )\n\t\t\t_programLayers.enable( 15 );\n\t\tif ( parameters.vertexTangents )\n\t\t\t_programLayers.enable( 16 );\n\t\tif ( parameters.anisotropy )\n\t\t\t_programLayers.enable( 17 );\n\t\tif ( parameters.alphaHash )\n\t\t\t_programLayers.enable( 18 );\n\t\tif ( parameters.batching )\n\t\t\t_programLayers.enable( 19 );\n\n\t\tarray.push( _programLayers.mask );\n\t\t_programLayers.disableAll();\n\n\t\tif ( parameters.fog )\n\t\t\t_programLayers.enable( 0 );\n\t\tif ( parameters.useFog )\n\t\t\t_programLayers.enable( 1 );\n\t\tif ( parameters.flatShading )\n\t\t\t_programLayers.enable( 2 );\n\t\tif ( parameters.logarithmicDepthBuffer )\n\t\t\t_programLayers.enable( 3 );\n\t\tif ( parameters.skinning )\n\t\t\t_programLayers.enable( 4 );\n\t\tif ( parameters.morphTargets )\n\t\t\t_programLayers.enable( 5 );\n\t\tif ( parameters.morphNormals )\n\t\t\t_programLayers.enable( 6 );\n\t\tif ( parameters.morphColors )\n\t\t\t_programLayers.enable( 7 );\n\t\tif ( parameters.premultipliedAlpha )\n\t\t\t_programLayers.enable( 8 );\n\t\tif ( parameters.shadowMapEnabled )\n\t\t\t_programLayers.enable( 9 );\n\t\tif ( parameters.useLegacyLights )\n\t\t\t_programLayers.enable( 10 );\n\t\tif ( parameters.doubleSided )\n\t\t\t_programLayers.enable( 11 );\n\t\tif ( parameters.flipSided )\n\t\t\t_programLayers.enable( 12 );\n\t\tif ( parameters.useDepthPacking )\n\t\t\t_programLayers.enable( 13 );\n\t\tif ( parameters.dithering )\n\t\t\t_programLayers.enable( 14 );\n\t\tif ( parameters.transmission )\n\t\t\t_programLayers.enable( 15 );\n\t\tif ( parameters.sheen )\n\t\t\t_programLayers.enable( 16 );\n\t\tif ( parameters.opaque )\n\t\t\t_programLayers.enable( 17 );\n\t\tif ( parameters.pointsUvs )\n\t\t\t_programLayers.enable( 18 );\n\t\tif ( parameters.decodeVideoTexture )\n\t\t\t_programLayers.enable( 19 );\n\t\tif ( parameters.alphaToCoverage )\n\t\t\t_programLayers.enable( 20 );\n\n\t\tarray.push( _programLayers.mask );\n\n\t}\n\n\tfunction getUniforms( material ) {\n\n\t\tconst shaderID = shaderIDs[ material.type ];\n\t\tlet uniforms;\n\n\t\tif ( shaderID ) {\n\n\t\t\tconst shader = ShaderLib[ shaderID ];\n\t\t\tuniforms = UniformsUtils.clone( shader.uniforms );\n\n\t\t} else {\n\n\t\t\tuniforms = material.uniforms;\n\n\t\t}\n\n\t\treturn uniforms;\n\n\t}\n\n\tfunction acquireProgram( parameters, cacheKey ) {\n\n\t\tlet program;\n\n\t\t// Check if code has been already compiled\n\t\tfor ( let p = 0, pl = programs.length; p < pl; p ++ ) {\n\n\t\t\tconst preexistingProgram = programs[ p ];\n\n\t\t\tif ( preexistingProgram.cacheKey === cacheKey ) {\n\n\t\t\t\tprogram = preexistingProgram;\n\t\t\t\t++ program.usedTimes;\n\n\t\t\t\tbreak;\n\n\t\t\t}\n\n\t\t}\n\n\t\tif ( program === undefined ) {\n\n\t\t\tprogram = new WebGLProgram( renderer, cacheKey, parameters, bindingStates );\n\t\t\tprograms.push( program );\n\n\t\t}\n\n\t\treturn program;\n\n\t}\n\n\tfunction releaseProgram( program ) {\n\n\t\tif ( -- program.usedTimes === 0 ) {\n\n\t\t\t// Remove from unordered set\n\t\t\tconst i = programs.indexOf( program );\n\t\t\tprograms[ i ] = programs[ programs.length - 1 ];\n\t\t\tprograms.pop();\n\n\t\t\t// Free WebGL resources\n\t\t\tprogram.destroy();\n\n\t\t}\n\n\t}\n\n\tfunction releaseShaderCache( material ) {\n\n\t\t_customShaders.remove( material );\n\n\t}\n\n\tfunction dispose() {\n\n\t\t_customShaders.dispose();\n\n\t}\n\n\treturn {\n\t\tgetParameters: getParameters,\n\t\tgetProgramCacheKey: getProgramCacheKey,\n\t\tgetUniforms: getUniforms,\n\t\tacquireProgram: acquireProgram,\n\t\treleaseProgram: releaseProgram,\n\t\treleaseShaderCache: releaseShaderCache,\n\t\t// Exposed for resource monitoring & error feedback via renderer.info:\n\t\tprograms: programs,\n\t\tdispose: dispose\n\t};\n\n}\n\nfunction WebGLProperties() {\n\n\tlet properties = new WeakMap();\n\n\tfunction get( object ) {\n\n\t\tlet map = properties.get( object );\n\n\t\tif ( map === undefined ) {\n\n\t\t\tmap = {};\n\t\t\tproperties.set( object, map );\n\n\t\t}\n\n\t\treturn map;\n\n\t}\n\n\tfunction remove( object ) {\n\n\t\tproperties.delete( object );\n\n\t}\n\n\tfunction update( object, key, value ) {\n\n\t\tproperties.get( object )[ key ] = value;\n\n\t}\n\n\tfunction dispose() {\n\n\t\tproperties = new WeakMap();\n\n\t}\n\n\treturn {\n\t\tget: get,\n\t\tremove: remove,\n\t\tupdate: update,\n\t\tdispose: dispose\n\t};\n\n}\n\nfunction painterSortStable( a, b ) {\n\n\tif ( a.groupOrder !== b.groupOrder ) {\n\n\t\treturn a.groupOrder - b.groupOrder;\n\n\t} else if ( a.renderOrder !== b.renderOrder ) {\n\n\t\treturn a.renderOrder - b.renderOrder;\n\n\t} else if ( a.material.id !== b.material.id ) {\n\n\t\treturn a.material.id - b.material.id;\n\n\t} else if ( a.z !== b.z ) {\n\n\t\treturn a.z - b.z;\n\n\t} else {\n\n\t\treturn a.id - b.id;\n\n\t}\n\n}\n\nfunction reversePainterSortStable( a, b ) {\n\n\tif ( a.groupOrder !== b.groupOrder ) {\n\n\t\treturn a.groupOrder - b.groupOrder;\n\n\t} else if ( a.renderOrder !== b.renderOrder ) {\n\n\t\treturn a.renderOrder - b.renderOrder;\n\n\t} else if ( a.z !== b.z ) {\n\n\t\treturn b.z - a.z;\n\n\t} else {\n\n\t\treturn a.id - b.id;\n\n\t}\n\n}\n\n\nfunction WebGLRenderList() {\n\n\tconst renderItems = [];\n\tlet renderItemsIndex = 0;\n\n\tconst opaque = [];\n\tconst transmissive = [];\n\tconst transparent = [];\n\n\tfunction init() {\n\n\t\trenderItemsIndex = 0;\n\n\t\topaque.length = 0;\n\t\ttransmissive.length = 0;\n\t\ttransparent.length = 0;\n\n\t}\n\n\tfunction getNextRenderItem( object, geometry, material, groupOrder, z, group ) {\n\n\t\tlet renderItem = renderItems[ renderItemsIndex ];\n\n\t\tif ( renderItem === undefined ) {\n\n\t\t\trenderItem = {\n\t\t\t\tid: object.id,\n\t\t\t\tobject: object,\n\t\t\t\tgeometry: geometry,\n\t\t\t\tmaterial: material,\n\t\t\t\tgroupOrder: groupOrder,\n\t\t\t\trenderOrder: object.renderOrder,\n\t\t\t\tz: z,\n\t\t\t\tgroup: group\n\t\t\t};\n\n\t\t\trenderItems[ renderItemsIndex ] = renderItem;\n\n\t\t} else {\n\n\t\t\trenderItem.id = object.id;\n\t\t\trenderItem.object = object;\n\t\t\trenderItem.geometry = geometry;\n\t\t\trenderItem.material = material;\n\t\t\trenderItem.groupOrder = groupOrder;\n\t\t\trenderItem.renderOrder = object.renderOrder;\n\t\t\trenderItem.z = z;\n\t\t\trenderItem.group = group;\n\n\t\t}\n\n\t\trenderItemsIndex ++;\n\n\t\treturn renderItem;\n\n\t}\n\n\tfunction push( object, geometry, material, groupOrder, z, group ) {\n\n\t\tconst renderItem = getNextRenderItem( object, geometry, material, groupOrder, z, group );\n\n\t\tif ( material.transmission > 0.0 ) {\n\n\t\t\ttransmissive.push( renderItem );\n\n\t\t} else if ( material.transparent === true ) {\n\n\t\t\ttransparent.push( renderItem );\n\n\t\t} else {\n\n\t\t\topaque.push( renderItem );\n\n\t\t}\n\n\t}\n\n\tfunction unshift( object, geometry, material, groupOrder, z, group ) {\n\n\t\tconst renderItem = getNextRenderItem( object, geometry, material, groupOrder, z, group );\n\n\t\tif ( material.transmission > 0.0 ) {\n\n\t\t\ttransmissive.unshift( renderItem );\n\n\t\t} else if ( material.transparent === true ) {\n\n\t\t\ttransparent.unshift( renderItem );\n\n\t\t} else {\n\n\t\t\topaque.unshift( renderItem );\n\n\t\t}\n\n\t}\n\n\tfunction sort( customOpaqueSort, customTransparentSort ) {\n\n\t\tif ( opaque.length > 1 ) opaque.sort( customOpaqueSort || painterSortStable );\n\t\tif ( transmissive.length > 1 ) transmissive.sort( customTransparentSort || reversePainterSortStable );\n\t\tif ( transparent.length > 1 ) transparent.sort( customTransparentSort || reversePainterSortStable );\n\n\t}\n\n\tfunction finish() {\n\n\t\t// Clear references from inactive renderItems in the list\n\n\t\tfor ( let i = renderItemsIndex, il = renderItems.length; i < il; i ++ ) {\n\n\t\t\tconst renderItem = renderItems[ i ];\n\n\t\t\tif ( renderItem.id === null ) break;\n\n\t\t\trenderItem.id = null;\n\t\t\trenderItem.object = null;\n\t\t\trenderItem.geometry = null;\n\t\t\trenderItem.material = null;\n\t\t\trenderItem.group = null;\n\n\t\t}\n\n\t}\n\n\treturn {\n\n\t\topaque: opaque,\n\t\ttransmissive: transmissive,\n\t\ttransparent: transparent,\n\n\t\tinit: init,\n\t\tpush: push,\n\t\tunshift: unshift,\n\t\tfinish: finish,\n\n\t\tsort: sort\n\t};\n\n}\n\nfunction WebGLRenderLists() {\n\n\tlet lists = new WeakMap();\n\n\tfunction get( scene, renderCallDepth ) {\n\n\t\tconst listArray = lists.get( scene );\n\t\tlet list;\n\n\t\tif ( listArray === undefined ) {\n\n\t\t\tlist = new WebGLRenderList();\n\t\t\tlists.set( scene, [ list ] );\n\n\t\t} else {\n\n\t\t\tif ( renderCallDepth >= listArray.length ) {\n\n\t\t\t\tlist = new WebGLRenderList();\n\t\t\t\tlistArray.push( list );\n\n\t\t\t} else {\n\n\t\t\t\tlist = listArray[ renderCallDepth ];\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn list;\n\n\t}\n\n\tfunction dispose() {\n\n\t\tlists = new WeakMap();\n\n\t}\n\n\treturn {\n\t\tget: get,\n\t\tdispose: dispose\n\t};\n\n}\n\nfunction UniformsCache() {\n\n\tconst lights = {};\n\n\treturn {\n\n\t\tget: function ( light ) {\n\n\t\t\tif ( lights[ light.id ] !== undefined ) {\n\n\t\t\t\treturn lights[ light.id ];\n\n\t\t\t}\n\n\t\t\tlet uniforms;\n\n\t\t\tswitch ( light.type ) {\n\n\t\t\t\tcase 'DirectionalLight':\n\t\t\t\t\tuniforms = {\n\t\t\t\t\t\tdirection: new Vector3(),\n\t\t\t\t\t\tcolor: new Color()\n\t\t\t\t\t};\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase 'SpotLight':\n\t\t\t\t\tuniforms = {\n\t\t\t\t\t\tposition: new Vector3(),\n\t\t\t\t\t\tdirection: new Vector3(),\n\t\t\t\t\t\tcolor: new Color(),\n\t\t\t\t\t\tdistance: 0,\n\t\t\t\t\t\tconeCos: 0,\n\t\t\t\t\t\tpenumbraCos: 0,\n\t\t\t\t\t\tdecay: 0\n\t\t\t\t\t};\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase 'PointLight':\n\t\t\t\t\tuniforms = {\n\t\t\t\t\t\tposition: new Vector3(),\n\t\t\t\t\t\tcolor: new Color(),\n\t\t\t\t\t\tdistance: 0,\n\t\t\t\t\t\tdecay: 0\n\t\t\t\t\t};\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase 'HemisphereLight':\n\t\t\t\t\tuniforms = {\n\t\t\t\t\t\tdirection: new Vector3(),\n\t\t\t\t\t\tskyColor: new Color(),\n\t\t\t\t\t\tgroundColor: new Color()\n\t\t\t\t\t};\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase 'RectAreaLight':\n\t\t\t\t\tuniforms = {\n\t\t\t\t\t\tcolor: new Color(),\n\t\t\t\t\t\tposition: new Vector3(),\n\t\t\t\t\t\thalfWidth: new Vector3(),\n\t\t\t\t\t\thalfHeight: new Vector3()\n\t\t\t\t\t};\n\t\t\t\t\tbreak;\n\n\t\t\t}\n\n\t\t\tlights[ light.id ] = uniforms;\n\n\t\t\treturn uniforms;\n\n\t\t}\n\n\t};\n\n}\n\nfunction ShadowUniformsCache() {\n\n\tconst lights = {};\n\n\treturn {\n\n\t\tget: function ( light ) {\n\n\t\t\tif ( lights[ light.id ] !== undefined ) {\n\n\t\t\t\treturn lights[ light.id ];\n\n\t\t\t}\n\n\t\t\tlet uniforms;\n\n\t\t\tswitch ( light.type ) {\n\n\t\t\t\tcase 'DirectionalLight':\n\t\t\t\t\tuniforms = {\n\t\t\t\t\t\tshadowBias: 0,\n\t\t\t\t\t\tshadowNormalBias: 0,\n\t\t\t\t\t\tshadowRadius: 1,\n\t\t\t\t\t\tshadowMapSize: new Vector2()\n\t\t\t\t\t};\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase 'SpotLight':\n\t\t\t\t\tuniforms = {\n\t\t\t\t\t\tshadowBias: 0,\n\t\t\t\t\t\tshadowNormalBias: 0,\n\t\t\t\t\t\tshadowRadius: 1,\n\t\t\t\t\t\tshadowMapSize: new Vector2()\n\t\t\t\t\t};\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase 'PointLight':\n\t\t\t\t\tuniforms = {\n\t\t\t\t\t\tshadowBias: 0,\n\t\t\t\t\t\tshadowNormalBias: 0,\n\t\t\t\t\t\tshadowRadius: 1,\n\t\t\t\t\t\tshadowMapSize: new Vector2(),\n\t\t\t\t\t\tshadowCameraNear: 1,\n\t\t\t\t\t\tshadowCameraFar: 1000\n\t\t\t\t\t};\n\t\t\t\t\tbreak;\n\n\t\t\t\t// TODO (abelnation): set RectAreaLight shadow uniforms\n\n\t\t\t}\n\n\t\t\tlights[ light.id ] = uniforms;\n\n\t\t\treturn uniforms;\n\n\t\t}\n\n\t};\n\n}\n\n\n\nlet nextVersion = 0;\n\nfunction shadowCastingAndTexturingLightsFirst( lightA, lightB ) {\n\n\treturn ( lightB.castShadow ? 2 : 0 ) - ( lightA.castShadow ? 2 : 0 ) + ( lightB.map ? 1 : 0 ) - ( lightA.map ? 1 : 0 );\n\n}\n\nfunction WebGLLights( extensions ) {\n\n\tconst cache = new UniformsCache();\n\n\tconst shadowCache = ShadowUniformsCache();\n\n\tconst state = {\n\n\t\tversion: 0,\n\n\t\thash: {\n\t\t\tdirectionalLength: - 1,\n\t\t\tpointLength: - 1,\n\t\t\tspotLength: - 1,\n\t\t\trectAreaLength: - 1,\n\t\t\themiLength: - 1,\n\n\t\t\tnumDirectionalShadows: - 1,\n\t\t\tnumPointShadows: - 1,\n\t\t\tnumSpotShadows: - 1,\n\t\t\tnumSpotMaps: - 1,\n\n\t\t\tnumLightProbes: - 1\n\t\t},\n\n\t\tambient: [ 0, 0, 0 ],\n\t\tprobe: [],\n\t\tdirectional: [],\n\t\tdirectionalShadow: [],\n\t\tdirectionalShadowMap: [],\n\t\tdirectionalShadowMatrix: [],\n\t\tspot: [],\n\t\tspotLightMap: [],\n\t\tspotShadow: [],\n\t\tspotShadowMap: [],\n\t\tspotLightMatrix: [],\n\t\trectArea: [],\n\t\trectAreaLTC1: null,\n\t\trectAreaLTC2: null,\n\t\tpoint: [],\n\t\tpointShadow: [],\n\t\tpointShadowMap: [],\n\t\tpointShadowMatrix: [],\n\t\themi: [],\n\t\tnumSpotLightShadowsWithMaps: 0,\n\t\tnumLightProbes: 0\n\n\t};\n\n\tfor ( let i = 0; i < 9; i ++ ) state.probe.push( new Vector3() );\n\n\tconst vector3 = new Vector3();\n\tconst matrix4 = new Matrix4();\n\tconst matrix42 = new Matrix4();\n\n\tfunction setup( lights, useLegacyLights ) {\n\n\t\tlet r = 0, g = 0, b = 0;\n\n\t\tfor ( let i = 0; i < 9; i ++ ) state.probe[ i ].set( 0, 0, 0 );\n\n\t\tlet directionalLength = 0;\n\t\tlet pointLength = 0;\n\t\tlet spotLength = 0;\n\t\tlet rectAreaLength = 0;\n\t\tlet hemiLength = 0;\n\n\t\tlet numDirectionalShadows = 0;\n\t\tlet numPointShadows = 0;\n\t\tlet numSpotShadows = 0;\n\t\tlet numSpotMaps = 0;\n\t\tlet numSpotShadowsWithMaps = 0;\n\n\t\tlet numLightProbes = 0;\n\n\t\t// ordering : [shadow casting + map texturing, map texturing, shadow casting, none ]\n\t\tlights.sort( shadowCastingAndTexturingLightsFirst );\n\n\t\t// artist-friendly light intensity scaling factor\n\t\tconst scaleFactor = ( useLegacyLights === true ) ? Math.PI : 1;\n\n\t\tfor ( let i = 0, l = lights.length; i < l; i ++ ) {\n\n\t\t\tconst light = lights[ i ];\n\n\t\t\tconst color = light.color;\n\t\t\tconst intensity = light.intensity;\n\t\t\tconst distance = light.distance;\n\n\t\t\tconst shadowMap = ( light.shadow && light.shadow.map ) ? light.shadow.map.texture : null;\n\n\t\t\tif ( light.isAmbientLight ) {\n\n\t\t\t\tr += color.r * intensity * scaleFactor;\n\t\t\t\tg += color.g * intensity * scaleFactor;\n\t\t\t\tb += color.b * intensity * scaleFactor;\n\n\t\t\t} else if ( light.isLightProbe ) {\n\n\t\t\t\tfor ( let j = 0; j < 9; j ++ ) {\n\n\t\t\t\t\tstate.probe[ j ].addScaledVector( light.sh.coefficients[ j ], intensity );\n\n\t\t\t\t}\n\n\t\t\t\tnumLightProbes ++;\n\n\t\t\t} else if ( light.isDirectionalLight ) {\n\n\t\t\t\tconst uniforms = cache.get( light );\n\n\t\t\t\tuniforms.color.copy( light.color ).multiplyScalar( light.intensity * scaleFactor );\n\n\t\t\t\tif ( light.castShadow ) {\n\n\t\t\t\t\tconst shadow = light.shadow;\n\n\t\t\t\t\tconst shadowUniforms = shadowCache.get( light );\n\n\t\t\t\t\tshadowUniforms.shadowBias = shadow.bias;\n\t\t\t\t\tshadowUniforms.shadowNormalBias = shadow.normalBias;\n\t\t\t\t\tshadowUniforms.shadowRadius = shadow.radius;\n\t\t\t\t\tshadowUniforms.shadowMapSize = shadow.mapSize;\n\n\t\t\t\t\tstate.directionalShadow[ directionalLength ] = shadowUniforms;\n\t\t\t\t\tstate.directionalShadowMap[ directionalLength ] = shadowMap;\n\t\t\t\t\tstate.directionalShadowMatrix[ directionalLength ] = light.shadow.matrix;\n\n\t\t\t\t\tnumDirectionalShadows ++;\n\n\t\t\t\t}\n\n\t\t\t\tstate.directional[ directionalLength ] = uniforms;\n\n\t\t\t\tdirectionalLength ++;\n\n\t\t\t} else if ( light.isSpotLight ) {\n\n\t\t\t\tconst uniforms = cache.get( light );\n\n\t\t\t\tuniforms.position.setFromMatrixPosition( light.matrixWorld );\n\n\t\t\t\tuniforms.color.copy( color ).multiplyScalar( intensity * scaleFactor );\n\t\t\t\tuniforms.distance = distance;\n\n\t\t\t\tuniforms.coneCos = Math.cos( light.angle );\n\t\t\t\tuniforms.penumbraCos = Math.cos( light.angle * ( 1 - light.penumbra ) );\n\t\t\t\tuniforms.decay = light.decay;\n\n\t\t\t\tstate.spot[ spotLength ] = uniforms;\n\n\t\t\t\tconst shadow = light.shadow;\n\n\t\t\t\tif ( light.map ) {\n\n\t\t\t\t\tstate.spotLightMap[ numSpotMaps ] = light.map;\n\t\t\t\t\tnumSpotMaps ++;\n\n\t\t\t\t\t// make sure the lightMatrix is up to date\n\t\t\t\t\t// TODO : do it if required only\n\t\t\t\t\tshadow.updateMatrices( light );\n\n\t\t\t\t\tif ( light.castShadow ) numSpotShadowsWithMaps ++;\n\n\t\t\t\t}\n\n\t\t\t\tstate.spotLightMatrix[ spotLength ] = shadow.matrix;\n\n\t\t\t\tif ( light.castShadow ) {\n\n\t\t\t\t\tconst shadowUniforms = shadowCache.get( light );\n\n\t\t\t\t\tshadowUniforms.shadowBias = shadow.bias;\n\t\t\t\t\tshadowUniforms.shadowNormalBias = shadow.normalBias;\n\t\t\t\t\tshadowUniforms.shadowRadius = shadow.radius;\n\t\t\t\t\tshadowUniforms.shadowMapSize = shadow.mapSize;\n\n\t\t\t\t\tstate.spotShadow[ spotLength ] = shadowUniforms;\n\t\t\t\t\tstate.spotShadowMap[ spotLength ] = shadowMap;\n\n\t\t\t\t\tnumSpotShadows ++;\n\n\t\t\t\t}\n\n\t\t\t\tspotLength ++;\n\n\t\t\t} else if ( light.isRectAreaLight ) {\n\n\t\t\t\tconst uniforms = cache.get( light );\n\n\t\t\t\tuniforms.color.copy( color ).multiplyScalar( intensity );\n\n\t\t\t\tuniforms.halfWidth.set( light.width * 0.5, 0.0, 0.0 );\n\t\t\t\tuniforms.halfHeight.set( 0.0, light.height * 0.5, 0.0 );\n\n\t\t\t\tstate.rectArea[ rectAreaLength ] = uniforms;\n\n\t\t\t\trectAreaLength ++;\n\n\t\t\t} else if ( light.isPointLight ) {\n\n\t\t\t\tconst uniforms = cache.get( light );\n\n\t\t\t\tuniforms.color.copy( light.color ).multiplyScalar( light.intensity * scaleFactor );\n\t\t\t\tuniforms.distance = light.distance;\n\t\t\t\tuniforms.decay = light.decay;\n\n\t\t\t\tif ( light.castShadow ) {\n\n\t\t\t\t\tconst shadow = light.shadow;\n\n\t\t\t\t\tconst shadowUniforms = shadowCache.get( light );\n\n\t\t\t\t\tshadowUniforms.shadowBias = shadow.bias;\n\t\t\t\t\tshadowUniforms.shadowNormalBias = shadow.normalBias;\n\t\t\t\t\tshadowUniforms.shadowRadius = shadow.radius;\n\t\t\t\t\tshadowUniforms.shadowMapSize = shadow.mapSize;\n\t\t\t\t\tshadowUniforms.shadowCameraNear = shadow.camera.near;\n\t\t\t\t\tshadowUniforms.shadowCameraFar = shadow.camera.far;\n\n\t\t\t\t\tstate.pointShadow[ pointLength ] = shadowUniforms;\n\t\t\t\t\tstate.pointShadowMap[ pointLength ] = shadowMap;\n\t\t\t\t\tstate.pointShadowMatrix[ pointLength ] = light.shadow.matrix;\n\n\t\t\t\t\tnumPointShadows ++;\n\n\t\t\t\t}\n\n\t\t\t\tstate.point[ pointLength ] = uniforms;\n\n\t\t\t\tpointLength ++;\n\n\t\t\t} else if ( light.isHemisphereLight ) {\n\n\t\t\t\tconst uniforms = cache.get( light );\n\n\t\t\t\tuniforms.skyColor.copy( light.color ).multiplyScalar( intensity * scaleFactor );\n\t\t\t\tuniforms.groundColor.copy( light.groundColor ).multiplyScalar( intensity * scaleFactor );\n\n\t\t\t\tstate.hemi[ hemiLength ] = uniforms;\n\n\t\t\t\themiLength ++;\n\n\t\t\t}\n\n\t\t}\n\n\t\tif ( rectAreaLength > 0 ) {\n\n\t\t\tif ( extensions.has( 'OES_texture_float_linear' ) === true ) {\n\n\t\t\t\tstate.rectAreaLTC1 = UniformsLib.LTC_FLOAT_1;\n\t\t\t\tstate.rectAreaLTC2 = UniformsLib.LTC_FLOAT_2;\n\n\t\t\t} else {\n\n\t\t\t\tstate.rectAreaLTC1 = UniformsLib.LTC_HALF_1;\n\t\t\t\tstate.rectAreaLTC2 = UniformsLib.LTC_HALF_2;\n\n\t\t\t}\n\n\t\t}\n\n\t\tstate.ambient[ 0 ] = r;\n\t\tstate.ambient[ 1 ] = g;\n\t\tstate.ambient[ 2 ] = b;\n\n\t\tconst hash = state.hash;\n\n\t\tif ( hash.directionalLength !== directionalLength ||\n\t\t\thash.pointLength !== pointLength ||\n\t\t\thash.spotLength !== spotLength ||\n\t\t\thash.rectAreaLength !== rectAreaLength ||\n\t\t\thash.hemiLength !== hemiLength ||\n\t\t\thash.numDirectionalShadows !== numDirectionalShadows ||\n\t\t\thash.numPointShadows !== numPointShadows ||\n\t\t\thash.numSpotShadows !== numSpotShadows ||\n\t\t\thash.numSpotMaps !== numSpotMaps ||\n\t\t\thash.numLightProbes !== numLightProbes ) {\n\n\t\t\tstate.directional.length = directionalLength;\n\t\t\tstate.spot.length = spotLength;\n\t\t\tstate.rectArea.length = rectAreaLength;\n\t\t\tstate.point.length = pointLength;\n\t\t\tstate.hemi.length = hemiLength;\n\n\t\t\tstate.directionalShadow.length = numDirectionalShadows;\n\t\t\tstate.directionalShadowMap.length = numDirectionalShadows;\n\t\t\tstate.pointShadow.length = numPointShadows;\n\t\t\tstate.pointShadowMap.length = numPointShadows;\n\t\t\tstate.spotShadow.length = numSpotShadows;\n\t\t\tstate.spotShadowMap.length = numSpotShadows;\n\t\t\tstate.directionalShadowMatrix.length = numDirectionalShadows;\n\t\t\tstate.pointShadowMatrix.length = numPointShadows;\n\t\t\tstate.spotLightMatrix.length = numSpotShadows + numSpotMaps - numSpotShadowsWithMaps;\n\t\t\tstate.spotLightMap.length = numSpotMaps;\n\t\t\tstate.numSpotLightShadowsWithMaps = numSpotShadowsWithMaps;\n\t\t\tstate.numLightProbes = numLightProbes;\n\n\t\t\thash.directionalLength = directionalLength;\n\t\t\thash.pointLength = pointLength;\n\t\t\thash.spotLength = spotLength;\n\t\t\thash.rectAreaLength = rectAreaLength;\n\t\t\thash.hemiLength = hemiLength;\n\n\t\t\thash.numDirectionalShadows = numDirectionalShadows;\n\t\t\thash.numPointShadows = numPointShadows;\n\t\t\thash.numSpotShadows = numSpotShadows;\n\t\t\thash.numSpotMaps = numSpotMaps;\n\n\t\t\thash.numLightProbes = numLightProbes;\n\n\t\t\tstate.version = nextVersion ++;\n\n\t\t}\n\n\t}\n\n\tfunction setupView( lights, camera ) {\n\n\t\tlet directionalLength = 0;\n\t\tlet pointLength = 0;\n\t\tlet spotLength = 0;\n\t\tlet rectAreaLength = 0;\n\t\tlet hemiLength = 0;\n\n\t\tconst viewMatrix = camera.matrixWorldInverse;\n\n\t\tfor ( let i = 0, l = lights.length; i < l; i ++ ) {\n\n\t\t\tconst light = lights[ i ];\n\n\t\t\tif ( light.isDirectionalLight ) {\n\n\t\t\t\tconst uniforms = state.directional[ directionalLength ];\n\n\t\t\t\tuniforms.direction.setFromMatrixPosition( light.matrixWorld );\n\t\t\t\tvector3.setFromMatrixPosition( light.target.matrixWorld );\n\t\t\t\tuniforms.direction.sub( vector3 );\n\t\t\t\tuniforms.direction.transformDirection( viewMatrix );\n\n\t\t\t\tdirectionalLength ++;\n\n\t\t\t} else if ( light.isSpotLight ) {\n\n\t\t\t\tconst uniforms = state.spot[ spotLength ];\n\n\t\t\t\tuniforms.position.setFromMatrixPosition( light.matrixWorld );\n\t\t\t\tuniforms.position.applyMatrix4( viewMatrix );\n\n\t\t\t\tuniforms.direction.setFromMatrixPosition( light.matrixWorld );\n\t\t\t\tvector3.setFromMatrixPosition( light.target.matrixWorld );\n\t\t\t\tuniforms.direction.sub( vector3 );\n\t\t\t\tuniforms.direction.transformDirection( viewMatrix );\n\n\t\t\t\tspotLength ++;\n\n\t\t\t} else if ( light.isRectAreaLight ) {\n\n\t\t\t\tconst uniforms = state.rectArea[ rectAreaLength ];\n\n\t\t\t\tuniforms.position.setFromMatrixPosition( light.matrixWorld );\n\t\t\t\tuniforms.position.applyMatrix4( viewMatrix );\n\n\t\t\t\t// extract local rotation of light to derive width/height half vectors\n\t\t\t\tmatrix42.identity();\n\t\t\t\tmatrix4.copy( light.matrixWorld );\n\t\t\t\tmatrix4.premultiply( viewMatrix );\n\t\t\t\tmatrix42.extractRotation( matrix4 );\n\n\t\t\t\tuniforms.halfWidth.set( light.width * 0.5, 0.0, 0.0 );\n\t\t\t\tuniforms.halfHeight.set( 0.0, light.height * 0.5, 0.0 );\n\n\t\t\t\tuniforms.halfWidth.applyMatrix4( matrix42 );\n\t\t\t\tuniforms.halfHeight.applyMatrix4( matrix42 );\n\n\t\t\t\trectAreaLength ++;\n\n\t\t\t} else if ( light.isPointLight ) {\n\n\t\t\t\tconst uniforms = state.point[ pointLength ];\n\n\t\t\t\tuniforms.position.setFromMatrixPosition( light.matrixWorld );\n\t\t\t\tuniforms.position.applyMatrix4( viewMatrix );\n\n\t\t\t\tpointLength ++;\n\n\t\t\t} else if ( light.isHemisphereLight ) {\n\n\t\t\t\tconst uniforms = state.hemi[ hemiLength ];\n\n\t\t\t\tuniforms.direction.setFromMatrixPosition( light.matrixWorld );\n\t\t\t\tuniforms.direction.transformDirection( viewMatrix );\n\n\t\t\t\themiLength ++;\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n\treturn {\n\t\tsetup: setup,\n\t\tsetupView: setupView,\n\t\tstate: state\n\t};\n\n}\n\nfunction WebGLRenderState( extensions ) {\n\n\tconst lights = new WebGLLights( extensions );\n\n\tconst lightsArray = [];\n\tconst shadowsArray = [];\n\n\tfunction init() {\n\n\t\tlightsArray.length = 0;\n\t\tshadowsArray.length = 0;\n\n\t}\n\n\tfunction pushLight( light ) {\n\n\t\tlightsArray.push( light );\n\n\t}\n\n\tfunction pushShadow( shadowLight ) {\n\n\t\tshadowsArray.push( shadowLight );\n\n\t}\n\n\tfunction setupLights( useLegacyLights ) {\n\n\t\tlights.setup( lightsArray, useLegacyLights );\n\n\t}\n\n\tfunction setupLightsView( camera ) {\n\n\t\tlights.setupView( lightsArray, camera );\n\n\t}\n\n\tconst state = {\n\t\tlightsArray: lightsArray,\n\t\tshadowsArray: shadowsArray,\n\n\t\tlights: lights,\n\n\t\ttransmissionRenderTarget: null\n\t};\n\n\treturn {\n\t\tinit: init,\n\t\tstate: state,\n\t\tsetupLights: setupLights,\n\t\tsetupLightsView: setupLightsView,\n\n\t\tpushLight: pushLight,\n\t\tpushShadow: pushShadow\n\t};\n\n}\n\nfunction WebGLRenderStates( extensions ) {\n\n\tlet renderStates = new WeakMap();\n\n\tfunction get( scene, renderCallDepth = 0 ) {\n\n\t\tconst renderStateArray = renderStates.get( scene );\n\t\tlet renderState;\n\n\t\tif ( renderStateArray === undefined ) {\n\n\t\t\trenderState = new WebGLRenderState( extensions );\n\t\t\trenderStates.set( scene, [ renderState ] );\n\n\t\t} else {\n\n\t\t\tif ( renderCallDepth >= renderStateArray.length ) {\n\n\t\t\t\trenderState = new WebGLRenderState( extensions );\n\t\t\t\trenderStateArray.push( renderState );\n\n\t\t\t} else {\n\n\t\t\t\trenderState = renderStateArray[ renderCallDepth ];\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn renderState;\n\n\t}\n\n\tfunction dispose() {\n\n\t\trenderStates = new WeakMap();\n\n\t}\n\n\treturn {\n\t\tget: get,\n\t\tdispose: dispose\n\t};\n\n}\n\nclass MeshDepthMaterial extends Material {\n\n\tconstructor( parameters ) {\n\n\t\tsuper();\n\n\t\tthis.isMeshDepthMaterial = true;\n\n\t\tthis.type = 'MeshDepthMaterial';\n\n\t\tthis.depthPacking = BasicDepthPacking;\n\n\t\tthis.map = null;\n\n\t\tthis.alphaMap = null;\n\n\t\tthis.displacementMap = null;\n\t\tthis.displacementScale = 1;\n\t\tthis.displacementBias = 0;\n\n\t\tthis.wireframe = false;\n\t\tthis.wireframeLinewidth = 1;\n\n\t\tthis.setValues( parameters );\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.depthPacking = source.depthPacking;\n\n\t\tthis.map = source.map;\n\n\t\tthis.alphaMap = source.alphaMap;\n\n\t\tthis.displacementMap = source.displacementMap;\n\t\tthis.displacementScale = source.displacementScale;\n\t\tthis.displacementBias = source.displacementBias;\n\n\t\tthis.wireframe = source.wireframe;\n\t\tthis.wireframeLinewidth = source.wireframeLinewidth;\n\n\t\treturn this;\n\n\t}\n\n}\n\nclass MeshDistanceMaterial extends Material {\n\n\tconstructor( parameters ) {\n\n\t\tsuper();\n\n\t\tthis.isMeshDistanceMaterial = true;\n\n\t\tthis.type = 'MeshDistanceMaterial';\n\n\t\tthis.map = null;\n\n\t\tthis.alphaMap = null;\n\n\t\tthis.displacementMap = null;\n\t\tthis.displacementScale = 1;\n\t\tthis.displacementBias = 0;\n\n\t\tthis.setValues( parameters );\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.map = source.map;\n\n\t\tthis.alphaMap = source.alphaMap;\n\n\t\tthis.displacementMap = source.displacementMap;\n\t\tthis.displacementScale = source.displacementScale;\n\t\tthis.displacementBias = source.displacementBias;\n\n\t\treturn this;\n\n\t}\n\n}\n\nconst vertex = \"void main() {\\n\\tgl_Position = vec4( position, 1.0 );\\n}\";\n\nconst fragment = \"uniform sampler2D shadow_pass;\\nuniform vec2 resolution;\\nuniform float radius;\\n#include \\nvoid main() {\\n\\tconst float samples = float( VSM_SAMPLES );\\n\\tfloat mean = 0.0;\\n\\tfloat squared_mean = 0.0;\\n\\tfloat uvStride = samples <= 1.0 ? 0.0 : 2.0 / ( samples - 1.0 );\\n\\tfloat uvStart = samples <= 1.0 ? 0.0 : - 1.0;\\n\\tfor ( float i = 0.0; i < samples; i ++ ) {\\n\\t\\tfloat uvOffset = uvStart + i * uvStride;\\n\\t\\t#ifdef HORIZONTAL_PASS\\n\\t\\t\\tvec2 distribution = unpackRGBATo2Half( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( uvOffset, 0.0 ) * radius ) / resolution ) );\\n\\t\\t\\tmean += distribution.x;\\n\\t\\t\\tsquared_mean += distribution.y * distribution.y + distribution.x * distribution.x;\\n\\t\\t#else\\n\\t\\t\\tfloat depth = unpackRGBAToDepth( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( 0.0, uvOffset ) * radius ) / resolution ) );\\n\\t\\t\\tmean += depth;\\n\\t\\t\\tsquared_mean += depth * depth;\\n\\t\\t#endif\\n\\t}\\n\\tmean = mean / samples;\\n\\tsquared_mean = squared_mean / samples;\\n\\tfloat std_dev = sqrt( squared_mean - mean * mean );\\n\\tgl_FragColor = pack2HalfToRGBA( vec2( mean, std_dev ) );\\n}\";\n\nfunction WebGLShadowMap( _renderer, _objects, _capabilities ) {\n\n\tlet _frustum = new Frustum();\n\n\tconst _shadowMapSize = new Vector2(),\n\t\t_viewportSize = new Vector2(),\n\n\t\t_viewport = new Vector4(),\n\n\t\t_depthMaterial = new MeshDepthMaterial( { depthPacking: RGBADepthPacking } ),\n\t\t_distanceMaterial = new MeshDistanceMaterial(),\n\n\t\t_materialCache = {},\n\n\t\t_maxTextureSize = _capabilities.maxTextureSize;\n\n\tconst shadowSide = { [ FrontSide ]: BackSide, [ BackSide ]: FrontSide, [ DoubleSide ]: DoubleSide };\n\n\tconst shadowMaterialVertical = new ShaderMaterial( {\n\t\tdefines: {\n\t\t\tVSM_SAMPLES: 8\n\t\t},\n\t\tuniforms: {\n\t\t\tshadow_pass: { value: null },\n\t\t\tresolution: { value: new Vector2() },\n\t\t\tradius: { value: 4.0 }\n\t\t},\n\n\t\tvertexShader: vertex,\n\t\tfragmentShader: fragment\n\n\t} );\n\n\tconst shadowMaterialHorizontal = shadowMaterialVertical.clone();\n\tshadowMaterialHorizontal.defines.HORIZONTAL_PASS = 1;\n\n\tconst fullScreenTri = new BufferGeometry();\n\tfullScreenTri.setAttribute(\n\t\t'position',\n\t\tnew BufferAttribute(\n\t\t\tnew Float32Array( [ - 1, - 1, 0.5, 3, - 1, 0.5, - 1, 3, 0.5 ] ),\n\t\t\t3\n\t\t)\n\t);\n\n\tconst fullScreenMesh = new Mesh( fullScreenTri, shadowMaterialVertical );\n\n\tconst scope = this;\n\n\tthis.enabled = false;\n\n\tthis.autoUpdate = true;\n\tthis.needsUpdate = false;\n\n\tthis.type = PCFShadowMap;\n\tlet _previousType = this.type;\n\n\tthis.render = function ( lights, scene, camera ) {\n\n\t\tif ( scope.enabled === false ) return;\n\t\tif ( scope.autoUpdate === false && scope.needsUpdate === false ) return;\n\n\t\tif ( lights.length === 0 ) return;\n\n\t\tconst currentRenderTarget = _renderer.getRenderTarget();\n\t\tconst activeCubeFace = _renderer.getActiveCubeFace();\n\t\tconst activeMipmapLevel = _renderer.getActiveMipmapLevel();\n\n\t\tconst _state = _renderer.state;\n\n\t\t// Set GL state for depth map.\n\t\t_state.setBlending( NoBlending );\n\t\t_state.buffers.color.setClear( 1, 1, 1, 1 );\n\t\t_state.buffers.depth.setTest( true );\n\t\t_state.setScissorTest( false );\n\n\t\t// check for shadow map type changes\n\n\t\tconst toVSM = ( _previousType !== VSMShadowMap && this.type === VSMShadowMap );\n\t\tconst fromVSM = ( _previousType === VSMShadowMap && this.type !== VSMShadowMap );\n\n\t\t// render depth map\n\n\t\tfor ( let i = 0, il = lights.length; i < il; i ++ ) {\n\n\t\t\tconst light = lights[ i ];\n\t\t\tconst shadow = light.shadow;\n\n\t\t\tif ( shadow === undefined ) {\n\n\t\t\t\tconsole.warn( 'THREE.WebGLShadowMap:', light, 'has no shadow.' );\n\t\t\t\tcontinue;\n\n\t\t\t}\n\n\t\t\tif ( shadow.autoUpdate === false && shadow.needsUpdate === false ) continue;\n\n\t\t\t_shadowMapSize.copy( shadow.mapSize );\n\n\t\t\tconst shadowFrameExtents = shadow.getFrameExtents();\n\n\t\t\t_shadowMapSize.multiply( shadowFrameExtents );\n\n\t\t\t_viewportSize.copy( shadow.mapSize );\n\n\t\t\tif ( _shadowMapSize.x > _maxTextureSize || _shadowMapSize.y > _maxTextureSize ) {\n\n\t\t\t\tif ( _shadowMapSize.x > _maxTextureSize ) {\n\n\t\t\t\t\t_viewportSize.x = Math.floor( _maxTextureSize / shadowFrameExtents.x );\n\t\t\t\t\t_shadowMapSize.x = _viewportSize.x * shadowFrameExtents.x;\n\t\t\t\t\tshadow.mapSize.x = _viewportSize.x;\n\n\t\t\t\t}\n\n\t\t\t\tif ( _shadowMapSize.y > _maxTextureSize ) {\n\n\t\t\t\t\t_viewportSize.y = Math.floor( _maxTextureSize / shadowFrameExtents.y );\n\t\t\t\t\t_shadowMapSize.y = _viewportSize.y * shadowFrameExtents.y;\n\t\t\t\t\tshadow.mapSize.y = _viewportSize.y;\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tif ( shadow.map === null || toVSM === true || fromVSM === true ) {\n\n\t\t\t\tconst pars = ( this.type !== VSMShadowMap ) ? { minFilter: NearestFilter, magFilter: NearestFilter } : {};\n\n\t\t\t\tif ( shadow.map !== null ) {\n\n\t\t\t\t\tshadow.map.dispose();\n\n\t\t\t\t}\n\n\t\t\t\tshadow.map = new WebGLRenderTarget( _shadowMapSize.x, _shadowMapSize.y, pars );\n\t\t\t\tshadow.map.texture.name = light.name + '.shadowMap';\n\n\t\t\t\tshadow.camera.updateProjectionMatrix();\n\n\t\t\t}\n\n\t\t\t_renderer.setRenderTarget( shadow.map );\n\t\t\t_renderer.clear();\n\n\t\t\tconst viewportCount = shadow.getViewportCount();\n\n\t\t\tfor ( let vp = 0; vp < viewportCount; vp ++ ) {\n\n\t\t\t\tconst viewport = shadow.getViewport( vp );\n\n\t\t\t\t_viewport.set(\n\t\t\t\t\t_viewportSize.x * viewport.x,\n\t\t\t\t\t_viewportSize.y * viewport.y,\n\t\t\t\t\t_viewportSize.x * viewport.z,\n\t\t\t\t\t_viewportSize.y * viewport.w\n\t\t\t\t);\n\n\t\t\t\t_state.viewport( _viewport );\n\n\t\t\t\tshadow.updateMatrices( light, vp );\n\n\t\t\t\t_frustum = shadow.getFrustum();\n\n\t\t\t\trenderObject( scene, camera, shadow.camera, light, this.type );\n\n\t\t\t}\n\n\t\t\t// do blur pass for VSM\n\n\t\t\tif ( shadow.isPointLightShadow !== true && this.type === VSMShadowMap ) {\n\n\t\t\t\tVSMPass( shadow, camera );\n\n\t\t\t}\n\n\t\t\tshadow.needsUpdate = false;\n\n\t\t}\n\n\t\t_previousType = this.type;\n\n\t\tscope.needsUpdate = false;\n\n\t\t_renderer.setRenderTarget( currentRenderTarget, activeCubeFace, activeMipmapLevel );\n\n\t};\n\n\tfunction VSMPass( shadow, camera ) {\n\n\t\tconst geometry = _objects.update( fullScreenMesh );\n\n\t\tif ( shadowMaterialVertical.defines.VSM_SAMPLES !== shadow.blurSamples ) {\n\n\t\t\tshadowMaterialVertical.defines.VSM_SAMPLES = shadow.blurSamples;\n\t\t\tshadowMaterialHorizontal.defines.VSM_SAMPLES = shadow.blurSamples;\n\n\t\t\tshadowMaterialVertical.needsUpdate = true;\n\t\t\tshadowMaterialHorizontal.needsUpdate = true;\n\n\t\t}\n\n\t\tif ( shadow.mapPass === null ) {\n\n\t\t\tshadow.mapPass = new WebGLRenderTarget( _shadowMapSize.x, _shadowMapSize.y );\n\n\t\t}\n\n\t\t// vertical pass\n\n\t\tshadowMaterialVertical.uniforms.shadow_pass.value = shadow.map.texture;\n\t\tshadowMaterialVertical.uniforms.resolution.value = shadow.mapSize;\n\t\tshadowMaterialVertical.uniforms.radius.value = shadow.radius;\n\t\t_renderer.setRenderTarget( shadow.mapPass );\n\t\t_renderer.clear();\n\t\t_renderer.renderBufferDirect( camera, null, geometry, shadowMaterialVertical, fullScreenMesh, null );\n\n\t\t// horizontal pass\n\n\t\tshadowMaterialHorizontal.uniforms.shadow_pass.value = shadow.mapPass.texture;\n\t\tshadowMaterialHorizontal.uniforms.resolution.value = shadow.mapSize;\n\t\tshadowMaterialHorizontal.uniforms.radius.value = shadow.radius;\n\t\t_renderer.setRenderTarget( shadow.map );\n\t\t_renderer.clear();\n\t\t_renderer.renderBufferDirect( camera, null, geometry, shadowMaterialHorizontal, fullScreenMesh, null );\n\n\t}\n\n\tfunction getDepthMaterial( object, material, light, type ) {\n\n\t\tlet result = null;\n\n\t\tconst customMaterial = ( light.isPointLight === true ) ? object.customDistanceMaterial : object.customDepthMaterial;\n\n\t\tif ( customMaterial !== undefined ) {\n\n\t\t\tresult = customMaterial;\n\n\t\t} else {\n\n\t\t\tresult = ( light.isPointLight === true ) ? _distanceMaterial : _depthMaterial;\n\n\t\t\tif ( ( _renderer.localClippingEnabled && material.clipShadows === true && Array.isArray( material.clippingPlanes ) && material.clippingPlanes.length !== 0 ) ||\n\t\t\t\t( material.displacementMap && material.displacementScale !== 0 ) ||\n\t\t\t\t( material.alphaMap && material.alphaTest > 0 ) ||\n\t\t\t\t( material.map && material.alphaTest > 0 ) ) {\n\n\t\t\t\t// in this case we need a unique material instance reflecting the\n\t\t\t\t// appropriate state\n\n\t\t\t\tconst keyA = result.uuid, keyB = material.uuid;\n\n\t\t\t\tlet materialsForVariant = _materialCache[ keyA ];\n\n\t\t\t\tif ( materialsForVariant === undefined ) {\n\n\t\t\t\t\tmaterialsForVariant = {};\n\t\t\t\t\t_materialCache[ keyA ] = materialsForVariant;\n\n\t\t\t\t}\n\n\t\t\t\tlet cachedMaterial = materialsForVariant[ keyB ];\n\n\t\t\t\tif ( cachedMaterial === undefined ) {\n\n\t\t\t\t\tcachedMaterial = result.clone();\n\t\t\t\t\tmaterialsForVariant[ keyB ] = cachedMaterial;\n\t\t\t\t\tmaterial.addEventListener( 'dispose', onMaterialDispose );\n\n\t\t\t\t}\n\n\t\t\t\tresult = cachedMaterial;\n\n\t\t\t}\n\n\t\t}\n\n\t\tresult.visible = material.visible;\n\t\tresult.wireframe = material.wireframe;\n\n\t\tif ( type === VSMShadowMap ) {\n\n\t\t\tresult.side = ( material.shadowSide !== null ) ? material.shadowSide : material.side;\n\n\t\t} else {\n\n\t\t\tresult.side = ( material.shadowSide !== null ) ? material.shadowSide : shadowSide[ material.side ];\n\n\t\t}\n\n\t\tresult.alphaMap = material.alphaMap;\n\t\tresult.alphaTest = material.alphaTest;\n\t\tresult.map = material.map;\n\n\t\tresult.clipShadows = material.clipShadows;\n\t\tresult.clippingPlanes = material.clippingPlanes;\n\t\tresult.clipIntersection = material.clipIntersection;\n\n\t\tresult.displacementMap = material.displacementMap;\n\t\tresult.displacementScale = material.displacementScale;\n\t\tresult.displacementBias = material.displacementBias;\n\n\t\tresult.wireframeLinewidth = material.wireframeLinewidth;\n\t\tresult.linewidth = material.linewidth;\n\n\t\tif ( light.isPointLight === true && result.isMeshDistanceMaterial === true ) {\n\n\t\t\tconst materialProperties = _renderer.properties.get( result );\n\t\t\tmaterialProperties.light = light;\n\n\t\t}\n\n\t\treturn result;\n\n\t}\n\n\tfunction renderObject( object, camera, shadowCamera, light, type ) {\n\n\t\tif ( object.visible === false ) return;\n\n\t\tconst visible = object.layers.test( camera.layers );\n\n\t\tif ( visible && ( object.isMesh || object.isLine || object.isPoints ) ) {\n\n\t\t\tif ( ( object.castShadow || ( object.receiveShadow && type === VSMShadowMap ) ) && ( ! object.frustumCulled || _frustum.intersectsObject( object ) ) ) {\n\n\t\t\t\tobject.modelViewMatrix.multiplyMatrices( shadowCamera.matrixWorldInverse, object.matrixWorld );\n\n\t\t\t\tconst geometry = _objects.update( object );\n\t\t\t\tconst material = object.material;\n\n\t\t\t\tif ( Array.isArray( material ) ) {\n\n\t\t\t\t\tconst groups = geometry.groups;\n\n\t\t\t\t\tfor ( let k = 0, kl = groups.length; k < kl; k ++ ) {\n\n\t\t\t\t\t\tconst group = groups[ k ];\n\t\t\t\t\t\tconst groupMaterial = material[ group.materialIndex ];\n\n\t\t\t\t\t\tif ( groupMaterial && groupMaterial.visible ) {\n\n\t\t\t\t\t\t\tconst depthMaterial = getDepthMaterial( object, groupMaterial, light, type );\n\n\t\t\t\t\t\t\tobject.onBeforeShadow( _renderer, object, camera, shadowCamera, geometry, depthMaterial, group );\n\n\t\t\t\t\t\t\t_renderer.renderBufferDirect( shadowCamera, null, geometry, depthMaterial, object, group );\n\n\t\t\t\t\t\t\tobject.onAfterShadow( _renderer, object, camera, shadowCamera, geometry, depthMaterial, group );\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}\n\n\t\t\t\t} else if ( material.visible ) {\n\n\t\t\t\t\tconst depthMaterial = getDepthMaterial( object, material, light, type );\n\n\t\t\t\t\tobject.onBeforeShadow( _renderer, object, camera, shadowCamera, geometry, depthMaterial, null );\n\n\t\t\t\t\t_renderer.renderBufferDirect( shadowCamera, null, geometry, depthMaterial, object, null );\n\n\t\t\t\t\tobject.onAfterShadow( _renderer, object, camera, shadowCamera, geometry, depthMaterial, null );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t\tconst children = object.children;\n\n\t\tfor ( let i = 0, l = children.length; i < l; i ++ ) {\n\n\t\t\trenderObject( children[ i ], camera, shadowCamera, light, type );\n\n\t\t}\n\n\t}\n\n\tfunction onMaterialDispose( event ) {\n\n\t\tconst material = event.target;\n\n\t\tmaterial.removeEventListener( 'dispose', onMaterialDispose );\n\n\t\t// make sure to remove the unique distance/depth materials used for shadow map rendering\n\n\t\tfor ( const id in _materialCache ) {\n\n\t\t\tconst cache = _materialCache[ id ];\n\n\t\t\tconst uuid = event.target.uuid;\n\n\t\t\tif ( uuid in cache ) {\n\n\t\t\t\tconst shadowMaterial = cache[ uuid ];\n\t\t\t\tshadowMaterial.dispose();\n\t\t\t\tdelete cache[ uuid ];\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n}\n\nfunction WebGLState( gl ) {\n\n\tfunction ColorBuffer() {\n\n\t\tlet locked = false;\n\n\t\tconst color = new Vector4();\n\t\tlet currentColorMask = null;\n\t\tconst currentColorClear = new Vector4( 0, 0, 0, 0 );\n\n\t\treturn {\n\n\t\t\tsetMask: function ( colorMask ) {\n\n\t\t\t\tif ( currentColorMask !== colorMask && ! locked ) {\n\n\t\t\t\t\tgl.colorMask( colorMask, colorMask, colorMask, colorMask );\n\t\t\t\t\tcurrentColorMask = colorMask;\n\n\t\t\t\t}\n\n\t\t\t},\n\n\t\t\tsetLocked: function ( lock ) {\n\n\t\t\t\tlocked = lock;\n\n\t\t\t},\n\n\t\t\tsetClear: function ( r, g, b, a, premultipliedAlpha ) {\n\n\t\t\t\tif ( premultipliedAlpha === true ) {\n\n\t\t\t\t\tr *= a; g *= a; b *= a;\n\n\t\t\t\t}\n\n\t\t\t\tcolor.set( r, g, b, a );\n\n\t\t\t\tif ( currentColorClear.equals( color ) === false ) {\n\n\t\t\t\t\tgl.clearColor( r, g, b, a );\n\t\t\t\t\tcurrentColorClear.copy( color );\n\n\t\t\t\t}\n\n\t\t\t},\n\n\t\t\treset: function () {\n\n\t\t\t\tlocked = false;\n\n\t\t\t\tcurrentColorMask = null;\n\t\t\t\tcurrentColorClear.set( - 1, 0, 0, 0 ); // set to invalid state\n\n\t\t\t}\n\n\t\t};\n\n\t}\n\n\tfunction DepthBuffer() {\n\n\t\tlet locked = false;\n\n\t\tlet currentDepthMask = null;\n\t\tlet currentDepthFunc = null;\n\t\tlet currentDepthClear = null;\n\n\t\treturn {\n\n\t\t\tsetTest: function ( depthTest ) {\n\n\t\t\t\tif ( depthTest ) {\n\n\t\t\t\t\tenable( gl.DEPTH_TEST );\n\n\t\t\t\t} else {\n\n\t\t\t\t\tdisable( gl.DEPTH_TEST );\n\n\t\t\t\t}\n\n\t\t\t},\n\n\t\t\tsetMask: function ( depthMask ) {\n\n\t\t\t\tif ( currentDepthMask !== depthMask && ! locked ) {\n\n\t\t\t\t\tgl.depthMask( depthMask );\n\t\t\t\t\tcurrentDepthMask = depthMask;\n\n\t\t\t\t}\n\n\t\t\t},\n\n\t\t\tsetFunc: function ( depthFunc ) {\n\n\t\t\t\tif ( currentDepthFunc !== depthFunc ) {\n\n\t\t\t\t\tswitch ( depthFunc ) {\n\n\t\t\t\t\t\tcase NeverDepth:\n\n\t\t\t\t\t\t\tgl.depthFunc( gl.NEVER );\n\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t\tcase AlwaysDepth:\n\n\t\t\t\t\t\t\tgl.depthFunc( gl.ALWAYS );\n\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t\tcase LessDepth:\n\n\t\t\t\t\t\t\tgl.depthFunc( gl.LESS );\n\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t\tcase LessEqualDepth:\n\n\t\t\t\t\t\t\tgl.depthFunc( gl.LEQUAL );\n\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t\tcase EqualDepth:\n\n\t\t\t\t\t\t\tgl.depthFunc( gl.EQUAL );\n\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t\tcase GreaterEqualDepth:\n\n\t\t\t\t\t\t\tgl.depthFunc( gl.GEQUAL );\n\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t\tcase GreaterDepth:\n\n\t\t\t\t\t\t\tgl.depthFunc( gl.GREATER );\n\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t\tcase NotEqualDepth:\n\n\t\t\t\t\t\t\tgl.depthFunc( gl.NOTEQUAL );\n\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t\tdefault:\n\n\t\t\t\t\t\t\tgl.depthFunc( gl.LEQUAL );\n\n\t\t\t\t\t}\n\n\t\t\t\t\tcurrentDepthFunc = depthFunc;\n\n\t\t\t\t}\n\n\t\t\t},\n\n\t\t\tsetLocked: function ( lock ) {\n\n\t\t\t\tlocked = lock;\n\n\t\t\t},\n\n\t\t\tsetClear: function ( depth ) {\n\n\t\t\t\tif ( currentDepthClear !== depth ) {\n\n\t\t\t\t\tgl.clearDepth( depth );\n\t\t\t\t\tcurrentDepthClear = depth;\n\n\t\t\t\t}\n\n\t\t\t},\n\n\t\t\treset: function () {\n\n\t\t\t\tlocked = false;\n\n\t\t\t\tcurrentDepthMask = null;\n\t\t\t\tcurrentDepthFunc = null;\n\t\t\t\tcurrentDepthClear = null;\n\n\t\t\t}\n\n\t\t};\n\n\t}\n\n\tfunction StencilBuffer() {\n\n\t\tlet locked = false;\n\n\t\tlet currentStencilMask = null;\n\t\tlet currentStencilFunc = null;\n\t\tlet currentStencilRef = null;\n\t\tlet currentStencilFuncMask = null;\n\t\tlet currentStencilFail = null;\n\t\tlet currentStencilZFail = null;\n\t\tlet currentStencilZPass = null;\n\t\tlet currentStencilClear = null;\n\n\t\treturn {\n\n\t\t\tsetTest: function ( stencilTest ) {\n\n\t\t\t\tif ( ! locked ) {\n\n\t\t\t\t\tif ( stencilTest ) {\n\n\t\t\t\t\t\tenable( gl.STENCIL_TEST );\n\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\tdisable( gl.STENCIL_TEST );\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t},\n\n\t\t\tsetMask: function ( stencilMask ) {\n\n\t\t\t\tif ( currentStencilMask !== stencilMask && ! locked ) {\n\n\t\t\t\t\tgl.stencilMask( stencilMask );\n\t\t\t\t\tcurrentStencilMask = stencilMask;\n\n\t\t\t\t}\n\n\t\t\t},\n\n\t\t\tsetFunc: function ( stencilFunc, stencilRef, stencilMask ) {\n\n\t\t\t\tif ( currentStencilFunc !== stencilFunc ||\n\t\t\t\t currentStencilRef !== stencilRef ||\n\t\t\t\t currentStencilFuncMask !== stencilMask ) {\n\n\t\t\t\t\tgl.stencilFunc( stencilFunc, stencilRef, stencilMask );\n\n\t\t\t\t\tcurrentStencilFunc = stencilFunc;\n\t\t\t\t\tcurrentStencilRef = stencilRef;\n\t\t\t\t\tcurrentStencilFuncMask = stencilMask;\n\n\t\t\t\t}\n\n\t\t\t},\n\n\t\t\tsetOp: function ( stencilFail, stencilZFail, stencilZPass ) {\n\n\t\t\t\tif ( currentStencilFail !== stencilFail ||\n\t\t\t\t currentStencilZFail !== stencilZFail ||\n\t\t\t\t currentStencilZPass !== stencilZPass ) {\n\n\t\t\t\t\tgl.stencilOp( stencilFail, stencilZFail, stencilZPass );\n\n\t\t\t\t\tcurrentStencilFail = stencilFail;\n\t\t\t\t\tcurrentStencilZFail = stencilZFail;\n\t\t\t\t\tcurrentStencilZPass = stencilZPass;\n\n\t\t\t\t}\n\n\t\t\t},\n\n\t\t\tsetLocked: function ( lock ) {\n\n\t\t\t\tlocked = lock;\n\n\t\t\t},\n\n\t\t\tsetClear: function ( stencil ) {\n\n\t\t\t\tif ( currentStencilClear !== stencil ) {\n\n\t\t\t\t\tgl.clearStencil( stencil );\n\t\t\t\t\tcurrentStencilClear = stencil;\n\n\t\t\t\t}\n\n\t\t\t},\n\n\t\t\treset: function () {\n\n\t\t\t\tlocked = false;\n\n\t\t\t\tcurrentStencilMask = null;\n\t\t\t\tcurrentStencilFunc = null;\n\t\t\t\tcurrentStencilRef = null;\n\t\t\t\tcurrentStencilFuncMask = null;\n\t\t\t\tcurrentStencilFail = null;\n\t\t\t\tcurrentStencilZFail = null;\n\t\t\t\tcurrentStencilZPass = null;\n\t\t\t\tcurrentStencilClear = null;\n\n\t\t\t}\n\n\t\t};\n\n\t}\n\n\t//\n\n\tconst colorBuffer = new ColorBuffer();\n\tconst depthBuffer = new DepthBuffer();\n\tconst stencilBuffer = new StencilBuffer();\n\n\tconst uboBindings = new WeakMap();\n\tconst uboProgramMap = new WeakMap();\n\n\tlet enabledCapabilities = {};\n\n\tlet currentBoundFramebuffers = {};\n\tlet currentDrawbuffers = new WeakMap();\n\tlet defaultDrawbuffers = [];\n\n\tlet currentProgram = null;\n\n\tlet currentBlendingEnabled = false;\n\tlet currentBlending = null;\n\tlet currentBlendEquation = null;\n\tlet currentBlendSrc = null;\n\tlet currentBlendDst = null;\n\tlet currentBlendEquationAlpha = null;\n\tlet currentBlendSrcAlpha = null;\n\tlet currentBlendDstAlpha = null;\n\tlet currentBlendColor = new Color( 0, 0, 0 );\n\tlet currentBlendAlpha = 0;\n\tlet currentPremultipledAlpha = false;\n\n\tlet currentFlipSided = null;\n\tlet currentCullFace = null;\n\n\tlet currentLineWidth = null;\n\n\tlet currentPolygonOffsetFactor = null;\n\tlet currentPolygonOffsetUnits = null;\n\n\tconst maxTextures = gl.getParameter( gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS );\n\n\tlet lineWidthAvailable = false;\n\tlet version = 0;\n\tconst glVersion = gl.getParameter( gl.VERSION );\n\n\tif ( glVersion.indexOf( 'WebGL' ) !== - 1 ) {\n\n\t\tversion = parseFloat( /^WebGL (\\d)/.exec( glVersion )[ 1 ] );\n\t\tlineWidthAvailable = ( version >= 1.0 );\n\n\t} else if ( glVersion.indexOf( 'OpenGL ES' ) !== - 1 ) {\n\n\t\tversion = parseFloat( /^OpenGL ES (\\d)/.exec( glVersion )[ 1 ] );\n\t\tlineWidthAvailable = ( version >= 2.0 );\n\n\t}\n\n\tlet currentTextureSlot = null;\n\tlet currentBoundTextures = {};\n\n\tconst scissorParam = gl.getParameter( gl.SCISSOR_BOX );\n\tconst viewportParam = gl.getParameter( gl.VIEWPORT );\n\n\tconst currentScissor = new Vector4().fromArray( scissorParam );\n\tconst currentViewport = new Vector4().fromArray( viewportParam );\n\n\tfunction createTexture( type, target, count, dimensions ) {\n\n\t\tconst data = new Uint8Array( 4 ); // 4 is required to match default unpack alignment of 4.\n\t\tconst texture = gl.createTexture();\n\n\t\tgl.bindTexture( type, texture );\n\t\tgl.texParameteri( type, gl.TEXTURE_MIN_FILTER, gl.NEAREST );\n\t\tgl.texParameteri( type, gl.TEXTURE_MAG_FILTER, gl.NEAREST );\n\n\t\tfor ( let i = 0; i < count; i ++ ) {\n\n\t\t\tif ( type === gl.TEXTURE_3D || type === gl.TEXTURE_2D_ARRAY ) {\n\n\t\t\t\tgl.texImage3D( target, 0, gl.RGBA, 1, 1, dimensions, 0, gl.RGBA, gl.UNSIGNED_BYTE, data );\n\n\t\t\t} else {\n\n\t\t\t\tgl.texImage2D( target + i, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, data );\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn texture;\n\n\t}\n\n\tconst emptyTextures = {};\n\temptyTextures[ gl.TEXTURE_2D ] = createTexture( gl.TEXTURE_2D, gl.TEXTURE_2D, 1 );\n\temptyTextures[ gl.TEXTURE_CUBE_MAP ] = createTexture( gl.TEXTURE_CUBE_MAP, gl.TEXTURE_CUBE_MAP_POSITIVE_X, 6 );\n\temptyTextures[ gl.TEXTURE_2D_ARRAY ] = createTexture( gl.TEXTURE_2D_ARRAY, gl.TEXTURE_2D_ARRAY, 1, 1 );\n\temptyTextures[ gl.TEXTURE_3D ] = createTexture( gl.TEXTURE_3D, gl.TEXTURE_3D, 1, 1 );\n\n\t// init\n\n\tcolorBuffer.setClear( 0, 0, 0, 1 );\n\tdepthBuffer.setClear( 1 );\n\tstencilBuffer.setClear( 0 );\n\n\tenable( gl.DEPTH_TEST );\n\tdepthBuffer.setFunc( LessEqualDepth );\n\n\tsetFlipSided( false );\n\tsetCullFace( CullFaceBack );\n\tenable( gl.CULL_FACE );\n\n\tsetBlending( NoBlending );\n\n\t//\n\n\tfunction enable( id ) {\n\n\t\tif ( enabledCapabilities[ id ] !== true ) {\n\n\t\t\tgl.enable( id );\n\t\t\tenabledCapabilities[ id ] = true;\n\n\t\t}\n\n\t}\n\n\tfunction disable( id ) {\n\n\t\tif ( enabledCapabilities[ id ] !== false ) {\n\n\t\t\tgl.disable( id );\n\t\t\tenabledCapabilities[ id ] = false;\n\n\t\t}\n\n\t}\n\n\tfunction bindFramebuffer( target, framebuffer ) {\n\n\t\tif ( currentBoundFramebuffers[ target ] !== framebuffer ) {\n\n\t\t\tgl.bindFramebuffer( target, framebuffer );\n\n\t\t\tcurrentBoundFramebuffers[ target ] = framebuffer;\n\n\t\t\t// gl.DRAW_FRAMEBUFFER is equivalent to gl.FRAMEBUFFER\n\n\t\t\tif ( target === gl.DRAW_FRAMEBUFFER ) {\n\n\t\t\t\tcurrentBoundFramebuffers[ gl.FRAMEBUFFER ] = framebuffer;\n\n\t\t\t}\n\n\t\t\tif ( target === gl.FRAMEBUFFER ) {\n\n\t\t\t\tcurrentBoundFramebuffers[ gl.DRAW_FRAMEBUFFER ] = framebuffer;\n\n\t\t\t}\n\n\t\t\treturn true;\n\n\t\t}\n\n\t\treturn false;\n\n\t}\n\n\tfunction drawBuffers( renderTarget, framebuffer ) {\n\n\t\tlet drawBuffers = defaultDrawbuffers;\n\n\t\tlet needsUpdate = false;\n\n\t\tif ( renderTarget ) {\n\n\t\t\tdrawBuffers = currentDrawbuffers.get( framebuffer );\n\n\t\t\tif ( drawBuffers === undefined ) {\n\n\t\t\t\tdrawBuffers = [];\n\t\t\t\tcurrentDrawbuffers.set( framebuffer, drawBuffers );\n\n\t\t\t}\n\n\t\t\tconst textures = renderTarget.textures;\n\n\t\t\tif ( drawBuffers.length !== textures.length || drawBuffers[ 0 ] !== gl.COLOR_ATTACHMENT0 ) {\n\n\t\t\t\tfor ( let i = 0, il = textures.length; i < il; i ++ ) {\n\n\t\t\t\t\tdrawBuffers[ i ] = gl.COLOR_ATTACHMENT0 + i;\n\n\t\t\t\t}\n\n\t\t\t\tdrawBuffers.length = textures.length;\n\n\t\t\t\tneedsUpdate = true;\n\n\t\t\t}\n\n\t\t} else {\n\n\t\t\tif ( drawBuffers[ 0 ] !== gl.BACK ) {\n\n\t\t\t\tdrawBuffers[ 0 ] = gl.BACK;\n\n\t\t\t\tneedsUpdate = true;\n\n\t\t\t}\n\n\t\t}\n\n\t\tif ( needsUpdate ) {\n\n\t\t\tgl.drawBuffers( drawBuffers );\n\n\t\t}\n\n\t}\n\n\tfunction useProgram( program ) {\n\n\t\tif ( currentProgram !== program ) {\n\n\t\t\tgl.useProgram( program );\n\n\t\t\tcurrentProgram = program;\n\n\t\t\treturn true;\n\n\t\t}\n\n\t\treturn false;\n\n\t}\n\n\tconst equationToGL = {\n\t\t[ AddEquation ]: gl.FUNC_ADD,\n\t\t[ SubtractEquation ]: gl.FUNC_SUBTRACT,\n\t\t[ ReverseSubtractEquation ]: gl.FUNC_REVERSE_SUBTRACT\n\t};\n\n\tequationToGL[ MinEquation ] = gl.MIN;\n\tequationToGL[ MaxEquation ] = gl.MAX;\n\n\tconst factorToGL = {\n\t\t[ ZeroFactor ]: gl.ZERO,\n\t\t[ OneFactor ]: gl.ONE,\n\t\t[ SrcColorFactor ]: gl.SRC_COLOR,\n\t\t[ SrcAlphaFactor ]: gl.SRC_ALPHA,\n\t\t[ SrcAlphaSaturateFactor ]: gl.SRC_ALPHA_SATURATE,\n\t\t[ DstColorFactor ]: gl.DST_COLOR,\n\t\t[ DstAlphaFactor ]: gl.DST_ALPHA,\n\t\t[ OneMinusSrcColorFactor ]: gl.ONE_MINUS_SRC_COLOR,\n\t\t[ OneMinusSrcAlphaFactor ]: gl.ONE_MINUS_SRC_ALPHA,\n\t\t[ OneMinusDstColorFactor ]: gl.ONE_MINUS_DST_COLOR,\n\t\t[ OneMinusDstAlphaFactor ]: gl.ONE_MINUS_DST_ALPHA,\n\t\t[ ConstantColorFactor ]: gl.CONSTANT_COLOR,\n\t\t[ OneMinusConstantColorFactor ]: gl.ONE_MINUS_CONSTANT_COLOR,\n\t\t[ ConstantAlphaFactor ]: gl.CONSTANT_ALPHA,\n\t\t[ OneMinusConstantAlphaFactor ]: gl.ONE_MINUS_CONSTANT_ALPHA\n\t};\n\n\tfunction setBlending( blending, blendEquation, blendSrc, blendDst, blendEquationAlpha, blendSrcAlpha, blendDstAlpha, blendColor, blendAlpha, premultipliedAlpha ) {\n\n\t\tif ( blending === NoBlending ) {\n\n\t\t\tif ( currentBlendingEnabled === true ) {\n\n\t\t\t\tdisable( gl.BLEND );\n\t\t\t\tcurrentBlendingEnabled = false;\n\n\t\t\t}\n\n\t\t\treturn;\n\n\t\t}\n\n\t\tif ( currentBlendingEnabled === false ) {\n\n\t\t\tenable( gl.BLEND );\n\t\t\tcurrentBlendingEnabled = true;\n\n\t\t}\n\n\t\tif ( blending !== CustomBlending ) {\n\n\t\t\tif ( blending !== currentBlending || premultipliedAlpha !== currentPremultipledAlpha ) {\n\n\t\t\t\tif ( currentBlendEquation !== AddEquation || currentBlendEquationAlpha !== AddEquation ) {\n\n\t\t\t\t\tgl.blendEquation( gl.FUNC_ADD );\n\n\t\t\t\t\tcurrentBlendEquation = AddEquation;\n\t\t\t\t\tcurrentBlendEquationAlpha = AddEquation;\n\n\t\t\t\t}\n\n\t\t\t\tif ( premultipliedAlpha ) {\n\n\t\t\t\t\tswitch ( blending ) {\n\n\t\t\t\t\t\tcase NormalBlending:\n\t\t\t\t\t\t\tgl.blendFuncSeparate( gl.ONE, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA );\n\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t\tcase AdditiveBlending:\n\t\t\t\t\t\t\tgl.blendFunc( gl.ONE, gl.ONE );\n\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t\tcase SubtractiveBlending:\n\t\t\t\t\t\t\tgl.blendFuncSeparate( gl.ZERO, gl.ONE_MINUS_SRC_COLOR, gl.ZERO, gl.ONE );\n\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t\tcase MultiplyBlending:\n\t\t\t\t\t\t\tgl.blendFuncSeparate( gl.ZERO, gl.SRC_COLOR, gl.ZERO, gl.SRC_ALPHA );\n\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t\tdefault:\n\t\t\t\t\t\t\tconsole.error( 'THREE.WebGLState: Invalid blending: ', blending );\n\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t}\n\n\t\t\t\t} else {\n\n\t\t\t\t\tswitch ( blending ) {\n\n\t\t\t\t\t\tcase NormalBlending:\n\t\t\t\t\t\t\tgl.blendFuncSeparate( gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA );\n\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t\tcase AdditiveBlending:\n\t\t\t\t\t\t\tgl.blendFunc( gl.SRC_ALPHA, gl.ONE );\n\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t\tcase SubtractiveBlending:\n\t\t\t\t\t\t\tgl.blendFuncSeparate( gl.ZERO, gl.ONE_MINUS_SRC_COLOR, gl.ZERO, gl.ONE );\n\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t\tcase MultiplyBlending:\n\t\t\t\t\t\t\tgl.blendFunc( gl.ZERO, gl.SRC_COLOR );\n\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t\tdefault:\n\t\t\t\t\t\t\tconsole.error( 'THREE.WebGLState: Invalid blending: ', blending );\n\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t\tcurrentBlendSrc = null;\n\t\t\t\tcurrentBlendDst = null;\n\t\t\t\tcurrentBlendSrcAlpha = null;\n\t\t\t\tcurrentBlendDstAlpha = null;\n\t\t\t\tcurrentBlendColor.set( 0, 0, 0 );\n\t\t\t\tcurrentBlendAlpha = 0;\n\n\t\t\t\tcurrentBlending = blending;\n\t\t\t\tcurrentPremultipledAlpha = premultipliedAlpha;\n\n\t\t\t}\n\n\t\t\treturn;\n\n\t\t}\n\n\t\t// custom blending\n\n\t\tblendEquationAlpha = blendEquationAlpha || blendEquation;\n\t\tblendSrcAlpha = blendSrcAlpha || blendSrc;\n\t\tblendDstAlpha = blendDstAlpha || blendDst;\n\n\t\tif ( blendEquation !== currentBlendEquation || blendEquationAlpha !== currentBlendEquationAlpha ) {\n\n\t\t\tgl.blendEquationSeparate( equationToGL[ blendEquation ], equationToGL[ blendEquationAlpha ] );\n\n\t\t\tcurrentBlendEquation = blendEquation;\n\t\t\tcurrentBlendEquationAlpha = blendEquationAlpha;\n\n\t\t}\n\n\t\tif ( blendSrc !== currentBlendSrc || blendDst !== currentBlendDst || blendSrcAlpha !== currentBlendSrcAlpha || blendDstAlpha !== currentBlendDstAlpha ) {\n\n\t\t\tgl.blendFuncSeparate( factorToGL[ blendSrc ], factorToGL[ blendDst ], factorToGL[ blendSrcAlpha ], factorToGL[ blendDstAlpha ] );\n\n\t\t\tcurrentBlendSrc = blendSrc;\n\t\t\tcurrentBlendDst = blendDst;\n\t\t\tcurrentBlendSrcAlpha = blendSrcAlpha;\n\t\t\tcurrentBlendDstAlpha = blendDstAlpha;\n\n\t\t}\n\n\t\tif ( blendColor.equals( currentBlendColor ) === false || blendAlpha !== currentBlendAlpha ) {\n\n\t\t\tgl.blendColor( blendColor.r, blendColor.g, blendColor.b, blendAlpha );\n\n\t\t\tcurrentBlendColor.copy( blendColor );\n\t\t\tcurrentBlendAlpha = blendAlpha;\n\n\t\t}\n\n\t\tcurrentBlending = blending;\n\t\tcurrentPremultipledAlpha = false;\n\n\t}\n\n\tfunction setMaterial( material, frontFaceCW ) {\n\n\t\tmaterial.side === DoubleSide\n\t\t\t? disable( gl.CULL_FACE )\n\t\t\t: enable( gl.CULL_FACE );\n\n\t\tlet flipSided = ( material.side === BackSide );\n\t\tif ( frontFaceCW ) flipSided = ! flipSided;\n\n\t\tsetFlipSided( flipSided );\n\n\t\t( material.blending === NormalBlending && material.transparent === false )\n\t\t\t? setBlending( NoBlending )\n\t\t\t: setBlending( material.blending, material.blendEquation, material.blendSrc, material.blendDst, material.blendEquationAlpha, material.blendSrcAlpha, material.blendDstAlpha, material.blendColor, material.blendAlpha, material.premultipliedAlpha );\n\n\t\tdepthBuffer.setFunc( material.depthFunc );\n\t\tdepthBuffer.setTest( material.depthTest );\n\t\tdepthBuffer.setMask( material.depthWrite );\n\t\tcolorBuffer.setMask( material.colorWrite );\n\n\t\tconst stencilWrite = material.stencilWrite;\n\t\tstencilBuffer.setTest( stencilWrite );\n\t\tif ( stencilWrite ) {\n\n\t\t\tstencilBuffer.setMask( material.stencilWriteMask );\n\t\t\tstencilBuffer.setFunc( material.stencilFunc, material.stencilRef, material.stencilFuncMask );\n\t\t\tstencilBuffer.setOp( material.stencilFail, material.stencilZFail, material.stencilZPass );\n\n\t\t}\n\n\t\tsetPolygonOffset( material.polygonOffset, material.polygonOffsetFactor, material.polygonOffsetUnits );\n\n\t\tmaterial.alphaToCoverage === true\n\t\t\t? enable( gl.SAMPLE_ALPHA_TO_COVERAGE )\n\t\t\t: disable( gl.SAMPLE_ALPHA_TO_COVERAGE );\n\n\t}\n\n\t//\n\n\tfunction setFlipSided( flipSided ) {\n\n\t\tif ( currentFlipSided !== flipSided ) {\n\n\t\t\tif ( flipSided ) {\n\n\t\t\t\tgl.frontFace( gl.CW );\n\n\t\t\t} else {\n\n\t\t\t\tgl.frontFace( gl.CCW );\n\n\t\t\t}\n\n\t\t\tcurrentFlipSided = flipSided;\n\n\t\t}\n\n\t}\n\n\tfunction setCullFace( cullFace ) {\n\n\t\tif ( cullFace !== CullFaceNone ) {\n\n\t\t\tenable( gl.CULL_FACE );\n\n\t\t\tif ( cullFace !== currentCullFace ) {\n\n\t\t\t\tif ( cullFace === CullFaceBack ) {\n\n\t\t\t\t\tgl.cullFace( gl.BACK );\n\n\t\t\t\t} else if ( cullFace === CullFaceFront ) {\n\n\t\t\t\t\tgl.cullFace( gl.FRONT );\n\n\t\t\t\t} else {\n\n\t\t\t\t\tgl.cullFace( gl.FRONT_AND_BACK );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t} else {\n\n\t\t\tdisable( gl.CULL_FACE );\n\n\t\t}\n\n\t\tcurrentCullFace = cullFace;\n\n\t}\n\n\tfunction setLineWidth( width ) {\n\n\t\tif ( width !== currentLineWidth ) {\n\n\t\t\tif ( lineWidthAvailable ) gl.lineWidth( width );\n\n\t\t\tcurrentLineWidth = width;\n\n\t\t}\n\n\t}\n\n\tfunction setPolygonOffset( polygonOffset, factor, units ) {\n\n\t\tif ( polygonOffset ) {\n\n\t\t\tenable( gl.POLYGON_OFFSET_FILL );\n\n\t\t\tif ( currentPolygonOffsetFactor !== factor || currentPolygonOffsetUnits !== units ) {\n\n\t\t\t\tgl.polygonOffset( factor, units );\n\n\t\t\t\tcurrentPolygonOffsetFactor = factor;\n\t\t\t\tcurrentPolygonOffsetUnits = units;\n\n\t\t\t}\n\n\t\t} else {\n\n\t\t\tdisable( gl.POLYGON_OFFSET_FILL );\n\n\t\t}\n\n\t}\n\n\tfunction setScissorTest( scissorTest ) {\n\n\t\tif ( scissorTest ) {\n\n\t\t\tenable( gl.SCISSOR_TEST );\n\n\t\t} else {\n\n\t\t\tdisable( gl.SCISSOR_TEST );\n\n\t\t}\n\n\t}\n\n\t// texture\n\n\tfunction activeTexture( webglSlot ) {\n\n\t\tif ( webglSlot === undefined ) webglSlot = gl.TEXTURE0 + maxTextures - 1;\n\n\t\tif ( currentTextureSlot !== webglSlot ) {\n\n\t\t\tgl.activeTexture( webglSlot );\n\t\t\tcurrentTextureSlot = webglSlot;\n\n\t\t}\n\n\t}\n\n\tfunction bindTexture( webglType, webglTexture, webglSlot ) {\n\n\t\tif ( webglSlot === undefined ) {\n\n\t\t\tif ( currentTextureSlot === null ) {\n\n\t\t\t\twebglSlot = gl.TEXTURE0 + maxTextures - 1;\n\n\t\t\t} else {\n\n\t\t\t\twebglSlot = currentTextureSlot;\n\n\t\t\t}\n\n\t\t}\n\n\t\tlet boundTexture = currentBoundTextures[ webglSlot ];\n\n\t\tif ( boundTexture === undefined ) {\n\n\t\t\tboundTexture = { type: undefined, texture: undefined };\n\t\t\tcurrentBoundTextures[ webglSlot ] = boundTexture;\n\n\t\t}\n\n\t\tif ( boundTexture.type !== webglType || boundTexture.texture !== webglTexture ) {\n\n\t\t\tif ( currentTextureSlot !== webglSlot ) {\n\n\t\t\t\tgl.activeTexture( webglSlot );\n\t\t\t\tcurrentTextureSlot = webglSlot;\n\n\t\t\t}\n\n\t\t\tgl.bindTexture( webglType, webglTexture || emptyTextures[ webglType ] );\n\n\t\t\tboundTexture.type = webglType;\n\t\t\tboundTexture.texture = webglTexture;\n\n\t\t}\n\n\t}\n\n\tfunction unbindTexture() {\n\n\t\tconst boundTexture = currentBoundTextures[ currentTextureSlot ];\n\n\t\tif ( boundTexture !== undefined && boundTexture.type !== undefined ) {\n\n\t\t\tgl.bindTexture( boundTexture.type, null );\n\n\t\t\tboundTexture.type = undefined;\n\t\t\tboundTexture.texture = undefined;\n\n\t\t}\n\n\t}\n\n\tfunction compressedTexImage2D() {\n\n\t\ttry {\n\n\t\t\tgl.compressedTexImage2D.apply( gl, arguments );\n\n\t\t} catch ( error ) {\n\n\t\t\tconsole.error( 'THREE.WebGLState:', error );\n\n\t\t}\n\n\t}\n\n\tfunction compressedTexImage3D() {\n\n\t\ttry {\n\n\t\t\tgl.compressedTexImage3D.apply( gl, arguments );\n\n\t\t} catch ( error ) {\n\n\t\t\tconsole.error( 'THREE.WebGLState:', error );\n\n\t\t}\n\n\t}\n\n\tfunction texSubImage2D() {\n\n\t\ttry {\n\n\t\t\tgl.texSubImage2D.apply( gl, arguments );\n\n\t\t} catch ( error ) {\n\n\t\t\tconsole.error( 'THREE.WebGLState:', error );\n\n\t\t}\n\n\t}\n\n\tfunction texSubImage3D() {\n\n\t\ttry {\n\n\t\t\tgl.texSubImage3D.apply( gl, arguments );\n\n\t\t} catch ( error ) {\n\n\t\t\tconsole.error( 'THREE.WebGLState:', error );\n\n\t\t}\n\n\t}\n\n\tfunction compressedTexSubImage2D() {\n\n\t\ttry {\n\n\t\t\tgl.compressedTexSubImage2D.apply( gl, arguments );\n\n\t\t} catch ( error ) {\n\n\t\t\tconsole.error( 'THREE.WebGLState:', error );\n\n\t\t}\n\n\t}\n\n\tfunction compressedTexSubImage3D() {\n\n\t\ttry {\n\n\t\t\tgl.compressedTexSubImage3D.apply( gl, arguments );\n\n\t\t} catch ( error ) {\n\n\t\t\tconsole.error( 'THREE.WebGLState:', error );\n\n\t\t}\n\n\t}\n\n\tfunction texStorage2D() {\n\n\t\ttry {\n\n\t\t\tgl.texStorage2D.apply( gl, arguments );\n\n\t\t} catch ( error ) {\n\n\t\t\tconsole.error( 'THREE.WebGLState:', error );\n\n\t\t}\n\n\t}\n\n\tfunction texStorage3D() {\n\n\t\ttry {\n\n\t\t\tgl.texStorage3D.apply( gl, arguments );\n\n\t\t} catch ( error ) {\n\n\t\t\tconsole.error( 'THREE.WebGLState:', error );\n\n\t\t}\n\n\t}\n\n\tfunction texImage2D() {\n\n\t\ttry {\n\n\t\t\tgl.texImage2D.apply( gl, arguments );\n\n\t\t} catch ( error ) {\n\n\t\t\tconsole.error( 'THREE.WebGLState:', error );\n\n\t\t}\n\n\t}\n\n\tfunction texImage3D() {\n\n\t\ttry {\n\n\t\t\tgl.texImage3D.apply( gl, arguments );\n\n\t\t} catch ( error ) {\n\n\t\t\tconsole.error( 'THREE.WebGLState:', error );\n\n\t\t}\n\n\t}\n\n\t//\n\n\tfunction scissor( scissor ) {\n\n\t\tif ( currentScissor.equals( scissor ) === false ) {\n\n\t\t\tgl.scissor( scissor.x, scissor.y, scissor.z, scissor.w );\n\t\t\tcurrentScissor.copy( scissor );\n\n\t\t}\n\n\t}\n\n\tfunction viewport( viewport ) {\n\n\t\tif ( currentViewport.equals( viewport ) === false ) {\n\n\t\t\tgl.viewport( viewport.x, viewport.y, viewport.z, viewport.w );\n\t\t\tcurrentViewport.copy( viewport );\n\n\t\t}\n\n\t}\n\n\tfunction updateUBOMapping( uniformsGroup, program ) {\n\n\t\tlet mapping = uboProgramMap.get( program );\n\n\t\tif ( mapping === undefined ) {\n\n\t\t\tmapping = new WeakMap();\n\n\t\t\tuboProgramMap.set( program, mapping );\n\n\t\t}\n\n\t\tlet blockIndex = mapping.get( uniformsGroup );\n\n\t\tif ( blockIndex === undefined ) {\n\n\t\t\tblockIndex = gl.getUniformBlockIndex( program, uniformsGroup.name );\n\n\t\t\tmapping.set( uniformsGroup, blockIndex );\n\n\t\t}\n\n\t}\n\n\tfunction uniformBlockBinding( uniformsGroup, program ) {\n\n\t\tconst mapping = uboProgramMap.get( program );\n\t\tconst blockIndex = mapping.get( uniformsGroup );\n\n\t\tif ( uboBindings.get( program ) !== blockIndex ) {\n\n\t\t\t// bind shader specific block index to global block point\n\t\t\tgl.uniformBlockBinding( program, blockIndex, uniformsGroup.__bindingPointIndex );\n\n\t\t\tuboBindings.set( program, blockIndex );\n\n\t\t}\n\n\t}\n\n\t//\n\n\tfunction reset() {\n\n\t\t// reset state\n\n\t\tgl.disable( gl.BLEND );\n\t\tgl.disable( gl.CULL_FACE );\n\t\tgl.disable( gl.DEPTH_TEST );\n\t\tgl.disable( gl.POLYGON_OFFSET_FILL );\n\t\tgl.disable( gl.SCISSOR_TEST );\n\t\tgl.disable( gl.STENCIL_TEST );\n\t\tgl.disable( gl.SAMPLE_ALPHA_TO_COVERAGE );\n\n\t\tgl.blendEquation( gl.FUNC_ADD );\n\t\tgl.blendFunc( gl.ONE, gl.ZERO );\n\t\tgl.blendFuncSeparate( gl.ONE, gl.ZERO, gl.ONE, gl.ZERO );\n\t\tgl.blendColor( 0, 0, 0, 0 );\n\n\t\tgl.colorMask( true, true, true, true );\n\t\tgl.clearColor( 0, 0, 0, 0 );\n\n\t\tgl.depthMask( true );\n\t\tgl.depthFunc( gl.LESS );\n\t\tgl.clearDepth( 1 );\n\n\t\tgl.stencilMask( 0xffffffff );\n\t\tgl.stencilFunc( gl.ALWAYS, 0, 0xffffffff );\n\t\tgl.stencilOp( gl.KEEP, gl.KEEP, gl.KEEP );\n\t\tgl.clearStencil( 0 );\n\n\t\tgl.cullFace( gl.BACK );\n\t\tgl.frontFace( gl.CCW );\n\n\t\tgl.polygonOffset( 0, 0 );\n\n\t\tgl.activeTexture( gl.TEXTURE0 );\n\n\t\tgl.bindFramebuffer( gl.FRAMEBUFFER, null );\n\t\tgl.bindFramebuffer( gl.DRAW_FRAMEBUFFER, null );\n\t\tgl.bindFramebuffer( gl.READ_FRAMEBUFFER, null );\n\n\t\tgl.useProgram( null );\n\n\t\tgl.lineWidth( 1 );\n\n\t\tgl.scissor( 0, 0, gl.canvas.width, gl.canvas.height );\n\t\tgl.viewport( 0, 0, gl.canvas.width, gl.canvas.height );\n\n\t\t// reset internals\n\n\t\tenabledCapabilities = {};\n\n\t\tcurrentTextureSlot = null;\n\t\tcurrentBoundTextures = {};\n\n\t\tcurrentBoundFramebuffers = {};\n\t\tcurrentDrawbuffers = new WeakMap();\n\t\tdefaultDrawbuffers = [];\n\n\t\tcurrentProgram = null;\n\n\t\tcurrentBlendingEnabled = false;\n\t\tcurrentBlending = null;\n\t\tcurrentBlendEquation = null;\n\t\tcurrentBlendSrc = null;\n\t\tcurrentBlendDst = null;\n\t\tcurrentBlendEquationAlpha = null;\n\t\tcurrentBlendSrcAlpha = null;\n\t\tcurrentBlendDstAlpha = null;\n\t\tcurrentBlendColor = new Color( 0, 0, 0 );\n\t\tcurrentBlendAlpha = 0;\n\t\tcurrentPremultipledAlpha = false;\n\n\t\tcurrentFlipSided = null;\n\t\tcurrentCullFace = null;\n\n\t\tcurrentLineWidth = null;\n\n\t\tcurrentPolygonOffsetFactor = null;\n\t\tcurrentPolygonOffsetUnits = null;\n\n\t\tcurrentScissor.set( 0, 0, gl.canvas.width, gl.canvas.height );\n\t\tcurrentViewport.set( 0, 0, gl.canvas.width, gl.canvas.height );\n\n\t\tcolorBuffer.reset();\n\t\tdepthBuffer.reset();\n\t\tstencilBuffer.reset();\n\n\t}\n\n\treturn {\n\n\t\tbuffers: {\n\t\t\tcolor: colorBuffer,\n\t\t\tdepth: depthBuffer,\n\t\t\tstencil: stencilBuffer\n\t\t},\n\n\t\tenable: enable,\n\t\tdisable: disable,\n\n\t\tbindFramebuffer: bindFramebuffer,\n\t\tdrawBuffers: drawBuffers,\n\n\t\tuseProgram: useProgram,\n\n\t\tsetBlending: setBlending,\n\t\tsetMaterial: setMaterial,\n\n\t\tsetFlipSided: setFlipSided,\n\t\tsetCullFace: setCullFace,\n\n\t\tsetLineWidth: setLineWidth,\n\t\tsetPolygonOffset: setPolygonOffset,\n\n\t\tsetScissorTest: setScissorTest,\n\n\t\tactiveTexture: activeTexture,\n\t\tbindTexture: bindTexture,\n\t\tunbindTexture: unbindTexture,\n\t\tcompressedTexImage2D: compressedTexImage2D,\n\t\tcompressedTexImage3D: compressedTexImage3D,\n\t\ttexImage2D: texImage2D,\n\t\ttexImage3D: texImage3D,\n\n\t\tupdateUBOMapping: updateUBOMapping,\n\t\tuniformBlockBinding: uniformBlockBinding,\n\n\t\ttexStorage2D: texStorage2D,\n\t\ttexStorage3D: texStorage3D,\n\t\ttexSubImage2D: texSubImage2D,\n\t\ttexSubImage3D: texSubImage3D,\n\t\tcompressedTexSubImage2D: compressedTexSubImage2D,\n\t\tcompressedTexSubImage3D: compressedTexSubImage3D,\n\n\t\tscissor: scissor,\n\t\tviewport: viewport,\n\n\t\treset: reset\n\n\t};\n\n}\n\nfunction WebGLTextures( _gl, extensions, state, properties, capabilities, utils, info ) {\n\n\tconst multisampledRTTExt = extensions.has( 'WEBGL_multisampled_render_to_texture' ) ? extensions.get( 'WEBGL_multisampled_render_to_texture' ) : null;\n\tconst supportsInvalidateFramebuffer = typeof navigator === 'undefined' ? false : /OculusBrowser/g.test( navigator.userAgent );\n\n\tconst _imageDimensions = new Vector2();\n\tconst _videoTextures = new WeakMap();\n\tlet _canvas;\n\n\tconst _sources = new WeakMap(); // maps WebglTexture objects to instances of Source\n\n\t// cordova iOS (as of 5.0) still uses UIWebView, which provides OffscreenCanvas,\n\t// also OffscreenCanvas.getContext(\"webgl\"), but not OffscreenCanvas.getContext(\"2d\")!\n\t// Some implementations may only implement OffscreenCanvas partially (e.g. lacking 2d).\n\n\tlet useOffscreenCanvas = false;\n\n\ttry {\n\n\t\tuseOffscreenCanvas = typeof OffscreenCanvas !== 'undefined'\n\t\t\t// eslint-disable-next-line compat/compat\n\t\t\t&& ( new OffscreenCanvas( 1, 1 ).getContext( '2d' ) ) !== null;\n\n\t} catch ( err ) {\n\n\t\t// Ignore any errors\n\n\t}\n\n\tfunction createCanvas( width, height ) {\n\n\t\t// Use OffscreenCanvas when available. Specially needed in web workers\n\n\t\treturn useOffscreenCanvas ?\n\t\t\t// eslint-disable-next-line compat/compat\n\t\t\tnew OffscreenCanvas( width, height ) : createElementNS( 'canvas' );\n\n\t}\n\n\tfunction resizeImage( image, needsNewCanvas, maxSize ) {\n\n\t\tlet scale = 1;\n\n\t\tconst dimensions = getDimensions( image );\n\n\t\t// handle case if texture exceeds max size\n\n\t\tif ( dimensions.width > maxSize || dimensions.height > maxSize ) {\n\n\t\t\tscale = maxSize / Math.max( dimensions.width, dimensions.height );\n\n\t\t}\n\n\t\t// only perform resize if necessary\n\n\t\tif ( scale < 1 ) {\n\n\t\t\t// only perform resize for certain image types\n\n\t\t\tif ( ( typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement ) ||\n\t\t\t\t( typeof HTMLCanvasElement !== 'undefined' && image instanceof HTMLCanvasElement ) ||\n\t\t\t\t( typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap ) ||\n\t\t\t\t( typeof VideoFrame !== 'undefined' && image instanceof VideoFrame ) ) {\n\n\t\t\t\tconst width = Math.floor( scale * dimensions.width );\n\t\t\t\tconst height = Math.floor( scale * dimensions.height );\n\n\t\t\t\tif ( _canvas === undefined ) _canvas = createCanvas( width, height );\n\n\t\t\t\t// cube textures can't reuse the same canvas\n\n\t\t\t\tconst canvas = needsNewCanvas ? createCanvas( width, height ) : _canvas;\n\n\t\t\t\tcanvas.width = width;\n\t\t\t\tcanvas.height = height;\n\n\t\t\t\tconst context = canvas.getContext( '2d' );\n\t\t\t\tcontext.drawImage( image, 0, 0, width, height );\n\n\t\t\t\tconsole.warn( 'THREE.WebGLRenderer: Texture has been resized from (' + dimensions.width + 'x' + dimensions.height + ') to (' + width + 'x' + height + ').' );\n\n\t\t\t\treturn canvas;\n\n\t\t\t} else {\n\n\t\t\t\tif ( 'data' in image ) {\n\n\t\t\t\t\tconsole.warn( 'THREE.WebGLRenderer: Image in DataTexture is too big (' + dimensions.width + 'x' + dimensions.height + ').' );\n\n\t\t\t\t}\n\n\t\t\t\treturn image;\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn image;\n\n\t}\n\n\tfunction textureNeedsGenerateMipmaps( texture ) {\n\n\t\treturn texture.generateMipmaps && texture.minFilter !== NearestFilter && texture.minFilter !== LinearFilter;\n\n\t}\n\n\tfunction generateMipmap( target ) {\n\n\t\t_gl.generateMipmap( target );\n\n\t}\n\n\tfunction getInternalFormat( internalFormatName, glFormat, glType, colorSpace, forceLinearTransfer = false ) {\n\n\t\tif ( internalFormatName !== null ) {\n\n\t\t\tif ( _gl[ internalFormatName ] !== undefined ) return _gl[ internalFormatName ];\n\n\t\t\tconsole.warn( 'THREE.WebGLRenderer: Attempt to use non-existing WebGL internal format \\'' + internalFormatName + '\\'' );\n\n\t\t}\n\n\t\tlet internalFormat = glFormat;\n\n\t\tif ( glFormat === _gl.RED ) {\n\n\t\t\tif ( glType === _gl.FLOAT ) internalFormat = _gl.R32F;\n\t\t\tif ( glType === _gl.HALF_FLOAT ) internalFormat = _gl.R16F;\n\t\t\tif ( glType === _gl.UNSIGNED_BYTE ) internalFormat = _gl.R8;\n\n\t\t}\n\n\t\tif ( glFormat === _gl.RED_INTEGER ) {\n\n\t\t\tif ( glType === _gl.UNSIGNED_BYTE ) internalFormat = _gl.R8UI;\n\t\t\tif ( glType === _gl.UNSIGNED_SHORT ) internalFormat = _gl.R16UI;\n\t\t\tif ( glType === _gl.UNSIGNED_INT ) internalFormat = _gl.R32UI;\n\t\t\tif ( glType === _gl.BYTE ) internalFormat = _gl.R8I;\n\t\t\tif ( glType === _gl.SHORT ) internalFormat = _gl.R16I;\n\t\t\tif ( glType === _gl.INT ) internalFormat = _gl.R32I;\n\n\t\t}\n\n\t\tif ( glFormat === _gl.RG ) {\n\n\t\t\tif ( glType === _gl.FLOAT ) internalFormat = _gl.RG32F;\n\t\t\tif ( glType === _gl.HALF_FLOAT ) internalFormat = _gl.RG16F;\n\t\t\tif ( glType === _gl.UNSIGNED_BYTE ) internalFormat = _gl.RG8;\n\n\t\t}\n\n\t\tif ( glFormat === _gl.RG_INTEGER ) {\n\n\t\t\tif ( glType === _gl.UNSIGNED_BYTE ) internalFormat = _gl.RG8UI;\n\t\t\tif ( glType === _gl.UNSIGNED_SHORT ) internalFormat = _gl.RG16UI;\n\t\t\tif ( glType === _gl.UNSIGNED_INT ) internalFormat = _gl.RG32UI;\n\t\t\tif ( glType === _gl.BYTE ) internalFormat = _gl.RG8I;\n\t\t\tif ( glType === _gl.SHORT ) internalFormat = _gl.RG16I;\n\t\t\tif ( glType === _gl.INT ) internalFormat = _gl.RG32I;\n\n\t\t}\n\n\t\tif ( glFormat === _gl.RGB ) {\n\n\t\t\tif ( glType === _gl.UNSIGNED_INT_5_9_9_9_REV ) internalFormat = _gl.RGB9_E5;\n\n\t\t}\n\n\t\tif ( glFormat === _gl.RGBA ) {\n\n\t\t\tconst transfer = forceLinearTransfer ? LinearTransfer : ColorManagement.getTransfer( colorSpace );\n\n\t\t\tif ( glType === _gl.FLOAT ) internalFormat = _gl.RGBA32F;\n\t\t\tif ( glType === _gl.HALF_FLOAT ) internalFormat = _gl.RGBA16F;\n\t\t\tif ( glType === _gl.UNSIGNED_BYTE ) internalFormat = ( transfer === SRGBTransfer ) ? _gl.SRGB8_ALPHA8 : _gl.RGBA8;\n\t\t\tif ( glType === _gl.UNSIGNED_SHORT_4_4_4_4 ) internalFormat = _gl.RGBA4;\n\t\t\tif ( glType === _gl.UNSIGNED_SHORT_5_5_5_1 ) internalFormat = _gl.RGB5_A1;\n\n\t\t}\n\n\t\tif ( internalFormat === _gl.R16F || internalFormat === _gl.R32F ||\n\t\t\tinternalFormat === _gl.RG16F || internalFormat === _gl.RG32F ||\n\t\t\tinternalFormat === _gl.RGBA16F || internalFormat === _gl.RGBA32F ) {\n\n\t\t\textensions.get( 'EXT_color_buffer_float' );\n\n\t\t}\n\n\t\treturn internalFormat;\n\n\t}\n\n\tfunction getMipLevels( texture, image ) {\n\n\t\tif ( textureNeedsGenerateMipmaps( texture ) === true || ( texture.isFramebufferTexture && texture.minFilter !== NearestFilter && texture.minFilter !== LinearFilter ) ) {\n\n\t\t\treturn Math.log2( Math.max( image.width, image.height ) ) + 1;\n\n\t\t} else if ( texture.mipmaps !== undefined && texture.mipmaps.length > 0 ) {\n\n\t\t\t// user-defined mipmaps\n\n\t\t\treturn texture.mipmaps.length;\n\n\t\t} else if ( texture.isCompressedTexture && Array.isArray( texture.image ) ) {\n\n\t\t\treturn image.mipmaps.length;\n\n\t\t} else {\n\n\t\t\t// texture without mipmaps (only base level)\n\n\t\t\treturn 1;\n\n\t\t}\n\n\t}\n\n\t//\n\n\tfunction onTextureDispose( event ) {\n\n\t\tconst texture = event.target;\n\n\t\ttexture.removeEventListener( 'dispose', onTextureDispose );\n\n\t\tdeallocateTexture( texture );\n\n\t\tif ( texture.isVideoTexture ) {\n\n\t\t\t_videoTextures.delete( texture );\n\n\t\t}\n\n\t}\n\n\tfunction onRenderTargetDispose( event ) {\n\n\t\tconst renderTarget = event.target;\n\n\t\trenderTarget.removeEventListener( 'dispose', onRenderTargetDispose );\n\n\t\tdeallocateRenderTarget( renderTarget );\n\n\t}\n\n\t//\n\n\tfunction deallocateTexture( texture ) {\n\n\t\tconst textureProperties = properties.get( texture );\n\n\t\tif ( textureProperties.__webglInit === undefined ) return;\n\n\t\t// check if it's necessary to remove the WebGLTexture object\n\n\t\tconst source = texture.source;\n\t\tconst webglTextures = _sources.get( source );\n\n\t\tif ( webglTextures ) {\n\n\t\t\tconst webglTexture = webglTextures[ textureProperties.__cacheKey ];\n\t\t\twebglTexture.usedTimes --;\n\n\t\t\t// the WebGLTexture object is not used anymore, remove it\n\n\t\t\tif ( webglTexture.usedTimes === 0 ) {\n\n\t\t\t\tdeleteTexture( texture );\n\n\t\t\t}\n\n\t\t\t// remove the weak map entry if no WebGLTexture uses the source anymore\n\n\t\t\tif ( Object.keys( webglTextures ).length === 0 ) {\n\n\t\t\t\t_sources.delete( source );\n\n\t\t\t}\n\n\t\t}\n\n\t\tproperties.remove( texture );\n\n\t}\n\n\tfunction deleteTexture( texture ) {\n\n\t\tconst textureProperties = properties.get( texture );\n\t\t_gl.deleteTexture( textureProperties.__webglTexture );\n\n\t\tconst source = texture.source;\n\t\tconst webglTextures = _sources.get( source );\n\t\tdelete webglTextures[ textureProperties.__cacheKey ];\n\n\t\tinfo.memory.textures --;\n\n\t}\n\n\tfunction deallocateRenderTarget( renderTarget ) {\n\n\t\tconst renderTargetProperties = properties.get( renderTarget );\n\n\t\tif ( renderTarget.depthTexture ) {\n\n\t\t\trenderTarget.depthTexture.dispose();\n\n\t\t}\n\n\t\tif ( renderTarget.isWebGLCubeRenderTarget ) {\n\n\t\t\tfor ( let i = 0; i < 6; i ++ ) {\n\n\t\t\t\tif ( Array.isArray( renderTargetProperties.__webglFramebuffer[ i ] ) ) {\n\n\t\t\t\t\tfor ( let level = 0; level < renderTargetProperties.__webglFramebuffer[ i ].length; level ++ ) _gl.deleteFramebuffer( renderTargetProperties.__webglFramebuffer[ i ][ level ] );\n\n\t\t\t\t} else {\n\n\t\t\t\t\t_gl.deleteFramebuffer( renderTargetProperties.__webglFramebuffer[ i ] );\n\n\t\t\t\t}\n\n\t\t\t\tif ( renderTargetProperties.__webglDepthbuffer ) _gl.deleteRenderbuffer( renderTargetProperties.__webglDepthbuffer[ i ] );\n\n\t\t\t}\n\n\t\t} else {\n\n\t\t\tif ( Array.isArray( renderTargetProperties.__webglFramebuffer ) ) {\n\n\t\t\t\tfor ( let level = 0; level < renderTargetProperties.__webglFramebuffer.length; level ++ ) _gl.deleteFramebuffer( renderTargetProperties.__webglFramebuffer[ level ] );\n\n\t\t\t} else {\n\n\t\t\t\t_gl.deleteFramebuffer( renderTargetProperties.__webglFramebuffer );\n\n\t\t\t}\n\n\t\t\tif ( renderTargetProperties.__webglDepthbuffer ) _gl.deleteRenderbuffer( renderTargetProperties.__webglDepthbuffer );\n\t\t\tif ( renderTargetProperties.__webglMultisampledFramebuffer ) _gl.deleteFramebuffer( renderTargetProperties.__webglMultisampledFramebuffer );\n\n\t\t\tif ( renderTargetProperties.__webglColorRenderbuffer ) {\n\n\t\t\t\tfor ( let i = 0; i < renderTargetProperties.__webglColorRenderbuffer.length; i ++ ) {\n\n\t\t\t\t\tif ( renderTargetProperties.__webglColorRenderbuffer[ i ] ) _gl.deleteRenderbuffer( renderTargetProperties.__webglColorRenderbuffer[ i ] );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tif ( renderTargetProperties.__webglDepthRenderbuffer ) _gl.deleteRenderbuffer( renderTargetProperties.__webglDepthRenderbuffer );\n\n\t\t}\n\n\t\tconst textures = renderTarget.textures;\n\n\t\tfor ( let i = 0, il = textures.length; i < il; i ++ ) {\n\n\t\t\tconst attachmentProperties = properties.get( textures[ i ] );\n\n\t\t\tif ( attachmentProperties.__webglTexture ) {\n\n\t\t\t\t_gl.deleteTexture( attachmentProperties.__webglTexture );\n\n\t\t\t\tinfo.memory.textures --;\n\n\t\t\t}\n\n\t\t\tproperties.remove( textures[ i ] );\n\n\t\t}\n\n\t\tproperties.remove( renderTarget );\n\n\t}\n\n\t//\n\n\tlet textureUnits = 0;\n\n\tfunction resetTextureUnits() {\n\n\t\ttextureUnits = 0;\n\n\t}\n\n\tfunction allocateTextureUnit() {\n\n\t\tconst textureUnit = textureUnits;\n\n\t\tif ( textureUnit >= capabilities.maxTextures ) {\n\n\t\t\tconsole.warn( 'THREE.WebGLTextures: Trying to use ' + textureUnit + ' texture units while this GPU supports only ' + capabilities.maxTextures );\n\n\t\t}\n\n\t\ttextureUnits += 1;\n\n\t\treturn textureUnit;\n\n\t}\n\n\tfunction getTextureCacheKey( texture ) {\n\n\t\tconst array = [];\n\n\t\tarray.push( texture.wrapS );\n\t\tarray.push( texture.wrapT );\n\t\tarray.push( texture.wrapR || 0 );\n\t\tarray.push( texture.magFilter );\n\t\tarray.push( texture.minFilter );\n\t\tarray.push( texture.anisotropy );\n\t\tarray.push( texture.internalFormat );\n\t\tarray.push( texture.format );\n\t\tarray.push( texture.type );\n\t\tarray.push( texture.generateMipmaps );\n\t\tarray.push( texture.premultiplyAlpha );\n\t\tarray.push( texture.flipY );\n\t\tarray.push( texture.unpackAlignment );\n\t\tarray.push( texture.colorSpace );\n\n\t\treturn array.join();\n\n\t}\n\n\t//\n\n\tfunction setTexture2D( texture, slot ) {\n\n\t\tconst textureProperties = properties.get( texture );\n\n\t\tif ( texture.isVideoTexture ) updateVideoTexture( texture );\n\n\t\tif ( texture.isRenderTargetTexture === false && texture.version > 0 && textureProperties.__version !== texture.version ) {\n\n\t\t\tconst image = texture.image;\n\n\t\t\tif ( image === null ) {\n\n\t\t\t\tconsole.warn( 'THREE.WebGLRenderer: Texture marked for update but no image data found.' );\n\n\t\t\t} else if ( image.complete === false ) {\n\n\t\t\t\tconsole.warn( 'THREE.WebGLRenderer: Texture marked for update but image is incomplete' );\n\n\t\t\t} else {\n\n\t\t\t\tuploadTexture( textureProperties, texture, slot );\n\t\t\t\treturn;\n\n\t\t\t}\n\n\t\t}\n\n\t\tstate.bindTexture( _gl.TEXTURE_2D, textureProperties.__webglTexture, _gl.TEXTURE0 + slot );\n\n\t}\n\n\tfunction setTexture2DArray( texture, slot ) {\n\n\t\tconst textureProperties = properties.get( texture );\n\n\t\tif ( texture.version > 0 && textureProperties.__version !== texture.version ) {\n\n\t\t\tuploadTexture( textureProperties, texture, slot );\n\t\t\treturn;\n\n\t\t}\n\n\t\tstate.bindTexture( _gl.TEXTURE_2D_ARRAY, textureProperties.__webglTexture, _gl.TEXTURE0 + slot );\n\n\t}\n\n\tfunction setTexture3D( texture, slot ) {\n\n\t\tconst textureProperties = properties.get( texture );\n\n\t\tif ( texture.version > 0 && textureProperties.__version !== texture.version ) {\n\n\t\t\tuploadTexture( textureProperties, texture, slot );\n\t\t\treturn;\n\n\t\t}\n\n\t\tstate.bindTexture( _gl.TEXTURE_3D, textureProperties.__webglTexture, _gl.TEXTURE0 + slot );\n\n\t}\n\n\tfunction setTextureCube( texture, slot ) {\n\n\t\tconst textureProperties = properties.get( texture );\n\n\t\tif ( texture.version > 0 && textureProperties.__version !== texture.version ) {\n\n\t\t\tuploadCubeTexture( textureProperties, texture, slot );\n\t\t\treturn;\n\n\t\t}\n\n\t\tstate.bindTexture( _gl.TEXTURE_CUBE_MAP, textureProperties.__webglTexture, _gl.TEXTURE0 + slot );\n\n\t}\n\n\tconst wrappingToGL = {\n\t\t[ RepeatWrapping ]: _gl.REPEAT,\n\t\t[ ClampToEdgeWrapping ]: _gl.CLAMP_TO_EDGE,\n\t\t[ MirroredRepeatWrapping ]: _gl.MIRRORED_REPEAT\n\t};\n\n\tconst filterToGL = {\n\t\t[ NearestFilter ]: _gl.NEAREST,\n\t\t[ NearestMipmapNearestFilter ]: _gl.NEAREST_MIPMAP_NEAREST,\n\t\t[ NearestMipmapLinearFilter ]: _gl.NEAREST_MIPMAP_LINEAR,\n\n\t\t[ LinearFilter ]: _gl.LINEAR,\n\t\t[ LinearMipmapNearestFilter ]: _gl.LINEAR_MIPMAP_NEAREST,\n\t\t[ LinearMipmapLinearFilter ]: _gl.LINEAR_MIPMAP_LINEAR\n\t};\n\n\tconst compareToGL = {\n\t\t[ NeverCompare ]: _gl.NEVER,\n\t\t[ AlwaysCompare ]: _gl.ALWAYS,\n\t\t[ LessCompare ]: _gl.LESS,\n\t\t[ LessEqualCompare ]: _gl.LEQUAL,\n\t\t[ EqualCompare ]: _gl.EQUAL,\n\t\t[ GreaterEqualCompare ]: _gl.GEQUAL,\n\t\t[ GreaterCompare ]: _gl.GREATER,\n\t\t[ NotEqualCompare ]: _gl.NOTEQUAL\n\t};\n\n\tfunction setTextureParameters( textureType, texture ) {\n\n\t\tif ( texture.type === FloatType && extensions.has( 'OES_texture_float_linear' ) === false &&\n\t\t\t( texture.magFilter === LinearFilter || texture.magFilter === LinearMipmapNearestFilter || texture.magFilter === NearestMipmapLinearFilter || texture.magFilter === LinearMipmapLinearFilter ||\n\t\t\ttexture.minFilter === LinearFilter || texture.minFilter === LinearMipmapNearestFilter || texture.minFilter === NearestMipmapLinearFilter || texture.minFilter === LinearMipmapLinearFilter ) ) {\n\n\t\t\tconsole.warn( 'THREE.WebGLRenderer: Unable to use linear filtering with floating point textures. OES_texture_float_linear not supported on this device.' );\n\n\t\t}\n\n\t\t_gl.texParameteri( textureType, _gl.TEXTURE_WRAP_S, wrappingToGL[ texture.wrapS ] );\n\t\t_gl.texParameteri( textureType, _gl.TEXTURE_WRAP_T, wrappingToGL[ texture.wrapT ] );\n\n\t\tif ( textureType === _gl.TEXTURE_3D || textureType === _gl.TEXTURE_2D_ARRAY ) {\n\n\t\t\t_gl.texParameteri( textureType, _gl.TEXTURE_WRAP_R, wrappingToGL[ texture.wrapR ] );\n\n\t\t}\n\n\t\t_gl.texParameteri( textureType, _gl.TEXTURE_MAG_FILTER, filterToGL[ texture.magFilter ] );\n\t\t_gl.texParameteri( textureType, _gl.TEXTURE_MIN_FILTER, filterToGL[ texture.minFilter ] );\n\n\t\tif ( texture.compareFunction ) {\n\n\t\t\t_gl.texParameteri( textureType, _gl.TEXTURE_COMPARE_MODE, _gl.COMPARE_REF_TO_TEXTURE );\n\t\t\t_gl.texParameteri( textureType, _gl.TEXTURE_COMPARE_FUNC, compareToGL[ texture.compareFunction ] );\n\n\t\t}\n\n\t\tif ( extensions.has( 'EXT_texture_filter_anisotropic' ) === true ) {\n\n\t\t\tif ( texture.magFilter === NearestFilter ) return;\n\t\t\tif ( texture.minFilter !== NearestMipmapLinearFilter && texture.minFilter !== LinearMipmapLinearFilter ) return;\n\t\t\tif ( texture.type === FloatType && extensions.has( 'OES_texture_float_linear' ) === false ) return; // verify extension\n\n\t\t\tif ( texture.anisotropy > 1 || properties.get( texture ).__currentAnisotropy ) {\n\n\t\t\t\tconst extension = extensions.get( 'EXT_texture_filter_anisotropic' );\n\t\t\t\t_gl.texParameterf( textureType, extension.TEXTURE_MAX_ANISOTROPY_EXT, Math.min( texture.anisotropy, capabilities.getMaxAnisotropy() ) );\n\t\t\t\tproperties.get( texture ).__currentAnisotropy = texture.anisotropy;\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n\tfunction initTexture( textureProperties, texture ) {\n\n\t\tlet forceUpload = false;\n\n\t\tif ( textureProperties.__webglInit === undefined ) {\n\n\t\t\ttextureProperties.__webglInit = true;\n\n\t\t\ttexture.addEventListener( 'dispose', onTextureDispose );\n\n\t\t}\n\n\t\t// create Source <-> WebGLTextures mapping if necessary\n\n\t\tconst source = texture.source;\n\t\tlet webglTextures = _sources.get( source );\n\n\t\tif ( webglTextures === undefined ) {\n\n\t\t\twebglTextures = {};\n\t\t\t_sources.set( source, webglTextures );\n\n\t\t}\n\n\t\t// check if there is already a WebGLTexture object for the given texture parameters\n\n\t\tconst textureCacheKey = getTextureCacheKey( texture );\n\n\t\tif ( textureCacheKey !== textureProperties.__cacheKey ) {\n\n\t\t\t// if not, create a new instance of WebGLTexture\n\n\t\t\tif ( webglTextures[ textureCacheKey ] === undefined ) {\n\n\t\t\t\t// create new entry\n\n\t\t\t\twebglTextures[ textureCacheKey ] = {\n\t\t\t\t\ttexture: _gl.createTexture(),\n\t\t\t\t\tusedTimes: 0\n\t\t\t\t};\n\n\t\t\t\tinfo.memory.textures ++;\n\n\t\t\t\t// when a new instance of WebGLTexture was created, a texture upload is required\n\t\t\t\t// even if the image contents are identical\n\n\t\t\t\tforceUpload = true;\n\n\t\t\t}\n\n\t\t\twebglTextures[ textureCacheKey ].usedTimes ++;\n\n\t\t\t// every time the texture cache key changes, it's necessary to check if an instance of\n\t\t\t// WebGLTexture can be deleted in order to avoid a memory leak.\n\n\t\t\tconst webglTexture = webglTextures[ textureProperties.__cacheKey ];\n\n\t\t\tif ( webglTexture !== undefined ) {\n\n\t\t\t\twebglTextures[ textureProperties.__cacheKey ].usedTimes --;\n\n\t\t\t\tif ( webglTexture.usedTimes === 0 ) {\n\n\t\t\t\t\tdeleteTexture( texture );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\t// store references to cache key and WebGLTexture object\n\n\t\t\ttextureProperties.__cacheKey = textureCacheKey;\n\t\t\ttextureProperties.__webglTexture = webglTextures[ textureCacheKey ].texture;\n\n\t\t}\n\n\t\treturn forceUpload;\n\n\t}\n\n\tfunction uploadTexture( textureProperties, texture, slot ) {\n\n\t\tlet textureType = _gl.TEXTURE_2D;\n\n\t\tif ( texture.isDataArrayTexture || texture.isCompressedArrayTexture ) textureType = _gl.TEXTURE_2D_ARRAY;\n\t\tif ( texture.isData3DTexture ) textureType = _gl.TEXTURE_3D;\n\n\t\tconst forceUpload = initTexture( textureProperties, texture );\n\t\tconst source = texture.source;\n\n\t\tstate.bindTexture( textureType, textureProperties.__webglTexture, _gl.TEXTURE0 + slot );\n\n\t\tconst sourceProperties = properties.get( source );\n\n\t\tif ( source.version !== sourceProperties.__version || forceUpload === true ) {\n\n\t\t\tstate.activeTexture( _gl.TEXTURE0 + slot );\n\n\t\t\tconst workingPrimaries = ColorManagement.getPrimaries( ColorManagement.workingColorSpace );\n\t\t\tconst texturePrimaries = texture.colorSpace === NoColorSpace ? null : ColorManagement.getPrimaries( texture.colorSpace );\n\t\t\tconst unpackConversion = texture.colorSpace === NoColorSpace || workingPrimaries === texturePrimaries ? _gl.NONE : _gl.BROWSER_DEFAULT_WEBGL;\n\n\t\t\t_gl.pixelStorei( _gl.UNPACK_FLIP_Y_WEBGL, texture.flipY );\n\t\t\t_gl.pixelStorei( _gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, texture.premultiplyAlpha );\n\t\t\t_gl.pixelStorei( _gl.UNPACK_ALIGNMENT, texture.unpackAlignment );\n\t\t\t_gl.pixelStorei( _gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, unpackConversion );\n\n\t\t\tlet image = resizeImage( texture.image, false, capabilities.maxTextureSize );\n\t\t\timage = verifyColorSpace( texture, image );\n\n\t\t\tconst glFormat = utils.convert( texture.format, texture.colorSpace );\n\n\t\t\tconst glType = utils.convert( texture.type );\n\t\t\tlet glInternalFormat = getInternalFormat( texture.internalFormat, glFormat, glType, texture.colorSpace, texture.isVideoTexture );\n\n\t\t\tsetTextureParameters( textureType, texture );\n\n\t\t\tlet mipmap;\n\t\t\tconst mipmaps = texture.mipmaps;\n\n\t\t\tconst useTexStorage = ( texture.isVideoTexture !== true && glInternalFormat !== RGB_ETC1_Format );\n\t\t\tconst allocateMemory = ( sourceProperties.__version === undefined ) || ( forceUpload === true );\n\t\t\tconst dataReady = source.dataReady;\n\t\t\tconst levels = getMipLevels( texture, image );\n\n\t\t\tif ( texture.isDepthTexture ) {\n\n\t\t\t\t// populate depth texture with dummy data\n\n\t\t\t\tglInternalFormat = _gl.DEPTH_COMPONENT16;\n\n\t\t\t\tif ( texture.type === FloatType ) {\n\n\t\t\t\t\tglInternalFormat = _gl.DEPTH_COMPONENT32F;\n\n\t\t\t\t} else if ( texture.type === UnsignedIntType ) {\n\n\t\t\t\t\tglInternalFormat = _gl.DEPTH_COMPONENT24;\n\n\t\t\t\t} else if ( texture.type === UnsignedInt248Type ) {\n\n\t\t\t\t\tglInternalFormat = _gl.DEPTH24_STENCIL8;\n\n\t\t\t\t}\n\n\t\t\t\t//\n\n\t\t\t\tif ( allocateMemory ) {\n\n\t\t\t\t\tif ( useTexStorage ) {\n\n\t\t\t\t\t\tstate.texStorage2D( _gl.TEXTURE_2D, 1, glInternalFormat, image.width, image.height );\n\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\tstate.texImage2D( _gl.TEXTURE_2D, 0, glInternalFormat, image.width, image.height, 0, glFormat, glType, null );\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t} else if ( texture.isDataTexture ) {\n\n\t\t\t\t// use manually created mipmaps if available\n\t\t\t\t// if there are no manual mipmaps\n\t\t\t\t// set 0 level mipmap and then use GL to generate other mipmap levels\n\n\t\t\t\tif ( mipmaps.length > 0 ) {\n\n\t\t\t\t\tif ( useTexStorage && allocateMemory ) {\n\n\t\t\t\t\t\tstate.texStorage2D( _gl.TEXTURE_2D, levels, glInternalFormat, mipmaps[ 0 ].width, mipmaps[ 0 ].height );\n\n\t\t\t\t\t}\n\n\t\t\t\t\tfor ( let i = 0, il = mipmaps.length; i < il; i ++ ) {\n\n\t\t\t\t\t\tmipmap = mipmaps[ i ];\n\n\t\t\t\t\t\tif ( useTexStorage ) {\n\n\t\t\t\t\t\t\tif ( dataReady ) {\n\n\t\t\t\t\t\t\t\tstate.texSubImage2D( _gl.TEXTURE_2D, i, 0, 0, mipmap.width, mipmap.height, glFormat, glType, mipmap.data );\n\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\tstate.texImage2D( _gl.TEXTURE_2D, i, glInternalFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data );\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}\n\n\t\t\t\t\ttexture.generateMipmaps = false;\n\n\t\t\t\t} else {\n\n\t\t\t\t\tif ( useTexStorage ) {\n\n\t\t\t\t\t\tif ( allocateMemory ) {\n\n\t\t\t\t\t\t\tstate.texStorage2D( _gl.TEXTURE_2D, levels, glInternalFormat, image.width, image.height );\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tif ( dataReady ) {\n\n\t\t\t\t\t\t\tstate.texSubImage2D( _gl.TEXTURE_2D, 0, 0, 0, image.width, image.height, glFormat, glType, image.data );\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\tstate.texImage2D( _gl.TEXTURE_2D, 0, glInternalFormat, image.width, image.height, 0, glFormat, glType, image.data );\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t} else if ( texture.isCompressedTexture ) {\n\n\t\t\t\tif ( texture.isCompressedArrayTexture ) {\n\n\t\t\t\t\tif ( useTexStorage && allocateMemory ) {\n\n\t\t\t\t\t\tstate.texStorage3D( _gl.TEXTURE_2D_ARRAY, levels, glInternalFormat, mipmaps[ 0 ].width, mipmaps[ 0 ].height, image.depth );\n\n\t\t\t\t\t}\n\n\t\t\t\t\tfor ( let i = 0, il = mipmaps.length; i < il; i ++ ) {\n\n\t\t\t\t\t\tmipmap = mipmaps[ i ];\n\n\t\t\t\t\t\tif ( texture.format !== RGBAFormat ) {\n\n\t\t\t\t\t\t\tif ( glFormat !== null ) {\n\n\t\t\t\t\t\t\t\tif ( useTexStorage ) {\n\n\t\t\t\t\t\t\t\t\tif ( dataReady ) {\n\n\t\t\t\t\t\t\t\t\t\tstate.compressedTexSubImage3D( _gl.TEXTURE_2D_ARRAY, i, 0, 0, 0, mipmap.width, mipmap.height, image.depth, glFormat, mipmap.data, 0, 0 );\n\n\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\t\tstate.compressedTexImage3D( _gl.TEXTURE_2D_ARRAY, i, glInternalFormat, mipmap.width, mipmap.height, image.depth, 0, mipmap.data, 0, 0 );\n\n\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\tconsole.warn( 'THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .uploadTexture()' );\n\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\tif ( useTexStorage ) {\n\n\t\t\t\t\t\t\t\tif ( dataReady ) {\n\n\t\t\t\t\t\t\t\t\tstate.texSubImage3D( _gl.TEXTURE_2D_ARRAY, i, 0, 0, 0, mipmap.width, mipmap.height, image.depth, glFormat, glType, mipmap.data );\n\n\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\tstate.texImage3D( _gl.TEXTURE_2D_ARRAY, i, glInternalFormat, mipmap.width, mipmap.height, image.depth, 0, glFormat, glType, mipmap.data );\n\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}\n\n\t\t\t\t} else {\n\n\t\t\t\t\tif ( useTexStorage && allocateMemory ) {\n\n\t\t\t\t\t\tstate.texStorage2D( _gl.TEXTURE_2D, levels, glInternalFormat, mipmaps[ 0 ].width, mipmaps[ 0 ].height );\n\n\t\t\t\t\t}\n\n\t\t\t\t\tfor ( let i = 0, il = mipmaps.length; i < il; i ++ ) {\n\n\t\t\t\t\t\tmipmap = mipmaps[ i ];\n\n\t\t\t\t\t\tif ( texture.format !== RGBAFormat ) {\n\n\t\t\t\t\t\t\tif ( glFormat !== null ) {\n\n\t\t\t\t\t\t\t\tif ( useTexStorage ) {\n\n\t\t\t\t\t\t\t\t\tif ( dataReady ) {\n\n\t\t\t\t\t\t\t\t\t\tstate.compressedTexSubImage2D( _gl.TEXTURE_2D, i, 0, 0, mipmap.width, mipmap.height, glFormat, mipmap.data );\n\n\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\t\tstate.compressedTexImage2D( _gl.TEXTURE_2D, i, glInternalFormat, mipmap.width, mipmap.height, 0, mipmap.data );\n\n\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\tconsole.warn( 'THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .uploadTexture()' );\n\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\tif ( useTexStorage ) {\n\n\t\t\t\t\t\t\t\tif ( dataReady ) {\n\n\t\t\t\t\t\t\t\t\tstate.texSubImage2D( _gl.TEXTURE_2D, i, 0, 0, mipmap.width, mipmap.height, glFormat, glType, mipmap.data );\n\n\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\tstate.texImage2D( _gl.TEXTURE_2D, i, glInternalFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data );\n\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t} else if ( texture.isDataArrayTexture ) {\n\n\t\t\t\tif ( useTexStorage ) {\n\n\t\t\t\t\tif ( allocateMemory ) {\n\n\t\t\t\t\t\tstate.texStorage3D( _gl.TEXTURE_2D_ARRAY, levels, glInternalFormat, image.width, image.height, image.depth );\n\n\t\t\t\t\t}\n\n\t\t\t\t\tif ( dataReady ) {\n\n\t\t\t\t\t\tstate.texSubImage3D( _gl.TEXTURE_2D_ARRAY, 0, 0, 0, 0, image.width, image.height, image.depth, glFormat, glType, image.data );\n\n\t\t\t\t\t}\n\n\t\t\t\t} else {\n\n\t\t\t\t\tstate.texImage3D( _gl.TEXTURE_2D_ARRAY, 0, glInternalFormat, image.width, image.height, image.depth, 0, glFormat, glType, image.data );\n\n\t\t\t\t}\n\n\t\t\t} else if ( texture.isData3DTexture ) {\n\n\t\t\t\tif ( useTexStorage ) {\n\n\t\t\t\t\tif ( allocateMemory ) {\n\n\t\t\t\t\t\tstate.texStorage3D( _gl.TEXTURE_3D, levels, glInternalFormat, image.width, image.height, image.depth );\n\n\t\t\t\t\t}\n\n\t\t\t\t\tif ( dataReady ) {\n\n\t\t\t\t\t\tstate.texSubImage3D( _gl.TEXTURE_3D, 0, 0, 0, 0, image.width, image.height, image.depth, glFormat, glType, image.data );\n\n\t\t\t\t\t}\n\n\t\t\t\t} else {\n\n\t\t\t\t\tstate.texImage3D( _gl.TEXTURE_3D, 0, glInternalFormat, image.width, image.height, image.depth, 0, glFormat, glType, image.data );\n\n\t\t\t\t}\n\n\t\t\t} else if ( texture.isFramebufferTexture ) {\n\n\t\t\t\tif ( allocateMemory ) {\n\n\t\t\t\t\tif ( useTexStorage ) {\n\n\t\t\t\t\t\tstate.texStorage2D( _gl.TEXTURE_2D, levels, glInternalFormat, image.width, image.height );\n\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\tlet width = image.width, height = image.height;\n\n\t\t\t\t\t\tfor ( let i = 0; i < levels; i ++ ) {\n\n\t\t\t\t\t\t\tstate.texImage2D( _gl.TEXTURE_2D, i, glInternalFormat, width, height, 0, glFormat, glType, null );\n\n\t\t\t\t\t\t\twidth >>= 1;\n\t\t\t\t\t\t\theight >>= 1;\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t} else {\n\n\t\t\t\t// regular Texture (image, video, canvas)\n\n\t\t\t\t// use manually created mipmaps if available\n\t\t\t\t// if there are no manual mipmaps\n\t\t\t\t// set 0 level mipmap and then use GL to generate other mipmap levels\n\n\t\t\t\tif ( mipmaps.length > 0 ) {\n\n\t\t\t\t\tif ( useTexStorage && allocateMemory ) {\n\n\t\t\t\t\t\tconst dimensions = getDimensions( mipmaps[ 0 ] );\n\n\t\t\t\t\t\tstate.texStorage2D( _gl.TEXTURE_2D, levels, glInternalFormat, dimensions.width, dimensions.height );\n\n\t\t\t\t\t}\n\n\t\t\t\t\tfor ( let i = 0, il = mipmaps.length; i < il; i ++ ) {\n\n\t\t\t\t\t\tmipmap = mipmaps[ i ];\n\n\t\t\t\t\t\tif ( useTexStorage ) {\n\n\t\t\t\t\t\t\tif ( dataReady ) {\n\n\t\t\t\t\t\t\t\tstate.texSubImage2D( _gl.TEXTURE_2D, i, 0, 0, glFormat, glType, mipmap );\n\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\tstate.texImage2D( _gl.TEXTURE_2D, i, glInternalFormat, glFormat, glType, mipmap );\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}\n\n\t\t\t\t\ttexture.generateMipmaps = false;\n\n\t\t\t\t} else {\n\n\t\t\t\t\tif ( useTexStorage ) {\n\n\t\t\t\t\t\tif ( allocateMemory ) {\n\n\t\t\t\t\t\t\tconst dimensions = getDimensions( image );\n\n\t\t\t\t\t\t\tstate.texStorage2D( _gl.TEXTURE_2D, levels, glInternalFormat, dimensions.width, dimensions.height );\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tif ( dataReady ) {\n\n\t\t\t\t\t\t\tstate.texSubImage2D( _gl.TEXTURE_2D, 0, 0, 0, glFormat, glType, image );\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\tstate.texImage2D( _gl.TEXTURE_2D, 0, glInternalFormat, glFormat, glType, image );\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tif ( textureNeedsGenerateMipmaps( texture ) ) {\n\n\t\t\t\tgenerateMipmap( textureType );\n\n\t\t\t}\n\n\t\t\tsourceProperties.__version = source.version;\n\n\t\t\tif ( texture.onUpdate ) texture.onUpdate( texture );\n\n\t\t}\n\n\t\ttextureProperties.__version = texture.version;\n\n\t}\n\n\tfunction uploadCubeTexture( textureProperties, texture, slot ) {\n\n\t\tif ( texture.image.length !== 6 ) return;\n\n\t\tconst forceUpload = initTexture( textureProperties, texture );\n\t\tconst source = texture.source;\n\n\t\tstate.bindTexture( _gl.TEXTURE_CUBE_MAP, textureProperties.__webglTexture, _gl.TEXTURE0 + slot );\n\n\t\tconst sourceProperties = properties.get( source );\n\n\t\tif ( source.version !== sourceProperties.__version || forceUpload === true ) {\n\n\t\t\tstate.activeTexture( _gl.TEXTURE0 + slot );\n\n\t\t\tconst workingPrimaries = ColorManagement.getPrimaries( ColorManagement.workingColorSpace );\n\t\t\tconst texturePrimaries = texture.colorSpace === NoColorSpace ? null : ColorManagement.getPrimaries( texture.colorSpace );\n\t\t\tconst unpackConversion = texture.colorSpace === NoColorSpace || workingPrimaries === texturePrimaries ? _gl.NONE : _gl.BROWSER_DEFAULT_WEBGL;\n\n\t\t\t_gl.pixelStorei( _gl.UNPACK_FLIP_Y_WEBGL, texture.flipY );\n\t\t\t_gl.pixelStorei( _gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, texture.premultiplyAlpha );\n\t\t\t_gl.pixelStorei( _gl.UNPACK_ALIGNMENT, texture.unpackAlignment );\n\t\t\t_gl.pixelStorei( _gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, unpackConversion );\n\n\t\t\tconst isCompressed = ( texture.isCompressedTexture || texture.image[ 0 ].isCompressedTexture );\n\t\t\tconst isDataTexture = ( texture.image[ 0 ] && texture.image[ 0 ].isDataTexture );\n\n\t\t\tconst cubeImage = [];\n\n\t\t\tfor ( let i = 0; i < 6; i ++ ) {\n\n\t\t\t\tif ( ! isCompressed && ! isDataTexture ) {\n\n\t\t\t\t\tcubeImage[ i ] = resizeImage( texture.image[ i ], true, capabilities.maxCubemapSize );\n\n\t\t\t\t} else {\n\n\t\t\t\t\tcubeImage[ i ] = isDataTexture ? texture.image[ i ].image : texture.image[ i ];\n\n\t\t\t\t}\n\n\t\t\t\tcubeImage[ i ] = verifyColorSpace( texture, cubeImage[ i ] );\n\n\t\t\t}\n\n\t\t\tconst image = cubeImage[ 0 ],\n\t\t\t\tglFormat = utils.convert( texture.format, texture.colorSpace ),\n\t\t\t\tglType = utils.convert( texture.type ),\n\t\t\t\tglInternalFormat = getInternalFormat( texture.internalFormat, glFormat, glType, texture.colorSpace );\n\n\t\t\tconst useTexStorage = ( texture.isVideoTexture !== true );\n\t\t\tconst allocateMemory = ( sourceProperties.__version === undefined ) || ( forceUpload === true );\n\t\t\tconst dataReady = source.dataReady;\n\t\t\tlet levels = getMipLevels( texture, image );\n\n\t\t\tsetTextureParameters( _gl.TEXTURE_CUBE_MAP, texture );\n\n\t\t\tlet mipmaps;\n\n\t\t\tif ( isCompressed ) {\n\n\t\t\t\tif ( useTexStorage && allocateMemory ) {\n\n\t\t\t\t\tstate.texStorage2D( _gl.TEXTURE_CUBE_MAP, levels, glInternalFormat, image.width, image.height );\n\n\t\t\t\t}\n\n\t\t\t\tfor ( let i = 0; i < 6; i ++ ) {\n\n\t\t\t\t\tmipmaps = cubeImage[ i ].mipmaps;\n\n\t\t\t\t\tfor ( let j = 0; j < mipmaps.length; j ++ ) {\n\n\t\t\t\t\t\tconst mipmap = mipmaps[ j ];\n\n\t\t\t\t\t\tif ( texture.format !== RGBAFormat ) {\n\n\t\t\t\t\t\t\tif ( glFormat !== null ) {\n\n\t\t\t\t\t\t\t\tif ( useTexStorage ) {\n\n\t\t\t\t\t\t\t\t\tif ( dataReady ) {\n\n\t\t\t\t\t\t\t\t\t\tstate.compressedTexSubImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j, 0, 0, mipmap.width, mipmap.height, glFormat, mipmap.data );\n\n\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\t\tstate.compressedTexImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j, glInternalFormat, mipmap.width, mipmap.height, 0, mipmap.data );\n\n\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\tconsole.warn( 'THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .setTextureCube()' );\n\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\tif ( useTexStorage ) {\n\n\t\t\t\t\t\t\t\tif ( dataReady ) {\n\n\t\t\t\t\t\t\t\t\tstate.texSubImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j, 0, 0, mipmap.width, mipmap.height, glFormat, glType, mipmap.data );\n\n\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\tstate.texImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j, glInternalFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data );\n\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t} else {\n\n\t\t\t\tmipmaps = texture.mipmaps;\n\n\t\t\t\tif ( useTexStorage && allocateMemory ) {\n\n\t\t\t\t\t// TODO: Uniformly handle mipmap definitions\n\t\t\t\t\t// Normal textures and compressed cube textures define base level + mips with their mipmap array\n\t\t\t\t\t// Uncompressed cube textures use their mipmap array only for mips (no base level)\n\n\t\t\t\t\tif ( mipmaps.length > 0 ) levels ++;\n\n\t\t\t\t\tconst dimensions = getDimensions( cubeImage[ 0 ] );\n\n\t\t\t\t\tstate.texStorage2D( _gl.TEXTURE_CUBE_MAP, levels, glInternalFormat, dimensions.width, dimensions.height );\n\n\t\t\t\t}\n\n\t\t\t\tfor ( let i = 0; i < 6; i ++ ) {\n\n\t\t\t\t\tif ( isDataTexture ) {\n\n\t\t\t\t\t\tif ( useTexStorage ) {\n\n\t\t\t\t\t\t\tif ( dataReady ) {\n\n\t\t\t\t\t\t\t\tstate.texSubImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, 0, 0, cubeImage[ i ].width, cubeImage[ i ].height, glFormat, glType, cubeImage[ i ].data );\n\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\tstate.texImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glInternalFormat, cubeImage[ i ].width, cubeImage[ i ].height, 0, glFormat, glType, cubeImage[ i ].data );\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tfor ( let j = 0; j < mipmaps.length; j ++ ) {\n\n\t\t\t\t\t\t\tconst mipmap = mipmaps[ j ];\n\t\t\t\t\t\t\tconst mipmapImage = mipmap.image[ i ].image;\n\n\t\t\t\t\t\t\tif ( useTexStorage ) {\n\n\t\t\t\t\t\t\t\tif ( dataReady ) {\n\n\t\t\t\t\t\t\t\t\tstate.texSubImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j + 1, 0, 0, mipmapImage.width, mipmapImage.height, glFormat, glType, mipmapImage.data );\n\n\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\tstate.texImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j + 1, glInternalFormat, mipmapImage.width, mipmapImage.height, 0, glFormat, glType, mipmapImage.data );\n\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\tif ( useTexStorage ) {\n\n\t\t\t\t\t\t\tif ( dataReady ) {\n\n\t\t\t\t\t\t\t\tstate.texSubImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, 0, 0, glFormat, glType, cubeImage[ i ] );\n\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\tstate.texImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glInternalFormat, glFormat, glType, cubeImage[ i ] );\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tfor ( let j = 0; j < mipmaps.length; j ++ ) {\n\n\t\t\t\t\t\t\tconst mipmap = mipmaps[ j ];\n\n\t\t\t\t\t\t\tif ( useTexStorage ) {\n\n\t\t\t\t\t\t\t\tif ( dataReady ) {\n\n\t\t\t\t\t\t\t\t\tstate.texSubImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j + 1, 0, 0, glFormat, glType, mipmap.image[ i ] );\n\n\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\tstate.texImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j + 1, glInternalFormat, glFormat, glType, mipmap.image[ i ] );\n\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tif ( textureNeedsGenerateMipmaps( texture ) ) {\n\n\t\t\t\t// We assume images for cube map have the same size.\n\t\t\t\tgenerateMipmap( _gl.TEXTURE_CUBE_MAP );\n\n\t\t\t}\n\n\t\t\tsourceProperties.__version = source.version;\n\n\t\t\tif ( texture.onUpdate ) texture.onUpdate( texture );\n\n\t\t}\n\n\t\ttextureProperties.__version = texture.version;\n\n\t}\n\n\t// Render targets\n\n\t// Setup storage for target texture and bind it to correct framebuffer\n\tfunction setupFrameBufferTexture( framebuffer, renderTarget, texture, attachment, textureTarget, level ) {\n\n\t\tconst glFormat = utils.convert( texture.format, texture.colorSpace );\n\t\tconst glType = utils.convert( texture.type );\n\t\tconst glInternalFormat = getInternalFormat( texture.internalFormat, glFormat, glType, texture.colorSpace );\n\t\tconst renderTargetProperties = properties.get( renderTarget );\n\n\t\tif ( ! renderTargetProperties.__hasExternalTextures ) {\n\n\t\t\tconst width = Math.max( 1, renderTarget.width >> level );\n\t\t\tconst height = Math.max( 1, renderTarget.height >> level );\n\n\t\t\tif ( textureTarget === _gl.TEXTURE_3D || textureTarget === _gl.TEXTURE_2D_ARRAY ) {\n\n\t\t\t\tstate.texImage3D( textureTarget, level, glInternalFormat, width, height, renderTarget.depth, 0, glFormat, glType, null );\n\n\t\t\t} else {\n\n\t\t\t\tstate.texImage2D( textureTarget, level, glInternalFormat, width, height, 0, glFormat, glType, null );\n\n\t\t\t}\n\n\t\t}\n\n\t\tstate.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer );\n\n\t\tif ( useMultisampledRTT( renderTarget ) ) {\n\n\t\t\tmultisampledRTTExt.framebufferTexture2DMultisampleEXT( _gl.FRAMEBUFFER, attachment, textureTarget, properties.get( texture ).__webglTexture, 0, getRenderTargetSamples( renderTarget ) );\n\n\t\t} else if ( textureTarget === _gl.TEXTURE_2D || ( textureTarget >= _gl.TEXTURE_CUBE_MAP_POSITIVE_X && textureTarget <= _gl.TEXTURE_CUBE_MAP_NEGATIVE_Z ) ) { // see #24753\n\n\t\t\t_gl.framebufferTexture2D( _gl.FRAMEBUFFER, attachment, textureTarget, properties.get( texture ).__webglTexture, level );\n\n\t\t}\n\n\t\tstate.bindFramebuffer( _gl.FRAMEBUFFER, null );\n\n\t}\n\n\n\t// Setup storage for internal depth/stencil buffers and bind to correct framebuffer\n\tfunction setupRenderBufferStorage( renderbuffer, renderTarget, isMultisample ) {\n\n\t\t_gl.bindRenderbuffer( _gl.RENDERBUFFER, renderbuffer );\n\n\t\tif ( renderTarget.depthBuffer && ! renderTarget.stencilBuffer ) {\n\n\t\t\tlet glInternalFormat = _gl.DEPTH_COMPONENT24;\n\n\t\t\tif ( isMultisample || useMultisampledRTT( renderTarget ) ) {\n\n\t\t\t\tconst depthTexture = renderTarget.depthTexture;\n\n\t\t\t\tif ( depthTexture && depthTexture.isDepthTexture ) {\n\n\t\t\t\t\tif ( depthTexture.type === FloatType ) {\n\n\t\t\t\t\t\tglInternalFormat = _gl.DEPTH_COMPONENT32F;\n\n\t\t\t\t\t} else if ( depthTexture.type === UnsignedIntType ) {\n\n\t\t\t\t\t\tglInternalFormat = _gl.DEPTH_COMPONENT24;\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t\tconst samples = getRenderTargetSamples( renderTarget );\n\n\t\t\t\tif ( useMultisampledRTT( renderTarget ) ) {\n\n\t\t\t\t\tmultisampledRTTExt.renderbufferStorageMultisampleEXT( _gl.RENDERBUFFER, samples, glInternalFormat, renderTarget.width, renderTarget.height );\n\n\t\t\t\t} else {\n\n\t\t\t\t\t_gl.renderbufferStorageMultisample( _gl.RENDERBUFFER, samples, glInternalFormat, renderTarget.width, renderTarget.height );\n\n\t\t\t\t}\n\n\t\t\t} else {\n\n\t\t\t\t_gl.renderbufferStorage( _gl.RENDERBUFFER, glInternalFormat, renderTarget.width, renderTarget.height );\n\n\t\t\t}\n\n\t\t\t_gl.framebufferRenderbuffer( _gl.FRAMEBUFFER, _gl.DEPTH_ATTACHMENT, _gl.RENDERBUFFER, renderbuffer );\n\n\t\t} else if ( renderTarget.depthBuffer && renderTarget.stencilBuffer ) {\n\n\t\t\tconst samples = getRenderTargetSamples( renderTarget );\n\n\t\t\tif ( isMultisample && useMultisampledRTT( renderTarget ) === false ) {\n\n\t\t\t\t_gl.renderbufferStorageMultisample( _gl.RENDERBUFFER, samples, _gl.DEPTH24_STENCIL8, renderTarget.width, renderTarget.height );\n\n\t\t\t} else if ( useMultisampledRTT( renderTarget ) ) {\n\n\t\t\t\tmultisampledRTTExt.renderbufferStorageMultisampleEXT( _gl.RENDERBUFFER, samples, _gl.DEPTH24_STENCIL8, renderTarget.width, renderTarget.height );\n\n\t\t\t} else {\n\n\t\t\t\t_gl.renderbufferStorage( _gl.RENDERBUFFER, _gl.DEPTH_STENCIL, renderTarget.width, renderTarget.height );\n\n\t\t\t}\n\n\n\t\t\t_gl.framebufferRenderbuffer( _gl.FRAMEBUFFER, _gl.DEPTH_STENCIL_ATTACHMENT, _gl.RENDERBUFFER, renderbuffer );\n\n\t\t} else {\n\n\t\t\tconst textures = renderTarget.textures;\n\n\t\t\tfor ( let i = 0; i < textures.length; i ++ ) {\n\n\t\t\t\tconst texture = textures[ i ];\n\n\t\t\t\tconst glFormat = utils.convert( texture.format, texture.colorSpace );\n\t\t\t\tconst glType = utils.convert( texture.type );\n\t\t\t\tconst glInternalFormat = getInternalFormat( texture.internalFormat, glFormat, glType, texture.colorSpace );\n\t\t\t\tconst samples = getRenderTargetSamples( renderTarget );\n\n\t\t\t\tif ( isMultisample && useMultisampledRTT( renderTarget ) === false ) {\n\n\t\t\t\t\t_gl.renderbufferStorageMultisample( _gl.RENDERBUFFER, samples, glInternalFormat, renderTarget.width, renderTarget.height );\n\n\t\t\t\t} else if ( useMultisampledRTT( renderTarget ) ) {\n\n\t\t\t\t\tmultisampledRTTExt.renderbufferStorageMultisampleEXT( _gl.RENDERBUFFER, samples, glInternalFormat, renderTarget.width, renderTarget.height );\n\n\t\t\t\t} else {\n\n\t\t\t\t\t_gl.renderbufferStorage( _gl.RENDERBUFFER, glInternalFormat, renderTarget.width, renderTarget.height );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t\t_gl.bindRenderbuffer( _gl.RENDERBUFFER, null );\n\n\t}\n\n\t// Setup resources for a Depth Texture for a FBO (needs an extension)\n\tfunction setupDepthTexture( framebuffer, renderTarget ) {\n\n\t\tconst isCube = ( renderTarget && renderTarget.isWebGLCubeRenderTarget );\n\t\tif ( isCube ) throw new Error( 'Depth Texture with cube render targets is not supported' );\n\n\t\tstate.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer );\n\n\t\tif ( ! ( renderTarget.depthTexture && renderTarget.depthTexture.isDepthTexture ) ) {\n\n\t\t\tthrow new Error( 'renderTarget.depthTexture must be an instance of THREE.DepthTexture' );\n\n\t\t}\n\n\t\t// upload an empty depth texture with framebuffer size\n\t\tif ( ! properties.get( renderTarget.depthTexture ).__webglTexture ||\n\t\t\t\trenderTarget.depthTexture.image.width !== renderTarget.width ||\n\t\t\t\trenderTarget.depthTexture.image.height !== renderTarget.height ) {\n\n\t\t\trenderTarget.depthTexture.image.width = renderTarget.width;\n\t\t\trenderTarget.depthTexture.image.height = renderTarget.height;\n\t\t\trenderTarget.depthTexture.needsUpdate = true;\n\n\t\t}\n\n\t\tsetTexture2D( renderTarget.depthTexture, 0 );\n\n\t\tconst webglDepthTexture = properties.get( renderTarget.depthTexture ).__webglTexture;\n\t\tconst samples = getRenderTargetSamples( renderTarget );\n\n\t\tif ( renderTarget.depthTexture.format === DepthFormat ) {\n\n\t\t\tif ( useMultisampledRTT( renderTarget ) ) {\n\n\t\t\t\tmultisampledRTTExt.framebufferTexture2DMultisampleEXT( _gl.FRAMEBUFFER, _gl.DEPTH_ATTACHMENT, _gl.TEXTURE_2D, webglDepthTexture, 0, samples );\n\n\t\t\t} else {\n\n\t\t\t\t_gl.framebufferTexture2D( _gl.FRAMEBUFFER, _gl.DEPTH_ATTACHMENT, _gl.TEXTURE_2D, webglDepthTexture, 0 );\n\n\t\t\t}\n\n\t\t} else if ( renderTarget.depthTexture.format === DepthStencilFormat ) {\n\n\t\t\tif ( useMultisampledRTT( renderTarget ) ) {\n\n\t\t\t\tmultisampledRTTExt.framebufferTexture2DMultisampleEXT( _gl.FRAMEBUFFER, _gl.DEPTH_STENCIL_ATTACHMENT, _gl.TEXTURE_2D, webglDepthTexture, 0, samples );\n\n\t\t\t} else {\n\n\t\t\t\t_gl.framebufferTexture2D( _gl.FRAMEBUFFER, _gl.DEPTH_STENCIL_ATTACHMENT, _gl.TEXTURE_2D, webglDepthTexture, 0 );\n\n\t\t\t}\n\n\t\t} else {\n\n\t\t\tthrow new Error( 'Unknown depthTexture format' );\n\n\t\t}\n\n\t}\n\n\t// Setup GL resources for a non-texture depth buffer\n\tfunction setupDepthRenderbuffer( renderTarget ) {\n\n\t\tconst renderTargetProperties = properties.get( renderTarget );\n\t\tconst isCube = ( renderTarget.isWebGLCubeRenderTarget === true );\n\n\t\tif ( renderTarget.depthTexture && ! renderTargetProperties.__autoAllocateDepthBuffer ) {\n\n\t\t\tif ( isCube ) throw new Error( 'target.depthTexture not supported in Cube render targets' );\n\n\t\t\tsetupDepthTexture( renderTargetProperties.__webglFramebuffer, renderTarget );\n\n\t\t} else {\n\n\t\t\tif ( isCube ) {\n\n\t\t\t\trenderTargetProperties.__webglDepthbuffer = [];\n\n\t\t\t\tfor ( let i = 0; i < 6; i ++ ) {\n\n\t\t\t\t\tstate.bindFramebuffer( _gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer[ i ] );\n\t\t\t\t\trenderTargetProperties.__webglDepthbuffer[ i ] = _gl.createRenderbuffer();\n\t\t\t\t\tsetupRenderBufferStorage( renderTargetProperties.__webglDepthbuffer[ i ], renderTarget, false );\n\n\t\t\t\t}\n\n\t\t\t} else {\n\n\t\t\t\tstate.bindFramebuffer( _gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer );\n\t\t\t\trenderTargetProperties.__webglDepthbuffer = _gl.createRenderbuffer();\n\t\t\t\tsetupRenderBufferStorage( renderTargetProperties.__webglDepthbuffer, renderTarget, false );\n\n\t\t\t}\n\n\t\t}\n\n\t\tstate.bindFramebuffer( _gl.FRAMEBUFFER, null );\n\n\t}\n\n\t// rebind framebuffer with external textures\n\tfunction rebindTextures( renderTarget, colorTexture, depthTexture ) {\n\n\t\tconst renderTargetProperties = properties.get( renderTarget );\n\n\t\tif ( colorTexture !== undefined ) {\n\n\t\t\tsetupFrameBufferTexture( renderTargetProperties.__webglFramebuffer, renderTarget, renderTarget.texture, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_2D, 0 );\n\n\t\t}\n\n\t\tif ( depthTexture !== undefined ) {\n\n\t\t\tsetupDepthRenderbuffer( renderTarget );\n\n\t\t}\n\n\t}\n\n\t// Set up GL resources for the render target\n\tfunction setupRenderTarget( renderTarget ) {\n\n\t\tconst texture = renderTarget.texture;\n\n\t\tconst renderTargetProperties = properties.get( renderTarget );\n\t\tconst textureProperties = properties.get( texture );\n\n\t\trenderTarget.addEventListener( 'dispose', onRenderTargetDispose );\n\n\t\tconst textures = renderTarget.textures;\n\n\t\tconst isCube = ( renderTarget.isWebGLCubeRenderTarget === true );\n\t\tconst isMultipleRenderTargets = ( textures.length > 1 );\n\n\t\tif ( ! isMultipleRenderTargets ) {\n\n\t\t\tif ( textureProperties.__webglTexture === undefined ) {\n\n\t\t\t\ttextureProperties.__webglTexture = _gl.createTexture();\n\n\t\t\t}\n\n\t\t\ttextureProperties.__version = texture.version;\n\t\t\tinfo.memory.textures ++;\n\n\t\t}\n\n\t\t// Setup framebuffer\n\n\t\tif ( isCube ) {\n\n\t\t\trenderTargetProperties.__webglFramebuffer = [];\n\n\t\t\tfor ( let i = 0; i < 6; i ++ ) {\n\n\t\t\t\tif ( texture.mipmaps && texture.mipmaps.length > 0 ) {\n\n\t\t\t\t\trenderTargetProperties.__webglFramebuffer[ i ] = [];\n\n\t\t\t\t\tfor ( let level = 0; level < texture.mipmaps.length; level ++ ) {\n\n\t\t\t\t\t\trenderTargetProperties.__webglFramebuffer[ i ][ level ] = _gl.createFramebuffer();\n\n\t\t\t\t\t}\n\n\t\t\t\t} else {\n\n\t\t\t\t\trenderTargetProperties.__webglFramebuffer[ i ] = _gl.createFramebuffer();\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t} else {\n\n\t\t\tif ( texture.mipmaps && texture.mipmaps.length > 0 ) {\n\n\t\t\t\trenderTargetProperties.__webglFramebuffer = [];\n\n\t\t\t\tfor ( let level = 0; level < texture.mipmaps.length; level ++ ) {\n\n\t\t\t\t\trenderTargetProperties.__webglFramebuffer[ level ] = _gl.createFramebuffer();\n\n\t\t\t\t}\n\n\t\t\t} else {\n\n\t\t\t\trenderTargetProperties.__webglFramebuffer = _gl.createFramebuffer();\n\n\t\t\t}\n\n\t\t\tif ( isMultipleRenderTargets ) {\n\n\t\t\t\tfor ( let i = 0, il = textures.length; i < il; i ++ ) {\n\n\t\t\t\t\tconst attachmentProperties = properties.get( textures[ i ] );\n\n\t\t\t\t\tif ( attachmentProperties.__webglTexture === undefined ) {\n\n\t\t\t\t\t\tattachmentProperties.__webglTexture = _gl.createTexture();\n\n\t\t\t\t\t\tinfo.memory.textures ++;\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tif ( ( renderTarget.samples > 0 ) && useMultisampledRTT( renderTarget ) === false ) {\n\n\t\t\t\trenderTargetProperties.__webglMultisampledFramebuffer = _gl.createFramebuffer();\n\t\t\t\trenderTargetProperties.__webglColorRenderbuffer = [];\n\n\t\t\t\tstate.bindFramebuffer( _gl.FRAMEBUFFER, renderTargetProperties.__webglMultisampledFramebuffer );\n\n\t\t\t\tfor ( let i = 0; i < textures.length; i ++ ) {\n\n\t\t\t\t\tconst texture = textures[ i ];\n\t\t\t\t\trenderTargetProperties.__webglColorRenderbuffer[ i ] = _gl.createRenderbuffer();\n\n\t\t\t\t\t_gl.bindRenderbuffer( _gl.RENDERBUFFER, renderTargetProperties.__webglColorRenderbuffer[ i ] );\n\n\t\t\t\t\tconst glFormat = utils.convert( texture.format, texture.colorSpace );\n\t\t\t\t\tconst glType = utils.convert( texture.type );\n\t\t\t\t\tconst glInternalFormat = getInternalFormat( texture.internalFormat, glFormat, glType, texture.colorSpace, renderTarget.isXRRenderTarget === true );\n\t\t\t\t\tconst samples = getRenderTargetSamples( renderTarget );\n\t\t\t\t\t_gl.renderbufferStorageMultisample( _gl.RENDERBUFFER, samples, glInternalFormat, renderTarget.width, renderTarget.height );\n\n\t\t\t\t\t_gl.framebufferRenderbuffer( _gl.FRAMEBUFFER, _gl.COLOR_ATTACHMENT0 + i, _gl.RENDERBUFFER, renderTargetProperties.__webglColorRenderbuffer[ i ] );\n\n\t\t\t\t}\n\n\t\t\t\t_gl.bindRenderbuffer( _gl.RENDERBUFFER, null );\n\n\t\t\t\tif ( renderTarget.depthBuffer ) {\n\n\t\t\t\t\trenderTargetProperties.__webglDepthRenderbuffer = _gl.createRenderbuffer();\n\t\t\t\t\tsetupRenderBufferStorage( renderTargetProperties.__webglDepthRenderbuffer, renderTarget, true );\n\n\t\t\t\t}\n\n\t\t\t\tstate.bindFramebuffer( _gl.FRAMEBUFFER, null );\n\n\t\t\t}\n\n\t\t}\n\n\t\t// Setup color buffer\n\n\t\tif ( isCube ) {\n\n\t\t\tstate.bindTexture( _gl.TEXTURE_CUBE_MAP, textureProperties.__webglTexture );\n\t\t\tsetTextureParameters( _gl.TEXTURE_CUBE_MAP, texture );\n\n\t\t\tfor ( let i = 0; i < 6; i ++ ) {\n\n\t\t\t\tif ( texture.mipmaps && texture.mipmaps.length > 0 ) {\n\n\t\t\t\t\tfor ( let level = 0; level < texture.mipmaps.length; level ++ ) {\n\n\t\t\t\t\t\tsetupFrameBufferTexture( renderTargetProperties.__webglFramebuffer[ i ][ level ], renderTarget, texture, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, level );\n\n\t\t\t\t\t}\n\n\t\t\t\t} else {\n\n\t\t\t\t\tsetupFrameBufferTexture( renderTargetProperties.__webglFramebuffer[ i ], renderTarget, texture, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0 );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tif ( textureNeedsGenerateMipmaps( texture ) ) {\n\n\t\t\t\tgenerateMipmap( _gl.TEXTURE_CUBE_MAP );\n\n\t\t\t}\n\n\t\t\tstate.unbindTexture();\n\n\t\t} else if ( isMultipleRenderTargets ) {\n\n\t\t\tfor ( let i = 0, il = textures.length; i < il; i ++ ) {\n\n\t\t\t\tconst attachment = textures[ i ];\n\t\t\t\tconst attachmentProperties = properties.get( attachment );\n\n\t\t\t\tstate.bindTexture( _gl.TEXTURE_2D, attachmentProperties.__webglTexture );\n\t\t\t\tsetTextureParameters( _gl.TEXTURE_2D, attachment );\n\t\t\t\tsetupFrameBufferTexture( renderTargetProperties.__webglFramebuffer, renderTarget, attachment, _gl.COLOR_ATTACHMENT0 + i, _gl.TEXTURE_2D, 0 );\n\n\t\t\t\tif ( textureNeedsGenerateMipmaps( attachment ) ) {\n\n\t\t\t\t\tgenerateMipmap( _gl.TEXTURE_2D );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tstate.unbindTexture();\n\n\t\t} else {\n\n\t\t\tlet glTextureType = _gl.TEXTURE_2D;\n\n\t\t\tif ( renderTarget.isWebGL3DRenderTarget || renderTarget.isWebGLArrayRenderTarget ) {\n\n\t\t\t\tglTextureType = renderTarget.isWebGL3DRenderTarget ? _gl.TEXTURE_3D : _gl.TEXTURE_2D_ARRAY;\n\n\t\t\t}\n\n\t\t\tstate.bindTexture( glTextureType, textureProperties.__webglTexture );\n\t\t\tsetTextureParameters( glTextureType, texture );\n\n\t\t\tif ( texture.mipmaps && texture.mipmaps.length > 0 ) {\n\n\t\t\t\tfor ( let level = 0; level < texture.mipmaps.length; level ++ ) {\n\n\t\t\t\t\tsetupFrameBufferTexture( renderTargetProperties.__webglFramebuffer[ level ], renderTarget, texture, _gl.COLOR_ATTACHMENT0, glTextureType, level );\n\n\t\t\t\t}\n\n\t\t\t} else {\n\n\t\t\t\tsetupFrameBufferTexture( renderTargetProperties.__webglFramebuffer, renderTarget, texture, _gl.COLOR_ATTACHMENT0, glTextureType, 0 );\n\n\t\t\t}\n\n\t\t\tif ( textureNeedsGenerateMipmaps( texture ) ) {\n\n\t\t\t\tgenerateMipmap( glTextureType );\n\n\t\t\t}\n\n\t\t\tstate.unbindTexture();\n\n\t\t}\n\n\t\t// Setup depth and stencil buffers\n\n\t\tif ( renderTarget.depthBuffer ) {\n\n\t\t\tsetupDepthRenderbuffer( renderTarget );\n\n\t\t}\n\n\t}\n\n\tfunction updateRenderTargetMipmap( renderTarget ) {\n\n\t\tconst textures = renderTarget.textures;\n\n\t\tfor ( let i = 0, il = textures.length; i < il; i ++ ) {\n\n\t\t\tconst texture = textures[ i ];\n\n\t\t\tif ( textureNeedsGenerateMipmaps( texture ) ) {\n\n\t\t\t\tconst target = renderTarget.isWebGLCubeRenderTarget ? _gl.TEXTURE_CUBE_MAP : _gl.TEXTURE_2D;\n\t\t\t\tconst webglTexture = properties.get( texture ).__webglTexture;\n\n\t\t\t\tstate.bindTexture( target, webglTexture );\n\t\t\t\tgenerateMipmap( target );\n\t\t\t\tstate.unbindTexture();\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n\tfunction updateMultisampleRenderTarget( renderTarget ) {\n\n\t\tif ( ( renderTarget.samples > 0 ) && useMultisampledRTT( renderTarget ) === false ) {\n\n\t\t\tconst textures = renderTarget.textures;\n\t\t\tconst width = renderTarget.width;\n\t\t\tconst height = renderTarget.height;\n\t\t\tlet mask = _gl.COLOR_BUFFER_BIT;\n\t\t\tconst invalidationArray = [];\n\t\t\tconst depthStyle = renderTarget.stencilBuffer ? _gl.DEPTH_STENCIL_ATTACHMENT : _gl.DEPTH_ATTACHMENT;\n\t\t\tconst renderTargetProperties = properties.get( renderTarget );\n\t\t\tconst isMultipleRenderTargets = ( textures.length > 1 );\n\n\t\t\t// If MRT we need to remove FBO attachments\n\t\t\tif ( isMultipleRenderTargets ) {\n\n\t\t\t\tfor ( let i = 0; i < textures.length; i ++ ) {\n\n\t\t\t\t\tstate.bindFramebuffer( _gl.FRAMEBUFFER, renderTargetProperties.__webglMultisampledFramebuffer );\n\t\t\t\t\t_gl.framebufferRenderbuffer( _gl.FRAMEBUFFER, _gl.COLOR_ATTACHMENT0 + i, _gl.RENDERBUFFER, null );\n\n\t\t\t\t\tstate.bindFramebuffer( _gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer );\n\t\t\t\t\t_gl.framebufferTexture2D( _gl.DRAW_FRAMEBUFFER, _gl.COLOR_ATTACHMENT0 + i, _gl.TEXTURE_2D, null, 0 );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tstate.bindFramebuffer( _gl.READ_FRAMEBUFFER, renderTargetProperties.__webglMultisampledFramebuffer );\n\t\t\tstate.bindFramebuffer( _gl.DRAW_FRAMEBUFFER, renderTargetProperties.__webglFramebuffer );\n\n\t\t\tfor ( let i = 0; i < textures.length; i ++ ) {\n\n\t\t\t\tinvalidationArray.push( _gl.COLOR_ATTACHMENT0 + i );\n\n\t\t\t\tif ( renderTarget.depthBuffer ) {\n\n\t\t\t\t\tinvalidationArray.push( depthStyle );\n\n\t\t\t\t}\n\n\t\t\t\tconst ignoreDepthValues = ( renderTargetProperties.__ignoreDepthValues !== undefined ) ? renderTargetProperties.__ignoreDepthValues : false;\n\n\t\t\t\tif ( ignoreDepthValues === false ) {\n\n\t\t\t\t\tif ( renderTarget.depthBuffer ) mask |= _gl.DEPTH_BUFFER_BIT;\n\n\t\t\t\t\t// resolving stencil is slow with a D3D backend. disable it for all transmission render targets (see #27799)\n\n\t\t\t\t\tif ( renderTarget.stencilBuffer && renderTargetProperties.__isTransmissionRenderTarget !== true ) mask |= _gl.STENCIL_BUFFER_BIT;\n\n\t\t\t\t}\n\n\t\t\t\tif ( isMultipleRenderTargets ) {\n\n\t\t\t\t\t_gl.framebufferRenderbuffer( _gl.READ_FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, _gl.RENDERBUFFER, renderTargetProperties.__webglColorRenderbuffer[ i ] );\n\n\t\t\t\t}\n\n\t\t\t\tif ( ignoreDepthValues === true ) {\n\n\t\t\t\t\t_gl.invalidateFramebuffer( _gl.READ_FRAMEBUFFER, [ depthStyle ] );\n\t\t\t\t\t_gl.invalidateFramebuffer( _gl.DRAW_FRAMEBUFFER, [ depthStyle ] );\n\n\t\t\t\t}\n\n\t\t\t\tif ( isMultipleRenderTargets ) {\n\n\t\t\t\t\tconst webglTexture = properties.get( textures[ i ] ).__webglTexture;\n\t\t\t\t\t_gl.framebufferTexture2D( _gl.DRAW_FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_2D, webglTexture, 0 );\n\n\t\t\t\t}\n\n\t\t\t\t_gl.blitFramebuffer( 0, 0, width, height, 0, 0, width, height, mask, _gl.NEAREST );\n\n\t\t\t\tif ( supportsInvalidateFramebuffer ) {\n\n\t\t\t\t\t_gl.invalidateFramebuffer( _gl.READ_FRAMEBUFFER, invalidationArray );\n\n\t\t\t\t}\n\n\n\t\t\t}\n\n\t\t\tstate.bindFramebuffer( _gl.READ_FRAMEBUFFER, null );\n\t\t\tstate.bindFramebuffer( _gl.DRAW_FRAMEBUFFER, null );\n\n\t\t\t// If MRT since pre-blit we removed the FBO we need to reconstruct the attachments\n\t\t\tif ( isMultipleRenderTargets ) {\n\n\t\t\t\tfor ( let i = 0; i < textures.length; i ++ ) {\n\n\t\t\t\t\tstate.bindFramebuffer( _gl.FRAMEBUFFER, renderTargetProperties.__webglMultisampledFramebuffer );\n\t\t\t\t\t_gl.framebufferRenderbuffer( _gl.FRAMEBUFFER, _gl.COLOR_ATTACHMENT0 + i, _gl.RENDERBUFFER, renderTargetProperties.__webglColorRenderbuffer[ i ] );\n\n\t\t\t\t\tconst webglTexture = properties.get( textures[ i ] ).__webglTexture;\n\n\t\t\t\t\tstate.bindFramebuffer( _gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer );\n\t\t\t\t\t_gl.framebufferTexture2D( _gl.DRAW_FRAMEBUFFER, _gl.COLOR_ATTACHMENT0 + i, _gl.TEXTURE_2D, webglTexture, 0 );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tstate.bindFramebuffer( _gl.DRAW_FRAMEBUFFER, renderTargetProperties.__webglMultisampledFramebuffer );\n\n\t\t}\n\n\t}\n\n\tfunction getRenderTargetSamples( renderTarget ) {\n\n\t\treturn Math.min( capabilities.maxSamples, renderTarget.samples );\n\n\t}\n\n\tfunction useMultisampledRTT( renderTarget ) {\n\n\t\tconst renderTargetProperties = properties.get( renderTarget );\n\n\t\treturn renderTarget.samples > 0 && extensions.has( 'WEBGL_multisampled_render_to_texture' ) === true && renderTargetProperties.__useRenderToTexture !== false;\n\n\t}\n\n\tfunction updateVideoTexture( texture ) {\n\n\t\tconst frame = info.render.frame;\n\n\t\t// Check the last frame we updated the VideoTexture\n\n\t\tif ( _videoTextures.get( texture ) !== frame ) {\n\n\t\t\t_videoTextures.set( texture, frame );\n\t\t\ttexture.update();\n\n\t\t}\n\n\t}\n\n\tfunction verifyColorSpace( texture, image ) {\n\n\t\tconst colorSpace = texture.colorSpace;\n\t\tconst format = texture.format;\n\t\tconst type = texture.type;\n\n\t\tif ( texture.isCompressedTexture === true || texture.isVideoTexture === true ) return image;\n\n\t\tif ( colorSpace !== LinearSRGBColorSpace && colorSpace !== NoColorSpace ) {\n\n\t\t\t// sRGB\n\n\t\t\tif ( ColorManagement.getTransfer( colorSpace ) === SRGBTransfer ) {\n\n\t\t\t\t// in WebGL 2 uncompressed textures can only be sRGB encoded if they have the RGBA8 format\n\n\t\t\t\tif ( format !== RGBAFormat || type !== UnsignedByteType ) {\n\n\t\t\t\t\tconsole.warn( 'THREE.WebGLTextures: sRGB encoded textures have to use RGBAFormat and UnsignedByteType.' );\n\n\t\t\t\t}\n\n\t\t\t} else {\n\n\t\t\t\tconsole.error( 'THREE.WebGLTextures: Unsupported texture color space:', colorSpace );\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn image;\n\n\t}\n\n\tfunction getDimensions( image ) {\n\n\t\tif ( typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement ) {\n\n\t\t\t// if intrinsic data are not available, fallback to width/height\n\n\t\t\t_imageDimensions.width = image.naturalWidth || image.width;\n\t\t\t_imageDimensions.height = image.naturalHeight || image.height;\n\n\t\t} else if ( typeof VideoFrame !== 'undefined' && image instanceof VideoFrame ) {\n\n\t\t\t_imageDimensions.width = image.displayWidth;\n\t\t\t_imageDimensions.height = image.displayHeight;\n\n\t\t} else {\n\n\t\t\t_imageDimensions.width = image.width;\n\t\t\t_imageDimensions.height = image.height;\n\n\t\t}\n\n\t\treturn _imageDimensions;\n\n\t}\n\n\t//\n\n\tthis.allocateTextureUnit = allocateTextureUnit;\n\tthis.resetTextureUnits = resetTextureUnits;\n\n\tthis.setTexture2D = setTexture2D;\n\tthis.setTexture2DArray = setTexture2DArray;\n\tthis.setTexture3D = setTexture3D;\n\tthis.setTextureCube = setTextureCube;\n\tthis.rebindTextures = rebindTextures;\n\tthis.setupRenderTarget = setupRenderTarget;\n\tthis.updateRenderTargetMipmap = updateRenderTargetMipmap;\n\tthis.updateMultisampleRenderTarget = updateMultisampleRenderTarget;\n\tthis.setupDepthRenderbuffer = setupDepthRenderbuffer;\n\tthis.setupFrameBufferTexture = setupFrameBufferTexture;\n\tthis.useMultisampledRTT = useMultisampledRTT;\n\n}\n\nfunction WebGLUtils( gl, extensions ) {\n\n\tfunction convert( p, colorSpace = NoColorSpace ) {\n\n\t\tlet extension;\n\n\t\tconst transfer = ColorManagement.getTransfer( colorSpace );\n\n\t\tif ( p === UnsignedByteType ) return gl.UNSIGNED_BYTE;\n\t\tif ( p === UnsignedShort4444Type ) return gl.UNSIGNED_SHORT_4_4_4_4;\n\t\tif ( p === UnsignedShort5551Type ) return gl.UNSIGNED_SHORT_5_5_5_1;\n\t\tif ( p === UnsignedInt5999Type ) return gl.UNSIGNED_INT_5_9_9_9_REV;\n\n\t\tif ( p === ByteType ) return gl.BYTE;\n\t\tif ( p === ShortType ) return gl.SHORT;\n\t\tif ( p === UnsignedShortType ) return gl.UNSIGNED_SHORT;\n\t\tif ( p === IntType ) return gl.INT;\n\t\tif ( p === UnsignedIntType ) return gl.UNSIGNED_INT;\n\t\tif ( p === FloatType ) return gl.FLOAT;\n\t\tif ( p === HalfFloatType ) return gl.HALF_FLOAT;\n\n\t\tif ( p === AlphaFormat ) return gl.ALPHA;\n\t\tif ( p === RGBFormat ) return gl.RGB;\n\t\tif ( p === RGBAFormat ) return gl.RGBA;\n\t\tif ( p === LuminanceFormat ) return gl.LUMINANCE;\n\t\tif ( p === LuminanceAlphaFormat ) return gl.LUMINANCE_ALPHA;\n\t\tif ( p === DepthFormat ) return gl.DEPTH_COMPONENT;\n\t\tif ( p === DepthStencilFormat ) return gl.DEPTH_STENCIL;\n\n\t\t// WebGL2 formats.\n\n\t\tif ( p === RedFormat ) return gl.RED;\n\t\tif ( p === RedIntegerFormat ) return gl.RED_INTEGER;\n\t\tif ( p === RGFormat ) return gl.RG;\n\t\tif ( p === RGIntegerFormat ) return gl.RG_INTEGER;\n\t\tif ( p === RGBAIntegerFormat ) return gl.RGBA_INTEGER;\n\n\t\t// S3TC\n\n\t\tif ( p === RGB_S3TC_DXT1_Format || p === RGBA_S3TC_DXT1_Format || p === RGBA_S3TC_DXT3_Format || p === RGBA_S3TC_DXT5_Format ) {\n\n\t\t\tif ( transfer === SRGBTransfer ) {\n\n\t\t\t\textension = extensions.get( 'WEBGL_compressed_texture_s3tc_srgb' );\n\n\t\t\t\tif ( extension !== null ) {\n\n\t\t\t\t\tif ( p === RGB_S3TC_DXT1_Format ) return extension.COMPRESSED_SRGB_S3TC_DXT1_EXT;\n\t\t\t\t\tif ( p === RGBA_S3TC_DXT1_Format ) return extension.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT;\n\t\t\t\t\tif ( p === RGBA_S3TC_DXT3_Format ) return extension.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT;\n\t\t\t\t\tif ( p === RGBA_S3TC_DXT5_Format ) return extension.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT;\n\n\t\t\t\t} else {\n\n\t\t\t\t\treturn null;\n\n\t\t\t\t}\n\n\t\t\t} else {\n\n\t\t\t\textension = extensions.get( 'WEBGL_compressed_texture_s3tc' );\n\n\t\t\t\tif ( extension !== null ) {\n\n\t\t\t\t\tif ( p === RGB_S3TC_DXT1_Format ) return extension.COMPRESSED_RGB_S3TC_DXT1_EXT;\n\t\t\t\t\tif ( p === RGBA_S3TC_DXT1_Format ) return extension.COMPRESSED_RGBA_S3TC_DXT1_EXT;\n\t\t\t\t\tif ( p === RGBA_S3TC_DXT3_Format ) return extension.COMPRESSED_RGBA_S3TC_DXT3_EXT;\n\t\t\t\t\tif ( p === RGBA_S3TC_DXT5_Format ) return extension.COMPRESSED_RGBA_S3TC_DXT5_EXT;\n\n\t\t\t\t} else {\n\n\t\t\t\t\treturn null;\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t\t// PVRTC\n\n\t\tif ( p === RGB_PVRTC_4BPPV1_Format || p === RGB_PVRTC_2BPPV1_Format || p === RGBA_PVRTC_4BPPV1_Format || p === RGBA_PVRTC_2BPPV1_Format ) {\n\n\t\t\textension = extensions.get( 'WEBGL_compressed_texture_pvrtc' );\n\n\t\t\tif ( extension !== null ) {\n\n\t\t\t\tif ( p === RGB_PVRTC_4BPPV1_Format ) return extension.COMPRESSED_RGB_PVRTC_4BPPV1_IMG;\n\t\t\t\tif ( p === RGB_PVRTC_2BPPV1_Format ) return extension.COMPRESSED_RGB_PVRTC_2BPPV1_IMG;\n\t\t\t\tif ( p === RGBA_PVRTC_4BPPV1_Format ) return extension.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;\n\t\t\t\tif ( p === RGBA_PVRTC_2BPPV1_Format ) return extension.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG;\n\n\t\t\t} else {\n\n\t\t\t\treturn null;\n\n\t\t\t}\n\n\t\t}\n\n\t\t// ETC1\n\n\t\tif ( p === RGB_ETC1_Format ) {\n\n\t\t\textension = extensions.get( 'WEBGL_compressed_texture_etc1' );\n\n\t\t\tif ( extension !== null ) {\n\n\t\t\t\treturn extension.COMPRESSED_RGB_ETC1_WEBGL;\n\n\t\t\t} else {\n\n\t\t\t\treturn null;\n\n\t\t\t}\n\n\t\t}\n\n\t\t// ETC2\n\n\t\tif ( p === RGB_ETC2_Format || p === RGBA_ETC2_EAC_Format ) {\n\n\t\t\textension = extensions.get( 'WEBGL_compressed_texture_etc' );\n\n\t\t\tif ( extension !== null ) {\n\n\t\t\t\tif ( p === RGB_ETC2_Format ) return ( transfer === SRGBTransfer ) ? extension.COMPRESSED_SRGB8_ETC2 : extension.COMPRESSED_RGB8_ETC2;\n\t\t\t\tif ( p === RGBA_ETC2_EAC_Format ) return ( transfer === SRGBTransfer ) ? extension.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC : extension.COMPRESSED_RGBA8_ETC2_EAC;\n\n\t\t\t} else {\n\n\t\t\t\treturn null;\n\n\t\t\t}\n\n\t\t}\n\n\t\t// ASTC\n\n\t\tif ( p === RGBA_ASTC_4x4_Format || p === RGBA_ASTC_5x4_Format || p === RGBA_ASTC_5x5_Format ||\n\t\t\tp === RGBA_ASTC_6x5_Format || p === RGBA_ASTC_6x6_Format || p === RGBA_ASTC_8x5_Format ||\n\t\t\tp === RGBA_ASTC_8x6_Format || p === RGBA_ASTC_8x8_Format || p === RGBA_ASTC_10x5_Format ||\n\t\t\tp === RGBA_ASTC_10x6_Format || p === RGBA_ASTC_10x8_Format || p === RGBA_ASTC_10x10_Format ||\n\t\t\tp === RGBA_ASTC_12x10_Format || p === RGBA_ASTC_12x12_Format ) {\n\n\t\t\textension = extensions.get( 'WEBGL_compressed_texture_astc' );\n\n\t\t\tif ( extension !== null ) {\n\n\t\t\t\tif ( p === RGBA_ASTC_4x4_Format ) return ( transfer === SRGBTransfer ) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR : extension.COMPRESSED_RGBA_ASTC_4x4_KHR;\n\t\t\t\tif ( p === RGBA_ASTC_5x4_Format ) return ( transfer === SRGBTransfer ) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR : extension.COMPRESSED_RGBA_ASTC_5x4_KHR;\n\t\t\t\tif ( p === RGBA_ASTC_5x5_Format ) return ( transfer === SRGBTransfer ) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR : extension.COMPRESSED_RGBA_ASTC_5x5_KHR;\n\t\t\t\tif ( p === RGBA_ASTC_6x5_Format ) return ( transfer === SRGBTransfer ) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR : extension.COMPRESSED_RGBA_ASTC_6x5_KHR;\n\t\t\t\tif ( p === RGBA_ASTC_6x6_Format ) return ( transfer === SRGBTransfer ) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR : extension.COMPRESSED_RGBA_ASTC_6x6_KHR;\n\t\t\t\tif ( p === RGBA_ASTC_8x5_Format ) return ( transfer === SRGBTransfer ) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR : extension.COMPRESSED_RGBA_ASTC_8x5_KHR;\n\t\t\t\tif ( p === RGBA_ASTC_8x6_Format ) return ( transfer === SRGBTransfer ) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR : extension.COMPRESSED_RGBA_ASTC_8x6_KHR;\n\t\t\t\tif ( p === RGBA_ASTC_8x8_Format ) return ( transfer === SRGBTransfer ) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR : extension.COMPRESSED_RGBA_ASTC_8x8_KHR;\n\t\t\t\tif ( p === RGBA_ASTC_10x5_Format ) return ( transfer === SRGBTransfer ) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR : extension.COMPRESSED_RGBA_ASTC_10x5_KHR;\n\t\t\t\tif ( p === RGBA_ASTC_10x6_Format ) return ( transfer === SRGBTransfer ) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR : extension.COMPRESSED_RGBA_ASTC_10x6_KHR;\n\t\t\t\tif ( p === RGBA_ASTC_10x8_Format ) return ( transfer === SRGBTransfer ) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR : extension.COMPRESSED_RGBA_ASTC_10x8_KHR;\n\t\t\t\tif ( p === RGBA_ASTC_10x10_Format ) return ( transfer === SRGBTransfer ) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR : extension.COMPRESSED_RGBA_ASTC_10x10_KHR;\n\t\t\t\tif ( p === RGBA_ASTC_12x10_Format ) return ( transfer === SRGBTransfer ) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR : extension.COMPRESSED_RGBA_ASTC_12x10_KHR;\n\t\t\t\tif ( p === RGBA_ASTC_12x12_Format ) return ( transfer === SRGBTransfer ) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR : extension.COMPRESSED_RGBA_ASTC_12x12_KHR;\n\n\t\t\t} else {\n\n\t\t\t\treturn null;\n\n\t\t\t}\n\n\t\t}\n\n\t\t// BPTC\n\n\t\tif ( p === RGBA_BPTC_Format || p === RGB_BPTC_SIGNED_Format || p === RGB_BPTC_UNSIGNED_Format ) {\n\n\t\t\textension = extensions.get( 'EXT_texture_compression_bptc' );\n\n\t\t\tif ( extension !== null ) {\n\n\t\t\t\tif ( p === RGBA_BPTC_Format ) return ( transfer === SRGBTransfer ) ? extension.COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT : extension.COMPRESSED_RGBA_BPTC_UNORM_EXT;\n\t\t\t\tif ( p === RGB_BPTC_SIGNED_Format ) return extension.COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT;\n\t\t\t\tif ( p === RGB_BPTC_UNSIGNED_Format ) return extension.COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT;\n\n\t\t\t} else {\n\n\t\t\t\treturn null;\n\n\t\t\t}\n\n\t\t}\n\n\t\t// RGTC\n\n\t\tif ( p === RED_RGTC1_Format || p === SIGNED_RED_RGTC1_Format || p === RED_GREEN_RGTC2_Format || p === SIGNED_RED_GREEN_RGTC2_Format ) {\n\n\t\t\textension = extensions.get( 'EXT_texture_compression_rgtc' );\n\n\t\t\tif ( extension !== null ) {\n\n\t\t\t\tif ( p === RGBA_BPTC_Format ) return extension.COMPRESSED_RED_RGTC1_EXT;\n\t\t\t\tif ( p === SIGNED_RED_RGTC1_Format ) return extension.COMPRESSED_SIGNED_RED_RGTC1_EXT;\n\t\t\t\tif ( p === RED_GREEN_RGTC2_Format ) return extension.COMPRESSED_RED_GREEN_RGTC2_EXT;\n\t\t\t\tif ( p === SIGNED_RED_GREEN_RGTC2_Format ) return extension.COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT;\n\n\t\t\t} else {\n\n\t\t\t\treturn null;\n\n\t\t\t}\n\n\t\t}\n\n\t\t//\n\n\t\tif ( p === UnsignedInt248Type ) return gl.UNSIGNED_INT_24_8;\n\n\t\t// if \"p\" can't be resolved, assume the user defines a WebGL constant as a string (fallback/workaround for packed RGB formats)\n\n\t\treturn ( gl[ p ] !== undefined ) ? gl[ p ] : null;\n\n\t}\n\n\treturn { convert: convert };\n\n}\n\nclass ArrayCamera extends PerspectiveCamera {\n\n\tconstructor( array = [] ) {\n\n\t\tsuper();\n\n\t\tthis.isArrayCamera = true;\n\n\t\tthis.cameras = array;\n\n\t}\n\n}\n\nclass Group extends Object3D {\n\n\tconstructor() {\n\n\t\tsuper();\n\n\t\tthis.isGroup = true;\n\n\t\tthis.type = 'Group';\n\n\t}\n\n}\n\nconst _moveEvent = { type: 'move' };\n\nclass WebXRController {\n\n\tconstructor() {\n\n\t\tthis._targetRay = null;\n\t\tthis._grip = null;\n\t\tthis._hand = null;\n\n\t}\n\n\tgetHandSpace() {\n\n\t\tif ( this._hand === null ) {\n\n\t\t\tthis._hand = new Group();\n\t\t\tthis._hand.matrixAutoUpdate = false;\n\t\t\tthis._hand.visible = false;\n\n\t\t\tthis._hand.joints = {};\n\t\t\tthis._hand.inputState = { pinching: false };\n\n\t\t}\n\n\t\treturn this._hand;\n\n\t}\n\n\tgetTargetRaySpace() {\n\n\t\tif ( this._targetRay === null ) {\n\n\t\t\tthis._targetRay = new Group();\n\t\t\tthis._targetRay.matrixAutoUpdate = false;\n\t\t\tthis._targetRay.visible = false;\n\t\t\tthis._targetRay.hasLinearVelocity = false;\n\t\t\tthis._targetRay.linearVelocity = new Vector3();\n\t\t\tthis._targetRay.hasAngularVelocity = false;\n\t\t\tthis._targetRay.angularVelocity = new Vector3();\n\n\t\t}\n\n\t\treturn this._targetRay;\n\n\t}\n\n\tgetGripSpace() {\n\n\t\tif ( this._grip === null ) {\n\n\t\t\tthis._grip = new Group();\n\t\t\tthis._grip.matrixAutoUpdate = false;\n\t\t\tthis._grip.visible = false;\n\t\t\tthis._grip.hasLinearVelocity = false;\n\t\t\tthis._grip.linearVelocity = new Vector3();\n\t\t\tthis._grip.hasAngularVelocity = false;\n\t\t\tthis._grip.angularVelocity = new Vector3();\n\n\t\t}\n\n\t\treturn this._grip;\n\n\t}\n\n\tdispatchEvent( event ) {\n\n\t\tif ( this._targetRay !== null ) {\n\n\t\t\tthis._targetRay.dispatchEvent( event );\n\n\t\t}\n\n\t\tif ( this._grip !== null ) {\n\n\t\t\tthis._grip.dispatchEvent( event );\n\n\t\t}\n\n\t\tif ( this._hand !== null ) {\n\n\t\t\tthis._hand.dispatchEvent( event );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tconnect( inputSource ) {\n\n\t\tif ( inputSource && inputSource.hand ) {\n\n\t\t\tconst hand = this._hand;\n\n\t\t\tif ( hand ) {\n\n\t\t\t\tfor ( const inputjoint of inputSource.hand.values() ) {\n\n\t\t\t\t\t// Initialize hand with joints when connected\n\t\t\t\t\tthis._getHandJoint( hand, inputjoint );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t\tthis.dispatchEvent( { type: 'connected', data: inputSource } );\n\n\t\treturn this;\n\n\t}\n\n\tdisconnect( inputSource ) {\n\n\t\tthis.dispatchEvent( { type: 'disconnected', data: inputSource } );\n\n\t\tif ( this._targetRay !== null ) {\n\n\t\t\tthis._targetRay.visible = false;\n\n\t\t}\n\n\t\tif ( this._grip !== null ) {\n\n\t\t\tthis._grip.visible = false;\n\n\t\t}\n\n\t\tif ( this._hand !== null ) {\n\n\t\t\tthis._hand.visible = false;\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tupdate( inputSource, frame, referenceSpace ) {\n\n\t\tlet inputPose = null;\n\t\tlet gripPose = null;\n\t\tlet handPose = null;\n\n\t\tconst targetRay = this._targetRay;\n\t\tconst grip = this._grip;\n\t\tconst hand = this._hand;\n\n\t\tif ( inputSource && frame.session.visibilityState !== 'visible-blurred' ) {\n\n\t\t\tif ( hand && inputSource.hand ) {\n\n\t\t\t\thandPose = true;\n\n\t\t\t\tfor ( const inputjoint of inputSource.hand.values() ) {\n\n\t\t\t\t\t// Update the joints groups with the XRJoint poses\n\t\t\t\t\tconst jointPose = frame.getJointPose( inputjoint, referenceSpace );\n\n\t\t\t\t\t// The transform of this joint will be updated with the joint pose on each frame\n\t\t\t\t\tconst joint = this._getHandJoint( hand, inputjoint );\n\n\t\t\t\t\tif ( jointPose !== null ) {\n\n\t\t\t\t\t\tjoint.matrix.fromArray( jointPose.transform.matrix );\n\t\t\t\t\t\tjoint.matrix.decompose( joint.position, joint.rotation, joint.scale );\n\t\t\t\t\t\tjoint.matrixWorldNeedsUpdate = true;\n\t\t\t\t\t\tjoint.jointRadius = jointPose.radius;\n\n\t\t\t\t\t}\n\n\t\t\t\t\tjoint.visible = jointPose !== null;\n\n\t\t\t\t}\n\n\t\t\t\t// Custom events\n\n\t\t\t\t// Check pinchz\n\t\t\t\tconst indexTip = hand.joints[ 'index-finger-tip' ];\n\t\t\t\tconst thumbTip = hand.joints[ 'thumb-tip' ];\n\t\t\t\tconst distance = indexTip.position.distanceTo( thumbTip.position );\n\n\t\t\t\tconst distanceToPinch = 0.02;\n\t\t\t\tconst threshold = 0.005;\n\n\t\t\t\tif ( hand.inputState.pinching && distance > distanceToPinch + threshold ) {\n\n\t\t\t\t\thand.inputState.pinching = false;\n\t\t\t\t\tthis.dispatchEvent( {\n\t\t\t\t\t\ttype: 'pinchend',\n\t\t\t\t\t\thandedness: inputSource.handedness,\n\t\t\t\t\t\ttarget: this\n\t\t\t\t\t} );\n\n\t\t\t\t} else if ( ! hand.inputState.pinching && distance <= distanceToPinch - threshold ) {\n\n\t\t\t\t\thand.inputState.pinching = true;\n\t\t\t\t\tthis.dispatchEvent( {\n\t\t\t\t\t\ttype: 'pinchstart',\n\t\t\t\t\t\thandedness: inputSource.handedness,\n\t\t\t\t\t\ttarget: this\n\t\t\t\t\t} );\n\n\t\t\t\t}\n\n\t\t\t} else {\n\n\t\t\t\tif ( grip !== null && inputSource.gripSpace ) {\n\n\t\t\t\t\tgripPose = frame.getPose( inputSource.gripSpace, referenceSpace );\n\n\t\t\t\t\tif ( gripPose !== null ) {\n\n\t\t\t\t\t\tgrip.matrix.fromArray( gripPose.transform.matrix );\n\t\t\t\t\t\tgrip.matrix.decompose( grip.position, grip.rotation, grip.scale );\n\t\t\t\t\t\tgrip.matrixWorldNeedsUpdate = true;\n\n\t\t\t\t\t\tif ( gripPose.linearVelocity ) {\n\n\t\t\t\t\t\t\tgrip.hasLinearVelocity = true;\n\t\t\t\t\t\t\tgrip.linearVelocity.copy( gripPose.linearVelocity );\n\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\tgrip.hasLinearVelocity = false;\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tif ( gripPose.angularVelocity ) {\n\n\t\t\t\t\t\t\tgrip.hasAngularVelocity = true;\n\t\t\t\t\t\t\tgrip.angularVelocity.copy( gripPose.angularVelocity );\n\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\tgrip.hasAngularVelocity = false;\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tif ( targetRay !== null ) {\n\n\t\t\t\tinputPose = frame.getPose( inputSource.targetRaySpace, referenceSpace );\n\n\t\t\t\t// Some runtimes (namely Vive Cosmos with Vive OpenXR Runtime) have only grip space and ray space is equal to it\n\t\t\t\tif ( inputPose === null && gripPose !== null ) {\n\n\t\t\t\t\tinputPose = gripPose;\n\n\t\t\t\t}\n\n\t\t\t\tif ( inputPose !== null ) {\n\n\t\t\t\t\ttargetRay.matrix.fromArray( inputPose.transform.matrix );\n\t\t\t\t\ttargetRay.matrix.decompose( targetRay.position, targetRay.rotation, targetRay.scale );\n\t\t\t\t\ttargetRay.matrixWorldNeedsUpdate = true;\n\n\t\t\t\t\tif ( inputPose.linearVelocity ) {\n\n\t\t\t\t\t\ttargetRay.hasLinearVelocity = true;\n\t\t\t\t\t\ttargetRay.linearVelocity.copy( inputPose.linearVelocity );\n\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\ttargetRay.hasLinearVelocity = false;\n\n\t\t\t\t\t}\n\n\t\t\t\t\tif ( inputPose.angularVelocity ) {\n\n\t\t\t\t\t\ttargetRay.hasAngularVelocity = true;\n\t\t\t\t\t\ttargetRay.angularVelocity.copy( inputPose.angularVelocity );\n\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\ttargetRay.hasAngularVelocity = false;\n\n\t\t\t\t\t}\n\n\t\t\t\t\tthis.dispatchEvent( _moveEvent );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\n\t\t}\n\n\t\tif ( targetRay !== null ) {\n\n\t\t\ttargetRay.visible = ( inputPose !== null );\n\n\t\t}\n\n\t\tif ( grip !== null ) {\n\n\t\t\tgrip.visible = ( gripPose !== null );\n\n\t\t}\n\n\t\tif ( hand !== null ) {\n\n\t\t\thand.visible = ( handPose !== null );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\t// private method\n\n\t_getHandJoint( hand, inputjoint ) {\n\n\t\tif ( hand.joints[ inputjoint.jointName ] === undefined ) {\n\n\t\t\tconst joint = new Group();\n\t\t\tjoint.matrixAutoUpdate = false;\n\t\t\tjoint.visible = false;\n\t\t\thand.joints[ inputjoint.jointName ] = joint;\n\n\t\t\thand.add( joint );\n\n\t\t}\n\n\t\treturn hand.joints[ inputjoint.jointName ];\n\n\t}\n\n}\n\nconst _occlusion_vertex = `\nvoid main() {\n\n\tgl_Position = vec4( position, 1.0 );\n\n}`;\n\nconst _occlusion_fragment = `\nuniform sampler2DArray depthColor;\nuniform float depthWidth;\nuniform float depthHeight;\n\nvoid main() {\n\n\tvec2 coord = vec2( gl_FragCoord.x / depthWidth, gl_FragCoord.y / depthHeight );\n\n\tif ( coord.x >= 1.0 ) {\n\n\t\tgl_FragDepth = texture( depthColor, vec3( coord.x - 1.0, coord.y, 1 ) ).r;\n\n\t} else {\n\n\t\tgl_FragDepth = texture( depthColor, vec3( coord.x, coord.y, 0 ) ).r;\n\n\t}\n\n}`;\n\nclass WebXRDepthSensing {\n\n\tconstructor() {\n\n\t\tthis.texture = null;\n\t\tthis.mesh = null;\n\n\t\tthis.depthNear = 0;\n\t\tthis.depthFar = 0;\n\n\t}\n\n\tinit( renderer, depthData, renderState ) {\n\n\t\tif ( this.texture === null ) {\n\n\t\t\tconst texture = new Texture();\n\n\t\t\tconst texProps = renderer.properties.get( texture );\n\t\t\ttexProps.__webglTexture = depthData.texture;\n\n\t\t\tif ( ( depthData.depthNear != renderState.depthNear ) || ( depthData.depthFar != renderState.depthFar ) ) {\n\n\t\t\t\tthis.depthNear = depthData.depthNear;\n\t\t\t\tthis.depthFar = depthData.depthFar;\n\n\t\t\t}\n\n\t\t\tthis.texture = texture;\n\n\t\t}\n\n\t}\n\n\trender( renderer, cameraXR ) {\n\n\t\tif ( this.texture !== null ) {\n\n\t\t\tif ( this.mesh === null ) {\n\n\t\t\t\tconst viewport = cameraXR.cameras[ 0 ].viewport;\n\t\t\t\tconst material = new ShaderMaterial( {\n\t\t\t\t\tvertexShader: _occlusion_vertex,\n\t\t\t\t\tfragmentShader: _occlusion_fragment,\n\t\t\t\t\tuniforms: {\n\t\t\t\t\t\tdepthColor: { value: this.texture },\n\t\t\t\t\t\tdepthWidth: { value: viewport.z },\n\t\t\t\t\t\tdepthHeight: { value: viewport.w }\n\t\t\t\t\t}\n\t\t\t\t} );\n\n\t\t\t\tthis.mesh = new Mesh( new PlaneGeometry( 20, 20 ), material );\n\n\t\t\t}\n\n\t\t\trenderer.render( this.mesh, cameraXR );\n\n\t\t}\n\n\t}\n\n\treset() {\n\n\t\tthis.texture = null;\n\t\tthis.mesh = null;\n\n\t}\n\n}\n\nclass WebXRManager extends EventDispatcher {\n\n\tconstructor( renderer, gl ) {\n\n\t\tsuper();\n\n\t\tconst scope = this;\n\n\t\tlet session = null;\n\n\t\tlet framebufferScaleFactor = 1.0;\n\n\t\tlet referenceSpace = null;\n\t\tlet referenceSpaceType = 'local-floor';\n\t\t// Set default foveation to maximum.\n\t\tlet foveation = 1.0;\n\t\tlet customReferenceSpace = null;\n\n\t\tlet pose = null;\n\t\tlet glBinding = null;\n\t\tlet glProjLayer = null;\n\t\tlet glBaseLayer = null;\n\t\tlet xrFrame = null;\n\n\t\tconst depthSensing = new WebXRDepthSensing();\n\t\tconst attributes = gl.getContextAttributes();\n\n\t\tlet initialRenderTarget = null;\n\t\tlet newRenderTarget = null;\n\n\t\tconst controllers = [];\n\t\tconst controllerInputSources = [];\n\n\t\tconst currentSize = new Vector2();\n\t\tlet currentPixelRatio = null;\n\n\t\t//\n\n\t\tconst cameraL = new PerspectiveCamera();\n\t\tcameraL.layers.enable( 1 );\n\t\tcameraL.viewport = new Vector4();\n\n\t\tconst cameraR = new PerspectiveCamera();\n\t\tcameraR.layers.enable( 2 );\n\t\tcameraR.viewport = new Vector4();\n\n\t\tconst cameras = [ cameraL, cameraR ];\n\n\t\tconst cameraXR = new ArrayCamera();\n\t\tcameraXR.layers.enable( 1 );\n\t\tcameraXR.layers.enable( 2 );\n\n\t\tlet _currentDepthNear = null;\n\t\tlet _currentDepthFar = null;\n\n\t\t//\n\n\t\tthis.cameraAutoUpdate = true;\n\t\tthis.enabled = false;\n\n\t\tthis.isPresenting = false;\n\n\t\tthis.getController = function ( index ) {\n\n\t\t\tlet controller = controllers[ index ];\n\n\t\t\tif ( controller === undefined ) {\n\n\t\t\t\tcontroller = new WebXRController();\n\t\t\t\tcontrollers[ index ] = controller;\n\n\t\t\t}\n\n\t\t\treturn controller.getTargetRaySpace();\n\n\t\t};\n\n\t\tthis.getControllerGrip = function ( index ) {\n\n\t\t\tlet controller = controllers[ index ];\n\n\t\t\tif ( controller === undefined ) {\n\n\t\t\t\tcontroller = new WebXRController();\n\t\t\t\tcontrollers[ index ] = controller;\n\n\t\t\t}\n\n\t\t\treturn controller.getGripSpace();\n\n\t\t};\n\n\t\tthis.getHand = function ( index ) {\n\n\t\t\tlet controller = controllers[ index ];\n\n\t\t\tif ( controller === undefined ) {\n\n\t\t\t\tcontroller = new WebXRController();\n\t\t\t\tcontrollers[ index ] = controller;\n\n\t\t\t}\n\n\t\t\treturn controller.getHandSpace();\n\n\t\t};\n\n\t\t//\n\n\t\tfunction onSessionEvent( event ) {\n\n\t\t\tconst controllerIndex = controllerInputSources.indexOf( event.inputSource );\n\n\t\t\tif ( controllerIndex === - 1 ) {\n\n\t\t\t\treturn;\n\n\t\t\t}\n\n\t\t\tconst controller = controllers[ controllerIndex ];\n\n\t\t\tif ( controller !== undefined ) {\n\n\t\t\t\tcontroller.update( event.inputSource, event.frame, customReferenceSpace || referenceSpace );\n\t\t\t\tcontroller.dispatchEvent( { type: event.type, data: event.inputSource } );\n\n\t\t\t}\n\n\t\t}\n\n\t\tfunction onSessionEnd() {\n\n\t\t\tsession.removeEventListener( 'select', onSessionEvent );\n\t\t\tsession.removeEventListener( 'selectstart', onSessionEvent );\n\t\t\tsession.removeEventListener( 'selectend', onSessionEvent );\n\t\t\tsession.removeEventListener( 'squeeze', onSessionEvent );\n\t\t\tsession.removeEventListener( 'squeezestart', onSessionEvent );\n\t\t\tsession.removeEventListener( 'squeezeend', onSessionEvent );\n\t\t\tsession.removeEventListener( 'end', onSessionEnd );\n\t\t\tsession.removeEventListener( 'inputsourceschange', onInputSourcesChange );\n\n\t\t\tfor ( let i = 0; i < controllers.length; i ++ ) {\n\n\t\t\t\tconst inputSource = controllerInputSources[ i ];\n\n\t\t\t\tif ( inputSource === null ) continue;\n\n\t\t\t\tcontrollerInputSources[ i ] = null;\n\n\t\t\t\tcontrollers[ i ].disconnect( inputSource );\n\n\t\t\t}\n\n\t\t\t_currentDepthNear = null;\n\t\t\t_currentDepthFar = null;\n\n\t\t\tdepthSensing.reset();\n\n\t\t\t// restore framebuffer/rendering state\n\n\t\t\trenderer.setRenderTarget( initialRenderTarget );\n\n\t\t\tglBaseLayer = null;\n\t\t\tglProjLayer = null;\n\t\t\tglBinding = null;\n\t\t\tsession = null;\n\t\t\tnewRenderTarget = null;\n\n\t\t\t//\n\n\t\t\tanimation.stop();\n\n\t\t\tscope.isPresenting = false;\n\n\t\t\trenderer.setPixelRatio( currentPixelRatio );\n\t\t\trenderer.setSize( currentSize.width, currentSize.height, false );\n\n\t\t\tscope.dispatchEvent( { type: 'sessionend' } );\n\n\t\t}\n\n\t\tthis.setFramebufferScaleFactor = function ( value ) {\n\n\t\t\tframebufferScaleFactor = value;\n\n\t\t\tif ( scope.isPresenting === true ) {\n\n\t\t\t\tconsole.warn( 'THREE.WebXRManager: Cannot change framebuffer scale while presenting.' );\n\n\t\t\t}\n\n\t\t};\n\n\t\tthis.setReferenceSpaceType = function ( value ) {\n\n\t\t\treferenceSpaceType = value;\n\n\t\t\tif ( scope.isPresenting === true ) {\n\n\t\t\t\tconsole.warn( 'THREE.WebXRManager: Cannot change reference space type while presenting.' );\n\n\t\t\t}\n\n\t\t};\n\n\t\tthis.getReferenceSpace = function () {\n\n\t\t\treturn customReferenceSpace || referenceSpace;\n\n\t\t};\n\n\t\tthis.setReferenceSpace = function ( space ) {\n\n\t\t\tcustomReferenceSpace = space;\n\n\t\t};\n\n\t\tthis.getBaseLayer = function () {\n\n\t\t\treturn glProjLayer !== null ? glProjLayer : glBaseLayer;\n\n\t\t};\n\n\t\tthis.getBinding = function () {\n\n\t\t\treturn glBinding;\n\n\t\t};\n\n\t\tthis.getFrame = function () {\n\n\t\t\treturn xrFrame;\n\n\t\t};\n\n\t\tthis.getSession = function () {\n\n\t\t\treturn session;\n\n\t\t};\n\n\t\tthis.setSession = async function ( value ) {\n\n\t\t\tsession = value;\n\n\t\t\tif ( session !== null ) {\n\n\t\t\t\tinitialRenderTarget = renderer.getRenderTarget();\n\n\t\t\t\tsession.addEventListener( 'select', onSessionEvent );\n\t\t\t\tsession.addEventListener( 'selectstart', onSessionEvent );\n\t\t\t\tsession.addEventListener( 'selectend', onSessionEvent );\n\t\t\t\tsession.addEventListener( 'squeeze', onSessionEvent );\n\t\t\t\tsession.addEventListener( 'squeezestart', onSessionEvent );\n\t\t\t\tsession.addEventListener( 'squeezeend', onSessionEvent );\n\t\t\t\tsession.addEventListener( 'end', onSessionEnd );\n\t\t\t\tsession.addEventListener( 'inputsourceschange', onInputSourcesChange );\n\n\t\t\t\tif ( attributes.xrCompatible !== true ) {\n\n\t\t\t\t\tawait gl.makeXRCompatible();\n\n\t\t\t\t}\n\n\t\t\t\tcurrentPixelRatio = renderer.getPixelRatio();\n\t\t\t\trenderer.getSize( currentSize );\n\n\t\t\t\tif ( session.renderState.layers === undefined ) {\n\n\t\t\t\t\tconst layerInit = {\n\t\t\t\t\t\tantialias: attributes.antialias,\n\t\t\t\t\t\talpha: true,\n\t\t\t\t\t\tdepth: attributes.depth,\n\t\t\t\t\t\tstencil: attributes.stencil,\n\t\t\t\t\t\tframebufferScaleFactor: framebufferScaleFactor\n\t\t\t\t\t};\n\n\t\t\t\t\tglBaseLayer = new XRWebGLLayer( session, gl, layerInit );\n\n\t\t\t\t\tsession.updateRenderState( { baseLayer: glBaseLayer } );\n\n\t\t\t\t\trenderer.setPixelRatio( 1 );\n\t\t\t\t\trenderer.setSize( glBaseLayer.framebufferWidth, glBaseLayer.framebufferHeight, false );\n\n\t\t\t\t\tnewRenderTarget = new WebGLRenderTarget(\n\t\t\t\t\t\tglBaseLayer.framebufferWidth,\n\t\t\t\t\t\tglBaseLayer.framebufferHeight,\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tformat: RGBAFormat,\n\t\t\t\t\t\t\ttype: UnsignedByteType,\n\t\t\t\t\t\t\tcolorSpace: renderer.outputColorSpace,\n\t\t\t\t\t\t\tstencilBuffer: attributes.stencil\n\t\t\t\t\t\t}\n\t\t\t\t\t);\n\n\t\t\t\t} else {\n\n\t\t\t\t\tlet depthFormat = null;\n\t\t\t\t\tlet depthType = null;\n\t\t\t\t\tlet glDepthFormat = null;\n\n\t\t\t\t\tif ( attributes.depth ) {\n\n\t\t\t\t\t\tglDepthFormat = attributes.stencil ? gl.DEPTH24_STENCIL8 : gl.DEPTH_COMPONENT24;\n\t\t\t\t\t\tdepthFormat = attributes.stencil ? DepthStencilFormat : DepthFormat;\n\t\t\t\t\t\tdepthType = attributes.stencil ? UnsignedInt248Type : UnsignedIntType;\n\n\t\t\t\t\t}\n\n\t\t\t\t\tconst projectionlayerInit = {\n\t\t\t\t\t\tcolorFormat: gl.RGBA8,\n\t\t\t\t\t\tdepthFormat: glDepthFormat,\n\t\t\t\t\t\tscaleFactor: framebufferScaleFactor\n\t\t\t\t\t};\n\n\t\t\t\t\tglBinding = new XRWebGLBinding( session, gl );\n\n\t\t\t\t\tglProjLayer = glBinding.createProjectionLayer( projectionlayerInit );\n\n\t\t\t\t\tsession.updateRenderState( { layers: [ glProjLayer ] } );\n\n\t\t\t\t\trenderer.setPixelRatio( 1 );\n\t\t\t\t\trenderer.setSize( glProjLayer.textureWidth, glProjLayer.textureHeight, false );\n\n\t\t\t\t\tnewRenderTarget = new WebGLRenderTarget(\n\t\t\t\t\t\tglProjLayer.textureWidth,\n\t\t\t\t\t\tglProjLayer.textureHeight,\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tformat: RGBAFormat,\n\t\t\t\t\t\t\ttype: UnsignedByteType,\n\t\t\t\t\t\t\tdepthTexture: new DepthTexture( glProjLayer.textureWidth, glProjLayer.textureHeight, depthType, undefined, undefined, undefined, undefined, undefined, undefined, depthFormat ),\n\t\t\t\t\t\t\tstencilBuffer: attributes.stencil,\n\t\t\t\t\t\t\tcolorSpace: renderer.outputColorSpace,\n\t\t\t\t\t\t\tsamples: attributes.antialias ? 4 : 0\n\t\t\t\t\t\t} );\n\n\t\t\t\t\tconst renderTargetProperties = renderer.properties.get( newRenderTarget );\n\t\t\t\t\trenderTargetProperties.__ignoreDepthValues = glProjLayer.ignoreDepthValues;\n\n\t\t\t\t}\n\n\t\t\t\tnewRenderTarget.isXRRenderTarget = true; // TODO Remove this when possible, see #23278\n\n\t\t\t\tthis.setFoveation( foveation );\n\n\t\t\t\tcustomReferenceSpace = null;\n\t\t\t\treferenceSpace = await session.requestReferenceSpace( referenceSpaceType );\n\n\t\t\t\tanimation.setContext( session );\n\t\t\t\tanimation.start();\n\n\t\t\t\tscope.isPresenting = true;\n\n\t\t\t\tscope.dispatchEvent( { type: 'sessionstart' } );\n\n\t\t\t}\n\n\t\t};\n\n\t\tthis.getEnvironmentBlendMode = function () {\n\n\t\t\tif ( session !== null ) {\n\n\t\t\t\treturn session.environmentBlendMode;\n\n\t\t\t}\n\n\t\t};\n\n\t\tfunction onInputSourcesChange( event ) {\n\n\t\t\t// Notify disconnected\n\n\t\t\tfor ( let i = 0; i < event.removed.length; i ++ ) {\n\n\t\t\t\tconst inputSource = event.removed[ i ];\n\t\t\t\tconst index = controllerInputSources.indexOf( inputSource );\n\n\t\t\t\tif ( index >= 0 ) {\n\n\t\t\t\t\tcontrollerInputSources[ index ] = null;\n\t\t\t\t\tcontrollers[ index ].disconnect( inputSource );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\t// Notify connected\n\n\t\t\tfor ( let i = 0; i < event.added.length; i ++ ) {\n\n\t\t\t\tconst inputSource = event.added[ i ];\n\n\t\t\t\tlet controllerIndex = controllerInputSources.indexOf( inputSource );\n\n\t\t\t\tif ( controllerIndex === - 1 ) {\n\n\t\t\t\t\t// Assign input source a controller that currently has no input source\n\n\t\t\t\t\tfor ( let i = 0; i < controllers.length; i ++ ) {\n\n\t\t\t\t\t\tif ( i >= controllerInputSources.length ) {\n\n\t\t\t\t\t\t\tcontrollerInputSources.push( inputSource );\n\t\t\t\t\t\t\tcontrollerIndex = i;\n\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t\t} else if ( controllerInputSources[ i ] === null ) {\n\n\t\t\t\t\t\t\tcontrollerInputSources[ i ] = inputSource;\n\t\t\t\t\t\t\tcontrollerIndex = i;\n\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}\n\n\t\t\t\t\t// If all controllers do currently receive input we ignore new ones\n\n\t\t\t\t\tif ( controllerIndex === - 1 ) break;\n\n\t\t\t\t}\n\n\t\t\t\tconst controller = controllers[ controllerIndex ];\n\n\t\t\t\tif ( controller ) {\n\n\t\t\t\t\tcontroller.connect( inputSource );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t\t//\n\n\t\tconst cameraLPos = new Vector3();\n\t\tconst cameraRPos = new Vector3();\n\n\t\t/**\n\t\t * Assumes 2 cameras that are parallel and share an X-axis, and that\n\t\t * the cameras' projection and world matrices have already been set.\n\t\t * And that near and far planes are identical for both cameras.\n\t\t * Visualization of this technique: https://computergraphics.stackexchange.com/a/4765\n\t\t */\n\t\tfunction setProjectionFromUnion( camera, cameraL, cameraR ) {\n\n\t\t\tcameraLPos.setFromMatrixPosition( cameraL.matrixWorld );\n\t\t\tcameraRPos.setFromMatrixPosition( cameraR.matrixWorld );\n\n\t\t\tconst ipd = cameraLPos.distanceTo( cameraRPos );\n\n\t\t\tconst projL = cameraL.projectionMatrix.elements;\n\t\t\tconst projR = cameraR.projectionMatrix.elements;\n\n\t\t\t// VR systems will have identical far and near planes, and\n\t\t\t// most likely identical top and bottom frustum extents.\n\t\t\t// Use the left camera for these values.\n\t\t\tconst near = projL[ 14 ] / ( projL[ 10 ] - 1 );\n\t\t\tconst far = projL[ 14 ] / ( projL[ 10 ] + 1 );\n\t\t\tconst topFov = ( projL[ 9 ] + 1 ) / projL[ 5 ];\n\t\t\tconst bottomFov = ( projL[ 9 ] - 1 ) / projL[ 5 ];\n\n\t\t\tconst leftFov = ( projL[ 8 ] - 1 ) / projL[ 0 ];\n\t\t\tconst rightFov = ( projR[ 8 ] + 1 ) / projR[ 0 ];\n\t\t\tconst left = near * leftFov;\n\t\t\tconst right = near * rightFov;\n\n\t\t\t// Calculate the new camera's position offset from the\n\t\t\t// left camera. xOffset should be roughly half `ipd`.\n\t\t\tconst zOffset = ipd / ( - leftFov + rightFov );\n\t\t\tconst xOffset = zOffset * - leftFov;\n\n\t\t\t// TODO: Better way to apply this offset?\n\t\t\tcameraL.matrixWorld.decompose( camera.position, camera.quaternion, camera.scale );\n\t\t\tcamera.translateX( xOffset );\n\t\t\tcamera.translateZ( zOffset );\n\t\t\tcamera.matrixWorld.compose( camera.position, camera.quaternion, camera.scale );\n\t\t\tcamera.matrixWorldInverse.copy( camera.matrixWorld ).invert();\n\n\t\t\t// Find the union of the frustum values of the cameras and scale\n\t\t\t// the values so that the near plane's position does not change in world space,\n\t\t\t// although must now be relative to the new union camera.\n\t\t\tconst near2 = near + zOffset;\n\t\t\tconst far2 = far + zOffset;\n\t\t\tconst left2 = left - xOffset;\n\t\t\tconst right2 = right + ( ipd - xOffset );\n\t\t\tconst top2 = topFov * far / far2 * near2;\n\t\t\tconst bottom2 = bottomFov * far / far2 * near2;\n\n\t\t\tcamera.projectionMatrix.makePerspective( left2, right2, top2, bottom2, near2, far2 );\n\t\t\tcamera.projectionMatrixInverse.copy( camera.projectionMatrix ).invert();\n\n\t\t}\n\n\t\tfunction updateCamera( camera, parent ) {\n\n\t\t\tif ( parent === null ) {\n\n\t\t\t\tcamera.matrixWorld.copy( camera.matrix );\n\n\t\t\t} else {\n\n\t\t\t\tcamera.matrixWorld.multiplyMatrices( parent.matrixWorld, camera.matrix );\n\n\t\t\t}\n\n\t\t\tcamera.matrixWorldInverse.copy( camera.matrixWorld ).invert();\n\n\t\t}\n\n\t\tthis.updateCamera = function ( camera ) {\n\n\t\t\tif ( session === null ) return;\n\n\t\t\tif ( depthSensing.texture !== null ) {\n\n\t\t\t\tcamera.near = depthSensing.depthNear;\n\t\t\t\tcamera.far = depthSensing.depthFar;\n\n\t\t\t}\n\n\t\t\tcameraXR.near = cameraR.near = cameraL.near = camera.near;\n\t\t\tcameraXR.far = cameraR.far = cameraL.far = camera.far;\n\n\t\t\tif ( _currentDepthNear !== cameraXR.near || _currentDepthFar !== cameraXR.far ) {\n\n\t\t\t\t// Note that the new renderState won't apply until the next frame. See #18320\n\n\t\t\t\tsession.updateRenderState( {\n\t\t\t\t\tdepthNear: cameraXR.near,\n\t\t\t\t\tdepthFar: cameraXR.far\n\t\t\t\t} );\n\n\t\t\t\t_currentDepthNear = cameraXR.near;\n\t\t\t\t_currentDepthFar = cameraXR.far;\n\n\t\t\t\tcameraL.near = _currentDepthNear;\n\t\t\t\tcameraL.far = _currentDepthFar;\n\t\t\t\tcameraR.near = _currentDepthNear;\n\t\t\t\tcameraR.far = _currentDepthFar;\n\n\t\t\t\tcameraL.updateProjectionMatrix();\n\t\t\t\tcameraR.updateProjectionMatrix();\n\t\t\t\tcamera.updateProjectionMatrix();\n\n\t\t\t}\n\n\t\t\tconst parent = camera.parent;\n\t\t\tconst cameras = cameraXR.cameras;\n\n\t\t\tupdateCamera( cameraXR, parent );\n\n\t\t\tfor ( let i = 0; i < cameras.length; i ++ ) {\n\n\t\t\t\tupdateCamera( cameras[ i ], parent );\n\n\t\t\t}\n\n\t\t\t// update projection matrix for proper view frustum culling\n\n\t\t\tif ( cameras.length === 2 ) {\n\n\t\t\t\tsetProjectionFromUnion( cameraXR, cameraL, cameraR );\n\n\t\t\t} else {\n\n\t\t\t\t// assume single camera setup (AR)\n\n\t\t\t\tcameraXR.projectionMatrix.copy( cameraL.projectionMatrix );\n\n\t\t\t}\n\n\t\t\t// update user camera and its children\n\n\t\t\tupdateUserCamera( camera, cameraXR, parent );\n\n\t\t};\n\n\t\tfunction updateUserCamera( camera, cameraXR, parent ) {\n\n\t\t\tif ( parent === null ) {\n\n\t\t\t\tcamera.matrix.copy( cameraXR.matrixWorld );\n\n\t\t\t} else {\n\n\t\t\t\tcamera.matrix.copy( parent.matrixWorld );\n\t\t\t\tcamera.matrix.invert();\n\t\t\t\tcamera.matrix.multiply( cameraXR.matrixWorld );\n\n\t\t\t}\n\n\t\t\tcamera.matrix.decompose( camera.position, camera.quaternion, camera.scale );\n\t\t\tcamera.updateMatrixWorld( true );\n\n\t\t\tcamera.projectionMatrix.copy( cameraXR.projectionMatrix );\n\t\t\tcamera.projectionMatrixInverse.copy( cameraXR.projectionMatrixInverse );\n\n\t\t\tif ( camera.isPerspectiveCamera ) {\n\n\t\t\t\tcamera.fov = RAD2DEG * 2 * Math.atan( 1 / camera.projectionMatrix.elements[ 5 ] );\n\t\t\t\tcamera.zoom = 1;\n\n\t\t\t}\n\n\t\t}\n\n\t\tthis.getCamera = function () {\n\n\t\t\treturn cameraXR;\n\n\t\t};\n\n\t\tthis.getFoveation = function () {\n\n\t\t\tif ( glProjLayer === null && glBaseLayer === null ) {\n\n\t\t\t\treturn undefined;\n\n\t\t\t}\n\n\t\t\treturn foveation;\n\n\t\t};\n\n\t\tthis.setFoveation = function ( value ) {\n\n\t\t\t// 0 = no foveation = full resolution\n\t\t\t// 1 = maximum foveation = the edges render at lower resolution\n\n\t\t\tfoveation = value;\n\n\t\t\tif ( glProjLayer !== null ) {\n\n\t\t\t\tglProjLayer.fixedFoveation = value;\n\n\t\t\t}\n\n\t\t\tif ( glBaseLayer !== null && glBaseLayer.fixedFoveation !== undefined ) {\n\n\t\t\t\tglBaseLayer.fixedFoveation = value;\n\n\t\t\t}\n\n\t\t};\n\n\t\tthis.hasDepthSensing = function () {\n\n\t\t\treturn depthSensing.texture !== null;\n\n\t\t};\n\n\t\t// Animation Loop\n\n\t\tlet onAnimationFrameCallback = null;\n\n\t\tfunction onAnimationFrame( time, frame ) {\n\n\t\t\tpose = frame.getViewerPose( customReferenceSpace || referenceSpace );\n\t\t\txrFrame = frame;\n\n\t\t\tif ( pose !== null ) {\n\n\t\t\t\tconst views = pose.views;\n\n\t\t\t\tif ( glBaseLayer !== null ) {\n\n\t\t\t\t\trenderer.setRenderTargetFramebuffer( newRenderTarget, glBaseLayer.framebuffer );\n\t\t\t\t\trenderer.setRenderTarget( newRenderTarget );\n\n\t\t\t\t}\n\n\t\t\t\tlet cameraXRNeedsUpdate = false;\n\n\t\t\t\t// check if it's necessary to rebuild cameraXR's camera list\n\n\t\t\t\tif ( views.length !== cameraXR.cameras.length ) {\n\n\t\t\t\t\tcameraXR.cameras.length = 0;\n\t\t\t\t\tcameraXRNeedsUpdate = true;\n\n\t\t\t\t}\n\n\t\t\t\tfor ( let i = 0; i < views.length; i ++ ) {\n\n\t\t\t\t\tconst view = views[ i ];\n\n\t\t\t\t\tlet viewport = null;\n\n\t\t\t\t\tif ( glBaseLayer !== null ) {\n\n\t\t\t\t\t\tviewport = glBaseLayer.getViewport( view );\n\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\tconst glSubImage = glBinding.getViewSubImage( glProjLayer, view );\n\t\t\t\t\t\tviewport = glSubImage.viewport;\n\n\t\t\t\t\t\t// For side-by-side projection, we only produce a single texture for both eyes.\n\t\t\t\t\t\tif ( i === 0 ) {\n\n\t\t\t\t\t\t\trenderer.setRenderTargetTextures(\n\t\t\t\t\t\t\t\tnewRenderTarget,\n\t\t\t\t\t\t\t\tglSubImage.colorTexture,\n\t\t\t\t\t\t\t\tglProjLayer.ignoreDepthValues ? undefined : glSubImage.depthStencilTexture );\n\n\t\t\t\t\t\t\trenderer.setRenderTarget( newRenderTarget );\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}\n\n\t\t\t\t\tlet camera = cameras[ i ];\n\n\t\t\t\t\tif ( camera === undefined ) {\n\n\t\t\t\t\t\tcamera = new PerspectiveCamera();\n\t\t\t\t\t\tcamera.layers.enable( i );\n\t\t\t\t\t\tcamera.viewport = new Vector4();\n\t\t\t\t\t\tcameras[ i ] = camera;\n\n\t\t\t\t\t}\n\n\t\t\t\t\tcamera.matrix.fromArray( view.transform.matrix );\n\t\t\t\t\tcamera.matrix.decompose( camera.position, camera.quaternion, camera.scale );\n\t\t\t\t\tcamera.projectionMatrix.fromArray( view.projectionMatrix );\n\t\t\t\t\tcamera.projectionMatrixInverse.copy( camera.projectionMatrix ).invert();\n\t\t\t\t\tcamera.viewport.set( viewport.x, viewport.y, viewport.width, viewport.height );\n\n\t\t\t\t\tif ( i === 0 ) {\n\n\t\t\t\t\t\tcameraXR.matrix.copy( camera.matrix );\n\t\t\t\t\t\tcameraXR.matrix.decompose( cameraXR.position, cameraXR.quaternion, cameraXR.scale );\n\n\t\t\t\t\t}\n\n\t\t\t\t\tif ( cameraXRNeedsUpdate === true ) {\n\n\t\t\t\t\t\tcameraXR.cameras.push( camera );\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t\t//\n\n\t\t\t\tconst enabledFeatures = session.enabledFeatures;\n\n\t\t\t\tif ( enabledFeatures && enabledFeatures.includes( 'depth-sensing' ) ) {\n\n\t\t\t\t\tconst depthData = glBinding.getDepthInformation( views[ 0 ] );\n\n\t\t\t\t\tif ( depthData && depthData.isValid && depthData.texture ) {\n\n\t\t\t\t\t\tdepthSensing.init( renderer, depthData, session.renderState );\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\t//\n\n\t\t\tfor ( let i = 0; i < controllers.length; i ++ ) {\n\n\t\t\t\tconst inputSource = controllerInputSources[ i ];\n\t\t\t\tconst controller = controllers[ i ];\n\n\t\t\t\tif ( inputSource !== null && controller !== undefined ) {\n\n\t\t\t\t\tcontroller.update( inputSource, frame, customReferenceSpace || referenceSpace );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tdepthSensing.render( renderer, cameraXR );\n\n\t\t\tif ( onAnimationFrameCallback ) onAnimationFrameCallback( time, frame );\n\n\t\t\tif ( frame.detectedPlanes ) {\n\n\t\t\t\tscope.dispatchEvent( { type: 'planesdetected', data: frame } );\n\n\t\t\t}\n\n\t\t\txrFrame = null;\n\n\t\t}\n\n\t\tconst animation = new WebGLAnimation();\n\n\t\tanimation.setAnimationLoop( onAnimationFrame );\n\n\t\tthis.setAnimationLoop = function ( callback ) {\n\n\t\t\tonAnimationFrameCallback = callback;\n\n\t\t};\n\n\t\tthis.dispose = function () {};\n\n\t}\n\n}\n\nconst _e1 = /*@__PURE__*/ new Euler();\nconst _m1 = /*@__PURE__*/ new Matrix4();\n\nfunction WebGLMaterials( renderer, properties ) {\n\n\tfunction refreshTransformUniform( map, uniform ) {\n\n\t\tif ( map.matrixAutoUpdate === true ) {\n\n\t\t\tmap.updateMatrix();\n\n\t\t}\n\n\t\tuniform.value.copy( map.matrix );\n\n\t}\n\n\tfunction refreshFogUniforms( uniforms, fog ) {\n\n\t\tfog.color.getRGB( uniforms.fogColor.value, getUnlitUniformColorSpace( renderer ) );\n\n\t\tif ( fog.isFog ) {\n\n\t\t\tuniforms.fogNear.value = fog.near;\n\t\t\tuniforms.fogFar.value = fog.far;\n\n\t\t} else if ( fog.isFogExp2 ) {\n\n\t\t\tuniforms.fogDensity.value = fog.density;\n\n\t\t}\n\n\t}\n\n\tfunction refreshMaterialUniforms( uniforms, material, pixelRatio, height, transmissionRenderTarget ) {\n\n\t\tif ( material.isMeshBasicMaterial ) {\n\n\t\t\trefreshUniformsCommon( uniforms, material );\n\n\t\t} else if ( material.isMeshLambertMaterial ) {\n\n\t\t\trefreshUniformsCommon( uniforms, material );\n\n\t\t} else if ( material.isMeshToonMaterial ) {\n\n\t\t\trefreshUniformsCommon( uniforms, material );\n\t\t\trefreshUniformsToon( uniforms, material );\n\n\t\t} else if ( material.isMeshPhongMaterial ) {\n\n\t\t\trefreshUniformsCommon( uniforms, material );\n\t\t\trefreshUniformsPhong( uniforms, material );\n\n\t\t} else if ( material.isMeshStandardMaterial ) {\n\n\t\t\trefreshUniformsCommon( uniforms, material );\n\t\t\trefreshUniformsStandard( uniforms, material );\n\n\t\t\tif ( material.isMeshPhysicalMaterial ) {\n\n\t\t\t\trefreshUniformsPhysical( uniforms, material, transmissionRenderTarget );\n\n\t\t\t}\n\n\t\t} else if ( material.isMeshMatcapMaterial ) {\n\n\t\t\trefreshUniformsCommon( uniforms, material );\n\t\t\trefreshUniformsMatcap( uniforms, material );\n\n\t\t} else if ( material.isMeshDepthMaterial ) {\n\n\t\t\trefreshUniformsCommon( uniforms, material );\n\n\t\t} else if ( material.isMeshDistanceMaterial ) {\n\n\t\t\trefreshUniformsCommon( uniforms, material );\n\t\t\trefreshUniformsDistance( uniforms, material );\n\n\t\t} else if ( material.isMeshNormalMaterial ) {\n\n\t\t\trefreshUniformsCommon( uniforms, material );\n\n\t\t} else if ( material.isLineBasicMaterial ) {\n\n\t\t\trefreshUniformsLine( uniforms, material );\n\n\t\t\tif ( material.isLineDashedMaterial ) {\n\n\t\t\t\trefreshUniformsDash( uniforms, material );\n\n\t\t\t}\n\n\t\t} else if ( material.isPointsMaterial ) {\n\n\t\t\trefreshUniformsPoints( uniforms, material, pixelRatio, height );\n\n\t\t} else if ( material.isSpriteMaterial ) {\n\n\t\t\trefreshUniformsSprites( uniforms, material );\n\n\t\t} else if ( material.isShadowMaterial ) {\n\n\t\t\tuniforms.color.value.copy( material.color );\n\t\t\tuniforms.opacity.value = material.opacity;\n\n\t\t} else if ( material.isShaderMaterial ) {\n\n\t\t\tmaterial.uniformsNeedUpdate = false; // #15581\n\n\t\t}\n\n\t}\n\n\tfunction refreshUniformsCommon( uniforms, material ) {\n\n\t\tuniforms.opacity.value = material.opacity;\n\n\t\tif ( material.color ) {\n\n\t\t\tuniforms.diffuse.value.copy( material.color );\n\n\t\t}\n\n\t\tif ( material.emissive ) {\n\n\t\t\tuniforms.emissive.value.copy( material.emissive ).multiplyScalar( material.emissiveIntensity );\n\n\t\t}\n\n\t\tif ( material.map ) {\n\n\t\t\tuniforms.map.value = material.map;\n\n\t\t\trefreshTransformUniform( material.map, uniforms.mapTransform );\n\n\t\t}\n\n\t\tif ( material.alphaMap ) {\n\n\t\t\tuniforms.alphaMap.value = material.alphaMap;\n\n\t\t\trefreshTransformUniform( material.alphaMap, uniforms.alphaMapTransform );\n\n\t\t}\n\n\t\tif ( material.bumpMap ) {\n\n\t\t\tuniforms.bumpMap.value = material.bumpMap;\n\n\t\t\trefreshTransformUniform( material.bumpMap, uniforms.bumpMapTransform );\n\n\t\t\tuniforms.bumpScale.value = material.bumpScale;\n\n\t\t\tif ( material.side === BackSide ) {\n\n\t\t\t\tuniforms.bumpScale.value *= - 1;\n\n\t\t\t}\n\n\t\t}\n\n\t\tif ( material.normalMap ) {\n\n\t\t\tuniforms.normalMap.value = material.normalMap;\n\n\t\t\trefreshTransformUniform( material.normalMap, uniforms.normalMapTransform );\n\n\t\t\tuniforms.normalScale.value.copy( material.normalScale );\n\n\t\t\tif ( material.side === BackSide ) {\n\n\t\t\t\tuniforms.normalScale.value.negate();\n\n\t\t\t}\n\n\t\t}\n\n\t\tif ( material.displacementMap ) {\n\n\t\t\tuniforms.displacementMap.value = material.displacementMap;\n\n\t\t\trefreshTransformUniform( material.displacementMap, uniforms.displacementMapTransform );\n\n\t\t\tuniforms.displacementScale.value = material.displacementScale;\n\t\t\tuniforms.displacementBias.value = material.displacementBias;\n\n\t\t}\n\n\t\tif ( material.emissiveMap ) {\n\n\t\t\tuniforms.emissiveMap.value = material.emissiveMap;\n\n\t\t\trefreshTransformUniform( material.emissiveMap, uniforms.emissiveMapTransform );\n\n\t\t}\n\n\t\tif ( material.specularMap ) {\n\n\t\t\tuniforms.specularMap.value = material.specularMap;\n\n\t\t\trefreshTransformUniform( material.specularMap, uniforms.specularMapTransform );\n\n\t\t}\n\n\t\tif ( material.alphaTest > 0 ) {\n\n\t\t\tuniforms.alphaTest.value = material.alphaTest;\n\n\t\t}\n\n\t\tconst materialProperties = properties.get( material );\n\n\t\tconst envMap = materialProperties.envMap;\n\t\tconst envMapRotation = materialProperties.envMapRotation;\n\n\t\tif ( envMap ) {\n\n\t\t\tuniforms.envMap.value = envMap;\n\n\t\t\t_e1.copy( envMapRotation );\n\n\t\t\t// accommodate left-handed frame\n\t\t\t_e1.x *= - 1; _e1.y *= - 1; _e1.z *= - 1;\n\n\t\t\tif ( envMap.isCubeTexture && envMap.isRenderTargetTexture === false ) {\n\n\t\t\t\t// environment maps which are not cube render targets or PMREMs follow a different convention\n\t\t\t\t_e1.y *= - 1;\n\t\t\t\t_e1.z *= - 1;\n\n\t\t\t}\n\n\t\t\tuniforms.envMapRotation.value.setFromMatrix4( _m1.makeRotationFromEuler( _e1 ) );\n\n\t\t\tuniforms.flipEnvMap.value = ( envMap.isCubeTexture && envMap.isRenderTargetTexture === false ) ? - 1 : 1;\n\n\t\t\tuniforms.reflectivity.value = material.reflectivity;\n\t\t\tuniforms.ior.value = material.ior;\n\t\t\tuniforms.refractionRatio.value = material.refractionRatio;\n\n\t\t}\n\n\t\tif ( material.lightMap ) {\n\n\t\t\tuniforms.lightMap.value = material.lightMap;\n\n\t\t\t// artist-friendly light intensity scaling factor\n\t\t\tconst scaleFactor = ( renderer._useLegacyLights === true ) ? Math.PI : 1;\n\n\t\t\tuniforms.lightMapIntensity.value = material.lightMapIntensity * scaleFactor;\n\n\t\t\trefreshTransformUniform( material.lightMap, uniforms.lightMapTransform );\n\n\t\t}\n\n\t\tif ( material.aoMap ) {\n\n\t\t\tuniforms.aoMap.value = material.aoMap;\n\t\t\tuniforms.aoMapIntensity.value = material.aoMapIntensity;\n\n\t\t\trefreshTransformUniform( material.aoMap, uniforms.aoMapTransform );\n\n\t\t}\n\n\t}\n\n\tfunction refreshUniformsLine( uniforms, material ) {\n\n\t\tuniforms.diffuse.value.copy( material.color );\n\t\tuniforms.opacity.value = material.opacity;\n\n\t\tif ( material.map ) {\n\n\t\t\tuniforms.map.value = material.map;\n\n\t\t\trefreshTransformUniform( material.map, uniforms.mapTransform );\n\n\t\t}\n\n\t}\n\n\tfunction refreshUniformsDash( uniforms, material ) {\n\n\t\tuniforms.dashSize.value = material.dashSize;\n\t\tuniforms.totalSize.value = material.dashSize + material.gapSize;\n\t\tuniforms.scale.value = material.scale;\n\n\t}\n\n\tfunction refreshUniformsPoints( uniforms, material, pixelRatio, height ) {\n\n\t\tuniforms.diffuse.value.copy( material.color );\n\t\tuniforms.opacity.value = material.opacity;\n\t\tuniforms.size.value = material.size * pixelRatio;\n\t\tuniforms.scale.value = height * 0.5;\n\n\t\tif ( material.map ) {\n\n\t\t\tuniforms.map.value = material.map;\n\n\t\t\trefreshTransformUniform( material.map, uniforms.uvTransform );\n\n\t\t}\n\n\t\tif ( material.alphaMap ) {\n\n\t\t\tuniforms.alphaMap.value = material.alphaMap;\n\n\t\t\trefreshTransformUniform( material.alphaMap, uniforms.alphaMapTransform );\n\n\t\t}\n\n\t\tif ( material.alphaTest > 0 ) {\n\n\t\t\tuniforms.alphaTest.value = material.alphaTest;\n\n\t\t}\n\n\t}\n\n\tfunction refreshUniformsSprites( uniforms, material ) {\n\n\t\tuniforms.diffuse.value.copy( material.color );\n\t\tuniforms.opacity.value = material.opacity;\n\t\tuniforms.rotation.value = material.rotation;\n\n\t\tif ( material.map ) {\n\n\t\t\tuniforms.map.value = material.map;\n\n\t\t\trefreshTransformUniform( material.map, uniforms.mapTransform );\n\n\t\t}\n\n\t\tif ( material.alphaMap ) {\n\n\t\t\tuniforms.alphaMap.value = material.alphaMap;\n\n\t\t\trefreshTransformUniform( material.alphaMap, uniforms.alphaMapTransform );\n\n\t\t}\n\n\t\tif ( material.alphaTest > 0 ) {\n\n\t\t\tuniforms.alphaTest.value = material.alphaTest;\n\n\t\t}\n\n\t}\n\n\tfunction refreshUniformsPhong( uniforms, material ) {\n\n\t\tuniforms.specular.value.copy( material.specular );\n\t\tuniforms.shininess.value = Math.max( material.shininess, 1e-4 ); // to prevent pow( 0.0, 0.0 )\n\n\t}\n\n\tfunction refreshUniformsToon( uniforms, material ) {\n\n\t\tif ( material.gradientMap ) {\n\n\t\t\tuniforms.gradientMap.value = material.gradientMap;\n\n\t\t}\n\n\t}\n\n\tfunction refreshUniformsStandard( uniforms, material ) {\n\n\t\tuniforms.metalness.value = material.metalness;\n\n\t\tif ( material.metalnessMap ) {\n\n\t\t\tuniforms.metalnessMap.value = material.metalnessMap;\n\n\t\t\trefreshTransformUniform( material.metalnessMap, uniforms.metalnessMapTransform );\n\n\t\t}\n\n\t\tuniforms.roughness.value = material.roughness;\n\n\t\tif ( material.roughnessMap ) {\n\n\t\t\tuniforms.roughnessMap.value = material.roughnessMap;\n\n\t\t\trefreshTransformUniform( material.roughnessMap, uniforms.roughnessMapTransform );\n\n\t\t}\n\n\t\tif ( material.envMap ) {\n\n\t\t\t//uniforms.envMap.value = material.envMap; // part of uniforms common\n\n\t\t\tuniforms.envMapIntensity.value = material.envMapIntensity;\n\n\t\t}\n\n\t}\n\n\tfunction refreshUniformsPhysical( uniforms, material, transmissionRenderTarget ) {\n\n\t\tuniforms.ior.value = material.ior; // also part of uniforms common\n\n\t\tif ( material.sheen > 0 ) {\n\n\t\t\tuniforms.sheenColor.value.copy( material.sheenColor ).multiplyScalar( material.sheen );\n\n\t\t\tuniforms.sheenRoughness.value = material.sheenRoughness;\n\n\t\t\tif ( material.sheenColorMap ) {\n\n\t\t\t\tuniforms.sheenColorMap.value = material.sheenColorMap;\n\n\t\t\t\trefreshTransformUniform( material.sheenColorMap, uniforms.sheenColorMapTransform );\n\n\t\t\t}\n\n\t\t\tif ( material.sheenRoughnessMap ) {\n\n\t\t\t\tuniforms.sheenRoughnessMap.value = material.sheenRoughnessMap;\n\n\t\t\t\trefreshTransformUniform( material.sheenRoughnessMap, uniforms.sheenRoughnessMapTransform );\n\n\t\t\t}\n\n\t\t}\n\n\t\tif ( material.clearcoat > 0 ) {\n\n\t\t\tuniforms.clearcoat.value = material.clearcoat;\n\t\t\tuniforms.clearcoatRoughness.value = material.clearcoatRoughness;\n\n\t\t\tif ( material.clearcoatMap ) {\n\n\t\t\t\tuniforms.clearcoatMap.value = material.clearcoatMap;\n\n\t\t\t\trefreshTransformUniform( material.clearcoatMap, uniforms.clearcoatMapTransform );\n\n\t\t\t}\n\n\t\t\tif ( material.clearcoatRoughnessMap ) {\n\n\t\t\t\tuniforms.clearcoatRoughnessMap.value = material.clearcoatRoughnessMap;\n\n\t\t\t\trefreshTransformUniform( material.clearcoatRoughnessMap, uniforms.clearcoatRoughnessMapTransform );\n\n\t\t\t}\n\n\t\t\tif ( material.clearcoatNormalMap ) {\n\n\t\t\t\tuniforms.clearcoatNormalMap.value = material.clearcoatNormalMap;\n\n\t\t\t\trefreshTransformUniform( material.clearcoatNormalMap, uniforms.clearcoatNormalMapTransform );\n\n\t\t\t\tuniforms.clearcoatNormalScale.value.copy( material.clearcoatNormalScale );\n\n\t\t\t\tif ( material.side === BackSide ) {\n\n\t\t\t\t\tuniforms.clearcoatNormalScale.value.negate();\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t\tif ( material.iridescence > 0 ) {\n\n\t\t\tuniforms.iridescence.value = material.iridescence;\n\t\t\tuniforms.iridescenceIOR.value = material.iridescenceIOR;\n\t\t\tuniforms.iridescenceThicknessMinimum.value = material.iridescenceThicknessRange[ 0 ];\n\t\t\tuniforms.iridescenceThicknessMaximum.value = material.iridescenceThicknessRange[ 1 ];\n\n\t\t\tif ( material.iridescenceMap ) {\n\n\t\t\t\tuniforms.iridescenceMap.value = material.iridescenceMap;\n\n\t\t\t\trefreshTransformUniform( material.iridescenceMap, uniforms.iridescenceMapTransform );\n\n\t\t\t}\n\n\t\t\tif ( material.iridescenceThicknessMap ) {\n\n\t\t\t\tuniforms.iridescenceThicknessMap.value = material.iridescenceThicknessMap;\n\n\t\t\t\trefreshTransformUniform( material.iridescenceThicknessMap, uniforms.iridescenceThicknessMapTransform );\n\n\t\t\t}\n\n\t\t}\n\n\t\tif ( material.transmission > 0 ) {\n\n\t\t\tuniforms.transmission.value = material.transmission;\n\t\t\tuniforms.transmissionSamplerMap.value = transmissionRenderTarget.texture;\n\t\t\tuniforms.transmissionSamplerSize.value.set( transmissionRenderTarget.width, transmissionRenderTarget.height );\n\n\t\t\tif ( material.transmissionMap ) {\n\n\t\t\t\tuniforms.transmissionMap.value = material.transmissionMap;\n\n\t\t\t\trefreshTransformUniform( material.transmissionMap, uniforms.transmissionMapTransform );\n\n\t\t\t}\n\n\t\t\tuniforms.thickness.value = material.thickness;\n\n\t\t\tif ( material.thicknessMap ) {\n\n\t\t\t\tuniforms.thicknessMap.value = material.thicknessMap;\n\n\t\t\t\trefreshTransformUniform( material.thicknessMap, uniforms.thicknessMapTransform );\n\n\t\t\t}\n\n\t\t\tuniforms.attenuationDistance.value = material.attenuationDistance;\n\t\t\tuniforms.attenuationColor.value.copy( material.attenuationColor );\n\n\t\t}\n\n\t\tif ( material.anisotropy > 0 ) {\n\n\t\t\tuniforms.anisotropyVector.value.set( material.anisotropy * Math.cos( material.anisotropyRotation ), material.anisotropy * Math.sin( material.anisotropyRotation ) );\n\n\t\t\tif ( material.anisotropyMap ) {\n\n\t\t\t\tuniforms.anisotropyMap.value = material.anisotropyMap;\n\n\t\t\t\trefreshTransformUniform( material.anisotropyMap, uniforms.anisotropyMapTransform );\n\n\t\t\t}\n\n\t\t}\n\n\t\tuniforms.specularIntensity.value = material.specularIntensity;\n\t\tuniforms.specularColor.value.copy( material.specularColor );\n\n\t\tif ( material.specularColorMap ) {\n\n\t\t\tuniforms.specularColorMap.value = material.specularColorMap;\n\n\t\t\trefreshTransformUniform( material.specularColorMap, uniforms.specularColorMapTransform );\n\n\t\t}\n\n\t\tif ( material.specularIntensityMap ) {\n\n\t\t\tuniforms.specularIntensityMap.value = material.specularIntensityMap;\n\n\t\t\trefreshTransformUniform( material.specularIntensityMap, uniforms.specularIntensityMapTransform );\n\n\t\t}\n\n\t}\n\n\tfunction refreshUniformsMatcap( uniforms, material ) {\n\n\t\tif ( material.matcap ) {\n\n\t\t\tuniforms.matcap.value = material.matcap;\n\n\t\t}\n\n\t}\n\n\tfunction refreshUniformsDistance( uniforms, material ) {\n\n\t\tconst light = properties.get( material ).light;\n\n\t\tuniforms.referencePosition.value.setFromMatrixPosition( light.matrixWorld );\n\t\tuniforms.nearDistance.value = light.shadow.camera.near;\n\t\tuniforms.farDistance.value = light.shadow.camera.far;\n\n\t}\n\n\treturn {\n\t\trefreshFogUniforms: refreshFogUniforms,\n\t\trefreshMaterialUniforms: refreshMaterialUniforms\n\t};\n\n}\n\nfunction WebGLUniformsGroups( gl, info, capabilities, state ) {\n\n\tlet buffers = {};\n\tlet updateList = {};\n\tlet allocatedBindingPoints = [];\n\n\tconst maxBindingPoints = gl.getParameter( gl.MAX_UNIFORM_BUFFER_BINDINGS ); // binding points are global whereas block indices are per shader program\n\n\tfunction bind( uniformsGroup, program ) {\n\n\t\tconst webglProgram = program.program;\n\t\tstate.uniformBlockBinding( uniformsGroup, webglProgram );\n\n\t}\n\n\tfunction update( uniformsGroup, program ) {\n\n\t\tlet buffer = buffers[ uniformsGroup.id ];\n\n\t\tif ( buffer === undefined ) {\n\n\t\t\tprepareUniformsGroup( uniformsGroup );\n\n\t\t\tbuffer = createBuffer( uniformsGroup );\n\t\t\tbuffers[ uniformsGroup.id ] = buffer;\n\n\t\t\tuniformsGroup.addEventListener( 'dispose', onUniformsGroupsDispose );\n\n\t\t}\n\n\t\t// ensure to update the binding points/block indices mapping for this program\n\n\t\tconst webglProgram = program.program;\n\t\tstate.updateUBOMapping( uniformsGroup, webglProgram );\n\n\t\t// update UBO once per frame\n\n\t\tconst frame = info.render.frame;\n\n\t\tif ( updateList[ uniformsGroup.id ] !== frame ) {\n\n\t\t\tupdateBufferData( uniformsGroup );\n\n\t\t\tupdateList[ uniformsGroup.id ] = frame;\n\n\t\t}\n\n\t}\n\n\tfunction createBuffer( uniformsGroup ) {\n\n\t\t// the setup of an UBO is independent of a particular shader program but global\n\n\t\tconst bindingPointIndex = allocateBindingPointIndex();\n\t\tuniformsGroup.__bindingPointIndex = bindingPointIndex;\n\n\t\tconst buffer = gl.createBuffer();\n\t\tconst size = uniformsGroup.__size;\n\t\tconst usage = uniformsGroup.usage;\n\n\t\tgl.bindBuffer( gl.UNIFORM_BUFFER, buffer );\n\t\tgl.bufferData( gl.UNIFORM_BUFFER, size, usage );\n\t\tgl.bindBuffer( gl.UNIFORM_BUFFER, null );\n\t\tgl.bindBufferBase( gl.UNIFORM_BUFFER, bindingPointIndex, buffer );\n\n\t\treturn buffer;\n\n\t}\n\n\tfunction allocateBindingPointIndex() {\n\n\t\tfor ( let i = 0; i < maxBindingPoints; i ++ ) {\n\n\t\t\tif ( allocatedBindingPoints.indexOf( i ) === - 1 ) {\n\n\t\t\t\tallocatedBindingPoints.push( i );\n\t\t\t\treturn i;\n\n\t\t\t}\n\n\t\t}\n\n\t\tconsole.error( 'THREE.WebGLRenderer: Maximum number of simultaneously usable uniforms groups reached.' );\n\n\t\treturn 0;\n\n\t}\n\n\tfunction updateBufferData( uniformsGroup ) {\n\n\t\tconst buffer = buffers[ uniformsGroup.id ];\n\t\tconst uniforms = uniformsGroup.uniforms;\n\t\tconst cache = uniformsGroup.__cache;\n\n\t\tgl.bindBuffer( gl.UNIFORM_BUFFER, buffer );\n\n\t\tfor ( let i = 0, il = uniforms.length; i < il; i ++ ) {\n\n\t\t\tconst uniformArray = Array.isArray( uniforms[ i ] ) ? uniforms[ i ] : [ uniforms[ i ] ];\n\n\t\t\tfor ( let j = 0, jl = uniformArray.length; j < jl; j ++ ) {\n\n\t\t\t\tconst uniform = uniformArray[ j ];\n\n\t\t\t\tif ( hasUniformChanged( uniform, i, j, cache ) === true ) {\n\n\t\t\t\t\tconst offset = uniform.__offset;\n\n\t\t\t\t\tconst values = Array.isArray( uniform.value ) ? uniform.value : [ uniform.value ];\n\n\t\t\t\t\tlet arrayOffset = 0;\n\n\t\t\t\t\tfor ( let k = 0; k < values.length; k ++ ) {\n\n\t\t\t\t\t\tconst value = values[ k ];\n\n\t\t\t\t\t\tconst info = getUniformSize( value );\n\n\t\t\t\t\t\t// TODO add integer and struct support\n\t\t\t\t\t\tif ( typeof value === 'number' || typeof value === 'boolean' ) {\n\n\t\t\t\t\t\t\tuniform.__data[ 0 ] = value;\n\t\t\t\t\t\t\tgl.bufferSubData( gl.UNIFORM_BUFFER, offset + arrayOffset, uniform.__data );\n\n\t\t\t\t\t\t} else if ( value.isMatrix3 ) {\n\n\t\t\t\t\t\t\t// manually converting 3x3 to 3x4\n\n\t\t\t\t\t\t\tuniform.__data[ 0 ] = value.elements[ 0 ];\n\t\t\t\t\t\t\tuniform.__data[ 1 ] = value.elements[ 1 ];\n\t\t\t\t\t\t\tuniform.__data[ 2 ] = value.elements[ 2 ];\n\t\t\t\t\t\t\tuniform.__data[ 3 ] = 0;\n\t\t\t\t\t\t\tuniform.__data[ 4 ] = value.elements[ 3 ];\n\t\t\t\t\t\t\tuniform.__data[ 5 ] = value.elements[ 4 ];\n\t\t\t\t\t\t\tuniform.__data[ 6 ] = value.elements[ 5 ];\n\t\t\t\t\t\t\tuniform.__data[ 7 ] = 0;\n\t\t\t\t\t\t\tuniform.__data[ 8 ] = value.elements[ 6 ];\n\t\t\t\t\t\t\tuniform.__data[ 9 ] = value.elements[ 7 ];\n\t\t\t\t\t\t\tuniform.__data[ 10 ] = value.elements[ 8 ];\n\t\t\t\t\t\t\tuniform.__data[ 11 ] = 0;\n\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\tvalue.toArray( uniform.__data, arrayOffset );\n\n\t\t\t\t\t\t\tarrayOffset += info.storage / Float32Array.BYTES_PER_ELEMENT;\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}\n\n\t\t\t\t\tgl.bufferSubData( gl.UNIFORM_BUFFER, offset, uniform.__data );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t\tgl.bindBuffer( gl.UNIFORM_BUFFER, null );\n\n\t}\n\n\tfunction hasUniformChanged( uniform, index, indexArray, cache ) {\n\n\t\tconst value = uniform.value;\n\t\tconst indexString = index + '_' + indexArray;\n\n\t\tif ( cache[ indexString ] === undefined ) {\n\n\t\t\t// cache entry does not exist so far\n\n\t\t\tif ( typeof value === 'number' || typeof value === 'boolean' ) {\n\n\t\t\t\tcache[ indexString ] = value;\n\n\t\t\t} else {\n\n\t\t\t\tcache[ indexString ] = value.clone();\n\n\t\t\t}\n\n\t\t\treturn true;\n\n\t\t} else {\n\n\t\t\tconst cachedObject = cache[ indexString ];\n\n\t\t\t// compare current value with cached entry\n\n\t\t\tif ( typeof value === 'number' || typeof value === 'boolean' ) {\n\n\t\t\t\tif ( cachedObject !== value ) {\n\n\t\t\t\t\tcache[ indexString ] = value;\n\t\t\t\t\treturn true;\n\n\t\t\t\t}\n\n\t\t\t} else {\n\n\t\t\t\tif ( cachedObject.equals( value ) === false ) {\n\n\t\t\t\t\tcachedObject.copy( value );\n\t\t\t\t\treturn true;\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn false;\n\n\t}\n\n\tfunction prepareUniformsGroup( uniformsGroup ) {\n\n\t\t// determine total buffer size according to the STD140 layout\n\t\t// Hint: STD140 is the only supported layout in WebGL 2\n\n\t\tconst uniforms = uniformsGroup.uniforms;\n\n\t\tlet offset = 0; // global buffer offset in bytes\n\t\tconst chunkSize = 16; // size of a chunk in bytes\n\n\t\tfor ( let i = 0, l = uniforms.length; i < l; i ++ ) {\n\n\t\t\tconst uniformArray = Array.isArray( uniforms[ i ] ) ? uniforms[ i ] : [ uniforms[ i ] ];\n\n\t\t\tfor ( let j = 0, jl = uniformArray.length; j < jl; j ++ ) {\n\n\t\t\t\tconst uniform = uniformArray[ j ];\n\n\t\t\t\tconst values = Array.isArray( uniform.value ) ? uniform.value : [ uniform.value ];\n\n\t\t\t\tfor ( let k = 0, kl = values.length; k < kl; k ++ ) {\n\n\t\t\t\t\tconst value = values[ k ];\n\n\t\t\t\t\tconst info = getUniformSize( value );\n\n\t\t\t\t\t// Calculate the chunk offset\n\t\t\t\t\tconst chunkOffsetUniform = offset % chunkSize;\n\n\t\t\t\t\t// Check for chunk overflow\n\t\t\t\t\tif ( chunkOffsetUniform !== 0 && ( chunkSize - chunkOffsetUniform ) < info.boundary ) {\n\n\t\t\t\t\t\t// Add padding and adjust offset\n\t\t\t\t\t\toffset += ( chunkSize - chunkOffsetUniform );\n\n\t\t\t\t\t}\n\n\t\t\t\t\t// the following two properties will be used for partial buffer updates\n\n\t\t\t\t\tuniform.__data = new Float32Array( info.storage / Float32Array.BYTES_PER_ELEMENT );\n\t\t\t\t\tuniform.__offset = offset;\n\n\n\t\t\t\t\t// Update the global offset\n\t\t\t\t\toffset += info.storage;\n\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t\t// ensure correct final padding\n\n\t\tconst chunkOffset = offset % chunkSize;\n\n\t\tif ( chunkOffset > 0 ) offset += ( chunkSize - chunkOffset );\n\n\t\t//\n\n\t\tuniformsGroup.__size = offset;\n\t\tuniformsGroup.__cache = {};\n\n\t\treturn this;\n\n\t}\n\n\tfunction getUniformSize( value ) {\n\n\t\tconst info = {\n\t\t\tboundary: 0, // bytes\n\t\t\tstorage: 0 // bytes\n\t\t};\n\n\t\t// determine sizes according to STD140\n\n\t\tif ( typeof value === 'number' || typeof value === 'boolean' ) {\n\n\t\t\t// float/int/bool\n\n\t\t\tinfo.boundary = 4;\n\t\t\tinfo.storage = 4;\n\n\t\t} else if ( value.isVector2 ) {\n\n\t\t\t// vec2\n\n\t\t\tinfo.boundary = 8;\n\t\t\tinfo.storage = 8;\n\n\t\t} else if ( value.isVector3 || value.isColor ) {\n\n\t\t\t// vec3\n\n\t\t\tinfo.boundary = 16;\n\t\t\tinfo.storage = 12; // evil: vec3 must start on a 16-byte boundary but it only consumes 12 bytes\n\n\t\t} else if ( value.isVector4 ) {\n\n\t\t\t// vec4\n\n\t\t\tinfo.boundary = 16;\n\t\t\tinfo.storage = 16;\n\n\t\t} else if ( value.isMatrix3 ) {\n\n\t\t\t// mat3 (in STD140 a 3x3 matrix is represented as 3x4)\n\n\t\t\tinfo.boundary = 48;\n\t\t\tinfo.storage = 48;\n\n\t\t} else if ( value.isMatrix4 ) {\n\n\t\t\t// mat4\n\n\t\t\tinfo.boundary = 64;\n\t\t\tinfo.storage = 64;\n\n\t\t} else if ( value.isTexture ) {\n\n\t\t\tconsole.warn( 'THREE.WebGLRenderer: Texture samplers can not be part of an uniforms group.' );\n\n\t\t} else {\n\n\t\t\tconsole.warn( 'THREE.WebGLRenderer: Unsupported uniform value type.', value );\n\n\t\t}\n\n\t\treturn info;\n\n\t}\n\n\tfunction onUniformsGroupsDispose( event ) {\n\n\t\tconst uniformsGroup = event.target;\n\n\t\tuniformsGroup.removeEventListener( 'dispose', onUniformsGroupsDispose );\n\n\t\tconst index = allocatedBindingPoints.indexOf( uniformsGroup.__bindingPointIndex );\n\t\tallocatedBindingPoints.splice( index, 1 );\n\n\t\tgl.deleteBuffer( buffers[ uniformsGroup.id ] );\n\n\t\tdelete buffers[ uniformsGroup.id ];\n\t\tdelete updateList[ uniformsGroup.id ];\n\n\t}\n\n\tfunction dispose() {\n\n\t\tfor ( const id in buffers ) {\n\n\t\t\tgl.deleteBuffer( buffers[ id ] );\n\n\t\t}\n\n\t\tallocatedBindingPoints = [];\n\t\tbuffers = {};\n\t\tupdateList = {};\n\n\t}\n\n\treturn {\n\n\t\tbind: bind,\n\t\tupdate: update,\n\n\t\tdispose: dispose\n\n\t};\n\n}\n\nclass WebGLRenderer {\n\n\tconstructor( parameters = {} ) {\n\n\t\tconst {\n\t\t\tcanvas = createCanvasElement(),\n\t\t\tcontext = null,\n\t\t\tdepth = true,\n\t\t\tstencil = false,\n\t\t\talpha = false,\n\t\t\tantialias = false,\n\t\t\tpremultipliedAlpha = true,\n\t\t\tpreserveDrawingBuffer = false,\n\t\t\tpowerPreference = 'default',\n\t\t\tfailIfMajorPerformanceCaveat = false,\n\t\t} = parameters;\n\n\t\tthis.isWebGLRenderer = true;\n\n\t\tlet _alpha;\n\n\t\tif ( context !== null ) {\n\n\t\t\tif ( typeof WebGLRenderingContext !== 'undefined' && context instanceof WebGLRenderingContext ) {\n\n\t\t\t\tthrow new Error( 'THREE.WebGLRenderer: WebGL 1 is not supported since r163.' );\n\n\t\t\t}\n\n\t\t\t_alpha = context.getContextAttributes().alpha;\n\n\t\t} else {\n\n\t\t\t_alpha = alpha;\n\n\t\t}\n\n\t\tconst uintClearColor = new Uint32Array( 4 );\n\t\tconst intClearColor = new Int32Array( 4 );\n\n\t\tlet currentRenderList = null;\n\t\tlet currentRenderState = null;\n\n\t\t// render() can be called from within a callback triggered by another render.\n\t\t// We track this so that the nested render call gets its list and state isolated from the parent render call.\n\n\t\tconst renderListStack = [];\n\t\tconst renderStateStack = [];\n\n\t\t// public properties\n\n\t\tthis.domElement = canvas;\n\n\t\t// Debug configuration container\n\t\tthis.debug = {\n\n\t\t\t/**\n\t\t\t * Enables error checking and reporting when shader programs are being compiled\n\t\t\t * @type {boolean}\n\t\t\t */\n\t\t\tcheckShaderErrors: true,\n\t\t\t/**\n\t\t\t * Callback for custom error reporting.\n\t\t\t * @type {?Function}\n\t\t\t */\n\t\t\tonShaderError: null\n\t\t};\n\n\t\t// clearing\n\n\t\tthis.autoClear = true;\n\t\tthis.autoClearColor = true;\n\t\tthis.autoClearDepth = true;\n\t\tthis.autoClearStencil = true;\n\n\t\t// scene graph\n\n\t\tthis.sortObjects = true;\n\n\t\t// user-defined clipping\n\n\t\tthis.clippingPlanes = [];\n\t\tthis.localClippingEnabled = false;\n\n\t\t// physically based shading\n\n\t\tthis._outputColorSpace = SRGBColorSpace;\n\n\t\t// physical lights\n\n\t\tthis._useLegacyLights = false;\n\n\t\t// tone mapping\n\n\t\tthis.toneMapping = NoToneMapping;\n\t\tthis.toneMappingExposure = 1.0;\n\n\t\t// internal properties\n\n\t\tconst _this = this;\n\n\t\tlet _isContextLost = false;\n\n\t\t// internal state cache\n\n\t\tlet _currentActiveCubeFace = 0;\n\t\tlet _currentActiveMipmapLevel = 0;\n\t\tlet _currentRenderTarget = null;\n\t\tlet _currentMaterialId = - 1;\n\n\t\tlet _currentCamera = null;\n\n\t\tconst _currentViewport = new Vector4();\n\t\tconst _currentScissor = new Vector4();\n\t\tlet _currentScissorTest = null;\n\n\t\tconst _currentClearColor = new Color( 0x000000 );\n\t\tlet _currentClearAlpha = 0;\n\n\t\t//\n\n\t\tlet _width = canvas.width;\n\t\tlet _height = canvas.height;\n\n\t\tlet _pixelRatio = 1;\n\t\tlet _opaqueSort = null;\n\t\tlet _transparentSort = null;\n\n\t\tconst _viewport = new Vector4( 0, 0, _width, _height );\n\t\tconst _scissor = new Vector4( 0, 0, _width, _height );\n\t\tlet _scissorTest = false;\n\n\t\t// frustum\n\n\t\tconst _frustum = new Frustum();\n\n\t\t// clipping\n\n\t\tlet _clippingEnabled = false;\n\t\tlet _localClippingEnabled = false;\n\n\t\t// camera matrices cache\n\n\t\tconst _projScreenMatrix = new Matrix4();\n\n\t\tconst _vector2 = new Vector2();\n\t\tconst _vector3 = new Vector3();\n\n\t\tconst _emptyScene = { background: null, fog: null, environment: null, overrideMaterial: null, isScene: true };\n\n\t\tfunction getTargetPixelRatio() {\n\n\t\t\treturn _currentRenderTarget === null ? _pixelRatio : 1;\n\n\t\t}\n\n\t\t// initialize\n\n\t\tlet _gl = context;\n\n\t\tfunction getContext( contextName, contextAttributes ) {\n\n\t\t\tconst context = canvas.getContext( contextName, contextAttributes );\n\t\t\tif ( context !== null ) return context;\n\n\t\t\treturn null;\n\n\t\t}\n\n\t\ttry {\n\n\t\t\tconst contextAttributes = {\n\t\t\t\talpha: true,\n\t\t\t\tdepth,\n\t\t\t\tstencil,\n\t\t\t\tantialias,\n\t\t\t\tpremultipliedAlpha,\n\t\t\t\tpreserveDrawingBuffer,\n\t\t\t\tpowerPreference,\n\t\t\t\tfailIfMajorPerformanceCaveat,\n\t\t\t};\n\n\t\t\t// OffscreenCanvas does not have setAttribute, see #22811\n\t\t\tif ( 'setAttribute' in canvas ) canvas.setAttribute( 'data-engine', `three.js r${REVISION}` );\n\n\t\t\t// event listeners must be registered before WebGL context is created, see #12753\n\t\t\tcanvas.addEventListener( 'webglcontextlost', onContextLost, false );\n\t\t\tcanvas.addEventListener( 'webglcontextrestored', onContextRestore, false );\n\t\t\tcanvas.addEventListener( 'webglcontextcreationerror', onContextCreationError, false );\n\n\t\t\tif ( _gl === null ) {\n\n\t\t\t\tconst contextName = 'webgl2';\n\n\t\t\t\t_gl = getContext( contextName, contextAttributes );\n\n\t\t\t\tif ( _gl === null ) {\n\n\t\t\t\t\tif ( getContext( contextName ) ) {\n\n\t\t\t\t\t\tthrow new Error( 'Error creating WebGL context with your selected attributes.' );\n\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\tthrow new Error( 'Error creating WebGL context.' );\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t} catch ( error ) {\n\n\t\t\tconsole.error( 'THREE.WebGLRenderer: ' + error.message );\n\t\t\tthrow error;\n\n\t\t}\n\n\t\tlet extensions, capabilities, state, info;\n\t\tlet properties, textures, cubemaps, cubeuvmaps, attributes, geometries, objects;\n\t\tlet programCache, materials, renderLists, renderStates, clipping, shadowMap;\n\n\t\tlet background, morphtargets, bufferRenderer, indexedBufferRenderer;\n\n\t\tlet utils, bindingStates, uniformsGroups;\n\n\t\tfunction initGLContext() {\n\n\t\t\textensions = new WebGLExtensions( _gl );\n\t\t\textensions.init();\n\n\t\t\tcapabilities = new WebGLCapabilities( _gl, extensions, parameters );\n\n\t\t\tutils = new WebGLUtils( _gl, extensions );\n\n\t\t\tstate = new WebGLState( _gl );\n\n\t\t\tinfo = new WebGLInfo( _gl );\n\t\t\tproperties = new WebGLProperties();\n\t\t\ttextures = new WebGLTextures( _gl, extensions, state, properties, capabilities, utils, info );\n\t\t\tcubemaps = new WebGLCubeMaps( _this );\n\t\t\tcubeuvmaps = new WebGLCubeUVMaps( _this );\n\t\t\tattributes = new WebGLAttributes( _gl );\n\t\t\tbindingStates = new WebGLBindingStates( _gl, attributes );\n\t\t\tgeometries = new WebGLGeometries( _gl, attributes, info, bindingStates );\n\t\t\tobjects = new WebGLObjects( _gl, geometries, attributes, info );\n\t\t\tmorphtargets = new WebGLMorphtargets( _gl, capabilities, textures );\n\t\t\tclipping = new WebGLClipping( properties );\n\t\t\tprogramCache = new WebGLPrograms( _this, cubemaps, cubeuvmaps, extensions, capabilities, bindingStates, clipping );\n\t\t\tmaterials = new WebGLMaterials( _this, properties );\n\t\t\trenderLists = new WebGLRenderLists();\n\t\t\trenderStates = new WebGLRenderStates( extensions );\n\t\t\tbackground = new WebGLBackground( _this, cubemaps, cubeuvmaps, state, objects, _alpha, premultipliedAlpha );\n\t\t\tshadowMap = new WebGLShadowMap( _this, objects, capabilities );\n\t\t\tuniformsGroups = new WebGLUniformsGroups( _gl, info, capabilities, state );\n\n\t\t\tbufferRenderer = new WebGLBufferRenderer( _gl, extensions, info );\n\t\t\tindexedBufferRenderer = new WebGLIndexedBufferRenderer( _gl, extensions, info );\n\n\t\t\tinfo.programs = programCache.programs;\n\n\t\t\t_this.capabilities = capabilities;\n\t\t\t_this.extensions = extensions;\n\t\t\t_this.properties = properties;\n\t\t\t_this.renderLists = renderLists;\n\t\t\t_this.shadowMap = shadowMap;\n\t\t\t_this.state = state;\n\t\t\t_this.info = info;\n\n\t\t}\n\n\t\tinitGLContext();\n\n\t\t// xr\n\n\t\tconst xr = new WebXRManager( _this, _gl );\n\n\t\tthis.xr = xr;\n\n\t\t// API\n\n\t\tthis.getContext = function () {\n\n\t\t\treturn _gl;\n\n\t\t};\n\n\t\tthis.getContextAttributes = function () {\n\n\t\t\treturn _gl.getContextAttributes();\n\n\t\t};\n\n\t\tthis.forceContextLoss = function () {\n\n\t\t\tconst extension = extensions.get( 'WEBGL_lose_context' );\n\t\t\tif ( extension ) extension.loseContext();\n\n\t\t};\n\n\t\tthis.forceContextRestore = function () {\n\n\t\t\tconst extension = extensions.get( 'WEBGL_lose_context' );\n\t\t\tif ( extension ) extension.restoreContext();\n\n\t\t};\n\n\t\tthis.getPixelRatio = function () {\n\n\t\t\treturn _pixelRatio;\n\n\t\t};\n\n\t\tthis.setPixelRatio = function ( value ) {\n\n\t\t\tif ( value === undefined ) return;\n\n\t\t\t_pixelRatio = value;\n\n\t\t\tthis.setSize( _width, _height, false );\n\n\t\t};\n\n\t\tthis.getSize = function ( target ) {\n\n\t\t\treturn target.set( _width, _height );\n\n\t\t};\n\n\t\tthis.setSize = function ( width, height, updateStyle = true ) {\n\n\t\t\tif ( xr.isPresenting ) {\n\n\t\t\t\tconsole.warn( 'THREE.WebGLRenderer: Can\\'t change size while VR device is presenting.' );\n\t\t\t\treturn;\n\n\t\t\t}\n\n\t\t\t_width = width;\n\t\t\t_height = height;\n\n\t\t\tcanvas.width = Math.floor( width * _pixelRatio );\n\t\t\tcanvas.height = Math.floor( height * _pixelRatio );\n\n\t\t\tif ( updateStyle === true ) {\n\n\t\t\t\tcanvas.style.width = width + 'px';\n\t\t\t\tcanvas.style.height = height + 'px';\n\n\t\t\t}\n\n\t\t\tthis.setViewport( 0, 0, width, height );\n\n\t\t};\n\n\t\tthis.getDrawingBufferSize = function ( target ) {\n\n\t\t\treturn target.set( _width * _pixelRatio, _height * _pixelRatio ).floor();\n\n\t\t};\n\n\t\tthis.setDrawingBufferSize = function ( width, height, pixelRatio ) {\n\n\t\t\t_width = width;\n\t\t\t_height = height;\n\n\t\t\t_pixelRatio = pixelRatio;\n\n\t\t\tcanvas.width = Math.floor( width * pixelRatio );\n\t\t\tcanvas.height = Math.floor( height * pixelRatio );\n\n\t\t\tthis.setViewport( 0, 0, width, height );\n\n\t\t};\n\n\t\tthis.getCurrentViewport = function ( target ) {\n\n\t\t\treturn target.copy( _currentViewport );\n\n\t\t};\n\n\t\tthis.getViewport = function ( target ) {\n\n\t\t\treturn target.copy( _viewport );\n\n\t\t};\n\n\t\tthis.setViewport = function ( x, y, width, height ) {\n\n\t\t\tif ( x.isVector4 ) {\n\n\t\t\t\t_viewport.set( x.x, x.y, x.z, x.w );\n\n\t\t\t} else {\n\n\t\t\t\t_viewport.set( x, y, width, height );\n\n\t\t\t}\n\n\t\t\tstate.viewport( _currentViewport.copy( _viewport ).multiplyScalar( _pixelRatio ).round() );\n\n\t\t};\n\n\t\tthis.getScissor = function ( target ) {\n\n\t\t\treturn target.copy( _scissor );\n\n\t\t};\n\n\t\tthis.setScissor = function ( x, y, width, height ) {\n\n\t\t\tif ( x.isVector4 ) {\n\n\t\t\t\t_scissor.set( x.x, x.y, x.z, x.w );\n\n\t\t\t} else {\n\n\t\t\t\t_scissor.set( x, y, width, height );\n\n\t\t\t}\n\n\t\t\tstate.scissor( _currentScissor.copy( _scissor ).multiplyScalar( _pixelRatio ).round() );\n\n\t\t};\n\n\t\tthis.getScissorTest = function () {\n\n\t\t\treturn _scissorTest;\n\n\t\t};\n\n\t\tthis.setScissorTest = function ( boolean ) {\n\n\t\t\tstate.setScissorTest( _scissorTest = boolean );\n\n\t\t};\n\n\t\tthis.setOpaqueSort = function ( method ) {\n\n\t\t\t_opaqueSort = method;\n\n\t\t};\n\n\t\tthis.setTransparentSort = function ( method ) {\n\n\t\t\t_transparentSort = method;\n\n\t\t};\n\n\t\t// Clearing\n\n\t\tthis.getClearColor = function ( target ) {\n\n\t\t\treturn target.copy( background.getClearColor() );\n\n\t\t};\n\n\t\tthis.setClearColor = function () {\n\n\t\t\tbackground.setClearColor.apply( background, arguments );\n\n\t\t};\n\n\t\tthis.getClearAlpha = function () {\n\n\t\t\treturn background.getClearAlpha();\n\n\t\t};\n\n\t\tthis.setClearAlpha = function () {\n\n\t\t\tbackground.setClearAlpha.apply( background, arguments );\n\n\t\t};\n\n\t\tthis.clear = function ( color = true, depth = true, stencil = true ) {\n\n\t\t\tlet bits = 0;\n\n\t\t\tif ( color ) {\n\n\t\t\t\t// check if we're trying to clear an integer target\n\t\t\t\tlet isIntegerFormat = false;\n\t\t\t\tif ( _currentRenderTarget !== null ) {\n\n\t\t\t\t\tconst targetFormat = _currentRenderTarget.texture.format;\n\t\t\t\t\tisIntegerFormat = targetFormat === RGBAIntegerFormat ||\n\t\t\t\t\t\ttargetFormat === RGIntegerFormat ||\n\t\t\t\t\t\ttargetFormat === RedIntegerFormat;\n\n\t\t\t\t}\n\n\t\t\t\t// use the appropriate clear functions to clear the target if it's a signed\n\t\t\t\t// or unsigned integer target\n\t\t\t\tif ( isIntegerFormat ) {\n\n\t\t\t\t\tconst targetType = _currentRenderTarget.texture.type;\n\t\t\t\t\tconst isUnsignedType = targetType === UnsignedByteType ||\n\t\t\t\t\t\ttargetType === UnsignedIntType ||\n\t\t\t\t\t\ttargetType === UnsignedShortType ||\n\t\t\t\t\t\ttargetType === UnsignedInt248Type ||\n\t\t\t\t\t\ttargetType === UnsignedShort4444Type ||\n\t\t\t\t\t\ttargetType === UnsignedShort5551Type;\n\n\t\t\t\t\tconst clearColor = background.getClearColor();\n\t\t\t\t\tconst a = background.getClearAlpha();\n\t\t\t\t\tconst r = clearColor.r;\n\t\t\t\t\tconst g = clearColor.g;\n\t\t\t\t\tconst b = clearColor.b;\n\n\t\t\t\t\tif ( isUnsignedType ) {\n\n\t\t\t\t\t\tuintClearColor[ 0 ] = r;\n\t\t\t\t\t\tuintClearColor[ 1 ] = g;\n\t\t\t\t\t\tuintClearColor[ 2 ] = b;\n\t\t\t\t\t\tuintClearColor[ 3 ] = a;\n\t\t\t\t\t\t_gl.clearBufferuiv( _gl.COLOR, 0, uintClearColor );\n\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\tintClearColor[ 0 ] = r;\n\t\t\t\t\t\tintClearColor[ 1 ] = g;\n\t\t\t\t\t\tintClearColor[ 2 ] = b;\n\t\t\t\t\t\tintClearColor[ 3 ] = a;\n\t\t\t\t\t\t_gl.clearBufferiv( _gl.COLOR, 0, intClearColor );\n\n\t\t\t\t\t}\n\n\t\t\t\t} else {\n\n\t\t\t\t\tbits |= _gl.COLOR_BUFFER_BIT;\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tif ( depth ) bits |= _gl.DEPTH_BUFFER_BIT;\n\t\t\tif ( stencil ) {\n\n\t\t\t\tbits |= _gl.STENCIL_BUFFER_BIT;\n\t\t\t\tthis.state.buffers.stencil.setMask( 0xffffffff );\n\n\t\t\t}\n\n\t\t\t_gl.clear( bits );\n\n\t\t};\n\n\t\tthis.clearColor = function () {\n\n\t\t\tthis.clear( true, false, false );\n\n\t\t};\n\n\t\tthis.clearDepth = function () {\n\n\t\t\tthis.clear( false, true, false );\n\n\t\t};\n\n\t\tthis.clearStencil = function () {\n\n\t\t\tthis.clear( false, false, true );\n\n\t\t};\n\n\t\t//\n\n\t\tthis.dispose = function () {\n\n\t\t\tcanvas.removeEventListener( 'webglcontextlost', onContextLost, false );\n\t\t\tcanvas.removeEventListener( 'webglcontextrestored', onContextRestore, false );\n\t\t\tcanvas.removeEventListener( 'webglcontextcreationerror', onContextCreationError, false );\n\n\t\t\trenderLists.dispose();\n\t\t\trenderStates.dispose();\n\t\t\tproperties.dispose();\n\t\t\tcubemaps.dispose();\n\t\t\tcubeuvmaps.dispose();\n\t\t\tobjects.dispose();\n\t\t\tbindingStates.dispose();\n\t\t\tuniformsGroups.dispose();\n\t\t\tprogramCache.dispose();\n\n\t\t\txr.dispose();\n\n\t\t\txr.removeEventListener( 'sessionstart', onXRSessionStart );\n\t\t\txr.removeEventListener( 'sessionend', onXRSessionEnd );\n\n\t\t\tanimation.stop();\n\n\t\t};\n\n\t\t// Events\n\n\t\tfunction onContextLost( event ) {\n\n\t\t\tevent.preventDefault();\n\n\t\t\tconsole.log( 'THREE.WebGLRenderer: Context Lost.' );\n\n\t\t\t_isContextLost = true;\n\n\t\t}\n\n\t\tfunction onContextRestore( /* event */ ) {\n\n\t\t\tconsole.log( 'THREE.WebGLRenderer: Context Restored.' );\n\n\t\t\t_isContextLost = false;\n\n\t\t\tconst infoAutoReset = info.autoReset;\n\t\t\tconst shadowMapEnabled = shadowMap.enabled;\n\t\t\tconst shadowMapAutoUpdate = shadowMap.autoUpdate;\n\t\t\tconst shadowMapNeedsUpdate = shadowMap.needsUpdate;\n\t\t\tconst shadowMapType = shadowMap.type;\n\n\t\t\tinitGLContext();\n\n\t\t\tinfo.autoReset = infoAutoReset;\n\t\t\tshadowMap.enabled = shadowMapEnabled;\n\t\t\tshadowMap.autoUpdate = shadowMapAutoUpdate;\n\t\t\tshadowMap.needsUpdate = shadowMapNeedsUpdate;\n\t\t\tshadowMap.type = shadowMapType;\n\n\t\t}\n\n\t\tfunction onContextCreationError( event ) {\n\n\t\t\tconsole.error( 'THREE.WebGLRenderer: A WebGL context could not be created. Reason: ', event.statusMessage );\n\n\t\t}\n\n\t\tfunction onMaterialDispose( event ) {\n\n\t\t\tconst material = event.target;\n\n\t\t\tmaterial.removeEventListener( 'dispose', onMaterialDispose );\n\n\t\t\tdeallocateMaterial( material );\n\n\t\t}\n\n\t\t// Buffer deallocation\n\n\t\tfunction deallocateMaterial( material ) {\n\n\t\t\treleaseMaterialProgramReferences( material );\n\n\t\t\tproperties.remove( material );\n\n\t\t}\n\n\n\t\tfunction releaseMaterialProgramReferences( material ) {\n\n\t\t\tconst programs = properties.get( material ).programs;\n\n\t\t\tif ( programs !== undefined ) {\n\n\t\t\t\tprograms.forEach( function ( program ) {\n\n\t\t\t\t\tprogramCache.releaseProgram( program );\n\n\t\t\t\t} );\n\n\t\t\t\tif ( material.isShaderMaterial ) {\n\n\t\t\t\t\tprogramCache.releaseShaderCache( material );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t\t// Buffer rendering\n\n\t\tthis.renderBufferDirect = function ( camera, scene, geometry, material, object, group ) {\n\n\t\t\tif ( scene === null ) scene = _emptyScene; // renderBufferDirect second parameter used to be fog (could be null)\n\n\t\t\tconst frontFaceCW = ( object.isMesh && object.matrixWorld.determinant() < 0 );\n\n\t\t\tconst program = setProgram( camera, scene, geometry, material, object );\n\n\t\t\tstate.setMaterial( material, frontFaceCW );\n\n\t\t\t//\n\n\t\t\tlet index = geometry.index;\n\t\t\tlet rangeFactor = 1;\n\n\t\t\tif ( material.wireframe === true ) {\n\n\t\t\t\tindex = geometries.getWireframeAttribute( geometry );\n\n\t\t\t\tif ( index === undefined ) return;\n\n\t\t\t\trangeFactor = 2;\n\n\t\t\t}\n\n\t\t\t//\n\n\t\t\tconst drawRange = geometry.drawRange;\n\t\t\tconst position = geometry.attributes.position;\n\n\t\t\tlet drawStart = drawRange.start * rangeFactor;\n\t\t\tlet drawEnd = ( drawRange.start + drawRange.count ) * rangeFactor;\n\n\t\t\tif ( group !== null ) {\n\n\t\t\t\tdrawStart = Math.max( drawStart, group.start * rangeFactor );\n\t\t\t\tdrawEnd = Math.min( drawEnd, ( group.start + group.count ) * rangeFactor );\n\n\t\t\t}\n\n\t\t\tif ( index !== null ) {\n\n\t\t\t\tdrawStart = Math.max( drawStart, 0 );\n\t\t\t\tdrawEnd = Math.min( drawEnd, index.count );\n\n\t\t\t} else if ( position !== undefined && position !== null ) {\n\n\t\t\t\tdrawStart = Math.max( drawStart, 0 );\n\t\t\t\tdrawEnd = Math.min( drawEnd, position.count );\n\n\t\t\t}\n\n\t\t\tconst drawCount = drawEnd - drawStart;\n\n\t\t\tif ( drawCount < 0 || drawCount === Infinity ) return;\n\n\t\t\t//\n\n\t\t\tbindingStates.setup( object, material, program, geometry, index );\n\n\t\t\tlet attribute;\n\t\t\tlet renderer = bufferRenderer;\n\n\t\t\tif ( index !== null ) {\n\n\t\t\t\tattribute = attributes.get( index );\n\n\t\t\t\trenderer = indexedBufferRenderer;\n\t\t\t\trenderer.setIndex( attribute );\n\n\t\t\t}\n\n\t\t\t//\n\n\t\t\tif ( object.isMesh ) {\n\n\t\t\t\tif ( material.wireframe === true ) {\n\n\t\t\t\t\tstate.setLineWidth( material.wireframeLinewidth * getTargetPixelRatio() );\n\t\t\t\t\trenderer.setMode( _gl.LINES );\n\n\t\t\t\t} else {\n\n\t\t\t\t\trenderer.setMode( _gl.TRIANGLES );\n\n\t\t\t\t}\n\n\t\t\t} else if ( object.isLine ) {\n\n\t\t\t\tlet lineWidth = material.linewidth;\n\n\t\t\t\tif ( lineWidth === undefined ) lineWidth = 1; // Not using Line*Material\n\n\t\t\t\tstate.setLineWidth( lineWidth * getTargetPixelRatio() );\n\n\t\t\t\tif ( object.isLineSegments ) {\n\n\t\t\t\t\trenderer.setMode( _gl.LINES );\n\n\t\t\t\t} else if ( object.isLineLoop ) {\n\n\t\t\t\t\trenderer.setMode( _gl.LINE_LOOP );\n\n\t\t\t\t} else {\n\n\t\t\t\t\trenderer.setMode( _gl.LINE_STRIP );\n\n\t\t\t\t}\n\n\t\t\t} else if ( object.isPoints ) {\n\n\t\t\t\trenderer.setMode( _gl.POINTS );\n\n\t\t\t} else if ( object.isSprite ) {\n\n\t\t\t\trenderer.setMode( _gl.TRIANGLES );\n\n\t\t\t}\n\n\t\t\tif ( object.isBatchedMesh ) {\n\n\t\t\t\trenderer.renderMultiDraw( object._multiDrawStarts, object._multiDrawCounts, object._multiDrawCount );\n\n\t\t\t} else if ( object.isInstancedMesh ) {\n\n\t\t\t\trenderer.renderInstances( drawStart, drawCount, object.count );\n\n\t\t\t} else if ( geometry.isInstancedBufferGeometry ) {\n\n\t\t\t\tconst maxInstanceCount = geometry._maxInstanceCount !== undefined ? geometry._maxInstanceCount : Infinity;\n\t\t\t\tconst instanceCount = Math.min( geometry.instanceCount, maxInstanceCount );\n\n\t\t\t\trenderer.renderInstances( drawStart, drawCount, instanceCount );\n\n\t\t\t} else {\n\n\t\t\t\trenderer.render( drawStart, drawCount );\n\n\t\t\t}\n\n\t\t};\n\n\t\t// Compile\n\n\t\tfunction prepareMaterial( material, scene, object ) {\n\n\t\t\tif ( material.transparent === true && material.side === DoubleSide && material.forceSinglePass === false ) {\n\n\t\t\t\tmaterial.side = BackSide;\n\t\t\t\tmaterial.needsUpdate = true;\n\t\t\t\tgetProgram( material, scene, object );\n\n\t\t\t\tmaterial.side = FrontSide;\n\t\t\t\tmaterial.needsUpdate = true;\n\t\t\t\tgetProgram( material, scene, object );\n\n\t\t\t\tmaterial.side = DoubleSide;\n\n\t\t\t} else {\n\n\t\t\t\tgetProgram( material, scene, object );\n\n\t\t\t}\n\n\t\t}\n\n\t\tthis.compile = function ( scene, camera, targetScene = null ) {\n\n\t\t\tif ( targetScene === null ) targetScene = scene;\n\n\t\t\tcurrentRenderState = renderStates.get( targetScene );\n\t\t\tcurrentRenderState.init();\n\n\t\t\trenderStateStack.push( currentRenderState );\n\n\t\t\t// gather lights from both the target scene and the new object that will be added to the scene.\n\n\t\t\ttargetScene.traverseVisible( function ( object ) {\n\n\t\t\t\tif ( object.isLight && object.layers.test( camera.layers ) ) {\n\n\t\t\t\t\tcurrentRenderState.pushLight( object );\n\n\t\t\t\t\tif ( object.castShadow ) {\n\n\t\t\t\t\t\tcurrentRenderState.pushShadow( object );\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t} );\n\n\t\t\tif ( scene !== targetScene ) {\n\n\t\t\t\tscene.traverseVisible( function ( object ) {\n\n\t\t\t\t\tif ( object.isLight && object.layers.test( camera.layers ) ) {\n\n\t\t\t\t\t\tcurrentRenderState.pushLight( object );\n\n\t\t\t\t\t\tif ( object.castShadow ) {\n\n\t\t\t\t\t\t\tcurrentRenderState.pushShadow( object );\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}\n\n\t\t\t\t} );\n\n\t\t\t}\n\n\t\t\tcurrentRenderState.setupLights( _this._useLegacyLights );\n\n\t\t\t// Only initialize materials in the new scene, not the targetScene.\n\n\t\t\tconst materials = new Set();\n\n\t\t\tscene.traverse( function ( object ) {\n\n\t\t\t\tconst material = object.material;\n\n\t\t\t\tif ( material ) {\n\n\t\t\t\t\tif ( Array.isArray( material ) ) {\n\n\t\t\t\t\t\tfor ( let i = 0; i < material.length; i ++ ) {\n\n\t\t\t\t\t\t\tconst material2 = material[ i ];\n\n\t\t\t\t\t\t\tprepareMaterial( material2, targetScene, object );\n\t\t\t\t\t\t\tmaterials.add( material2 );\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\tprepareMaterial( material, targetScene, object );\n\t\t\t\t\t\tmaterials.add( material );\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t} );\n\n\t\t\trenderStateStack.pop();\n\t\t\tcurrentRenderState = null;\n\n\t\t\treturn materials;\n\n\t\t};\n\n\t\t// compileAsync\n\n\t\tthis.compileAsync = function ( scene, camera, targetScene = null ) {\n\n\t\t\tconst materials = this.compile( scene, camera, targetScene );\n\n\t\t\t// Wait for all the materials in the new object to indicate that they're\n\t\t\t// ready to be used before resolving the promise.\n\n\t\t\treturn new Promise( ( resolve ) => {\n\n\t\t\t\tfunction checkMaterialsReady() {\n\n\t\t\t\t\tmaterials.forEach( function ( material ) {\n\n\t\t\t\t\t\tconst materialProperties = properties.get( material );\n\t\t\t\t\t\tconst program = materialProperties.currentProgram;\n\n\t\t\t\t\t\tif ( program.isReady() ) {\n\n\t\t\t\t\t\t\t// remove any programs that report they're ready to use from the list\n\t\t\t\t\t\t\tmaterials.delete( material );\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t} );\n\n\t\t\t\t\t// once the list of compiling materials is empty, call the callback\n\n\t\t\t\t\tif ( materials.size === 0 ) {\n\n\t\t\t\t\t\tresolve( scene );\n\t\t\t\t\t\treturn;\n\n\t\t\t\t\t}\n\n\t\t\t\t\t// if some materials are still not ready, wait a bit and check again\n\n\t\t\t\t\tsetTimeout( checkMaterialsReady, 10 );\n\n\t\t\t\t}\n\n\t\t\t\tif ( extensions.get( 'KHR_parallel_shader_compile' ) !== null ) {\n\n\t\t\t\t\t// If we can check the compilation status of the materials without\n\t\t\t\t\t// blocking then do so right away.\n\n\t\t\t\t\tcheckMaterialsReady();\n\n\t\t\t\t} else {\n\n\t\t\t\t\t// Otherwise start by waiting a bit to give the materials we just\n\t\t\t\t\t// initialized a chance to finish.\n\n\t\t\t\t\tsetTimeout( checkMaterialsReady, 10 );\n\n\t\t\t\t}\n\n\t\t\t} );\n\n\t\t};\n\n\t\t// Animation Loop\n\n\t\tlet onAnimationFrameCallback = null;\n\n\t\tfunction onAnimationFrame( time ) {\n\n\t\t\tif ( onAnimationFrameCallback ) onAnimationFrameCallback( time );\n\n\t\t}\n\n\t\tfunction onXRSessionStart() {\n\n\t\t\tanimation.stop();\n\n\t\t}\n\n\t\tfunction onXRSessionEnd() {\n\n\t\t\tanimation.start();\n\n\t\t}\n\n\t\tconst animation = new WebGLAnimation();\n\t\tanimation.setAnimationLoop( onAnimationFrame );\n\n\t\tif ( typeof self !== 'undefined' ) animation.setContext( self );\n\n\t\tthis.setAnimationLoop = function ( callback ) {\n\n\t\t\tonAnimationFrameCallback = callback;\n\t\t\txr.setAnimationLoop( callback );\n\n\t\t\t( callback === null ) ? animation.stop() : animation.start();\n\n\t\t};\n\n\t\txr.addEventListener( 'sessionstart', onXRSessionStart );\n\t\txr.addEventListener( 'sessionend', onXRSessionEnd );\n\n\t\t// Rendering\n\n\t\tthis.render = function ( scene, camera ) {\n\n\t\t\tif ( camera !== undefined && camera.isCamera !== true ) {\n\n\t\t\t\tconsole.error( 'THREE.WebGLRenderer.render: camera is not an instance of THREE.Camera.' );\n\t\t\t\treturn;\n\n\t\t\t}\n\n\t\t\tif ( _isContextLost === true ) return;\n\n\t\t\t// update scene graph\n\n\t\t\tif ( scene.matrixWorldAutoUpdate === true ) scene.updateMatrixWorld();\n\n\t\t\t// update camera matrices and frustum\n\n\t\t\tif ( camera.parent === null && camera.matrixWorldAutoUpdate === true ) camera.updateMatrixWorld();\n\n\t\t\tif ( xr.enabled === true && xr.isPresenting === true ) {\n\n\t\t\t\tif ( xr.cameraAutoUpdate === true ) xr.updateCamera( camera );\n\n\t\t\t\tcamera = xr.getCamera(); // use XR camera for rendering\n\n\t\t\t}\n\n\t\t\t//\n\t\t\tif ( scene.isScene === true ) scene.onBeforeRender( _this, scene, camera, _currentRenderTarget );\n\n\t\t\tcurrentRenderState = renderStates.get( scene, renderStateStack.length );\n\t\t\tcurrentRenderState.init();\n\n\t\t\trenderStateStack.push( currentRenderState );\n\n\t\t\t_projScreenMatrix.multiplyMatrices( camera.projectionMatrix, camera.matrixWorldInverse );\n\t\t\t_frustum.setFromProjectionMatrix( _projScreenMatrix );\n\n\t\t\t_localClippingEnabled = this.localClippingEnabled;\n\t\t\t_clippingEnabled = clipping.init( this.clippingPlanes, _localClippingEnabled );\n\n\t\t\tcurrentRenderList = renderLists.get( scene, renderListStack.length );\n\t\t\tcurrentRenderList.init();\n\n\t\t\trenderListStack.push( currentRenderList );\n\n\t\t\tprojectObject( scene, camera, 0, _this.sortObjects );\n\n\t\t\tcurrentRenderList.finish();\n\n\t\t\tif ( _this.sortObjects === true ) {\n\n\t\t\t\tcurrentRenderList.sort( _opaqueSort, _transparentSort );\n\n\t\t\t}\n\n\t\t\t//\n\n\t\t\tthis.info.render.frame ++;\n\n\t\t\tif ( _clippingEnabled === true ) clipping.beginShadows();\n\n\t\t\tconst shadowsArray = currentRenderState.state.shadowsArray;\n\n\t\t\tshadowMap.render( shadowsArray, scene, camera );\n\n\t\t\tif ( _clippingEnabled === true ) clipping.endShadows();\n\n\t\t\t//\n\n\t\t\tif ( this.info.autoReset === true ) this.info.reset();\n\n\n\t\t\t//\n\n\t\t\tif ( xr.enabled === false || xr.isPresenting === false || xr.hasDepthSensing() === false ) {\n\n\t\t\t\tbackground.render( currentRenderList, scene );\n\n\t\t\t}\n\n\t\t\t// render scene\n\n\t\t\tcurrentRenderState.setupLights( _this._useLegacyLights );\n\n\t\t\tif ( camera.isArrayCamera ) {\n\n\t\t\t\tconst cameras = camera.cameras;\n\n\t\t\t\tfor ( let i = 0, l = cameras.length; i < l; i ++ ) {\n\n\t\t\t\t\tconst camera2 = cameras[ i ];\n\n\t\t\t\t\trenderScene( currentRenderList, scene, camera2, camera2.viewport );\n\n\t\t\t\t}\n\n\t\t\t} else {\n\n\t\t\t\trenderScene( currentRenderList, scene, camera );\n\n\t\t\t}\n\n\t\t\t//\n\n\t\t\tif ( _currentRenderTarget !== null ) {\n\n\t\t\t\t// resolve multisample renderbuffers to a single-sample texture if necessary\n\n\t\t\t\ttextures.updateMultisampleRenderTarget( _currentRenderTarget );\n\n\t\t\t\t// Generate mipmap if we're using any kind of mipmap filtering\n\n\t\t\t\ttextures.updateRenderTargetMipmap( _currentRenderTarget );\n\n\t\t\t}\n\n\t\t\t//\n\n\t\t\tif ( scene.isScene === true ) scene.onAfterRender( _this, scene, camera );\n\n\t\t\t// _gl.finish();\n\n\t\t\tbindingStates.resetDefaultState();\n\t\t\t_currentMaterialId = - 1;\n\t\t\t_currentCamera = null;\n\n\t\t\trenderStateStack.pop();\n\n\t\t\tif ( renderStateStack.length > 0 ) {\n\n\t\t\t\tcurrentRenderState = renderStateStack[ renderStateStack.length - 1 ];\n\n\t\t\t} else {\n\n\t\t\t\tcurrentRenderState = null;\n\n\t\t\t}\n\n\t\t\trenderListStack.pop();\n\n\t\t\tif ( renderListStack.length > 0 ) {\n\n\t\t\t\tcurrentRenderList = renderListStack[ renderListStack.length - 1 ];\n\n\t\t\t} else {\n\n\t\t\t\tcurrentRenderList = null;\n\n\t\t\t}\n\n\t\t};\n\n\t\tfunction projectObject( object, camera, groupOrder, sortObjects ) {\n\n\t\t\tif ( object.visible === false ) return;\n\n\t\t\tconst visible = object.layers.test( camera.layers );\n\n\t\t\tif ( visible ) {\n\n\t\t\t\tif ( object.isGroup ) {\n\n\t\t\t\t\tgroupOrder = object.renderOrder;\n\n\t\t\t\t} else if ( object.isLOD ) {\n\n\t\t\t\t\tif ( object.autoUpdate === true ) object.update( camera );\n\n\t\t\t\t} else if ( object.isLight ) {\n\n\t\t\t\t\tcurrentRenderState.pushLight( object );\n\n\t\t\t\t\tif ( object.castShadow ) {\n\n\t\t\t\t\t\tcurrentRenderState.pushShadow( object );\n\n\t\t\t\t\t}\n\n\t\t\t\t} else if ( object.isSprite ) {\n\n\t\t\t\t\tif ( ! object.frustumCulled || _frustum.intersectsSprite( object ) ) {\n\n\t\t\t\t\t\tif ( sortObjects ) {\n\n\t\t\t\t\t\t\t_vector3.setFromMatrixPosition( object.matrixWorld )\n\t\t\t\t\t\t\t\t.applyMatrix4( _projScreenMatrix );\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tconst geometry = objects.update( object );\n\t\t\t\t\t\tconst material = object.material;\n\n\t\t\t\t\t\tif ( material.visible ) {\n\n\t\t\t\t\t\t\tcurrentRenderList.push( object, geometry, material, groupOrder, _vector3.z, null );\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}\n\n\t\t\t\t} else if ( object.isMesh || object.isLine || object.isPoints ) {\n\n\t\t\t\t\tif ( ! object.frustumCulled || _frustum.intersectsObject( object ) ) {\n\n\t\t\t\t\t\tconst geometry = objects.update( object );\n\t\t\t\t\t\tconst material = object.material;\n\n\t\t\t\t\t\tif ( sortObjects ) {\n\n\t\t\t\t\t\t\tif ( object.boundingSphere !== undefined ) {\n\n\t\t\t\t\t\t\t\tif ( object.boundingSphere === null ) object.computeBoundingSphere();\n\t\t\t\t\t\t\t\t_vector3.copy( object.boundingSphere.center );\n\n\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\tif ( geometry.boundingSphere === null ) geometry.computeBoundingSphere();\n\t\t\t\t\t\t\t\t_vector3.copy( geometry.boundingSphere.center );\n\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t_vector3\n\t\t\t\t\t\t\t\t.applyMatrix4( object.matrixWorld )\n\t\t\t\t\t\t\t\t.applyMatrix4( _projScreenMatrix );\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tif ( Array.isArray( material ) ) {\n\n\t\t\t\t\t\t\tconst groups = geometry.groups;\n\n\t\t\t\t\t\t\tfor ( let i = 0, l = groups.length; i < l; i ++ ) {\n\n\t\t\t\t\t\t\t\tconst group = groups[ i ];\n\t\t\t\t\t\t\t\tconst groupMaterial = material[ group.materialIndex ];\n\n\t\t\t\t\t\t\t\tif ( groupMaterial && groupMaterial.visible ) {\n\n\t\t\t\t\t\t\t\t\tcurrentRenderList.push( object, geometry, groupMaterial, groupOrder, _vector3.z, group );\n\n\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t} else if ( material.visible ) {\n\n\t\t\t\t\t\t\tcurrentRenderList.push( object, geometry, material, groupOrder, _vector3.z, null );\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tconst children = object.children;\n\n\t\t\tfor ( let i = 0, l = children.length; i < l; i ++ ) {\n\n\t\t\t\tprojectObject( children[ i ], camera, groupOrder, sortObjects );\n\n\t\t\t}\n\n\t\t}\n\n\t\tfunction renderScene( currentRenderList, scene, camera, viewport ) {\n\n\t\t\tconst opaqueObjects = currentRenderList.opaque;\n\t\t\tconst transmissiveObjects = currentRenderList.transmissive;\n\t\t\tconst transparentObjects = currentRenderList.transparent;\n\n\t\t\tcurrentRenderState.setupLightsView( camera );\n\n\t\t\tif ( _clippingEnabled === true ) clipping.setGlobalState( _this.clippingPlanes, camera );\n\n\t\t\tif ( transmissiveObjects.length > 0 ) renderTransmissionPass( opaqueObjects, transmissiveObjects, scene, camera );\n\n\t\t\tif ( viewport ) state.viewport( _currentViewport.copy( viewport ) );\n\n\t\t\tif ( opaqueObjects.length > 0 ) renderObjects( opaqueObjects, scene, camera );\n\t\t\tif ( transmissiveObjects.length > 0 ) renderObjects( transmissiveObjects, scene, camera );\n\t\t\tif ( transparentObjects.length > 0 ) renderObjects( transparentObjects, scene, camera );\n\n\t\t\t// Ensure depth buffer writing is enabled so it can be cleared on next render\n\n\t\t\tstate.buffers.depth.setTest( true );\n\t\t\tstate.buffers.depth.setMask( true );\n\t\t\tstate.buffers.color.setMask( true );\n\n\t\t\tstate.setPolygonOffset( false );\n\n\t\t}\n\n\t\tfunction renderTransmissionPass( opaqueObjects, transmissiveObjects, scene, camera ) {\n\n\t\t\tconst overrideMaterial = scene.isScene === true ? scene.overrideMaterial : null;\n\n\t\t\tif ( overrideMaterial !== null ) {\n\n\t\t\t\treturn;\n\n\t\t\t}\n\n\t\t\tif ( currentRenderState.state.transmissionRenderTarget === null ) {\n\n\t\t\t\tcurrentRenderState.state.transmissionRenderTarget = new WebGLRenderTarget( 1, 1, {\n\t\t\t\t\tgenerateMipmaps: true,\n\t\t\t\t\ttype: ( extensions.has( 'EXT_color_buffer_half_float' ) || extensions.has( 'EXT_color_buffer_float' ) ) ? HalfFloatType : UnsignedByteType,\n\t\t\t\t\tminFilter: LinearMipmapLinearFilter,\n\t\t\t\t\tsamples: 4,\n\t\t\t\t\tstencilBuffer: stencil\n\t\t\t\t} );\n\n\t\t\t\tconst renderTargetProperties = properties.get( currentRenderState.state.transmissionRenderTarget );\n\t\t\t\trenderTargetProperties.__isTransmissionRenderTarget = true;\n\n\t\t\t\t// debug\n\n\t\t\t\t/*\n\t\t\t\tconst geometry = new PlaneGeometry();\n\t\t\t\tconst material = new MeshBasicMaterial( { map: _transmissionRenderTarget.texture } );\n\n\t\t\t\tconst mesh = new Mesh( geometry, material );\n\t\t\t\tscene.add( mesh );\n\t\t\t\t*/\n\n\t\t\t}\n\n\t\t\tconst transmissionRenderTarget = currentRenderState.state.transmissionRenderTarget;\n\n\t\t\t_this.getDrawingBufferSize( _vector2 );\n\t\t\ttransmissionRenderTarget.setSize( _vector2.x, _vector2.y );\n\n\t\t\t//\n\n\t\t\tconst currentRenderTarget = _this.getRenderTarget();\n\t\t\t_this.setRenderTarget( transmissionRenderTarget );\n\n\t\t\t_this.getClearColor( _currentClearColor );\n\t\t\t_currentClearAlpha = _this.getClearAlpha();\n\t\t\tif ( _currentClearAlpha < 1 ) _this.setClearColor( 0xffffff, 0.5 );\n\n\t\t\t_this.clear();\n\n\t\t\t// Turn off the features which can affect the frag color for opaque objects pass.\n\t\t\t// Otherwise they are applied twice in opaque objects pass and transmission objects pass.\n\t\t\tconst currentToneMapping = _this.toneMapping;\n\t\t\t_this.toneMapping = NoToneMapping;\n\n\t\t\trenderObjects( opaqueObjects, scene, camera );\n\n\t\t\ttextures.updateMultisampleRenderTarget( transmissionRenderTarget );\n\t\t\ttextures.updateRenderTargetMipmap( transmissionRenderTarget );\n\n\t\t\tlet renderTargetNeedsUpdate = false;\n\n\t\t\tfor ( let i = 0, l = transmissiveObjects.length; i < l; i ++ ) {\n\n\t\t\t\tconst renderItem = transmissiveObjects[ i ];\n\n\t\t\t\tconst object = renderItem.object;\n\t\t\t\tconst geometry = renderItem.geometry;\n\t\t\t\tconst material = renderItem.material;\n\t\t\t\tconst group = renderItem.group;\n\n\t\t\t\tif ( material.side === DoubleSide && object.layers.test( camera.layers ) ) {\n\n\t\t\t\t\tconst currentSide = material.side;\n\n\t\t\t\t\tmaterial.side = BackSide;\n\t\t\t\t\tmaterial.needsUpdate = true;\n\n\t\t\t\t\trenderObject( object, scene, camera, geometry, material, group );\n\n\t\t\t\t\tmaterial.side = currentSide;\n\t\t\t\t\tmaterial.needsUpdate = true;\n\n\t\t\t\t\trenderTargetNeedsUpdate = true;\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tif ( renderTargetNeedsUpdate === true ) {\n\n\t\t\t\ttextures.updateMultisampleRenderTarget( transmissionRenderTarget );\n\t\t\t\ttextures.updateRenderTargetMipmap( transmissionRenderTarget );\n\n\t\t\t}\n\n\t\t\t_this.setRenderTarget( currentRenderTarget );\n\n\t\t\t_this.setClearColor( _currentClearColor, _currentClearAlpha );\n\n\t\t\t_this.toneMapping = currentToneMapping;\n\n\t\t}\n\n\t\tfunction renderObjects( renderList, scene, camera ) {\n\n\t\t\tconst overrideMaterial = scene.isScene === true ? scene.overrideMaterial : null;\n\n\t\t\tfor ( let i = 0, l = renderList.length; i < l; i ++ ) {\n\n\t\t\t\tconst renderItem = renderList[ i ];\n\n\t\t\t\tconst object = renderItem.object;\n\t\t\t\tconst geometry = renderItem.geometry;\n\t\t\t\tconst material = overrideMaterial === null ? renderItem.material : overrideMaterial;\n\t\t\t\tconst group = renderItem.group;\n\n\t\t\t\tif ( object.layers.test( camera.layers ) ) {\n\n\t\t\t\t\trenderObject( object, scene, camera, geometry, material, group );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t\tfunction renderObject( object, scene, camera, geometry, material, group ) {\n\n\t\t\tobject.onBeforeRender( _this, scene, camera, geometry, material, group );\n\n\t\t\tobject.modelViewMatrix.multiplyMatrices( camera.matrixWorldInverse, object.matrixWorld );\n\t\t\tobject.normalMatrix.getNormalMatrix( object.modelViewMatrix );\n\n\t\t\tmaterial.onBeforeRender( _this, scene, camera, geometry, object, group );\n\n\t\t\tif ( material.transparent === true && material.side === DoubleSide && material.forceSinglePass === false ) {\n\n\t\t\t\tmaterial.side = BackSide;\n\t\t\t\tmaterial.needsUpdate = true;\n\t\t\t\t_this.renderBufferDirect( camera, scene, geometry, material, object, group );\n\n\t\t\t\tmaterial.side = FrontSide;\n\t\t\t\tmaterial.needsUpdate = true;\n\t\t\t\t_this.renderBufferDirect( camera, scene, geometry, material, object, group );\n\n\t\t\t\tmaterial.side = DoubleSide;\n\n\t\t\t} else {\n\n\t\t\t\t_this.renderBufferDirect( camera, scene, geometry, material, object, group );\n\n\t\t\t}\n\n\t\t\tobject.onAfterRender( _this, scene, camera, geometry, material, group );\n\n\t\t}\n\n\t\tfunction getProgram( material, scene, object ) {\n\n\t\t\tif ( scene.isScene !== true ) scene = _emptyScene; // scene could be a Mesh, Line, Points, ...\n\n\t\t\tconst materialProperties = properties.get( material );\n\n\t\t\tconst lights = currentRenderState.state.lights;\n\t\t\tconst shadowsArray = currentRenderState.state.shadowsArray;\n\n\t\t\tconst lightsStateVersion = lights.state.version;\n\n\t\t\tconst parameters = programCache.getParameters( material, lights.state, shadowsArray, scene, object );\n\t\t\tconst programCacheKey = programCache.getProgramCacheKey( parameters );\n\n\t\t\tlet programs = materialProperties.programs;\n\n\t\t\t// always update environment and fog - changing these trigger an getProgram call, but it's possible that the program doesn't change\n\n\t\t\tmaterialProperties.environment = material.isMeshStandardMaterial ? scene.environment : null;\n\t\t\tmaterialProperties.fog = scene.fog;\n\t\t\tmaterialProperties.envMap = ( material.isMeshStandardMaterial ? cubeuvmaps : cubemaps ).get( material.envMap || materialProperties.environment );\n\t\t\tmaterialProperties.envMapRotation = ( materialProperties.environment !== null && material.envMap === null ) ? scene.environmentRotation : material.envMapRotation;\n\n\t\t\tif ( programs === undefined ) {\n\n\t\t\t\t// new material\n\n\t\t\t\tmaterial.addEventListener( 'dispose', onMaterialDispose );\n\n\t\t\t\tprograms = new Map();\n\t\t\t\tmaterialProperties.programs = programs;\n\n\t\t\t}\n\n\t\t\tlet program = programs.get( programCacheKey );\n\n\t\t\tif ( program !== undefined ) {\n\n\t\t\t\t// early out if program and light state is identical\n\n\t\t\t\tif ( materialProperties.currentProgram === program && materialProperties.lightsStateVersion === lightsStateVersion ) {\n\n\t\t\t\t\tupdateCommonMaterialProperties( material, parameters );\n\n\t\t\t\t\treturn program;\n\n\t\t\t\t}\n\n\t\t\t} else {\n\n\t\t\t\tparameters.uniforms = programCache.getUniforms( material );\n\n\t\t\t\tmaterial.onBuild( object, parameters, _this );\n\n\t\t\t\tmaterial.onBeforeCompile( parameters, _this );\n\n\t\t\t\tprogram = programCache.acquireProgram( parameters, programCacheKey );\n\t\t\t\tprograms.set( programCacheKey, program );\n\n\t\t\t\tmaterialProperties.uniforms = parameters.uniforms;\n\n\t\t\t}\n\n\t\t\tconst uniforms = materialProperties.uniforms;\n\n\t\t\tif ( ( ! material.isShaderMaterial && ! material.isRawShaderMaterial ) || material.clipping === true ) {\n\n\t\t\t\tuniforms.clippingPlanes = clipping.uniform;\n\n\t\t\t}\n\n\t\t\tupdateCommonMaterialProperties( material, parameters );\n\n\t\t\t// store the light setup it was created for\n\n\t\t\tmaterialProperties.needsLights = materialNeedsLights( material );\n\t\t\tmaterialProperties.lightsStateVersion = lightsStateVersion;\n\n\t\t\tif ( materialProperties.needsLights ) {\n\n\t\t\t\t// wire up the material to this renderer's lighting state\n\n\t\t\t\tuniforms.ambientLightColor.value = lights.state.ambient;\n\t\t\t\tuniforms.lightProbe.value = lights.state.probe;\n\t\t\t\tuniforms.directionalLights.value = lights.state.directional;\n\t\t\t\tuniforms.directionalLightShadows.value = lights.state.directionalShadow;\n\t\t\t\tuniforms.spotLights.value = lights.state.spot;\n\t\t\t\tuniforms.spotLightShadows.value = lights.state.spotShadow;\n\t\t\t\tuniforms.rectAreaLights.value = lights.state.rectArea;\n\t\t\t\tuniforms.ltc_1.value = lights.state.rectAreaLTC1;\n\t\t\t\tuniforms.ltc_2.value = lights.state.rectAreaLTC2;\n\t\t\t\tuniforms.pointLights.value = lights.state.point;\n\t\t\t\tuniforms.pointLightShadows.value = lights.state.pointShadow;\n\t\t\t\tuniforms.hemisphereLights.value = lights.state.hemi;\n\n\t\t\t\tuniforms.directionalShadowMap.value = lights.state.directionalShadowMap;\n\t\t\t\tuniforms.directionalShadowMatrix.value = lights.state.directionalShadowMatrix;\n\t\t\t\tuniforms.spotShadowMap.value = lights.state.spotShadowMap;\n\t\t\t\tuniforms.spotLightMatrix.value = lights.state.spotLightMatrix;\n\t\t\t\tuniforms.spotLightMap.value = lights.state.spotLightMap;\n\t\t\t\tuniforms.pointShadowMap.value = lights.state.pointShadowMap;\n\t\t\t\tuniforms.pointShadowMatrix.value = lights.state.pointShadowMatrix;\n\t\t\t\t// TODO (abelnation): add area lights shadow info to uniforms\n\n\t\t\t}\n\n\t\t\tmaterialProperties.currentProgram = program;\n\t\t\tmaterialProperties.uniformsList = null;\n\n\t\t\treturn program;\n\n\t\t}\n\n\t\tfunction getUniformList( materialProperties ) {\n\n\t\t\tif ( materialProperties.uniformsList === null ) {\n\n\t\t\t\tconst progUniforms = materialProperties.currentProgram.getUniforms();\n\t\t\t\tmaterialProperties.uniformsList = WebGLUniforms.seqWithValue( progUniforms.seq, materialProperties.uniforms );\n\n\t\t\t}\n\n\t\t\treturn materialProperties.uniformsList;\n\n\t\t}\n\n\t\tfunction updateCommonMaterialProperties( material, parameters ) {\n\n\t\t\tconst materialProperties = properties.get( material );\n\n\t\t\tmaterialProperties.outputColorSpace = parameters.outputColorSpace;\n\t\t\tmaterialProperties.batching = parameters.batching;\n\t\t\tmaterialProperties.instancing = parameters.instancing;\n\t\t\tmaterialProperties.instancingColor = parameters.instancingColor;\n\t\t\tmaterialProperties.instancingMorph = parameters.instancingMorph;\n\t\t\tmaterialProperties.skinning = parameters.skinning;\n\t\t\tmaterialProperties.morphTargets = parameters.morphTargets;\n\t\t\tmaterialProperties.morphNormals = parameters.morphNormals;\n\t\t\tmaterialProperties.morphColors = parameters.morphColors;\n\t\t\tmaterialProperties.morphTargetsCount = parameters.morphTargetsCount;\n\t\t\tmaterialProperties.numClippingPlanes = parameters.numClippingPlanes;\n\t\t\tmaterialProperties.numIntersection = parameters.numClipIntersection;\n\t\t\tmaterialProperties.vertexAlphas = parameters.vertexAlphas;\n\t\t\tmaterialProperties.vertexTangents = parameters.vertexTangents;\n\t\t\tmaterialProperties.toneMapping = parameters.toneMapping;\n\n\t\t}\n\n\t\tfunction setProgram( camera, scene, geometry, material, object ) {\n\n\t\t\tif ( scene.isScene !== true ) scene = _emptyScene; // scene could be a Mesh, Line, Points, ...\n\n\t\t\ttextures.resetTextureUnits();\n\n\t\t\tconst fog = scene.fog;\n\t\t\tconst environment = material.isMeshStandardMaterial ? scene.environment : null;\n\t\t\tconst colorSpace = ( _currentRenderTarget === null ) ? _this.outputColorSpace : ( _currentRenderTarget.isXRRenderTarget === true ? _currentRenderTarget.texture.colorSpace : LinearSRGBColorSpace );\n\t\t\tconst envMap = ( material.isMeshStandardMaterial ? cubeuvmaps : cubemaps ).get( material.envMap || environment );\n\t\t\tconst vertexAlphas = material.vertexColors === true && !! geometry.attributes.color && geometry.attributes.color.itemSize === 4;\n\t\t\tconst vertexTangents = !! geometry.attributes.tangent && ( !! material.normalMap || material.anisotropy > 0 );\n\t\t\tconst morphTargets = !! geometry.morphAttributes.position;\n\t\t\tconst morphNormals = !! geometry.morphAttributes.normal;\n\t\t\tconst morphColors = !! geometry.morphAttributes.color;\n\n\t\t\tlet toneMapping = NoToneMapping;\n\n\t\t\tif ( material.toneMapped ) {\n\n\t\t\t\tif ( _currentRenderTarget === null || _currentRenderTarget.isXRRenderTarget === true ) {\n\n\t\t\t\t\ttoneMapping = _this.toneMapping;\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tconst morphAttribute = geometry.morphAttributes.position || geometry.morphAttributes.normal || geometry.morphAttributes.color;\n\t\t\tconst morphTargetsCount = ( morphAttribute !== undefined ) ? morphAttribute.length : 0;\n\n\t\t\tconst materialProperties = properties.get( material );\n\t\t\tconst lights = currentRenderState.state.lights;\n\n\t\t\tif ( _clippingEnabled === true ) {\n\n\t\t\t\tif ( _localClippingEnabled === true || camera !== _currentCamera ) {\n\n\t\t\t\t\tconst useCache =\n\t\t\t\t\t\tcamera === _currentCamera &&\n\t\t\t\t\t\tmaterial.id === _currentMaterialId;\n\n\t\t\t\t\t// we might want to call this function with some ClippingGroup\n\t\t\t\t\t// object instead of the material, once it becomes feasible\n\t\t\t\t\t// (#8465, #8379)\n\t\t\t\t\tclipping.setState( material, camera, useCache );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\t//\n\n\t\t\tlet needsProgramChange = false;\n\n\t\t\tif ( material.version === materialProperties.__version ) {\n\n\t\t\t\tif ( materialProperties.needsLights && ( materialProperties.lightsStateVersion !== lights.state.version ) ) {\n\n\t\t\t\t\tneedsProgramChange = true;\n\n\t\t\t\t} else if ( materialProperties.outputColorSpace !== colorSpace ) {\n\n\t\t\t\t\tneedsProgramChange = true;\n\n\t\t\t\t} else if ( object.isBatchedMesh && materialProperties.batching === false ) {\n\n\t\t\t\t\tneedsProgramChange = true;\n\n\t\t\t\t} else if ( ! object.isBatchedMesh && materialProperties.batching === true ) {\n\n\t\t\t\t\tneedsProgramChange = true;\n\n\t\t\t\t} else if ( object.isInstancedMesh && materialProperties.instancing === false ) {\n\n\t\t\t\t\tneedsProgramChange = true;\n\n\t\t\t\t} else if ( ! object.isInstancedMesh && materialProperties.instancing === true ) {\n\n\t\t\t\t\tneedsProgramChange = true;\n\n\t\t\t\t} else if ( object.isSkinnedMesh && materialProperties.skinning === false ) {\n\n\t\t\t\t\tneedsProgramChange = true;\n\n\t\t\t\t} else if ( ! object.isSkinnedMesh && materialProperties.skinning === true ) {\n\n\t\t\t\t\tneedsProgramChange = true;\n\n\t\t\t\t} else if ( object.isInstancedMesh && materialProperties.instancingColor === true && object.instanceColor === null ) {\n\n\t\t\t\t\tneedsProgramChange = true;\n\n\t\t\t\t} else if ( object.isInstancedMesh && materialProperties.instancingColor === false && object.instanceColor !== null ) {\n\n\t\t\t\t\tneedsProgramChange = true;\n\n\t\t\t\t} else if ( object.isInstancedMesh && materialProperties.instancingMorph === true && object.morphTexture === null ) {\n\n\t\t\t\t\tneedsProgramChange = true;\n\n\t\t\t\t} else if ( object.isInstancedMesh && materialProperties.instancingMorph === false && object.morphTexture !== null ) {\n\n\t\t\t\t\tneedsProgramChange = true;\n\n\t\t\t\t} else if ( materialProperties.envMap !== envMap ) {\n\n\t\t\t\t\tneedsProgramChange = true;\n\n\t\t\t\t} else if ( material.fog === true && materialProperties.fog !== fog ) {\n\n\t\t\t\t\tneedsProgramChange = true;\n\n\t\t\t\t} else if ( materialProperties.numClippingPlanes !== undefined &&\n\t\t\t\t\t( materialProperties.numClippingPlanes !== clipping.numPlanes ||\n\t\t\t\t\tmaterialProperties.numIntersection !== clipping.numIntersection ) ) {\n\n\t\t\t\t\tneedsProgramChange = true;\n\n\t\t\t\t} else if ( materialProperties.vertexAlphas !== vertexAlphas ) {\n\n\t\t\t\t\tneedsProgramChange = true;\n\n\t\t\t\t} else if ( materialProperties.vertexTangents !== vertexTangents ) {\n\n\t\t\t\t\tneedsProgramChange = true;\n\n\t\t\t\t} else if ( materialProperties.morphTargets !== morphTargets ) {\n\n\t\t\t\t\tneedsProgramChange = true;\n\n\t\t\t\t} else if ( materialProperties.morphNormals !== morphNormals ) {\n\n\t\t\t\t\tneedsProgramChange = true;\n\n\t\t\t\t} else if ( materialProperties.morphColors !== morphColors ) {\n\n\t\t\t\t\tneedsProgramChange = true;\n\n\t\t\t\t} else if ( materialProperties.toneMapping !== toneMapping ) {\n\n\t\t\t\t\tneedsProgramChange = true;\n\n\t\t\t\t} else if ( materialProperties.morphTargetsCount !== morphTargetsCount ) {\n\n\t\t\t\t\tneedsProgramChange = true;\n\n\t\t\t\t}\n\n\t\t\t} else {\n\n\t\t\t\tneedsProgramChange = true;\n\t\t\t\tmaterialProperties.__version = material.version;\n\n\t\t\t}\n\n\t\t\t//\n\n\t\t\tlet program = materialProperties.currentProgram;\n\n\t\t\tif ( needsProgramChange === true ) {\n\n\t\t\t\tprogram = getProgram( material, scene, object );\n\n\t\t\t}\n\n\t\t\tlet refreshProgram = false;\n\t\t\tlet refreshMaterial = false;\n\t\t\tlet refreshLights = false;\n\n\t\t\tconst p_uniforms = program.getUniforms(),\n\t\t\t\tm_uniforms = materialProperties.uniforms;\n\n\t\t\tif ( state.useProgram( program.program ) ) {\n\n\t\t\t\trefreshProgram = true;\n\t\t\t\trefreshMaterial = true;\n\t\t\t\trefreshLights = true;\n\n\t\t\t}\n\n\t\t\tif ( material.id !== _currentMaterialId ) {\n\n\t\t\t\t_currentMaterialId = material.id;\n\n\t\t\t\trefreshMaterial = true;\n\n\t\t\t}\n\n\t\t\tif ( refreshProgram || _currentCamera !== camera ) {\n\n\t\t\t\t// common camera uniforms\n\n\t\t\t\tp_uniforms.setValue( _gl, 'projectionMatrix', camera.projectionMatrix );\n\t\t\t\tp_uniforms.setValue( _gl, 'viewMatrix', camera.matrixWorldInverse );\n\n\t\t\t\tconst uCamPos = p_uniforms.map.cameraPosition;\n\n\t\t\t\tif ( uCamPos !== undefined ) {\n\n\t\t\t\t\tuCamPos.setValue( _gl, _vector3.setFromMatrixPosition( camera.matrixWorld ) );\n\n\t\t\t\t}\n\n\t\t\t\tif ( capabilities.logarithmicDepthBuffer ) {\n\n\t\t\t\t\tp_uniforms.setValue( _gl, 'logDepthBufFC',\n\t\t\t\t\t\t2.0 / ( Math.log( camera.far + 1.0 ) / Math.LN2 ) );\n\n\t\t\t\t}\n\n\t\t\t\t// consider moving isOrthographic to UniformLib and WebGLMaterials, see https://github.com/mrdoob/three.js/pull/26467#issuecomment-1645185067\n\n\t\t\t\tif ( material.isMeshPhongMaterial ||\n\t\t\t\t\tmaterial.isMeshToonMaterial ||\n\t\t\t\t\tmaterial.isMeshLambertMaterial ||\n\t\t\t\t\tmaterial.isMeshBasicMaterial ||\n\t\t\t\t\tmaterial.isMeshStandardMaterial ||\n\t\t\t\t\tmaterial.isShaderMaterial ) {\n\n\t\t\t\t\tp_uniforms.setValue( _gl, 'isOrthographic', camera.isOrthographicCamera === true );\n\n\t\t\t\t}\n\n\t\t\t\tif ( _currentCamera !== camera ) {\n\n\t\t\t\t\t_currentCamera = camera;\n\n\t\t\t\t\t// lighting uniforms depend on the camera so enforce an update\n\t\t\t\t\t// now, in case this material supports lights - or later, when\n\t\t\t\t\t// the next material that does gets activated:\n\n\t\t\t\t\trefreshMaterial = true;\t\t// set to true on material change\n\t\t\t\t\trefreshLights = true;\t\t// remains set until update done\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\t// skinning and morph target uniforms must be set even if material didn't change\n\t\t\t// auto-setting of texture unit for bone and morph texture must go before other textures\n\t\t\t// otherwise textures used for skinning and morphing can take over texture units reserved for other material textures\n\n\t\t\tif ( object.isSkinnedMesh ) {\n\n\t\t\t\tp_uniforms.setOptional( _gl, object, 'bindMatrix' );\n\t\t\t\tp_uniforms.setOptional( _gl, object, 'bindMatrixInverse' );\n\n\t\t\t\tconst skeleton = object.skeleton;\n\n\t\t\t\tif ( skeleton ) {\n\n\t\t\t\t\tif ( skeleton.boneTexture === null ) skeleton.computeBoneTexture();\n\n\t\t\t\t\tp_uniforms.setValue( _gl, 'boneTexture', skeleton.boneTexture, textures );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tif ( object.isBatchedMesh ) {\n\n\t\t\t\tp_uniforms.setOptional( _gl, object, 'batchingTexture' );\n\t\t\t\tp_uniforms.setValue( _gl, 'batchingTexture', object._matricesTexture, textures );\n\n\t\t\t}\n\n\t\t\tconst morphAttributes = geometry.morphAttributes;\n\n\t\t\tif ( morphAttributes.position !== undefined || morphAttributes.normal !== undefined || ( morphAttributes.color !== undefined ) ) {\n\n\t\t\t\tmorphtargets.update( object, geometry, program );\n\n\t\t\t}\n\n\t\t\tif ( refreshMaterial || materialProperties.receiveShadow !== object.receiveShadow ) {\n\n\t\t\t\tmaterialProperties.receiveShadow = object.receiveShadow;\n\t\t\t\tp_uniforms.setValue( _gl, 'receiveShadow', object.receiveShadow );\n\n\t\t\t}\n\n\t\t\t// https://github.com/mrdoob/three.js/pull/24467#issuecomment-1209031512\n\n\t\t\tif ( material.isMeshGouraudMaterial && material.envMap !== null ) {\n\n\t\t\t\tm_uniforms.envMap.value = envMap;\n\n\t\t\t\tm_uniforms.flipEnvMap.value = ( envMap.isCubeTexture && envMap.isRenderTargetTexture === false ) ? - 1 : 1;\n\n\t\t\t}\n\n\t\t\tif ( material.isMeshStandardMaterial && material.envMap === null && scene.environment !== null ) {\n\n\t\t\t\tm_uniforms.envMapIntensity.value = scene.environmentIntensity;\n\n\t\t\t}\n\n\t\t\tif ( refreshMaterial ) {\n\n\t\t\t\tp_uniforms.setValue( _gl, 'toneMappingExposure', _this.toneMappingExposure );\n\n\t\t\t\tif ( materialProperties.needsLights ) {\n\n\t\t\t\t\t// the current material requires lighting info\n\n\t\t\t\t\t// note: all lighting uniforms are always set correctly\n\t\t\t\t\t// they simply reference the renderer's state for their\n\t\t\t\t\t// values\n\t\t\t\t\t//\n\t\t\t\t\t// use the current material's .needsUpdate flags to set\n\t\t\t\t\t// the GL state when required\n\n\t\t\t\t\tmarkUniformsLightsNeedsUpdate( m_uniforms, refreshLights );\n\n\t\t\t\t}\n\n\t\t\t\t// refresh uniforms common to several materials\n\n\t\t\t\tif ( fog && material.fog === true ) {\n\n\t\t\t\t\tmaterials.refreshFogUniforms( m_uniforms, fog );\n\n\t\t\t\t}\n\n\t\t\t\tmaterials.refreshMaterialUniforms( m_uniforms, material, _pixelRatio, _height, currentRenderState.state.transmissionRenderTarget );\n\n\t\t\t\tWebGLUniforms.upload( _gl, getUniformList( materialProperties ), m_uniforms, textures );\n\n\t\t\t}\n\n\t\t\tif ( material.isShaderMaterial && material.uniformsNeedUpdate === true ) {\n\n\t\t\t\tWebGLUniforms.upload( _gl, getUniformList( materialProperties ), m_uniforms, textures );\n\t\t\t\tmaterial.uniformsNeedUpdate = false;\n\n\t\t\t}\n\n\t\t\tif ( material.isSpriteMaterial ) {\n\n\t\t\t\tp_uniforms.setValue( _gl, 'center', object.center );\n\n\t\t\t}\n\n\t\t\t// common matrices\n\n\t\t\tp_uniforms.setValue( _gl, 'modelViewMatrix', object.modelViewMatrix );\n\t\t\tp_uniforms.setValue( _gl, 'normalMatrix', object.normalMatrix );\n\t\t\tp_uniforms.setValue( _gl, 'modelMatrix', object.matrixWorld );\n\n\t\t\t// UBOs\n\n\t\t\tif ( material.isShaderMaterial || material.isRawShaderMaterial ) {\n\n\t\t\t\tconst groups = material.uniformsGroups;\n\n\t\t\t\tfor ( let i = 0, l = groups.length; i < l; i ++ ) {\n\n\t\t\t\t\tconst group = groups[ i ];\n\n\t\t\t\t\tuniformsGroups.update( group, program );\n\t\t\t\t\tuniformsGroups.bind( group, program );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\treturn program;\n\n\t\t}\n\n\t\t// If uniforms are marked as clean, they don't need to be loaded to the GPU.\n\n\t\tfunction markUniformsLightsNeedsUpdate( uniforms, value ) {\n\n\t\t\tuniforms.ambientLightColor.needsUpdate = value;\n\t\t\tuniforms.lightProbe.needsUpdate = value;\n\n\t\t\tuniforms.directionalLights.needsUpdate = value;\n\t\t\tuniforms.directionalLightShadows.needsUpdate = value;\n\t\t\tuniforms.pointLights.needsUpdate = value;\n\t\t\tuniforms.pointLightShadows.needsUpdate = value;\n\t\t\tuniforms.spotLights.needsUpdate = value;\n\t\t\tuniforms.spotLightShadows.needsUpdate = value;\n\t\t\tuniforms.rectAreaLights.needsUpdate = value;\n\t\t\tuniforms.hemisphereLights.needsUpdate = value;\n\n\t\t}\n\n\t\tfunction materialNeedsLights( material ) {\n\n\t\t\treturn material.isMeshLambertMaterial || material.isMeshToonMaterial || material.isMeshPhongMaterial ||\n\t\t\t\tmaterial.isMeshStandardMaterial || material.isShadowMaterial ||\n\t\t\t\t( material.isShaderMaterial && material.lights === true );\n\n\t\t}\n\n\t\tthis.getActiveCubeFace = function () {\n\n\t\t\treturn _currentActiveCubeFace;\n\n\t\t};\n\n\t\tthis.getActiveMipmapLevel = function () {\n\n\t\t\treturn _currentActiveMipmapLevel;\n\n\t\t};\n\n\t\tthis.getRenderTarget = function () {\n\n\t\t\treturn _currentRenderTarget;\n\n\t\t};\n\n\t\tthis.setRenderTargetTextures = function ( renderTarget, colorTexture, depthTexture ) {\n\n\t\t\tproperties.get( renderTarget.texture ).__webglTexture = colorTexture;\n\t\t\tproperties.get( renderTarget.depthTexture ).__webglTexture = depthTexture;\n\n\t\t\tconst renderTargetProperties = properties.get( renderTarget );\n\t\t\trenderTargetProperties.__hasExternalTextures = true;\n\n\t\t\trenderTargetProperties.__autoAllocateDepthBuffer = depthTexture === undefined;\n\n\t\t\tif ( ! renderTargetProperties.__autoAllocateDepthBuffer ) {\n\n\t\t\t\t// The multisample_render_to_texture extension doesn't work properly if there\n\t\t\t\t// are midframe flushes and an external depth buffer. Disable use of the extension.\n\t\t\t\tif ( extensions.has( 'WEBGL_multisampled_render_to_texture' ) === true ) {\n\n\t\t\t\t\tconsole.warn( 'THREE.WebGLRenderer: Render-to-texture extension was disabled because an external texture was provided' );\n\t\t\t\t\trenderTargetProperties.__useRenderToTexture = false;\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t};\n\n\t\tthis.setRenderTargetFramebuffer = function ( renderTarget, defaultFramebuffer ) {\n\n\t\t\tconst renderTargetProperties = properties.get( renderTarget );\n\t\t\trenderTargetProperties.__webglFramebuffer = defaultFramebuffer;\n\t\t\trenderTargetProperties.__useDefaultFramebuffer = defaultFramebuffer === undefined;\n\n\t\t};\n\n\t\tthis.setRenderTarget = function ( renderTarget, activeCubeFace = 0, activeMipmapLevel = 0 ) {\n\n\t\t\t_currentRenderTarget = renderTarget;\n\t\t\t_currentActiveCubeFace = activeCubeFace;\n\t\t\t_currentActiveMipmapLevel = activeMipmapLevel;\n\n\t\t\tlet useDefaultFramebuffer = true;\n\t\t\tlet framebuffer = null;\n\t\t\tlet isCube = false;\n\t\t\tlet isRenderTarget3D = false;\n\n\t\t\tif ( renderTarget ) {\n\n\t\t\t\tconst renderTargetProperties = properties.get( renderTarget );\n\n\t\t\t\tif ( renderTargetProperties.__useDefaultFramebuffer !== undefined ) {\n\n\t\t\t\t\t// We need to make sure to rebind the framebuffer.\n\t\t\t\t\tstate.bindFramebuffer( _gl.FRAMEBUFFER, null );\n\t\t\t\t\tuseDefaultFramebuffer = false;\n\n\t\t\t\t} else if ( renderTargetProperties.__webglFramebuffer === undefined ) {\n\n\t\t\t\t\ttextures.setupRenderTarget( renderTarget );\n\n\t\t\t\t} else if ( renderTargetProperties.__hasExternalTextures ) {\n\n\t\t\t\t\t// Color and depth texture must be rebound in order for the swapchain to update.\n\t\t\t\t\ttextures.rebindTextures( renderTarget, properties.get( renderTarget.texture ).__webglTexture, properties.get( renderTarget.depthTexture ).__webglTexture );\n\n\t\t\t\t}\n\n\t\t\t\tconst texture = renderTarget.texture;\n\n\t\t\t\tif ( texture.isData3DTexture || texture.isDataArrayTexture || texture.isCompressedArrayTexture ) {\n\n\t\t\t\t\tisRenderTarget3D = true;\n\n\t\t\t\t}\n\n\t\t\t\tconst __webglFramebuffer = properties.get( renderTarget ).__webglFramebuffer;\n\n\t\t\t\tif ( renderTarget.isWebGLCubeRenderTarget ) {\n\n\t\t\t\t\tif ( Array.isArray( __webglFramebuffer[ activeCubeFace ] ) ) {\n\n\t\t\t\t\t\tframebuffer = __webglFramebuffer[ activeCubeFace ][ activeMipmapLevel ];\n\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\tframebuffer = __webglFramebuffer[ activeCubeFace ];\n\n\t\t\t\t\t}\n\n\t\t\t\t\tisCube = true;\n\n\t\t\t\t} else if ( ( renderTarget.samples > 0 ) && textures.useMultisampledRTT( renderTarget ) === false ) {\n\n\t\t\t\t\tframebuffer = properties.get( renderTarget ).__webglMultisampledFramebuffer;\n\n\t\t\t\t} else {\n\n\t\t\t\t\tif ( Array.isArray( __webglFramebuffer ) ) {\n\n\t\t\t\t\t\tframebuffer = __webglFramebuffer[ activeMipmapLevel ];\n\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\tframebuffer = __webglFramebuffer;\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t\t_currentViewport.copy( renderTarget.viewport );\n\t\t\t\t_currentScissor.copy( renderTarget.scissor );\n\t\t\t\t_currentScissorTest = renderTarget.scissorTest;\n\n\t\t\t} else {\n\n\t\t\t\t_currentViewport.copy( _viewport ).multiplyScalar( _pixelRatio ).floor();\n\t\t\t\t_currentScissor.copy( _scissor ).multiplyScalar( _pixelRatio ).floor();\n\t\t\t\t_currentScissorTest = _scissorTest;\n\n\t\t\t}\n\n\t\t\tconst framebufferBound = state.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer );\n\n\t\t\tif ( framebufferBound && useDefaultFramebuffer ) {\n\n\t\t\t\tstate.drawBuffers( renderTarget, framebuffer );\n\n\t\t\t}\n\n\t\t\tstate.viewport( _currentViewport );\n\t\t\tstate.scissor( _currentScissor );\n\t\t\tstate.setScissorTest( _currentScissorTest );\n\n\t\t\tif ( isCube ) {\n\n\t\t\t\tconst textureProperties = properties.get( renderTarget.texture );\n\t\t\t\t_gl.framebufferTexture2D( _gl.FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_CUBE_MAP_POSITIVE_X + activeCubeFace, textureProperties.__webglTexture, activeMipmapLevel );\n\n\t\t\t} else if ( isRenderTarget3D ) {\n\n\t\t\t\tconst textureProperties = properties.get( renderTarget.texture );\n\t\t\t\tconst layer = activeCubeFace || 0;\n\t\t\t\t_gl.framebufferTextureLayer( _gl.FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, textureProperties.__webglTexture, activeMipmapLevel || 0, layer );\n\n\t\t\t}\n\n\t\t\t_currentMaterialId = - 1; // reset current material to ensure correct uniform bindings\n\n\t\t};\n\n\t\tthis.readRenderTargetPixels = function ( renderTarget, x, y, width, height, buffer, activeCubeFaceIndex ) {\n\n\t\t\tif ( ! ( renderTarget && renderTarget.isWebGLRenderTarget ) ) {\n\n\t\t\t\tconsole.error( 'THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget.' );\n\t\t\t\treturn;\n\n\t\t\t}\n\n\t\t\tlet framebuffer = properties.get( renderTarget ).__webglFramebuffer;\n\n\t\t\tif ( renderTarget.isWebGLCubeRenderTarget && activeCubeFaceIndex !== undefined ) {\n\n\t\t\t\tframebuffer = framebuffer[ activeCubeFaceIndex ];\n\n\t\t\t}\n\n\t\t\tif ( framebuffer ) {\n\n\t\t\t\tstate.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer );\n\n\t\t\t\ttry {\n\n\t\t\t\t\tconst texture = renderTarget.texture;\n\t\t\t\t\tconst textureFormat = texture.format;\n\t\t\t\t\tconst textureType = texture.type;\n\n\t\t\t\t\tif ( textureFormat !== RGBAFormat && utils.convert( textureFormat ) !== _gl.getParameter( _gl.IMPLEMENTATION_COLOR_READ_FORMAT ) ) {\n\n\t\t\t\t\t\tconsole.error( 'THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in RGBA or implementation defined format.' );\n\t\t\t\t\t\treturn;\n\n\t\t\t\t\t}\n\n\t\t\t\t\tconst halfFloatSupportedByExt = ( textureType === HalfFloatType ) && ( extensions.has( 'EXT_color_buffer_half_float' ) || extensions.has( 'EXT_color_buffer_float' ) );\n\n\t\t\t\t\tif ( textureType !== UnsignedByteType && utils.convert( textureType ) !== _gl.getParameter( _gl.IMPLEMENTATION_COLOR_READ_TYPE ) && // Edge and Chrome Mac < 52 (#9513)\n\t\t\t\t\t\ttextureType !== FloatType && ! halfFloatSupportedByExt ) {\n\n\t\t\t\t\t\tconsole.error( 'THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in UnsignedByteType or implementation defined type.' );\n\t\t\t\t\t\treturn;\n\n\t\t\t\t\t}\n\n\t\t\t\t\t// the following if statement ensures valid read requests (no out-of-bounds pixels, see #8604)\n\n\t\t\t\t\tif ( ( x >= 0 && x <= ( renderTarget.width - width ) ) && ( y >= 0 && y <= ( renderTarget.height - height ) ) ) {\n\n\t\t\t\t\t\t_gl.readPixels( x, y, width, height, utils.convert( textureFormat ), utils.convert( textureType ), buffer );\n\n\t\t\t\t\t}\n\n\t\t\t\t} finally {\n\n\t\t\t\t\t// restore framebuffer of current render target if necessary\n\n\t\t\t\t\tconst framebuffer = ( _currentRenderTarget !== null ) ? properties.get( _currentRenderTarget ).__webglFramebuffer : null;\n\t\t\t\t\tstate.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t};\n\n\t\tthis.copyFramebufferToTexture = function ( position, texture, level = 0 ) {\n\n\t\t\tconst levelScale = Math.pow( 2, - level );\n\t\t\tconst width = Math.floor( texture.image.width * levelScale );\n\t\t\tconst height = Math.floor( texture.image.height * levelScale );\n\n\t\t\ttextures.setTexture2D( texture, 0 );\n\n\t\t\t_gl.copyTexSubImage2D( _gl.TEXTURE_2D, level, 0, 0, position.x, position.y, width, height );\n\n\t\t\tstate.unbindTexture();\n\n\t\t};\n\n\t\tthis.copyTextureToTexture = function ( position, srcTexture, dstTexture, level = 0 ) {\n\n\t\t\tconst width = srcTexture.image.width;\n\t\t\tconst height = srcTexture.image.height;\n\t\t\tconst glFormat = utils.convert( dstTexture.format );\n\t\t\tconst glType = utils.convert( dstTexture.type );\n\n\t\t\ttextures.setTexture2D( dstTexture, 0 );\n\n\t\t\t// As another texture upload may have changed pixelStorei\n\t\t\t// parameters, make sure they are correct for the dstTexture\n\t\t\t_gl.pixelStorei( _gl.UNPACK_FLIP_Y_WEBGL, dstTexture.flipY );\n\t\t\t_gl.pixelStorei( _gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, dstTexture.premultiplyAlpha );\n\t\t\t_gl.pixelStorei( _gl.UNPACK_ALIGNMENT, dstTexture.unpackAlignment );\n\n\t\t\tif ( srcTexture.isDataTexture ) {\n\n\t\t\t\t_gl.texSubImage2D( _gl.TEXTURE_2D, level, position.x, position.y, width, height, glFormat, glType, srcTexture.image.data );\n\n\t\t\t} else {\n\n\t\t\t\tif ( srcTexture.isCompressedTexture ) {\n\n\t\t\t\t\t_gl.compressedTexSubImage2D( _gl.TEXTURE_2D, level, position.x, position.y, srcTexture.mipmaps[ 0 ].width, srcTexture.mipmaps[ 0 ].height, glFormat, srcTexture.mipmaps[ 0 ].data );\n\n\t\t\t\t} else {\n\n\t\t\t\t\t_gl.texSubImage2D( _gl.TEXTURE_2D, level, position.x, position.y, glFormat, glType, srcTexture.image );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\t// Generate mipmaps only when copying level 0\n\t\t\tif ( level === 0 && dstTexture.generateMipmaps ) _gl.generateMipmap( _gl.TEXTURE_2D );\n\n\t\t\tstate.unbindTexture();\n\n\t\t};\n\n\t\tthis.copyTextureToTexture3D = function ( sourceBox, position, srcTexture, dstTexture, level = 0 ) {\n\n\t\t\tconst width = Math.round( sourceBox.max.x - sourceBox.min.x );\n\t\t\tconst height = Math.round( sourceBox.max.y - sourceBox.min.y );\n\t\t\tconst depth = sourceBox.max.z - sourceBox.min.z + 1;\n\t\t\tconst glFormat = utils.convert( dstTexture.format );\n\t\t\tconst glType = utils.convert( dstTexture.type );\n\t\t\tlet glTarget;\n\n\t\t\tif ( dstTexture.isData3DTexture ) {\n\n\t\t\t\ttextures.setTexture3D( dstTexture, 0 );\n\t\t\t\tglTarget = _gl.TEXTURE_3D;\n\n\t\t\t} else if ( dstTexture.isDataArrayTexture || dstTexture.isCompressedArrayTexture ) {\n\n\t\t\t\ttextures.setTexture2DArray( dstTexture, 0 );\n\t\t\t\tglTarget = _gl.TEXTURE_2D_ARRAY;\n\n\t\t\t} else {\n\n\t\t\t\tconsole.warn( 'THREE.WebGLRenderer.copyTextureToTexture3D: only supports THREE.DataTexture3D and THREE.DataTexture2DArray.' );\n\t\t\t\treturn;\n\n\t\t\t}\n\n\t\t\t_gl.pixelStorei( _gl.UNPACK_FLIP_Y_WEBGL, dstTexture.flipY );\n\t\t\t_gl.pixelStorei( _gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, dstTexture.premultiplyAlpha );\n\t\t\t_gl.pixelStorei( _gl.UNPACK_ALIGNMENT, dstTexture.unpackAlignment );\n\n\t\t\tconst unpackRowLen = _gl.getParameter( _gl.UNPACK_ROW_LENGTH );\n\t\t\tconst unpackImageHeight = _gl.getParameter( _gl.UNPACK_IMAGE_HEIGHT );\n\t\t\tconst unpackSkipPixels = _gl.getParameter( _gl.UNPACK_SKIP_PIXELS );\n\t\t\tconst unpackSkipRows = _gl.getParameter( _gl.UNPACK_SKIP_ROWS );\n\t\t\tconst unpackSkipImages = _gl.getParameter( _gl.UNPACK_SKIP_IMAGES );\n\n\t\t\tconst image = srcTexture.isCompressedTexture ? srcTexture.mipmaps[ level ] : srcTexture.image;\n\n\t\t\t_gl.pixelStorei( _gl.UNPACK_ROW_LENGTH, image.width );\n\t\t\t_gl.pixelStorei( _gl.UNPACK_IMAGE_HEIGHT, image.height );\n\t\t\t_gl.pixelStorei( _gl.UNPACK_SKIP_PIXELS, sourceBox.min.x );\n\t\t\t_gl.pixelStorei( _gl.UNPACK_SKIP_ROWS, sourceBox.min.y );\n\t\t\t_gl.pixelStorei( _gl.UNPACK_SKIP_IMAGES, sourceBox.min.z );\n\n\t\t\tif ( srcTexture.isDataTexture || srcTexture.isData3DTexture ) {\n\n\t\t\t\t_gl.texSubImage3D( glTarget, level, position.x, position.y, position.z, width, height, depth, glFormat, glType, image.data );\n\n\t\t\t} else {\n\n\t\t\t\tif ( dstTexture.isCompressedArrayTexture ) {\n\n\t\t\t\t\t_gl.compressedTexSubImage3D( glTarget, level, position.x, position.y, position.z, width, height, depth, glFormat, image.data );\n\n\t\t\t\t} else {\n\n\t\t\t\t\t_gl.texSubImage3D( glTarget, level, position.x, position.y, position.z, width, height, depth, glFormat, glType, image );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\t_gl.pixelStorei( _gl.UNPACK_ROW_LENGTH, unpackRowLen );\n\t\t\t_gl.pixelStorei( _gl.UNPACK_IMAGE_HEIGHT, unpackImageHeight );\n\t\t\t_gl.pixelStorei( _gl.UNPACK_SKIP_PIXELS, unpackSkipPixels );\n\t\t\t_gl.pixelStorei( _gl.UNPACK_SKIP_ROWS, unpackSkipRows );\n\t\t\t_gl.pixelStorei( _gl.UNPACK_SKIP_IMAGES, unpackSkipImages );\n\n\t\t\t// Generate mipmaps only when copying level 0\n\t\t\tif ( level === 0 && dstTexture.generateMipmaps ) _gl.generateMipmap( glTarget );\n\n\t\t\tstate.unbindTexture();\n\n\t\t};\n\n\t\tthis.initTexture = function ( texture ) {\n\n\t\t\tif ( texture.isCubeTexture ) {\n\n\t\t\t\ttextures.setTextureCube( texture, 0 );\n\n\t\t\t} else if ( texture.isData3DTexture ) {\n\n\t\t\t\ttextures.setTexture3D( texture, 0 );\n\n\t\t\t} else if ( texture.isDataArrayTexture || texture.isCompressedArrayTexture ) {\n\n\t\t\t\ttextures.setTexture2DArray( texture, 0 );\n\n\t\t\t} else {\n\n\t\t\t\ttextures.setTexture2D( texture, 0 );\n\n\t\t\t}\n\n\t\t\tstate.unbindTexture();\n\n\t\t};\n\n\t\tthis.resetState = function () {\n\n\t\t\t_currentActiveCubeFace = 0;\n\t\t\t_currentActiveMipmapLevel = 0;\n\t\t\t_currentRenderTarget = null;\n\n\t\t\tstate.reset();\n\t\t\tbindingStates.reset();\n\n\t\t};\n\n\t\tif ( typeof __THREE_DEVTOOLS__ !== 'undefined' ) {\n\n\t\t\t__THREE_DEVTOOLS__.dispatchEvent( new CustomEvent( 'observe', { detail: this } ) );\n\n\t\t}\n\n\t}\n\n\tget coordinateSystem() {\n\n\t\treturn WebGLCoordinateSystem;\n\n\t}\n\n\tget outputColorSpace() {\n\n\t\treturn this._outputColorSpace;\n\n\t}\n\n\tset outputColorSpace( colorSpace ) {\n\n\t\tthis._outputColorSpace = colorSpace;\n\n\t\tconst gl = this.getContext();\n\t\tgl.drawingBufferColorSpace = colorSpace === DisplayP3ColorSpace ? 'display-p3' : 'srgb';\n\t\tgl.unpackColorSpace = ColorManagement.workingColorSpace === LinearDisplayP3ColorSpace ? 'display-p3' : 'srgb';\n\n\t}\n\n\tget useLegacyLights() { // @deprecated, r155\n\n\t\tconsole.warn( 'THREE.WebGLRenderer: The property .useLegacyLights has been deprecated. Migrate your lighting according to the following guide: https://discourse.threejs.org/t/updates-to-lighting-in-three-js-r155/53733.' );\n\t\treturn this._useLegacyLights;\n\n\t}\n\n\tset useLegacyLights( value ) { // @deprecated, r155\n\n\t\tconsole.warn( 'THREE.WebGLRenderer: The property .useLegacyLights has been deprecated. Migrate your lighting according to the following guide: https://discourse.threejs.org/t/updates-to-lighting-in-three-js-r155/53733.' );\n\t\tthis._useLegacyLights = value;\n\n\t}\n\n}\n\nclass FogExp2 {\n\n\tconstructor( color, density = 0.00025 ) {\n\n\t\tthis.isFogExp2 = true;\n\n\t\tthis.name = '';\n\n\t\tthis.color = new Color( color );\n\t\tthis.density = density;\n\n\t}\n\n\tclone() {\n\n\t\treturn new FogExp2( this.color, this.density );\n\n\t}\n\n\ttoJSON( /* meta */ ) {\n\n\t\treturn {\n\t\t\ttype: 'FogExp2',\n\t\t\tname: this.name,\n\t\t\tcolor: this.color.getHex(),\n\t\t\tdensity: this.density\n\t\t};\n\n\t}\n\n}\n\nclass Fog {\n\n\tconstructor( color, near = 1, far = 1000 ) {\n\n\t\tthis.isFog = true;\n\n\t\tthis.name = '';\n\n\t\tthis.color = new Color( color );\n\n\t\tthis.near = near;\n\t\tthis.far = far;\n\n\t}\n\n\tclone() {\n\n\t\treturn new Fog( this.color, this.near, this.far );\n\n\t}\n\n\ttoJSON( /* meta */ ) {\n\n\t\treturn {\n\t\t\ttype: 'Fog',\n\t\t\tname: this.name,\n\t\t\tcolor: this.color.getHex(),\n\t\t\tnear: this.near,\n\t\t\tfar: this.far\n\t\t};\n\n\t}\n\n}\n\nclass Scene extends Object3D {\n\n\tconstructor() {\n\n\t\tsuper();\n\n\t\tthis.isScene = true;\n\n\t\tthis.type = 'Scene';\n\n\t\tthis.background = null;\n\t\tthis.environment = null;\n\t\tthis.fog = null;\n\n\t\tthis.backgroundBlurriness = 0;\n\t\tthis.backgroundIntensity = 1;\n\t\tthis.backgroundRotation = new Euler();\n\n\t\tthis.environmentIntensity = 1;\n\t\tthis.environmentRotation = new Euler();\n\n\t\tthis.overrideMaterial = null;\n\n\t\tif ( typeof __THREE_DEVTOOLS__ !== 'undefined' ) {\n\n\t\t\t__THREE_DEVTOOLS__.dispatchEvent( new CustomEvent( 'observe', { detail: this } ) );\n\n\t\t}\n\n\t}\n\n\tcopy( source, recursive ) {\n\n\t\tsuper.copy( source, recursive );\n\n\t\tif ( source.background !== null ) this.background = source.background.clone();\n\t\tif ( source.environment !== null ) this.environment = source.environment.clone();\n\t\tif ( source.fog !== null ) this.fog = source.fog.clone();\n\n\t\tthis.backgroundBlurriness = source.backgroundBlurriness;\n\t\tthis.backgroundIntensity = source.backgroundIntensity;\n\t\tthis.backgroundRotation.copy( source.backgroundRotation );\n\n\t\tthis.environmentIntensity = source.environmentIntensity;\n\t\tthis.environmentRotation.copy( source.environmentRotation );\n\n\t\tif ( source.overrideMaterial !== null ) this.overrideMaterial = source.overrideMaterial.clone();\n\n\t\tthis.matrixAutoUpdate = source.matrixAutoUpdate;\n\n\t\treturn this;\n\n\t}\n\n\ttoJSON( meta ) {\n\n\t\tconst data = super.toJSON( meta );\n\n\t\tif ( this.fog !== null ) data.object.fog = this.fog.toJSON();\n\n\t\tif ( this.backgroundBlurriness > 0 ) data.object.backgroundBlurriness = this.backgroundBlurriness;\n\t\tif ( this.backgroundIntensity !== 1 ) data.object.backgroundIntensity = this.backgroundIntensity;\n\t\tdata.object.backgroundRotation = this.backgroundRotation.toArray();\n\n\t\tif ( this.environmentIntensity !== 1 ) data.object.environmentIntensity = this.environmentIntensity;\n\t\tdata.object.environmentRotation = this.environmentRotation.toArray();\n\n\t\treturn data;\n\n\t}\n\n}\n\nclass InterleavedBuffer {\n\n\tconstructor( array, stride ) {\n\n\t\tthis.isInterleavedBuffer = true;\n\n\t\tthis.array = array;\n\t\tthis.stride = stride;\n\t\tthis.count = array !== undefined ? array.length / stride : 0;\n\n\t\tthis.usage = StaticDrawUsage;\n\t\tthis._updateRange = { offset: 0, count: - 1 };\n\t\tthis.updateRanges = [];\n\n\t\tthis.version = 0;\n\n\t\tthis.uuid = generateUUID();\n\n\t}\n\n\tonUploadCallback() {}\n\n\tset needsUpdate( value ) {\n\n\t\tif ( value === true ) this.version ++;\n\n\t}\n\n\tget updateRange() {\n\n\t\twarnOnce( 'THREE.InterleavedBuffer: updateRange() is deprecated and will be removed in r169. Use addUpdateRange() instead.' ); // @deprecated, r159\n\t\treturn this._updateRange;\n\n\t}\n\n\tsetUsage( value ) {\n\n\t\tthis.usage = value;\n\n\t\treturn this;\n\n\t}\n\n\taddUpdateRange( start, count ) {\n\n\t\tthis.updateRanges.push( { start, count } );\n\n\t}\n\n\tclearUpdateRanges() {\n\n\t\tthis.updateRanges.length = 0;\n\n\t}\n\n\tcopy( source ) {\n\n\t\tthis.array = new source.array.constructor( source.array );\n\t\tthis.count = source.count;\n\t\tthis.stride = source.stride;\n\t\tthis.usage = source.usage;\n\n\t\treturn this;\n\n\t}\n\n\tcopyAt( index1, attribute, index2 ) {\n\n\t\tindex1 *= this.stride;\n\t\tindex2 *= attribute.stride;\n\n\t\tfor ( let i = 0, l = this.stride; i < l; i ++ ) {\n\n\t\t\tthis.array[ index1 + i ] = attribute.array[ index2 + i ];\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tset( value, offset = 0 ) {\n\n\t\tthis.array.set( value, offset );\n\n\t\treturn this;\n\n\t}\n\n\tclone( data ) {\n\n\t\tif ( data.arrayBuffers === undefined ) {\n\n\t\t\tdata.arrayBuffers = {};\n\n\t\t}\n\n\t\tif ( this.array.buffer._uuid === undefined ) {\n\n\t\t\tthis.array.buffer._uuid = generateUUID();\n\n\t\t}\n\n\t\tif ( data.arrayBuffers[ this.array.buffer._uuid ] === undefined ) {\n\n\t\t\tdata.arrayBuffers[ this.array.buffer._uuid ] = this.array.slice( 0 ).buffer;\n\n\t\t}\n\n\t\tconst array = new this.array.constructor( data.arrayBuffers[ this.array.buffer._uuid ] );\n\n\t\tconst ib = new this.constructor( array, this.stride );\n\t\tib.setUsage( this.usage );\n\n\t\treturn ib;\n\n\t}\n\n\tonUpload( callback ) {\n\n\t\tthis.onUploadCallback = callback;\n\n\t\treturn this;\n\n\t}\n\n\ttoJSON( data ) {\n\n\t\tif ( data.arrayBuffers === undefined ) {\n\n\t\t\tdata.arrayBuffers = {};\n\n\t\t}\n\n\t\t// generate UUID for array buffer if necessary\n\n\t\tif ( this.array.buffer._uuid === undefined ) {\n\n\t\t\tthis.array.buffer._uuid = generateUUID();\n\n\t\t}\n\n\t\tif ( data.arrayBuffers[ this.array.buffer._uuid ] === undefined ) {\n\n\t\t\tdata.arrayBuffers[ this.array.buffer._uuid ] = Array.from( new Uint32Array( this.array.buffer ) );\n\n\t\t}\n\n\t\t//\n\n\t\treturn {\n\t\t\tuuid: this.uuid,\n\t\t\tbuffer: this.array.buffer._uuid,\n\t\t\ttype: this.array.constructor.name,\n\t\t\tstride: this.stride\n\t\t};\n\n\t}\n\n}\n\nconst _vector$6 = /*@__PURE__*/ new Vector3();\n\nclass InterleavedBufferAttribute {\n\n\tconstructor( interleavedBuffer, itemSize, offset, normalized = false ) {\n\n\t\tthis.isInterleavedBufferAttribute = true;\n\n\t\tthis.name = '';\n\n\t\tthis.data = interleavedBuffer;\n\t\tthis.itemSize = itemSize;\n\t\tthis.offset = offset;\n\n\t\tthis.normalized = normalized;\n\n\t}\n\n\tget count() {\n\n\t\treturn this.data.count;\n\n\t}\n\n\tget array() {\n\n\t\treturn this.data.array;\n\n\t}\n\n\tset needsUpdate( value ) {\n\n\t\tthis.data.needsUpdate = value;\n\n\t}\n\n\tapplyMatrix4( m ) {\n\n\t\tfor ( let i = 0, l = this.data.count; i < l; i ++ ) {\n\n\t\t\t_vector$6.fromBufferAttribute( this, i );\n\n\t\t\t_vector$6.applyMatrix4( m );\n\n\t\t\tthis.setXYZ( i, _vector$6.x, _vector$6.y, _vector$6.z );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tapplyNormalMatrix( m ) {\n\n\t\tfor ( let i = 0, l = this.count; i < l; i ++ ) {\n\n\t\t\t_vector$6.fromBufferAttribute( this, i );\n\n\t\t\t_vector$6.applyNormalMatrix( m );\n\n\t\t\tthis.setXYZ( i, _vector$6.x, _vector$6.y, _vector$6.z );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\ttransformDirection( m ) {\n\n\t\tfor ( let i = 0, l = this.count; i < l; i ++ ) {\n\n\t\t\t_vector$6.fromBufferAttribute( this, i );\n\n\t\t\t_vector$6.transformDirection( m );\n\n\t\t\tthis.setXYZ( i, _vector$6.x, _vector$6.y, _vector$6.z );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tgetComponent( index, component ) {\n\n\t\tlet value = this.array[ index * this.data.stride + this.offset + component ];\n\n\t\tif ( this.normalized ) value = denormalize( value, this.array );\n\n\t\treturn value;\n\n\t}\n\n\tsetComponent( index, component, value ) {\n\n\t\tif ( this.normalized ) value = normalize( value, this.array );\n\n\t\tthis.data.array[ index * this.data.stride + this.offset + component ] = value;\n\n\t\treturn this;\n\n\t}\n\n\tsetX( index, x ) {\n\n\t\tif ( this.normalized ) x = normalize( x, this.array );\n\n\t\tthis.data.array[ index * this.data.stride + this.offset ] = x;\n\n\t\treturn this;\n\n\t}\n\n\tsetY( index, y ) {\n\n\t\tif ( this.normalized ) y = normalize( y, this.array );\n\n\t\tthis.data.array[ index * this.data.stride + this.offset + 1 ] = y;\n\n\t\treturn this;\n\n\t}\n\n\tsetZ( index, z ) {\n\n\t\tif ( this.normalized ) z = normalize( z, this.array );\n\n\t\tthis.data.array[ index * this.data.stride + this.offset + 2 ] = z;\n\n\t\treturn this;\n\n\t}\n\n\tsetW( index, w ) {\n\n\t\tif ( this.normalized ) w = normalize( w, this.array );\n\n\t\tthis.data.array[ index * this.data.stride + this.offset + 3 ] = w;\n\n\t\treturn this;\n\n\t}\n\n\tgetX( index ) {\n\n\t\tlet x = this.data.array[ index * this.data.stride + this.offset ];\n\n\t\tif ( this.normalized ) x = denormalize( x, this.array );\n\n\t\treturn x;\n\n\t}\n\n\tgetY( index ) {\n\n\t\tlet y = this.data.array[ index * this.data.stride + this.offset + 1 ];\n\n\t\tif ( this.normalized ) y = denormalize( y, this.array );\n\n\t\treturn y;\n\n\t}\n\n\tgetZ( index ) {\n\n\t\tlet z = this.data.array[ index * this.data.stride + this.offset + 2 ];\n\n\t\tif ( this.normalized ) z = denormalize( z, this.array );\n\n\t\treturn z;\n\n\t}\n\n\tgetW( index ) {\n\n\t\tlet w = this.data.array[ index * this.data.stride + this.offset + 3 ];\n\n\t\tif ( this.normalized ) w = denormalize( w, this.array );\n\n\t\treturn w;\n\n\t}\n\n\tsetXY( index, x, y ) {\n\n\t\tindex = index * this.data.stride + this.offset;\n\n\t\tif ( this.normalized ) {\n\n\t\t\tx = normalize( x, this.array );\n\t\t\ty = normalize( y, this.array );\n\n\t\t}\n\n\t\tthis.data.array[ index + 0 ] = x;\n\t\tthis.data.array[ index + 1 ] = y;\n\n\t\treturn this;\n\n\t}\n\n\tsetXYZ( index, x, y, z ) {\n\n\t\tindex = index * this.data.stride + this.offset;\n\n\t\tif ( this.normalized ) {\n\n\t\t\tx = normalize( x, this.array );\n\t\t\ty = normalize( y, this.array );\n\t\t\tz = normalize( z, this.array );\n\n\t\t}\n\n\t\tthis.data.array[ index + 0 ] = x;\n\t\tthis.data.array[ index + 1 ] = y;\n\t\tthis.data.array[ index + 2 ] = z;\n\n\t\treturn this;\n\n\t}\n\n\tsetXYZW( index, x, y, z, w ) {\n\n\t\tindex = index * this.data.stride + this.offset;\n\n\t\tif ( this.normalized ) {\n\n\t\t\tx = normalize( x, this.array );\n\t\t\ty = normalize( y, this.array );\n\t\t\tz = normalize( z, this.array );\n\t\t\tw = normalize( w, this.array );\n\n\t\t}\n\n\t\tthis.data.array[ index + 0 ] = x;\n\t\tthis.data.array[ index + 1 ] = y;\n\t\tthis.data.array[ index + 2 ] = z;\n\t\tthis.data.array[ index + 3 ] = w;\n\n\t\treturn this;\n\n\t}\n\n\tclone( data ) {\n\n\t\tif ( data === undefined ) {\n\n\t\t\tconsole.log( 'THREE.InterleavedBufferAttribute.clone(): Cloning an interleaved buffer attribute will de-interleave buffer data.' );\n\n\t\t\tconst array = [];\n\n\t\t\tfor ( let i = 0; i < this.count; i ++ ) {\n\n\t\t\t\tconst index = i * this.data.stride + this.offset;\n\n\t\t\t\tfor ( let j = 0; j < this.itemSize; j ++ ) {\n\n\t\t\t\t\tarray.push( this.data.array[ index + j ] );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\treturn new BufferAttribute( new this.array.constructor( array ), this.itemSize, this.normalized );\n\n\t\t} else {\n\n\t\t\tif ( data.interleavedBuffers === undefined ) {\n\n\t\t\t\tdata.interleavedBuffers = {};\n\n\t\t\t}\n\n\t\t\tif ( data.interleavedBuffers[ this.data.uuid ] === undefined ) {\n\n\t\t\t\tdata.interleavedBuffers[ this.data.uuid ] = this.data.clone( data );\n\n\t\t\t}\n\n\t\t\treturn new InterleavedBufferAttribute( data.interleavedBuffers[ this.data.uuid ], this.itemSize, this.offset, this.normalized );\n\n\t\t}\n\n\t}\n\n\ttoJSON( data ) {\n\n\t\tif ( data === undefined ) {\n\n\t\t\tconsole.log( 'THREE.InterleavedBufferAttribute.toJSON(): Serializing an interleaved buffer attribute will de-interleave buffer data.' );\n\n\t\t\tconst array = [];\n\n\t\t\tfor ( let i = 0; i < this.count; i ++ ) {\n\n\t\t\t\tconst index = i * this.data.stride + this.offset;\n\n\t\t\t\tfor ( let j = 0; j < this.itemSize; j ++ ) {\n\n\t\t\t\t\tarray.push( this.data.array[ index + j ] );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\t// de-interleave data and save it as an ordinary buffer attribute for now\n\n\t\t\treturn {\n\t\t\t\titemSize: this.itemSize,\n\t\t\t\ttype: this.array.constructor.name,\n\t\t\t\tarray: array,\n\t\t\t\tnormalized: this.normalized\n\t\t\t};\n\n\t\t} else {\n\n\t\t\t// save as true interleaved attribute\n\n\t\t\tif ( data.interleavedBuffers === undefined ) {\n\n\t\t\t\tdata.interleavedBuffers = {};\n\n\t\t\t}\n\n\t\t\tif ( data.interleavedBuffers[ this.data.uuid ] === undefined ) {\n\n\t\t\t\tdata.interleavedBuffers[ this.data.uuid ] = this.data.toJSON( data );\n\n\t\t\t}\n\n\t\t\treturn {\n\t\t\t\tisInterleavedBufferAttribute: true,\n\t\t\t\titemSize: this.itemSize,\n\t\t\t\tdata: this.data.uuid,\n\t\t\t\toffset: this.offset,\n\t\t\t\tnormalized: this.normalized\n\t\t\t};\n\n\t\t}\n\n\t}\n\n}\n\nclass SpriteMaterial extends Material {\n\n\tconstructor( parameters ) {\n\n\t\tsuper();\n\n\t\tthis.isSpriteMaterial = true;\n\n\t\tthis.type = 'SpriteMaterial';\n\n\t\tthis.color = new Color( 0xffffff );\n\n\t\tthis.map = null;\n\n\t\tthis.alphaMap = null;\n\n\t\tthis.rotation = 0;\n\n\t\tthis.sizeAttenuation = true;\n\n\t\tthis.transparent = true;\n\n\t\tthis.fog = true;\n\n\t\tthis.setValues( parameters );\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.color.copy( source.color );\n\n\t\tthis.map = source.map;\n\n\t\tthis.alphaMap = source.alphaMap;\n\n\t\tthis.rotation = source.rotation;\n\n\t\tthis.sizeAttenuation = source.sizeAttenuation;\n\n\t\tthis.fog = source.fog;\n\n\t\treturn this;\n\n\t}\n\n}\n\nlet _geometry;\n\nconst _intersectPoint = /*@__PURE__*/ new Vector3();\nconst _worldScale = /*@__PURE__*/ new Vector3();\nconst _mvPosition = /*@__PURE__*/ new Vector3();\n\nconst _alignedPosition = /*@__PURE__*/ new Vector2();\nconst _rotatedPosition = /*@__PURE__*/ new Vector2();\nconst _viewWorldMatrix = /*@__PURE__*/ new Matrix4();\n\nconst _vA = /*@__PURE__*/ new Vector3();\nconst _vB = /*@__PURE__*/ new Vector3();\nconst _vC = /*@__PURE__*/ new Vector3();\n\nconst _uvA = /*@__PURE__*/ new Vector2();\nconst _uvB = /*@__PURE__*/ new Vector2();\nconst _uvC = /*@__PURE__*/ new Vector2();\n\nclass Sprite extends Object3D {\n\n\tconstructor( material = new SpriteMaterial() ) {\n\n\t\tsuper();\n\n\t\tthis.isSprite = true;\n\n\t\tthis.type = 'Sprite';\n\n\t\tif ( _geometry === undefined ) {\n\n\t\t\t_geometry = new BufferGeometry();\n\n\t\t\tconst float32Array = new Float32Array( [\n\t\t\t\t- 0.5, - 0.5, 0, 0, 0,\n\t\t\t\t0.5, - 0.5, 0, 1, 0,\n\t\t\t\t0.5, 0.5, 0, 1, 1,\n\t\t\t\t- 0.5, 0.5, 0, 0, 1\n\t\t\t] );\n\n\t\t\tconst interleavedBuffer = new InterleavedBuffer( float32Array, 5 );\n\n\t\t\t_geometry.setIndex( [ 0, 1, 2,\t0, 2, 3 ] );\n\t\t\t_geometry.setAttribute( 'position', new InterleavedBufferAttribute( interleavedBuffer, 3, 0, false ) );\n\t\t\t_geometry.setAttribute( 'uv', new InterleavedBufferAttribute( interleavedBuffer, 2, 3, false ) );\n\n\t\t}\n\n\t\tthis.geometry = _geometry;\n\t\tthis.material = material;\n\n\t\tthis.center = new Vector2( 0.5, 0.5 );\n\n\t}\n\n\traycast( raycaster, intersects ) {\n\n\t\tif ( raycaster.camera === null ) {\n\n\t\t\tconsole.error( 'THREE.Sprite: \"Raycaster.camera\" needs to be set in order to raycast against sprites.' );\n\n\t\t}\n\n\t\t_worldScale.setFromMatrixScale( this.matrixWorld );\n\n\t\t_viewWorldMatrix.copy( raycaster.camera.matrixWorld );\n\t\tthis.modelViewMatrix.multiplyMatrices( raycaster.camera.matrixWorldInverse, this.matrixWorld );\n\n\t\t_mvPosition.setFromMatrixPosition( this.modelViewMatrix );\n\n\t\tif ( raycaster.camera.isPerspectiveCamera && this.material.sizeAttenuation === false ) {\n\n\t\t\t_worldScale.multiplyScalar( - _mvPosition.z );\n\n\t\t}\n\n\t\tconst rotation = this.material.rotation;\n\t\tlet sin, cos;\n\n\t\tif ( rotation !== 0 ) {\n\n\t\t\tcos = Math.cos( rotation );\n\t\t\tsin = Math.sin( rotation );\n\n\t\t}\n\n\t\tconst center = this.center;\n\n\t\ttransformVertex( _vA.set( - 0.5, - 0.5, 0 ), _mvPosition, center, _worldScale, sin, cos );\n\t\ttransformVertex( _vB.set( 0.5, - 0.5, 0 ), _mvPosition, center, _worldScale, sin, cos );\n\t\ttransformVertex( _vC.set( 0.5, 0.5, 0 ), _mvPosition, center, _worldScale, sin, cos );\n\n\t\t_uvA.set( 0, 0 );\n\t\t_uvB.set( 1, 0 );\n\t\t_uvC.set( 1, 1 );\n\n\t\t// check first triangle\n\t\tlet intersect = raycaster.ray.intersectTriangle( _vA, _vB, _vC, false, _intersectPoint );\n\n\t\tif ( intersect === null ) {\n\n\t\t\t// check second triangle\n\t\t\ttransformVertex( _vB.set( - 0.5, 0.5, 0 ), _mvPosition, center, _worldScale, sin, cos );\n\t\t\t_uvB.set( 0, 1 );\n\n\t\t\tintersect = raycaster.ray.intersectTriangle( _vA, _vC, _vB, false, _intersectPoint );\n\t\t\tif ( intersect === null ) {\n\n\t\t\t\treturn;\n\n\t\t\t}\n\n\t\t}\n\n\t\tconst distance = raycaster.ray.origin.distanceTo( _intersectPoint );\n\n\t\tif ( distance < raycaster.near || distance > raycaster.far ) return;\n\n\t\tintersects.push( {\n\n\t\t\tdistance: distance,\n\t\t\tpoint: _intersectPoint.clone(),\n\t\t\tuv: Triangle.getInterpolation( _intersectPoint, _vA, _vB, _vC, _uvA, _uvB, _uvC, new Vector2() ),\n\t\t\tface: null,\n\t\t\tobject: this\n\n\t\t} );\n\n\t}\n\n\tcopy( source, recursive ) {\n\n\t\tsuper.copy( source, recursive );\n\n\t\tif ( source.center !== undefined ) this.center.copy( source.center );\n\n\t\tthis.material = source.material;\n\n\t\treturn this;\n\n\t}\n\n}\n\nfunction transformVertex( vertexPosition, mvPosition, center, scale, sin, cos ) {\n\n\t// compute position in camera space\n\t_alignedPosition.subVectors( vertexPosition, center ).addScalar( 0.5 ).multiply( scale );\n\n\t// to check if rotation is not zero\n\tif ( sin !== undefined ) {\n\n\t\t_rotatedPosition.x = ( cos * _alignedPosition.x ) - ( sin * _alignedPosition.y );\n\t\t_rotatedPosition.y = ( sin * _alignedPosition.x ) + ( cos * _alignedPosition.y );\n\n\t} else {\n\n\t\t_rotatedPosition.copy( _alignedPosition );\n\n\t}\n\n\n\tvertexPosition.copy( mvPosition );\n\tvertexPosition.x += _rotatedPosition.x;\n\tvertexPosition.y += _rotatedPosition.y;\n\n\t// transform to world space\n\tvertexPosition.applyMatrix4( _viewWorldMatrix );\n\n}\n\nconst _v1$2 = /*@__PURE__*/ new Vector3();\nconst _v2$1 = /*@__PURE__*/ new Vector3();\n\nclass LOD extends Object3D {\n\n\tconstructor() {\n\n\t\tsuper();\n\n\t\tthis._currentLevel = 0;\n\n\t\tthis.type = 'LOD';\n\n\t\tObject.defineProperties( this, {\n\t\t\tlevels: {\n\t\t\t\tenumerable: true,\n\t\t\t\tvalue: []\n\t\t\t},\n\t\t\tisLOD: {\n\t\t\t\tvalue: true,\n\t\t\t}\n\t\t} );\n\n\t\tthis.autoUpdate = true;\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source, false );\n\n\t\tconst levels = source.levels;\n\n\t\tfor ( let i = 0, l = levels.length; i < l; i ++ ) {\n\n\t\t\tconst level = levels[ i ];\n\n\t\t\tthis.addLevel( level.object.clone(), level.distance, level.hysteresis );\n\n\t\t}\n\n\t\tthis.autoUpdate = source.autoUpdate;\n\n\t\treturn this;\n\n\t}\n\n\taddLevel( object, distance = 0, hysteresis = 0 ) {\n\n\t\tdistance = Math.abs( distance );\n\n\t\tconst levels = this.levels;\n\n\t\tlet l;\n\n\t\tfor ( l = 0; l < levels.length; l ++ ) {\n\n\t\t\tif ( distance < levels[ l ].distance ) {\n\n\t\t\t\tbreak;\n\n\t\t\t}\n\n\t\t}\n\n\t\tlevels.splice( l, 0, { distance: distance, hysteresis: hysteresis, object: object } );\n\n\t\tthis.add( object );\n\n\t\treturn this;\n\n\t}\n\n\tgetCurrentLevel() {\n\n\t\treturn this._currentLevel;\n\n\t}\n\n\n\n\tgetObjectForDistance( distance ) {\n\n\t\tconst levels = this.levels;\n\n\t\tif ( levels.length > 0 ) {\n\n\t\t\tlet i, l;\n\n\t\t\tfor ( i = 1, l = levels.length; i < l; i ++ ) {\n\n\t\t\t\tlet levelDistance = levels[ i ].distance;\n\n\t\t\t\tif ( levels[ i ].object.visible ) {\n\n\t\t\t\t\tlevelDistance -= levelDistance * levels[ i ].hysteresis;\n\n\t\t\t\t}\n\n\t\t\t\tif ( distance < levelDistance ) {\n\n\t\t\t\t\tbreak;\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\treturn levels[ i - 1 ].object;\n\n\t\t}\n\n\t\treturn null;\n\n\t}\n\n\traycast( raycaster, intersects ) {\n\n\t\tconst levels = this.levels;\n\n\t\tif ( levels.length > 0 ) {\n\n\t\t\t_v1$2.setFromMatrixPosition( this.matrixWorld );\n\n\t\t\tconst distance = raycaster.ray.origin.distanceTo( _v1$2 );\n\n\t\t\tthis.getObjectForDistance( distance ).raycast( raycaster, intersects );\n\n\t\t}\n\n\t}\n\n\tupdate( camera ) {\n\n\t\tconst levels = this.levels;\n\n\t\tif ( levels.length > 1 ) {\n\n\t\t\t_v1$2.setFromMatrixPosition( camera.matrixWorld );\n\t\t\t_v2$1.setFromMatrixPosition( this.matrixWorld );\n\n\t\t\tconst distance = _v1$2.distanceTo( _v2$1 ) / camera.zoom;\n\n\t\t\tlevels[ 0 ].object.visible = true;\n\n\t\t\tlet i, l;\n\n\t\t\tfor ( i = 1, l = levels.length; i < l; i ++ ) {\n\n\t\t\t\tlet levelDistance = levels[ i ].distance;\n\n\t\t\t\tif ( levels[ i ].object.visible ) {\n\n\t\t\t\t\tlevelDistance -= levelDistance * levels[ i ].hysteresis;\n\n\t\t\t\t}\n\n\t\t\t\tif ( distance >= levelDistance ) {\n\n\t\t\t\t\tlevels[ i - 1 ].object.visible = false;\n\t\t\t\t\tlevels[ i ].object.visible = true;\n\n\t\t\t\t} else {\n\n\t\t\t\t\tbreak;\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tthis._currentLevel = i - 1;\n\n\t\t\tfor ( ; i < l; i ++ ) {\n\n\t\t\t\tlevels[ i ].object.visible = false;\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n\ttoJSON( meta ) {\n\n\t\tconst data = super.toJSON( meta );\n\n\t\tif ( this.autoUpdate === false ) data.object.autoUpdate = false;\n\n\t\tdata.object.levels = [];\n\n\t\tconst levels = this.levels;\n\n\t\tfor ( let i = 0, l = levels.length; i < l; i ++ ) {\n\n\t\t\tconst level = levels[ i ];\n\n\t\t\tdata.object.levels.push( {\n\t\t\t\tobject: level.object.uuid,\n\t\t\t\tdistance: level.distance,\n\t\t\t\thysteresis: level.hysteresis\n\t\t\t} );\n\n\t\t}\n\n\t\treturn data;\n\n\t}\n\n}\n\nconst _basePosition = /*@__PURE__*/ new Vector3();\n\nconst _skinIndex = /*@__PURE__*/ new Vector4();\nconst _skinWeight = /*@__PURE__*/ new Vector4();\n\nconst _vector3 = /*@__PURE__*/ new Vector3();\nconst _matrix4 = /*@__PURE__*/ new Matrix4();\nconst _vertex = /*@__PURE__*/ new Vector3();\n\nconst _sphere$4 = /*@__PURE__*/ new Sphere();\nconst _inverseMatrix$2 = /*@__PURE__*/ new Matrix4();\nconst _ray$2 = /*@__PURE__*/ new Ray();\n\nclass SkinnedMesh extends Mesh {\n\n\tconstructor( geometry, material ) {\n\n\t\tsuper( geometry, material );\n\n\t\tthis.isSkinnedMesh = true;\n\n\t\tthis.type = 'SkinnedMesh';\n\n\t\tthis.bindMode = AttachedBindMode;\n\t\tthis.bindMatrix = new Matrix4();\n\t\tthis.bindMatrixInverse = new Matrix4();\n\n\t\tthis.boundingBox = null;\n\t\tthis.boundingSphere = null;\n\n\t}\n\n\tcomputeBoundingBox() {\n\n\t\tconst geometry = this.geometry;\n\n\t\tif ( this.boundingBox === null ) {\n\n\t\t\tthis.boundingBox = new Box3();\n\n\t\t}\n\n\t\tthis.boundingBox.makeEmpty();\n\n\t\tconst positionAttribute = geometry.getAttribute( 'position' );\n\n\t\tfor ( let i = 0; i < positionAttribute.count; i ++ ) {\n\n\t\t\tthis.getVertexPosition( i, _vertex );\n\t\t\tthis.boundingBox.expandByPoint( _vertex );\n\n\t\t}\n\n\t}\n\n\tcomputeBoundingSphere() {\n\n\t\tconst geometry = this.geometry;\n\n\t\tif ( this.boundingSphere === null ) {\n\n\t\t\tthis.boundingSphere = new Sphere();\n\n\t\t}\n\n\t\tthis.boundingSphere.makeEmpty();\n\n\t\tconst positionAttribute = geometry.getAttribute( 'position' );\n\n\t\tfor ( let i = 0; i < positionAttribute.count; i ++ ) {\n\n\t\t\tthis.getVertexPosition( i, _vertex );\n\t\t\tthis.boundingSphere.expandByPoint( _vertex );\n\n\t\t}\n\n\t}\n\n\tcopy( source, recursive ) {\n\n\t\tsuper.copy( source, recursive );\n\n\t\tthis.bindMode = source.bindMode;\n\t\tthis.bindMatrix.copy( source.bindMatrix );\n\t\tthis.bindMatrixInverse.copy( source.bindMatrixInverse );\n\n\t\tthis.skeleton = source.skeleton;\n\n\t\tif ( source.boundingBox !== null ) this.boundingBox = source.boundingBox.clone();\n\t\tif ( source.boundingSphere !== null ) this.boundingSphere = source.boundingSphere.clone();\n\n\t\treturn this;\n\n\t}\n\n\traycast( raycaster, intersects ) {\n\n\t\tconst material = this.material;\n\t\tconst matrixWorld = this.matrixWorld;\n\n\t\tif ( material === undefined ) return;\n\n\t\t// test with bounding sphere in world space\n\n\t\tif ( this.boundingSphere === null ) this.computeBoundingSphere();\n\n\t\t_sphere$4.copy( this.boundingSphere );\n\t\t_sphere$4.applyMatrix4( matrixWorld );\n\n\t\tif ( raycaster.ray.intersectsSphere( _sphere$4 ) === false ) return;\n\n\t\t// convert ray to local space of skinned mesh\n\n\t\t_inverseMatrix$2.copy( matrixWorld ).invert();\n\t\t_ray$2.copy( raycaster.ray ).applyMatrix4( _inverseMatrix$2 );\n\n\t\t// test with bounding box in local space\n\n\t\tif ( this.boundingBox !== null ) {\n\n\t\t\tif ( _ray$2.intersectsBox( this.boundingBox ) === false ) return;\n\n\t\t}\n\n\t\t// test for intersections with geometry\n\n\t\tthis._computeIntersections( raycaster, intersects, _ray$2 );\n\n\t}\n\n\tgetVertexPosition( index, target ) {\n\n\t\tsuper.getVertexPosition( index, target );\n\n\t\tthis.applyBoneTransform( index, target );\n\n\t\treturn target;\n\n\t}\n\n\tbind( skeleton, bindMatrix ) {\n\n\t\tthis.skeleton = skeleton;\n\n\t\tif ( bindMatrix === undefined ) {\n\n\t\t\tthis.updateMatrixWorld( true );\n\n\t\t\tthis.skeleton.calculateInverses();\n\n\t\t\tbindMatrix = this.matrixWorld;\n\n\t\t}\n\n\t\tthis.bindMatrix.copy( bindMatrix );\n\t\tthis.bindMatrixInverse.copy( bindMatrix ).invert();\n\n\t}\n\n\tpose() {\n\n\t\tthis.skeleton.pose();\n\n\t}\n\n\tnormalizeSkinWeights() {\n\n\t\tconst vector = new Vector4();\n\n\t\tconst skinWeight = this.geometry.attributes.skinWeight;\n\n\t\tfor ( let i = 0, l = skinWeight.count; i < l; i ++ ) {\n\n\t\t\tvector.fromBufferAttribute( skinWeight, i );\n\n\t\t\tconst scale = 1.0 / vector.manhattanLength();\n\n\t\t\tif ( scale !== Infinity ) {\n\n\t\t\t\tvector.multiplyScalar( scale );\n\n\t\t\t} else {\n\n\t\t\t\tvector.set( 1, 0, 0, 0 ); // do something reasonable\n\n\t\t\t}\n\n\t\t\tskinWeight.setXYZW( i, vector.x, vector.y, vector.z, vector.w );\n\n\t\t}\n\n\t}\n\n\tupdateMatrixWorld( force ) {\n\n\t\tsuper.updateMatrixWorld( force );\n\n\t\tif ( this.bindMode === AttachedBindMode ) {\n\n\t\t\tthis.bindMatrixInverse.copy( this.matrixWorld ).invert();\n\n\t\t} else if ( this.bindMode === DetachedBindMode ) {\n\n\t\t\tthis.bindMatrixInverse.copy( this.bindMatrix ).invert();\n\n\t\t} else {\n\n\t\t\tconsole.warn( 'THREE.SkinnedMesh: Unrecognized bindMode: ' + this.bindMode );\n\n\t\t}\n\n\t}\n\n\tapplyBoneTransform( index, vector ) {\n\n\t\tconst skeleton = this.skeleton;\n\t\tconst geometry = this.geometry;\n\n\t\t_skinIndex.fromBufferAttribute( geometry.attributes.skinIndex, index );\n\t\t_skinWeight.fromBufferAttribute( geometry.attributes.skinWeight, index );\n\n\t\t_basePosition.copy( vector ).applyMatrix4( this.bindMatrix );\n\n\t\tvector.set( 0, 0, 0 );\n\n\t\tfor ( let i = 0; i < 4; i ++ ) {\n\n\t\t\tconst weight = _skinWeight.getComponent( i );\n\n\t\t\tif ( weight !== 0 ) {\n\n\t\t\t\tconst boneIndex = _skinIndex.getComponent( i );\n\n\t\t\t\t_matrix4.multiplyMatrices( skeleton.bones[ boneIndex ].matrixWorld, skeleton.boneInverses[ boneIndex ] );\n\n\t\t\t\tvector.addScaledVector( _vector3.copy( _basePosition ).applyMatrix4( _matrix4 ), weight );\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn vector.applyMatrix4( this.bindMatrixInverse );\n\n\t}\n\n}\n\nclass Bone extends Object3D {\n\n\tconstructor() {\n\n\t\tsuper();\n\n\t\tthis.isBone = true;\n\n\t\tthis.type = 'Bone';\n\n\t}\n\n}\n\nclass DataTexture extends Texture {\n\n\tconstructor( data = null, width = 1, height = 1, format, type, mapping, wrapS, wrapT, magFilter = NearestFilter, minFilter = NearestFilter, anisotropy, colorSpace ) {\n\n\t\tsuper( null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, colorSpace );\n\n\t\tthis.isDataTexture = true;\n\n\t\tthis.image = { data: data, width: width, height: height };\n\n\t\tthis.generateMipmaps = false;\n\t\tthis.flipY = false;\n\t\tthis.unpackAlignment = 1;\n\n\t}\n\n}\n\nconst _offsetMatrix = /*@__PURE__*/ new Matrix4();\nconst _identityMatrix$1 = /*@__PURE__*/ new Matrix4();\n\nclass Skeleton {\n\n\tconstructor( bones = [], boneInverses = [] ) {\n\n\t\tthis.uuid = generateUUID();\n\n\t\tthis.bones = bones.slice( 0 );\n\t\tthis.boneInverses = boneInverses;\n\t\tthis.boneMatrices = null;\n\n\t\tthis.boneTexture = null;\n\n\t\tthis.init();\n\n\t}\n\n\tinit() {\n\n\t\tconst bones = this.bones;\n\t\tconst boneInverses = this.boneInverses;\n\n\t\tthis.boneMatrices = new Float32Array( bones.length * 16 );\n\n\t\t// calculate inverse bone matrices if necessary\n\n\t\tif ( boneInverses.length === 0 ) {\n\n\t\t\tthis.calculateInverses();\n\n\t\t} else {\n\n\t\t\t// handle special case\n\n\t\t\tif ( bones.length !== boneInverses.length ) {\n\n\t\t\t\tconsole.warn( 'THREE.Skeleton: Number of inverse bone matrices does not match amount of bones.' );\n\n\t\t\t\tthis.boneInverses = [];\n\n\t\t\t\tfor ( let i = 0, il = this.bones.length; i < il; i ++ ) {\n\n\t\t\t\t\tthis.boneInverses.push( new Matrix4() );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n\tcalculateInverses() {\n\n\t\tthis.boneInverses.length = 0;\n\n\t\tfor ( let i = 0, il = this.bones.length; i < il; i ++ ) {\n\n\t\t\tconst inverse = new Matrix4();\n\n\t\t\tif ( this.bones[ i ] ) {\n\n\t\t\t\tinverse.copy( this.bones[ i ].matrixWorld ).invert();\n\n\t\t\t}\n\n\t\t\tthis.boneInverses.push( inverse );\n\n\t\t}\n\n\t}\n\n\tpose() {\n\n\t\t// recover the bind-time world matrices\n\n\t\tfor ( let i = 0, il = this.bones.length; i < il; i ++ ) {\n\n\t\t\tconst bone = this.bones[ i ];\n\n\t\t\tif ( bone ) {\n\n\t\t\t\tbone.matrixWorld.copy( this.boneInverses[ i ] ).invert();\n\n\t\t\t}\n\n\t\t}\n\n\t\t// compute the local matrices, positions, rotations and scales\n\n\t\tfor ( let i = 0, il = this.bones.length; i < il; i ++ ) {\n\n\t\t\tconst bone = this.bones[ i ];\n\n\t\t\tif ( bone ) {\n\n\t\t\t\tif ( bone.parent && bone.parent.isBone ) {\n\n\t\t\t\t\tbone.matrix.copy( bone.parent.matrixWorld ).invert();\n\t\t\t\t\tbone.matrix.multiply( bone.matrixWorld );\n\n\t\t\t\t} else {\n\n\t\t\t\t\tbone.matrix.copy( bone.matrixWorld );\n\n\t\t\t\t}\n\n\t\t\t\tbone.matrix.decompose( bone.position, bone.quaternion, bone.scale );\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n\tupdate() {\n\n\t\tconst bones = this.bones;\n\t\tconst boneInverses = this.boneInverses;\n\t\tconst boneMatrices = this.boneMatrices;\n\t\tconst boneTexture = this.boneTexture;\n\n\t\t// flatten bone matrices to array\n\n\t\tfor ( let i = 0, il = bones.length; i < il; i ++ ) {\n\n\t\t\t// compute the offset between the current and the original transform\n\n\t\t\tconst matrix = bones[ i ] ? bones[ i ].matrixWorld : _identityMatrix$1;\n\n\t\t\t_offsetMatrix.multiplyMatrices( matrix, boneInverses[ i ] );\n\t\t\t_offsetMatrix.toArray( boneMatrices, i * 16 );\n\n\t\t}\n\n\t\tif ( boneTexture !== null ) {\n\n\t\t\tboneTexture.needsUpdate = true;\n\n\t\t}\n\n\t}\n\n\tclone() {\n\n\t\treturn new Skeleton( this.bones, this.boneInverses );\n\n\t}\n\n\tcomputeBoneTexture() {\n\n\t\t// layout (1 matrix = 4 pixels)\n\t\t// RGBA RGBA RGBA RGBA (=> column1, column2, column3, column4)\n\t\t// with 8x8 pixel texture max 16 bones * 4 pixels = (8 * 8)\n\t\t// 16x16 pixel texture max 64 bones * 4 pixels = (16 * 16)\n\t\t// 32x32 pixel texture max 256 bones * 4 pixels = (32 * 32)\n\t\t// 64x64 pixel texture max 1024 bones * 4 pixels = (64 * 64)\n\n\t\tlet size = Math.sqrt( this.bones.length * 4 ); // 4 pixels needed for 1 matrix\n\t\tsize = Math.ceil( size / 4 ) * 4;\n\t\tsize = Math.max( size, 4 );\n\n\t\tconst boneMatrices = new Float32Array( size * size * 4 ); // 4 floats per RGBA pixel\n\t\tboneMatrices.set( this.boneMatrices ); // copy current values\n\n\t\tconst boneTexture = new DataTexture( boneMatrices, size, size, RGBAFormat, FloatType );\n\t\tboneTexture.needsUpdate = true;\n\n\t\tthis.boneMatrices = boneMatrices;\n\t\tthis.boneTexture = boneTexture;\n\n\t\treturn this;\n\n\t}\n\n\tgetBoneByName( name ) {\n\n\t\tfor ( let i = 0, il = this.bones.length; i < il; i ++ ) {\n\n\t\t\tconst bone = this.bones[ i ];\n\n\t\t\tif ( bone.name === name ) {\n\n\t\t\t\treturn bone;\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn undefined;\n\n\t}\n\n\tdispose( ) {\n\n\t\tif ( this.boneTexture !== null ) {\n\n\t\t\tthis.boneTexture.dispose();\n\n\t\t\tthis.boneTexture = null;\n\n\t\t}\n\n\t}\n\n\tfromJSON( json, bones ) {\n\n\t\tthis.uuid = json.uuid;\n\n\t\tfor ( let i = 0, l = json.bones.length; i < l; i ++ ) {\n\n\t\t\tconst uuid = json.bones[ i ];\n\t\t\tlet bone = bones[ uuid ];\n\n\t\t\tif ( bone === undefined ) {\n\n\t\t\t\tconsole.warn( 'THREE.Skeleton: No bone found with UUID:', uuid );\n\t\t\t\tbone = new Bone();\n\n\t\t\t}\n\n\t\t\tthis.bones.push( bone );\n\t\t\tthis.boneInverses.push( new Matrix4().fromArray( json.boneInverses[ i ] ) );\n\n\t\t}\n\n\t\tthis.init();\n\n\t\treturn this;\n\n\t}\n\n\ttoJSON() {\n\n\t\tconst data = {\n\t\t\tmetadata: {\n\t\t\t\tversion: 4.6,\n\t\t\t\ttype: 'Skeleton',\n\t\t\t\tgenerator: 'Skeleton.toJSON'\n\t\t\t},\n\t\t\tbones: [],\n\t\t\tboneInverses: []\n\t\t};\n\n\t\tdata.uuid = this.uuid;\n\n\t\tconst bones = this.bones;\n\t\tconst boneInverses = this.boneInverses;\n\n\t\tfor ( let i = 0, l = bones.length; i < l; i ++ ) {\n\n\t\t\tconst bone = bones[ i ];\n\t\t\tdata.bones.push( bone.uuid );\n\n\t\t\tconst boneInverse = boneInverses[ i ];\n\t\t\tdata.boneInverses.push( boneInverse.toArray() );\n\n\t\t}\n\n\t\treturn data;\n\n\t}\n\n}\n\nclass InstancedBufferAttribute extends BufferAttribute {\n\n\tconstructor( array, itemSize, normalized, meshPerAttribute = 1 ) {\n\n\t\tsuper( array, itemSize, normalized );\n\n\t\tthis.isInstancedBufferAttribute = true;\n\n\t\tthis.meshPerAttribute = meshPerAttribute;\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.meshPerAttribute = source.meshPerAttribute;\n\n\t\treturn this;\n\n\t}\n\n\ttoJSON() {\n\n\t\tconst data = super.toJSON();\n\n\t\tdata.meshPerAttribute = this.meshPerAttribute;\n\n\t\tdata.isInstancedBufferAttribute = true;\n\n\t\treturn data;\n\n\t}\n\n}\n\nconst _instanceLocalMatrix = /*@__PURE__*/ new Matrix4();\nconst _instanceWorldMatrix = /*@__PURE__*/ new Matrix4();\n\nconst _instanceIntersects = [];\n\nconst _box3 = /*@__PURE__*/ new Box3();\nconst _identity = /*@__PURE__*/ new Matrix4();\nconst _mesh$1 = /*@__PURE__*/ new Mesh();\nconst _sphere$3 = /*@__PURE__*/ new Sphere();\n\nclass InstancedMesh extends Mesh {\n\n\tconstructor( geometry, material, count ) {\n\n\t\tsuper( geometry, material );\n\n\t\tthis.isInstancedMesh = true;\n\n\t\tthis.instanceMatrix = new InstancedBufferAttribute( new Float32Array( count * 16 ), 16 );\n\t\tthis.instanceColor = null;\n\t\tthis.morphTexture = null;\n\n\t\tthis.count = count;\n\n\t\tthis.boundingBox = null;\n\t\tthis.boundingSphere = null;\n\n\t\tfor ( let i = 0; i < count; i ++ ) {\n\n\t\t\tthis.setMatrixAt( i, _identity );\n\n\t\t}\n\n\t}\n\n\tcomputeBoundingBox() {\n\n\t\tconst geometry = this.geometry;\n\t\tconst count = this.count;\n\n\t\tif ( this.boundingBox === null ) {\n\n\t\t\tthis.boundingBox = new Box3();\n\n\t\t}\n\n\t\tif ( geometry.boundingBox === null ) {\n\n\t\t\tgeometry.computeBoundingBox();\n\n\t\t}\n\n\t\tthis.boundingBox.makeEmpty();\n\n\t\tfor ( let i = 0; i < count; i ++ ) {\n\n\t\t\tthis.getMatrixAt( i, _instanceLocalMatrix );\n\n\t\t\t_box3.copy( geometry.boundingBox ).applyMatrix4( _instanceLocalMatrix );\n\n\t\t\tthis.boundingBox.union( _box3 );\n\n\t\t}\n\n\t}\n\n\tcomputeBoundingSphere() {\n\n\t\tconst geometry = this.geometry;\n\t\tconst count = this.count;\n\n\t\tif ( this.boundingSphere === null ) {\n\n\t\t\tthis.boundingSphere = new Sphere();\n\n\t\t}\n\n\t\tif ( geometry.boundingSphere === null ) {\n\n\t\t\tgeometry.computeBoundingSphere();\n\n\t\t}\n\n\t\tthis.boundingSphere.makeEmpty();\n\n\t\tfor ( let i = 0; i < count; i ++ ) {\n\n\t\t\tthis.getMatrixAt( i, _instanceLocalMatrix );\n\n\t\t\t_sphere$3.copy( geometry.boundingSphere ).applyMatrix4( _instanceLocalMatrix );\n\n\t\t\tthis.boundingSphere.union( _sphere$3 );\n\n\t\t}\n\n\t}\n\n\tcopy( source, recursive ) {\n\n\t\tsuper.copy( source, recursive );\n\n\t\tthis.instanceMatrix.copy( source.instanceMatrix );\n\n\t\tif ( source.morphTexture !== null ) this.morphTexture = source.morphTexture.clone();\n\t\tif ( source.instanceColor !== null ) this.instanceColor = source.instanceColor.clone();\n\n\t\tthis.count = source.count;\n\n\t\tif ( source.boundingBox !== null ) this.boundingBox = source.boundingBox.clone();\n\t\tif ( source.boundingSphere !== null ) this.boundingSphere = source.boundingSphere.clone();\n\n\t\treturn this;\n\n\t}\n\n\tgetColorAt( index, color ) {\n\n\t\tcolor.fromArray( this.instanceColor.array, index * 3 );\n\n\t}\n\n\tgetMatrixAt( index, matrix ) {\n\n\t\tmatrix.fromArray( this.instanceMatrix.array, index * 16 );\n\n\t}\n\n\tgetMorphAt( index, object ) {\n\n\t\tconst objectInfluences = object.morphTargetInfluences;\n\n\t\tconst array = this.morphTexture.source.data.data;\n\n\t\tconst len = objectInfluences.length + 1; // All influences + the baseInfluenceSum\n\n\t\tconst dataIndex = index * len + 1; // Skip the baseInfluenceSum at the beginning\n\n\t\tfor ( let i = 0; i < objectInfluences.length; i ++ ) {\n\n\t\t\tobjectInfluences[ i ] = array[ dataIndex + i ];\n\n\t\t}\n\n\t}\n\n\traycast( raycaster, intersects ) {\n\n\t\tconst matrixWorld = this.matrixWorld;\n\t\tconst raycastTimes = this.count;\n\n\t\t_mesh$1.geometry = this.geometry;\n\t\t_mesh$1.material = this.material;\n\n\t\tif ( _mesh$1.material === undefined ) return;\n\n\t\t// test with bounding sphere first\n\n\t\tif ( this.boundingSphere === null ) this.computeBoundingSphere();\n\n\t\t_sphere$3.copy( this.boundingSphere );\n\t\t_sphere$3.applyMatrix4( matrixWorld );\n\n\t\tif ( raycaster.ray.intersectsSphere( _sphere$3 ) === false ) return;\n\n\t\t// now test each instance\n\n\t\tfor ( let instanceId = 0; instanceId < raycastTimes; instanceId ++ ) {\n\n\t\t\t// calculate the world matrix for each instance\n\n\t\t\tthis.getMatrixAt( instanceId, _instanceLocalMatrix );\n\n\t\t\t_instanceWorldMatrix.multiplyMatrices( matrixWorld, _instanceLocalMatrix );\n\n\t\t\t// the mesh represents this single instance\n\n\t\t\t_mesh$1.matrixWorld = _instanceWorldMatrix;\n\n\t\t\t_mesh$1.raycast( raycaster, _instanceIntersects );\n\n\t\t\t// process the result of raycast\n\n\t\t\tfor ( let i = 0, l = _instanceIntersects.length; i < l; i ++ ) {\n\n\t\t\t\tconst intersect = _instanceIntersects[ i ];\n\t\t\t\tintersect.instanceId = instanceId;\n\t\t\t\tintersect.object = this;\n\t\t\t\tintersects.push( intersect );\n\n\t\t\t}\n\n\t\t\t_instanceIntersects.length = 0;\n\n\t\t}\n\n\t}\n\n\tsetColorAt( index, color ) {\n\n\t\tif ( this.instanceColor === null ) {\n\n\t\t\tthis.instanceColor = new InstancedBufferAttribute( new Float32Array( this.instanceMatrix.count * 3 ), 3 );\n\n\t\t}\n\n\t\tcolor.toArray( this.instanceColor.array, index * 3 );\n\n\t}\n\n\tsetMatrixAt( index, matrix ) {\n\n\t\tmatrix.toArray( this.instanceMatrix.array, index * 16 );\n\n\t}\n\n\tsetMorphAt( index, object ) {\n\n\t\tconst objectInfluences = object.morphTargetInfluences;\n\n\t\tconst len = objectInfluences.length + 1; // morphBaseInfluence + all influences\n\n\t\tif ( this.morphTexture === null ) {\n\n\t\t\tthis.morphTexture = new DataTexture( new Float32Array( len * this.count ), len, this.count, RedFormat, FloatType );\n\n\t\t}\n\n\t\tconst array = this.morphTexture.source.data.data;\n\n\t\tlet morphInfluencesSum = 0;\n\n\t\tfor ( let i = 0; i < objectInfluences.length; i ++ ) {\n\n\t\t\tmorphInfluencesSum += objectInfluences[ i ];\n\n\t\t}\n\n\t\tconst morphBaseInfluence = this.geometry.morphTargetsRelative ? 1 : 1 - morphInfluencesSum;\n\n\t\tconst dataIndex = len * index;\n\n\t\tarray[ dataIndex ] = morphBaseInfluence;\n\n\t\tarray.set( objectInfluences, dataIndex + 1 );\n\n\t}\n\n\tupdateMorphTargets() {\n\n\t}\n\n\tdispose() {\n\n\t\tthis.dispatchEvent( { type: 'dispose' } );\n\n\t\tif ( this.morphTexture !== null ) {\n\n\t\t\tthis.morphTexture.dispose();\n\t\t\tthis.morphTexture = null;\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n}\n\nfunction sortOpaque( a, b ) {\n\n\treturn a.z - b.z;\n\n}\n\nfunction sortTransparent( a, b ) {\n\n\treturn b.z - a.z;\n\n}\n\nclass MultiDrawRenderList {\n\n\tconstructor() {\n\n\t\tthis.index = 0;\n\t\tthis.pool = [];\n\t\tthis.list = [];\n\n\t}\n\n\tpush( drawRange, z ) {\n\n\t\tconst pool = this.pool;\n\t\tconst list = this.list;\n\t\tif ( this.index >= pool.length ) {\n\n\t\t\tpool.push( {\n\n\t\t\t\tstart: - 1,\n\t\t\t\tcount: - 1,\n\t\t\t\tz: - 1,\n\n\t\t\t} );\n\n\t\t}\n\n\t\tconst item = pool[ this.index ];\n\t\tlist.push( item );\n\t\tthis.index ++;\n\n\t\titem.start = drawRange.start;\n\t\titem.count = drawRange.count;\n\t\titem.z = z;\n\n\t}\n\n\treset() {\n\n\t\tthis.list.length = 0;\n\t\tthis.index = 0;\n\n\t}\n\n}\n\nconst ID_ATTR_NAME = 'batchId';\nconst _matrix$1 = /*@__PURE__*/ new Matrix4();\nconst _invMatrixWorld = /*@__PURE__*/ new Matrix4();\nconst _identityMatrix = /*@__PURE__*/ new Matrix4();\nconst _projScreenMatrix$2 = /*@__PURE__*/ new Matrix4();\nconst _frustum = /*@__PURE__*/ new Frustum();\nconst _box$1 = /*@__PURE__*/ new Box3();\nconst _sphere$2 = /*@__PURE__*/ new Sphere();\nconst _vector$5 = /*@__PURE__*/ new Vector3();\nconst _renderList = /*@__PURE__*/ new MultiDrawRenderList();\nconst _mesh = /*@__PURE__*/ new Mesh();\nconst _batchIntersects = [];\n\n// @TODO: SkinnedMesh support?\n// @TODO: geometry.groups support?\n// @TODO: geometry.drawRange support?\n// @TODO: geometry.morphAttributes support?\n// @TODO: Support uniform parameter per geometry\n// @TODO: Add an \"optimize\" function to pack geometry and remove data gaps\n\n// copies data from attribute \"src\" into \"target\" starting at \"targetOffset\"\nfunction copyAttributeData( src, target, targetOffset = 0 ) {\n\n\tconst itemSize = target.itemSize;\n\tif ( src.isInterleavedBufferAttribute || src.array.constructor !== target.array.constructor ) {\n\n\t\t// use the component getters and setters if the array data cannot\n\t\t// be copied directly\n\t\tconst vertexCount = src.count;\n\t\tfor ( let i = 0; i < vertexCount; i ++ ) {\n\n\t\t\tfor ( let c = 0; c < itemSize; c ++ ) {\n\n\t\t\t\ttarget.setComponent( i + targetOffset, c, src.getComponent( i, c ) );\n\n\t\t\t}\n\n\t\t}\n\n\t} else {\n\n\t\t// faster copy approach using typed array set function\n\t\ttarget.array.set( src.array, targetOffset * itemSize );\n\n\t}\n\n\ttarget.needsUpdate = true;\n\n}\n\nclass BatchedMesh extends Mesh {\n\n\tget maxGeometryCount() {\n\n\t\treturn this._maxGeometryCount;\n\n\t}\n\n\tconstructor( maxGeometryCount, maxVertexCount, maxIndexCount = maxVertexCount * 2, material ) {\n\n\t\tsuper( new BufferGeometry(), material );\n\n\t\tthis.isBatchedMesh = true;\n\t\tthis.perObjectFrustumCulled = true;\n\t\tthis.sortObjects = true;\n\t\tthis.boundingBox = null;\n\t\tthis.boundingSphere = null;\n\t\tthis.customSort = null;\n\n\t\tthis._drawRanges = [];\n\t\tthis._reservedRanges = [];\n\n\t\tthis._visibility = [];\n\t\tthis._active = [];\n\t\tthis._bounds = [];\n\n\t\tthis._maxGeometryCount = maxGeometryCount;\n\t\tthis._maxVertexCount = maxVertexCount;\n\t\tthis._maxIndexCount = maxIndexCount;\n\n\t\tthis._geometryInitialized = false;\n\t\tthis._geometryCount = 0;\n\t\tthis._multiDrawCounts = new Int32Array( maxGeometryCount );\n\t\tthis._multiDrawStarts = new Int32Array( maxGeometryCount );\n\t\tthis._multiDrawCount = 0;\n\t\tthis._visibilityChanged = true;\n\n\t\t// Local matrix per geometry by using data texture\n\t\tthis._matricesTexture = null;\n\n\t\tthis._initMatricesTexture();\n\n\t}\n\n\t_initMatricesTexture() {\n\n\t\t// layout (1 matrix = 4 pixels)\n\t\t// RGBA RGBA RGBA RGBA (=> column1, column2, column3, column4)\n\t\t// with 8x8 pixel texture max 16 matrices * 4 pixels = (8 * 8)\n\t\t// 16x16 pixel texture max 64 matrices * 4 pixels = (16 * 16)\n\t\t// 32x32 pixel texture max 256 matrices * 4 pixels = (32 * 32)\n\t\t// 64x64 pixel texture max 1024 matrices * 4 pixels = (64 * 64)\n\n\t\tlet size = Math.sqrt( this._maxGeometryCount * 4 ); // 4 pixels needed for 1 matrix\n\t\tsize = Math.ceil( size / 4 ) * 4;\n\t\tsize = Math.max( size, 4 );\n\n\t\tconst matricesArray = new Float32Array( size * size * 4 ); // 4 floats per RGBA pixel\n\t\tconst matricesTexture = new DataTexture( matricesArray, size, size, RGBAFormat, FloatType );\n\n\t\tthis._matricesTexture = matricesTexture;\n\n\t}\n\n\t_initializeGeometry( reference ) {\n\n\t\tconst geometry = this.geometry;\n\t\tconst maxVertexCount = this._maxVertexCount;\n\t\tconst maxGeometryCount = this._maxGeometryCount;\n\t\tconst maxIndexCount = this._maxIndexCount;\n\t\tif ( this._geometryInitialized === false ) {\n\n\t\t\tfor ( const attributeName in reference.attributes ) {\n\n\t\t\t\tconst srcAttribute = reference.getAttribute( attributeName );\n\t\t\t\tconst { array, itemSize, normalized } = srcAttribute;\n\n\t\t\t\tconst dstArray = new array.constructor( maxVertexCount * itemSize );\n\t\t\t\tconst dstAttribute = new BufferAttribute( dstArray, itemSize, normalized );\n\n\t\t\t\tgeometry.setAttribute( attributeName, dstAttribute );\n\n\t\t\t}\n\n\t\t\tif ( reference.getIndex() !== null ) {\n\n\t\t\t\tconst indexArray = maxVertexCount > 65536\n\t\t\t\t\t? new Uint32Array( maxIndexCount )\n\t\t\t\t\t: new Uint16Array( maxIndexCount );\n\n\t\t\t\tgeometry.setIndex( new BufferAttribute( indexArray, 1 ) );\n\n\t\t\t}\n\n\t\t\tconst idArray = maxGeometryCount > 65536\n\t\t\t\t? new Uint32Array( maxVertexCount )\n\t\t\t\t: new Uint16Array( maxVertexCount );\n\t\t\tgeometry.setAttribute( ID_ATTR_NAME, new BufferAttribute( idArray, 1 ) );\n\n\t\t\tthis._geometryInitialized = true;\n\n\t\t}\n\n\t}\n\n\t// Make sure the geometry is compatible with the existing combined geometry attributes\n\t_validateGeometry( geometry ) {\n\n\t\t// check that the geometry doesn't have a version of our reserved id attribute\n\t\tif ( geometry.getAttribute( ID_ATTR_NAME ) ) {\n\n\t\t\tthrow new Error( `BatchedMesh: Geometry cannot use attribute \"${ ID_ATTR_NAME }\"` );\n\n\t\t}\n\n\t\t// check to ensure the geometries are using consistent attributes and indices\n\t\tconst batchGeometry = this.geometry;\n\t\tif ( Boolean( geometry.getIndex() ) !== Boolean( batchGeometry.getIndex() ) ) {\n\n\t\t\tthrow new Error( 'BatchedMesh: All geometries must consistently have \"index\".' );\n\n\t\t}\n\n\t\tfor ( const attributeName in batchGeometry.attributes ) {\n\n\t\t\tif ( attributeName === ID_ATTR_NAME ) {\n\n\t\t\t\tcontinue;\n\n\t\t\t}\n\n\t\t\tif ( ! geometry.hasAttribute( attributeName ) ) {\n\n\t\t\t\tthrow new Error( `BatchedMesh: Added geometry missing \"${ attributeName }\". All geometries must have consistent attributes.` );\n\n\t\t\t}\n\n\t\t\tconst srcAttribute = geometry.getAttribute( attributeName );\n\t\t\tconst dstAttribute = batchGeometry.getAttribute( attributeName );\n\t\t\tif ( srcAttribute.itemSize !== dstAttribute.itemSize || srcAttribute.normalized !== dstAttribute.normalized ) {\n\n\t\t\t\tthrow new Error( 'BatchedMesh: All attributes must have a consistent itemSize and normalized value.' );\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n\tsetCustomSort( func ) {\n\n\t\tthis.customSort = func;\n\t\treturn this;\n\n\t}\n\n\tcomputeBoundingBox() {\n\n\t\tif ( this.boundingBox === null ) {\n\n\t\t\tthis.boundingBox = new Box3();\n\n\t\t}\n\n\t\tconst geometryCount = this._geometryCount;\n\t\tconst boundingBox = this.boundingBox;\n\t\tconst active = this._active;\n\n\t\tboundingBox.makeEmpty();\n\t\tfor ( let i = 0; i < geometryCount; i ++ ) {\n\n\t\t\tif ( active[ i ] === false ) continue;\n\n\t\t\tthis.getMatrixAt( i, _matrix$1 );\n\t\t\tthis.getBoundingBoxAt( i, _box$1 ).applyMatrix4( _matrix$1 );\n\t\t\tboundingBox.union( _box$1 );\n\n\t\t}\n\n\t}\n\n\tcomputeBoundingSphere() {\n\n\t\tif ( this.boundingSphere === null ) {\n\n\t\t\tthis.boundingSphere = new Sphere();\n\n\t\t}\n\n\t\tconst geometryCount = this._geometryCount;\n\t\tconst boundingSphere = this.boundingSphere;\n\t\tconst active = this._active;\n\n\t\tboundingSphere.makeEmpty();\n\t\tfor ( let i = 0; i < geometryCount; i ++ ) {\n\n\t\t\tif ( active[ i ] === false ) continue;\n\n\t\t\tthis.getMatrixAt( i, _matrix$1 );\n\t\t\tthis.getBoundingSphereAt( i, _sphere$2 ).applyMatrix4( _matrix$1 );\n\t\t\tboundingSphere.union( _sphere$2 );\n\n\t\t}\n\n\t}\n\n\taddGeometry( geometry, vertexCount = - 1, indexCount = - 1 ) {\n\n\t\tthis._initializeGeometry( geometry );\n\n\t\tthis._validateGeometry( geometry );\n\n\t\t// ensure we're not over geometry\n\t\tif ( this._geometryCount >= this._maxGeometryCount ) {\n\n\t\t\tthrow new Error( 'BatchedMesh: Maximum geometry count reached.' );\n\n\t\t}\n\n\t\t// get the necessary range fo the geometry\n\t\tconst reservedRange = {\n\t\t\tvertexStart: - 1,\n\t\t\tvertexCount: - 1,\n\t\t\tindexStart: - 1,\n\t\t\tindexCount: - 1,\n\t\t};\n\n\t\tlet lastRange = null;\n\t\tconst reservedRanges = this._reservedRanges;\n\t\tconst drawRanges = this._drawRanges;\n\t\tconst bounds = this._bounds;\n\t\tif ( this._geometryCount !== 0 ) {\n\n\t\t\tlastRange = reservedRanges[ reservedRanges.length - 1 ];\n\n\t\t}\n\n\t\tif ( vertexCount === - 1 ) {\n\n\t\t\treservedRange.vertexCount = geometry.getAttribute( 'position' ).count;\n\n\t\t} else {\n\n\t\t\treservedRange.vertexCount = vertexCount;\n\n\t\t}\n\n\t\tif ( lastRange === null ) {\n\n\t\t\treservedRange.vertexStart = 0;\n\n\t\t} else {\n\n\t\t\treservedRange.vertexStart = lastRange.vertexStart + lastRange.vertexCount;\n\n\t\t}\n\n\t\tconst index = geometry.getIndex();\n\t\tconst hasIndex = index !== null;\n\t\tif ( hasIndex ) {\n\n\t\t\tif ( indexCount\t=== - 1 ) {\n\n\t\t\t\treservedRange.indexCount = index.count;\n\n\t\t\t} else {\n\n\t\t\t\treservedRange.indexCount = indexCount;\n\n\t\t\t}\n\n\t\t\tif ( lastRange === null ) {\n\n\t\t\t\treservedRange.indexStart = 0;\n\n\t\t\t} else {\n\n\t\t\t\treservedRange.indexStart = lastRange.indexStart + lastRange.indexCount;\n\n\t\t\t}\n\n\t\t}\n\n\t\tif (\n\t\t\treservedRange.indexStart !== - 1 &&\n\t\t\treservedRange.indexStart + reservedRange.indexCount > this._maxIndexCount ||\n\t\t\treservedRange.vertexStart + reservedRange.vertexCount > this._maxVertexCount\n\t\t) {\n\n\t\t\tthrow new Error( 'BatchedMesh: Reserved space request exceeds the maximum buffer size.' );\n\n\t\t}\n\n\t\tconst visibility = this._visibility;\n\t\tconst active = this._active;\n\t\tconst matricesTexture = this._matricesTexture;\n\t\tconst matricesArray = this._matricesTexture.image.data;\n\n\t\t// push new visibility states\n\t\tvisibility.push( true );\n\t\tactive.push( true );\n\n\t\t// update id\n\t\tconst geometryId = this._geometryCount;\n\t\tthis._geometryCount ++;\n\n\t\t// initialize matrix information\n\t\t_identityMatrix.toArray( matricesArray, geometryId * 16 );\n\t\tmatricesTexture.needsUpdate = true;\n\n\t\t// add the reserved range and draw range objects\n\t\treservedRanges.push( reservedRange );\n\t\tdrawRanges.push( {\n\t\t\tstart: hasIndex ? reservedRange.indexStart : reservedRange.vertexStart,\n\t\t\tcount: - 1\n\t\t} );\n\t\tbounds.push( {\n\t\t\tboxInitialized: false,\n\t\t\tbox: new Box3(),\n\n\t\t\tsphereInitialized: false,\n\t\t\tsphere: new Sphere()\n\t\t} );\n\n\t\t// set the id for the geometry\n\t\tconst idAttribute = this.geometry.getAttribute( ID_ATTR_NAME );\n\t\tfor ( let i = 0; i < reservedRange.vertexCount; i ++ ) {\n\n\t\t\tidAttribute.setX( reservedRange.vertexStart + i, geometryId );\n\n\t\t}\n\n\t\tidAttribute.needsUpdate = true;\n\n\t\t// update the geometry\n\t\tthis.setGeometryAt( geometryId, geometry );\n\n\t\treturn geometryId;\n\n\t}\n\n\tsetGeometryAt( id, geometry ) {\n\n\t\tif ( id >= this._geometryCount ) {\n\n\t\t\tthrow new Error( 'BatchedMesh: Maximum geometry count reached.' );\n\n\t\t}\n\n\t\tthis._validateGeometry( geometry );\n\n\t\tconst batchGeometry = this.geometry;\n\t\tconst hasIndex = batchGeometry.getIndex() !== null;\n\t\tconst dstIndex = batchGeometry.getIndex();\n\t\tconst srcIndex = geometry.getIndex();\n\t\tconst reservedRange = this._reservedRanges[ id ];\n\t\tif (\n\t\t\thasIndex &&\n\t\t\tsrcIndex.count > reservedRange.indexCount ||\n\t\t\tgeometry.attributes.position.count > reservedRange.vertexCount\n\t\t) {\n\n\t\t\tthrow new Error( 'BatchedMesh: Reserved space not large enough for provided geometry.' );\n\n\t\t}\n\n\t\t// copy geometry over\n\t\tconst vertexStart = reservedRange.vertexStart;\n\t\tconst vertexCount = reservedRange.vertexCount;\n\t\tfor ( const attributeName in batchGeometry.attributes ) {\n\n\t\t\tif ( attributeName === ID_ATTR_NAME ) {\n\n\t\t\t\tcontinue;\n\n\t\t\t}\n\n\t\t\t// copy attribute data\n\t\t\tconst srcAttribute = geometry.getAttribute( attributeName );\n\t\t\tconst dstAttribute = batchGeometry.getAttribute( attributeName );\n\t\t\tcopyAttributeData( srcAttribute, dstAttribute, vertexStart );\n\n\t\t\t// fill the rest in with zeroes\n\t\t\tconst itemSize = srcAttribute.itemSize;\n\t\t\tfor ( let i = srcAttribute.count, l = vertexCount; i < l; i ++ ) {\n\n\t\t\t\tconst index = vertexStart + i;\n\t\t\t\tfor ( let c = 0; c < itemSize; c ++ ) {\n\n\t\t\t\t\tdstAttribute.setComponent( index, c, 0 );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tdstAttribute.needsUpdate = true;\n\t\t\tdstAttribute.addUpdateRange( vertexStart * itemSize, vertexCount * itemSize );\n\n\t\t}\n\n\t\t// copy index\n\t\tif ( hasIndex ) {\n\n\t\t\tconst indexStart = reservedRange.indexStart;\n\n\t\t\t// copy index data over\n\t\t\tfor ( let i = 0; i < srcIndex.count; i ++ ) {\n\n\t\t\t\tdstIndex.setX( indexStart + i, vertexStart + srcIndex.getX( i ) );\n\n\t\t\t}\n\n\t\t\t// fill the rest in with zeroes\n\t\t\tfor ( let i = srcIndex.count, l = reservedRange.indexCount; i < l; i ++ ) {\n\n\t\t\t\tdstIndex.setX( indexStart + i, vertexStart );\n\n\t\t\t}\n\n\t\t\tdstIndex.needsUpdate = true;\n\t\t\tdstIndex.addUpdateRange( indexStart, reservedRange.indexCount );\n\n\t\t}\n\n\t\t// store the bounding boxes\n\t\tconst bound = this._bounds[ id ];\n\t\tif ( geometry.boundingBox !== null ) {\n\n\t\t\tbound.box.copy( geometry.boundingBox );\n\t\t\tbound.boxInitialized = true;\n\n\t\t} else {\n\n\t\t\tbound.boxInitialized = false;\n\n\t\t}\n\n\t\tif ( geometry.boundingSphere !== null ) {\n\n\t\t\tbound.sphere.copy( geometry.boundingSphere );\n\t\t\tbound.sphereInitialized = true;\n\n\t\t} else {\n\n\t\t\tbound.sphereInitialized = false;\n\n\t\t}\n\n\t\t// set drawRange count\n\t\tconst drawRange = this._drawRanges[ id ];\n\t\tconst posAttr = geometry.getAttribute( 'position' );\n\t\tdrawRange.count = hasIndex ? srcIndex.count : posAttr.count;\n\t\tthis._visibilityChanged = true;\n\n\t\treturn id;\n\n\t}\n\n\tdeleteGeometry( geometryId ) {\n\n\t\t// Note: User needs to call optimize() afterward to pack the data.\n\n\t\tconst active = this._active;\n\t\tif ( geometryId >= active.length || active[ geometryId ] === false ) {\n\n\t\t\treturn this;\n\n\t\t}\n\n\t\tactive[ geometryId ] = false;\n\t\tthis._visibilityChanged = true;\n\n\t\treturn this;\n\n\t}\n\n\t// get bounding box and compute it if it doesn't exist\n\tgetBoundingBoxAt( id, target ) {\n\n\t\tconst active = this._active;\n\t\tif ( active[ id ] === false ) {\n\n\t\t\treturn null;\n\n\t\t}\n\n\t\t// compute bounding box\n\t\tconst bound = this._bounds[ id ];\n\t\tconst box = bound.box;\n\t\tconst geometry = this.geometry;\n\t\tif ( bound.boxInitialized === false ) {\n\n\t\t\tbox.makeEmpty();\n\n\t\t\tconst index = geometry.index;\n\t\t\tconst position = geometry.attributes.position;\n\t\t\tconst drawRange = this._drawRanges[ id ];\n\t\t\tfor ( let i = drawRange.start, l = drawRange.start + drawRange.count; i < l; i ++ ) {\n\n\t\t\t\tlet iv = i;\n\t\t\t\tif ( index ) {\n\n\t\t\t\t\tiv = index.getX( iv );\n\n\t\t\t\t}\n\n\t\t\t\tbox.expandByPoint( _vector$5.fromBufferAttribute( position, iv ) );\n\n\t\t\t}\n\n\t\t\tbound.boxInitialized = true;\n\n\t\t}\n\n\t\ttarget.copy( box );\n\t\treturn target;\n\n\t}\n\n\t// get bounding sphere and compute it if it doesn't exist\n\tgetBoundingSphereAt( id, target ) {\n\n\t\tconst active = this._active;\n\t\tif ( active[ id ] === false ) {\n\n\t\t\treturn null;\n\n\t\t}\n\n\t\t// compute bounding sphere\n\t\tconst bound = this._bounds[ id ];\n\t\tconst sphere = bound.sphere;\n\t\tconst geometry = this.geometry;\n\t\tif ( bound.sphereInitialized === false ) {\n\n\t\t\tsphere.makeEmpty();\n\n\t\t\tthis.getBoundingBoxAt( id, _box$1 );\n\t\t\t_box$1.getCenter( sphere.center );\n\n\t\t\tconst index = geometry.index;\n\t\t\tconst position = geometry.attributes.position;\n\t\t\tconst drawRange = this._drawRanges[ id ];\n\n\t\t\tlet maxRadiusSq = 0;\n\t\t\tfor ( let i = drawRange.start, l = drawRange.start + drawRange.count; i < l; i ++ ) {\n\n\t\t\t\tlet iv = i;\n\t\t\t\tif ( index ) {\n\n\t\t\t\t\tiv = index.getX( iv );\n\n\t\t\t\t}\n\n\t\t\t\t_vector$5.fromBufferAttribute( position, iv );\n\t\t\t\tmaxRadiusSq = Math.max( maxRadiusSq, sphere.center.distanceToSquared( _vector$5 ) );\n\n\t\t\t}\n\n\t\t\tsphere.radius = Math.sqrt( maxRadiusSq );\n\t\t\tbound.sphereInitialized = true;\n\n\t\t}\n\n\t\ttarget.copy( sphere );\n\t\treturn target;\n\n\t}\n\n\tsetMatrixAt( geometryId, matrix ) {\n\n\t\t// @TODO: Map geometryId to index of the arrays because\n\t\t// optimize() can make geometryId mismatch the index\n\n\t\tconst active = this._active;\n\t\tconst matricesTexture = this._matricesTexture;\n\t\tconst matricesArray = this._matricesTexture.image.data;\n\t\tconst geometryCount = this._geometryCount;\n\t\tif ( geometryId >= geometryCount || active[ geometryId ] === false ) {\n\n\t\t\treturn this;\n\n\t\t}\n\n\t\tmatrix.toArray( matricesArray, geometryId * 16 );\n\t\tmatricesTexture.needsUpdate = true;\n\n\t\treturn this;\n\n\t}\n\n\tgetMatrixAt( geometryId, matrix ) {\n\n\t\tconst active = this._active;\n\t\tconst matricesArray = this._matricesTexture.image.data;\n\t\tconst geometryCount = this._geometryCount;\n\t\tif ( geometryId >= geometryCount || active[ geometryId ] === false ) {\n\n\t\t\treturn null;\n\n\t\t}\n\n\t\treturn matrix.fromArray( matricesArray, geometryId * 16 );\n\n\t}\n\n\tsetVisibleAt( geometryId, value ) {\n\n\t\tconst visibility = this._visibility;\n\t\tconst active = this._active;\n\t\tconst geometryCount = this._geometryCount;\n\n\t\t// if the geometry is out of range, not active, or visibility state\n\t\t// does not change then return early\n\t\tif (\n\t\t\tgeometryId >= geometryCount ||\n\t\t\tactive[ geometryId ] === false ||\n\t\t\tvisibility[ geometryId ] === value\n\t\t) {\n\n\t\t\treturn this;\n\n\t\t}\n\n\t\tvisibility[ geometryId ] = value;\n\t\tthis._visibilityChanged = true;\n\n\t\treturn this;\n\n\t}\n\n\tgetVisibleAt( geometryId ) {\n\n\t\tconst visibility = this._visibility;\n\t\tconst active = this._active;\n\t\tconst geometryCount = this._geometryCount;\n\n\t\t// return early if the geometry is out of range or not active\n\t\tif ( geometryId >= geometryCount || active[ geometryId ] === false ) {\n\n\t\t\treturn false;\n\n\t\t}\n\n\t\treturn visibility[ geometryId ];\n\n\t}\n\n\traycast( raycaster, intersects ) {\n\n\t\tconst visibility = this._visibility;\n\t\tconst active = this._active;\n\t\tconst drawRanges = this._drawRanges;\n\t\tconst geometryCount = this._geometryCount;\n\t\tconst matrixWorld = this.matrixWorld;\n\t\tconst batchGeometry = this.geometry;\n\n\t\t// iterate over each geometry\n\t\t_mesh.material = this.material;\n\t\t_mesh.geometry.index = batchGeometry.index;\n\t\t_mesh.geometry.attributes = batchGeometry.attributes;\n\t\tif ( _mesh.geometry.boundingBox === null ) {\n\n\t\t\t_mesh.geometry.boundingBox = new Box3();\n\n\t\t}\n\n\t\tif ( _mesh.geometry.boundingSphere === null ) {\n\n\t\t\t_mesh.geometry.boundingSphere = new Sphere();\n\n\t\t}\n\n\t\tfor ( let i = 0; i < geometryCount; i ++ ) {\n\n\t\t\tif ( ! visibility[ i ] || ! active[ i ] ) {\n\n\t\t\t\tcontinue;\n\n\t\t\t}\n\n\t\t\tconst drawRange = drawRanges[ i ];\n\t\t\t_mesh.geometry.setDrawRange( drawRange.start, drawRange.count );\n\n\t\t\t// ge the intersects\n\t\t\tthis.getMatrixAt( i, _mesh.matrixWorld ).premultiply( matrixWorld );\n\t\t\tthis.getBoundingBoxAt( i, _mesh.geometry.boundingBox );\n\t\t\tthis.getBoundingSphereAt( i, _mesh.geometry.boundingSphere );\n\t\t\t_mesh.raycast( raycaster, _batchIntersects );\n\n\t\t\t// add batch id to the intersects\n\t\t\tfor ( let j = 0, l = _batchIntersects.length; j < l; j ++ ) {\n\n\t\t\t\tconst intersect = _batchIntersects[ j ];\n\t\t\t\tintersect.object = this;\n\t\t\t\tintersect.batchId = i;\n\t\t\t\tintersects.push( intersect );\n\n\t\t\t}\n\n\t\t\t_batchIntersects.length = 0;\n\n\t\t}\n\n\t\t_mesh.material = null;\n\t\t_mesh.geometry.index = null;\n\t\t_mesh.geometry.attributes = {};\n\t\t_mesh.geometry.setDrawRange( 0, Infinity );\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.geometry = source.geometry.clone();\n\t\tthis.perObjectFrustumCulled = source.perObjectFrustumCulled;\n\t\tthis.sortObjects = source.sortObjects;\n\t\tthis.boundingBox = source.boundingBox !== null ? source.boundingBox.clone() : null;\n\t\tthis.boundingSphere = source.boundingSphere !== null ? source.boundingSphere.clone() : null;\n\n\t\tthis._drawRanges = source._drawRanges.map( range => ( { ...range } ) );\n\t\tthis._reservedRanges = source._reservedRanges.map( range => ( { ...range } ) );\n\n\t\tthis._visibility = source._visibility.slice();\n\t\tthis._active = source._active.slice();\n\t\tthis._bounds = source._bounds.map( bound => ( {\n\t\t\tboxInitialized: bound.boxInitialized,\n\t\t\tbox: bound.box.clone(),\n\n\t\t\tsphereInitialized: bound.sphereInitialized,\n\t\t\tsphere: bound.sphere.clone()\n\t\t} ) );\n\n\t\tthis._maxGeometryCount = source._maxGeometryCount;\n\t\tthis._maxVertexCount = source._maxVertexCount;\n\t\tthis._maxIndexCount = source._maxIndexCount;\n\n\t\tthis._geometryInitialized = source._geometryInitialized;\n\t\tthis._geometryCount = source._geometryCount;\n\t\tthis._multiDrawCounts = source._multiDrawCounts.slice();\n\t\tthis._multiDrawStarts = source._multiDrawStarts.slice();\n\n\t\tthis._matricesTexture = source._matricesTexture.clone();\n\t\tthis._matricesTexture.image.data = this._matricesTexture.image.slice();\n\n\t\treturn this;\n\n\t}\n\n\tdispose() {\n\n\t\t// Assuming the geometry is not shared with other meshes\n\t\tthis.geometry.dispose();\n\n\t\tthis._matricesTexture.dispose();\n\t\tthis._matricesTexture = null;\n\t\treturn this;\n\n\t}\n\n\tonBeforeRender( renderer, scene, camera, geometry, material/*, _group*/ ) {\n\n\t\t// if visibility has not changed and frustum culling and object sorting is not required\n\t\t// then skip iterating over all items\n\t\tif ( ! this._visibilityChanged && ! this.perObjectFrustumCulled && ! this.sortObjects ) {\n\n\t\t\treturn;\n\n\t\t}\n\n\t\t// the indexed version of the multi draw function requires specifying the start\n\t\t// offset in bytes.\n\t\tconst index = geometry.getIndex();\n\t\tconst bytesPerElement = index === null ? 1 : index.array.BYTES_PER_ELEMENT;\n\n\t\tconst active = this._active;\n\t\tconst visibility = this._visibility;\n\t\tconst multiDrawStarts = this._multiDrawStarts;\n\t\tconst multiDrawCounts = this._multiDrawCounts;\n\t\tconst drawRanges = this._drawRanges;\n\t\tconst perObjectFrustumCulled = this.perObjectFrustumCulled;\n\n\t\t// prepare the frustum in the local frame\n\t\tif ( perObjectFrustumCulled ) {\n\n\t\t\t_projScreenMatrix$2\n\t\t\t\t.multiplyMatrices( camera.projectionMatrix, camera.matrixWorldInverse )\n\t\t\t\t.multiply( this.matrixWorld );\n\t\t\t_frustum.setFromProjectionMatrix(\n\t\t\t\t_projScreenMatrix$2,\n\t\t\t\trenderer.coordinateSystem\n\t\t\t);\n\n\t\t}\n\n\t\tlet count = 0;\n\t\tif ( this.sortObjects ) {\n\n\t\t\t// get the camera position in the local frame\n\t\t\t_invMatrixWorld.copy( this.matrixWorld ).invert();\n\t\t\t_vector$5.setFromMatrixPosition( camera.matrixWorld ).applyMatrix4( _invMatrixWorld );\n\n\t\t\tfor ( let i = 0, l = visibility.length; i < l; i ++ ) {\n\n\t\t\t\tif ( visibility[ i ] && active[ i ] ) {\n\n\t\t\t\t\t// get the bounds in world space\n\t\t\t\t\tthis.getMatrixAt( i, _matrix$1 );\n\t\t\t\t\tthis.getBoundingSphereAt( i, _sphere$2 ).applyMatrix4( _matrix$1 );\n\n\t\t\t\t\t// determine whether the batched geometry is within the frustum\n\t\t\t\t\tlet culled = false;\n\t\t\t\t\tif ( perObjectFrustumCulled ) {\n\n\t\t\t\t\t\tculled = ! _frustum.intersectsSphere( _sphere$2 );\n\n\t\t\t\t\t}\n\n\t\t\t\t\tif ( ! culled ) {\n\n\t\t\t\t\t\t// get the distance from camera used for sorting\n\t\t\t\t\t\tconst z = _vector$5.distanceTo( _sphere$2.center );\n\t\t\t\t\t\t_renderList.push( drawRanges[ i ], z );\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\t// Sort the draw ranges and prep for rendering\n\t\t\tconst list = _renderList.list;\n\t\t\tconst customSort = this.customSort;\n\t\t\tif ( customSort === null ) {\n\n\t\t\t\tlist.sort( material.transparent ? sortTransparent : sortOpaque );\n\n\t\t\t} else {\n\n\t\t\t\tcustomSort.call( this, list, camera );\n\n\t\t\t}\n\n\t\t\tfor ( let i = 0, l = list.length; i < l; i ++ ) {\n\n\t\t\t\tconst item = list[ i ];\n\t\t\t\tmultiDrawStarts[ count ] = item.start * bytesPerElement;\n\t\t\t\tmultiDrawCounts[ count ] = item.count;\n\t\t\t\tcount ++;\n\n\t\t\t}\n\n\t\t\t_renderList.reset();\n\n\t\t} else {\n\n\t\t\tfor ( let i = 0, l = visibility.length; i < l; i ++ ) {\n\n\t\t\t\tif ( visibility[ i ] && active[ i ] ) {\n\n\t\t\t\t\t// determine whether the batched geometry is within the frustum\n\t\t\t\t\tlet culled = false;\n\t\t\t\t\tif ( perObjectFrustumCulled ) {\n\n\t\t\t\t\t\t// get the bounds in world space\n\t\t\t\t\t\tthis.getMatrixAt( i, _matrix$1 );\n\t\t\t\t\t\tthis.getBoundingSphereAt( i, _sphere$2 ).applyMatrix4( _matrix$1 );\n\t\t\t\t\t\tculled = ! _frustum.intersectsSphere( _sphere$2 );\n\n\t\t\t\t\t}\n\n\t\t\t\t\tif ( ! culled ) {\n\n\t\t\t\t\t\tconst range = drawRanges[ i ];\n\t\t\t\t\t\tmultiDrawStarts[ count ] = range.start * bytesPerElement;\n\t\t\t\t\t\tmultiDrawCounts[ count ] = range.count;\n\t\t\t\t\t\tcount ++;\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t\tthis._multiDrawCount = count;\n\t\tthis._visibilityChanged = false;\n\n\t}\n\n\tonBeforeShadow( renderer, object, camera, shadowCamera, geometry, depthMaterial/* , group */ ) {\n\n\t\tthis.onBeforeRender( renderer, null, shadowCamera, geometry, depthMaterial );\n\n\t}\n\n}\n\nclass LineBasicMaterial extends Material {\n\n\tconstructor( parameters ) {\n\n\t\tsuper();\n\n\t\tthis.isLineBasicMaterial = true;\n\n\t\tthis.type = 'LineBasicMaterial';\n\n\t\tthis.color = new Color( 0xffffff );\n\n\t\tthis.map = null;\n\n\t\tthis.linewidth = 1;\n\t\tthis.linecap = 'round';\n\t\tthis.linejoin = 'round';\n\n\t\tthis.fog = true;\n\n\t\tthis.setValues( parameters );\n\n\t}\n\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.color.copy( source.color );\n\n\t\tthis.map = source.map;\n\n\t\tthis.linewidth = source.linewidth;\n\t\tthis.linecap = source.linecap;\n\t\tthis.linejoin = source.linejoin;\n\n\t\tthis.fog = source.fog;\n\n\t\treturn this;\n\n\t}\n\n}\n\nconst _start$1 = /*@__PURE__*/ new Vector3();\nconst _end$1 = /*@__PURE__*/ new Vector3();\nconst _inverseMatrix$1 = /*@__PURE__*/ new Matrix4();\nconst _ray$1 = /*@__PURE__*/ new Ray();\nconst _sphere$1 = /*@__PURE__*/ new Sphere();\n\nclass Line extends Object3D {\n\n\tconstructor( geometry = new BufferGeometry(), material = new LineBasicMaterial() ) {\n\n\t\tsuper();\n\n\t\tthis.isLine = true;\n\n\t\tthis.type = 'Line';\n\n\t\tthis.geometry = geometry;\n\t\tthis.material = material;\n\n\t\tthis.updateMorphTargets();\n\n\t}\n\n\tcopy( source, recursive ) {\n\n\t\tsuper.copy( source, recursive );\n\n\t\tthis.material = Array.isArray( source.material ) ? source.material.slice() : source.material;\n\t\tthis.geometry = source.geometry;\n\n\t\treturn this;\n\n\t}\n\n\tcomputeLineDistances() {\n\n\t\tconst geometry = this.geometry;\n\n\t\t// we assume non-indexed geometry\n\n\t\tif ( geometry.index === null ) {\n\n\t\t\tconst positionAttribute = geometry.attributes.position;\n\t\t\tconst lineDistances = [ 0 ];\n\n\t\t\tfor ( let i = 1, l = positionAttribute.count; i < l; i ++ ) {\n\n\t\t\t\t_start$1.fromBufferAttribute( positionAttribute, i - 1 );\n\t\t\t\t_end$1.fromBufferAttribute( positionAttribute, i );\n\n\t\t\t\tlineDistances[ i ] = lineDistances[ i - 1 ];\n\t\t\t\tlineDistances[ i ] += _start$1.distanceTo( _end$1 );\n\n\t\t\t}\n\n\t\t\tgeometry.setAttribute( 'lineDistance', new Float32BufferAttribute( lineDistances, 1 ) );\n\n\t\t} else {\n\n\t\t\tconsole.warn( 'THREE.Line.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.' );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\traycast( raycaster, intersects ) {\n\n\t\tconst geometry = this.geometry;\n\t\tconst matrixWorld = this.matrixWorld;\n\t\tconst threshold = raycaster.params.Line.threshold;\n\t\tconst drawRange = geometry.drawRange;\n\n\t\t// Checking boundingSphere distance to ray\n\n\t\tif ( geometry.boundingSphere === null ) geometry.computeBoundingSphere();\n\n\t\t_sphere$1.copy( geometry.boundingSphere );\n\t\t_sphere$1.applyMatrix4( matrixWorld );\n\t\t_sphere$1.radius += threshold;\n\n\t\tif ( raycaster.ray.intersectsSphere( _sphere$1 ) === false ) return;\n\n\t\t//\n\n\t\t_inverseMatrix$1.copy( matrixWorld ).invert();\n\t\t_ray$1.copy( raycaster.ray ).applyMatrix4( _inverseMatrix$1 );\n\n\t\tconst localThreshold = threshold / ( ( this.scale.x + this.scale.y + this.scale.z ) / 3 );\n\t\tconst localThresholdSq = localThreshold * localThreshold;\n\n\t\tconst vStart = new Vector3();\n\t\tconst vEnd = new Vector3();\n\t\tconst interSegment = new Vector3();\n\t\tconst interRay = new Vector3();\n\t\tconst step = this.isLineSegments ? 2 : 1;\n\n\t\tconst index = geometry.index;\n\t\tconst attributes = geometry.attributes;\n\t\tconst positionAttribute = attributes.position;\n\n\t\tif ( index !== null ) {\n\n\t\t\tconst start = Math.max( 0, drawRange.start );\n\t\t\tconst end = Math.min( index.count, ( drawRange.start + drawRange.count ) );\n\n\t\t\tfor ( let i = start, l = end - 1; i < l; i += step ) {\n\n\t\t\t\tconst a = index.getX( i );\n\t\t\t\tconst b = index.getX( i + 1 );\n\n\t\t\t\tvStart.fromBufferAttribute( positionAttribute, a );\n\t\t\t\tvEnd.fromBufferAttribute( positionAttribute, b );\n\n\t\t\t\tconst distSq = _ray$1.distanceSqToSegment( vStart, vEnd, interRay, interSegment );\n\n\t\t\t\tif ( distSq > localThresholdSq ) continue;\n\n\t\t\t\tinterRay.applyMatrix4( this.matrixWorld ); //Move back to world space for distance calculation\n\n\t\t\t\tconst distance = raycaster.ray.origin.distanceTo( interRay );\n\n\t\t\t\tif ( distance < raycaster.near || distance > raycaster.far ) continue;\n\n\t\t\t\tintersects.push( {\n\n\t\t\t\t\tdistance: distance,\n\t\t\t\t\t// What do we want? intersection point on the ray or on the segment??\n\t\t\t\t\t// point: raycaster.ray.at( distance ),\n\t\t\t\t\tpoint: interSegment.clone().applyMatrix4( this.matrixWorld ),\n\t\t\t\t\tindex: i,\n\t\t\t\t\tface: null,\n\t\t\t\t\tfaceIndex: null,\n\t\t\t\t\tobject: this\n\n\t\t\t\t} );\n\n\t\t\t}\n\n\t\t} else {\n\n\t\t\tconst start = Math.max( 0, drawRange.start );\n\t\t\tconst end = Math.min( positionAttribute.count, ( drawRange.start + drawRange.count ) );\n\n\t\t\tfor ( let i = start, l = end - 1; i < l; i += step ) {\n\n\t\t\t\tvStart.fromBufferAttribute( positionAttribute, i );\n\t\t\t\tvEnd.fromBufferAttribute( positionAttribute, i + 1 );\n\n\t\t\t\tconst distSq = _ray$1.distanceSqToSegment( vStart, vEnd, interRay, interSegment );\n\n\t\t\t\tif ( distSq > localThresholdSq ) continue;\n\n\t\t\t\tinterRay.applyMatrix4( this.matrixWorld ); //Move back to world space for distance calculation\n\n\t\t\t\tconst distance = raycaster.ray.origin.distanceTo( interRay );\n\n\t\t\t\tif ( distance < raycaster.near || distance > raycaster.far ) continue;\n\n\t\t\t\tintersects.push( {\n\n\t\t\t\t\tdistance: distance,\n\t\t\t\t\t// What do we want? intersection point on the ray or on the segment??\n\t\t\t\t\t// point: raycaster.ray.at( distance ),\n\t\t\t\t\tpoint: interSegment.clone().applyMatrix4( this.matrixWorld ),\n\t\t\t\t\tindex: i,\n\t\t\t\t\tface: null,\n\t\t\t\t\tfaceIndex: null,\n\t\t\t\t\tobject: this\n\n\t\t\t\t} );\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n\tupdateMorphTargets() {\n\n\t\tconst geometry = this.geometry;\n\n\t\tconst morphAttributes = geometry.morphAttributes;\n\t\tconst keys = Object.keys( morphAttributes );\n\n\t\tif ( keys.length > 0 ) {\n\n\t\t\tconst morphAttribute = morphAttributes[ keys[ 0 ] ];\n\n\t\t\tif ( morphAttribute !== undefined ) {\n\n\t\t\t\tthis.morphTargetInfluences = [];\n\t\t\t\tthis.morphTargetDictionary = {};\n\n\t\t\t\tfor ( let m = 0, ml = morphAttribute.length; m < ml; m ++ ) {\n\n\t\t\t\t\tconst name = morphAttribute[ m ].name || String( m );\n\n\t\t\t\t\tthis.morphTargetInfluences.push( 0 );\n\t\t\t\t\tthis.morphTargetDictionary[ name ] = m;\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n}\n\nconst _start = /*@__PURE__*/ new Vector3();\nconst _end = /*@__PURE__*/ new Vector3();\n\nclass LineSegments extends Line {\n\n\tconstructor( geometry, material ) {\n\n\t\tsuper( geometry, material );\n\n\t\tthis.isLineSegments = true;\n\n\t\tthis.type = 'LineSegments';\n\n\t}\n\n\tcomputeLineDistances() {\n\n\t\tconst geometry = this.geometry;\n\n\t\t// we assume non-indexed geometry\n\n\t\tif ( geometry.index === null ) {\n\n\t\t\tconst positionAttribute = geometry.attributes.position;\n\t\t\tconst lineDistances = [];\n\n\t\t\tfor ( let i = 0, l = positionAttribute.count; i < l; i += 2 ) {\n\n\t\t\t\t_start.fromBufferAttribute( positionAttribute, i );\n\t\t\t\t_end.fromBufferAttribute( positionAttribute, i + 1 );\n\n\t\t\t\tlineDistances[ i ] = ( i === 0 ) ? 0 : lineDistances[ i - 1 ];\n\t\t\t\tlineDistances[ i + 1 ] = lineDistances[ i ] + _start.distanceTo( _end );\n\n\t\t\t}\n\n\t\t\tgeometry.setAttribute( 'lineDistance', new Float32BufferAttribute( lineDistances, 1 ) );\n\n\t\t} else {\n\n\t\t\tconsole.warn( 'THREE.LineSegments.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.' );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n}\n\nclass LineLoop extends Line {\n\n\tconstructor( geometry, material ) {\n\n\t\tsuper( geometry, material );\n\n\t\tthis.isLineLoop = true;\n\n\t\tthis.type = 'LineLoop';\n\n\t}\n\n}\n\nclass PointsMaterial extends Material {\n\n\tconstructor( parameters ) {\n\n\t\tsuper();\n\n\t\tthis.isPointsMaterial = true;\n\n\t\tthis.type = 'PointsMaterial';\n\n\t\tthis.color = new Color( 0xffffff );\n\n\t\tthis.map = null;\n\n\t\tthis.alphaMap = null;\n\n\t\tthis.size = 1;\n\t\tthis.sizeAttenuation = true;\n\n\t\tthis.fog = true;\n\n\t\tthis.setValues( parameters );\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.color.copy( source.color );\n\n\t\tthis.map = source.map;\n\n\t\tthis.alphaMap = source.alphaMap;\n\n\t\tthis.size = source.size;\n\t\tthis.sizeAttenuation = source.sizeAttenuation;\n\n\t\tthis.fog = source.fog;\n\n\t\treturn this;\n\n\t}\n\n}\n\nconst _inverseMatrix = /*@__PURE__*/ new Matrix4();\nconst _ray = /*@__PURE__*/ new Ray();\nconst _sphere = /*@__PURE__*/ new Sphere();\nconst _position$2 = /*@__PURE__*/ new Vector3();\n\nclass Points extends Object3D {\n\n\tconstructor( geometry = new BufferGeometry(), material = new PointsMaterial() ) {\n\n\t\tsuper();\n\n\t\tthis.isPoints = true;\n\n\t\tthis.type = 'Points';\n\n\t\tthis.geometry = geometry;\n\t\tthis.material = material;\n\n\t\tthis.updateMorphTargets();\n\n\t}\n\n\tcopy( source, recursive ) {\n\n\t\tsuper.copy( source, recursive );\n\n\t\tthis.material = Array.isArray( source.material ) ? source.material.slice() : source.material;\n\t\tthis.geometry = source.geometry;\n\n\t\treturn this;\n\n\t}\n\n\traycast( raycaster, intersects ) {\n\n\t\tconst geometry = this.geometry;\n\t\tconst matrixWorld = this.matrixWorld;\n\t\tconst threshold = raycaster.params.Points.threshold;\n\t\tconst drawRange = geometry.drawRange;\n\n\t\t// Checking boundingSphere distance to ray\n\n\t\tif ( geometry.boundingSphere === null ) geometry.computeBoundingSphere();\n\n\t\t_sphere.copy( geometry.boundingSphere );\n\t\t_sphere.applyMatrix4( matrixWorld );\n\t\t_sphere.radius += threshold;\n\n\t\tif ( raycaster.ray.intersectsSphere( _sphere ) === false ) return;\n\n\t\t//\n\n\t\t_inverseMatrix.copy( matrixWorld ).invert();\n\t\t_ray.copy( raycaster.ray ).applyMatrix4( _inverseMatrix );\n\n\t\tconst localThreshold = threshold / ( ( this.scale.x + this.scale.y + this.scale.z ) / 3 );\n\t\tconst localThresholdSq = localThreshold * localThreshold;\n\n\t\tconst index = geometry.index;\n\t\tconst attributes = geometry.attributes;\n\t\tconst positionAttribute = attributes.position;\n\n\t\tif ( index !== null ) {\n\n\t\t\tconst start = Math.max( 0, drawRange.start );\n\t\t\tconst end = Math.min( index.count, ( drawRange.start + drawRange.count ) );\n\n\t\t\tfor ( let i = start, il = end; i < il; i ++ ) {\n\n\t\t\t\tconst a = index.getX( i );\n\n\t\t\t\t_position$2.fromBufferAttribute( positionAttribute, a );\n\n\t\t\t\ttestPoint( _position$2, a, localThresholdSq, matrixWorld, raycaster, intersects, this );\n\n\t\t\t}\n\n\t\t} else {\n\n\t\t\tconst start = Math.max( 0, drawRange.start );\n\t\t\tconst end = Math.min( positionAttribute.count, ( drawRange.start + drawRange.count ) );\n\n\t\t\tfor ( let i = start, l = end; i < l; i ++ ) {\n\n\t\t\t\t_position$2.fromBufferAttribute( positionAttribute, i );\n\n\t\t\t\ttestPoint( _position$2, i, localThresholdSq, matrixWorld, raycaster, intersects, this );\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n\tupdateMorphTargets() {\n\n\t\tconst geometry = this.geometry;\n\n\t\tconst morphAttributes = geometry.morphAttributes;\n\t\tconst keys = Object.keys( morphAttributes );\n\n\t\tif ( keys.length > 0 ) {\n\n\t\t\tconst morphAttribute = morphAttributes[ keys[ 0 ] ];\n\n\t\t\tif ( morphAttribute !== undefined ) {\n\n\t\t\t\tthis.morphTargetInfluences = [];\n\t\t\t\tthis.morphTargetDictionary = {};\n\n\t\t\t\tfor ( let m = 0, ml = morphAttribute.length; m < ml; m ++ ) {\n\n\t\t\t\t\tconst name = morphAttribute[ m ].name || String( m );\n\n\t\t\t\t\tthis.morphTargetInfluences.push( 0 );\n\t\t\t\t\tthis.morphTargetDictionary[ name ] = m;\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n}\n\nfunction testPoint( point, index, localThresholdSq, matrixWorld, raycaster, intersects, object ) {\n\n\tconst rayPointDistanceSq = _ray.distanceSqToPoint( point );\n\n\tif ( rayPointDistanceSq < localThresholdSq ) {\n\n\t\tconst intersectPoint = new Vector3();\n\n\t\t_ray.closestPointToPoint( point, intersectPoint );\n\t\tintersectPoint.applyMatrix4( matrixWorld );\n\n\t\tconst distance = raycaster.ray.origin.distanceTo( intersectPoint );\n\n\t\tif ( distance < raycaster.near || distance > raycaster.far ) return;\n\n\t\tintersects.push( {\n\n\t\t\tdistance: distance,\n\t\t\tdistanceToRay: Math.sqrt( rayPointDistanceSq ),\n\t\t\tpoint: intersectPoint,\n\t\t\tindex: index,\n\t\t\tface: null,\n\t\t\tobject: object\n\n\t\t} );\n\n\t}\n\n}\n\nclass VideoTexture extends Texture {\n\n\tconstructor( video, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy ) {\n\n\t\tsuper( video, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy );\n\n\t\tthis.isVideoTexture = true;\n\n\t\tthis.minFilter = minFilter !== undefined ? minFilter : LinearFilter;\n\t\tthis.magFilter = magFilter !== undefined ? magFilter : LinearFilter;\n\n\t\tthis.generateMipmaps = false;\n\n\t\tconst scope = this;\n\n\t\tfunction updateVideo() {\n\n\t\t\tscope.needsUpdate = true;\n\t\t\tvideo.requestVideoFrameCallback( updateVideo );\n\n\t\t}\n\n\t\tif ( 'requestVideoFrameCallback' in video ) {\n\n\t\t\tvideo.requestVideoFrameCallback( updateVideo );\n\n\t\t}\n\n\t}\n\n\tclone() {\n\n\t\treturn new this.constructor( this.image ).copy( this );\n\n\t}\n\n\tupdate() {\n\n\t\tconst video = this.image;\n\t\tconst hasVideoFrameCallback = 'requestVideoFrameCallback' in video;\n\n\t\tif ( hasVideoFrameCallback === false && video.readyState >= video.HAVE_CURRENT_DATA ) {\n\n\t\t\tthis.needsUpdate = true;\n\n\t\t}\n\n\t}\n\n}\n\nclass FramebufferTexture extends Texture {\n\n\tconstructor( width, height ) {\n\n\t\tsuper( { width, height } );\n\n\t\tthis.isFramebufferTexture = true;\n\n\t\tthis.magFilter = NearestFilter;\n\t\tthis.minFilter = NearestFilter;\n\n\t\tthis.generateMipmaps = false;\n\n\t\tthis.needsUpdate = true;\n\n\t}\n\n}\n\nclass CompressedTexture extends Texture {\n\n\tconstructor( mipmaps, width, height, format, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy, colorSpace ) {\n\n\t\tsuper( null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, colorSpace );\n\n\t\tthis.isCompressedTexture = true;\n\n\t\tthis.image = { width: width, height: height };\n\t\tthis.mipmaps = mipmaps;\n\n\t\t// no flipping for cube textures\n\t\t// (also flipping doesn't work for compressed textures )\n\n\t\tthis.flipY = false;\n\n\t\t// can't generate mipmaps for compressed textures\n\t\t// mips must be embedded in DDS files\n\n\t\tthis.generateMipmaps = false;\n\n\t}\n\n}\n\nclass CompressedArrayTexture extends CompressedTexture {\n\n\tconstructor( mipmaps, width, height, depth, format, type ) {\n\n\t\tsuper( mipmaps, width, height, format, type );\n\n\t\tthis.isCompressedArrayTexture = true;\n\t\tthis.image.depth = depth;\n\t\tthis.wrapR = ClampToEdgeWrapping;\n\n\t}\n\n}\n\nclass CompressedCubeTexture extends CompressedTexture {\n\n\tconstructor( images, format, type ) {\n\n\t\tsuper( undefined, images[ 0 ].width, images[ 0 ].height, format, type, CubeReflectionMapping );\n\n\t\tthis.isCompressedCubeTexture = true;\n\t\tthis.isCubeTexture = true;\n\n\t\tthis.image = images;\n\n\t}\n\n}\n\nclass CanvasTexture extends Texture {\n\n\tconstructor( canvas, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy ) {\n\n\t\tsuper( canvas, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy );\n\n\t\tthis.isCanvasTexture = true;\n\n\t\tthis.needsUpdate = true;\n\n\t}\n\n}\n\n/**\n * Extensible curve object.\n *\n * Some common of curve methods:\n * .getPoint( t, optionalTarget ), .getTangent( t, optionalTarget )\n * .getPointAt( u, optionalTarget ), .getTangentAt( u, optionalTarget )\n * .getPoints(), .getSpacedPoints()\n * .getLength()\n * .updateArcLengths()\n *\n * This following curves inherit from THREE.Curve:\n *\n * -- 2D curves --\n * THREE.ArcCurve\n * THREE.CubicBezierCurve\n * THREE.EllipseCurve\n * THREE.LineCurve\n * THREE.QuadraticBezierCurve\n * THREE.SplineCurve\n *\n * -- 3D curves --\n * THREE.CatmullRomCurve3\n * THREE.CubicBezierCurve3\n * THREE.LineCurve3\n * THREE.QuadraticBezierCurve3\n *\n * A series of curves can be represented as a THREE.CurvePath.\n *\n **/\n\nclass Curve {\n\n\tconstructor() {\n\n\t\tthis.type = 'Curve';\n\n\t\tthis.arcLengthDivisions = 200;\n\n\t}\n\n\t// Virtual base class method to overwrite and implement in subclasses\n\t//\t- t [0 .. 1]\n\n\tgetPoint( /* t, optionalTarget */ ) {\n\n\t\tconsole.warn( 'THREE.Curve: .getPoint() not implemented.' );\n\t\treturn null;\n\n\t}\n\n\t// Get point at relative position in curve according to arc length\n\t// - u [0 .. 1]\n\n\tgetPointAt( u, optionalTarget ) {\n\n\t\tconst t = this.getUtoTmapping( u );\n\t\treturn this.getPoint( t, optionalTarget );\n\n\t}\n\n\t// Get sequence of points using getPoint( t )\n\n\tgetPoints( divisions = 5 ) {\n\n\t\tconst points = [];\n\n\t\tfor ( let d = 0; d <= divisions; d ++ ) {\n\n\t\t\tpoints.push( this.getPoint( d / divisions ) );\n\n\t\t}\n\n\t\treturn points;\n\n\t}\n\n\t// Get sequence of points using getPointAt( u )\n\n\tgetSpacedPoints( divisions = 5 ) {\n\n\t\tconst points = [];\n\n\t\tfor ( let d = 0; d <= divisions; d ++ ) {\n\n\t\t\tpoints.push( this.getPointAt( d / divisions ) );\n\n\t\t}\n\n\t\treturn points;\n\n\t}\n\n\t// Get total curve arc length\n\n\tgetLength() {\n\n\t\tconst lengths = this.getLengths();\n\t\treturn lengths[ lengths.length - 1 ];\n\n\t}\n\n\t// Get list of cumulative segment lengths\n\n\tgetLengths( divisions = this.arcLengthDivisions ) {\n\n\t\tif ( this.cacheArcLengths &&\n\t\t\t( this.cacheArcLengths.length === divisions + 1 ) &&\n\t\t\t! this.needsUpdate ) {\n\n\t\t\treturn this.cacheArcLengths;\n\n\t\t}\n\n\t\tthis.needsUpdate = false;\n\n\t\tconst cache = [];\n\t\tlet current, last = this.getPoint( 0 );\n\t\tlet sum = 0;\n\n\t\tcache.push( 0 );\n\n\t\tfor ( let p = 1; p <= divisions; p ++ ) {\n\n\t\t\tcurrent = this.getPoint( p / divisions );\n\t\t\tsum += current.distanceTo( last );\n\t\t\tcache.push( sum );\n\t\t\tlast = current;\n\n\t\t}\n\n\t\tthis.cacheArcLengths = cache;\n\n\t\treturn cache; // { sums: cache, sum: sum }; Sum is in the last element.\n\n\t}\n\n\tupdateArcLengths() {\n\n\t\tthis.needsUpdate = true;\n\t\tthis.getLengths();\n\n\t}\n\n\t// Given u ( 0 .. 1 ), get a t to find p. This gives you points which are equidistant\n\n\tgetUtoTmapping( u, distance ) {\n\n\t\tconst arcLengths = this.getLengths();\n\n\t\tlet i = 0;\n\t\tconst il = arcLengths.length;\n\n\t\tlet targetArcLength; // The targeted u distance value to get\n\n\t\tif ( distance ) {\n\n\t\t\ttargetArcLength = distance;\n\n\t\t} else {\n\n\t\t\ttargetArcLength = u * arcLengths[ il - 1 ];\n\n\t\t}\n\n\t\t// binary search for the index with largest value smaller than target u distance\n\n\t\tlet low = 0, high = il - 1, comparison;\n\n\t\twhile ( low <= high ) {\n\n\t\t\ti = Math.floor( low + ( high - low ) / 2 ); // less likely to overflow, though probably not issue here, JS doesn't really have integers, all numbers are floats\n\n\t\t\tcomparison = arcLengths[ i ] - targetArcLength;\n\n\t\t\tif ( comparison < 0 ) {\n\n\t\t\t\tlow = i + 1;\n\n\t\t\t} else if ( comparison > 0 ) {\n\n\t\t\t\thigh = i - 1;\n\n\t\t\t} else {\n\n\t\t\t\thigh = i;\n\t\t\t\tbreak;\n\n\t\t\t\t// DONE\n\n\t\t\t}\n\n\t\t}\n\n\t\ti = high;\n\n\t\tif ( arcLengths[ i ] === targetArcLength ) {\n\n\t\t\treturn i / ( il - 1 );\n\n\t\t}\n\n\t\t// we could get finer grain at lengths, or use simple interpolation between two points\n\n\t\tconst lengthBefore = arcLengths[ i ];\n\t\tconst lengthAfter = arcLengths[ i + 1 ];\n\n\t\tconst segmentLength = lengthAfter - lengthBefore;\n\n\t\t// determine where we are between the 'before' and 'after' points\n\n\t\tconst segmentFraction = ( targetArcLength - lengthBefore ) / segmentLength;\n\n\t\t// add that fractional amount to t\n\n\t\tconst t = ( i + segmentFraction ) / ( il - 1 );\n\n\t\treturn t;\n\n\t}\n\n\t// Returns a unit vector tangent at t\n\t// In case any sub curve does not implement its tangent derivation,\n\t// 2 points a small delta apart will be used to find its gradient\n\t// which seems to give a reasonable approximation\n\n\tgetTangent( t, optionalTarget ) {\n\n\t\tconst delta = 0.0001;\n\t\tlet t1 = t - delta;\n\t\tlet t2 = t + delta;\n\n\t\t// Capping in case of danger\n\n\t\tif ( t1 < 0 ) t1 = 0;\n\t\tif ( t2 > 1 ) t2 = 1;\n\n\t\tconst pt1 = this.getPoint( t1 );\n\t\tconst pt2 = this.getPoint( t2 );\n\n\t\tconst tangent = optionalTarget || ( ( pt1.isVector2 ) ? new Vector2() : new Vector3() );\n\n\t\ttangent.copy( pt2 ).sub( pt1 ).normalize();\n\n\t\treturn tangent;\n\n\t}\n\n\tgetTangentAt( u, optionalTarget ) {\n\n\t\tconst t = this.getUtoTmapping( u );\n\t\treturn this.getTangent( t, optionalTarget );\n\n\t}\n\n\tcomputeFrenetFrames( segments, closed ) {\n\n\t\t// see http://www.cs.indiana.edu/pub/techreports/TR425.pdf\n\n\t\tconst normal = new Vector3();\n\n\t\tconst tangents = [];\n\t\tconst normals = [];\n\t\tconst binormals = [];\n\n\t\tconst vec = new Vector3();\n\t\tconst mat = new Matrix4();\n\n\t\t// compute the tangent vectors for each segment on the curve\n\n\t\tfor ( let i = 0; i <= segments; i ++ ) {\n\n\t\t\tconst u = i / segments;\n\n\t\t\ttangents[ i ] = this.getTangentAt( u, new Vector3() );\n\n\t\t}\n\n\t\t// select an initial normal vector perpendicular to the first tangent vector,\n\t\t// and in the direction of the minimum tangent xyz component\n\n\t\tnormals[ 0 ] = new Vector3();\n\t\tbinormals[ 0 ] = new Vector3();\n\t\tlet min = Number.MAX_VALUE;\n\t\tconst tx = Math.abs( tangents[ 0 ].x );\n\t\tconst ty = Math.abs( tangents[ 0 ].y );\n\t\tconst tz = Math.abs( tangents[ 0 ].z );\n\n\t\tif ( tx <= min ) {\n\n\t\t\tmin = tx;\n\t\t\tnormal.set( 1, 0, 0 );\n\n\t\t}\n\n\t\tif ( ty <= min ) {\n\n\t\t\tmin = ty;\n\t\t\tnormal.set( 0, 1, 0 );\n\n\t\t}\n\n\t\tif ( tz <= min ) {\n\n\t\t\tnormal.set( 0, 0, 1 );\n\n\t\t}\n\n\t\tvec.crossVectors( tangents[ 0 ], normal ).normalize();\n\n\t\tnormals[ 0 ].crossVectors( tangents[ 0 ], vec );\n\t\tbinormals[ 0 ].crossVectors( tangents[ 0 ], normals[ 0 ] );\n\n\n\t\t// compute the slowly-varying normal and binormal vectors for each segment on the curve\n\n\t\tfor ( let i = 1; i <= segments; i ++ ) {\n\n\t\t\tnormals[ i ] = normals[ i - 1 ].clone();\n\n\t\t\tbinormals[ i ] = binormals[ i - 1 ].clone();\n\n\t\t\tvec.crossVectors( tangents[ i - 1 ], tangents[ i ] );\n\n\t\t\tif ( vec.length() > Number.EPSILON ) {\n\n\t\t\t\tvec.normalize();\n\n\t\t\t\tconst theta = Math.acos( clamp( tangents[ i - 1 ].dot( tangents[ i ] ), - 1, 1 ) ); // clamp for floating pt errors\n\n\t\t\t\tnormals[ i ].applyMatrix4( mat.makeRotationAxis( vec, theta ) );\n\n\t\t\t}\n\n\t\t\tbinormals[ i ].crossVectors( tangents[ i ], normals[ i ] );\n\n\t\t}\n\n\t\t// if the curve is closed, postprocess the vectors so the first and last normal vectors are the same\n\n\t\tif ( closed === true ) {\n\n\t\t\tlet theta = Math.acos( clamp( normals[ 0 ].dot( normals[ segments ] ), - 1, 1 ) );\n\t\t\ttheta /= segments;\n\n\t\t\tif ( tangents[ 0 ].dot( vec.crossVectors( normals[ 0 ], normals[ segments ] ) ) > 0 ) {\n\n\t\t\t\ttheta = - theta;\n\n\t\t\t}\n\n\t\t\tfor ( let i = 1; i <= segments; i ++ ) {\n\n\t\t\t\t// twist a little...\n\t\t\t\tnormals[ i ].applyMatrix4( mat.makeRotationAxis( tangents[ i ], theta * i ) );\n\t\t\t\tbinormals[ i ].crossVectors( tangents[ i ], normals[ i ] );\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn {\n\t\t\ttangents: tangents,\n\t\t\tnormals: normals,\n\t\t\tbinormals: binormals\n\t\t};\n\n\t}\n\n\tclone() {\n\n\t\treturn new this.constructor().copy( this );\n\n\t}\n\n\tcopy( source ) {\n\n\t\tthis.arcLengthDivisions = source.arcLengthDivisions;\n\n\t\treturn this;\n\n\t}\n\n\ttoJSON() {\n\n\t\tconst data = {\n\t\t\tmetadata: {\n\t\t\t\tversion: 4.6,\n\t\t\t\ttype: 'Curve',\n\t\t\t\tgenerator: 'Curve.toJSON'\n\t\t\t}\n\t\t};\n\n\t\tdata.arcLengthDivisions = this.arcLengthDivisions;\n\t\tdata.type = this.type;\n\n\t\treturn data;\n\n\t}\n\n\tfromJSON( json ) {\n\n\t\tthis.arcLengthDivisions = json.arcLengthDivisions;\n\n\t\treturn this;\n\n\t}\n\n}\n\nclass EllipseCurve extends Curve {\n\n\tconstructor( aX = 0, aY = 0, xRadius = 1, yRadius = 1, aStartAngle = 0, aEndAngle = Math.PI * 2, aClockwise = false, aRotation = 0 ) {\n\n\t\tsuper();\n\n\t\tthis.isEllipseCurve = true;\n\n\t\tthis.type = 'EllipseCurve';\n\n\t\tthis.aX = aX;\n\t\tthis.aY = aY;\n\n\t\tthis.xRadius = xRadius;\n\t\tthis.yRadius = yRadius;\n\n\t\tthis.aStartAngle = aStartAngle;\n\t\tthis.aEndAngle = aEndAngle;\n\n\t\tthis.aClockwise = aClockwise;\n\n\t\tthis.aRotation = aRotation;\n\n\t}\n\n\tgetPoint( t, optionalTarget = new Vector2() ) {\n\n\t\tconst point = optionalTarget;\n\n\t\tconst twoPi = Math.PI * 2;\n\t\tlet deltaAngle = this.aEndAngle - this.aStartAngle;\n\t\tconst samePoints = Math.abs( deltaAngle ) < Number.EPSILON;\n\n\t\t// ensures that deltaAngle is 0 .. 2 PI\n\t\twhile ( deltaAngle < 0 ) deltaAngle += twoPi;\n\t\twhile ( deltaAngle > twoPi ) deltaAngle -= twoPi;\n\n\t\tif ( deltaAngle < Number.EPSILON ) {\n\n\t\t\tif ( samePoints ) {\n\n\t\t\t\tdeltaAngle = 0;\n\n\t\t\t} else {\n\n\t\t\t\tdeltaAngle = twoPi;\n\n\t\t\t}\n\n\t\t}\n\n\t\tif ( this.aClockwise === true && ! samePoints ) {\n\n\t\t\tif ( deltaAngle === twoPi ) {\n\n\t\t\t\tdeltaAngle = - twoPi;\n\n\t\t\t} else {\n\n\t\t\t\tdeltaAngle = deltaAngle - twoPi;\n\n\t\t\t}\n\n\t\t}\n\n\t\tconst angle = this.aStartAngle + t * deltaAngle;\n\t\tlet x = this.aX + this.xRadius * Math.cos( angle );\n\t\tlet y = this.aY + this.yRadius * Math.sin( angle );\n\n\t\tif ( this.aRotation !== 0 ) {\n\n\t\t\tconst cos = Math.cos( this.aRotation );\n\t\t\tconst sin = Math.sin( this.aRotation );\n\n\t\t\tconst tx = x - this.aX;\n\t\t\tconst ty = y - this.aY;\n\n\t\t\t// Rotate the point about the center of the ellipse.\n\t\t\tx = tx * cos - ty * sin + this.aX;\n\t\t\ty = tx * sin + ty * cos + this.aY;\n\n\t\t}\n\n\t\treturn point.set( x, y );\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.aX = source.aX;\n\t\tthis.aY = source.aY;\n\n\t\tthis.xRadius = source.xRadius;\n\t\tthis.yRadius = source.yRadius;\n\n\t\tthis.aStartAngle = source.aStartAngle;\n\t\tthis.aEndAngle = source.aEndAngle;\n\n\t\tthis.aClockwise = source.aClockwise;\n\n\t\tthis.aRotation = source.aRotation;\n\n\t\treturn this;\n\n\t}\n\n\ttoJSON() {\n\n\t\tconst data = super.toJSON();\n\n\t\tdata.aX = this.aX;\n\t\tdata.aY = this.aY;\n\n\t\tdata.xRadius = this.xRadius;\n\t\tdata.yRadius = this.yRadius;\n\n\t\tdata.aStartAngle = this.aStartAngle;\n\t\tdata.aEndAngle = this.aEndAngle;\n\n\t\tdata.aClockwise = this.aClockwise;\n\n\t\tdata.aRotation = this.aRotation;\n\n\t\treturn data;\n\n\t}\n\n\tfromJSON( json ) {\n\n\t\tsuper.fromJSON( json );\n\n\t\tthis.aX = json.aX;\n\t\tthis.aY = json.aY;\n\n\t\tthis.xRadius = json.xRadius;\n\t\tthis.yRadius = json.yRadius;\n\n\t\tthis.aStartAngle = json.aStartAngle;\n\t\tthis.aEndAngle = json.aEndAngle;\n\n\t\tthis.aClockwise = json.aClockwise;\n\n\t\tthis.aRotation = json.aRotation;\n\n\t\treturn this;\n\n\t}\n\n}\n\nclass ArcCurve extends EllipseCurve {\n\n\tconstructor( aX, aY, aRadius, aStartAngle, aEndAngle, aClockwise ) {\n\n\t\tsuper( aX, aY, aRadius, aRadius, aStartAngle, aEndAngle, aClockwise );\n\n\t\tthis.isArcCurve = true;\n\n\t\tthis.type = 'ArcCurve';\n\n\t}\n\n}\n\n/**\n * Centripetal CatmullRom Curve - which is useful for avoiding\n * cusps and self-intersections in non-uniform catmull rom curves.\n * http://www.cemyuksel.com/research/catmullrom_param/catmullrom.pdf\n *\n * curve.type accepts centripetal(default), chordal and catmullrom\n * curve.tension is used for catmullrom which defaults to 0.5\n */\n\n\n/*\nBased on an optimized c++ solution in\n - http://stackoverflow.com/questions/9489736/catmull-rom-curve-with-no-cusps-and-no-self-intersections/\n - http://ideone.com/NoEbVM\n\nThis CubicPoly class could be used for reusing some variables and calculations,\nbut for three.js curve use, it could be possible inlined and flatten into a single function call\nwhich can be placed in CurveUtils.\n*/\n\nfunction CubicPoly() {\n\n\tlet c0 = 0, c1 = 0, c2 = 0, c3 = 0;\n\n\t/*\n\t * Compute coefficients for a cubic polynomial\n\t * p(s) = c0 + c1*s + c2*s^2 + c3*s^3\n\t * such that\n\t * p(0) = x0, p(1) = x1\n\t * and\n\t * p'(0) = t0, p'(1) = t1.\n\t */\n\tfunction init( x0, x1, t0, t1 ) {\n\n\t\tc0 = x0;\n\t\tc1 = t0;\n\t\tc2 = - 3 * x0 + 3 * x1 - 2 * t0 - t1;\n\t\tc3 = 2 * x0 - 2 * x1 + t0 + t1;\n\n\t}\n\n\treturn {\n\n\t\tinitCatmullRom: function ( x0, x1, x2, x3, tension ) {\n\n\t\t\tinit( x1, x2, tension * ( x2 - x0 ), tension * ( x3 - x1 ) );\n\n\t\t},\n\n\t\tinitNonuniformCatmullRom: function ( x0, x1, x2, x3, dt0, dt1, dt2 ) {\n\n\t\t\t// compute tangents when parameterized in [t1,t2]\n\t\t\tlet t1 = ( x1 - x0 ) / dt0 - ( x2 - x0 ) / ( dt0 + dt1 ) + ( x2 - x1 ) / dt1;\n\t\t\tlet t2 = ( x2 - x1 ) / dt1 - ( x3 - x1 ) / ( dt1 + dt2 ) + ( x3 - x2 ) / dt2;\n\n\t\t\t// rescale tangents for parametrization in [0,1]\n\t\t\tt1 *= dt1;\n\t\t\tt2 *= dt1;\n\n\t\t\tinit( x1, x2, t1, t2 );\n\n\t\t},\n\n\t\tcalc: function ( t ) {\n\n\t\t\tconst t2 = t * t;\n\t\t\tconst t3 = t2 * t;\n\t\t\treturn c0 + c1 * t + c2 * t2 + c3 * t3;\n\n\t\t}\n\n\t};\n\n}\n\n//\n\nconst tmp = /*@__PURE__*/ new Vector3();\nconst px = /*@__PURE__*/ new CubicPoly();\nconst py = /*@__PURE__*/ new CubicPoly();\nconst pz = /*@__PURE__*/ new CubicPoly();\n\nclass CatmullRomCurve3 extends Curve {\n\n\tconstructor( points = [], closed = false, curveType = 'centripetal', tension = 0.5 ) {\n\n\t\tsuper();\n\n\t\tthis.isCatmullRomCurve3 = true;\n\n\t\tthis.type = 'CatmullRomCurve3';\n\n\t\tthis.points = points;\n\t\tthis.closed = closed;\n\t\tthis.curveType = curveType;\n\t\tthis.tension = tension;\n\n\t}\n\n\tgetPoint( t, optionalTarget = new Vector3() ) {\n\n\t\tconst point = optionalTarget;\n\n\t\tconst points = this.points;\n\t\tconst l = points.length;\n\n\t\tconst p = ( l - ( this.closed ? 0 : 1 ) ) * t;\n\t\tlet intPoint = Math.floor( p );\n\t\tlet weight = p - intPoint;\n\n\t\tif ( this.closed ) {\n\n\t\t\tintPoint += intPoint > 0 ? 0 : ( Math.floor( Math.abs( intPoint ) / l ) + 1 ) * l;\n\n\t\t} else if ( weight === 0 && intPoint === l - 1 ) {\n\n\t\t\tintPoint = l - 2;\n\t\t\tweight = 1;\n\n\t\t}\n\n\t\tlet p0, p3; // 4 points (p1 & p2 defined below)\n\n\t\tif ( this.closed || intPoint > 0 ) {\n\n\t\t\tp0 = points[ ( intPoint - 1 ) % l ];\n\n\t\t} else {\n\n\t\t\t// extrapolate first point\n\t\t\ttmp.subVectors( points[ 0 ], points[ 1 ] ).add( points[ 0 ] );\n\t\t\tp0 = tmp;\n\n\t\t}\n\n\t\tconst p1 = points[ intPoint % l ];\n\t\tconst p2 = points[ ( intPoint + 1 ) % l ];\n\n\t\tif ( this.closed || intPoint + 2 < l ) {\n\n\t\t\tp3 = points[ ( intPoint + 2 ) % l ];\n\n\t\t} else {\n\n\t\t\t// extrapolate last point\n\t\t\ttmp.subVectors( points[ l - 1 ], points[ l - 2 ] ).add( points[ l - 1 ] );\n\t\t\tp3 = tmp;\n\n\t\t}\n\n\t\tif ( this.curveType === 'centripetal' || this.curveType === 'chordal' ) {\n\n\t\t\t// init Centripetal / Chordal Catmull-Rom\n\t\t\tconst pow = this.curveType === 'chordal' ? 0.5 : 0.25;\n\t\t\tlet dt0 = Math.pow( p0.distanceToSquared( p1 ), pow );\n\t\t\tlet dt1 = Math.pow( p1.distanceToSquared( p2 ), pow );\n\t\t\tlet dt2 = Math.pow( p2.distanceToSquared( p3 ), pow );\n\n\t\t\t// safety check for repeated points\n\t\t\tif ( dt1 < 1e-4 ) dt1 = 1.0;\n\t\t\tif ( dt0 < 1e-4 ) dt0 = dt1;\n\t\t\tif ( dt2 < 1e-4 ) dt2 = dt1;\n\n\t\t\tpx.initNonuniformCatmullRom( p0.x, p1.x, p2.x, p3.x, dt0, dt1, dt2 );\n\t\t\tpy.initNonuniformCatmullRom( p0.y, p1.y, p2.y, p3.y, dt0, dt1, dt2 );\n\t\t\tpz.initNonuniformCatmullRom( p0.z, p1.z, p2.z, p3.z, dt0, dt1, dt2 );\n\n\t\t} else if ( this.curveType === 'catmullrom' ) {\n\n\t\t\tpx.initCatmullRom( p0.x, p1.x, p2.x, p3.x, this.tension );\n\t\t\tpy.initCatmullRom( p0.y, p1.y, p2.y, p3.y, this.tension );\n\t\t\tpz.initCatmullRom( p0.z, p1.z, p2.z, p3.z, this.tension );\n\n\t\t}\n\n\t\tpoint.set(\n\t\t\tpx.calc( weight ),\n\t\t\tpy.calc( weight ),\n\t\t\tpz.calc( weight )\n\t\t);\n\n\t\treturn point;\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.points = [];\n\n\t\tfor ( let i = 0, l = source.points.length; i < l; i ++ ) {\n\n\t\t\tconst point = source.points[ i ];\n\n\t\t\tthis.points.push( point.clone() );\n\n\t\t}\n\n\t\tthis.closed = source.closed;\n\t\tthis.curveType = source.curveType;\n\t\tthis.tension = source.tension;\n\n\t\treturn this;\n\n\t}\n\n\ttoJSON() {\n\n\t\tconst data = super.toJSON();\n\n\t\tdata.points = [];\n\n\t\tfor ( let i = 0, l = this.points.length; i < l; i ++ ) {\n\n\t\t\tconst point = this.points[ i ];\n\t\t\tdata.points.push( point.toArray() );\n\n\t\t}\n\n\t\tdata.closed = this.closed;\n\t\tdata.curveType = this.curveType;\n\t\tdata.tension = this.tension;\n\n\t\treturn data;\n\n\t}\n\n\tfromJSON( json ) {\n\n\t\tsuper.fromJSON( json );\n\n\t\tthis.points = [];\n\n\t\tfor ( let i = 0, l = json.points.length; i < l; i ++ ) {\n\n\t\t\tconst point = json.points[ i ];\n\t\t\tthis.points.push( new Vector3().fromArray( point ) );\n\n\t\t}\n\n\t\tthis.closed = json.closed;\n\t\tthis.curveType = json.curveType;\n\t\tthis.tension = json.tension;\n\n\t\treturn this;\n\n\t}\n\n}\n\n/**\n * Bezier Curves formulas obtained from\n * https://en.wikipedia.org/wiki/B%C3%A9zier_curve\n */\n\nfunction CatmullRom( t, p0, p1, p2, p3 ) {\n\n\tconst v0 = ( p2 - p0 ) * 0.5;\n\tconst v1 = ( p3 - p1 ) * 0.5;\n\tconst t2 = t * t;\n\tconst t3 = t * t2;\n\treturn ( 2 * p1 - 2 * p2 + v0 + v1 ) * t3 + ( - 3 * p1 + 3 * p2 - 2 * v0 - v1 ) * t2 + v0 * t + p1;\n\n}\n\n//\n\nfunction QuadraticBezierP0( t, p ) {\n\n\tconst k = 1 - t;\n\treturn k * k * p;\n\n}\n\nfunction QuadraticBezierP1( t, p ) {\n\n\treturn 2 * ( 1 - t ) * t * p;\n\n}\n\nfunction QuadraticBezierP2( t, p ) {\n\n\treturn t * t * p;\n\n}\n\nfunction QuadraticBezier( t, p0, p1, p2 ) {\n\n\treturn QuadraticBezierP0( t, p0 ) + QuadraticBezierP1( t, p1 ) +\n\t\tQuadraticBezierP2( t, p2 );\n\n}\n\n//\n\nfunction CubicBezierP0( t, p ) {\n\n\tconst k = 1 - t;\n\treturn k * k * k * p;\n\n}\n\nfunction CubicBezierP1( t, p ) {\n\n\tconst k = 1 - t;\n\treturn 3 * k * k * t * p;\n\n}\n\nfunction CubicBezierP2( t, p ) {\n\n\treturn 3 * ( 1 - t ) * t * t * p;\n\n}\n\nfunction CubicBezierP3( t, p ) {\n\n\treturn t * t * t * p;\n\n}\n\nfunction CubicBezier( t, p0, p1, p2, p3 ) {\n\n\treturn CubicBezierP0( t, p0 ) + CubicBezierP1( t, p1 ) + CubicBezierP2( t, p2 ) +\n\t\tCubicBezierP3( t, p3 );\n\n}\n\nclass CubicBezierCurve extends Curve {\n\n\tconstructor( v0 = new Vector2(), v1 = new Vector2(), v2 = new Vector2(), v3 = new Vector2() ) {\n\n\t\tsuper();\n\n\t\tthis.isCubicBezierCurve = true;\n\n\t\tthis.type = 'CubicBezierCurve';\n\n\t\tthis.v0 = v0;\n\t\tthis.v1 = v1;\n\t\tthis.v2 = v2;\n\t\tthis.v3 = v3;\n\n\t}\n\n\tgetPoint( t, optionalTarget = new Vector2() ) {\n\n\t\tconst point = optionalTarget;\n\n\t\tconst v0 = this.v0, v1 = this.v1, v2 = this.v2, v3 = this.v3;\n\n\t\tpoint.set(\n\t\t\tCubicBezier( t, v0.x, v1.x, v2.x, v3.x ),\n\t\t\tCubicBezier( t, v0.y, v1.y, v2.y, v3.y )\n\t\t);\n\n\t\treturn point;\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.v0.copy( source.v0 );\n\t\tthis.v1.copy( source.v1 );\n\t\tthis.v2.copy( source.v2 );\n\t\tthis.v3.copy( source.v3 );\n\n\t\treturn this;\n\n\t}\n\n\ttoJSON() {\n\n\t\tconst data = super.toJSON();\n\n\t\tdata.v0 = this.v0.toArray();\n\t\tdata.v1 = this.v1.toArray();\n\t\tdata.v2 = this.v2.toArray();\n\t\tdata.v3 = this.v3.toArray();\n\n\t\treturn data;\n\n\t}\n\n\tfromJSON( json ) {\n\n\t\tsuper.fromJSON( json );\n\n\t\tthis.v0.fromArray( json.v0 );\n\t\tthis.v1.fromArray( json.v1 );\n\t\tthis.v2.fromArray( json.v2 );\n\t\tthis.v3.fromArray( json.v3 );\n\n\t\treturn this;\n\n\t}\n\n}\n\nclass CubicBezierCurve3 extends Curve {\n\n\tconstructor( v0 = new Vector3(), v1 = new Vector3(), v2 = new Vector3(), v3 = new Vector3() ) {\n\n\t\tsuper();\n\n\t\tthis.isCubicBezierCurve3 = true;\n\n\t\tthis.type = 'CubicBezierCurve3';\n\n\t\tthis.v0 = v0;\n\t\tthis.v1 = v1;\n\t\tthis.v2 = v2;\n\t\tthis.v3 = v3;\n\n\t}\n\n\tgetPoint( t, optionalTarget = new Vector3() ) {\n\n\t\tconst point = optionalTarget;\n\n\t\tconst v0 = this.v0, v1 = this.v1, v2 = this.v2, v3 = this.v3;\n\n\t\tpoint.set(\n\t\t\tCubicBezier( t, v0.x, v1.x, v2.x, v3.x ),\n\t\t\tCubicBezier( t, v0.y, v1.y, v2.y, v3.y ),\n\t\t\tCubicBezier( t, v0.z, v1.z, v2.z, v3.z )\n\t\t);\n\n\t\treturn point;\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.v0.copy( source.v0 );\n\t\tthis.v1.copy( source.v1 );\n\t\tthis.v2.copy( source.v2 );\n\t\tthis.v3.copy( source.v3 );\n\n\t\treturn this;\n\n\t}\n\n\ttoJSON() {\n\n\t\tconst data = super.toJSON();\n\n\t\tdata.v0 = this.v0.toArray();\n\t\tdata.v1 = this.v1.toArray();\n\t\tdata.v2 = this.v2.toArray();\n\t\tdata.v3 = this.v3.toArray();\n\n\t\treturn data;\n\n\t}\n\n\tfromJSON( json ) {\n\n\t\tsuper.fromJSON( json );\n\n\t\tthis.v0.fromArray( json.v0 );\n\t\tthis.v1.fromArray( json.v1 );\n\t\tthis.v2.fromArray( json.v2 );\n\t\tthis.v3.fromArray( json.v3 );\n\n\t\treturn this;\n\n\t}\n\n}\n\nclass LineCurve extends Curve {\n\n\tconstructor( v1 = new Vector2(), v2 = new Vector2() ) {\n\n\t\tsuper();\n\n\t\tthis.isLineCurve = true;\n\n\t\tthis.type = 'LineCurve';\n\n\t\tthis.v1 = v1;\n\t\tthis.v2 = v2;\n\n\t}\n\n\tgetPoint( t, optionalTarget = new Vector2() ) {\n\n\t\tconst point = optionalTarget;\n\n\t\tif ( t === 1 ) {\n\n\t\t\tpoint.copy( this.v2 );\n\n\t\t} else {\n\n\t\t\tpoint.copy( this.v2 ).sub( this.v1 );\n\t\t\tpoint.multiplyScalar( t ).add( this.v1 );\n\n\t\t}\n\n\t\treturn point;\n\n\t}\n\n\t// Line curve is linear, so we can overwrite default getPointAt\n\tgetPointAt( u, optionalTarget ) {\n\n\t\treturn this.getPoint( u, optionalTarget );\n\n\t}\n\n\tgetTangent( t, optionalTarget = new Vector2() ) {\n\n\t\treturn optionalTarget.subVectors( this.v2, this.v1 ).normalize();\n\n\t}\n\n\tgetTangentAt( u, optionalTarget ) {\n\n\t\treturn this.getTangent( u, optionalTarget );\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.v1.copy( source.v1 );\n\t\tthis.v2.copy( source.v2 );\n\n\t\treturn this;\n\n\t}\n\n\ttoJSON() {\n\n\t\tconst data = super.toJSON();\n\n\t\tdata.v1 = this.v1.toArray();\n\t\tdata.v2 = this.v2.toArray();\n\n\t\treturn data;\n\n\t}\n\n\tfromJSON( json ) {\n\n\t\tsuper.fromJSON( json );\n\n\t\tthis.v1.fromArray( json.v1 );\n\t\tthis.v2.fromArray( json.v2 );\n\n\t\treturn this;\n\n\t}\n\n}\n\nclass LineCurve3 extends Curve {\n\n\tconstructor( v1 = new Vector3(), v2 = new Vector3() ) {\n\n\t\tsuper();\n\n\t\tthis.isLineCurve3 = true;\n\n\t\tthis.type = 'LineCurve3';\n\n\t\tthis.v1 = v1;\n\t\tthis.v2 = v2;\n\n\t}\n\n\tgetPoint( t, optionalTarget = new Vector3() ) {\n\n\t\tconst point = optionalTarget;\n\n\t\tif ( t === 1 ) {\n\n\t\t\tpoint.copy( this.v2 );\n\n\t\t} else {\n\n\t\t\tpoint.copy( this.v2 ).sub( this.v1 );\n\t\t\tpoint.multiplyScalar( t ).add( this.v1 );\n\n\t\t}\n\n\t\treturn point;\n\n\t}\n\n\t// Line curve is linear, so we can overwrite default getPointAt\n\tgetPointAt( u, optionalTarget ) {\n\n\t\treturn this.getPoint( u, optionalTarget );\n\n\t}\n\n\tgetTangent( t, optionalTarget = new Vector3() ) {\n\n\t\treturn optionalTarget.subVectors( this.v2, this.v1 ).normalize();\n\n\t}\n\n\tgetTangentAt( u, optionalTarget ) {\n\n\t\treturn this.getTangent( u, optionalTarget );\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.v1.copy( source.v1 );\n\t\tthis.v2.copy( source.v2 );\n\n\t\treturn this;\n\n\t}\n\n\ttoJSON() {\n\n\t\tconst data = super.toJSON();\n\n\t\tdata.v1 = this.v1.toArray();\n\t\tdata.v2 = this.v2.toArray();\n\n\t\treturn data;\n\n\t}\n\n\tfromJSON( json ) {\n\n\t\tsuper.fromJSON( json );\n\n\t\tthis.v1.fromArray( json.v1 );\n\t\tthis.v2.fromArray( json.v2 );\n\n\t\treturn this;\n\n\t}\n\n}\n\nclass QuadraticBezierCurve extends Curve {\n\n\tconstructor( v0 = new Vector2(), v1 = new Vector2(), v2 = new Vector2() ) {\n\n\t\tsuper();\n\n\t\tthis.isQuadraticBezierCurve = true;\n\n\t\tthis.type = 'QuadraticBezierCurve';\n\n\t\tthis.v0 = v0;\n\t\tthis.v1 = v1;\n\t\tthis.v2 = v2;\n\n\t}\n\n\tgetPoint( t, optionalTarget = new Vector2() ) {\n\n\t\tconst point = optionalTarget;\n\n\t\tconst v0 = this.v0, v1 = this.v1, v2 = this.v2;\n\n\t\tpoint.set(\n\t\t\tQuadraticBezier( t, v0.x, v1.x, v2.x ),\n\t\t\tQuadraticBezier( t, v0.y, v1.y, v2.y )\n\t\t);\n\n\t\treturn point;\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.v0.copy( source.v0 );\n\t\tthis.v1.copy( source.v1 );\n\t\tthis.v2.copy( source.v2 );\n\n\t\treturn this;\n\n\t}\n\n\ttoJSON() {\n\n\t\tconst data = super.toJSON();\n\n\t\tdata.v0 = this.v0.toArray();\n\t\tdata.v1 = this.v1.toArray();\n\t\tdata.v2 = this.v2.toArray();\n\n\t\treturn data;\n\n\t}\n\n\tfromJSON( json ) {\n\n\t\tsuper.fromJSON( json );\n\n\t\tthis.v0.fromArray( json.v0 );\n\t\tthis.v1.fromArray( json.v1 );\n\t\tthis.v2.fromArray( json.v2 );\n\n\t\treturn this;\n\n\t}\n\n}\n\nclass QuadraticBezierCurve3 extends Curve {\n\n\tconstructor( v0 = new Vector3(), v1 = new Vector3(), v2 = new Vector3() ) {\n\n\t\tsuper();\n\n\t\tthis.isQuadraticBezierCurve3 = true;\n\n\t\tthis.type = 'QuadraticBezierCurve3';\n\n\t\tthis.v0 = v0;\n\t\tthis.v1 = v1;\n\t\tthis.v2 = v2;\n\n\t}\n\n\tgetPoint( t, optionalTarget = new Vector3() ) {\n\n\t\tconst point = optionalTarget;\n\n\t\tconst v0 = this.v0, v1 = this.v1, v2 = this.v2;\n\n\t\tpoint.set(\n\t\t\tQuadraticBezier( t, v0.x, v1.x, v2.x ),\n\t\t\tQuadraticBezier( t, v0.y, v1.y, v2.y ),\n\t\t\tQuadraticBezier( t, v0.z, v1.z, v2.z )\n\t\t);\n\n\t\treturn point;\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.v0.copy( source.v0 );\n\t\tthis.v1.copy( source.v1 );\n\t\tthis.v2.copy( source.v2 );\n\n\t\treturn this;\n\n\t}\n\n\ttoJSON() {\n\n\t\tconst data = super.toJSON();\n\n\t\tdata.v0 = this.v0.toArray();\n\t\tdata.v1 = this.v1.toArray();\n\t\tdata.v2 = this.v2.toArray();\n\n\t\treturn data;\n\n\t}\n\n\tfromJSON( json ) {\n\n\t\tsuper.fromJSON( json );\n\n\t\tthis.v0.fromArray( json.v0 );\n\t\tthis.v1.fromArray( json.v1 );\n\t\tthis.v2.fromArray( json.v2 );\n\n\t\treturn this;\n\n\t}\n\n}\n\nclass SplineCurve extends Curve {\n\n\tconstructor( points = [] ) {\n\n\t\tsuper();\n\n\t\tthis.isSplineCurve = true;\n\n\t\tthis.type = 'SplineCurve';\n\n\t\tthis.points = points;\n\n\t}\n\n\tgetPoint( t, optionalTarget = new Vector2() ) {\n\n\t\tconst point = optionalTarget;\n\n\t\tconst points = this.points;\n\t\tconst p = ( points.length - 1 ) * t;\n\n\t\tconst intPoint = Math.floor( p );\n\t\tconst weight = p - intPoint;\n\n\t\tconst p0 = points[ intPoint === 0 ? intPoint : intPoint - 1 ];\n\t\tconst p1 = points[ intPoint ];\n\t\tconst p2 = points[ intPoint > points.length - 2 ? points.length - 1 : intPoint + 1 ];\n\t\tconst p3 = points[ intPoint > points.length - 3 ? points.length - 1 : intPoint + 2 ];\n\n\t\tpoint.set(\n\t\t\tCatmullRom( weight, p0.x, p1.x, p2.x, p3.x ),\n\t\t\tCatmullRom( weight, p0.y, p1.y, p2.y, p3.y )\n\t\t);\n\n\t\treturn point;\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.points = [];\n\n\t\tfor ( let i = 0, l = source.points.length; i < l; i ++ ) {\n\n\t\t\tconst point = source.points[ i ];\n\n\t\t\tthis.points.push( point.clone() );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\ttoJSON() {\n\n\t\tconst data = super.toJSON();\n\n\t\tdata.points = [];\n\n\t\tfor ( let i = 0, l = this.points.length; i < l; i ++ ) {\n\n\t\t\tconst point = this.points[ i ];\n\t\t\tdata.points.push( point.toArray() );\n\n\t\t}\n\n\t\treturn data;\n\n\t}\n\n\tfromJSON( json ) {\n\n\t\tsuper.fromJSON( json );\n\n\t\tthis.points = [];\n\n\t\tfor ( let i = 0, l = json.points.length; i < l; i ++ ) {\n\n\t\t\tconst point = json.points[ i ];\n\t\t\tthis.points.push( new Vector2().fromArray( point ) );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n}\n\nvar Curves = /*#__PURE__*/Object.freeze({\n\t__proto__: null,\n\tArcCurve: ArcCurve,\n\tCatmullRomCurve3: CatmullRomCurve3,\n\tCubicBezierCurve: CubicBezierCurve,\n\tCubicBezierCurve3: CubicBezierCurve3,\n\tEllipseCurve: EllipseCurve,\n\tLineCurve: LineCurve,\n\tLineCurve3: LineCurve3,\n\tQuadraticBezierCurve: QuadraticBezierCurve,\n\tQuadraticBezierCurve3: QuadraticBezierCurve3,\n\tSplineCurve: SplineCurve\n});\n\n/**************************************************************\n *\tCurved Path - a curve path is simply a array of connected\n * curves, but retains the api of a curve\n **************************************************************/\n\nclass CurvePath extends Curve {\n\n\tconstructor() {\n\n\t\tsuper();\n\n\t\tthis.type = 'CurvePath';\n\n\t\tthis.curves = [];\n\t\tthis.autoClose = false; // Automatically closes the path\n\n\t}\n\n\tadd( curve ) {\n\n\t\tthis.curves.push( curve );\n\n\t}\n\n\tclosePath() {\n\n\t\t// Add a line curve if start and end of lines are not connected\n\t\tconst startPoint = this.curves[ 0 ].getPoint( 0 );\n\t\tconst endPoint = this.curves[ this.curves.length - 1 ].getPoint( 1 );\n\n\t\tif ( ! startPoint.equals( endPoint ) ) {\n\n\t\t\tconst lineType = ( startPoint.isVector2 === true ) ? 'LineCurve' : 'LineCurve3';\n\t\t\tthis.curves.push( new Curves[ lineType ]( endPoint, startPoint ) );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\t// To get accurate point with reference to\n\t// entire path distance at time t,\n\t// following has to be done:\n\n\t// 1. Length of each sub path have to be known\n\t// 2. Locate and identify type of curve\n\t// 3. Get t for the curve\n\t// 4. Return curve.getPointAt(t')\n\n\tgetPoint( t, optionalTarget ) {\n\n\t\tconst d = t * this.getLength();\n\t\tconst curveLengths = this.getCurveLengths();\n\t\tlet i = 0;\n\n\t\t// To think about boundaries points.\n\n\t\twhile ( i < curveLengths.length ) {\n\n\t\t\tif ( curveLengths[ i ] >= d ) {\n\n\t\t\t\tconst diff = curveLengths[ i ] - d;\n\t\t\t\tconst curve = this.curves[ i ];\n\n\t\t\t\tconst segmentLength = curve.getLength();\n\t\t\t\tconst u = segmentLength === 0 ? 0 : 1 - diff / segmentLength;\n\n\t\t\t\treturn curve.getPointAt( u, optionalTarget );\n\n\t\t\t}\n\n\t\t\ti ++;\n\n\t\t}\n\n\t\treturn null;\n\n\t\t// loop where sum != 0, sum > d , sum+1 1 && ! points[ points.length - 1 ].equals( points[ 0 ] ) ) {\n\n\t\t\tpoints.push( points[ 0 ] );\n\n\t\t}\n\n\t\treturn points;\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.curves = [];\n\n\t\tfor ( let i = 0, l = source.curves.length; i < l; i ++ ) {\n\n\t\t\tconst curve = source.curves[ i ];\n\n\t\t\tthis.curves.push( curve.clone() );\n\n\t\t}\n\n\t\tthis.autoClose = source.autoClose;\n\n\t\treturn this;\n\n\t}\n\n\ttoJSON() {\n\n\t\tconst data = super.toJSON();\n\n\t\tdata.autoClose = this.autoClose;\n\t\tdata.curves = [];\n\n\t\tfor ( let i = 0, l = this.curves.length; i < l; i ++ ) {\n\n\t\t\tconst curve = this.curves[ i ];\n\t\t\tdata.curves.push( curve.toJSON() );\n\n\t\t}\n\n\t\treturn data;\n\n\t}\n\n\tfromJSON( json ) {\n\n\t\tsuper.fromJSON( json );\n\n\t\tthis.autoClose = json.autoClose;\n\t\tthis.curves = [];\n\n\t\tfor ( let i = 0, l = json.curves.length; i < l; i ++ ) {\n\n\t\t\tconst curve = json.curves[ i ];\n\t\t\tthis.curves.push( new Curves[ curve.type ]().fromJSON( curve ) );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n}\n\nclass Path extends CurvePath {\n\n\tconstructor( points ) {\n\n\t\tsuper();\n\n\t\tthis.type = 'Path';\n\n\t\tthis.currentPoint = new Vector2();\n\n\t\tif ( points ) {\n\n\t\t\tthis.setFromPoints( points );\n\n\t\t}\n\n\t}\n\n\tsetFromPoints( points ) {\n\n\t\tthis.moveTo( points[ 0 ].x, points[ 0 ].y );\n\n\t\tfor ( let i = 1, l = points.length; i < l; i ++ ) {\n\n\t\t\tthis.lineTo( points[ i ].x, points[ i ].y );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tmoveTo( x, y ) {\n\n\t\tthis.currentPoint.set( x, y ); // TODO consider referencing vectors instead of copying?\n\n\t\treturn this;\n\n\t}\n\n\tlineTo( x, y ) {\n\n\t\tconst curve = new LineCurve( this.currentPoint.clone(), new Vector2( x, y ) );\n\t\tthis.curves.push( curve );\n\n\t\tthis.currentPoint.set( x, y );\n\n\t\treturn this;\n\n\t}\n\n\tquadraticCurveTo( aCPx, aCPy, aX, aY ) {\n\n\t\tconst curve = new QuadraticBezierCurve(\n\t\t\tthis.currentPoint.clone(),\n\t\t\tnew Vector2( aCPx, aCPy ),\n\t\t\tnew Vector2( aX, aY )\n\t\t);\n\n\t\tthis.curves.push( curve );\n\n\t\tthis.currentPoint.set( aX, aY );\n\n\t\treturn this;\n\n\t}\n\n\tbezierCurveTo( aCP1x, aCP1y, aCP2x, aCP2y, aX, aY ) {\n\n\t\tconst curve = new CubicBezierCurve(\n\t\t\tthis.currentPoint.clone(),\n\t\t\tnew Vector2( aCP1x, aCP1y ),\n\t\t\tnew Vector2( aCP2x, aCP2y ),\n\t\t\tnew Vector2( aX, aY )\n\t\t);\n\n\t\tthis.curves.push( curve );\n\n\t\tthis.currentPoint.set( aX, aY );\n\n\t\treturn this;\n\n\t}\n\n\tsplineThru( pts /*Array of Vector*/ ) {\n\n\t\tconst npts = [ this.currentPoint.clone() ].concat( pts );\n\n\t\tconst curve = new SplineCurve( npts );\n\t\tthis.curves.push( curve );\n\n\t\tthis.currentPoint.copy( pts[ pts.length - 1 ] );\n\n\t\treturn this;\n\n\t}\n\n\tarc( aX, aY, aRadius, aStartAngle, aEndAngle, aClockwise ) {\n\n\t\tconst x0 = this.currentPoint.x;\n\t\tconst y0 = this.currentPoint.y;\n\n\t\tthis.absarc( aX + x0, aY + y0, aRadius,\n\t\t\taStartAngle, aEndAngle, aClockwise );\n\n\t\treturn this;\n\n\t}\n\n\tabsarc( aX, aY, aRadius, aStartAngle, aEndAngle, aClockwise ) {\n\n\t\tthis.absellipse( aX, aY, aRadius, aRadius, aStartAngle, aEndAngle, aClockwise );\n\n\t\treturn this;\n\n\t}\n\n\tellipse( aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation ) {\n\n\t\tconst x0 = this.currentPoint.x;\n\t\tconst y0 = this.currentPoint.y;\n\n\t\tthis.absellipse( aX + x0, aY + y0, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation );\n\n\t\treturn this;\n\n\t}\n\n\tabsellipse( aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation ) {\n\n\t\tconst curve = new EllipseCurve( aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation );\n\n\t\tif ( this.curves.length > 0 ) {\n\n\t\t\t// if a previous curve is present, attempt to join\n\t\t\tconst firstPoint = curve.getPoint( 0 );\n\n\t\t\tif ( ! firstPoint.equals( this.currentPoint ) ) {\n\n\t\t\t\tthis.lineTo( firstPoint.x, firstPoint.y );\n\n\t\t\t}\n\n\t\t}\n\n\t\tthis.curves.push( curve );\n\n\t\tconst lastPoint = curve.getPoint( 1 );\n\t\tthis.currentPoint.copy( lastPoint );\n\n\t\treturn this;\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.currentPoint.copy( source.currentPoint );\n\n\t\treturn this;\n\n\t}\n\n\ttoJSON() {\n\n\t\tconst data = super.toJSON();\n\n\t\tdata.currentPoint = this.currentPoint.toArray();\n\n\t\treturn data;\n\n\t}\n\n\tfromJSON( json ) {\n\n\t\tsuper.fromJSON( json );\n\n\t\tthis.currentPoint.fromArray( json.currentPoint );\n\n\t\treturn this;\n\n\t}\n\n}\n\nclass LatheGeometry extends BufferGeometry {\n\n\tconstructor( points = [ new Vector2( 0, - 0.5 ), new Vector2( 0.5, 0 ), new Vector2( 0, 0.5 ) ], segments = 12, phiStart = 0, phiLength = Math.PI * 2 ) {\n\n\t\tsuper();\n\n\t\tthis.type = 'LatheGeometry';\n\n\t\tthis.parameters = {\n\t\t\tpoints: points,\n\t\t\tsegments: segments,\n\t\t\tphiStart: phiStart,\n\t\t\tphiLength: phiLength\n\t\t};\n\n\t\tsegments = Math.floor( segments );\n\n\t\t// clamp phiLength so it's in range of [ 0, 2PI ]\n\n\t\tphiLength = clamp( phiLength, 0, Math.PI * 2 );\n\n\t\t// buffers\n\n\t\tconst indices = [];\n\t\tconst vertices = [];\n\t\tconst uvs = [];\n\t\tconst initNormals = [];\n\t\tconst normals = [];\n\n\t\t// helper variables\n\n\t\tconst inverseSegments = 1.0 / segments;\n\t\tconst vertex = new Vector3();\n\t\tconst uv = new Vector2();\n\t\tconst normal = new Vector3();\n\t\tconst curNormal = new Vector3();\n\t\tconst prevNormal = new Vector3();\n\t\tlet dx = 0;\n\t\tlet dy = 0;\n\n\t\t// pre-compute normals for initial \"meridian\"\n\n\t\tfor ( let j = 0; j <= ( points.length - 1 ); j ++ ) {\n\n\t\t\tswitch ( j ) {\n\n\t\t\t\tcase 0:\t\t\t\t// special handling for 1st vertex on path\n\n\t\t\t\t\tdx = points[ j + 1 ].x - points[ j ].x;\n\t\t\t\t\tdy = points[ j + 1 ].y - points[ j ].y;\n\n\t\t\t\t\tnormal.x = dy * 1.0;\n\t\t\t\t\tnormal.y = - dx;\n\t\t\t\t\tnormal.z = dy * 0.0;\n\n\t\t\t\t\tprevNormal.copy( normal );\n\n\t\t\t\t\tnormal.normalize();\n\n\t\t\t\t\tinitNormals.push( normal.x, normal.y, normal.z );\n\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase ( points.length - 1 ):\t// special handling for last Vertex on path\n\n\t\t\t\t\tinitNormals.push( prevNormal.x, prevNormal.y, prevNormal.z );\n\n\t\t\t\t\tbreak;\n\n\t\t\t\tdefault:\t\t\t// default handling for all vertices in between\n\n\t\t\t\t\tdx = points[ j + 1 ].x - points[ j ].x;\n\t\t\t\t\tdy = points[ j + 1 ].y - points[ j ].y;\n\n\t\t\t\t\tnormal.x = dy * 1.0;\n\t\t\t\t\tnormal.y = - dx;\n\t\t\t\t\tnormal.z = dy * 0.0;\n\n\t\t\t\t\tcurNormal.copy( normal );\n\n\t\t\t\t\tnormal.x += prevNormal.x;\n\t\t\t\t\tnormal.y += prevNormal.y;\n\t\t\t\t\tnormal.z += prevNormal.z;\n\n\t\t\t\t\tnormal.normalize();\n\n\t\t\t\t\tinitNormals.push( normal.x, normal.y, normal.z );\n\n\t\t\t\t\tprevNormal.copy( curNormal );\n\n\t\t\t}\n\n\t\t}\n\n\t\t// generate vertices, uvs and normals\n\n\t\tfor ( let i = 0; i <= segments; i ++ ) {\n\n\t\t\tconst phi = phiStart + i * inverseSegments * phiLength;\n\n\t\t\tconst sin = Math.sin( phi );\n\t\t\tconst cos = Math.cos( phi );\n\n\t\t\tfor ( let j = 0; j <= ( points.length - 1 ); j ++ ) {\n\n\t\t\t\t// vertex\n\n\t\t\t\tvertex.x = points[ j ].x * sin;\n\t\t\t\tvertex.y = points[ j ].y;\n\t\t\t\tvertex.z = points[ j ].x * cos;\n\n\t\t\t\tvertices.push( vertex.x, vertex.y, vertex.z );\n\n\t\t\t\t// uv\n\n\t\t\t\tuv.x = i / segments;\n\t\t\t\tuv.y = j / ( points.length - 1 );\n\n\t\t\t\tuvs.push( uv.x, uv.y );\n\n\t\t\t\t// normal\n\n\t\t\t\tconst x = initNormals[ 3 * j + 0 ] * sin;\n\t\t\t\tconst y = initNormals[ 3 * j + 1 ];\n\t\t\t\tconst z = initNormals[ 3 * j + 0 ] * cos;\n\n\t\t\t\tnormals.push( x, y, z );\n\n\t\t\t}\n\n\t\t}\n\n\t\t// indices\n\n\t\tfor ( let i = 0; i < segments; i ++ ) {\n\n\t\t\tfor ( let j = 0; j < ( points.length - 1 ); j ++ ) {\n\n\t\t\t\tconst base = j + i * points.length;\n\n\t\t\t\tconst a = base;\n\t\t\t\tconst b = base + points.length;\n\t\t\t\tconst c = base + points.length + 1;\n\t\t\t\tconst d = base + 1;\n\n\t\t\t\t// faces\n\n\t\t\t\tindices.push( a, b, d );\n\t\t\t\tindices.push( c, d, b );\n\n\t\t\t}\n\n\t\t}\n\n\t\t// build geometry\n\n\t\tthis.setIndex( indices );\n\t\tthis.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\n\t\tthis.setAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );\n\t\tthis.setAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.parameters = Object.assign( {}, source.parameters );\n\n\t\treturn this;\n\n\t}\n\n\tstatic fromJSON( data ) {\n\n\t\treturn new LatheGeometry( data.points, data.segments, data.phiStart, data.phiLength );\n\n\t}\n\n}\n\nclass CapsuleGeometry extends LatheGeometry {\n\n\tconstructor( radius = 1, length = 1, capSegments = 4, radialSegments = 8 ) {\n\n\t\tconst path = new Path();\n\t\tpath.absarc( 0, - length / 2, radius, Math.PI * 1.5, 0 );\n\t\tpath.absarc( 0, length / 2, radius, 0, Math.PI * 0.5 );\n\n\t\tsuper( path.getPoints( capSegments ), radialSegments );\n\n\t\tthis.type = 'CapsuleGeometry';\n\n\t\tthis.parameters = {\n\t\t\tradius: radius,\n\t\t\tlength: length,\n\t\t\tcapSegments: capSegments,\n\t\t\tradialSegments: radialSegments,\n\t\t};\n\n\t}\n\n\tstatic fromJSON( data ) {\n\n\t\treturn new CapsuleGeometry( data.radius, data.length, data.capSegments, data.radialSegments );\n\n\t}\n\n}\n\nclass CircleGeometry extends BufferGeometry {\n\n\tconstructor( radius = 1, segments = 32, thetaStart = 0, thetaLength = Math.PI * 2 ) {\n\n\t\tsuper();\n\n\t\tthis.type = 'CircleGeometry';\n\n\t\tthis.parameters = {\n\t\t\tradius: radius,\n\t\t\tsegments: segments,\n\t\t\tthetaStart: thetaStart,\n\t\t\tthetaLength: thetaLength\n\t\t};\n\n\t\tsegments = Math.max( 3, segments );\n\n\t\t// buffers\n\n\t\tconst indices = [];\n\t\tconst vertices = [];\n\t\tconst normals = [];\n\t\tconst uvs = [];\n\n\t\t// helper variables\n\n\t\tconst vertex = new Vector3();\n\t\tconst uv = new Vector2();\n\n\t\t// center point\n\n\t\tvertices.push( 0, 0, 0 );\n\t\tnormals.push( 0, 0, 1 );\n\t\tuvs.push( 0.5, 0.5 );\n\n\t\tfor ( let s = 0, i = 3; s <= segments; s ++, i += 3 ) {\n\n\t\t\tconst segment = thetaStart + s / segments * thetaLength;\n\n\t\t\t// vertex\n\n\t\t\tvertex.x = radius * Math.cos( segment );\n\t\t\tvertex.y = radius * Math.sin( segment );\n\n\t\t\tvertices.push( vertex.x, vertex.y, vertex.z );\n\n\t\t\t// normal\n\n\t\t\tnormals.push( 0, 0, 1 );\n\n\t\t\t// uvs\n\n\t\t\tuv.x = ( vertices[ i ] / radius + 1 ) / 2;\n\t\t\tuv.y = ( vertices[ i + 1 ] / radius + 1 ) / 2;\n\n\t\t\tuvs.push( uv.x, uv.y );\n\n\t\t}\n\n\t\t// indices\n\n\t\tfor ( let i = 1; i <= segments; i ++ ) {\n\n\t\t\tindices.push( i, i + 1, 0 );\n\n\t\t}\n\n\t\t// build geometry\n\n\t\tthis.setIndex( indices );\n\t\tthis.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\n\t\tthis.setAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );\n\t\tthis.setAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.parameters = Object.assign( {}, source.parameters );\n\n\t\treturn this;\n\n\t}\n\n\tstatic fromJSON( data ) {\n\n\t\treturn new CircleGeometry( data.radius, data.segments, data.thetaStart, data.thetaLength );\n\n\t}\n\n}\n\nclass CylinderGeometry extends BufferGeometry {\n\n\tconstructor( radiusTop = 1, radiusBottom = 1, height = 1, radialSegments = 32, heightSegments = 1, openEnded = false, thetaStart = 0, thetaLength = Math.PI * 2 ) {\n\n\t\tsuper();\n\n\t\tthis.type = 'CylinderGeometry';\n\n\t\tthis.parameters = {\n\t\t\tradiusTop: radiusTop,\n\t\t\tradiusBottom: radiusBottom,\n\t\t\theight: height,\n\t\t\tradialSegments: radialSegments,\n\t\t\theightSegments: heightSegments,\n\t\t\topenEnded: openEnded,\n\t\t\tthetaStart: thetaStart,\n\t\t\tthetaLength: thetaLength\n\t\t};\n\n\t\tconst scope = this;\n\n\t\tradialSegments = Math.floor( radialSegments );\n\t\theightSegments = Math.floor( heightSegments );\n\n\t\t// buffers\n\n\t\tconst indices = [];\n\t\tconst vertices = [];\n\t\tconst normals = [];\n\t\tconst uvs = [];\n\n\t\t// helper variables\n\n\t\tlet index = 0;\n\t\tconst indexArray = [];\n\t\tconst halfHeight = height / 2;\n\t\tlet groupStart = 0;\n\n\t\t// generate geometry\n\n\t\tgenerateTorso();\n\n\t\tif ( openEnded === false ) {\n\n\t\t\tif ( radiusTop > 0 ) generateCap( true );\n\t\t\tif ( radiusBottom > 0 ) generateCap( false );\n\n\t\t}\n\n\t\t// build geometry\n\n\t\tthis.setIndex( indices );\n\t\tthis.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\n\t\tthis.setAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );\n\t\tthis.setAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );\n\n\t\tfunction generateTorso() {\n\n\t\t\tconst normal = new Vector3();\n\t\t\tconst vertex = new Vector3();\n\n\t\t\tlet groupCount = 0;\n\n\t\t\t// this will be used to calculate the normal\n\t\t\tconst slope = ( radiusBottom - radiusTop ) / height;\n\n\t\t\t// generate vertices, normals and uvs\n\n\t\t\tfor ( let y = 0; y <= heightSegments; y ++ ) {\n\n\t\t\t\tconst indexRow = [];\n\n\t\t\t\tconst v = y / heightSegments;\n\n\t\t\t\t// calculate the radius of the current row\n\n\t\t\t\tconst radius = v * ( radiusBottom - radiusTop ) + radiusTop;\n\n\t\t\t\tfor ( let x = 0; x <= radialSegments; x ++ ) {\n\n\t\t\t\t\tconst u = x / radialSegments;\n\n\t\t\t\t\tconst theta = u * thetaLength + thetaStart;\n\n\t\t\t\t\tconst sinTheta = Math.sin( theta );\n\t\t\t\t\tconst cosTheta = Math.cos( theta );\n\n\t\t\t\t\t// vertex\n\n\t\t\t\t\tvertex.x = radius * sinTheta;\n\t\t\t\t\tvertex.y = - v * height + halfHeight;\n\t\t\t\t\tvertex.z = radius * cosTheta;\n\t\t\t\t\tvertices.push( vertex.x, vertex.y, vertex.z );\n\n\t\t\t\t\t// normal\n\n\t\t\t\t\tnormal.set( sinTheta, slope, cosTheta ).normalize();\n\t\t\t\t\tnormals.push( normal.x, normal.y, normal.z );\n\n\t\t\t\t\t// uv\n\n\t\t\t\t\tuvs.push( u, 1 - v );\n\n\t\t\t\t\t// save index of vertex in respective row\n\n\t\t\t\t\tindexRow.push( index ++ );\n\n\t\t\t\t}\n\n\t\t\t\t// now save vertices of the row in our index array\n\n\t\t\t\tindexArray.push( indexRow );\n\n\t\t\t}\n\n\t\t\t// generate indices\n\n\t\t\tfor ( let x = 0; x < radialSegments; x ++ ) {\n\n\t\t\t\tfor ( let y = 0; y < heightSegments; y ++ ) {\n\n\t\t\t\t\t// we use the index array to access the correct indices\n\n\t\t\t\t\tconst a = indexArray[ y ][ x ];\n\t\t\t\t\tconst b = indexArray[ y + 1 ][ x ];\n\t\t\t\t\tconst c = indexArray[ y + 1 ][ x + 1 ];\n\t\t\t\t\tconst d = indexArray[ y ][ x + 1 ];\n\n\t\t\t\t\t// faces\n\n\t\t\t\t\tindices.push( a, b, d );\n\t\t\t\t\tindices.push( b, c, d );\n\n\t\t\t\t\t// update group counter\n\n\t\t\t\t\tgroupCount += 6;\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\t// add a group to the geometry. this will ensure multi material support\n\n\t\t\tscope.addGroup( groupStart, groupCount, 0 );\n\n\t\t\t// calculate new start value for groups\n\n\t\t\tgroupStart += groupCount;\n\n\t\t}\n\n\t\tfunction generateCap( top ) {\n\n\t\t\t// save the index of the first center vertex\n\t\t\tconst centerIndexStart = index;\n\n\t\t\tconst uv = new Vector2();\n\t\t\tconst vertex = new Vector3();\n\n\t\t\tlet groupCount = 0;\n\n\t\t\tconst radius = ( top === true ) ? radiusTop : radiusBottom;\n\t\t\tconst sign = ( top === true ) ? 1 : - 1;\n\n\t\t\t// first we generate the center vertex data of the cap.\n\t\t\t// because the geometry needs one set of uvs per face,\n\t\t\t// we must generate a center vertex per face/segment\n\n\t\t\tfor ( let x = 1; x <= radialSegments; x ++ ) {\n\n\t\t\t\t// vertex\n\n\t\t\t\tvertices.push( 0, halfHeight * sign, 0 );\n\n\t\t\t\t// normal\n\n\t\t\t\tnormals.push( 0, sign, 0 );\n\n\t\t\t\t// uv\n\n\t\t\t\tuvs.push( 0.5, 0.5 );\n\n\t\t\t\t// increase index\n\n\t\t\t\tindex ++;\n\n\t\t\t}\n\n\t\t\t// save the index of the last center vertex\n\t\t\tconst centerIndexEnd = index;\n\n\t\t\t// now we generate the surrounding vertices, normals and uvs\n\n\t\t\tfor ( let x = 0; x <= radialSegments; x ++ ) {\n\n\t\t\t\tconst u = x / radialSegments;\n\t\t\t\tconst theta = u * thetaLength + thetaStart;\n\n\t\t\t\tconst cosTheta = Math.cos( theta );\n\t\t\t\tconst sinTheta = Math.sin( theta );\n\n\t\t\t\t// vertex\n\n\t\t\t\tvertex.x = radius * sinTheta;\n\t\t\t\tvertex.y = halfHeight * sign;\n\t\t\t\tvertex.z = radius * cosTheta;\n\t\t\t\tvertices.push( vertex.x, vertex.y, vertex.z );\n\n\t\t\t\t// normal\n\n\t\t\t\tnormals.push( 0, sign, 0 );\n\n\t\t\t\t// uv\n\n\t\t\t\tuv.x = ( cosTheta * 0.5 ) + 0.5;\n\t\t\t\tuv.y = ( sinTheta * 0.5 * sign ) + 0.5;\n\t\t\t\tuvs.push( uv.x, uv.y );\n\n\t\t\t\t// increase index\n\n\t\t\t\tindex ++;\n\n\t\t\t}\n\n\t\t\t// generate indices\n\n\t\t\tfor ( let x = 0; x < radialSegments; x ++ ) {\n\n\t\t\t\tconst c = centerIndexStart + x;\n\t\t\t\tconst i = centerIndexEnd + x;\n\n\t\t\t\tif ( top === true ) {\n\n\t\t\t\t\t// face top\n\n\t\t\t\t\tindices.push( i, i + 1, c );\n\n\t\t\t\t} else {\n\n\t\t\t\t\t// face bottom\n\n\t\t\t\t\tindices.push( i + 1, i, c );\n\n\t\t\t\t}\n\n\t\t\t\tgroupCount += 3;\n\n\t\t\t}\n\n\t\t\t// add a group to the geometry. this will ensure multi material support\n\n\t\t\tscope.addGroup( groupStart, groupCount, top === true ? 1 : 2 );\n\n\t\t\t// calculate new start value for groups\n\n\t\t\tgroupStart += groupCount;\n\n\t\t}\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.parameters = Object.assign( {}, source.parameters );\n\n\t\treturn this;\n\n\t}\n\n\tstatic fromJSON( data ) {\n\n\t\treturn new CylinderGeometry( data.radiusTop, data.radiusBottom, data.height, data.radialSegments, data.heightSegments, data.openEnded, data.thetaStart, data.thetaLength );\n\n\t}\n\n}\n\nclass ConeGeometry extends CylinderGeometry {\n\n\tconstructor( radius = 1, height = 1, radialSegments = 32, heightSegments = 1, openEnded = false, thetaStart = 0, thetaLength = Math.PI * 2 ) {\n\n\t\tsuper( 0, radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength );\n\n\t\tthis.type = 'ConeGeometry';\n\n\t\tthis.parameters = {\n\t\t\tradius: radius,\n\t\t\theight: height,\n\t\t\tradialSegments: radialSegments,\n\t\t\theightSegments: heightSegments,\n\t\t\topenEnded: openEnded,\n\t\t\tthetaStart: thetaStart,\n\t\t\tthetaLength: thetaLength\n\t\t};\n\n\t}\n\n\tstatic fromJSON( data ) {\n\n\t\treturn new ConeGeometry( data.radius, data.height, data.radialSegments, data.heightSegments, data.openEnded, data.thetaStart, data.thetaLength );\n\n\t}\n\n}\n\nclass PolyhedronGeometry extends BufferGeometry {\n\n\tconstructor( vertices = [], indices = [], radius = 1, detail = 0 ) {\n\n\t\tsuper();\n\n\t\tthis.type = 'PolyhedronGeometry';\n\n\t\tthis.parameters = {\n\t\t\tvertices: vertices,\n\t\t\tindices: indices,\n\t\t\tradius: radius,\n\t\t\tdetail: detail\n\t\t};\n\n\t\t// default buffer data\n\n\t\tconst vertexBuffer = [];\n\t\tconst uvBuffer = [];\n\n\t\t// the subdivision creates the vertex buffer data\n\n\t\tsubdivide( detail );\n\n\t\t// all vertices should lie on a conceptual sphere with a given radius\n\n\t\tapplyRadius( radius );\n\n\t\t// finally, create the uv data\n\n\t\tgenerateUVs();\n\n\t\t// build non-indexed geometry\n\n\t\tthis.setAttribute( 'position', new Float32BufferAttribute( vertexBuffer, 3 ) );\n\t\tthis.setAttribute( 'normal', new Float32BufferAttribute( vertexBuffer.slice(), 3 ) );\n\t\tthis.setAttribute( 'uv', new Float32BufferAttribute( uvBuffer, 2 ) );\n\n\t\tif ( detail === 0 ) {\n\n\t\t\tthis.computeVertexNormals(); // flat normals\n\n\t\t} else {\n\n\t\t\tthis.normalizeNormals(); // smooth normals\n\n\t\t}\n\n\t\t// helper functions\n\n\t\tfunction subdivide( detail ) {\n\n\t\t\tconst a = new Vector3();\n\t\t\tconst b = new Vector3();\n\t\t\tconst c = new Vector3();\n\n\t\t\t// iterate over all faces and apply a subdivision with the given detail value\n\n\t\t\tfor ( let i = 0; i < indices.length; i += 3 ) {\n\n\t\t\t\t// get the vertices of the face\n\n\t\t\t\tgetVertexByIndex( indices[ i + 0 ], a );\n\t\t\t\tgetVertexByIndex( indices[ i + 1 ], b );\n\t\t\t\tgetVertexByIndex( indices[ i + 2 ], c );\n\n\t\t\t\t// perform subdivision\n\n\t\t\t\tsubdivideFace( a, b, c, detail );\n\n\t\t\t}\n\n\t\t}\n\n\t\tfunction subdivideFace( a, b, c, detail ) {\n\n\t\t\tconst cols = detail + 1;\n\n\t\t\t// we use this multidimensional array as a data structure for creating the subdivision\n\n\t\t\tconst v = [];\n\n\t\t\t// construct all of the vertices for this subdivision\n\n\t\t\tfor ( let i = 0; i <= cols; i ++ ) {\n\n\t\t\t\tv[ i ] = [];\n\n\t\t\t\tconst aj = a.clone().lerp( c, i / cols );\n\t\t\t\tconst bj = b.clone().lerp( c, i / cols );\n\n\t\t\t\tconst rows = cols - i;\n\n\t\t\t\tfor ( let j = 0; j <= rows; j ++ ) {\n\n\t\t\t\t\tif ( j === 0 && i === cols ) {\n\n\t\t\t\t\t\tv[ i ][ j ] = aj;\n\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\tv[ i ][ j ] = aj.clone().lerp( bj, j / rows );\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\t// construct all of the faces\n\n\t\t\tfor ( let i = 0; i < cols; i ++ ) {\n\n\t\t\t\tfor ( let j = 0; j < 2 * ( cols - i ) - 1; j ++ ) {\n\n\t\t\t\t\tconst k = Math.floor( j / 2 );\n\n\t\t\t\t\tif ( j % 2 === 0 ) {\n\n\t\t\t\t\t\tpushVertex( v[ i ][ k + 1 ] );\n\t\t\t\t\t\tpushVertex( v[ i + 1 ][ k ] );\n\t\t\t\t\t\tpushVertex( v[ i ][ k ] );\n\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\tpushVertex( v[ i ][ k + 1 ] );\n\t\t\t\t\t\tpushVertex( v[ i + 1 ][ k + 1 ] );\n\t\t\t\t\t\tpushVertex( v[ i + 1 ][ k ] );\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t\tfunction applyRadius( radius ) {\n\n\t\t\tconst vertex = new Vector3();\n\n\t\t\t// iterate over the entire buffer and apply the radius to each vertex\n\n\t\t\tfor ( let i = 0; i < vertexBuffer.length; i += 3 ) {\n\n\t\t\t\tvertex.x = vertexBuffer[ i + 0 ];\n\t\t\t\tvertex.y = vertexBuffer[ i + 1 ];\n\t\t\t\tvertex.z = vertexBuffer[ i + 2 ];\n\n\t\t\t\tvertex.normalize().multiplyScalar( radius );\n\n\t\t\t\tvertexBuffer[ i + 0 ] = vertex.x;\n\t\t\t\tvertexBuffer[ i + 1 ] = vertex.y;\n\t\t\t\tvertexBuffer[ i + 2 ] = vertex.z;\n\n\t\t\t}\n\n\t\t}\n\n\t\tfunction generateUVs() {\n\n\t\t\tconst vertex = new Vector3();\n\n\t\t\tfor ( let i = 0; i < vertexBuffer.length; i += 3 ) {\n\n\t\t\t\tvertex.x = vertexBuffer[ i + 0 ];\n\t\t\t\tvertex.y = vertexBuffer[ i + 1 ];\n\t\t\t\tvertex.z = vertexBuffer[ i + 2 ];\n\n\t\t\t\tconst u = azimuth( vertex ) / 2 / Math.PI + 0.5;\n\t\t\t\tconst v = inclination( vertex ) / Math.PI + 0.5;\n\t\t\t\tuvBuffer.push( u, 1 - v );\n\n\t\t\t}\n\n\t\t\tcorrectUVs();\n\n\t\t\tcorrectSeam();\n\n\t\t}\n\n\t\tfunction correctSeam() {\n\n\t\t\t// handle case when face straddles the seam, see #3269\n\n\t\t\tfor ( let i = 0; i < uvBuffer.length; i += 6 ) {\n\n\t\t\t\t// uv data of a single face\n\n\t\t\t\tconst x0 = uvBuffer[ i + 0 ];\n\t\t\t\tconst x1 = uvBuffer[ i + 2 ];\n\t\t\t\tconst x2 = uvBuffer[ i + 4 ];\n\n\t\t\t\tconst max = Math.max( x0, x1, x2 );\n\t\t\t\tconst min = Math.min( x0, x1, x2 );\n\n\t\t\t\t// 0.9 is somewhat arbitrary\n\n\t\t\t\tif ( max > 0.9 && min < 0.1 ) {\n\n\t\t\t\t\tif ( x0 < 0.2 ) uvBuffer[ i + 0 ] += 1;\n\t\t\t\t\tif ( x1 < 0.2 ) uvBuffer[ i + 2 ] += 1;\n\t\t\t\t\tif ( x2 < 0.2 ) uvBuffer[ i + 4 ] += 1;\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t\tfunction pushVertex( vertex ) {\n\n\t\t\tvertexBuffer.push( vertex.x, vertex.y, vertex.z );\n\n\t\t}\n\n\t\tfunction getVertexByIndex( index, vertex ) {\n\n\t\t\tconst stride = index * 3;\n\n\t\t\tvertex.x = vertices[ stride + 0 ];\n\t\t\tvertex.y = vertices[ stride + 1 ];\n\t\t\tvertex.z = vertices[ stride + 2 ];\n\n\t\t}\n\n\t\tfunction correctUVs() {\n\n\t\t\tconst a = new Vector3();\n\t\t\tconst b = new Vector3();\n\t\t\tconst c = new Vector3();\n\n\t\t\tconst centroid = new Vector3();\n\n\t\t\tconst uvA = new Vector2();\n\t\t\tconst uvB = new Vector2();\n\t\t\tconst uvC = new Vector2();\n\n\t\t\tfor ( let i = 0, j = 0; i < vertexBuffer.length; i += 9, j += 6 ) {\n\n\t\t\t\ta.set( vertexBuffer[ i + 0 ], vertexBuffer[ i + 1 ], vertexBuffer[ i + 2 ] );\n\t\t\t\tb.set( vertexBuffer[ i + 3 ], vertexBuffer[ i + 4 ], vertexBuffer[ i + 5 ] );\n\t\t\t\tc.set( vertexBuffer[ i + 6 ], vertexBuffer[ i + 7 ], vertexBuffer[ i + 8 ] );\n\n\t\t\t\tuvA.set( uvBuffer[ j + 0 ], uvBuffer[ j + 1 ] );\n\t\t\t\tuvB.set( uvBuffer[ j + 2 ], uvBuffer[ j + 3 ] );\n\t\t\t\tuvC.set( uvBuffer[ j + 4 ], uvBuffer[ j + 5 ] );\n\n\t\t\t\tcentroid.copy( a ).add( b ).add( c ).divideScalar( 3 );\n\n\t\t\t\tconst azi = azimuth( centroid );\n\n\t\t\t\tcorrectUV( uvA, j + 0, a, azi );\n\t\t\t\tcorrectUV( uvB, j + 2, b, azi );\n\t\t\t\tcorrectUV( uvC, j + 4, c, azi );\n\n\t\t\t}\n\n\t\t}\n\n\t\tfunction correctUV( uv, stride, vector, azimuth ) {\n\n\t\t\tif ( ( azimuth < 0 ) && ( uv.x === 1 ) ) {\n\n\t\t\t\tuvBuffer[ stride ] = uv.x - 1;\n\n\t\t\t}\n\n\t\t\tif ( ( vector.x === 0 ) && ( vector.z === 0 ) ) {\n\n\t\t\t\tuvBuffer[ stride ] = azimuth / 2 / Math.PI + 0.5;\n\n\t\t\t}\n\n\t\t}\n\n\t\t// Angle around the Y axis, counter-clockwise when looking from above.\n\n\t\tfunction azimuth( vector ) {\n\n\t\t\treturn Math.atan2( vector.z, - vector.x );\n\n\t\t}\n\n\n\t\t// Angle above the XZ plane.\n\n\t\tfunction inclination( vector ) {\n\n\t\t\treturn Math.atan2( - vector.y, Math.sqrt( ( vector.x * vector.x ) + ( vector.z * vector.z ) ) );\n\n\t\t}\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.parameters = Object.assign( {}, source.parameters );\n\n\t\treturn this;\n\n\t}\n\n\tstatic fromJSON( data ) {\n\n\t\treturn new PolyhedronGeometry( data.vertices, data.indices, data.radius, data.details );\n\n\t}\n\n}\n\nclass DodecahedronGeometry extends PolyhedronGeometry {\n\n\tconstructor( radius = 1, detail = 0 ) {\n\n\t\tconst t = ( 1 + Math.sqrt( 5 ) ) / 2;\n\t\tconst r = 1 / t;\n\n\t\tconst vertices = [\n\n\t\t\t// (\u00B11, \u00B11, \u00B11)\n\t\t\t- 1, - 1, - 1,\t- 1, - 1, 1,\n\t\t\t- 1, 1, - 1, - 1, 1, 1,\n\t\t\t1, - 1, - 1, 1, - 1, 1,\n\t\t\t1, 1, - 1, 1, 1, 1,\n\n\t\t\t// (0, \u00B11/\u03C6, \u00B1\u03C6)\n\t\t\t0, - r, - t, 0, - r, t,\n\t\t\t0, r, - t, 0, r, t,\n\n\t\t\t// (\u00B11/\u03C6, \u00B1\u03C6, 0)\n\t\t\t- r, - t, 0, - r, t, 0,\n\t\t\tr, - t, 0, r, t, 0,\n\n\t\t\t// (\u00B1\u03C6, 0, \u00B11/\u03C6)\n\t\t\t- t, 0, - r, t, 0, - r,\n\t\t\t- t, 0, r, t, 0, r\n\t\t];\n\n\t\tconst indices = [\n\t\t\t3, 11, 7, \t3, 7, 15, \t3, 15, 13,\n\t\t\t7, 19, 17, \t7, 17, 6, \t7, 6, 15,\n\t\t\t17, 4, 8, \t17, 8, 10, \t17, 10, 6,\n\t\t\t8, 0, 16, \t8, 16, 2, \t8, 2, 10,\n\t\t\t0, 12, 1, \t0, 1, 18, \t0, 18, 16,\n\t\t\t6, 10, 2, \t6, 2, 13, \t6, 13, 15,\n\t\t\t2, 16, 18, \t2, 18, 3, \t2, 3, 13,\n\t\t\t18, 1, 9, \t18, 9, 11, \t18, 11, 3,\n\t\t\t4, 14, 12, \t4, 12, 0, \t4, 0, 8,\n\t\t\t11, 9, 5, \t11, 5, 19, \t11, 19, 7,\n\t\t\t19, 5, 14, \t19, 14, 4, \t19, 4, 17,\n\t\t\t1, 12, 14, \t1, 14, 5, \t1, 5, 9\n\t\t];\n\n\t\tsuper( vertices, indices, radius, detail );\n\n\t\tthis.type = 'DodecahedronGeometry';\n\n\t\tthis.parameters = {\n\t\t\tradius: radius,\n\t\t\tdetail: detail\n\t\t};\n\n\t}\n\n\tstatic fromJSON( data ) {\n\n\t\treturn new DodecahedronGeometry( data.radius, data.detail );\n\n\t}\n\n}\n\nconst _v0 = /*@__PURE__*/ new Vector3();\nconst _v1$1 = /*@__PURE__*/ new Vector3();\nconst _normal = /*@__PURE__*/ new Vector3();\nconst _triangle = /*@__PURE__*/ new Triangle();\n\nclass EdgesGeometry extends BufferGeometry {\n\n\tconstructor( geometry = null, thresholdAngle = 1 ) {\n\n\t\tsuper();\n\n\t\tthis.type = 'EdgesGeometry';\n\n\t\tthis.parameters = {\n\t\t\tgeometry: geometry,\n\t\t\tthresholdAngle: thresholdAngle\n\t\t};\n\n\t\tif ( geometry !== null ) {\n\n\t\t\tconst precisionPoints = 4;\n\t\t\tconst precision = Math.pow( 10, precisionPoints );\n\t\t\tconst thresholdDot = Math.cos( DEG2RAD * thresholdAngle );\n\n\t\t\tconst indexAttr = geometry.getIndex();\n\t\t\tconst positionAttr = geometry.getAttribute( 'position' );\n\t\t\tconst indexCount = indexAttr ? indexAttr.count : positionAttr.count;\n\n\t\t\tconst indexArr = [ 0, 0, 0 ];\n\t\t\tconst vertKeys = [ 'a', 'b', 'c' ];\n\t\t\tconst hashes = new Array( 3 );\n\n\t\t\tconst edgeData = {};\n\t\t\tconst vertices = [];\n\t\t\tfor ( let i = 0; i < indexCount; i += 3 ) {\n\n\t\t\t\tif ( indexAttr ) {\n\n\t\t\t\t\tindexArr[ 0 ] = indexAttr.getX( i );\n\t\t\t\t\tindexArr[ 1 ] = indexAttr.getX( i + 1 );\n\t\t\t\t\tindexArr[ 2 ] = indexAttr.getX( i + 2 );\n\n\t\t\t\t} else {\n\n\t\t\t\t\tindexArr[ 0 ] = i;\n\t\t\t\t\tindexArr[ 1 ] = i + 1;\n\t\t\t\t\tindexArr[ 2 ] = i + 2;\n\n\t\t\t\t}\n\n\t\t\t\tconst { a, b, c } = _triangle;\n\t\t\t\ta.fromBufferAttribute( positionAttr, indexArr[ 0 ] );\n\t\t\t\tb.fromBufferAttribute( positionAttr, indexArr[ 1 ] );\n\t\t\t\tc.fromBufferAttribute( positionAttr, indexArr[ 2 ] );\n\t\t\t\t_triangle.getNormal( _normal );\n\n\t\t\t\t// create hashes for the edge from the vertices\n\t\t\t\thashes[ 0 ] = `${ Math.round( a.x * precision ) },${ Math.round( a.y * precision ) },${ Math.round( a.z * precision ) }`;\n\t\t\t\thashes[ 1 ] = `${ Math.round( b.x * precision ) },${ Math.round( b.y * precision ) },${ Math.round( b.z * precision ) }`;\n\t\t\t\thashes[ 2 ] = `${ Math.round( c.x * precision ) },${ Math.round( c.y * precision ) },${ Math.round( c.z * precision ) }`;\n\n\t\t\t\t// skip degenerate triangles\n\t\t\t\tif ( hashes[ 0 ] === hashes[ 1 ] || hashes[ 1 ] === hashes[ 2 ] || hashes[ 2 ] === hashes[ 0 ] ) {\n\n\t\t\t\t\tcontinue;\n\n\t\t\t\t}\n\n\t\t\t\t// iterate over every edge\n\t\t\t\tfor ( let j = 0; j < 3; j ++ ) {\n\n\t\t\t\t\t// get the first and next vertex making up the edge\n\t\t\t\t\tconst jNext = ( j + 1 ) % 3;\n\t\t\t\t\tconst vecHash0 = hashes[ j ];\n\t\t\t\t\tconst vecHash1 = hashes[ jNext ];\n\t\t\t\t\tconst v0 = _triangle[ vertKeys[ j ] ];\n\t\t\t\t\tconst v1 = _triangle[ vertKeys[ jNext ] ];\n\n\t\t\t\t\tconst hash = `${ vecHash0 }_${ vecHash1 }`;\n\t\t\t\t\tconst reverseHash = `${ vecHash1 }_${ vecHash0 }`;\n\n\t\t\t\t\tif ( reverseHash in edgeData && edgeData[ reverseHash ] ) {\n\n\t\t\t\t\t\t// if we found a sibling edge add it into the vertex array if\n\t\t\t\t\t\t// it meets the angle threshold and delete the edge from the map.\n\t\t\t\t\t\tif ( _normal.dot( edgeData[ reverseHash ].normal ) <= thresholdDot ) {\n\n\t\t\t\t\t\t\tvertices.push( v0.x, v0.y, v0.z );\n\t\t\t\t\t\t\tvertices.push( v1.x, v1.y, v1.z );\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tedgeData[ reverseHash ] = null;\n\n\t\t\t\t\t} else if ( ! ( hash in edgeData ) ) {\n\n\t\t\t\t\t\t// if we've already got an edge here then skip adding a new one\n\t\t\t\t\t\tedgeData[ hash ] = {\n\n\t\t\t\t\t\t\tindex0: indexArr[ j ],\n\t\t\t\t\t\t\tindex1: indexArr[ jNext ],\n\t\t\t\t\t\t\tnormal: _normal.clone(),\n\n\t\t\t\t\t\t};\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\t// iterate over all remaining, unmatched edges and add them to the vertex array\n\t\t\tfor ( const key in edgeData ) {\n\n\t\t\t\tif ( edgeData[ key ] ) {\n\n\t\t\t\t\tconst { index0, index1 } = edgeData[ key ];\n\t\t\t\t\t_v0.fromBufferAttribute( positionAttr, index0 );\n\t\t\t\t\t_v1$1.fromBufferAttribute( positionAttr, index1 );\n\n\t\t\t\t\tvertices.push( _v0.x, _v0.y, _v0.z );\n\t\t\t\t\tvertices.push( _v1$1.x, _v1$1.y, _v1$1.z );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tthis.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\n\n\t\t}\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.parameters = Object.assign( {}, source.parameters );\n\n\t\treturn this;\n\n\t}\n\n}\n\nclass Shape extends Path {\n\n\tconstructor( points ) {\n\n\t\tsuper( points );\n\n\t\tthis.uuid = generateUUID();\n\n\t\tthis.type = 'Shape';\n\n\t\tthis.holes = [];\n\n\t}\n\n\tgetPointsHoles( divisions ) {\n\n\t\tconst holesPts = [];\n\n\t\tfor ( let i = 0, l = this.holes.length; i < l; i ++ ) {\n\n\t\t\tholesPts[ i ] = this.holes[ i ].getPoints( divisions );\n\n\t\t}\n\n\t\treturn holesPts;\n\n\t}\n\n\t// get points of shape and holes (keypoints based on segments parameter)\n\n\textractPoints( divisions ) {\n\n\t\treturn {\n\n\t\t\tshape: this.getPoints( divisions ),\n\t\t\tholes: this.getPointsHoles( divisions )\n\n\t\t};\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.holes = [];\n\n\t\tfor ( let i = 0, l = source.holes.length; i < l; i ++ ) {\n\n\t\t\tconst hole = source.holes[ i ];\n\n\t\t\tthis.holes.push( hole.clone() );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\ttoJSON() {\n\n\t\tconst data = super.toJSON();\n\n\t\tdata.uuid = this.uuid;\n\t\tdata.holes = [];\n\n\t\tfor ( let i = 0, l = this.holes.length; i < l; i ++ ) {\n\n\t\t\tconst hole = this.holes[ i ];\n\t\t\tdata.holes.push( hole.toJSON() );\n\n\t\t}\n\n\t\treturn data;\n\n\t}\n\n\tfromJSON( json ) {\n\n\t\tsuper.fromJSON( json );\n\n\t\tthis.uuid = json.uuid;\n\t\tthis.holes = [];\n\n\t\tfor ( let i = 0, l = json.holes.length; i < l; i ++ ) {\n\n\t\t\tconst hole = json.holes[ i ];\n\t\t\tthis.holes.push( new Path().fromJSON( hole ) );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n}\n\n/**\n * Port from https://github.com/mapbox/earcut (v2.2.4)\n */\n\nconst Earcut = {\n\n\ttriangulate: function ( data, holeIndices, dim = 2 ) {\n\n\t\tconst hasHoles = holeIndices && holeIndices.length;\n\t\tconst outerLen = hasHoles ? holeIndices[ 0 ] * dim : data.length;\n\t\tlet outerNode = linkedList( data, 0, outerLen, dim, true );\n\t\tconst triangles = [];\n\n\t\tif ( ! outerNode || outerNode.next === outerNode.prev ) return triangles;\n\n\t\tlet minX, minY, maxX, maxY, x, y, invSize;\n\n\t\tif ( hasHoles ) outerNode = eliminateHoles( data, holeIndices, outerNode, dim );\n\n\t\t// if the shape is not too simple, we'll use z-order curve hash later; calculate polygon bbox\n\t\tif ( data.length > 80 * dim ) {\n\n\t\t\tminX = maxX = data[ 0 ];\n\t\t\tminY = maxY = data[ 1 ];\n\n\t\t\tfor ( let i = dim; i < outerLen; i += dim ) {\n\n\t\t\t\tx = data[ i ];\n\t\t\t\ty = data[ i + 1 ];\n\t\t\t\tif ( x < minX ) minX = x;\n\t\t\t\tif ( y < minY ) minY = y;\n\t\t\t\tif ( x > maxX ) maxX = x;\n\t\t\t\tif ( y > maxY ) maxY = y;\n\n\t\t\t}\n\n\t\t\t// minX, minY and invSize are later used to transform coords into integers for z-order calculation\n\t\t\tinvSize = Math.max( maxX - minX, maxY - minY );\n\t\t\tinvSize = invSize !== 0 ? 32767 / invSize : 0;\n\n\t\t}\n\n\t\tearcutLinked( outerNode, triangles, dim, minX, minY, invSize, 0 );\n\n\t\treturn triangles;\n\n\t}\n\n};\n\n// create a circular doubly linked list from polygon points in the specified winding order\nfunction linkedList( data, start, end, dim, clockwise ) {\n\n\tlet i, last;\n\n\tif ( clockwise === ( signedArea( data, start, end, dim ) > 0 ) ) {\n\n\t\tfor ( i = start; i < end; i += dim ) last = insertNode( i, data[ i ], data[ i + 1 ], last );\n\n\t} else {\n\n\t\tfor ( i = end - dim; i >= start; i -= dim ) last = insertNode( i, data[ i ], data[ i + 1 ], last );\n\n\t}\n\n\tif ( last && equals( last, last.next ) ) {\n\n\t\tremoveNode( last );\n\t\tlast = last.next;\n\n\t}\n\n\treturn last;\n\n}\n\n// eliminate colinear or duplicate points\nfunction filterPoints( start, end ) {\n\n\tif ( ! start ) return start;\n\tif ( ! end ) end = start;\n\n\tlet p = start,\n\t\tagain;\n\tdo {\n\n\t\tagain = false;\n\n\t\tif ( ! p.steiner && ( equals( p, p.next ) || area( p.prev, p, p.next ) === 0 ) ) {\n\n\t\t\tremoveNode( p );\n\t\t\tp = end = p.prev;\n\t\t\tif ( p === p.next ) break;\n\t\t\tagain = true;\n\n\t\t} else {\n\n\t\t\tp = p.next;\n\n\t\t}\n\n\t} while ( again || p !== end );\n\n\treturn end;\n\n}\n\n// main ear slicing loop which triangulates a polygon (given as a linked list)\nfunction earcutLinked( ear, triangles, dim, minX, minY, invSize, pass ) {\n\n\tif ( ! ear ) return;\n\n\t// interlink polygon nodes in z-order\n\tif ( ! pass && invSize ) indexCurve( ear, minX, minY, invSize );\n\n\tlet stop = ear,\n\t\tprev, next;\n\n\t// iterate through ears, slicing them one by one\n\twhile ( ear.prev !== ear.next ) {\n\n\t\tprev = ear.prev;\n\t\tnext = ear.next;\n\n\t\tif ( invSize ? isEarHashed( ear, minX, minY, invSize ) : isEar( ear ) ) {\n\n\t\t\t// cut off the triangle\n\t\t\ttriangles.push( prev.i / dim | 0 );\n\t\t\ttriangles.push( ear.i / dim | 0 );\n\t\t\ttriangles.push( next.i / dim | 0 );\n\n\t\t\tremoveNode( ear );\n\n\t\t\t// skipping the next vertex leads to less sliver triangles\n\t\t\tear = next.next;\n\t\t\tstop = next.next;\n\n\t\t\tcontinue;\n\n\t\t}\n\n\t\tear = next;\n\n\t\t// if we looped through the whole remaining polygon and can't find any more ears\n\t\tif ( ear === stop ) {\n\n\t\t\t// try filtering points and slicing again\n\t\t\tif ( ! pass ) {\n\n\t\t\t\tearcutLinked( filterPoints( ear ), triangles, dim, minX, minY, invSize, 1 );\n\n\t\t\t\t// if this didn't work, try curing all small self-intersections locally\n\n\t\t\t} else if ( pass === 1 ) {\n\n\t\t\t\tear = cureLocalIntersections( filterPoints( ear ), triangles, dim );\n\t\t\t\tearcutLinked( ear, triangles, dim, minX, minY, invSize, 2 );\n\n\t\t\t\t// as a last resort, try splitting the remaining polygon into two\n\n\t\t\t} else if ( pass === 2 ) {\n\n\t\t\t\tsplitEarcut( ear, triangles, dim, minX, minY, invSize );\n\n\t\t\t}\n\n\t\t\tbreak;\n\n\t\t}\n\n\t}\n\n}\n\n// check whether a polygon node forms a valid ear with adjacent nodes\nfunction isEar( ear ) {\n\n\tconst a = ear.prev,\n\t\tb = ear,\n\t\tc = ear.next;\n\n\tif ( area( a, b, c ) >= 0 ) return false; // reflex, can't be an ear\n\n\t// now make sure we don't have other points inside the potential ear\n\tconst ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;\n\n\t// triangle bbox; min & max are calculated like this for speed\n\tconst x0 = ax < bx ? ( ax < cx ? ax : cx ) : ( bx < cx ? bx : cx ),\n\t\ty0 = ay < by ? ( ay < cy ? ay : cy ) : ( by < cy ? by : cy ),\n\t\tx1 = ax > bx ? ( ax > cx ? ax : cx ) : ( bx > cx ? bx : cx ),\n\t\ty1 = ay > by ? ( ay > cy ? ay : cy ) : ( by > cy ? by : cy );\n\n\tlet p = c.next;\n\twhile ( p !== a ) {\n\n\t\tif ( p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 &&\n\t\t\tpointInTriangle( ax, ay, bx, by, cx, cy, p.x, p.y ) &&\n\t\t\tarea( p.prev, p, p.next ) >= 0 ) return false;\n\t\tp = p.next;\n\n\t}\n\n\treturn true;\n\n}\n\nfunction isEarHashed( ear, minX, minY, invSize ) {\n\n\tconst a = ear.prev,\n\t\tb = ear,\n\t\tc = ear.next;\n\n\tif ( area( a, b, c ) >= 0 ) return false; // reflex, can't be an ear\n\n\tconst ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;\n\n\t// triangle bbox; min & max are calculated like this for speed\n\tconst x0 = ax < bx ? ( ax < cx ? ax : cx ) : ( bx < cx ? bx : cx ),\n\t\ty0 = ay < by ? ( ay < cy ? ay : cy ) : ( by < cy ? by : cy ),\n\t\tx1 = ax > bx ? ( ax > cx ? ax : cx ) : ( bx > cx ? bx : cx ),\n\t\ty1 = ay > by ? ( ay > cy ? ay : cy ) : ( by > cy ? by : cy );\n\n\t// z-order range for the current triangle bbox;\n\tconst minZ = zOrder( x0, y0, minX, minY, invSize ),\n\t\tmaxZ = zOrder( x1, y1, minX, minY, invSize );\n\n\tlet p = ear.prevZ,\n\t\tn = ear.nextZ;\n\n\t// look for points inside the triangle in both directions\n\twhile ( p && p.z >= minZ && n && n.z <= maxZ ) {\n\n\t\tif ( p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c &&\n\t\t\tpointInTriangle( ax, ay, bx, by, cx, cy, p.x, p.y ) && area( p.prev, p, p.next ) >= 0 ) return false;\n\t\tp = p.prevZ;\n\n\t\tif ( n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c &&\n\t\t\tpointInTriangle( ax, ay, bx, by, cx, cy, n.x, n.y ) && area( n.prev, n, n.next ) >= 0 ) return false;\n\t\tn = n.nextZ;\n\n\t}\n\n\t// look for remaining points in decreasing z-order\n\twhile ( p && p.z >= minZ ) {\n\n\t\tif ( p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c &&\n\t\t\tpointInTriangle( ax, ay, bx, by, cx, cy, p.x, p.y ) && area( p.prev, p, p.next ) >= 0 ) return false;\n\t\tp = p.prevZ;\n\n\t}\n\n\t// look for remaining points in increasing z-order\n\twhile ( n && n.z <= maxZ ) {\n\n\t\tif ( n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c &&\n\t\t\tpointInTriangle( ax, ay, bx, by, cx, cy, n.x, n.y ) && area( n.prev, n, n.next ) >= 0 ) return false;\n\t\tn = n.nextZ;\n\n\t}\n\n\treturn true;\n\n}\n\n// go through all polygon nodes and cure small local self-intersections\nfunction cureLocalIntersections( start, triangles, dim ) {\n\n\tlet p = start;\n\tdo {\n\n\t\tconst a = p.prev,\n\t\t\tb = p.next.next;\n\n\t\tif ( ! equals( a, b ) && intersects( a, p, p.next, b ) && locallyInside( a, b ) && locallyInside( b, a ) ) {\n\n\t\t\ttriangles.push( a.i / dim | 0 );\n\t\t\ttriangles.push( p.i / dim | 0 );\n\t\t\ttriangles.push( b.i / dim | 0 );\n\n\t\t\t// remove two nodes involved\n\t\t\tremoveNode( p );\n\t\t\tremoveNode( p.next );\n\n\t\t\tp = start = b;\n\n\t\t}\n\n\t\tp = p.next;\n\n\t} while ( p !== start );\n\n\treturn filterPoints( p );\n\n}\n\n// try splitting polygon into two and triangulate them independently\nfunction splitEarcut( start, triangles, dim, minX, minY, invSize ) {\n\n\t// look for a valid diagonal that divides the polygon into two\n\tlet a = start;\n\tdo {\n\n\t\tlet b = a.next.next;\n\t\twhile ( b !== a.prev ) {\n\n\t\t\tif ( a.i !== b.i && isValidDiagonal( a, b ) ) {\n\n\t\t\t\t// split the polygon in two by the diagonal\n\t\t\t\tlet c = splitPolygon( a, b );\n\n\t\t\t\t// filter colinear points around the cuts\n\t\t\t\ta = filterPoints( a, a.next );\n\t\t\t\tc = filterPoints( c, c.next );\n\n\t\t\t\t// run earcut on each half\n\t\t\t\tearcutLinked( a, triangles, dim, minX, minY, invSize, 0 );\n\t\t\t\tearcutLinked( c, triangles, dim, minX, minY, invSize, 0 );\n\t\t\t\treturn;\n\n\t\t\t}\n\n\t\t\tb = b.next;\n\n\t\t}\n\n\t\ta = a.next;\n\n\t} while ( a !== start );\n\n}\n\n// link every hole into the outer loop, producing a single-ring polygon without holes\nfunction eliminateHoles( data, holeIndices, outerNode, dim ) {\n\n\tconst queue = [];\n\tlet i, len, start, end, list;\n\n\tfor ( i = 0, len = holeIndices.length; i < len; i ++ ) {\n\n\t\tstart = holeIndices[ i ] * dim;\n\t\tend = i < len - 1 ? holeIndices[ i + 1 ] * dim : data.length;\n\t\tlist = linkedList( data, start, end, dim, false );\n\t\tif ( list === list.next ) list.steiner = true;\n\t\tqueue.push( getLeftmost( list ) );\n\n\t}\n\n\tqueue.sort( compareX );\n\n\t// process holes from left to right\n\tfor ( i = 0; i < queue.length; i ++ ) {\n\n\t\touterNode = eliminateHole( queue[ i ], outerNode );\n\n\t}\n\n\treturn outerNode;\n\n}\n\nfunction compareX( a, b ) {\n\n\treturn a.x - b.x;\n\n}\n\n// find a bridge between vertices that connects hole with an outer ring and link it\nfunction eliminateHole( hole, outerNode ) {\n\n\tconst bridge = findHoleBridge( hole, outerNode );\n\tif ( ! bridge ) {\n\n\t\treturn outerNode;\n\n\t}\n\n\tconst bridgeReverse = splitPolygon( bridge, hole );\n\n\t// filter collinear points around the cuts\n\tfilterPoints( bridgeReverse, bridgeReverse.next );\n\treturn filterPoints( bridge, bridge.next );\n\n}\n\n// David Eberly's algorithm for finding a bridge between hole and outer polygon\nfunction findHoleBridge( hole, outerNode ) {\n\n\tlet p = outerNode,\n\t\tqx = - Infinity,\n\t\tm;\n\n\tconst hx = hole.x, hy = hole.y;\n\n\t// find a segment intersected by a ray from the hole's leftmost point to the left;\n\t// segment's endpoint with lesser x will be potential connection point\n\tdo {\n\n\t\tif ( hy <= p.y && hy >= p.next.y && p.next.y !== p.y ) {\n\n\t\t\tconst x = p.x + ( hy - p.y ) * ( p.next.x - p.x ) / ( p.next.y - p.y );\n\t\t\tif ( x <= hx && x > qx ) {\n\n\t\t\t\tqx = x;\n\t\t\t\tm = p.x < p.next.x ? p : p.next;\n\t\t\t\tif ( x === hx ) return m; // hole touches outer segment; pick leftmost endpoint\n\n\t\t\t}\n\n\t\t}\n\n\t\tp = p.next;\n\n\t} while ( p !== outerNode );\n\n\tif ( ! m ) return null;\n\n\t// look for points inside the triangle of hole point, segment intersection and endpoint;\n\t// if there are no points found, we have a valid connection;\n\t// otherwise choose the point of the minimum angle with the ray as connection point\n\n\tconst stop = m,\n\t\tmx = m.x,\n\t\tmy = m.y;\n\tlet tanMin = Infinity, tan;\n\n\tp = m;\n\n\tdo {\n\n\t\tif ( hx >= p.x && p.x >= mx && hx !== p.x &&\n\t\t\t\tpointInTriangle( hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y ) ) {\n\n\t\t\ttan = Math.abs( hy - p.y ) / ( hx - p.x ); // tangential\n\n\t\t\tif ( locallyInside( p, hole ) && ( tan < tanMin || ( tan === tanMin && ( p.x > m.x || ( p.x === m.x && sectorContainsSector( m, p ) ) ) ) ) ) {\n\n\t\t\t\tm = p;\n\t\t\t\ttanMin = tan;\n\n\t\t\t}\n\n\t\t}\n\n\t\tp = p.next;\n\n\t} while ( p !== stop );\n\n\treturn m;\n\n}\n\n// whether sector in vertex m contains sector in vertex p in the same coordinates\nfunction sectorContainsSector( m, p ) {\n\n\treturn area( m.prev, m, p.prev ) < 0 && area( p.next, m, m.next ) < 0;\n\n}\n\n// interlink polygon nodes in z-order\nfunction indexCurve( start, minX, minY, invSize ) {\n\n\tlet p = start;\n\tdo {\n\n\t\tif ( p.z === 0 ) p.z = zOrder( p.x, p.y, minX, minY, invSize );\n\t\tp.prevZ = p.prev;\n\t\tp.nextZ = p.next;\n\t\tp = p.next;\n\n\t} while ( p !== start );\n\n\tp.prevZ.nextZ = null;\n\tp.prevZ = null;\n\n\tsortLinked( p );\n\n}\n\n// Simon Tatham's linked list merge sort algorithm\n// http://www.chiark.greenend.org.uk/~sgtatham/algorithms/listsort.html\nfunction sortLinked( list ) {\n\n\tlet i, p, q, e, tail, numMerges, pSize, qSize,\n\t\tinSize = 1;\n\n\tdo {\n\n\t\tp = list;\n\t\tlist = null;\n\t\ttail = null;\n\t\tnumMerges = 0;\n\n\t\twhile ( p ) {\n\n\t\t\tnumMerges ++;\n\t\t\tq = p;\n\t\t\tpSize = 0;\n\t\t\tfor ( i = 0; i < inSize; i ++ ) {\n\n\t\t\t\tpSize ++;\n\t\t\t\tq = q.nextZ;\n\t\t\t\tif ( ! q ) break;\n\n\t\t\t}\n\n\t\t\tqSize = inSize;\n\n\t\t\twhile ( pSize > 0 || ( qSize > 0 && q ) ) {\n\n\t\t\t\tif ( pSize !== 0 && ( qSize === 0 || ! q || p.z <= q.z ) ) {\n\n\t\t\t\t\te = p;\n\t\t\t\t\tp = p.nextZ;\n\t\t\t\t\tpSize --;\n\n\t\t\t\t} else {\n\n\t\t\t\t\te = q;\n\t\t\t\t\tq = q.nextZ;\n\t\t\t\t\tqSize --;\n\n\t\t\t\t}\n\n\t\t\t\tif ( tail ) tail.nextZ = e;\n\t\t\t\telse list = e;\n\n\t\t\t\te.prevZ = tail;\n\t\t\t\ttail = e;\n\n\t\t\t}\n\n\t\t\tp = q;\n\n\t\t}\n\n\t\ttail.nextZ = null;\n\t\tinSize *= 2;\n\n\t} while ( numMerges > 1 );\n\n\treturn list;\n\n}\n\n// z-order of a point given coords and inverse of the longer side of data bbox\nfunction zOrder( x, y, minX, minY, invSize ) {\n\n\t// coords are transformed into non-negative 15-bit integer range\n\tx = ( x - minX ) * invSize | 0;\n\ty = ( y - minY ) * invSize | 0;\n\n\tx = ( x | ( x << 8 ) ) & 0x00FF00FF;\n\tx = ( x | ( x << 4 ) ) & 0x0F0F0F0F;\n\tx = ( x | ( x << 2 ) ) & 0x33333333;\n\tx = ( x | ( x << 1 ) ) & 0x55555555;\n\n\ty = ( y | ( y << 8 ) ) & 0x00FF00FF;\n\ty = ( y | ( y << 4 ) ) & 0x0F0F0F0F;\n\ty = ( y | ( y << 2 ) ) & 0x33333333;\n\ty = ( y | ( y << 1 ) ) & 0x55555555;\n\n\treturn x | ( y << 1 );\n\n}\n\n// find the leftmost node of a polygon ring\nfunction getLeftmost( start ) {\n\n\tlet p = start,\n\t\tleftmost = start;\n\tdo {\n\n\t\tif ( p.x < leftmost.x || ( p.x === leftmost.x && p.y < leftmost.y ) ) leftmost = p;\n\t\tp = p.next;\n\n\t} while ( p !== start );\n\n\treturn leftmost;\n\n}\n\n// check if a point lies within a convex triangle\nfunction pointInTriangle( ax, ay, bx, by, cx, cy, px, py ) {\n\n\treturn ( cx - px ) * ( ay - py ) >= ( ax - px ) * ( cy - py ) &&\n ( ax - px ) * ( by - py ) >= ( bx - px ) * ( ay - py ) &&\n ( bx - px ) * ( cy - py ) >= ( cx - px ) * ( by - py );\n\n}\n\n// check if a diagonal between two polygon nodes is valid (lies in polygon interior)\nfunction isValidDiagonal( a, b ) {\n\n\treturn a.next.i !== b.i && a.prev.i !== b.i && ! intersectsPolygon( a, b ) && // dones't intersect other edges\n ( locallyInside( a, b ) && locallyInside( b, a ) && middleInside( a, b ) && // locally visible\n ( area( a.prev, a, b.prev ) || area( a, b.prev, b ) ) || // does not create opposite-facing sectors\n equals( a, b ) && area( a.prev, a, a.next ) > 0 && area( b.prev, b, b.next ) > 0 ); // special zero-length case\n\n}\n\n// signed area of a triangle\nfunction area( p, q, r ) {\n\n\treturn ( q.y - p.y ) * ( r.x - q.x ) - ( q.x - p.x ) * ( r.y - q.y );\n\n}\n\n// check if two points are equal\nfunction equals( p1, p2 ) {\n\n\treturn p1.x === p2.x && p1.y === p2.y;\n\n}\n\n// check if two segments intersect\nfunction intersects( p1, q1, p2, q2 ) {\n\n\tconst o1 = sign( area( p1, q1, p2 ) );\n\tconst o2 = sign( area( p1, q1, q2 ) );\n\tconst o3 = sign( area( p2, q2, p1 ) );\n\tconst o4 = sign( area( p2, q2, q1 ) );\n\n\tif ( o1 !== o2 && o3 !== o4 ) return true; // general case\n\n\tif ( o1 === 0 && onSegment( p1, p2, q1 ) ) return true; // p1, q1 and p2 are collinear and p2 lies on p1q1\n\tif ( o2 === 0 && onSegment( p1, q2, q1 ) ) return true; // p1, q1 and q2 are collinear and q2 lies on p1q1\n\tif ( o3 === 0 && onSegment( p2, p1, q2 ) ) return true; // p2, q2 and p1 are collinear and p1 lies on p2q2\n\tif ( o4 === 0 && onSegment( p2, q1, q2 ) ) return true; // p2, q2 and q1 are collinear and q1 lies on p2q2\n\n\treturn false;\n\n}\n\n// for collinear points p, q, r, check if point q lies on segment pr\nfunction onSegment( p, q, r ) {\n\n\treturn q.x <= Math.max( p.x, r.x ) && q.x >= Math.min( p.x, r.x ) && q.y <= Math.max( p.y, r.y ) && q.y >= Math.min( p.y, r.y );\n\n}\n\nfunction sign( num ) {\n\n\treturn num > 0 ? 1 : num < 0 ? - 1 : 0;\n\n}\n\n// check if a polygon diagonal intersects any polygon segments\nfunction intersectsPolygon( a, b ) {\n\n\tlet p = a;\n\tdo {\n\n\t\tif ( p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i &&\n\t\t\tintersects( p, p.next, a, b ) ) return true;\n\t\tp = p.next;\n\n\t} while ( p !== a );\n\n\treturn false;\n\n}\n\n// check if a polygon diagonal is locally inside the polygon\nfunction locallyInside( a, b ) {\n\n\treturn area( a.prev, a, a.next ) < 0 ?\n\t\tarea( a, b, a.next ) >= 0 && area( a, a.prev, b ) >= 0 :\n\t\tarea( a, b, a.prev ) < 0 || area( a, a.next, b ) < 0;\n\n}\n\n// check if the middle point of a polygon diagonal is inside the polygon\nfunction middleInside( a, b ) {\n\n\tlet p = a,\n\t\tinside = false;\n\tconst px = ( a.x + b.x ) / 2,\n\t\tpy = ( a.y + b.y ) / 2;\n\tdo {\n\n\t\tif ( ( ( p.y > py ) !== ( p.next.y > py ) ) && p.next.y !== p.y &&\n\t\t\t( px < ( p.next.x - p.x ) * ( py - p.y ) / ( p.next.y - p.y ) + p.x ) )\n\t\t\tinside = ! inside;\n\t\tp = p.next;\n\n\t} while ( p !== a );\n\n\treturn inside;\n\n}\n\n// link two polygon vertices with a bridge; if the vertices belong to the same ring, it splits polygon into two;\n// if one belongs to the outer ring and another to a hole, it merges it into a single ring\nfunction splitPolygon( a, b ) {\n\n\tconst a2 = new Node( a.i, a.x, a.y ),\n\t\tb2 = new Node( b.i, b.x, b.y ),\n\t\tan = a.next,\n\t\tbp = b.prev;\n\n\ta.next = b;\n\tb.prev = a;\n\n\ta2.next = an;\n\tan.prev = a2;\n\n\tb2.next = a2;\n\ta2.prev = b2;\n\n\tbp.next = b2;\n\tb2.prev = bp;\n\n\treturn b2;\n\n}\n\n// create a node and optionally link it with previous one (in a circular doubly linked list)\nfunction insertNode( i, x, y, last ) {\n\n\tconst p = new Node( i, x, y );\n\n\tif ( ! last ) {\n\n\t\tp.prev = p;\n\t\tp.next = p;\n\n\t} else {\n\n\t\tp.next = last.next;\n\t\tp.prev = last;\n\t\tlast.next.prev = p;\n\t\tlast.next = p;\n\n\t}\n\n\treturn p;\n\n}\n\nfunction removeNode( p ) {\n\n\tp.next.prev = p.prev;\n\tp.prev.next = p.next;\n\n\tif ( p.prevZ ) p.prevZ.nextZ = p.nextZ;\n\tif ( p.nextZ ) p.nextZ.prevZ = p.prevZ;\n\n}\n\nfunction Node( i, x, y ) {\n\n\t// vertex index in coordinates array\n\tthis.i = i;\n\n\t// vertex coordinates\n\tthis.x = x;\n\tthis.y = y;\n\n\t// previous and next vertex nodes in a polygon ring\n\tthis.prev = null;\n\tthis.next = null;\n\n\t// z-order curve value\n\tthis.z = 0;\n\n\t// previous and next nodes in z-order\n\tthis.prevZ = null;\n\tthis.nextZ = null;\n\n\t// indicates whether this is a steiner point\n\tthis.steiner = false;\n\n}\n\nfunction signedArea( data, start, end, dim ) {\n\n\tlet sum = 0;\n\tfor ( let i = start, j = end - dim; i < end; i += dim ) {\n\n\t\tsum += ( data[ j ] - data[ i ] ) * ( data[ i + 1 ] + data[ j + 1 ] );\n\t\tj = i;\n\n\t}\n\n\treturn sum;\n\n}\n\nclass ShapeUtils {\n\n\t// calculate area of the contour polygon\n\n\tstatic area( contour ) {\n\n\t\tconst n = contour.length;\n\t\tlet a = 0.0;\n\n\t\tfor ( let p = n - 1, q = 0; q < n; p = q ++ ) {\n\n\t\t\ta += contour[ p ].x * contour[ q ].y - contour[ q ].x * contour[ p ].y;\n\n\t\t}\n\n\t\treturn a * 0.5;\n\n\t}\n\n\tstatic isClockWise( pts ) {\n\n\t\treturn ShapeUtils.area( pts ) < 0;\n\n\t}\n\n\tstatic triangulateShape( contour, holes ) {\n\n\t\tconst vertices = []; // flat array of vertices like [ x0,y0, x1,y1, x2,y2, ... ]\n\t\tconst holeIndices = []; // array of hole indices\n\t\tconst faces = []; // final array of vertex indices like [ [ a,b,d ], [ b,c,d ] ]\n\n\t\tremoveDupEndPts( contour );\n\t\taddContour( vertices, contour );\n\n\t\t//\n\n\t\tlet holeIndex = contour.length;\n\n\t\tholes.forEach( removeDupEndPts );\n\n\t\tfor ( let i = 0; i < holes.length; i ++ ) {\n\n\t\t\tholeIndices.push( holeIndex );\n\t\t\tholeIndex += holes[ i ].length;\n\t\t\taddContour( vertices, holes[ i ] );\n\n\t\t}\n\n\t\t//\n\n\t\tconst triangles = Earcut.triangulate( vertices, holeIndices );\n\n\t\t//\n\n\t\tfor ( let i = 0; i < triangles.length; i += 3 ) {\n\n\t\t\tfaces.push( triangles.slice( i, i + 3 ) );\n\n\t\t}\n\n\t\treturn faces;\n\n\t}\n\n}\n\nfunction removeDupEndPts( points ) {\n\n\tconst l = points.length;\n\n\tif ( l > 2 && points[ l - 1 ].equals( points[ 0 ] ) ) {\n\n\t\tpoints.pop();\n\n\t}\n\n}\n\nfunction addContour( vertices, contour ) {\n\n\tfor ( let i = 0; i < contour.length; i ++ ) {\n\n\t\tvertices.push( contour[ i ].x );\n\t\tvertices.push( contour[ i ].y );\n\n\t}\n\n}\n\n/**\n * Creates extruded geometry from a path shape.\n *\n * parameters = {\n *\n * curveSegments: , // number of points on the curves\n * steps: , // number of points for z-side extrusions / used for subdividing segments of extrude spline too\n * depth: , // Depth to extrude the shape\n *\n * bevelEnabled: , // turn on bevel\n * bevelThickness: , // how deep into the original shape bevel goes\n * bevelSize: , // how far from shape outline (including bevelOffset) is bevel\n * bevelOffset: , // how far from shape outline does bevel start\n * bevelSegments: , // number of bevel layers\n *\n * extrudePath: // curve to extrude shape along\n *\n * UVGenerator: // object that provides UV generator functions\n *\n * }\n */\n\n\nclass ExtrudeGeometry extends BufferGeometry {\n\n\tconstructor( shapes = new Shape( [ new Vector2( 0.5, 0.5 ), new Vector2( - 0.5, 0.5 ), new Vector2( - 0.5, - 0.5 ), new Vector2( 0.5, - 0.5 ) ] ), options = {} ) {\n\n\t\tsuper();\n\n\t\tthis.type = 'ExtrudeGeometry';\n\n\t\tthis.parameters = {\n\t\t\tshapes: shapes,\n\t\t\toptions: options\n\t\t};\n\n\t\tshapes = Array.isArray( shapes ) ? shapes : [ shapes ];\n\n\t\tconst scope = this;\n\n\t\tconst verticesArray = [];\n\t\tconst uvArray = [];\n\n\t\tfor ( let i = 0, l = shapes.length; i < l; i ++ ) {\n\n\t\t\tconst shape = shapes[ i ];\n\t\t\taddShape( shape );\n\n\t\t}\n\n\t\t// build geometry\n\n\t\tthis.setAttribute( 'position', new Float32BufferAttribute( verticesArray, 3 ) );\n\t\tthis.setAttribute( 'uv', new Float32BufferAttribute( uvArray, 2 ) );\n\n\t\tthis.computeVertexNormals();\n\n\t\t// functions\n\n\t\tfunction addShape( shape ) {\n\n\t\t\tconst placeholder = [];\n\n\t\t\t// options\n\n\t\t\tconst curveSegments = options.curveSegments !== undefined ? options.curveSegments : 12;\n\t\t\tconst steps = options.steps !== undefined ? options.steps : 1;\n\t\t\tconst depth = options.depth !== undefined ? options.depth : 1;\n\n\t\t\tlet bevelEnabled = options.bevelEnabled !== undefined ? options.bevelEnabled : true;\n\t\t\tlet bevelThickness = options.bevelThickness !== undefined ? options.bevelThickness : 0.2;\n\t\t\tlet bevelSize = options.bevelSize !== undefined ? options.bevelSize : bevelThickness - 0.1;\n\t\t\tlet bevelOffset = options.bevelOffset !== undefined ? options.bevelOffset : 0;\n\t\t\tlet bevelSegments = options.bevelSegments !== undefined ? options.bevelSegments : 3;\n\n\t\t\tconst extrudePath = options.extrudePath;\n\n\t\t\tconst uvgen = options.UVGenerator !== undefined ? options.UVGenerator : WorldUVGenerator;\n\n\t\t\t//\n\n\t\t\tlet extrudePts, extrudeByPath = false;\n\t\t\tlet splineTube, binormal, normal, position2;\n\n\t\t\tif ( extrudePath ) {\n\n\t\t\t\textrudePts = extrudePath.getSpacedPoints( steps );\n\n\t\t\t\textrudeByPath = true;\n\t\t\t\tbevelEnabled = false; // bevels not supported for path extrusion\n\n\t\t\t\t// SETUP TNB variables\n\n\t\t\t\t// TODO1 - have a .isClosed in spline?\n\n\t\t\t\tsplineTube = extrudePath.computeFrenetFrames( steps, false );\n\n\t\t\t\t// console.log(splineTube, 'splineTube', splineTube.normals.length, 'steps', steps, 'extrudePts', extrudePts.length);\n\n\t\t\t\tbinormal = new Vector3();\n\t\t\t\tnormal = new Vector3();\n\t\t\t\tposition2 = new Vector3();\n\n\t\t\t}\n\n\t\t\t// Safeguards if bevels are not enabled\n\n\t\t\tif ( ! bevelEnabled ) {\n\n\t\t\t\tbevelSegments = 0;\n\t\t\t\tbevelThickness = 0;\n\t\t\t\tbevelSize = 0;\n\t\t\t\tbevelOffset = 0;\n\n\t\t\t}\n\n\t\t\t// Variables initialization\n\n\t\t\tconst shapePoints = shape.extractPoints( curveSegments );\n\n\t\t\tlet vertices = shapePoints.shape;\n\t\t\tconst holes = shapePoints.holes;\n\n\t\t\tconst reverse = ! ShapeUtils.isClockWise( vertices );\n\n\t\t\tif ( reverse ) {\n\n\t\t\t\tvertices = vertices.reverse();\n\n\t\t\t\t// Maybe we should also check if holes are in the opposite direction, just to be safe ...\n\n\t\t\t\tfor ( let h = 0, hl = holes.length; h < hl; h ++ ) {\n\n\t\t\t\t\tconst ahole = holes[ h ];\n\n\t\t\t\t\tif ( ShapeUtils.isClockWise( ahole ) ) {\n\n\t\t\t\t\t\tholes[ h ] = ahole.reverse();\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t}\n\n\n\t\t\tconst faces = ShapeUtils.triangulateShape( vertices, holes );\n\n\t\t\t/* Vertices */\n\n\t\t\tconst contour = vertices; // vertices has all points but contour has only points of circumference\n\n\t\t\tfor ( let h = 0, hl = holes.length; h < hl; h ++ ) {\n\n\t\t\t\tconst ahole = holes[ h ];\n\n\t\t\t\tvertices = vertices.concat( ahole );\n\n\t\t\t}\n\n\n\t\t\tfunction scalePt2( pt, vec, size ) {\n\n\t\t\t\tif ( ! vec ) console.error( 'THREE.ExtrudeGeometry: vec does not exist' );\n\n\t\t\t\treturn pt.clone().addScaledVector( vec, size );\n\n\t\t\t}\n\n\t\t\tconst vlen = vertices.length, flen = faces.length;\n\n\n\t\t\t// Find directions for point movement\n\n\n\t\t\tfunction getBevelVec( inPt, inPrev, inNext ) {\n\n\t\t\t\t// computes for inPt the corresponding point inPt' on a new contour\n\t\t\t\t// shifted by 1 unit (length of normalized vector) to the left\n\t\t\t\t// if we walk along contour clockwise, this new contour is outside the old one\n\t\t\t\t//\n\t\t\t\t// inPt' is the intersection of the two lines parallel to the two\n\t\t\t\t// adjacent edges of inPt at a distance of 1 unit on the left side.\n\n\t\t\t\tlet v_trans_x, v_trans_y, shrink_by; // resulting translation vector for inPt\n\n\t\t\t\t// good reading for geometry algorithms (here: line-line intersection)\n\t\t\t\t// http://geomalgorithms.com/a05-_intersect-1.html\n\n\t\t\t\tconst v_prev_x = inPt.x - inPrev.x,\n\t\t\t\t\tv_prev_y = inPt.y - inPrev.y;\n\t\t\t\tconst v_next_x = inNext.x - inPt.x,\n\t\t\t\t\tv_next_y = inNext.y - inPt.y;\n\n\t\t\t\tconst v_prev_lensq = ( v_prev_x * v_prev_x + v_prev_y * v_prev_y );\n\n\t\t\t\t// check for collinear edges\n\t\t\t\tconst collinear0 = ( v_prev_x * v_next_y - v_prev_y * v_next_x );\n\n\t\t\t\tif ( Math.abs( collinear0 ) > Number.EPSILON ) {\n\n\t\t\t\t\t// not collinear\n\n\t\t\t\t\t// length of vectors for normalizing\n\n\t\t\t\t\tconst v_prev_len = Math.sqrt( v_prev_lensq );\n\t\t\t\t\tconst v_next_len = Math.sqrt( v_next_x * v_next_x + v_next_y * v_next_y );\n\n\t\t\t\t\t// shift adjacent points by unit vectors to the left\n\n\t\t\t\t\tconst ptPrevShift_x = ( inPrev.x - v_prev_y / v_prev_len );\n\t\t\t\t\tconst ptPrevShift_y = ( inPrev.y + v_prev_x / v_prev_len );\n\n\t\t\t\t\tconst ptNextShift_x = ( inNext.x - v_next_y / v_next_len );\n\t\t\t\t\tconst ptNextShift_y = ( inNext.y + v_next_x / v_next_len );\n\n\t\t\t\t\t// scaling factor for v_prev to intersection point\n\n\t\t\t\t\tconst sf = ( ( ptNextShift_x - ptPrevShift_x ) * v_next_y -\n\t\t\t\t\t\t\t( ptNextShift_y - ptPrevShift_y ) * v_next_x ) /\n\t\t\t\t\t\t( v_prev_x * v_next_y - v_prev_y * v_next_x );\n\n\t\t\t\t\t// vector from inPt to intersection point\n\n\t\t\t\t\tv_trans_x = ( ptPrevShift_x + v_prev_x * sf - inPt.x );\n\t\t\t\t\tv_trans_y = ( ptPrevShift_y + v_prev_y * sf - inPt.y );\n\n\t\t\t\t\t// Don't normalize!, otherwise sharp corners become ugly\n\t\t\t\t\t// but prevent crazy spikes\n\t\t\t\t\tconst v_trans_lensq = ( v_trans_x * v_trans_x + v_trans_y * v_trans_y );\n\t\t\t\t\tif ( v_trans_lensq <= 2 ) {\n\n\t\t\t\t\t\treturn new Vector2( v_trans_x, v_trans_y );\n\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\tshrink_by = Math.sqrt( v_trans_lensq / 2 );\n\n\t\t\t\t\t}\n\n\t\t\t\t} else {\n\n\t\t\t\t\t// handle special case of collinear edges\n\n\t\t\t\t\tlet direction_eq = false; // assumes: opposite\n\n\t\t\t\t\tif ( v_prev_x > Number.EPSILON ) {\n\n\t\t\t\t\t\tif ( v_next_x > Number.EPSILON ) {\n\n\t\t\t\t\t\t\tdirection_eq = true;\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\tif ( v_prev_x < - Number.EPSILON ) {\n\n\t\t\t\t\t\t\tif ( v_next_x < - Number.EPSILON ) {\n\n\t\t\t\t\t\t\t\tdirection_eq = true;\n\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\tif ( Math.sign( v_prev_y ) === Math.sign( v_next_y ) ) {\n\n\t\t\t\t\t\t\t\tdirection_eq = true;\n\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}\n\n\t\t\t\t\tif ( direction_eq ) {\n\n\t\t\t\t\t\t// console.log(\"Warning: lines are a straight sequence\");\n\t\t\t\t\t\tv_trans_x = - v_prev_y;\n\t\t\t\t\t\tv_trans_y = v_prev_x;\n\t\t\t\t\t\tshrink_by = Math.sqrt( v_prev_lensq );\n\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\t// console.log(\"Warning: lines are a straight spike\");\n\t\t\t\t\t\tv_trans_x = v_prev_x;\n\t\t\t\t\t\tv_trans_y = v_prev_y;\n\t\t\t\t\t\tshrink_by = Math.sqrt( v_prev_lensq / 2 );\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t\treturn new Vector2( v_trans_x / shrink_by, v_trans_y / shrink_by );\n\n\t\t\t}\n\n\n\t\t\tconst contourMovements = [];\n\n\t\t\tfor ( let i = 0, il = contour.length, j = il - 1, k = i + 1; i < il; i ++, j ++, k ++ ) {\n\n\t\t\t\tif ( j === il ) j = 0;\n\t\t\t\tif ( k === il ) k = 0;\n\n\t\t\t\t// (j)---(i)---(k)\n\t\t\t\t// console.log('i,j,k', i, j , k)\n\n\t\t\t\tcontourMovements[ i ] = getBevelVec( contour[ i ], contour[ j ], contour[ k ] );\n\n\t\t\t}\n\n\t\t\tconst holesMovements = [];\n\t\t\tlet oneHoleMovements, verticesMovements = contourMovements.concat();\n\n\t\t\tfor ( let h = 0, hl = holes.length; h < hl; h ++ ) {\n\n\t\t\t\tconst ahole = holes[ h ];\n\n\t\t\t\toneHoleMovements = [];\n\n\t\t\t\tfor ( let i = 0, il = ahole.length, j = il - 1, k = i + 1; i < il; i ++, j ++, k ++ ) {\n\n\t\t\t\t\tif ( j === il ) j = 0;\n\t\t\t\t\tif ( k === il ) k = 0;\n\n\t\t\t\t\t// (j)---(i)---(k)\n\t\t\t\t\toneHoleMovements[ i ] = getBevelVec( ahole[ i ], ahole[ j ], ahole[ k ] );\n\n\t\t\t\t}\n\n\t\t\t\tholesMovements.push( oneHoleMovements );\n\t\t\t\tverticesMovements = verticesMovements.concat( oneHoleMovements );\n\n\t\t\t}\n\n\n\t\t\t// Loop bevelSegments, 1 for the front, 1 for the back\n\n\t\t\tfor ( let b = 0; b < bevelSegments; b ++ ) {\n\n\t\t\t\t//for ( b = bevelSegments; b > 0; b -- ) {\n\n\t\t\t\tconst t = b / bevelSegments;\n\t\t\t\tconst z = bevelThickness * Math.cos( t * Math.PI / 2 );\n\t\t\t\tconst bs = bevelSize * Math.sin( t * Math.PI / 2 ) + bevelOffset;\n\n\t\t\t\t// contract shape\n\n\t\t\t\tfor ( let i = 0, il = contour.length; i < il; i ++ ) {\n\n\t\t\t\t\tconst vert = scalePt2( contour[ i ], contourMovements[ i ], bs );\n\n\t\t\t\t\tv( vert.x, vert.y, - z );\n\n\t\t\t\t}\n\n\t\t\t\t// expand holes\n\n\t\t\t\tfor ( let h = 0, hl = holes.length; h < hl; h ++ ) {\n\n\t\t\t\t\tconst ahole = holes[ h ];\n\t\t\t\t\toneHoleMovements = holesMovements[ h ];\n\n\t\t\t\t\tfor ( let i = 0, il = ahole.length; i < il; i ++ ) {\n\n\t\t\t\t\t\tconst vert = scalePt2( ahole[ i ], oneHoleMovements[ i ], bs );\n\n\t\t\t\t\t\tv( vert.x, vert.y, - z );\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tconst bs = bevelSize + bevelOffset;\n\n\t\t\t// Back facing vertices\n\n\t\t\tfor ( let i = 0; i < vlen; i ++ ) {\n\n\t\t\t\tconst vert = bevelEnabled ? scalePt2( vertices[ i ], verticesMovements[ i ], bs ) : vertices[ i ];\n\n\t\t\t\tif ( ! extrudeByPath ) {\n\n\t\t\t\t\tv( vert.x, vert.y, 0 );\n\n\t\t\t\t} else {\n\n\t\t\t\t\t// v( vert.x, vert.y + extrudePts[ 0 ].y, extrudePts[ 0 ].x );\n\n\t\t\t\t\tnormal.copy( splineTube.normals[ 0 ] ).multiplyScalar( vert.x );\n\t\t\t\t\tbinormal.copy( splineTube.binormals[ 0 ] ).multiplyScalar( vert.y );\n\n\t\t\t\t\tposition2.copy( extrudePts[ 0 ] ).add( normal ).add( binormal );\n\n\t\t\t\t\tv( position2.x, position2.y, position2.z );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\t// Add stepped vertices...\n\t\t\t// Including front facing vertices\n\n\t\t\tfor ( let s = 1; s <= steps; s ++ ) {\n\n\t\t\t\tfor ( let i = 0; i < vlen; i ++ ) {\n\n\t\t\t\t\tconst vert = bevelEnabled ? scalePt2( vertices[ i ], verticesMovements[ i ], bs ) : vertices[ i ];\n\n\t\t\t\t\tif ( ! extrudeByPath ) {\n\n\t\t\t\t\t\tv( vert.x, vert.y, depth / steps * s );\n\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\t// v( vert.x, vert.y + extrudePts[ s - 1 ].y, extrudePts[ s - 1 ].x );\n\n\t\t\t\t\t\tnormal.copy( splineTube.normals[ s ] ).multiplyScalar( vert.x );\n\t\t\t\t\t\tbinormal.copy( splineTube.binormals[ s ] ).multiplyScalar( vert.y );\n\n\t\t\t\t\t\tposition2.copy( extrudePts[ s ] ).add( normal ).add( binormal );\n\n\t\t\t\t\t\tv( position2.x, position2.y, position2.z );\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t}\n\n\n\t\t\t// Add bevel segments planes\n\n\t\t\t//for ( b = 1; b <= bevelSegments; b ++ ) {\n\t\t\tfor ( let b = bevelSegments - 1; b >= 0; b -- ) {\n\n\t\t\t\tconst t = b / bevelSegments;\n\t\t\t\tconst z = bevelThickness * Math.cos( t * Math.PI / 2 );\n\t\t\t\tconst bs = bevelSize * Math.sin( t * Math.PI / 2 ) + bevelOffset;\n\n\t\t\t\t// contract shape\n\n\t\t\t\tfor ( let i = 0, il = contour.length; i < il; i ++ ) {\n\n\t\t\t\t\tconst vert = scalePt2( contour[ i ], contourMovements[ i ], bs );\n\t\t\t\t\tv( vert.x, vert.y, depth + z );\n\n\t\t\t\t}\n\n\t\t\t\t// expand holes\n\n\t\t\t\tfor ( let h = 0, hl = holes.length; h < hl; h ++ ) {\n\n\t\t\t\t\tconst ahole = holes[ h ];\n\t\t\t\t\toneHoleMovements = holesMovements[ h ];\n\n\t\t\t\t\tfor ( let i = 0, il = ahole.length; i < il; i ++ ) {\n\n\t\t\t\t\t\tconst vert = scalePt2( ahole[ i ], oneHoleMovements[ i ], bs );\n\n\t\t\t\t\t\tif ( ! extrudeByPath ) {\n\n\t\t\t\t\t\t\tv( vert.x, vert.y, depth + z );\n\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\tv( vert.x, vert.y + extrudePts[ steps - 1 ].y, extrudePts[ steps - 1 ].x + z );\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\t/* Faces */\n\n\t\t\t// Top and bottom faces\n\n\t\t\tbuildLidFaces();\n\n\t\t\t// Sides faces\n\n\t\t\tbuildSideFaces();\n\n\n\t\t\t///// Internal functions\n\n\t\t\tfunction buildLidFaces() {\n\n\t\t\t\tconst start = verticesArray.length / 3;\n\n\t\t\t\tif ( bevelEnabled ) {\n\n\t\t\t\t\tlet layer = 0; // steps + 1\n\t\t\t\t\tlet offset = vlen * layer;\n\n\t\t\t\t\t// Bottom faces\n\n\t\t\t\t\tfor ( let i = 0; i < flen; i ++ ) {\n\n\t\t\t\t\t\tconst face = faces[ i ];\n\t\t\t\t\t\tf3( face[ 2 ] + offset, face[ 1 ] + offset, face[ 0 ] + offset );\n\n\t\t\t\t\t}\n\n\t\t\t\t\tlayer = steps + bevelSegments * 2;\n\t\t\t\t\toffset = vlen * layer;\n\n\t\t\t\t\t// Top faces\n\n\t\t\t\t\tfor ( let i = 0; i < flen; i ++ ) {\n\n\t\t\t\t\t\tconst face = faces[ i ];\n\t\t\t\t\t\tf3( face[ 0 ] + offset, face[ 1 ] + offset, face[ 2 ] + offset );\n\n\t\t\t\t\t}\n\n\t\t\t\t} else {\n\n\t\t\t\t\t// Bottom faces\n\n\t\t\t\t\tfor ( let i = 0; i < flen; i ++ ) {\n\n\t\t\t\t\t\tconst face = faces[ i ];\n\t\t\t\t\t\tf3( face[ 2 ], face[ 1 ], face[ 0 ] );\n\n\t\t\t\t\t}\n\n\t\t\t\t\t// Top faces\n\n\t\t\t\t\tfor ( let i = 0; i < flen; i ++ ) {\n\n\t\t\t\t\t\tconst face = faces[ i ];\n\t\t\t\t\t\tf3( face[ 0 ] + vlen * steps, face[ 1 ] + vlen * steps, face[ 2 ] + vlen * steps );\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t\tscope.addGroup( start, verticesArray.length / 3 - start, 0 );\n\n\t\t\t}\n\n\t\t\t// Create faces for the z-sides of the shape\n\n\t\t\tfunction buildSideFaces() {\n\n\t\t\t\tconst start = verticesArray.length / 3;\n\t\t\t\tlet layeroffset = 0;\n\t\t\t\tsidewalls( contour, layeroffset );\n\t\t\t\tlayeroffset += contour.length;\n\n\t\t\t\tfor ( let h = 0, hl = holes.length; h < hl; h ++ ) {\n\n\t\t\t\t\tconst ahole = holes[ h ];\n\t\t\t\t\tsidewalls( ahole, layeroffset );\n\n\t\t\t\t\t//, true\n\t\t\t\t\tlayeroffset += ahole.length;\n\n\t\t\t\t}\n\n\n\t\t\t\tscope.addGroup( start, verticesArray.length / 3 - start, 1 );\n\n\n\t\t\t}\n\n\t\t\tfunction sidewalls( contour, layeroffset ) {\n\n\t\t\t\tlet i = contour.length;\n\n\t\t\t\twhile ( -- i >= 0 ) {\n\n\t\t\t\t\tconst j = i;\n\t\t\t\t\tlet k = i - 1;\n\t\t\t\t\tif ( k < 0 ) k = contour.length - 1;\n\n\t\t\t\t\t//console.log('b', i,j, i-1, k,vertices.length);\n\n\t\t\t\t\tfor ( let s = 0, sl = ( steps + bevelSegments * 2 ); s < sl; s ++ ) {\n\n\t\t\t\t\t\tconst slen1 = vlen * s;\n\t\t\t\t\t\tconst slen2 = vlen * ( s + 1 );\n\n\t\t\t\t\t\tconst a = layeroffset + j + slen1,\n\t\t\t\t\t\t\tb = layeroffset + k + slen1,\n\t\t\t\t\t\t\tc = layeroffset + k + slen2,\n\t\t\t\t\t\t\td = layeroffset + j + slen2;\n\n\t\t\t\t\t\tf4( a, b, c, d );\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tfunction v( x, y, z ) {\n\n\t\t\t\tplaceholder.push( x );\n\t\t\t\tplaceholder.push( y );\n\t\t\t\tplaceholder.push( z );\n\n\t\t\t}\n\n\n\t\t\tfunction f3( a, b, c ) {\n\n\t\t\t\taddVertex( a );\n\t\t\t\taddVertex( b );\n\t\t\t\taddVertex( c );\n\n\t\t\t\tconst nextIndex = verticesArray.length / 3;\n\t\t\t\tconst uvs = uvgen.generateTopUV( scope, verticesArray, nextIndex - 3, nextIndex - 2, nextIndex - 1 );\n\n\t\t\t\taddUV( uvs[ 0 ] );\n\t\t\t\taddUV( uvs[ 1 ] );\n\t\t\t\taddUV( uvs[ 2 ] );\n\n\t\t\t}\n\n\t\t\tfunction f4( a, b, c, d ) {\n\n\t\t\t\taddVertex( a );\n\t\t\t\taddVertex( b );\n\t\t\t\taddVertex( d );\n\n\t\t\t\taddVertex( b );\n\t\t\t\taddVertex( c );\n\t\t\t\taddVertex( d );\n\n\n\t\t\t\tconst nextIndex = verticesArray.length / 3;\n\t\t\t\tconst uvs = uvgen.generateSideWallUV( scope, verticesArray, nextIndex - 6, nextIndex - 3, nextIndex - 2, nextIndex - 1 );\n\n\t\t\t\taddUV( uvs[ 0 ] );\n\t\t\t\taddUV( uvs[ 1 ] );\n\t\t\t\taddUV( uvs[ 3 ] );\n\n\t\t\t\taddUV( uvs[ 1 ] );\n\t\t\t\taddUV( uvs[ 2 ] );\n\t\t\t\taddUV( uvs[ 3 ] );\n\n\t\t\t}\n\n\t\t\tfunction addVertex( index ) {\n\n\t\t\t\tverticesArray.push( placeholder[ index * 3 + 0 ] );\n\t\t\t\tverticesArray.push( placeholder[ index * 3 + 1 ] );\n\t\t\t\tverticesArray.push( placeholder[ index * 3 + 2 ] );\n\n\t\t\t}\n\n\n\t\t\tfunction addUV( vector2 ) {\n\n\t\t\t\tuvArray.push( vector2.x );\n\t\t\t\tuvArray.push( vector2.y );\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.parameters = Object.assign( {}, source.parameters );\n\n\t\treturn this;\n\n\t}\n\n\ttoJSON() {\n\n\t\tconst data = super.toJSON();\n\n\t\tconst shapes = this.parameters.shapes;\n\t\tconst options = this.parameters.options;\n\n\t\treturn toJSON$1( shapes, options, data );\n\n\t}\n\n\tstatic fromJSON( data, shapes ) {\n\n\t\tconst geometryShapes = [];\n\n\t\tfor ( let j = 0, jl = data.shapes.length; j < jl; j ++ ) {\n\n\t\t\tconst shape = shapes[ data.shapes[ j ] ];\n\n\t\t\tgeometryShapes.push( shape );\n\n\t\t}\n\n\t\tconst extrudePath = data.options.extrudePath;\n\n\t\tif ( extrudePath !== undefined ) {\n\n\t\t\tdata.options.extrudePath = new Curves[ extrudePath.type ]().fromJSON( extrudePath );\n\n\t\t}\n\n\t\treturn new ExtrudeGeometry( geometryShapes, data.options );\n\n\t}\n\n}\n\nconst WorldUVGenerator = {\n\n\tgenerateTopUV: function ( geometry, vertices, indexA, indexB, indexC ) {\n\n\t\tconst a_x = vertices[ indexA * 3 ];\n\t\tconst a_y = vertices[ indexA * 3 + 1 ];\n\t\tconst b_x = vertices[ indexB * 3 ];\n\t\tconst b_y = vertices[ indexB * 3 + 1 ];\n\t\tconst c_x = vertices[ indexC * 3 ];\n\t\tconst c_y = vertices[ indexC * 3 + 1 ];\n\n\t\treturn [\n\t\t\tnew Vector2( a_x, a_y ),\n\t\t\tnew Vector2( b_x, b_y ),\n\t\t\tnew Vector2( c_x, c_y )\n\t\t];\n\n\t},\n\n\tgenerateSideWallUV: function ( geometry, vertices, indexA, indexB, indexC, indexD ) {\n\n\t\tconst a_x = vertices[ indexA * 3 ];\n\t\tconst a_y = vertices[ indexA * 3 + 1 ];\n\t\tconst a_z = vertices[ indexA * 3 + 2 ];\n\t\tconst b_x = vertices[ indexB * 3 ];\n\t\tconst b_y = vertices[ indexB * 3 + 1 ];\n\t\tconst b_z = vertices[ indexB * 3 + 2 ];\n\t\tconst c_x = vertices[ indexC * 3 ];\n\t\tconst c_y = vertices[ indexC * 3 + 1 ];\n\t\tconst c_z = vertices[ indexC * 3 + 2 ];\n\t\tconst d_x = vertices[ indexD * 3 ];\n\t\tconst d_y = vertices[ indexD * 3 + 1 ];\n\t\tconst d_z = vertices[ indexD * 3 + 2 ];\n\n\t\tif ( Math.abs( a_y - b_y ) < Math.abs( a_x - b_x ) ) {\n\n\t\t\treturn [\n\t\t\t\tnew Vector2( a_x, 1 - a_z ),\n\t\t\t\tnew Vector2( b_x, 1 - b_z ),\n\t\t\t\tnew Vector2( c_x, 1 - c_z ),\n\t\t\t\tnew Vector2( d_x, 1 - d_z )\n\t\t\t];\n\n\t\t} else {\n\n\t\t\treturn [\n\t\t\t\tnew Vector2( a_y, 1 - a_z ),\n\t\t\t\tnew Vector2( b_y, 1 - b_z ),\n\t\t\t\tnew Vector2( c_y, 1 - c_z ),\n\t\t\t\tnew Vector2( d_y, 1 - d_z )\n\t\t\t];\n\n\t\t}\n\n\t}\n\n};\n\nfunction toJSON$1( shapes, options, data ) {\n\n\tdata.shapes = [];\n\n\tif ( Array.isArray( shapes ) ) {\n\n\t\tfor ( let i = 0, l = shapes.length; i < l; i ++ ) {\n\n\t\t\tconst shape = shapes[ i ];\n\n\t\t\tdata.shapes.push( shape.uuid );\n\n\t\t}\n\n\t} else {\n\n\t\tdata.shapes.push( shapes.uuid );\n\n\t}\n\n\tdata.options = Object.assign( {}, options );\n\n\tif ( options.extrudePath !== undefined ) data.options.extrudePath = options.extrudePath.toJSON();\n\n\treturn data;\n\n}\n\nclass IcosahedronGeometry extends PolyhedronGeometry {\n\n\tconstructor( radius = 1, detail = 0 ) {\n\n\t\tconst t = ( 1 + Math.sqrt( 5 ) ) / 2;\n\n\t\tconst vertices = [\n\t\t\t- 1, t, 0, \t1, t, 0, \t- 1, - t, 0, \t1, - t, 0,\n\t\t\t0, - 1, t, \t0, 1, t,\t0, - 1, - t, \t0, 1, - t,\n\t\t\tt, 0, - 1, \tt, 0, 1, \t- t, 0, - 1, \t- t, 0, 1\n\t\t];\n\n\t\tconst indices = [\n\t\t\t0, 11, 5, \t0, 5, 1, \t0, 1, 7, \t0, 7, 10, \t0, 10, 11,\n\t\t\t1, 5, 9, \t5, 11, 4,\t11, 10, 2,\t10, 7, 6,\t7, 1, 8,\n\t\t\t3, 9, 4, \t3, 4, 2,\t3, 2, 6,\t3, 6, 8,\t3, 8, 9,\n\t\t\t4, 9, 5, \t2, 4, 11,\t6, 2, 10,\t8, 6, 7,\t9, 8, 1\n\t\t];\n\n\t\tsuper( vertices, indices, radius, detail );\n\n\t\tthis.type = 'IcosahedronGeometry';\n\n\t\tthis.parameters = {\n\t\t\tradius: radius,\n\t\t\tdetail: detail\n\t\t};\n\n\t}\n\n\tstatic fromJSON( data ) {\n\n\t\treturn new IcosahedronGeometry( data.radius, data.detail );\n\n\t}\n\n}\n\nclass OctahedronGeometry extends PolyhedronGeometry {\n\n\tconstructor( radius = 1, detail = 0 ) {\n\n\t\tconst vertices = [\n\t\t\t1, 0, 0, \t- 1, 0, 0,\t0, 1, 0,\n\t\t\t0, - 1, 0, \t0, 0, 1,\t0, 0, - 1\n\t\t];\n\n\t\tconst indices = [\n\t\t\t0, 2, 4,\t0, 4, 3,\t0, 3, 5,\n\t\t\t0, 5, 2,\t1, 2, 5,\t1, 5, 3,\n\t\t\t1, 3, 4,\t1, 4, 2\n\t\t];\n\n\t\tsuper( vertices, indices, radius, detail );\n\n\t\tthis.type = 'OctahedronGeometry';\n\n\t\tthis.parameters = {\n\t\t\tradius: radius,\n\t\t\tdetail: detail\n\t\t};\n\n\t}\n\n\tstatic fromJSON( data ) {\n\n\t\treturn new OctahedronGeometry( data.radius, data.detail );\n\n\t}\n\n}\n\nclass RingGeometry extends BufferGeometry {\n\n\tconstructor( innerRadius = 0.5, outerRadius = 1, thetaSegments = 32, phiSegments = 1, thetaStart = 0, thetaLength = Math.PI * 2 ) {\n\n\t\tsuper();\n\n\t\tthis.type = 'RingGeometry';\n\n\t\tthis.parameters = {\n\t\t\tinnerRadius: innerRadius,\n\t\t\touterRadius: outerRadius,\n\t\t\tthetaSegments: thetaSegments,\n\t\t\tphiSegments: phiSegments,\n\t\t\tthetaStart: thetaStart,\n\t\t\tthetaLength: thetaLength\n\t\t};\n\n\t\tthetaSegments = Math.max( 3, thetaSegments );\n\t\tphiSegments = Math.max( 1, phiSegments );\n\n\t\t// buffers\n\n\t\tconst indices = [];\n\t\tconst vertices = [];\n\t\tconst normals = [];\n\t\tconst uvs = [];\n\n\t\t// some helper variables\n\n\t\tlet radius = innerRadius;\n\t\tconst radiusStep = ( ( outerRadius - innerRadius ) / phiSegments );\n\t\tconst vertex = new Vector3();\n\t\tconst uv = new Vector2();\n\n\t\t// generate vertices, normals and uvs\n\n\t\tfor ( let j = 0; j <= phiSegments; j ++ ) {\n\n\t\t\tfor ( let i = 0; i <= thetaSegments; i ++ ) {\n\n\t\t\t\t// values are generate from the inside of the ring to the outside\n\n\t\t\t\tconst segment = thetaStart + i / thetaSegments * thetaLength;\n\n\t\t\t\t// vertex\n\n\t\t\t\tvertex.x = radius * Math.cos( segment );\n\t\t\t\tvertex.y = radius * Math.sin( segment );\n\n\t\t\t\tvertices.push( vertex.x, vertex.y, vertex.z );\n\n\t\t\t\t// normal\n\n\t\t\t\tnormals.push( 0, 0, 1 );\n\n\t\t\t\t// uv\n\n\t\t\t\tuv.x = ( vertex.x / outerRadius + 1 ) / 2;\n\t\t\t\tuv.y = ( vertex.y / outerRadius + 1 ) / 2;\n\n\t\t\t\tuvs.push( uv.x, uv.y );\n\n\t\t\t}\n\n\t\t\t// increase the radius for next row of vertices\n\n\t\t\tradius += radiusStep;\n\n\t\t}\n\n\t\t// indices\n\n\t\tfor ( let j = 0; j < phiSegments; j ++ ) {\n\n\t\t\tconst thetaSegmentLevel = j * ( thetaSegments + 1 );\n\n\t\t\tfor ( let i = 0; i < thetaSegments; i ++ ) {\n\n\t\t\t\tconst segment = i + thetaSegmentLevel;\n\n\t\t\t\tconst a = segment;\n\t\t\t\tconst b = segment + thetaSegments + 1;\n\t\t\t\tconst c = segment + thetaSegments + 2;\n\t\t\t\tconst d = segment + 1;\n\n\t\t\t\t// faces\n\n\t\t\t\tindices.push( a, b, d );\n\t\t\t\tindices.push( b, c, d );\n\n\t\t\t}\n\n\t\t}\n\n\t\t// build geometry\n\n\t\tthis.setIndex( indices );\n\t\tthis.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\n\t\tthis.setAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );\n\t\tthis.setAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.parameters = Object.assign( {}, source.parameters );\n\n\t\treturn this;\n\n\t}\n\n\tstatic fromJSON( data ) {\n\n\t\treturn new RingGeometry( data.innerRadius, data.outerRadius, data.thetaSegments, data.phiSegments, data.thetaStart, data.thetaLength );\n\n\t}\n\n}\n\nclass ShapeGeometry extends BufferGeometry {\n\n\tconstructor( shapes = new Shape( [ new Vector2( 0, 0.5 ), new Vector2( - 0.5, - 0.5 ), new Vector2( 0.5, - 0.5 ) ] ), curveSegments = 12 ) {\n\n\t\tsuper();\n\n\t\tthis.type = 'ShapeGeometry';\n\n\t\tthis.parameters = {\n\t\t\tshapes: shapes,\n\t\t\tcurveSegments: curveSegments\n\t\t};\n\n\t\t// buffers\n\n\t\tconst indices = [];\n\t\tconst vertices = [];\n\t\tconst normals = [];\n\t\tconst uvs = [];\n\n\t\t// helper variables\n\n\t\tlet groupStart = 0;\n\t\tlet groupCount = 0;\n\n\t\t// allow single and array values for \"shapes\" parameter\n\n\t\tif ( Array.isArray( shapes ) === false ) {\n\n\t\t\taddShape( shapes );\n\n\t\t} else {\n\n\t\t\tfor ( let i = 0; i < shapes.length; i ++ ) {\n\n\t\t\t\taddShape( shapes[ i ] );\n\n\t\t\t\tthis.addGroup( groupStart, groupCount, i ); // enables MultiMaterial support\n\n\t\t\t\tgroupStart += groupCount;\n\t\t\t\tgroupCount = 0;\n\n\t\t\t}\n\n\t\t}\n\n\t\t// build geometry\n\n\t\tthis.setIndex( indices );\n\t\tthis.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\n\t\tthis.setAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );\n\t\tthis.setAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );\n\n\n\t\t// helper functions\n\n\t\tfunction addShape( shape ) {\n\n\t\t\tconst indexOffset = vertices.length / 3;\n\t\t\tconst points = shape.extractPoints( curveSegments );\n\n\t\t\tlet shapeVertices = points.shape;\n\t\t\tconst shapeHoles = points.holes;\n\n\t\t\t// check direction of vertices\n\n\t\t\tif ( ShapeUtils.isClockWise( shapeVertices ) === false ) {\n\n\t\t\t\tshapeVertices = shapeVertices.reverse();\n\n\t\t\t}\n\n\t\t\tfor ( let i = 0, l = shapeHoles.length; i < l; i ++ ) {\n\n\t\t\t\tconst shapeHole = shapeHoles[ i ];\n\n\t\t\t\tif ( ShapeUtils.isClockWise( shapeHole ) === true ) {\n\n\t\t\t\t\tshapeHoles[ i ] = shapeHole.reverse();\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tconst faces = ShapeUtils.triangulateShape( shapeVertices, shapeHoles );\n\n\t\t\t// join vertices of inner and outer paths to a single array\n\n\t\t\tfor ( let i = 0, l = shapeHoles.length; i < l; i ++ ) {\n\n\t\t\t\tconst shapeHole = shapeHoles[ i ];\n\t\t\t\tshapeVertices = shapeVertices.concat( shapeHole );\n\n\t\t\t}\n\n\t\t\t// vertices, normals, uvs\n\n\t\t\tfor ( let i = 0, l = shapeVertices.length; i < l; i ++ ) {\n\n\t\t\t\tconst vertex = shapeVertices[ i ];\n\n\t\t\t\tvertices.push( vertex.x, vertex.y, 0 );\n\t\t\t\tnormals.push( 0, 0, 1 );\n\t\t\t\tuvs.push( vertex.x, vertex.y ); // world uvs\n\n\t\t\t}\n\n\t\t\t// indices\n\n\t\t\tfor ( let i = 0, l = faces.length; i < l; i ++ ) {\n\n\t\t\t\tconst face = faces[ i ];\n\n\t\t\t\tconst a = face[ 0 ] + indexOffset;\n\t\t\t\tconst b = face[ 1 ] + indexOffset;\n\t\t\t\tconst c = face[ 2 ] + indexOffset;\n\n\t\t\t\tindices.push( a, b, c );\n\t\t\t\tgroupCount += 3;\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.parameters = Object.assign( {}, source.parameters );\n\n\t\treturn this;\n\n\t}\n\n\ttoJSON() {\n\n\t\tconst data = super.toJSON();\n\n\t\tconst shapes = this.parameters.shapes;\n\n\t\treturn toJSON( shapes, data );\n\n\t}\n\n\tstatic fromJSON( data, shapes ) {\n\n\t\tconst geometryShapes = [];\n\n\t\tfor ( let j = 0, jl = data.shapes.length; j < jl; j ++ ) {\n\n\t\t\tconst shape = shapes[ data.shapes[ j ] ];\n\n\t\t\tgeometryShapes.push( shape );\n\n\t\t}\n\n\t\treturn new ShapeGeometry( geometryShapes, data.curveSegments );\n\n\t}\n\n}\n\nfunction toJSON( shapes, data ) {\n\n\tdata.shapes = [];\n\n\tif ( Array.isArray( shapes ) ) {\n\n\t\tfor ( let i = 0, l = shapes.length; i < l; i ++ ) {\n\n\t\t\tconst shape = shapes[ i ];\n\n\t\t\tdata.shapes.push( shape.uuid );\n\n\t\t}\n\n\t} else {\n\n\t\tdata.shapes.push( shapes.uuid );\n\n\t}\n\n\treturn data;\n\n}\n\nclass SphereGeometry extends BufferGeometry {\n\n\tconstructor( radius = 1, widthSegments = 32, heightSegments = 16, phiStart = 0, phiLength = Math.PI * 2, thetaStart = 0, thetaLength = Math.PI ) {\n\n\t\tsuper();\n\n\t\tthis.type = 'SphereGeometry';\n\n\t\tthis.parameters = {\n\t\t\tradius: radius,\n\t\t\twidthSegments: widthSegments,\n\t\t\theightSegments: heightSegments,\n\t\t\tphiStart: phiStart,\n\t\t\tphiLength: phiLength,\n\t\t\tthetaStart: thetaStart,\n\t\t\tthetaLength: thetaLength\n\t\t};\n\n\t\twidthSegments = Math.max( 3, Math.floor( widthSegments ) );\n\t\theightSegments = Math.max( 2, Math.floor( heightSegments ) );\n\n\t\tconst thetaEnd = Math.min( thetaStart + thetaLength, Math.PI );\n\n\t\tlet index = 0;\n\t\tconst grid = [];\n\n\t\tconst vertex = new Vector3();\n\t\tconst normal = new Vector3();\n\n\t\t// buffers\n\n\t\tconst indices = [];\n\t\tconst vertices = [];\n\t\tconst normals = [];\n\t\tconst uvs = [];\n\n\t\t// generate vertices, normals and uvs\n\n\t\tfor ( let iy = 0; iy <= heightSegments; iy ++ ) {\n\n\t\t\tconst verticesRow = [];\n\n\t\t\tconst v = iy / heightSegments;\n\n\t\t\t// special case for the poles\n\n\t\t\tlet uOffset = 0;\n\n\t\t\tif ( iy === 0 && thetaStart === 0 ) {\n\n\t\t\t\tuOffset = 0.5 / widthSegments;\n\n\t\t\t} else if ( iy === heightSegments && thetaEnd === Math.PI ) {\n\n\t\t\t\tuOffset = - 0.5 / widthSegments;\n\n\t\t\t}\n\n\t\t\tfor ( let ix = 0; ix <= widthSegments; ix ++ ) {\n\n\t\t\t\tconst u = ix / widthSegments;\n\n\t\t\t\t// vertex\n\n\t\t\t\tvertex.x = - radius * Math.cos( phiStart + u * phiLength ) * Math.sin( thetaStart + v * thetaLength );\n\t\t\t\tvertex.y = radius * Math.cos( thetaStart + v * thetaLength );\n\t\t\t\tvertex.z = radius * Math.sin( phiStart + u * phiLength ) * Math.sin( thetaStart + v * thetaLength );\n\n\t\t\t\tvertices.push( vertex.x, vertex.y, vertex.z );\n\n\t\t\t\t// normal\n\n\t\t\t\tnormal.copy( vertex ).normalize();\n\t\t\t\tnormals.push( normal.x, normal.y, normal.z );\n\n\t\t\t\t// uv\n\n\t\t\t\tuvs.push( u + uOffset, 1 - v );\n\n\t\t\t\tverticesRow.push( index ++ );\n\n\t\t\t}\n\n\t\t\tgrid.push( verticesRow );\n\n\t\t}\n\n\t\t// indices\n\n\t\tfor ( let iy = 0; iy < heightSegments; iy ++ ) {\n\n\t\t\tfor ( let ix = 0; ix < widthSegments; ix ++ ) {\n\n\t\t\t\tconst a = grid[ iy ][ ix + 1 ];\n\t\t\t\tconst b = grid[ iy ][ ix ];\n\t\t\t\tconst c = grid[ iy + 1 ][ ix ];\n\t\t\t\tconst d = grid[ iy + 1 ][ ix + 1 ];\n\n\t\t\t\tif ( iy !== 0 || thetaStart > 0 ) indices.push( a, b, d );\n\t\t\t\tif ( iy !== heightSegments - 1 || thetaEnd < Math.PI ) indices.push( b, c, d );\n\n\t\t\t}\n\n\t\t}\n\n\t\t// build geometry\n\n\t\tthis.setIndex( indices );\n\t\tthis.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\n\t\tthis.setAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );\n\t\tthis.setAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.parameters = Object.assign( {}, source.parameters );\n\n\t\treturn this;\n\n\t}\n\n\tstatic fromJSON( data ) {\n\n\t\treturn new SphereGeometry( data.radius, data.widthSegments, data.heightSegments, data.phiStart, data.phiLength, data.thetaStart, data.thetaLength );\n\n\t}\n\n}\n\nclass TetrahedronGeometry extends PolyhedronGeometry {\n\n\tconstructor( radius = 1, detail = 0 ) {\n\n\t\tconst vertices = [\n\t\t\t1, 1, 1, \t- 1, - 1, 1, \t- 1, 1, - 1, \t1, - 1, - 1\n\t\t];\n\n\t\tconst indices = [\n\t\t\t2, 1, 0, \t0, 3, 2,\t1, 3, 0,\t2, 3, 1\n\t\t];\n\n\t\tsuper( vertices, indices, radius, detail );\n\n\t\tthis.type = 'TetrahedronGeometry';\n\n\t\tthis.parameters = {\n\t\t\tradius: radius,\n\t\t\tdetail: detail\n\t\t};\n\n\t}\n\n\tstatic fromJSON( data ) {\n\n\t\treturn new TetrahedronGeometry( data.radius, data.detail );\n\n\t}\n\n}\n\nclass TorusGeometry extends BufferGeometry {\n\n\tconstructor( radius = 1, tube = 0.4, radialSegments = 12, tubularSegments = 48, arc = Math.PI * 2 ) {\n\n\t\tsuper();\n\n\t\tthis.type = 'TorusGeometry';\n\n\t\tthis.parameters = {\n\t\t\tradius: radius,\n\t\t\ttube: tube,\n\t\t\tradialSegments: radialSegments,\n\t\t\ttubularSegments: tubularSegments,\n\t\t\tarc: arc\n\t\t};\n\n\t\tradialSegments = Math.floor( radialSegments );\n\t\ttubularSegments = Math.floor( tubularSegments );\n\n\t\t// buffers\n\n\t\tconst indices = [];\n\t\tconst vertices = [];\n\t\tconst normals = [];\n\t\tconst uvs = [];\n\n\t\t// helper variables\n\n\t\tconst center = new Vector3();\n\t\tconst vertex = new Vector3();\n\t\tconst normal = new Vector3();\n\n\t\t// generate vertices, normals and uvs\n\n\t\tfor ( let j = 0; j <= radialSegments; j ++ ) {\n\n\t\t\tfor ( let i = 0; i <= tubularSegments; i ++ ) {\n\n\t\t\t\tconst u = i / tubularSegments * arc;\n\t\t\t\tconst v = j / radialSegments * Math.PI * 2;\n\n\t\t\t\t// vertex\n\n\t\t\t\tvertex.x = ( radius + tube * Math.cos( v ) ) * Math.cos( u );\n\t\t\t\tvertex.y = ( radius + tube * Math.cos( v ) ) * Math.sin( u );\n\t\t\t\tvertex.z = tube * Math.sin( v );\n\n\t\t\t\tvertices.push( vertex.x, vertex.y, vertex.z );\n\n\t\t\t\t// normal\n\n\t\t\t\tcenter.x = radius * Math.cos( u );\n\t\t\t\tcenter.y = radius * Math.sin( u );\n\t\t\t\tnormal.subVectors( vertex, center ).normalize();\n\n\t\t\t\tnormals.push( normal.x, normal.y, normal.z );\n\n\t\t\t\t// uv\n\n\t\t\t\tuvs.push( i / tubularSegments );\n\t\t\t\tuvs.push( j / radialSegments );\n\n\t\t\t}\n\n\t\t}\n\n\t\t// generate indices\n\n\t\tfor ( let j = 1; j <= radialSegments; j ++ ) {\n\n\t\t\tfor ( let i = 1; i <= tubularSegments; i ++ ) {\n\n\t\t\t\t// indices\n\n\t\t\t\tconst a = ( tubularSegments + 1 ) * j + i - 1;\n\t\t\t\tconst b = ( tubularSegments + 1 ) * ( j - 1 ) + i - 1;\n\t\t\t\tconst c = ( tubularSegments + 1 ) * ( j - 1 ) + i;\n\t\t\t\tconst d = ( tubularSegments + 1 ) * j + i;\n\n\t\t\t\t// faces\n\n\t\t\t\tindices.push( a, b, d );\n\t\t\t\tindices.push( b, c, d );\n\n\t\t\t}\n\n\t\t}\n\n\t\t// build geometry\n\n\t\tthis.setIndex( indices );\n\t\tthis.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\n\t\tthis.setAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );\n\t\tthis.setAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.parameters = Object.assign( {}, source.parameters );\n\n\t\treturn this;\n\n\t}\n\n\tstatic fromJSON( data ) {\n\n\t\treturn new TorusGeometry( data.radius, data.tube, data.radialSegments, data.tubularSegments, data.arc );\n\n\t}\n\n}\n\nclass TorusKnotGeometry extends BufferGeometry {\n\n\tconstructor( radius = 1, tube = 0.4, tubularSegments = 64, radialSegments = 8, p = 2, q = 3 ) {\n\n\t\tsuper();\n\n\t\tthis.type = 'TorusKnotGeometry';\n\n\t\tthis.parameters = {\n\t\t\tradius: radius,\n\t\t\ttube: tube,\n\t\t\ttubularSegments: tubularSegments,\n\t\t\tradialSegments: radialSegments,\n\t\t\tp: p,\n\t\t\tq: q\n\t\t};\n\n\t\ttubularSegments = Math.floor( tubularSegments );\n\t\tradialSegments = Math.floor( radialSegments );\n\n\t\t// buffers\n\n\t\tconst indices = [];\n\t\tconst vertices = [];\n\t\tconst normals = [];\n\t\tconst uvs = [];\n\n\t\t// helper variables\n\n\t\tconst vertex = new Vector3();\n\t\tconst normal = new Vector3();\n\n\t\tconst P1 = new Vector3();\n\t\tconst P2 = new Vector3();\n\n\t\tconst B = new Vector3();\n\t\tconst T = new Vector3();\n\t\tconst N = new Vector3();\n\n\t\t// generate vertices, normals and uvs\n\n\t\tfor ( let i = 0; i <= tubularSegments; ++ i ) {\n\n\t\t\t// the radian \"u\" is used to calculate the position on the torus curve of the current tubular segment\n\n\t\t\tconst u = i / tubularSegments * p * Math.PI * 2;\n\n\t\t\t// now we calculate two points. P1 is our current position on the curve, P2 is a little farther ahead.\n\t\t\t// these points are used to create a special \"coordinate space\", which is necessary to calculate the correct vertex positions\n\n\t\t\tcalculatePositionOnCurve( u, p, q, radius, P1 );\n\t\t\tcalculatePositionOnCurve( u + 0.01, p, q, radius, P2 );\n\n\t\t\t// calculate orthonormal basis\n\n\t\t\tT.subVectors( P2, P1 );\n\t\t\tN.addVectors( P2, P1 );\n\t\t\tB.crossVectors( T, N );\n\t\t\tN.crossVectors( B, T );\n\n\t\t\t// normalize B, N. T can be ignored, we don't use it\n\n\t\t\tB.normalize();\n\t\t\tN.normalize();\n\n\t\t\tfor ( let j = 0; j <= radialSegments; ++ j ) {\n\n\t\t\t\t// now calculate the vertices. they are nothing more than an extrusion of the torus curve.\n\t\t\t\t// because we extrude a shape in the xy-plane, there is no need to calculate a z-value.\n\n\t\t\t\tconst v = j / radialSegments * Math.PI * 2;\n\t\t\t\tconst cx = - tube * Math.cos( v );\n\t\t\t\tconst cy = tube * Math.sin( v );\n\n\t\t\t\t// now calculate the final vertex position.\n\t\t\t\t// first we orient the extrusion with our basis vectors, then we add it to the current position on the curve\n\n\t\t\t\tvertex.x = P1.x + ( cx * N.x + cy * B.x );\n\t\t\t\tvertex.y = P1.y + ( cx * N.y + cy * B.y );\n\t\t\t\tvertex.z = P1.z + ( cx * N.z + cy * B.z );\n\n\t\t\t\tvertices.push( vertex.x, vertex.y, vertex.z );\n\n\t\t\t\t// normal (P1 is always the center/origin of the extrusion, thus we can use it to calculate the normal)\n\n\t\t\t\tnormal.subVectors( vertex, P1 ).normalize();\n\n\t\t\t\tnormals.push( normal.x, normal.y, normal.z );\n\n\t\t\t\t// uv\n\n\t\t\t\tuvs.push( i / tubularSegments );\n\t\t\t\tuvs.push( j / radialSegments );\n\n\t\t\t}\n\n\t\t}\n\n\t\t// generate indices\n\n\t\tfor ( let j = 1; j <= tubularSegments; j ++ ) {\n\n\t\t\tfor ( let i = 1; i <= radialSegments; i ++ ) {\n\n\t\t\t\t// indices\n\n\t\t\t\tconst a = ( radialSegments + 1 ) * ( j - 1 ) + ( i - 1 );\n\t\t\t\tconst b = ( radialSegments + 1 ) * j + ( i - 1 );\n\t\t\t\tconst c = ( radialSegments + 1 ) * j + i;\n\t\t\t\tconst d = ( radialSegments + 1 ) * ( j - 1 ) + i;\n\n\t\t\t\t// faces\n\n\t\t\t\tindices.push( a, b, d );\n\t\t\t\tindices.push( b, c, d );\n\n\t\t\t}\n\n\t\t}\n\n\t\t// build geometry\n\n\t\tthis.setIndex( indices );\n\t\tthis.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\n\t\tthis.setAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );\n\t\tthis.setAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );\n\n\t\t// this function calculates the current position on the torus curve\n\n\t\tfunction calculatePositionOnCurve( u, p, q, radius, position ) {\n\n\t\t\tconst cu = Math.cos( u );\n\t\t\tconst su = Math.sin( u );\n\t\t\tconst quOverP = q / p * u;\n\t\t\tconst cs = Math.cos( quOverP );\n\n\t\t\tposition.x = radius * ( 2 + cs ) * 0.5 * cu;\n\t\t\tposition.y = radius * ( 2 + cs ) * su * 0.5;\n\t\t\tposition.z = radius * Math.sin( quOverP ) * 0.5;\n\n\t\t}\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.parameters = Object.assign( {}, source.parameters );\n\n\t\treturn this;\n\n\t}\n\n\tstatic fromJSON( data ) {\n\n\t\treturn new TorusKnotGeometry( data.radius, data.tube, data.tubularSegments, data.radialSegments, data.p, data.q );\n\n\t}\n\n}\n\nclass TubeGeometry extends BufferGeometry {\n\n\tconstructor( path = new QuadraticBezierCurve3( new Vector3( - 1, - 1, 0 ), new Vector3( - 1, 1, 0 ), new Vector3( 1, 1, 0 ) ), tubularSegments = 64, radius = 1, radialSegments = 8, closed = false ) {\n\n\t\tsuper();\n\n\t\tthis.type = 'TubeGeometry';\n\n\t\tthis.parameters = {\n\t\t\tpath: path,\n\t\t\ttubularSegments: tubularSegments,\n\t\t\tradius: radius,\n\t\t\tradialSegments: radialSegments,\n\t\t\tclosed: closed\n\t\t};\n\n\t\tconst frames = path.computeFrenetFrames( tubularSegments, closed );\n\n\t\t// expose internals\n\n\t\tthis.tangents = frames.tangents;\n\t\tthis.normals = frames.normals;\n\t\tthis.binormals = frames.binormals;\n\n\t\t// helper variables\n\n\t\tconst vertex = new Vector3();\n\t\tconst normal = new Vector3();\n\t\tconst uv = new Vector2();\n\t\tlet P = new Vector3();\n\n\t\t// buffer\n\n\t\tconst vertices = [];\n\t\tconst normals = [];\n\t\tconst uvs = [];\n\t\tconst indices = [];\n\n\t\t// create buffer data\n\n\t\tgenerateBufferData();\n\n\t\t// build geometry\n\n\t\tthis.setIndex( indices );\n\t\tthis.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\n\t\tthis.setAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );\n\t\tthis.setAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );\n\n\t\t// functions\n\n\t\tfunction generateBufferData() {\n\n\t\t\tfor ( let i = 0; i < tubularSegments; i ++ ) {\n\n\t\t\t\tgenerateSegment( i );\n\n\t\t\t}\n\n\t\t\t// if the geometry is not closed, generate the last row of vertices and normals\n\t\t\t// at the regular position on the given path\n\t\t\t//\n\t\t\t// if the geometry is closed, duplicate the first row of vertices and normals (uvs will differ)\n\n\t\t\tgenerateSegment( ( closed === false ) ? tubularSegments : 0 );\n\n\t\t\t// uvs are generated in a separate function.\n\t\t\t// this makes it easy compute correct values for closed geometries\n\n\t\t\tgenerateUVs();\n\n\t\t\t// finally create faces\n\n\t\t\tgenerateIndices();\n\n\t\t}\n\n\t\tfunction generateSegment( i ) {\n\n\t\t\t// we use getPointAt to sample evenly distributed points from the given path\n\n\t\t\tP = path.getPointAt( i / tubularSegments, P );\n\n\t\t\t// retrieve corresponding normal and binormal\n\n\t\t\tconst N = frames.normals[ i ];\n\t\t\tconst B = frames.binormals[ i ];\n\n\t\t\t// generate normals and vertices for the current segment\n\n\t\t\tfor ( let j = 0; j <= radialSegments; j ++ ) {\n\n\t\t\t\tconst v = j / radialSegments * Math.PI * 2;\n\n\t\t\t\tconst sin = Math.sin( v );\n\t\t\t\tconst cos = - Math.cos( v );\n\n\t\t\t\t// normal\n\n\t\t\t\tnormal.x = ( cos * N.x + sin * B.x );\n\t\t\t\tnormal.y = ( cos * N.y + sin * B.y );\n\t\t\t\tnormal.z = ( cos * N.z + sin * B.z );\n\t\t\t\tnormal.normalize();\n\n\t\t\t\tnormals.push( normal.x, normal.y, normal.z );\n\n\t\t\t\t// vertex\n\n\t\t\t\tvertex.x = P.x + radius * normal.x;\n\t\t\t\tvertex.y = P.y + radius * normal.y;\n\t\t\t\tvertex.z = P.z + radius * normal.z;\n\n\t\t\t\tvertices.push( vertex.x, vertex.y, vertex.z );\n\n\t\t\t}\n\n\t\t}\n\n\t\tfunction generateIndices() {\n\n\t\t\tfor ( let j = 1; j <= tubularSegments; j ++ ) {\n\n\t\t\t\tfor ( let i = 1; i <= radialSegments; i ++ ) {\n\n\t\t\t\t\tconst a = ( radialSegments + 1 ) * ( j - 1 ) + ( i - 1 );\n\t\t\t\t\tconst b = ( radialSegments + 1 ) * j + ( i - 1 );\n\t\t\t\t\tconst c = ( radialSegments + 1 ) * j + i;\n\t\t\t\t\tconst d = ( radialSegments + 1 ) * ( j - 1 ) + i;\n\n\t\t\t\t\t// faces\n\n\t\t\t\t\tindices.push( a, b, d );\n\t\t\t\t\tindices.push( b, c, d );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t\tfunction generateUVs() {\n\n\t\t\tfor ( let i = 0; i <= tubularSegments; i ++ ) {\n\n\t\t\t\tfor ( let j = 0; j <= radialSegments; j ++ ) {\n\n\t\t\t\t\tuv.x = i / tubularSegments;\n\t\t\t\t\tuv.y = j / radialSegments;\n\n\t\t\t\t\tuvs.push( uv.x, uv.y );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.parameters = Object.assign( {}, source.parameters );\n\n\t\treturn this;\n\n\t}\n\n\ttoJSON() {\n\n\t\tconst data = super.toJSON();\n\n\t\tdata.path = this.parameters.path.toJSON();\n\n\t\treturn data;\n\n\t}\n\n\tstatic fromJSON( data ) {\n\n\t\t// This only works for built-in curves (e.g. CatmullRomCurve3).\n\t\t// User defined curves or instances of CurvePath will not be deserialized.\n\t\treturn new TubeGeometry(\n\t\t\tnew Curves[ data.path.type ]().fromJSON( data.path ),\n\t\t\tdata.tubularSegments,\n\t\t\tdata.radius,\n\t\t\tdata.radialSegments,\n\t\t\tdata.closed\n\t\t);\n\n\t}\n\n}\n\nclass WireframeGeometry extends BufferGeometry {\n\n\tconstructor( geometry = null ) {\n\n\t\tsuper();\n\n\t\tthis.type = 'WireframeGeometry';\n\n\t\tthis.parameters = {\n\t\t\tgeometry: geometry\n\t\t};\n\n\t\tif ( geometry !== null ) {\n\n\t\t\t// buffer\n\n\t\t\tconst vertices = [];\n\t\t\tconst edges = new Set();\n\n\t\t\t// helper variables\n\n\t\t\tconst start = new Vector3();\n\t\t\tconst end = new Vector3();\n\n\t\t\tif ( geometry.index !== null ) {\n\n\t\t\t\t// indexed BufferGeometry\n\n\t\t\t\tconst position = geometry.attributes.position;\n\t\t\t\tconst indices = geometry.index;\n\t\t\t\tlet groups = geometry.groups;\n\n\t\t\t\tif ( groups.length === 0 ) {\n\n\t\t\t\t\tgroups = [ { start: 0, count: indices.count, materialIndex: 0 } ];\n\n\t\t\t\t}\n\n\t\t\t\t// create a data structure that contains all edges without duplicates\n\n\t\t\t\tfor ( let o = 0, ol = groups.length; o < ol; ++ o ) {\n\n\t\t\t\t\tconst group = groups[ o ];\n\n\t\t\t\t\tconst groupStart = group.start;\n\t\t\t\t\tconst groupCount = group.count;\n\n\t\t\t\t\tfor ( let i = groupStart, l = ( groupStart + groupCount ); i < l; i += 3 ) {\n\n\t\t\t\t\t\tfor ( let j = 0; j < 3; j ++ ) {\n\n\t\t\t\t\t\t\tconst index1 = indices.getX( i + j );\n\t\t\t\t\t\t\tconst index2 = indices.getX( i + ( j + 1 ) % 3 );\n\n\t\t\t\t\t\t\tstart.fromBufferAttribute( position, index1 );\n\t\t\t\t\t\t\tend.fromBufferAttribute( position, index2 );\n\n\t\t\t\t\t\t\tif ( isUniqueEdge( start, end, edges ) === true ) {\n\n\t\t\t\t\t\t\t\tvertices.push( start.x, start.y, start.z );\n\t\t\t\t\t\t\t\tvertices.push( end.x, end.y, end.z );\n\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t} else {\n\n\t\t\t\t// non-indexed BufferGeometry\n\n\t\t\t\tconst position = geometry.attributes.position;\n\n\t\t\t\tfor ( let i = 0, l = ( position.count / 3 ); i < l; i ++ ) {\n\n\t\t\t\t\tfor ( let j = 0; j < 3; j ++ ) {\n\n\t\t\t\t\t\t// three edges per triangle, an edge is represented as (index1, index2)\n\t\t\t\t\t\t// e.g. the first triangle has the following edges: (0,1),(1,2),(2,0)\n\n\t\t\t\t\t\tconst index1 = 3 * i + j;\n\t\t\t\t\t\tconst index2 = 3 * i + ( ( j + 1 ) % 3 );\n\n\t\t\t\t\t\tstart.fromBufferAttribute( position, index1 );\n\t\t\t\t\t\tend.fromBufferAttribute( position, index2 );\n\n\t\t\t\t\t\tif ( isUniqueEdge( start, end, edges ) === true ) {\n\n\t\t\t\t\t\t\tvertices.push( start.x, start.y, start.z );\n\t\t\t\t\t\t\tvertices.push( end.x, end.y, end.z );\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\t// build geometry\n\n\t\t\tthis.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\n\n\t\t}\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.parameters = Object.assign( {}, source.parameters );\n\n\t\treturn this;\n\n\t}\n\n}\n\nfunction isUniqueEdge( start, end, edges ) {\n\n\tconst hash1 = `${start.x},${start.y},${start.z}-${end.x},${end.y},${end.z}`;\n\tconst hash2 = `${end.x},${end.y},${end.z}-${start.x},${start.y},${start.z}`; // coincident edge\n\n\tif ( edges.has( hash1 ) === true || edges.has( hash2 ) === true ) {\n\n\t\treturn false;\n\n\t} else {\n\n\t\tedges.add( hash1 );\n\t\tedges.add( hash2 );\n\t\treturn true;\n\n\t}\n\n}\n\nvar Geometries = /*#__PURE__*/Object.freeze({\n\t__proto__: null,\n\tBoxGeometry: BoxGeometry,\n\tCapsuleGeometry: CapsuleGeometry,\n\tCircleGeometry: CircleGeometry,\n\tConeGeometry: ConeGeometry,\n\tCylinderGeometry: CylinderGeometry,\n\tDodecahedronGeometry: DodecahedronGeometry,\n\tEdgesGeometry: EdgesGeometry,\n\tExtrudeGeometry: ExtrudeGeometry,\n\tIcosahedronGeometry: IcosahedronGeometry,\n\tLatheGeometry: LatheGeometry,\n\tOctahedronGeometry: OctahedronGeometry,\n\tPlaneGeometry: PlaneGeometry,\n\tPolyhedronGeometry: PolyhedronGeometry,\n\tRingGeometry: RingGeometry,\n\tShapeGeometry: ShapeGeometry,\n\tSphereGeometry: SphereGeometry,\n\tTetrahedronGeometry: TetrahedronGeometry,\n\tTorusGeometry: TorusGeometry,\n\tTorusKnotGeometry: TorusKnotGeometry,\n\tTubeGeometry: TubeGeometry,\n\tWireframeGeometry: WireframeGeometry\n});\n\nclass ShadowMaterial extends Material {\n\n\tconstructor( parameters ) {\n\n\t\tsuper();\n\n\t\tthis.isShadowMaterial = true;\n\n\t\tthis.type = 'ShadowMaterial';\n\n\t\tthis.color = new Color( 0x000000 );\n\t\tthis.transparent = true;\n\n\t\tthis.fog = true;\n\n\t\tthis.setValues( parameters );\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.color.copy( source.color );\n\n\t\tthis.fog = source.fog;\n\n\t\treturn this;\n\n\t}\n\n}\n\nclass RawShaderMaterial extends ShaderMaterial {\n\n\tconstructor( parameters ) {\n\n\t\tsuper( parameters );\n\n\t\tthis.isRawShaderMaterial = true;\n\n\t\tthis.type = 'RawShaderMaterial';\n\n\t}\n\n}\n\nclass MeshStandardMaterial extends Material {\n\n\tconstructor( parameters ) {\n\n\t\tsuper();\n\n\t\tthis.isMeshStandardMaterial = true;\n\n\t\tthis.defines = { 'STANDARD': '' };\n\n\t\tthis.type = 'MeshStandardMaterial';\n\n\t\tthis.color = new Color( 0xffffff ); // diffuse\n\t\tthis.roughness = 1.0;\n\t\tthis.metalness = 0.0;\n\n\t\tthis.map = null;\n\n\t\tthis.lightMap = null;\n\t\tthis.lightMapIntensity = 1.0;\n\n\t\tthis.aoMap = null;\n\t\tthis.aoMapIntensity = 1.0;\n\n\t\tthis.emissive = new Color( 0x000000 );\n\t\tthis.emissiveIntensity = 1.0;\n\t\tthis.emissiveMap = null;\n\n\t\tthis.bumpMap = null;\n\t\tthis.bumpScale = 1;\n\n\t\tthis.normalMap = null;\n\t\tthis.normalMapType = TangentSpaceNormalMap;\n\t\tthis.normalScale = new Vector2( 1, 1 );\n\n\t\tthis.displacementMap = null;\n\t\tthis.displacementScale = 1;\n\t\tthis.displacementBias = 0;\n\n\t\tthis.roughnessMap = null;\n\n\t\tthis.metalnessMap = null;\n\n\t\tthis.alphaMap = null;\n\n\t\tthis.envMap = null;\n\t\tthis.envMapRotation = new Euler();\n\t\tthis.envMapIntensity = 1.0;\n\n\t\tthis.wireframe = false;\n\t\tthis.wireframeLinewidth = 1;\n\t\tthis.wireframeLinecap = 'round';\n\t\tthis.wireframeLinejoin = 'round';\n\n\t\tthis.flatShading = false;\n\n\t\tthis.fog = true;\n\n\t\tthis.setValues( parameters );\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.defines = { 'STANDARD': '' };\n\n\t\tthis.color.copy( source.color );\n\t\tthis.roughness = source.roughness;\n\t\tthis.metalness = source.metalness;\n\n\t\tthis.map = source.map;\n\n\t\tthis.lightMap = source.lightMap;\n\t\tthis.lightMapIntensity = source.lightMapIntensity;\n\n\t\tthis.aoMap = source.aoMap;\n\t\tthis.aoMapIntensity = source.aoMapIntensity;\n\n\t\tthis.emissive.copy( source.emissive );\n\t\tthis.emissiveMap = source.emissiveMap;\n\t\tthis.emissiveIntensity = source.emissiveIntensity;\n\n\t\tthis.bumpMap = source.bumpMap;\n\t\tthis.bumpScale = source.bumpScale;\n\n\t\tthis.normalMap = source.normalMap;\n\t\tthis.normalMapType = source.normalMapType;\n\t\tthis.normalScale.copy( source.normalScale );\n\n\t\tthis.displacementMap = source.displacementMap;\n\t\tthis.displacementScale = source.displacementScale;\n\t\tthis.displacementBias = source.displacementBias;\n\n\t\tthis.roughnessMap = source.roughnessMap;\n\n\t\tthis.metalnessMap = source.metalnessMap;\n\n\t\tthis.alphaMap = source.alphaMap;\n\n\t\tthis.envMap = source.envMap;\n\t\tthis.envMapRotation.copy( source.envMapRotation );\n\t\tthis.envMapIntensity = source.envMapIntensity;\n\n\t\tthis.wireframe = source.wireframe;\n\t\tthis.wireframeLinewidth = source.wireframeLinewidth;\n\t\tthis.wireframeLinecap = source.wireframeLinecap;\n\t\tthis.wireframeLinejoin = source.wireframeLinejoin;\n\n\t\tthis.flatShading = source.flatShading;\n\n\t\tthis.fog = source.fog;\n\n\t\treturn this;\n\n\t}\n\n}\n\nclass MeshPhysicalMaterial extends MeshStandardMaterial {\n\n\tconstructor( parameters ) {\n\n\t\tsuper();\n\n\t\tthis.isMeshPhysicalMaterial = true;\n\n\t\tthis.defines = {\n\n\t\t\t'STANDARD': '',\n\t\t\t'PHYSICAL': ''\n\n\t\t};\n\n\t\tthis.type = 'MeshPhysicalMaterial';\n\n\t\tthis.anisotropyRotation = 0;\n\t\tthis.anisotropyMap = null;\n\n\t\tthis.clearcoatMap = null;\n\t\tthis.clearcoatRoughness = 0.0;\n\t\tthis.clearcoatRoughnessMap = null;\n\t\tthis.clearcoatNormalScale = new Vector2( 1, 1 );\n\t\tthis.clearcoatNormalMap = null;\n\n\t\tthis.ior = 1.5;\n\n\t\tObject.defineProperty( this, 'reflectivity', {\n\t\t\tget: function () {\n\n\t\t\t\treturn ( clamp( 2.5 * ( this.ior - 1 ) / ( this.ior + 1 ), 0, 1 ) );\n\n\t\t\t},\n\t\t\tset: function ( reflectivity ) {\n\n\t\t\t\tthis.ior = ( 1 + 0.4 * reflectivity ) / ( 1 - 0.4 * reflectivity );\n\n\t\t\t}\n\t\t} );\n\n\t\tthis.iridescenceMap = null;\n\t\tthis.iridescenceIOR = 1.3;\n\t\tthis.iridescenceThicknessRange = [ 100, 400 ];\n\t\tthis.iridescenceThicknessMap = null;\n\n\t\tthis.sheenColor = new Color( 0x000000 );\n\t\tthis.sheenColorMap = null;\n\t\tthis.sheenRoughness = 1.0;\n\t\tthis.sheenRoughnessMap = null;\n\n\t\tthis.transmissionMap = null;\n\n\t\tthis.thickness = 0;\n\t\tthis.thicknessMap = null;\n\t\tthis.attenuationDistance = Infinity;\n\t\tthis.attenuationColor = new Color( 1, 1, 1 );\n\n\t\tthis.specularIntensity = 1.0;\n\t\tthis.specularIntensityMap = null;\n\t\tthis.specularColor = new Color( 1, 1, 1 );\n\t\tthis.specularColorMap = null;\n\n\t\tthis._anisotropy = 0;\n\t\tthis._clearcoat = 0;\n\t\tthis._iridescence = 0;\n\t\tthis._sheen = 0.0;\n\t\tthis._transmission = 0;\n\n\t\tthis.setValues( parameters );\n\n\t}\n\n\tget anisotropy() {\n\n\t\treturn this._anisotropy;\n\n\t}\n\n\tset anisotropy( value ) {\n\n\t\tif ( this._anisotropy > 0 !== value > 0 ) {\n\n\t\t\tthis.version ++;\n\n\t\t}\n\n\t\tthis._anisotropy = value;\n\n\t}\n\n\tget clearcoat() {\n\n\t\treturn this._clearcoat;\n\n\t}\n\n\tset clearcoat( value ) {\n\n\t\tif ( this._clearcoat > 0 !== value > 0 ) {\n\n\t\t\tthis.version ++;\n\n\t\t}\n\n\t\tthis._clearcoat = value;\n\n\t}\n\n\tget iridescence() {\n\n\t\treturn this._iridescence;\n\n\t}\n\n\tset iridescence( value ) {\n\n\t\tif ( this._iridescence > 0 !== value > 0 ) {\n\n\t\t\tthis.version ++;\n\n\t\t}\n\n\t\tthis._iridescence = value;\n\n\t}\n\n\tget sheen() {\n\n\t\treturn this._sheen;\n\n\t}\n\n\tset sheen( value ) {\n\n\t\tif ( this._sheen > 0 !== value > 0 ) {\n\n\t\t\tthis.version ++;\n\n\t\t}\n\n\t\tthis._sheen = value;\n\n\t}\n\n\tget transmission() {\n\n\t\treturn this._transmission;\n\n\t}\n\n\tset transmission( value ) {\n\n\t\tif ( this._transmission > 0 !== value > 0 ) {\n\n\t\t\tthis.version ++;\n\n\t\t}\n\n\t\tthis._transmission = value;\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.defines = {\n\n\t\t\t'STANDARD': '',\n\t\t\t'PHYSICAL': ''\n\n\t\t};\n\n\t\tthis.anisotropy = source.anisotropy;\n\t\tthis.anisotropyRotation = source.anisotropyRotation;\n\t\tthis.anisotropyMap = source.anisotropyMap;\n\n\t\tthis.clearcoat = source.clearcoat;\n\t\tthis.clearcoatMap = source.clearcoatMap;\n\t\tthis.clearcoatRoughness = source.clearcoatRoughness;\n\t\tthis.clearcoatRoughnessMap = source.clearcoatRoughnessMap;\n\t\tthis.clearcoatNormalMap = source.clearcoatNormalMap;\n\t\tthis.clearcoatNormalScale.copy( source.clearcoatNormalScale );\n\n\t\tthis.ior = source.ior;\n\n\t\tthis.iridescence = source.iridescence;\n\t\tthis.iridescenceMap = source.iridescenceMap;\n\t\tthis.iridescenceIOR = source.iridescenceIOR;\n\t\tthis.iridescenceThicknessRange = [ ...source.iridescenceThicknessRange ];\n\t\tthis.iridescenceThicknessMap = source.iridescenceThicknessMap;\n\n\t\tthis.sheen = source.sheen;\n\t\tthis.sheenColor.copy( source.sheenColor );\n\t\tthis.sheenColorMap = source.sheenColorMap;\n\t\tthis.sheenRoughness = source.sheenRoughness;\n\t\tthis.sheenRoughnessMap = source.sheenRoughnessMap;\n\n\t\tthis.transmission = source.transmission;\n\t\tthis.transmissionMap = source.transmissionMap;\n\n\t\tthis.thickness = source.thickness;\n\t\tthis.thicknessMap = source.thicknessMap;\n\t\tthis.attenuationDistance = source.attenuationDistance;\n\t\tthis.attenuationColor.copy( source.attenuationColor );\n\n\t\tthis.specularIntensity = source.specularIntensity;\n\t\tthis.specularIntensityMap = source.specularIntensityMap;\n\t\tthis.specularColor.copy( source.specularColor );\n\t\tthis.specularColorMap = source.specularColorMap;\n\n\t\treturn this;\n\n\t}\n\n}\n\nclass MeshPhongMaterial extends Material {\n\n\tconstructor( parameters ) {\n\n\t\tsuper();\n\n\t\tthis.isMeshPhongMaterial = true;\n\n\t\tthis.type = 'MeshPhongMaterial';\n\n\t\tthis.color = new Color( 0xffffff ); // diffuse\n\t\tthis.specular = new Color( 0x111111 );\n\t\tthis.shininess = 30;\n\n\t\tthis.map = null;\n\n\t\tthis.lightMap = null;\n\t\tthis.lightMapIntensity = 1.0;\n\n\t\tthis.aoMap = null;\n\t\tthis.aoMapIntensity = 1.0;\n\n\t\tthis.emissive = new Color( 0x000000 );\n\t\tthis.emissiveIntensity = 1.0;\n\t\tthis.emissiveMap = null;\n\n\t\tthis.bumpMap = null;\n\t\tthis.bumpScale = 1;\n\n\t\tthis.normalMap = null;\n\t\tthis.normalMapType = TangentSpaceNormalMap;\n\t\tthis.normalScale = new Vector2( 1, 1 );\n\n\t\tthis.displacementMap = null;\n\t\tthis.displacementScale = 1;\n\t\tthis.displacementBias = 0;\n\n\t\tthis.specularMap = null;\n\n\t\tthis.alphaMap = null;\n\n\t\tthis.envMap = null;\n\t\tthis.envMapRotation = new Euler();\n\t\tthis.combine = MultiplyOperation;\n\t\tthis.reflectivity = 1;\n\t\tthis.refractionRatio = 0.98;\n\n\t\tthis.wireframe = false;\n\t\tthis.wireframeLinewidth = 1;\n\t\tthis.wireframeLinecap = 'round';\n\t\tthis.wireframeLinejoin = 'round';\n\n\t\tthis.flatShading = false;\n\n\t\tthis.fog = true;\n\n\t\tthis.setValues( parameters );\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.color.copy( source.color );\n\t\tthis.specular.copy( source.specular );\n\t\tthis.shininess = source.shininess;\n\n\t\tthis.map = source.map;\n\n\t\tthis.lightMap = source.lightMap;\n\t\tthis.lightMapIntensity = source.lightMapIntensity;\n\n\t\tthis.aoMap = source.aoMap;\n\t\tthis.aoMapIntensity = source.aoMapIntensity;\n\n\t\tthis.emissive.copy( source.emissive );\n\t\tthis.emissiveMap = source.emissiveMap;\n\t\tthis.emissiveIntensity = source.emissiveIntensity;\n\n\t\tthis.bumpMap = source.bumpMap;\n\t\tthis.bumpScale = source.bumpScale;\n\n\t\tthis.normalMap = source.normalMap;\n\t\tthis.normalMapType = source.normalMapType;\n\t\tthis.normalScale.copy( source.normalScale );\n\n\t\tthis.displacementMap = source.displacementMap;\n\t\tthis.displacementScale = source.displacementScale;\n\t\tthis.displacementBias = source.displacementBias;\n\n\t\tthis.specularMap = source.specularMap;\n\n\t\tthis.alphaMap = source.alphaMap;\n\n\t\tthis.envMap = source.envMap;\n\t\tthis.envMapRotation.copy( source.envMapRotation );\n\t\tthis.combine = source.combine;\n\t\tthis.reflectivity = source.reflectivity;\n\t\tthis.refractionRatio = source.refractionRatio;\n\n\t\tthis.wireframe = source.wireframe;\n\t\tthis.wireframeLinewidth = source.wireframeLinewidth;\n\t\tthis.wireframeLinecap = source.wireframeLinecap;\n\t\tthis.wireframeLinejoin = source.wireframeLinejoin;\n\n\t\tthis.flatShading = source.flatShading;\n\n\t\tthis.fog = source.fog;\n\n\t\treturn this;\n\n\t}\n\n}\n\nclass MeshToonMaterial extends Material {\n\n\tconstructor( parameters ) {\n\n\t\tsuper();\n\n\t\tthis.isMeshToonMaterial = true;\n\n\t\tthis.defines = { 'TOON': '' };\n\n\t\tthis.type = 'MeshToonMaterial';\n\n\t\tthis.color = new Color( 0xffffff );\n\n\t\tthis.map = null;\n\t\tthis.gradientMap = null;\n\n\t\tthis.lightMap = null;\n\t\tthis.lightMapIntensity = 1.0;\n\n\t\tthis.aoMap = null;\n\t\tthis.aoMapIntensity = 1.0;\n\n\t\tthis.emissive = new Color( 0x000000 );\n\t\tthis.emissiveIntensity = 1.0;\n\t\tthis.emissiveMap = null;\n\n\t\tthis.bumpMap = null;\n\t\tthis.bumpScale = 1;\n\n\t\tthis.normalMap = null;\n\t\tthis.normalMapType = TangentSpaceNormalMap;\n\t\tthis.normalScale = new Vector2( 1, 1 );\n\n\t\tthis.displacementMap = null;\n\t\tthis.displacementScale = 1;\n\t\tthis.displacementBias = 0;\n\n\t\tthis.alphaMap = null;\n\n\t\tthis.wireframe = false;\n\t\tthis.wireframeLinewidth = 1;\n\t\tthis.wireframeLinecap = 'round';\n\t\tthis.wireframeLinejoin = 'round';\n\n\t\tthis.fog = true;\n\n\t\tthis.setValues( parameters );\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.color.copy( source.color );\n\n\t\tthis.map = source.map;\n\t\tthis.gradientMap = source.gradientMap;\n\n\t\tthis.lightMap = source.lightMap;\n\t\tthis.lightMapIntensity = source.lightMapIntensity;\n\n\t\tthis.aoMap = source.aoMap;\n\t\tthis.aoMapIntensity = source.aoMapIntensity;\n\n\t\tthis.emissive.copy( source.emissive );\n\t\tthis.emissiveMap = source.emissiveMap;\n\t\tthis.emissiveIntensity = source.emissiveIntensity;\n\n\t\tthis.bumpMap = source.bumpMap;\n\t\tthis.bumpScale = source.bumpScale;\n\n\t\tthis.normalMap = source.normalMap;\n\t\tthis.normalMapType = source.normalMapType;\n\t\tthis.normalScale.copy( source.normalScale );\n\n\t\tthis.displacementMap = source.displacementMap;\n\t\tthis.displacementScale = source.displacementScale;\n\t\tthis.displacementBias = source.displacementBias;\n\n\t\tthis.alphaMap = source.alphaMap;\n\n\t\tthis.wireframe = source.wireframe;\n\t\tthis.wireframeLinewidth = source.wireframeLinewidth;\n\t\tthis.wireframeLinecap = source.wireframeLinecap;\n\t\tthis.wireframeLinejoin = source.wireframeLinejoin;\n\n\t\tthis.fog = source.fog;\n\n\t\treturn this;\n\n\t}\n\n}\n\nclass MeshNormalMaterial extends Material {\n\n\tconstructor( parameters ) {\n\n\t\tsuper();\n\n\t\tthis.isMeshNormalMaterial = true;\n\n\t\tthis.type = 'MeshNormalMaterial';\n\n\t\tthis.bumpMap = null;\n\t\tthis.bumpScale = 1;\n\n\t\tthis.normalMap = null;\n\t\tthis.normalMapType = TangentSpaceNormalMap;\n\t\tthis.normalScale = new Vector2( 1, 1 );\n\n\t\tthis.displacementMap = null;\n\t\tthis.displacementScale = 1;\n\t\tthis.displacementBias = 0;\n\n\t\tthis.wireframe = false;\n\t\tthis.wireframeLinewidth = 1;\n\n\t\tthis.flatShading = false;\n\n\t\tthis.setValues( parameters );\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.bumpMap = source.bumpMap;\n\t\tthis.bumpScale = source.bumpScale;\n\n\t\tthis.normalMap = source.normalMap;\n\t\tthis.normalMapType = source.normalMapType;\n\t\tthis.normalScale.copy( source.normalScale );\n\n\t\tthis.displacementMap = source.displacementMap;\n\t\tthis.displacementScale = source.displacementScale;\n\t\tthis.displacementBias = source.displacementBias;\n\n\t\tthis.wireframe = source.wireframe;\n\t\tthis.wireframeLinewidth = source.wireframeLinewidth;\n\n\t\tthis.flatShading = source.flatShading;\n\n\t\treturn this;\n\n\t}\n\n}\n\nclass MeshLambertMaterial extends Material {\n\n\tconstructor( parameters ) {\n\n\t\tsuper();\n\n\t\tthis.isMeshLambertMaterial = true;\n\n\t\tthis.type = 'MeshLambertMaterial';\n\n\t\tthis.color = new Color( 0xffffff ); // diffuse\n\n\t\tthis.map = null;\n\n\t\tthis.lightMap = null;\n\t\tthis.lightMapIntensity = 1.0;\n\n\t\tthis.aoMap = null;\n\t\tthis.aoMapIntensity = 1.0;\n\n\t\tthis.emissive = new Color( 0x000000 );\n\t\tthis.emissiveIntensity = 1.0;\n\t\tthis.emissiveMap = null;\n\n\t\tthis.bumpMap = null;\n\t\tthis.bumpScale = 1;\n\n\t\tthis.normalMap = null;\n\t\tthis.normalMapType = TangentSpaceNormalMap;\n\t\tthis.normalScale = new Vector2( 1, 1 );\n\n\t\tthis.displacementMap = null;\n\t\tthis.displacementScale = 1;\n\t\tthis.displacementBias = 0;\n\n\t\tthis.specularMap = null;\n\n\t\tthis.alphaMap = null;\n\n\t\tthis.envMap = null;\n\t\tthis.envMapRotation = new Euler();\n\t\tthis.combine = MultiplyOperation;\n\t\tthis.reflectivity = 1;\n\t\tthis.refractionRatio = 0.98;\n\n\t\tthis.wireframe = false;\n\t\tthis.wireframeLinewidth = 1;\n\t\tthis.wireframeLinecap = 'round';\n\t\tthis.wireframeLinejoin = 'round';\n\n\t\tthis.flatShading = false;\n\n\t\tthis.fog = true;\n\n\t\tthis.setValues( parameters );\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.color.copy( source.color );\n\n\t\tthis.map = source.map;\n\n\t\tthis.lightMap = source.lightMap;\n\t\tthis.lightMapIntensity = source.lightMapIntensity;\n\n\t\tthis.aoMap = source.aoMap;\n\t\tthis.aoMapIntensity = source.aoMapIntensity;\n\n\t\tthis.emissive.copy( source.emissive );\n\t\tthis.emissiveMap = source.emissiveMap;\n\t\tthis.emissiveIntensity = source.emissiveIntensity;\n\n\t\tthis.bumpMap = source.bumpMap;\n\t\tthis.bumpScale = source.bumpScale;\n\n\t\tthis.normalMap = source.normalMap;\n\t\tthis.normalMapType = source.normalMapType;\n\t\tthis.normalScale.copy( source.normalScale );\n\n\t\tthis.displacementMap = source.displacementMap;\n\t\tthis.displacementScale = source.displacementScale;\n\t\tthis.displacementBias = source.displacementBias;\n\n\t\tthis.specularMap = source.specularMap;\n\n\t\tthis.alphaMap = source.alphaMap;\n\n\t\tthis.envMap = source.envMap;\n\t\tthis.envMapRotation.copy( source.envMapRotation );\n\t\tthis.combine = source.combine;\n\t\tthis.reflectivity = source.reflectivity;\n\t\tthis.refractionRatio = source.refractionRatio;\n\n\t\tthis.wireframe = source.wireframe;\n\t\tthis.wireframeLinewidth = source.wireframeLinewidth;\n\t\tthis.wireframeLinecap = source.wireframeLinecap;\n\t\tthis.wireframeLinejoin = source.wireframeLinejoin;\n\n\t\tthis.flatShading = source.flatShading;\n\n\t\tthis.fog = source.fog;\n\n\t\treturn this;\n\n\t}\n\n}\n\nclass MeshMatcapMaterial extends Material {\n\n\tconstructor( parameters ) {\n\n\t\tsuper();\n\n\t\tthis.isMeshMatcapMaterial = true;\n\n\t\tthis.defines = { 'MATCAP': '' };\n\n\t\tthis.type = 'MeshMatcapMaterial';\n\n\t\tthis.color = new Color( 0xffffff ); // diffuse\n\n\t\tthis.matcap = null;\n\n\t\tthis.map = null;\n\n\t\tthis.bumpMap = null;\n\t\tthis.bumpScale = 1;\n\n\t\tthis.normalMap = null;\n\t\tthis.normalMapType = TangentSpaceNormalMap;\n\t\tthis.normalScale = new Vector2( 1, 1 );\n\n\t\tthis.displacementMap = null;\n\t\tthis.displacementScale = 1;\n\t\tthis.displacementBias = 0;\n\n\t\tthis.alphaMap = null;\n\n\t\tthis.flatShading = false;\n\n\t\tthis.fog = true;\n\n\t\tthis.setValues( parameters );\n\n\t}\n\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.defines = { 'MATCAP': '' };\n\n\t\tthis.color.copy( source.color );\n\n\t\tthis.matcap = source.matcap;\n\n\t\tthis.map = source.map;\n\n\t\tthis.bumpMap = source.bumpMap;\n\t\tthis.bumpScale = source.bumpScale;\n\n\t\tthis.normalMap = source.normalMap;\n\t\tthis.normalMapType = source.normalMapType;\n\t\tthis.normalScale.copy( source.normalScale );\n\n\t\tthis.displacementMap = source.displacementMap;\n\t\tthis.displacementScale = source.displacementScale;\n\t\tthis.displacementBias = source.displacementBias;\n\n\t\tthis.alphaMap = source.alphaMap;\n\n\t\tthis.flatShading = source.flatShading;\n\n\t\tthis.fog = source.fog;\n\n\t\treturn this;\n\n\t}\n\n}\n\nclass LineDashedMaterial extends LineBasicMaterial {\n\n\tconstructor( parameters ) {\n\n\t\tsuper();\n\n\t\tthis.isLineDashedMaterial = true;\n\n\t\tthis.type = 'LineDashedMaterial';\n\n\t\tthis.scale = 1;\n\t\tthis.dashSize = 3;\n\t\tthis.gapSize = 1;\n\n\t\tthis.setValues( parameters );\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.scale = source.scale;\n\t\tthis.dashSize = source.dashSize;\n\t\tthis.gapSize = source.gapSize;\n\n\t\treturn this;\n\n\t}\n\n}\n\n// converts an array to a specific type\nfunction convertArray( array, type, forceClone ) {\n\n\tif ( ! array || // let 'undefined' and 'null' pass\n\t\t! forceClone && array.constructor === type ) return array;\n\n\tif ( typeof type.BYTES_PER_ELEMENT === 'number' ) {\n\n\t\treturn new type( array ); // create typed array\n\n\t}\n\n\treturn Array.prototype.slice.call( array ); // create Array\n\n}\n\nfunction isTypedArray( object ) {\n\n\treturn ArrayBuffer.isView( object ) &&\n\t\t! ( object instanceof DataView );\n\n}\n\n// returns an array by which times and values can be sorted\nfunction getKeyframeOrder( times ) {\n\n\tfunction compareTime( i, j ) {\n\n\t\treturn times[ i ] - times[ j ];\n\n\t}\n\n\tconst n = times.length;\n\tconst result = new Array( n );\n\tfor ( let i = 0; i !== n; ++ i ) result[ i ] = i;\n\n\tresult.sort( compareTime );\n\n\treturn result;\n\n}\n\n// uses the array previously returned by 'getKeyframeOrder' to sort data\nfunction sortedArray( values, stride, order ) {\n\n\tconst nValues = values.length;\n\tconst result = new values.constructor( nValues );\n\n\tfor ( let i = 0, dstOffset = 0; dstOffset !== nValues; ++ i ) {\n\n\t\tconst srcOffset = order[ i ] * stride;\n\n\t\tfor ( let j = 0; j !== stride; ++ j ) {\n\n\t\t\tresult[ dstOffset ++ ] = values[ srcOffset + j ];\n\n\t\t}\n\n\t}\n\n\treturn result;\n\n}\n\n// function for parsing AOS keyframe formats\nfunction flattenJSON( jsonKeys, times, values, valuePropertyName ) {\n\n\tlet i = 1, key = jsonKeys[ 0 ];\n\n\twhile ( key !== undefined && key[ valuePropertyName ] === undefined ) {\n\n\t\tkey = jsonKeys[ i ++ ];\n\n\t}\n\n\tif ( key === undefined ) return; // no data\n\n\tlet value = key[ valuePropertyName ];\n\tif ( value === undefined ) return; // no data\n\n\tif ( Array.isArray( value ) ) {\n\n\t\tdo {\n\n\t\t\tvalue = key[ valuePropertyName ];\n\n\t\t\tif ( value !== undefined ) {\n\n\t\t\t\ttimes.push( key.time );\n\t\t\t\tvalues.push.apply( values, value ); // push all elements\n\n\t\t\t}\n\n\t\t\tkey = jsonKeys[ i ++ ];\n\n\t\t} while ( key !== undefined );\n\n\t} else if ( value.toArray !== undefined ) {\n\n\t\t// ...assume THREE.Math-ish\n\n\t\tdo {\n\n\t\t\tvalue = key[ valuePropertyName ];\n\n\t\t\tif ( value !== undefined ) {\n\n\t\t\t\ttimes.push( key.time );\n\t\t\t\tvalue.toArray( values, values.length );\n\n\t\t\t}\n\n\t\t\tkey = jsonKeys[ i ++ ];\n\n\t\t} while ( key !== undefined );\n\n\t} else {\n\n\t\t// otherwise push as-is\n\n\t\tdo {\n\n\t\t\tvalue = key[ valuePropertyName ];\n\n\t\t\tif ( value !== undefined ) {\n\n\t\t\t\ttimes.push( key.time );\n\t\t\t\tvalues.push( value );\n\n\t\t\t}\n\n\t\t\tkey = jsonKeys[ i ++ ];\n\n\t\t} while ( key !== undefined );\n\n\t}\n\n}\n\nfunction subclip( sourceClip, name, startFrame, endFrame, fps = 30 ) {\n\n\tconst clip = sourceClip.clone();\n\n\tclip.name = name;\n\n\tconst tracks = [];\n\n\tfor ( let i = 0; i < clip.tracks.length; ++ i ) {\n\n\t\tconst track = clip.tracks[ i ];\n\t\tconst valueSize = track.getValueSize();\n\n\t\tconst times = [];\n\t\tconst values = [];\n\n\t\tfor ( let j = 0; j < track.times.length; ++ j ) {\n\n\t\t\tconst frame = track.times[ j ] * fps;\n\n\t\t\tif ( frame < startFrame || frame >= endFrame ) continue;\n\n\t\t\ttimes.push( track.times[ j ] );\n\n\t\t\tfor ( let k = 0; k < valueSize; ++ k ) {\n\n\t\t\t\tvalues.push( track.values[ j * valueSize + k ] );\n\n\t\t\t}\n\n\t\t}\n\n\t\tif ( times.length === 0 ) continue;\n\n\t\ttrack.times = convertArray( times, track.times.constructor );\n\t\ttrack.values = convertArray( values, track.values.constructor );\n\n\t\ttracks.push( track );\n\n\t}\n\n\tclip.tracks = tracks;\n\n\t// find minimum .times value across all tracks in the trimmed clip\n\n\tlet minStartTime = Infinity;\n\n\tfor ( let i = 0; i < clip.tracks.length; ++ i ) {\n\n\t\tif ( minStartTime > clip.tracks[ i ].times[ 0 ] ) {\n\n\t\t\tminStartTime = clip.tracks[ i ].times[ 0 ];\n\n\t\t}\n\n\t}\n\n\t// shift all tracks such that clip begins at t=0\n\n\tfor ( let i = 0; i < clip.tracks.length; ++ i ) {\n\n\t\tclip.tracks[ i ].shift( - 1 * minStartTime );\n\n\t}\n\n\tclip.resetDuration();\n\n\treturn clip;\n\n}\n\nfunction makeClipAdditive( targetClip, referenceFrame = 0, referenceClip = targetClip, fps = 30 ) {\n\n\tif ( fps <= 0 ) fps = 30;\n\n\tconst numTracks = referenceClip.tracks.length;\n\tconst referenceTime = referenceFrame / fps;\n\n\t// Make each track's values relative to the values at the reference frame\n\tfor ( let i = 0; i < numTracks; ++ i ) {\n\n\t\tconst referenceTrack = referenceClip.tracks[ i ];\n\t\tconst referenceTrackType = referenceTrack.ValueTypeName;\n\n\t\t// Skip this track if it's non-numeric\n\t\tif ( referenceTrackType === 'bool' || referenceTrackType === 'string' ) continue;\n\n\t\t// Find the track in the target clip whose name and type matches the reference track\n\t\tconst targetTrack = targetClip.tracks.find( function ( track ) {\n\n\t\t\treturn track.name === referenceTrack.name\n\t\t\t\t&& track.ValueTypeName === referenceTrackType;\n\n\t\t} );\n\n\t\tif ( targetTrack === undefined ) continue;\n\n\t\tlet referenceOffset = 0;\n\t\tconst referenceValueSize = referenceTrack.getValueSize();\n\n\t\tif ( referenceTrack.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline ) {\n\n\t\t\treferenceOffset = referenceValueSize / 3;\n\n\t\t}\n\n\t\tlet targetOffset = 0;\n\t\tconst targetValueSize = targetTrack.getValueSize();\n\n\t\tif ( targetTrack.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline ) {\n\n\t\t\ttargetOffset = targetValueSize / 3;\n\n\t\t}\n\n\t\tconst lastIndex = referenceTrack.times.length - 1;\n\t\tlet referenceValue;\n\n\t\t// Find the value to subtract out of the track\n\t\tif ( referenceTime <= referenceTrack.times[ 0 ] ) {\n\n\t\t\t// Reference frame is earlier than the first keyframe, so just use the first keyframe\n\t\t\tconst startIndex = referenceOffset;\n\t\t\tconst endIndex = referenceValueSize - referenceOffset;\n\t\t\treferenceValue = referenceTrack.values.slice( startIndex, endIndex );\n\n\t\t} else if ( referenceTime >= referenceTrack.times[ lastIndex ] ) {\n\n\t\t\t// Reference frame is after the last keyframe, so just use the last keyframe\n\t\t\tconst startIndex = lastIndex * referenceValueSize + referenceOffset;\n\t\t\tconst endIndex = startIndex + referenceValueSize - referenceOffset;\n\t\t\treferenceValue = referenceTrack.values.slice( startIndex, endIndex );\n\n\t\t} else {\n\n\t\t\t// Interpolate to the reference value\n\t\t\tconst interpolant = referenceTrack.createInterpolant();\n\t\t\tconst startIndex = referenceOffset;\n\t\t\tconst endIndex = referenceValueSize - referenceOffset;\n\t\t\tinterpolant.evaluate( referenceTime );\n\t\t\treferenceValue = interpolant.resultBuffer.slice( startIndex, endIndex );\n\n\t\t}\n\n\t\t// Conjugate the quaternion\n\t\tif ( referenceTrackType === 'quaternion' ) {\n\n\t\t\tconst referenceQuat = new Quaternion().fromArray( referenceValue ).normalize().conjugate();\n\t\t\treferenceQuat.toArray( referenceValue );\n\n\t\t}\n\n\t\t// Subtract the reference value from all of the track values\n\n\t\tconst numTimes = targetTrack.times.length;\n\t\tfor ( let j = 0; j < numTimes; ++ j ) {\n\n\t\t\tconst valueStart = j * targetValueSize + targetOffset;\n\n\t\t\tif ( referenceTrackType === 'quaternion' ) {\n\n\t\t\t\t// Multiply the conjugate for quaternion track types\n\t\t\t\tQuaternion.multiplyQuaternionsFlat(\n\t\t\t\t\ttargetTrack.values,\n\t\t\t\t\tvalueStart,\n\t\t\t\t\treferenceValue,\n\t\t\t\t\t0,\n\t\t\t\t\ttargetTrack.values,\n\t\t\t\t\tvalueStart\n\t\t\t\t);\n\n\t\t\t} else {\n\n\t\t\t\tconst valueEnd = targetValueSize - targetOffset * 2;\n\n\t\t\t\t// Subtract each value for all other numeric track types\n\t\t\t\tfor ( let k = 0; k < valueEnd; ++ k ) {\n\n\t\t\t\t\ttargetTrack.values[ valueStart + k ] -= referenceValue[ k ];\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n\ttargetClip.blendMode = AdditiveAnimationBlendMode;\n\n\treturn targetClip;\n\n}\n\nconst AnimationUtils = {\n\tconvertArray: convertArray,\n\tisTypedArray: isTypedArray,\n\tgetKeyframeOrder: getKeyframeOrder,\n\tsortedArray: sortedArray,\n\tflattenJSON: flattenJSON,\n\tsubclip: subclip,\n\tmakeClipAdditive: makeClipAdditive\n};\n\n/**\n * Abstract base class of interpolants over parametric samples.\n *\n * The parameter domain is one dimensional, typically the time or a path\n * along a curve defined by the data.\n *\n * The sample values can have any dimensionality and derived classes may\n * apply special interpretations to the data.\n *\n * This class provides the interval seek in a Template Method, deferring\n * the actual interpolation to derived classes.\n *\n * Time complexity is O(1) for linear access crossing at most two points\n * and O(log N) for random access, where N is the number of positions.\n *\n * References:\n *\n * \t\thttp://www.oodesign.com/template-method-pattern.html\n *\n */\n\nclass Interpolant {\n\n\tconstructor( parameterPositions, sampleValues, sampleSize, resultBuffer ) {\n\n\t\tthis.parameterPositions = parameterPositions;\n\t\tthis._cachedIndex = 0;\n\n\t\tthis.resultBuffer = resultBuffer !== undefined ?\n\t\t\tresultBuffer : new sampleValues.constructor( sampleSize );\n\t\tthis.sampleValues = sampleValues;\n\t\tthis.valueSize = sampleSize;\n\n\t\tthis.settings = null;\n\t\tthis.DefaultSettings_ = {};\n\n\t}\n\n\tevaluate( t ) {\n\n\t\tconst pp = this.parameterPositions;\n\t\tlet i1 = this._cachedIndex,\n\t\t\tt1 = pp[ i1 ],\n\t\t\tt0 = pp[ i1 - 1 ];\n\n\t\tvalidate_interval: {\n\n\t\t\tseek: {\n\n\t\t\t\tlet right;\n\n\t\t\t\tlinear_scan: {\n\n\t\t\t\t\t//- See http://jsperf.com/comparison-to-undefined/3\n\t\t\t\t\t//- slower code:\n\t\t\t\t\t//-\n\t\t\t\t\t//- \t\t\t\tif ( t >= t1 || t1 === undefined ) {\n\t\t\t\t\tforward_scan: if ( ! ( t < t1 ) ) {\n\n\t\t\t\t\t\tfor ( let giveUpAt = i1 + 2; ; ) {\n\n\t\t\t\t\t\t\tif ( t1 === undefined ) {\n\n\t\t\t\t\t\t\t\tif ( t < t0 ) break forward_scan;\n\n\t\t\t\t\t\t\t\t// after end\n\n\t\t\t\t\t\t\t\ti1 = pp.length;\n\t\t\t\t\t\t\t\tthis._cachedIndex = i1;\n\t\t\t\t\t\t\t\treturn this.copySampleValue_( i1 - 1 );\n\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\tif ( i1 === giveUpAt ) break; // this loop\n\n\t\t\t\t\t\t\tt0 = t1;\n\t\t\t\t\t\t\tt1 = pp[ ++ i1 ];\n\n\t\t\t\t\t\t\tif ( t < t1 ) {\n\n\t\t\t\t\t\t\t\t// we have arrived at the sought interval\n\t\t\t\t\t\t\t\tbreak seek;\n\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// prepare binary search on the right side of the index\n\t\t\t\t\t\tright = pp.length;\n\t\t\t\t\t\tbreak linear_scan;\n\n\t\t\t\t\t}\n\n\t\t\t\t\t//- slower code:\n\t\t\t\t\t//-\t\t\t\t\tif ( t < t0 || t0 === undefined ) {\n\t\t\t\t\tif ( ! ( t >= t0 ) ) {\n\n\t\t\t\t\t\t// looping?\n\n\t\t\t\t\t\tconst t1global = pp[ 1 ];\n\n\t\t\t\t\t\tif ( t < t1global ) {\n\n\t\t\t\t\t\t\ti1 = 2; // + 1, using the scan for the details\n\t\t\t\t\t\t\tt0 = t1global;\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// linear reverse scan\n\n\t\t\t\t\t\tfor ( let giveUpAt = i1 - 2; ; ) {\n\n\t\t\t\t\t\t\tif ( t0 === undefined ) {\n\n\t\t\t\t\t\t\t\t// before start\n\n\t\t\t\t\t\t\t\tthis._cachedIndex = 0;\n\t\t\t\t\t\t\t\treturn this.copySampleValue_( 0 );\n\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\tif ( i1 === giveUpAt ) break; // this loop\n\n\t\t\t\t\t\t\tt1 = t0;\n\t\t\t\t\t\t\tt0 = pp[ -- i1 - 1 ];\n\n\t\t\t\t\t\t\tif ( t >= t0 ) {\n\n\t\t\t\t\t\t\t\t// we have arrived at the sought interval\n\t\t\t\t\t\t\t\tbreak seek;\n\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// prepare binary search on the left side of the index\n\t\t\t\t\t\tright = i1;\n\t\t\t\t\t\ti1 = 0;\n\t\t\t\t\t\tbreak linear_scan;\n\n\t\t\t\t\t}\n\n\t\t\t\t\t// the interval is valid\n\n\t\t\t\t\tbreak validate_interval;\n\n\t\t\t\t} // linear scan\n\n\t\t\t\t// binary search\n\n\t\t\t\twhile ( i1 < right ) {\n\n\t\t\t\t\tconst mid = ( i1 + right ) >>> 1;\n\n\t\t\t\t\tif ( t < pp[ mid ] ) {\n\n\t\t\t\t\t\tright = mid;\n\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\ti1 = mid + 1;\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t\tt1 = pp[ i1 ];\n\t\t\t\tt0 = pp[ i1 - 1 ];\n\n\t\t\t\t// check boundary cases, again\n\n\t\t\t\tif ( t0 === undefined ) {\n\n\t\t\t\t\tthis._cachedIndex = 0;\n\t\t\t\t\treturn this.copySampleValue_( 0 );\n\n\t\t\t\t}\n\n\t\t\t\tif ( t1 === undefined ) {\n\n\t\t\t\t\ti1 = pp.length;\n\t\t\t\t\tthis._cachedIndex = i1;\n\t\t\t\t\treturn this.copySampleValue_( i1 - 1 );\n\n\t\t\t\t}\n\n\t\t\t} // seek\n\n\t\t\tthis._cachedIndex = i1;\n\n\t\t\tthis.intervalChanged_( i1, t0, t1 );\n\n\t\t} // validate_interval\n\n\t\treturn this.interpolate_( i1, t0, t, t1 );\n\n\t}\n\n\tgetSettings_() {\n\n\t\treturn this.settings || this.DefaultSettings_;\n\n\t}\n\n\tcopySampleValue_( index ) {\n\n\t\t// copies a sample value to the result buffer\n\n\t\tconst result = this.resultBuffer,\n\t\t\tvalues = this.sampleValues,\n\t\t\tstride = this.valueSize,\n\t\t\toffset = index * stride;\n\n\t\tfor ( let i = 0; i !== stride; ++ i ) {\n\n\t\t\tresult[ i ] = values[ offset + i ];\n\n\t\t}\n\n\t\treturn result;\n\n\t}\n\n\t// Template methods for derived classes:\n\n\tinterpolate_( /* i1, t0, t, t1 */ ) {\n\n\t\tthrow new Error( 'call to abstract method' );\n\t\t// implementations shall return this.resultBuffer\n\n\t}\n\n\tintervalChanged_( /* i1, t0, t1 */ ) {\n\n\t\t// empty\n\n\t}\n\n}\n\n/**\n * Fast and simple cubic spline interpolant.\n *\n * It was derived from a Hermitian construction setting the first derivative\n * at each sample position to the linear slope between neighboring positions\n * over their parameter interval.\n */\n\nclass CubicInterpolant extends Interpolant {\n\n\tconstructor( parameterPositions, sampleValues, sampleSize, resultBuffer ) {\n\n\t\tsuper( parameterPositions, sampleValues, sampleSize, resultBuffer );\n\n\t\tthis._weightPrev = - 0;\n\t\tthis._offsetPrev = - 0;\n\t\tthis._weightNext = - 0;\n\t\tthis._offsetNext = - 0;\n\n\t\tthis.DefaultSettings_ = {\n\n\t\t\tendingStart: ZeroCurvatureEnding,\n\t\t\tendingEnd: ZeroCurvatureEnding\n\n\t\t};\n\n\t}\n\n\tintervalChanged_( i1, t0, t1 ) {\n\n\t\tconst pp = this.parameterPositions;\n\t\tlet iPrev = i1 - 2,\n\t\t\tiNext = i1 + 1,\n\n\t\t\ttPrev = pp[ iPrev ],\n\t\t\ttNext = pp[ iNext ];\n\n\t\tif ( tPrev === undefined ) {\n\n\t\t\tswitch ( this.getSettings_().endingStart ) {\n\n\t\t\t\tcase ZeroSlopeEnding:\n\n\t\t\t\t\t// f'(t0) = 0\n\t\t\t\t\tiPrev = i1;\n\t\t\t\t\ttPrev = 2 * t0 - t1;\n\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase WrapAroundEnding:\n\n\t\t\t\t\t// use the other end of the curve\n\t\t\t\t\tiPrev = pp.length - 2;\n\t\t\t\t\ttPrev = t0 + pp[ iPrev ] - pp[ iPrev + 1 ];\n\n\t\t\t\t\tbreak;\n\n\t\t\t\tdefault: // ZeroCurvatureEnding\n\n\t\t\t\t\t// f''(t0) = 0 a.k.a. Natural Spline\n\t\t\t\t\tiPrev = i1;\n\t\t\t\t\ttPrev = t1;\n\n\t\t\t}\n\n\t\t}\n\n\t\tif ( tNext === undefined ) {\n\n\t\t\tswitch ( this.getSettings_().endingEnd ) {\n\n\t\t\t\tcase ZeroSlopeEnding:\n\n\t\t\t\t\t// f'(tN) = 0\n\t\t\t\t\tiNext = i1;\n\t\t\t\t\ttNext = 2 * t1 - t0;\n\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase WrapAroundEnding:\n\n\t\t\t\t\t// use the other end of the curve\n\t\t\t\t\tiNext = 1;\n\t\t\t\t\ttNext = t1 + pp[ 1 ] - pp[ 0 ];\n\n\t\t\t\t\tbreak;\n\n\t\t\t\tdefault: // ZeroCurvatureEnding\n\n\t\t\t\t\t// f''(tN) = 0, a.k.a. Natural Spline\n\t\t\t\t\tiNext = i1 - 1;\n\t\t\t\t\ttNext = t0;\n\n\t\t\t}\n\n\t\t}\n\n\t\tconst halfDt = ( t1 - t0 ) * 0.5,\n\t\t\tstride = this.valueSize;\n\n\t\tthis._weightPrev = halfDt / ( t0 - tPrev );\n\t\tthis._weightNext = halfDt / ( tNext - t1 );\n\t\tthis._offsetPrev = iPrev * stride;\n\t\tthis._offsetNext = iNext * stride;\n\n\t}\n\n\tinterpolate_( i1, t0, t, t1 ) {\n\n\t\tconst result = this.resultBuffer,\n\t\t\tvalues = this.sampleValues,\n\t\t\tstride = this.valueSize,\n\n\t\t\to1 = i1 * stride,\t\to0 = o1 - stride,\n\t\t\toP = this._offsetPrev, \toN = this._offsetNext,\n\t\t\twP = this._weightPrev,\twN = this._weightNext,\n\n\t\t\tp = ( t - t0 ) / ( t1 - t0 ),\n\t\t\tpp = p * p,\n\t\t\tppp = pp * p;\n\n\t\t// evaluate polynomials\n\n\t\tconst sP = - wP * ppp + 2 * wP * pp - wP * p;\n\t\tconst s0 = ( 1 + wP ) * ppp + ( - 1.5 - 2 * wP ) * pp + ( - 0.5 + wP ) * p + 1;\n\t\tconst s1 = ( - 1 - wN ) * ppp + ( 1.5 + wN ) * pp + 0.5 * p;\n\t\tconst sN = wN * ppp - wN * pp;\n\n\t\t// combine data linearly\n\n\t\tfor ( let i = 0; i !== stride; ++ i ) {\n\n\t\t\tresult[ i ] =\n\t\t\t\t\tsP * values[ oP + i ] +\n\t\t\t\t\ts0 * values[ o0 + i ] +\n\t\t\t\t\ts1 * values[ o1 + i ] +\n\t\t\t\t\tsN * values[ oN + i ];\n\n\t\t}\n\n\t\treturn result;\n\n\t}\n\n}\n\nclass LinearInterpolant extends Interpolant {\n\n\tconstructor( parameterPositions, sampleValues, sampleSize, resultBuffer ) {\n\n\t\tsuper( parameterPositions, sampleValues, sampleSize, resultBuffer );\n\n\t}\n\n\tinterpolate_( i1, t0, t, t1 ) {\n\n\t\tconst result = this.resultBuffer,\n\t\t\tvalues = this.sampleValues,\n\t\t\tstride = this.valueSize,\n\n\t\t\toffset1 = i1 * stride,\n\t\t\toffset0 = offset1 - stride,\n\n\t\t\tweight1 = ( t - t0 ) / ( t1 - t0 ),\n\t\t\tweight0 = 1 - weight1;\n\n\t\tfor ( let i = 0; i !== stride; ++ i ) {\n\n\t\t\tresult[ i ] =\n\t\t\t\t\tvalues[ offset0 + i ] * weight0 +\n\t\t\t\t\tvalues[ offset1 + i ] * weight1;\n\n\t\t}\n\n\t\treturn result;\n\n\t}\n\n}\n\n/**\n *\n * Interpolant that evaluates to the sample value at the position preceding\n * the parameter.\n */\n\nclass DiscreteInterpolant extends Interpolant {\n\n\tconstructor( parameterPositions, sampleValues, sampleSize, resultBuffer ) {\n\n\t\tsuper( parameterPositions, sampleValues, sampleSize, resultBuffer );\n\n\t}\n\n\tinterpolate_( i1 /*, t0, t, t1 */ ) {\n\n\t\treturn this.copySampleValue_( i1 - 1 );\n\n\t}\n\n}\n\nclass KeyframeTrack {\n\n\tconstructor( name, times, values, interpolation ) {\n\n\t\tif ( name === undefined ) throw new Error( 'THREE.KeyframeTrack: track name is undefined' );\n\t\tif ( times === undefined || times.length === 0 ) throw new Error( 'THREE.KeyframeTrack: no keyframes in track named ' + name );\n\n\t\tthis.name = name;\n\n\t\tthis.times = convertArray( times, this.TimeBufferType );\n\t\tthis.values = convertArray( values, this.ValueBufferType );\n\n\t\tthis.setInterpolation( interpolation || this.DefaultInterpolation );\n\n\t}\n\n\t// Serialization (in static context, because of constructor invocation\n\t// and automatic invocation of .toJSON):\n\n\tstatic toJSON( track ) {\n\n\t\tconst trackType = track.constructor;\n\n\t\tlet json;\n\n\t\t// derived classes can define a static toJSON method\n\t\tif ( trackType.toJSON !== this.toJSON ) {\n\n\t\t\tjson = trackType.toJSON( track );\n\n\t\t} else {\n\n\t\t\t// by default, we assume the data can be serialized as-is\n\t\t\tjson = {\n\n\t\t\t\t'name': track.name,\n\t\t\t\t'times': convertArray( track.times, Array ),\n\t\t\t\t'values': convertArray( track.values, Array )\n\n\t\t\t};\n\n\t\t\tconst interpolation = track.getInterpolation();\n\n\t\t\tif ( interpolation !== track.DefaultInterpolation ) {\n\n\t\t\t\tjson.interpolation = interpolation;\n\n\t\t\t}\n\n\t\t}\n\n\t\tjson.type = track.ValueTypeName; // mandatory\n\n\t\treturn json;\n\n\t}\n\n\tInterpolantFactoryMethodDiscrete( result ) {\n\n\t\treturn new DiscreteInterpolant( this.times, this.values, this.getValueSize(), result );\n\n\t}\n\n\tInterpolantFactoryMethodLinear( result ) {\n\n\t\treturn new LinearInterpolant( this.times, this.values, this.getValueSize(), result );\n\n\t}\n\n\tInterpolantFactoryMethodSmooth( result ) {\n\n\t\treturn new CubicInterpolant( this.times, this.values, this.getValueSize(), result );\n\n\t}\n\n\tsetInterpolation( interpolation ) {\n\n\t\tlet factoryMethod;\n\n\t\tswitch ( interpolation ) {\n\n\t\t\tcase InterpolateDiscrete:\n\n\t\t\t\tfactoryMethod = this.InterpolantFactoryMethodDiscrete;\n\n\t\t\t\tbreak;\n\n\t\t\tcase InterpolateLinear:\n\n\t\t\t\tfactoryMethod = this.InterpolantFactoryMethodLinear;\n\n\t\t\t\tbreak;\n\n\t\t\tcase InterpolateSmooth:\n\n\t\t\t\tfactoryMethod = this.InterpolantFactoryMethodSmooth;\n\n\t\t\t\tbreak;\n\n\t\t}\n\n\t\tif ( factoryMethod === undefined ) {\n\n\t\t\tconst message = 'unsupported interpolation for ' +\n\t\t\t\tthis.ValueTypeName + ' keyframe track named ' + this.name;\n\n\t\t\tif ( this.createInterpolant === undefined ) {\n\n\t\t\t\t// fall back to default, unless the default itself is messed up\n\t\t\t\tif ( interpolation !== this.DefaultInterpolation ) {\n\n\t\t\t\t\tthis.setInterpolation( this.DefaultInterpolation );\n\n\t\t\t\t} else {\n\n\t\t\t\t\tthrow new Error( message ); // fatal, in this case\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tconsole.warn( 'THREE.KeyframeTrack:', message );\n\t\t\treturn this;\n\n\t\t}\n\n\t\tthis.createInterpolant = factoryMethod;\n\n\t\treturn this;\n\n\t}\n\n\tgetInterpolation() {\n\n\t\tswitch ( this.createInterpolant ) {\n\n\t\t\tcase this.InterpolantFactoryMethodDiscrete:\n\n\t\t\t\treturn InterpolateDiscrete;\n\n\t\t\tcase this.InterpolantFactoryMethodLinear:\n\n\t\t\t\treturn InterpolateLinear;\n\n\t\t\tcase this.InterpolantFactoryMethodSmooth:\n\n\t\t\t\treturn InterpolateSmooth;\n\n\t\t}\n\n\t}\n\n\tgetValueSize() {\n\n\t\treturn this.values.length / this.times.length;\n\n\t}\n\n\t// move all keyframes either forwards or backwards in time\n\tshift( timeOffset ) {\n\n\t\tif ( timeOffset !== 0.0 ) {\n\n\t\t\tconst times = this.times;\n\n\t\t\tfor ( let i = 0, n = times.length; i !== n; ++ i ) {\n\n\t\t\t\ttimes[ i ] += timeOffset;\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\t// scale all keyframe times by a factor (useful for frame <-> seconds conversions)\n\tscale( timeScale ) {\n\n\t\tif ( timeScale !== 1.0 ) {\n\n\t\t\tconst times = this.times;\n\n\t\t\tfor ( let i = 0, n = times.length; i !== n; ++ i ) {\n\n\t\t\t\ttimes[ i ] *= timeScale;\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\t// removes keyframes before and after animation without changing any values within the range [startTime, endTime].\n\t// IMPORTANT: We do not shift around keys to the start of the track time, because for interpolated keys this will change their values\n\ttrim( startTime, endTime ) {\n\n\t\tconst times = this.times,\n\t\t\tnKeys = times.length;\n\n\t\tlet from = 0,\n\t\t\tto = nKeys - 1;\n\n\t\twhile ( from !== nKeys && times[ from ] < startTime ) {\n\n\t\t\t++ from;\n\n\t\t}\n\n\t\twhile ( to !== - 1 && times[ to ] > endTime ) {\n\n\t\t\t-- to;\n\n\t\t}\n\n\t\t++ to; // inclusive -> exclusive bound\n\n\t\tif ( from !== 0 || to !== nKeys ) {\n\n\t\t\t// empty tracks are forbidden, so keep at least one keyframe\n\t\t\tif ( from >= to ) {\n\n\t\t\t\tto = Math.max( to, 1 );\n\t\t\t\tfrom = to - 1;\n\n\t\t\t}\n\n\t\t\tconst stride = this.getValueSize();\n\t\t\tthis.times = times.slice( from, to );\n\t\t\tthis.values = this.values.slice( from * stride, to * stride );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\t// ensure we do not get a GarbageInGarbageOut situation, make sure tracks are at least minimally viable\n\tvalidate() {\n\n\t\tlet valid = true;\n\n\t\tconst valueSize = this.getValueSize();\n\t\tif ( valueSize - Math.floor( valueSize ) !== 0 ) {\n\n\t\t\tconsole.error( 'THREE.KeyframeTrack: Invalid value size in track.', this );\n\t\t\tvalid = false;\n\n\t\t}\n\n\t\tconst times = this.times,\n\t\t\tvalues = this.values,\n\n\t\t\tnKeys = times.length;\n\n\t\tif ( nKeys === 0 ) {\n\n\t\t\tconsole.error( 'THREE.KeyframeTrack: Track is empty.', this );\n\t\t\tvalid = false;\n\n\t\t}\n\n\t\tlet prevTime = null;\n\n\t\tfor ( let i = 0; i !== nKeys; i ++ ) {\n\n\t\t\tconst currTime = times[ i ];\n\n\t\t\tif ( typeof currTime === 'number' && isNaN( currTime ) ) {\n\n\t\t\t\tconsole.error( 'THREE.KeyframeTrack: Time is not a valid number.', this, i, currTime );\n\t\t\t\tvalid = false;\n\t\t\t\tbreak;\n\n\t\t\t}\n\n\t\t\tif ( prevTime !== null && prevTime > currTime ) {\n\n\t\t\t\tconsole.error( 'THREE.KeyframeTrack: Out of order keys.', this, i, currTime, prevTime );\n\t\t\t\tvalid = false;\n\t\t\t\tbreak;\n\n\t\t\t}\n\n\t\t\tprevTime = currTime;\n\n\t\t}\n\n\t\tif ( values !== undefined ) {\n\n\t\t\tif ( isTypedArray( values ) ) {\n\n\t\t\t\tfor ( let i = 0, n = values.length; i !== n; ++ i ) {\n\n\t\t\t\t\tconst value = values[ i ];\n\n\t\t\t\t\tif ( isNaN( value ) ) {\n\n\t\t\t\t\t\tconsole.error( 'THREE.KeyframeTrack: Value is not a valid number.', this, i, value );\n\t\t\t\t\t\tvalid = false;\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn valid;\n\n\t}\n\n\t// removes equivalent sequential keys as common in morph target sequences\n\t// (0,0,0,0,1,1,1,0,0,0,0,0,0,0) --> (0,0,1,1,0,0)\n\toptimize() {\n\n\t\t// times or values may be shared with other tracks, so overwriting is unsafe\n\t\tconst times = this.times.slice(),\n\t\t\tvalues = this.values.slice(),\n\t\t\tstride = this.getValueSize(),\n\n\t\t\tsmoothInterpolation = this.getInterpolation() === InterpolateSmooth,\n\n\t\t\tlastIndex = times.length - 1;\n\n\t\tlet writeIndex = 1;\n\n\t\tfor ( let i = 1; i < lastIndex; ++ i ) {\n\n\t\t\tlet keep = false;\n\n\t\t\tconst time = times[ i ];\n\t\t\tconst timeNext = times[ i + 1 ];\n\n\t\t\t// remove adjacent keyframes scheduled at the same time\n\n\t\t\tif ( time !== timeNext && ( i !== 1 || time !== times[ 0 ] ) ) {\n\n\t\t\t\tif ( ! smoothInterpolation ) {\n\n\t\t\t\t\t// remove unnecessary keyframes same as their neighbors\n\n\t\t\t\t\tconst offset = i * stride,\n\t\t\t\t\t\toffsetP = offset - stride,\n\t\t\t\t\t\toffsetN = offset + stride;\n\n\t\t\t\t\tfor ( let j = 0; j !== stride; ++ j ) {\n\n\t\t\t\t\t\tconst value = values[ offset + j ];\n\n\t\t\t\t\t\tif ( value !== values[ offsetP + j ] ||\n\t\t\t\t\t\t\tvalue !== values[ offsetN + j ] ) {\n\n\t\t\t\t\t\t\tkeep = true;\n\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}\n\n\t\t\t\t} else {\n\n\t\t\t\t\tkeep = true;\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\t// in-place compaction\n\n\t\t\tif ( keep ) {\n\n\t\t\t\tif ( i !== writeIndex ) {\n\n\t\t\t\t\ttimes[ writeIndex ] = times[ i ];\n\n\t\t\t\t\tconst readOffset = i * stride,\n\t\t\t\t\t\twriteOffset = writeIndex * stride;\n\n\t\t\t\t\tfor ( let j = 0; j !== stride; ++ j ) {\n\n\t\t\t\t\t\tvalues[ writeOffset + j ] = values[ readOffset + j ];\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t\t++ writeIndex;\n\n\t\t\t}\n\n\t\t}\n\n\t\t// flush last keyframe (compaction looks ahead)\n\n\t\tif ( lastIndex > 0 ) {\n\n\t\t\ttimes[ writeIndex ] = times[ lastIndex ];\n\n\t\t\tfor ( let readOffset = lastIndex * stride, writeOffset = writeIndex * stride, j = 0; j !== stride; ++ j ) {\n\n\t\t\t\tvalues[ writeOffset + j ] = values[ readOffset + j ];\n\n\t\t\t}\n\n\t\t\t++ writeIndex;\n\n\t\t}\n\n\t\tif ( writeIndex !== times.length ) {\n\n\t\t\tthis.times = times.slice( 0, writeIndex );\n\t\t\tthis.values = values.slice( 0, writeIndex * stride );\n\n\t\t} else {\n\n\t\t\tthis.times = times;\n\t\t\tthis.values = values;\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tclone() {\n\n\t\tconst times = this.times.slice();\n\t\tconst values = this.values.slice();\n\n\t\tconst TypedKeyframeTrack = this.constructor;\n\t\tconst track = new TypedKeyframeTrack( this.name, times, values );\n\n\t\t// Interpolant argument to constructor is not saved, so copy the factory method directly.\n\t\ttrack.createInterpolant = this.createInterpolant;\n\n\t\treturn track;\n\n\t}\n\n}\n\nKeyframeTrack.prototype.TimeBufferType = Float32Array;\nKeyframeTrack.prototype.ValueBufferType = Float32Array;\nKeyframeTrack.prototype.DefaultInterpolation = InterpolateLinear;\n\n/**\n * A Track of Boolean keyframe values.\n */\nclass BooleanKeyframeTrack extends KeyframeTrack {}\n\nBooleanKeyframeTrack.prototype.ValueTypeName = 'bool';\nBooleanKeyframeTrack.prototype.ValueBufferType = Array;\nBooleanKeyframeTrack.prototype.DefaultInterpolation = InterpolateDiscrete;\nBooleanKeyframeTrack.prototype.InterpolantFactoryMethodLinear = undefined;\nBooleanKeyframeTrack.prototype.InterpolantFactoryMethodSmooth = undefined;\n\n/**\n * A Track of keyframe values that represent color.\n */\nclass ColorKeyframeTrack extends KeyframeTrack {}\n\nColorKeyframeTrack.prototype.ValueTypeName = 'color';\n\n/**\n * A Track of numeric keyframe values.\n */\nclass NumberKeyframeTrack extends KeyframeTrack {}\n\nNumberKeyframeTrack.prototype.ValueTypeName = 'number';\n\n/**\n * Spherical linear unit quaternion interpolant.\n */\n\nclass QuaternionLinearInterpolant extends Interpolant {\n\n\tconstructor( parameterPositions, sampleValues, sampleSize, resultBuffer ) {\n\n\t\tsuper( parameterPositions, sampleValues, sampleSize, resultBuffer );\n\n\t}\n\n\tinterpolate_( i1, t0, t, t1 ) {\n\n\t\tconst result = this.resultBuffer,\n\t\t\tvalues = this.sampleValues,\n\t\t\tstride = this.valueSize,\n\n\t\t\talpha = ( t - t0 ) / ( t1 - t0 );\n\n\t\tlet offset = i1 * stride;\n\n\t\tfor ( let end = offset + stride; offset !== end; offset += 4 ) {\n\n\t\t\tQuaternion.slerpFlat( result, 0, values, offset - stride, values, offset, alpha );\n\n\t\t}\n\n\t\treturn result;\n\n\t}\n\n}\n\n/**\n * A Track of quaternion keyframe values.\n */\nclass QuaternionKeyframeTrack extends KeyframeTrack {\n\n\tInterpolantFactoryMethodLinear( result ) {\n\n\t\treturn new QuaternionLinearInterpolant( this.times, this.values, this.getValueSize(), result );\n\n\t}\n\n}\n\nQuaternionKeyframeTrack.prototype.ValueTypeName = 'quaternion';\n// ValueBufferType is inherited\nQuaternionKeyframeTrack.prototype.DefaultInterpolation = InterpolateLinear;\nQuaternionKeyframeTrack.prototype.InterpolantFactoryMethodSmooth = undefined;\n\n/**\n * A Track that interpolates Strings\n */\nclass StringKeyframeTrack extends KeyframeTrack {}\n\nStringKeyframeTrack.prototype.ValueTypeName = 'string';\nStringKeyframeTrack.prototype.ValueBufferType = Array;\nStringKeyframeTrack.prototype.DefaultInterpolation = InterpolateDiscrete;\nStringKeyframeTrack.prototype.InterpolantFactoryMethodLinear = undefined;\nStringKeyframeTrack.prototype.InterpolantFactoryMethodSmooth = undefined;\n\n/**\n * A Track of vectored keyframe values.\n */\nclass VectorKeyframeTrack extends KeyframeTrack {}\n\nVectorKeyframeTrack.prototype.ValueTypeName = 'vector';\n\nclass AnimationClip {\n\n\tconstructor( name = '', duration = - 1, tracks = [], blendMode = NormalAnimationBlendMode ) {\n\n\t\tthis.name = name;\n\t\tthis.tracks = tracks;\n\t\tthis.duration = duration;\n\t\tthis.blendMode = blendMode;\n\n\t\tthis.uuid = generateUUID();\n\n\t\t// this means it should figure out its duration by scanning the tracks\n\t\tif ( this.duration < 0 ) {\n\n\t\t\tthis.resetDuration();\n\n\t\t}\n\n\t}\n\n\n\tstatic parse( json ) {\n\n\t\tconst tracks = [],\n\t\t\tjsonTracks = json.tracks,\n\t\t\tframeTime = 1.0 / ( json.fps || 1.0 );\n\n\t\tfor ( let i = 0, n = jsonTracks.length; i !== n; ++ i ) {\n\n\t\t\ttracks.push( parseKeyframeTrack( jsonTracks[ i ] ).scale( frameTime ) );\n\n\t\t}\n\n\t\tconst clip = new this( json.name, json.duration, tracks, json.blendMode );\n\t\tclip.uuid = json.uuid;\n\n\t\treturn clip;\n\n\t}\n\n\tstatic toJSON( clip ) {\n\n\t\tconst tracks = [],\n\t\t\tclipTracks = clip.tracks;\n\n\t\tconst json = {\n\n\t\t\t'name': clip.name,\n\t\t\t'duration': clip.duration,\n\t\t\t'tracks': tracks,\n\t\t\t'uuid': clip.uuid,\n\t\t\t'blendMode': clip.blendMode\n\n\t\t};\n\n\t\tfor ( let i = 0, n = clipTracks.length; i !== n; ++ i ) {\n\n\t\t\ttracks.push( KeyframeTrack.toJSON( clipTracks[ i ] ) );\n\n\t\t}\n\n\t\treturn json;\n\n\t}\n\n\tstatic CreateFromMorphTargetSequence( name, morphTargetSequence, fps, noLoop ) {\n\n\t\tconst numMorphTargets = morphTargetSequence.length;\n\t\tconst tracks = [];\n\n\t\tfor ( let i = 0; i < numMorphTargets; i ++ ) {\n\n\t\t\tlet times = [];\n\t\t\tlet values = [];\n\n\t\t\ttimes.push(\n\t\t\t\t( i + numMorphTargets - 1 ) % numMorphTargets,\n\t\t\t\ti,\n\t\t\t\t( i + 1 ) % numMorphTargets );\n\n\t\t\tvalues.push( 0, 1, 0 );\n\n\t\t\tconst order = getKeyframeOrder( times );\n\t\t\ttimes = sortedArray( times, 1, order );\n\t\t\tvalues = sortedArray( values, 1, order );\n\n\t\t\t// if there is a key at the first frame, duplicate it as the\n\t\t\t// last frame as well for perfect loop.\n\t\t\tif ( ! noLoop && times[ 0 ] === 0 ) {\n\n\t\t\t\ttimes.push( numMorphTargets );\n\t\t\t\tvalues.push( values[ 0 ] );\n\n\t\t\t}\n\n\t\t\ttracks.push(\n\t\t\t\tnew NumberKeyframeTrack(\n\t\t\t\t\t'.morphTargetInfluences[' + morphTargetSequence[ i ].name + ']',\n\t\t\t\t\ttimes, values\n\t\t\t\t).scale( 1.0 / fps ) );\n\n\t\t}\n\n\t\treturn new this( name, - 1, tracks );\n\n\t}\n\n\tstatic findByName( objectOrClipArray, name ) {\n\n\t\tlet clipArray = objectOrClipArray;\n\n\t\tif ( ! Array.isArray( objectOrClipArray ) ) {\n\n\t\t\tconst o = objectOrClipArray;\n\t\t\tclipArray = o.geometry && o.geometry.animations || o.animations;\n\n\t\t}\n\n\t\tfor ( let i = 0; i < clipArray.length; i ++ ) {\n\n\t\t\tif ( clipArray[ i ].name === name ) {\n\n\t\t\t\treturn clipArray[ i ];\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn null;\n\n\t}\n\n\tstatic CreateClipsFromMorphTargetSequences( morphTargets, fps, noLoop ) {\n\n\t\tconst animationToMorphTargets = {};\n\n\t\t// tested with https://regex101.com/ on trick sequences\n\t\t// such flamingo_flyA_003, flamingo_run1_003, crdeath0059\n\t\tconst pattern = /^([\\w-]*?)([\\d]+)$/;\n\n\t\t// sort morph target names into animation groups based\n\t\t// patterns like Walk_001, Walk_002, Run_001, Run_002\n\t\tfor ( let i = 0, il = morphTargets.length; i < il; i ++ ) {\n\n\t\t\tconst morphTarget = morphTargets[ i ];\n\t\t\tconst parts = morphTarget.name.match( pattern );\n\n\t\t\tif ( parts && parts.length > 1 ) {\n\n\t\t\t\tconst name = parts[ 1 ];\n\n\t\t\t\tlet animationMorphTargets = animationToMorphTargets[ name ];\n\n\t\t\t\tif ( ! animationMorphTargets ) {\n\n\t\t\t\t\tanimationToMorphTargets[ name ] = animationMorphTargets = [];\n\n\t\t\t\t}\n\n\t\t\t\tanimationMorphTargets.push( morphTarget );\n\n\t\t\t}\n\n\t\t}\n\n\t\tconst clips = [];\n\n\t\tfor ( const name in animationToMorphTargets ) {\n\n\t\t\tclips.push( this.CreateFromMorphTargetSequence( name, animationToMorphTargets[ name ], fps, noLoop ) );\n\n\t\t}\n\n\t\treturn clips;\n\n\t}\n\n\t// parse the animation.hierarchy format\n\tstatic parseAnimation( animation, bones ) {\n\n\t\tif ( ! animation ) {\n\n\t\t\tconsole.error( 'THREE.AnimationClip: No animation in JSONLoader data.' );\n\t\t\treturn null;\n\n\t\t}\n\n\t\tconst addNonemptyTrack = function ( trackType, trackName, animationKeys, propertyName, destTracks ) {\n\n\t\t\t// only return track if there are actually keys.\n\t\t\tif ( animationKeys.length !== 0 ) {\n\n\t\t\t\tconst times = [];\n\t\t\t\tconst values = [];\n\n\t\t\t\tflattenJSON( animationKeys, times, values, propertyName );\n\n\t\t\t\t// empty keys are filtered out, so check again\n\t\t\t\tif ( times.length !== 0 ) {\n\n\t\t\t\t\tdestTracks.push( new trackType( trackName, times, values ) );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t};\n\n\t\tconst tracks = [];\n\n\t\tconst clipName = animation.name || 'default';\n\t\tconst fps = animation.fps || 30;\n\t\tconst blendMode = animation.blendMode;\n\n\t\t// automatic length determination in AnimationClip.\n\t\tlet duration = animation.length || - 1;\n\n\t\tconst hierarchyTracks = animation.hierarchy || [];\n\n\t\tfor ( let h = 0; h < hierarchyTracks.length; h ++ ) {\n\n\t\t\tconst animationKeys = hierarchyTracks[ h ].keys;\n\n\t\t\t// skip empty tracks\n\t\t\tif ( ! animationKeys || animationKeys.length === 0 ) continue;\n\n\t\t\t// process morph targets\n\t\t\tif ( animationKeys[ 0 ].morphTargets ) {\n\n\t\t\t\t// figure out all morph targets used in this track\n\t\t\t\tconst morphTargetNames = {};\n\n\t\t\t\tlet k;\n\n\t\t\t\tfor ( k = 0; k < animationKeys.length; k ++ ) {\n\n\t\t\t\t\tif ( animationKeys[ k ].morphTargets ) {\n\n\t\t\t\t\t\tfor ( let m = 0; m < animationKeys[ k ].morphTargets.length; m ++ ) {\n\n\t\t\t\t\t\t\tmorphTargetNames[ animationKeys[ k ].morphTargets[ m ] ] = - 1;\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t\t// create a track for each morph target with all zero\n\t\t\t\t// morphTargetInfluences except for the keys in which\n\t\t\t\t// the morphTarget is named.\n\t\t\t\tfor ( const morphTargetName in morphTargetNames ) {\n\n\t\t\t\t\tconst times = [];\n\t\t\t\t\tconst values = [];\n\n\t\t\t\t\tfor ( let m = 0; m !== animationKeys[ k ].morphTargets.length; ++ m ) {\n\n\t\t\t\t\t\tconst animationKey = animationKeys[ k ];\n\n\t\t\t\t\t\ttimes.push( animationKey.time );\n\t\t\t\t\t\tvalues.push( ( animationKey.morphTarget === morphTargetName ) ? 1 : 0 );\n\n\t\t\t\t\t}\n\n\t\t\t\t\ttracks.push( new NumberKeyframeTrack( '.morphTargetInfluence[' + morphTargetName + ']', times, values ) );\n\n\t\t\t\t}\n\n\t\t\t\tduration = morphTargetNames.length * fps;\n\n\t\t\t} else {\n\n\t\t\t\t// ...assume skeletal animation\n\n\t\t\t\tconst boneName = '.bones[' + bones[ h ].name + ']';\n\n\t\t\t\taddNonemptyTrack(\n\t\t\t\t\tVectorKeyframeTrack, boneName + '.position',\n\t\t\t\t\tanimationKeys, 'pos', tracks );\n\n\t\t\t\taddNonemptyTrack(\n\t\t\t\t\tQuaternionKeyframeTrack, boneName + '.quaternion',\n\t\t\t\t\tanimationKeys, 'rot', tracks );\n\n\t\t\t\taddNonemptyTrack(\n\t\t\t\t\tVectorKeyframeTrack, boneName + '.scale',\n\t\t\t\t\tanimationKeys, 'scl', tracks );\n\n\t\t\t}\n\n\t\t}\n\n\t\tif ( tracks.length === 0 ) {\n\n\t\t\treturn null;\n\n\t\t}\n\n\t\tconst clip = new this( clipName, duration, tracks, blendMode );\n\n\t\treturn clip;\n\n\t}\n\n\tresetDuration() {\n\n\t\tconst tracks = this.tracks;\n\t\tlet duration = 0;\n\n\t\tfor ( let i = 0, n = tracks.length; i !== n; ++ i ) {\n\n\t\t\tconst track = this.tracks[ i ];\n\n\t\t\tduration = Math.max( duration, track.times[ track.times.length - 1 ] );\n\n\t\t}\n\n\t\tthis.duration = duration;\n\n\t\treturn this;\n\n\t}\n\n\ttrim() {\n\n\t\tfor ( let i = 0; i < this.tracks.length; i ++ ) {\n\n\t\t\tthis.tracks[ i ].trim( 0, this.duration );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tvalidate() {\n\n\t\tlet valid = true;\n\n\t\tfor ( let i = 0; i < this.tracks.length; i ++ ) {\n\n\t\t\tvalid = valid && this.tracks[ i ].validate();\n\n\t\t}\n\n\t\treturn valid;\n\n\t}\n\n\toptimize() {\n\n\t\tfor ( let i = 0; i < this.tracks.length; i ++ ) {\n\n\t\t\tthis.tracks[ i ].optimize();\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tclone() {\n\n\t\tconst tracks = [];\n\n\t\tfor ( let i = 0; i < this.tracks.length; i ++ ) {\n\n\t\t\ttracks.push( this.tracks[ i ].clone() );\n\n\t\t}\n\n\t\treturn new this.constructor( this.name, this.duration, tracks, this.blendMode );\n\n\t}\n\n\ttoJSON() {\n\n\t\treturn this.constructor.toJSON( this );\n\n\t}\n\n}\n\nfunction getTrackTypeForValueTypeName( typeName ) {\n\n\tswitch ( typeName.toLowerCase() ) {\n\n\t\tcase 'scalar':\n\t\tcase 'double':\n\t\tcase 'float':\n\t\tcase 'number':\n\t\tcase 'integer':\n\n\t\t\treturn NumberKeyframeTrack;\n\n\t\tcase 'vector':\n\t\tcase 'vector2':\n\t\tcase 'vector3':\n\t\tcase 'vector4':\n\n\t\t\treturn VectorKeyframeTrack;\n\n\t\tcase 'color':\n\n\t\t\treturn ColorKeyframeTrack;\n\n\t\tcase 'quaternion':\n\n\t\t\treturn QuaternionKeyframeTrack;\n\n\t\tcase 'bool':\n\t\tcase 'boolean':\n\n\t\t\treturn BooleanKeyframeTrack;\n\n\t\tcase 'string':\n\n\t\t\treturn StringKeyframeTrack;\n\n\t}\n\n\tthrow new Error( 'THREE.KeyframeTrack: Unsupported typeName: ' + typeName );\n\n}\n\nfunction parseKeyframeTrack( json ) {\n\n\tif ( json.type === undefined ) {\n\n\t\tthrow new Error( 'THREE.KeyframeTrack: track type undefined, can not parse' );\n\n\t}\n\n\tconst trackType = getTrackTypeForValueTypeName( json.type );\n\n\tif ( json.times === undefined ) {\n\n\t\tconst times = [], values = [];\n\n\t\tflattenJSON( json.keys, times, values, 'value' );\n\n\t\tjson.times = times;\n\t\tjson.values = values;\n\n\t}\n\n\t// derived classes can define a static parse method\n\tif ( trackType.parse !== undefined ) {\n\n\t\treturn trackType.parse( json );\n\n\t} else {\n\n\t\t// by default, we assume a constructor compatible with the base\n\t\treturn new trackType( json.name, json.times, json.values, json.interpolation );\n\n\t}\n\n}\n\nconst Cache = {\n\n\tenabled: false,\n\n\tfiles: {},\n\n\tadd: function ( key, file ) {\n\n\t\tif ( this.enabled === false ) return;\n\n\t\t// console.log( 'THREE.Cache', 'Adding key:', key );\n\n\t\tthis.files[ key ] = file;\n\n\t},\n\n\tget: function ( key ) {\n\n\t\tif ( this.enabled === false ) return;\n\n\t\t// console.log( 'THREE.Cache', 'Checking key:', key );\n\n\t\treturn this.files[ key ];\n\n\t},\n\n\tremove: function ( key ) {\n\n\t\tdelete this.files[ key ];\n\n\t},\n\n\tclear: function () {\n\n\t\tthis.files = {};\n\n\t}\n\n};\n\nclass LoadingManager {\n\n\tconstructor( onLoad, onProgress, onError ) {\n\n\t\tconst scope = this;\n\n\t\tlet isLoading = false;\n\t\tlet itemsLoaded = 0;\n\t\tlet itemsTotal = 0;\n\t\tlet urlModifier = undefined;\n\t\tconst handlers = [];\n\n\t\t// Refer to #5689 for the reason why we don't set .onStart\n\t\t// in the constructor\n\n\t\tthis.onStart = undefined;\n\t\tthis.onLoad = onLoad;\n\t\tthis.onProgress = onProgress;\n\t\tthis.onError = onError;\n\n\t\tthis.itemStart = function ( url ) {\n\n\t\t\titemsTotal ++;\n\n\t\t\tif ( isLoading === false ) {\n\n\t\t\t\tif ( scope.onStart !== undefined ) {\n\n\t\t\t\t\tscope.onStart( url, itemsLoaded, itemsTotal );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tisLoading = true;\n\n\t\t};\n\n\t\tthis.itemEnd = function ( url ) {\n\n\t\t\titemsLoaded ++;\n\n\t\t\tif ( scope.onProgress !== undefined ) {\n\n\t\t\t\tscope.onProgress( url, itemsLoaded, itemsTotal );\n\n\t\t\t}\n\n\t\t\tif ( itemsLoaded === itemsTotal ) {\n\n\t\t\t\tisLoading = false;\n\n\t\t\t\tif ( scope.onLoad !== undefined ) {\n\n\t\t\t\t\tscope.onLoad();\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t};\n\n\t\tthis.itemError = function ( url ) {\n\n\t\t\tif ( scope.onError !== undefined ) {\n\n\t\t\t\tscope.onError( url );\n\n\t\t\t}\n\n\t\t};\n\n\t\tthis.resolveURL = function ( url ) {\n\n\t\t\tif ( urlModifier ) {\n\n\t\t\t\treturn urlModifier( url );\n\n\t\t\t}\n\n\t\t\treturn url;\n\n\t\t};\n\n\t\tthis.setURLModifier = function ( transform ) {\n\n\t\t\turlModifier = transform;\n\n\t\t\treturn this;\n\n\t\t};\n\n\t\tthis.addHandler = function ( regex, loader ) {\n\n\t\t\thandlers.push( regex, loader );\n\n\t\t\treturn this;\n\n\t\t};\n\n\t\tthis.removeHandler = function ( regex ) {\n\n\t\t\tconst index = handlers.indexOf( regex );\n\n\t\t\tif ( index !== - 1 ) {\n\n\t\t\t\thandlers.splice( index, 2 );\n\n\t\t\t}\n\n\t\t\treturn this;\n\n\t\t};\n\n\t\tthis.getHandler = function ( file ) {\n\n\t\t\tfor ( let i = 0, l = handlers.length; i < l; i += 2 ) {\n\n\t\t\t\tconst regex = handlers[ i ];\n\t\t\t\tconst loader = handlers[ i + 1 ];\n\n\t\t\t\tif ( regex.global ) regex.lastIndex = 0; // see #17920\n\n\t\t\t\tif ( regex.test( file ) ) {\n\n\t\t\t\t\treturn loader;\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\treturn null;\n\n\t\t};\n\n\t}\n\n}\n\nconst DefaultLoadingManager = /*@__PURE__*/ new LoadingManager();\n\nclass Loader {\n\n\tconstructor( manager ) {\n\n\t\tthis.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager;\n\n\t\tthis.crossOrigin = 'anonymous';\n\t\tthis.withCredentials = false;\n\t\tthis.path = '';\n\t\tthis.resourcePath = '';\n\t\tthis.requestHeader = {};\n\n\t}\n\n\tload( /* url, onLoad, onProgress, onError */ ) {}\n\n\tloadAsync( url, onProgress ) {\n\n\t\tconst scope = this;\n\n\t\treturn new Promise( function ( resolve, reject ) {\n\n\t\t\tscope.load( url, resolve, onProgress, reject );\n\n\t\t} );\n\n\t}\n\n\tparse( /* data */ ) {}\n\n\tsetCrossOrigin( crossOrigin ) {\n\n\t\tthis.crossOrigin = crossOrigin;\n\t\treturn this;\n\n\t}\n\n\tsetWithCredentials( value ) {\n\n\t\tthis.withCredentials = value;\n\t\treturn this;\n\n\t}\n\n\tsetPath( path ) {\n\n\t\tthis.path = path;\n\t\treturn this;\n\n\t}\n\n\tsetResourcePath( resourcePath ) {\n\n\t\tthis.resourcePath = resourcePath;\n\t\treturn this;\n\n\t}\n\n\tsetRequestHeader( requestHeader ) {\n\n\t\tthis.requestHeader = requestHeader;\n\t\treturn this;\n\n\t}\n\n}\n\nLoader.DEFAULT_MATERIAL_NAME = '__DEFAULT';\n\nconst loading = {};\n\nclass HttpError extends Error {\n\n\tconstructor( message, response ) {\n\n\t\tsuper( message );\n\t\tthis.response = response;\n\n\t}\n\n}\n\nclass FileLoader extends Loader {\n\n\tconstructor( manager ) {\n\n\t\tsuper( manager );\n\n\t}\n\n\tload( url, onLoad, onProgress, onError ) {\n\n\t\tif ( url === undefined ) url = '';\n\n\t\tif ( this.path !== undefined ) url = this.path + url;\n\n\t\turl = this.manager.resolveURL( url );\n\n\t\tconst cached = Cache.get( url );\n\n\t\tif ( cached !== undefined ) {\n\n\t\t\tthis.manager.itemStart( url );\n\n\t\t\tsetTimeout( () => {\n\n\t\t\t\tif ( onLoad ) onLoad( cached );\n\n\t\t\t\tthis.manager.itemEnd( url );\n\n\t\t\t}, 0 );\n\n\t\t\treturn cached;\n\n\t\t}\n\n\t\t// Check if request is duplicate\n\n\t\tif ( loading[ url ] !== undefined ) {\n\n\t\t\tloading[ url ].push( {\n\n\t\t\t\tonLoad: onLoad,\n\t\t\t\tonProgress: onProgress,\n\t\t\t\tonError: onError\n\n\t\t\t} );\n\n\t\t\treturn;\n\n\t\t}\n\n\t\t// Initialise array for duplicate requests\n\t\tloading[ url ] = [];\n\n\t\tloading[ url ].push( {\n\t\t\tonLoad: onLoad,\n\t\t\tonProgress: onProgress,\n\t\t\tonError: onError,\n\t\t} );\n\n\t\t// create request\n\t\tconst req = new Request( url, {\n\t\t\theaders: new Headers( this.requestHeader ),\n\t\t\tcredentials: this.withCredentials ? 'include' : 'same-origin',\n\t\t\t// An abort controller could be added within a future PR\n\t\t} );\n\n\t\t// record states ( avoid data race )\n\t\tconst mimeType = this.mimeType;\n\t\tconst responseType = this.responseType;\n\n\t\t// start the fetch\n\t\tfetch( req )\n\t\t\t.then( response => {\n\n\t\t\t\tif ( response.status === 200 || response.status === 0 ) {\n\n\t\t\t\t\t// Some browsers return HTTP Status 0 when using non-http protocol\n\t\t\t\t\t// e.g. 'file://' or 'data://'. Handle as success.\n\n\t\t\t\t\tif ( response.status === 0 ) {\n\n\t\t\t\t\t\tconsole.warn( 'THREE.FileLoader: HTTP Status 0 received.' );\n\n\t\t\t\t\t}\n\n\t\t\t\t\t// Workaround: Checking if response.body === undefined for Alipay browser #23548\n\n\t\t\t\t\tif ( typeof ReadableStream === 'undefined' || response.body === undefined || response.body.getReader === undefined ) {\n\n\t\t\t\t\t\treturn response;\n\n\t\t\t\t\t}\n\n\t\t\t\t\tconst callbacks = loading[ url ];\n\t\t\t\t\tconst reader = response.body.getReader();\n\n\t\t\t\t\t// Nginx needs X-File-Size check\n\t\t\t\t\t// https://serverfault.com/questions/482875/why-does-nginx-remove-content-length-header-for-chunked-content\n\t\t\t\t\tconst contentLength = response.headers.get( 'Content-Length' ) || response.headers.get( 'X-File-Size' );\n\t\t\t\t\tconst total = contentLength ? parseInt( contentLength ) : 0;\n\t\t\t\t\tconst lengthComputable = total !== 0;\n\t\t\t\t\tlet loaded = 0;\n\n\t\t\t\t\t// periodically read data into the new stream tracking while download progress\n\t\t\t\t\tconst stream = new ReadableStream( {\n\t\t\t\t\t\tstart( controller ) {\n\n\t\t\t\t\t\t\treadData();\n\n\t\t\t\t\t\t\tfunction readData() {\n\n\t\t\t\t\t\t\t\treader.read().then( ( { done, value } ) => {\n\n\t\t\t\t\t\t\t\t\tif ( done ) {\n\n\t\t\t\t\t\t\t\t\t\tcontroller.close();\n\n\t\t\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\t\t\tloaded += value.byteLength;\n\n\t\t\t\t\t\t\t\t\t\tconst event = new ProgressEvent( 'progress', { lengthComputable, loaded, total } );\n\t\t\t\t\t\t\t\t\t\tfor ( let i = 0, il = callbacks.length; i < il; i ++ ) {\n\n\t\t\t\t\t\t\t\t\t\t\tconst callback = callbacks[ i ];\n\t\t\t\t\t\t\t\t\t\t\tif ( callback.onProgress ) callback.onProgress( event );\n\n\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\tcontroller.enqueue( value );\n\t\t\t\t\t\t\t\t\t\treadData();\n\n\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t} );\n\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t} );\n\n\t\t\t\t\treturn new Response( stream );\n\n\t\t\t\t} else {\n\n\t\t\t\t\tthrow new HttpError( `fetch for \"${response.url}\" responded with ${response.status}: ${response.statusText}`, response );\n\n\t\t\t\t}\n\n\t\t\t} )\n\t\t\t.then( response => {\n\n\t\t\t\tswitch ( responseType ) {\n\n\t\t\t\t\tcase 'arraybuffer':\n\n\t\t\t\t\t\treturn response.arrayBuffer();\n\n\t\t\t\t\tcase 'blob':\n\n\t\t\t\t\t\treturn response.blob();\n\n\t\t\t\t\tcase 'document':\n\n\t\t\t\t\t\treturn response.text()\n\t\t\t\t\t\t\t.then( text => {\n\n\t\t\t\t\t\t\t\tconst parser = new DOMParser();\n\t\t\t\t\t\t\t\treturn parser.parseFromString( text, mimeType );\n\n\t\t\t\t\t\t\t} );\n\n\t\t\t\t\tcase 'json':\n\n\t\t\t\t\t\treturn response.json();\n\n\t\t\t\t\tdefault:\n\n\t\t\t\t\t\tif ( mimeType === undefined ) {\n\n\t\t\t\t\t\t\treturn response.text();\n\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t// sniff encoding\n\t\t\t\t\t\t\tconst re = /charset=\"?([^;\"\\s]*)\"?/i;\n\t\t\t\t\t\t\tconst exec = re.exec( mimeType );\n\t\t\t\t\t\t\tconst label = exec && exec[ 1 ] ? exec[ 1 ].toLowerCase() : undefined;\n\t\t\t\t\t\t\tconst decoder = new TextDecoder( label );\n\t\t\t\t\t\t\treturn response.arrayBuffer().then( ab => decoder.decode( ab ) );\n\n\t\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t} )\n\t\t\t.then( data => {\n\n\t\t\t\t// Add to cache only on HTTP success, so that we do not cache\n\t\t\t\t// error response bodies as proper responses to requests.\n\t\t\t\tCache.add( url, data );\n\n\t\t\t\tconst callbacks = loading[ url ];\n\t\t\t\tdelete loading[ url ];\n\n\t\t\t\tfor ( let i = 0, il = callbacks.length; i < il; i ++ ) {\n\n\t\t\t\t\tconst callback = callbacks[ i ];\n\t\t\t\t\tif ( callback.onLoad ) callback.onLoad( data );\n\n\t\t\t\t}\n\n\t\t\t} )\n\t\t\t.catch( err => {\n\n\t\t\t\t// Abort errors and other errors are handled the same\n\n\t\t\t\tconst callbacks = loading[ url ];\n\n\t\t\t\tif ( callbacks === undefined ) {\n\n\t\t\t\t\t// When onLoad was called and url was deleted in `loading`\n\t\t\t\t\tthis.manager.itemError( url );\n\t\t\t\t\tthrow err;\n\n\t\t\t\t}\n\n\t\t\t\tdelete loading[ url ];\n\n\t\t\t\tfor ( let i = 0, il = callbacks.length; i < il; i ++ ) {\n\n\t\t\t\t\tconst callback = callbacks[ i ];\n\t\t\t\t\tif ( callback.onError ) callback.onError( err );\n\n\t\t\t\t}\n\n\t\t\t\tthis.manager.itemError( url );\n\n\t\t\t} )\n\t\t\t.finally( () => {\n\n\t\t\t\tthis.manager.itemEnd( url );\n\n\t\t\t} );\n\n\t\tthis.manager.itemStart( url );\n\n\t}\n\n\tsetResponseType( value ) {\n\n\t\tthis.responseType = value;\n\t\treturn this;\n\n\t}\n\n\tsetMimeType( value ) {\n\n\t\tthis.mimeType = value;\n\t\treturn this;\n\n\t}\n\n}\n\nclass AnimationLoader extends Loader {\n\n\tconstructor( manager ) {\n\n\t\tsuper( manager );\n\n\t}\n\n\tload( url, onLoad, onProgress, onError ) {\n\n\t\tconst scope = this;\n\n\t\tconst loader = new FileLoader( this.manager );\n\t\tloader.setPath( this.path );\n\t\tloader.setRequestHeader( this.requestHeader );\n\t\tloader.setWithCredentials( this.withCredentials );\n\t\tloader.load( url, function ( text ) {\n\n\t\t\ttry {\n\n\t\t\t\tonLoad( scope.parse( JSON.parse( text ) ) );\n\n\t\t\t} catch ( e ) {\n\n\t\t\t\tif ( onError ) {\n\n\t\t\t\t\tonError( e );\n\n\t\t\t\t} else {\n\n\t\t\t\t\tconsole.error( e );\n\n\t\t\t\t}\n\n\t\t\t\tscope.manager.itemError( url );\n\n\t\t\t}\n\n\t\t}, onProgress, onError );\n\n\t}\n\n\tparse( json ) {\n\n\t\tconst animations = [];\n\n\t\tfor ( let i = 0; i < json.length; i ++ ) {\n\n\t\t\tconst clip = AnimationClip.parse( json[ i ] );\n\n\t\t\tanimations.push( clip );\n\n\t\t}\n\n\t\treturn animations;\n\n\t}\n\n}\n\n/**\n * Abstract Base class to block based textures loader (dds, pvr, ...)\n *\n * Sub classes have to implement the parse() method which will be used in load().\n */\n\nclass CompressedTextureLoader extends Loader {\n\n\tconstructor( manager ) {\n\n\t\tsuper( manager );\n\n\t}\n\n\tload( url, onLoad, onProgress, onError ) {\n\n\t\tconst scope = this;\n\n\t\tconst images = [];\n\n\t\tconst texture = new CompressedTexture();\n\n\t\tconst loader = new FileLoader( this.manager );\n\t\tloader.setPath( this.path );\n\t\tloader.setResponseType( 'arraybuffer' );\n\t\tloader.setRequestHeader( this.requestHeader );\n\t\tloader.setWithCredentials( scope.withCredentials );\n\n\t\tlet loaded = 0;\n\n\t\tfunction loadTexture( i ) {\n\n\t\t\tloader.load( url[ i ], function ( buffer ) {\n\n\t\t\t\tconst texDatas = scope.parse( buffer, true );\n\n\t\t\t\timages[ i ] = {\n\t\t\t\t\twidth: texDatas.width,\n\t\t\t\t\theight: texDatas.height,\n\t\t\t\t\tformat: texDatas.format,\n\t\t\t\t\tmipmaps: texDatas.mipmaps\n\t\t\t\t};\n\n\t\t\t\tloaded += 1;\n\n\t\t\t\tif ( loaded === 6 ) {\n\n\t\t\t\t\tif ( texDatas.mipmapCount === 1 ) texture.minFilter = LinearFilter;\n\n\t\t\t\t\ttexture.image = images;\n\t\t\t\t\ttexture.format = texDatas.format;\n\t\t\t\t\ttexture.needsUpdate = true;\n\n\t\t\t\t\tif ( onLoad ) onLoad( texture );\n\n\t\t\t\t}\n\n\t\t\t}, onProgress, onError );\n\n\t\t}\n\n\t\tif ( Array.isArray( url ) ) {\n\n\t\t\tfor ( let i = 0, il = url.length; i < il; ++ i ) {\n\n\t\t\t\tloadTexture( i );\n\n\t\t\t}\n\n\t\t} else {\n\n\t\t\t// compressed cubemap texture stored in a single DDS file\n\n\t\t\tloader.load( url, function ( buffer ) {\n\n\t\t\t\tconst texDatas = scope.parse( buffer, true );\n\n\t\t\t\tif ( texDatas.isCubemap ) {\n\n\t\t\t\t\tconst faces = texDatas.mipmaps.length / texDatas.mipmapCount;\n\n\t\t\t\t\tfor ( let f = 0; f < faces; f ++ ) {\n\n\t\t\t\t\t\timages[ f ] = { mipmaps: [] };\n\n\t\t\t\t\t\tfor ( let i = 0; i < texDatas.mipmapCount; i ++ ) {\n\n\t\t\t\t\t\t\timages[ f ].mipmaps.push( texDatas.mipmaps[ f * texDatas.mipmapCount + i ] );\n\t\t\t\t\t\t\timages[ f ].format = texDatas.format;\n\t\t\t\t\t\t\timages[ f ].width = texDatas.width;\n\t\t\t\t\t\t\timages[ f ].height = texDatas.height;\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}\n\n\t\t\t\t\ttexture.image = images;\n\n\t\t\t\t} else {\n\n\t\t\t\t\ttexture.image.width = texDatas.width;\n\t\t\t\t\ttexture.image.height = texDatas.height;\n\t\t\t\t\ttexture.mipmaps = texDatas.mipmaps;\n\n\t\t\t\t}\n\n\t\t\t\tif ( texDatas.mipmapCount === 1 ) {\n\n\t\t\t\t\ttexture.minFilter = LinearFilter;\n\n\t\t\t\t}\n\n\t\t\t\ttexture.format = texDatas.format;\n\t\t\t\ttexture.needsUpdate = true;\n\n\t\t\t\tif ( onLoad ) onLoad( texture );\n\n\t\t\t}, onProgress, onError );\n\n\t\t}\n\n\t\treturn texture;\n\n\t}\n\n}\n\nclass ImageLoader extends Loader {\n\n\tconstructor( manager ) {\n\n\t\tsuper( manager );\n\n\t}\n\n\tload( url, onLoad, onProgress, onError ) {\n\n\t\tif ( this.path !== undefined ) url = this.path + url;\n\n\t\turl = this.manager.resolveURL( url );\n\n\t\tconst scope = this;\n\n\t\tconst cached = Cache.get( url );\n\n\t\tif ( cached !== undefined ) {\n\n\t\t\tscope.manager.itemStart( url );\n\n\t\t\tsetTimeout( function () {\n\n\t\t\t\tif ( onLoad ) onLoad( cached );\n\n\t\t\t\tscope.manager.itemEnd( url );\n\n\t\t\t}, 0 );\n\n\t\t\treturn cached;\n\n\t\t}\n\n\t\tconst image = createElementNS( 'img' );\n\n\t\tfunction onImageLoad() {\n\n\t\t\tremoveEventListeners();\n\n\t\t\tCache.add( url, this );\n\n\t\t\tif ( onLoad ) onLoad( this );\n\n\t\t\tscope.manager.itemEnd( url );\n\n\t\t}\n\n\t\tfunction onImageError( event ) {\n\n\t\t\tremoveEventListeners();\n\n\t\t\tif ( onError ) onError( event );\n\n\t\t\tscope.manager.itemError( url );\n\t\t\tscope.manager.itemEnd( url );\n\n\t\t}\n\n\t\tfunction removeEventListeners() {\n\n\t\t\timage.removeEventListener( 'load', onImageLoad, false );\n\t\t\timage.removeEventListener( 'error', onImageError, false );\n\n\t\t}\n\n\t\timage.addEventListener( 'load', onImageLoad, false );\n\t\timage.addEventListener( 'error', onImageError, false );\n\n\t\tif ( url.slice( 0, 5 ) !== 'data:' ) {\n\n\t\t\tif ( this.crossOrigin !== undefined ) image.crossOrigin = this.crossOrigin;\n\n\t\t}\n\n\t\tscope.manager.itemStart( url );\n\n\t\timage.src = url;\n\n\t\treturn image;\n\n\t}\n\n}\n\nclass CubeTextureLoader extends Loader {\n\n\tconstructor( manager ) {\n\n\t\tsuper( manager );\n\n\t}\n\n\tload( urls, onLoad, onProgress, onError ) {\n\n\t\tconst texture = new CubeTexture();\n\t\ttexture.colorSpace = SRGBColorSpace;\n\n\t\tconst loader = new ImageLoader( this.manager );\n\t\tloader.setCrossOrigin( this.crossOrigin );\n\t\tloader.setPath( this.path );\n\n\t\tlet loaded = 0;\n\n\t\tfunction loadTexture( i ) {\n\n\t\t\tloader.load( urls[ i ], function ( image ) {\n\n\t\t\t\ttexture.images[ i ] = image;\n\n\t\t\t\tloaded ++;\n\n\t\t\t\tif ( loaded === 6 ) {\n\n\t\t\t\t\ttexture.needsUpdate = true;\n\n\t\t\t\t\tif ( onLoad ) onLoad( texture );\n\n\t\t\t\t}\n\n\t\t\t}, undefined, onError );\n\n\t\t}\n\n\t\tfor ( let i = 0; i < urls.length; ++ i ) {\n\n\t\t\tloadTexture( i );\n\n\t\t}\n\n\t\treturn texture;\n\n\t}\n\n}\n\n/**\n * Abstract Base class to load generic binary textures formats (rgbe, hdr, ...)\n *\n * Sub classes have to implement the parse() method which will be used in load().\n */\n\nclass DataTextureLoader extends Loader {\n\n\tconstructor( manager ) {\n\n\t\tsuper( manager );\n\n\t}\n\n\tload( url, onLoad, onProgress, onError ) {\n\n\t\tconst scope = this;\n\n\t\tconst texture = new DataTexture();\n\n\t\tconst loader = new FileLoader( this.manager );\n\t\tloader.setResponseType( 'arraybuffer' );\n\t\tloader.setRequestHeader( this.requestHeader );\n\t\tloader.setPath( this.path );\n\t\tloader.setWithCredentials( scope.withCredentials );\n\t\tloader.load( url, function ( buffer ) {\n\n\t\t\tlet texData;\n\n\t\t\ttry {\n\n\t\t\t\ttexData = scope.parse( buffer );\n\n\t\t\t} catch ( error ) {\n\n\t\t\t\tif ( onError !== undefined ) {\n\n\t\t\t\t\tonError( error );\n\n\t\t\t\t} else {\n\n\t\t\t\t\tconsole.error( error );\n\t\t\t\t\treturn;\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tif ( texData.image !== undefined ) {\n\n\t\t\t\ttexture.image = texData.image;\n\n\t\t\t} else if ( texData.data !== undefined ) {\n\n\t\t\t\ttexture.image.width = texData.width;\n\t\t\t\ttexture.image.height = texData.height;\n\t\t\t\ttexture.image.data = texData.data;\n\n\t\t\t}\n\n\t\t\ttexture.wrapS = texData.wrapS !== undefined ? texData.wrapS : ClampToEdgeWrapping;\n\t\t\ttexture.wrapT = texData.wrapT !== undefined ? texData.wrapT : ClampToEdgeWrapping;\n\n\t\t\ttexture.magFilter = texData.magFilter !== undefined ? texData.magFilter : LinearFilter;\n\t\t\ttexture.minFilter = texData.minFilter !== undefined ? texData.minFilter : LinearFilter;\n\n\t\t\ttexture.anisotropy = texData.anisotropy !== undefined ? texData.anisotropy : 1;\n\n\t\t\tif ( texData.colorSpace !== undefined ) {\n\n\t\t\t\ttexture.colorSpace = texData.colorSpace;\n\n\t\t\t}\n\n\t\t\tif ( texData.flipY !== undefined ) {\n\n\t\t\t\ttexture.flipY = texData.flipY;\n\n\t\t\t}\n\n\t\t\tif ( texData.format !== undefined ) {\n\n\t\t\t\ttexture.format = texData.format;\n\n\t\t\t}\n\n\t\t\tif ( texData.type !== undefined ) {\n\n\t\t\t\ttexture.type = texData.type;\n\n\t\t\t}\n\n\t\t\tif ( texData.mipmaps !== undefined ) {\n\n\t\t\t\ttexture.mipmaps = texData.mipmaps;\n\t\t\t\ttexture.minFilter = LinearMipmapLinearFilter; // presumably...\n\n\t\t\t}\n\n\t\t\tif ( texData.mipmapCount === 1 ) {\n\n\t\t\t\ttexture.minFilter = LinearFilter;\n\n\t\t\t}\n\n\t\t\tif ( texData.generateMipmaps !== undefined ) {\n\n\t\t\t\ttexture.generateMipmaps = texData.generateMipmaps;\n\n\t\t\t}\n\n\t\t\ttexture.needsUpdate = true;\n\n\t\t\tif ( onLoad ) onLoad( texture, texData );\n\n\t\t}, onProgress, onError );\n\n\n\t\treturn texture;\n\n\t}\n\n}\n\nclass TextureLoader extends Loader {\n\n\tconstructor( manager ) {\n\n\t\tsuper( manager );\n\n\t}\n\n\tload( url, onLoad, onProgress, onError ) {\n\n\t\tconst texture = new Texture();\n\n\t\tconst loader = new ImageLoader( this.manager );\n\t\tloader.setCrossOrigin( this.crossOrigin );\n\t\tloader.setPath( this.path );\n\n\t\tloader.load( url, function ( image ) {\n\n\t\t\ttexture.image = image;\n\t\t\ttexture.needsUpdate = true;\n\n\t\t\tif ( onLoad !== undefined ) {\n\n\t\t\t\tonLoad( texture );\n\n\t\t\t}\n\n\t\t}, onProgress, onError );\n\n\t\treturn texture;\n\n\t}\n\n}\n\nclass Light extends Object3D {\n\n\tconstructor( color, intensity = 1 ) {\n\n\t\tsuper();\n\n\t\tthis.isLight = true;\n\n\t\tthis.type = 'Light';\n\n\t\tthis.color = new Color( color );\n\t\tthis.intensity = intensity;\n\n\t}\n\n\tdispose() {\n\n\t\t// Empty here in base class; some subclasses override.\n\n\t}\n\n\tcopy( source, recursive ) {\n\n\t\tsuper.copy( source, recursive );\n\n\t\tthis.color.copy( source.color );\n\t\tthis.intensity = source.intensity;\n\n\t\treturn this;\n\n\t}\n\n\ttoJSON( meta ) {\n\n\t\tconst data = super.toJSON( meta );\n\n\t\tdata.object.color = this.color.getHex();\n\t\tdata.object.intensity = this.intensity;\n\n\t\tif ( this.groundColor !== undefined ) data.object.groundColor = this.groundColor.getHex();\n\n\t\tif ( this.distance !== undefined ) data.object.distance = this.distance;\n\t\tif ( this.angle !== undefined ) data.object.angle = this.angle;\n\t\tif ( this.decay !== undefined ) data.object.decay = this.decay;\n\t\tif ( this.penumbra !== undefined ) data.object.penumbra = this.penumbra;\n\n\t\tif ( this.shadow !== undefined ) data.object.shadow = this.shadow.toJSON();\n\n\t\treturn data;\n\n\t}\n\n}\n\nclass HemisphereLight extends Light {\n\n\tconstructor( skyColor, groundColor, intensity ) {\n\n\t\tsuper( skyColor, intensity );\n\n\t\tthis.isHemisphereLight = true;\n\n\t\tthis.type = 'HemisphereLight';\n\n\t\tthis.position.copy( Object3D.DEFAULT_UP );\n\t\tthis.updateMatrix();\n\n\t\tthis.groundColor = new Color( groundColor );\n\n\t}\n\n\tcopy( source, recursive ) {\n\n\t\tsuper.copy( source, recursive );\n\n\t\tthis.groundColor.copy( source.groundColor );\n\n\t\treturn this;\n\n\t}\n\n}\n\nconst _projScreenMatrix$1 = /*@__PURE__*/ new Matrix4();\nconst _lightPositionWorld$1 = /*@__PURE__*/ new Vector3();\nconst _lookTarget$1 = /*@__PURE__*/ new Vector3();\n\nclass LightShadow {\n\n\tconstructor( camera ) {\n\n\t\tthis.camera = camera;\n\n\t\tthis.bias = 0;\n\t\tthis.normalBias = 0;\n\t\tthis.radius = 1;\n\t\tthis.blurSamples = 8;\n\n\t\tthis.mapSize = new Vector2( 512, 512 );\n\n\t\tthis.map = null;\n\t\tthis.mapPass = null;\n\t\tthis.matrix = new Matrix4();\n\n\t\tthis.autoUpdate = true;\n\t\tthis.needsUpdate = false;\n\n\t\tthis._frustum = new Frustum();\n\t\tthis._frameExtents = new Vector2( 1, 1 );\n\n\t\tthis._viewportCount = 1;\n\n\t\tthis._viewports = [\n\n\t\t\tnew Vector4( 0, 0, 1, 1 )\n\n\t\t];\n\n\t}\n\n\tgetViewportCount() {\n\n\t\treturn this._viewportCount;\n\n\t}\n\n\tgetFrustum() {\n\n\t\treturn this._frustum;\n\n\t}\n\n\tupdateMatrices( light ) {\n\n\t\tconst shadowCamera = this.camera;\n\t\tconst shadowMatrix = this.matrix;\n\n\t\t_lightPositionWorld$1.setFromMatrixPosition( light.matrixWorld );\n\t\tshadowCamera.position.copy( _lightPositionWorld$1 );\n\n\t\t_lookTarget$1.setFromMatrixPosition( light.target.matrixWorld );\n\t\tshadowCamera.lookAt( _lookTarget$1 );\n\t\tshadowCamera.updateMatrixWorld();\n\n\t\t_projScreenMatrix$1.multiplyMatrices( shadowCamera.projectionMatrix, shadowCamera.matrixWorldInverse );\n\t\tthis._frustum.setFromProjectionMatrix( _projScreenMatrix$1 );\n\n\t\tshadowMatrix.set(\n\t\t\t0.5, 0.0, 0.0, 0.5,\n\t\t\t0.0, 0.5, 0.0, 0.5,\n\t\t\t0.0, 0.0, 0.5, 0.5,\n\t\t\t0.0, 0.0, 0.0, 1.0\n\t\t);\n\n\t\tshadowMatrix.multiply( _projScreenMatrix$1 );\n\n\t}\n\n\tgetViewport( viewportIndex ) {\n\n\t\treturn this._viewports[ viewportIndex ];\n\n\t}\n\n\tgetFrameExtents() {\n\n\t\treturn this._frameExtents;\n\n\t}\n\n\tdispose() {\n\n\t\tif ( this.map ) {\n\n\t\t\tthis.map.dispose();\n\n\t\t}\n\n\t\tif ( this.mapPass ) {\n\n\t\t\tthis.mapPass.dispose();\n\n\t\t}\n\n\t}\n\n\tcopy( source ) {\n\n\t\tthis.camera = source.camera.clone();\n\n\t\tthis.bias = source.bias;\n\t\tthis.radius = source.radius;\n\n\t\tthis.mapSize.copy( source.mapSize );\n\n\t\treturn this;\n\n\t}\n\n\tclone() {\n\n\t\treturn new this.constructor().copy( this );\n\n\t}\n\n\ttoJSON() {\n\n\t\tconst object = {};\n\n\t\tif ( this.bias !== 0 ) object.bias = this.bias;\n\t\tif ( this.normalBias !== 0 ) object.normalBias = this.normalBias;\n\t\tif ( this.radius !== 1 ) object.radius = this.radius;\n\t\tif ( this.mapSize.x !== 512 || this.mapSize.y !== 512 ) object.mapSize = this.mapSize.toArray();\n\n\t\tobject.camera = this.camera.toJSON( false ).object;\n\t\tdelete object.camera.matrix;\n\n\t\treturn object;\n\n\t}\n\n}\n\nclass SpotLightShadow extends LightShadow {\n\n\tconstructor() {\n\n\t\tsuper( new PerspectiveCamera( 50, 1, 0.5, 500 ) );\n\n\t\tthis.isSpotLightShadow = true;\n\n\t\tthis.focus = 1;\n\n\t}\n\n\tupdateMatrices( light ) {\n\n\t\tconst camera = this.camera;\n\n\t\tconst fov = RAD2DEG * 2 * light.angle * this.focus;\n\t\tconst aspect = this.mapSize.width / this.mapSize.height;\n\t\tconst far = light.distance || camera.far;\n\n\t\tif ( fov !== camera.fov || aspect !== camera.aspect || far !== camera.far ) {\n\n\t\t\tcamera.fov = fov;\n\t\t\tcamera.aspect = aspect;\n\t\t\tcamera.far = far;\n\t\t\tcamera.updateProjectionMatrix();\n\n\t\t}\n\n\t\tsuper.updateMatrices( light );\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.focus = source.focus;\n\n\t\treturn this;\n\n\t}\n\n}\n\nclass SpotLight extends Light {\n\n\tconstructor( color, intensity, distance = 0, angle = Math.PI / 3, penumbra = 0, decay = 2 ) {\n\n\t\tsuper( color, intensity );\n\n\t\tthis.isSpotLight = true;\n\n\t\tthis.type = 'SpotLight';\n\n\t\tthis.position.copy( Object3D.DEFAULT_UP );\n\t\tthis.updateMatrix();\n\n\t\tthis.target = new Object3D();\n\n\t\tthis.distance = distance;\n\t\tthis.angle = angle;\n\t\tthis.penumbra = penumbra;\n\t\tthis.decay = decay;\n\n\t\tthis.map = null;\n\n\t\tthis.shadow = new SpotLightShadow();\n\n\t}\n\n\tget power() {\n\n\t\t// compute the light's luminous power (in lumens) from its intensity (in candela)\n\t\t// by convention for a spotlight, luminous power (lm) = \u03C0 * luminous intensity (cd)\n\t\treturn this.intensity * Math.PI;\n\n\t}\n\n\tset power( power ) {\n\n\t\t// set the light's intensity (in candela) from the desired luminous power (in lumens)\n\t\tthis.intensity = power / Math.PI;\n\n\t}\n\n\tdispose() {\n\n\t\tthis.shadow.dispose();\n\n\t}\n\n\tcopy( source, recursive ) {\n\n\t\tsuper.copy( source, recursive );\n\n\t\tthis.distance = source.distance;\n\t\tthis.angle = source.angle;\n\t\tthis.penumbra = source.penumbra;\n\t\tthis.decay = source.decay;\n\n\t\tthis.target = source.target.clone();\n\n\t\tthis.shadow = source.shadow.clone();\n\n\t\treturn this;\n\n\t}\n\n}\n\nconst _projScreenMatrix = /*@__PURE__*/ new Matrix4();\nconst _lightPositionWorld = /*@__PURE__*/ new Vector3();\nconst _lookTarget = /*@__PURE__*/ new Vector3();\n\nclass PointLightShadow extends LightShadow {\n\n\tconstructor() {\n\n\t\tsuper( new PerspectiveCamera( 90, 1, 0.5, 500 ) );\n\n\t\tthis.isPointLightShadow = true;\n\n\t\tthis._frameExtents = new Vector2( 4, 2 );\n\n\t\tthis._viewportCount = 6;\n\n\t\tthis._viewports = [\n\t\t\t// These viewports map a cube-map onto a 2D texture with the\n\t\t\t// following orientation:\n\t\t\t//\n\t\t\t// xzXZ\n\t\t\t// y Y\n\t\t\t//\n\t\t\t// X - Positive x direction\n\t\t\t// x - Negative x direction\n\t\t\t// Y - Positive y direction\n\t\t\t// y - Negative y direction\n\t\t\t// Z - Positive z direction\n\t\t\t// z - Negative z direction\n\n\t\t\t// positive X\n\t\t\tnew Vector4( 2, 1, 1, 1 ),\n\t\t\t// negative X\n\t\t\tnew Vector4( 0, 1, 1, 1 ),\n\t\t\t// positive Z\n\t\t\tnew Vector4( 3, 1, 1, 1 ),\n\t\t\t// negative Z\n\t\t\tnew Vector4( 1, 1, 1, 1 ),\n\t\t\t// positive Y\n\t\t\tnew Vector4( 3, 0, 1, 1 ),\n\t\t\t// negative Y\n\t\t\tnew Vector4( 1, 0, 1, 1 )\n\t\t];\n\n\t\tthis._cubeDirections = [\n\t\t\tnew Vector3( 1, 0, 0 ), new Vector3( - 1, 0, 0 ), new Vector3( 0, 0, 1 ),\n\t\t\tnew Vector3( 0, 0, - 1 ), new Vector3( 0, 1, 0 ), new Vector3( 0, - 1, 0 )\n\t\t];\n\n\t\tthis._cubeUps = [\n\t\t\tnew Vector3( 0, 1, 0 ), new Vector3( 0, 1, 0 ), new Vector3( 0, 1, 0 ),\n\t\t\tnew Vector3( 0, 1, 0 ), new Vector3( 0, 0, 1 ),\tnew Vector3( 0, 0, - 1 )\n\t\t];\n\n\t}\n\n\tupdateMatrices( light, viewportIndex = 0 ) {\n\n\t\tconst camera = this.camera;\n\t\tconst shadowMatrix = this.matrix;\n\n\t\tconst far = light.distance || camera.far;\n\n\t\tif ( far !== camera.far ) {\n\n\t\t\tcamera.far = far;\n\t\t\tcamera.updateProjectionMatrix();\n\n\t\t}\n\n\t\t_lightPositionWorld.setFromMatrixPosition( light.matrixWorld );\n\t\tcamera.position.copy( _lightPositionWorld );\n\n\t\t_lookTarget.copy( camera.position );\n\t\t_lookTarget.add( this._cubeDirections[ viewportIndex ] );\n\t\tcamera.up.copy( this._cubeUps[ viewportIndex ] );\n\t\tcamera.lookAt( _lookTarget );\n\t\tcamera.updateMatrixWorld();\n\n\t\tshadowMatrix.makeTranslation( - _lightPositionWorld.x, - _lightPositionWorld.y, - _lightPositionWorld.z );\n\n\t\t_projScreenMatrix.multiplyMatrices( camera.projectionMatrix, camera.matrixWorldInverse );\n\t\tthis._frustum.setFromProjectionMatrix( _projScreenMatrix );\n\n\t}\n\n}\n\nclass PointLight extends Light {\n\n\tconstructor( color, intensity, distance = 0, decay = 2 ) {\n\n\t\tsuper( color, intensity );\n\n\t\tthis.isPointLight = true;\n\n\t\tthis.type = 'PointLight';\n\n\t\tthis.distance = distance;\n\t\tthis.decay = decay;\n\n\t\tthis.shadow = new PointLightShadow();\n\n\t}\n\n\tget power() {\n\n\t\t// compute the light's luminous power (in lumens) from its intensity (in candela)\n\t\t// for an isotropic light source, luminous power (lm) = 4 \u03C0 luminous intensity (cd)\n\t\treturn this.intensity * 4 * Math.PI;\n\n\t}\n\n\tset power( power ) {\n\n\t\t// set the light's intensity (in candela) from the desired luminous power (in lumens)\n\t\tthis.intensity = power / ( 4 * Math.PI );\n\n\t}\n\n\tdispose() {\n\n\t\tthis.shadow.dispose();\n\n\t}\n\n\tcopy( source, recursive ) {\n\n\t\tsuper.copy( source, recursive );\n\n\t\tthis.distance = source.distance;\n\t\tthis.decay = source.decay;\n\n\t\tthis.shadow = source.shadow.clone();\n\n\t\treturn this;\n\n\t}\n\n}\n\nclass DirectionalLightShadow extends LightShadow {\n\n\tconstructor() {\n\n\t\tsuper( new OrthographicCamera( - 5, 5, 5, - 5, 0.5, 500 ) );\n\n\t\tthis.isDirectionalLightShadow = true;\n\n\t}\n\n}\n\nclass DirectionalLight extends Light {\n\n\tconstructor( color, intensity ) {\n\n\t\tsuper( color, intensity );\n\n\t\tthis.isDirectionalLight = true;\n\n\t\tthis.type = 'DirectionalLight';\n\n\t\tthis.position.copy( Object3D.DEFAULT_UP );\n\t\tthis.updateMatrix();\n\n\t\tthis.target = new Object3D();\n\n\t\tthis.shadow = new DirectionalLightShadow();\n\n\t}\n\n\tdispose() {\n\n\t\tthis.shadow.dispose();\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.target = source.target.clone();\n\t\tthis.shadow = source.shadow.clone();\n\n\t\treturn this;\n\n\t}\n\n}\n\nclass AmbientLight extends Light {\n\n\tconstructor( color, intensity ) {\n\n\t\tsuper( color, intensity );\n\n\t\tthis.isAmbientLight = true;\n\n\t\tthis.type = 'AmbientLight';\n\n\t}\n\n}\n\nclass RectAreaLight extends Light {\n\n\tconstructor( color, intensity, width = 10, height = 10 ) {\n\n\t\tsuper( color, intensity );\n\n\t\tthis.isRectAreaLight = true;\n\n\t\tthis.type = 'RectAreaLight';\n\n\t\tthis.width = width;\n\t\tthis.height = height;\n\n\t}\n\n\tget power() {\n\n\t\t// compute the light's luminous power (in lumens) from its intensity (in nits)\n\t\treturn this.intensity * this.width * this.height * Math.PI;\n\n\t}\n\n\tset power( power ) {\n\n\t\t// set the light's intensity (in nits) from the desired luminous power (in lumens)\n\t\tthis.intensity = power / ( this.width * this.height * Math.PI );\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.width = source.width;\n\t\tthis.height = source.height;\n\n\t\treturn this;\n\n\t}\n\n\ttoJSON( meta ) {\n\n\t\tconst data = super.toJSON( meta );\n\n\t\tdata.object.width = this.width;\n\t\tdata.object.height = this.height;\n\n\t\treturn data;\n\n\t}\n\n}\n\n/**\n * Primary reference:\n * https://graphics.stanford.edu/papers/envmap/envmap.pdf\n *\n * Secondary reference:\n * https://www.ppsloan.org/publications/StupidSH36.pdf\n */\n\n// 3-band SH defined by 9 coefficients\n\nclass SphericalHarmonics3 {\n\n\tconstructor() {\n\n\t\tthis.isSphericalHarmonics3 = true;\n\n\t\tthis.coefficients = [];\n\n\t\tfor ( let i = 0; i < 9; i ++ ) {\n\n\t\t\tthis.coefficients.push( new Vector3() );\n\n\t\t}\n\n\t}\n\n\tset( coefficients ) {\n\n\t\tfor ( let i = 0; i < 9; i ++ ) {\n\n\t\t\tthis.coefficients[ i ].copy( coefficients[ i ] );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tzero() {\n\n\t\tfor ( let i = 0; i < 9; i ++ ) {\n\n\t\t\tthis.coefficients[ i ].set( 0, 0, 0 );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\t// get the radiance in the direction of the normal\n\t// target is a Vector3\n\tgetAt( normal, target ) {\n\n\t\t// normal is assumed to be unit length\n\n\t\tconst x = normal.x, y = normal.y, z = normal.z;\n\n\t\tconst coeff = this.coefficients;\n\n\t\t// band 0\n\t\ttarget.copy( coeff[ 0 ] ).multiplyScalar( 0.282095 );\n\n\t\t// band 1\n\t\ttarget.addScaledVector( coeff[ 1 ], 0.488603 * y );\n\t\ttarget.addScaledVector( coeff[ 2 ], 0.488603 * z );\n\t\ttarget.addScaledVector( coeff[ 3 ], 0.488603 * x );\n\n\t\t// band 2\n\t\ttarget.addScaledVector( coeff[ 4 ], 1.092548 * ( x * y ) );\n\t\ttarget.addScaledVector( coeff[ 5 ], 1.092548 * ( y * z ) );\n\t\ttarget.addScaledVector( coeff[ 6 ], 0.315392 * ( 3.0 * z * z - 1.0 ) );\n\t\ttarget.addScaledVector( coeff[ 7 ], 1.092548 * ( x * z ) );\n\t\ttarget.addScaledVector( coeff[ 8 ], 0.546274 * ( x * x - y * y ) );\n\n\t\treturn target;\n\n\t}\n\n\t// get the irradiance (radiance convolved with cosine lobe) in the direction of the normal\n\t// target is a Vector3\n\t// https://graphics.stanford.edu/papers/envmap/envmap.pdf\n\tgetIrradianceAt( normal, target ) {\n\n\t\t// normal is assumed to be unit length\n\n\t\tconst x = normal.x, y = normal.y, z = normal.z;\n\n\t\tconst coeff = this.coefficients;\n\n\t\t// band 0\n\t\ttarget.copy( coeff[ 0 ] ).multiplyScalar( 0.886227 ); // \u03C0 * 0.282095\n\n\t\t// band 1\n\t\ttarget.addScaledVector( coeff[ 1 ], 2.0 * 0.511664 * y ); // ( 2 * \u03C0 / 3 ) * 0.488603\n\t\ttarget.addScaledVector( coeff[ 2 ], 2.0 * 0.511664 * z );\n\t\ttarget.addScaledVector( coeff[ 3 ], 2.0 * 0.511664 * x );\n\n\t\t// band 2\n\t\ttarget.addScaledVector( coeff[ 4 ], 2.0 * 0.429043 * x * y ); // ( \u03C0 / 4 ) * 1.092548\n\t\ttarget.addScaledVector( coeff[ 5 ], 2.0 * 0.429043 * y * z );\n\t\ttarget.addScaledVector( coeff[ 6 ], 0.743125 * z * z - 0.247708 ); // ( \u03C0 / 4 ) * 0.315392 * 3\n\t\ttarget.addScaledVector( coeff[ 7 ], 2.0 * 0.429043 * x * z );\n\t\ttarget.addScaledVector( coeff[ 8 ], 0.429043 * ( x * x - y * y ) ); // ( \u03C0 / 4 ) * 0.546274\n\n\t\treturn target;\n\n\t}\n\n\tadd( sh ) {\n\n\t\tfor ( let i = 0; i < 9; i ++ ) {\n\n\t\t\tthis.coefficients[ i ].add( sh.coefficients[ i ] );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\taddScaledSH( sh, s ) {\n\n\t\tfor ( let i = 0; i < 9; i ++ ) {\n\n\t\t\tthis.coefficients[ i ].addScaledVector( sh.coefficients[ i ], s );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tscale( s ) {\n\n\t\tfor ( let i = 0; i < 9; i ++ ) {\n\n\t\t\tthis.coefficients[ i ].multiplyScalar( s );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tlerp( sh, alpha ) {\n\n\t\tfor ( let i = 0; i < 9; i ++ ) {\n\n\t\t\tthis.coefficients[ i ].lerp( sh.coefficients[ i ], alpha );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tequals( sh ) {\n\n\t\tfor ( let i = 0; i < 9; i ++ ) {\n\n\t\t\tif ( ! this.coefficients[ i ].equals( sh.coefficients[ i ] ) ) {\n\n\t\t\t\treturn false;\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn true;\n\n\t}\n\n\tcopy( sh ) {\n\n\t\treturn this.set( sh.coefficients );\n\n\t}\n\n\tclone() {\n\n\t\treturn new this.constructor().copy( this );\n\n\t}\n\n\tfromArray( array, offset = 0 ) {\n\n\t\tconst coefficients = this.coefficients;\n\n\t\tfor ( let i = 0; i < 9; i ++ ) {\n\n\t\t\tcoefficients[ i ].fromArray( array, offset + ( i * 3 ) );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\ttoArray( array = [], offset = 0 ) {\n\n\t\tconst coefficients = this.coefficients;\n\n\t\tfor ( let i = 0; i < 9; i ++ ) {\n\n\t\t\tcoefficients[ i ].toArray( array, offset + ( i * 3 ) );\n\n\t\t}\n\n\t\treturn array;\n\n\t}\n\n\t// evaluate the basis functions\n\t// shBasis is an Array[ 9 ]\n\tstatic getBasisAt( normal, shBasis ) {\n\n\t\t// normal is assumed to be unit length\n\n\t\tconst x = normal.x, y = normal.y, z = normal.z;\n\n\t\t// band 0\n\t\tshBasis[ 0 ] = 0.282095;\n\n\t\t// band 1\n\t\tshBasis[ 1 ] = 0.488603 * y;\n\t\tshBasis[ 2 ] = 0.488603 * z;\n\t\tshBasis[ 3 ] = 0.488603 * x;\n\n\t\t// band 2\n\t\tshBasis[ 4 ] = 1.092548 * x * y;\n\t\tshBasis[ 5 ] = 1.092548 * y * z;\n\t\tshBasis[ 6 ] = 0.315392 * ( 3 * z * z - 1 );\n\t\tshBasis[ 7 ] = 1.092548 * x * z;\n\t\tshBasis[ 8 ] = 0.546274 * ( x * x - y * y );\n\n\t}\n\n}\n\nclass LightProbe extends Light {\n\n\tconstructor( sh = new SphericalHarmonics3(), intensity = 1 ) {\n\n\t\tsuper( undefined, intensity );\n\n\t\tthis.isLightProbe = true;\n\n\t\tthis.sh = sh;\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.sh.copy( source.sh );\n\n\t\treturn this;\n\n\t}\n\n\tfromJSON( json ) {\n\n\t\tthis.intensity = json.intensity; // TODO: Move this bit to Light.fromJSON();\n\t\tthis.sh.fromArray( json.sh );\n\n\t\treturn this;\n\n\t}\n\n\ttoJSON( meta ) {\n\n\t\tconst data = super.toJSON( meta );\n\n\t\tdata.object.sh = this.sh.toArray();\n\n\t\treturn data;\n\n\t}\n\n}\n\nclass MaterialLoader extends Loader {\n\n\tconstructor( manager ) {\n\n\t\tsuper( manager );\n\t\tthis.textures = {};\n\n\t}\n\n\tload( url, onLoad, onProgress, onError ) {\n\n\t\tconst scope = this;\n\n\t\tconst loader = new FileLoader( scope.manager );\n\t\tloader.setPath( scope.path );\n\t\tloader.setRequestHeader( scope.requestHeader );\n\t\tloader.setWithCredentials( scope.withCredentials );\n\t\tloader.load( url, function ( text ) {\n\n\t\t\ttry {\n\n\t\t\t\tonLoad( scope.parse( JSON.parse( text ) ) );\n\n\t\t\t} catch ( e ) {\n\n\t\t\t\tif ( onError ) {\n\n\t\t\t\t\tonError( e );\n\n\t\t\t\t} else {\n\n\t\t\t\t\tconsole.error( e );\n\n\t\t\t\t}\n\n\t\t\t\tscope.manager.itemError( url );\n\n\t\t\t}\n\n\t\t}, onProgress, onError );\n\n\t}\n\n\tparse( json ) {\n\n\t\tconst textures = this.textures;\n\n\t\tfunction getTexture( name ) {\n\n\t\t\tif ( textures[ name ] === undefined ) {\n\n\t\t\t\tconsole.warn( 'THREE.MaterialLoader: Undefined texture', name );\n\n\t\t\t}\n\n\t\t\treturn textures[ name ];\n\n\t\t}\n\n\t\tconst material = MaterialLoader.createMaterialFromType( json.type );\n\n\t\tif ( json.uuid !== undefined ) material.uuid = json.uuid;\n\t\tif ( json.name !== undefined ) material.name = json.name;\n\t\tif ( json.color !== undefined && material.color !== undefined ) material.color.setHex( json.color );\n\t\tif ( json.roughness !== undefined ) material.roughness = json.roughness;\n\t\tif ( json.metalness !== undefined ) material.metalness = json.metalness;\n\t\tif ( json.sheen !== undefined ) material.sheen = json.sheen;\n\t\tif ( json.sheenColor !== undefined ) material.sheenColor = new Color().setHex( json.sheenColor );\n\t\tif ( json.sheenRoughness !== undefined ) material.sheenRoughness = json.sheenRoughness;\n\t\tif ( json.emissive !== undefined && material.emissive !== undefined ) material.emissive.setHex( json.emissive );\n\t\tif ( json.specular !== undefined && material.specular !== undefined ) material.specular.setHex( json.specular );\n\t\tif ( json.specularIntensity !== undefined ) material.specularIntensity = json.specularIntensity;\n\t\tif ( json.specularColor !== undefined && material.specularColor !== undefined ) material.specularColor.setHex( json.specularColor );\n\t\tif ( json.shininess !== undefined ) material.shininess = json.shininess;\n\t\tif ( json.clearcoat !== undefined ) material.clearcoat = json.clearcoat;\n\t\tif ( json.clearcoatRoughness !== undefined ) material.clearcoatRoughness = json.clearcoatRoughness;\n\t\tif ( json.iridescence !== undefined ) material.iridescence = json.iridescence;\n\t\tif ( json.iridescenceIOR !== undefined ) material.iridescenceIOR = json.iridescenceIOR;\n\t\tif ( json.iridescenceThicknessRange !== undefined ) material.iridescenceThicknessRange = json.iridescenceThicknessRange;\n\t\tif ( json.transmission !== undefined ) material.transmission = json.transmission;\n\t\tif ( json.thickness !== undefined ) material.thickness = json.thickness;\n\t\tif ( json.attenuationDistance !== undefined ) material.attenuationDistance = json.attenuationDistance;\n\t\tif ( json.attenuationColor !== undefined && material.attenuationColor !== undefined ) material.attenuationColor.setHex( json.attenuationColor );\n\t\tif ( json.anisotropy !== undefined ) material.anisotropy = json.anisotropy;\n\t\tif ( json.anisotropyRotation !== undefined ) material.anisotropyRotation = json.anisotropyRotation;\n\t\tif ( json.fog !== undefined ) material.fog = json.fog;\n\t\tif ( json.flatShading !== undefined ) material.flatShading = json.flatShading;\n\t\tif ( json.blending !== undefined ) material.blending = json.blending;\n\t\tif ( json.combine !== undefined ) material.combine = json.combine;\n\t\tif ( json.side !== undefined ) material.side = json.side;\n\t\tif ( json.shadowSide !== undefined ) material.shadowSide = json.shadowSide;\n\t\tif ( json.opacity !== undefined ) material.opacity = json.opacity;\n\t\tif ( json.transparent !== undefined ) material.transparent = json.transparent;\n\t\tif ( json.alphaTest !== undefined ) material.alphaTest = json.alphaTest;\n\t\tif ( json.alphaHash !== undefined ) material.alphaHash = json.alphaHash;\n\t\tif ( json.depthFunc !== undefined ) material.depthFunc = json.depthFunc;\n\t\tif ( json.depthTest !== undefined ) material.depthTest = json.depthTest;\n\t\tif ( json.depthWrite !== undefined ) material.depthWrite = json.depthWrite;\n\t\tif ( json.colorWrite !== undefined ) material.colorWrite = json.colorWrite;\n\t\tif ( json.blendSrc !== undefined ) material.blendSrc = json.blendSrc;\n\t\tif ( json.blendDst !== undefined ) material.blendDst = json.blendDst;\n\t\tif ( json.blendEquation !== undefined ) material.blendEquation = json.blendEquation;\n\t\tif ( json.blendSrcAlpha !== undefined ) material.blendSrcAlpha = json.blendSrcAlpha;\n\t\tif ( json.blendDstAlpha !== undefined ) material.blendDstAlpha = json.blendDstAlpha;\n\t\tif ( json.blendEquationAlpha !== undefined ) material.blendEquationAlpha = json.blendEquationAlpha;\n\t\tif ( json.blendColor !== undefined && material.blendColor !== undefined ) material.blendColor.setHex( json.blendColor );\n\t\tif ( json.blendAlpha !== undefined ) material.blendAlpha = json.blendAlpha;\n\t\tif ( json.stencilWriteMask !== undefined ) material.stencilWriteMask = json.stencilWriteMask;\n\t\tif ( json.stencilFunc !== undefined ) material.stencilFunc = json.stencilFunc;\n\t\tif ( json.stencilRef !== undefined ) material.stencilRef = json.stencilRef;\n\t\tif ( json.stencilFuncMask !== undefined ) material.stencilFuncMask = json.stencilFuncMask;\n\t\tif ( json.stencilFail !== undefined ) material.stencilFail = json.stencilFail;\n\t\tif ( json.stencilZFail !== undefined ) material.stencilZFail = json.stencilZFail;\n\t\tif ( json.stencilZPass !== undefined ) material.stencilZPass = json.stencilZPass;\n\t\tif ( json.stencilWrite !== undefined ) material.stencilWrite = json.stencilWrite;\n\n\t\tif ( json.wireframe !== undefined ) material.wireframe = json.wireframe;\n\t\tif ( json.wireframeLinewidth !== undefined ) material.wireframeLinewidth = json.wireframeLinewidth;\n\t\tif ( json.wireframeLinecap !== undefined ) material.wireframeLinecap = json.wireframeLinecap;\n\t\tif ( json.wireframeLinejoin !== undefined ) material.wireframeLinejoin = json.wireframeLinejoin;\n\n\t\tif ( json.rotation !== undefined ) material.rotation = json.rotation;\n\n\t\tif ( json.linewidth !== undefined ) material.linewidth = json.linewidth;\n\t\tif ( json.dashSize !== undefined ) material.dashSize = json.dashSize;\n\t\tif ( json.gapSize !== undefined ) material.gapSize = json.gapSize;\n\t\tif ( json.scale !== undefined ) material.scale = json.scale;\n\n\t\tif ( json.polygonOffset !== undefined ) material.polygonOffset = json.polygonOffset;\n\t\tif ( json.polygonOffsetFactor !== undefined ) material.polygonOffsetFactor = json.polygonOffsetFactor;\n\t\tif ( json.polygonOffsetUnits !== undefined ) material.polygonOffsetUnits = json.polygonOffsetUnits;\n\n\t\tif ( json.dithering !== undefined ) material.dithering = json.dithering;\n\n\t\tif ( json.alphaToCoverage !== undefined ) material.alphaToCoverage = json.alphaToCoverage;\n\t\tif ( json.premultipliedAlpha !== undefined ) material.premultipliedAlpha = json.premultipliedAlpha;\n\t\tif ( json.forceSinglePass !== undefined ) material.forceSinglePass = json.forceSinglePass;\n\n\t\tif ( json.visible !== undefined ) material.visible = json.visible;\n\n\t\tif ( json.toneMapped !== undefined ) material.toneMapped = json.toneMapped;\n\n\t\tif ( json.userData !== undefined ) material.userData = json.userData;\n\n\t\tif ( json.vertexColors !== undefined ) {\n\n\t\t\tif ( typeof json.vertexColors === 'number' ) {\n\n\t\t\t\tmaterial.vertexColors = ( json.vertexColors > 0 ) ? true : false;\n\n\t\t\t} else {\n\n\t\t\t\tmaterial.vertexColors = json.vertexColors;\n\n\t\t\t}\n\n\t\t}\n\n\t\t// Shader Material\n\n\t\tif ( json.uniforms !== undefined ) {\n\n\t\t\tfor ( const name in json.uniforms ) {\n\n\t\t\t\tconst uniform = json.uniforms[ name ];\n\n\t\t\t\tmaterial.uniforms[ name ] = {};\n\n\t\t\t\tswitch ( uniform.type ) {\n\n\t\t\t\t\tcase 't':\n\t\t\t\t\t\tmaterial.uniforms[ name ].value = getTexture( uniform.value );\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tcase 'c':\n\t\t\t\t\t\tmaterial.uniforms[ name ].value = new Color().setHex( uniform.value );\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tcase 'v2':\n\t\t\t\t\t\tmaterial.uniforms[ name ].value = new Vector2().fromArray( uniform.value );\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tcase 'v3':\n\t\t\t\t\t\tmaterial.uniforms[ name ].value = new Vector3().fromArray( uniform.value );\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tcase 'v4':\n\t\t\t\t\t\tmaterial.uniforms[ name ].value = new Vector4().fromArray( uniform.value );\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tcase 'm3':\n\t\t\t\t\t\tmaterial.uniforms[ name ].value = new Matrix3().fromArray( uniform.value );\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tcase 'm4':\n\t\t\t\t\t\tmaterial.uniforms[ name ].value = new Matrix4().fromArray( uniform.value );\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tdefault:\n\t\t\t\t\t\tmaterial.uniforms[ name ].value = uniform.value;\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t\tif ( json.defines !== undefined ) material.defines = json.defines;\n\t\tif ( json.vertexShader !== undefined ) material.vertexShader = json.vertexShader;\n\t\tif ( json.fragmentShader !== undefined ) material.fragmentShader = json.fragmentShader;\n\t\tif ( json.glslVersion !== undefined ) material.glslVersion = json.glslVersion;\n\n\t\tif ( json.extensions !== undefined ) {\n\n\t\t\tfor ( const key in json.extensions ) {\n\n\t\t\t\tmaterial.extensions[ key ] = json.extensions[ key ];\n\n\t\t\t}\n\n\t\t}\n\n\t\tif ( json.lights !== undefined ) material.lights = json.lights;\n\t\tif ( json.clipping !== undefined ) material.clipping = json.clipping;\n\n\t\t// for PointsMaterial\n\n\t\tif ( json.size !== undefined ) material.size = json.size;\n\t\tif ( json.sizeAttenuation !== undefined ) material.sizeAttenuation = json.sizeAttenuation;\n\n\t\t// maps\n\n\t\tif ( json.map !== undefined ) material.map = getTexture( json.map );\n\t\tif ( json.matcap !== undefined ) material.matcap = getTexture( json.matcap );\n\n\t\tif ( json.alphaMap !== undefined ) material.alphaMap = getTexture( json.alphaMap );\n\n\t\tif ( json.bumpMap !== undefined ) material.bumpMap = getTexture( json.bumpMap );\n\t\tif ( json.bumpScale !== undefined ) material.bumpScale = json.bumpScale;\n\n\t\tif ( json.normalMap !== undefined ) material.normalMap = getTexture( json.normalMap );\n\t\tif ( json.normalMapType !== undefined ) material.normalMapType = json.normalMapType;\n\t\tif ( json.normalScale !== undefined ) {\n\n\t\t\tlet normalScale = json.normalScale;\n\n\t\t\tif ( Array.isArray( normalScale ) === false ) {\n\n\t\t\t\t// Blender exporter used to export a scalar. See #7459\n\n\t\t\t\tnormalScale = [ normalScale, normalScale ];\n\n\t\t\t}\n\n\t\t\tmaterial.normalScale = new Vector2().fromArray( normalScale );\n\n\t\t}\n\n\t\tif ( json.displacementMap !== undefined ) material.displacementMap = getTexture( json.displacementMap );\n\t\tif ( json.displacementScale !== undefined ) material.displacementScale = json.displacementScale;\n\t\tif ( json.displacementBias !== undefined ) material.displacementBias = json.displacementBias;\n\n\t\tif ( json.roughnessMap !== undefined ) material.roughnessMap = getTexture( json.roughnessMap );\n\t\tif ( json.metalnessMap !== undefined ) material.metalnessMap = getTexture( json.metalnessMap );\n\n\t\tif ( json.emissiveMap !== undefined ) material.emissiveMap = getTexture( json.emissiveMap );\n\t\tif ( json.emissiveIntensity !== undefined ) material.emissiveIntensity = json.emissiveIntensity;\n\n\t\tif ( json.specularMap !== undefined ) material.specularMap = getTexture( json.specularMap );\n\t\tif ( json.specularIntensityMap !== undefined ) material.specularIntensityMap = getTexture( json.specularIntensityMap );\n\t\tif ( json.specularColorMap !== undefined ) material.specularColorMap = getTexture( json.specularColorMap );\n\n\t\tif ( json.envMap !== undefined ) material.envMap = getTexture( json.envMap );\n\t\tif ( json.envMapRotation !== undefined ) material.envMapRotation.fromArray( json.envMapRotation );\n\t\tif ( json.envMapIntensity !== undefined ) material.envMapIntensity = json.envMapIntensity;\n\n\t\tif ( json.reflectivity !== undefined ) material.reflectivity = json.reflectivity;\n\t\tif ( json.refractionRatio !== undefined ) material.refractionRatio = json.refractionRatio;\n\n\t\tif ( json.lightMap !== undefined ) material.lightMap = getTexture( json.lightMap );\n\t\tif ( json.lightMapIntensity !== undefined ) material.lightMapIntensity = json.lightMapIntensity;\n\n\t\tif ( json.aoMap !== undefined ) material.aoMap = getTexture( json.aoMap );\n\t\tif ( json.aoMapIntensity !== undefined ) material.aoMapIntensity = json.aoMapIntensity;\n\n\t\tif ( json.gradientMap !== undefined ) material.gradientMap = getTexture( json.gradientMap );\n\n\t\tif ( json.clearcoatMap !== undefined ) material.clearcoatMap = getTexture( json.clearcoatMap );\n\t\tif ( json.clearcoatRoughnessMap !== undefined ) material.clearcoatRoughnessMap = getTexture( json.clearcoatRoughnessMap );\n\t\tif ( json.clearcoatNormalMap !== undefined ) material.clearcoatNormalMap = getTexture( json.clearcoatNormalMap );\n\t\tif ( json.clearcoatNormalScale !== undefined ) material.clearcoatNormalScale = new Vector2().fromArray( json.clearcoatNormalScale );\n\n\t\tif ( json.iridescenceMap !== undefined ) material.iridescenceMap = getTexture( json.iridescenceMap );\n\t\tif ( json.iridescenceThicknessMap !== undefined ) material.iridescenceThicknessMap = getTexture( json.iridescenceThicknessMap );\n\n\t\tif ( json.transmissionMap !== undefined ) material.transmissionMap = getTexture( json.transmissionMap );\n\t\tif ( json.thicknessMap !== undefined ) material.thicknessMap = getTexture( json.thicknessMap );\n\n\t\tif ( json.anisotropyMap !== undefined ) material.anisotropyMap = getTexture( json.anisotropyMap );\n\n\t\tif ( json.sheenColorMap !== undefined ) material.sheenColorMap = getTexture( json.sheenColorMap );\n\t\tif ( json.sheenRoughnessMap !== undefined ) material.sheenRoughnessMap = getTexture( json.sheenRoughnessMap );\n\n\t\treturn material;\n\n\t}\n\n\tsetTextures( value ) {\n\n\t\tthis.textures = value;\n\t\treturn this;\n\n\t}\n\n\tstatic createMaterialFromType( type ) {\n\n\t\tconst materialLib = {\n\t\t\tShadowMaterial,\n\t\t\tSpriteMaterial,\n\t\t\tRawShaderMaterial,\n\t\t\tShaderMaterial,\n\t\t\tPointsMaterial,\n\t\t\tMeshPhysicalMaterial,\n\t\t\tMeshStandardMaterial,\n\t\t\tMeshPhongMaterial,\n\t\t\tMeshToonMaterial,\n\t\t\tMeshNormalMaterial,\n\t\t\tMeshLambertMaterial,\n\t\t\tMeshDepthMaterial,\n\t\t\tMeshDistanceMaterial,\n\t\t\tMeshBasicMaterial,\n\t\t\tMeshMatcapMaterial,\n\t\t\tLineDashedMaterial,\n\t\t\tLineBasicMaterial,\n\t\t\tMaterial\n\t\t};\n\n\t\treturn new materialLib[ type ]();\n\n\t}\n\n}\n\nclass LoaderUtils {\n\n\tstatic decodeText( array ) {\n\n\t\tif ( typeof TextDecoder !== 'undefined' ) {\n\n\t\t\treturn new TextDecoder().decode( array );\n\n\t\t}\n\n\t\t// Avoid the String.fromCharCode.apply(null, array) shortcut, which\n\t\t// throws a \"maximum call stack size exceeded\" error for large arrays.\n\n\t\tlet s = '';\n\n\t\tfor ( let i = 0, il = array.length; i < il; i ++ ) {\n\n\t\t\t// Implicitly assumes little-endian.\n\t\t\ts += String.fromCharCode( array[ i ] );\n\n\t\t}\n\n\t\ttry {\n\n\t\t\t// merges multi-byte utf-8 characters.\n\n\t\t\treturn decodeURIComponent( escape( s ) );\n\n\t\t} catch ( e ) { // see #16358\n\n\t\t\treturn s;\n\n\t\t}\n\n\t}\n\n\tstatic extractUrlBase( url ) {\n\n\t\tconst index = url.lastIndexOf( '/' );\n\n\t\tif ( index === - 1 ) return './';\n\n\t\treturn url.slice( 0, index + 1 );\n\n\t}\n\n\tstatic resolveURL( url, path ) {\n\n\t\t// Invalid URL\n\t\tif ( typeof url !== 'string' || url === '' ) return '';\n\n\t\t// Host Relative URL\n\t\tif ( /^https?:\\/\\//i.test( path ) && /^\\//.test( url ) ) {\n\n\t\t\tpath = path.replace( /(^https?:\\/\\/[^\\/]+).*/i, '$1' );\n\n\t\t}\n\n\t\t// Absolute URL http://,https://,//\n\t\tif ( /^(https?:)?\\/\\//i.test( url ) ) return url;\n\n\t\t// Data URI\n\t\tif ( /^data:.*,.*$/i.test( url ) ) return url;\n\n\t\t// Blob URL\n\t\tif ( /^blob:.*$/i.test( url ) ) return url;\n\n\t\t// Relative URL\n\t\treturn path + url;\n\n\t}\n\n}\n\nclass InstancedBufferGeometry extends BufferGeometry {\n\n\tconstructor() {\n\n\t\tsuper();\n\n\t\tthis.isInstancedBufferGeometry = true;\n\n\t\tthis.type = 'InstancedBufferGeometry';\n\t\tthis.instanceCount = Infinity;\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.instanceCount = source.instanceCount;\n\n\t\treturn this;\n\n\t}\n\n\ttoJSON() {\n\n\t\tconst data = super.toJSON();\n\n\t\tdata.instanceCount = this.instanceCount;\n\n\t\tdata.isInstancedBufferGeometry = true;\n\n\t\treturn data;\n\n\t}\n\n}\n\nclass BufferGeometryLoader extends Loader {\n\n\tconstructor( manager ) {\n\n\t\tsuper( manager );\n\n\t}\n\n\tload( url, onLoad, onProgress, onError ) {\n\n\t\tconst scope = this;\n\n\t\tconst loader = new FileLoader( scope.manager );\n\t\tloader.setPath( scope.path );\n\t\tloader.setRequestHeader( scope.requestHeader );\n\t\tloader.setWithCredentials( scope.withCredentials );\n\t\tloader.load( url, function ( text ) {\n\n\t\t\ttry {\n\n\t\t\t\tonLoad( scope.parse( JSON.parse( text ) ) );\n\n\t\t\t} catch ( e ) {\n\n\t\t\t\tif ( onError ) {\n\n\t\t\t\t\tonError( e );\n\n\t\t\t\t} else {\n\n\t\t\t\t\tconsole.error( e );\n\n\t\t\t\t}\n\n\t\t\t\tscope.manager.itemError( url );\n\n\t\t\t}\n\n\t\t}, onProgress, onError );\n\n\t}\n\n\tparse( json ) {\n\n\t\tconst interleavedBufferMap = {};\n\t\tconst arrayBufferMap = {};\n\n\t\tfunction getInterleavedBuffer( json, uuid ) {\n\n\t\t\tif ( interleavedBufferMap[ uuid ] !== undefined ) return interleavedBufferMap[ uuid ];\n\n\t\t\tconst interleavedBuffers = json.interleavedBuffers;\n\t\t\tconst interleavedBuffer = interleavedBuffers[ uuid ];\n\n\t\t\tconst buffer = getArrayBuffer( json, interleavedBuffer.buffer );\n\n\t\t\tconst array = getTypedArray( interleavedBuffer.type, buffer );\n\t\t\tconst ib = new InterleavedBuffer( array, interleavedBuffer.stride );\n\t\t\tib.uuid = interleavedBuffer.uuid;\n\n\t\t\tinterleavedBufferMap[ uuid ] = ib;\n\n\t\t\treturn ib;\n\n\t\t}\n\n\t\tfunction getArrayBuffer( json, uuid ) {\n\n\t\t\tif ( arrayBufferMap[ uuid ] !== undefined ) return arrayBufferMap[ uuid ];\n\n\t\t\tconst arrayBuffers = json.arrayBuffers;\n\t\t\tconst arrayBuffer = arrayBuffers[ uuid ];\n\n\t\t\tconst ab = new Uint32Array( arrayBuffer ).buffer;\n\n\t\t\tarrayBufferMap[ uuid ] = ab;\n\n\t\t\treturn ab;\n\n\t\t}\n\n\t\tconst geometry = json.isInstancedBufferGeometry ? new InstancedBufferGeometry() : new BufferGeometry();\n\n\t\tconst index = json.data.index;\n\n\t\tif ( index !== undefined ) {\n\n\t\t\tconst typedArray = getTypedArray( index.type, index.array );\n\t\t\tgeometry.setIndex( new BufferAttribute( typedArray, 1 ) );\n\n\t\t}\n\n\t\tconst attributes = json.data.attributes;\n\n\t\tfor ( const key in attributes ) {\n\n\t\t\tconst attribute = attributes[ key ];\n\t\t\tlet bufferAttribute;\n\n\t\t\tif ( attribute.isInterleavedBufferAttribute ) {\n\n\t\t\t\tconst interleavedBuffer = getInterleavedBuffer( json.data, attribute.data );\n\t\t\t\tbufferAttribute = new InterleavedBufferAttribute( interleavedBuffer, attribute.itemSize, attribute.offset, attribute.normalized );\n\n\t\t\t} else {\n\n\t\t\t\tconst typedArray = getTypedArray( attribute.type, attribute.array );\n\t\t\t\tconst bufferAttributeConstr = attribute.isInstancedBufferAttribute ? InstancedBufferAttribute : BufferAttribute;\n\t\t\t\tbufferAttribute = new bufferAttributeConstr( typedArray, attribute.itemSize, attribute.normalized );\n\n\t\t\t}\n\n\t\t\tif ( attribute.name !== undefined ) bufferAttribute.name = attribute.name;\n\t\t\tif ( attribute.usage !== undefined ) bufferAttribute.setUsage( attribute.usage );\n\n\t\t\tgeometry.setAttribute( key, bufferAttribute );\n\n\t\t}\n\n\t\tconst morphAttributes = json.data.morphAttributes;\n\n\t\tif ( morphAttributes ) {\n\n\t\t\tfor ( const key in morphAttributes ) {\n\n\t\t\t\tconst attributeArray = morphAttributes[ key ];\n\n\t\t\t\tconst array = [];\n\n\t\t\t\tfor ( let i = 0, il = attributeArray.length; i < il; i ++ ) {\n\n\t\t\t\t\tconst attribute = attributeArray[ i ];\n\t\t\t\t\tlet bufferAttribute;\n\n\t\t\t\t\tif ( attribute.isInterleavedBufferAttribute ) {\n\n\t\t\t\t\t\tconst interleavedBuffer = getInterleavedBuffer( json.data, attribute.data );\n\t\t\t\t\t\tbufferAttribute = new InterleavedBufferAttribute( interleavedBuffer, attribute.itemSize, attribute.offset, attribute.normalized );\n\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\tconst typedArray = getTypedArray( attribute.type, attribute.array );\n\t\t\t\t\t\tbufferAttribute = new BufferAttribute( typedArray, attribute.itemSize, attribute.normalized );\n\n\t\t\t\t\t}\n\n\t\t\t\t\tif ( attribute.name !== undefined ) bufferAttribute.name = attribute.name;\n\t\t\t\t\tarray.push( bufferAttribute );\n\n\t\t\t\t}\n\n\t\t\t\tgeometry.morphAttributes[ key ] = array;\n\n\t\t\t}\n\n\t\t}\n\n\t\tconst morphTargetsRelative = json.data.morphTargetsRelative;\n\n\t\tif ( morphTargetsRelative ) {\n\n\t\t\tgeometry.morphTargetsRelative = true;\n\n\t\t}\n\n\t\tconst groups = json.data.groups || json.data.drawcalls || json.data.offsets;\n\n\t\tif ( groups !== undefined ) {\n\n\t\t\tfor ( let i = 0, n = groups.length; i !== n; ++ i ) {\n\n\t\t\t\tconst group = groups[ i ];\n\n\t\t\t\tgeometry.addGroup( group.start, group.count, group.materialIndex );\n\n\t\t\t}\n\n\t\t}\n\n\t\tconst boundingSphere = json.data.boundingSphere;\n\n\t\tif ( boundingSphere !== undefined ) {\n\n\t\t\tconst center = new Vector3();\n\n\t\t\tif ( boundingSphere.center !== undefined ) {\n\n\t\t\t\tcenter.fromArray( boundingSphere.center );\n\n\t\t\t}\n\n\t\t\tgeometry.boundingSphere = new Sphere( center, boundingSphere.radius );\n\n\t\t}\n\n\t\tif ( json.name ) geometry.name = json.name;\n\t\tif ( json.userData ) geometry.userData = json.userData;\n\n\t\treturn geometry;\n\n\t}\n\n}\n\nclass ObjectLoader extends Loader {\n\n\tconstructor( manager ) {\n\n\t\tsuper( manager );\n\n\t}\n\n\tload( url, onLoad, onProgress, onError ) {\n\n\t\tconst scope = this;\n\n\t\tconst path = ( this.path === '' ) ? LoaderUtils.extractUrlBase( url ) : this.path;\n\t\tthis.resourcePath = this.resourcePath || path;\n\n\t\tconst loader = new FileLoader( this.manager );\n\t\tloader.setPath( this.path );\n\t\tloader.setRequestHeader( this.requestHeader );\n\t\tloader.setWithCredentials( this.withCredentials );\n\t\tloader.load( url, function ( text ) {\n\n\t\t\tlet json = null;\n\n\t\t\ttry {\n\n\t\t\t\tjson = JSON.parse( text );\n\n\t\t\t} catch ( error ) {\n\n\t\t\t\tif ( onError !== undefined ) onError( error );\n\n\t\t\t\tconsole.error( 'THREE:ObjectLoader: Can\\'t parse ' + url + '.', error.message );\n\n\t\t\t\treturn;\n\n\t\t\t}\n\n\t\t\tconst metadata = json.metadata;\n\n\t\t\tif ( metadata === undefined || metadata.type === undefined || metadata.type.toLowerCase() === 'geometry' ) {\n\n\t\t\t\tif ( onError !== undefined ) onError( new Error( 'THREE.ObjectLoader: Can\\'t load ' + url ) );\n\n\t\t\t\tconsole.error( 'THREE.ObjectLoader: Can\\'t load ' + url );\n\t\t\t\treturn;\n\n\t\t\t}\n\n\t\t\tscope.parse( json, onLoad );\n\n\t\t}, onProgress, onError );\n\n\t}\n\n\tasync loadAsync( url, onProgress ) {\n\n\t\tconst scope = this;\n\n\t\tconst path = ( this.path === '' ) ? LoaderUtils.extractUrlBase( url ) : this.path;\n\t\tthis.resourcePath = this.resourcePath || path;\n\n\t\tconst loader = new FileLoader( this.manager );\n\t\tloader.setPath( this.path );\n\t\tloader.setRequestHeader( this.requestHeader );\n\t\tloader.setWithCredentials( this.withCredentials );\n\n\t\tconst text = await loader.loadAsync( url, onProgress );\n\n\t\tconst json = JSON.parse( text );\n\n\t\tconst metadata = json.metadata;\n\n\t\tif ( metadata === undefined || metadata.type === undefined || metadata.type.toLowerCase() === 'geometry' ) {\n\n\t\t\tthrow new Error( 'THREE.ObjectLoader: Can\\'t load ' + url );\n\n\t\t}\n\n\t\treturn await scope.parseAsync( json );\n\n\t}\n\n\tparse( json, onLoad ) {\n\n\t\tconst animations = this.parseAnimations( json.animations );\n\t\tconst shapes = this.parseShapes( json.shapes );\n\t\tconst geometries = this.parseGeometries( json.geometries, shapes );\n\n\t\tconst images = this.parseImages( json.images, function () {\n\n\t\t\tif ( onLoad !== undefined ) onLoad( object );\n\n\t\t} );\n\n\t\tconst textures = this.parseTextures( json.textures, images );\n\t\tconst materials = this.parseMaterials( json.materials, textures );\n\n\t\tconst object = this.parseObject( json.object, geometries, materials, textures, animations );\n\t\tconst skeletons = this.parseSkeletons( json.skeletons, object );\n\n\t\tthis.bindSkeletons( object, skeletons );\n\n\t\t//\n\n\t\tif ( onLoad !== undefined ) {\n\n\t\t\tlet hasImages = false;\n\n\t\t\tfor ( const uuid in images ) {\n\n\t\t\t\tif ( images[ uuid ].data instanceof HTMLImageElement ) {\n\n\t\t\t\t\thasImages = true;\n\t\t\t\t\tbreak;\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tif ( hasImages === false ) onLoad( object );\n\n\t\t}\n\n\t\treturn object;\n\n\t}\n\n\tasync parseAsync( json ) {\n\n\t\tconst animations = this.parseAnimations( json.animations );\n\t\tconst shapes = this.parseShapes( json.shapes );\n\t\tconst geometries = this.parseGeometries( json.geometries, shapes );\n\n\t\tconst images = await this.parseImagesAsync( json.images );\n\n\t\tconst textures = this.parseTextures( json.textures, images );\n\t\tconst materials = this.parseMaterials( json.materials, textures );\n\n\t\tconst object = this.parseObject( json.object, geometries, materials, textures, animations );\n\t\tconst skeletons = this.parseSkeletons( json.skeletons, object );\n\n\t\tthis.bindSkeletons( object, skeletons );\n\n\t\treturn object;\n\n\t}\n\n\tparseShapes( json ) {\n\n\t\tconst shapes = {};\n\n\t\tif ( json !== undefined ) {\n\n\t\t\tfor ( let i = 0, l = json.length; i < l; i ++ ) {\n\n\t\t\t\tconst shape = new Shape().fromJSON( json[ i ] );\n\n\t\t\t\tshapes[ shape.uuid ] = shape;\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn shapes;\n\n\t}\n\n\tparseSkeletons( json, object ) {\n\n\t\tconst skeletons = {};\n\t\tconst bones = {};\n\n\t\t// generate bone lookup table\n\n\t\tobject.traverse( function ( child ) {\n\n\t\t\tif ( child.isBone ) bones[ child.uuid ] = child;\n\n\t\t} );\n\n\t\t// create skeletons\n\n\t\tif ( json !== undefined ) {\n\n\t\t\tfor ( let i = 0, l = json.length; i < l; i ++ ) {\n\n\t\t\t\tconst skeleton = new Skeleton().fromJSON( json[ i ], bones );\n\n\t\t\t\tskeletons[ skeleton.uuid ] = skeleton;\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn skeletons;\n\n\t}\n\n\tparseGeometries( json, shapes ) {\n\n\t\tconst geometries = {};\n\n\t\tif ( json !== undefined ) {\n\n\t\t\tconst bufferGeometryLoader = new BufferGeometryLoader();\n\n\t\t\tfor ( let i = 0, l = json.length; i < l; i ++ ) {\n\n\t\t\t\tlet geometry;\n\t\t\t\tconst data = json[ i ];\n\n\t\t\t\tswitch ( data.type ) {\n\n\t\t\t\t\tcase 'BufferGeometry':\n\t\t\t\t\tcase 'InstancedBufferGeometry':\n\n\t\t\t\t\t\tgeometry = bufferGeometryLoader.parse( data );\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tdefault:\n\n\t\t\t\t\t\tif ( data.type in Geometries ) {\n\n\t\t\t\t\t\t\tgeometry = Geometries[ data.type ].fromJSON( data, shapes );\n\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\tconsole.warn( `THREE.ObjectLoader: Unsupported geometry type \"${ data.type }\"` );\n\n\t\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t\tgeometry.uuid = data.uuid;\n\n\t\t\t\tif ( data.name !== undefined ) geometry.name = data.name;\n\t\t\t\tif ( data.userData !== undefined ) geometry.userData = data.userData;\n\n\t\t\t\tgeometries[ data.uuid ] = geometry;\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn geometries;\n\n\t}\n\n\tparseMaterials( json, textures ) {\n\n\t\tconst cache = {}; // MultiMaterial\n\t\tconst materials = {};\n\n\t\tif ( json !== undefined ) {\n\n\t\t\tconst loader = new MaterialLoader();\n\t\t\tloader.setTextures( textures );\n\n\t\t\tfor ( let i = 0, l = json.length; i < l; i ++ ) {\n\n\t\t\t\tconst data = json[ i ];\n\n\t\t\t\tif ( cache[ data.uuid ] === undefined ) {\n\n\t\t\t\t\tcache[ data.uuid ] = loader.parse( data );\n\n\t\t\t\t}\n\n\t\t\t\tmaterials[ data.uuid ] = cache[ data.uuid ];\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn materials;\n\n\t}\n\n\tparseAnimations( json ) {\n\n\t\tconst animations = {};\n\n\t\tif ( json !== undefined ) {\n\n\t\t\tfor ( let i = 0; i < json.length; i ++ ) {\n\n\t\t\t\tconst data = json[ i ];\n\n\t\t\t\tconst clip = AnimationClip.parse( data );\n\n\t\t\t\tanimations[ clip.uuid ] = clip;\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn animations;\n\n\t}\n\n\tparseImages( json, onLoad ) {\n\n\t\tconst scope = this;\n\t\tconst images = {};\n\n\t\tlet loader;\n\n\t\tfunction loadImage( url ) {\n\n\t\t\tscope.manager.itemStart( url );\n\n\t\t\treturn loader.load( url, function () {\n\n\t\t\t\tscope.manager.itemEnd( url );\n\n\t\t\t}, undefined, function () {\n\n\t\t\t\tscope.manager.itemError( url );\n\t\t\t\tscope.manager.itemEnd( url );\n\n\t\t\t} );\n\n\t\t}\n\n\t\tfunction deserializeImage( image ) {\n\n\t\t\tif ( typeof image === 'string' ) {\n\n\t\t\t\tconst url = image;\n\n\t\t\t\tconst path = /^(\\/\\/)|([a-z]+:(\\/\\/)?)/i.test( url ) ? url : scope.resourcePath + url;\n\n\t\t\t\treturn loadImage( path );\n\n\t\t\t} else {\n\n\t\t\t\tif ( image.data ) {\n\n\t\t\t\t\treturn {\n\t\t\t\t\t\tdata: getTypedArray( image.type, image.data ),\n\t\t\t\t\t\twidth: image.width,\n\t\t\t\t\t\theight: image.height\n\t\t\t\t\t};\n\n\t\t\t\t} else {\n\n\t\t\t\t\treturn null;\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t\tif ( json !== undefined && json.length > 0 ) {\n\n\t\t\tconst manager = new LoadingManager( onLoad );\n\n\t\t\tloader = new ImageLoader( manager );\n\t\t\tloader.setCrossOrigin( this.crossOrigin );\n\n\t\t\tfor ( let i = 0, il = json.length; i < il; i ++ ) {\n\n\t\t\t\tconst image = json[ i ];\n\t\t\t\tconst url = image.url;\n\n\t\t\t\tif ( Array.isArray( url ) ) {\n\n\t\t\t\t\t// load array of images e.g CubeTexture\n\n\t\t\t\t\tconst imageArray = [];\n\n\t\t\t\t\tfor ( let j = 0, jl = url.length; j < jl; j ++ ) {\n\n\t\t\t\t\t\tconst currentUrl = url[ j ];\n\n\t\t\t\t\t\tconst deserializedImage = deserializeImage( currentUrl );\n\n\t\t\t\t\t\tif ( deserializedImage !== null ) {\n\n\t\t\t\t\t\t\tif ( deserializedImage instanceof HTMLImageElement ) {\n\n\t\t\t\t\t\t\t\timageArray.push( deserializedImage );\n\n\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\t// special case: handle array of data textures for cube textures\n\n\t\t\t\t\t\t\t\timageArray.push( new DataTexture( deserializedImage.data, deserializedImage.width, deserializedImage.height ) );\n\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}\n\n\t\t\t\t\timages[ image.uuid ] = new Source( imageArray );\n\n\t\t\t\t} else {\n\n\t\t\t\t\t// load single image\n\n\t\t\t\t\tconst deserializedImage = deserializeImage( image.url );\n\t\t\t\t\timages[ image.uuid ] = new Source( deserializedImage );\n\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn images;\n\n\t}\n\n\tasync parseImagesAsync( json ) {\n\n\t\tconst scope = this;\n\t\tconst images = {};\n\n\t\tlet loader;\n\n\t\tasync function deserializeImage( image ) {\n\n\t\t\tif ( typeof image === 'string' ) {\n\n\t\t\t\tconst url = image;\n\n\t\t\t\tconst path = /^(\\/\\/)|([a-z]+:(\\/\\/)?)/i.test( url ) ? url : scope.resourcePath + url;\n\n\t\t\t\treturn await loader.loadAsync( path );\n\n\t\t\t} else {\n\n\t\t\t\tif ( image.data ) {\n\n\t\t\t\t\treturn {\n\t\t\t\t\t\tdata: getTypedArray( image.type, image.data ),\n\t\t\t\t\t\twidth: image.width,\n\t\t\t\t\t\theight: image.height\n\t\t\t\t\t};\n\n\t\t\t\t} else {\n\n\t\t\t\t\treturn null;\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t\tif ( json !== undefined && json.length > 0 ) {\n\n\t\t\tloader = new ImageLoader( this.manager );\n\t\t\tloader.setCrossOrigin( this.crossOrigin );\n\n\t\t\tfor ( let i = 0, il = json.length; i < il; i ++ ) {\n\n\t\t\t\tconst image = json[ i ];\n\t\t\t\tconst url = image.url;\n\n\t\t\t\tif ( Array.isArray( url ) ) {\n\n\t\t\t\t\t// load array of images e.g CubeTexture\n\n\t\t\t\t\tconst imageArray = [];\n\n\t\t\t\t\tfor ( let j = 0, jl = url.length; j < jl; j ++ ) {\n\n\t\t\t\t\t\tconst currentUrl = url[ j ];\n\n\t\t\t\t\t\tconst deserializedImage = await deserializeImage( currentUrl );\n\n\t\t\t\t\t\tif ( deserializedImage !== null ) {\n\n\t\t\t\t\t\t\tif ( deserializedImage instanceof HTMLImageElement ) {\n\n\t\t\t\t\t\t\t\timageArray.push( deserializedImage );\n\n\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\t// special case: handle array of data textures for cube textures\n\n\t\t\t\t\t\t\t\timageArray.push( new DataTexture( deserializedImage.data, deserializedImage.width, deserializedImage.height ) );\n\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}\n\n\t\t\t\t\timages[ image.uuid ] = new Source( imageArray );\n\n\t\t\t\t} else {\n\n\t\t\t\t\t// load single image\n\n\t\t\t\t\tconst deserializedImage = await deserializeImage( image.url );\n\t\t\t\t\timages[ image.uuid ] = new Source( deserializedImage );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn images;\n\n\t}\n\n\tparseTextures( json, images ) {\n\n\t\tfunction parseConstant( value, type ) {\n\n\t\t\tif ( typeof value === 'number' ) return value;\n\n\t\t\tconsole.warn( 'THREE.ObjectLoader.parseTexture: Constant should be in numeric form.', value );\n\n\t\t\treturn type[ value ];\n\n\t\t}\n\n\t\tconst textures = {};\n\n\t\tif ( json !== undefined ) {\n\n\t\t\tfor ( let i = 0, l = json.length; i < l; i ++ ) {\n\n\t\t\t\tconst data = json[ i ];\n\n\t\t\t\tif ( data.image === undefined ) {\n\n\t\t\t\t\tconsole.warn( 'THREE.ObjectLoader: No \"image\" specified for', data.uuid );\n\n\t\t\t\t}\n\n\t\t\t\tif ( images[ data.image ] === undefined ) {\n\n\t\t\t\t\tconsole.warn( 'THREE.ObjectLoader: Undefined image', data.image );\n\n\t\t\t\t}\n\n\t\t\t\tconst source = images[ data.image ];\n\t\t\t\tconst image = source.data;\n\n\t\t\t\tlet texture;\n\n\t\t\t\tif ( Array.isArray( image ) ) {\n\n\t\t\t\t\ttexture = new CubeTexture();\n\n\t\t\t\t\tif ( image.length === 6 ) texture.needsUpdate = true;\n\n\t\t\t\t} else {\n\n\t\t\t\t\tif ( image && image.data ) {\n\n\t\t\t\t\t\ttexture = new DataTexture();\n\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\ttexture = new Texture();\n\n\t\t\t\t\t}\n\n\t\t\t\t\tif ( image ) texture.needsUpdate = true; // textures can have undefined image data\n\n\t\t\t\t}\n\n\t\t\t\ttexture.source = source;\n\n\t\t\t\ttexture.uuid = data.uuid;\n\n\t\t\t\tif ( data.name !== undefined ) texture.name = data.name;\n\n\t\t\t\tif ( data.mapping !== undefined ) texture.mapping = parseConstant( data.mapping, TEXTURE_MAPPING );\n\t\t\t\tif ( data.channel !== undefined ) texture.channel = data.channel;\n\n\t\t\t\tif ( data.offset !== undefined ) texture.offset.fromArray( data.offset );\n\t\t\t\tif ( data.repeat !== undefined ) texture.repeat.fromArray( data.repeat );\n\t\t\t\tif ( data.center !== undefined ) texture.center.fromArray( data.center );\n\t\t\t\tif ( data.rotation !== undefined ) texture.rotation = data.rotation;\n\n\t\t\t\tif ( data.wrap !== undefined ) {\n\n\t\t\t\t\ttexture.wrapS = parseConstant( data.wrap[ 0 ], TEXTURE_WRAPPING );\n\t\t\t\t\ttexture.wrapT = parseConstant( data.wrap[ 1 ], TEXTURE_WRAPPING );\n\n\t\t\t\t}\n\n\t\t\t\tif ( data.format !== undefined ) texture.format = data.format;\n\t\t\t\tif ( data.internalFormat !== undefined ) texture.internalFormat = data.internalFormat;\n\t\t\t\tif ( data.type !== undefined ) texture.type = data.type;\n\t\t\t\tif ( data.colorSpace !== undefined ) texture.colorSpace = data.colorSpace;\n\n\t\t\t\tif ( data.minFilter !== undefined ) texture.minFilter = parseConstant( data.minFilter, TEXTURE_FILTER );\n\t\t\t\tif ( data.magFilter !== undefined ) texture.magFilter = parseConstant( data.magFilter, TEXTURE_FILTER );\n\t\t\t\tif ( data.anisotropy !== undefined ) texture.anisotropy = data.anisotropy;\n\n\t\t\t\tif ( data.flipY !== undefined ) texture.flipY = data.flipY;\n\n\t\t\t\tif ( data.generateMipmaps !== undefined ) texture.generateMipmaps = data.generateMipmaps;\n\t\t\t\tif ( data.premultiplyAlpha !== undefined ) texture.premultiplyAlpha = data.premultiplyAlpha;\n\t\t\t\tif ( data.unpackAlignment !== undefined ) texture.unpackAlignment = data.unpackAlignment;\n\t\t\t\tif ( data.compareFunction !== undefined ) texture.compareFunction = data.compareFunction;\n\n\t\t\t\tif ( data.userData !== undefined ) texture.userData = data.userData;\n\n\t\t\t\ttextures[ data.uuid ] = texture;\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn textures;\n\n\t}\n\n\tparseObject( data, geometries, materials, textures, animations ) {\n\n\t\tlet object;\n\n\t\tfunction getGeometry( name ) {\n\n\t\t\tif ( geometries[ name ] === undefined ) {\n\n\t\t\t\tconsole.warn( 'THREE.ObjectLoader: Undefined geometry', name );\n\n\t\t\t}\n\n\t\t\treturn geometries[ name ];\n\n\t\t}\n\n\t\tfunction getMaterial( name ) {\n\n\t\t\tif ( name === undefined ) return undefined;\n\n\t\t\tif ( Array.isArray( name ) ) {\n\n\t\t\t\tconst array = [];\n\n\t\t\t\tfor ( let i = 0, l = name.length; i < l; i ++ ) {\n\n\t\t\t\t\tconst uuid = name[ i ];\n\n\t\t\t\t\tif ( materials[ uuid ] === undefined ) {\n\n\t\t\t\t\t\tconsole.warn( 'THREE.ObjectLoader: Undefined material', uuid );\n\n\t\t\t\t\t}\n\n\t\t\t\t\tarray.push( materials[ uuid ] );\n\n\t\t\t\t}\n\n\t\t\t\treturn array;\n\n\t\t\t}\n\n\t\t\tif ( materials[ name ] === undefined ) {\n\n\t\t\t\tconsole.warn( 'THREE.ObjectLoader: Undefined material', name );\n\n\t\t\t}\n\n\t\t\treturn materials[ name ];\n\n\t\t}\n\n\t\tfunction getTexture( uuid ) {\n\n\t\t\tif ( textures[ uuid ] === undefined ) {\n\n\t\t\t\tconsole.warn( 'THREE.ObjectLoader: Undefined texture', uuid );\n\n\t\t\t}\n\n\t\t\treturn textures[ uuid ];\n\n\t\t}\n\n\t\tlet geometry, material;\n\n\t\tswitch ( data.type ) {\n\n\t\t\tcase 'Scene':\n\n\t\t\t\tobject = new Scene();\n\n\t\t\t\tif ( data.background !== undefined ) {\n\n\t\t\t\t\tif ( Number.isInteger( data.background ) ) {\n\n\t\t\t\t\t\tobject.background = new Color( data.background );\n\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\tobject.background = getTexture( data.background );\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t\tif ( data.environment !== undefined ) {\n\n\t\t\t\t\tobject.environment = getTexture( data.environment );\n\n\t\t\t\t}\n\n\t\t\t\tif ( data.fog !== undefined ) {\n\n\t\t\t\t\tif ( data.fog.type === 'Fog' ) {\n\n\t\t\t\t\t\tobject.fog = new Fog( data.fog.color, data.fog.near, data.fog.far );\n\n\t\t\t\t\t} else if ( data.fog.type === 'FogExp2' ) {\n\n\t\t\t\t\t\tobject.fog = new FogExp2( data.fog.color, data.fog.density );\n\n\t\t\t\t\t}\n\n\t\t\t\t\tif ( data.fog.name !== '' ) {\n\n\t\t\t\t\t\tobject.fog.name = data.fog.name;\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t\tif ( data.backgroundBlurriness !== undefined ) object.backgroundBlurriness = data.backgroundBlurriness;\n\t\t\t\tif ( data.backgroundIntensity !== undefined ) object.backgroundIntensity = data.backgroundIntensity;\n\t\t\t\tif ( data.backgroundRotation !== undefined ) object.backgroundRotation.fromArray( data.backgroundRotation );\n\n\t\t\t\tif ( data.environmentIntensity !== undefined ) object.environmentIntensity = data.environmentIntensity;\n\t\t\t\tif ( data.environmentRotation !== undefined ) object.environmentRotation.fromArray( data.environmentRotation );\n\n\t\t\t\tbreak;\n\n\t\t\tcase 'PerspectiveCamera':\n\n\t\t\t\tobject = new PerspectiveCamera( data.fov, data.aspect, data.near, data.far );\n\n\t\t\t\tif ( data.focus !== undefined ) object.focus = data.focus;\n\t\t\t\tif ( data.zoom !== undefined ) object.zoom = data.zoom;\n\t\t\t\tif ( data.filmGauge !== undefined ) object.filmGauge = data.filmGauge;\n\t\t\t\tif ( data.filmOffset !== undefined ) object.filmOffset = data.filmOffset;\n\t\t\t\tif ( data.view !== undefined ) object.view = Object.assign( {}, data.view );\n\n\t\t\t\tbreak;\n\n\t\t\tcase 'OrthographicCamera':\n\n\t\t\t\tobject = new OrthographicCamera( data.left, data.right, data.top, data.bottom, data.near, data.far );\n\n\t\t\t\tif ( data.zoom !== undefined ) object.zoom = data.zoom;\n\t\t\t\tif ( data.view !== undefined ) object.view = Object.assign( {}, data.view );\n\n\t\t\t\tbreak;\n\n\t\t\tcase 'AmbientLight':\n\n\t\t\t\tobject = new AmbientLight( data.color, data.intensity );\n\n\t\t\t\tbreak;\n\n\t\t\tcase 'DirectionalLight':\n\n\t\t\t\tobject = new DirectionalLight( data.color, data.intensity );\n\n\t\t\t\tbreak;\n\n\t\t\tcase 'PointLight':\n\n\t\t\t\tobject = new PointLight( data.color, data.intensity, data.distance, data.decay );\n\n\t\t\t\tbreak;\n\n\t\t\tcase 'RectAreaLight':\n\n\t\t\t\tobject = new RectAreaLight( data.color, data.intensity, data.width, data.height );\n\n\t\t\t\tbreak;\n\n\t\t\tcase 'SpotLight':\n\n\t\t\t\tobject = new SpotLight( data.color, data.intensity, data.distance, data.angle, data.penumbra, data.decay );\n\n\t\t\t\tbreak;\n\n\t\t\tcase 'HemisphereLight':\n\n\t\t\t\tobject = new HemisphereLight( data.color, data.groundColor, data.intensity );\n\n\t\t\t\tbreak;\n\n\t\t\tcase 'LightProbe':\n\n\t\t\t\tobject = new LightProbe().fromJSON( data );\n\n\t\t\t\tbreak;\n\n\t\t\tcase 'SkinnedMesh':\n\n\t\t\t\tgeometry = getGeometry( data.geometry );\n\t\t\t \tmaterial = getMaterial( data.material );\n\n\t\t\t\tobject = new SkinnedMesh( geometry, material );\n\n\t\t\t\tif ( data.bindMode !== undefined ) object.bindMode = data.bindMode;\n\t\t\t\tif ( data.bindMatrix !== undefined ) object.bindMatrix.fromArray( data.bindMatrix );\n\t\t\t\tif ( data.skeleton !== undefined ) object.skeleton = data.skeleton;\n\n\t\t\t\tbreak;\n\n\t\t\tcase 'Mesh':\n\n\t\t\t\tgeometry = getGeometry( data.geometry );\n\t\t\t\tmaterial = getMaterial( data.material );\n\n\t\t\t\tobject = new Mesh( geometry, material );\n\n\t\t\t\tbreak;\n\n\t\t\tcase 'InstancedMesh':\n\n\t\t\t\tgeometry = getGeometry( data.geometry );\n\t\t\t\tmaterial = getMaterial( data.material );\n\t\t\t\tconst count = data.count;\n\t\t\t\tconst instanceMatrix = data.instanceMatrix;\n\t\t\t\tconst instanceColor = data.instanceColor;\n\n\t\t\t\tobject = new InstancedMesh( geometry, material, count );\n\t\t\t\tobject.instanceMatrix = new InstancedBufferAttribute( new Float32Array( instanceMatrix.array ), 16 );\n\t\t\t\tif ( instanceColor !== undefined ) object.instanceColor = new InstancedBufferAttribute( new Float32Array( instanceColor.array ), instanceColor.itemSize );\n\n\t\t\t\tbreak;\n\n\t\t\tcase 'BatchedMesh':\n\n\t\t\t\tgeometry = getGeometry( data.geometry );\n\t\t\t\tmaterial = getMaterial( data.material );\n\n\t\t\t\tobject = new BatchedMesh( data.maxGeometryCount, data.maxVertexCount, data.maxIndexCount, material );\n\t\t\t\tobject.geometry = geometry;\n\t\t\t\tobject.perObjectFrustumCulled = data.perObjectFrustumCulled;\n\t\t\t\tobject.sortObjects = data.sortObjects;\n\n\t\t\t\tobject._drawRanges = data.drawRanges;\n\t\t\t\tobject._reservedRanges = data.reservedRanges;\n\n\t\t\t\tobject._visibility = data.visibility;\n\t\t\t\tobject._active = data.active;\n\t\t\t\tobject._bounds = data.bounds.map( bound => {\n\n\t\t\t\t\tconst box = new Box3();\n\t\t\t\t\tbox.min.fromArray( bound.boxMin );\n\t\t\t\t\tbox.max.fromArray( bound.boxMax );\n\n\t\t\t\t\tconst sphere = new Sphere();\n\t\t\t\t\tsphere.radius = bound.sphereRadius;\n\t\t\t\t\tsphere.center.fromArray( bound.sphereCenter );\n\n\t\t\t\t\treturn {\n\t\t\t\t\t\tboxInitialized: bound.boxInitialized,\n\t\t\t\t\t\tbox: box,\n\n\t\t\t\t\t\tsphereInitialized: bound.sphereInitialized,\n\t\t\t\t\t\tsphere: sphere\n\t\t\t\t\t};\n\n\t\t\t\t} );\n\n\t\t\t\tobject._maxGeometryCount = data.maxGeometryCount;\n\t\t\t\tobject._maxVertexCount = data.maxVertexCount;\n\t\t\t\tobject._maxIndexCount = data.maxIndexCount;\n\n\t\t\t\tobject._geometryInitialized = data.geometryInitialized;\n\t\t\t\tobject._geometryCount = data.geometryCount;\n\n\t\t\t\tobject._matricesTexture = getTexture( data.matricesTexture.uuid );\n\n\t\t\t\tbreak;\n\n\t\t\tcase 'LOD':\n\n\t\t\t\tobject = new LOD();\n\n\t\t\t\tbreak;\n\n\t\t\tcase 'Line':\n\n\t\t\t\tobject = new Line( getGeometry( data.geometry ), getMaterial( data.material ) );\n\n\t\t\t\tbreak;\n\n\t\t\tcase 'LineLoop':\n\n\t\t\t\tobject = new LineLoop( getGeometry( data.geometry ), getMaterial( data.material ) );\n\n\t\t\t\tbreak;\n\n\t\t\tcase 'LineSegments':\n\n\t\t\t\tobject = new LineSegments( getGeometry( data.geometry ), getMaterial( data.material ) );\n\n\t\t\t\tbreak;\n\n\t\t\tcase 'PointCloud':\n\t\t\tcase 'Points':\n\n\t\t\t\tobject = new Points( getGeometry( data.geometry ), getMaterial( data.material ) );\n\n\t\t\t\tbreak;\n\n\t\t\tcase 'Sprite':\n\n\t\t\t\tobject = new Sprite( getMaterial( data.material ) );\n\n\t\t\t\tbreak;\n\n\t\t\tcase 'Group':\n\n\t\t\t\tobject = new Group();\n\n\t\t\t\tbreak;\n\n\t\t\tcase 'Bone':\n\n\t\t\t\tobject = new Bone();\n\n\t\t\t\tbreak;\n\n\t\t\tdefault:\n\n\t\t\t\tobject = new Object3D();\n\n\t\t}\n\n\t\tobject.uuid = data.uuid;\n\n\t\tif ( data.name !== undefined ) object.name = data.name;\n\n\t\tif ( data.matrix !== undefined ) {\n\n\t\t\tobject.matrix.fromArray( data.matrix );\n\n\t\t\tif ( data.matrixAutoUpdate !== undefined ) object.matrixAutoUpdate = data.matrixAutoUpdate;\n\t\t\tif ( object.matrixAutoUpdate ) object.matrix.decompose( object.position, object.quaternion, object.scale );\n\n\t\t} else {\n\n\t\t\tif ( data.position !== undefined ) object.position.fromArray( data.position );\n\t\t\tif ( data.rotation !== undefined ) object.rotation.fromArray( data.rotation );\n\t\t\tif ( data.quaternion !== undefined ) object.quaternion.fromArray( data.quaternion );\n\t\t\tif ( data.scale !== undefined ) object.scale.fromArray( data.scale );\n\n\t\t}\n\n\t\tif ( data.up !== undefined ) object.up.fromArray( data.up );\n\n\t\tif ( data.castShadow !== undefined ) object.castShadow = data.castShadow;\n\t\tif ( data.receiveShadow !== undefined ) object.receiveShadow = data.receiveShadow;\n\n\t\tif ( data.shadow ) {\n\n\t\t\tif ( data.shadow.bias !== undefined ) object.shadow.bias = data.shadow.bias;\n\t\t\tif ( data.shadow.normalBias !== undefined ) object.shadow.normalBias = data.shadow.normalBias;\n\t\t\tif ( data.shadow.radius !== undefined ) object.shadow.radius = data.shadow.radius;\n\t\t\tif ( data.shadow.mapSize !== undefined ) object.shadow.mapSize.fromArray( data.shadow.mapSize );\n\t\t\tif ( data.shadow.camera !== undefined ) object.shadow.camera = this.parseObject( data.shadow.camera );\n\n\t\t}\n\n\t\tif ( data.visible !== undefined ) object.visible = data.visible;\n\t\tif ( data.frustumCulled !== undefined ) object.frustumCulled = data.frustumCulled;\n\t\tif ( data.renderOrder !== undefined ) object.renderOrder = data.renderOrder;\n\t\tif ( data.userData !== undefined ) object.userData = data.userData;\n\t\tif ( data.layers !== undefined ) object.layers.mask = data.layers;\n\n\t\tif ( data.children !== undefined ) {\n\n\t\t\tconst children = data.children;\n\n\t\t\tfor ( let i = 0; i < children.length; i ++ ) {\n\n\t\t\t\tobject.add( this.parseObject( children[ i ], geometries, materials, textures, animations ) );\n\n\t\t\t}\n\n\t\t}\n\n\t\tif ( data.animations !== undefined ) {\n\n\t\t\tconst objectAnimations = data.animations;\n\n\t\t\tfor ( let i = 0; i < objectAnimations.length; i ++ ) {\n\n\t\t\t\tconst uuid = objectAnimations[ i ];\n\n\t\t\t\tobject.animations.push( animations[ uuid ] );\n\n\t\t\t}\n\n\t\t}\n\n\t\tif ( data.type === 'LOD' ) {\n\n\t\t\tif ( data.autoUpdate !== undefined ) object.autoUpdate = data.autoUpdate;\n\n\t\t\tconst levels = data.levels;\n\n\t\t\tfor ( let l = 0; l < levels.length; l ++ ) {\n\n\t\t\t\tconst level = levels[ l ];\n\t\t\t\tconst child = object.getObjectByProperty( 'uuid', level.object );\n\n\t\t\t\tif ( child !== undefined ) {\n\n\t\t\t\t\tobject.addLevel( child, level.distance, level.hysteresis );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn object;\n\n\t}\n\n\tbindSkeletons( object, skeletons ) {\n\n\t\tif ( Object.keys( skeletons ).length === 0 ) return;\n\n\t\tobject.traverse( function ( child ) {\n\n\t\t\tif ( child.isSkinnedMesh === true && child.skeleton !== undefined ) {\n\n\t\t\t\tconst skeleton = skeletons[ child.skeleton ];\n\n\t\t\t\tif ( skeleton === undefined ) {\n\n\t\t\t\t\tconsole.warn( 'THREE.ObjectLoader: No skeleton found with UUID:', child.skeleton );\n\n\t\t\t\t} else {\n\n\t\t\t\t\tchild.bind( skeleton, child.bindMatrix );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t} );\n\n\t}\n\n}\n\nconst TEXTURE_MAPPING = {\n\tUVMapping: UVMapping,\n\tCubeReflectionMapping: CubeReflectionMapping,\n\tCubeRefractionMapping: CubeRefractionMapping,\n\tEquirectangularReflectionMapping: EquirectangularReflectionMapping,\n\tEquirectangularRefractionMapping: EquirectangularRefractionMapping,\n\tCubeUVReflectionMapping: CubeUVReflectionMapping\n};\n\nconst TEXTURE_WRAPPING = {\n\tRepeatWrapping: RepeatWrapping,\n\tClampToEdgeWrapping: ClampToEdgeWrapping,\n\tMirroredRepeatWrapping: MirroredRepeatWrapping\n};\n\nconst TEXTURE_FILTER = {\n\tNearestFilter: NearestFilter,\n\tNearestMipmapNearestFilter: NearestMipmapNearestFilter,\n\tNearestMipmapLinearFilter: NearestMipmapLinearFilter,\n\tLinearFilter: LinearFilter,\n\tLinearMipmapNearestFilter: LinearMipmapNearestFilter,\n\tLinearMipmapLinearFilter: LinearMipmapLinearFilter\n};\n\nclass ImageBitmapLoader extends Loader {\n\n\tconstructor( manager ) {\n\n\t\tsuper( manager );\n\n\t\tthis.isImageBitmapLoader = true;\n\n\t\tif ( typeof createImageBitmap === 'undefined' ) {\n\n\t\t\tconsole.warn( 'THREE.ImageBitmapLoader: createImageBitmap() not supported.' );\n\n\t\t}\n\n\t\tif ( typeof fetch === 'undefined' ) {\n\n\t\t\tconsole.warn( 'THREE.ImageBitmapLoader: fetch() not supported.' );\n\n\t\t}\n\n\t\tthis.options = { premultiplyAlpha: 'none' };\n\n\t}\n\n\tsetOptions( options ) {\n\n\t\tthis.options = options;\n\n\t\treturn this;\n\n\t}\n\n\tload( url, onLoad, onProgress, onError ) {\n\n\t\tif ( url === undefined ) url = '';\n\n\t\tif ( this.path !== undefined ) url = this.path + url;\n\n\t\turl = this.manager.resolveURL( url );\n\n\t\tconst scope = this;\n\n\t\tconst cached = Cache.get( url );\n\n\t\tif ( cached !== undefined ) {\n\n\t\t\tscope.manager.itemStart( url );\n\n\t\t\t// If cached is a promise, wait for it to resolve\n\t\t\tif ( cached.then ) {\n\n\t\t\t\tcached.then( imageBitmap => {\n\n\t\t\t\t\tif ( onLoad ) onLoad( imageBitmap );\n\n\t\t\t\t\tscope.manager.itemEnd( url );\n\n\t\t\t\t} ).catch( e => {\n\n\t\t\t\t\tif ( onError ) onError( e );\n\n\t\t\t\t} );\n\t\t\t\treturn;\n\n\t\t\t}\n\n\t\t\t// If cached is not a promise (i.e., it's already an imageBitmap)\n\t\t\tsetTimeout( function () {\n\n\t\t\t\tif ( onLoad ) onLoad( cached );\n\n\t\t\t\tscope.manager.itemEnd( url );\n\n\t\t\t}, 0 );\n\n\t\t\treturn cached;\n\n\t\t}\n\n\t\tconst fetchOptions = {};\n\t\tfetchOptions.credentials = ( this.crossOrigin === 'anonymous' ) ? 'same-origin' : 'include';\n\t\tfetchOptions.headers = this.requestHeader;\n\n\t\tconst promise = fetch( url, fetchOptions ).then( function ( res ) {\n\n\t\t\treturn res.blob();\n\n\t\t} ).then( function ( blob ) {\n\n\t\t\treturn createImageBitmap( blob, Object.assign( scope.options, { colorSpaceConversion: 'none' } ) );\n\n\t\t} ).then( function ( imageBitmap ) {\n\n\t\t\tCache.add( url, imageBitmap );\n\n\t\t\tif ( onLoad ) onLoad( imageBitmap );\n\n\t\t\tscope.manager.itemEnd( url );\n\n\t\t\treturn imageBitmap;\n\n\t\t} ).catch( function ( e ) {\n\n\t\t\tif ( onError ) onError( e );\n\n\t\t\tCache.remove( url );\n\n\t\t\tscope.manager.itemError( url );\n\t\t\tscope.manager.itemEnd( url );\n\n\t\t} );\n\n\t\tCache.add( url, promise );\n\t\tscope.manager.itemStart( url );\n\n\t}\n\n}\n\nlet _context;\n\nclass AudioContext {\n\n\tstatic getContext() {\n\n\t\tif ( _context === undefined ) {\n\n\t\t\t_context = new ( window.AudioContext || window.webkitAudioContext )();\n\n\t\t}\n\n\t\treturn _context;\n\n\t}\n\n\tstatic setContext( value ) {\n\n\t\t_context = value;\n\n\t}\n\n}\n\nclass AudioLoader extends Loader {\n\n\tconstructor( manager ) {\n\n\t\tsuper( manager );\n\n\t}\n\n\tload( url, onLoad, onProgress, onError ) {\n\n\t\tconst scope = this;\n\n\t\tconst loader = new FileLoader( this.manager );\n\t\tloader.setResponseType( 'arraybuffer' );\n\t\tloader.setPath( this.path );\n\t\tloader.setRequestHeader( this.requestHeader );\n\t\tloader.setWithCredentials( this.withCredentials );\n\t\tloader.load( url, function ( buffer ) {\n\n\t\t\ttry {\n\n\t\t\t\t// Create a copy of the buffer. The `decodeAudioData` method\n\t\t\t\t// detaches the buffer when complete, preventing reuse.\n\t\t\t\tconst bufferCopy = buffer.slice( 0 );\n\n\t\t\t\tconst context = AudioContext.getContext();\n\t\t\t\tcontext.decodeAudioData( bufferCopy, function ( audioBuffer ) {\n\n\t\t\t\t\tonLoad( audioBuffer );\n\n\t\t\t\t} ).catch( handleError );\n\n\t\t\t} catch ( e ) {\n\n\t\t\t\thandleError( e );\n\n\t\t\t}\n\n\t\t}, onProgress, onError );\n\n\t\tfunction handleError( e ) {\n\n\t\t\tif ( onError ) {\n\n\t\t\t\tonError( e );\n\n\t\t\t} else {\n\n\t\t\t\tconsole.error( e );\n\n\t\t\t}\n\n\t\t\tscope.manager.itemError( url );\n\n\t\t}\n\n\t}\n\n}\n\nconst _eyeRight = /*@__PURE__*/ new Matrix4();\nconst _eyeLeft = /*@__PURE__*/ new Matrix4();\nconst _projectionMatrix = /*@__PURE__*/ new Matrix4();\n\nclass StereoCamera {\n\n\tconstructor() {\n\n\t\tthis.type = 'StereoCamera';\n\n\t\tthis.aspect = 1;\n\n\t\tthis.eyeSep = 0.064;\n\n\t\tthis.cameraL = new PerspectiveCamera();\n\t\tthis.cameraL.layers.enable( 1 );\n\t\tthis.cameraL.matrixAutoUpdate = false;\n\n\t\tthis.cameraR = new PerspectiveCamera();\n\t\tthis.cameraR.layers.enable( 2 );\n\t\tthis.cameraR.matrixAutoUpdate = false;\n\n\t\tthis._cache = {\n\t\t\tfocus: null,\n\t\t\tfov: null,\n\t\t\taspect: null,\n\t\t\tnear: null,\n\t\t\tfar: null,\n\t\t\tzoom: null,\n\t\t\teyeSep: null\n\t\t};\n\n\t}\n\n\tupdate( camera ) {\n\n\t\tconst cache = this._cache;\n\n\t\tconst needsUpdate = cache.focus !== camera.focus || cache.fov !== camera.fov ||\n\t\t\tcache.aspect !== camera.aspect * this.aspect || cache.near !== camera.near ||\n\t\t\tcache.far !== camera.far || cache.zoom !== camera.zoom || cache.eyeSep !== this.eyeSep;\n\n\t\tif ( needsUpdate ) {\n\n\t\t\tcache.focus = camera.focus;\n\t\t\tcache.fov = camera.fov;\n\t\t\tcache.aspect = camera.aspect * this.aspect;\n\t\t\tcache.near = camera.near;\n\t\t\tcache.far = camera.far;\n\t\t\tcache.zoom = camera.zoom;\n\t\t\tcache.eyeSep = this.eyeSep;\n\n\t\t\t// Off-axis stereoscopic effect based on\n\t\t\t// http://paulbourke.net/stereographics/stereorender/\n\n\t\t\t_projectionMatrix.copy( camera.projectionMatrix );\n\t\t\tconst eyeSepHalf = cache.eyeSep / 2;\n\t\t\tconst eyeSepOnProjection = eyeSepHalf * cache.near / cache.focus;\n\t\t\tconst ymax = ( cache.near * Math.tan( DEG2RAD * cache.fov * 0.5 ) ) / cache.zoom;\n\t\t\tlet xmin, xmax;\n\n\t\t\t// translate xOffset\n\n\t\t\t_eyeLeft.elements[ 12 ] = - eyeSepHalf;\n\t\t\t_eyeRight.elements[ 12 ] = eyeSepHalf;\n\n\t\t\t// for left eye\n\n\t\t\txmin = - ymax * cache.aspect + eyeSepOnProjection;\n\t\t\txmax = ymax * cache.aspect + eyeSepOnProjection;\n\n\t\t\t_projectionMatrix.elements[ 0 ] = 2 * cache.near / ( xmax - xmin );\n\t\t\t_projectionMatrix.elements[ 8 ] = ( xmax + xmin ) / ( xmax - xmin );\n\n\t\t\tthis.cameraL.projectionMatrix.copy( _projectionMatrix );\n\n\t\t\t// for right eye\n\n\t\t\txmin = - ymax * cache.aspect - eyeSepOnProjection;\n\t\t\txmax = ymax * cache.aspect - eyeSepOnProjection;\n\n\t\t\t_projectionMatrix.elements[ 0 ] = 2 * cache.near / ( xmax - xmin );\n\t\t\t_projectionMatrix.elements[ 8 ] = ( xmax + xmin ) / ( xmax - xmin );\n\n\t\t\tthis.cameraR.projectionMatrix.copy( _projectionMatrix );\n\n\t\t}\n\n\t\tthis.cameraL.matrixWorld.copy( camera.matrixWorld ).multiply( _eyeLeft );\n\t\tthis.cameraR.matrixWorld.copy( camera.matrixWorld ).multiply( _eyeRight );\n\n\t}\n\n}\n\nclass Clock {\n\n\tconstructor( autoStart = true ) {\n\n\t\tthis.autoStart = autoStart;\n\n\t\tthis.startTime = 0;\n\t\tthis.oldTime = 0;\n\t\tthis.elapsedTime = 0;\n\n\t\tthis.running = false;\n\n\t}\n\n\tstart() {\n\n\t\tthis.startTime = now();\n\n\t\tthis.oldTime = this.startTime;\n\t\tthis.elapsedTime = 0;\n\t\tthis.running = true;\n\n\t}\n\n\tstop() {\n\n\t\tthis.getElapsedTime();\n\t\tthis.running = false;\n\t\tthis.autoStart = false;\n\n\t}\n\n\tgetElapsedTime() {\n\n\t\tthis.getDelta();\n\t\treturn this.elapsedTime;\n\n\t}\n\n\tgetDelta() {\n\n\t\tlet diff = 0;\n\n\t\tif ( this.autoStart && ! this.running ) {\n\n\t\t\tthis.start();\n\t\t\treturn 0;\n\n\t\t}\n\n\t\tif ( this.running ) {\n\n\t\t\tconst newTime = now();\n\n\t\t\tdiff = ( newTime - this.oldTime ) / 1000;\n\t\t\tthis.oldTime = newTime;\n\n\t\t\tthis.elapsedTime += diff;\n\n\t\t}\n\n\t\treturn diff;\n\n\t}\n\n}\n\nfunction now() {\n\n\treturn ( typeof performance === 'undefined' ? Date : performance ).now(); // see #10732\n\n}\n\nconst _position$1 = /*@__PURE__*/ new Vector3();\nconst _quaternion$1 = /*@__PURE__*/ new Quaternion();\nconst _scale$1 = /*@__PURE__*/ new Vector3();\nconst _orientation$1 = /*@__PURE__*/ new Vector3();\n\nclass AudioListener extends Object3D {\n\n\tconstructor() {\n\n\t\tsuper();\n\n\t\tthis.type = 'AudioListener';\n\n\t\tthis.context = AudioContext.getContext();\n\n\t\tthis.gain = this.context.createGain();\n\t\tthis.gain.connect( this.context.destination );\n\n\t\tthis.filter = null;\n\n\t\tthis.timeDelta = 0;\n\n\t\t// private\n\n\t\tthis._clock = new Clock();\n\n\t}\n\n\tgetInput() {\n\n\t\treturn this.gain;\n\n\t}\n\n\tremoveFilter() {\n\n\t\tif ( this.filter !== null ) {\n\n\t\t\tthis.gain.disconnect( this.filter );\n\t\t\tthis.filter.disconnect( this.context.destination );\n\t\t\tthis.gain.connect( this.context.destination );\n\t\t\tthis.filter = null;\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tgetFilter() {\n\n\t\treturn this.filter;\n\n\t}\n\n\tsetFilter( value ) {\n\n\t\tif ( this.filter !== null ) {\n\n\t\t\tthis.gain.disconnect( this.filter );\n\t\t\tthis.filter.disconnect( this.context.destination );\n\n\t\t} else {\n\n\t\t\tthis.gain.disconnect( this.context.destination );\n\n\t\t}\n\n\t\tthis.filter = value;\n\t\tthis.gain.connect( this.filter );\n\t\tthis.filter.connect( this.context.destination );\n\n\t\treturn this;\n\n\t}\n\n\tgetMasterVolume() {\n\n\t\treturn this.gain.gain.value;\n\n\t}\n\n\tsetMasterVolume( value ) {\n\n\t\tthis.gain.gain.setTargetAtTime( value, this.context.currentTime, 0.01 );\n\n\t\treturn this;\n\n\t}\n\n\tupdateMatrixWorld( force ) {\n\n\t\tsuper.updateMatrixWorld( force );\n\n\t\tconst listener = this.context.listener;\n\t\tconst up = this.up;\n\n\t\tthis.timeDelta = this._clock.getDelta();\n\n\t\tthis.matrixWorld.decompose( _position$1, _quaternion$1, _scale$1 );\n\n\t\t_orientation$1.set( 0, 0, - 1 ).applyQuaternion( _quaternion$1 );\n\n\t\tif ( listener.positionX ) {\n\n\t\t\t// code path for Chrome (see #14393)\n\n\t\t\tconst endTime = this.context.currentTime + this.timeDelta;\n\n\t\t\tlistener.positionX.linearRampToValueAtTime( _position$1.x, endTime );\n\t\t\tlistener.positionY.linearRampToValueAtTime( _position$1.y, endTime );\n\t\t\tlistener.positionZ.linearRampToValueAtTime( _position$1.z, endTime );\n\t\t\tlistener.forwardX.linearRampToValueAtTime( _orientation$1.x, endTime );\n\t\t\tlistener.forwardY.linearRampToValueAtTime( _orientation$1.y, endTime );\n\t\t\tlistener.forwardZ.linearRampToValueAtTime( _orientation$1.z, endTime );\n\t\t\tlistener.upX.linearRampToValueAtTime( up.x, endTime );\n\t\t\tlistener.upY.linearRampToValueAtTime( up.y, endTime );\n\t\t\tlistener.upZ.linearRampToValueAtTime( up.z, endTime );\n\n\t\t} else {\n\n\t\t\tlistener.setPosition( _position$1.x, _position$1.y, _position$1.z );\n\t\t\tlistener.setOrientation( _orientation$1.x, _orientation$1.y, _orientation$1.z, up.x, up.y, up.z );\n\n\t\t}\n\n\t}\n\n}\n\nclass Audio extends Object3D {\n\n\tconstructor( listener ) {\n\n\t\tsuper();\n\n\t\tthis.type = 'Audio';\n\n\t\tthis.listener = listener;\n\t\tthis.context = listener.context;\n\n\t\tthis.gain = this.context.createGain();\n\t\tthis.gain.connect( listener.getInput() );\n\n\t\tthis.autoplay = false;\n\n\t\tthis.buffer = null;\n\t\tthis.detune = 0;\n\t\tthis.loop = false;\n\t\tthis.loopStart = 0;\n\t\tthis.loopEnd = 0;\n\t\tthis.offset = 0;\n\t\tthis.duration = undefined;\n\t\tthis.playbackRate = 1;\n\t\tthis.isPlaying = false;\n\t\tthis.hasPlaybackControl = true;\n\t\tthis.source = null;\n\t\tthis.sourceType = 'empty';\n\n\t\tthis._startedAt = 0;\n\t\tthis._progress = 0;\n\t\tthis._connected = false;\n\n\t\tthis.filters = [];\n\n\t}\n\n\tgetOutput() {\n\n\t\treturn this.gain;\n\n\t}\n\n\tsetNodeSource( audioNode ) {\n\n\t\tthis.hasPlaybackControl = false;\n\t\tthis.sourceType = 'audioNode';\n\t\tthis.source = audioNode;\n\t\tthis.connect();\n\n\t\treturn this;\n\n\t}\n\n\tsetMediaElementSource( mediaElement ) {\n\n\t\tthis.hasPlaybackControl = false;\n\t\tthis.sourceType = 'mediaNode';\n\t\tthis.source = this.context.createMediaElementSource( mediaElement );\n\t\tthis.connect();\n\n\t\treturn this;\n\n\t}\n\n\tsetMediaStreamSource( mediaStream ) {\n\n\t\tthis.hasPlaybackControl = false;\n\t\tthis.sourceType = 'mediaStreamNode';\n\t\tthis.source = this.context.createMediaStreamSource( mediaStream );\n\t\tthis.connect();\n\n\t\treturn this;\n\n\t}\n\n\tsetBuffer( audioBuffer ) {\n\n\t\tthis.buffer = audioBuffer;\n\t\tthis.sourceType = 'buffer';\n\n\t\tif ( this.autoplay ) this.play();\n\n\t\treturn this;\n\n\t}\n\n\tplay( delay = 0 ) {\n\n\t\tif ( this.isPlaying === true ) {\n\n\t\t\tconsole.warn( 'THREE.Audio: Audio is already playing.' );\n\t\t\treturn;\n\n\t\t}\n\n\t\tif ( this.hasPlaybackControl === false ) {\n\n\t\t\tconsole.warn( 'THREE.Audio: this Audio has no playback control.' );\n\t\t\treturn;\n\n\t\t}\n\n\t\tthis._startedAt = this.context.currentTime + delay;\n\n\t\tconst source = this.context.createBufferSource();\n\t\tsource.buffer = this.buffer;\n\t\tsource.loop = this.loop;\n\t\tsource.loopStart = this.loopStart;\n\t\tsource.loopEnd = this.loopEnd;\n\t\tsource.onended = this.onEnded.bind( this );\n\t\tsource.start( this._startedAt, this._progress + this.offset, this.duration );\n\n\t\tthis.isPlaying = true;\n\n\t\tthis.source = source;\n\n\t\tthis.setDetune( this.detune );\n\t\tthis.setPlaybackRate( this.playbackRate );\n\n\t\treturn this.connect();\n\n\t}\n\n\tpause() {\n\n\t\tif ( this.hasPlaybackControl === false ) {\n\n\t\t\tconsole.warn( 'THREE.Audio: this Audio has no playback control.' );\n\t\t\treturn;\n\n\t\t}\n\n\t\tif ( this.isPlaying === true ) {\n\n\t\t\t// update current progress\n\n\t\t\tthis._progress += Math.max( this.context.currentTime - this._startedAt, 0 ) * this.playbackRate;\n\n\t\t\tif ( this.loop === true ) {\n\n\t\t\t\t// ensure _progress does not exceed duration with looped audios\n\n\t\t\t\tthis._progress = this._progress % ( this.duration || this.buffer.duration );\n\n\t\t\t}\n\n\t\t\tthis.source.stop();\n\t\t\tthis.source.onended = null;\n\n\t\t\tthis.isPlaying = false;\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tstop() {\n\n\t\tif ( this.hasPlaybackControl === false ) {\n\n\t\t\tconsole.warn( 'THREE.Audio: this Audio has no playback control.' );\n\t\t\treturn;\n\n\t\t}\n\n\t\tthis._progress = 0;\n\n\t\tif ( this.source !== null ) {\n\n\t\t\tthis.source.stop();\n\t\t\tthis.source.onended = null;\n\n\t\t}\n\n\t\tthis.isPlaying = false;\n\n\t\treturn this;\n\n\t}\n\n\tconnect() {\n\n\t\tif ( this.filters.length > 0 ) {\n\n\t\t\tthis.source.connect( this.filters[ 0 ] );\n\n\t\t\tfor ( let i = 1, l = this.filters.length; i < l; i ++ ) {\n\n\t\t\t\tthis.filters[ i - 1 ].connect( this.filters[ i ] );\n\n\t\t\t}\n\n\t\t\tthis.filters[ this.filters.length - 1 ].connect( this.getOutput() );\n\n\t\t} else {\n\n\t\t\tthis.source.connect( this.getOutput() );\n\n\t\t}\n\n\t\tthis._connected = true;\n\n\t\treturn this;\n\n\t}\n\n\tdisconnect() {\n\n\t\tif ( this._connected === false ) {\n\n\t\t\treturn;\n\n\t\t}\n\n\t\tif ( this.filters.length > 0 ) {\n\n\t\t\tthis.source.disconnect( this.filters[ 0 ] );\n\n\t\t\tfor ( let i = 1, l = this.filters.length; i < l; i ++ ) {\n\n\t\t\t\tthis.filters[ i - 1 ].disconnect( this.filters[ i ] );\n\n\t\t\t}\n\n\t\t\tthis.filters[ this.filters.length - 1 ].disconnect( this.getOutput() );\n\n\t\t} else {\n\n\t\t\tthis.source.disconnect( this.getOutput() );\n\n\t\t}\n\n\t\tthis._connected = false;\n\n\t\treturn this;\n\n\t}\n\n\tgetFilters() {\n\n\t\treturn this.filters;\n\n\t}\n\n\tsetFilters( value ) {\n\n\t\tif ( ! value ) value = [];\n\n\t\tif ( this._connected === true ) {\n\n\t\t\tthis.disconnect();\n\t\t\tthis.filters = value.slice();\n\t\t\tthis.connect();\n\n\t\t} else {\n\n\t\t\tthis.filters = value.slice();\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tsetDetune( value ) {\n\n\t\tthis.detune = value;\n\n\t\tif ( this.isPlaying === true && this.source.detune !== undefined ) {\n\n\t\t\tthis.source.detune.setTargetAtTime( this.detune, this.context.currentTime, 0.01 );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tgetDetune() {\n\n\t\treturn this.detune;\n\n\t}\n\n\tgetFilter() {\n\n\t\treturn this.getFilters()[ 0 ];\n\n\t}\n\n\tsetFilter( filter ) {\n\n\t\treturn this.setFilters( filter ? [ filter ] : [] );\n\n\t}\n\n\tsetPlaybackRate( value ) {\n\n\t\tif ( this.hasPlaybackControl === false ) {\n\n\t\t\tconsole.warn( 'THREE.Audio: this Audio has no playback control.' );\n\t\t\treturn;\n\n\t\t}\n\n\t\tthis.playbackRate = value;\n\n\t\tif ( this.isPlaying === true ) {\n\n\t\t\tthis.source.playbackRate.setTargetAtTime( this.playbackRate, this.context.currentTime, 0.01 );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tgetPlaybackRate() {\n\n\t\treturn this.playbackRate;\n\n\t}\n\n\tonEnded() {\n\n\t\tthis.isPlaying = false;\n\n\t}\n\n\tgetLoop() {\n\n\t\tif ( this.hasPlaybackControl === false ) {\n\n\t\t\tconsole.warn( 'THREE.Audio: this Audio has no playback control.' );\n\t\t\treturn false;\n\n\t\t}\n\n\t\treturn this.loop;\n\n\t}\n\n\tsetLoop( value ) {\n\n\t\tif ( this.hasPlaybackControl === false ) {\n\n\t\t\tconsole.warn( 'THREE.Audio: this Audio has no playback control.' );\n\t\t\treturn;\n\n\t\t}\n\n\t\tthis.loop = value;\n\n\t\tif ( this.isPlaying === true ) {\n\n\t\t\tthis.source.loop = this.loop;\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tsetLoopStart( value ) {\n\n\t\tthis.loopStart = value;\n\n\t\treturn this;\n\n\t}\n\n\tsetLoopEnd( value ) {\n\n\t\tthis.loopEnd = value;\n\n\t\treturn this;\n\n\t}\n\n\tgetVolume() {\n\n\t\treturn this.gain.gain.value;\n\n\t}\n\n\tsetVolume( value ) {\n\n\t\tthis.gain.gain.setTargetAtTime( value, this.context.currentTime, 0.01 );\n\n\t\treturn this;\n\n\t}\n\n}\n\nconst _position = /*@__PURE__*/ new Vector3();\nconst _quaternion = /*@__PURE__*/ new Quaternion();\nconst _scale = /*@__PURE__*/ new Vector3();\nconst _orientation = /*@__PURE__*/ new Vector3();\n\nclass PositionalAudio extends Audio {\n\n\tconstructor( listener ) {\n\n\t\tsuper( listener );\n\n\t\tthis.panner = this.context.createPanner();\n\t\tthis.panner.panningModel = 'HRTF';\n\t\tthis.panner.connect( this.gain );\n\n\t}\n\n\tconnect() {\n\n\t\tsuper.connect();\n\n\t\tthis.panner.connect( this.gain );\n\n\t}\n\n\tdisconnect() {\n\n\t\tsuper.disconnect();\n\n\t\tthis.panner.disconnect( this.gain );\n\n\t}\n\n\tgetOutput() {\n\n\t\treturn this.panner;\n\n\t}\n\n\tgetRefDistance() {\n\n\t\treturn this.panner.refDistance;\n\n\t}\n\n\tsetRefDistance( value ) {\n\n\t\tthis.panner.refDistance = value;\n\n\t\treturn this;\n\n\t}\n\n\tgetRolloffFactor() {\n\n\t\treturn this.panner.rolloffFactor;\n\n\t}\n\n\tsetRolloffFactor( value ) {\n\n\t\tthis.panner.rolloffFactor = value;\n\n\t\treturn this;\n\n\t}\n\n\tgetDistanceModel() {\n\n\t\treturn this.panner.distanceModel;\n\n\t}\n\n\tsetDistanceModel( value ) {\n\n\t\tthis.panner.distanceModel = value;\n\n\t\treturn this;\n\n\t}\n\n\tgetMaxDistance() {\n\n\t\treturn this.panner.maxDistance;\n\n\t}\n\n\tsetMaxDistance( value ) {\n\n\t\tthis.panner.maxDistance = value;\n\n\t\treturn this;\n\n\t}\n\n\tsetDirectionalCone( coneInnerAngle, coneOuterAngle, coneOuterGain ) {\n\n\t\tthis.panner.coneInnerAngle = coneInnerAngle;\n\t\tthis.panner.coneOuterAngle = coneOuterAngle;\n\t\tthis.panner.coneOuterGain = coneOuterGain;\n\n\t\treturn this;\n\n\t}\n\n\tupdateMatrixWorld( force ) {\n\n\t\tsuper.updateMatrixWorld( force );\n\n\t\tif ( this.hasPlaybackControl === true && this.isPlaying === false ) return;\n\n\t\tthis.matrixWorld.decompose( _position, _quaternion, _scale );\n\n\t\t_orientation.set( 0, 0, 1 ).applyQuaternion( _quaternion );\n\n\t\tconst panner = this.panner;\n\n\t\tif ( panner.positionX ) {\n\n\t\t\t// code path for Chrome and Firefox (see #14393)\n\n\t\t\tconst endTime = this.context.currentTime + this.listener.timeDelta;\n\n\t\t\tpanner.positionX.linearRampToValueAtTime( _position.x, endTime );\n\t\t\tpanner.positionY.linearRampToValueAtTime( _position.y, endTime );\n\t\t\tpanner.positionZ.linearRampToValueAtTime( _position.z, endTime );\n\t\t\tpanner.orientationX.linearRampToValueAtTime( _orientation.x, endTime );\n\t\t\tpanner.orientationY.linearRampToValueAtTime( _orientation.y, endTime );\n\t\t\tpanner.orientationZ.linearRampToValueAtTime( _orientation.z, endTime );\n\n\t\t} else {\n\n\t\t\tpanner.setPosition( _position.x, _position.y, _position.z );\n\t\t\tpanner.setOrientation( _orientation.x, _orientation.y, _orientation.z );\n\n\t\t}\n\n\t}\n\n}\n\nclass AudioAnalyser {\n\n\tconstructor( audio, fftSize = 2048 ) {\n\n\t\tthis.analyser = audio.context.createAnalyser();\n\t\tthis.analyser.fftSize = fftSize;\n\n\t\tthis.data = new Uint8Array( this.analyser.frequencyBinCount );\n\n\t\taudio.getOutput().connect( this.analyser );\n\n\t}\n\n\n\tgetFrequencyData() {\n\n\t\tthis.analyser.getByteFrequencyData( this.data );\n\n\t\treturn this.data;\n\n\t}\n\n\tgetAverageFrequency() {\n\n\t\tlet value = 0;\n\t\tconst data = this.getFrequencyData();\n\n\t\tfor ( let i = 0; i < data.length; i ++ ) {\n\n\t\t\tvalue += data[ i ];\n\n\t\t}\n\n\t\treturn value / data.length;\n\n\t}\n\n}\n\nclass PropertyMixer {\n\n\tconstructor( binding, typeName, valueSize ) {\n\n\t\tthis.binding = binding;\n\t\tthis.valueSize = valueSize;\n\n\t\tlet mixFunction,\n\t\t\tmixFunctionAdditive,\n\t\t\tsetIdentity;\n\n\t\t// buffer layout: [ incoming | accu0 | accu1 | orig | addAccu | (optional work) ]\n\t\t//\n\t\t// interpolators can use .buffer as their .result\n\t\t// the data then goes to 'incoming'\n\t\t//\n\t\t// 'accu0' and 'accu1' are used frame-interleaved for\n\t\t// the cumulative result and are compared to detect\n\t\t// changes\n\t\t//\n\t\t// 'orig' stores the original state of the property\n\t\t//\n\t\t// 'add' is used for additive cumulative results\n\t\t//\n\t\t// 'work' is optional and is only present for quaternion types. It is used\n\t\t// to store intermediate quaternion multiplication results\n\n\t\tswitch ( typeName ) {\n\n\t\t\tcase 'quaternion':\n\t\t\t\tmixFunction = this._slerp;\n\t\t\t\tmixFunctionAdditive = this._slerpAdditive;\n\t\t\t\tsetIdentity = this._setAdditiveIdentityQuaternion;\n\n\t\t\t\tthis.buffer = new Float64Array( valueSize * 6 );\n\t\t\t\tthis._workIndex = 5;\n\t\t\t\tbreak;\n\n\t\t\tcase 'string':\n\t\t\tcase 'bool':\n\t\t\t\tmixFunction = this._select;\n\n\t\t\t\t// Use the regular mix function and for additive on these types,\n\t\t\t\t// additive is not relevant for non-numeric types\n\t\t\t\tmixFunctionAdditive = this._select;\n\n\t\t\t\tsetIdentity = this._setAdditiveIdentityOther;\n\n\t\t\t\tthis.buffer = new Array( valueSize * 5 );\n\t\t\t\tbreak;\n\n\t\t\tdefault:\n\t\t\t\tmixFunction = this._lerp;\n\t\t\t\tmixFunctionAdditive = this._lerpAdditive;\n\t\t\t\tsetIdentity = this._setAdditiveIdentityNumeric;\n\n\t\t\t\tthis.buffer = new Float64Array( valueSize * 5 );\n\n\t\t}\n\n\t\tthis._mixBufferRegion = mixFunction;\n\t\tthis._mixBufferRegionAdditive = mixFunctionAdditive;\n\t\tthis._setIdentity = setIdentity;\n\t\tthis._origIndex = 3;\n\t\tthis._addIndex = 4;\n\n\t\tthis.cumulativeWeight = 0;\n\t\tthis.cumulativeWeightAdditive = 0;\n\n\t\tthis.useCount = 0;\n\t\tthis.referenceCount = 0;\n\n\t}\n\n\t// accumulate data in the 'incoming' region into 'accu'\n\taccumulate( accuIndex, weight ) {\n\n\t\t// note: happily accumulating nothing when weight = 0, the caller knows\n\t\t// the weight and shouldn't have made the call in the first place\n\n\t\tconst buffer = this.buffer,\n\t\t\tstride = this.valueSize,\n\t\t\toffset = accuIndex * stride + stride;\n\n\t\tlet currentWeight = this.cumulativeWeight;\n\n\t\tif ( currentWeight === 0 ) {\n\n\t\t\t// accuN := incoming * weight\n\n\t\t\tfor ( let i = 0; i !== stride; ++ i ) {\n\n\t\t\t\tbuffer[ offset + i ] = buffer[ i ];\n\n\t\t\t}\n\n\t\t\tcurrentWeight = weight;\n\n\t\t} else {\n\n\t\t\t// accuN := accuN + incoming * weight\n\n\t\t\tcurrentWeight += weight;\n\t\t\tconst mix = weight / currentWeight;\n\t\t\tthis._mixBufferRegion( buffer, offset, 0, mix, stride );\n\n\t\t}\n\n\t\tthis.cumulativeWeight = currentWeight;\n\n\t}\n\n\t// accumulate data in the 'incoming' region into 'add'\n\taccumulateAdditive( weight ) {\n\n\t\tconst buffer = this.buffer,\n\t\t\tstride = this.valueSize,\n\t\t\toffset = stride * this._addIndex;\n\n\t\tif ( this.cumulativeWeightAdditive === 0 ) {\n\n\t\t\t// add = identity\n\n\t\t\tthis._setIdentity();\n\n\t\t}\n\n\t\t// add := add + incoming * weight\n\n\t\tthis._mixBufferRegionAdditive( buffer, offset, 0, weight, stride );\n\t\tthis.cumulativeWeightAdditive += weight;\n\n\t}\n\n\t// apply the state of 'accu' to the binding when accus differ\n\tapply( accuIndex ) {\n\n\t\tconst stride = this.valueSize,\n\t\t\tbuffer = this.buffer,\n\t\t\toffset = accuIndex * stride + stride,\n\n\t\t\tweight = this.cumulativeWeight,\n\t\t\tweightAdditive = this.cumulativeWeightAdditive,\n\n\t\t\tbinding = this.binding;\n\n\t\tthis.cumulativeWeight = 0;\n\t\tthis.cumulativeWeightAdditive = 0;\n\n\t\tif ( weight < 1 ) {\n\n\t\t\t// accuN := accuN + original * ( 1 - cumulativeWeight )\n\n\t\t\tconst originalValueOffset = stride * this._origIndex;\n\n\t\t\tthis._mixBufferRegion(\n\t\t\t\tbuffer, offset, originalValueOffset, 1 - weight, stride );\n\n\t\t}\n\n\t\tif ( weightAdditive > 0 ) {\n\n\t\t\t// accuN := accuN + additive accuN\n\n\t\t\tthis._mixBufferRegionAdditive( buffer, offset, this._addIndex * stride, 1, stride );\n\n\t\t}\n\n\t\tfor ( let i = stride, e = stride + stride; i !== e; ++ i ) {\n\n\t\t\tif ( buffer[ i ] !== buffer[ i + stride ] ) {\n\n\t\t\t\t// value has changed -> update scene graph\n\n\t\t\t\tbinding.setValue( buffer, offset );\n\t\t\t\tbreak;\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n\t// remember the state of the bound property and copy it to both accus\n\tsaveOriginalState() {\n\n\t\tconst binding = this.binding;\n\n\t\tconst buffer = this.buffer,\n\t\t\tstride = this.valueSize,\n\n\t\t\toriginalValueOffset = stride * this._origIndex;\n\n\t\tbinding.getValue( buffer, originalValueOffset );\n\n\t\t// accu[0..1] := orig -- initially detect changes against the original\n\t\tfor ( let i = stride, e = originalValueOffset; i !== e; ++ i ) {\n\n\t\t\tbuffer[ i ] = buffer[ originalValueOffset + ( i % stride ) ];\n\n\t\t}\n\n\t\t// Add to identity for additive\n\t\tthis._setIdentity();\n\n\t\tthis.cumulativeWeight = 0;\n\t\tthis.cumulativeWeightAdditive = 0;\n\n\t}\n\n\t// apply the state previously taken via 'saveOriginalState' to the binding\n\trestoreOriginalState() {\n\n\t\tconst originalValueOffset = this.valueSize * 3;\n\t\tthis.binding.setValue( this.buffer, originalValueOffset );\n\n\t}\n\n\t_setAdditiveIdentityNumeric() {\n\n\t\tconst startIndex = this._addIndex * this.valueSize;\n\t\tconst endIndex = startIndex + this.valueSize;\n\n\t\tfor ( let i = startIndex; i < endIndex; i ++ ) {\n\n\t\t\tthis.buffer[ i ] = 0;\n\n\t\t}\n\n\t}\n\n\t_setAdditiveIdentityQuaternion() {\n\n\t\tthis._setAdditiveIdentityNumeric();\n\t\tthis.buffer[ this._addIndex * this.valueSize + 3 ] = 1;\n\n\t}\n\n\t_setAdditiveIdentityOther() {\n\n\t\tconst startIndex = this._origIndex * this.valueSize;\n\t\tconst targetIndex = this._addIndex * this.valueSize;\n\n\t\tfor ( let i = 0; i < this.valueSize; i ++ ) {\n\n\t\t\tthis.buffer[ targetIndex + i ] = this.buffer[ startIndex + i ];\n\n\t\t}\n\n\t}\n\n\n\t// mix functions\n\n\t_select( buffer, dstOffset, srcOffset, t, stride ) {\n\n\t\tif ( t >= 0.5 ) {\n\n\t\t\tfor ( let i = 0; i !== stride; ++ i ) {\n\n\t\t\t\tbuffer[ dstOffset + i ] = buffer[ srcOffset + i ];\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n\t_slerp( buffer, dstOffset, srcOffset, t ) {\n\n\t\tQuaternion.slerpFlat( buffer, dstOffset, buffer, dstOffset, buffer, srcOffset, t );\n\n\t}\n\n\t_slerpAdditive( buffer, dstOffset, srcOffset, t, stride ) {\n\n\t\tconst workOffset = this._workIndex * stride;\n\n\t\t// Store result in intermediate buffer offset\n\t\tQuaternion.multiplyQuaternionsFlat( buffer, workOffset, buffer, dstOffset, buffer, srcOffset );\n\n\t\t// Slerp to the intermediate result\n\t\tQuaternion.slerpFlat( buffer, dstOffset, buffer, dstOffset, buffer, workOffset, t );\n\n\t}\n\n\t_lerp( buffer, dstOffset, srcOffset, t, stride ) {\n\n\t\tconst s = 1 - t;\n\n\t\tfor ( let i = 0; i !== stride; ++ i ) {\n\n\t\t\tconst j = dstOffset + i;\n\n\t\t\tbuffer[ j ] = buffer[ j ] * s + buffer[ srcOffset + i ] * t;\n\n\t\t}\n\n\t}\n\n\t_lerpAdditive( buffer, dstOffset, srcOffset, t, stride ) {\n\n\t\tfor ( let i = 0; i !== stride; ++ i ) {\n\n\t\t\tconst j = dstOffset + i;\n\n\t\t\tbuffer[ j ] = buffer[ j ] + buffer[ srcOffset + i ] * t;\n\n\t\t}\n\n\t}\n\n}\n\n// Characters [].:/ are reserved for track binding syntax.\nconst _RESERVED_CHARS_RE = '\\\\[\\\\]\\\\.:\\\\/';\nconst _reservedRe = new RegExp( '[' + _RESERVED_CHARS_RE + ']', 'g' );\n\n// Attempts to allow node names from any language. ES5's `\\w` regexp matches\n// only latin characters, and the unicode \\p{L} is not yet supported. So\n// instead, we exclude reserved characters and match everything else.\nconst _wordChar = '[^' + _RESERVED_CHARS_RE + ']';\nconst _wordCharOrDot = '[^' + _RESERVED_CHARS_RE.replace( '\\\\.', '' ) + ']';\n\n// Parent directories, delimited by '/' or ':'. Currently unused, but must\n// be matched to parse the rest of the track name.\nconst _directoryRe = /*@__PURE__*/ /((?:WC+[\\/:])*)/.source.replace( 'WC', _wordChar );\n\n// Target node. May contain word characters (a-zA-Z0-9_) and '.' or '-'.\nconst _nodeRe = /*@__PURE__*/ /(WCOD+)?/.source.replace( 'WCOD', _wordCharOrDot );\n\n// Object on target node, and accessor. May not contain reserved\n// characters. Accessor may contain any character except closing bracket.\nconst _objectRe = /*@__PURE__*/ /(?:\\.(WC+)(?:\\[(.+)\\])?)?/.source.replace( 'WC', _wordChar );\n\n// Property and accessor. May not contain reserved characters. Accessor may\n// contain any non-bracket characters.\nconst _propertyRe = /*@__PURE__*/ /\\.(WC+)(?:\\[(.+)\\])?/.source.replace( 'WC', _wordChar );\n\nconst _trackRe = new RegExp( ''\n\t+ '^'\n\t+ _directoryRe\n\t+ _nodeRe\n\t+ _objectRe\n\t+ _propertyRe\n\t+ '$'\n);\n\nconst _supportedObjectNames = [ 'material', 'materials', 'bones', 'map' ];\n\nclass Composite {\n\n\tconstructor( targetGroup, path, optionalParsedPath ) {\n\n\t\tconst parsedPath = optionalParsedPath || PropertyBinding.parseTrackName( path );\n\n\t\tthis._targetGroup = targetGroup;\n\t\tthis._bindings = targetGroup.subscribe_( path, parsedPath );\n\n\t}\n\n\tgetValue( array, offset ) {\n\n\t\tthis.bind(); // bind all binding\n\n\t\tconst firstValidIndex = this._targetGroup.nCachedObjects_,\n\t\t\tbinding = this._bindings[ firstValidIndex ];\n\n\t\t// and only call .getValue on the first\n\t\tif ( binding !== undefined ) binding.getValue( array, offset );\n\n\t}\n\n\tsetValue( array, offset ) {\n\n\t\tconst bindings = this._bindings;\n\n\t\tfor ( let i = this._targetGroup.nCachedObjects_, n = bindings.length; i !== n; ++ i ) {\n\n\t\t\tbindings[ i ].setValue( array, offset );\n\n\t\t}\n\n\t}\n\n\tbind() {\n\n\t\tconst bindings = this._bindings;\n\n\t\tfor ( let i = this._targetGroup.nCachedObjects_, n = bindings.length; i !== n; ++ i ) {\n\n\t\t\tbindings[ i ].bind();\n\n\t\t}\n\n\t}\n\n\tunbind() {\n\n\t\tconst bindings = this._bindings;\n\n\t\tfor ( let i = this._targetGroup.nCachedObjects_, n = bindings.length; i !== n; ++ i ) {\n\n\t\t\tbindings[ i ].unbind();\n\n\t\t}\n\n\t}\n\n}\n\n// Note: This class uses a State pattern on a per-method basis:\n// 'bind' sets 'this.getValue' / 'setValue' and shadows the\n// prototype version of these methods with one that represents\n// the bound state. When the property is not found, the methods\n// become no-ops.\nclass PropertyBinding {\n\n\tconstructor( rootNode, path, parsedPath ) {\n\n\t\tthis.path = path;\n\t\tthis.parsedPath = parsedPath || PropertyBinding.parseTrackName( path );\n\n\t\tthis.node = PropertyBinding.findNode( rootNode, this.parsedPath.nodeName );\n\n\t\tthis.rootNode = rootNode;\n\n\t\t// initial state of these methods that calls 'bind'\n\t\tthis.getValue = this._getValue_unbound;\n\t\tthis.setValue = this._setValue_unbound;\n\n\t}\n\n\n\tstatic create( root, path, parsedPath ) {\n\n\t\tif ( ! ( root && root.isAnimationObjectGroup ) ) {\n\n\t\t\treturn new PropertyBinding( root, path, parsedPath );\n\n\t\t} else {\n\n\t\t\treturn new PropertyBinding.Composite( root, path, parsedPath );\n\n\t\t}\n\n\t}\n\n\t/**\n\t * Replaces spaces with underscores and removes unsupported characters from\n\t * node names, to ensure compatibility with parseTrackName().\n\t *\n\t * @param {string} name Node name to be sanitized.\n\t * @return {string}\n\t */\n\tstatic sanitizeNodeName( name ) {\n\n\t\treturn name.replace( /\\s/g, '_' ).replace( _reservedRe, '' );\n\n\t}\n\n\tstatic parseTrackName( trackName ) {\n\n\t\tconst matches = _trackRe.exec( trackName );\n\n\t\tif ( matches === null ) {\n\n\t\t\tthrow new Error( 'PropertyBinding: Cannot parse trackName: ' + trackName );\n\n\t\t}\n\n\t\tconst results = {\n\t\t\t// directoryName: matches[ 1 ], // (tschw) currently unused\n\t\t\tnodeName: matches[ 2 ],\n\t\t\tobjectName: matches[ 3 ],\n\t\t\tobjectIndex: matches[ 4 ],\n\t\t\tpropertyName: matches[ 5 ], // required\n\t\t\tpropertyIndex: matches[ 6 ]\n\t\t};\n\n\t\tconst lastDot = results.nodeName && results.nodeName.lastIndexOf( '.' );\n\n\t\tif ( lastDot !== undefined && lastDot !== - 1 ) {\n\n\t\t\tconst objectName = results.nodeName.substring( lastDot + 1 );\n\n\t\t\t// Object names must be checked against an allowlist. Otherwise, there\n\t\t\t// is no way to parse 'foo.bar.baz': 'baz' must be a property, but\n\t\t\t// 'bar' could be the objectName, or part of a nodeName (which can\n\t\t\t// include '.' characters).\n\t\t\tif ( _supportedObjectNames.indexOf( objectName ) !== - 1 ) {\n\n\t\t\t\tresults.nodeName = results.nodeName.substring( 0, lastDot );\n\t\t\t\tresults.objectName = objectName;\n\n\t\t\t}\n\n\t\t}\n\n\t\tif ( results.propertyName === null || results.propertyName.length === 0 ) {\n\n\t\t\tthrow new Error( 'PropertyBinding: can not parse propertyName from trackName: ' + trackName );\n\n\t\t}\n\n\t\treturn results;\n\n\t}\n\n\tstatic findNode( root, nodeName ) {\n\n\t\tif ( nodeName === undefined || nodeName === '' || nodeName === '.' || nodeName === - 1 || nodeName === root.name || nodeName === root.uuid ) {\n\n\t\t\treturn root;\n\n\t\t}\n\n\t\t// search into skeleton bones.\n\t\tif ( root.skeleton ) {\n\n\t\t\tconst bone = root.skeleton.getBoneByName( nodeName );\n\n\t\t\tif ( bone !== undefined ) {\n\n\t\t\t\treturn bone;\n\n\t\t\t}\n\n\t\t}\n\n\t\t// search into node subtree.\n\t\tif ( root.children ) {\n\n\t\t\tconst searchNodeSubtree = function ( children ) {\n\n\t\t\t\tfor ( let i = 0; i < children.length; i ++ ) {\n\n\t\t\t\t\tconst childNode = children[ i ];\n\n\t\t\t\t\tif ( childNode.name === nodeName || childNode.uuid === nodeName ) {\n\n\t\t\t\t\t\treturn childNode;\n\n\t\t\t\t\t}\n\n\t\t\t\t\tconst result = searchNodeSubtree( childNode.children );\n\n\t\t\t\t\tif ( result ) return result;\n\n\t\t\t\t}\n\n\t\t\t\treturn null;\n\n\t\t\t};\n\n\t\t\tconst subTreeNode = searchNodeSubtree( root.children );\n\n\t\t\tif ( subTreeNode ) {\n\n\t\t\t\treturn subTreeNode;\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn null;\n\n\t}\n\n\t// these are used to \"bind\" a nonexistent property\n\t_getValue_unavailable() {}\n\t_setValue_unavailable() {}\n\n\t// Getters\n\n\t_getValue_direct( buffer, offset ) {\n\n\t\tbuffer[ offset ] = this.targetObject[ this.propertyName ];\n\n\t}\n\n\t_getValue_array( buffer, offset ) {\n\n\t\tconst source = this.resolvedProperty;\n\n\t\tfor ( let i = 0, n = source.length; i !== n; ++ i ) {\n\n\t\t\tbuffer[ offset ++ ] = source[ i ];\n\n\t\t}\n\n\t}\n\n\t_getValue_arrayElement( buffer, offset ) {\n\n\t\tbuffer[ offset ] = this.resolvedProperty[ this.propertyIndex ];\n\n\t}\n\n\t_getValue_toArray( buffer, offset ) {\n\n\t\tthis.resolvedProperty.toArray( buffer, offset );\n\n\t}\n\n\t// Direct\n\n\t_setValue_direct( buffer, offset ) {\n\n\t\tthis.targetObject[ this.propertyName ] = buffer[ offset ];\n\n\t}\n\n\t_setValue_direct_setNeedsUpdate( buffer, offset ) {\n\n\t\tthis.targetObject[ this.propertyName ] = buffer[ offset ];\n\t\tthis.targetObject.needsUpdate = true;\n\n\t}\n\n\t_setValue_direct_setMatrixWorldNeedsUpdate( buffer, offset ) {\n\n\t\tthis.targetObject[ this.propertyName ] = buffer[ offset ];\n\t\tthis.targetObject.matrixWorldNeedsUpdate = true;\n\n\t}\n\n\t// EntireArray\n\n\t_setValue_array( buffer, offset ) {\n\n\t\tconst dest = this.resolvedProperty;\n\n\t\tfor ( let i = 0, n = dest.length; i !== n; ++ i ) {\n\n\t\t\tdest[ i ] = buffer[ offset ++ ];\n\n\t\t}\n\n\t}\n\n\t_setValue_array_setNeedsUpdate( buffer, offset ) {\n\n\t\tconst dest = this.resolvedProperty;\n\n\t\tfor ( let i = 0, n = dest.length; i !== n; ++ i ) {\n\n\t\t\tdest[ i ] = buffer[ offset ++ ];\n\n\t\t}\n\n\t\tthis.targetObject.needsUpdate = true;\n\n\t}\n\n\t_setValue_array_setMatrixWorldNeedsUpdate( buffer, offset ) {\n\n\t\tconst dest = this.resolvedProperty;\n\n\t\tfor ( let i = 0, n = dest.length; i !== n; ++ i ) {\n\n\t\t\tdest[ i ] = buffer[ offset ++ ];\n\n\t\t}\n\n\t\tthis.targetObject.matrixWorldNeedsUpdate = true;\n\n\t}\n\n\t// ArrayElement\n\n\t_setValue_arrayElement( buffer, offset ) {\n\n\t\tthis.resolvedProperty[ this.propertyIndex ] = buffer[ offset ];\n\n\t}\n\n\t_setValue_arrayElement_setNeedsUpdate( buffer, offset ) {\n\n\t\tthis.resolvedProperty[ this.propertyIndex ] = buffer[ offset ];\n\t\tthis.targetObject.needsUpdate = true;\n\n\t}\n\n\t_setValue_arrayElement_setMatrixWorldNeedsUpdate( buffer, offset ) {\n\n\t\tthis.resolvedProperty[ this.propertyIndex ] = buffer[ offset ];\n\t\tthis.targetObject.matrixWorldNeedsUpdate = true;\n\n\t}\n\n\t// HasToFromArray\n\n\t_setValue_fromArray( buffer, offset ) {\n\n\t\tthis.resolvedProperty.fromArray( buffer, offset );\n\n\t}\n\n\t_setValue_fromArray_setNeedsUpdate( buffer, offset ) {\n\n\t\tthis.resolvedProperty.fromArray( buffer, offset );\n\t\tthis.targetObject.needsUpdate = true;\n\n\t}\n\n\t_setValue_fromArray_setMatrixWorldNeedsUpdate( buffer, offset ) {\n\n\t\tthis.resolvedProperty.fromArray( buffer, offset );\n\t\tthis.targetObject.matrixWorldNeedsUpdate = true;\n\n\t}\n\n\t_getValue_unbound( targetArray, offset ) {\n\n\t\tthis.bind();\n\t\tthis.getValue( targetArray, offset );\n\n\t}\n\n\t_setValue_unbound( sourceArray, offset ) {\n\n\t\tthis.bind();\n\t\tthis.setValue( sourceArray, offset );\n\n\t}\n\n\t// create getter / setter pair for a property in the scene graph\n\tbind() {\n\n\t\tlet targetObject = this.node;\n\t\tconst parsedPath = this.parsedPath;\n\n\t\tconst objectName = parsedPath.objectName;\n\t\tconst propertyName = parsedPath.propertyName;\n\t\tlet propertyIndex = parsedPath.propertyIndex;\n\n\t\tif ( ! targetObject ) {\n\n\t\t\ttargetObject = PropertyBinding.findNode( this.rootNode, parsedPath.nodeName );\n\n\t\t\tthis.node = targetObject;\n\n\t\t}\n\n\t\t// set fail state so we can just 'return' on error\n\t\tthis.getValue = this._getValue_unavailable;\n\t\tthis.setValue = this._setValue_unavailable;\n\n\t\t// ensure there is a value node\n\t\tif ( ! targetObject ) {\n\n\t\t\tconsole.warn( 'THREE.PropertyBinding: No target node found for track: ' + this.path + '.' );\n\t\t\treturn;\n\n\t\t}\n\n\t\tif ( objectName ) {\n\n\t\t\tlet objectIndex = parsedPath.objectIndex;\n\n\t\t\t// special cases were we need to reach deeper into the hierarchy to get the face materials....\n\t\t\tswitch ( objectName ) {\n\n\t\t\t\tcase 'materials':\n\n\t\t\t\t\tif ( ! targetObject.material ) {\n\n\t\t\t\t\t\tconsole.error( 'THREE.PropertyBinding: Can not bind to material as node does not have a material.', this );\n\t\t\t\t\t\treturn;\n\n\t\t\t\t\t}\n\n\t\t\t\t\tif ( ! targetObject.material.materials ) {\n\n\t\t\t\t\t\tconsole.error( 'THREE.PropertyBinding: Can not bind to material.materials as node.material does not have a materials array.', this );\n\t\t\t\t\t\treturn;\n\n\t\t\t\t\t}\n\n\t\t\t\t\ttargetObject = targetObject.material.materials;\n\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase 'bones':\n\n\t\t\t\t\tif ( ! targetObject.skeleton ) {\n\n\t\t\t\t\t\tconsole.error( 'THREE.PropertyBinding: Can not bind to bones as node does not have a skeleton.', this );\n\t\t\t\t\t\treturn;\n\n\t\t\t\t\t}\n\n\t\t\t\t\t// potential future optimization: skip this if propertyIndex is already an integer\n\t\t\t\t\t// and convert the integer string to a true integer.\n\n\t\t\t\t\ttargetObject = targetObject.skeleton.bones;\n\n\t\t\t\t\t// support resolving morphTarget names into indices.\n\t\t\t\t\tfor ( let i = 0; i < targetObject.length; i ++ ) {\n\n\t\t\t\t\t\tif ( targetObject[ i ].name === objectIndex ) {\n\n\t\t\t\t\t\t\tobjectIndex = i;\n\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}\n\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase 'map':\n\n\t\t\t\t\tif ( 'map' in targetObject ) {\n\n\t\t\t\t\t\ttargetObject = targetObject.map;\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t}\n\n\t\t\t\t\tif ( ! targetObject.material ) {\n\n\t\t\t\t\t\tconsole.error( 'THREE.PropertyBinding: Can not bind to material as node does not have a material.', this );\n\t\t\t\t\t\treturn;\n\n\t\t\t\t\t}\n\n\t\t\t\t\tif ( ! targetObject.material.map ) {\n\n\t\t\t\t\t\tconsole.error( 'THREE.PropertyBinding: Can not bind to material.map as node.material does not have a map.', this );\n\t\t\t\t\t\treturn;\n\n\t\t\t\t\t}\n\n\t\t\t\t\ttargetObject = targetObject.material.map;\n\t\t\t\t\tbreak;\n\n\t\t\t\tdefault:\n\n\t\t\t\t\tif ( targetObject[ objectName ] === undefined ) {\n\n\t\t\t\t\t\tconsole.error( 'THREE.PropertyBinding: Can not bind to objectName of node undefined.', this );\n\t\t\t\t\t\treturn;\n\n\t\t\t\t\t}\n\n\t\t\t\t\ttargetObject = targetObject[ objectName ];\n\n\t\t\t}\n\n\n\t\t\tif ( objectIndex !== undefined ) {\n\n\t\t\t\tif ( targetObject[ objectIndex ] === undefined ) {\n\n\t\t\t\t\tconsole.error( 'THREE.PropertyBinding: Trying to bind to objectIndex of objectName, but is undefined.', this, targetObject );\n\t\t\t\t\treturn;\n\n\t\t\t\t}\n\n\t\t\t\ttargetObject = targetObject[ objectIndex ];\n\n\t\t\t}\n\n\t\t}\n\n\t\t// resolve property\n\t\tconst nodeProperty = targetObject[ propertyName ];\n\n\t\tif ( nodeProperty === undefined ) {\n\n\t\t\tconst nodeName = parsedPath.nodeName;\n\n\t\t\tconsole.error( 'THREE.PropertyBinding: Trying to update property for track: ' + nodeName +\n\t\t\t\t'.' + propertyName + ' but it wasn\\'t found.', targetObject );\n\t\t\treturn;\n\n\t\t}\n\n\t\t// determine versioning scheme\n\t\tlet versioning = this.Versioning.None;\n\n\t\tthis.targetObject = targetObject;\n\n\t\tif ( targetObject.needsUpdate !== undefined ) { // material\n\n\t\t\tversioning = this.Versioning.NeedsUpdate;\n\n\t\t} else if ( targetObject.matrixWorldNeedsUpdate !== undefined ) { // node transform\n\n\t\t\tversioning = this.Versioning.MatrixWorldNeedsUpdate;\n\n\t\t}\n\n\t\t// determine how the property gets bound\n\t\tlet bindingType = this.BindingType.Direct;\n\n\t\tif ( propertyIndex !== undefined ) {\n\n\t\t\t// access a sub element of the property array (only primitives are supported right now)\n\n\t\t\tif ( propertyName === 'morphTargetInfluences' ) {\n\n\t\t\t\t// potential optimization, skip this if propertyIndex is already an integer, and convert the integer string to a true integer.\n\n\t\t\t\t// support resolving morphTarget names into indices.\n\t\t\t\tif ( ! targetObject.geometry ) {\n\n\t\t\t\t\tconsole.error( 'THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.', this );\n\t\t\t\t\treturn;\n\n\t\t\t\t}\n\n\t\t\t\tif ( ! targetObject.geometry.morphAttributes ) {\n\n\t\t\t\t\tconsole.error( 'THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.morphAttributes.', this );\n\t\t\t\t\treturn;\n\n\t\t\t\t}\n\n\t\t\t\tif ( targetObject.morphTargetDictionary[ propertyIndex ] !== undefined ) {\n\n\t\t\t\t\tpropertyIndex = targetObject.morphTargetDictionary[ propertyIndex ];\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tbindingType = this.BindingType.ArrayElement;\n\n\t\t\tthis.resolvedProperty = nodeProperty;\n\t\t\tthis.propertyIndex = propertyIndex;\n\n\t\t} else if ( nodeProperty.fromArray !== undefined && nodeProperty.toArray !== undefined ) {\n\n\t\t\t// must use copy for Object3D.Euler/Quaternion\n\n\t\t\tbindingType = this.BindingType.HasFromToArray;\n\n\t\t\tthis.resolvedProperty = nodeProperty;\n\n\t\t} else if ( Array.isArray( nodeProperty ) ) {\n\n\t\t\tbindingType = this.BindingType.EntireArray;\n\n\t\t\tthis.resolvedProperty = nodeProperty;\n\n\t\t} else {\n\n\t\t\tthis.propertyName = propertyName;\n\n\t\t}\n\n\t\t// select getter / setter\n\t\tthis.getValue = this.GetterByBindingType[ bindingType ];\n\t\tthis.setValue = this.SetterByBindingTypeAndVersioning[ bindingType ][ versioning ];\n\n\t}\n\n\tunbind() {\n\n\t\tthis.node = null;\n\n\t\t// back to the prototype version of getValue / setValue\n\t\t// note: avoiding to mutate the shape of 'this' via 'delete'\n\t\tthis.getValue = this._getValue_unbound;\n\t\tthis.setValue = this._setValue_unbound;\n\n\t}\n\n}\n\nPropertyBinding.Composite = Composite;\n\nPropertyBinding.prototype.BindingType = {\n\tDirect: 0,\n\tEntireArray: 1,\n\tArrayElement: 2,\n\tHasFromToArray: 3\n};\n\nPropertyBinding.prototype.Versioning = {\n\tNone: 0,\n\tNeedsUpdate: 1,\n\tMatrixWorldNeedsUpdate: 2\n};\n\nPropertyBinding.prototype.GetterByBindingType = [\n\n\tPropertyBinding.prototype._getValue_direct,\n\tPropertyBinding.prototype._getValue_array,\n\tPropertyBinding.prototype._getValue_arrayElement,\n\tPropertyBinding.prototype._getValue_toArray,\n\n];\n\nPropertyBinding.prototype.SetterByBindingTypeAndVersioning = [\n\n\t[\n\t\t// Direct\n\t\tPropertyBinding.prototype._setValue_direct,\n\t\tPropertyBinding.prototype._setValue_direct_setNeedsUpdate,\n\t\tPropertyBinding.prototype._setValue_direct_setMatrixWorldNeedsUpdate,\n\n\t], [\n\n\t\t// EntireArray\n\n\t\tPropertyBinding.prototype._setValue_array,\n\t\tPropertyBinding.prototype._setValue_array_setNeedsUpdate,\n\t\tPropertyBinding.prototype._setValue_array_setMatrixWorldNeedsUpdate,\n\n\t], [\n\n\t\t// ArrayElement\n\t\tPropertyBinding.prototype._setValue_arrayElement,\n\t\tPropertyBinding.prototype._setValue_arrayElement_setNeedsUpdate,\n\t\tPropertyBinding.prototype._setValue_arrayElement_setMatrixWorldNeedsUpdate,\n\n\t], [\n\n\t\t// HasToFromArray\n\t\tPropertyBinding.prototype._setValue_fromArray,\n\t\tPropertyBinding.prototype._setValue_fromArray_setNeedsUpdate,\n\t\tPropertyBinding.prototype._setValue_fromArray_setMatrixWorldNeedsUpdate,\n\n\t]\n\n];\n\n/**\n *\n * A group of objects that receives a shared animation state.\n *\n * Usage:\n *\n * - Add objects you would otherwise pass as 'root' to the\n * constructor or the .clipAction method of AnimationMixer.\n *\n * - Instead pass this object as 'root'.\n *\n * - You can also add and remove objects later when the mixer\n * is running.\n *\n * Note:\n *\n * Objects of this class appear as one object to the mixer,\n * so cache control of the individual objects must be done\n * on the group.\n *\n * Limitation:\n *\n * - The animated properties must be compatible among the\n * all objects in the group.\n *\n * - A single property can either be controlled through a\n * target group or directly, but not both.\n */\n\nclass AnimationObjectGroup {\n\n\tconstructor() {\n\n\t\tthis.isAnimationObjectGroup = true;\n\n\t\tthis.uuid = generateUUID();\n\n\t\t// cached objects followed by the active ones\n\t\tthis._objects = Array.prototype.slice.call( arguments );\n\n\t\tthis.nCachedObjects_ = 0; // threshold\n\t\t// note: read by PropertyBinding.Composite\n\n\t\tconst indices = {};\n\t\tthis._indicesByUUID = indices; // for bookkeeping\n\n\t\tfor ( let i = 0, n = arguments.length; i !== n; ++ i ) {\n\n\t\t\tindices[ arguments[ i ].uuid ] = i;\n\n\t\t}\n\n\t\tthis._paths = []; // inside: string\n\t\tthis._parsedPaths = []; // inside: { we don't care, here }\n\t\tthis._bindings = []; // inside: Array< PropertyBinding >\n\t\tthis._bindingsIndicesByPath = {}; // inside: indices in these arrays\n\n\t\tconst scope = this;\n\n\t\tthis.stats = {\n\n\t\t\tobjects: {\n\t\t\t\tget total() {\n\n\t\t\t\t\treturn scope._objects.length;\n\n\t\t\t\t},\n\t\t\t\tget inUse() {\n\n\t\t\t\t\treturn this.total - scope.nCachedObjects_;\n\n\t\t\t\t}\n\t\t\t},\n\t\t\tget bindingsPerObject() {\n\n\t\t\t\treturn scope._bindings.length;\n\n\t\t\t}\n\n\t\t};\n\n\t}\n\n\tadd() {\n\n\t\tconst objects = this._objects,\n\t\t\tindicesByUUID = this._indicesByUUID,\n\t\t\tpaths = this._paths,\n\t\t\tparsedPaths = this._parsedPaths,\n\t\t\tbindings = this._bindings,\n\t\t\tnBindings = bindings.length;\n\n\t\tlet knownObject = undefined,\n\t\t\tnObjects = objects.length,\n\t\t\tnCachedObjects = this.nCachedObjects_;\n\n\t\tfor ( let i = 0, n = arguments.length; i !== n; ++ i ) {\n\n\t\t\tconst object = arguments[ i ],\n\t\t\t\tuuid = object.uuid;\n\t\t\tlet index = indicesByUUID[ uuid ];\n\n\t\t\tif ( index === undefined ) {\n\n\t\t\t\t// unknown object -> add it to the ACTIVE region\n\n\t\t\t\tindex = nObjects ++;\n\t\t\t\tindicesByUUID[ uuid ] = index;\n\t\t\t\tobjects.push( object );\n\n\t\t\t\t// accounting is done, now do the same for all bindings\n\n\t\t\t\tfor ( let j = 0, m = nBindings; j !== m; ++ j ) {\n\n\t\t\t\t\tbindings[ j ].push( new PropertyBinding( object, paths[ j ], parsedPaths[ j ] ) );\n\n\t\t\t\t}\n\n\t\t\t} else if ( index < nCachedObjects ) {\n\n\t\t\t\tknownObject = objects[ index ];\n\n\t\t\t\t// move existing object to the ACTIVE region\n\n\t\t\t\tconst firstActiveIndex = -- nCachedObjects,\n\t\t\t\t\tlastCachedObject = objects[ firstActiveIndex ];\n\n\t\t\t\tindicesByUUID[ lastCachedObject.uuid ] = index;\n\t\t\t\tobjects[ index ] = lastCachedObject;\n\n\t\t\t\tindicesByUUID[ uuid ] = firstActiveIndex;\n\t\t\t\tobjects[ firstActiveIndex ] = object;\n\n\t\t\t\t// accounting is done, now do the same for all bindings\n\n\t\t\t\tfor ( let j = 0, m = nBindings; j !== m; ++ j ) {\n\n\t\t\t\t\tconst bindingsForPath = bindings[ j ],\n\t\t\t\t\t\tlastCached = bindingsForPath[ firstActiveIndex ];\n\n\t\t\t\t\tlet binding = bindingsForPath[ index ];\n\n\t\t\t\t\tbindingsForPath[ index ] = lastCached;\n\n\t\t\t\t\tif ( binding === undefined ) {\n\n\t\t\t\t\t\t// since we do not bother to create new bindings\n\t\t\t\t\t\t// for objects that are cached, the binding may\n\t\t\t\t\t\t// or may not exist\n\n\t\t\t\t\t\tbinding = new PropertyBinding( object, paths[ j ], parsedPaths[ j ] );\n\n\t\t\t\t\t}\n\n\t\t\t\t\tbindingsForPath[ firstActiveIndex ] = binding;\n\n\t\t\t\t}\n\n\t\t\t} else if ( objects[ index ] !== knownObject ) {\n\n\t\t\t\tconsole.error( 'THREE.AnimationObjectGroup: Different objects with the same UUID ' +\n\t\t\t\t\t'detected. Clean the caches or recreate your infrastructure when reloading scenes.' );\n\n\t\t\t} // else the object is already where we want it to be\n\n\t\t} // for arguments\n\n\t\tthis.nCachedObjects_ = nCachedObjects;\n\n\t}\n\n\tremove() {\n\n\t\tconst objects = this._objects,\n\t\t\tindicesByUUID = this._indicesByUUID,\n\t\t\tbindings = this._bindings,\n\t\t\tnBindings = bindings.length;\n\n\t\tlet nCachedObjects = this.nCachedObjects_;\n\n\t\tfor ( let i = 0, n = arguments.length; i !== n; ++ i ) {\n\n\t\t\tconst object = arguments[ i ],\n\t\t\t\tuuid = object.uuid,\n\t\t\t\tindex = indicesByUUID[ uuid ];\n\n\t\t\tif ( index !== undefined && index >= nCachedObjects ) {\n\n\t\t\t\t// move existing object into the CACHED region\n\n\t\t\t\tconst lastCachedIndex = nCachedObjects ++,\n\t\t\t\t\tfirstActiveObject = objects[ lastCachedIndex ];\n\n\t\t\t\tindicesByUUID[ firstActiveObject.uuid ] = index;\n\t\t\t\tobjects[ index ] = firstActiveObject;\n\n\t\t\t\tindicesByUUID[ uuid ] = lastCachedIndex;\n\t\t\t\tobjects[ lastCachedIndex ] = object;\n\n\t\t\t\t// accounting is done, now do the same for all bindings\n\n\t\t\t\tfor ( let j = 0, m = nBindings; j !== m; ++ j ) {\n\n\t\t\t\t\tconst bindingsForPath = bindings[ j ],\n\t\t\t\t\t\tfirstActive = bindingsForPath[ lastCachedIndex ],\n\t\t\t\t\t\tbinding = bindingsForPath[ index ];\n\n\t\t\t\t\tbindingsForPath[ index ] = firstActive;\n\t\t\t\t\tbindingsForPath[ lastCachedIndex ] = binding;\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t} // for arguments\n\n\t\tthis.nCachedObjects_ = nCachedObjects;\n\n\t}\n\n\t// remove & forget\n\tuncache() {\n\n\t\tconst objects = this._objects,\n\t\t\tindicesByUUID = this._indicesByUUID,\n\t\t\tbindings = this._bindings,\n\t\t\tnBindings = bindings.length;\n\n\t\tlet nCachedObjects = this.nCachedObjects_,\n\t\t\tnObjects = objects.length;\n\n\t\tfor ( let i = 0, n = arguments.length; i !== n; ++ i ) {\n\n\t\t\tconst object = arguments[ i ],\n\t\t\t\tuuid = object.uuid,\n\t\t\t\tindex = indicesByUUID[ uuid ];\n\n\t\t\tif ( index !== undefined ) {\n\n\t\t\t\tdelete indicesByUUID[ uuid ];\n\n\t\t\t\tif ( index < nCachedObjects ) {\n\n\t\t\t\t\t// object is cached, shrink the CACHED region\n\n\t\t\t\t\tconst firstActiveIndex = -- nCachedObjects,\n\t\t\t\t\t\tlastCachedObject = objects[ firstActiveIndex ],\n\t\t\t\t\t\tlastIndex = -- nObjects,\n\t\t\t\t\t\tlastObject = objects[ lastIndex ];\n\n\t\t\t\t\t// last cached object takes this object's place\n\t\t\t\t\tindicesByUUID[ lastCachedObject.uuid ] = index;\n\t\t\t\t\tobjects[ index ] = lastCachedObject;\n\n\t\t\t\t\t// last object goes to the activated slot and pop\n\t\t\t\t\tindicesByUUID[ lastObject.uuid ] = firstActiveIndex;\n\t\t\t\t\tobjects[ firstActiveIndex ] = lastObject;\n\t\t\t\t\tobjects.pop();\n\n\t\t\t\t\t// accounting is done, now do the same for all bindings\n\n\t\t\t\t\tfor ( let j = 0, m = nBindings; j !== m; ++ j ) {\n\n\t\t\t\t\t\tconst bindingsForPath = bindings[ j ],\n\t\t\t\t\t\t\tlastCached = bindingsForPath[ firstActiveIndex ],\n\t\t\t\t\t\t\tlast = bindingsForPath[ lastIndex ];\n\n\t\t\t\t\t\tbindingsForPath[ index ] = lastCached;\n\t\t\t\t\t\tbindingsForPath[ firstActiveIndex ] = last;\n\t\t\t\t\t\tbindingsForPath.pop();\n\n\t\t\t\t\t}\n\n\t\t\t\t} else {\n\n\t\t\t\t\t// object is active, just swap with the last and pop\n\n\t\t\t\t\tconst lastIndex = -- nObjects,\n\t\t\t\t\t\tlastObject = objects[ lastIndex ];\n\n\t\t\t\t\tif ( lastIndex > 0 ) {\n\n\t\t\t\t\t\tindicesByUUID[ lastObject.uuid ] = index;\n\n\t\t\t\t\t}\n\n\t\t\t\t\tobjects[ index ] = lastObject;\n\t\t\t\t\tobjects.pop();\n\n\t\t\t\t\t// accounting is done, now do the same for all bindings\n\n\t\t\t\t\tfor ( let j = 0, m = nBindings; j !== m; ++ j ) {\n\n\t\t\t\t\t\tconst bindingsForPath = bindings[ j ];\n\n\t\t\t\t\t\tbindingsForPath[ index ] = bindingsForPath[ lastIndex ];\n\t\t\t\t\t\tbindingsForPath.pop();\n\n\t\t\t\t\t}\n\n\t\t\t\t} // cached or active\n\n\t\t\t} // if object is known\n\n\t\t} // for arguments\n\n\t\tthis.nCachedObjects_ = nCachedObjects;\n\n\t}\n\n\t// Internal interface used by befriended PropertyBinding.Composite:\n\n\tsubscribe_( path, parsedPath ) {\n\n\t\t// returns an array of bindings for the given path that is changed\n\t\t// according to the contained objects in the group\n\n\t\tconst indicesByPath = this._bindingsIndicesByPath;\n\t\tlet index = indicesByPath[ path ];\n\t\tconst bindings = this._bindings;\n\n\t\tif ( index !== undefined ) return bindings[ index ];\n\n\t\tconst paths = this._paths,\n\t\t\tparsedPaths = this._parsedPaths,\n\t\t\tobjects = this._objects,\n\t\t\tnObjects = objects.length,\n\t\t\tnCachedObjects = this.nCachedObjects_,\n\t\t\tbindingsForPath = new Array( nObjects );\n\n\t\tindex = bindings.length;\n\n\t\tindicesByPath[ path ] = index;\n\n\t\tpaths.push( path );\n\t\tparsedPaths.push( parsedPath );\n\t\tbindings.push( bindingsForPath );\n\n\t\tfor ( let i = nCachedObjects, n = objects.length; i !== n; ++ i ) {\n\n\t\t\tconst object = objects[ i ];\n\t\t\tbindingsForPath[ i ] = new PropertyBinding( object, path, parsedPath );\n\n\t\t}\n\n\t\treturn bindingsForPath;\n\n\t}\n\n\tunsubscribe_( path ) {\n\n\t\t// tells the group to forget about a property path and no longer\n\t\t// update the array previously obtained with 'subscribe_'\n\n\t\tconst indicesByPath = this._bindingsIndicesByPath,\n\t\t\tindex = indicesByPath[ path ];\n\n\t\tif ( index !== undefined ) {\n\n\t\t\tconst paths = this._paths,\n\t\t\t\tparsedPaths = this._parsedPaths,\n\t\t\t\tbindings = this._bindings,\n\t\t\t\tlastBindingsIndex = bindings.length - 1,\n\t\t\t\tlastBindings = bindings[ lastBindingsIndex ],\n\t\t\t\tlastBindingsPath = path[ lastBindingsIndex ];\n\n\t\t\tindicesByPath[ lastBindingsPath ] = index;\n\n\t\t\tbindings[ index ] = lastBindings;\n\t\t\tbindings.pop();\n\n\t\t\tparsedPaths[ index ] = parsedPaths[ lastBindingsIndex ];\n\t\t\tparsedPaths.pop();\n\n\t\t\tpaths[ index ] = paths[ lastBindingsIndex ];\n\t\t\tpaths.pop();\n\n\t\t}\n\n\t}\n\n}\n\nclass AnimationAction {\n\n\tconstructor( mixer, clip, localRoot = null, blendMode = clip.blendMode ) {\n\n\t\tthis._mixer = mixer;\n\t\tthis._clip = clip;\n\t\tthis._localRoot = localRoot;\n\t\tthis.blendMode = blendMode;\n\n\t\tconst tracks = clip.tracks,\n\t\t\tnTracks = tracks.length,\n\t\t\tinterpolants = new Array( nTracks );\n\n\t\tconst interpolantSettings = {\n\t\t\tendingStart: ZeroCurvatureEnding,\n\t\t\tendingEnd: ZeroCurvatureEnding\n\t\t};\n\n\t\tfor ( let i = 0; i !== nTracks; ++ i ) {\n\n\t\t\tconst interpolant = tracks[ i ].createInterpolant( null );\n\t\t\tinterpolants[ i ] = interpolant;\n\t\t\tinterpolant.settings = interpolantSettings;\n\n\t\t}\n\n\t\tthis._interpolantSettings = interpolantSettings;\n\n\t\tthis._interpolants = interpolants; // bound by the mixer\n\n\t\t// inside: PropertyMixer (managed by the mixer)\n\t\tthis._propertyBindings = new Array( nTracks );\n\n\t\tthis._cacheIndex = null; // for the memory manager\n\t\tthis._byClipCacheIndex = null; // for the memory manager\n\n\t\tthis._timeScaleInterpolant = null;\n\t\tthis._weightInterpolant = null;\n\n\t\tthis.loop = LoopRepeat;\n\t\tthis._loopCount = - 1;\n\n\t\t// global mixer time when the action is to be started\n\t\t// it's set back to 'null' upon start of the action\n\t\tthis._startTime = null;\n\n\t\t// scaled local time of the action\n\t\t// gets clamped or wrapped to 0..clip.duration according to loop\n\t\tthis.time = 0;\n\n\t\tthis.timeScale = 1;\n\t\tthis._effectiveTimeScale = 1;\n\n\t\tthis.weight = 1;\n\t\tthis._effectiveWeight = 1;\n\n\t\tthis.repetitions = Infinity; // no. of repetitions when looping\n\n\t\tthis.paused = false; // true -> zero effective time scale\n\t\tthis.enabled = true; // false -> zero effective weight\n\n\t\tthis.clampWhenFinished = false;// keep feeding the last frame?\n\n\t\tthis.zeroSlopeAtStart = true;// for smooth interpolation w/o separate\n\t\tthis.zeroSlopeAtEnd = true;// clips for start, loop and end\n\n\t}\n\n\t// State & Scheduling\n\n\tplay() {\n\n\t\tthis._mixer._activateAction( this );\n\n\t\treturn this;\n\n\t}\n\n\tstop() {\n\n\t\tthis._mixer._deactivateAction( this );\n\n\t\treturn this.reset();\n\n\t}\n\n\treset() {\n\n\t\tthis.paused = false;\n\t\tthis.enabled = true;\n\n\t\tthis.time = 0; // restart clip\n\t\tthis._loopCount = - 1;// forget previous loops\n\t\tthis._startTime = null;// forget scheduling\n\n\t\treturn this.stopFading().stopWarping();\n\n\t}\n\n\tisRunning() {\n\n\t\treturn this.enabled && ! this.paused && this.timeScale !== 0 &&\n\t\t\tthis._startTime === null && this._mixer._isActiveAction( this );\n\n\t}\n\n\t// return true when play has been called\n\tisScheduled() {\n\n\t\treturn this._mixer._isActiveAction( this );\n\n\t}\n\n\tstartAt( time ) {\n\n\t\tthis._startTime = time;\n\n\t\treturn this;\n\n\t}\n\n\tsetLoop( mode, repetitions ) {\n\n\t\tthis.loop = mode;\n\t\tthis.repetitions = repetitions;\n\n\t\treturn this;\n\n\t}\n\n\t// Weight\n\n\t// set the weight stopping any scheduled fading\n\t// although .enabled = false yields an effective weight of zero, this\n\t// method does *not* change .enabled, because it would be confusing\n\tsetEffectiveWeight( weight ) {\n\n\t\tthis.weight = weight;\n\n\t\t// note: same logic as when updated at runtime\n\t\tthis._effectiveWeight = this.enabled ? weight : 0;\n\n\t\treturn this.stopFading();\n\n\t}\n\n\t// return the weight considering fading and .enabled\n\tgetEffectiveWeight() {\n\n\t\treturn this._effectiveWeight;\n\n\t}\n\n\tfadeIn( duration ) {\n\n\t\treturn this._scheduleFading( duration, 0, 1 );\n\n\t}\n\n\tfadeOut( duration ) {\n\n\t\treturn this._scheduleFading( duration, 1, 0 );\n\n\t}\n\n\tcrossFadeFrom( fadeOutAction, duration, warp ) {\n\n\t\tfadeOutAction.fadeOut( duration );\n\t\tthis.fadeIn( duration );\n\n\t\tif ( warp ) {\n\n\t\t\tconst fadeInDuration = this._clip.duration,\n\t\t\t\tfadeOutDuration = fadeOutAction._clip.duration,\n\n\t\t\t\tstartEndRatio = fadeOutDuration / fadeInDuration,\n\t\t\t\tendStartRatio = fadeInDuration / fadeOutDuration;\n\n\t\t\tfadeOutAction.warp( 1.0, startEndRatio, duration );\n\t\t\tthis.warp( endStartRatio, 1.0, duration );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tcrossFadeTo( fadeInAction, duration, warp ) {\n\n\t\treturn fadeInAction.crossFadeFrom( this, duration, warp );\n\n\t}\n\n\tstopFading() {\n\n\t\tconst weightInterpolant = this._weightInterpolant;\n\n\t\tif ( weightInterpolant !== null ) {\n\n\t\t\tthis._weightInterpolant = null;\n\t\t\tthis._mixer._takeBackControlInterpolant( weightInterpolant );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\t// Time Scale Control\n\n\t// set the time scale stopping any scheduled warping\n\t// although .paused = true yields an effective time scale of zero, this\n\t// method does *not* change .paused, because it would be confusing\n\tsetEffectiveTimeScale( timeScale ) {\n\n\t\tthis.timeScale = timeScale;\n\t\tthis._effectiveTimeScale = this.paused ? 0 : timeScale;\n\n\t\treturn this.stopWarping();\n\n\t}\n\n\t// return the time scale considering warping and .paused\n\tgetEffectiveTimeScale() {\n\n\t\treturn this._effectiveTimeScale;\n\n\t}\n\n\tsetDuration( duration ) {\n\n\t\tthis.timeScale = this._clip.duration / duration;\n\n\t\treturn this.stopWarping();\n\n\t}\n\n\tsyncWith( action ) {\n\n\t\tthis.time = action.time;\n\t\tthis.timeScale = action.timeScale;\n\n\t\treturn this.stopWarping();\n\n\t}\n\n\thalt( duration ) {\n\n\t\treturn this.warp( this._effectiveTimeScale, 0, duration );\n\n\t}\n\n\twarp( startTimeScale, endTimeScale, duration ) {\n\n\t\tconst mixer = this._mixer,\n\t\t\tnow = mixer.time,\n\t\t\ttimeScale = this.timeScale;\n\n\t\tlet interpolant = this._timeScaleInterpolant;\n\n\t\tif ( interpolant === null ) {\n\n\t\t\tinterpolant = mixer._lendControlInterpolant();\n\t\t\tthis._timeScaleInterpolant = interpolant;\n\n\t\t}\n\n\t\tconst times = interpolant.parameterPositions,\n\t\t\tvalues = interpolant.sampleValues;\n\n\t\ttimes[ 0 ] = now;\n\t\ttimes[ 1 ] = now + duration;\n\n\t\tvalues[ 0 ] = startTimeScale / timeScale;\n\t\tvalues[ 1 ] = endTimeScale / timeScale;\n\n\t\treturn this;\n\n\t}\n\n\tstopWarping() {\n\n\t\tconst timeScaleInterpolant = this._timeScaleInterpolant;\n\n\t\tif ( timeScaleInterpolant !== null ) {\n\n\t\t\tthis._timeScaleInterpolant = null;\n\t\t\tthis._mixer._takeBackControlInterpolant( timeScaleInterpolant );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\t// Object Accessors\n\n\tgetMixer() {\n\n\t\treturn this._mixer;\n\n\t}\n\n\tgetClip() {\n\n\t\treturn this._clip;\n\n\t}\n\n\tgetRoot() {\n\n\t\treturn this._localRoot || this._mixer._root;\n\n\t}\n\n\t// Interna\n\n\t_update( time, deltaTime, timeDirection, accuIndex ) {\n\n\t\t// called by the mixer\n\n\t\tif ( ! this.enabled ) {\n\n\t\t\t// call ._updateWeight() to update ._effectiveWeight\n\n\t\t\tthis._updateWeight( time );\n\t\t\treturn;\n\n\t\t}\n\n\t\tconst startTime = this._startTime;\n\n\t\tif ( startTime !== null ) {\n\n\t\t\t// check for scheduled start of action\n\n\t\t\tconst timeRunning = ( time - startTime ) * timeDirection;\n\t\t\tif ( timeRunning < 0 || timeDirection === 0 ) {\n\n\t\t\t\tdeltaTime = 0;\n\n\t\t\t} else {\n\n\n\t\t\t\tthis._startTime = null; // unschedule\n\t\t\t\tdeltaTime = timeDirection * timeRunning;\n\n\t\t\t}\n\n\t\t}\n\n\t\t// apply time scale and advance time\n\n\t\tdeltaTime *= this._updateTimeScale( time );\n\t\tconst clipTime = this._updateTime( deltaTime );\n\n\t\t// note: _updateTime may disable the action resulting in\n\t\t// an effective weight of 0\n\n\t\tconst weight = this._updateWeight( time );\n\n\t\tif ( weight > 0 ) {\n\n\t\t\tconst interpolants = this._interpolants;\n\t\t\tconst propertyMixers = this._propertyBindings;\n\n\t\t\tswitch ( this.blendMode ) {\n\n\t\t\t\tcase AdditiveAnimationBlendMode:\n\n\t\t\t\t\tfor ( let j = 0, m = interpolants.length; j !== m; ++ j ) {\n\n\t\t\t\t\t\tinterpolants[ j ].evaluate( clipTime );\n\t\t\t\t\t\tpropertyMixers[ j ].accumulateAdditive( weight );\n\n\t\t\t\t\t}\n\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase NormalAnimationBlendMode:\n\t\t\t\tdefault:\n\n\t\t\t\t\tfor ( let j = 0, m = interpolants.length; j !== m; ++ j ) {\n\n\t\t\t\t\t\tinterpolants[ j ].evaluate( clipTime );\n\t\t\t\t\t\tpropertyMixers[ j ].accumulate( accuIndex, weight );\n\n\t\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n\t_updateWeight( time ) {\n\n\t\tlet weight = 0;\n\n\t\tif ( this.enabled ) {\n\n\t\t\tweight = this.weight;\n\t\t\tconst interpolant = this._weightInterpolant;\n\n\t\t\tif ( interpolant !== null ) {\n\n\t\t\t\tconst interpolantValue = interpolant.evaluate( time )[ 0 ];\n\n\t\t\t\tweight *= interpolantValue;\n\n\t\t\t\tif ( time > interpolant.parameterPositions[ 1 ] ) {\n\n\t\t\t\t\tthis.stopFading();\n\n\t\t\t\t\tif ( interpolantValue === 0 ) {\n\n\t\t\t\t\t\t// faded out, disable\n\t\t\t\t\t\tthis.enabled = false;\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t\tthis._effectiveWeight = weight;\n\t\treturn weight;\n\n\t}\n\n\t_updateTimeScale( time ) {\n\n\t\tlet timeScale = 0;\n\n\t\tif ( ! this.paused ) {\n\n\t\t\ttimeScale = this.timeScale;\n\n\t\t\tconst interpolant = this._timeScaleInterpolant;\n\n\t\t\tif ( interpolant !== null ) {\n\n\t\t\t\tconst interpolantValue = interpolant.evaluate( time )[ 0 ];\n\n\t\t\t\ttimeScale *= interpolantValue;\n\n\t\t\t\tif ( time > interpolant.parameterPositions[ 1 ] ) {\n\n\t\t\t\t\tthis.stopWarping();\n\n\t\t\t\t\tif ( timeScale === 0 ) {\n\n\t\t\t\t\t\t// motion has halted, pause\n\t\t\t\t\t\tthis.paused = true;\n\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\t// warp done - apply final time scale\n\t\t\t\t\t\tthis.timeScale = timeScale;\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t\tthis._effectiveTimeScale = timeScale;\n\t\treturn timeScale;\n\n\t}\n\n\t_updateTime( deltaTime ) {\n\n\t\tconst duration = this._clip.duration;\n\t\tconst loop = this.loop;\n\n\t\tlet time = this.time + deltaTime;\n\t\tlet loopCount = this._loopCount;\n\n\t\tconst pingPong = ( loop === LoopPingPong );\n\n\t\tif ( deltaTime === 0 ) {\n\n\t\t\tif ( loopCount === - 1 ) return time;\n\n\t\t\treturn ( pingPong && ( loopCount & 1 ) === 1 ) ? duration - time : time;\n\n\t\t}\n\n\t\tif ( loop === LoopOnce ) {\n\n\t\t\tif ( loopCount === - 1 ) {\n\n\t\t\t\t// just started\n\n\t\t\t\tthis._loopCount = 0;\n\t\t\t\tthis._setEndings( true, true, false );\n\n\t\t\t}\n\n\t\t\thandle_stop: {\n\n\t\t\t\tif ( time >= duration ) {\n\n\t\t\t\t\ttime = duration;\n\n\t\t\t\t} else if ( time < 0 ) {\n\n\t\t\t\t\ttime = 0;\n\n\t\t\t\t} else {\n\n\t\t\t\t\tthis.time = time;\n\n\t\t\t\t\tbreak handle_stop;\n\n\t\t\t\t}\n\n\t\t\t\tif ( this.clampWhenFinished ) this.paused = true;\n\t\t\t\telse this.enabled = false;\n\n\t\t\t\tthis.time = time;\n\n\t\t\t\tthis._mixer.dispatchEvent( {\n\t\t\t\t\ttype: 'finished', action: this,\n\t\t\t\t\tdirection: deltaTime < 0 ? - 1 : 1\n\t\t\t\t} );\n\n\t\t\t}\n\n\t\t} else { // repetitive Repeat or PingPong\n\n\t\t\tif ( loopCount === - 1 ) {\n\n\t\t\t\t// just started\n\n\t\t\t\tif ( deltaTime >= 0 ) {\n\n\t\t\t\t\tloopCount = 0;\n\n\t\t\t\t\tthis._setEndings( true, this.repetitions === 0, pingPong );\n\n\t\t\t\t} else {\n\n\t\t\t\t\t// when looping in reverse direction, the initial\n\t\t\t\t\t// transition through zero counts as a repetition,\n\t\t\t\t\t// so leave loopCount at -1\n\n\t\t\t\t\tthis._setEndings( this.repetitions === 0, true, pingPong );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tif ( time >= duration || time < 0 ) {\n\n\t\t\t\t// wrap around\n\n\t\t\t\tconst loopDelta = Math.floor( time / duration ); // signed\n\t\t\t\ttime -= duration * loopDelta;\n\n\t\t\t\tloopCount += Math.abs( loopDelta );\n\n\t\t\t\tconst pending = this.repetitions - loopCount;\n\n\t\t\t\tif ( pending <= 0 ) {\n\n\t\t\t\t\t// have to stop (switch state, clamp time, fire event)\n\n\t\t\t\t\tif ( this.clampWhenFinished ) this.paused = true;\n\t\t\t\t\telse this.enabled = false;\n\n\t\t\t\t\ttime = deltaTime > 0 ? duration : 0;\n\n\t\t\t\t\tthis.time = time;\n\n\t\t\t\t\tthis._mixer.dispatchEvent( {\n\t\t\t\t\t\ttype: 'finished', action: this,\n\t\t\t\t\t\tdirection: deltaTime > 0 ? 1 : - 1\n\t\t\t\t\t} );\n\n\t\t\t\t} else {\n\n\t\t\t\t\t// keep running\n\n\t\t\t\t\tif ( pending === 1 ) {\n\n\t\t\t\t\t\t// entering the last round\n\n\t\t\t\t\t\tconst atStart = deltaTime < 0;\n\t\t\t\t\t\tthis._setEndings( atStart, ! atStart, pingPong );\n\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\tthis._setEndings( false, false, pingPong );\n\n\t\t\t\t\t}\n\n\t\t\t\t\tthis._loopCount = loopCount;\n\n\t\t\t\t\tthis.time = time;\n\n\t\t\t\t\tthis._mixer.dispatchEvent( {\n\t\t\t\t\t\ttype: 'loop', action: this, loopDelta: loopDelta\n\t\t\t\t\t} );\n\n\t\t\t\t}\n\n\t\t\t} else {\n\n\t\t\t\tthis.time = time;\n\n\t\t\t}\n\n\t\t\tif ( pingPong && ( loopCount & 1 ) === 1 ) {\n\n\t\t\t\t// invert time for the \"pong round\"\n\n\t\t\t\treturn duration - time;\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn time;\n\n\t}\n\n\t_setEndings( atStart, atEnd, pingPong ) {\n\n\t\tconst settings = this._interpolantSettings;\n\n\t\tif ( pingPong ) {\n\n\t\t\tsettings.endingStart = ZeroSlopeEnding;\n\t\t\tsettings.endingEnd = ZeroSlopeEnding;\n\n\t\t} else {\n\n\t\t\t// assuming for LoopOnce atStart == atEnd == true\n\n\t\t\tif ( atStart ) {\n\n\t\t\t\tsettings.endingStart = this.zeroSlopeAtStart ? ZeroSlopeEnding : ZeroCurvatureEnding;\n\n\t\t\t} else {\n\n\t\t\t\tsettings.endingStart = WrapAroundEnding;\n\n\t\t\t}\n\n\t\t\tif ( atEnd ) {\n\n\t\t\t\tsettings.endingEnd = this.zeroSlopeAtEnd ? ZeroSlopeEnding : ZeroCurvatureEnding;\n\n\t\t\t} else {\n\n\t\t\t\tsettings.endingEnd \t = WrapAroundEnding;\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n\t_scheduleFading( duration, weightNow, weightThen ) {\n\n\t\tconst mixer = this._mixer, now = mixer.time;\n\t\tlet interpolant = this._weightInterpolant;\n\n\t\tif ( interpolant === null ) {\n\n\t\t\tinterpolant = mixer._lendControlInterpolant();\n\t\t\tthis._weightInterpolant = interpolant;\n\n\t\t}\n\n\t\tconst times = interpolant.parameterPositions,\n\t\t\tvalues = interpolant.sampleValues;\n\n\t\ttimes[ 0 ] = now;\n\t\tvalues[ 0 ] = weightNow;\n\t\ttimes[ 1 ] = now + duration;\n\t\tvalues[ 1 ] = weightThen;\n\n\t\treturn this;\n\n\t}\n\n}\n\nconst _controlInterpolantsResultBuffer = new Float32Array( 1 );\n\n\nclass AnimationMixer extends EventDispatcher {\n\n\tconstructor( root ) {\n\n\t\tsuper();\n\n\t\tthis._root = root;\n\t\tthis._initMemoryManager();\n\t\tthis._accuIndex = 0;\n\t\tthis.time = 0;\n\t\tthis.timeScale = 1.0;\n\n\t}\n\n\t_bindAction( action, prototypeAction ) {\n\n\t\tconst root = action._localRoot || this._root,\n\t\t\ttracks = action._clip.tracks,\n\t\t\tnTracks = tracks.length,\n\t\t\tbindings = action._propertyBindings,\n\t\t\tinterpolants = action._interpolants,\n\t\t\trootUuid = root.uuid,\n\t\t\tbindingsByRoot = this._bindingsByRootAndName;\n\n\t\tlet bindingsByName = bindingsByRoot[ rootUuid ];\n\n\t\tif ( bindingsByName === undefined ) {\n\n\t\t\tbindingsByName = {};\n\t\t\tbindingsByRoot[ rootUuid ] = bindingsByName;\n\n\t\t}\n\n\t\tfor ( let i = 0; i !== nTracks; ++ i ) {\n\n\t\t\tconst track = tracks[ i ],\n\t\t\t\ttrackName = track.name;\n\n\t\t\tlet binding = bindingsByName[ trackName ];\n\n\t\t\tif ( binding !== undefined ) {\n\n\t\t\t\t++ binding.referenceCount;\n\t\t\t\tbindings[ i ] = binding;\n\n\t\t\t} else {\n\n\t\t\t\tbinding = bindings[ i ];\n\n\t\t\t\tif ( binding !== undefined ) {\n\n\t\t\t\t\t// existing binding, make sure the cache knows\n\n\t\t\t\t\tif ( binding._cacheIndex === null ) {\n\n\t\t\t\t\t\t++ binding.referenceCount;\n\t\t\t\t\t\tthis._addInactiveBinding( binding, rootUuid, trackName );\n\n\t\t\t\t\t}\n\n\t\t\t\t\tcontinue;\n\n\t\t\t\t}\n\n\t\t\t\tconst path = prototypeAction && prototypeAction.\n\t\t\t\t\t_propertyBindings[ i ].binding.parsedPath;\n\n\t\t\t\tbinding = new PropertyMixer(\n\t\t\t\t\tPropertyBinding.create( root, trackName, path ),\n\t\t\t\t\ttrack.ValueTypeName, track.getValueSize() );\n\n\t\t\t\t++ binding.referenceCount;\n\t\t\t\tthis._addInactiveBinding( binding, rootUuid, trackName );\n\n\t\t\t\tbindings[ i ] = binding;\n\n\t\t\t}\n\n\t\t\tinterpolants[ i ].resultBuffer = binding.buffer;\n\n\t\t}\n\n\t}\n\n\t_activateAction( action ) {\n\n\t\tif ( ! this._isActiveAction( action ) ) {\n\n\t\t\tif ( action._cacheIndex === null ) {\n\n\t\t\t\t// this action has been forgotten by the cache, but the user\n\t\t\t\t// appears to be still using it -> rebind\n\n\t\t\t\tconst rootUuid = ( action._localRoot || this._root ).uuid,\n\t\t\t\t\tclipUuid = action._clip.uuid,\n\t\t\t\t\tactionsForClip = this._actionsByClip[ clipUuid ];\n\n\t\t\t\tthis._bindAction( action,\n\t\t\t\t\tactionsForClip && actionsForClip.knownActions[ 0 ] );\n\n\t\t\t\tthis._addInactiveAction( action, clipUuid, rootUuid );\n\n\t\t\t}\n\n\t\t\tconst bindings = action._propertyBindings;\n\n\t\t\t// increment reference counts / sort out state\n\t\t\tfor ( let i = 0, n = bindings.length; i !== n; ++ i ) {\n\n\t\t\t\tconst binding = bindings[ i ];\n\n\t\t\t\tif ( binding.useCount ++ === 0 ) {\n\n\t\t\t\t\tthis._lendBinding( binding );\n\t\t\t\t\tbinding.saveOriginalState();\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tthis._lendAction( action );\n\n\t\t}\n\n\t}\n\n\t_deactivateAction( action ) {\n\n\t\tif ( this._isActiveAction( action ) ) {\n\n\t\t\tconst bindings = action._propertyBindings;\n\n\t\t\t// decrement reference counts / sort out state\n\t\t\tfor ( let i = 0, n = bindings.length; i !== n; ++ i ) {\n\n\t\t\t\tconst binding = bindings[ i ];\n\n\t\t\t\tif ( -- binding.useCount === 0 ) {\n\n\t\t\t\t\tbinding.restoreOriginalState();\n\t\t\t\t\tthis._takeBackBinding( binding );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tthis._takeBackAction( action );\n\n\t\t}\n\n\t}\n\n\t// Memory manager\n\n\t_initMemoryManager() {\n\n\t\tthis._actions = []; // 'nActiveActions' followed by inactive ones\n\t\tthis._nActiveActions = 0;\n\n\t\tthis._actionsByClip = {};\n\t\t// inside:\n\t\t// {\n\t\t// \tknownActions: Array< AnimationAction > - used as prototypes\n\t\t// \tactionByRoot: AnimationAction - lookup\n\t\t// }\n\n\n\t\tthis._bindings = []; // 'nActiveBindings' followed by inactive ones\n\t\tthis._nActiveBindings = 0;\n\n\t\tthis._bindingsByRootAndName = {}; // inside: Map< name, PropertyMixer >\n\n\n\t\tthis._controlInterpolants = []; // same game as above\n\t\tthis._nActiveControlInterpolants = 0;\n\n\t\tconst scope = this;\n\n\t\tthis.stats = {\n\n\t\t\tactions: {\n\t\t\t\tget total() {\n\n\t\t\t\t\treturn scope._actions.length;\n\n\t\t\t\t},\n\t\t\t\tget inUse() {\n\n\t\t\t\t\treturn scope._nActiveActions;\n\n\t\t\t\t}\n\t\t\t},\n\t\t\tbindings: {\n\t\t\t\tget total() {\n\n\t\t\t\t\treturn scope._bindings.length;\n\n\t\t\t\t},\n\t\t\t\tget inUse() {\n\n\t\t\t\t\treturn scope._nActiveBindings;\n\n\t\t\t\t}\n\t\t\t},\n\t\t\tcontrolInterpolants: {\n\t\t\t\tget total() {\n\n\t\t\t\t\treturn scope._controlInterpolants.length;\n\n\t\t\t\t},\n\t\t\t\tget inUse() {\n\n\t\t\t\t\treturn scope._nActiveControlInterpolants;\n\n\t\t\t\t}\n\t\t\t}\n\n\t\t};\n\n\t}\n\n\t// Memory management for AnimationAction objects\n\n\t_isActiveAction( action ) {\n\n\t\tconst index = action._cacheIndex;\n\t\treturn index !== null && index < this._nActiveActions;\n\n\t}\n\n\t_addInactiveAction( action, clipUuid, rootUuid ) {\n\n\t\tconst actions = this._actions,\n\t\t\tactionsByClip = this._actionsByClip;\n\n\t\tlet actionsForClip = actionsByClip[ clipUuid ];\n\n\t\tif ( actionsForClip === undefined ) {\n\n\t\t\tactionsForClip = {\n\n\t\t\t\tknownActions: [ action ],\n\t\t\t\tactionByRoot: {}\n\n\t\t\t};\n\n\t\t\taction._byClipCacheIndex = 0;\n\n\t\t\tactionsByClip[ clipUuid ] = actionsForClip;\n\n\t\t} else {\n\n\t\t\tconst knownActions = actionsForClip.knownActions;\n\n\t\t\taction._byClipCacheIndex = knownActions.length;\n\t\t\tknownActions.push( action );\n\n\t\t}\n\n\t\taction._cacheIndex = actions.length;\n\t\tactions.push( action );\n\n\t\tactionsForClip.actionByRoot[ rootUuid ] = action;\n\n\t}\n\n\t_removeInactiveAction( action ) {\n\n\t\tconst actions = this._actions,\n\t\t\tlastInactiveAction = actions[ actions.length - 1 ],\n\t\t\tcacheIndex = action._cacheIndex;\n\n\t\tlastInactiveAction._cacheIndex = cacheIndex;\n\t\tactions[ cacheIndex ] = lastInactiveAction;\n\t\tactions.pop();\n\n\t\taction._cacheIndex = null;\n\n\n\t\tconst clipUuid = action._clip.uuid,\n\t\t\tactionsByClip = this._actionsByClip,\n\t\t\tactionsForClip = actionsByClip[ clipUuid ],\n\t\t\tknownActionsForClip = actionsForClip.knownActions,\n\n\t\t\tlastKnownAction =\n\t\t\t\tknownActionsForClip[ knownActionsForClip.length - 1 ],\n\n\t\t\tbyClipCacheIndex = action._byClipCacheIndex;\n\n\t\tlastKnownAction._byClipCacheIndex = byClipCacheIndex;\n\t\tknownActionsForClip[ byClipCacheIndex ] = lastKnownAction;\n\t\tknownActionsForClip.pop();\n\n\t\taction._byClipCacheIndex = null;\n\n\n\t\tconst actionByRoot = actionsForClip.actionByRoot,\n\t\t\trootUuid = ( action._localRoot || this._root ).uuid;\n\n\t\tdelete actionByRoot[ rootUuid ];\n\n\t\tif ( knownActionsForClip.length === 0 ) {\n\n\t\t\tdelete actionsByClip[ clipUuid ];\n\n\t\t}\n\n\t\tthis._removeInactiveBindingsForAction( action );\n\n\t}\n\n\t_removeInactiveBindingsForAction( action ) {\n\n\t\tconst bindings = action._propertyBindings;\n\n\t\tfor ( let i = 0, n = bindings.length; i !== n; ++ i ) {\n\n\t\t\tconst binding = bindings[ i ];\n\n\t\t\tif ( -- binding.referenceCount === 0 ) {\n\n\t\t\t\tthis._removeInactiveBinding( binding );\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n\t_lendAction( action ) {\n\n\t\t// [ active actions | inactive actions ]\n\t\t// [ active actions >| inactive actions ]\n\t\t// s a\n\t\t// <-swap->\n\t\t// a s\n\n\t\tconst actions = this._actions,\n\t\t\tprevIndex = action._cacheIndex,\n\n\t\t\tlastActiveIndex = this._nActiveActions ++,\n\n\t\t\tfirstInactiveAction = actions[ lastActiveIndex ];\n\n\t\taction._cacheIndex = lastActiveIndex;\n\t\tactions[ lastActiveIndex ] = action;\n\n\t\tfirstInactiveAction._cacheIndex = prevIndex;\n\t\tactions[ prevIndex ] = firstInactiveAction;\n\n\t}\n\n\t_takeBackAction( action ) {\n\n\t\t// [ active actions | inactive actions ]\n\t\t// [ active actions |< inactive actions ]\n\t\t// a s\n\t\t// <-swap->\n\t\t// s a\n\n\t\tconst actions = this._actions,\n\t\t\tprevIndex = action._cacheIndex,\n\n\t\t\tfirstInactiveIndex = -- this._nActiveActions,\n\n\t\t\tlastActiveAction = actions[ firstInactiveIndex ];\n\n\t\taction._cacheIndex = firstInactiveIndex;\n\t\tactions[ firstInactiveIndex ] = action;\n\n\t\tlastActiveAction._cacheIndex = prevIndex;\n\t\tactions[ prevIndex ] = lastActiveAction;\n\n\t}\n\n\t// Memory management for PropertyMixer objects\n\n\t_addInactiveBinding( binding, rootUuid, trackName ) {\n\n\t\tconst bindingsByRoot = this._bindingsByRootAndName,\n\t\t\tbindings = this._bindings;\n\n\t\tlet bindingByName = bindingsByRoot[ rootUuid ];\n\n\t\tif ( bindingByName === undefined ) {\n\n\t\t\tbindingByName = {};\n\t\t\tbindingsByRoot[ rootUuid ] = bindingByName;\n\n\t\t}\n\n\t\tbindingByName[ trackName ] = binding;\n\n\t\tbinding._cacheIndex = bindings.length;\n\t\tbindings.push( binding );\n\n\t}\n\n\t_removeInactiveBinding( binding ) {\n\n\t\tconst bindings = this._bindings,\n\t\t\tpropBinding = binding.binding,\n\t\t\trootUuid = propBinding.rootNode.uuid,\n\t\t\ttrackName = propBinding.path,\n\t\t\tbindingsByRoot = this._bindingsByRootAndName,\n\t\t\tbindingByName = bindingsByRoot[ rootUuid ],\n\n\t\t\tlastInactiveBinding = bindings[ bindings.length - 1 ],\n\t\t\tcacheIndex = binding._cacheIndex;\n\n\t\tlastInactiveBinding._cacheIndex = cacheIndex;\n\t\tbindings[ cacheIndex ] = lastInactiveBinding;\n\t\tbindings.pop();\n\n\t\tdelete bindingByName[ trackName ];\n\n\t\tif ( Object.keys( bindingByName ).length === 0 ) {\n\n\t\t\tdelete bindingsByRoot[ rootUuid ];\n\n\t\t}\n\n\t}\n\n\t_lendBinding( binding ) {\n\n\t\tconst bindings = this._bindings,\n\t\t\tprevIndex = binding._cacheIndex,\n\n\t\t\tlastActiveIndex = this._nActiveBindings ++,\n\n\t\t\tfirstInactiveBinding = bindings[ lastActiveIndex ];\n\n\t\tbinding._cacheIndex = lastActiveIndex;\n\t\tbindings[ lastActiveIndex ] = binding;\n\n\t\tfirstInactiveBinding._cacheIndex = prevIndex;\n\t\tbindings[ prevIndex ] = firstInactiveBinding;\n\n\t}\n\n\t_takeBackBinding( binding ) {\n\n\t\tconst bindings = this._bindings,\n\t\t\tprevIndex = binding._cacheIndex,\n\n\t\t\tfirstInactiveIndex = -- this._nActiveBindings,\n\n\t\t\tlastActiveBinding = bindings[ firstInactiveIndex ];\n\n\t\tbinding._cacheIndex = firstInactiveIndex;\n\t\tbindings[ firstInactiveIndex ] = binding;\n\n\t\tlastActiveBinding._cacheIndex = prevIndex;\n\t\tbindings[ prevIndex ] = lastActiveBinding;\n\n\t}\n\n\n\t// Memory management of Interpolants for weight and time scale\n\n\t_lendControlInterpolant() {\n\n\t\tconst interpolants = this._controlInterpolants,\n\t\t\tlastActiveIndex = this._nActiveControlInterpolants ++;\n\n\t\tlet interpolant = interpolants[ lastActiveIndex ];\n\n\t\tif ( interpolant === undefined ) {\n\n\t\t\tinterpolant = new LinearInterpolant(\n\t\t\t\tnew Float32Array( 2 ), new Float32Array( 2 ),\n\t\t\t\t1, _controlInterpolantsResultBuffer );\n\n\t\t\tinterpolant.__cacheIndex = lastActiveIndex;\n\t\t\tinterpolants[ lastActiveIndex ] = interpolant;\n\n\t\t}\n\n\t\treturn interpolant;\n\n\t}\n\n\t_takeBackControlInterpolant( interpolant ) {\n\n\t\tconst interpolants = this._controlInterpolants,\n\t\t\tprevIndex = interpolant.__cacheIndex,\n\n\t\t\tfirstInactiveIndex = -- this._nActiveControlInterpolants,\n\n\t\t\tlastActiveInterpolant = interpolants[ firstInactiveIndex ];\n\n\t\tinterpolant.__cacheIndex = firstInactiveIndex;\n\t\tinterpolants[ firstInactiveIndex ] = interpolant;\n\n\t\tlastActiveInterpolant.__cacheIndex = prevIndex;\n\t\tinterpolants[ prevIndex ] = lastActiveInterpolant;\n\n\t}\n\n\t// return an action for a clip optionally using a custom root target\n\t// object (this method allocates a lot of dynamic memory in case a\n\t// previously unknown clip/root combination is specified)\n\tclipAction( clip, optionalRoot, blendMode ) {\n\n\t\tconst root = optionalRoot || this._root,\n\t\t\trootUuid = root.uuid;\n\n\t\tlet clipObject = typeof clip === 'string' ? AnimationClip.findByName( root, clip ) : clip;\n\n\t\tconst clipUuid = clipObject !== null ? clipObject.uuid : clip;\n\n\t\tconst actionsForClip = this._actionsByClip[ clipUuid ];\n\t\tlet prototypeAction = null;\n\n\t\tif ( blendMode === undefined ) {\n\n\t\t\tif ( clipObject !== null ) {\n\n\t\t\t\tblendMode = clipObject.blendMode;\n\n\t\t\t} else {\n\n\t\t\t\tblendMode = NormalAnimationBlendMode;\n\n\t\t\t}\n\n\t\t}\n\n\t\tif ( actionsForClip !== undefined ) {\n\n\t\t\tconst existingAction = actionsForClip.actionByRoot[ rootUuid ];\n\n\t\t\tif ( existingAction !== undefined && existingAction.blendMode === blendMode ) {\n\n\t\t\t\treturn existingAction;\n\n\t\t\t}\n\n\t\t\t// we know the clip, so we don't have to parse all\n\t\t\t// the bindings again but can just copy\n\t\t\tprototypeAction = actionsForClip.knownActions[ 0 ];\n\n\t\t\t// also, take the clip from the prototype action\n\t\t\tif ( clipObject === null )\n\t\t\t\tclipObject = prototypeAction._clip;\n\n\t\t}\n\n\t\t// clip must be known when specified via string\n\t\tif ( clipObject === null ) return null;\n\n\t\t// allocate all resources required to run it\n\t\tconst newAction = new AnimationAction( this, clipObject, optionalRoot, blendMode );\n\n\t\tthis._bindAction( newAction, prototypeAction );\n\n\t\t// and make the action known to the memory manager\n\t\tthis._addInactiveAction( newAction, clipUuid, rootUuid );\n\n\t\treturn newAction;\n\n\t}\n\n\t// get an existing action\n\texistingAction( clip, optionalRoot ) {\n\n\t\tconst root = optionalRoot || this._root,\n\t\t\trootUuid = root.uuid,\n\n\t\t\tclipObject = typeof clip === 'string' ?\n\t\t\t\tAnimationClip.findByName( root, clip ) : clip,\n\n\t\t\tclipUuid = clipObject ? clipObject.uuid : clip,\n\n\t\t\tactionsForClip = this._actionsByClip[ clipUuid ];\n\n\t\tif ( actionsForClip !== undefined ) {\n\n\t\t\treturn actionsForClip.actionByRoot[ rootUuid ] || null;\n\n\t\t}\n\n\t\treturn null;\n\n\t}\n\n\t// deactivates all previously scheduled actions\n\tstopAllAction() {\n\n\t\tconst actions = this._actions,\n\t\t\tnActions = this._nActiveActions;\n\n\t\tfor ( let i = nActions - 1; i >= 0; -- i ) {\n\n\t\t\tactions[ i ].stop();\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\t// advance the time and update apply the animation\n\tupdate( deltaTime ) {\n\n\t\tdeltaTime *= this.timeScale;\n\n\t\tconst actions = this._actions,\n\t\t\tnActions = this._nActiveActions,\n\n\t\t\ttime = this.time += deltaTime,\n\t\t\ttimeDirection = Math.sign( deltaTime ),\n\n\t\t\taccuIndex = this._accuIndex ^= 1;\n\n\t\t// run active actions\n\n\t\tfor ( let i = 0; i !== nActions; ++ i ) {\n\n\t\t\tconst action = actions[ i ];\n\n\t\t\taction._update( time, deltaTime, timeDirection, accuIndex );\n\n\t\t}\n\n\t\t// update scene graph\n\n\t\tconst bindings = this._bindings,\n\t\t\tnBindings = this._nActiveBindings;\n\n\t\tfor ( let i = 0; i !== nBindings; ++ i ) {\n\n\t\t\tbindings[ i ].apply( accuIndex );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\t// Allows you to seek to a specific time in an animation.\n\tsetTime( timeInSeconds ) {\n\n\t\tthis.time = 0; // Zero out time attribute for AnimationMixer object;\n\t\tfor ( let i = 0; i < this._actions.length; i ++ ) {\n\n\t\t\tthis._actions[ i ].time = 0; // Zero out time attribute for all associated AnimationAction objects.\n\n\t\t}\n\n\t\treturn this.update( timeInSeconds ); // Update used to set exact time. Returns \"this\" AnimationMixer object.\n\n\t}\n\n\t// return this mixer's root target object\n\tgetRoot() {\n\n\t\treturn this._root;\n\n\t}\n\n\t// free all resources specific to a particular clip\n\tuncacheClip( clip ) {\n\n\t\tconst actions = this._actions,\n\t\t\tclipUuid = clip.uuid,\n\t\t\tactionsByClip = this._actionsByClip,\n\t\t\tactionsForClip = actionsByClip[ clipUuid ];\n\n\t\tif ( actionsForClip !== undefined ) {\n\n\t\t\t// note: just calling _removeInactiveAction would mess up the\n\t\t\t// iteration state and also require updating the state we can\n\t\t\t// just throw away\n\n\t\t\tconst actionsToRemove = actionsForClip.knownActions;\n\n\t\t\tfor ( let i = 0, n = actionsToRemove.length; i !== n; ++ i ) {\n\n\t\t\t\tconst action = actionsToRemove[ i ];\n\n\t\t\t\tthis._deactivateAction( action );\n\n\t\t\t\tconst cacheIndex = action._cacheIndex,\n\t\t\t\t\tlastInactiveAction = actions[ actions.length - 1 ];\n\n\t\t\t\taction._cacheIndex = null;\n\t\t\t\taction._byClipCacheIndex = null;\n\n\t\t\t\tlastInactiveAction._cacheIndex = cacheIndex;\n\t\t\t\tactions[ cacheIndex ] = lastInactiveAction;\n\t\t\t\tactions.pop();\n\n\t\t\t\tthis._removeInactiveBindingsForAction( action );\n\n\t\t\t}\n\n\t\t\tdelete actionsByClip[ clipUuid ];\n\n\t\t}\n\n\t}\n\n\t// free all resources specific to a particular root target object\n\tuncacheRoot( root ) {\n\n\t\tconst rootUuid = root.uuid,\n\t\t\tactionsByClip = this._actionsByClip;\n\n\t\tfor ( const clipUuid in actionsByClip ) {\n\n\t\t\tconst actionByRoot = actionsByClip[ clipUuid ].actionByRoot,\n\t\t\t\taction = actionByRoot[ rootUuid ];\n\n\t\t\tif ( action !== undefined ) {\n\n\t\t\t\tthis._deactivateAction( action );\n\t\t\t\tthis._removeInactiveAction( action );\n\n\t\t\t}\n\n\t\t}\n\n\t\tconst bindingsByRoot = this._bindingsByRootAndName,\n\t\t\tbindingByName = bindingsByRoot[ rootUuid ];\n\n\t\tif ( bindingByName !== undefined ) {\n\n\t\t\tfor ( const trackName in bindingByName ) {\n\n\t\t\t\tconst binding = bindingByName[ trackName ];\n\t\t\t\tbinding.restoreOriginalState();\n\t\t\t\tthis._removeInactiveBinding( binding );\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n\t// remove a targeted clip from the cache\n\tuncacheAction( clip, optionalRoot ) {\n\n\t\tconst action = this.existingAction( clip, optionalRoot );\n\n\t\tif ( action !== null ) {\n\n\t\t\tthis._deactivateAction( action );\n\t\t\tthis._removeInactiveAction( action );\n\n\t\t}\n\n\t}\n\n}\n\nclass Uniform {\n\n\tconstructor( value ) {\n\n\t\tthis.value = value;\n\n\t}\n\n\tclone() {\n\n\t\treturn new Uniform( this.value.clone === undefined ? this.value : this.value.clone() );\n\n\t}\n\n}\n\nlet _id = 0;\n\nclass UniformsGroup extends EventDispatcher {\n\n\tconstructor() {\n\n\t\tsuper();\n\n\t\tthis.isUniformsGroup = true;\n\n\t\tObject.defineProperty( this, 'id', { value: _id ++ } );\n\n\t\tthis.name = '';\n\n\t\tthis.usage = StaticDrawUsage;\n\t\tthis.uniforms = [];\n\n\t}\n\n\tadd( uniform ) {\n\n\t\tthis.uniforms.push( uniform );\n\n\t\treturn this;\n\n\t}\n\n\tremove( uniform ) {\n\n\t\tconst index = this.uniforms.indexOf( uniform );\n\n\t\tif ( index !== - 1 ) this.uniforms.splice( index, 1 );\n\n\t\treturn this;\n\n\t}\n\n\tsetName( name ) {\n\n\t\tthis.name = name;\n\n\t\treturn this;\n\n\t}\n\n\tsetUsage( value ) {\n\n\t\tthis.usage = value;\n\n\t\treturn this;\n\n\t}\n\n\tdispose() {\n\n\t\tthis.dispatchEvent( { type: 'dispose' } );\n\n\t\treturn this;\n\n\t}\n\n\tcopy( source ) {\n\n\t\tthis.name = source.name;\n\t\tthis.usage = source.usage;\n\n\t\tconst uniformsSource = source.uniforms;\n\n\t\tthis.uniforms.length = 0;\n\n\t\tfor ( let i = 0, l = uniformsSource.length; i < l; i ++ ) {\n\n\t\t\tconst uniforms = Array.isArray( uniformsSource[ i ] ) ? uniformsSource[ i ] : [ uniformsSource[ i ] ];\n\n\t\t\tfor ( let j = 0; j < uniforms.length; j ++ ) {\n\n\t\t\t\tthis.uniforms.push( uniforms[ j ].clone() );\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tclone() {\n\n\t\treturn new this.constructor().copy( this );\n\n\t}\n\n}\n\nclass InstancedInterleavedBuffer extends InterleavedBuffer {\n\n\tconstructor( array, stride, meshPerAttribute = 1 ) {\n\n\t\tsuper( array, stride );\n\n\t\tthis.isInstancedInterleavedBuffer = true;\n\n\t\tthis.meshPerAttribute = meshPerAttribute;\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source );\n\n\t\tthis.meshPerAttribute = source.meshPerAttribute;\n\n\t\treturn this;\n\n\t}\n\n\tclone( data ) {\n\n\t\tconst ib = super.clone( data );\n\n\t\tib.meshPerAttribute = this.meshPerAttribute;\n\n\t\treturn ib;\n\n\t}\n\n\ttoJSON( data ) {\n\n\t\tconst json = super.toJSON( data );\n\n\t\tjson.isInstancedInterleavedBuffer = true;\n\t\tjson.meshPerAttribute = this.meshPerAttribute;\n\n\t\treturn json;\n\n\t}\n\n}\n\nclass GLBufferAttribute {\n\n\tconstructor( buffer, type, itemSize, elementSize, count ) {\n\n\t\tthis.isGLBufferAttribute = true;\n\n\t\tthis.name = '';\n\n\t\tthis.buffer = buffer;\n\t\tthis.type = type;\n\t\tthis.itemSize = itemSize;\n\t\tthis.elementSize = elementSize;\n\t\tthis.count = count;\n\n\t\tthis.version = 0;\n\n\t}\n\n\tset needsUpdate( value ) {\n\n\t\tif ( value === true ) this.version ++;\n\n\t}\n\n\tsetBuffer( buffer ) {\n\n\t\tthis.buffer = buffer;\n\n\t\treturn this;\n\n\t}\n\n\tsetType( type, elementSize ) {\n\n\t\tthis.type = type;\n\t\tthis.elementSize = elementSize;\n\n\t\treturn this;\n\n\t}\n\n\tsetItemSize( itemSize ) {\n\n\t\tthis.itemSize = itemSize;\n\n\t\treturn this;\n\n\t}\n\n\tsetCount( count ) {\n\n\t\tthis.count = count;\n\n\t\treturn this;\n\n\t}\n\n}\n\nconst _matrix = /*@__PURE__*/ new Matrix4();\n\nclass Raycaster {\n\n\tconstructor( origin, direction, near = 0, far = Infinity ) {\n\n\t\tthis.ray = new Ray( origin, direction );\n\t\t// direction is assumed to be normalized (for accurate distance calculations)\n\n\t\tthis.near = near;\n\t\tthis.far = far;\n\t\tthis.camera = null;\n\t\tthis.layers = new Layers();\n\n\t\tthis.params = {\n\t\t\tMesh: {},\n\t\t\tLine: { threshold: 1 },\n\t\t\tLOD: {},\n\t\t\tPoints: { threshold: 1 },\n\t\t\tSprite: {}\n\t\t};\n\n\t}\n\n\tset( origin, direction ) {\n\n\t\t// direction is assumed to be normalized (for accurate distance calculations)\n\n\t\tthis.ray.set( origin, direction );\n\n\t}\n\n\tsetFromCamera( coords, camera ) {\n\n\t\tif ( camera.isPerspectiveCamera ) {\n\n\t\t\tthis.ray.origin.setFromMatrixPosition( camera.matrixWorld );\n\t\t\tthis.ray.direction.set( coords.x, coords.y, 0.5 ).unproject( camera ).sub( this.ray.origin ).normalize();\n\t\t\tthis.camera = camera;\n\n\t\t} else if ( camera.isOrthographicCamera ) {\n\n\t\t\tthis.ray.origin.set( coords.x, coords.y, ( camera.near + camera.far ) / ( camera.near - camera.far ) ).unproject( camera ); // set origin in plane of camera\n\t\t\tthis.ray.direction.set( 0, 0, - 1 ).transformDirection( camera.matrixWorld );\n\t\t\tthis.camera = camera;\n\n\t\t} else {\n\n\t\t\tconsole.error( 'THREE.Raycaster: Unsupported camera type: ' + camera.type );\n\n\t\t}\n\n\t}\n\n\tsetFromXRController( controller ) {\n\n\t\t_matrix.identity().extractRotation( controller.matrixWorld );\n\n\t\tthis.ray.origin.setFromMatrixPosition( controller.matrixWorld );\n\t\tthis.ray.direction.set( 0, 0, - 1 ).applyMatrix4( _matrix );\n\n\t\treturn this;\n\n\t}\n\n\tintersectObject( object, recursive = true, intersects = [] ) {\n\n\t\tintersect( object, this, intersects, recursive );\n\n\t\tintersects.sort( ascSort );\n\n\t\treturn intersects;\n\n\t}\n\n\tintersectObjects( objects, recursive = true, intersects = [] ) {\n\n\t\tfor ( let i = 0, l = objects.length; i < l; i ++ ) {\n\n\t\t\tintersect( objects[ i ], this, intersects, recursive );\n\n\t\t}\n\n\t\tintersects.sort( ascSort );\n\n\t\treturn intersects;\n\n\t}\n\n}\n\nfunction ascSort( a, b ) {\n\n\treturn a.distance - b.distance;\n\n}\n\nfunction intersect( object, raycaster, intersects, recursive ) {\n\n\tif ( object.layers.test( raycaster.layers ) ) {\n\n\t\tobject.raycast( raycaster, intersects );\n\n\t}\n\n\tif ( recursive === true ) {\n\n\t\tconst children = object.children;\n\n\t\tfor ( let i = 0, l = children.length; i < l; i ++ ) {\n\n\t\t\tintersect( children[ i ], raycaster, intersects, true );\n\n\t\t}\n\n\t}\n\n}\n\n/**\n * Ref: https://en.wikipedia.org/wiki/Spherical_coordinate_system\n *\n * phi (the polar angle) is measured from the positive y-axis. The positive y-axis is up.\n * theta (the azimuthal angle) is measured from the positive z-axis.\n */\nclass Spherical {\n\n\tconstructor( radius = 1, phi = 0, theta = 0 ) {\n\n\t\tthis.radius = radius;\n\t\tthis.phi = phi; // polar angle\n\t\tthis.theta = theta; // azimuthal angle\n\n\t\treturn this;\n\n\t}\n\n\tset( radius, phi, theta ) {\n\n\t\tthis.radius = radius;\n\t\tthis.phi = phi;\n\t\tthis.theta = theta;\n\n\t\treturn this;\n\n\t}\n\n\tcopy( other ) {\n\n\t\tthis.radius = other.radius;\n\t\tthis.phi = other.phi;\n\t\tthis.theta = other.theta;\n\n\t\treturn this;\n\n\t}\n\n\t// restrict phi to be between EPS and PI-EPS\n\tmakeSafe() {\n\n\t\tconst EPS = 0.000001;\n\t\tthis.phi = Math.max( EPS, Math.min( Math.PI - EPS, this.phi ) );\n\n\t\treturn this;\n\n\t}\n\n\tsetFromVector3( v ) {\n\n\t\treturn this.setFromCartesianCoords( v.x, v.y, v.z );\n\n\t}\n\n\tsetFromCartesianCoords( x, y, z ) {\n\n\t\tthis.radius = Math.sqrt( x * x + y * y + z * z );\n\n\t\tif ( this.radius === 0 ) {\n\n\t\t\tthis.theta = 0;\n\t\t\tthis.phi = 0;\n\n\t\t} else {\n\n\t\t\tthis.theta = Math.atan2( x, z );\n\t\t\tthis.phi = Math.acos( clamp( y / this.radius, - 1, 1 ) );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tclone() {\n\n\t\treturn new this.constructor().copy( this );\n\n\t}\n\n}\n\n/**\n * Ref: https://en.wikipedia.org/wiki/Cylindrical_coordinate_system\n */\n\nclass Cylindrical {\n\n\tconstructor( radius = 1, theta = 0, y = 0 ) {\n\n\t\tthis.radius = radius; // distance from the origin to a point in the x-z plane\n\t\tthis.theta = theta; // counterclockwise angle in the x-z plane measured in radians from the positive z-axis\n\t\tthis.y = y; // height above the x-z plane\n\n\t\treturn this;\n\n\t}\n\n\tset( radius, theta, y ) {\n\n\t\tthis.radius = radius;\n\t\tthis.theta = theta;\n\t\tthis.y = y;\n\n\t\treturn this;\n\n\t}\n\n\tcopy( other ) {\n\n\t\tthis.radius = other.radius;\n\t\tthis.theta = other.theta;\n\t\tthis.y = other.y;\n\n\t\treturn this;\n\n\t}\n\n\tsetFromVector3( v ) {\n\n\t\treturn this.setFromCartesianCoords( v.x, v.y, v.z );\n\n\t}\n\n\tsetFromCartesianCoords( x, y, z ) {\n\n\t\tthis.radius = Math.sqrt( x * x + z * z );\n\t\tthis.theta = Math.atan2( x, z );\n\t\tthis.y = y;\n\n\t\treturn this;\n\n\t}\n\n\tclone() {\n\n\t\treturn new this.constructor().copy( this );\n\n\t}\n\n}\n\nconst _vector$4 = /*@__PURE__*/ new Vector2();\n\nclass Box2 {\n\n\tconstructor( min = new Vector2( + Infinity, + Infinity ), max = new Vector2( - Infinity, - Infinity ) ) {\n\n\t\tthis.isBox2 = true;\n\n\t\tthis.min = min;\n\t\tthis.max = max;\n\n\t}\n\n\tset( min, max ) {\n\n\t\tthis.min.copy( min );\n\t\tthis.max.copy( max );\n\n\t\treturn this;\n\n\t}\n\n\tsetFromPoints( points ) {\n\n\t\tthis.makeEmpty();\n\n\t\tfor ( let i = 0, il = points.length; i < il; i ++ ) {\n\n\t\t\tthis.expandByPoint( points[ i ] );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tsetFromCenterAndSize( center, size ) {\n\n\t\tconst halfSize = _vector$4.copy( size ).multiplyScalar( 0.5 );\n\t\tthis.min.copy( center ).sub( halfSize );\n\t\tthis.max.copy( center ).add( halfSize );\n\n\t\treturn this;\n\n\t}\n\n\tclone() {\n\n\t\treturn new this.constructor().copy( this );\n\n\t}\n\n\tcopy( box ) {\n\n\t\tthis.min.copy( box.min );\n\t\tthis.max.copy( box.max );\n\n\t\treturn this;\n\n\t}\n\n\tmakeEmpty() {\n\n\t\tthis.min.x = this.min.y = + Infinity;\n\t\tthis.max.x = this.max.y = - Infinity;\n\n\t\treturn this;\n\n\t}\n\n\tisEmpty() {\n\n\t\t// this is a more robust check for empty than ( volume <= 0 ) because volume can get positive with two negative axes\n\n\t\treturn ( this.max.x < this.min.x ) || ( this.max.y < this.min.y );\n\n\t}\n\n\tgetCenter( target ) {\n\n\t\treturn this.isEmpty() ? target.set( 0, 0 ) : target.addVectors( this.min, this.max ).multiplyScalar( 0.5 );\n\n\t}\n\n\tgetSize( target ) {\n\n\t\treturn this.isEmpty() ? target.set( 0, 0 ) : target.subVectors( this.max, this.min );\n\n\t}\n\n\texpandByPoint( point ) {\n\n\t\tthis.min.min( point );\n\t\tthis.max.max( point );\n\n\t\treturn this;\n\n\t}\n\n\texpandByVector( vector ) {\n\n\t\tthis.min.sub( vector );\n\t\tthis.max.add( vector );\n\n\t\treturn this;\n\n\t}\n\n\texpandByScalar( scalar ) {\n\n\t\tthis.min.addScalar( - scalar );\n\t\tthis.max.addScalar( scalar );\n\n\t\treturn this;\n\n\t}\n\n\tcontainsPoint( point ) {\n\n\t\treturn point.x < this.min.x || point.x > this.max.x ||\n\t\t\tpoint.y < this.min.y || point.y > this.max.y ? false : true;\n\n\t}\n\n\tcontainsBox( box ) {\n\n\t\treturn this.min.x <= box.min.x && box.max.x <= this.max.x &&\n\t\t\tthis.min.y <= box.min.y && box.max.y <= this.max.y;\n\n\t}\n\n\tgetParameter( point, target ) {\n\n\t\t// This can potentially have a divide by zero if the box\n\t\t// has a size dimension of 0.\n\n\t\treturn target.set(\n\t\t\t( point.x - this.min.x ) / ( this.max.x - this.min.x ),\n\t\t\t( point.y - this.min.y ) / ( this.max.y - this.min.y )\n\t\t);\n\n\t}\n\n\tintersectsBox( box ) {\n\n\t\t// using 4 splitting planes to rule out intersections\n\n\t\treturn box.max.x < this.min.x || box.min.x > this.max.x ||\n\t\t\tbox.max.y < this.min.y || box.min.y > this.max.y ? false : true;\n\n\t}\n\n\tclampPoint( point, target ) {\n\n\t\treturn target.copy( point ).clamp( this.min, this.max );\n\n\t}\n\n\tdistanceToPoint( point ) {\n\n\t\treturn this.clampPoint( point, _vector$4 ).distanceTo( point );\n\n\t}\n\n\tintersect( box ) {\n\n\t\tthis.min.max( box.min );\n\t\tthis.max.min( box.max );\n\n\t\tif ( this.isEmpty() ) this.makeEmpty();\n\n\t\treturn this;\n\n\t}\n\n\tunion( box ) {\n\n\t\tthis.min.min( box.min );\n\t\tthis.max.max( box.max );\n\n\t\treturn this;\n\n\t}\n\n\ttranslate( offset ) {\n\n\t\tthis.min.add( offset );\n\t\tthis.max.add( offset );\n\n\t\treturn this;\n\n\t}\n\n\tequals( box ) {\n\n\t\treturn box.min.equals( this.min ) && box.max.equals( this.max );\n\n\t}\n\n}\n\nconst _startP = /*@__PURE__*/ new Vector3();\nconst _startEnd = /*@__PURE__*/ new Vector3();\n\nclass Line3 {\n\n\tconstructor( start = new Vector3(), end = new Vector3() ) {\n\n\t\tthis.start = start;\n\t\tthis.end = end;\n\n\t}\n\n\tset( start, end ) {\n\n\t\tthis.start.copy( start );\n\t\tthis.end.copy( end );\n\n\t\treturn this;\n\n\t}\n\n\tcopy( line ) {\n\n\t\tthis.start.copy( line.start );\n\t\tthis.end.copy( line.end );\n\n\t\treturn this;\n\n\t}\n\n\tgetCenter( target ) {\n\n\t\treturn target.addVectors( this.start, this.end ).multiplyScalar( 0.5 );\n\n\t}\n\n\tdelta( target ) {\n\n\t\treturn target.subVectors( this.end, this.start );\n\n\t}\n\n\tdistanceSq() {\n\n\t\treturn this.start.distanceToSquared( this.end );\n\n\t}\n\n\tdistance() {\n\n\t\treturn this.start.distanceTo( this.end );\n\n\t}\n\n\tat( t, target ) {\n\n\t\treturn this.delta( target ).multiplyScalar( t ).add( this.start );\n\n\t}\n\n\tclosestPointToPointParameter( point, clampToLine ) {\n\n\t\t_startP.subVectors( point, this.start );\n\t\t_startEnd.subVectors( this.end, this.start );\n\n\t\tconst startEnd2 = _startEnd.dot( _startEnd );\n\t\tconst startEnd_startP = _startEnd.dot( _startP );\n\n\t\tlet t = startEnd_startP / startEnd2;\n\n\t\tif ( clampToLine ) {\n\n\t\t\tt = clamp( t, 0, 1 );\n\n\t\t}\n\n\t\treturn t;\n\n\t}\n\n\tclosestPointToPoint( point, clampToLine, target ) {\n\n\t\tconst t = this.closestPointToPointParameter( point, clampToLine );\n\n\t\treturn this.delta( target ).multiplyScalar( t ).add( this.start );\n\n\t}\n\n\tapplyMatrix4( matrix ) {\n\n\t\tthis.start.applyMatrix4( matrix );\n\t\tthis.end.applyMatrix4( matrix );\n\n\t\treturn this;\n\n\t}\n\n\tequals( line ) {\n\n\t\treturn line.start.equals( this.start ) && line.end.equals( this.end );\n\n\t}\n\n\tclone() {\n\n\t\treturn new this.constructor().copy( this );\n\n\t}\n\n}\n\nconst _vector$3 = /*@__PURE__*/ new Vector3();\n\nclass SpotLightHelper extends Object3D {\n\n\tconstructor( light, color ) {\n\n\t\tsuper();\n\n\t\tthis.light = light;\n\n\t\tthis.matrixAutoUpdate = false;\n\n\t\tthis.color = color;\n\n\t\tthis.type = 'SpotLightHelper';\n\n\t\tconst geometry = new BufferGeometry();\n\n\t\tconst positions = [\n\t\t\t0, 0, 0, \t0, 0, 1,\n\t\t\t0, 0, 0, \t1, 0, 1,\n\t\t\t0, 0, 0,\t- 1, 0, 1,\n\t\t\t0, 0, 0, \t0, 1, 1,\n\t\t\t0, 0, 0, \t0, - 1, 1\n\t\t];\n\n\t\tfor ( let i = 0, j = 1, l = 32; i < l; i ++, j ++ ) {\n\n\t\t\tconst p1 = ( i / l ) * Math.PI * 2;\n\t\t\tconst p2 = ( j / l ) * Math.PI * 2;\n\n\t\t\tpositions.push(\n\t\t\t\tMath.cos( p1 ), Math.sin( p1 ), 1,\n\t\t\t\tMath.cos( p2 ), Math.sin( p2 ), 1\n\t\t\t);\n\n\t\t}\n\n\t\tgeometry.setAttribute( 'position', new Float32BufferAttribute( positions, 3 ) );\n\n\t\tconst material = new LineBasicMaterial( { fog: false, toneMapped: false } );\n\n\t\tthis.cone = new LineSegments( geometry, material );\n\t\tthis.add( this.cone );\n\n\t\tthis.update();\n\n\t}\n\n\tdispose() {\n\n\t\tthis.cone.geometry.dispose();\n\t\tthis.cone.material.dispose();\n\n\t}\n\n\tupdate() {\n\n\t\tthis.light.updateWorldMatrix( true, false );\n\t\tthis.light.target.updateWorldMatrix( true, false );\n\n\t\t// update the local matrix based on the parent and light target transforms\n\t\tif ( this.parent ) {\n\n\t\t\tthis.parent.updateWorldMatrix( true );\n\n\t\t\tthis.matrix\n\t\t\t\t.copy( this.parent.matrixWorld )\n\t\t\t\t.invert()\n\t\t\t\t.multiply( this.light.matrixWorld );\n\n\t\t} else {\n\n\t\t\tthis.matrix.copy( this.light.matrixWorld );\n\n\t\t}\n\n\t\tthis.matrixWorld.copy( this.light.matrixWorld );\n\n\t\tconst coneLength = this.light.distance ? this.light.distance : 1000;\n\t\tconst coneWidth = coneLength * Math.tan( this.light.angle );\n\n\t\tthis.cone.scale.set( coneWidth, coneWidth, coneLength );\n\n\t\t_vector$3.setFromMatrixPosition( this.light.target.matrixWorld );\n\n\t\tthis.cone.lookAt( _vector$3 );\n\n\t\tif ( this.color !== undefined ) {\n\n\t\t\tthis.cone.material.color.set( this.color );\n\n\t\t} else {\n\n\t\t\tthis.cone.material.color.copy( this.light.color );\n\n\t\t}\n\n\t}\n\n}\n\nconst _vector$2 = /*@__PURE__*/ new Vector3();\nconst _boneMatrix = /*@__PURE__*/ new Matrix4();\nconst _matrixWorldInv = /*@__PURE__*/ new Matrix4();\n\n\nclass SkeletonHelper extends LineSegments {\n\n\tconstructor( object ) {\n\n\t\tconst bones = getBoneList( object );\n\n\t\tconst geometry = new BufferGeometry();\n\n\t\tconst vertices = [];\n\t\tconst colors = [];\n\n\t\tconst color1 = new Color( 0, 0, 1 );\n\t\tconst color2 = new Color( 0, 1, 0 );\n\n\t\tfor ( let i = 0; i < bones.length; i ++ ) {\n\n\t\t\tconst bone = bones[ i ];\n\n\t\t\tif ( bone.parent && bone.parent.isBone ) {\n\n\t\t\t\tvertices.push( 0, 0, 0 );\n\t\t\t\tvertices.push( 0, 0, 0 );\n\t\t\t\tcolors.push( color1.r, color1.g, color1.b );\n\t\t\t\tcolors.push( color2.r, color2.g, color2.b );\n\n\t\t\t}\n\n\t\t}\n\n\t\tgeometry.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\n\t\tgeometry.setAttribute( 'color', new Float32BufferAttribute( colors, 3 ) );\n\n\t\tconst material = new LineBasicMaterial( { vertexColors: true, depthTest: false, depthWrite: false, toneMapped: false, transparent: true } );\n\n\t\tsuper( geometry, material );\n\n\t\tthis.isSkeletonHelper = true;\n\n\t\tthis.type = 'SkeletonHelper';\n\n\t\tthis.root = object;\n\t\tthis.bones = bones;\n\n\t\tthis.matrix = object.matrixWorld;\n\t\tthis.matrixAutoUpdate = false;\n\n\t}\n\n\tupdateMatrixWorld( force ) {\n\n\t\tconst bones = this.bones;\n\n\t\tconst geometry = this.geometry;\n\t\tconst position = geometry.getAttribute( 'position' );\n\n\t\t_matrixWorldInv.copy( this.root.matrixWorld ).invert();\n\n\t\tfor ( let i = 0, j = 0; i < bones.length; i ++ ) {\n\n\t\t\tconst bone = bones[ i ];\n\n\t\t\tif ( bone.parent && bone.parent.isBone ) {\n\n\t\t\t\t_boneMatrix.multiplyMatrices( _matrixWorldInv, bone.matrixWorld );\n\t\t\t\t_vector$2.setFromMatrixPosition( _boneMatrix );\n\t\t\t\tposition.setXYZ( j, _vector$2.x, _vector$2.y, _vector$2.z );\n\n\t\t\t\t_boneMatrix.multiplyMatrices( _matrixWorldInv, bone.parent.matrixWorld );\n\t\t\t\t_vector$2.setFromMatrixPosition( _boneMatrix );\n\t\t\t\tposition.setXYZ( j + 1, _vector$2.x, _vector$2.y, _vector$2.z );\n\n\t\t\t\tj += 2;\n\n\t\t\t}\n\n\t\t}\n\n\t\tgeometry.getAttribute( 'position' ).needsUpdate = true;\n\n\t\tsuper.updateMatrixWorld( force );\n\n\t}\n\n\tdispose() {\n\n\t\tthis.geometry.dispose();\n\t\tthis.material.dispose();\n\n\t}\n\n}\n\n\nfunction getBoneList( object ) {\n\n\tconst boneList = [];\n\n\tif ( object.isBone === true ) {\n\n\t\tboneList.push( object );\n\n\t}\n\n\tfor ( let i = 0; i < object.children.length; i ++ ) {\n\n\t\tboneList.push.apply( boneList, getBoneList( object.children[ i ] ) );\n\n\t}\n\n\treturn boneList;\n\n}\n\nclass PointLightHelper extends Mesh {\n\n\tconstructor( light, sphereSize, color ) {\n\n\t\tconst geometry = new SphereGeometry( sphereSize, 4, 2 );\n\t\tconst material = new MeshBasicMaterial( { wireframe: true, fog: false, toneMapped: false } );\n\n\t\tsuper( geometry, material );\n\n\t\tthis.light = light;\n\n\t\tthis.color = color;\n\n\t\tthis.type = 'PointLightHelper';\n\n\t\tthis.matrix = this.light.matrixWorld;\n\t\tthis.matrixAutoUpdate = false;\n\n\t\tthis.update();\n\n\n\t\t/*\n\t// TODO: delete this comment?\n\tconst distanceGeometry = new THREE.IcosahedronGeometry( 1, 2 );\n\tconst distanceMaterial = new THREE.MeshBasicMaterial( { color: hexColor, fog: false, wireframe: true, opacity: 0.1, transparent: true } );\n\n\tthis.lightSphere = new THREE.Mesh( bulbGeometry, bulbMaterial );\n\tthis.lightDistance = new THREE.Mesh( distanceGeometry, distanceMaterial );\n\n\tconst d = light.distance;\n\n\tif ( d === 0.0 ) {\n\n\t\tthis.lightDistance.visible = false;\n\n\t} else {\n\n\t\tthis.lightDistance.scale.set( d, d, d );\n\n\t}\n\n\tthis.add( this.lightDistance );\n\t*/\n\n\t}\n\n\tdispose() {\n\n\t\tthis.geometry.dispose();\n\t\tthis.material.dispose();\n\n\t}\n\n\tupdate() {\n\n\t\tthis.light.updateWorldMatrix( true, false );\n\n\t\tif ( this.color !== undefined ) {\n\n\t\t\tthis.material.color.set( this.color );\n\n\t\t} else {\n\n\t\t\tthis.material.color.copy( this.light.color );\n\n\t\t}\n\n\t\t/*\n\t\tconst d = this.light.distance;\n\n\t\tif ( d === 0.0 ) {\n\n\t\t\tthis.lightDistance.visible = false;\n\n\t\t} else {\n\n\t\t\tthis.lightDistance.visible = true;\n\t\t\tthis.lightDistance.scale.set( d, d, d );\n\n\t\t}\n\t\t*/\n\n\t}\n\n}\n\nconst _vector$1 = /*@__PURE__*/ new Vector3();\nconst _color1 = /*@__PURE__*/ new Color();\nconst _color2 = /*@__PURE__*/ new Color();\n\nclass HemisphereLightHelper extends Object3D {\n\n\tconstructor( light, size, color ) {\n\n\t\tsuper();\n\n\t\tthis.light = light;\n\n\t\tthis.matrix = light.matrixWorld;\n\t\tthis.matrixAutoUpdate = false;\n\n\t\tthis.color = color;\n\n\t\tthis.type = 'HemisphereLightHelper';\n\n\t\tconst geometry = new OctahedronGeometry( size );\n\t\tgeometry.rotateY( Math.PI * 0.5 );\n\n\t\tthis.material = new MeshBasicMaterial( { wireframe: true, fog: false, toneMapped: false } );\n\t\tif ( this.color === undefined ) this.material.vertexColors = true;\n\n\t\tconst position = geometry.getAttribute( 'position' );\n\t\tconst colors = new Float32Array( position.count * 3 );\n\n\t\tgeometry.setAttribute( 'color', new BufferAttribute( colors, 3 ) );\n\n\t\tthis.add( new Mesh( geometry, this.material ) );\n\n\t\tthis.update();\n\n\t}\n\n\tdispose() {\n\n\t\tthis.children[ 0 ].geometry.dispose();\n\t\tthis.children[ 0 ].material.dispose();\n\n\t}\n\n\tupdate() {\n\n\t\tconst mesh = this.children[ 0 ];\n\n\t\tif ( this.color !== undefined ) {\n\n\t\t\tthis.material.color.set( this.color );\n\n\t\t} else {\n\n\t\t\tconst colors = mesh.geometry.getAttribute( 'color' );\n\n\t\t\t_color1.copy( this.light.color );\n\t\t\t_color2.copy( this.light.groundColor );\n\n\t\t\tfor ( let i = 0, l = colors.count; i < l; i ++ ) {\n\n\t\t\t\tconst color = ( i < ( l / 2 ) ) ? _color1 : _color2;\n\n\t\t\t\tcolors.setXYZ( i, color.r, color.g, color.b );\n\n\t\t\t}\n\n\t\t\tcolors.needsUpdate = true;\n\n\t\t}\n\n\t\tthis.light.updateWorldMatrix( true, false );\n\n\t\tmesh.lookAt( _vector$1.setFromMatrixPosition( this.light.matrixWorld ).negate() );\n\n\t}\n\n}\n\nclass GridHelper extends LineSegments {\n\n\tconstructor( size = 10, divisions = 10, color1 = 0x444444, color2 = 0x888888 ) {\n\n\t\tcolor1 = new Color( color1 );\n\t\tcolor2 = new Color( color2 );\n\n\t\tconst center = divisions / 2;\n\t\tconst step = size / divisions;\n\t\tconst halfSize = size / 2;\n\n\t\tconst vertices = [], colors = [];\n\n\t\tfor ( let i = 0, j = 0, k = - halfSize; i <= divisions; i ++, k += step ) {\n\n\t\t\tvertices.push( - halfSize, 0, k, halfSize, 0, k );\n\t\t\tvertices.push( k, 0, - halfSize, k, 0, halfSize );\n\n\t\t\tconst color = i === center ? color1 : color2;\n\n\t\t\tcolor.toArray( colors, j ); j += 3;\n\t\t\tcolor.toArray( colors, j ); j += 3;\n\t\t\tcolor.toArray( colors, j ); j += 3;\n\t\t\tcolor.toArray( colors, j ); j += 3;\n\n\t\t}\n\n\t\tconst geometry = new BufferGeometry();\n\t\tgeometry.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\n\t\tgeometry.setAttribute( 'color', new Float32BufferAttribute( colors, 3 ) );\n\n\t\tconst material = new LineBasicMaterial( { vertexColors: true, toneMapped: false } );\n\n\t\tsuper( geometry, material );\n\n\t\tthis.type = 'GridHelper';\n\n\t}\n\n\tdispose() {\n\n\t\tthis.geometry.dispose();\n\t\tthis.material.dispose();\n\n\t}\n\n}\n\nclass PolarGridHelper extends LineSegments {\n\n\tconstructor( radius = 10, sectors = 16, rings = 8, divisions = 64, color1 = 0x444444, color2 = 0x888888 ) {\n\n\t\tcolor1 = new Color( color1 );\n\t\tcolor2 = new Color( color2 );\n\n\t\tconst vertices = [];\n\t\tconst colors = [];\n\n\t\t// create the sectors\n\n\t\tif ( sectors > 1 ) {\n\n\t\t\tfor ( let i = 0; i < sectors; i ++ ) {\n\n\t\t\t\tconst v = ( i / sectors ) * ( Math.PI * 2 );\n\n\t\t\t\tconst x = Math.sin( v ) * radius;\n\t\t\t\tconst z = Math.cos( v ) * radius;\n\n\t\t\t\tvertices.push( 0, 0, 0 );\n\t\t\t\tvertices.push( x, 0, z );\n\n\t\t\t\tconst color = ( i & 1 ) ? color1 : color2;\n\n\t\t\t\tcolors.push( color.r, color.g, color.b );\n\t\t\t\tcolors.push( color.r, color.g, color.b );\n\n\t\t\t}\n\n\t\t}\n\n\t\t// create the rings\n\n\t\tfor ( let i = 0; i < rings; i ++ ) {\n\n\t\t\tconst color = ( i & 1 ) ? color1 : color2;\n\n\t\t\tconst r = radius - ( radius / rings * i );\n\n\t\t\tfor ( let j = 0; j < divisions; j ++ ) {\n\n\t\t\t\t// first vertex\n\n\t\t\t\tlet v = ( j / divisions ) * ( Math.PI * 2 );\n\n\t\t\t\tlet x = Math.sin( v ) * r;\n\t\t\t\tlet z = Math.cos( v ) * r;\n\n\t\t\t\tvertices.push( x, 0, z );\n\t\t\t\tcolors.push( color.r, color.g, color.b );\n\n\t\t\t\t// second vertex\n\n\t\t\t\tv = ( ( j + 1 ) / divisions ) * ( Math.PI * 2 );\n\n\t\t\t\tx = Math.sin( v ) * r;\n\t\t\t\tz = Math.cos( v ) * r;\n\n\t\t\t\tvertices.push( x, 0, z );\n\t\t\t\tcolors.push( color.r, color.g, color.b );\n\n\t\t\t}\n\n\t\t}\n\n\t\tconst geometry = new BufferGeometry();\n\t\tgeometry.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\n\t\tgeometry.setAttribute( 'color', new Float32BufferAttribute( colors, 3 ) );\n\n\t\tconst material = new LineBasicMaterial( { vertexColors: true, toneMapped: false } );\n\n\t\tsuper( geometry, material );\n\n\t\tthis.type = 'PolarGridHelper';\n\n\t}\n\n\tdispose() {\n\n\t\tthis.geometry.dispose();\n\t\tthis.material.dispose();\n\n\t}\n\n}\n\nconst _v1 = /*@__PURE__*/ new Vector3();\nconst _v2 = /*@__PURE__*/ new Vector3();\nconst _v3 = /*@__PURE__*/ new Vector3();\n\nclass DirectionalLightHelper extends Object3D {\n\n\tconstructor( light, size, color ) {\n\n\t\tsuper();\n\n\t\tthis.light = light;\n\n\t\tthis.matrix = light.matrixWorld;\n\t\tthis.matrixAutoUpdate = false;\n\n\t\tthis.color = color;\n\n\t\tthis.type = 'DirectionalLightHelper';\n\n\t\tif ( size === undefined ) size = 1;\n\n\t\tlet geometry = new BufferGeometry();\n\t\tgeometry.setAttribute( 'position', new Float32BufferAttribute( [\n\t\t\t- size, size, 0,\n\t\t\tsize, size, 0,\n\t\t\tsize, - size, 0,\n\t\t\t- size, - size, 0,\n\t\t\t- size, size, 0\n\t\t], 3 ) );\n\n\t\tconst material = new LineBasicMaterial( { fog: false, toneMapped: false } );\n\n\t\tthis.lightPlane = new Line( geometry, material );\n\t\tthis.add( this.lightPlane );\n\n\t\tgeometry = new BufferGeometry();\n\t\tgeometry.setAttribute( 'position', new Float32BufferAttribute( [ 0, 0, 0, 0, 0, 1 ], 3 ) );\n\n\t\tthis.targetLine = new Line( geometry, material );\n\t\tthis.add( this.targetLine );\n\n\t\tthis.update();\n\n\t}\n\n\tdispose() {\n\n\t\tthis.lightPlane.geometry.dispose();\n\t\tthis.lightPlane.material.dispose();\n\t\tthis.targetLine.geometry.dispose();\n\t\tthis.targetLine.material.dispose();\n\n\t}\n\n\tupdate() {\n\n\t\tthis.light.updateWorldMatrix( true, false );\n\t\tthis.light.target.updateWorldMatrix( true, false );\n\n\t\t_v1.setFromMatrixPosition( this.light.matrixWorld );\n\t\t_v2.setFromMatrixPosition( this.light.target.matrixWorld );\n\t\t_v3.subVectors( _v2, _v1 );\n\n\t\tthis.lightPlane.lookAt( _v2 );\n\n\t\tif ( this.color !== undefined ) {\n\n\t\t\tthis.lightPlane.material.color.set( this.color );\n\t\t\tthis.targetLine.material.color.set( this.color );\n\n\t\t} else {\n\n\t\t\tthis.lightPlane.material.color.copy( this.light.color );\n\t\t\tthis.targetLine.material.color.copy( this.light.color );\n\n\t\t}\n\n\t\tthis.targetLine.lookAt( _v2 );\n\t\tthis.targetLine.scale.z = _v3.length();\n\n\t}\n\n}\n\nconst _vector = /*@__PURE__*/ new Vector3();\nconst _camera = /*@__PURE__*/ new Camera();\n\n/**\n *\t- shows frustum, line of sight and up of the camera\n *\t- suitable for fast updates\n * \t- based on frustum visualization in lightgl.js shadowmap example\n *\t\thttps://github.com/evanw/lightgl.js/blob/master/tests/shadowmap.html\n */\n\nclass CameraHelper extends LineSegments {\n\n\tconstructor( camera ) {\n\n\t\tconst geometry = new BufferGeometry();\n\t\tconst material = new LineBasicMaterial( { color: 0xffffff, vertexColors: true, toneMapped: false } );\n\n\t\tconst vertices = [];\n\t\tconst colors = [];\n\n\t\tconst pointMap = {};\n\n\t\t// near\n\n\t\taddLine( 'n1', 'n2' );\n\t\taddLine( 'n2', 'n4' );\n\t\taddLine( 'n4', 'n3' );\n\t\taddLine( 'n3', 'n1' );\n\n\t\t// far\n\n\t\taddLine( 'f1', 'f2' );\n\t\taddLine( 'f2', 'f4' );\n\t\taddLine( 'f4', 'f3' );\n\t\taddLine( 'f3', 'f1' );\n\n\t\t// sides\n\n\t\taddLine( 'n1', 'f1' );\n\t\taddLine( 'n2', 'f2' );\n\t\taddLine( 'n3', 'f3' );\n\t\taddLine( 'n4', 'f4' );\n\n\t\t// cone\n\n\t\taddLine( 'p', 'n1' );\n\t\taddLine( 'p', 'n2' );\n\t\taddLine( 'p', 'n3' );\n\t\taddLine( 'p', 'n4' );\n\n\t\t// up\n\n\t\taddLine( 'u1', 'u2' );\n\t\taddLine( 'u2', 'u3' );\n\t\taddLine( 'u3', 'u1' );\n\n\t\t// target\n\n\t\taddLine( 'c', 't' );\n\t\taddLine( 'p', 'c' );\n\n\t\t// cross\n\n\t\taddLine( 'cn1', 'cn2' );\n\t\taddLine( 'cn3', 'cn4' );\n\n\t\taddLine( 'cf1', 'cf2' );\n\t\taddLine( 'cf3', 'cf4' );\n\n\t\tfunction addLine( a, b ) {\n\n\t\t\taddPoint( a );\n\t\t\taddPoint( b );\n\n\t\t}\n\n\t\tfunction addPoint( id ) {\n\n\t\t\tvertices.push( 0, 0, 0 );\n\t\t\tcolors.push( 0, 0, 0 );\n\n\t\t\tif ( pointMap[ id ] === undefined ) {\n\n\t\t\t\tpointMap[ id ] = [];\n\n\t\t\t}\n\n\t\t\tpointMap[ id ].push( ( vertices.length / 3 ) - 1 );\n\n\t\t}\n\n\t\tgeometry.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\n\t\tgeometry.setAttribute( 'color', new Float32BufferAttribute( colors, 3 ) );\n\n\t\tsuper( geometry, material );\n\n\t\tthis.type = 'CameraHelper';\n\n\t\tthis.camera = camera;\n\t\tif ( this.camera.updateProjectionMatrix ) this.camera.updateProjectionMatrix();\n\n\t\tthis.matrix = camera.matrixWorld;\n\t\tthis.matrixAutoUpdate = false;\n\n\t\tthis.pointMap = pointMap;\n\n\t\tthis.update();\n\n\t\t// colors\n\n\t\tconst colorFrustum = new Color( 0xffaa00 );\n\t\tconst colorCone = new Color( 0xff0000 );\n\t\tconst colorUp = new Color( 0x00aaff );\n\t\tconst colorTarget = new Color( 0xffffff );\n\t\tconst colorCross = new Color( 0x333333 );\n\n\t\tthis.setColors( colorFrustum, colorCone, colorUp, colorTarget, colorCross );\n\n\t}\n\n\tsetColors( frustum, cone, up, target, cross ) {\n\n\t\tconst geometry = this.geometry;\n\n\t\tconst colorAttribute = geometry.getAttribute( 'color' );\n\n\t\t// near\n\n\t\tcolorAttribute.setXYZ( 0, frustum.r, frustum.g, frustum.b ); colorAttribute.setXYZ( 1, frustum.r, frustum.g, frustum.b ); // n1, n2\n\t\tcolorAttribute.setXYZ( 2, frustum.r, frustum.g, frustum.b ); colorAttribute.setXYZ( 3, frustum.r, frustum.g, frustum.b ); // n2, n4\n\t\tcolorAttribute.setXYZ( 4, frustum.r, frustum.g, frustum.b ); colorAttribute.setXYZ( 5, frustum.r, frustum.g, frustum.b ); // n4, n3\n\t\tcolorAttribute.setXYZ( 6, frustum.r, frustum.g, frustum.b ); colorAttribute.setXYZ( 7, frustum.r, frustum.g, frustum.b ); // n3, n1\n\n\t\t// far\n\n\t\tcolorAttribute.setXYZ( 8, frustum.r, frustum.g, frustum.b ); colorAttribute.setXYZ( 9, frustum.r, frustum.g, frustum.b ); // f1, f2\n\t\tcolorAttribute.setXYZ( 10, frustum.r, frustum.g, frustum.b ); colorAttribute.setXYZ( 11, frustum.r, frustum.g, frustum.b ); // f2, f4\n\t\tcolorAttribute.setXYZ( 12, frustum.r, frustum.g, frustum.b ); colorAttribute.setXYZ( 13, frustum.r, frustum.g, frustum.b ); // f4, f3\n\t\tcolorAttribute.setXYZ( 14, frustum.r, frustum.g, frustum.b ); colorAttribute.setXYZ( 15, frustum.r, frustum.g, frustum.b ); // f3, f1\n\n\t\t// sides\n\n\t\tcolorAttribute.setXYZ( 16, frustum.r, frustum.g, frustum.b ); colorAttribute.setXYZ( 17, frustum.r, frustum.g, frustum.b ); // n1, f1\n\t\tcolorAttribute.setXYZ( 18, frustum.r, frustum.g, frustum.b ); colorAttribute.setXYZ( 19, frustum.r, frustum.g, frustum.b ); // n2, f2\n\t\tcolorAttribute.setXYZ( 20, frustum.r, frustum.g, frustum.b ); colorAttribute.setXYZ( 21, frustum.r, frustum.g, frustum.b ); // n3, f3\n\t\tcolorAttribute.setXYZ( 22, frustum.r, frustum.g, frustum.b ); colorAttribute.setXYZ( 23, frustum.r, frustum.g, frustum.b ); // n4, f4\n\n\t\t// cone\n\n\t\tcolorAttribute.setXYZ( 24, cone.r, cone.g, cone.b ); colorAttribute.setXYZ( 25, cone.r, cone.g, cone.b ); // p, n1\n\t\tcolorAttribute.setXYZ( 26, cone.r, cone.g, cone.b ); colorAttribute.setXYZ( 27, cone.r, cone.g, cone.b ); // p, n2\n\t\tcolorAttribute.setXYZ( 28, cone.r, cone.g, cone.b ); colorAttribute.setXYZ( 29, cone.r, cone.g, cone.b ); // p, n3\n\t\tcolorAttribute.setXYZ( 30, cone.r, cone.g, cone.b ); colorAttribute.setXYZ( 31, cone.r, cone.g, cone.b ); // p, n4\n\n\t\t// up\n\n\t\tcolorAttribute.setXYZ( 32, up.r, up.g, up.b ); colorAttribute.setXYZ( 33, up.r, up.g, up.b ); // u1, u2\n\t\tcolorAttribute.setXYZ( 34, up.r, up.g, up.b ); colorAttribute.setXYZ( 35, up.r, up.g, up.b ); // u2, u3\n\t\tcolorAttribute.setXYZ( 36, up.r, up.g, up.b ); colorAttribute.setXYZ( 37, up.r, up.g, up.b ); // u3, u1\n\n\t\t// target\n\n\t\tcolorAttribute.setXYZ( 38, target.r, target.g, target.b ); colorAttribute.setXYZ( 39, target.r, target.g, target.b ); // c, t\n\t\tcolorAttribute.setXYZ( 40, cross.r, cross.g, cross.b ); colorAttribute.setXYZ( 41, cross.r, cross.g, cross.b ); // p, c\n\n\t\t// cross\n\n\t\tcolorAttribute.setXYZ( 42, cross.r, cross.g, cross.b ); colorAttribute.setXYZ( 43, cross.r, cross.g, cross.b ); // cn1, cn2\n\t\tcolorAttribute.setXYZ( 44, cross.r, cross.g, cross.b ); colorAttribute.setXYZ( 45, cross.r, cross.g, cross.b ); // cn3, cn4\n\n\t\tcolorAttribute.setXYZ( 46, cross.r, cross.g, cross.b ); colorAttribute.setXYZ( 47, cross.r, cross.g, cross.b ); // cf1, cf2\n\t\tcolorAttribute.setXYZ( 48, cross.r, cross.g, cross.b ); colorAttribute.setXYZ( 49, cross.r, cross.g, cross.b ); // cf3, cf4\n\n\t\tcolorAttribute.needsUpdate = true;\n\n\t}\n\n\tupdate() {\n\n\t\tconst geometry = this.geometry;\n\t\tconst pointMap = this.pointMap;\n\n\t\tconst w = 1, h = 1;\n\n\t\t// we need just camera projection matrix inverse\n\t\t// world matrix must be identity\n\n\t\t_camera.projectionMatrixInverse.copy( this.camera.projectionMatrixInverse );\n\n\t\t// center / target\n\n\t\tsetPoint( 'c', pointMap, geometry, _camera, 0, 0, - 1 );\n\t\tsetPoint( 't', pointMap, geometry, _camera, 0, 0, 1 );\n\n\t\t// near\n\n\t\tsetPoint( 'n1', pointMap, geometry, _camera, - w, - h, - 1 );\n\t\tsetPoint( 'n2', pointMap, geometry, _camera, w, - h, - 1 );\n\t\tsetPoint( 'n3', pointMap, geometry, _camera, - w, h, - 1 );\n\t\tsetPoint( 'n4', pointMap, geometry, _camera, w, h, - 1 );\n\n\t\t// far\n\n\t\tsetPoint( 'f1', pointMap, geometry, _camera, - w, - h, 1 );\n\t\tsetPoint( 'f2', pointMap, geometry, _camera, w, - h, 1 );\n\t\tsetPoint( 'f3', pointMap, geometry, _camera, - w, h, 1 );\n\t\tsetPoint( 'f4', pointMap, geometry, _camera, w, h, 1 );\n\n\t\t// up\n\n\t\tsetPoint( 'u1', pointMap, geometry, _camera, w * 0.7, h * 1.1, - 1 );\n\t\tsetPoint( 'u2', pointMap, geometry, _camera, - w * 0.7, h * 1.1, - 1 );\n\t\tsetPoint( 'u3', pointMap, geometry, _camera, 0, h * 2, - 1 );\n\n\t\t// cross\n\n\t\tsetPoint( 'cf1', pointMap, geometry, _camera, - w, 0, 1 );\n\t\tsetPoint( 'cf2', pointMap, geometry, _camera, w, 0, 1 );\n\t\tsetPoint( 'cf3', pointMap, geometry, _camera, 0, - h, 1 );\n\t\tsetPoint( 'cf4', pointMap, geometry, _camera, 0, h, 1 );\n\n\t\tsetPoint( 'cn1', pointMap, geometry, _camera, - w, 0, - 1 );\n\t\tsetPoint( 'cn2', pointMap, geometry, _camera, w, 0, - 1 );\n\t\tsetPoint( 'cn3', pointMap, geometry, _camera, 0, - h, - 1 );\n\t\tsetPoint( 'cn4', pointMap, geometry, _camera, 0, h, - 1 );\n\n\t\tgeometry.getAttribute( 'position' ).needsUpdate = true;\n\n\t}\n\n\tdispose() {\n\n\t\tthis.geometry.dispose();\n\t\tthis.material.dispose();\n\n\t}\n\n}\n\n\nfunction setPoint( point, pointMap, geometry, camera, x, y, z ) {\n\n\t_vector.set( x, y, z ).unproject( camera );\n\n\tconst points = pointMap[ point ];\n\n\tif ( points !== undefined ) {\n\n\t\tconst position = geometry.getAttribute( 'position' );\n\n\t\tfor ( let i = 0, l = points.length; i < l; i ++ ) {\n\n\t\t\tposition.setXYZ( points[ i ], _vector.x, _vector.y, _vector.z );\n\n\t\t}\n\n\t}\n\n}\n\nconst _box = /*@__PURE__*/ new Box3();\n\nclass BoxHelper extends LineSegments {\n\n\tconstructor( object, color = 0xffff00 ) {\n\n\t\tconst indices = new Uint16Array( [ 0, 1, 1, 2, 2, 3, 3, 0, 4, 5, 5, 6, 6, 7, 7, 4, 0, 4, 1, 5, 2, 6, 3, 7 ] );\n\t\tconst positions = new Float32Array( 8 * 3 );\n\n\t\tconst geometry = new BufferGeometry();\n\t\tgeometry.setIndex( new BufferAttribute( indices, 1 ) );\n\t\tgeometry.setAttribute( 'position', new BufferAttribute( positions, 3 ) );\n\n\t\tsuper( geometry, new LineBasicMaterial( { color: color, toneMapped: false } ) );\n\n\t\tthis.object = object;\n\t\tthis.type = 'BoxHelper';\n\n\t\tthis.matrixAutoUpdate = false;\n\n\t\tthis.update();\n\n\t}\n\n\tupdate( object ) {\n\n\t\tif ( object !== undefined ) {\n\n\t\t\tconsole.warn( 'THREE.BoxHelper: .update() has no longer arguments.' );\n\n\t\t}\n\n\t\tif ( this.object !== undefined ) {\n\n\t\t\t_box.setFromObject( this.object );\n\n\t\t}\n\n\t\tif ( _box.isEmpty() ) return;\n\n\t\tconst min = _box.min;\n\t\tconst max = _box.max;\n\n\t\t/*\n\t\t\t5____4\n\t\t1/___0/|\n\t\t| 6__|_7\n\t\t2/___3/\n\n\t\t0: max.x, max.y, max.z\n\t\t1: min.x, max.y, max.z\n\t\t2: min.x, min.y, max.z\n\t\t3: max.x, min.y, max.z\n\t\t4: max.x, max.y, min.z\n\t\t5: min.x, max.y, min.z\n\t\t6: min.x, min.y, min.z\n\t\t7: max.x, min.y, min.z\n\t\t*/\n\n\t\tconst position = this.geometry.attributes.position;\n\t\tconst array = position.array;\n\n\t\tarray[ 0 ] = max.x; array[ 1 ] = max.y; array[ 2 ] = max.z;\n\t\tarray[ 3 ] = min.x; array[ 4 ] = max.y; array[ 5 ] = max.z;\n\t\tarray[ 6 ] = min.x; array[ 7 ] = min.y; array[ 8 ] = max.z;\n\t\tarray[ 9 ] = max.x; array[ 10 ] = min.y; array[ 11 ] = max.z;\n\t\tarray[ 12 ] = max.x; array[ 13 ] = max.y; array[ 14 ] = min.z;\n\t\tarray[ 15 ] = min.x; array[ 16 ] = max.y; array[ 17 ] = min.z;\n\t\tarray[ 18 ] = min.x; array[ 19 ] = min.y; array[ 20 ] = min.z;\n\t\tarray[ 21 ] = max.x; array[ 22 ] = min.y; array[ 23 ] = min.z;\n\n\t\tposition.needsUpdate = true;\n\n\t\tthis.geometry.computeBoundingSphere();\n\n\t}\n\n\tsetFromObject( object ) {\n\n\t\tthis.object = object;\n\t\tthis.update();\n\n\t\treturn this;\n\n\t}\n\n\tcopy( source, recursive ) {\n\n\t\tsuper.copy( source, recursive );\n\n\t\tthis.object = source.object;\n\n\t\treturn this;\n\n\t}\n\n\tdispose() {\n\n\t\tthis.geometry.dispose();\n\t\tthis.material.dispose();\n\n\t}\n\n}\n\nclass Box3Helper extends LineSegments {\n\n\tconstructor( box, color = 0xffff00 ) {\n\n\t\tconst indices = new Uint16Array( [ 0, 1, 1, 2, 2, 3, 3, 0, 4, 5, 5, 6, 6, 7, 7, 4, 0, 4, 1, 5, 2, 6, 3, 7 ] );\n\n\t\tconst positions = [ 1, 1, 1, - 1, 1, 1, - 1, - 1, 1, 1, - 1, 1, 1, 1, - 1, - 1, 1, - 1, - 1, - 1, - 1, 1, - 1, - 1 ];\n\n\t\tconst geometry = new BufferGeometry();\n\n\t\tgeometry.setIndex( new BufferAttribute( indices, 1 ) );\n\n\t\tgeometry.setAttribute( 'position', new Float32BufferAttribute( positions, 3 ) );\n\n\t\tsuper( geometry, new LineBasicMaterial( { color: color, toneMapped: false } ) );\n\n\t\tthis.box = box;\n\n\t\tthis.type = 'Box3Helper';\n\n\t\tthis.geometry.computeBoundingSphere();\n\n\t}\n\n\tupdateMatrixWorld( force ) {\n\n\t\tconst box = this.box;\n\n\t\tif ( box.isEmpty() ) return;\n\n\t\tbox.getCenter( this.position );\n\n\t\tbox.getSize( this.scale );\n\n\t\tthis.scale.multiplyScalar( 0.5 );\n\n\t\tsuper.updateMatrixWorld( force );\n\n\t}\n\n\tdispose() {\n\n\t\tthis.geometry.dispose();\n\t\tthis.material.dispose();\n\n\t}\n\n}\n\nclass PlaneHelper extends Line {\n\n\tconstructor( plane, size = 1, hex = 0xffff00 ) {\n\n\t\tconst color = hex;\n\n\t\tconst positions = [ 1, - 1, 0, - 1, 1, 0, - 1, - 1, 0, 1, 1, 0, - 1, 1, 0, - 1, - 1, 0, 1, - 1, 0, 1, 1, 0 ];\n\n\t\tconst geometry = new BufferGeometry();\n\t\tgeometry.setAttribute( 'position', new Float32BufferAttribute( positions, 3 ) );\n\t\tgeometry.computeBoundingSphere();\n\n\t\tsuper( geometry, new LineBasicMaterial( { color: color, toneMapped: false } ) );\n\n\t\tthis.type = 'PlaneHelper';\n\n\t\tthis.plane = plane;\n\n\t\tthis.size = size;\n\n\t\tconst positions2 = [ 1, 1, 0, - 1, 1, 0, - 1, - 1, 0, 1, 1, 0, - 1, - 1, 0, 1, - 1, 0 ];\n\n\t\tconst geometry2 = new BufferGeometry();\n\t\tgeometry2.setAttribute( 'position', new Float32BufferAttribute( positions2, 3 ) );\n\t\tgeometry2.computeBoundingSphere();\n\n\t\tthis.add( new Mesh( geometry2, new MeshBasicMaterial( { color: color, opacity: 0.2, transparent: true, depthWrite: false, toneMapped: false } ) ) );\n\n\t}\n\n\tupdateMatrixWorld( force ) {\n\n\t\tthis.position.set( 0, 0, 0 );\n\n\t\tthis.scale.set( 0.5 * this.size, 0.5 * this.size, 1 );\n\n\t\tthis.lookAt( this.plane.normal );\n\n\t\tthis.translateZ( - this.plane.constant );\n\n\t\tsuper.updateMatrixWorld( force );\n\n\t}\n\n\tdispose() {\n\n\t\tthis.geometry.dispose();\n\t\tthis.material.dispose();\n\t\tthis.children[ 0 ].geometry.dispose();\n\t\tthis.children[ 0 ].material.dispose();\n\n\t}\n\n}\n\nconst _axis = /*@__PURE__*/ new Vector3();\nlet _lineGeometry, _coneGeometry;\n\nclass ArrowHelper extends Object3D {\n\n\t// dir is assumed to be normalized\n\n\tconstructor( dir = new Vector3( 0, 0, 1 ), origin = new Vector3( 0, 0, 0 ), length = 1, color = 0xffff00, headLength = length * 0.2, headWidth = headLength * 0.2 ) {\n\n\t\tsuper();\n\n\t\tthis.type = 'ArrowHelper';\n\n\t\tif ( _lineGeometry === undefined ) {\n\n\t\t\t_lineGeometry = new BufferGeometry();\n\t\t\t_lineGeometry.setAttribute( 'position', new Float32BufferAttribute( [ 0, 0, 0, 0, 1, 0 ], 3 ) );\n\n\t\t\t_coneGeometry = new CylinderGeometry( 0, 0.5, 1, 5, 1 );\n\t\t\t_coneGeometry.translate( 0, - 0.5, 0 );\n\n\t\t}\n\n\t\tthis.position.copy( origin );\n\n\t\tthis.line = new Line( _lineGeometry, new LineBasicMaterial( { color: color, toneMapped: false } ) );\n\t\tthis.line.matrixAutoUpdate = false;\n\t\tthis.add( this.line );\n\n\t\tthis.cone = new Mesh( _coneGeometry, new MeshBasicMaterial( { color: color, toneMapped: false } ) );\n\t\tthis.cone.matrixAutoUpdate = false;\n\t\tthis.add( this.cone );\n\n\t\tthis.setDirection( dir );\n\t\tthis.setLength( length, headLength, headWidth );\n\n\t}\n\n\tsetDirection( dir ) {\n\n\t\t// dir is assumed to be normalized\n\n\t\tif ( dir.y > 0.99999 ) {\n\n\t\t\tthis.quaternion.set( 0, 0, 0, 1 );\n\n\t\t} else if ( dir.y < - 0.99999 ) {\n\n\t\t\tthis.quaternion.set( 1, 0, 0, 0 );\n\n\t\t} else {\n\n\t\t\t_axis.set( dir.z, 0, - dir.x ).normalize();\n\n\t\t\tconst radians = Math.acos( dir.y );\n\n\t\t\tthis.quaternion.setFromAxisAngle( _axis, radians );\n\n\t\t}\n\n\t}\n\n\tsetLength( length, headLength = length * 0.2, headWidth = headLength * 0.2 ) {\n\n\t\tthis.line.scale.set( 1, Math.max( 0.0001, length - headLength ), 1 ); // see #17458\n\t\tthis.line.updateMatrix();\n\n\t\tthis.cone.scale.set( headWidth, headLength, headWidth );\n\t\tthis.cone.position.y = length;\n\t\tthis.cone.updateMatrix();\n\n\t}\n\n\tsetColor( color ) {\n\n\t\tthis.line.material.color.set( color );\n\t\tthis.cone.material.color.set( color );\n\n\t}\n\n\tcopy( source ) {\n\n\t\tsuper.copy( source, false );\n\n\t\tthis.line.copy( source.line );\n\t\tthis.cone.copy( source.cone );\n\n\t\treturn this;\n\n\t}\n\n\tdispose() {\n\n\t\tthis.line.geometry.dispose();\n\t\tthis.line.material.dispose();\n\t\tthis.cone.geometry.dispose();\n\t\tthis.cone.material.dispose();\n\n\t}\n\n}\n\nclass AxesHelper extends LineSegments {\n\n\tconstructor( size = 1 ) {\n\n\t\tconst vertices = [\n\t\t\t0, 0, 0,\tsize, 0, 0,\n\t\t\t0, 0, 0,\t0, size, 0,\n\t\t\t0, 0, 0,\t0, 0, size\n\t\t];\n\n\t\tconst colors = [\n\t\t\t1, 0, 0,\t1, 0.6, 0,\n\t\t\t0, 1, 0,\t0.6, 1, 0,\n\t\t\t0, 0, 1,\t0, 0.6, 1\n\t\t];\n\n\t\tconst geometry = new BufferGeometry();\n\t\tgeometry.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\n\t\tgeometry.setAttribute( 'color', new Float32BufferAttribute( colors, 3 ) );\n\n\t\tconst material = new LineBasicMaterial( { vertexColors: true, toneMapped: false } );\n\n\t\tsuper( geometry, material );\n\n\t\tthis.type = 'AxesHelper';\n\n\t}\n\n\tsetColors( xAxisColor, yAxisColor, zAxisColor ) {\n\n\t\tconst color = new Color();\n\t\tconst array = this.geometry.attributes.color.array;\n\n\t\tcolor.set( xAxisColor );\n\t\tcolor.toArray( array, 0 );\n\t\tcolor.toArray( array, 3 );\n\n\t\tcolor.set( yAxisColor );\n\t\tcolor.toArray( array, 6 );\n\t\tcolor.toArray( array, 9 );\n\n\t\tcolor.set( zAxisColor );\n\t\tcolor.toArray( array, 12 );\n\t\tcolor.toArray( array, 15 );\n\n\t\tthis.geometry.attributes.color.needsUpdate = true;\n\n\t\treturn this;\n\n\t}\n\n\tdispose() {\n\n\t\tthis.geometry.dispose();\n\t\tthis.material.dispose();\n\n\t}\n\n}\n\nclass ShapePath {\n\n\tconstructor() {\n\n\t\tthis.type = 'ShapePath';\n\n\t\tthis.color = new Color();\n\n\t\tthis.subPaths = [];\n\t\tthis.currentPath = null;\n\n\t}\n\n\tmoveTo( x, y ) {\n\n\t\tthis.currentPath = new Path();\n\t\tthis.subPaths.push( this.currentPath );\n\t\tthis.currentPath.moveTo( x, y );\n\n\t\treturn this;\n\n\t}\n\n\tlineTo( x, y ) {\n\n\t\tthis.currentPath.lineTo( x, y );\n\n\t\treturn this;\n\n\t}\n\n\tquadraticCurveTo( aCPx, aCPy, aX, aY ) {\n\n\t\tthis.currentPath.quadraticCurveTo( aCPx, aCPy, aX, aY );\n\n\t\treturn this;\n\n\t}\n\n\tbezierCurveTo( aCP1x, aCP1y, aCP2x, aCP2y, aX, aY ) {\n\n\t\tthis.currentPath.bezierCurveTo( aCP1x, aCP1y, aCP2x, aCP2y, aX, aY );\n\n\t\treturn this;\n\n\t}\n\n\tsplineThru( pts ) {\n\n\t\tthis.currentPath.splineThru( pts );\n\n\t\treturn this;\n\n\t}\n\n\ttoShapes( isCCW ) {\n\n\t\tfunction toShapesNoHoles( inSubpaths ) {\n\n\t\t\tconst shapes = [];\n\n\t\t\tfor ( let i = 0, l = inSubpaths.length; i < l; i ++ ) {\n\n\t\t\t\tconst tmpPath = inSubpaths[ i ];\n\n\t\t\t\tconst tmpShape = new Shape();\n\t\t\t\ttmpShape.curves = tmpPath.curves;\n\n\t\t\t\tshapes.push( tmpShape );\n\n\t\t\t}\n\n\t\t\treturn shapes;\n\n\t\t}\n\n\t\tfunction isPointInsidePolygon( inPt, inPolygon ) {\n\n\t\t\tconst polyLen = inPolygon.length;\n\n\t\t\t// inPt on polygon contour => immediate success or\n\t\t\t// toggling of inside/outside at every single! intersection point of an edge\n\t\t\t// with the horizontal line through inPt, left of inPt\n\t\t\t// not counting lowerY endpoints of edges and whole edges on that line\n\t\t\tlet inside = false;\n\t\t\tfor ( let p = polyLen - 1, q = 0; q < polyLen; p = q ++ ) {\n\n\t\t\t\tlet edgeLowPt = inPolygon[ p ];\n\t\t\t\tlet edgeHighPt = inPolygon[ q ];\n\n\t\t\t\tlet edgeDx = edgeHighPt.x - edgeLowPt.x;\n\t\t\t\tlet edgeDy = edgeHighPt.y - edgeLowPt.y;\n\n\t\t\t\tif ( Math.abs( edgeDy ) > Number.EPSILON ) {\n\n\t\t\t\t\t// not parallel\n\t\t\t\t\tif ( edgeDy < 0 ) {\n\n\t\t\t\t\t\tedgeLowPt = inPolygon[ q ]; edgeDx = - edgeDx;\n\t\t\t\t\t\tedgeHighPt = inPolygon[ p ]; edgeDy = - edgeDy;\n\n\t\t\t\t\t}\n\n\t\t\t\t\tif ( ( inPt.y < edgeLowPt.y ) || ( inPt.y > edgeHighPt.y ) ) \t\tcontinue;\n\n\t\t\t\t\tif ( inPt.y === edgeLowPt.y ) {\n\n\t\t\t\t\t\tif ( inPt.x === edgeLowPt.x )\t\treturn\ttrue;\t\t// inPt is on contour ?\n\t\t\t\t\t\t// continue;\t\t\t\t// no intersection or edgeLowPt => doesn't count !!!\n\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\tconst perpEdge = edgeDy * ( inPt.x - edgeLowPt.x ) - edgeDx * ( inPt.y - edgeLowPt.y );\n\t\t\t\t\t\tif ( perpEdge === 0 )\t\t\t\treturn\ttrue;\t\t// inPt is on contour ?\n\t\t\t\t\t\tif ( perpEdge < 0 ) \t\t\t\tcontinue;\n\t\t\t\t\t\tinside = ! inside;\t\t// true intersection left of inPt\n\n\t\t\t\t\t}\n\n\t\t\t\t} else {\n\n\t\t\t\t\t// parallel or collinear\n\t\t\t\t\tif ( inPt.y !== edgeLowPt.y ) \t\tcontinue;\t\t\t// parallel\n\t\t\t\t\t// edge lies on the same horizontal line as inPt\n\t\t\t\t\tif ( ( ( edgeHighPt.x <= inPt.x ) && ( inPt.x <= edgeLowPt.x ) ) ||\n\t\t\t\t\t\t ( ( edgeLowPt.x <= inPt.x ) && ( inPt.x <= edgeHighPt.x ) ) )\t\treturn\ttrue;\t// inPt: Point on contour !\n\t\t\t\t\t// continue;\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\treturn\tinside;\n\n\t\t}\n\n\t\tconst isClockWise = ShapeUtils.isClockWise;\n\n\t\tconst subPaths = this.subPaths;\n\t\tif ( subPaths.length === 0 ) return [];\n\n\t\tlet solid, tmpPath, tmpShape;\n\t\tconst shapes = [];\n\n\t\tif ( subPaths.length === 1 ) {\n\n\t\t\ttmpPath = subPaths[ 0 ];\n\t\t\ttmpShape = new Shape();\n\t\t\ttmpShape.curves = tmpPath.curves;\n\t\t\tshapes.push( tmpShape );\n\t\t\treturn shapes;\n\n\t\t}\n\n\t\tlet holesFirst = ! isClockWise( subPaths[ 0 ].getPoints() );\n\t\tholesFirst = isCCW ? ! holesFirst : holesFirst;\n\n\t\t// console.log(\"Holes first\", holesFirst);\n\n\t\tconst betterShapeHoles = [];\n\t\tconst newShapes = [];\n\t\tlet newShapeHoles = [];\n\t\tlet mainIdx = 0;\n\t\tlet tmpPoints;\n\n\t\tnewShapes[ mainIdx ] = undefined;\n\t\tnewShapeHoles[ mainIdx ] = [];\n\n\t\tfor ( let i = 0, l = subPaths.length; i < l; i ++ ) {\n\n\t\t\ttmpPath = subPaths[ i ];\n\t\t\ttmpPoints = tmpPath.getPoints();\n\t\t\tsolid = isClockWise( tmpPoints );\n\t\t\tsolid = isCCW ? ! solid : solid;\n\n\t\t\tif ( solid ) {\n\n\t\t\t\tif ( ( ! holesFirst ) && ( newShapes[ mainIdx ] ) )\tmainIdx ++;\n\n\t\t\t\tnewShapes[ mainIdx ] = { s: new Shape(), p: tmpPoints };\n\t\t\t\tnewShapes[ mainIdx ].s.curves = tmpPath.curves;\n\n\t\t\t\tif ( holesFirst )\tmainIdx ++;\n\t\t\t\tnewShapeHoles[ mainIdx ] = [];\n\n\t\t\t\t//console.log('cw', i);\n\n\t\t\t} else {\n\n\t\t\t\tnewShapeHoles[ mainIdx ].push( { h: tmpPath, p: tmpPoints[ 0 ] } );\n\n\t\t\t\t//console.log('ccw', i);\n\n\t\t\t}\n\n\t\t}\n\n\t\t// only Holes? -> probably all Shapes with wrong orientation\n\t\tif ( ! newShapes[ 0 ] )\treturn\ttoShapesNoHoles( subPaths );\n\n\n\t\tif ( newShapes.length > 1 ) {\n\n\t\t\tlet ambiguous = false;\n\t\t\tlet toChange = 0;\n\n\t\t\tfor ( let sIdx = 0, sLen = newShapes.length; sIdx < sLen; sIdx ++ ) {\n\n\t\t\t\tbetterShapeHoles[ sIdx ] = [];\n\n\t\t\t}\n\n\t\t\tfor ( let sIdx = 0, sLen = newShapes.length; sIdx < sLen; sIdx ++ ) {\n\n\t\t\t\tconst sho = newShapeHoles[ sIdx ];\n\n\t\t\t\tfor ( let hIdx = 0; hIdx < sho.length; hIdx ++ ) {\n\n\t\t\t\t\tconst ho = sho[ hIdx ];\n\t\t\t\t\tlet hole_unassigned = true;\n\n\t\t\t\t\tfor ( let s2Idx = 0; s2Idx < newShapes.length; s2Idx ++ ) {\n\n\t\t\t\t\t\tif ( isPointInsidePolygon( ho.p, newShapes[ s2Idx ].p ) ) {\n\n\t\t\t\t\t\t\tif ( sIdx !== s2Idx )\ttoChange ++;\n\n\t\t\t\t\t\t\tif ( hole_unassigned ) {\n\n\t\t\t\t\t\t\t\thole_unassigned = false;\n\t\t\t\t\t\t\t\tbetterShapeHoles[ s2Idx ].push( ho );\n\n\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\tambiguous = true;\n\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}\n\n\t\t\t\t\tif ( hole_unassigned ) {\n\n\t\t\t\t\t\tbetterShapeHoles[ sIdx ].push( ho );\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tif ( toChange > 0 && ambiguous === false ) {\n\n\t\t\t\tnewShapeHoles = betterShapeHoles;\n\n\t\t\t}\n\n\t\t}\n\n\t\tlet tmpHoles;\n\n\t\tfor ( let i = 0, il = newShapes.length; i < il; i ++ ) {\n\n\t\t\ttmpShape = newShapes[ i ].s;\n\t\t\tshapes.push( tmpShape );\n\t\t\ttmpHoles = newShapeHoles[ i ];\n\n\t\t\tfor ( let j = 0, jl = tmpHoles.length; j < jl; j ++ ) {\n\n\t\t\t\ttmpShape.holes.push( tmpHoles[ j ].h );\n\n\t\t\t}\n\n\t\t}\n\n\t\t//console.log(\"shape\", shapes);\n\n\t\treturn shapes;\n\n\t}\n\n}\n\nclass WebGLMultipleRenderTargets extends WebGLRenderTarget { // @deprecated, r162\n\n\tconstructor( width = 1, height = 1, count = 1, options = {} ) {\n\n\t\tconsole.warn( 'THREE.WebGLMultipleRenderTargets has been deprecated and will be removed in r172. Use THREE.WebGLRenderTarget and set the \"count\" parameter to enable MRT.' );\n\n\t\tsuper( width, height, { ...options, count } );\n\n\t\tthis.isWebGLMultipleRenderTargets = true;\n\n\t}\n\n\tget texture() {\n\n\t\treturn this.textures;\n\n\t}\n\n}\n\nif ( typeof __THREE_DEVTOOLS__ !== 'undefined' ) {\n\n\t__THREE_DEVTOOLS__.dispatchEvent( new CustomEvent( 'register', { detail: {\n\t\trevision: REVISION,\n\t} } ) );\n\n}\n\nif ( typeof window !== 'undefined' ) {\n\n\tif ( window.__THREE__ ) {\n\n\t\tconsole.warn( 'WARNING: Multiple instances of Three.js being imported.' );\n\n\t} else {\n\n\t\twindow.__THREE__ = REVISION;\n\n\t}\n\n}\n\nexport { ACESFilmicToneMapping, AddEquation, AddOperation, AdditiveAnimationBlendMode, AdditiveBlending, AgXToneMapping, AlphaFormat, AlwaysCompare, AlwaysDepth, AlwaysStencilFunc, AmbientLight, AnimationAction, AnimationClip, AnimationLoader, AnimationMixer, AnimationObjectGroup, AnimationUtils, ArcCurve, ArrayCamera, ArrowHelper, AttachedBindMode, Audio, AudioAnalyser, AudioContext, AudioListener, AudioLoader, AxesHelper, BackSide, BasicDepthPacking, BasicShadowMap, BatchedMesh, Bone, BooleanKeyframeTrack, Box2, Box3, Box3Helper, BoxGeometry, BoxHelper, BufferAttribute, BufferGeometry, BufferGeometryLoader, ByteType, Cache, Camera, CameraHelper, CanvasTexture, CapsuleGeometry, CatmullRomCurve3, CineonToneMapping, CircleGeometry, ClampToEdgeWrapping, Clock, Color, ColorKeyframeTrack, ColorManagement, CompressedArrayTexture, CompressedCubeTexture, CompressedTexture, CompressedTextureLoader, ConeGeometry, ConstantAlphaFactor, ConstantColorFactor, CubeCamera, CubeReflectionMapping, CubeRefractionMapping, CubeTexture, CubeTextureLoader, CubeUVReflectionMapping, CubicBezierCurve, CubicBezierCurve3, CubicInterpolant, CullFaceBack, CullFaceFront, CullFaceFrontBack, CullFaceNone, Curve, CurvePath, CustomBlending, CustomToneMapping, CylinderGeometry, Cylindrical, Data3DTexture, DataArrayTexture, DataTexture, DataTextureLoader, DataUtils, DecrementStencilOp, DecrementWrapStencilOp, DefaultLoadingManager, DepthFormat, DepthStencilFormat, DepthTexture, DetachedBindMode, DirectionalLight, DirectionalLightHelper, DiscreteInterpolant, DisplayP3ColorSpace, DodecahedronGeometry, DoubleSide, DstAlphaFactor, DstColorFactor, DynamicCopyUsage, DynamicDrawUsage, DynamicReadUsage, EdgesGeometry, EllipseCurve, EqualCompare, EqualDepth, EqualStencilFunc, EquirectangularReflectionMapping, EquirectangularRefractionMapping, Euler, EventDispatcher, ExtrudeGeometry, FileLoader, Float16BufferAttribute, Float32BufferAttribute, FloatType, Fog, FogExp2, FramebufferTexture, FrontSide, Frustum, GLBufferAttribute, GLSL1, GLSL3, GreaterCompare, GreaterDepth, GreaterEqualCompare, GreaterEqualDepth, GreaterEqualStencilFunc, GreaterStencilFunc, GridHelper, Group, HalfFloatType, HemisphereLight, HemisphereLightHelper, IcosahedronGeometry, ImageBitmapLoader, ImageLoader, ImageUtils, IncrementStencilOp, IncrementWrapStencilOp, InstancedBufferAttribute, InstancedBufferGeometry, InstancedInterleavedBuffer, InstancedMesh, Int16BufferAttribute, Int32BufferAttribute, Int8BufferAttribute, IntType, InterleavedBuffer, InterleavedBufferAttribute, Interpolant, InterpolateDiscrete, InterpolateLinear, InterpolateSmooth, InvertStencilOp, KeepStencilOp, KeyframeTrack, LOD, LatheGeometry, Layers, LessCompare, LessDepth, LessEqualCompare, LessEqualDepth, LessEqualStencilFunc, LessStencilFunc, Light, LightProbe, Line, Line3, LineBasicMaterial, LineCurve, LineCurve3, LineDashedMaterial, LineLoop, LineSegments, LinearDisplayP3ColorSpace, LinearFilter, LinearInterpolant, LinearMipMapLinearFilter, LinearMipMapNearestFilter, LinearMipmapLinearFilter, LinearMipmapNearestFilter, LinearSRGBColorSpace, LinearToneMapping, LinearTransfer, Loader, LoaderUtils, LoadingManager, LoopOnce, LoopPingPong, LoopRepeat, LuminanceAlphaFormat, LuminanceFormat, MOUSE, Material, MaterialLoader, MathUtils, Matrix3, Matrix4, MaxEquation, Mesh, MeshBasicMaterial, MeshDepthMaterial, MeshDistanceMaterial, MeshLambertMaterial, MeshMatcapMaterial, MeshNormalMaterial, MeshPhongMaterial, MeshPhysicalMaterial, MeshStandardMaterial, MeshToonMaterial, MinEquation, MirroredRepeatWrapping, MixOperation, MultiplyBlending, MultiplyOperation, NearestFilter, NearestMipMapLinearFilter, NearestMipMapNearestFilter, NearestMipmapLinearFilter, NearestMipmapNearestFilter, NeutralToneMapping, NeverCompare, NeverDepth, NeverStencilFunc, NoBlending, NoColorSpace, NoToneMapping, NormalAnimationBlendMode, NormalBlending, NotEqualCompare, NotEqualDepth, NotEqualStencilFunc, NumberKeyframeTrack, Object3D, ObjectLoader, ObjectSpaceNormalMap, OctahedronGeometry, OneFactor, OneMinusConstantAlphaFactor, OneMinusConstantColorFactor, OneMinusDstAlphaFactor, OneMinusDstColorFactor, OneMinusSrcAlphaFactor, OneMinusSrcColorFactor, OrthographicCamera, P3Primaries, PCFShadowMap, PCFSoftShadowMap, PMREMGenerator, Path, PerspectiveCamera, Plane, PlaneGeometry, PlaneHelper, PointLight, PointLightHelper, Points, PointsMaterial, PolarGridHelper, PolyhedronGeometry, PositionalAudio, PropertyBinding, PropertyMixer, QuadraticBezierCurve, QuadraticBezierCurve3, Quaternion, QuaternionKeyframeTrack, QuaternionLinearInterpolant, RED_GREEN_RGTC2_Format, RED_RGTC1_Format, REVISION, RGBADepthPacking, RGBAFormat, RGBAIntegerFormat, RGBA_ASTC_10x10_Format, RGBA_ASTC_10x5_Format, RGBA_ASTC_10x6_Format, RGBA_ASTC_10x8_Format, RGBA_ASTC_12x10_Format, RGBA_ASTC_12x12_Format, RGBA_ASTC_4x4_Format, RGBA_ASTC_5x4_Format, RGBA_ASTC_5x5_Format, RGBA_ASTC_6x5_Format, RGBA_ASTC_6x6_Format, RGBA_ASTC_8x5_Format, RGBA_ASTC_8x6_Format, RGBA_ASTC_8x8_Format, RGBA_BPTC_Format, RGBA_ETC2_EAC_Format, RGBA_PVRTC_2BPPV1_Format, RGBA_PVRTC_4BPPV1_Format, RGBA_S3TC_DXT1_Format, RGBA_S3TC_DXT3_Format, RGBA_S3TC_DXT5_Format, RGBFormat, RGB_BPTC_SIGNED_Format, RGB_BPTC_UNSIGNED_Format, RGB_ETC1_Format, RGB_ETC2_Format, RGB_PVRTC_2BPPV1_Format, RGB_PVRTC_4BPPV1_Format, RGB_S3TC_DXT1_Format, RGFormat, RGIntegerFormat, RawShaderMaterial, Ray, Raycaster, Rec709Primaries, RectAreaLight, RedFormat, RedIntegerFormat, ReinhardToneMapping, RenderTarget, RepeatWrapping, ReplaceStencilOp, ReverseSubtractEquation, RingGeometry, SIGNED_RED_GREEN_RGTC2_Format, SIGNED_RED_RGTC1_Format, SRGBColorSpace, SRGBTransfer, Scene, ShaderChunk, ShaderLib, ShaderMaterial, ShadowMaterial, Shape, ShapeGeometry, ShapePath, ShapeUtils, ShortType, Skeleton, SkeletonHelper, SkinnedMesh, Source, Sphere, SphereGeometry, Spherical, SphericalHarmonics3, SplineCurve, SpotLight, SpotLightHelper, Sprite, SpriteMaterial, SrcAlphaFactor, SrcAlphaSaturateFactor, SrcColorFactor, StaticCopyUsage, StaticDrawUsage, StaticReadUsage, StereoCamera, StreamCopyUsage, StreamDrawUsage, StreamReadUsage, StringKeyframeTrack, SubtractEquation, SubtractiveBlending, TOUCH, TangentSpaceNormalMap, TetrahedronGeometry, Texture, TextureLoader, TorusGeometry, TorusKnotGeometry, Triangle, TriangleFanDrawMode, TriangleStripDrawMode, TrianglesDrawMode, TubeGeometry, UVMapping, Uint16BufferAttribute, Uint32BufferAttribute, Uint8BufferAttribute, Uint8ClampedBufferAttribute, Uniform, UniformsGroup, UniformsLib, UniformsUtils, UnsignedByteType, UnsignedInt248Type, UnsignedInt5999Type, UnsignedIntType, UnsignedShort4444Type, UnsignedShort5551Type, UnsignedShortType, VSMShadowMap, Vector2, Vector3, Vector4, VectorKeyframeTrack, VideoTexture, WebGL3DRenderTarget, WebGLArrayRenderTarget, WebGLCoordinateSystem, WebGLCubeRenderTarget, WebGLMultipleRenderTargets, WebGLRenderTarget, WebGLRenderer, WebGLUtils, WebGPUCoordinateSystem, WireframeGeometry, WrapAroundEnding, ZeroCurvatureEnding, ZeroFactor, ZeroSlopeEnding, ZeroStencilOp, createCanvasElement };\n", "import {\n\tBufferGeometry,\n\tBufferAttribute,\n\tLineBasicMaterial,\n\tLine,\n\tMathUtils\n} from 'three';\n\nclass PositionalAudioHelper extends Line {\n\n\tconstructor( audio, range = 1, divisionsInnerAngle = 16, divisionsOuterAngle = 2 ) {\n\n\t\tconst geometry = new BufferGeometry();\n\t\tconst divisions = divisionsInnerAngle + divisionsOuterAngle * 2;\n\t\tconst positions = new Float32Array( ( divisions * 3 + 3 ) * 3 );\n\t\tgeometry.setAttribute( 'position', new BufferAttribute( positions, 3 ) );\n\n\t\tconst materialInnerAngle = new LineBasicMaterial( { color: 0x00ff00 } );\n\t\tconst materialOuterAngle = new LineBasicMaterial( { color: 0xffff00 } );\n\n\t\tsuper( geometry, [ materialOuterAngle, materialInnerAngle ] );\n\n\t\tthis.audio = audio;\n\t\tthis.range = range;\n\t\tthis.divisionsInnerAngle = divisionsInnerAngle;\n\t\tthis.divisionsOuterAngle = divisionsOuterAngle;\n\t\tthis.type = 'PositionalAudioHelper';\n\n\t\tthis.update();\n\n\t}\n\n\tupdate() {\n\n\t\tconst audio = this.audio;\n\t\tconst range = this.range;\n\t\tconst divisionsInnerAngle = this.divisionsInnerAngle;\n\t\tconst divisionsOuterAngle = this.divisionsOuterAngle;\n\n\t\tconst coneInnerAngle = MathUtils.degToRad( audio.panner.coneInnerAngle );\n\t\tconst coneOuterAngle = MathUtils.degToRad( audio.panner.coneOuterAngle );\n\n\t\tconst halfConeInnerAngle = coneInnerAngle / 2;\n\t\tconst halfConeOuterAngle = coneOuterAngle / 2;\n\n\t\tlet start = 0;\n\t\tlet count = 0;\n\t\tlet i;\n\t\tlet stride;\n\n\t\tconst geometry = this.geometry;\n\t\tconst positionAttribute = geometry.attributes.position;\n\n\t\tgeometry.clearGroups();\n\n\t\t//\n\n\t\tfunction generateSegment( from, to, divisions, materialIndex ) {\n\n\t\t\tconst step = ( to - from ) / divisions;\n\n\t\t\tpositionAttribute.setXYZ( start, 0, 0, 0 );\n\t\t\tcount ++;\n\n\t\t\tfor ( i = from; i < to; i += step ) {\n\n\t\t\t\tstride = start + count;\n\n\t\t\t\tpositionAttribute.setXYZ( stride, Math.sin( i ) * range, 0, Math.cos( i ) * range );\n\t\t\t\tpositionAttribute.setXYZ( stride + 1, Math.sin( Math.min( i + step, to ) ) * range, 0, Math.cos( Math.min( i + step, to ) ) * range );\n\t\t\t\tpositionAttribute.setXYZ( stride + 2, 0, 0, 0 );\n\n\t\t\t\tcount += 3;\n\n\t\t\t}\n\n\t\t\tgeometry.addGroup( start, count, materialIndex );\n\n\t\t\tstart += count;\n\t\t\tcount = 0;\n\n\t\t}\n\n\t\t//\n\n\t\tgenerateSegment( - halfConeOuterAngle, - halfConeInnerAngle, divisionsOuterAngle, 0 );\n\t\tgenerateSegment( - halfConeInnerAngle, halfConeInnerAngle, divisionsInnerAngle, 1 );\n\t\tgenerateSegment( halfConeInnerAngle, halfConeOuterAngle, divisionsOuterAngle, 0 );\n\n\t\t//\n\n\t\tpositionAttribute.needsUpdate = true;\n\n\t\tif ( coneInnerAngle === coneOuterAngle ) this.material[ 0 ].visible = false;\n\n\t}\n\n\tdispose() {\n\n\t\tthis.geometry.dispose();\n\t\tthis.material[ 0 ].dispose();\n\t\tthis.material[ 1 ].dispose();\n\n\t}\n\n}\n\n\nexport { PositionalAudioHelper };\n", "import {\n\tBufferAttribute,\n\tBufferGeometry,\n\tColor,\n\tFileLoader,\n\tLoader,\n\tLinearSRGBColorSpace,\n\tSRGBColorSpace\n} from 'three';\n\nconst _taskCache = new WeakMap();\n\nclass DRACOLoader extends Loader {\n\n\tconstructor( manager ) {\n\n\t\tsuper( manager );\n\n\t\tthis.decoderPath = '';\n\t\tthis.decoderConfig = {};\n\t\tthis.decoderBinary = null;\n\t\tthis.decoderPending = null;\n\n\t\tthis.workerLimit = 4;\n\t\tthis.workerPool = [];\n\t\tthis.workerNextTaskID = 1;\n\t\tthis.workerSourceURL = '';\n\n\t\tthis.defaultAttributeIDs = {\n\t\t\tposition: 'POSITION',\n\t\t\tnormal: 'NORMAL',\n\t\t\tcolor: 'COLOR',\n\t\t\tuv: 'TEX_COORD'\n\t\t};\n\t\tthis.defaultAttributeTypes = {\n\t\t\tposition: 'Float32Array',\n\t\t\tnormal: 'Float32Array',\n\t\t\tcolor: 'Float32Array',\n\t\t\tuv: 'Float32Array'\n\t\t};\n\n\t}\n\n\tsetDecoderPath( path ) {\n\n\t\tthis.decoderPath = path;\n\n\t\treturn this;\n\n\t}\n\n\tsetDecoderConfig( config ) {\n\n\t\tthis.decoderConfig = config;\n\n\t\treturn this;\n\n\t}\n\n\tsetWorkerLimit( workerLimit ) {\n\n\t\tthis.workerLimit = workerLimit;\n\n\t\treturn this;\n\n\t}\n\n\tload( url, onLoad, onProgress, onError ) {\n\n\t\tconst loader = new FileLoader( this.manager );\n\n\t\tloader.setPath( this.path );\n\t\tloader.setResponseType( 'arraybuffer' );\n\t\tloader.setRequestHeader( this.requestHeader );\n\t\tloader.setWithCredentials( this.withCredentials );\n\n\t\tloader.load( url, ( buffer ) => {\n\n\t\t\tthis.parse( buffer, onLoad, onError );\n\n\t\t}, onProgress, onError );\n\n\t}\n\n\n\tparse( buffer, onLoad, onError = ()=>{} ) {\n\n\t\tthis.decodeDracoFile( buffer, onLoad, null, null, SRGBColorSpace ).catch( onError );\n\n\t}\n\n\tdecodeDracoFile( buffer, callback, attributeIDs, attributeTypes, vertexColorSpace = LinearSRGBColorSpace, onError = () => {} ) {\n\n\t\tconst taskConfig = {\n\t\t\tattributeIDs: attributeIDs || this.defaultAttributeIDs,\n\t\t\tattributeTypes: attributeTypes || this.defaultAttributeTypes,\n\t\t\tuseUniqueIDs: !! attributeIDs,\n\t\t\tvertexColorSpace: vertexColorSpace,\n\t\t};\n\n\t\treturn this.decodeGeometry( buffer, taskConfig ).then( callback ).catch( onError );\n\n\t}\n\n\tdecodeGeometry( buffer, taskConfig ) {\n\n\t\tconst taskKey = JSON.stringify( taskConfig );\n\n\t\t// Check for an existing task using this buffer. A transferred buffer cannot be transferred\n\t\t// again from this thread.\n\t\tif ( _taskCache.has( buffer ) ) {\n\n\t\t\tconst cachedTask = _taskCache.get( buffer );\n\n\t\t\tif ( cachedTask.key === taskKey ) {\n\n\t\t\t\treturn cachedTask.promise;\n\n\t\t\t} else if ( buffer.byteLength === 0 ) {\n\n\t\t\t\t// Technically, it would be possible to wait for the previous task to complete,\n\t\t\t\t// transfer the buffer back, and decode again with the second configuration. That\n\t\t\t\t// is complex, and I don't know of any reason to decode a Draco buffer twice in\n\t\t\t\t// different ways, so this is left unimplemented.\n\t\t\t\tthrow new Error(\n\n\t\t\t\t\t'THREE.DRACOLoader: Unable to re-decode a buffer with different ' +\n\t\t\t\t\t'settings. Buffer has already been transferred.'\n\n\t\t\t\t);\n\n\t\t\t}\n\n\t\t}\n\n\t\t//\n\n\t\tlet worker;\n\t\tconst taskID = this.workerNextTaskID ++;\n\t\tconst taskCost = buffer.byteLength;\n\n\t\t// Obtain a worker and assign a task, and construct a geometry instance\n\t\t// when the task completes.\n\t\tconst geometryPending = this._getWorker( taskID, taskCost )\n\t\t\t.then( ( _worker ) => {\n\n\t\t\t\tworker = _worker;\n\n\t\t\t\treturn new Promise( ( resolve, reject ) => {\n\n\t\t\t\t\tworker._callbacks[ taskID ] = { resolve, reject };\n\n\t\t\t\t\tworker.postMessage( { type: 'decode', id: taskID, taskConfig, buffer }, [ buffer ] );\n\n\t\t\t\t\t// this.debug();\n\n\t\t\t\t} );\n\n\t\t\t} )\n\t\t\t.then( ( message ) => this._createGeometry( message.geometry ) );\n\n\t\t// Remove task from the task list.\n\t\t// Note: replaced '.finally()' with '.catch().then()' block - iOS 11 support (#19416)\n\t\tgeometryPending\n\t\t\t.catch( () => true )\n\t\t\t.then( () => {\n\n\t\t\t\tif ( worker && taskID ) {\n\n\t\t\t\t\tthis._releaseTask( worker, taskID );\n\n\t\t\t\t\t// this.debug();\n\n\t\t\t\t}\n\n\t\t\t} );\n\n\t\t// Cache the task result.\n\t\t_taskCache.set( buffer, {\n\n\t\t\tkey: taskKey,\n\t\t\tpromise: geometryPending\n\n\t\t} );\n\n\t\treturn geometryPending;\n\n\t}\n\n\t_createGeometry( geometryData ) {\n\n\t\tconst geometry = new BufferGeometry();\n\n\t\tif ( geometryData.index ) {\n\n\t\t\tgeometry.setIndex( new BufferAttribute( geometryData.index.array, 1 ) );\n\n\t\t}\n\n\t\tfor ( let i = 0; i < geometryData.attributes.length; i ++ ) {\n\n\t\t\tconst result = geometryData.attributes[ i ];\n\t\t\tconst name = result.name;\n\t\t\tconst array = result.array;\n\t\t\tconst itemSize = result.itemSize;\n\n\t\t\tconst attribute = new BufferAttribute( array, itemSize );\n\n\t\t\tif ( name === 'color' ) {\n\n\t\t\t\tthis._assignVertexColorSpace( attribute, result.vertexColorSpace );\n\n\t\t\t\tattribute.normalized = ( array instanceof Float32Array ) === false;\n\n\t\t\t}\n\n\t\t\tgeometry.setAttribute( name, attribute );\n\n\t\t}\n\n\t\treturn geometry;\n\n\t}\n\n\t_assignVertexColorSpace( attribute, inputColorSpace ) {\n\n\t\t// While .drc files do not specify colorspace, the only 'official' tooling\n\t\t// is PLY and OBJ converters, which use sRGB. We'll assume sRGB when a .drc\n\t\t// file is passed into .load() or .parse(). GLTFLoader uses internal APIs\n\t\t// to decode geometry, and vertex colors are already Linear-sRGB in there.\n\n\t\tif ( inputColorSpace !== SRGBColorSpace ) return;\n\n\t\tconst _color = new Color();\n\n\t\tfor ( let i = 0, il = attribute.count; i < il; i ++ ) {\n\n\t\t\t_color.fromBufferAttribute( attribute, i ).convertSRGBToLinear();\n\t\t\tattribute.setXYZ( i, _color.r, _color.g, _color.b );\n\n\t\t}\n\n\t}\n\n\t_loadLibrary( url, responseType ) {\n\n\t\tconst loader = new FileLoader( this.manager );\n\t\tloader.setPath( this.decoderPath );\n\t\tloader.setResponseType( responseType );\n\t\tloader.setWithCredentials( this.withCredentials );\n\n\t\treturn new Promise( ( resolve, reject ) => {\n\n\t\t\tloader.load( url, resolve, undefined, reject );\n\n\t\t} );\n\n\t}\n\n\tpreload() {\n\n\t\tthis._initDecoder();\n\n\t\treturn this;\n\n\t}\n\n\t_initDecoder() {\n\n\t\tif ( this.decoderPending ) return this.decoderPending;\n\n\t\tconst useJS = typeof WebAssembly !== 'object' || this.decoderConfig.type === 'js';\n\t\tconst librariesPending = [];\n\n\t\tif ( useJS ) {\n\n\t\t\tlibrariesPending.push( this._loadLibrary( 'draco_decoder.js', 'text' ) );\n\n\t\t} else {\n\n\t\t\tlibrariesPending.push( this._loadLibrary( 'draco_wasm_wrapper.js', 'text' ) );\n\t\t\tlibrariesPending.push( this._loadLibrary( 'draco_decoder.wasm', 'arraybuffer' ) );\n\n\t\t}\n\n\t\tthis.decoderPending = Promise.all( librariesPending )\n\t\t\t.then( ( libraries ) => {\n\n\t\t\t\tconst jsContent = libraries[ 0 ];\n\n\t\t\t\tif ( ! useJS ) {\n\n\t\t\t\t\tthis.decoderConfig.wasmBinary = libraries[ 1 ];\n\n\t\t\t\t}\n\n\t\t\t\tconst fn = DRACOWorker.toString();\n\n\t\t\t\tconst body = [\n\t\t\t\t\t'/* draco decoder */',\n\t\t\t\t\tjsContent,\n\t\t\t\t\t'',\n\t\t\t\t\t'/* worker */',\n\t\t\t\t\tfn.substring( fn.indexOf( '{' ) + 1, fn.lastIndexOf( '}' ) )\n\t\t\t\t].join( '\\n' );\n\n\t\t\t\tthis.workerSourceURL = URL.createObjectURL( new Blob( [ body ] ) );\n\n\t\t\t} );\n\n\t\treturn this.decoderPending;\n\n\t}\n\n\t_getWorker( taskID, taskCost ) {\n\n\t\treturn this._initDecoder().then( () => {\n\n\t\t\tif ( this.workerPool.length < this.workerLimit ) {\n\n\t\t\t\tconst worker = new Worker( this.workerSourceURL );\n\n\t\t\t\tworker._callbacks = {};\n\t\t\t\tworker._taskCosts = {};\n\t\t\t\tworker._taskLoad = 0;\n\n\t\t\t\tworker.postMessage( { type: 'init', decoderConfig: this.decoderConfig } );\n\n\t\t\t\tworker.onmessage = function ( e ) {\n\n\t\t\t\t\tconst message = e.data;\n\n\t\t\t\t\tswitch ( message.type ) {\n\n\t\t\t\t\t\tcase 'decode':\n\t\t\t\t\t\t\tworker._callbacks[ message.id ].resolve( message );\n\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t\tcase 'error':\n\t\t\t\t\t\t\tworker._callbacks[ message.id ].reject( message );\n\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t\tdefault:\n\t\t\t\t\t\t\tconsole.error( 'THREE.DRACOLoader: Unexpected message, \"' + message.type + '\"' );\n\n\t\t\t\t\t}\n\n\t\t\t\t};\n\n\t\t\t\tthis.workerPool.push( worker );\n\n\t\t\t} else {\n\n\t\t\t\tthis.workerPool.sort( function ( a, b ) {\n\n\t\t\t\t\treturn a._taskLoad > b._taskLoad ? - 1 : 1;\n\n\t\t\t\t} );\n\n\t\t\t}\n\n\t\t\tconst worker = this.workerPool[ this.workerPool.length - 1 ];\n\t\t\tworker._taskCosts[ taskID ] = taskCost;\n\t\t\tworker._taskLoad += taskCost;\n\t\t\treturn worker;\n\n\t\t} );\n\n\t}\n\n\t_releaseTask( worker, taskID ) {\n\n\t\tworker._taskLoad -= worker._taskCosts[ taskID ];\n\t\tdelete worker._callbacks[ taskID ];\n\t\tdelete worker._taskCosts[ taskID ];\n\n\t}\n\n\tdebug() {\n\n\t\tconsole.log( 'Task load: ', this.workerPool.map( ( worker ) => worker._taskLoad ) );\n\n\t}\n\n\tdispose() {\n\n\t\tfor ( let i = 0; i < this.workerPool.length; ++ i ) {\n\n\t\t\tthis.workerPool[ i ].terminate();\n\n\t\t}\n\n\t\tthis.workerPool.length = 0;\n\n\t\tif ( this.workerSourceURL !== '' ) {\n\n\t\t\tURL.revokeObjectURL( this.workerSourceURL );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n}\n\n/* WEB WORKER */\n\nfunction DRACOWorker() {\n\n\tlet decoderConfig;\n\tlet decoderPending;\n\n\tonmessage = function ( e ) {\n\n\t\tconst message = e.data;\n\n\t\tswitch ( message.type ) {\n\n\t\t\tcase 'init':\n\t\t\t\tdecoderConfig = message.decoderConfig;\n\t\t\t\tdecoderPending = new Promise( function ( resolve/*, reject*/ ) {\n\n\t\t\t\t\tdecoderConfig.onModuleLoaded = function ( draco ) {\n\n\t\t\t\t\t\t// Module is Promise-like. Wrap before resolving to avoid loop.\n\t\t\t\t\t\tresolve( { draco: draco } );\n\n\t\t\t\t\t};\n\n\t\t\t\t\tDracoDecoderModule( decoderConfig ); // eslint-disable-line no-undef\n\n\t\t\t\t} );\n\t\t\t\tbreak;\n\n\t\t\tcase 'decode':\n\t\t\t\tconst buffer = message.buffer;\n\t\t\t\tconst taskConfig = message.taskConfig;\n\t\t\t\tdecoderPending.then( ( module ) => {\n\n\t\t\t\t\tconst draco = module.draco;\n\t\t\t\t\tconst decoder = new draco.Decoder();\n\n\t\t\t\t\ttry {\n\n\t\t\t\t\t\tconst geometry = decodeGeometry( draco, decoder, new Int8Array( buffer ), taskConfig );\n\n\t\t\t\t\t\tconst buffers = geometry.attributes.map( ( attr ) => attr.array.buffer );\n\n\t\t\t\t\t\tif ( geometry.index ) buffers.push( geometry.index.array.buffer );\n\n\t\t\t\t\t\tself.postMessage( { type: 'decode', id: message.id, geometry }, buffers );\n\n\t\t\t\t\t} catch ( error ) {\n\n\t\t\t\t\t\tconsole.error( error );\n\n\t\t\t\t\t\tself.postMessage( { type: 'error', id: message.id, error: error.message } );\n\n\t\t\t\t\t} finally {\n\n\t\t\t\t\t\tdraco.destroy( decoder );\n\n\t\t\t\t\t}\n\n\t\t\t\t} );\n\t\t\t\tbreak;\n\n\t\t}\n\n\t};\n\n\tfunction decodeGeometry( draco, decoder, array, taskConfig ) {\n\n\t\tconst attributeIDs = taskConfig.attributeIDs;\n\t\tconst attributeTypes = taskConfig.attributeTypes;\n\n\t\tlet dracoGeometry;\n\t\tlet decodingStatus;\n\n\t\tconst geometryType = decoder.GetEncodedGeometryType( array );\n\n\t\tif ( geometryType === draco.TRIANGULAR_MESH ) {\n\n\t\t\tdracoGeometry = new draco.Mesh();\n\t\t\tdecodingStatus = decoder.DecodeArrayToMesh( array, array.byteLength, dracoGeometry );\n\n\t\t} else if ( geometryType === draco.POINT_CLOUD ) {\n\n\t\t\tdracoGeometry = new draco.PointCloud();\n\t\t\tdecodingStatus = decoder.DecodeArrayToPointCloud( array, array.byteLength, dracoGeometry );\n\n\t\t} else {\n\n\t\t\tthrow new Error( 'THREE.DRACOLoader: Unexpected geometry type.' );\n\n\t\t}\n\n\t\tif ( ! decodingStatus.ok() || dracoGeometry.ptr === 0 ) {\n\n\t\t\tthrow new Error( 'THREE.DRACOLoader: Decoding failed: ' + decodingStatus.error_msg() );\n\n\t\t}\n\n\t\tconst geometry = { index: null, attributes: [] };\n\n\t\t// Gather all vertex attributes.\n\t\tfor ( const attributeName in attributeIDs ) {\n\n\t\t\tconst attributeType = self[ attributeTypes[ attributeName ] ];\n\n\t\t\tlet attribute;\n\t\t\tlet attributeID;\n\n\t\t\t// A Draco file may be created with default vertex attributes, whose attribute IDs\n\t\t\t// are mapped 1:1 from their semantic name (POSITION, NORMAL, ...). Alternatively,\n\t\t\t// a Draco file may contain a custom set of attributes, identified by known unique\n\t\t\t// IDs. glTF files always do the latter, and `.drc` files typically do the former.\n\t\t\tif ( taskConfig.useUniqueIDs ) {\n\n\t\t\t\tattributeID = attributeIDs[ attributeName ];\n\t\t\t\tattribute = decoder.GetAttributeByUniqueId( dracoGeometry, attributeID );\n\n\t\t\t} else {\n\n\t\t\t\tattributeID = decoder.GetAttributeId( dracoGeometry, draco[ attributeIDs[ attributeName ] ] );\n\n\t\t\t\tif ( attributeID === - 1 ) continue;\n\n\t\t\t\tattribute = decoder.GetAttribute( dracoGeometry, attributeID );\n\n\t\t\t}\n\n\t\t\tconst attributeResult = decodeAttribute( draco, decoder, dracoGeometry, attributeName, attributeType, attribute );\n\n\t\t\tif ( attributeName === 'color' ) {\n\n\t\t\t\tattributeResult.vertexColorSpace = taskConfig.vertexColorSpace;\n\n\t\t\t}\n\n\t\t\tgeometry.attributes.push( attributeResult );\n\n\t\t}\n\n\t\t// Add index.\n\t\tif ( geometryType === draco.TRIANGULAR_MESH ) {\n\n\t\t\tgeometry.index = decodeIndex( draco, decoder, dracoGeometry );\n\n\t\t}\n\n\t\tdraco.destroy( dracoGeometry );\n\n\t\treturn geometry;\n\n\t}\n\n\tfunction decodeIndex( draco, decoder, dracoGeometry ) {\n\n\t\tconst numFaces = dracoGeometry.num_faces();\n\t\tconst numIndices = numFaces * 3;\n\t\tconst byteLength = numIndices * 4;\n\n\t\tconst ptr = draco._malloc( byteLength );\n\t\tdecoder.GetTrianglesUInt32Array( dracoGeometry, byteLength, ptr );\n\t\tconst index = new Uint32Array( draco.HEAPF32.buffer, ptr, numIndices ).slice();\n\t\tdraco._free( ptr );\n\n\t\treturn { array: index, itemSize: 1 };\n\n\t}\n\n\tfunction decodeAttribute( draco, decoder, dracoGeometry, attributeName, attributeType, attribute ) {\n\n\t\tconst numComponents = attribute.num_components();\n\t\tconst numPoints = dracoGeometry.num_points();\n\t\tconst numValues = numPoints * numComponents;\n\t\tconst byteLength = numValues * attributeType.BYTES_PER_ELEMENT;\n\t\tconst dataType = getDracoDataType( draco, attributeType );\n\n\t\tconst ptr = draco._malloc( byteLength );\n\t\tdecoder.GetAttributeDataArrayForAllPoints( dracoGeometry, attribute, dataType, byteLength, ptr );\n\t\tconst array = new attributeType( draco.HEAPF32.buffer, ptr, numValues ).slice();\n\t\tdraco._free( ptr );\n\n\t\treturn {\n\t\t\tname: attributeName,\n\t\t\tarray: array,\n\t\t\titemSize: numComponents\n\t\t};\n\n\t}\n\n\tfunction getDracoDataType( draco, attributeType ) {\n\n\t\tswitch ( attributeType ) {\n\n\t\t\tcase Float32Array: return draco.DT_FLOAT32;\n\t\t\tcase Int8Array: return draco.DT_INT8;\n\t\t\tcase Int16Array: return draco.DT_INT16;\n\t\t\tcase Int32Array: return draco.DT_INT32;\n\t\t\tcase Uint8Array: return draco.DT_UINT8;\n\t\t\tcase Uint16Array: return draco.DT_UINT16;\n\t\t\tcase Uint32Array: return draco.DT_UINT32;\n\n\t\t}\n\n\t}\n\n}\n\nexport { DRACOLoader };\n", "// This file is part of meshoptimizer library and is distributed under the terms of MIT License.\n// Copyright (C) 2016-2022, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)\nvar MeshoptDecoder = (function() {\n\t\"use strict\";\n\n\t// Built with clang version 14.0.4\n\t// Built from meshoptimizer 0.18\n\tvar wasm_base = \"b9H79Tebbbe8Fv9Gbb9Gvuuuuueu9Giuuub9Geueu9Giuuueuikqbeeedddillviebeoweuec:q;iekr;leDo9TW9T9VV95dbH9F9F939H79T9F9J9H229F9Jt9VV7bb8A9TW79O9V9Wt9F9KW9J9V9KW9wWVtW949c919M9MWVbeY9TW79O9V9Wt9F9KW9J9V9KW69U9KW949c919M9MWVbdE9TW79O9V9Wt9F9KW9J9V9KW69U9KW949tWG91W9U9JWbiL9TW79O9V9Wt9F9KW9J9V9KWS9P2tWV9p9JtblK9TW79O9V9Wt9F9KW9J9V9KWS9P2tWV9r919HtbvL9TW79O9V9Wt9F9KW9J9V9KWS9P2tWVT949Wbol79IV9Rbrq:P8Yqdbk;3sezu8Jjjjjbcj;eb9Rgv8Kjjjjbc9:hodnadcefal0mbcuhoaiRbbc:Ge9hmbavaialfgrad9Radz1jjjbhwcj;abad9UhoaicefhldnadTmbaoc;WFbGgocjdaocjd6EhDcbhqinaqae9pmeaDaeaq9RaqaDfae6Egkcsfgocl4cifcd4hxdndndndnaoc9WGgmTmbcbhPcehsawcjdfhzalhHinaraH9Rax6midnaraHaxfgl9RcK6mbczhoinawcj;cbfaogifgoc9WfhOdndndndndnaHaic9WfgAco4fRbbaAci4coG4ciGPlbedibkaO9cb83ibaOcwf9cb83ibxikaOalRblalRbbgAco4gCaCciSgCE86bbaocGfalclfaCfgORbbaAcl4ciGgCaCciSgCE86bbaocVfaOaCfgORbbaAcd4ciGgCaCciSgCE86bbaoc7faOaCfgORbbaAciGgAaAciSgAE86bbaoctfaOaAfgARbbalRbegOco4gCaCciSgCE86bbaoc91faAaCfgARbbaOcl4ciGgCaCciSgCE86bbaoc4faAaCfgARbbaOcd4ciGgCaCciSgCE86bbaoc93faAaCfgARbbaOciGgOaOciSgOE86bbaoc94faAaOfgARbbalRbdgOco4gCaCciSgCE86bbaoc95faAaCfgARbbaOcl4ciGgCaCciSgCE86bbaoc96faAaCfgARbbaOcd4ciGgCaCciSgCE86bbaoc97faAaCfgARbbaOciGgOaOciSgOE86bbaoc98faAaOfgORbbalRbiglco4gAaAciSgAE86bbaoc99faOaAfgORbbalcl4ciGgAaAciSgAE86bbaoc9:faOaAfgORbbalcd4ciGgAaAciSgAE86bbaocufaOaAfgoRbbalciGglalciSglE86bbaoalfhlxdkaOalRbwalRbbgAcl4gCaCcsSgCE86bbaocGfalcwfaCfgORbbaAcsGgAaAcsSgAE86bbaocVfaOaAfgORbbalRbegAcl4gCaCcsSgCE86bbaoc7faOaCfgORbbaAcsGgAaAcsSgAE86bbaoctfaOaAfgORbbalRbdgAcl4gCaCcsSgCE86bbaoc91faOaCfgORbbaAcsGgAaAcsSgAE86bbaoc4faOaAfgORbbalRbigAcl4gCaCcsSgCE86bbaoc93faOaCfgORbbaAcsGgAaAcsSgAE86bbaoc94faOaAfgORbbalRblgAcl4gCaCcsSgCE86bbaoc95faOaCfgORbbaAcsGgAaAcsSgAE86bbaoc96faOaAfgORbbalRbvgAcl4gCaCcsSgCE86bbaoc97faOaCfgORbbaAcsGgAaAcsSgAE86bbaoc98faOaAfgORbbalRbogAcl4gCaCcsSgCE86bbaoc99faOaCfgORbbaAcsGgAaAcsSgAE86bbaoc9:faOaAfgORbbalRbrglcl4gAaAcsSgAE86bbaocufaOaAfgoRbbalcsGglalcsSglE86bbaoalfhlxekaOal8Pbb83bbaOcwfalcwf8Pbb83bbalczfhlkdnaiam9pmbaiczfhoaral9RcL0mekkaiam6mialTmidnakTmbawaPfRbbhOcbhoazhiinaiawcj;cbfaofRbbgAce4cbaAceG9R7aOfgO86bbaiadfhiaocefgoak9hmbkkazcefhzaPcefgPad6hsalhHaPad9hmexvkkcbhlasceGmdxikalaxad2fhCdnakTmbcbhHcehsawcjdfhminaral9Rax6mialTmdalaxfhlawaHfRbbhOcbhoamhiinaiawcj;cbfaofRbbgAce4cbaAceG9R7aOfgO86bbaiadfhiaocefgoak9hmbkamcefhmaHcefgHad6hsaHad9hmbkaChlxikcbhocehsinaral9Rax6mdalTmealaxfhlaocefgoad6hsadao9hmbkaChlxdkcbhlasceGTmekc9:hoxikabaqad2fawcjdfakad2z1jjjb8Aawawcjdfakcufad2fadz1jjjb8Aakaqfhqalmbkc9:hoxekcbc99aral9Radcaadca0ESEhokavcj;ebf8Kjjjjbaok;yzeHu8Jjjjjbc;ae9Rgv8Kjjjjbc9:hodnaeci9UgrcHfal0mbcuhoaiRbbgwc;WeGc;Ge9hmbawcsGgDce0mbavc;abfcFecjez:jjjjb8AavcUf9cu83ibavc8Wf9cu83ibavcyf9cu83ibavcaf9cu83ibavcKf9cu83ibavczf9cu83ibav9cu83iwav9cu83ibaialfc9WfhqaicefgwarfhodnaeTmbcmcsaDceSEhkcbhxcbhmcbhDcbhicbhlindnaoaq9nmbc9:hoxikdndnawRbbgrc;Ve0mbavc;abfalarcl4cu7fcsGcitfgPydlhsaPydbhzdnarcsGgPak9pmbavaiarcu7fcsGcdtfydbaxaPEhraPThPdndnadcd9hmbabaDcetfgHaz87ebaHcdfas87ebaHclfar87ebxekabaDcdtfgHazBdbaHclfasBdbaHcwfarBdbkaxaPfhxavc;abfalcitfgHarBdbaHasBdlavaicdtfarBdbavc;abfalcefcsGglcitfgHazBdbaHarBdlaiaPfhialcefhlxdkdndnaPcsSmbamaPfaPc987fcefhmxekaocefhrao8SbbgPcFeGhHdndnaPcu9mmbarhoxekaocvfhoaHcFbGhHcrhPdninar8SbbgOcFbGaPtaHVhHaOcu9kmearcefhraPcrfgPc8J9hmbxdkkarcefhokaHce4cbaHceG9R7amfhmkdndnadcd9hmbabaDcetfgraz87ebarcdfas87ebarclfam87ebxekabaDcdtfgrazBdbarclfasBdbarcwfamBdbkavc;abfalcitfgramBdbarasBdlavaicdtfamBdbavc;abfalcefcsGglcitfgrazBdbaramBdlaicefhialcefhlxekdnarcpe0mbaxcefgOavaiaqarcsGfRbbgPcl49RcsGcdtfydbaPcz6gHEhravaiaP9RcsGcdtfydbaOaHfgsaPcsGgOEhPaOThOdndnadcd9hmbabaDcetfgzax87ebazcdfar87ebazclfaP87ebxekabaDcdtfgzaxBdbazclfarBdbazcwfaPBdbkavaicdtfaxBdbavc;abfalcitfgzarBdbazaxBdlavaicefgicsGcdtfarBdbavc;abfalcefcsGcitfgzaPBdbazarBdlavaiaHfcsGgicdtfaPBdbavc;abfalcdfcsGglcitfgraxBdbaraPBdlalcefhlaiaOfhiasaOfhxxekaxcbaoRbbgzEgAarc;:eSgrfhsazcsGhCazcl4hXdndnazcs0mbascefhOxekashOavaiaX9RcsGcdtfydbhskdndnaCmbaOcefhxxekaOhxavaiaz9RcsGcdtfydbhOkdndnarTmbaocefhrxekaocdfhrao8SbegHcFeGhPdnaHcu9kmbaocofhAaPcFbGhPcrhodninar8SbbgHcFbGaotaPVhPaHcu9kmearcefhraocrfgoc8J9hmbkaAhrxekarcefhrkaPce4cbaPceG9R7amfgmhAkdndnaXcsSmbarhPxekarcefhPar8SbbgocFeGhHdnaocu9kmbarcvfhsaHcFbGhHcrhodninaP8SbbgrcFbGaotaHVhHarcu9kmeaPcefhPaocrfgoc8J9hmbkashPxekaPcefhPkaHce4cbaHceG9R7amfgmhskdndnaCcsSmbaPhoxekaPcefhoaP8SbbgrcFeGhHdnarcu9kmbaPcvfhOaHcFbGhHcrhrdninao8SbbgPcFbGartaHVhHaPcu9kmeaocefhoarcrfgrc8J9hmbkaOhoxekaocefhokaHce4cbaHceG9R7amfgmhOkdndnadcd9hmbabaDcetfgraA87ebarcdfas87ebarclfaO87ebxekabaDcdtfgraABdbarclfasBdbarcwfaOBdbkavc;abfalcitfgrasBdbaraABdlavaicdtfaABdbavc;abfalcefcsGcitfgraOBdbarasBdlavaicefgicsGcdtfasBdbavc;abfalcdfcsGcitfgraABdbaraOBdlavaiazcz6aXcsSVfgicsGcdtfaOBdbaiaCTaCcsSVfhialcifhlkawcefhwalcsGhlaicsGhiaDcifgDae6mbkkcbc99aoaqSEhokavc;aef8Kjjjjbaok:llevu8Jjjjjbcz9Rhvc9:hodnaecvfal0mbcuhoaiRbbc;:eGc;qe9hmbav9cb83iwaicefhraialfc98fhwdnaeTmbdnadcdSmbcbhDindnaraw6mbc9:skarcefhoar8SbbglcFeGhidndnalcu9mmbaohrxekarcvfhraicFbGhicrhldninao8SbbgdcFbGaltaiVhiadcu9kmeaocefhoalcrfglc8J9hmbxdkkaocefhrkabaDcdtfaicd4cbaice4ceG9R7avcwfaiceGcdtVgoydbfglBdbaoalBdbaDcefgDae9hmbxdkkcbhDindnaraw6mbc9:skarcefhoar8SbbglcFeGhidndnalcu9mmbaohrxekarcvfhraicFbGhicrhldninao8SbbgdcFbGaltaiVhiadcu9kmeaocefhoalcrfglc8J9hmbxdkkaocefhrkabaDcetfaicd4cbaice4ceG9R7avcwfaiceGcdtVgoydbfgl87ebaoalBdbaDcefgDae9hmbkkcbc99arawSEhokaok:Lvoeue99dud99eud99dndnadcl9hmbaeTmeindndnabcdfgd8Sbb:Yab8Sbbgi:Ygl:l:tabcefgv8Sbbgo:Ygr:l:tgwJbb;:9cawawNJbbbbawawJbbbb9GgDEgq:mgkaqaicb9iEalMgwawNakaqaocb9iEarMgqaqNMM:r:vglNJbbbZJbbb:;aDEMgr:lJbbb9p9DTmbar:Ohixekcjjjj94hikadai86bbdndnaqalNJbbbZJbbb:;aqJbbbb9GEMgq:lJbbb9p9DTmbaq:Ohdxekcjjjj94hdkavad86bbdndnawalNJbbbZJbbb:;awJbbbb9GEMgw:lJbbb9p9DTmbaw:Ohdxekcjjjj94hdkabad86bbabclfhbaecufgembxdkkaeTmbindndnabclfgd8Ueb:Yab8Uebgi:Ygl:l:tabcdfgv8Uebgo:Ygr:l:tgwJb;:FSawawNJbbbbawawJbbbb9GgDEgq:mgkaqaicb9iEalMgwawNakaqaocb9iEarMgqaqNMM:r:vglNJbbbZJbbb:;aDEMgr:lJbbb9p9DTmbar:Ohixekcjjjj94hikadai87ebdndnaqalNJbbbZJbbb:;aqJbbbb9GEMgq:lJbbb9p9DTmbaq:Ohdxekcjjjj94hdkavad87ebdndnawalNJbbbZJbbb:;awJbbbb9GEMgw:lJbbb9p9DTmbaw:Ohdxekcjjjj94hdkabad87ebabcwfhbaecufgembkkk;siliui99iue99dnaeTmbcbhiabhlindndnJ;Zl81Zalcof8UebgvciV:Y:vgoal8Ueb:YNgrJb;:FSNJbbbZJbbb:;arJbbbb9GEMgw:lJbbb9p9DTmbaw:OhDxekcjjjj94hDkalclf8Uebhqalcdf8UebhkabavcefciGaiVcetfaD87ebdndnaoak:YNgwJb;:FSNJbbbZJbbb:;awJbbbb9GEMgx:lJbbb9p9DTmbax:Ohkxekcjjjj94hkkabavcdfciGaiVcetfak87ebdndnaoaq:YNgoJb;:FSNJbbbZJbbb:;aoJbbbb9GEMgx:lJbbb9p9DTmbax:Ohqxekcjjjj94hqkabavcufciGaiVcetfaq87ebdndnJbbjZararN:tawawN:taoaoN:tgrJbbbbarJbbbb9GE:rJb;:FSNJbbbZMgr:lJbbb9p9DTmbar:Ohqxekcjjjj94hqkabavciGaiVcetfaq87ebalcwfhlaiclfhiaecufgembkkk9mbdnadcd4ae2geTmbinababydbgdcwtcw91:Yadce91cjjj;8ifcjjj98G::NUdbabclfhbaecufgembkkk9teiucbcbydj1jjbgeabcifc98GfgbBdj1jjbdndnabZbcztgd9nmbcuhiabad9RcFFifcz4nbcuSmekaehikaik;LeeeudndnaeabVciGTmbabhixekdndnadcz9pmbabhixekabhiinaiaeydbBdbaiclfaeclfydbBdbaicwfaecwfydbBdbaicxfaecxfydbBdbaiczfhiaeczfheadc9Wfgdcs0mbkkadcl6mbinaiaeydbBdbaeclfheaiclfhiadc98fgdci0mbkkdnadTmbinaiaeRbb86bbaicefhiaecefheadcufgdmbkkabk;aeedudndnabciGTmbabhixekaecFeGc:b:c:ew2hldndnadcz9pmbabhixekabhiinaialBdbaicxfalBdbaicwfalBdbaiclfalBdbaiczfhiadc9Wfgdcs0mbkkadcl6mbinaialBdbaiclfhiadc98fgdci0mbkkdnadTmbinaiae86bbaicefhiadcufgdmbkkabkkkebcjwklz9Kbb\";\n\tvar wasm_simd = \"b9H79TebbbeKl9Gbb9Gvuuuuueu9Giuuub9Geueuikqbbebeedddilve9Weeeviebeoweuec:q;Aekr;leDo9TW9T9VV95dbH9F9F939H79T9F9J9H229F9Jt9VV7bb8A9TW79O9V9Wt9F9KW9J9V9KW9wWVtW949c919M9MWVbdY9TW79O9V9Wt9F9KW9J9V9KW69U9KW949c919M9MWVblE9TW79O9V9Wt9F9KW9J9V9KW69U9KW949tWG91W9U9JWbvL9TW79O9V9Wt9F9KW9J9V9KWS9P2tWV9p9JtboK9TW79O9V9Wt9F9KW9J9V9KWS9P2tWV9r919HtbrL9TW79O9V9Wt9F9KW9J9V9KWS9P2tWVT949Wbwl79IV9RbDq;t9tqlbzik9:evu8Jjjjjbcz9Rhbcbheincbhdcbhiinabcwfadfaicjuaead4ceGglE86bbaialfhiadcefgdcw9hmbkaec:q:yjjbfai86bbaecitc:q1jjbfab8Piw83ibaecefgecjd9hmbkk;h8JlHud97euo978Jjjjjbcj;kb9Rgv8Kjjjjbc9:hodnadcefal0mbcuhoaiRbbc:Ge9hmbavaialfgrad9Rad;8qbbcj;abad9UhoaicefhldnadTmbaoc;WFbGgocjdaocjd6EhwcbhDinaDae9pmeawaeaD9RaDawfae6Egqcsfgoc9WGgkci2hxakcethmaocl4cifcd4hPabaDad2fhscbhzdnincehHalhOcbhAdninaraO9RaP6miavcj;cbfaAak2fhCaOaPfhlcbhidnakc;ab6mbaral9Rc;Gb6mbcbhoinaCaofhidndndndndnaOaoco4fRbbgXciGPlbedibkaipxbbbbbbbbbbbbbbbbpklbxikaialpbblalpbbbgQclp:meaQpmbzeHdOiAlCvXoQrLgQcdp:meaQpmbzeHdOiAlCvXoQrLpxiiiiiiiiiiiiiiiip9ogLpxiiiiiiiiiiiiiiiip8JgQp5b9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibaKc:q:yjjbfpbbbgYaYpmbbbbbbbbbbbbbbbbaQp5e9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibp9UpmbedilvorzHOACXQLpPaLaQp9spklbalclfaYpQbfaKc:q:yjjbfRbbfhlxdkaialpbbwalpbbbgQclp:meaQpmbzeHdOiAlCvXoQrLpxssssssssssssssssp9ogLpxssssssssssssssssp8JgQp5b9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibaKc:q:yjjbfpbbbgYaYpmbbbbbbbbbbbbbbbbaQp5e9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibp9UpmbedilvorzHOACXQLpPaLaQp9spklbalcwfaYpQbfaKc:q:yjjbfRbbfhlxekaialpbbbpklbalczfhlkdndndndndnaXcd4ciGPlbedibkaipxbbbbbbbbbbbbbbbbpklzxikaialpbblalpbbbgQclp:meaQpmbzeHdOiAlCvXoQrLgQcdp:meaQpmbzeHdOiAlCvXoQrLpxiiiiiiiiiiiiiiiip9ogLpxiiiiiiiiiiiiiiiip8JgQp5b9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibaKc:q:yjjbfpbbbgYaYpmbbbbbbbbbbbbbbbbaQp5e9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibp9UpmbedilvorzHOACXQLpPaLaQp9spklzalclfaYpQbfaKc:q:yjjbfRbbfhlxdkaialpbbwalpbbbgQclp:meaQpmbzeHdOiAlCvXoQrLpxssssssssssssssssp9ogLpxssssssssssssssssp8JgQp5b9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibaKc:q:yjjbfpbbbgYaYpmbbbbbbbbbbbbbbbbaQp5e9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibp9UpmbedilvorzHOACXQLpPaLaQp9spklzalcwfaYpQbfaKc:q:yjjbfRbbfhlxekaialpbbbpklzalczfhlkdndndndndnaXcl4ciGPlbedibkaipxbbbbbbbbbbbbbbbbpklaxikaialpbblalpbbbgQclp:meaQpmbzeHdOiAlCvXoQrLgQcdp:meaQpmbzeHdOiAlCvXoQrLpxiiiiiiiiiiiiiiiip9ogLpxiiiiiiiiiiiiiiiip8JgQp5b9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibaKc:q:yjjbfpbbbgYaYpmbbbbbbbbbbbbbbbbaQp5e9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibp9UpmbedilvorzHOACXQLpPaLaQp9spklaalclfaYpQbfaKc:q:yjjbfRbbfhlxdkaialpbbwalpbbbgQclp:meaQpmbzeHdOiAlCvXoQrLpxssssssssssssssssp9ogLpxssssssssssssssssp8JgQp5b9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibaKc:q:yjjbfpbbbgYaYpmbbbbbbbbbbbbbbbbaQp5e9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibp9UpmbedilvorzHOACXQLpPaLaQp9spklaalcwfaYpQbfaKc:q:yjjbfRbbfhlxekaialpbbbpklaalczfhlkdndndndndnaXco4Plbedibkaipxbbbbbbbbbbbbbbbbpkl8WxikaialpbblalpbbbgQclp:meaQpmbzeHdOiAlCvXoQrLgQcdp:meaQpmbzeHdOiAlCvXoQrLpxiiiiiiiiiiiiiiiip9ogLpxiiiiiiiiiiiiiiiip8JgQp5b9cjF;8;4;W;G;ab9:9cU1:NgXcitc:q1jjbfpbibaXc:q:yjjbfpbbbgYaYpmbbbbbbbbbbbbbbbbaQp5e9cjF;8;4;W;G;ab9:9cU1:NgXcitc:q1jjbfpbibp9UpmbedilvorzHOACXQLpPaLaQp9spkl8WalclfaYpQbfaXc:q:yjjbfRbbfhlxdkaialpbbwalpbbbgQclp:meaQpmbzeHdOiAlCvXoQrLpxssssssssssssssssp9ogLpxssssssssssssssssp8JgQp5b9cjF;8;4;W;G;ab9:9cU1:NgXcitc:q1jjbfpbibaXc:q:yjjbfpbbbgYaYpmbbbbbbbbbbbbbbbbaQp5e9cjF;8;4;W;G;ab9:9cU1:NgXcitc:q1jjbfpbibp9UpmbedilvorzHOACXQLpPaLaQp9spkl8WalcwfaYpQbfaXc:q:yjjbfRbbfhlxekaialpbbbpkl8Walczfhlkaoc;abfhiaocjefak0meaihoaral9Rc;Fb0mbkkdndnaiak9pmbaici4hoinaral9RcK6mdaCaifhXdndndndndnaOaico4fRbbaocoG4ciGPlbedibkaXpxbbbbbbbbbbbbbbbbpklbxikaXalpbblalpbbbgQclp:meaQpmbzeHdOiAlCvXoQrLgQcdp:meaQpmbzeHdOiAlCvXoQrLpxiiiiiiiiiiiiiiiip9ogLpxiiiiiiiiiiiiiiiip8JgQp5b9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibaKc:q:yjjbfpbbbgYaYpmbbbbbbbbbbbbbbbbaQp5e9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibp9UpmbedilvorzHOACXQLpPaLaQp9spklbalclfaYpQbfaKc:q:yjjbfRbbfhlxdkaXalpbbwalpbbbgQclp:meaQpmbzeHdOiAlCvXoQrLpxssssssssssssssssp9ogLpxssssssssssssssssp8JgQp5b9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibaKc:q:yjjbfpbbbgYaYpmbbbbbbbbbbbbbbbbaQp5e9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibp9UpmbedilvorzHOACXQLpPaLaQp9spklbalcwfaYpQbfaKc:q:yjjbfRbbfhlxekaXalpbbbpklbalczfhlkaocdfhoaiczfgiak6mbkkalTmbaAci6hHalhOaAcefgohAaoclSmdxekkcbhlaHceGmdkdnakTmbavcjdfazfhiavazfpbdbhYcbhXinaiavcj;cbfaXfgopblbgLcep9TaLpxeeeeeeeeeeeeeeeegQp9op9Hp9rgLaoakfpblbg8Acep9Ta8AaQp9op9Hp9rg8ApmbzeHdOiAlCvXoQrLgEaoamfpblbg3cep9Ta3aQp9op9Hp9rg3aoaxfpblbg5cep9Ta5aQp9op9Hp9rg5pmbzeHdOiAlCvXoQrLg8EpmbezHdiOAlvCXorQLgQaQpmbedibedibedibediaYp9UgYp9AdbbaiadfgoaYaQaQpmlvorlvorlvorlvorp9UgYp9AdbbaoadfgoaYaQaQpmwDqkwDqkwDqkwDqkp9UgYp9AdbbaoadfgoaYaQaQpmxmPsxmPsxmPsxmPsp9UgYp9AdbbaoadfgoaYaEa8EpmwDKYqk8AExm35Ps8E8FgQaQpmbedibedibedibedip9UgYp9AdbbaoadfgoaYaQaQpmlvorlvorlvorlvorp9UgYp9AdbbaoadfgoaYaQaQpmwDqkwDqkwDqkwDqkp9UgYp9AdbbaoadfgoaYaQaQpmxmPsxmPsxmPsxmPsp9UgYp9AdbbaoadfgoaYaLa8ApmwKDYq8AkEx3m5P8Es8FgLa3a5pmwKDYq8AkEx3m5P8Es8Fg8ApmbezHdiOAlvCXorQLgQaQpmbedibedibedibedip9UgYp9AdbbaoadfgoaYaQaQpmlvorlvorlvorlvorp9UgYp9AdbbaoadfgoaYaQaQpmwDqkwDqkwDqkwDqkp9UgYp9AdbbaoadfgoaYaQaQpmxmPsxmPsxmPsxmPsp9UgYp9AdbbaoadfgoaYaLa8ApmwDKYqk8AExm35Ps8E8FgQaQpmbedibedibedibedip9UgYp9AdbbaoadfgoaYaQaQpmlvorlvorlvorlvorp9UgYp9AdbbaoadfgoaYaQaQpmwDqkwDqkwDqkwDqkp9UgYp9AdbbaoadfgoaYaQaQpmxmPsxmPsxmPsxmPsp9UgYp9AdbbaoadfhiaXczfgXak6mbkkazclfgzad6mbkasavcjdfaqad2;8qbbavavcjdfaqcufad2fad;8qbbaqaDfhDc9:hoalmexikkc9:hoxekcbc99aral9Radcaadca0ESEhokavcj;kbf8Kjjjjbaokwbz:bjjjbk;uzeHu8Jjjjjbc;ae9Rgv8Kjjjjbc9:hodnaeci9UgrcHfal0mbcuhoaiRbbgwc;WeGc;Ge9hmbawcsGgDce0mbavc;abfcFecje;8kbavcUf9cu83ibavc8Wf9cu83ibavcyf9cu83ibavcaf9cu83ibavcKf9cu83ibavczf9cu83ibav9cu83iwav9cu83ibaialfc9WfhqaicefgwarfhodnaeTmbcmcsaDceSEhkcbhxcbhmcbhDcbhicbhlindnaoaq9nmbc9:hoxikdndnawRbbgrc;Ve0mbavc;abfalarcl4cu7fcsGcitfgPydlhsaPydbhzdnarcsGgPak9pmbavaiarcu7fcsGcdtfydbaxaPEhraPThPdndnadcd9hmbabaDcetfgHaz87ebaHcdfas87ebaHclfar87ebxekabaDcdtfgHazBdbaHclfasBdbaHcwfarBdbkaxaPfhxavc;abfalcitfgHarBdbaHasBdlavaicdtfarBdbavc;abfalcefcsGglcitfgHazBdbaHarBdlaiaPfhialcefhlxdkdndnaPcsSmbamaPfaPc987fcefhmxekaocefhrao8SbbgPcFeGhHdndnaPcu9mmbarhoxekaocvfhoaHcFbGhHcrhPdninar8SbbgOcFbGaPtaHVhHaOcu9kmearcefhraPcrfgPc8J9hmbxdkkarcefhokaHce4cbaHceG9R7amfhmkdndnadcd9hmbabaDcetfgraz87ebarcdfas87ebarclfam87ebxekabaDcdtfgrazBdbarclfasBdbarcwfamBdbkavc;abfalcitfgramBdbarasBdlavaicdtfamBdbavc;abfalcefcsGglcitfgrazBdbaramBdlaicefhialcefhlxekdnarcpe0mbaxcefgOavaiaqarcsGfRbbgPcl49RcsGcdtfydbaPcz6gHEhravaiaP9RcsGcdtfydbaOaHfgsaPcsGgOEhPaOThOdndnadcd9hmbabaDcetfgzax87ebazcdfar87ebazclfaP87ebxekabaDcdtfgzaxBdbazclfarBdbazcwfaPBdbkavaicdtfaxBdbavc;abfalcitfgzarBdbazaxBdlavaicefgicsGcdtfarBdbavc;abfalcefcsGcitfgzaPBdbazarBdlavaiaHfcsGgicdtfaPBdbavc;abfalcdfcsGglcitfgraxBdbaraPBdlalcefhlaiaOfhiasaOfhxxekaxcbaoRbbgzEgAarc;:eSgrfhsazcsGhCazcl4hXdndnazcs0mbascefhOxekashOavaiaX9RcsGcdtfydbhskdndnaCmbaOcefhxxekaOhxavaiaz9RcsGcdtfydbhOkdndnarTmbaocefhrxekaocdfhrao8SbegHcFeGhPdnaHcu9kmbaocofhAaPcFbGhPcrhodninar8SbbgHcFbGaotaPVhPaHcu9kmearcefhraocrfgoc8J9hmbkaAhrxekarcefhrkaPce4cbaPceG9R7amfgmhAkdndnaXcsSmbarhPxekarcefhPar8SbbgocFeGhHdnaocu9kmbarcvfhsaHcFbGhHcrhodninaP8SbbgrcFbGaotaHVhHarcu9kmeaPcefhPaocrfgoc8J9hmbkashPxekaPcefhPkaHce4cbaHceG9R7amfgmhskdndnaCcsSmbaPhoxekaPcefhoaP8SbbgrcFeGhHdnarcu9kmbaPcvfhOaHcFbGhHcrhrdninao8SbbgPcFbGartaHVhHaPcu9kmeaocefhoarcrfgrc8J9hmbkaOhoxekaocefhokaHce4cbaHceG9R7amfgmhOkdndnadcd9hmbabaDcetfgraA87ebarcdfas87ebarclfaO87ebxekabaDcdtfgraABdbarclfasBdbarcwfaOBdbkavc;abfalcitfgrasBdbaraABdlavaicdtfaABdbavc;abfalcefcsGcitfgraOBdbarasBdlavaicefgicsGcdtfasBdbavc;abfalcdfcsGcitfgraABdbaraOBdlavaiazcz6aXcsSVfgicsGcdtfaOBdbaiaCTaCcsSVfhialcifhlkawcefhwalcsGhlaicsGhiaDcifgDae6mbkkcbc99aoaqSEhokavc;aef8Kjjjjbaok:llevu8Jjjjjbcz9Rhvc9:hodnaecvfal0mbcuhoaiRbbc;:eGc;qe9hmbav9cb83iwaicefhraialfc98fhwdnaeTmbdnadcdSmbcbhDindnaraw6mbc9:skarcefhoar8SbbglcFeGhidndnalcu9mmbaohrxekarcvfhraicFbGhicrhldninao8SbbgdcFbGaltaiVhiadcu9kmeaocefhoalcrfglc8J9hmbxdkkaocefhrkabaDcdtfaicd4cbaice4ceG9R7avcwfaiceGcdtVgoydbfglBdbaoalBdbaDcefgDae9hmbxdkkcbhDindnaraw6mbc9:skarcefhoar8SbbglcFeGhidndnalcu9mmbaohrxekarcvfhraicFbGhicrhldninao8SbbgdcFbGaltaiVhiadcu9kmeaocefhoalcrfglc8J9hmbxdkkaocefhrkabaDcetfaicd4cbaice4ceG9R7avcwfaiceGcdtVgoydbfgl87ebaoalBdbaDcefgDae9hmbkkcbc99arawSEhokaok:EPliuo97eue978Jjjjjbca9Rhidndnadcl9hmbdnaec98GglTmbcbhvabhdinadadpbbbgocKp:RecKp:Sep;6egraocwp:RecKp:Sep;6earp;Geaoczp:RecKp:Sep;6egwp;Gep;Kep;LegDpxbbbbbbbbbbbbbbbbp:2egqarpxbbbjbbbjbbbjbbbjgkp9op9rp;Kegrpxbb;:9cbb;:9cbb;:9cbb;:9cararp;MeaDaDp;Meawaqawakp9op9rp;Kegrarp;Mep;Kep;Kep;Jep;Negwp;Mepxbbn0bbn0bbn0bbn0gqp;KepxFbbbFbbbFbbbFbbbp9oaopxbbbFbbbFbbbFbbbFp9op9qarawp;Meaqp;Kecwp:RepxbFbbbFbbbFbbbFbbp9op9qaDawp;Meaqp;Keczp:RepxbbFbbbFbbbFbbbFbp9op9qpkbbadczfhdavclfgval6mbkkalae9pmeaiaeciGgvcdtgdVcbczad9R;8kbaiabalcdtfglad;8qbbdnavTmbaiaipblbgocKp:RecKp:Sep;6egraocwp:RecKp:Sep;6earp;Geaoczp:RecKp:Sep;6egwp;Gep;Kep;LegDpxbbbbbbbbbbbbbbbbp:2egqarpxbbbjbbbjbbbjbbbjgkp9op9rp;Kegrpxbb;:9cbb;:9cbb;:9cbb;:9cararp;MeaDaDp;Meawaqawakp9op9rp;Kegrarp;Mep;Kep;Kep;Jep;Negwp;Mepxbbn0bbn0bbn0bbn0gqp;KepxFbbbFbbbFbbbFbbbp9oaopxbbbFbbbFbbbFbbbFp9op9qarawp;Meaqp;Kecwp:RepxbFbbbFbbbFbbbFbbp9op9qaDawp;Meaqp;Keczp:RepxbbFbbbFbbbFbbbFbp9op9qpklbkalaiad;8qbbskdnaec98GgxTmbcbhvabhdinadczfglalpbbbgopxbbbbbbFFbbbbbbFFgkp9oadpbbbgDaopmlvorxmPsCXQL358E8FpxFubbFubbFubbFubbp9op;6eaDaopmbediwDqkzHOAKY8AEgoczp:Sep;6egrp;Geaoczp:Reczp:Sep;6egwp;Gep;Kep;Legopxb;:FSb;:FSb;:FSb;:FSawaopxbbbbbbbbbbbbbbbbp:2egqawpxbbbjbbbjbbbjbbbjgmp9op9rp;Kegwawp;Meaoaop;Mearaqaramp9op9rp;Kegoaop;Mep;Kep;Kep;Jep;Negrp;Mepxbbn0bbn0bbn0bbn0gqp;Keczp:Reawarp;Meaqp;KepxFFbbFFbbFFbbFFbbp9op9qgwaoarp;Meaqp;KepxFFbbFFbbFFbbFFbbp9ogopmwDKYqk8AExm35Ps8E8Fp9qpkbbadaDakp9oawaopmbezHdiOAlvCXorQLp9qpkbbadcafhdavclfgvax6mbkkaxae9pmbaiaeciGgvcitgdfcbcaad9R;8kbaiabaxcitfglad;8qbbdnavTmbaiaipblzgopxbbbbbbFFbbbbbbFFgkp9oaipblbgDaopmlvorxmPsCXQL358E8FpxFubbFubbFubbFubbp9op;6eaDaopmbediwDqkzHOAKY8AEgoczp:Sep;6egrp;Geaoczp:Reczp:Sep;6egwp;Gep;Kep;Legopxb;:FSb;:FSb;:FSb;:FSawaopxbbbbbbbbbbbbbbbbp:2egqawpxbbbjbbbjbbbjbbbjgmp9op9rp;Kegwawp;Meaoaop;Mearaqaramp9op9rp;Kegoaop;Mep;Kep;Kep;Jep;Negrp;Mepxbbn0bbn0bbn0bbn0gqp;Keczp:Reawarp;Meaqp;KepxFFbbFFbbFFbbFFbbp9op9qgwaoarp;Meaqp;KepxFFbbFFbbFFbbFFbbp9ogopmwDKYqk8AExm35Ps8E8Fp9qpklzaiaDakp9oawaopmbezHdiOAlvCXorQLp9qpklbkalaiad;8qbbkk;4wllue97euv978Jjjjjbc8W9Rhidnaec98GglTmbcbhvabhoinaiaopbbbgraoczfgwpbbbgDpmlvorxmPsCXQL358E8Fgqczp:Segkclp:RepklbaopxbbjZbbjZbbjZbbjZpx;Zl81Z;Zl81Z;Zl81Z;Zl81Zakpxibbbibbbibbbibbbp9qp;6ep;NegkaraDpmbediwDqkzHOAKY8AEgrczp:Reczp:Sep;6ep;MegDaDp;Meakarczp:Sep;6ep;Megxaxp;Meakaqczp:Reczp:Sep;6ep;Megqaqp;Mep;Kep;Kep;Lepxbbbbbbbbbbbbbbbbp:4ep;Jepxb;:FSb;:FSb;:FSb;:FSgkp;Mepxbbn0bbn0bbn0bbn0grp;KepxFFbbFFbbFFbbFFbbgmp9oaxakp;Mearp;Keczp:Rep9qgxaqakp;Mearp;Keczp:ReaDakp;Mearp;Keamp9op9qgkpmbezHdiOAlvCXorQLgrp5baipblbpEb:T:j83ibaocwfarp5eaipblbpEe:T:j83ibawaxakpmwDKYqk8AExm35Ps8E8Fgkp5baipblbpEd:T:j83ibaocKfakp5eaipblbpEi:T:j83ibaocafhoavclfgval6mbkkdnalae9pmbaiaeciGgvcitgofcbcaao9R;8kbaiabalcitfgwao;8qbbdnavTmbaiaipblbgraipblzgDpmlvorxmPsCXQL358E8Fgqczp:Segkclp:RepklaaipxbbjZbbjZbbjZbbjZpx;Zl81Z;Zl81Z;Zl81Z;Zl81Zakpxibbbibbbibbbibbbp9qp;6ep;NegkaraDpmbediwDqkzHOAKY8AEgrczp:Reczp:Sep;6ep;MegDaDp;Meakarczp:Sep;6ep;Megxaxp;Meakaqczp:Reczp:Sep;6ep;Megqaqp;Mep;Kep;Kep;Lepxbbbbbbbbbbbbbbbbp:4ep;Jepxb;:FSb;:FSb;:FSb;:FSgkp;Mepxbbn0bbn0bbn0bbn0grp;KepxFFbbFFbbFFbbFFbbgmp9oaxakp;Mearp;Keczp:Rep9qgxaqakp;Mearp;Keczp:ReaDakp;Mearp;Keamp9op9qgkpmbezHdiOAlvCXorQLgrp5baipblapEb:T:j83ibaiarp5eaipblapEe:T:j83iwaiaxakpmwDKYqk8AExm35Ps8E8Fgkp5baipblapEd:T:j83izaiakp5eaipblapEi:T:j83iKkawaiao;8qbbkk:Pddiue978Jjjjjbc;ab9Rhidnadcd4ae2glc98GgvTmbcbhdabheinaeaepbbbgocwp:Recwp:Sep;6eaocep:SepxbbjZbbjZbbjZbbjZp:UepxbbjFbbjFbbjFbbjFp9op;Mepkbbaeczfheadclfgdav6mbkkdnaval9pmbaialciGgdcdtgeVcbc;abae9R;8kbaiabavcdtfgvae;8qbbdnadTmbaiaipblbgocwp:Recwp:Sep;6eaocep:SepxbbjZbbjZbbjZbbjZp:UepxbbjFbbjFbbjFbbjFp9op;Mepklbkavaiae;8qbbkk9teiucbcbydj1jjbgeabcifc98GfgbBdj1jjbdndnabZbcztgd9nmbcuhiabad9RcFFifcz4nbcuSmekaehikaikkkebcjwklz9Tbb\";\n\n\tvar detector = new Uint8Array([0,97,115,109,1,0,0,0,1,4,1,96,0,0,3,3,2,0,0,5,3,1,0,1,12,1,0,10,22,2,12,0,65,0,65,0,65,0,252,10,0,0,11,7,0,65,0,253,15,26,11]);\n\tvar wasmpack = new Uint8Array([32,0,65,2,1,106,34,33,3,128,11,4,13,64,6,253,10,7,15,116,127,5,8,12,40,16,19,54,20,9,27,255,113,17,42,67,24,23,146,148,18,14,22,45,70,69,56,114,101,21,25,63,75,136,108,28,118,29,73,115]);\n\n\tif (typeof WebAssembly !== 'object') {\n\t\treturn {\n\t\t\tsupported: false,\n\t\t};\n\t}\n\n\tvar wasm = WebAssembly.validate(detector) ? wasm_simd : wasm_base;\n\n\tvar instance;\n\n\tvar ready =\n\t\tWebAssembly.instantiate(unpack(wasm), {})\n\t\t.then(function(result) {\n\t\t\tinstance = result.instance;\n\t\t\tinstance.exports.__wasm_call_ctors();\n\t\t});\n\n\tfunction unpack(data) {\n\t\tvar result = new Uint8Array(data.length);\n\t\tfor (var i = 0; i < data.length; ++i) {\n\t\t\tvar ch = data.charCodeAt(i);\n\t\t\tresult[i] = ch > 96 ? ch - 97 : ch > 64 ? ch - 39 : ch + 4;\n\t\t}\n\t\tvar write = 0;\n\t\tfor (var i = 0; i < data.length; ++i) {\n\t\t\tresult[write++] = (result[i] < 60) ? wasmpack[result[i]] : (result[i] - 60) * 64 + result[++i];\n\t\t}\n\t\treturn result.buffer.slice(0, write);\n\t}\n\n\tfunction decode(fun, target, count, size, source, filter) {\n\t\tvar sbrk = instance.exports.sbrk;\n\t\tvar count4 = (count + 3) & ~3;\n\t\tvar tp = sbrk(count4 * size);\n\t\tvar sp = sbrk(source.length);\n\t\tvar heap = new Uint8Array(instance.exports.memory.buffer);\n\t\theap.set(source, sp);\n\t\tvar res = fun(tp, count, size, sp, source.length);\n\t\tif (res == 0 && filter) {\n\t\t\tfilter(tp, count4, size);\n\t\t}\n\t\ttarget.set(heap.subarray(tp, tp + count * size));\n\t\tsbrk(tp - sbrk(0));\n\t\tif (res != 0) {\n\t\t\tthrow new Error(\"Malformed buffer data: \" + res);\n\t\t}\n\t}\n\n\tvar filters = {\n\t\tNONE: \"\",\n\t\tOCTAHEDRAL: \"meshopt_decodeFilterOct\",\n\t\tQUATERNION: \"meshopt_decodeFilterQuat\",\n\t\tEXPONENTIAL: \"meshopt_decodeFilterExp\",\n\t};\n\n\tvar decoders = {\n\t\tATTRIBUTES: \"meshopt_decodeVertexBuffer\",\n\t\tTRIANGLES: \"meshopt_decodeIndexBuffer\",\n\t\tINDICES: \"meshopt_decodeIndexSequence\",\n\t};\n\n\tvar workers = [];\n\tvar requestId = 0;\n\n\tfunction createWorker(url) {\n\t\tvar worker = {\n\t\t\tobject: new Worker(url),\n\t\t\tpending: 0,\n\t\t\trequests: {}\n\t\t};\n\n\t\tworker.object.onmessage = function(event) {\n\t\t\tvar data = event.data;\n\n\t\t\tworker.pending -= data.count;\n\t\t\tworker.requests[data.id][data.action](data.value);\n\n\t\t\tdelete worker.requests[data.id];\n\t\t};\n\n\t\treturn worker;\n\t}\n\n\tfunction initWorkers(count) {\n\t\tvar source =\n\t\t\t\"var instance; var ready = WebAssembly.instantiate(new Uint8Array([\" + new Uint8Array(unpack(wasm)) + \"]), {})\" +\n\t\t\t\".then(function(result) { instance = result.instance; instance.exports.__wasm_call_ctors(); });\" +\n\t\t\t\"self.onmessage = workerProcess;\" +\n\t\t\tdecode.toString() + workerProcess.toString();\n\n\t\tvar blob = new Blob([source], {type: 'text/javascript'});\n\t\tvar url = URL.createObjectURL(blob);\n\n\t\tfor (var i = 0; i < count; ++i) {\n\t\t\tworkers[i] = createWorker(url);\n\t\t}\n\n\t\tURL.revokeObjectURL(url);\n\t}\n\n\tfunction decodeWorker(count, size, source, mode, filter) {\n\t\tvar worker = workers[0];\n\n\t\tfor (var i = 1; i < workers.length; ++i) {\n\t\t\tif (workers[i].pending < worker.pending) {\n\t\t\t\tworker = workers[i];\n\t\t\t}\n\t\t}\n\n\t\treturn new Promise(function (resolve, reject) {\n\t\t\tvar data = new Uint8Array(source);\n\t\t\tvar id = requestId++;\n\n\t\t\tworker.pending += count;\n\t\t\tworker.requests[id] = { resolve: resolve, reject: reject };\n\t\t\tworker.object.postMessage({ id: id, count: count, size: size, source: data, mode: mode, filter: filter }, [ data.buffer ]);\n\t\t});\n\t}\n\n\tfunction workerProcess(event) {\n\t\tready.then(function() {\n\t\t\tvar data = event.data;\n\t\t\ttry {\n\t\t\t\tvar target = new Uint8Array(data.count * data.size);\n\t\t\t\tdecode(instance.exports[data.mode], target, data.count, data.size, data.source, instance.exports[data.filter]);\n\t\t\t\tself.postMessage({ id: data.id, count: data.count, action: \"resolve\", value: target }, [ target.buffer ]);\n\t\t\t} catch (error) {\n\t\t\t\tself.postMessage({ id: data.id, count: data.count, action: \"reject\", value: error });\n\t\t\t}\n\t\t});\n\t}\n\n\treturn {\n\t\tready: ready,\n\t\tsupported: true,\n\t\tuseWorkers: function(count) {\n\t\t\tinitWorkers(count);\n\t\t},\n\t\tdecodeVertexBuffer: function(target, count, size, source, filter) {\n\t\t\tdecode(instance.exports.meshopt_decodeVertexBuffer, target, count, size, source, instance.exports[filters[filter]]);\n\t\t},\n\t\tdecodeIndexBuffer: function(target, count, size, source) {\n\t\t\tdecode(instance.exports.meshopt_decodeIndexBuffer, target, count, size, source);\n\t\t},\n\t\tdecodeIndexSequence: function(target, count, size, source) {\n\t\t\tdecode(instance.exports.meshopt_decodeIndexSequence, target, count, size, source);\n\t\t},\n\t\tdecodeGltfBuffer: function(target, count, size, source, mode, filter) {\n\t\t\tdecode(instance.exports[decoders[mode]], target, count, size, source, instance.exports[filters[filter]]);\n\t\t},\n\t\tdecodeGltfBufferAsync: function(count, size, source, mode, filter) {\n\t\t\tif (workers.length > 0) {\n\t\t\t\treturn decodeWorker(count, size, source, decoders[mode], filters[filter]);\n\t\t\t}\n\n\t\t\treturn ready.then(function() {\n\t\t\t\tvar target = new Uint8Array(count * size);\n\t\t\t\tdecode(instance.exports[decoders[mode]], target, count, size, source, instance.exports[filters[filter]]);\n\t\t\t\treturn target;\n\t\t\t});\n\t\t}\n\t};\n})();\n\nexport { MeshoptDecoder };\n", "/*!\nfflate - fast JavaScript compression/decompression\n\nLicensed under MIT. https://github.com/101arrowz/fflate/blob/master/LICENSE\nversion 0.8.2\n*/\n\n// DEFLATE is a complex format; to read this code, you should probably check the RFC first:\n// https://tools.ietf.org/html/rfc1951\n// You may also wish to take a look at the guide I made about this program:\n// https://gist.github.com/101arrowz/253f31eb5abc3d9275ab943003ffecad\n// Some of the following code is similar to that of UZIP.js:\n// https://github.com/photopea/UZIP.js\n// However, the vast majority of the codebase has diverged from UZIP.js to increase performance and reduce bundle size.\n// Sometimes 0 will appear where -1 would be more appropriate. This is because using a uint\n// is better for memory in most engines (I *think*).\nvar ch2 = {};\nvar wk = (function (c, id, msg, transfer, cb) {\n var w = new Worker(ch2[id] || (ch2[id] = URL.createObjectURL(new Blob([\n c + ';addEventListener(\"error\",function(e){e=e.error;postMessage({$e$:[e.message,e.code,e.stack]})})'\n ], { type: 'text/javascript' }))));\n w.onmessage = function (e) {\n var d = e.data, ed = d.$e$;\n if (ed) {\n var err = new Error(ed[0]);\n err['code'] = ed[1];\n err.stack = ed[2];\n cb(err, null);\n }\n else\n cb(null, d);\n };\n w.postMessage(msg, transfer);\n return w;\n});\n\n// aliases for shorter compressed code (most minifers don't do this)\nvar u8 = Uint8Array, u16 = Uint16Array, i32 = Int32Array;\n// fixed length extra bits\nvar fleb = new u8([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, /* unused */ 0, 0, /* impossible */ 0]);\n// fixed distance extra bits\nvar fdeb = new u8([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, /* unused */ 0, 0]);\n// code length index map\nvar clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);\n// get base, reverse index map from extra bits\nvar freb = function (eb, start) {\n var b = new u16(31);\n for (var i = 0; i < 31; ++i) {\n b[i] = start += 1 << eb[i - 1];\n }\n // numbers here are at max 18 bits\n var r = new i32(b[30]);\n for (var i = 1; i < 30; ++i) {\n for (var j = b[i]; j < b[i + 1]; ++j) {\n r[j] = ((j - b[i]) << 5) | i;\n }\n }\n return { b: b, r: r };\n};\nvar _a = freb(fleb, 2), fl = _a.b, revfl = _a.r;\n// we can ignore the fact that the other numbers are wrong; they never happen anyway\nfl[28] = 258, revfl[258] = 28;\nvar _b = freb(fdeb, 0), fd = _b.b, revfd = _b.r;\n// map of value to reverse (assuming 16 bits)\nvar rev = new u16(32768);\nfor (var i = 0; i < 32768; ++i) {\n // reverse table algorithm from SO\n var x = ((i & 0xAAAA) >> 1) | ((i & 0x5555) << 1);\n x = ((x & 0xCCCC) >> 2) | ((x & 0x3333) << 2);\n x = ((x & 0xF0F0) >> 4) | ((x & 0x0F0F) << 4);\n rev[i] = (((x & 0xFF00) >> 8) | ((x & 0x00FF) << 8)) >> 1;\n}\n// create huffman tree from u8 \"map\": index -> code length for code index\n// mb (max bits) must be at most 15\n// TODO: optimize/split up?\nvar hMap = (function (cd, mb, r) {\n var s = cd.length;\n // index\n var i = 0;\n // u16 \"map\": index -> # of codes with bit length = index\n var l = new u16(mb);\n // length of cd must be 288 (total # of codes)\n for (; i < s; ++i) {\n if (cd[i])\n ++l[cd[i] - 1];\n }\n // u16 \"map\": index -> minimum code for bit length = index\n var le = new u16(mb);\n for (i = 1; i < mb; ++i) {\n le[i] = (le[i - 1] + l[i - 1]) << 1;\n }\n var co;\n if (r) {\n // u16 \"map\": index -> number of actual bits, symbol for code\n co = new u16(1 << mb);\n // bits to remove for reverser\n var rvb = 15 - mb;\n for (i = 0; i < s; ++i) {\n // ignore 0 lengths\n if (cd[i]) {\n // num encoding both symbol and bits read\n var sv = (i << 4) | cd[i];\n // free bits\n var r_1 = mb - cd[i];\n // start value\n var v = le[cd[i] - 1]++ << r_1;\n // m is end value\n for (var m = v | ((1 << r_1) - 1); v <= m; ++v) {\n // every 16 bit value starting with the code yields the same result\n co[rev[v] >> rvb] = sv;\n }\n }\n }\n }\n else {\n co = new u16(s);\n for (i = 0; i < s; ++i) {\n if (cd[i]) {\n co[i] = rev[le[cd[i] - 1]++] >> (15 - cd[i]);\n }\n }\n }\n return co;\n});\n// fixed length tree\nvar flt = new u8(288);\nfor (var i = 0; i < 144; ++i)\n flt[i] = 8;\nfor (var i = 144; i < 256; ++i)\n flt[i] = 9;\nfor (var i = 256; i < 280; ++i)\n flt[i] = 7;\nfor (var i = 280; i < 288; ++i)\n flt[i] = 8;\n// fixed distance tree\nvar fdt = new u8(32);\nfor (var i = 0; i < 32; ++i)\n fdt[i] = 5;\n// fixed length map\nvar flm = /*#__PURE__*/ hMap(flt, 9, 0), flrm = /*#__PURE__*/ hMap(flt, 9, 1);\n// fixed distance map\nvar fdm = /*#__PURE__*/ hMap(fdt, 5, 0), fdrm = /*#__PURE__*/ hMap(fdt, 5, 1);\n// find max of array\nvar max = function (a) {\n var m = a[0];\n for (var i = 1; i < a.length; ++i) {\n if (a[i] > m)\n m = a[i];\n }\n return m;\n};\n// read d, starting at bit p and mask with m\nvar bits = function (d, p, m) {\n var o = (p / 8) | 0;\n return ((d[o] | (d[o + 1] << 8)) >> (p & 7)) & m;\n};\n// read d, starting at bit p continuing for at least 16 bits\nvar bits16 = function (d, p) {\n var o = (p / 8) | 0;\n return ((d[o] | (d[o + 1] << 8) | (d[o + 2] << 16)) >> (p & 7));\n};\n// get end of byte\nvar shft = function (p) { return ((p + 7) / 8) | 0; };\n// typed array slice - allows garbage collector to free original reference,\n// while being more compatible than .slice\nvar slc = function (v, s, e) {\n if (s == null || s < 0)\n s = 0;\n if (e == null || e > v.length)\n e = v.length;\n // can't use .constructor in case user-supplied\n return new u8(v.subarray(s, e));\n};\n/**\n * Codes for errors generated within this library\n */\nexport var FlateErrorCode = {\n UnexpectedEOF: 0,\n InvalidBlockType: 1,\n InvalidLengthLiteral: 2,\n InvalidDistance: 3,\n StreamFinished: 4,\n NoStreamHandler: 5,\n InvalidHeader: 6,\n NoCallback: 7,\n InvalidUTF8: 8,\n ExtraFieldTooLong: 9,\n InvalidDate: 10,\n FilenameTooLong: 11,\n StreamFinishing: 12,\n InvalidZipData: 13,\n UnknownCompressionMethod: 14\n};\n// error codes\nvar ec = [\n 'unexpected EOF',\n 'invalid block type',\n 'invalid length/literal',\n 'invalid distance',\n 'stream finished',\n 'no stream handler',\n ,\n 'no callback',\n 'invalid UTF-8 data',\n 'extra field too long',\n 'date not in range 1980-2099',\n 'filename too long',\n 'stream finishing',\n 'invalid zip data'\n // determined by unknown compression method\n];\n;\nvar err = function (ind, msg, nt) {\n var e = new Error(msg || ec[ind]);\n e.code = ind;\n if (Error.captureStackTrace)\n Error.captureStackTrace(e, err);\n if (!nt)\n throw e;\n return e;\n};\n// expands raw DEFLATE data\nvar inflt = function (dat, st, buf, dict) {\n // source length dict length\n var sl = dat.length, dl = dict ? dict.length : 0;\n if (!sl || st.f && !st.l)\n return buf || new u8(0);\n var noBuf = !buf;\n // have to estimate size\n var resize = noBuf || st.i != 2;\n // no state\n var noSt = st.i;\n // Assumes roughly 33% compression ratio average\n if (noBuf)\n buf = new u8(sl * 3);\n // ensure buffer can fit at least l elements\n var cbuf = function (l) {\n var bl = buf.length;\n // need to increase size to fit\n if (l > bl) {\n // Double or set to necessary, whichever is greater\n var nbuf = new u8(Math.max(bl * 2, l));\n nbuf.set(buf);\n buf = nbuf;\n }\n };\n // last chunk bitpos bytes\n var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;\n // total bits\n var tbts = sl * 8;\n do {\n if (!lm) {\n // BFINAL - this is only 1 when last chunk is next\n final = bits(dat, pos, 1);\n // type: 0 = no compression, 1 = fixed huffman, 2 = dynamic huffman\n var type = bits(dat, pos + 1, 3);\n pos += 3;\n if (!type) {\n // go to end of byte boundary\n var s = shft(pos) + 4, l = dat[s - 4] | (dat[s - 3] << 8), t = s + l;\n if (t > sl) {\n if (noSt)\n err(0);\n break;\n }\n // ensure size\n if (resize)\n cbuf(bt + l);\n // Copy over uncompressed data\n buf.set(dat.subarray(s, t), bt);\n // Get new bitpos, update byte count\n st.b = bt += l, st.p = pos = t * 8, st.f = final;\n continue;\n }\n else if (type == 1)\n lm = flrm, dm = fdrm, lbt = 9, dbt = 5;\n else if (type == 2) {\n // literal lengths\n var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;\n var tl = hLit + bits(dat, pos + 5, 31) + 1;\n pos += 14;\n // length+distance tree\n var ldt = new u8(tl);\n // code length tree\n var clt = new u8(19);\n for (var i = 0; i < hcLen; ++i) {\n // use index map to get real code\n clt[clim[i]] = bits(dat, pos + i * 3, 7);\n }\n pos += hcLen * 3;\n // code lengths bits\n var clb = max(clt), clbmsk = (1 << clb) - 1;\n // code lengths map\n var clm = hMap(clt, clb, 1);\n for (var i = 0; i < tl;) {\n var r = clm[bits(dat, pos, clbmsk)];\n // bits read\n pos += r & 15;\n // symbol\n var s = r >> 4;\n // code length to copy\n if (s < 16) {\n ldt[i++] = s;\n }\n else {\n // copy count\n var c = 0, n = 0;\n if (s == 16)\n n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];\n else if (s == 17)\n n = 3 + bits(dat, pos, 7), pos += 3;\n else if (s == 18)\n n = 11 + bits(dat, pos, 127), pos += 7;\n while (n--)\n ldt[i++] = c;\n }\n }\n // length tree distance tree\n var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);\n // max length bits\n lbt = max(lt);\n // max dist bits\n dbt = max(dt);\n lm = hMap(lt, lbt, 1);\n dm = hMap(dt, dbt, 1);\n }\n else\n err(1);\n if (pos > tbts) {\n if (noSt)\n err(0);\n break;\n }\n }\n // Make sure the buffer can hold this + the largest possible addition\n // Maximum chunk size (practically, theoretically infinite) is 2^17\n if (resize)\n cbuf(bt + 131072);\n var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;\n var lpos = pos;\n for (;; lpos = pos) {\n // bits read, code\n var c = lm[bits16(dat, pos) & lms], sym = c >> 4;\n pos += c & 15;\n if (pos > tbts) {\n if (noSt)\n err(0);\n break;\n }\n if (!c)\n err(2);\n if (sym < 256)\n buf[bt++] = sym;\n else if (sym == 256) {\n lpos = pos, lm = null;\n break;\n }\n else {\n var add = sym - 254;\n // no extra bits needed if less\n if (sym > 264) {\n // index\n var i = sym - 257, b = fleb[i];\n add = bits(dat, pos, (1 << b) - 1) + fl[i];\n pos += b;\n }\n // dist\n var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;\n if (!d)\n err(3);\n pos += d & 15;\n var dt = fd[dsym];\n if (dsym > 3) {\n var b = fdeb[dsym];\n dt += bits16(dat, pos) & (1 << b) - 1, pos += b;\n }\n if (pos > tbts) {\n if (noSt)\n err(0);\n break;\n }\n if (resize)\n cbuf(bt + 131072);\n var end = bt + add;\n if (bt < dt) {\n var shift = dl - dt, dend = Math.min(dt, end);\n if (shift + bt < 0)\n err(3);\n for (; bt < dend; ++bt)\n buf[bt] = dict[shift + bt];\n }\n for (; bt < end; ++bt)\n buf[bt] = buf[bt - dt];\n }\n }\n st.l = lm, st.p = lpos, st.b = bt, st.f = final;\n if (lm)\n final = 1, st.m = lbt, st.d = dm, st.n = dbt;\n } while (!final);\n // don't reallocate for streams or user buffers\n return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);\n};\n// starting at p, write the minimum number of bits that can hold v to d\nvar wbits = function (d, p, v) {\n v <<= p & 7;\n var o = (p / 8) | 0;\n d[o] |= v;\n d[o + 1] |= v >> 8;\n};\n// starting at p, write the minimum number of bits (>8) that can hold v to d\nvar wbits16 = function (d, p, v) {\n v <<= p & 7;\n var o = (p / 8) | 0;\n d[o] |= v;\n d[o + 1] |= v >> 8;\n d[o + 2] |= v >> 16;\n};\n// creates code lengths from a frequency table\nvar hTree = function (d, mb) {\n // Need extra info to make a tree\n var t = [];\n for (var i = 0; i < d.length; ++i) {\n if (d[i])\n t.push({ s: i, f: d[i] });\n }\n var s = t.length;\n var t2 = t.slice();\n if (!s)\n return { t: et, l: 0 };\n if (s == 1) {\n var v = new u8(t[0].s + 1);\n v[t[0].s] = 1;\n return { t: v, l: 1 };\n }\n t.sort(function (a, b) { return a.f - b.f; });\n // after i2 reaches last ind, will be stopped\n // freq must be greater than largest possible number of symbols\n t.push({ s: -1, f: 25001 });\n var l = t[0], r = t[1], i0 = 0, i1 = 1, i2 = 2;\n t[0] = { s: -1, f: l.f + r.f, l: l, r: r };\n // efficient algorithm from UZIP.js\n // i0 is lookbehind, i2 is lookahead - after processing two low-freq\n // symbols that combined have high freq, will start processing i2 (high-freq,\n // non-composite) symbols instead\n // see https://reddit.com/r/photopea/comments/ikekht/uzipjs_questions/\n while (i1 != s - 1) {\n l = t[t[i0].f < t[i2].f ? i0++ : i2++];\n r = t[i0 != i1 && t[i0].f < t[i2].f ? i0++ : i2++];\n t[i1++] = { s: -1, f: l.f + r.f, l: l, r: r };\n }\n var maxSym = t2[0].s;\n for (var i = 1; i < s; ++i) {\n if (t2[i].s > maxSym)\n maxSym = t2[i].s;\n }\n // code lengths\n var tr = new u16(maxSym + 1);\n // max bits in tree\n var mbt = ln(t[i1 - 1], tr, 0);\n if (mbt > mb) {\n // more algorithms from UZIP.js\n // TODO: find out how this code works (debt)\n // ind debt\n var i = 0, dt = 0;\n // left cost\n var lft = mbt - mb, cst = 1 << lft;\n t2.sort(function (a, b) { return tr[b.s] - tr[a.s] || a.f - b.f; });\n for (; i < s; ++i) {\n var i2_1 = t2[i].s;\n if (tr[i2_1] > mb) {\n dt += cst - (1 << (mbt - tr[i2_1]));\n tr[i2_1] = mb;\n }\n else\n break;\n }\n dt >>= lft;\n while (dt > 0) {\n var i2_2 = t2[i].s;\n if (tr[i2_2] < mb)\n dt -= 1 << (mb - tr[i2_2]++ - 1);\n else\n ++i;\n }\n for (; i >= 0 && dt; --i) {\n var i2_3 = t2[i].s;\n if (tr[i2_3] == mb) {\n --tr[i2_3];\n ++dt;\n }\n }\n mbt = mb;\n }\n return { t: new u8(tr), l: mbt };\n};\n// get the max length and assign length codes\nvar ln = function (n, l, d) {\n return n.s == -1\n ? Math.max(ln(n.l, l, d + 1), ln(n.r, l, d + 1))\n : (l[n.s] = d);\n};\n// length codes generation\nvar lc = function (c) {\n var s = c.length;\n // Note that the semicolon was intentional\n while (s && !c[--s])\n ;\n var cl = new u16(++s);\n // ind num streak\n var cli = 0, cln = c[0], cls = 1;\n var w = function (v) { cl[cli++] = v; };\n for (var i = 1; i <= s; ++i) {\n if (c[i] == cln && i != s)\n ++cls;\n else {\n if (!cln && cls > 2) {\n for (; cls > 138; cls -= 138)\n w(32754);\n if (cls > 2) {\n w(cls > 10 ? ((cls - 11) << 5) | 28690 : ((cls - 3) << 5) | 12305);\n cls = 0;\n }\n }\n else if (cls > 3) {\n w(cln), --cls;\n for (; cls > 6; cls -= 6)\n w(8304);\n if (cls > 2)\n w(((cls - 3) << 5) | 8208), cls = 0;\n }\n while (cls--)\n w(cln);\n cls = 1;\n cln = c[i];\n }\n }\n return { c: cl.subarray(0, cli), n: s };\n};\n// calculate the length of output from tree, code lengths\nvar clen = function (cf, cl) {\n var l = 0;\n for (var i = 0; i < cl.length; ++i)\n l += cf[i] * cl[i];\n return l;\n};\n// writes a fixed block\n// returns the new bit pos\nvar wfblk = function (out, pos, dat) {\n // no need to write 00 as type: TypedArray defaults to 0\n var s = dat.length;\n var o = shft(pos + 2);\n out[o] = s & 255;\n out[o + 1] = s >> 8;\n out[o + 2] = out[o] ^ 255;\n out[o + 3] = out[o + 1] ^ 255;\n for (var i = 0; i < s; ++i)\n out[o + i + 4] = dat[i];\n return (o + 4 + s) * 8;\n};\n// writes a block\nvar wblk = function (dat, out, final, syms, lf, df, eb, li, bs, bl, p) {\n wbits(out, p++, final);\n ++lf[256];\n var _a = hTree(lf, 15), dlt = _a.t, mlb = _a.l;\n var _b = hTree(df, 15), ddt = _b.t, mdb = _b.l;\n var _c = lc(dlt), lclt = _c.c, nlc = _c.n;\n var _d = lc(ddt), lcdt = _d.c, ndc = _d.n;\n var lcfreq = new u16(19);\n for (var i = 0; i < lclt.length; ++i)\n ++lcfreq[lclt[i] & 31];\n for (var i = 0; i < lcdt.length; ++i)\n ++lcfreq[lcdt[i] & 31];\n var _e = hTree(lcfreq, 7), lct = _e.t, mlcb = _e.l;\n var nlcc = 19;\n for (; nlcc > 4 && !lct[clim[nlcc - 1]]; --nlcc)\n ;\n var flen = (bl + 5) << 3;\n var ftlen = clen(lf, flt) + clen(df, fdt) + eb;\n var dtlen = clen(lf, dlt) + clen(df, ddt) + eb + 14 + 3 * nlcc + clen(lcfreq, lct) + 2 * lcfreq[16] + 3 * lcfreq[17] + 7 * lcfreq[18];\n if (bs >= 0 && flen <= ftlen && flen <= dtlen)\n return wfblk(out, p, dat.subarray(bs, bs + bl));\n var lm, ll, dm, dl;\n wbits(out, p, 1 + (dtlen < ftlen)), p += 2;\n if (dtlen < ftlen) {\n lm = hMap(dlt, mlb, 0), ll = dlt, dm = hMap(ddt, mdb, 0), dl = ddt;\n var llm = hMap(lct, mlcb, 0);\n wbits(out, p, nlc - 257);\n wbits(out, p + 5, ndc - 1);\n wbits(out, p + 10, nlcc - 4);\n p += 14;\n for (var i = 0; i < nlcc; ++i)\n wbits(out, p + 3 * i, lct[clim[i]]);\n p += 3 * nlcc;\n var lcts = [lclt, lcdt];\n for (var it = 0; it < 2; ++it) {\n var clct = lcts[it];\n for (var i = 0; i < clct.length; ++i) {\n var len = clct[i] & 31;\n wbits(out, p, llm[len]), p += lct[len];\n if (len > 15)\n wbits(out, p, (clct[i] >> 5) & 127), p += clct[i] >> 12;\n }\n }\n }\n else {\n lm = flm, ll = flt, dm = fdm, dl = fdt;\n }\n for (var i = 0; i < li; ++i) {\n var sym = syms[i];\n if (sym > 255) {\n var len = (sym >> 18) & 31;\n wbits16(out, p, lm[len + 257]), p += ll[len + 257];\n if (len > 7)\n wbits(out, p, (sym >> 23) & 31), p += fleb[len];\n var dst = sym & 31;\n wbits16(out, p, dm[dst]), p += dl[dst];\n if (dst > 3)\n wbits16(out, p, (sym >> 5) & 8191), p += fdeb[dst];\n }\n else {\n wbits16(out, p, lm[sym]), p += ll[sym];\n }\n }\n wbits16(out, p, lm[256]);\n return p + ll[256];\n};\n// deflate options (nice << 13) | chain\nvar deo = /*#__PURE__*/ new i32([65540, 131080, 131088, 131104, 262176, 1048704, 1048832, 2114560, 2117632]);\n// empty\nvar et = /*#__PURE__*/ new u8(0);\n// compresses data into a raw DEFLATE buffer\nvar dflt = function (dat, lvl, plvl, pre, post, st) {\n var s = st.z || dat.length;\n var o = new u8(pre + s + 5 * (1 + Math.ceil(s / 7000)) + post);\n // writing to this writes to the output buffer\n var w = o.subarray(pre, o.length - post);\n var lst = st.l;\n var pos = (st.r || 0) & 7;\n if (lvl) {\n if (pos)\n w[0] = st.r >> 3;\n var opt = deo[lvl - 1];\n var n = opt >> 13, c = opt & 8191;\n var msk_1 = (1 << plvl) - 1;\n // prev 2-byte val map curr 2-byte val map\n var prev = st.p || new u16(32768), head = st.h || new u16(msk_1 + 1);\n var bs1_1 = Math.ceil(plvl / 3), bs2_1 = 2 * bs1_1;\n var hsh = function (i) { return (dat[i] ^ (dat[i + 1] << bs1_1) ^ (dat[i + 2] << bs2_1)) & msk_1; };\n // 24576 is an arbitrary number of maximum symbols per block\n // 424 buffer for last block\n var syms = new i32(25000);\n // length/literal freq distance freq\n var lf = new u16(288), df = new u16(32);\n // l/lcnt exbits index l/lind waitdx blkpos\n var lc_1 = 0, eb = 0, i = st.i || 0, li = 0, wi = st.w || 0, bs = 0;\n for (; i + 2 < s; ++i) {\n // hash value\n var hv = hsh(i);\n // index mod 32768 previous index mod\n var imod = i & 32767, pimod = head[hv];\n prev[imod] = pimod;\n head[hv] = imod;\n // We always should modify head and prev, but only add symbols if\n // this data is not yet processed (\"wait\" for wait index)\n if (wi <= i) {\n // bytes remaining\n var rem = s - i;\n if ((lc_1 > 7000 || li > 24576) && (rem > 423 || !lst)) {\n pos = wblk(dat, w, 0, syms, lf, df, eb, li, bs, i - bs, pos);\n li = lc_1 = eb = 0, bs = i;\n for (var j = 0; j < 286; ++j)\n lf[j] = 0;\n for (var j = 0; j < 30; ++j)\n df[j] = 0;\n }\n // len dist chain\n var l = 2, d = 0, ch_1 = c, dif = imod - pimod & 32767;\n if (rem > 2 && hv == hsh(i - dif)) {\n var maxn = Math.min(n, rem) - 1;\n var maxd = Math.min(32767, i);\n // max possible length\n // not capped at dif because decompressors implement \"rolling\" index population\n var ml = Math.min(258, rem);\n while (dif <= maxd && --ch_1 && imod != pimod) {\n if (dat[i + l] == dat[i + l - dif]) {\n var nl = 0;\n for (; nl < ml && dat[i + nl] == dat[i + nl - dif]; ++nl)\n ;\n if (nl > l) {\n l = nl, d = dif;\n // break out early when we reach \"nice\" (we are satisfied enough)\n if (nl > maxn)\n break;\n // now, find the rarest 2-byte sequence within this\n // length of literals and search for that instead.\n // Much faster than just using the start\n var mmd = Math.min(dif, nl - 2);\n var md = 0;\n for (var j = 0; j < mmd; ++j) {\n var ti = i - dif + j & 32767;\n var pti = prev[ti];\n var cd = ti - pti & 32767;\n if (cd > md)\n md = cd, pimod = ti;\n }\n }\n }\n // check the previous match\n imod = pimod, pimod = prev[imod];\n dif += imod - pimod & 32767;\n }\n }\n // d will be nonzero only when a match was found\n if (d) {\n // store both dist and len data in one int32\n // Make sure this is recognized as a len/dist with 28th bit (2^28)\n syms[li++] = 268435456 | (revfl[l] << 18) | revfd[d];\n var lin = revfl[l] & 31, din = revfd[d] & 31;\n eb += fleb[lin] + fdeb[din];\n ++lf[257 + lin];\n ++df[din];\n wi = i + l;\n ++lc_1;\n }\n else {\n syms[li++] = dat[i];\n ++lf[dat[i]];\n }\n }\n }\n for (i = Math.max(i, wi); i < s; ++i) {\n syms[li++] = dat[i];\n ++lf[dat[i]];\n }\n pos = wblk(dat, w, lst, syms, lf, df, eb, li, bs, i - bs, pos);\n if (!lst) {\n st.r = (pos & 7) | w[(pos / 8) | 0] << 3;\n // shft(pos) now 1 less if pos & 7 != 0\n pos -= 7;\n st.h = head, st.p = prev, st.i = i, st.w = wi;\n }\n }\n else {\n for (var i = st.w || 0; i < s + lst; i += 65535) {\n // end\n var e = i + 65535;\n if (e >= s) {\n // write final block\n w[(pos / 8) | 0] = lst;\n e = s;\n }\n pos = wfblk(w, pos + 1, dat.subarray(i, e));\n }\n st.i = s;\n }\n return slc(o, 0, pre + shft(pos) + post);\n};\n// CRC32 table\nvar crct = /*#__PURE__*/ (function () {\n var t = new Int32Array(256);\n for (var i = 0; i < 256; ++i) {\n var c = i, k = 9;\n while (--k)\n c = ((c & 1) && -306674912) ^ (c >>> 1);\n t[i] = c;\n }\n return t;\n})();\n// CRC32\nvar crc = function () {\n var c = -1;\n return {\n p: function (d) {\n // closures have awful performance\n var cr = c;\n for (var i = 0; i < d.length; ++i)\n cr = crct[(cr & 255) ^ d[i]] ^ (cr >>> 8);\n c = cr;\n },\n d: function () { return ~c; }\n };\n};\n// Adler32\nvar adler = function () {\n var a = 1, b = 0;\n return {\n p: function (d) {\n // closures have awful performance\n var n = a, m = b;\n var l = d.length | 0;\n for (var i = 0; i != l;) {\n var e = Math.min(i + 2655, l);\n for (; i < e; ++i)\n m += n += d[i];\n n = (n & 65535) + 15 * (n >> 16), m = (m & 65535) + 15 * (m >> 16);\n }\n a = n, b = m;\n },\n d: function () {\n a %= 65521, b %= 65521;\n return (a & 255) << 24 | (a & 0xFF00) << 8 | (b & 255) << 8 | (b >> 8);\n }\n };\n};\n;\n// deflate with opts\nvar dopt = function (dat, opt, pre, post, st) {\n if (!st) {\n st = { l: 1 };\n if (opt.dictionary) {\n var dict = opt.dictionary.subarray(-32768);\n var newDat = new u8(dict.length + dat.length);\n newDat.set(dict);\n newDat.set(dat, dict.length);\n dat = newDat;\n st.w = dict.length;\n }\n }\n return dflt(dat, opt.level == null ? 6 : opt.level, opt.mem == null ? (st.l ? Math.ceil(Math.max(8, Math.min(13, Math.log(dat.length))) * 1.5) : 20) : (12 + opt.mem), pre, post, st);\n};\n// Walmart object spread\nvar mrg = function (a, b) {\n var o = {};\n for (var k in a)\n o[k] = a[k];\n for (var k in b)\n o[k] = b[k];\n return o;\n};\n// worker clone\n// This is possibly the craziest part of the entire codebase, despite how simple it may seem.\n// The only parameter to this function is a closure that returns an array of variables outside of the function scope.\n// We're going to try to figure out the variable names used in the closure as strings because that is crucial for workerization.\n// We will return an object mapping of true variable name to value (basically, the current scope as a JS object).\n// The reason we can't just use the original variable names is minifiers mangling the toplevel scope.\n// This took me three weeks to figure out how to do.\nvar wcln = function (fn, fnStr, td) {\n var dt = fn();\n var st = fn.toString();\n var ks = st.slice(st.indexOf('[') + 1, st.lastIndexOf(']')).replace(/\\s+/g, '').split(',');\n for (var i = 0; i < dt.length; ++i) {\n var v = dt[i], k = ks[i];\n if (typeof v == 'function') {\n fnStr += ';' + k + '=';\n var st_1 = v.toString();\n if (v.prototype) {\n // for global objects\n if (st_1.indexOf('[native code]') != -1) {\n var spInd = st_1.indexOf(' ', 8) + 1;\n fnStr += st_1.slice(spInd, st_1.indexOf('(', spInd));\n }\n else {\n fnStr += st_1;\n for (var t in v.prototype)\n fnStr += ';' + k + '.prototype.' + t + '=' + v.prototype[t].toString();\n }\n }\n else\n fnStr += st_1;\n }\n else\n td[k] = v;\n }\n return fnStr;\n};\nvar ch = [];\n// clone bufs\nvar cbfs = function (v) {\n var tl = [];\n for (var k in v) {\n if (v[k].buffer) {\n tl.push((v[k] = new v[k].constructor(v[k])).buffer);\n }\n }\n return tl;\n};\n// use a worker to execute code\nvar wrkr = function (fns, init, id, cb) {\n if (!ch[id]) {\n var fnStr = '', td_1 = {}, m = fns.length - 1;\n for (var i = 0; i < m; ++i)\n fnStr = wcln(fns[i], fnStr, td_1);\n ch[id] = { c: wcln(fns[m], fnStr, td_1), e: td_1 };\n }\n var td = mrg({}, ch[id].e);\n return wk(ch[id].c + ';onmessage=function(e){for(var k in e.data)self[k]=e.data[k];onmessage=' + init.toString() + '}', id, td, cbfs(td), cb);\n};\n// base async inflate fn\nvar bInflt = function () { return [u8, u16, i32, fleb, fdeb, clim, fl, fd, flrm, fdrm, rev, ec, hMap, max, bits, bits16, shft, slc, err, inflt, inflateSync, pbf, gopt]; };\nvar bDflt = function () { return [u8, u16, i32, fleb, fdeb, clim, revfl, revfd, flm, flt, fdm, fdt, rev, deo, et, hMap, wbits, wbits16, hTree, ln, lc, clen, wfblk, wblk, shft, slc, dflt, dopt, deflateSync, pbf]; };\n// gzip extra\nvar gze = function () { return [gzh, gzhl, wbytes, crc, crct]; };\n// gunzip extra\nvar guze = function () { return [gzs, gzl]; };\n// zlib extra\nvar zle = function () { return [zlh, wbytes, adler]; };\n// unzlib extra\nvar zule = function () { return [zls]; };\n// post buf\nvar pbf = function (msg) { return postMessage(msg, [msg.buffer]); };\n// get opts\nvar gopt = function (o) { return o && {\n out: o.size && new u8(o.size),\n dictionary: o.dictionary\n}; };\n// async helper\nvar cbify = function (dat, opts, fns, init, id, cb) {\n var w = wrkr(fns, init, id, function (err, dat) {\n w.terminate();\n cb(err, dat);\n });\n w.postMessage([dat, opts], opts.consume ? [dat.buffer] : []);\n return function () { w.terminate(); };\n};\n// auto stream\nvar astrm = function (strm) {\n strm.ondata = function (dat, final) { return postMessage([dat, final], [dat.buffer]); };\n return function (ev) {\n if (ev.data.length) {\n strm.push(ev.data[0], ev.data[1]);\n postMessage([ev.data[0].length]);\n }\n else\n strm.flush();\n };\n};\n// async stream attach\nvar astrmify = function (fns, strm, opts, init, id, flush, ext) {\n var t;\n var w = wrkr(fns, init, id, function (err, dat) {\n if (err)\n w.terminate(), strm.ondata.call(strm, err);\n else if (!Array.isArray(dat))\n ext(dat);\n else if (dat.length == 1) {\n strm.queuedSize -= dat[0];\n if (strm.ondrain)\n strm.ondrain(dat[0]);\n }\n else {\n if (dat[1])\n w.terminate();\n strm.ondata.call(strm, err, dat[0], dat[1]);\n }\n });\n w.postMessage(opts);\n strm.queuedSize = 0;\n strm.push = function (d, f) {\n if (!strm.ondata)\n err(5);\n if (t)\n strm.ondata(err(4, 0, 1), null, !!f);\n strm.queuedSize += d.length;\n w.postMessage([d, t = f], [d.buffer]);\n };\n strm.terminate = function () { w.terminate(); };\n if (flush) {\n strm.flush = function () { w.postMessage([]); };\n }\n};\n// read 2 bytes\nvar b2 = function (d, b) { return d[b] | (d[b + 1] << 8); };\n// read 4 bytes\nvar b4 = function (d, b) { return (d[b] | (d[b + 1] << 8) | (d[b + 2] << 16) | (d[b + 3] << 24)) >>> 0; };\nvar b8 = function (d, b) { return b4(d, b) + (b4(d, b + 4) * 4294967296); };\n// write bytes\nvar wbytes = function (d, b, v) {\n for (; v; ++b)\n d[b] = v, v >>>= 8;\n};\n// gzip header\nvar gzh = function (c, o) {\n var fn = o.filename;\n c[0] = 31, c[1] = 139, c[2] = 8, c[8] = o.level < 2 ? 4 : o.level == 9 ? 2 : 0, c[9] = 3; // assume Unix\n if (o.mtime != 0)\n wbytes(c, 4, Math.floor(new Date(o.mtime || Date.now()) / 1000));\n if (fn) {\n c[3] = 8;\n for (var i = 0; i <= fn.length; ++i)\n c[i + 10] = fn.charCodeAt(i);\n }\n};\n// gzip footer: -8 to -4 = CRC, -4 to -0 is length\n// gzip start\nvar gzs = function (d) {\n if (d[0] != 31 || d[1] != 139 || d[2] != 8)\n err(6, 'invalid gzip data');\n var flg = d[3];\n var st = 10;\n if (flg & 4)\n st += (d[10] | d[11] << 8) + 2;\n for (var zs = (flg >> 3 & 1) + (flg >> 4 & 1); zs > 0; zs -= !d[st++])\n ;\n return st + (flg & 2);\n};\n// gzip length\nvar gzl = function (d) {\n var l = d.length;\n return (d[l - 4] | d[l - 3] << 8 | d[l - 2] << 16 | d[l - 1] << 24) >>> 0;\n};\n// gzip header length\nvar gzhl = function (o) { return 10 + (o.filename ? o.filename.length + 1 : 0); };\n// zlib header\nvar zlh = function (c, o) {\n var lv = o.level, fl = lv == 0 ? 0 : lv < 6 ? 1 : lv == 9 ? 3 : 2;\n c[0] = 120, c[1] = (fl << 6) | (o.dictionary && 32);\n c[1] |= 31 - ((c[0] << 8) | c[1]) % 31;\n if (o.dictionary) {\n var h = adler();\n h.p(o.dictionary);\n wbytes(c, 2, h.d());\n }\n};\n// zlib start\nvar zls = function (d, dict) {\n if ((d[0] & 15) != 8 || (d[0] >> 4) > 7 || ((d[0] << 8 | d[1]) % 31))\n err(6, 'invalid zlib data');\n if ((d[1] >> 5 & 1) == +!dict)\n err(6, 'invalid zlib data: ' + (d[1] & 32 ? 'need' : 'unexpected') + ' dictionary');\n return (d[1] >> 3 & 4) + 2;\n};\nfunction StrmOpt(opts, cb) {\n if (typeof opts == 'function')\n cb = opts, opts = {};\n this.ondata = cb;\n return opts;\n}\n/**\n * Streaming DEFLATE compression\n */\nvar Deflate = /*#__PURE__*/ (function () {\n function Deflate(opts, cb) {\n if (typeof opts == 'function')\n cb = opts, opts = {};\n this.ondata = cb;\n this.o = opts || {};\n this.s = { l: 0, i: 32768, w: 32768, z: 32768 };\n // Buffer length must always be 0 mod 32768 for index calculations to be correct when modifying head and prev\n // 98304 = 32768 (lookback) + 65536 (common chunk size)\n this.b = new u8(98304);\n if (this.o.dictionary) {\n var dict = this.o.dictionary.subarray(-32768);\n this.b.set(dict, 32768 - dict.length);\n this.s.i = 32768 - dict.length;\n }\n }\n Deflate.prototype.p = function (c, f) {\n this.ondata(dopt(c, this.o, 0, 0, this.s), f);\n };\n /**\n * Pushes a chunk to be deflated\n * @param chunk The chunk to push\n * @param final Whether this is the last chunk\n */\n Deflate.prototype.push = function (chunk, final) {\n if (!this.ondata)\n err(5);\n if (this.s.l)\n err(4);\n var endLen = chunk.length + this.s.z;\n if (endLen > this.b.length) {\n if (endLen > 2 * this.b.length - 32768) {\n var newBuf = new u8(endLen & -32768);\n newBuf.set(this.b.subarray(0, this.s.z));\n this.b = newBuf;\n }\n var split = this.b.length - this.s.z;\n this.b.set(chunk.subarray(0, split), this.s.z);\n this.s.z = this.b.length;\n this.p(this.b, false);\n this.b.set(this.b.subarray(-32768));\n this.b.set(chunk.subarray(split), 32768);\n this.s.z = chunk.length - split + 32768;\n this.s.i = 32766, this.s.w = 32768;\n }\n else {\n this.b.set(chunk, this.s.z);\n this.s.z += chunk.length;\n }\n this.s.l = final & 1;\n if (this.s.z > this.s.w + 8191 || final) {\n this.p(this.b, final || false);\n this.s.w = this.s.i, this.s.i -= 2;\n }\n };\n /**\n * Flushes buffered uncompressed data. Useful to immediately retrieve the\n * deflated output for small inputs.\n */\n Deflate.prototype.flush = function () {\n if (!this.ondata)\n err(5);\n if (this.s.l)\n err(4);\n this.p(this.b, false);\n this.s.w = this.s.i, this.s.i -= 2;\n };\n return Deflate;\n}());\nexport { Deflate };\n/**\n * Asynchronous streaming DEFLATE compression\n */\nvar AsyncDeflate = /*#__PURE__*/ (function () {\n function AsyncDeflate(opts, cb) {\n astrmify([\n bDflt,\n function () { return [astrm, Deflate]; }\n ], this, StrmOpt.call(this, opts, cb), function (ev) {\n var strm = new Deflate(ev.data);\n onmessage = astrm(strm);\n }, 6, 1);\n }\n return AsyncDeflate;\n}());\nexport { AsyncDeflate };\nexport function deflate(data, opts, cb) {\n if (!cb)\n cb = opts, opts = {};\n if (typeof cb != 'function')\n err(7);\n return cbify(data, opts, [\n bDflt,\n ], function (ev) { return pbf(deflateSync(ev.data[0], ev.data[1])); }, 0, cb);\n}\n/**\n * Compresses data with DEFLATE without any wrapper\n * @param data The data to compress\n * @param opts The compression options\n * @returns The deflated version of the data\n */\nexport function deflateSync(data, opts) {\n return dopt(data, opts || {}, 0, 0);\n}\n/**\n * Streaming DEFLATE decompression\n */\nvar Inflate = /*#__PURE__*/ (function () {\n function Inflate(opts, cb) {\n // no StrmOpt here to avoid adding to workerizer\n if (typeof opts == 'function')\n cb = opts, opts = {};\n this.ondata = cb;\n var dict = opts && opts.dictionary && opts.dictionary.subarray(-32768);\n this.s = { i: 0, b: dict ? dict.length : 0 };\n this.o = new u8(32768);\n this.p = new u8(0);\n if (dict)\n this.o.set(dict);\n }\n Inflate.prototype.e = function (c) {\n if (!this.ondata)\n err(5);\n if (this.d)\n err(4);\n if (!this.p.length)\n this.p = c;\n else if (c.length) {\n var n = new u8(this.p.length + c.length);\n n.set(this.p), n.set(c, this.p.length), this.p = n;\n }\n };\n Inflate.prototype.c = function (final) {\n this.s.i = +(this.d = final || false);\n var bts = this.s.b;\n var dt = inflt(this.p, this.s, this.o);\n this.ondata(slc(dt, bts, this.s.b), this.d);\n this.o = slc(dt, this.s.b - 32768), this.s.b = this.o.length;\n this.p = slc(this.p, (this.s.p / 8) | 0), this.s.p &= 7;\n };\n /**\n * Pushes a chunk to be inflated\n * @param chunk The chunk to push\n * @param final Whether this is the final chunk\n */\n Inflate.prototype.push = function (chunk, final) {\n this.e(chunk), this.c(final);\n };\n return Inflate;\n}());\nexport { Inflate };\n/**\n * Asynchronous streaming DEFLATE decompression\n */\nvar AsyncInflate = /*#__PURE__*/ (function () {\n function AsyncInflate(opts, cb) {\n astrmify([\n bInflt,\n function () { return [astrm, Inflate]; }\n ], this, StrmOpt.call(this, opts, cb), function (ev) {\n var strm = new Inflate(ev.data);\n onmessage = astrm(strm);\n }, 7, 0);\n }\n return AsyncInflate;\n}());\nexport { AsyncInflate };\nexport function inflate(data, opts, cb) {\n if (!cb)\n cb = opts, opts = {};\n if (typeof cb != 'function')\n err(7);\n return cbify(data, opts, [\n bInflt\n ], function (ev) { return pbf(inflateSync(ev.data[0], gopt(ev.data[1]))); }, 1, cb);\n}\n/**\n * Expands DEFLATE data with no wrapper\n * @param data The data to decompress\n * @param opts The decompression options\n * @returns The decompressed version of the data\n */\nexport function inflateSync(data, opts) {\n return inflt(data, { i: 2 }, opts && opts.out, opts && opts.dictionary);\n}\n// before you yell at me for not just using extends, my reason is that TS inheritance is hard to workerize.\n/**\n * Streaming GZIP compression\n */\nvar Gzip = /*#__PURE__*/ (function () {\n function Gzip(opts, cb) {\n this.c = crc();\n this.l = 0;\n this.v = 1;\n Deflate.call(this, opts, cb);\n }\n /**\n * Pushes a chunk to be GZIPped\n * @param chunk The chunk to push\n * @param final Whether this is the last chunk\n */\n Gzip.prototype.push = function (chunk, final) {\n this.c.p(chunk);\n this.l += chunk.length;\n Deflate.prototype.push.call(this, chunk, final);\n };\n Gzip.prototype.p = function (c, f) {\n var raw = dopt(c, this.o, this.v && gzhl(this.o), f && 8, this.s);\n if (this.v)\n gzh(raw, this.o), this.v = 0;\n if (f)\n wbytes(raw, raw.length - 8, this.c.d()), wbytes(raw, raw.length - 4, this.l);\n this.ondata(raw, f);\n };\n /**\n * Flushes buffered uncompressed data. Useful to immediately retrieve the\n * GZIPped output for small inputs.\n */\n Gzip.prototype.flush = function () {\n Deflate.prototype.flush.call(this);\n };\n return Gzip;\n}());\nexport { Gzip };\n/**\n * Asynchronous streaming GZIP compression\n */\nvar AsyncGzip = /*#__PURE__*/ (function () {\n function AsyncGzip(opts, cb) {\n astrmify([\n bDflt,\n gze,\n function () { return [astrm, Deflate, Gzip]; }\n ], this, StrmOpt.call(this, opts, cb), function (ev) {\n var strm = new Gzip(ev.data);\n onmessage = astrm(strm);\n }, 8, 1);\n }\n return AsyncGzip;\n}());\nexport { AsyncGzip };\nexport function gzip(data, opts, cb) {\n if (!cb)\n cb = opts, opts = {};\n if (typeof cb != 'function')\n err(7);\n return cbify(data, opts, [\n bDflt,\n gze,\n function () { return [gzipSync]; }\n ], function (ev) { return pbf(gzipSync(ev.data[0], ev.data[1])); }, 2, cb);\n}\n/**\n * Compresses data with GZIP\n * @param data The data to compress\n * @param opts The compression options\n * @returns The gzipped version of the data\n */\nexport function gzipSync(data, opts) {\n if (!opts)\n opts = {};\n var c = crc(), l = data.length;\n c.p(data);\n var d = dopt(data, opts, gzhl(opts), 8), s = d.length;\n return gzh(d, opts), wbytes(d, s - 8, c.d()), wbytes(d, s - 4, l), d;\n}\n/**\n * Streaming single or multi-member GZIP decompression\n */\nvar Gunzip = /*#__PURE__*/ (function () {\n function Gunzip(opts, cb) {\n this.v = 1;\n this.r = 0;\n Inflate.call(this, opts, cb);\n }\n /**\n * Pushes a chunk to be GUNZIPped\n * @param chunk The chunk to push\n * @param final Whether this is the last chunk\n */\n Gunzip.prototype.push = function (chunk, final) {\n Inflate.prototype.e.call(this, chunk);\n this.r += chunk.length;\n if (this.v) {\n var p = this.p.subarray(this.v - 1);\n var s = p.length > 3 ? gzs(p) : 4;\n if (s > p.length) {\n if (!final)\n return;\n }\n else if (this.v > 1 && this.onmember) {\n this.onmember(this.r - p.length);\n }\n this.p = p.subarray(s), this.v = 0;\n }\n // necessary to prevent TS from using the closure value\n // This allows for workerization to function correctly\n Inflate.prototype.c.call(this, final);\n // process concatenated GZIP\n if (this.s.f && !this.s.l && !final) {\n this.v = shft(this.s.p) + 9;\n this.s = { i: 0 };\n this.o = new u8(0);\n this.push(new u8(0), final);\n }\n };\n return Gunzip;\n}());\nexport { Gunzip };\n/**\n * Asynchronous streaming single or multi-member GZIP decompression\n */\nvar AsyncGunzip = /*#__PURE__*/ (function () {\n function AsyncGunzip(opts, cb) {\n var _this = this;\n astrmify([\n bInflt,\n guze,\n function () { return [astrm, Inflate, Gunzip]; }\n ], this, StrmOpt.call(this, opts, cb), function (ev) {\n var strm = new Gunzip(ev.data);\n strm.onmember = function (offset) { return postMessage(offset); };\n onmessage = astrm(strm);\n }, 9, 0, function (offset) { return _this.onmember && _this.onmember(offset); });\n }\n return AsyncGunzip;\n}());\nexport { AsyncGunzip };\nexport function gunzip(data, opts, cb) {\n if (!cb)\n cb = opts, opts = {};\n if (typeof cb != 'function')\n err(7);\n return cbify(data, opts, [\n bInflt,\n guze,\n function () { return [gunzipSync]; }\n ], function (ev) { return pbf(gunzipSync(ev.data[0], ev.data[1])); }, 3, cb);\n}\n/**\n * Expands GZIP data\n * @param data The data to decompress\n * @param opts The decompression options\n * @returns The decompressed version of the data\n */\nexport function gunzipSync(data, opts) {\n var st = gzs(data);\n if (st + 8 > data.length)\n err(6, 'invalid gzip data');\n return inflt(data.subarray(st, -8), { i: 2 }, opts && opts.out || new u8(gzl(data)), opts && opts.dictionary);\n}\n/**\n * Streaming Zlib compression\n */\nvar Zlib = /*#__PURE__*/ (function () {\n function Zlib(opts, cb) {\n this.c = adler();\n this.v = 1;\n Deflate.call(this, opts, cb);\n }\n /**\n * Pushes a chunk to be zlibbed\n * @param chunk The chunk to push\n * @param final Whether this is the last chunk\n */\n Zlib.prototype.push = function (chunk, final) {\n this.c.p(chunk);\n Deflate.prototype.push.call(this, chunk, final);\n };\n Zlib.prototype.p = function (c, f) {\n var raw = dopt(c, this.o, this.v && (this.o.dictionary ? 6 : 2), f && 4, this.s);\n if (this.v)\n zlh(raw, this.o), this.v = 0;\n if (f)\n wbytes(raw, raw.length - 4, this.c.d());\n this.ondata(raw, f);\n };\n /**\n * Flushes buffered uncompressed data. Useful to immediately retrieve the\n * zlibbed output for small inputs.\n */\n Zlib.prototype.flush = function () {\n Deflate.prototype.flush.call(this);\n };\n return Zlib;\n}());\nexport { Zlib };\n/**\n * Asynchronous streaming Zlib compression\n */\nvar AsyncZlib = /*#__PURE__*/ (function () {\n function AsyncZlib(opts, cb) {\n astrmify([\n bDflt,\n zle,\n function () { return [astrm, Deflate, Zlib]; }\n ], this, StrmOpt.call(this, opts, cb), function (ev) {\n var strm = new Zlib(ev.data);\n onmessage = astrm(strm);\n }, 10, 1);\n }\n return AsyncZlib;\n}());\nexport { AsyncZlib };\nexport function zlib(data, opts, cb) {\n if (!cb)\n cb = opts, opts = {};\n if (typeof cb != 'function')\n err(7);\n return cbify(data, opts, [\n bDflt,\n zle,\n function () { return [zlibSync]; }\n ], function (ev) { return pbf(zlibSync(ev.data[0], ev.data[1])); }, 4, cb);\n}\n/**\n * Compress data with Zlib\n * @param data The data to compress\n * @param opts The compression options\n * @returns The zlib-compressed version of the data\n */\nexport function zlibSync(data, opts) {\n if (!opts)\n opts = {};\n var a = adler();\n a.p(data);\n var d = dopt(data, opts, opts.dictionary ? 6 : 2, 4);\n return zlh(d, opts), wbytes(d, d.length - 4, a.d()), d;\n}\n/**\n * Streaming Zlib decompression\n */\nvar Unzlib = /*#__PURE__*/ (function () {\n function Unzlib(opts, cb) {\n Inflate.call(this, opts, cb);\n this.v = opts && opts.dictionary ? 2 : 1;\n }\n /**\n * Pushes a chunk to be unzlibbed\n * @param chunk The chunk to push\n * @param final Whether this is the last chunk\n */\n Unzlib.prototype.push = function (chunk, final) {\n Inflate.prototype.e.call(this, chunk);\n if (this.v) {\n if (this.p.length < 6 && !final)\n return;\n this.p = this.p.subarray(zls(this.p, this.v - 1)), this.v = 0;\n }\n if (final) {\n if (this.p.length < 4)\n err(6, 'invalid zlib data');\n this.p = this.p.subarray(0, -4);\n }\n // necessary to prevent TS from using the closure value\n // This allows for workerization to function correctly\n Inflate.prototype.c.call(this, final);\n };\n return Unzlib;\n}());\nexport { Unzlib };\n/**\n * Asynchronous streaming Zlib decompression\n */\nvar AsyncUnzlib = /*#__PURE__*/ (function () {\n function AsyncUnzlib(opts, cb) {\n astrmify([\n bInflt,\n zule,\n function () { return [astrm, Inflate, Unzlib]; }\n ], this, StrmOpt.call(this, opts, cb), function (ev) {\n var strm = new Unzlib(ev.data);\n onmessage = astrm(strm);\n }, 11, 0);\n }\n return AsyncUnzlib;\n}());\nexport { AsyncUnzlib };\nexport function unzlib(data, opts, cb) {\n if (!cb)\n cb = opts, opts = {};\n if (typeof cb != 'function')\n err(7);\n return cbify(data, opts, [\n bInflt,\n zule,\n function () { return [unzlibSync]; }\n ], function (ev) { return pbf(unzlibSync(ev.data[0], gopt(ev.data[1]))); }, 5, cb);\n}\n/**\n * Expands Zlib data\n * @param data The data to decompress\n * @param opts The decompression options\n * @returns The decompressed version of the data\n */\nexport function unzlibSync(data, opts) {\n return inflt(data.subarray(zls(data, opts && opts.dictionary), -4), { i: 2 }, opts && opts.out, opts && opts.dictionary);\n}\n// Default algorithm for compression (used because having a known output size allows faster decompression)\nexport { gzip as compress, AsyncGzip as AsyncCompress };\nexport { gzipSync as compressSync, Gzip as Compress };\n/**\n * Streaming GZIP, Zlib, or raw DEFLATE decompression\n */\nvar Decompress = /*#__PURE__*/ (function () {\n function Decompress(opts, cb) {\n this.o = StrmOpt.call(this, opts, cb) || {};\n this.G = Gunzip;\n this.I = Inflate;\n this.Z = Unzlib;\n }\n // init substream\n // overriden by AsyncDecompress\n Decompress.prototype.i = function () {\n var _this = this;\n this.s.ondata = function (dat, final) {\n _this.ondata(dat, final);\n };\n };\n /**\n * Pushes a chunk to be decompressed\n * @param chunk The chunk to push\n * @param final Whether this is the last chunk\n */\n Decompress.prototype.push = function (chunk, final) {\n if (!this.ondata)\n err(5);\n if (!this.s) {\n if (this.p && this.p.length) {\n var n = new u8(this.p.length + chunk.length);\n n.set(this.p), n.set(chunk, this.p.length);\n }\n else\n this.p = chunk;\n if (this.p.length > 2) {\n this.s = (this.p[0] == 31 && this.p[1] == 139 && this.p[2] == 8)\n ? new this.G(this.o)\n : ((this.p[0] & 15) != 8 || (this.p[0] >> 4) > 7 || ((this.p[0] << 8 | this.p[1]) % 31))\n ? new this.I(this.o)\n : new this.Z(this.o);\n this.i();\n this.s.push(this.p, final);\n this.p = null;\n }\n }\n else\n this.s.push(chunk, final);\n };\n return Decompress;\n}());\nexport { Decompress };\n/**\n * Asynchronous streaming GZIP, Zlib, or raw DEFLATE decompression\n */\nvar AsyncDecompress = /*#__PURE__*/ (function () {\n function AsyncDecompress(opts, cb) {\n Decompress.call(this, opts, cb);\n this.queuedSize = 0;\n this.G = AsyncGunzip;\n this.I = AsyncInflate;\n this.Z = AsyncUnzlib;\n }\n AsyncDecompress.prototype.i = function () {\n var _this = this;\n this.s.ondata = function (err, dat, final) {\n _this.ondata(err, dat, final);\n };\n this.s.ondrain = function (size) {\n _this.queuedSize -= size;\n if (_this.ondrain)\n _this.ondrain(size);\n };\n };\n /**\n * Pushes a chunk to be decompressed\n * @param chunk The chunk to push\n * @param final Whether this is the last chunk\n */\n AsyncDecompress.prototype.push = function (chunk, final) {\n this.queuedSize += chunk.length;\n Decompress.prototype.push.call(this, chunk, final);\n };\n return AsyncDecompress;\n}());\nexport { AsyncDecompress };\nexport function decompress(data, opts, cb) {\n if (!cb)\n cb = opts, opts = {};\n if (typeof cb != 'function')\n err(7);\n return (data[0] == 31 && data[1] == 139 && data[2] == 8)\n ? gunzip(data, opts, cb)\n : ((data[0] & 15) != 8 || (data[0] >> 4) > 7 || ((data[0] << 8 | data[1]) % 31))\n ? inflate(data, opts, cb)\n : unzlib(data, opts, cb);\n}\n/**\n * Expands compressed GZIP, Zlib, or raw DEFLATE data, automatically detecting the format\n * @param data The data to decompress\n * @param opts The decompression options\n * @returns The decompressed version of the data\n */\nexport function decompressSync(data, opts) {\n return (data[0] == 31 && data[1] == 139 && data[2] == 8)\n ? gunzipSync(data, opts)\n : ((data[0] & 15) != 8 || (data[0] >> 4) > 7 || ((data[0] << 8 | data[1]) % 31))\n ? inflateSync(data, opts)\n : unzlibSync(data, opts);\n}\n// flatten a directory structure\nvar fltn = function (d, p, t, o) {\n for (var k in d) {\n var val = d[k], n = p + k, op = o;\n if (Array.isArray(val))\n op = mrg(o, val[1]), val = val[0];\n if (val instanceof u8)\n t[n] = [val, op];\n else {\n t[n += '/'] = [new u8(0), op];\n fltn(val, n, t, o);\n }\n }\n};\n// text encoder\nvar te = typeof TextEncoder != 'undefined' && /*#__PURE__*/ new TextEncoder();\n// text decoder\nvar td = typeof TextDecoder != 'undefined' && /*#__PURE__*/ new TextDecoder();\n// text decoder stream\nvar tds = 0;\ntry {\n td.decode(et, { stream: true });\n tds = 1;\n}\ncatch (e) { }\n// decode UTF8\nvar dutf8 = function (d) {\n for (var r = '', i = 0;;) {\n var c = d[i++];\n var eb = (c > 127) + (c > 223) + (c > 239);\n if (i + eb > d.length)\n return { s: r, r: slc(d, i - 1) };\n if (!eb)\n r += String.fromCharCode(c);\n else if (eb == 3) {\n c = ((c & 15) << 18 | (d[i++] & 63) << 12 | (d[i++] & 63) << 6 | (d[i++] & 63)) - 65536,\n r += String.fromCharCode(55296 | (c >> 10), 56320 | (c & 1023));\n }\n else if (eb & 1)\n r += String.fromCharCode((c & 31) << 6 | (d[i++] & 63));\n else\n r += String.fromCharCode((c & 15) << 12 | (d[i++] & 63) << 6 | (d[i++] & 63));\n }\n};\n/**\n * Streaming UTF-8 decoding\n */\nvar DecodeUTF8 = /*#__PURE__*/ (function () {\n /**\n * Creates a UTF-8 decoding stream\n * @param cb The callback to call whenever data is decoded\n */\n function DecodeUTF8(cb) {\n this.ondata = cb;\n if (tds)\n this.t = new TextDecoder();\n else\n this.p = et;\n }\n /**\n * Pushes a chunk to be decoded from UTF-8 binary\n * @param chunk The chunk to push\n * @param final Whether this is the last chunk\n */\n DecodeUTF8.prototype.push = function (chunk, final) {\n if (!this.ondata)\n err(5);\n final = !!final;\n if (this.t) {\n this.ondata(this.t.decode(chunk, { stream: true }), final);\n if (final) {\n if (this.t.decode().length)\n err(8);\n this.t = null;\n }\n return;\n }\n if (!this.p)\n err(4);\n var dat = new u8(this.p.length + chunk.length);\n dat.set(this.p);\n dat.set(chunk, this.p.length);\n var _a = dutf8(dat), s = _a.s, r = _a.r;\n if (final) {\n if (r.length)\n err(8);\n this.p = null;\n }\n else\n this.p = r;\n this.ondata(s, final);\n };\n return DecodeUTF8;\n}());\nexport { DecodeUTF8 };\n/**\n * Streaming UTF-8 encoding\n */\nvar EncodeUTF8 = /*#__PURE__*/ (function () {\n /**\n * Creates a UTF-8 decoding stream\n * @param cb The callback to call whenever data is encoded\n */\n function EncodeUTF8(cb) {\n this.ondata = cb;\n }\n /**\n * Pushes a chunk to be encoded to UTF-8\n * @param chunk The string data to push\n * @param final Whether this is the last chunk\n */\n EncodeUTF8.prototype.push = function (chunk, final) {\n if (!this.ondata)\n err(5);\n if (this.d)\n err(4);\n this.ondata(strToU8(chunk), this.d = final || false);\n };\n return EncodeUTF8;\n}());\nexport { EncodeUTF8 };\n/**\n * Converts a string into a Uint8Array for use with compression/decompression methods\n * @param str The string to encode\n * @param latin1 Whether or not to interpret the data as Latin-1. This should\n * not need to be true unless decoding a binary string.\n * @returns The string encoded in UTF-8/Latin-1 binary\n */\nexport function strToU8(str, latin1) {\n if (latin1) {\n var ar_1 = new u8(str.length);\n for (var i = 0; i < str.length; ++i)\n ar_1[i] = str.charCodeAt(i);\n return ar_1;\n }\n if (te)\n return te.encode(str);\n var l = str.length;\n var ar = new u8(str.length + (str.length >> 1));\n var ai = 0;\n var w = function (v) { ar[ai++] = v; };\n for (var i = 0; i < l; ++i) {\n if (ai + 5 > ar.length) {\n var n = new u8(ai + 8 + ((l - i) << 1));\n n.set(ar);\n ar = n;\n }\n var c = str.charCodeAt(i);\n if (c < 128 || latin1)\n w(c);\n else if (c < 2048)\n w(192 | (c >> 6)), w(128 | (c & 63));\n else if (c > 55295 && c < 57344)\n c = 65536 + (c & 1023 << 10) | (str.charCodeAt(++i) & 1023),\n w(240 | (c >> 18)), w(128 | ((c >> 12) & 63)), w(128 | ((c >> 6) & 63)), w(128 | (c & 63));\n else\n w(224 | (c >> 12)), w(128 | ((c >> 6) & 63)), w(128 | (c & 63));\n }\n return slc(ar, 0, ai);\n}\n/**\n * Converts a Uint8Array to a string\n * @param dat The data to decode to string\n * @param latin1 Whether or not to interpret the data as Latin-1. This should\n * not need to be true unless encoding to binary string.\n * @returns The original UTF-8/Latin-1 string\n */\nexport function strFromU8(dat, latin1) {\n if (latin1) {\n var r = '';\n for (var i = 0; i < dat.length; i += 16384)\n r += String.fromCharCode.apply(null, dat.subarray(i, i + 16384));\n return r;\n }\n else if (td) {\n return td.decode(dat);\n }\n else {\n var _a = dutf8(dat), s = _a.s, r = _a.r;\n if (r.length)\n err(8);\n return s;\n }\n}\n;\n// deflate bit flag\nvar dbf = function (l) { return l == 1 ? 3 : l < 6 ? 2 : l == 9 ? 1 : 0; };\n// skip local zip header\nvar slzh = function (d, b) { return b + 30 + b2(d, b + 26) + b2(d, b + 28); };\n// read zip header\nvar zh = function (d, b, z) {\n var fnl = b2(d, b + 28), fn = strFromU8(d.subarray(b + 46, b + 46 + fnl), !(b2(d, b + 8) & 2048)), es = b + 46 + fnl, bs = b4(d, b + 20);\n var _a = z && bs == 4294967295 ? z64e(d, es) : [bs, b4(d, b + 24), b4(d, b + 42)], sc = _a[0], su = _a[1], off = _a[2];\n return [b2(d, b + 10), sc, su, fn, es + b2(d, b + 30) + b2(d, b + 32), off];\n};\n// read zip64 extra field\nvar z64e = function (d, b) {\n for (; b2(d, b) != 1; b += 4 + b2(d, b + 2))\n ;\n return [b8(d, b + 12), b8(d, b + 4), b8(d, b + 20)];\n};\n// extra field length\nvar exfl = function (ex) {\n var le = 0;\n if (ex) {\n for (var k in ex) {\n var l = ex[k].length;\n if (l > 65535)\n err(9);\n le += l + 4;\n }\n }\n return le;\n};\n// write zip header\nvar wzh = function (d, b, f, fn, u, c, ce, co) {\n var fl = fn.length, ex = f.extra, col = co && co.length;\n var exl = exfl(ex);\n wbytes(d, b, ce != null ? 0x2014B50 : 0x4034B50), b += 4;\n if (ce != null)\n d[b++] = 20, d[b++] = f.os;\n d[b] = 20, b += 2; // spec compliance? what's that?\n d[b++] = (f.flag << 1) | (c < 0 && 8), d[b++] = u && 8;\n d[b++] = f.compression & 255, d[b++] = f.compression >> 8;\n var dt = new Date(f.mtime == null ? Date.now() : f.mtime), y = dt.getFullYear() - 1980;\n if (y < 0 || y > 119)\n err(10);\n wbytes(d, b, (y << 25) | ((dt.getMonth() + 1) << 21) | (dt.getDate() << 16) | (dt.getHours() << 11) | (dt.getMinutes() << 5) | (dt.getSeconds() >> 1)), b += 4;\n if (c != -1) {\n wbytes(d, b, f.crc);\n wbytes(d, b + 4, c < 0 ? -c - 2 : c);\n wbytes(d, b + 8, f.size);\n }\n wbytes(d, b + 12, fl);\n wbytes(d, b + 14, exl), b += 16;\n if (ce != null) {\n wbytes(d, b, col);\n wbytes(d, b + 6, f.attrs);\n wbytes(d, b + 10, ce), b += 14;\n }\n d.set(fn, b);\n b += fl;\n if (exl) {\n for (var k in ex) {\n var exf = ex[k], l = exf.length;\n wbytes(d, b, +k);\n wbytes(d, b + 2, l);\n d.set(exf, b + 4), b += 4 + l;\n }\n }\n if (col)\n d.set(co, b), b += col;\n return b;\n};\n// write zip footer (end of central directory)\nvar wzf = function (o, b, c, d, e) {\n wbytes(o, b, 0x6054B50); // skip disk\n wbytes(o, b + 8, c);\n wbytes(o, b + 10, c);\n wbytes(o, b + 12, d);\n wbytes(o, b + 16, e);\n};\n/**\n * A pass-through stream to keep data uncompressed in a ZIP archive.\n */\nvar ZipPassThrough = /*#__PURE__*/ (function () {\n /**\n * Creates a pass-through stream that can be added to ZIP archives\n * @param filename The filename to associate with this data stream\n */\n function ZipPassThrough(filename) {\n this.filename = filename;\n this.c = crc();\n this.size = 0;\n this.compression = 0;\n }\n /**\n * Processes a chunk and pushes to the output stream. You can override this\n * method in a subclass for custom behavior, but by default this passes\n * the data through. You must call this.ondata(err, chunk, final) at some\n * point in this method.\n * @param chunk The chunk to process\n * @param final Whether this is the last chunk\n */\n ZipPassThrough.prototype.process = function (chunk, final) {\n this.ondata(null, chunk, final);\n };\n /**\n * Pushes a chunk to be added. If you are subclassing this with a custom\n * compression algorithm, note that you must push data from the source\n * file only, pre-compression.\n * @param chunk The chunk to push\n * @param final Whether this is the last chunk\n */\n ZipPassThrough.prototype.push = function (chunk, final) {\n if (!this.ondata)\n err(5);\n this.c.p(chunk);\n this.size += chunk.length;\n if (final)\n this.crc = this.c.d();\n this.process(chunk, final || false);\n };\n return ZipPassThrough;\n}());\nexport { ZipPassThrough };\n// I don't extend because TypeScript extension adds 1kB of runtime bloat\n/**\n * Streaming DEFLATE compression for ZIP archives. Prefer using AsyncZipDeflate\n * for better performance\n */\nvar ZipDeflate = /*#__PURE__*/ (function () {\n /**\n * Creates a DEFLATE stream that can be added to ZIP archives\n * @param filename The filename to associate with this data stream\n * @param opts The compression options\n */\n function ZipDeflate(filename, opts) {\n var _this = this;\n if (!opts)\n opts = {};\n ZipPassThrough.call(this, filename);\n this.d = new Deflate(opts, function (dat, final) {\n _this.ondata(null, dat, final);\n });\n this.compression = 8;\n this.flag = dbf(opts.level);\n }\n ZipDeflate.prototype.process = function (chunk, final) {\n try {\n this.d.push(chunk, final);\n }\n catch (e) {\n this.ondata(e, null, final);\n }\n };\n /**\n * Pushes a chunk to be deflated\n * @param chunk The chunk to push\n * @param final Whether this is the last chunk\n */\n ZipDeflate.prototype.push = function (chunk, final) {\n ZipPassThrough.prototype.push.call(this, chunk, final);\n };\n return ZipDeflate;\n}());\nexport { ZipDeflate };\n/**\n * Asynchronous streaming DEFLATE compression for ZIP archives\n */\nvar AsyncZipDeflate = /*#__PURE__*/ (function () {\n /**\n * Creates an asynchronous DEFLATE stream that can be added to ZIP archives\n * @param filename The filename to associate with this data stream\n * @param opts The compression options\n */\n function AsyncZipDeflate(filename, opts) {\n var _this = this;\n if (!opts)\n opts = {};\n ZipPassThrough.call(this, filename);\n this.d = new AsyncDeflate(opts, function (err, dat, final) {\n _this.ondata(err, dat, final);\n });\n this.compression = 8;\n this.flag = dbf(opts.level);\n this.terminate = this.d.terminate;\n }\n AsyncZipDeflate.prototype.process = function (chunk, final) {\n this.d.push(chunk, final);\n };\n /**\n * Pushes a chunk to be deflated\n * @param chunk The chunk to push\n * @param final Whether this is the last chunk\n */\n AsyncZipDeflate.prototype.push = function (chunk, final) {\n ZipPassThrough.prototype.push.call(this, chunk, final);\n };\n return AsyncZipDeflate;\n}());\nexport { AsyncZipDeflate };\n// TODO: Better tree shaking\n/**\n * A zippable archive to which files can incrementally be added\n */\nvar Zip = /*#__PURE__*/ (function () {\n /**\n * Creates an empty ZIP archive to which files can be added\n * @param cb The callback to call whenever data for the generated ZIP archive\n * is available\n */\n function Zip(cb) {\n this.ondata = cb;\n this.u = [];\n this.d = 1;\n }\n /**\n * Adds a file to the ZIP archive\n * @param file The file stream to add\n */\n Zip.prototype.add = function (file) {\n var _this = this;\n if (!this.ondata)\n err(5);\n // finishing or finished\n if (this.d & 2)\n this.ondata(err(4 + (this.d & 1) * 8, 0, 1), null, false);\n else {\n var f = strToU8(file.filename), fl_1 = f.length;\n var com = file.comment, o = com && strToU8(com);\n var u = fl_1 != file.filename.length || (o && (com.length != o.length));\n var hl_1 = fl_1 + exfl(file.extra) + 30;\n if (fl_1 > 65535)\n this.ondata(err(11, 0, 1), null, false);\n var header = new u8(hl_1);\n wzh(header, 0, file, f, u, -1);\n var chks_1 = [header];\n var pAll_1 = function () {\n for (var _i = 0, chks_2 = chks_1; _i < chks_2.length; _i++) {\n var chk = chks_2[_i];\n _this.ondata(null, chk, false);\n }\n chks_1 = [];\n };\n var tr_1 = this.d;\n this.d = 0;\n var ind_1 = this.u.length;\n var uf_1 = mrg(file, {\n f: f,\n u: u,\n o: o,\n t: function () {\n if (file.terminate)\n file.terminate();\n },\n r: function () {\n pAll_1();\n if (tr_1) {\n var nxt = _this.u[ind_1 + 1];\n if (nxt)\n nxt.r();\n else\n _this.d = 1;\n }\n tr_1 = 1;\n }\n });\n var cl_1 = 0;\n file.ondata = function (err, dat, final) {\n if (err) {\n _this.ondata(err, dat, final);\n _this.terminate();\n }\n else {\n cl_1 += dat.length;\n chks_1.push(dat);\n if (final) {\n var dd = new u8(16);\n wbytes(dd, 0, 0x8074B50);\n wbytes(dd, 4, file.crc);\n wbytes(dd, 8, cl_1);\n wbytes(dd, 12, file.size);\n chks_1.push(dd);\n uf_1.c = cl_1, uf_1.b = hl_1 + cl_1 + 16, uf_1.crc = file.crc, uf_1.size = file.size;\n if (tr_1)\n uf_1.r();\n tr_1 = 1;\n }\n else if (tr_1)\n pAll_1();\n }\n };\n this.u.push(uf_1);\n }\n };\n /**\n * Ends the process of adding files and prepares to emit the final chunks.\n * This *must* be called after adding all desired files for the resulting\n * ZIP file to work properly.\n */\n Zip.prototype.end = function () {\n var _this = this;\n if (this.d & 2) {\n this.ondata(err(4 + (this.d & 1) * 8, 0, 1), null, true);\n return;\n }\n if (this.d)\n this.e();\n else\n this.u.push({\n r: function () {\n if (!(_this.d & 1))\n return;\n _this.u.splice(-1, 1);\n _this.e();\n },\n t: function () { }\n });\n this.d = 3;\n };\n Zip.prototype.e = function () {\n var bt = 0, l = 0, tl = 0;\n for (var _i = 0, _a = this.u; _i < _a.length; _i++) {\n var f = _a[_i];\n tl += 46 + f.f.length + exfl(f.extra) + (f.o ? f.o.length : 0);\n }\n var out = new u8(tl + 22);\n for (var _b = 0, _c = this.u; _b < _c.length; _b++) {\n var f = _c[_b];\n wzh(out, bt, f, f.f, f.u, -f.c - 2, l, f.o);\n bt += 46 + f.f.length + exfl(f.extra) + (f.o ? f.o.length : 0), l += f.b;\n }\n wzf(out, bt, this.u.length, tl, l);\n this.ondata(null, out, true);\n this.d = 2;\n };\n /**\n * A method to terminate any internal workers used by the stream. Subsequent\n * calls to add() will fail.\n */\n Zip.prototype.terminate = function () {\n for (var _i = 0, _a = this.u; _i < _a.length; _i++) {\n var f = _a[_i];\n f.t();\n }\n this.d = 2;\n };\n return Zip;\n}());\nexport { Zip };\nexport function zip(data, opts, cb) {\n if (!cb)\n cb = opts, opts = {};\n if (typeof cb != 'function')\n err(7);\n var r = {};\n fltn(data, '', r, opts);\n var k = Object.keys(r);\n var lft = k.length, o = 0, tot = 0;\n var slft = lft, files = new Array(lft);\n var term = [];\n var tAll = function () {\n for (var i = 0; i < term.length; ++i)\n term[i]();\n };\n var cbd = function (a, b) {\n mt(function () { cb(a, b); });\n };\n mt(function () { cbd = cb; });\n var cbf = function () {\n var out = new u8(tot + 22), oe = o, cdl = tot - o;\n tot = 0;\n for (var i = 0; i < slft; ++i) {\n var f = files[i];\n try {\n var l = f.c.length;\n wzh(out, tot, f, f.f, f.u, l);\n var badd = 30 + f.f.length + exfl(f.extra);\n var loc = tot + badd;\n out.set(f.c, loc);\n wzh(out, o, f, f.f, f.u, l, tot, f.m), o += 16 + badd + (f.m ? f.m.length : 0), tot = loc + l;\n }\n catch (e) {\n return cbd(e, null);\n }\n }\n wzf(out, o, files.length, cdl, oe);\n cbd(null, out);\n };\n if (!lft)\n cbf();\n var _loop_1 = function (i) {\n var fn = k[i];\n var _a = r[fn], file = _a[0], p = _a[1];\n var c = crc(), size = file.length;\n c.p(file);\n var f = strToU8(fn), s = f.length;\n var com = p.comment, m = com && strToU8(com), ms = m && m.length;\n var exl = exfl(p.extra);\n var compression = p.level == 0 ? 0 : 8;\n var cbl = function (e, d) {\n if (e) {\n tAll();\n cbd(e, null);\n }\n else {\n var l = d.length;\n files[i] = mrg(p, {\n size: size,\n crc: c.d(),\n c: d,\n f: f,\n m: m,\n u: s != fn.length || (m && (com.length != ms)),\n compression: compression\n });\n o += 30 + s + exl + l;\n tot += 76 + 2 * (s + exl) + (ms || 0) + l;\n if (!--lft)\n cbf();\n }\n };\n if (s > 65535)\n cbl(err(11, 0, 1), null);\n if (!compression)\n cbl(null, file);\n else if (size < 160000) {\n try {\n cbl(null, deflateSync(file, p));\n }\n catch (e) {\n cbl(e, null);\n }\n }\n else\n term.push(deflate(file, p, cbl));\n };\n // Cannot use lft because it can decrease\n for (var i = 0; i < slft; ++i) {\n _loop_1(i);\n }\n return tAll;\n}\n/**\n * Synchronously creates a ZIP file. Prefer using `zip` for better performance\n * with more than one file.\n * @param data The directory structure for the ZIP archive\n * @param opts The main options, merged with per-file options\n * @returns The generated ZIP archive\n */\nexport function zipSync(data, opts) {\n if (!opts)\n opts = {};\n var r = {};\n var files = [];\n fltn(data, '', r, opts);\n var o = 0;\n var tot = 0;\n for (var fn in r) {\n var _a = r[fn], file = _a[0], p = _a[1];\n var compression = p.level == 0 ? 0 : 8;\n var f = strToU8(fn), s = f.length;\n var com = p.comment, m = com && strToU8(com), ms = m && m.length;\n var exl = exfl(p.extra);\n if (s > 65535)\n err(11);\n var d = compression ? deflateSync(file, p) : file, l = d.length;\n var c = crc();\n c.p(file);\n files.push(mrg(p, {\n size: file.length,\n crc: c.d(),\n c: d,\n f: f,\n m: m,\n u: s != fn.length || (m && (com.length != ms)),\n o: o,\n compression: compression\n }));\n o += 30 + s + exl + l;\n tot += 76 + 2 * (s + exl) + (ms || 0) + l;\n }\n var out = new u8(tot + 22), oe = o, cdl = tot - o;\n for (var i = 0; i < files.length; ++i) {\n var f = files[i];\n wzh(out, f.o, f, f.f, f.u, f.c.length);\n var badd = 30 + f.f.length + exfl(f.extra);\n out.set(f.c, f.o + badd);\n wzh(out, o, f, f.f, f.u, f.c.length, f.o, f.m), o += 16 + badd + (f.m ? f.m.length : 0);\n }\n wzf(out, o, files.length, cdl, oe);\n return out;\n}\n/**\n * Streaming pass-through decompression for ZIP archives\n */\nvar UnzipPassThrough = /*#__PURE__*/ (function () {\n function UnzipPassThrough() {\n }\n UnzipPassThrough.prototype.push = function (data, final) {\n this.ondata(null, data, final);\n };\n UnzipPassThrough.compression = 0;\n return UnzipPassThrough;\n}());\nexport { UnzipPassThrough };\n/**\n * Streaming DEFLATE decompression for ZIP archives. Prefer AsyncZipInflate for\n * better performance.\n */\nvar UnzipInflate = /*#__PURE__*/ (function () {\n /**\n * Creates a DEFLATE decompression that can be used in ZIP archives\n */\n function UnzipInflate() {\n var _this = this;\n this.i = new Inflate(function (dat, final) {\n _this.ondata(null, dat, final);\n });\n }\n UnzipInflate.prototype.push = function (data, final) {\n try {\n this.i.push(data, final);\n }\n catch (e) {\n this.ondata(e, null, final);\n }\n };\n UnzipInflate.compression = 8;\n return UnzipInflate;\n}());\nexport { UnzipInflate };\n/**\n * Asynchronous streaming DEFLATE decompression for ZIP archives\n */\nvar AsyncUnzipInflate = /*#__PURE__*/ (function () {\n /**\n * Creates a DEFLATE decompression that can be used in ZIP archives\n */\n function AsyncUnzipInflate(_, sz) {\n var _this = this;\n if (sz < 320000) {\n this.i = new Inflate(function (dat, final) {\n _this.ondata(null, dat, final);\n });\n }\n else {\n this.i = new AsyncInflate(function (err, dat, final) {\n _this.ondata(err, dat, final);\n });\n this.terminate = this.i.terminate;\n }\n }\n AsyncUnzipInflate.prototype.push = function (data, final) {\n if (this.i.terminate)\n data = slc(data, 0);\n this.i.push(data, final);\n };\n AsyncUnzipInflate.compression = 8;\n return AsyncUnzipInflate;\n}());\nexport { AsyncUnzipInflate };\n/**\n * A ZIP archive decompression stream that emits files as they are discovered\n */\nvar Unzip = /*#__PURE__*/ (function () {\n /**\n * Creates a ZIP decompression stream\n * @param cb The callback to call whenever a file in the ZIP archive is found\n */\n function Unzip(cb) {\n this.onfile = cb;\n this.k = [];\n this.o = {\n 0: UnzipPassThrough\n };\n this.p = et;\n }\n /**\n * Pushes a chunk to be unzipped\n * @param chunk The chunk to push\n * @param final Whether this is the last chunk\n */\n Unzip.prototype.push = function (chunk, final) {\n var _this = this;\n if (!this.onfile)\n err(5);\n if (!this.p)\n err(4);\n if (this.c > 0) {\n var len = Math.min(this.c, chunk.length);\n var toAdd = chunk.subarray(0, len);\n this.c -= len;\n if (this.d)\n this.d.push(toAdd, !this.c);\n else\n this.k[0].push(toAdd);\n chunk = chunk.subarray(len);\n if (chunk.length)\n return this.push(chunk, final);\n }\n else {\n var f = 0, i = 0, is = void 0, buf = void 0;\n if (!this.p.length)\n buf = chunk;\n else if (!chunk.length)\n buf = this.p;\n else {\n buf = new u8(this.p.length + chunk.length);\n buf.set(this.p), buf.set(chunk, this.p.length);\n }\n var l = buf.length, oc = this.c, add = oc && this.d;\n var _loop_2 = function () {\n var _a;\n var sig = b4(buf, i);\n if (sig == 0x4034B50) {\n f = 1, is = i;\n this_1.d = null;\n this_1.c = 0;\n var bf = b2(buf, i + 6), cmp_1 = b2(buf, i + 8), u = bf & 2048, dd = bf & 8, fnl = b2(buf, i + 26), es = b2(buf, i + 28);\n if (l > i + 30 + fnl + es) {\n var chks_3 = [];\n this_1.k.unshift(chks_3);\n f = 2;\n var sc_1 = b4(buf, i + 18), su_1 = b4(buf, i + 22);\n var fn_1 = strFromU8(buf.subarray(i + 30, i += 30 + fnl), !u);\n if (sc_1 == 4294967295) {\n _a = dd ? [-2] : z64e(buf, i), sc_1 = _a[0], su_1 = _a[1];\n }\n else if (dd)\n sc_1 = -1;\n i += es;\n this_1.c = sc_1;\n var d_1;\n var file_1 = {\n name: fn_1,\n compression: cmp_1,\n start: function () {\n if (!file_1.ondata)\n err(5);\n if (!sc_1)\n file_1.ondata(null, et, true);\n else {\n var ctr = _this.o[cmp_1];\n if (!ctr)\n file_1.ondata(err(14, 'unknown compression type ' + cmp_1, 1), null, false);\n d_1 = sc_1 < 0 ? new ctr(fn_1) : new ctr(fn_1, sc_1, su_1);\n d_1.ondata = function (err, dat, final) { file_1.ondata(err, dat, final); };\n for (var _i = 0, chks_4 = chks_3; _i < chks_4.length; _i++) {\n var dat = chks_4[_i];\n d_1.push(dat, false);\n }\n if (_this.k[0] == chks_3 && _this.c)\n _this.d = d_1;\n else\n d_1.push(et, true);\n }\n },\n terminate: function () {\n if (d_1 && d_1.terminate)\n d_1.terminate();\n }\n };\n if (sc_1 >= 0)\n file_1.size = sc_1, file_1.originalSize = su_1;\n this_1.onfile(file_1);\n }\n return \"break\";\n }\n else if (oc) {\n if (sig == 0x8074B50) {\n is = i += 12 + (oc == -2 && 8), f = 3, this_1.c = 0;\n return \"break\";\n }\n else if (sig == 0x2014B50) {\n is = i -= 4, f = 3, this_1.c = 0;\n return \"break\";\n }\n }\n };\n var this_1 = this;\n for (; i < l - 4; ++i) {\n var state_1 = _loop_2();\n if (state_1 === \"break\")\n break;\n }\n this.p = et;\n if (oc < 0) {\n var dat = f ? buf.subarray(0, is - 12 - (oc == -2 && 8) - (b4(buf, is - 16) == 0x8074B50 && 4)) : buf.subarray(0, i);\n if (add)\n add.push(dat, !!f);\n else\n this.k[+(f == 2)].push(dat);\n }\n if (f & 2)\n return this.push(buf.subarray(i), final);\n this.p = buf.subarray(i);\n }\n if (final) {\n if (this.c)\n err(13);\n this.p = null;\n }\n };\n /**\n * Registers a decoder with the stream, allowing for files compressed with\n * the compression type provided to be expanded correctly\n * @param decoder The decoder constructor\n */\n Unzip.prototype.register = function (decoder) {\n this.o[decoder.compression] = decoder;\n };\n return Unzip;\n}());\nexport { Unzip };\nvar mt = typeof queueMicrotask == 'function' ? queueMicrotask : typeof setTimeout == 'function' ? setTimeout : function (fn) { fn(); };\nexport function unzip(data, opts, cb) {\n if (!cb)\n cb = opts, opts = {};\n if (typeof cb != 'function')\n err(7);\n var term = [];\n var tAll = function () {\n for (var i = 0; i < term.length; ++i)\n term[i]();\n };\n var files = {};\n var cbd = function (a, b) {\n mt(function () { cb(a, b); });\n };\n mt(function () { cbd = cb; });\n var e = data.length - 22;\n for (; b4(data, e) != 0x6054B50; --e) {\n if (!e || data.length - e > 65558) {\n cbd(err(13, 0, 1), null);\n return tAll;\n }\n }\n ;\n var lft = b2(data, e + 8);\n if (lft) {\n var c = lft;\n var o = b4(data, e + 16);\n var z = o == 4294967295 || c == 65535;\n if (z) {\n var ze = b4(data, e - 12);\n z = b4(data, ze) == 0x6064B50;\n if (z) {\n c = lft = b4(data, ze + 32);\n o = b4(data, ze + 48);\n }\n }\n var fltr = opts && opts.filter;\n var _loop_3 = function (i) {\n var _a = zh(data, o, z), c_1 = _a[0], sc = _a[1], su = _a[2], fn = _a[3], no = _a[4], off = _a[5], b = slzh(data, off);\n o = no;\n var cbl = function (e, d) {\n if (e) {\n tAll();\n cbd(e, null);\n }\n else {\n if (d)\n files[fn] = d;\n if (!--lft)\n cbd(null, files);\n }\n };\n if (!fltr || fltr({\n name: fn,\n size: sc,\n originalSize: su,\n compression: c_1\n })) {\n if (!c_1)\n cbl(null, slc(data, b, b + sc));\n else if (c_1 == 8) {\n var infl = data.subarray(b, b + sc);\n // Synchronously decompress under 512KB, or barely-compressed data\n if (su < 524288 || sc > 0.8 * su) {\n try {\n cbl(null, inflateSync(infl, { out: new u8(su) }));\n }\n catch (e) {\n cbl(e, null);\n }\n }\n else\n term.push(inflate(infl, { size: su }, cbl));\n }\n else\n cbl(err(14, 'unknown compression type ' + c_1, 1), null);\n }\n else\n cbl(null, null);\n };\n for (var i = 0; i < c; ++i) {\n _loop_3(i);\n }\n }\n else\n cbd(null, {});\n return tAll;\n}\n/**\n * Synchronously decompresses a ZIP archive. Prefer using `unzip` for better\n * performance with more than one file.\n * @param data The raw compressed ZIP file\n * @param opts The ZIP extraction options\n * @returns The decompressed files\n */\nexport function unzipSync(data, opts) {\n var files = {};\n var e = data.length - 22;\n for (; b4(data, e) != 0x6054B50; --e) {\n if (!e || data.length - e > 65558)\n err(13);\n }\n ;\n var c = b2(data, e + 8);\n if (!c)\n return {};\n var o = b4(data, e + 16);\n var z = o == 4294967295 || c == 65535;\n if (z) {\n var ze = b4(data, e - 12);\n z = b4(data, ze) == 0x6064B50;\n if (z) {\n c = b4(data, ze + 32);\n o = b4(data, ze + 48);\n }\n }\n var fltr = opts && opts.filter;\n for (var i = 0; i < c; ++i) {\n var _a = zh(data, o, z), c_2 = _a[0], sc = _a[1], su = _a[2], fn = _a[3], no = _a[4], off = _a[5], b = slzh(data, off);\n o = no;\n if (!fltr || fltr({\n name: fn,\n size: sc,\n originalSize: su,\n compression: c_2\n })) {\n if (!c_2)\n files[fn] = slc(data, b, b + sc);\n else if (c_2 == 8)\n files[fn] = inflateSync(data.subarray(b, b + sc), { out: new u8(su) });\n else\n err(14, 'unknown compression type ' + c_2);\n }\n }\n return files;\n}\n", "import {\n\tVector3,\n\tVector4\n} from 'three';\n\n/**\n * NURBS utils\n *\n * See NURBSCurve and NURBSSurface.\n **/\n\n\n/**************************************************************\n *\tNURBS Utils\n **************************************************************/\n\n/*\nFinds knot vector span.\n\np : degree\nu : parametric value\nU : knot vector\n\nreturns the span\n*/\nfunction findSpan( p, u, U ) {\n\n\tconst n = U.length - p - 1;\n\n\tif ( u >= U[ n ] ) {\n\n\t\treturn n - 1;\n\n\t}\n\n\tif ( u <= U[ p ] ) {\n\n\t\treturn p;\n\n\t}\n\n\tlet low = p;\n\tlet high = n;\n\tlet mid = Math.floor( ( low + high ) / 2 );\n\n\twhile ( u < U[ mid ] || u >= U[ mid + 1 ] ) {\n\n\t\tif ( u < U[ mid ] ) {\n\n\t\t\thigh = mid;\n\n\t\t} else {\n\n\t\t\tlow = mid;\n\n\t\t}\n\n\t\tmid = Math.floor( ( low + high ) / 2 );\n\n\t}\n\n\treturn mid;\n\n}\n\n\n/*\nCalculate basis functions. See The NURBS Book, page 70, algorithm A2.2\n\nspan : span in which u lies\nu : parametric point\np : degree\nU : knot vector\n\nreturns array[p+1] with basis functions values.\n*/\nfunction calcBasisFunctions( span, u, p, U ) {\n\n\tconst N = [];\n\tconst left = [];\n\tconst right = [];\n\tN[ 0 ] = 1.0;\n\n\tfor ( let j = 1; j <= p; ++ j ) {\n\n\t\tleft[ j ] = u - U[ span + 1 - j ];\n\t\tright[ j ] = U[ span + j ] - u;\n\n\t\tlet saved = 0.0;\n\n\t\tfor ( let r = 0; r < j; ++ r ) {\n\n\t\t\tconst rv = right[ r + 1 ];\n\t\t\tconst lv = left[ j - r ];\n\t\t\tconst temp = N[ r ] / ( rv + lv );\n\t\t\tN[ r ] = saved + rv * temp;\n\t\t\tsaved = lv * temp;\n\n\t\t}\n\n\t\tN[ j ] = saved;\n\n\t}\n\n\treturn N;\n\n}\n\n\n/*\nCalculate B-Spline curve points. See The NURBS Book, page 82, algorithm A3.1.\n\np : degree of B-Spline\nU : knot vector\nP : control points (x, y, z, w)\nu : parametric point\n\nreturns point for given u\n*/\nfunction calcBSplinePoint( p, U, P, u ) {\n\n\tconst span = findSpan( p, u, U );\n\tconst N = calcBasisFunctions( span, u, p, U );\n\tconst C = new Vector4( 0, 0, 0, 0 );\n\n\tfor ( let j = 0; j <= p; ++ j ) {\n\n\t\tconst point = P[ span - p + j ];\n\t\tconst Nj = N[ j ];\n\t\tconst wNj = point.w * Nj;\n\t\tC.x += point.x * wNj;\n\t\tC.y += point.y * wNj;\n\t\tC.z += point.z * wNj;\n\t\tC.w += point.w * Nj;\n\n\t}\n\n\treturn C;\n\n}\n\n\n/*\nCalculate basis functions derivatives. See The NURBS Book, page 72, algorithm A2.3.\n\nspan : span in which u lies\nu : parametric point\np : degree\nn : number of derivatives to calculate\nU : knot vector\n\nreturns array[n+1][p+1] with basis functions derivatives\n*/\nfunction calcBasisFunctionDerivatives( span, u, p, n, U ) {\n\n\tconst zeroArr = [];\n\tfor ( let i = 0; i <= p; ++ i )\n\t\tzeroArr[ i ] = 0.0;\n\n\tconst ders = [];\n\n\tfor ( let i = 0; i <= n; ++ i )\n\t\tders[ i ] = zeroArr.slice( 0 );\n\n\tconst ndu = [];\n\n\tfor ( let i = 0; i <= p; ++ i )\n\t\tndu[ i ] = zeroArr.slice( 0 );\n\n\tndu[ 0 ][ 0 ] = 1.0;\n\n\tconst left = zeroArr.slice( 0 );\n\tconst right = zeroArr.slice( 0 );\n\n\tfor ( let j = 1; j <= p; ++ j ) {\n\n\t\tleft[ j ] = u - U[ span + 1 - j ];\n\t\tright[ j ] = U[ span + j ] - u;\n\n\t\tlet saved = 0.0;\n\n\t\tfor ( let r = 0; r < j; ++ r ) {\n\n\t\t\tconst rv = right[ r + 1 ];\n\t\t\tconst lv = left[ j - r ];\n\t\t\tndu[ j ][ r ] = rv + lv;\n\n\t\t\tconst temp = ndu[ r ][ j - 1 ] / ndu[ j ][ r ];\n\t\t\tndu[ r ][ j ] = saved + rv * temp;\n\t\t\tsaved = lv * temp;\n\n\t\t}\n\n\t\tndu[ j ][ j ] = saved;\n\n\t}\n\n\tfor ( let j = 0; j <= p; ++ j ) {\n\n\t\tders[ 0 ][ j ] = ndu[ j ][ p ];\n\n\t}\n\n\tfor ( let r = 0; r <= p; ++ r ) {\n\n\t\tlet s1 = 0;\n\t\tlet s2 = 1;\n\n\t\tconst a = [];\n\t\tfor ( let i = 0; i <= p; ++ i ) {\n\n\t\t\ta[ i ] = zeroArr.slice( 0 );\n\n\t\t}\n\n\t\ta[ 0 ][ 0 ] = 1.0;\n\n\t\tfor ( let k = 1; k <= n; ++ k ) {\n\n\t\t\tlet d = 0.0;\n\t\t\tconst rk = r - k;\n\t\t\tconst pk = p - k;\n\n\t\t\tif ( r >= k ) {\n\n\t\t\t\ta[ s2 ][ 0 ] = a[ s1 ][ 0 ] / ndu[ pk + 1 ][ rk ];\n\t\t\t\td = a[ s2 ][ 0 ] * ndu[ rk ][ pk ];\n\n\t\t\t}\n\n\t\t\tconst j1 = ( rk >= - 1 ) ? 1 : - rk;\n\t\t\tconst j2 = ( r - 1 <= pk ) ? k - 1 : p - r;\n\n\t\t\tfor ( let j = j1; j <= j2; ++ j ) {\n\n\t\t\t\ta[ s2 ][ j ] = ( a[ s1 ][ j ] - a[ s1 ][ j - 1 ] ) / ndu[ pk + 1 ][ rk + j ];\n\t\t\t\td += a[ s2 ][ j ] * ndu[ rk + j ][ pk ];\n\n\t\t\t}\n\n\t\t\tif ( r <= pk ) {\n\n\t\t\t\ta[ s2 ][ k ] = - a[ s1 ][ k - 1 ] / ndu[ pk + 1 ][ r ];\n\t\t\t\td += a[ s2 ][ k ] * ndu[ r ][ pk ];\n\n\t\t\t}\n\n\t\t\tders[ k ][ r ] = d;\n\n\t\t\tconst j = s1;\n\t\t\ts1 = s2;\n\t\t\ts2 = j;\n\n\t\t}\n\n\t}\n\n\tlet r = p;\n\n\tfor ( let k = 1; k <= n; ++ k ) {\n\n\t\tfor ( let j = 0; j <= p; ++ j ) {\n\n\t\t\tders[ k ][ j ] *= r;\n\n\t\t}\n\n\t\tr *= p - k;\n\n\t}\n\n\treturn ders;\n\n}\n\n\n/*\n\tCalculate derivatives of a B-Spline. See The NURBS Book, page 93, algorithm A3.2.\n\n\tp : degree\n\tU : knot vector\n\tP : control points\n\tu : Parametric points\n\tnd : number of derivatives\n\n\treturns array[d+1] with derivatives\n\t*/\nfunction calcBSplineDerivatives( p, U, P, u, nd ) {\n\n\tconst du = nd < p ? nd : p;\n\tconst CK = [];\n\tconst span = findSpan( p, u, U );\n\tconst nders = calcBasisFunctionDerivatives( span, u, p, du, U );\n\tconst Pw = [];\n\n\tfor ( let i = 0; i < P.length; ++ i ) {\n\n\t\tconst point = P[ i ].clone();\n\t\tconst w = point.w;\n\n\t\tpoint.x *= w;\n\t\tpoint.y *= w;\n\t\tpoint.z *= w;\n\n\t\tPw[ i ] = point;\n\n\t}\n\n\tfor ( let k = 0; k <= du; ++ k ) {\n\n\t\tconst point = Pw[ span - p ].clone().multiplyScalar( nders[ k ][ 0 ] );\n\n\t\tfor ( let j = 1; j <= p; ++ j ) {\n\n\t\t\tpoint.add( Pw[ span - p + j ].clone().multiplyScalar( nders[ k ][ j ] ) );\n\n\t\t}\n\n\t\tCK[ k ] = point;\n\n\t}\n\n\tfor ( let k = du + 1; k <= nd + 1; ++ k ) {\n\n\t\tCK[ k ] = new Vector4( 0, 0, 0 );\n\n\t}\n\n\treturn CK;\n\n}\n\n\n/*\nCalculate \"K over I\"\n\nreturns k!/(i!(k-i)!)\n*/\nfunction calcKoverI( k, i ) {\n\n\tlet nom = 1;\n\n\tfor ( let j = 2; j <= k; ++ j ) {\n\n\t\tnom *= j;\n\n\t}\n\n\tlet denom = 1;\n\n\tfor ( let j = 2; j <= i; ++ j ) {\n\n\t\tdenom *= j;\n\n\t}\n\n\tfor ( let j = 2; j <= k - i; ++ j ) {\n\n\t\tdenom *= j;\n\n\t}\n\n\treturn nom / denom;\n\n}\n\n\n/*\nCalculate derivatives (0-nd) of rational curve. See The NURBS Book, page 127, algorithm A4.2.\n\nPders : result of function calcBSplineDerivatives\n\nreturns array with derivatives for rational curve.\n*/\nfunction calcRationalCurveDerivatives( Pders ) {\n\n\tconst nd = Pders.length;\n\tconst Aders = [];\n\tconst wders = [];\n\n\tfor ( let i = 0; i < nd; ++ i ) {\n\n\t\tconst point = Pders[ i ];\n\t\tAders[ i ] = new Vector3( point.x, point.y, point.z );\n\t\twders[ i ] = point.w;\n\n\t}\n\n\tconst CK = [];\n\n\tfor ( let k = 0; k < nd; ++ k ) {\n\n\t\tconst v = Aders[ k ].clone();\n\n\t\tfor ( let i = 1; i <= k; ++ i ) {\n\n\t\t\tv.sub( CK[ k - i ].clone().multiplyScalar( calcKoverI( k, i ) * wders[ i ] ) );\n\n\t\t}\n\n\t\tCK[ k ] = v.divideScalar( wders[ 0 ] );\n\n\t}\n\n\treturn CK;\n\n}\n\n\n/*\nCalculate NURBS curve derivatives. See The NURBS Book, page 127, algorithm A4.2.\n\np : degree\nU : knot vector\nP : control points in homogeneous space\nu : parametric points\nnd : number of derivatives\n\nreturns array with derivatives.\n*/\nfunction calcNURBSDerivatives( p, U, P, u, nd ) {\n\n\tconst Pders = calcBSplineDerivatives( p, U, P, u, nd );\n\treturn calcRationalCurveDerivatives( Pders );\n\n}\n\n\n/*\nCalculate rational B-Spline surface point. See The NURBS Book, page 134, algorithm A4.3.\n\np, q : degrees of B-Spline surface\nU, V : knot vectors\nP : control points (x, y, z, w)\nu, v : parametric values\n\nreturns point for given (u, v)\n*/\nfunction calcSurfacePoint( p, q, U, V, P, u, v, target ) {\n\n\tconst uspan = findSpan( p, u, U );\n\tconst vspan = findSpan( q, v, V );\n\tconst Nu = calcBasisFunctions( uspan, u, p, U );\n\tconst Nv = calcBasisFunctions( vspan, v, q, V );\n\tconst temp = [];\n\n\tfor ( let l = 0; l <= q; ++ l ) {\n\n\t\ttemp[ l ] = new Vector4( 0, 0, 0, 0 );\n\t\tfor ( let k = 0; k <= p; ++ k ) {\n\n\t\t\tconst point = P[ uspan - p + k ][ vspan - q + l ].clone();\n\t\t\tconst w = point.w;\n\t\t\tpoint.x *= w;\n\t\t\tpoint.y *= w;\n\t\t\tpoint.z *= w;\n\t\t\ttemp[ l ].add( point.multiplyScalar( Nu[ k ] ) );\n\n\t\t}\n\n\t}\n\n\tconst Sw = new Vector4( 0, 0, 0, 0 );\n\tfor ( let l = 0; l <= q; ++ l ) {\n\n\t\tSw.add( temp[ l ].multiplyScalar( Nv[ l ] ) );\n\n\t}\n\n\tSw.divideScalar( Sw.w );\n\ttarget.set( Sw.x, Sw.y, Sw.z );\n\n}\n\n/*\nCalculate rational B-Spline volume point. See The NURBS Book, page 134, algorithm A4.3.\n\np, q, r : degrees of B-Splinevolume\nU, V, W : knot vectors\nP : control points (x, y, z, w)\nu, v, w : parametric values\n\nreturns point for given (u, v, w)\n*/\nfunction calcVolumePoint( p, q, r, U, V, W, P, u, v, w, target ) {\n\n\tconst uspan = findSpan( p, u, U );\n\tconst vspan = findSpan( q, v, V );\n\tconst wspan = findSpan( r, w, W );\n\tconst Nu = calcBasisFunctions( uspan, u, p, U );\n\tconst Nv = calcBasisFunctions( vspan, v, q, V );\n\tconst Nw = calcBasisFunctions( wspan, w, r, W );\n\tconst temp = [];\n\n\tfor ( let m = 0; m <= r; ++ m ) {\n\n\t\ttemp[ m ] = [];\n\n\t\tfor ( let l = 0; l <= q; ++ l ) {\n\n\t\t\ttemp[ m ][ l ] = new Vector4( 0, 0, 0, 0 );\n\t\t\tfor ( let k = 0; k <= p; ++ k ) {\n\n\t\t\t\tconst point = P[ uspan - p + k ][ vspan - q + l ][ wspan - r + m ].clone();\n\t\t\t\tconst w = point.w;\n\t\t\t\tpoint.x *= w;\n\t\t\t\tpoint.y *= w;\n\t\t\t\tpoint.z *= w;\n\t\t\t\ttemp[ m ][ l ].add( point.multiplyScalar( Nu[ k ] ) );\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\tconst Sw = new Vector4( 0, 0, 0, 0 );\n\tfor ( let m = 0; m <= r; ++ m ) {\n\t\tfor ( let l = 0; l <= q; ++ l ) {\n\n\t\t\tSw.add( temp[ m ][ l ].multiplyScalar( Nw[ m ] ).multiplyScalar( Nv[ l ] ) );\n\n\t\t}\n\t}\n\n\tSw.divideScalar( Sw.w );\n\ttarget.set( Sw.x, Sw.y, Sw.z );\n\n}\n\n\nexport {\n\tfindSpan,\n\tcalcBasisFunctions,\n\tcalcBSplinePoint,\n\tcalcBasisFunctionDerivatives,\n\tcalcBSplineDerivatives,\n\tcalcKoverI,\n\tcalcRationalCurveDerivatives,\n\tcalcNURBSDerivatives,\n\tcalcSurfacePoint,\n\tcalcVolumePoint,\n};\n", "import {\n\tCurve,\n\tVector3,\n\tVector4\n} from 'three';\nimport * as NURBSUtils from '../curves/NURBSUtils.js';\n\n/**\n * NURBS curve object\n *\n * Derives from Curve, overriding getPoint and getTangent.\n *\n * Implementation is based on (x, y [, z=0 [, w=1]]) control points with w=weight.\n *\n **/\n\nclass NURBSCurve extends Curve {\n\n\tconstructor(\n\t\tdegree,\n\t\tknots /* array of reals */,\n\t\tcontrolPoints /* array of Vector(2|3|4) */,\n\t\tstartKnot /* index in knots */,\n\t\tendKnot /* index in knots */\n\t) {\n\n\t\tsuper();\n\n\t\tthis.degree = degree;\n\t\tthis.knots = knots;\n\t\tthis.controlPoints = [];\n\t\t// Used by periodic NURBS to remove hidden spans\n\t\tthis.startKnot = startKnot || 0;\n\t\tthis.endKnot = endKnot || ( this.knots.length - 1 );\n\n\t\tfor ( let i = 0; i < controlPoints.length; ++ i ) {\n\n\t\t\t// ensure Vector4 for control points\n\t\t\tconst point = controlPoints[ i ];\n\t\t\tthis.controlPoints[ i ] = new Vector4( point.x, point.y, point.z, point.w );\n\n\t\t}\n\n\t}\n\n\tgetPoint( t, optionalTarget = new Vector3() ) {\n\n\t\tconst point = optionalTarget;\n\n\t\tconst u = this.knots[ this.startKnot ] + t * ( this.knots[ this.endKnot ] - this.knots[ this.startKnot ] ); // linear mapping t->u\n\n\t\t// following results in (wx, wy, wz, w) homogeneous point\n\t\tconst hpoint = NURBSUtils.calcBSplinePoint( this.degree, this.knots, this.controlPoints, u );\n\n\t\tif ( hpoint.w !== 1.0 ) {\n\n\t\t\t// project to 3D space: (wx, wy, wz, w) -> (x, y, z, 1)\n\t\t\thpoint.divideScalar( hpoint.w );\n\n\t\t}\n\n\t\treturn point.set( hpoint.x, hpoint.y, hpoint.z );\n\n\t}\n\n\tgetTangent( t, optionalTarget = new Vector3() ) {\n\n\t\tconst tangent = optionalTarget;\n\n\t\tconst u = this.knots[ 0 ] + t * ( this.knots[ this.knots.length - 1 ] - this.knots[ 0 ] );\n\t\tconst ders = NURBSUtils.calcNURBSDerivatives( this.degree, this.knots, this.controlPoints, u, 1 );\n\t\ttangent.copy( ders[ 1 ] ).normalize();\n\n\t\treturn tangent;\n\n\t}\n\n}\n\nexport { NURBSCurve };\n", "import {\n\tAmbientLight,\n\tAnimationClip,\n\tBone,\n\tBufferGeometry,\n\tClampToEdgeWrapping,\n\tColor,\n\tDirectionalLight,\n\tEquirectangularReflectionMapping,\n\tEuler,\n\tFileLoader,\n\tFloat32BufferAttribute,\n\tGroup,\n\tLine,\n\tLineBasicMaterial,\n\tLoader,\n\tLoaderUtils,\n\tMathUtils,\n\tMatrix3,\n\tMatrix4,\n\tMesh,\n\tMeshLambertMaterial,\n\tMeshPhongMaterial,\n\tNumberKeyframeTrack,\n\tObject3D,\n\tOrthographicCamera,\n\tPerspectiveCamera,\n\tPointLight,\n\tPropertyBinding,\n\tQuaternion,\n\tQuaternionKeyframeTrack,\n\tRepeatWrapping,\n\tSkeleton,\n\tSkinnedMesh,\n\tSpotLight,\n\tTexture,\n\tTextureLoader,\n\tUint16BufferAttribute,\n\tVector2,\n\tVector3,\n\tVector4,\n\tVectorKeyframeTrack,\n\tSRGBColorSpace,\n\tShapeUtils\n} from 'three';\nimport * as fflate from '../libs/fflate.module.js';\nimport { NURBSCurve } from '../curves/NURBSCurve.js';\n\n/**\n * Loader loads FBX file and generates Group representing FBX scene.\n * Requires FBX file to be >= 7.0 and in ASCII or >= 6400 in Binary format\n * Versions lower than this may load but will probably have errors\n *\n * Needs Support:\n * Morph normals / blend shape normals\n *\n * FBX format references:\n * \thttps://help.autodesk.com/view/FBX/2017/ENU/?guid=__cpp_ref_index_html (C++ SDK reference)\n *\n * Binary format specification:\n *\thttps://code.blender.org/2013/08/fbx-binary-file-format-specification/\n */\n\n\nlet fbxTree;\nlet connections;\nlet sceneGraph;\n\nclass FBXLoader extends Loader {\n\n\tconstructor( manager ) {\n\n\t\tsuper( manager );\n\n\t}\n\n\tload( url, onLoad, onProgress, onError ) {\n\n\t\tconst scope = this;\n\n\t\tconst path = ( scope.path === '' ) ? LoaderUtils.extractUrlBase( url ) : scope.path;\n\n\t\tconst loader = new FileLoader( this.manager );\n\t\tloader.setPath( scope.path );\n\t\tloader.setResponseType( 'arraybuffer' );\n\t\tloader.setRequestHeader( scope.requestHeader );\n\t\tloader.setWithCredentials( scope.withCredentials );\n\n\t\tloader.load( url, function ( buffer ) {\n\n\t\t\ttry {\n\n\t\t\t\tonLoad( scope.parse( buffer, path ) );\n\n\t\t\t} catch ( e ) {\n\n\t\t\t\tif ( onError ) {\n\n\t\t\t\t\tonError( e );\n\n\t\t\t\t} else {\n\n\t\t\t\t\tconsole.error( e );\n\n\t\t\t\t}\n\n\t\t\t\tscope.manager.itemError( url );\n\n\t\t\t}\n\n\t\t}, onProgress, onError );\n\n\t}\n\n\tparse( FBXBuffer, path ) {\n\n\t\tif ( isFbxFormatBinary( FBXBuffer ) ) {\n\n\t\t\tfbxTree = new BinaryParser().parse( FBXBuffer );\n\n\t\t} else {\n\n\t\t\tconst FBXText = convertArrayBufferToString( FBXBuffer );\n\n\t\t\tif ( ! isFbxFormatASCII( FBXText ) ) {\n\n\t\t\t\tthrow new Error( 'THREE.FBXLoader: Unknown format.' );\n\n\t\t\t}\n\n\t\t\tif ( getFbxVersion( FBXText ) < 7000 ) {\n\n\t\t\t\tthrow new Error( 'THREE.FBXLoader: FBX version not supported, FileVersion: ' + getFbxVersion( FBXText ) );\n\n\t\t\t}\n\n\t\t\tfbxTree = new TextParser().parse( FBXText );\n\n\t\t}\n\n\t\t// console.log( fbxTree );\n\n\t\tconst textureLoader = new TextureLoader( this.manager ).setPath( this.resourcePath || path ).setCrossOrigin( this.crossOrigin );\n\n\t\treturn new FBXTreeParser( textureLoader, this.manager ).parse( fbxTree );\n\n\t}\n\n}\n\n// Parse the FBXTree object returned by the BinaryParser or TextParser and return a Group\nclass FBXTreeParser {\n\n\tconstructor( textureLoader, manager ) {\n\n\t\tthis.textureLoader = textureLoader;\n\t\tthis.manager = manager;\n\n\t}\n\n\tparse() {\n\n\t\tconnections = this.parseConnections();\n\n\t\tconst images = this.parseImages();\n\t\tconst textures = this.parseTextures( images );\n\t\tconst materials = this.parseMaterials( textures );\n\t\tconst deformers = this.parseDeformers();\n\t\tconst geometryMap = new GeometryParser().parse( deformers );\n\n\t\tthis.parseScene( deformers, geometryMap, materials );\n\n\t\treturn sceneGraph;\n\n\t}\n\n\t// Parses FBXTree.Connections which holds parent-child connections between objects (e.g. material -> texture, model->geometry )\n\t// and details the connection type\n\tparseConnections() {\n\n\t\tconst connectionMap = new Map();\n\n\t\tif ( 'Connections' in fbxTree ) {\n\n\t\t\tconst rawConnections = fbxTree.Connections.connections;\n\n\t\t\trawConnections.forEach( function ( rawConnection ) {\n\n\t\t\t\tconst fromID = rawConnection[ 0 ];\n\t\t\t\tconst toID = rawConnection[ 1 ];\n\t\t\t\tconst relationship = rawConnection[ 2 ];\n\n\t\t\t\tif ( ! connectionMap.has( fromID ) ) {\n\n\t\t\t\t\tconnectionMap.set( fromID, {\n\t\t\t\t\t\tparents: [],\n\t\t\t\t\t\tchildren: []\n\t\t\t\t\t} );\n\n\t\t\t\t}\n\n\t\t\t\tconst parentRelationship = { ID: toID, relationship: relationship };\n\t\t\t\tconnectionMap.get( fromID ).parents.push( parentRelationship );\n\n\t\t\t\tif ( ! connectionMap.has( toID ) ) {\n\n\t\t\t\t\tconnectionMap.set( toID, {\n\t\t\t\t\t\tparents: [],\n\t\t\t\t\t\tchildren: []\n\t\t\t\t\t} );\n\n\t\t\t\t}\n\n\t\t\t\tconst childRelationship = { ID: fromID, relationship: relationship };\n\t\t\t\tconnectionMap.get( toID ).children.push( childRelationship );\n\n\t\t\t} );\n\n\t\t}\n\n\t\treturn connectionMap;\n\n\t}\n\n\t// Parse FBXTree.Objects.Video for embedded image data\n\t// These images are connected to textures in FBXTree.Objects.Textures\n\t// via FBXTree.Connections.\n\tparseImages() {\n\n\t\tconst images = {};\n\t\tconst blobs = {};\n\n\t\tif ( 'Video' in fbxTree.Objects ) {\n\n\t\t\tconst videoNodes = fbxTree.Objects.Video;\n\n\t\t\tfor ( const nodeID in videoNodes ) {\n\n\t\t\t\tconst videoNode = videoNodes[ nodeID ];\n\n\t\t\t\tconst id = parseInt( nodeID );\n\n\t\t\t\timages[ id ] = videoNode.RelativeFilename || videoNode.Filename;\n\n\t\t\t\t// raw image data is in videoNode.Content\n\t\t\t\tif ( 'Content' in videoNode ) {\n\n\t\t\t\t\tconst arrayBufferContent = ( videoNode.Content instanceof ArrayBuffer ) && ( videoNode.Content.byteLength > 0 );\n\t\t\t\t\tconst base64Content = ( typeof videoNode.Content === 'string' ) && ( videoNode.Content !== '' );\n\n\t\t\t\t\tif ( arrayBufferContent || base64Content ) {\n\n\t\t\t\t\t\tconst image = this.parseImage( videoNodes[ nodeID ] );\n\n\t\t\t\t\t\tblobs[ videoNode.RelativeFilename || videoNode.Filename ] = image;\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t\tfor ( const id in images ) {\n\n\t\t\tconst filename = images[ id ];\n\n\t\t\tif ( blobs[ filename ] !== undefined ) images[ id ] = blobs[ filename ];\n\t\t\telse images[ id ] = images[ id ].split( '\\\\' ).pop();\n\n\t\t}\n\n\t\treturn images;\n\n\t}\n\n\t// Parse embedded image data in FBXTree.Video.Content\n\tparseImage( videoNode ) {\n\n\t\tconst content = videoNode.Content;\n\t\tconst fileName = videoNode.RelativeFilename || videoNode.Filename;\n\t\tconst extension = fileName.slice( fileName.lastIndexOf( '.' ) + 1 ).toLowerCase();\n\n\t\tlet type;\n\n\t\tswitch ( extension ) {\n\n\t\t\tcase 'bmp':\n\n\t\t\t\ttype = 'image/bmp';\n\t\t\t\tbreak;\n\n\t\t\tcase 'jpg':\n\t\t\tcase 'jpeg':\n\n\t\t\t\ttype = 'image/jpeg';\n\t\t\t\tbreak;\n\n\t\t\tcase 'png':\n\n\t\t\t\ttype = 'image/png';\n\t\t\t\tbreak;\n\n\t\t\tcase 'tif':\n\n\t\t\t\ttype = 'image/tiff';\n\t\t\t\tbreak;\n\n\t\t\tcase 'tga':\n\n\t\t\t\tif ( this.manager.getHandler( '.tga' ) === null ) {\n\n\t\t\t\t\tconsole.warn( 'FBXLoader: TGA loader not found, skipping ', fileName );\n\n\t\t\t\t}\n\n\t\t\t\ttype = 'image/tga';\n\t\t\t\tbreak;\n\n\t\t\tdefault:\n\n\t\t\t\tconsole.warn( 'FBXLoader: Image type \"' + extension + '\" is not supported.' );\n\t\t\t\treturn;\n\n\t\t}\n\n\t\tif ( typeof content === 'string' ) { // ASCII format\n\n\t\t\treturn 'data:' + type + ';base64,' + content;\n\n\t\t} else { // Binary Format\n\n\t\t\tconst array = new Uint8Array( content );\n\t\t\treturn window.URL.createObjectURL( new Blob( [ array ], { type: type } ) );\n\n\t\t}\n\n\t}\n\n\t// Parse nodes in FBXTree.Objects.Texture\n\t// These contain details such as UV scaling, cropping, rotation etc and are connected\n\t// to images in FBXTree.Objects.Video\n\tparseTextures( images ) {\n\n\t\tconst textureMap = new Map();\n\n\t\tif ( 'Texture' in fbxTree.Objects ) {\n\n\t\t\tconst textureNodes = fbxTree.Objects.Texture;\n\t\t\tfor ( const nodeID in textureNodes ) {\n\n\t\t\t\tconst texture = this.parseTexture( textureNodes[ nodeID ], images );\n\t\t\t\ttextureMap.set( parseInt( nodeID ), texture );\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn textureMap;\n\n\t}\n\n\t// Parse individual node in FBXTree.Objects.Texture\n\tparseTexture( textureNode, images ) {\n\n\t\tconst texture = this.loadTexture( textureNode, images );\n\n\t\ttexture.ID = textureNode.id;\n\n\t\ttexture.name = textureNode.attrName;\n\n\t\tconst wrapModeU = textureNode.WrapModeU;\n\t\tconst wrapModeV = textureNode.WrapModeV;\n\n\t\tconst valueU = wrapModeU !== undefined ? wrapModeU.value : 0;\n\t\tconst valueV = wrapModeV !== undefined ? wrapModeV.value : 0;\n\n\t\t// http://download.autodesk.com/us/fbx/SDKdocs/FBX_SDK_Help/files/fbxsdkref/class_k_fbx_texture.html#889640e63e2e681259ea81061b85143a\n\t\t// 0: repeat(default), 1: clamp\n\n\t\ttexture.wrapS = valueU === 0 ? RepeatWrapping : ClampToEdgeWrapping;\n\t\ttexture.wrapT = valueV === 0 ? RepeatWrapping : ClampToEdgeWrapping;\n\n\t\tif ( 'Scaling' in textureNode ) {\n\n\t\t\tconst values = textureNode.Scaling.value;\n\n\t\t\ttexture.repeat.x = values[ 0 ];\n\t\t\ttexture.repeat.y = values[ 1 ];\n\n\t\t}\n\n\t\tif ( 'Translation' in textureNode ) {\n\n\t\t\tconst values = textureNode.Translation.value;\n\n\t\t\ttexture.offset.x = values[ 0 ];\n\t\t\ttexture.offset.y = values[ 1 ];\n\n\t\t}\n\n\t\treturn texture;\n\n\t}\n\n\t// load a texture specified as a blob or data URI, or via an external URL using TextureLoader\n\tloadTexture( textureNode, images ) {\n\n\t\tlet fileName;\n\n\t\tconst currentPath = this.textureLoader.path;\n\n\t\tconst children = connections.get( textureNode.id ).children;\n\n\t\tif ( children !== undefined && children.length > 0 && images[ children[ 0 ].ID ] !== undefined ) {\n\n\t\t\tfileName = images[ children[ 0 ].ID ];\n\n\t\t\tif ( fileName.indexOf( 'blob:' ) === 0 || fileName.indexOf( 'data:' ) === 0 ) {\n\n\t\t\t\tthis.textureLoader.setPath( undefined );\n\n\t\t\t}\n\n\t\t}\n\n\t\tlet texture;\n\n\t\tconst extension = textureNode.FileName.slice( - 3 ).toLowerCase();\n\n\t\tif ( extension === 'tga' ) {\n\n\t\t\tconst loader = this.manager.getHandler( '.tga' );\n\n\t\t\tif ( loader === null ) {\n\n\t\t\t\tconsole.warn( 'FBXLoader: TGA loader not found, creating placeholder texture for', textureNode.RelativeFilename );\n\t\t\t\ttexture = new Texture();\n\n\t\t\t} else {\n\n\t\t\t\tloader.setPath( this.textureLoader.path );\n\t\t\t\ttexture = loader.load( fileName );\n\n\t\t\t}\n\n\t\t} else if ( extension === 'dds' ) {\n\n\t\t\tconst loader = this.manager.getHandler( '.dds' );\n\n\t\t\tif ( loader === null ) {\n\n\t\t\t\tconsole.warn( 'FBXLoader: DDS loader not found, creating placeholder texture for', textureNode.RelativeFilename );\n\t\t\t\ttexture = new Texture();\n\n\t\t\t} else {\n\n\t\t\t\tloader.setPath( this.textureLoader.path );\n\t\t\t\ttexture = loader.load( fileName );\n\n\t\t\t}\n\n\t\t} else if ( extension === 'psd' ) {\n\n\t\t\tconsole.warn( 'FBXLoader: PSD textures are not supported, creating placeholder texture for', textureNode.RelativeFilename );\n\t\t\ttexture = new Texture();\n\n\t\t} else {\n\n\t\t\ttexture = this.textureLoader.load( fileName );\n\n\t\t}\n\n\t\tthis.textureLoader.setPath( currentPath );\n\n\t\treturn texture;\n\n\t}\n\n\t// Parse nodes in FBXTree.Objects.Material\n\tparseMaterials( textureMap ) {\n\n\t\tconst materialMap = new Map();\n\n\t\tif ( 'Material' in fbxTree.Objects ) {\n\n\t\t\tconst materialNodes = fbxTree.Objects.Material;\n\n\t\t\tfor ( const nodeID in materialNodes ) {\n\n\t\t\t\tconst material = this.parseMaterial( materialNodes[ nodeID ], textureMap );\n\n\t\t\t\tif ( material !== null ) materialMap.set( parseInt( nodeID ), material );\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn materialMap;\n\n\t}\n\n\t// Parse single node in FBXTree.Objects.Material\n\t// Materials are connected to texture maps in FBXTree.Objects.Textures\n\t// FBX format currently only supports Lambert and Phong shading models\n\tparseMaterial( materialNode, textureMap ) {\n\n\t\tconst ID = materialNode.id;\n\t\tconst name = materialNode.attrName;\n\t\tlet type = materialNode.ShadingModel;\n\n\t\t// Case where FBX wraps shading model in property object.\n\t\tif ( typeof type === 'object' ) {\n\n\t\t\ttype = type.value;\n\n\t\t}\n\n\t\t// Ignore unused materials which don't have any connections.\n\t\tif ( ! connections.has( ID ) ) return null;\n\n\t\tconst parameters = this.parseParameters( materialNode, textureMap, ID );\n\n\t\tlet material;\n\n\t\tswitch ( type.toLowerCase() ) {\n\n\t\t\tcase 'phong':\n\t\t\t\tmaterial = new MeshPhongMaterial();\n\t\t\t\tbreak;\n\t\t\tcase 'lambert':\n\t\t\t\tmaterial = new MeshLambertMaterial();\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\tconsole.warn( 'THREE.FBXLoader: unknown material type \"%s\". Defaulting to MeshPhongMaterial.', type );\n\t\t\t\tmaterial = new MeshPhongMaterial();\n\t\t\t\tbreak;\n\n\t\t}\n\n\t\tmaterial.setValues( parameters );\n\t\tmaterial.name = name;\n\n\t\treturn material;\n\n\t}\n\n\t// Parse FBX material and return parameters suitable for a three.js material\n\t// Also parse the texture map and return any textures associated with the material\n\tparseParameters( materialNode, textureMap, ID ) {\n\n\t\tconst parameters = {};\n\n\t\tif ( materialNode.BumpFactor ) {\n\n\t\t\tparameters.bumpScale = materialNode.BumpFactor.value;\n\n\t\t}\n\n\t\tif ( materialNode.Diffuse ) {\n\n\t\t\tparameters.color = new Color().fromArray( materialNode.Diffuse.value ).convertSRGBToLinear();\n\n\t\t} else if ( materialNode.DiffuseColor && ( materialNode.DiffuseColor.type === 'Color' || materialNode.DiffuseColor.type === 'ColorRGB' ) ) {\n\n\t\t\t// The blender exporter exports diffuse here instead of in materialNode.Diffuse\n\t\t\tparameters.color = new Color().fromArray( materialNode.DiffuseColor.value ).convertSRGBToLinear();\n\n\t\t}\n\n\t\tif ( materialNode.DisplacementFactor ) {\n\n\t\t\tparameters.displacementScale = materialNode.DisplacementFactor.value;\n\n\t\t}\n\n\t\tif ( materialNode.Emissive ) {\n\n\t\t\tparameters.emissive = new Color().fromArray( materialNode.Emissive.value ).convertSRGBToLinear();\n\n\t\t} else if ( materialNode.EmissiveColor && ( materialNode.EmissiveColor.type === 'Color' || materialNode.EmissiveColor.type === 'ColorRGB' ) ) {\n\n\t\t\t// The blender exporter exports emissive color here instead of in materialNode.Emissive\n\t\t\tparameters.emissive = new Color().fromArray( materialNode.EmissiveColor.value ).convertSRGBToLinear();\n\n\t\t}\n\n\t\tif ( materialNode.EmissiveFactor ) {\n\n\t\t\tparameters.emissiveIntensity = parseFloat( materialNode.EmissiveFactor.value );\n\n\t\t}\n\n\t\tif ( materialNode.Opacity ) {\n\n\t\t\tparameters.opacity = parseFloat( materialNode.Opacity.value );\n\n\t\t}\n\n\t\tif ( parameters.opacity < 1.0 ) {\n\n\t\t\tparameters.transparent = true;\n\n\t\t}\n\n\t\tif ( materialNode.ReflectionFactor ) {\n\n\t\t\tparameters.reflectivity = materialNode.ReflectionFactor.value;\n\n\t\t}\n\n\t\tif ( materialNode.Shininess ) {\n\n\t\t\tparameters.shininess = materialNode.Shininess.value;\n\n\t\t}\n\n\t\tif ( materialNode.Specular ) {\n\n\t\t\tparameters.specular = new Color().fromArray( materialNode.Specular.value ).convertSRGBToLinear();\n\n\t\t} else if ( materialNode.SpecularColor && materialNode.SpecularColor.type === 'Color' ) {\n\n\t\t\t// The blender exporter exports specular color here instead of in materialNode.Specular\n\t\t\tparameters.specular = new Color().fromArray( materialNode.SpecularColor.value ).convertSRGBToLinear();\n\n\t\t}\n\n\t\tconst scope = this;\n\t\tconnections.get( ID ).children.forEach( function ( child ) {\n\n\t\t\tconst type = child.relationship;\n\n\t\t\tswitch ( type ) {\n\n\t\t\t\tcase 'Bump':\n\t\t\t\t\tparameters.bumpMap = scope.getTexture( textureMap, child.ID );\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase 'Maya|TEX_ao_map':\n\t\t\t\t\tparameters.aoMap = scope.getTexture( textureMap, child.ID );\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase 'DiffuseColor':\n\t\t\t\tcase 'Maya|TEX_color_map':\n\t\t\t\t\tparameters.map = scope.getTexture( textureMap, child.ID );\n\t\t\t\t\tif ( parameters.map !== undefined ) {\n\n\t\t\t\t\t\tparameters.map.colorSpace = SRGBColorSpace;\n\n\t\t\t\t\t}\n\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase 'DisplacementColor':\n\t\t\t\t\tparameters.displacementMap = scope.getTexture( textureMap, child.ID );\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase 'EmissiveColor':\n\t\t\t\t\tparameters.emissiveMap = scope.getTexture( textureMap, child.ID );\n\t\t\t\t\tif ( parameters.emissiveMap !== undefined ) {\n\n\t\t\t\t\t\tparameters.emissiveMap.colorSpace = SRGBColorSpace;\n\n\t\t\t\t\t}\n\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase 'NormalMap':\n\t\t\t\tcase 'Maya|TEX_normal_map':\n\t\t\t\t\tparameters.normalMap = scope.getTexture( textureMap, child.ID );\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase 'ReflectionColor':\n\t\t\t\t\tparameters.envMap = scope.getTexture( textureMap, child.ID );\n\t\t\t\t\tif ( parameters.envMap !== undefined ) {\n\n\t\t\t\t\t\tparameters.envMap.mapping = EquirectangularReflectionMapping;\n\t\t\t\t\t\tparameters.envMap.colorSpace = SRGBColorSpace;\n\n\t\t\t\t\t}\n\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase 'SpecularColor':\n\t\t\t\t\tparameters.specularMap = scope.getTexture( textureMap, child.ID );\n\t\t\t\t\tif ( parameters.specularMap !== undefined ) {\n\n\t\t\t\t\t\tparameters.specularMap.colorSpace = SRGBColorSpace;\n\n\t\t\t\t\t}\n\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase 'TransparentColor':\n\t\t\t\tcase 'TransparencyFactor':\n\t\t\t\t\tparameters.alphaMap = scope.getTexture( textureMap, child.ID );\n\t\t\t\t\tparameters.transparent = true;\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase 'AmbientColor':\n\t\t\t\tcase 'ShininessExponent': // AKA glossiness map\n\t\t\t\tcase 'SpecularFactor': // AKA specularLevel\n\t\t\t\tcase 'VectorDisplacementColor': // NOTE: Seems to be a copy of DisplacementColor\n\t\t\t\tdefault:\n\t\t\t\t\tconsole.warn( 'THREE.FBXLoader: %s map is not supported in three.js, skipping texture.', type );\n\t\t\t\t\tbreak;\n\n\t\t\t}\n\n\t\t} );\n\n\t\treturn parameters;\n\n\t}\n\n\t// get a texture from the textureMap for use by a material.\n\tgetTexture( textureMap, id ) {\n\n\t\t// if the texture is a layered texture, just use the first layer and issue a warning\n\t\tif ( 'LayeredTexture' in fbxTree.Objects && id in fbxTree.Objects.LayeredTexture ) {\n\n\t\t\tconsole.warn( 'THREE.FBXLoader: layered textures are not supported in three.js. Discarding all but first layer.' );\n\t\t\tid = connections.get( id ).children[ 0 ].ID;\n\n\t\t}\n\n\t\treturn textureMap.get( id );\n\n\t}\n\n\t// Parse nodes in FBXTree.Objects.Deformer\n\t// Deformer node can contain skinning or Vertex Cache animation data, however only skinning is supported here\n\t// Generates map of Skeleton-like objects for use later when generating and binding skeletons.\n\tparseDeformers() {\n\n\t\tconst skeletons = {};\n\t\tconst morphTargets = {};\n\n\t\tif ( 'Deformer' in fbxTree.Objects ) {\n\n\t\t\tconst DeformerNodes = fbxTree.Objects.Deformer;\n\n\t\t\tfor ( const nodeID in DeformerNodes ) {\n\n\t\t\t\tconst deformerNode = DeformerNodes[ nodeID ];\n\n\t\t\t\tconst relationships = connections.get( parseInt( nodeID ) );\n\n\t\t\t\tif ( deformerNode.attrType === 'Skin' ) {\n\n\t\t\t\t\tconst skeleton = this.parseSkeleton( relationships, DeformerNodes );\n\t\t\t\t\tskeleton.ID = nodeID;\n\n\t\t\t\t\tif ( relationships.parents.length > 1 ) console.warn( 'THREE.FBXLoader: skeleton attached to more than one geometry is not supported.' );\n\t\t\t\t\tskeleton.geometryID = relationships.parents[ 0 ].ID;\n\n\t\t\t\t\tskeletons[ nodeID ] = skeleton;\n\n\t\t\t\t} else if ( deformerNode.attrType === 'BlendShape' ) {\n\n\t\t\t\t\tconst morphTarget = {\n\t\t\t\t\t\tid: nodeID,\n\t\t\t\t\t};\n\n\t\t\t\t\tmorphTarget.rawTargets = this.parseMorphTargets( relationships, DeformerNodes );\n\t\t\t\t\tmorphTarget.id = nodeID;\n\n\t\t\t\t\tif ( relationships.parents.length > 1 ) console.warn( 'THREE.FBXLoader: morph target attached to more than one geometry is not supported.' );\n\n\t\t\t\t\tmorphTargets[ nodeID ] = morphTarget;\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn {\n\n\t\t\tskeletons: skeletons,\n\t\t\tmorphTargets: morphTargets,\n\n\t\t};\n\n\t}\n\n\t// Parse single nodes in FBXTree.Objects.Deformer\n\t// The top level skeleton node has type 'Skin' and sub nodes have type 'Cluster'\n\t// Each skin node represents a skeleton and each cluster node represents a bone\n\tparseSkeleton( relationships, deformerNodes ) {\n\n\t\tconst rawBones = [];\n\n\t\trelationships.children.forEach( function ( child ) {\n\n\t\t\tconst boneNode = deformerNodes[ child.ID ];\n\n\t\t\tif ( boneNode.attrType !== 'Cluster' ) return;\n\n\t\t\tconst rawBone = {\n\n\t\t\t\tID: child.ID,\n\t\t\t\tindices: [],\n\t\t\t\tweights: [],\n\t\t\t\ttransformLink: new Matrix4().fromArray( boneNode.TransformLink.a ),\n\t\t\t\t// transform: new Matrix4().fromArray( boneNode.Transform.a ),\n\t\t\t\t// linkMode: boneNode.Mode,\n\n\t\t\t};\n\n\t\t\tif ( 'Indexes' in boneNode ) {\n\n\t\t\t\trawBone.indices = boneNode.Indexes.a;\n\t\t\t\trawBone.weights = boneNode.Weights.a;\n\n\t\t\t}\n\n\t\t\trawBones.push( rawBone );\n\n\t\t} );\n\n\t\treturn {\n\n\t\t\trawBones: rawBones,\n\t\t\tbones: []\n\n\t\t};\n\n\t}\n\n\t// The top level morph deformer node has type \"BlendShape\" and sub nodes have type \"BlendShapeChannel\"\n\tparseMorphTargets( relationships, deformerNodes ) {\n\n\t\tconst rawMorphTargets = [];\n\n\t\tfor ( let i = 0; i < relationships.children.length; i ++ ) {\n\n\t\t\tconst child = relationships.children[ i ];\n\n\t\t\tconst morphTargetNode = deformerNodes[ child.ID ];\n\n\t\t\tconst rawMorphTarget = {\n\n\t\t\t\tname: morphTargetNode.attrName,\n\t\t\t\tinitialWeight: morphTargetNode.DeformPercent,\n\t\t\t\tid: morphTargetNode.id,\n\t\t\t\tfullWeights: morphTargetNode.FullWeights.a\n\n\t\t\t};\n\n\t\t\tif ( morphTargetNode.attrType !== 'BlendShapeChannel' ) return;\n\n\t\t\trawMorphTarget.geoID = connections.get( parseInt( child.ID ) ).children.filter( function ( child ) {\n\n\t\t\t\treturn child.relationship === undefined;\n\n\t\t\t} )[ 0 ].ID;\n\n\t\t\trawMorphTargets.push( rawMorphTarget );\n\n\t\t}\n\n\t\treturn rawMorphTargets;\n\n\t}\n\n\t// create the main Group() to be returned by the loader\n\tparseScene( deformers, geometryMap, materialMap ) {\n\n\t\tsceneGraph = new Group();\n\n\t\tconst modelMap = this.parseModels( deformers.skeletons, geometryMap, materialMap );\n\n\t\tconst modelNodes = fbxTree.Objects.Model;\n\n\t\tconst scope = this;\n\t\tmodelMap.forEach( function ( model ) {\n\n\t\t\tconst modelNode = modelNodes[ model.ID ];\n\t\t\tscope.setLookAtProperties( model, modelNode );\n\n\t\t\tconst parentConnections = connections.get( model.ID ).parents;\n\n\t\t\tparentConnections.forEach( function ( connection ) {\n\n\t\t\t\tconst parent = modelMap.get( connection.ID );\n\t\t\t\tif ( parent !== undefined ) parent.add( model );\n\n\t\t\t} );\n\n\t\t\tif ( model.parent === null ) {\n\n\t\t\t\tsceneGraph.add( model );\n\n\t\t\t}\n\n\n\t\t} );\n\n\t\tthis.bindSkeleton( deformers.skeletons, geometryMap, modelMap );\n\n\t\tthis.addGlobalSceneSettings();\n\n\t\tsceneGraph.traverse( function ( node ) {\n\n\t\t\tif ( node.userData.transformData ) {\n\n\t\t\t\tif ( node.parent ) {\n\n\t\t\t\t\tnode.userData.transformData.parentMatrix = node.parent.matrix;\n\t\t\t\t\tnode.userData.transformData.parentMatrixWorld = node.parent.matrixWorld;\n\n\t\t\t\t}\n\n\t\t\t\tconst transform = generateTransform( node.userData.transformData );\n\n\t\t\t\tnode.applyMatrix4( transform );\n\t\t\t\tnode.updateWorldMatrix();\n\n\t\t\t}\n\n\t\t} );\n\n\t\tconst animations = new AnimationParser().parse();\n\n\t\t// if all the models where already combined in a single group, just return that\n\t\tif ( sceneGraph.children.length === 1 && sceneGraph.children[ 0 ].isGroup ) {\n\n\t\t\tsceneGraph.children[ 0 ].animations = animations;\n\t\t\tsceneGraph = sceneGraph.children[ 0 ];\n\n\t\t}\n\n\t\tsceneGraph.animations = animations;\n\n\t}\n\n\t// parse nodes in FBXTree.Objects.Model\n\tparseModels( skeletons, geometryMap, materialMap ) {\n\n\t\tconst modelMap = new Map();\n\t\tconst modelNodes = fbxTree.Objects.Model;\n\n\t\tfor ( const nodeID in modelNodes ) {\n\n\t\t\tconst id = parseInt( nodeID );\n\t\t\tconst node = modelNodes[ nodeID ];\n\t\t\tconst relationships = connections.get( id );\n\n\t\t\tlet model = this.buildSkeleton( relationships, skeletons, id, node.attrName );\n\n\t\t\tif ( ! model ) {\n\n\t\t\t\tswitch ( node.attrType ) {\n\n\t\t\t\t\tcase 'Camera':\n\t\t\t\t\t\tmodel = this.createCamera( relationships );\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase 'Light':\n\t\t\t\t\t\tmodel = this.createLight( relationships );\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase 'Mesh':\n\t\t\t\t\t\tmodel = this.createMesh( relationships, geometryMap, materialMap );\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase 'NurbsCurve':\n\t\t\t\t\t\tmodel = this.createCurve( relationships, geometryMap );\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase 'LimbNode':\n\t\t\t\t\tcase 'Root':\n\t\t\t\t\t\tmodel = new Bone();\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase 'Null':\n\t\t\t\t\tdefault:\n\t\t\t\t\t\tmodel = new Group();\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t}\n\n\t\t\t\tmodel.name = node.attrName ? PropertyBinding.sanitizeNodeName( node.attrName ) : '';\n\t\t\t\tmodel.userData.originalName = node.attrName;\n\n\t\t\t\tmodel.ID = id;\n\n\t\t\t}\n\n\t\t\tthis.getTransformData( model, node );\n\t\t\tmodelMap.set( id, model );\n\n\t\t}\n\n\t\treturn modelMap;\n\n\t}\n\n\tbuildSkeleton( relationships, skeletons, id, name ) {\n\n\t\tlet bone = null;\n\n\t\trelationships.parents.forEach( function ( parent ) {\n\n\t\t\tfor ( const ID in skeletons ) {\n\n\t\t\t\tconst skeleton = skeletons[ ID ];\n\n\t\t\t\tskeleton.rawBones.forEach( function ( rawBone, i ) {\n\n\t\t\t\t\tif ( rawBone.ID === parent.ID ) {\n\n\t\t\t\t\t\tconst subBone = bone;\n\t\t\t\t\t\tbone = new Bone();\n\n\t\t\t\t\t\tbone.matrixWorld.copy( rawBone.transformLink );\n\n\t\t\t\t\t\t// set name and id here - otherwise in cases where \"subBone\" is created it will not have a name / id\n\n\t\t\t\t\t\tbone.name = name ? PropertyBinding.sanitizeNodeName( name ) : '';\n\t\t\t\t\t\tbone.userData.originalName = name;\n\t\t\t\t\t\tbone.ID = id;\n\n\t\t\t\t\t\tskeleton.bones[ i ] = bone;\n\n\t\t\t\t\t\t// In cases where a bone is shared between multiple meshes\n\t\t\t\t\t\t// duplicate the bone here and and it as a child of the first bone\n\t\t\t\t\t\tif ( subBone !== null ) {\n\n\t\t\t\t\t\t\tbone.add( subBone );\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}\n\n\t\t\t\t} );\n\n\t\t\t}\n\n\t\t} );\n\n\t\treturn bone;\n\n\t}\n\n\t// create a PerspectiveCamera or OrthographicCamera\n\tcreateCamera( relationships ) {\n\n\t\tlet model;\n\t\tlet cameraAttribute;\n\n\t\trelationships.children.forEach( function ( child ) {\n\n\t\t\tconst attr = fbxTree.Objects.NodeAttribute[ child.ID ];\n\n\t\t\tif ( attr !== undefined ) {\n\n\t\t\t\tcameraAttribute = attr;\n\n\t\t\t}\n\n\t\t} );\n\n\t\tif ( cameraAttribute === undefined ) {\n\n\t\t\tmodel = new Object3D();\n\n\t\t} else {\n\n\t\t\tlet type = 0;\n\t\t\tif ( cameraAttribute.CameraProjectionType !== undefined && cameraAttribute.CameraProjectionType.value === 1 ) {\n\n\t\t\t\ttype = 1;\n\n\t\t\t}\n\n\t\t\tlet nearClippingPlane = 1;\n\t\t\tif ( cameraAttribute.NearPlane !== undefined ) {\n\n\t\t\t\tnearClippingPlane = cameraAttribute.NearPlane.value / 1000;\n\n\t\t\t}\n\n\t\t\tlet farClippingPlane = 1000;\n\t\t\tif ( cameraAttribute.FarPlane !== undefined ) {\n\n\t\t\t\tfarClippingPlane = cameraAttribute.FarPlane.value / 1000;\n\n\t\t\t}\n\n\n\t\t\tlet width = window.innerWidth;\n\t\t\tlet height = window.innerHeight;\n\n\t\t\tif ( cameraAttribute.AspectWidth !== undefined && cameraAttribute.AspectHeight !== undefined ) {\n\n\t\t\t\twidth = cameraAttribute.AspectWidth.value;\n\t\t\t\theight = cameraAttribute.AspectHeight.value;\n\n\t\t\t}\n\n\t\t\tconst aspect = width / height;\n\n\t\t\tlet fov = 45;\n\t\t\tif ( cameraAttribute.FieldOfView !== undefined ) {\n\n\t\t\t\tfov = cameraAttribute.FieldOfView.value;\n\n\t\t\t}\n\n\t\t\tconst focalLength = cameraAttribute.FocalLength ? cameraAttribute.FocalLength.value : null;\n\n\t\t\tswitch ( type ) {\n\n\t\t\t\tcase 0: // Perspective\n\t\t\t\t\tmodel = new PerspectiveCamera( fov, aspect, nearClippingPlane, farClippingPlane );\n\t\t\t\t\tif ( focalLength !== null ) model.setFocalLength( focalLength );\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase 1: // Orthographic\n\t\t\t\t\tmodel = new OrthographicCamera( - width / 2, width / 2, height / 2, - height / 2, nearClippingPlane, farClippingPlane );\n\t\t\t\t\tbreak;\n\n\t\t\t\tdefault:\n\t\t\t\t\tconsole.warn( 'THREE.FBXLoader: Unknown camera type ' + type + '.' );\n\t\t\t\t\tmodel = new Object3D();\n\t\t\t\t\tbreak;\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn model;\n\n\t}\n\n\t// Create a DirectionalLight, PointLight or SpotLight\n\tcreateLight( relationships ) {\n\n\t\tlet model;\n\t\tlet lightAttribute;\n\n\t\trelationships.children.forEach( function ( child ) {\n\n\t\t\tconst attr = fbxTree.Objects.NodeAttribute[ child.ID ];\n\n\t\t\tif ( attr !== undefined ) {\n\n\t\t\t\tlightAttribute = attr;\n\n\t\t\t}\n\n\t\t} );\n\n\t\tif ( lightAttribute === undefined ) {\n\n\t\t\tmodel = new Object3D();\n\n\t\t} else {\n\n\t\t\tlet type;\n\n\t\t\t// LightType can be undefined for Point lights\n\t\t\tif ( lightAttribute.LightType === undefined ) {\n\n\t\t\t\ttype = 0;\n\n\t\t\t} else {\n\n\t\t\t\ttype = lightAttribute.LightType.value;\n\n\t\t\t}\n\n\t\t\tlet color = 0xffffff;\n\n\t\t\tif ( lightAttribute.Color !== undefined ) {\n\n\t\t\t\tcolor = new Color().fromArray( lightAttribute.Color.value ).convertSRGBToLinear();\n\n\t\t\t}\n\n\t\t\tlet intensity = ( lightAttribute.Intensity === undefined ) ? 1 : lightAttribute.Intensity.value / 100;\n\n\t\t\t// light disabled\n\t\t\tif ( lightAttribute.CastLightOnObject !== undefined && lightAttribute.CastLightOnObject.value === 0 ) {\n\n\t\t\t\tintensity = 0;\n\n\t\t\t}\n\n\t\t\tlet distance = 0;\n\t\t\tif ( lightAttribute.FarAttenuationEnd !== undefined ) {\n\n\t\t\t\tif ( lightAttribute.EnableFarAttenuation !== undefined && lightAttribute.EnableFarAttenuation.value === 0 ) {\n\n\t\t\t\t\tdistance = 0;\n\n\t\t\t\t} else {\n\n\t\t\t\t\tdistance = lightAttribute.FarAttenuationEnd.value;\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\t// TODO: could this be calculated linearly from FarAttenuationStart to FarAttenuationEnd?\n\t\t\tconst decay = 1;\n\n\t\t\tswitch ( type ) {\n\n\t\t\t\tcase 0: // Point\n\t\t\t\t\tmodel = new PointLight( color, intensity, distance, decay );\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase 1: // Directional\n\t\t\t\t\tmodel = new DirectionalLight( color, intensity );\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase 2: // Spot\n\t\t\t\t\tlet angle = Math.PI / 3;\n\n\t\t\t\t\tif ( lightAttribute.InnerAngle !== undefined ) {\n\n\t\t\t\t\t\tangle = MathUtils.degToRad( lightAttribute.InnerAngle.value );\n\n\t\t\t\t\t}\n\n\t\t\t\t\tlet penumbra = 0;\n\t\t\t\t\tif ( lightAttribute.OuterAngle !== undefined ) {\n\n\t\t\t\t\t\t// TODO: this is not correct - FBX calculates outer and inner angle in degrees\n\t\t\t\t\t\t// with OuterAngle > InnerAngle && OuterAngle <= Math.PI\n\t\t\t\t\t\t// while three.js uses a penumbra between (0, 1) to attenuate the inner angle\n\t\t\t\t\t\tpenumbra = MathUtils.degToRad( lightAttribute.OuterAngle.value );\n\t\t\t\t\t\tpenumbra = Math.max( penumbra, 1 );\n\n\t\t\t\t\t}\n\n\t\t\t\t\tmodel = new SpotLight( color, intensity, distance, angle, penumbra, decay );\n\t\t\t\t\tbreak;\n\n\t\t\t\tdefault:\n\t\t\t\t\tconsole.warn( 'THREE.FBXLoader: Unknown light type ' + lightAttribute.LightType.value + ', defaulting to a PointLight.' );\n\t\t\t\t\tmodel = new PointLight( color, intensity );\n\t\t\t\t\tbreak;\n\n\t\t\t}\n\n\t\t\tif ( lightAttribute.CastShadows !== undefined && lightAttribute.CastShadows.value === 1 ) {\n\n\t\t\t\tmodel.castShadow = true;\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn model;\n\n\t}\n\n\tcreateMesh( relationships, geometryMap, materialMap ) {\n\n\t\tlet model;\n\t\tlet geometry = null;\n\t\tlet material = null;\n\t\tconst materials = [];\n\n\t\t// get geometry and materials(s) from connections\n\t\trelationships.children.forEach( function ( child ) {\n\n\t\t\tif ( geometryMap.has( child.ID ) ) {\n\n\t\t\t\tgeometry = geometryMap.get( child.ID );\n\n\t\t\t}\n\n\t\t\tif ( materialMap.has( child.ID ) ) {\n\n\t\t\t\tmaterials.push( materialMap.get( child.ID ) );\n\n\t\t\t}\n\n\t\t} );\n\n\t\tif ( materials.length > 1 ) {\n\n\t\t\tmaterial = materials;\n\n\t\t} else if ( materials.length > 0 ) {\n\n\t\t\tmaterial = materials[ 0 ];\n\n\t\t} else {\n\n\t\t\tmaterial = new MeshPhongMaterial( {\n\t\t\t\tname: Loader.DEFAULT_MATERIAL_NAME,\n\t\t\t\tcolor: 0xcccccc\n\t\t\t} );\n\t\t\tmaterials.push( material );\n\n\t\t}\n\n\t\tif ( 'color' in geometry.attributes ) {\n\n\t\t\tmaterials.forEach( function ( material ) {\n\n\t\t\t\tmaterial.vertexColors = true;\n\n\t\t\t} );\n\n\t\t}\n\n\t\tif ( geometry.FBX_Deformer ) {\n\n\t\t\tmodel = new SkinnedMesh( geometry, material );\n\t\t\tmodel.normalizeSkinWeights();\n\n\t\t} else {\n\n\t\t\tmodel = new Mesh( geometry, material );\n\n\t\t}\n\n\t\treturn model;\n\n\t}\n\n\tcreateCurve( relationships, geometryMap ) {\n\n\t\tconst geometry = relationships.children.reduce( function ( geo, child ) {\n\n\t\t\tif ( geometryMap.has( child.ID ) ) geo = geometryMap.get( child.ID );\n\n\t\t\treturn geo;\n\n\t\t}, null );\n\n\t\t// FBX does not list materials for Nurbs lines, so we'll just put our own in here.\n\t\tconst material = new LineBasicMaterial( {\n\t\t\tname: Loader.DEFAULT_MATERIAL_NAME,\n\t\t\tcolor: 0x3300ff,\n\t\t\tlinewidth: 1\n\t\t} );\n\t\treturn new Line( geometry, material );\n\n\t}\n\n\t// parse the model node for transform data\n\tgetTransformData( model, modelNode ) {\n\n\t\tconst transformData = {};\n\n\t\tif ( 'InheritType' in modelNode ) transformData.inheritType = parseInt( modelNode.InheritType.value );\n\n\t\tif ( 'RotationOrder' in modelNode ) transformData.eulerOrder = getEulerOrder( modelNode.RotationOrder.value );\n\t\telse transformData.eulerOrder = 'ZYX';\n\n\t\tif ( 'Lcl_Translation' in modelNode ) transformData.translation = modelNode.Lcl_Translation.value;\n\n\t\tif ( 'PreRotation' in modelNode ) transformData.preRotation = modelNode.PreRotation.value;\n\t\tif ( 'Lcl_Rotation' in modelNode ) transformData.rotation = modelNode.Lcl_Rotation.value;\n\t\tif ( 'PostRotation' in modelNode ) transformData.postRotation = modelNode.PostRotation.value;\n\n\t\tif ( 'Lcl_Scaling' in modelNode ) transformData.scale = modelNode.Lcl_Scaling.value;\n\n\t\tif ( 'ScalingOffset' in modelNode ) transformData.scalingOffset = modelNode.ScalingOffset.value;\n\t\tif ( 'ScalingPivot' in modelNode ) transformData.scalingPivot = modelNode.ScalingPivot.value;\n\n\t\tif ( 'RotationOffset' in modelNode ) transformData.rotationOffset = modelNode.RotationOffset.value;\n\t\tif ( 'RotationPivot' in modelNode ) transformData.rotationPivot = modelNode.RotationPivot.value;\n\n\t\tmodel.userData.transformData = transformData;\n\n\t}\n\n\tsetLookAtProperties( model, modelNode ) {\n\n\t\tif ( 'LookAtProperty' in modelNode ) {\n\n\t\t\tconst children = connections.get( model.ID ).children;\n\n\t\t\tchildren.forEach( function ( child ) {\n\n\t\t\t\tif ( child.relationship === 'LookAtProperty' ) {\n\n\t\t\t\t\tconst lookAtTarget = fbxTree.Objects.Model[ child.ID ];\n\n\t\t\t\t\tif ( 'Lcl_Translation' in lookAtTarget ) {\n\n\t\t\t\t\t\tconst pos = lookAtTarget.Lcl_Translation.value;\n\n\t\t\t\t\t\t// DirectionalLight, SpotLight\n\t\t\t\t\t\tif ( model.target !== undefined ) {\n\n\t\t\t\t\t\t\tmodel.target.position.fromArray( pos );\n\t\t\t\t\t\t\tsceneGraph.add( model.target );\n\n\t\t\t\t\t\t} else { // Cameras and other Object3Ds\n\n\t\t\t\t\t\t\tmodel.lookAt( new Vector3().fromArray( pos ) );\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t} );\n\n\t\t}\n\n\t}\n\n\tbindSkeleton( skeletons, geometryMap, modelMap ) {\n\n\t\tconst bindMatrices = this.parsePoseNodes();\n\n\t\tfor ( const ID in skeletons ) {\n\n\t\t\tconst skeleton = skeletons[ ID ];\n\n\t\t\tconst parents = connections.get( parseInt( skeleton.ID ) ).parents;\n\n\t\t\tparents.forEach( function ( parent ) {\n\n\t\t\t\tif ( geometryMap.has( parent.ID ) ) {\n\n\t\t\t\t\tconst geoID = parent.ID;\n\t\t\t\t\tconst geoRelationships = connections.get( geoID );\n\n\t\t\t\t\tgeoRelationships.parents.forEach( function ( geoConnParent ) {\n\n\t\t\t\t\t\tif ( modelMap.has( geoConnParent.ID ) ) {\n\n\t\t\t\t\t\t\tconst model = modelMap.get( geoConnParent.ID );\n\n\t\t\t\t\t\t\tmodel.bind( new Skeleton( skeleton.bones ), bindMatrices[ geoConnParent.ID ] );\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t} );\n\n\t\t\t\t}\n\n\t\t\t} );\n\n\t\t}\n\n\t}\n\n\tparsePoseNodes() {\n\n\t\tconst bindMatrices = {};\n\n\t\tif ( 'Pose' in fbxTree.Objects ) {\n\n\t\t\tconst BindPoseNode = fbxTree.Objects.Pose;\n\n\t\t\tfor ( const nodeID in BindPoseNode ) {\n\n\t\t\t\tif ( BindPoseNode[ nodeID ].attrType === 'BindPose' && BindPoseNode[ nodeID ].NbPoseNodes > 0 ) {\n\n\t\t\t\t\tconst poseNodes = BindPoseNode[ nodeID ].PoseNode;\n\n\t\t\t\t\tif ( Array.isArray( poseNodes ) ) {\n\n\t\t\t\t\t\tposeNodes.forEach( function ( poseNode ) {\n\n\t\t\t\t\t\t\tbindMatrices[ poseNode.Node ] = new Matrix4().fromArray( poseNode.Matrix.a );\n\n\t\t\t\t\t\t} );\n\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\tbindMatrices[ poseNodes.Node ] = new Matrix4().fromArray( poseNodes.Matrix.a );\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn bindMatrices;\n\n\t}\n\n\taddGlobalSceneSettings() {\n\n\t\tif ( 'GlobalSettings' in fbxTree ) {\n\n\t\t\tif ( 'AmbientColor' in fbxTree.GlobalSettings ) {\n\n\t\t\t\t// Parse ambient color - if it's not set to black (default), create an ambient light\n\n\t\t\t\tconst ambientColor = fbxTree.GlobalSettings.AmbientColor.value;\n\t\t\t\tconst r = ambientColor[ 0 ];\n\t\t\t\tconst g = ambientColor[ 1 ];\n\t\t\t\tconst b = ambientColor[ 2 ];\n\n\t\t\t\tif ( r !== 0 || g !== 0 || b !== 0 ) {\n\n\t\t\t\t\tconst color = new Color( r, g, b ).convertSRGBToLinear();\n\t\t\t\t\tsceneGraph.add( new AmbientLight( color, 1 ) );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tif ( 'UnitScaleFactor' in fbxTree.GlobalSettings ) {\n\n\t\t\t\tsceneGraph.userData.unitScaleFactor = fbxTree.GlobalSettings.UnitScaleFactor.value;\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n}\n\n// parse Geometry data from FBXTree and return map of BufferGeometries\nclass GeometryParser {\n\n\tconstructor() {\n\n\t\tthis.negativeMaterialIndices = false;\n\n\t}\n\n\t// Parse nodes in FBXTree.Objects.Geometry\n\tparse( deformers ) {\n\n\t\tconst geometryMap = new Map();\n\n\t\tif ( 'Geometry' in fbxTree.Objects ) {\n\n\t\t\tconst geoNodes = fbxTree.Objects.Geometry;\n\n\t\t\tfor ( const nodeID in geoNodes ) {\n\n\t\t\t\tconst relationships = connections.get( parseInt( nodeID ) );\n\t\t\t\tconst geo = this.parseGeometry( relationships, geoNodes[ nodeID ], deformers );\n\n\t\t\t\tgeometryMap.set( parseInt( nodeID ), geo );\n\n\t\t\t}\n\n\t\t}\n\n\t\t// report warnings\n\n\t\tif ( this.negativeMaterialIndices === true ) {\n\n\t\t\tconsole.warn( 'THREE.FBXLoader: The FBX file contains invalid (negative) material indices. The asset might not render as expected.' );\n\n\t\t}\n\n\t\treturn geometryMap;\n\n\t}\n\n\t// Parse single node in FBXTree.Objects.Geometry\n\tparseGeometry( relationships, geoNode, deformers ) {\n\n\t\tswitch ( geoNode.attrType ) {\n\n\t\t\tcase 'Mesh':\n\t\t\t\treturn this.parseMeshGeometry( relationships, geoNode, deformers );\n\t\t\t\tbreak;\n\n\t\t\tcase 'NurbsCurve':\n\t\t\t\treturn this.parseNurbsGeometry( geoNode );\n\t\t\t\tbreak;\n\n\t\t}\n\n\t}\n\n\t// Parse single node mesh geometry in FBXTree.Objects.Geometry\n\tparseMeshGeometry( relationships, geoNode, deformers ) {\n\n\t\tconst skeletons = deformers.skeletons;\n\t\tconst morphTargets = [];\n\n\t\tconst modelNodes = relationships.parents.map( function ( parent ) {\n\n\t\t\treturn fbxTree.Objects.Model[ parent.ID ];\n\n\t\t} );\n\n\t\t// don't create geometry if it is not associated with any models\n\t\tif ( modelNodes.length === 0 ) return;\n\n\t\tconst skeleton = relationships.children.reduce( function ( skeleton, child ) {\n\n\t\t\tif ( skeletons[ child.ID ] !== undefined ) skeleton = skeletons[ child.ID ];\n\n\t\t\treturn skeleton;\n\n\t\t}, null );\n\n\t\trelationships.children.forEach( function ( child ) {\n\n\t\t\tif ( deformers.morphTargets[ child.ID ] !== undefined ) {\n\n\t\t\t\tmorphTargets.push( deformers.morphTargets[ child.ID ] );\n\n\t\t\t}\n\n\t\t} );\n\n\t\t// Assume one model and get the preRotation from that\n\t\t// if there is more than one model associated with the geometry this may cause problems\n\t\tconst modelNode = modelNodes[ 0 ];\n\n\t\tconst transformData = {};\n\n\t\tif ( 'RotationOrder' in modelNode ) transformData.eulerOrder = getEulerOrder( modelNode.RotationOrder.value );\n\t\tif ( 'InheritType' in modelNode ) transformData.inheritType = parseInt( modelNode.InheritType.value );\n\n\t\tif ( 'GeometricTranslation' in modelNode ) transformData.translation = modelNode.GeometricTranslation.value;\n\t\tif ( 'GeometricRotation' in modelNode ) transformData.rotation = modelNode.GeometricRotation.value;\n\t\tif ( 'GeometricScaling' in modelNode ) transformData.scale = modelNode.GeometricScaling.value;\n\n\t\tconst transform = generateTransform( transformData );\n\n\t\treturn this.genGeometry( geoNode, skeleton, morphTargets, transform );\n\n\t}\n\n\t// Generate a BufferGeometry from a node in FBXTree.Objects.Geometry\n\tgenGeometry( geoNode, skeleton, morphTargets, preTransform ) {\n\n\t\tconst geo = new BufferGeometry();\n\t\tif ( geoNode.attrName ) geo.name = geoNode.attrName;\n\n\t\tconst geoInfo = this.parseGeoNode( geoNode, skeleton );\n\t\tconst buffers = this.genBuffers( geoInfo );\n\n\t\tconst positionAttribute = new Float32BufferAttribute( buffers.vertex, 3 );\n\n\t\tpositionAttribute.applyMatrix4( preTransform );\n\n\t\tgeo.setAttribute( 'position', positionAttribute );\n\n\t\tif ( buffers.colors.length > 0 ) {\n\n\t\t\tgeo.setAttribute( 'color', new Float32BufferAttribute( buffers.colors, 3 ) );\n\n\t\t}\n\n\t\tif ( skeleton ) {\n\n\t\t\tgeo.setAttribute( 'skinIndex', new Uint16BufferAttribute( buffers.weightsIndices, 4 ) );\n\n\t\t\tgeo.setAttribute( 'skinWeight', new Float32BufferAttribute( buffers.vertexWeights, 4 ) );\n\n\t\t\t// used later to bind the skeleton to the model\n\t\t\tgeo.FBX_Deformer = skeleton;\n\n\t\t}\n\n\t\tif ( buffers.normal.length > 0 ) {\n\n\t\t\tconst normalMatrix = new Matrix3().getNormalMatrix( preTransform );\n\n\t\t\tconst normalAttribute = new Float32BufferAttribute( buffers.normal, 3 );\n\t\t\tnormalAttribute.applyNormalMatrix( normalMatrix );\n\n\t\t\tgeo.setAttribute( 'normal', normalAttribute );\n\n\t\t}\n\n\t\tbuffers.uvs.forEach( function ( uvBuffer, i ) {\n\n\t\t\tconst name = i === 0 ? 'uv' : `uv${ i }`;\n\n\t\t\tgeo.setAttribute( name, new Float32BufferAttribute( buffers.uvs[ i ], 2 ) );\n\n\t\t} );\n\n\t\tif ( geoInfo.material && geoInfo.material.mappingType !== 'AllSame' ) {\n\n\t\t\t// Convert the material indices of each vertex into rendering groups on the geometry.\n\t\t\tlet prevMaterialIndex = buffers.materialIndex[ 0 ];\n\t\t\tlet startIndex = 0;\n\n\t\t\tbuffers.materialIndex.forEach( function ( currentIndex, i ) {\n\n\t\t\t\tif ( currentIndex !== prevMaterialIndex ) {\n\n\t\t\t\t\tgeo.addGroup( startIndex, i - startIndex, prevMaterialIndex );\n\n\t\t\t\t\tprevMaterialIndex = currentIndex;\n\t\t\t\t\tstartIndex = i;\n\n\t\t\t\t}\n\n\t\t\t} );\n\n\t\t\t// the loop above doesn't add the last group, do that here.\n\t\t\tif ( geo.groups.length > 0 ) {\n\n\t\t\t\tconst lastGroup = geo.groups[ geo.groups.length - 1 ];\n\t\t\t\tconst lastIndex = lastGroup.start + lastGroup.count;\n\n\t\t\t\tif ( lastIndex !== buffers.materialIndex.length ) {\n\n\t\t\t\t\tgeo.addGroup( lastIndex, buffers.materialIndex.length - lastIndex, prevMaterialIndex );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\t// case where there are multiple materials but the whole geometry is only\n\t\t\t// using one of them\n\t\t\tif ( geo.groups.length === 0 ) {\n\n\t\t\t\tgeo.addGroup( 0, buffers.materialIndex.length, buffers.materialIndex[ 0 ] );\n\n\t\t\t}\n\n\t\t}\n\n\t\tthis.addMorphTargets( geo, geoNode, morphTargets, preTransform );\n\n\t\treturn geo;\n\n\t}\n\n\tparseGeoNode( geoNode, skeleton ) {\n\n\t\tconst geoInfo = {};\n\n\t\tgeoInfo.vertexPositions = ( geoNode.Vertices !== undefined ) ? geoNode.Vertices.a : [];\n\t\tgeoInfo.vertexIndices = ( geoNode.PolygonVertexIndex !== undefined ) ? geoNode.PolygonVertexIndex.a : [];\n\n\t\tif ( geoNode.LayerElementColor ) {\n\n\t\t\tgeoInfo.color = this.parseVertexColors( geoNode.LayerElementColor[ 0 ] );\n\n\t\t}\n\n\t\tif ( geoNode.LayerElementMaterial ) {\n\n\t\t\tgeoInfo.material = this.parseMaterialIndices( geoNode.LayerElementMaterial[ 0 ] );\n\n\t\t}\n\n\t\tif ( geoNode.LayerElementNormal ) {\n\n\t\t\tgeoInfo.normal = this.parseNormals( geoNode.LayerElementNormal[ 0 ] );\n\n\t\t}\n\n\t\tif ( geoNode.LayerElementUV ) {\n\n\t\t\tgeoInfo.uv = [];\n\n\t\t\tlet i = 0;\n\t\t\twhile ( geoNode.LayerElementUV[ i ] ) {\n\n\t\t\t\tif ( geoNode.LayerElementUV[ i ].UV ) {\n\n\t\t\t\t\tgeoInfo.uv.push( this.parseUVs( geoNode.LayerElementUV[ i ] ) );\n\n\t\t\t\t}\n\n\t\t\t\ti ++;\n\n\t\t\t}\n\n\t\t}\n\n\t\tgeoInfo.weightTable = {};\n\n\t\tif ( skeleton !== null ) {\n\n\t\t\tgeoInfo.skeleton = skeleton;\n\n\t\t\tskeleton.rawBones.forEach( function ( rawBone, i ) {\n\n\t\t\t\t// loop over the bone's vertex indices and weights\n\t\t\t\trawBone.indices.forEach( function ( index, j ) {\n\n\t\t\t\t\tif ( geoInfo.weightTable[ index ] === undefined ) geoInfo.weightTable[ index ] = [];\n\n\t\t\t\t\tgeoInfo.weightTable[ index ].push( {\n\n\t\t\t\t\t\tid: i,\n\t\t\t\t\t\tweight: rawBone.weights[ j ],\n\n\t\t\t\t\t} );\n\n\t\t\t\t} );\n\n\t\t\t} );\n\n\t\t}\n\n\t\treturn geoInfo;\n\n\t}\n\n\tgenBuffers( geoInfo ) {\n\n\t\tconst buffers = {\n\t\t\tvertex: [],\n\t\t\tnormal: [],\n\t\t\tcolors: [],\n\t\t\tuvs: [],\n\t\t\tmaterialIndex: [],\n\t\t\tvertexWeights: [],\n\t\t\tweightsIndices: [],\n\t\t};\n\n\t\tlet polygonIndex = 0;\n\t\tlet faceLength = 0;\n\t\tlet displayedWeightsWarning = false;\n\n\t\t// these will hold data for a single face\n\t\tlet facePositionIndexes = [];\n\t\tlet faceNormals = [];\n\t\tlet faceColors = [];\n\t\tlet faceUVs = [];\n\t\tlet faceWeights = [];\n\t\tlet faceWeightIndices = [];\n\n\t\tconst scope = this;\n\t\tgeoInfo.vertexIndices.forEach( function ( vertexIndex, polygonVertexIndex ) {\n\n\t\t\tlet materialIndex;\n\t\t\tlet endOfFace = false;\n\n\t\t\t// Face index and vertex index arrays are combined in a single array\n\t\t\t// A cube with quad faces looks like this:\n\t\t\t// PolygonVertexIndex: *24 {\n\t\t\t// a: 0, 1, 3, -3, 2, 3, 5, -5, 4, 5, 7, -7, 6, 7, 1, -1, 1, 7, 5, -4, 6, 0, 2, -5\n\t\t\t// }\n\t\t\t// Negative numbers mark the end of a face - first face here is 0, 1, 3, -3\n\t\t\t// to find index of last vertex bit shift the index: ^ - 1\n\t\t\tif ( vertexIndex < 0 ) {\n\n\t\t\t\tvertexIndex = vertexIndex ^ - 1; // equivalent to ( x * -1 ) - 1\n\t\t\t\tendOfFace = true;\n\n\t\t\t}\n\n\t\t\tlet weightIndices = [];\n\t\t\tlet weights = [];\n\n\t\t\tfacePositionIndexes.push( vertexIndex * 3, vertexIndex * 3 + 1, vertexIndex * 3 + 2 );\n\n\t\t\tif ( geoInfo.color ) {\n\n\t\t\t\tconst data = getData( polygonVertexIndex, polygonIndex, vertexIndex, geoInfo.color );\n\n\t\t\t\tfaceColors.push( data[ 0 ], data[ 1 ], data[ 2 ] );\n\n\t\t\t}\n\n\t\t\tif ( geoInfo.skeleton ) {\n\n\t\t\t\tif ( geoInfo.weightTable[ vertexIndex ] !== undefined ) {\n\n\t\t\t\t\tgeoInfo.weightTable[ vertexIndex ].forEach( function ( wt ) {\n\n\t\t\t\t\t\tweights.push( wt.weight );\n\t\t\t\t\t\tweightIndices.push( wt.id );\n\n\t\t\t\t\t} );\n\n\n\t\t\t\t}\n\n\t\t\t\tif ( weights.length > 4 ) {\n\n\t\t\t\t\tif ( ! displayedWeightsWarning ) {\n\n\t\t\t\t\t\tconsole.warn( 'THREE.FBXLoader: Vertex has more than 4 skinning weights assigned to vertex. Deleting additional weights.' );\n\t\t\t\t\t\tdisplayedWeightsWarning = true;\n\n\t\t\t\t\t}\n\n\t\t\t\t\tconst wIndex = [ 0, 0, 0, 0 ];\n\t\t\t\t\tconst Weight = [ 0, 0, 0, 0 ];\n\n\t\t\t\t\tweights.forEach( function ( weight, weightIndex ) {\n\n\t\t\t\t\t\tlet currentWeight = weight;\n\t\t\t\t\t\tlet currentIndex = weightIndices[ weightIndex ];\n\n\t\t\t\t\t\tWeight.forEach( function ( comparedWeight, comparedWeightIndex, comparedWeightArray ) {\n\n\t\t\t\t\t\t\tif ( currentWeight > comparedWeight ) {\n\n\t\t\t\t\t\t\t\tcomparedWeightArray[ comparedWeightIndex ] = currentWeight;\n\t\t\t\t\t\t\t\tcurrentWeight = comparedWeight;\n\n\t\t\t\t\t\t\t\tconst tmp = wIndex[ comparedWeightIndex ];\n\t\t\t\t\t\t\t\twIndex[ comparedWeightIndex ] = currentIndex;\n\t\t\t\t\t\t\t\tcurrentIndex = tmp;\n\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t} );\n\n\t\t\t\t\t} );\n\n\t\t\t\t\tweightIndices = wIndex;\n\t\t\t\t\tweights = Weight;\n\n\t\t\t\t}\n\n\t\t\t\t// if the weight array is shorter than 4 pad with 0s\n\t\t\t\twhile ( weights.length < 4 ) {\n\n\t\t\t\t\tweights.push( 0 );\n\t\t\t\t\tweightIndices.push( 0 );\n\n\t\t\t\t}\n\n\t\t\t\tfor ( let i = 0; i < 4; ++ i ) {\n\n\t\t\t\t\tfaceWeights.push( weights[ i ] );\n\t\t\t\t\tfaceWeightIndices.push( weightIndices[ i ] );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tif ( geoInfo.normal ) {\n\n\t\t\t\tconst data = getData( polygonVertexIndex, polygonIndex, vertexIndex, geoInfo.normal );\n\n\t\t\t\tfaceNormals.push( data[ 0 ], data[ 1 ], data[ 2 ] );\n\n\t\t\t}\n\n\t\t\tif ( geoInfo.material && geoInfo.material.mappingType !== 'AllSame' ) {\n\n\t\t\t\tmaterialIndex = getData( polygonVertexIndex, polygonIndex, vertexIndex, geoInfo.material )[ 0 ];\n\n\t\t\t\tif ( materialIndex < 0 ) {\n\n\t\t\t\t\tscope.negativeMaterialIndices = true;\n\t\t\t\t\tmaterialIndex = 0; // fallback\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tif ( geoInfo.uv ) {\n\n\t\t\t\tgeoInfo.uv.forEach( function ( uv, i ) {\n\n\t\t\t\t\tconst data = getData( polygonVertexIndex, polygonIndex, vertexIndex, uv );\n\n\t\t\t\t\tif ( faceUVs[ i ] === undefined ) {\n\n\t\t\t\t\t\tfaceUVs[ i ] = [];\n\n\t\t\t\t\t}\n\n\t\t\t\t\tfaceUVs[ i ].push( data[ 0 ] );\n\t\t\t\t\tfaceUVs[ i ].push( data[ 1 ] );\n\n\t\t\t\t} );\n\n\t\t\t}\n\n\t\t\tfaceLength ++;\n\n\t\t\tif ( endOfFace ) {\n\n\t\t\t\tscope.genFace( buffers, geoInfo, facePositionIndexes, materialIndex, faceNormals, faceColors, faceUVs, faceWeights, faceWeightIndices, faceLength );\n\n\t\t\t\tpolygonIndex ++;\n\t\t\t\tfaceLength = 0;\n\n\t\t\t\t// reset arrays for the next face\n\t\t\t\tfacePositionIndexes = [];\n\t\t\t\tfaceNormals = [];\n\t\t\t\tfaceColors = [];\n\t\t\t\tfaceUVs = [];\n\t\t\t\tfaceWeights = [];\n\t\t\t\tfaceWeightIndices = [];\n\n\t\t\t}\n\n\t\t} );\n\n\t\treturn buffers;\n\n\t}\n\n\t// See https://www.khronos.org/opengl/wiki/Calculating_a_Surface_Normal\n\tgetNormalNewell( vertices ) {\n\n\t\tconst normal = new Vector3( 0.0, 0.0, 0.0 );\n\n\t\tfor ( let i = 0; i < vertices.length; i ++ ) {\n\n\t\t\tconst current = vertices[ i ];\n\t\t\tconst next = vertices[ ( i + 1 ) % vertices.length ];\n\n\t\t\tnormal.x += ( current.y - next.y ) * ( current.z + next.z );\n\t\t\tnormal.y += ( current.z - next.z ) * ( current.x + next.x );\n\t\t\tnormal.z += ( current.x - next.x ) * ( current.y + next.y );\n\n\t\t}\n\n\t\tnormal.normalize();\n\n\t\treturn normal;\n\n\t}\n\n\tgetNormalTangentAndBitangent( vertices ) {\n\n\t\tconst normalVector = this.getNormalNewell( vertices );\n\t\t// Avoid up being equal or almost equal to normalVector\n\t\tconst up = Math.abs( normalVector.z ) > 0.5 ? new Vector3( 0.0, 1.0, 0.0 ) : new Vector3( 0.0, 0.0, 1.0 );\n\t\tconst tangent = up.cross( normalVector ).normalize();\n\t\tconst bitangent = normalVector.clone().cross( tangent ).normalize();\n\n\t\treturn {\n\t\t\tnormal: normalVector,\n\t\t\ttangent: tangent,\n\t\t\tbitangent: bitangent\n\t\t};\n\n\t}\n\n\tflattenVertex( vertex, normalTangent, normalBitangent ) {\n\n\t\treturn new Vector2(\n\t\t\tvertex.dot( normalTangent ),\n\t\t\tvertex.dot( normalBitangent )\n\t\t);\n\n\t}\n\n\t// Generate data for a single face in a geometry. If the face is a quad then split it into 2 tris\n\tgenFace( buffers, geoInfo, facePositionIndexes, materialIndex, faceNormals, faceColors, faceUVs, faceWeights, faceWeightIndices, faceLength ) {\n\n\t\tlet triangles;\n\n\t\tif ( faceLength > 3 ) {\n\n\t\t\t// Triangulate n-gon using earcut\n\n\t\t\tconst vertices = [];\n\n\t\t\tfor ( let i = 0; i < facePositionIndexes.length; i += 3 ) {\n\n\t\t\t\tvertices.push( new Vector3(\n\t\t\t\t\tgeoInfo.vertexPositions[ facePositionIndexes[ i ] ],\n\t\t\t\t\tgeoInfo.vertexPositions[ facePositionIndexes[ i + 1 ] ],\n\t\t\t\t\tgeoInfo.vertexPositions[ facePositionIndexes[ i + 2 ] ]\n\t\t\t\t) );\n\n\t\t\t}\n\n\t\t\tconst { tangent, bitangent } = this.getNormalTangentAndBitangent( vertices );\n\t\t\tconst triangulationInput = [];\n\n\t\t\tfor ( const vertex of vertices ) {\n\n\t\t\t\ttriangulationInput.push( this.flattenVertex( vertex, tangent, bitangent ) );\n\n\t\t\t}\n\n\t\t\ttriangles = ShapeUtils.triangulateShape( triangulationInput, [] );\n\n\t\t} else {\n\n\t\t\t// Regular triangle, skip earcut triangulation step\n\t\t\ttriangles = [[ 0, 1, 2 ]];\n\n\t\t}\n\n\t\tfor ( const [ i0, i1, i2 ] of triangles ) {\n\n\t\t\tbuffers.vertex.push( geoInfo.vertexPositions[ facePositionIndexes[ i0 * 3 ] ] );\n\t\t\tbuffers.vertex.push( geoInfo.vertexPositions[ facePositionIndexes[ i0 * 3 + 1 ] ] );\n\t\t\tbuffers.vertex.push( geoInfo.vertexPositions[ facePositionIndexes[ i0 * 3 + 2 ] ] );\n\n\t\t\tbuffers.vertex.push( geoInfo.vertexPositions[ facePositionIndexes[ i1 * 3 ] ] );\n\t\t\tbuffers.vertex.push( geoInfo.vertexPositions[ facePositionIndexes[ i1 * 3 + 1 ] ] );\n\t\t\tbuffers.vertex.push( geoInfo.vertexPositions[ facePositionIndexes[ i1 * 3 + 2 ] ] );\n\n\t\t\tbuffers.vertex.push( geoInfo.vertexPositions[ facePositionIndexes[ i2 * 3 ] ] );\n\t\t\tbuffers.vertex.push( geoInfo.vertexPositions[ facePositionIndexes[ i2 * 3 + 1 ] ] );\n\t\t\tbuffers.vertex.push( geoInfo.vertexPositions[ facePositionIndexes[ i2 * 3 + 2 ] ] );\n\n\t\t\tif ( geoInfo.skeleton ) {\n\n\t\t\t\tbuffers.vertexWeights.push( faceWeights[ i0 * 4 ] );\n\t\t\t\tbuffers.vertexWeights.push( faceWeights[ i0 * 4 + 1 ] );\n\t\t\t\tbuffers.vertexWeights.push( faceWeights[ i0 * 4 + 2 ] );\n\t\t\t\tbuffers.vertexWeights.push( faceWeights[ i0 * 4 + 3 ] );\n\n\t\t\t\tbuffers.vertexWeights.push( faceWeights[ i1 * 4 ] );\n\t\t\t\tbuffers.vertexWeights.push( faceWeights[ i1 * 4 + 1 ] );\n\t\t\t\tbuffers.vertexWeights.push( faceWeights[ i1 * 4 + 2 ] );\n\t\t\t\tbuffers.vertexWeights.push( faceWeights[ i1 * 4 + 3 ] );\n\n\t\t\t\tbuffers.vertexWeights.push( faceWeights[ i2 * 4 ] );\n\t\t\t\tbuffers.vertexWeights.push( faceWeights[ i2 * 4 + 1 ] );\n\t\t\t\tbuffers.vertexWeights.push( faceWeights[ i2 * 4 + 2 ] );\n\t\t\t\tbuffers.vertexWeights.push( faceWeights[ i2 * 4 + 3 ] );\n\n\t\t\t\tbuffers.weightsIndices.push( faceWeightIndices[ i0 * 4 ] );\n\t\t\t\tbuffers.weightsIndices.push( faceWeightIndices[ i0 * 4 + 1 ] );\n\t\t\t\tbuffers.weightsIndices.push( faceWeightIndices[ i0 * 4 + 2 ] );\n\t\t\t\tbuffers.weightsIndices.push( faceWeightIndices[ i0 * 4 + 3 ] );\n\n\t\t\t\tbuffers.weightsIndices.push( faceWeightIndices[ i1 * 4 ] );\n\t\t\t\tbuffers.weightsIndices.push( faceWeightIndices[ i1 * 4 + 1 ] );\n\t\t\t\tbuffers.weightsIndices.push( faceWeightIndices[ i1 * 4 + 2 ] );\n\t\t\t\tbuffers.weightsIndices.push( faceWeightIndices[ i1 * 4 + 3 ] );\n\n\t\t\t\tbuffers.weightsIndices.push( faceWeightIndices[ i2 * 4 ] );\n\t\t\t\tbuffers.weightsIndices.push( faceWeightIndices[ i2 * 4 + 1 ] );\n\t\t\t\tbuffers.weightsIndices.push( faceWeightIndices[ i2 * 4 + 2 ] );\n\t\t\t\tbuffers.weightsIndices.push( faceWeightIndices[ i2 * 4 + 3 ] );\n\n\t\t\t}\n\n\t\t\tif ( geoInfo.color ) {\n\n\t\t\t\tbuffers.colors.push( faceColors[ i0 * 3 ] );\n\t\t\t\tbuffers.colors.push( faceColors[ i0 * 3 + 1 ] );\n\t\t\t\tbuffers.colors.push( faceColors[ i0 * 3 + 2 ] );\n\n\t\t\t\tbuffers.colors.push( faceColors[ i1 * 3 ] );\n\t\t\t\tbuffers.colors.push( faceColors[ i1 * 3 + 1 ] );\n\t\t\t\tbuffers.colors.push( faceColors[ i1 * 3 + 2 ] );\n\n\t\t\t\tbuffers.colors.push( faceColors[ i2 * 3 ] );\n\t\t\t\tbuffers.colors.push( faceColors[ i2 * 3 + 1 ] );\n\t\t\t\tbuffers.colors.push( faceColors[ i2 * 3 + 2 ] );\n\n\t\t\t}\n\n\t\t\tif ( geoInfo.material && geoInfo.material.mappingType !== 'AllSame' ) {\n\n\t\t\t\tbuffers.materialIndex.push( materialIndex );\n\t\t\t\tbuffers.materialIndex.push( materialIndex );\n\t\t\t\tbuffers.materialIndex.push( materialIndex );\n\n\t\t\t}\n\n\t\t\tif ( geoInfo.normal ) {\n\n\t\t\t\tbuffers.normal.push( faceNormals[ i0 * 3 ] );\n\t\t\t\tbuffers.normal.push( faceNormals[ i0 * 3 + 1 ] );\n\t\t\t\tbuffers.normal.push( faceNormals[ i0 * 3 + 2 ] );\n\n\t\t\t\tbuffers.normal.push( faceNormals[ i1 * 3 ] );\n\t\t\t\tbuffers.normal.push( faceNormals[ i1 * 3 + 1 ] );\n\t\t\t\tbuffers.normal.push( faceNormals[ i1 * 3 + 2 ] );\n\n\t\t\t\tbuffers.normal.push( faceNormals[ i2 * 3 ] );\n\t\t\t\tbuffers.normal.push( faceNormals[ i2 * 3 + 1 ] );\n\t\t\t\tbuffers.normal.push( faceNormals[ i2 * 3 + 2 ] );\n\n\t\t\t}\n\n\t\t\tif ( geoInfo.uv ) {\n\n\t\t\t\tgeoInfo.uv.forEach( function ( uv, j ) {\n\n\t\t\t\t\tif ( buffers.uvs[ j ] === undefined ) buffers.uvs[ j ] = [];\n\n\t\t\t\t\tbuffers.uvs[ j ].push( faceUVs[ j ][ i0 * 2 ] );\n\t\t\t\t\tbuffers.uvs[ j ].push( faceUVs[ j ][ i0 * 2 + 1 ] );\n\n\t\t\t\t\tbuffers.uvs[ j ].push( faceUVs[ j ][ i1 * 2 ] );\n\t\t\t\t\tbuffers.uvs[ j ].push( faceUVs[ j ][ i1 * 2 + 1 ] );\n\n\t\t\t\t\tbuffers.uvs[ j ].push( faceUVs[ j ][ i2 * 2 ] );\n\t\t\t\t\tbuffers.uvs[ j ].push( faceUVs[ j ][ i2 * 2 + 1 ] );\n\n\t\t\t\t} );\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n\taddMorphTargets( parentGeo, parentGeoNode, morphTargets, preTransform ) {\n\n\t\tif ( morphTargets.length === 0 ) return;\n\n\t\tparentGeo.morphTargetsRelative = true;\n\n\t\tparentGeo.morphAttributes.position = [];\n\t\t// parentGeo.morphAttributes.normal = []; // not implemented\n\n\t\tconst scope = this;\n\t\tmorphTargets.forEach( function ( morphTarget ) {\n\n\t\t\tmorphTarget.rawTargets.forEach( function ( rawTarget ) {\n\n\t\t\t\tconst morphGeoNode = fbxTree.Objects.Geometry[ rawTarget.geoID ];\n\n\t\t\t\tif ( morphGeoNode !== undefined ) {\n\n\t\t\t\t\tscope.genMorphGeometry( parentGeo, parentGeoNode, morphGeoNode, preTransform, rawTarget.name );\n\n\t\t\t\t}\n\n\t\t\t} );\n\n\t\t} );\n\n\t}\n\n\t// a morph geometry node is similar to a standard node, and the node is also contained\n\t// in FBXTree.Objects.Geometry, however it can only have attributes for position, normal\n\t// and a special attribute Index defining which vertices of the original geometry are affected\n\t// Normal and position attributes only have data for the vertices that are affected by the morph\n\tgenMorphGeometry( parentGeo, parentGeoNode, morphGeoNode, preTransform, name ) {\n\n\t\tconst vertexIndices = ( parentGeoNode.PolygonVertexIndex !== undefined ) ? parentGeoNode.PolygonVertexIndex.a : [];\n\n\t\tconst morphPositionsSparse = ( morphGeoNode.Vertices !== undefined ) ? morphGeoNode.Vertices.a : [];\n\t\tconst indices = ( morphGeoNode.Indexes !== undefined ) ? morphGeoNode.Indexes.a : [];\n\n\t\tconst length = parentGeo.attributes.position.count * 3;\n\t\tconst morphPositions = new Float32Array( length );\n\n\t\tfor ( let i = 0; i < indices.length; i ++ ) {\n\n\t\t\tconst morphIndex = indices[ i ] * 3;\n\n\t\t\tmorphPositions[ morphIndex ] = morphPositionsSparse[ i * 3 ];\n\t\t\tmorphPositions[ morphIndex + 1 ] = morphPositionsSparse[ i * 3 + 1 ];\n\t\t\tmorphPositions[ morphIndex + 2 ] = morphPositionsSparse[ i * 3 + 2 ];\n\n\t\t}\n\n\t\t// TODO: add morph normal support\n\t\tconst morphGeoInfo = {\n\t\t\tvertexIndices: vertexIndices,\n\t\t\tvertexPositions: morphPositions,\n\n\t\t};\n\n\t\tconst morphBuffers = this.genBuffers( morphGeoInfo );\n\n\t\tconst positionAttribute = new Float32BufferAttribute( morphBuffers.vertex, 3 );\n\t\tpositionAttribute.name = name || morphGeoNode.attrName;\n\n\t\tpositionAttribute.applyMatrix4( preTransform );\n\n\t\tparentGeo.morphAttributes.position.push( positionAttribute );\n\n\t}\n\n\t// Parse normal from FBXTree.Objects.Geometry.LayerElementNormal if it exists\n\tparseNormals( NormalNode ) {\n\n\t\tconst mappingType = NormalNode.MappingInformationType;\n\t\tconst referenceType = NormalNode.ReferenceInformationType;\n\t\tconst buffer = NormalNode.Normals.a;\n\t\tlet indexBuffer = [];\n\t\tif ( referenceType === 'IndexToDirect' ) {\n\n\t\t\tif ( 'NormalIndex' in NormalNode ) {\n\n\t\t\t\tindexBuffer = NormalNode.NormalIndex.a;\n\n\t\t\t} else if ( 'NormalsIndex' in NormalNode ) {\n\n\t\t\t\tindexBuffer = NormalNode.NormalsIndex.a;\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn {\n\t\t\tdataSize: 3,\n\t\t\tbuffer: buffer,\n\t\t\tindices: indexBuffer,\n\t\t\tmappingType: mappingType,\n\t\t\treferenceType: referenceType\n\t\t};\n\n\t}\n\n\t// Parse UVs from FBXTree.Objects.Geometry.LayerElementUV if it exists\n\tparseUVs( UVNode ) {\n\n\t\tconst mappingType = UVNode.MappingInformationType;\n\t\tconst referenceType = UVNode.ReferenceInformationType;\n\t\tconst buffer = UVNode.UV.a;\n\t\tlet indexBuffer = [];\n\t\tif ( referenceType === 'IndexToDirect' ) {\n\n\t\t\tindexBuffer = UVNode.UVIndex.a;\n\n\t\t}\n\n\t\treturn {\n\t\t\tdataSize: 2,\n\t\t\tbuffer: buffer,\n\t\t\tindices: indexBuffer,\n\t\t\tmappingType: mappingType,\n\t\t\treferenceType: referenceType\n\t\t};\n\n\t}\n\n\t// Parse Vertex Colors from FBXTree.Objects.Geometry.LayerElementColor if it exists\n\tparseVertexColors( ColorNode ) {\n\n\t\tconst mappingType = ColorNode.MappingInformationType;\n\t\tconst referenceType = ColorNode.ReferenceInformationType;\n\t\tconst buffer = ColorNode.Colors.a;\n\t\tlet indexBuffer = [];\n\t\tif ( referenceType === 'IndexToDirect' ) {\n\n\t\t\tindexBuffer = ColorNode.ColorIndex.a;\n\n\t\t}\n\n\t\tfor ( let i = 0, c = new Color(); i < buffer.length; i += 4 ) {\n\n\t\t\tc.fromArray( buffer, i ).convertSRGBToLinear().toArray( buffer, i );\n\n\t\t}\n\n\t\treturn {\n\t\t\tdataSize: 4,\n\t\t\tbuffer: buffer,\n\t\t\tindices: indexBuffer,\n\t\t\tmappingType: mappingType,\n\t\t\treferenceType: referenceType\n\t\t};\n\n\t}\n\n\t// Parse mapping and material data in FBXTree.Objects.Geometry.LayerElementMaterial if it exists\n\tparseMaterialIndices( MaterialNode ) {\n\n\t\tconst mappingType = MaterialNode.MappingInformationType;\n\t\tconst referenceType = MaterialNode.ReferenceInformationType;\n\n\t\tif ( mappingType === 'NoMappingInformation' ) {\n\n\t\t\treturn {\n\t\t\t\tdataSize: 1,\n\t\t\t\tbuffer: [ 0 ],\n\t\t\t\tindices: [ 0 ],\n\t\t\t\tmappingType: 'AllSame',\n\t\t\t\treferenceType: referenceType\n\t\t\t};\n\n\t\t}\n\n\t\tconst materialIndexBuffer = MaterialNode.Materials.a;\n\n\t\t// Since materials are stored as indices, there's a bit of a mismatch between FBX and what\n\t\t// we expect.So we create an intermediate buffer that points to the index in the buffer,\n\t\t// for conforming with the other functions we've written for other data.\n\t\tconst materialIndices = [];\n\n\t\tfor ( let i = 0; i < materialIndexBuffer.length; ++ i ) {\n\n\t\t\tmaterialIndices.push( i );\n\n\t\t}\n\n\t\treturn {\n\t\t\tdataSize: 1,\n\t\t\tbuffer: materialIndexBuffer,\n\t\t\tindices: materialIndices,\n\t\t\tmappingType: mappingType,\n\t\t\treferenceType: referenceType\n\t\t};\n\n\t}\n\n\t// Generate a NurbGeometry from a node in FBXTree.Objects.Geometry\n\tparseNurbsGeometry( geoNode ) {\n\n\t\tconst order = parseInt( geoNode.Order );\n\n\t\tif ( isNaN( order ) ) {\n\n\t\t\tconsole.error( 'THREE.FBXLoader: Invalid Order %s given for geometry ID: %s', geoNode.Order, geoNode.id );\n\t\t\treturn new BufferGeometry();\n\n\t\t}\n\n\t\tconst degree = order - 1;\n\n\t\tconst knots = geoNode.KnotVector.a;\n\t\tconst controlPoints = [];\n\t\tconst pointsValues = geoNode.Points.a;\n\n\t\tfor ( let i = 0, l = pointsValues.length; i < l; i += 4 ) {\n\n\t\t\tcontrolPoints.push( new Vector4().fromArray( pointsValues, i ) );\n\n\t\t}\n\n\t\tlet startKnot, endKnot;\n\n\t\tif ( geoNode.Form === 'Closed' ) {\n\n\t\t\tcontrolPoints.push( controlPoints[ 0 ] );\n\n\t\t} else if ( geoNode.Form === 'Periodic' ) {\n\n\t\t\tstartKnot = degree;\n\t\t\tendKnot = knots.length - 1 - startKnot;\n\n\t\t\tfor ( let i = 0; i < degree; ++ i ) {\n\n\t\t\t\tcontrolPoints.push( controlPoints[ i ] );\n\n\t\t\t}\n\n\t\t}\n\n\t\tconst curve = new NURBSCurve( degree, knots, controlPoints, startKnot, endKnot );\n\t\tconst points = curve.getPoints( controlPoints.length * 12 );\n\n\t\treturn new BufferGeometry().setFromPoints( points );\n\n\t}\n\n}\n\n// parse animation data from FBXTree\nclass AnimationParser {\n\n\t// take raw animation clips and turn them into three.js animation clips\n\tparse() {\n\n\t\tconst animationClips = [];\n\n\t\tconst rawClips = this.parseClips();\n\n\t\tif ( rawClips !== undefined ) {\n\n\t\t\tfor ( const key in rawClips ) {\n\n\t\t\t\tconst rawClip = rawClips[ key ];\n\n\t\t\t\tconst clip = this.addClip( rawClip );\n\n\t\t\t\tanimationClips.push( clip );\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn animationClips;\n\n\t}\n\n\tparseClips() {\n\n\t\t// since the actual transformation data is stored in FBXTree.Objects.AnimationCurve,\n\t\t// if this is undefined we can safely assume there are no animations\n\t\tif ( fbxTree.Objects.AnimationCurve === undefined ) return undefined;\n\n\t\tconst curveNodesMap = this.parseAnimationCurveNodes();\n\n\t\tthis.parseAnimationCurves( curveNodesMap );\n\n\t\tconst layersMap = this.parseAnimationLayers( curveNodesMap );\n\t\tconst rawClips = this.parseAnimStacks( layersMap );\n\n\t\treturn rawClips;\n\n\t}\n\n\t// parse nodes in FBXTree.Objects.AnimationCurveNode\n\t// each AnimationCurveNode holds data for an animation transform for a model (e.g. left arm rotation )\n\t// and is referenced by an AnimationLayer\n\tparseAnimationCurveNodes() {\n\n\t\tconst rawCurveNodes = fbxTree.Objects.AnimationCurveNode;\n\n\t\tconst curveNodesMap = new Map();\n\n\t\tfor ( const nodeID in rawCurveNodes ) {\n\n\t\t\tconst rawCurveNode = rawCurveNodes[ nodeID ];\n\n\t\t\tif ( rawCurveNode.attrName.match( /S|R|T|DeformPercent/ ) !== null ) {\n\n\t\t\t\tconst curveNode = {\n\n\t\t\t\t\tid: rawCurveNode.id,\n\t\t\t\t\tattr: rawCurveNode.attrName,\n\t\t\t\t\tcurves: {},\n\n\t\t\t\t};\n\n\t\t\t\tcurveNodesMap.set( curveNode.id, curveNode );\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn curveNodesMap;\n\n\t}\n\n\t// parse nodes in FBXTree.Objects.AnimationCurve and connect them up to\n\t// previously parsed AnimationCurveNodes. Each AnimationCurve holds data for a single animated\n\t// axis ( e.g. times and values of x rotation)\n\tparseAnimationCurves( curveNodesMap ) {\n\n\t\tconst rawCurves = fbxTree.Objects.AnimationCurve;\n\n\t\t// TODO: Many values are identical up to roundoff error, but won't be optimised\n\t\t// e.g. position times: [0, 0.4, 0. 8]\n\t\t// position values: [7.23538335023477e-7, 93.67518615722656, -0.9982695579528809, 7.23538335023477e-7, 93.67518615722656, -0.9982695579528809, 7.235384487103147e-7, 93.67520904541016, -0.9982695579528809]\n\t\t// clearly, this should be optimised to\n\t\t// times: [0], positions [7.23538335023477e-7, 93.67518615722656, -0.9982695579528809]\n\t\t// this shows up in nearly every FBX file, and generally time array is length > 100\n\n\t\tfor ( const nodeID in rawCurves ) {\n\n\t\t\tconst animationCurve = {\n\n\t\t\t\tid: rawCurves[ nodeID ].id,\n\t\t\t\ttimes: rawCurves[ nodeID ].KeyTime.a.map( convertFBXTimeToSeconds ),\n\t\t\t\tvalues: rawCurves[ nodeID ].KeyValueFloat.a,\n\n\t\t\t};\n\n\t\t\tconst relationships = connections.get( animationCurve.id );\n\n\t\t\tif ( relationships !== undefined ) {\n\n\t\t\t\tconst animationCurveID = relationships.parents[ 0 ].ID;\n\t\t\t\tconst animationCurveRelationship = relationships.parents[ 0 ].relationship;\n\n\t\t\t\tif ( animationCurveRelationship.match( /X/ ) ) {\n\n\t\t\t\t\tcurveNodesMap.get( animationCurveID ).curves[ 'x' ] = animationCurve;\n\n\t\t\t\t} else if ( animationCurveRelationship.match( /Y/ ) ) {\n\n\t\t\t\t\tcurveNodesMap.get( animationCurveID ).curves[ 'y' ] = animationCurve;\n\n\t\t\t\t} else if ( animationCurveRelationship.match( /Z/ ) ) {\n\n\t\t\t\t\tcurveNodesMap.get( animationCurveID ).curves[ 'z' ] = animationCurve;\n\n\t\t\t\t} else if ( animationCurveRelationship.match( /DeformPercent/ ) && curveNodesMap.has( animationCurveID ) ) {\n\n\t\t\t\t\tcurveNodesMap.get( animationCurveID ).curves[ 'morph' ] = animationCurve;\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n\t// parse nodes in FBXTree.Objects.AnimationLayer. Each layers holds references\n\t// to various AnimationCurveNodes and is referenced by an AnimationStack node\n\t// note: theoretically a stack can have multiple layers, however in practice there always seems to be one per stack\n\tparseAnimationLayers( curveNodesMap ) {\n\n\t\tconst rawLayers = fbxTree.Objects.AnimationLayer;\n\n\t\tconst layersMap = new Map();\n\n\t\tfor ( const nodeID in rawLayers ) {\n\n\t\t\tconst layerCurveNodes = [];\n\n\t\t\tconst connection = connections.get( parseInt( nodeID ) );\n\n\t\t\tif ( connection !== undefined ) {\n\n\t\t\t\t// all the animationCurveNodes used in the layer\n\t\t\t\tconst children = connection.children;\n\n\t\t\t\tchildren.forEach( function ( child, i ) {\n\n\t\t\t\t\tif ( curveNodesMap.has( child.ID ) ) {\n\n\t\t\t\t\t\tconst curveNode = curveNodesMap.get( child.ID );\n\n\t\t\t\t\t\t// check that the curves are defined for at least one axis, otherwise ignore the curveNode\n\t\t\t\t\t\tif ( curveNode.curves.x !== undefined || curveNode.curves.y !== undefined || curveNode.curves.z !== undefined ) {\n\n\t\t\t\t\t\t\tif ( layerCurveNodes[ i ] === undefined ) {\n\n\t\t\t\t\t\t\t\tconst modelID = connections.get( child.ID ).parents.filter( function ( parent ) {\n\n\t\t\t\t\t\t\t\t\treturn parent.relationship !== undefined;\n\n\t\t\t\t\t\t\t\t} )[ 0 ].ID;\n\n\t\t\t\t\t\t\t\tif ( modelID !== undefined ) {\n\n\t\t\t\t\t\t\t\t\tconst rawModel = fbxTree.Objects.Model[ modelID.toString() ];\n\n\t\t\t\t\t\t\t\t\tif ( rawModel === undefined ) {\n\n\t\t\t\t\t\t\t\t\t\tconsole.warn( 'THREE.FBXLoader: Encountered a unused curve.', child );\n\t\t\t\t\t\t\t\t\t\treturn;\n\n\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\tconst node = {\n\n\t\t\t\t\t\t\t\t\t\tmodelName: rawModel.attrName ? PropertyBinding.sanitizeNodeName( rawModel.attrName ) : '',\n\t\t\t\t\t\t\t\t\t\tID: rawModel.id,\n\t\t\t\t\t\t\t\t\t\tinitialPosition: [ 0, 0, 0 ],\n\t\t\t\t\t\t\t\t\t\tinitialRotation: [ 0, 0, 0 ],\n\t\t\t\t\t\t\t\t\t\tinitialScale: [ 1, 1, 1 ],\n\n\t\t\t\t\t\t\t\t\t};\n\n\t\t\t\t\t\t\t\t\tsceneGraph.traverse( function ( child ) {\n\n\t\t\t\t\t\t\t\t\t\tif ( child.ID === rawModel.id ) {\n\n\t\t\t\t\t\t\t\t\t\t\tnode.transform = child.matrix;\n\n\t\t\t\t\t\t\t\t\t\t\tif ( child.userData.transformData ) node.eulerOrder = child.userData.transformData.eulerOrder;\n\n\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t} );\n\n\t\t\t\t\t\t\t\t\tif ( ! node.transform ) node.transform = new Matrix4();\n\n\t\t\t\t\t\t\t\t\t// if the animated model is pre rotated, we'll have to apply the pre rotations to every\n\t\t\t\t\t\t\t\t\t// animation value as well\n\t\t\t\t\t\t\t\t\tif ( 'PreRotation' in rawModel ) node.preRotation = rawModel.PreRotation.value;\n\t\t\t\t\t\t\t\t\tif ( 'PostRotation' in rawModel ) node.postRotation = rawModel.PostRotation.value;\n\n\t\t\t\t\t\t\t\t\tlayerCurveNodes[ i ] = node;\n\n\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\tif ( layerCurveNodes[ i ] ) layerCurveNodes[ i ][ curveNode.attr ] = curveNode;\n\n\t\t\t\t\t\t} else if ( curveNode.curves.morph !== undefined ) {\n\n\t\t\t\t\t\t\tif ( layerCurveNodes[ i ] === undefined ) {\n\n\t\t\t\t\t\t\t\tconst deformerID = connections.get( child.ID ).parents.filter( function ( parent ) {\n\n\t\t\t\t\t\t\t\t\treturn parent.relationship !== undefined;\n\n\t\t\t\t\t\t\t\t} )[ 0 ].ID;\n\n\t\t\t\t\t\t\t\tconst morpherID = connections.get( deformerID ).parents[ 0 ].ID;\n\t\t\t\t\t\t\t\tconst geoID = connections.get( morpherID ).parents[ 0 ].ID;\n\n\t\t\t\t\t\t\t\t// assuming geometry is not used in more than one model\n\t\t\t\t\t\t\t\tconst modelID = connections.get( geoID ).parents[ 0 ].ID;\n\n\t\t\t\t\t\t\t\tconst rawModel = fbxTree.Objects.Model[ modelID ];\n\n\t\t\t\t\t\t\t\tconst node = {\n\n\t\t\t\t\t\t\t\t\tmodelName: rawModel.attrName ? PropertyBinding.sanitizeNodeName( rawModel.attrName ) : '',\n\t\t\t\t\t\t\t\t\tmorphName: fbxTree.Objects.Deformer[ deformerID ].attrName,\n\n\t\t\t\t\t\t\t\t};\n\n\t\t\t\t\t\t\t\tlayerCurveNodes[ i ] = node;\n\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\tlayerCurveNodes[ i ][ curveNode.attr ] = curveNode;\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}\n\n\t\t\t\t} );\n\n\t\t\t\tlayersMap.set( parseInt( nodeID ), layerCurveNodes );\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn layersMap;\n\n\t}\n\n\t// parse nodes in FBXTree.Objects.AnimationStack. These are the top level node in the animation\n\t// hierarchy. Each Stack node will be used to create a AnimationClip\n\tparseAnimStacks( layersMap ) {\n\n\t\tconst rawStacks = fbxTree.Objects.AnimationStack;\n\n\t\t// connect the stacks (clips) up to the layers\n\t\tconst rawClips = {};\n\n\t\tfor ( const nodeID in rawStacks ) {\n\n\t\t\tconst children = connections.get( parseInt( nodeID ) ).children;\n\n\t\t\tif ( children.length > 1 ) {\n\n\t\t\t\t// it seems like stacks will always be associated with a single layer. But just in case there are files\n\t\t\t\t// where there are multiple layers per stack, we'll display a warning\n\t\t\t\tconsole.warn( 'THREE.FBXLoader: Encountered an animation stack with multiple layers, this is currently not supported. Ignoring subsequent layers.' );\n\n\t\t\t}\n\n\t\t\tconst layer = layersMap.get( children[ 0 ].ID );\n\n\t\t\trawClips[ nodeID ] = {\n\n\t\t\t\tname: rawStacks[ nodeID ].attrName,\n\t\t\t\tlayer: layer,\n\n\t\t\t};\n\n\t\t}\n\n\t\treturn rawClips;\n\n\t}\n\n\taddClip( rawClip ) {\n\n\t\tlet tracks = [];\n\n\t\tconst scope = this;\n\t\trawClip.layer.forEach( function ( rawTracks ) {\n\n\t\t\ttracks = tracks.concat( scope.generateTracks( rawTracks ) );\n\n\t\t} );\n\n\t\treturn new AnimationClip( rawClip.name, - 1, tracks );\n\n\t}\n\n\tgenerateTracks( rawTracks ) {\n\n\t\tconst tracks = [];\n\n\t\tlet initialPosition = new Vector3();\n\t\tlet initialScale = new Vector3();\n\n\t\tif ( rawTracks.transform ) rawTracks.transform.decompose( initialPosition, new Quaternion(), initialScale );\n\n\t\tinitialPosition = initialPosition.toArray();\n\t\tinitialScale = initialScale.toArray();\n\n\t\tif ( rawTracks.T !== undefined && Object.keys( rawTracks.T.curves ).length > 0 ) {\n\n\t\t\tconst positionTrack = this.generateVectorTrack( rawTracks.modelName, rawTracks.T.curves, initialPosition, 'position' );\n\t\t\tif ( positionTrack !== undefined ) tracks.push( positionTrack );\n\n\t\t}\n\n\t\tif ( rawTracks.R !== undefined && Object.keys( rawTracks.R.curves ).length > 0 ) {\n\n\t\t\tconst rotationTrack = this.generateRotationTrack( rawTracks.modelName, rawTracks.R.curves, rawTracks.preRotation, rawTracks.postRotation, rawTracks.eulerOrder );\n\t\t\tif ( rotationTrack !== undefined ) tracks.push( rotationTrack );\n\n\t\t}\n\n\t\tif ( rawTracks.S !== undefined && Object.keys( rawTracks.S.curves ).length > 0 ) {\n\n\t\t\tconst scaleTrack = this.generateVectorTrack( rawTracks.modelName, rawTracks.S.curves, initialScale, 'scale' );\n\t\t\tif ( scaleTrack !== undefined ) tracks.push( scaleTrack );\n\n\t\t}\n\n\t\tif ( rawTracks.DeformPercent !== undefined ) {\n\n\t\t\tconst morphTrack = this.generateMorphTrack( rawTracks );\n\t\t\tif ( morphTrack !== undefined ) tracks.push( morphTrack );\n\n\t\t}\n\n\t\treturn tracks;\n\n\t}\n\n\tgenerateVectorTrack( modelName, curves, initialValue, type ) {\n\n\t\tconst times = this.getTimesForAllAxes( curves );\n\t\tconst values = this.getKeyframeTrackValues( times, curves, initialValue );\n\n\t\treturn new VectorKeyframeTrack( modelName + '.' + type, times, values );\n\n\t}\n\n\tgenerateRotationTrack( modelName, curves, preRotation, postRotation, eulerOrder ) {\n\n\t\tlet times;\n\t\tlet values;\n\n\t\tif ( curves.x !== undefined && curves.y !== undefined && curves.z !== undefined ) {\n\n\t\t\tconst result = this.interpolateRotations( curves.x, curves.y, curves.z, eulerOrder );\n\n\t\t\ttimes = result[ 0 ];\n\t\t\tvalues = result[ 1 ];\n\n\t\t}\n\n\t\tif ( preRotation !== undefined ) {\n\n\t\t\tpreRotation = preRotation.map( MathUtils.degToRad );\n\t\t\tpreRotation.push( eulerOrder );\n\n\t\t\tpreRotation = new Euler().fromArray( preRotation );\n\t\t\tpreRotation = new Quaternion().setFromEuler( preRotation );\n\n\t\t}\n\n\t\tif ( postRotation !== undefined ) {\n\n\t\t\tpostRotation = postRotation.map( MathUtils.degToRad );\n\t\t\tpostRotation.push( eulerOrder );\n\n\t\t\tpostRotation = new Euler().fromArray( postRotation );\n\t\t\tpostRotation = new Quaternion().setFromEuler( postRotation ).invert();\n\n\t\t}\n\n\t\tconst quaternion = new Quaternion();\n\t\tconst euler = new Euler();\n\n\t\tconst quaternionValues = [];\n\n\t\tif ( ! values || ! times ) return new QuaternionKeyframeTrack( modelName + '.quaternion', [ 0 ], [ 0 ] );\n\n\t\tfor ( let i = 0; i < values.length; i += 3 ) {\n\n\t\t\teuler.set( values[ i ], values[ i + 1 ], values[ i + 2 ], eulerOrder );\n\t\t\tquaternion.setFromEuler( euler );\n\n\t\t\tif ( preRotation !== undefined ) quaternion.premultiply( preRotation );\n\t\t\tif ( postRotation !== undefined ) quaternion.multiply( postRotation );\n\n\t\t\t// Check unroll\n\t\t\tif ( i > 2 ) {\n\n\t\t\t\tconst prevQuat = new Quaternion().fromArray(\n\t\t\t\t\tquaternionValues,\n\t\t\t\t\t( ( i - 3 ) / 3 ) * 4\n\t\t\t\t);\n\n\t\t\t\tif ( prevQuat.dot( quaternion ) < 0 ) {\n\n\t\t\t\t\tquaternion.set( - quaternion.x, - quaternion.y, - quaternion.z, - quaternion.w );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tquaternion.toArray( quaternionValues, ( i / 3 ) * 4 );\n\n\t\t}\n\n\t\treturn new QuaternionKeyframeTrack( modelName + '.quaternion', times, quaternionValues );\n\n\t}\n\n\tgenerateMorphTrack( rawTracks ) {\n\n\t\tconst curves = rawTracks.DeformPercent.curves.morph;\n\t\tconst values = curves.values.map( function ( val ) {\n\n\t\t\treturn val / 100;\n\n\t\t} );\n\n\t\tconst morphNum = sceneGraph.getObjectByName( rawTracks.modelName ).morphTargetDictionary[ rawTracks.morphName ];\n\n\t\treturn new NumberKeyframeTrack( rawTracks.modelName + '.morphTargetInfluences[' + morphNum + ']', curves.times, values );\n\n\t}\n\n\t// For all animated objects, times are defined separately for each axis\n\t// Here we'll combine the times into one sorted array without duplicates\n\tgetTimesForAllAxes( curves ) {\n\n\t\tlet times = [];\n\n\t\t// first join together the times for each axis, if defined\n\t\tif ( curves.x !== undefined ) times = times.concat( curves.x.times );\n\t\tif ( curves.y !== undefined ) times = times.concat( curves.y.times );\n\t\tif ( curves.z !== undefined ) times = times.concat( curves.z.times );\n\n\t\t// then sort them\n\t\ttimes = times.sort( function ( a, b ) {\n\n\t\t\treturn a - b;\n\n\t\t} );\n\n\t\t// and remove duplicates\n\t\tif ( times.length > 1 ) {\n\n\t\t\tlet targetIndex = 1;\n\t\t\tlet lastValue = times[ 0 ];\n\t\t\tfor ( let i = 1; i < times.length; i ++ ) {\n\n\t\t\t\tconst currentValue = times[ i ];\n\t\t\t\tif ( currentValue !== lastValue ) {\n\n\t\t\t\t\ttimes[ targetIndex ] = currentValue;\n\t\t\t\t\tlastValue = currentValue;\n\t\t\t\t\ttargetIndex ++;\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\ttimes = times.slice( 0, targetIndex );\n\n\t\t}\n\n\t\treturn times;\n\n\t}\n\n\tgetKeyframeTrackValues( times, curves, initialValue ) {\n\n\t\tconst prevValue = initialValue;\n\n\t\tconst values = [];\n\n\t\tlet xIndex = - 1;\n\t\tlet yIndex = - 1;\n\t\tlet zIndex = - 1;\n\n\t\ttimes.forEach( function ( time ) {\n\n\t\t\tif ( curves.x ) xIndex = curves.x.times.indexOf( time );\n\t\t\tif ( curves.y ) yIndex = curves.y.times.indexOf( time );\n\t\t\tif ( curves.z ) zIndex = curves.z.times.indexOf( time );\n\n\t\t\t// if there is an x value defined for this frame, use that\n\t\t\tif ( xIndex !== - 1 ) {\n\n\t\t\t\tconst xValue = curves.x.values[ xIndex ];\n\t\t\t\tvalues.push( xValue );\n\t\t\t\tprevValue[ 0 ] = xValue;\n\n\t\t\t} else {\n\n\t\t\t\t// otherwise use the x value from the previous frame\n\t\t\t\tvalues.push( prevValue[ 0 ] );\n\n\t\t\t}\n\n\t\t\tif ( yIndex !== - 1 ) {\n\n\t\t\t\tconst yValue = curves.y.values[ yIndex ];\n\t\t\t\tvalues.push( yValue );\n\t\t\t\tprevValue[ 1 ] = yValue;\n\n\t\t\t} else {\n\n\t\t\t\tvalues.push( prevValue[ 1 ] );\n\n\t\t\t}\n\n\t\t\tif ( zIndex !== - 1 ) {\n\n\t\t\t\tconst zValue = curves.z.values[ zIndex ];\n\t\t\t\tvalues.push( zValue );\n\t\t\t\tprevValue[ 2 ] = zValue;\n\n\t\t\t} else {\n\n\t\t\t\tvalues.push( prevValue[ 2 ] );\n\n\t\t\t}\n\n\t\t} );\n\n\t\treturn values;\n\n\t}\n\n\t// Rotations are defined as Euler angles which can have values of any size\n\t// These will be converted to quaternions which don't support values greater than\n\t// PI, so we'll interpolate large rotations\n\tinterpolateRotations( curvex, curvey, curvez, eulerOrder ) {\n\n\t\tconst times = [];\n\t\tconst values = [];\n\n\t\t// Add first frame\n\t\ttimes.push( curvex.times[ 0 ] );\n\t\tvalues.push( MathUtils.degToRad( curvex.values[ 0 ] ) );\n\t\tvalues.push( MathUtils.degToRad( curvey.values[ 0 ] ) );\n\t\tvalues.push( MathUtils.degToRad( curvez.values[ 0 ] ) );\n\n\t\tfor ( let i = 1; i < curvex.values.length; i ++ ) {\n\n\t\t\tconst initialValue = [\n\t\t\t\tcurvex.values[ i - 1 ],\n\t\t\t\tcurvey.values[ i - 1 ],\n\t\t\t\tcurvez.values[ i - 1 ],\n\t\t\t];\n\n\t\t\tif ( isNaN( initialValue[ 0 ] ) || isNaN( initialValue[ 1 ] ) || isNaN( initialValue[ 2 ] ) ) {\n\n\t\t\t\tcontinue;\n\n\t\t\t}\n\n\t\t\tconst initialValueRad = initialValue.map( MathUtils.degToRad );\n\n\t\t\tconst currentValue = [\n\t\t\t\tcurvex.values[ i ],\n\t\t\t\tcurvey.values[ i ],\n\t\t\t\tcurvez.values[ i ],\n\t\t\t];\n\n\t\t\tif ( isNaN( currentValue[ 0 ] ) || isNaN( currentValue[ 1 ] ) || isNaN( currentValue[ 2 ] ) ) {\n\n\t\t\t\tcontinue;\n\n\t\t\t}\n\n\t\t\tconst currentValueRad = currentValue.map( MathUtils.degToRad );\n\n\t\t\tconst valuesSpan = [\n\t\t\t\tcurrentValue[ 0 ] - initialValue[ 0 ],\n\t\t\t\tcurrentValue[ 1 ] - initialValue[ 1 ],\n\t\t\t\tcurrentValue[ 2 ] - initialValue[ 2 ],\n\t\t\t];\n\n\t\t\tconst absoluteSpan = [\n\t\t\t\tMath.abs( valuesSpan[ 0 ] ),\n\t\t\t\tMath.abs( valuesSpan[ 1 ] ),\n\t\t\t\tMath.abs( valuesSpan[ 2 ] ),\n\t\t\t];\n\n\t\t\tif ( absoluteSpan[ 0 ] >= 180 || absoluteSpan[ 1 ] >= 180 || absoluteSpan[ 2 ] >= 180 ) {\n\n\t\t\t\tconst maxAbsSpan = Math.max( ...absoluteSpan );\n\n\t\t\t\tconst numSubIntervals = maxAbsSpan / 180;\n\n\t\t\t\tconst E1 = new Euler( ...initialValueRad, eulerOrder );\n\t\t\t\tconst E2 = new Euler( ...currentValueRad, eulerOrder );\n\n\t\t\t\tconst Q1 = new Quaternion().setFromEuler( E1 );\n\t\t\t\tconst Q2 = new Quaternion().setFromEuler( E2 );\n\n\t\t\t\t// Check unroll\n\t\t\t\tif ( Q1.dot( Q2 ) ) {\n\n\t\t\t\t\tQ2.set( - Q2.x, - Q2.y, - Q2.z, - Q2.w );\n\n\t\t\t\t}\n\n\t\t\t\t// Interpolate\n\t\t\t\tconst initialTime = curvex.times[ i - 1 ];\n\t\t\t\tconst timeSpan = curvex.times[ i ] - initialTime;\n\n\t\t\t\tconst Q = new Quaternion();\n\t\t\t\tconst E = new Euler();\n\t\t\t\tfor ( let t = 0; t < 1; t += 1 / numSubIntervals ) {\n\n\t\t\t\t\tQ.copy( Q1.clone().slerp( Q2.clone(), t ) );\n\n\t\t\t\t\ttimes.push( initialTime + t * timeSpan );\n\t\t\t\t\tE.setFromQuaternion( Q, eulerOrder );\n\n\t\t\t\t\tvalues.push( E.x );\n\t\t\t\t\tvalues.push( E.y );\n\t\t\t\t\tvalues.push( E.z );\n\n\t\t\t\t}\n\n\t\t\t} else {\n\n\t\t\t\ttimes.push( curvex.times[ i ] );\n\t\t\t\tvalues.push( MathUtils.degToRad( curvex.values[ i ] ) );\n\t\t\t\tvalues.push( MathUtils.degToRad( curvey.values[ i ] ) );\n\t\t\t\tvalues.push( MathUtils.degToRad( curvez.values[ i ] ) );\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn [ times, values ];\n\n\t}\n\n}\n\n// parse an FBX file in ASCII format\nclass TextParser {\n\n\tgetPrevNode() {\n\n\t\treturn this.nodeStack[ this.currentIndent - 2 ];\n\n\t}\n\n\tgetCurrentNode() {\n\n\t\treturn this.nodeStack[ this.currentIndent - 1 ];\n\n\t}\n\n\tgetCurrentProp() {\n\n\t\treturn this.currentProp;\n\n\t}\n\n\tpushStack( node ) {\n\n\t\tthis.nodeStack.push( node );\n\t\tthis.currentIndent += 1;\n\n\t}\n\n\tpopStack() {\n\n\t\tthis.nodeStack.pop();\n\t\tthis.currentIndent -= 1;\n\n\t}\n\n\tsetCurrentProp( val, name ) {\n\n\t\tthis.currentProp = val;\n\t\tthis.currentPropName = name;\n\n\t}\n\n\tparse( text ) {\n\n\t\tthis.currentIndent = 0;\n\n\t\tthis.allNodes = new FBXTree();\n\t\tthis.nodeStack = [];\n\t\tthis.currentProp = [];\n\t\tthis.currentPropName = '';\n\n\t\tconst scope = this;\n\n\t\tconst split = text.split( /[\\r\\n]+/ );\n\n\t\tsplit.forEach( function ( line, i ) {\n\n\t\t\tconst matchComment = line.match( /^[\\s\\t]*;/ );\n\t\t\tconst matchEmpty = line.match( /^[\\s\\t]*$/ );\n\n\t\t\tif ( matchComment || matchEmpty ) return;\n\n\t\t\tconst matchBeginning = line.match( '^\\\\t{' + scope.currentIndent + '}(\\\\w+):(.*){', '' );\n\t\t\tconst matchProperty = line.match( '^\\\\t{' + ( scope.currentIndent ) + '}(\\\\w+):[\\\\s\\\\t\\\\r\\\\n](.*)' );\n\t\t\tconst matchEnd = line.match( '^\\\\t{' + ( scope.currentIndent - 1 ) + '}}' );\n\n\t\t\tif ( matchBeginning ) {\n\n\t\t\t\tscope.parseNodeBegin( line, matchBeginning );\n\n\t\t\t} else if ( matchProperty ) {\n\n\t\t\t\tscope.parseNodeProperty( line, matchProperty, split[ ++ i ] );\n\n\t\t\t} else if ( matchEnd ) {\n\n\t\t\t\tscope.popStack();\n\n\t\t\t} else if ( line.match( /^[^\\s\\t}]/ ) ) {\n\n\t\t\t\t// large arrays are split over multiple lines terminated with a ',' character\n\t\t\t\t// if this is encountered the line needs to be joined to the previous line\n\t\t\t\tscope.parseNodePropertyContinued( line );\n\n\t\t\t}\n\n\t\t} );\n\n\t\treturn this.allNodes;\n\n\t}\n\n\tparseNodeBegin( line, property ) {\n\n\t\tconst nodeName = property[ 1 ].trim().replace( /^\"/, '' ).replace( /\"$/, '' );\n\n\t\tconst nodeAttrs = property[ 2 ].split( ',' ).map( function ( attr ) {\n\n\t\t\treturn attr.trim().replace( /^\"/, '' ).replace( /\"$/, '' );\n\n\t\t} );\n\n\t\tconst node = { name: nodeName };\n\t\tconst attrs = this.parseNodeAttr( nodeAttrs );\n\n\t\tconst currentNode = this.getCurrentNode();\n\n\t\t// a top node\n\t\tif ( this.currentIndent === 0 ) {\n\n\t\t\tthis.allNodes.add( nodeName, node );\n\n\t\t} else { // a subnode\n\n\t\t\t// if the subnode already exists, append it\n\t\t\tif ( nodeName in currentNode ) {\n\n\t\t\t\t// special case Pose needs PoseNodes as an array\n\t\t\t\tif ( nodeName === 'PoseNode' ) {\n\n\t\t\t\t\tcurrentNode.PoseNode.push( node );\n\n\t\t\t\t} else if ( currentNode[ nodeName ].id !== undefined ) {\n\n\t\t\t\t\tcurrentNode[ nodeName ] = {};\n\t\t\t\t\tcurrentNode[ nodeName ][ currentNode[ nodeName ].id ] = currentNode[ nodeName ];\n\n\t\t\t\t}\n\n\t\t\t\tif ( attrs.id !== '' ) currentNode[ nodeName ][ attrs.id ] = node;\n\n\t\t\t} else if ( typeof attrs.id === 'number' ) {\n\n\t\t\t\tcurrentNode[ nodeName ] = {};\n\t\t\t\tcurrentNode[ nodeName ][ attrs.id ] = node;\n\n\t\t\t} else if ( nodeName !== 'Properties70' ) {\n\n\t\t\t\tif ( nodeName === 'PoseNode' )\tcurrentNode[ nodeName ] = [ node ];\n\t\t\t\telse currentNode[ nodeName ] = node;\n\n\t\t\t}\n\n\t\t}\n\n\t\tif ( typeof attrs.id === 'number' ) node.id = attrs.id;\n\t\tif ( attrs.name !== '' ) node.attrName = attrs.name;\n\t\tif ( attrs.type !== '' ) node.attrType = attrs.type;\n\n\t\tthis.pushStack( node );\n\n\t}\n\n\tparseNodeAttr( attrs ) {\n\n\t\tlet id = attrs[ 0 ];\n\n\t\tif ( attrs[ 0 ] !== '' ) {\n\n\t\t\tid = parseInt( attrs[ 0 ] );\n\n\t\t\tif ( isNaN( id ) ) {\n\n\t\t\t\tid = attrs[ 0 ];\n\n\t\t\t}\n\n\t\t}\n\n\t\tlet name = '', type = '';\n\n\t\tif ( attrs.length > 1 ) {\n\n\t\t\tname = attrs[ 1 ].replace( /^(\\w+)::/, '' );\n\t\t\ttype = attrs[ 2 ];\n\n\t\t}\n\n\t\treturn { id: id, name: name, type: type };\n\n\t}\n\n\tparseNodeProperty( line, property, contentLine ) {\n\n\t\tlet propName = property[ 1 ].replace( /^\"/, '' ).replace( /\"$/, '' ).trim();\n\t\tlet propValue = property[ 2 ].replace( /^\"/, '' ).replace( /\"$/, '' ).trim();\n\n\t\t// for special case: base64 image data follows \"Content: ,\" line\n\t\t//\tContent: ,\n\t\t//\t \"/9j/4RDaRXhpZgAATU0A...\"\n\t\tif ( propName === 'Content' && propValue === ',' ) {\n\n\t\t\tpropValue = contentLine.replace( /\"/g, '' ).replace( /,$/, '' ).trim();\n\n\t\t}\n\n\t\tconst currentNode = this.getCurrentNode();\n\t\tconst parentName = currentNode.name;\n\n\t\tif ( parentName === 'Properties70' ) {\n\n\t\t\tthis.parseNodeSpecialProperty( line, propName, propValue );\n\t\t\treturn;\n\n\t\t}\n\n\t\t// Connections\n\t\tif ( propName === 'C' ) {\n\n\t\t\tconst connProps = propValue.split( ',' ).slice( 1 );\n\t\t\tconst from = parseInt( connProps[ 0 ] );\n\t\t\tconst to = parseInt( connProps[ 1 ] );\n\n\t\t\tlet rest = propValue.split( ',' ).slice( 3 );\n\n\t\t\trest = rest.map( function ( elem ) {\n\n\t\t\t\treturn elem.trim().replace( /^\"/, '' );\n\n\t\t\t} );\n\n\t\t\tpropName = 'connections';\n\t\t\tpropValue = [ from, to ];\n\t\t\tappend( propValue, rest );\n\n\t\t\tif ( currentNode[ propName ] === undefined ) {\n\n\t\t\t\tcurrentNode[ propName ] = [];\n\n\t\t\t}\n\n\t\t}\n\n\t\t// Node\n\t\tif ( propName === 'Node' ) currentNode.id = propValue;\n\n\t\t// connections\n\t\tif ( propName in currentNode && Array.isArray( currentNode[ propName ] ) ) {\n\n\t\t\tcurrentNode[ propName ].push( propValue );\n\n\t\t} else {\n\n\t\t\tif ( propName !== 'a' ) currentNode[ propName ] = propValue;\n\t\t\telse currentNode.a = propValue;\n\n\t\t}\n\n\t\tthis.setCurrentProp( currentNode, propName );\n\n\t\t// convert string to array, unless it ends in ',' in which case more will be added to it\n\t\tif ( propName === 'a' && propValue.slice( - 1 ) !== ',' ) {\n\n\t\t\tcurrentNode.a = parseNumberArray( propValue );\n\n\t\t}\n\n\t}\n\n\tparseNodePropertyContinued( line ) {\n\n\t\tconst currentNode = this.getCurrentNode();\n\n\t\tcurrentNode.a += line;\n\n\t\t// if the line doesn't end in ',' we have reached the end of the property value\n\t\t// so convert the string to an array\n\t\tif ( line.slice( - 1 ) !== ',' ) {\n\n\t\t\tcurrentNode.a = parseNumberArray( currentNode.a );\n\n\t\t}\n\n\t}\n\n\t// parse \"Property70\"\n\tparseNodeSpecialProperty( line, propName, propValue ) {\n\n\t\t// split this\n\t\t// P: \"Lcl Scaling\", \"Lcl Scaling\", \"\", \"A\",1,1,1\n\t\t// into array like below\n\t\t// [\"Lcl Scaling\", \"Lcl Scaling\", \"\", \"A\", \"1,1,1\" ]\n\t\tconst props = propValue.split( '\",' ).map( function ( prop ) {\n\n\t\t\treturn prop.trim().replace( /^\\\"/, '' ).replace( /\\s/, '_' );\n\n\t\t} );\n\n\t\tconst innerPropName = props[ 0 ];\n\t\tconst innerPropType1 = props[ 1 ];\n\t\tconst innerPropType2 = props[ 2 ];\n\t\tconst innerPropFlag = props[ 3 ];\n\t\tlet innerPropValue = props[ 4 ];\n\n\t\t// cast values where needed, otherwise leave as strings\n\t\tswitch ( innerPropType1 ) {\n\n\t\t\tcase 'int':\n\t\t\tcase 'enum':\n\t\t\tcase 'bool':\n\t\t\tcase 'ULongLong':\n\t\t\tcase 'double':\n\t\t\tcase 'Number':\n\t\t\tcase 'FieldOfView':\n\t\t\t\tinnerPropValue = parseFloat( innerPropValue );\n\t\t\t\tbreak;\n\n\t\t\tcase 'Color':\n\t\t\tcase 'ColorRGB':\n\t\t\tcase 'Vector3D':\n\t\t\tcase 'Lcl_Translation':\n\t\t\tcase 'Lcl_Rotation':\n\t\t\tcase 'Lcl_Scaling':\n\t\t\t\tinnerPropValue = parseNumberArray( innerPropValue );\n\t\t\t\tbreak;\n\n\t\t}\n\n\t\t// CAUTION: these props must append to parent's parent\n\t\tthis.getPrevNode()[ innerPropName ] = {\n\n\t\t\t'type': innerPropType1,\n\t\t\t'type2': innerPropType2,\n\t\t\t'flag': innerPropFlag,\n\t\t\t'value': innerPropValue\n\n\t\t};\n\n\t\tthis.setCurrentProp( this.getPrevNode(), innerPropName );\n\n\t}\n\n}\n\n// Parse an FBX file in Binary format\nclass BinaryParser {\n\n\tparse( buffer ) {\n\n\t\tconst reader = new BinaryReader( buffer );\n\t\treader.skip( 23 ); // skip magic 23 bytes\n\n\t\tconst version = reader.getUint32();\n\n\t\tif ( version < 6400 ) {\n\n\t\t\tthrow new Error( 'THREE.FBXLoader: FBX version not supported, FileVersion: ' + version );\n\n\t\t}\n\n\t\tconst allNodes = new FBXTree();\n\n\t\twhile ( ! this.endOfContent( reader ) ) {\n\n\t\t\tconst node = this.parseNode( reader, version );\n\t\t\tif ( node !== null ) allNodes.add( node.name, node );\n\n\t\t}\n\n\t\treturn allNodes;\n\n\t}\n\n\t// Check if reader has reached the end of content.\n\tendOfContent( reader ) {\n\n\t\t// footer size: 160bytes + 16-byte alignment padding\n\t\t// - 16bytes: magic\n\t\t// - padding til 16-byte alignment (at least 1byte?)\n\t\t//\t(seems like some exporters embed fixed 15 or 16bytes?)\n\t\t// - 4bytes: magic\n\t\t// - 4bytes: version\n\t\t// - 120bytes: zero\n\t\t// - 16bytes: magic\n\t\tif ( reader.size() % 16 === 0 ) {\n\n\t\t\treturn ( ( reader.getOffset() + 160 + 16 ) & ~ 0xf ) >= reader.size();\n\n\t\t} else {\n\n\t\t\treturn reader.getOffset() + 160 + 16 >= reader.size();\n\n\t\t}\n\n\t}\n\n\t// recursively parse nodes until the end of the file is reached\n\tparseNode( reader, version ) {\n\n\t\tconst node = {};\n\n\t\t// The first three data sizes depends on version.\n\t\tconst endOffset = ( version >= 7500 ) ? reader.getUint64() : reader.getUint32();\n\t\tconst numProperties = ( version >= 7500 ) ? reader.getUint64() : reader.getUint32();\n\n\t\t( version >= 7500 ) ? reader.getUint64() : reader.getUint32(); // the returned propertyListLen is not used\n\n\t\tconst nameLen = reader.getUint8();\n\t\tconst name = reader.getString( nameLen );\n\n\t\t// Regards this node as NULL-record if endOffset is zero\n\t\tif ( endOffset === 0 ) return null;\n\n\t\tconst propertyList = [];\n\n\t\tfor ( let i = 0; i < numProperties; i ++ ) {\n\n\t\t\tpropertyList.push( this.parseProperty( reader ) );\n\n\t\t}\n\n\t\t// Regards the first three elements in propertyList as id, attrName, and attrType\n\t\tconst id = propertyList.length > 0 ? propertyList[ 0 ] : '';\n\t\tconst attrName = propertyList.length > 1 ? propertyList[ 1 ] : '';\n\t\tconst attrType = propertyList.length > 2 ? propertyList[ 2 ] : '';\n\n\t\t// check if this node represents just a single property\n\t\t// like (name, 0) set or (name2, [0, 1, 2]) set of {name: 0, name2: [0, 1, 2]}\n\t\tnode.singleProperty = ( numProperties === 1 && reader.getOffset() === endOffset ) ? true : false;\n\n\t\twhile ( endOffset > reader.getOffset() ) {\n\n\t\t\tconst subNode = this.parseNode( reader, version );\n\n\t\t\tif ( subNode !== null ) this.parseSubNode( name, node, subNode );\n\n\t\t}\n\n\t\tnode.propertyList = propertyList; // raw property list used by parent\n\n\t\tif ( typeof id === 'number' ) node.id = id;\n\t\tif ( attrName !== '' ) node.attrName = attrName;\n\t\tif ( attrType !== '' ) node.attrType = attrType;\n\t\tif ( name !== '' ) node.name = name;\n\n\t\treturn node;\n\n\t}\n\n\tparseSubNode( name, node, subNode ) {\n\n\t\t// special case: child node is single property\n\t\tif ( subNode.singleProperty === true ) {\n\n\t\t\tconst value = subNode.propertyList[ 0 ];\n\n\t\t\tif ( Array.isArray( value ) ) {\n\n\t\t\t\tnode[ subNode.name ] = subNode;\n\n\t\t\t\tsubNode.a = value;\n\n\t\t\t} else {\n\n\t\t\t\tnode[ subNode.name ] = value;\n\n\t\t\t}\n\n\t\t} else if ( name === 'Connections' && subNode.name === 'C' ) {\n\n\t\t\tconst array = [];\n\n\t\t\tsubNode.propertyList.forEach( function ( property, i ) {\n\n\t\t\t\t// first Connection is FBX type (OO, OP, etc.). We'll discard these\n\t\t\t\tif ( i !== 0 ) array.push( property );\n\n\t\t\t} );\n\n\t\t\tif ( node.connections === undefined ) {\n\n\t\t\t\tnode.connections = [];\n\n\t\t\t}\n\n\t\t\tnode.connections.push( array );\n\n\t\t} else if ( subNode.name === 'Properties70' ) {\n\n\t\t\tconst keys = Object.keys( subNode );\n\n\t\t\tkeys.forEach( function ( key ) {\n\n\t\t\t\tnode[ key ] = subNode[ key ];\n\n\t\t\t} );\n\n\t\t} else if ( name === 'Properties70' && subNode.name === 'P' ) {\n\n\t\t\tlet innerPropName = subNode.propertyList[ 0 ];\n\t\t\tlet innerPropType1 = subNode.propertyList[ 1 ];\n\t\t\tconst innerPropType2 = subNode.propertyList[ 2 ];\n\t\t\tconst innerPropFlag = subNode.propertyList[ 3 ];\n\t\t\tlet innerPropValue;\n\n\t\t\tif ( innerPropName.indexOf( 'Lcl ' ) === 0 ) innerPropName = innerPropName.replace( 'Lcl ', 'Lcl_' );\n\t\t\tif ( innerPropType1.indexOf( 'Lcl ' ) === 0 ) innerPropType1 = innerPropType1.replace( 'Lcl ', 'Lcl_' );\n\n\t\t\tif ( innerPropType1 === 'Color' || innerPropType1 === 'ColorRGB' || innerPropType1 === 'Vector' || innerPropType1 === 'Vector3D' || innerPropType1.indexOf( 'Lcl_' ) === 0 ) {\n\n\t\t\t\tinnerPropValue = [\n\t\t\t\t\tsubNode.propertyList[ 4 ],\n\t\t\t\t\tsubNode.propertyList[ 5 ],\n\t\t\t\t\tsubNode.propertyList[ 6 ]\n\t\t\t\t];\n\n\t\t\t} else {\n\n\t\t\t\tinnerPropValue = subNode.propertyList[ 4 ];\n\n\t\t\t}\n\n\t\t\t// this will be copied to parent, see above\n\t\t\tnode[ innerPropName ] = {\n\n\t\t\t\t'type': innerPropType1,\n\t\t\t\t'type2': innerPropType2,\n\t\t\t\t'flag': innerPropFlag,\n\t\t\t\t'value': innerPropValue\n\n\t\t\t};\n\n\t\t} else if ( node[ subNode.name ] === undefined ) {\n\n\t\t\tif ( typeof subNode.id === 'number' ) {\n\n\t\t\t\tnode[ subNode.name ] = {};\n\t\t\t\tnode[ subNode.name ][ subNode.id ] = subNode;\n\n\t\t\t} else {\n\n\t\t\t\tnode[ subNode.name ] = subNode;\n\n\t\t\t}\n\n\t\t} else {\n\n\t\t\tif ( subNode.name === 'PoseNode' ) {\n\n\t\t\t\tif ( ! Array.isArray( node[ subNode.name ] ) ) {\n\n\t\t\t\t\tnode[ subNode.name ] = [ node[ subNode.name ] ];\n\n\t\t\t\t}\n\n\t\t\t\tnode[ subNode.name ].push( subNode );\n\n\t\t\t} else if ( node[ subNode.name ][ subNode.id ] === undefined ) {\n\n\t\t\t\tnode[ subNode.name ][ subNode.id ] = subNode;\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n\tparseProperty( reader ) {\n\n\t\tconst type = reader.getString( 1 );\n\t\tlet length;\n\n\t\tswitch ( type ) {\n\n\t\t\tcase 'C':\n\t\t\t\treturn reader.getBoolean();\n\n\t\t\tcase 'D':\n\t\t\t\treturn reader.getFloat64();\n\n\t\t\tcase 'F':\n\t\t\t\treturn reader.getFloat32();\n\n\t\t\tcase 'I':\n\t\t\t\treturn reader.getInt32();\n\n\t\t\tcase 'L':\n\t\t\t\treturn reader.getInt64();\n\n\t\t\tcase 'R':\n\t\t\t\tlength = reader.getUint32();\n\t\t\t\treturn reader.getArrayBuffer( length );\n\n\t\t\tcase 'S':\n\t\t\t\tlength = reader.getUint32();\n\t\t\t\treturn reader.getString( length );\n\n\t\t\tcase 'Y':\n\t\t\t\treturn reader.getInt16();\n\n\t\t\tcase 'b':\n\t\t\tcase 'c':\n\t\t\tcase 'd':\n\t\t\tcase 'f':\n\t\t\tcase 'i':\n\t\t\tcase 'l':\n\n\t\t\t\tconst arrayLength = reader.getUint32();\n\t\t\t\tconst encoding = reader.getUint32(); // 0: non-compressed, 1: compressed\n\t\t\t\tconst compressedLength = reader.getUint32();\n\n\t\t\t\tif ( encoding === 0 ) {\n\n\t\t\t\t\tswitch ( type ) {\n\n\t\t\t\t\t\tcase 'b':\n\t\t\t\t\t\tcase 'c':\n\t\t\t\t\t\t\treturn reader.getBooleanArray( arrayLength );\n\n\t\t\t\t\t\tcase 'd':\n\t\t\t\t\t\t\treturn reader.getFloat64Array( arrayLength );\n\n\t\t\t\t\t\tcase 'f':\n\t\t\t\t\t\t\treturn reader.getFloat32Array( arrayLength );\n\n\t\t\t\t\t\tcase 'i':\n\t\t\t\t\t\t\treturn reader.getInt32Array( arrayLength );\n\n\t\t\t\t\t\tcase 'l':\n\t\t\t\t\t\t\treturn reader.getInt64Array( arrayLength );\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t\tconst data = fflate.unzlibSync( new Uint8Array( reader.getArrayBuffer( compressedLength ) ) );\n\t\t\t\tconst reader2 = new BinaryReader( data.buffer );\n\n\t\t\t\tswitch ( type ) {\n\n\t\t\t\t\tcase 'b':\n\t\t\t\t\tcase 'c':\n\t\t\t\t\t\treturn reader2.getBooleanArray( arrayLength );\n\n\t\t\t\t\tcase 'd':\n\t\t\t\t\t\treturn reader2.getFloat64Array( arrayLength );\n\n\t\t\t\t\tcase 'f':\n\t\t\t\t\t\treturn reader2.getFloat32Array( arrayLength );\n\n\t\t\t\t\tcase 'i':\n\t\t\t\t\t\treturn reader2.getInt32Array( arrayLength );\n\n\t\t\t\t\tcase 'l':\n\t\t\t\t\t\treturn reader2.getInt64Array( arrayLength );\n\n\t\t\t\t}\n\n\t\t\t\tbreak; // cannot happen but is required by the DeepScan\n\n\t\t\tdefault:\n\t\t\t\tthrow new Error( 'THREE.FBXLoader: Unknown property type ' + type );\n\n\t\t}\n\n\t}\n\n}\n\nclass BinaryReader {\n\n\tconstructor( buffer, littleEndian ) {\n\n\t\tthis.dv = new DataView( buffer );\n\t\tthis.offset = 0;\n\t\tthis.littleEndian = ( littleEndian !== undefined ) ? littleEndian : true;\n\t\tthis._textDecoder = new TextDecoder();\n\n\t}\n\n\tgetOffset() {\n\n\t\treturn this.offset;\n\n\t}\n\n\tsize() {\n\n\t\treturn this.dv.buffer.byteLength;\n\n\t}\n\n\tskip( length ) {\n\n\t\tthis.offset += length;\n\n\t}\n\n\t// seems like true/false representation depends on exporter.\n\t// true: 1 or 'Y'(=0x59), false: 0 or 'T'(=0x54)\n\t// then sees LSB.\n\tgetBoolean() {\n\n\t\treturn ( this.getUint8() & 1 ) === 1;\n\n\t}\n\n\tgetBooleanArray( size ) {\n\n\t\tconst a = [];\n\n\t\tfor ( let i = 0; i < size; i ++ ) {\n\n\t\t\ta.push( this.getBoolean() );\n\n\t\t}\n\n\t\treturn a;\n\n\t}\n\n\tgetUint8() {\n\n\t\tconst value = this.dv.getUint8( this.offset );\n\t\tthis.offset += 1;\n\t\treturn value;\n\n\t}\n\n\tgetInt16() {\n\n\t\tconst value = this.dv.getInt16( this.offset, this.littleEndian );\n\t\tthis.offset += 2;\n\t\treturn value;\n\n\t}\n\n\tgetInt32() {\n\n\t\tconst value = this.dv.getInt32( this.offset, this.littleEndian );\n\t\tthis.offset += 4;\n\t\treturn value;\n\n\t}\n\n\tgetInt32Array( size ) {\n\n\t\tconst a = [];\n\n\t\tfor ( let i = 0; i < size; i ++ ) {\n\n\t\t\ta.push( this.getInt32() );\n\n\t\t}\n\n\t\treturn a;\n\n\t}\n\n\tgetUint32() {\n\n\t\tconst value = this.dv.getUint32( this.offset, this.littleEndian );\n\t\tthis.offset += 4;\n\t\treturn value;\n\n\t}\n\n\t// JavaScript doesn't support 64-bit integer so calculate this here\n\t// 1 << 32 will return 1 so using multiply operation instead here.\n\t// There's a possibility that this method returns wrong value if the value\n\t// is out of the range between Number.MAX_SAFE_INTEGER and Number.MIN_SAFE_INTEGER.\n\t// TODO: safely handle 64-bit integer\n\tgetInt64() {\n\n\t\tlet low, high;\n\n\t\tif ( this.littleEndian ) {\n\n\t\t\tlow = this.getUint32();\n\t\t\thigh = this.getUint32();\n\n\t\t} else {\n\n\t\t\thigh = this.getUint32();\n\t\t\tlow = this.getUint32();\n\n\t\t}\n\n\t\t// calculate negative value\n\t\tif ( high & 0x80000000 ) {\n\n\t\t\thigh = ~ high & 0xFFFFFFFF;\n\t\t\tlow = ~ low & 0xFFFFFFFF;\n\n\t\t\tif ( low === 0xFFFFFFFF ) high = ( high + 1 ) & 0xFFFFFFFF;\n\n\t\t\tlow = ( low + 1 ) & 0xFFFFFFFF;\n\n\t\t\treturn - ( high * 0x100000000 + low );\n\n\t\t}\n\n\t\treturn high * 0x100000000 + low;\n\n\t}\n\n\tgetInt64Array( size ) {\n\n\t\tconst a = [];\n\n\t\tfor ( let i = 0; i < size; i ++ ) {\n\n\t\t\ta.push( this.getInt64() );\n\n\t\t}\n\n\t\treturn a;\n\n\t}\n\n\t// Note: see getInt64() comment\n\tgetUint64() {\n\n\t\tlet low, high;\n\n\t\tif ( this.littleEndian ) {\n\n\t\t\tlow = this.getUint32();\n\t\t\thigh = this.getUint32();\n\n\t\t} else {\n\n\t\t\thigh = this.getUint32();\n\t\t\tlow = this.getUint32();\n\n\t\t}\n\n\t\treturn high * 0x100000000 + low;\n\n\t}\n\n\tgetFloat32() {\n\n\t\tconst value = this.dv.getFloat32( this.offset, this.littleEndian );\n\t\tthis.offset += 4;\n\t\treturn value;\n\n\t}\n\n\tgetFloat32Array( size ) {\n\n\t\tconst a = [];\n\n\t\tfor ( let i = 0; i < size; i ++ ) {\n\n\t\t\ta.push( this.getFloat32() );\n\n\t\t}\n\n\t\treturn a;\n\n\t}\n\n\tgetFloat64() {\n\n\t\tconst value = this.dv.getFloat64( this.offset, this.littleEndian );\n\t\tthis.offset += 8;\n\t\treturn value;\n\n\t}\n\n\tgetFloat64Array( size ) {\n\n\t\tconst a = [];\n\n\t\tfor ( let i = 0; i < size; i ++ ) {\n\n\t\t\ta.push( this.getFloat64() );\n\n\t\t}\n\n\t\treturn a;\n\n\t}\n\n\tgetArrayBuffer( size ) {\n\n\t\tconst value = this.dv.buffer.slice( this.offset, this.offset + size );\n\t\tthis.offset += size;\n\t\treturn value;\n\n\t}\n\n\tgetString( size ) {\n\n\t\tconst start = this.offset;\n\t\tlet a = new Uint8Array( this.dv.buffer, start, size );\n\n\t\tthis.skip( size );\n\n\t\tconst nullByte = a.indexOf( 0 );\n\t\tif ( nullByte >= 0 ) a = new Uint8Array( this.dv.buffer, start, nullByte );\n\n\t\treturn this._textDecoder.decode( a );\n\n\t}\n\n}\n\n// FBXTree holds a representation of the FBX data, returned by the TextParser ( FBX ASCII format)\n// and BinaryParser( FBX Binary format)\nclass FBXTree {\n\n\tadd( key, val ) {\n\n\t\tthis[ key ] = val;\n\n\t}\n\n}\n\n// ************** UTILITY FUNCTIONS **************\n\nfunction isFbxFormatBinary( buffer ) {\n\n\tconst CORRECT = 'Kaydara\\u0020FBX\\u0020Binary\\u0020\\u0020\\0';\n\n\treturn buffer.byteLength >= CORRECT.length && CORRECT === convertArrayBufferToString( buffer, 0, CORRECT.length );\n\n}\n\nfunction isFbxFormatASCII( text ) {\n\n\tconst CORRECT = [ 'K', 'a', 'y', 'd', 'a', 'r', 'a', '\\\\', 'F', 'B', 'X', '\\\\', 'B', 'i', 'n', 'a', 'r', 'y', '\\\\', '\\\\' ];\n\n\tlet cursor = 0;\n\n\tfunction read( offset ) {\n\n\t\tconst result = text[ offset - 1 ];\n\t\ttext = text.slice( cursor + offset );\n\t\tcursor ++;\n\t\treturn result;\n\n\t}\n\n\tfor ( let i = 0; i < CORRECT.length; ++ i ) {\n\n\t\tconst num = read( 1 );\n\t\tif ( num === CORRECT[ i ] ) {\n\n\t\t\treturn false;\n\n\t\t}\n\n\t}\n\n\treturn true;\n\n}\n\nfunction getFbxVersion( text ) {\n\n\tconst versionRegExp = /FBXVersion: (\\d+)/;\n\tconst match = text.match( versionRegExp );\n\n\tif ( match ) {\n\n\t\tconst version = parseInt( match[ 1 ] );\n\t\treturn version;\n\n\t}\n\n\tthrow new Error( 'THREE.FBXLoader: Cannot find the version number for the file given.' );\n\n}\n\n// Converts FBX ticks into real time seconds.\nfunction convertFBXTimeToSeconds( time ) {\n\n\treturn time / 46186158000;\n\n}\n\nconst dataArray = [];\n\n// extracts the data from the correct position in the FBX array based on indexing type\nfunction getData( polygonVertexIndex, polygonIndex, vertexIndex, infoObject ) {\n\n\tlet index;\n\n\tswitch ( infoObject.mappingType ) {\n\n\t\tcase 'ByPolygonVertex' :\n\t\t\tindex = polygonVertexIndex;\n\t\t\tbreak;\n\t\tcase 'ByPolygon' :\n\t\t\tindex = polygonIndex;\n\t\t\tbreak;\n\t\tcase 'ByVertice' :\n\t\t\tindex = vertexIndex;\n\t\t\tbreak;\n\t\tcase 'AllSame' :\n\t\t\tindex = infoObject.indices[ 0 ];\n\t\t\tbreak;\n\t\tdefault :\n\t\t\tconsole.warn( 'THREE.FBXLoader: unknown attribute mapping type ' + infoObject.mappingType );\n\n\t}\n\n\tif ( infoObject.referenceType === 'IndexToDirect' ) index = infoObject.indices[ index ];\n\n\tconst from = index * infoObject.dataSize;\n\tconst to = from + infoObject.dataSize;\n\n\treturn slice( dataArray, infoObject.buffer, from, to );\n\n}\n\nconst tempEuler = new Euler();\nconst tempVec = new Vector3();\n\n// generate transformation from FBX transform data\n// ref: https://help.autodesk.com/view/FBX/2017/ENU/?guid=__files_GUID_10CDD63C_79C1_4F2D_BB28_AD2BE65A02ED_htm\n// ref: http://docs.autodesk.com/FBX/2014/ENU/FBX-SDK-Documentation/index.html?url=cpp_ref/_transformations_2main_8cxx-example.html,topicNumber=cpp_ref__transformations_2main_8cxx_example_htmlfc10a1e1-b18d-4e72-9dc0-70d0f1959f5e\nfunction generateTransform( transformData ) {\n\n\tconst lTranslationM = new Matrix4();\n\tconst lPreRotationM = new Matrix4();\n\tconst lRotationM = new Matrix4();\n\tconst lPostRotationM = new Matrix4();\n\n\tconst lScalingM = new Matrix4();\n\tconst lScalingPivotM = new Matrix4();\n\tconst lScalingOffsetM = new Matrix4();\n\tconst lRotationOffsetM = new Matrix4();\n\tconst lRotationPivotM = new Matrix4();\n\n\tconst lParentGX = new Matrix4();\n\tconst lParentLX = new Matrix4();\n\tconst lGlobalT = new Matrix4();\n\n\tconst inheritType = ( transformData.inheritType ) ? transformData.inheritType : 0;\n\n\tif ( transformData.translation ) lTranslationM.setPosition( tempVec.fromArray( transformData.translation ) );\n\n\tif ( transformData.preRotation ) {\n\n\t\tconst array = transformData.preRotation.map( MathUtils.degToRad );\n\t\tarray.push( transformData.eulerOrder || Euler.DEFAULT_ORDER );\n\t\tlPreRotationM.makeRotationFromEuler( tempEuler.fromArray( array ) );\n\n\t}\n\n\tif ( transformData.rotation ) {\n\n\t\tconst array = transformData.rotation.map( MathUtils.degToRad );\n\t\tarray.push( transformData.eulerOrder || Euler.DEFAULT_ORDER );\n\t\tlRotationM.makeRotationFromEuler( tempEuler.fromArray( array ) );\n\n\t}\n\n\tif ( transformData.postRotation ) {\n\n\t\tconst array = transformData.postRotation.map( MathUtils.degToRad );\n\t\tarray.push( transformData.eulerOrder || Euler.DEFAULT_ORDER );\n\t\tlPostRotationM.makeRotationFromEuler( tempEuler.fromArray( array ) );\n\t\tlPostRotationM.invert();\n\n\t}\n\n\tif ( transformData.scale ) lScalingM.scale( tempVec.fromArray( transformData.scale ) );\n\n\t// Pivots and offsets\n\tif ( transformData.scalingOffset ) lScalingOffsetM.setPosition( tempVec.fromArray( transformData.scalingOffset ) );\n\tif ( transformData.scalingPivot ) lScalingPivotM.setPosition( tempVec.fromArray( transformData.scalingPivot ) );\n\tif ( transformData.rotationOffset ) lRotationOffsetM.setPosition( tempVec.fromArray( transformData.rotationOffset ) );\n\tif ( transformData.rotationPivot ) lRotationPivotM.setPosition( tempVec.fromArray( transformData.rotationPivot ) );\n\n\t// parent transform\n\tif ( transformData.parentMatrixWorld ) {\n\n\t\tlParentLX.copy( transformData.parentMatrix );\n\t\tlParentGX.copy( transformData.parentMatrixWorld );\n\n\t}\n\n\tconst lLRM = lPreRotationM.clone().multiply( lRotationM ).multiply( lPostRotationM );\n\t// Global Rotation\n\tconst lParentGRM = new Matrix4();\n\tlParentGRM.extractRotation( lParentGX );\n\n\t// Global Shear*Scaling\n\tconst lParentTM = new Matrix4();\n\tlParentTM.copyPosition( lParentGX );\n\n\tconst lParentGRSM = lParentTM.clone().invert().multiply( lParentGX );\n\tconst lParentGSM = lParentGRM.clone().invert().multiply( lParentGRSM );\n\tconst lLSM = lScalingM;\n\n\tconst lGlobalRS = new Matrix4();\n\n\tif ( inheritType === 0 ) {\n\n\t\tlGlobalRS.copy( lParentGRM ).multiply( lLRM ).multiply( lParentGSM ).multiply( lLSM );\n\n\t} else if ( inheritType === 1 ) {\n\n\t\tlGlobalRS.copy( lParentGRM ).multiply( lParentGSM ).multiply( lLRM ).multiply( lLSM );\n\n\t} else {\n\n\t\tconst lParentLSM = new Matrix4().scale( new Vector3().setFromMatrixScale( lParentLX ) );\n\t\tconst lParentLSM_inv = lParentLSM.clone().invert();\n\t\tconst lParentGSM_noLocal = lParentGSM.clone().multiply( lParentLSM_inv );\n\n\t\tlGlobalRS.copy( lParentGRM ).multiply( lLRM ).multiply( lParentGSM_noLocal ).multiply( lLSM );\n\n\t}\n\n\tconst lRotationPivotM_inv = lRotationPivotM.clone().invert();\n\tconst lScalingPivotM_inv = lScalingPivotM.clone().invert();\n\t// Calculate the local transform matrix\n\tlet lTransform = lTranslationM.clone().multiply( lRotationOffsetM ).multiply( lRotationPivotM ).multiply( lPreRotationM ).multiply( lRotationM ).multiply( lPostRotationM ).multiply( lRotationPivotM_inv ).multiply( lScalingOffsetM ).multiply( lScalingPivotM ).multiply( lScalingM ).multiply( lScalingPivotM_inv );\n\n\tconst lLocalTWithAllPivotAndOffsetInfo = new Matrix4().copyPosition( lTransform );\n\n\tconst lGlobalTranslation = lParentGX.clone().multiply( lLocalTWithAllPivotAndOffsetInfo );\n\tlGlobalT.copyPosition( lGlobalTranslation );\n\n\tlTransform = lGlobalT.clone().multiply( lGlobalRS );\n\n\t// from global to local\n\tlTransform.premultiply( lParentGX.invert() );\n\n\treturn lTransform;\n\n}\n\n// Returns the three.js intrinsic Euler order corresponding to FBX extrinsic Euler order\n// ref: http://help.autodesk.com/view/FBX/2017/ENU/?guid=__cpp_ref_class_fbx_euler_html\nfunction getEulerOrder( order ) {\n\n\torder = order || 0;\n\n\tconst enums = [\n\t\t'ZYX', // -> XYZ extrinsic\n\t\t'YZX', // -> XZY extrinsic\n\t\t'XZY', // -> YZX extrinsic\n\t\t'ZXY', // -> YXZ extrinsic\n\t\t'YXZ', // -> ZXY extrinsic\n\t\t'XYZ', // -> ZYX extrinsic\n\t\t//'SphericXYZ', // not possible to support\n\t];\n\n\tif ( order === 6 ) {\n\n\t\tconsole.warn( 'THREE.FBXLoader: unsupported Euler Order: Spherical XYZ. Animations and rotations may be incorrect.' );\n\t\treturn enums[ 0 ];\n\n\t}\n\n\treturn enums[ order ];\n\n}\n\n// Parses comma separated list of numbers and returns them an array.\n// Used internally by the TextParser\nfunction parseNumberArray( value ) {\n\n\tconst array = value.split( ',' ).map( function ( val ) {\n\n\t\treturn parseFloat( val );\n\n\t} );\n\n\treturn array;\n\n}\n\nfunction convertArrayBufferToString( buffer, from, to ) {\n\n\tif ( from === undefined ) from = 0;\n\tif ( to === undefined ) to = buffer.byteLength;\n\n\treturn new TextDecoder().decode( new Uint8Array( buffer, from, to ) );\n\n}\n\nfunction append( a, b ) {\n\n\tfor ( let i = 0, j = a.length, l = b.length; i < l; i ++, j ++ ) {\n\n\t\ta[ j ] = b[ i ];\n\n\t}\n\n}\n\nfunction slice( a, b, from, to ) {\n\n\tfor ( let i = from, j = 0; i < to; i ++, j ++ ) {\n\n\t\ta[ j ] = b[ i ];\n\n\t}\n\n\treturn a;\n\n}\n\n\nexport { FBXLoader };\n", "import {\n\tBufferAttribute,\n\tBufferGeometry,\n\tFloat32BufferAttribute,\n\tInstancedBufferAttribute,\n\tInterleavedBuffer,\n\tInterleavedBufferAttribute,\n\tTriangleFanDrawMode,\n\tTriangleStripDrawMode,\n\tTrianglesDrawMode,\n\tVector3,\n} from 'three';\n\nfunction computeMikkTSpaceTangents( geometry, MikkTSpace, negateSign = true ) {\n\n\tif ( ! MikkTSpace || ! MikkTSpace.isReady ) {\n\n\t\tthrow new Error( 'BufferGeometryUtils: Initialized MikkTSpace library required.' );\n\n\t}\n\n\tif ( ! geometry.hasAttribute( 'position' ) || ! geometry.hasAttribute( 'normal' ) || ! geometry.hasAttribute( 'uv' ) ) {\n\n\t\tthrow new Error( 'BufferGeometryUtils: Tangents require \"position\", \"normal\", and \"uv\" attributes.' );\n\n\t}\n\n\tfunction getAttributeArray( attribute ) {\n\n\t\tif ( attribute.normalized || attribute.isInterleavedBufferAttribute ) {\n\n\t\t\tconst dstArray = new Float32Array( attribute.count * attribute.itemSize );\n\n\t\t\tfor ( let i = 0, j = 0; i < attribute.count; i ++ ) {\n\n\t\t\t\tdstArray[ j ++ ] = attribute.getX( i );\n\t\t\t\tdstArray[ j ++ ] = attribute.getY( i );\n\n\t\t\t\tif ( attribute.itemSize > 2 ) {\n\n\t\t\t\t\tdstArray[ j ++ ] = attribute.getZ( i );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\treturn dstArray;\n\n\t\t}\n\n\t\tif ( attribute.array instanceof Float32Array ) {\n\n\t\t\treturn attribute.array;\n\n\t\t}\n\n\t\treturn new Float32Array( attribute.array );\n\n\t}\n\n\t// MikkTSpace algorithm requires non-indexed input.\n\n\tconst _geometry = geometry.index ? geometry.toNonIndexed() : geometry;\n\n\t// Compute vertex tangents.\n\n\tconst tangents = MikkTSpace.generateTangents(\n\n\t\tgetAttributeArray( _geometry.attributes.position ),\n\t\tgetAttributeArray( _geometry.attributes.normal ),\n\t\tgetAttributeArray( _geometry.attributes.uv )\n\n\t);\n\n\t// Texture coordinate convention of glTF differs from the apparent\n\t// default of the MikkTSpace library; .w component must be flipped.\n\n\tif ( negateSign ) {\n\n\t\tfor ( let i = 3; i < tangents.length; i += 4 ) {\n\n\t\t\ttangents[ i ] *= - 1;\n\n\t\t}\n\n\t}\n\n\t//\n\n\t_geometry.setAttribute( 'tangent', new BufferAttribute( tangents, 4 ) );\n\n\tif ( geometry !== _geometry ) {\n\n\t\tgeometry.copy( _geometry );\n\n\t}\n\n\treturn geometry;\n\n}\n\n/**\n * @param {Array} geometries\n * @param {Boolean} useGroups\n * @return {BufferGeometry}\n */\nfunction mergeGeometries( geometries, useGroups = false ) {\n\n\tconst isIndexed = geometries[ 0 ].index !== null;\n\n\tconst attributesUsed = new Set( Object.keys( geometries[ 0 ].attributes ) );\n\tconst morphAttributesUsed = new Set( Object.keys( geometries[ 0 ].morphAttributes ) );\n\n\tconst attributes = {};\n\tconst morphAttributes = {};\n\n\tconst morphTargetsRelative = geometries[ 0 ].morphTargetsRelative;\n\n\tconst mergedGeometry = new BufferGeometry();\n\n\tlet offset = 0;\n\n\tfor ( let i = 0; i < geometries.length; ++ i ) {\n\n\t\tconst geometry = geometries[ i ];\n\t\tlet attributesCount = 0;\n\n\t\t// ensure that all geometries are indexed, or none\n\n\t\tif ( isIndexed !== ( geometry.index !== null ) ) {\n\n\t\t\tconsole.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '. All geometries must have compatible attributes; make sure index attribute exists among all geometries, or in none of them.' );\n\t\t\treturn null;\n\n\t\t}\n\n\t\t// gather attributes, exit early if they're different\n\n\t\tfor ( const name in geometry.attributes ) {\n\n\t\t\tif ( ! attributesUsed.has( name ) ) {\n\n\t\t\t\tconsole.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '. All geometries must have compatible attributes; make sure \"' + name + '\" attribute exists among all geometries, or in none of them.' );\n\t\t\t\treturn null;\n\n\t\t\t}\n\n\t\t\tif ( attributes[ name ] === undefined ) attributes[ name ] = [];\n\n\t\t\tattributes[ name ].push( geometry.attributes[ name ] );\n\n\t\t\tattributesCount ++;\n\n\t\t}\n\n\t\t// ensure geometries have the same number of attributes\n\n\t\tif ( attributesCount !== attributesUsed.size ) {\n\n\t\t\tconsole.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '. Make sure all geometries have the same number of attributes.' );\n\t\t\treturn null;\n\n\t\t}\n\n\t\t// gather morph attributes, exit early if they're different\n\n\t\tif ( morphTargetsRelative !== geometry.morphTargetsRelative ) {\n\n\t\t\tconsole.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '. .morphTargetsRelative must be consistent throughout all geometries.' );\n\t\t\treturn null;\n\n\t\t}\n\n\t\tfor ( const name in geometry.morphAttributes ) {\n\n\t\t\tif ( ! morphAttributesUsed.has( name ) ) {\n\n\t\t\t\tconsole.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '. .morphAttributes must be consistent throughout all geometries.' );\n\t\t\t\treturn null;\n\n\t\t\t}\n\n\t\t\tif ( morphAttributes[ name ] === undefined ) morphAttributes[ name ] = [];\n\n\t\t\tmorphAttributes[ name ].push( geometry.morphAttributes[ name ] );\n\n\t\t}\n\n\t\tif ( useGroups ) {\n\n\t\t\tlet count;\n\n\t\t\tif ( isIndexed ) {\n\n\t\t\t\tcount = geometry.index.count;\n\n\t\t\t} else if ( geometry.attributes.position !== undefined ) {\n\n\t\t\t\tcount = geometry.attributes.position.count;\n\n\t\t\t} else {\n\n\t\t\t\tconsole.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '. The geometry must have either an index or a position attribute' );\n\t\t\t\treturn null;\n\n\t\t\t}\n\n\t\t\tmergedGeometry.addGroup( offset, count, i );\n\n\t\t\toffset += count;\n\n\t\t}\n\n\t}\n\n\t// merge indices\n\n\tif ( isIndexed ) {\n\n\t\tlet indexOffset = 0;\n\t\tconst mergedIndex = [];\n\n\t\tfor ( let i = 0; i < geometries.length; ++ i ) {\n\n\t\t\tconst index = geometries[ i ].index;\n\n\t\t\tfor ( let j = 0; j < index.count; ++ j ) {\n\n\t\t\t\tmergedIndex.push( index.getX( j ) + indexOffset );\n\n\t\t\t}\n\n\t\t\tindexOffset += geometries[ i ].attributes.position.count;\n\n\t\t}\n\n\t\tmergedGeometry.setIndex( mergedIndex );\n\n\t}\n\n\t// merge attributes\n\n\tfor ( const name in attributes ) {\n\n\t\tconst mergedAttribute = mergeAttributes( attributes[ name ] );\n\n\t\tif ( ! mergedAttribute ) {\n\n\t\t\tconsole.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed while trying to merge the ' + name + ' attribute.' );\n\t\t\treturn null;\n\n\t\t}\n\n\t\tmergedGeometry.setAttribute( name, mergedAttribute );\n\n\t}\n\n\t// merge morph attributes\n\n\tfor ( const name in morphAttributes ) {\n\n\t\tconst numMorphTargets = morphAttributes[ name ][ 0 ].length;\n\n\t\tif ( numMorphTargets === 0 ) break;\n\n\t\tmergedGeometry.morphAttributes = mergedGeometry.morphAttributes || {};\n\t\tmergedGeometry.morphAttributes[ name ] = [];\n\n\t\tfor ( let i = 0; i < numMorphTargets; ++ i ) {\n\n\t\t\tconst morphAttributesToMerge = [];\n\n\t\t\tfor ( let j = 0; j < morphAttributes[ name ].length; ++ j ) {\n\n\t\t\t\tmorphAttributesToMerge.push( morphAttributes[ name ][ j ][ i ] );\n\n\t\t\t}\n\n\t\t\tconst mergedMorphAttribute = mergeAttributes( morphAttributesToMerge );\n\n\t\t\tif ( ! mergedMorphAttribute ) {\n\n\t\t\t\tconsole.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed while trying to merge the ' + name + ' morphAttribute.' );\n\t\t\t\treturn null;\n\n\t\t\t}\n\n\t\t\tmergedGeometry.morphAttributes[ name ].push( mergedMorphAttribute );\n\n\t\t}\n\n\t}\n\n\treturn mergedGeometry;\n\n}\n\n/**\n * @param {Array} attributes\n * @return {BufferAttribute}\n */\nfunction mergeAttributes( attributes ) {\n\n\tlet TypedArray;\n\tlet itemSize;\n\tlet normalized;\n\tlet gpuType = - 1;\n\tlet arrayLength = 0;\n\n\tfor ( let i = 0; i < attributes.length; ++ i ) {\n\n\t\tconst attribute = attributes[ i ];\n\n\t\tif ( TypedArray === undefined ) TypedArray = attribute.array.constructor;\n\t\tif ( TypedArray !== attribute.array.constructor ) {\n\n\t\t\tconsole.error( 'THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.array must be of consistent array types across matching attributes.' );\n\t\t\treturn null;\n\n\t\t}\n\n\t\tif ( itemSize === undefined ) itemSize = attribute.itemSize;\n\t\tif ( itemSize !== attribute.itemSize ) {\n\n\t\t\tconsole.error( 'THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.itemSize must be consistent across matching attributes.' );\n\t\t\treturn null;\n\n\t\t}\n\n\t\tif ( normalized === undefined ) normalized = attribute.normalized;\n\t\tif ( normalized !== attribute.normalized ) {\n\n\t\t\tconsole.error( 'THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.normalized must be consistent across matching attributes.' );\n\t\t\treturn null;\n\n\t\t}\n\n\t\tif ( gpuType === - 1 ) gpuType = attribute.gpuType;\n\t\tif ( gpuType !== attribute.gpuType ) {\n\n\t\t\tconsole.error( 'THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.gpuType must be consistent across matching attributes.' );\n\t\t\treturn null;\n\n\t\t}\n\n\t\tarrayLength += attribute.count * itemSize;\n\n\t}\n\n\tconst array = new TypedArray( arrayLength );\n\tconst result = new BufferAttribute( array, itemSize, normalized );\n\tlet offset = 0;\n\n\tfor ( let i = 0; i < attributes.length; ++ i ) {\n\n\t\tconst attribute = attributes[ i ];\n\t\tif ( attribute.isInterleavedBufferAttribute ) {\n\n\t\t\tconst tupleOffset = offset / itemSize;\n\t\t\tfor ( let j = 0, l = attribute.count; j < l; j ++ ) {\n\n\t\t\t\tfor ( let c = 0; c < itemSize; c ++ ) {\n\n\t\t\t\t\tconst value = attribute.getComponent( j, c );\n\t\t\t\t\tresult.setComponent( j + tupleOffset, c, value );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t} else {\n\n\t\t\tarray.set( attribute.array, offset );\n\n\t\t}\n\n\t\toffset += attribute.count * itemSize;\n\n\t}\n\n\tif ( gpuType !== undefined ) {\n\n\t\tresult.gpuType = gpuType;\n\n\t}\n\n\treturn result;\n\n}\n\n/**\n * @param {BufferAttribute}\n * @return {BufferAttribute}\n */\nexport function deepCloneAttribute( attribute ) {\n\n\tif ( attribute.isInstancedInterleavedBufferAttribute || attribute.isInterleavedBufferAttribute ) {\n\n\t\treturn deinterleaveAttribute( attribute );\n\n\t}\n\n\tif ( attribute.isInstancedBufferAttribute ) {\n\n\t\treturn new InstancedBufferAttribute().copy( attribute );\n\n\t}\n\n\treturn new BufferAttribute().copy( attribute );\n\n}\n\n/**\n * @param {Array} attributes\n * @return {Array}\n */\nfunction interleaveAttributes( attributes ) {\n\n\t// Interleaves the provided attributes into an InterleavedBuffer and returns\n\t// a set of InterleavedBufferAttributes for each attribute\n\tlet TypedArray;\n\tlet arrayLength = 0;\n\tlet stride = 0;\n\n\t// calculate the length and type of the interleavedBuffer\n\tfor ( let i = 0, l = attributes.length; i < l; ++ i ) {\n\n\t\tconst attribute = attributes[ i ];\n\n\t\tif ( TypedArray === undefined ) TypedArray = attribute.array.constructor;\n\t\tif ( TypedArray !== attribute.array.constructor ) {\n\n\t\t\tconsole.error( 'AttributeBuffers of different types cannot be interleaved' );\n\t\t\treturn null;\n\n\t\t}\n\n\t\tarrayLength += attribute.array.length;\n\t\tstride += attribute.itemSize;\n\n\t}\n\n\t// Create the set of buffer attributes\n\tconst interleavedBuffer = new InterleavedBuffer( new TypedArray( arrayLength ), stride );\n\tlet offset = 0;\n\tconst res = [];\n\tconst getters = [ 'getX', 'getY', 'getZ', 'getW' ];\n\tconst setters = [ 'setX', 'setY', 'setZ', 'setW' ];\n\n\tfor ( let j = 0, l = attributes.length; j < l; j ++ ) {\n\n\t\tconst attribute = attributes[ j ];\n\t\tconst itemSize = attribute.itemSize;\n\t\tconst count = attribute.count;\n\t\tconst iba = new InterleavedBufferAttribute( interleavedBuffer, itemSize, offset, attribute.normalized );\n\t\tres.push( iba );\n\n\t\toffset += itemSize;\n\n\t\t// Move the data for each attribute into the new interleavedBuffer\n\t\t// at the appropriate offset\n\t\tfor ( let c = 0; c < count; c ++ ) {\n\n\t\t\tfor ( let k = 0; k < itemSize; k ++ ) {\n\n\t\t\t\tiba[ setters[ k ] ]( c, attribute[ getters[ k ] ]( c ) );\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n\treturn res;\n\n}\n\n// returns a new, non-interleaved version of the provided attribute\nexport function deinterleaveAttribute( attribute ) {\n\n\tconst cons = attribute.data.array.constructor;\n\tconst count = attribute.count;\n\tconst itemSize = attribute.itemSize;\n\tconst normalized = attribute.normalized;\n\n\tconst array = new cons( count * itemSize );\n\tlet newAttribute;\n\tif ( attribute.isInstancedInterleavedBufferAttribute ) {\n\n\t\tnewAttribute = new InstancedBufferAttribute( array, itemSize, normalized, attribute.meshPerAttribute );\n\n\t} else {\n\n\t\tnewAttribute = new BufferAttribute( array, itemSize, normalized );\n\n\t}\n\n\tfor ( let i = 0; i < count; i ++ ) {\n\n\t\tnewAttribute.setX( i, attribute.getX( i ) );\n\n\t\tif ( itemSize >= 2 ) {\n\n\t\t\tnewAttribute.setY( i, attribute.getY( i ) );\n\n\t\t}\n\n\t\tif ( itemSize >= 3 ) {\n\n\t\t\tnewAttribute.setZ( i, attribute.getZ( i ) );\n\n\t\t}\n\n\t\tif ( itemSize >= 4 ) {\n\n\t\t\tnewAttribute.setW( i, attribute.getW( i ) );\n\n\t\t}\n\n\t}\n\n\treturn newAttribute;\n\n}\n\n// deinterleaves all attributes on the geometry\nexport function deinterleaveGeometry( geometry ) {\n\n\tconst attributes = geometry.attributes;\n\tconst morphTargets = geometry.morphTargets;\n\tconst attrMap = new Map();\n\n\tfor ( const key in attributes ) {\n\n\t\tconst attr = attributes[ key ];\n\t\tif ( attr.isInterleavedBufferAttribute ) {\n\n\t\t\tif ( ! attrMap.has( attr ) ) {\n\n\t\t\t\tattrMap.set( attr, deinterleaveAttribute( attr ) );\n\n\t\t\t}\n\n\t\t\tattributes[ key ] = attrMap.get( attr );\n\n\t\t}\n\n\t}\n\n\tfor ( const key in morphTargets ) {\n\n\t\tconst attr = morphTargets[ key ];\n\t\tif ( attr.isInterleavedBufferAttribute ) {\n\n\t\t\tif ( ! attrMap.has( attr ) ) {\n\n\t\t\t\tattrMap.set( attr, deinterleaveAttribute( attr ) );\n\n\t\t\t}\n\n\t\t\tmorphTargets[ key ] = attrMap.get( attr );\n\n\t\t}\n\n\t}\n\n}\n\n/**\n * @param {BufferGeometry} geometry\n * @return {number}\n */\nfunction estimateBytesUsed( geometry ) {\n\n\t// Return the estimated memory used by this geometry in bytes\n\t// Calculate using itemSize, count, and BYTES_PER_ELEMENT to account\n\t// for InterleavedBufferAttributes.\n\tlet mem = 0;\n\tfor ( const name in geometry.attributes ) {\n\n\t\tconst attr = geometry.getAttribute( name );\n\t\tmem += attr.count * attr.itemSize * attr.array.BYTES_PER_ELEMENT;\n\n\t}\n\n\tconst indices = geometry.getIndex();\n\tmem += indices ? indices.count * indices.itemSize * indices.array.BYTES_PER_ELEMENT : 0;\n\treturn mem;\n\n}\n\n/**\n * @param {BufferGeometry} geometry\n * @param {number} tolerance\n * @return {BufferGeometry}\n */\nfunction mergeVertices( geometry, tolerance = 1e-4 ) {\n\n\ttolerance = Math.max( tolerance, Number.EPSILON );\n\n\t// Generate an index buffer if the geometry doesn't have one, or optimize it\n\t// if it's already available.\n\tconst hashToIndex = {};\n\tconst indices = geometry.getIndex();\n\tconst positions = geometry.getAttribute( 'position' );\n\tconst vertexCount = indices ? indices.count : positions.count;\n\n\t// next value for triangle indices\n\tlet nextIndex = 0;\n\n\t// attributes and new attribute arrays\n\tconst attributeNames = Object.keys( geometry.attributes );\n\tconst tmpAttributes = {};\n\tconst tmpMorphAttributes = {};\n\tconst newIndices = [];\n\tconst getters = [ 'getX', 'getY', 'getZ', 'getW' ];\n\tconst setters = [ 'setX', 'setY', 'setZ', 'setW' ];\n\n\t// Initialize the arrays, allocating space conservatively. Extra\n\t// space will be trimmed in the last step.\n\tfor ( let i = 0, l = attributeNames.length; i < l; i ++ ) {\n\n\t\tconst name = attributeNames[ i ];\n\t\tconst attr = geometry.attributes[ name ];\n\n\t\ttmpAttributes[ name ] = new BufferAttribute(\n\t\t\tnew attr.array.constructor( attr.count * attr.itemSize ),\n\t\t\tattr.itemSize,\n\t\t\tattr.normalized\n\t\t);\n\n\t\tconst morphAttr = geometry.morphAttributes[ name ];\n\t\tif ( morphAttr ) {\n\n\t\t\ttmpMorphAttributes[ name ] = new BufferAttribute(\n\t\t\t\tnew morphAttr.array.constructor( morphAttr.count * morphAttr.itemSize ),\n\t\t\t\tmorphAttr.itemSize,\n\t\t\t\tmorphAttr.normalized\n\t\t\t);\n\n\t\t}\n\n\t}\n\n\t// convert the error tolerance to an amount of decimal places to truncate to\n\tconst halfTolerance = tolerance * 0.5;\n\tconst exponent = Math.log10( 1 / tolerance );\n\tconst hashMultiplier = Math.pow( 10, exponent );\n\tconst hashAdditive = halfTolerance * hashMultiplier;\n\tfor ( let i = 0; i < vertexCount; i ++ ) {\n\n\t\tconst index = indices ? indices.getX( i ) : i;\n\n\t\t// Generate a hash for the vertex attributes at the current index 'i'\n\t\tlet hash = '';\n\t\tfor ( let j = 0, l = attributeNames.length; j < l; j ++ ) {\n\n\t\t\tconst name = attributeNames[ j ];\n\t\t\tconst attribute = geometry.getAttribute( name );\n\t\t\tconst itemSize = attribute.itemSize;\n\n\t\t\tfor ( let k = 0; k < itemSize; k ++ ) {\n\n\t\t\t\t// double tilde truncates the decimal value\n\t\t\t\thash += `${ ~ ~ ( attribute[ getters[ k ] ]( index ) * hashMultiplier + hashAdditive ) },`;\n\n\t\t\t}\n\n\t\t}\n\n\t\t// Add another reference to the vertex if it's already\n\t\t// used by another index\n\t\tif ( hash in hashToIndex ) {\n\n\t\t\tnewIndices.push( hashToIndex[ hash ] );\n\n\t\t} else {\n\n\t\t\t// copy data to the new index in the temporary attributes\n\t\t\tfor ( let j = 0, l = attributeNames.length; j < l; j ++ ) {\n\n\t\t\t\tconst name = attributeNames[ j ];\n\t\t\t\tconst attribute = geometry.getAttribute( name );\n\t\t\t\tconst morphAttr = geometry.morphAttributes[ name ];\n\t\t\t\tconst itemSize = attribute.itemSize;\n\t\t\t\tconst newarray = tmpAttributes[ name ];\n\t\t\t\tconst newMorphArrays = tmpMorphAttributes[ name ];\n\n\t\t\t\tfor ( let k = 0; k < itemSize; k ++ ) {\n\n\t\t\t\t\tconst getterFunc = getters[ k ];\n\t\t\t\t\tconst setterFunc = setters[ k ];\n\t\t\t\t\tnewarray[ setterFunc ]( nextIndex, attribute[ getterFunc ]( index ) );\n\n\t\t\t\t\tif ( morphAttr ) {\n\n\t\t\t\t\t\tfor ( let m = 0, ml = morphAttr.length; m < ml; m ++ ) {\n\n\t\t\t\t\t\t\tnewMorphArrays[ m ][ setterFunc ]( nextIndex, morphAttr[ m ][ getterFunc ]( index ) );\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\thashToIndex[ hash ] = nextIndex;\n\t\t\tnewIndices.push( nextIndex );\n\t\t\tnextIndex ++;\n\n\t\t}\n\n\t}\n\n\t// generate result BufferGeometry\n\tconst result = geometry.clone();\n\tfor ( const name in geometry.attributes ) {\n\n\t\tconst tmpAttribute = tmpAttributes[ name ];\n\n\t\tresult.setAttribute( name, new BufferAttribute(\n\t\t\ttmpAttribute.array.slice( 0, nextIndex * tmpAttribute.itemSize ),\n\t\t\ttmpAttribute.itemSize,\n\t\t\ttmpAttribute.normalized,\n\t\t) );\n\n\t\tif ( ! ( name in tmpMorphAttributes ) ) continue;\n\n\t\tfor ( let j = 0; j < tmpMorphAttributes[ name ].length; j ++ ) {\n\n\t\t\tconst tmpMorphAttribute = tmpMorphAttributes[ name ][ j ];\n\n\t\t\tresult.morphAttributes[ name ][ j ] = new BufferAttribute(\n\t\t\t\ttmpMorphAttribute.array.slice( 0, nextIndex * tmpMorphAttribute.itemSize ),\n\t\t\t\ttmpMorphAttribute.itemSize,\n\t\t\t\ttmpMorphAttribute.normalized,\n\t\t\t);\n\n\t\t}\n\n\t}\n\n\t// indices\n\n\tresult.setIndex( newIndices );\n\n\treturn result;\n\n}\n\n/**\n * @param {BufferGeometry} geometry\n * @param {number} drawMode\n * @return {BufferGeometry}\n */\nfunction toTrianglesDrawMode( geometry, drawMode ) {\n\n\tif ( drawMode === TrianglesDrawMode ) {\n\n\t\tconsole.warn( 'THREE.BufferGeometryUtils.toTrianglesDrawMode(): Geometry already defined as triangles.' );\n\t\treturn geometry;\n\n\t}\n\n\tif ( drawMode === TriangleFanDrawMode || drawMode === TriangleStripDrawMode ) {\n\n\t\tlet index = geometry.getIndex();\n\n\t\t// generate index if not present\n\n\t\tif ( index === null ) {\n\n\t\t\tconst indices = [];\n\n\t\t\tconst position = geometry.getAttribute( 'position' );\n\n\t\t\tif ( position !== undefined ) {\n\n\t\t\t\tfor ( let i = 0; i < position.count; i ++ ) {\n\n\t\t\t\t\tindices.push( i );\n\n\t\t\t\t}\n\n\t\t\t\tgeometry.setIndex( indices );\n\t\t\t\tindex = geometry.getIndex();\n\n\t\t\t} else {\n\n\t\t\t\tconsole.error( 'THREE.BufferGeometryUtils.toTrianglesDrawMode(): Undefined position attribute. Processing not possible.' );\n\t\t\t\treturn geometry;\n\n\t\t\t}\n\n\t\t}\n\n\t\t//\n\n\t\tconst numberOfTriangles = index.count - 2;\n\t\tconst newIndices = [];\n\n\t\tif ( drawMode === TriangleFanDrawMode ) {\n\n\t\t\t// gl.TRIANGLE_FAN\n\n\t\t\tfor ( let i = 1; i <= numberOfTriangles; i ++ ) {\n\n\t\t\t\tnewIndices.push( index.getX( 0 ) );\n\t\t\t\tnewIndices.push( index.getX( i ) );\n\t\t\t\tnewIndices.push( index.getX( i + 1 ) );\n\n\t\t\t}\n\n\t\t} else {\n\n\t\t\t// gl.TRIANGLE_STRIP\n\n\t\t\tfor ( let i = 0; i < numberOfTriangles; i ++ ) {\n\n\t\t\t\tif ( i % 2 === 0 ) {\n\n\t\t\t\t\tnewIndices.push( index.getX( i ) );\n\t\t\t\t\tnewIndices.push( index.getX( i + 1 ) );\n\t\t\t\t\tnewIndices.push( index.getX( i + 2 ) );\n\n\t\t\t\t} else {\n\n\t\t\t\t\tnewIndices.push( index.getX( i + 2 ) );\n\t\t\t\t\tnewIndices.push( index.getX( i + 1 ) );\n\t\t\t\t\tnewIndices.push( index.getX( i ) );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t\tif ( ( newIndices.length / 3 ) !== numberOfTriangles ) {\n\n\t\t\tconsole.error( 'THREE.BufferGeometryUtils.toTrianglesDrawMode(): Unable to generate correct amount of triangles.' );\n\n\t\t}\n\n\t\t// build final geometry\n\n\t\tconst newGeometry = geometry.clone();\n\t\tnewGeometry.setIndex( newIndices );\n\t\tnewGeometry.clearGroups();\n\n\t\treturn newGeometry;\n\n\t} else {\n\n\t\tconsole.error( 'THREE.BufferGeometryUtils.toTrianglesDrawMode(): Unknown draw mode:', drawMode );\n\t\treturn geometry;\n\n\t}\n\n}\n\n/**\n * Calculates the morphed attributes of a morphed/skinned BufferGeometry.\n * Helpful for Raytracing or Decals.\n * @param {Mesh | Line | Points} object An instance of Mesh, Line or Points.\n * @return {Object} An Object with original position/normal attributes and morphed ones.\n */\nfunction computeMorphedAttributes( object ) {\n\n\tconst _vA = new Vector3();\n\tconst _vB = new Vector3();\n\tconst _vC = new Vector3();\n\n\tconst _tempA = new Vector3();\n\tconst _tempB = new Vector3();\n\tconst _tempC = new Vector3();\n\n\tconst _morphA = new Vector3();\n\tconst _morphB = new Vector3();\n\tconst _morphC = new Vector3();\n\n\tfunction _calculateMorphedAttributeData(\n\t\tobject,\n\t\tattribute,\n\t\tmorphAttribute,\n\t\tmorphTargetsRelative,\n\t\ta,\n\t\tb,\n\t\tc,\n\t\tmodifiedAttributeArray\n\t) {\n\n\t\t_vA.fromBufferAttribute( attribute, a );\n\t\t_vB.fromBufferAttribute( attribute, b );\n\t\t_vC.fromBufferAttribute( attribute, c );\n\n\t\tconst morphInfluences = object.morphTargetInfluences;\n\n\t\tif ( morphAttribute && morphInfluences ) {\n\n\t\t\t_morphA.set( 0, 0, 0 );\n\t\t\t_morphB.set( 0, 0, 0 );\n\t\t\t_morphC.set( 0, 0, 0 );\n\n\t\t\tfor ( let i = 0, il = morphAttribute.length; i < il; i ++ ) {\n\n\t\t\t\tconst influence = morphInfluences[ i ];\n\t\t\t\tconst morph = morphAttribute[ i ];\n\n\t\t\t\tif ( influence === 0 ) continue;\n\n\t\t\t\t_tempA.fromBufferAttribute( morph, a );\n\t\t\t\t_tempB.fromBufferAttribute( morph, b );\n\t\t\t\t_tempC.fromBufferAttribute( morph, c );\n\n\t\t\t\tif ( morphTargetsRelative ) {\n\n\t\t\t\t\t_morphA.addScaledVector( _tempA, influence );\n\t\t\t\t\t_morphB.addScaledVector( _tempB, influence );\n\t\t\t\t\t_morphC.addScaledVector( _tempC, influence );\n\n\t\t\t\t} else {\n\n\t\t\t\t\t_morphA.addScaledVector( _tempA.sub( _vA ), influence );\n\t\t\t\t\t_morphB.addScaledVector( _tempB.sub( _vB ), influence );\n\t\t\t\t\t_morphC.addScaledVector( _tempC.sub( _vC ), influence );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\t_vA.add( _morphA );\n\t\t\t_vB.add( _morphB );\n\t\t\t_vC.add( _morphC );\n\n\t\t}\n\n\t\tif ( object.isSkinnedMesh ) {\n\n\t\t\tobject.applyBoneTransform( a, _vA );\n\t\t\tobject.applyBoneTransform( b, _vB );\n\t\t\tobject.applyBoneTransform( c, _vC );\n\n\t\t}\n\n\t\tmodifiedAttributeArray[ a * 3 + 0 ] = _vA.x;\n\t\tmodifiedAttributeArray[ a * 3 + 1 ] = _vA.y;\n\t\tmodifiedAttributeArray[ a * 3 + 2 ] = _vA.z;\n\t\tmodifiedAttributeArray[ b * 3 + 0 ] = _vB.x;\n\t\tmodifiedAttributeArray[ b * 3 + 1 ] = _vB.y;\n\t\tmodifiedAttributeArray[ b * 3 + 2 ] = _vB.z;\n\t\tmodifiedAttributeArray[ c * 3 + 0 ] = _vC.x;\n\t\tmodifiedAttributeArray[ c * 3 + 1 ] = _vC.y;\n\t\tmodifiedAttributeArray[ c * 3 + 2 ] = _vC.z;\n\n\t}\n\n\tconst geometry = object.geometry;\n\tconst material = object.material;\n\n\tlet a, b, c;\n\tconst index = geometry.index;\n\tconst positionAttribute = geometry.attributes.position;\n\tconst morphPosition = geometry.morphAttributes.position;\n\tconst morphTargetsRelative = geometry.morphTargetsRelative;\n\tconst normalAttribute = geometry.attributes.normal;\n\tconst morphNormal = geometry.morphAttributes.position;\n\n\tconst groups = geometry.groups;\n\tconst drawRange = geometry.drawRange;\n\tlet i, j, il, jl;\n\tlet group;\n\tlet start, end;\n\n\tconst modifiedPosition = new Float32Array( positionAttribute.count * positionAttribute.itemSize );\n\tconst modifiedNormal = new Float32Array( normalAttribute.count * normalAttribute.itemSize );\n\n\tif ( index !== null ) {\n\n\t\t// indexed buffer geometry\n\n\t\tif ( Array.isArray( material ) ) {\n\n\t\t\tfor ( i = 0, il = groups.length; i < il; i ++ ) {\n\n\t\t\t\tgroup = groups[ i ];\n\n\t\t\t\tstart = Math.max( group.start, drawRange.start );\n\t\t\t\tend = Math.min( ( group.start + group.count ), ( drawRange.start + drawRange.count ) );\n\n\t\t\t\tfor ( j = start, jl = end; j < jl; j += 3 ) {\n\n\t\t\t\t\ta = index.getX( j );\n\t\t\t\t\tb = index.getX( j + 1 );\n\t\t\t\t\tc = index.getX( j + 2 );\n\n\t\t\t\t\t_calculateMorphedAttributeData(\n\t\t\t\t\t\tobject,\n\t\t\t\t\t\tpositionAttribute,\n\t\t\t\t\t\tmorphPosition,\n\t\t\t\t\t\tmorphTargetsRelative,\n\t\t\t\t\t\ta, b, c,\n\t\t\t\t\t\tmodifiedPosition\n\t\t\t\t\t);\n\n\t\t\t\t\t_calculateMorphedAttributeData(\n\t\t\t\t\t\tobject,\n\t\t\t\t\t\tnormalAttribute,\n\t\t\t\t\t\tmorphNormal,\n\t\t\t\t\t\tmorphTargetsRelative,\n\t\t\t\t\t\ta, b, c,\n\t\t\t\t\t\tmodifiedNormal\n\t\t\t\t\t);\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t} else {\n\n\t\t\tstart = Math.max( 0, drawRange.start );\n\t\t\tend = Math.min( index.count, ( drawRange.start + drawRange.count ) );\n\n\t\t\tfor ( i = start, il = end; i < il; i += 3 ) {\n\n\t\t\t\ta = index.getX( i );\n\t\t\t\tb = index.getX( i + 1 );\n\t\t\t\tc = index.getX( i + 2 );\n\n\t\t\t\t_calculateMorphedAttributeData(\n\t\t\t\t\tobject,\n\t\t\t\t\tpositionAttribute,\n\t\t\t\t\tmorphPosition,\n\t\t\t\t\tmorphTargetsRelative,\n\t\t\t\t\ta, b, c,\n\t\t\t\t\tmodifiedPosition\n\t\t\t\t);\n\n\t\t\t\t_calculateMorphedAttributeData(\n\t\t\t\t\tobject,\n\t\t\t\t\tnormalAttribute,\n\t\t\t\t\tmorphNormal,\n\t\t\t\t\tmorphTargetsRelative,\n\t\t\t\t\ta, b, c,\n\t\t\t\t\tmodifiedNormal\n\t\t\t\t);\n\n\t\t\t}\n\n\t\t}\n\n\t} else {\n\n\t\t// non-indexed buffer geometry\n\n\t\tif ( Array.isArray( material ) ) {\n\n\t\t\tfor ( i = 0, il = groups.length; i < il; i ++ ) {\n\n\t\t\t\tgroup = groups[ i ];\n\n\t\t\t\tstart = Math.max( group.start, drawRange.start );\n\t\t\t\tend = Math.min( ( group.start + group.count ), ( drawRange.start + drawRange.count ) );\n\n\t\t\t\tfor ( j = start, jl = end; j < jl; j += 3 ) {\n\n\t\t\t\t\ta = j;\n\t\t\t\t\tb = j + 1;\n\t\t\t\t\tc = j + 2;\n\n\t\t\t\t\t_calculateMorphedAttributeData(\n\t\t\t\t\t\tobject,\n\t\t\t\t\t\tpositionAttribute,\n\t\t\t\t\t\tmorphPosition,\n\t\t\t\t\t\tmorphTargetsRelative,\n\t\t\t\t\t\ta, b, c,\n\t\t\t\t\t\tmodifiedPosition\n\t\t\t\t\t);\n\n\t\t\t\t\t_calculateMorphedAttributeData(\n\t\t\t\t\t\tobject,\n\t\t\t\t\t\tnormalAttribute,\n\t\t\t\t\t\tmorphNormal,\n\t\t\t\t\t\tmorphTargetsRelative,\n\t\t\t\t\t\ta, b, c,\n\t\t\t\t\t\tmodifiedNormal\n\t\t\t\t\t);\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t} else {\n\n\t\t\tstart = Math.max( 0, drawRange.start );\n\t\t\tend = Math.min( positionAttribute.count, ( drawRange.start + drawRange.count ) );\n\n\t\t\tfor ( i = start, il = end; i < il; i += 3 ) {\n\n\t\t\t\ta = i;\n\t\t\t\tb = i + 1;\n\t\t\t\tc = i + 2;\n\n\t\t\t\t_calculateMorphedAttributeData(\n\t\t\t\t\tobject,\n\t\t\t\t\tpositionAttribute,\n\t\t\t\t\tmorphPosition,\n\t\t\t\t\tmorphTargetsRelative,\n\t\t\t\t\ta, b, c,\n\t\t\t\t\tmodifiedPosition\n\t\t\t\t);\n\n\t\t\t\t_calculateMorphedAttributeData(\n\t\t\t\t\tobject,\n\t\t\t\t\tnormalAttribute,\n\t\t\t\t\tmorphNormal,\n\t\t\t\t\tmorphTargetsRelative,\n\t\t\t\t\ta, b, c,\n\t\t\t\t\tmodifiedNormal\n\t\t\t\t);\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n\tconst morphedPositionAttribute = new Float32BufferAttribute( modifiedPosition, 3 );\n\tconst morphedNormalAttribute = new Float32BufferAttribute( modifiedNormal, 3 );\n\n\treturn {\n\n\t\tpositionAttribute: positionAttribute,\n\t\tnormalAttribute: normalAttribute,\n\t\tmorphedPositionAttribute: morphedPositionAttribute,\n\t\tmorphedNormalAttribute: morphedNormalAttribute\n\n\t};\n\n}\n\nfunction mergeGroups( geometry ) {\n\n\tif ( geometry.groups.length === 0 ) {\n\n\t\tconsole.warn( 'THREE.BufferGeometryUtils.mergeGroups(): No groups are defined. Nothing to merge.' );\n\t\treturn geometry;\n\n\t}\n\n\tlet groups = geometry.groups;\n\n\t// sort groups by material index\n\n\tgroups = groups.sort( ( a, b ) => {\n\n\t\tif ( a.materialIndex !== b.materialIndex ) return a.materialIndex - b.materialIndex;\n\n\t\treturn a.start - b.start;\n\n\t} );\n\n\t// create index for non-indexed geometries\n\n\tif ( geometry.getIndex() === null ) {\n\n\t\tconst positionAttribute = geometry.getAttribute( 'position' );\n\t\tconst indices = [];\n\n\t\tfor ( let i = 0; i < positionAttribute.count; i += 3 ) {\n\n\t\t\tindices.push( i, i + 1, i + 2 );\n\n\t\t}\n\n\t\tgeometry.setIndex( indices );\n\n\t}\n\n\t// sort index\n\n\tconst index = geometry.getIndex();\n\n\tconst newIndices = [];\n\n\tfor ( let i = 0; i < groups.length; i ++ ) {\n\n\t\tconst group = groups[ i ];\n\n\t\tconst groupStart = group.start;\n\t\tconst groupLength = groupStart + group.count;\n\n\t\tfor ( let j = groupStart; j < groupLength; j ++ ) {\n\n\t\t\tnewIndices.push( index.getX( j ) );\n\n\t\t}\n\n\t}\n\n\tgeometry.dispose(); // Required to force buffer recreation\n\tgeometry.setIndex( newIndices );\n\n\t// update groups indices\n\n\tlet start = 0;\n\n\tfor ( let i = 0; i < groups.length; i ++ ) {\n\n\t\tconst group = groups[ i ];\n\n\t\tgroup.start = start;\n\t\tstart += group.count;\n\n\t}\n\n\t// merge groups\n\n\tlet currentGroup = groups[ 0 ];\n\n\tgeometry.groups = [ currentGroup ];\n\n\tfor ( let i = 1; i < groups.length; i ++ ) {\n\n\t\tconst group = groups[ i ];\n\n\t\tif ( currentGroup.materialIndex === group.materialIndex ) {\n\n\t\t\tcurrentGroup.count += group.count;\n\n\t\t} else {\n\n\t\t\tcurrentGroup = group;\n\t\t\tgeometry.groups.push( currentGroup );\n\n\t\t}\n\n\t}\n\n\treturn geometry;\n\n}\n\n\n/**\n * Modifies the supplied geometry if it is non-indexed, otherwise creates a new,\n * non-indexed geometry. Returns the geometry with smooth normals everywhere except\n * faces that meet at an angle greater than the crease angle.\n *\n * @param {BufferGeometry} geometry\n * @param {number} [creaseAngle]\n * @return {BufferGeometry}\n */\nfunction toCreasedNormals( geometry, creaseAngle = Math.PI / 3 /* 60 degrees */ ) {\n\n\tconst creaseDot = Math.cos( creaseAngle );\n\tconst hashMultiplier = ( 1 + 1e-10 ) * 1e2;\n\n\t// reusable vectors\n\tconst verts = [ new Vector3(), new Vector3(), new Vector3() ];\n\tconst tempVec1 = new Vector3();\n\tconst tempVec2 = new Vector3();\n\tconst tempNorm = new Vector3();\n\tconst tempNorm2 = new Vector3();\n\n\t// hashes a vector\n\tfunction hashVertex( v ) {\n\n\t\tconst x = ~ ~ ( v.x * hashMultiplier );\n\t\tconst y = ~ ~ ( v.y * hashMultiplier );\n\t\tconst z = ~ ~ ( v.z * hashMultiplier );\n\t\treturn `${x},${y},${z}`;\n\n\t}\n\n\t// BufferGeometry.toNonIndexed() warns if the geometry is non-indexed\n\t// and returns the original geometry\n\tconst resultGeometry = geometry.index ? geometry.toNonIndexed() : geometry;\n\tconst posAttr = resultGeometry.attributes.position;\n\tconst vertexMap = {};\n\n\t// find all the normals shared by commonly located vertices\n\tfor ( let i = 0, l = posAttr.count / 3; i < l; i ++ ) {\n\n\t\tconst i3 = 3 * i;\n\t\tconst a = verts[ 0 ].fromBufferAttribute( posAttr, i3 + 0 );\n\t\tconst b = verts[ 1 ].fromBufferAttribute( posAttr, i3 + 1 );\n\t\tconst c = verts[ 2 ].fromBufferAttribute( posAttr, i3 + 2 );\n\n\t\ttempVec1.subVectors( c, b );\n\t\ttempVec2.subVectors( a, b );\n\n\t\t// add the normal to the map for all vertices\n\t\tconst normal = new Vector3().crossVectors( tempVec1, tempVec2 ).normalize();\n\t\tfor ( let n = 0; n < 3; n ++ ) {\n\n\t\t\tconst vert = verts[ n ];\n\t\t\tconst hash = hashVertex( vert );\n\t\t\tif ( ! ( hash in vertexMap ) ) {\n\n\t\t\t\tvertexMap[ hash ] = [];\n\n\t\t\t}\n\n\t\t\tvertexMap[ hash ].push( normal );\n\n\t\t}\n\n\t}\n\n\t// average normals from all vertices that share a common location if they are within the\n\t// provided crease threshold\n\tconst normalArray = new Float32Array( posAttr.count * 3 );\n\tconst normAttr = new BufferAttribute( normalArray, 3, false );\n\tfor ( let i = 0, l = posAttr.count / 3; i < l; i ++ ) {\n\n\t\t// get the face normal for this vertex\n\t\tconst i3 = 3 * i;\n\t\tconst a = verts[ 0 ].fromBufferAttribute( posAttr, i3 + 0 );\n\t\tconst b = verts[ 1 ].fromBufferAttribute( posAttr, i3 + 1 );\n\t\tconst c = verts[ 2 ].fromBufferAttribute( posAttr, i3 + 2 );\n\n\t\ttempVec1.subVectors( c, b );\n\t\ttempVec2.subVectors( a, b );\n\n\t\ttempNorm.crossVectors( tempVec1, tempVec2 ).normalize();\n\n\t\t// average all normals that meet the threshold and set the normal value\n\t\tfor ( let n = 0; n < 3; n ++ ) {\n\n\t\t\tconst vert = verts[ n ];\n\t\t\tconst hash = hashVertex( vert );\n\t\t\tconst otherNormals = vertexMap[ hash ];\n\t\t\ttempNorm2.set( 0, 0, 0 );\n\n\t\t\tfor ( let k = 0, lk = otherNormals.length; k < lk; k ++ ) {\n\n\t\t\t\tconst otherNorm = otherNormals[ k ];\n\t\t\t\tif ( tempNorm.dot( otherNorm ) > creaseDot ) {\n\n\t\t\t\t\ttempNorm2.add( otherNorm );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\ttempNorm2.normalize();\n\t\t\tnormAttr.setXYZ( i3 + n, tempNorm2.x, tempNorm2.y, tempNorm2.z );\n\n\t\t}\n\n\t}\n\n\tresultGeometry.setAttribute( 'normal', normAttr );\n\treturn resultGeometry;\n\n}\n\nexport {\n\tcomputeMikkTSpaceTangents,\n\tmergeGeometries,\n\tmergeAttributes,\n\tinterleaveAttributes,\n\testimateBytesUsed,\n\tmergeVertices,\n\ttoTrianglesDrawMode,\n\tcomputeMorphedAttributes,\n\tmergeGroups,\n\ttoCreasedNormals\n};\n", "import {\n\tAnimationClip,\n\tBone,\n\tBox3,\n\tBufferAttribute,\n\tBufferGeometry,\n\tClampToEdgeWrapping,\n\tColor,\n\tColorManagement,\n\tDirectionalLight,\n\tDoubleSide,\n\tFileLoader,\n\tFrontSide,\n\tGroup,\n\tImageBitmapLoader,\n\tInstancedMesh,\n\tInterleavedBuffer,\n\tInterleavedBufferAttribute,\n\tInterpolant,\n\tInterpolateDiscrete,\n\tInterpolateLinear,\n\tLine,\n\tLineBasicMaterial,\n\tLineLoop,\n\tLineSegments,\n\tLinearFilter,\n\tLinearMipmapLinearFilter,\n\tLinearMipmapNearestFilter,\n\tLinearSRGBColorSpace,\n\tLoader,\n\tLoaderUtils,\n\tMaterial,\n\tMathUtils,\n\tMatrix4,\n\tMesh,\n\tMeshBasicMaterial,\n\tMeshPhysicalMaterial,\n\tMeshStandardMaterial,\n\tMirroredRepeatWrapping,\n\tNearestFilter,\n\tNearestMipmapLinearFilter,\n\tNearestMipmapNearestFilter,\n\tNumberKeyframeTrack,\n\tObject3D,\n\tOrthographicCamera,\n\tPerspectiveCamera,\n\tPointLight,\n\tPoints,\n\tPointsMaterial,\n\tPropertyBinding,\n\tQuaternion,\n\tQuaternionKeyframeTrack,\n\tRepeatWrapping,\n\tSkeleton,\n\tSkinnedMesh,\n\tSphere,\n\tSpotLight,\n\tTexture,\n\tTextureLoader,\n\tTriangleFanDrawMode,\n\tTriangleStripDrawMode,\n\tVector2,\n\tVector3,\n\tVectorKeyframeTrack,\n\tSRGBColorSpace,\n\tInstancedBufferAttribute\n} from 'three';\nimport { toTrianglesDrawMode } from '../utils/BufferGeometryUtils.js';\n\nclass GLTFLoader extends Loader {\n\n\tconstructor( manager ) {\n\n\t\tsuper( manager );\n\n\t\tthis.dracoLoader = null;\n\t\tthis.ktx2Loader = null;\n\t\tthis.meshoptDecoder = null;\n\n\t\tthis.pluginCallbacks = [];\n\n\t\tthis.register( function ( parser ) {\n\n\t\t\treturn new GLTFMaterialsClearcoatExtension( parser );\n\n\t\t} );\n\n\t\tthis.register( function ( parser ) {\n\n\t\t\treturn new GLTFTextureBasisUExtension( parser );\n\n\t\t} );\n\n\t\tthis.register( function ( parser ) {\n\n\t\t\treturn new GLTFTextureWebPExtension( parser );\n\n\t\t} );\n\n\t\tthis.register( function ( parser ) {\n\n\t\t\treturn new GLTFTextureAVIFExtension( parser );\n\n\t\t} );\n\n\t\tthis.register( function ( parser ) {\n\n\t\t\treturn new GLTFMaterialsSheenExtension( parser );\n\n\t\t} );\n\n\t\tthis.register( function ( parser ) {\n\n\t\t\treturn new GLTFMaterialsTransmissionExtension( parser );\n\n\t\t} );\n\n\t\tthis.register( function ( parser ) {\n\n\t\t\treturn new GLTFMaterialsVolumeExtension( parser );\n\n\t\t} );\n\n\t\tthis.register( function ( parser ) {\n\n\t\t\treturn new GLTFMaterialsIorExtension( parser );\n\n\t\t} );\n\n\t\tthis.register( function ( parser ) {\n\n\t\t\treturn new GLTFMaterialsEmissiveStrengthExtension( parser );\n\n\t\t} );\n\n\t\tthis.register( function ( parser ) {\n\n\t\t\treturn new GLTFMaterialsSpecularExtension( parser );\n\n\t\t} );\n\n\t\tthis.register( function ( parser ) {\n\n\t\t\treturn new GLTFMaterialsIridescenceExtension( parser );\n\n\t\t} );\n\n\t\tthis.register( function ( parser ) {\n\n\t\t\treturn new GLTFMaterialsAnisotropyExtension( parser );\n\n\t\t} );\n\n\t\tthis.register( function ( parser ) {\n\n\t\t\treturn new GLTFMaterialsBumpExtension( parser );\n\n\t\t} );\n\n\t\tthis.register( function ( parser ) {\n\n\t\t\treturn new GLTFLightsExtension( parser );\n\n\t\t} );\n\n\t\tthis.register( function ( parser ) {\n\n\t\t\treturn new GLTFMeshoptCompression( parser );\n\n\t\t} );\n\n\t\tthis.register( function ( parser ) {\n\n\t\t\treturn new GLTFMeshGpuInstancing( parser );\n\n\t\t} );\n\n\t}\n\n\tload( url, onLoad, onProgress, onError ) {\n\n\t\tconst scope = this;\n\n\t\tlet resourcePath;\n\n\t\tif ( this.resourcePath !== '' ) {\n\n\t\t\tresourcePath = this.resourcePath;\n\n\t\t} else if ( this.path !== '' ) {\n\n\t\t\t// If a base path is set, resources will be relative paths from that plus the relative path of the gltf file\n\t\t\t// Example path = 'https://my-cnd-server.com/', url = 'assets/models/model.gltf'\n\t\t\t// resourcePath = 'https://my-cnd-server.com/assets/models/'\n\t\t\t// referenced resource 'model.bin' will be loaded from 'https://my-cnd-server.com/assets/models/model.bin'\n\t\t\t// referenced resource '../textures/texture.png' will be loaded from 'https://my-cnd-server.com/assets/textures/texture.png'\n\t\t\tconst relativeUrl = LoaderUtils.extractUrlBase( url );\n\t\t\tresourcePath = LoaderUtils.resolveURL( relativeUrl, this.path );\n\n\t\t} else {\n\n\t\t\tresourcePath = LoaderUtils.extractUrlBase( url );\n\n\t\t}\n\n\t\t// Tells the LoadingManager to track an extra item, which resolves after\n\t\t// the model is fully loaded. This means the count of items loaded will\n\t\t// be incorrect, but ensures manager.onLoad() does not fire early.\n\t\tthis.manager.itemStart( url );\n\n\t\tconst _onError = function ( e ) {\n\n\t\t\tif ( onError ) {\n\n\t\t\t\tonError( e );\n\n\t\t\t} else {\n\n\t\t\t\tconsole.error( e );\n\n\t\t\t}\n\n\t\t\tscope.manager.itemError( url );\n\t\t\tscope.manager.itemEnd( url );\n\n\t\t};\n\n\t\tconst loader = new FileLoader( this.manager );\n\n\t\tloader.setPath( this.path );\n\t\tloader.setResponseType( 'arraybuffer' );\n\t\tloader.setRequestHeader( this.requestHeader );\n\t\tloader.setWithCredentials( this.withCredentials );\n\n\t\tloader.load( url, function ( data ) {\n\n\t\t\ttry {\n\n\t\t\t\tscope.parse( data, resourcePath, function ( gltf ) {\n\n\t\t\t\t\tonLoad( gltf );\n\n\t\t\t\t\tscope.manager.itemEnd( url );\n\n\t\t\t\t}, _onError );\n\n\t\t\t} catch ( e ) {\n\n\t\t\t\t_onError( e );\n\n\t\t\t}\n\n\t\t}, onProgress, _onError );\n\n\t}\n\n\tsetDRACOLoader( dracoLoader ) {\n\n\t\tthis.dracoLoader = dracoLoader;\n\t\treturn this;\n\n\t}\n\n\tsetDDSLoader() {\n\n\t\tthrow new Error(\n\n\t\t\t'THREE.GLTFLoader: \"MSFT_texture_dds\" no longer supported. Please update to \"KHR_texture_basisu\".'\n\n\t\t);\n\n\t}\n\n\tsetKTX2Loader( ktx2Loader ) {\n\n\t\tthis.ktx2Loader = ktx2Loader;\n\t\treturn this;\n\n\t}\n\n\tsetMeshoptDecoder( meshoptDecoder ) {\n\n\t\tthis.meshoptDecoder = meshoptDecoder;\n\t\treturn this;\n\n\t}\n\n\tregister( callback ) {\n\n\t\tif ( this.pluginCallbacks.indexOf( callback ) === - 1 ) {\n\n\t\t\tthis.pluginCallbacks.push( callback );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tunregister( callback ) {\n\n\t\tif ( this.pluginCallbacks.indexOf( callback ) !== - 1 ) {\n\n\t\t\tthis.pluginCallbacks.splice( this.pluginCallbacks.indexOf( callback ), 1 );\n\n\t\t}\n\n\t\treturn this;\n\n\t}\n\n\tparse( data, path, onLoad, onError ) {\n\n\t\tlet json;\n\t\tconst extensions = {};\n\t\tconst plugins = {};\n\t\tconst textDecoder = new TextDecoder();\n\n\t\tif ( typeof data === 'string' ) {\n\n\t\t\tjson = JSON.parse( data );\n\n\t\t} else if ( data instanceof ArrayBuffer ) {\n\n\t\t\tconst magic = textDecoder.decode( new Uint8Array( data, 0, 4 ) );\n\n\t\t\tif ( magic === BINARY_EXTENSION_HEADER_MAGIC ) {\n\n\t\t\t\ttry {\n\n\t\t\t\t\textensions[ EXTENSIONS.KHR_BINARY_GLTF ] = new GLTFBinaryExtension( data );\n\n\t\t\t\t} catch ( error ) {\n\n\t\t\t\t\tif ( onError ) onError( error );\n\t\t\t\t\treturn;\n\n\t\t\t\t}\n\n\t\t\t\tjson = JSON.parse( extensions[ EXTENSIONS.KHR_BINARY_GLTF ].content );\n\n\t\t\t} else {\n\n\t\t\t\tjson = JSON.parse( textDecoder.decode( data ) );\n\n\t\t\t}\n\n\t\t} else {\n\n\t\t\tjson = data;\n\n\t\t}\n\n\t\tif ( json.asset === undefined || json.asset.version[ 0 ] < 2 ) {\n\n\t\t\tif ( onError ) onError( new Error( 'THREE.GLTFLoader: Unsupported asset. glTF versions >=2.0 are supported.' ) );\n\t\t\treturn;\n\n\t\t}\n\n\t\tconst parser = new GLTFParser( json, {\n\n\t\t\tpath: path || this.resourcePath || '',\n\t\t\tcrossOrigin: this.crossOrigin,\n\t\t\trequestHeader: this.requestHeader,\n\t\t\tmanager: this.manager,\n\t\t\tktx2Loader: this.ktx2Loader,\n\t\t\tmeshoptDecoder: this.meshoptDecoder\n\n\t\t} );\n\n\t\tparser.fileLoader.setRequestHeader( this.requestHeader );\n\n\t\tfor ( let i = 0; i < this.pluginCallbacks.length; i ++ ) {\n\n\t\t\tconst plugin = this.pluginCallbacks[ i ]( parser );\n\n\t\t\tif ( ! plugin.name ) console.error( 'THREE.GLTFLoader: Invalid plugin found: missing name' );\n\n\t\t\tplugins[ plugin.name ] = plugin;\n\n\t\t\t// Workaround to avoid determining as unknown extension\n\t\t\t// in addUnknownExtensionsToUserData().\n\t\t\t// Remove this workaround if we move all the existing\n\t\t\t// extension handlers to plugin system\n\t\t\textensions[ plugin.name ] = true;\n\n\t\t}\n\n\t\tif ( json.extensionsUsed ) {\n\n\t\t\tfor ( let i = 0; i < json.extensionsUsed.length; ++ i ) {\n\n\t\t\t\tconst extensionName = json.extensionsUsed[ i ];\n\t\t\t\tconst extensionsRequired = json.extensionsRequired || [];\n\n\t\t\t\tswitch ( extensionName ) {\n\n\t\t\t\t\tcase EXTENSIONS.KHR_MATERIALS_UNLIT:\n\t\t\t\t\t\textensions[ extensionName ] = new GLTFMaterialsUnlitExtension();\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tcase EXTENSIONS.KHR_DRACO_MESH_COMPRESSION:\n\t\t\t\t\t\textensions[ extensionName ] = new GLTFDracoMeshCompressionExtension( json, this.dracoLoader );\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tcase EXTENSIONS.KHR_TEXTURE_TRANSFORM:\n\t\t\t\t\t\textensions[ extensionName ] = new GLTFTextureTransformExtension();\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tcase EXTENSIONS.KHR_MESH_QUANTIZATION:\n\t\t\t\t\t\textensions[ extensionName ] = new GLTFMeshQuantizationExtension();\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tdefault:\n\n\t\t\t\t\t\tif ( extensionsRequired.indexOf( extensionName ) >= 0 && plugins[ extensionName ] === undefined ) {\n\n\t\t\t\t\t\t\tconsole.warn( 'THREE.GLTFLoader: Unknown extension \"' + extensionName + '\".' );\n\n\t\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t\tparser.setExtensions( extensions );\n\t\tparser.setPlugins( plugins );\n\t\tparser.parse( onLoad, onError );\n\n\t}\n\n\tparseAsync( data, path ) {\n\n\t\tconst scope = this;\n\n\t\treturn new Promise( function ( resolve, reject ) {\n\n\t\t\tscope.parse( data, path, resolve, reject );\n\n\t\t} );\n\n\t}\n\n}\n\n/* GLTFREGISTRY */\n\nfunction GLTFRegistry() {\n\n\tlet objects = {};\n\n\treturn\t{\n\n\t\tget: function ( key ) {\n\n\t\t\treturn objects[ key ];\n\n\t\t},\n\n\t\tadd: function ( key, object ) {\n\n\t\t\tobjects[ key ] = object;\n\n\t\t},\n\n\t\tremove: function ( key ) {\n\n\t\t\tdelete objects[ key ];\n\n\t\t},\n\n\t\tremoveAll: function () {\n\n\t\t\tobjects = {};\n\n\t\t}\n\n\t};\n\n}\n\n/*********************************/\n/********** EXTENSIONS ***********/\n/*********************************/\n\nconst EXTENSIONS = {\n\tKHR_BINARY_GLTF: 'KHR_binary_glTF',\n\tKHR_DRACO_MESH_COMPRESSION: 'KHR_draco_mesh_compression',\n\tKHR_LIGHTS_PUNCTUAL: 'KHR_lights_punctual',\n\tKHR_MATERIALS_CLEARCOAT: 'KHR_materials_clearcoat',\n\tKHR_MATERIALS_IOR: 'KHR_materials_ior',\n\tKHR_MATERIALS_SHEEN: 'KHR_materials_sheen',\n\tKHR_MATERIALS_SPECULAR: 'KHR_materials_specular',\n\tKHR_MATERIALS_TRANSMISSION: 'KHR_materials_transmission',\n\tKHR_MATERIALS_IRIDESCENCE: 'KHR_materials_iridescence',\n\tKHR_MATERIALS_ANISOTROPY: 'KHR_materials_anisotropy',\n\tKHR_MATERIALS_UNLIT: 'KHR_materials_unlit',\n\tKHR_MATERIALS_VOLUME: 'KHR_materials_volume',\n\tKHR_TEXTURE_BASISU: 'KHR_texture_basisu',\n\tKHR_TEXTURE_TRANSFORM: 'KHR_texture_transform',\n\tKHR_MESH_QUANTIZATION: 'KHR_mesh_quantization',\n\tKHR_MATERIALS_EMISSIVE_STRENGTH: 'KHR_materials_emissive_strength',\n\tEXT_MATERIALS_BUMP: 'EXT_materials_bump',\n\tEXT_TEXTURE_WEBP: 'EXT_texture_webp',\n\tEXT_TEXTURE_AVIF: 'EXT_texture_avif',\n\tEXT_MESHOPT_COMPRESSION: 'EXT_meshopt_compression',\n\tEXT_MESH_GPU_INSTANCING: 'EXT_mesh_gpu_instancing'\n};\n\n/**\n * Punctual Lights Extension\n *\n * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_lights_punctual\n */\nclass GLTFLightsExtension {\n\n\tconstructor( parser ) {\n\n\t\tthis.parser = parser;\n\t\tthis.name = EXTENSIONS.KHR_LIGHTS_PUNCTUAL;\n\n\t\t// Object3D instance caches\n\t\tthis.cache = { refs: {}, uses: {} };\n\n\t}\n\n\t_markDefs() {\n\n\t\tconst parser = this.parser;\n\t\tconst nodeDefs = this.parser.json.nodes || [];\n\n\t\tfor ( let nodeIndex = 0, nodeLength = nodeDefs.length; nodeIndex < nodeLength; nodeIndex ++ ) {\n\n\t\t\tconst nodeDef = nodeDefs[ nodeIndex ];\n\n\t\t\tif ( nodeDef.extensions\n\t\t\t\t\t&& nodeDef.extensions[ this.name ]\n\t\t\t\t\t&& nodeDef.extensions[ this.name ].light !== undefined ) {\n\n\t\t\t\tparser._addNodeRef( this.cache, nodeDef.extensions[ this.name ].light );\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n\t_loadLight( lightIndex ) {\n\n\t\tconst parser = this.parser;\n\t\tconst cacheKey = 'light:' + lightIndex;\n\t\tlet dependency = parser.cache.get( cacheKey );\n\n\t\tif ( dependency ) return dependency;\n\n\t\tconst json = parser.json;\n\t\tconst extensions = ( json.extensions && json.extensions[ this.name ] ) || {};\n\t\tconst lightDefs = extensions.lights || [];\n\t\tconst lightDef = lightDefs[ lightIndex ];\n\t\tlet lightNode;\n\n\t\tconst color = new Color( 0xffffff );\n\n\t\tif ( lightDef.color !== undefined ) color.setRGB( lightDef.color[ 0 ], lightDef.color[ 1 ], lightDef.color[ 2 ], LinearSRGBColorSpace );\n\n\t\tconst range = lightDef.range !== undefined ? lightDef.range : 0;\n\n\t\tswitch ( lightDef.type ) {\n\n\t\t\tcase 'directional':\n\t\t\t\tlightNode = new DirectionalLight( color );\n\t\t\t\tlightNode.target.position.set( 0, 0, - 1 );\n\t\t\t\tlightNode.add( lightNode.target );\n\t\t\t\tbreak;\n\n\t\t\tcase 'point':\n\t\t\t\tlightNode = new PointLight( color );\n\t\t\t\tlightNode.distance = range;\n\t\t\t\tbreak;\n\n\t\t\tcase 'spot':\n\t\t\t\tlightNode = new SpotLight( color );\n\t\t\t\tlightNode.distance = range;\n\t\t\t\t// Handle spotlight properties.\n\t\t\t\tlightDef.spot = lightDef.spot || {};\n\t\t\t\tlightDef.spot.innerConeAngle = lightDef.spot.innerConeAngle !== undefined ? lightDef.spot.innerConeAngle : 0;\n\t\t\t\tlightDef.spot.outerConeAngle = lightDef.spot.outerConeAngle !== undefined ? lightDef.spot.outerConeAngle : Math.PI / 4.0;\n\t\t\t\tlightNode.angle = lightDef.spot.outerConeAngle;\n\t\t\t\tlightNode.penumbra = 1.0 - lightDef.spot.innerConeAngle / lightDef.spot.outerConeAngle;\n\t\t\t\tlightNode.target.position.set( 0, 0, - 1 );\n\t\t\t\tlightNode.add( lightNode.target );\n\t\t\t\tbreak;\n\n\t\t\tdefault:\n\t\t\t\tthrow new Error( 'THREE.GLTFLoader: Unexpected light type: ' + lightDef.type );\n\n\t\t}\n\n\t\t// Some lights (e.g. spot) default to a position other than the origin. Reset the position\n\t\t// here, because node-level parsing will only override position if explicitly specified.\n\t\tlightNode.position.set( 0, 0, 0 );\n\n\t\tlightNode.decay = 2;\n\n\t\tassignExtrasToUserData( lightNode, lightDef );\n\n\t\tif ( lightDef.intensity !== undefined ) lightNode.intensity = lightDef.intensity;\n\n\t\tlightNode.name = parser.createUniqueName( lightDef.name || ( 'light_' + lightIndex ) );\n\n\t\tdependency = Promise.resolve( lightNode );\n\n\t\tparser.cache.add( cacheKey, dependency );\n\n\t\treturn dependency;\n\n\t}\n\n\tgetDependency( type, index ) {\n\n\t\tif ( type !== 'light' ) return;\n\n\t\treturn this._loadLight( index );\n\n\t}\n\n\tcreateNodeAttachment( nodeIndex ) {\n\n\t\tconst self = this;\n\t\tconst parser = this.parser;\n\t\tconst json = parser.json;\n\t\tconst nodeDef = json.nodes[ nodeIndex ];\n\t\tconst lightDef = ( nodeDef.extensions && nodeDef.extensions[ this.name ] ) || {};\n\t\tconst lightIndex = lightDef.light;\n\n\t\tif ( lightIndex === undefined ) return null;\n\n\t\treturn this._loadLight( lightIndex ).then( function ( light ) {\n\n\t\t\treturn parser._getNodeRef( self.cache, lightIndex, light );\n\n\t\t} );\n\n\t}\n\n}\n\n/**\n * Unlit Materials Extension\n *\n * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_unlit\n */\nclass GLTFMaterialsUnlitExtension {\n\n\tconstructor() {\n\n\t\tthis.name = EXTENSIONS.KHR_MATERIALS_UNLIT;\n\n\t}\n\n\tgetMaterialType() {\n\n\t\treturn MeshBasicMaterial;\n\n\t}\n\n\textendParams( materialParams, materialDef, parser ) {\n\n\t\tconst pending = [];\n\n\t\tmaterialParams.color = new Color( 1.0, 1.0, 1.0 );\n\t\tmaterialParams.opacity = 1.0;\n\n\t\tconst metallicRoughness = materialDef.pbrMetallicRoughness;\n\n\t\tif ( metallicRoughness ) {\n\n\t\t\tif ( Array.isArray( metallicRoughness.baseColorFactor ) ) {\n\n\t\t\t\tconst array = metallicRoughness.baseColorFactor;\n\n\t\t\t\tmaterialParams.color.setRGB( array[ 0 ], array[ 1 ], array[ 2 ], LinearSRGBColorSpace );\n\t\t\t\tmaterialParams.opacity = array[ 3 ];\n\n\t\t\t}\n\n\t\t\tif ( metallicRoughness.baseColorTexture !== undefined ) {\n\n\t\t\t\tpending.push( parser.assignTexture( materialParams, 'map', metallicRoughness.baseColorTexture, SRGBColorSpace ) );\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn Promise.all( pending );\n\n\t}\n\n}\n\n/**\n * Materials Emissive Strength Extension\n *\n * Specification: https://github.com/KhronosGroup/glTF/blob/5768b3ce0ef32bc39cdf1bef10b948586635ead3/extensions/2.0/Khronos/KHR_materials_emissive_strength/README.md\n */\nclass GLTFMaterialsEmissiveStrengthExtension {\n\n\tconstructor( parser ) {\n\n\t\tthis.parser = parser;\n\t\tthis.name = EXTENSIONS.KHR_MATERIALS_EMISSIVE_STRENGTH;\n\n\t}\n\n\textendMaterialParams( materialIndex, materialParams ) {\n\n\t\tconst parser = this.parser;\n\t\tconst materialDef = parser.json.materials[ materialIndex ];\n\n\t\tif ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) {\n\n\t\t\treturn Promise.resolve();\n\n\t\t}\n\n\t\tconst emissiveStrength = materialDef.extensions[ this.name ].emissiveStrength;\n\n\t\tif ( emissiveStrength !== undefined ) {\n\n\t\t\tmaterialParams.emissiveIntensity = emissiveStrength;\n\n\t\t}\n\n\t\treturn Promise.resolve();\n\n\t}\n\n}\n\n/**\n * Clearcoat Materials Extension\n *\n * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_clearcoat\n */\nclass GLTFMaterialsClearcoatExtension {\n\n\tconstructor( parser ) {\n\n\t\tthis.parser = parser;\n\t\tthis.name = EXTENSIONS.KHR_MATERIALS_CLEARCOAT;\n\n\t}\n\n\tgetMaterialType( materialIndex ) {\n\n\t\tconst parser = this.parser;\n\t\tconst materialDef = parser.json.materials[ materialIndex ];\n\n\t\tif ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null;\n\n\t\treturn MeshPhysicalMaterial;\n\n\t}\n\n\textendMaterialParams( materialIndex, materialParams ) {\n\n\t\tconst parser = this.parser;\n\t\tconst materialDef = parser.json.materials[ materialIndex ];\n\n\t\tif ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) {\n\n\t\t\treturn Promise.resolve();\n\n\t\t}\n\n\t\tconst pending = [];\n\n\t\tconst extension = materialDef.extensions[ this.name ];\n\n\t\tif ( extension.clearcoatFactor !== undefined ) {\n\n\t\t\tmaterialParams.clearcoat = extension.clearcoatFactor;\n\n\t\t}\n\n\t\tif ( extension.clearcoatTexture !== undefined ) {\n\n\t\t\tpending.push( parser.assignTexture( materialParams, 'clearcoatMap', extension.clearcoatTexture ) );\n\n\t\t}\n\n\t\tif ( extension.clearcoatRoughnessFactor !== undefined ) {\n\n\t\t\tmaterialParams.clearcoatRoughness = extension.clearcoatRoughnessFactor;\n\n\t\t}\n\n\t\tif ( extension.clearcoatRoughnessTexture !== undefined ) {\n\n\t\t\tpending.push( parser.assignTexture( materialParams, 'clearcoatRoughnessMap', extension.clearcoatRoughnessTexture ) );\n\n\t\t}\n\n\t\tif ( extension.clearcoatNormalTexture !== undefined ) {\n\n\t\t\tpending.push( parser.assignTexture( materialParams, 'clearcoatNormalMap', extension.clearcoatNormalTexture ) );\n\n\t\t\tif ( extension.clearcoatNormalTexture.scale !== undefined ) {\n\n\t\t\t\tconst scale = extension.clearcoatNormalTexture.scale;\n\n\t\t\t\tmaterialParams.clearcoatNormalScale = new Vector2( scale, scale );\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn Promise.all( pending );\n\n\t}\n\n}\n\n/**\n * Iridescence Materials Extension\n *\n * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_iridescence\n */\nclass GLTFMaterialsIridescenceExtension {\n\n\tconstructor( parser ) {\n\n\t\tthis.parser = parser;\n\t\tthis.name = EXTENSIONS.KHR_MATERIALS_IRIDESCENCE;\n\n\t}\n\n\tgetMaterialType( materialIndex ) {\n\n\t\tconst parser = this.parser;\n\t\tconst materialDef = parser.json.materials[ materialIndex ];\n\n\t\tif ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null;\n\n\t\treturn MeshPhysicalMaterial;\n\n\t}\n\n\textendMaterialParams( materialIndex, materialParams ) {\n\n\t\tconst parser = this.parser;\n\t\tconst materialDef = parser.json.materials[ materialIndex ];\n\n\t\tif ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) {\n\n\t\t\treturn Promise.resolve();\n\n\t\t}\n\n\t\tconst pending = [];\n\n\t\tconst extension = materialDef.extensions[ this.name ];\n\n\t\tif ( extension.iridescenceFactor !== undefined ) {\n\n\t\t\tmaterialParams.iridescence = extension.iridescenceFactor;\n\n\t\t}\n\n\t\tif ( extension.iridescenceTexture !== undefined ) {\n\n\t\t\tpending.push( parser.assignTexture( materialParams, 'iridescenceMap', extension.iridescenceTexture ) );\n\n\t\t}\n\n\t\tif ( extension.iridescenceIor !== undefined ) {\n\n\t\t\tmaterialParams.iridescenceIOR = extension.iridescenceIor;\n\n\t\t}\n\n\t\tif ( materialParams.iridescenceThicknessRange === undefined ) {\n\n\t\t\tmaterialParams.iridescenceThicknessRange = [ 100, 400 ];\n\n\t\t}\n\n\t\tif ( extension.iridescenceThicknessMinimum !== undefined ) {\n\n\t\t\tmaterialParams.iridescenceThicknessRange[ 0 ] = extension.iridescenceThicknessMinimum;\n\n\t\t}\n\n\t\tif ( extension.iridescenceThicknessMaximum !== undefined ) {\n\n\t\t\tmaterialParams.iridescenceThicknessRange[ 1 ] = extension.iridescenceThicknessMaximum;\n\n\t\t}\n\n\t\tif ( extension.iridescenceThicknessTexture !== undefined ) {\n\n\t\t\tpending.push( parser.assignTexture( materialParams, 'iridescenceThicknessMap', extension.iridescenceThicknessTexture ) );\n\n\t\t}\n\n\t\treturn Promise.all( pending );\n\n\t}\n\n}\n\n/**\n * Sheen Materials Extension\n *\n * Specification: https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_materials_sheen\n */\nclass GLTFMaterialsSheenExtension {\n\n\tconstructor( parser ) {\n\n\t\tthis.parser = parser;\n\t\tthis.name = EXTENSIONS.KHR_MATERIALS_SHEEN;\n\n\t}\n\n\tgetMaterialType( materialIndex ) {\n\n\t\tconst parser = this.parser;\n\t\tconst materialDef = parser.json.materials[ materialIndex ];\n\n\t\tif ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null;\n\n\t\treturn MeshPhysicalMaterial;\n\n\t}\n\n\textendMaterialParams( materialIndex, materialParams ) {\n\n\t\tconst parser = this.parser;\n\t\tconst materialDef = parser.json.materials[ materialIndex ];\n\n\t\tif ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) {\n\n\t\t\treturn Promise.resolve();\n\n\t\t}\n\n\t\tconst pending = [];\n\n\t\tmaterialParams.sheenColor = new Color( 0, 0, 0 );\n\t\tmaterialParams.sheenRoughness = 0;\n\t\tmaterialParams.sheen = 1;\n\n\t\tconst extension = materialDef.extensions[ this.name ];\n\n\t\tif ( extension.sheenColorFactor !== undefined ) {\n\n\t\t\tconst colorFactor = extension.sheenColorFactor;\n\t\t\tmaterialParams.sheenColor.setRGB( colorFactor[ 0 ], colorFactor[ 1 ], colorFactor[ 2 ], LinearSRGBColorSpace );\n\n\t\t}\n\n\t\tif ( extension.sheenRoughnessFactor !== undefined ) {\n\n\t\t\tmaterialParams.sheenRoughness = extension.sheenRoughnessFactor;\n\n\t\t}\n\n\t\tif ( extension.sheenColorTexture !== undefined ) {\n\n\t\t\tpending.push( parser.assignTexture( materialParams, 'sheenColorMap', extension.sheenColorTexture, SRGBColorSpace ) );\n\n\t\t}\n\n\t\tif ( extension.sheenRoughnessTexture !== undefined ) {\n\n\t\t\tpending.push( parser.assignTexture( materialParams, 'sheenRoughnessMap', extension.sheenRoughnessTexture ) );\n\n\t\t}\n\n\t\treturn Promise.all( pending );\n\n\t}\n\n}\n\n/**\n * Transmission Materials Extension\n *\n * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_transmission\n * Draft: https://github.com/KhronosGroup/glTF/pull/1698\n */\nclass GLTFMaterialsTransmissionExtension {\n\n\tconstructor( parser ) {\n\n\t\tthis.parser = parser;\n\t\tthis.name = EXTENSIONS.KHR_MATERIALS_TRANSMISSION;\n\n\t}\n\n\tgetMaterialType( materialIndex ) {\n\n\t\tconst parser = this.parser;\n\t\tconst materialDef = parser.json.materials[ materialIndex ];\n\n\t\tif ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null;\n\n\t\treturn MeshPhysicalMaterial;\n\n\t}\n\n\textendMaterialParams( materialIndex, materialParams ) {\n\n\t\tconst parser = this.parser;\n\t\tconst materialDef = parser.json.materials[ materialIndex ];\n\n\t\tif ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) {\n\n\t\t\treturn Promise.resolve();\n\n\t\t}\n\n\t\tconst pending = [];\n\n\t\tconst extension = materialDef.extensions[ this.name ];\n\n\t\tif ( extension.transmissionFactor !== undefined ) {\n\n\t\t\tmaterialParams.transmission = extension.transmissionFactor;\n\n\t\t}\n\n\t\tif ( extension.transmissionTexture !== undefined ) {\n\n\t\t\tpending.push( parser.assignTexture( materialParams, 'transmissionMap', extension.transmissionTexture ) );\n\n\t\t}\n\n\t\treturn Promise.all( pending );\n\n\t}\n\n}\n\n/**\n * Materials Volume Extension\n *\n * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_volume\n */\nclass GLTFMaterialsVolumeExtension {\n\n\tconstructor( parser ) {\n\n\t\tthis.parser = parser;\n\t\tthis.name = EXTENSIONS.KHR_MATERIALS_VOLUME;\n\n\t}\n\n\tgetMaterialType( materialIndex ) {\n\n\t\tconst parser = this.parser;\n\t\tconst materialDef = parser.json.materials[ materialIndex ];\n\n\t\tif ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null;\n\n\t\treturn MeshPhysicalMaterial;\n\n\t}\n\n\textendMaterialParams( materialIndex, materialParams ) {\n\n\t\tconst parser = this.parser;\n\t\tconst materialDef = parser.json.materials[ materialIndex ];\n\n\t\tif ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) {\n\n\t\t\treturn Promise.resolve();\n\n\t\t}\n\n\t\tconst pending = [];\n\n\t\tconst extension = materialDef.extensions[ this.name ];\n\n\t\tmaterialParams.thickness = extension.thicknessFactor !== undefined ? extension.thicknessFactor : 0;\n\n\t\tif ( extension.thicknessTexture !== undefined ) {\n\n\t\t\tpending.push( parser.assignTexture( materialParams, 'thicknessMap', extension.thicknessTexture ) );\n\n\t\t}\n\n\t\tmaterialParams.attenuationDistance = extension.attenuationDistance || Infinity;\n\n\t\tconst colorArray = extension.attenuationColor || [ 1, 1, 1 ];\n\t\tmaterialParams.attenuationColor = new Color().setRGB( colorArray[ 0 ], colorArray[ 1 ], colorArray[ 2 ], LinearSRGBColorSpace );\n\n\t\treturn Promise.all( pending );\n\n\t}\n\n}\n\n/**\n * Materials ior Extension\n *\n * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_ior\n */\nclass GLTFMaterialsIorExtension {\n\n\tconstructor( parser ) {\n\n\t\tthis.parser = parser;\n\t\tthis.name = EXTENSIONS.KHR_MATERIALS_IOR;\n\n\t}\n\n\tgetMaterialType( materialIndex ) {\n\n\t\tconst parser = this.parser;\n\t\tconst materialDef = parser.json.materials[ materialIndex ];\n\n\t\tif ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null;\n\n\t\treturn MeshPhysicalMaterial;\n\n\t}\n\n\textendMaterialParams( materialIndex, materialParams ) {\n\n\t\tconst parser = this.parser;\n\t\tconst materialDef = parser.json.materials[ materialIndex ];\n\n\t\tif ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) {\n\n\t\t\treturn Promise.resolve();\n\n\t\t}\n\n\t\tconst extension = materialDef.extensions[ this.name ];\n\n\t\tmaterialParams.ior = extension.ior !== undefined ? extension.ior : 1.5;\n\n\t\treturn Promise.resolve();\n\n\t}\n\n}\n\n/**\n * Materials specular Extension\n *\n * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_specular\n */\nclass GLTFMaterialsSpecularExtension {\n\n\tconstructor( parser ) {\n\n\t\tthis.parser = parser;\n\t\tthis.name = EXTENSIONS.KHR_MATERIALS_SPECULAR;\n\n\t}\n\n\tgetMaterialType( materialIndex ) {\n\n\t\tconst parser = this.parser;\n\t\tconst materialDef = parser.json.materials[ materialIndex ];\n\n\t\tif ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null;\n\n\t\treturn MeshPhysicalMaterial;\n\n\t}\n\n\textendMaterialParams( materialIndex, materialParams ) {\n\n\t\tconst parser = this.parser;\n\t\tconst materialDef = parser.json.materials[ materialIndex ];\n\n\t\tif ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) {\n\n\t\t\treturn Promise.resolve();\n\n\t\t}\n\n\t\tconst pending = [];\n\n\t\tconst extension = materialDef.extensions[ this.name ];\n\n\t\tmaterialParams.specularIntensity = extension.specularFactor !== undefined ? extension.specularFactor : 1.0;\n\n\t\tif ( extension.specularTexture !== undefined ) {\n\n\t\t\tpending.push( parser.assignTexture( materialParams, 'specularIntensityMap', extension.specularTexture ) );\n\n\t\t}\n\n\t\tconst colorArray = extension.specularColorFactor || [ 1, 1, 1 ];\n\t\tmaterialParams.specularColor = new Color().setRGB( colorArray[ 0 ], colorArray[ 1 ], colorArray[ 2 ], LinearSRGBColorSpace );\n\n\t\tif ( extension.specularColorTexture !== undefined ) {\n\n\t\t\tpending.push( parser.assignTexture( materialParams, 'specularColorMap', extension.specularColorTexture, SRGBColorSpace ) );\n\n\t\t}\n\n\t\treturn Promise.all( pending );\n\n\t}\n\n}\n\n\n/**\n * Materials bump Extension\n *\n * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/EXT_materials_bump\n */\nclass GLTFMaterialsBumpExtension {\n\n\tconstructor( parser ) {\n\n\t\tthis.parser = parser;\n\t\tthis.name = EXTENSIONS.EXT_MATERIALS_BUMP;\n\n\t}\n\n\tgetMaterialType( materialIndex ) {\n\n\t\tconst parser = this.parser;\n\t\tconst materialDef = parser.json.materials[ materialIndex ];\n\n\t\tif ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null;\n\n\t\treturn MeshPhysicalMaterial;\n\n\t}\n\n\textendMaterialParams( materialIndex, materialParams ) {\n\n\t\tconst parser = this.parser;\n\t\tconst materialDef = parser.json.materials[ materialIndex ];\n\n\t\tif ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) {\n\n\t\t\treturn Promise.resolve();\n\n\t\t}\n\n\t\tconst pending = [];\n\n\t\tconst extension = materialDef.extensions[ this.name ];\n\n\t\tmaterialParams.bumpScale = extension.bumpFactor !== undefined ? extension.bumpFactor : 1.0;\n\n\t\tif ( extension.bumpTexture !== undefined ) {\n\n\t\t\tpending.push( parser.assignTexture( materialParams, 'bumpMap', extension.bumpTexture ) );\n\n\t\t}\n\n\t\treturn Promise.all( pending );\n\n\t}\n\n}\n\n/**\n * Materials anisotropy Extension\n *\n * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_anisotropy\n */\nclass GLTFMaterialsAnisotropyExtension {\n\n\tconstructor( parser ) {\n\n\t\tthis.parser = parser;\n\t\tthis.name = EXTENSIONS.KHR_MATERIALS_ANISOTROPY;\n\n\t}\n\n\tgetMaterialType( materialIndex ) {\n\n\t\tconst parser = this.parser;\n\t\tconst materialDef = parser.json.materials[ materialIndex ];\n\n\t\tif ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null;\n\n\t\treturn MeshPhysicalMaterial;\n\n\t}\n\n\textendMaterialParams( materialIndex, materialParams ) {\n\n\t\tconst parser = this.parser;\n\t\tconst materialDef = parser.json.materials[ materialIndex ];\n\n\t\tif ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) {\n\n\t\t\treturn Promise.resolve();\n\n\t\t}\n\n\t\tconst pending = [];\n\n\t\tconst extension = materialDef.extensions[ this.name ];\n\n\t\tif ( extension.anisotropyStrength !== undefined ) {\n\n\t\t\tmaterialParams.anisotropy = extension.anisotropyStrength;\n\n\t\t}\n\n\t\tif ( extension.anisotropyRotation !== undefined ) {\n\n\t\t\tmaterialParams.anisotropyRotation = extension.anisotropyRotation;\n\n\t\t}\n\n\t\tif ( extension.anisotropyTexture !== undefined ) {\n\n\t\t\tpending.push( parser.assignTexture( materialParams, 'anisotropyMap', extension.anisotropyTexture ) );\n\n\t\t}\n\n\t\treturn Promise.all( pending );\n\n\t}\n\n}\n\n/**\n * BasisU Texture Extension\n *\n * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_texture_basisu\n */\nclass GLTFTextureBasisUExtension {\n\n\tconstructor( parser ) {\n\n\t\tthis.parser = parser;\n\t\tthis.name = EXTENSIONS.KHR_TEXTURE_BASISU;\n\n\t}\n\n\tloadTexture( textureIndex ) {\n\n\t\tconst parser = this.parser;\n\t\tconst json = parser.json;\n\n\t\tconst textureDef = json.textures[ textureIndex ];\n\n\t\tif ( ! textureDef.extensions || ! textureDef.extensions[ this.name ] ) {\n\n\t\t\treturn null;\n\n\t\t}\n\n\t\tconst extension = textureDef.extensions[ this.name ];\n\t\tconst loader = parser.options.ktx2Loader;\n\n\t\tif ( ! loader ) {\n\n\t\t\tif ( json.extensionsRequired && json.extensionsRequired.indexOf( this.name ) >= 0 ) {\n\n\t\t\t\tthrow new Error( 'THREE.GLTFLoader: setKTX2Loader must be called before loading KTX2 textures' );\n\n\t\t\t} else {\n\n\t\t\t\t// Assumes that the extension is optional and that a fallback texture is present\n\t\t\t\treturn null;\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn parser.loadTextureImage( textureIndex, extension.source, loader );\n\n\t}\n\n}\n\n/**\n * WebP Texture Extension\n *\n * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/EXT_texture_webp\n */\nclass GLTFTextureWebPExtension {\n\n\tconstructor( parser ) {\n\n\t\tthis.parser = parser;\n\t\tthis.name = EXTENSIONS.EXT_TEXTURE_WEBP;\n\t\tthis.isSupported = null;\n\n\t}\n\n\tloadTexture( textureIndex ) {\n\n\t\tconst name = this.name;\n\t\tconst parser = this.parser;\n\t\tconst json = parser.json;\n\n\t\tconst textureDef = json.textures[ textureIndex ];\n\n\t\tif ( ! textureDef.extensions || ! textureDef.extensions[ name ] ) {\n\n\t\t\treturn null;\n\n\t\t}\n\n\t\tconst extension = textureDef.extensions[ name ];\n\t\tconst source = json.images[ extension.source ];\n\n\t\tlet loader = parser.textureLoader;\n\t\tif ( source.uri ) {\n\n\t\t\tconst handler = parser.options.manager.getHandler( source.uri );\n\t\t\tif ( handler !== null ) loader = handler;\n\n\t\t}\n\n\t\treturn this.detectSupport().then( function ( isSupported ) {\n\n\t\t\tif ( isSupported ) return parser.loadTextureImage( textureIndex, extension.source, loader );\n\n\t\t\tif ( json.extensionsRequired && json.extensionsRequired.indexOf( name ) >= 0 ) {\n\n\t\t\t\tthrow new Error( 'THREE.GLTFLoader: WebP required by asset but unsupported.' );\n\n\t\t\t}\n\n\t\t\t// Fall back to PNG or JPEG.\n\t\t\treturn parser.loadTexture( textureIndex );\n\n\t\t} );\n\n\t}\n\n\tdetectSupport() {\n\n\t\tif ( ! this.isSupported ) {\n\n\t\t\tthis.isSupported = new Promise( function ( resolve ) {\n\n\t\t\t\tconst image = new Image();\n\n\t\t\t\t// Lossy test image. Support for lossy images doesn't guarantee support for all\n\t\t\t\t// WebP images, unfortunately.\n\t\t\t\timage.src = 'data:image/webp;base64,UklGRiIAAABXRUJQVlA4IBYAAAAwAQCdASoBAAEADsD+JaQAA3AAAAAA';\n\n\t\t\t\timage.onload = image.onerror = function () {\n\n\t\t\t\t\tresolve( image.height === 1 );\n\n\t\t\t\t};\n\n\t\t\t} );\n\n\t\t}\n\n\t\treturn this.isSupported;\n\n\t}\n\n}\n\n/**\n * AVIF Texture Extension\n *\n * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/EXT_texture_avif\n */\nclass GLTFTextureAVIFExtension {\n\n\tconstructor( parser ) {\n\n\t\tthis.parser = parser;\n\t\tthis.name = EXTENSIONS.EXT_TEXTURE_AVIF;\n\t\tthis.isSupported = null;\n\n\t}\n\n\tloadTexture( textureIndex ) {\n\n\t\tconst name = this.name;\n\t\tconst parser = this.parser;\n\t\tconst json = parser.json;\n\n\t\tconst textureDef = json.textures[ textureIndex ];\n\n\t\tif ( ! textureDef.extensions || ! textureDef.extensions[ name ] ) {\n\n\t\t\treturn null;\n\n\t\t}\n\n\t\tconst extension = textureDef.extensions[ name ];\n\t\tconst source = json.images[ extension.source ];\n\n\t\tlet loader = parser.textureLoader;\n\t\tif ( source.uri ) {\n\n\t\t\tconst handler = parser.options.manager.getHandler( source.uri );\n\t\t\tif ( handler !== null ) loader = handler;\n\n\t\t}\n\n\t\treturn this.detectSupport().then( function ( isSupported ) {\n\n\t\t\tif ( isSupported ) return parser.loadTextureImage( textureIndex, extension.source, loader );\n\n\t\t\tif ( json.extensionsRequired && json.extensionsRequired.indexOf( name ) >= 0 ) {\n\n\t\t\t\tthrow new Error( 'THREE.GLTFLoader: AVIF required by asset but unsupported.' );\n\n\t\t\t}\n\n\t\t\t// Fall back to PNG or JPEG.\n\t\t\treturn parser.loadTexture( textureIndex );\n\n\t\t} );\n\n\t}\n\n\tdetectSupport() {\n\n\t\tif ( ! this.isSupported ) {\n\n\t\t\tthis.isSupported = new Promise( function ( resolve ) {\n\n\t\t\t\tconst image = new Image();\n\n\t\t\t\t// Lossy test image.\n\t\t\t\timage.src = 'data:image/avif;base64,AAAAIGZ0eXBhdmlmAAAAAGF2aWZtaWYxbWlhZk1BMUIAAADybWV0YQAAAAAAAAAoaGRscgAAAAAAAAAAcGljdAAAAAAAAAAAAAAAAGxpYmF2aWYAAAAADnBpdG0AAAAAAAEAAAAeaWxvYwAAAABEAAABAAEAAAABAAABGgAAABcAAAAoaWluZgAAAAAAAQAAABppbmZlAgAAAAABAABhdjAxQ29sb3IAAAAAamlwcnAAAABLaXBjbwAAABRpc3BlAAAAAAAAAAEAAAABAAAAEHBpeGkAAAAAAwgICAAAAAxhdjFDgQAMAAAAABNjb2xybmNseAACAAIABoAAAAAXaXBtYQAAAAAAAAABAAEEAQKDBAAAAB9tZGF0EgAKCBgABogQEDQgMgkQAAAAB8dSLfI=';\n\t\t\t\timage.onload = image.onerror = function () {\n\n\t\t\t\t\tresolve( image.height === 1 );\n\n\t\t\t\t};\n\n\t\t\t} );\n\n\t\t}\n\n\t\treturn this.isSupported;\n\n\t}\n\n}\n\n/**\n * meshopt BufferView Compression Extension\n *\n * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/EXT_meshopt_compression\n */\nclass GLTFMeshoptCompression {\n\n\tconstructor( parser ) {\n\n\t\tthis.name = EXTENSIONS.EXT_MESHOPT_COMPRESSION;\n\t\tthis.parser = parser;\n\n\t}\n\n\tloadBufferView( index ) {\n\n\t\tconst json = this.parser.json;\n\t\tconst bufferView = json.bufferViews[ index ];\n\n\t\tif ( bufferView.extensions && bufferView.extensions[ this.name ] ) {\n\n\t\t\tconst extensionDef = bufferView.extensions[ this.name ];\n\n\t\t\tconst buffer = this.parser.getDependency( 'buffer', extensionDef.buffer );\n\t\t\tconst decoder = this.parser.options.meshoptDecoder;\n\n\t\t\tif ( ! decoder || ! decoder.supported ) {\n\n\t\t\t\tif ( json.extensionsRequired && json.extensionsRequired.indexOf( this.name ) >= 0 ) {\n\n\t\t\t\t\tthrow new Error( 'THREE.GLTFLoader: setMeshoptDecoder must be called before loading compressed files' );\n\n\t\t\t\t} else {\n\n\t\t\t\t\t// Assumes that the extension is optional and that fallback buffer data is present\n\t\t\t\t\treturn null;\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\treturn buffer.then( function ( res ) {\n\n\t\t\t\tconst byteOffset = extensionDef.byteOffset || 0;\n\t\t\t\tconst byteLength = extensionDef.byteLength || 0;\n\n\t\t\t\tconst count = extensionDef.count;\n\t\t\t\tconst stride = extensionDef.byteStride;\n\n\t\t\t\tconst source = new Uint8Array( res, byteOffset, byteLength );\n\n\t\t\t\tif ( decoder.decodeGltfBufferAsync ) {\n\n\t\t\t\t\treturn decoder.decodeGltfBufferAsync( count, stride, source, extensionDef.mode, extensionDef.filter ).then( function ( res ) {\n\n\t\t\t\t\t\treturn res.buffer;\n\n\t\t\t\t\t} );\n\n\t\t\t\t} else {\n\n\t\t\t\t\t// Support for MeshoptDecoder 0.18 or earlier, without decodeGltfBufferAsync\n\t\t\t\t\treturn decoder.ready.then( function () {\n\n\t\t\t\t\t\tconst result = new ArrayBuffer( count * stride );\n\t\t\t\t\t\tdecoder.decodeGltfBuffer( new Uint8Array( result ), count, stride, source, extensionDef.mode, extensionDef.filter );\n\t\t\t\t\t\treturn result;\n\n\t\t\t\t\t} );\n\n\t\t\t\t}\n\n\t\t\t} );\n\n\t\t} else {\n\n\t\t\treturn null;\n\n\t\t}\n\n\t}\n\n}\n\n/**\n * GPU Instancing Extension\n *\n * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/EXT_mesh_gpu_instancing\n *\n */\nclass GLTFMeshGpuInstancing {\n\n\tconstructor( parser ) {\n\n\t\tthis.name = EXTENSIONS.EXT_MESH_GPU_INSTANCING;\n\t\tthis.parser = parser;\n\n\t}\n\n\tcreateNodeMesh( nodeIndex ) {\n\n\t\tconst json = this.parser.json;\n\t\tconst nodeDef = json.nodes[ nodeIndex ];\n\n\t\tif ( ! nodeDef.extensions || ! nodeDef.extensions[ this.name ] ||\n\t\t\tnodeDef.mesh === undefined ) {\n\n\t\t\treturn null;\n\n\t\t}\n\n\t\tconst meshDef = json.meshes[ nodeDef.mesh ];\n\n\t\t// No Points or Lines + Instancing support yet\n\n\t\tfor ( const primitive of meshDef.primitives ) {\n\n\t\t\tif ( primitive.mode !== WEBGL_CONSTANTS.TRIANGLES &&\n\t\t\t\t primitive.mode !== WEBGL_CONSTANTS.TRIANGLE_STRIP &&\n\t\t\t\t primitive.mode !== WEBGL_CONSTANTS.TRIANGLE_FAN &&\n\t\t\t\t primitive.mode !== undefined ) {\n\n\t\t\t\treturn null;\n\n\t\t\t}\n\n\t\t}\n\n\t\tconst extensionDef = nodeDef.extensions[ this.name ];\n\t\tconst attributesDef = extensionDef.attributes;\n\n\t\t// @TODO: Can we support InstancedMesh + SkinnedMesh?\n\n\t\tconst pending = [];\n\t\tconst attributes = {};\n\n\t\tfor ( const key in attributesDef ) {\n\n\t\t\tpending.push( this.parser.getDependency( 'accessor', attributesDef[ key ] ).then( accessor => {\n\n\t\t\t\tattributes[ key ] = accessor;\n\t\t\t\treturn attributes[ key ];\n\n\t\t\t} ) );\n\n\t\t}\n\n\t\tif ( pending.length < 1 ) {\n\n\t\t\treturn null;\n\n\t\t}\n\n\t\tpending.push( this.parser.createNodeMesh( nodeIndex ) );\n\n\t\treturn Promise.all( pending ).then( results => {\n\n\t\t\tconst nodeObject = results.pop();\n\t\t\tconst meshes = nodeObject.isGroup ? nodeObject.children : [ nodeObject ];\n\t\t\tconst count = results[ 0 ].count; // All attribute counts should be same\n\t\t\tconst instancedMeshes = [];\n\n\t\t\tfor ( const mesh of meshes ) {\n\n\t\t\t\t// Temporal variables\n\t\t\t\tconst m = new Matrix4();\n\t\t\t\tconst p = new Vector3();\n\t\t\t\tconst q = new Quaternion();\n\t\t\t\tconst s = new Vector3( 1, 1, 1 );\n\n\t\t\t\tconst instancedMesh = new InstancedMesh( mesh.geometry, mesh.material, count );\n\n\t\t\t\tfor ( let i = 0; i < count; i ++ ) {\n\n\t\t\t\t\tif ( attributes.TRANSLATION ) {\n\n\t\t\t\t\t\tp.fromBufferAttribute( attributes.TRANSLATION, i );\n\n\t\t\t\t\t}\n\n\t\t\t\t\tif ( attributes.ROTATION ) {\n\n\t\t\t\t\t\tq.fromBufferAttribute( attributes.ROTATION, i );\n\n\t\t\t\t\t}\n\n\t\t\t\t\tif ( attributes.SCALE ) {\n\n\t\t\t\t\t\ts.fromBufferAttribute( attributes.SCALE, i );\n\n\t\t\t\t\t}\n\n\t\t\t\t\tinstancedMesh.setMatrixAt( i, m.compose( p, q, s ) );\n\n\t\t\t\t}\n\n\t\t\t\t// Add instance attributes to the geometry, excluding TRS.\n\t\t\t\tfor ( const attributeName in attributes ) {\n\n\t\t\t\t\tif ( attributeName === '_COLOR_0' ) {\n\n\t\t\t\t\t\tconst attr = attributes[ attributeName ];\n\t\t\t\t\t\tinstancedMesh.instanceColor = new InstancedBufferAttribute( attr.array, attr.itemSize, attr.normalized );\n\n\t\t\t\t\t} else if ( attributeName !== 'TRANSLATION' &&\n\t\t\t\t\t\t attributeName !== 'ROTATION' &&\n\t\t\t\t\t\t attributeName !== 'SCALE' ) {\n\n\t\t\t\t\t\tmesh.geometry.setAttribute( attributeName, attributes[ attributeName ] );\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t\t// Just in case\n\t\t\t\tObject3D.prototype.copy.call( instancedMesh, mesh );\n\n\t\t\t\tthis.parser.assignFinalMaterial( instancedMesh );\n\n\t\t\t\tinstancedMeshes.push( instancedMesh );\n\n\t\t\t}\n\n\t\t\tif ( nodeObject.isGroup ) {\n\n\t\t\t\tnodeObject.clear();\n\n\t\t\t\tnodeObject.add( ... instancedMeshes );\n\n\t\t\t\treturn nodeObject;\n\n\t\t\t}\n\n\t\t\treturn instancedMeshes[ 0 ];\n\n\t\t} );\n\n\t}\n\n}\n\n/* BINARY EXTENSION */\nconst BINARY_EXTENSION_HEADER_MAGIC = 'glTF';\nconst BINARY_EXTENSION_HEADER_LENGTH = 12;\nconst BINARY_EXTENSION_CHUNK_TYPES = { JSON: 0x4E4F534A, BIN: 0x004E4942 };\n\nclass GLTFBinaryExtension {\n\n\tconstructor( data ) {\n\n\t\tthis.name = EXTENSIONS.KHR_BINARY_GLTF;\n\t\tthis.content = null;\n\t\tthis.body = null;\n\n\t\tconst headerView = new DataView( data, 0, BINARY_EXTENSION_HEADER_LENGTH );\n\t\tconst textDecoder = new TextDecoder();\n\n\t\tthis.header = {\n\t\t\tmagic: textDecoder.decode( new Uint8Array( data.slice( 0, 4 ) ) ),\n\t\t\tversion: headerView.getUint32( 4, true ),\n\t\t\tlength: headerView.getUint32( 8, true )\n\t\t};\n\n\t\tif ( this.header.magic !== BINARY_EXTENSION_HEADER_MAGIC ) {\n\n\t\t\tthrow new Error( 'THREE.GLTFLoader: Unsupported glTF-Binary header.' );\n\n\t\t} else if ( this.header.version < 2.0 ) {\n\n\t\t\tthrow new Error( 'THREE.GLTFLoader: Legacy binary file detected.' );\n\n\t\t}\n\n\t\tconst chunkContentsLength = this.header.length - BINARY_EXTENSION_HEADER_LENGTH;\n\t\tconst chunkView = new DataView( data, BINARY_EXTENSION_HEADER_LENGTH );\n\t\tlet chunkIndex = 0;\n\n\t\twhile ( chunkIndex < chunkContentsLength ) {\n\n\t\t\tconst chunkLength = chunkView.getUint32( chunkIndex, true );\n\t\t\tchunkIndex += 4;\n\n\t\t\tconst chunkType = chunkView.getUint32( chunkIndex, true );\n\t\t\tchunkIndex += 4;\n\n\t\t\tif ( chunkType === BINARY_EXTENSION_CHUNK_TYPES.JSON ) {\n\n\t\t\t\tconst contentArray = new Uint8Array( data, BINARY_EXTENSION_HEADER_LENGTH + chunkIndex, chunkLength );\n\t\t\t\tthis.content = textDecoder.decode( contentArray );\n\n\t\t\t} else if ( chunkType === BINARY_EXTENSION_CHUNK_TYPES.BIN ) {\n\n\t\t\t\tconst byteOffset = BINARY_EXTENSION_HEADER_LENGTH + chunkIndex;\n\t\t\t\tthis.body = data.slice( byteOffset, byteOffset + chunkLength );\n\n\t\t\t}\n\n\t\t\t// Clients must ignore chunks with unknown types.\n\n\t\t\tchunkIndex += chunkLength;\n\n\t\t}\n\n\t\tif ( this.content === null ) {\n\n\t\t\tthrow new Error( 'THREE.GLTFLoader: JSON content not found.' );\n\n\t\t}\n\n\t}\n\n}\n\n/**\n * DRACO Mesh Compression Extension\n *\n * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_draco_mesh_compression\n */\nclass GLTFDracoMeshCompressionExtension {\n\n\tconstructor( json, dracoLoader ) {\n\n\t\tif ( ! dracoLoader ) {\n\n\t\t\tthrow new Error( 'THREE.GLTFLoader: No DRACOLoader instance provided.' );\n\n\t\t}\n\n\t\tthis.name = EXTENSIONS.KHR_DRACO_MESH_COMPRESSION;\n\t\tthis.json = json;\n\t\tthis.dracoLoader = dracoLoader;\n\t\tthis.dracoLoader.preload();\n\n\t}\n\n\tdecodePrimitive( primitive, parser ) {\n\n\t\tconst json = this.json;\n\t\tconst dracoLoader = this.dracoLoader;\n\t\tconst bufferViewIndex = primitive.extensions[ this.name ].bufferView;\n\t\tconst gltfAttributeMap = primitive.extensions[ this.name ].attributes;\n\t\tconst threeAttributeMap = {};\n\t\tconst attributeNormalizedMap = {};\n\t\tconst attributeTypeMap = {};\n\n\t\tfor ( const attributeName in gltfAttributeMap ) {\n\n\t\t\tconst threeAttributeName = ATTRIBUTES[ attributeName ] || attributeName.toLowerCase();\n\n\t\t\tthreeAttributeMap[ threeAttributeName ] = gltfAttributeMap[ attributeName ];\n\n\t\t}\n\n\t\tfor ( const attributeName in primitive.attributes ) {\n\n\t\t\tconst threeAttributeName = ATTRIBUTES[ attributeName ] || attributeName.toLowerCase();\n\n\t\t\tif ( gltfAttributeMap[ attributeName ] !== undefined ) {\n\n\t\t\t\tconst accessorDef = json.accessors[ primitive.attributes[ attributeName ] ];\n\t\t\t\tconst componentType = WEBGL_COMPONENT_TYPES[ accessorDef.componentType ];\n\n\t\t\t\tattributeTypeMap[ threeAttributeName ] = componentType.name;\n\t\t\t\tattributeNormalizedMap[ threeAttributeName ] = accessorDef.normalized === true;\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn parser.getDependency( 'bufferView', bufferViewIndex ).then( function ( bufferView ) {\n\n\t\t\treturn new Promise( function ( resolve, reject ) {\n\n\t\t\t\tdracoLoader.decodeDracoFile( bufferView, function ( geometry ) {\n\n\t\t\t\t\tfor ( const attributeName in geometry.attributes ) {\n\n\t\t\t\t\t\tconst attribute = geometry.attributes[ attributeName ];\n\t\t\t\t\t\tconst normalized = attributeNormalizedMap[ attributeName ];\n\n\t\t\t\t\t\tif ( normalized !== undefined ) attribute.normalized = normalized;\n\n\t\t\t\t\t}\n\n\t\t\t\t\tresolve( geometry );\n\n\t\t\t\t}, threeAttributeMap, attributeTypeMap, LinearSRGBColorSpace, reject );\n\n\t\t\t} );\n\n\t\t} );\n\n\t}\n\n}\n\n/**\n * Texture Transform Extension\n *\n * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_texture_transform\n */\nclass GLTFTextureTransformExtension {\n\n\tconstructor() {\n\n\t\tthis.name = EXTENSIONS.KHR_TEXTURE_TRANSFORM;\n\n\t}\n\n\textendTexture( texture, transform ) {\n\n\t\tif ( ( transform.texCoord === undefined || transform.texCoord === texture.channel )\n\t\t\t&& transform.offset === undefined\n\t\t\t&& transform.rotation === undefined\n\t\t\t&& transform.scale === undefined ) {\n\n\t\t\t// See https://github.com/mrdoob/three.js/issues/21819.\n\t\t\treturn texture;\n\n\t\t}\n\n\t\ttexture = texture.clone();\n\n\t\tif ( transform.texCoord !== undefined ) {\n\n\t\t\ttexture.channel = transform.texCoord;\n\n\t\t}\n\n\t\tif ( transform.offset !== undefined ) {\n\n\t\t\ttexture.offset.fromArray( transform.offset );\n\n\t\t}\n\n\t\tif ( transform.rotation !== undefined ) {\n\n\t\t\ttexture.rotation = transform.rotation;\n\n\t\t}\n\n\t\tif ( transform.scale !== undefined ) {\n\n\t\t\ttexture.repeat.fromArray( transform.scale );\n\n\t\t}\n\n\t\ttexture.needsUpdate = true;\n\n\t\treturn texture;\n\n\t}\n\n}\n\n/**\n * Mesh Quantization Extension\n *\n * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_mesh_quantization\n */\nclass GLTFMeshQuantizationExtension {\n\n\tconstructor() {\n\n\t\tthis.name = EXTENSIONS.KHR_MESH_QUANTIZATION;\n\n\t}\n\n}\n\n/*********************************/\n/********** INTERPOLATION ********/\n/*********************************/\n\n// Spline Interpolation\n// Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#appendix-c-spline-interpolation\nclass GLTFCubicSplineInterpolant extends Interpolant {\n\n\tconstructor( parameterPositions, sampleValues, sampleSize, resultBuffer ) {\n\n\t\tsuper( parameterPositions, sampleValues, sampleSize, resultBuffer );\n\n\t}\n\n\tcopySampleValue_( index ) {\n\n\t\t// Copies a sample value to the result buffer. See description of glTF\n\t\t// CUBICSPLINE values layout in interpolate_() function below.\n\n\t\tconst result = this.resultBuffer,\n\t\t\tvalues = this.sampleValues,\n\t\t\tvalueSize = this.valueSize,\n\t\t\toffset = index * valueSize * 3 + valueSize;\n\n\t\tfor ( let i = 0; i !== valueSize; i ++ ) {\n\n\t\t\tresult[ i ] = values[ offset + i ];\n\n\t\t}\n\n\t\treturn result;\n\n\t}\n\n\tinterpolate_( i1, t0, t, t1 ) {\n\n\t\tconst result = this.resultBuffer;\n\t\tconst values = this.sampleValues;\n\t\tconst stride = this.valueSize;\n\n\t\tconst stride2 = stride * 2;\n\t\tconst stride3 = stride * 3;\n\n\t\tconst td = t1 - t0;\n\n\t\tconst p = ( t - t0 ) / td;\n\t\tconst pp = p * p;\n\t\tconst ppp = pp * p;\n\n\t\tconst offset1 = i1 * stride3;\n\t\tconst offset0 = offset1 - stride3;\n\n\t\tconst s2 = - 2 * ppp + 3 * pp;\n\t\tconst s3 = ppp - pp;\n\t\tconst s0 = 1 - s2;\n\t\tconst s1 = s3 - pp + p;\n\n\t\t// Layout of keyframe output values for CUBICSPLINE animations:\n\t\t// [ inTangent_1, splineVertex_1, outTangent_1, inTangent_2, splineVertex_2, ... ]\n\t\tfor ( let i = 0; i !== stride; i ++ ) {\n\n\t\t\tconst p0 = values[ offset0 + i + stride ]; // splineVertex_k\n\t\t\tconst m0 = values[ offset0 + i + stride2 ] * td; // outTangent_k * (t_k+1 - t_k)\n\t\t\tconst p1 = values[ offset1 + i + stride ]; // splineVertex_k+1\n\t\t\tconst m1 = values[ offset1 + i ] * td; // inTangent_k+1 * (t_k+1 - t_k)\n\n\t\t\tresult[ i ] = s0 * p0 + s1 * m0 + s2 * p1 + s3 * m1;\n\n\t\t}\n\n\t\treturn result;\n\n\t}\n\n}\n\nconst _q = new Quaternion();\n\nclass GLTFCubicSplineQuaternionInterpolant extends GLTFCubicSplineInterpolant {\n\n\tinterpolate_( i1, t0, t, t1 ) {\n\n\t\tconst result = super.interpolate_( i1, t0, t, t1 );\n\n\t\t_q.fromArray( result ).normalize().toArray( result );\n\n\t\treturn result;\n\n\t}\n\n}\n\n\n/*********************************/\n/********** INTERNALS ************/\n/*********************************/\n\n/* CONSTANTS */\n\nconst WEBGL_CONSTANTS = {\n\tFLOAT: 5126,\n\t//FLOAT_MAT2: 35674,\n\tFLOAT_MAT3: 35675,\n\tFLOAT_MAT4: 35676,\n\tFLOAT_VEC2: 35664,\n\tFLOAT_VEC3: 35665,\n\tFLOAT_VEC4: 35666,\n\tLINEAR: 9729,\n\tREPEAT: 10497,\n\tSAMPLER_2D: 35678,\n\tPOINTS: 0,\n\tLINES: 1,\n\tLINE_LOOP: 2,\n\tLINE_STRIP: 3,\n\tTRIANGLES: 4,\n\tTRIANGLE_STRIP: 5,\n\tTRIANGLE_FAN: 6,\n\tUNSIGNED_BYTE: 5121,\n\tUNSIGNED_SHORT: 5123\n};\n\nconst WEBGL_COMPONENT_TYPES = {\n\t5120: Int8Array,\n\t5121: Uint8Array,\n\t5122: Int16Array,\n\t5123: Uint16Array,\n\t5125: Uint32Array,\n\t5126: Float32Array\n};\n\nconst WEBGL_FILTERS = {\n\t9728: NearestFilter,\n\t9729: LinearFilter,\n\t9984: NearestMipmapNearestFilter,\n\t9985: LinearMipmapNearestFilter,\n\t9986: NearestMipmapLinearFilter,\n\t9987: LinearMipmapLinearFilter\n};\n\nconst WEBGL_WRAPPINGS = {\n\t33071: ClampToEdgeWrapping,\n\t33648: MirroredRepeatWrapping,\n\t10497: RepeatWrapping\n};\n\nconst WEBGL_TYPE_SIZES = {\n\t'SCALAR': 1,\n\t'VEC2': 2,\n\t'VEC3': 3,\n\t'VEC4': 4,\n\t'MAT2': 4,\n\t'MAT3': 9,\n\t'MAT4': 16\n};\n\nconst ATTRIBUTES = {\n\tPOSITION: 'position',\n\tNORMAL: 'normal',\n\tTANGENT: 'tangent',\n\tTEXCOORD_0: 'uv',\n\tTEXCOORD_1: 'uv1',\n\tTEXCOORD_2: 'uv2',\n\tTEXCOORD_3: 'uv3',\n\tCOLOR_0: 'color',\n\tWEIGHTS_0: 'skinWeight',\n\tJOINTS_0: 'skinIndex',\n};\n\nconst PATH_PROPERTIES = {\n\tscale: 'scale',\n\ttranslation: 'position',\n\trotation: 'quaternion',\n\tweights: 'morphTargetInfluences'\n};\n\nconst INTERPOLATION = {\n\tCUBICSPLINE: undefined, // We use a custom interpolant (GLTFCubicSplineInterpolation) for CUBICSPLINE tracks. Each\n\t\t // keyframe track will be initialized with a default interpolation type, then modified.\n\tLINEAR: InterpolateLinear,\n\tSTEP: InterpolateDiscrete\n};\n\nconst ALPHA_MODES = {\n\tOPAQUE: 'OPAQUE',\n\tMASK: 'MASK',\n\tBLEND: 'BLEND'\n};\n\n/**\n * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#default-material\n */\nfunction createDefaultMaterial( cache ) {\n\n\tif ( cache[ 'DefaultMaterial' ] === undefined ) {\n\n\t\tcache[ 'DefaultMaterial' ] = new MeshStandardMaterial( {\n\t\t\tcolor: 0xFFFFFF,\n\t\t\temissive: 0x000000,\n\t\t\tmetalness: 1,\n\t\t\troughness: 1,\n\t\t\ttransparent: false,\n\t\t\tdepthTest: true,\n\t\t\tside: FrontSide\n\t\t} );\n\n\t}\n\n\treturn cache[ 'DefaultMaterial' ];\n\n}\n\nfunction addUnknownExtensionsToUserData( knownExtensions, object, objectDef ) {\n\n\t// Add unknown glTF extensions to an object's userData.\n\n\tfor ( const name in objectDef.extensions ) {\n\n\t\tif ( knownExtensions[ name ] === undefined ) {\n\n\t\t\tobject.userData.gltfExtensions = object.userData.gltfExtensions || {};\n\t\t\tobject.userData.gltfExtensions[ name ] = objectDef.extensions[ name ];\n\n\t\t}\n\n\t}\n\n}\n\n/**\n * @param {Object3D|Material|BufferGeometry} object\n * @param {GLTF.definition} gltfDef\n */\nfunction assignExtrasToUserData( object, gltfDef ) {\n\n\tif ( gltfDef.extras !== undefined ) {\n\n\t\tif ( typeof gltfDef.extras === 'object' ) {\n\n\t\t\tObject.assign( object.userData, gltfDef.extras );\n\n\t\t} else {\n\n\t\t\tconsole.warn( 'THREE.GLTFLoader: Ignoring primitive type .extras, ' + gltfDef.extras );\n\n\t\t}\n\n\t}\n\n}\n\n/**\n * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#morph-targets\n *\n * @param {BufferGeometry} geometry\n * @param {Array} targets\n * @param {GLTFParser} parser\n * @return {Promise}\n */\nfunction addMorphTargets( geometry, targets, parser ) {\n\n\tlet hasMorphPosition = false;\n\tlet hasMorphNormal = false;\n\tlet hasMorphColor = false;\n\n\tfor ( let i = 0, il = targets.length; i < il; i ++ ) {\n\n\t\tconst target = targets[ i ];\n\n\t\tif ( target.POSITION !== undefined ) hasMorphPosition = true;\n\t\tif ( target.NORMAL !== undefined ) hasMorphNormal = true;\n\t\tif ( target.COLOR_0 !== undefined ) hasMorphColor = true;\n\n\t\tif ( hasMorphPosition && hasMorphNormal && hasMorphColor ) break;\n\n\t}\n\n\tif ( ! hasMorphPosition && ! hasMorphNormal && ! hasMorphColor ) return Promise.resolve( geometry );\n\n\tconst pendingPositionAccessors = [];\n\tconst pendingNormalAccessors = [];\n\tconst pendingColorAccessors = [];\n\n\tfor ( let i = 0, il = targets.length; i < il; i ++ ) {\n\n\t\tconst target = targets[ i ];\n\n\t\tif ( hasMorphPosition ) {\n\n\t\t\tconst pendingAccessor = target.POSITION !== undefined\n\t\t\t\t? parser.getDependency( 'accessor', target.POSITION )\n\t\t\t\t: geometry.attributes.position;\n\n\t\t\tpendingPositionAccessors.push( pendingAccessor );\n\n\t\t}\n\n\t\tif ( hasMorphNormal ) {\n\n\t\t\tconst pendingAccessor = target.NORMAL !== undefined\n\t\t\t\t? parser.getDependency( 'accessor', target.NORMAL )\n\t\t\t\t: geometry.attributes.normal;\n\n\t\t\tpendingNormalAccessors.push( pendingAccessor );\n\n\t\t}\n\n\t\tif ( hasMorphColor ) {\n\n\t\t\tconst pendingAccessor = target.COLOR_0 !== undefined\n\t\t\t\t? parser.getDependency( 'accessor', target.COLOR_0 )\n\t\t\t\t: geometry.attributes.color;\n\n\t\t\tpendingColorAccessors.push( pendingAccessor );\n\n\t\t}\n\n\t}\n\n\treturn Promise.all( [\n\t\tPromise.all( pendingPositionAccessors ),\n\t\tPromise.all( pendingNormalAccessors ),\n\t\tPromise.all( pendingColorAccessors )\n\t] ).then( function ( accessors ) {\n\n\t\tconst morphPositions = accessors[ 0 ];\n\t\tconst morphNormals = accessors[ 1 ];\n\t\tconst morphColors = accessors[ 2 ];\n\n\t\tif ( hasMorphPosition ) geometry.morphAttributes.position = morphPositions;\n\t\tif ( hasMorphNormal ) geometry.morphAttributes.normal = morphNormals;\n\t\tif ( hasMorphColor ) geometry.morphAttributes.color = morphColors;\n\t\tgeometry.morphTargetsRelative = true;\n\n\t\treturn geometry;\n\n\t} );\n\n}\n\n/**\n * @param {Mesh} mesh\n * @param {GLTF.Mesh} meshDef\n */\nfunction updateMorphTargets( mesh, meshDef ) {\n\n\tmesh.updateMorphTargets();\n\n\tif ( meshDef.weights !== undefined ) {\n\n\t\tfor ( let i = 0, il = meshDef.weights.length; i < il; i ++ ) {\n\n\t\t\tmesh.morphTargetInfluences[ i ] = meshDef.weights[ i ];\n\n\t\t}\n\n\t}\n\n\t// .extras has user-defined data, so check that .extras.targetNames is an array.\n\tif ( meshDef.extras && Array.isArray( meshDef.extras.targetNames ) ) {\n\n\t\tconst targetNames = meshDef.extras.targetNames;\n\n\t\tif ( mesh.morphTargetInfluences.length === targetNames.length ) {\n\n\t\t\tmesh.morphTargetDictionary = {};\n\n\t\t\tfor ( let i = 0, il = targetNames.length; i < il; i ++ ) {\n\n\t\t\t\tmesh.morphTargetDictionary[ targetNames[ i ] ] = i;\n\n\t\t\t}\n\n\t\t} else {\n\n\t\t\tconsole.warn( 'THREE.GLTFLoader: Invalid extras.targetNames length. Ignoring names.' );\n\n\t\t}\n\n\t}\n\n}\n\nfunction createPrimitiveKey( primitiveDef ) {\n\n\tlet geometryKey;\n\n\tconst dracoExtension = primitiveDef.extensions && primitiveDef.extensions[ EXTENSIONS.KHR_DRACO_MESH_COMPRESSION ];\n\n\tif ( dracoExtension ) {\n\n\t\tgeometryKey = 'draco:' + dracoExtension.bufferView\n\t\t\t\t+ ':' + dracoExtension.indices\n\t\t\t\t+ ':' + createAttributesKey( dracoExtension.attributes );\n\n\t} else {\n\n\t\tgeometryKey = primitiveDef.indices + ':' + createAttributesKey( primitiveDef.attributes ) + ':' + primitiveDef.mode;\n\n\t}\n\n\tif ( primitiveDef.targets !== undefined ) {\n\n\t\tfor ( let i = 0, il = primitiveDef.targets.length; i < il; i ++ ) {\n\n\t\t\tgeometryKey += ':' + createAttributesKey( primitiveDef.targets[ i ] );\n\n\t\t}\n\n\t}\n\n\treturn geometryKey;\n\n}\n\nfunction createAttributesKey( attributes ) {\n\n\tlet attributesKey = '';\n\n\tconst keys = Object.keys( attributes ).sort();\n\n\tfor ( let i = 0, il = keys.length; i < il; i ++ ) {\n\n\t\tattributesKey += keys[ i ] + ':' + attributes[ keys[ i ] ] + ';';\n\n\t}\n\n\treturn attributesKey;\n\n}\n\nfunction getNormalizedComponentScale( constructor ) {\n\n\t// Reference:\n\t// https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_mesh_quantization#encoding-quantized-data\n\n\tswitch ( constructor ) {\n\n\t\tcase Int8Array:\n\t\t\treturn 1 / 127;\n\n\t\tcase Uint8Array:\n\t\t\treturn 1 / 255;\n\n\t\tcase Int16Array:\n\t\t\treturn 1 / 32767;\n\n\t\tcase Uint16Array:\n\t\t\treturn 1 / 65535;\n\n\t\tdefault:\n\t\t\tthrow new Error( 'THREE.GLTFLoader: Unsupported normalized accessor component type.' );\n\n\t}\n\n}\n\nfunction getImageURIMimeType( uri ) {\n\n\tif ( uri.search( /\\.jpe?g($|\\?)/i ) > 0 || uri.search( /^data\\:image\\/jpeg/ ) === 0 ) return 'image/jpeg';\n\tif ( uri.search( /\\.webp($|\\?)/i ) > 0 || uri.search( /^data\\:image\\/webp/ ) === 0 ) return 'image/webp';\n\n\treturn 'image/png';\n\n}\n\nconst _identityMatrix = new Matrix4();\n\n/* GLTF PARSER */\n\nclass GLTFParser {\n\n\tconstructor( json = {}, options = {} ) {\n\n\t\tthis.json = json;\n\t\tthis.extensions = {};\n\t\tthis.plugins = {};\n\t\tthis.options = options;\n\n\t\t// loader object cache\n\t\tthis.cache = new GLTFRegistry();\n\n\t\t// associations between Three.js objects and glTF elements\n\t\tthis.associations = new Map();\n\n\t\t// BufferGeometry caching\n\t\tthis.primitiveCache = {};\n\n\t\t// Node cache\n\t\tthis.nodeCache = {};\n\n\t\t// Object3D instance caches\n\t\tthis.meshCache = { refs: {}, uses: {} };\n\t\tthis.cameraCache = { refs: {}, uses: {} };\n\t\tthis.lightCache = { refs: {}, uses: {} };\n\n\t\tthis.sourceCache = {};\n\t\tthis.textureCache = {};\n\n\t\t// Track node names, to ensure no duplicates\n\t\tthis.nodeNamesUsed = {};\n\n\t\t// Use an ImageBitmapLoader if imageBitmaps are supported. Moves much of the\n\t\t// expensive work of uploading a texture to the GPU off the main thread.\n\n\t\tlet isSafari = false;\n\t\tlet isFirefox = false;\n\t\tlet firefoxVersion = - 1;\n\n\t\tif ( typeof navigator !== 'undefined' ) {\n\n\t\t\tisSafari = /^((?!chrome|android).)*safari/i.test( navigator.userAgent ) === true;\n\t\t\tisFirefox = navigator.userAgent.indexOf( 'Firefox' ) > - 1;\n\t\t\tfirefoxVersion = isFirefox ? navigator.userAgent.match( /Firefox\\/([0-9]+)\\./ )[ 1 ] : - 1;\n\n\t\t}\n\n\t\tif ( typeof createImageBitmap === 'undefined' || isSafari || ( isFirefox && firefoxVersion < 98 ) ) {\n\n\t\t\tthis.textureLoader = new TextureLoader( this.options.manager );\n\n\t\t} else {\n\n\t\t\tthis.textureLoader = new ImageBitmapLoader( this.options.manager );\n\n\t\t}\n\n\t\tthis.textureLoader.setCrossOrigin( this.options.crossOrigin );\n\t\tthis.textureLoader.setRequestHeader( this.options.requestHeader );\n\n\t\tthis.fileLoader = new FileLoader( this.options.manager );\n\t\tthis.fileLoader.setResponseType( 'arraybuffer' );\n\n\t\tif ( this.options.crossOrigin === 'use-credentials' ) {\n\n\t\t\tthis.fileLoader.setWithCredentials( true );\n\n\t\t}\n\n\t}\n\n\tsetExtensions( extensions ) {\n\n\t\tthis.extensions = extensions;\n\n\t}\n\n\tsetPlugins( plugins ) {\n\n\t\tthis.plugins = plugins;\n\n\t}\n\n\tparse( onLoad, onError ) {\n\n\t\tconst parser = this;\n\t\tconst json = this.json;\n\t\tconst extensions = this.extensions;\n\n\t\t// Clear the loader cache\n\t\tthis.cache.removeAll();\n\t\tthis.nodeCache = {};\n\n\t\t// Mark the special nodes/meshes in json for efficient parse\n\t\tthis._invokeAll( function ( ext ) {\n\n\t\t\treturn ext._markDefs && ext._markDefs();\n\n\t\t} );\n\n\t\tPromise.all( this._invokeAll( function ( ext ) {\n\n\t\t\treturn ext.beforeRoot && ext.beforeRoot();\n\n\t\t} ) ).then( function () {\n\n\t\t\treturn Promise.all( [\n\n\t\t\t\tparser.getDependencies( 'scene' ),\n\t\t\t\tparser.getDependencies( 'animation' ),\n\t\t\t\tparser.getDependencies( 'camera' ),\n\n\t\t\t] );\n\n\t\t} ).then( function ( dependencies ) {\n\n\t\t\tconst result = {\n\t\t\t\tscene: dependencies[ 0 ][ json.scene || 0 ],\n\t\t\t\tscenes: dependencies[ 0 ],\n\t\t\t\tanimations: dependencies[ 1 ],\n\t\t\t\tcameras: dependencies[ 2 ],\n\t\t\t\tasset: json.asset,\n\t\t\t\tparser: parser,\n\t\t\t\tuserData: {}\n\t\t\t};\n\n\t\t\taddUnknownExtensionsToUserData( extensions, result, json );\n\n\t\t\tassignExtrasToUserData( result, json );\n\n\t\t\treturn Promise.all( parser._invokeAll( function ( ext ) {\n\n\t\t\t\treturn ext.afterRoot && ext.afterRoot( result );\n\n\t\t\t} ) ).then( function () {\n\n\t\t\t\tfor ( const scene of result.scenes ) {\n\n\t\t\t\t\tscene.updateMatrixWorld();\n\n\t\t\t\t}\n\n\t\t\t\tonLoad( result );\n\n\t\t\t} );\n\n\t\t} ).catch( onError );\n\n\t}\n\n\t/**\n\t * Marks the special nodes/meshes in json for efficient parse.\n\t */\n\t_markDefs() {\n\n\t\tconst nodeDefs = this.json.nodes || [];\n\t\tconst skinDefs = this.json.skins || [];\n\t\tconst meshDefs = this.json.meshes || [];\n\n\t\t// Nothing in the node definition indicates whether it is a Bone or an\n\t\t// Object3D. Use the skins' joint references to mark bones.\n\t\tfor ( let skinIndex = 0, skinLength = skinDefs.length; skinIndex < skinLength; skinIndex ++ ) {\n\n\t\t\tconst joints = skinDefs[ skinIndex ].joints;\n\n\t\t\tfor ( let i = 0, il = joints.length; i < il; i ++ ) {\n\n\t\t\t\tnodeDefs[ joints[ i ] ].isBone = true;\n\n\t\t\t}\n\n\t\t}\n\n\t\t// Iterate over all nodes, marking references to shared resources,\n\t\t// as well as skeleton joints.\n\t\tfor ( let nodeIndex = 0, nodeLength = nodeDefs.length; nodeIndex < nodeLength; nodeIndex ++ ) {\n\n\t\t\tconst nodeDef = nodeDefs[ nodeIndex ];\n\n\t\t\tif ( nodeDef.mesh !== undefined ) {\n\n\t\t\t\tthis._addNodeRef( this.meshCache, nodeDef.mesh );\n\n\t\t\t\t// Nothing in the mesh definition indicates whether it is\n\t\t\t\t// a SkinnedMesh or Mesh. Use the node's mesh reference\n\t\t\t\t// to mark SkinnedMesh if node has skin.\n\t\t\t\tif ( nodeDef.skin !== undefined ) {\n\n\t\t\t\t\tmeshDefs[ nodeDef.mesh ].isSkinnedMesh = true;\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tif ( nodeDef.camera !== undefined ) {\n\n\t\t\t\tthis._addNodeRef( this.cameraCache, nodeDef.camera );\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n\t/**\n\t * Counts references to shared node / Object3D resources. These resources\n\t * can be reused, or \"instantiated\", at multiple nodes in the scene\n\t * hierarchy. Mesh, Camera, and Light instances are instantiated and must\n\t * be marked. Non-scenegraph resources (like Materials, Geometries, and\n\t * Textures) can be reused directly and are not marked here.\n\t *\n\t * Example: CesiumMilkTruck sample model reuses \"Wheel\" meshes.\n\t */\n\t_addNodeRef( cache, index ) {\n\n\t\tif ( index === undefined ) return;\n\n\t\tif ( cache.refs[ index ] === undefined ) {\n\n\t\t\tcache.refs[ index ] = cache.uses[ index ] = 0;\n\n\t\t}\n\n\t\tcache.refs[ index ] ++;\n\n\t}\n\n\t/** Returns a reference to a shared resource, cloning it if necessary. */\n\t_getNodeRef( cache, index, object ) {\n\n\t\tif ( cache.refs[ index ] <= 1 ) return object;\n\n\t\tconst ref = object.clone();\n\n\t\t// Propagates mappings to the cloned object, prevents mappings on the\n\t\t// original object from being lost.\n\t\tconst updateMappings = ( original, clone ) => {\n\n\t\t\tconst mappings = this.associations.get( original );\n\t\t\tif ( mappings != null ) {\n\n\t\t\t\tthis.associations.set( clone, mappings );\n\n\t\t\t}\n\n\t\t\tfor ( const [ i, child ] of original.children.entries() ) {\n\n\t\t\t\tupdateMappings( child, clone.children[ i ] );\n\n\t\t\t}\n\n\t\t};\n\n\t\tupdateMappings( object, ref );\n\n\t\tref.name += '_instance_' + ( cache.uses[ index ] ++ );\n\n\t\treturn ref;\n\n\t}\n\n\t_invokeOne( func ) {\n\n\t\tconst extensions = Object.values( this.plugins );\n\t\textensions.push( this );\n\n\t\tfor ( let i = 0; i < extensions.length; i ++ ) {\n\n\t\t\tconst result = func( extensions[ i ] );\n\n\t\t\tif ( result ) return result;\n\n\t\t}\n\n\t\treturn null;\n\n\t}\n\n\t_invokeAll( func ) {\n\n\t\tconst extensions = Object.values( this.plugins );\n\t\textensions.unshift( this );\n\n\t\tconst pending = [];\n\n\t\tfor ( let i = 0; i < extensions.length; i ++ ) {\n\n\t\t\tconst result = func( extensions[ i ] );\n\n\t\t\tif ( result ) pending.push( result );\n\n\t\t}\n\n\t\treturn pending;\n\n\t}\n\n\t/**\n\t * Requests the specified dependency asynchronously, with caching.\n\t * @param {string} type\n\t * @param {number} index\n\t * @return {Promise}\n\t */\n\tgetDependency( type, index ) {\n\n\t\tconst cacheKey = type + ':' + index;\n\t\tlet dependency = this.cache.get( cacheKey );\n\n\t\tif ( ! dependency ) {\n\n\t\t\tswitch ( type ) {\n\n\t\t\t\tcase 'scene':\n\t\t\t\t\tdependency = this.loadScene( index );\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase 'node':\n\t\t\t\t\tdependency = this._invokeOne( function ( ext ) {\n\n\t\t\t\t\t\treturn ext.loadNode && ext.loadNode( index );\n\n\t\t\t\t\t} );\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase 'mesh':\n\t\t\t\t\tdependency = this._invokeOne( function ( ext ) {\n\n\t\t\t\t\t\treturn ext.loadMesh && ext.loadMesh( index );\n\n\t\t\t\t\t} );\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase 'accessor':\n\t\t\t\t\tdependency = this.loadAccessor( index );\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase 'bufferView':\n\t\t\t\t\tdependency = this._invokeOne( function ( ext ) {\n\n\t\t\t\t\t\treturn ext.loadBufferView && ext.loadBufferView( index );\n\n\t\t\t\t\t} );\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase 'buffer':\n\t\t\t\t\tdependency = this.loadBuffer( index );\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase 'material':\n\t\t\t\t\tdependency = this._invokeOne( function ( ext ) {\n\n\t\t\t\t\t\treturn ext.loadMaterial && ext.loadMaterial( index );\n\n\t\t\t\t\t} );\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase 'texture':\n\t\t\t\t\tdependency = this._invokeOne( function ( ext ) {\n\n\t\t\t\t\t\treturn ext.loadTexture && ext.loadTexture( index );\n\n\t\t\t\t\t} );\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase 'skin':\n\t\t\t\t\tdependency = this.loadSkin( index );\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase 'animation':\n\t\t\t\t\tdependency = this._invokeOne( function ( ext ) {\n\n\t\t\t\t\t\treturn ext.loadAnimation && ext.loadAnimation( index );\n\n\t\t\t\t\t} );\n\t\t\t\t\tbreak;\n\n\t\t\t\tcase 'camera':\n\t\t\t\t\tdependency = this.loadCamera( index );\n\t\t\t\t\tbreak;\n\n\t\t\t\tdefault:\n\t\t\t\t\tdependency = this._invokeOne( function ( ext ) {\n\n\t\t\t\t\t\treturn ext != this && ext.getDependency && ext.getDependency( type, index );\n\n\t\t\t\t\t} );\n\n\t\t\t\t\tif ( ! dependency ) {\n\n\t\t\t\t\t\tthrow new Error( 'Unknown type: ' + type );\n\n\t\t\t\t\t}\n\n\t\t\t\t\tbreak;\n\n\t\t\t}\n\n\t\t\tthis.cache.add( cacheKey, dependency );\n\n\t\t}\n\n\t\treturn dependency;\n\n\t}\n\n\t/**\n\t * Requests all dependencies of the specified type asynchronously, with caching.\n\t * @param {string} type\n\t * @return {Promise>}\n\t */\n\tgetDependencies( type ) {\n\n\t\tlet dependencies = this.cache.get( type );\n\n\t\tif ( ! dependencies ) {\n\n\t\t\tconst parser = this;\n\t\t\tconst defs = this.json[ type + ( type === 'mesh' ? 'es' : 's' ) ] || [];\n\n\t\t\tdependencies = Promise.all( defs.map( function ( def, index ) {\n\n\t\t\t\treturn parser.getDependency( type, index );\n\n\t\t\t} ) );\n\n\t\t\tthis.cache.add( type, dependencies );\n\n\t\t}\n\n\t\treturn dependencies;\n\n\t}\n\n\t/**\n\t * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views\n\t * @param {number} bufferIndex\n\t * @return {Promise}\n\t */\n\tloadBuffer( bufferIndex ) {\n\n\t\tconst bufferDef = this.json.buffers[ bufferIndex ];\n\t\tconst loader = this.fileLoader;\n\n\t\tif ( bufferDef.type && bufferDef.type !== 'arraybuffer' ) {\n\n\t\t\tthrow new Error( 'THREE.GLTFLoader: ' + bufferDef.type + ' buffer type is not supported.' );\n\n\t\t}\n\n\t\t// If present, GLB container is required to be the first buffer.\n\t\tif ( bufferDef.uri === undefined && bufferIndex === 0 ) {\n\n\t\t\treturn Promise.resolve( this.extensions[ EXTENSIONS.KHR_BINARY_GLTF ].body );\n\n\t\t}\n\n\t\tconst options = this.options;\n\n\t\treturn new Promise( function ( resolve, reject ) {\n\n\t\t\tloader.load( LoaderUtils.resolveURL( bufferDef.uri, options.path ), resolve, undefined, function () {\n\n\t\t\t\treject( new Error( 'THREE.GLTFLoader: Failed to load buffer \"' + bufferDef.uri + '\".' ) );\n\n\t\t\t} );\n\n\t\t} );\n\n\t}\n\n\t/**\n\t * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views\n\t * @param {number} bufferViewIndex\n\t * @return {Promise}\n\t */\n\tloadBufferView( bufferViewIndex ) {\n\n\t\tconst bufferViewDef = this.json.bufferViews[ bufferViewIndex ];\n\n\t\treturn this.getDependency( 'buffer', bufferViewDef.buffer ).then( function ( buffer ) {\n\n\t\t\tconst byteLength = bufferViewDef.byteLength || 0;\n\t\t\tconst byteOffset = bufferViewDef.byteOffset || 0;\n\t\t\treturn buffer.slice( byteOffset, byteOffset + byteLength );\n\n\t\t} );\n\n\t}\n\n\t/**\n\t * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#accessors\n\t * @param {number} accessorIndex\n\t * @return {Promise}\n\t */\n\tloadAccessor( accessorIndex ) {\n\n\t\tconst parser = this;\n\t\tconst json = this.json;\n\n\t\tconst accessorDef = this.json.accessors[ accessorIndex ];\n\n\t\tif ( accessorDef.bufferView === undefined && accessorDef.sparse === undefined ) {\n\n\t\t\tconst itemSize = WEBGL_TYPE_SIZES[ accessorDef.type ];\n\t\t\tconst TypedArray = WEBGL_COMPONENT_TYPES[ accessorDef.componentType ];\n\t\t\tconst normalized = accessorDef.normalized === true;\n\n\t\t\tconst array = new TypedArray( accessorDef.count * itemSize );\n\t\t\treturn Promise.resolve( new BufferAttribute( array, itemSize, normalized ) );\n\n\t\t}\n\n\t\tconst pendingBufferViews = [];\n\n\t\tif ( accessorDef.bufferView !== undefined ) {\n\n\t\t\tpendingBufferViews.push( this.getDependency( 'bufferView', accessorDef.bufferView ) );\n\n\t\t} else {\n\n\t\t\tpendingBufferViews.push( null );\n\n\t\t}\n\n\t\tif ( accessorDef.sparse !== undefined ) {\n\n\t\t\tpendingBufferViews.push( this.getDependency( 'bufferView', accessorDef.sparse.indices.bufferView ) );\n\t\t\tpendingBufferViews.push( this.getDependency( 'bufferView', accessorDef.sparse.values.bufferView ) );\n\n\t\t}\n\n\t\treturn Promise.all( pendingBufferViews ).then( function ( bufferViews ) {\n\n\t\t\tconst bufferView = bufferViews[ 0 ];\n\n\t\t\tconst itemSize = WEBGL_TYPE_SIZES[ accessorDef.type ];\n\t\t\tconst TypedArray = WEBGL_COMPONENT_TYPES[ accessorDef.componentType ];\n\n\t\t\t// For VEC3: itemSize is 3, elementBytes is 4, itemBytes is 12.\n\t\t\tconst elementBytes = TypedArray.BYTES_PER_ELEMENT;\n\t\t\tconst itemBytes = elementBytes * itemSize;\n\t\t\tconst byteOffset = accessorDef.byteOffset || 0;\n\t\t\tconst byteStride = accessorDef.bufferView !== undefined ? json.bufferViews[ accessorDef.bufferView ].byteStride : undefined;\n\t\t\tconst normalized = accessorDef.normalized === true;\n\t\t\tlet array, bufferAttribute;\n\n\t\t\t// The buffer is not interleaved if the stride is the item size in bytes.\n\t\t\tif ( byteStride && byteStride !== itemBytes ) {\n\n\t\t\t\t// Each \"slice\" of the buffer, as defined by 'count' elements of 'byteStride' bytes, gets its own InterleavedBuffer\n\t\t\t\t// This makes sure that IBA.count reflects accessor.count properly\n\t\t\t\tconst ibSlice = Math.floor( byteOffset / byteStride );\n\t\t\t\tconst ibCacheKey = 'InterleavedBuffer:' + accessorDef.bufferView + ':' + accessorDef.componentType + ':' + ibSlice + ':' + accessorDef.count;\n\t\t\t\tlet ib = parser.cache.get( ibCacheKey );\n\n\t\t\t\tif ( ! ib ) {\n\n\t\t\t\t\tarray = new TypedArray( bufferView, ibSlice * byteStride, accessorDef.count * byteStride / elementBytes );\n\n\t\t\t\t\t// Integer parameters to IB/IBA are in array elements, not bytes.\n\t\t\t\t\tib = new InterleavedBuffer( array, byteStride / elementBytes );\n\n\t\t\t\t\tparser.cache.add( ibCacheKey, ib );\n\n\t\t\t\t}\n\n\t\t\t\tbufferAttribute = new InterleavedBufferAttribute( ib, itemSize, ( byteOffset % byteStride ) / elementBytes, normalized );\n\n\t\t\t} else {\n\n\t\t\t\tif ( bufferView === null ) {\n\n\t\t\t\t\tarray = new TypedArray( accessorDef.count * itemSize );\n\n\t\t\t\t} else {\n\n\t\t\t\t\tarray = new TypedArray( bufferView, byteOffset, accessorDef.count * itemSize );\n\n\t\t\t\t}\n\n\t\t\t\tbufferAttribute = new BufferAttribute( array, itemSize, normalized );\n\n\t\t\t}\n\n\t\t\t// https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#sparse-accessors\n\t\t\tif ( accessorDef.sparse !== undefined ) {\n\n\t\t\t\tconst itemSizeIndices = WEBGL_TYPE_SIZES.SCALAR;\n\t\t\t\tconst TypedArrayIndices = WEBGL_COMPONENT_TYPES[ accessorDef.sparse.indices.componentType ];\n\n\t\t\t\tconst byteOffsetIndices = accessorDef.sparse.indices.byteOffset || 0;\n\t\t\t\tconst byteOffsetValues = accessorDef.sparse.values.byteOffset || 0;\n\n\t\t\t\tconst sparseIndices = new TypedArrayIndices( bufferViews[ 1 ], byteOffsetIndices, accessorDef.sparse.count * itemSizeIndices );\n\t\t\t\tconst sparseValues = new TypedArray( bufferViews[ 2 ], byteOffsetValues, accessorDef.sparse.count * itemSize );\n\n\t\t\t\tif ( bufferView !== null ) {\n\n\t\t\t\t\t// Avoid modifying the original ArrayBuffer, if the bufferView wasn't initialized with zeroes.\n\t\t\t\t\tbufferAttribute = new BufferAttribute( bufferAttribute.array.slice(), bufferAttribute.itemSize, bufferAttribute.normalized );\n\n\t\t\t\t}\n\n\t\t\t\tfor ( let i = 0, il = sparseIndices.length; i < il; i ++ ) {\n\n\t\t\t\t\tconst index = sparseIndices[ i ];\n\n\t\t\t\t\tbufferAttribute.setX( index, sparseValues[ i * itemSize ] );\n\t\t\t\t\tif ( itemSize >= 2 ) bufferAttribute.setY( index, sparseValues[ i * itemSize + 1 ] );\n\t\t\t\t\tif ( itemSize >= 3 ) bufferAttribute.setZ( index, sparseValues[ i * itemSize + 2 ] );\n\t\t\t\t\tif ( itemSize >= 4 ) bufferAttribute.setW( index, sparseValues[ i * itemSize + 3 ] );\n\t\t\t\t\tif ( itemSize >= 5 ) throw new Error( 'THREE.GLTFLoader: Unsupported itemSize in sparse BufferAttribute.' );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\treturn bufferAttribute;\n\n\t\t} );\n\n\t}\n\n\t/**\n\t * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#textures\n\t * @param {number} textureIndex\n\t * @return {Promise}\n\t */\n\tloadTexture( textureIndex ) {\n\n\t\tconst json = this.json;\n\t\tconst options = this.options;\n\t\tconst textureDef = json.textures[ textureIndex ];\n\t\tconst sourceIndex = textureDef.source;\n\t\tconst sourceDef = json.images[ sourceIndex ];\n\n\t\tlet loader = this.textureLoader;\n\n\t\tif ( sourceDef.uri ) {\n\n\t\t\tconst handler = options.manager.getHandler( sourceDef.uri );\n\t\t\tif ( handler !== null ) loader = handler;\n\n\t\t}\n\n\t\treturn this.loadTextureImage( textureIndex, sourceIndex, loader );\n\n\t}\n\n\tloadTextureImage( textureIndex, sourceIndex, loader ) {\n\n\t\tconst parser = this;\n\t\tconst json = this.json;\n\n\t\tconst textureDef = json.textures[ textureIndex ];\n\t\tconst sourceDef = json.images[ sourceIndex ];\n\n\t\tconst cacheKey = ( sourceDef.uri || sourceDef.bufferView ) + ':' + textureDef.sampler;\n\n\t\tif ( this.textureCache[ cacheKey ] ) {\n\n\t\t\t// See https://github.com/mrdoob/three.js/issues/21559.\n\t\t\treturn this.textureCache[ cacheKey ];\n\n\t\t}\n\n\t\tconst promise = this.loadImageSource( sourceIndex, loader ).then( function ( texture ) {\n\n\t\t\ttexture.flipY = false;\n\n\t\t\ttexture.name = textureDef.name || sourceDef.name || '';\n\n\t\t\tif ( texture.name === '' && typeof sourceDef.uri === 'string' && sourceDef.uri.startsWith( 'data:image/' ) === false ) {\n\n\t\t\t\ttexture.name = sourceDef.uri;\n\n\t\t\t}\n\n\t\t\tconst samplers = json.samplers || {};\n\t\t\tconst sampler = samplers[ textureDef.sampler ] || {};\n\n\t\t\ttexture.magFilter = WEBGL_FILTERS[ sampler.magFilter ] || LinearFilter;\n\t\t\ttexture.minFilter = WEBGL_FILTERS[ sampler.minFilter ] || LinearMipmapLinearFilter;\n\t\t\ttexture.wrapS = WEBGL_WRAPPINGS[ sampler.wrapS ] || RepeatWrapping;\n\t\t\ttexture.wrapT = WEBGL_WRAPPINGS[ sampler.wrapT ] || RepeatWrapping;\n\n\t\t\tparser.associations.set( texture, { textures: textureIndex } );\n\n\t\t\treturn texture;\n\n\t\t} ).catch( function () {\n\n\t\t\treturn null;\n\n\t\t} );\n\n\t\tthis.textureCache[ cacheKey ] = promise;\n\n\t\treturn promise;\n\n\t}\n\n\tloadImageSource( sourceIndex, loader ) {\n\n\t\tconst parser = this;\n\t\tconst json = this.json;\n\t\tconst options = this.options;\n\n\t\tif ( this.sourceCache[ sourceIndex ] !== undefined ) {\n\n\t\t\treturn this.sourceCache[ sourceIndex ].then( ( texture ) => texture.clone() );\n\n\t\t}\n\n\t\tconst sourceDef = json.images[ sourceIndex ];\n\n\t\tconst URL = self.URL || self.webkitURL;\n\n\t\tlet sourceURI = sourceDef.uri || '';\n\t\tlet isObjectURL = false;\n\n\t\tif ( sourceDef.bufferView !== undefined ) {\n\n\t\t\t// Load binary image data from bufferView, if provided.\n\n\t\t\tsourceURI = parser.getDependency( 'bufferView', sourceDef.bufferView ).then( function ( bufferView ) {\n\n\t\t\t\tisObjectURL = true;\n\t\t\t\tconst blob = new Blob( [ bufferView ], { type: sourceDef.mimeType } );\n\t\t\t\tsourceURI = URL.createObjectURL( blob );\n\t\t\t\treturn sourceURI;\n\n\t\t\t} );\n\n\t\t} else if ( sourceDef.uri === undefined ) {\n\n\t\t\tthrow new Error( 'THREE.GLTFLoader: Image ' + sourceIndex + ' is missing URI and bufferView' );\n\n\t\t}\n\n\t\tconst promise = Promise.resolve( sourceURI ).then( function ( sourceURI ) {\n\n\t\t\treturn new Promise( function ( resolve, reject ) {\n\n\t\t\t\tlet onLoad = resolve;\n\n\t\t\t\tif ( loader.isImageBitmapLoader === true ) {\n\n\t\t\t\t\tonLoad = function ( imageBitmap ) {\n\n\t\t\t\t\t\tconst texture = new Texture( imageBitmap );\n\t\t\t\t\t\ttexture.needsUpdate = true;\n\n\t\t\t\t\t\tresolve( texture );\n\n\t\t\t\t\t};\n\n\t\t\t\t}\n\n\t\t\t\tloader.load( LoaderUtils.resolveURL( sourceURI, options.path ), onLoad, undefined, reject );\n\n\t\t\t} );\n\n\t\t} ).then( function ( texture ) {\n\n\t\t\t// Clean up resources and configure Texture.\n\n\t\t\tif ( isObjectURL === true ) {\n\n\t\t\t\tURL.revokeObjectURL( sourceURI );\n\n\t\t\t}\n\n\t\t\ttexture.userData.mimeType = sourceDef.mimeType || getImageURIMimeType( sourceDef.uri );\n\n\t\t\treturn texture;\n\n\t\t} ).catch( function ( error ) {\n\n\t\t\tconsole.error( 'THREE.GLTFLoader: Couldn\\'t load texture', sourceURI );\n\t\t\tthrow error;\n\n\t\t} );\n\n\t\tthis.sourceCache[ sourceIndex ] = promise;\n\t\treturn promise;\n\n\t}\n\n\t/**\n\t * Asynchronously assigns a texture to the given material parameters.\n\t * @param {Object} materialParams\n\t * @param {string} mapName\n\t * @param {Object} mapDef\n\t * @return {Promise}\n\t */\n\tassignTexture( materialParams, mapName, mapDef, colorSpace ) {\n\n\t\tconst parser = this;\n\n\t\treturn this.getDependency( 'texture', mapDef.index ).then( function ( texture ) {\n\n\t\t\tif ( ! texture ) return null;\n\n\t\t\tif ( mapDef.texCoord !== undefined && mapDef.texCoord > 0 ) {\n\n\t\t\t\ttexture = texture.clone();\n\t\t\t\ttexture.channel = mapDef.texCoord;\n\n\t\t\t}\n\n\t\t\tif ( parser.extensions[ EXTENSIONS.KHR_TEXTURE_TRANSFORM ] ) {\n\n\t\t\t\tconst transform = mapDef.extensions !== undefined ? mapDef.extensions[ EXTENSIONS.KHR_TEXTURE_TRANSFORM ] : undefined;\n\n\t\t\t\tif ( transform ) {\n\n\t\t\t\t\tconst gltfReference = parser.associations.get( texture );\n\t\t\t\t\ttexture = parser.extensions[ EXTENSIONS.KHR_TEXTURE_TRANSFORM ].extendTexture( texture, transform );\n\t\t\t\t\tparser.associations.set( texture, gltfReference );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tif ( colorSpace !== undefined ) {\n\n\t\t\t\ttexture.colorSpace = colorSpace;\n\n\t\t\t}\n\n\t\t\tmaterialParams[ mapName ] = texture;\n\n\t\t\treturn texture;\n\n\t\t} );\n\n\t}\n\n\t/**\n\t * Assigns final material to a Mesh, Line, or Points instance. The instance\n\t * already has a material (generated from the glTF material options alone)\n\t * but reuse of the same glTF material may require multiple threejs materials\n\t * to accommodate different primitive types, defines, etc. New materials will\n\t * be created if necessary, and reused from a cache.\n\t * @param {Object3D} mesh Mesh, Line, or Points instance.\n\t */\n\tassignFinalMaterial( mesh ) {\n\n\t\tconst geometry = mesh.geometry;\n\t\tlet material = mesh.material;\n\n\t\tconst useDerivativeTangents = geometry.attributes.tangent === undefined;\n\t\tconst useVertexColors = geometry.attributes.color !== undefined;\n\t\tconst useFlatShading = geometry.attributes.normal === undefined;\n\n\t\tif ( mesh.isPoints ) {\n\n\t\t\tconst cacheKey = 'PointsMaterial:' + material.uuid;\n\n\t\t\tlet pointsMaterial = this.cache.get( cacheKey );\n\n\t\t\tif ( ! pointsMaterial ) {\n\n\t\t\t\tpointsMaterial = new PointsMaterial();\n\t\t\t\tMaterial.prototype.copy.call( pointsMaterial, material );\n\t\t\t\tpointsMaterial.color.copy( material.color );\n\t\t\t\tpointsMaterial.map = material.map;\n\t\t\t\tpointsMaterial.sizeAttenuation = false; // glTF spec says points should be 1px\n\n\t\t\t\tthis.cache.add( cacheKey, pointsMaterial );\n\n\t\t\t}\n\n\t\t\tmaterial = pointsMaterial;\n\n\t\t} else if ( mesh.isLine ) {\n\n\t\t\tconst cacheKey = 'LineBasicMaterial:' + material.uuid;\n\n\t\t\tlet lineMaterial = this.cache.get( cacheKey );\n\n\t\t\tif ( ! lineMaterial ) {\n\n\t\t\t\tlineMaterial = new LineBasicMaterial();\n\t\t\t\tMaterial.prototype.copy.call( lineMaterial, material );\n\t\t\t\tlineMaterial.color.copy( material.color );\n\t\t\t\tlineMaterial.map = material.map;\n\n\t\t\t\tthis.cache.add( cacheKey, lineMaterial );\n\n\t\t\t}\n\n\t\t\tmaterial = lineMaterial;\n\n\t\t}\n\n\t\t// Clone the material if it will be modified\n\t\tif ( useDerivativeTangents || useVertexColors || useFlatShading ) {\n\n\t\t\tlet cacheKey = 'ClonedMaterial:' + material.uuid + ':';\n\n\t\t\tif ( useDerivativeTangents ) cacheKey += 'derivative-tangents:';\n\t\t\tif ( useVertexColors ) cacheKey += 'vertex-colors:';\n\t\t\tif ( useFlatShading ) cacheKey += 'flat-shading:';\n\n\t\t\tlet cachedMaterial = this.cache.get( cacheKey );\n\n\t\t\tif ( ! cachedMaterial ) {\n\n\t\t\t\tcachedMaterial = material.clone();\n\n\t\t\t\tif ( useVertexColors ) cachedMaterial.vertexColors = true;\n\t\t\t\tif ( useFlatShading ) cachedMaterial.flatShading = true;\n\n\t\t\t\tif ( useDerivativeTangents ) {\n\n\t\t\t\t\t// https://github.com/mrdoob/three.js/issues/11438#issuecomment-507003995\n\t\t\t\t\tif ( cachedMaterial.normalScale ) cachedMaterial.normalScale.y *= - 1;\n\t\t\t\t\tif ( cachedMaterial.clearcoatNormalScale ) cachedMaterial.clearcoatNormalScale.y *= - 1;\n\n\t\t\t\t}\n\n\t\t\t\tthis.cache.add( cacheKey, cachedMaterial );\n\n\t\t\t\tthis.associations.set( cachedMaterial, this.associations.get( material ) );\n\n\t\t\t}\n\n\t\t\tmaterial = cachedMaterial;\n\n\t\t}\n\n\t\tmesh.material = material;\n\n\t}\n\n\tgetMaterialType( /* materialIndex */ ) {\n\n\t\treturn MeshStandardMaterial;\n\n\t}\n\n\t/**\n\t * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#materials\n\t * @param {number} materialIndex\n\t * @return {Promise}\n\t */\n\tloadMaterial( materialIndex ) {\n\n\t\tconst parser = this;\n\t\tconst json = this.json;\n\t\tconst extensions = this.extensions;\n\t\tconst materialDef = json.materials[ materialIndex ];\n\n\t\tlet materialType;\n\t\tconst materialParams = {};\n\t\tconst materialExtensions = materialDef.extensions || {};\n\n\t\tconst pending = [];\n\n\t\tif ( materialExtensions[ EXTENSIONS.KHR_MATERIALS_UNLIT ] ) {\n\n\t\t\tconst kmuExtension = extensions[ EXTENSIONS.KHR_MATERIALS_UNLIT ];\n\t\t\tmaterialType = kmuExtension.getMaterialType();\n\t\t\tpending.push( kmuExtension.extendParams( materialParams, materialDef, parser ) );\n\n\t\t} else {\n\n\t\t\t// Specification:\n\t\t\t// https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#metallic-roughness-material\n\n\t\t\tconst metallicRoughness = materialDef.pbrMetallicRoughness || {};\n\n\t\t\tmaterialParams.color = new Color( 1.0, 1.0, 1.0 );\n\t\t\tmaterialParams.opacity = 1.0;\n\n\t\t\tif ( Array.isArray( metallicRoughness.baseColorFactor ) ) {\n\n\t\t\t\tconst array = metallicRoughness.baseColorFactor;\n\n\t\t\t\tmaterialParams.color.setRGB( array[ 0 ], array[ 1 ], array[ 2 ], LinearSRGBColorSpace );\n\t\t\t\tmaterialParams.opacity = array[ 3 ];\n\n\t\t\t}\n\n\t\t\tif ( metallicRoughness.baseColorTexture !== undefined ) {\n\n\t\t\t\tpending.push( parser.assignTexture( materialParams, 'map', metallicRoughness.baseColorTexture, SRGBColorSpace ) );\n\n\t\t\t}\n\n\t\t\tmaterialParams.metalness = metallicRoughness.metallicFactor !== undefined ? metallicRoughness.metallicFactor : 1.0;\n\t\t\tmaterialParams.roughness = metallicRoughness.roughnessFactor !== undefined ? metallicRoughness.roughnessFactor : 1.0;\n\n\t\t\tif ( metallicRoughness.metallicRoughnessTexture !== undefined ) {\n\n\t\t\t\tpending.push( parser.assignTexture( materialParams, 'metalnessMap', metallicRoughness.metallicRoughnessTexture ) );\n\t\t\t\tpending.push( parser.assignTexture( materialParams, 'roughnessMap', metallicRoughness.metallicRoughnessTexture ) );\n\n\t\t\t}\n\n\t\t\tmaterialType = this._invokeOne( function ( ext ) {\n\n\t\t\t\treturn ext.getMaterialType && ext.getMaterialType( materialIndex );\n\n\t\t\t} );\n\n\t\t\tpending.push( Promise.all( this._invokeAll( function ( ext ) {\n\n\t\t\t\treturn ext.extendMaterialParams && ext.extendMaterialParams( materialIndex, materialParams );\n\n\t\t\t} ) ) );\n\n\t\t}\n\n\t\tif ( materialDef.doubleSided === true ) {\n\n\t\t\tmaterialParams.side = DoubleSide;\n\n\t\t}\n\n\t\tconst alphaMode = materialDef.alphaMode || ALPHA_MODES.OPAQUE;\n\n\t\tif ( alphaMode === ALPHA_MODES.BLEND ) {\n\n\t\t\tmaterialParams.transparent = true;\n\n\t\t\t// See: https://github.com/mrdoob/three.js/issues/17706\n\t\t\tmaterialParams.depthWrite = false;\n\n\t\t} else {\n\n\t\t\tmaterialParams.transparent = false;\n\n\t\t\tif ( alphaMode === ALPHA_MODES.MASK ) {\n\n\t\t\t\tmaterialParams.alphaTest = materialDef.alphaCutoff !== undefined ? materialDef.alphaCutoff : 0.5;\n\n\t\t\t}\n\n\t\t}\n\n\t\tif ( materialDef.normalTexture !== undefined && materialType !== MeshBasicMaterial ) {\n\n\t\t\tpending.push( parser.assignTexture( materialParams, 'normalMap', materialDef.normalTexture ) );\n\n\t\t\tmaterialParams.normalScale = new Vector2( 1, 1 );\n\n\t\t\tif ( materialDef.normalTexture.scale !== undefined ) {\n\n\t\t\t\tconst scale = materialDef.normalTexture.scale;\n\n\t\t\t\tmaterialParams.normalScale.set( scale, scale );\n\n\t\t\t}\n\n\t\t}\n\n\t\tif ( materialDef.occlusionTexture !== undefined && materialType !== MeshBasicMaterial ) {\n\n\t\t\tpending.push( parser.assignTexture( materialParams, 'aoMap', materialDef.occlusionTexture ) );\n\n\t\t\tif ( materialDef.occlusionTexture.strength !== undefined ) {\n\n\t\t\t\tmaterialParams.aoMapIntensity = materialDef.occlusionTexture.strength;\n\n\t\t\t}\n\n\t\t}\n\n\t\tif ( materialDef.emissiveFactor !== undefined && materialType !== MeshBasicMaterial ) {\n\n\t\t\tconst emissiveFactor = materialDef.emissiveFactor;\n\t\t\tmaterialParams.emissive = new Color().setRGB( emissiveFactor[ 0 ], emissiveFactor[ 1 ], emissiveFactor[ 2 ], LinearSRGBColorSpace );\n\n\t\t}\n\n\t\tif ( materialDef.emissiveTexture !== undefined && materialType !== MeshBasicMaterial ) {\n\n\t\t\tpending.push( parser.assignTexture( materialParams, 'emissiveMap', materialDef.emissiveTexture, SRGBColorSpace ) );\n\n\t\t}\n\n\t\treturn Promise.all( pending ).then( function () {\n\n\t\t\tconst material = new materialType( materialParams );\n\n\t\t\tif ( materialDef.name ) material.name = materialDef.name;\n\n\t\t\tassignExtrasToUserData( material, materialDef );\n\n\t\t\tparser.associations.set( material, { materials: materialIndex } );\n\n\t\t\tif ( materialDef.extensions ) addUnknownExtensionsToUserData( extensions, material, materialDef );\n\n\t\t\treturn material;\n\n\t\t} );\n\n\t}\n\n\t/** When Object3D instances are targeted by animation, they need unique names. */\n\tcreateUniqueName( originalName ) {\n\n\t\tconst sanitizedName = PropertyBinding.sanitizeNodeName( originalName || '' );\n\n\t\tif ( sanitizedName in this.nodeNamesUsed ) {\n\n\t\t\treturn sanitizedName + '_' + ( ++ this.nodeNamesUsed[ sanitizedName ] );\n\n\t\t} else {\n\n\t\t\tthis.nodeNamesUsed[ sanitizedName ] = 0;\n\n\t\t\treturn sanitizedName;\n\n\t\t}\n\n\t}\n\n\t/**\n\t * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#geometry\n\t *\n\t * Creates BufferGeometries from primitives.\n\t *\n\t * @param {Array} primitives\n\t * @return {Promise>}\n\t */\n\tloadGeometries( primitives ) {\n\n\t\tconst parser = this;\n\t\tconst extensions = this.extensions;\n\t\tconst cache = this.primitiveCache;\n\n\t\tfunction createDracoPrimitive( primitive ) {\n\n\t\t\treturn extensions[ EXTENSIONS.KHR_DRACO_MESH_COMPRESSION ]\n\t\t\t\t.decodePrimitive( primitive, parser )\n\t\t\t\t.then( function ( geometry ) {\n\n\t\t\t\t\treturn addPrimitiveAttributes( geometry, primitive, parser );\n\n\t\t\t\t} );\n\n\t\t}\n\n\t\tconst pending = [];\n\n\t\tfor ( let i = 0, il = primitives.length; i < il; i ++ ) {\n\n\t\t\tconst primitive = primitives[ i ];\n\t\t\tconst cacheKey = createPrimitiveKey( primitive );\n\n\t\t\t// See if we've already created this geometry\n\t\t\tconst cached = cache[ cacheKey ];\n\n\t\t\tif ( cached ) {\n\n\t\t\t\t// Use the cached geometry if it exists\n\t\t\t\tpending.push( cached.promise );\n\n\t\t\t} else {\n\n\t\t\t\tlet geometryPromise;\n\n\t\t\t\tif ( primitive.extensions && primitive.extensions[ EXTENSIONS.KHR_DRACO_MESH_COMPRESSION ] ) {\n\n\t\t\t\t\t// Use DRACO geometry if available\n\t\t\t\t\tgeometryPromise = createDracoPrimitive( primitive );\n\n\t\t\t\t} else {\n\n\t\t\t\t\t// Otherwise create a new geometry\n\t\t\t\t\tgeometryPromise = addPrimitiveAttributes( new BufferGeometry(), primitive, parser );\n\n\t\t\t\t}\n\n\t\t\t\t// Cache this geometry\n\t\t\t\tcache[ cacheKey ] = { primitive: primitive, promise: geometryPromise };\n\n\t\t\t\tpending.push( geometryPromise );\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn Promise.all( pending );\n\n\t}\n\n\t/**\n\t * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#meshes\n\t * @param {number} meshIndex\n\t * @return {Promise}\n\t */\n\tloadMesh( meshIndex ) {\n\n\t\tconst parser = this;\n\t\tconst json = this.json;\n\t\tconst extensions = this.extensions;\n\n\t\tconst meshDef = json.meshes[ meshIndex ];\n\t\tconst primitives = meshDef.primitives;\n\n\t\tconst pending = [];\n\n\t\tfor ( let i = 0, il = primitives.length; i < il; i ++ ) {\n\n\t\t\tconst material = primitives[ i ].material === undefined\n\t\t\t\t? createDefaultMaterial( this.cache )\n\t\t\t\t: this.getDependency( 'material', primitives[ i ].material );\n\n\t\t\tpending.push( material );\n\n\t\t}\n\n\t\tpending.push( parser.loadGeometries( primitives ) );\n\n\t\treturn Promise.all( pending ).then( function ( results ) {\n\n\t\t\tconst materials = results.slice( 0, results.length - 1 );\n\t\t\tconst geometries = results[ results.length - 1 ];\n\n\t\t\tconst meshes = [];\n\n\t\t\tfor ( let i = 0, il = geometries.length; i < il; i ++ ) {\n\n\t\t\t\tconst geometry = geometries[ i ];\n\t\t\t\tconst primitive = primitives[ i ];\n\n\t\t\t\t// 1. create Mesh\n\n\t\t\t\tlet mesh;\n\n\t\t\t\tconst material = materials[ i ];\n\n\t\t\t\tif ( primitive.mode === WEBGL_CONSTANTS.TRIANGLES ||\n\t\t\t\t\t\tprimitive.mode === WEBGL_CONSTANTS.TRIANGLE_STRIP ||\n\t\t\t\t\t\tprimitive.mode === WEBGL_CONSTANTS.TRIANGLE_FAN ||\n\t\t\t\t\t\tprimitive.mode === undefined ) {\n\n\t\t\t\t\t// .isSkinnedMesh isn't in glTF spec. See ._markDefs()\n\t\t\t\t\tmesh = meshDef.isSkinnedMesh === true\n\t\t\t\t\t\t? new SkinnedMesh( geometry, material )\n\t\t\t\t\t\t: new Mesh( geometry, material );\n\n\t\t\t\t\tif ( mesh.isSkinnedMesh === true ) {\n\n\t\t\t\t\t\t// normalize skin weights to fix malformed assets (see #15319)\n\t\t\t\t\t\tmesh.normalizeSkinWeights();\n\n\t\t\t\t\t}\n\n\t\t\t\t\tif ( primitive.mode === WEBGL_CONSTANTS.TRIANGLE_STRIP ) {\n\n\t\t\t\t\t\tmesh.geometry = toTrianglesDrawMode( mesh.geometry, TriangleStripDrawMode );\n\n\t\t\t\t\t} else if ( primitive.mode === WEBGL_CONSTANTS.TRIANGLE_FAN ) {\n\n\t\t\t\t\t\tmesh.geometry = toTrianglesDrawMode( mesh.geometry, TriangleFanDrawMode );\n\n\t\t\t\t\t}\n\n\t\t\t\t} else if ( primitive.mode === WEBGL_CONSTANTS.LINES ) {\n\n\t\t\t\t\tmesh = new LineSegments( geometry, material );\n\n\t\t\t\t} else if ( primitive.mode === WEBGL_CONSTANTS.LINE_STRIP ) {\n\n\t\t\t\t\tmesh = new Line( geometry, material );\n\n\t\t\t\t} else if ( primitive.mode === WEBGL_CONSTANTS.LINE_LOOP ) {\n\n\t\t\t\t\tmesh = new LineLoop( geometry, material );\n\n\t\t\t\t} else if ( primitive.mode === WEBGL_CONSTANTS.POINTS ) {\n\n\t\t\t\t\tmesh = new Points( geometry, material );\n\n\t\t\t\t} else {\n\n\t\t\t\t\tthrow new Error( 'THREE.GLTFLoader: Primitive mode unsupported: ' + primitive.mode );\n\n\t\t\t\t}\n\n\t\t\t\tif ( Object.keys( mesh.geometry.morphAttributes ).length > 0 ) {\n\n\t\t\t\t\tupdateMorphTargets( mesh, meshDef );\n\n\t\t\t\t}\n\n\t\t\t\tmesh.name = parser.createUniqueName( meshDef.name || ( 'mesh_' + meshIndex ) );\n\n\t\t\t\tassignExtrasToUserData( mesh, meshDef );\n\n\t\t\t\tif ( primitive.extensions ) addUnknownExtensionsToUserData( extensions, mesh, primitive );\n\n\t\t\t\tparser.assignFinalMaterial( mesh );\n\n\t\t\t\tmeshes.push( mesh );\n\n\t\t\t}\n\n\t\t\tfor ( let i = 0, il = meshes.length; i < il; i ++ ) {\n\n\t\t\t\tparser.associations.set( meshes[ i ], {\n\t\t\t\t\tmeshes: meshIndex,\n\t\t\t\t\tprimitives: i\n\t\t\t\t} );\n\n\t\t\t}\n\n\t\t\tif ( meshes.length === 1 ) {\n\n\t\t\t\tif ( meshDef.extensions ) addUnknownExtensionsToUserData( extensions, meshes[ 0 ], meshDef );\n\n\t\t\t\treturn meshes[ 0 ];\n\n\t\t\t}\n\n\t\t\tconst group = new Group();\n\n\t\t\tif ( meshDef.extensions ) addUnknownExtensionsToUserData( extensions, group, meshDef );\n\n\t\t\tparser.associations.set( group, { meshes: meshIndex } );\n\n\t\t\tfor ( let i = 0, il = meshes.length; i < il; i ++ ) {\n\n\t\t\t\tgroup.add( meshes[ i ] );\n\n\t\t\t}\n\n\t\t\treturn group;\n\n\t\t} );\n\n\t}\n\n\t/**\n\t * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#cameras\n\t * @param {number} cameraIndex\n\t * @return {Promise}\n\t */\n\tloadCamera( cameraIndex ) {\n\n\t\tlet camera;\n\t\tconst cameraDef = this.json.cameras[ cameraIndex ];\n\t\tconst params = cameraDef[ cameraDef.type ];\n\n\t\tif ( ! params ) {\n\n\t\t\tconsole.warn( 'THREE.GLTFLoader: Missing camera parameters.' );\n\t\t\treturn;\n\n\t\t}\n\n\t\tif ( cameraDef.type === 'perspective' ) {\n\n\t\t\tcamera = new PerspectiveCamera( MathUtils.radToDeg( params.yfov ), params.aspectRatio || 1, params.znear || 1, params.zfar || 2e6 );\n\n\t\t} else if ( cameraDef.type === 'orthographic' ) {\n\n\t\t\tcamera = new OrthographicCamera( - params.xmag, params.xmag, params.ymag, - params.ymag, params.znear, params.zfar );\n\n\t\t}\n\n\t\tif ( cameraDef.name ) camera.name = this.createUniqueName( cameraDef.name );\n\n\t\tassignExtrasToUserData( camera, cameraDef );\n\n\t\treturn Promise.resolve( camera );\n\n\t}\n\n\t/**\n\t * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skins\n\t * @param {number} skinIndex\n\t * @return {Promise}\n\t */\n\tloadSkin( skinIndex ) {\n\n\t\tconst skinDef = this.json.skins[ skinIndex ];\n\n\t\tconst pending = [];\n\n\t\tfor ( let i = 0, il = skinDef.joints.length; i < il; i ++ ) {\n\n\t\t\tpending.push( this._loadNodeShallow( skinDef.joints[ i ] ) );\n\n\t\t}\n\n\t\tif ( skinDef.inverseBindMatrices !== undefined ) {\n\n\t\t\tpending.push( this.getDependency( 'accessor', skinDef.inverseBindMatrices ) );\n\n\t\t} else {\n\n\t\t\tpending.push( null );\n\n\t\t}\n\n\t\treturn Promise.all( pending ).then( function ( results ) {\n\n\t\t\tconst inverseBindMatrices = results.pop();\n\t\t\tconst jointNodes = results;\n\n\t\t\t// Note that bones (joint nodes) may or may not be in the\n\t\t\t// scene graph at this time.\n\n\t\t\tconst bones = [];\n\t\t\tconst boneInverses = [];\n\n\t\t\tfor ( let i = 0, il = jointNodes.length; i < il; i ++ ) {\n\n\t\t\t\tconst jointNode = jointNodes[ i ];\n\n\t\t\t\tif ( jointNode ) {\n\n\t\t\t\t\tbones.push( jointNode );\n\n\t\t\t\t\tconst mat = new Matrix4();\n\n\t\t\t\t\tif ( inverseBindMatrices !== null ) {\n\n\t\t\t\t\t\tmat.fromArray( inverseBindMatrices.array, i * 16 );\n\n\t\t\t\t\t}\n\n\t\t\t\t\tboneInverses.push( mat );\n\n\t\t\t\t} else {\n\n\t\t\t\t\tconsole.warn( 'THREE.GLTFLoader: Joint \"%s\" could not be found.', skinDef.joints[ i ] );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\treturn new Skeleton( bones, boneInverses );\n\n\t\t} );\n\n\t}\n\n\t/**\n\t * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#animations\n\t * @param {number} animationIndex\n\t * @return {Promise}\n\t */\n\tloadAnimation( animationIndex ) {\n\n\t\tconst json = this.json;\n\t\tconst parser = this;\n\n\t\tconst animationDef = json.animations[ animationIndex ];\n\t\tconst animationName = animationDef.name ? animationDef.name : 'animation_' + animationIndex;\n\n\t\tconst pendingNodes = [];\n\t\tconst pendingInputAccessors = [];\n\t\tconst pendingOutputAccessors = [];\n\t\tconst pendingSamplers = [];\n\t\tconst pendingTargets = [];\n\n\t\tfor ( let i = 0, il = animationDef.channels.length; i < il; i ++ ) {\n\n\t\t\tconst channel = animationDef.channels[ i ];\n\t\t\tconst sampler = animationDef.samplers[ channel.sampler ];\n\t\t\tconst target = channel.target;\n\t\t\tconst name = target.node;\n\t\t\tconst input = animationDef.parameters !== undefined ? animationDef.parameters[ sampler.input ] : sampler.input;\n\t\t\tconst output = animationDef.parameters !== undefined ? animationDef.parameters[ sampler.output ] : sampler.output;\n\n\t\t\tif ( target.node === undefined ) continue;\n\n\t\t\tpendingNodes.push( this.getDependency( 'node', name ) );\n\t\t\tpendingInputAccessors.push( this.getDependency( 'accessor', input ) );\n\t\t\tpendingOutputAccessors.push( this.getDependency( 'accessor', output ) );\n\t\t\tpendingSamplers.push( sampler );\n\t\t\tpendingTargets.push( target );\n\n\t\t}\n\n\t\treturn Promise.all( [\n\n\t\t\tPromise.all( pendingNodes ),\n\t\t\tPromise.all( pendingInputAccessors ),\n\t\t\tPromise.all( pendingOutputAccessors ),\n\t\t\tPromise.all( pendingSamplers ),\n\t\t\tPromise.all( pendingTargets )\n\n\t\t] ).then( function ( dependencies ) {\n\n\t\t\tconst nodes = dependencies[ 0 ];\n\t\t\tconst inputAccessors = dependencies[ 1 ];\n\t\t\tconst outputAccessors = dependencies[ 2 ];\n\t\t\tconst samplers = dependencies[ 3 ];\n\t\t\tconst targets = dependencies[ 4 ];\n\n\t\t\tconst tracks = [];\n\n\t\t\tfor ( let i = 0, il = nodes.length; i < il; i ++ ) {\n\n\t\t\t\tconst node = nodes[ i ];\n\t\t\t\tconst inputAccessor = inputAccessors[ i ];\n\t\t\t\tconst outputAccessor = outputAccessors[ i ];\n\t\t\t\tconst sampler = samplers[ i ];\n\t\t\t\tconst target = targets[ i ];\n\n\t\t\t\tif ( node === undefined ) continue;\n\n\t\t\t\tif ( node.updateMatrix ) {\n\n\t\t\t\t\tnode.updateMatrix();\n\n\t\t\t\t}\n\n\t\t\t\tconst createdTracks = parser._createAnimationTracks( node, inputAccessor, outputAccessor, sampler, target );\n\n\t\t\t\tif ( createdTracks ) {\n\n\t\t\t\t\tfor ( let k = 0; k < createdTracks.length; k ++ ) {\n\n\t\t\t\t\t\ttracks.push( createdTracks[ k ] );\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\treturn new AnimationClip( animationName, undefined, tracks );\n\n\t\t} );\n\n\t}\n\n\tcreateNodeMesh( nodeIndex ) {\n\n\t\tconst json = this.json;\n\t\tconst parser = this;\n\t\tconst nodeDef = json.nodes[ nodeIndex ];\n\n\t\tif ( nodeDef.mesh === undefined ) return null;\n\n\t\treturn parser.getDependency( 'mesh', nodeDef.mesh ).then( function ( mesh ) {\n\n\t\t\tconst node = parser._getNodeRef( parser.meshCache, nodeDef.mesh, mesh );\n\n\t\t\t// if weights are provided on the node, override weights on the mesh.\n\t\t\tif ( nodeDef.weights !== undefined ) {\n\n\t\t\t\tnode.traverse( function ( o ) {\n\n\t\t\t\t\tif ( ! o.isMesh ) return;\n\n\t\t\t\t\tfor ( let i = 0, il = nodeDef.weights.length; i < il; i ++ ) {\n\n\t\t\t\t\t\to.morphTargetInfluences[ i ] = nodeDef.weights[ i ];\n\n\t\t\t\t\t}\n\n\t\t\t\t} );\n\n\t\t\t}\n\n\t\t\treturn node;\n\n\t\t} );\n\n\t}\n\n\t/**\n\t * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#nodes-and-hierarchy\n\t * @param {number} nodeIndex\n\t * @return {Promise}\n\t */\n\tloadNode( nodeIndex ) {\n\n\t\tconst json = this.json;\n\t\tconst parser = this;\n\n\t\tconst nodeDef = json.nodes[ nodeIndex ];\n\n\t\tconst nodePending = parser._loadNodeShallow( nodeIndex );\n\n\t\tconst childPending = [];\n\t\tconst childrenDef = nodeDef.children || [];\n\n\t\tfor ( let i = 0, il = childrenDef.length; i < il; i ++ ) {\n\n\t\t\tchildPending.push( parser.getDependency( 'node', childrenDef[ i ] ) );\n\n\t\t}\n\n\t\tconst skeletonPending = nodeDef.skin === undefined\n\t\t\t? Promise.resolve( null )\n\t\t\t: parser.getDependency( 'skin', nodeDef.skin );\n\n\t\treturn Promise.all( [\n\t\t\tnodePending,\n\t\t\tPromise.all( childPending ),\n\t\t\tskeletonPending\n\t\t] ).then( function ( results ) {\n\n\t\t\tconst node = results[ 0 ];\n\t\t\tconst children = results[ 1 ];\n\t\t\tconst skeleton = results[ 2 ];\n\n\t\t\tif ( skeleton !== null ) {\n\n\t\t\t\t// This full traverse should be fine because\n\t\t\t\t// child glTF nodes have not been added to this node yet.\n\t\t\t\tnode.traverse( function ( mesh ) {\n\n\t\t\t\t\tif ( ! mesh.isSkinnedMesh ) return;\n\n\t\t\t\t\tmesh.bind( skeleton, _identityMatrix );\n\n\t\t\t\t} );\n\n\t\t\t}\n\n\t\t\tfor ( let i = 0, il = children.length; i < il; i ++ ) {\n\n\t\t\t\tnode.add( children[ i ] );\n\n\t\t\t}\n\n\t\t\treturn node;\n\n\t\t} );\n\n\t}\n\n\t// ._loadNodeShallow() parses a single node.\n\t// skin and child nodes are created and added in .loadNode() (no '_' prefix).\n\t_loadNodeShallow( nodeIndex ) {\n\n\t\tconst json = this.json;\n\t\tconst extensions = this.extensions;\n\t\tconst parser = this;\n\n\t\t// This method is called from .loadNode() and .loadSkin().\n\t\t// Cache a node to avoid duplication.\n\n\t\tif ( this.nodeCache[ nodeIndex ] !== undefined ) {\n\n\t\t\treturn this.nodeCache[ nodeIndex ];\n\n\t\t}\n\n\t\tconst nodeDef = json.nodes[ nodeIndex ];\n\n\t\t// reserve node's name before its dependencies, so the root has the intended name.\n\t\tconst nodeName = nodeDef.name ? parser.createUniqueName( nodeDef.name ) : '';\n\n\t\tconst pending = [];\n\n\t\tconst meshPromise = parser._invokeOne( function ( ext ) {\n\n\t\t\treturn ext.createNodeMesh && ext.createNodeMesh( nodeIndex );\n\n\t\t} );\n\n\t\tif ( meshPromise ) {\n\n\t\t\tpending.push( meshPromise );\n\n\t\t}\n\n\t\tif ( nodeDef.camera !== undefined ) {\n\n\t\t\tpending.push( parser.getDependency( 'camera', nodeDef.camera ).then( function ( camera ) {\n\n\t\t\t\treturn parser._getNodeRef( parser.cameraCache, nodeDef.camera, camera );\n\n\t\t\t} ) );\n\n\t\t}\n\n\t\tparser._invokeAll( function ( ext ) {\n\n\t\t\treturn ext.createNodeAttachment && ext.createNodeAttachment( nodeIndex );\n\n\t\t} ).forEach( function ( promise ) {\n\n\t\t\tpending.push( promise );\n\n\t\t} );\n\n\t\tthis.nodeCache[ nodeIndex ] = Promise.all( pending ).then( function ( objects ) {\n\n\t\t\tlet node;\n\n\t\t\t// .isBone isn't in glTF spec. See ._markDefs\n\t\t\tif ( nodeDef.isBone === true ) {\n\n\t\t\t\tnode = new Bone();\n\n\t\t\t} else if ( objects.length > 1 ) {\n\n\t\t\t\tnode = new Group();\n\n\t\t\t} else if ( objects.length === 1 ) {\n\n\t\t\t\tnode = objects[ 0 ];\n\n\t\t\t} else {\n\n\t\t\t\tnode = new Object3D();\n\n\t\t\t}\n\n\t\t\tif ( node !== objects[ 0 ] ) {\n\n\t\t\t\tfor ( let i = 0, il = objects.length; i < il; i ++ ) {\n\n\t\t\t\t\tnode.add( objects[ i ] );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tif ( nodeDef.name ) {\n\n\t\t\t\tnode.userData.name = nodeDef.name;\n\t\t\t\tnode.name = nodeName;\n\n\t\t\t}\n\n\t\t\tassignExtrasToUserData( node, nodeDef );\n\n\t\t\tif ( nodeDef.extensions ) addUnknownExtensionsToUserData( extensions, node, nodeDef );\n\n\t\t\tif ( nodeDef.matrix !== undefined ) {\n\n\t\t\t\tconst matrix = new Matrix4();\n\t\t\t\tmatrix.fromArray( nodeDef.matrix );\n\t\t\t\tnode.applyMatrix4( matrix );\n\n\t\t\t} else {\n\n\t\t\t\tif ( nodeDef.translation !== undefined ) {\n\n\t\t\t\t\tnode.position.fromArray( nodeDef.translation );\n\n\t\t\t\t}\n\n\t\t\t\tif ( nodeDef.rotation !== undefined ) {\n\n\t\t\t\t\tnode.quaternion.fromArray( nodeDef.rotation );\n\n\t\t\t\t}\n\n\t\t\t\tif ( nodeDef.scale !== undefined ) {\n\n\t\t\t\t\tnode.scale.fromArray( nodeDef.scale );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\tif ( ! parser.associations.has( node ) ) {\n\n\t\t\t\tparser.associations.set( node, {} );\n\n\t\t\t}\n\n\t\t\tparser.associations.get( node ).nodes = nodeIndex;\n\n\t\t\treturn node;\n\n\t\t} );\n\n\t\treturn this.nodeCache[ nodeIndex ];\n\n\t}\n\n\t/**\n\t * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#scenes\n\t * @param {number} sceneIndex\n\t * @return {Promise}\n\t */\n\tloadScene( sceneIndex ) {\n\n\t\tconst extensions = this.extensions;\n\t\tconst sceneDef = this.json.scenes[ sceneIndex ];\n\t\tconst parser = this;\n\n\t\t// Loader returns Group, not Scene.\n\t\t// See: https://github.com/mrdoob/three.js/issues/18342#issuecomment-578981172\n\t\tconst scene = new Group();\n\t\tif ( sceneDef.name ) scene.name = parser.createUniqueName( sceneDef.name );\n\n\t\tassignExtrasToUserData( scene, sceneDef );\n\n\t\tif ( sceneDef.extensions ) addUnknownExtensionsToUserData( extensions, scene, sceneDef );\n\n\t\tconst nodeIds = sceneDef.nodes || [];\n\n\t\tconst pending = [];\n\n\t\tfor ( let i = 0, il = nodeIds.length; i < il; i ++ ) {\n\n\t\t\tpending.push( parser.getDependency( 'node', nodeIds[ i ] ) );\n\n\t\t}\n\n\t\treturn Promise.all( pending ).then( function ( nodes ) {\n\n\t\t\tfor ( let i = 0, il = nodes.length; i < il; i ++ ) {\n\n\t\t\t\tscene.add( nodes[ i ] );\n\n\t\t\t}\n\n\t\t\t// Removes dangling associations, associations that reference a node that\n\t\t\t// didn't make it into the scene.\n\t\t\tconst reduceAssociations = ( node ) => {\n\n\t\t\t\tconst reducedAssociations = new Map();\n\n\t\t\t\tfor ( const [ key, value ] of parser.associations ) {\n\n\t\t\t\t\tif ( key instanceof Material || key instanceof Texture ) {\n\n\t\t\t\t\t\treducedAssociations.set( key, value );\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t\tnode.traverse( ( node ) => {\n\n\t\t\t\t\tconst mappings = parser.associations.get( node );\n\n\t\t\t\t\tif ( mappings != null ) {\n\n\t\t\t\t\t\treducedAssociations.set( node, mappings );\n\n\t\t\t\t\t}\n\n\t\t\t\t} );\n\n\t\t\t\treturn reducedAssociations;\n\n\t\t\t};\n\n\t\t\tparser.associations = reduceAssociations( scene );\n\n\t\t\treturn scene;\n\n\t\t} );\n\n\t}\n\n\t_createAnimationTracks( node, inputAccessor, outputAccessor, sampler, target ) {\n\n\t\tconst tracks = [];\n\n\t\tconst targetName = node.name ? node.name : node.uuid;\n\t\tconst targetNames = [];\n\n\t\tif ( PATH_PROPERTIES[ target.path ] === PATH_PROPERTIES.weights ) {\n\n\t\t\tnode.traverse( function ( object ) {\n\n\t\t\t\tif ( object.morphTargetInfluences ) {\n\n\t\t\t\t\ttargetNames.push( object.name ? object.name : object.uuid );\n\n\t\t\t\t}\n\n\t\t\t} );\n\n\t\t} else {\n\n\t\t\ttargetNames.push( targetName );\n\n\t\t}\n\n\t\tlet TypedKeyframeTrack;\n\n\t\tswitch ( PATH_PROPERTIES[ target.path ] ) {\n\n\t\t\tcase PATH_PROPERTIES.weights:\n\n\t\t\t\tTypedKeyframeTrack = NumberKeyframeTrack;\n\t\t\t\tbreak;\n\n\t\t\tcase PATH_PROPERTIES.rotation:\n\n\t\t\t\tTypedKeyframeTrack = QuaternionKeyframeTrack;\n\t\t\t\tbreak;\n\n\t\t\tcase PATH_PROPERTIES.position:\n\t\t\tcase PATH_PROPERTIES.scale:\n\n\t\t\t\tTypedKeyframeTrack = VectorKeyframeTrack;\n\t\t\t\tbreak;\n\n\t\t\tdefault:\n\n\t\t\t\tswitch ( outputAccessor.itemSize ) {\n\n\t\t\t\t\tcase 1:\n\t\t\t\t\t\tTypedKeyframeTrack = NumberKeyframeTrack;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase 2:\n\t\t\t\t\tcase 3:\n\t\t\t\t\tdefault:\n\t\t\t\t\t\tTypedKeyframeTrack = VectorKeyframeTrack;\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t}\n\n\t\t\t\tbreak;\n\n\t\t}\n\n\t\tconst interpolation = sampler.interpolation !== undefined ? INTERPOLATION[ sampler.interpolation ] : InterpolateLinear;\n\n\n\t\tconst outputArray = this._getArrayFromAccessor( outputAccessor );\n\n\t\tfor ( let j = 0, jl = targetNames.length; j < jl; j ++ ) {\n\n\t\t\tconst track = new TypedKeyframeTrack(\n\t\t\t\ttargetNames[ j ] + '.' + PATH_PROPERTIES[ target.path ],\n\t\t\t\tinputAccessor.array,\n\t\t\t\toutputArray,\n\t\t\t\tinterpolation\n\t\t\t);\n\n\t\t\t// Override interpolation with custom factory method.\n\t\t\tif ( sampler.interpolation === 'CUBICSPLINE' ) {\n\n\t\t\t\tthis._createCubicSplineTrackInterpolant( track );\n\n\t\t\t}\n\n\t\t\ttracks.push( track );\n\n\t\t}\n\n\t\treturn tracks;\n\n\t}\n\n\t_getArrayFromAccessor( accessor ) {\n\n\t\tlet outputArray = accessor.array;\n\n\t\tif ( accessor.normalized ) {\n\n\t\t\tconst scale = getNormalizedComponentScale( outputArray.constructor );\n\t\t\tconst scaled = new Float32Array( outputArray.length );\n\n\t\t\tfor ( let j = 0, jl = outputArray.length; j < jl; j ++ ) {\n\n\t\t\t\tscaled[ j ] = outputArray[ j ] * scale;\n\n\t\t\t}\n\n\t\t\toutputArray = scaled;\n\n\t\t}\n\n\t\treturn outputArray;\n\n\t}\n\n\t_createCubicSplineTrackInterpolant( track ) {\n\n\t\ttrack.createInterpolant = function InterpolantFactoryMethodGLTFCubicSpline( result ) {\n\n\t\t\t// A CUBICSPLINE keyframe in glTF has three output values for each input value,\n\t\t\t// representing inTangent, splineVertex, and outTangent. As a result, track.getValueSize()\n\t\t\t// must be divided by three to get the interpolant's sampleSize argument.\n\n\t\t\tconst interpolantType = ( this instanceof QuaternionKeyframeTrack ) ? GLTFCubicSplineQuaternionInterpolant : GLTFCubicSplineInterpolant;\n\n\t\t\treturn new interpolantType( this.times, this.values, this.getValueSize() / 3, result );\n\n\t\t};\n\n\t\t// Mark as CUBICSPLINE. `track.getInterpolation()` doesn't support custom interpolants.\n\t\ttrack.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline = true;\n\n\t}\n\n}\n\n/**\n * @param {BufferGeometry} geometry\n * @param {GLTF.Primitive} primitiveDef\n * @param {GLTFParser} parser\n */\nfunction computeBounds( geometry, primitiveDef, parser ) {\n\n\tconst attributes = primitiveDef.attributes;\n\n\tconst box = new Box3();\n\n\tif ( attributes.POSITION !== undefined ) {\n\n\t\tconst accessor = parser.json.accessors[ attributes.POSITION ];\n\n\t\tconst min = accessor.min;\n\t\tconst max = accessor.max;\n\n\t\t// glTF requires 'min' and 'max', but VRM (which extends glTF) currently ignores that requirement.\n\n\t\tif ( min !== undefined && max !== undefined ) {\n\n\t\t\tbox.set(\n\t\t\t\tnew Vector3( min[ 0 ], min[ 1 ], min[ 2 ] ),\n\t\t\t\tnew Vector3( max[ 0 ], max[ 1 ], max[ 2 ] )\n\t\t\t);\n\n\t\t\tif ( accessor.normalized ) {\n\n\t\t\t\tconst boxScale = getNormalizedComponentScale( WEBGL_COMPONENT_TYPES[ accessor.componentType ] );\n\t\t\t\tbox.min.multiplyScalar( boxScale );\n\t\t\t\tbox.max.multiplyScalar( boxScale );\n\n\t\t\t}\n\n\t\t} else {\n\n\t\t\tconsole.warn( 'THREE.GLTFLoader: Missing min/max properties for accessor POSITION.' );\n\n\t\t\treturn;\n\n\t\t}\n\n\t} else {\n\n\t\treturn;\n\n\t}\n\n\tconst targets = primitiveDef.targets;\n\n\tif ( targets !== undefined ) {\n\n\t\tconst maxDisplacement = new Vector3();\n\t\tconst vector = new Vector3();\n\n\t\tfor ( let i = 0, il = targets.length; i < il; i ++ ) {\n\n\t\t\tconst target = targets[ i ];\n\n\t\t\tif ( target.POSITION !== undefined ) {\n\n\t\t\t\tconst accessor = parser.json.accessors[ target.POSITION ];\n\t\t\t\tconst min = accessor.min;\n\t\t\t\tconst max = accessor.max;\n\n\t\t\t\t// glTF requires 'min' and 'max', but VRM (which extends glTF) currently ignores that requirement.\n\n\t\t\t\tif ( min !== undefined && max !== undefined ) {\n\n\t\t\t\t\t// we need to get max of absolute components because target weight is [-1,1]\n\t\t\t\t\tvector.setX( Math.max( Math.abs( min[ 0 ] ), Math.abs( max[ 0 ] ) ) );\n\t\t\t\t\tvector.setY( Math.max( Math.abs( min[ 1 ] ), Math.abs( max[ 1 ] ) ) );\n\t\t\t\t\tvector.setZ( Math.max( Math.abs( min[ 2 ] ), Math.abs( max[ 2 ] ) ) );\n\n\n\t\t\t\t\tif ( accessor.normalized ) {\n\n\t\t\t\t\t\tconst boxScale = getNormalizedComponentScale( WEBGL_COMPONENT_TYPES[ accessor.componentType ] );\n\t\t\t\t\t\tvector.multiplyScalar( boxScale );\n\n\t\t\t\t\t}\n\n\t\t\t\t\t// Note: this assumes that the sum of all weights is at most 1. This isn't quite correct - it's more conservative\n\t\t\t\t\t// to assume that each target can have a max weight of 1. However, for some use cases - notably, when morph targets\n\t\t\t\t\t// are used to implement key-frame animations and as such only two are active at a time - this results in very large\n\t\t\t\t\t// boxes. So for now we make a box that's sometimes a touch too small but is hopefully mostly of reasonable size.\n\t\t\t\t\tmaxDisplacement.max( vector );\n\n\t\t\t\t} else {\n\n\t\t\t\t\tconsole.warn( 'THREE.GLTFLoader: Missing min/max properties for accessor POSITION.' );\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t\t// As per comment above this box isn't conservative, but has a reasonable size for a very large number of morph targets.\n\t\tbox.expandByVector( maxDisplacement );\n\n\t}\n\n\tgeometry.boundingBox = box;\n\n\tconst sphere = new Sphere();\n\n\tbox.getCenter( sphere.center );\n\tsphere.radius = box.min.distanceTo( box.max ) / 2;\n\n\tgeometry.boundingSphere = sphere;\n\n}\n\n/**\n * @param {BufferGeometry} geometry\n * @param {GLTF.Primitive} primitiveDef\n * @param {GLTFParser} parser\n * @return {Promise}\n */\nfunction addPrimitiveAttributes( geometry, primitiveDef, parser ) {\n\n\tconst attributes = primitiveDef.attributes;\n\n\tconst pending = [];\n\n\tfunction assignAttributeAccessor( accessorIndex, attributeName ) {\n\n\t\treturn parser.getDependency( 'accessor', accessorIndex )\n\t\t\t.then( function ( accessor ) {\n\n\t\t\t\tgeometry.setAttribute( attributeName, accessor );\n\n\t\t\t} );\n\n\t}\n\n\tfor ( const gltfAttributeName in attributes ) {\n\n\t\tconst threeAttributeName = ATTRIBUTES[ gltfAttributeName ] || gltfAttributeName.toLowerCase();\n\n\t\t// Skip attributes already provided by e.g. Draco extension.\n\t\tif ( threeAttributeName in geometry.attributes ) continue;\n\n\t\tpending.push( assignAttributeAccessor( attributes[ gltfAttributeName ], threeAttributeName ) );\n\n\t}\n\n\tif ( primitiveDef.indices !== undefined && ! geometry.index ) {\n\n\t\tconst accessor = parser.getDependency( 'accessor', primitiveDef.indices ).then( function ( accessor ) {\n\n\t\t\tgeometry.setIndex( accessor );\n\n\t\t} );\n\n\t\tpending.push( accessor );\n\n\t}\n\n\tif ( ColorManagement.workingColorSpace !== LinearSRGBColorSpace && 'COLOR_0' in attributes ) {\n\n\t\tconsole.warn( `THREE.GLTFLoader: Converting vertex colors from \"srgb-linear\" to \"${ColorManagement.workingColorSpace}\" not supported.` );\n\n\t}\n\n\tassignExtrasToUserData( geometry, primitiveDef );\n\n\tcomputeBounds( geometry, primitiveDef, parser );\n\n\treturn Promise.all( pending ).then( function () {\n\n\t\treturn primitiveDef.targets !== undefined\n\t\t\t? addMorphTargets( geometry, primitiveDef.targets, parser )\n\t\t\t: geometry;\n\n\t} );\n\n}\n\nexport { GLTFLoader };\n", "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", "var $jscomp=$jscomp||{};$jscomp.scope={};$jscomp.arrayIteratorImpl=function(h){var n=0;return function(){return n<h.length?{done:!1,value:h[n++]}:{done:!0}}};$jscomp.arrayIterator=function(h){return{next:$jscomp.arrayIteratorImpl(h)}};$jscomp.makeIterator=function(h){var n="undefined"!=typeof Symbol&&Symbol.iterator&&h[Symbol.iterator];return n?n.call(h):$jscomp.arrayIterator(h)};$jscomp.ASSUME_ES5=!1;$jscomp.ASSUME_NO_NATIVE_MAP=!1;$jscomp.ASSUME_NO_NATIVE_SET=!1;$jscomp.SIMPLE_FROUND_POLYFILL=!1;
$jscomp.ISOLATE_POLYFILLS=!1;$jscomp.FORCE_POLYFILL_PROMISE=!1;$jscomp.FORCE_POLYFILL_PROMISE_WHEN_NO_UNHANDLED_REJECTION=!1;$jscomp.getGlobal=function(h){h=["object"==typeof globalThis&&globalThis,h,"object"==typeof window&&window,"object"==typeof self&&self,"object"==typeof global&&global];for(var n=0;n<h.length;++n){var k=h[n];if(k&&k.Math==Math)return k}throw Error("Cannot find global object");};$jscomp.global=$jscomp.getGlobal(this);
$jscomp.defineProperty=$jscomp.ASSUME_ES5||"function"==typeof Object.defineProperties?Object.defineProperty:function(h,n,k){if(h==Array.prototype||h==Object.prototype)return h;h[n]=k.value;return h};$jscomp.IS_SYMBOL_NATIVE="function"===typeof Symbol&&"symbol"===typeof Symbol("x");$jscomp.TRUST_ES6_POLYFILLS=!$jscomp.ISOLATE_POLYFILLS||$jscomp.IS_SYMBOL_NATIVE;$jscomp.polyfills={};$jscomp.propertyToPolyfillSymbol={};$jscomp.POLYFILL_PREFIX="$jscp$";
var $jscomp$lookupPolyfilledValue=function(h,n){var k=$jscomp.propertyToPolyfillSymbol[n];if(null==k)return h[n];k=h[k];return void 0!==k?k:h[n]};$jscomp.polyfill=function(h,n,k,p){n&&($jscomp.ISOLATE_POLYFILLS?$jscomp.polyfillIsolated(h,n,k,p):$jscomp.polyfillUnisolated(h,n,k,p))};
$jscomp.polyfillUnisolated=function(h,n,k,p){k=$jscomp.global;h=h.split(".");for(p=0;p<h.length-1;p++){var l=h[p];if(!(l in k))return;k=k[l]}h=h[h.length-1];p=k[h];n=n(p);n!=p&&null!=n&&$jscomp.defineProperty(k,h,{configurable:!0,writable:!0,value:n})};
$jscomp.polyfillIsolated=function(h,n,k,p){var l=h.split(".");h=1===l.length;p=l[0];p=!h&&p in $jscomp.polyfills?$jscomp.polyfills:$jscomp.global;for(var y=0;y<l.length-1;y++){var f=l[y];if(!(f in p))return;p=p[f]}l=l[l.length-1];k=$jscomp.IS_SYMBOL_NATIVE&&"es6"===k?p[l]:null;n=n(k);null!=n&&(h?$jscomp.defineProperty($jscomp.polyfills,l,{configurable:!0,writable:!0,value:n}):n!==k&&(void 0===$jscomp.propertyToPolyfillSymbol[l]&&(k=1E9*Math.random()>>>0,$jscomp.propertyToPolyfillSymbol[l]=$jscomp.IS_SYMBOL_NATIVE?
$jscomp.global.Symbol(l):$jscomp.POLYFILL_PREFIX+k+"$"+l),$jscomp.defineProperty(p,$jscomp.propertyToPolyfillSymbol[l],{configurable:!0,writable:!0,value:n})))};
$jscomp.polyfill("Promise",function(h){function n(){this.batch_=null}function k(f){return f instanceof l?f:new l(function(q,u){q(f)})}if(h&&(!($jscomp.FORCE_POLYFILL_PROMISE||$jscomp.FORCE_POLYFILL_PROMISE_WHEN_NO_UNHANDLED_REJECTION&&"undefined"===typeof $jscomp.global.PromiseRejectionEvent)||!$jscomp.global.Promise||-1===$jscomp.global.Promise.toString().indexOf("[native code]")))return h;n.prototype.asyncExecute=function(f){if(null==this.batch_){this.batch_=[];var q=this;this.asyncExecuteFunction(function(){q.executeBatch_()})}this.batch_.push(f)};
var p=$jscomp.global.setTimeout;n.prototype.asyncExecuteFunction=function(f){p(f,0)};n.prototype.executeBatch_=function(){for(;this.batch_&&this.batch_.length;){var f=this.batch_;this.batch_=[];for(var q=0;q<f.length;++q){var u=f[q];f[q]=null;try{u()}catch(A){this.asyncThrow_(A)}}}this.batch_=null};n.prototype.asyncThrow_=function(f){this.asyncExecuteFunction(function(){throw f;})};var l=function(f){this.state_=0;this.result_=void 0;this.onSettledCallbacks_=[];this.isRejectionHandled_=!1;var q=this.createResolveAndReject_();
try{f(q.resolve,q.reject)}catch(u){q.reject(u)}};l.prototype.createResolveAndReject_=function(){function f(A){return function(F){u||(u=!0,A.call(q,F))}}var q=this,u=!1;return{resolve:f(this.resolveTo_),reject:f(this.reject_)}};l.prototype.resolveTo_=function(f){if(f===this)this.reject_(new TypeError("A Promise cannot resolve to itself"));else if(f instanceof l)this.settleSameAsPromise_(f);else{a:switch(typeof f){case "object":var q=null!=f;break a;case "function":q=!0;break a;default:q=!1}q?this.resolveToNonPromiseObj_(f):
this.fulfill_(f)}};l.prototype.resolveToNonPromiseObj_=function(f){var q=void 0;try{q=f.then}catch(u){this.reject_(u);return}"function"==typeof q?this.settleSameAsThenable_(q,f):this.fulfill_(f)};l.prototype.reject_=function(f){this.settle_(2,f)};l.prototype.fulfill_=function(f){this.settle_(1,f)};l.prototype.settle_=function(f,q){if(0!=this.state_)throw Error("Cannot settle("+f+", "+q+"): Promise already settled in state"+this.state_);this.state_=f;this.result_=q;2===this.state_&&this.scheduleUnhandledRejectionCheck_();
this.executeOnSettledCallbacks_()};l.prototype.scheduleUnhandledRejectionCheck_=function(){var f=this;p(function(){if(f.notifyUnhandledRejection_()){var q=$jscomp.global.console;"undefined"!==typeof q&&q.error(f.result_)}},1)};l.prototype.notifyUnhandledRejection_=function(){if(this.isRejectionHandled_)return!1;var f=$jscomp.global.CustomEvent,q=$jscomp.global.Event,u=$jscomp.global.dispatchEvent;if("undefined"===typeof u)return!0;"function"===typeof f?f=new f("unhandledrejection",{cancelable:!0}):
"function"===typeof q?f=new q("unhandledrejection",{cancelable:!0}):(f=$jscomp.global.document.createEvent("CustomEvent"),f.initCustomEvent("unhandledrejection",!1,!0,f));f.promise=this;f.reason=this.result_;return u(f)};l.prototype.executeOnSettledCallbacks_=function(){if(null!=this.onSettledCallbacks_){for(var f=0;f<this.onSettledCallbacks_.length;++f)y.asyncExecute(this.onSettledCallbacks_[f]);this.onSettledCallbacks_=null}};var y=new n;l.prototype.settleSameAsPromise_=function(f){var q=this.createResolveAndReject_();
f.callWhenSettled_(q.resolve,q.reject)};l.prototype.settleSameAsThenable_=function(f,q){var u=this.createResolveAndReject_();try{f.call(q,u.resolve,u.reject)}catch(A){u.reject(A)}};l.prototype.then=function(f,q){function u(w,B){return"function"==typeof w?function(R){try{A(w(R))}catch(Z){F(Z)}}:B}var A,F,v=new l(function(w,B){A=w;F=B});this.callWhenSettled_(u(f,A),u(q,F));return v};l.prototype.catch=function(f){return this.then(void 0,f)};l.prototype.callWhenSettled_=function(f,q){function u(){switch(A.state_){case 1:f(A.result_);
break;case 2:q(A.result_);break;default:throw Error("Unexpected state: "+A.state_);}}var A=this;null==this.onSettledCallbacks_?y.asyncExecute(u):this.onSettledCallbacks_.push(u);this.isRejectionHandled_=!0};l.resolve=k;l.reject=function(f){return new l(function(q,u){u(f)})};l.race=function(f){return new l(function(q,u){for(var A=$jscomp.makeIterator(f),F=A.next();!F.done;F=A.next())k(F.value).callWhenSettled_(q,u)})};l.all=function(f){var q=$jscomp.makeIterator(f),u=q.next();return u.done?k([]):new l(function(A,
F){function v(R){return function(Z){w[R]=Z;B--;0==B&&A(w)}}var w=[],B=0;do w.push(void 0),B++,k(u.value).callWhenSettled_(v(w.length-1),F),u=q.next();while(!u.done)})};return l},"es6","es3");$jscomp.owns=function(h,n){return Object.prototype.hasOwnProperty.call(h,n)};$jscomp.assign=$jscomp.TRUST_ES6_POLYFILLS&&"function"==typeof Object.assign?Object.assign:function(h,n){for(var k=1;k<arguments.length;k++){var p=arguments[k];if(p)for(var l in p)$jscomp.owns(p,l)&&(h[l]=p[l])}return h};
$jscomp.polyfill("Object.assign",function(h){return h||$jscomp.assign},"es6","es3");$jscomp.checkStringArgs=function(h,n,k){if(null==h)throw new TypeError("The 'this' value for String.prototype."+k+" must not be null or undefined");if(n instanceof RegExp)throw new TypeError("First argument to String.prototype."+k+" must not be a regular expression");return h+""};
$jscomp.polyfill("String.prototype.startsWith",function(h){return h?h:function(n,k){var p=$jscomp.checkStringArgs(this,n,"startsWith");n+="";var l=p.length,y=n.length;k=Math.max(0,Math.min(k|0,p.length));for(var f=0;f<y&&k<l;)if(p[k++]!=n[f++])return!1;return f>=y}},"es6","es3");
$jscomp.polyfill("Array.prototype.copyWithin",function(h){function n(k){k=Number(k);return Infinity===k||-Infinity===k?k:k|0}return h?h:function(k,p,l){var y=this.length;k=n(k);p=n(p);l=void 0===l?y:n(l);k=0>k?Math.max(y+k,0):Math.min(k,y);p=0>p?Math.max(y+p,0):Math.min(p,y);l=0>l?Math.max(y+l,0):Math.min(l,y);if(k<p)for(;p<l;)p in this?this[k++]=this[p++]:(delete this[k++],p++);else for(l=Math.min(l,y+p-k),k+=l-p;l>p;)--l in this?this[--k]=this[l]:delete this[--k];return this}},"es6","es3");
$jscomp.typedArrayCopyWithin=function(h){return h?h:Array.prototype.copyWithin};$jscomp.polyfill("Int8Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");$jscomp.polyfill("Uint8Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");$jscomp.polyfill("Uint8ClampedArray.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");$jscomp.polyfill("Int16Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");
$jscomp.polyfill("Uint16Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");$jscomp.polyfill("Int32Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");$jscomp.polyfill("Uint32Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");$jscomp.polyfill("Float32Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");$jscomp.polyfill("Float64Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");
var DracoDecoderModule=function(){var h="undefined"!==typeof document&&document.currentScript?document.currentScript.src:void 0;"undefined"!==typeof __filename&&(h=h||__filename);return function(n){function k(e){return a.locateFile?a.locateFile(e,U):U+e}function p(e,b){if(e){var c=ia;var d=e+b;for(b=e;c[b]&&!(b>=d);)++b;if(16<b-e&&c.buffer&&ra)c=ra.decode(c.subarray(e,b));else{for(d="";e<b;){var g=c[e++];if(g&128){var t=c[e++]&63;if(192==(g&224))d+=String.fromCharCode((g&31)<<6|t);else{var aa=c[e++]&
63;g=224==(g&240)?(g&15)<<12|t<<6|aa:(g&7)<<18|t<<12|aa<<6|c[e++]&63;65536>g?d+=String.fromCharCode(g):(g-=65536,d+=String.fromCharCode(55296|g>>10,56320|g&1023))}}else d+=String.fromCharCode(g)}c=d}}else c="";return c}function l(){var e=ja.buffer;a.HEAP8=W=new Int8Array(e);a.HEAP16=new Int16Array(e);a.HEAP32=ca=new Int32Array(e);a.HEAPU8=ia=new Uint8Array(e);a.HEAPU16=new Uint16Array(e);a.HEAPU32=Y=new Uint32Array(e);a.HEAPF32=new Float32Array(e);a.HEAPF64=new Float64Array(e)}function y(e){if(a.onAbort)a.onAbort(e);
e="Aborted("+e+")";da(e);sa=!0;e=new WebAssembly.RuntimeError(e+". Build with -sASSERTIONS for more info.");ka(e);throw e;}function f(e){try{if(e==P&&ea)return new Uint8Array(ea);if(ma)return ma(e);throw"both async and sync fetching of the wasm failed";}catch(b){y(b)}}function q(){if(!ea&&(ta||fa)){if("function"==typeof fetch&&!P.startsWith("file://"))return fetch(P,{credentials:"same-origin"}).then(function(e){if(!e.ok)throw"failed to load wasm binary file at '"+P+"'";return e.arrayBuffer()}).catch(function(){return f(P)});
if(na)return new Promise(function(e,b){na(P,function(c){e(new Uint8Array(c))},b)})}return Promise.resolve().then(function(){return f(P)})}function u(e){for(;0<e.length;)e.shift()(a)}function A(e){this.excPtr=e;this.ptr=e-24;this.set_type=function(b){Y[this.ptr+4>>2]=b};this.get_type=function(){return Y[this.ptr+4>>2]};this.set_destructor=function(b){Y[this.ptr+8>>2]=b};this.get_destructor=function(){return Y[this.ptr+8>>2]};this.set_refcount=function(b){ca[this.ptr>>2]=b};this.set_caught=function(b){W[this.ptr+
12>>0]=b?1:0};this.get_caught=function(){return 0!=W[this.ptr+12>>0]};this.set_rethrown=function(b){W[this.ptr+13>>0]=b?1:0};this.get_rethrown=function(){return 0!=W[this.ptr+13>>0]};this.init=function(b,c){this.set_adjusted_ptr(0);this.set_type(b);this.set_destructor(c);this.set_refcount(0);this.set_caught(!1);this.set_rethrown(!1)};this.add_ref=function(){ca[this.ptr>>2]+=1};this.release_ref=function(){var b=ca[this.ptr>>2];ca[this.ptr>>2]=b-1;return 1===b};this.set_adjusted_ptr=function(b){Y[this.ptr+
16>>2]=b};this.get_adjusted_ptr=function(){return Y[this.ptr+16>>2]};this.get_exception_ptr=function(){if(ua(this.get_type()))return Y[this.excPtr>>2];var b=this.get_adjusted_ptr();return 0!==b?b:this.excPtr}}function F(){function e(){if(!la&&(la=!0,a.calledRun=!0,!sa)){va=!0;u(oa);wa(a);if(a.onRuntimeInitialized)a.onRuntimeInitialized();if(a.postRun)for("function"==typeof a.postRun&&(a.postRun=[a.postRun]);a.postRun.length;)xa.unshift(a.postRun.shift());u(xa)}}if(!(0<ba)){if(a.preRun)for("function"==
typeof a.preRun&&(a.preRun=[a.preRun]);a.preRun.length;)ya.unshift(a.preRun.shift());u(ya);0<ba||(a.setStatus?(a.setStatus("Running..."),setTimeout(function(){setTimeout(function(){a.setStatus("")},1);e()},1)):e())}}function v(){}function w(e){return(e||v).__cache__}function B(e,b){var c=w(b),d=c[e];if(d)return d;d=Object.create((b||v).prototype);d.ptr=e;return c[e]=d}function R(e){if("string"===typeof e){for(var b=0,c=0;c<e.length;++c){var d=e.charCodeAt(c);127>=d?b++:2047>=d?b+=2:55296<=d&&57343>=
d?(b+=4,++c):b+=3}b=Array(b+1);c=0;d=b.length;if(0<d){d=c+d-1;for(var g=0;g<e.length;++g){var t=e.charCodeAt(g);if(55296<=t&&57343>=t){var aa=e.charCodeAt(++g);t=65536+((t&1023)<<10)|aa&1023}if(127>=t){if(c>=d)break;b[c++]=t}else{if(2047>=t){if(c+1>=d)break;b[c++]=192|t>>6}else{if(65535>=t){if(c+2>=d)break;b[c++]=224|t>>12}else{if(c+3>=d)break;b[c++]=240|t>>18;b[c++]=128|t>>12&63}b[c++]=128|t>>6&63}b[c++]=128|t&63}}b[c]=0}e=r.alloc(b,W);r.copy(b,W,e);return e}return e}function Z(e){if("object"===
typeof e){var b=r.alloc(e,W);r.copy(e,W,b);return b}return e}function X(){throw"cannot construct a VoidPtr, no constructor in IDL";}function S(){this.ptr=za();w(S)[this.ptr]=this}function Q(){this.ptr=Aa();w(Q)[this.ptr]=this}function V(){this.ptr=Ba();w(V)[this.ptr]=this}function x(){this.ptr=Ca();w(x)[this.ptr]=this}function D(){this.ptr=Da();w(D)[this.ptr]=this}function G(){this.ptr=Ea();w(G)[this.ptr]=this}function H(){this.ptr=Fa();w(H)[this.ptr]=this}function E(){this.ptr=Ga();w(E)[this.ptr]=
this}function T(){this.ptr=Ha();w(T)[this.ptr]=this}function C(){throw"cannot construct a Status, no constructor in IDL";}function I(){this.ptr=Ia();w(I)[this.ptr]=this}function J(){this.ptr=Ja();w(J)[this.ptr]=this}function K(){this.ptr=Ka();w(K)[this.ptr]=this}function L(){this.ptr=La();w(L)[this.ptr]=this}function M(){this.ptr=Ma();w(M)[this.ptr]=this}function N(){this.ptr=Na();w(N)[this.ptr]=this}function O(){this.ptr=Oa();w(O)[this.ptr]=this}function z(){this.ptr=Pa();w(z)[this.ptr]=this}function m(){this.ptr=
Qa();w(m)[this.ptr]=this}n=void 0===n?{}:n;var a="undefined"!=typeof n?n:{},wa,ka;a.ready=new Promise(function(e,b){wa=e;ka=b});var Ra=!1,Sa=!1;a.onRuntimeInitialized=function(){Ra=!0;if(Sa&&"function"===typeof a.onModuleLoaded)a.onModuleLoaded(a)};a.onModuleParsed=function(){Sa=!0;if(Ra&&"function"===typeof a.onModuleLoaded)a.onModuleLoaded(a)};a.isVersionSupported=function(e){if("string"!==typeof e)return!1;e=e.split(".");return 2>e.length||3<e.length?!1:1==e[0]&&0<=e[1]&&5>=e[1]?!0:0!=e[0]||10<
e[1]?!1:!0};var Ta=Object.assign({},a),ta="object"==typeof window,fa="function"==typeof importScripts,Ua="object"==typeof process&&"object"==typeof process.versions&&"string"==typeof process.versions.node,U="";if(Ua){var Va=require("fs"),pa=require("path");U=fa?pa.dirname(U)+"/":__dirname+"/";var Wa=function(e,b){e=e.startsWith("file://")?new URL(e):pa.normalize(e);return Va.readFileSync(e,b?void 0:"utf8")};var ma=function(e){e=Wa(e,!0);e.buffer||(e=new Uint8Array(e));return e};var na=function(e,
b,c){e=e.startsWith("file://")?new URL(e):pa.normalize(e);Va.readFile(e,function(d,g){d?c(d):b(g.buffer)})};1<process.argv.length&&process.argv[1].replace(/\\/g,"/");process.argv.slice(2);a.inspect=function(){return"[Emscripten Module object]"}}else if(ta||fa)fa?U=self.location.href:"undefined"!=typeof document&&document.currentScript&&(U=document.currentScript.src),h&&(U=h),U=0!==U.indexOf("blob:")?U.substr(0,U.replace(/[?#].*/,"").lastIndexOf("/")+1):"",Wa=function(e){var b=new XMLHttpRequest;b.open("GET",
e,!1);b.send(null);return b.responseText},fa&&(ma=function(e){var b=new XMLHttpRequest;b.open("GET",e,!1);b.responseType="arraybuffer";b.send(null);return new Uint8Array(b.response)}),na=function(e,b,c){var d=new XMLHttpRequest;d.open("GET",e,!0);d.responseType="arraybuffer";d.onload=function(){200==d.status||0==d.status&&d.response?b(d.response):c()};d.onerror=c;d.send(null)};a.print||console.log.bind(console);var da=a.printErr||console.warn.bind(console);Object.assign(a,Ta);Ta=null;var ea;a.wasmBinary&&
(ea=a.wasmBinary);"object"!=typeof WebAssembly&&y("no native wasm support detected");var ja,sa=!1,ra="undefined"!=typeof TextDecoder?new TextDecoder("utf8"):void 0,W,ia,ca,Y,ya=[],oa=[],xa=[],va=!1,ba=0,qa=null,ha=null;var P="draco_decoder_gltf.wasm";P.startsWith("data:application/octet-stream;base64,")||(P=k(P));var pd=0,qd={b:function(e,b,c){(new A(e)).init(b,c);pd++;throw e;},a:function(){y("")},d:function(e,b,c){ia.copyWithin(e,b,b+c)},c:function(e){var b=ia.length;e>>>=0;if(2147483648<e)return!1;
for(var c=1;4>=c;c*=2){var d=b*(1+.2/c);d=Math.min(d,e+100663296);var g=Math;d=Math.max(e,d);g=g.min.call(g,2147483648,d+(65536-d%65536)%65536);a:{d=ja.buffer;try{ja.grow(g-d.byteLength+65535>>>16);l();var t=1;break a}catch(aa){}t=void 0}if(t)return!0}return!1}};(function(){function e(g,t){a.asm=g.exports;ja=a.asm.e;l();oa.unshift(a.asm.f);ba--;a.monitorRunDependencies&&a.monitorRunDependencies(ba);0==ba&&(null!==qa&&(clearInterval(qa),qa=null),ha&&(g=ha,ha=null,g()))}function b(g){e(g.instance)}
function c(g){return q().then(function(t){return WebAssembly.instantiate(t,d)}).then(function(t){return t}).then(g,function(t){da("failed to asynchronously prepare wasm: "+t);y(t)})}var d={a:qd};ba++;a.monitorRunDependencies&&a.monitorRunDependencies(ba);if(a.instantiateWasm)try{return a.instantiateWasm(d,e)}catch(g){da("Module.instantiateWasm callback failed with error: "+g),ka(g)}(function(){return ea||"function"!=typeof WebAssembly.instantiateStreaming||P.startsWith("data:application/octet-stream;base64,")||
P.startsWith("file://")||Ua||"function"!=typeof fetch?c(b):fetch(P,{credentials:"same-origin"}).then(function(g){return WebAssembly.instantiateStreaming(g,d).then(b,function(t){da("wasm streaming compile failed: "+t);da("falling back to ArrayBuffer instantiation");return c(b)})})})().catch(ka);return{}})();var Xa=a._emscripten_bind_VoidPtr___destroy___0=function(){return(Xa=a._emscripten_bind_VoidPtr___destroy___0=a.asm.h).apply(null,arguments)},za=a._emscripten_bind_DecoderBuffer_DecoderBuffer_0=
function(){return(za=a._emscripten_bind_DecoderBuffer_DecoderBuffer_0=a.asm.i).apply(null,arguments)},Ya=a._emscripten_bind_DecoderBuffer_Init_2=function(){return(Ya=a._emscripten_bind_DecoderBuffer_Init_2=a.asm.j).apply(null,arguments)},Za=a._emscripten_bind_DecoderBuffer___destroy___0=function(){return(Za=a._emscripten_bind_DecoderBuffer___destroy___0=a.asm.k).apply(null,arguments)},Aa=a._emscripten_bind_AttributeTransformData_AttributeTransformData_0=function(){return(Aa=a._emscripten_bind_AttributeTransformData_AttributeTransformData_0=
a.asm.l).apply(null,arguments)},$a=a._emscripten_bind_AttributeTransformData_transform_type_0=function(){return($a=a._emscripten_bind_AttributeTransformData_transform_type_0=a.asm.m).apply(null,arguments)},ab=a._emscripten_bind_AttributeTransformData___destroy___0=function(){return(ab=a._emscripten_bind_AttributeTransformData___destroy___0=a.asm.n).apply(null,arguments)},Ba=a._emscripten_bind_GeometryAttribute_GeometryAttribute_0=function(){return(Ba=a._emscripten_bind_GeometryAttribute_GeometryAttribute_0=
a.asm.o).apply(null,arguments)},bb=a._emscripten_bind_GeometryAttribute___destroy___0=function(){return(bb=a._emscripten_bind_GeometryAttribute___destroy___0=a.asm.p).apply(null,arguments)},Ca=a._emscripten_bind_PointAttribute_PointAttribute_0=function(){return(Ca=a._emscripten_bind_PointAttribute_PointAttribute_0=a.asm.q).apply(null,arguments)},cb=a._emscripten_bind_PointAttribute_size_0=function(){return(cb=a._emscripten_bind_PointAttribute_size_0=a.asm.r).apply(null,arguments)},db=a._emscripten_bind_PointAttribute_GetAttributeTransformData_0=
function(){return(db=a._emscripten_bind_PointAttribute_GetAttributeTransformData_0=a.asm.s).apply(null,arguments)},eb=a._emscripten_bind_PointAttribute_attribute_type_0=function(){return(eb=a._emscripten_bind_PointAttribute_attribute_type_0=a.asm.t).apply(null,arguments)},fb=a._emscripten_bind_PointAttribute_data_type_0=function(){return(fb=a._emscripten_bind_PointAttribute_data_type_0=a.asm.u).apply(null,arguments)},gb=a._emscripten_bind_PointAttribute_num_components_0=function(){return(gb=a._emscripten_bind_PointAttribute_num_components_0=
a.asm.v).apply(null,arguments)},hb=a._emscripten_bind_PointAttribute_normalized_0=function(){return(hb=a._emscripten_bind_PointAttribute_normalized_0=a.asm.w).apply(null,arguments)},ib=a._emscripten_bind_PointAttribute_byte_stride_0=function(){return(ib=a._emscripten_bind_PointAttribute_byte_stride_0=a.asm.x).apply(null,arguments)},jb=a._emscripten_bind_PointAttribute_byte_offset_0=function(){return(jb=a._emscripten_bind_PointAttribute_byte_offset_0=a.asm.y).apply(null,arguments)},kb=a._emscripten_bind_PointAttribute_unique_id_0=
function(){return(kb=a._emscripten_bind_PointAttribute_unique_id_0=a.asm.z).apply(null,arguments)},lb=a._emscripten_bind_PointAttribute___destroy___0=function(){return(lb=a._emscripten_bind_PointAttribute___destroy___0=a.asm.A).apply(null,arguments)},Da=a._emscripten_bind_AttributeQuantizationTransform_AttributeQuantizationTransform_0=function(){return(Da=a._emscripten_bind_AttributeQuantizationTransform_AttributeQuantizationTransform_0=a.asm.B).apply(null,arguments)},mb=a._emscripten_bind_AttributeQuantizationTransform_InitFromAttribute_1=
function(){return(mb=a._emscripten_bind_AttributeQuantizationTransform_InitFromAttribute_1=a.asm.C).apply(null,arguments)},nb=a._emscripten_bind_AttributeQuantizationTransform_quantization_bits_0=function(){return(nb=a._emscripten_bind_AttributeQuantizationTransform_quantization_bits_0=a.asm.D).apply(null,arguments)},ob=a._emscripten_bind_AttributeQuantizationTransform_min_value_1=function(){return(ob=a._emscripten_bind_AttributeQuantizationTransform_min_value_1=a.asm.E).apply(null,arguments)},pb=
a._emscripten_bind_AttributeQuantizationTransform_range_0=function(){return(pb=a._emscripten_bind_AttributeQuantizationTransform_range_0=a.asm.F).apply(null,arguments)},qb=a._emscripten_bind_AttributeQuantizationTransform___destroy___0=function(){return(qb=a._emscripten_bind_AttributeQuantizationTransform___destroy___0=a.asm.G).apply(null,arguments)},Ea=a._emscripten_bind_AttributeOctahedronTransform_AttributeOctahedronTransform_0=function(){return(Ea=a._emscripten_bind_AttributeOctahedronTransform_AttributeOctahedronTransform_0=
a.asm.H).apply(null,arguments)},rb=a._emscripten_bind_AttributeOctahedronTransform_InitFromAttribute_1=function(){return(rb=a._emscripten_bind_AttributeOctahedronTransform_InitFromAttribute_1=a.asm.I).apply(null,arguments)},sb=a._emscripten_bind_AttributeOctahedronTransform_quantization_bits_0=function(){return(sb=a._emscripten_bind_AttributeOctahedronTransform_quantization_bits_0=a.asm.J).apply(null,arguments)},tb=a._emscripten_bind_AttributeOctahedronTransform___destroy___0=function(){return(tb=
a._emscripten_bind_AttributeOctahedronTransform___destroy___0=a.asm.K).apply(null,arguments)},Fa=a._emscripten_bind_PointCloud_PointCloud_0=function(){return(Fa=a._emscripten_bind_PointCloud_PointCloud_0=a.asm.L).apply(null,arguments)},ub=a._emscripten_bind_PointCloud_num_attributes_0=function(){return(ub=a._emscripten_bind_PointCloud_num_attributes_0=a.asm.M).apply(null,arguments)},vb=a._emscripten_bind_PointCloud_num_points_0=function(){return(vb=a._emscripten_bind_PointCloud_num_points_0=a.asm.N).apply(null,
arguments)},wb=a._emscripten_bind_PointCloud___destroy___0=function(){return(wb=a._emscripten_bind_PointCloud___destroy___0=a.asm.O).apply(null,arguments)},Ga=a._emscripten_bind_Mesh_Mesh_0=function(){return(Ga=a._emscripten_bind_Mesh_Mesh_0=a.asm.P).apply(null,arguments)},xb=a._emscripten_bind_Mesh_num_faces_0=function(){return(xb=a._emscripten_bind_Mesh_num_faces_0=a.asm.Q).apply(null,arguments)},yb=a._emscripten_bind_Mesh_num_attributes_0=function(){return(yb=a._emscripten_bind_Mesh_num_attributes_0=
a.asm.R).apply(null,arguments)},zb=a._emscripten_bind_Mesh_num_points_0=function(){return(zb=a._emscripten_bind_Mesh_num_points_0=a.asm.S).apply(null,arguments)},Ab=a._emscripten_bind_Mesh___destroy___0=function(){return(Ab=a._emscripten_bind_Mesh___destroy___0=a.asm.T).apply(null,arguments)},Ha=a._emscripten_bind_Metadata_Metadata_0=function(){return(Ha=a._emscripten_bind_Metadata_Metadata_0=a.asm.U).apply(null,arguments)},Bb=a._emscripten_bind_Metadata___destroy___0=function(){return(Bb=a._emscripten_bind_Metadata___destroy___0=
a.asm.V).apply(null,arguments)},Cb=a._emscripten_bind_Status_code_0=function(){return(Cb=a._emscripten_bind_Status_code_0=a.asm.W).apply(null,arguments)},Db=a._emscripten_bind_Status_ok_0=function(){return(Db=a._emscripten_bind_Status_ok_0=a.asm.X).apply(null,arguments)},Eb=a._emscripten_bind_Status_error_msg_0=function(){return(Eb=a._emscripten_bind_Status_error_msg_0=a.asm.Y).apply(null,arguments)},Fb=a._emscripten_bind_Status___destroy___0=function(){return(Fb=a._emscripten_bind_Status___destroy___0=
a.asm.Z).apply(null,arguments)},Ia=a._emscripten_bind_DracoFloat32Array_DracoFloat32Array_0=function(){return(Ia=a._emscripten_bind_DracoFloat32Array_DracoFloat32Array_0=a.asm._).apply(null,arguments)},Gb=a._emscripten_bind_DracoFloat32Array_GetValue_1=function(){return(Gb=a._emscripten_bind_DracoFloat32Array_GetValue_1=a.asm.$).apply(null,arguments)},Hb=a._emscripten_bind_DracoFloat32Array_size_0=function(){return(Hb=a._emscripten_bind_DracoFloat32Array_size_0=a.asm.aa).apply(null,arguments)},Ib=
a._emscripten_bind_DracoFloat32Array___destroy___0=function(){return(Ib=a._emscripten_bind_DracoFloat32Array___destroy___0=a.asm.ba).apply(null,arguments)},Ja=a._emscripten_bind_DracoInt8Array_DracoInt8Array_0=function(){return(Ja=a._emscripten_bind_DracoInt8Array_DracoInt8Array_0=a.asm.ca).apply(null,arguments)},Jb=a._emscripten_bind_DracoInt8Array_GetValue_1=function(){return(Jb=a._emscripten_bind_DracoInt8Array_GetValue_1=a.asm.da).apply(null,arguments)},Kb=a._emscripten_bind_DracoInt8Array_size_0=
function(){return(Kb=a._emscripten_bind_DracoInt8Array_size_0=a.asm.ea).apply(null,arguments)},Lb=a._emscripten_bind_DracoInt8Array___destroy___0=function(){return(Lb=a._emscripten_bind_DracoInt8Array___destroy___0=a.asm.fa).apply(null,arguments)},Ka=a._emscripten_bind_DracoUInt8Array_DracoUInt8Array_0=function(){return(Ka=a._emscripten_bind_DracoUInt8Array_DracoUInt8Array_0=a.asm.ga).apply(null,arguments)},Mb=a._emscripten_bind_DracoUInt8Array_GetValue_1=function(){return(Mb=a._emscripten_bind_DracoUInt8Array_GetValue_1=
a.asm.ha).apply(null,arguments)},Nb=a._emscripten_bind_DracoUInt8Array_size_0=function(){return(Nb=a._emscripten_bind_DracoUInt8Array_size_0=a.asm.ia).apply(null,arguments)},Ob=a._emscripten_bind_DracoUInt8Array___destroy___0=function(){return(Ob=a._emscripten_bind_DracoUInt8Array___destroy___0=a.asm.ja).apply(null,arguments)},La=a._emscripten_bind_DracoInt16Array_DracoInt16Array_0=function(){return(La=a._emscripten_bind_DracoInt16Array_DracoInt16Array_0=a.asm.ka).apply(null,arguments)},Pb=a._emscripten_bind_DracoInt16Array_GetValue_1=
function(){return(Pb=a._emscripten_bind_DracoInt16Array_GetValue_1=a.asm.la).apply(null,arguments)},Qb=a._emscripten_bind_DracoInt16Array_size_0=function(){return(Qb=a._emscripten_bind_DracoInt16Array_size_0=a.asm.ma).apply(null,arguments)},Rb=a._emscripten_bind_DracoInt16Array___destroy___0=function(){return(Rb=a._emscripten_bind_DracoInt16Array___destroy___0=a.asm.na).apply(null,arguments)},Ma=a._emscripten_bind_DracoUInt16Array_DracoUInt16Array_0=function(){return(Ma=a._emscripten_bind_DracoUInt16Array_DracoUInt16Array_0=
a.asm.oa).apply(null,arguments)},Sb=a._emscripten_bind_DracoUInt16Array_GetValue_1=function(){return(Sb=a._emscripten_bind_DracoUInt16Array_GetValue_1=a.asm.pa).apply(null,arguments)},Tb=a._emscripten_bind_DracoUInt16Array_size_0=function(){return(Tb=a._emscripten_bind_DracoUInt16Array_size_0=a.asm.qa).apply(null,arguments)},Ub=a._emscripten_bind_DracoUInt16Array___destroy___0=function(){return(Ub=a._emscripten_bind_DracoUInt16Array___destroy___0=a.asm.ra).apply(null,arguments)},Na=a._emscripten_bind_DracoInt32Array_DracoInt32Array_0=
function(){return(Na=a._emscripten_bind_DracoInt32Array_DracoInt32Array_0=a.asm.sa).apply(null,arguments)},Vb=a._emscripten_bind_DracoInt32Array_GetValue_1=function(){return(Vb=a._emscripten_bind_DracoInt32Array_GetValue_1=a.asm.ta).apply(null,arguments)},Wb=a._emscripten_bind_DracoInt32Array_size_0=function(){return(Wb=a._emscripten_bind_DracoInt32Array_size_0=a.asm.ua).apply(null,arguments)},Xb=a._emscripten_bind_DracoInt32Array___destroy___0=function(){return(Xb=a._emscripten_bind_DracoInt32Array___destroy___0=
a.asm.va).apply(null,arguments)},Oa=a._emscripten_bind_DracoUInt32Array_DracoUInt32Array_0=function(){return(Oa=a._emscripten_bind_DracoUInt32Array_DracoUInt32Array_0=a.asm.wa).apply(null,arguments)},Yb=a._emscripten_bind_DracoUInt32Array_GetValue_1=function(){return(Yb=a._emscripten_bind_DracoUInt32Array_GetValue_1=a.asm.xa).apply(null,arguments)},Zb=a._emscripten_bind_DracoUInt32Array_size_0=function(){return(Zb=a._emscripten_bind_DracoUInt32Array_size_0=a.asm.ya).apply(null,arguments)},$b=a._emscripten_bind_DracoUInt32Array___destroy___0=
function(){return($b=a._emscripten_bind_DracoUInt32Array___destroy___0=a.asm.za).apply(null,arguments)},Pa=a._emscripten_bind_MetadataQuerier_MetadataQuerier_0=function(){return(Pa=a._emscripten_bind_MetadataQuerier_MetadataQuerier_0=a.asm.Aa).apply(null,arguments)},ac=a._emscripten_bind_MetadataQuerier_HasEntry_2=function(){return(ac=a._emscripten_bind_MetadataQuerier_HasEntry_2=a.asm.Ba).apply(null,arguments)},bc=a._emscripten_bind_MetadataQuerier_GetIntEntry_2=function(){return(bc=a._emscripten_bind_MetadataQuerier_GetIntEntry_2=
a.asm.Ca).apply(null,arguments)},cc=a._emscripten_bind_MetadataQuerier_GetIntEntryArray_3=function(){return(cc=a._emscripten_bind_MetadataQuerier_GetIntEntryArray_3=a.asm.Da).apply(null,arguments)},dc=a._emscripten_bind_MetadataQuerier_GetDoubleEntry_2=function(){return(dc=a._emscripten_bind_MetadataQuerier_GetDoubleEntry_2=a.asm.Ea).apply(null,arguments)},ec=a._emscripten_bind_MetadataQuerier_GetStringEntry_2=function(){return(ec=a._emscripten_bind_MetadataQuerier_GetStringEntry_2=a.asm.Fa).apply(null,
arguments)},fc=a._emscripten_bind_MetadataQuerier_NumEntries_1=function(){return(fc=a._emscripten_bind_MetadataQuerier_NumEntries_1=a.asm.Ga).apply(null,arguments)},gc=a._emscripten_bind_MetadataQuerier_GetEntryName_2=function(){return(gc=a._emscripten_bind_MetadataQuerier_GetEntryName_2=a.asm.Ha).apply(null,arguments)},hc=a._emscripten_bind_MetadataQuerier___destroy___0=function(){return(hc=a._emscripten_bind_MetadataQuerier___destroy___0=a.asm.Ia).apply(null,arguments)},Qa=a._emscripten_bind_Decoder_Decoder_0=
function(){return(Qa=a._emscripten_bind_Decoder_Decoder_0=a.asm.Ja).apply(null,arguments)},ic=a._emscripten_bind_Decoder_DecodeArrayToPointCloud_3=function(){return(ic=a._emscripten_bind_Decoder_DecodeArrayToPointCloud_3=a.asm.Ka).apply(null,arguments)},jc=a._emscripten_bind_Decoder_DecodeArrayToMesh_3=function(){return(jc=a._emscripten_bind_Decoder_DecodeArrayToMesh_3=a.asm.La).apply(null,arguments)},kc=a._emscripten_bind_Decoder_GetAttributeId_2=function(){return(kc=a._emscripten_bind_Decoder_GetAttributeId_2=
a.asm.Ma).apply(null,arguments)},lc=a._emscripten_bind_Decoder_GetAttributeIdByName_2=function(){return(lc=a._emscripten_bind_Decoder_GetAttributeIdByName_2=a.asm.Na).apply(null,arguments)},mc=a._emscripten_bind_Decoder_GetAttributeIdByMetadataEntry_3=function(){return(mc=a._emscripten_bind_Decoder_GetAttributeIdByMetadataEntry_3=a.asm.Oa).apply(null,arguments)},nc=a._emscripten_bind_Decoder_GetAttribute_2=function(){return(nc=a._emscripten_bind_Decoder_GetAttribute_2=a.asm.Pa).apply(null,arguments)},
oc=a._emscripten_bind_Decoder_GetAttributeByUniqueId_2=function(){return(oc=a._emscripten_bind_Decoder_GetAttributeByUniqueId_2=a.asm.Qa).apply(null,arguments)},pc=a._emscripten_bind_Decoder_GetMetadata_1=function(){return(pc=a._emscripten_bind_Decoder_GetMetadata_1=a.asm.Ra).apply(null,arguments)},qc=a._emscripten_bind_Decoder_GetAttributeMetadata_2=function(){return(qc=a._emscripten_bind_Decoder_GetAttributeMetadata_2=a.asm.Sa).apply(null,arguments)},rc=a._emscripten_bind_Decoder_GetFaceFromMesh_3=
function(){return(rc=a._emscripten_bind_Decoder_GetFaceFromMesh_3=a.asm.Ta).apply(null,arguments)},sc=a._emscripten_bind_Decoder_GetTriangleStripsFromMesh_2=function(){return(sc=a._emscripten_bind_Decoder_GetTriangleStripsFromMesh_2=a.asm.Ua).apply(null,arguments)},tc=a._emscripten_bind_Decoder_GetTrianglesUInt16Array_3=function(){return(tc=a._emscripten_bind_Decoder_GetTrianglesUInt16Array_3=a.asm.Va).apply(null,arguments)},uc=a._emscripten_bind_Decoder_GetTrianglesUInt32Array_3=function(){return(uc=
a._emscripten_bind_Decoder_GetTrianglesUInt32Array_3=a.asm.Wa).apply(null,arguments)},vc=a._emscripten_bind_Decoder_GetAttributeFloat_3=function(){return(vc=a._emscripten_bind_Decoder_GetAttributeFloat_3=a.asm.Xa).apply(null,arguments)},wc=a._emscripten_bind_Decoder_GetAttributeFloatForAllPoints_3=function(){return(wc=a._emscripten_bind_Decoder_GetAttributeFloatForAllPoints_3=a.asm.Ya).apply(null,arguments)},xc=a._emscripten_bind_Decoder_GetAttributeIntForAllPoints_3=function(){return(xc=a._emscripten_bind_Decoder_GetAttributeIntForAllPoints_3=
a.asm.Za).apply(null,arguments)},yc=a._emscripten_bind_Decoder_GetAttributeInt8ForAllPoints_3=function(){return(yc=a._emscripten_bind_Decoder_GetAttributeInt8ForAllPoints_3=a.asm._a).apply(null,arguments)},zc=a._emscripten_bind_Decoder_GetAttributeUInt8ForAllPoints_3=function(){return(zc=a._emscripten_bind_Decoder_GetAttributeUInt8ForAllPoints_3=a.asm.$a).apply(null,arguments)},Ac=a._emscripten_bind_Decoder_GetAttributeInt16ForAllPoints_3=function(){return(Ac=a._emscripten_bind_Decoder_GetAttributeInt16ForAllPoints_3=
a.asm.ab).apply(null,arguments)},Bc=a._emscripten_bind_Decoder_GetAttributeUInt16ForAllPoints_3=function(){return(Bc=a._emscripten_bind_Decoder_GetAttributeUInt16ForAllPoints_3=a.asm.bb).apply(null,arguments)},Cc=a._emscripten_bind_Decoder_GetAttributeInt32ForAllPoints_3=function(){return(Cc=a._emscripten_bind_Decoder_GetAttributeInt32ForAllPoints_3=a.asm.cb).apply(null,arguments)},Dc=a._emscripten_bind_Decoder_GetAttributeUInt32ForAllPoints_3=function(){return(Dc=a._emscripten_bind_Decoder_GetAttributeUInt32ForAllPoints_3=
a.asm.db).apply(null,arguments)},Ec=a._emscripten_bind_Decoder_GetAttributeDataArrayForAllPoints_5=function(){return(Ec=a._emscripten_bind_Decoder_GetAttributeDataArrayForAllPoints_5=a.asm.eb).apply(null,arguments)},Fc=a._emscripten_bind_Decoder_SkipAttributeTransform_1=function(){return(Fc=a._emscripten_bind_Decoder_SkipAttributeTransform_1=a.asm.fb).apply(null,arguments)},Gc=a._emscripten_bind_Decoder_GetEncodedGeometryType_Deprecated_1=function(){return(Gc=a._emscripten_bind_Decoder_GetEncodedGeometryType_Deprecated_1=
a.asm.gb).apply(null,arguments)},Hc=a._emscripten_bind_Decoder_DecodeBufferToPointCloud_2=function(){return(Hc=a._emscripten_bind_Decoder_DecodeBufferToPointCloud_2=a.asm.hb).apply(null,arguments)},Ic=a._emscripten_bind_Decoder_DecodeBufferToMesh_2=function(){return(Ic=a._emscripten_bind_Decoder_DecodeBufferToMesh_2=a.asm.ib).apply(null,arguments)},Jc=a._emscripten_bind_Decoder___destroy___0=function(){return(Jc=a._emscripten_bind_Decoder___destroy___0=a.asm.jb).apply(null,arguments)},Kc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_INVALID_TRANSFORM=
function(){return(Kc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_INVALID_TRANSFORM=a.asm.kb).apply(null,arguments)},Lc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_NO_TRANSFORM=function(){return(Lc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_NO_TRANSFORM=a.asm.lb).apply(null,arguments)},Mc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_QUANTIZATION_TRANSFORM=function(){return(Mc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_QUANTIZATION_TRANSFORM=
a.asm.mb).apply(null,arguments)},Nc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_OCTAHEDRON_TRANSFORM=function(){return(Nc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_OCTAHEDRON_TRANSFORM=a.asm.nb).apply(null,arguments)},Oc=a._emscripten_enum_draco_GeometryAttribute_Type_INVALID=function(){return(Oc=a._emscripten_enum_draco_GeometryAttribute_Type_INVALID=a.asm.ob).apply(null,arguments)},Pc=a._emscripten_enum_draco_GeometryAttribute_Type_POSITION=function(){return(Pc=a._emscripten_enum_draco_GeometryAttribute_Type_POSITION=
a.asm.pb).apply(null,arguments)},Qc=a._emscripten_enum_draco_GeometryAttribute_Type_NORMAL=function(){return(Qc=a._emscripten_enum_draco_GeometryAttribute_Type_NORMAL=a.asm.qb).apply(null,arguments)},Rc=a._emscripten_enum_draco_GeometryAttribute_Type_COLOR=function(){return(Rc=a._emscripten_enum_draco_GeometryAttribute_Type_COLOR=a.asm.rb).apply(null,arguments)},Sc=a._emscripten_enum_draco_GeometryAttribute_Type_TEX_COORD=function(){return(Sc=a._emscripten_enum_draco_GeometryAttribute_Type_TEX_COORD=
a.asm.sb).apply(null,arguments)},Tc=a._emscripten_enum_draco_GeometryAttribute_Type_GENERIC=function(){return(Tc=a._emscripten_enum_draco_GeometryAttribute_Type_GENERIC=a.asm.tb).apply(null,arguments)},Uc=a._emscripten_enum_draco_EncodedGeometryType_INVALID_GEOMETRY_TYPE=function(){return(Uc=a._emscripten_enum_draco_EncodedGeometryType_INVALID_GEOMETRY_TYPE=a.asm.ub).apply(null,arguments)},Vc=a._emscripten_enum_draco_EncodedGeometryType_POINT_CLOUD=function(){return(Vc=a._emscripten_enum_draco_EncodedGeometryType_POINT_CLOUD=
a.asm.vb).apply(null,arguments)},Wc=a._emscripten_enum_draco_EncodedGeometryType_TRIANGULAR_MESH=function(){return(Wc=a._emscripten_enum_draco_EncodedGeometryType_TRIANGULAR_MESH=a.asm.wb).apply(null,arguments)},Xc=a._emscripten_enum_draco_DataType_DT_INVALID=function(){return(Xc=a._emscripten_enum_draco_DataType_DT_INVALID=a.asm.xb).apply(null,arguments)},Yc=a._emscripten_enum_draco_DataType_DT_INT8=function(){return(Yc=a._emscripten_enum_draco_DataType_DT_INT8=a.asm.yb).apply(null,arguments)},Zc=
a._emscripten_enum_draco_DataType_DT_UINT8=function(){return(Zc=a._emscripten_enum_draco_DataType_DT_UINT8=a.asm.zb).apply(null,arguments)},$c=a._emscripten_enum_draco_DataType_DT_INT16=function(){return($c=a._emscripten_enum_draco_DataType_DT_INT16=a.asm.Ab).apply(null,arguments)},ad=a._emscripten_enum_draco_DataType_DT_UINT16=function(){return(ad=a._emscripten_enum_draco_DataType_DT_UINT16=a.asm.Bb).apply(null,arguments)},bd=a._emscripten_enum_draco_DataType_DT_INT32=function(){return(bd=a._emscripten_enum_draco_DataType_DT_INT32=
a.asm.Cb).apply(null,arguments)},cd=a._emscripten_enum_draco_DataType_DT_UINT32=function(){return(cd=a._emscripten_enum_draco_DataType_DT_UINT32=a.asm.Db).apply(null,arguments)},dd=a._emscripten_enum_draco_DataType_DT_INT64=function(){return(dd=a._emscripten_enum_draco_DataType_DT_INT64=a.asm.Eb).apply(null,arguments)},ed=a._emscripten_enum_draco_DataType_DT_UINT64=function(){return(ed=a._emscripten_enum_draco_DataType_DT_UINT64=a.asm.Fb).apply(null,arguments)},fd=a._emscripten_enum_draco_DataType_DT_FLOAT32=
function(){return(fd=a._emscripten_enum_draco_DataType_DT_FLOAT32=a.asm.Gb).apply(null,arguments)},gd=a._emscripten_enum_draco_DataType_DT_FLOAT64=function(){return(gd=a._emscripten_enum_draco_DataType_DT_FLOAT64=a.asm.Hb).apply(null,arguments)},hd=a._emscripten_enum_draco_DataType_DT_BOOL=function(){return(hd=a._emscripten_enum_draco_DataType_DT_BOOL=a.asm.Ib).apply(null,arguments)},id=a._emscripten_enum_draco_DataType_DT_TYPES_COUNT=function(){return(id=a._emscripten_enum_draco_DataType_DT_TYPES_COUNT=
a.asm.Jb).apply(null,arguments)},jd=a._emscripten_enum_draco_StatusCode_OK=function(){return(jd=a._emscripten_enum_draco_StatusCode_OK=a.asm.Kb).apply(null,arguments)},kd=a._emscripten_enum_draco_StatusCode_DRACO_ERROR=function(){return(kd=a._emscripten_enum_draco_StatusCode_DRACO_ERROR=a.asm.Lb).apply(null,arguments)},ld=a._emscripten_enum_draco_StatusCode_IO_ERROR=function(){return(ld=a._emscripten_enum_draco_StatusCode_IO_ERROR=a.asm.Mb).apply(null,arguments)},md=a._emscripten_enum_draco_StatusCode_INVALID_PARAMETER=
function(){return(md=a._emscripten_enum_draco_StatusCode_INVALID_PARAMETER=a.asm.Nb).apply(null,arguments)},nd=a._emscripten_enum_draco_StatusCode_UNSUPPORTED_VERSION=function(){return(nd=a._emscripten_enum_draco_StatusCode_UNSUPPORTED_VERSION=a.asm.Ob).apply(null,arguments)},od=a._emscripten_enum_draco_StatusCode_UNKNOWN_VERSION=function(){return(od=a._emscripten_enum_draco_StatusCode_UNKNOWN_VERSION=a.asm.Pb).apply(null,arguments)};a._malloc=function(){return(a._malloc=a.asm.Qb).apply(null,arguments)};
a._free=function(){return(a._free=a.asm.Rb).apply(null,arguments)};var ua=function(){return(ua=a.asm.Sb).apply(null,arguments)};a.___start_em_js=11660;a.___stop_em_js=11758;var la;ha=function b(){la||F();la||(ha=b)};if(a.preInit)for("function"==typeof a.preInit&&(a.preInit=[a.preInit]);0<a.preInit.length;)a.preInit.pop()();F();v.prototype=Object.create(v.prototype);v.prototype.constructor=v;v.prototype.__class__=v;v.__cache__={};a.WrapperObject=v;a.getCache=w;a.wrapPointer=B;a.castObject=function(b,
c){return B(b.ptr,c)};a.NULL=B(0);a.destroy=function(b){if(!b.__destroy__)throw"Error: Cannot destroy object. (Did you create it yourself?)";b.__destroy__();delete w(b.__class__)[b.ptr]};a.compare=function(b,c){return b.ptr===c.ptr};a.getPointer=function(b){return b.ptr};a.getClass=function(b){return b.__class__};var r={buffer:0,size:0,pos:0,temps:[],needed:0,prepare:function(){if(r.needed){for(var b=0;b<r.temps.length;b++)a._free(r.temps[b]);r.temps.length=0;a._free(r.buffer);r.buffer=0;r.size+=
r.needed;r.needed=0}r.buffer||(r.size+=128,r.buffer=a._malloc(r.size),r.buffer||y(void 0));r.pos=0},alloc:function(b,c){r.buffer||y(void 0);b=b.length*c.BYTES_PER_ELEMENT;b=b+7&-8;r.pos+b>=r.size?(0<b||y(void 0),r.needed+=b,c=a._malloc(b),r.temps.push(c)):(c=r.buffer+r.pos,r.pos+=b);return c},copy:function(b,c,d){d>>>=0;switch(c.BYTES_PER_ELEMENT){case 2:d>>>=1;break;case 4:d>>>=2;break;case 8:d>>>=3}for(var g=0;g<b.length;g++)c[d+g]=b[g]}};X.prototype=Object.create(v.prototype);X.prototype.constructor=
X;X.prototype.__class__=X;X.__cache__={};a.VoidPtr=X;X.prototype.__destroy__=X.prototype.__destroy__=function(){Xa(this.ptr)};S.prototype=Object.create(v.prototype);S.prototype.constructor=S;S.prototype.__class__=S;S.__cache__={};a.DecoderBuffer=S;S.prototype.Init=S.prototype.Init=function(b,c){var d=this.ptr;r.prepare();"object"==typeof b&&(b=Z(b));c&&"object"===typeof c&&(c=c.ptr);Ya(d,b,c)};S.prototype.__destroy__=S.prototype.__destroy__=function(){Za(this.ptr)};Q.prototype=Object.create(v.prototype);
Q.prototype.constructor=Q;Q.prototype.__class__=Q;Q.__cache__={};a.AttributeTransformData=Q;Q.prototype.transform_type=Q.prototype.transform_type=function(){return $a(this.ptr)};Q.prototype.__destroy__=Q.prototype.__destroy__=function(){ab(this.ptr)};V.prototype=Object.create(v.prototype);V.prototype.constructor=V;V.prototype.__class__=V;V.__cache__={};a.GeometryAttribute=V;V.prototype.__destroy__=V.prototype.__destroy__=function(){bb(this.ptr)};x.prototype=Object.create(v.prototype);x.prototype.constructor=
x;x.prototype.__class__=x;x.__cache__={};a.PointAttribute=x;x.prototype.size=x.prototype.size=function(){return cb(this.ptr)};x.prototype.GetAttributeTransformData=x.prototype.GetAttributeTransformData=function(){return B(db(this.ptr),Q)};x.prototype.attribute_type=x.prototype.attribute_type=function(){return eb(this.ptr)};x.prototype.data_type=x.prototype.data_type=function(){return fb(this.ptr)};x.prototype.num_components=x.prototype.num_components=function(){return gb(this.ptr)};x.prototype.normalized=
x.prototype.normalized=function(){return!!hb(this.ptr)};x.prototype.byte_stride=x.prototype.byte_stride=function(){return ib(this.ptr)};x.prototype.byte_offset=x.prototype.byte_offset=function(){return jb(this.ptr)};x.prototype.unique_id=x.prototype.unique_id=function(){return kb(this.ptr)};x.prototype.__destroy__=x.prototype.__destroy__=function(){lb(this.ptr)};D.prototype=Object.create(v.prototype);D.prototype.constructor=D;D.prototype.__class__=D;D.__cache__={};a.AttributeQuantizationTransform=
D;D.prototype.InitFromAttribute=D.prototype.InitFromAttribute=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return!!mb(c,b)};D.prototype.quantization_bits=D.prototype.quantization_bits=function(){return nb(this.ptr)};D.prototype.min_value=D.prototype.min_value=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return ob(c,b)};D.prototype.range=D.prototype.range=function(){return pb(this.ptr)};D.prototype.__destroy__=D.prototype.__destroy__=function(){qb(this.ptr)};G.prototype=
Object.create(v.prototype);G.prototype.constructor=G;G.prototype.__class__=G;G.__cache__={};a.AttributeOctahedronTransform=G;G.prototype.InitFromAttribute=G.prototype.InitFromAttribute=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return!!rb(c,b)};G.prototype.quantization_bits=G.prototype.quantization_bits=function(){return sb(this.ptr)};G.prototype.__destroy__=G.prototype.__destroy__=function(){tb(this.ptr)};H.prototype=Object.create(v.prototype);H.prototype.constructor=H;H.prototype.__class__=
H;H.__cache__={};a.PointCloud=H;H.prototype.num_attributes=H.prototype.num_attributes=function(){return ub(this.ptr)};H.prototype.num_points=H.prototype.num_points=function(){return vb(this.ptr)};H.prototype.__destroy__=H.prototype.__destroy__=function(){wb(this.ptr)};E.prototype=Object.create(v.prototype);E.prototype.constructor=E;E.prototype.__class__=E;E.__cache__={};a.Mesh=E;E.prototype.num_faces=E.prototype.num_faces=function(){return xb(this.ptr)};E.prototype.num_attributes=E.prototype.num_attributes=
function(){return yb(this.ptr)};E.prototype.num_points=E.prototype.num_points=function(){return zb(this.ptr)};E.prototype.__destroy__=E.prototype.__destroy__=function(){Ab(this.ptr)};T.prototype=Object.create(v.prototype);T.prototype.constructor=T;T.prototype.__class__=T;T.__cache__={};a.Metadata=T;T.prototype.__destroy__=T.prototype.__destroy__=function(){Bb(this.ptr)};C.prototype=Object.create(v.prototype);C.prototype.constructor=C;C.prototype.__class__=C;C.__cache__={};a.Status=C;C.prototype.code=
C.prototype.code=function(){return Cb(this.ptr)};C.prototype.ok=C.prototype.ok=function(){return!!Db(this.ptr)};C.prototype.error_msg=C.prototype.error_msg=function(){return p(Eb(this.ptr))};C.prototype.__destroy__=C.prototype.__destroy__=function(){Fb(this.ptr)};I.prototype=Object.create(v.prototype);I.prototype.constructor=I;I.prototype.__class__=I;I.__cache__={};a.DracoFloat32Array=I;I.prototype.GetValue=I.prototype.GetValue=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return Gb(c,
b)};I.prototype.size=I.prototype.size=function(){return Hb(this.ptr)};I.prototype.__destroy__=I.prototype.__destroy__=function(){Ib(this.ptr)};J.prototype=Object.create(v.prototype);J.prototype.constructor=J;J.prototype.__class__=J;J.__cache__={};a.DracoInt8Array=J;J.prototype.GetValue=J.prototype.GetValue=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return Jb(c,b)};J.prototype.size=J.prototype.size=function(){return Kb(this.ptr)};J.prototype.__destroy__=J.prototype.__destroy__=function(){Lb(this.ptr)};
K.prototype=Object.create(v.prototype);K.prototype.constructor=K;K.prototype.__class__=K;K.__cache__={};a.DracoUInt8Array=K;K.prototype.GetValue=K.prototype.GetValue=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return Mb(c,b)};K.prototype.size=K.prototype.size=function(){return Nb(this.ptr)};K.prototype.__destroy__=K.prototype.__destroy__=function(){Ob(this.ptr)};L.prototype=Object.create(v.prototype);L.prototype.constructor=L;L.prototype.__class__=L;L.__cache__={};a.DracoInt16Array=
L;L.prototype.GetValue=L.prototype.GetValue=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return Pb(c,b)};L.prototype.size=L.prototype.size=function(){return Qb(this.ptr)};L.prototype.__destroy__=L.prototype.__destroy__=function(){Rb(this.ptr)};M.prototype=Object.create(v.prototype);M.prototype.constructor=M;M.prototype.__class__=M;M.__cache__={};a.DracoUInt16Array=M;M.prototype.GetValue=M.prototype.GetValue=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return Sb(c,b)};
M.prototype.size=M.prototype.size=function(){return Tb(this.ptr)};M.prototype.__destroy__=M.prototype.__destroy__=function(){Ub(this.ptr)};N.prototype=Object.create(v.prototype);N.prototype.constructor=N;N.prototype.__class__=N;N.__cache__={};a.DracoInt32Array=N;N.prototype.GetValue=N.prototype.GetValue=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return Vb(c,b)};N.prototype.size=N.prototype.size=function(){return Wb(this.ptr)};N.prototype.__destroy__=N.prototype.__destroy__=function(){Xb(this.ptr)};
O.prototype=Object.create(v.prototype);O.prototype.constructor=O;O.prototype.__class__=O;O.__cache__={};a.DracoUInt32Array=O;O.prototype.GetValue=O.prototype.GetValue=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return Yb(c,b)};O.prototype.size=O.prototype.size=function(){return Zb(this.ptr)};O.prototype.__destroy__=O.prototype.__destroy__=function(){$b(this.ptr)};z.prototype=Object.create(v.prototype);z.prototype.constructor=z;z.prototype.__class__=z;z.__cache__={};a.MetadataQuerier=
z;z.prototype.HasEntry=z.prototype.HasEntry=function(b,c){var d=this.ptr;r.prepare();b&&"object"===typeof b&&(b=b.ptr);c=c&&"object"===typeof c?c.ptr:R(c);return!!ac(d,b,c)};z.prototype.GetIntEntry=z.prototype.GetIntEntry=function(b,c){var d=this.ptr;r.prepare();b&&"object"===typeof b&&(b=b.ptr);c=c&&"object"===typeof c?c.ptr:R(c);return bc(d,b,c)};z.prototype.GetIntEntryArray=z.prototype.GetIntEntryArray=function(b,c,d){var g=this.ptr;r.prepare();b&&"object"===typeof b&&(b=b.ptr);c=c&&"object"===
typeof c?c.ptr:R(c);d&&"object"===typeof d&&(d=d.ptr);cc(g,b,c,d)};z.prototype.GetDoubleEntry=z.prototype.GetDoubleEntry=function(b,c){var d=this.ptr;r.prepare();b&&"object"===typeof b&&(b=b.ptr);c=c&&"object"===typeof c?c.ptr:R(c);return dc(d,b,c)};z.prototype.GetStringEntry=z.prototype.GetStringEntry=function(b,c){var d=this.ptr;r.prepare();b&&"object"===typeof b&&(b=b.ptr);c=c&&"object"===typeof c?c.ptr:R(c);return p(ec(d,b,c))};z.prototype.NumEntries=z.prototype.NumEntries=function(b){var c=this.ptr;
b&&"object"===typeof b&&(b=b.ptr);return fc(c,b)};z.prototype.GetEntryName=z.prototype.GetEntryName=function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);return p(gc(d,b,c))};z.prototype.__destroy__=z.prototype.__destroy__=function(){hc(this.ptr)};m.prototype=Object.create(v.prototype);m.prototype.constructor=m;m.prototype.__class__=m;m.__cache__={};a.Decoder=m;m.prototype.DecodeArrayToPointCloud=m.prototype.DecodeArrayToPointCloud=function(b,c,d){var g=
this.ptr;r.prepare();"object"==typeof b&&(b=Z(b));c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return B(ic(g,b,c,d),C)};m.prototype.DecodeArrayToMesh=m.prototype.DecodeArrayToMesh=function(b,c,d){var g=this.ptr;r.prepare();"object"==typeof b&&(b=Z(b));c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return B(jc(g,b,c,d),C)};m.prototype.GetAttributeId=m.prototype.GetAttributeId=function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&
(c=c.ptr);return kc(d,b,c)};m.prototype.GetAttributeIdByName=m.prototype.GetAttributeIdByName=function(b,c){var d=this.ptr;r.prepare();b&&"object"===typeof b&&(b=b.ptr);c=c&&"object"===typeof c?c.ptr:R(c);return lc(d,b,c)};m.prototype.GetAttributeIdByMetadataEntry=m.prototype.GetAttributeIdByMetadataEntry=function(b,c,d){var g=this.ptr;r.prepare();b&&"object"===typeof b&&(b=b.ptr);c=c&&"object"===typeof c?c.ptr:R(c);d=d&&"object"===typeof d?d.ptr:R(d);return mc(g,b,c,d)};m.prototype.GetAttribute=
m.prototype.GetAttribute=function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);return B(nc(d,b,c),x)};m.prototype.GetAttributeByUniqueId=m.prototype.GetAttributeByUniqueId=function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);return B(oc(d,b,c),x)};m.prototype.GetMetadata=m.prototype.GetMetadata=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return B(pc(c,b),T)};m.prototype.GetAttributeMetadata=m.prototype.GetAttributeMetadata=
function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);return B(qc(d,b,c),T)};m.prototype.GetFaceFromMesh=m.prototype.GetFaceFromMesh=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!rc(g,b,c,d)};m.prototype.GetTriangleStripsFromMesh=m.prototype.GetTriangleStripsFromMesh=function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);
return sc(d,b,c)};m.prototype.GetTrianglesUInt16Array=m.prototype.GetTrianglesUInt16Array=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!tc(g,b,c,d)};m.prototype.GetTrianglesUInt32Array=m.prototype.GetTrianglesUInt32Array=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!uc(g,b,c,d)};m.prototype.GetAttributeFloat=m.prototype.GetAttributeFloat=
function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!vc(g,b,c,d)};m.prototype.GetAttributeFloatForAllPoints=m.prototype.GetAttributeFloatForAllPoints=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!wc(g,b,c,d)};m.prototype.GetAttributeIntForAllPoints=m.prototype.GetAttributeIntForAllPoints=function(b,c,d){var g=this.ptr;
b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!xc(g,b,c,d)};m.prototype.GetAttributeInt8ForAllPoints=m.prototype.GetAttributeInt8ForAllPoints=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!yc(g,b,c,d)};m.prototype.GetAttributeUInt8ForAllPoints=m.prototype.GetAttributeUInt8ForAllPoints=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=
b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!zc(g,b,c,d)};m.prototype.GetAttributeInt16ForAllPoints=m.prototype.GetAttributeInt16ForAllPoints=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!Ac(g,b,c,d)};m.prototype.GetAttributeUInt16ForAllPoints=m.prototype.GetAttributeUInt16ForAllPoints=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&
(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!Bc(g,b,c,d)};m.prototype.GetAttributeInt32ForAllPoints=m.prototype.GetAttributeInt32ForAllPoints=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!Cc(g,b,c,d)};m.prototype.GetAttributeUInt32ForAllPoints=m.prototype.GetAttributeUInt32ForAllPoints=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===
typeof d&&(d=d.ptr);return!!Dc(g,b,c,d)};m.prototype.GetAttributeDataArrayForAllPoints=m.prototype.GetAttributeDataArrayForAllPoints=function(b,c,d,g,t){var aa=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);g&&"object"===typeof g&&(g=g.ptr);t&&"object"===typeof t&&(t=t.ptr);return!!Ec(aa,b,c,d,g,t)};m.prototype.SkipAttributeTransform=m.prototype.SkipAttributeTransform=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);Fc(c,
b)};m.prototype.GetEncodedGeometryType_Deprecated=m.prototype.GetEncodedGeometryType_Deprecated=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return Gc(c,b)};m.prototype.DecodeBufferToPointCloud=m.prototype.DecodeBufferToPointCloud=function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);return B(Hc(d,b,c),C)};m.prototype.DecodeBufferToMesh=m.prototype.DecodeBufferToMesh=function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===
typeof c&&(c=c.ptr);return B(Ic(d,b,c),C)};m.prototype.__destroy__=m.prototype.__destroy__=function(){Jc(this.ptr)};(function(){function b(){a.ATTRIBUTE_INVALID_TRANSFORM=Kc();a.ATTRIBUTE_NO_TRANSFORM=Lc();a.ATTRIBUTE_QUANTIZATION_TRANSFORM=Mc();a.ATTRIBUTE_OCTAHEDRON_TRANSFORM=Nc();a.INVALID=Oc();a.POSITION=Pc();a.NORMAL=Qc();a.COLOR=Rc();a.TEX_COORD=Sc();a.GENERIC=Tc();a.INVALID_GEOMETRY_TYPE=Uc();a.POINT_CLOUD=Vc();a.TRIANGULAR_MESH=Wc();a.DT_INVALID=Xc();a.DT_INT8=Yc();a.DT_UINT8=Zc();a.DT_INT16=
$c();a.DT_UINT16=ad();a.DT_INT32=bd();a.DT_UINT32=cd();a.DT_INT64=dd();a.DT_UINT64=ed();a.DT_FLOAT32=fd();a.DT_FLOAT64=gd();a.DT_BOOL=hd();a.DT_TYPES_COUNT=id();a.OK=jd();a.DRACO_ERROR=kd();a.IO_ERROR=ld();a.INVALID_PARAMETER=md();a.UNSUPPORTED_VERSION=nd();a.UNKNOWN_VERSION=od()}va?b():oa.unshift(b)})();if("function"===typeof a.onModuleParsed)a.onModuleParsed();a.Decoder.prototype.GetEncodedGeometryType=function(b){if(b.__class__&&b.__class__===a.DecoderBuffer)return a.Decoder.prototype.GetEncodedGeometryType_Deprecated(b);
if(8>b.byteLength)return a.INVALID_GEOMETRY_TYPE;switch(b[7]){case 0:return a.POINT_CLOUD;case 1:return a.TRIANGULAR_MESH;default:return a.INVALID_GEOMETRY_TYPE}};return n.ready}}();"object"===typeof exports&&"object"===typeof module?module.exports=DracoDecoderModule:"function"===typeof define&&define.amd?define([],function(){return DracoDecoderModule}):"object"===typeof exports&&(exports.DracoDecoderModule=DracoDecoderModule);
", "import DRACO_DECODER_WASM from \"base64:three/examples/jsm/libs/draco/gltf/draco_decoder.wasm\";\nimport DRACO_WASM_WRAPPER from \"base64:three/examples/jsm/libs/draco/gltf/draco_wasm_wrapper.js\";\nimport { AnimationClip, FileLoader, Group, LoadingManager } from \"three\";\n// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n// @ts-ignore\nimport { DRACOLoader } from \"three/addons/loaders/DRACOLoader.js\";\n// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n// @ts-ignore\nimport { MeshoptDecoder } from \"three/examples/jsm/libs/meshopt_decoder.module.js\";\nimport { FBXLoader } from \"three/examples/jsm/loaders/FBXLoader.js\";\nimport { GLTFLoader } from \"three/examples/jsm/loaders/GLTFLoader.js\";\n\nconst textDecoder = new TextDecoder();\n\nfunction convertArrayBufferToString(buffer: ArrayBuffer, from?: number, to?: number) {\n if (from === undefined) {\n from = 0;\n }\n if (to === undefined) {\n to = buffer.byteLength;\n }\n\n return textDecoder.decode(new Uint8Array(buffer, from, to));\n}\n\nconst fbxBinaryHeader = \"Kaydara\\u0020FBX\\u0020Binary\\u0020\\u0020\\0\";\nfunction IsFBXBinary(buffer: ArrayBuffer): boolean {\n return (\n buffer.byteLength >= fbxBinaryHeader.length &&\n fbxBinaryHeader === convertArrayBufferToString(buffer, 0, fbxBinaryHeader.length)\n );\n}\n\nconst gtlfBinaryHeader = \"glTF\";\nfunction IsGLB(buffer: ArrayBuffer): boolean {\n return buffer.byteLength >= 4 && gtlfBinaryHeader === convertArrayBufferToString(buffer, 0, 4);\n}\n\nconst fbxTextHeader = [\n \"K\",\n \"a\",\n \"y\",\n \"d\",\n \"a\",\n \"r\",\n \"a\",\n \"\\\\\",\n \"F\",\n \"B\",\n \"X\",\n \"\\\\\",\n \"B\",\n \"i\",\n \"n\",\n \"a\",\n \"r\",\n \"y\",\n \"\\\\\",\n \"\\\\\",\n];\nfunction isFbxFormatASCII(text: string): boolean {\n let cursor = 0;\n\n function read(offset: number) {\n const result = text[offset - 1];\n text = text.slice(cursor + offset);\n cursor++;\n return result;\n }\n\n for (let i = 0; i < fbxTextHeader.length; ++i) {\n const num = read(1);\n if (num !== fbxTextHeader[i]) {\n return false;\n }\n }\n\n return true;\n}\n\nexport type ModelLoadResult = { group: Group; animations: Array };\n\nexport class ModelLoader {\n private fbxLoader: FBXLoader;\n private gltfLoader: GLTFLoader;\n private static dracoLoader: DRACOLoader | null = null;\n\n private static getDracoLoader() {\n if (ModelLoader.dracoLoader) {\n return ModelLoader.dracoLoader;\n }\n ModelLoader.dracoLoader = new DRACOLoader({\n /*\n Implement the methods of the LoadingManager interface so that we can inject the embedded Draco decoder\n rather than retrieve it from the network by overriding the resolveURL method to return data URIs.\n */\n resolveURL: (url: string) => {\n if (url === \"draco_wasm_wrapper.js\") {\n return \"data:text/javascript;base64,\" + DRACO_WASM_WRAPPER;\n } else if (url === \"draco_decoder.wasm\") {\n return \"data:application/wasm;base64,\" + DRACO_DECODER_WASM;\n }\n return url;\n },\n itemStart: () => {\n // no-op\n },\n itemEnd: () => {\n // no-op\n },\n itemError: () => {\n // no-op\n },\n }).preload();\n return ModelLoader.dracoLoader;\n }\n\n constructor(\n private manager?: LoadingManager,\n private options: { requestHeader?: Record; withCredentials?: boolean } = {},\n ) {\n this.gltfLoader = new GLTFLoader(this.manager)\n .setMeshoptDecoder(MeshoptDecoder)\n .setDRACOLoader(ModelLoader.getDracoLoader());\n\n this.fbxLoader = new FBXLoader(this.manager);\n }\n\n public async load(url: string, onProgress?: (loaded: number, total: number) => void) {\n return new Promise((resolve, reject) => {\n const resourcePath = ModelLoader.extractUrlBase(url);\n\n this.manager?.itemStart(url);\n\n const _onError = (e: Error) => {\n reject(e);\n\n this.manager?.itemError(url);\n this.manager?.itemEnd(url);\n };\n\n const loader = new FileLoader(this.manager);\n loader.setResponseType(\"arraybuffer\");\n if (this.options.requestHeader) {\n loader.setRequestHeader(this.options.requestHeader);\n }\n if (this.options.withCredentials !== undefined) {\n loader.setWithCredentials(this.options.withCredentials);\n }\n\n loader.load(\n url,\n async (data: ArrayBuffer) => {\n try {\n const loadResult = await this.loadFromBuffer(data, resourcePath);\n this.manager?.itemEnd(url);\n resolve(loadResult);\n } catch (e) {\n _onError(e);\n }\n },\n (progressEvent) => {\n if (onProgress && progressEvent.lengthComputable) {\n onProgress(progressEvent.loaded, progressEvent.total);\n }\n },\n _onError,\n );\n });\n }\n\n private static extractUrlBase(url: string): string {\n const index = url.lastIndexOf(\"/\");\n\n if (index === -1) {\n return \"./\";\n }\n\n return url.slice(0, index + 1);\n }\n\n public async loadFromBuffer(buffer: ArrayBuffer, pathName: string): Promise {\n // fbx binary\n if (IsFBXBinary(buffer)) {\n const group = this.fbxLoader.parse(buffer, pathName);\n return { group, animations: [] };\n }\n\n // gltf/glb binary\n if (IsGLB(buffer)) {\n const gltf = await this.gltfLoader.parseAsync(buffer, pathName);\n return { group: gltf.scene, animations: gltf.animations };\n }\n\n const text = convertArrayBufferToString(buffer);\n // fbx text\n if (isFbxFormatASCII(text)) {\n const group = this.fbxLoader.parse(text, pathName);\n return { group, animations: [] };\n }\n\n // gltf text\n const gltf = await this.gltfLoader.parseAsync(text, pathName);\n return { group: gltf.scene, animations: gltf.animations };\n }\n}\n", "import { Audio, MAudioProps } from \"@mml-io/mml-web\";\nimport { AudioGraphics } from \"@mml-io/mml-web\";\nimport { LoadingInstanceManager } from \"@mml-io/mml-web\";\nimport * as THREE from \"three\";\nimport { PositionalAudioHelper } from \"three/addons/helpers/PositionalAudioHelper.js\";\n\nimport { ThreeJSGraphicsAdapter } from \"../ThreeJSGraphicsAdapter\";\n\nconst debugAudioSphereSize = 0.25;\nconst debugAudioGeometry = new THREE.SphereGeometry(debugAudioSphereSize, 4, 2);\nconst debugAudioMaterial = new THREE.MeshBasicMaterial({\n wireframe: true,\n fog: false,\n toneMapped: false,\n color: 0x00ff00,\n});\nconst audioRefDistance = 1;\nconst audioRolloffFactor = 1;\n\nfunction extendAudioToDuration(\n context: AudioContext,\n buffer: AudioBuffer,\n seconds: number,\n): AudioBuffer {\n const updatedBuffer = context.createBuffer(\n buffer.numberOfChannels,\n Math.ceil(seconds * buffer.sampleRate),\n buffer.sampleRate,\n );\n for (let channelNumber = 0; channelNumber < buffer.numberOfChannels; channelNumber++) {\n const channelData = buffer.getChannelData(channelNumber);\n const updatedChannelData = updatedBuffer.getChannelData(channelNumber);\n updatedChannelData.set(channelData, 0);\n }\n return updatedBuffer;\n}\n\nexport class ThreeJSAudio extends AudioGraphics {\n private audioDebugHelper: THREE.Mesh | null = null;\n private audioDebugConeX: PositionalAudioHelper | null;\n private audioDebugConeY: PositionalAudioHelper | null;\n private audioContextStateChangedListener = () => {\n this.syncAudioTime();\n };\n\n private documentTimeListener: { remove: () => void };\n private delayedPauseTimer: NodeJS.Timeout | null = null;\n private srcLoadingInstanceManager = new LoadingInstanceManager(`${Audio.tagName}.src`);\n\n private positionalAudio: THREE.PositionalAudio;\n\n private loadedAudioState: {\n loadedAudio:\n | {\n mode: \"LOADED\";\n buffer: AudioBuffer;\n currentSource: {\n sourceNode: AudioBufferSourceNode;\n contextStartTime: number;\n } | null;\n paddedBuffer?: {\n buffer: AudioBuffer;\n totalDuration: number;\n };\n }\n | {\n mode: \"LOADING\";\n srcLoadPromise: Promise;\n abortController: AbortController;\n }\n | null;\n currentSrc: string;\n } | null = null;\n\n constructor(private audio: Audio) {\n super(audio);\n\n this.documentTimeListener = this.audio.addDocumentTimeListener(() => {\n if (this.loadedAudioState) {\n this.syncAudioTime();\n }\n });\n\n const audioListener = this.getAudioListener();\n this.positionalAudio = new THREE.PositionalAudio(audioListener);\n this.positionalAudio.context.addEventListener(\n \"statechange\",\n this.audioContextStateChangedListener,\n );\n this.positionalAudio.setVolume(this.audio.props.volume);\n this.positionalAudio.setDirectionalCone(\n this.audio.props.coneFalloffAngle ?? 360,\n this.audio.props.coneAngle,\n 0,\n );\n this.positionalAudio.setRefDistance(audioRefDistance);\n this.positionalAudio.setRolloffFactor(audioRolloffFactor);\n this.audio.getContainer().add(this.positionalAudio);\n\n this.updateAudio();\n this.updateDebugVisualisation();\n }\n\n disable(): void {}\n\n enable(): void {}\n\n public syncAudioTime() {\n const audioContext = this.positionalAudio.context;\n if (audioContext.state !== \"running\") {\n return;\n }\n\n if (this.delayedPauseTimer !== null) {\n clearTimeout(this.delayedPauseTimer);\n this.delayedPauseTimer = null;\n }\n\n if (\n !this.loadedAudioState ||\n !this.loadedAudioState.loadedAudio ||\n this.loadedAudioState.loadedAudio.mode !== \"LOADED\"\n ) {\n return;\n }\n\n const loadedAudio = this.loadedAudioState.loadedAudio;\n const audioBuffer = loadedAudio.buffer;\n let currentSource = loadedAudio.currentSource;\n\n if (!this.audio.props.enabled || this.audio.isDisabled()) {\n if (currentSource) {\n currentSource.sourceNode.stop();\n loadedAudio.currentSource = null;\n }\n return;\n }\n\n const documentTime = this.audio.getDocumentTime();\n if (this.audio.props.pauseTime !== null) {\n const timeUntilPause = this.audio.props.pauseTime - documentTime;\n if (timeUntilPause < 2) {\n // The audio should be paused because the pauseTime is in the past or very close\n if (currentSource) {\n currentSource.sourceNode.stop();\n loadedAudio.currentSource = null;\n }\n return;\n } else {\n // The pause time is in the future\n const delayedPauseTimer = setTimeout(() => {\n if (this.delayedPauseTimer === delayedPauseTimer) {\n this.delayedPauseTimer = null;\n }\n this.syncAudioTime();\n }, timeUntilPause);\n this.delayedPauseTimer = delayedPauseTimer;\n }\n }\n\n const currentTime = (documentTime - this.audio.props.startTime) / 1000;\n const audioDuration = audioBuffer.duration;\n\n let loopDurationSeconds: number | null = null;\n if (this.audio.props.loopDuration !== null && this.audio.props.loopDuration > 0) {\n loopDurationSeconds = this.audio.props.loopDuration / 1000;\n }\n\n let desiredAudioTime: number;\n if (this.audio.props.loop) {\n if (currentTime < 0) {\n desiredAudioTime = currentTime;\n } else {\n if (loopDurationSeconds === null) {\n desiredAudioTime = currentTime % audioDuration;\n } else {\n desiredAudioTime = currentTime % loopDurationSeconds;\n }\n }\n } else {\n desiredAudioTime = currentTime;\n if (desiredAudioTime > audioDuration) {\n // The audio should stop because it has reached the end\n if (currentSource) {\n currentSource.sourceNode.stop();\n loadedAudio.currentSource = null;\n }\n return;\n }\n }\n\n const loopDurationLongerThanAudioDuration =\n loopDurationSeconds && loopDurationSeconds > audioDuration;\n const playbackLength = loopDurationSeconds ? loopDurationSeconds : audioDuration;\n\n if (currentSource) {\n if (currentSource.sourceNode.loop !== this.audio.props.loop) {\n // The loop setting has changed - remove the existing audio source and a new one will be created\n currentSource.sourceNode.stop();\n loadedAudio.currentSource = null;\n currentSource = null;\n } else if (\n loopDurationSeconds !== null &&\n loopDurationLongerThanAudioDuration &&\n (!loadedAudio.paddedBuffer || loadedAudio.paddedBuffer.totalDuration < loopDurationSeconds)\n ) {\n /*\n The loop duration is set, and it is longer than the audio file, and\n either there is no existing padding, or the existing padding is too\n short. Dispose of the existing audio source and create a new one.\n */\n currentSource.sourceNode.stop();\n loadedAudio.currentSource = null;\n currentSource = null;\n } else if (\n loopDurationSeconds === null &&\n currentSource.sourceNode.loopEnd !== audioBuffer.duration\n ) {\n // The loop duration has been removed - reset the loop end to the audio duration\n currentSource.sourceNode.stop();\n loadedAudio.currentSource = null;\n currentSource = null;\n } else {\n if (this.audio.props.startTime > documentTime) {\n currentSource.sourceNode.stop();\n loadedAudio.currentSource = null;\n currentSource = null;\n } else {\n const unloopedCurrentAudioPoint =\n (audioContext.currentTime - currentSource.contextStartTime) /\n currentSource.sourceNode.playbackRate.value;\n\n if (unloopedCurrentAudioPoint < 0) {\n // Audio should not be playing yet, so stop it and it will be rescheduled\n currentSource.sourceNode.stop();\n loadedAudio.currentSource = null;\n currentSource = null;\n } else {\n if (\n loopDurationSeconds !== null &&\n currentSource.sourceNode.loopEnd !== loopDurationSeconds\n ) {\n currentSource.sourceNode.loopEnd = loopDurationSeconds;\n }\n\n const currentAudioPoint = unloopedCurrentAudioPoint % playbackLength;\n\n let delta = desiredAudioTime - currentAudioPoint;\n if (this.audio.props.loop) {\n // Check if the delta wrapping around is smaller (i.e. the desired and current are closer together if we wrap around)\n const loopedDelta = delta - playbackLength;\n if (Math.abs(delta) > Math.abs(loopedDelta)) {\n delta = loopedDelta;\n }\n }\n\n if (Math.abs(delta) > 0.5) {\n // We need to skip to the correct point as playback has drifted too far. Remove the audio source and a new one will be created\n currentSource.sourceNode.stop();\n loadedAudio.currentSource = null;\n currentSource = null;\n } else {\n if (Math.abs(delta) < 0.1) {\n // Do nothing - this is close enough - set the playback rate to 1\n currentSource.sourceNode.playbackRate.value = 1;\n } else {\n if (delta > 0) {\n currentSource.sourceNode.playbackRate.value = 1.01;\n } else {\n currentSource.sourceNode.playbackRate.value = 0.99;\n }\n }\n // Calculate a start time that produces the current time as calculated time the next time it is checked\n currentSource.contextStartTime =\n audioContext.currentTime -\n currentAudioPoint / currentSource.sourceNode.playbackRate.value;\n }\n }\n }\n }\n }\n\n if (!currentSource) {\n // There is no current source (or it was removed) - create a new one\n const currentSourceNode = this.positionalAudio.context.createBufferSource();\n\n let buffer = audioBuffer;\n if (loopDurationSeconds && loopDurationLongerThanAudioDuration) {\n // The loop duration requires longer audio than the original audio - pad it with silence\n if (\n loadedAudio.paddedBuffer &&\n loadedAudio.paddedBuffer.totalDuration === loopDurationSeconds\n ) {\n // The padding is already the correct length\n buffer = loadedAudio.paddedBuffer.buffer;\n } else {\n const paddedBuffer = extendAudioToDuration(\n this.positionalAudio.context,\n audioBuffer,\n loopDurationSeconds,\n );\n loadedAudio.paddedBuffer = {\n buffer: paddedBuffer,\n totalDuration: loopDurationSeconds,\n };\n buffer = paddedBuffer;\n }\n }\n\n currentSourceNode.buffer = buffer;\n currentSourceNode.loop = this.audio.props.loop;\n currentSourceNode.loopStart = 0;\n if (loopDurationSeconds) {\n currentSourceNode.loopEnd = loopDurationSeconds;\n } else {\n currentSourceNode.loopEnd = audioBuffer.duration;\n }\n let contextStartTime;\n if (desiredAudioTime < 0) {\n // The audio should not have started yet - schedule it to start in the future\n const timeFromNowToStart = -desiredAudioTime;\n contextStartTime = audioContext.currentTime + timeFromNowToStart;\n currentSourceNode.start(contextStartTime);\n } else {\n /*\n The audio should have been playing already. Start playing from an\n offset into the file and set the contextStartTime to when it should\n have started\n */\n contextStartTime = audioContext.currentTime - desiredAudioTime;\n currentSourceNode.start(0, desiredAudioTime);\n }\n loadedAudio.currentSource = {\n sourceNode: currentSourceNode,\n contextStartTime,\n };\n this.positionalAudio.setNodeSource(currentSourceNode);\n }\n }\n\n private clearAudio() {\n if (this.loadedAudioState) {\n if (this.loadedAudioState.loadedAudio) {\n if (this.loadedAudioState.loadedAudio.mode === \"LOADING\") {\n this.loadedAudioState.loadedAudio.abortController.abort();\n } else {\n if (this.loadedAudioState.loadedAudio.currentSource?.sourceNode) {\n this.loadedAudioState.loadedAudio.currentSource.sourceNode.stop();\n }\n }\n }\n this.loadedAudioState = null;\n }\n }\n\n private updateAudio() {\n if (!this.audio.isConnected) {\n return;\n }\n\n const audioListener = this.getAudioListener();\n const audioContext = audioListener.context;\n\n if (!this.audio.props.src) {\n this.clearAudio();\n } else {\n const contentAddress = this.audio.contentSrcToContentAddress(this.audio.props.src);\n if (this.loadedAudioState && this.loadedAudioState.currentSrc === contentAddress) {\n // Already loaded this audio src\n } else {\n this.clearAudio();\n\n const abortController = new AbortController();\n\n this.srcLoadingInstanceManager.start(\n this.audio.getLoadingProgressManager(),\n contentAddress,\n );\n const srcLoadPromise = this.asyncLoadSourceAsset(\n contentAddress,\n abortController,\n audioContext,\n (loaded, total) => {\n this.srcLoadingInstanceManager.setProgress(loaded / total);\n },\n );\n this.loadedAudioState = {\n loadedAudio: {\n mode: \"LOADING\",\n abortController,\n srcLoadPromise,\n },\n currentSrc: contentAddress,\n };\n srcLoadPromise\n .then((buffer) => {\n if (\n this.loadedAudioState &&\n this.loadedAudioState.loadedAudio?.mode === \"LOADING\" &&\n this.loadedAudioState.loadedAudio.srcLoadPromise === srcLoadPromise\n ) {\n this.loadedAudioState.loadedAudio = {\n mode: \"LOADED\",\n buffer,\n currentSource: null,\n };\n this.srcLoadingInstanceManager.finish();\n this.syncAudioTime();\n }\n })\n .catch((e) => {\n if (\n this.loadedAudioState &&\n this.loadedAudioState.loadedAudio?.mode === \"LOADING\" &&\n this.loadedAudioState.loadedAudio.srcLoadPromise === srcLoadPromise\n ) {\n console.error(\"Failed to load audio\", e);\n this.srcLoadingInstanceManager.error(e);\n this.clearAudio();\n }\n });\n }\n }\n\n this.syncAudioTime();\n }\n\n async asyncLoadSourceAsset(\n contentAddress: string,\n abortController: AbortController,\n audioContext: AudioContext,\n // TODO - implement progress\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n onProgress: (loaded: number, total: number) => void,\n ): Promise {\n return new Promise((resolve, reject) => {\n (async () => {\n if (contentAddress.startsWith(\"data:\")) {\n // Construct an AudioBuffer from the data URL\n const base64 = contentAddress.split(\",\", 2)[1];\n if (!base64) {\n reject(new Error(\"Invalid data URL\"));\n return;\n }\n let arrayBuffer;\n\n try {\n const binary = atob(base64);\n const uint8Array = new Uint8Array(binary.length);\n for (let i = 0; i < binary.length; i++) {\n uint8Array[i] = binary.charCodeAt(i);\n }\n arrayBuffer = uint8Array.buffer;\n } catch (e) {\n console.error(\"Failed to decode base64 data URL\", e);\n return;\n }\n audioContext\n .decodeAudioData(arrayBuffer)\n .then((audioBuffer) => {\n if (abortController.signal.aborted) {\n return;\n }\n resolve(audioBuffer);\n })\n .catch((e) => {\n console.error(\"Failed to decode data URI audio data\", e);\n });\n return;\n }\n\n const response = await fetch(contentAddress, {\n signal: abortController.signal,\n });\n\n if (response.ok) {\n response\n .arrayBuffer()\n .then((buffer) => {\n if (abortController.signal.aborted) {\n return;\n }\n audioContext.decodeAudioData(buffer).then((audioBuffer) => {\n if (abortController.signal.aborted) {\n return;\n }\n resolve(audioBuffer);\n });\n })\n .catch((e) => {\n console.error(\"Failed to decode fetched audio data\", e);\n });\n } else {\n console.error(\"Failed to fetch audio data\", response);\n }\n })();\n });\n }\n\n setSrc(): void {\n this.updateAudio();\n }\n setStartTime(): void {\n if (this.loadedAudioState) {\n this.syncAudioTime();\n }\n }\n setPauseTime(): void {\n if (this.loadedAudioState) {\n this.syncAudioTime();\n }\n }\n setLoopDuration(): void {\n if (this.loadedAudioState) {\n this.syncAudioTime();\n }\n }\n setLoop(): void {\n this.updateAudio();\n }\n setEnabled(): void {\n this.updateAudio();\n }\n setVolume(volume: number): void {\n this.positionalAudio.setVolume(volume);\n }\n setConeAngle(coneAngle: number | null, mAudioProps: MAudioProps): void {\n this.positionalAudio.setDirectionalCone(\n mAudioProps.coneAngle,\n mAudioProps.coneFalloffAngle ?? 360,\n 0,\n );\n this.updateDebugVisualisation();\n }\n setConeFalloffAngle(coneFalloffAngle: number | null, mAudioProps: MAudioProps): void {\n this.positionalAudio.setDirectionalCone(\n mAudioProps.coneAngle,\n mAudioProps.coneFalloffAngle ?? 360,\n 0,\n );\n this.updateDebugVisualisation();\n }\n\n setDebug(): void {\n this.updateDebugVisualisation();\n }\n\n dispose() {\n if (this.positionalAudio) {\n this.positionalAudio.context.removeEventListener(\n \"statechange\",\n this.audioContextStateChangedListener,\n );\n this.positionalAudio.disconnect();\n this.positionalAudio.removeFromParent();\n }\n\n this.clearAudio();\n\n if (this.delayedPauseTimer) {\n clearTimeout(this.delayedPauseTimer);\n this.delayedPauseTimer = null;\n }\n this.documentTimeListener.remove();\n this.clearDebugVisualisation();\n this.srcLoadingInstanceManager.dispose();\n }\n\n private clearDebugVisualisation() {\n if (this.audioDebugHelper) {\n this.audioDebugHelper.removeFromParent();\n this.audioDebugHelper = null;\n }\n if (this.audioDebugConeX) {\n this.audioDebugConeX.removeFromParent();\n this.audioDebugConeX = null;\n this.audioDebugConeY?.removeFromParent();\n this.audioDebugConeY = null;\n }\n }\n\n private updateDebugVisualisation() {\n if (!this.audio.props.debug) {\n this.clearDebugVisualisation();\n } else {\n if (!this.audioDebugHelper) {\n this.audioDebugHelper = new THREE.Mesh(debugAudioGeometry, debugAudioMaterial);\n this.audio.getContainer().add(this.audioDebugHelper);\n }\n if (!this.audioDebugConeX && this.audio.props.coneAngle) {\n this.audioDebugConeX = new PositionalAudioHelper(this.positionalAudio, 10);\n this.positionalAudio.add(this.audioDebugConeX);\n this.audioDebugConeY = new PositionalAudioHelper(this.positionalAudio, 10);\n this.audioDebugConeY.rotation.z = Math.PI / 2;\n this.positionalAudio.add(this.audioDebugConeY);\n }\n if (!this.audio.props.coneAngle && this.audioDebugConeX) {\n this.audioDebugConeX.removeFromParent();\n this.audioDebugConeX = null;\n this.audioDebugConeY?.removeFromParent();\n this.audioDebugConeY = null;\n }\n }\n this.audioDebugConeX?.update();\n this.audioDebugConeY?.update();\n }\n\n private getAudioListener() {\n return this.audio.getScene().getGraphicsAdapter().getAudioListener();\n }\n}\n", "import { ChatProbe } from \"@mml-io/mml-web\";\nimport { ChatProbeGraphics } from \"@mml-io/mml-web\";\nimport * as THREE from \"three\";\n\nimport { ThreeJSGraphicsAdapter } from \"../ThreeJSGraphicsAdapter\";\n\nexport class ThreeJSChatProbe extends ChatProbeGraphics {\n private static DebugGeometry = new THREE.SphereGeometry(1, 16, 16, 1);\n private static DebugMaterial = new THREE.MeshBasicMaterial({\n color: 0xffff00,\n wireframe: true,\n transparent: true,\n opacity: 0.3,\n });\n\n private debugMesh: THREE.Mesh | null = null;\n\n constructor(private chatProbe: ChatProbe) {\n super(chatProbe);\n }\n\n disable(): void {}\n\n enable(): void {}\n\n setRange(): void {\n this.updateDebugVisualisation();\n }\n\n setDebug() {\n this.updateDebugVisualisation();\n }\n\n private clearDebugVisualisation() {\n if (this.debugMesh) {\n this.debugMesh.removeFromParent();\n this.debugMesh = null;\n }\n }\n\n private updateDebugVisualisation() {\n if (!this.chatProbe.props.debug) {\n this.clearDebugVisualisation();\n } else {\n if (this.chatProbe.isConnected && !this.debugMesh) {\n const mesh = new THREE.Mesh(ThreeJSChatProbe.DebugGeometry, ThreeJSChatProbe.DebugMaterial);\n mesh.castShadow = false;\n mesh.receiveShadow = false;\n this.debugMesh = mesh;\n this.chatProbe.getContainer().add(this.debugMesh);\n }\n\n if (this.debugMesh) {\n this.debugMesh.scale.set(\n this.chatProbe.props.range,\n this.chatProbe.props.range,\n this.chatProbe.props.range,\n );\n }\n }\n }\n\n dispose() {\n this.clearDebugVisualisation();\n }\n}\n", "import { Cube } from \"@mml-io/mml-web\";\nimport { CubeGraphics } from \"@mml-io/mml-web\";\nimport { MMLColor } from \"@mml-io/mml-web\";\nimport * as THREE from \"three\";\n\nimport { ThreeJSGraphicsAdapter } from \"../ThreeJSGraphicsAdapter\";\n\nexport class ThreeJSCube extends CubeGraphics {\n static boxGeometry = new THREE.BoxGeometry(1, 1, 1);\n private mesh: THREE.Mesh>;\n private material: THREE.MeshStandardMaterial;\n constructor(private cube: Cube) {\n super(cube);\n\n this.material = new THREE.MeshStandardMaterial({\n color: new THREE.Color(cube.props.color.r, cube.props.color.g, cube.props.color.b),\n });\n this.mesh = new THREE.Mesh(ThreeJSCube.boxGeometry, this.material);\n this.mesh.castShadow = cube.props.castShadows;\n this.mesh.receiveShadow = true;\n this.cube.getContainer().add(this.mesh);\n }\n\n disable(): void {}\n\n enable(): void {}\n\n getCollisionElement(): THREE.Object3D {\n return this.mesh;\n }\n\n setColor(color: MMLColor): void {\n this.material.color = new THREE.Color(color.r, color.g, color.b);\n }\n\n setWidth(width: number): void {\n this.mesh.scale.x = width;\n }\n\n setHeight(height: number): void {\n this.mesh.scale.y = height;\n }\n\n setDepth(depth: number): void {\n this.mesh.scale.z = depth;\n }\n\n setCastShadows(castShadows: boolean): void {\n this.mesh.castShadow = castShadows;\n }\n\n setOpacity(opacity: number): void {\n const needsUpdate = this.material.transparent === (opacity === 1);\n this.material.transparent = opacity !== 1;\n this.material.needsUpdate = needsUpdate;\n this.material.opacity = opacity;\n }\n\n dispose() {}\n}\n", "import { Cylinder, CylinderGraphics, MMLColor } from \"@mml-io/mml-web\";\nimport * as THREE from \"three\";\n\nimport { ThreeJSGraphicsAdapter } from \"../ThreeJSGraphicsAdapter\";\n\nexport class ThreeJSCylinder extends CylinderGraphics {\n static cylinderGeometry = new THREE.CylinderGeometry(0.5, 0.5, 1);\n private mesh: THREE.Mesh>;\n private material: THREE.MeshStandardMaterial;\n\n constructor(private cylinder: Cylinder) {\n super(cylinder);\n\n this.material = new THREE.MeshStandardMaterial({\n color: new THREE.Color(\n cylinder.props.color.r,\n cylinder.props.color.g,\n cylinder.props.color.b,\n ),\n });\n this.mesh = new THREE.Mesh(ThreeJSCylinder.cylinderGeometry, this.material);\n this.mesh.castShadow = cylinder.props.castShadows;\n this.mesh.receiveShadow = true;\n this.cylinder.getContainer().add(this.mesh);\n }\n\n disable(): void {}\n\n enable(): void {}\n\n getCollisionElement(): THREE.Object3D {\n return this.mesh;\n }\n\n setColor(color: MMLColor): void {\n this.material.color = new THREE.Color(color.r, color.g, color.b);\n }\n\n setRadius(radius: number): void {\n this.mesh.scale.x = radius * 2;\n this.mesh.scale.z = radius * 2;\n }\n\n setHeight(height: number): void {\n this.mesh.scale.y = height;\n }\n\n setCastShadows(castShadows: boolean): void {\n this.mesh.castShadow = castShadows;\n }\n\n setOpacity(opacity: number): void {\n const needsUpdate = this.material.transparent === (opacity === 1);\n this.material.transparent = opacity !== 1;\n this.material.needsUpdate = needsUpdate;\n this.material.opacity = opacity;\n }\n\n dispose() {}\n}\n", "import { DebugHelper, DebugHelperGraphics } from \"@mml-io/mml-web\";\nimport * as THREE from \"three\";\n\nimport { ThreeJSGraphicsAdapter } from \"../ThreeJSGraphicsAdapter\";\n\nexport class ThreeJSDebugHelper extends DebugHelperGraphics {\n private debugAxes: THREE.AxesHelper | null = null;\n\n constructor(private debugHelper: DebugHelper) {\n super(debugHelper);\n this.debugAxes = new THREE.AxesHelper(1);\n this.debugHelper.getContainer().add(this.debugAxes);\n }\n\n dispose() {\n if (this.debugAxes) {\n this.debugHelper.getContainer().remove(this.debugAxes);\n }\n this.debugAxes = null;\n }\n}\n", "import { Frame } from \"@mml-io/mml-web\";\nimport { FrameGraphics } from \"@mml-io/mml-web\";\nimport * as THREE from \"three\";\n\nimport { ThreeJSGraphicsAdapter } from \"../ThreeJSGraphicsAdapter\";\n\nfunction setMeshToBoundingBox(\n mesh: THREE.Mesh,\n minX: number,\n maxX: number,\n minY: number,\n maxY: number,\n minZ: number,\n maxZ: number,\n) {\n mesh.scale.set(maxX - minX, maxY - minY, maxZ - minZ);\n mesh.position.set((maxX + minX) / 2, (maxY + minY) / 2, (maxZ + minZ) / 2);\n}\n\nexport class ThreeJSFrame extends FrameGraphics {\n private static DebugBoxGeometry = new THREE.BoxGeometry(1, 1, 1, 1, 1, 1);\n private static DebugConstraintMaterial = new THREE.MeshBasicMaterial({\n color: 0xff0000,\n wireframe: true,\n transparent: true,\n opacity: 0.3,\n });\n private static DebugLoadRangeMaterial = new THREE.MeshBasicMaterial({\n color: 0x00ff00,\n wireframe: true,\n transparent: true,\n opacity: 0.3,\n });\n private static DebugUnloadRangeMaterial = new THREE.MeshBasicMaterial({\n color: 0x0000ff,\n wireframe: true,\n transparent: true,\n opacity: 0.3,\n });\n\n private debugMeshes: {\n debugBoxConstraintMesh: THREE.Mesh;\n debugBoxLoadRangeMesh: THREE.Mesh;\n debugBoxUnloadRangeMesh: THREE.Mesh;\n } | null = null;\n\n constructor(private frame: Frame) {\n super(frame);\n }\n\n setSrc() {\n // no-op\n }\n\n setDebug(): void {\n this.updateDebugVisualisation();\n }\n setLoadRange(): void {\n this.updateDebugVisualisation();\n }\n setUnloadRange(): void {\n this.updateDebugVisualisation();\n }\n setMinX(): void {\n this.updateDebugVisualisation();\n }\n setMaxX(): void {\n this.updateDebugVisualisation();\n }\n setMinY(): void {\n this.updateDebugVisualisation();\n }\n setMaxY(): void {\n this.updateDebugVisualisation();\n }\n setMinZ(): void {\n this.updateDebugVisualisation();\n }\n setMaxZ(): void {\n this.updateDebugVisualisation();\n }\n\n disable(): void {}\n\n enable(): void {}\n\n dispose() {}\n\n private clearDebugVisualisation() {\n if (this.debugMeshes) {\n this.debugMeshes.debugBoxConstraintMesh.removeFromParent();\n this.debugMeshes.debugBoxLoadRangeMesh.removeFromParent();\n this.debugMeshes.debugBoxUnloadRangeMesh.removeFromParent();\n this.debugMeshes = null;\n }\n }\n\n private updateDebugVisualisation() {\n if (!this.frame.props.debug) {\n this.clearDebugVisualisation();\n } else {\n if (!this.frame.isConnected) {\n return;\n }\n if (!this.debugMeshes) {\n this.debugMeshes = {\n debugBoxConstraintMesh: new THREE.Mesh(\n ThreeJSFrame.DebugBoxGeometry,\n ThreeJSFrame.DebugConstraintMaterial,\n ),\n debugBoxLoadRangeMesh: new THREE.Mesh(\n ThreeJSFrame.DebugBoxGeometry,\n ThreeJSFrame.DebugLoadRangeMaterial,\n ),\n debugBoxUnloadRangeMesh: new THREE.Mesh(\n ThreeJSFrame.DebugBoxGeometry,\n ThreeJSFrame.DebugUnloadRangeMaterial,\n ),\n };\n this.frame.getContainer().add(this.debugMeshes.debugBoxConstraintMesh);\n this.frame.getContainer().add(this.debugMeshes.debugBoxLoadRangeMesh);\n this.frame.getContainer().add(this.debugMeshes.debugBoxUnloadRangeMesh);\n }\n\n let boxBounds = this.frame.getDefinedBoxBounds();\n if (!boxBounds) {\n boxBounds = [0, 0, 0, 0, 0, 0];\n }\n\n const [minX, maxX, minY, maxY, minZ, maxZ] = boxBounds;\n this.debugMeshes.debugBoxConstraintMesh.visible = true;\n this.debugMeshes.debugBoxLoadRangeMesh.visible = true;\n this.debugMeshes.debugBoxUnloadRangeMesh.visible = true;\n\n setMeshToBoundingBox(\n this.debugMeshes.debugBoxConstraintMesh,\n minX,\n maxX,\n minY,\n maxY,\n minZ,\n maxZ,\n );\n\n if (this.frame.props.loadRange === null) {\n this.debugMeshes.debugBoxLoadRangeMesh.visible = false;\n this.debugMeshes.debugBoxUnloadRangeMesh.visible = false;\n } else {\n this.debugMeshes.debugBoxLoadRangeMesh.visible = true;\n this.debugMeshes.debugBoxUnloadRangeMesh.visible = true;\n\n setMeshToBoundingBox(\n this.debugMeshes.debugBoxLoadRangeMesh,\n minX - this.frame.props.loadRange,\n maxX + this.frame.props.loadRange,\n minY - this.frame.props.loadRange,\n maxY + this.frame.props.loadRange,\n minZ - this.frame.props.loadRange,\n maxZ + this.frame.props.loadRange,\n );\n\n setMeshToBoundingBox(\n this.debugMeshes.debugBoxUnloadRangeMesh,\n minX - this.frame.props.loadRange - this.frame.props.unloadRange,\n maxX + this.frame.props.loadRange + this.frame.props.unloadRange,\n minY - this.frame.props.loadRange - this.frame.props.unloadRange,\n maxY + this.frame.props.loadRange + this.frame.props.unloadRange,\n minZ - this.frame.props.loadRange - this.frame.props.unloadRange,\n maxZ + this.frame.props.loadRange + this.frame.props.unloadRange,\n );\n }\n }\n }\n}\n", "import {\n calculateContentSize,\n Image,\n ImageGraphics,\n LoadingInstanceManager,\n} from \"@mml-io/mml-web\";\nimport * as THREE from \"three\";\n\nimport { ThreeJSGraphicsAdapter } from \"../ThreeJSGraphicsAdapter\";\n\nexport class ThreeJSImage extends ImageGraphics {\n private static planeGeometry = new THREE.PlaneGeometry(1, 1);\n private mesh: THREE.Mesh>;\n private material: THREE.MeshStandardMaterial;\n private static imageLoader = new THREE.ImageLoader();\n\n private srcApplyPromise: Promise | null = null;\n private loadedImage: HTMLImageElement | null;\n private loadedImageHasTransparency = false;\n private srcLoadingInstanceManager = new LoadingInstanceManager(`${Image.tagName}.src`);\n constructor(\n private image: Image,\n private updateMeshCallback: () => void,\n ) {\n super(image, updateMeshCallback);\n\n this.material = new THREE.MeshStandardMaterial({\n color: 0xffffff,\n transparent: this.image.props.opacity !== 1 || this.loadedImageHasTransparency,\n opacity: this.image.props.opacity,\n side: THREE.DoubleSide,\n });\n this.mesh = new THREE.Mesh(ThreeJSImage.planeGeometry, this.material);\n this.mesh.castShadow = image.props.castShadows;\n this.mesh.receiveShadow = true;\n this.image.getContainer().add(this.mesh);\n }\n\n public getWidthAndHeight(): { width: number; height: number } {\n return {\n width: this.mesh.scale.x,\n height: this.mesh.scale.y,\n };\n }\n\n disable(): void {}\n\n enable(): void {}\n\n getCollisionElement(): THREE.Object3D {\n return this.mesh;\n }\n\n setWidth(): void {\n this.updateWidthAndHeight();\n }\n\n setHeight(): void {\n this.updateWidthAndHeight();\n }\n\n setCastShadows(castShadows: boolean): void {\n this.mesh.castShadow = castShadows;\n }\n\n setOpacity(opacity: number): void {\n const needsUpdate = this.material.transparent === (opacity === 1);\n this.material.transparent = opacity !== 1;\n this.material.needsUpdate = needsUpdate;\n this.material.opacity = opacity;\n }\n\n setEmissive() {\n this.updateMaterialEmissiveIntensity();\n }\n\n private updateMaterialEmissiveIntensity() {\n if (this.material) {\n const map = this.material.map as THREE.Texture;\n if (this.image.props.emissive > 0) {\n this.material.emissive = new THREE.Color(0xffffff);\n this.material.emissiveMap = map;\n this.material.emissiveIntensity = this.image.props.emissive;\n this.material.needsUpdate = true;\n } else {\n this.material.emissive = new THREE.Color(0x000000);\n this.material.emissiveMap = null;\n this.material.emissiveIntensity = 1;\n this.material.needsUpdate = true;\n }\n }\n }\n\n setSrc(newValue: string | null): void {\n const src = (newValue || \"\").trim();\n const isDataUri = src.startsWith(\"data:image/\");\n if (this.loadedImage !== null && !isDataUri) {\n // if the image has already been loaded, remove the image data from the THREE material\n this.clearImage();\n }\n if (!src) {\n // if the src attribute is empty, reset the dimensions and return\n this.updateWidthAndHeight();\n this.srcLoadingInstanceManager.abortIfLoading();\n return;\n }\n if (!this.material) {\n // if the element is not yet connected, return\n return;\n }\n\n if (isDataUri) {\n // if the src is a data url, load it directly rather than using the loader - this avoids a potential frame skip\n const image = document.createElement(\"img\");\n image.src = src;\n this.applyImage(image);\n this.srcLoadingInstanceManager.abortIfLoading();\n return;\n }\n\n const contentSrc = this.image.contentSrcToContentAddress(src);\n const srcApplyPromise = loadImageAsPromise(\n ThreeJSImage.imageLoader,\n contentSrc,\n (loaded, total) => {\n this.srcLoadingInstanceManager.setProgress(loaded / total);\n },\n );\n this.srcLoadingInstanceManager.start(this.image.getLoadingProgressManager(), contentSrc);\n this.srcApplyPromise = srcApplyPromise;\n srcApplyPromise\n .then((image: HTMLImageElement) => {\n if (this.srcApplyPromise !== srcApplyPromise || !this.material) {\n // If we've loaded a different image since, or we're no longer connected, ignore this image\n return;\n }\n this.applyImage(image);\n this.srcLoadingInstanceManager.finish();\n })\n .catch((error) => {\n console.error(\"Error loading image:\", newValue, error);\n if (this.srcApplyPromise !== srcApplyPromise || !this.material) {\n // If we've loaded a different image since, or we're no longer connected, ignore this image\n return;\n }\n this.clearImage();\n this.srcLoadingInstanceManager.error(error);\n });\n }\n\n private updateWidthAndHeight() {\n const mesh = this.mesh;\n\n const { width, height } = calculateContentSize({\n content: this.loadedImage\n ? { width: this.loadedImage.width, height: this.loadedImage.height }\n : undefined,\n width: this.image.props.width,\n height: this.image.props.height,\n });\n mesh.scale.x = width;\n mesh.scale.y = height;\n\n this.updateMeshCallback();\n }\n\n private applyImage(image: HTMLImageElement) {\n this.loadedImage = image;\n if (!image.complete) {\n // Wait for the image to be fully loaded (most likely a data uri that has not yet been decoded)\n image.addEventListener(\"load\", () => {\n if (this.loadedImage !== image) {\n // if the image has changed since we started loading, ignore this image\n return;\n }\n this.applyImage(image);\n });\n return;\n }\n this.loadedImageHasTransparency = hasTransparency(this.loadedImage);\n if (!this.material) {\n return;\n }\n if (this.loadedImageHasTransparency) {\n this.material.alphaMap = new THREE.CanvasTexture(this.loadedImage);\n this.material.alphaTest = 0.01;\n } else {\n this.material.alphaMap = null;\n this.material.alphaTest = 0;\n }\n this.material.transparent = this.image.props.opacity !== 1 || this.loadedImageHasTransparency;\n this.material.map = new THREE.CanvasTexture(this.loadedImage);\n this.material.needsUpdate = true;\n this.updateMaterialEmissiveIntensity();\n this.updateWidthAndHeight();\n }\n\n private clearImage() {\n this.loadedImage = null;\n this.srcApplyPromise = null;\n if (this.material && this.material.map) {\n this.material.map.dispose();\n this.material.needsUpdate = true;\n this.material.map = null;\n this.material.alphaMap = null;\n this.material.alphaTest = 0;\n }\n this.updateWidthAndHeight();\n }\n\n dispose() {\n if (this.material.map) {\n this.material.map.dispose();\n this.material.map = null;\n }\n if (this.material.emissiveMap) {\n this.material.emissiveMap.dispose();\n this.material.emissiveMap = null;\n }\n this.material.dispose();\n this.loadedImage = null;\n this.srcLoadingInstanceManager.dispose();\n }\n}\n\nexport function loadImageAsPromise(\n imageLoader: THREE.ImageLoader,\n path: string,\n onProgress?: (loaded: number, total: number) => void,\n): Promise {\n return new Promise((resolve, reject) => {\n imageLoader.load(\n path,\n (image: HTMLImageElement) => {\n resolve(image);\n },\n (xhr: ProgressEvent) => {\n if (onProgress) {\n onProgress(xhr.loaded, xhr.total);\n }\n },\n (error: ErrorEvent) => {\n reject(error);\n },\n );\n });\n}\n\nfunction hasTransparency(image: HTMLImageElement) {\n if (image.width === 0 || image.height === 0) {\n return false;\n }\n const canvas = document.createElement(\"canvas\");\n canvas.width = image.width;\n canvas.height = image.height;\n const ctx = canvas.getContext(\"2d\") as CanvasRenderingContext2D;\n ctx.drawImage(image, 0, 0);\n\n const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height).data;\n\n for (let i = 3, n = imageData.length; i < n; i += 4) {\n if (imageData[i] < 255) {\n return true;\n }\n }\n return false;\n}\n", "import { Interaction } from \"@mml-io/mml-web\";\nimport { InteractionGraphics } from \"@mml-io/mml-web\";\nimport * as THREE from \"three\";\n\nimport { ThreeJSGraphicsAdapter } from \"../ThreeJSGraphicsAdapter\";\n\nexport class ThreeJSInteraction extends InteractionGraphics {\n private static DebugGeometry = new THREE.SphereGeometry(1, 16, 16, 1);\n private static DebugMaterial = new THREE.MeshBasicMaterial({\n color: 0x00aa00,\n wireframe: true,\n transparent: true,\n opacity: 0.3,\n });\n\n private debugMesh: THREE.Mesh | null = null;\n\n constructor(private positionProbe: Interaction) {\n super(positionProbe);\n }\n\n disable(): void {}\n\n enable(): void {}\n\n setRange(): void {\n this.updateDebugVisualisation();\n }\n\n setInFocus(): void {\n // no-op\n }\n\n setLineOfSight(): void {\n // no-op\n }\n\n setPriority(): void {\n // no-op\n }\n\n setPrompt(): void {\n // no-op\n }\n\n setDebug() {\n this.updateDebugVisualisation();\n }\n\n private clearDebugVisualisation() {\n if (this.debugMesh) {\n this.debugMesh.removeFromParent();\n this.debugMesh = null;\n }\n }\n\n private updateDebugVisualisation() {\n if (!this.positionProbe.props.debug) {\n this.clearDebugVisualisation();\n } else {\n if (this.positionProbe.isConnected && !this.debugMesh) {\n const mesh = new THREE.Mesh(\n ThreeJSInteraction.DebugGeometry,\n ThreeJSInteraction.DebugMaterial,\n );\n mesh.castShadow = false;\n mesh.receiveShadow = false;\n this.debugMesh = mesh;\n this.positionProbe.getContainer().add(this.debugMesh);\n }\n\n if (this.debugMesh) {\n this.debugMesh.scale.set(\n this.positionProbe.props.range,\n this.positionProbe.props.range,\n this.positionProbe.props.range,\n );\n }\n }\n }\n\n dispose() {\n this.clearDebugVisualisation();\n }\n}\n", "import { CanvasText, Label, LabelGraphics } from \"@mml-io/mml-web\";\nimport * as THREE from \"three\";\n\nimport { ThreeJSGraphicsAdapter } from \"../ThreeJSGraphicsAdapter\";\n\nexport class ThreeJSLabel extends LabelGraphics {\n static labelGeometry = new THREE.PlaneGeometry(1, 1);\n private mesh: THREE.Mesh>;\n private material: THREE.MeshStandardMaterial | null = null;\n private canvasText: CanvasText = new CanvasText();\n\n constructor(private label: Label) {\n super(label);\n\n this.material = new THREE.MeshStandardMaterial({\n transparent: false,\n });\n this.mesh = new THREE.Mesh(ThreeJSLabel.labelGeometry, this.material);\n this.mesh.material = this.material;\n this.mesh.scale.x = this.label.props.width;\n this.mesh.scale.y = this.label.props.height;\n this.mesh.castShadow = this.label.props.castShadows;\n this.mesh.receiveShadow = true;\n this.redrawText();\n this.label.getContainer().add(this.mesh);\n }\n\n disable(): void {}\n\n enable(): void {}\n\n getCollisionElement(): THREE.Object3D {\n return this.mesh;\n }\n\n setContent(): void {\n this.redrawText();\n }\n\n setAlignment(): void {\n this.redrawText();\n }\n\n setFontSize(): void {\n this.redrawText();\n }\n\n setPadding(): void {\n this.redrawText();\n }\n\n setFontColor(): void {\n this.redrawText();\n }\n\n setEmissive(): void {\n this.updateMaterialEmissiveIntensity();\n }\n\n setColor(): void {\n this.redrawText();\n }\n\n setWidth(width: number): void {\n this.mesh.scale.x = width;\n this.redrawText();\n }\n\n setHeight(height: number): void {\n this.mesh.scale.y = height;\n this.redrawText();\n }\n\n setCastShadows(castShadows: boolean): void {\n this.mesh.castShadow = castShadows;\n }\n\n private redrawText() {\n if (!this.material) {\n return;\n }\n if (this.material.map) {\n this.material.map.dispose();\n }\n\n const canvas = this.canvasText.renderText(this.label.props.content, {\n bold: true,\n fontSize: this.label.props.fontSize * 2,\n paddingPx: this.label.props.padding,\n textColorRGB255A1: {\n r: this.label.props.fontColor.r * 255,\n g: this.label.props.fontColor.g * 255,\n b: this.label.props.fontColor.b * 255,\n a: this.label.props.fontColor.a ?? 1,\n },\n backgroundColorRGB255A1: {\n r: this.label.props.color.r * 255,\n g: this.label.props.color.g * 255,\n b: this.label.props.color.b * 255,\n a: this.label.props.color.a ?? 1,\n },\n dimensions: {\n width: this.label.props.width * 200,\n height: this.label.props.height * 200,\n },\n alignment: this.label.props.alignment,\n });\n\n this.material.map = new THREE.CanvasTexture(canvas);\n this.material.transparent = (this.label.props.color.a ?? 1) < 1;\n this.updateMaterialEmissiveIntensity();\n }\n\n private updateMaterialEmissiveIntensity() {\n if (this.material) {\n const map = this.material.map as THREE.Texture;\n if (this.label.props.emissive > 0) {\n this.material.emissive = new THREE.Color(0xffffff);\n this.material.emissiveMap = map;\n this.material.emissiveIntensity = this.label.props.emissive;\n this.material.needsUpdate = true;\n } else {\n this.material.emissive = new THREE.Color(0x000000);\n this.material.emissiveMap = null;\n this.material.emissiveIntensity = 1;\n this.material.needsUpdate = true;\n }\n }\n }\n\n dispose() {\n this.mesh.geometry.dispose();\n if (this.material) {\n if (this.material.map) {\n this.material.map.dispose();\n }\n this.material.dispose();\n this.material = null;\n }\n }\n}\n", "import { Light, LightTypes } from \"@mml-io/mml-web\";\nimport { LightGraphics } from \"@mml-io/mml-web\";\nimport { MMLColor } from \"@mml-io/mml-web\";\nimport * as THREE from \"three\";\n\nimport { ThreeJSGraphicsAdapter } from \"../ThreeJSGraphicsAdapter\";\n\ndeclare type LightHelper = THREE.PointLightHelper | THREE.SpotLightHelper;\n\nconst debugSphereSize = 0.25;\n\nexport class ThreeJSLight extends LightGraphics {\n private threeLight: THREE.PointLight | THREE.SpotLight;\n private threeLightHelper: LightHelper | null;\n\n constructor(private light: Light) {\n super(light);\n this.createLight();\n }\n\n private createLight() {\n if (this.threeLight) {\n this.threeLight.removeFromParent();\n }\n\n const { r, g, b } = this.light.props.color;\n const color = new THREE.Color(r, g, b);\n\n switch (this.light.props.type) {\n case LightTypes.spotlight: {\n const light = new THREE.SpotLight(\n color,\n this.light.props.intensity,\n this.light.props.distance ?? undefined,\n THREE.MathUtils.degToRad(this.light.props.angleDeg),\n );\n // create a target\n const target = new THREE.Object3D();\n target.position.set(0, -1, 0);\n light.position.set(0, 0, 0);\n light.add(target);\n light.target = target;\n this.threeLight = light;\n break;\n }\n case LightTypes.point:\n this.threeLight = new THREE.PointLight(\n color,\n this.light.props.intensity,\n this.light.props.distance ?? undefined,\n );\n break;\n }\n\n if (this.threeLight.shadow) {\n this.threeLight.castShadow = this.light.props.castShadows;\n this.threeLight.shadow.mapSize.width = 512;\n this.threeLight.shadow.mapSize.height = 512;\n if (this.threeLight.shadow.camera instanceof THREE.PerspectiveCamera) {\n this.threeLight.shadow.camera.near = 0.5;\n this.threeLight.shadow.camera.far = 500;\n }\n this.threeLight.shadow.bias = -0.001;\n this.threeLight.shadow.normalBias = 0.01;\n const d = 10;\n const c = this.threeLight.shadow.camera as any;\n c.left = -d;\n c.right = d;\n c.top = d;\n c.bottom = -d;\n }\n\n this.threeLight.intensity = this.light.props.intensity;\n\n this.light.getContainer().add(this.threeLight);\n\n if (this.threeLightHelper) {\n this.makeLightHelper();\n }\n if (!this.light.props.enabled) {\n this.threeLight.visible = false;\n if (this.threeLightHelper) {\n this.threeLightHelper.visible = false;\n }\n }\n }\n\n private makeLightHelper() {\n if (this.threeLightHelper) {\n this.threeLightHelper.removeFromParent();\n this.threeLightHelper = null;\n }\n\n if (this.light instanceof THREE.PointLight) {\n this.threeLightHelper = new THREE.PointLightHelper(this.light, debugSphereSize);\n } else if (this.light instanceof THREE.SpotLight) {\n this.threeLightHelper = new THREE.SpotLightHelper(this.light);\n }\n\n if (this.threeLightHelper) {\n this.light.getContainer().add(this.threeLightHelper);\n this.threeLightHelper.matrix = this.threeLight.matrix;\n this.threeLightHelper.visible = this.threeLight.visible;\n }\n }\n\n disable(): void {}\n\n enable(): void {}\n\n setEnabled(enabled: boolean): void {\n this.threeLight.visible = enabled;\n if (this.threeLightHelper) {\n this.threeLightHelper.visible = enabled;\n }\n }\n\n setCastShadows(castShadows: boolean) {\n this.threeLight.castShadow = castShadows;\n }\n\n setAngle(angle: number) {\n if (this.threeLight instanceof THREE.SpotLight) {\n (this.threeLight as THREE.SpotLight).angle = THREE.MathUtils.degToRad(angle);\n }\n }\n\n setIntensity(intensity: number) {\n this.threeLight.intensity = intensity;\n }\n\n setDistance(distance: number) {\n this.threeLight.distance = distance;\n }\n\n setType(): void {\n this.createLight();\n }\n\n setDebug(debug: boolean): void {\n if (debug && !this.threeLightHelper) {\n this.makeLightHelper();\n } else if (!debug && this.threeLightHelper) {\n this.threeLightHelper.removeFromParent();\n this.threeLightHelper = null;\n }\n }\n\n setColor(color: MMLColor): void {\n this.threeLight.color.set(new THREE.Color(color.r, color.g, color.b));\n if (this.threeLightHelper) {\n this.threeLightHelper.color = new THREE.Color(color.r, color.g, color.b);\n }\n }\n\n dispose() {\n this.light.getContainer().remove(this.threeLight);\n if (this.threeLightHelper) {\n this.threeLightHelper.removeFromParent();\n }\n }\n}\n", "import { Link } from \"@mml-io/mml-web\";\nimport { LinkGraphics } from \"@mml-io/mml-web\";\n\nimport { ThreeJSGraphicsAdapter } from \"../ThreeJSGraphicsAdapter\";\n\nexport class ThreeJSLink extends LinkGraphics {\n constructor(private link: Link) {\n super(link);\n }\n\n disable(): void {}\n\n enable(): void {}\n\n setHref(): void {\n // no-op\n }\n\n setTarget(): void {\n // no-op\n }\n\n dispose() {}\n}\n", "import { MElement, MELEMENT_PROPERTY_NAME } from \"@mml-io/mml-web\";\nimport { MElementGraphics } from \"@mml-io/mml-web\";\nimport * as THREE from \"three\";\n\nimport { ThreeJSGraphicsAdapter } from \"../ThreeJSGraphicsAdapter\";\n\nexport class ThreeJSMElement extends MElementGraphics {\n protected container: THREE.Object3D;\n private currentParentContainer: THREE.Object3D | null = null;\n\n constructor(private element: MElement) {\n super(element);\n this.container = new THREE.Group();\n this.container.name = this.constructor.name;\n (this.container as any)[MELEMENT_PROPERTY_NAME] = element;\n\n if (this.currentParentContainer !== null) {\n throw new Error(\"Already connected to a parent\");\n }\n\n const mElementParent = this.element.getMElementParent();\n if (mElementParent) {\n this.currentParentContainer = mElementParent.getContainer();\n this.currentParentContainer.add(this.container);\n return;\n }\n\n // If none of the ancestors are MElements then this element may be directly connected to the body (without a wrapper).\n // Attempt to use a global scene that has been configured to attach this element to.\n const scene = this.element.getScene();\n this.currentParentContainer = scene.getRootContainer();\n this.currentParentContainer.add(this.container);\n }\n\n public getContainer(): THREE.Object3D {\n return this.container;\n }\n\n public dispose() {\n if (this.currentParentContainer === null) {\n throw new Error(\"Was not connected to a parent\");\n }\n\n this.currentParentContainer.remove(this.container);\n this.currentParentContainer = null;\n }\n}\n", "import { MElement, Model, TransformableElement } from \"@mml-io/mml-web\";\nimport { ModelGraphics } from \"@mml-io/mml-web\";\nimport { LoadingInstanceManager } from \"@mml-io/mml-web\";\nimport { IVect3 } from \"@mml-io/mml-web\";\nimport { ModelLoader, ModelLoadResult } from \"@mml-io/model-loader\";\nimport * as THREE from \"three\";\n\nimport { ThreeJSGraphicsAdapter } from \"../ThreeJSGraphicsAdapter\";\n\ntype ThreeJSModelLoadState = {\n group: THREE.Object3D;\n bones: Map;\n boundingBox: {\n size: THREE.Vector3;\n centerOffset: THREE.Vector3;\n };\n};\n\ntype ThreeJSModelAnimState = {\n currentAnimationClip: THREE.AnimationClip;\n appliedAnimation: {\n animationGroup: THREE.AnimationObjectGroup;\n animationMixer: THREE.AnimationMixer;\n animationAction: THREE.AnimationAction;\n } | null;\n};\n\nexport class ThreeJSModel extends ModelGraphics {\n private static modelLoader = new ModelLoader();\n private srcLoadingInstanceManager = new LoadingInstanceManager(`${Model.tagName}.src`);\n private animLoadingInstanceManager = new LoadingInstanceManager(`${Model.tagName}.anim`);\n private latestSrcModelPromise: Promise | null = null;\n private latestAnimPromise: Promise | null = null;\n\n private socketChildrenByBone = new Map>>();\n\n private attachments = new Map<\n Model,\n {\n animationGroup: THREE.AnimationObjectGroup;\n animationMixer: THREE.AnimationMixer;\n animationAction: THREE.AnimationAction;\n } | null\n >();\n private registeredParentAttachment: Model | null = null;\n\n private static DebugBoundingBoxGeometry = new THREE.BoxGeometry(1, 1, 1, 1, 1, 1);\n private static DebugBoundingBoxMaterial = new THREE.MeshBasicMaterial({\n color: 0xff0000,\n wireframe: true,\n transparent: true,\n opacity: 0.3,\n });\n private debugBoundingBox: THREE.Mesh | null = null;\n\n protected loadedState: ThreeJSModelLoadState | null = null;\n protected animState: ThreeJSModelAnimState | null = null;\n\n private documentTimeTickListener: null | { remove: () => void } = null;\n\n constructor(\n private model: Model,\n private updateMeshCallback: () => void,\n ) {\n super(model, updateMeshCallback);\n }\n\n hasLoadedModel(): boolean {\n return !!this.loadedState?.group;\n }\n\n hasLoadedAnimation(): boolean {\n return !!this.animState?.appliedAnimation;\n }\n\n disable(): void {}\n\n enable(): void {}\n\n getBoundingBox(): { centerOffset: IVect3; size: IVect3 } | null {\n if (this.loadedState) {\n return {\n centerOffset: this.loadedState.boundingBox.centerOffset,\n size: this.loadedState.boundingBox.size,\n };\n }\n return null;\n }\n\n getCollisionElement(): THREE.Object3D {\n return this.loadedState?.group ?? new THREE.Object3D();\n }\n\n setDebug(): void {\n this.updateDebugVisualisation();\n }\n\n setCastShadows(castShadows: boolean) {\n if (this.loadedState) {\n this.loadedState.group.traverse((object) => {\n if ((object as THREE.Mesh).isMesh) {\n const mesh = object as THREE.Mesh;\n mesh.castShadow = castShadows;\n }\n });\n }\n }\n\n setAnim(anim: string): void {\n this.resetAnimationMixer();\n this.animState = null;\n for (const [attachment, animState] of this.attachments) {\n if (animState) {\n animState.animationMixer.stopAllAction();\n this.attachments.set(attachment, null);\n }\n }\n\n if (!anim) {\n this.latestAnimPromise = null;\n this.animLoadingInstanceManager.abortIfLoading();\n\n // If the animation is removed then the model can be added to the parent attachment if the model is loaded\n if (this.loadedState && !this.registeredParentAttachment) {\n const parent = this.model.parentElement;\n if (parent instanceof Model) {\n this.registeredParentAttachment = parent;\n (parent.modelGraphics as ThreeJSModel).registerAttachment(this.model);\n }\n }\n return;\n }\n\n if (this.registeredParentAttachment) {\n (this.registeredParentAttachment.modelGraphics as ThreeJSModel).unregisterAttachment(\n this.model,\n );\n this.registeredParentAttachment = null;\n }\n\n const animSrc = this.model.contentSrcToContentAddress(anim);\n const animPromise = this.asyncLoadSourceAsset(animSrc, (loaded, total) => {\n this.animLoadingInstanceManager.setProgress(loaded / total);\n });\n this.animLoadingInstanceManager.start(this.model.getLoadingProgressManager(), animSrc);\n this.latestAnimPromise = animPromise;\n animPromise\n .then((result) => {\n if (this.latestAnimPromise !== animPromise || !this.model.isConnected) {\n return;\n }\n this.latestAnimPromise = null;\n this.playAnimation(result.animations[0]);\n\n for (const [model] of this.attachments) {\n this.registerAttachment(model);\n }\n\n this.animLoadingInstanceManager.finish();\n })\n .catch((err) => {\n console.error(\"Error loading m-model.anim\", err);\n this.latestAnimPromise = null;\n this.animLoadingInstanceManager.error(err);\n });\n }\n\n setAnimEnabled(): void {\n // no-op - property is observed in animation tick\n }\n\n setAnimLoop(): void {\n // no-op - property is observed in animation tick\n }\n\n setAnimStartTime(): void {\n // no-op - property is observed in animation tick\n }\n\n setAnimPauseTime(): void {\n // no-op - property is observed in animation tick\n }\n\n transformed(): void {\n // no-op\n }\n\n setSrc(src: string): void {\n if (this.loadedState !== null) {\n this.loadedState.group.removeFromParent();\n if (this.registeredParentAttachment) {\n (this.registeredParentAttachment.modelGraphics as ThreeJSModel).unregisterAttachment(\n this.model,\n );\n this.registeredParentAttachment = null;\n }\n ThreeJSModel.disposeOfGroup(this.loadedState.group);\n this.loadedState = null;\n this.updateMeshCallback();\n this.updateDebugVisualisation();\n }\n if (!src) {\n this.srcLoadingInstanceManager.abortIfLoading();\n this.socketChildrenByBone.forEach((children) => {\n children.forEach((child) => {\n this.model.getContainer().add(child.getContainer());\n });\n });\n this.updateMeshCallback();\n this.updateDebugVisualisation();\n return;\n }\n\n const contentSrc = this.model.contentSrcToContentAddress(src);\n const srcModelPromise = this.asyncLoadSourceAsset(contentSrc, (loaded, total) => {\n this.srcLoadingInstanceManager.setProgress(loaded / total);\n });\n this.srcLoadingInstanceManager.start(this.model.getLoadingProgressManager(), contentSrc);\n this.latestSrcModelPromise = srcModelPromise;\n srcModelPromise\n .then((result) => {\n if (this.latestSrcModelPromise !== srcModelPromise || !this.model.isConnected) {\n // If we've loaded a different model since, or we're no longer connected, dispose of this one\n ThreeJSModel.disposeOfGroup(result.group);\n return;\n }\n result.group.traverse((child) => {\n if ((child as THREE.Mesh).isMesh) {\n child.castShadow = this.model.props.castShadows;\n child.receiveShadow = true;\n }\n });\n this.latestSrcModelPromise = null;\n const group = result.group;\n const bones = new Map();\n group.traverse((object) => {\n if (object instanceof THREE.Bone) {\n bones.set(object.name, object);\n }\n });\n const boundingBox = new THREE.Box3();\n group.updateWorldMatrix(true, true);\n boundingBox.expandByObject(group);\n\n this.loadedState = {\n group,\n bones,\n boundingBox: {\n size: boundingBox.getSize(new THREE.Vector3(0, 0, 0)),\n centerOffset: boundingBox.getCenter(new THREE.Vector3(0, 0, 0)),\n },\n };\n this.model.getContainer().add(group);\n\n for (const [boneName, children] of this.socketChildrenByBone) {\n const bone = bones.get(boneName);\n if (bone) {\n children.forEach((child) => {\n bone.add(child.getContainer());\n });\n }\n }\n\n this.updateMeshCallback();\n\n const parent = this.model.parentElement;\n if (parent instanceof Model) {\n if (!this.latestAnimPromise && !this.animState) {\n this.registeredParentAttachment = parent;\n (parent.modelGraphics as ThreeJSModel).registerAttachment(this.model);\n }\n }\n\n if (this.animState) {\n this.playAnimation(this.animState.currentAnimationClip);\n }\n this.srcLoadingInstanceManager.finish();\n\n this.updateDebugVisualisation();\n })\n .catch((err) => {\n console.error(\"Error loading m-model.src\", err);\n this.srcLoadingInstanceManager.error(err);\n });\n }\n\n public registerAttachment(attachment: Model) {\n let animState = null;\n if (this.animState) {\n const attachmentLoadedState = (attachment.modelGraphics as ThreeJSModel).loadedState;\n if (!attachmentLoadedState) {\n throw new Error(\"Attachment must be loaded before registering\");\n }\n const animationGroup = new THREE.AnimationObjectGroup();\n const animationMixer = new THREE.AnimationMixer(animationGroup);\n const action = animationMixer.clipAction(this.animState.currentAnimationClip);\n animState = {\n animationGroup,\n animationMixer,\n animationAction: action,\n };\n animationGroup.add(attachmentLoadedState.group);\n action.play();\n }\n this.attachments.set(attachment, animState);\n }\n\n public unregisterAttachment(attachment: Model) {\n const attachmentState = this.attachments.get(attachment);\n if (attachmentState) {\n attachmentState.animationMixer.stopAllAction();\n }\n this.attachments.delete(attachment);\n }\n\n private updateDebugVisualisation() {\n if (!this.model.props.debug) {\n this.clearDebugVisualisation();\n } else {\n if (!this.debugBoundingBox) {\n this.debugBoundingBox = new THREE.Mesh(\n ThreeJSModel.DebugBoundingBoxGeometry,\n ThreeJSModel.DebugBoundingBoxMaterial,\n );\n this.model.getContainer().add(this.debugBoundingBox);\n }\n if (this.loadedState) {\n const boundingBox = this.loadedState.boundingBox;\n if (boundingBox.centerOffset) {\n this.debugBoundingBox.position.copy(boundingBox.centerOffset);\n } else {\n this.debugBoundingBox.position.set(0, 0, 0);\n }\n this.debugBoundingBox.scale.copy(boundingBox.size);\n } else {\n this.debugBoundingBox.scale.set(0, 0, 0);\n }\n }\n }\n\n private clearDebugVisualisation() {\n if (this.debugBoundingBox) {\n this.debugBoundingBox.removeFromParent();\n this.debugBoundingBox = null;\n }\n }\n\n async asyncLoadSourceAsset(\n url: string,\n onProgress: (loaded: number, total: number) => void,\n ): Promise {\n return await ThreeJSModel.modelLoader.load(url, onProgress);\n }\n\n private resetAnimationMixer() {\n if (this.documentTimeTickListener) {\n this.documentTimeTickListener.remove();\n this.documentTimeTickListener = null;\n }\n if (this.animState) {\n const appliedAnimation = this.animState.appliedAnimation;\n if (appliedAnimation) {\n appliedAnimation.animationMixer.stopAllAction();\n }\n this.animState.appliedAnimation = null;\n }\n }\n\n public registerSocketChild(\n child: TransformableElement,\n socketName: string,\n ): void {\n let children = this.socketChildrenByBone.get(socketName);\n if (!children) {\n children = new Set>();\n this.socketChildrenByBone.set(socketName, children);\n }\n children.add(child);\n\n if (this.loadedState) {\n const bone = this.loadedState.bones.get(socketName);\n if (bone) {\n bone.add(child.getContainer());\n } else {\n this.model.getContainer().add(child.getContainer());\n }\n }\n }\n\n public unregisterSocketChild(\n child: TransformableElement,\n socketName: string,\n addToRoot: boolean = true,\n ): void {\n const socketChildren = this.socketChildrenByBone.get(socketName);\n if (socketChildren) {\n socketChildren.delete(child);\n if (addToRoot) {\n this.model.getContainer().add(child.getContainer());\n }\n if (socketChildren.size === 0) {\n this.socketChildrenByBone.delete(socketName);\n }\n }\n }\n\n private triggerSocketedChildrenTransformed() {\n // Socketed children need to be updated when the animation is updated as their position may have updated\n this.socketChildrenByBone.forEach((children) => {\n children.forEach((child) => {\n if (child instanceof TransformableElement) {\n child.didUpdateTransformation();\n }\n });\n });\n }\n\n private playAnimation(anim: THREE.AnimationClip) {\n this.resetAnimationMixer();\n this.animState = {\n currentAnimationClip: anim,\n appliedAnimation: null,\n };\n const animationGroup = new THREE.AnimationObjectGroup();\n const animationMixer = new THREE.AnimationMixer(animationGroup);\n const action = animationMixer.clipAction(anim);\n this.animState.appliedAnimation = {\n animationGroup,\n animationMixer,\n animationAction: action,\n };\n if (this.loadedState) {\n animationGroup.add(this.loadedState.group);\n }\n action.play();\n if (!this.documentTimeTickListener) {\n this.documentTimeTickListener = this.model.addDocumentTimeTickListener(\n (documentTime: number) => {\n this.updateAnimation(documentTime);\n },\n );\n }\n }\n\n private updateAnimation(docTimeMs: number, force: boolean = false) {\n if (this.animState) {\n if (!this.model.props.animEnabled && this.animState.appliedAnimation) {\n this.resetAnimationMixer();\n this.triggerSocketedChildrenTransformed();\n } else {\n if (!this.animState.appliedAnimation) {\n this.playAnimation(this.animState.currentAnimationClip);\n }\n let animationTimeMs = docTimeMs - this.model.props.animStartTime;\n if (docTimeMs < this.model.props.animStartTime) {\n animationTimeMs = 0;\n } else if (this.model.props.animPauseTime !== null) {\n if (docTimeMs > this.model.props.animPauseTime) {\n animationTimeMs = this.model.props.animPauseTime - this.model.props.animStartTime;\n }\n }\n\n const clip = this.animState.currentAnimationClip;\n if (clip !== null) {\n if (!this.model.props.animLoop) {\n if (animationTimeMs > clip.duration * 1000) {\n animationTimeMs = clip.duration * 1000;\n }\n }\n }\n\n for (const [model, attachmentState] of this.attachments) {\n if (attachmentState) {\n attachmentState.animationMixer.setTime(animationTimeMs / 1000);\n (model.modelGraphics as ThreeJSModel).triggerSocketedChildrenTransformed();\n }\n }\n\n if (force) {\n this.animState.appliedAnimation?.animationMixer.setTime((animationTimeMs + 1) / 1000);\n }\n this.animState.appliedAnimation?.animationMixer.setTime(animationTimeMs / 1000);\n this.triggerSocketedChildrenTransformed();\n }\n }\n }\n\n dispose() {\n if (this.documentTimeTickListener) {\n this.documentTimeTickListener.remove();\n this.documentTimeTickListener = null;\n }\n if (this.registeredParentAttachment) {\n (this.registeredParentAttachment?.modelGraphics as ThreeJSModel)?.unregisterAttachment(\n this.model,\n );\n this.registeredParentAttachment = null;\n }\n if (this.loadedState) {\n this.loadedState.group.removeFromParent();\n ThreeJSModel.disposeOfGroup(this.loadedState.group);\n this.loadedState = null;\n }\n this.clearDebugVisualisation();\n this.animLoadingInstanceManager.dispose();\n this.srcLoadingInstanceManager.dispose();\n }\n\n private static disposeOfGroup(group: THREE.Object3D) {\n group.traverse((child) => {\n if ((child as THREE.Mesh).isMesh) {\n const mesh = child as THREE.Mesh;\n mesh.geometry.dispose();\n if (Array.isArray(mesh.material)) {\n for (const material of mesh.material) {\n ThreeJSModel.disposeOfMaterial(material);\n }\n } else if (mesh.material) {\n ThreeJSModel.disposeOfMaterial(mesh.material);\n }\n }\n });\n }\n\n private static disposeOfMaterial(material: THREE.Material) {\n material.dispose();\n for (const key of Object.keys(material)) {\n const value = (material as any)[key];\n if (value && typeof value === \"object\" && \"minFilter\" in value) {\n value.dispose();\n }\n }\n }\n}\n", "import { Plane } from \"@mml-io/mml-web\";\nimport { MMLColor } from \"@mml-io/mml-web\";\nimport { PlaneGraphics } from \"@mml-io/mml-web\";\nimport * as THREE from \"three\";\n\nimport { ThreeJSGraphicsAdapter } from \"../ThreeJSGraphicsAdapter\";\n\nexport class ThreeJSPlane extends PlaneGraphics {\n static planeGeometry = new THREE.PlaneGeometry(1, 1);\n private mesh: THREE.Mesh>;\n private material: THREE.MeshStandardMaterial;\n\n constructor(private plane: Plane) {\n super(plane);\n\n this.material = new THREE.MeshStandardMaterial({\n color: new THREE.Color(plane.props.color.r, plane.props.color.g, plane.props.color.b),\n });\n this.mesh = new THREE.Mesh(ThreeJSPlane.planeGeometry, this.material);\n this.mesh.castShadow = plane.props.castShadows;\n this.mesh.receiveShadow = true;\n this.plane.getContainer().add(this.mesh);\n }\n\n disable(): void {}\n\n enable(): void {}\n\n getCollisionElement(): THREE.Object3D {\n return this.mesh;\n }\n\n setColor(color: MMLColor): void {\n this.material.color = new THREE.Color(color.r, color.g, color.b);\n }\n\n setWidth(width: number): void {\n this.mesh.scale.x = width;\n }\n\n setHeight(height: number): void {\n this.mesh.scale.y = height;\n }\n\n setCastShadows(castShadows: boolean): void {\n this.mesh.castShadow = castShadows;\n }\n\n setOpacity(opacity: number): void {\n const needsUpdate = this.material.transparent === (opacity === 1);\n this.material.transparent = opacity !== 1;\n this.material.needsUpdate = needsUpdate;\n this.material.opacity = opacity;\n }\n\n dispose() {}\n}\n", "import { PositionProbe } from \"@mml-io/mml-web\";\nimport { PositionProbeGraphics } from \"@mml-io/mml-web\";\nimport * as THREE from \"three\";\n\nimport { ThreeJSGraphicsAdapter } from \"../ThreeJSGraphicsAdapter\";\n\nexport class ThreeJSPositionProbe extends PositionProbeGraphics {\n private static DebugGeometry = new THREE.SphereGeometry(1, 16, 16, 1);\n private static DebugMaterial = new THREE.MeshBasicMaterial({\n color: 0xff0000,\n wireframe: true,\n transparent: true,\n opacity: 0.3,\n });\n\n private debugMesh: THREE.Mesh | null = null;\n\n constructor(private positionProbe: PositionProbe) {\n super(positionProbe);\n }\n\n disable(): void {}\n\n enable(): void {}\n\n setRange(): void {\n this.updateDebugVisualisation();\n }\n\n setDebug() {\n this.updateDebugVisualisation();\n }\n\n private clearDebugVisualisation() {\n if (this.debugMesh) {\n this.debugMesh.removeFromParent();\n this.debugMesh = null;\n }\n }\n\n private updateDebugVisualisation() {\n if (!this.positionProbe.props.debug) {\n this.clearDebugVisualisation();\n } else {\n if (this.positionProbe.isConnected && !this.debugMesh) {\n const mesh = new THREE.Mesh(\n ThreeJSPositionProbe.DebugGeometry,\n ThreeJSPositionProbe.DebugMaterial,\n );\n mesh.castShadow = false;\n mesh.receiveShadow = false;\n this.debugMesh = mesh;\n this.positionProbe.getContainer().add(this.debugMesh);\n }\n\n if (this.debugMesh) {\n this.debugMesh.scale.set(\n this.positionProbe.props.range,\n this.positionProbe.props.range,\n this.positionProbe.props.range,\n );\n }\n }\n }\n\n dispose() {\n this.clearDebugVisualisation();\n }\n}\n", "import { Prompt } from \"@mml-io/mml-web\";\nimport { PromptGraphics } from \"@mml-io/mml-web\";\n\nimport { ThreeJSGraphicsAdapter } from \"../ThreeJSGraphicsAdapter\";\n\nexport class ThreeJSPrompt extends PromptGraphics {\n constructor(private prompt: Prompt) {\n super(prompt);\n }\n\n disable(): void {}\n\n enable(): void {}\n\n setMessage(): void {\n // no-op\n }\n\n setPlaceholder(): void {\n // no-op\n }\n\n setPrefill(): void {\n // no-op\n }\n\n setDebug(): void {\n // no-op\n }\n\n dispose() {}\n}\n", "import { RemoteDocument, RemoteDocumentGraphics } from \"@mml-io/mml-web\";\nimport * as THREE from \"three\";\n\nimport { ThreeJSGraphicsAdapter } from \"../ThreeJSGraphicsAdapter\";\nimport { getThreeJSReconnectingStatus } from \"../ThreeJSReconnectingStatus\";\n\nexport class ThreeJSRemoteDocument extends RemoteDocumentGraphics {\n private statusUI: THREE.Mesh | null = null;\n\n constructor(private element: RemoteDocument) {\n super(element);\n }\n\n public showError(showError: boolean): void {\n if (!showError) {\n if (this.statusUI !== null) {\n this.element.getContainer().remove(this.statusUI);\n this.statusUI = null;\n }\n } else {\n if (this.statusUI === null) {\n const { geometry, material, height } = getThreeJSReconnectingStatus();\n const mesh: THREE.Mesh = new THREE.Mesh(\n geometry,\n material,\n );\n mesh.position.set(0, height / 2, 0);\n this.statusUI = mesh;\n this.element.getContainer().add(this.statusUI);\n }\n }\n }\n\n public dispose() {}\n}\n", "import { CanvasText } from \"@mml-io/mml-web\";\nimport * as THREE from \"three\";\n\nfunction createReconnectingStatus() {\n const canvas = new CanvasText().renderText(\"Reconnecting\", {\n bold: true,\n fontSize: 32,\n paddingPx: 10,\n textColorRGB255A1: {\n r: 255,\n g: 0,\n b: 0,\n a: 1.0,\n },\n backgroundColorRGB255A1: {\n r: 255,\n g: 255,\n b: 255,\n a: 1.0,\n },\n alignment: \"center\",\n });\n\n const texture = new THREE.Texture(canvas);\n texture.minFilter = THREE.LinearFilter;\n texture.magFilter = THREE.LinearFilter;\n texture.format = THREE.RGBAFormat;\n texture.needsUpdate = true;\n\n const width = canvas.width;\n const height = canvas.height;\n\n const material = new THREE.MeshBasicMaterial({\n map: texture,\n side: THREE.DoubleSide,\n });\n const geometry = new THREE.PlaneGeometry(width / 100, height / 100, 1, 1);\n return { geometry, material, width: width / 100, height: height / 100 };\n}\n\nexport type ThreeJSReconnectingStatus = {\n geometry: THREE.PlaneGeometry;\n material: THREE.MeshBasicMaterial;\n width: number;\n height: number;\n};\n\nlet reconnectingStatus: ThreeJSReconnectingStatus | null = null;\n\nexport function getThreeJSReconnectingStatus(): ThreeJSReconnectingStatus {\n if (!reconnectingStatus) {\n reconnectingStatus = createReconnectingStatus();\n }\n return reconnectingStatus;\n}\n", "import { Sphere } from \"@mml-io/mml-web\";\nimport { MMLColor } from \"@mml-io/mml-web\";\nimport { SphereGraphics } from \"@mml-io/mml-web\";\nimport * as THREE from \"three\";\n\nimport { ThreeJSGraphicsAdapter } from \"../ThreeJSGraphicsAdapter\";\n\nconst defaultSphereWidthSegments = 16;\nconst defaultSphereHeightSegments = 16;\n\nexport class ThreeJSSphere extends SphereGraphics {\n static sphereGeometry = new THREE.SphereGeometry(\n 0.5,\n defaultSphereWidthSegments,\n defaultSphereHeightSegments,\n );\n private mesh: THREE.Mesh>;\n private material: THREE.MeshStandardMaterial;\n\n constructor(private sphere: Sphere) {\n super(sphere);\n\n this.material = new THREE.MeshStandardMaterial({\n color: new THREE.Color(sphere.props.color.r, sphere.props.color.g, sphere.props.color.b),\n });\n this.mesh = new THREE.Mesh(ThreeJSSphere.sphereGeometry, this.material);\n this.mesh.castShadow = sphere.props.castShadows;\n this.mesh.receiveShadow = true;\n this.sphere.getContainer().add(this.mesh);\n }\n\n disable(): void {}\n\n enable(): void {}\n\n getCollisionElement(): THREE.Object3D {\n return this.mesh;\n }\n\n setColor(color: MMLColor): void {\n this.material.color = new THREE.Color(color.r, color.g, color.b);\n }\n\n setRadius(radius: number): void {\n this.mesh.scale.x = radius * 2;\n this.mesh.scale.y = radius * 2;\n this.mesh.scale.z = radius * 2;\n }\n\n setCastShadows(castShadows: boolean): void {\n this.mesh.castShadow = castShadows;\n }\n\n setOpacity(opacity: number): void {\n const needsUpdate = this.material.transparent === (opacity === 1);\n this.material.transparent = opacity !== 1;\n this.material.needsUpdate = needsUpdate;\n this.material.opacity = opacity;\n }\n\n dispose() {}\n}\n", "import {\n Matr4,\n Matr4Data,\n Model,\n TransformableElement,\n TransformableGraphics,\n} from \"@mml-io/mml-web\";\nimport * as THREE from \"three\";\n\nimport { ThreeJSGraphicsAdapter } from \"../ThreeJSGraphicsAdapter\";\nimport { ThreeJSModel } from \"./ThreeJSModel\";\n\nexport class ThreeJSTransformable extends TransformableGraphics {\n private socketName: string | null = null;\n private registeredSocketParent: ThreeJSModel | null = null;\n\n constructor(private transformableElement: TransformableElement) {\n super(transformableElement);\n }\n\n getWorldMatrix(): Matr4 {\n // TODO - optimize/reduce calls to updateWorldMatrix\n const container = this.getContainer();\n container.updateWorldMatrix(true, false);\n return new Matr4(container.matrixWorld.elements as Matr4Data);\n }\n\n setVisible(visible: boolean): void {\n this.getContainer().visible = visible;\n }\n\n setSocket(socketName: string | null): void {\n if (this.socketName !== socketName) {\n if (this.socketName !== null && this.registeredSocketParent) {\n this.registeredSocketParent.unregisterSocketChild(\n this.transformableElement,\n this.socketName,\n );\n }\n this.socketName = socketName;\n if (socketName !== null) {\n this.registerWithParentModel(socketName);\n }\n } else {\n this.socketName = socketName;\n }\n }\n\n private registerWithParentModel(socketName: string): void {\n if (\n (this.transformableElement.parentElement as Model | undefined)\n ?.isModel\n ) {\n const parentModel = this.transformableElement.parentElement as Model;\n this.registeredSocketParent = parentModel.modelGraphics as ThreeJSModel;\n this.registeredSocketParent.registerSocketChild(this.transformableElement, socketName);\n }\n }\n\n private getContainer(): THREE.Group {\n return this.transformableElement.getContainer() as THREE.Group;\n }\n\n setX(x: number): void {\n this.getContainer().position.x = x;\n }\n\n setY(y: number): void {\n this.getContainer().position.y = y;\n }\n\n setZ(z: number): void {\n this.getContainer().position.z = z;\n }\n\n setRotationX(rotationX: number): void {\n this.getContainer().rotation.x = rotationX * THREE.MathUtils.DEG2RAD;\n }\n\n setRotationY(rotationY: number): void {\n this.getContainer().rotation.y = rotationY * THREE.MathUtils.DEG2RAD;\n }\n\n setRotationZ(rotationZ: number): void {\n this.getContainer().rotation.z = rotationZ * THREE.MathUtils.DEG2RAD;\n }\n\n setScaleX(scaleX: number): void {\n this.getContainer().scale.x = scaleX;\n }\n\n setScaleY(scaleY: number): void {\n this.getContainer().scale.y = scaleY;\n }\n\n setScaleZ(scaleZ: number): void {\n this.getContainer().scale.z = scaleZ;\n }\n\n dispose() {\n if (this.socketName && this.registeredSocketParent !== null) {\n this.registeredSocketParent.unregisterSocketChild(\n this.transformableElement,\n this.socketName,\n false,\n );\n }\n }\n}\n", "import {\n calculateContentSize,\n StaticFileVideoSource,\n Video,\n VideoGraphics,\n VideoSource,\n WHEPVideoSource,\n} from \"@mml-io/mml-web\";\nimport * as THREE from \"three\";\n\nimport { ThreeJSGraphicsAdapter } from \"../ThreeJSGraphicsAdapter\";\n\nconst audioRefDistance = 1;\nconst audioRolloffFactor = 1;\n\nconst disabledVideoMaterial = new THREE.MeshStandardMaterial({\n color: 0x000000,\n side: THREE.DoubleSide,\n});\n\nexport class ThreeJSVideo extends VideoGraphics {\n private videoSource: VideoSource | null = null;\n private videoMaterial: THREE.MeshStandardMaterial;\n\n private mesh: THREE.Mesh<\n THREE.PlaneGeometry,\n THREE.MeshStandardMaterial | THREE.MeshBasicMaterial\n >;\n\n private loadedVideoState: {\n video: HTMLVideoElement;\n audio: THREE.PositionalAudio;\n videoTexture: THREE.VideoTexture | null;\n } | null = null;\n\n constructor(\n private video: Video,\n private updateMeshCallback: () => void,\n ) {\n super(video, updateMeshCallback);\n\n const geometry = new THREE.PlaneGeometry(1, 1, 1, 1);\n // Video material is only applied once a video is played\n this.videoMaterial = new THREE.MeshStandardMaterial({\n color: 0xffffff,\n transparent: false,\n side: THREE.DoubleSide,\n });\n this.mesh = new THREE.Mesh(geometry, disabledVideoMaterial);\n this.mesh.castShadow = true;\n this.mesh.receiveShadow = false;\n this.video.getContainer().add(this.mesh);\n }\n\n public getWidthAndHeight(): { width: number; height: number } {\n return {\n width: this.mesh.scale.x,\n height: this.mesh.scale.y,\n };\n }\n\n public syncVideoTime() {\n if (this.loadedVideoState) {\n const videoTag = this.loadedVideoState.video;\n if (videoTag.readyState === 0) {\n return;\n }\n\n const audioListener = this.getAudioListener();\n const audioContext = audioListener.context;\n if (audioContext.state === \"running\") {\n videoTag.muted = false;\n }\n\n if (this.video.isDisabled()) {\n videoTag.muted = true;\n }\n\n if (this.videoSource) {\n this.videoSource.syncVideoSource(this.video.props);\n }\n }\n }\n\n private getAudioListener() {\n return this.video.getScene().getGraphicsAdapter().getAudioListener();\n }\n\n public enable(): void {\n this.updateVideo();\n }\n public disable(): void {\n this.updateVideo();\n }\n\n public getCollisionElement(): THREE.Object3D {\n return this.mesh;\n }\n\n public setSrc(): void {\n this.updateVideo();\n }\n\n public setWidth(): void {\n this.updateWidthAndHeight();\n }\n\n public setHeight(): void {\n this.updateWidthAndHeight();\n }\n\n public setEnabled(): void {\n this.updateVideo();\n }\n\n public setCastShadows(): void {\n this.updateVideo();\n }\n\n public setLoop(): void {\n this.updateVideo();\n }\n\n public setVolume(): void {\n if (this.loadedVideoState) {\n this.loadedVideoState.audio.setVolume(this.video.props.volume);\n }\n }\n\n public setEmissive(): void {\n this.updateVideo();\n this.updateMaterialEmissiveIntensity();\n }\n\n public setStartTime(): void {\n this.updateVideo();\n }\n\n public setPauseTime(): void {\n this.updateVideo();\n }\n\n private updateVideo() {\n if (!this.video.isConnected) {\n return;\n }\n\n if (!this.video.props.enabled) {\n this.clearSource();\n return;\n }\n\n if (!this.video.props.src) {\n this.clearSource();\n } else {\n const contentAddress = this.video.contentSrcToContentAddress(this.video.props.src);\n if (this.videoSource === null || this.videoSource.getContentAddress() !== contentAddress) {\n this.clearSource();\n\n const video = document.createElement(\"video\");\n video.playsInline = true;\n // Muted allows autoplay immediately without the user needing to interact with the document\n // Video will be unmuted when the audiocontext is available\n video.muted = true;\n video.autoplay = true;\n video.crossOrigin = \"anonymous\";\n\n const audioListener = this.getAudioListener();\n const audioContext = audioListener.context;\n\n const audio = new THREE.PositionalAudio(audioListener);\n audio.setMediaElementSource(video);\n audio.setVolume(this.video.props.volume);\n audio.setRefDistance(audioRefDistance);\n audio.setRolloffFactor(audioRolloffFactor);\n this.loadedVideoState = {\n video,\n audio,\n videoTexture: null,\n };\n this.updateMaterialEmissiveIntensity();\n this.video.getContainer().add(audio);\n\n const url = new URL(contentAddress);\n if (WHEPVideoSource.isWHEPURL(url)) {\n this.videoSource = new WHEPVideoSource(url, video);\n } else {\n this.videoSource = new StaticFileVideoSource(url, video, this.video.props, () => {\n return this.video.getDocumentTime();\n });\n }\n\n audioContext.addEventListener(\"statechange\", () => {\n this.syncVideoTime();\n });\n video.addEventListener(\"loadeddata\", () => {\n if (!this.loadedVideoState || this.loadedVideoState.video !== video) {\n // Video was changed before it loaded\n return;\n }\n\n const videoTexture = new THREE.VideoTexture(video);\n this.videoMaterial.map = videoTexture;\n this.videoMaterial.needsUpdate = true;\n this.mesh.material = this.videoMaterial;\n this.loadedVideoState.videoTexture = videoTexture;\n\n this.syncVideoTime();\n this.updateWidthAndHeight();\n this.updateMaterialEmissiveIntensity();\n });\n }\n }\n\n if (this.videoSource) {\n this.syncVideoTime();\n }\n }\n\n private clearSource() {\n if (this.videoSource) {\n this.videoSource.dispose();\n this.videoSource = null;\n }\n if (this.loadedVideoState) {\n const tag = this.loadedVideoState.video;\n // There is an existing src - stop playing to allow changing it\n tag.pause();\n tag.src = \"\";\n tag.load();\n this.loadedVideoState = null;\n this.mesh.material = disabledVideoMaterial;\n this.updateWidthAndHeight();\n }\n }\n\n dispose() {\n this.clearSource();\n if (this.loadedVideoState) {\n this.loadedVideoState = null;\n }\n }\n\n private updateMaterialEmissiveIntensity() {\n if (this.loadedVideoState && this.loadedVideoState.videoTexture) {\n if (this.video.props.emissive > 0) {\n this.videoMaterial.emissive = new THREE.Color(0xffffff);\n this.videoMaterial.emissiveMap = this.loadedVideoState.videoTexture;\n this.videoMaterial.emissiveIntensity = this.video.props.emissive;\n this.videoMaterial.needsUpdate = true;\n } else {\n this.videoMaterial.emissive = new THREE.Color(0x000000);\n this.videoMaterial.emissiveMap = null;\n this.videoMaterial.emissiveIntensity = 1;\n this.videoMaterial.needsUpdate = true;\n }\n }\n }\n\n private updateWidthAndHeight() {\n const mesh = this.mesh;\n\n const { width, height } = calculateContentSize({\n content: this.loadedVideoState\n ? {\n width: this.loadedVideoState.video.videoWidth,\n height: this.loadedVideoState.video.videoHeight,\n }\n : undefined,\n width: this.video.props.width,\n height: this.video.props.height,\n });\n mesh.scale.x = width;\n mesh.scale.y = height;\n\n this.updateMeshCallback();\n }\n}\n", "import {\n EventHandlerCollection,\n getRelativePositionAndRotationRelativeToObject,\n MElement,\n TransformableElement,\n} from \"@mml-io/mml-web\";\nimport * as THREE from \"three\";\n\nconst mouseMovePixelsThreshold = 10;\nconst mouseMoveTimeThresholdMilliseconds = 500;\n\n/**\n * The ThreeJSClickTrigger class is responsible for handling click events on the MML scene and raycasts into the scene to\n * determine which object was clicked and then dispatches events to those elements.\n */\nexport class ThreeJSClickTrigger {\n private eventHandlerCollection: EventHandlerCollection = new EventHandlerCollection();\n private raycaster: THREE.Raycaster;\n private mouseDownTime: number | null = null;\n private mouseMoveDelta = 0;\n\n static init(\n clickTarget: Document | HTMLElement,\n rootContainer: THREE.Object3D,\n camera: THREE.Camera,\n ): ThreeJSClickTrigger {\n return new ThreeJSClickTrigger(clickTarget, rootContainer, camera);\n }\n\n private constructor(\n private clickTarget: Document | HTMLElement,\n private rootContainer: THREE.Object3D,\n private camera: THREE.Camera,\n ) {\n this.raycaster = new THREE.Raycaster();\n\n this.eventHandlerCollection.add(clickTarget, \"mousedown\", this.handleMouseDown.bind(this));\n this.eventHandlerCollection.add(clickTarget, \"mouseup\", this.handleMouseUp.bind(this));\n this.eventHandlerCollection.add(clickTarget, \"mousemove\", this.handleMouseMove.bind(this));\n }\n\n private handleMouseDown() {\n this.mouseDownTime = Date.now();\n this.mouseMoveDelta = 0;\n }\n\n private handleMouseUp(event: MouseEvent) {\n if (!this.mouseDownTime) {\n return;\n }\n const duration = Date.now() - this.mouseDownTime;\n this.mouseDownTime = null;\n if (\n this.mouseMoveDelta < mouseMovePixelsThreshold &&\n duration < mouseMoveTimeThresholdMilliseconds\n ) {\n this.handleClick(event);\n }\n }\n\n private handleMouseMove(event: MouseEvent) {\n if (this.mouseDownTime) {\n this.mouseMoveDelta += Math.abs(event.movementX) + Math.abs(event.movementY);\n }\n }\n\n private handleClick(event: MouseEvent) {\n if ((event.detail as any).element) {\n // Avoid infinite loop of handling click events that originated from this trigger\n return;\n }\n let x = 0;\n let y = 0;\n if (!document.pointerLockElement) {\n let width = window.innerWidth;\n let height = window.innerHeight;\n if (this.clickTarget instanceof HTMLElement) {\n width = this.clickTarget.offsetWidth;\n height = this.clickTarget.offsetHeight;\n }\n x = (event.offsetX / width) * 2 - 1;\n y = -((event.offsetY / height) * 2 - 1);\n }\n this.raycaster.setFromCamera(new THREE.Vector2(x, y), this.camera);\n const intersections = this.raycaster.intersectObject(this.rootContainer, true);\n if (intersections.length > 0) {\n for (const intersection of intersections) {\n let obj: THREE.Object3D | null = intersection.object;\n while (obj) {\n /*\n Ignore scene objects that have a transparent or wireframe material\n */\n if (this.isMaterialIgnored(obj)) {\n break;\n }\n\n const mElement = MElement.getMElementFromObject(obj);\n if (mElement && mElement instanceof TransformableElement && mElement.isClickable()) {\n // let's get the intersection point relative to the element origin\n\n const elementRelative = getRelativePositionAndRotationRelativeToObject(\n {\n position: intersection.point,\n rotation: {\n x: 0,\n y: 0,\n z: 0,\n },\n },\n mElement,\n );\n\n mElement.dispatchEvent(\n new CustomEvent(\"click\", {\n bubbles: true,\n detail: {\n position: {\n ...elementRelative.position,\n },\n },\n }),\n );\n return;\n }\n obj = obj.parent;\n }\n }\n }\n }\n\n dispose() {\n this.eventHandlerCollection.clear();\n }\n\n private isMaterialIgnored(obj: THREE.Object3D): boolean {\n const mesh = obj as THREE.Mesh;\n if (mesh) {\n if (\n ((mesh.material as THREE.Material) &&\n (mesh.material as THREE.Material).transparent &&\n (mesh.material as THREE.Material).opacity < 1) ||\n ((mesh.material as THREE.MeshLambertMaterial) &&\n (mesh.material as THREE.MeshLambertMaterial).wireframe) ||\n ((mesh.material as THREE.MeshPhongMaterial) &&\n (mesh.material as THREE.MeshPhongMaterial).wireframe) ||\n ((mesh.material as THREE.MeshPhysicalMaterial) &&\n (mesh.material as THREE.MeshPhysicalMaterial).wireframe) ||\n ((mesh.material as THREE.MeshStandardMaterial) &&\n (mesh.material as THREE.MeshStandardMaterial).wireframe) ||\n ((mesh.material as THREE.LineBasicMaterial) &&\n (mesh.material as THREE.LineBasicMaterial).isLineBasicMaterial)\n ) {\n return true;\n }\n }\n return false;\n }\n}\n", "import { MMLGraphicsInterface } from \"@mml-io/mml-web\";\n\nimport * as ThreeJSElements from \"./elements\";\nimport { ThreeJSGraphicsAdapter } from \"./ThreeJSGraphicsAdapter\";\n\nexport const ThreeJSGraphicsInterface: MMLGraphicsInterface = {\n MElementGraphicsInterface: (element) => new ThreeJSElements.ThreeJSMElement(element),\n MMLDebugHelperGraphicsInterface: (debugHelper) =>\n new ThreeJSElements.ThreeJSDebugHelper(debugHelper),\n MMLAudioGraphicsInterface: (element) => new ThreeJSElements.ThreeJSAudio(element),\n MMLChatProbeGraphicsInterface: (element) => new ThreeJSElements.ThreeJSChatProbe(element),\n MMLCubeGraphicsInterface: (element) => new ThreeJSElements.ThreeJSCube(element),\n MMLCylinderGraphicsInterface: (element) => new ThreeJSElements.ThreeJSCylinder(element),\n MMLFrameGraphicsInterface: (element) => new ThreeJSElements.ThreeJSFrame(element),\n MMLImageGraphicsInterface: (element, updateMeshCallback) =>\n new ThreeJSElements.ThreeJSImage(element, updateMeshCallback),\n MMLInteractionGraphicsInterface: (element) => new ThreeJSElements.ThreeJSInteraction(element),\n MMLLabelGraphicsInterface: (element) => new ThreeJSElements.ThreeJSLabel(element),\n MMLLightGraphicsInterface: (element) => new ThreeJSElements.ThreeJSLight(element),\n MMLLinkGraphicsInterface: (element) => new ThreeJSElements.ThreeJSLink(element),\n MMLModelGraphicsInterface: (element, updateMeshCallback) =>\n new ThreeJSElements.ThreeJSModel(element, updateMeshCallback),\n MMLPlaneGraphicsInterface: (element) => new ThreeJSElements.ThreeJSPlane(element),\n MMLPositionProbeGraphicsInterface: (element) => new ThreeJSElements.ThreeJSPositionProbe(element),\n MMLPromptGraphicsInterface: (element) => new ThreeJSElements.ThreeJSPrompt(element),\n MMLSphereGraphicsInterface: (element) => new ThreeJSElements.ThreeJSSphere(element),\n MMLTransformableGraphicsInterface: (element) => new ThreeJSElements.ThreeJSTransformable(element),\n MMLVideoGraphicsInterface: (element, updateMeshCallback: () => void) =>\n new ThreeJSElements.ThreeJSVideo(element, updateMeshCallback),\n RemoteDocumentGraphicsInterface: (element) => new ThreeJSElements.ThreeJSRemoteDocument(element),\n};\n", "import { Interaction } from \"@mml-io/mml-web\";\nimport * as THREE from \"three\";\n\nimport { ThreeJSGraphicsAdapter } from \"./ThreeJSGraphicsAdapter\";\n\nexport class ThreeJSInteractionAdapter {\n private static worldPos = new THREE.Vector3();\n\n private static matrix = new THREE.Matrix4();\n private static frustum = new THREE.Frustum();\n\n private static raycaster = new THREE.Raycaster();\n private static intersections = new Array>();\n private static direction = new THREE.Vector3();\n\n static interactionShouldShowDistance(\n interaction: Interaction,\n camera: THREE.Camera,\n scene: THREE.Scene,\n ): number | null {\n const worldPos = interaction\n .getContainer()\n .getWorldPosition(ThreeJSInteractionAdapter.worldPos);\n\n const cameraPos = camera.position;\n const distance = cameraPos.distanceTo(worldPos);\n if (distance > interaction.props.range) {\n return null;\n }\n\n if (interaction.props.inFocus) {\n ThreeJSInteractionAdapter.matrix.multiplyMatrices(\n camera.projectionMatrix,\n camera.matrixWorldInverse,\n );\n ThreeJSInteractionAdapter.frustum.setFromProjectionMatrix(ThreeJSInteractionAdapter.matrix);\n if (!ThreeJSInteractionAdapter.frustum.containsPoint(worldPos)) {\n return null;\n }\n }\n\n if (interaction.props.lineOfSight) {\n const raycastResults = ThreeJSInteractionAdapter.getRaycastResults(\n cameraPos,\n worldPos,\n distance,\n scene,\n );\n if (raycastResults.length > 0) {\n for (const result of raycastResults) {\n if (!ThreeJSInteractionAdapter.hasAncestor(result.object, interaction.getContainer())) {\n return null;\n }\n }\n }\n }\n\n return distance;\n }\n\n static getRaycastResults(\n a: THREE.Vector3,\n b: THREE.Vector3,\n distance: number,\n scene: THREE.Scene,\n ) {\n ThreeJSInteractionAdapter.direction.copy(b);\n ThreeJSInteractionAdapter.direction.sub(a);\n ThreeJSInteractionAdapter.direction.normalize();\n\n ThreeJSInteractionAdapter.raycaster.set(a, ThreeJSInteractionAdapter.direction);\n ThreeJSInteractionAdapter.raycaster.near = 0;\n ThreeJSInteractionAdapter.raycaster.far = distance;\n\n ThreeJSInteractionAdapter.intersections.length = 0;\n ThreeJSInteractionAdapter.raycaster.intersectObject(\n scene,\n true,\n ThreeJSInteractionAdapter.intersections,\n );\n return ThreeJSInteractionAdapter.intersections;\n }\n\n static hasAncestor(object: THREE.Object3D, ancestor: THREE.Object3D): boolean {\n let parent = object.parent;\n while (parent !== null) {\n if (parent === ancestor) {\n return true;\n }\n parent = parent.parent;\n }\n return false;\n }\n}\n", "import { EventHandlerCollection, IVect3, Matr4, Quat } from \"@mml-io/mml-web\";\nimport { PerspectiveCamera, Vector3 } from \"three\";\n\nimport { ThreeJSControls } from \"./ThreeJSControls\";\n\nconst up = { x: 0, y: 1, z: 0 };\nconst right = { x: 1, y: 0, z: 0 };\nconst quaternion = new Quat();\nconst qPitch = new Quat();\nconst qYaw = new Quat();\n\nconst tempVector = new Vector3();\n\n// Creates a set of 5DOF flight controls that requires dragging the mouse to move the rotation and position of the camera\nexport class ThreeJSDragFlyCameraControls implements ThreeJSControls {\n public readonly type = \"drag-fly\";\n\n private enabled = false;\n\n private yaw = 0;\n private pitch = 0;\n\n private forward = false;\n private backward = false;\n private left = false;\n private right = false;\n private up = false;\n private down = false;\n\n // Set to constrain the pitch of the camera\n private minPolarAngle = 0 * (Math.PI / 180);\n private maxPolarAngle = 180 * (Math.PI / 180);\n\n private invertedMouseY = false;\n\n private eventHandlerCollection: EventHandlerCollection = new EventHandlerCollection();\n private mouseDown = false;\n\n constructor(\n private camera: PerspectiveCamera,\n private domElement: HTMLElement,\n private speed = 15.0,\n ) {\n this.domElement.style.userSelect = \"none\";\n }\n\n public fitContent(boundingBox: { min: IVect3; max: IVect3 }) {\n const center = {\n x: (boundingBox.min.x + boundingBox.max.x) / 2,\n y: (boundingBox.min.y + boundingBox.max.y) / 2,\n z: (boundingBox.min.z + boundingBox.max.z) / 2,\n };\n const size = {\n x: boundingBox.max.x - boundingBox.min.x,\n y: boundingBox.max.y - boundingBox.min.y,\n z: boundingBox.max.z - boundingBox.min.z,\n };\n const fov = this.camera.fov;\n const maximumDimension = Math.max(size.x, size.y, size.z);\n const distance = Math.abs(maximumDimension / 4 / Math.tan(fov / 2));\n const currentCameraRay = this.camera.getWorldDirection(new Vector3()).normalize();\n currentCameraRay.multiplyScalar(-distance);\n this.camera.position.set(\n center.x + currentCameraRay.x,\n center.y + currentCameraRay.y,\n center.z + currentCameraRay.z,\n );\n this.setLookAt(center.x, center.y, center.z);\n }\n\n public enable() {\n if (this.enabled) {\n return;\n }\n this.enabled = true;\n this.eventHandlerCollection.add(document, \"keydown\", this.onKeyDown.bind(this));\n this.eventHandlerCollection.add(document, \"keyup\", this.onKeyUp.bind(this));\n this.eventHandlerCollection.add(window, \"blur\", this.onBlur.bind(this));\n this.eventHandlerCollection.add(document, \"mousemove\", this.onMouseMove.bind(this));\n this.eventHandlerCollection.add(this.domElement, \"mousedown\", this.onMouseDown.bind(this));\n this.eventHandlerCollection.add(document, \"mouseup\", this.onMouseUp.bind(this));\n this.eventHandlerCollection.add(document, \"wheel\", this.onMouseWheel.bind(this));\n }\n\n public disable() {\n if (!this.enabled) {\n return;\n }\n this.eventHandlerCollection.clear();\n this.enabled = false;\n }\n\n public setInvert(invert: boolean) {\n this.invertedMouseY = invert;\n }\n\n public dispose() {\n this.disable();\n }\n\n public update(dt: number) {\n if (!this.mouseDown) {\n return;\n }\n\n tempVector.set(\n (Number(this.right) - Number(this.left)) * dt * 30,\n (Number(this.up) - Number(this.down)) * dt * 30,\n (Number(this.backward) - Number(this.forward)) * dt * 30,\n );\n tempVector.applyQuaternion(this.camera.quaternion);\n this.camera.position.add(tempVector);\n }\n\n private onKeyDown(event: KeyboardEvent) {\n if (!this.mouseDown) {\n return;\n }\n switch (event.code) {\n case \"ArrowUp\":\n case \"KeyW\":\n this.forward = true;\n break;\n case \"ArrowLeft\":\n case \"KeyA\":\n this.left = true;\n break;\n case \"ArrowDown\":\n case \"KeyS\":\n this.backward = true;\n break;\n case \"ArrowRight\":\n case \"KeyD\":\n this.right = true;\n break;\n case \"Space\":\n this.up = true;\n break;\n case \"ShiftLeft\":\n this.down = true;\n break;\n }\n event.preventDefault();\n }\n\n private onKeyUp(event: KeyboardEvent) {\n switch (event.code) {\n case \"ArrowUp\":\n case \"KeyW\":\n this.forward = false;\n break;\n case \"ArrowLeft\":\n case \"KeyA\":\n this.left = false;\n break;\n case \"ArrowDown\":\n case \"KeyS\":\n this.backward = false;\n break;\n case \"ArrowRight\":\n case \"KeyD\":\n this.right = false;\n break;\n case \"Space\":\n this.up = false;\n break;\n case \"ShiftLeft\":\n this.down = false;\n break;\n }\n }\n\n private onBlur() {\n this.mouseDown = false;\n this.forward = false;\n this.left = false;\n this.backward = false;\n this.right = false;\n this.up = false;\n this.down = false;\n }\n\n private onMouseDown() {\n this.mouseDown = true;\n }\n\n public setCameraPosition(x: number, y: number, z: number) {\n this.camera.position.set(x, y, z);\n }\n\n public setLookAt(x: number, y: number, z: number) {\n this.camera.lookAt(new Vector3(x, y, z));\n const q1 = new Quat().setFromEulerXYZ(this.camera.rotation);\n const { yaw, pitch } = getYawPitchFromQuaternion(q1);\n this.yaw = yaw;\n this.pitch = pitch;\n this.updateCameraFromYawAndPitch();\n }\n\n private onMouseMove(event: MouseEvent) {\n if (!this.mouseDown) {\n return;\n }\n const movementX = event.movementX;\n let movementY = event.movementY;\n\n if (this.invertedMouseY) {\n movementY *= -1;\n }\n\n this.yaw += movementX * -0.002;\n this.pitch += movementY * -0.002;\n\n this.updateCameraFromYawAndPitch();\n }\n\n private updateCameraFromYawAndPitch() {\n this.yaw = this.yaw % (Math.PI * 2);\n this.pitch = this.pitch % (Math.PI * 2);\n this.pitch = Math.max(\n Math.PI / 2 - this.maxPolarAngle,\n Math.min(Math.PI / 2 - this.minPolarAngle, this.pitch),\n );\n\n qPitch.setFromAxisAngle(right, this.pitch);\n qYaw.setFromAxisAngle(up, this.yaw);\n\n quaternion.set(0, 0, 0, 1);\n quaternion.multiply(qYaw);\n quaternion.multiply(qPitch);\n\n this.camera.quaternion.set(quaternion.x, quaternion.y, quaternion.z, quaternion.w);\n }\n\n private onMouseUp() {\n this.mouseDown = false;\n }\n\n private onMouseWheel(event: WheelEvent) {\n if (!this.mouseDown) {\n return;\n }\n this.speed -= event.deltaY * 0.1;\n\n // restrict to a reasonable min and max\n this.speed = Math.max(5, Math.min(this.speed, 1000));\n }\n}\n\nfunction clamp(value: number, min: number, max: number) {\n return Math.max(min, Math.min(max, value));\n}\n\nfunction getYawPitchFromQuaternion(quaternion: Quat) {\n const matr4 = new Matr4();\n matr4.setRotationFromQuaternion(quaternion);\n\n const d = matr4.data;\n const m11 = d[0];\n const m13 = d[8];\n const m23 = d[9];\n const m31 = d[2];\n const m33 = d[10];\n\n const yaw = Math.abs(m23) < 0.9999999 ? Math.atan2(m13, m33) : Math.atan2(-m31, m11);\n const pitch = Math.asin(-clamp(m23, -1, 1));\n return { yaw, pitch };\n}\n", "import { EventHandlerCollection, IVect3 } from \"@mml-io/mml-web\";\nimport { PerspectiveCamera, Spherical, Vector3 } from \"three\";\n\nimport { ThreeJSControls } from \"./ThreeJSControls\";\n\nconst tempSpherical = new Spherical();\n\nexport class ThreeJSOrbitCameraControls implements ThreeJSControls {\n public readonly type = \"orbit\";\n\n private enabled = false;\n\n private degreesPerSecond = 10;\n private yaw = 0;\n private pitch = Math.PI * 0.4;\n\n // Set to constrain the pitch of the camera\n private minPolarAngle = -89.9999 * (Math.PI / 180);\n private maxPolarAngle = 89.9999 * (Math.PI / 180);\n\n private invertedMouseY = false;\n\n private eventHandlerCollection: EventHandlerCollection = new EventHandlerCollection();\n private mouseDown = false;\n private cameraLookAt: Vector3 = new Vector3();\n\n constructor(\n private camera: PerspectiveCamera,\n private domElement: HTMLElement,\n private distance = 15.0,\n ) {\n this.domElement.style.userSelect = \"none\";\n }\n\n public fitContent(boundingBox: { min: IVect3; max: IVect3 }) {\n const center = {\n x: (boundingBox.min.x + boundingBox.max.x) / 2,\n y: (boundingBox.min.y + boundingBox.max.y) / 2,\n z: (boundingBox.min.z + boundingBox.max.z) / 2,\n };\n const size = {\n x: boundingBox.max.x - boundingBox.min.x,\n y: boundingBox.max.y - boundingBox.min.y,\n z: boundingBox.max.z - boundingBox.min.z,\n };\n const fov = this.camera.fov || 1;\n const maximumDimension = Math.max(size.x, size.y, size.z);\n this.distance = Math.abs(maximumDimension / 4 / Math.tan(fov / 2));\n this.setLookAt(center.x, center.y, center.z);\n this.update();\n }\n\n public enable() {\n if (this.enabled) {\n return;\n }\n this.enabled = true;\n this.eventHandlerCollection.add(window, \"blur\", this.onBlur.bind(this));\n this.eventHandlerCollection.add(document, \"mousemove\", this.onMouseMove.bind(this));\n this.eventHandlerCollection.add(this.domElement, \"mousedown\", this.onMouseDown.bind(this));\n this.eventHandlerCollection.add(document, \"mouseup\", this.onMouseUp.bind(this));\n this.eventHandlerCollection.add(document, \"wheel\", this.onMouseWheel.bind(this));\n }\n\n public disable() {\n if (!this.enabled) {\n return;\n }\n this.eventHandlerCollection.clear();\n this.enabled = false;\n }\n\n public setInvert(invert: boolean) {\n this.invertedMouseY = invert;\n }\n\n public dispose() {\n this.disable();\n }\n\n private getBaseYaw(): number {\n return (-((Date.now() / 1000) * this.degreesPerSecond) % 360) * (Math.PI / 180);\n }\n\n public update() {\n const baseYaw = this.getBaseYaw();\n const yaw = baseYaw + this.yaw;\n\n tempSpherical.set(this.distance, this.pitch, yaw);\n this.camera.position.setFromSpherical(tempSpherical);\n this.camera.position.add(this.cameraLookAt);\n\n this.camera.lookAt(this.cameraLookAt.x, this.cameraLookAt.y, this.cameraLookAt.z);\n }\n\n private onBlur() {\n this.mouseDown = false;\n }\n\n private onMouseDown() {\n this.mouseDown = true;\n }\n\n public setDegreesPerSecond(degreesPerSecond: number) {\n this.degreesPerSecond = degreesPerSecond;\n }\n\n public setLookAt(x: number, y: number, z: number) {\n this.cameraLookAt.set(x, y, z);\n }\n\n public setDistance(distance: number) {\n this.distance = distance;\n }\n\n public setPitchDegrees(pitch: number) {\n this.pitch = pitch * (Math.PI / 180);\n this.pitch = this.pitch % (Math.PI * 2);\n }\n\n private onMouseMove(event: MouseEvent) {\n if (!this.mouseDown) {\n return;\n }\n const movementX = event.movementX;\n let movementY = event.movementY;\n\n if (this.invertedMouseY) {\n movementY *= -1;\n }\n\n this.yaw += movementX * -0.002;\n this.pitch += movementY * -0.002;\n this.yaw = this.yaw % (Math.PI * 2);\n this.pitch = this.pitch % (Math.PI * 2);\n this.pitch = Math.max(\n Math.PI / 2 - this.maxPolarAngle,\n Math.min(Math.PI / 2 - this.minPolarAngle, this.pitch),\n );\n }\n private onMouseUp() {\n this.mouseDown = false;\n }\n\n private onMouseWheel(event: WheelEvent) {\n this.distance += event.deltaY * 0.1;\n this.distance = Math.max(0.01, Math.min(this.distance, 1000));\n }\n}\n", "import { Interaction, MElement, MMLGraphicsInterface, radToDeg } from \"@mml-io/mml-web\";\nimport {\n ThreeJSClickTrigger,\n ThreeJSGraphicsAdapter,\n ThreeJSGraphicsInterface,\n ThreeJSInteractionAdapter,\n} from \"@mml-io/mml-web-threejs\";\nimport * as THREE from \"three\";\n\nimport { ThreeJSControls } from \"./controls/ThreeJSControls\";\nimport { ThreeJSDragFlyCameraControls } from \"./controls/ThreeJSDragFlyCameraControls\";\nimport { ThreeJSOrbitCameraControls } from \"./controls/ThreeJSOrbitCameraControls\";\n\nexport enum StandaloneThreeJSAdapterControlsType {\n None,\n DragFly,\n Orbit,\n}\n\nexport type StandaloneThreeJSAdapterOptions = {\n controlsType?: StandaloneThreeJSAdapterControlsType;\n};\n\nexport class StandaloneThreeJSAdapter implements ThreeJSGraphicsAdapter {\n collisionType: THREE.Object3D;\n containerType: THREE.Object3D;\n\n private rootContainer: THREE.Object3D;\n private threeScene: THREE.Scene;\n private camera: THREE.PerspectiveCamera;\n private renderer: THREE.WebGLRenderer;\n private audioListener: THREE.AudioListener;\n private animationFrameCallback: () => void;\n private animationFrameRequest: number;\n private clickTrigger: ThreeJSClickTrigger;\n public controls: ThreeJSControls | null = null;\n\n private constructor(\n private element: HTMLElement,\n private options: StandaloneThreeJSAdapterOptions,\n ) {}\n\n public static async create(\n element: HTMLElement,\n options: StandaloneThreeJSAdapterOptions,\n ): Promise {\n const adapter = new StandaloneThreeJSAdapter(element, options);\n await adapter.init();\n return adapter;\n }\n\n public interactionShouldShowDistance(interaction: Interaction): number | null {\n return ThreeJSInteractionAdapter.interactionShouldShowDistance(\n interaction,\n this.camera,\n this.threeScene,\n );\n }\n\n getThreeScene(): THREE.Scene {\n return this.threeScene;\n }\n\n getRenderer(): THREE.WebGLRenderer {\n return this.renderer;\n }\n\n public setCameraFOV(fov: number) {\n this.camera.fov = fov;\n this.camera.updateProjectionMatrix();\n }\n\n public getGraphicsAdapterFactory(): MMLGraphicsInterface {\n return ThreeJSGraphicsInterface as MMLGraphicsInterface;\n }\n\n async init(): Promise {\n return new Promise((resolve) => {\n this.rootContainer = new THREE.Group();\n this.threeScene = new THREE.Scene();\n this.threeScene.add(this.rootContainer);\n\n this.camera = new THREE.PerspectiveCamera(\n 75,\n window.innerWidth / window.innerHeight,\n 0.01,\n 1000,\n );\n this.clickTrigger = ThreeJSClickTrigger.init(this.element, this.rootContainer, this.camera);\n\n this.renderer = this.createRenderer();\n\n this.audioListener = new THREE.AudioListener();\n if (this.audioListener.context.state === \"suspended\") {\n const resumeAudio = () => {\n this.audioListener.context.resume();\n document.removeEventListener(\"click\", resumeAudio);\n document.removeEventListener(\"touchstart\", resumeAudio);\n };\n document.addEventListener(\"click\", resumeAudio);\n document.addEventListener(\"touchstart\", resumeAudio);\n }\n this.camera.add(this.audioListener);\n this.camera.position.z = 10;\n this.camera.position.y = 5;\n\n THREE.Cache.enabled = true;\n\n this.setControlsType(this.options.controlsType);\n\n const clock = new THREE.Clock();\n this.animationFrameCallback = () => {\n this.animationFrameRequest = requestAnimationFrame(this.animationFrameCallback);\n if (this.controls) {\n this.controls.update(clock.getDelta());\n }\n this.renderer.render(this.threeScene, this.camera);\n };\n this.element.appendChild(this.renderer.domElement);\n resolve();\n });\n }\n\n public setControlsType(type?: StandaloneThreeJSAdapterControlsType) {\n if (this.controls) {\n this.controls.dispose();\n this.controls = null;\n }\n switch (type) {\n case StandaloneThreeJSAdapterControlsType.None:\n break;\n case StandaloneThreeJSAdapterControlsType.Orbit:\n this.controls = new ThreeJSOrbitCameraControls(this.camera, this.element);\n break;\n case StandaloneThreeJSAdapterControlsType.DragFly:\n default:\n this.controls = new ThreeJSDragFlyCameraControls(this.camera, this.element);\n break;\n }\n if (this.controls) {\n this.controls.enable();\n }\n }\n\n private createRenderer() {\n let renderer;\n if (navigator.userAgent.includes(\"jsdom\")) {\n renderer = {\n domElement: document.createElement(\"canvas\"),\n setSize: () => void 0,\n render: () => void 0,\n } as unknown as THREE.WebGLRenderer;\n } else {\n renderer = new THREE.WebGLRenderer({ antialias: true, alpha: true });\n renderer.setPixelRatio(window.devicePixelRatio);\n renderer.outputColorSpace = THREE.SRGBColorSpace;\n renderer.shadowMap.enabled = true;\n renderer.shadowMap.type = THREE.PCFSoftShadowMap;\n }\n renderer.domElement.style.pointerEvents = \"none\";\n return renderer;\n }\n\n start() {\n this.animationFrameRequest = requestAnimationFrame(this.animationFrameCallback);\n }\n\n getUserPositionAndRotation() {\n const position = this.camera.position;\n const rotation = this.camera.rotation;\n return {\n position: {\n x: position.x,\n y: position.y,\n z: position.z,\n },\n rotation: {\n x: radToDeg(rotation.x),\n y: radToDeg(rotation.y),\n z: radToDeg(rotation.z),\n },\n };\n }\n\n public getAudioListener() {\n return this.audioListener;\n }\n\n resize(width: number, height: number) {\n this.camera.aspect = width / height;\n this.camera.updateProjectionMatrix();\n this.renderer.setSize(width, height);\n }\n\n dispose() {\n this.clickTrigger.dispose();\n if (this.controls) {\n this.controls.dispose();\n this.controls = null;\n }\n cancelAnimationFrame(this.animationFrameRequest);\n }\n\n getRootContainer() {\n return this.rootContainer;\n }\n\n getCamera() {\n return this.camera;\n }\n\n public getBoundingBoxForElement(element: HTMLElement): {\n x: number;\n y: number;\n width: number;\n height: number;\n } | null {\n const camera = this.camera;\n const renderer = this.renderer;\n\n if (!(element instanceof MElement)) {\n return null;\n }\n\n const object = element.getContainer();\n\n // Create a Box3 for the 3D bounding box\n const box3 = new THREE.Box3().setFromObject(object);\n\n // Custom function to convert 3D Vector3 to 2D canvas coordinates\n const toCanvasCoords = (point: THREE.Vector3) => {\n const vec = point.clone().project(camera);\n vec.x = ((vec.x + 1) / 2) * renderer.domElement.clientWidth;\n vec.y = ((-vec.y + 1) / 2) * renderer.domElement.clientHeight;\n return vec;\n };\n\n // Project the 3D bounding box corners into 2D canvas coordinates\n const corners3D = [\n new THREE.Vector3(box3.min.x, box3.min.y, box3.min.z),\n new THREE.Vector3(box3.max.x, box3.min.y, box3.min.z),\n new THREE.Vector3(box3.max.x, box3.min.y, box3.max.z),\n new THREE.Vector3(box3.min.x, box3.min.y, box3.max.z),\n new THREE.Vector3(box3.min.x, box3.max.y, box3.min.z),\n new THREE.Vector3(box3.max.x, box3.max.y, box3.min.z),\n new THREE.Vector3(box3.max.x, box3.max.y, box3.max.z),\n new THREE.Vector3(box3.min.x, box3.max.y, box3.max.z),\n ];\n const corners2D = corners3D.map(toCanvasCoords);\n\n // Calculate the 2D bounding box from the projected canvas coordinates\n const minX = Math.min(...corners2D.map((corner) => corner.x));\n const maxX = Math.max(...corners2D.map((corner) => corner.x));\n const minY = Math.min(...corners2D.map((corner) => corner.y));\n const maxY = Math.max(...corners2D.map((corner) => corner.y));\n\n return {\n x: minX,\n y: minY,\n width: maxX - minX,\n height: maxY - minY,\n };\n }\n}\n", "/**\n * @monogrid/gainmap-js v3.0.6\n * With \u2764\uFE0F, by MONOGRID \n */\n\nimport { RGBAFormat, LinearFilter, ClampToEdgeWrapping, Scene, OrthographicCamera, HalfFloatType, FloatType, Mesh, PlaneGeometry, WebGLRenderTarget, UVMapping, WebGLRenderer, DataTexture, LinearSRGBColorSpace, ShaderMaterial, Texture, IntType, ShortType, ByteType, UnsignedIntType, UnsignedByteType, MeshBasicMaterial } from 'three';\n\nconst getBufferForType = (type, width, height) => {\n let out;\n switch (type) {\n case UnsignedByteType:\n out = new Uint8ClampedArray(width * height * 4);\n break;\n case HalfFloatType:\n out = new Uint16Array(width * height * 4);\n break;\n case UnsignedIntType:\n out = new Uint32Array(width * height * 4);\n break;\n case ByteType:\n out = new Int8Array(width * height * 4);\n break;\n case ShortType:\n out = new Int16Array(width * height * 4);\n break;\n case IntType:\n out = new Int32Array(width * height * 4);\n break;\n case FloatType:\n out = new Float32Array(width * height * 4);\n break;\n default:\n throw new Error('Unsupported data type');\n }\n return out;\n};\nlet _canReadPixelsResult;\n/**\n * Test if this browser implementation can correctly read pixels from the specified\n * Render target type.\n *\n * Runs only once\n *\n * @param type\n * @param renderer\n * @param camera\n * @param renderTargetOptions\n * @returns\n */\nconst canReadPixels = (type, renderer, camera, renderTargetOptions) => {\n if (_canReadPixelsResult !== undefined)\n return _canReadPixelsResult;\n const testRT = new WebGLRenderTarget(1, 1, renderTargetOptions);\n renderer.setRenderTarget(testRT);\n const mesh = new Mesh(new PlaneGeometry(), new MeshBasicMaterial({ color: 0xffffff }));\n renderer.render(mesh, camera);\n renderer.setRenderTarget(null);\n const out = getBufferForType(type, testRT.width, testRT.height);\n renderer.readRenderTargetPixels(testRT, 0, 0, testRT.width, testRT.height, out);\n testRT.dispose();\n mesh.geometry.dispose();\n mesh.material.dispose();\n _canReadPixelsResult = out[0] !== 0;\n return _canReadPixelsResult;\n};\n/**\n * Utility class used for rendering a texture with a material\n *\n * @category Core\n * @group Core\n */\nclass QuadRenderer {\n /**\n * Constructs a new QuadRenderer\n *\n * @param options Parameters for this QuadRenderer\n */\n constructor(options) {\n var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;\n this._rendererIsDisposable = false;\n this._supportsReadPixels = true;\n /**\n * Renders the input texture using the specified material\n */\n this.render = () => {\n this._renderer.setRenderTarget(this._renderTarget);\n try {\n this._renderer.render(this._scene, this._camera);\n }\n catch (e) {\n this._renderer.setRenderTarget(null);\n throw e;\n }\n this._renderer.setRenderTarget(null);\n };\n this._width = options.width;\n this._height = options.height;\n this._type = options.type;\n this._colorSpace = options.colorSpace;\n const rtOptions = {\n // fixed options\n format: RGBAFormat,\n depthBuffer: false,\n stencilBuffer: false,\n // user options\n type: this._type, // set in class property\n colorSpace: this._colorSpace, // set in class property\n anisotropy: ((_a = options.renderTargetOptions) === null || _a === void 0 ? void 0 : _a.anisotropy) !== undefined ? (_b = options.renderTargetOptions) === null || _b === void 0 ? void 0 : _b.anisotropy : 1,\n generateMipmaps: ((_c = options.renderTargetOptions) === null || _c === void 0 ? void 0 : _c.generateMipmaps) !== undefined ? (_d = options.renderTargetOptions) === null || _d === void 0 ? void 0 : _d.generateMipmaps : false,\n magFilter: ((_e = options.renderTargetOptions) === null || _e === void 0 ? void 0 : _e.magFilter) !== undefined ? (_f = options.renderTargetOptions) === null || _f === void 0 ? void 0 : _f.magFilter : LinearFilter,\n minFilter: ((_g = options.renderTargetOptions) === null || _g === void 0 ? void 0 : _g.minFilter) !== undefined ? (_h = options.renderTargetOptions) === null || _h === void 0 ? void 0 : _h.minFilter : LinearFilter,\n samples: ((_j = options.renderTargetOptions) === null || _j === void 0 ? void 0 : _j.samples) !== undefined ? (_k = options.renderTargetOptions) === null || _k === void 0 ? void 0 : _k.samples : undefined,\n wrapS: ((_l = options.renderTargetOptions) === null || _l === void 0 ? void 0 : _l.wrapS) !== undefined ? (_m = options.renderTargetOptions) === null || _m === void 0 ? void 0 : _m.wrapS : ClampToEdgeWrapping,\n wrapT: ((_o = options.renderTargetOptions) === null || _o === void 0 ? void 0 : _o.wrapT) !== undefined ? (_p = options.renderTargetOptions) === null || _p === void 0 ? void 0 : _p.wrapT : ClampToEdgeWrapping\n };\n this._material = options.material;\n if (options.renderer) {\n this._renderer = options.renderer;\n }\n else {\n this._renderer = QuadRenderer.instantiateRenderer();\n this._rendererIsDisposable = true;\n }\n this._scene = new Scene();\n this._camera = new OrthographicCamera();\n this._camera.position.set(0, 0, 10);\n this._camera.left = -0.5;\n this._camera.right = 0.5;\n this._camera.top = 0.5;\n this._camera.bottom = -0.5;\n this._camera.updateProjectionMatrix();\n if (!canReadPixels(this._type, this._renderer, this._camera, rtOptions)) {\n let alternativeType;\n switch (this._type) {\n case HalfFloatType:\n alternativeType = this._renderer.extensions.has('EXT_color_buffer_float') ? FloatType : undefined;\n break;\n }\n if (alternativeType !== undefined) {\n console.warn(`This browser does not support reading pixels from ${this._type} RenderTargets, switching to ${FloatType}`);\n this._type = alternativeType;\n }\n else {\n this._supportsReadPixels = false;\n console.warn('This browser dos not support toArray or toDataTexture, calls to those methods will result in an error thrown');\n }\n }\n this._quad = new Mesh(new PlaneGeometry(), this._material);\n this._quad.geometry.computeBoundingBox();\n this._scene.add(this._quad);\n this._renderTarget = new WebGLRenderTarget(this.width, this.height, rtOptions);\n this._renderTarget.texture.mapping = ((_q = options.renderTargetOptions) === null || _q === void 0 ? void 0 : _q.mapping) !== undefined ? (_r = options.renderTargetOptions) === null || _r === void 0 ? void 0 : _r.mapping : UVMapping;\n }\n /**\n * Instantiates a temporary renderer\n *\n * @returns\n */\n static instantiateRenderer() {\n const renderer = new WebGLRenderer();\n renderer.setSize(128, 128);\n // renderer.outputColorSpace = SRGBColorSpace\n // renderer.toneMapping = LinearToneMapping\n // renderer.debug.checkShaderErrors = false\n // this._rendererIsDisposable = true\n return renderer;\n }\n /**\n * Obtains a Buffer containing the rendered texture.\n *\n * @throws Error if the browser cannot read pixels from this RenderTarget type.\n * @returns a TypedArray containing RGBA values from this renderer\n */\n toArray() {\n if (!this._supportsReadPixels)\n throw new Error('Can\\'t read pixels in this browser');\n const out = getBufferForType(this._type, this._width, this._height);\n this._renderer.readRenderTargetPixels(this._renderTarget, 0, 0, this._width, this._height, out);\n return out;\n }\n /**\n * Performs a readPixel operation in the renderTarget\n * and returns a DataTexture containing the read data\n *\n * @param options options\n * @returns\n */\n toDataTexture(options) {\n const returnValue = new DataTexture(\n // fixed values\n this.toArray(), this.width, this.height, RGBAFormat, this._type, \n // user values\n (options === null || options === void 0 ? void 0 : options.mapping) || UVMapping, (options === null || options === void 0 ? void 0 : options.wrapS) || ClampToEdgeWrapping, (options === null || options === void 0 ? void 0 : options.wrapT) || ClampToEdgeWrapping, (options === null || options === void 0 ? void 0 : options.magFilter) || LinearFilter, (options === null || options === void 0 ? void 0 : options.minFilter) || LinearFilter, (options === null || options === void 0 ? void 0 : options.anisotropy) || 1, \n // fixed value\n LinearSRGBColorSpace);\n // set this afterwards, we can't set it in constructor\n returnValue.generateMipmaps = (options === null || options === void 0 ? void 0 : options.generateMipmaps) !== undefined ? options === null || options === void 0 ? void 0 : options.generateMipmaps : false;\n return returnValue;\n }\n /**\n * If using a disposable renderer, it will dispose it.\n */\n disposeOnDemandRenderer() {\n this._renderer.setRenderTarget(null);\n if (this._rendererIsDisposable) {\n this._renderer.dispose();\n this._renderer.forceContextLoss();\n }\n }\n /**\n * Will dispose of **all** assets used by this renderer.\n *\n *\n * @param disposeRenderTarget will dispose of the renderTarget which will not be usable later\n * set this to true if you passed the `renderTarget.texture` to a `PMREMGenerator`\n * or are otherwise done with it.\n *\n * @example\n * ```js\n * const loader = new HDRJPGLoader(renderer)\n * const result = await loader.loadAsync('gainmap.jpeg')\n * const mesh = new Mesh(geometry, new MeshBasicMaterial({ map: result.renderTarget.texture }) )\n * // DO NOT dispose the renderTarget here,\n * // it is used directly in the material\n * result.dispose()\n * ```\n *\n * @example\n * ```js\n * const loader = new HDRJPGLoader(renderer)\n * const pmremGenerator = new PMREMGenerator( renderer );\n * const result = await loader.loadAsync('gainmap.jpeg')\n * const envMap = pmremGenerator.fromEquirectangular(result.renderTarget.texture)\n * const mesh = new Mesh(geometry, new MeshStandardMaterial({ envMap }) )\n * // renderTarget can be disposed here\n * // because it was used to generate a PMREM texture\n * result.dispose(true)\n * ```\n */\n dispose(disposeRenderTarget) {\n this.disposeOnDemandRenderer();\n if (disposeRenderTarget) {\n this.renderTarget.dispose();\n }\n // dispose shader material texture uniforms\n if (this.material instanceof ShaderMaterial) {\n Object.values(this.material.uniforms).forEach(v => {\n if (v.value instanceof Texture)\n v.value.dispose();\n });\n }\n // dispose other material properties\n Object.values(this.material).forEach(value => {\n if (value instanceof Texture)\n value.dispose();\n });\n this.material.dispose();\n this._quad.geometry.dispose();\n }\n /**\n * Width of the texture\n */\n get width() { return this._width; }\n set width(value) {\n this._width = value;\n this._renderTarget.setSize(this._width, this._height);\n }\n /**\n * Height of the texture\n */\n get height() { return this._height; }\n set height(value) {\n this._height = value;\n this._renderTarget.setSize(this._width, this._height);\n }\n /**\n * The renderer used\n */\n get renderer() { return this._renderer; }\n /**\n * The `WebGLRenderTarget` used.\n */\n get renderTarget() { return this._renderTarget; }\n set renderTarget(value) {\n this._renderTarget = value;\n this._width = value.width;\n this._height = value.height;\n // this._type = value.texture.type\n }\n /**\n * The `Material` used.\n */\n get material() { return this._material; }\n /**\n *\n */\n get type() { return this._type; }\n get colorSpace() { return this._colorSpace; }\n}\n\nexport { QuadRenderer as Q };\n", "/**\n * @monogrid/gainmap-js v3.0.6\n * With \u2764\uFE0F, by MONOGRID \n */\n\nimport { Q as QuadRenderer } from './QuadRenderer-B3h-sJtp.js';\nimport { ShaderMaterial, Vector3, NoBlending, SRGBColorSpace, LinearSRGBColorSpace, HalfFloatType, Loader, LoadingManager, Texture, UVMapping, ClampToEdgeWrapping, LinearFilter, LinearMipMapLinearFilter, RGBAFormat, UnsignedByteType, FileLoader } from 'three';\n\nconst vertexShader = /* glsl */ `\nvarying vec2 vUv;\n\nvoid main() {\n vUv = uv;\n gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);\n}\n`;\nconst fragmentShader = /* glsl */ `\n// min half float value\n#define HALF_FLOAT_MIN vec3( -65504, -65504, -65504 )\n// max half float value\n#define HALF_FLOAT_MAX vec3( 65504, 65504, 65504 )\n\nuniform sampler2D sdr;\nuniform sampler2D gainMap;\nuniform vec3 gamma;\nuniform vec3 offsetHdr;\nuniform vec3 offsetSdr;\nuniform vec3 gainMapMin;\nuniform vec3 gainMapMax;\nuniform float weightFactor;\n\nvarying vec2 vUv;\n\nvoid main() {\n vec3 rgb = texture2D( sdr, vUv ).rgb;\n vec3 recovery = texture2D( gainMap, vUv ).rgb;\n vec3 logRecovery = pow( recovery, gamma );\n vec3 logBoost = gainMapMin * ( 1.0 - logRecovery ) + gainMapMax * logRecovery;\n vec3 hdrColor = (rgb + offsetSdr) * exp2( logBoost * weightFactor ) - offsetHdr;\n vec3 clampedHdrColor = max( HALF_FLOAT_MIN, min( HALF_FLOAT_MAX, hdrColor ));\n gl_FragColor = vec4( clampedHdrColor , 1.0 );\n}\n`;\n/**\n * A Material which is able to decode the Gainmap into a full HDR Representation\n *\n * @category Materials\n * @group Materials\n */\nclass GainMapDecoderMaterial extends ShaderMaterial {\n /**\n *\n * @param params\n */\n constructor({ gamma, offsetHdr, offsetSdr, gainMapMin, gainMapMax, maxDisplayBoost, hdrCapacityMin, hdrCapacityMax, sdr, gainMap }) {\n super({\n name: 'GainMapDecoderMaterial',\n vertexShader,\n fragmentShader,\n uniforms: {\n sdr: { value: sdr },\n gainMap: { value: gainMap },\n gamma: { value: new Vector3(1.0 / gamma[0], 1.0 / gamma[1], 1.0 / gamma[2]) },\n offsetHdr: { value: new Vector3().fromArray(offsetHdr) },\n offsetSdr: { value: new Vector3().fromArray(offsetSdr) },\n gainMapMin: { value: new Vector3().fromArray(gainMapMin) },\n gainMapMax: { value: new Vector3().fromArray(gainMapMax) },\n weightFactor: {\n value: (Math.log2(maxDisplayBoost) - hdrCapacityMin) / (hdrCapacityMax - hdrCapacityMin)\n }\n },\n blending: NoBlending,\n depthTest: false,\n depthWrite: false\n });\n this._maxDisplayBoost = maxDisplayBoost;\n this._hdrCapacityMin = hdrCapacityMin;\n this._hdrCapacityMax = hdrCapacityMax;\n this.needsUpdate = true;\n this.uniformsNeedUpdate = true;\n }\n get sdr() { return this.uniforms.sdr.value; }\n set sdr(value) { this.uniforms.sdr.value = value; }\n get gainMap() { return this.uniforms.gainMap.value; }\n set gainMap(value) { this.uniforms.gainMap.value = value; }\n /**\n * @see {@link GainMapMetadata.offsetHdr}\n */\n get offsetHdr() { return this.uniforms.offsetHdr.value.toArray(); }\n set offsetHdr(value) { this.uniforms.offsetHdr.value.fromArray(value); }\n /**\n * @see {@link GainMapMetadata.offsetSdr}\n */\n get offsetSdr() { return this.uniforms.offsetSdr.value.toArray(); }\n set offsetSdr(value) { this.uniforms.offsetSdr.value.fromArray(value); }\n /**\n * @see {@link GainMapMetadata.gainMapMin}\n */\n get gainMapMin() { return this.uniforms.gainMapMin.value.toArray(); }\n set gainMapMin(value) { this.uniforms.gainMapMin.value.fromArray(value); }\n /**\n * @see {@link GainMapMetadata.gainMapMax}\n */\n get gainMapMax() { return this.uniforms.gainMapMax.value.toArray(); }\n set gainMapMax(value) { this.uniforms.gainMapMax.value.fromArray(value); }\n /**\n * @see {@link GainMapMetadata.gamma}\n */\n get gamma() {\n const g = this.uniforms.gamma.value;\n return [1 / g.x, 1 / g.y, 1 / g.z];\n }\n set gamma(value) {\n const g = this.uniforms.gamma.value;\n g.x = 1.0 / value[0];\n g.y = 1.0 / value[1];\n g.z = 1.0 / value[2];\n }\n /**\n * @see {@link GainMapMetadata.hdrCapacityMin}\n * @remarks Logarithmic space\n */\n get hdrCapacityMin() { return this._hdrCapacityMin; }\n set hdrCapacityMin(value) {\n this._hdrCapacityMin = value;\n this.calculateWeight();\n }\n /**\n * @see {@link GainMapMetadata.hdrCapacityMin}\n * @remarks Logarithmic space\n */\n get hdrCapacityMax() { return this._hdrCapacityMax; }\n set hdrCapacityMax(value) {\n this._hdrCapacityMax = value;\n this.calculateWeight();\n }\n /**\n * @see {@link GainmapDecodingParameters.maxDisplayBoost}\n * @remarks Non Logarithmic space\n */\n get maxDisplayBoost() { return this._maxDisplayBoost; }\n set maxDisplayBoost(value) {\n this._maxDisplayBoost = Math.max(1, Math.min(65504, value));\n this.calculateWeight();\n }\n calculateWeight() {\n const val = (Math.log2(this._maxDisplayBoost) - this._hdrCapacityMin) / (this._hdrCapacityMax - this._hdrCapacityMin);\n this.uniforms.weightFactor.value = Math.max(0, Math.min(1, val));\n }\n}\n\n/**\n * Decodes a gain map using a WebGLRenderTarget\n *\n * @category Decoding Functions\n * @group Decoding Functions\n * @example\n * import { decode } from '@monogrid/gainmap-js'\n * import {\n * Mesh,\n * MeshBasicMaterial,\n * PerspectiveCamera,\n * PlaneGeometry,\n * Scene,\n * TextureLoader,\n * WebGLRenderer\n * } from 'three'\n *\n * const renderer = new WebGLRenderer()\n *\n * const textureLoader = new TextureLoader()\n *\n * // load SDR Representation\n * const sdr = await textureLoader.loadAsync('sdr.jpg')\n * // load Gain map recovery image\n * const gainMap = await textureLoader.loadAsync('gainmap.jpg')\n * // load metadata\n * const metadata = await (await fetch('metadata.json')).json()\n *\n * const result = await decode({\n * sdr,\n * gainMap,\n * // this allows to use `result.renderTarget.texture` directly\n * renderer,\n * // this will restore the full HDR range\n * maxDisplayBoost: Math.pow(2, metadata.hdrCapacityMax),\n * ...metadata\n * })\n *\n * const scene = new Scene()\n * // `result` can be used to populate a Texture\n * const mesh = new Mesh(\n * new PlaneGeometry(),\n * new MeshBasicMaterial({ map: result.renderTarget.texture })\n * )\n * scene.add(mesh)\n * renderer.render(scene, new PerspectiveCamera())\n *\n * // result must be manually disposed\n * // when you are done using it\n * result.dispose()\n *\n * @param params\n * @returns\n * @throws {Error} if the WebGLRenderer fails to render the gain map\n */\nconst decode = (params) => {\n const { sdr, gainMap, renderer } = params;\n if (sdr.colorSpace !== SRGBColorSpace) {\n console.warn('SDR Colorspace needs to be *SRGBColorSpace*, setting it automatically');\n sdr.colorSpace = SRGBColorSpace;\n }\n sdr.needsUpdate = true;\n if (gainMap.colorSpace !== LinearSRGBColorSpace) {\n console.warn('Gainmap Colorspace needs to be *LinearSRGBColorSpace*, setting it automatically');\n gainMap.colorSpace = LinearSRGBColorSpace;\n }\n gainMap.needsUpdate = true;\n const material = new GainMapDecoderMaterial({\n ...params,\n sdr,\n gainMap\n });\n const quadRenderer = new QuadRenderer({\n // TODO: three types are generic, eslint complains here, see how we can solve\n // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access\n width: sdr.image.width,\n // TODO: three types are generic, eslint complains here, see how we can solve\n // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access\n height: sdr.image.height,\n type: HalfFloatType,\n colorSpace: LinearSRGBColorSpace,\n material,\n renderer,\n renderTargetOptions: params.renderTargetOptions\n });\n try {\n quadRenderer.render();\n }\n catch (e) {\n quadRenderer.disposeOnDemandRenderer();\n throw e;\n }\n return quadRenderer;\n};\n\nclass GainMapNotFoundError extends Error {\n}\n\nclass XMPMetadataNotFoundError extends Error {\n}\n\nconst getAttribute = (description, name, defaultValue) => {\n var _a;\n let returnValue;\n const parsedValue = (_a = description.attributes.getNamedItem(name)) === null || _a === void 0 ? void 0 : _a.nodeValue;\n if (!parsedValue) {\n const node = description.getElementsByTagName(name)[0];\n if (node) {\n const values = node.getElementsByTagName('rdf:li');\n if (values.length === 3) {\n returnValue = Array.from(values).map(v => v.innerHTML);\n }\n else {\n throw new Error(`Gainmap metadata contains an array of items for ${name} but its length is not 3`);\n }\n }\n else {\n if (defaultValue)\n return defaultValue;\n else\n throw new Error(`Can't find ${name} in gainmap metadata`);\n }\n }\n else {\n returnValue = parsedValue;\n }\n return returnValue;\n};\n/**\n *\n * @param input\n * @returns\n */\nconst extractXMP = (input) => {\n var _a, _b;\n let str;\n // support node test environment\n if (typeof TextDecoder !== 'undefined')\n str = new TextDecoder().decode(input);\n else\n str = input.toString();\n let start = str.indexOf('', start);\n str.slice(start, end + 10);\n const xmpBlock = str.slice(start, end + 10);\n try {\n const xmlDocument = parser.parseFromString(xmpBlock, 'text/xml');\n const description = xmlDocument.getElementsByTagName('rdf:Description')[0];\n const gainMapMin = getAttribute(description, 'hdrgm:GainMapMin', '0');\n const gainMapMax = getAttribute(description, 'hdrgm:GainMapMax');\n const gamma = getAttribute(description, 'hdrgm:Gamma', '1');\n const offsetSDR = getAttribute(description, 'hdrgm:OffsetSDR', '0.015625');\n const offsetHDR = getAttribute(description, 'hdrgm:OffsetHDR', '0.015625');\n let hdrCapacityMin = (_a = description.attributes.getNamedItem('hdrgm:HDRCapacityMin')) === null || _a === void 0 ? void 0 : _a.nodeValue;\n if (!hdrCapacityMin)\n hdrCapacityMin = '0';\n const hdrCapacityMax = (_b = description.attributes.getNamedItem('hdrgm:HDRCapacityMax')) === null || _b === void 0 ? void 0 : _b.nodeValue;\n if (!hdrCapacityMax)\n throw new Error('Incomplete gainmap metadata');\n return {\n gainMapMin: Array.isArray(gainMapMin) ? gainMapMin.map(v => parseFloat(v)) : [parseFloat(gainMapMin), parseFloat(gainMapMin), parseFloat(gainMapMin)],\n gainMapMax: Array.isArray(gainMapMax) ? gainMapMax.map(v => parseFloat(v)) : [parseFloat(gainMapMax), parseFloat(gainMapMax), parseFloat(gainMapMax)],\n gamma: Array.isArray(gamma) ? gamma.map(v => parseFloat(v)) : [parseFloat(gamma), parseFloat(gamma), parseFloat(gamma)],\n offsetSdr: Array.isArray(offsetSDR) ? offsetSDR.map(v => parseFloat(v)) : [parseFloat(offsetSDR), parseFloat(offsetSDR), parseFloat(offsetSDR)],\n offsetHdr: Array.isArray(offsetHDR) ? offsetHDR.map(v => parseFloat(v)) : [parseFloat(offsetHDR), parseFloat(offsetHDR), parseFloat(offsetHDR)],\n hdrCapacityMin: parseFloat(hdrCapacityMin),\n hdrCapacityMax: parseFloat(hdrCapacityMax)\n };\n }\n catch (e) {\n }\n start = str.indexOf(' {\n const debug = this.options.debug;\n const dataView = new DataView(imageArrayBuffer.buffer);\n // If you're executing this line on a big endian machine, it'll be reversed.\n // bigEnd further down though, refers to the endianness of the image itself.\n if (dataView.getUint16(0) !== 0xffd8) {\n reject(new Error('Not a valid jpeg'));\n return;\n }\n const length = dataView.byteLength;\n let offset = 2;\n let loops = 0;\n let marker; // APP# marker\n while (offset < length) {\n if (++loops > 250) {\n reject(new Error(`Found no marker after ${loops} loops \uD83D\uDE35`));\n return;\n }\n if (dataView.getUint8(offset) !== 0xff) {\n reject(new Error(`Not a valid marker at offset 0x${offset.toString(16)}, found: 0x${dataView.getUint8(offset).toString(16)}`));\n return;\n }\n marker = dataView.getUint8(offset + 1);\n if (debug)\n console.log(`Marker: ${marker.toString(16)}`);\n if (marker === 0xe2) {\n if (debug)\n console.log('Found APP2 marker (0xffe2)');\n // Works for iPhone 8 Plus, X, and XSMax. Or any photos of MPF format.\n // Great way to visualize image information in html is using Exiftool. E.g.:\n // ./exiftool.exe -htmldump -wantTrailer photo.jpg > photo.html\n const formatPt = offset + 4;\n /*\n * Structure of the MP Format Identifier\n *\n * Offset Addr. | Code (Hex) | Description\n * +00 ff Marker Prefix <-- offset\n * +01 e2 APP2\n * +02 #n APP2 Field Length\n * +03 #n APP2 Field Length\n * +04 4d 'M' <-- formatPt\n * +05 50 'P'\n * +06 46 'F'\n * +07 00 NULL\n * <-- tiffOffset\n */\n if (dataView.getUint32(formatPt) === 0x4d504600) {\n // Found MPF tag, so we start dig out sub images\n const tiffOffset = formatPt + 4;\n let bigEnd; // Endianness from TIFF header\n // Test for TIFF validity and endianness\n // 0x4949 and 0x4D4D ('II' and 'MM') marks Little Endian and Big Endian\n if (dataView.getUint16(tiffOffset) === 0x4949) {\n bigEnd = false;\n }\n else if (dataView.getUint16(tiffOffset) === 0x4d4d) {\n bigEnd = true;\n }\n else {\n reject(new Error('No valid endianness marker found in TIFF header'));\n return;\n }\n if (dataView.getUint16(tiffOffset + 2, !bigEnd) !== 0x002a) {\n reject(new Error('Not valid TIFF data! (no 0x002A marker)'));\n return;\n }\n // 32 bit number stating the offset from the start of the 8 Byte MP Header\n // to MP Index IFD Least possible value is thus 8 (means 0 offset)\n const firstIFDOffset = dataView.getUint32(tiffOffset + 4, !bigEnd);\n if (firstIFDOffset < 0x00000008) {\n reject(new Error('Not valid TIFF data! (First offset less than 8)'));\n return;\n }\n // Move ahead to MP Index IFD\n // Assume we're at the first IFD, so firstIFDOffset points to\n // MP Index IFD and not MP Attributes IFD. (If we try extract from a sub image,\n // we fail silently here due to this assumption)\n // Count (2 Byte) | MP Index Fields a.k.a. MP Entries (count * 12 Byte) | Offset of Next IFD (4 Byte)\n const dirStart = tiffOffset + firstIFDOffset; // Start of IFD (Image File Directory)\n const count = dataView.getUint16(dirStart, !bigEnd); // Count of MPEntries (2 Byte)\n // Extract info from MPEntries (starting after Count)\n const entriesStart = dirStart + 2;\n let numberOfImages = 0;\n for (let i = entriesStart; i < entriesStart + 12 * count; i += 12) {\n // Each entry is 12 Bytes long\n // Check MP Index IFD tags, here we only take tag 0xb001 = Number of images\n if (dataView.getUint16(i, !bigEnd) === 0xb001) {\n // stored in Last 4 bytes of its 12 Byte entry.\n numberOfImages = dataView.getUint32(i + 8, !bigEnd);\n }\n }\n const nextIFDOffsetLen = 4; // 4 Byte offset field that appears after MP Index IFD tags\n const MPImageListValPt = dirStart + 2 + count * 12 + nextIFDOffsetLen;\n const images = [];\n for (let i = MPImageListValPt; i < MPImageListValPt + numberOfImages * 16; i += 16) {\n const image = {\n MPType: dataView.getUint32(i, !bigEnd),\n size: dataView.getUint32(i + 4, !bigEnd),\n // This offset is specified relative to the address of the MP Endian\n // field in the MP Header, unless the image is a First Individual Image,\n // in which case the value of the offset shall be NULL (0x00000000).\n dataOffset: dataView.getUint32(i + 8, !bigEnd),\n dependantImages: dataView.getUint32(i + 12, !bigEnd),\n start: -1,\n end: -1,\n isFII: false\n };\n if (!image.dataOffset) {\n // dataOffset is 0x00000000 for First Individual Image\n image.start = 0;\n image.isFII = true;\n }\n else {\n image.start = tiffOffset + image.dataOffset;\n image.isFII = false;\n }\n image.end = image.start + image.size;\n images.push(image);\n }\n if (this.options.extractNonFII && images.length) {\n const bufferBlob = new Blob([dataView]);\n const imgs = [];\n for (const image of images) {\n if (image.isFII && !this.options.extractFII) {\n continue; // Skip FII\n }\n const imageBlob = bufferBlob.slice(image.start, image.end + 1, 'image/jpeg');\n // we don't need this\n // const imageUrl = URL.createObjectURL(imageBlob)\n // image.img = document.createElement('img')\n // image.img.src = imageUrl\n imgs.push(imageBlob);\n }\n resolve(imgs);\n }\n }\n }\n offset += 2 + dataView.getUint16(offset + 2);\n }\n });\n }\n}\n\n/**\n * Extracts XMP Metadata and the gain map recovery image\n * from a single JPEG file.\n *\n * @category Decoding Functions\n * @group Decoding Functions\n * @param jpegFile an `Uint8Array` containing and encoded JPEG file\n * @returns an sdr `Uint8Array` compressed in JPEG, a gainMap `Uint8Array` compressed in JPEG and the XMP parsed XMP metadata\n * @throws Error if XMP Metadata is not found\n * @throws Error if Gain map image is not found\n * @example\n * import { FileLoader } from 'three'\n * import { extractGainmapFromJPEG } from '@monogrid/gainmap-js'\n *\n * const jpegFile = await new FileLoader()\n * .setResponseType('arraybuffer')\n * .loadAsync('image.jpg')\n *\n * const { sdr, gainMap, metadata } = extractGainmapFromJPEG(jpegFile)\n */\nconst extractGainmapFromJPEG = async (jpegFile) => {\n const metadata = extractXMP(jpegFile);\n if (!metadata)\n throw new XMPMetadataNotFoundError('Gain map XMP metadata not found');\n const mpfExtractor = new MPFExtractor({ extractFII: true, extractNonFII: true });\n const images = await mpfExtractor.extract(jpegFile);\n if (images.length !== 2)\n throw new GainMapNotFoundError('Gain map recovery image not found');\n return {\n sdr: new Uint8Array(await images[0].arrayBuffer()),\n gainMap: new Uint8Array(await images[1].arrayBuffer()),\n metadata\n };\n};\n\n/**\n * private function, async get image from blob\n *\n * @param blob\n * @returns\n */\nconst getHTMLImageFromBlob = (blob) => {\n return new Promise((resolve, reject) => {\n const img = document.createElement('img');\n img.onload = () => { resolve(img); };\n img.onerror = (e) => { reject(e); };\n img.src = URL.createObjectURL(blob);\n });\n};\n\nclass LoaderBase extends Loader {\n /**\n *\n * @param renderer\n * @param manager\n */\n constructor(renderer, manager) {\n super(manager);\n if (renderer)\n this._renderer = renderer;\n this._internalLoadingManager = new LoadingManager();\n }\n /**\n * Specify the renderer to use when rendering the gain map\n *\n * @param renderer\n * @returns\n */\n setRenderer(renderer) {\n this._renderer = renderer;\n return this;\n }\n /**\n * Specify the renderTarget options to use when rendering the gain map\n *\n * @param options\n * @returns\n */\n setRenderTargetOptions(options) {\n this._renderTargetOptions = options;\n return this;\n }\n /**\n * @private\n * @returns\n */\n prepareQuadRenderer() {\n if (!this._renderer)\n console.warn('WARNING: An existing WebGL Renderer was not passed to this Loader constructor or in setRenderer, the result of this Loader will need to be converted to a Data Texture with toDataTexture() before you can use it in your renderer.');\n // temporary values\n const material = new GainMapDecoderMaterial({\n gainMapMax: [1, 1, 1],\n gainMapMin: [0, 0, 0],\n gamma: [1, 1, 1],\n offsetHdr: [1, 1, 1],\n offsetSdr: [1, 1, 1],\n hdrCapacityMax: 1,\n hdrCapacityMin: 0,\n maxDisplayBoost: 1,\n gainMap: new Texture(),\n sdr: new Texture()\n });\n return new QuadRenderer({\n width: 16,\n height: 16,\n type: HalfFloatType,\n colorSpace: LinearSRGBColorSpace,\n material,\n renderer: this._renderer,\n renderTargetOptions: this._renderTargetOptions\n });\n }\n /**\n * @private\n * @param quadRenderer\n * @param metadata\n * @param sdrBuffer\n * @param gainMapBuffer\n */\n async render(quadRenderer, metadata, sdrBuffer, gainMapBuffer) {\n // this is optional, will render a black gain-map if not present\n const gainMapBlob = gainMapBuffer ? new Blob([gainMapBuffer], { type: 'image/jpeg' }) : undefined;\n const sdrBlob = new Blob([sdrBuffer], { type: 'image/jpeg' });\n let sdrImage;\n let gainMapImage;\n let needsFlip = false;\n if (typeof createImageBitmap === 'undefined') {\n const res = await Promise.all([\n gainMapBlob ? getHTMLImageFromBlob(gainMapBlob) : Promise.resolve(undefined),\n getHTMLImageFromBlob(sdrBlob)\n ]);\n gainMapImage = res[0];\n sdrImage = res[1];\n needsFlip = true;\n }\n else {\n const res = await Promise.all([\n gainMapBlob ? createImageBitmap(gainMapBlob, { imageOrientation: 'flipY' }) : Promise.resolve(undefined),\n createImageBitmap(sdrBlob, { imageOrientation: 'flipY' })\n ]);\n gainMapImage = res[0];\n sdrImage = res[1];\n }\n const gainMap = new Texture(gainMapImage || new ImageData(2, 2), UVMapping, ClampToEdgeWrapping, ClampToEdgeWrapping, LinearFilter, LinearMipMapLinearFilter, RGBAFormat, UnsignedByteType, 1, LinearSRGBColorSpace);\n gainMap.flipY = needsFlip;\n gainMap.needsUpdate = true;\n const sdr = new Texture(sdrImage, UVMapping, ClampToEdgeWrapping, ClampToEdgeWrapping, LinearFilter, LinearMipMapLinearFilter, RGBAFormat, UnsignedByteType, 1, SRGBColorSpace);\n sdr.flipY = needsFlip;\n sdr.needsUpdate = true;\n quadRenderer.width = sdrImage.width;\n quadRenderer.height = sdrImage.height;\n quadRenderer.material.gainMap = gainMap;\n quadRenderer.material.sdr = sdr;\n quadRenderer.material.gainMapMin = metadata.gainMapMin;\n quadRenderer.material.gainMapMax = metadata.gainMapMax;\n quadRenderer.material.offsetHdr = metadata.offsetHdr;\n quadRenderer.material.offsetSdr = metadata.offsetSdr;\n quadRenderer.material.gamma = metadata.gamma;\n quadRenderer.material.hdrCapacityMin = metadata.hdrCapacityMin;\n quadRenderer.material.hdrCapacityMax = metadata.hdrCapacityMax;\n quadRenderer.material.maxDisplayBoost = Math.pow(2, metadata.hdrCapacityMax);\n quadRenderer.material.needsUpdate = true;\n quadRenderer.render();\n }\n}\n\n/**\n * A Three.js Loader for the gain map format.\n *\n * @category Loaders\n * @group Loaders\n *\n * @example\n * import { GainMapLoader } from '@monogrid/gainmap-js'\n * import {\n * EquirectangularReflectionMapping,\n * LinearFilter,\n * Mesh,\n * MeshBasicMaterial,\n * PerspectiveCamera,\n * PlaneGeometry,\n * Scene,\n * WebGLRenderer\n * } from 'three'\n *\n * const renderer = new WebGLRenderer()\n *\n * const loader = new GainMapLoader(renderer)\n *\n * const result = await loader.loadAsync(['sdr.jpeg', 'gainmap.jpeg', 'metadata.json'])\n * // `result` can be used to populate a Texture\n *\n * const scene = new Scene()\n * const mesh = new Mesh(\n * new PlaneGeometry(),\n * new MeshBasicMaterial({ map: result.renderTarget.texture })\n * )\n * scene.add(mesh)\n * renderer.render(scene, new PerspectiveCamera())\n *\n * // Starting from three.js r159\n * // `result.renderTarget.texture` can\n * // also be used as Equirectangular scene background\n * //\n * // it was previously needed to convert it\n * // to a DataTexture with `result.toDataTexture()`\n * scene.background = result.renderTarget.texture\n * scene.background.mapping = EquirectangularReflectionMapping\n *\n * // result must be manually disposed\n * // when you are done using it\n * result.dispose()\n *\n */\nclass GainMapLoader extends LoaderBase {\n /**\n * Loads a gainmap using separate data\n * * sdr image\n * * gain map image\n * * metadata json\n *\n * useful for webp gain maps\n *\n * @param urls An array in the form of [sdr.jpg, gainmap.jpg, metadata.json]\n * @param onLoad Load complete callback, will receive the result\n * @param onProgress Progress callback, will receive a {@link ProgressEvent}\n * @param onError Error callback\n * @returns\n */\n load([sdrUrl, gainMapUrl, metadataUrl], onLoad, onProgress, onError) {\n const quadRenderer = this.prepareQuadRenderer();\n let sdr;\n let gainMap;\n let metadata;\n const loadCheck = async () => {\n if (sdr && gainMap && metadata) {\n // solves #16\n try {\n await this.render(quadRenderer, metadata, sdr, gainMap);\n }\n catch (error) {\n this.manager.itemError(sdrUrl);\n this.manager.itemError(gainMapUrl);\n this.manager.itemError(metadataUrl);\n if (typeof onError === 'function')\n onError(error);\n quadRenderer.disposeOnDemandRenderer();\n return;\n }\n if (typeof onLoad === 'function')\n onLoad(quadRenderer);\n this.manager.itemEnd(sdrUrl);\n this.manager.itemEnd(gainMapUrl);\n this.manager.itemEnd(metadataUrl);\n quadRenderer.disposeOnDemandRenderer();\n }\n };\n let sdrLengthComputable = true;\n let sdrTotal = 0;\n let sdrLoaded = 0;\n let gainMapLengthComputable = true;\n let gainMapTotal = 0;\n let gainMapLoaded = 0;\n let metadataLengthComputable = true;\n let metadataTotal = 0;\n let metadataLoaded = 0;\n const progressHandler = () => {\n if (typeof onProgress === 'function') {\n const total = sdrTotal + gainMapTotal + metadataTotal;\n const loaded = sdrLoaded + gainMapLoaded + metadataLoaded;\n const lengthComputable = sdrLengthComputable && gainMapLengthComputable && metadataLengthComputable;\n onProgress(new ProgressEvent('progress', { lengthComputable, loaded, total }));\n }\n };\n this.manager.itemStart(sdrUrl);\n this.manager.itemStart(gainMapUrl);\n this.manager.itemStart(metadataUrl);\n const sdrLoader = new FileLoader(this._internalLoadingManager);\n sdrLoader.setResponseType('arraybuffer');\n sdrLoader.setRequestHeader(this.requestHeader);\n sdrLoader.setPath(this.path);\n sdrLoader.setWithCredentials(this.withCredentials);\n sdrLoader.load(sdrUrl, async (buffer) => {\n /* istanbul ignore if\n this condition exists only because of three.js types + strict mode\n */\n if (typeof buffer === 'string')\n throw new Error('Invalid sdr buffer');\n sdr = buffer;\n await loadCheck();\n }, (e) => {\n sdrLengthComputable = e.lengthComputable;\n sdrLoaded = e.loaded;\n sdrTotal = e.total;\n progressHandler();\n }, (error) => {\n this.manager.itemError(sdrUrl);\n if (typeof onError === 'function')\n onError(error);\n });\n const gainMapLoader = new FileLoader(this._internalLoadingManager);\n gainMapLoader.setResponseType('arraybuffer');\n gainMapLoader.setRequestHeader(this.requestHeader);\n gainMapLoader.setPath(this.path);\n gainMapLoader.setWithCredentials(this.withCredentials);\n gainMapLoader.load(gainMapUrl, async (buffer) => {\n /* istanbul ignore if\n this condition exists only because of three.js types + strict mode\n */\n if (typeof buffer === 'string')\n throw new Error('Invalid gainmap buffer');\n gainMap = buffer;\n await loadCheck();\n }, (e) => {\n gainMapLengthComputable = e.lengthComputable;\n gainMapLoaded = e.loaded;\n gainMapTotal = e.total;\n progressHandler();\n }, (error) => {\n this.manager.itemError(gainMapUrl);\n if (typeof onError === 'function')\n onError(error);\n });\n const metadataLoader = new FileLoader(this._internalLoadingManager);\n // metadataLoader.setResponseType('json')\n metadataLoader.setRequestHeader(this.requestHeader);\n metadataLoader.setPath(this.path);\n metadataLoader.setWithCredentials(this.withCredentials);\n metadataLoader.load(metadataUrl, async (json) => {\n /* istanbul ignore if\n this condition exists only because of three.js types + strict mode\n */\n if (typeof json !== 'string')\n throw new Error('Invalid metadata string');\n // TODO: implement check on JSON file and remove this eslint disable\n // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n metadata = JSON.parse(json);\n await loadCheck();\n }, (e) => {\n metadataLengthComputable = e.lengthComputable;\n metadataLoaded = e.loaded;\n metadataTotal = e.total;\n progressHandler();\n }, (error) => {\n this.manager.itemError(metadataUrl);\n if (typeof onError === 'function')\n onError(error);\n });\n return quadRenderer;\n }\n}\n\n/**\n * A Three.js Loader for a JPEG with embedded gainmap metadata.\n *\n * @category Loaders\n * @group Loaders\n *\n * @example\n * import { HDRJPGLoader } from '@monogrid/gainmap-js'\n * import {\n * EquirectangularReflectionMapping,\n * LinearFilter,\n * Mesh,\n * MeshBasicMaterial,\n * PerspectiveCamera,\n * PlaneGeometry,\n * Scene,\n * WebGLRenderer\n * } from 'three'\n *\n * const renderer = new WebGLRenderer()\n *\n * const loader = new HDRJPGLoader(renderer)\n *\n * const result = await loader.loadAsync('gainmap.jpeg')\n * // `result` can be used to populate a Texture\n *\n * const scene = new Scene()\n * const mesh = new Mesh(\n * new PlaneGeometry(),\n * new MeshBasicMaterial({ map: result.renderTarget.texture })\n * )\n * scene.add(mesh)\n * renderer.render(scene, new PerspectiveCamera())\n *\n * // Starting from three.js r159\n * // `result.renderTarget.texture` can\n * // also be used as Equirectangular scene background\n * //\n * // it was previously needed to convert it\n * // to a DataTexture with `result.toDataTexture()`\n * scene.background = result.renderTarget.texture\n * scene.background.mapping = EquirectangularReflectionMapping\n *\n * // result must be manually disposed\n * // when you are done using it\n * result.dispose()\n *\n */\nclass HDRJPGLoader extends LoaderBase {\n /**\n * Loads a JPEG containing gain map metadata\n * Renders a normal SDR image if gainmap data is not found\n *\n * @param url An array in the form of [sdr.jpg, gainmap.jpg, metadata.json]\n * @param onLoad Load complete callback, will receive the result\n * @param onProgress Progress callback, will receive a {@link ProgressEvent}\n * @param onError Error callback\n * @returns\n */\n load(url, onLoad, onProgress, onError) {\n const quadRenderer = this.prepareQuadRenderer();\n const loader = new FileLoader(this._internalLoadingManager);\n loader.setResponseType('arraybuffer');\n loader.setRequestHeader(this.requestHeader);\n loader.setPath(this.path);\n loader.setWithCredentials(this.withCredentials);\n this.manager.itemStart(url);\n loader.load(url, async (jpeg) => {\n /* istanbul ignore if\n this condition exists only because of three.js types + strict mode\n */\n if (typeof jpeg === 'string')\n throw new Error('Invalid buffer, received [string], was expecting [ArrayBuffer]');\n const jpegBuffer = new Uint8Array(jpeg);\n let sdrJPEG;\n let gainMapJPEG;\n let metadata;\n try {\n const extractionResult = await extractGainmapFromJPEG(jpegBuffer);\n // gain map is successfully reconstructed\n sdrJPEG = extractionResult.sdr;\n gainMapJPEG = extractionResult.gainMap;\n metadata = extractionResult.metadata;\n }\n catch (e) {\n // render the SDR version if this is not a gainmap\n if (e instanceof XMPMetadataNotFoundError || e instanceof GainMapNotFoundError) {\n console.warn(`Failure to reconstruct an HDR image from ${url}: Gain map metadata not found in the file, HDRJPGLoader will render the SDR jpeg`);\n metadata = {\n gainMapMin: [0, 0, 0],\n gainMapMax: [1, 1, 1],\n gamma: [1, 1, 1],\n hdrCapacityMin: 0,\n hdrCapacityMax: 1,\n offsetHdr: [0, 0, 0],\n offsetSdr: [0, 0, 0]\n };\n sdrJPEG = jpegBuffer;\n }\n else {\n throw e;\n }\n }\n // solves #16\n try {\n await this.render(quadRenderer, metadata, sdrJPEG, gainMapJPEG);\n }\n catch (error) {\n this.manager.itemError(url);\n if (typeof onError === 'function')\n onError(error);\n quadRenderer.disposeOnDemandRenderer();\n return;\n }\n if (typeof onLoad === 'function')\n onLoad(quadRenderer);\n this.manager.itemEnd(url);\n quadRenderer.disposeOnDemandRenderer();\n }, onProgress, (error) => {\n this.manager.itemError(url);\n if (typeof onError === 'function')\n onError(error);\n });\n return quadRenderer;\n }\n}\n\nexport { GainMapDecoderMaterial, GainMapLoader, HDRJPGLoader, HDRJPGLoader as JPEGRLoader, MPFExtractor, QuadRenderer, decode, extractGainmapFromJPEG, extractXMP };\n", "import {\n FullScreenMMLScene,\n MMLNetworkSource,\n NetworkedDOMWebsocketStatus,\n NetworkedDOMWebsocketStatusToString,\n parseColorAttribute,\n StatusUI,\n} from \"@mml-io/mml-web\";\nimport {\n StandaloneThreeJSAdapter,\n StandaloneThreeJSAdapterControlsType,\n ThreeJSDragFlyCameraControls,\n ThreeJSOrbitCameraControls,\n} from \"@mml-io/mml-web-threejs-standalone\";\nimport { HDRJPGLoader } from \"@monogrid/gainmap-js\";\nimport * as THREE from \"three\";\n\nimport { calculateContentBounds } from \"./calculateContentBounds\";\nimport { envMaps } from \"./env-maps\";\nimport { FormIteration } from \"./FormIteration\";\nimport { MMLSourceDefinition } from \"./MMLSourceDefinition\";\nimport { parseXYZ } from \"./parseXYZ\";\nimport { setDebugGlobals } from \"./setDebugGlobals\";\nimport {\n ambientLightColorField,\n ambientLightField,\n backgroundColorField,\n cameraFitContents,\n cameraFovField,\n cameraLookAtField,\n cameraModeField,\n cameraOrbitDistanceField,\n cameraOrbitPitchField,\n cameraOrbitSpeedField,\n cameraPositionField,\n environmentMapField,\n} from \"./ui/fields\";\n\nexport class ThreeJSModeInternal {\n private disposed = false;\n\n private loadedState: {\n mmlNetworkSource: MMLNetworkSource;\n graphicsAdapter: StandaloneThreeJSAdapter;\n fullScreenMMLScene: FullScreenMMLScene;\n statusUI: StatusUI;\n } | null = null;\n\n private ambientLight: THREE.AmbientLight | null = null;\n\n public readonly type = \"three\";\n private environmentMap: string | null = null;\n\n constructor(\n private windowTarget: Window,\n private targetForWrappers: HTMLElement,\n private mmlSourceDefinition: MMLSourceDefinition,\n private formIteration: FormIteration,\n ) {\n this.init();\n }\n\n private async init() {\n const fullScreenMMLScene = new FullScreenMMLScene();\n document.body.append(fullScreenMMLScene.element);\n const graphicsAdapter = await StandaloneThreeJSAdapter.create(fullScreenMMLScene.element, {\n controlsType: StandaloneThreeJSAdapterControlsType.DragFly,\n });\n if (this.disposed) {\n graphicsAdapter.dispose();\n return;\n }\n\n fullScreenMMLScene.init(graphicsAdapter);\n const statusUI = new StatusUI();\n const mmlNetworkSource = MMLNetworkSource.create({\n mmlScene: fullScreenMMLScene,\n statusUpdated: (status: NetworkedDOMWebsocketStatus) => {\n if (status === NetworkedDOMWebsocketStatus.Connected) {\n statusUI.setNoStatus();\n } else {\n statusUI.setStatus(NetworkedDOMWebsocketStatusToString(status));\n }\n },\n url: this.mmlSourceDefinition.url,\n windowTarget: this.windowTarget,\n targetForWrappers: this.targetForWrappers,\n });\n setDebugGlobals({\n mmlScene: fullScreenMMLScene,\n remoteDocumentWrapper: mmlNetworkSource.remoteDocumentWrapper,\n });\n const loadingCallback = () => {\n const [, completedLoading] = fullScreenMMLScene.getLoadingProgressManager().toRatio();\n if (completedLoading) {\n fullScreenMMLScene.getLoadingProgressManager().removeProgressCallback(loadingCallback);\n\n const fitContent = this.formIteration.getFieldValue(cameraFitContents);\n if (fitContent === \"true\") {\n graphicsAdapter.controls?.fitContent(calculateContentBounds(this.targetForWrappers));\n }\n }\n };\n fullScreenMMLScene.getLoadingProgressManager().addProgressCallback(loadingCallback);\n this.loadedState = {\n mmlNetworkSource,\n graphicsAdapter,\n fullScreenMMLScene,\n statusUI,\n };\n this.update(this.formIteration);\n }\n\n update(formIteration: FormIteration) {\n this.formIteration = formIteration;\n if (!this.loadedState) {\n return;\n }\n\n const graphicsAdapter = this.loadedState.graphicsAdapter;\n const threeScene = graphicsAdapter.getThreeScene();\n const threeRenderer = graphicsAdapter.getRenderer();\n\n this.setBackgroundColor(formIteration, threeRenderer);\n this.setAmbientLight(formIteration, threeScene);\n this.setAmbientLightColor(formIteration);\n this.setEnvironmentMap(formIteration, threeRenderer, threeScene);\n\n this.setCameraMode(formIteration, graphicsAdapter);\n\n formIteration.completed();\n }\n\n private setEnvironmentMap(\n formIteration: FormIteration,\n threeRenderer: THREE.WebGLRenderer,\n threeScene: THREE.Scene,\n ) {\n let environmentMap = formIteration.getFieldValue(environmentMapField);\n const foundEnvMap = envMaps[environmentMap];\n if (foundEnvMap) {\n environmentMap = foundEnvMap.url;\n }\n if (!environmentMap) {\n threeScene.environment = null;\n threeScene.background = null;\n this.environmentMap = null;\n return;\n }\n if (environmentMap === this.environmentMap) {\n return;\n }\n\n const pmremGenerator = new THREE.PMREMGenerator(threeRenderer);\n const loader = new HDRJPGLoader(threeRenderer);\n loader.loadAsync(environmentMap).then((result) => {\n const hdrJpg = result.renderTarget.texture;\n hdrJpg.mapping = THREE.EquirectangularReflectionMapping;\n\n const envMap = pmremGenerator.fromEquirectangular(hdrJpg).texture;\n threeScene.backgroundIntensity = 1;\n threeScene.backgroundBlurriness = 0;\n threeScene.backgroundRotation = new THREE.Euler(0, -Math.PI / 2, 0);\n threeScene.background = envMap;\n threeScene.environment = envMap;\n result.dispose();\n });\n }\n\n private setAmbientLightColor(formIteration: FormIteration) {\n const ambientLightColorString = formIteration.getFieldValue(ambientLightColorField);\n const color = parseColorAttribute(ambientLightColorString, {\n r: 1,\n g: 1,\n b: 1,\n });\n if (this.ambientLight) {\n this.ambientLight.color.setRGB(color.r, color.g, color.b);\n }\n }\n\n private setAmbientLight(formIteration: FormIteration, threeScene: THREE.Scene) {\n const ambientLightIntensityString = formIteration.getFieldValue(ambientLightField);\n let ambientLightIntensity = parseFloat(ambientLightIntensityString);\n if (isNaN(ambientLightIntensity)) {\n ambientLightIntensity = 0;\n }\n if (ambientLightIntensity < 0) {\n ambientLightIntensity = 0;\n }\n if (this.ambientLight && ambientLightIntensity <= 0) {\n this.ambientLight.removeFromParent();\n this.ambientLight = null;\n }\n if (!this.ambientLight && ambientLightIntensity > 0) {\n this.ambientLight = new THREE.AmbientLight(0xffffff, ambientLightIntensity);\n threeScene.add(this.ambientLight);\n } else if (this.ambientLight) {\n this.ambientLight.intensity = ambientLightIntensity;\n }\n }\n\n private setBackgroundColor(formIteration: FormIteration, threeRenderer: THREE.WebGLRenderer) {\n const backgroundColorString = formIteration.getFieldValue(backgroundColorField);\n const color = parseColorAttribute(backgroundColorString, {\n r: 1,\n g: 1,\n b: 1,\n a: 0,\n });\n threeRenderer.setClearColor(new THREE.Color(color.r, color.g, color.b), color.a);\n }\n\n public dispose() {\n this.disposed = true;\n if (this.loadedState) {\n this.loadedState.mmlNetworkSource.dispose();\n this.loadedState.graphicsAdapter.dispose();\n this.loadedState.fullScreenMMLScene.dispose();\n this.loadedState.statusUI.dispose();\n this.loadedState = null;\n }\n }\n\n private setCameraMode(formIteration: FormIteration, graphicsAdapter: StandaloneThreeJSAdapter) {\n let cameraFOV = parseFloat(formIteration.getFieldValue(cameraFovField));\n if (isNaN(cameraFOV)) {\n cameraFOV = 75;\n }\n graphicsAdapter.setCameraFOV(cameraFOV);\n\n const cameraMode = formIteration.getFieldValue(cameraModeField);\n if (cameraMode === \"orbit\") {\n if (graphicsAdapter.controls?.type !== \"orbit\") {\n graphicsAdapter.setControlsType(StandaloneThreeJSAdapterControlsType.Orbit);\n }\n const controls = graphicsAdapter.controls as ThreeJSOrbitCameraControls;\n let orbitSpeed = parseFloat(formIteration.getFieldValue(cameraOrbitSpeedField));\n if (isNaN(orbitSpeed)) {\n orbitSpeed = 0;\n }\n controls.setDegreesPerSecond(orbitSpeed);\n\n let orbitPitch = parseFloat(formIteration.getFieldValue(cameraOrbitPitchField));\n\n if (isNaN(orbitPitch)) {\n orbitPitch = 0;\n }\n controls.setPitchDegrees(orbitPitch);\n\n const fitContent = formIteration.getFieldValue(cameraFitContents);\n if (fitContent === \"true\") {\n controls.fitContent(calculateContentBounds(this.targetForWrappers));\n } else {\n const lookAt = parseXYZ(formIteration.getFieldValue(cameraLookAtField));\n controls.setLookAt(lookAt[0], lookAt[1], lookAt[2]);\n\n let orbitDistance = parseFloat(formIteration.getFieldValue(cameraOrbitDistanceField));\n if (isNaN(orbitDistance)) {\n orbitDistance = 1;\n }\n controls.setDistance(orbitDistance);\n }\n } else if (cameraMode === \"drag-fly\") {\n if (graphicsAdapter.controls?.type !== \"drag-fly\") {\n graphicsAdapter.setControlsType(StandaloneThreeJSAdapterControlsType.DragFly);\n }\n const controls = graphicsAdapter.controls as ThreeJSDragFlyCameraControls;\n\n const cameraPosition = parseXYZ(formIteration.getFieldValue(cameraPositionField));\n controls.setCameraPosition(cameraPosition[0], cameraPosition[1], cameraPosition[2]);\n\n const lookAt = parseXYZ(formIteration.getFieldValue(cameraLookAtField));\n controls.setLookAt(lookAt[0], lookAt[1], lookAt[2]);\n\n const fitContent = formIteration.getFieldValue(cameraFitContents);\n if (fitContent === \"true\") {\n controls.fitContent(calculateContentBounds(this.targetForWrappers));\n }\n } else if (cameraMode === \"none\" && graphicsAdapter.controls !== null) {\n graphicsAdapter.setControlsType(StandaloneThreeJSAdapterControlsType.None);\n }\n }\n}\n"], + "mappings": "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", + "names": ["max", "radToDeg", "max", "quaternion", "max", "sign", "up", "right", "data", "indices", "intersects", "intersect", "width", "height", "depth", "fov", "aspect", "renderer", "scene", "alpha", "attributes", "precision", "right", "x", "max", "vertexShader", "fragmentShader", "self", "drawBuffers", "scissor", "viewport", "_canvas", "err", "texture", "i", "cameraL", "cameraR", "right2", "cameras", "cameraXR", "info", "_projScreenMatrix", "_vector2", "_vector3", "context", "stencil", "bits", "materials", "currentRenderList", "parameters", "framebuffer", "intersects", "intersect", "intersects", "vertex", "sign", "vertex", "right", "err", "fov", "aspect", "up", "Audio", "now", "intersects", "_color", "worker", "l", "right", "r", "j", "child", "aspect", "fov", "material", "skeleton", "up", "vertex", "quaternion", "textDecoder", "self", "res", "td", "URL", "sourceURI", "node", "max", "accessor", "convertArrayBufferToString", "isFbxFormatASCII", "_ModelLoader", "_a", "_b", "gltf", "_a", "_b", "_ThreeJSChatProbe", "_ThreeJSCube", "_ThreeJSCylinder", "_ThreeJSFrame", "_ThreeJSImage", "LoadingInstanceManager", "Image", "_ThreeJSInteraction", "_ThreeJSLabel", "_ThreeJSModel", "err", "_ThreeJSPlane", "_ThreeJSPositionProbe", "CanvasText", "_ThreeJSSphere", "audioRefDistance", "audioRolloffFactor", "calculateContentSize", "MElement", "TransformableElement", "_ThreeJSInteractionAdapter", "fov", "clamp", "max", "quaternion", "EventHandlerCollection", "Vector3", "StandaloneThreeJSAdapterControlsType", "_a", "_b", "_q", "_a", "_b"] +} diff --git a/pull/212/v1/chunk-CPWJBFSW.js b/pull/212/v1/chunk-CPWJBFSW.js new file mode 100644 index 00000000..728152f4 --- /dev/null +++ b/pull/212/v1/chunk-CPWJBFSW.js @@ -0,0 +1,78 @@ +import { + TransformableElement +} from "./chunk-OGDCF6KN.js"; + +// src/calculateContentBounds.ts +function calculateContentBounds(rootElement) { + let minX = null; + let minY = null; + let minZ = null; + let maxX = null; + let maxY = null; + let maxZ = null; + const traverse = (element) => { + if (element instanceof TransformableElement) { + const bounds = element.getContentBounds(); + if (bounds) { + bounds.getCorners().forEach((corner) => { + if (minX === null || corner.x < minX) { + minX = corner.x; + } + if (minY === null || corner.y < minY) { + minY = corner.y; + } + if (minZ === null || corner.z < minZ) { + minZ = corner.z; + } + if (maxX === null || corner.x > maxX) { + maxX = corner.x; + } + if (maxY === null || corner.y > maxY) { + maxY = corner.y; + } + if (maxZ === null || corner.z > maxZ) { + maxZ = corner.z; + } + }); + } + } + element.childNodes.forEach((child) => { + traverse(child); + }); + }; + traverse(rootElement); + if (minX === null || minY === null || minZ === null || maxX === null || maxY === null || maxZ === null) { + return { + min: { x: -0.5, y: -0.5, z: -0.5 }, + max: { x: 0.5, y: 0.5, z: 0.5 } + }; + } + return { + min: { x: minX, y: minY, z: minZ }, + max: { x: maxX, y: maxY, z: maxZ } + }; +} + +// src/env-maps/cloudysky_2k.jpg +var cloudysky_2k_default = "./cloudysky_2k-WS2HEI54.jpg"; + +// src/env-maps/index.ts +var envMaps = { + cloudysky: { + name: "Cloudy Sky", + url: cloudysky_2k_default + } +}; + +// src/parseXYZ.ts +function parseXYZ(str) { + const asNumbers = str.split(",").slice(0, 3).map(parseFloat).map((v) => isNaN(v) ? 0 : v); + return [asNumbers[0] || 0, asNumbers[1] || 0, asNumbers[2] || 0]; +} + +export { + calculateContentBounds, + envMaps, + parseXYZ +}; +//# sourceMappingURL=chunk-CPWJBFSW.js.map diff --git a/pull/212/v1/chunk-CPWJBFSW.js.map b/pull/212/v1/chunk-CPWJBFSW.js.map new file mode 100644 index 00000000..91830e34 --- /dev/null +++ b/pull/212/v1/chunk-CPWJBFSW.js.map @@ -0,0 +1,7 @@ +{ + "version": 3, + "sources": ["../src/calculateContentBounds.ts", "../src/env-maps/index.ts", "../src/parseXYZ.ts"], + "sourcesContent": ["import { IVect3, TransformableElement } from \"@mml-io/mml-web\";\n\nexport function calculateContentBounds(rootElement: Element): { min: IVect3; max: IVect3 } {\n let minX: number | null = null;\n let minY: number | null = null;\n let minZ: number | null = null;\n let maxX: number | null = null;\n let maxY: number | null = null;\n let maxZ: number | null = null;\n const traverse = (element: ChildNode) => {\n if (element instanceof TransformableElement) {\n const bounds = element.getContentBounds();\n if (bounds) {\n bounds.getCorners().forEach((corner) => {\n if (minX === null || corner.x < minX) {\n minX = corner.x;\n }\n if (minY === null || corner.y < minY) {\n minY = corner.y;\n }\n if (minZ === null || corner.z < minZ) {\n minZ = corner.z;\n }\n if (maxX === null || corner.x > maxX) {\n maxX = corner.x;\n }\n if (maxY === null || corner.y > maxY) {\n maxY = corner.y;\n }\n if (maxZ === null || corner.z > maxZ) {\n maxZ = corner.z;\n }\n });\n }\n }\n element.childNodes.forEach((child) => {\n traverse(child);\n });\n };\n traverse(rootElement);\n if (\n minX === null ||\n minY === null ||\n minZ === null ||\n maxX === null ||\n maxY === null ||\n maxZ === null\n ) {\n // Return a default bounding box if no content was found\n return {\n min: { x: -0.5, y: -0.5, z: -0.5 },\n max: { x: 0.5, y: 0.5, z: 0.5 },\n };\n }\n\n return {\n min: { x: minX, y: minY, z: minZ },\n max: { x: maxX, y: maxY, z: maxZ },\n };\n}\n", "type EnvMap = {\n name: string;\n url: string;\n};\n\nimport cloudysky from \"./cloudysky_2k.jpg\";\n\nexport const envMaps: {\n [key: string]: EnvMap;\n} = {\n cloudysky: {\n name: \"Cloudy Sky\",\n url: cloudysky,\n },\n};\n", "export function parseXYZ(str: string): [number, number, number] {\n const asNumbers = str\n .split(\",\")\n .slice(0, 3)\n .map(parseFloat)\n .map((v) => (isNaN(v) ? 0 : v)) as [number, number, number];\n return [asNumbers[0] || 0, asNumbers[1] || 0, asNumbers[2] || 0];\n}\n"], + "mappings": ";;;;;AAEO,SAAS,uBAAuB,aAAoD;AACzF,MAAI,OAAsB;AAC1B,MAAI,OAAsB;AAC1B,MAAI,OAAsB;AAC1B,MAAI,OAAsB;AAC1B,MAAI,OAAsB;AAC1B,MAAI,OAAsB;AAC1B,QAAM,WAAW,CAAC,YAAuB;AACvC,QAAI,mBAAmB,sBAAsB;AAC3C,YAAM,SAAS,QAAQ,iBAAiB;AACxC,UAAI,QAAQ;AACV,eAAO,WAAW,EAAE,QAAQ,CAAC,WAAW;AACtC,cAAI,SAAS,QAAQ,OAAO,IAAI,MAAM;AACpC,mBAAO,OAAO;AAAA,UAChB;AACA,cAAI,SAAS,QAAQ,OAAO,IAAI,MAAM;AACpC,mBAAO,OAAO;AAAA,UAChB;AACA,cAAI,SAAS,QAAQ,OAAO,IAAI,MAAM;AACpC,mBAAO,OAAO;AAAA,UAChB;AACA,cAAI,SAAS,QAAQ,OAAO,IAAI,MAAM;AACpC,mBAAO,OAAO;AAAA,UAChB;AACA,cAAI,SAAS,QAAQ,OAAO,IAAI,MAAM;AACpC,mBAAO,OAAO;AAAA,UAChB;AACA,cAAI,SAAS,QAAQ,OAAO,IAAI,MAAM;AACpC,mBAAO,OAAO;AAAA,UAChB;AAAA,QACF,CAAC;AAAA,MACH;AAAA,IACF;AACA,YAAQ,WAAW,QAAQ,CAAC,UAAU;AACpC,eAAS,KAAK;AAAA,IAChB,CAAC;AAAA,EACH;AACA,WAAS,WAAW;AACpB,MACE,SAAS,QACT,SAAS,QACT,SAAS,QACT,SAAS,QACT,SAAS,QACT,SAAS,MACT;AAEA,WAAO;AAAA,MACL,KAAK,EAAE,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK;AAAA,MACjC,KAAK,EAAE,GAAG,KAAK,GAAG,KAAK,GAAG,IAAI;AAAA,IAChC;AAAA,EACF;AAEA,SAAO;AAAA,IACL,KAAK,EAAE,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK;AAAA,IACjC,KAAK,EAAE,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK;AAAA,EACnC;AACF;;;;;;ACpDO,IAAM,UAET;AAAA,EACF,WAAW;AAAA,IACT,MAAM;AAAA,IACN,KAAK;AAAA,EACP;AACF;;;ACdO,SAAS,SAAS,KAAuC;AAC9D,QAAM,YAAY,IACf,MAAM,GAAG,EACT,MAAM,GAAG,CAAC,EACV,IAAI,UAAU,EACd,IAAI,CAAC,MAAO,MAAM,CAAC,IAAI,IAAI,CAAE;AAChC,SAAO,CAAC,UAAU,CAAC,KAAK,GAAG,UAAU,CAAC,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC;AACjE;", + "names": [] +} diff --git a/pull/212/v1/chunk-OGDCF6KN.js b/pull/212/v1/chunk-OGDCF6KN.js new file mode 100644 index 00000000..1082239f --- /dev/null +++ b/pull/212/v1/chunk-OGDCF6KN.js @@ -0,0 +1,9500 @@ +// ../../node_modules/@mml-io/networked-dom-protocol/build/index.js +var networkedDOMProtocolSubProtocol_v0_1 = "networked-dom-v0.1"; +var textDecoder = new TextDecoder(); +var BufferReader = class { + constructor(buffer) { + this.buffer = buffer; + this.offset = 0; + } + readUInt8() { + return this.buffer[this.offset++]; + } + readBoolean() { + return this.readUInt8() === 1; + } + readUVarint(signed = false) { + let lo = 0; + let hi = 0; + let i = 0; + for (; i < 4; ++i) { + lo = (lo | (this.buffer[this.offset] & 127) << i * 7) >>> 0; + if (this.buffer[this.offset++] < 128) { + return signed ? loAndHiAsSigned(lo, hi) : loAndHiAsUnsigned(lo, hi); + } + } + lo = (lo | (this.buffer[this.offset] & 127) << 28) >>> 0; + hi = (hi | (this.buffer[this.offset] & 127) >> 4) >>> 0; + if (this.buffer[this.offset++] < 128) { + return signed ? loAndHiAsSigned(lo, hi) : loAndHiAsUnsigned(lo, hi); + } + i = 0; + for (; i < 5; ++i) { + hi = (hi | (this.buffer[this.offset] & 127) << i * 7 + 3) >>> 0; + if (this.buffer[this.offset++] < 128) { + return signed ? loAndHiAsSigned(lo, hi) : loAndHiAsUnsigned(lo, hi); + } + } + throw Error("invalid varint encoding"); + } + readUVarintPrefixedString() { + const readLength = this.readUVarint(); + let string = ""; + let hasNonAscii = false; + for (let i = 0; i < readLength; i++) { + const charValue = this.buffer[this.offset + i]; + if (charValue < 128) { + string += String.fromCharCode(charValue); + } else { + hasNonAscii = true; + break; + } + } + if (!hasNonAscii) { + this.offset += readLength; + return string; + } + const result = textDecoder.decode(this.buffer.subarray(this.offset, this.offset + readLength)); + this.offset += readLength; + return result; + } + // returns the string and a boolean indicating if the string was negative length + readVarintPrefixedString() { + const length = this.readVarint(); + const negativeLength = length < 0; + const readLength = negativeLength ? -length : length; + let string = ""; + let hasNonAscii = false; + for (let i = 0; i < readLength; i++) { + const charValue = this.buffer[this.offset + i]; + if (charValue < 128) { + string += String.fromCharCode(charValue); + } else { + hasNonAscii = true; + break; + } + } + if (!hasNonAscii) { + this.offset += readLength; + return [string, negativeLength]; + } + const result = textDecoder.decode(this.buffer.subarray(this.offset, this.offset + readLength)); + this.offset += readLength; + return [result, negativeLength]; + } + readVarint() { + return this.readUVarint(true); + } + isEnd() { + return this.offset >= this.buffer.length; + } +}; +function loAndHiAsSigned(lo, hi) { + const value = lo + hi * 4294967296; + if (value & 1) { + return -(value + 1) / 2; + } + return value / 2; +} +function loAndHiAsUnsigned(lo, hi) { + return lo + hi * 4294967296; +} +var textEncoder = new TextEncoder(); +var BufferWriter = class { + constructor(initialLength) { + this.buffer = new Uint8Array(initialLength); + this.offset = 0; + } + // Write an unsigned 8-bit integer + writeUint8(value) { + this.ensureCapacity(1); + this.buffer[this.offset] = value & 255; + this.offset += 1; + } + writeBoolean(bool) { + this.writeUint8(bool ? 1 : 0); + } + // Write an array of bytes + writeBytes(bytes) { + this.ensureCapacity(bytes.byteLength); + this.buffer.set(bytes, this.offset); + this.offset += bytes.byteLength; + } + // Get the written bytes as a Uint8Array + getBuffer() { + return this.buffer.subarray(0, this.offset); + } + getWrittenLength() { + return this.offset; + } + // Ensure there is enough capacity in the buffer + ensureCapacity(neededSpace) { + while (this.offset + neededSpace > this.buffer.length) { + this.expandBuffer(); + } + } + // Expand the buffer by doubling its current length + expandBuffer() { + const newBuffer = new Uint8Array(this.buffer.length * 2); + newBuffer.set(this.buffer); + this.buffer = newBuffer; + } + writeUVarint(x) { + if (x <= 268435455) { + this.ensureCapacity(4); + while (x >= 128) { + this.buffer[this.offset] = x & 127 | 128; + this.offset++; + x >>>= 7; + } + this.buffer[this.offset] = x & 127; + this.offset++; + return; + } + this.ensureCapacity(10); + let lo = 0; + let hi = 0; + if (x !== 0) { + lo = x >>> 0; + hi = (x - lo) / 4294967296 >>> 0; + } + while (hi) { + this.buffer[this.offset++] = lo & 127 | 128; + lo = (lo >>> 7 | hi << 25) >>> 0; + hi >>>= 7; + } + while (lo > 127) { + this.buffer[this.offset++] = lo & 127 | 128; + lo = lo >>> 7; + } + this.buffer[this.offset++] = lo; + } + writeVarint(x) { + if (x >= 0) { + this.writeUVarint(x * 2); + } else { + this.writeUVarint(-x * 2 - 1); + } + } + writeLengthPrefixedString(value, varint = false, negativeLength = false) { + const originalOffset = this.offset; + if (varint) { + this.writeVarint(negativeLength ? -value.length : value.length); + } else { + this.writeUVarint(value.length); + } + this.ensureCapacity(value.length); + let nonAscii = false; + for (let i = 0; i < value.length; i++) { + const charCode = value.charCodeAt(i); + if (charCode > 127) { + nonAscii = true; + break; + } + this.buffer[this.offset++] = charCode; + } + if (!nonAscii) { + return; + } + this.offset = originalOffset; + let encodedLength = value.length; + this.ensureCapacity(encodedLength); + while (true) { + this.offset = originalOffset; + if (varint) { + this.writeVarint(negativeLength ? -encodedLength : encodedLength); + } else { + this.writeUVarint(encodedLength); + } + const offsetAfterVarint = this.offset; + const varintLength = offsetAfterVarint - originalOffset; + const writeBuffer = new Uint8Array(this.buffer.buffer, this.offset); + const { read, written } = textEncoder.encodeInto(value, writeBuffer); + if (read !== value.length) { + this.expandBuffer(); + continue; + } + if (written !== encodedLength) { + encodedLength = written; + this.offset = originalOffset; + if (varint) { + this.writeVarint(negativeLength ? -encodedLength : encodedLength); + } else { + this.writeUVarint(encodedLength); + } + const newOffsetAfterVarint = this.offset; + const actualVarintLength = newOffsetAfterVarint - originalOffset; + if (actualVarintLength !== varintLength) { + continue; + } else { + } + } + this.offset += written; + return; + } + } +}; +function decodeAttributes(buffer) { + const attributesLength = buffer.readUVarint(); + const attributes = []; + for (let i = 0; i < attributesLength; i++) { + const [key, negativeLength] = buffer.readVarintPrefixedString(); + if (negativeLength) { + attributes.push([key, null]); + continue; + } + const value = buffer.readUVarintPrefixedString(); + attributes.push([key, value]); + } + return attributes; +} +function decodeNodeDescription(buffer) { + const nodeId = buffer.readUVarint(); + const tag = buffer.readUVarintPrefixedString(); + if (tag === "") { + const text = buffer.readUVarintPrefixedString(); + return { type: "text", nodeId, text }; + } + const attributes = decodeAttributes(buffer); + const visibleToLength = buffer.readUVarint(); + let visibleTo; + if (visibleToLength !== 0) { + visibleTo = []; + for (let i = 0; i < visibleToLength; i++) { + visibleTo.push(buffer.readUVarint()); + } + } + const hiddenFromLength = buffer.readUVarint(); + let hiddenFrom; + if (hiddenFromLength !== 0) { + hiddenFrom = []; + for (let i = 0; i < hiddenFromLength; i++) { + hiddenFrom.push(buffer.readUVarint()); + } + } + const childrenLength = buffer.readUVarint(); + const children = []; + for (let i = 0; i < childrenLength; i++) { + children.push(decodeNodeDescription(buffer)); + } + const node = { + type: "element", + nodeId, + tag, + attributes, + children + }; + if (visibleTo) { + node.visibleTo = visibleTo; + } + if (hiddenFrom) { + node.hiddenFrom = hiddenFrom; + } + return node; +} +var networkedDOMProtocolSubProtocol_v0_2 = "networked-dom-v0.2"; +var SnapshotMessageType = 1; +var BatchStartMessageType = 2; +var DocumentTimeMessageType = 3; +var ChildrenAddedMessageType = 4; +var ChildrenRemovedMessageType = 5; +var AttributesChangedMessageType = 6; +var ChangeVisibleToMessageType = 7; +var ChangeHiddenFromMessageType = 8; +var TextChangedMessageType = 9; +var BatchEndMessageType = 10; +var PingMessageType = 11; +var WarningMessageType = 12; +var ErrorMessageType = 13; +var ConnectUsersMessageType = 14; +var DisconnectUsersMessageType = 15; +var EventMessageType = 16; +var PongMessageType = 17; +function encodeConnectUsers(connectUsersMessage, writer) { + const connectionIdsLength = connectUsersMessage.connectionIds.length; + writer.writeUint8(ConnectUsersMessageType); + writer.writeUVarint(connectionIdsLength); + for (let i = 0; i < connectionIdsLength; i++) { + writer.writeUVarint(connectUsersMessage.connectionIds[i]); + } +} +function encodeDisconnectUsers(disconnectUsersMessage, writer) { + const connectionIdsLength = disconnectUsersMessage.connectionIds.length; + writer.writeUint8(DisconnectUsersMessageType); + writer.writeUVarint(connectionIdsLength); + for (let i = 0; i < connectionIdsLength; i++) { + writer.writeUVarint(disconnectUsersMessage.connectionIds[i]); + } +} +function encodeEvent(event, writer) { + writer.writeUint8(EventMessageType); + writer.writeUVarint(event.nodeId); + writer.writeUVarint(event.connectionId); + writer.writeLengthPrefixedString(event.name); + writer.writeBoolean(event.bubbles); + writer.writeLengthPrefixedString(JSON.stringify(event.params)); +} +function encodePong(pongMessage, writer) { + writer.writeUint8(PongMessageType); + writer.writeUVarint(pongMessage.pong); +} +function decodeAttributesChanged(buffer) { + const nodeId = buffer.readUVarint(); + const attributes = decodeAttributes(buffer); + return { + type: "attributesChanged", + nodeId, + attributes + }; +} +var batchEndMessage = { + type: "batchEnd" +}; +var batchStartMessage = { + type: "batchStart" +}; +function decodeChangeHiddenFrom(buffer) { + const nodeId = buffer.readUVarint(); + const addHiddenFromLength = buffer.readUVarint(); + const addHiddenFrom = []; + for (let i = 0; i < addHiddenFromLength; i++) { + addHiddenFrom.push(buffer.readUVarint()); + } + const removeHiddenFromLength = buffer.readUVarint(); + const removeHiddenFrom = []; + for (let i = 0; i < removeHiddenFromLength; i++) { + removeHiddenFrom.push(buffer.readUVarint()); + } + return { + type: "changeHiddenFrom", + nodeId, + addHiddenFrom, + removeHiddenFrom + }; +} +function decodeChangeVisibleTo(buffer) { + const nodeId = buffer.readUVarint(); + const addVisibleToLength = buffer.readUVarint(); + const addVisibleTo = []; + for (let i = 0; i < addVisibleToLength; i++) { + addVisibleTo.push(buffer.readUVarint()); + } + const removeVisibleToLength = buffer.readUVarint(); + const removeVisibleTo = []; + for (let i = 0; i < removeVisibleToLength; i++) { + removeVisibleTo.push(buffer.readUVarint()); + } + return { + type: "changeVisibleTo", + nodeId, + addVisibleTo, + removeVisibleTo + }; +} +function decodeChildrenAdded(buffer) { + const nodeId = buffer.readUVarint(); + const previousNodeId = buffer.readUVarint(); + const childrenLength = buffer.readUVarint(); + const children = []; + for (let i = 0; i < childrenLength; i++) { + children.push(decodeNodeDescription(buffer)); + } + return { + type: "childrenAdded", + nodeId, + previousNodeId: previousNodeId === 0 ? null : previousNodeId, + addedNodes: children + }; +} +function decodeChildrenRemoved(buffer) { + const nodeId = buffer.readUVarint(); + const removedNodesLength = buffer.readUVarint(); + const removedNodes = []; + for (let i = 0; i < removedNodesLength; i++) { + removedNodes.push(buffer.readUVarint()); + } + return { + type: "childrenRemoved", + nodeId, + removedNodes + }; +} +function decodeDocumentTime(buffer) { + return { + type: "documentTime", + documentTime: buffer.readUVarint() + }; +} +function decodeError(buffer) { + const message = buffer.readUVarintPrefixedString(); + return { + type: "error", + message + }; +} +function decodePing(buffer) { + const ping = buffer.readUVarint(); + const documentTime = buffer.readUVarint(); + return { + type: "ping", + ping, + documentTime + }; +} +function decodeSnapshot(buffer) { + return { + type: "snapshot", + snapshot: decodeNodeDescription(buffer), + documentTime: buffer.readUVarint() + }; +} +function decodeTextChanged(buffer) { + const nodeId = buffer.readUVarint(); + const text = buffer.readUVarintPrefixedString(); + return { + type: "textChanged", + nodeId, + text + }; +} +function decodeWarning(buffer) { + const message = buffer.readUVarintPrefixedString(); + return { + type: "warning", + message + }; +} +function decodeServerMessages(buffer) { + const messages = []; + while (!buffer.isEnd()) { + const messageType = buffer.readUInt8(); + switch (messageType) { + case SnapshotMessageType: + messages.push(decodeSnapshot(buffer)); + break; + case DocumentTimeMessageType: + messages.push(decodeDocumentTime(buffer)); + break; + case ChildrenAddedMessageType: + messages.push(decodeChildrenAdded(buffer)); + break; + case ChildrenRemovedMessageType: + messages.push(decodeChildrenRemoved(buffer)); + break; + case AttributesChangedMessageType: + messages.push(decodeAttributesChanged(buffer)); + break; + case TextChangedMessageType: + messages.push(decodeTextChanged(buffer)); + break; + case ChangeVisibleToMessageType: + messages.push(decodeChangeVisibleTo(buffer)); + break; + case ChangeHiddenFromMessageType: + messages.push(decodeChangeHiddenFrom(buffer)); + break; + case BatchStartMessageType: + messages.push(batchStartMessage); + break; + case BatchEndMessageType: + messages.push(batchEndMessage); + break; + case PingMessageType: + messages.push(decodePing(buffer)); + break; + case WarningMessageType: + messages.push(decodeWarning(buffer)); + break; + case ErrorMessageType: + messages.push(decodeError(buffer)); + break; + default: + throw new Error(`Unknown message type: ${messageType}`); + } + } + return messages; +} +function encodeClientMessage(message, writer) { + const type = message.type; + switch (type) { + case "connectUsers": + return encodeConnectUsers(message, writer); + case "disconnectUsers": + return encodeDisconnectUsers(message, writer); + case "event": + return encodeEvent(message, writer); + case "pong": + return encodePong(message, writer); + default: + throw new Error(`Unknown message type: ${type}`); + } +} + +// ../../node_modules/@mml-io/networked-dom-web/build/index.js +var DOMSanitizer = class _DOMSanitizer { + static sanitise(node, options = {}) { + if (node.getAttributeNames) { + for (const attr of node.getAttributeNames()) { + if (!_DOMSanitizer.IsValidAttributeName(attr)) { + node.removeAttribute(attr); + } + } + } + if (node instanceof HTMLElement) { + if (options.tagPrefix) { + const tag = node.nodeName.toLowerCase(); + if (!tag.startsWith(options.tagPrefix.toLowerCase())) { + node = _DOMSanitizer.replaceNodeTagName( + node, + options.replacementTagPrefix ? options.replacementTagPrefix + tag : `x-${tag}` + ); + } + } + } + if (node.nodeName === "SCRIPT" || node.nodeName === "OBJECT" || node.nodeName === "IFRAME") { + node.innerHTML = ""; + _DOMSanitizer.stripAllAttributes(node); + } else { + if (node.getAttributeNames) { + for (const attr of node.getAttributeNames()) { + if (!_DOMSanitizer.shouldAcceptAttribute(attr)) { + node.removeAttribute(attr); + } + } + } + for (let i = 0; i < node.childNodes.length; i++) { + _DOMSanitizer.sanitise(node.childNodes[i], options); + } + } + return node; + } + static replaceNodeTagName(node, newTagName) { + var _a; + const replacementNode = document.createElement(newTagName); + let index; + while (node.firstChild) { + replacementNode.appendChild(node.firstChild); + } + for (index = node.attributes.length - 1; index >= 0; --index) { + replacementNode.setAttribute(node.attributes[index].name, node.attributes[index].value); + } + (_a = node.parentNode) == null ? void 0 : _a.replaceChild(replacementNode, node); + return replacementNode; + } + static stripAllAttributes(node) { + if (node.getAttributeNames) { + for (const attr of node.getAttributeNames()) { + node.removeAttribute(attr); + } + } + } + static IsASCIIDigit(c) { + return c >= "0" && c <= "9"; + } + static IsASCIIAlpha(c) { + return c >= "a" && c <= "z"; + } + static IsValidAttributeName(characters) { + const c = characters[0]; + if (!(_DOMSanitizer.IsASCIIAlpha(c) || c === ":" || c === "_")) { + return false; + } + for (let i = 1; i < characters.length; i++) { + const c2 = characters[i]; + if (!(_DOMSanitizer.IsASCIIDigit(c2) || _DOMSanitizer.IsASCIIAlpha(c2) || c2 === ":" || c2 === "_" || c2 === "-" || c2 === ".")) { + return false; + } + } + return true; + } + static shouldAcceptAttribute(attribute) { + if (!_DOMSanitizer.IsValidAttributeName(attribute)) { + console.warn("Invalid attribute name", attribute); + return false; + } + return !attribute.startsWith("on"); + } +}; +var NetworkedDOMWebsocketV01Adapter = class { + constructor(websocket, parentElement, connectedCallback, timeCallback, options = {}) { + this.websocket = websocket; + this.parentElement = parentElement; + this.connectedCallback = connectedCallback; + this.timeCallback = timeCallback; + this.options = options; + this.idToElement = /* @__PURE__ */ new Map(); + this.elementToId = /* @__PURE__ */ new Map(); + this.currentRoot = null; + this.websocket.binaryType = "arraybuffer"; + } + handleEvent(element, event) { + const nodeId = this.elementToId.get(element); + if (nodeId === void 0 || nodeId === null) { + throw new Error("Element not found"); + } + const detailWithoutElement = { + ...event.detail + }; + delete detailWithoutElement.element; + const remoteEvent = { + type: "event", + nodeId, + name: event.type, + bubbles: event.bubbles, + params: detailWithoutElement + }; + this.send(remoteEvent); + } + send(fromClientMessage) { + this.websocket.send(JSON.stringify(fromClientMessage)); + } + clearContents() { + this.idToElement.clear(); + this.elementToId.clear(); + if (this.currentRoot) { + this.currentRoot.remove(); + this.currentRoot = null; + return true; + } + return false; + } + receiveMessage(event) { + const messages = JSON.parse(event.data); + for (const message of messages) { + switch (message.type) { + case "error": + console.error("Error from server", message); + break; + case "warning": + console.warn("Warning from server", message); + break; + default: { + if (message.documentTime) { + if (this.timeCallback) { + this.timeCallback(message.documentTime); + } + } + switch (message.type) { + case "snapshot": + this.handleSnapshot(message); + this.connectedCallback(); + break; + case "attributeChange": + this.handleAttributeChange(message); + break; + case "childrenChanged": + this.handleChildrenChanged(message); + break; + case "textChanged": + this.handleTextChanged(message); + break; + case "ping": + this.send({ + type: "pong", + pong: message.ping + }); + break; + default: + console.warn("unknown message type", message); + break; + } + } + } + } + } + handleTextChanged(message) { + const { nodeId, text } = message; + if (nodeId === void 0 || nodeId === null) { + console.warn("No nodeId in textChanged message"); + return; + } + const node = this.idToElement.get(nodeId); + if (!node) { + throw new Error("No node found for textChanged message"); + } + if (!isText(node, this.parentElement)) { + throw new Error("Node for textChanged message is not a Text node"); + } + node.textContent = text; + } + handleChildrenChanged(message) { + const { nodeId, addedNodes, removedNodes, previousNodeId } = message; + if (nodeId === void 0 || nodeId === null) { + console.warn("No nodeId in childrenChanged message"); + return; + } + const parent = this.idToElement.get(nodeId); + if (!parent) { + throw new Error("No parent found for childrenChanged message"); + } + if (!parent.isConnected) { + console.error("Parent is not connected", parent); + } + if (!isHTMLElement(parent, this.parentElement)) { + throw new Error("Parent is not an HTMLElement (that supports children)"); + } + let nextElement = null; + let previousElement = null; + if (previousNodeId) { + previousElement = this.idToElement.get(previousNodeId); + if (!previousElement) { + throw new Error("No previous element found for childrenChanged message"); + } + nextElement = previousElement.nextSibling; + } + const elementsToAdd = []; + for (const addedNode of addedNodes) { + const childElement = this.handleNewElement(addedNode); + if (childElement) { + elementsToAdd.push(childElement); + } + } + if (elementsToAdd.length) { + if (previousElement) { + if (nextElement) { + const docFrag = new DocumentFragment(); + docFrag.append(...elementsToAdd); + parent.insertBefore(docFrag, nextElement); + } else { + parent.append(...elementsToAdd); + } + } else { + parent.prepend(...elementsToAdd); + } + } + for (const removedNode of removedNodes) { + const childElement = this.idToElement.get(removedNode); + if (!childElement) { + throw new Error(`Child element not found: ${removedNode}`); + } + this.elementToId.delete(childElement); + this.idToElement.delete(removedNode); + parent.removeChild(childElement); + if (isHTMLElement(childElement, this.parentElement)) { + this.removeChildElementIds(childElement); + } + } + } + removeChildElementIds(parent) { + for (let i = 0; i < parent.children.length; i++) { + const child = parent.children[i]; + const childId = this.elementToId.get(child); + if (!childId) { + console.error("Inner child of removed element had no id", child); + } else { + this.elementToId.delete(child); + this.idToElement.delete(childId); + } + this.removeChildElementIds(child); + } + } + handleSnapshot(message) { + if (this.currentRoot) { + this.currentRoot.remove(); + this.currentRoot = null; + this.elementToId.clear(); + this.idToElement.clear(); + } + const element = this.handleNewElement(message.snapshot); + if (!element) { + throw new Error("Snapshot element not created"); + } + if (!isHTMLElement(element, this.parentElement)) { + throw new Error("Snapshot element is not an HTMLElement"); + } + this.currentRoot = element; + this.parentElement.append(element); + } + handleAttributeChange(message) { + const { nodeId, attribute, newValue } = message; + if (nodeId === void 0 || nodeId === null) { + console.warn("No nodeId in attributeChange message"); + return; + } + const element = this.idToElement.get(nodeId); + if (element) { + if (isHTMLElement(element, this.parentElement)) { + if (newValue === null) { + element.removeAttribute(attribute); + } else { + if (DOMSanitizer.shouldAcceptAttribute(attribute)) { + element.setAttribute(attribute, newValue); + } + } + } else { + console.error("Element is not an HTMLElement and cannot support attributes", element); + } + } else { + console.error("No element found for attributeChange message"); + } + } + handleNewElement(message) { + if (message.type === "text") { + const { nodeId: nodeId2, text: text2 } = message; + const textNode = document.createTextNode(""); + textNode.textContent = text2; + this.idToElement.set(nodeId2, textNode); + this.elementToId.set(textNode, nodeId2); + return textNode; + } + const { tag, nodeId, attributes, children, text } = message; + if (nodeId === void 0 || nodeId === null) { + console.warn("No nodeId in handleNewElement message", message); + return null; + } + if (this.idToElement.has(nodeId)) { + console.error( + "Received nodeId to add that is already present", + nodeId, + this.idToElement.get(nodeId) + ); + } + if (tag === "#text") { + const textNode = document.createTextNode(""); + textNode.textContent = text || null; + this.idToElement.set(nodeId, textNode); + this.elementToId.set(textNode, nodeId); + return textNode; + } + let element; + try { + let filteredTag = tag; + if (this.options.tagPrefix) { + if (!tag.toLowerCase().startsWith(this.options.tagPrefix.toLowerCase())) { + filteredTag = this.options.replacementTagPrefix ? this.options.replacementTagPrefix + tag : `x-${tag}`; + } + } + element = document.createElement(filteredTag); + } catch (e) { + console.error(`Error creating element: (${tag})`, e); + element = document.createElement("x-div"); + } + this.idToElement.set(nodeId, element); + this.elementToId.set(element, nodeId); + for (const key in attributes) { + if (DOMSanitizer.shouldAcceptAttribute(key)) { + const value = attributes[key]; + element.setAttribute(key, value); + } + } + if (children) { + for (const child of children) { + const childElement = this.handleNewElement(child); + if (childElement) { + element.append(childElement); + } + } + } + return element; + } +}; +var connectionId = 1; +var hiddenTag = "x-hidden"; +var NetworkedDOMWebsocketV02Adapter = class { + constructor(websocket, parentElement, connectedCallback, timeCallback, options = {}) { + this.websocket = websocket; + this.parentElement = parentElement; + this.connectedCallback = connectedCallback; + this.timeCallback = timeCallback; + this.options = options; + this.idToElement = /* @__PURE__ */ new Map(); + this.elementToId = /* @__PURE__ */ new Map(); + this.hiddenPlaceholderElements = /* @__PURE__ */ new Map(); + this.currentRoot = null; + this.batchMode = false; + this.batchMessages = []; + this.websocket.binaryType = "arraybuffer"; + this.send({ type: "connectUsers", connectionIds: [connectionId] }); + } + handleEvent(element, event) { + const nodeId = this.elementToId.get(element); + if (nodeId === void 0 || nodeId === null) { + throw new Error("Element not found"); + } + const detailWithoutElement = { + ...event.detail + }; + delete detailWithoutElement.element; + const remoteEvent = { + type: "event", + nodeId, + connectionId, + name: event.type, + bubbles: event.bubbles, + params: detailWithoutElement + }; + this.send(remoteEvent); + } + send(message) { + const writer = new BufferWriter(256); + encodeClientMessage(message, writer); + this.websocket.send(writer.getBuffer()); + } + clearContents() { + this.idToElement.clear(); + this.elementToId.clear(); + if (this.currentRoot) { + this.currentRoot.remove(); + this.currentRoot = null; + return true; + } + return false; + } + receiveMessage(event) { + const reader = new BufferReader(new Uint8Array(event.data)); + const messages = decodeServerMessages(reader); + for (const message of messages) { + if (message.type === "batchStart") { + this.batchMode = true; + } else if (message.type === "batchEnd") { + this.batchMode = false; + for (const message2 of this.batchMessages) { + this.applyMessage(message2); + } + this.batchMessages = []; + } else { + if (this.batchMode) { + this.batchMessages.push(message); + } else { + this.applyMessage(message); + } + } + } + } + applyMessage(message) { + switch (message.type) { + case "error": + console.error("Error from server", message); + break; + case "warning": + console.warn("Warning from server", message); + break; + case "snapshot": + this.handleSnapshot(message); + this.connectedCallback(); + break; + case "attributesChanged": + this.handleAttributeChange(message); + break; + case "documentTime": + this.handleDocumentTime(message); + break; + case "childrenAdded": + this.handleChildrenAdded(message); + break; + case "changeHiddenFrom": + this.handleChangeHiddenFrom(message); + break; + case "childrenRemoved": + this.handleChildrenRemoved(message); + break; + case "textChanged": + this.handleTextChanged(message); + break; + case "ping": + this.handlePing(message); + break; + default: + console.warn("unknown message type", message); + break; + } + } + handleTextChanged(message) { + const { nodeId, text } = message; + if (nodeId === void 0 || nodeId === null) { + console.warn("No nodeId in textChanged message"); + return; + } + const node = this.idToElement.get(nodeId); + if (!node) { + throw new Error("No node found for textChanged message"); + } + if (!isText(node, this.parentElement)) { + throw new Error("Node for textChanged message is not a Text node"); + } + node.textContent = text; + } + handleChangeHiddenFrom(message) { + const { nodeId, addHiddenFrom, removeHiddenFrom } = message; + const node = this.idToElement.get(nodeId); + const hiddenElement = this.hiddenPlaceholderElements.get(nodeId); + if (addHiddenFrom.length > 0 && addHiddenFrom.indexOf(connectionId) !== -1) { + if (hiddenElement) { + return; + } + if (!node) { + throw new Error("No node found for changeHiddenFrom message"); + } + const parent = node.parentElement; + if (!parent) { + throw new Error("Node has no parent"); + } + const placeholder = document.createElement(hiddenTag); + parent.replaceChild(placeholder, node); + this.hiddenPlaceholderElements.set(nodeId, { placeholder, element: node }); + } else if (removeHiddenFrom.length > 0 && removeHiddenFrom.indexOf(connectionId) !== -1) { + if (!hiddenElement) { + return; + } + const { placeholder, element } = hiddenElement; + const parent = placeholder.parentElement; + if (!parent) { + throw new Error("Placeholder has no parent"); + } + parent.replaceChild(element, placeholder); + this.hiddenPlaceholderElements.delete(nodeId); + } + } + handleChildrenAdded(message) { + const { nodeId, addedNodes, previousNodeId } = message; + if (nodeId === void 0 || nodeId === null) { + console.warn("No nodeId in childrenChanged message"); + return; + } + let parent = this.idToElement.get(nodeId); + if (!parent) { + throw new Error("No parent found for childrenChanged message"); + } + const hiddenParent = this.hiddenPlaceholderElements.get(nodeId); + if (hiddenParent) { + parent = hiddenParent.element; + } else { + if (!parent.isConnected) { + console.error("Parent is not connected", parent); + } + } + if (!isHTMLElement(parent, this.parentElement)) { + throw new Error("Parent is not an HTMLElement (that supports children)"); + } + let nextElement = null; + let previousElement = null; + if (previousNodeId) { + previousElement = this.idToElement.get(previousNodeId); + if (!previousElement) { + throw new Error("No previous element found for childrenChanged message"); + } + nextElement = previousElement.nextSibling; + } + const elementsToAdd = []; + for (const addedNode of addedNodes) { + const childElement = this.handleNewElement(addedNode); + if (childElement) { + elementsToAdd.push(childElement); + } + } + if (elementsToAdd.length) { + if (previousElement) { + if (nextElement) { + const docFrag = new DocumentFragment(); + docFrag.append(...elementsToAdd); + parent.insertBefore(docFrag, nextElement); + } else { + parent.append(...elementsToAdd); + } + } else { + parent.prepend(...elementsToAdd); + } + } + } + handleChildrenRemoved(message) { + const { nodeId, removedNodes } = message; + if (nodeId === void 0 || nodeId === null) { + console.warn("No nodeId in childrenChanged message"); + return; + } + const parent = this.idToElement.get(nodeId); + if (!parent) { + throw new Error("No parent found for childrenChanged message"); + } + if (!parent.isConnected) { + console.error("Parent is not connected", parent); + } + if (!isHTMLElement(parent, this.parentElement)) { + throw new Error("Parent is not an HTMLElement (that supports children)"); + } + for (const removedNode of removedNodes) { + const childElement = this.idToElement.get(removedNode); + if (!childElement) { + throw new Error(`Child element not found: ${removedNode}`); + } + this.elementToId.delete(childElement); + this.idToElement.delete(removedNode); + this.hiddenPlaceholderElements.delete(removedNode); + parent.removeChild(childElement); + if (isHTMLElement(childElement, this.parentElement)) { + this.removeChildElementIds(childElement); + } + } + } + removeChildElementIds(parent) { + for (let i = 0; i < parent.children.length; i++) { + const child = parent.children[i]; + const childId = this.elementToId.get(child); + if (!childId) { + console.error("Inner child of removed element had no id", child); + } else { + this.elementToId.delete(child); + this.idToElement.delete(childId); + this.hiddenPlaceholderElements.delete(childId); + } + this.removeChildElementIds(child); + } + } + handleSnapshot(message) { + var _a; + if (this.currentRoot) { + this.currentRoot.remove(); + this.currentRoot = null; + this.elementToId.clear(); + this.idToElement.clear(); + } + (_a = this.timeCallback) == null ? void 0 : _a.call(this, message.documentTime); + const element = this.handleNewElement(message.snapshot); + if (!element) { + throw new Error("Snapshot element not created"); + } + if (!isHTMLElement(element, this.parentElement)) { + throw new Error("Snapshot element is not an HTMLElement"); + } + this.currentRoot = element; + this.parentElement.append(element); + } + handleDocumentTime(message) { + var _a; + (_a = this.timeCallback) == null ? void 0 : _a.call(this, message.documentTime); + } + handleAttributeChange(message) { + const { nodeId, attributes } = message; + if (nodeId === void 0 || nodeId === null) { + console.warn("No nodeId in attributeChange message"); + return; + } + let element = this.idToElement.get(nodeId); + const hiddenElement = this.hiddenPlaceholderElements.get(nodeId); + if (hiddenElement) { + element = hiddenElement.element; + } + if (element) { + if (isHTMLElement(element, this.parentElement)) { + for (const [key, newValue] of attributes) { + if (newValue === null) { + element.removeAttribute(key); + } else { + if (DOMSanitizer.shouldAcceptAttribute(key)) { + element.setAttribute(key, newValue); + } + } + } + } else { + console.error("Element is not an HTMLElement and cannot support attributes", element); + } + } else { + console.error("No element found for attributeChange message"); + } + } + handleNewElement(message) { + if (message.type === "text") { + const { nodeId: nodeId2, text: text2 } = message; + const textNode = document.createTextNode(""); + textNode.textContent = text2; + this.idToElement.set(nodeId2, textNode); + this.elementToId.set(textNode, nodeId2); + return textNode; + } + const { tag, nodeId, attributes, children, text, hiddenFrom } = message; + if (this.idToElement.has(nodeId)) { + console.error( + "Received nodeId to add that is already present", + nodeId, + this.idToElement.get(nodeId) + ); + return null; + } + if (tag === "#text") { + const textNode = document.createTextNode(""); + textNode.textContent = text || null; + this.idToElement.set(nodeId, textNode); + this.elementToId.set(textNode, nodeId); + return textNode; + } + let element; + try { + let filteredTag = tag; + if (this.options.tagPrefix) { + if (!tag.toLowerCase().startsWith(this.options.tagPrefix.toLowerCase())) { + filteredTag = this.options.replacementTagPrefix ? this.options.replacementTagPrefix + tag : `x-${tag}`; + } + } + element = document.createElement(filteredTag); + } catch (e) { + console.error(`Error creating element: (${tag})`, e); + element = document.createElement("x-div"); + } + for (const [key, value] of attributes) { + if (value !== null) { + if (DOMSanitizer.shouldAcceptAttribute(key)) { + element.setAttribute(key, value); + } + } + } + if (children) { + for (const child of children) { + const childElement = this.handleNewElement(child); + if (childElement) { + element.append(childElement); + } + } + } + if (hiddenFrom && hiddenFrom.length > 0 && hiddenFrom.indexOf(connectionId) !== -1) { + const placeholder = document.createElement(hiddenTag); + this.idToElement.set(nodeId, placeholder); + this.elementToId.set(placeholder, nodeId); + this.hiddenPlaceholderElements.set(nodeId, { placeholder, element }); + return placeholder; + } else { + this.idToElement.set(nodeId, element); + this.elementToId.set(element, nodeId); + return element; + } + } + handlePing(message) { + var _a; + (_a = this.timeCallback) == null ? void 0 : _a.call(this, message.documentTime); + this.send({ + type: "pong", + pong: message.ping + }); + } +}; +var startingBackoffTimeMilliseconds = 100; +var maximumBackoffTimeMilliseconds = 1e4; +var maximumWebsocketConnectionTimeout = 5e3; +var NetworkedDOMWebsocketStatus = /* @__PURE__ */ ((NetworkedDOMWebsocketStatus2) => { + NetworkedDOMWebsocketStatus2[NetworkedDOMWebsocketStatus2["Connecting"] = 0] = "Connecting"; + NetworkedDOMWebsocketStatus2[NetworkedDOMWebsocketStatus2["ConnectionOpen"] = 1] = "ConnectionOpen"; + NetworkedDOMWebsocketStatus2[NetworkedDOMWebsocketStatus2["Connected"] = 2] = "Connected"; + NetworkedDOMWebsocketStatus2[NetworkedDOMWebsocketStatus2["Reconnecting"] = 3] = "Reconnecting"; + NetworkedDOMWebsocketStatus2[NetworkedDOMWebsocketStatus2["Disconnected"] = 4] = "Disconnected"; + return NetworkedDOMWebsocketStatus2; +})(NetworkedDOMWebsocketStatus || {}); +function NetworkedDOMWebsocketStatusToString(status) { + switch (status) { + case 0: + return "Connecting..."; + case 1: + return "Connection Open"; + case 2: + return "Connected"; + case 3: + return "Reconnecting..."; + case 4: + return "Disconnected"; + default: + return "Unknown"; + } +} +var NetworkedDOMWebsocket = class { + constructor(url, websocketFactory, parentElement, timeCallback, statusUpdateCallback, options = {}) { + this.url = url; + this.websocketFactory = websocketFactory; + this.parentElement = parentElement; + this.timeCallback = timeCallback; + this.statusUpdateCallback = statusUpdateCallback; + this.options = options; + this.websocket = null; + this.websocketAdapter = null; + this.stopped = false; + this.backoffTime = startingBackoffTimeMilliseconds; + this.status = null; + this.setStatus( + 0 + /* Connecting */ + ); + this.startWebSocketConnectionAttempt(); + } + static createWebSocket(url) { + return new WebSocket(url, [ + networkedDOMProtocolSubProtocol_v0_2, + networkedDOMProtocolSubProtocol_v0_1 + ]); + } + setStatus(status) { + if (this.status !== status) { + this.status = status; + if (this.statusUpdateCallback) { + this.statusUpdateCallback(status); + } + } + } + createWebsocketWithTimeout(timeout) { + return new Promise((resolve, reject) => { + const timeoutId = setTimeout(() => { + reject(new Error("websocket connection timed out")); + }, timeout); + const websocket = this.websocketFactory(this.url); + websocket.binaryType = "arraybuffer"; + websocket.addEventListener("open", () => { + clearTimeout(timeoutId); + this.websocket = websocket; + const isV02 = websocket.protocol === networkedDOMProtocolSubProtocol_v0_2; + let websocketAdapter; + if (isV02) { + websocketAdapter = new NetworkedDOMWebsocketV02Adapter( + websocket, + this.parentElement, + () => { + this.backoffTime = startingBackoffTimeMilliseconds; + this.setStatus( + 2 + /* Connected */ + ); + }, + this.timeCallback, + this.options + ); + } else { + websocketAdapter = new NetworkedDOMWebsocketV01Adapter( + websocket, + this.parentElement, + () => { + this.backoffTime = startingBackoffTimeMilliseconds; + this.setStatus( + 2 + /* Connected */ + ); + }, + this.timeCallback, + this.options + ); + } + this.websocketAdapter = websocketAdapter; + websocket.addEventListener("message", (event) => { + if (websocket !== this.websocket) { + console.log("Ignoring websocket message event because it is no longer current"); + websocket.close(); + return; + } + websocketAdapter.receiveMessage(event); + }); + const onWebsocketClose = async () => { + let hadContents = false; + if (this.websocketAdapter) { + hadContents = this.websocketAdapter.clearContents(); + } + if (this.stopped) { + this.setStatus( + 4 + /* Disconnected */ + ); + return; + } + if (!hadContents) { + await this.waitBackoffTime(); + } + this.setStatus( + 3 + /* Reconnecting */ + ); + this.startWebSocketConnectionAttempt(); + }; + websocket.addEventListener("close", () => { + if (websocket !== this.websocket) { + console.warn("Ignoring websocket close event because it is no longer current"); + return; + } + onWebsocketClose(); + }); + websocket.addEventListener("error", (e) => { + if (websocket !== this.websocket) { + console.log("Ignoring websocket error event because it is no longer current"); + return; + } + console.error("NetworkedDOMWebsocket error", e); + onWebsocketClose(); + }); + this.setStatus( + 1 + /* ConnectionOpen */ + ); + resolve(websocket); + }); + websocket.addEventListener("error", (e) => { + clearTimeout(timeoutId); + reject(e); + }); + }); + } + async waitBackoffTime() { + console.warn(`Websocket connection to '${this.url}' failed: retrying in ${this.backoffTime}ms`); + await new Promise((resolve) => setTimeout(resolve, this.backoffTime)); + this.backoffTime = Math.min( + // Introduce a small amount of randomness to prevent clients from retrying in lockstep + this.backoffTime * (1.5 + Math.random() * 0.5), + maximumBackoffTimeMilliseconds + ); + } + async startWebSocketConnectionAttempt() { + if (this.stopped) { + return; + } + while (true) { + if (this.stopped) { + return; + } + try { + await this.createWebsocketWithTimeout(maximumWebsocketConnectionTimeout); + break; + } catch (e) { + console.error("Websocket connection failed", e); + this.setStatus( + 3 + /* Reconnecting */ + ); + await this.waitBackoffTime(); + } + } + } + stop() { + this.stopped = true; + if (this.websocket !== null) { + this.websocket.close(); + this.websocket = null; + } + } + handleEvent(element, event) { + if (this.websocketAdapter) { + this.websocketAdapter.handleEvent(element, event); + } + } +}; +function isHTMLElement(node, rootNode) { + if (node instanceof HTMLElement) { + return true; + } + if (!rootNode.ownerDocument.defaultView) { + return false; + } + return node instanceof rootNode.ownerDocument.defaultView.HTMLElement; +} +function isText(node, rootNode) { + if (node instanceof Text) { + return true; + } + if (!rootNode.ownerDocument.defaultView) { + return false; + } + return node instanceof rootNode.ownerDocument.defaultView.Text; +} + +// ../../node_modules/@mml-io/mml-web/build/index.js +function lerpHSL(colorA, colorB, alpha) { + const hslA = getHSL(colorA); + const hslB = getHSL(colorB); + const h = hslA.h + (hslB.h - hslA.h) * alpha; + const s = hslA.s + (hslB.s - hslA.s) * alpha; + const l = hslA.l + (hslB.l - hslA.l) * alpha; + return hslToRGB(h, s, l); +} +function hue2RGB(p, q, t) { + if (t < 0) t += 1; + if (t > 1) t -= 1; + if (t < 1 / 6) return p + (q - p) * 6 * t; + if (t < 1 / 2) return q; + if (t < 2 / 3) return p + (q - p) * 6 * (2 / 3 - t); + return p; +} +function euclideanModulo(n, m) { + return (n % m + m) % m; +} +function hslToRGB(h, s, l) { + h = euclideanModulo(h, 1); + s = Math.max(0, Math.min(s, 1)); + l = Math.max(0, Math.min(l, 1)); + if (s === 0) { + return { r: l, g: l, b: l }; + } else { + const p = l <= 0.5 ? l * (1 + s) : l + s - l * s; + const q = 2 * l - p; + return { + r: hue2RGB(q, p, h + 1 / 3), + g: hue2RGB(q, p, h), + b: hue2RGB(q, p, h - 1 / 3) + }; + } +} +function getHSL(source) { + const r = source.r, g = source.g, b = source.b; + const max = Math.max(r, g, b); + const min = Math.min(r, g, b); + let hue = 0; + let saturation = 0; + const lightness = (min + max) / 2; + if (min === max) { + hue = 0; + saturation = 0; + } else { + const delta = max - min; + saturation = lightness <= 0.5 ? delta / (max + min) : delta / (2 - max - min); + switch (max) { + case r: + hue = (g - b) / delta + (g < b ? 6 : 0); + break; + case g: + hue = (b - r) / delta + 2; + break; + case b: + hue = (r - g) / delta + 4; + break; + } + hue /= 6; + } + return { + h: hue, + s: saturation, + l: lightness + }; +} +var colors = { + aliceblue: [240 / 255, 248 / 255, 255 / 255], + antiquewhite: [250 / 255, 235 / 255, 215 / 255], + aqua: [0 / 255, 255 / 255, 255 / 255], + aquamarine: [127 / 255, 255 / 255, 212 / 255], + azure: [240 / 255, 255 / 255, 255 / 255], + beige: [245 / 255, 245 / 255, 220 / 255], + bisque: [255 / 255, 228 / 255, 196 / 255], + black: [0 / 255, 0 / 255, 0 / 255], + blanchedalmond: [255 / 255, 235 / 255, 205 / 255], + blue: [0 / 255, 0 / 255, 255 / 255], + blueviolet: [138 / 255, 43 / 255, 226 / 255], + brown: [165 / 255, 42 / 255, 42 / 255], + burlywood: [222 / 255, 184 / 255, 135 / 255], + cadetblue: [95 / 255, 158 / 255, 160 / 255], + chartreuse: [127 / 255, 255 / 255, 0 / 255], + chocolate: [210 / 255, 105 / 255, 30 / 255], + coral: [255 / 255, 127 / 255, 80 / 255], + cornflowerblue: [100 / 255, 149 / 255, 237 / 255], + cornsilk: [255 / 255, 248 / 255, 220 / 255], + crimson: [220 / 255, 20 / 255, 60 / 255], + cyan: [0 / 255, 255 / 255, 255 / 255], + darkblue: [0 / 255, 0 / 255, 139 / 255], + darkcyan: [0 / 255, 139 / 255, 139 / 255], + darkgoldenrod: [184 / 255, 134 / 255, 11 / 255], + darkgray: [169 / 255, 169 / 255, 169 / 255], + darkgreen: [0 / 255, 100 / 255, 0 / 255], + darkgrey: [169 / 255, 169 / 255, 169 / 255], + darkkhaki: [189 / 255, 183 / 255, 107 / 255], + darkmagenta: [139 / 255, 0 / 255, 139 / 255], + darkolivegreen: [85 / 255, 107 / 255, 47 / 255], + darkorange: [255 / 255, 140 / 255, 0 / 255], + darkorchid: [153 / 255, 50 / 255, 204 / 255], + darkred: [139 / 255, 0 / 255, 0 / 255], + darksalmon: [233 / 255, 150 / 255, 122 / 255], + darkseagreen: [143 / 255, 188 / 255, 143 / 255], + darkslateblue: [72 / 255, 61 / 255, 139 / 255], + darkslategray: [47 / 255, 79 / 255, 79 / 255], + darkslategrey: [47 / 255, 79 / 255, 79 / 255], + darkturquoise: [0 / 255, 206 / 255, 209 / 255], + darkviolet: [148 / 255, 0 / 255, 211 / 255], + deeppink: [255 / 255, 20 / 255, 147 / 255], + deepskyblue: [0 / 255, 191 / 255, 255 / 255], + dimgray: [105 / 255, 105 / 255, 105 / 255], + dimgrey: [105 / 255, 105 / 255, 105 / 255], + dodgerblue: [30 / 255, 144 / 255, 255 / 255], + firebrick: [178 / 255, 34 / 255, 34 / 255], + floralwhite: [255 / 255, 250 / 255, 240 / 255], + forestgreen: [34 / 255, 139 / 255, 34 / 255], + fuchsia: [255 / 255, 0 / 255, 255 / 255], + gainsboro: [220 / 255, 220 / 255, 220 / 255], + ghostwhite: [248 / 255, 248 / 255, 255 / 255], + gold: [255 / 255, 215 / 255, 0 / 255], + goldenrod: [218 / 255, 165 / 255, 32 / 255], + gray: [128 / 255, 128 / 255, 128 / 255], + green: [0 / 255, 128 / 255, 0 / 255], + greenyellow: [173 / 255, 255 / 255, 47 / 255], + grey: [128 / 255, 128 / 255, 128 / 255], + honeydew: [240 / 255, 255 / 255, 240 / 255], + hotpink: [255 / 255, 105 / 255, 180 / 255], + indianred: [205 / 255, 92 / 255, 92 / 255], + indigo: [75 / 255, 0 / 255, 130 / 255], + ivory: [255 / 255, 255 / 255, 240 / 255], + khaki: [240 / 255, 230 / 255, 140 / 255], + lavender: [230 / 255, 230 / 255, 250 / 255], + lavenderblush: [255 / 255, 240 / 255, 245 / 255], + lawngreen: [124 / 255, 252 / 255, 0 / 255], + lemonchiffon: [255 / 255, 250 / 255, 205 / 255], + lightblue: [173 / 255, 216 / 255, 230 / 255], + lightcoral: [240 / 255, 128 / 255, 128 / 255], + lightcyan: [224 / 255, 255 / 255, 255 / 255], + lightgoldenrodyellow: [250 / 255, 250 / 255, 210 / 255], + lightgray: [211 / 255, 211 / 255, 211 / 255], + lightgreen: [144 / 255, 238 / 255, 144 / 255], + lightgrey: [211 / 255, 211 / 255, 211 / 255], + lightpink: [255 / 255, 182 / 255, 193 / 255], + lightsalmon: [255 / 255, 160 / 255, 122 / 255], + lightseagreen: [32 / 255, 178 / 255, 170 / 255], + lightskyblue: [135 / 255, 206 / 255, 250 / 255], + lightslategray: [119 / 255, 136 / 255, 153 / 255], + lightslategrey: [119 / 255, 136 / 255, 153 / 255], + lightsteelblue: [176 / 255, 196 / 255, 222 / 255], + lightyellow: [255 / 255, 255 / 255, 224 / 255], + lime: [0 / 255, 255 / 255, 0 / 255], + limegreen: [50 / 255, 205 / 255, 50 / 255], + linen: [250 / 255, 240 / 255, 230 / 255], + magenta: [255 / 255, 0 / 255, 255 / 255], + maroon: [128 / 255, 0 / 255, 0 / 255], + mediumaquamarine: [102 / 255, 205 / 255, 170 / 255], + mediumblue: [0 / 255, 0 / 255, 205 / 255], + mediumorchid: [186 / 255, 85 / 255, 211 / 255], + mediumpurple: [147 / 255, 112 / 255, 219 / 255], + mediumseagreen: [60 / 255, 179 / 255, 113 / 255], + mediumslateblue: [123 / 255, 104 / 255, 238 / 255], + mediumspringgreen: [0 / 255, 250 / 255, 154 / 255], + mediumturquoise: [72 / 255, 209 / 255, 204 / 255], + mediumvioletred: [199 / 255, 21 / 255, 133 / 255], + midnightblue: [25 / 255, 25 / 255, 112 / 255], + mintcream: [245 / 255, 255 / 255, 250 / 255], + mistyrose: [255 / 255, 228 / 255, 225 / 255], + moccasin: [255 / 255, 228 / 255, 181 / 255], + navajowhite: [255 / 255, 222 / 255, 173 / 255], + navy: [0 / 255, 0 / 255, 128 / 255], + oldlace: [253 / 255, 245 / 255, 230 / 255], + olive: [128 / 255, 128 / 255, 0 / 255], + olivedrab: [107 / 255, 142 / 255, 35 / 255], + orange: [255 / 255, 165 / 255, 0 / 255], + orangered: [255 / 255, 69 / 255, 0 / 255], + orchid: [218 / 255, 112 / 255, 214 / 255], + palegoldenrod: [238 / 255, 232 / 255, 170 / 255], + palegreen: [152 / 255, 251 / 255, 152 / 255], + paleturquoise: [175 / 255, 238 / 255, 238 / 255], + palevioletred: [219 / 255, 112 / 255, 147 / 255], + papayawhip: [255 / 255, 239 / 255, 213 / 255], + peachpuff: [255 / 255, 218 / 255, 185 / 255], + peru: [205 / 255, 133 / 255, 63 / 255], + pink: [255 / 255, 192 / 255, 203 / 255], + plum: [221 / 255, 160 / 255, 221 / 255], + powderblue: [176 / 255, 224 / 255, 230 / 255], + purple: [128 / 255, 0 / 255, 128 / 255], + rebeccapurple: [102 / 255, 51 / 255, 153 / 255], + red: [255 / 255, 0 / 255, 0 / 255], + rosybrown: [188 / 255, 143 / 255, 143 / 255], + royalblue: [65 / 255, 105 / 255, 225 / 255], + saddlebrown: [139 / 255, 69 / 255, 19 / 255], + salmon: [250 / 255, 128 / 255, 114 / 255], + sandybrown: [244 / 255, 164 / 255, 96 / 255], + seagreen: [46 / 255, 139 / 255, 87 / 255], + seashell: [255 / 255, 245 / 255, 238 / 255], + sienna: [160 / 255, 82 / 255, 45 / 255], + silver: [192 / 255, 192 / 255, 192 / 255], + skyblue: [135 / 255, 206 / 255, 235 / 255], + slateblue: [106 / 255, 90 / 255, 205 / 255], + slategray: [112 / 255, 128 / 255, 144 / 255], + slategrey: [112 / 255, 128 / 255, 144 / 255], + snow: [255 / 255, 250 / 255, 250 / 255], + springgreen: [0 / 255, 255 / 255, 127 / 255], + steelblue: [70 / 255, 130 / 255, 180 / 255], + tan: [210 / 255, 180 / 255, 140 / 255], + teal: [0 / 255, 128 / 255, 128 / 255], + thistle: [216 / 255, 191 / 255, 216 / 255], + tomato: [255 / 255, 99 / 255, 71 / 255], + turquoise: [64 / 255, 224 / 255, 208 / 255], + violet: [238 / 255, 130 / 255, 238 / 255], + wheat: [245 / 255, 222 / 255, 179 / 255], + white: [255 / 255, 255 / 255, 255 / 255], + whitesmoke: [245 / 255, 245 / 255, 245 / 255], + yellow: [255 / 255, 255 / 255, 0 / 255], + yellowgreen: [154 / 255, 205 / 255, 50 / 255] +}; +var AttributeHandler = class { + constructor(map) { + this.map = map; + } + getAttributes() { + return Object.keys(this.map); + } + handle(instance, name, newValue) { + const handler = this.map[name]; + if (handler) { + handler(instance, newValue); + return true; + } + return false; + } +}; +function parseColorAttribute(value, defaultValue) { + return parseAttribute(value, defaultValue, (value2) => { + const colorNameValues = colors[value2]; + if (colorNameValues) { + return { + r: colorNameValues[0], + g: colorNameValues[1], + b: colorNameValues[2] + }; + } + if (value2.length === 7) { + const hex = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(value2); + if (hex) { + return { + r: parseInt(hex[1], 16) / 255, + g: parseInt(hex[2], 16) / 255, + b: parseInt(hex[3], 16) / 255 + }; + } + } + if (value2.length === 4) { + const hex = /^#?([a-f\d])([a-f\d])([a-f\d])$/i.exec(value2); + if (hex) { + return { + r: parseInt(hex[1] + hex[1], 16) / 255, + g: parseInt(hex[2] + hex[2], 16) / 255, + b: parseInt(hex[3] + hex[3], 16) / 255 + }; + } + } + if (value2.indexOf("rgb(") === 0) { + const rgb = /^rgb\((\d+),\s*(\d+),\s*(\d+)\)$/.exec(value2); + if (rgb) { + return { + r: parseInt(rgb[1], 10) / 255, + g: parseInt(rgb[2], 10) / 255, + b: parseInt(rgb[3], 10) / 255 + }; + } + } + if (value2.indexOf("rgba(") === 0) { + const rgba = /^rgba\((\d+),\s*(\d+),\s*(\d+),\s*(\d*\.?\d+)\)$/.exec(value2); + if (rgba) { + return { + r: parseInt(rgba[1], 10) / 255, + g: parseInt(rgba[2], 10) / 255, + b: parseInt(rgba[3], 10) / 255, + a: parseFloat(rgba[4]) + }; + } + } + if (value2.indexOf("hsl(") === 0) { + const hsl = /^hsl\(\s*(\d+)\s*,\s*(\d+(?:\.\d+)?%)\s*,\s*(\d+(?:\.\d+)?%)\)$/.exec(value2); + if (hsl) { + let h = parseFloat(hsl[1]) / 360; + if (h === 0) { + h = 1e-4; + } else if (h === 1) { + h = 0.9999; + } + let s = parseFloat(hsl[2]) / 100; + if (s === 0) { + s = 1e-4; + } else if (s === 1) { + s = 0.9999; + } + let l = parseFloat(hsl[3]) / 100; + if (l === 0) { + l = 1e-4; + } else if (l === 1) { + l = 0.9999; + } + return hslToRGB(h, s, l); + } + } + if (value2.indexOf("hsla(") === 0) { + const hsla = /^hsla\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?%)\s*,\s*(\d+(?:\.\d+)?%),\s*(\d+(?:\.\d+)?)\)$/.exec( + value2 + ); + if (hsla) { + let h = parseFloat(hsla[1]) / 360; + if (h === 0) { + h = 1e-4; + } else if (h === 1) { + h = 0.9999; + } + let s = parseFloat(hsla[2]) / 100; + if (s === 0) { + s = 1e-4; + } else if (s === 1) { + s = 0.9999; + } + let l = parseFloat(hsla[3]) / 100; + if (l === 0) { + l = 1e-4; + } else if (l === 1) { + l = 0.9999; + } + return hslToRGB(h, s, l); + } + } + return null; + }); +} +function parseAttribute(value, defaultValue, parser) { + if (value === null) { + return defaultValue; + } + const parsed = parser(value); + if (parsed === null) { + return defaultValue; + } + return parsed; +} +function floatParser(value) { + const parsed = parseFloat(value); + if (isNaN(parsed)) { + return null; + } + return parsed; +} +function boolParser(value) { + if (value === "true") { + return true; + } else if (value === "false") { + return false; + } + return null; +} +function parseFloatAttribute(value, defaultValue) { + return parseAttribute(value, defaultValue, floatParser); +} +function parseBoolAttribute(value, defaultValue) { + return parseAttribute(value, defaultValue, boolParser); +} +function parseEnumAttribute(value, enumValues, defaultValue) { + return parseAttribute(value, defaultValue, (value2) => { + if (Object.keys(enumValues).indexOf(value2) === -1) { + return null; + } + return value2; + }); +} +var scene = null; +var documentTimeManager = null; +function getGlobalMMLScene() { + if (!scene) { + throw new Error("GlobalMMLScene not set"); + } + return scene; +} +function getGlobalDocumentTimeManager() { + if (!documentTimeManager) { + throw new Error("GlobalMMLScene not set"); + } + return documentTimeManager; +} +var MELEMENT_PROPERTY_NAME = "m-element-property"; +var consumeEventEventName = "consume-event"; +var MElement = class _MElement extends HTMLElement { + constructor() { + super(); + this.mElementGraphics = null; + } + // This allows switching which document this HTMLElement subclass extends so that it can be placed into iframes + static overwriteSuperclass(newSuperclass) { + _MElement.__proto__ = newSuperclass; + } + static get observedAttributes() { + return []; + } + static getMElementFromObject(object) { + return object[MELEMENT_PROPERTY_NAME] || null; + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + addSideEffectChild(child) { + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + removeSideEffectChild(child) { + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + attributeChangedCallback(name, oldValue, newValue) { + } + getScene() { + const remoteDocumentElement = this.getInitiatedRemoteDocument(); + if (remoteDocumentElement) { + return remoteDocumentElement.getMMLScene(); + } + const globalScene = getGlobalMMLScene(); + if (!globalScene) { + throw new Error("No scene attachment found and no global scene found"); + } + return globalScene; + } + getInitiatedRemoteDocument() { + for (let parentNode = this; parentNode; parentNode = parentNode.parentNode) { + if (parentNode.nodeName === "M-REMOTE-DOCUMENT" && parentNode.getMMLScene()) { + return parentNode; + } + } + return null; + } + contentSrcToContentAddress(src) { + const documentLocation = this.getDocumentHost(); + try { + const url = new URL(src); + return url.toString(); + } catch { + } + let protocol = documentLocation.protocol; + if (protocol === "ws:") { + protocol = "http:"; + } else if (protocol === "wss:") { + protocol = "https:"; + } + if (src.startsWith("/")) { + return `${protocol}//${documentLocation.host}${src}`; + } else { + const path = documentLocation.pathname; + const lastSlashIndex = path.lastIndexOf("/"); + if (lastSlashIndex === -1) { + return `${protocol}//${documentLocation.host}/${src}`; + } + const pathWithoutFilename = path.substring(0, lastSlashIndex + 1); + return `${protocol}//${documentLocation.host}${pathWithoutFilename}${src}`; + } + } + getDocumentHost() { + const remoteDocument = this.getInitiatedRemoteDocument(); + if (remoteDocument) { + const remoteDocumentAddress = remoteDocument.getDocumentAddress(); + if (remoteDocumentAddress) { + const url = new URL(remoteDocumentAddress); + return url; + } + } + return window.location; + } + getDocumentTime() { + const documentTimeContextProvider = this.getDocumentTimeManager(); + if (documentTimeContextProvider) { + return documentTimeContextProvider.getDocumentTime(); + } + return Number(document.timeline.currentTime); + } + getWindowTime() { + const documentTimeContextProvider = this.getDocumentTimeManager(); + if (documentTimeContextProvider) { + return documentTimeContextProvider.getWindowTime(); + } + return Number(document.timeline.currentTime); + } + getLoadingProgressManager() { + var _a; + const scene2 = this.getScene(); + if (scene2) { + return ((_a = scene2.getLoadingProgressManager) == null ? void 0 : _a.call(scene2)) || null; + } + return null; + } + getDocumentTimeManager() { + const remoteDocument = this.getInitiatedRemoteDocument(); + if (remoteDocument) { + return remoteDocument.getDocumentTimeManager(); + } + const globalDocumentTimeManager = getGlobalDocumentTimeManager(); + if (globalDocumentTimeManager) { + return globalDocumentTimeManager; + } + return null; + } + addDocumentTimeListener(cb) { + const documentTimeManager2 = this.getDocumentTimeManager(); + if (documentTimeManager2) { + documentTimeManager2.addDocumentTimeListenerCallback(cb); + return { + remove: () => { + documentTimeManager2.removeDocumentTimeListenerCallback(cb); + } + }; + } else { + console.warn("No document time context provider found to add listener to"); + return { + remove: () => { + } + }; + } + } + addDocumentTimeTickListener(cb) { + const documentTimeManager2 = this.getDocumentTimeManager(); + if (documentTimeManager2) { + documentTimeManager2.addDocumentTimeTickListenerCallback(cb); + return { + remove: () => { + documentTimeManager2.removeDocumentTimeTickListenerCallback(cb); + } + }; + } else { + console.warn("No document time context provider found to add listener to"); + return { + remove: () => { + } + }; + } + } + getContainer() { + var _a; + const container = (_a = this.mElementGraphics) == null ? void 0 : _a.getContainer(); + if (!container) { + throw new Error("No container found"); + } + return container; + } + getUserPositionAndRotation() { + const remoteDocument = this.getScene(); + if (!remoteDocument) { + throw new Error("No scene to retrieve user position from"); + } + return remoteDocument.getUserPositionAndRotation(); + } + dispatchEvent(event) { + const remoteDocument = this.getInitiatedRemoteDocument(); + if (remoteDocument) { + remoteDocument.dispatchEvent( + new CustomEvent(consumeEventEventName, { + bubbles: false, + detail: { element: this, originalEvent: event } + }) + ); + return super.dispatchEvent(event); + } else { + if (event.type !== "click") { + const script = this.getAttribute("on" + event.type.toLowerCase()); + if (script) { + const handler = window["eval"](`(function(event){ ${script} })`); + handler.apply(this, [event]); + } + } + return super.dispatchEvent(event); + } + } + getMElementParent() { + let parentNode = this.parentNode; + while (parentNode != null) { + if (parentNode instanceof _MElement) { + return parentNode; + } + parentNode = parentNode.parentNode; + } + return null; + } + connectedCallback() { + if (!this.getScene().hasGraphicsAdapter() || this.mElementGraphics) { + return; + } + const graphicsAdapter = this.getScene().getGraphicsAdapter(); + this.mElementGraphics = graphicsAdapter.getGraphicsAdapterFactory().MElementGraphicsInterface(this); + } + disconnectedCallback() { + var _a; + (_a = this.mElementGraphics) == null ? void 0 : _a.dispose(); + this.mElementGraphics = null; + } +}; +var defaultAttribute = null; +var defaultStart = 0; +var defaultEnd = 0; +var defaultLoop = true; +var defaultPingPong = false; +var defaultEasing = ""; +var defaultStartTime = 0; +var defaultPauseTime = null; +var defaultAnimDuration = 1e3; +var defaultPingPongDelay = 0; +var defaultColor = { r: 1, g: 1, b: 1 }; +var _AttributeAnimation = class _AttributeAnimation2 extends MElement { + constructor() { + super(); + this.props = { + attr: defaultAttribute, + start: defaultStart, + end: defaultEnd, + loop: defaultLoop, + pingPong: defaultPingPong, + pingPongDelay: defaultPingPongDelay, + easing: defaultEasing, + startTime: defaultStartTime, + pauseTime: defaultPauseTime, + animDuration: defaultAnimDuration + }; + this.registeredParentAttachment = null; + } + static get observedAttributes() { + return [..._AttributeAnimation2.attributeHandler.getAttributes()]; + } + enable() { + } + disable() { + } + getContentBounds() { + return null; + } + getAnimatedAttributeName() { + return this.props.attr; + } + parentTransformed() { + } + isClickable() { + return false; + } + attributeChangedCallback(name, oldValue, newValue) { + super.attributeChangedCallback(name, oldValue, newValue); + _AttributeAnimation2.attributeHandler.handle(this, name, newValue); + } + connectedCallback() { + super.connectedCallback(); + if (this.parentElement && this.parentElement instanceof MElement) { + this.registeredParentAttachment = this.parentElement; + if (this.props.attr) { + this.registeredParentAttachment.addSideEffectChild(this); + } + } + } + disconnectedCallback() { + if (this.registeredParentAttachment && this.props.attr) { + this.registeredParentAttachment.removeSideEffectChild(this); + } + this.registeredParentAttachment = null; + super.disconnectedCallback(); + } + getColorValueForTime(docTimeMs) { + const [ratio, state] = getEasedRatioForTime(docTimeMs, this.props); + if (typeof this.props.start !== "object" || typeof this.props.end !== "object") { + return [defaultColor, state]; + } + if (ratio === StartOfAnimationSymbol) { + return [this.props.start, state]; + } else if (ratio === EndOfAnimationSymbol) { + return [this.props.end, state]; + } else { + const value = lerpHSL(this.props.start, this.props.end, ratio); + return [value, state]; + } + } + getFloatValueForTime(docTimeMs) { + const [ratio, state] = getEasedRatioForTime(docTimeMs, this.props); + if (typeof this.props.start !== "number" || typeof this.props.end !== "number") { + return [0, state]; + } + if (ratio === StartOfAnimationSymbol) { + return [this.props.start, state]; + } else if (ratio === EndOfAnimationSymbol) { + return [this.props.end, state]; + } else { + const value = ratio * (this.props.end - this.props.start) + this.props.start; + return [value, state]; + } + } +}; +_AttributeAnimation.tagName = "m-attr-anim"; +_AttributeAnimation.attributeHandler = new AttributeHandler({ + attr: (instance, newValue) => { + if (instance.registeredParentAttachment && instance.props.attr) { + instance.registeredParentAttachment.removeSideEffectChild(instance); + } + instance.props.attr = newValue || defaultAttribute; + if (instance.registeredParentAttachment && instance.props.attr) { + instance.registeredParentAttachment.addSideEffectChild(instance); + } + }, + start: (instance, newValue) => { + let parsedValue = parseFloatAttribute(newValue, null); + if (parsedValue === null) { + parsedValue = parseColorAttribute(newValue, null); + } + if (parsedValue === null) { + instance.props.start = defaultStart; + } else { + instance.props.start = parsedValue; + } + }, + end: (instance, newValue) => { + let parsedValue = parseFloatAttribute(newValue, null); + if (parsedValue === null) { + parsedValue = parseColorAttribute(newValue, null); + } + if (parsedValue === null) { + instance.props.end = defaultStart; + } else { + instance.props.end = parsedValue; + } + }, + loop: (instance, newValue) => { + instance.props.loop = parseBoolAttribute(newValue, defaultLoop); + }, + "ping-pong": (instance, newValue) => { + instance.props.pingPong = parseBoolAttribute(newValue, defaultPingPong); + }, + "ping-pong-delay": (instance, newValue) => { + instance.props.pingPongDelay = parseFloatAttribute(newValue, defaultPingPongDelay); + }, + easing: (instance, newValue) => { + instance.props.easing = newValue || defaultEasing; + }, + "start-time": (instance, newValue) => { + instance.props.startTime = parseFloatAttribute(newValue, defaultStartTime); + }, + "pause-time": (instance, newValue) => { + instance.props.pauseTime = parseFloatAttribute(newValue, defaultPauseTime); + }, + duration: (instance, newValue) => { + instance.props.animDuration = parseFloatAttribute(newValue, defaultAnimDuration); + } +}); +var AttributeAnimation = _AttributeAnimation; +var defaultAttribute2 = "all"; +var defaultEasing2 = ""; +var defaultLerpDuration = 1e3; +var _AttributeLerp = class _AttributeLerp2 extends MElement { + constructor() { + super(); + this.props = { + attr: defaultAttribute2, + easing: defaultEasing2, + lerpDuration: defaultLerpDuration + }; + this.registeredParentAttachment = null; + } + static get observedAttributes() { + return [..._AttributeLerp2.attributeHandler.getAttributes()]; + } + enable() { + } + disable() { + } + getContentBounds() { + return null; + } + getAnimatedAttributeName() { + return this.props.attr; + } + parentTransformed() { + } + isClickable() { + return false; + } + attributeChangedCallback(name, oldValue, newValue) { + super.attributeChangedCallback(name, oldValue, newValue); + _AttributeLerp2.attributeHandler.handle(this, name, newValue); + } + connectedCallback() { + super.connectedCallback(); + if (this.parentElement && this.parentElement instanceof MElement) { + this.registeredParentAttachment = this.parentElement; + this.registeredParentAttachment.addSideEffectChild(this); + } + } + disconnectedCallback() { + if (this.registeredParentAttachment) { + this.registeredParentAttachment.removeSideEffectChild(this); + } + this.registeredParentAttachment = null; + super.disconnectedCallback(); + } + getColorValueForTime(windowTime, elementValueSetTime, elementValue, previousValue) { + const ratio = this.getLerpRatio(windowTime, elementValueSetTime); + if (ratio >= 1) { + return elementValue; + } + return lerpHSL(previousValue, elementValue, ratio); + } + getFloatValueForTime(windowTime, elementValueSetTime, elementValue, previousValue) { + const from = previousValue; + const to = elementValue; + const ratio = this.getLerpRatio(windowTime, elementValueSetTime); + if (ratio >= 1) { + return to; + } + return from + (to - from) * ratio; + } + getLerpRatio(windowTime, elementValueSetTime) { + const duration = this.props.lerpDuration; + const timePassed = (windowTime || 0) - elementValueSetTime; + const ratioOfTimePassed = Math.min(timePassed / duration, 1); + const easing = this.props.easing; + let ratio; + const easingFunction = easingsByName[easing]; + if (easingFunction) { + ratio = easingFunction(ratioOfTimePassed, 0, 1, 1); + } else { + ratio = ratioOfTimePassed; + } + return ratio; + } +}; +_AttributeLerp.tagName = "m-attr-lerp"; +_AttributeLerp.attributeHandler = new AttributeHandler({ + attr: (instance, newValue) => { + if (instance.registeredParentAttachment) { + instance.registeredParentAttachment.removeSideEffectChild(instance); + } + instance.props.attr = newValue !== null ? newValue : defaultAttribute2; + if (instance.registeredParentAttachment) { + instance.registeredParentAttachment.addSideEffectChild(instance); + } + }, + easing: (instance, newValue) => { + instance.props.easing = newValue || defaultEasing2; + }, + duration: (instance, newValue) => { + instance.props.lerpDuration = Math.max(0, parseFloatAttribute(newValue, defaultLerpDuration)); + } +}); +var AttributeLerp = _AttributeLerp; +function TupleToState(tuple) { + return { + previousValue: null, + elementValue: null, + elementValueSetTime: null, + type: tuple[0], + latestValue: tuple[1], + defaultValue: tuple[1], + handler: tuple[2] + }; +} +function updateIfChangedValue(state, newValue) { + if (newValue === null) { + newValue = state.attributeState.defaultValue; + } + if (state.attributeState.latestValue !== newValue) { + state.attributeState.latestValue = newValue; + state.attributeState.handler(newValue); + } +} +function isColorAttribute(attributeState) { + return attributeState.type === 1; +} +function isNumberAttribute(attributeState) { + return attributeState.type === 0; +} +var AnimatedAttributeHelper = class { + constructor(element, handlers) { + this.element = element; + this.handlers = handlers; + this.stateByAttribute = {}; + this.allAnimations = /* @__PURE__ */ new Set(); + this.allLerps = /* @__PURE__ */ new Set(); + this.documentTimeTickListener = null; + this.hasTicked = false; + this.element = element; + this.reset(); + } + addSideEffectChild(child) { + if (child instanceof AttributeAnimation) { + const attr = child.getAnimatedAttributeName(); + if (attr) { + this.addAnimation(child, attr); + } + } else if (child instanceof AttributeLerp) { + const attr = child.getAnimatedAttributeName(); + if (attr) { + this.addLerp(child, attr); + } + } + } + removeSideEffectChild(child) { + if (child instanceof AttributeAnimation) { + const attr = child.getAnimatedAttributeName(); + if (attr) { + this.removeAnimation(child, attr); + } + } else if (child instanceof AttributeLerp) { + const attr = child.getAnimatedAttributeName(); + if (attr) { + this.removeLerp(child, attr); + } + } + } + elementSetAttribute(key, newValue) { + const state = this.stateByAttribute[key]; + if (!state) { + return; + } + state.attributeState.elementValue = newValue; + if (this.hasTicked) { + state.attributeState.previousValue = state.attributeState.latestValue; + } else { + state.attributeState.previousValue = newValue; + } + if (this.element.isConnected) { + state.attributeState.elementValueSetTime = this.element.getWindowTime(); + } else { + state.attributeState.elementValueSetTime = null; + } + if (state.animationsSet.size > 0 || state.lerpsSet.size > 0) { + return; + } + updateIfChangedValue(state, newValue); + } + getAttributesForAttributeValue(attr) { + if (attr === "all") { + return Object.keys(this.stateByAttribute); + } + return attr.split(",").map((a) => a.trim()).filter((a) => this.stateByAttribute[a]); + } + addLerp(lerp, attributeValue) { + const attributes = this.getAttributesForAttributeValue(attributeValue); + for (const key of attributes) { + const state = this.stateByAttribute[key]; + if (!state) { + return; + } + if (state.animationsSet.size === 0 && state.lerpsSet.size === 0) { + this.documentTimeTickListener = this.element.addDocumentTimeTickListener((documentTime) => { + this.updateTime(documentTime); + }); + } + this.allLerps.add(lerp); + state.lerpsSet.add(lerp); + state.lerpsInOrder = []; + const elementChildren = Array.from(this.element.children); + for (const child of elementChildren) { + if (state.lerpsSet.has(child)) { + state.lerpsInOrder.push(child); + } + } + } + } + removeLerp(lerp, attributeValue) { + const attributes = this.getAttributesForAttributeValue(attributeValue); + for (const key of attributes) { + const state = this.stateByAttribute[key]; + if (!state) { + return; + } + state.lerpsInOrder.splice(state.lerpsInOrder.indexOf(lerp), 1); + state.lerpsSet.delete(lerp); + if (state.animationsSet.size === 0) { + updateIfChangedValue(state, state.attributeState.elementValue); + } + this.allLerps.delete(lerp); + if (this.allLerps.size === 0) { + if (this.documentTimeTickListener) { + this.documentTimeTickListener.remove(); + this.documentTimeTickListener = null; + } + } + } + } + addAnimation(animation, key) { + const state = this.stateByAttribute[key]; + if (!state) { + return; + } + if (state.animationsSet.size === 0 && state.lerpsSet.size === 0) { + this.documentTimeTickListener = this.element.addDocumentTimeTickListener((documentTime) => { + this.updateTime(documentTime); + }); + } + this.allAnimations.add(animation); + state.animationsSet.add(animation); + state.animationsInOrder = []; + const elementChildren = Array.from(this.element.children); + for (const child of elementChildren) { + if (state.animationsSet.has(child)) { + state.animationsInOrder.push(child); + } + } + } + removeAnimation(animation, key) { + const state = this.stateByAttribute[key]; + if (!state) { + return; + } + state.animationsInOrder.splice(state.animationsInOrder.indexOf(animation), 1); + state.animationsSet.delete(animation); + if (state.animationsSet.size === 0) { + updateIfChangedValue(state, state.attributeState.elementValue); + } + this.allAnimations.delete(animation); + if (this.allAnimations.size === 0) { + if (this.documentTimeTickListener) { + this.documentTimeTickListener.remove(); + this.documentTimeTickListener = null; + } + } + } + updateTime(documentTime) { + this.hasTicked = true; + for (const key in this.stateByAttribute) { + let stale = null; + const state = this.stateByAttribute[key]; + for (const animation of state.animationsInOrder) { + const [newValue, active] = state.attributeState.type === 1 ? animation.getColorValueForTime(documentTime) : animation.getFloatValueForTime(documentTime); + if (active === 0) { + updateIfChangedValue(state, newValue); + stale = null; + break; + } else { + if (stale === null) { + stale = { value: newValue, state: active }; + } else { + const isAboutToStartRatherThanEnded = stale.state > 0 && active < 0; + const isMoreRecentEnd = stale.state > 0 && active > 0 && stale.state > active; + const isSoonerToStart = stale.state < 0 && active < 0 && stale.state < active; + if (isAboutToStartRatherThanEnded || isMoreRecentEnd || isSoonerToStart) { + stale = { value: newValue, state: active }; + } + } + } + } + if (stale !== null) { + updateIfChangedValue(state, stale.value); + continue; + } + if (state.lerpsInOrder.length > 0) { + const lerp = state.lerpsInOrder[0]; + const config = state.attributeState; + if (config.elementValueSetTime !== null && config.previousValue !== null && config.elementValue !== null) { + if (isColorAttribute(config)) { + updateIfChangedValue( + state, + lerp.getColorValueForTime( + this.element.getWindowTime(), + config.elementValueSetTime, + config.elementValue, + config.previousValue + ) + ); + } else if (isNumberAttribute(config)) { + updateIfChangedValue( + state, + lerp.getFloatValueForTime( + this.element.getWindowTime(), + config.elementValueSetTime, + config.elementValue, + config.previousValue + ) + ); + } + } + } + } + } + reset() { + for (const key in this.handlers) { + const state = TupleToState(this.handlers[key]); + this.stateByAttribute[key] = { + attributeState: state, + animationsInOrder: [], + animationsSet: /* @__PURE__ */ new Set(), + lerpsInOrder: [], + lerpsSet: /* @__PURE__ */ new Set() + }; + } + } +}; +var easingFunctions = { + easeInQuad(t, b, c, d) { + return c * (t /= d) * t + b; + }, + easeOutQuad(t, b, c, d) { + return -c * (t /= d) * (t - 2) + b; + }, + easeInOutQuad(t, b, c, d) { + if ((t /= d / 2) < 1) return c / 2 * t * t + b; + return -c / 2 * (--t * (t - 2) - 1) + b; + }, + easeInCubic(t, b, c, d) { + return c * (t /= d) * t * t + b; + }, + easeOutCubic(t, b, c, d) { + return c * ((t = t / d - 1) * t * t + 1) + b; + }, + easeInOutCubic(t, b, c, d) { + if ((t /= d / 2) < 1) return c / 2 * t * t * t + b; + return c / 2 * ((t -= 2) * t * t + 2) + b; + }, + easeInQuart(t, b, c, d) { + return c * (t /= d) * t * t * t + b; + }, + easeOutQuart(t, b, c, d) { + return -c * ((t = t / d - 1) * t * t * t - 1) + b; + }, + easeInOutQuart(t, b, c, d) { + if ((t /= d / 2) < 1) return c / 2 * t * t * t * t + b; + return -c / 2 * ((t -= 2) * t * t * t - 2) + b; + }, + easeInQuint(t, b, c, d) { + return c * (t /= d) * t * t * t * t + b; + }, + easeOutQuint(t, b, c, d) { + return c * ((t = t / d - 1) * t * t * t * t + 1) + b; + }, + easeInOutQuint(t, b, c, d) { + if ((t /= d / 2) < 1) return c / 2 * t * t * t * t * t + b; + return c / 2 * ((t -= 2) * t * t * t * t + 2) + b; + }, + easeInSine(t, b, c, d) { + return -c * Math.cos(t / d * (Math.PI / 2)) + c + b; + }, + easeOutSine(t, b, c, d) { + return c * Math.sin(t / d * (Math.PI / 2)) + b; + }, + easeInOutSine(t, b, c, d) { + return -c / 2 * (Math.cos(Math.PI * t / d) - 1) + b; + }, + easeInExpo(t, b, c, d) { + return t === 0 ? b : c * Math.pow(2, 10 * (t / d - 1)) + b; + }, + easeOutExpo(t, b, c, d) { + return t === d ? b + c : c * (-Math.pow(2, -10 * t / d) + 1) + b; + }, + easeInOutExpo(t, b, c, d) { + if (t === 0) return b; + if (t === d) return b + c; + if ((t /= d / 2) < 1) return c / 2 * Math.pow(2, 10 * (t - 1)) + b; + return c / 2 * (-Math.pow(2, -10 * --t) + 2) + b; + }, + easeInCirc(t, b, c, d) { + return -c * (Math.sqrt(1 - (t /= d) * t) - 1) + b; + }, + easeOutCirc(t, b, c, d) { + return c * Math.sqrt(1 - (t = t / d - 1) * t) + b; + }, + easeInOutCirc(t, b, c, d) { + if ((t /= d / 2) < 1) return -c / 2 * (Math.sqrt(1 - t * t) - 1) + b; + return c / 2 * (Math.sqrt(1 - (t -= 2) * t) + 1) + b; + }, + easeInElastic(t, b, c, d) { + let s = 1.70158; + let p = 0; + let a = c; + if (t === 0) return b; + if ((t /= d) === 1) return b + c; + if (!p) p = d * 0.3; + if (a < Math.abs(c)) { + a = c; + s = p / 4; + } else { + s = p / (2 * Math.PI) * Math.asin(c / a); + } + return -(a * Math.pow(2, 10 * (t -= 1)) * Math.sin((t * d - s) * (2 * Math.PI) / p)) + b; + }, + easeOutElastic(t, b, c, d) { + let s = 1.70158; + let p = 0; + let a = c; + if (t === 0) return b; + if ((t /= d) === 1) return b + c; + if (!p) p = d * 0.3; + if (a < Math.abs(c)) { + a = c; + s = p / 4; + } else { + s = p / (2 * Math.PI) * Math.asin(c / a); + } + return a * Math.pow(2, -10 * t) * Math.sin((t * d - s) * (2 * Math.PI) / p) + c + b; + }, + easeInOutElastic(t, b, c, d) { + let s = 1.70158; + let p = 0; + let a = c; + if (t === 0) return b; + if ((t /= d / 2) === 2) return b + c; + if (!p) p = d * (0.3 * 1.5); + if (a < Math.abs(c)) { + a = c; + s = p / 4; + } else { + s = p / (2 * Math.PI) * Math.asin(c / a); + } + if (t < 1) + return -0.5 * (a * Math.pow(2, 10 * (t -= 1)) * Math.sin((t * d - s) * (2 * Math.PI) / p)) + b; + return a * Math.pow(2, -10 * (t -= 1)) * Math.sin((t * d - s) * (2 * Math.PI) / p) * 0.5 + c + b; + }, + easeInBack(t, b, c, d) { + const s = 1.70158; + return c * (t /= d) * t * ((s + 1) * t - s) + b; + }, + easeOutBack(t, b, c, d) { + const s = 1.70158; + return c * ((t = t / d - 1) * t * ((s + 1) * t + s) + 1) + b; + }, + easeInOutBack(t, b, c, d) { + let s = 1.70158; + if ((t /= d / 2) < 1) return c / 2 * (t * t * (((s *= 1.525) + 1) * t - s)) + b; + return c / 2 * ((t -= 2) * t * (((s *= 1.525) + 1) * t + s) + 2) + b; + }, + easeInBounce(t, b, c, d) { + return c - easingFunctions.easeOutBounce(d - t, 0, c, d) + b; + }, + easeOutBounce(t, b, c, d) { + if ((t /= d) < 1 / 2.75) { + return c * (7.5625 * t * t) + b; + } else if (t < 2 / 2.75) { + return c * (7.5625 * (t -= 1.5 / 2.75) * t + 0.75) + b; + } else if (t < 2.5 / 2.75) { + return c * (7.5625 * (t -= 2.25 / 2.75) * t + 0.9375) + b; + } else { + return c * (7.5625 * (t -= 2.625 / 2.75) * t + 0.984375) + b; + } + }, + easeInOutBounce(t, b, c, d) { + if (t < d / 2) return easingFunctions.easeInBounce(t * 2, 0, c, d) * 0.5 + b; + return easingFunctions.easeOutBounce(t * 2 - d, 0, c, d) * 0.5 + c * 0.5 + b; + } +}; +var easingsByName = easingFunctions; +var StartOfAnimationSymbol = Symbol("Start"); +var EndOfAnimationSymbol = Symbol("End"); +function getEasedRatioForTime(docTimeMs, props) { + if (props.pauseTime !== null && docTimeMs >= props.pauseTime) { + docTimeMs = props.pauseTime; + } + let elapsedTime = docTimeMs - props.startTime; + if (elapsedTime < 0) { + return [StartOfAnimationSymbol, elapsedTime]; + } else if (elapsedTime < props.animDuration || props.loop) { + if (props.loop) { + elapsedTime = elapsedTime % props.animDuration; + } + let elapsedRatio = elapsedTime / props.animDuration; + if (props.pingPong) { + let pingPongDelayRatio = props.pingPongDelay / props.animDuration; + if (pingPongDelayRatio < 0) { + pingPongDelayRatio = 0; + } + if (pingPongDelayRatio > 0.5) { + pingPongDelayRatio = 0.5; + } + if (elapsedRatio < pingPongDelayRatio / 2) { + elapsedRatio = 0; + } else if (elapsedRatio > 0.5 - pingPongDelayRatio / 2 && elapsedRatio < 0.5 + pingPongDelayRatio / 2) { + elapsedRatio = 1; + } else if (elapsedRatio > 1 - pingPongDelayRatio / 2) { + elapsedRatio = 0; + } else { + if (elapsedRatio > 0.5) { + elapsedRatio = (elapsedRatio - 0.5 - pingPongDelayRatio / 2) * 2 / (1 - pingPongDelayRatio * 2); + elapsedRatio = 1 - elapsedRatio; + } else { + elapsedRatio = (elapsedRatio - pingPongDelayRatio / 2) * 2 / (1 - pingPongDelayRatio * 2); + } + } + } + let newValue; + const easingFunction = easingsByName[props.easing]; + if (easingFunction) { + newValue = easingFunction(elapsedRatio, 0, 1, 1); + } else { + newValue = elapsedRatio; + } + return [newValue, 0]; + } else { + if (props.pingPong) { + return [StartOfAnimationSymbol, elapsedTime - props.animDuration]; + } + return [EndOfAnimationSymbol, elapsedTime - props.animDuration]; + } +} +var Quat = class _Quat { + constructor(x, y, z, w) { + if (x instanceof _Quat) { + this.x = x.x; + this.y = x.y; + this.z = x.z; + this.w = x.w; + return; + } + this.x = x || 0; + this.y = y || 0; + this.z = z || 0; + this.w = w || 1; + } + copy(other) { + this.x = other.x || 0; + this.y = other.y || 0; + this.z = other.z || 0; + this.w = other.w || 0; + return this; + } + multiply(q) { + return this.multiplyQuaternions(this, q); + } + premultiply(q) { + return this.multiplyQuaternions(q, this); + } + multiplyQuaternions(a, b) { + const qax = a.x; + const qay = a.y; + const qaz = a.z; + const qaw = a.w; + const qbx = b.x; + const qby = b.y; + const qbz = b.z; + const qbw = b.w; + this.x = qax * qbw + qaw * qbx + qay * qbz - qaz * qby; + this.y = qay * qbw + qaw * qby + qaz * qbx - qax * qbz; + this.z = qaz * qbw + qaw * qbz + qax * qby - qay * qbx; + this.w = qaw * qbw - qax * qbx - qay * qby - qaz * qbz; + return this; + } + setFromEulerXYZ(euler) { + const x = euler.x; + const y = euler.y; + const z = euler.z; + const cos = Math.cos; + const sin = Math.sin; + const c1 = cos(x / 2); + const c2 = cos(y / 2); + const c3 = cos(z / 2); + const s1 = sin(x / 2); + const s2 = sin(y / 2); + const s3 = sin(z / 2); + this.x = s1 * c2 * c3 + c1 * s2 * s3; + this.y = c1 * s2 * c3 - s1 * c2 * s3; + this.z = c1 * c2 * s3 + s1 * s2 * c3; + this.w = c1 * c2 * c3 - s1 * s2 * s3; + return this; + } + setFromRotationMatrix(m) { + const te = m.data, m11 = te[0], m12 = te[4], m13 = te[8], m21 = te[1], m22 = te[5], m23 = te[9], m31 = te[2], m32 = te[6], m33 = te[10], trace = m11 + m22 + m33; + if (trace > 0) { + const s = 0.5 / Math.sqrt(trace + 1); + this.w = 0.25 / s; + this.x = (m32 - m23) * s; + this.y = (m13 - m31) * s; + this.z = (m21 - m12) * s; + } else if (m11 > m22 && m11 > m33) { + const s = 2 * Math.sqrt(1 + m11 - m22 - m33); + this.w = (m32 - m23) / s; + this.x = 0.25 * s; + this.y = (m12 + m21) / s; + this.z = (m13 + m31) / s; + } else if (m22 > m33) { + const s = 2 * Math.sqrt(1 + m22 - m11 - m33); + this.w = (m13 - m31) / s; + this.x = (m12 + m21) / s; + this.y = 0.25 * s; + this.z = (m23 + m32) / s; + } else { + const s = 2 * Math.sqrt(1 + m33 - m11 - m22); + this.w = (m21 - m12) / s; + this.x = (m13 + m31) / s; + this.y = (m23 + m32) / s; + this.z = 0.25 * s; + } + return this; + } + setFromAxisAngle(axis, angle) { + const halfAngle = angle / 2; + const s = Math.sin(halfAngle); + this.x = axis.x * s; + this.y = axis.y * s; + this.z = axis.z * s; + this.w = Math.cos(halfAngle); + return this; + } + clone() { + return new _Quat(this); + } + set(x, y, z, w) { + this.x = x; + this.y = y; + this.z = z; + this.w = w; + return this; + } +}; +var Vect3 = class _Vect3 { + constructor(x, y, z) { + if (x && typeof x === "object") { + this.x = x.x; + this.y = x.y; + this.z = x.z; + return; + } + this.x = x || 0; + this.y = y || 0; + this.z = z || 0; + } + copy(other) { + this.x = other.x || 0; + this.y = other.y || 0; + this.z = other.z || 0; + return this; + } + length() { + return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z); + } + lengthSquared() { + return this.x * this.x + this.y * this.y + this.z * this.z; + } + clone() { + return new _Vect3(this); + } + set(x, y, z) { + this.x = x; + this.y = y; + this.z = z; + return this; + } + applyMatrix4(matrix) { + const x = this.x; + const y = this.y; + const z = this.z; + const e = matrix.data; + const w = 1 / (e[3] * x + e[7] * y + e[11] * z + e[15]); + this.x = (e[0] * x + e[4] * y + e[8] * z + e[12]) * w; + this.y = (e[1] * x + e[5] * y + e[9] * z + e[13]) * w; + this.z = (e[2] * x + e[6] * y + e[10] * z + e[14]) * w; + return this; + } + add(other) { + this.x += other.x || 0; + this.y += other.y || 0; + this.z += other.z || 0; + return this; + } + sub(other) { + this.x -= other.x || 0; + this.y -= other.y || 0; + this.z -= other.z || 0; + return this; + } +}; +var Vect3Zeroes = { x: 0, y: 0, z: 0 }; +var Vect3Ones = { x: 1, y: 1, z: 1 }; +var _Matr4 = class _Matr42 { + constructor(data) { + if (data instanceof _Matr42) { + this.data = [...data.data]; + } else if (data instanceof Array) { + this.data = [...data]; + } else if (data instanceof Float32Array) { + this.data = [...data]; + } else { + this.data = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]; + } + } + identity() { + this.data = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]; + return this; + } + copy(m) { + this.data = [...m.data]; + return this; + } + set(...args) { + if (args[0] instanceof Array) { + this.data = args[0]; + } else { + this.data = args; + } + return this; + } + setRotationFromQuaternion(q) { + return this.compose(Vect3Zeroes, q, Vect3Ones); + } + clone() { + return new _Matr42(this.data); + } + determinant() { + const te = this.data; + const n11 = te[0], n12 = te[4], n13 = te[8], n14 = te[12]; + const n21 = te[1], n22 = te[5], n23 = te[9], n24 = te[13]; + const n31 = te[2], n32 = te[6], n33 = te[10], n34 = te[14]; + const n41 = te[3], n42 = te[7], n43 = te[11], n44 = te[15]; + return n41 * (+n14 * n23 * n32 - n13 * n24 * n32 - n14 * n22 * n33 + n12 * n24 * n33 + n13 * n22 * n34 - n12 * n23 * n34) + n42 * (+n11 * n23 * n34 - n11 * n24 * n33 + n14 * n21 * n33 - n13 * n21 * n34 + n13 * n24 * n31 - n14 * n23 * n31) + n43 * (+n11 * n24 * n32 - n11 * n22 * n34 - n14 * n21 * n32 + n12 * n21 * n34 + n14 * n22 * n31 - n12 * n24 * n31) + n44 * (-n13 * n22 * n31 - n11 * n23 * n32 + n11 * n22 * n33 + n13 * n21 * n32 - n12 * n21 * n33 + n12 * n23 * n31); + } + makeRotationX(theta) { + const c = Math.cos(theta), s = Math.sin(theta); + this.set(1, 0, 0, 0, 0, c, -s, 0, 0, s, c, 0, 0, 0, 0, 1); + return this; + } + makeRotationY(theta) { + const c = Math.cos(theta), s = Math.sin(theta); + this.set(c, 0, s, 0, 0, 1, 0, 0, -s, 0, c, 0, 0, 0, 0, 1); + return this; + } + makeRotationZ(theta) { + const c = Math.cos(theta), s = Math.sin(theta); + this.set(c, -s, 0, 0, s, c, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1); + return this; + } + makeTranslation(x, y, z) { + this.set(1, 0, 0, x, 0, 1, 0, y, 0, 0, 1, z, 0, 0, 0, 1); + return this; + } + makeScale(x, y, z) { + this.set(x, 0, 0, 0, 0, y, 0, 0, 0, 0, z, 0, 0, 0, 0, 1); + return this; + } + compose(position, quaternion, scale) { + const te = this.data; + const x = quaternion.x, y = quaternion.y, z = quaternion.z, w = quaternion.w; + const x2 = x + x, y2 = y + y, z2 = z + z; + const xx = x * x2, xy = x * y2, xz = x * z2; + const yy = y * y2, yz = y * z2, zz = z * z2; + const wx = w * x2, wy = w * y2, wz = w * z2; + const sx = scale.x, sy = scale.y, sz = scale.z; + te[0] = (1 - (yy + zz)) * sx; + te[1] = (xy + wz) * sx; + te[2] = (xz - wy) * sx; + te[3] = 0; + te[4] = (xy - wz) * sy; + te[5] = (1 - (xx + zz)) * sy; + te[6] = (yz + wx) * sy; + te[7] = 0; + te[8] = (xz + wy) * sz; + te[9] = (yz - wx) * sz; + te[10] = (1 - (xx + yy)) * sz; + te[11] = 0; + te[12] = position.x; + te[13] = position.y; + te[14] = position.z; + te[15] = 1; + return this; + } + decompose(position, quaternion, scale) { + const te = this.data; + const _v1 = _Matr42.tempVect3; + let sx = _v1.set(te[0], te[1], te[2]).length(); + const sy = _v1.set(te[4], te[5], te[6]).length(); + const sz = _v1.set(te[8], te[9], te[10]).length(); + const det = this.determinant(); + if (det < 0) sx = -sx; + position.x = te[12]; + position.y = te[13]; + position.z = te[14]; + const _m1 = _Matr42.tempMatr4; + _m1.copy(this); + const invSX = 1 / sx; + const invSY = 1 / sy; + const invSZ = 1 / sz; + _m1.data[0] *= invSX; + _m1.data[1] *= invSX; + _m1.data[2] *= invSX; + _m1.data[4] *= invSY; + _m1.data[5] *= invSY; + _m1.data[6] *= invSY; + _m1.data[8] *= invSZ; + _m1.data[9] *= invSZ; + _m1.data[10] *= invSZ; + const _q1 = _Matr42.tempQuat; + _q1.setFromRotationMatrix(_m1); + quaternion.x = _q1.x; + quaternion.y = _q1.y; + quaternion.z = _q1.z; + quaternion.w = _q1.w; + scale.x = sx; + scale.y = sy; + scale.z = sz; + return this; + } + multiply(m) { + return this.multiplyMatrices(this, m); + } + premultiply(m) { + return this.multiplyMatrices(m, this); + } + multiplyMatrices(a, b) { + const ae = a.data; + const be = b.data; + const te = this.data; + const a11 = ae[0], a12 = ae[4], a13 = ae[8], a14 = ae[12]; + const a21 = ae[1], a22 = ae[5], a23 = ae[9], a24 = ae[13]; + const a31 = ae[2], a32 = ae[6], a33 = ae[10], a34 = ae[14]; + const a41 = ae[3], a42 = ae[7], a43 = ae[11], a44 = ae[15]; + const b11 = be[0], b12 = be[4], b13 = be[8], b14 = be[12]; + const b21 = be[1], b22 = be[5], b23 = be[9], b24 = be[13]; + const b31 = be[2], b32 = be[6], b33 = be[10], b34 = be[14]; + const b41 = be[3], b42 = be[7], b43 = be[11], b44 = be[15]; + te[0] = a11 * b11 + a12 * b21 + a13 * b31 + a14 * b41; + te[4] = a11 * b12 + a12 * b22 + a13 * b32 + a14 * b42; + te[8] = a11 * b13 + a12 * b23 + a13 * b33 + a14 * b43; + te[12] = a11 * b14 + a12 * b24 + a13 * b34 + a14 * b44; + te[1] = a21 * b11 + a22 * b21 + a23 * b31 + a24 * b41; + te[5] = a21 * b12 + a22 * b22 + a23 * b32 + a24 * b42; + te[9] = a21 * b13 + a22 * b23 + a23 * b33 + a24 * b43; + te[13] = a21 * b14 + a22 * b24 + a23 * b34 + a24 * b44; + te[2] = a31 * b11 + a32 * b21 + a33 * b31 + a34 * b41; + te[6] = a31 * b12 + a32 * b22 + a33 * b32 + a34 * b42; + te[10] = a31 * b13 + a32 * b23 + a33 * b33 + a34 * b43; + te[14] = a31 * b14 + a32 * b24 + a33 * b34 + a34 * b44; + te[3] = a41 * b11 + a42 * b21 + a43 * b31 + a44 * b41; + te[7] = a41 * b12 + a42 * b22 + a43 * b32 + a44 * b42; + te[11] = a41 * b13 + a42 * b23 + a43 * b33 + a44 * b43; + te[15] = a41 * b14 + a42 * b24 + a43 * b34 + a44 * b44; + return this; + } + invert() { + const te = this.data, n11 = te[0], n21 = te[1], n31 = te[2], n41 = te[3], n12 = te[4], n22 = te[5], n32 = te[6], n42 = te[7], n13 = te[8], n23 = te[9], n33 = te[10], n43 = te[11], n14 = te[12], n24 = te[13], n34 = te[14], n44 = te[15], t11 = n23 * n34 * n42 - n24 * n33 * n42 + n24 * n32 * n43 - n22 * n34 * n43 - n23 * n32 * n44 + n22 * n33 * n44, t12 = n14 * n33 * n42 - n13 * n34 * n42 - n14 * n32 * n43 + n12 * n34 * n43 + n13 * n32 * n44 - n12 * n33 * n44, t13 = n13 * n24 * n42 - n14 * n23 * n42 + n14 * n22 * n43 - n12 * n24 * n43 - n13 * n22 * n44 + n12 * n23 * n44, t14 = n14 * n23 * n32 - n13 * n24 * n32 - n14 * n22 * n33 + n12 * n24 * n33 + n13 * n22 * n34 - n12 * n23 * n34; + const det = n11 * t11 + n21 * t12 + n31 * t13 + n41 * t14; + if (det === 0) { + return this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); + } + const detInv = 1 / det; + te[0] = t11 * detInv; + te[1] = (n24 * n33 * n41 - n23 * n34 * n41 - n24 * n31 * n43 + n21 * n34 * n43 + n23 * n31 * n44 - n21 * n33 * n44) * detInv; + te[2] = (n22 * n34 * n41 - n24 * n32 * n41 + n24 * n31 * n42 - n21 * n34 * n42 - n22 * n31 * n44 + n21 * n32 * n44) * detInv; + te[3] = (n23 * n32 * n41 - n22 * n33 * n41 - n23 * n31 * n42 + n21 * n33 * n42 + n22 * n31 * n43 - n21 * n32 * n43) * detInv; + te[4] = t12 * detInv; + te[5] = (n13 * n34 * n41 - n14 * n33 * n41 + n14 * n31 * n43 - n11 * n34 * n43 - n13 * n31 * n44 + n11 * n33 * n44) * detInv; + te[6] = (n14 * n32 * n41 - n12 * n34 * n41 - n14 * n31 * n42 + n11 * n34 * n42 + n12 * n31 * n44 - n11 * n32 * n44) * detInv; + te[7] = (n12 * n33 * n41 - n13 * n32 * n41 + n13 * n31 * n42 - n11 * n33 * n42 - n12 * n31 * n43 + n11 * n32 * n43) * detInv; + te[8] = t13 * detInv; + te[9] = (n14 * n23 * n41 - n13 * n24 * n41 - n14 * n21 * n43 + n11 * n24 * n43 + n13 * n21 * n44 - n11 * n23 * n44) * detInv; + te[10] = (n12 * n24 * n41 - n14 * n22 * n41 + n14 * n21 * n42 - n11 * n24 * n42 - n12 * n21 * n44 + n11 * n22 * n44) * detInv; + te[11] = (n13 * n22 * n41 - n12 * n23 * n41 - n13 * n21 * n42 + n11 * n23 * n42 + n12 * n21 * n43 - n11 * n22 * n43) * detInv; + te[12] = t14 * detInv; + te[13] = (n13 * n24 * n31 - n14 * n23 * n31 + n14 * n21 * n33 - n11 * n24 * n33 - n13 * n21 * n34 + n11 * n23 * n34) * detInv; + te[14] = (n14 * n22 * n31 - n12 * n24 * n31 - n14 * n21 * n32 + n11 * n24 * n32 + n12 * n21 * n34 - n11 * n22 * n34) * detInv; + te[15] = (n12 * n23 * n31 - n13 * n22 * n31 + n13 * n21 * n32 - n11 * n23 * n32 - n12 * n21 * n33 + n11 * n22 * n33) * detInv; + return this; + } +}; +_Matr4.tempMatr4 = new _Matr4(); +_Matr4.tempVect3 = new Vect3(); +_Matr4.tempQuat = new Quat(); +var Matr4 = _Matr4; +var epsilon = 1e-4; +var matrix1 = new Matr4(); +var vector1 = new Vect3(); +var OrientedBoundingBox = class _OrientedBoundingBox { + constructor(size, matr4, centerOffset = null) { + this.size = size; + this.matr4 = matr4; + this.centerOffset = centerOffset; + } + static fromSizeAndMatrixWorld(size, matr4) { + return new _OrientedBoundingBox(size, matr4); + } + static fromSizeMatrixWorldAndCenter(size, matr4, centerOffset) { + return new _OrientedBoundingBox(size, matr4, centerOffset); + } + static fromMatrixWorld(matr4) { + return new _OrientedBoundingBox(new Vect3(), matr4); + } + getCorners() { + const corners = []; + for (let x = -1; x <= 1; x += 2) { + for (let y = -1; y <= 1; y += 2) { + for (let z = -1; z <= 1; z += 2) { + const point = vector1.set( + x * (this.size.x / 2), + y * (this.size.y / 2), + z * (this.size.z / 2) + ); + if (this.centerOffset !== null) { + point.add(this.centerOffset); + } + point.applyMatrix4(this.matr4); + corners.push(point.clone()); + } + } + } + return corners; + } + completelyContainsBoundingBox(childOBB) { + const invertedMatrix = matrix1.copy(this.matr4).invert(); + for (let x = -1; x <= 1; x += 2) { + for (let y = -1; y <= 1; y += 2) { + for (let z = -1; z <= 1; z += 2) { + const point = vector1.set( + x * (childOBB.size.x / 2), + y * (childOBB.size.y / 2), + z * (childOBB.size.z / 2) + ); + if (childOBB.centerOffset !== null) { + point.add(childOBB.centerOffset); + } + point.applyMatrix4(childOBB.matr4); + const localPoint = point.applyMatrix4(invertedMatrix); + if (this.centerOffset !== null) { + localPoint.sub(this.centerOffset); + } + const isWithin = Math.abs(localPoint.x) <= this.size.x / 2 + epsilon && Math.abs(localPoint.y) <= this.size.y / 2 + epsilon && Math.abs(localPoint.z) <= this.size.z / 2 + epsilon; + if (!isWithin) { + return false; + } + } + } + } + return true; + } + containsPoint(point) { + const invertedMatrix = matrix1.copy(this.matr4).invert(); + const localPoint = vector1.copy(point).applyMatrix4(invertedMatrix); + if (this.centerOffset !== null) { + localPoint.sub(this.centerOffset); + } + return Math.abs(localPoint.x) <= this.size.x / 2 + epsilon && Math.abs(localPoint.y) <= this.size.y / 2 + epsilon && Math.abs(localPoint.z) <= this.size.z / 2 + epsilon; + } +}; +var CanvasText = class { + constructor() { + this.canvas = document.createElement("canvas"); + this.context = this.canvas.getContext("2d"); + } + renderText(message, options) { + const fontsize = options.fontSize; + const textColor = options.textColorRGB255A1; + const backgroundColor = options.backgroundColorRGB255A1 || { r: 255, g: 255, b: 255, a: 1 }; + const padding = options.paddingPx || 0; + const font = options.font || "Arial"; + const fontString = (options.bold ? "bold " : "") + fontsize + "px " + font; + const textAlign = options.alignment ?? "left"; + if (options.dimensions) { + this.canvas.width = options.dimensions.width; + this.canvas.height = options.dimensions.height; + this.context.clearRect(0, 0, this.canvas.width, this.canvas.height); + this.context.font = fontString; + this.context.textAlign = textAlign; + this.context.fillStyle = `rgba(${backgroundColor.r}, ${backgroundColor.g}, ${backgroundColor.b}, ${backgroundColor.a})`; + this.context.lineWidth = 0; + this.context.fillRect(0, 0, this.canvas.width, this.canvas.height); + this.context.fillStyle = `rgba(${textColor.r}, ${textColor.g}, ${textColor.b}, ${textColor.a})`; + this.context.font = fontString; + printAtWordWrap( + this.context, + message, + textAlign, + fontsize, + fontsize, + this.canvas.width, + padding + ); + } else { + this.context.font = fontString; + const metrics = this.context.measureText(message); + const textWidth = metrics.width; + const textHeight = metrics.fontBoundingBoxAscent + metrics.fontBoundingBoxDescent; + this.canvas.width = textWidth + padding * 2; + this.canvas.height = textHeight + padding; + this.context.clearRect(0, 0, this.canvas.width, this.canvas.height); + this.context.font = fontString; + this.context.textAlign = textAlign; + this.context.fillStyle = `rgba(${backgroundColor.r}, ${backgroundColor.g}, ${backgroundColor.b}, ${backgroundColor.a})`; + this.context.lineWidth = 0; + this.context.fillRect(0, 0, this.canvas.width, this.canvas.height); + this.context.fillStyle = `rgba(${textColor.r}, ${textColor.g}, ${textColor.b}, ${textColor.a})`; + this.context.font = fontString; + this.context.fillText( + message, + padding + getTextAlignOffset(textAlign, textWidth), + textHeight + ); + } + return this.canvas; + } +}; +function printAtWordWrap(context, fullText, textAlign, y, lineHeight, fitWidth, padding) { + const x = getTextAlignOffset(textAlign, fitWidth - padding * 2); + const lines = fullText.split("\n"); + let currentLine = 0; + for (const text of lines) { + fitWidth = fitWidth || 0; + if (fitWidth <= 0) { + context.fillText(text, x, y + lineHeight * currentLine); + currentLine++; + continue; + } + let words = text.split(" "); + let lastWordIndex = 1; + while (words.length > 0 && lastWordIndex <= words.length) { + const str = words.slice(0, lastWordIndex).join(" "); + const textWidth = context.measureText(str).width; + if (textWidth + padding * 2 > fitWidth) { + if (lastWordIndex === 1) { + lastWordIndex = 2; + } + context.fillText( + words.slice(0, lastWordIndex - 1).join(" "), + x + padding, + y + lineHeight * currentLine + padding + ); + currentLine++; + words = words.splice(lastWordIndex - 1); + lastWordIndex = 1; + } else { + lastWordIndex++; + } + } + if (lastWordIndex > 0 && words.length > 0) { + context.fillText(words.join(" "), x + padding, y + lineHeight * currentLine + padding); + currentLine++; + } + } +} +function getTextAlignOffset(textAlign, width) { + switch (textAlign) { + case "center": + return width / 2; + case "right": + return width; + default: + return 0; + } +} +var collideAttributeName = "collide"; +var collisionIntervalAttributeName = "collision-interval"; +var defaultCollideable = true; +var _CollideableHelper = class _CollideableHelper2 { + constructor(element) { + this.props = { + collide: defaultCollideable + }; + this.scene = null; + this.collider = null; + this.added = false; + this.enabled = true; + this.element = element; + } + enable() { + if (this.enabled) { + return; + } + this.enabled = true; + this.updateCollider(this.collider); + } + disable() { + if (!this.enabled) { + return; + } + this.enabled = false; + this.updateCollider(this.collider); + } + updateCollider(collider) { + var _a, _b, _c, _d, _e, _f, _g, _h; + if (!this.element.isConnected) { + this.collider = collider; + return; + } + this.scene = this.element.getScene(); + const previousCollider = this.collider; + const colliderChanged = previousCollider !== collider; + if (colliderChanged) { + this.added = false; + } + this.collider = collider; + const shouldEnableCollider = this.props.collide && this.enabled; + if (!shouldEnableCollider && previousCollider === null) { + this.added = false; + return; + } + if (shouldEnableCollider) { + if (colliderChanged && previousCollider !== null) { + (_b = (_a = this.scene).removeCollider) == null ? void 0 : _b.call(_a, previousCollider, this.element); + } + if (collider !== null) { + if (this.added) { + (_d = (_c = this.scene).updateCollider) == null ? void 0 : _d.call(_c, collider, this.element); + } else { + this.added = true; + (_f = (_e = this.scene).addCollider) == null ? void 0 : _f.call(_e, collider, this.element); + } + } + } else { + if (previousCollider !== null) { + this.added = false; + (_h = (_g = this.scene).removeCollider) == null ? void 0 : _h.call(_g, previousCollider, this.element); + } + } + } + removeColliders() { + var _a; + const scene2 = this.scene; + if (!scene2) { + return; + } + if (!this.collider) { + return; + } + (_a = scene2.removeCollider) == null ? void 0 : _a.call(scene2, this.collider, this.element); + this.scene = null; + } + handle(name, newValue) { + _CollideableHelper2.AttributeHandler.handle(this, name, newValue); + } + parentTransformed() { + this.updateCollider(this.collider); + } +}; +_CollideableHelper.AttributeHandler = new AttributeHandler({ + [collideAttributeName]: (instance, newValue) => { + const collide = parseBoolAttribute(newValue, defaultCollideable); + if (collide !== instance.props.collide) { + instance.props.collide = collide; + instance.updateCollider(instance.collider); + } + }, + [collisionIntervalAttributeName]: () => { + } +}); +_CollideableHelper.observedAttributes = _CollideableHelper.AttributeHandler.getAttributes(); +var CollideableHelper = _CollideableHelper; +var debugAttributeName = "debug"; +var DebugHelper = class { + constructor(element) { + this.element = element; + this.debugGraphics = null; + } + getContainer() { + return this.element.getContainer(); + } + handle(name, newValue) { + var _a; + if (name === debugAttributeName) { + if (parseBoolAttribute(newValue, false)) { + if (!this.debugGraphics) { + this.debugGraphics = this.element.getScene().getGraphicsAdapter().getGraphicsAdapterFactory().MMLDebugHelperGraphicsInterface(this); + } + } else { + (_a = this.debugGraphics) == null ? void 0 : _a.dispose(); + this.debugGraphics = null; + } + } + } +}; +DebugHelper.observedAttributes = [debugAttributeName]; +function clamp(value, min, max) { + return Math.max(min, Math.min(max, value)); +} +var _EulXYZ = class _EulXYZ2 { + constructor(x, y, z) { + if (x instanceof _EulXYZ2) { + this.x = x.x; + this.y = x.y; + this.z = x.z; + return; + } + this.x = x || 0; + this.y = y || 0; + this.z = z || 0; + } + setFromRotationMatrix(m) { + const d = m.data; + const m11 = d[0]; + const m12 = d[4]; + const m13 = d[8]; + const m22 = d[5]; + const m23 = d[9]; + const m32 = d[6]; + const m33 = d[10]; + this.y = Math.asin(clamp(m13, -1, 1)); + if (Math.abs(m13) < 0.9999999) { + this.x = Math.atan2(-m23, m33); + this.z = Math.atan2(-m12, m11); + } else { + this.x = Math.atan2(m32, m22); + this.z = 0; + } + return this; + } + setFromQuaternion(q) { + const matrix = _EulXYZ2.tempMatrix; + matrix.setRotationFromQuaternion(q); + return this.setFromRotationMatrix(matrix); + } + copy(other) { + this.x = other.x || 0; + this.y = other.y || 0; + this.z = other.z || 0; + return this; + } + length() { + return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z); + } + lengthSquared() { + return this.x * this.x + this.y * this.y + this.z * this.z; + } + clone() { + return new _EulXYZ2(this); + } + set(x, y, z) { + this.x = x; + this.y = y; + this.z = z; + return this; + } +}; +_EulXYZ.tempMatrix = new Matr4(); +var EulXYZ = _EulXYZ; +function radToDeg(rad) { + return rad * (180 / Math.PI); +} +function degToRad(deg) { + return deg * (Math.PI / 180); +} +function minimumNonZero(value) { + return value === 0 ? 1e-6 : value; +} +var defaultVisible = true; +var _TransformableElement = class _TransformableElement2 extends MElement { + constructor() { + super(...arguments); + this.transformableElementProps = { + socket: null, + x: 0, + y: 0, + z: 0, + rx: 0, + ry: 0, + rz: 0, + sx: 1, + sy: 1, + sz: 1 + }; + this.desiredVisible = defaultVisible; + this.appliedBounds = /* @__PURE__ */ new Map(); + this.directlyDisabledByBounds = false; + this.disabledByParent = false; + this.transformableElementGraphics = null; + this.transformableAnimatedAttributeHelper = new AnimatedAttributeHelper(this, { + x: [ + 0, + 0, + (newValue) => { + var _a; + this.transformableElementProps.x = newValue; + (_a = this.transformableElementGraphics) == null ? void 0 : _a.setX(newValue, this.transformableElementProps); + this.didUpdateTransformation(); + } + ], + y: [ + 0, + 0, + (newValue) => { + var _a; + this.transformableElementProps.y = newValue; + (_a = this.transformableElementGraphics) == null ? void 0 : _a.setY(newValue, this.transformableElementProps); + this.didUpdateTransformation(); + } + ], + z: [ + 0, + 0, + (newValue) => { + var _a; + this.transformableElementProps.z = newValue; + (_a = this.transformableElementGraphics) == null ? void 0 : _a.setZ(newValue, this.transformableElementProps); + this.didUpdateTransformation(); + } + ], + rx: [ + 0, + 0, + (newValue) => { + var _a; + this.transformableElementProps.rx = newValue; + (_a = this.transformableElementGraphics) == null ? void 0 : _a.setRotationX(newValue, this.transformableElementProps); + this.didUpdateTransformation(); + } + ], + ry: [ + 0, + 0, + (newValue) => { + var _a; + this.transformableElementProps.ry = newValue; + (_a = this.transformableElementGraphics) == null ? void 0 : _a.setRotationY(newValue, this.transformableElementProps); + this.didUpdateTransformation(); + } + ], + rz: [ + 0, + 0, + (newValue) => { + var _a; + this.transformableElementProps.rz = newValue; + (_a = this.transformableElementGraphics) == null ? void 0 : _a.setRotationZ(newValue, this.transformableElementProps); + this.didUpdateTransformation(); + } + ], + sx: [ + 0, + 1, + (newValue) => { + var _a; + this.transformableElementProps.sx = newValue; + (_a = this.transformableElementGraphics) == null ? void 0 : _a.setScaleX( + minimumNonZero(newValue), + this.transformableElementProps + ); + this.didUpdateTransformation(); + } + ], + sy: [ + 0, + 1, + (newValue) => { + var _a; + this.transformableElementProps.sy = newValue; + (_a = this.transformableElementGraphics) == null ? void 0 : _a.setScaleY( + minimumNonZero(newValue), + this.transformableElementProps + ); + this.didUpdateTransformation(); + } + ], + sz: [ + 0, + 1, + (newValue) => { + var _a; + this.transformableElementProps.sz = newValue; + (_a = this.transformableElementGraphics) == null ? void 0 : _a.setScaleZ( + minimumNonZero(newValue), + this.transformableElementProps + ); + this.didUpdateTransformation(); + } + ] + }); + this.debugHelper = new DebugHelper(this); + } + getTransformableElementParent() { + let parentNode = this.parentNode; + while (parentNode != null) { + if (parentNode instanceof _TransformableElement2) { + return parentNode; + } + parentNode = parentNode.parentNode; + } + return null; + } + calculateLocalMatrix(matrix) { + const pos = { + x: this.transformableElementProps.x, + y: this.transformableElementProps.y, + z: this.transformableElementProps.z + }; + const eulerXYZRotation = { + x: degToRad(this.transformableElementProps.rx), + y: degToRad(this.transformableElementProps.ry), + z: degToRad(this.transformableElementProps.rz) + }; + const scale = { + x: this.transformableElementProps.sx, + y: this.transformableElementProps.sy, + z: this.transformableElementProps.sz + }; + const quaternion = _TransformableElement2.tempQuat; + quaternion.setFromEulerXYZ(eulerXYZRotation); + matrix.compose(pos, quaternion, scale); + } + connectedCallback() { + super.connectedCallback(); + if (!this.getScene().hasGraphicsAdapter() || this.transformableElementGraphics) { + return; + } + const graphicsAdapter = this.getScene().getGraphicsAdapter(); + this.transformableElementGraphics = graphicsAdapter.getGraphicsAdapterFactory().MMLTransformableGraphicsInterface(this); + const mElementParent = this.getTransformableElementParent(); + if (mElementParent) { + const parentBounds = mElementParent.getAppliedBounds(); + parentBounds.forEach((orientedBox, ref) => { + this.addOrUpdateParentBound(ref, orientedBox); + }); + return; + } + } + disconnectedCallback() { + var _a; + this.transformableAnimatedAttributeHelper.reset(); + (_a = this.transformableElementGraphics) == null ? void 0 : _a.dispose(); + this.transformableElementGraphics = null; + super.disconnectedCallback(); + } + static get observedAttributes() { + return [ + ..._TransformableElement2.TransformableElementAttributeHandler.getAttributes(), + ...DebugHelper.observedAttributes + ]; + } + addSideEffectChild(child) { + this.transformableAnimatedAttributeHelper.addSideEffectChild(child); + super.addSideEffectChild(child); + } + removeSideEffectChild(child) { + this.transformableAnimatedAttributeHelper.removeSideEffectChild(child); + super.removeSideEffectChild(child); + } + applyBounds() { + if (!this.transformableElementGraphics) { + return; + } + const appliedBounds = this.getAppliedBounds(); + if (appliedBounds.size > 0) { + const thisElementBounds = this.getContentBounds(); + if (thisElementBounds) { + for (const [, orientedBox] of appliedBounds) { + if (!orientedBox.completelyContainsBoundingBox(thisElementBounds)) { + if (!this.directlyDisabledByBounds) { + this.disabledByBounds(); + } + return; + } + } + } + } + this.reenableByBounds(); + } + didUpdateTransformation() { + this.applyBounds(); + this.parentTransformed(); + traverseImmediateTransformableElementChildren(this, (child) => { + child.didUpdateTransformation(); + }); + } + attributeChangedCallback(name, oldValue, newValue) { + if (!this.transformableElementGraphics) { + return; + } + _TransformableElement2.TransformableElementAttributeHandler.handle(this, name, newValue); + this.debugHelper.handle(name, newValue); + } + getAppliedBounds() { + return this.appliedBounds; + } + addOrUpdateParentBound(ref, orientedBox) { + this.appliedBounds.set(ref, orientedBox); + traverseImmediateTransformableElementChildren(this, (child) => { + child.addOrUpdateParentBound(ref, orientedBox); + }); + this.applyBounds(); + } + removeParentBound(ref) { + this.appliedBounds.delete(ref); + traverseImmediateTransformableElementChildren(this, (child) => { + child.removeParentBound(ref); + }); + this.applyBounds(); + } + disabledByBounds() { + if (this.directlyDisabledByBounds) { + return; + } + this.directlyDisabledByBounds = true; + this.updateVisibility(); + if (this.disabledByParent) { + return; + } + this.disable(); + traverseImmediateTransformableElementChildren(this, (child) => { + child.disabledByParentBounds(); + }); + } + isDisabled() { + return this.directlyDisabledByBounds || this.disabledByParent; + } + disabledByParentBounds() { + if (this.disabledByParent) { + return; + } + this.disabledByParent = true; + this.updateVisibility(); + if (this.directlyDisabledByBounds) { + return; + } + this.disable(); + traverseImmediateTransformableElementChildren(this, (child) => { + child.disabledByParentBounds(); + }); + } + reenableByBounds() { + if (!this.directlyDisabledByBounds) { + return; + } + this.directlyDisabledByBounds = false; + if (!this.disabledByParent) { + this.updateVisibility(); + this.enable(); + traverseImmediateTransformableElementChildren(this, (child) => { + child.reenableByParentBounds(); + }); + } + } + reenableByParentBounds() { + if (!this.disabledByParent) { + return; + } + this.disabledByParent = false; + if (!this.directlyDisabledByBounds) { + this.updateVisibility(); + this.enable(); + traverseImmediateTransformableElementChildren(this, (child) => { + child.reenableByParentBounds(); + }); + } + } + updateVisibility() { + var _a; + (_a = this.transformableElementGraphics) == null ? void 0 : _a.setVisible( + this.desiredVisible && !this.isDisabled(), + this.transformableElementProps + ); + } +}; +_TransformableElement.tempQuat = new Quat(); +_TransformableElement.TransformableElementAttributeHandler = new AttributeHandler({ + x: (instance, newValue) => { + instance.transformableAnimatedAttributeHelper.elementSetAttribute( + "x", + parseFloatAttribute(newValue, 0) + ); + }, + y: (instance, newValue) => { + instance.transformableAnimatedAttributeHelper.elementSetAttribute( + "y", + parseFloatAttribute(newValue, 0) + ); + }, + z: (instance, newValue) => { + instance.transformableAnimatedAttributeHelper.elementSetAttribute( + "z", + parseFloatAttribute(newValue, 0) + ); + }, + rx: (instance, newValue) => { + instance.transformableAnimatedAttributeHelper.elementSetAttribute( + "rx", + parseFloatAttribute(newValue, 0) + ); + }, + ry: (instance, newValue) => { + instance.transformableAnimatedAttributeHelper.elementSetAttribute( + "ry", + parseFloatAttribute(newValue, 0) + ); + }, + rz: (instance, newValue) => { + instance.transformableAnimatedAttributeHelper.elementSetAttribute( + "rz", + parseFloatAttribute(newValue, 0) + ); + }, + sx: (instance, newValue) => { + instance.transformableAnimatedAttributeHelper.elementSetAttribute( + "sx", + parseFloatAttribute(newValue, 1) + ); + }, + sy: (instance, newValue) => { + instance.transformableAnimatedAttributeHelper.elementSetAttribute( + "sy", + parseFloatAttribute(newValue, 1) + ); + }, + sz: (instance, newValue) => { + instance.transformableAnimatedAttributeHelper.elementSetAttribute( + "sz", + parseFloatAttribute(newValue, 1) + ); + }, + visible: (instance, newValue) => { + instance.desiredVisible = parseBoolAttribute(newValue, defaultVisible); + instance.updateVisibility(); + }, + socket: (instance, newValue) => { + var _a; + instance.transformableElementProps.socket = newValue; + (_a = instance.transformableElementGraphics) == null ? void 0 : _a.setSocket( + newValue, + instance.transformableElementProps + ); + instance.applyBounds(); + } +}); +var TransformableElement = _TransformableElement; +function traverseImmediateTransformableElementChildren(element, callback) { + element.childNodes.forEach((child) => { + if (child instanceof TransformableElement) { + callback(child); + } else { + traverseImmediateTransformableElementChildren(child, callback); + } + }); +} +var defaultAudioVolume = 1; +var defaultAudioLoop = true; +var defaultAudioEnabled = true; +var defaultAudioStartTime = 0; +var defaultAudioPauseTime = null; +var defaultAudioSrc = null; +var defaultAudioInnerConeAngle = 360; +var defaultAudioOuterConeAngle = 0; +var defaultAudioDebug = false; +function clampAudioConeAngle(angle) { + return Math.max(Math.min(angle, 360), 0); +} +var _Audio = class _Audio2 extends TransformableElement { + constructor() { + super(); + this.props = { + src: defaultAudioSrc, + startTime: defaultAudioStartTime, + pauseTime: defaultAudioPauseTime, + loop: defaultAudioLoop, + loopDuration: null, + enabled: defaultAudioEnabled, + volume: defaultAudioVolume, + coneAngle: defaultAudioInnerConeAngle, + coneFalloffAngle: defaultAudioOuterConeAngle, + debug: false + }; + this.audioGraphics = null; + this.audioAnimatedAttributeHelper = new AnimatedAttributeHelper(this, { + volume: [ + 0, + defaultAudioVolume, + (newValue) => { + var _a; + this.props.volume = newValue; + (_a = this.audioGraphics) == null ? void 0 : _a.setVolume(newValue, this.props); + } + ], + "cone-angle": [ + 0, + defaultAudioInnerConeAngle, + (newValue) => { + var _a; + this.props.coneAngle = newValue === null ? defaultAudioInnerConeAngle : clampAudioConeAngle(newValue); + (_a = this.audioGraphics) == null ? void 0 : _a.setConeAngle(this.props.coneAngle, this.props); + } + ], + "cone-falloff-angle": [ + 0, + defaultAudioOuterConeAngle, + (newValue) => { + var _a; + this.props.coneFalloffAngle = clampAudioConeAngle(newValue); + (_a = this.audioGraphics) == null ? void 0 : _a.setConeFalloffAngle(this.props.coneFalloffAngle, this.props); + } + ] + }); + } + static get observedAttributes() { + return [...TransformableElement.observedAttributes, ..._Audio2.attributeHandler.getAttributes()]; + } + enable() { + var _a; + (_a = this.audioGraphics) == null ? void 0 : _a.syncAudioTime(); + } + disable() { + var _a; + (_a = this.audioGraphics) == null ? void 0 : _a.syncAudioTime(); + } + getContentBounds() { + if (!this.transformableElementGraphics) { + return null; + } + return OrientedBoundingBox.fromMatrixWorld(this.transformableElementGraphics.getWorldMatrix()); + } + addSideEffectChild(child) { + this.audioAnimatedAttributeHelper.addSideEffectChild(child); + super.addSideEffectChild(child); + } + removeSideEffectChild(child) { + this.audioAnimatedAttributeHelper.removeSideEffectChild(child); + super.removeSideEffectChild(child); + } + parentTransformed() { + } + isClickable() { + return true; + } + attributeChangedCallback(name, oldValue, newValue) { + if (!this.audioGraphics) { + return; + } + super.attributeChangedCallback(name, oldValue, newValue); + _Audio2.attributeHandler.handle(this, name, newValue); + } + documentTimeChanged() { + var _a; + (_a = this.audioGraphics) == null ? void 0 : _a.syncAudioTime(); + } + connectedCallback() { + super.connectedCallback(); + if (!this.getScene().hasGraphicsAdapter() || this.audioGraphics) { + return; + } + const graphicsAdapter = this.getScene().getGraphicsAdapter(); + this.audioGraphics = graphicsAdapter.getGraphicsAdapterFactory().MMLAudioGraphicsInterface(this); + this.documentTimeListener = this.addDocumentTimeListener(() => { + this.documentTimeChanged(); + }); + for (const name of _Audio2.observedAttributes) { + const value = this.getAttribute(name); + if (value !== null) { + this.attributeChangedCallback(name, null, value); + } + } + } + disconnectedCallback() { + var _a; + this.audioAnimatedAttributeHelper.reset(); + (_a = this.audioGraphics) == null ? void 0 : _a.dispose(); + this.audioGraphics = null; + this.documentTimeListener.remove(); + super.disconnectedCallback(); + } +}; +_Audio.tagName = "m-audio"; +_Audio.attributeHandler = new AttributeHandler({ + enabled: (instance, newValue) => { + var _a; + instance.props.enabled = parseBoolAttribute(newValue, defaultAudioEnabled); + (_a = instance.audioGraphics) == null ? void 0 : _a.setEnabled(instance.props.enabled, instance.props); + }, + loop: (instance, newValue) => { + var _a; + instance.props.loop = parseBoolAttribute(newValue, defaultAudioLoop); + (_a = instance.audioGraphics) == null ? void 0 : _a.setLoop(instance.props.loop, instance.props); + }, + "loop-duration": (instance, newValue) => { + var _a; + instance.props.loopDuration = parseFloatAttribute(newValue, null); + (_a = instance.audioGraphics) == null ? void 0 : _a.setLoopDuration(instance.props.loopDuration, instance.props); + }, + "start-time": (instance, newValue) => { + var _a; + instance.props.startTime = parseFloatAttribute(newValue, defaultAudioStartTime); + (_a = instance.audioGraphics) == null ? void 0 : _a.setStartTime(instance.props.startTime, instance.props); + }, + "pause-time": (instance, newValue) => { + var _a; + instance.props.pauseTime = parseFloatAttribute(newValue, defaultAudioPauseTime); + (_a = instance.audioGraphics) == null ? void 0 : _a.setPauseTime(instance.props.pauseTime, instance.props); + }, + src: (instance, newValue) => { + var _a; + instance.props.src = newValue; + (_a = instance.audioGraphics) == null ? void 0 : _a.setSrc(newValue, instance.props); + }, + volume: (instance, newValue) => { + instance.audioAnimatedAttributeHelper.elementSetAttribute( + "volume", + parseFloatAttribute(newValue, defaultAudioVolume) + ); + }, + "cone-angle": (instance, newValue) => { + instance.audioAnimatedAttributeHelper.elementSetAttribute( + "cone-angle", + parseFloatAttribute(newValue, null) + ); + }, + "cone-falloff-angle": (instance, newValue) => { + instance.audioAnimatedAttributeHelper.elementSetAttribute( + "cone-falloff-angle", + parseFloatAttribute(newValue, defaultAudioOuterConeAngle) + ); + }, + debug: (instance, newValue) => { + var _a; + instance.props.debug = parseBoolAttribute(newValue, defaultAudioDebug); + (_a = instance.audioGraphics) == null ? void 0 : _a.setDebug(instance.props.debug, instance.props); + } +}); +var Audio = _Audio; +var defaultModelSrc = null; +var defaultModelAnim = null; +var defaultModelAnimLoop = true; +var defaultModelAnimEnabled = true; +var defaultModelAnimStartTime = 0; +var defaultModelAnimPauseTime = null; +var defaultModelCastShadows = true; +var defaultModelDebug = false; +var _Model = class _Model2 extends TransformableElement { + constructor() { + super(); + this.props = { + src: defaultModelSrc, + anim: defaultModelAnim, + animStartTime: defaultModelAnimStartTime, + animPauseTime: defaultModelAnimPauseTime, + animLoop: defaultModelAnimLoop, + animEnabled: defaultModelAnimEnabled, + castShadows: defaultModelCastShadows, + debug: defaultModelDebug + }; + this.isModel = true; + this.collideableHelper = new CollideableHelper(this); + this.modelGraphics = null; + } + enable() { + this.collideableHelper.enable(); + } + disable() { + this.collideableHelper.disable(); + } + static get observedAttributes() { + return [ + ...TransformableElement.observedAttributes, + ..._Model2.attributeHandler.getAttributes(), + ...CollideableHelper.observedAttributes + ]; + } + getContentBounds() { + var _a; + if (!this.transformableElementGraphics) { + return null; + } + const boundingBox = (_a = this.modelGraphics) == null ? void 0 : _a.getBoundingBox(); + if (boundingBox) { + return OrientedBoundingBox.fromSizeMatrixWorldAndCenter( + boundingBox.size, + this.transformableElementGraphics.getWorldMatrix(), + boundingBox.centerOffset + ); + } + return null; + } + parentTransformed() { + var _a; + this.collideableHelper.parentTransformed(); + (_a = this.modelGraphics) == null ? void 0 : _a.transformed(); + } + isClickable() { + return true; + } + attributeChangedCallback(name, oldValue, newValue) { + if (!this.modelGraphics) { + return; + } + super.attributeChangedCallback(name, oldValue, newValue); + _Model2.attributeHandler.handle(this, name, newValue); + this.collideableHelper.handle(name, newValue); + if (TransformableElement.observedAttributes.includes(name)) { + this.modelGraphics.transformed(); + } + } + connectedCallback() { + super.connectedCallback(); + if (!this.getScene().hasGraphicsAdapter() || this.modelGraphics) { + return; + } + const graphicsAdapter = this.getScene().getGraphicsAdapter(); + this.modelGraphics = graphicsAdapter.getGraphicsAdapterFactory().MMLModelGraphicsInterface(this, () => { + var _a; + this.applyBounds(); + this.collideableHelper.updateCollider((_a = this.modelGraphics) == null ? void 0 : _a.getCollisionElement()); + }); + for (const name of _Model2.observedAttributes) { + const value = this.getAttribute(name); + if (value !== null) { + this.attributeChangedCallback(name, null, value); + } + } + } + disconnectedCallback() { + var _a; + this.collideableHelper.removeColliders(); + (_a = this.modelGraphics) == null ? void 0 : _a.dispose(); + this.modelGraphics = null; + super.disconnectedCallback(); + } +}; +_Model.tagName = "m-model"; +_Model.attributeHandler = new AttributeHandler({ + src: (instance, newValue) => { + var _a; + instance.props.src = newValue; + (_a = instance.modelGraphics) == null ? void 0 : _a.setSrc(newValue, instance.props); + }, + anim: (instance, newValue) => { + var _a; + instance.props.anim = newValue; + (_a = instance.modelGraphics) == null ? void 0 : _a.setAnim(newValue, instance.props); + }, + debug: (instance, newValue) => { + var _a; + instance.props.debug = parseBoolAttribute(newValue, defaultModelDebug); + (_a = instance.modelGraphics) == null ? void 0 : _a.setDebug(instance.props.debug, instance.props); + }, + "cast-shadows": (instance, newValue) => { + var _a; + instance.props.castShadows = parseBoolAttribute(newValue, defaultModelCastShadows); + (_a = instance.modelGraphics) == null ? void 0 : _a.setCastShadows(instance.props.castShadows, instance.props); + }, + "anim-enabled": (instance, newValue) => { + var _a; + instance.props.animEnabled = parseBoolAttribute(newValue, defaultModelAnimEnabled); + (_a = instance.modelGraphics) == null ? void 0 : _a.setAnimEnabled(instance.props.animEnabled, instance.props); + }, + "anim-loop": (instance, newValue) => { + var _a; + instance.props.animLoop = parseBoolAttribute(newValue, defaultModelAnimLoop); + (_a = instance.modelGraphics) == null ? void 0 : _a.setAnimLoop(instance.props.animLoop, instance.props); + }, + "anim-start-time": (instance, newValue) => { + var _a; + instance.props.animStartTime = parseFloatAttribute(newValue, defaultModelAnimStartTime); + (_a = instance.modelGraphics) == null ? void 0 : _a.setAnimStartTime(instance.props.animStartTime, instance.props); + }, + "anim-pause-time": (instance, newValue) => { + var _a; + instance.props.animPauseTime = parseFloatAttribute(newValue, defaultModelAnimPauseTime); + (_a = instance.modelGraphics) == null ? void 0 : _a.setAnimPauseTime(instance.props.animPauseTime, instance.props); + } +}); +var Model = _Model; +var Character = class extends Model { + static get observedAttributes() { + return [...Model.observedAttributes]; + } + constructor() { + super(); + } + parentTransformed() { + } + isClickable() { + return true; + } + connectedCallback() { + super.connectedCallback(); + } + disconnectedCallback() { + super.disconnectedCallback(); + } +}; +Character.tagName = "m-character"; +var tempContainerMatrix = new Matr4(); +var tempTargetMatrix = new Matr4(); +var tempPositionVector = new Vect3(); +var tempRotationEuler = new EulXYZ(); +var tempRotationQuaternion = new Quat(); +var tempScaleVector = new Vect3(); +function getRelativePositionAndRotationRelativeToObject(positionAndRotation, container) { + const { x, y, z } = positionAndRotation.position; + const { x: rx, y: ry, z: rz } = positionAndRotation.rotation; + tempContainerMatrix.identity(); + const tempMatr4 = new Matr4(); + for (let obj = container; obj; obj = obj.parentNode) { + if (obj instanceof TransformableElement) { + obj.calculateLocalMatrix(tempMatr4); + tempContainerMatrix.premultiply(tempMatr4); + } + } + tempContainerMatrix.invert(); + tempPositionVector.set(x, y, z); + tempRotationEuler.set(degToRad(rx), degToRad(ry), degToRad(rz)); + tempRotationQuaternion.setFromEulerXYZ(tempRotationEuler); + tempScaleVector.set(1, 1, 1); + tempTargetMatrix.compose(tempPositionVector, tempRotationQuaternion, tempScaleVector); + tempTargetMatrix.premultiply(tempContainerMatrix); + tempTargetMatrix.decompose(tempPositionVector, tempRotationQuaternion, tempScaleVector); + tempRotationEuler.setFromQuaternion(tempRotationQuaternion); + return { + position: { + x: tempPositionVector.x, + y: tempPositionVector.y, + z: tempPositionVector.z + }, + rotation: { + x: radToDeg(tempRotationEuler.x), + y: radToDeg(tempRotationEuler.y), + z: radToDeg(tempRotationEuler.z) + } + }; +} +var defaultChatProbeRange = 10; +var defaultChatProbeDebug = false; +var chatProbeChatEventName = "chat"; +var _ChatProbe = class _ChatProbe2 extends TransformableElement { + constructor() { + super(); + this.chatProbeGraphics = null; + this.registeredScene = null; + this.chatProbeAnimatedAttributeHelper = new AnimatedAttributeHelper(this, { + range: [ + 0, + defaultChatProbeRange, + (newValue) => { + var _a; + this.props.range = newValue; + (_a = this.chatProbeGraphics) == null ? void 0 : _a.setRange(newValue, this.props); + this.applyBounds(); + } + ] + }); + this.props = { + debug: defaultChatProbeDebug, + range: defaultChatProbeRange + }; + } + static get observedAttributes() { + return [ + ...TransformableElement.observedAttributes, + ..._ChatProbe2.attributeHandler.getAttributes() + ]; + } + enable() { + } + disable() { + } + getContentBounds() { + if (!this.transformableElementGraphics) { + return null; + } + return OrientedBoundingBox.fromSizeAndMatrixWorld( + new Vect3(this.props.range * 2, this.props.range * 2, this.props.range * 2), + this.transformableElementGraphics.getWorldMatrix() + ); + } + addSideEffectChild(child) { + this.chatProbeAnimatedAttributeHelper.addSideEffectChild(child); + super.addSideEffectChild(child); + } + removeSideEffectChild(child) { + this.chatProbeAnimatedAttributeHelper.removeSideEffectChild(child); + super.removeSideEffectChild(child); + } + parentTransformed() { + var _a, _b; + (_b = (_a = this.registeredScene) == null ? void 0 : _a.updateChatProbe) == null ? void 0 : _b.call(_a, this); + } + isClickable() { + return false; + } + attributeChangedCallback(name, oldValue, newValue) { + super.attributeChangedCallback(name, oldValue, newValue); + _ChatProbe2.attributeHandler.handle(this, name, newValue); + } + trigger(message) { + const userPositionAndRotation = this.getUserPositionAndRotation(); + const elementRelative = getRelativePositionAndRotationRelativeToObject( + userPositionAndRotation, + this + ); + const distance = new Vect3().copy(elementRelative.position).length(); + let withinBounds = true; + this.getAppliedBounds().forEach((bounds) => { + if (!bounds.containsPoint(userPositionAndRotation.position)) { + withinBounds = false; + } + }); + if (withinBounds && distance <= this.props.range) { + this.dispatchEvent( + new CustomEvent(chatProbeChatEventName, { + detail: { + message + } + }) + ); + } + } + connectedCallback() { + super.connectedCallback(); + if (!this.getScene().hasGraphicsAdapter() || this.chatProbeGraphics) { + return; + } + const graphicsAdapter = this.getScene().getGraphicsAdapter(); + this.chatProbeGraphics = graphicsAdapter.getGraphicsAdapterFactory().MMLChatProbeGraphicsInterface(this); + for (const name of _ChatProbe2.observedAttributes) { + const value = this.getAttribute(name); + if (value !== null) { + this.attributeChangedCallback(name, null, value); + } + } + this.applyBounds(); + this.registerChatProbe(); + } + disconnectedCallback() { + var _a; + this.unregisterChatProbe(); + this.chatProbeAnimatedAttributeHelper.reset(); + (_a = this.chatProbeGraphics) == null ? void 0 : _a.dispose(); + this.chatProbeGraphics = null; + super.disconnectedCallback(); + } + registerChatProbe() { + var _a; + const scene2 = this.getScene(); + this.registeredScene = scene2; + (_a = scene2.addChatProbe) == null ? void 0 : _a.call(scene2, this); + } + unregisterChatProbe() { + var _a, _b; + if (this.registeredScene !== null) { + (_b = (_a = this.registeredScene).removeChatProbe) == null ? void 0 : _b.call(_a, this); + this.registeredScene = null; + } + } +}; +_ChatProbe.tagName = "m-chat-probe"; +_ChatProbe.attributeHandler = new AttributeHandler({ + range: (instance, newValue) => { + instance.chatProbeAnimatedAttributeHelper.elementSetAttribute( + "range", + parseFloatAttribute(newValue, defaultChatProbeRange) + ); + }, + debug: (instance, newValue) => { + var _a; + instance.props.debug = parseBoolAttribute(newValue, defaultChatProbeDebug); + (_a = instance.chatProbeGraphics) == null ? void 0 : _a.setDebug(instance.props.debug, instance.props); + } +}); +var ChatProbe = _ChatProbe; +var defaultCubeColor = { r: 1, g: 1, b: 1 }; +var defaultCubeWidth = 1; +var defaultCubeHeight = 1; +var defaultCubeDepth = 1; +var defaultCubeOpacity = 1; +var defaultCubeCastShadows = true; +var _Cube = class _Cube2 extends TransformableElement { + constructor() { + super(); + this.cubeGraphics = null; + this.props = { + width: defaultCubeWidth, + height: defaultCubeHeight, + depth: defaultCubeDepth, + color: defaultCubeColor, + opacity: defaultCubeOpacity, + castShadows: defaultCubeCastShadows + }; + this.cubeAnimatedAttributeHelper = new AnimatedAttributeHelper(this, { + color: [ + 1, + defaultCubeColor, + (newValue) => { + var _a; + this.props.color = newValue; + (_a = this.cubeGraphics) == null ? void 0 : _a.setColor(newValue, this.props); + } + ], + width: [ + 0, + defaultCubeWidth, + (newValue) => { + var _a, _b; + this.props.width = newValue; + (_a = this.cubeGraphics) == null ? void 0 : _a.setWidth(newValue, this.props); + this.applyBounds(); + this.collideableHelper.updateCollider((_b = this.cubeGraphics) == null ? void 0 : _b.getCollisionElement()); + } + ], + height: [ + 0, + defaultCubeHeight, + (newValue) => { + var _a, _b; + this.props.height = newValue; + (_a = this.cubeGraphics) == null ? void 0 : _a.setHeight(newValue, this.props); + this.applyBounds(); + this.collideableHelper.updateCollider((_b = this.cubeGraphics) == null ? void 0 : _b.getCollisionElement()); + } + ], + depth: [ + 0, + defaultCubeDepth, + (newValue) => { + var _a, _b; + this.props.depth = newValue; + (_a = this.cubeGraphics) == null ? void 0 : _a.setDepth(newValue, this.props); + this.applyBounds(); + this.collideableHelper.updateCollider((_b = this.cubeGraphics) == null ? void 0 : _b.getCollisionElement()); + } + ], + opacity: [ + 0, + defaultCubeOpacity, + (newValue) => { + var _a; + this.props.opacity = newValue; + (_a = this.cubeGraphics) == null ? void 0 : _a.setOpacity(newValue, this.props); + } + ] + }); + this.collideableHelper = new CollideableHelper(this); + } + enable() { + this.collideableHelper.enable(); + } + disable() { + this.collideableHelper.disable(); + } + getContentBounds() { + if (!this.transformableElementGraphics) { + return null; + } + return OrientedBoundingBox.fromSizeAndMatrixWorld( + new Vect3(this.props.width, this.props.height, this.props.depth), + this.transformableElementGraphics.getWorldMatrix() + ); + } + static get observedAttributes() { + return [ + ...TransformableElement.observedAttributes, + ..._Cube2.attributeHandler.getAttributes(), + ...CollideableHelper.observedAttributes + ]; + } + addSideEffectChild(child) { + this.cubeAnimatedAttributeHelper.addSideEffectChild(child); + super.addSideEffectChild(child); + } + removeSideEffectChild(child) { + this.cubeAnimatedAttributeHelper.removeSideEffectChild(child); + super.removeSideEffectChild(child); + } + parentTransformed() { + this.collideableHelper.parentTransformed(); + } + isClickable() { + return true; + } + attributeChangedCallback(name, oldValue, newValue) { + if (!this.cubeGraphics) { + return; + } + super.attributeChangedCallback(name, oldValue, newValue); + _Cube2.attributeHandler.handle(this, name, newValue); + this.collideableHelper.handle(name, newValue); + } + connectedCallback() { + var _a; + super.connectedCallback(); + if (!this.getScene().hasGraphicsAdapter() || this.cubeGraphics) { + return; + } + const graphicsAdapter = this.getScene().getGraphicsAdapter(); + this.cubeGraphics = graphicsAdapter.getGraphicsAdapterFactory().MMLCubeGraphicsInterface(this); + for (const name of _Cube2.observedAttributes) { + const value = this.getAttribute(name); + if (value !== null) { + this.attributeChangedCallback(name, null, value); + } + } + this.applyBounds(); + this.collideableHelper.updateCollider((_a = this.cubeGraphics) == null ? void 0 : _a.getCollisionElement()); + } + disconnectedCallback() { + var _a; + this.collideableHelper.removeColliders(); + this.cubeAnimatedAttributeHelper.reset(); + (_a = this.cubeGraphics) == null ? void 0 : _a.dispose(); + this.cubeGraphics = null; + super.disconnectedCallback(); + } +}; +_Cube.tagName = "m-cube"; +_Cube.attributeHandler = new AttributeHandler({ + width: (instance, newValue) => { + instance.cubeAnimatedAttributeHelper.elementSetAttribute( + "width", + parseFloatAttribute(newValue, defaultCubeWidth) + ); + }, + height: (instance, newValue) => { + instance.cubeAnimatedAttributeHelper.elementSetAttribute( + "height", + parseFloatAttribute(newValue, defaultCubeHeight) + ); + }, + depth: (instance, newValue) => { + instance.cubeAnimatedAttributeHelper.elementSetAttribute( + "depth", + parseFloatAttribute(newValue, defaultCubeDepth) + ); + }, + color: (instance, newValue) => { + instance.cubeAnimatedAttributeHelper.elementSetAttribute( + "color", + parseColorAttribute(newValue, defaultCubeColor) + ); + }, + opacity: (instance, newValue) => { + instance.cubeAnimatedAttributeHelper.elementSetAttribute( + "opacity", + parseFloatAttribute(newValue, defaultCubeOpacity) + ); + }, + "cast-shadows": (instance, newValue) => { + var _a; + instance.props.castShadows = parseBoolAttribute(newValue, defaultCubeCastShadows); + (_a = instance.cubeGraphics) == null ? void 0 : _a.setCastShadows(instance.props.castShadows, instance.props); + } +}); +var Cube = _Cube; +var defaultCylinderColor = { r: 1, g: 1, b: 1 }; +var defaultCylinderRadius = 0.5; +var defaultCylinderHeight = 1; +var defaultCylinderOpacity = 1; +var defaultCylinderCastShadows = true; +var _Cylinder = class _Cylinder2 extends TransformableElement { + constructor() { + super(); + this.props = { + radius: defaultCylinderRadius, + height: defaultCylinderHeight, + color: defaultCylinderColor, + opacity: defaultCylinderOpacity, + castShadows: defaultCylinderCastShadows + }; + this.cylinderAnimatedAttributeHelper = new AnimatedAttributeHelper(this, { + color: [ + 1, + defaultCylinderColor, + (newValue) => { + var _a; + this.props.color = newValue; + (_a = this.cylinderGraphics) == null ? void 0 : _a.setColor(newValue, this.props); + } + ], + radius: [ + 0, + defaultCylinderRadius, + (newValue) => { + var _a, _b; + this.props.radius = newValue; + (_a = this.cylinderGraphics) == null ? void 0 : _a.setRadius(newValue, this.props); + this.applyBounds(); + this.collideableHelper.updateCollider((_b = this.cylinderGraphics) == null ? void 0 : _b.getCollisionElement()); + } + ], + height: [ + 0, + defaultCylinderHeight, + (newValue) => { + var _a, _b; + this.props.height = newValue; + (_a = this.cylinderGraphics) == null ? void 0 : _a.setHeight(newValue, this.props); + this.applyBounds(); + this.collideableHelper.updateCollider((_b = this.cylinderGraphics) == null ? void 0 : _b.getCollisionElement()); + } + ], + opacity: [ + 0, + defaultCylinderOpacity, + (newValue) => { + var _a; + this.props.opacity = newValue; + (_a = this.cylinderGraphics) == null ? void 0 : _a.setOpacity(newValue, this.props); + } + ] + }); + this.collideableHelper = new CollideableHelper(this); + } + enable() { + this.collideableHelper.enable(); + } + disable() { + this.collideableHelper.disable(); + } + getContentBounds() { + if (!this.transformableElementGraphics) { + return null; + } + return OrientedBoundingBox.fromSizeAndMatrixWorld( + new Vect3(this.props.radius * 2, this.props.height, this.props.radius * 2), + this.transformableElementGraphics.getWorldMatrix() + ); + } + static get observedAttributes() { + return [ + ...TransformableElement.observedAttributes, + ..._Cylinder2.attributeHandler.getAttributes(), + ...CollideableHelper.observedAttributes + ]; + } + addSideEffectChild(child) { + this.cylinderAnimatedAttributeHelper.addSideEffectChild(child); + super.addSideEffectChild(child); + } + removeSideEffectChild(child) { + this.cylinderAnimatedAttributeHelper.removeSideEffectChild(child); + super.removeSideEffectChild(child); + } + parentTransformed() { + this.collideableHelper.parentTransformed(); + } + isClickable() { + return true; + } + attributeChangedCallback(name, oldValue, newValue) { + if (!this.cylinderGraphics) { + return; + } + super.attributeChangedCallback(name, oldValue, newValue); + _Cylinder2.attributeHandler.handle(this, name, newValue); + this.collideableHelper.handle(name, newValue); + } + connectedCallback() { + var _a; + super.connectedCallback(); + if (!this.getScene().hasGraphicsAdapter() || this.cylinderGraphics) { + return; + } + const graphicsAdapter = this.getScene().getGraphicsAdapter(); + this.cylinderGraphics = graphicsAdapter.getGraphicsAdapterFactory().MMLCylinderGraphicsInterface(this); + for (const name of _Cylinder2.observedAttributes) { + const value = this.getAttribute(name); + if (value !== null) { + this.attributeChangedCallback(name, null, value); + } + } + this.applyBounds(); + this.collideableHelper.updateCollider((_a = this.cylinderGraphics) == null ? void 0 : _a.getCollisionElement()); + } + disconnectedCallback() { + var _a; + this.collideableHelper.removeColliders(); + this.cylinderAnimatedAttributeHelper.reset(); + (_a = this.cylinderGraphics) == null ? void 0 : _a.dispose(); + this.cylinderGraphics = null; + super.disconnectedCallback(); + } +}; +_Cylinder.tagName = "m-cylinder"; +_Cylinder.attributeHandler = new AttributeHandler({ + radius: (instance, newValue) => { + instance.cylinderAnimatedAttributeHelper.elementSetAttribute( + "radius", + parseFloatAttribute(newValue, defaultCylinderRadius) + ); + }, + height: (instance, newValue) => { + instance.cylinderAnimatedAttributeHelper.elementSetAttribute( + "height", + parseFloatAttribute(newValue, defaultCylinderHeight) + ); + }, + color: (instance, newValue) => { + instance.cylinderAnimatedAttributeHelper.elementSetAttribute( + "color", + parseColorAttribute(newValue, defaultCylinderColor) + ); + }, + opacity: (instance, newValue) => { + instance.cylinderAnimatedAttributeHelper.elementSetAttribute( + "opacity", + parseFloatAttribute(newValue, defaultCylinderOpacity) + ); + }, + "cast-shadows": (instance, newValue) => { + var _a; + instance.props.castShadows = parseBoolAttribute(newValue, defaultCylinderCastShadows); + (_a = instance.cylinderGraphics) == null ? void 0 : _a.setCastShadows(instance.props.castShadows, instance.props); + } +}); +var Cylinder = _Cylinder; +function createWrappedScene(scene2, loadingProgressManager) { + return { + addCollider(collider, element) { + if (scene2.addCollider) { + scene2.addCollider(collider, element); + } + }, + updateCollider(collider, element) { + if (scene2.updateCollider) { + scene2.updateCollider(collider, element); + } + }, + removeCollider(collider, element) { + if (scene2.removeCollider) { + scene2.removeCollider(collider, element); + } + }, + addInteraction(interaction) { + if (scene2.addInteraction) { + scene2.addInteraction(interaction); + } + }, + updateInteraction(interaction) { + if (scene2.updateInteraction) { + scene2.updateInteraction(interaction); + } + }, + removeInteraction(interaction) { + if (scene2.removeInteraction) { + scene2.removeInteraction(interaction); + } + }, + addChatProbe(chatProbe) { + if (scene2.addChatProbe) { + scene2.addChatProbe(chatProbe); + } + }, + updateChatProbe(chatProbe) { + if (scene2.updateChatProbe) { + scene2.updateChatProbe(chatProbe); + } + }, + removeChatProbe(chatProbe) { + if (scene2.removeChatProbe) { + scene2.removeChatProbe(chatProbe); + } + }, + hasGraphicsAdapter() { + return scene2.hasGraphicsAdapter(); + }, + getGraphicsAdapter() { + return scene2.getGraphicsAdapter(); + }, + prompt(promptProps, abortSignal, callback) { + scene2.prompt(promptProps, abortSignal, callback); + }, + link(linkProps, abortSignal, windowCallback) { + scene2.link(linkProps, abortSignal, windowCallback); + }, + getRootContainer: () => { + throw new Error("Wrapped scenes do not have a root container"); + }, + getUserPositionAndRotation: () => { + return scene2.getUserPositionAndRotation(); + }, + getLoadingProgressManager: () => { + return loadingProgressManager; + } + }; +} +var noManagerSymbol = Symbol("NoLoadingProgressManagerProvided"); +var LoadingInstanceManager = class { + constructor(type) { + this.type = type; + this.currentlyLoadingProgressManager = null; + } + start(loadingProgressManager, url) { + if (this.currentlyLoadingProgressManager !== null) { + if (this.currentlyLoadingProgressManager === noManagerSymbol && !loadingProgressManager) { + return; + } + if (this.currentlyLoadingProgressManager !== loadingProgressManager) { + throw new Error("Already loading with a different progress manager"); + } + } else { + if (!loadingProgressManager) { + this.currentlyLoadingProgressManager = noManagerSymbol; + } else { + this.currentlyLoadingProgressManager = loadingProgressManager; + this.currentlyLoadingProgressManager.addLoadingAsset(this, url, this.type); + } + } + } + setProgress(ratio) { + if (!this.currentlyLoadingProgressManager) { + throw new Error("Not currently loading - cannot finish"); + } + if (this.currentlyLoadingProgressManager !== noManagerSymbol) { + this.currentlyLoadingProgressManager.updateAssetProgress(this, ratio); + } + } + // The content being loaded is no longer needed, but the instance may still request content load start again + abortIfLoading() { + if (this.currentlyLoadingProgressManager && this.currentlyLoadingProgressManager !== noManagerSymbol) { + this.currentlyLoadingProgressManager.disposeOfLoadingAsset(this); + } + this.currentlyLoadingProgressManager = null; + } + // The instance is no longer needed, and will not request content load start again (content may not be loading) + dispose() { + this.abortIfLoading(); + } + finish() { + if (!this.currentlyLoadingProgressManager) { + throw new Error("Not currently loading - cannot finish"); + } + if (this.currentlyLoadingProgressManager !== noManagerSymbol) { + this.currentlyLoadingProgressManager.completedLoadingAsset(this); + } + } + error(err) { + if (!this.currentlyLoadingProgressManager) { + throw new Error("Not currently loading - cannot error"); + } + if (this.currentlyLoadingProgressManager !== noManagerSymbol) { + if (err) { + this.currentlyLoadingProgressManager.errorLoadingAsset(this, err); + } else { + this.currentlyLoadingProgressManager.errorLoadingAsset(this, new Error("Unknown error")); + } + } + } +}; +var LoadingProgressManager = class { + constructor() { + this.summary = { + totalLoaded: 0, + totalErrored: 0, + totalToLoad: 0 + }; + this.initialLoad = false; + this.loadingAssets = /* @__PURE__ */ new Map(); + this.summaryByType = /* @__PURE__ */ new Map(); + this.loadingDocuments = /* @__PURE__ */ new Map(); + this.onProgressCallbacks = /* @__PURE__ */ new Set(); + } + addProgressCallback(callback) { + this.onProgressCallbacks.add(callback); + } + removeProgressCallback(callback) { + this.onProgressCallbacks.delete(callback); + } + onProgress() { + for (const callback of this.onProgressCallbacks) { + callback(); + } + } + addLoadingAsset(ref, url, type) { + if (this.loadingAssets.has(ref)) { + throw new Error("Asset reference already exists"); + } + const assetRecord = { type, assetUrl: url, progressRatio: 0, loadStatus: false }; + this.loadingAssets.set(ref, assetRecord); + let typeSummary = this.summaryByType.get(type); + if (!typeSummary) { + typeSummary = { totalLoaded: 0, totalToLoad: 0, totalErrored: 0, assets: /* @__PURE__ */ new Map() }; + this.summaryByType.set(type, typeSummary); + } + typeSummary.assets.set(ref, assetRecord); + typeSummary.totalToLoad++; + this.summary.totalToLoad++; + this.onProgress(); + } + setInitialLoad(result) { + if (result instanceof Error) { + this.initialLoad = result; + } else { + this.initialLoad = true; + } + this.onProgress(); + } + disposeOfLoadingAsset(ref) { + const asset = this.loadingAssets.get(ref); + if (asset) { + this.loadingAssets.delete(ref); + const { type, loadStatus } = asset; + const typeSummary = this.summaryByType.get(type); + if (typeSummary) { + typeSummary.assets.delete(ref); + typeSummary.totalToLoad--; + this.summary.totalToLoad--; + if (loadStatus === true) { + typeSummary.totalLoaded--; + this.summary.totalLoaded--; + } else if (loadStatus instanceof Error) { + typeSummary.totalErrored--; + this.summary.totalErrored--; + } + this.onProgress(); + } + } + } + errorLoadingAsset(ref, err) { + const asset = this.loadingAssets.get(ref); + if (asset) { + const { type } = asset; + asset.loadStatus = err; + const typeSummary = this.summaryByType.get(type); + if (typeSummary) { + typeSummary.totalErrored++; + this.summary.totalErrored++; + this.onProgress(); + } + } + } + updateAssetProgress(ref, progressRatio) { + const asset = this.loadingAssets.get(ref); + if (asset) { + asset.progressRatio = progressRatio; + this.onProgress(); + } + } + completedLoadingAsset(ref) { + const asset = this.loadingAssets.get(ref); + if (asset) { + const { type } = asset; + asset.loadStatus = true; + const typeSummary = this.summaryByType.get(type); + if (typeSummary) { + typeSummary.totalLoaded++; + this.summary.totalLoaded++; + this.onProgress(); + } + } + } + addLoadingDocument(ref, documentUrl, progressManager) { + this.loadingDocuments.set(ref, { documentUrl, progressManager }); + this.onProgress(); + } + removeLoadingDocument(ref) { + this.loadingDocuments.delete(ref); + this.onProgress(); + } + updateDocumentProgress(ref) { + const loadingDocument = this.loadingDocuments.get(ref); + if (loadingDocument) { + this.onProgress(); + } + } + toSummary() { + const loadingProgressSummary = { + initialLoad: this.initialLoad, + summary: { ...this.summary }, + summaryByType: {}, + innerDocuments: [] + }; + for (const [key, ofType] of this.summaryByType) { + const ofTypeSummary = { + totalToLoad: ofType.totalToLoad, + totalLoaded: ofType.totalLoaded, + totalErrored: ofType.totalErrored, + assetErrors: [] + }; + if (ofType.totalErrored > 0) { + for (const [, asset] of ofType.assets) { + if (asset.loadStatus instanceof Error) { + ofTypeSummary.assetErrors.push([asset.assetUrl, asset.loadStatus]); + } + } + } + loadingProgressSummary.summaryByType[key] = ofTypeSummary; + } + for (const [, innerDocProgress] of this.loadingDocuments) { + loadingProgressSummary.innerDocuments.push([ + innerDocProgress.documentUrl, + innerDocProgress.progressManager.toSummary() + ]); + } + return loadingProgressSummary; + } + static LoadingProgressSummaryToString(loadingProgressSummary) { + const text = []; + const showDocProgress = (docUrl, docProgress) => { + if (docProgress.initialLoad instanceof Error) { + text.push(`${docUrl}: Error: ${docProgress.initialLoad.message}`); + return; + } else if (!docProgress.initialLoad) { + text.push(`${docUrl}: Loading...`); + return; + } + text.push( + `${docUrl}: (${docProgress.summary.totalLoaded} loaded, ${docProgress.summary.totalErrored} errors) / (${docProgress.summary.totalToLoad} to load) = ${docProgress.summary.totalLoaded + docProgress.summary.totalErrored}/${docProgress.summary.totalToLoad}` + ); + for (const key in docProgress.summaryByType) { + const ofType = docProgress.summaryByType[key]; + text.push( + ` - ${key}: (${ofType.totalLoaded} loaded, ${ofType.totalErrored} errors) / (${ofType.totalToLoad} to load) = ${ofType.totalLoaded + ofType.totalErrored}/${ofType.totalToLoad}` + ); + if (ofType.totalErrored > 0) { + text.push(` - Errors:`); + for (const [assetUrl, error] of ofType.assetErrors) { + text.push(` - ${assetUrl}: ${error.message}`); + } + } + } + for (const [innerDocumentUrl, innerDocProgress] of docProgress.innerDocuments) { + showDocProgress(innerDocumentUrl, innerDocProgress); + } + }; + showDocProgress("root", loadingProgressSummary); + return text.join("\n"); + } + toRatio() { + if (!this.initialLoad) { + return [0, false]; + } + if (this.initialLoad instanceof Error) { + return [1, true]; + } + let totalRatio = 0; + let complete = true; + let numberOfDocuments = this.loadingDocuments.size; + if (this.summary.totalToLoad > 0) { + numberOfDocuments += 1; + const loadedAndErrored = this.summary.totalLoaded + this.summary.totalErrored; + complete = complete && loadedAndErrored === this.summary.totalToLoad; + let directAssetsLoadedRatio = 0; + for (const [, asset] of this.loadingAssets) { + if (asset.loadStatus instanceof Error || asset.loadStatus) { + directAssetsLoadedRatio += 1; + } else { + directAssetsLoadedRatio += asset.progressRatio; + } + } + directAssetsLoadedRatio /= this.summary.totalToLoad; + totalRatio += directAssetsLoadedRatio / numberOfDocuments; + } else if (this.loadingDocuments.size === 0) { + return [1, true]; + } + for (const [, innerDocument] of this.loadingDocuments) { + const [innerDocumentRatio, innerDocumentComplete] = innerDocument.progressManager.toRatio(); + totalRatio += innerDocumentRatio / numberOfDocuments; + complete = complete && innerDocumentComplete; + } + return [totalRatio, complete]; + } +}; +var LoadingProgressBar = class { + constructor(loadingProgressManager) { + this.loadingProgressManager = loadingProgressManager; + this.hasCompleted = false; + this.element = document.createElement("div"); + this.element.addEventListener("click", (event) => { + event.stopPropagation(); + }); + this.element.addEventListener("mousedown", (event) => { + event.stopPropagation(); + }); + this.element.addEventListener("mousemove", (event) => { + event.stopPropagation(); + }); + this.element.addEventListener("mouseup", (event) => { + event.stopPropagation(); + }); + this.progressDebugView = document.createElement("div"); + this.progressDebugView.style.position = "absolute"; + this.progressDebugView.style.backgroundColor = "rgba(128, 128, 128, 0.25)"; + this.progressDebugView.style.top = "20px"; + this.progressDebugView.style.left = "0"; + this.progressDebugView.style.border = "1px solid black"; + this.progressDebugView.style.maxHeight = "calc(100% - 20px)"; + this.progressDebugView.style.maxWidth = "100%"; + this.progressDebugView.style.overflow = "auto"; + this.element.append(this.progressDebugView); + this.debugCheckbox = document.createElement("input"); + this.debugCheckbox.type = "checkbox"; + this.debugCheckbox.addEventListener("change", () => { + this.progressDebugElement.style.display = this.debugCheckbox.checked ? "block" : "none"; + if (this.hasCompleted) { + this.dispose(); + } + }); + this.debugLabel = document.createElement("label"); + this.debugLabel.textContent = "Debug loading"; + this.debugLabel.style.fontFamily = "sans-serif"; + this.debugLabel.style.padding = "5px"; + this.debugLabel.style.display = "inline-block"; + this.debugLabel.style.userSelect = "none"; + this.debugLabel.append(this.debugCheckbox); + this.progressDebugView.append(this.debugLabel); + this.progressDebugElement = document.createElement("pre"); + this.progressDebugElement.style.margin = "0"; + this.progressDebugElement.style.display = this.debugCheckbox.checked ? "block" : "none"; + this.progressDebugView.append(this.progressDebugElement); + this.progressBarHolder = document.createElement("div"); + this.progressBarHolder.style.position = "absolute"; + this.progressBarHolder.style.top = "0"; + this.progressBarHolder.style.left = "0"; + this.progressBarHolder.style.width = "100%"; + this.progressBarHolder.style.backgroundColor = "gray"; + this.progressBarHolder.style.height = "20px"; + this.element.append(this.progressBarHolder); + this.progressBar = document.createElement("div"); + this.progressBar.style.position = "absolute"; + this.progressBar.style.top = "0"; + this.progressBar.style.left = "0"; + this.progressBar.style.width = "0"; + this.progressBar.style.height = "100%"; + this.progressBar.style.backgroundColor = "#0050a4"; + this.progressBarHolder.append(this.progressBar); + this.loadingStatusText = document.createElement("div"); + this.loadingStatusText.style.position = "absolute"; + this.loadingStatusText.style.top = "0"; + this.loadingStatusText.style.left = "0"; + this.loadingStatusText.style.width = "100%"; + this.loadingStatusText.style.height = "100%"; + this.loadingStatusText.style.color = "white"; + this.loadingStatusText.style.textAlign = "center"; + this.loadingStatusText.style.verticalAlign = "middle"; + this.loadingStatusText.style.lineHeight = "20px"; + this.loadingStatusText.style.fontFamily = "sans-serif"; + this.loadingStatusText.textContent = "Loading..."; + this.progressBarHolder.append(this.loadingStatusText); + this.loadingCallback = () => { + const [loadingRatio, completedLoading] = this.loadingProgressManager.toRatio(); + if (completedLoading) { + if (!this.hasCompleted) { + this.hasCompleted = true; + if (!this.debugCheckbox.checked) { + this.dispose(); + } + } + this.loadingStatusText.textContent = "Completed"; + this.progressBar.style.width = "100%"; + } else { + this.loadingStatusText.textContent = `Loading... ${(loadingRatio * 100).toFixed(2)}%`; + this.progressBar.style.width = `${loadingRatio * 100}%`; + } + this.progressDebugElement.textContent = LoadingProgressManager.LoadingProgressSummaryToString( + this.loadingProgressManager.toSummary() + ); + }; + this.loadingProgressManager.addProgressCallback(this.loadingCallback); + } + dispose() { + this.loadingProgressManager.removeProgressCallback(this.loadingCallback); + this.element.remove(); + } +}; +var domParser; +async function fetchRemoteStaticMML(address) { + const response = await fetch(address); + const text = await response.text(); + if (!domParser) { + domParser = new DOMParser(); + } + const remoteDocumentAsHTMLNode = domParser.parseFromString(text, "text/html"); + return DOMSanitizer.sanitise(remoteDocumentAsHTMLNode.body, { + tagPrefix: "m-", + replacementTagPrefix: "x-" + }); +} +var RemoteDocumentWrapper = class { + constructor(address, targetWindow, mmlScene, handleEvent) { + this.remoteDocument = targetWindow.document.createElement( + RemoteDocument.tagName + ); + this.remoteDocument.addEventListener(consumeEventEventName, (wrappedEvent) => { + const { originalEvent, element } = wrappedEvent.detail; + handleEvent(element, originalEvent); + }); + this.remoteDocument.init(mmlScene, address); + } + setDocumentTime(documentTime) { + this.remoteDocument.getDocumentTimeManager().setDocumentTime(documentTime); + } + overrideDocumentTime(documentTime) { + this.remoteDocument.getDocumentTimeManager().overrideDocumentTime(documentTime); + } +}; +var StaticHTMLFrameInstance = class { + constructor(targetElement, src, scene2) { + var _a, _b; + this.targetForWrapper = targetElement; + this.src = src; + this.scene = scene2; + const windowTarget = targetElement.ownerDocument.defaultView; + this.loadingProgressManager = new LoadingProgressManager(); + this.loadingProgressManager.addProgressCallback(() => { + var _a2, _b2; + (_b2 = (_a2 = scene2.getLoadingProgressManager) == null ? void 0 : _a2.call(scene2)) == null ? void 0 : _b2.updateDocumentProgress(this); + }); + const address = this.targetForWrapper.contentSrcToContentAddress(this.src); + (_b = (_a = scene2.getLoadingProgressManager) == null ? void 0 : _a.call(scene2)) == null ? void 0 : _b.addLoadingDocument(this, address, this.loadingProgressManager); + const wrappedScene = createWrappedScene(this.scene, this.loadingProgressManager); + this.remoteDocumentWrapper = new RemoteDocumentWrapper( + address, + windowTarget, + wrappedScene, + () => { + } + ); + this.targetForWrapper.append(this.remoteDocumentWrapper.remoteDocument); + fetchRemoteStaticMML(address).then((remoteDocumentBody) => { + this.remoteDocumentWrapper.remoteDocument.append(remoteDocumentBody); + this.loadingProgressManager.setInitialLoad(true); + }).catch((err) => { + this.loadingProgressManager.setInitialLoad(err); + }); + } + dispose() { + this.targetForWrapper.removeChild(this.remoteDocumentWrapper.remoteDocument); + this.loadingProgressManager.removeLoadingDocument(this); + } +}; +var WebSocketFrameInstance = class { + constructor(targetElement, src, scene2) { + var _a, _b; + this.targetForWrapper = targetElement; + this.src = src; + this.scene = scene2; + const windowTarget = targetElement.ownerDocument.defaultView; + let overriddenHandler = null; + const eventHandler = (element, event) => { + if (!overriddenHandler) { + throw new Error("overriddenHandler not set"); + } + overriddenHandler(element, event); + }; + this.loadingProgressManager = new LoadingProgressManager(); + this.loadingProgressManager.addProgressCallback(() => { + var _a2, _b2; + (_b2 = (_a2 = scene2.getLoadingProgressManager) == null ? void 0 : _a2.call(scene2)) == null ? void 0 : _b2.updateDocumentProgress(this); + }); + const websocketAddress = this.srcToAddress(this.src); + (_b = (_a = scene2.getLoadingProgressManager) == null ? void 0 : _a.call(scene2)) == null ? void 0 : _b.addLoadingDocument(this, websocketAddress, this.loadingProgressManager); + const wrappedScene = createWrappedScene(this.scene, this.loadingProgressManager); + this.remoteDocumentWrapper = new RemoteDocumentWrapper( + websocketAddress, + windowTarget, + wrappedScene, + () => { + } + ); + this.targetForWrapper.append(this.remoteDocumentWrapper.remoteDocument); + this.remoteDocumentWrapper.remoteDocument.addEventListener( + consumeEventEventName, + (wrappedEvent) => { + const { originalEvent, element } = wrappedEvent.detail; + eventHandler(element, originalEvent); + } + ); + this.domWebsocket = new NetworkedDOMWebsocket( + websocketAddress, + NetworkedDOMWebsocket.createWebSocket, + this.remoteDocumentWrapper.remoteDocument, + (time) => { + this.remoteDocumentWrapper.remoteDocument.getDocumentTimeManager().setDocumentTime(time); + }, + (status) => { + if (status === NetworkedDOMWebsocketStatus.Reconnecting) { + this.remoteDocumentWrapper.remoteDocument.showError(true); + this.loadingProgressManager.setInitialLoad(new Error("Failed to connect")); + } else if (status === NetworkedDOMWebsocketStatus.Connected) { + this.remoteDocumentWrapper.remoteDocument.showError(false); + this.loadingProgressManager.setInitialLoad(true); + } else { + this.remoteDocumentWrapper.remoteDocument.showError(false); + } + }, + { + tagPrefix: "m-" + } + ); + overriddenHandler = (element, event) => { + this.domWebsocket.handleEvent(element, event); + }; + } + srcToAddress(src) { + const insecurePrefix = "ws:///"; + const securePrefix = "wss:///"; + if (src.startsWith(insecurePrefix)) { + return `ws://${this.getDocumentHost()}/${src.substring(insecurePrefix.length)}`; + } else if (src.startsWith(securePrefix)) { + return `wss://${this.getDocumentHost()}/${src.substring(securePrefix.length)}`; + } else { + return src; + } + } + getDocumentHost() { + const remoteDocument = this.targetForWrapper.getInitiatedRemoteDocument(); + if (remoteDocument) { + const remoteDocumentAddress = remoteDocument.getDocumentAddress(); + if (remoteDocumentAddress) { + const url = new URL(remoteDocumentAddress); + return url.host; + } + } + return window.location.host; + } + dispose() { + var _a, _b, _c; + this.domWebsocket.stop(); + this.targetForWrapper.removeChild(this.remoteDocumentWrapper.remoteDocument); + (_c = (_b = (_a = this.scene).getLoadingProgressManager) == null ? void 0 : _b.call(_a)) == null ? void 0 : _c.removeLoadingDocument(this); + } +}; +var defaultUnloadRange = 1; +var defaultFrameDebug = false; +var _Frame = class _Frame2 extends TransformableElement { + constructor() { + super(); + this.frameContentsInstance = null; + this.isActivelyLoaded = false; + this.timer = null; + this.props = { + src: null, + loadRange: null, + unloadRange: defaultUnloadRange, + debug: defaultFrameDebug, + minX: null, + maxX: null, + minY: null, + maxY: null, + minZ: null, + maxZ: null + }; + } + enable() { + } + disable() { + } + boundsUpdated() { + if (!this.transformableElementGraphics) { + return; + } + const boxBounds = this.getDefinedBoxBounds(); + if (boxBounds) { + const [minX, maxX, minY, maxY, minZ, maxZ] = boxBounds; + const obb = OrientedBoundingBox.fromSizeMatrixWorldAndCenter( + new Vect3(maxX - minX, maxY - minY, maxZ - minZ), + this.transformableElementGraphics.getWorldMatrix(), + new Vect3((maxX + minX) / 2, (maxY + minY) / 2, (maxZ + minZ) / 2) + ); + this.addOrUpdateParentBound(this, obb); + } else { + this.removeParentBound(this); + } + } + shouldBeLoaded() { + if (!this.isConnected) { + return false; + } + if (this.props.loadRange === null) { + return true; + } + const userPositionAndRotation = this.getUserPositionAndRotation(); + const elementRelative = getRelativePositionAndRotationRelativeToObject( + userPositionAndRotation, + this + ); + let boxBounds = this.getDefinedBoxBounds(); + if (!boxBounds) { + boxBounds = [0, 0, 0, 0, 0, 0]; + } + const [minX, maxX, minY, maxY, minZ, maxZ] = boxBounds; + if (elementRelative.position.x >= minX - this.props.loadRange && elementRelative.position.x <= maxX + this.props.loadRange && elementRelative.position.y >= minY - this.props.loadRange && elementRelative.position.y <= maxY + this.props.loadRange && elementRelative.position.z >= minZ - this.props.loadRange && elementRelative.position.z <= maxZ + this.props.loadRange) { + return true; + } + if (elementRelative.position.x >= minX - this.props.loadRange - this.props.unloadRange && elementRelative.position.x <= maxX + this.props.loadRange + this.props.unloadRange && elementRelative.position.y >= minY - this.props.loadRange - this.props.unloadRange && elementRelative.position.y <= maxY + this.props.loadRange + this.props.unloadRange && elementRelative.position.z >= minZ - this.props.loadRange - this.props.unloadRange && elementRelative.position.z <= maxZ + this.props.loadRange + this.props.unloadRange) { + return this.isActivelyLoaded; + } + } + syncLoadState() { + const shouldBeLoaded = this.shouldBeLoaded(); + if (shouldBeLoaded && !this.isActivelyLoaded) { + if (this.props.src) { + this.isActivelyLoaded = true; + this.createFrameContentsInstance(this.props.src); + } + } else if (!shouldBeLoaded && this.isActivelyLoaded) { + this.isActivelyLoaded = false; + this.disposeInstance(); + } + } + static get observedAttributes() { + return [...TransformableElement.observedAttributes, ..._Frame2.attributeHandler.getAttributes()]; + } + getContentBounds() { + return null; + } + parentTransformed() { + this.boundsUpdated(); + } + isClickable() { + return true; + } + startEmitting() { + if (this.timer) { + clearInterval(this.timer); + } + this.timer = setInterval(() => { + this.syncLoadState(); + }, 100); + } + createFrameContentsInstance(src) { + if (this.frameContentsInstance) { + if (this.frameContentsInstance.src !== src) { + console.error("Instance already existed with a different src"); + this.disposeInstance(); + } else { + return; + } + } + if (src.startsWith("ws://") || src.startsWith("wss://")) { + this.frameContentsInstance = new WebSocketFrameInstance(this, src, this.getScene()); + } else { + this.frameContentsInstance = new StaticHTMLFrameInstance(this, src, this.getScene()); + } + } + getDefinedBoxBounds() { + if (this.props.minX !== null || this.props.maxX !== null || this.props.minY !== null || this.props.maxY !== null || this.props.minZ !== null || this.props.maxZ !== null) { + const minX = this.props.minX ?? this.props.maxX ?? 0; + let maxX = this.props.maxX ?? this.props.minX ?? 0; + const minY = this.props.minY ?? this.props.maxY ?? 0; + let maxY = this.props.maxY ?? this.props.minY ?? 0; + const minZ = this.props.minZ ?? this.props.maxZ ?? 0; + let maxZ = this.props.maxZ ?? this.props.minZ ?? 0; + if (minX > maxX) { + maxX = minX; + } + if (minY > maxY) { + maxY = minY; + } + if (minZ > maxZ) { + maxZ = minZ; + } + return [minX, maxX, minY, maxY, minZ, maxZ]; + } + return null; + } + disposeInstance() { + if (this.frameContentsInstance !== null) { + this.frameContentsInstance.dispose(); + this.frameContentsInstance = null; + this.isActivelyLoaded = false; + } + } + attributeChangedCallback(name, oldValue, newValue) { + if (!this.frameGraphics) { + return; + } + super.attributeChangedCallback(name, oldValue, newValue); + _Frame2.attributeHandler.handle(this, name, newValue); + } + connectedCallback() { + super.connectedCallback(); + if (!this.getScene().hasGraphicsAdapter() || this.frameGraphics) { + return; + } + const graphicsAdapter = this.getScene().getGraphicsAdapter(); + this.startEmitting(); + this.syncLoadState(); + this.frameGraphics = graphicsAdapter.getGraphicsAdapterFactory().MMLFrameGraphicsInterface(this); + for (const name of _Frame2.observedAttributes) { + const value = this.getAttribute(name); + if (value !== null) { + this.attributeChangedCallback(name, null, value); + } + } + this.applyBounds(); + } + disconnectedCallback() { + var _a; + (_a = this.frameGraphics) == null ? void 0 : _a.dispose(); + this.frameGraphics = null; + if (this.timer) { + clearInterval(this.timer); + } + this.disposeInstance(); + super.disconnectedCallback(); + } +}; +_Frame.tagName = "m-frame"; +_Frame.attributeHandler = new AttributeHandler({ + src: (instance, newValue) => { + var _a; + instance.props.src = newValue; + if (instance.frameContentsInstance) { + instance.disposeInstance(); + } + instance.syncLoadState(); + (_a = instance.frameGraphics) == null ? void 0 : _a.setSrc(instance.props.src, instance.props); + }, + "load-range": (instance, newValue) => { + var _a; + instance.props.loadRange = parseFloatAttribute(newValue, null); + instance.syncLoadState(); + (_a = instance.frameGraphics) == null ? void 0 : _a.setLoadRange(instance.props.loadRange, instance.props); + }, + "unload-range": (instance, newValue) => { + var _a; + instance.props.unloadRange = parseFloatAttribute(newValue, defaultUnloadRange); + instance.syncLoadState(); + (_a = instance.frameGraphics) == null ? void 0 : _a.setUnloadRange(instance.props.unloadRange, instance.props); + }, + debug: (instance, newValue) => { + var _a; + instance.props.debug = parseBoolAttribute(newValue, defaultFrameDebug); + (_a = instance.frameGraphics) == null ? void 0 : _a.setDebug(instance.props.debug, instance.props); + }, + "min-x": (instance, newValue) => { + var _a; + instance.props.minX = parseFloatAttribute(newValue, null); + instance.boundsUpdated(); + (_a = instance.frameGraphics) == null ? void 0 : _a.setMinX(instance.props.minX, instance.props); + }, + "max-x": (instance, newValue) => { + var _a; + instance.props.maxX = parseFloatAttribute(newValue, null); + instance.boundsUpdated(); + (_a = instance.frameGraphics) == null ? void 0 : _a.setMaxX(instance.props.maxX, instance.props); + }, + "min-y": (instance, newValue) => { + var _a; + instance.props.minY = parseFloatAttribute(newValue, null); + instance.boundsUpdated(); + (_a = instance.frameGraphics) == null ? void 0 : _a.setMinY(instance.props.minY, instance.props); + }, + "max-y": (instance, newValue) => { + var _a; + instance.props.maxY = parseFloatAttribute(newValue, null); + instance.boundsUpdated(); + (_a = instance.frameGraphics) == null ? void 0 : _a.setMaxY(instance.props.maxY, instance.props); + }, + "min-z": (instance, newValue) => { + var _a; + instance.props.minZ = parseFloatAttribute(newValue, null); + instance.boundsUpdated(); + (_a = instance.frameGraphics) == null ? void 0 : _a.setMinZ(instance.props.minZ, instance.props); + }, + "max-z": (instance, newValue) => { + var _a; + instance.props.maxZ = parseFloatAttribute(newValue, null); + instance.boundsUpdated(); + (_a = instance.frameGraphics) == null ? void 0 : _a.setMaxZ(instance.props.maxZ, instance.props); + } +}); +var Frame = _Frame; +var _Group = class _Group2 extends TransformableElement { + static get observedAttributes() { + return [...TransformableElement.observedAttributes]; + } + enable() { + } + disable() { + } + constructor() { + super(); + } + getContentBounds() { + return null; + } + parentTransformed() { + } + isClickable() { + return true; + } + attributeChangedCallback(name, oldValue, newValue) { + if (!this.transformableElementGraphics) { + return; + } + super.attributeChangedCallback(name, oldValue, newValue); + } + connectedCallback() { + super.connectedCallback(); + if (!this.getScene().hasGraphicsAdapter()) { + return; + } + for (const name of _Group2.observedAttributes) { + const value = this.getAttribute(name); + if (value !== null) { + this.attributeChangedCallback(name, null, value); + } + } + } +}; +_Group.tagName = "m-group"; +var Group = _Group; +var defaultImageSrc = null; +var defaultImageWidth = null; +var defaultImageHeight = null; +var defaultImageOpacity = 1; +var defaultImageCastShadows = true; +var defaultImageEmissive = 0; +var _Image = class _Image2 extends TransformableElement { + constructor() { + super(); + this.props = { + src: defaultImageSrc, + width: defaultImageWidth, + height: defaultImageHeight, + opacity: defaultImageOpacity, + castShadows: defaultImageCastShadows, + emissive: defaultImageEmissive + }; + this.imageAnimatedAttributeHelper = new AnimatedAttributeHelper(this, { + width: [ + 0, + defaultImageWidth, + (newValue) => { + var _a; + this.props.width = newValue; + (_a = this.imageGraphics) == null ? void 0 : _a.setWidth(newValue, this.props); + } + ], + height: [ + 0, + defaultImageHeight, + (newValue) => { + var _a; + this.props.height = newValue; + (_a = this.imageGraphics) == null ? void 0 : _a.setHeight(newValue, this.props); + } + ], + opacity: [ + 0, + defaultImageOpacity, + (newValue) => { + var _a; + this.props.opacity = newValue; + (_a = this.imageGraphics) == null ? void 0 : _a.setOpacity(newValue, this.props); + } + ], + emissive: [ + 0, + defaultImageEmissive, + (newValue) => { + var _a; + this.props.emissive = newValue; + (_a = this.imageGraphics) == null ? void 0 : _a.setEmissive(newValue, this.props); + } + ] + }); + this.collideableHelper = new CollideableHelper(this); + } + enable() { + this.collideableHelper.enable(); + } + disable() { + this.collideableHelper.disable(); + } + static get observedAttributes() { + return [ + ...TransformableElement.observedAttributes, + ..._Image2.attributeHandler.getAttributes(), + ...CollideableHelper.observedAttributes + ]; + } + getContentBounds() { + var _a; + if (!this.transformableElementGraphics) { + return null; + } + const { width, height } = ((_a = this.imageGraphics) == null ? void 0 : _a.getWidthAndHeight()) || { width: 0, height: 0 }; + return OrientedBoundingBox.fromSizeAndMatrixWorld( + new Vect3(width, height, 0), + this.transformableElementGraphics.getWorldMatrix() + ); + } + addSideEffectChild(child) { + this.imageAnimatedAttributeHelper.addSideEffectChild(child); + super.addSideEffectChild(child); + } + removeSideEffectChild(child) { + this.imageAnimatedAttributeHelper.removeSideEffectChild(child); + super.removeSideEffectChild(child); + } + parentTransformed() { + this.collideableHelper.parentTransformed(); + } + isClickable() { + return true; + } + attributeChangedCallback(name, oldValue, newValue) { + if (!this.imageGraphics) { + return; + } + super.attributeChangedCallback(name, oldValue, newValue); + _Image2.attributeHandler.handle(this, name, newValue); + this.collideableHelper.handle(name, newValue); + } + connectedCallback() { + var _a; + super.connectedCallback(); + if (!this.getScene().hasGraphicsAdapter() || this.imageGraphics) { + return; + } + const graphicsAdapter = this.getScene().getGraphicsAdapter(); + this.imageGraphics = graphicsAdapter.getGraphicsAdapterFactory().MMLImageGraphicsInterface(this, () => { + var _a2; + this.applyBounds(); + this.collideableHelper.updateCollider((_a2 = this.imageGraphics) == null ? void 0 : _a2.getCollisionElement()); + }); + for (const name of _Image2.observedAttributes) { + const value = this.getAttribute(name); + if (value !== null) { + this.attributeChangedCallback(name, null, value); + } + } + this.collideableHelper.updateCollider((_a = this.imageGraphics) == null ? void 0 : _a.getCollisionElement()); + } + disconnectedCallback() { + var _a; + this.imageAnimatedAttributeHelper.reset(); + (_a = this.imageGraphics) == null ? void 0 : _a.dispose(); + this.imageGraphics = null; + super.disconnectedCallback(); + this.collideableHelper.removeColliders(); + } +}; +_Image.tagName = "m-image"; +_Image.attributeHandler = new AttributeHandler({ + width: (instance, newValue) => { + instance.imageAnimatedAttributeHelper.elementSetAttribute( + "width", + parseFloatAttribute(newValue, defaultImageWidth) + ); + }, + height: (instance, newValue) => { + instance.imageAnimatedAttributeHelper.elementSetAttribute( + "height", + parseFloatAttribute(newValue, defaultImageHeight) + ); + }, + src: (instance, newValue) => { + var _a; + instance.props.src = newValue; + (_a = instance.imageGraphics) == null ? void 0 : _a.setSrc(newValue, instance.props); + }, + opacity: (instance, newValue) => { + instance.imageAnimatedAttributeHelper.elementSetAttribute( + "opacity", + parseFloatAttribute(newValue, defaultImageOpacity) + ); + }, + emissive: (instance, newValue) => { + instance.imageAnimatedAttributeHelper.elementSetAttribute( + "emissive", + parseFloatAttribute(newValue, defaultImageEmissive) + ); + }, + "cast-shadows": (instance, newValue) => { + var _a; + instance.props.castShadows = parseBoolAttribute(newValue, defaultImageCastShadows); + (_a = instance.imageGraphics) == null ? void 0 : _a.setCastShadows(instance.props.castShadows, instance.props); + } +}); +var Image = _Image; +var defaultInteractionRange = 5; +var defaultInteractionInFocus = true; +var defaultInteractionLineOfSight = false; +var defaultInteractionPriority = 1; +var defaultInteractionPrompt = null; +var defaultInteractionDebug = false; +var _Interaction = class _Interaction2 extends TransformableElement { + constructor() { + super(); + this.interactionAnimatedAttributeHelper = new AnimatedAttributeHelper(this, { + range: [ + 0, + defaultInteractionRange, + (newValue) => { + var _a; + this.props.range = newValue; + this.applyBounds(); + (_a = this.interactionGraphics) == null ? void 0 : _a.setRange(newValue, this.props); + } + ] + }); + this.props = { + range: defaultInteractionRange, + inFocus: defaultInteractionInFocus, + lineOfSight: defaultInteractionLineOfSight, + priority: defaultInteractionPriority, + prompt: defaultInteractionPrompt, + debug: defaultInteractionDebug + }; + this.registeredScene = null; + } + static get observedAttributes() { + return [ + ...TransformableElement.observedAttributes, + ..._Interaction2.attributeHandler.getAttributes() + ]; + } + enable() { + } + disable() { + } + getContentBounds() { + if (!this.transformableElementGraphics) { + return null; + } + return OrientedBoundingBox.fromSizeAndMatrixWorld( + new Vect3(this.props.range * 2, this.props.range * 2, this.props.range * 2), + this.transformableElementGraphics.getWorldMatrix() + ); + } + addSideEffectChild(child) { + this.interactionAnimatedAttributeHelper.addSideEffectChild(child); + super.addSideEffectChild(child); + } + removeSideEffectChild(child) { + this.interactionAnimatedAttributeHelper.removeSideEffectChild(child); + super.removeSideEffectChild(child); + } + parentTransformed() { + var _a, _b; + (_b = (_a = this.registeredScene) == null ? void 0 : _a.updateInteraction) == null ? void 0 : _b.call(_a, this); + } + isClickable() { + return false; + } + connectedCallback() { + super.connectedCallback(); + if (!this.getScene().hasGraphicsAdapter() || this.interactionGraphics) { + return; + } + const graphicsAdapter = this.getScene().getGraphicsAdapter(); + this.interactionGraphics = graphicsAdapter.getGraphicsAdapterFactory().MMLInteractionGraphicsInterface(this); + for (const name of _Interaction2.observedAttributes) { + const value = this.getAttribute(name); + if (value !== null) { + this.attributeChangedCallback(name, null, value); + } + } + this.registerInteraction(); + } + disconnectedCallback() { + var _a; + this.unregisterInteraction(); + this.interactionAnimatedAttributeHelper.reset(); + (_a = this.interactionGraphics) == null ? void 0 : _a.dispose(); + this.interactionGraphics = null; + super.disconnectedCallback(); + } + attributeChangedCallback(name, oldValue, newValue) { + var _a, _b; + super.attributeChangedCallback(name, oldValue, newValue); + if (_Interaction2.attributeHandler.handle(this, name, newValue)) { + if (this.registeredScene !== null) { + (_b = (_a = this.registeredScene).updateInteraction) == null ? void 0 : _b.call(_a, this); + } + } + } + trigger() { + this.dispatchEvent(new CustomEvent("interact", { detail: {} })); + } + registerInteraction() { + var _a; + const scene2 = this.getScene(); + this.registeredScene = scene2; + (_a = scene2.addInteraction) == null ? void 0 : _a.call(scene2, this); + } + unregisterInteraction() { + var _a, _b; + if (this.registeredScene !== null) { + (_b = (_a = this.registeredScene).removeInteraction) == null ? void 0 : _b.call(_a, this); + this.registeredScene = null; + } + } +}; +_Interaction.tagName = "m-interaction"; +_Interaction.attributeHandler = new AttributeHandler({ + range: (instance, newValue) => { + instance.interactionAnimatedAttributeHelper.elementSetAttribute( + "range", + parseFloatAttribute(newValue, defaultInteractionRange) + ); + }, + "in-focus": (instance, newValue) => { + var _a; + instance.props.inFocus = parseBoolAttribute(newValue, defaultInteractionInFocus); + (_a = instance.interactionGraphics) == null ? void 0 : _a.setInFocus(instance.props.inFocus, instance.props); + }, + "line-of-sight": (instance, newValue) => { + var _a; + instance.props.lineOfSight = parseBoolAttribute(newValue, defaultInteractionLineOfSight); + (_a = instance.interactionGraphics) == null ? void 0 : _a.setLineOfSight(instance.props.lineOfSight, instance.props); + }, + priority: (instance, newValue) => { + var _a; + instance.props.priority = parseFloatAttribute(newValue, defaultInteractionPriority); + (_a = instance.interactionGraphics) == null ? void 0 : _a.setPriority(instance.props.priority, instance.props); + }, + prompt: (instance, newValue) => { + var _a; + instance.props.prompt = newValue; + (_a = instance.interactionGraphics) == null ? void 0 : _a.setPrompt(instance.props.prompt, instance.props); + }, + debug: (instance, newValue) => { + var _a; + instance.props.debug = parseBoolAttribute(newValue, defaultInteractionDebug); + (_a = instance.interactionGraphics) == null ? void 0 : _a.setDebug(instance.props.debug, instance.props); + } +}); +var Interaction = _Interaction; +var MLabelAlignment = /* @__PURE__ */ ((MLabelAlignment2) => { + MLabelAlignment2["left"] = "left"; + MLabelAlignment2["center"] = "center"; + MLabelAlignment2["right"] = "right"; + return MLabelAlignment2; +})(MLabelAlignment || {}); +var defaultLabelColor = { r: 1, g: 1, b: 1 }; +var defaultFontColor = { r: 0, g: 0, b: 0 }; +var defaultLabelAlignment = "left"; +var defaultLabelFontSize = 24; +var defaultLabelPadding = 8; +var defaultLabelWidth = 1; +var defaultLabelHeight = 1; +var defaultLabelCastShadows = true; +var defaultEmissive = 0; +var _Label = class _Label2 extends TransformableElement { + constructor() { + super(); + this.collideableHelper = new CollideableHelper(this); + this.labelAnimatedAttributeHelper = new AnimatedAttributeHelper(this, { + color: [ + 1, + defaultLabelColor, + (newValue) => { + var _a; + this.props.color = newValue; + (_a = this.labelGraphics) == null ? void 0 : _a.setColor(this.props.color, this.props); + } + ], + "font-color": [ + 1, + defaultFontColor, + (newValue) => { + var _a; + this.props.fontColor = newValue; + (_a = this.labelGraphics) == null ? void 0 : _a.setFontColor(this.props.fontColor, this.props); + } + ], + width: [ + 0, + defaultLabelWidth, + (newValue) => { + var _a; + this.props.width = newValue; + (_a = this.labelGraphics) == null ? void 0 : _a.setWidth(this.props.width, this.props); + } + ], + height: [ + 0, + defaultLabelHeight, + (newValue) => { + var _a; + this.props.height = newValue; + (_a = this.labelGraphics) == null ? void 0 : _a.setHeight(this.props.height, this.props); + } + ], + padding: [ + 0, + defaultLabelPadding, + (newValue) => { + var _a; + this.props.padding = newValue; + (_a = this.labelGraphics) == null ? void 0 : _a.setPadding(this.props.padding, this.props); + } + ], + "font-size": [ + 0, + defaultLabelFontSize, + (newValue) => { + var _a; + this.props.fontSize = newValue; + (_a = this.labelGraphics) == null ? void 0 : _a.setFontSize(this.props.fontSize, this.props); + } + ] + }); + this.props = { + content: "", + alignment: defaultLabelAlignment, + width: defaultLabelWidth, + height: defaultLabelHeight, + fontSize: defaultLabelFontSize, + padding: defaultLabelPadding, + color: defaultLabelColor, + fontColor: defaultFontColor, + castShadows: defaultLabelCastShadows, + emissive: defaultEmissive + }; + } + enable() { + } + disable() { + } + static get observedAttributes() { + return [...TransformableElement.observedAttributes, ..._Label2.attributeHandler.getAttributes()]; + } + getContentBounds() { + if (!this.transformableElementGraphics) { + return null; + } + return OrientedBoundingBox.fromSizeAndMatrixWorld( + new Vect3(this.props.width, this.props.height, 0), + this.transformableElementGraphics.getWorldMatrix() + ); + } + addSideEffectChild(child) { + this.labelAnimatedAttributeHelper.addSideEffectChild(child); + super.addSideEffectChild(child); + } + removeSideEffectChild(child) { + this.labelAnimatedAttributeHelper.removeSideEffectChild(child); + super.removeSideEffectChild(child); + } + parentTransformed() { + } + isClickable() { + return true; + } + attributeChangedCallback(name, oldValue, newValue) { + if (!this.labelGraphics) { + return; + } + super.attributeChangedCallback(name, oldValue, newValue); + _Label2.attributeHandler.handle(this, name, newValue); + this.collideableHelper.handle(name, newValue); + } + connectedCallback() { + var _a; + super.connectedCallback(); + if (!this.getScene().hasGraphicsAdapter() || this.labelGraphics) { + return; + } + const graphicsAdapter = this.getScene().getGraphicsAdapter(); + this.labelGraphics = graphicsAdapter.getGraphicsAdapterFactory().MMLLabelGraphicsInterface(this); + for (const name of _Label2.observedAttributes) { + const value = this.getAttribute(name); + if (value !== null) { + this.attributeChangedCallback(name, null, value); + } + } + this.applyBounds(); + this.collideableHelper.updateCollider((_a = this.labelGraphics) == null ? void 0 : _a.getCollisionElement()); + } + disconnectedCallback() { + var _a; + this.collideableHelper.removeColliders(); + this.labelAnimatedAttributeHelper.reset(); + (_a = this.labelGraphics) == null ? void 0 : _a.dispose(); + this.labelGraphics = null; + super.disconnectedCallback(); + } +}; +_Label.tagName = "m-label"; +_Label.attributeHandler = new AttributeHandler({ + width: (instance, newValue) => { + instance.labelAnimatedAttributeHelper.elementSetAttribute( + "width", + parseFloatAttribute(newValue, defaultLabelWidth) + ); + }, + height: (instance, newValue) => { + instance.labelAnimatedAttributeHelper.elementSetAttribute( + "height", + parseFloatAttribute(newValue, defaultLabelHeight) + ); + }, + color: (instance, newValue) => { + instance.labelAnimatedAttributeHelper.elementSetAttribute( + "color", + parseColorAttribute(newValue, defaultLabelColor) + ); + }, + "font-color": (instance, newValue) => { + instance.labelAnimatedAttributeHelper.elementSetAttribute( + "font-color", + parseColorAttribute(newValue, defaultFontColor) + ); + }, + "font-size": (instance, newValue) => { + instance.labelAnimatedAttributeHelper.elementSetAttribute( + "font-size", + parseFloatAttribute(newValue, defaultLabelFontSize) + ); + }, + padding: (instance, newValue) => { + instance.labelAnimatedAttributeHelper.elementSetAttribute( + "padding", + parseFloatAttribute(newValue, defaultLabelPadding) + ); + }, + content: (instance, newValue) => { + var _a; + instance.props.content = newValue || ""; + (_a = instance.labelGraphics) == null ? void 0 : _a.setContent(instance.props.content, instance.props); + }, + alignment: (instance, newValue) => { + var _a; + instance.props.alignment = parseEnumAttribute( + newValue, + MLabelAlignment, + defaultLabelAlignment + ); + (_a = instance.labelGraphics) == null ? void 0 : _a.setAlignment(instance.props.alignment, instance.props); + }, + "cast-shadows": (instance, newValue) => { + var _a; + instance.props.castShadows = parseBoolAttribute(newValue, defaultLabelCastShadows); + (_a = instance.labelGraphics) == null ? void 0 : _a.setCastShadows(instance.props.castShadows, instance.props); + }, + emissive: (instance, newValue) => { + var _a; + instance.props.emissive = parseFloatAttribute(newValue, defaultEmissive); + (_a = instance.labelGraphics) == null ? void 0 : _a.setEmissive(instance.props.emissive, instance.props); + } +}); +var Label = _Label; +var LightTypes = /* @__PURE__ */ ((LightTypes2) => { + LightTypes2["spotlight"] = "spotlight"; + LightTypes2["point"] = "point"; + return LightTypes2; +})(LightTypes || {}); +var defaultLightColor = { r: 1, g: 1, b: 1 }; +var defaultLightIntensity = 1; +var defaultLightAngle = 45; +var defaultLightEnabled = true; +var defaultLightDebug = false; +var defaultLightDistance = null; +var defaultLightCastShadows = true; +var defaultLightType = "spotlight"; +var _Light = class _Light2 extends TransformableElement { + constructor() { + super(); + this.lightAnimatedAttributeHelper = new AnimatedAttributeHelper(this, { + color: [ + 1, + defaultLightColor, + (newValue) => { + var _a; + this.props.color = newValue; + (_a = this.lightGraphics) == null ? void 0 : _a.setColor(newValue, this.props); + } + ], + intensity: [ + 0, + defaultLightIntensity, + (newValue) => { + var _a; + this.props.intensity = newValue; + (_a = this.lightGraphics) == null ? void 0 : _a.setIntensity(newValue, this.props); + } + ], + angle: [ + 0, + defaultLightAngle, + (newValue) => { + var _a; + this.props.angleDeg = newValue; + (_a = this.lightGraphics) == null ? void 0 : _a.setAngle(newValue, this.props); + } + ], + distance: [ + 0, + defaultLightDistance, + (newValue) => { + var _a; + this.props.distance = newValue; + (_a = this.lightGraphics) == null ? void 0 : _a.setDistance(newValue, this.props); + } + ] + }); + this.props = { + color: defaultLightColor, + intensity: defaultLightIntensity, + enabled: defaultLightEnabled, + angleDeg: defaultLightAngle, + distance: defaultLightDistance, + castShadows: defaultLightCastShadows, + debug: defaultLightDebug, + type: defaultLightType + }; + } + static get observedAttributes() { + return [...TransformableElement.observedAttributes, ..._Light2.attributeHandler.getAttributes()]; + } + enable() { + } + disable() { + } + getContentBounds() { + if (!this.transformableElementGraphics) { + return null; + } + return OrientedBoundingBox.fromMatrixWorld(this.transformableElementGraphics.getWorldMatrix()); + } + addSideEffectChild(child) { + if (child instanceof AttributeAnimation) { + const attr = child.getAnimatedAttributeName(); + if (attr) { + this.lightAnimatedAttributeHelper.addAnimation(child, attr); + } + } + super.addSideEffectChild(child); + } + removeSideEffectChild(child) { + if (child instanceof AttributeAnimation) { + const attr = child.getAnimatedAttributeName(); + if (attr) { + this.lightAnimatedAttributeHelper.removeAnimation(child, attr); + } + } + super.removeSideEffectChild(child); + } + parentTransformed() { + } + isClickable() { + return false; + } + attributeChangedCallback(name, oldValue, newValue) { + if (!this.lightGraphics) { + return; + } + super.attributeChangedCallback(name, oldValue, newValue); + _Light2.attributeHandler.handle(this, name, newValue); + } + connectedCallback() { + super.connectedCallback(); + if (!this.getScene().hasGraphicsAdapter() || this.lightGraphics) { + return; + } + const graphicsAdapter = this.getScene().getGraphicsAdapter(); + this.lightGraphics = graphicsAdapter.getGraphicsAdapterFactory().MMLLightGraphicsInterface(this); + for (const name of _Light2.observedAttributes) { + const value = this.getAttribute(name); + if (value !== null) { + this.attributeChangedCallback(name, null, value); + } + } + } + disconnectedCallback() { + var _a; + this.lightAnimatedAttributeHelper.reset(); + (_a = this.lightGraphics) == null ? void 0 : _a.dispose(); + this.lightGraphics = null; + super.disconnectedCallback(); + } +}; +_Light.tagName = "m-light"; +_Light.attributeHandler = new AttributeHandler({ + color: (instance, newValue) => { + instance.lightAnimatedAttributeHelper.elementSetAttribute( + "color", + parseColorAttribute(newValue, defaultLightColor) + ); + }, + intensity: (instance, newValue) => { + instance.lightAnimatedAttributeHelper.elementSetAttribute( + "intensity", + parseFloatAttribute(newValue, defaultLightIntensity) + ); + }, + angle: (instance, newValue) => { + instance.lightAnimatedAttributeHelper.elementSetAttribute( + "angle", + parseFloatAttribute(newValue, defaultLightAngle) + ); + }, + distance: (instance, newValue) => { + instance.lightAnimatedAttributeHelper.elementSetAttribute( + "distance", + parseFloatAttribute(newValue, defaultLightDistance) + ); + }, + enabled: (instance, newValue) => { + var _a; + instance.props.enabled = parseBoolAttribute(newValue, defaultLightEnabled); + (_a = instance.lightGraphics) == null ? void 0 : _a.setEnabled(instance.props.enabled, instance.props); + }, + "cast-shadows": (instance, newValue) => { + var _a; + instance.props.castShadows = parseBoolAttribute(newValue, defaultLightCastShadows); + (_a = instance.lightGraphics) == null ? void 0 : _a.setCastShadows(instance.props.castShadows, instance.props); + }, + debug: (instance, newValue) => { + var _a; + instance.props.debug = parseBoolAttribute(newValue, defaultLightDebug); + (_a = instance.lightGraphics) == null ? void 0 : _a.setDebug(instance.props.debug, instance.props); + }, + type: (instance, newValue) => { + var _a; + instance.props.type = parseEnumAttribute(newValue, LightTypes, defaultLightType); + (_a = instance.lightGraphics) == null ? void 0 : _a.setType(instance.props.type, instance.props); + } +}); +var Light = _Light; +var _Link = class _Link2 extends TransformableElement { + constructor() { + super(); + this.abortController = null; + this.props = { + href: null, + target: null + }; + this.addEventListener("click", () => { + if (this.props.href) { + const href = this.props.href; + if (!_Link2.isAcceptableHref(href)) { + console.warn( + `Refusing to navigate to ${href} as it does not meet the acceptable href criteria.` + ); + return; + } + if (this.abortController) { + this.abortController.abort(); + this.abortController = null; + } + this.abortController = new AbortController(); + this.getScene().link( + { href, target: this.props.target ?? void 0, popup: false }, + this.abortController.signal, + () => { + this.abortController = null; + } + ); + } + }); + } + static get observedAttributes() { + return [...TransformableElement.observedAttributes, ..._Link2.attributeHandler.getAttributes()]; + } + /* + This is a simple check to ensure that the href is an acceptable URL and is + not a "javascript:alert('foo')" URL or something other than a navigable URL. + */ + static isAcceptableHref(href) { + const url = new URL(href, window.location.href); + if (url.protocol === "http:" || url.protocol === "https:") { + return true; + } + return false; + } + parentTransformed() { + } + isClickable() { + return false; + } + attributeChangedCallback(name, oldValue, newValue) { + if (!this.transformableElementGraphics) { + return; + } + super.attributeChangedCallback(name, oldValue, newValue); + _Link2.attributeHandler.handle(this, name, newValue); + } + disable() { + } + enable() { + } + getContentBounds() { + return null; + } + connectedCallback() { + super.connectedCallback(); + if (!this.getScene().hasGraphicsAdapter() || this.linkGraphics) { + return; + } + const graphicsAdapter = this.getScene().getGraphicsAdapter(); + this.linkGraphics = graphicsAdapter.getGraphicsAdapterFactory().MMLLinkGraphicsInterface(this); + for (const name of _Link2.observedAttributes) { + const value = this.getAttribute(name); + if (value !== null) { + this.attributeChangedCallback(name, null, value); + } + } + } + disconnectedCallback() { + var _a; + (_a = this.linkGraphics) == null ? void 0 : _a.dispose(); + this.linkGraphics = null; + super.disconnectedCallback(); + } +}; +_Link.tagName = "m-link"; +_Link.attributeHandler = new AttributeHandler({ + href: (instance, newValue) => { + instance.props.href = newValue !== null ? newValue : null; + }, + target: (instance, newValue) => { + instance.props.target = newValue !== null ? newValue : null; + } +}); +var Link = _Link; +var defaultPlaneColor = { r: 1, g: 1, b: 1 }; +var defaultPlaneWidth = 1; +var defaultPlaneHeight = 1; +var defaultPlaneOpacity = 1; +var defaultPlaneCastShadows = true; +var _Plane = class _Plane2 extends TransformableElement { + constructor() { + super(); + this.props = { + width: defaultPlaneWidth, + height: defaultPlaneHeight, + color: defaultPlaneColor, + opacity: defaultPlaneOpacity, + castShadows: defaultPlaneCastShadows + }; + this.planeAnimatedAttributeHelper = new AnimatedAttributeHelper(this, { + color: [ + 1, + defaultPlaneColor, + (newValue) => { + var _a; + this.props.color = newValue; + (_a = this.planeGraphics) == null ? void 0 : _a.setColor(newValue, this.props); + } + ], + width: [ + 0, + defaultPlaneWidth, + (newValue) => { + var _a, _b; + this.props.width = newValue; + (_a = this.planeGraphics) == null ? void 0 : _a.setWidth(newValue, this.props); + this.applyBounds(); + this.collideableHelper.updateCollider((_b = this.planeGraphics) == null ? void 0 : _b.getCollisionElement()); + } + ], + height: [ + 0, + defaultPlaneHeight, + (newValue) => { + var _a, _b; + this.props.height = newValue; + (_a = this.planeGraphics) == null ? void 0 : _a.setHeight(newValue, this.props); + this.applyBounds(); + this.collideableHelper.updateCollider((_b = this.planeGraphics) == null ? void 0 : _b.getCollisionElement()); + } + ], + opacity: [ + 0, + defaultPlaneOpacity, + (newValue) => { + var _a; + this.props.opacity = newValue; + (_a = this.planeGraphics) == null ? void 0 : _a.setOpacity(newValue, this.props); + } + ] + }); + this.collideableHelper = new CollideableHelper(this); + } + enable() { + this.collideableHelper.enable(); + } + disable() { + this.collideableHelper.disable(); + } + getContentBounds() { + if (!this.transformableElementGraphics) { + return null; + } + return OrientedBoundingBox.fromSizeAndMatrixWorld( + new Vect3(this.props.width, this.props.height, 0), + this.transformableElementGraphics.getWorldMatrix() + ); + } + static get observedAttributes() { + return [ + ...TransformableElement.observedAttributes, + ..._Plane2.attributeHandler.getAttributes(), + ...CollideableHelper.observedAttributes + ]; + } + addSideEffectChild(child) { + this.planeAnimatedAttributeHelper.addSideEffectChild(child); + super.addSideEffectChild(child); + } + removeSideEffectChild(child) { + this.planeAnimatedAttributeHelper.removeSideEffectChild(child); + super.removeSideEffectChild(child); + } + parentTransformed() { + this.collideableHelper.parentTransformed(); + } + isClickable() { + return true; + } + attributeChangedCallback(name, oldValue, newValue) { + if (!this.planeGraphics) { + return; + } + super.attributeChangedCallback(name, oldValue, newValue); + _Plane2.attributeHandler.handle(this, name, newValue); + this.collideableHelper.handle(name, newValue); + } + connectedCallback() { + var _a; + super.connectedCallback(); + if (!this.getScene().hasGraphicsAdapter() || this.planeGraphics) { + return; + } + const graphicsAdapter = this.getScene().getGraphicsAdapter(); + this.planeGraphics = graphicsAdapter.getGraphicsAdapterFactory().MMLPlaneGraphicsInterface(this); + for (const name of _Plane2.observedAttributes) { + const value = this.getAttribute(name); + if (value !== null) { + this.attributeChangedCallback(name, null, value); + } + } + this.applyBounds(); + this.collideableHelper.updateCollider((_a = this.planeGraphics) == null ? void 0 : _a.getCollisionElement()); + } + disconnectedCallback() { + var _a; + this.collideableHelper.removeColliders(); + this.planeAnimatedAttributeHelper.reset(); + (_a = this.planeGraphics) == null ? void 0 : _a.dispose(); + this.planeGraphics = null; + super.disconnectedCallback(); + } +}; +_Plane.tagName = "m-plane"; +_Plane.attributeHandler = new AttributeHandler({ + width: (instance, newValue) => { + instance.planeAnimatedAttributeHelper.elementSetAttribute( + "width", + parseFloatAttribute(newValue, defaultPlaneWidth) + ); + }, + height: (instance, newValue) => { + instance.planeAnimatedAttributeHelper.elementSetAttribute( + "height", + parseFloatAttribute(newValue, defaultPlaneHeight) + ); + }, + color: (instance, newValue) => { + instance.planeAnimatedAttributeHelper.elementSetAttribute( + "color", + parseColorAttribute(newValue, defaultPlaneColor) + ); + }, + opacity: (instance, newValue) => { + instance.planeAnimatedAttributeHelper.elementSetAttribute( + "opacity", + parseFloatAttribute(newValue, defaultPlaneOpacity) + ); + }, + "cast-shadows": (instance, newValue) => { + var _a; + instance.props.castShadows = parseBoolAttribute(newValue, defaultPlaneCastShadows); + (_a = instance.planeGraphics) == null ? void 0 : _a.setCastShadows(instance.props.castShadows, instance.props); + } +}); +var Plane = _Plane; +var defaultPositionProbeRange = 10; +var defaultPositionProbeInterval = 1e3; +var defaultPositionProbeMinimumInterval = 100; +var defaultPositionProbeDebug = false; +var positionProbeEnterEventName = "positionenter"; +var positionProbePositionMoveEventName = "positionmove"; +var positionProbeLeaveEventName = "positionleave"; +var _PositionProbe = class _PositionProbe2 extends TransformableElement { + constructor() { + super(); + this.positionProbeAnimatedAttributeHelper = new AnimatedAttributeHelper(this, { + range: [ + 0, + defaultPositionProbeRange, + (newValue) => { + var _a; + this.props.range = newValue; + (_a = this.positionProbeGraphics) == null ? void 0 : _a.setRange(newValue, this.props); + this.applyBounds(); + } + ] + }); + this.props = { + intervalMs: defaultPositionProbeInterval, + debug: defaultPositionProbeDebug, + range: defaultPositionProbeRange + }; + this.timer = null; + this.currentlyInRange = false; + } + static get observedAttributes() { + return [ + ...TransformableElement.observedAttributes, + ..._PositionProbe2.attributeHandler.getAttributes() + ]; + } + enable() { + } + disable() { + } + parentTransformed() { + } + getContentBounds() { + if (!this.transformableElementGraphics) { + return null; + } + return OrientedBoundingBox.fromSizeAndMatrixWorld( + new Vect3(this.props.range * 2, this.props.range * 2, this.props.range * 2), + this.transformableElementGraphics.getWorldMatrix() + ); + } + addSideEffectChild(child) { + this.positionProbeAnimatedAttributeHelper.addSideEffectChild(child); + super.addSideEffectChild(child); + } + removeSideEffectChild(child) { + this.positionProbeAnimatedAttributeHelper.removeSideEffectChild(child); + super.removeSideEffectChild(child); + } + isClickable() { + return false; + } + attributeChangedCallback(name, oldValue, newValue) { + if (!this.positionProbeGraphics) { + return; + } + super.attributeChangedCallback(name, oldValue, newValue); + _PositionProbe2.attributeHandler.handle(this, name, newValue); + } + emitPosition() { + const userPositionAndRotation = this.getUserPositionAndRotation(); + const elementRelative = getRelativePositionAndRotationRelativeToObject( + userPositionAndRotation, + this + ); + const distance = new Vect3().copy(elementRelative.position).length(); + let withinBounds = true; + this.getAppliedBounds().forEach((bounds) => { + if (!bounds.containsPoint(userPositionAndRotation.position)) { + withinBounds = false; + } + }); + if (withinBounds && distance <= this.props.range) { + const elementRelativePositionAndRotation = { + position: elementRelative.position, + rotation: { + x: elementRelative.rotation.x, + y: elementRelative.rotation.y, + z: elementRelative.rotation.z + } + }; + let documentRoot = null; + const remoteDocument = this.getInitiatedRemoteDocument(); + if (remoteDocument) { + documentRoot = remoteDocument; + } + const documentRelative = documentRoot !== null ? getRelativePositionAndRotationRelativeToObject(userPositionAndRotation, documentRoot) : userPositionAndRotation; + const documentRelativePositionAndRotation = { + position: documentRelative.position, + rotation: { + x: documentRelative.rotation.x, + y: documentRelative.rotation.y, + z: documentRelative.rotation.z + } + }; + if (!this.currentlyInRange) { + this.currentlyInRange = true; + this.dispatchEvent( + new CustomEvent(positionProbeEnterEventName, { + detail: { + elementRelative: elementRelativePositionAndRotation, + documentRelative: documentRelativePositionAndRotation + } + }) + ); + } else { + this.dispatchEvent( + new CustomEvent(positionProbePositionMoveEventName, { + detail: { + elementRelative: elementRelativePositionAndRotation, + documentRelative: documentRelativePositionAndRotation + } + }) + ); + } + } else { + if (this.currentlyInRange) { + this.currentlyInRange = false; + this.dispatchEvent(new CustomEvent(positionProbeLeaveEventName, {})); + } + } + } + connectedCallback() { + super.connectedCallback(); + if (!this.getScene().hasGraphicsAdapter() || this.positionProbeGraphics) { + return; + } + const graphicsAdapter = this.getScene().getGraphicsAdapter(); + this.positionProbeGraphics = graphicsAdapter.getGraphicsAdapterFactory().MMLPositionProbeGraphicsInterface(this); + for (const name of _PositionProbe2.observedAttributes) { + const value = this.getAttribute(name); + if (value !== null) { + this.attributeChangedCallback(name, null, value); + } + } + this.applyBounds(); + this.startEmitting(); + } + disconnectedCallback() { + var _a; + if (this.timer) { + clearInterval(this.timer); + } + this.positionProbeAnimatedAttributeHelper.reset(); + (_a = this.positionProbeGraphics) == null ? void 0 : _a.dispose(); + this.positionProbeGraphics = null; + super.disconnectedCallback(); + } + startEmitting() { + if (this.timer) { + clearInterval(this.timer); + } + this.timer = setInterval(() => { + this.emitPosition(); + }, this.props.intervalMs); + } +}; +_PositionProbe.tagName = "m-position-probe"; +_PositionProbe.attributeHandler = new AttributeHandler({ + range: (instance, newValue) => { + instance.positionProbeAnimatedAttributeHelper.elementSetAttribute( + "range", + parseFloatAttribute(newValue, defaultPositionProbeRange) + ); + }, + interval: (instance, newValue) => { + instance.props.intervalMs = Math.max( + defaultPositionProbeMinimumInterval, + parseFloatAttribute(newValue, defaultPositionProbeInterval) + ); + instance.startEmitting(); + }, + debug: (instance, newValue) => { + var _a; + instance.props.debug = parseBoolAttribute(newValue, defaultPositionProbeDebug); + (_a = instance.positionProbeGraphics) == null ? void 0 : _a.setDebug(instance.props.debug, instance.props); + } +}); +var PositionProbe = _PositionProbe; +var _Prompt = class _Prompt2 extends TransformableElement { + constructor() { + super(); + this.abortController = null; + this.props = { + message: void 0, + placeholder: void 0, + prefill: void 0 + }; + this.addEventListener("click", () => { + this.trigger(); + }); + } + enable() { + } + disable() { + } + static get observedAttributes() { + return [...TransformableElement.observedAttributes, ..._Prompt2.attributeHandler.getAttributes()]; + } + getContentBounds() { + return null; + } + parentTransformed() { + } + isClickable() { + return false; + } + attributeChangedCallback(name, oldValue, newValue) { + if (!this.promptGraphics) { + return; + } + super.attributeChangedCallback(name, oldValue, newValue); + _Prompt2.attributeHandler.handle(this, name, newValue); + } + trigger() { + if (this.abortController) { + this.abortController.abort(); + this.abortController = null; + } + this.abortController = new AbortController(); + this.getScene().prompt(this.props, this.abortController.signal, (result) => { + if (!this.isConnected) { + return; + } + if (result !== null) { + this.dispatchEvent( + new CustomEvent("prompt", { bubbles: false, detail: { value: result } }) + ); + } + }); + } + connectedCallback() { + super.connectedCallback(); + if (!this.getScene().hasGraphicsAdapter() || this.promptGraphics) { + return; + } + const graphicsAdapter = this.getScene().getGraphicsAdapter(); + this.promptGraphics = graphicsAdapter.getGraphicsAdapterFactory().MMLPromptGraphicsInterface(this); + for (const name of _Prompt2.observedAttributes) { + const value = this.getAttribute(name); + if (value !== null) { + this.attributeChangedCallback(name, null, value); + } + } + } + disconnectedCallback() { + var _a; + (_a = this.promptGraphics) == null ? void 0 : _a.dispose(); + this.promptGraphics = null; + super.disconnectedCallback(); + } +}; +_Prompt.tagName = "m-prompt"; +_Prompt.attributeHandler = new AttributeHandler({ + message: (instance, newValue) => { + var _a; + instance.props.message = newValue !== null ? newValue : void 0; + (_a = instance.promptGraphics) == null ? void 0 : _a.setMessage(instance.props.message, instance.props); + }, + placeholder: (instance, newValue) => { + var _a; + instance.props.placeholder = newValue !== null ? newValue : void 0; + (_a = instance.promptGraphics) == null ? void 0 : _a.setPlaceholder(instance.props.placeholder, instance.props); + }, + prefill: (instance, newValue) => { + var _a; + instance.props.prefill = newValue !== null ? newValue : void 0; + (_a = instance.promptGraphics) == null ? void 0 : _a.setPrefill(instance.props.prefill, instance.props); + } +}); +var Prompt = _Prompt; +var MMLDocumentTimeManager = class { + constructor() { + this.relativeDocumentStartTime = 0; + this.overridenDocumentTime = null; + this.documentTimeListeners = /* @__PURE__ */ new Set(); + this.documentTimeTickListeners = /* @__PURE__ */ new Set(); + } + tick() { + const documentTime = this.getDocumentTime(); + for (const cb of this.documentTimeTickListeners) { + cb(documentTime); + } + } + getDocumentTime() { + if (this.overridenDocumentTime !== null) { + return this.overridenDocumentTime; + } + return document.timeline.currentTime - this.relativeDocumentStartTime; + } + getWindowTime() { + if (this.overridenDocumentTime !== null) { + return this.overridenDocumentTime; + } + return document.timeline.currentTime; + } + addDocumentTimeListenerCallback(cb) { + this.documentTimeListeners.add(cb); + } + removeDocumentTimeListenerCallback(cb) { + this.documentTimeListeners.delete(cb); + } + addDocumentTimeTickListenerCallback(cb) { + this.documentTimeTickListeners.add(cb); + } + removeDocumentTimeTickListenerCallback(cb) { + this.documentTimeTickListeners.delete(cb); + } + setDocumentTime(documentTime) { + if (this.overridenDocumentTime !== null) { + return; + } + this.relativeDocumentStartTime = document.timeline.currentTime - documentTime; + for (const cb of this.documentTimeListeners) { + cb(documentTime); + } + } + // This method is used for testing to allow overriding the document time + overrideDocumentTime(documentTime) { + this.overridenDocumentTime = documentTime; + for (const cb of this.documentTimeListeners) { + cb(documentTime); + } + } +}; +var RemoteDocument = class extends MElement { + constructor() { + super(); + this.scene = null; + this.documentAddress = null; + this.animationFrameCallback = null; + this.documentTimeManager = new MMLDocumentTimeManager(); + this.addEventListener(consumeEventEventName, (wrappedEvent) => { + wrappedEvent.stopPropagation(); + }); + } + showError(showError) { + var _a; + (_a = this.remoteDocumentGraphics) == null ? void 0 : _a.showError(showError); + } + enable() { + } + disable() { + } + getContentBounds() { + return null; + } + parentTransformed() { + } + isClickable() { + return false; + } + getDocumentTimeManager() { + return this.documentTimeManager; + } + connectedCallback() { + this.style.display = "none"; + if (!this.isConnected) { + return; + } + super.connectedCallback(); + if (!this.getScene().hasGraphicsAdapter() || this.remoteDocumentGraphics) { + return; + } + const graphicsAdapter = this.getScene().getGraphicsAdapter(); + this.remoteDocumentGraphics = graphicsAdapter.getGraphicsAdapterFactory().RemoteDocumentGraphicsInterface(this); + this.animationFrameCallback = window.requestAnimationFrame(() => { + this.tick(); + }); + } + disconnectedCallback() { + var _a; + if (this.animationFrameCallback) { + window.cancelAnimationFrame(this.animationFrameCallback); + this.animationFrameCallback = null; + } + (_a = this.remoteDocumentGraphics) == null ? void 0 : _a.dispose(); + this.remoteDocumentGraphics = null; + super.disconnectedCallback(); + } + dispatchEvent(event) { + if (this.contains(event.detail.element)) { + return HTMLElement.prototype.dispatchEvent.call(this, event); + } else { + return false; + } + } + init(mmlScene, documentAddress) { + if (this.scene) { + throw new Error("Scene already set"); + } + this.scene = mmlScene; + this.documentAddress = documentAddress; + this.connectedCallback(); + } + getDocumentAddress() { + return this.documentAddress; + } + getMMLScene() { + if (!this.scene) { + return null; + } + return this.scene; + } + tick() { + this.documentTimeManager.tick(); + this.animationFrameCallback = window.requestAnimationFrame(() => { + this.tick(); + }); + } +}; +RemoteDocument.tagName = "m-remote-document"; +var defaultSphereColor = { r: 1, g: 1, b: 1 }; +var defaultSphereRadius = 0.5; +var defaultSphereOpacity = 1; +var defaultSphereCastShadows = true; +var _Sphere = class _Sphere2 extends TransformableElement { + constructor() { + super(); + this.props = { + radius: defaultSphereRadius, + color: defaultSphereColor, + opacity: defaultSphereOpacity, + castShadows: defaultSphereCastShadows + }; + this.sphereAnimatedAttributeHelper = new AnimatedAttributeHelper(this, { + color: [ + 1, + defaultSphereColor, + (newValue) => { + var _a; + this.props.color = newValue; + (_a = this.sphereGraphics) == null ? void 0 : _a.setColor(newValue, this.props); + } + ], + radius: [ + 0, + defaultSphereRadius, + (newValue) => { + var _a, _b; + this.props.radius = newValue; + (_a = this.sphereGraphics) == null ? void 0 : _a.setRadius(newValue, this.props); + this.applyBounds(); + this.collideableHelper.updateCollider((_b = this.sphereGraphics) == null ? void 0 : _b.getCollisionElement()); + } + ], + opacity: [ + 0, + defaultSphereOpacity, + (newValue) => { + var _a; + this.props.opacity = newValue; + (_a = this.sphereGraphics) == null ? void 0 : _a.setOpacity(newValue, this.props); + } + ] + }); + this.collideableHelper = new CollideableHelper(this); + } + enable() { + this.collideableHelper.enable(); + } + disable() { + this.collideableHelper.disable(); + } + getContentBounds() { + if (!this.transformableElementGraphics) { + return null; + } + return OrientedBoundingBox.fromSizeAndMatrixWorld( + new Vect3(this.props.radius * 2, this.props.radius * 2, this.props.radius * 2), + this.transformableElementGraphics.getWorldMatrix() + ); + } + static get observedAttributes() { + return [ + ...TransformableElement.observedAttributes, + ..._Sphere2.attributeHandler.getAttributes(), + ...CollideableHelper.observedAttributes + ]; + } + addSideEffectChild(child) { + this.sphereAnimatedAttributeHelper.addSideEffectChild(child); + super.addSideEffectChild(child); + } + removeSideEffectChild(child) { + this.sphereAnimatedAttributeHelper.removeSideEffectChild(child); + super.removeSideEffectChild(child); + } + parentTransformed() { + this.collideableHelper.parentTransformed(); + } + isClickable() { + return true; + } + attributeChangedCallback(name, oldValue, newValue) { + if (!this.sphereGraphics) { + return; + } + super.attributeChangedCallback(name, oldValue, newValue); + _Sphere2.attributeHandler.handle(this, name, newValue); + this.collideableHelper.handle(name, newValue); + } + connectedCallback() { + super.connectedCallback(); + if (!this.getScene().hasGraphicsAdapter() || this.sphereGraphics) { + return; + } + const graphicsAdapter = this.getScene().getGraphicsAdapter(); + this.sphereGraphics = graphicsAdapter.getGraphicsAdapterFactory().MMLSphereGraphicsInterface(this); + for (const name of _Sphere2.observedAttributes) { + const value = this.getAttribute(name); + if (value !== null) { + this.attributeChangedCallback(name, null, value); + } + } + this.applyBounds(); + this.collideableHelper.updateCollider(this.sphereGraphics.getCollisionElement()); + } + disconnectedCallback() { + var _a; + this.collideableHelper.removeColliders(); + this.sphereAnimatedAttributeHelper.reset(); + (_a = this.sphereGraphics) == null ? void 0 : _a.dispose(); + this.sphereGraphics = null; + super.disconnectedCallback(); + } +}; +_Sphere.tagName = "m-sphere"; +_Sphere.attributeHandler = new AttributeHandler({ + radius: (instance, newValue) => { + instance.sphereAnimatedAttributeHelper.elementSetAttribute( + "radius", + parseFloatAttribute(newValue, defaultSphereRadius) + ); + }, + color: (instance, newValue) => { + instance.sphereAnimatedAttributeHelper.elementSetAttribute( + "color", + parseColorAttribute(newValue, defaultSphereColor) + ); + }, + opacity: (instance, newValue) => { + instance.sphereAnimatedAttributeHelper.elementSetAttribute( + "opacity", + parseFloatAttribute(newValue, defaultSphereOpacity) + ); + }, + "cast-shadows": (instance, newValue) => { + var _a; + instance.props.castShadows = parseBoolAttribute(newValue, defaultSphereCastShadows); + (_a = instance.sphereGraphics) == null ? void 0 : _a.setCastShadows(instance.props.castShadows, instance.props); + } +}); +var Sphere = _Sphere; +var defaultVideoWidth = null; +var defaultVideoHeight = null; +var defaultVideoVolume = 1; +var defaultVideoLoop = true; +var defaultVideoEnabled = true; +var defaultVideoStartTime = 0; +var defaultVideoPauseTime = null; +var defaultVideoSrc = null; +var defaultVideoCastShadows = true; +var defaultVideoEmissive = 0; +var _Video = class _Video2 extends TransformableElement { + constructor() { + super(); + this.videoAnimatedAttributeHelper = new AnimatedAttributeHelper(this, { + width: [ + 0, + defaultVideoWidth, + (newValue) => { + var _a; + this.props.width = newValue; + (_a = this.videoGraphics) == null ? void 0 : _a.setWidth(newValue, this.props); + } + ], + height: [ + 0, + defaultVideoHeight, + (newValue) => { + var _a; + this.props.height = newValue; + (_a = this.videoGraphics) == null ? void 0 : _a.setHeight(newValue, this.props); + } + ], + emissive: [ + 0, + defaultVideoEmissive, + (newValue) => { + var _a; + this.props.emissive = newValue; + (_a = this.videoGraphics) == null ? void 0 : _a.setEmissive(newValue, this.props); + } + ] + }); + this.collideableHelper = new CollideableHelper(this); + this.props = { + startTime: defaultVideoStartTime, + pauseTime: defaultVideoPauseTime, + src: defaultVideoSrc, + loop: defaultVideoLoop, + enabled: defaultVideoEnabled, + volume: defaultVideoVolume, + width: defaultVideoWidth, + height: defaultVideoHeight, + castShadows: defaultVideoCastShadows, + emissive: defaultVideoEmissive + }; + } + static get observedAttributes() { + return [ + ...TransformableElement.observedAttributes, + ..._Video2.attributeHandler.getAttributes(), + ...CollideableHelper.observedAttributes + ]; + } + enable() { + var _a; + (_a = this.videoGraphics) == null ? void 0 : _a.syncVideoTime(); + } + disable() { + var _a; + (_a = this.videoGraphics) == null ? void 0 : _a.syncVideoTime(); + } + getContentBounds() { + if (!this.videoGraphics || !this.transformableElementGraphics) { + return null; + } + const { width, height } = this.videoGraphics.getWidthAndHeight() || { width: 0, height: 0 }; + return OrientedBoundingBox.fromSizeAndMatrixWorld( + new Vect3(width, height, 0), + this.transformableElementGraphics.getWorldMatrix() + ); + } + addSideEffectChild(child) { + this.videoAnimatedAttributeHelper.addSideEffectChild(child); + super.addSideEffectChild(child); + } + removeSideEffectChild(child) { + this.videoAnimatedAttributeHelper.removeSideEffectChild(child); + super.removeSideEffectChild(child); + } + parentTransformed() { + this.collideableHelper.parentTransformed(); + } + isClickable() { + return true; + } + attributeChangedCallback(name, oldValue, newValue) { + if (!this.videoGraphics) { + return; + } + super.attributeChangedCallback(name, oldValue, newValue); + _Video2.attributeHandler.handle(this, name, newValue); + this.collideableHelper.handle(name, newValue); + } + documentTimeChanged() { + var _a; + (_a = this.videoGraphics) == null ? void 0 : _a.syncVideoTime(); + } + connectedCallback() { + var _a; + super.connectedCallback(); + if (!this.getScene().hasGraphicsAdapter() || this.videoGraphics) { + return; + } + const graphicsAdapter = this.getScene().getGraphicsAdapter(); + this.videoGraphics = graphicsAdapter.getGraphicsAdapterFactory().MMLVideoGraphicsInterface(this, () => { + var _a2; + this.applyBounds(); + this.collideableHelper.updateCollider((_a2 = this.videoGraphics) == null ? void 0 : _a2.getCollisionElement()); + }); + this.documentTimeListener = this.addDocumentTimeListener(() => { + this.documentTimeChanged(); + }); + for (const name of _Video2.observedAttributes) { + const value = this.getAttribute(name); + if (value !== null) { + this.attributeChangedCallback(name, null, value); + } + } + this.collideableHelper.updateCollider((_a = this.videoGraphics) == null ? void 0 : _a.getCollisionElement()); + } + disconnectedCallback() { + var _a; + this.videoAnimatedAttributeHelper.reset(); + (_a = this.videoGraphics) == null ? void 0 : _a.dispose(); + this.videoGraphics = null; + this.documentTimeListener.remove(); + this.collideableHelper.removeColliders(); + super.disconnectedCallback(); + } +}; +_Video.tagName = "m-video"; +_Video.attributeHandler = new AttributeHandler({ + width: (instance, newValue) => { + instance.videoAnimatedAttributeHelper.elementSetAttribute( + "width", + parseFloatAttribute(newValue, defaultVideoWidth) + ); + }, + height: (instance, newValue) => { + instance.videoAnimatedAttributeHelper.elementSetAttribute( + "height", + parseFloatAttribute(newValue, defaultVideoHeight) + ); + }, + enabled: (instance, newValue) => { + var _a; + instance.props.enabled = parseBoolAttribute(newValue, defaultVideoEnabled); + (_a = instance.videoGraphics) == null ? void 0 : _a.setEnabled(instance.props.enabled, instance.props); + }, + loop: (instance, newValue) => { + var _a; + instance.props.loop = parseBoolAttribute(newValue, defaultVideoLoop); + (_a = instance.videoGraphics) == null ? void 0 : _a.setLoop(instance.props.loop, instance.props); + }, + "start-time": (instance, newValue) => { + var _a; + instance.props.startTime = parseFloatAttribute(newValue, defaultVideoStartTime); + (_a = instance.videoGraphics) == null ? void 0 : _a.setStartTime(instance.props.startTime, instance.props); + }, + "pause-time": (instance, newValue) => { + var _a; + instance.props.pauseTime = parseFloatAttribute(newValue, defaultVideoPauseTime); + (_a = instance.videoGraphics) == null ? void 0 : _a.setPauseTime(instance.props.pauseTime, instance.props); + }, + src: (instance, newValue) => { + var _a; + instance.props.src = newValue; + (_a = instance.videoGraphics) == null ? void 0 : _a.setSrc(newValue, instance.props); + }, + volume: (instance, newValue) => { + var _a; + instance.props.volume = parseFloatAttribute(newValue, defaultVideoVolume); + (_a = instance.videoGraphics) == null ? void 0 : _a.setVolume(instance.props.volume, instance.props); + }, + "cast-shadows": (instance, newValue) => { + var _a; + instance.props.castShadows = parseBoolAttribute(newValue, defaultVideoCastShadows); + (_a = instance.videoGraphics) == null ? void 0 : _a.setCastShadows(instance.props.castShadows, instance.props); + }, + emissive: (instance, newValue) => { + instance.videoAnimatedAttributeHelper.elementSetAttribute( + "emissive", + parseFloatAttribute(newValue, defaultVideoEmissive) + ); + } +}); +var Video = _Video; +function registerCustomElementsToWindow(targetWindow) { + const targetHTMLElement = targetWindow["HTMLElement"]; + MElement.overwriteSuperclass(targetHTMLElement); + targetWindow.customElements.define(RemoteDocument.tagName, RemoteDocument); + targetWindow.customElements.define(Light.tagName, Light); + targetWindow.customElements.define(Model.tagName, Model); + targetWindow.customElements.define(Character.tagName, Character); + targetWindow.customElements.define(Cube.tagName, Cube); + targetWindow.customElements.define(Frame.tagName, Frame); + targetWindow.customElements.define(Cylinder.tagName, Cylinder); + targetWindow.customElements.define(Plane.tagName, Plane); + targetWindow.customElements.define(Label.tagName, Label); + targetWindow.customElements.define(Group.tagName, Group); + targetWindow.customElements.define(Prompt.tagName, Prompt); + targetWindow.customElements.define(Link.tagName, Link); + targetWindow.customElements.define(Sphere.tagName, Sphere); + targetWindow.customElements.define(Image.tagName, Image); + targetWindow.customElements.define(Video.tagName, Video); + targetWindow.customElements.define(Audio.tagName, Audio); + targetWindow.customElements.define(PositionProbe.tagName, PositionProbe); + targetWindow.customElements.define(ChatProbe.tagName, ChatProbe); + targetWindow.customElements.define(Interaction.tagName, Interaction); + targetWindow.customElements.define(AttributeAnimation.tagName, AttributeAnimation); + targetWindow.customElements.define(AttributeLerp.tagName, AttributeLerp); +} +var EventHandlerCollection = class _EventHandlerCollection { + constructor() { + this.eventsByTarget = /* @__PURE__ */ new Map(); + } + add(target, key, listener, options) { + target.addEventListener(key, listener, options); + let existingTarget = this.eventsByTarget.get(target); + if (existingTarget === void 0) { + existingTarget = /* @__PURE__ */ new Map(); + this.eventsByTarget.set(target, existingTarget); + } + let existingKey = existingTarget.get(key); + if (existingKey === void 0) { + existingKey = /* @__PURE__ */ new Set(); + existingTarget.set(key, existingKey); + } + existingKey.add(listener); + return this; + } + clear() { + this.eventsByTarget.forEach((keyMap, target) => { + keyMap.forEach((listenerSet, key) => { + listenerSet.forEach((listenerFunc) => { + target.removeEventListener(key, listenerFunc); + }); + }); + }); + this.eventsByTarget.clear(); + } + static create(initial) { + const instance = new _EventHandlerCollection(); + if (initial !== void 0) { + initial.forEach(([target, key, listenerFunc, options]) => { + instance.add(target, key, listenerFunc, options); + }); + } + return instance; + } +}; +function createInteractionsHolder(onPrev, onNext, onClose) { + const holderElement = document.createElement("div"); + holderElement.setAttribute("data-test-id", "interactions-holder"); + holderElement.style.zIndex = "100"; + holderElement.style.position = "absolute"; + holderElement.style.backgroundColor = "white"; + holderElement.style.padding = "10px"; + holderElement.style.display = "none"; + holderElement.style.border = "1px solid #AAA"; + holderElement.style.fontFamily = "sans-serif"; + holderElement.style.top = "50%"; + holderElement.style.left = "50%"; + holderElement.style.transform = "translate(-50%, -50%)"; + const closeButtonHolder = document.createElement("div"); + closeButtonHolder.style.display = "flex"; + closeButtonHolder.style.justifyContent = "flex-end"; + holderElement.appendChild(closeButtonHolder); + const title = document.createElement("h3"); + title.style.textAlign = "center"; + title.textContent = "Interactions"; + holderElement.appendChild(title); + const closeButton = document.createElement("button"); + closeButton.textContent = "Close"; + closeButton.style.cursor = "pointer"; + closeButton.addEventListener("click", () => { + onClose(); + }); + closeButtonHolder.appendChild(closeButton); + const listElement = document.createElement("div"); + listElement.setAttribute("data-test-id", "interactions-list"); + holderElement.appendChild(listElement); + const buttonHolder = document.createElement("div"); + buttonHolder.style.display = "flex"; + buttonHolder.style.justifyContent = "space-between"; + holderElement.appendChild(buttonHolder); + const prevButton = document.createElement("button"); + prevButton.textContent = "Prev"; + prevButton.style.cursor = "pointer"; + prevButton.addEventListener("click", onPrev); + buttonHolder.appendChild(prevButton); + const statusHolder = document.createElement("div"); + statusHolder.style.display = "flex"; + statusHolder.style.justifyContent = "center"; + statusHolder.style.padding = "5px"; + buttonHolder.appendChild(statusHolder); + const nextButton = document.createElement("button"); + nextButton.textContent = "Next"; + nextButton.style.cursor = "pointer"; + nextButton.addEventListener("click", onNext); + buttonHolder.appendChild(nextButton); + return { holderElement, listElement, prevButton, statusHolder, nextButton }; +} +function createInteractionPrompt() { + const interactionPrompt = document.createElement("div"); + interactionPrompt.setAttribute("data-test-id", "interactions-prompt"); + interactionPrompt.style.zIndex = "101"; + interactionPrompt.style.position = "absolute"; + interactionPrompt.style.top = "10px"; + interactionPrompt.style.left = "10px"; + interactionPrompt.style.display = "none"; + interactionPrompt.style.padding = "12px 10px"; + interactionPrompt.style.fontFamily = "Helvetica"; + interactionPrompt.style.color = "white"; + interactionPrompt.style.backgroundColor = "#222222b2"; + interactionPrompt.innerHTML = "Press E to interact"; + return interactionPrompt; +} +var _InteractionManager = class _InteractionManager2 { + constructor(container, interactionShouldShowDistance) { + this.container = container; + this.interactionShouldShowDistance = interactionShouldShowDistance; + this.pageOffset = 0; + this.eventCollection = new EventHandlerCollection(); + this.possibleActions = /* @__PURE__ */ new Map(); + this.visibleActions = /* @__PURE__ */ new Set(); + this.tickInterval = null; + this.sortedActions = []; + this.container = container; + const { holderElement, listElement, prevButton, statusHolder, nextButton } = createInteractionsHolder( + () => { + this.pageOffset--; + this.displayInteractions(); + }, + () => { + this.pageOffset++; + this.displayInteractions(); + }, + () => { + this.hideHolder(); + } + ); + this.prevButton = prevButton; + this.statusHolder = statusHolder; + this.nextButton = nextButton; + this.interactionListElement = listElement; + this.interactionHolderElement = holderElement; + this.container.appendChild(this.interactionHolderElement); + this.interactionPromptElement = createInteractionPrompt(); + this.container.appendChild(this.interactionPromptElement); + this.eventCollection.add(document, "keydown", (e) => { + if (e.code === "KeyE") { + if (this.interactionHolderElement.style.display === "block") { + this.hideHolder(); + return; + } + if (this.visibleActions.size > 0) { + this.showHolder(); + } + } else if (e.code === "Escape") { + this.hideHolder(); + } + }); + } + static createButtonText(interaction) { + return `${interaction.props.prompt ?? "Interact"}`; + } + getInteractionListener() { + return { + addInteraction: (interaction) => { + this.possibleActions.set(interaction, { + interaction + }); + }, + removeInteraction: (interaction) => { + const interactionState = this.possibleActions.get(interaction); + if (!interactionState) { + console.warn("Interaction not found", interaction); + return; + } + if (interactionState.button) { + interactionState.button.remove(); + } + this.possibleActions.delete(interaction); + if (this.visibleActions.has(interactionState)) { + this.visibleActions.delete(interactionState); + if (this.visibleActions.size === 0) { + this.hidePrompt(); + } + } + }, + updateInteraction: (interaction) => { + const interactionState = this.possibleActions.get(interaction); + if (!interactionState) { + console.warn("Interaction not found", interaction); + return; + } + if (interactionState.button) { + interactionState.button.textContent = _InteractionManager2.createButtonText(interaction); + } + } + }; + } + static init(container, interactionShouldShowDistance) { + const interactionManager = new _InteractionManager2(container, interactionShouldShowDistance); + interactionManager.startTick(); + return { interactionManager, interactionListener: interactionManager.getInteractionListener() }; + } + dispose() { + if (this.tickInterval) { + clearInterval(this.tickInterval); + } + this.eventCollection.clear(); + this.interactionListElement.remove(); + this.interactionHolderElement.remove(); + this.interactionPromptElement.remove(); + } + startTick() { + this.tickInterval = setInterval(() => { + this.possibleActions.forEach((interactionState, interaction) => { + const showDistance = this.interactionShouldShowDistance(interaction); + if (showDistance !== null) { + interactionState.distance = showDistance; + this.visibleActions.add(interactionState); + } else { + this.visibleActions.delete(interactionState); + } + }); + if (this.visibleActions.size === 0) { + this.hidePrompt(); + this.hideHolder(); + return; + } else { + this.showPrompt(); + } + this.sortedActions = Array.from(this.visibleActions).sort( + (a, b) => { + const priorityDiff = a.interaction.props.priority - b.interaction.props.priority; + if (priorityDiff !== 0) { + return priorityDiff; + } + if (a.distance && b.distance) { + const distanceDiff = a.distance - b.distance; + if (Math.abs(distanceDiff) > 0.1) { + return distanceDiff; + } + } + return 0; + } + ); + this.displayInteractions(); + }, 1e3); + } + displayInteractions() { + this.interactionListElement.innerHTML = ""; + const maximumPageOffset = Math.floor( + (this.sortedActions.length - 1) / _InteractionManager2.pageLimit + ); + if (this.pageOffset > maximumPageOffset) { + this.pageOffset = maximumPageOffset; + } + if (this.pageOffset < 0) { + this.pageOffset = 0; + } + const startIndex = this.pageOffset * _InteractionManager2.pageLimit; + const pagedItems = this.sortedActions.slice( + startIndex, + startIndex + _InteractionManager2.pageLimit + ); + if (this.pageOffset > 0) { + this.prevButton.removeAttribute("disabled"); + } else { + this.prevButton.setAttribute("disabled", "true"); + } + if (this.pageOffset < maximumPageOffset) { + this.nextButton.removeAttribute("disabled"); + } else { + this.nextButton.setAttribute("disabled", "true"); + } + this.statusHolder.textContent = `Page ${this.pageOffset + 1} of ${maximumPageOffset + 1}`; + pagedItems.forEach((interactionState) => { + if (!interactionState.button) { + const interactionText = _InteractionManager2.createButtonText(interactionState.interaction); + const button = document.createElement("button"); + button.style.display = "block"; + button.style.marginBottom = "5px"; + button.style.cursor = "pointer"; + button.style.textOverflow = "ellipsis"; + button.style.overflow = "hidden"; + button.style.whiteSpace = "nowrap"; + button.style.maxWidth = "200px"; + button.setAttribute("data-test-id", `interaction-${interactionText}`); + button.textContent = interactionText; + button.addEventListener("click", () => { + interactionState.interaction.trigger(); + this.hideHolder(); + }); + interactionState.button = button; + } + this.interactionListElement.appendChild(interactionState.button); + }); + } + hideHolder() { + this.interactionHolderElement.style.display = "none"; + } + showHolder() { + this.interactionHolderElement.style.display = "block"; + } + hidePrompt() { + this.interactionPromptElement.style.display = "none"; + } + showPrompt() { + this.interactionPromptElement.style.display = "block"; + } +}; +_InteractionManager.pageLimit = 3; +var InteractionManager = _InteractionManager; +var Modal = class { + constructor() { + this.element = document.createElement("div"); + this.element.style.display = "block"; + this.element.style.border = "1px solid #AAA"; + this.element.style.fontFamily = "sans-serif"; + this.element.style.color = "black"; + this.element.style.boxShadow = "0px 4px 4px rgba(0, 0, 0, 0.1)"; + this.element.style.backdropFilter = "blur(4px)"; + this.element.style.borderRadius = "4px"; + this.titleElement = document.createElement("div"); + this.titleElement.style.background = "rgba(255, 255, 255, 0.8)"; + this.titleElement.style.padding = "8px"; + this.titleElement.style.fontWeight = "bold"; + this.titleElement.style.borderBottom = "1px solid #AAA"; + this.contentsElement = document.createElement("div"); + this.contentsElement.style.background = "rgba(255, 255, 255, 0.6)"; + this.contentsElement.style.padding = "8px"; + this.element.append(this.titleElement, this.contentsElement); + this.element.addEventListener("keydown", (e) => { + e.stopPropagation(); + }); + } + dispose() { + this.element.remove(); + } +}; +var ConfirmModal = class extends Modal { + constructor(title, message, callback) { + super(); + this.titleElement.textContent = title; + this.confirmContentsElement = document.createElement("div"); + this.messageElement = document.createElement("div"); + this.messageElement.textContent = message; + this.messageElement.style.marginBottom = "8px"; + this.confirmContentsElement.appendChild(this.messageElement); + this.contentsElement.appendChild(this.confirmContentsElement); + this.buttonsHolder = document.createElement("div"); + this.buttonsHolder.style.display = "flex"; + this.buttonsHolder.style.justifyContent = "space-between"; + this.buttonsHolder.style.marginTop = "8px"; + this.cancelButton = document.createElement("button"); + this.cancelButton.setAttribute("data-test-id", "confirm-modal-cancel-button"); + this.cancelButton.style.cursor = "pointer"; + this.cancelButton.textContent = "Cancel"; + this.cancelButton.addEventListener("click", () => { + callback(false); + this.dispose(); + }); + this.buttonsHolder.appendChild(this.cancelButton); + this.okButton = document.createElement("button"); + this.okButton.setAttribute("data-test-id", "confirm-modal-ok-button"); + this.okButton.style.cursor = "pointer"; + this.okButton.textContent = "OK"; + this.okButton.addEventListener("click", () => { + callback(true); + this.dispose(); + }); + this.buttonsHolder.appendChild(this.okButton); + this.contentsElement.appendChild(this.buttonsHolder); + } +}; +var PromptModal = class extends Modal { + constructor(promptProps, callback) { + super(); + this.eventHandlerCollection = new EventHandlerCollection(); + this.callback = callback; + this.titleElement.textContent = "Prompt"; + this.promptContentsElement = document.createElement("div"); + this.promptMessageElement = document.createElement("div"); + this.promptMessageElement.textContent = promptProps.message || "Enter a value"; + this.promptMessageElement.style.marginBottom = "8px"; + this.promptContentsElement.appendChild(this.promptMessageElement); + this.promptInputElement = document.createElement("input"); + this.promptInputElement.type = "text"; + this.promptInputElement.style.width = "80vw"; + this.promptInputElement.style.maxWidth = "300px"; + this.promptInputElement.setAttribute("data-test-id", "prompt-input"); + this.promptInputElement.setAttribute("placeholder", promptProps.placeholder || ""); + this.promptInputElement.setAttribute("value", promptProps.prefill || ""); + this.promptInputElement.addEventListener("change", () => { + this.checkValue(); + }); + this.promptInputElement.addEventListener("keyup", (event) => { + if (event.key === "Enter") { + if (this.promptInputElement.value.length > 0) { + this.dispose(); + this.callback(this.promptInputElement.value); + } + } + this.checkValue(); + }); + this.eventHandlerCollection.add(document, "keydown", (e) => { + if (e.code === "Escape") { + this.dispose(); + this.callback(null); + } + this.checkValue(); + }); + this.promptContentsElement.appendChild(this.promptInputElement); + this.contentsElement.appendChild(this.promptContentsElement); + this.buttonsHolder = document.createElement("div"); + this.buttonsHolder.style.display = "flex"; + this.buttonsHolder.style.justifyContent = "space-between"; + this.buttonsHolder.style.marginTop = "8px"; + this.cancelButton = document.createElement("button"); + this.cancelButton.setAttribute("data-test-id", "prompt-cancel-button"); + this.cancelButton.style.cursor = "pointer"; + this.cancelButton.textContent = "Cancel"; + this.cancelButton.addEventListener("click", () => { + this.dispose(); + this.callback(null); + }); + this.buttonsHolder.appendChild(this.cancelButton); + this.okButton = document.createElement("button"); + this.okButton.setAttribute("data-test-id", "prompt-ok-button"); + this.okButton.style.cursor = "pointer"; + this.okButton.textContent = "OK"; + this.okButton.addEventListener("click", () => { + this.dispose(); + this.callback(this.promptInputElement.value); + }); + this.buttonsHolder.appendChild(this.okButton); + this.contentsElement.appendChild(this.buttonsHolder); + } + focus() { + this.promptInputElement.focus(); + this.promptInputElement.setSelectionRange( + this.promptInputElement.value.length, + this.promptInputElement.value.length + ); + this.checkValue(); + } + dispose() { + this.eventHandlerCollection.clear(); + super.dispose(); + } + checkValue() { + if (this.promptInputElement.value.length > 0) { + this.okButton.disabled = false; + } else { + this.okButton.disabled = true; + } + } +}; +var PromptManager = class _PromptManager { + constructor(container) { + this.container = container; + this.queue = new Array(); + this.currentPrompt = null; + this.currentModal = null; + const holderElement = document.createElement("div"); + holderElement.setAttribute("data-test-id", "prompt-holder"); + holderElement.style.zIndex = "100"; + holderElement.style.position = "absolute"; + holderElement.style.top = "50%"; + holderElement.style.left = "50%"; + holderElement.style.transform = "translate(-50%, -50%)"; + this.promptHolderElement = holderElement; + this.container.appendChild(this.promptHolderElement); + } + static init(container) { + return new _PromptManager(container); + } + dispose() { + this.promptHolderElement.remove(); + } + showPrompt(promptState) { + this.currentPrompt = promptState; + if ("href" in promptState) { + const confirmModal = new ConfirmModal( + "Confirm Navigation", + `Open ${promptState.href}?`, + (result) => { + this.currentPrompt = null; + this.currentModal = null; + if (result) { + let features; + if (promptState.popup) { + const popupWidth = 500; + const popupHeight = 500; + const screenLeft = window.screenLeft !== void 0 ? window.screenLeft : window.screenX; + const screenTop = window.screenTop !== void 0 ? window.screenTop : window.screenY; + const windowWidth = window.innerWidth ? window.innerWidth : document.documentElement.clientWidth ? document.documentElement.clientWidth : screen.width; + const windowHeight = window.innerHeight ? window.innerHeight : document.documentElement.clientHeight ? document.documentElement.clientHeight : screen.height; + const left = (windowWidth - popupWidth) / 2 + screenLeft; + const top = (windowHeight - popupHeight) / 2 + screenTop; + features = `toolbar=no,menubar=no,width=${popupWidth},height=${popupHeight},left=${left},top=${top}`; + } + const openedWindow = window.open( + promptState.href, + promptState.target ?? "_blank", + features + ); + promptState.windowCallback(openedWindow); + } + this.showNextPromptIfAny(); + } + ); + this.currentModal = confirmModal; + this.promptHolderElement.appendChild(confirmModal.element); + } else { + const promptModal = new PromptModal(promptState.promptProps, (result) => { + this.currentPrompt = null; + this.currentModal = null; + promptState.resolve(result); + this.showNextPromptIfAny(); + }); + this.currentModal = promptModal; + this.promptHolderElement.appendChild(promptModal.element); + promptModal.focus(); + } + } + prompt(promptProps, abortSignal, callback) { + abortSignal.addEventListener("abort", () => { + var _a; + if (this.currentPrompt === promptState) { + this.currentPrompt = null; + (_a = this.currentModal) == null ? void 0 : _a.dispose(); + this.showNextPromptIfAny(); + } else { + this.queue = this.queue.filter((item) => item !== promptState); + } + }); + const promptState = { + promptProps, + resolve: callback + }; + if (this.currentPrompt !== null) { + this.queue.push(promptState); + return; + } + this.showPrompt(promptState); + } + link(linkProps, abortSignal, windowCallback) { + abortSignal.addEventListener("abort", () => { + var _a; + if (this.currentPrompt === linkState) { + this.currentPrompt = null; + (_a = this.currentModal) == null ? void 0 : _a.dispose(); + this.currentModal = null; + this.showNextPromptIfAny(); + } else { + this.queue = this.queue.filter((item) => item !== linkState); + } + }); + const linkState = { + href: linkProps.href, + target: linkProps.target, + popup: linkProps.popup ?? false, + windowCallback + }; + if (this.currentPrompt !== null) { + this.queue.push(linkState); + return; + } + this.showPrompt(linkState); + } + showNextPromptIfAny() { + const nextPrompt = this.queue.shift(); + if (nextPrompt !== void 0) { + this.showPrompt(nextPrompt); + } + } +}; +var MMLScene = class { + constructor(element) { + this.element = element; + this.colliders = /* @__PURE__ */ new Set(); + this.interactions = /* @__PURE__ */ new Set(); + this.interactionListeners = /* @__PURE__ */ new Set(); + this.chatProbes = /* @__PURE__ */ new Set(); + this.chatProbeListeners = /* @__PURE__ */ new Set(); + this.graphicsAdapter = null; + this.loadingProgressManager = new LoadingProgressManager(); + } + init(graphicsAdapter) { + this.graphicsAdapter = graphicsAdapter; + this.graphicsAdapter.start(); + this.resizeObserver = new ResizeObserver(() => { + this.fitContainer(); + }); + this.resizeObserver.observe(this.element); + this.promptManager = PromptManager.init(this.element); + const { interactionManager, interactionListener } = InteractionManager.init( + this.element, + this.graphicsAdapter.interactionShouldShowDistance.bind(this.graphicsAdapter) + ); + this.interactionManager = interactionManager; + this.addInteractionListener(interactionListener); + this.resizeListener = () => { + this.fitContainer(); + }; + window.addEventListener("resize", this.resizeListener, false); + this.fitContainer(); + } + hasGraphicsAdapter() { + return this.graphicsAdapter !== null; + } + getGraphicsAdapter() { + if (!this.graphicsAdapter) { + throw new Error("MMLScene not initialized with a graphics adapter. Call init() first."); + } + return this.graphicsAdapter; + } + getRootContainer() { + if (!this.graphicsAdapter) { + throw new Error("MMLScene not initialized with a graphics adapter"); + } + return this.graphicsAdapter.getRootContainer(); + } + getUserPositionAndRotation() { + if (!this.graphicsAdapter) { + throw new Error("MMLScene not initialized with a graphics adapter"); + } + return this.graphicsAdapter.getUserPositionAndRotation(); + } + fitContainer() { + if (!this.graphicsAdapter) { + throw new Error("MMLScene not initialized with a graphics adapter"); + } + const width = this.element.clientWidth; + const height = this.element.clientHeight; + this.graphicsAdapter.resize(width, height); + } + dispose() { + window.removeEventListener("resize", this.resizeListener); + this.resizeObserver.disconnect(); + this.promptManager.dispose(); + this.interactionManager.dispose(); + } + prompt(promptProps, abortSignal, callback) { + if (!this) { + console.error("MMLScene not initialized"); + return; + } + this.promptManager.prompt(promptProps, abortSignal, callback); + } + link(linkProps, abortSignal, windowCallback) { + this.promptManager.link(linkProps, abortSignal, windowCallback); + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + addCollider(collider, element) { + this.colliders.add(collider); + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + updateCollider(collider) { + } + removeCollider(collider) { + this.colliders.delete(collider); + } + addInteraction(interaction) { + this.interactions.add(interaction); + for (const listener of this.interactionListeners) { + listener.addInteraction(interaction); + } + } + updateInteraction(interaction) { + for (const listener of this.interactionListeners) { + listener.updateInteraction(interaction); + } + } + removeInteraction(interaction) { + this.interactions.delete(interaction); + for (const listener of this.interactionListeners) { + listener.removeInteraction(interaction); + } + } + getInteractions() { + return this.interactions; + } + addInteractionListener(listener, addExistingInteractions = true) { + this.interactionListeners.add(listener); + if (addExistingInteractions) { + for (const interaction of this.interactions) { + listener.addInteraction(interaction); + } + } + } + removeInteractionListener(listener) { + this.interactionListeners.delete(listener); + } + addChatProbe(chatProbe) { + this.chatProbes.add(chatProbe); + for (const listener of this.chatProbeListeners) { + listener.addChatProbe(chatProbe); + } + } + updateChatProbe(chatProbe) { + for (const listener of this.chatProbeListeners) { + listener.updateChatProbe(chatProbe); + } + } + removeChatProbe(chatProbe) { + this.chatProbes.delete(chatProbe); + for (const listener of this.chatProbeListeners) { + listener.removeChatProbe(chatProbe); + } + } + getLoadingProgressManager() { + return this.loadingProgressManager; + } + getChatProbes() { + return this.chatProbes; + } + addChatProbeListener(listener, addExistingChatProbes = true) { + this.chatProbeListeners.add(listener); + if (addExistingChatProbes) { + for (const chatProbe of this.chatProbes) { + listener.addChatProbe(chatProbe); + } + } + } + removeChatProbeListener(listener) { + this.chatProbeListeners.delete(listener); + } +}; +var FullScreenMMLScene = class extends MMLScene { + constructor() { + super(document.createElement("div")); + this.element = document.createElement("div"); + this.element.style.width = "100%"; + this.element.style.height = "100%"; + this.element.style.position = "relative"; + const loadingProgressManager = this.getLoadingProgressManager(); + this.loadingProgressBar = new LoadingProgressBar(loadingProgressManager); + this.element.append(this.loadingProgressBar.element); + this.configureWindowStyling(); + } + configureWindowStyling() { + document.documentElement.style.width = "100%"; + document.documentElement.style.height = "100%"; + document.documentElement.style.overflow = "hidden"; + document.documentElement.style.overscrollBehaviorX = "contain"; + document.documentElement.style.margin = "0"; + const onload = () => { + document.body.style.margin = "0"; + document.body.style.height = "100%"; + }; + if (document.body) { + onload(); + } else { + window.addEventListener("load", () => { + onload(); + }); + } + } + dispose() { + super.dispose(); + this.element.remove(); + } +}; +var AudioGraphics = class { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + constructor(element) { + } +}; +var ChatProbeGraphics = class { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + constructor(element) { + } +}; +var CubeGraphics = class { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + constructor(element) { + } +}; +var CylinderGraphics = class { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + constructor(element) { + } +}; +var DebugHelperGraphics = class { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + constructor(debugHelper) { + } +}; +var FrameGraphics = class { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + constructor(element) { + } +}; +var ImageGraphics = class { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + constructor(element, updateMeshCallback) { + } +}; +var InteractionGraphics = class { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + constructor(element) { + } +}; +var LabelGraphics = class { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + constructor(element) { + } +}; +var LightGraphics = class { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + constructor(element) { + } +}; +var LinkGraphics = class { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + constructor(element) { + } +}; +var MElementGraphics = class { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + constructor(element) { + } +}; +var ModelGraphics = class { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + constructor(element, updateMeshCallback) { + } +}; +var PlaneGraphics = class { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + constructor(element) { + } +}; +var PositionProbeGraphics = class { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + constructor(element) { + } +}; +var PromptGraphics = class { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + constructor(element) { + } +}; +var RemoteDocumentGraphics = class { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + constructor(element) { + } +}; +var SphereGraphics = class { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + constructor(element) { + } +}; +var TransformableGraphics = class { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + constructor(element) { + } +}; +var VideoGraphics = class { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + constructor(element, updateMeshCallback) { + } +}; +var IframeWrapper = class _IframeWrapper { + constructor() { + this.iframe = document.createElement("iframe"); + this.iframe.style.position = "fixed"; + this.iframe.style.top = "0"; + this.iframe.style.left = "0"; + this.iframe.style.width = "0"; + this.iframe.style.height = "0"; + this.iframe.style.border = "none"; + this.iframe.style.visibility = "hidden"; + } + static async create() { + return new Promise((resolve) => { + const iframeWrapper = new _IframeWrapper(); + document.body.append(iframeWrapper.iframe); + const ready = iframeWrapper.iframe.contentWindow ? iframeWrapper.iframe.contentWindow.document.readyState === "complete" : false; + const onLoad = () => { + const iframe = iframeWrapper.iframe; + const iframeWindow = iframe.contentWindow; + resolve({ + iframeWrapper, + iframeWindow, + iframeDocument: iframeWindow.document, + iframeBody: iframeWindow.document.body + }); + }; + if (ready) { + setTimeout(() => { + onLoad(); + }); + } else { + iframeWrapper.iframe.addEventListener("load", () => { + onLoad(); + }); + } + }); + } + dispose() { + this.iframe.remove(); + } +}; +var MMLNetworkSource = class _MMLNetworkSource { + constructor(options) { + this.options = options; + this.websocket = null; + } + static create(options) { + const mmlNetworkSource = new _MMLNetworkSource(options); + mmlNetworkSource.init(); + return mmlNetworkSource; + } + init() { + let overriddenHandler = null; + const eventHandler = (element, event) => { + if (!overriddenHandler) { + throw new Error("overriddenHandler not set"); + } + overriddenHandler(element, event); + }; + const src = this.options.url; + this.remoteDocumentWrapper = new RemoteDocumentWrapper( + src, + this.options.windowTarget, + this.options.mmlScene, + eventHandler + ); + this.options.targetForWrappers.append(this.remoteDocumentWrapper.remoteDocument); + let loadingProgressManager; + if (this.options.mmlScene.getLoadingProgressManager) { + loadingProgressManager = this.options.mmlScene.getLoadingProgressManager(); + } + const isWebsocket = src.startsWith("ws://") || src.startsWith("wss://"); + if (isWebsocket) { + const websocket = new NetworkedDOMWebsocket( + this.options.url, + NetworkedDOMWebsocket.createWebSocket, + this.remoteDocumentWrapper.remoteDocument, + (time) => { + this.remoteDocumentWrapper.setDocumentTime(time); + }, + (status) => { + if (status === NetworkedDOMWebsocketStatus.Connected) { + loadingProgressManager == null ? void 0 : loadingProgressManager.setInitialLoad(true); + } + this.options.statusUpdated(status); + }, + { + tagPrefix: "m-" + } + ); + this.websocket = websocket; + overriddenHandler = (element, event) => { + websocket.handleEvent(element, event); + }; + } else { + fetchRemoteStaticMML(this.options.url).then((remoteDocumentBody) => { + this.remoteDocumentWrapper.remoteDocument.append(remoteDocumentBody); + loadingProgressManager == null ? void 0 : loadingProgressManager.setInitialLoad(true); + }).catch((err) => { + loadingProgressManager == null ? void 0 : loadingProgressManager.setInitialLoad(err); + }); + overriddenHandler = () => { + }; + } + } + dispose() { + if (this.websocket) { + this.websocket.stop(); + this.websocket = null; + } + this.remoteDocumentWrapper.remoteDocument.remove(); + } +}; +var StatusUI = class { + constructor() { + this.element = document.createElement("div"); + this.element.style.position = "fixed"; + this.element.style.top = "50%"; + this.element.style.left = "50%"; + this.element.style.transform = "translate(-50%, -50%)"; + this.element.style.zIndex = "1000"; + this.element.style.backgroundColor = "rgba(0, 0, 0, 0.5)"; + this.element.style.color = "white"; + this.element.style.padding = "1em"; + this.element.style.fontFamily = "sans-serif"; + this.element.style.fontSize = "1.5em"; + this.element.style.fontWeight = "bold"; + this.element.style.pointerEvents = "none"; + this.element.style.display = "none"; + document.body.append(this.element); + } + setStatus(text) { + this.element.textContent = text; + this.element.style.display = "block"; + } + setNoStatus() { + this.element.textContent = ""; + this.element.style.display = "none"; + } + dispose() { + this.element.remove(); + } +}; +var tagAdapterDefaultTheme = { + background: "#1D2331", + brackets: "#D4D2C8", + tag: "#73D0FF", + attribute: "#FFD173", + unrecognizedAttribute: "#FF9800", + value: "#D5FF80", + appliedValue: "#B800FF", + equals: "#FFAD66", + quote: "#D5FF80" +}; +var TagDebugAdapterDebugHelper = class { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + constructor(debugHelper) { + } + dispose() { + } +}; +function TagDebugAdapterElement(functionToAttribute, additionalFunctions) { + return (element) => { + const result = {}; + for (const key in functionToAttribute) { + const attributeName = functionToAttribute[key]; + result[key] = (val) => { + var _a; + (_a = element.getContainer()) == null ? void 0 : _a.setAppliedAttributeValue(attributeName, val); + }; + } + return { + ...result, + enable: () => { + }, + disable: () => { + }, + getCollisionElement() { + return null; + }, + dispose: () => { + }, + ...additionalFunctions + }; + }; +} +var TagDebugAttribute = class { + constructor(key, value, theme, isObserved) { + this.key = key; + this.value = value; + this.theme = theme; + this.isObserved = isObserved; + this.appliedValue = null; + this.element = document.createElement("span"); + if (!isObserved) { + this.element.style.borderBottomStyle = "dotted"; + this.element.style.borderWidth = "2px"; + this.element.style.borderColor = this.theme.unrecognizedAttribute; + } + const keySpan = document.createElement("span"); + keySpan.textContent = ` ${key}`; + keySpan.style.color = this.theme.attribute; + const equalsSpan = document.createElement("span"); + equalsSpan.textContent = "="; + equalsSpan.style.color = this.theme.equals; + const quoteSpan = document.createElement("span"); + quoteSpan.textContent = `"`; + quoteSpan.style.color = this.theme.quote; + this.valueSpan = document.createElement("span"); + this.valueSpan.textContent = value; + this.valueSpan.style.color = this.theme.value; + const endQuoteSpan = document.createElement("span"); + endQuoteSpan.textContent = `"`; + endQuoteSpan.style.color = this.theme.quote; + this.appliedValueSpan = document.createElement("span"); + this.appliedValueSpan.className = "no-copy"; + this.appliedValueSpan.style.color = this.theme.appliedValue; + this.appliedValueSpan.style.display = "none"; + this.element.append( + keySpan, + equalsSpan, + quoteSpan, + this.valueSpan, + endQuoteSpan, + this.appliedValueSpan + ); + } + setValue(value) { + this.value = value; + if (value === null) { + this.valueSpan.textContent = ""; + this.appliedValueSpan.style.display = "none"; + if (this.appliedValue !== null) { + this.appliedValueSpan.style.display = "inline"; + } + return; + } + this.valueSpan.textContent = `${value}`; + if (this.appliedValue !== null) { + if (this.appliedValue.asString === value) { + this.appliedValueSpan.style.display = "none"; + } else { + this.appliedValueSpan.style.display = "inline"; + } + } + } + setAppliedValue(value) { + if (value === null) { + this.appliedValueSpan.style.display = "none"; + this.appliedValue = null; + return; + } + if (typeof value === "object") { + this.appliedValueSpan.style.display = "inline"; + this.appliedValueSpan.textContent = `\u2588(${value.r}, ${value.g}, ${value.b}${value.a ? `, ${value.a}` : ""})`; + const average = (value.r + value.g + value.b) / 3; + this.appliedValueSpan.style.color = `rgb(${value.r * 255}, ${value.g * 255}, ${value.b * 255})`; + this.appliedValueSpan.style.backgroundColor = average > 0.5 ? "black" : "white"; + } else { + const asString = value.toString(); + let displayString = asString; + if (typeof value === "number") { + const asFixed = value.toFixed(6); + if (asString.length > asFixed.length) { + displayString = asFixed; + } + } + this.appliedValue = { + raw: value, + asString, + displayString + }; + if (this.value !== null) { + if (this.value === asString) { + this.appliedValueSpan.style.display = "none"; + return; + } + } + this.appliedValueSpan.style.display = "inline"; + this.appliedValueSpan.textContent = `(${displayString})`; + } + } + hasAppliedValue() { + return this.appliedValue !== null; + } + hasValue() { + return this.value !== null; + } +}; +var ignoredAttributes = /* @__PURE__ */ new Set(["style"]); +var TagDebugMElement = class _TagDebugMElement { + constructor(mElement) { + this.mElement = mElement; + this.currentParent = null; + this.attributes = {}; + this.observedAttributes = /* @__PURE__ */ new Set(); + var _a, _b, _c; + const observedAttributesArray = ((_b = (_a = mElement.__proto__) == null ? void 0 : _a.constructor) == null ? void 0 : _b.observedAttributes) ?? []; + this.observedAttributes = /* @__PURE__ */ new Set([...observedAttributesArray, "id", "class"]); + const graphicAdapter = mElement.getScene().getGraphicsAdapter(); + this.theme = graphicAdapter.theme; + this.container = document.createElement("div"); + this.container.style.fontFamily = "monospace"; + this.container.style.lineHeight = "1.5em"; + const mElementParent = this.mElement.getMElementParent(); + if (mElementParent) { + this.currentParent = mElementParent.getContainer(); + (_c = this.currentParent) == null ? void 0 : _c.childElementHolder.append(this.container); + this.indentLevel = this.currentParent.indentLevel + 1; + } else { + const scene2 = this.mElement.getScene(); + this.currentParent = scene2; + scene2.getRootContainer().append(this.container); + this.indentLevel = 0; + } + const firstLine = document.createElement("div"); + firstLine.style.textWrap = "nowrap"; + const openingLineBreak = document.createElement("span"); + openingLineBreak.textContent = "\n"; + const openingBracket = document.createElement("span"); + const indent = Array(this.indentLevel * 4).fill(" ").join(""); + openingBracket.textContent = `${indent}<`; + openingBracket.style.color = this.theme.brackets; + openingBracket.style.whiteSpace = "pre"; + const openingTag = document.createElement("span"); + openingTag.textContent = mElement.tagName.toLowerCase(); + openingTag.style.color = this.theme.tag; + this.attributesHolder = document.createElement("span"); + const openingTagEnd = document.createElement("span"); + openingTagEnd.textContent = ">"; + openingTagEnd.style.color = this.theme.brackets; + firstLine.append( + openingLineBreak, + openingBracket, + openingTag, + this.attributesHolder, + openingTagEnd + ); + this.childElementHolder = document.createElement("div"); + const closingTag = document.createElement("div"); + closingTag.style.textWrap = "nowrap"; + const closingLineBreak = document.createElement("span"); + closingLineBreak.textContent = "\n"; + const closingTagOpeningBracket = document.createElement("span"); + closingTagOpeningBracket.textContent = `${indent}"; + closingTagEnd.style.color = this.theme.brackets; + closingTag.append(closingLineBreak, closingTagOpeningBracket, closingTagName, closingTagEnd); + this.container.append(firstLine, this.childElementHolder, closingTag); + this.mutationObserver = new MutationObserver((mutations) => { + mutations.forEach((mutation) => { + if (mutation.type === "attributes") { + const attributeName = mutation.attributeName; + if (ignoredAttributes.has(attributeName)) { + return; + } + const attributeValue = this.mElement.getAttribute(attributeName); + const existingAttribute = this.attributes[attributeName]; + if (attributeValue === null) { + if (existingAttribute) { + if (!existingAttribute.hasAppliedValue()) { + existingAttribute.element.remove(); + delete this.attributes[attributeName]; + } else { + existingAttribute.setValue(null); + } + } + } else { + if (existingAttribute) { + existingAttribute.setValue(attributeValue); + } else { + this.createAttributeElement(attributeName, attributeValue); + } + } + } + }); + }); + for (let i = 0; i < mElement.attributes.length; i++) { + const attribute = mElement.attributes[i]; + if (ignoredAttributes.has(attribute.name)) { + continue; + } + this.createAttributeElement(attribute.name, attribute.value); + } + this.mutationObserver.observe(mElement, { attributes: true }); + } + createAttributeElement(attributeName, value) { + const newAttribute = new TagDebugAttribute( + attributeName, + value, + this.theme, + this.observedAttributes.has(attributeName) + ); + this.attributes[attributeName] = newAttribute; + this.attributesHolder.append(newAttribute.element); + return newAttribute; + } + setAppliedAttributeValue(attributeName, value) { + const existingAttribute = this.attributes[attributeName]; + if (existingAttribute) { + existingAttribute.setAppliedValue(value); + if (value === null && !existingAttribute.hasValue()) { + existingAttribute.element.remove(); + delete this.attributes[attributeName]; + } + } else if (value !== null) { + const newAttribute = this.createAttributeElement(attributeName, null); + newAttribute.setAppliedValue(value); + } + } + getContainer() { + return this; + } + dispose() { + this.mutationObserver.disconnect(); + if (this.currentParent === null) { + throw new Error("Was not connected to a parent"); + } + if (this.currentParent instanceof _TagDebugMElement) { + this.currentParent.childElementHolder.removeChild(this.container); + this.currentParent = null; + } else { + this.currentParent.getRootContainer().removeChild(this.container); + this.currentParent = null; + } + } +}; +var TagDebugAdapterGraphicsInterface = { + MElementGraphicsInterface: (element) => new TagDebugMElement(element), + MMLDebugHelperGraphicsInterface: (debugHelper) => new TagDebugAdapterDebugHelper(debugHelper), + MMLCubeGraphicsInterface: TagDebugAdapterElement( + { + setWidth: "width", + setHeight: "height", + setDepth: "depth", + setCastShadows: "cast-shadows", + setColor: "color", + setOpacity: "opacity" + }, + {} + ), + MMLSphereGraphicsInterface: TagDebugAdapterElement( + { + setRadius: "radius", + setCastShadows: "cast-shadows", + setColor: "color", + setOpacity: "opacity" + }, + {} + ), + MMLPlaneGraphicsInterface: TagDebugAdapterElement( + { + setWidth: "width", + setHeight: "height", + setCastShadows: "cast-shadows", + setColor: "color", + setOpacity: "opacity" + }, + {} + ), + MMLImageGraphicsInterface: TagDebugAdapterElement( + { + setSrc: "src", + setWidth: "width", + setHeight: "height", + setEmissive: "emissive", + setCastShadows: "cast-shadows", + setOpacity: "opacity" + }, + { + getWidthAndHeight: () => ({ width: 0, height: 0 }) + } + ), + MMLAudioGraphicsInterface: TagDebugAdapterElement( + { + setSrc: "src", + setEnabled: "enabled", + setLoop: "loop", + setLoopDuration: "loop-duration", + setVolume: "volume", + setStartTime: "start-time", + setPauseTime: "pause-time", + setConeAngle: "cone-angle", + setConeFalloffAngle: "cone-falloff-angle", + setDebug: "debug" + }, + { + syncAudioTime: () => { + } + } + ), + MMLCylinderGraphicsInterface: TagDebugAdapterElement( + { + setRadius: "radius", + setHeight: "height", + setCastShadows: "cast-shadows", + setColor: "color", + setOpacity: "opacity" + }, + {} + ), + MMLTransformableGraphicsInterface: TagDebugAdapterElement( + { + setX: "x", + setY: "y", + setZ: "z", + setRotationX: "rx", + setRotationY: "ry", + setRotationZ: "rz", + setScaleX: "sx", + setScaleY: "sy", + setScaleZ: "sz", + setVisible: "visible", + setSocket: "socket" + }, + { + getWorldMatrix: () => { + return new Matr4(); + } + } + ), + RemoteDocumentGraphicsInterface: TagDebugAdapterElement( + {}, + { + showError() { + }, + dispose() { + } + } + ), + MMLLightGraphicsInterface: TagDebugAdapterElement( + { + setEnabled: "enabled", + setDebug: "debug", + setCastShadows: "cast-shadows", + setAngle: "angle", + setIntensity: "intensity", + setDistance: "distance", + setType: "type", + setColor: "color" + }, + {} + ), + MMLLinkGraphicsInterface: TagDebugAdapterElement( + { + setHref: "href", + setTarget: "target" + }, + {} + ), + MMLModelGraphicsInterface: TagDebugAdapterElement( + { + setSrc: "src", + setDebug: "debug", + setCastShadows: "cast-shadows", + setAnim: "anim", + setAnimEnabled: "anim-enabled", + setAnimStartTime: "anim-start-time", + setAnimPauseTime: "anim-pause-time", + setAnimLoop: "anim-loop" + }, + { + getBoundingBox: () => ({ + centerOffset: { x: 0, y: 0, z: 0 }, + size: { x: 0, y: 0, z: 0 } + }), + hasLoadedAnimation: () => false, + hasLoadedModel: () => false, + transformed: () => false + } + ), + MMLVideoGraphicsInterface: TagDebugAdapterElement( + { + setSrc: "src", + setWidth: "width", + setHeight: "height", + setEnabled: "enabled", + setCastShadows: "cast-shadows", + setLoop: "loop", + setVolume: "volume", + setEmissive: "emissive", + setStartTime: "start-time", + setPauseTime: "pause-time" + }, + { + syncVideoTime: () => { + }, + getWidthAndHeight: () => ({ width: 0, height: 0 }) + } + ), + MMLFrameGraphicsInterface: TagDebugAdapterElement( + { + setSrc: "src", + setDebug: "debug", + setLoadRange: "load-range", + setUnloadRange: "unload-range", + setMinX: "min-x", + setMaxX: "max-x", + setMinY: "min-y", + setMaxY: "max-y", + setMinZ: "min-z", + setMaxZ: "max-z" + }, + {} + ), + MMLLabelGraphicsInterface: TagDebugAdapterElement( + { + setContent: "content", + setFontSize: "font-size", + setAlignment: "alignment", + setPadding: "padding", + setColor: "color", + setFontColor: "font-color", + setEmissive: "emissive", + setWidth: "width", + setHeight: "height", + setCastShadows: "cast-shadows" + }, + {} + ), + MMLPromptGraphicsInterface: TagDebugAdapterElement( + { + setMessage: "message", + setPlaceholder: "placeholder", + setPrefill: "prefill", + setDebug: "debug" + }, + {} + ), + MMLInteractionGraphicsInterface: TagDebugAdapterElement( + { + setRange: "range", + setInFocus: "in-focus", + setLineOfSight: "line-of-sight", + setPriority: "priority", + setPrompt: "prompt", + setDebug: "debug" + }, + {} + ), + MMLChatProbeGraphicsInterface: TagDebugAdapterElement( + { + setRange: "range", + setDebug: "debug" + }, + {} + ), + MMLPositionProbeGraphicsInterface: TagDebugAdapterElement( + { + setRange: "range", + setDebug: "debug" + }, + {} + ) +}; +var StandaloneTagDebugAdapter = class _StandaloneTagDebugAdapter { + constructor(element) { + this.element = element; + this.theme = tagAdapterDefaultTheme; + this.element.style.background = this.theme.background; + element.addEventListener("copy", function(e) { + var _a; + e.preventDefault(); + const selection = window.getSelection(); + if (selection) { + const range = selection.getRangeAt(0); + const div = document.createElement("div"); + div.appendChild(range.cloneContents()); + const noCopyElements = div.querySelectorAll(".no-copy"); + noCopyElements.forEach((element2) => element2.remove()); + const asText = div.textContent; + if (asText) { + (_a = e.clipboardData) == null ? void 0 : _a.setData("text/plain", asText); + } + } + }); + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + interactionShouldShowDistance(interaction) { + return null; + } + getGraphicsAdapterFactory() { + return TagDebugAdapterGraphicsInterface; + } + static async create(element) { + element.style.overflow = "auto"; + const adapter = new _StandaloneTagDebugAdapter(element); + await adapter.init(); + return adapter; + } + async init() { + return Promise.resolve(); + } + start() { + } + getUserPositionAndRotation() { + return { + position: { + x: 0, + y: 0, + z: 0 + }, + rotation: { + x: 0, + y: 0, + z: 0 + } + }; + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + resize(width, height) { + } + dispose() { + } + getRootContainer() { + return this.element; + } +}; +function calculateContentSize(opts) { + if (opts.content) { + const height = opts.height; + const width = opts.width; + const loadedWidth = Math.max(opts.content.width, 1); + const loadedHeight = Math.max(opts.content.height, 1); + if (height && width) { + return { width, height }; + } else if (height && !width) { + return { + // compute width from height and content aspect ratio + width: height * loadedWidth / loadedHeight, + height + }; + } else if (!height && width) { + return { + width, + // compute height from width and content aspect ratio + height: width * loadedHeight / loadedWidth + }; + } else { + return { + width: 1, + // compute height from content aspect ratio + height: loadedHeight / loadedWidth + }; + } + } else { + return { + width: opts.width !== null ? opts.width : 1, + height: opts.height !== null ? opts.height : 1 + }; + } +} +var StaticFileVideoSource = class { + constructor(srcURL, videoTag, videoSourceProps, getDocumentTime) { + this.srcURL = srcURL; + this.videoTag = videoTag; + this.videoSourceProps = videoSourceProps; + this.getDocumentTime = getDocumentTime; + this.delayedStartTimer = null; + this.delayedPauseTimer = null; + this.shouldBePaused = false; + this.pauseListener = () => { + if (this.shouldBePaused) { + return; + } + if (this.videoSourceProps) { + this.syncVideoSource(this.videoSourceProps); + } + }; + videoTag.addEventListener("pause", this.pauseListener); + try { + videoTag.src = srcURL.toString(); + } catch (e) { + console.error("src failed to switch", e); + } + } + getContentAddress() { + return this.srcURL.toString(); + } + dispose() { + this.videoTag.removeEventListener("pause", this.pauseListener); + this.videoTag.src = ""; + if (this.delayedPauseTimer !== null) { + clearTimeout(this.delayedPauseTimer); + this.delayedPauseTimer = null; + } + if (this.delayedStartTimer !== null) { + clearTimeout(this.delayedStartTimer); + this.delayedStartTimer = null; + } + } + syncVideoSource(props) { + const documentTimeMilliseconds = this.getDocumentTime(); + this.videoSourceProps = props; + if (this.delayedStartTimer) { + clearTimeout(this.delayedStartTimer); + this.delayedStartTimer = null; + } + if (this.delayedPauseTimer !== null) { + clearTimeout(this.delayedPauseTimer); + this.delayedPauseTimer = null; + } + const startTimeMilliseconds = props.startTime ? props.startTime : 0; + const pauseTimeMilliseconds = props.pauseTime; + if (pauseTimeMilliseconds !== null) { + if (documentTimeMilliseconds !== null && pauseTimeMilliseconds > documentTimeMilliseconds) { + const delayedPauseTimer = setTimeout(() => { + if (this.delayedPauseTimer === delayedPauseTimer) { + this.delayedPauseTimer = null; + } + this.syncVideoSource(this.videoSourceProps); + }, pauseTimeMilliseconds - documentTimeMilliseconds); + this.delayedPauseTimer = delayedPauseTimer; + } else { + let totalPlaybackTimeSeconds = (pauseTimeMilliseconds - startTimeMilliseconds) / 1e3; + if (totalPlaybackTimeSeconds < 0) { + totalPlaybackTimeSeconds = 0; + } + if (props.loop) { + totalPlaybackTimeSeconds = totalPlaybackTimeSeconds % this.videoTag.duration; + } else if (totalPlaybackTimeSeconds > this.videoTag.duration) { + totalPlaybackTimeSeconds = this.videoTag.duration; + } + this.shouldBePaused = true; + this.videoTag.pause(); + this.videoTag.currentTime = totalPlaybackTimeSeconds; + return; + } + } + let currentTimeSeconds = 0; + if (documentTimeMilliseconds) { + currentTimeSeconds = (documentTimeMilliseconds - startTimeMilliseconds) / 1e3; + } else { + currentTimeSeconds = startTimeMilliseconds / 1e3; + } + let desiredVideoTimeSeconds; + if (currentTimeSeconds < 0) { + this.videoTag.currentTime = 0; + this.shouldBePaused = true; + this.videoTag.pause(); + const delayedStartTimer = setTimeout(() => { + if (this.delayedStartTimer === delayedStartTimer) { + this.delayedStartTimer = null; + } + this.syncVideoSource(this.videoSourceProps); + }, -currentTimeSeconds * 1e3); + this.delayedStartTimer = delayedStartTimer; + return; + } else if (props.loop) { + desiredVideoTimeSeconds = currentTimeSeconds % this.videoTag.duration; + } else { + desiredVideoTimeSeconds = currentTimeSeconds; + } + let delta = desiredVideoTimeSeconds - this.videoTag.currentTime; + if (props.loop) { + const loopedDelta = delta - this.videoTag.duration; + if (Math.abs(delta) > Math.abs(loopedDelta)) { + delta = loopedDelta; + } + } + if (Math.abs(delta) < 0.1) { + this.videoTag.playbackRate = 1; + } else if (Math.abs(delta) > 0.5) { + this.videoTag.currentTime = desiredVideoTimeSeconds; + this.videoTag.playbackRate = 1; + } else { + if (delta > 0) { + this.videoTag.playbackRate = 1.02; + } else { + this.videoTag.playbackRate = 0.98; + } + } + if (desiredVideoTimeSeconds >= this.videoTag.duration) { + this.shouldBePaused = true; + this.videoTag.pause(); + return; + } else { + this.shouldBePaused = false; + if (this.videoTag.paused) { + this.videoTag.play().catch((e) => { + console.error("failed to play", e); + }); + } + return; + } + } +}; +async function negotiateConnectionWithClientOffer(peerConnection, endpoint) { + const offer = await peerConnection.createOffer(); + await peerConnection.setLocalDescription(offer); + const ofr = await waitToCompleteICEGathering(peerConnection); + if (!ofr) { + throw Error("failed to gather ICE candidates for offer"); + } + while (peerConnection.connectionState !== "closed") { + const response = await postSDPOffer(endpoint, ofr.sdp); + if (response.status === 201) { + const answerSDP = await response.text(); + await peerConnection.setRemoteDescription( + new RTCSessionDescription({ type: "answer", sdp: answerSDP }) + ); + return response.headers.get("Location"); + } else if (response.status === 405) { + console.log("Remember to update the URL passed into the WHIP or WHEP client"); + } else { + const errorMessage = await response.text(); + console.error("WHEP error in negotiation response", errorMessage); + } + await new Promise((r) => setTimeout(r, 5e3)); + } +} +async function postSDPOffer(endpoint, data) { + return await fetch(endpoint, { + method: "POST", + mode: "cors", + headers: { + "content-type": "application/sdp" + }, + body: data + }); +} +async function waitToCompleteICEGathering(peerConnection) { + return new Promise((resolve) => { + setTimeout(function() { + resolve(peerConnection.localDescription); + }, 1e3); + peerConnection.onicegatheringstatechange = () => peerConnection.iceGatheringState === "complete" && resolve(peerConnection.localDescription); + }); +} +var WHEPVideoSource = class { + constructor(srcURL, videoTag) { + this.srcURL = srcURL; + this.videoTag = videoTag; + const endpoint = new URL(srcURL); + endpoint.protocol = "https:"; + this.stream = new MediaStream(); + this.peerConnection = new RTCPeerConnection({ + iceServers: [ + { + urls: "stun:stun.cloudflare.com:3478" + } + ], + bundlePolicy: "max-bundle" + }); + this.peerConnection.addTransceiver("video", { + direction: "recvonly" + }); + this.peerConnection.addTransceiver("audio", { + direction: "recvonly" + }); + this.peerConnection.ontrack = (event) => { + const track = event.track; + const currentTracks = this.stream.getTracks(); + const streamAlreadyHasVideoTrack = currentTracks.some((track2) => track2.kind === "video"); + const streamAlreadyHasAudioTrack = currentTracks.some((track2) => track2.kind === "audio"); + switch (track.kind) { + case "video": + if (streamAlreadyHasVideoTrack) { + break; + } + this.stream.addTrack(track); + break; + case "audio": + if (streamAlreadyHasAudioTrack) { + break; + } + this.stream.addTrack(track); + break; + default: + console.warn("got unknown track " + track); + } + }; + this.peerConnection.addEventListener("connectionstatechange", () => { + if (this.peerConnection.connectionState !== "connected") { + return; + } + this.videoTag.srcObject = this.stream; + }); + this.peerConnection.addEventListener("negotiationneeded", async () => { + try { + await negotiateConnectionWithClientOffer(this.peerConnection, endpoint.toString()); + } catch (err) { + console.error("Failed to negotiate with WHEP endpoint", err); + } + }); + } + getContentAddress() { + return this.srcURL.toString(); + } + dispose() { + this.peerConnection.close(); + this.videoTag.srcObject = null; + } + syncVideoSource() { + this.videoTag.play().catch((err) => { + console.error("play error", err); + }); + } + static isWHEPURL(url) { + return url.protocol === "whep:"; + } +}; + +// src/ui/fields.ts +var sourceGroup = { + name: "source", + label: "Source" +}; +var rendererGroup = { + name: "renderer", + label: "Renderer" +}; +var environmentGroup = { + name: "environment", + label: "Environment" +}; +var cameraGroup = { + name: "camera", + label: "Camera" +}; +var lightGroup = { + name: "light", + label: "Light" +}; +var allGroups = [sourceGroup, rendererGroup, cameraGroup, lightGroup, environmentGroup]; +var cameraModeField = { + name: "cameraMode", + label: "Camera Mode", + type: "string", + options: ["orbit", "drag-fly", "none"], + defaultValue: "drag-fly", + groupDefinition: cameraGroup +}; +var cameraOrbitSpeedField = { + name: "cameraOrbitSpeed", + label: "Camera Orbit Speed (degrees per second)", + type: "number", + defaultValue: 10, + groupDefinition: cameraGroup +}; +var cameraOrbitDistanceField = { + name: "cameraOrbitDistance", + label: "Camera Orbit Distance", + type: "number", + defaultValue: 10, + groupDefinition: cameraGroup +}; +var cameraOrbitPitchField = { + name: "cameraOrbitPitch", + label: "Camera Orbit Pitch", + type: "number", + defaultValue: 60, + groupDefinition: cameraGroup +}; +var cameraFitContents = { + name: "cameraFitContents", + label: "Camera Fit Contents", + type: "string", + options: ["true", "false"], + defaultValue: "false", + groupDefinition: cameraGroup +}; +var cameraLookAtField = { + name: "cameraLookAt", + label: "Camera Look At", + type: "x,y,z", + defaultValue: "0,0,0", + groupDefinition: cameraGroup +}; +var cameraPositionField = { + name: "cameraPosition", + label: "Camera Position", + type: "x,y,z", + defaultValue: "0,5,10", + groupDefinition: cameraGroup +}; +var cameraFovField = { + name: "cameraFov", + label: "Camera FOV", + type: "number", + defaultValue: 75, + groupDefinition: cameraGroup +}; +var urlField = { + name: "url", + label: "URL", + type: "string", + defaultValue: "", + requireSubmission: true, + groupDefinition: sourceGroup +}; +var rendererField = { + name: "renderer", + label: "Renderer", + type: "string", + options: ["threejs", "playcanvas", "tags"], + defaultValue: "threejs", + groupDefinition: rendererGroup +}; +var backgroundColorField = { + name: "backgroundColor", + label: "Background Color", + type: "color", + defaultValue: "rgba(255, 255, 255, 0)", + groupDefinition: rendererGroup +}; +var environmentMapField = { + name: "environmentMap", + label: "Environment Map", + type: "string", + defaultValue: "", + requireSubmission: true, + groupDefinition: environmentGroup +}; +var ambientLightField = { + name: "ambientLight", + label: "Ambient Light", + type: "number", + defaultValue: 0, + groupDefinition: lightGroup +}; +var ambientLightColorField = { + name: "ambientLightColor", + label: "Ambient Light Color", + type: "color", + defaultValue: "white", + groupDefinition: lightGroup +}; +var allFields = [ + cameraModeField, + cameraFitContents, + cameraLookAtField, + cameraOrbitDistanceField, + cameraOrbitPitchField, + cameraOrbitSpeedField, + cameraPositionField, + cameraFovField, + environmentMapField, + urlField, + rendererField, + backgroundColorField, + ambientLightField, + ambientLightColorField +]; + +// src/setDebugGlobals.ts +function setDebugGlobals({ + mmlScene, + remoteDocumentWrapper +}) { + window["mml-web-client"] = { + mmlScene, + remoteDocumentWrapper + }; +} + +export { + NetworkedDOMWebsocketStatus, + NetworkedDOMWebsocketStatusToString, + parseColorAttribute, + parseBoolAttribute, + MELEMENT_PROPERTY_NAME, + MElement, + Quat, + Vect3, + Matr4, + CanvasText, + radToDeg, + TransformableElement, + Audio, + Model, + getRelativePositionAndRotationRelativeToObject, + LoadingInstanceManager, + Image, + LightTypes, + registerCustomElementsToWindow, + EventHandlerCollection, + FullScreenMMLScene, + AudioGraphics, + ChatProbeGraphics, + CubeGraphics, + CylinderGraphics, + DebugHelperGraphics, + FrameGraphics, + ImageGraphics, + InteractionGraphics, + LabelGraphics, + LightGraphics, + LinkGraphics, + MElementGraphics, + ModelGraphics, + PlaneGraphics, + PositionProbeGraphics, + PromptGraphics, + RemoteDocumentGraphics, + SphereGraphics, + TransformableGraphics, + VideoGraphics, + IframeWrapper, + MMLNetworkSource, + StatusUI, + StandaloneTagDebugAdapter, + calculateContentSize, + StaticFileVideoSource, + WHEPVideoSource, + allGroups, + cameraModeField, + cameraOrbitSpeedField, + cameraOrbitDistanceField, + cameraOrbitPitchField, + cameraFitContents, + cameraLookAtField, + cameraPositionField, + cameraFovField, + urlField, + rendererField, + backgroundColorField, + environmentMapField, + ambientLightField, + ambientLightColorField, + allFields, + setDebugGlobals +}; +//# sourceMappingURL=chunk-OGDCF6KN.js.map diff --git a/pull/212/v1/chunk-OGDCF6KN.js.map b/pull/212/v1/chunk-OGDCF6KN.js.map new file mode 100644 index 00000000..062dc4ab --- /dev/null +++ b/pull/212/v1/chunk-OGDCF6KN.js.map @@ -0,0 +1,7 @@ +{ + "version": 3, + "sources": ["../../../node_modules/@mml-io/networked-dom-protocol/src/networked-dom-v0.1/constants.ts", "../../../node_modules/@mml-io/networked-dom-protocol/src/networked-dom-v0.2/BufferReader.ts", "../../../node_modules/@mml-io/networked-dom-protocol/src/networked-dom-v0.2/BufferWriter.ts", "../../../node_modules/@mml-io/networked-dom-protocol/src/networked-dom-v0.2/common-structs/attributes.ts", "../../../node_modules/@mml-io/networked-dom-protocol/src/networked-dom-v0.2/common-structs/nodeDescription.ts", "../../../node_modules/@mml-io/networked-dom-protocol/src/networked-dom-v0.2/constants.ts", "../../../node_modules/@mml-io/networked-dom-protocol/src/networked-dom-v0.2/messageTypes.ts", "../../../node_modules/@mml-io/networked-dom-protocol/src/networked-dom-v0.2/messages/from-client/connectUsers.ts", "../../../node_modules/@mml-io/networked-dom-protocol/src/networked-dom-v0.2/messages/from-client/disconnectUsers.ts", "../../../node_modules/@mml-io/networked-dom-protocol/src/networked-dom-v0.2/messages/from-client/event.ts", "../../../node_modules/@mml-io/networked-dom-protocol/src/networked-dom-v0.2/messages/from-client/pong.ts", "../../../node_modules/@mml-io/networked-dom-protocol/src/networked-dom-v0.2/decodeClientMessages.ts", "../../../node_modules/@mml-io/networked-dom-protocol/src/networked-dom-v0.2/messages/from-server/attributesChanged.ts", "../../../node_modules/@mml-io/networked-dom-protocol/src/networked-dom-v0.2/messages/from-server/batchEnd.ts", "../../../node_modules/@mml-io/networked-dom-protocol/src/networked-dom-v0.2/messages/from-server/batchStart.ts", "../../../node_modules/@mml-io/networked-dom-protocol/src/networked-dom-v0.2/messages/from-server/changeHiddenFrom.ts", "../../../node_modules/@mml-io/networked-dom-protocol/src/networked-dom-v0.2/messages/from-server/changeVisibleTo.ts", "../../../node_modules/@mml-io/networked-dom-protocol/src/networked-dom-v0.2/messages/from-server/childrenAdded.ts", "../../../node_modules/@mml-io/networked-dom-protocol/src/networked-dom-v0.2/messages/from-server/childrenRemoved.ts", "../../../node_modules/@mml-io/networked-dom-protocol/src/networked-dom-v0.2/messages/from-server/documentTime.ts", "../../../node_modules/@mml-io/networked-dom-protocol/src/networked-dom-v0.2/messages/from-server/error.ts", "../../../node_modules/@mml-io/networked-dom-protocol/src/networked-dom-v0.2/messages/from-server/ping.ts", "../../../node_modules/@mml-io/networked-dom-protocol/src/networked-dom-v0.2/messages/from-server/snapshot.ts", "../../../node_modules/@mml-io/networked-dom-protocol/src/networked-dom-v0.2/messages/from-server/textChanged.ts", "../../../node_modules/@mml-io/networked-dom-protocol/src/networked-dom-v0.2/messages/from-server/warning.ts", "../../../node_modules/@mml-io/networked-dom-protocol/src/networked-dom-v0.2/decodeServerMessages.ts", "../../../node_modules/@mml-io/networked-dom-protocol/src/networked-dom-v0.2/encodeClientMessage.ts", "../../../node_modules/@mml-io/networked-dom-protocol/src/networked-dom-v0.2/encodeServerMessage.ts", "../../../node_modules/@mml-io/networked-dom-web/src/DOMSanitizer.ts", "../../../node_modules/@mml-io/networked-dom-web/src/NetworkedDOMWebsocket.ts", "../../../node_modules/@mml-io/networked-dom-web/src/NetworkedDOMWebsocketV01Adapter.ts", "../../../node_modules/@mml-io/networked-dom-web/src/NetworkedDOMWebsocketV02Adapter.ts", "../../../node_modules/@mml-io/mml-web/src/color/color-utils.ts", "../../../node_modules/@mml-io/mml-web/src/color/colors.ts", "../../../node_modules/@mml-io/mml-web/src/attributes/attribute-handling.ts", "../../../node_modules/@mml-io/mml-web/src/global/global.ts", "../../../node_modules/@mml-io/mml-web/src/elements/MElement.ts", "../../../node_modules/@mml-io/mml-web/src/elements/AttributeAnimation.ts", "../../../node_modules/@mml-io/mml-web/src/elements/AttributeLerp.ts", "../../../node_modules/@mml-io/mml-web/src/attribute-animation/AnimatedAttributeHelper.ts", "../../../node_modules/@mml-io/mml-web/src/attribute-animation/easingFunctions.ts", "../../../node_modules/@mml-io/mml-web/src/attribute-animation/easings.ts", "../../../node_modules/@mml-io/mml-web/src/attribute-animation/animation-timings.ts", "../../../node_modules/@mml-io/mml-web/src/math/Quat.ts", "../../../node_modules/@mml-io/mml-web/src/math/Vect3.ts", "../../../node_modules/@mml-io/mml-web/src/math/Matr4.ts", "../../../node_modules/@mml-io/mml-web/src/bounding-box/OrientedBoundingBox.ts", "../../../node_modules/@mml-io/mml-web/src/canvas-text/CanvasText.ts", "../../../node_modules/@mml-io/mml-web/src/collision/CollideableHelper.ts", "../../../node_modules/@mml-io/mml-web/src/collision/MMLCollisionTrigger.ts", "../../../node_modules/@mml-io/mml-web/src/debug-helper/DebugHelper.ts", "../../../node_modules/@mml-io/mml-web/src/math/EulXYZ.ts", "../../../node_modules/@mml-io/mml-web/src/math/radToDeg.ts", "../../../node_modules/@mml-io/mml-web/src/elements/TransformableElement.ts", "../../../node_modules/@mml-io/mml-web/src/elements/Audio.ts", "../../../node_modules/@mml-io/mml-web/src/elements/Model.ts", "../../../node_modules/@mml-io/mml-web/src/elements/Character.ts", "../../../node_modules/@mml-io/mml-web/src/position/position-utils.ts", "../../../node_modules/@mml-io/mml-web/src/elements/ChatProbe.ts", "../../../node_modules/@mml-io/mml-web/src/elements/Cube.ts", "../../../node_modules/@mml-io/mml-web/src/elements/Cylinder.ts", "../../../node_modules/@mml-io/mml-web/src/frame/CreateWrappedScene.ts", "../../../node_modules/@mml-io/mml-web/src/loading/LoadingInstanceManager.ts", "../../../node_modules/@mml-io/mml-web/src/loading/LoadingProgressManager.ts", "../../../node_modules/@mml-io/mml-web/src/loading/LoadingProgressBar.ts", "../../../node_modules/@mml-io/mml-web/src/remote-document/fetchRemoteStaticMML.ts", "../../../node_modules/@mml-io/mml-web/src/remote-document/RemoteDocumentWrapper.ts", "../../../node_modules/@mml-io/mml-web/src/frame/StaticHTMLFrameInstance.ts", "../../../node_modules/@mml-io/mml-web/src/frame/WebSocketFrameInstance.ts", "../../../node_modules/@mml-io/mml-web/src/elements/Frame.ts", "../../../node_modules/@mml-io/mml-web/src/elements/Group.ts", "../../../node_modules/@mml-io/mml-web/src/elements/Image.ts", "../../../node_modules/@mml-io/mml-web/src/elements/Interaction.ts", "../../../node_modules/@mml-io/mml-web/src/elements/Label.ts", "../../../node_modules/@mml-io/mml-web/src/elements/Light.ts", "../../../node_modules/@mml-io/mml-web/src/elements/Link.ts", "../../../node_modules/@mml-io/mml-web/src/elements/Plane.ts", "../../../node_modules/@mml-io/mml-web/src/elements/PositionProbe.ts", "../../../node_modules/@mml-io/mml-web/src/elements/Prompt.ts", "../../../node_modules/@mml-io/mml-web/src/time/MMLDocumentTimeManager.ts", "../../../node_modules/@mml-io/mml-web/src/elements/RemoteDocument.ts", "../../../node_modules/@mml-io/mml-web/src/elements/Sphere.ts", "../../../node_modules/@mml-io/mml-web/src/elements/Video.ts", "../../../node_modules/@mml-io/mml-web/src/elements/register-custom-elements.ts", "../../../node_modules/@mml-io/mml-web/src/utils/EventHandlerCollection.ts", "../../../node_modules/@mml-io/mml-web/src/interaction-ui/InteractionManager.ts", "../../../node_modules/@mml-io/mml-web/src/prompt-ui/Modal.ts", "../../../node_modules/@mml-io/mml-web/src/prompt-ui/ConfirmModal.ts", "../../../node_modules/@mml-io/mml-web/src/prompt-ui/PromptModal.ts", "../../../node_modules/@mml-io/mml-web/src/prompt-ui/PromptManager.ts", "../../../node_modules/@mml-io/mml-web/src/scene/MMLScene.ts", "../../../node_modules/@mml-io/mml-web/src/scene/FullScreenMMLScene.ts", "../../../node_modules/@mml-io/mml-web/src/configure-window-for-mml.ts", "../../../node_modules/@mml-io/mml-web/src/graphics/AudioGraphics.ts", "../../../node_modules/@mml-io/mml-web/src/graphics/ChatProbeGraphics.ts", "../../../node_modules/@mml-io/mml-web/src/graphics/CubeGraphics.ts", "../../../node_modules/@mml-io/mml-web/src/graphics/CylinderGraphics.ts", "../../../node_modules/@mml-io/mml-web/src/graphics/DebugHelperGraphics.ts", "../../../node_modules/@mml-io/mml-web/src/graphics/FrameGraphics.ts", "../../../node_modules/@mml-io/mml-web/src/graphics/ImageGraphics.ts", "../../../node_modules/@mml-io/mml-web/src/graphics/InteractionGraphics.ts", "../../../node_modules/@mml-io/mml-web/src/graphics/LabelGraphics.ts", "../../../node_modules/@mml-io/mml-web/src/graphics/LightGraphics.ts", "../../../node_modules/@mml-io/mml-web/src/graphics/LinkGraphics.ts", "../../../node_modules/@mml-io/mml-web/src/graphics/MElementGraphics.ts", "../../../node_modules/@mml-io/mml-web/src/graphics/ModelGraphics.ts", "../../../node_modules/@mml-io/mml-web/src/graphics/PlaneGraphics.ts", "../../../node_modules/@mml-io/mml-web/src/graphics/PositionProbeGraphics.ts", "../../../node_modules/@mml-io/mml-web/src/graphics/PromptGraphics.ts", "../../../node_modules/@mml-io/mml-web/src/graphics/RemoteDocumentGraphics.ts", "../../../node_modules/@mml-io/mml-web/src/graphics/SphereGraphics.ts", "../../../node_modules/@mml-io/mml-web/src/graphics/TransformableGraphics.ts", "../../../node_modules/@mml-io/mml-web/src/graphics/VideoGraphics.ts", "../../../node_modules/@mml-io/mml-web/src/iframe/IframeWrapper.ts", "../../../node_modules/@mml-io/mml-web/src/network/MMLNetworkSource.ts", "../../../node_modules/@mml-io/mml-web/src/status-ui/StatusUI.ts", "../../../node_modules/@mml-io/mml-web/src/tag-debug-adapter/TagAdapterThemeColors.ts", "../../../node_modules/@mml-io/mml-web/src/tag-debug-adapter/TagDebugAdapterDebugHelper.ts", "../../../node_modules/@mml-io/mml-web/src/tag-debug-adapter/TagDebugAdapterElement.ts", "../../../node_modules/@mml-io/mml-web/src/tag-debug-adapter/TagDebugAttribute.ts", "../../../node_modules/@mml-io/mml-web/src/tag-debug-adapter/TagDebugMElement.ts", "../../../node_modules/@mml-io/mml-web/src/tag-debug-adapter/TagDebugAdapterGraphicsInterface.ts", "../../../node_modules/@mml-io/mml-web/src/tag-debug-adapter/StandaloneTagDebugAdapter.ts", "../../../node_modules/@mml-io/mml-web/src/utils/calculateContentSize.ts", "../../../node_modules/@mml-io/mml-web/src/video/StaticFileVideoSource.ts", "../../../node_modules/@mml-io/mml-web/src/video/negotiateConnectionWithClientOffer.ts", "../../../node_modules/@mml-io/mml-web/src/video/WHEPVideoSource.ts", "../../../node_modules/@mml-io/mml-web/src/index.ts", "../src/ui/fields.ts", "../src/setDebugGlobals.ts"], + "sourcesContent": ["export const networkedDOMProtocolSubProtocol_v0_1 = \"networked-dom-v0.1\";\n", "const textDecoder = new TextDecoder();\n\nexport class BufferReader {\n private buffer: Uint8Array;\n private offset: number;\n\n constructor(buffer: Uint8Array) {\n this.buffer = buffer;\n this.offset = 0;\n }\n\n public readUInt8(): number {\n return this.buffer[this.offset++];\n }\n\n public readBoolean(): boolean {\n return this.readUInt8() === 1;\n }\n\n public readUVarint(signed = false): number {\n let lo = 0;\n let hi = 0;\n let i = 0;\n for (; i < 4; ++i) {\n lo = (lo | ((this.buffer[this.offset] & 127) << (i * 7))) >>> 0;\n if (this.buffer[this.offset++] < 128) {\n return signed ? loAndHiAsSigned(lo, hi) : loAndHiAsUnsigned(lo, hi);\n }\n }\n lo = (lo | ((this.buffer[this.offset] & 127) << 28)) >>> 0;\n hi = (hi | ((this.buffer[this.offset] & 127) >> 4)) >>> 0;\n if (this.buffer[this.offset++] < 128) {\n return signed ? loAndHiAsSigned(lo, hi) : loAndHiAsUnsigned(lo, hi);\n }\n i = 0;\n for (; i < 5; ++i) {\n hi = (hi | ((this.buffer[this.offset] & 127) << (i * 7 + 3))) >>> 0;\n if (this.buffer[this.offset++] < 128) {\n return signed ? loAndHiAsSigned(lo, hi) : loAndHiAsUnsigned(lo, hi);\n }\n }\n\n throw Error(\"invalid varint encoding\");\n }\n\n public readUVarintPrefixedString(): string {\n const readLength = this.readUVarint();\n\n let string = \"\";\n let hasNonAscii = false;\n for (let i = 0; i < readLength; i++) {\n const charValue = this.buffer[this.offset + i];\n if (charValue < 0x80) {\n string += String.fromCharCode(charValue);\n } else {\n hasNonAscii = true;\n break;\n }\n }\n if (!hasNonAscii) {\n this.offset += readLength;\n return string;\n }\n\n // Slow path - decode the string using TextDecoder\n const result = textDecoder.decode(this.buffer.subarray(this.offset, this.offset + readLength));\n this.offset += readLength;\n return result;\n }\n\n // returns the string and a boolean indicating if the string was negative length\n public readVarintPrefixedString(): [string, boolean] {\n const length = this.readVarint();\n const negativeLength = length < 0;\n const readLength = negativeLength ? -length : length;\n\n let string = \"\";\n let hasNonAscii = false;\n for (let i = 0; i < readLength; i++) {\n const charValue = this.buffer[this.offset + i];\n if (charValue < 0x80) {\n string += String.fromCharCode(charValue);\n } else {\n hasNonAscii = true;\n break;\n }\n }\n if (!hasNonAscii) {\n this.offset += readLength;\n return [string, negativeLength];\n }\n\n // Slow path - decode the string using TextDecoder\n const result = textDecoder.decode(this.buffer.subarray(this.offset, this.offset + readLength));\n this.offset += readLength;\n return [result, negativeLength];\n }\n\n public readVarint(): number {\n return this.readUVarint(true);\n }\n\n public isEnd() {\n return this.offset >= this.buffer.length;\n }\n}\n\nfunction loAndHiAsSigned(lo: number, hi: number) {\n const value = lo + hi * 4294967296;\n if (value & 1) {\n return -(value + 1) / 2;\n }\n return value / 2;\n}\n\nfunction loAndHiAsUnsigned(lo: number, hi: number) {\n return lo + hi * 4294967296;\n}\n", "const textEncoder = new TextEncoder();\n\nexport class BufferWriter {\n private buffer: Uint8Array;\n private offset: number;\n\n constructor(initialLength: number) {\n this.buffer = new Uint8Array(initialLength);\n this.offset = 0;\n }\n\n // Write an unsigned 8-bit integer\n public writeUint8(value: number): void {\n this.ensureCapacity(1);\n this.buffer[this.offset] = value & 0xff;\n this.offset += 1;\n }\n\n public writeBoolean(bool: boolean) {\n this.writeUint8(bool ? 1 : 0);\n }\n\n // Write an array of bytes\n public writeBytes(bytes: Uint8Array): void {\n this.ensureCapacity(bytes.byteLength);\n this.buffer.set(bytes, this.offset);\n this.offset += bytes.byteLength;\n }\n\n // Get the written bytes as a Uint8Array\n public getBuffer(): Uint8Array {\n return this.buffer.subarray(0, this.offset);\n }\n\n public getWrittenLength(): number {\n return this.offset;\n }\n\n // Ensure there is enough capacity in the buffer\n private ensureCapacity(neededSpace: number): void {\n while (this.offset + neededSpace > this.buffer.length) {\n this.expandBuffer();\n }\n }\n\n // Expand the buffer by doubling its current length\n private expandBuffer(): void {\n const newBuffer = new Uint8Array(this.buffer.length * 2);\n newBuffer.set(this.buffer);\n this.buffer = newBuffer;\n }\n\n public writeUVarint(x: number) {\n if (x <= 268435455) {\n // Simple case that can be handled without hi and lo\n this.ensureCapacity(4);\n while (x >= 0x80) {\n this.buffer[this.offset] = (x & 0x7f) | 0x80; // Extract least significant 7 bits and set continuation bit\n this.offset++;\n x >>>= 7; // Use unsigned shift here\n }\n this.buffer[this.offset] = x & 0x7f; // No need for 0xff here since we're limiting it to 7 bits\n this.offset++;\n return;\n }\n this.ensureCapacity(10);\n\n let lo = 0;\n let hi = 0;\n if (x !== 0) {\n lo = x >>> 0;\n hi = ((x - lo) / 4294967296) >>> 0;\n }\n\n while (hi) {\n this.buffer[this.offset++] = (lo & 127) | 128;\n lo = ((lo >>> 7) | (hi << 25)) >>> 0;\n hi >>>= 7;\n }\n while (lo > 127) {\n this.buffer[this.offset++] = (lo & 127) | 128;\n lo = lo >>> 7;\n }\n this.buffer[this.offset++] = lo;\n }\n\n public writeVarint(x: number) {\n if (x >= 0) {\n this.writeUVarint(x * 2);\n } else {\n this.writeUVarint(-x * 2 - 1);\n }\n }\n\n public writeLengthPrefixedString(value: string, varint = false, negativeLength = false) {\n /*\n Try fast case first - no non-ascii characters and byte length is string length.\n\n Even if this case fails (non-ascii character found) the data will always be\n shorter so it can be overwritten\n */\n const originalOffset = this.offset; // store this in case we need to overwrite from here\n // Just write the length of the string (not the known encoded length)\n if (varint) {\n this.writeVarint(negativeLength ? -value.length : value.length);\n } else {\n this.writeUVarint(value.length);\n }\n this.ensureCapacity(value.length); // Ensure we have enough space for the string\n let nonAscii = false;\n for (let i = 0; i < value.length; i++) {\n const charCode = value.charCodeAt(i);\n if (charCode > 0x7f) {\n nonAscii = true;\n break;\n }\n this.buffer[this.offset++] = charCode;\n }\n\n if (!nonAscii) {\n return;\n }\n\n /*\n If we have non-ascii characters, we need to encode the string respecting\n utf-8 and overwrite the buffer from the original offset\n */\n this.offset = originalOffset; // overwrite the length\n let encodedLength = value.length; // This will be overwritten once we know the actual length\n this.ensureCapacity(encodedLength); // This will be at least the required length, but it gives the chance of initially creating a large enough buffer\n while (true) {\n this.offset = originalOffset;\n if (varint) {\n this.writeVarint(negativeLength ? -encodedLength : encodedLength);\n } else {\n this.writeUVarint(encodedLength);\n }\n const offsetAfterVarint = this.offset;\n const varintLength = offsetAfterVarint - originalOffset;\n\n const writeBuffer = new Uint8Array(this.buffer.buffer, this.offset);\n const { read, written } = textEncoder.encodeInto(value, writeBuffer);\n if (read !== value.length) {\n // Need more space and try again\n this.expandBuffer();\n continue;\n }\n if (written !== encodedLength) {\n encodedLength = written;\n // We need to overwrite the varint with the correct length\n this.offset = originalOffset;\n if (varint) {\n this.writeVarint(negativeLength ? -encodedLength : encodedLength);\n } else {\n this.writeUVarint(encodedLength);\n }\n const newOffsetAfterVarint = this.offset;\n const actualVarintLength = newOffsetAfterVarint - originalOffset;\n if (actualVarintLength !== varintLength) {\n // The varint length changed and it has overwritten the string\n // We need to write the string again\n continue;\n } else {\n // The varint length is the same so the string is intact\n }\n }\n // String written successfully - update the offset\n this.offset += written;\n return;\n }\n }\n}\n", "import { BufferReader } from \"../BufferReader\";\nimport { BufferWriter } from \"../BufferWriter\";\n\nexport function encodeAttribute(writer: BufferWriter, key: string, value: string | null) {\n if (value === null) {\n writer.writeLengthPrefixedString(key, true, true);\n } else {\n writer.writeLengthPrefixedString(key, true, false);\n writer.writeLengthPrefixedString(value);\n }\n}\n\nexport function encodeAttributes(writer: BufferWriter, attributes: Array<[string, string | null]>) {\n writer.writeUVarint(attributes.length);\n\n for (let i = 0; i < attributes.length; i++) {\n encodeAttribute(writer, attributes[i][0], attributes[i][1]);\n }\n}\n\nexport function decodeAttributes(buffer: BufferReader): Array<[string, string | null]> {\n const attributesLength = buffer.readUVarint();\n const attributes: Array<[string, string | null]> = [];\n for (let i = 0; i < attributesLength; i++) {\n const [key, negativeLength] = buffer.readVarintPrefixedString();\n if (negativeLength) {\n attributes.push([key, null]);\n continue;\n }\n const value = buffer.readUVarintPrefixedString();\n attributes.push([key, value]);\n }\n return attributes;\n}\n", "import { BufferReader } from \"../BufferReader\";\nimport { BufferWriter } from \"../BufferWriter\";\nimport { decodeAttributes, encodeAttributes } from \"./attributes\";\n\nexport type NetworkedDOMV02TextNodeDescription = {\n type: \"text\";\n nodeId: number;\n text: string;\n};\n\nexport type NetworkedDOMV02ElementNodeDescription = {\n type: \"element\";\n nodeId: number;\n tag: string;\n attributes: Array<[string, string | null]>;\n children: Array;\n visibleTo?: Array;\n hiddenFrom?: Array;\n text?: string;\n};\n\nexport type NetworkedDOMV02NodeDescription =\n | NetworkedDOMV02ElementNodeDescription\n | NetworkedDOMV02TextNodeDescription;\n\nexport function encodeNodeDescription(\n writer: BufferWriter,\n nodeDescription: NetworkedDOMV02NodeDescription,\n): void {\n writer.writeUVarint(nodeDescription.nodeId);\n\n if (nodeDescription.type === \"text\") {\n writer.writeLengthPrefixedString(\"\"); // Empty tag indicates text node\n writer.writeLengthPrefixedString(nodeDescription.text);\n return;\n }\n\n writer.writeLengthPrefixedString(nodeDescription.tag);\n\n encodeAttributes(writer, nodeDescription.attributes);\n\n if (!nodeDescription.visibleTo) {\n writer.writeUVarint(0);\n } else {\n writer.writeUVarint(nodeDescription.visibleTo.length);\n for (let i = 0; i < nodeDescription.visibleTo.length; i++) {\n writer.writeUVarint(nodeDescription.visibleTo[i]);\n }\n }\n\n if (!nodeDescription.hiddenFrom) {\n writer.writeUVarint(0);\n } else {\n writer.writeUVarint(nodeDescription.hiddenFrom.length);\n for (let i = 0; i < nodeDescription.hiddenFrom.length; i++) {\n writer.writeUVarint(nodeDescription.hiddenFrom[i]);\n }\n }\n\n writer.writeUVarint(nodeDescription.children.length);\n for (let i = 0; i < nodeDescription.children.length; i++) {\n encodeNodeDescription(writer, nodeDescription.children[i]);\n }\n}\n\nexport function decodeNodeDescription(buffer: BufferReader): NetworkedDOMV02NodeDescription {\n const nodeId = buffer.readUVarint();\n const tag = buffer.readUVarintPrefixedString();\n if (tag === \"\") {\n // Text node\n const text = buffer.readUVarintPrefixedString();\n return { type: \"text\", nodeId, text };\n }\n\n const attributes = decodeAttributes(buffer);\n\n const visibleToLength = buffer.readUVarint();\n let visibleTo: number[] | undefined;\n if (visibleToLength !== 0) {\n visibleTo = [];\n for (let i = 0; i < visibleToLength; i++) {\n visibleTo.push(buffer.readUVarint());\n }\n }\n\n const hiddenFromLength = buffer.readUVarint();\n let hiddenFrom: number[] | undefined;\n if (hiddenFromLength !== 0) {\n hiddenFrom = [];\n for (let i = 0; i < hiddenFromLength; i++) {\n hiddenFrom.push(buffer.readUVarint());\n }\n }\n\n const childrenLength = buffer.readUVarint();\n const children: NetworkedDOMV02NodeDescription[] = [];\n for (let i = 0; i < childrenLength; i++) {\n children.push(decodeNodeDescription(buffer));\n }\n\n const node: NetworkedDOMV02ElementNodeDescription = {\n type: \"element\",\n nodeId,\n tag,\n attributes,\n children,\n };\n\n if (visibleTo) {\n node.visibleTo = visibleTo;\n }\n if (hiddenFrom) {\n node.hiddenFrom = hiddenFrom;\n }\n\n return node;\n}\n", "export const networkedDOMProtocolSubProtocol_v0_2 = \"networked-dom-v0.2\";\n", "// Server -> Client\nexport const SnapshotMessageType = 1;\nexport const BatchStartMessageType = 2;\nexport const DocumentTimeMessageType = 3;\nexport const ChildrenAddedMessageType = 4;\nexport const ChildrenRemovedMessageType = 5;\nexport const AttributesChangedMessageType = 6;\nexport const ChangeVisibleToMessageType = 7;\nexport const ChangeHiddenFromMessageType = 8;\nexport const TextChangedMessageType = 9;\nexport const BatchEndMessageType = 10;\nexport const PingMessageType = 11;\nexport const WarningMessageType = 12;\nexport const ErrorMessageType = 13;\n\n// Client -> Server\nexport const ConnectUsersMessageType = 14;\nexport const DisconnectUsersMessageType = 15;\nexport const EventMessageType = 16;\nexport const PongMessageType = 17;\n", "import { BufferReader } from \"../../BufferReader\";\nimport { BufferWriter } from \"../../BufferWriter\";\nimport { ConnectUsersMessageType } from \"../../messageTypes\";\n\nexport type NetworkedDOMV02ConnectUsersMessage = {\n type: \"connectUsers\";\n connectionIds: Array;\n};\n\nexport function encodeConnectUsers(\n connectUsersMessage: NetworkedDOMV02ConnectUsersMessage,\n writer: BufferWriter,\n) {\n const connectionIdsLength = connectUsersMessage.connectionIds.length;\n writer.writeUint8(ConnectUsersMessageType);\n writer.writeUVarint(connectionIdsLength);\n for (let i = 0; i < connectionIdsLength; i++) {\n writer.writeUVarint(connectUsersMessage.connectionIds[i]);\n }\n}\n\n// Assumes that the first byte has already been read (the message type)\nexport function decodeConnectUsers(buffer: BufferReader): NetworkedDOMV02ConnectUsersMessage {\n const connectionIds: number[] = [];\n const connectionIdsLength = buffer.readUVarint();\n for (let i = 0; i < connectionIdsLength; i++) {\n connectionIds.push(buffer.readUVarint());\n }\n return {\n type: \"connectUsers\",\n connectionIds,\n };\n}\n", "import { BufferReader } from \"../../BufferReader\";\nimport { BufferWriter } from \"../../BufferWriter\";\nimport { DisconnectUsersMessageType } from \"../../messageTypes\";\n\nexport type NetworkedDOMV02DisconnectUsersMessage = {\n type: \"disconnectUsers\";\n connectionIds: Array;\n};\n\nexport function encodeDisconnectUsers(\n disconnectUsersMessage: NetworkedDOMV02DisconnectUsersMessage,\n writer: BufferWriter,\n) {\n const connectionIdsLength = disconnectUsersMessage.connectionIds.length;\n writer.writeUint8(DisconnectUsersMessageType);\n writer.writeUVarint(connectionIdsLength);\n for (let i = 0; i < connectionIdsLength; i++) {\n writer.writeUVarint(disconnectUsersMessage.connectionIds[i]);\n }\n}\n\n// Assumes that the first byte has already been read (the message type)\nexport function decodeDisconnectUsers(buffer: BufferReader): NetworkedDOMV02DisconnectUsersMessage {\n const connectionIds: number[] = [];\n const connectionIdsLength = buffer.readUVarint();\n for (let i = 0; i < connectionIdsLength; i++) {\n connectionIds.push(buffer.readUVarint());\n }\n return {\n type: \"disconnectUsers\",\n connectionIds,\n };\n}\n", "import { BufferReader } from \"../../BufferReader\";\nimport { BufferWriter } from \"../../BufferWriter\";\nimport { EventMessageType } from \"../../messageTypes\";\n\nexport type NetworkedDOMV02RemoteEvent = {\n type: \"event\";\n connectionId: number;\n nodeId: number;\n name: string;\n bubbles: boolean;\n params: any;\n};\n\nexport function encodeEvent(event: NetworkedDOMV02RemoteEvent, writer: BufferWriter) {\n writer.writeUint8(EventMessageType);\n writer.writeUVarint(event.nodeId);\n writer.writeUVarint(event.connectionId);\n writer.writeLengthPrefixedString(event.name);\n writer.writeBoolean(event.bubbles);\n writer.writeLengthPrefixedString(JSON.stringify(event.params));\n}\n\n// Assumes that the first byte has already been read (the message type)\nexport function decodeEvent(buffer: BufferReader): NetworkedDOMV02RemoteEvent {\n const nodeId = buffer.readUVarint();\n const connectionId = buffer.readUVarint();\n const name = buffer.readUVarintPrefixedString();\n const bubbles = buffer.readBoolean();\n const paramsJSONString = buffer.readUVarintPrefixedString();\n const params = JSON.parse(paramsJSONString);\n return {\n type: \"event\",\n nodeId,\n connectionId,\n name,\n bubbles,\n params,\n };\n}\n", "import { BufferReader } from \"../../BufferReader\";\nimport { BufferWriter } from \"../../BufferWriter\";\nimport { PongMessageType } from \"../../messageTypes\";\n\nexport type NetworkedDOMV02PongMessage = {\n type: \"pong\";\n pong: number;\n};\n\nexport function encodePong(pongMessage: NetworkedDOMV02PongMessage, writer: BufferWriter) {\n writer.writeUint8(PongMessageType);\n writer.writeUVarint(pongMessage.pong);\n}\n\n// Assumes that the first byte has already been read (the message type)\nexport function decodePong(buffer: BufferReader): NetworkedDOMV02PongMessage {\n const pong = buffer.readUVarint();\n return {\n type: \"pong\",\n pong,\n };\n}\n", "import { BufferReader } from \"./BufferReader\";\nimport { NetworkedDOMV02ClientMessage } from \"./messages\";\nimport { decodeConnectUsers } from \"./messages/from-client/connectUsers\";\nimport { decodeDisconnectUsers } from \"./messages/from-client/disconnectUsers\";\nimport { decodeEvent } from \"./messages/from-client/event\";\nimport { decodePong } from \"./messages/from-client/pong\";\nimport {\n ConnectUsersMessageType,\n DisconnectUsersMessageType,\n EventMessageType,\n PongMessageType,\n} from \"./messageTypes\";\n\nexport function decodeClientMessages(buffer: BufferReader): Array {\n const messages: NetworkedDOMV02ClientMessage[] = [];\n while (!buffer.isEnd()) {\n const messageType = buffer.readUInt8();\n switch (messageType) {\n case ConnectUsersMessageType:\n messages.push(decodeConnectUsers(buffer));\n break;\n case DisconnectUsersMessageType:\n messages.push(decodeDisconnectUsers(buffer));\n break;\n case EventMessageType:\n messages.push(decodeEvent(buffer));\n break;\n case PongMessageType:\n messages.push(decodePong(buffer));\n break;\n default:\n throw new Error(`Unknown message type: ${messageType}`);\n }\n }\n return messages;\n}\n", "import { BufferReader } from \"../../BufferReader\";\nimport { BufferWriter } from \"../../BufferWriter\";\nimport { decodeAttributes, encodeAttributes } from \"../../common-structs/attributes\";\nimport { AttributesChangedMessageType } from \"../../messageTypes\";\n\nexport type NetworkedDOMV02AttributesChangedDiff = {\n type: \"attributesChanged\";\n nodeId: number;\n attributes: Array<[string, string | null]>;\n documentTime?: number;\n};\n\nexport function encodeAttributesChanged(\n msg: NetworkedDOMV02AttributesChangedDiff,\n writer: BufferWriter = new BufferWriter(64),\n): BufferWriter {\n writer.writeUint8(AttributesChangedMessageType);\n writer.writeUVarint(msg.nodeId);\n encodeAttributes(writer, msg.attributes);\n return writer;\n}\n\n// Assumes that the first byte has already been read (the message type)\nexport function decodeAttributesChanged(\n buffer: BufferReader,\n): NetworkedDOMV02AttributesChangedDiff {\n const nodeId = buffer.readUVarint();\n const attributes = decodeAttributes(buffer);\n return {\n type: \"attributesChanged\",\n nodeId,\n attributes,\n };\n}\n", "import { BufferWriter } from \"../../BufferWriter\";\nimport { BatchEndMessageType } from \"../../messageTypes\";\n\nexport type NetworkedDOMV02BatchEndMessage = {\n type: \"batchEnd\";\n};\n\nexport function encodeBatchEnd(writer: BufferWriter = new BufferWriter(1)): BufferWriter {\n writer.writeUint8(BatchEndMessageType);\n return writer;\n}\n\nexport const batchEndMessage: NetworkedDOMV02BatchEndMessage = {\n type: \"batchEnd\",\n};\n", "import { BufferWriter } from \"../../BufferWriter\";\nimport { BatchStartMessageType } from \"../../messageTypes\";\n\nexport type NetworkedDOMV02BatchStartMessage = {\n type: \"batchStart\";\n};\n\nexport function encodeBatchStart(writer: BufferWriter = new BufferWriter(1)): BufferWriter {\n writer.writeUint8(BatchStartMessageType);\n return writer;\n}\n\nexport const batchStartMessage: NetworkedDOMV02BatchStartMessage = {\n type: \"batchStart\",\n};\n", "import { BufferReader } from \"../../BufferReader\";\nimport { BufferWriter } from \"../../BufferWriter\";\nimport { ChangeHiddenFromMessageType } from \"../../messageTypes\";\n\nexport type NetworkedDOMV02ChangeHiddenFromDiff = {\n type: \"changeHiddenFrom\";\n nodeId: number;\n addHiddenFrom: Array;\n removeHiddenFrom: Array;\n};\n\nexport function encodeChangeHiddenFrom(\n msg: NetworkedDOMV02ChangeHiddenFromDiff,\n writer: BufferWriter = new BufferWriter(64),\n): BufferWriter {\n writer.writeUint8(ChangeHiddenFromMessageType);\n writer.writeUVarint(msg.nodeId);\n\n if (msg.addHiddenFrom) {\n writer.writeUVarint(msg.addHiddenFrom.length);\n\n for (const key of msg.addHiddenFrom) {\n writer.writeUVarint(key);\n }\n } else {\n // If there are no addHiddenFrom, we still need to send a 0 to indicate that there are no entries\n writer.writeUVarint(0);\n }\n if (msg.removeHiddenFrom) {\n writer.writeUVarint(msg.removeHiddenFrom.length);\n\n for (const key of msg.removeHiddenFrom) {\n writer.writeUVarint(key);\n }\n } else {\n // If there are no removeHiddenFrom, we still need to send a 0 to indicate that there are no entries\n writer.writeUVarint(0);\n }\n return writer;\n}\n\n// Assumes that the first byte has already been read (the message type)\nexport function decodeChangeHiddenFrom(buffer: BufferReader): NetworkedDOMV02ChangeHiddenFromDiff {\n const nodeId = buffer.readUVarint();\n const addHiddenFromLength = buffer.readUVarint();\n const addHiddenFrom: number[] = [];\n for (let i = 0; i < addHiddenFromLength; i++) {\n addHiddenFrom.push(buffer.readUVarint());\n }\n\n const removeHiddenFromLength = buffer.readUVarint();\n const removeHiddenFrom: number[] = [];\n for (let i = 0; i < removeHiddenFromLength; i++) {\n removeHiddenFrom.push(buffer.readUVarint());\n }\n\n return {\n type: \"changeHiddenFrom\",\n nodeId,\n addHiddenFrom,\n removeHiddenFrom,\n };\n}\n", "import { BufferReader } from \"../../BufferReader\";\nimport { BufferWriter } from \"../../BufferWriter\";\nimport { ChangeVisibleToMessageType } from \"../../messageTypes\";\n\nexport type NetworkedDOMV02ChangeVisibleToDiff = {\n type: \"changeVisibleTo\";\n nodeId: number;\n /*\n The semantics are that if there are no visibleTo limitations then the node is visible to everyone.\n\n It is advisable to apply the addVisibleTo first before the removeVisibleTo to avoid even a temporary state where a node is visible to everyone between the two operations.\n */\n addVisibleTo: Array;\n removeVisibleTo: Array;\n};\n\nexport function encodeChangeVisibleTo(\n msg: NetworkedDOMV02ChangeVisibleToDiff,\n writer: BufferWriter = new BufferWriter(64),\n): BufferWriter {\n writer.writeUint8(ChangeVisibleToMessageType);\n writer.writeUVarint(msg.nodeId);\n\n if (msg.addVisibleTo) {\n writer.writeUVarint(msg.addVisibleTo.length);\n\n for (const key of msg.addVisibleTo) {\n writer.writeUVarint(key);\n }\n } else {\n // If there are no addVisibleTo, we still need to send a 0 to indicate that there are no entries\n writer.writeUVarint(0);\n }\n if (msg.removeVisibleTo) {\n writer.writeUVarint(msg.removeVisibleTo.length);\n\n for (const key of msg.removeVisibleTo) {\n writer.writeUVarint(key);\n }\n } else {\n // If there are no removeVisibleTo, we still need to send a 0 to indicate that there are no entries\n writer.writeUVarint(0);\n }\n return writer;\n}\n\n// Assumes that the first byte has already been read (the message type)\nexport function decodeChangeVisibleTo(buffer: BufferReader): NetworkedDOMV02ChangeVisibleToDiff {\n const nodeId = buffer.readUVarint();\n const addVisibleToLength = buffer.readUVarint();\n const addVisibleTo: number[] = [];\n for (let i = 0; i < addVisibleToLength; i++) {\n addVisibleTo.push(buffer.readUVarint());\n }\n\n const removeVisibleToLength = buffer.readUVarint();\n const removeVisibleTo: number[] = [];\n for (let i = 0; i < removeVisibleToLength; i++) {\n removeVisibleTo.push(buffer.readUVarint());\n }\n\n return {\n type: \"changeVisibleTo\",\n nodeId,\n addVisibleTo,\n removeVisibleTo,\n };\n}\n", "import { BufferReader } from \"../../BufferReader\";\nimport { BufferWriter } from \"../../BufferWriter\";\nimport {\n decodeNodeDescription,\n encodeNodeDescription,\n NetworkedDOMV02NodeDescription,\n} from \"../../common-structs/nodeDescription\";\nimport { ChildrenAddedMessageType } from \"../../messageTypes\";\n\nexport type NetworkedDOMV02ChildrenAddedDiff = {\n type: \"childrenAdded\";\n nodeId: number;\n previousNodeId: number | null;\n addedNodes: Array;\n};\n\nexport function encodeChildrenAdded(\n msg: NetworkedDOMV02ChildrenAddedDiff,\n writer: BufferWriter = new BufferWriter(64),\n): BufferWriter {\n writer.writeUint8(ChildrenAddedMessageType);\n writer.writeUVarint(msg.nodeId);\n writer.writeUVarint(msg.previousNodeId ?? 0);\n writer.writeUVarint(msg.addedNodes.length);\n for (let i = 0; i < msg.addedNodes.length; i++) {\n encodeNodeDescription(writer, msg.addedNodes[i]);\n }\n return writer;\n}\n\n// Assumes that the first byte has already been read (the message type)\nexport function decodeChildrenAdded(buffer: BufferReader): NetworkedDOMV02ChildrenAddedDiff {\n const nodeId = buffer.readUVarint();\n const previousNodeId = buffer.readUVarint();\n const childrenLength = buffer.readUVarint();\n const children: NetworkedDOMV02NodeDescription[] = [];\n for (let i = 0; i < childrenLength; i++) {\n children.push(decodeNodeDescription(buffer));\n }\n return {\n type: \"childrenAdded\",\n nodeId,\n previousNodeId: previousNodeId === 0 ? null : previousNodeId,\n addedNodes: children,\n };\n}\n", "import { BufferReader } from \"../../BufferReader\";\nimport { BufferWriter } from \"../../BufferWriter\";\nimport { ChildrenRemovedMessageType } from \"../../messageTypes\";\n\nexport type NetworkedDOMV02ChildrenRemovedDiff = {\n type: \"childrenRemoved\";\n nodeId: number;\n removedNodes: Array;\n documentTime?: number;\n};\n\nexport function encodeChildrenRemoved(\n msg: NetworkedDOMV02ChildrenRemovedDiff,\n writer: BufferWriter = new BufferWriter(64),\n): BufferWriter {\n writer.writeUint8(ChildrenRemovedMessageType);\n writer.writeUVarint(msg.nodeId);\n writer.writeUVarint(msg.removedNodes.length);\n for (const nodeId of msg.removedNodes) {\n writer.writeUVarint(nodeId);\n }\n return writer;\n}\n\n// Assumes that the first byte has already been read (the message type)\nexport function decodeChildrenRemoved(buffer: BufferReader): NetworkedDOMV02ChildrenRemovedDiff {\n const nodeId = buffer.readUVarint();\n const removedNodesLength = buffer.readUVarint();\n const removedNodes: number[] = [];\n for (let i = 0; i < removedNodesLength; i++) {\n removedNodes.push(buffer.readUVarint());\n }\n return {\n type: \"childrenRemoved\",\n nodeId,\n removedNodes,\n };\n}\n", "import { BufferReader } from \"../../BufferReader\";\nimport { BufferWriter } from \"../../BufferWriter\";\nimport { DocumentTimeMessageType } from \"../../messageTypes\";\n\nexport type NetworkedDOMV02DocumentTimeMessage = {\n type: \"documentTime\";\n documentTime: number;\n};\n\nexport function encodeDocumentTime(\n msg: NetworkedDOMV02DocumentTimeMessage,\n writer: BufferWriter = new BufferWriter(8),\n): BufferWriter {\n writer.writeUint8(DocumentTimeMessageType);\n writer.writeUVarint(msg.documentTime);\n return writer;\n}\n\n// Assumes that the first byte has already been read (the message type)\nexport function decodeDocumentTime(buffer: BufferReader): NetworkedDOMV02DocumentTimeMessage {\n return {\n type: \"documentTime\",\n documentTime: buffer.readUVarint(),\n };\n}\n", "import { BufferReader } from \"../../BufferReader\";\nimport { BufferWriter } from \"../../BufferWriter\";\nimport { ErrorMessageType } from \"../../messageTypes\";\n\nexport type NetworkedDOMV02ErrorMessage = {\n type: \"error\";\n message: string;\n};\n\nexport function encodeError(\n msg: NetworkedDOMV02ErrorMessage,\n writer: BufferWriter = new BufferWriter(64),\n): BufferWriter {\n writer.writeUint8(ErrorMessageType);\n writer.writeLengthPrefixedString(msg.message);\n return writer;\n}\n\n// Assumes that the first byte has already been read (the message type)\nexport function decodeError(buffer: BufferReader): NetworkedDOMV02ErrorMessage {\n const message = buffer.readUVarintPrefixedString();\n return {\n type: \"error\",\n message,\n };\n}\n", "import { BufferReader } from \"../../BufferReader\";\nimport { BufferWriter } from \"../../BufferWriter\";\nimport { PingMessageType } from \"../../messageTypes\";\n\nexport type NetworkedDOMV02PingMessage = {\n type: \"ping\";\n ping: number;\n documentTime: number;\n};\n\nexport function encodePing(\n pingMessage: NetworkedDOMV02PingMessage,\n writer: BufferWriter = new BufferWriter(8),\n): BufferWriter {\n writer.writeUint8(PingMessageType);\n writer.writeUVarint(pingMessage.ping);\n writer.writeUVarint(pingMessage.documentTime);\n return writer;\n}\n\n// Assumes that the first byte has already been read (the message type)\nexport function decodePing(buffer: BufferReader): NetworkedDOMV02PingMessage {\n const ping = buffer.readUVarint();\n const documentTime = buffer.readUVarint();\n return {\n type: \"ping\",\n ping,\n documentTime,\n };\n}\n", "import { BufferReader } from \"../../BufferReader\";\nimport { BufferWriter } from \"../../BufferWriter\";\nimport {\n decodeNodeDescription,\n encodeNodeDescription,\n NetworkedDOMV02ElementNodeDescription,\n NetworkedDOMV02NodeDescription,\n} from \"../../common-structs/nodeDescription\";\nimport { SnapshotMessageType } from \"../../messageTypes\";\n\nexport type NetworkedDOMV02SnapshotMessage = {\n type: \"snapshot\";\n snapshot: NetworkedDOMV02NodeDescription;\n documentTime: number;\n};\n\nexport function encodeSnapshot(\n msg: NetworkedDOMV02SnapshotMessage,\n writer: BufferWriter = new BufferWriter(64),\n): BufferWriter {\n writer.writeUint8(SnapshotMessageType);\n encodeNodeDescription(writer, msg.snapshot as NetworkedDOMV02ElementNodeDescription);\n writer.writeUVarint(msg.documentTime);\n return writer;\n}\n\n// Assumes that the first byte has already been read (the message type)\nexport function decodeSnapshot(buffer: BufferReader): NetworkedDOMV02SnapshotMessage {\n return {\n type: \"snapshot\",\n snapshot: decodeNodeDescription(buffer),\n documentTime: buffer.readUVarint(),\n };\n}\n", "import { BufferReader } from \"../../BufferReader\";\nimport { BufferWriter } from \"../../BufferWriter\";\nimport { TextChangedMessageType } from \"../../messageTypes\";\n\nexport type NetworkedDOMV02TextChangedDiff = {\n type: \"textChanged\";\n nodeId: number;\n text: string;\n};\n\nexport function encodeTextChanged(\n msg: NetworkedDOMV02TextChangedDiff,\n writer: BufferWriter = new BufferWriter(64),\n): BufferWriter {\n writer.writeUint8(TextChangedMessageType);\n writer.writeUVarint(msg.nodeId);\n writer.writeLengthPrefixedString(msg.text);\n return writer;\n}\n\n// Assumes that the first byte has already been read (the message type)\nexport function decodeTextChanged(buffer: BufferReader): NetworkedDOMV02TextChangedDiff {\n const nodeId = buffer.readUVarint();\n const text = buffer.readUVarintPrefixedString();\n return {\n type: \"textChanged\",\n nodeId,\n text,\n };\n}\n", "import { BufferReader } from \"../../BufferReader\";\nimport { BufferWriter } from \"../../BufferWriter\";\nimport { WarningMessageType } from \"../../messageTypes\";\n\nexport type NetworkedDOMV02WarningMessage = {\n type: \"warning\";\n message: string;\n};\n\nexport function encodeWarning(\n msg: NetworkedDOMV02WarningMessage,\n writer: BufferWriter = new BufferWriter(64),\n): BufferWriter {\n writer.writeUint8(WarningMessageType);\n writer.writeLengthPrefixedString(msg.message);\n return writer;\n}\n\n// Assumes that the first byte has already been read (the message type)\nexport function decodeWarning(buffer: BufferReader): NetworkedDOMV02WarningMessage {\n const message = buffer.readUVarintPrefixedString();\n return {\n type: \"warning\",\n message,\n };\n}\n", "import { BufferReader } from \"./BufferReader\";\nimport {\n batchEndMessage,\n batchStartMessage,\n decodeAttributesChanged,\n decodeChangeHiddenFrom,\n decodeChangeVisibleTo,\n decodeChildrenAdded,\n decodeChildrenRemoved,\n decodeError,\n decodePing,\n decodeSnapshot,\n decodeTextChanged,\n decodeWarning,\n NetworkedDOMV02ServerMessage,\n} from \"./messages\";\nimport { decodeDocumentTime } from \"./messages/from-server/documentTime\";\nimport {\n AttributesChangedMessageType,\n BatchEndMessageType,\n BatchStartMessageType,\n ChangeHiddenFromMessageType,\n ChangeVisibleToMessageType,\n ChildrenAddedMessageType,\n ChildrenRemovedMessageType,\n DocumentTimeMessageType,\n ErrorMessageType,\n PingMessageType,\n SnapshotMessageType,\n TextChangedMessageType,\n WarningMessageType,\n} from \"./messageTypes\";\n\nexport function decodeServerMessages(buffer: BufferReader): Array {\n const messages: NetworkedDOMV02ServerMessage[] = [];\n while (!buffer.isEnd()) {\n const messageType = buffer.readUInt8();\n switch (messageType) {\n case SnapshotMessageType:\n messages.push(decodeSnapshot(buffer));\n break;\n case DocumentTimeMessageType:\n messages.push(decodeDocumentTime(buffer));\n break;\n case ChildrenAddedMessageType:\n messages.push(decodeChildrenAdded(buffer));\n break;\n case ChildrenRemovedMessageType:\n messages.push(decodeChildrenRemoved(buffer));\n break;\n case AttributesChangedMessageType:\n messages.push(decodeAttributesChanged(buffer));\n break;\n case TextChangedMessageType:\n messages.push(decodeTextChanged(buffer));\n break;\n case ChangeVisibleToMessageType:\n messages.push(decodeChangeVisibleTo(buffer));\n break;\n case ChangeHiddenFromMessageType:\n messages.push(decodeChangeHiddenFrom(buffer));\n break;\n case BatchStartMessageType:\n messages.push(batchStartMessage);\n break;\n case BatchEndMessageType:\n messages.push(batchEndMessage);\n break;\n case PingMessageType:\n messages.push(decodePing(buffer));\n break;\n case WarningMessageType:\n messages.push(decodeWarning(buffer));\n break;\n case ErrorMessageType:\n messages.push(decodeError(buffer));\n break;\n default:\n throw new Error(`Unknown message type: ${messageType}`);\n }\n }\n return messages;\n}\n", "import { BufferWriter } from \"./BufferWriter\";\nimport {\n encodeConnectUsers,\n encodeDisconnectUsers,\n encodeEvent,\n encodePong,\n NetworkedDOMV02ClientMessage,\n} from \"./messages\";\n\nexport function encodeClientMessage(message: NetworkedDOMV02ClientMessage, writer: BufferWriter) {\n const type = message.type;\n switch (type) {\n case \"connectUsers\":\n return encodeConnectUsers(message, writer);\n case \"disconnectUsers\":\n return encodeDisconnectUsers(message, writer);\n case \"event\":\n return encodeEvent(message, writer);\n case \"pong\":\n return encodePong(message, writer);\n default:\n throw new Error(`Unknown message type: ${type}`);\n }\n}\n", "import { BufferWriter } from \"./BufferWriter\";\nimport {\n encodeBatchEnd,\n encodeBatchStart,\n encodeTextChanged,\n NetworkedDOMV02ServerMessage,\n} from \"./messages\";\nimport { encodeAttributesChanged } from \"./messages/from-server/attributesChanged\";\nimport { encodeChangeHiddenFrom } from \"./messages/from-server/changeHiddenFrom\";\nimport { encodeChangeVisibleTo } from \"./messages/from-server/changeVisibleTo\";\nimport { encodeChildrenAdded } from \"./messages/from-server/childrenAdded\";\nimport { encodeChildrenRemoved } from \"./messages/from-server/childrenRemoved\";\nimport { encodeDocumentTime } from \"./messages/from-server/documentTime\";\nimport { encodeError } from \"./messages/from-server/error\";\nimport { encodePing } from \"./messages/from-server/ping\";\nimport { encodeSnapshot } from \"./messages/from-server/snapshot\";\nimport { encodeWarning } from \"./messages/from-server/warning\";\n\nexport function encodeServerMessage(\n message: NetworkedDOMV02ServerMessage,\n writer?: BufferWriter,\n): BufferWriter {\n switch (message.type) {\n case \"snapshot\":\n return encodeSnapshot(message, writer);\n case \"documentTime\":\n return encodeDocumentTime(message, writer);\n case \"childrenAdded\":\n return encodeChildrenAdded(message, writer);\n case \"childrenRemoved\":\n return encodeChildrenRemoved(message, writer);\n case \"attributesChanged\":\n return encodeAttributesChanged(message, writer);\n case \"textChanged\":\n return encodeTextChanged(message, writer);\n case \"changeVisibleTo\":\n return encodeChangeVisibleTo(message, writer);\n case \"changeHiddenFrom\":\n return encodeChangeHiddenFrom(message, writer);\n case \"batchStart\":\n return encodeBatchStart(writer);\n case \"batchEnd\":\n return encodeBatchEnd(writer);\n case \"ping\":\n return encodePing(message, writer);\n case \"warning\":\n return encodeWarning(message, writer);\n case \"error\":\n return encodeError(message, writer);\n default:\n throw new Error(`Unknown message type: ${(message as any).type}`);\n }\n}\n", "export type DOMSanitizerOptions = {\n tagPrefix?: string; // e.g. \"m-\" to restrict to only custom elements with a tag name starting with \"m-\"\n replacementTagPrefix?: string; // e.g. \"x-\" to replace non-prefixed tags with a new prefix (e.g. \"div\" -> \"x-div\")\n};\n\nexport class DOMSanitizer {\n static sanitise(node: HTMLElement, options: DOMSanitizerOptions = {}) {\n if (node.getAttributeNames) {\n for (const attr of node.getAttributeNames()) {\n if (!DOMSanitizer.IsValidAttributeName(attr)) {\n node.removeAttribute(attr);\n }\n }\n }\n\n if (node instanceof HTMLElement) {\n if (options.tagPrefix) {\n const tag = node.nodeName.toLowerCase();\n if (!tag.startsWith(options.tagPrefix.toLowerCase())) {\n node = DOMSanitizer.replaceNodeTagName(\n node,\n options.replacementTagPrefix ? options.replacementTagPrefix + tag : `x-${tag}`,\n );\n }\n }\n }\n\n if (node.nodeName === \"SCRIPT\" || node.nodeName === \"OBJECT\" || node.nodeName === \"IFRAME\") {\n // set contents to empty string\n node.innerHTML = \"\";\n DOMSanitizer.stripAllAttributes(node);\n } else {\n if (node.getAttributeNames) {\n for (const attr of node.getAttributeNames()) {\n if (!DOMSanitizer.shouldAcceptAttribute(attr)) {\n node.removeAttribute(attr);\n }\n }\n }\n for (let i = 0; i < node.childNodes.length; i++) {\n DOMSanitizer.sanitise(node.childNodes[i] as HTMLElement, options);\n }\n }\n return node;\n }\n\n static replaceNodeTagName(node: HTMLElement, newTagName: string) {\n const replacementNode = document.createElement(newTagName);\n let index;\n while (node.firstChild) {\n replacementNode.appendChild(node.firstChild);\n }\n for (index = node.attributes.length - 1; index >= 0; --index) {\n replacementNode.setAttribute(node.attributes[index].name, node.attributes[index].value);\n }\n node.parentNode?.replaceChild(replacementNode, node);\n return replacementNode;\n }\n\n static stripAllAttributes(node: HTMLElement) {\n if (node.getAttributeNames) {\n for (const attr of node.getAttributeNames()) {\n node.removeAttribute(attr);\n }\n }\n }\n\n static IsASCIIDigit(c: string): boolean {\n return c >= \"0\" && c <= \"9\";\n }\n\n static IsASCIIAlpha(c: string) {\n return c >= \"a\" && c <= \"z\";\n }\n\n static IsValidAttributeName(characters: string): boolean {\n const c = characters[0];\n if (!(DOMSanitizer.IsASCIIAlpha(c) || c === \":\" || c === \"_\")) {\n return false;\n }\n\n for (let i = 1; i < characters.length; i++) {\n const c = characters[i];\n if (\n !(\n DOMSanitizer.IsASCIIDigit(c) ||\n DOMSanitizer.IsASCIIAlpha(c) ||\n c === \":\" ||\n c === \"_\" ||\n c === \"-\" ||\n c === \".\"\n )\n ) {\n return false;\n }\n }\n\n return true;\n }\n\n static shouldAcceptAttribute(attribute: string) {\n if (!DOMSanitizer.IsValidAttributeName(attribute)) {\n console.warn(\"Invalid attribute name\", attribute);\n return false;\n }\n\n // TODO - this might be overly restrictive - apologies to someone that finds this because you have a non-event attribute filtered by this\n return !attribute.startsWith(\"on\");\n }\n}\n", "import {\n networkedDOMProtocolSubProtocol_v0_1,\n networkedDOMProtocolSubProtocol_v0_2,\n} from \"@mml-io/networked-dom-protocol\";\n\nimport { NetworkedDOMWebsocketV01Adapter } from \"./NetworkedDOMWebsocketV01Adapter\";\nimport { NetworkedDOMWebsocketV02Adapter } from \"./NetworkedDOMWebsocketV02Adapter\";\n\nconst startingBackoffTimeMilliseconds = 100;\nconst maximumBackoffTimeMilliseconds = 10000;\nconst maximumWebsocketConnectionTimeout = 5000;\n\nexport type NetworkedDOMWebsocketFactory = (url: string) => WebSocket;\n\nexport enum NetworkedDOMWebsocketStatus {\n Connecting,\n ConnectionOpen, // The websocket is open and connected, but no messages have been received yet\n Connected, // The websocket is open and connected, and messages are being received\n Reconnecting,\n Disconnected,\n}\n\nexport function NetworkedDOMWebsocketStatusToString(status: NetworkedDOMWebsocketStatus): string {\n switch (status) {\n case NetworkedDOMWebsocketStatus.Connecting:\n return \"Connecting...\";\n case NetworkedDOMWebsocketStatus.ConnectionOpen:\n return \"Connection Open\";\n case NetworkedDOMWebsocketStatus.Connected:\n return \"Connected\";\n case NetworkedDOMWebsocketStatus.Reconnecting:\n return \"Reconnecting...\";\n case NetworkedDOMWebsocketStatus.Disconnected:\n return \"Disconnected\";\n default:\n return \"Unknown\";\n }\n}\n\nexport type NetworkedDOMWebsocketOptions = {\n tagPrefix?: string; // e.g. \"m-\" to restrict to only custom elements with a tag name starting with \"m-\"\n replacementTagPrefix?: string; // e.g. \"x-\" to replace non-prefixed tags with a new prefix (e.g. \"div\" -> \"x-div\")\n};\n\nexport type NetworkedDOMWebsocketAdapter = {\n receiveMessage: (message: MessageEvent) => void;\n handleEvent: (element: HTMLElement, event: CustomEvent<{ element: HTMLElement }>) => void;\n clearContents: () => boolean;\n};\n\n/**\n * NetworkedDOMWebsocket is a client for a NetworkedDOMServer. It connects to a server on the provided url and receives\n * updates to the DOM. It also sends events to the server for interactions with the DOM.\n *\n * The NetworkedDOMWebsocket is attached to a parentElement and synchronizes the received DOM under that element.\n */\nexport class NetworkedDOMWebsocket {\n private websocket: WebSocket | null = null;\n private websocketAdapter: NetworkedDOMWebsocketAdapter | null = null;\n\n private stopped = false;\n private backoffTime = startingBackoffTimeMilliseconds;\n private status: NetworkedDOMWebsocketStatus | null = null;\n\n public static createWebSocket(url: string): WebSocket {\n return new WebSocket(url, [\n networkedDOMProtocolSubProtocol_v0_2,\n networkedDOMProtocolSubProtocol_v0_1,\n ]);\n }\n\n constructor(\n private url: string,\n private websocketFactory: NetworkedDOMWebsocketFactory,\n private parentElement: HTMLElement,\n private timeCallback?: (time: number) => void,\n private statusUpdateCallback?: (status: NetworkedDOMWebsocketStatus) => void,\n private options: NetworkedDOMWebsocketOptions = {},\n ) {\n this.setStatus(NetworkedDOMWebsocketStatus.Connecting);\n this.startWebSocketConnectionAttempt();\n }\n\n private setStatus(status: NetworkedDOMWebsocketStatus) {\n if (this.status !== status) {\n this.status = status;\n if (this.statusUpdateCallback) {\n this.statusUpdateCallback(status);\n }\n }\n }\n\n private createWebsocketWithTimeout(timeout: number): Promise {\n return new Promise((resolve, reject) => {\n const timeoutId = setTimeout(() => {\n reject(new Error(\"websocket connection timed out\"));\n }, timeout);\n const websocket = this.websocketFactory(this.url);\n websocket.binaryType = \"arraybuffer\";\n websocket.addEventListener(\"open\", () => {\n clearTimeout(timeoutId);\n\n this.websocket = websocket;\n const isV02 = websocket.protocol === networkedDOMProtocolSubProtocol_v0_2;\n let websocketAdapter: NetworkedDOMWebsocketAdapter;\n if (isV02) {\n websocketAdapter = new NetworkedDOMWebsocketV02Adapter(\n websocket,\n this.parentElement,\n () => {\n this.backoffTime = startingBackoffTimeMilliseconds;\n this.setStatus(NetworkedDOMWebsocketStatus.Connected);\n },\n this.timeCallback,\n this.options,\n );\n } else {\n websocketAdapter = new NetworkedDOMWebsocketV01Adapter(\n websocket,\n this.parentElement,\n () => {\n this.backoffTime = startingBackoffTimeMilliseconds;\n this.setStatus(NetworkedDOMWebsocketStatus.Connected);\n },\n this.timeCallback,\n this.options,\n );\n }\n this.websocketAdapter = websocketAdapter;\n\n websocket.addEventListener(\"message\", (event) => {\n if (websocket !== this.websocket) {\n console.log(\"Ignoring websocket message event because it is no longer current\");\n websocket.close();\n return;\n }\n websocketAdapter.receiveMessage(event);\n });\n\n const onWebsocketClose = async () => {\n let hadContents = false;\n if (this.websocketAdapter) {\n hadContents = this.websocketAdapter.clearContents();\n }\n if (this.stopped) {\n // This closing is expected. The client closed the websocket.\n this.setStatus(NetworkedDOMWebsocketStatus.Disconnected);\n return;\n }\n if (!hadContents) {\n // The websocket did not deliver any contents. It may have been successfully opened, but immediately closed. This client should back off to prevent this happening in a rapid loop.\n await this.waitBackoffTime();\n }\n // The websocket closed unexpectedly. Try to reconnect.\n this.setStatus(NetworkedDOMWebsocketStatus.Reconnecting);\n this.startWebSocketConnectionAttempt();\n };\n\n websocket.addEventListener(\"close\", () => {\n if (websocket !== this.websocket) {\n console.warn(\"Ignoring websocket close event because it is no longer current\");\n return;\n }\n onWebsocketClose();\n });\n websocket.addEventListener(\"error\", (e) => {\n if (websocket !== this.websocket) {\n console.log(\"Ignoring websocket error event because it is no longer current\");\n return;\n }\n console.error(\"NetworkedDOMWebsocket error\", e);\n onWebsocketClose();\n });\n\n this.setStatus(NetworkedDOMWebsocketStatus.ConnectionOpen);\n resolve(websocket);\n });\n websocket.addEventListener(\"error\", (e) => {\n clearTimeout(timeoutId);\n reject(e);\n });\n });\n }\n\n private async waitBackoffTime(): Promise {\n console.warn(`Websocket connection to '${this.url}' failed: retrying in ${this.backoffTime}ms`);\n await new Promise((resolve) => setTimeout(resolve, this.backoffTime));\n this.backoffTime = Math.min(\n // Introduce a small amount of randomness to prevent clients from retrying in lockstep\n this.backoffTime * (1.5 + Math.random() * 0.5),\n maximumBackoffTimeMilliseconds,\n );\n }\n\n private async startWebSocketConnectionAttempt() {\n if (this.stopped) {\n return;\n }\n while (true) {\n if (this.stopped) {\n return;\n }\n try {\n await this.createWebsocketWithTimeout(maximumWebsocketConnectionTimeout);\n break;\n } catch (e) {\n console.error(\"Websocket connection failed\", e);\n // Connection failed, retry with backoff\n this.setStatus(NetworkedDOMWebsocketStatus.Reconnecting);\n await this.waitBackoffTime();\n }\n }\n }\n\n public stop() {\n this.stopped = true;\n if (this.websocket !== null) {\n this.websocket.close();\n this.websocket = null;\n }\n }\n\n public handleEvent(element: HTMLElement, event: CustomEvent<{ element: HTMLElement }>) {\n if (this.websocketAdapter) {\n this.websocketAdapter.handleEvent(element, event);\n }\n }\n}\n\nexport function isHTMLElement(node: unknown, rootNode: HTMLElement): node is HTMLElement {\n if (node instanceof HTMLElement) {\n return true;\n }\n if (!rootNode.ownerDocument.defaultView) {\n return false;\n }\n return node instanceof rootNode.ownerDocument.defaultView.HTMLElement;\n}\n\nexport function isText(node: unknown, rootNode: HTMLElement): node is Text {\n if (node instanceof Text) {\n return true;\n }\n if (!rootNode.ownerDocument.defaultView) {\n return false;\n }\n return node instanceof rootNode.ownerDocument.defaultView.Text;\n}\n", "import {\n NetworkedDOMV01AttributeChangedDiff,\n NetworkedDOMV01ChildrenChangedDiff,\n NetworkedDOMV01ClientMessage,\n NetworkedDOMV01NodeDescription,\n NetworkedDOMV01RemoteEvent,\n NetworkedDOMV01ServerMessage,\n NetworkedDOMV01SnapshotMessage,\n NetworkedDOMV01TextChangedDiff,\n} from \"@mml-io/networked-dom-protocol\";\n\nimport { DOMSanitizer } from \"./DOMSanitizer\";\nimport {\n isHTMLElement,\n isText,\n NetworkedDOMWebsocketAdapter,\n NetworkedDOMWebsocketOptions,\n} from \"./NetworkedDOMWebsocket\";\n\nexport class NetworkedDOMWebsocketV01Adapter implements NetworkedDOMWebsocketAdapter {\n private idToElement = new Map();\n private elementToId = new Map();\n private currentRoot: HTMLElement | null = null;\n\n constructor(\n private websocket: WebSocket,\n private parentElement: HTMLElement,\n private connectedCallback: () => void,\n private timeCallback?: (time: number) => void,\n private options: NetworkedDOMWebsocketOptions = {},\n ) {\n this.websocket.binaryType = \"arraybuffer\";\n }\n\n public handleEvent(element: HTMLElement, event: CustomEvent<{ element: HTMLElement }>) {\n const nodeId = this.elementToId.get(element);\n if (nodeId === undefined || nodeId === null) {\n throw new Error(\"Element not found\");\n }\n\n const detailWithoutElement: Partial = {\n ...event.detail,\n };\n delete detailWithoutElement.element;\n\n const remoteEvent: NetworkedDOMV01RemoteEvent = {\n type: \"event\",\n nodeId,\n name: event.type,\n bubbles: event.bubbles,\n params: detailWithoutElement,\n };\n\n this.send(remoteEvent);\n }\n\n private send(fromClientMessage: NetworkedDOMV01ClientMessage) {\n this.websocket.send(JSON.stringify(fromClientMessage));\n }\n\n public clearContents(): boolean {\n this.idToElement.clear();\n this.elementToId.clear();\n if (this.currentRoot) {\n this.currentRoot.remove();\n this.currentRoot = null;\n return true;\n }\n return false;\n }\n\n receiveMessage(event: MessageEvent) {\n const messages = JSON.parse(event.data) as Array;\n for (const message of messages) {\n switch (message.type) {\n case \"error\":\n console.error(\"Error from server\", message);\n break;\n case \"warning\":\n console.warn(\"Warning from server\", message);\n break;\n default: {\n if (message.documentTime) {\n if (this.timeCallback) {\n this.timeCallback(message.documentTime);\n }\n }\n switch (message.type) {\n case \"snapshot\":\n this.handleSnapshot(message);\n this.connectedCallback();\n break;\n case \"attributeChange\":\n this.handleAttributeChange(message);\n break;\n case \"childrenChanged\":\n this.handleChildrenChanged(message);\n break;\n case \"textChanged\":\n this.handleTextChanged(message);\n break;\n case \"ping\":\n this.send({\n type: \"pong\",\n pong: message.ping,\n });\n break;\n default:\n console.warn(\"unknown message type\", message);\n break;\n }\n }\n }\n }\n }\n\n private handleTextChanged(message: NetworkedDOMV01TextChangedDiff) {\n const { nodeId, text } = message;\n\n if (nodeId === undefined || nodeId === null) {\n console.warn(\"No nodeId in textChanged message\");\n return;\n }\n const node = this.idToElement.get(nodeId);\n if (!node) {\n throw new Error(\"No node found for textChanged message\");\n }\n if (!isText(node, this.parentElement)) {\n throw new Error(\"Node for textChanged message is not a Text node\");\n }\n node.textContent = text;\n }\n\n private handleChildrenChanged(message: NetworkedDOMV01ChildrenChangedDiff) {\n const { nodeId, addedNodes, removedNodes, previousNodeId } = message;\n if (nodeId === undefined || nodeId === null) {\n console.warn(\"No nodeId in childrenChanged message\");\n return;\n }\n const parent = this.idToElement.get(nodeId);\n if (!parent) {\n throw new Error(\"No parent found for childrenChanged message\");\n }\n if (!parent.isConnected) {\n console.error(\"Parent is not connected\", parent);\n }\n if (!isHTMLElement(parent, this.parentElement)) {\n throw new Error(\"Parent is not an HTMLElement (that supports children)\");\n }\n let nextElement = null;\n let previousElement = null;\n if (previousNodeId) {\n previousElement = this.idToElement.get(previousNodeId);\n if (!previousElement) {\n throw new Error(\"No previous element found for childrenChanged message\");\n }\n nextElement = previousElement.nextSibling;\n }\n\n const elementsToAdd = [];\n for (const addedNode of addedNodes) {\n const childElement = this.handleNewElement(addedNode);\n if (childElement) {\n elementsToAdd.push(childElement);\n }\n }\n if (elementsToAdd.length) {\n if (previousElement) {\n if (nextElement) {\n // There is a previous and next element - insertBefore the next element\n const docFrag = new DocumentFragment();\n docFrag.append(...elementsToAdd);\n parent.insertBefore(docFrag, nextElement);\n } else {\n // No next element - must be the last children\n parent.append(...elementsToAdd);\n }\n } else {\n // No previous element - must be the first children\n parent.prepend(...elementsToAdd);\n }\n }\n for (const removedNode of removedNodes) {\n const childElement = this.idToElement.get(removedNode);\n if (!childElement) {\n throw new Error(`Child element not found: ${removedNode}`);\n }\n this.elementToId.delete(childElement);\n this.idToElement.delete(removedNode);\n parent.removeChild(childElement);\n if (isHTMLElement(childElement, this.parentElement)) {\n // If child is capable of supporting children then remove any that exist\n this.removeChildElementIds(childElement);\n }\n }\n }\n\n private removeChildElementIds(parent: HTMLElement) {\n for (let i = 0; i < parent.children.length; i++) {\n const child = parent.children[i];\n const childId = this.elementToId.get(child as HTMLElement);\n if (!childId) {\n console.error(\"Inner child of removed element had no id\", child);\n } else {\n this.elementToId.delete(child);\n this.idToElement.delete(childId);\n }\n this.removeChildElementIds(child as HTMLElement);\n }\n }\n\n private handleSnapshot(message: NetworkedDOMV01SnapshotMessage) {\n // This websocket is successfully connected. Reset the backoff time.\n if (this.currentRoot) {\n this.currentRoot.remove();\n this.currentRoot = null;\n this.elementToId.clear();\n this.idToElement.clear();\n }\n\n // create a tree of DOM elements\n // NOTE: the MElement constructors are not executed during this stage\n const element = this.handleNewElement(message.snapshot);\n if (!element) {\n throw new Error(\"Snapshot element not created\");\n }\n if (!isHTMLElement(element, this.parentElement)) {\n throw new Error(\"Snapshot element is not an HTMLElement\");\n }\n this.currentRoot = element;\n // appending to the tree causes MElements to be constructed\n this.parentElement.append(element);\n }\n\n private handleAttributeChange(message: NetworkedDOMV01AttributeChangedDiff) {\n const { nodeId, attribute, newValue } = message;\n if (nodeId === undefined || nodeId === null) {\n console.warn(\"No nodeId in attributeChange message\");\n return;\n }\n const element = this.idToElement.get(nodeId);\n if (element) {\n if (isHTMLElement(element, this.parentElement)) {\n if (newValue === null) {\n element.removeAttribute(attribute);\n } else {\n if (DOMSanitizer.shouldAcceptAttribute(attribute)) {\n element.setAttribute(attribute, newValue);\n }\n }\n } else {\n console.error(\"Element is not an HTMLElement and cannot support attributes\", element);\n }\n } else {\n console.error(\"No element found for attributeChange message\");\n }\n }\n\n private handleNewElement(message: NetworkedDOMV01NodeDescription): Node | null {\n if (message.type === \"text\") {\n const { nodeId, text } = message;\n const textNode = document.createTextNode(\"\");\n textNode.textContent = text;\n this.idToElement.set(nodeId, textNode);\n this.elementToId.set(textNode, nodeId);\n return textNode;\n }\n const { tag, nodeId, attributes, children, text } = message;\n if (nodeId === undefined || nodeId === null) {\n console.warn(\"No nodeId in handleNewElement message\", message);\n return null;\n }\n if (this.idToElement.has(nodeId)) {\n console.error(\n \"Received nodeId to add that is already present\",\n nodeId,\n this.idToElement.get(nodeId),\n );\n }\n if (tag === \"#text\") {\n const textNode = document.createTextNode(\"\");\n textNode.textContent = text || null;\n this.idToElement.set(nodeId, textNode);\n this.elementToId.set(textNode, nodeId);\n return textNode;\n }\n\n let element;\n try {\n let filteredTag = tag;\n if (this.options.tagPrefix) {\n if (!tag.toLowerCase().startsWith(this.options.tagPrefix.toLowerCase())) {\n filteredTag = this.options.replacementTagPrefix\n ? this.options.replacementTagPrefix + tag\n : `x-${tag}`;\n }\n }\n element = document.createElement(filteredTag);\n } catch (e) {\n console.error(`Error creating element: (${tag})`, e);\n element = document.createElement(\"x-div\");\n }\n this.idToElement.set(nodeId, element);\n this.elementToId.set(element, nodeId);\n for (const key in attributes) {\n if (DOMSanitizer.shouldAcceptAttribute(key)) {\n const value = attributes[key];\n element.setAttribute(key, value);\n }\n }\n if (children) {\n for (const child of children) {\n const childElement = this.handleNewElement(child);\n if (childElement) {\n element.append(childElement);\n }\n }\n }\n return element;\n }\n}\n", "import {\n BufferReader,\n BufferWriter,\n decodeServerMessages,\n encodeClientMessage,\n NetworkedDOMV02AttributesChangedDiff,\n NetworkedDOMV02ChangeHiddenFromDiff,\n NetworkedDOMV02ChildrenAddedDiff,\n NetworkedDOMV02ChildrenRemovedDiff,\n NetworkedDOMV02ClientMessage,\n NetworkedDOMV02DocumentTimeMessage,\n NetworkedDOMV02NodeDescription,\n NetworkedDOMV02PingMessage,\n NetworkedDOMV02RemoteEvent,\n NetworkedDOMV02ServerMessage,\n NetworkedDOMV02SnapshotMessage,\n NetworkedDOMV02TextChangedDiff,\n} from \"@mml-io/networked-dom-protocol\";\n\nimport { DOMSanitizer } from \"./DOMSanitizer\";\nimport {\n isHTMLElement,\n isText,\n NetworkedDOMWebsocketAdapter,\n NetworkedDOMWebsocketOptions,\n} from \"./NetworkedDOMWebsocket\";\n\n// This client uses a single connection id\nconst connectionId = 1;\n\n// If an element should not be visible to this client, it will be replaced with this tag and attributes will be stored ready to be applied if it is unhidden.\nconst hiddenTag = \"x-hidden\";\n\nexport class NetworkedDOMWebsocketV02Adapter implements NetworkedDOMWebsocketAdapter {\n private idToElement = new Map();\n private elementToId = new Map();\n private hiddenPlaceholderElements = new Map<\n number,\n {\n placeholder: Node;\n element: Node;\n }\n >();\n private currentRoot: HTMLElement | null = null;\n private batchMode = false;\n private batchMessages: Array = [];\n\n constructor(\n private websocket: WebSocket,\n private parentElement: HTMLElement,\n private connectedCallback: () => void,\n private timeCallback?: (time: number) => void,\n private options: NetworkedDOMWebsocketOptions = {},\n ) {\n this.websocket.binaryType = \"arraybuffer\";\n this.send({ type: \"connectUsers\", connectionIds: [connectionId] });\n }\n\n public handleEvent(element: HTMLElement, event: CustomEvent<{ element: HTMLElement }>) {\n const nodeId = this.elementToId.get(element);\n if (nodeId === undefined || nodeId === null) {\n throw new Error(\"Element not found\");\n }\n\n const detailWithoutElement: Partial = {\n ...event.detail,\n };\n delete detailWithoutElement.element;\n\n const remoteEvent: NetworkedDOMV02RemoteEvent = {\n type: \"event\",\n nodeId,\n connectionId,\n name: event.type,\n bubbles: event.bubbles,\n params: detailWithoutElement,\n };\n\n this.send(remoteEvent);\n }\n\n private send(message: NetworkedDOMV02ClientMessage) {\n const writer = new BufferWriter(256);\n encodeClientMessage(message, writer);\n this.websocket.send(writer.getBuffer());\n }\n\n public clearContents(): boolean {\n this.idToElement.clear();\n this.elementToId.clear();\n if (this.currentRoot) {\n this.currentRoot.remove();\n this.currentRoot = null;\n return true;\n }\n return false;\n }\n\n public receiveMessage(event: MessageEvent) {\n const reader = new BufferReader(new Uint8Array(event.data));\n const messages = decodeServerMessages(reader);\n for (const message of messages) {\n if (message.type === \"batchStart\") {\n // Need to wait for batchEnd before applying messages\n this.batchMode = true;\n } else if (message.type === \"batchEnd\") {\n // Apply all messages\n this.batchMode = false;\n for (const message of this.batchMessages) {\n this.applyMessage(message);\n }\n this.batchMessages = [];\n } else {\n if (this.batchMode) {\n this.batchMessages.push(message);\n } else {\n this.applyMessage(message);\n }\n }\n }\n }\n\n private applyMessage(message: NetworkedDOMV02ServerMessage) {\n switch (message.type) {\n case \"error\":\n console.error(\"Error from server\", message);\n break;\n case \"warning\":\n console.warn(\"Warning from server\", message);\n break;\n case \"snapshot\":\n this.handleSnapshot(message);\n this.connectedCallback();\n break;\n case \"attributesChanged\":\n this.handleAttributeChange(message);\n break;\n case \"documentTime\":\n this.handleDocumentTime(message);\n break;\n case \"childrenAdded\":\n this.handleChildrenAdded(message);\n break;\n case \"changeHiddenFrom\":\n this.handleChangeHiddenFrom(message);\n break;\n case \"childrenRemoved\":\n this.handleChildrenRemoved(message);\n break;\n case \"textChanged\":\n this.handleTextChanged(message);\n break;\n case \"ping\":\n this.handlePing(message);\n break;\n default:\n console.warn(\"unknown message type\", message);\n break;\n }\n }\n\n private handleTextChanged(message: NetworkedDOMV02TextChangedDiff) {\n const { nodeId, text } = message;\n\n if (nodeId === undefined || nodeId === null) {\n console.warn(\"No nodeId in textChanged message\");\n return;\n }\n const node = this.idToElement.get(nodeId);\n if (!node) {\n throw new Error(\"No node found for textChanged message\");\n }\n if (!isText(node, this.parentElement)) {\n throw new Error(\"Node for textChanged message is not a Text node\");\n }\n node.textContent = text;\n }\n\n private handleChangeHiddenFrom(message: NetworkedDOMV02ChangeHiddenFromDiff) {\n const { nodeId, addHiddenFrom, removeHiddenFrom } = message;\n const node = this.idToElement.get(nodeId);\n const hiddenElement = this.hiddenPlaceholderElements.get(nodeId);\n if (addHiddenFrom.length > 0 && addHiddenFrom.indexOf(connectionId) !== -1) {\n // This element is being hidden\n if (hiddenElement) {\n // This element is already hidden\n return;\n }\n if (!node) {\n throw new Error(\"No node found for changeHiddenFrom message\");\n }\n const parent = node.parentElement;\n if (!parent) {\n throw new Error(\"Node has no parent\");\n }\n const placeholder = document.createElement(hiddenTag);\n parent.replaceChild(placeholder, node);\n this.hiddenPlaceholderElements.set(nodeId, { placeholder, element: node });\n } else if (removeHiddenFrom.length > 0 && removeHiddenFrom.indexOf(connectionId) !== -1) {\n // This element is being unhidden\n if (!hiddenElement) {\n // This element is not hidden\n return;\n }\n const { placeholder, element } = hiddenElement;\n const parent = placeholder.parentElement;\n if (!parent) {\n throw new Error(\"Placeholder has no parent\");\n }\n parent.replaceChild(element, placeholder);\n this.hiddenPlaceholderElements.delete(nodeId);\n }\n }\n\n private handleChildrenAdded(message: NetworkedDOMV02ChildrenAddedDiff) {\n const { nodeId, addedNodes, previousNodeId } = message;\n if (nodeId === undefined || nodeId === null) {\n console.warn(\"No nodeId in childrenChanged message\");\n return;\n }\n let parent = this.idToElement.get(nodeId);\n if (!parent) {\n throw new Error(\"No parent found for childrenChanged message\");\n }\n\n const hiddenParent = this.hiddenPlaceholderElements.get(nodeId);\n if (hiddenParent) {\n // This element is hidden - add the children to the hidden element (not the placeholder)\n parent = hiddenParent.element;\n } else {\n if (!parent.isConnected) {\n console.error(\"Parent is not connected\", parent);\n }\n }\n if (!isHTMLElement(parent, this.parentElement)) {\n throw new Error(\"Parent is not an HTMLElement (that supports children)\");\n }\n let nextElement = null;\n let previousElement = null;\n if (previousNodeId) {\n previousElement = this.idToElement.get(previousNodeId);\n if (!previousElement) {\n throw new Error(\"No previous element found for childrenChanged message\");\n }\n nextElement = previousElement.nextSibling;\n }\n\n const elementsToAdd = [];\n for (const addedNode of addedNodes) {\n const childElement = this.handleNewElement(addedNode);\n if (childElement) {\n elementsToAdd.push(childElement);\n }\n }\n if (elementsToAdd.length) {\n if (previousElement) {\n if (nextElement) {\n // There is a previous and next element - insertBefore the next element\n const docFrag = new DocumentFragment();\n docFrag.append(...elementsToAdd);\n parent.insertBefore(docFrag, nextElement);\n } else {\n // No next element - must be the last children\n parent.append(...elementsToAdd);\n }\n } else {\n // No previous element - must be the first children\n parent.prepend(...elementsToAdd);\n }\n }\n }\n\n private handleChildrenRemoved(message: NetworkedDOMV02ChildrenRemovedDiff) {\n const { nodeId, removedNodes } = message;\n if (nodeId === undefined || nodeId === null) {\n console.warn(\"No nodeId in childrenChanged message\");\n return;\n }\n const parent = this.idToElement.get(nodeId);\n if (!parent) {\n throw new Error(\"No parent found for childrenChanged message\");\n }\n if (!parent.isConnected) {\n console.error(\"Parent is not connected\", parent);\n }\n if (!isHTMLElement(parent, this.parentElement)) {\n throw new Error(\"Parent is not an HTMLElement (that supports children)\");\n }\n\n for (const removedNode of removedNodes) {\n const childElement = this.idToElement.get(removedNode);\n if (!childElement) {\n throw new Error(`Child element not found: ${removedNode}`);\n }\n this.elementToId.delete(childElement);\n this.idToElement.delete(removedNode);\n this.hiddenPlaceholderElements.delete(removedNode);\n parent.removeChild(childElement);\n if (isHTMLElement(childElement, this.parentElement)) {\n // If child is capable of supporting children then remove any that exist\n this.removeChildElementIds(childElement);\n }\n }\n }\n\n private removeChildElementIds(parent: HTMLElement) {\n for (let i = 0; i < parent.children.length; i++) {\n const child = parent.children[i];\n const childId = this.elementToId.get(child as HTMLElement);\n if (!childId) {\n console.error(\"Inner child of removed element had no id\", child);\n } else {\n this.elementToId.delete(child);\n this.idToElement.delete(childId);\n this.hiddenPlaceholderElements.delete(childId);\n }\n this.removeChildElementIds(child as HTMLElement);\n }\n }\n\n private handleSnapshot(message: NetworkedDOMV02SnapshotMessage) {\n // This websocket is successfully connected. Reset the backoff time.\n if (this.currentRoot) {\n this.currentRoot.remove();\n this.currentRoot = null;\n this.elementToId.clear();\n this.idToElement.clear();\n }\n\n this.timeCallback?.(message.documentTime);\n\n // create a tree of DOM elements\n // NOTE: the MElement constructors are not executed during this stage\n const element = this.handleNewElement(message.snapshot);\n if (!element) {\n throw new Error(\"Snapshot element not created\");\n }\n if (!isHTMLElement(element, this.parentElement)) {\n throw new Error(\"Snapshot element is not an HTMLElement\");\n }\n this.currentRoot = element;\n // appending to the tree causes MElements to be constructed\n this.parentElement.append(element);\n }\n\n private handleDocumentTime(message: NetworkedDOMV02DocumentTimeMessage) {\n this.timeCallback?.(message.documentTime);\n }\n\n private handleAttributeChange(message: NetworkedDOMV02AttributesChangedDiff) {\n const { nodeId, attributes } = message;\n if (nodeId === undefined || nodeId === null) {\n console.warn(\"No nodeId in attributeChange message\");\n return;\n }\n let element = this.idToElement.get(nodeId);\n const hiddenElement = this.hiddenPlaceholderElements.get(nodeId);\n if (hiddenElement) {\n // This element is hidden - apply the attributes to the hidden element\n element = hiddenElement.element;\n }\n if (element) {\n if (isHTMLElement(element, this.parentElement)) {\n for (const [key, newValue] of attributes) {\n if (newValue === null) {\n element.removeAttribute(key);\n } else {\n if (DOMSanitizer.shouldAcceptAttribute(key)) {\n element.setAttribute(key, newValue);\n }\n }\n }\n } else {\n console.error(\"Element is not an HTMLElement and cannot support attributes\", element);\n }\n } else {\n console.error(\"No element found for attributeChange message\");\n }\n }\n\n private handleNewElement(message: NetworkedDOMV02NodeDescription): Node | null {\n if (message.type === \"text\") {\n const { nodeId, text } = message;\n const textNode = document.createTextNode(\"\");\n textNode.textContent = text;\n this.idToElement.set(nodeId, textNode);\n this.elementToId.set(textNode, nodeId);\n return textNode;\n }\n const { tag, nodeId, attributes, children, text, hiddenFrom } = message;\n if (this.idToElement.has(nodeId)) {\n console.error(\n \"Received nodeId to add that is already present\",\n nodeId,\n this.idToElement.get(nodeId),\n );\n return null;\n }\n\n if (tag === \"#text\") {\n const textNode = document.createTextNode(\"\");\n textNode.textContent = text || null;\n this.idToElement.set(nodeId, textNode);\n this.elementToId.set(textNode, nodeId);\n return textNode;\n }\n\n let element;\n try {\n let filteredTag = tag;\n if (this.options.tagPrefix) {\n if (!tag.toLowerCase().startsWith(this.options.tagPrefix.toLowerCase())) {\n filteredTag = this.options.replacementTagPrefix\n ? this.options.replacementTagPrefix + tag\n : `x-${tag}`;\n }\n }\n element = document.createElement(filteredTag);\n } catch (e) {\n console.error(`Error creating element: (${tag})`, e);\n element = document.createElement(\"x-div\");\n }\n for (const [key, value] of attributes) {\n if (value !== null) {\n if (DOMSanitizer.shouldAcceptAttribute(key)) {\n element.setAttribute(key, value);\n }\n }\n }\n if (children) {\n for (const child of children) {\n const childElement = this.handleNewElement(child);\n if (childElement) {\n element.append(childElement);\n }\n }\n }\n\n if (hiddenFrom && hiddenFrom.length > 0 && hiddenFrom.indexOf(connectionId) !== -1) {\n // This element is hidden - create a placeholder that will be in the DOM to maintain structure, but keep the underlying element hidden\n const placeholder = document.createElement(hiddenTag);\n this.idToElement.set(nodeId, placeholder);\n this.elementToId.set(placeholder, nodeId);\n this.hiddenPlaceholderElements.set(nodeId, { placeholder, element });\n return placeholder;\n } else {\n this.idToElement.set(nodeId, element);\n this.elementToId.set(element, nodeId);\n return element;\n }\n }\n\n private handlePing(message: NetworkedDOMV02PingMessage) {\n this.timeCallback?.(message.documentTime);\n this.send({\n type: \"pong\",\n pong: message.ping,\n });\n }\n}\n", "import { MMLColor } from \"./MMLColor\";\n\nexport function lerpHSL(colorA: MMLColor, colorB: MMLColor, alpha: number): MMLColor {\n const hslA = getHSL(colorA);\n const hslB = getHSL(colorB);\n const h = hslA.h + (hslB.h - hslA.h) * alpha;\n const s = hslA.s + (hslB.s - hslA.s) * alpha;\n const l = hslA.l + (hslB.l - hslA.l) * alpha;\n return hslToRGB(h, s, l);\n}\n\nfunction hue2RGB(p: number, q: number, t: number) {\n if (t < 0) t += 1;\n if (t > 1) t -= 1;\n if (t < 1 / 6) return p + (q - p) * 6 * t;\n if (t < 1 / 2) return q;\n if (t < 2 / 3) return p + (q - p) * 6 * (2 / 3 - t);\n return p;\n}\n\nfunction euclideanModulo(n: number, m: number) {\n return ((n % m) + m) % m;\n}\n\nexport function hslToRGB(h: number, s: number, l: number): MMLColor {\n h = euclideanModulo(h, 1);\n s = Math.max(0, Math.min(s, 1));\n l = Math.max(0, Math.min(l, 1));\n\n if (s === 0) {\n return { r: l, g: l, b: l };\n } else {\n const p = l <= 0.5 ? l * (1 + s) : l + s - l * s;\n const q = 2 * l - p;\n\n return {\n r: hue2RGB(q, p, h + 1 / 3),\n g: hue2RGB(q, p, h),\n b: hue2RGB(q, p, h - 1 / 3),\n };\n }\n}\n\nfunction getHSL(source: MMLColor): { h: number; s: number; l: number } {\n // h,s,l ranges are in 0.0 - 1.0\n\n const r = source.r,\n g = source.g,\n b = source.b;\n\n const max = Math.max(r, g, b);\n const min = Math.min(r, g, b);\n\n let hue = 0;\n let saturation = 0;\n const lightness = (min + max) / 2.0;\n\n if (min === max) {\n hue = 0;\n saturation = 0;\n } else {\n const delta = max - min;\n\n saturation = lightness <= 0.5 ? delta / (max + min) : delta / (2 - max - min);\n\n switch (max) {\n case r:\n hue = (g - b) / delta + (g < b ? 6 : 0);\n break;\n case g:\n hue = (b - r) / delta + 2;\n break;\n case b:\n hue = (r - g) / delta + 4;\n break;\n }\n\n hue /= 6;\n }\n\n return {\n h: hue,\n s: saturation,\n l: lightness,\n };\n}\n", "export const colors: { [key: string]: [number, number, number] } = {\n aliceblue: [0xf0 / 255, 0xf8 / 255, 0xff / 255],\n antiquewhite: [0xfa / 255, 0xeb / 255, 0xd7 / 255],\n aqua: [0x00 / 255, 0xff / 255, 0xff / 255],\n aquamarine: [0x7f / 255, 0xff / 255, 0xd4 / 255],\n azure: [0xf0 / 255, 0xff / 255, 0xff / 255],\n beige: [0xf5 / 255, 0xf5 / 255, 0xdc / 255],\n bisque: [0xff / 255, 0xe4 / 255, 0xc4 / 255],\n black: [0x00 / 255, 0x00 / 255, 0x00 / 255],\n blanchedalmond: [0xff / 255, 0xeb / 255, 0xcd / 255],\n blue: [0x00 / 255, 0x00 / 255, 0xff / 255],\n blueviolet: [0x8a / 255, 0x2b / 255, 0xe2 / 255],\n brown: [0xa5 / 255, 0x2a / 255, 0x2a / 255],\n burlywood: [0xde / 255, 0xb8 / 255, 0x87 / 255],\n cadetblue: [0x5f / 255, 0x9e / 255, 0xa0 / 255],\n chartreuse: [0x7f / 255, 0xff / 255, 0x00 / 255],\n chocolate: [0xd2 / 255, 0x69 / 255, 0x1e / 255],\n coral: [0xff / 255, 0x7f / 255, 0x50 / 255],\n cornflowerblue: [0x64 / 255, 0x95 / 255, 0xed / 255],\n cornsilk: [0xff / 255, 0xf8 / 255, 0xdc / 255],\n crimson: [0xdc / 255, 0x14 / 255, 0x3c / 255],\n cyan: [0x00 / 255, 0xff / 255, 0xff / 255],\n darkblue: [0x00 / 255, 0x00 / 255, 0x8b / 255],\n darkcyan: [0x00 / 255, 0x8b / 255, 0x8b / 255],\n darkgoldenrod: [0xb8 / 255, 0x86 / 255, 0x0b / 255],\n darkgray: [0xa9 / 255, 0xa9 / 255, 0xa9 / 255],\n darkgreen: [0x00 / 255, 0x64 / 255, 0x00 / 255],\n darkgrey: [0xa9 / 255, 0xa9 / 255, 0xa9 / 255],\n darkkhaki: [0xbd / 255, 0xb7 / 255, 0x6b / 255],\n darkmagenta: [0x8b / 255, 0x00 / 255, 0x8b / 255],\n darkolivegreen: [0x55 / 255, 0x6b / 255, 0x2f / 255],\n darkorange: [0xff / 255, 0x8c / 255, 0x00 / 255],\n darkorchid: [0x99 / 255, 0x32 / 255, 0xcc / 255],\n darkred: [0x8b / 255, 0x00 / 255, 0x00 / 255],\n darksalmon: [0xe9 / 255, 0x96 / 255, 0x7a / 255],\n darkseagreen: [0x8f / 255, 0xbc / 255, 0x8f / 255],\n darkslateblue: [0x48 / 255, 0x3d / 255, 0x8b / 255],\n darkslategray: [0x2f / 255, 0x4f / 255, 0x4f / 255],\n darkslategrey: [0x2f / 255, 0x4f / 255, 0x4f / 255],\n darkturquoise: [0x00 / 255, 0xce / 255, 0xd1 / 255],\n darkviolet: [0x94 / 255, 0x00 / 255, 0xd3 / 255],\n deeppink: [0xff / 255, 0x14 / 255, 0x93 / 255],\n deepskyblue: [0x00 / 255, 0xbf / 255, 0xff / 255],\n dimgray: [0x69 / 255, 0x69 / 255, 0x69 / 255],\n dimgrey: [0x69 / 255, 0x69 / 255, 0x69 / 255],\n dodgerblue: [0x1e / 255, 0x90 / 255, 0xff / 255],\n firebrick: [0xb2 / 255, 0x22 / 255, 0x22 / 255],\n floralwhite: [0xff / 255, 0xfa / 255, 0xf0 / 255],\n forestgreen: [0x22 / 255, 0x8b / 255, 0x22 / 255],\n fuchsia: [0xff / 255, 0x00 / 255, 0xff / 255],\n gainsboro: [0xdc / 255, 0xdc / 255, 0xdc / 255],\n ghostwhite: [0xf8 / 255, 0xf8 / 255, 0xff / 255],\n gold: [0xff / 255, 0xd7 / 255, 0x00 / 255],\n goldenrod: [0xda / 255, 0xa5 / 255, 0x20 / 255],\n gray: [0x80 / 255, 0x80 / 255, 0x80 / 255],\n green: [0x00 / 255, 0x80 / 255, 0x00 / 255],\n greenyellow: [0xad / 255, 0xff / 255, 0x2f / 255],\n grey: [0x80 / 255, 0x80 / 255, 0x80 / 255],\n honeydew: [0xf0 / 255, 0xff / 255, 0xf0 / 255],\n hotpink: [0xff / 255, 0x69 / 255, 0xb4 / 255],\n indianred: [0xcd / 255, 0x5c / 255, 0x5c / 255],\n indigo: [0x4b / 255, 0x00 / 255, 0x82 / 255],\n ivory: [0xff / 255, 0xff / 255, 0xf0 / 255],\n khaki: [0xf0 / 255, 0xe6 / 255, 0x8c / 255],\n lavender: [0xe6 / 255, 0xe6 / 255, 0xfa / 255],\n lavenderblush: [0xff / 255, 0xf0 / 255, 0xf5 / 255],\n lawngreen: [0x7c / 255, 0xfc / 255, 0x00 / 255],\n lemonchiffon: [0xff / 255, 0xfa / 255, 0xcd / 255],\n lightblue: [0xad / 255, 0xd8 / 255, 0xe6 / 255],\n lightcoral: [0xf0 / 255, 0x80 / 255, 0x80 / 255],\n lightcyan: [0xe0 / 255, 0xff / 255, 0xff / 255],\n lightgoldenrodyellow: [0xfa / 255, 0xfa / 255, 0xd2 / 255],\n lightgray: [0xd3 / 255, 0xd3 / 255, 0xd3 / 255],\n lightgreen: [0x90 / 255, 0xee / 255, 0x90 / 255],\n lightgrey: [0xd3 / 255, 0xd3 / 255, 0xd3 / 255],\n lightpink: [0xff / 255, 0xb6 / 255, 0xc1 / 255],\n lightsalmon: [0xff / 255, 0xa0 / 255, 0x7a / 255],\n lightseagreen: [0x20 / 255, 0xb2 / 255, 0xaa / 255],\n lightskyblue: [0x87 / 255, 0xce / 255, 0xfa / 255],\n lightslategray: [0x77 / 255, 0x88 / 255, 0x99 / 255],\n lightslategrey: [0x77 / 255, 0x88 / 255, 0x99 / 255],\n lightsteelblue: [0xb0 / 255, 0xc4 / 255, 0xde / 255],\n lightyellow: [0xff / 255, 0xff / 255, 0xe0 / 255],\n lime: [0x00 / 255, 0xff / 255, 0x00 / 255],\n limegreen: [0x32 / 255, 0xcd / 255, 0x32 / 255],\n linen: [0xfa / 255, 0xf0 / 255, 0xe6 / 255],\n magenta: [0xff / 255, 0x00 / 255, 0xff / 255],\n maroon: [0x80 / 255, 0x00 / 255, 0x00 / 255],\n mediumaquamarine: [0x66 / 255, 0xcd / 255, 0xaa / 255],\n mediumblue: [0x00 / 255, 0x00 / 255, 0xcd / 255],\n mediumorchid: [0xba / 255, 0x55 / 255, 0xd3 / 255],\n mediumpurple: [0x93 / 255, 0x70 / 255, 0xdb / 255],\n mediumseagreen: [0x3c / 255, 0xb3 / 255, 0x71 / 255],\n mediumslateblue: [0x7b / 255, 0x68 / 255, 0xee / 255],\n mediumspringgreen: [0x00 / 255, 0xfa / 255, 0x9a / 255],\n mediumturquoise: [0x48 / 255, 0xd1 / 255, 0xcc / 255],\n mediumvioletred: [0xc7 / 255, 0x15 / 255, 0x85 / 255],\n midnightblue: [0x19 / 255, 0x19 / 255, 0x70 / 255],\n mintcream: [0xf5 / 255, 0xff / 255, 0xfa / 255],\n mistyrose: [0xff / 255, 0xe4 / 255, 0xe1 / 255],\n moccasin: [0xff / 255, 0xe4 / 255, 0xb5 / 255],\n navajowhite: [0xff / 255, 0xde / 255, 0xad / 255],\n navy: [0x00 / 255, 0x00 / 255, 0x80 / 255],\n oldlace: [0xfd / 255, 0xf5 / 255, 0xe6 / 255],\n olive: [0x80 / 255, 0x80 / 255, 0x00 / 255],\n olivedrab: [0x6b / 255, 0x8e / 255, 0x23 / 255],\n orange: [0xff / 255, 0xa5 / 255, 0x00 / 255],\n orangered: [0xff / 255, 0x45 / 255, 0x00 / 255],\n orchid: [0xda / 255, 0x70 / 255, 0xd6 / 255],\n palegoldenrod: [0xee / 255, 0xe8 / 255, 0xaa / 255],\n palegreen: [0x98 / 255, 0xfb / 255, 0x98 / 255],\n paleturquoise: [0xaf / 255, 0xee / 255, 0xee / 255],\n palevioletred: [0xdb / 255, 0x70 / 255, 0x93 / 255],\n papayawhip: [0xff / 255, 0xef / 255, 0xd5 / 255],\n peachpuff: [0xff / 255, 0xda / 255, 0xb9 / 255],\n peru: [0xcd / 255, 0x85 / 255, 0x3f / 255],\n pink: [0xff / 255, 0xc0 / 255, 0xcb / 255],\n plum: [0xdd / 255, 0xa0 / 255, 0xdd / 255],\n powderblue: [0xb0 / 255, 0xe0 / 255, 0xe6 / 255],\n purple: [0x80 / 255, 0x00 / 255, 0x80 / 255],\n rebeccapurple: [0x66 / 255, 0x33 / 255, 0x99 / 255],\n red: [0xff / 255, 0x00 / 255, 0x00 / 255],\n rosybrown: [0xbc / 255, 0x8f / 255, 0x8f / 255],\n royalblue: [0x41 / 255, 0x69 / 255, 0xe1 / 255],\n saddlebrown: [0x8b / 255, 0x45 / 255, 0x13 / 255],\n salmon: [0xfa / 255, 0x80 / 255, 0x72 / 255],\n sandybrown: [0xf4 / 255, 0xa4 / 255, 0x60 / 255],\n seagreen: [0x2e / 255, 0x8b / 255, 0x57 / 255],\n seashell: [0xff / 255, 0xf5 / 255, 0xee / 255],\n sienna: [0xa0 / 255, 0x52 / 255, 0x2d / 255],\n silver: [0xc0 / 255, 0xc0 / 255, 0xc0 / 255],\n skyblue: [0x87 / 255, 0xce / 255, 0xeb / 255],\n slateblue: [0x6a / 255, 0x5a / 255, 0xcd / 255],\n slategray: [0x70 / 255, 0x80 / 255, 0x90 / 255],\n slategrey: [0x70 / 255, 0x80 / 255, 0x90 / 255],\n snow: [0xff / 255, 0xfa / 255, 0xfa / 255],\n springgreen: [0x00 / 255, 0xff / 255, 0x7f / 255],\n steelblue: [0x46 / 255, 0x82 / 255, 0xb4 / 255],\n tan: [0xd2 / 255, 0xb4 / 255, 0x8c / 255],\n teal: [0x00 / 255, 0x80 / 255, 0x80 / 255],\n thistle: [0xd8 / 255, 0xbf / 255, 0xd8 / 255],\n tomato: [0xff / 255, 0x63 / 255, 0x47 / 255],\n turquoise: [0x40 / 255, 0xe0 / 255, 0xd0 / 255],\n violet: [0xee / 255, 0x82 / 255, 0xee / 255],\n wheat: [0xf5 / 255, 0xde / 255, 0xb3 / 255],\n white: [0xff / 255, 0xff / 255, 0xff / 255],\n whitesmoke: [0xf5 / 255, 0xf5 / 255, 0xf5 / 255],\n yellow: [0xff / 255, 0xff / 255, 0x00 / 255],\n yellowgreen: [0x9a / 255, 0xcd / 255, 0x32 / 255],\n};\n", "import { colors, hslToRGB, MMLColor } from \"../color\";\n\nexport type AttributeHandlerMap = {\n [key: string]: (instance: T, newValue: string | null) => void;\n};\n\nexport class AttributeHandler {\n private map: AttributeHandlerMap;\n\n constructor(map: AttributeHandlerMap) {\n this.map = map;\n }\n\n public getAttributes() {\n return Object.keys(this.map);\n }\n\n public handle(instance: T, name: string, newValue: string): boolean {\n const handler = this.map[name];\n if (handler) {\n handler(instance, newValue);\n return true;\n }\n return false;\n }\n}\n\nexport function parseColorAttribute(value: string | null, defaultValue: null): MMLColor | null;\nexport function parseColorAttribute(value: string | null, defaultValue: MMLColor): MMLColor;\nexport function parseColorAttribute(\n value: string | null,\n defaultValue: MMLColor | null,\n): MMLColor | null {\n return parseAttribute(value, defaultValue, (value) => {\n const colorNameValues = colors[value];\n if (colorNameValues) {\n return {\n r: colorNameValues[0],\n g: colorNameValues[1],\n b: colorNameValues[2],\n };\n }\n\n if (value.length === 7) {\n const hex = /^#?([a-f\\d]{2})([a-f\\d]{2})([a-f\\d]{2})$/i.exec(value);\n if (hex) {\n // e.g. #ff00ff\n return {\n r: parseInt(hex[1], 16) / 255,\n g: parseInt(hex[2], 16) / 255,\n b: parseInt(hex[3], 16) / 255,\n };\n }\n }\n\n if (value.length === 4) {\n const hex = /^#?([a-f\\d])([a-f\\d])([a-f\\d])$/i.exec(value);\n if (hex) {\n // e.g. #f0f\n return {\n r: parseInt(hex[1] + hex[1], 16) / 255,\n g: parseInt(hex[2] + hex[2], 16) / 255,\n b: parseInt(hex[3] + hex[3], 16) / 255,\n };\n }\n }\n\n if (value.indexOf(\"rgb(\") === 0) {\n const rgb = /^rgb\\((\\d+),\\s*(\\d+),\\s*(\\d+)\\)$/.exec(value);\n if (rgb) {\n // e.g. rgb(255,0,255)\n return {\n r: parseInt(rgb[1], 10) / 255,\n g: parseInt(rgb[2], 10) / 255,\n b: parseInt(rgb[3], 10) / 255,\n };\n }\n }\n\n if (value.indexOf(\"rgba(\") === 0) {\n const rgba = /^rgba\\((\\d+),\\s*(\\d+),\\s*(\\d+),\\s*(\\d*\\.?\\d+)\\)$/.exec(value);\n if (rgba) {\n // e.g. rgba(255,0,255,0.5)\n return {\n r: parseInt(rgba[1], 10) / 255,\n g: parseInt(rgba[2], 10) / 255,\n b: parseInt(rgba[3], 10) / 255,\n a: parseFloat(rgba[4]),\n };\n }\n }\n\n if (value.indexOf(\"hsl(\") === 0) {\n const hsl = /^hsl\\(\\s*(\\d+)\\s*,\\s*(\\d+(?:\\.\\d+)?%)\\s*,\\s*(\\d+(?:\\.\\d+)?%)\\)$/.exec(value);\n if (hsl) {\n let h = parseFloat(hsl[1]) / 360;\n // special case for hsl/hsla to change the behaviour at extremes such that animations can differentiate (and therefore lerp) between 0 and 360 degrees\n if (h === 0) {\n h = 0.0001;\n } else if (h === 1) {\n h = 0.9999;\n }\n let s = parseFloat(hsl[2]) / 100;\n if (s === 0) {\n s = 0.0001;\n } else if (s === 1) {\n s = 0.9999;\n }\n let l = parseFloat(hsl[3]) / 100;\n if (l === 0) {\n l = 0.0001;\n } else if (l === 1) {\n l = 0.9999;\n }\n return hslToRGB(h, s, l);\n }\n }\n\n if (value.indexOf(\"hsla(\") === 0) {\n const hsla =\n /^hsla\\(\\s*(\\d+(?:\\.\\d+)?)\\s*,\\s*(\\d+(?:\\.\\d+)?%)\\s*,\\s*(\\d+(?:\\.\\d+)?%),\\s*(\\d+(?:\\.\\d+)?)\\)$/.exec(\n value,\n );\n if (hsla) {\n let h = parseFloat(hsla[1]) / 360;\n // special case for hsl/hsla to change the behaviour at extremes such that animations can differentiate (and therefore lerp) between 0 and 360 degrees\n if (h === 0) {\n h = 0.0001;\n } else if (h === 1) {\n h = 0.9999;\n }\n let s = parseFloat(hsla[2]) / 100;\n if (s === 0) {\n s = 0.0001;\n } else if (s === 1) {\n s = 0.9999;\n }\n let l = parseFloat(hsla[3]) / 100;\n if (l === 0) {\n l = 0.0001;\n } else if (l === 1) {\n l = 0.9999;\n }\n return hslToRGB(h, s, l);\n }\n }\n return null;\n });\n}\n\nexport function parseAttribute(\n value: string | null,\n defaultValue: T,\n parser: (value: string) => T | null,\n): T {\n if (value === null) {\n return defaultValue;\n }\n const parsed = parser(value);\n if (parsed === null) {\n return defaultValue;\n }\n return parsed;\n}\n\nexport function floatParser(value: string): number | null {\n const parsed = parseFloat(value);\n if (isNaN(parsed)) {\n return null;\n }\n return parsed;\n}\n\nexport function boolParser(value: string): boolean | null {\n if (value === \"true\") {\n return true;\n } else if (value === \"false\") {\n return false;\n }\n return null;\n}\n\nexport function parseFloatAttribute(value: string | null, defaultValue: null): number | null;\nexport function parseFloatAttribute(value: string | null, defaultValue: number): number;\n\nexport function parseFloatAttribute(\n value: string | null,\n defaultValue: number | null,\n): number | null {\n return parseAttribute(value, defaultValue, floatParser);\n}\n\nexport function parseBoolAttribute(value: string | null, defaultValue: boolean): boolean {\n return parseAttribute(value, defaultValue, boolParser);\n}\n\nexport function parseEnumAttribute(\n value: string | null,\n enumValues: Record,\n defaultValue: T,\n): T {\n return parseAttribute(value, defaultValue, (value) => {\n if (Object.keys(enumValues).indexOf(value as T) === -1) {\n return null;\n }\n return value as T;\n });\n}\n", "import { GraphicsAdapter } from \"../graphics\";\nimport { IMMLScene } from \"../scene\";\nimport { MMLDocumentTimeManager } from \"../time\";\n\nlet scene: IMMLScene | null = null;\nlet documentTimeManager: MMLDocumentTimeManager | null = null;\n\nexport function setGlobalMMLScene(sceneArg: IMMLScene) {\n if (scene) {\n throw new Error(\"GlobalMMLScene already set\");\n }\n scene = sceneArg;\n}\n\nexport function getGlobalMMLScene(): IMMLScene {\n if (!scene) {\n throw new Error(\"GlobalMMLScene not set\");\n }\n return scene;\n}\n\nexport function setGlobalDocumentTimeManager(documentTimeManagerArg: MMLDocumentTimeManager) {\n if (documentTimeManager) {\n throw new Error(\"GlobalDocumentTimeManager already set\");\n }\n documentTimeManager = documentTimeManagerArg;\n}\n\nexport function getGlobalDocumentTimeManager(): MMLDocumentTimeManager {\n if (!documentTimeManager) {\n throw new Error(\"GlobalMMLScene not set\");\n }\n return documentTimeManager;\n}\n", "import { getGlobalDocumentTimeManager, getGlobalMMLScene } from \"../global\";\nimport { GraphicsAdapter } from \"../graphics\";\nimport { MElementGraphics } from \"../graphics\";\nimport { LoadingProgressManager } from \"../loading\";\nimport { IMMLScene, PositionAndRotation } from \"../scene\";\nimport { MMLDocumentTimeManager } from \"../time\";\nimport type { RemoteDocument } from \"./RemoteDocument\";\n\nexport const MELEMENT_PROPERTY_NAME = \"m-element-property\";\nexport const consumeEventEventName = \"consume-event\";\n\nexport abstract class MElement extends HTMLElement {\n // This allows switching which document this HTMLElement subclass extends so that it can be placed into iframes\n static overwriteSuperclass(newSuperclass: typeof HTMLElement) {\n (MElement as any).__proto__ = newSuperclass;\n }\n\n static get observedAttributes(): Array {\n return [];\n }\n\n private mElementGraphics: MElementGraphics | null = null;\n\n constructor() {\n super();\n }\n\n static getMElementFromObject(object: unknown): MElement | null {\n return (object as any)[MELEMENT_PROPERTY_NAME] || null;\n }\n\n public abstract isClickable(): boolean;\n\n public abstract parentTransformed(): void;\n\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n public addSideEffectChild(child: MElement): void {\n // no-op\n }\n\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n public removeSideEffectChild(child: MElement): void {\n // no-op\n }\n\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n public attributeChangedCallback(name: string, oldValue: string | null, newValue: string) {\n // no-op\n }\n\n public getScene(): IMMLScene {\n const remoteDocumentElement = this.getInitiatedRemoteDocument();\n if (remoteDocumentElement) {\n // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n return (remoteDocumentElement as RemoteDocument).getMMLScene()!;\n }\n const globalScene = getGlobalMMLScene() as IMMLScene;\n if (!globalScene) {\n throw new Error(\"No scene attachment found and no global scene found\");\n }\n return globalScene;\n }\n\n public getInitiatedRemoteDocument(): RemoteDocument | null {\n // eslint-disable-next-line @typescript-eslint/no-this-alias\n for (let parentNode: ParentNode | null = this; parentNode; parentNode = parentNode.parentNode) {\n if (\n parentNode.nodeName === \"M-REMOTE-DOCUMENT\" &&\n (parentNode as RemoteDocument).getMMLScene()\n ) {\n // Return the first remote document that has an explicit scene set\n return parentNode as RemoteDocument;\n }\n }\n return null;\n }\n\n public contentSrcToContentAddress(src: string): string {\n // Convert the potentially relative src to an absolute address using the document host\n const documentLocation = this.getDocumentHost();\n // First check if the src is a host-relative path\n try {\n // Check if the src is a valid URL - if so then it's already absolute\n const url = new URL(src);\n return url.toString();\n } catch {\n // Do nothing\n }\n let protocol = documentLocation.protocol;\n if (protocol === \"ws:\") {\n protocol = \"http:\";\n } else if (protocol === \"wss:\") {\n protocol = \"https:\";\n }\n if (src.startsWith(\"/\")) {\n // If the src is host-relative then we can just use the document host\n return `${protocol}//${documentLocation.host}${src}`;\n } else {\n // Otherwise we need to use the document host as a base\n const path = documentLocation.pathname;\n const lastSlashIndex = path.lastIndexOf(\"/\");\n if (lastSlashIndex === -1) {\n return `${protocol}//${documentLocation.host}/${src}`;\n }\n const pathWithoutFilename = path.substring(0, lastSlashIndex + 1);\n return `${protocol}//${documentLocation.host}${pathWithoutFilename}${src}`;\n }\n }\n\n private getDocumentHost(): URL | Location {\n const remoteDocument = this.getInitiatedRemoteDocument();\n if (remoteDocument) {\n const remoteDocumentAddress = remoteDocument.getDocumentAddress();\n if (remoteDocumentAddress) {\n const url = new URL(remoteDocumentAddress);\n return url;\n }\n }\n return window.location;\n }\n\n public getDocumentTime(): number {\n const documentTimeContextProvider = this.getDocumentTimeManager();\n if (documentTimeContextProvider) {\n return documentTimeContextProvider.getDocumentTime();\n }\n // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n return Number(document.timeline.currentTime!);\n }\n\n public getWindowTime(): number {\n const documentTimeContextProvider = this.getDocumentTimeManager();\n if (documentTimeContextProvider) {\n return documentTimeContextProvider.getWindowTime();\n }\n // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n return Number(document.timeline.currentTime!);\n }\n\n public getLoadingProgressManager(): LoadingProgressManager | null {\n const scene = this.getScene();\n if (scene) {\n return scene.getLoadingProgressManager?.() || null;\n }\n return null;\n }\n\n protected getDocumentTimeManager(): MMLDocumentTimeManager | null {\n const remoteDocument = this.getInitiatedRemoteDocument();\n if (remoteDocument) {\n return remoteDocument.getDocumentTimeManager();\n }\n const globalDocumentTimeManager = getGlobalDocumentTimeManager();\n if (globalDocumentTimeManager) {\n return globalDocumentTimeManager;\n }\n return null;\n }\n\n public addDocumentTimeListener(cb: (documentTime: number) => void): {\n remove: () => void;\n } {\n const documentTimeManager = this.getDocumentTimeManager();\n if (documentTimeManager) {\n documentTimeManager.addDocumentTimeListenerCallback(cb);\n return {\n remove: () => {\n documentTimeManager.removeDocumentTimeListenerCallback(cb);\n },\n };\n } else {\n console.warn(\"No document time context provider found to add listener to\");\n return {\n remove: () => {\n // no-op\n },\n };\n }\n }\n\n public addDocumentTimeTickListener(cb: (documentTime: number) => void): {\n remove: () => void;\n } {\n const documentTimeManager = this.getDocumentTimeManager();\n if (documentTimeManager) {\n documentTimeManager.addDocumentTimeTickListenerCallback(cb);\n return {\n remove: () => {\n documentTimeManager.removeDocumentTimeTickListenerCallback(cb);\n },\n };\n } else {\n console.warn(\"No document time context provider found to add listener to\");\n return {\n remove: () => {\n // no-op\n },\n };\n }\n }\n\n getContainer(): G[\"containerType\"] {\n const container = this.mElementGraphics?.getContainer();\n if (!container) {\n throw new Error(\"No container found\");\n }\n return container;\n }\n\n getUserPositionAndRotation(): PositionAndRotation {\n const remoteDocument = this.getScene();\n if (!remoteDocument) {\n throw new Error(\"No scene to retrieve user position from\");\n }\n return remoteDocument.getUserPositionAndRotation();\n }\n\n dispatchEvent(event: Event): boolean {\n const remoteDocument = this.getInitiatedRemoteDocument();\n if (remoteDocument) {\n remoteDocument.dispatchEvent(\n new CustomEvent(consumeEventEventName, {\n bubbles: false,\n detail: { element: this, originalEvent: event },\n }),\n );\n return super.dispatchEvent(event);\n } else {\n if (event.type !== \"click\") {\n const script = this.getAttribute(\"on\" + event.type.toLowerCase());\n if (script) {\n const handler = window[\"eval\"](`(function(event){ ${script} })`);\n handler.apply(this, [event]);\n }\n }\n return super.dispatchEvent(event);\n }\n }\n\n public getMElementParent(): MElement | null {\n let parentNode = this.parentNode;\n while (parentNode != null) {\n if (parentNode instanceof MElement) {\n return parentNode;\n }\n parentNode = parentNode.parentNode;\n }\n return null;\n }\n\n public connectedCallback(): void {\n if (!this.getScene().hasGraphicsAdapter() || this.mElementGraphics) {\n return;\n }\n const graphicsAdapter = this.getScene().getGraphicsAdapter();\n\n this.mElementGraphics = graphicsAdapter\n .getGraphicsAdapterFactory()\n .MElementGraphicsInterface(this);\n }\n\n disconnectedCallback() {\n this.mElementGraphics?.dispose();\n this.mElementGraphics = null;\n }\n}\n", "import {\n EndOfAnimationSymbol,\n getEasedRatioForTime,\n StartOfAnimationSymbol,\n} from \"../attribute-animation\";\nimport {\n AttributeHandler,\n parseBoolAttribute,\n parseColorAttribute,\n parseFloatAttribute,\n} from \"../attributes\";\nimport { OrientedBoundingBox } from \"../bounding-box\";\nimport { lerpHSL } from \"../color\";\nimport { MMLColor } from \"../color\";\nimport { GraphicsAdapter } from \"../graphics\";\nimport { MElement } from \"./MElement\";\n\nconst defaultAttribute: string | null = null;\nconst defaultStart = 0;\nconst defaultEnd = 0;\nconst defaultLoop = true;\nconst defaultPingPong = false;\nconst defaultEasing = \"\";\nconst defaultStartTime = 0;\nconst defaultPauseTime = null;\nconst defaultAnimDuration = 1000;\nconst defaultPingPongDelay = 0;\n\nexport enum AnimationType {\n Number,\n Color,\n}\n\nconst defaultColor: MMLColor = { r: 1, g: 1, b: 1 };\n\n/*\n Attribute animations are applied with the following precedence:\n 1. The first child m-attr-anim that is running (start time has passed, and duration is not exceeded / is looping)\n 2. The next-to-start m-attr-anim that is not yet running (start time has not passed). If equal timing then the first occurring child is used.\n 3. The last m-attr-anim to end (duration has been exceeded, and is not looping). If equal timing then the first occurring child is used.\n 4. The element's attribute value.\n */\n\nexport class AttributeAnimation extends MElement {\n static tagName = \"m-attr-anim\";\n\n private props = {\n attr: defaultAttribute,\n start: defaultStart as number | MMLColor,\n end: defaultEnd as number | MMLColor,\n loop: defaultLoop,\n pingPong: defaultPingPong,\n pingPongDelay: defaultPingPongDelay,\n easing: defaultEasing,\n startTime: defaultStartTime,\n pauseTime: defaultPauseTime as number | null,\n animDuration: defaultAnimDuration,\n };\n\n private registeredParentAttachment: MElement | null = null;\n\n private static attributeHandler = new AttributeHandler>({\n attr: (instance, newValue) => {\n if (instance.registeredParentAttachment && instance.props.attr) {\n instance.registeredParentAttachment.removeSideEffectChild(instance);\n }\n instance.props.attr = newValue || defaultAttribute;\n if (instance.registeredParentAttachment && instance.props.attr) {\n instance.registeredParentAttachment.addSideEffectChild(instance);\n }\n },\n start: (instance, newValue) => {\n let parsedValue: number | MMLColor | null = parseFloatAttribute(newValue, null);\n if (parsedValue === null) {\n parsedValue = parseColorAttribute(newValue, null);\n }\n if (parsedValue === null) {\n instance.props.start = defaultStart;\n } else {\n instance.props.start = parsedValue;\n }\n },\n end: (instance, newValue) => {\n let parsedValue: number | MMLColor | null = parseFloatAttribute(newValue, null);\n if (parsedValue === null) {\n parsedValue = parseColorAttribute(newValue, null);\n }\n if (parsedValue === null) {\n instance.props.end = defaultStart;\n } else {\n instance.props.end = parsedValue;\n }\n },\n loop: (instance, newValue) => {\n instance.props.loop = parseBoolAttribute(newValue, defaultLoop);\n },\n \"ping-pong\": (instance, newValue) => {\n instance.props.pingPong = parseBoolAttribute(newValue, defaultPingPong);\n },\n \"ping-pong-delay\": (instance, newValue) => {\n instance.props.pingPongDelay = parseFloatAttribute(newValue, defaultPingPongDelay);\n },\n easing: (instance, newValue) => {\n instance.props.easing = newValue || defaultEasing;\n },\n \"start-time\": (instance, newValue) => {\n instance.props.startTime = parseFloatAttribute(newValue, defaultStartTime);\n },\n \"pause-time\": (instance, newValue) => {\n instance.props.pauseTime = parseFloatAttribute(newValue, defaultPauseTime);\n },\n duration: (instance, newValue) => {\n instance.props.animDuration = parseFloatAttribute(newValue, defaultAnimDuration);\n },\n });\n\n static get observedAttributes(): Array {\n return [...AttributeAnimation.attributeHandler.getAttributes()];\n }\n constructor() {\n super();\n }\n\n protected enable() {\n // no-op\n }\n\n protected disable() {\n // no-op\n }\n\n public getContentBounds(): OrientedBoundingBox | null {\n return null;\n }\n\n public getAnimatedAttributeName(): string | null {\n return this.props.attr;\n }\n\n public parentTransformed(): void {\n // no-op\n }\n\n public isClickable(): boolean {\n return false;\n }\n\n attributeChangedCallback(name: string, oldValue: string | null, newValue: string) {\n super.attributeChangedCallback(name, oldValue, newValue);\n AttributeAnimation.attributeHandler.handle(this, name, newValue);\n }\n\n public connectedCallback(): void {\n super.connectedCallback();\n if (this.parentElement && this.parentElement instanceof MElement) {\n this.registeredParentAttachment = this.parentElement;\n if (this.props.attr) {\n this.registeredParentAttachment.addSideEffectChild(this);\n }\n }\n }\n\n disconnectedCallback() {\n if (this.registeredParentAttachment && this.props.attr) {\n this.registeredParentAttachment.removeSideEffectChild(this);\n }\n this.registeredParentAttachment = null;\n super.disconnectedCallback();\n }\n\n public getColorValueForTime(docTimeMs: number): [MMLColor, number] {\n const [ratio, state] = getEasedRatioForTime(docTimeMs, this.props);\n if (typeof this.props.start !== \"object\" || typeof this.props.end !== \"object\") {\n return [defaultColor, state];\n }\n if (ratio === StartOfAnimationSymbol) {\n return [this.props.start, state];\n } else if (ratio === EndOfAnimationSymbol) {\n return [this.props.end, state];\n } else {\n const value = lerpHSL(this.props.start, this.props.end, ratio);\n return [value, state];\n }\n }\n\n public getFloatValueForTime(docTimeMs: number): [number, number] {\n const [ratio, state] = getEasedRatioForTime(docTimeMs, this.props);\n if (typeof this.props.start !== \"number\" || typeof this.props.end !== \"number\") {\n return [0, state];\n }\n if (ratio === StartOfAnimationSymbol) {\n return [this.props.start as number, state];\n } else if (ratio === EndOfAnimationSymbol) {\n return [this.props.end as number, state];\n } else {\n const value = ratio * (this.props.end - this.props.start) + this.props.start;\n return [value, state];\n }\n }\n}\n", "import { easingsByName } from \"../attribute-animation\";\nimport { AttributeHandler, parseFloatAttribute } from \"../attributes\";\nimport { OrientedBoundingBox } from \"../bounding-box\";\nimport { lerpHSL, MMLColor } from \"../color\";\nimport { GraphicsAdapter } from \"../graphics\";\nimport { MElement } from \"./MElement\";\n\nconst defaultAttribute: string = \"all\";\nconst defaultEasing = \"\";\nconst defaultLerpDuration = 1000;\n\nexport class AttributeLerp extends MElement {\n static tagName = \"m-attr-lerp\";\n\n private props = {\n attr: defaultAttribute,\n easing: defaultEasing,\n lerpDuration: defaultLerpDuration,\n };\n\n private registeredParentAttachment: MElement | null = null;\n\n private static attributeHandler = new AttributeHandler>({\n attr: (instance, newValue) => {\n if (instance.registeredParentAttachment) {\n instance.registeredParentAttachment.removeSideEffectChild(instance);\n }\n instance.props.attr = newValue !== null ? newValue : defaultAttribute;\n if (instance.registeredParentAttachment) {\n instance.registeredParentAttachment.addSideEffectChild(instance);\n }\n },\n easing: (instance, newValue) => {\n instance.props.easing = newValue || defaultEasing;\n },\n duration: (instance, newValue) => {\n instance.props.lerpDuration = Math.max(0, parseFloatAttribute(newValue, defaultLerpDuration));\n },\n });\n\n static get observedAttributes(): Array {\n return [...AttributeLerp.attributeHandler.getAttributes()];\n }\n\n constructor() {\n super();\n }\n\n protected enable() {\n // no-op\n }\n\n protected disable() {\n // no-op\n }\n\n public getContentBounds(): OrientedBoundingBox | null {\n return null;\n }\n\n public getAnimatedAttributeName(): string | null {\n return this.props.attr;\n }\n\n public parentTransformed(): void {\n // no-op\n }\n\n public isClickable(): boolean {\n return false;\n }\n\n attributeChangedCallback(name: string, oldValue: string | null, newValue: string) {\n super.attributeChangedCallback(name, oldValue, newValue);\n AttributeLerp.attributeHandler.handle(this, name, newValue);\n }\n\n public connectedCallback(): void {\n super.connectedCallback();\n if (this.parentElement && this.parentElement instanceof MElement) {\n this.registeredParentAttachment = this.parentElement;\n this.registeredParentAttachment.addSideEffectChild(this);\n }\n }\n\n disconnectedCallback() {\n if (this.registeredParentAttachment) {\n this.registeredParentAttachment.removeSideEffectChild(this);\n }\n this.registeredParentAttachment = null;\n super.disconnectedCallback();\n }\n\n public getColorValueForTime(\n windowTime: number,\n elementValueSetTime: number,\n elementValue: MMLColor,\n previousValue: MMLColor,\n ) {\n const ratio = this.getLerpRatio(windowTime, elementValueSetTime);\n if (ratio >= 1) {\n return elementValue;\n }\n return lerpHSL(previousValue, elementValue, ratio);\n }\n\n public getFloatValueForTime(\n windowTime: number,\n elementValueSetTime: number,\n elementValue: number,\n previousValue: number,\n ) {\n const from = previousValue;\n const to = elementValue;\n const ratio = this.getLerpRatio(windowTime, elementValueSetTime);\n if (ratio >= 1) {\n return to;\n }\n return from + (to - from) * ratio;\n }\n\n private getLerpRatio(windowTime: number, elementValueSetTime: number) {\n const duration = this.props.lerpDuration;\n const timePassed = (windowTime || 0) - elementValueSetTime;\n const ratioOfTimePassed = Math.min(timePassed / duration, 1);\n const easing = this.props.easing;\n let ratio;\n const easingFunction = easingsByName[easing];\n if (easingFunction) {\n ratio = easingFunction(ratioOfTimePassed, 0, 1, 1);\n } else {\n ratio = ratioOfTimePassed;\n }\n return ratio;\n }\n}\n", "import { MMLColor } from \"../color\";\nimport { AnimationType, AttributeAnimation } from \"../elements/AttributeAnimation\";\nimport { AttributeLerp } from \"../elements/AttributeLerp\";\nimport { MElement } from \"../elements/MElement\";\nimport { GraphicsAdapter } from \"../graphics\";\n\ntype AttributeTuple = T extends AnimationType.Number\n ? [\n AnimationType.Number,\n AnimationTypeToValueType | null,\n (newValue: AnimationTypeToValueType | null) => void,\n ]\n : [\n AnimationType.Color,\n AnimationTypeToValueType | null,\n (newValue: AnimationTypeToValueType | null) => void,\n ];\n\nexport type AttributeHandlerRecord = Record<\n string,\n AttributeTuple | AttributeTuple\n>;\n\ntype AnimationTypeToValueType = T extends AnimationType.Number\n ? number\n : MMLColor;\n\ntype AttributeState = {\n type: T;\n previousValue: AnimationTypeToValueType | null;\n elementValue: AnimationTypeToValueType | null;\n elementValueSetTime: number | null;\n latestValue: AnimationTypeToValueType | null;\n defaultValue: AnimationTypeToValueType | null;\n handler: (newValue: AnimationTypeToValueType | null) => void;\n};\n\ntype AnimationStateRecord = {\n attributeState: AttributeState;\n animationsInOrder: Array>;\n animationsSet: Set>;\n lerpsInOrder: Array>;\n lerpsSet: Set>;\n};\n\nfunction TupleToState(tuple: AttributeTuple): AttributeState {\n return {\n previousValue: null,\n elementValue: null,\n elementValueSetTime: null,\n type: tuple[0],\n latestValue: tuple[1],\n defaultValue: tuple[1],\n handler: tuple[2],\n } as AttributeState;\n}\n\nfunction updateIfChangedValue(\n state: AnimationStateRecord,\n newValue: AnimationTypeToValueType | null,\n) {\n if (newValue === null) {\n // There is no value from the source (likely there are no animations and no attribute value), so use the default.\n newValue = state.attributeState.defaultValue;\n }\n if (state.attributeState.latestValue !== newValue) {\n state.attributeState.latestValue = newValue;\n state.attributeState.handler(newValue);\n }\n}\n\nfunction isColorAttribute(\n attributeState: AttributeState,\n): attributeState is AttributeState {\n return attributeState.type === AnimationType.Color;\n}\n\nfunction isNumberAttribute(\n attributeState: AttributeState,\n): attributeState is AttributeState {\n return attributeState.type === AnimationType.Number;\n}\n\n/**\n * The AnimatedAttributeHelper is a utility class that manages the application of attribute animations to an element.\n *\n * It is used by an MElement that has animateable attributes and is responsible for applying the animations to the\n * element according to the precedence rules defined in the AttributeAnimation class, and falling back to the element's\n * attribute value if no animations are active.\n */\nexport class AnimatedAttributeHelper {\n private stateByAttribute: {\n [p: string]: AnimationStateRecord;\n } = {};\n\n private allAnimations: Set> = new Set();\n private allLerps: Set> = new Set();\n\n private documentTimeTickListener: null | { remove: () => void } = null;\n\n // Track if this helper has ticked at least once.\n private hasTicked = false;\n\n constructor(\n private element: MElement,\n private handlers: AttributeHandlerRecord,\n ) {\n this.element = element;\n this.reset();\n }\n\n public addSideEffectChild(child: MElement): void {\n if (child instanceof AttributeAnimation) {\n const attr = child.getAnimatedAttributeName();\n if (attr) {\n this.addAnimation(child, attr);\n }\n } else if (child instanceof AttributeLerp) {\n const attr = child.getAnimatedAttributeName();\n if (attr) {\n this.addLerp(child, attr);\n }\n }\n }\n\n public removeSideEffectChild(child: MElement): void {\n if (child instanceof AttributeAnimation) {\n const attr = child.getAnimatedAttributeName();\n if (attr) {\n this.removeAnimation(child, attr);\n }\n } else if (child instanceof AttributeLerp) {\n const attr = child.getAnimatedAttributeName();\n if (attr) {\n this.removeLerp(child, attr);\n }\n }\n }\n\n public elementSetAttribute(\n key: string,\n newValue: AnimationTypeToValueType | null,\n ) {\n const state = this.stateByAttribute[key] as AnimationStateRecord;\n if (!state) {\n return;\n }\n state.attributeState.elementValue = newValue;\n if (this.hasTicked) {\n state.attributeState.previousValue = state.attributeState.latestValue;\n } else {\n // If the element has not ticked yet, set the previous value to the new value to avoid lerping from the default value.\n state.attributeState.previousValue = newValue;\n }\n\n if (this.element.isConnected) {\n state.attributeState.elementValueSetTime = this.element.getWindowTime();\n } else {\n state.attributeState.elementValueSetTime = null;\n }\n if (state.animationsSet.size > 0 || state.lerpsSet.size > 0) {\n return;\n }\n updateIfChangedValue(state, newValue);\n }\n\n public getAttributesForAttributeValue(attr: string): Array {\n // attr is in the format \"some-attr, another-attr\" or \"all\". Only return attributes that exist\n if (attr === \"all\") {\n return Object.keys(this.stateByAttribute);\n }\n return attr\n .split(\",\")\n .map((a) => a.trim())\n .filter((a) => this.stateByAttribute[a]);\n }\n\n public addLerp(lerp: AttributeLerp, attributeValue: string) {\n const attributes = this.getAttributesForAttributeValue(attributeValue);\n for (const key of attributes) {\n const state = this.stateByAttribute[key];\n if (!state) {\n return;\n }\n if (state.animationsSet.size === 0 && state.lerpsSet.size === 0) {\n // start listening to document time\n this.documentTimeTickListener = this.element.addDocumentTimeTickListener((documentTime) => {\n this.updateTime(documentTime);\n });\n }\n this.allLerps.add(lerp);\n state.lerpsSet.add(lerp);\n state.lerpsInOrder = [];\n const elementChildren = Array.from(this.element.children);\n for (const child of elementChildren) {\n if (state.lerpsSet.has(child as AttributeLerp)) {\n state.lerpsInOrder.push(child as AttributeLerp);\n }\n }\n }\n }\n\n public removeLerp(lerp: AttributeLerp, attributeValue: string) {\n const attributes = this.getAttributesForAttributeValue(attributeValue);\n for (const key of attributes) {\n const state = this.stateByAttribute[key];\n if (!state) {\n return;\n }\n state.lerpsInOrder.splice(state.lerpsInOrder.indexOf(lerp), 1);\n state.lerpsSet.delete(lerp);\n if (state.animationsSet.size === 0) {\n updateIfChangedValue(state, state.attributeState.elementValue);\n }\n this.allLerps.delete(lerp);\n if (this.allLerps.size === 0) {\n // stop listening to document time\n if (this.documentTimeTickListener) {\n this.documentTimeTickListener.remove();\n this.documentTimeTickListener = null;\n }\n }\n }\n }\n\n public addAnimation(animation: AttributeAnimation, key: string) {\n const state = this.stateByAttribute[key];\n if (!state) {\n return;\n }\n if (state.animationsSet.size === 0 && state.lerpsSet.size === 0) {\n // start listening to document time\n this.documentTimeTickListener = this.element.addDocumentTimeTickListener((documentTime) => {\n this.updateTime(documentTime);\n });\n }\n this.allAnimations.add(animation);\n state.animationsSet.add(animation);\n state.animationsInOrder = [];\n const elementChildren = Array.from(this.element.children);\n for (const child of elementChildren) {\n if (state.animationsSet.has(child as AttributeAnimation)) {\n state.animationsInOrder.push(child as AttributeAnimation);\n }\n }\n }\n\n public removeAnimation(animation: AttributeAnimation, key: string) {\n const state = this.stateByAttribute[key];\n if (!state) {\n return;\n }\n state.animationsInOrder.splice(state.animationsInOrder.indexOf(animation), 1);\n state.animationsSet.delete(animation);\n if (state.animationsSet.size === 0) {\n updateIfChangedValue(state, state.attributeState.elementValue);\n }\n this.allAnimations.delete(animation);\n if (this.allAnimations.size === 0) {\n // stop listening to document time\n if (this.documentTimeTickListener) {\n this.documentTimeTickListener.remove();\n this.documentTimeTickListener = null;\n }\n }\n }\n\n public updateTime(documentTime: number) {\n this.hasTicked = true;\n\n for (const key in this.stateByAttribute) {\n let stale: { value: number | MMLColor; state: number } | null = null;\n const state = this.stateByAttribute[key];\n for (const animation of state.animationsInOrder) {\n const [newValue, active] =\n state.attributeState.type === AnimationType.Color\n ? animation.getColorValueForTime(documentTime)\n : animation.getFloatValueForTime(documentTime);\n\n if (active === 0) {\n updateIfChangedValue(state, newValue);\n stale = null;\n break;\n } else {\n if (stale === null) {\n stale = { value: newValue, state: active };\n } else {\n const isAboutToStartRatherThanEnded = stale.state > 0 && active < 0;\n const isMoreRecentEnd = stale.state > 0 && active > 0 && stale.state > active;\n const isSoonerToStart = stale.state < 0 && active < 0 && stale.state < active;\n\n if (isAboutToStartRatherThanEnded || isMoreRecentEnd || isSoonerToStart) {\n stale = { value: newValue, state: active };\n }\n }\n }\n }\n\n if (stale !== null) {\n updateIfChangedValue(state, stale.value);\n continue;\n }\n\n if (state.lerpsInOrder.length > 0) {\n const lerp = state.lerpsInOrder[0];\n const config = state.attributeState;\n if (\n config.elementValueSetTime !== null &&\n config.previousValue !== null &&\n config.elementValue !== null\n ) {\n if (isColorAttribute(config)) {\n updateIfChangedValue(\n state,\n lerp.getColorValueForTime(\n this.element.getWindowTime(),\n config.elementValueSetTime,\n config.elementValue,\n config.previousValue,\n ),\n );\n } else if (isNumberAttribute(config)) {\n updateIfChangedValue(\n state,\n lerp.getFloatValueForTime(\n this.element.getWindowTime(),\n config.elementValueSetTime,\n config.elementValue,\n config.previousValue,\n ),\n );\n }\n }\n }\n }\n }\n\n reset() {\n for (const key in this.handlers) {\n const state = TupleToState(this.handlers[key]);\n this.stateByAttribute[key] = {\n attributeState: state,\n animationsInOrder: [],\n animationsSet: new Set(),\n lerpsInOrder: [],\n lerpsSet: new Set(),\n };\n }\n }\n}\n", "/* ============================================================\n * jQuery Easing v1.3 - http://gsgd.co.uk/sandbox/jquery/easing/\n *\n * Open source under the BSD License.\n *\n * Copyright \u00A9 2008 George McGinley Smith\n * All rights reserved.\n * https://raw.github.com/danro/jquery-easing/master/LICENSE\n * ======================================================== */\n\nexport const easingFunctions = {\n easeInQuad(t: number, b: number, c: number, d: number): number {\n return c * (t /= d) * t + b;\n },\n easeOutQuad(t: number, b: number, c: number, d: number): number {\n return -c * (t /= d) * (t - 2) + b;\n },\n easeInOutQuad(t: number, b: number, c: number, d: number): number {\n if ((t /= d / 2) < 1) return (c / 2) * t * t + b;\n return (-c / 2) * (--t * (t - 2) - 1) + b;\n },\n easeInCubic(t: number, b: number, c: number, d: number): number {\n return c * (t /= d) * t * t + b;\n },\n easeOutCubic(t: number, b: number, c: number, d: number): number {\n return c * ((t = t / d - 1) * t * t + 1) + b;\n },\n easeInOutCubic(t: number, b: number, c: number, d: number): number {\n if ((t /= d / 2) < 1) return (c / 2) * t * t * t + b;\n return (c / 2) * ((t -= 2) * t * t + 2) + b;\n },\n easeInQuart(t: number, b: number, c: number, d: number): number {\n return c * (t /= d) * t * t * t + b;\n },\n easeOutQuart(t: number, b: number, c: number, d: number): number {\n return -c * ((t = t / d - 1) * t * t * t - 1) + b;\n },\n easeInOutQuart(t: number, b: number, c: number, d: number): number {\n if ((t /= d / 2) < 1) return (c / 2) * t * t * t * t + b;\n return (-c / 2) * ((t -= 2) * t * t * t - 2) + b;\n },\n easeInQuint(t: number, b: number, c: number, d: number): number {\n return c * (t /= d) * t * t * t * t + b;\n },\n easeOutQuint(t: number, b: number, c: number, d: number): number {\n return c * ((t = t / d - 1) * t * t * t * t + 1) + b;\n },\n easeInOutQuint(t: number, b: number, c: number, d: number): number {\n if ((t /= d / 2) < 1) return (c / 2) * t * t * t * t * t + b;\n return (c / 2) * ((t -= 2) * t * t * t * t + 2) + b;\n },\n easeInSine(t: number, b: number, c: number, d: number): number {\n return -c * Math.cos((t / d) * (Math.PI / 2)) + c + b;\n },\n easeOutSine(t: number, b: number, c: number, d: number): number {\n return c * Math.sin((t / d) * (Math.PI / 2)) + b;\n },\n easeInOutSine(t: number, b: number, c: number, d: number): number {\n return (-c / 2) * (Math.cos((Math.PI * t) / d) - 1) + b;\n },\n easeInExpo(t: number, b: number, c: number, d: number): number {\n return t === 0 ? b : c * Math.pow(2, 10 * (t / d - 1)) + b;\n },\n easeOutExpo(t: number, b: number, c: number, d: number): number {\n return t === d ? b + c : c * (-Math.pow(2, (-10 * t) / d) + 1) + b;\n },\n easeInOutExpo(t: number, b: number, c: number, d: number): number {\n if (t === 0) return b;\n if (t === d) return b + c;\n if ((t /= d / 2) < 1) return (c / 2) * Math.pow(2, 10 * (t - 1)) + b;\n return (c / 2) * (-Math.pow(2, -10 * --t) + 2) + b;\n },\n easeInCirc(t: number, b: number, c: number, d: number): number {\n return -c * (Math.sqrt(1 - (t /= d) * t) - 1) + b;\n },\n easeOutCirc(t: number, b: number, c: number, d: number): number {\n return c * Math.sqrt(1 - (t = t / d - 1) * t) + b;\n },\n easeInOutCirc(t: number, b: number, c: number, d: number): number {\n if ((t /= d / 2) < 1) return (-c / 2) * (Math.sqrt(1 - t * t) - 1) + b;\n return (c / 2) * (Math.sqrt(1 - (t -= 2) * t) + 1) + b;\n },\n easeInElastic(t: number, b: number, c: number, d: number): number {\n let s = 1.70158;\n let p = 0;\n let a = c;\n if (t === 0) return b;\n if ((t /= d) === 1) return b + c;\n if (!p) p = d * 0.3;\n if (a < Math.abs(c)) {\n a = c;\n s = p / 4;\n } else {\n s = (p / (2 * Math.PI)) * Math.asin(c / a);\n }\n return -(a * Math.pow(2, 10 * (t -= 1)) * Math.sin(((t * d - s) * (2 * Math.PI)) / p)) + b;\n },\n easeOutElastic(t: number, b: number, c: number, d: number): number {\n let s = 1.70158;\n let p = 0;\n let a = c;\n if (t === 0) return b;\n if ((t /= d) === 1) return b + c;\n if (!p) p = d * 0.3;\n if (a < Math.abs(c)) {\n a = c;\n s = p / 4;\n } else {\n s = (p / (2 * Math.PI)) * Math.asin(c / a);\n }\n return a * Math.pow(2, -10 * t) * Math.sin(((t * d - s) * (2 * Math.PI)) / p) + c + b;\n },\n easeInOutElastic(t: number, b: number, c: number, d: number): number {\n let s = 1.70158;\n let p = 0;\n let a = c;\n if (t === 0) return b;\n if ((t /= d / 2) === 2) return b + c;\n if (!p) p = d * (0.3 * 1.5);\n if (a < Math.abs(c)) {\n a = c;\n s = p / 4;\n } else {\n s = (p / (2 * Math.PI)) * Math.asin(c / a);\n }\n if (t < 1)\n return (\n -0.5 * (a * Math.pow(2, 10 * (t -= 1)) * Math.sin(((t * d - s) * (2 * Math.PI)) / p)) + b\n );\n return (\n a * Math.pow(2, -10 * (t -= 1)) * Math.sin(((t * d - s) * (2 * Math.PI)) / p) * 0.5 + c + b\n );\n },\n easeInBack(t: number, b: number, c: number, d: number) {\n const s = 1.70158;\n return c * (t /= d) * t * ((s + 1) * t - s) + b;\n },\n easeOutBack(t: number, b: number, c: number, d: number) {\n const s = 1.70158;\n return c * ((t = t / d - 1) * t * ((s + 1) * t + s) + 1) + b;\n },\n easeInOutBack(t: number, b: number, c: number, d: number) {\n let s = 1.70158;\n if ((t /= d / 2) < 1) return (c / 2) * (t * t * (((s *= 1.525) + 1) * t - s)) + b;\n return (c / 2) * ((t -= 2) * t * (((s *= 1.525) + 1) * t + s) + 2) + b;\n },\n easeInBounce(t: number, b: number, c: number, d: number): number {\n return c - easingFunctions.easeOutBounce(d - t, 0, c, d) + b;\n },\n easeOutBounce(t: number, b: number, c: number, d: number): number {\n if ((t /= d) < 1 / 2.75) {\n return c * (7.5625 * t * t) + b;\n } else if (t < 2 / 2.75) {\n return c * (7.5625 * (t -= 1.5 / 2.75) * t + 0.75) + b;\n } else if (t < 2.5 / 2.75) {\n return c * (7.5625 * (t -= 2.25 / 2.75) * t + 0.9375) + b;\n } else {\n return c * (7.5625 * (t -= 2.625 / 2.75) * t + 0.984375) + b;\n }\n },\n easeInOutBounce(t: number, b: number, c: number, d: number): number {\n if (t < d / 2) return easingFunctions.easeInBounce(t * 2, 0, c, d) * 0.5 + b;\n return easingFunctions.easeOutBounce(t * 2 - d, 0, c, d) * 0.5 + c * 0.5 + b;\n },\n};\n/*\n *\n * TERMS OF USE - EASING EQUATIONS\n *\n * Open source under the BSD License.\n *\n * Copyright \u00A9 2001 Robert Penner\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without modification,\n * are permitted provided that the following conditions are met:\n *\n * Redistributions of source code must retain the above copyright notice, this list of\n * conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright notice, this list\n * of conditions and the following disclaimer in the documentation and/or other materials\n * provided with the distribution.\n *\n * Neither the name of the author nor the names of contributors may be used to endorse\n * or promote products derived from this software without specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND ANY\n * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF\n * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE\n * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,\n * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE\n * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED\n * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING\n * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED\n * OF THE POSSIBILITY OF SUCH DAMAGE.\n *\n */\n", "import { easingFunctions } from \"./easingFunctions\";\n\nexport const easingsByName: Record<\n string,\n (amount: number, base: number, change: number, duration: number) => number\n> = easingFunctions;\n", "import { easingsByName } from \"./easings\";\n\nexport const StartOfAnimationSymbol = Symbol(\"Start\");\nexport const EndOfAnimationSymbol = Symbol(\"End\");\n\n// Returns [current ratio | start | end symbols, state (negative if before start, zero if running, positive if after end)]\nexport function getEasedRatioForTime(\n docTimeMs: number,\n props: {\n startTime: number;\n pauseTime: number | null;\n animDuration: number;\n loop: boolean;\n pingPong: boolean;\n pingPongDelay: number;\n easing: string;\n },\n): [typeof StartOfAnimationSymbol | number | typeof EndOfAnimationSymbol, number] {\n if (props.pauseTime !== null && docTimeMs >= props.pauseTime) {\n docTimeMs = props.pauseTime;\n }\n let elapsedTime = docTimeMs - props.startTime;\n if (elapsedTime < 0) {\n return [StartOfAnimationSymbol, elapsedTime];\n } else if (elapsedTime < props.animDuration || props.loop) {\n if (props.loop) {\n elapsedTime = elapsedTime % props.animDuration;\n }\n let elapsedRatio = elapsedTime / props.animDuration;\n if (props.pingPong) {\n let pingPongDelayRatio = props.pingPongDelay / props.animDuration;\n if (pingPongDelayRatio < 0) {\n pingPongDelayRatio = 0;\n }\n if (pingPongDelayRatio > 0.5) {\n pingPongDelayRatio = 0.5;\n }\n\n /*\n ping-pong-delay describes how long the animation should stay at the start and end values.\n The attribute describes the delay at each end - therefore a ping-pong-delay of 1000 on a duration of 10000 means\n that the animation should stay at the start value for 500ms, then animate to the end value up until 4500ms,\n before waiting for 1000ms at the end value, and then animating back to the start value until 9500ms\n */\n\n if (elapsedRatio < pingPongDelayRatio / 2) {\n elapsedRatio = 0;\n } else if (\n elapsedRatio > 0.5 - pingPongDelayRatio / 2 &&\n elapsedRatio < 0.5 + pingPongDelayRatio / 2\n ) {\n elapsedRatio = 1;\n } else if (elapsedRatio > 1 - pingPongDelayRatio / 2) {\n elapsedRatio = 0;\n } else {\n // The loop should reach the end value at half the time and then return\n // to the start value at the end of the loop.\n if (elapsedRatio > 0.5) {\n elapsedRatio =\n ((elapsedRatio - 0.5 - pingPongDelayRatio / 2) * 2) / (1 - pingPongDelayRatio * 2);\n elapsedRatio = 1 - elapsedRatio;\n } else {\n elapsedRatio =\n ((elapsedRatio - pingPongDelayRatio / 2) * 2) / (1 - pingPongDelayRatio * 2);\n }\n }\n }\n let newValue;\n const easingFunction = easingsByName[props.easing];\n if (easingFunction) {\n newValue = easingFunction(elapsedRatio, 0, 1, 1);\n } else {\n newValue = elapsedRatio;\n }\n return [newValue, 0];\n } else {\n if (props.pingPong) {\n // ping-pong animations return to the start value at the end of their duration so the \"final\" state should be the start value.\n return [StartOfAnimationSymbol, elapsedTime - props.animDuration];\n }\n return [EndOfAnimationSymbol, elapsedTime - props.animDuration];\n }\n}\n", "// Largely based on https://github.com/mrdoob/three.js/blob/master/src/math/Quaternion.js\n\nimport { Matr4 } from \"./Matr4\";\n\nexport class Quat {\n public x: number;\n public y: number;\n public z: number;\n public w: number;\n\n constructor(x?: number | Quat, y?: number, z?: number, w?: number) {\n if (x instanceof Quat) {\n this.x = x.x;\n this.y = x.y;\n this.z = x.z;\n this.w = x.w;\n return;\n }\n this.x = x || 0;\n this.y = y || 0;\n this.z = z || 0;\n this.w = w || 1;\n }\n\n copy(other: { x?: number; y?: number; z?: number; w?: number }): this {\n this.x = other.x || 0;\n this.y = other.y || 0;\n this.z = other.z || 0;\n this.w = other.w || 0;\n return this;\n }\n\n multiply(q: { x: number; y: number; z: number; w: number }): this {\n return this.multiplyQuaternions(this, q);\n }\n\n premultiply(q: { x: number; y: number; z: number; w: number }): this {\n return this.multiplyQuaternions(q, this);\n }\n\n multiplyQuaternions(\n a: { x: number; y: number; z: number; w: number },\n b: { x: number; y: number; z: number; w: number },\n ): this {\n const qax = a.x;\n const qay = a.y;\n const qaz = a.z;\n const qaw = a.w;\n const qbx = b.x;\n const qby = b.y;\n const qbz = b.z;\n const qbw = b.w;\n\n this.x = qax * qbw + qaw * qbx + qay * qbz - qaz * qby;\n this.y = qay * qbw + qaw * qby + qaz * qbx - qax * qbz;\n this.z = qaz * qbw + qaw * qbz + qax * qby - qay * qbx;\n this.w = qaw * qbw - qax * qbx - qay * qby - qaz * qbz;\n\n return this;\n }\n\n setFromEulerXYZ(euler: { x: number; y: number; z: number }): this {\n const x = euler.x;\n const y = euler.y;\n const z = euler.z;\n\n const cos = Math.cos;\n const sin = Math.sin;\n\n const c1 = cos(x / 2);\n const c2 = cos(y / 2);\n const c3 = cos(z / 2);\n\n const s1 = sin(x / 2);\n const s2 = sin(y / 2);\n const s3 = sin(z / 2);\n\n this.x = s1 * c2 * c3 + c1 * s2 * s3;\n this.y = c1 * s2 * c3 - s1 * c2 * s3;\n this.z = c1 * c2 * s3 + s1 * s2 * c3;\n this.w = c1 * c2 * c3 - s1 * s2 * s3;\n\n return this;\n }\n\n setFromRotationMatrix(m: Matr4): this {\n // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)\n const te = m.data,\n m11 = te[0],\n m12 = te[4],\n m13 = te[8],\n m21 = te[1],\n m22 = te[5],\n m23 = te[9],\n m31 = te[2],\n m32 = te[6],\n m33 = te[10],\n trace = m11 + m22 + m33;\n\n if (trace > 0) {\n const s = 0.5 / Math.sqrt(trace + 1.0);\n\n this.w = 0.25 / s;\n this.x = (m32 - m23) * s;\n this.y = (m13 - m31) * s;\n this.z = (m21 - m12) * s;\n } else if (m11 > m22 && m11 > m33) {\n const s = 2.0 * Math.sqrt(1.0 + m11 - m22 - m33);\n\n this.w = (m32 - m23) / s;\n this.x = 0.25 * s;\n this.y = (m12 + m21) / s;\n this.z = (m13 + m31) / s;\n } else if (m22 > m33) {\n const s = 2.0 * Math.sqrt(1.0 + m22 - m11 - m33);\n\n this.w = (m13 - m31) / s;\n this.x = (m12 + m21) / s;\n this.y = 0.25 * s;\n this.z = (m23 + m32) / s;\n } else {\n const s = 2.0 * Math.sqrt(1.0 + m33 - m11 - m22);\n\n this.w = (m21 - m12) / s;\n this.x = (m13 + m31) / s;\n this.y = (m23 + m32) / s;\n this.z = 0.25 * s;\n }\n\n return this;\n }\n\n setFromAxisAngle(axis: { x: number; y: number; z: number }, angle: number): this {\n // assumes axis is normalized\n\n const halfAngle = angle / 2;\n const s = Math.sin(halfAngle);\n\n this.x = axis.x * s;\n this.y = axis.y * s;\n this.z = axis.z * s;\n this.w = Math.cos(halfAngle);\n\n return this;\n }\n\n clone(): Quat {\n return new Quat(this);\n }\n\n set(x: number, y: number, z: number, w: number): this {\n this.x = x;\n this.y = y;\n this.z = z;\n this.w = w;\n return this;\n }\n}\n", "import { Matr4Data } from \"./Matr4\";\n\nexport type IVect3 = { x: number; y: number; z: number };\n\nexport class Vect3 {\n public x: number;\n public y: number;\n public z: number;\n\n constructor(x?: number | IVect3, y?: number, z?: number) {\n if (x && typeof x === \"object\") {\n this.x = x.x;\n this.y = x.y;\n this.z = x.z;\n return;\n }\n this.x = x || 0;\n this.y = y || 0;\n this.z = z || 0;\n }\n\n copy(other: IVect3): this {\n this.x = other.x || 0;\n this.y = other.y || 0;\n this.z = other.z || 0;\n return this;\n }\n\n length(): number {\n return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);\n }\n\n lengthSquared(): number {\n return this.x * this.x + this.y * this.y + this.z * this.z;\n }\n\n clone(): Vect3 {\n return new Vect3(this);\n }\n\n set(x: number, y: number, z: number): this {\n this.x = x;\n this.y = y;\n this.z = z;\n return this;\n }\n\n applyMatrix4(matrix: { data: Matr4Data }): this {\n const x = this.x;\n const y = this.y;\n const z = this.z;\n const e = matrix.data;\n\n const w = 1 / (e[3] * x + e[7] * y + e[11] * z + e[15]);\n\n this.x = (e[0] * x + e[4] * y + e[8] * z + e[12]) * w;\n this.y = (e[1] * x + e[5] * y + e[9] * z + e[13]) * w;\n this.z = (e[2] * x + e[6] * y + e[10] * z + e[14]) * w;\n\n return this;\n }\n\n add(other: IVect3) {\n this.x += other.x || 0;\n this.y += other.y || 0;\n this.z += other.z || 0;\n return this;\n }\n\n sub(other: IVect3) {\n this.x -= other.x || 0;\n this.y -= other.y || 0;\n this.z -= other.z || 0;\n return this;\n }\n}\n", "// Largely based on https://github.com/mrdoob/three.js/blob/master/src/math/Matrix4.js\nimport { Quat } from \"./Quat\";\nimport { Vect3 } from \"./Vect3\";\n\nconst Vect3Zeroes = { x: 0, y: 0, z: 0 };\nconst Vect3Ones = { x: 1, y: 1, z: 1 };\n\nexport type Matr4Data = [\n number,\n number,\n number,\n number,\n number,\n number,\n number,\n number,\n number,\n number,\n number,\n number,\n number,\n number,\n number,\n number,\n];\n\nexport class Matr4 {\n static tempMatr4 = new Matr4();\n static tempVect3 = new Vect3();\n static tempQuat = new Quat();\n\n public data: Matr4Data;\n\n constructor(data?: Matr4Data | Matr4 | Float32Array) {\n if (data instanceof Matr4) {\n this.data = [...data.data];\n } else if (data instanceof Array) {\n this.data = [...data];\n } else if (data instanceof Float32Array) {\n this.data = [...data] as Matr4Data;\n } else {\n this.data = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];\n }\n }\n\n identity(): this {\n this.data = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];\n return this;\n }\n\n copy(m: Matr4): Matr4 {\n this.data = [...m.data];\n return this;\n }\n\n set(...args: Matr4Data | [Matr4Data]): this {\n if (args[0] instanceof Array) {\n this.data = args[0];\n } else {\n this.data = args as Matr4Data;\n }\n return this;\n }\n\n public setRotationFromQuaternion(q: { x: number; y: number; z: number; w: number }): this {\n return this.compose(Vect3Zeroes, q, Vect3Ones);\n }\n\n clone(): Matr4 {\n return new Matr4(this.data);\n }\n\n determinant(): number {\n const te = this.data;\n\n const n11 = te[0],\n n12 = te[4],\n n13 = te[8],\n n14 = te[12];\n const n21 = te[1],\n n22 = te[5],\n n23 = te[9],\n n24 = te[13];\n const n31 = te[2],\n n32 = te[6],\n n33 = te[10],\n n34 = te[14];\n const n41 = te[3],\n n42 = te[7],\n n43 = te[11],\n n44 = te[15];\n\n return (\n n41 *\n (+n14 * n23 * n32 -\n n13 * n24 * n32 -\n n14 * n22 * n33 +\n n12 * n24 * n33 +\n n13 * n22 * n34 -\n n12 * n23 * n34) +\n n42 *\n (+n11 * n23 * n34 -\n n11 * n24 * n33 +\n n14 * n21 * n33 -\n n13 * n21 * n34 +\n n13 * n24 * n31 -\n n14 * n23 * n31) +\n n43 *\n (+n11 * n24 * n32 -\n n11 * n22 * n34 -\n n14 * n21 * n32 +\n n12 * n21 * n34 +\n n14 * n22 * n31 -\n n12 * n24 * n31) +\n n44 *\n (-n13 * n22 * n31 -\n n11 * n23 * n32 +\n n11 * n22 * n33 +\n n13 * n21 * n32 -\n n12 * n21 * n33 +\n n12 * n23 * n31)\n );\n }\n\n makeRotationX(theta: number) {\n const c = Math.cos(theta),\n s = Math.sin(theta);\n\n this.set(1, 0, 0, 0, 0, c, -s, 0, 0, s, c, 0, 0, 0, 0, 1);\n\n return this;\n }\n\n makeRotationY(theta: number) {\n const c = Math.cos(theta),\n s = Math.sin(theta);\n\n this.set(c, 0, s, 0, 0, 1, 0, 0, -s, 0, c, 0, 0, 0, 0, 1);\n\n return this;\n }\n\n makeRotationZ(theta: number) {\n const c = Math.cos(theta),\n s = Math.sin(theta);\n\n this.set(c, -s, 0, 0, s, c, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);\n return this;\n }\n\n makeTranslation(x: number, y: number, z: number) {\n this.set(1, 0, 0, x, 0, 1, 0, y, 0, 0, 1, z, 0, 0, 0, 1);\n return this;\n }\n\n makeScale(x: number, y: number, z: number) {\n this.set(x, 0, 0, 0, 0, y, 0, 0, 0, 0, z, 0, 0, 0, 0, 1);\n return this;\n }\n\n compose(\n position: { x: number; y: number; z: number },\n quaternion: { x: number; y: number; z: number; w: number },\n scale: { x: number; y: number; z: number },\n ): this {\n const te = this.data;\n\n const x = quaternion.x,\n y = quaternion.y,\n z = quaternion.z,\n w = quaternion.w;\n const x2 = x + x,\n y2 = y + y,\n z2 = z + z;\n const xx = x * x2,\n xy = x * y2,\n xz = x * z2;\n const yy = y * y2,\n yz = y * z2,\n zz = z * z2;\n const wx = w * x2,\n wy = w * y2,\n wz = w * z2;\n\n const sx = scale.x,\n sy = scale.y,\n sz = scale.z;\n\n te[0] = (1 - (yy + zz)) * sx;\n te[1] = (xy + wz) * sx;\n te[2] = (xz - wy) * sx;\n te[3] = 0;\n\n te[4] = (xy - wz) * sy;\n te[5] = (1 - (xx + zz)) * sy;\n te[6] = (yz + wx) * sy;\n te[7] = 0;\n\n te[8] = (xz + wy) * sz;\n te[9] = (yz - wx) * sz;\n te[10] = (1 - (xx + yy)) * sz;\n te[11] = 0;\n\n te[12] = position.x;\n te[13] = position.y;\n te[14] = position.z;\n te[15] = 1;\n\n return this;\n }\n\n decompose(\n position: { x: number; y: number; z: number },\n quaternion: { x: number; y: number; z: number; w: number },\n scale: { x: number; y: number; z: number },\n ): this {\n const te = this.data;\n\n const _v1 = Matr4.tempVect3;\n let sx = _v1.set(te[0], te[1], te[2]).length();\n const sy = _v1.set(te[4], te[5], te[6]).length();\n const sz = _v1.set(te[8], te[9], te[10]).length();\n\n // if determine is negative, we need to invert one scale\n const det = this.determinant();\n if (det < 0) sx = -sx;\n\n position.x = te[12];\n position.y = te[13];\n position.z = te[14];\n\n // scale the rotation part\n const _m1 = Matr4.tempMatr4;\n _m1.copy(this);\n\n const invSX = 1 / sx;\n const invSY = 1 / sy;\n const invSZ = 1 / sz;\n\n _m1.data[0] *= invSX;\n _m1.data[1] *= invSX;\n _m1.data[2] *= invSX;\n\n _m1.data[4] *= invSY;\n _m1.data[5] *= invSY;\n _m1.data[6] *= invSY;\n\n _m1.data[8] *= invSZ;\n _m1.data[9] *= invSZ;\n _m1.data[10] *= invSZ;\n\n const _q1 = Matr4.tempQuat;\n _q1.setFromRotationMatrix(_m1);\n\n quaternion.x = _q1.x;\n quaternion.y = _q1.y;\n quaternion.z = _q1.z;\n quaternion.w = _q1.w;\n\n scale.x = sx;\n scale.y = sy;\n scale.z = sz;\n\n return this;\n }\n\n multiply(m: Matr4): this {\n return this.multiplyMatrices(this, m);\n }\n\n premultiply(m: Matr4): this {\n return this.multiplyMatrices(m, this);\n }\n\n multiplyMatrices(a: Matr4, b: Matr4): this {\n const ae = a.data;\n const be = b.data;\n const te = this.data;\n\n const a11 = ae[0],\n a12 = ae[4],\n a13 = ae[8],\n a14 = ae[12];\n const a21 = ae[1],\n a22 = ae[5],\n a23 = ae[9],\n a24 = ae[13];\n const a31 = ae[2],\n a32 = ae[6],\n a33 = ae[10],\n a34 = ae[14];\n const a41 = ae[3],\n a42 = ae[7],\n a43 = ae[11],\n a44 = ae[15];\n\n const b11 = be[0],\n b12 = be[4],\n b13 = be[8],\n b14 = be[12];\n const b21 = be[1],\n b22 = be[5],\n b23 = be[9],\n b24 = be[13];\n const b31 = be[2],\n b32 = be[6],\n b33 = be[10],\n b34 = be[14];\n const b41 = be[3],\n b42 = be[7],\n b43 = be[11],\n b44 = be[15];\n\n te[0] = a11 * b11 + a12 * b21 + a13 * b31 + a14 * b41;\n te[4] = a11 * b12 + a12 * b22 + a13 * b32 + a14 * b42;\n te[8] = a11 * b13 + a12 * b23 + a13 * b33 + a14 * b43;\n te[12] = a11 * b14 + a12 * b24 + a13 * b34 + a14 * b44;\n\n te[1] = a21 * b11 + a22 * b21 + a23 * b31 + a24 * b41;\n te[5] = a21 * b12 + a22 * b22 + a23 * b32 + a24 * b42;\n te[9] = a21 * b13 + a22 * b23 + a23 * b33 + a24 * b43;\n te[13] = a21 * b14 + a22 * b24 + a23 * b34 + a24 * b44;\n\n te[2] = a31 * b11 + a32 * b21 + a33 * b31 + a34 * b41;\n te[6] = a31 * b12 + a32 * b22 + a33 * b32 + a34 * b42;\n te[10] = a31 * b13 + a32 * b23 + a33 * b33 + a34 * b43;\n te[14] = a31 * b14 + a32 * b24 + a33 * b34 + a34 * b44;\n\n te[3] = a41 * b11 + a42 * b21 + a43 * b31 + a44 * b41;\n te[7] = a41 * b12 + a42 * b22 + a43 * b32 + a44 * b42;\n te[11] = a41 * b13 + a42 * b23 + a43 * b33 + a44 * b43;\n te[15] = a41 * b14 + a42 * b24 + a43 * b34 + a44 * b44;\n\n return this;\n }\n\n invert(): this {\n // based on http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm\n const te = this.data,\n n11 = te[0],\n n21 = te[1],\n n31 = te[2],\n n41 = te[3],\n n12 = te[4],\n n22 = te[5],\n n32 = te[6],\n n42 = te[7],\n n13 = te[8],\n n23 = te[9],\n n33 = te[10],\n n43 = te[11],\n n14 = te[12],\n n24 = te[13],\n n34 = te[14],\n n44 = te[15],\n t11 =\n n23 * n34 * n42 -\n n24 * n33 * n42 +\n n24 * n32 * n43 -\n n22 * n34 * n43 -\n n23 * n32 * n44 +\n n22 * n33 * n44,\n t12 =\n n14 * n33 * n42 -\n n13 * n34 * n42 -\n n14 * n32 * n43 +\n n12 * n34 * n43 +\n n13 * n32 * n44 -\n n12 * n33 * n44,\n t13 =\n n13 * n24 * n42 -\n n14 * n23 * n42 +\n n14 * n22 * n43 -\n n12 * n24 * n43 -\n n13 * n22 * n44 +\n n12 * n23 * n44,\n t14 =\n n14 * n23 * n32 -\n n13 * n24 * n32 -\n n14 * n22 * n33 +\n n12 * n24 * n33 +\n n13 * n22 * n34 -\n n12 * n23 * n34;\n\n const det = n11 * t11 + n21 * t12 + n31 * t13 + n41 * t14;\n\n if (det === 0) {\n return this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);\n }\n\n const detInv = 1 / det;\n\n te[0] = t11 * detInv;\n te[1] =\n (n24 * n33 * n41 -\n n23 * n34 * n41 -\n n24 * n31 * n43 +\n n21 * n34 * n43 +\n n23 * n31 * n44 -\n n21 * n33 * n44) *\n detInv;\n te[2] =\n (n22 * n34 * n41 -\n n24 * n32 * n41 +\n n24 * n31 * n42 -\n n21 * n34 * n42 -\n n22 * n31 * n44 +\n n21 * n32 * n44) *\n detInv;\n te[3] =\n (n23 * n32 * n41 -\n n22 * n33 * n41 -\n n23 * n31 * n42 +\n n21 * n33 * n42 +\n n22 * n31 * n43 -\n n21 * n32 * n43) *\n detInv;\n\n te[4] = t12 * detInv;\n te[5] =\n (n13 * n34 * n41 -\n n14 * n33 * n41 +\n n14 * n31 * n43 -\n n11 * n34 * n43 -\n n13 * n31 * n44 +\n n11 * n33 * n44) *\n detInv;\n te[6] =\n (n14 * n32 * n41 -\n n12 * n34 * n41 -\n n14 * n31 * n42 +\n n11 * n34 * n42 +\n n12 * n31 * n44 -\n n11 * n32 * n44) *\n detInv;\n te[7] =\n (n12 * n33 * n41 -\n n13 * n32 * n41 +\n n13 * n31 * n42 -\n n11 * n33 * n42 -\n n12 * n31 * n43 +\n n11 * n32 * n43) *\n detInv;\n\n te[8] = t13 * detInv;\n te[9] =\n (n14 * n23 * n41 -\n n13 * n24 * n41 -\n n14 * n21 * n43 +\n n11 * n24 * n43 +\n n13 * n21 * n44 -\n n11 * n23 * n44) *\n detInv;\n te[10] =\n (n12 * n24 * n41 -\n n14 * n22 * n41 +\n n14 * n21 * n42 -\n n11 * n24 * n42 -\n n12 * n21 * n44 +\n n11 * n22 * n44) *\n detInv;\n te[11] =\n (n13 * n22 * n41 -\n n12 * n23 * n41 -\n n13 * n21 * n42 +\n n11 * n23 * n42 +\n n12 * n21 * n43 -\n n11 * n22 * n43) *\n detInv;\n\n te[12] = t14 * detInv;\n te[13] =\n (n13 * n24 * n31 -\n n14 * n23 * n31 +\n n14 * n21 * n33 -\n n11 * n24 * n33 -\n n13 * n21 * n34 +\n n11 * n23 * n34) *\n detInv;\n te[14] =\n (n14 * n22 * n31 -\n n12 * n24 * n31 -\n n14 * n21 * n32 +\n n11 * n24 * n32 +\n n12 * n21 * n34 -\n n11 * n22 * n34) *\n detInv;\n te[15] =\n (n12 * n23 * n31 -\n n13 * n22 * n31 +\n n13 * n21 * n32 -\n n11 * n23 * n32 -\n n12 * n21 * n33 +\n n11 * n22 * n33) *\n detInv;\n\n return this;\n }\n}\n", "import { Matr4 } from \"../math/Matr4\";\nimport { IVect3, Vect3 } from \"../math/Vect3\";\n\n// Amount to tolerate on bounds (to avoid floating point errors)\nconst epsilon = 0.0001;\n\nconst matrix1 = new Matr4();\nconst vector1 = new Vect3();\n\nexport class OrientedBoundingBox {\n private constructor(\n public size: IVect3,\n public matr4: Matr4,\n public centerOffset: IVect3 | null = null,\n ) {}\n\n static fromSizeAndMatrixWorld(size: Vect3, matr4: Matr4): OrientedBoundingBox {\n return new OrientedBoundingBox(size, matr4);\n }\n\n static fromSizeMatrixWorldAndCenter(\n size: IVect3,\n matr4: Matr4,\n centerOffset: IVect3,\n ): OrientedBoundingBox {\n return new OrientedBoundingBox(size, matr4, centerOffset);\n }\n\n static fromMatrixWorld(matr4: Matr4): OrientedBoundingBox {\n return new OrientedBoundingBox(new Vect3(), matr4);\n }\n\n public getCorners(): Vect3[] {\n const corners: Vect3[] = [];\n for (let x = -1; x <= 1; x += 2) {\n for (let y = -1; y <= 1; y += 2) {\n for (let z = -1; z <= 1; z += 2) {\n const point = vector1.set(\n x * (this.size.x / 2),\n y * (this.size.y / 2),\n z * (this.size.z / 2),\n );\n\n if (this.centerOffset !== null) {\n point.add(this.centerOffset);\n }\n\n point.applyMatrix4(this.matr4);\n corners.push(point.clone());\n }\n }\n }\n return corners;\n }\n\n public completelyContainsBoundingBox(childOBB: OrientedBoundingBox): boolean {\n const invertedMatrix = matrix1.copy(this.matr4).invert();\n\n for (let x = -1; x <= 1; x += 2) {\n for (let y = -1; y <= 1; y += 2) {\n for (let z = -1; z <= 1; z += 2) {\n const point = vector1.set(\n x * (childOBB.size.x / 2),\n y * (childOBB.size.y / 2),\n z * (childOBB.size.z / 2),\n );\n\n if (childOBB.centerOffset !== null) {\n point.add(childOBB.centerOffset);\n }\n\n point.applyMatrix4(childOBB.matr4);\n\n const localPoint = point.applyMatrix4(invertedMatrix);\n if (this.centerOffset !== null) {\n localPoint.sub(this.centerOffset);\n }\n const isWithin =\n Math.abs(localPoint.x) <= this.size.x / 2 + epsilon &&\n Math.abs(localPoint.y) <= this.size.y / 2 + epsilon &&\n Math.abs(localPoint.z) <= this.size.z / 2 + epsilon;\n\n if (!isWithin) {\n return false;\n }\n }\n }\n }\n\n return true;\n }\n\n public containsPoint(point: { x: number; y: number; z: number }): boolean {\n const invertedMatrix = matrix1.copy(this.matr4).invert();\n\n const localPoint = vector1.copy(point).applyMatrix4(invertedMatrix);\n if (this.centerOffset !== null) {\n localPoint.sub(this.centerOffset);\n }\n return (\n Math.abs(localPoint.x) <= this.size.x / 2 + epsilon &&\n Math.abs(localPoint.y) <= this.size.y / 2 + epsilon &&\n Math.abs(localPoint.z) <= this.size.z / 2 + epsilon\n );\n }\n}\n", "export type RGBA = {\n r: number;\n g: number;\n b: number;\n a: number;\n};\n\nexport type CanvasTextOptions = {\n fontSize: number;\n textColorRGB255A1: RGBA;\n backgroundColorRGB255A1?: RGBA;\n font?: string;\n bold?: boolean;\n paddingPx?: number;\n alignment?: string;\n dimensions?: {\n width: number;\n height: number;\n };\n};\n\nexport class CanvasText {\n private canvas: HTMLCanvasElement;\n private context: CanvasRenderingContext2D;\n\n constructor() {\n this.canvas = document.createElement(\"canvas\");\n this.context = this.canvas.getContext(\"2d\") as CanvasRenderingContext2D;\n }\n\n public renderText(message: string, options: CanvasTextOptions): HTMLCanvasElement {\n const fontsize = options.fontSize;\n const textColor = options.textColorRGB255A1;\n const backgroundColor = options.backgroundColorRGB255A1 || { r: 255, g: 255, b: 255, a: 1 };\n const padding = options.paddingPx || 0;\n const font = options.font || \"Arial\";\n const fontString = (options.bold ? \"bold \" : \"\") + fontsize + \"px \" + font;\n\n // calculate text alignment offset\n const textAlign = (options.alignment as CanvasTextAlign) ?? \"left\";\n\n if (options.dimensions) {\n // NOTE: setting the canvas dimensions resets the context properties, so\n // we always do it first\n this.canvas.width = options.dimensions.width;\n this.canvas.height = options.dimensions.height;\n this.context.clearRect(0, 0, this.canvas.width, this.canvas.height);\n this.context.font = fontString;\n this.context.textAlign = textAlign;\n this.context.fillStyle = `rgba(${backgroundColor.r}, ${backgroundColor.g}, ${backgroundColor.b}, ${backgroundColor.a})`;\n this.context.lineWidth = 0;\n this.context.fillRect(0, 0, this.canvas.width, this.canvas.height);\n this.context.fillStyle = `rgba(${textColor.r}, ${textColor.g}, ${textColor.b}, ${textColor.a})`;\n this.context.font = fontString;\n printAtWordWrap(\n this.context,\n message,\n textAlign,\n fontsize,\n fontsize,\n this.canvas.width,\n padding,\n );\n } else {\n // NOTE: setting the this.canvas dimensions resets the context properties, so\n // we always do it first. However, we also need to take into account the\n // font size to measure the text in the first place.\n this.context.font = fontString;\n const metrics = this.context.measureText(message);\n const textWidth = metrics.width;\n const textHeight = metrics.fontBoundingBoxAscent + metrics.fontBoundingBoxDescent;\n this.canvas.width = textWidth + padding * 2;\n this.canvas.height = textHeight + padding;\n this.context.clearRect(0, 0, this.canvas.width, this.canvas.height);\n this.context.font = fontString;\n this.context.textAlign = textAlign;\n this.context.fillStyle = `rgba(${backgroundColor.r}, ${backgroundColor.g}, ${backgroundColor.b}, ${backgroundColor.a})`;\n this.context.lineWidth = 0;\n this.context.fillRect(0, 0, this.canvas.width, this.canvas.height);\n this.context.fillStyle = `rgba(${textColor.r}, ${textColor.g}, ${textColor.b}, ${textColor.a})`;\n this.context.font = fontString;\n this.context.fillText(\n message,\n padding + getTextAlignOffset(textAlign, textWidth),\n textHeight,\n );\n }\n\n return this.canvas;\n }\n}\n\nfunction printAtWordWrap(\n context: CanvasRenderingContext2D,\n fullText: string,\n textAlign: CanvasTextAlign,\n y: number,\n lineHeight: number,\n fitWidth: number,\n padding: number,\n) {\n const x = getTextAlignOffset(textAlign, fitWidth - padding * 2);\n const lines = fullText.split(\"\\n\");\n let currentLine = 0;\n for (const text of lines) {\n fitWidth = fitWidth || 0;\n\n if (fitWidth <= 0) {\n context.fillText(text, x, y + lineHeight * currentLine);\n currentLine++;\n continue;\n }\n let words = text.split(\" \");\n let lastWordIndex = 1;\n while (words.length > 0 && lastWordIndex <= words.length) {\n const str = words.slice(0, lastWordIndex).join(\" \");\n const textWidth = context.measureText(str).width;\n if (textWidth + padding * 2 > fitWidth) {\n if (lastWordIndex === 1) {\n lastWordIndex = 2;\n }\n context.fillText(\n words.slice(0, lastWordIndex - 1).join(\" \"),\n x + padding,\n y + lineHeight * currentLine + padding,\n );\n currentLine++;\n words = words.splice(lastWordIndex - 1);\n lastWordIndex = 1;\n } else {\n lastWordIndex++;\n }\n }\n if (lastWordIndex > 0 && words.length > 0) {\n context.fillText(words.join(\" \"), x + padding, y + lineHeight * currentLine + padding);\n currentLine++;\n }\n }\n}\n\nfunction getTextAlignOffset(textAlign: CanvasTextAlign, width: number) {\n switch (textAlign) {\n case \"center\":\n return width / 2;\n case \"right\":\n return width;\n default:\n return 0;\n }\n}\n", "import { AttributeHandler, parseBoolAttribute } from \"../attributes\";\nimport { MElement } from \"../elements\";\nimport { GraphicsAdapter } from \"../graphics\";\nimport { IMMLScene } from \"../scene\";\n\nconst collideAttributeName = \"collide\";\nconst collisionIntervalAttributeName = \"collision-interval\";\nconst defaultCollideable = true;\n\n/**\n * CollideableHelper is a helper class for MML elements that have meshes that should be able to be collided with.\n *\n * It reacts to the attribute values for the collide and collision-interval attributes and adds, updates, or removes the\n * collider from the MMLScene as appropriate.\n */\nexport class CollideableHelper {\n private element: MElement;\n\n private props = {\n collide: defaultCollideable,\n };\n\n static AttributeHandler = new AttributeHandler>({\n [collideAttributeName]: (instance, newValue) => {\n const collide = parseBoolAttribute(newValue, defaultCollideable);\n if (collide !== instance.props.collide) {\n instance.props.collide = collide;\n instance.updateCollider(instance.collider);\n }\n },\n [collisionIntervalAttributeName]: () => {\n // Collision interval is handled by the MMLCollisionTrigger, but is here for completeness of attribute handling\n },\n });\n static observedAttributes = CollideableHelper.AttributeHandler.getAttributes();\n\n constructor(element: MElement) {\n this.element = element;\n }\n\n private scene: IMMLScene | null = null;\n private collider: unknown | null = null;\n private added: boolean = false;\n private enabled: boolean = true;\n\n public enable() {\n if (this.enabled) {\n return;\n }\n\n this.enabled = true;\n this.updateCollider(this.collider);\n }\n\n public disable() {\n if (!this.enabled) {\n return;\n }\n\n this.enabled = false;\n this.updateCollider(this.collider);\n }\n\n public updateCollider(collider: unknown | null) {\n if (!this.element.isConnected) {\n //element not connected to scene yet - keep track of the collider for when it is connected\n this.collider = collider;\n return;\n }\n\n // store the scene so that colliders can be removed from it even after this node has been removed from the DOM.\n this.scene = this.element.getScene();\n\n const previousCollider = this.collider;\n const colliderChanged = previousCollider !== collider;\n if (colliderChanged) {\n this.added = false;\n }\n this.collider = collider;\n\n const shouldEnableCollider = this.props.collide && this.enabled;\n if (!shouldEnableCollider && previousCollider === null) {\n this.added = false;\n return;\n }\n\n if (shouldEnableCollider) {\n if (colliderChanged && previousCollider !== null) {\n this.scene.removeCollider?.(previousCollider, this.element);\n }\n if (collider !== null) {\n if (this.added) {\n this.scene.updateCollider?.(collider, this.element);\n } else {\n this.added = true;\n this.scene.addCollider?.(collider, this.element);\n }\n }\n } else {\n if (previousCollider !== null) {\n this.added = false;\n this.scene.removeCollider?.(previousCollider, this.element);\n }\n }\n }\n\n public removeColliders() {\n const scene = this.scene;\n if (!scene) {\n // colliders were never added or the scene was already torn down\n return;\n }\n\n if (!this.collider) {\n // no primary object yet, so nothing to collide with\n return;\n }\n\n scene.removeCollider?.(this.collider, this.element);\n\n this.scene = null;\n }\n\n public handle(name: string, newValue: string) {\n CollideableHelper.AttributeHandler.handle(this, name, newValue);\n }\n\n public parentTransformed() {\n this.updateCollider(this.collider);\n }\n}\n", "import { MElement } from \"../elements\";\nimport { GraphicsAdapter } from \"../graphics\";\n\nexport type CollisionData = {\n position: { x: number; y: number; z: number };\n};\n\nexport type ColliderData = {\n collider: T;\n mElement: MElement;\n currentlyColliding: boolean;\n lastUpdate: number;\n};\n\nconst collisionIntervalMinimumMilliseconds = 100;\nconst collisionIntervalAttrName = \"collision-interval\";\nexport const collisionStartEventName = \"collisionstart\";\nexport const collisionMoveEventName = \"collisionmove\";\nexport const collisionEndEventName = \"collisionend\";\n\nexport function getCollisionInterval(mElement: MElement): null | number {\n const collisionEventsAttr = mElement.getAttribute(collisionIntervalAttrName);\n if (collisionEventsAttr === null) {\n return null;\n }\n const parsed = parseFloat(collisionEventsAttr);\n if (isNaN(parsed)) {\n return null;\n }\n return parsed;\n}\n\n/**\n * The MMLCollisionTrigger class is responsible for keeping track of which colliders the \"user\" (avatar) is currently\n * colliding with, and dispatches events to the elements if they are listening for collisions.\n */\nexport class MMLCollisionTrigger {\n private colliderToElementMap = new Map>();\n private currentCollidingColliders = new Set();\n\n static init(): MMLCollisionTrigger {\n return new MMLCollisionTrigger();\n }\n\n public setCurrentCollisions(currentCollisions: Map | null) {\n const currentTime = performance.now();\n if (currentCollisions) {\n for (const [collider, collisionData] of currentCollisions) {\n const colliderData = this.colliderToElementMap.get(collider);\n if (colliderData) {\n let listeningInterval = getCollisionInterval(colliderData.mElement);\n if (listeningInterval === null) {\n // Not listening for collisions - if colliding then record stopping\n if (colliderData.currentlyColliding) {\n colliderData.lastUpdate = currentTime;\n colliderData.currentlyColliding = false;\n }\n } else {\n if (listeningInterval < collisionIntervalMinimumMilliseconds) {\n listeningInterval = collisionIntervalMinimumMilliseconds;\n }\n if (colliderData.lastUpdate < currentTime - listeningInterval) {\n colliderData.lastUpdate = currentTime;\n if (!colliderData.currentlyColliding) {\n colliderData.currentlyColliding = true;\n colliderData.mElement.dispatchEvent(\n new CustomEvent(collisionStartEventName, {\n bubbles: true,\n detail: {\n position: collisionData.position,\n },\n }),\n );\n this.currentCollidingColliders.add(collider);\n } else {\n colliderData.mElement.dispatchEvent(\n new CustomEvent(collisionMoveEventName, {\n bubbles: true,\n detail: {\n position: collisionData.position,\n },\n }),\n );\n }\n }\n }\n }\n }\n }\n for (const collider of this.currentCollidingColliders) {\n if (!currentCollisions?.has(collider)) {\n this.currentCollidingColliders.delete(collider);\n const colliderData = this.colliderToElementMap.get(collider);\n if (colliderData) {\n colliderData.lastUpdate = currentTime;\n colliderData.currentlyColliding = false;\n colliderData.mElement.dispatchEvent(\n new CustomEvent(collisionEndEventName, {\n bubbles: true,\n detail: {},\n }),\n );\n }\n }\n }\n }\n\n public addCollider(collider: T, mElement: MElement) {\n this.colliderToElementMap.set(collider, {\n collider,\n currentlyColliding: false,\n mElement,\n lastUpdate: 0,\n });\n }\n\n public removeCollider(collider: T) {\n this.colliderToElementMap.delete(collider);\n this.currentCollidingColliders.delete(collider);\n }\n}\n", "import { parseBoolAttribute } from \"../attributes\";\nimport { MElement } from \"../elements\";\nimport { DebugHelperGraphics, GraphicsAdapter } from \"../graphics\";\n\nconst debugAttributeName = \"debug\";\n\nexport class DebugHelper {\n static observedAttributes = [debugAttributeName];\n\n private debugGraphics: DebugHelperGraphics | null = null;\n\n constructor(public element: MElement) {}\n\n public getContainer(): G[\"containerType\"] {\n return this.element.getContainer();\n }\n\n public handle(name: string, newValue: string) {\n if (name === debugAttributeName) {\n if (parseBoolAttribute(newValue, false)) {\n if (!this.debugGraphics) {\n this.debugGraphics = this.element\n .getScene()\n .getGraphicsAdapter()\n .getGraphicsAdapterFactory()\n .MMLDebugHelperGraphicsInterface(this);\n }\n } else {\n this.debugGraphics?.dispose();\n this.debugGraphics = null;\n }\n }\n }\n}\n", "// Largely based on https://github.com/mrdoob/three.js/blob/master/src/math/Euler.js\nimport { Matr4 } from \"./Matr4\";\n\nfunction clamp(value: number, min: number, max: number) {\n return Math.max(min, Math.min(max, value));\n}\n\nexport class EulXYZ {\n private static tempMatrix = new Matr4();\n public x: number;\n public y: number;\n public z: number;\n\n constructor(x?: number | EulXYZ, y?: number, z?: number) {\n if (x instanceof EulXYZ) {\n this.x = x.x;\n this.y = x.y;\n this.z = x.z;\n return;\n }\n this.x = x || 0;\n this.y = y || 0;\n this.z = z || 0;\n }\n\n setFromRotationMatrix(m: Matr4): this {\n const d = m.data;\n const m11 = d[0];\n const m12 = d[4];\n const m13 = d[8];\n const m22 = d[5];\n const m23 = d[9];\n const m32 = d[6];\n const m33 = d[10];\n\n this.y = Math.asin(clamp(m13, -1, 1));\n\n if (Math.abs(m13) < 0.9999999) {\n this.x = Math.atan2(-m23, m33);\n this.z = Math.atan2(-m12, m11);\n } else {\n this.x = Math.atan2(m32, m22);\n this.z = 0;\n }\n\n return this;\n }\n\n setFromQuaternion(q: { x: number; y: number; z: number; w: number }): this {\n const matrix = EulXYZ.tempMatrix;\n matrix.setRotationFromQuaternion(q);\n return this.setFromRotationMatrix(matrix);\n }\n\n copy(other: { x?: number; y?: number; z?: number }): this {\n this.x = other.x || 0;\n this.y = other.y || 0;\n this.z = other.z || 0;\n return this;\n }\n\n length(): number {\n return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);\n }\n\n lengthSquared(): number {\n return this.x * this.x + this.y * this.y + this.z * this.z;\n }\n\n clone(): EulXYZ {\n return new EulXYZ(this);\n }\n\n set(x: number, y: number, z: number): this {\n this.x = x;\n this.y = y;\n this.z = z;\n return this;\n }\n}\n", "export function radToDeg(rad: number): number {\n return rad * (180 / Math.PI);\n}\n\nexport function degToRad(deg: number): number {\n return deg * (Math.PI / 180);\n}\n", "import { AnimatedAttributeHelper } from \"../attribute-animation\";\nimport { AttributeHandler, parseBoolAttribute, parseFloatAttribute } from \"../attributes\";\nimport { OrientedBoundingBox } from \"../bounding-box\";\nimport { DebugHelper } from \"../debug-helper\";\nimport { GraphicsAdapter, TransformableGraphics } from \"../graphics\";\nimport { degToRad, Matr4, Quat } from \"../math\";\nimport { AnimationType } from \"./AttributeAnimation\";\nimport { MElement } from \"./MElement\";\n\n// Workaround for zero-scale values breaking audio playback in THREE PositionalAudio\nfunction minimumNonZero(value: number): number {\n return value === 0 ? 0.000001 : value;\n}\n\nconst defaultVisible = true;\n\nexport type TransformableElementProps = {\n socket: string | null;\n x: number;\n y: number;\n z: number;\n rx: number;\n ry: number;\n rz: number;\n sx: number;\n sy: number;\n sz: number;\n};\n\nexport abstract class TransformableElement<\n G extends GraphicsAdapter = GraphicsAdapter,\n> extends MElement {\n private static tempQuat = new Quat();\n\n private transformableElementProps: TransformableElementProps = {\n socket: null,\n x: 0,\n y: 0,\n z: 0,\n rx: 0,\n ry: 0,\n rz: 0,\n sx: 1,\n sy: 1,\n sz: 1,\n };\n\n private desiredVisible = defaultVisible;\n private appliedBounds = new Map();\n protected directlyDisabledByBounds = false;\n protected disabledByParent = false;\n\n protected transformableElementGraphics: TransformableGraphics | null = null;\n\n private getTransformableElementParent(): TransformableElement | null {\n let parentNode = this.parentNode;\n while (parentNode != null) {\n if (parentNode instanceof TransformableElement) {\n return parentNode;\n }\n parentNode = parentNode.parentNode;\n }\n return null;\n }\n\n calculateLocalMatrix(matrix: Matr4): void {\n const pos = {\n x: this.transformableElementProps.x,\n y: this.transformableElementProps.y,\n z: this.transformableElementProps.z,\n };\n const eulerXYZRotation = {\n x: degToRad(this.transformableElementProps.rx),\n y: degToRad(this.transformableElementProps.ry),\n z: degToRad(this.transformableElementProps.rz),\n };\n const scale = {\n x: this.transformableElementProps.sx,\n y: this.transformableElementProps.sy,\n z: this.transformableElementProps.sz,\n };\n const quaternion = TransformableElement.tempQuat;\n quaternion.setFromEulerXYZ(eulerXYZRotation);\n matrix.compose(pos, quaternion, scale);\n }\n\n public connectedCallback(): void {\n super.connectedCallback();\n\n if (!this.getScene().hasGraphicsAdapter() || this.transformableElementGraphics) {\n return;\n }\n const graphicsAdapter = this.getScene().getGraphicsAdapter();\n\n this.transformableElementGraphics = graphicsAdapter\n .getGraphicsAdapterFactory()\n .MMLTransformableGraphicsInterface(this);\n\n const mElementParent = this.getTransformableElementParent();\n if (mElementParent) {\n const parentBounds = mElementParent.getAppliedBounds();\n parentBounds.forEach((orientedBox, ref) => {\n this.addOrUpdateParentBound(ref, orientedBox);\n });\n return;\n }\n }\n\n disconnectedCallback(): void {\n this.transformableAnimatedAttributeHelper.reset();\n this.transformableElementGraphics?.dispose();\n this.transformableElementGraphics = null;\n super.disconnectedCallback();\n }\n\n private transformableAnimatedAttributeHelper = new AnimatedAttributeHelper(this, {\n x: [\n AnimationType.Number,\n 0,\n (newValue: number) => {\n this.transformableElementProps.x = newValue;\n this.transformableElementGraphics?.setX(newValue, this.transformableElementProps);\n this.didUpdateTransformation();\n },\n ],\n y: [\n AnimationType.Number,\n 0,\n (newValue: number) => {\n this.transformableElementProps.y = newValue;\n this.transformableElementGraphics?.setY(newValue, this.transformableElementProps);\n this.didUpdateTransformation();\n },\n ],\n z: [\n AnimationType.Number,\n 0,\n (newValue: number) => {\n this.transformableElementProps.z = newValue;\n this.transformableElementGraphics?.setZ(newValue, this.transformableElementProps);\n this.didUpdateTransformation();\n },\n ],\n rx: [\n AnimationType.Number,\n 0,\n (newValue: number) => {\n this.transformableElementProps.rx = newValue;\n this.transformableElementGraphics?.setRotationX(newValue, this.transformableElementProps);\n this.didUpdateTransformation();\n },\n ],\n ry: [\n AnimationType.Number,\n 0,\n (newValue: number) => {\n this.transformableElementProps.ry = newValue;\n this.transformableElementGraphics?.setRotationY(newValue, this.transformableElementProps);\n this.didUpdateTransformation();\n },\n ],\n rz: [\n AnimationType.Number,\n 0,\n (newValue: number) => {\n this.transformableElementProps.rz = newValue;\n this.transformableElementGraphics?.setRotationZ(newValue, this.transformableElementProps);\n this.didUpdateTransformation();\n },\n ],\n sx: [\n AnimationType.Number,\n 1,\n (newValue: number) => {\n this.transformableElementProps.sx = newValue;\n this.transformableElementGraphics?.setScaleX(\n minimumNonZero(newValue),\n this.transformableElementProps,\n );\n this.didUpdateTransformation();\n },\n ],\n sy: [\n AnimationType.Number,\n 1,\n (newValue: number) => {\n this.transformableElementProps.sy = newValue;\n this.transformableElementGraphics?.setScaleY(\n minimumNonZero(newValue),\n this.transformableElementProps,\n );\n this.didUpdateTransformation();\n },\n ],\n sz: [\n AnimationType.Number,\n 1,\n (newValue: number) => {\n this.transformableElementProps.sz = newValue;\n this.transformableElementGraphics?.setScaleZ(\n minimumNonZero(newValue),\n this.transformableElementProps,\n );\n this.didUpdateTransformation();\n },\n ],\n });\n\n private static TransformableElementAttributeHandler = new AttributeHandler<\n TransformableElement\n >({\n x: (instance, newValue) => {\n instance.transformableAnimatedAttributeHelper.elementSetAttribute(\n \"x\",\n parseFloatAttribute(newValue, 0),\n );\n },\n y: (instance, newValue) => {\n instance.transformableAnimatedAttributeHelper.elementSetAttribute(\n \"y\",\n parseFloatAttribute(newValue, 0),\n );\n },\n z: (instance, newValue) => {\n instance.transformableAnimatedAttributeHelper.elementSetAttribute(\n \"z\",\n parseFloatAttribute(newValue, 0),\n );\n },\n rx: (instance, newValue) => {\n instance.transformableAnimatedAttributeHelper.elementSetAttribute(\n \"rx\",\n parseFloatAttribute(newValue, 0),\n );\n },\n ry: (instance, newValue) => {\n instance.transformableAnimatedAttributeHelper.elementSetAttribute(\n \"ry\",\n parseFloatAttribute(newValue, 0),\n );\n },\n rz: (instance, newValue) => {\n instance.transformableAnimatedAttributeHelper.elementSetAttribute(\n \"rz\",\n parseFloatAttribute(newValue, 0),\n );\n },\n sx: (instance, newValue) => {\n instance.transformableAnimatedAttributeHelper.elementSetAttribute(\n \"sx\",\n parseFloatAttribute(newValue, 1),\n );\n },\n sy: (instance, newValue) => {\n instance.transformableAnimatedAttributeHelper.elementSetAttribute(\n \"sy\",\n parseFloatAttribute(newValue, 1),\n );\n },\n sz: (instance, newValue) => {\n instance.transformableAnimatedAttributeHelper.elementSetAttribute(\n \"sz\",\n parseFloatAttribute(newValue, 1),\n );\n },\n visible: (instance, newValue) => {\n instance.desiredVisible = parseBoolAttribute(newValue, defaultVisible);\n instance.updateVisibility();\n },\n socket: (instance, newValue) => {\n instance.transformableElementProps.socket = newValue;\n instance.transformableElementGraphics?.setSocket(\n newValue,\n instance.transformableElementProps,\n );\n instance.applyBounds();\n },\n });\n\n static get observedAttributes(): Array {\n return [\n ...TransformableElement.TransformableElementAttributeHandler.getAttributes(),\n ...DebugHelper.observedAttributes,\n ];\n }\n\n private debugHelper = new DebugHelper(this);\n\n public abstract getContentBounds(): OrientedBoundingBox | null;\n\n public addSideEffectChild(child: MElement): void {\n this.transformableAnimatedAttributeHelper.addSideEffectChild(child);\n super.addSideEffectChild(child);\n }\n\n public removeSideEffectChild(child: MElement): void {\n this.transformableAnimatedAttributeHelper.removeSideEffectChild(child);\n super.removeSideEffectChild(child);\n }\n\n protected applyBounds() {\n if (!this.transformableElementGraphics) {\n // This element hasn't been connected yet - ignore the bounds application as it will be applied when connected\n return;\n }\n const appliedBounds = this.getAppliedBounds();\n if (appliedBounds.size > 0) {\n const thisElementBounds = this.getContentBounds();\n if (thisElementBounds) {\n for (const [, orientedBox] of appliedBounds) {\n if (!orientedBox.completelyContainsBoundingBox(thisElementBounds)) {\n if (!this.directlyDisabledByBounds) {\n this.disabledByBounds();\n }\n return;\n }\n }\n }\n }\n this.reenableByBounds();\n }\n\n public didUpdateTransformation() {\n this.applyBounds();\n this.parentTransformed();\n traverseImmediateTransformableElementChildren(this, (child) => {\n child.didUpdateTransformation();\n });\n }\n\n public attributeChangedCallback(name: string, oldValue: string | null, newValue: string) {\n if (!this.transformableElementGraphics) {\n return;\n }\n\n TransformableElement.TransformableElementAttributeHandler.handle(this, name, newValue);\n this.debugHelper.handle(name, newValue);\n }\n\n protected getAppliedBounds(): Map {\n return this.appliedBounds;\n }\n\n public addOrUpdateParentBound(ref: unknown, orientedBox: OrientedBoundingBox): void {\n this.appliedBounds.set(ref, orientedBox);\n traverseImmediateTransformableElementChildren(this, (child) => {\n child.addOrUpdateParentBound(ref, orientedBox);\n });\n this.applyBounds();\n }\n\n public removeParentBound(ref: unknown): void {\n this.appliedBounds.delete(ref);\n traverseImmediateTransformableElementChildren(this, (child) => {\n child.removeParentBound(ref);\n });\n this.applyBounds();\n }\n\n protected disabledByBounds() {\n if (this.directlyDisabledByBounds) {\n return;\n }\n this.directlyDisabledByBounds = true;\n this.updateVisibility();\n if (this.disabledByParent) {\n return;\n }\n this.disable();\n\n traverseImmediateTransformableElementChildren(this, (child) => {\n child.disabledByParentBounds();\n });\n }\n\n public isDisabled() {\n return this.directlyDisabledByBounds || this.disabledByParent;\n }\n\n protected disabledByParentBounds() {\n if (this.disabledByParent) {\n return;\n }\n this.disabledByParent = true;\n this.updateVisibility();\n if (this.directlyDisabledByBounds) {\n return;\n }\n this.disable();\n\n traverseImmediateTransformableElementChildren(this, (child) => {\n child.disabledByParentBounds();\n });\n }\n\n protected abstract disable(): void;\n\n protected reenableByBounds() {\n if (!this.directlyDisabledByBounds) {\n return;\n }\n\n this.directlyDisabledByBounds = false;\n\n if (!this.disabledByParent) {\n this.updateVisibility();\n this.enable();\n\n traverseImmediateTransformableElementChildren(this, (child) => {\n child.reenableByParentBounds();\n });\n }\n }\n\n protected reenableByParentBounds() {\n if (!this.disabledByParent) {\n return;\n }\n this.disabledByParent = false;\n\n if (!this.directlyDisabledByBounds) {\n this.updateVisibility();\n this.enable();\n\n traverseImmediateTransformableElementChildren(this, (child) => {\n child.reenableByParentBounds();\n });\n }\n }\n\n protected abstract enable(): void;\n\n private updateVisibility() {\n this.transformableElementGraphics?.setVisible(\n this.desiredVisible && !this.isDisabled(),\n this.transformableElementProps,\n );\n }\n}\n\nfunction traverseImmediateTransformableElementChildren(\n element: ChildNode,\n callback: (element: TransformableElement) => void,\n) {\n element.childNodes.forEach((child) => {\n if (child instanceof TransformableElement) {\n callback(child);\n } else {\n traverseImmediateTransformableElementChildren(child, callback);\n }\n });\n}\n", "import { AnimatedAttributeHelper } from \"../attribute-animation\";\nimport { AttributeHandler, parseBoolAttribute, parseFloatAttribute } from \"../attributes\";\nimport { OrientedBoundingBox } from \"../bounding-box\";\nimport { GraphicsAdapter } from \"../graphics\";\nimport { AudioGraphics } from \"../graphics/AudioGraphics\";\nimport { AnimationType } from \"./AttributeAnimation\";\nimport { MElement } from \"./MElement\";\nimport { TransformableElement } from \"./TransformableElement\";\n\nconst defaultAudioVolume = 1;\nconst defaultAudioLoop = true;\nconst defaultAudioEnabled = true;\nconst defaultAudioStartTime = 0;\nconst defaultAudioPauseTime = null;\nconst defaultAudioSrc = null;\nconst defaultAudioInnerConeAngle: number = 360;\nconst defaultAudioOuterConeAngle = 0;\nconst defaultAudioDebug = false;\n\nfunction clampAudioConeAngle(angle: number) {\n return Math.max(Math.min(angle, 360), 0);\n}\n\nexport type MAudioProps = {\n src: string | null;\n startTime: number;\n pauseTime: number | null;\n loop: boolean;\n loopDuration: number | null;\n enabled: boolean;\n volume: number;\n coneAngle: number;\n coneFalloffAngle: number | null;\n debug: boolean;\n};\n\nexport class Audio extends TransformableElement {\n static tagName = \"m-audio\";\n\n public props: MAudioProps = {\n src: defaultAudioSrc as string | null,\n startTime: defaultAudioStartTime,\n pauseTime: defaultAudioPauseTime as number | null,\n loop: defaultAudioLoop,\n loopDuration: null,\n enabled: defaultAudioEnabled,\n volume: defaultAudioVolume,\n coneAngle: defaultAudioInnerConeAngle,\n coneFalloffAngle: defaultAudioOuterConeAngle as number | null,\n debug: false,\n };\n\n private audioGraphics: AudioGraphics | null = null;\n\n private audioAnimatedAttributeHelper = new AnimatedAttributeHelper(this, {\n volume: [\n AnimationType.Number,\n defaultAudioVolume,\n (newValue: number) => {\n this.props.volume = newValue;\n this.audioGraphics?.setVolume(newValue, this.props);\n },\n ],\n \"cone-angle\": [\n AnimationType.Number,\n defaultAudioInnerConeAngle,\n (newValue: number | null) => {\n this.props.coneAngle =\n newValue === null ? defaultAudioInnerConeAngle : clampAudioConeAngle(newValue);\n this.audioGraphics?.setConeAngle(this.props.coneAngle, this.props);\n },\n ],\n \"cone-falloff-angle\": [\n AnimationType.Number,\n defaultAudioOuterConeAngle,\n (newValue: number) => {\n this.props.coneFalloffAngle = clampAudioConeAngle(newValue);\n this.audioGraphics?.setConeFalloffAngle(this.props.coneFalloffAngle, this.props);\n },\n ],\n });\n\n private documentTimeListener: { remove: () => void };\n\n static get observedAttributes(): Array {\n return [...TransformableElement.observedAttributes, ...Audio.attributeHandler.getAttributes()];\n }\n\n private static attributeHandler = new AttributeHandler>({\n enabled: (instance, newValue) => {\n instance.props.enabled = parseBoolAttribute(newValue, defaultAudioEnabled);\n instance.audioGraphics?.setEnabled(instance.props.enabled, instance.props);\n },\n loop: (instance, newValue) => {\n instance.props.loop = parseBoolAttribute(newValue, defaultAudioLoop);\n instance.audioGraphics?.setLoop(instance.props.loop, instance.props);\n },\n \"loop-duration\": (instance, newValue) => {\n instance.props.loopDuration = parseFloatAttribute(newValue, null);\n instance.audioGraphics?.setLoopDuration(instance.props.loopDuration, instance.props);\n },\n \"start-time\": (instance, newValue) => {\n instance.props.startTime = parseFloatAttribute(newValue, defaultAudioStartTime);\n instance.audioGraphics?.setStartTime(instance.props.startTime, instance.props);\n },\n \"pause-time\": (instance, newValue) => {\n instance.props.pauseTime = parseFloatAttribute(newValue, defaultAudioPauseTime);\n instance.audioGraphics?.setPauseTime(instance.props.pauseTime, instance.props);\n },\n src: (instance, newValue) => {\n instance.props.src = newValue;\n instance.audioGraphics?.setSrc(newValue, instance.props);\n },\n volume: (instance, newValue) => {\n instance.audioAnimatedAttributeHelper.elementSetAttribute(\n \"volume\",\n parseFloatAttribute(newValue, defaultAudioVolume),\n );\n },\n \"cone-angle\": (instance, newValue) => {\n instance.audioAnimatedAttributeHelper.elementSetAttribute(\n \"cone-angle\",\n parseFloatAttribute(newValue, null),\n );\n },\n \"cone-falloff-angle\": (instance, newValue) => {\n instance.audioAnimatedAttributeHelper.elementSetAttribute(\n \"cone-falloff-angle\",\n parseFloatAttribute(newValue, defaultAudioOuterConeAngle),\n );\n },\n debug: (instance, newValue) => {\n instance.props.debug = parseBoolAttribute(newValue, defaultAudioDebug);\n instance.audioGraphics?.setDebug(instance.props.debug, instance.props);\n },\n });\n\n constructor() {\n super();\n }\n\n protected enable() {\n this.audioGraphics?.syncAudioTime();\n }\n\n protected disable() {\n this.audioGraphics?.syncAudioTime();\n }\n\n public getContentBounds(): OrientedBoundingBox | null {\n if (!this.transformableElementGraphics) {\n return null;\n }\n return OrientedBoundingBox.fromMatrixWorld(this.transformableElementGraphics.getWorldMatrix());\n }\n\n public addSideEffectChild(child: MElement): void {\n this.audioAnimatedAttributeHelper.addSideEffectChild(child);\n super.addSideEffectChild(child);\n }\n\n public removeSideEffectChild(child: MElement): void {\n this.audioAnimatedAttributeHelper.removeSideEffectChild(child);\n super.removeSideEffectChild(child);\n }\n\n public parentTransformed(): void {\n // no-op\n }\n\n public isClickable(): boolean {\n return true;\n }\n\n attributeChangedCallback(name: string, oldValue: string | null, newValue: string) {\n if (!this.audioGraphics) {\n return;\n }\n super.attributeChangedCallback(name, oldValue, newValue);\n Audio.attributeHandler.handle(this, name, newValue);\n }\n\n private documentTimeChanged() {\n this.audioGraphics?.syncAudioTime();\n }\n\n public connectedCallback(): void {\n super.connectedCallback();\n\n if (!this.getScene().hasGraphicsAdapter() || this.audioGraphics) {\n return;\n }\n const graphicsAdapter = this.getScene().getGraphicsAdapter();\n\n this.audioGraphics = graphicsAdapter\n .getGraphicsAdapterFactory()\n .MMLAudioGraphicsInterface(this);\n\n this.documentTimeListener = this.addDocumentTimeListener(() => {\n this.documentTimeChanged();\n });\n\n for (const name of Audio.observedAttributes) {\n const value = this.getAttribute(name);\n if (value !== null) {\n this.attributeChangedCallback(name, null, value);\n }\n }\n }\n\n disconnectedCallback() {\n this.audioAnimatedAttributeHelper.reset();\n this.audioGraphics?.dispose();\n this.audioGraphics = null;\n this.documentTimeListener.remove();\n super.disconnectedCallback();\n }\n}\n", "import { AttributeHandler, parseBoolAttribute, parseFloatAttribute } from \"../attributes\";\nimport { OrientedBoundingBox } from \"../bounding-box\";\nimport { CollideableHelper } from \"../collision\";\nimport { GraphicsAdapter, ModelGraphics } from \"../graphics\";\nimport { TransformableElement } from \"./TransformableElement\";\n\nconst defaultModelSrc = null;\nconst defaultModelAnim = null;\nconst defaultModelAnimLoop = true;\nconst defaultModelAnimEnabled = true;\nconst defaultModelAnimStartTime = 0;\nconst defaultModelAnimPauseTime = null;\nconst defaultModelCastShadows = true;\nconst defaultModelDebug = false;\n\nexport type MModelProps = {\n src: string | null;\n anim: string | null;\n animLoop: boolean;\n animEnabled: boolean;\n animStartTime: number;\n animPauseTime: number | null;\n castShadows: boolean;\n debug: boolean;\n};\n\nexport class Model extends TransformableElement {\n static tagName = \"m-model\";\n\n public props: MModelProps = {\n src: defaultModelSrc,\n anim: defaultModelAnim,\n animStartTime: defaultModelAnimStartTime,\n animPauseTime: defaultModelAnimPauseTime as number | null,\n animLoop: defaultModelAnimLoop,\n animEnabled: defaultModelAnimEnabled,\n castShadows: defaultModelCastShadows,\n debug: defaultModelDebug,\n };\n\n public isModel = true;\n\n private collideableHelper = new CollideableHelper(this);\n\n private static attributeHandler = new AttributeHandler>({\n src: (instance, newValue) => {\n instance.props.src = newValue;\n instance.modelGraphics?.setSrc(newValue, instance.props);\n },\n anim: (instance, newValue) => {\n instance.props.anim = newValue;\n instance.modelGraphics?.setAnim(newValue, instance.props);\n },\n debug: (instance, newValue) => {\n instance.props.debug = parseBoolAttribute(newValue, defaultModelDebug);\n instance.modelGraphics?.setDebug(instance.props.debug, instance.props);\n },\n \"cast-shadows\": (instance, newValue) => {\n instance.props.castShadows = parseBoolAttribute(newValue, defaultModelCastShadows);\n instance.modelGraphics?.setCastShadows(instance.props.castShadows, instance.props);\n },\n \"anim-enabled\": (instance, newValue) => {\n instance.props.animEnabled = parseBoolAttribute(newValue, defaultModelAnimEnabled);\n instance.modelGraphics?.setAnimEnabled(instance.props.animEnabled, instance.props);\n },\n \"anim-loop\": (instance, newValue) => {\n instance.props.animLoop = parseBoolAttribute(newValue, defaultModelAnimLoop);\n instance.modelGraphics?.setAnimLoop(instance.props.animLoop, instance.props);\n },\n \"anim-start-time\": (instance, newValue) => {\n instance.props.animStartTime = parseFloatAttribute(newValue, defaultModelAnimStartTime);\n instance.modelGraphics?.setAnimStartTime(instance.props.animStartTime, instance.props);\n },\n \"anim-pause-time\": (instance, newValue) => {\n instance.props.animPauseTime = parseFloatAttribute(newValue, defaultModelAnimPauseTime);\n instance.modelGraphics?.setAnimPauseTime(instance.props.animPauseTime, instance.props);\n },\n });\n public modelGraphics: ModelGraphics | null = null;\n\n protected enable() {\n this.collideableHelper.enable();\n }\n\n protected disable() {\n this.collideableHelper.disable();\n }\n\n static get observedAttributes(): Array {\n return [\n ...TransformableElement.observedAttributes,\n ...Model.attributeHandler.getAttributes(),\n ...CollideableHelper.observedAttributes,\n ];\n }\n\n constructor() {\n super();\n }\n\n public getContentBounds(): OrientedBoundingBox | null {\n if (!this.transformableElementGraphics) {\n return null;\n }\n const boundingBox = this.modelGraphics?.getBoundingBox();\n if (boundingBox) {\n return OrientedBoundingBox.fromSizeMatrixWorldAndCenter(\n boundingBox.size,\n this.transformableElementGraphics.getWorldMatrix(),\n boundingBox.centerOffset,\n );\n }\n return null;\n }\n\n public parentTransformed(): void {\n this.collideableHelper.parentTransformed();\n this.modelGraphics?.transformed();\n }\n\n public isClickable(): boolean {\n return true;\n }\n\n attributeChangedCallback(name: string, oldValue: string | null, newValue: string) {\n if (!this.modelGraphics) {\n return;\n }\n super.attributeChangedCallback(name, oldValue, newValue);\n Model.attributeHandler.handle(this, name, newValue);\n this.collideableHelper.handle(name, newValue);\n if (TransformableElement.observedAttributes.includes(name)) {\n // The element might have moved/scaled, so we need to call transformed\n this.modelGraphics.transformed();\n }\n }\n\n public connectedCallback(): void {\n super.connectedCallback();\n\n if (!this.getScene().hasGraphicsAdapter() || this.modelGraphics) {\n return;\n }\n const graphicsAdapter = this.getScene().getGraphicsAdapter();\n\n this.modelGraphics = graphicsAdapter\n .getGraphicsAdapterFactory()\n .MMLModelGraphicsInterface(this, () => {\n this.applyBounds();\n this.collideableHelper.updateCollider(this.modelGraphics?.getCollisionElement());\n });\n\n for (const name of Model.observedAttributes) {\n const value = this.getAttribute(name);\n if (value !== null) {\n this.attributeChangedCallback(name, null, value);\n }\n }\n }\n\n disconnectedCallback() {\n // stop listening to document time ticking\n this.collideableHelper.removeColliders();\n this.modelGraphics?.dispose();\n this.modelGraphics = null;\n super.disconnectedCallback();\n }\n}\n", "import { GraphicsAdapter } from \"../graphics\";\nimport { Model } from \"./Model\";\n\nexport class Character extends Model {\n static tagName = \"m-character\";\n\n static get observedAttributes(): Array {\n return [...Model.observedAttributes];\n }\n\n constructor() {\n super();\n }\n\n public parentTransformed(): void {\n // no-op\n }\n\n public isClickable(): boolean {\n return true;\n }\n\n public connectedCallback() {\n super.connectedCallback();\n }\n\n disconnectedCallback() {\n super.disconnectedCallback();\n }\n}\n", "import { MElement, TransformableElement } from \"../elements\";\nimport { GraphicsAdapter } from \"../graphics\";\nimport { degToRad, EulXYZ, Matr4, Quat, radToDeg, Vect3 } from \"../math\";\nimport { PositionAndRotation } from \"../scene\";\n\nconst tempContainerMatrix = new Matr4();\nconst tempTargetMatrix = new Matr4();\nconst tempPositionVector = new Vect3();\nconst tempRotationEuler = new EulXYZ();\nconst tempRotationQuaternion = new Quat();\nconst tempScaleVector = new Vect3();\n\nexport function getRelativePositionAndRotationRelativeToObject(\n positionAndRotation: PositionAndRotation,\n container: MElement,\n): PositionAndRotation {\n const { x, y, z } = positionAndRotation.position;\n\n // Rotation in degrees\n const { x: rx, y: ry, z: rz } = positionAndRotation.rotation;\n\n tempContainerMatrix.identity();\n const tempMatr4 = new Matr4();\n for (let obj: ParentNode | null = container; obj; obj = obj.parentNode) {\n if (obj instanceof TransformableElement) {\n obj.calculateLocalMatrix(tempMatr4);\n tempContainerMatrix.premultiply(tempMatr4);\n }\n }\n\n tempContainerMatrix.invert();\n\n tempPositionVector.set(x, y, z);\n tempRotationEuler.set(degToRad(rx), degToRad(ry), degToRad(rz));\n tempRotationQuaternion.setFromEulerXYZ(tempRotationEuler);\n tempScaleVector.set(1, 1, 1);\n tempTargetMatrix.compose(tempPositionVector, tempRotationQuaternion, tempScaleVector);\n\n tempTargetMatrix.premultiply(tempContainerMatrix);\n tempTargetMatrix.decompose(tempPositionVector, tempRotationQuaternion, tempScaleVector);\n tempRotationEuler.setFromQuaternion(tempRotationQuaternion);\n\n return {\n position: {\n x: tempPositionVector.x,\n y: tempPositionVector.y,\n z: tempPositionVector.z,\n },\n rotation: {\n x: radToDeg(tempRotationEuler.x),\n y: radToDeg(tempRotationEuler.y),\n z: radToDeg(tempRotationEuler.z),\n },\n };\n}\n", "import { AnimatedAttributeHelper } from \"../attribute-animation\";\nimport { AttributeHandler, parseBoolAttribute, parseFloatAttribute } from \"../attributes\";\nimport { OrientedBoundingBox } from \"../bounding-box\";\nimport { GraphicsAdapter } from \"../graphics\";\nimport { ChatProbeGraphics } from \"../graphics/ChatProbeGraphics\";\nimport { Vect3 } from \"../math/Vect3\";\nimport { getRelativePositionAndRotationRelativeToObject } from \"../position\";\nimport { IMMLScene } from \"../scene\";\nimport { AnimationType } from \"./AttributeAnimation\";\nimport { MElement } from \"./MElement\";\nimport { TransformableElement } from \"./TransformableElement\";\n\nconst defaultChatProbeRange = 10;\nconst defaultChatProbeDebug = false;\nconst chatProbeChatEventName = \"chat\";\n\nexport type MChatProbeProps = {\n debug: boolean;\n range: number;\n};\n\nexport class ChatProbe<\n G extends GraphicsAdapter = GraphicsAdapter,\n> extends TransformableElement {\n static tagName = \"m-chat-probe\";\n private chatProbeGraphics: ChatProbeGraphics | null = null;\n private registeredScene: IMMLScene | null = null;\n\n private chatProbeAnimatedAttributeHelper = new AnimatedAttributeHelper(this, {\n range: [\n AnimationType.Number,\n defaultChatProbeRange,\n (newValue: number) => {\n this.props.range = newValue;\n this.chatProbeGraphics?.setRange(newValue, this.props);\n this.applyBounds();\n },\n ],\n });\n\n public props: MChatProbeProps = {\n debug: defaultChatProbeDebug,\n range: defaultChatProbeRange,\n };\n\n private static attributeHandler = new AttributeHandler>({\n range: (instance, newValue) => {\n instance.chatProbeAnimatedAttributeHelper.elementSetAttribute(\n \"range\",\n parseFloatAttribute(newValue, defaultChatProbeRange),\n );\n },\n debug: (instance, newValue) => {\n instance.props.debug = parseBoolAttribute(newValue, defaultChatProbeDebug);\n instance.chatProbeGraphics?.setDebug(instance.props.debug, instance.props);\n },\n });\n\n static get observedAttributes(): Array {\n return [\n ...TransformableElement.observedAttributes,\n ...ChatProbe.attributeHandler.getAttributes(),\n ];\n }\n\n constructor() {\n super();\n }\n\n protected enable() {\n // no-op (the probe only sends events if the position is within range)\n }\n\n protected disable() {\n // no-op (the probe only sends events if the position is within range)\n }\n\n public getContentBounds(): OrientedBoundingBox | null {\n if (!this.transformableElementGraphics) {\n return null;\n }\n return OrientedBoundingBox.fromSizeAndMatrixWorld(\n new Vect3(this.props.range * 2, this.props.range * 2, this.props.range * 2),\n this.transformableElementGraphics.getWorldMatrix(),\n );\n }\n\n public addSideEffectChild(child: MElement): void {\n this.chatProbeAnimatedAttributeHelper.addSideEffectChild(child);\n super.addSideEffectChild(child);\n }\n\n public removeSideEffectChild(child: MElement): void {\n this.chatProbeAnimatedAttributeHelper.removeSideEffectChild(child);\n super.removeSideEffectChild(child);\n }\n\n public parentTransformed(): void {\n this.registeredScene?.updateChatProbe?.(this);\n }\n\n public isClickable(): boolean {\n return false;\n }\n\n attributeChangedCallback(name: string, oldValue: string | null, newValue: string) {\n super.attributeChangedCallback(name, oldValue, newValue);\n ChatProbe.attributeHandler.handle(this, name, newValue);\n }\n\n public trigger(message: string) {\n const userPositionAndRotation = this.getUserPositionAndRotation();\n const elementRelative = getRelativePositionAndRotationRelativeToObject(\n userPositionAndRotation,\n this,\n );\n\n // Check if the position is within range\n const distance = new Vect3().copy(elementRelative.position).length();\n\n let withinBounds = true;\n this.getAppliedBounds().forEach((bounds) => {\n if (!bounds.containsPoint(userPositionAndRotation.position)) {\n withinBounds = false;\n }\n });\n\n if (withinBounds && distance <= this.props.range) {\n this.dispatchEvent(\n new CustomEvent(chatProbeChatEventName, {\n detail: {\n message,\n },\n }),\n );\n }\n }\n\n public connectedCallback(): void {\n super.connectedCallback();\n\n if (!this.getScene().hasGraphicsAdapter() || this.chatProbeGraphics) {\n return;\n }\n const graphicsAdapter = this.getScene().getGraphicsAdapter();\n\n this.chatProbeGraphics = graphicsAdapter\n .getGraphicsAdapterFactory()\n .MMLChatProbeGraphicsInterface(this);\n\n for (const name of ChatProbe.observedAttributes) {\n const value = this.getAttribute(name);\n if (value !== null) {\n this.attributeChangedCallback(name, null, value);\n }\n }\n\n this.applyBounds();\n this.registerChatProbe();\n }\n\n public disconnectedCallback(): void {\n this.unregisterChatProbe();\n this.chatProbeAnimatedAttributeHelper.reset();\n this.chatProbeGraphics?.dispose();\n this.chatProbeGraphics = null;\n super.disconnectedCallback();\n }\n\n private registerChatProbe() {\n const scene = this.getScene();\n this.registeredScene = scene;\n scene.addChatProbe?.(this);\n }\n\n private unregisterChatProbe() {\n if (this.registeredScene !== null) {\n this.registeredScene.removeChatProbe?.(this);\n this.registeredScene = null;\n }\n }\n}\n", "import { AnimatedAttributeHelper } from \"../attribute-animation\";\nimport {\n AttributeHandler,\n parseBoolAttribute,\n parseColorAttribute,\n parseFloatAttribute,\n} from \"../attributes\";\nimport { OrientedBoundingBox } from \"../bounding-box\";\nimport { CollideableHelper } from \"../collision\";\nimport { MMLColor } from \"../color\";\nimport { GraphicsAdapter } from \"../graphics\";\nimport { CubeGraphics } from \"../graphics/CubeGraphics\";\nimport { Vect3 } from \"../math/Vect3\";\nimport { AnimationType } from \"./AttributeAnimation\";\nimport { MElement } from \"./MElement\";\nimport { TransformableElement } from \"./TransformableElement\";\n\nconst defaultCubeColor: MMLColor = { r: 1, g: 1, b: 1 };\nconst defaultCubeWidth = 1;\nconst defaultCubeHeight = 1;\nconst defaultCubeDepth = 1;\nconst defaultCubeOpacity = 1;\nconst defaultCubeCastShadows = true;\n\nexport type MCubeProps = {\n width: number;\n height: number;\n depth: number;\n color: MMLColor;\n opacity: number;\n castShadows: boolean;\n};\n\nexport class Cube extends TransformableElement {\n static tagName = \"m-cube\";\n private cubeGraphics: CubeGraphics | null = null;\n\n public props: MCubeProps = {\n width: defaultCubeWidth,\n height: defaultCubeHeight,\n depth: defaultCubeDepth,\n color: defaultCubeColor,\n opacity: defaultCubeOpacity,\n castShadows: defaultCubeCastShadows,\n };\n\n private cubeAnimatedAttributeHelper = new AnimatedAttributeHelper(this, {\n color: [\n AnimationType.Color,\n defaultCubeColor,\n (newValue: MMLColor) => {\n this.props.color = newValue;\n this.cubeGraphics?.setColor(newValue, this.props);\n },\n ],\n width: [\n AnimationType.Number,\n defaultCubeWidth,\n (newValue: number) => {\n this.props.width = newValue;\n this.cubeGraphics?.setWidth(newValue, this.props);\n this.applyBounds();\n this.collideableHelper.updateCollider(this.cubeGraphics?.getCollisionElement());\n },\n ],\n height: [\n AnimationType.Number,\n defaultCubeHeight,\n (newValue: number) => {\n this.props.height = newValue;\n this.cubeGraphics?.setHeight(newValue, this.props);\n this.applyBounds();\n this.collideableHelper.updateCollider(this.cubeGraphics?.getCollisionElement());\n },\n ],\n depth: [\n AnimationType.Number,\n defaultCubeDepth,\n (newValue: number) => {\n this.props.depth = newValue;\n this.cubeGraphics?.setDepth(newValue, this.props);\n this.applyBounds();\n this.collideableHelper.updateCollider(this.cubeGraphics?.getCollisionElement());\n },\n ],\n opacity: [\n AnimationType.Number,\n defaultCubeOpacity,\n (newValue: number) => {\n this.props.opacity = newValue;\n this.cubeGraphics?.setOpacity(newValue, this.props);\n },\n ],\n });\n private collideableHelper = new CollideableHelper(this);\n\n private static attributeHandler = new AttributeHandler>({\n width: (instance, newValue) => {\n instance.cubeAnimatedAttributeHelper.elementSetAttribute(\n \"width\",\n parseFloatAttribute(newValue, defaultCubeWidth),\n );\n },\n height: (instance, newValue) => {\n instance.cubeAnimatedAttributeHelper.elementSetAttribute(\n \"height\",\n parseFloatAttribute(newValue, defaultCubeHeight),\n );\n },\n depth: (instance, newValue) => {\n instance.cubeAnimatedAttributeHelper.elementSetAttribute(\n \"depth\",\n parseFloatAttribute(newValue, defaultCubeDepth),\n );\n },\n color: (instance, newValue) => {\n instance.cubeAnimatedAttributeHelper.elementSetAttribute(\n \"color\",\n parseColorAttribute(newValue, defaultCubeColor),\n );\n },\n opacity: (instance, newValue) => {\n instance.cubeAnimatedAttributeHelper.elementSetAttribute(\n \"opacity\",\n parseFloatAttribute(newValue, defaultCubeOpacity),\n );\n },\n \"cast-shadows\": (instance, newValue) => {\n instance.props.castShadows = parseBoolAttribute(newValue, defaultCubeCastShadows);\n instance.cubeGraphics?.setCastShadows(instance.props.castShadows, instance.props);\n },\n });\n\n protected enable() {\n this.collideableHelper.enable();\n }\n\n protected disable() {\n this.collideableHelper.disable();\n }\n\n public getContentBounds(): OrientedBoundingBox | null {\n if (!this.transformableElementGraphics) {\n return null;\n }\n return OrientedBoundingBox.fromSizeAndMatrixWorld(\n new Vect3(this.props.width, this.props.height, this.props.depth),\n this.transformableElementGraphics.getWorldMatrix(),\n );\n }\n\n static get observedAttributes(): Array {\n return [\n ...TransformableElement.observedAttributes,\n ...Cube.attributeHandler.getAttributes(),\n ...CollideableHelper.observedAttributes,\n ];\n }\n\n constructor() {\n super();\n }\n\n public addSideEffectChild(child: MElement): void {\n this.cubeAnimatedAttributeHelper.addSideEffectChild(child);\n super.addSideEffectChild(child);\n }\n\n public removeSideEffectChild(child: MElement): void {\n this.cubeAnimatedAttributeHelper.removeSideEffectChild(child);\n super.removeSideEffectChild(child);\n }\n\n public parentTransformed(): void {\n this.collideableHelper.parentTransformed();\n }\n\n public isClickable(): boolean {\n return true;\n }\n\n public attributeChangedCallback(name: string, oldValue: string | null, newValue: string) {\n if (!this.cubeGraphics) {\n return;\n }\n super.attributeChangedCallback(name, oldValue, newValue);\n Cube.attributeHandler.handle(this, name, newValue);\n this.collideableHelper.handle(name, newValue);\n }\n\n public connectedCallback(): void {\n super.connectedCallback();\n\n if (!this.getScene().hasGraphicsAdapter() || this.cubeGraphics) {\n return;\n }\n const graphicsAdapter = this.getScene().getGraphicsAdapter();\n\n this.cubeGraphics = graphicsAdapter.getGraphicsAdapterFactory().MMLCubeGraphicsInterface(this);\n\n for (const name of Cube.observedAttributes) {\n const value = this.getAttribute(name);\n if (value !== null) {\n this.attributeChangedCallback(name, null, value);\n }\n }\n\n this.applyBounds();\n this.collideableHelper.updateCollider(this.cubeGraphics?.getCollisionElement());\n }\n\n public disconnectedCallback(): void {\n this.collideableHelper.removeColliders();\n this.cubeAnimatedAttributeHelper.reset();\n this.cubeGraphics?.dispose();\n this.cubeGraphics = null;\n super.disconnectedCallback();\n }\n}\n", "import { AnimatedAttributeHelper } from \"../attribute-animation\";\nimport {\n AttributeHandler,\n parseBoolAttribute,\n parseColorAttribute,\n parseFloatAttribute,\n} from \"../attributes\";\nimport { OrientedBoundingBox } from \"../bounding-box\";\nimport { CollideableHelper } from \"../collision\";\nimport { MMLColor } from \"../color\";\nimport { GraphicsAdapter } from \"../graphics\";\nimport { CylinderGraphics } from \"../graphics/CylinderGraphics\";\nimport { Vect3 } from \"../math/Vect3\";\nimport { AnimationType } from \"./AttributeAnimation\";\nimport { MElement } from \"./MElement\";\nimport { TransformableElement } from \"./TransformableElement\";\n\nconst defaultCylinderColor: MMLColor = { r: 1, g: 1, b: 1 };\nconst defaultCylinderRadius = 0.5;\nconst defaultCylinderHeight = 1;\nconst defaultCylinderOpacity = 1;\nconst defaultCylinderCastShadows = true;\n\nexport type MCylinderProps = {\n radius: number;\n height: number;\n color: MMLColor;\n opacity: number;\n castShadows: boolean;\n};\n\nexport class Cylinder extends TransformableElement {\n static tagName = \"m-cylinder\";\n private cylinderGraphics: CylinderGraphics | null;\n\n public props: MCylinderProps = {\n radius: defaultCylinderRadius,\n height: defaultCylinderHeight,\n color: defaultCylinderColor,\n opacity: defaultCylinderOpacity,\n castShadows: defaultCylinderCastShadows,\n };\n\n private cylinderAnimatedAttributeHelper = new AnimatedAttributeHelper(this, {\n color: [\n AnimationType.Color,\n defaultCylinderColor,\n (newValue: MMLColor) => {\n this.props.color = newValue;\n this.cylinderGraphics?.setColor(newValue, this.props);\n },\n ],\n radius: [\n AnimationType.Number,\n defaultCylinderRadius,\n (newValue: number) => {\n this.props.radius = newValue;\n this.cylinderGraphics?.setRadius(newValue, this.props);\n this.applyBounds();\n this.collideableHelper.updateCollider(this.cylinderGraphics?.getCollisionElement());\n },\n ],\n height: [\n AnimationType.Number,\n defaultCylinderHeight,\n (newValue: number) => {\n this.props.height = newValue;\n this.cylinderGraphics?.setHeight(newValue, this.props);\n this.applyBounds();\n this.collideableHelper.updateCollider(this.cylinderGraphics?.getCollisionElement());\n },\n ],\n opacity: [\n AnimationType.Number,\n defaultCylinderOpacity,\n (newValue: number) => {\n this.props.opacity = newValue;\n this.cylinderGraphics?.setOpacity(newValue, this.props);\n },\n ],\n });\n private collideableHelper = new CollideableHelper(this);\n\n private static attributeHandler = new AttributeHandler>({\n radius: (instance, newValue) => {\n instance.cylinderAnimatedAttributeHelper.elementSetAttribute(\n \"radius\",\n parseFloatAttribute(newValue, defaultCylinderRadius),\n );\n },\n height: (instance, newValue) => {\n instance.cylinderAnimatedAttributeHelper.elementSetAttribute(\n \"height\",\n parseFloatAttribute(newValue, defaultCylinderHeight),\n );\n },\n color: (instance, newValue) => {\n instance.cylinderAnimatedAttributeHelper.elementSetAttribute(\n \"color\",\n parseColorAttribute(newValue, defaultCylinderColor),\n );\n },\n opacity: (instance, newValue) => {\n instance.cylinderAnimatedAttributeHelper.elementSetAttribute(\n \"opacity\",\n parseFloatAttribute(newValue, defaultCylinderOpacity),\n );\n },\n \"cast-shadows\": (instance, newValue) => {\n instance.props.castShadows = parseBoolAttribute(newValue, defaultCylinderCastShadows);\n instance.cylinderGraphics?.setCastShadows(instance.props.castShadows, instance.props);\n },\n });\n\n protected enable() {\n this.collideableHelper.enable();\n }\n\n protected disable() {\n this.collideableHelper.disable();\n }\n\n public getContentBounds(): OrientedBoundingBox | null {\n if (!this.transformableElementGraphics) {\n return null;\n }\n return OrientedBoundingBox.fromSizeAndMatrixWorld(\n new Vect3(this.props.radius * 2, this.props.height, this.props.radius * 2),\n this.transformableElementGraphics.getWorldMatrix(),\n );\n }\n\n static get observedAttributes(): Array {\n return [\n ...TransformableElement.observedAttributes,\n ...Cylinder.attributeHandler.getAttributes(),\n ...CollideableHelper.observedAttributes,\n ];\n }\n\n constructor() {\n super();\n }\n\n public addSideEffectChild(child: MElement): void {\n this.cylinderAnimatedAttributeHelper.addSideEffectChild(child);\n super.addSideEffectChild(child);\n }\n\n public removeSideEffectChild(child: MElement): void {\n this.cylinderAnimatedAttributeHelper.removeSideEffectChild(child);\n super.removeSideEffectChild(child);\n }\n\n public parentTransformed(): void {\n this.collideableHelper.parentTransformed();\n }\n\n public isClickable(): boolean {\n return true;\n }\n\n public attributeChangedCallback(name: string, oldValue: string | null, newValue: string) {\n if (!this.cylinderGraphics) {\n return;\n }\n super.attributeChangedCallback(name, oldValue, newValue);\n Cylinder.attributeHandler.handle(this, name, newValue);\n this.collideableHelper.handle(name, newValue);\n }\n\n public connectedCallback(): void {\n super.connectedCallback();\n\n if (!this.getScene().hasGraphicsAdapter() || this.cylinderGraphics) {\n return;\n }\n const graphicsAdapter = this.getScene().getGraphicsAdapter();\n\n this.cylinderGraphics = graphicsAdapter\n .getGraphicsAdapterFactory()\n .MMLCylinderGraphicsInterface(this);\n\n for (const name of Cylinder.observedAttributes) {\n const value = this.getAttribute(name);\n if (value !== null) {\n this.attributeChangedCallback(name, null, value);\n }\n }\n\n this.applyBounds();\n this.collideableHelper.updateCollider(this.cylinderGraphics?.getCollisionElement());\n }\n\n public disconnectedCallback(): void {\n this.collideableHelper.removeColliders();\n this.cylinderAnimatedAttributeHelper.reset();\n this.cylinderGraphics?.dispose();\n this.cylinderGraphics = null;\n super.disconnectedCallback();\n }\n}\n", "import { ChatProbe, Interaction, MElement } from \"../elements\";\nimport { GraphicsAdapter } from \"../graphics\";\nimport { LoadingProgressManager } from \"../loading\";\nimport { IMMLScene, LinkProps, PromptProps } from \"../scene\";\n\nexport function createWrappedScene(\n scene: IMMLScene,\n loadingProgressManager: LoadingProgressManager | null,\n): IMMLScene {\n return {\n addCollider(collider: unknown, element: MElement): void {\n if (scene.addCollider) {\n scene.addCollider(collider, element);\n }\n },\n updateCollider(collider: unknown, element: MElement): void {\n if (scene.updateCollider) {\n scene.updateCollider(collider, element);\n }\n },\n removeCollider(collider: unknown, element: MElement): void {\n if (scene.removeCollider) {\n scene.removeCollider(collider, element);\n }\n },\n addInteraction(interaction: Interaction): void {\n if (scene.addInteraction) {\n scene.addInteraction(interaction);\n }\n },\n updateInteraction(interaction: Interaction): void {\n if (scene.updateInteraction) {\n scene.updateInteraction(interaction);\n }\n },\n removeInteraction(interaction: Interaction): void {\n if (scene.removeInteraction) {\n scene.removeInteraction(interaction);\n }\n },\n addChatProbe(chatProbe: ChatProbe): void {\n if (scene.addChatProbe) {\n scene.addChatProbe(chatProbe);\n }\n },\n updateChatProbe(chatProbe: ChatProbe): void {\n if (scene.updateChatProbe) {\n scene.updateChatProbe(chatProbe);\n }\n },\n removeChatProbe(chatProbe: ChatProbe): void {\n if (scene.removeChatProbe) {\n scene.removeChatProbe(chatProbe);\n }\n },\n hasGraphicsAdapter() {\n return scene.hasGraphicsAdapter();\n },\n getGraphicsAdapter() {\n return scene.getGraphicsAdapter();\n },\n prompt(\n promptProps: PromptProps,\n abortSignal: AbortSignal,\n callback: (result: string | null) => void,\n ) {\n scene.prompt(promptProps, abortSignal, callback);\n },\n link(\n linkProps: LinkProps,\n abortSignal: AbortSignal,\n windowCallback: (openedWindow: Window | null) => void,\n ) {\n scene.link(linkProps, abortSignal, windowCallback);\n },\n getRootContainer: () => {\n throw new Error(\"Wrapped scenes do not have a root container\");\n },\n getUserPositionAndRotation: () => {\n return scene.getUserPositionAndRotation();\n },\n getLoadingProgressManager: () => {\n return loadingProgressManager;\n },\n };\n}\n", "import { LoadingProgressManager } from \"./LoadingProgressManager\";\n\nconst noManagerSymbol = Symbol(\"NoLoadingProgressManagerProvided\");\n\nexport class LoadingInstanceManager {\n // Only set if the instance is loading / has loaded / has errored\n private currentlyLoadingProgressManager: LoadingProgressManager | typeof noManagerSymbol | null =\n null;\n\n constructor(private type: string) {}\n\n public start(loadingProgressManager: LoadingProgressManager | null, url: string) {\n if (this.currentlyLoadingProgressManager !== null) {\n if (this.currentlyLoadingProgressManager === noManagerSymbol && !loadingProgressManager) {\n // Already loading with no progress manager, and no progress manager provided - do nothing\n return;\n }\n if (this.currentlyLoadingProgressManager !== loadingProgressManager) {\n throw new Error(\"Already loading with a different progress manager\");\n }\n // else the instance is already reported as loading with this progress manager (could be a change in content)\n } else {\n // This instance is now loading - report to the progress manager\n if (!loadingProgressManager) {\n this.currentlyLoadingProgressManager = noManagerSymbol;\n } else {\n this.currentlyLoadingProgressManager = loadingProgressManager;\n this.currentlyLoadingProgressManager.addLoadingAsset(this, url, this.type);\n }\n }\n }\n\n public setProgress(ratio: number) {\n if (!this.currentlyLoadingProgressManager) {\n throw new Error(\"Not currently loading - cannot finish\");\n }\n if (this.currentlyLoadingProgressManager !== noManagerSymbol) {\n this.currentlyLoadingProgressManager.updateAssetProgress(this, ratio);\n }\n }\n\n // The content being loaded is no longer needed, but the instance may still request content load start again\n public abortIfLoading() {\n if (\n this.currentlyLoadingProgressManager &&\n this.currentlyLoadingProgressManager !== noManagerSymbol\n ) {\n this.currentlyLoadingProgressManager.disposeOfLoadingAsset(this);\n }\n this.currentlyLoadingProgressManager = null;\n }\n\n // The instance is no longer needed, and will not request content load start again (content may not be loading)\n public dispose() {\n this.abortIfLoading();\n }\n\n public finish() {\n if (!this.currentlyLoadingProgressManager) {\n throw new Error(\"Not currently loading - cannot finish\");\n }\n if (this.currentlyLoadingProgressManager !== noManagerSymbol) {\n this.currentlyLoadingProgressManager.completedLoadingAsset(this);\n }\n }\n\n public error(err?: Error | null) {\n if (!this.currentlyLoadingProgressManager) {\n throw new Error(\"Not currently loading - cannot error\");\n }\n if (this.currentlyLoadingProgressManager !== noManagerSymbol) {\n if (err) {\n this.currentlyLoadingProgressManager.errorLoadingAsset(this, err);\n } else {\n this.currentlyLoadingProgressManager.errorLoadingAsset(this, new Error(\"Unknown error\"));\n }\n }\n }\n}\n", "type AssetStatus = {\n type: string;\n assetUrl: string;\n progressRatio: number;\n loadStatus: boolean | Error;\n};\n\ntype LoadingCountSummary = {\n totalLoaded: number;\n totalErrored: number;\n totalToLoad: number;\n};\n\ntype LoadingProgressSummary = {\n initialLoad: boolean | Error;\n summary: LoadingCountSummary;\n summaryByType: { [key: string]: LoadingCountSummary & { assetErrors: Array<[string, Error]> } };\n innerDocuments: Array<[string, LoadingProgressSummary]>;\n};\n\nexport class LoadingProgressManager {\n public summary: LoadingCountSummary = {\n totalLoaded: 0,\n totalErrored: 0,\n totalToLoad: 0,\n };\n\n public initialLoad: boolean | Error = false;\n\n public loadingAssets = new Map();\n public summaryByType = new Map<\n string,\n LoadingCountSummary & {\n assets: Map;\n }\n >();\n public loadingDocuments = new Map<\n unknown,\n { documentUrl: string; progressManager: LoadingProgressManager }\n >();\n\n private onProgressCallbacks = new Set<() => void>();\n\n constructor() {}\n\n public addProgressCallback(callback: () => void): void {\n this.onProgressCallbacks.add(callback);\n }\n\n public removeProgressCallback(callback: () => void): void {\n this.onProgressCallbacks.delete(callback);\n }\n\n private onProgress(): void {\n for (const callback of this.onProgressCallbacks) {\n callback();\n }\n }\n\n public addLoadingAsset(ref: unknown, url: string, type: string): void {\n if (this.loadingAssets.has(ref)) {\n throw new Error(\"Asset reference already exists\");\n }\n const assetRecord: AssetStatus = { type, assetUrl: url, progressRatio: 0, loadStatus: false };\n this.loadingAssets.set(ref, assetRecord);\n\n let typeSummary = this.summaryByType.get(type);\n if (!typeSummary) {\n typeSummary = { totalLoaded: 0, totalToLoad: 0, totalErrored: 0, assets: new Map() };\n this.summaryByType.set(type, typeSummary);\n }\n typeSummary.assets.set(ref, assetRecord);\n typeSummary.totalToLoad++;\n this.summary.totalToLoad++;\n this.onProgress();\n }\n\n public setInitialLoad(result: true | Error): void {\n if (result instanceof Error) {\n this.initialLoad = result;\n } else {\n this.initialLoad = true;\n }\n this.onProgress();\n }\n\n public disposeOfLoadingAsset(ref: unknown): void {\n const asset = this.loadingAssets.get(ref);\n if (asset) {\n this.loadingAssets.delete(ref);\n const { type, loadStatus } = asset;\n const typeSummary = this.summaryByType.get(type);\n if (typeSummary) {\n typeSummary.assets.delete(ref);\n typeSummary.totalToLoad--;\n this.summary.totalToLoad--;\n if (loadStatus === true) {\n typeSummary.totalLoaded--;\n this.summary.totalLoaded--;\n } else if (loadStatus instanceof Error) {\n typeSummary.totalErrored--;\n this.summary.totalErrored--;\n }\n this.onProgress();\n }\n }\n }\n\n public errorLoadingAsset(ref: unknown, err: Error) {\n const asset = this.loadingAssets.get(ref);\n if (asset) {\n const { type } = asset;\n asset.loadStatus = err;\n const typeSummary = this.summaryByType.get(type);\n if (typeSummary) {\n typeSummary.totalErrored++;\n this.summary.totalErrored++;\n this.onProgress();\n }\n }\n }\n\n public updateAssetProgress(ref: unknown, progressRatio: number): void {\n const asset = this.loadingAssets.get(ref);\n if (asset) {\n asset.progressRatio = progressRatio;\n this.onProgress();\n }\n }\n\n public completedLoadingAsset(ref: unknown): void {\n const asset = this.loadingAssets.get(ref);\n if (asset) {\n const { type } = asset;\n asset.loadStatus = true;\n const typeSummary = this.summaryByType.get(type);\n if (typeSummary) {\n typeSummary.totalLoaded++;\n this.summary.totalLoaded++;\n this.onProgress();\n }\n }\n }\n\n public addLoadingDocument(\n ref: unknown,\n documentUrl: string,\n progressManager: LoadingProgressManager,\n ): void {\n this.loadingDocuments.set(ref, { documentUrl, progressManager });\n this.onProgress();\n }\n\n public removeLoadingDocument(ref: unknown): void {\n this.loadingDocuments.delete(ref);\n this.onProgress();\n }\n\n public updateDocumentProgress(ref: unknown): void {\n const loadingDocument = this.loadingDocuments.get(ref);\n if (loadingDocument) {\n this.onProgress();\n }\n }\n\n public toSummary(): LoadingProgressSummary {\n const loadingProgressSummary: LoadingProgressSummary = {\n initialLoad: this.initialLoad,\n summary: { ...this.summary },\n summaryByType: {},\n innerDocuments: [],\n };\n\n for (const [key, ofType] of this.summaryByType) {\n const ofTypeSummary: LoadingCountSummary & { assetErrors: Array<[string, Error]> } = {\n totalToLoad: ofType.totalToLoad,\n totalLoaded: ofType.totalLoaded,\n totalErrored: ofType.totalErrored,\n assetErrors: [],\n };\n if (ofType.totalErrored > 0) {\n for (const [, asset] of ofType.assets) {\n if (asset.loadStatus instanceof Error) {\n ofTypeSummary.assetErrors.push([asset.assetUrl, asset.loadStatus]);\n }\n }\n }\n loadingProgressSummary.summaryByType[key] = ofTypeSummary;\n }\n for (const [, innerDocProgress] of this.loadingDocuments) {\n loadingProgressSummary.innerDocuments.push([\n innerDocProgress.documentUrl,\n innerDocProgress.progressManager.toSummary(),\n ]);\n }\n return loadingProgressSummary;\n }\n\n public static LoadingProgressSummaryToString(\n loadingProgressSummary: LoadingProgressSummary,\n ): string {\n const text: Array = [];\n const showDocProgress = (docUrl: string, docProgress: LoadingProgressSummary) => {\n if (docProgress.initialLoad instanceof Error) {\n text.push(`${docUrl}: Error: ${docProgress.initialLoad.message}`);\n return;\n } else if (!docProgress.initialLoad) {\n text.push(`${docUrl}: Loading...`);\n return;\n }\n text.push(\n `${docUrl}: (${docProgress.summary.totalLoaded} loaded, ${\n docProgress.summary.totalErrored\n } errors) / (${docProgress.summary.totalToLoad} to load) = ${\n docProgress.summary.totalLoaded + docProgress.summary.totalErrored\n }/${docProgress.summary.totalToLoad}`,\n );\n for (const key in docProgress.summaryByType) {\n const ofType = docProgress.summaryByType[key];\n text.push(\n ` - ${key}: (${ofType.totalLoaded} loaded, ${ofType.totalErrored} errors) / (${\n ofType.totalToLoad\n } to load) = ${ofType.totalLoaded + ofType.totalErrored}/${ofType.totalToLoad}`,\n );\n if (ofType.totalErrored > 0) {\n text.push(` - Errors:`);\n for (const [assetUrl, error] of ofType.assetErrors) {\n text.push(` - ${assetUrl}: ${error.message}`);\n }\n }\n }\n for (const [innerDocumentUrl, innerDocProgress] of docProgress.innerDocuments) {\n showDocProgress(innerDocumentUrl, innerDocProgress);\n }\n };\n showDocProgress(\"root\", loadingProgressSummary);\n return text.join(\"\\n\");\n }\n\n public toRatio(): [number, boolean] {\n if (!this.initialLoad) {\n return [0, false];\n }\n if (this.initialLoad instanceof Error) {\n return [1, true];\n }\n\n let totalRatio = 0;\n let complete = true;\n\n let numberOfDocuments = this.loadingDocuments.size;\n\n if (this.summary.totalToLoad > 0) {\n numberOfDocuments += 1;\n const loadedAndErrored = this.summary.totalLoaded + this.summary.totalErrored;\n complete = complete && loadedAndErrored === this.summary.totalToLoad;\n let directAssetsLoadedRatio = 0;\n for (const [, asset] of this.loadingAssets) {\n if (asset.loadStatus instanceof Error || asset.loadStatus) {\n directAssetsLoadedRatio += 1;\n } else {\n directAssetsLoadedRatio += asset.progressRatio;\n }\n }\n directAssetsLoadedRatio /= this.summary.totalToLoad;\n totalRatio += directAssetsLoadedRatio / numberOfDocuments;\n } else if (this.loadingDocuments.size === 0) {\n // There are no assets to load and no inner documents, so loading is complete\n return [1, true];\n }\n\n for (const [, innerDocument] of this.loadingDocuments) {\n const [innerDocumentRatio, innerDocumentComplete] = innerDocument.progressManager.toRatio();\n totalRatio += innerDocumentRatio / numberOfDocuments;\n complete = complete && innerDocumentComplete;\n }\n\n return [totalRatio, complete];\n }\n}\n", "import { LoadingProgressManager } from \"./LoadingProgressManager\";\n\nexport class LoadingProgressBar {\n public readonly element: HTMLDivElement;\n\n private progressBarHolder: HTMLDivElement;\n private progressBar: HTMLDivElement;\n private loadingStatusText: HTMLDivElement;\n\n private progressDebugView: HTMLDivElement;\n private progressDebugElement: HTMLPreElement;\n\n private debugLabel: HTMLLabelElement;\n private debugCheckbox: HTMLInputElement;\n\n private hasCompleted = false;\n private loadingCallback: () => void;\n\n constructor(private loadingProgressManager: LoadingProgressManager) {\n this.element = document.createElement(\"div\");\n this.element.addEventListener(\"click\", (event) => {\n event.stopPropagation();\n });\n this.element.addEventListener(\"mousedown\", (event) => {\n event.stopPropagation();\n });\n this.element.addEventListener(\"mousemove\", (event) => {\n event.stopPropagation();\n });\n this.element.addEventListener(\"mouseup\", (event) => {\n event.stopPropagation();\n });\n\n this.progressDebugView = document.createElement(\"div\");\n this.progressDebugView.style.position = \"absolute\";\n this.progressDebugView.style.backgroundColor = \"rgba(128, 128, 128, 0.25)\";\n this.progressDebugView.style.top = \"20px\";\n this.progressDebugView.style.left = \"0\";\n this.progressDebugView.style.border = \"1px solid black\";\n this.progressDebugView.style.maxHeight = \"calc(100% - 20px)\";\n this.progressDebugView.style.maxWidth = \"100%\";\n this.progressDebugView.style.overflow = \"auto\";\n this.element.append(this.progressDebugView);\n\n this.debugCheckbox = document.createElement(\"input\");\n this.debugCheckbox.type = \"checkbox\";\n this.debugCheckbox.addEventListener(\"change\", () => {\n this.progressDebugElement.style.display = this.debugCheckbox.checked ? \"block\" : \"none\";\n if (this.hasCompleted) {\n this.dispose();\n }\n });\n\n this.debugLabel = document.createElement(\"label\");\n this.debugLabel.textContent = \"Debug loading\";\n this.debugLabel.style.fontFamily = \"sans-serif\";\n this.debugLabel.style.padding = \"5px\";\n this.debugLabel.style.display = \"inline-block\";\n this.debugLabel.style.userSelect = \"none\";\n this.debugLabel.append(this.debugCheckbox);\n this.progressDebugView.append(this.debugLabel);\n\n this.progressDebugElement = document.createElement(\"pre\");\n this.progressDebugElement.style.margin = \"0\";\n this.progressDebugElement.style.display = this.debugCheckbox.checked ? \"block\" : \"none\";\n this.progressDebugView.append(this.progressDebugElement);\n\n this.progressBarHolder = document.createElement(\"div\");\n this.progressBarHolder.style.position = \"absolute\";\n this.progressBarHolder.style.top = \"0\";\n this.progressBarHolder.style.left = \"0\";\n this.progressBarHolder.style.width = \"100%\";\n this.progressBarHolder.style.backgroundColor = \"gray\";\n this.progressBarHolder.style.height = \"20px\";\n this.element.append(this.progressBarHolder);\n\n this.progressBar = document.createElement(\"div\");\n this.progressBar.style.position = \"absolute\";\n this.progressBar.style.top = \"0\";\n this.progressBar.style.left = \"0\";\n this.progressBar.style.width = \"0\";\n this.progressBar.style.height = \"100%\";\n this.progressBar.style.backgroundColor = \"#0050a4\";\n this.progressBarHolder.append(this.progressBar);\n\n this.loadingStatusText = document.createElement(\"div\");\n this.loadingStatusText.style.position = \"absolute\";\n this.loadingStatusText.style.top = \"0\";\n this.loadingStatusText.style.left = \"0\";\n this.loadingStatusText.style.width = \"100%\";\n this.loadingStatusText.style.height = \"100%\";\n this.loadingStatusText.style.color = \"white\";\n this.loadingStatusText.style.textAlign = \"center\";\n this.loadingStatusText.style.verticalAlign = \"middle\";\n this.loadingStatusText.style.lineHeight = \"20px\";\n this.loadingStatusText.style.fontFamily = \"sans-serif\";\n this.loadingStatusText.textContent = \"Loading...\";\n this.progressBarHolder.append(this.loadingStatusText);\n\n this.loadingCallback = () => {\n const [loadingRatio, completedLoading] = this.loadingProgressManager.toRatio();\n if (completedLoading) {\n if (!this.hasCompleted) {\n this.hasCompleted = true;\n if (!this.debugCheckbox.checked) {\n this.dispose();\n }\n }\n this.loadingStatusText.textContent = \"Completed\";\n this.progressBar.style.width = \"100%\";\n } else {\n this.loadingStatusText.textContent = `Loading... ${(loadingRatio * 100).toFixed(2)}%`;\n this.progressBar.style.width = `${loadingRatio * 100}%`;\n }\n this.progressDebugElement.textContent = LoadingProgressManager.LoadingProgressSummaryToString(\n this.loadingProgressManager.toSummary(),\n );\n };\n\n this.loadingProgressManager.addProgressCallback(this.loadingCallback);\n }\n\n public dispose() {\n this.loadingProgressManager.removeProgressCallback(this.loadingCallback);\n this.element.remove();\n }\n}\n", "import { DOMSanitizer } from \"@mml-io/networked-dom-web\";\n\nlet domParser: DOMParser;\n\nexport async function fetchRemoteStaticMML(address: string): Promise {\n const response = await fetch(address);\n const text = await response.text();\n if (!domParser) {\n domParser = new DOMParser();\n }\n const remoteDocumentAsHTMLNode = domParser.parseFromString(text, \"text/html\");\n return DOMSanitizer.sanitise(remoteDocumentAsHTMLNode.body, {\n tagPrefix: \"m-\",\n replacementTagPrefix: \"x-\",\n });\n}\n", "import { consumeEventEventName } from \"../elements\";\nimport { RemoteDocument } from \"../elements\";\nimport { GraphicsAdapter } from \"../graphics\";\nimport { IMMLScene } from \"../scene\";\n\n/**\n * The RemoteDocumentWrapper class creates an m-remote-document (RemoteDocument) element and initialises it with the\n * given address. It is expected that the `remoteDocument` element will be added to the DOM by the caller.\n */\nexport class RemoteDocumentWrapper {\n public readonly remoteDocument: RemoteDocument;\n\n constructor(\n address: string,\n targetWindow: Window,\n mmlScene: IMMLScene,\n handleEvent: (element: HTMLElement, event: CustomEvent) => void,\n ) {\n this.remoteDocument = targetWindow.document.createElement(\n RemoteDocument.tagName,\n ) as RemoteDocument;\n this.remoteDocument.addEventListener(consumeEventEventName, (wrappedEvent: CustomEvent) => {\n const { originalEvent, element } = wrappedEvent.detail;\n handleEvent(element, originalEvent);\n });\n this.remoteDocument.init(mmlScene, address);\n }\n\n public setDocumentTime(documentTime: number) {\n this.remoteDocument.getDocumentTimeManager().setDocumentTime(documentTime);\n }\n\n public overrideDocumentTime(documentTime: number) {\n this.remoteDocument.getDocumentTimeManager().overrideDocumentTime(documentTime);\n }\n}\n", "import { MElement } from \"../elements\";\nimport { GraphicsAdapter } from \"../graphics\";\nimport { LoadingProgressManager } from \"../loading\";\nimport { fetchRemoteStaticMML, RemoteDocumentWrapper } from \"../remote-document\";\nimport { IMMLScene } from \"../scene\";\nimport { createWrappedScene } from \"./CreateWrappedScene\";\n\nexport class StaticHTMLFrameInstance {\n public readonly src: string;\n private readonly remoteDocumentWrapper: RemoteDocumentWrapper;\n private readonly targetForWrapper: MElement;\n private readonly scene: IMMLScene;\n private loadingProgressManager: LoadingProgressManager;\n\n constructor(targetElement: MElement, src: string, scene: IMMLScene) {\n this.targetForWrapper = targetElement;\n this.src = src;\n this.scene = scene;\n\n // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n const windowTarget = targetElement.ownerDocument.defaultView!;\n\n this.loadingProgressManager = new LoadingProgressManager();\n this.loadingProgressManager.addProgressCallback(() => {\n scene.getLoadingProgressManager?.()?.updateDocumentProgress(this);\n });\n\n const address = this.targetForWrapper.contentSrcToContentAddress(this.src);\n\n scene\n .getLoadingProgressManager?.()\n ?.addLoadingDocument(this, address, this.loadingProgressManager);\n\n const wrappedScene: IMMLScene = createWrappedScene(this.scene, this.loadingProgressManager);\n\n this.remoteDocumentWrapper = new RemoteDocumentWrapper(\n address,\n windowTarget,\n wrappedScene,\n () => {\n // Events targeting static MML frames should not be sent\n },\n );\n this.targetForWrapper.append(this.remoteDocumentWrapper.remoteDocument);\n // Promise is intentionally ignored here\n fetchRemoteStaticMML(address)\n .then((remoteDocumentBody) => {\n this.remoteDocumentWrapper.remoteDocument.append(remoteDocumentBody);\n this.loadingProgressManager.setInitialLoad(true);\n })\n .catch((err) => {\n this.loadingProgressManager.setInitialLoad(err);\n });\n }\n\n public dispose() {\n this.targetForWrapper.removeChild(this.remoteDocumentWrapper.remoteDocument);\n this.loadingProgressManager.removeLoadingDocument(this);\n }\n}\n", "import { NetworkedDOMWebsocket, NetworkedDOMWebsocketStatus } from \"@mml-io/networked-dom-web\";\n\nimport { consumeEventEventName, MElement } from \"../elements\";\nimport { GraphicsAdapter } from \"../graphics\";\nimport { LoadingProgressManager } from \"../loading\";\nimport { RemoteDocumentWrapper } from \"../remote-document\";\nimport { IMMLScene } from \"../scene\";\nimport { createWrappedScene } from \"./CreateWrappedScene\";\n\nexport class WebSocketFrameInstance {\n public readonly src: string;\n private domWebsocket: NetworkedDOMWebsocket;\n private targetForWrapper: MElement;\n private readonly remoteDocumentWrapper: RemoteDocumentWrapper;\n private scene: IMMLScene;\n private loadingProgressManager: LoadingProgressManager;\n\n constructor(targetElement: MElement, src: string, scene: IMMLScene) {\n this.targetForWrapper = targetElement;\n this.src = src;\n this.scene = scene;\n\n // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n const windowTarget = targetElement.ownerDocument.defaultView!;\n\n let overriddenHandler: ((element: MElement, event: CustomEvent) => void) | null = null;\n const eventHandler = (element: MElement, event: CustomEvent) => {\n if (!overriddenHandler) {\n throw new Error(\"overriddenHandler not set\");\n }\n overriddenHandler(element, event);\n };\n\n this.loadingProgressManager = new LoadingProgressManager();\n this.loadingProgressManager.addProgressCallback(() => {\n scene.getLoadingProgressManager?.()?.updateDocumentProgress(this);\n });\n\n const websocketAddress = this.srcToAddress(this.src);\n\n scene\n .getLoadingProgressManager?.()\n ?.addLoadingDocument(this, websocketAddress, this.loadingProgressManager);\n\n const wrappedScene: IMMLScene = createWrappedScene(this.scene, this.loadingProgressManager);\n\n this.remoteDocumentWrapper = new RemoteDocumentWrapper(\n websocketAddress,\n windowTarget,\n wrappedScene,\n () => {\n // Events targeting static MML frames should not be sent\n },\n );\n\n this.targetForWrapper.append(this.remoteDocumentWrapper.remoteDocument);\n\n this.remoteDocumentWrapper.remoteDocument.addEventListener(\n consumeEventEventName,\n (wrappedEvent: CustomEvent) => {\n const { originalEvent, element } = wrappedEvent.detail;\n eventHandler(element, originalEvent);\n },\n );\n\n this.domWebsocket = new NetworkedDOMWebsocket(\n websocketAddress,\n NetworkedDOMWebsocket.createWebSocket,\n this.remoteDocumentWrapper.remoteDocument,\n (time: number) => {\n this.remoteDocumentWrapper.remoteDocument.getDocumentTimeManager().setDocumentTime(time);\n },\n (status: NetworkedDOMWebsocketStatus) => {\n if (status === NetworkedDOMWebsocketStatus.Reconnecting) {\n this.remoteDocumentWrapper.remoteDocument.showError(true);\n this.loadingProgressManager.setInitialLoad(new Error(\"Failed to connect\"));\n } else if (status === NetworkedDOMWebsocketStatus.Connected) {\n this.remoteDocumentWrapper.remoteDocument.showError(false);\n this.loadingProgressManager.setInitialLoad(true);\n } else {\n this.remoteDocumentWrapper.remoteDocument.showError(false);\n }\n },\n {\n tagPrefix: \"m-\",\n },\n );\n overriddenHandler = (element: MElement, event: CustomEvent) => {\n this.domWebsocket.handleEvent(element, event);\n };\n }\n\n private srcToAddress(src: string): string {\n const insecurePrefix = \"ws:///\";\n const securePrefix = \"wss:///\";\n if (src.startsWith(insecurePrefix)) {\n // Relative insecure websocket path\n return `ws://${this.getDocumentHost()}/${src.substring(insecurePrefix.length)}`;\n } else if (src.startsWith(securePrefix)) {\n // Relative secure websocket path\n return `wss://${this.getDocumentHost()}/${src.substring(securePrefix.length)}`;\n } else {\n return src;\n }\n }\n\n private getDocumentHost(): string {\n const remoteDocument = this.targetForWrapper.getInitiatedRemoteDocument();\n if (remoteDocument) {\n const remoteDocumentAddress = remoteDocument.getDocumentAddress();\n if (remoteDocumentAddress) {\n const url = new URL(remoteDocumentAddress);\n return url.host;\n }\n }\n return window.location.host;\n }\n\n dispose() {\n this.domWebsocket.stop();\n this.targetForWrapper.removeChild(this.remoteDocumentWrapper.remoteDocument);\n this.scene.getLoadingProgressManager?.()?.removeLoadingDocument(this);\n }\n}\n", "import { AttributeHandler, parseBoolAttribute, parseFloatAttribute } from \"../attributes\";\nimport { OrientedBoundingBox } from \"../bounding-box\";\nimport { StaticHTMLFrameInstance, WebSocketFrameInstance } from \"../frame\";\nimport { GraphicsAdapter } from \"../graphics\";\nimport { FrameGraphics } from \"../graphics/FrameGraphics\";\nimport { Vect3 } from \"../math/Vect3\";\nimport { getRelativePositionAndRotationRelativeToObject } from \"../position\";\nimport { TransformableElement } from \"./TransformableElement\";\n\nconst defaultUnloadRange = 1;\nconst defaultFrameDebug = false;\n\nexport type MFrameProps = {\n src: string | null;\n loadRange: number | null;\n unloadRange: number;\n\n debug: boolean;\n\n minX: number | null;\n maxX: number | null;\n minY: number | null;\n maxY: number | null;\n minZ: number | null;\n maxZ: number | null;\n};\n\nexport class Frame extends TransformableElement {\n static tagName = \"m-frame\";\n private frameGraphics: FrameGraphics | null;\n\n private static attributeHandler = new AttributeHandler>({\n src: (instance, newValue) => {\n instance.props.src = newValue;\n if (instance.frameContentsInstance) {\n instance.disposeInstance();\n }\n instance.syncLoadState();\n instance.frameGraphics?.setSrc(instance.props.src, instance.props);\n },\n \"load-range\": (instance, newValue) => {\n instance.props.loadRange = parseFloatAttribute(newValue, null);\n instance.syncLoadState();\n instance.frameGraphics?.setLoadRange(instance.props.loadRange, instance.props);\n },\n \"unload-range\": (instance, newValue) => {\n instance.props.unloadRange = parseFloatAttribute(newValue, defaultUnloadRange);\n instance.syncLoadState();\n instance.frameGraphics?.setUnloadRange(instance.props.unloadRange, instance.props);\n },\n debug: (instance, newValue) => {\n instance.props.debug = parseBoolAttribute(newValue, defaultFrameDebug);\n instance.frameGraphics?.setDebug(instance.props.debug, instance.props);\n },\n \"min-x\": (instance, newValue) => {\n instance.props.minX = parseFloatAttribute(newValue, null);\n instance.boundsUpdated();\n instance.frameGraphics?.setMinX(instance.props.minX, instance.props);\n },\n \"max-x\": (instance, newValue) => {\n instance.props.maxX = parseFloatAttribute(newValue, null);\n instance.boundsUpdated();\n instance.frameGraphics?.setMaxX(instance.props.maxX, instance.props);\n },\n \"min-y\": (instance, newValue) => {\n instance.props.minY = parseFloatAttribute(newValue, null);\n instance.boundsUpdated();\n instance.frameGraphics?.setMinY(instance.props.minY, instance.props);\n },\n \"max-y\": (instance, newValue) => {\n instance.props.maxY = parseFloatAttribute(newValue, null);\n instance.boundsUpdated();\n instance.frameGraphics?.setMaxY(instance.props.maxY, instance.props);\n },\n \"min-z\": (instance, newValue) => {\n instance.props.minZ = parseFloatAttribute(newValue, null);\n instance.boundsUpdated();\n instance.frameGraphics?.setMinZ(instance.props.minZ, instance.props);\n },\n \"max-z\": (instance, newValue) => {\n instance.props.maxZ = parseFloatAttribute(newValue, null);\n instance.boundsUpdated();\n instance.frameGraphics?.setMaxZ(instance.props.maxZ, instance.props);\n },\n });\n\n protected enable() {\n // no-op\n }\n\n protected disable() {\n // no-op\n }\n\n private frameContentsInstance: WebSocketFrameInstance | StaticHTMLFrameInstance | null =\n null;\n private isActivelyLoaded = false;\n private timer: NodeJS.Timeout | null = null;\n\n private boundsUpdated() {\n if (!this.transformableElementGraphics) {\n return;\n }\n const boxBounds = this.getDefinedBoxBounds();\n if (boxBounds) {\n const [minX, maxX, minY, maxY, minZ, maxZ] = boxBounds;\n const obb = OrientedBoundingBox.fromSizeMatrixWorldAndCenter(\n new Vect3(maxX - minX, maxY - minY, maxZ - minZ),\n this.transformableElementGraphics.getWorldMatrix(),\n new Vect3((maxX + minX) / 2, (maxY + minY) / 2, (maxZ + minZ) / 2),\n );\n this.addOrUpdateParentBound(this, obb);\n } else {\n this.removeParentBound(this);\n }\n }\n\n public props: MFrameProps = {\n src: null,\n loadRange: null,\n unloadRange: defaultUnloadRange,\n\n debug: defaultFrameDebug,\n\n minX: null,\n maxX: null,\n minY: null,\n maxY: null,\n minZ: null,\n maxZ: null,\n };\n\n private shouldBeLoaded() {\n if (!this.isConnected) {\n return false;\n }\n if (this.props.loadRange === null) {\n return true;\n }\n\n const userPositionAndRotation = this.getUserPositionAndRotation();\n const elementRelative = getRelativePositionAndRotationRelativeToObject(\n userPositionAndRotation,\n this,\n );\n\n let boxBounds = this.getDefinedBoxBounds();\n if (!boxBounds) {\n boxBounds = [0, 0, 0, 0, 0, 0];\n }\n const [minX, maxX, minY, maxY, minZ, maxZ] = boxBounds;\n if (\n elementRelative.position.x >= minX - this.props.loadRange &&\n elementRelative.position.x <= maxX + this.props.loadRange &&\n elementRelative.position.y >= minY - this.props.loadRange &&\n elementRelative.position.y <= maxY + this.props.loadRange &&\n elementRelative.position.z >= minZ - this.props.loadRange &&\n elementRelative.position.z <= maxZ + this.props.loadRange\n ) {\n return true;\n }\n // If the user is within the unload-range range, keep the current state\n if (\n elementRelative.position.x >= minX - this.props.loadRange - this.props.unloadRange &&\n elementRelative.position.x <= maxX + this.props.loadRange + this.props.unloadRange &&\n elementRelative.position.y >= minY - this.props.loadRange - this.props.unloadRange &&\n elementRelative.position.y <= maxY + this.props.loadRange + this.props.unloadRange &&\n elementRelative.position.z >= minZ - this.props.loadRange - this.props.unloadRange &&\n elementRelative.position.z <= maxZ + this.props.loadRange + this.props.unloadRange\n ) {\n return this.isActivelyLoaded;\n }\n }\n\n private syncLoadState() {\n const shouldBeLoaded = this.shouldBeLoaded();\n if (shouldBeLoaded && !this.isActivelyLoaded) {\n if (this.props.src) {\n this.isActivelyLoaded = true;\n this.createFrameContentsInstance(this.props.src);\n }\n } else if (!shouldBeLoaded && this.isActivelyLoaded) {\n this.isActivelyLoaded = false;\n this.disposeInstance();\n }\n }\n\n static get observedAttributes(): Array {\n return [...TransformableElement.observedAttributes, ...Frame.attributeHandler.getAttributes()];\n }\n\n constructor() {\n super();\n }\n\n public getContentBounds(): OrientedBoundingBox | null {\n return null;\n }\n\n public parentTransformed(): void {\n this.boundsUpdated();\n }\n\n public isClickable(): boolean {\n return true;\n }\n\n private startEmitting() {\n if (this.timer) {\n clearInterval(this.timer);\n }\n\n this.timer = setInterval(() => {\n this.syncLoadState();\n }, 100);\n }\n\n private createFrameContentsInstance(src: string) {\n if (this.frameContentsInstance) {\n if (this.frameContentsInstance.src !== src) {\n console.error(\"Instance already existed with a different src\");\n this.disposeInstance();\n } else {\n return;\n }\n }\n\n if (src.startsWith(\"ws://\") || src.startsWith(\"wss://\")) {\n this.frameContentsInstance = new WebSocketFrameInstance(this, src, this.getScene());\n } else {\n this.frameContentsInstance = new StaticHTMLFrameInstance(this, src, this.getScene());\n }\n }\n\n public getDefinedBoxBounds(): [number, number, number, number, number, number] | null {\n if (\n this.props.minX !== null ||\n this.props.maxX !== null ||\n this.props.minY !== null ||\n this.props.maxY !== null ||\n this.props.minZ !== null ||\n this.props.maxZ !== null\n ) {\n const minX = this.props.minX ?? this.props.maxX ?? 0;\n let maxX = this.props.maxX ?? this.props.minX ?? 0;\n const minY = this.props.minY ?? this.props.maxY ?? 0;\n let maxY = this.props.maxY ?? this.props.minY ?? 0;\n const minZ = this.props.minZ ?? this.props.maxZ ?? 0;\n let maxZ = this.props.maxZ ?? this.props.minZ ?? 0;\n // If any bounds are incorrect make them equal (and therefore not able to contain anything, but visually debuggable)\n if (minX > maxX) {\n maxX = minX;\n }\n if (minY > maxY) {\n maxY = minY;\n }\n if (minZ > maxZ) {\n maxZ = minZ;\n }\n return [minX, maxX, minY, maxY, minZ, maxZ];\n }\n return null;\n }\n\n private disposeInstance() {\n if (this.frameContentsInstance !== null) {\n this.frameContentsInstance.dispose();\n this.frameContentsInstance = null;\n this.isActivelyLoaded = false;\n }\n }\n\n attributeChangedCallback(name: string, oldValue: string | null, newValue: string) {\n if (!this.frameGraphics) {\n return;\n }\n super.attributeChangedCallback(name, oldValue, newValue);\n Frame.attributeHandler.handle(this, name, newValue);\n }\n\n public connectedCallback(): void {\n super.connectedCallback();\n\n if (!this.getScene().hasGraphicsAdapter() || this.frameGraphics) {\n return;\n }\n const graphicsAdapter = this.getScene().getGraphicsAdapter();\n\n this.startEmitting();\n this.syncLoadState();\n\n this.frameGraphics = graphicsAdapter\n .getGraphicsAdapterFactory()\n .MMLFrameGraphicsInterface(this);\n\n for (const name of Frame.observedAttributes) {\n const value = this.getAttribute(name);\n if (value !== null) {\n this.attributeChangedCallback(name, null, value);\n }\n }\n\n this.applyBounds();\n }\n\n public disconnectedCallback(): void {\n this.frameGraphics?.dispose();\n this.frameGraphics = null;\n\n if (this.timer) {\n clearInterval(this.timer);\n }\n this.disposeInstance();\n super.disconnectedCallback();\n }\n}\n", "import { OrientedBoundingBox } from \"../bounding-box\";\nimport { GraphicsAdapter } from \"../graphics\";\nimport { TransformableElement } from \"./TransformableElement\";\n\nexport class Group extends TransformableElement {\n static tagName = \"m-group\";\n static get observedAttributes(): Array {\n return [...TransformableElement.observedAttributes];\n }\n\n protected enable() {\n // no-op\n }\n\n protected disable() {\n // no-op\n }\n\n constructor() {\n super();\n }\n\n public getContentBounds(): OrientedBoundingBox | null {\n return null;\n }\n\n public parentTransformed(): void {\n // no-op\n }\n\n public isClickable(): boolean {\n return true;\n }\n\n attributeChangedCallback(name: string, oldValue: string | null, newValue: string) {\n if (!this.transformableElementGraphics) {\n return;\n }\n super.attributeChangedCallback(name, oldValue, newValue);\n }\n\n connectedCallback() {\n super.connectedCallback();\n\n if (!this.getScene().hasGraphicsAdapter()) {\n return;\n }\n\n for (const name of Group.observedAttributes) {\n const value = this.getAttribute(name);\n if (value !== null) {\n this.attributeChangedCallback(name, null, value);\n }\n }\n }\n}\n", "import { AnimatedAttributeHelper } from \"../attribute-animation\";\nimport { AttributeHandler, parseBoolAttribute, parseFloatAttribute } from \"../attributes\";\nimport { OrientedBoundingBox } from \"../bounding-box\";\nimport { CollideableHelper } from \"../collision\";\nimport { GraphicsAdapter } from \"../graphics\";\nimport { ImageGraphics } from \"../graphics/ImageGraphics\";\nimport { Vect3 } from \"../math/Vect3\";\nimport { AnimationType } from \"./AttributeAnimation\";\nimport { MElement } from \"./MElement\";\nimport { TransformableElement } from \"./TransformableElement\";\n\nconst defaultImageSrc = null;\nconst defaultImageWidth = null;\nconst defaultImageHeight = null;\nconst defaultImageOpacity = 1;\nconst defaultImageCastShadows = true;\nconst defaultImageEmissive = 0;\n\nexport type MImageProps = {\n src: string | null;\n width: number | null;\n height: number | null;\n opacity: number;\n castShadows: boolean;\n emissive: number;\n};\n\nexport class Image extends TransformableElement {\n static tagName = \"m-image\";\n\n public props: MImageProps = {\n src: defaultImageSrc,\n width: defaultImageWidth,\n height: defaultImageHeight,\n opacity: defaultImageOpacity,\n castShadows: defaultImageCastShadows,\n emissive: defaultImageEmissive as number,\n };\n\n private imageAnimatedAttributeHelper = new AnimatedAttributeHelper(this, {\n width: [\n AnimationType.Number,\n defaultImageWidth,\n (newValue: number) => {\n this.props.width = newValue;\n this.imageGraphics?.setWidth(newValue, this.props);\n },\n ],\n height: [\n AnimationType.Number,\n defaultImageHeight,\n (newValue: number) => {\n this.props.height = newValue;\n this.imageGraphics?.setHeight(newValue, this.props);\n },\n ],\n opacity: [\n AnimationType.Number,\n defaultImageOpacity,\n (newValue: number) => {\n this.props.opacity = newValue;\n this.imageGraphics?.setOpacity(newValue, this.props);\n },\n ],\n emissive: [\n AnimationType.Number,\n defaultImageEmissive,\n (newValue: number) => {\n this.props.emissive = newValue;\n this.imageGraphics?.setEmissive(newValue, this.props);\n },\n ],\n });\n\n private collideableHelper = new CollideableHelper(this);\n\n private static attributeHandler = new AttributeHandler>({\n width: (instance, newValue) => {\n instance.imageAnimatedAttributeHelper.elementSetAttribute(\n \"width\",\n parseFloatAttribute(newValue, defaultImageWidth),\n );\n },\n height: (instance, newValue) => {\n instance.imageAnimatedAttributeHelper.elementSetAttribute(\n \"height\",\n parseFloatAttribute(newValue, defaultImageHeight),\n );\n },\n src: (instance, newValue) => {\n instance.props.src = newValue;\n instance.imageGraphics?.setSrc(newValue, instance.props);\n },\n opacity: (instance, newValue) => {\n instance.imageAnimatedAttributeHelper.elementSetAttribute(\n \"opacity\",\n parseFloatAttribute(newValue, defaultImageOpacity),\n );\n },\n emissive: (instance, newValue) => {\n instance.imageAnimatedAttributeHelper.elementSetAttribute(\n \"emissive\",\n parseFloatAttribute(newValue, defaultImageEmissive),\n );\n },\n \"cast-shadows\": (instance, newValue) => {\n instance.props.castShadows = parseBoolAttribute(newValue, defaultImageCastShadows);\n instance.imageGraphics?.setCastShadows(instance.props.castShadows, instance.props);\n },\n });\n private imageGraphics: ImageGraphics | null;\n\n protected enable() {\n this.collideableHelper.enable();\n }\n\n protected disable() {\n this.collideableHelper.disable();\n }\n\n static get observedAttributes(): Array {\n return [\n ...TransformableElement.observedAttributes,\n ...Image.attributeHandler.getAttributes(),\n ...CollideableHelper.observedAttributes,\n ];\n }\n\n constructor() {\n super();\n }\n\n public getContentBounds(): OrientedBoundingBox | null {\n if (!this.transformableElementGraphics) {\n return null;\n }\n const { width, height } = this.imageGraphics?.getWidthAndHeight() || { width: 0, height: 0 };\n return OrientedBoundingBox.fromSizeAndMatrixWorld(\n new Vect3(width, height, 0),\n this.transformableElementGraphics.getWorldMatrix(),\n );\n }\n\n public addSideEffectChild(child: MElement): void {\n this.imageAnimatedAttributeHelper.addSideEffectChild(child);\n super.addSideEffectChild(child);\n }\n\n public removeSideEffectChild(child: MElement): void {\n this.imageAnimatedAttributeHelper.removeSideEffectChild(child);\n super.removeSideEffectChild(child);\n }\n\n public parentTransformed(): void {\n this.collideableHelper.parentTransformed();\n }\n\n public isClickable(): boolean {\n return true;\n }\n\n attributeChangedCallback(name: string, oldValue: string | null, newValue: string) {\n if (!this.imageGraphics) {\n return;\n }\n super.attributeChangedCallback(name, oldValue, newValue);\n Image.attributeHandler.handle(this, name, newValue);\n this.collideableHelper.handle(name, newValue);\n }\n\n connectedCallback(): void {\n super.connectedCallback();\n\n if (!this.getScene().hasGraphicsAdapter() || this.imageGraphics) {\n return;\n }\n const graphicsAdapter = this.getScene().getGraphicsAdapter();\n\n this.imageGraphics = graphicsAdapter\n .getGraphicsAdapterFactory()\n .MMLImageGraphicsInterface(this, () => {\n this.applyBounds();\n this.collideableHelper.updateCollider(this.imageGraphics?.getCollisionElement());\n });\n\n for (const name of Image.observedAttributes) {\n const value = this.getAttribute(name);\n if (value !== null) {\n this.attributeChangedCallback(name, null, value);\n }\n }\n\n this.collideableHelper.updateCollider(this.imageGraphics?.getCollisionElement());\n }\n\n disconnectedCallback() {\n this.imageAnimatedAttributeHelper.reset();\n this.imageGraphics?.dispose();\n this.imageGraphics = null;\n super.disconnectedCallback();\n this.collideableHelper.removeColliders();\n }\n}\n", "import { AnimatedAttributeHelper } from \"../attribute-animation\";\nimport { AttributeHandler, parseBoolAttribute, parseFloatAttribute } from \"../attributes\";\nimport { OrientedBoundingBox } from \"../bounding-box\";\nimport { GraphicsAdapter, InteractionGraphics } from \"../graphics\";\nimport { Vect3 } from \"../math\";\nimport { IMMLScene } from \"../scene\";\nimport { AnimationType } from \"./AttributeAnimation\";\nimport { MElement } from \"./MElement\";\nimport { TransformableElement } from \"./TransformableElement\";\n\nconst defaultInteractionRange = 5;\nconst defaultInteractionInFocus = true;\nconst defaultInteractionLineOfSight = false;\nconst defaultInteractionPriority = 1;\nconst defaultInteractionPrompt = null;\nconst defaultInteractionDebug = false;\n\nexport type MInteractionProps = {\n range: number;\n inFocus: boolean;\n lineOfSight: boolean;\n priority: number;\n prompt: string | null;\n debug: boolean;\n};\n\nexport class Interaction<\n G extends GraphicsAdapter = GraphicsAdapter,\n> extends TransformableElement {\n static tagName = \"m-interaction\";\n private interactionGraphics: InteractionGraphics | null;\n\n private interactionAnimatedAttributeHelper = new AnimatedAttributeHelper(this, {\n range: [\n AnimationType.Number,\n defaultInteractionRange,\n (newValue: number) => {\n this.props.range = newValue;\n this.applyBounds();\n this.interactionGraphics?.setRange(newValue, this.props);\n },\n ],\n });\n\n private static attributeHandler = new AttributeHandler>({\n range: (instance, newValue) => {\n instance.interactionAnimatedAttributeHelper.elementSetAttribute(\n \"range\",\n parseFloatAttribute(newValue, defaultInteractionRange),\n );\n },\n \"in-focus\": (instance, newValue) => {\n instance.props.inFocus = parseBoolAttribute(newValue, defaultInteractionInFocus);\n instance.interactionGraphics?.setInFocus(instance.props.inFocus, instance.props);\n },\n \"line-of-sight\": (instance, newValue) => {\n instance.props.lineOfSight = parseBoolAttribute(newValue, defaultInteractionLineOfSight);\n instance.interactionGraphics?.setLineOfSight(instance.props.lineOfSight, instance.props);\n },\n priority: (instance, newValue) => {\n instance.props.priority = parseFloatAttribute(newValue, defaultInteractionPriority);\n instance.interactionGraphics?.setPriority(instance.props.priority, instance.props);\n },\n prompt: (instance, newValue) => {\n instance.props.prompt = newValue;\n instance.interactionGraphics?.setPrompt(instance.props.prompt, instance.props);\n },\n debug: (instance, newValue) => {\n instance.props.debug = parseBoolAttribute(newValue, defaultInteractionDebug);\n instance.interactionGraphics?.setDebug(instance.props.debug, instance.props);\n },\n });\n static get observedAttributes(): Array {\n return [\n ...TransformableElement.observedAttributes,\n ...Interaction.attributeHandler.getAttributes(),\n ];\n }\n\n public props: MInteractionProps = {\n range: defaultInteractionRange as number,\n inFocus: defaultInteractionInFocus as boolean,\n lineOfSight: defaultInteractionLineOfSight as boolean,\n priority: defaultInteractionPriority as number,\n prompt: defaultInteractionPrompt as string | null,\n debug: defaultInteractionDebug as boolean,\n };\n\n private registeredScene: IMMLScene | null = null;\n\n constructor() {\n super();\n }\n\n protected enable() {\n // TODO\n }\n\n protected disable() {\n // TODO\n }\n\n public getContentBounds(): OrientedBoundingBox | null {\n if (!this.transformableElementGraphics) {\n return null;\n }\n return OrientedBoundingBox.fromSizeAndMatrixWorld(\n new Vect3(this.props.range * 2, this.props.range * 2, this.props.range * 2),\n this.transformableElementGraphics.getWorldMatrix(),\n );\n }\n\n public addSideEffectChild(child: MElement): void {\n this.interactionAnimatedAttributeHelper.addSideEffectChild(child);\n super.addSideEffectChild(child);\n }\n\n public removeSideEffectChild(child: MElement): void {\n this.interactionAnimatedAttributeHelper.removeSideEffectChild(child);\n super.removeSideEffectChild(child);\n }\n\n public parentTransformed(): void {\n this.registeredScene?.updateInteraction?.(this);\n }\n\n public isClickable(): boolean {\n return false;\n }\n\n public connectedCallback(): void {\n super.connectedCallback();\n\n if (!this.getScene().hasGraphicsAdapter() || this.interactionGraphics) {\n return;\n }\n const graphicsAdapter = this.getScene().getGraphicsAdapter();\n\n this.interactionGraphics = graphicsAdapter\n .getGraphicsAdapterFactory()\n .MMLInteractionGraphicsInterface(this);\n\n for (const name of Interaction.observedAttributes) {\n const value = this.getAttribute(name);\n if (value !== null) {\n this.attributeChangedCallback(name, null, value);\n }\n }\n\n this.registerInteraction();\n }\n\n public disconnectedCallback(): void {\n this.unregisterInteraction();\n this.interactionAnimatedAttributeHelper.reset();\n this.interactionGraphics?.dispose();\n this.interactionGraphics = null;\n super.disconnectedCallback();\n }\n\n public attributeChangedCallback(name: string, oldValue: string | null, newValue: string) {\n super.attributeChangedCallback(name, oldValue, newValue);\n if (Interaction.attributeHandler.handle(this, name, newValue)) {\n if (this.registeredScene !== null) {\n this.registeredScene.updateInteraction?.(this);\n }\n }\n }\n\n public trigger() {\n this.dispatchEvent(new CustomEvent(\"interact\", { detail: {} }));\n }\n\n private registerInteraction() {\n const scene = this.getScene();\n this.registeredScene = scene;\n scene.addInteraction?.(this);\n }\n\n private unregisterInteraction() {\n if (this.registeredScene !== null) {\n this.registeredScene.removeInteraction?.(this);\n this.registeredScene = null;\n }\n }\n}\n", "import * as THREE from \"three\";\n\nimport { AnimatedAttributeHelper } from \"../attribute-animation\";\nimport {\n AttributeHandler,\n parseBoolAttribute,\n parseColorAttribute,\n parseEnumAttribute,\n parseFloatAttribute,\n} from \"../attributes\";\nimport { OrientedBoundingBox } from \"../bounding-box\";\nimport { CollideableHelper } from \"../collision\";\nimport { MMLColor } from \"../color\";\nimport { GraphicsAdapter } from \"../graphics\";\nimport { LabelGraphics } from \"../graphics\";\nimport { Vect3 } from \"../math\";\nimport { AnimationType } from \"./AttributeAnimation\";\nimport { MElement } from \"./MElement\";\nimport { TransformableElement } from \"./TransformableElement\";\n\nexport enum MLabelAlignment {\n left = \"left\",\n center = \"center\",\n right = \"right\",\n}\n\nconst defaultLabelColor = { r: 1, g: 1, b: 1 };\nconst defaultFontColor = { r: 0, g: 0, b: 0 };\nconst defaultLabelAlignment = MLabelAlignment.left;\nconst defaultLabelFontSize = 24;\nconst defaultLabelPadding = 8;\nconst defaultLabelWidth = 1;\nconst defaultLabelHeight = 1;\nconst defaultLabelCastShadows = true;\nconst defaultEmissive = 0;\n\nexport type MLabelProps = {\n content: string;\n alignment: MLabelAlignment;\n width: number;\n height: number;\n fontSize: number;\n padding: number;\n color: MMLColor;\n fontColor: MMLColor;\n castShadows: boolean;\n emissive: number;\n};\n\nexport class Label extends TransformableElement {\n static tagName = \"m-label\";\n private labelGraphics: LabelGraphics | null;\n private collideableHelper = new CollideableHelper(this);\n\n private labelAnimatedAttributeHelper = new AnimatedAttributeHelper(this, {\n color: [\n AnimationType.Color,\n defaultLabelColor,\n (newValue: THREE.Color) => {\n this.props.color = newValue;\n this.labelGraphics?.setColor(this.props.color, this.props);\n },\n ],\n \"font-color\": [\n AnimationType.Color,\n defaultFontColor,\n (newValue: THREE.Color) => {\n this.props.fontColor = newValue;\n this.labelGraphics?.setFontColor(this.props.fontColor, this.props);\n },\n ],\n width: [\n AnimationType.Number,\n defaultLabelWidth,\n (newValue: number) => {\n this.props.width = newValue;\n this.labelGraphics?.setWidth(this.props.width, this.props);\n },\n ],\n height: [\n AnimationType.Number,\n defaultLabelHeight,\n (newValue: number) => {\n this.props.height = newValue;\n this.labelGraphics?.setHeight(this.props.height, this.props);\n },\n ],\n padding: [\n AnimationType.Number,\n defaultLabelPadding,\n (newValue: number) => {\n this.props.padding = newValue;\n this.labelGraphics?.setPadding(this.props.padding, this.props);\n },\n ],\n \"font-size\": [\n AnimationType.Number,\n defaultLabelFontSize,\n (newValue: number) => {\n this.props.fontSize = newValue;\n this.labelGraphics?.setFontSize(this.props.fontSize, this.props);\n },\n ],\n });\n\n public props: MLabelProps = {\n content: \"\",\n alignment: defaultLabelAlignment,\n width: defaultLabelWidth,\n height: defaultLabelHeight,\n fontSize: defaultLabelFontSize,\n padding: defaultLabelPadding,\n color: defaultLabelColor,\n fontColor: defaultFontColor,\n castShadows: defaultLabelCastShadows,\n emissive: defaultEmissive as number,\n };\n\n private static attributeHandler = new AttributeHandler>({\n width: (instance, newValue) => {\n instance.labelAnimatedAttributeHelper.elementSetAttribute(\n \"width\",\n parseFloatAttribute(newValue, defaultLabelWidth),\n );\n },\n height: (instance, newValue) => {\n instance.labelAnimatedAttributeHelper.elementSetAttribute(\n \"height\",\n parseFloatAttribute(newValue, defaultLabelHeight),\n );\n },\n color: (instance, newValue) => {\n instance.labelAnimatedAttributeHelper.elementSetAttribute(\n \"color\",\n parseColorAttribute(newValue, defaultLabelColor),\n );\n },\n \"font-color\": (instance, newValue) => {\n instance.labelAnimatedAttributeHelper.elementSetAttribute(\n \"font-color\",\n parseColorAttribute(newValue, defaultFontColor),\n );\n },\n \"font-size\": (instance, newValue) => {\n instance.labelAnimatedAttributeHelper.elementSetAttribute(\n \"font-size\",\n parseFloatAttribute(newValue, defaultLabelFontSize),\n );\n },\n padding: (instance, newValue) => {\n instance.labelAnimatedAttributeHelper.elementSetAttribute(\n \"padding\",\n parseFloatAttribute(newValue, defaultLabelPadding),\n );\n },\n content: (instance, newValue) => {\n instance.props.content = newValue || \"\";\n instance.labelGraphics?.setContent(instance.props.content, instance.props);\n },\n alignment: (instance, newValue) => {\n instance.props.alignment = parseEnumAttribute(\n newValue,\n MLabelAlignment,\n defaultLabelAlignment,\n );\n instance.labelGraphics?.setAlignment(instance.props.alignment, instance.props);\n },\n \"cast-shadows\": (instance, newValue) => {\n instance.props.castShadows = parseBoolAttribute(newValue, defaultLabelCastShadows);\n instance.labelGraphics?.setCastShadows(instance.props.castShadows, instance.props);\n },\n emissive: (instance, newValue) => {\n instance.props.emissive = parseFloatAttribute(newValue, defaultEmissive);\n instance.labelGraphics?.setEmissive(instance.props.emissive, instance.props);\n },\n });\n\n protected enable() {\n // no-op\n }\n\n protected disable() {\n // no-op\n }\n\n static get observedAttributes(): Array {\n return [...TransformableElement.observedAttributes, ...Label.attributeHandler.getAttributes()];\n }\n\n constructor() {\n super();\n }\n\n public getContentBounds(): OrientedBoundingBox | null {\n if (!this.transformableElementGraphics) {\n return null;\n }\n\n return OrientedBoundingBox.fromSizeAndMatrixWorld(\n new Vect3(this.props.width, this.props.height, 0),\n this.transformableElementGraphics.getWorldMatrix(),\n );\n }\n\n public addSideEffectChild(child: MElement): void {\n this.labelAnimatedAttributeHelper.addSideEffectChild(child);\n\n super.addSideEffectChild(child);\n }\n\n public removeSideEffectChild(child: MElement): void {\n this.labelAnimatedAttributeHelper.removeSideEffectChild(child);\n\n super.removeSideEffectChild(child);\n }\n\n public parentTransformed(): void {\n // no-op\n }\n\n public isClickable(): boolean {\n return true;\n }\n\n public attributeChangedCallback(name: string, oldValue: string | null, newValue: string) {\n if (!this.labelGraphics) {\n return;\n }\n super.attributeChangedCallback(name, oldValue, newValue);\n Label.attributeHandler.handle(this, name, newValue);\n this.collideableHelper.handle(name, newValue);\n }\n\n public connectedCallback(): void {\n super.connectedCallback();\n\n if (!this.getScene().hasGraphicsAdapter() || this.labelGraphics) {\n return;\n }\n const graphicsAdapter = this.getScene().getGraphicsAdapter();\n\n this.labelGraphics = graphicsAdapter\n .getGraphicsAdapterFactory()\n .MMLLabelGraphicsInterface(this);\n\n for (const name of Label.observedAttributes) {\n const value = this.getAttribute(name);\n if (value !== null) {\n this.attributeChangedCallback(name, null, value);\n }\n }\n\n this.applyBounds();\n this.collideableHelper.updateCollider(this.labelGraphics?.getCollisionElement());\n }\n\n public disconnectedCallback(): void {\n this.collideableHelper.removeColliders();\n this.labelAnimatedAttributeHelper.reset();\n this.labelGraphics?.dispose();\n this.labelGraphics = null;\n super.disconnectedCallback();\n }\n}\n", "import { AnimatedAttributeHelper } from \"../attribute-animation\";\nimport {\n AttributeHandler,\n parseBoolAttribute,\n parseColorAttribute,\n parseEnumAttribute,\n parseFloatAttribute,\n} from \"../attributes\";\nimport { OrientedBoundingBox } from \"../bounding-box\";\nimport { MMLColor } from \"../color\";\nimport { GraphicsAdapter, LightGraphics } from \"../graphics\";\nimport { AnimationType, AttributeAnimation } from \"./AttributeAnimation\";\nimport { MElement } from \"./MElement\";\nimport { TransformableElement } from \"./TransformableElement\";\n\nexport enum LightTypes {\n spotlight = \"spotlight\",\n point = \"point\",\n}\n\nconst defaultLightColor: MMLColor = { r: 1, g: 1, b: 1 };\nconst defaultLightIntensity = 1;\nconst defaultLightAngle = 45;\nconst defaultLightEnabled = true;\nconst defaultLightDebug = false;\nconst defaultLightDistance = null;\nconst defaultLightCastShadows = true;\nconst defaultLightType = LightTypes.spotlight;\n\nexport type MLightProps = {\n color: MMLColor;\n intensity: number;\n enabled: boolean;\n angleDeg: number;\n distance: number | null;\n castShadows: boolean;\n debug: boolean;\n type: LightTypes;\n};\n\nexport class Light extends TransformableElement {\n static tagName = \"m-light\";\n\n private lightGraphics: LightGraphics | null;\n\n private lightAnimatedAttributeHelper = new AnimatedAttributeHelper(this, {\n color: [\n AnimationType.Color,\n defaultLightColor,\n (newValue: MMLColor) => {\n this.props.color = newValue;\n this.lightGraphics?.setColor(newValue, this.props);\n },\n ],\n intensity: [\n AnimationType.Number,\n defaultLightIntensity,\n (newValue: number) => {\n this.props.intensity = newValue;\n this.lightGraphics?.setIntensity(newValue, this.props);\n },\n ],\n angle: [\n AnimationType.Number,\n defaultLightAngle,\n (newValue: number) => {\n this.props.angleDeg = newValue;\n this.lightGraphics?.setAngle(newValue, this.props);\n },\n ],\n distance: [\n AnimationType.Number,\n defaultLightDistance,\n (newValue: number) => {\n this.props.distance = newValue;\n this.lightGraphics?.setDistance(newValue, this.props);\n },\n ],\n });\n\n public props: MLightProps = {\n color: defaultLightColor,\n intensity: defaultLightIntensity,\n enabled: defaultLightEnabled,\n angleDeg: defaultLightAngle,\n distance: defaultLightDistance,\n castShadows: defaultLightCastShadows,\n debug: defaultLightDebug,\n type: defaultLightType as LightTypes,\n };\n\n private static attributeHandler = new AttributeHandler>({\n color: (instance, newValue) => {\n instance.lightAnimatedAttributeHelper.elementSetAttribute(\n \"color\",\n parseColorAttribute(newValue, defaultLightColor),\n );\n },\n intensity: (instance, newValue) => {\n instance.lightAnimatedAttributeHelper.elementSetAttribute(\n \"intensity\",\n parseFloatAttribute(newValue, defaultLightIntensity),\n );\n },\n angle: (instance, newValue) => {\n instance.lightAnimatedAttributeHelper.elementSetAttribute(\n \"angle\",\n parseFloatAttribute(newValue, defaultLightAngle),\n );\n },\n distance: (instance, newValue) => {\n instance.lightAnimatedAttributeHelper.elementSetAttribute(\n \"distance\",\n parseFloatAttribute(newValue, defaultLightDistance),\n );\n },\n enabled: (instance, newValue) => {\n instance.props.enabled = parseBoolAttribute(newValue, defaultLightEnabled);\n instance.lightGraphics?.setEnabled(instance.props.enabled, instance.props);\n },\n \"cast-shadows\": (instance, newValue) => {\n instance.props.castShadows = parseBoolAttribute(newValue, defaultLightCastShadows);\n instance.lightGraphics?.setCastShadows(instance.props.castShadows, instance.props);\n },\n debug: (instance, newValue) => {\n instance.props.debug = parseBoolAttribute(newValue, defaultLightDebug);\n instance.lightGraphics?.setDebug(instance.props.debug, instance.props);\n },\n type: (instance, newValue) => {\n instance.props.type = parseEnumAttribute(newValue, LightTypes, defaultLightType);\n instance.lightGraphics?.setType(instance.props.type, instance.props);\n },\n });\n\n static get observedAttributes(): Array {\n return [...TransformableElement.observedAttributes, ...Light.attributeHandler.getAttributes()];\n }\n\n constructor() {\n super();\n }\n\n protected enable() {\n // no-op\n }\n\n protected disable() {\n // no-op\n }\n\n public getContentBounds(): OrientedBoundingBox | null {\n if (!this.transformableElementGraphics) {\n return null;\n }\n return OrientedBoundingBox.fromMatrixWorld(this.transformableElementGraphics.getWorldMatrix());\n }\n\n public addSideEffectChild(child: MElement): void {\n if (child instanceof AttributeAnimation) {\n const attr = child.getAnimatedAttributeName();\n if (attr) {\n this.lightAnimatedAttributeHelper.addAnimation(child, attr);\n }\n }\n super.addSideEffectChild(child);\n }\n\n public removeSideEffectChild(child: MElement): void {\n if (child instanceof AttributeAnimation) {\n const attr = child.getAnimatedAttributeName();\n if (attr) {\n this.lightAnimatedAttributeHelper.removeAnimation(child, attr);\n }\n }\n super.removeSideEffectChild(child);\n }\n\n public parentTransformed(): void {\n // no-op\n }\n\n public isClickable(): boolean {\n return false;\n }\n\n attributeChangedCallback(name: string, oldValue: string | null, newValue: string) {\n if (!this.lightGraphics) {\n return;\n }\n super.attributeChangedCallback(name, oldValue, newValue);\n Light.attributeHandler.handle(this, name, newValue);\n }\n\n public connectedCallback(): void {\n super.connectedCallback();\n\n if (!this.getScene().hasGraphicsAdapter() || this.lightGraphics) {\n return;\n }\n const graphicsAdapter = this.getScene().getGraphicsAdapter();\n\n this.lightGraphics = graphicsAdapter\n .getGraphicsAdapterFactory()\n .MMLLightGraphicsInterface(this);\n\n for (const name of Light.observedAttributes) {\n const value = this.getAttribute(name);\n if (value !== null) {\n this.attributeChangedCallback(name, null, value);\n }\n }\n }\n\n public disconnectedCallback() {\n this.lightAnimatedAttributeHelper.reset();\n this.lightGraphics?.dispose();\n this.lightGraphics = null;\n super.disconnectedCallback();\n }\n}\n", "import { AttributeHandler } from \"../attributes\";\nimport { OrientedBoundingBox } from \"../bounding-box\";\nimport { GraphicsAdapter, LinkGraphics } from \"../graphics\";\nimport { TransformableElement } from \"./TransformableElement\";\n\nexport type MLinkProps = {\n href: string | null;\n target: string | null;\n};\n\nexport class Link extends TransformableElement {\n static tagName = \"m-link\";\n private linkGraphics: LinkGraphics | null;\n\n private abortController: AbortController | null = null;\n\n public props: MLinkProps = {\n href: null,\n target: null,\n };\n\n private static attributeHandler = new AttributeHandler>({\n href: (instance, newValue) => {\n instance.props.href = newValue !== null ? newValue : null;\n },\n target: (instance, newValue) => {\n instance.props.target = newValue !== null ? newValue : null;\n },\n });\n\n static get observedAttributes(): Array {\n return [...TransformableElement.observedAttributes, ...Link.attributeHandler.getAttributes()];\n }\n\n /*\n This is a simple check to ensure that the href is an acceptable URL and is\n not a \"javascript:alert('foo')\" URL or something other than a navigable URL.\n */\n static isAcceptableHref(href: string): boolean {\n const url = new URL(href, window.location.href);\n if (url.protocol === \"http:\" || url.protocol === \"https:\") {\n return true;\n }\n return false;\n }\n\n constructor() {\n super();\n\n this.addEventListener(\"click\", () => {\n if (this.props.href) {\n const href = this.props.href;\n if (!Link.isAcceptableHref(href)) {\n console.warn(\n `Refusing to navigate to ${href} as it does not meet the acceptable href criteria.`,\n );\n return;\n }\n\n if (this.abortController) {\n this.abortController.abort();\n this.abortController = null;\n }\n this.abortController = new AbortController();\n this.getScene().link(\n { href, target: this.props.target ?? undefined, popup: false },\n this.abortController.signal,\n () => {\n this.abortController = null;\n },\n );\n }\n });\n }\n\n public parentTransformed(): void {\n // no-op\n }\n\n public isClickable(): boolean {\n return false;\n }\n\n attributeChangedCallback(name: string, oldValue: string | null, newValue: string) {\n if (!this.transformableElementGraphics) {\n return;\n }\n super.attributeChangedCallback(name, oldValue, newValue);\n Link.attributeHandler.handle(this, name, newValue);\n }\n\n protected disable(): void {\n // no-op\n }\n\n protected enable(): void {\n // no-op\n }\n\n public getContentBounds(): OrientedBoundingBox | null {\n return null;\n }\n\n public connectedCallback(): void {\n super.connectedCallback();\n\n if (!this.getScene().hasGraphicsAdapter() || this.linkGraphics) {\n return;\n }\n const graphicsAdapter = this.getScene().getGraphicsAdapter();\n\n this.linkGraphics = graphicsAdapter.getGraphicsAdapterFactory().MMLLinkGraphicsInterface(this);\n\n for (const name of Link.observedAttributes) {\n const value = this.getAttribute(name);\n if (value !== null) {\n this.attributeChangedCallback(name, null, value);\n }\n }\n }\n\n public disconnectedCallback(): void {\n this.linkGraphics?.dispose();\n this.linkGraphics = null;\n super.disconnectedCallback();\n }\n}\n", "import { AnimatedAttributeHelper } from \"../attribute-animation\";\nimport {\n AttributeHandler,\n parseBoolAttribute,\n parseColorAttribute,\n parseFloatAttribute,\n} from \"../attributes\";\nimport { OrientedBoundingBox } from \"../bounding-box\";\nimport { CollideableHelper } from \"../collision\";\nimport { MMLColor } from \"../color\";\nimport { GraphicsAdapter, PlaneGraphics } from \"../graphics\";\nimport { Vect3 } from \"../math\";\nimport { AnimationType } from \"./AttributeAnimation\";\nimport { MElement } from \"./MElement\";\nimport { TransformableElement } from \"./TransformableElement\";\n\nconst defaultPlaneColor: MMLColor = { r: 1, g: 1, b: 1 };\nconst defaultPlaneWidth = 1;\nconst defaultPlaneHeight = 1;\nconst defaultPlaneOpacity = 1;\nconst defaultPlaneCastShadows = true;\n\nexport type MPlaneProps = {\n width: number;\n height: number;\n color: MMLColor;\n opacity: number;\n castShadows: boolean;\n};\n\nexport class Plane extends TransformableElement {\n static tagName = \"m-plane\";\n private planeGraphics: PlaneGraphics | null;\n\n public props: MPlaneProps = {\n width: defaultPlaneWidth,\n height: defaultPlaneHeight,\n color: defaultPlaneColor,\n opacity: defaultPlaneOpacity,\n castShadows: defaultPlaneCastShadows,\n };\n\n private planeAnimatedAttributeHelper = new AnimatedAttributeHelper(this, {\n color: [\n AnimationType.Color,\n defaultPlaneColor,\n (newValue: MMLColor) => {\n this.props.color = newValue;\n this.planeGraphics?.setColor(newValue, this.props);\n },\n ],\n width: [\n AnimationType.Number,\n defaultPlaneWidth,\n (newValue: number) => {\n this.props.width = newValue;\n this.planeGraphics?.setWidth(newValue, this.props);\n this.applyBounds();\n this.collideableHelper.updateCollider(this.planeGraphics?.getCollisionElement());\n },\n ],\n height: [\n AnimationType.Number,\n defaultPlaneHeight,\n (newValue: number) => {\n this.props.height = newValue;\n this.planeGraphics?.setHeight(newValue, this.props);\n this.applyBounds();\n this.collideableHelper.updateCollider(this.planeGraphics?.getCollisionElement());\n },\n ],\n opacity: [\n AnimationType.Number,\n defaultPlaneOpacity,\n (newValue: number) => {\n this.props.opacity = newValue;\n this.planeGraphics?.setOpacity(newValue, this.props);\n },\n ],\n });\n private collideableHelper = new CollideableHelper(this);\n\n private static attributeHandler = new AttributeHandler>({\n width: (instance, newValue) => {\n instance.planeAnimatedAttributeHelper.elementSetAttribute(\n \"width\",\n parseFloatAttribute(newValue, defaultPlaneWidth),\n );\n },\n height: (instance, newValue) => {\n instance.planeAnimatedAttributeHelper.elementSetAttribute(\n \"height\",\n parseFloatAttribute(newValue, defaultPlaneHeight),\n );\n },\n color: (instance, newValue) => {\n instance.planeAnimatedAttributeHelper.elementSetAttribute(\n \"color\",\n parseColorAttribute(newValue, defaultPlaneColor),\n );\n },\n opacity: (instance, newValue) => {\n instance.planeAnimatedAttributeHelper.elementSetAttribute(\n \"opacity\",\n parseFloatAttribute(newValue, defaultPlaneOpacity),\n );\n },\n \"cast-shadows\": (instance, newValue) => {\n instance.props.castShadows = parseBoolAttribute(newValue, defaultPlaneCastShadows);\n instance.planeGraphics?.setCastShadows(instance.props.castShadows, instance.props);\n },\n });\n\n protected enable() {\n this.collideableHelper.enable();\n }\n\n protected disable() {\n this.collideableHelper.disable();\n }\n\n public getContentBounds(): OrientedBoundingBox | null {\n if (!this.transformableElementGraphics) {\n return null;\n }\n return OrientedBoundingBox.fromSizeAndMatrixWorld(\n new Vect3(this.props.width, this.props.height, 0),\n this.transformableElementGraphics.getWorldMatrix(),\n );\n }\n\n static get observedAttributes(): Array {\n return [\n ...TransformableElement.observedAttributes,\n ...Plane.attributeHandler.getAttributes(),\n ...CollideableHelper.observedAttributes,\n ];\n }\n\n constructor() {\n super();\n }\n\n public addSideEffectChild(child: MElement): void {\n this.planeAnimatedAttributeHelper.addSideEffectChild(child);\n super.addSideEffectChild(child);\n }\n\n public removeSideEffectChild(child: MElement): void {\n this.planeAnimatedAttributeHelper.removeSideEffectChild(child);\n super.removeSideEffectChild(child);\n }\n\n public parentTransformed(): void {\n this.collideableHelper.parentTransformed();\n }\n\n public isClickable(): boolean {\n return true;\n }\n\n public attributeChangedCallback(name: string, oldValue: string | null, newValue: string) {\n if (!this.planeGraphics) {\n return;\n }\n super.attributeChangedCallback(name, oldValue, newValue);\n Plane.attributeHandler.handle(this, name, newValue);\n this.collideableHelper.handle(name, newValue);\n }\n\n public connectedCallback(): void {\n super.connectedCallback();\n\n if (!this.getScene().hasGraphicsAdapter() || this.planeGraphics) {\n return;\n }\n const graphicsAdapter = this.getScene().getGraphicsAdapter();\n\n this.planeGraphics = graphicsAdapter\n .getGraphicsAdapterFactory()\n .MMLPlaneGraphicsInterface(this);\n\n for (const name of Plane.observedAttributes) {\n const value = this.getAttribute(name);\n if (value !== null) {\n this.attributeChangedCallback(name, null, value);\n }\n }\n\n this.applyBounds();\n this.collideableHelper.updateCollider(this.planeGraphics?.getCollisionElement());\n }\n\n public disconnectedCallback(): void {\n this.collideableHelper.removeColliders();\n this.planeAnimatedAttributeHelper.reset();\n this.planeGraphics?.dispose();\n this.planeGraphics = null;\n super.disconnectedCallback();\n }\n}\n", "import { AnimatedAttributeHelper } from \"../attribute-animation\";\nimport { AttributeHandler, parseBoolAttribute, parseFloatAttribute } from \"../attributes\";\nimport { OrientedBoundingBox } from \"../bounding-box\";\nimport { GraphicsAdapter, PositionProbeGraphics } from \"../graphics\";\nimport { Vect3 } from \"../math\";\nimport { getRelativePositionAndRotationRelativeToObject } from \"../position\";\nimport { AnimationType } from \"./AttributeAnimation\";\nimport { MElement } from \"./MElement\";\nimport { TransformableElement } from \"./TransformableElement\";\n\nconst defaultPositionProbeRange = 10;\nconst defaultPositionProbeInterval = 1000;\nconst defaultPositionProbeMinimumInterval = 100;\nconst defaultPositionProbeDebug = false;\nconst positionProbeEnterEventName = \"positionenter\";\nconst positionProbePositionMoveEventName = \"positionmove\";\nconst positionProbeLeaveEventName = \"positionleave\";\n\nexport type MPositionProbeProps = {\n intervalMs: number;\n debug: boolean;\n range: number;\n};\n\nexport class PositionProbe<\n G extends GraphicsAdapter = GraphicsAdapter,\n> extends TransformableElement {\n static tagName = \"m-position-probe\";\n private positionProbeGraphics: PositionProbeGraphics | null;\n\n private positionProbeAnimatedAttributeHelper = new AnimatedAttributeHelper(this, {\n range: [\n AnimationType.Number,\n defaultPositionProbeRange,\n (newValue: number) => {\n this.props.range = newValue;\n this.positionProbeGraphics?.setRange(newValue, this.props);\n this.applyBounds();\n },\n ],\n });\n\n public props: MPositionProbeProps = {\n intervalMs: defaultPositionProbeInterval,\n debug: defaultPositionProbeDebug,\n range: defaultPositionProbeRange,\n };\n\n private static attributeHandler = new AttributeHandler>({\n range: (instance, newValue) => {\n instance.positionProbeAnimatedAttributeHelper.elementSetAttribute(\n \"range\",\n parseFloatAttribute(newValue, defaultPositionProbeRange),\n );\n },\n interval: (instance, newValue) => {\n instance.props.intervalMs = Math.max(\n defaultPositionProbeMinimumInterval,\n parseFloatAttribute(newValue, defaultPositionProbeInterval),\n );\n instance.startEmitting();\n },\n debug: (instance, newValue) => {\n instance.props.debug = parseBoolAttribute(newValue, defaultPositionProbeDebug);\n instance.positionProbeGraphics?.setDebug(instance.props.debug, instance.props);\n },\n });\n\n static get observedAttributes(): Array {\n return [\n ...TransformableElement.observedAttributes,\n ...PositionProbe.attributeHandler.getAttributes(),\n ];\n }\n\n private timer: NodeJS.Timeout | null = null;\n\n private currentlyInRange = false;\n\n constructor() {\n super();\n }\n\n protected enable() {\n // no-op\n }\n\n protected disable() {\n // no-op\n }\n\n public parentTransformed() {\n // no-op\n }\n\n public getContentBounds(): OrientedBoundingBox | null {\n if (!this.transformableElementGraphics) {\n return null;\n }\n return OrientedBoundingBox.fromSizeAndMatrixWorld(\n new Vect3(this.props.range * 2, this.props.range * 2, this.props.range * 2),\n this.transformableElementGraphics.getWorldMatrix(),\n );\n }\n\n public addSideEffectChild(child: MElement): void {\n this.positionProbeAnimatedAttributeHelper.addSideEffectChild(child);\n super.addSideEffectChild(child);\n }\n\n public removeSideEffectChild(child: MElement): void {\n this.positionProbeAnimatedAttributeHelper.removeSideEffectChild(child);\n super.removeSideEffectChild(child);\n }\n\n public isClickable(): boolean {\n return false;\n }\n\n attributeChangedCallback(name: string, oldValue: string | null, newValue: string) {\n if (!this.positionProbeGraphics) {\n return;\n }\n super.attributeChangedCallback(name, oldValue, newValue);\n PositionProbe.attributeHandler.handle(this, name, newValue);\n }\n\n private emitPosition() {\n const userPositionAndRotation = this.getUserPositionAndRotation();\n const elementRelative = getRelativePositionAndRotationRelativeToObject(\n userPositionAndRotation,\n this,\n );\n\n // Check if the position is within range\n const distance = new Vect3().copy(elementRelative.position).length();\n\n let withinBounds = true;\n this.getAppliedBounds().forEach((bounds) => {\n if (!bounds.containsPoint(userPositionAndRotation.position)) {\n withinBounds = false;\n }\n });\n\n if (withinBounds && distance <= this.props.range) {\n const elementRelativePositionAndRotation = {\n position: elementRelative.position,\n rotation: {\n x: elementRelative.rotation.x,\n y: elementRelative.rotation.y,\n z: elementRelative.rotation.z,\n },\n };\n\n let documentRoot: MElement | null = null;\n const remoteDocument = this.getInitiatedRemoteDocument();\n if (remoteDocument) {\n documentRoot = remoteDocument;\n }\n const documentRelative =\n documentRoot !== null\n ? getRelativePositionAndRotationRelativeToObject(userPositionAndRotation, documentRoot)\n : userPositionAndRotation;\n\n const documentRelativePositionAndRotation = {\n position: documentRelative.position,\n rotation: {\n x: documentRelative.rotation.x,\n y: documentRelative.rotation.y,\n z: documentRelative.rotation.z,\n },\n };\n if (!this.currentlyInRange) {\n this.currentlyInRange = true;\n this.dispatchEvent(\n new CustomEvent(positionProbeEnterEventName, {\n detail: {\n elementRelative: elementRelativePositionAndRotation,\n documentRelative: documentRelativePositionAndRotation,\n },\n }),\n );\n } else {\n this.dispatchEvent(\n new CustomEvent(positionProbePositionMoveEventName, {\n detail: {\n elementRelative: elementRelativePositionAndRotation,\n documentRelative: documentRelativePositionAndRotation,\n },\n }),\n );\n }\n } else {\n if (this.currentlyInRange) {\n this.currentlyInRange = false;\n this.dispatchEvent(new CustomEvent(positionProbeLeaveEventName, {}));\n }\n }\n }\n\n public connectedCallback(): void {\n super.connectedCallback();\n\n if (!this.getScene().hasGraphicsAdapter() || this.positionProbeGraphics) {\n return;\n }\n const graphicsAdapter = this.getScene().getGraphicsAdapter();\n\n this.positionProbeGraphics = graphicsAdapter\n .getGraphicsAdapterFactory()\n .MMLPositionProbeGraphicsInterface(this);\n\n for (const name of PositionProbe.observedAttributes) {\n const value = this.getAttribute(name);\n if (value !== null) {\n this.attributeChangedCallback(name, null, value);\n }\n }\n\n this.applyBounds();\n this.startEmitting();\n }\n\n public disconnectedCallback(): void {\n if (this.timer) {\n clearInterval(this.timer);\n }\n this.positionProbeAnimatedAttributeHelper.reset();\n this.positionProbeGraphics?.dispose();\n this.positionProbeGraphics = null;\n super.disconnectedCallback();\n }\n\n private startEmitting() {\n if (this.timer) {\n clearInterval(this.timer);\n }\n\n this.timer = setInterval(() => {\n this.emitPosition();\n }, this.props.intervalMs);\n }\n}\n", "import { AttributeHandler } from \"../attributes\";\nimport { OrientedBoundingBox } from \"../bounding-box\";\nimport { GraphicsAdapter, PromptGraphics } from \"../graphics\";\nimport { TransformableElement } from \"./TransformableElement\";\n\nexport type MPromptProps = {\n message: string | undefined;\n placeholder: string | undefined;\n prefill: string | undefined;\n};\n\nexport class Prompt extends TransformableElement {\n static tagName = \"m-prompt\";\n private promptGraphics: PromptGraphics | null;\n\n private abortController: AbortController | null = null;\n\n public props: MPromptProps = {\n message: undefined as string | undefined,\n placeholder: undefined as string | undefined,\n prefill: undefined as string | undefined,\n };\n\n private static attributeHandler = new AttributeHandler>({\n message: (instance, newValue) => {\n instance.props.message = newValue !== null ? newValue : undefined;\n instance.promptGraphics?.setMessage(instance.props.message, instance.props);\n },\n placeholder: (instance, newValue) => {\n instance.props.placeholder = newValue !== null ? newValue : undefined;\n instance.promptGraphics?.setPlaceholder(instance.props.placeholder, instance.props);\n },\n prefill: (instance, newValue) => {\n instance.props.prefill = newValue !== null ? newValue : undefined;\n instance.promptGraphics?.setPrefill(instance.props.prefill, instance.props);\n },\n });\n\n protected enable() {\n // no-op\n }\n\n protected disable() {\n // no-op\n }\n\n static get observedAttributes(): Array {\n return [...TransformableElement.observedAttributes, ...Prompt.attributeHandler.getAttributes()];\n }\n\n constructor() {\n super();\n\n this.addEventListener(\"click\", () => {\n this.trigger();\n });\n }\n\n public getContentBounds(): OrientedBoundingBox | null {\n return null;\n }\n\n public parentTransformed(): void {\n // no-op\n }\n\n public isClickable(): boolean {\n return false;\n }\n\n attributeChangedCallback(name: string, oldValue: string | null, newValue: string) {\n if (!this.promptGraphics) {\n return;\n }\n super.attributeChangedCallback(name, oldValue, newValue);\n Prompt.attributeHandler.handle(this, name, newValue);\n }\n\n private trigger(): void {\n if (this.abortController) {\n this.abortController.abort();\n this.abortController = null;\n }\n this.abortController = new AbortController();\n this.getScene().prompt(this.props, this.abortController.signal, (result) => {\n if (!this.isConnected) {\n return;\n }\n if (result !== null) {\n this.dispatchEvent(\n new CustomEvent(\"prompt\", { bubbles: false, detail: { value: result } }),\n );\n }\n });\n }\n\n public connectedCallback(): void {\n super.connectedCallback();\n\n if (!this.getScene().hasGraphicsAdapter() || this.promptGraphics) {\n return;\n }\n const graphicsAdapter = this.getScene().getGraphicsAdapter();\n\n this.promptGraphics = graphicsAdapter\n .getGraphicsAdapterFactory()\n .MMLPromptGraphicsInterface(this);\n\n for (const name of Prompt.observedAttributes) {\n const value = this.getAttribute(name);\n if (value !== null) {\n this.attributeChangedCallback(name, null, value);\n }\n }\n }\n\n public disconnectedCallback(): void {\n this.promptGraphics?.dispose();\n this.promptGraphics = null;\n super.disconnectedCallback();\n }\n}\n", "/**\n * The MMLDocumentTimeManager class is responsible for tracking the current document time and notifying listeners of\n * either shifts in time (e.g. media synced to time) and also ticking (e.g. for elements that are animating) when the\n * document time changes.\n */\nexport class MMLDocumentTimeManager {\n private relativeDocumentStartTime = 0;\n private overridenDocumentTime: number | null = null;\n private documentTimeListeners = new Set<(time: number) => void>();\n private documentTimeTickListeners = new Set<(time: number) => void>();\n\n constructor() {}\n\n public tick() {\n const documentTime = this.getDocumentTime();\n for (const cb of this.documentTimeTickListeners) {\n cb(documentTime);\n }\n }\n\n public getDocumentTime(): number {\n if (this.overridenDocumentTime !== null) {\n return this.overridenDocumentTime;\n }\n return (document.timeline.currentTime as number) - this.relativeDocumentStartTime;\n }\n\n public getWindowTime(): number {\n if (this.overridenDocumentTime !== null) {\n return this.overridenDocumentTime;\n }\n return document.timeline.currentTime as number;\n }\n\n public addDocumentTimeListenerCallback(cb: (time: number) => void) {\n this.documentTimeListeners.add(cb);\n }\n\n public removeDocumentTimeListenerCallback(cb: (time: number) => void) {\n this.documentTimeListeners.delete(cb);\n }\n\n public addDocumentTimeTickListenerCallback(cb: (time: number) => void) {\n this.documentTimeTickListeners.add(cb);\n }\n\n public removeDocumentTimeTickListenerCallback(cb: (time: number) => void) {\n this.documentTimeTickListeners.delete(cb);\n }\n\n public setDocumentTime(documentTime: number) {\n if (this.overridenDocumentTime !== null) {\n return;\n }\n this.relativeDocumentStartTime = (document.timeline.currentTime as number) - documentTime;\n\n for (const cb of this.documentTimeListeners) {\n cb(documentTime);\n }\n }\n\n // This method is used for testing to allow overriding the document time\n public overrideDocumentTime(documentTime: number) {\n this.overridenDocumentTime = documentTime;\n\n for (const cb of this.documentTimeListeners) {\n cb(documentTime);\n }\n }\n}\n", "import { OrientedBoundingBox } from \"../bounding-box\";\nimport { GraphicsAdapter } from \"../graphics\";\nimport { RemoteDocumentGraphics } from \"../graphics\";\nimport { IMMLScene } from \"../scene\";\nimport { MMLDocumentTimeManager } from \"../time\";\nimport { consumeEventEventName, MElement } from \"./MElement\";\n\nexport class RemoteDocument extends MElement {\n static tagName = \"m-remote-document\";\n\n private scene: IMMLScene | null = null;\n private documentAddress: string | null = null;\n private documentTimeManager: MMLDocumentTimeManager;\n private animationFrameCallback: number | null = null;\n private remoteDocumentGraphics: RemoteDocumentGraphics | null;\n\n constructor() {\n super();\n this.documentTimeManager = new MMLDocumentTimeManager();\n\n this.addEventListener(consumeEventEventName, (wrappedEvent: CustomEvent) => {\n wrappedEvent.stopPropagation();\n });\n }\n\n public showError(showError: boolean) {\n this.remoteDocumentGraphics?.showError(showError);\n }\n\n protected enable() {\n // no-op\n }\n\n protected disable() {\n // no-op\n }\n\n public getContentBounds(): OrientedBoundingBox | null {\n return null;\n }\n\n public parentTransformed(): void {\n // no-op\n }\n\n public isClickable(): boolean {\n return false;\n }\n\n public getDocumentTimeManager(): MMLDocumentTimeManager {\n return this.documentTimeManager;\n }\n\n public connectedCallback(): void {\n this.style.display = \"none\";\n if (!this.isConnected) {\n return;\n }\n\n super.connectedCallback();\n\n if (!this.getScene().hasGraphicsAdapter() || this.remoteDocumentGraphics) {\n return;\n }\n const graphicsAdapter = this.getScene().getGraphicsAdapter();\n\n this.remoteDocumentGraphics = graphicsAdapter\n .getGraphicsAdapterFactory()\n .RemoteDocumentGraphicsInterface(this);\n this.animationFrameCallback = window.requestAnimationFrame(() => {\n this.tick();\n });\n }\n\n public disconnectedCallback() {\n if (this.animationFrameCallback) {\n window.cancelAnimationFrame(this.animationFrameCallback);\n this.animationFrameCallback = null;\n }\n this.remoteDocumentGraphics?.dispose();\n this.remoteDocumentGraphics = null;\n super.disconnectedCallback();\n }\n\n public dispatchEvent(event: CustomEvent): boolean {\n if (this.contains(event.detail.element)) {\n return HTMLElement.prototype.dispatchEvent.call(this, event);\n } else {\n return false;\n }\n }\n\n public init(mmlScene: IMMLScene, documentAddress: string) {\n if (this.scene) {\n throw new Error(\"Scene already set\");\n }\n this.scene = mmlScene;\n this.documentAddress = documentAddress;\n this.connectedCallback();\n }\n\n public getDocumentAddress(): string | null {\n return this.documentAddress;\n }\n\n public getMMLScene(): IMMLScene | null {\n if (!this.scene) {\n return null;\n }\n return this.scene;\n }\n\n public tick() {\n this.documentTimeManager.tick();\n this.animationFrameCallback = window.requestAnimationFrame(() => {\n this.tick();\n });\n }\n}\n", "import { AnimatedAttributeHelper } from \"../attribute-animation\";\nimport {\n AttributeHandler,\n parseBoolAttribute,\n parseColorAttribute,\n parseFloatAttribute,\n} from \"../attributes\";\nimport { OrientedBoundingBox } from \"../bounding-box\";\nimport { CollideableHelper } from \"../collision\";\nimport { MMLColor } from \"../color\";\nimport { GraphicsAdapter, SphereGraphics } from \"../graphics\";\nimport { Vect3 } from \"../math\";\nimport { AnimationType } from \"./AttributeAnimation\";\nimport { MElement } from \"./MElement\";\nimport { TransformableElement } from \"./TransformableElement\";\n\nconst defaultSphereColor: MMLColor = { r: 1, g: 1, b: 1 };\nconst defaultSphereRadius = 0.5;\nconst defaultSphereOpacity = 1;\nconst defaultSphereCastShadows = true;\n\nexport type MSphereProps = {\n radius: number;\n color: MMLColor;\n opacity: number;\n castShadows: boolean;\n};\n\nexport class Sphere extends TransformableElement {\n static tagName = \"m-sphere\";\n\n public props: MSphereProps = {\n radius: defaultSphereRadius,\n color: defaultSphereColor,\n opacity: defaultSphereOpacity,\n castShadows: defaultSphereCastShadows,\n };\n\n private sphereAnimatedAttributeHelper = new AnimatedAttributeHelper(this, {\n color: [\n AnimationType.Color,\n defaultSphereColor,\n (newValue: MMLColor) => {\n this.props.color = newValue;\n this.sphereGraphics?.setColor(newValue, this.props);\n },\n ],\n radius: [\n AnimationType.Number,\n defaultSphereRadius,\n (newValue: number) => {\n this.props.radius = newValue;\n this.sphereGraphics?.setRadius(newValue, this.props);\n this.applyBounds();\n this.collideableHelper.updateCollider(this.sphereGraphics?.getCollisionElement());\n },\n ],\n opacity: [\n AnimationType.Number,\n defaultSphereOpacity,\n (newValue: number) => {\n this.props.opacity = newValue;\n this.sphereGraphics?.setOpacity(newValue, this.props);\n },\n ],\n });\n private collideableHelper = new CollideableHelper(this);\n\n private static attributeHandler = new AttributeHandler>({\n radius: (instance, newValue) => {\n instance.sphereAnimatedAttributeHelper.elementSetAttribute(\n \"radius\",\n parseFloatAttribute(newValue, defaultSphereRadius),\n );\n },\n color: (instance, newValue) => {\n instance.sphereAnimatedAttributeHelper.elementSetAttribute(\n \"color\",\n parseColorAttribute(newValue, defaultSphereColor),\n );\n },\n opacity: (instance, newValue) => {\n instance.sphereAnimatedAttributeHelper.elementSetAttribute(\n \"opacity\",\n parseFloatAttribute(newValue, defaultSphereOpacity),\n );\n },\n \"cast-shadows\": (instance, newValue) => {\n instance.props.castShadows = parseBoolAttribute(newValue, defaultSphereCastShadows);\n instance.sphereGraphics?.setCastShadows(instance.props.castShadows, instance.props);\n },\n });\n private sphereGraphics: SphereGraphics | null;\n\n protected enable() {\n this.collideableHelper.enable();\n }\n\n protected disable() {\n this.collideableHelper.disable();\n }\n\n public getContentBounds(): OrientedBoundingBox | null {\n if (!this.transformableElementGraphics) {\n return null;\n }\n return OrientedBoundingBox.fromSizeAndMatrixWorld(\n new Vect3(this.props.radius * 2, this.props.radius * 2, this.props.radius * 2),\n this.transformableElementGraphics.getWorldMatrix(),\n );\n }\n\n static get observedAttributes(): Array {\n return [\n ...TransformableElement.observedAttributes,\n ...Sphere.attributeHandler.getAttributes(),\n ...CollideableHelper.observedAttributes,\n ];\n }\n\n constructor() {\n super();\n }\n\n public addSideEffectChild(child: MElement): void {\n this.sphereAnimatedAttributeHelper.addSideEffectChild(child);\n super.addSideEffectChild(child);\n }\n\n public removeSideEffectChild(child: MElement): void {\n this.sphereAnimatedAttributeHelper.removeSideEffectChild(child);\n super.removeSideEffectChild(child);\n }\n\n public parentTransformed(): void {\n this.collideableHelper.parentTransformed();\n }\n\n public isClickable(): boolean {\n return true;\n }\n\n public attributeChangedCallback(name: string, oldValue: string | null, newValue: string) {\n if (!this.sphereGraphics) {\n return;\n }\n super.attributeChangedCallback(name, oldValue, newValue);\n Sphere.attributeHandler.handle(this, name, newValue);\n this.collideableHelper.handle(name, newValue);\n }\n\n public connectedCallback(): void {\n super.connectedCallback();\n\n if (!this.getScene().hasGraphicsAdapter() || this.sphereGraphics) {\n return;\n }\n const graphicsAdapter = this.getScene().getGraphicsAdapter();\n\n this.sphereGraphics = graphicsAdapter\n .getGraphicsAdapterFactory()\n .MMLSphereGraphicsInterface(this);\n\n for (const name of Sphere.observedAttributes) {\n const value = this.getAttribute(name);\n if (value !== null) {\n this.attributeChangedCallback(name, null, value);\n }\n }\n\n this.applyBounds();\n this.collideableHelper.updateCollider(this.sphereGraphics.getCollisionElement());\n }\n\n public disconnectedCallback(): void {\n this.collideableHelper.removeColliders();\n this.sphereAnimatedAttributeHelper.reset();\n this.sphereGraphics?.dispose();\n this.sphereGraphics = null;\n super.disconnectedCallback();\n }\n}\n", "import { AnimatedAttributeHelper } from \"../attribute-animation\";\nimport { AttributeHandler, parseBoolAttribute, parseFloatAttribute } from \"../attributes\";\nimport { OrientedBoundingBox } from \"../bounding-box\";\nimport { CollideableHelper } from \"../collision\";\nimport { GraphicsAdapter, VideoGraphics } from \"../graphics\";\nimport { Vect3 } from \"../math\";\nimport { AnimationType } from \"./AttributeAnimation\";\nimport { MElement } from \"./MElement\";\nimport { TransformableElement } from \"./TransformableElement\";\n\nconst defaultVideoWidth = null;\nconst defaultVideoHeight = null;\nconst defaultVideoVolume = 1;\nconst defaultVideoLoop = true;\nconst defaultVideoEnabled = true;\nconst defaultVideoStartTime = 0;\nconst defaultVideoPauseTime = null;\nconst defaultVideoSrc = null;\nconst defaultVideoCastShadows = true;\nconst defaultVideoEmissive = 0;\n\nexport type MVideoProps = {\n width: number | null;\n height: number | null;\n enabled: boolean;\n loop: boolean;\n startTime: number;\n pauseTime: number | null;\n src: string | null;\n volume: number;\n castShadows: boolean;\n emissive: number;\n};\n\nexport class Video extends TransformableElement {\n static tagName = \"m-video\";\n\n private videoAnimatedAttributeHelper = new AnimatedAttributeHelper(this, {\n width: [\n AnimationType.Number,\n defaultVideoWidth,\n (newValue: number) => {\n this.props.width = newValue;\n this.videoGraphics?.setWidth(newValue, this.props);\n },\n ],\n height: [\n AnimationType.Number,\n defaultVideoHeight,\n (newValue: number) => {\n this.props.height = newValue;\n this.videoGraphics?.setHeight(newValue, this.props);\n },\n ],\n emissive: [\n AnimationType.Number,\n defaultVideoEmissive,\n (newValue: number) => {\n this.props.emissive = newValue;\n this.videoGraphics?.setEmissive(newValue, this.props);\n },\n ],\n });\n\n static get observedAttributes(): Array {\n return [\n ...TransformableElement.observedAttributes,\n ...Video.attributeHandler.getAttributes(),\n ...CollideableHelper.observedAttributes,\n ];\n }\n\n private documentTimeListener: { remove: () => void };\n private collideableHelper = new CollideableHelper(this);\n\n // Parsed attribute values\n public props: MVideoProps = {\n startTime: defaultVideoStartTime,\n pauseTime: defaultVideoPauseTime,\n src: defaultVideoSrc,\n loop: defaultVideoLoop,\n enabled: defaultVideoEnabled,\n volume: defaultVideoVolume,\n width: defaultVideoWidth,\n height: defaultVideoHeight,\n castShadows: defaultVideoCastShadows,\n emissive: defaultVideoEmissive,\n };\n\n private static attributeHandler = new AttributeHandler>({\n width: (instance, newValue) => {\n instance.videoAnimatedAttributeHelper.elementSetAttribute(\n \"width\",\n parseFloatAttribute(newValue, defaultVideoWidth),\n );\n },\n height: (instance, newValue) => {\n instance.videoAnimatedAttributeHelper.elementSetAttribute(\n \"height\",\n parseFloatAttribute(newValue, defaultVideoHeight),\n );\n },\n enabled: (instance, newValue) => {\n instance.props.enabled = parseBoolAttribute(newValue, defaultVideoEnabled);\n instance.videoGraphics?.setEnabled(instance.props.enabled, instance.props);\n },\n loop: (instance, newValue) => {\n instance.props.loop = parseBoolAttribute(newValue, defaultVideoLoop);\n instance.videoGraphics?.setLoop(instance.props.loop, instance.props);\n },\n \"start-time\": (instance, newValue) => {\n instance.props.startTime = parseFloatAttribute(newValue, defaultVideoStartTime);\n instance.videoGraphics?.setStartTime(instance.props.startTime, instance.props);\n },\n \"pause-time\": (instance, newValue) => {\n instance.props.pauseTime = parseFloatAttribute(newValue, defaultVideoPauseTime);\n instance.videoGraphics?.setPauseTime(instance.props.pauseTime, instance.props);\n },\n src: (instance, newValue) => {\n instance.props.src = newValue;\n instance.videoGraphics?.setSrc(newValue, instance.props);\n },\n volume: (instance, newValue) => {\n instance.props.volume = parseFloatAttribute(newValue, defaultVideoVolume);\n instance.videoGraphics?.setVolume(instance.props.volume, instance.props);\n },\n \"cast-shadows\": (instance, newValue) => {\n instance.props.castShadows = parseBoolAttribute(newValue, defaultVideoCastShadows);\n instance.videoGraphics?.setCastShadows(instance.props.castShadows, instance.props);\n },\n emissive: (instance, newValue) => {\n instance.videoAnimatedAttributeHelper.elementSetAttribute(\n \"emissive\",\n parseFloatAttribute(newValue, defaultVideoEmissive),\n );\n },\n });\n private videoGraphics: VideoGraphics | null;\n\n protected enable() {\n this.videoGraphics?.syncVideoTime();\n }\n\n protected disable() {\n this.videoGraphics?.syncVideoTime();\n }\n\n constructor() {\n super();\n }\n\n public getContentBounds(): OrientedBoundingBox | null {\n if (!this.videoGraphics || !this.transformableElementGraphics) {\n return null;\n }\n const { width, height } = this.videoGraphics.getWidthAndHeight() || { width: 0, height: 0 };\n return OrientedBoundingBox.fromSizeAndMatrixWorld(\n new Vect3(width, height, 0),\n this.transformableElementGraphics.getWorldMatrix(),\n );\n }\n\n public addSideEffectChild(child: MElement): void {\n this.videoAnimatedAttributeHelper.addSideEffectChild(child);\n super.addSideEffectChild(child);\n }\n\n public removeSideEffectChild(child: MElement): void {\n this.videoAnimatedAttributeHelper.removeSideEffectChild(child);\n super.removeSideEffectChild(child);\n }\n\n public parentTransformed(): void {\n this.collideableHelper.parentTransformed();\n }\n\n public isClickable(): boolean {\n return true;\n }\n\n attributeChangedCallback(name: string, oldValue: string | null, newValue: string) {\n if (!this.videoGraphics) {\n return;\n }\n super.attributeChangedCallback(name, oldValue, newValue);\n Video.attributeHandler.handle(this, name, newValue);\n this.collideableHelper.handle(name, newValue);\n }\n\n private documentTimeChanged() {\n this.videoGraphics?.syncVideoTime();\n }\n\n public connectedCallback(): void {\n super.connectedCallback();\n\n if (!this.getScene().hasGraphicsAdapter() || this.videoGraphics) {\n return;\n }\n const graphicsAdapter = this.getScene().getGraphicsAdapter();\n\n this.videoGraphics = graphicsAdapter\n .getGraphicsAdapterFactory()\n .MMLVideoGraphicsInterface(this, () => {\n this.applyBounds();\n this.collideableHelper.updateCollider(this.videoGraphics?.getCollisionElement());\n });\n\n this.documentTimeListener = this.addDocumentTimeListener(() => {\n this.documentTimeChanged();\n });\n\n for (const name of Video.observedAttributes) {\n const value = this.getAttribute(name);\n if (value !== null) {\n this.attributeChangedCallback(name, null, value);\n }\n }\n\n this.collideableHelper.updateCollider(this.videoGraphics?.getCollisionElement());\n }\n\n disconnectedCallback() {\n this.videoAnimatedAttributeHelper.reset();\n this.videoGraphics?.dispose();\n this.videoGraphics = null;\n this.documentTimeListener.remove();\n this.collideableHelper.removeColliders();\n super.disconnectedCallback();\n }\n}\n", "import { AttributeAnimation } from \"./AttributeAnimation\";\nimport { AttributeLerp } from \"./AttributeLerp\";\nimport { Audio } from \"./Audio\";\nimport { Character } from \"./Character\";\nimport { ChatProbe } from \"./ChatProbe\";\nimport { Cube } from \"./Cube\";\nimport { Cylinder } from \"./Cylinder\";\nimport { Frame } from \"./Frame\";\nimport { Group } from \"./Group\";\nimport { Image } from \"./Image\";\nimport { Interaction } from \"./Interaction\";\nimport { Label } from \"./Label\";\nimport { Light } from \"./Light\";\nimport { Link } from \"./Link\";\nimport { MElement } from \"./MElement\";\nimport { Model } from \"./Model\";\nimport { Plane } from \"./Plane\";\nimport { PositionProbe } from \"./PositionProbe\";\nimport { Prompt } from \"./Prompt\";\nimport { RemoteDocument } from \"./RemoteDocument\";\nimport { Sphere } from \"./Sphere\";\nimport { Video } from \"./Video\";\n\nexport function registerCustomElementsToWindow(targetWindow: Window) {\n // TODO - copy the classes to generate window-specific classes rather than overwriting the superclass on each call\n const targetHTMLElement = (targetWindow as any)[\"HTMLElement\"] as typeof HTMLElement;\n MElement.overwriteSuperclass(targetHTMLElement);\n targetWindow.customElements.define(RemoteDocument.tagName, RemoteDocument);\n targetWindow.customElements.define(Light.tagName, Light);\n targetWindow.customElements.define(Model.tagName, Model);\n targetWindow.customElements.define(Character.tagName, Character);\n targetWindow.customElements.define(Cube.tagName, Cube);\n targetWindow.customElements.define(Frame.tagName, Frame);\n targetWindow.customElements.define(Cylinder.tagName, Cylinder);\n targetWindow.customElements.define(Plane.tagName, Plane);\n targetWindow.customElements.define(Label.tagName, Label);\n targetWindow.customElements.define(Group.tagName, Group);\n targetWindow.customElements.define(Prompt.tagName, Prompt);\n targetWindow.customElements.define(Link.tagName, Link);\n targetWindow.customElements.define(Sphere.tagName, Sphere);\n targetWindow.customElements.define(Image.tagName, Image);\n targetWindow.customElements.define(Video.tagName, Video);\n targetWindow.customElements.define(Audio.tagName, Audio);\n targetWindow.customElements.define(PositionProbe.tagName, PositionProbe);\n targetWindow.customElements.define(ChatProbe.tagName, ChatProbe);\n targetWindow.customElements.define(Interaction.tagName, Interaction);\n targetWindow.customElements.define(AttributeAnimation.tagName, AttributeAnimation);\n targetWindow.customElements.define(AttributeLerp.tagName, AttributeLerp);\n}\n", "type ListenerFunc = (...args: any[]) => void;\n\ntype EventSpecificationTuple = [EventTarget, string, ListenerFunc, AddEventListenerOptions?];\n\n/**\n * The EventHandlerCollection is a utility class that allows you to add event listeners to a collection of targets and\n * then clear them all at once.\n *\n * This avoids the caller needing to keep references to the functions applied to the event listeners.\n */\nexport class EventHandlerCollection {\n private eventsByTarget: Map>> = new Map();\n\n public add(\n target: EventTarget,\n key: string,\n listener: ListenerFunc,\n options?: AddEventListenerOptions,\n ): this {\n target.addEventListener(key, listener, options);\n\n let existingTarget = this.eventsByTarget.get(target);\n if (existingTarget === undefined) {\n existingTarget = new Map();\n this.eventsByTarget.set(target, existingTarget);\n }\n let existingKey = existingTarget.get(key);\n if (existingKey === undefined) {\n existingKey = new Set();\n existingTarget.set(key, existingKey);\n }\n existingKey.add(listener);\n\n return this;\n }\n\n public clear() {\n this.eventsByTarget.forEach((keyMap, target) => {\n keyMap.forEach((listenerSet, key) => {\n listenerSet.forEach((listenerFunc) => {\n target.removeEventListener(key, listenerFunc);\n });\n });\n });\n this.eventsByTarget.clear();\n }\n\n static create(initial?: Array): EventHandlerCollection {\n const instance = new EventHandlerCollection();\n if (initial !== undefined) {\n initial.forEach(([target, key, listenerFunc, options]) => {\n instance.add(target, key, listenerFunc, options);\n });\n }\n return instance;\n }\n}\n", "import { Interaction } from \"../elements\";\nimport { GraphicsAdapter } from \"../graphics\";\nimport { InteractionListener } from \"../scene\";\nimport { EventHandlerCollection } from \"../utils/EventHandlerCollection\";\n\ntype InteractionState = {\n interaction: Interaction;\n distance?: number;\n button?: HTMLButtonElement;\n};\n\nfunction createInteractionsHolder(\n onPrev: () => void,\n onNext: () => void,\n onClose: () => void,\n): {\n holderElement: HTMLDivElement;\n listElement: HTMLDivElement;\n prevButton: HTMLButtonElement;\n statusHolder: HTMLDivElement;\n nextButton: HTMLButtonElement;\n} {\n const holderElement = document.createElement(\"div\");\n holderElement.setAttribute(\"data-test-id\", \"interactions-holder\");\n holderElement.style.zIndex = \"100\";\n holderElement.style.position = \"absolute\";\n holderElement.style.backgroundColor = \"white\";\n holderElement.style.padding = \"10px\";\n holderElement.style.display = \"none\";\n holderElement.style.border = \"1px solid #AAA\";\n holderElement.style.fontFamily = \"sans-serif\";\n holderElement.style.top = \"50%\";\n holderElement.style.left = \"50%\";\n holderElement.style.transform = \"translate(-50%, -50%)\";\n\n const closeButtonHolder = document.createElement(\"div\");\n closeButtonHolder.style.display = \"flex\";\n closeButtonHolder.style.justifyContent = \"flex-end\";\n holderElement.appendChild(closeButtonHolder);\n\n const title = document.createElement(\"h3\");\n title.style.textAlign = \"center\";\n title.textContent = \"Interactions\";\n holderElement.appendChild(title);\n\n const closeButton = document.createElement(\"button\");\n closeButton.textContent = \"Close\";\n closeButton.style.cursor = \"pointer\";\n closeButton.addEventListener(\"click\", () => {\n onClose();\n });\n closeButtonHolder.appendChild(closeButton);\n\n const listElement = document.createElement(\"div\");\n listElement.setAttribute(\"data-test-id\", \"interactions-list\");\n holderElement.appendChild(listElement);\n\n const buttonHolder = document.createElement(\"div\");\n buttonHolder.style.display = \"flex\";\n buttonHolder.style.justifyContent = \"space-between\";\n holderElement.appendChild(buttonHolder);\n\n const prevButton = document.createElement(\"button\");\n prevButton.textContent = \"Prev\";\n prevButton.style.cursor = \"pointer\";\n prevButton.addEventListener(\"click\", onPrev);\n buttonHolder.appendChild(prevButton);\n\n const statusHolder = document.createElement(\"div\");\n statusHolder.style.display = \"flex\";\n statusHolder.style.justifyContent = \"center\";\n statusHolder.style.padding = \"5px\";\n buttonHolder.appendChild(statusHolder);\n\n const nextButton = document.createElement(\"button\");\n nextButton.textContent = \"Next\";\n nextButton.style.cursor = \"pointer\";\n nextButton.addEventListener(\"click\", onNext);\n buttonHolder.appendChild(nextButton);\n\n return { holderElement, listElement, prevButton, statusHolder, nextButton };\n}\n\nfunction createInteractionPrompt() {\n const interactionPrompt = document.createElement(\"div\");\n interactionPrompt.setAttribute(\"data-test-id\", \"interactions-prompt\");\n interactionPrompt.style.zIndex = \"101\";\n interactionPrompt.style.position = \"absolute\";\n interactionPrompt.style.top = \"10px\";\n interactionPrompt.style.left = \"10px\";\n interactionPrompt.style.display = \"none\";\n interactionPrompt.style.padding = \"12px 10px\";\n interactionPrompt.style.fontFamily = \"Helvetica\";\n interactionPrompt.style.color = \"white\";\n interactionPrompt.style.backgroundColor = \"#222222b2\";\n interactionPrompt.innerHTML = \"Press E to interact\";\n return interactionPrompt;\n}\n\nexport class InteractionManager {\n private static pageLimit = 3;\n private pageOffset = 0;\n\n private eventCollection = new EventHandlerCollection();\n\n private interactionListElement: HTMLDivElement;\n private interactionHolderElement: HTMLDivElement;\n private prevButton: HTMLButtonElement;\n private statusHolder: HTMLDivElement;\n private nextButton: HTMLButtonElement;\n private interactionPromptElement: HTMLDivElement;\n\n private possibleActions = new Map, InteractionState>();\n private visibleActions = new Set();\n private tickInterval: NodeJS.Timeout | null = null;\n private sortedActions: InteractionState[] = [];\n\n private static createButtonText(interaction: Interaction) {\n return `${interaction.props.prompt ?? \"Interact\"}`;\n }\n\n private constructor(\n private container: HTMLElement,\n private interactionShouldShowDistance: (\n interaction: Interaction,\n ) => number | null,\n ) {\n this.container = container;\n const { holderElement, listElement, prevButton, statusHolder, nextButton } =\n createInteractionsHolder(\n () => {\n this.pageOffset--;\n this.displayInteractions();\n },\n () => {\n this.pageOffset++;\n this.displayInteractions();\n },\n () => {\n this.hideHolder();\n },\n );\n this.prevButton = prevButton;\n this.statusHolder = statusHolder;\n this.nextButton = nextButton;\n this.interactionListElement = listElement;\n this.interactionHolderElement = holderElement;\n this.container.appendChild(this.interactionHolderElement);\n\n this.interactionPromptElement = createInteractionPrompt();\n this.container.appendChild(this.interactionPromptElement);\n\n this.eventCollection.add(document, \"keydown\", (e: KeyboardEvent) => {\n // if the e key is pressed, show the UI\n if (e.code === \"KeyE\") {\n if (this.interactionHolderElement.style.display === \"block\") {\n this.hideHolder();\n return;\n }\n if (this.visibleActions.size > 0) {\n this.showHolder();\n }\n } else if (e.code === \"Escape\") {\n this.hideHolder();\n }\n });\n }\n\n private getInteractionListener(): InteractionListener {\n return {\n addInteraction: (interaction: Interaction) => {\n this.possibleActions.set(interaction, {\n interaction,\n });\n },\n removeInteraction: (interaction: Interaction) => {\n const interactionState = this.possibleActions.get(interaction);\n if (!interactionState) {\n console.warn(\"Interaction not found\", interaction);\n return;\n }\n\n if (interactionState.button) {\n interactionState.button.remove();\n }\n this.possibleActions.delete(interaction);\n if (this.visibleActions.has(interactionState)) {\n this.visibleActions.delete(interactionState);\n if (this.visibleActions.size === 0) {\n this.hidePrompt();\n }\n }\n },\n updateInteraction: (interaction: Interaction) => {\n const interactionState = this.possibleActions.get(interaction);\n if (!interactionState) {\n console.warn(\"Interaction not found\", interaction);\n return;\n }\n if (interactionState.button) {\n interactionState.button.textContent = InteractionManager.createButtonText(interaction);\n }\n },\n };\n }\n\n static init(\n container: HTMLElement,\n interactionShouldShowDistance: (interaction: Interaction) => number | null,\n ): {\n interactionManager: InteractionManager;\n interactionListener: InteractionListener;\n } {\n const interactionManager = new InteractionManager(container, interactionShouldShowDistance);\n interactionManager.startTick();\n return { interactionManager, interactionListener: interactionManager.getInteractionListener() };\n }\n\n public dispose() {\n if (this.tickInterval) {\n clearInterval(this.tickInterval);\n }\n this.eventCollection.clear();\n this.interactionListElement.remove();\n this.interactionHolderElement.remove();\n this.interactionPromptElement.remove();\n }\n\n private startTick() {\n this.tickInterval = setInterval(() => {\n this.possibleActions.forEach((interactionState, interaction) => {\n const showDistance = this.interactionShouldShowDistance(interaction);\n if (showDistance !== null) {\n interactionState.distance = showDistance;\n this.visibleActions.add(interactionState);\n } else {\n this.visibleActions.delete(interactionState);\n }\n });\n\n if (this.visibleActions.size === 0) {\n this.hidePrompt();\n this.hideHolder();\n return;\n } else {\n this.showPrompt();\n }\n\n this.sortedActions = Array.from(this.visibleActions).sort(\n (a: InteractionState, b: InteractionState) => {\n // sort by priority first\n const priorityDiff = a.interaction.props.priority - b.interaction.props.priority;\n if (priorityDiff !== 0) {\n return priorityDiff;\n }\n\n // Otherwise sort by distance if available\n if (a.distance && b.distance) {\n const distanceDiff = a.distance - b.distance;\n if (Math.abs(distanceDiff) > 0.1) {\n return distanceDiff;\n }\n }\n return 0;\n },\n );\n\n this.displayInteractions();\n }, 1000);\n }\n\n private displayInteractions() {\n this.interactionListElement.innerHTML = \"\";\n const maximumPageOffset = Math.floor(\n (this.sortedActions.length - 1) / InteractionManager.pageLimit,\n );\n if (this.pageOffset > maximumPageOffset) {\n this.pageOffset = maximumPageOffset;\n }\n if (this.pageOffset < 0) {\n this.pageOffset = 0;\n }\n const startIndex = this.pageOffset * InteractionManager.pageLimit;\n\n const pagedItems = this.sortedActions.slice(\n startIndex,\n startIndex + InteractionManager.pageLimit,\n );\n\n if (this.pageOffset > 0) {\n this.prevButton.removeAttribute(\"disabled\");\n } else {\n this.prevButton.setAttribute(\"disabled\", \"true\");\n }\n\n if (this.pageOffset < maximumPageOffset) {\n this.nextButton.removeAttribute(\"disabled\");\n } else {\n this.nextButton.setAttribute(\"disabled\", \"true\");\n }\n\n this.statusHolder.textContent = `Page ${this.pageOffset + 1} of ${maximumPageOffset + 1}`;\n\n pagedItems.forEach((interactionState) => {\n if (!interactionState.button) {\n const interactionText = InteractionManager.createButtonText(interactionState.interaction);\n const button = document.createElement(\"button\");\n button.style.display = \"block\";\n button.style.marginBottom = \"5px\";\n button.style.cursor = \"pointer\";\n button.style.textOverflow = \"ellipsis\";\n button.style.overflow = \"hidden\";\n button.style.whiteSpace = \"nowrap\";\n button.style.maxWidth = \"200px\";\n button.setAttribute(\"data-test-id\", `interaction-${interactionText}`);\n button.textContent = interactionText;\n button.addEventListener(\"click\", () => {\n interactionState.interaction.trigger();\n this.hideHolder();\n });\n interactionState.button = button;\n }\n this.interactionListElement.appendChild(interactionState.button);\n });\n }\n\n private hideHolder() {\n this.interactionHolderElement.style.display = \"none\";\n }\n\n private showHolder() {\n this.interactionHolderElement.style.display = \"block\";\n }\n\n private hidePrompt() {\n this.interactionPromptElement.style.display = \"none\";\n }\n\n private showPrompt() {\n this.interactionPromptElement.style.display = \"block\";\n }\n}\n", "export class Modal {\n public element: HTMLDivElement;\n public titleElement: HTMLDivElement;\n public contentsElement: HTMLDivElement;\n\n constructor() {\n this.element = document.createElement(\"div\");\n this.element.style.display = \"block\";\n this.element.style.border = \"1px solid #AAA\";\n this.element.style.fontFamily = \"sans-serif\";\n this.element.style.color = \"black\";\n\n this.element.style.boxShadow = \"0px 4px 4px rgba(0, 0, 0, 0.1)\";\n this.element.style.backdropFilter = \"blur(4px)\";\n this.element.style.borderRadius = \"4px\";\n\n this.titleElement = document.createElement(\"div\");\n this.titleElement.style.background = \"rgba(255, 255, 255, 0.8)\";\n this.titleElement.style.padding = \"8px\";\n this.titleElement.style.fontWeight = \"bold\";\n this.titleElement.style.borderBottom = \"1px solid #AAA\";\n\n this.contentsElement = document.createElement(\"div\");\n this.contentsElement.style.background = \"rgba(255, 255, 255, 0.6)\";\n this.contentsElement.style.padding = \"8px\";\n this.element.append(this.titleElement, this.contentsElement);\n\n this.element.addEventListener(\"keydown\", (e: KeyboardEvent) => {\n e.stopPropagation();\n });\n }\n\n dispose() {\n this.element.remove();\n }\n}\n", "import { Modal } from \"./Modal\";\n\nexport class ConfirmModal extends Modal {\n private confirmContentsElement: HTMLDivElement;\n private messageElement: HTMLDivElement;\n private buttonsHolder: HTMLDivElement;\n private cancelButton: HTMLButtonElement;\n private okButton: HTMLButtonElement;\n\n constructor(title: string, message: string, callback: (result: boolean) => void) {\n super();\n\n this.titleElement.textContent = title;\n\n this.confirmContentsElement = document.createElement(\"div\");\n this.messageElement = document.createElement(\"div\");\n this.messageElement.textContent = message;\n this.messageElement.style.marginBottom = \"8px\";\n this.confirmContentsElement.appendChild(this.messageElement);\n this.contentsElement.appendChild(this.confirmContentsElement);\n\n this.buttonsHolder = document.createElement(\"div\");\n this.buttonsHolder.style.display = \"flex\";\n this.buttonsHolder.style.justifyContent = \"space-between\";\n this.buttonsHolder.style.marginTop = \"8px\";\n\n this.cancelButton = document.createElement(\"button\");\n this.cancelButton.setAttribute(\"data-test-id\", \"confirm-modal-cancel-button\");\n this.cancelButton.style.cursor = \"pointer\";\n this.cancelButton.textContent = \"Cancel\";\n this.cancelButton.addEventListener(\"click\", () => {\n callback(false);\n this.dispose();\n });\n this.buttonsHolder.appendChild(this.cancelButton);\n\n this.okButton = document.createElement(\"button\");\n this.okButton.setAttribute(\"data-test-id\", \"confirm-modal-ok-button\");\n this.okButton.style.cursor = \"pointer\";\n this.okButton.textContent = \"OK\";\n this.okButton.addEventListener(\"click\", () => {\n callback(true);\n this.dispose();\n });\n this.buttonsHolder.appendChild(this.okButton);\n this.contentsElement.appendChild(this.buttonsHolder);\n }\n}\n", "import { PromptProps } from \"../scene\";\nimport { EventHandlerCollection } from \"../utils/EventHandlerCollection\";\nimport { Modal } from \"./Modal\";\n\nexport class PromptModal extends Modal {\n private promptContentsElement: HTMLDivElement;\n private promptMessageElement: HTMLDivElement;\n private promptInputElement: HTMLInputElement;\n private buttonsHolder: HTMLDivElement;\n private cancelButton: HTMLButtonElement;\n private okButton: HTMLButtonElement;\n private callback: (result: string | null) => void;\n private eventHandlerCollection = new EventHandlerCollection();\n\n constructor(promptProps: PromptProps, callback: (result: string | null) => void) {\n super();\n\n this.callback = callback;\n\n this.titleElement.textContent = \"Prompt\";\n\n this.promptContentsElement = document.createElement(\"div\");\n this.promptMessageElement = document.createElement(\"div\");\n this.promptMessageElement.textContent = promptProps.message || \"Enter a value\";\n this.promptMessageElement.style.marginBottom = \"8px\";\n this.promptContentsElement.appendChild(this.promptMessageElement);\n\n this.promptInputElement = document.createElement(\"input\");\n this.promptInputElement.type = \"text\";\n this.promptInputElement.style.width = \"80vw\";\n this.promptInputElement.style.maxWidth = \"300px\";\n this.promptInputElement.setAttribute(\"data-test-id\", \"prompt-input\");\n this.promptInputElement.setAttribute(\"placeholder\", promptProps.placeholder || \"\");\n this.promptInputElement.setAttribute(\"value\", promptProps.prefill || \"\");\n this.promptInputElement.addEventListener(\"change\", () => {\n this.checkValue();\n });\n this.promptInputElement.addEventListener(\"keyup\", (event) => {\n if (event.key === \"Enter\") {\n if (this.promptInputElement.value.length > 0) {\n this.dispose();\n this.callback(this.promptInputElement.value);\n }\n }\n this.checkValue();\n });\n this.eventHandlerCollection.add(document, \"keydown\", (e: KeyboardEvent) => {\n if (e.code === \"Escape\") {\n this.dispose();\n this.callback(null);\n }\n this.checkValue();\n });\n this.promptContentsElement.appendChild(this.promptInputElement);\n this.contentsElement.appendChild(this.promptContentsElement);\n\n this.buttonsHolder = document.createElement(\"div\");\n this.buttonsHolder.style.display = \"flex\";\n this.buttonsHolder.style.justifyContent = \"space-between\";\n this.buttonsHolder.style.marginTop = \"8px\";\n\n this.cancelButton = document.createElement(\"button\");\n this.cancelButton.setAttribute(\"data-test-id\", \"prompt-cancel-button\");\n this.cancelButton.style.cursor = \"pointer\";\n this.cancelButton.textContent = \"Cancel\";\n this.cancelButton.addEventListener(\"click\", () => {\n this.dispose();\n this.callback(null);\n });\n this.buttonsHolder.appendChild(this.cancelButton);\n\n this.okButton = document.createElement(\"button\");\n this.okButton.setAttribute(\"data-test-id\", \"prompt-ok-button\");\n this.okButton.style.cursor = \"pointer\";\n this.okButton.textContent = \"OK\";\n this.okButton.addEventListener(\"click\", () => {\n this.dispose();\n this.callback(this.promptInputElement.value);\n });\n this.buttonsHolder.appendChild(this.okButton);\n this.contentsElement.appendChild(this.buttonsHolder);\n }\n\n public focus() {\n this.promptInputElement.focus();\n this.promptInputElement.setSelectionRange(\n this.promptInputElement.value.length,\n this.promptInputElement.value.length,\n );\n this.checkValue();\n }\n\n dispose() {\n this.eventHandlerCollection.clear();\n super.dispose();\n }\n\n private checkValue() {\n if (this.promptInputElement.value.length > 0) {\n this.okButton.disabled = false;\n } else {\n this.okButton.disabled = true;\n }\n }\n}\n", "import { LinkProps, PromptProps } from \"../scene\";\nimport { ConfirmModal } from \"./ConfirmModal\";\nimport { Modal } from \"./Modal\";\nimport { PromptModal } from \"./PromptModal\";\n\ntype PromptState = {\n prompt?: PromptModal;\n promptProps: PromptProps;\n resolve: (result: string | null) => void;\n};\n\ntype LinkState = {\n href: string;\n target?: string;\n popup: boolean;\n windowCallback: (openedWindow: Window | null) => void;\n};\n\nexport class PromptManager {\n private promptHolderElement: HTMLDivElement;\n\n private queue = new Array();\n private currentPrompt: PromptState | LinkState | null = null;\n private currentModal: Modal | null = null;\n\n private constructor(private container: HTMLElement) {\n const holderElement = document.createElement(\"div\");\n holderElement.setAttribute(\"data-test-id\", \"prompt-holder\");\n holderElement.style.zIndex = \"100\";\n holderElement.style.position = \"absolute\";\n holderElement.style.top = \"50%\";\n holderElement.style.left = \"50%\";\n holderElement.style.transform = \"translate(-50%, -50%)\";\n this.promptHolderElement = holderElement;\n this.container.appendChild(this.promptHolderElement);\n }\n\n static init(container: HTMLElement): PromptManager {\n return new PromptManager(container);\n }\n\n public dispose() {\n this.promptHolderElement.remove();\n }\n\n private showPrompt(promptState: PromptState | LinkState) {\n this.currentPrompt = promptState;\n if (\"href\" in promptState) {\n const confirmModal = new ConfirmModal(\n \"Confirm Navigation\",\n `Open ${promptState.href}?`,\n (result: boolean) => {\n this.currentPrompt = null;\n this.currentModal = null;\n if (result) {\n let features;\n if (promptState.popup) {\n const popupWidth = 500;\n const popupHeight = 500;\n\n const screenLeft =\n window.screenLeft !== undefined ? window.screenLeft : window.screenX;\n const screenTop = window.screenTop !== undefined ? window.screenTop : window.screenY;\n const windowWidth = window.innerWidth\n ? window.innerWidth\n : document.documentElement.clientWidth\n ? document.documentElement.clientWidth\n : screen.width;\n const windowHeight = window.innerHeight\n ? window.innerHeight\n : document.documentElement.clientHeight\n ? document.documentElement.clientHeight\n : screen.height;\n\n const left = (windowWidth - popupWidth) / 2 + screenLeft;\n const top = (windowHeight - popupHeight) / 2 + screenTop;\n features = `toolbar=no,menubar=no,width=${popupWidth},height=${popupHeight},left=${left},top=${top}`;\n }\n\n const openedWindow = window.open(\n promptState.href,\n promptState.target ?? \"_blank\",\n features,\n );\n promptState.windowCallback(openedWindow);\n }\n this.showNextPromptIfAny();\n },\n );\n this.currentModal = confirmModal;\n this.promptHolderElement.appendChild(confirmModal.element);\n } else {\n const promptModal = new PromptModal(promptState.promptProps, (result: string | null) => {\n this.currentPrompt = null;\n this.currentModal = null;\n promptState.resolve(result);\n this.showNextPromptIfAny();\n });\n this.currentModal = promptModal;\n this.promptHolderElement.appendChild(promptModal.element);\n promptModal.focus();\n }\n }\n\n public prompt(\n promptProps: PromptProps,\n abortSignal: AbortSignal,\n callback: (message: string | null) => void,\n ) {\n abortSignal.addEventListener(\"abort\", () => {\n if (this.currentPrompt === promptState) {\n // The current prompt is the one we are aborting\n this.currentPrompt = null;\n this.currentModal?.dispose();\n this.showNextPromptIfAny();\n } else {\n // Remove the link from the queue\n this.queue = this.queue.filter((item) => item !== promptState);\n }\n });\n const promptState: PromptState = {\n promptProps,\n resolve: callback,\n };\n if (this.currentPrompt !== null) {\n this.queue.push(promptState);\n return;\n }\n this.showPrompt(promptState);\n }\n\n public link(\n linkProps: LinkProps,\n abortSignal: AbortSignal,\n windowCallback: (openedWindow: Window | null) => void,\n ) {\n abortSignal.addEventListener(\"abort\", () => {\n if (this.currentPrompt === linkState) {\n // The current prompt is the one we are aborting\n this.currentPrompt = null;\n this.currentModal?.dispose();\n this.currentModal = null;\n this.showNextPromptIfAny();\n } else {\n // Remove the link from the queue\n this.queue = this.queue.filter((item) => item !== linkState);\n }\n });\n const linkState: LinkState = {\n href: linkProps.href,\n target: linkProps.target,\n popup: linkProps.popup ?? false,\n windowCallback,\n };\n if (this.currentPrompt !== null) {\n this.queue.push(linkState);\n return;\n }\n this.showPrompt(linkState);\n }\n\n private showNextPromptIfAny() {\n const nextPrompt = this.queue.shift();\n if (nextPrompt !== undefined) {\n this.showPrompt(nextPrompt);\n }\n }\n}\n", "import { DebugHelper } from \"../debug-helper\";\nimport {\n Audio,\n ChatProbe,\n Cube,\n Cylinder,\n Frame,\n Image,\n Interaction,\n Label,\n Light,\n Link,\n MElement,\n Model,\n Plane,\n PositionProbe,\n Prompt,\n RemoteDocument,\n Sphere,\n TransformableElement,\n Video,\n} from \"../elements\";\nimport {\n AudioGraphics,\n ChatProbeGraphics,\n CubeGraphics,\n CylinderGraphics,\n DebugHelperGraphics,\n FrameGraphics,\n ImageGraphics,\n InteractionGraphics,\n LabelGraphics,\n LightGraphics,\n LinkGraphics,\n MElementGraphics,\n ModelGraphics,\n PlaneGraphics,\n PositionProbeGraphics,\n PromptGraphics,\n RemoteDocumentGraphics,\n SphereGraphics,\n TransformableGraphics,\n VideoGraphics,\n} from \"../graphics\";\nimport { GraphicsAdapter, StandaloneGraphicsAdapter } from \"../graphics\";\nimport { InteractionManager } from \"../interaction-ui\";\nimport { LoadingProgressManager } from \"../loading\";\nimport { PromptManager } from \"../prompt-ui\";\n\nexport interface MMLGraphicsInterface {\n MMLDebugHelperGraphicsInterface(debugHelper: DebugHelper): DebugHelperGraphics;\n RemoteDocumentGraphicsInterface: (element: RemoteDocument) => RemoteDocumentGraphics;\n MElementGraphicsInterface: (element: MElement) => MElementGraphics;\n MMLTransformableGraphicsInterface: (element: TransformableElement) => TransformableGraphics;\n MMLImageGraphicsInterface: (\n element: Image,\n updateMeshCallback: () => void,\n ) => ImageGraphics;\n MMLVideoGraphicsInterface: (\n element: Video,\n updateMeshCallback: () => void,\n ) => VideoGraphics;\n MMLAudioGraphicsInterface: (element: Audio) => AudioGraphics;\n MMLCubeGraphicsInterface: (element: Cube) => CubeGraphics;\n MMLLabelGraphicsInterface: (element: Label) => LabelGraphics;\n MMLLinkGraphicsInterface: (element: Link) => LinkGraphics;\n MMLPlaneGraphicsInterface: (element: Plane) => PlaneGraphics;\n MMLPromptGraphicsInterface: (element: Prompt) => PromptGraphics;\n MMLInteractionGraphicsInterface: (element: Interaction) => InteractionGraphics;\n MMLChatProbeGraphicsInterface: (element: ChatProbe) => ChatProbeGraphics;\n MMLPositionProbeGraphicsInterface: (element: PositionProbe) => PositionProbeGraphics;\n MMLSphereGraphicsInterface: (element: Sphere) => SphereGraphics;\n MMLCylinderGraphicsInterface: (element: Cylinder) => CylinderGraphics;\n MMLLightGraphicsInterface: (element: Light) => LightGraphics;\n MMLFrameGraphicsInterface: (element: Frame) => FrameGraphics;\n MMLModelGraphicsInterface: (\n element: Model,\n updateMeshCallback: () => void,\n ) => ModelGraphics;\n}\n\nexport type PositionAndRotation = {\n position: { x: number; y: number; z: number };\n // rotation in degrees\n rotation: { x: number; y: number; z: number };\n};\n\nexport type InteractionListener = {\n addInteraction(interaction: Interaction): void;\n updateInteraction(interaction: Interaction): void;\n removeInteraction(interaction: Interaction): void;\n};\n\nexport type ChatProbeListener = {\n addChatProbe(chatProbe: ChatProbe): void;\n updateChatProbe(chatProbe: ChatProbe): void;\n removeChatProbe(chatProbe: ChatProbe): void;\n};\n\nexport type PromptProps = {\n message?: string;\n placeholder?: string;\n prefill?: string;\n};\n\nexport type LinkProps = {\n href: string;\n target?: string;\n popup?: boolean;\n};\n\n/**\n * The IMMLScene interface is the public interface for attaching content (E.g.\n * an MML Document) into the underlyingScene, but it can be implemented by\n * classes other than MMLScene.\n */\nexport type IMMLScene = {\n getGraphicsAdapter: () => G;\n hasGraphicsAdapter: () => boolean;\n\n getRootContainer: () => ReturnType;\n\n addCollider?: (collider: unknown, element: MElement) => void;\n updateCollider?: (collider: unknown, element: MElement) => void;\n removeCollider?: (collider: unknown, element: MElement) => void;\n\n addInteraction?: (interaction: Interaction) => void;\n updateInteraction?: (interaction: Interaction) => void;\n removeInteraction?: (interaction: Interaction) => void;\n\n addChatProbe?: (chatProbe: ChatProbe) => void;\n updateChatProbe?: (chatProbe: ChatProbe) => void;\n removeChatProbe?: (chatProbe: ChatProbe) => void;\n\n getUserPositionAndRotation(): PositionAndRotation;\n\n prompt: (\n promptProps: PromptProps,\n abortSignal: AbortSignal,\n callback: (message: string | null) => void,\n ) => void;\n\n link: (\n linkProps: LinkProps,\n abortSignal: AbortSignal,\n windowCallback: (openedWindow: Window | null) => void,\n ) => void;\n\n getLoadingProgressManager?: () => LoadingProgressManager | null;\n};\n\n/**\n * The MMLScene class creates a HTML Element that renders a scene and includes the various manager instances\n * for handling clicks, interaction events, and controls.\n *\n * It is the default implementation of the IMMLScene interface and presents a fly camera with drag controls.\n */\nexport class MMLScene> implements IMMLScene {\n private colliders = new Set();\n\n private interactions = new Set>();\n private interactionListeners = new Set>();\n\n private chatProbes = new Set>();\n private chatProbeListeners = new Set>();\n\n private resizeListener: () => void;\n private promptManager: PromptManager;\n private interactionManager: InteractionManager;\n private resizeObserver: ResizeObserver;\n private loadingProgressManager: LoadingProgressManager;\n\n private graphicsAdapter: G | null = null;\n\n constructor(public element: HTMLElement) {\n this.loadingProgressManager = new LoadingProgressManager();\n }\n\n public init(graphicsAdapter: G) {\n this.graphicsAdapter = graphicsAdapter;\n this.graphicsAdapter.start();\n\n this.resizeObserver = new ResizeObserver(() => {\n this.fitContainer();\n });\n this.resizeObserver.observe(this.element);\n\n this.promptManager = PromptManager.init(this.element);\n const { interactionManager, interactionListener } = InteractionManager.init(\n this.element,\n this.graphicsAdapter.interactionShouldShowDistance.bind(this.graphicsAdapter),\n );\n this.interactionManager = interactionManager;\n this.addInteractionListener(interactionListener);\n\n this.resizeListener = () => {\n this.fitContainer();\n };\n window.addEventListener(\"resize\", this.resizeListener, false);\n\n this.fitContainer();\n }\n\n public hasGraphicsAdapter(): boolean {\n return this.graphicsAdapter !== null;\n }\n\n public getGraphicsAdapter(): G {\n if (!this.graphicsAdapter) {\n throw new Error(\"MMLScene not initialized with a graphics adapter. Call init() first.\");\n }\n return this.graphicsAdapter;\n }\n\n public getRootContainer(): G[\"containerType\"] {\n if (!this.graphicsAdapter) {\n throw new Error(\"MMLScene not initialized with a graphics adapter\");\n }\n return this.graphicsAdapter.getRootContainer();\n }\n\n public getUserPositionAndRotation(): PositionAndRotation {\n if (!this.graphicsAdapter) {\n throw new Error(\"MMLScene not initialized with a graphics adapter\");\n }\n return this.graphicsAdapter.getUserPositionAndRotation();\n }\n\n public fitContainer() {\n if (!this.graphicsAdapter) {\n throw new Error(\"MMLScene not initialized with a graphics adapter\");\n }\n const width = this.element.clientWidth;\n const height = this.element.clientHeight;\n this.graphicsAdapter.resize(width, height);\n }\n\n public dispose() {\n window.removeEventListener(\"resize\", this.resizeListener);\n this.resizeObserver.disconnect();\n this.promptManager.dispose();\n this.interactionManager.dispose();\n }\n\n public prompt(\n promptProps: PromptProps,\n abortSignal: AbortSignal,\n callback: (message: string | null) => void,\n ) {\n if (!this) {\n console.error(\"MMLScene not initialized\");\n return;\n }\n this.promptManager.prompt(promptProps, abortSignal, callback);\n }\n\n public link(\n linkProps: LinkProps,\n abortSignal: AbortSignal,\n windowCallback: (openedWindow: Window | null) => void,\n ) {\n this.promptManager.link(linkProps, abortSignal, windowCallback);\n }\n\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n public addCollider(collider: unknown, element: MElement): void {\n this.colliders.add(collider);\n }\n\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n public updateCollider(collider: unknown): void {\n // no-op\n }\n\n public removeCollider(collider: unknown): void {\n this.colliders.delete(collider);\n }\n\n public addInteraction(interaction: Interaction): void {\n this.interactions.add(interaction);\n for (const listener of this.interactionListeners) {\n listener.addInteraction(interaction);\n }\n }\n\n public updateInteraction(interaction: Interaction): void {\n for (const listener of this.interactionListeners) {\n listener.updateInteraction(interaction);\n }\n }\n\n public removeInteraction(interaction: Interaction): void {\n this.interactions.delete(interaction);\n for (const listener of this.interactionListeners) {\n listener.removeInteraction(interaction);\n }\n }\n\n public getInteractions(): Set> {\n return this.interactions;\n }\n\n public addInteractionListener(\n listener: InteractionListener,\n addExistingInteractions = true,\n ): void {\n this.interactionListeners.add(listener);\n if (addExistingInteractions) {\n for (const interaction of this.interactions) {\n listener.addInteraction(interaction);\n }\n }\n }\n\n public removeInteractionListener(listener: InteractionListener): void {\n this.interactionListeners.delete(listener);\n }\n\n public addChatProbe(chatProbe: ChatProbe): void {\n this.chatProbes.add(chatProbe);\n for (const listener of this.chatProbeListeners) {\n listener.addChatProbe(chatProbe);\n }\n }\n\n public updateChatProbe(chatProbe: ChatProbe): void {\n for (const listener of this.chatProbeListeners) {\n listener.updateChatProbe(chatProbe);\n }\n }\n\n public removeChatProbe(chatProbe: ChatProbe): void {\n this.chatProbes.delete(chatProbe);\n for (const listener of this.chatProbeListeners) {\n listener.removeChatProbe(chatProbe);\n }\n }\n\n public getLoadingProgressManager(): LoadingProgressManager {\n return this.loadingProgressManager;\n }\n\n public getChatProbes(): Set> {\n return this.chatProbes;\n }\n\n public addChatProbeListener(listener: ChatProbeListener, addExistingChatProbes = true): void {\n this.chatProbeListeners.add(listener);\n if (addExistingChatProbes) {\n for (const chatProbe of this.chatProbes) {\n listener.addChatProbe(chatProbe);\n }\n }\n }\n\n public removeChatProbeListener(listener: ChatProbeListener): void {\n this.chatProbeListeners.delete(listener);\n }\n}\n", "import { StandaloneGraphicsAdapter } from \"../graphics\";\nimport { LoadingProgressBar } from \"../loading\";\nimport { MMLScene } from \"./MMLScene\";\n\nexport class FullScreenMMLScene extends MMLScene {\n private loadingProgressBar: LoadingProgressBar;\n\n constructor() {\n super(document.createElement(\"div\"));\n this.element = document.createElement(\"div\");\n this.element.style.width = \"100%\";\n this.element.style.height = \"100%\";\n this.element.style.position = \"relative\";\n\n const loadingProgressManager = this.getLoadingProgressManager();\n this.loadingProgressBar = new LoadingProgressBar(loadingProgressManager);\n this.element.append(this.loadingProgressBar.element);\n\n this.configureWindowStyling();\n }\n\n private configureWindowStyling() {\n document.documentElement.style.width = \"100%\";\n document.documentElement.style.height = \"100%\";\n document.documentElement.style.overflow = \"hidden\";\n document.documentElement.style.overscrollBehaviorX = \"contain\";\n document.documentElement.style.margin = \"0\";\n\n const onload = () => {\n document.body.style.margin = \"0\";\n document.body.style.height = \"100%\";\n };\n if (document.body) {\n onload();\n } else {\n window.addEventListener(\"load\", () => {\n onload();\n });\n }\n }\n\n dispose() {\n super.dispose();\n this.element.remove();\n }\n}\n", "import { MElement, registerCustomElementsToWindow } from \"./elements\";\nimport { setGlobalDocumentTimeManager, setGlobalMMLScene } from \"./global\";\nimport { StandaloneGraphicsAdapter } from \"./graphics\";\nimport { FullScreenMMLScene } from \"./scene\";\nimport { MMLDocumentTimeManager } from \"./time\";\n\nexport function configureWindowForMML(\n window: Window,\n getGraphicsAdapter: (element: HTMLElement) => Promise,\n) {\n const fullScreenMMLScene = new FullScreenMMLScene();\n const mmlDocumentTimeManager = new MMLDocumentTimeManager();\n setGlobalMMLScene(fullScreenMMLScene);\n setGlobalDocumentTimeManager(mmlDocumentTimeManager);\n registerCustomElementsToWindow(window);\n const onload = async () => {\n window.document.body.append(fullScreenMMLScene.element);\n\n const graphicsAdapter = await getGraphicsAdapter(fullScreenMMLScene.element);\n\n fullScreenMMLScene.init(graphicsAdapter);\n\n // Traverse all the elements in the document and add them to the scene\n const traverse = (element: Element | Document) => {\n for (const i in element.children) {\n const child = element.children[i];\n if (child instanceof MElement) {\n child.connectedCallback?.();\n }\n traverse(child);\n }\n };\n traverse(window.document);\n\n fullScreenMMLScene.getLoadingProgressManager().setInitialLoad(true);\n\n const tick = () => {\n mmlDocumentTimeManager.tick();\n window.requestAnimationFrame(tick);\n };\n tick();\n };\n\n if (window.document.body) {\n onload();\n } else {\n // Wait for the window to load\n window.addEventListener(\"load\", onload);\n }\n}\n", "import { Audio, MAudioProps } from \"../elements\";\nimport { GraphicsAdapter } from \"./GraphicsAdapter\";\n\nexport abstract class AudioGraphics {\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n constructor(element: Audio) {}\n\n abstract enable(): void;\n\n abstract disable(): void;\n\n abstract setSrc(src: string | null, mAudioProps: MAudioProps): void;\n\n abstract setStartTime(startTime: number, mAudioProps: MAudioProps): void;\n\n abstract setPauseTime(pauseTime: number | null, mAudioProps: MAudioProps): void;\n\n abstract setLoopDuration(loopDuration: number | null, mAudioProps: MAudioProps): void;\n\n abstract setLoop(loop: boolean, mAudioProps: MAudioProps): void;\n\n abstract setEnabled(enabled: boolean, mAudioProps: MAudioProps): void;\n\n abstract setVolume(volume: number, mAudioProps: MAudioProps): void;\n\n abstract setConeAngle(coneAngle: number | null, mAudioProps: MAudioProps): void;\n\n abstract setConeFalloffAngle(coneFalloffAngle: number | null, mAudioProps: MAudioProps): void;\n\n abstract setDebug(debug: boolean, mAudioProps: MAudioProps): void;\n\n abstract syncAudioTime(): void;\n\n abstract dispose(): void;\n}\n", "import { ChatProbe, MChatProbeProps } from \"../elements\";\nimport { GraphicsAdapter } from \"./GraphicsAdapter\";\n\nexport abstract class ChatProbeGraphics {\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n constructor(element: ChatProbe) {}\n\n abstract enable(): void;\n\n abstract disable(): void;\n\n abstract setRange(range: number, mChatProbeProps: MChatProbeProps): void;\n\n abstract setDebug(debug: boolean, mChatProbeProps: MChatProbeProps): void;\n\n abstract dispose(): void;\n}\n", "import { MMLColor } from \"../color\";\nimport { Cube, MCubeProps } from \"../elements\";\nimport { GraphicsAdapter } from \"./GraphicsAdapter\";\n\nexport abstract class CubeGraphics {\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n constructor(element: Cube) {}\n\n abstract enable(): void;\n\n abstract disable(): void;\n\n abstract getCollisionElement(): G[\"collisionType\"];\n\n abstract setWidth(width: number, mCubeProps: MCubeProps): void;\n\n abstract setHeight(height: number, mCubeProps: MCubeProps): void;\n\n abstract setDepth(depth: number, mCubeProps: MCubeProps): void;\n\n abstract setColor(color: MMLColor, mCubeProps: MCubeProps): void;\n\n abstract setOpacity(opacity: number, mCubeProps: MCubeProps): void;\n\n abstract setCastShadows(castShadows: boolean, mCubeProps: MCubeProps): void;\n\n abstract dispose(): void;\n}\n", "import { MMLColor } from \"../color\";\nimport { Cylinder, MCylinderProps } from \"../elements\";\nimport { GraphicsAdapter } from \"./GraphicsAdapter\";\n\nexport abstract class CylinderGraphics {\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n constructor(element: Cylinder) {}\n\n abstract enable(): void;\n\n abstract disable(): void;\n\n abstract getCollisionElement(): G[\"collisionType\"];\n\n abstract setRadius(radius: number, mCylinderProps: MCylinderProps): void;\n\n abstract setHeight(height: number, mCylinderProps: MCylinderProps): void;\n\n abstract setColor(color: MMLColor, mCylinderProps: MCylinderProps): void;\n\n abstract setOpacity(opacity: number, mCylinderProps: MCylinderProps): void;\n\n abstract setCastShadows(castShadows: boolean, mCylinderProps: MCylinderProps): void;\n\n abstract dispose(): void;\n}\n", "import { DebugHelper } from \"../debug-helper/DebugHelper\";\nimport { GraphicsAdapter } from \"./GraphicsAdapter\";\n\nexport abstract class DebugHelperGraphics {\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n constructor(debugHelper: DebugHelper) {}\n\n abstract dispose(): void;\n}\n", "import { Frame, MFrameProps } from \"../elements\";\nimport { GraphicsAdapter } from \"./GraphicsAdapter\";\n\nexport abstract class FrameGraphics {\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n constructor(element: Frame) {}\n\n abstract enable(): void;\n\n abstract disable(): void;\n\n abstract setSrc(src: string | null, mFrameProps: MFrameProps): void;\n\n abstract setDebug(debug: boolean, mFrameProps: MFrameProps): void;\n\n abstract setLoadRange(loadRange: number | null, mFrameProps: MFrameProps): void;\n\n abstract setUnloadRange(unloadRange: number, mFrameProps: MFrameProps): void;\n\n abstract setMinX(minX: number | null, mFrameProps: MFrameProps): void;\n\n abstract setMaxX(maxX: number | null, mFrameProps: MFrameProps): void;\n\n abstract setMinY(minY: number | null, mFrameProps: MFrameProps): void;\n\n abstract setMaxY(maxY: number | null, mFrameProps: MFrameProps): void;\n\n abstract setMinZ(minZ: number | null, mFrameProps: MFrameProps): void;\n\n abstract setMaxZ(maxZ: number | null, mFrameProps: MFrameProps): void;\n\n abstract dispose(): void;\n}\n", "import { Image, MImageProps } from \"../elements\";\nimport { GraphicsAdapter } from \"./GraphicsAdapter\";\n\nexport abstract class ImageGraphics {\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n constructor(element: Image, updateMeshCallback: () => void) {}\n\n abstract enable(): void;\n\n abstract disable(): void;\n\n abstract getCollisionElement(): G[\"collisionType\"];\n\n abstract getWidthAndHeight(): { width: number; height: number };\n\n abstract setSrc(src: string | null, mImageProps: MImageProps): void;\n\n abstract setWidth(width: number | null, mImageProps: MImageProps): void;\n\n abstract setHeight(height: number | null, mImageProps: MImageProps): void;\n\n abstract setOpacity(opacity: number, mImageProps: MImageProps): void;\n\n abstract setEmissive(opacity: number, mImageProps: MImageProps): void;\n\n abstract setCastShadows(castShadows: boolean, mImageProps: MImageProps): void;\n\n abstract dispose(): void;\n}\n", "import { Interaction, MInteractionProps } from \"../elements\";\nimport { GraphicsAdapter } from \"./GraphicsAdapter\";\n\nexport abstract class InteractionGraphics {\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n constructor(element: Interaction) {}\n\n abstract enable(): void;\n\n abstract disable(): void;\n\n abstract setRange(range: number, mInteractionProps: MInteractionProps): void;\n\n abstract setInFocus(inFocus: boolean, mInteractionProps: MInteractionProps): void;\n\n abstract setLineOfSight(lineOfSight: boolean, mInteractionProps: MInteractionProps): void;\n\n abstract setPriority(priority: number, mInteractionProps: MInteractionProps): void;\n\n abstract setPrompt(prompt: string | null, mInteractionProps: MInteractionProps): void;\n\n abstract setDebug(debug: boolean, mInteractionProps: MInteractionProps): void;\n\n abstract dispose(): void;\n}\n", "import { MMLColor } from \"../color\";\nimport { Label, MLabelAlignment, MLabelProps } from \"../elements\";\nimport { GraphicsAdapter } from \"./GraphicsAdapter\";\n\nexport abstract class LabelGraphics {\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n constructor(element: Label) {}\n\n abstract enable(): void;\n\n abstract disable(): void;\n\n abstract getCollisionElement(): G[\"collisionType\"];\n\n abstract setContent(content: string, mLabelProps: MLabelProps): void;\n\n abstract setAlignment(alignment: MLabelAlignment, mLabelProps: MLabelProps): void;\n\n abstract setWidth(width: number, mLabelProps: MLabelProps): void;\n\n abstract setHeight(height: number, mLabelProps: MLabelProps): void;\n\n abstract setFontSize(fontSize: number, mLabelProps: MLabelProps): void;\n\n abstract setPadding(padding: number, mLabelProps: MLabelProps): void;\n\n abstract setColor(color: MMLColor, mLabelProps: MLabelProps): void;\n\n abstract setFontColor(fontColor: MMLColor, mLabelProps: MLabelProps): void;\n\n abstract setCastShadows(castShadows: boolean, mLabelProps: MLabelProps): void;\n\n abstract setEmissive(emissive: number, mLabelProps: MLabelProps): void;\n\n abstract dispose(): void;\n}\n", "import { MMLColor } from \"../color\";\nimport { Light, LightTypes, MLightProps } from \"../elements\";\nimport { GraphicsAdapter } from \"./GraphicsAdapter\";\n\nexport abstract class LightGraphics {\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n constructor(element: Light) {}\n\n abstract enable(): void;\n\n abstract disable(): void;\n\n abstract setEnabled(enabled: boolean, mLightProps: MLightProps): void;\n\n abstract setDebug(debug: boolean, mLightProps: MLightProps): void;\n\n abstract setCastShadows(castShadows: boolean, mLightProps: MLightProps): void;\n\n abstract setAngle(angle: number, mLightProps: MLightProps): void;\n\n abstract setIntensity(intensity: number, mLightProps: MLightProps): void;\n\n abstract setDistance(distance: number, mLightProps: MLightProps): void;\n\n abstract setType(type: LightTypes, mLightProps: MLightProps): void;\n\n abstract setColor(color: MMLColor, mLightProps: MLightProps): void;\n\n abstract dispose(): void;\n}\n", "import { Link, MLinkProps } from \"../elements\";\nimport { GraphicsAdapter } from \"./GraphicsAdapter\";\n\nexport abstract class LinkGraphics {\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n constructor(element: Link) {}\n\n abstract enable(): void;\n\n abstract disable(): void;\n\n abstract setHref(href: string | null, props: MLinkProps): void;\n\n abstract setTarget(target: string | null, props: MLinkProps): void;\n\n abstract dispose(): void;\n}\n", "import { MElement } from \"../elements\";\nimport { GraphicsAdapter } from \"./GraphicsAdapter\";\n\nexport abstract class MElementGraphics {\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n constructor(element: MElement) {}\n\n abstract getContainer(): G[\"containerType\"];\n\n abstract dispose(): void;\n}\n", "import { MModelProps, Model } from \"../elements\";\nimport { IVect3 } from \"../math/Vect3\";\nimport { GraphicsAdapter } from \"./GraphicsAdapter\";\n\nexport abstract class ModelGraphics {\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n constructor(element: Model, updateMeshCallback: () => void) {}\n\n abstract enable(): void;\n\n abstract disable(): void;\n\n abstract getBoundingBox(): {\n centerOffset: IVect3;\n size: IVect3;\n } | null;\n\n abstract transformed(): void;\n\n abstract getCollisionElement(): G[\"collisionType\"];\n\n abstract hasLoadedModel(): boolean;\n\n abstract hasLoadedAnimation(): boolean;\n\n abstract setSrc(src: string | null, mModelProps: MModelProps): void;\n\n abstract setAnim(anim: string | null, mModelProps: MModelProps): void;\n\n abstract setAnimEnabled(animEnabled: boolean | null, mModelProps: MModelProps): void;\n\n abstract setAnimLoop(animLoop: boolean | null, mModelProps: MModelProps): void;\n\n abstract setAnimStartTime(animStartTime: number | null, mModelProps: MModelProps): void;\n\n abstract setAnimPauseTime(animPauseTime: number | null, mModelProps: MModelProps): void;\n\n abstract setDebug(debug: boolean, mModelProps: MModelProps): void;\n\n abstract setCastShadows(castShadows: boolean, mModelProps: MModelProps): void;\n\n abstract dispose(): void;\n}\n", "import { MMLColor } from \"../color\";\nimport { MPlaneProps, Plane } from \"../elements\";\nimport { GraphicsAdapter } from \"./GraphicsAdapter\";\n\nexport abstract class PlaneGraphics {\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n constructor(element: Plane) {}\n\n abstract enable(): void;\n\n abstract disable(): void;\n\n abstract getCollisionElement(): G[\"collisionType\"];\n\n abstract setWidth(width: number, mPlaneProps: MPlaneProps): void;\n\n abstract setHeight(height: number, mPlaneProps: MPlaneProps): void;\n\n abstract setColor(color: MMLColor, mPlaneProps: MPlaneProps): void;\n\n abstract setOpacity(opacity: number, mPlaneProps: MPlaneProps): void;\n\n abstract setCastShadows(castShadows: boolean, mPlaneProps: MPlaneProps): void;\n\n abstract dispose(): void;\n}\n", "import { MPositionProbeProps, PositionProbe } from \"../elements\";\nimport { GraphicsAdapter } from \"./GraphicsAdapter\";\n\nexport abstract class PositionProbeGraphics {\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n constructor(element: PositionProbe) {}\n\n abstract enable(): void;\n\n abstract disable(): void;\n\n abstract setRange(range: number, mPositionProbeProps: MPositionProbeProps): void;\n\n abstract setDebug(debug: boolean, mPositionProbeProps: MPositionProbeProps): void;\n\n abstract dispose(): void;\n}\n", "import { MPromptProps, Prompt } from \"../elements\";\nimport { GraphicsAdapter } from \"./GraphicsAdapter\";\n\nexport abstract class PromptGraphics {\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n constructor(element: Prompt) {}\n\n abstract enable(): void;\n\n abstract disable(): void;\n\n abstract setMessage(message: string | undefined, mPromptProps: MPromptProps): void;\n\n abstract setPlaceholder(placeholder: string | undefined, mPromptProps: MPromptProps): void;\n\n abstract setPrefill(prefill: string | undefined, mPromptProps: MPromptProps): void;\n\n abstract setDebug(debug: boolean, mPromptProps: MPromptProps): void;\n\n abstract dispose(): void;\n}\n", "import { RemoteDocument } from \"../elements\";\nimport { GraphicsAdapter } from \"./GraphicsAdapter\";\n\nexport abstract class RemoteDocumentGraphics {\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n constructor(element: RemoteDocument) {}\n\n abstract showError(showError: boolean): void;\n\n abstract dispose(): void;\n}\n", "import { MMLColor } from \"../color\";\nimport { MSphereProps, Sphere } from \"../elements\";\nimport { GraphicsAdapter } from \"./GraphicsAdapter\";\n\nexport abstract class SphereGraphics {\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n constructor(element: Sphere) {}\n\n abstract enable(): void;\n\n abstract disable(): void;\n\n abstract getCollisionElement(): G[\"collisionType\"];\n\n abstract setRadius(width: number, mSphereProps: MSphereProps): void;\n\n abstract setColor(color: MMLColor, mSphereProps: MSphereProps): void;\n\n abstract setOpacity(opacity: number, mSphereProps: MSphereProps): void;\n\n abstract setCastShadows(castShadows: boolean, mSphereProps: MSphereProps): void;\n\n abstract dispose(): void;\n}\n", "import { TransformableElement, TransformableElementProps } from \"../elements\";\nimport { Matr4 } from \"../math/Matr4\";\nimport { GraphicsAdapter } from \"./GraphicsAdapter\";\n\nexport abstract class TransformableGraphics {\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n constructor(element: TransformableElement) {}\n\n abstract getWorldMatrix(): Matr4;\n\n abstract setSocket(\n socket: string | null,\n transformableElementProps: TransformableElementProps,\n ): void;\n\n abstract setX(x: number, transformableElementProps: TransformableElementProps): void;\n\n abstract setY(y: number, transformableElementProps: TransformableElementProps): void;\n\n abstract setZ(z: number, transformableElementProps: TransformableElementProps): void;\n\n abstract setRotationX(\n rotationX: number,\n transformableElementProps: TransformableElementProps,\n ): void;\n\n abstract setRotationY(\n rotationY: number,\n transformableElementProps: TransformableElementProps,\n ): void;\n\n abstract setRotationZ(\n rotationZ: number,\n transformableElementProps: TransformableElementProps,\n ): void;\n\n abstract setScaleX(scaleX: number, transformableElementProps: TransformableElementProps): void;\n\n abstract setScaleY(scaleY: number, transformableElementProps: TransformableElementProps): void;\n\n abstract setScaleZ(scaleZ: number, transformableElementProps: TransformableElementProps): void;\n\n abstract setVisible(visible: boolean, transformableElementProps: TransformableElementProps): void;\n\n abstract dispose(): void;\n}\n", "import { MVideoProps, Video } from \"../elements\";\nimport { GraphicsAdapter } from \"./GraphicsAdapter\";\n\nexport abstract class VideoGraphics {\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n constructor(element: Video, updateMeshCallback: () => void) {}\n\n abstract enable(): void;\n\n abstract disable(): void;\n\n abstract getCollisionElement(): G[\"collisionType\"];\n\n abstract getWidthAndHeight(): { width: number; height: number };\n\n abstract setSrc(src: string | null, mVideoProps: MVideoProps): void;\n\n abstract setWidth(width: number | null, mVideoProps: MVideoProps): void;\n\n abstract setHeight(height: number | null, mVideoProps: MVideoProps): void;\n\n abstract setEnabled(enabled: boolean, mVideoProps: MVideoProps): void;\n\n abstract setCastShadows(castShadows: boolean, mVideoProps: MVideoProps): void;\n\n abstract setLoop(loop: boolean, mVideoProps: MVideoProps): void;\n\n abstract setVolume(volume: number, mVideoProps: MVideoProps): void;\n\n abstract setEmissive(emissive: number, mVideoProps: MVideoProps): void;\n\n abstract setStartTime(startTime: number, mVideoProps: MVideoProps): void;\n\n abstract setPauseTime(pauseTime: number | null, mVideoProps: MVideoProps): void;\n\n abstract syncVideoTime(): void;\n\n abstract dispose(): void;\n}\n", "export type IframeWrapperResult = {\n iframeWrapper: IframeWrapper;\n iframeWindow: Window;\n iframeDocument: Document;\n iframeBody: HTMLElement;\n};\n\n/**\n * The IframeWrapper class creates an iframe that can be used to load a document and then be disposed of. This is useful\n * for running a full NetworkedDOM document in an iframe and then disposing of it when it is no longer needed which will\n * clear up the + + diff --git a/pull/212/v1/index.js b/pull/212/v1/index.js new file mode 100644 index 00000000..b5d4868c --- /dev/null +++ b/pull/212/v1/index.js @@ -0,0 +1,781 @@ +import { + FullScreenMMLScene, + IframeWrapper, + MMLNetworkSource, + NetworkedDOMWebsocketStatus, + NetworkedDOMWebsocketStatusToString, + StandaloneTagDebugAdapter, + StatusUI, + allFields, + allGroups, + parseBoolAttribute, + registerCustomElementsToWindow, + rendererField, + setDebugGlobals, + urlField +} from "./chunk-OGDCF6KN.js"; + +// src/ui/setUrlParam.ts +function setUrlParam(name, value) { + const params = new URLSearchParams(window.location.search); + if (value === "" || value === null) { + params.delete(name); + } else { + params.set(name, value); + } + window.history.replaceState({}, "", `${window.location.pathname}?${params}`); + window.dispatchEvent(new PopStateEvent("popstate")); +} + +// src/ui/shared-styles.module.css +var shared_styles_default = { + "button": "shared-styles-module__button_Y_AOrq__0190", + "header": "shared-styles-module__header_Y_AOrq__0190" +}; + +// src/ui/UIElement.ts +var UIElement = class { + constructor() { + this.element = document.createElement("div"); + } + dispose() { + } +}; + +// src/ui/UIField.module.css +var UIField_default = { + "label": "UIField-module__label_lh-KDa__0190", + "labelFocused": "UIField-module__label-focused_lh-KDa__0190", + "selectInput": "UIField-module__select-input_lh-KDa__0190", + "submitButton": "UIField-module__submit-button_lh-KDa__0190", + "textInput": "UIField-module__text-input_lh-KDa__0190", + "uiField": "UIField-module__ui-field_lh-KDa__0190" +}; + +// src/ui/UIField.ts +var UIField = class extends UIElement { + constructor(fieldDefinition, group) { + super(); + this.fieldDefinition = fieldDefinition; + this.group = group; + this.element.className = UIField_default.uiField; + this.label = document.createElement("label"); + this.label.className = UIField_default.label; + this.label.textContent = fieldDefinition.label; + this.element.append(this.label); + if (fieldDefinition.options) { + const selectElement = document.createElement("select"); + this.selectElement = selectElement; + this.selectElement.className = UIField_default.selectInput; + const unsetOption = document.createElement("option"); + unsetOption.textContent = "Unset (default: " + fieldDefinition.defaultValue + ")"; + unsetOption.value = ""; + this.selectElement.append(unsetOption); + this.element.append(this.selectElement); + for (const option of fieldDefinition.options) { + const optionElement = document.createElement("option"); + optionElement.textContent = option; + this.selectElement.append(optionElement); + } + if (fieldDefinition.requireSubmission) { + this.submitButton = document.createElement("button"); + this.submitButton.classList.add(shared_styles_default.button, UIField_default.submitButton); + this.submitButton.textContent = "Submit"; + this.submitButton.addEventListener("click", () => { + this.onChange(selectElement.value); + }); + this.element.append(this.submitButton); + } else { + this.selectElement.addEventListener("change", () => { + this.onChange(selectElement.value); + }); + } + } else { + const input = document.createElement("input"); + this.input = input; + this.input.className = UIField_default.textInput; + this.input.placeholder = `Default: ${fieldDefinition.defaultValue.toString()}`; + this.input.addEventListener("focus", () => { + this.label.classList.add(UIField_default.labelFocused); + }); + this.input.addEventListener("blur", () => { + this.label.classList.remove(UIField_default.labelFocused); + }); + this.input.addEventListener("keydown", (event) => { + if (event.key === "Enter") { + this.onChange(input.value); + } + }); + if (fieldDefinition.type === "number") { + this.input.step = "0.01"; + this.input.type = "number"; + } else if (fieldDefinition.type === "color") { + this.input.type = "text"; + } else { + this.input.type = "text"; + } + this.element.append(this.input); + if (fieldDefinition.requireSubmission) { + this.submitButton = document.createElement("button"); + this.submitButton.classList.add(shared_styles_default.button, UIField_default.submitButton); + this.submitButton.textContent = "Submit"; + this.submitButton.addEventListener("click", () => { + if (this.input) { + this.onChange(this.input.value); + } else if (this.selectElement) { + this.onChange(this.selectElement.value); + } + }); + this.element.append(this.submitButton); + } else { + if (this.input) { + const input2 = this.input; + this.input.addEventListener("input", () => { + this.onChange(input2.value); + }); + } else if (this.selectElement) { + const selectElement = this.selectElement; + this.selectElement.addEventListener("change", () => { + this.onChange(selectElement.value); + }); + } + } + } + const params = new URLSearchParams(window.location.search); + const value = params.get(fieldDefinition.name); + if (value) { + this.setValue(value); + } + } + setValue(value) { + if (this.selectElement) { + this.selectElement.value = value; + } else if (this.input) { + this.input.value = value; + } + } + onChange(value) { + setUrlParam(this.fieldDefinition.name, value); + } +}; + +// src/ui/UIGroup.module.css +var UIGroup_default = { + "uiGroup": "UIGroup-module__ui-group_WUqfdq__0190" +}; + +// src/ui/UIGroup.ts +var UIGroup = class extends UIElement { + constructor(groupDefinition) { + super(); + this.groupDefinition = groupDefinition; + this.fields = new Array(); + this.element.className = UIGroup_default.uiGroup; + this.header = document.createElement("div"); + this.header.className = shared_styles_default.header; + this.header.textContent = groupDefinition.label; + this.element.append(this.header); + this.contents = document.createElement("div"); + this.contents.className = UIGroup_default.contents; + this.element.append(this.contents); + } + addField(uiField) { + if (this.fields.includes(uiField)) { + return; + } + this.fields.push(uiField); + this.fields.sort( + (a, b) => allFields.indexOf(a.fieldDefinition) - allFields.indexOf(b.fieldDefinition) + ); + const index = this.fields.indexOf(uiField); + if (index === this.fields.length - 1) { + this.contents.append(uiField.element); + } else { + const nextGroup = this.fields[index + 1]; + this.contents.insertBefore(uiField.element, nextGroup.element); + } + } + removeField(uiField) { + this.fields = this.fields.filter((f) => f !== uiField); + this.contents.removeChild(uiField.element); + } + dispose() { + for (const element of this.fields) { + element.dispose(); + } + this.fields = []; + } + isEmpty() { + return this.fields.length === 0; + } +}; + +// src/FormIteration.ts +var FormIteration = class { + constructor(queryParamState, viewerUI, previousFormIteration) { + this.queryParamState = queryParamState; + this.viewerUI = viewerUI; + this.unmatchedFields = /* @__PURE__ */ new Map(); + this.fields = /* @__PURE__ */ new Map(); + this.groups = /* @__PURE__ */ new Map(); + if (previousFormIteration) { + this.unmatchedFields = new Map(previousFormIteration.fields); + this.fields = new Map(previousFormIteration.fields); + } + } + getFieldValue(fieldDefinition) { + const unmatchedField = this.unmatchedFields.get(fieldDefinition); + if (unmatchedField) { + const uiGroup = unmatchedField.group; + this.groups.set(uiGroup.groupDefinition, uiGroup); + this.unmatchedFields.delete(fieldDefinition); + } + let field = this.fields.get(fieldDefinition); + if (!field) { + const groupDefinition = fieldDefinition.groupDefinition; + let uiGroup = this.groups.get(groupDefinition); + if (!uiGroup) { + uiGroup = new UIGroup(groupDefinition); + this.groups.set(groupDefinition, uiGroup); + this.viewerUI.addGroup(uiGroup); + } + field = new UIField(fieldDefinition, uiGroup); + uiGroup.addField(field); + this.fields.set(fieldDefinition, field); + } + const readValue = this.queryParamState.read(fieldDefinition.name); + if (readValue !== null) { + field.setValue(readValue); + return readValue; + } + return fieldDefinition.defaultValue.toString(); + } + clearUnmatchedFields() { + for (const field of this.unmatchedFields.values()) { + const group = field.group; + group.removeField(field); + field.dispose(); + if (group.isEmpty()) { + group.dispose(); + this.viewerUI.removeGroup(group); + this.groups.delete(group.groupDefinition); + } + this.fields.delete(field.fieldDefinition); + } + this.unmatchedFields.clear(); + } + completed() { + this.clearUnmatchedFields(); + this.viewerUI.showUnusedParams(Array.from(this.queryParamState.getUnusedParams())); + } +}; + +// src/PlayCanvasMode.ts +var PlayCanvasMode = class { + constructor(windowTarget, targetForWrappers, mmlSource, formIteration) { + this.windowTarget = windowTarget; + this.targetForWrappers = targetForWrappers; + this.mmlSource = mmlSource; + this.formIteration = formIteration; + this.disposed = false; + this.internalMode = null; + this.type = "playcanvas"; + this.init(); + } + async init() { + this.internalMode = await (async () => { + const { PlayCanvasModeInternal } = await import("./PlayCanvasModeInternal-6JRQ32LR.js"); + return new PlayCanvasModeInternal( + this.windowTarget, + this.targetForWrappers, + this.mmlSource, + this.formIteration + ); + })(); + if (this.disposed) { + this.dispose(); + return; + } + } + dispose() { + this.disposed = true; + if (this.internalMode) { + this.internalMode.dispose(); + } + } + update(formIteration) { + this.formIteration = formIteration; + if (!this.internalMode) { + return; + } + this.internalMode.update(formIteration); + } +}; + +// src/QueryParamState.ts +var QueryParamState = class _QueryParamState { + constructor(arg = /* @__PURE__ */ new Map()) { + this.params = /* @__PURE__ */ new Map(); + this.usedParams = /* @__PURE__ */ new Set(); + if (typeof arg === "string") { + this.params = new Map(new URLSearchParams(arg)); + } else { + this.params = new Map(arg); + } + } + cloneWithAdditionalParams(params) { + const newParams = new Map(this.params); + params.forEach((value, key) => { + newParams.set(key, value); + }); + return new _QueryParamState(newParams); + } + read(key) { + this.usedParams.add(key); + return this.params.get(key) ?? null; + } + getUnusedParams() { + const unusedParams = new Set(this.params.keys()); + this.usedParams.forEach((key) => { + unusedParams.delete(key); + }); + return unusedParams; + } + toString() { + const searchParams = new URLSearchParams(); + this.params.forEach((value, key) => { + searchParams.set(key, value); + }); + return searchParams.toString(); + } +}; + +// src/TagsMode.ts +var TagsMode = class { + constructor(windowTarget, targetForWrappers, mmlSourceDefinition, formIteration) { + this.windowTarget = windowTarget; + this.targetForWrappers = targetForWrappers; + this.mmlSourceDefinition = mmlSourceDefinition; + this.formIteration = formIteration; + this.disposed = false; + this.loadedState = null; + this.type = "tags"; + this.init(); + } + async init() { + const fullScreenMMLScene = new FullScreenMMLScene(); + document.body.append(fullScreenMMLScene.element); + const graphicsAdapter = await StandaloneTagDebugAdapter.create(fullScreenMMLScene.element); + if (this.disposed) { + graphicsAdapter.dispose(); + return; + } + fullScreenMMLScene.init(graphicsAdapter); + const statusUI = new StatusUI(); + const mmlNetworkSource = MMLNetworkSource.create({ + mmlScene: fullScreenMMLScene, + statusUpdated: (status) => { + if (status === NetworkedDOMWebsocketStatus.Connected) { + statusUI.setNoStatus(); + } else { + statusUI.setStatus(NetworkedDOMWebsocketStatusToString(status)); + } + }, + url: this.mmlSourceDefinition.url, + windowTarget: this.windowTarget, + targetForWrappers: this.targetForWrappers + }); + setDebugGlobals({ + mmlScene: fullScreenMMLScene, + remoteDocumentWrapper: mmlNetworkSource.remoteDocumentWrapper + }); + this.loadedState = { + mmlNetworkSource, + graphicsAdapter, + fullScreenMMLScene, + statusUI + }; + this.update(this.formIteration); + } + dispose() { + this.disposed = true; + if (this.loadedState) { + this.loadedState.mmlNetworkSource.dispose(); + this.loadedState.graphicsAdapter.dispose(); + this.loadedState.fullScreenMMLScene.dispose(); + this.loadedState.statusUI.dispose(); + this.loadedState = null; + } + } + update(formIteration) { + formIteration.completed(); + } +}; + +// src/ThreeJSMode.ts +var ThreeJSMode = class { + constructor(windowTarget, targetForWrappers, mmlSource, formIteration) { + this.windowTarget = windowTarget; + this.targetForWrappers = targetForWrappers; + this.mmlSource = mmlSource; + this.formIteration = formIteration; + this.disposed = false; + this.internalMode = null; + this.type = "threejs"; + this.init(); + } + async init() { + this.internalMode = await (async () => { + const { ThreeJSModeInternal } = await import("./ThreeJSModeInternal-OES4PZ5X.js"); + return new ThreeJSModeInternal( + this.windowTarget, + this.targetForWrappers, + this.mmlSource, + this.formIteration + ); + })(); + if (this.disposed) { + this.dispose(); + return; + } + } + dispose() { + this.disposed = true; + if (this.internalMode) { + this.internalMode.dispose(); + } + } + update(formIteration) { + this.formIteration = formIteration; + if (!this.internalMode) { + return; + } + this.internalMode.update(formIteration); + } +}; + +// ../../branding/src/svg/logotype/mml-logotype-white.svg +var mml_logotype_white_default = "./mml-logotype-white-YIZ3ZTFD.svg"; + +// src/ui/github-mark-white.svg +var github_mark_white_default = "./github-mark-white-DC6LPEI2.svg"; + +// src/ui/HideUISection.module.css +var HideUISection_default = { + "hidden": "HideUISection-module__hidden_ygtI5G__0190", + "hideUiSection": "HideUISection-module__hide-ui-section_ygtI5G__0190", + "hideUiSectionContents": "HideUISection-module__hide-ui-section-contents_ygtI5G__0190" +}; + +// src/ui/tooltip.module.css +var tooltip_default = { + "tooltip": "tooltip-module__tooltip_qonKzG__0190", + "tooltipInitiator": "tooltip-module__tooltip-initiator_qonKzG__0190", + "tooltipItem": "tooltip-module__tooltip-item_qonKzG__0190" +}; + +// src/ui/HideUISection.ts +var HideUISection = class { + constructor() { + this.element = document.createElement("div"); + this.element.className = HideUISection_default.hideUiSection; + this.hideUiHeader = document.createElement("div"); + this.hideUiHeader.textContent = "Hide UI"; + this.hideUiHeader.className = shared_styles_default.header; + this.element.append(this.hideUiHeader); + this.hideUiSectionContents = document.createElement("div"); + this.hideUiSectionContents.className = HideUISection_default.hideUiSectionContents; + this.element.append(this.hideUiSectionContents); + this.hideUiButton = document.createElement("button"); + this.hideUiButton.className = shared_styles_default.button; + this.hideUiButton.textContent = "Hide UI"; + this.hideUiButton.addEventListener("click", () => { + setUrlParam("noUI", "true"); + }); + this.hideUiSectionContents.append(this.hideUiButton); + const warningIcon = document.createElement("span"); + warningIcon.className = tooltip_default.tooltip; + warningIcon.setAttribute("data-direction", "left"); + const warningIconText = document.createElement("span"); + warningIconText.className = tooltip_default.tooltipInitiator; + warningIconText.textContent = "\u26A0\uFE0F"; + warningIcon.append(warningIconText); + const warningTooltip = document.createElement("span"); + warningTooltip.className = tooltip_default.tooltipItem; + warningTooltip.textContent = "If you hide the UI, it can only be shown again by removing the noUI parameter from the URL"; + warningIcon.append(warningTooltip); + this.hideUiSectionContents.append(warningIcon); + } + show() { + this.element.classList.remove(HideUISection_default.hidden); + } + hide() { + this.element.classList.add(HideUISection_default.hidden); + } +}; + +// src/ui/UnusedParameters.module.css +var UnusedParameters_default = { + "header": "UnusedParameters-module__header_BZL2TW__0190", + "hidden": "UnusedParameters-module__hidden_BZL2TW__0190", + "paramListItem": "UnusedParameters-module__param-list-item_BZL2TW__0190", + "unusedParameters": "UnusedParameters-module__unused-parameters_BZL2TW__0190" +}; + +// src/ui/UnusedParameters.ts +var UnusedParameters = class { + constructor() { + this.element = document.createElement("div"); + this.element.classList.add(UnusedParameters_default.unusedParameters, UnusedParameters_default.hidden); + this.header = document.createElement("div"); + this.header.textContent = "Unused Parameters"; + this.header.className = shared_styles_default.header; + this.element.append(this.header); + const warningIcon = document.createElement("span"); + warningIcon.className = tooltip_default.tooltip; + warningIcon.setAttribute("data-direction", "left"); + const warningIconText = document.createElement("span"); + warningIconText.className = tooltip_default.tooltipInitiator; + warningIconText.textContent = "\u26A0\uFE0F"; + warningIcon.append(warningIconText); + const warningTooltip = document.createElement("span"); + warningTooltip.className = tooltip_default.tooltipItem; + warningTooltip.textContent = "These parameters are not used by the viewer in the current mode"; + warningIcon.append(warningTooltip); + this.header.append(warningIcon); + this.paramsHolder = document.createElement("div"); + this.element.append(this.paramsHolder); + } + setParams(params) { + this.paramsHolder.innerHTML = ""; + if (params.length === 0) { + this.element.classList.add(UnusedParameters_default.hidden); + return; + } + this.element.classList.remove(UnusedParameters_default.hidden); + for (const param of params) { + const listItem = document.createElement("div"); + listItem.className = UnusedParameters_default.paramListItem; + const paramName = document.createElement("div"); + paramName.textContent = param; + listItem.append(paramName); + const removeButton = document.createElement("button"); + removeButton.className = shared_styles_default.button; + removeButton.textContent = "Remove"; + removeButton.addEventListener("click", () => { + setUrlParam(param, null); + }); + listItem.append(removeButton); + this.paramsHolder.append(listItem); + } + } +}; + +// src/ui/ViewerUI.module.css +var ViewerUI_default = { + "contents": "ViewerUI-module__contents_ne7v1W__0190", + "emptyState": "ViewerUI-module__empty-state_ne7v1W__0190", + "githubLink": "ViewerUI-module__github-link_ne7v1W__0190", + "githubLogo": "ViewerUI-module__github-logo_ne7v1W__0190", + "header": "ViewerUI-module__header_ne7v1W__0190", + "logo": "ViewerUI-module__logo_ne7v1W__0190", + "menuButton": "ViewerUI-module__menu-button_ne7v1W__0190", + "title": "ViewerUI-module__title_ne7v1W__0190", + "viewerUi": "ViewerUI-module__viewer-ui_ne7v1W__0190" +}; + +// src/ui/ViewerUI.ts +var ViewerUI = class { + constructor() { + this.groups = []; + this.element = document.createElement("div"); + this.element.className = ViewerUI_default.viewerUi; + this.element.addEventListener("wheel", (e) => e.stopPropagation()); + document.body.append(this.element); + this.contents = document.createElement("div"); + this.contents.className = ViewerUI_default.contents; + this.contents.style.display = "none"; + this.element.append(this.contents); + this.header = document.createElement("div"); + this.header.className = ViewerUI_default.header; + const title = document.createElement("div"); + title.className = ViewerUI_default.title; + const logoLink = document.createElement("a"); + logoLink.target = "_blank"; + logoLink.href = "https://mml.io"; + const logo = document.createElement("img"); + logo.classList.add(ViewerUI_default.logo); + logo.src = mml_logotype_white_default; + logo.alt = "MML"; + logoLink.append(logo); + title.append(logoLink); + const span = document.createElement("span"); + span.textContent = " Viewer (Alpha)"; + title.append(span); + this.header.append(title); + const githubLink = document.createElement("a"); + githubLink.target = "_blank"; + githubLink.className = ViewerUI_default.githubLink; + githubLink.href = "https://github.com/mml-io/mml/tree/main/packages/mml-viewer"; + const githubLogo = document.createElement("img"); + githubLogo.classList.add(ViewerUI_default.githubLogo); + githubLogo.src = github_mark_white_default; + githubLogo.alt = "GitHub"; + githubLink.append(githubLogo); + const githubSpan = document.createElement("span"); + githubSpan.textContent = "View Source"; + githubLink.append(githubSpan); + this.header.append(githubLink); + this.contents.append(this.header); + this.groupHolder = document.createElement("div"); + this.contents.append(this.groupHolder); + this.unusedParameters = new UnusedParameters(); + this.contents.append(this.unusedParameters.element); + this.hideUISection = new HideUISection(); + this.contents.append(this.hideUISection.element); + const menuIcon = document.createElement("button"); + menuIcon.classList.add(ViewerUI_default.menuButton, "no-copy"); + menuIcon.textContent = "\u2261"; + menuIcon.addEventListener("click", () => { + this.contents.style.display = this.contents.style.display === "none" ? "block" : "none"; + }); + this.element.append(menuIcon); + } + addGroup(uiGroup) { + this.groups.push(uiGroup); + this.groups.sort( + (a, b) => allGroups.indexOf(a.groupDefinition) - allGroups.indexOf(b.groupDefinition) + ); + const index = this.groups.indexOf(uiGroup); + if (index === this.groups.length - 1) { + this.groupHolder.append(uiGroup.element); + } else { + const nextGroup = this.groups[index + 1]; + this.groupHolder.insertBefore(uiGroup.element, nextGroup.element); + } + } + showUnusedParams(params) { + this.unusedParameters.setParams(params); + } + showAddressMenu() { + this.element.classList.add(ViewerUI_default.emptyState); + this.contents.style.display = "block"; + this.hideUISection.hide(); + } + hideAddressMenu() { + this.element.classList.remove(ViewerUI_default.emptyState); + this.hideUISection.show(); + } + removeGroup(group) { + this.groupHolder.removeChild(group.element); + this.groups = this.groups.filter((g) => g !== group); + } + show() { + this.element.style.display = "block"; + } + hide() { + this.element.style.display = "none"; + } +}; + +// src/StandaloneViewer.ts +var StandaloneViewer = class { + constructor(windowTarget, targetForWrappers) { + this.windowTarget = windowTarget; + this.targetForWrappers = targetForWrappers; + this.viewerUI = new ViewerUI(); + this.graphicsMode = null; + this.formIteration = null; + this.source = null; + window.addEventListener("popstate", () => { + this.handleParams(); + }); + this.handleParams(); + } + handleParams() { + const queryParamState = new QueryParamState(window.location.search); + const formIteration = new FormIteration(queryParamState, this.viewerUI, this.formIteration); + this.formIteration = formIteration; + const url = formIteration.getFieldValue(urlField); + const renderer = formIteration.getFieldValue(rendererField); + const noUI = parseBoolAttribute(queryParamState.read("noUI"), false); + if (noUI) { + this.viewerUI.hide(); + } else { + this.viewerUI.show(); + } + let source; + if (url) { + source = { url }; + if (this.source && this.source.url !== url) { + if (this.graphicsMode) { + this.graphicsMode.dispose(); + this.graphicsMode = null; + } + } + this.source = source; + } else { + if (this.graphicsMode) { + this.graphicsMode.dispose(); + this.graphicsMode = null; + } + this.viewerUI.showAddressMenu(); + this.formIteration.completed(); + return; + } + this.viewerUI.hideAddressMenu(); + if (this.graphicsMode && this.graphicsMode.type !== renderer) { + this.graphicsMode.dispose(); + this.graphicsMode = null; + } + if (!this.graphicsMode) { + if (renderer === "playcanvas") { + this.graphicsMode = new PlayCanvasMode( + this.windowTarget, + this.targetForWrappers, + source, + formIteration + ); + } else if (renderer === "threejs") { + this.graphicsMode = new ThreeJSMode( + this.windowTarget, + this.targetForWrappers, + source, + formIteration + ); + } else if (renderer === "tags") { + this.graphicsMode = new TagsMode( + this.windowTarget, + this.targetForWrappers, + source, + formIteration + ); + } + } else { + this.graphicsMode.update(formIteration); + } + } +}; + +// src/index.ts +window.addEventListener("load", () => { + (async () => { + const { iframeWindow, iframeBody } = await IframeWrapper.create(); + const windowTarget = iframeWindow; + const targetForWrappers = iframeBody; + registerCustomElementsToWindow(windowTarget); + const transparentPixel = document.createElement("div"); + transparentPixel.style.width = "1px"; + transparentPixel.style.height = "1px"; + transparentPixel.style.position = "absolute"; + transparentPixel.style.top = "1px"; + transparentPixel.style.left = "1px"; + transparentPixel.style.userSelect = "none"; + transparentPixel.style.pointerEvents = "none"; + transparentPixel.style.backdropFilter = "blur(1px)"; + document.body.append(transparentPixel); + const standaloneViewer = new StandaloneViewer(windowTarget, targetForWrappers); + window["mml-viewer"] = standaloneViewer; + })(); +}); +//# sourceMappingURL=index.js.map diff --git a/pull/212/v1/index.js.map b/pull/212/v1/index.js.map new file mode 100644 index 00000000..7024a67b --- /dev/null +++ b/pull/212/v1/index.js.map @@ -0,0 +1,7 @@ +{ + "version": 3, + "sources": ["../src/ui/setUrlParam.ts", "../src/ui/shared-styles.module.css", "../src/ui/UIElement.ts", "../src/ui/UIField.module.css", "../src/ui/UIField.ts", "../src/ui/UIGroup.module.css", "../src/ui/UIGroup.ts", "../src/FormIteration.ts", "../src/PlayCanvasMode.ts", "../src/QueryParamState.ts", "../src/TagsMode.ts", "../src/ThreeJSMode.ts", "../src/ui/HideUISection.module.css", "../src/ui/tooltip.module.css", "../src/ui/HideUISection.ts", "../src/ui/UnusedParameters.module.css", "../src/ui/UnusedParameters.ts", "../src/ui/ViewerUI.module.css", "../src/ui/ViewerUI.ts", "../src/StandaloneViewer.ts", "../src/index.ts"], + "sourcesContent": ["export function setUrlParam(name: string, value: string | null) {\n const params = new URLSearchParams(window.location.search);\n if (value === \"\" || value === null) {\n params.delete(name);\n } else {\n params.set(name, value);\n }\n window.history.replaceState({}, \"\", `${window.location.pathname}?${params}`);\n window.dispatchEvent(new PopStateEvent(\"popstate\"));\n}\n", "import \"esbuild-css-modules-plugin-ns-css:src/ui/shared-styles.module.css\";\n\nexport default {\n \"button\": \"shared-styles-module__button_Y_AOrq__0190\",\n \"header\": \"shared-styles-module__header_Y_AOrq__0190\"\n};\n ", "export class UIElement {\n public readonly element = document.createElement(\"div\");\n\n dispose() {}\n}\n", "import \"esbuild-css-modules-plugin-ns-css:src/ui/UIField.module.css\";\n\nexport default {\n \"label\": \"UIField-module__label_lh-KDa__0190\",\n \"labelFocused\": \"UIField-module__label-focused_lh-KDa__0190\",\n \"selectInput\": \"UIField-module__select-input_lh-KDa__0190\",\n \"submitButton\": \"UIField-module__submit-button_lh-KDa__0190\",\n \"textInput\": \"UIField-module__text-input_lh-KDa__0190\",\n \"uiField\": \"UIField-module__ui-field_lh-KDa__0190\"\n};\n ", "import { FieldDefinition } from \"./FieldDefinition\";\nimport { setUrlParam } from \"./setUrlParam\";\nimport sharedStyles from \"./shared-styles.module.css\";\nimport { UIElement } from \"./UIElement\";\nimport styles from \"./UIField.module.css\";\nimport { UIGroup } from \"./UIGroup\";\n\nexport class UIField extends UIElement {\n private label: HTMLLabelElement;\n private input?: HTMLInputElement;\n\n private selectElement?: HTMLSelectElement;\n\n private submitButton?: HTMLButtonElement;\n\n constructor(\n public fieldDefinition: FieldDefinition,\n public readonly group: UIGroup,\n ) {\n super();\n this.element.className = styles.uiField;\n\n this.label = document.createElement(\"label\");\n this.label.className = styles.label;\n this.label.textContent = fieldDefinition.label;\n this.element.append(this.label);\n\n if (fieldDefinition.options) {\n const selectElement = document.createElement(\"select\");\n this.selectElement = selectElement;\n this.selectElement.className = styles.selectInput;\n\n const unsetOption = document.createElement(\"option\");\n unsetOption.textContent = \"Unset (default: \" + fieldDefinition.defaultValue + \")\";\n unsetOption.value = \"\";\n this.selectElement.append(unsetOption);\n this.element.append(this.selectElement);\n\n for (const option of fieldDefinition.options) {\n const optionElement = document.createElement(\"option\");\n optionElement.textContent = option;\n this.selectElement.append(optionElement);\n }\n\n if (fieldDefinition.requireSubmission) {\n this.submitButton = document.createElement(\"button\");\n this.submitButton.classList.add(sharedStyles.button, styles.submitButton);\n this.submitButton.textContent = \"Submit\";\n this.submitButton.addEventListener(\"click\", () => {\n this.onChange(selectElement.value);\n });\n this.element.append(this.submitButton);\n } else {\n this.selectElement.addEventListener(\"change\", () => {\n this.onChange(selectElement.value);\n });\n }\n } else {\n const input = document.createElement(\"input\");\n this.input = input;\n this.input.className = styles.textInput;\n this.input.placeholder = `Default: ${fieldDefinition.defaultValue.toString()}`;\n this.input.addEventListener(\"focus\", () => {\n this.label.classList.add(styles.labelFocused);\n });\n this.input.addEventListener(\"blur\", () => {\n this.label.classList.remove(styles.labelFocused);\n });\n this.input.addEventListener(\"keydown\", (event) => {\n if (event.key === \"Enter\") {\n this.onChange(input.value);\n }\n });\n if (fieldDefinition.type === \"number\") {\n this.input.step = \"0.01\";\n this.input.type = \"number\";\n } else if (fieldDefinition.type === \"color\") {\n this.input.type = \"text\";\n } else {\n this.input.type = \"text\";\n }\n this.element.append(this.input);\n\n if (fieldDefinition.requireSubmission) {\n this.submitButton = document.createElement(\"button\");\n this.submitButton.classList.add(sharedStyles.button, styles.submitButton);\n this.submitButton.textContent = \"Submit\";\n this.submitButton.addEventListener(\"click\", () => {\n if (this.input) {\n this.onChange(this.input.value);\n } else if (this.selectElement) {\n this.onChange(this.selectElement.value);\n }\n });\n this.element.append(this.submitButton);\n } else {\n if (this.input) {\n const input = this.input;\n this.input.addEventListener(\"input\", () => {\n this.onChange(input.value);\n });\n } else if (this.selectElement) {\n const selectElement = this.selectElement;\n this.selectElement.addEventListener(\"change\", () => {\n this.onChange(selectElement.value);\n });\n }\n }\n }\n\n const params = new URLSearchParams(window.location.search);\n const value = params.get(fieldDefinition.name);\n if (value) {\n this.setValue(value);\n }\n }\n\n setValue(value: string) {\n if (this.selectElement) {\n this.selectElement.value = value;\n } else if (this.input) {\n this.input.value = value;\n }\n }\n\n onChange(value: string) {\n setUrlParam(this.fieldDefinition.name, value);\n }\n}\n", "import \"esbuild-css-modules-plugin-ns-css:src/ui/UIGroup.module.css\";\n\nexport default {\n \"uiGroup\": \"UIGroup-module__ui-group_WUqfdq__0190\"\n};\n ", "import { GroupDefinition } from \"./FieldDefinition\";\nimport { allFields } from \"./fields\";\nimport sharedStyles from \"./shared-styles.module.css\";\nimport { UIElement } from \"./UIElement\";\nimport { UIField } from \"./UIField\";\nimport styles from \"./UIGroup.module.css\";\n\nexport class UIGroup extends UIElement {\n private header: HTMLDivElement;\n private contents: HTMLDivElement;\n\n constructor(public readonly groupDefinition: GroupDefinition) {\n super();\n this.element.className = styles.uiGroup;\n this.header = document.createElement(\"div\");\n this.header.className = sharedStyles.header;\n this.header.textContent = groupDefinition.label;\n this.element.append(this.header);\n\n this.contents = document.createElement(\"div\");\n this.contents.className = styles.contents;\n this.element.append(this.contents);\n }\n\n private fields: Array = new Array();\n\n addField(uiField: UIField) {\n if (this.fields.includes(uiField)) {\n return;\n }\n\n this.fields.push(uiField);\n this.fields.sort(\n (a, b) => allFields.indexOf(a.fieldDefinition) - allFields.indexOf(b.fieldDefinition),\n );\n const index = this.fields.indexOf(uiField);\n if (index === this.fields.length - 1) {\n this.contents.append(uiField.element);\n } else {\n const nextGroup = this.fields[index + 1];\n this.contents.insertBefore(uiField.element, nextGroup.element);\n }\n }\n\n removeField(uiField: UIField) {\n this.fields = this.fields.filter((f) => f !== uiField);\n this.contents.removeChild(uiField.element);\n }\n\n dispose() {\n for (const element of this.fields) {\n element.dispose();\n }\n this.fields = [];\n }\n\n isEmpty() {\n return this.fields.length === 0;\n }\n}\n", "import { QueryParamState } from \"./QueryParamState\";\nimport { FieldDefinition, GroupDefinition } from \"./ui/FieldDefinition\";\nimport { UIField } from \"./ui/UIField\";\nimport { UIGroup } from \"./ui/UIGroup\";\nimport { ViewerUI } from \"./ui/ViewerUI\";\n\nexport class FormIteration {\n private unmatchedFields = new Map();\n\n private fields = new Map();\n private groups = new Map();\n\n constructor(\n private queryParamState: QueryParamState,\n private viewerUI: ViewerUI,\n previousFormIteration: FormIteration | null,\n ) {\n if (previousFormIteration) {\n this.unmatchedFields = new Map(previousFormIteration.fields);\n this.fields = new Map(previousFormIteration.fields);\n }\n }\n\n getFieldValue(fieldDefinition: FieldDefinition): string {\n const unmatchedField = this.unmatchedFields.get(fieldDefinition);\n if (unmatchedField) {\n const uiGroup = unmatchedField.group;\n this.groups.set(uiGroup.groupDefinition, uiGroup);\n this.unmatchedFields // We've used this existing field. Mark it as matched.\n .delete(fieldDefinition);\n }\n let field = this.fields.get(fieldDefinition);\n if (!field) {\n const groupDefinition = fieldDefinition.groupDefinition;\n let uiGroup = this.groups.get(groupDefinition);\n if (!uiGroup) {\n uiGroup = new UIGroup(groupDefinition);\n this.groups.set(groupDefinition, uiGroup);\n this.viewerUI.addGroup(uiGroup);\n }\n field = new UIField(fieldDefinition, uiGroup);\n uiGroup.addField(field);\n this.fields.set(fieldDefinition, field);\n }\n\n const readValue = this.queryParamState.read(fieldDefinition.name);\n if (readValue !== null) {\n field.setValue(readValue);\n return readValue;\n }\n return fieldDefinition.defaultValue.toString();\n }\n\n private clearUnmatchedFields() {\n for (const field of this.unmatchedFields.values()) {\n const group = field.group;\n group.removeField(field);\n field.dispose();\n if (group.isEmpty()) {\n group.dispose();\n this.viewerUI.removeGroup(group);\n this.groups.delete(group.groupDefinition);\n }\n this.fields.delete(field.fieldDefinition);\n }\n this.unmatchedFields.clear();\n }\n\n completed() {\n this.clearUnmatchedFields();\n this.viewerUI.showUnusedParams(Array.from(this.queryParamState.getUnusedParams()));\n }\n}\n", "import { FormIteration } from \"./FormIteration\";\nimport { GraphicsMode } from \"./GraphicsMode\";\nimport { MMLSourceDefinition } from \"./MMLSourceDefinition\";\n\nexport class PlayCanvasMode implements GraphicsMode {\n private disposed = false;\n private internalMode: GraphicsMode | null = null;\n\n public readonly type = \"playcanvas\";\n\n constructor(\n private windowTarget: Window,\n private targetForWrappers: HTMLElement,\n private mmlSource: MMLSourceDefinition,\n private formIteration: FormIteration,\n ) {\n this.init();\n }\n\n private async init() {\n this.internalMode = await (async () => {\n const { PlayCanvasModeInternal } = await import(\"./PlayCanvasModeInternal\");\n return new PlayCanvasModeInternal(\n this.windowTarget,\n this.targetForWrappers,\n this.mmlSource,\n this.formIteration,\n );\n })();\n if (this.disposed) {\n this.dispose();\n return;\n }\n }\n\n dispose() {\n this.disposed = true;\n if (this.internalMode) {\n this.internalMode.dispose();\n }\n }\n\n update(formIteration: FormIteration) {\n this.formIteration = formIteration;\n if (!this.internalMode) {\n return;\n }\n this.internalMode.update(formIteration);\n }\n}\n", "export class QueryParamState {\n private params: Map = new Map();\n private usedParams: Set = new Set();\n\n constructor(arg: string | Map = new Map()) {\n if (typeof arg === \"string\") {\n this.params = new Map(new URLSearchParams(arg));\n } else {\n this.params = new Map(arg);\n }\n }\n\n public cloneWithAdditionalParams(params: Map): QueryParamState {\n const newParams = new Map(this.params);\n params.forEach((value, key) => {\n newParams.set(key, value);\n });\n return new QueryParamState(newParams);\n }\n\n public read(key: string): string | null {\n this.usedParams.add(key);\n return this.params.get(key) ?? null;\n }\n\n public getUnusedParams(): Set {\n const unusedParams = new Set(this.params.keys());\n this.usedParams.forEach((key) => {\n unusedParams.delete(key);\n });\n return unusedParams;\n }\n\n public toString(): string {\n const searchParams = new URLSearchParams();\n this.params.forEach((value, key) => {\n searchParams.set(key, value);\n });\n return searchParams.toString();\n }\n}\n", "import {\n FullScreenMMLScene,\n MMLNetworkSource,\n NetworkedDOMWebsocketStatus,\n NetworkedDOMWebsocketStatusToString,\n StandaloneTagDebugAdapter,\n StatusUI,\n} from \"@mml-io/mml-web\";\n\nimport { FormIteration } from \"./FormIteration\";\nimport { GraphicsMode } from \"./GraphicsMode\";\nimport { MMLSourceDefinition } from \"./MMLSourceDefinition\";\nimport { setDebugGlobals } from \"./setDebugGlobals\";\n\nexport class TagsMode implements GraphicsMode {\n private disposed = false;\n\n private loadedState: {\n mmlNetworkSource: MMLNetworkSource;\n graphicsAdapter: StandaloneTagDebugAdapter;\n fullScreenMMLScene: FullScreenMMLScene;\n statusUI: StatusUI;\n } | null = null;\n\n constructor(\n private windowTarget: Window,\n private targetForWrappers: HTMLElement,\n private mmlSourceDefinition: MMLSourceDefinition,\n private formIteration: FormIteration,\n ) {\n this.init();\n }\n\n public readonly type = \"tags\";\n\n private async init() {\n const fullScreenMMLScene = new FullScreenMMLScene();\n document.body.append(fullScreenMMLScene.element);\n const graphicsAdapter = await StandaloneTagDebugAdapter.create(fullScreenMMLScene.element);\n if (this.disposed) {\n graphicsAdapter.dispose();\n return;\n }\n\n fullScreenMMLScene.init(graphicsAdapter);\n const statusUI = new StatusUI();\n const mmlNetworkSource = MMLNetworkSource.create({\n mmlScene: fullScreenMMLScene,\n statusUpdated: (status: NetworkedDOMWebsocketStatus) => {\n if (status === NetworkedDOMWebsocketStatus.Connected) {\n statusUI.setNoStatus();\n } else {\n statusUI.setStatus(NetworkedDOMWebsocketStatusToString(status));\n }\n },\n url: this.mmlSourceDefinition.url,\n windowTarget: this.windowTarget,\n targetForWrappers: this.targetForWrappers,\n });\n setDebugGlobals({\n mmlScene: fullScreenMMLScene,\n remoteDocumentWrapper: mmlNetworkSource.remoteDocumentWrapper,\n });\n this.loadedState = {\n mmlNetworkSource,\n graphicsAdapter,\n fullScreenMMLScene,\n statusUI,\n };\n this.update(this.formIteration);\n }\n\n public dispose() {\n this.disposed = true;\n if (this.loadedState) {\n this.loadedState.mmlNetworkSource.dispose();\n this.loadedState.graphicsAdapter.dispose();\n this.loadedState.fullScreenMMLScene.dispose();\n this.loadedState.statusUI.dispose();\n this.loadedState = null;\n }\n }\n\n update(formIteration: FormIteration) {\n formIteration.completed();\n }\n}\n", "import { FormIteration } from \"./FormIteration\";\nimport { GraphicsMode } from \"./GraphicsMode\";\nimport { MMLSourceDefinition } from \"./MMLSourceDefinition\";\n\nexport class ThreeJSMode implements GraphicsMode {\n private disposed = false;\n private internalMode: GraphicsMode | null = null;\n\n public readonly type = \"threejs\";\n\n constructor(\n private windowTarget: Window,\n private targetForWrappers: HTMLElement,\n private mmlSource: MMLSourceDefinition,\n private formIteration: FormIteration,\n ) {\n this.init();\n }\n\n private async init() {\n this.internalMode = await (async () => {\n const { ThreeJSModeInternal } = await import(\"./ThreeJSModeInternal\");\n return new ThreeJSModeInternal(\n this.windowTarget,\n this.targetForWrappers,\n this.mmlSource,\n this.formIteration,\n );\n })();\n if (this.disposed) {\n this.dispose();\n return;\n }\n }\n\n public dispose() {\n this.disposed = true;\n if (this.internalMode) {\n this.internalMode.dispose();\n }\n }\n\n update(formIteration: FormIteration) {\n this.formIteration = formIteration;\n if (!this.internalMode) {\n return;\n }\n this.internalMode.update(formIteration);\n }\n}\n", "import \"esbuild-css-modules-plugin-ns-css:src/ui/HideUISection.module.css\";\n\nexport default {\n \"hidden\": \"HideUISection-module__hidden_ygtI5G__0190\",\n \"hideUiSection\": \"HideUISection-module__hide-ui-section_ygtI5G__0190\",\n \"hideUiSectionContents\": \"HideUISection-module__hide-ui-section-contents_ygtI5G__0190\"\n};\n ", "import \"esbuild-css-modules-plugin-ns-css:src/ui/tooltip.module.css\";\n\nexport default {\n \"tooltip\": \"tooltip-module__tooltip_qonKzG__0190\",\n \"tooltipInitiator\": \"tooltip-module__tooltip-initiator_qonKzG__0190\",\n \"tooltipItem\": \"tooltip-module__tooltip-item_qonKzG__0190\"\n};\n ", "import styles from \"./HideUISection.module.css\";\nimport { setUrlParam } from \"./setUrlParam\";\nimport sharedStyles from \"./shared-styles.module.css\";\nimport tooltipStyles from \"./tooltip.module.css\";\n\nexport class HideUISection {\n public readonly element: HTMLDivElement;\n private hideUiButton: HTMLButtonElement;\n private hideUiHeader: HTMLDivElement;\n private hideUiSectionContents: HTMLDivElement;\n\n constructor() {\n this.element = document.createElement(\"div\");\n this.element.className = styles.hideUiSection;\n\n this.hideUiHeader = document.createElement(\"div\");\n this.hideUiHeader.textContent = \"Hide UI\";\n this.hideUiHeader.className = sharedStyles.header;\n this.element.append(this.hideUiHeader);\n\n this.hideUiSectionContents = document.createElement(\"div\");\n this.hideUiSectionContents.className = styles.hideUiSectionContents;\n this.element.append(this.hideUiSectionContents);\n\n this.hideUiButton = document.createElement(\"button\");\n this.hideUiButton.className = sharedStyles.button;\n this.hideUiButton.textContent = \"Hide UI\";\n this.hideUiButton.addEventListener(\"click\", () => {\n setUrlParam(\"noUI\", \"true\");\n });\n this.hideUiSectionContents.append(this.hideUiButton);\n\n const warningIcon = document.createElement(\"span\");\n warningIcon.className = tooltipStyles.tooltip;\n warningIcon.setAttribute(\"data-direction\", \"left\");\n const warningIconText = document.createElement(\"span\");\n warningIconText.className = tooltipStyles.tooltipInitiator;\n warningIconText.textContent = \"\u26A0\uFE0F\";\n warningIcon.append(warningIconText);\n const warningTooltip = document.createElement(\"span\");\n warningTooltip.className = tooltipStyles.tooltipItem;\n warningTooltip.textContent =\n \"If you hide the UI, it can only be shown again by removing the noUI parameter from the URL\";\n warningIcon.append(warningTooltip);\n this.hideUiSectionContents.append(warningIcon);\n }\n\n show() {\n this.element.classList.remove(styles.hidden);\n }\n\n hide() {\n this.element.classList.add(styles.hidden);\n }\n}\n", "import \"esbuild-css-modules-plugin-ns-css:src/ui/UnusedParameters.module.css\";\n\nexport default {\n \"header\": \"UnusedParameters-module__header_BZL2TW__0190\",\n \"hidden\": \"UnusedParameters-module__hidden_BZL2TW__0190\",\n \"paramListItem\": \"UnusedParameters-module__param-list-item_BZL2TW__0190\",\n \"unusedParameters\": \"UnusedParameters-module__unused-parameters_BZL2TW__0190\"\n};\n ", "import { setUrlParam } from \"./setUrlParam\";\nimport sharedStyles from \"./shared-styles.module.css\";\nimport tooltipStyles from \"./tooltip.module.css\";\nimport styles from \"./UnusedParameters.module.css\";\n\nexport class UnusedParameters {\n public readonly element: HTMLDivElement;\n private header: HTMLDivElement;\n private paramsHolder: HTMLDivElement;\n\n constructor() {\n this.element = document.createElement(\"div\");\n this.element.classList.add(styles.unusedParameters, styles.hidden);\n\n this.header = document.createElement(\"div\");\n this.header.textContent = \"Unused Parameters\";\n this.header.className = sharedStyles.header;\n this.element.append(this.header);\n\n const warningIcon = document.createElement(\"span\");\n warningIcon.className = tooltipStyles.tooltip;\n warningIcon.setAttribute(\"data-direction\", \"left\");\n const warningIconText = document.createElement(\"span\");\n warningIconText.className = tooltipStyles.tooltipInitiator;\n warningIconText.textContent = \"\u26A0\uFE0F\";\n warningIcon.append(warningIconText);\n const warningTooltip = document.createElement(\"span\");\n warningTooltip.className = tooltipStyles.tooltipItem;\n warningTooltip.textContent = \"These parameters are not used by the viewer in the current mode\";\n warningIcon.append(warningTooltip);\n this.header.append(warningIcon);\n\n this.paramsHolder = document.createElement(\"div\");\n this.element.append(this.paramsHolder);\n }\n\n setParams(params: string[]) {\n this.paramsHolder.innerHTML = \"\";\n if (params.length === 0) {\n this.element.classList.add(styles.hidden);\n return;\n }\n\n this.element.classList.remove(styles.hidden);\n\n for (const param of params) {\n const listItem = document.createElement(\"div\");\n listItem.className = styles.paramListItem;\n const paramName = document.createElement(\"div\");\n paramName.textContent = param;\n listItem.append(paramName);\n const removeButton = document.createElement(\"button\");\n removeButton.className = sharedStyles.button;\n removeButton.textContent = \"Remove\";\n removeButton.addEventListener(\"click\", () => {\n setUrlParam(param, null);\n });\n listItem.append(removeButton);\n this.paramsHolder.append(listItem);\n }\n }\n}\n", "import \"esbuild-css-modules-plugin-ns-css:src/ui/ViewerUI.module.css\";\n\nexport default {\n \"contents\": \"ViewerUI-module__contents_ne7v1W__0190\",\n \"emptyState\": \"ViewerUI-module__empty-state_ne7v1W__0190\",\n \"githubLink\": \"ViewerUI-module__github-link_ne7v1W__0190\",\n \"githubLogo\": \"ViewerUI-module__github-logo_ne7v1W__0190\",\n \"header\": \"ViewerUI-module__header_ne7v1W__0190\",\n \"logo\": \"ViewerUI-module__logo_ne7v1W__0190\",\n \"menuButton\": \"ViewerUI-module__menu-button_ne7v1W__0190\",\n \"title\": \"ViewerUI-module__title_ne7v1W__0190\",\n \"viewerUi\": \"ViewerUI-module__viewer-ui_ne7v1W__0190\"\n};\n ", "import MMLLogoSVG from \"../../../../branding/src/svg/logotype/mml-logotype-white.svg\";\nimport { allGroups } from \"./fields\";\nimport GitHubLogoSVG from \"./github-mark-white.svg\";\nimport { HideUISection } from \"./HideUISection\";\nimport { UIGroup } from \"./UIGroup\";\nimport { UnusedParameters } from \"./UnusedParameters\";\nimport styles from \"./ViewerUI.module.css\";\n\nexport class ViewerUI {\n private element: HTMLDivElement;\n private contents: HTMLDivElement;\n\n private header: HTMLDivElement;\n private groups: Array = [];\n private groupHolder: HTMLDivElement;\n\n private unusedParameters: UnusedParameters;\n private hideUISection: HideUISection;\n\n constructor() {\n this.element = document.createElement(\"div\");\n this.element.className = styles.viewerUi;\n this.element.addEventListener(\"wheel\", (e) => e.stopPropagation());\n document.body.append(this.element);\n\n this.contents = document.createElement(\"div\");\n this.contents.className = styles.contents;\n this.contents.style.display = \"none\";\n this.element.append(this.contents);\n\n this.header = document.createElement(\"div\");\n this.header.className = styles.header;\n\n const title = document.createElement(\"div\");\n title.className = styles.title;\n const logoLink = document.createElement(\"a\");\n logoLink.target = \"_blank\";\n logoLink.href = \"https://mml.io\";\n const logo = document.createElement(\"img\");\n logo.classList.add(styles.logo);\n logo.src = MMLLogoSVG;\n logo.alt = \"MML\";\n logoLink.append(logo);\n title.append(logoLink);\n const span = document.createElement(\"span\");\n span.textContent = \" Viewer (Alpha)\";\n title.append(span);\n this.header.append(title);\n\n const githubLink = document.createElement(\"a\");\n githubLink.target = \"_blank\";\n githubLink.className = styles.githubLink;\n githubLink.href = \"https://github.com/mml-io/mml/tree/main/packages/mml-viewer\";\n const githubLogo = document.createElement(\"img\");\n githubLogo.classList.add(styles.githubLogo);\n githubLogo.src = GitHubLogoSVG;\n githubLogo.alt = \"GitHub\";\n githubLink.append(githubLogo);\n const githubSpan = document.createElement(\"span\");\n githubSpan.textContent = \"View Source\";\n githubLink.append(githubSpan);\n this.header.append(githubLink);\n\n this.contents.append(this.header);\n\n this.groupHolder = document.createElement(\"div\");\n this.contents.append(this.groupHolder);\n\n this.unusedParameters = new UnusedParameters();\n this.contents.append(this.unusedParameters.element);\n\n this.hideUISection = new HideUISection();\n this.contents.append(this.hideUISection.element);\n\n const menuIcon = document.createElement(\"button\");\n menuIcon.classList.add(styles.menuButton, \"no-copy\");\n menuIcon.textContent = \"\u2261\";\n menuIcon.addEventListener(\"click\", () => {\n this.contents.style.display = this.contents.style.display === \"none\" ? \"block\" : \"none\";\n });\n this.element.append(menuIcon);\n }\n\n addGroup(uiGroup: UIGroup) {\n this.groups.push(uiGroup);\n this.groups.sort(\n (a, b) => allGroups.indexOf(a.groupDefinition) - allGroups.indexOf(b.groupDefinition),\n );\n const index = this.groups.indexOf(uiGroup);\n if (index === this.groups.length - 1) {\n this.groupHolder.append(uiGroup.element);\n } else {\n const nextGroup = this.groups[index + 1];\n this.groupHolder.insertBefore(uiGroup.element, nextGroup.element);\n }\n }\n\n showUnusedParams(params: string[]) {\n this.unusedParameters.setParams(params);\n }\n\n showAddressMenu() {\n this.element.classList.add(styles.emptyState);\n this.contents.style.display = \"block\";\n this.hideUISection.hide();\n }\n\n hideAddressMenu() {\n this.element.classList.remove(styles.emptyState);\n this.hideUISection.show();\n }\n\n removeGroup(group: UIGroup) {\n this.groupHolder.removeChild(group.element);\n this.groups = this.groups.filter((g) => g !== group);\n }\n\n show() {\n this.element.style.display = \"block\";\n }\n\n hide() {\n this.element.style.display = \"none\";\n }\n}\n", "import { parseBoolAttribute } from \"@mml-io/mml-web\";\n\nimport { FormIteration } from \"./FormIteration\";\nimport { GraphicsMode } from \"./GraphicsMode\";\nimport { MMLSourceDefinition } from \"./MMLSourceDefinition\";\nimport { PlayCanvasMode } from \"./PlayCanvasMode\";\nimport { QueryParamState } from \"./QueryParamState\";\nimport { TagsMode } from \"./TagsMode\";\nimport { ThreeJSMode } from \"./ThreeJSMode\";\nimport { rendererField, urlField } from \"./ui/fields\";\nimport { ViewerUI } from \"./ui/ViewerUI\";\n\nexport class StandaloneViewer {\n private viewerUI = new ViewerUI();\n private graphicsMode: GraphicsMode | null = null;\n private formIteration: FormIteration | null = null;\n private source: MMLSourceDefinition | null = null;\n\n constructor(\n private windowTarget: Window,\n private targetForWrappers: HTMLElement,\n ) {\n window.addEventListener(\"popstate\", () => {\n this.handleParams();\n });\n this.handleParams();\n }\n\n private handleParams() {\n const queryParamState = new QueryParamState(window.location.search);\n const formIteration = new FormIteration(queryParamState, this.viewerUI, this.formIteration);\n this.formIteration = formIteration;\n\n const url = formIteration.getFieldValue(urlField);\n const renderer = formIteration.getFieldValue(rendererField);\n const noUI = parseBoolAttribute(queryParamState.read(\"noUI\"), false);\n if (noUI) {\n this.viewerUI.hide();\n } else {\n this.viewerUI.show();\n }\n\n let source: MMLSourceDefinition;\n if (url) {\n source = { url };\n if (this.source && this.source.url !== url) {\n if (this.graphicsMode) {\n this.graphicsMode.dispose();\n this.graphicsMode = null;\n }\n }\n this.source = source;\n } else {\n if (this.graphicsMode) {\n this.graphicsMode.dispose();\n this.graphicsMode = null;\n }\n this.viewerUI.showAddressMenu();\n this.formIteration.completed();\n return;\n }\n this.viewerUI.hideAddressMenu();\n\n if (this.graphicsMode && this.graphicsMode.type !== renderer) {\n this.graphicsMode.dispose();\n this.graphicsMode = null;\n }\n if (!this.graphicsMode) {\n if (renderer === \"playcanvas\") {\n this.graphicsMode = new PlayCanvasMode(\n this.windowTarget,\n this.targetForWrappers,\n source,\n formIteration,\n );\n } else if (renderer === \"threejs\") {\n this.graphicsMode = new ThreeJSMode(\n this.windowTarget,\n this.targetForWrappers,\n source,\n formIteration,\n );\n } else if (renderer === \"tags\") {\n this.graphicsMode = new TagsMode(\n this.windowTarget,\n this.targetForWrappers,\n source,\n formIteration,\n );\n }\n } else {\n this.graphicsMode.update(formIteration);\n }\n }\n}\n", "import { IframeWrapper, registerCustomElementsToWindow } from \"@mml-io/mml-web\";\n\nimport { StandaloneViewer } from \"./StandaloneViewer\";\n\ndeclare global {\n interface Window {\n \"mml-viewer\": StandaloneViewer;\n }\n}\n\nwindow.addEventListener(\"load\", () => {\n (async () => {\n const { iframeWindow, iframeBody } = await IframeWrapper.create();\n const windowTarget = iframeWindow;\n const targetForWrappers = iframeBody;\n registerCustomElementsToWindow(windowTarget);\n\n /*\n Add a transparent pixel with a backdrop filter to force the background to\n be white in Chrome (and potentially other browsers). Without this the\n background is grey unless the menu UI is opened.\n */\n const transparentPixel = document.createElement(\"div\");\n transparentPixel.style.width = \"1px\";\n transparentPixel.style.height = \"1px\";\n transparentPixel.style.position = \"absolute\";\n transparentPixel.style.top = \"1px\";\n transparentPixel.style.left = \"1px\";\n transparentPixel.style.userSelect = \"none\";\n transparentPixel.style.pointerEvents = \"none\";\n transparentPixel.style.backdropFilter = \"blur(1px)\";\n document.body.append(transparentPixel);\n\n const standaloneViewer = new StandaloneViewer(windowTarget, targetForWrappers);\n window[\"mml-viewer\"] = standaloneViewer;\n })();\n});\n"], + "mappings": "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", + "names": ["input"] +} diff --git a/pull/212/v1/mml-logotype-white-YIZ3ZTFD.svg b/pull/212/v1/mml-logotype-white-YIZ3ZTFD.svg new file mode 100644 index 00000000..319d8ec3 --- /dev/null +++ b/pull/212/v1/mml-logotype-white-YIZ3ZTFD.svg @@ -0,0 +1,8 @@ + + + + + + + +